umc_h264_redual_decoder_templates.h

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

                        DECODE_INTERNAL_CHROMA_BLOCK_CAVLC(1, 1, 3)
                        break;

                    case CHROMA_FORMAT_422:
                        pNumCoeffsArray += iComponent * 8 + 16;

                        DECODE_EXTERNAL_CHROMA_BLOCK_CAVLC(0, 0, 0)
                        DECODE_TOP_CHROMA_BLOCK_CAVLC(1, 0, 1)
                        DECODE_LEFT_CHROMA_BLOCK_CAVLC(0, 1, 2)
                        DECODE_INTERNAL_CHROMA_BLOCK_CAVLC(1, 1, 3)
                        DECODE_LEFT_CHROMA_BLOCK_CAVLC(0, 2, 4)
                        DECODE_INTERNAL_CHROMA_BLOCK_CAVLC(1, 2, 5)
                        DECODE_LEFT_CHROMA_BLOCK_CAVLC(0, 3, 6)
                        DECODE_INTERNAL_CHROMA_BLOCK_CAVLC(1, 3, 7)
                        break;

                    default:
                        break;
                    }
                }
            }

            // set the empty CBP
            sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_chroma[0] = uFinalCBP[0];
            sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_chroma[1] = uFinalCBP[1];
        }
        else
        {
            // set the empty CBP
            sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_chroma[0] = 0;
            sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_chroma[1] = 0;
        }

        // set zero values to a num coeffs storage
        if (0 == (cbp & CHROMA_AC_BLOCKS))
        {
            Ipp8u *pNumCoeffsArray = sd->m_cur_mb.MacroblockCoeffsInfo->numCoeff;

            switch (color_format)
            {
            case CHROMA_FORMAT_420:
                memset(pNumCoeffsArray + 16, 0, sizeof(*pNumCoeffsArray) * 4 * 2);
                break;

            case CHROMA_FORMAT_422:
                memset(pNumCoeffsArray + 16, 0, sizeof(*pNumCoeffsArray) * 8 * 2);
                break;

            case CHROMA_FORMAT_444:
                memset(pNumCoeffsArray + 16, 0, sizeof(*pNumCoeffsArray) * 16 * 2);
                break;

            default:
                break;
            }
        }
    } // void DecodeCoefficients4x4_CAVLC(H264SegmentDecoderMultiThreaded * sd,
};

template <typename Coeffs, Ipp32s color_format, Ipp32s is_field>
class ResidualDecoderCABAC
{
public:
    typedef Coeffs *  CoeffsPtr;

    virtual ~ResidualDecoderCABAC() {}

