umc_h264_sd_inlines.h

audio-video-codecs.rar语音编解码器

            {
                Block->mb_num = -1;
                return;
            }
        }
        Block->mb_num = MB_N;
        return;
    }
    else
    {
        Block->block_num-=2;
        Block->mb_num = m_CurMBAddr;
        return;
    }

}

inline
void H264SegmentDecoder::GetTopLocationForCurrentMBChromaMBAFFH2(H264DecoderBlockLocation *Block)
{
    bool curmbfff = !pGetMBFieldDecodingFlag(m_cur_mb.GlobalMacroblockInfo);
    bool curmbtf  = !(m_CurMBAddr & 1);
    Ipp32s pair_offset = curmbtf? 1:-1;
    Ipp32s MB_X;
    Ipp32s MB_N;
    //chroma
    if (CHROMA_BLOCK_IS_ON_TOP_EDGE(Block->block_num-16,2))
    {
        if (curmbfff && !curmbtf )
        {
            MB_N = m_CurMBAddr + pair_offset;
            Block->block_num+=6;
        }
        else
        {
            MB_X = m_cur_mb.CurrentMacroblockNeighbours.mb_B;
            if (MB_X>=0)
            {
                Ipp8u xfff=!GetMBFieldDecodingFlag(m_gmbinfo->mbs[MB_X]);
                if (!curmbfff && curmbtf && !xfff)
                {
                    MB_N=MB_X;
                    Block->block_num+=6;
                }
                else
                {
                    //if (!curmbff && curmbtf && xfff)
                    //    Block->block_num+=0;
                    //else
                    Block->block_num+=6;
                    MB_N=MB_X + 1;
                }
            }
            else
            {
                Block->mb_num = -1;
                return;
            }
        }
        Block->mb_num = MB_N;
        return;
    }
    else
    {
        Block->block_num-=2;
        Block->mb_num = m_CurMBAddr;
        return;
    }

}

inline
void H264SegmentDecoder::GetTopLocationForCurrentMBChromaMBAFFH4(H264DecoderBlockLocation *Block)
{
    bool curmbfff = !pGetMBFieldDecodingFlag(m_cur_mb.GlobalMacroblockInfo);
    bool curmbtf  = !(m_CurMBAddr & 1);
    Ipp32s pair_offset = curmbtf? 1:-1;
    Ipp32s MB_X;
    Ipp32s MB_N;
    //chroma
    if (CHROMA_BLOCK_IS_ON_TOP_EDGE(Block->block_num-16,3))
    {
        if (curmbfff && !curmbtf )
        {
            MB_N = m_CurMBAddr + pair_offset;
            Block->block_num+=12;
        }
        else
        {
            MB_X = m_cur_mb.CurrentMacroblockNeighbours.mb_B;
            if (MB_X>=0)
            {
                Ipp8u xfff=!GetMBFieldDecodingFlag(m_gmbinfo->mbs[MB_X]);
                if (!curmbfff && curmbtf && !xfff)
                {
                    MB_N=MB_X;
                    Block->block_num+=12;
                }
                else
                {
                    Block->block_num+=12;
                    MB_N=MB_X + 1;
                }
            }
            else
            {
                Block->mb_num = -1;
                return;
            }
        }
        Block->mb_num = MB_N;
        return;
    }
    else
    {
        Block->block_num-=4;
        Block->mb_num = m_CurMBAddr;
        return;
    }

}

