umc_h264_redual_decoder_templates.h

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

                            (0); \
        } \
        /* create context increment */ \
        ctxIdxInc = condTermFlagA + 2 * condTermFlagB; \
        /* decode block coeffs */ \
        if (sd->m_pBitStream->DecodeSingleBin_CABAC(ctxCodedBlockFlag + ctxIdxInc)) \
        { \
            sd->m_pBitStream->ResidualBlock4x4_CABAC(BLOCK_CHROMA_AC_LEVELS, \
                                                     ctxBase, \
                                                     pScan, \
                                                     pPosCoefbuf, \
                                                     14); \
            /* update final CBP */ \
            uFinalCBP[iComponent] |= (1 << (block_number + 1)); \
            /* update coefficient buffer pointer */ \
            pPosCoefbuf += 16; \
        } \
    }

    void DecodeCoefficients16x16_CABAC(H264SegmentDecoderMultiThreaded * sd)
    {
        Ipp32u iDCCBP = 0;

        const Ipp32u *ctxBase;
        const Ipp32s *pScan;
        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 = ctxIdxOffset4x4FieldCoded;
            pScan = mp_scan4x4[1];
        }
        else
        {
            ctxBase = ctxIdxOffset4x4FrameCoded;
            pScan = mp_scan4x4[0];
        }

        {

            Ipp32s iMBAbove, iMBLeft;
            Ipp32s condTermFlagA, condTermFlagB;
            Ipp32u ctxIdxInc, ctxCodedBlockFlag;

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

            // create flag for A macroblock
            if (0 <= iMBLeft)
                condTermFlagA = (Ipp32u) (sd->m_mbinfo.mbs[iMBLeft].cbp4x4_luma & 1);
            else
                condTermFlagA = 1;

            // create flag for B macroblock
            if (0 <= iMBAbove)
                condTermFlagB = (Ipp32u) (sd->m_mbinfo.mbs[iMBAbove].cbp4x4_luma & 1);
            else
                condTermFlagB = 1;

            // create context increment
            ctxIdxInc = condTermFlagA + 2 * condTermFlagB;

            // select context for coded block flag
            ctxCodedBlockFlag = ctxBase[CODED_BLOCK_FLAG] +
                                ctxIdxBlockCatOffset[CODED_BLOCK_FLAG][BLOCK_LUMA_DC_LEVELS];

            // set bits for current block
            if (sd->m_pBitStream->DecodeSingleBin_CABAC(ctxCodedBlockFlag +
                                                        ctxIdxInc))
            {
                typedef Coeffs * CoeffsPtr;
                CoeffsPtr pPosCoefbuf = (CoeffsPtr)sd->m_pCoeffBlocksWrite;

                sd->m_pBitStream->ResidualBlock4x4_CABAC(BLOCK_LUMA_DC_LEVELS,
                                                         ctxBase,
                                                         pScan,
                                                         pPosCoefbuf,
                                                         15);
                iDCCBP = 1;
                // update buffer position pointer
                pPosCoefbuf += 16;
                sd->m_pCoeffBlocksWrite = (UMC::CoeffsPtrCommon) pPosCoefbuf;

            }
        }

        DecodeCoefficients4x4_CABAC(sd, 14);

        // save final CBP
        sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_luma |= iDCCBP;
    } // void DecodeCoefficients16x16_CABAC(H264SegmentDecoderMultiThreaded * sd)

    void DecodeCoefficients4x4_CABAC(H264SegmentDecoderMultiThreaded * sd,
                                       Ipp32s iMaxNum = 15)
    {
        CoeffsPtr pPosCoefbuf = (CoeffsPtr)sd->m_pCoeffBlocksWrite;

        Ipp32u cbp = sd->m_cur_mb.LocalMacroblockInfo->cbp;
        const Ipp32s *pScan;
        bool field_flag = pGetMBFieldDecodingFlag(sd->m_cur_mb.GlobalMacroblockInfo) ||
                          sd->m_pCurrentFrame->m_PictureStructureForDec<FRM_STRUCTURE;
        H264DecoderBlockNeighboursInfo *pN = &sd->m_cur_mb.CurrentBlockNeighbours;

        Ipp32s defTermFlag;
        const Ipp32u *ctxBase;
        Ipp32u ctxBlockCat;
        Ipp32u ctxCodedBlockFlag;

        // set default bit
        defTermFlag = (sd->m_cur_mb.GlobalMacroblockInfo->mbtype < MBTYPE_PCM) ? (1) : (0);

        // this code need additional checking
        if (field_flag)
        {
            ctxBase = ctxIdxOffset4x4FieldCoded;
            pScan = mp_scan4x4[1];
        }
        else
        {
            ctxBase = ctxIdxOffset4x4FrameCoded;
            pScan = mp_scan4x4[0];
        }

        // select context for block data
        ctxBlockCat = (14 == iMaxNum) ? (BLOCK_LUMA_AC_LEVELS) : (BLOCK_LUMA_LEVELS);
        // select context for coded block flag
        ctxCodedBlockFlag = (ctxBase[CODED_BLOCK_FLAG] +
                             ctxIdxBlockCatOffset[CODED_BLOCK_FLAG][ctxBlockCat]);


        //
        // decode luminance blocks
        //
        {
            Ipp32u uFinalCBP = 0;

            if (cbp & LUMA_BLOCK_8X8_0)
            {
                DECODE_EXTERNAL_LUMA_BLOCK_CABAC(0, 0, 0)
                DECODE_TOP_LUMA_BLOCK_CABAC(1, 0, 1, 0)
                DECODE_LEFT_LUMA_BLOCK_CABAC(0, 1, 2, 0)
                DECODE_INTERNAL_LUMA_BLOCK_CABAC(1, 1, 3, 2, 1)
            }

            if (cbp & LUMA_BLOCK_8X8_1)
            {
                DECODE_TOP_LUMA_BLOCK_CABAC(2, 0, 4, 1)
                DECODE_TOP_LUMA_BLOCK_CABAC(3, 0, 5, 4)
                DECODE_INTERNAL_LUMA_BLOCK_CABAC(2, 1, 6, 3, 4)
                DECODE_INTERNAL_LUMA_BLOCK_CABAC(3, 1, 7, 6, 5)
            }

            if (cbp & LUMA_BLOCK_8X8_2)
            {
                DECODE_LEFT_LUMA_BLOCK_CABAC(0, 2, 8, 2)
                DECODE_INTERNAL_LUMA_BLOCK_CABAC(1, 2, 9, 8, 3)
                DECODE_LEFT_LUMA_BLOCK_CABAC(0, 3, 10, 8)
                DECODE_INTERNAL_LUMA_BLOCK_CABAC(1, 3, 11, 10, 9)
            }

            if (cbp & LUMA_BLOCK_8X8_3)
            {
                DECODE_INTERNAL_LUMA_BLOCK_CABAC(2, 2, 12, 9, 6)
                DECODE_INTERNAL_LUMA_BLOCK_CABAC(3, 2, 13, 12, 7)
                DECODE_INTERNAL_LUMA_BLOCK_CABAC(2, 3, 14, 11, 12)
                DECODE_INTERNAL_LUMA_BLOCK_CABAC(3, 3, 15, 14, 13)
            }

            // save final CBP
            sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_luma = uFinalCBP;
        }

        //
        // decode chrominance blocks
        //

        if (cbp & CHROMA_DC_AC_BLOCKS)
        {
            Ipp32u uFinalCBP[2];

            // select new context
            ctxCodedBlockFlag = ctxBase[CODED_BLOCK_FLAG] +
                                ctxIdxBlockCatOffset[CODED_BLOCK_FLAG][BLOCK_CHROMA_DC_LEVELS +
                                                                       color_format];

            // decode DC blocks
            DECODE_CHROMA_DC_BLOCK_CABAC(0)
            DECODE_CHROMA_DC_BLOCK_CABAC(1)

            if (cbp & CHROMA_AC_BLOCKS)
            {
                Ipp32s iComponent;

                // select new context
                ctxCodedBlockFlag = ctxBase[CODED_BLOCK_FLAG] +
                                    ctxIdxBlockCatOffset[CODED_BLOCK_FLAG][BLOCK_CHROMA_AC_LEVELS];

                for (iComponent = 0; iComponent < 2; iComponent += 1)
                {
                    Ipp32s iBlocksBefore = 16 + iComponent * (2 << color_format);

                    switch (color_format)
                    {
                    case CHROMA_FORMAT_420:
                        DECODE_EXTERNAL_CHROMA_BLOCK_CABAC(0, 0, 0, 2)
                        DECODE_TOP_CHROMA_BLOCK_CABAC(1, 0, 1, 0, 3)
                        DECODE_LEFT_CHROMA_BLOCK_CABAC(0, 1, 2, 0)
                        DECODE_INTERNAL_CHROMA_BLOCK_CABAC(1, 1, 3, 2, 1)
                        break;

                    case CHROMA_FORMAT_422:
                        DECODE_EXTERNAL_CHROMA_BLOCK_CABAC(0, 0, 0, 6)
                        DECODE_TOP_CHROMA_BLOCK_CABAC(1, 0, 1, 0, 7)
                        DECODE_LEFT_CHROMA_BLOCK_CABAC(0, 1, 2, 0)
                        DECODE_INTERNAL_CHROMA_BLOCK_CABAC(1, 1, 3, 2, 1)
                        DECODE_LEFT_CHROMA_BLOCK_CABAC(0, 2, 4, 2)
                        DECODE_INTERNAL_CHROMA_BLOCK_CABAC(1, 2, 5, 4, 3)
                        DECODE_LEFT_CHROMA_BLOCK_CABAC(0, 3, 6, 4)
                        DECODE_INTERNAL_CHROMA_BLOCK_CABAC(1, 3, 7, 6, 5)
                        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;
        }

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

template <typename Coeffs, typename PlaneY, typename PlaneUV, Ipp32s color_format, Ipp32s is_field>
class ResidualDecoderPCM
{
public:
    typedef PlaneY * PlanePtrY;
    typedef PlaneUV * PlanePtrUV;
    typedef Coeffs *  CoeffsPtr;

    virtual ~ResidualDecoderPCM(){}

    ///////////////////////////////////////////////////////////////////////////////
    // decodePCMCoefficients
    //
    // Extracts raw coefficients from bitstream by:
    //  a) byte aligning bitstream pointer
    //  b) copying bitstream pointer to m_pCoeffBlocksWrite
    //  c) advancing bitstream pointer by 256+128 bytes
    //
    //    Also initializes NumCoef buffers for correct use in future MBs.
    //
    /////////////////////////////
    // Decode the coefficients for a PCM macroblock, placing them
    // in m_pCoeffBlocksBuf.
    void DecodeCoefficients_PCM(H264SegmentDecoderMultiThreaded * sd)
    {
        static const Ipp32u num_coeffs[4] = {256,384,512,768};

        Ipp32u length = num_coeffs[color_format];
        // number of raw coeff bits
        // to write pointer to non-aligned m_pCoeffBlocksWrite
        sd->m_cur_mb.LocalMacroblockInfo->QP = 0;

        PlanePtrY pCoeffBlocksWrite_Y = reinterpret_cast<PlanePtrY> (sd->m_pCoeffBlocksWrite);

        if (sd->m_pPicParamSet->entropy_coding_mode)
        {
            sd->m_pBitStream->TerminateDecode_CABAC();
        }
        else
        {
            sd->m_pBitStream->AlignPointerRight();
        }

        Ipp32u i;
        for (i = 0; i < 256; i++)
        {
            pCoeffBlocksWrite_Y[i] = (PlaneY) sd->m_pBitStream->GetBits(sd->bit_depth_luma);
        }

        sd->m_pCoeffBlocksWrite = (UMC::CoeffsPtrCommon)((Ipp8u*)sd->m_pCoeffBlocksWrite +
                        256*sizeof(PlaneY));

        if (color_format)
        {
            PlanePtrUV pCoeffBlocksWrite_UV = (PlanePtrUV) (sd->m_pCoeffBlocksWrite);
            for (i = 0; i < length - 256; i++)
            {
                pCoeffBlocksWrite_UV[i] = (PlaneUV) sd->m_pBitStream->GetBits(sd->bit_depth_chroma);
            }

            memset(sd->m_mbinfo.MacroblockCoeffsInfo[sd->m_CurMBAddr].numCoeff, 16, 48);//set correct numcoeffs

            if(sd->m_pPicParamSet->entropy_coding_mode)
            {
                sd->m_pBitStream->InitializeDecodingEngine_CABAC();
            }

            sd->m_pCoeffBlocksWrite = (UMC::CoeffsPtrCommon)((Ipp8u*)sd->m_pCoeffBlocksWrite +
                            (length - 256)*sizeof(PlaneUV));
        }
    } // void DecodeCoefficients_PCM(Ipp8u color_format)
};

} // namespace UMC

#endif // __UMC_H264_RESIDUAL_DECODER_TEMPLATES_H
#endif // UMC_ENABLE_H264_VIDEO_DECODER