    void DecodeCoefficients8x8_CABAC(H264SegmentDecoderMultiThreaded * sd)
    {
        Ipp8u cbp = sd->m_cur_mb.LocalMacroblockInfo->cbp;
        Ipp32u uBlockBit;
        CoeffsPtr pPosCoefbuf = (CoeffsPtr)sd->m_pCoeffBlocksWrite;

        Ipp32u i, j;
        Ipp32s top_bit     = 1;
        Ipp32s left_bit    = 1;
        Ipp32s def_bit = sd->m_cur_mb.GlobalMacroblockInfo->mbtype == MBTYPE_INTRA;
        const Ipp32u *ctxBase;
        const Ipp32s *single_scan;
        Ipp32s iMBAbove, iMBLeft;
        Ipp32u ctxIdxInc, iCtxBase;
        bool field_flag = pGetMBFieldDecodingFlag(sd->m_cur_mb.GlobalMacroblockInfo) ||
            sd->m_pCurrentFrame->m_PictureStructureForDec<FRM_STRUCTURE;
        H264DecoderBlockNeighboursInfo* pN = &sd->m_cur_mb.CurrentBlockNeighbours;

        //this code need additional checking
        if (field_flag)
        {
            ctxBase = ctxIdxOffset8x8FieldCoded;
            single_scan = hp_scan8x8[1];
        } else {
            ctxBase = ctxIdxOffset8x8FrameCoded;
            single_scan = hp_scan8x8[0];
        }

        Ipp32u &cbp4x4_luma = sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_luma;
        cbp4x4_luma = 0;
        sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_chroma[0] = 0;
        sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_chroma[1] = 0;
        uBlockBit = (2+4+8+16);//4 bit set

        // luma coefficients
        for (i = 0; i < 4; i++)
        {
            if (cbp & mask_bit[i]) // are there any coeff in current block
            {
                //set bits for current block
                sd->m_pBitStream->ResidualBlock8x8_CABAC( field_flag,
                                                    single_scan, pPosCoefbuf);

                cbp4x4_luma |= uBlockBit;
                pPosCoefbuf += 64;
            }

            uBlockBit <<= 4;
        }

        // chroma 2x2 DC coeff
        if (cbp > 15)
        {
            if (pGetMBFieldDecodingFlag(sd->m_cur_mb.GlobalMacroblockInfo))
            {
                single_scan = mp_scan4x4[1];
            }
            else
            {
                if (sd->m_pCurrentFrame->m_PictureStructureForDec < FRM_STRUCTURE)
                    single_scan = mp_scan4x4[1];
                else
                    single_scan = mp_scan4x4[0];
            }

            // chroma 2x2 DC coeff
            if (field_flag)
                ctxBase = ctxIdxOffset4x4FieldCoded;
            else
                ctxBase = ctxIdxOffset4x4FrameCoded;

            Ipp32u numOfCoeffs = 0;
            switch (color_format)
            {
            case 1:
                numOfCoeffs = 4;
                break;
            case 2:
                numOfCoeffs = 8;
                break;
            case 3:
                numOfCoeffs = 16;
                break;
            };

            iCtxBase = ctxBase[CODED_BLOCK_FLAG] +
                    ctxIdxBlockCatOffset[CODED_BLOCK_FLAG][BLOCK_CHROMA_DC_LEVELS + color_format];

            iMBAbove = pN->mb_above.mb_num;
            iMBLeft = pN->mbs_left[0].mb_num;

            for (i = 0; i < 2; i++)
            {
                if (0 <= iMBAbove)
                    top_bit = sd->m_mbinfo.mbs[iMBAbove].cbp4x4_chroma[i] & 1;
                else
                    top_bit = def_bit;

                if (0 <= iMBLeft)
                    left_bit = sd->m_mbinfo.mbs[iMBLeft].cbp4x4_chroma[i] & 1;
                else
                    left_bit = def_bit;

                ctxIdxInc = (top_bit<<1) + left_bit;

                if (sd->m_pBitStream->DecodeSingleBin_CABAC(iCtxBase + ctxIdxInc))
                {
                    const Ipp32s * sing_scan = 0;
                    switch (color_format)
                    {
                    case 1:
                        sing_scan = 0;
                        break;
                    case 2:
                        sing_scan = ChromaDC422RasterScan;
                        break;
                    case 3:
                        sing_scan = mp_scan4x4[0];
                        break;
                    }

                    BitStreamColorSpecific<Coeffs, color_format>::ResidualChromaDCBlock_CABAC(
                                                        ctxBase,
                                                        sing_scan,
                                                        pPosCoefbuf, sd->m_pBitStream);

                    sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_chroma[i] = 1;
                    pPosCoefbuf += numOfCoeffs;
                }
            }

            // chroma AC coeff, all zero from start_scan
            if (cbp > 31)
            {
                iCtxBase = ctxBase[CODED_BLOCK_FLAG] +
                            ctxIdxBlockCatOffset[CODED_BLOCK_FLAG][BLOCK_CHROMA_AC_LEVELS];

                for (j = 0; j < 2; j++)//plane
                {
                    Ipp32u &cbp4x4_chroma = sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_chroma[j];
                    Ipp32u addition = 16 + numOfCoeffs*j;
                    uBlockBit = 2;
                    for (i = 0; i < numOfCoeffs; i++, uBlockBit <<= 1)//block
                    {
                        Ipp32s raster_order_block = block_subblock_mapping[i];

                        Ipp32s bit = i + 1;

                        top_bit     = def_bit;
                        left_bit    = def_bit;

                        //--- get bits from neighbouring blocks ---
                        if (sb_y[color_format][i])
                        {
                            if (color_format == 3)
                                top_bit = BIT_CHECK(cbp4x4_chroma, block_subblock_mapping[raster_order_block - 4] + 1);
                            else
                                top_bit = BIT_CHECK(cbp4x4_chroma, bit - 2);
                        }
                        else
                        {
                            iMBAbove = pN->mb_above_chroma[0].mb_num;

                            if (0 <= iMBAbove)
                            {
                                if (color_format == 3)
                                    top_bit = BIT_CHECK(sd->m_mbinfo.mbs[iMBAbove].cbp4x4_chroma[j],
                                        block_subblock_mapping[pN->mb_above_chroma[j].block_num + sb_x[3][i] - addition] + 1);
                                else
                                    top_bit = BIT_CHECK(sd->m_mbinfo.mbs[iMBAbove].cbp4x4_chroma[j],
                                        pN->mb_above_chroma[j].block_num + sb_x[color_format][i] - addition + 1);
                            }
                        }

                        if (sb_x[color_format][i])
                        {
                            if (color_format == 3)
                                left_bit = BIT_CHECK(cbp4x4_chroma, block_subblock_mapping[raster_order_block - 1] + 1);
                            else
                                left_bit = BIT_CHECK(cbp4x4_chroma, bit - 1);
                        }
                        else
                        {
                            iMBLeft = pN->mbs_left_chroma[j][sb_y[color_format][i]].mb_num;

                            if (0 <= iMBLeft)
                            {
                                if (color_format == 3)
                                    left_bit = BIT_CHECK(sd->m_mbinfo.mbs[iMBLeft].cbp4x4_chroma[j],
                                        block_subblock_mapping[pN->mbs_left_chroma[j][sb_y[3][i]].block_num - addition] + 1);
                                else
                                    left_bit = BIT_CHECK(sd->m_mbinfo.mbs[iMBLeft].cbp4x4_chroma[j],
                                        pN->mbs_left_chroma[j][sb_y[color_format][i]].block_num - addition + 1);
                            }
                        }

                        ctxIdxInc = (top_bit<<1) + left_bit;

                        if (sd->m_pBitStream->DecodeSingleBin_CABAC(iCtxBase + ctxIdxInc))
                        {
                            sd->m_pBitStream->ResidualBlock4x4_CABAC (BLOCK_CHROMA_AC_LEVELS,
                                                        ctxBase,
                                                        single_scan,
                                                        pPosCoefbuf,
                                                        14);

                            cbp4x4_chroma |= uBlockBit;

                            pPosCoefbuf += 16;
                        }
                    }
                }
            }
        }

        // update buffer position pointer
        sd->m_pCoeffBlocksWrite = (UMC::CoeffsPtrCommon)pPosCoefbuf;
    }