void H264SegmentDecoder::UpdateNeighbouringBlocksBMEH(Ipp32s DeblockCalls)
{
    H264DecoderBlockNeighboursInfo * pN = &m_cur_mb.CurrentBlockNeighbours;

    pN->mb_above.block_num=0;
    pN->mb_above_chroma[0].block_num=16;
    pN->mb_above_left.block_num=0;
    pN->mb_above_right.block_num=3;
    pN->mbs_left[0].block_num=0;
    pN->mbs_left[1].block_num=4;
    pN->mbs_left[2].block_num=8;
    pN->mbs_left[3].block_num=12;
    pN->mbs_left_chroma[0][0].block_num=16;
    pN->mbs_left_chroma[0][1].block_num=16+2;
    if (m_pSliceHeader->MbaffFrameFlag)
    {
        GetLeftLocationForCurrentMBLumaMBAFF(&pN->mbs_left[0]);
        GetLeftLocationForCurrentMBLumaMBAFF(&pN->mbs_left[1]);
        GetLeftLocationForCurrentMBLumaMBAFF(&pN->mbs_left[2]);
        GetLeftLocationForCurrentMBLumaMBAFF(&pN->mbs_left[3]);
        GetTopLocationForCurrentMBLumaMBAFF(&pN->mb_above,DeblockCalls);
        GetTopRightLocationForCurrentMBLumaMBAFF(&pN->mb_above_right);
        GetTopLeftLocationForCurrentMBLumaMBAFF(&pN->mb_above_left);
        GetTopLocationForCurrentMBChromaMBAFFBMEH(&pN->mb_above_chroma[0]);
        GetLeftLocationForCurrentMBChromaMBAFFBMEH(&pN->mbs_left_chroma[0][0]);
        GetLeftLocationForCurrentMBChromaMBAFFBMEH(&pN->mbs_left_chroma[0][1]);
    }
    else
    {
        GetLeftLocationForCurrentMBLumaNonMBAFF(&pN->mbs_left[0]);
        GetLeftLocationForCurrentMBLumaNonMBAFF(&pN->mbs_left[1]);
        GetLeftLocationForCurrentMBLumaNonMBAFF(&pN->mbs_left[2]);
        GetLeftLocationForCurrentMBLumaNonMBAFF(&pN->mbs_left[3]);
        GetTopLocationForCurrentMBLumaNonMBAFF(&pN->mb_above);
        GetTopRightLocationForCurrentMBLumaNonMBAFF(&pN->mb_above_right);
        GetTopLeftLocationForCurrentMBLumaNonMBAFF(&pN->mb_above_left);
        GetTopLocationForCurrentMBChromaNonMBAFFBMEH(&pN->mb_above_chroma[0]);
        GetLeftLocationForCurrentMBChromaNonMBAFFBMEH(&pN->mbs_left_chroma[0][0]);
        GetLeftLocationForCurrentMBChromaNonMBAFFBMEH(&pN->mbs_left_chroma[0][1]);
    }
    pN->mbs_left_chroma[1][0]=pN->mbs_left_chroma[0][0];
    pN->mbs_left_chroma[1][1]=pN->mbs_left_chroma[0][1];
    pN->mb_above_chroma[1] = pN->mb_above_chroma[0];
    pN->mbs_left_chroma[1][0].block_num+=4;
    pN->mbs_left_chroma[1][1].block_num+=4;
    pN->mb_above_chroma[1].block_num+=4;
} // void H264SegmentDecoder::UpdateNeighbouringBlocks(Ipp8u DeblockCalls)

