umc_h264_dec_mblevel_calc.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

        return ;
    }
    else
    {
        Block->block_num-=4;
        Block->mb_num = m_CurMBAddr;
        return;
    }
    return;
}
void H264VideoDecoder::GetTopLocationForCurrentMBChromaMBAFF(H264DecoderBlockLocation *Block)
{
    bool curmbfff = !pGetMBFieldDecodingFlag(m_cur_mb.GlobalMacroblockInfo);
    bool curmbtf  = !pGetMBBottomFlag(m_cur_mb.GlobalMacroblockInfo);
    //Ipp32s mb_width = m_pCurrentFrame->macroBlockSize().width;
    Ipp32s pair_offset = curmbtf? mb_width:-mb_width;
    Ipp32s MB_X;
    Ipp32s MB_N;
    //chroma
    if (CHROMA_BLOCK_IS_ON_TOP_EDGE(Block->block_num))
    {
        if (curmbfff && !curmbtf )
        {
            MB_N = m_CurMBAddr + pair_offset;
            Block->block_num+=2;
        }
        else
        {
            MB_X = m_cur_mb.CurrentMacroblockNeighbours.mb_B;
            if (MB_X>=0)
            {
                Ipp8u xfff=!GetMBFieldDecodingFlag(m_pCurrentFrame->m_mbinfo.mbs[MB_X]);
                if (!curmbfff && curmbtf && !xfff)
                {
                    MB_N=MB_X;
                    Block->block_num+=2;
                }
                else
                {
                    //if (!curmbff && curmbtf && xfff)
                    //    Block->block_num+=0;
                    //else
                    Block->block_num+=2;
                    MB_N=MB_X + mb_width;
                }
            }
            else
            {
                Block->mb_num = -1;
                return;
            }
        }
        Block->mb_num = MB_N;
        return;
    }
    else
    {
        Block->block_num-=2;
        Block->mb_num = m_CurMBAddr;
        return;
    }

    return;
}
void H264VideoDecoder::GetTopLeftLocationForCurrentMBLumaNonMBAFF(H264DecoderBlockLocation *Block)
{
    //luma
    if (BLOCK_IS_ON_LEFT_EDGE(Block->block_num) && BLOCK_IS_ON_TOP_EDGE(Block->block_num))
    {
        Block->block_num+=15;
        Block->mb_num = m_cur_mb.CurrentMacroblockNeighbours.mb_D;
    }
    else if (BLOCK_IS_ON_LEFT_EDGE(Block->block_num))
    {
        Block->block_num--;
        Block->mb_num = m_cur_mb.CurrentMacroblockNeighbours.mb_A;
    }
    else if ( BLOCK_IS_ON_TOP_EDGE(Block->block_num))
    {
        Block->block_num+=11;
        Block->mb_num = m_cur_mb.CurrentMacroblockNeighbours.mb_B;
    }
    else
    {
        Block->block_num-=5;
        Block->mb_num = m_CurMBAddr;
    }
    return;
}
void H264VideoDecoder::GetTopLeftLocationForCurrentMBLumaMBAFF(H264DecoderBlockLocation *Block)
{
    bool curmbfff = !pGetMBFieldDecodingFlag(m_cur_mb.GlobalMacroblockInfo);
    bool curmbtf  = !pGetMBBottomFlag(m_cur_mb.GlobalMacroblockInfo);
    Ipp32s MB_X;
    Ipp32s MB_N;
    //luma
    if (BLOCK_IS_ON_LEFT_EDGE(Block->block_num) && BLOCK_IS_ON_TOP_EDGE(Block->block_num))
    {
        if (curmbfff && !curmbtf )
        {
            MB_X = m_cur_mb.CurrentMacroblockNeighbours.mb_A;
            if (MB_X<0)
            {
                Block->mb_num = -1;
                return;
            }
            if (!GetMBFieldDecodingFlag(m_pCurrentFrame->m_mbinfo.mbs[MB_X]))
            {
                MB_N = MB_X;
                Block->block_num+=15;
            }
            else
            {
                MB_N = MB_X + mb_width;
                Block->block_num+=7;
            }
        }
        else
        {
            MB_X = m_cur_mb.CurrentMacroblockNeighbours.mb_D;
            if (MB_X>=0)
            {
                if (curmbfff==curmbtf)
                {
                    MB_N=MB_X + mb_width;
                }
                else
                {
                    if (!GetMBFieldDecodingFlag(m_pCurrentFrame->m_mbinfo.mbs[MB_X]))
                    {
                        MB_N=MB_X + mb_width;
                    }
                    else
                    {
                        MB_N=MB_X;
                    }
                }
                Block->block_num+=15;
            }
            else
            {
                Block->mb_num = -1;
                return;
            }
        }

        Block->mb_num = MB_N;
        return;
    }
    else if (BLOCK_IS_ON_LEFT_EDGE(Block->block_num))
    {
        //Block->block_num-=4;
        GetLeftLocationForCurrentMBLumaMBAFF(Block,1);
        return;
    }
    else if (BLOCK_IS_ON_TOP_EDGE(Block->block_num))
    {
        Block->block_num--;
        GetTopLocationForCurrentMBLumaMBAFF(Block,0);
        return;
    }
    else
    {
        Block->block_num-=5;
        Block->mb_num = m_CurMBAddr;
        return;
    }
    return;
}
void H264VideoDecoder::GetTopRightLocationForCurrentMBLumaNonMBAFF(H264DecoderBlockLocation *Block)
{
    //luma
    if (Block->block_num==3)
    {
        Block->block_num+=9;
        Block->mb_num = m_cur_mb.CurrentMacroblockNeighbours.mb_C;
    }
    else if ( BLOCK_IS_ON_TOP_EDGE(Block->block_num))
    {
        Block->block_num+=13;
        Block->mb_num = m_cur_mb.CurrentMacroblockNeighbours.mb_B;
    }
    else if (!above_right_avail_4x4[Block->block_num])
    {
        Block->mb_num = -1;
    }
    else
    {
        Block->block_num-=3;
        Block->mb_num = m_CurMBAddr;
    }
    return;
}
void H264VideoDecoder::GetTopRightLocationForCurrentMBLumaMBAFF(H264DecoderBlockLocation *Block)
{
    bool curmbfff = !pGetMBFieldDecodingFlag(m_cur_mb.GlobalMacroblockInfo);
    bool curmbtf  = !pGetMBBottomFlag(m_cur_mb.GlobalMacroblockInfo);
    Ipp32s MB_X;
    Ipp32s MB_N;
    //luma
    if (Block->block_num==3)
    {
        if (curmbfff && !curmbtf )
        {
            Block->mb_num = -1;
            return;
        }
        else
        {
            MB_X = m_cur_mb.CurrentMacroblockNeighbours.mb_C;
            if (MB_X>=0)
            {
                if (curmbfff==curmbtf)
                {
                    MB_N=MB_X + mb_width;
                }
                else
                {
                    if (!GetMBFieldDecodingFlag(m_pCurrentFrame->m_mbinfo.mbs[MB_X]))
                    {
                        MB_N=MB_X + mb_width;
                    }
                    else
                    {
                        MB_N=MB_X;
                    }
                }
                Block->block_num+=9;
            }
            else
            {
                Block->mb_num = -1;
                return;
            }
        }
        Block->mb_num = MB_N;
        return;
    }
    else if ( BLOCK_IS_ON_TOP_EDGE(Block->block_num))
    {
        Block->block_num++;
        GetTopLocationForCurrentMBLumaMBAFF(Block,0);
        return;
    }
    else if (!above_right_avail_4x4_lin[Block->block_num])
    {
        Block->mb_num = -1;
        return;
    }
    else
    {
        Block->block_num-=3;
        Block->mb_num = m_CurMBAddr;
    }
    return;
}
void H264VideoDecoder::UpdateNeighbouringAddresses(Ipp8u IgnoreSliceEdges)
{
    //Ipp32s  mb_width = m_pCurrentFrame->macroBlockSize().width;
    if(!pGetMBBottomFlag(m_cur_mb.GlobalMacroblockInfo))//update only if top mb recieved
    {
        Ipp32s real_mb_width = mb_width*(m_CurSliceHeader.MbaffFrameFlag+1);
        m_cur_mb.CurrentMacroblockNeighbours.mb_A = m_CurMB_X>0?m_CurMBAddr-1:-1;
        m_cur_mb.CurrentMacroblockNeighbours.mb_B = m_CurMB_Y>0?m_CurMBAddr-real_mb_width:-1;
        m_cur_mb.CurrentMacroblockNeighbours.mb_C = m_CurMB_Y>0&&m_CurMB_X<mb_width-1?m_CurMBAddr-real_mb_width+1:-1;
        m_cur_mb.CurrentMacroblockNeighbours.mb_D = m_CurMB_Y>0&&m_CurMB_X>0?m_CurMBAddr-real_mb_width-1:-1;
        if (m_bNeedToCheckMBSliceEdges && !IgnoreSliceEdges)
        {
            if (m_cur_mb.CurrentMacroblockNeighbours.mb_A>=0 &&
                (m_cur_mb.GlobalMacroblockInfo->slice_id != m_pCurrentFrame->m_mbinfo.mbs[m_cur_mb.CurrentMacroblockNeighbours.mb_A].slice_id))
                m_cur_mb.CurrentMacroblockNeighbours.mb_A = -1;
            if (m_cur_mb.CurrentMacroblockNeighbours.mb_B>=0 &&
                (m_cur_mb.GlobalMacroblockInfo->slice_id != m_pCurrentFrame->m_mbinfo.mbs[m_cur_mb.CurrentMacroblockNeighbours.mb_B].slice_id))
                m_cur_mb.CurrentMacroblockNeighbours.mb_B = -1;
            if (m_cur_mb.CurrentMacroblockNeighbours.mb_C>=0 &&
                (m_cur_mb.GlobalMacroblockInfo->slice_id != m_pCurrentFrame->m_mbinfo.mbs[m_cur_mb.CurrentMacroblockNeighbours.mb_C].slice_id))
                m_cur_mb.CurrentMacroblockNeighbours.mb_C = -1;
            if (m_cur_mb.CurrentMacroblockNeighbours.mb_D>=0 &&
                (m_cur_mb.GlobalMacroblockInfo->slice_id != m_pCurrentFrame->m_mbinfo.mbs[m_cur_mb.CurrentMacroblockNeighbours.mb_D].slice_id))
                m_cur_mb.CurrentMacroblockNeighbours.mb_D = -1;
        }
        else if(m_bNeedToCheckMBSliceEdges && IgnoreSliceEdges)
        {
            if (m_cur_mb.CurrentMacroblockNeighbours.mb_A>=0 &&
                (m_cur_mb.GlobalMacroblockInfo->slice_id == -1))
                m_cur_mb.CurrentMacroblockNeighbours.mb_A = -1;
            if (m_cur_mb.CurrentMacroblockNeighbours.mb_B>=0 &&
                (m_cur_mb.GlobalMacroblockInfo->slice_id == -1))
                m_cur_mb.CurrentMacroblockNeighbours.mb_B = -1;
            if (m_cur_mb.CurrentMacroblockNeighbours.mb_C>=0 &&
                (m_cur_mb.GlobalMacroblockInfo->slice_id == -1))
                m_cur_mb.CurrentMacroblockNeighbours.mb_C = -1;
            if (m_cur_mb.CurrentMacroblockNeighbours.mb_D>=0 &&
                (m_cur_mb.GlobalMacroblockInfo->slice_id == -1))
                m_cur_mb.CurrentMacroblockNeighbours.mb_D = -1;
        }

    }
    m_cur_mb.GlobalMacroblockPairInfo = &m_pCurrentFrame->m_mbinfo.mbs[m_PairMBAddr];
    m_cur_mb.LocalMacroblockPairInfo = &m_mbinfo.mbs[m_PairMBAddr];

}
void H264VideoDecoder::UpdateNeighbouringBlocks(Ipp8u DeblockCalls)
{

    m_cur_mb.CurrentBlockNeighbours.mb_above.block_num=0;
    m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[0].block_num=16;
    m_cur_mb.CurrentBlockNeighbours.mb_above_left.block_num=0;
    m_cur_mb.CurrentBlockNeighbours.mb_above_right.block_num=3;
    m_cur_mb.CurrentBlockNeighbours.mbs_left[0].block_num=0;
    m_cur_mb.CurrentBlockNeighbours.mbs_left[1].block_num=4;
    m_cur_mb.CurrentBlockNeighbours.mbs_left[2].block_num=8;
    m_cur_mb.CurrentBlockNeighbours.mbs_left[3].block_num=12;
    m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][0].block_num=16;
    m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][1].block_num=18;
    if (m_CurSliceHeader.MbaffFrameFlag)
    {
        GetLeftLocationForCurrentMBLumaMBAFF(&m_cur_mb.CurrentBlockNeighbours.mbs_left[0]);
        GetLeftLocationForCurrentMBLumaMBAFF(&m_cur_mb.CurrentBlockNeighbours.mbs_left[1]);
        GetLeftLocationForCurrentMBLumaMBAFF(&m_cur_mb.CurrentBlockNeighbours.mbs_left[2]);
        GetLeftLocationForCurrentMBLumaMBAFF(&m_cur_mb.CurrentBlockNeighbours.mbs_left[3]);
        GetTopLocationForCurrentMBLumaMBAFF(&m_cur_mb.CurrentBlockNeighbours.mb_above,DeblockCalls);
        GetTopRightLocationForCurrentMBLumaMBAFF(&m_cur_mb.CurrentBlockNeighbours.mb_above_right);
        GetTopLeftLocationForCurrentMBLumaMBAFF(&m_cur_mb.CurrentBlockNeighbours.mb_above_left);
        GetTopLocationForCurrentMBChromaMBAFF(&m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[0]);
        GetLeftLocationForCurrentMBChromaMBAFF(&m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][0]);
        GetLeftLocationForCurrentMBChromaMBAFF(&m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][1]);
    }
    else
    {
        GetLeftLocationForCurrentMBLumaNonMBAFF(&m_cur_mb.CurrentBlockNeighbours.mbs_left[0]);
        GetLeftLocationForCurrentMBLumaNonMBAFF(&m_cur_mb.CurrentBlockNeighbours.mbs_left[1]);
        GetLeftLocationForCurrentMBLumaNonMBAFF(&m_cur_mb.CurrentBlockNeighbours.mbs_left[2]);
        GetLeftLocationForCurrentMBLumaNonMBAFF(&m_cur_mb.CurrentBlockNeighbours.mbs_left[3]);
        GetTopLocationForCurrentMBLumaNonMBAFF(&m_cur_mb.CurrentBlockNeighbours.mb_above);
        GetTopRightLocationForCurrentMBLumaNonMBAFF(&m_cur_mb.CurrentBlockNeighbours.mb_above_right);
        GetTopLeftLocationForCurrentMBLumaNonMBAFF(&m_cur_mb.CurrentBlockNeighbours.mb_above_left);
        GetTopLocationForCurrentMBChromaNonMBAFF(&m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[0]);
        GetLeftLocationForCurrentMBChromaNonMBAFF(&m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][0]);
        GetLeftLocationForCurrentMBChromaNonMBAFF(&m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][1]);
    }
    m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[1][0]=m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][0];
    m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[1][1]=m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][1];
    m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[1] = m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[0];
    m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[1][0].block_num+=4;
    m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[1][1].block_num+=4;
    m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[1].block_num+=4;
}