    inline
    Ipp32s CheckCBP(Ipp32s iCBP, Ipp32s iBlockNum)
    {
        return (iCBP & iBlockCBPMask[iBlockNum]) ? (1) : (0);

    } // Ipp32s CheckCBP(Ipp32s iCBP, Ipp32s iBlockNum)

    inline
    Ipp32s CheckCBPChroma(Ipp32s iCBP, Ipp32s iBlockNum)
    {
        return (iCBP & iBlockCBPMaskChroma[iBlockNum]) ? (1) : (0);

    } // Ipp32s CheckCBPChroma(Ipp32s iCBP, Ipp32s iBlockNum)

#define DECODE_EXTERNAL_LUMA_BLOCK_CABAC(x_pos, y_pos, block_number) \
    { \
        Ipp32s ctxIdxInc; \
        Ipp32s condTermFlagA, condTermFlagB; \
        /* create flag for A macroblock */ \
        { \
            H264DecoderBlockLocation mbAddrA; \
            mbAddrA = pN->mbs_left[y_pos]; \
            if (-1 < mbAddrA.mb_num) \
            { \
                condTermFlagA = CheckCBP(sd->m_mbinfo.mbs[mbAddrA.mb_num].cbp4x4_luma, \
                                         mbAddrA.block_num); \
            } \
            else \
                condTermFlagA = defTermFlag; \
        } \
        /* create flag for B macroblock */ \
        { \
            H264DecoderBlockLocation mbAddrB; \
            mbAddrB = pN->mb_above; \
            if (-1 < mbAddrB.mb_num) \
            { \
                condTermFlagB = (sd->m_mbinfo.mbs[mbAddrB.mb_num].cbp4x4_luma & 0x0800) ? \
                                (1) : \
                                (0); \