void H264SegmentDecoder::UpdateNeighbouringBlocksH2(Ipp32s DeblockCalls)
{
    H264DecoderBlockNeighboursInfo * pN = &m_cur_mb.CurrentBlockNeighbours;

    pN->mb_above.block_num=0;
    pN->mb_above_chroma[0].block_num=16;
    pN->mb_above_left.block_num=0;
    pN->mb_above_right.block_num=3;
    pN->mbs_left[0].block_num=0;
    pN->mbs_left[1].block_num=4;
    pN->mbs_left[2].block_num=8;
    pN->mbs_left[3].block_num=12;
    pN->mbs_left_chroma[0][0].block_num=16;
    pN->mbs_left_chroma[0][1].block_num=16+2;
    pN->mbs_left_chroma[0][2].block_num=16+4;
    pN->mbs_left_chroma[0][3].block_num=16+6;
    if (m_pSliceHeader->MbaffFrameFlag)
    {
        GetLeftLocationForCurrentMBLumaMBAFF(&pN->mbs_left[0]);
        GetLeftLocationForCurrentMBLumaMBAFF(&pN->mbs_left[1]);
        GetLeftLocationForCurrentMBLumaMBAFF(&pN->mbs_left[2]);
        GetLeftLocationForCurrentMBLumaMBAFF(&pN->mbs_left[3]);
        GetTopLocationForCurrentMBLumaMBAFF(&pN->mb_above,DeblockCalls);
        GetTopRightLocationForCurrentMBLumaMBAFF(&pN->mb_above_right);
        GetTopLeftLocationForCurrentMBLumaMBAFF(&pN->mb_above_left);
        GetTopLocationForCurrentMBChromaMBAFFH2(&pN->mb_above_chroma[0]);
        GetLeftLocationForCurrentMBChromaMBAFFH2(&pN->mbs_left_chroma[0][0]);
        GetLeftLocationForCurrentMBChromaMBAFFH2(&pN->mbs_left_chroma[0][1]);
        GetLeftLocationForCurrentMBChromaMBAFFH2(&pN->mbs_left_chroma[0][2]);
        GetLeftLocationForCurrentMBChromaMBAFFH2(&pN->mbs_left_chroma[0][3]);
    }
    else
    {
        GetLeftLocationForCurrentMBLumaNonMBAFF(&pN->mbs_left[0]);
        GetLeftLocationForCurrentMBLumaNonMBAFF(&pN->mbs_left[1]);
        GetLeftLocationForCurrentMBLumaNonMBAFF(&pN->mbs_left[2]);
        GetLeftLocationForCurrentMBLumaNonMBAFF(&pN->mbs_left[3]);
        GetTopLocationForCurrentMBLumaNonMBAFF(&pN->mb_above);
        GetTopRightLocationForCurrentMBLumaNonMBAFF(&pN->mb_above_right);
        GetTopLeftLocationForCurrentMBLumaNonMBAFF(&pN->mb_above_left);
        GetTopLocationForCurrentMBChromaNonMBAFFH2(&pN->mb_above_chroma[0]);
        GetLeftLocationForCurrentMBChromaNonMBAFFH2(&pN->mbs_left_chroma[0][0]);
        GetLeftLocationForCurrentMBChromaNonMBAFFH2(&pN->mbs_left_chroma[0][1]);
        GetLeftLocationForCurrentMBChromaNonMBAFFH2(&pN->mbs_left_chroma[0][2]);
        GetLeftLocationForCurrentMBChromaNonMBAFFH2(&pN->mbs_left_chroma[0][3]);
    }
    pN->mbs_left_chroma[1][0]=pN->mbs_left_chroma[0][0];
    pN->mbs_left_chroma[1][1]=pN->mbs_left_chroma[0][1];
    pN->mbs_left_chroma[1][2]=pN->mbs_left_chroma[0][2];
    pN->mbs_left_chroma[1][3]=pN->mbs_left_chroma[0][3];
    pN->mb_above_chroma[1] = pN->mb_above_chroma[0];
    pN->mbs_left_chroma[1][0].block_num+=8;
    pN->mbs_left_chroma[1][1].block_num+=8;
    pN->mbs_left_chroma[1][2].block_num+=8;
    pN->mbs_left_chroma[1][3].block_num+=8;
    pN->mb_above_chroma[1].block_num+=8;
} // void H264SegmentDecoder::UpdateNeighbouringBlocks(Ipp8u DeblockCalls)