void H264VideoDecoder::UpdateCurrentMBInfo()
{
    m_cur_mb.GlobalMacroblockInfo = &m_pCurrentFrame->m_mbinfo.mbs[m_CurMBAddr];
    m_cur_mb.LocalMacroblockInfo = &m_mbinfo.mbs[m_CurMBAddr];
    m_cur_mb.MacroblockCoeffsInfo = &m_mbinfo.MacroblockCoeffsInfo[m_CurMBAddr];
    m_cur_mb.MVs[0] = &m_pCurrentFrame->m_mbinfo.MV[0][m_CurMBAddr];
    m_cur_mb.MVs[1] = &m_pCurrentFrame->m_mbinfo.MV[1][m_CurMBAddr];
    m_cur_mb.MVs[2] = &m_mbinfo.MVDeltas[0][m_CurMBAddr];
    m_cur_mb.MVs[3] = &m_mbinfo.MVDeltas[1][m_CurMBAddr];
    m_cur_mb.MVFlags[0] = &m_mbinfo.MVFlags[0][m_CurMBAddr];
    m_cur_mb.MVFlags[1] = &m_mbinfo.MVFlags[1][m_CurMBAddr];
    m_cur_mb.RefIdxs[0] = &m_pCurrentFrame->m_mbinfo.RefIdxs[0][m_CurMBAddr];
    m_cur_mb.RefIdxs[1] = &m_pCurrentFrame->m_mbinfo.RefIdxs[1][m_CurMBAddr];
    if(!pGetMBBottomFlag(m_cur_mb.GlobalMacroblockInfo))
    {
        if (m_CurSliceHeader.MbaffFrameFlag)
            m_PairMBAddr = m_CurMBAddr+mb_width;
        else
            m_PairMBAddr = m_CurMBAddr;
    }
    else
    {
        m_PairMBAddr = m_CurMBAddr-mb_width;
    }
    m_cur_mb.GlobalMacroblockPairInfo = &m_pCurrentFrame->m_mbinfo.mbs[m_PairMBAddr];
    m_cur_mb.LocalMacroblockPairInfo = &m_mbinfo.mbs[m_PairMBAddr];

}
void H264VideoDecoder::ResetGMBData()
{
    Ipp32s i,j, firstj = 0;
    mb_width  = m_pCurrentFrame->macroBlockSize().width;
    mb_height = m_pCurrentFrame->macroBlockSize().height;
    Ipp8u mbaff = m_CurSliceHeader.MbaffFrameFlag;
    H264DecoderMacroblockGlobalInfo *g_mb_first=m_pCurrentFrame->m_mbinfo.mbs;
    H264DecoderMacroblockGlobalInfo *g_mb;
    if(m_pCurrentFrame->m_PictureStructureForDec<FRM_STRUCTURE)
    {
        mb_height >>= 1;
        if(m_pCurrentFrame->m_bottom_field_flag[m_field_index])
        {
            g_mb_first+= m_pCurrentFrame->totalMBs;
            firstj += mb_height;
        }
    }
    g_mb = g_mb_first;


    for (j = 0; j < mb_height; j++)
    {
        for (i = 0; i < mb_width; i++, g_mb++)
        {
            g_mb->slice_id = -1;
            g_mb->mb_aux_fields = (j&mbaff)<<1;
        }
    }


}

}//namespace UMC