void H264SegmentDecoder::UpdateNeighbouringBlocksH4(Ipp32s DeblockCalls)
{
    H264DecoderBlockNeighboursInfo * pN = &m_cur_mb.CurrentBlockNeighbours;

    pN->mb_above.block_num=0;
    pN->mb_above_chroma[0].block_num=16;
    pN->mb_above_left.block_num=0;
    pN->mb_above_right.block_num=3;
    pN->mbs_left[0].block_num=0;
    pN->mbs_left[1].block_num=4;
    pN->mbs_left[2].block_num=8;
    pN->mbs_left[3].block_num=12;
    pN->mbs_left_chroma[0][0].block_num=16;
    pN->mbs_left_chroma[0][1].block_num=16+4;
    pN->mbs_left_chroma[0][2].block_num=16+8;
    pN->mbs_left_chroma[0][3].block_num=16+12;
    if (m_pSliceHeader->MbaffFrameFlag)
    {
        GetLeftLocationForCurrentMBLumaMBAFF(&pN->mbs_left[0]);
        GetLeftLocationForCurrentMBLumaMBAFF(&pN->mbs_left[1]);
        GetLeftLocationForCurrentMBLumaMBAFF(&pN->mbs_left[2]);
        GetLeftLocationForCurrentMBLumaMBAFF(&pN->mbs_left[3]);
        GetTopLocationForCurrentMBLumaMBAFF(&pN->mb_above,DeblockCalls);
        GetTopRightLocationForCurrentMBLumaMBAFF(&pN->mb_above_right);
        GetTopLeftLocationForCurrentMBLumaMBAFF(&pN->mb_above_left);
        GetTopLocationForCurrentMBChromaMBAFFH4(&pN->mb_above_chroma[0]);

        pN->mbs_left_chroma[0][0] = pN->mbs_left[0];
        pN->mbs_left_chroma[0][1] = pN->mbs_left[1];
        pN->mbs_left_chroma[0][2] = pN->mbs_left[2];
        pN->mbs_left_chroma[0][3] = pN->mbs_left[3];
        pN->mbs_left_chroma[0][0].block_num +=16;
        pN->mbs_left_chroma[0][1].block_num +=16;
        pN->mbs_left_chroma[0][2].block_num +=16;
        pN->mbs_left_chroma[0][3].block_num +=16;
        /*GetLeftLocationForCurrentMBChromaMBAFFH4(&pN->mbs_left_chroma[0][0]);
        GetLeftLocationForCurrentMBChromaMBAFFH4(&pN->mbs_left_chroma[0][1]);
        GetLeftLocationForCurrentMBChromaMBAFFH4(&pN->mbs_left_chroma[0][2]);
        GetLeftLocationForCurrentMBChromaMBAFFH4(&pN->mbs_left_chroma[0][3]);*/
    }
    else
    {
        GetLeftLocationForCurrentMBLumaNonMBAFF(&pN->mbs_left[0]);
        GetLeftLocationForCurrentMBLumaNonMBAFF(&pN->mbs_left[1]);
        GetLeftLocationForCurrentMBLumaNonMBAFF(&pN->mbs_left[2]);
        GetLeftLocationForCurrentMBLumaNonMBAFF(&pN->mbs_left[3]);
        GetTopLocationForCurrentMBLumaNonMBAFF(&pN->mb_above);
        GetTopRightLocationForCurrentMBLumaNonMBAFF(&pN->mb_above_right);
        GetTopLeftLocationForCurrentMBLumaNonMBAFF(&pN->mb_above_left);
        GetTopLocationForCurrentMBChromaNonMBAFFH4(&pN->mb_above_chroma[0]);
        GetLeftLocationForCurrentMBChromaNonMBAFFH4(&pN->mbs_left_chroma[0][0]);
        GetLeftLocationForCurrentMBChromaNonMBAFFH4(&pN->mbs_left_chroma[0][1]);
        GetLeftLocationForCurrentMBChromaNonMBAFFH4(&pN->mbs_left_chroma[0][2]);
        GetLeftLocationForCurrentMBChromaNonMBAFFH4(&pN->mbs_left_chroma[0][3]);
    }
    pN->mbs_left_chroma[1][0]=pN->mbs_left_chroma[0][0];
    pN->mbs_left_chroma[1][1]=pN->mbs_left_chroma[0][1];
    pN->mbs_left_chroma[1][2]=pN->mbs_left_chroma[0][2];
    pN->mbs_left_chroma[1][3]=pN->mbs_left_chroma[0][3];
    pN->mb_above_chroma[1] = pN->mb_above_chroma[0];
    pN->mbs_left_chroma[1][0].block_num+=16;
    pN->mbs_left_chroma[1][1].block_num+=16;
    pN->mbs_left_chroma[1][2].block_num+=16;
    pN->mbs_left_chroma[1][3].block_num+=16;
    pN->mb_above_chroma[1].block_num+=16;
} // void H264SegmentDecoder::UpdateNeighbouringBlocks(Ipp8u DeblockCalls)

inline
void H264SegmentDecoder::UpdateCurrentMBInfo()
{
    m_cur_mb.GlobalMacroblockInfo = &m_gmbinfo->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_gmbinfo->MV[0][m_CurMBAddr];
    m_cur_mb.MVs[1] = &m_gmbinfo->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.RefIdxs[0] = &m_gmbinfo->RefIdxs[0][m_CurMBAddr];
    m_cur_mb.RefIdxs[1] = &m_gmbinfo->RefIdxs[1][m_CurMBAddr];

    if (m_pSliceHeader->MbaffFrameFlag)
    {
        m_PairMBAddr = (m_CurMBAddr & 1) ? m_CurMBAddr-1 : m_CurMBAddr+1;
        m_cur_mb.GlobalMacroblockPairInfo = &m_gmbinfo->mbs[m_PairMBAddr];
        m_cur_mb.LocalMacroblockPairInfo = &m_mbinfo.mbs[m_PairMBAddr];
    }
    /*else
    {
        m_PairMBAddr = m_CurMBAddr;
    }*/

} // void H264SegmentDecoder::UpdateCurrentMBInfo()

inline
void H264SegmentDecoder::UpdateNeighbouringAddresses(Ipp32s IgnoreSliceEdges)
{
    if (0 == (((Ipp32s) m_pSliceHeader->MbaffFrameFlag) |
              ((Ipp32s) m_pSlice->IsSliceGroups())))
    {
        UpdateNeighbouringAddressesField();
    }
    else
    {
        H264DecoderMacroblockNeighboursInfo * pN = &m_cur_mb.CurrentMacroblockNeighbours;

        if (!(m_pSliceHeader->MbaffFrameFlag && (m_CurMBAddr & 1))) //update only if top mb recieved
        {
            Ipp32s real_mb_width = mb_width*(m_pSliceHeader->MbaffFrameFlag+1);
            Ipp32s mb_left_offset = m_pSliceHeader->MbaffFrameFlag + 1;
            pN->mb_A = m_CurMB_X>0? m_CurMBAddr - mb_left_offset : -1;
            pN->mb_B = m_CurMB_Y>0? m_CurMBAddr - real_mb_width :-1;
            pN->mb_C = (m_CurMB_Y > 0 && m_CurMB_X < ((signed)mb_width) - 1) ? (m_CurMBAddr - real_mb_width + mb_left_offset) : (-1);
            pN->mb_D = m_CurMB_Y>0&&m_CurMB_X>0?m_CurMBAddr-real_mb_width-mb_left_offset:-1;
            if (m_bNeedToCheckMBSliceEdges && !IgnoreSliceEdges)
            {
                if (pN->mb_A>=0 &&
                    (m_cur_mb.GlobalMacroblockInfo->slice_id != m_gmbinfo->mbs[pN->mb_A].slice_id))
                    pN->mb_A = -1;
                if (pN->mb_B>=0 &&
                    (m_cur_mb.GlobalMacroblockInfo->slice_id != m_gmbinfo->mbs[pN->mb_B].slice_id))
                    pN->mb_B = -1;
                if (pN->mb_C>=0 &&
                    (m_cur_mb.GlobalMacroblockInfo->slice_id != m_gmbinfo->mbs[pN->mb_C].slice_id))
                    pN->mb_C = -1;
                if (pN->mb_D>=0 && (m_cur_mb.GlobalMacroblockInfo->slice_id != m_gmbinfo->mbs[pN->mb_D].slice_id))
                    pN->mb_D = -1;
            }
            else if(m_bNeedToCheckMBSliceEdges && IgnoreSliceEdges)
            {
                if (pN->mb_A>=0 &&
                    (m_cur_mb.GlobalMacroblockInfo->slice_id == 0))
                    pN->mb_A = -1;
                if (pN->mb_B>=0 &&
                    (m_cur_mb.GlobalMacroblockInfo->slice_id == 0))
                    pN->mb_B = -1;
                if (pN->mb_C>=0 &&
                    (m_cur_mb.GlobalMacroblockInfo->slice_id == 0))
                    pN->mb_C = -1;
                if (pN->mb_D>=0 &&
                    (m_cur_mb.GlobalMacroblockInfo->slice_id == 0))
                    pN->mb_D = -1;
            }

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

} // void H264SegmentDecoder::UpdateNeighbouringAddresses(Ipp8u IgnoreSliceEdges)

inline
void H264SegmentDecoder::UpdateNeighbouringAddressesField(void)
{
    H264DecoderMacroblockNeighboursInfo *pNInfo = &(m_cur_mb.CurrentMacroblockNeighbours);
    Ipp32s iFirst = m_pSlice->GetFirstMBNumber();
    Ipp32s iMBWidth = m_pSlice->GetMBWidth();

    if ((m_CurMB_X) && (m_CurMB_Y))
    {
        if (iFirst <= m_CurMBAddr - iMBWidth - 1)
        {
            pNInfo->mb_A = m_CurMBAddr - 1;
            pNInfo->mb_B = m_CurMBAddr - iMBWidth;
            pNInfo->mb_C = (m_CurMB_X + 1 < iMBWidth) ? (m_CurMBAddr - iMBWidth + 1) : (-1);
            pNInfo->mb_D = m_CurMBAddr - iMBWidth - 1;
        }
        else
        {
            pNInfo->mb_A = (iFirst <= m_CurMBAddr - 1) ? (m_CurMBAddr - 1) : (-1);
            pNInfo->mb_B = (iFirst <= m_CurMBAddr - iMBWidth) ? (m_CurMBAddr - iMBWidth) : (-1);
            pNInfo->mb_C = ((m_CurMB_X + 1 < iMBWidth) && (iFirst <= m_CurMBAddr - iMBWidth + 1)) ? (m_CurMBAddr - iMBWidth + 1) : (-1);
            pNInfo->mb_D = (iFirst <= m_CurMBAddr - iMBWidth - 1) ? (m_CurMBAddr - iMBWidth - 1) : (-1);
        }
    }
    else if (m_CurMB_X)
    {
        pNInfo->mb_A = (iFirst <= m_CurMBAddr - 1) ? (m_CurMBAddr - 1) : (-1);
        pNInfo->mb_B = -1;
        pNInfo->mb_C = -1;
        pNInfo->mb_D = -1;
    }
    else if (m_CurMB_Y)
    {
        pNInfo->mb_A = -1;
        pNInfo->mb_B = (iFirst <= m_CurMBAddr - iMBWidth) ? (m_CurMBAddr - iMBWidth) : (-1);
        pNInfo->mb_C = (iFirst <= m_CurMBAddr - iMBWidth + 1) ? (m_CurMBAddr - iMBWidth + 1) : (-1);
        pNInfo->mb_D = -1;
    }
    else
    {
        pNInfo->mb_A = -1;
        pNInfo->mb_B = -1;
        pNInfo->mb_C = -1;
        pNInfo->mb_D = -1;
    }

} // void H264SegmentDecoder::UpdateNeighbouringAddressesField(void)


} // namespace UMC

#endif /* __UMC_H264_SEGMENT_DECODER_INLINES_H */
#endif // UMC_ENABLE_H264_VIDEO_DECODER