umc_h264_segment_decoder_templates.h

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

            return;
        }

        // decode macroblock field flag
        if (sd->m_isMBAFF)
        {
            if (0 == (sd->m_CurMBAddr & 1))
                sd->DecodeMBFieldDecodingFlag_CAVLC();
        }
        else
            pSetMBFieldDecodingFlag(sd->m_cur_mb.GlobalMacroblockInfo, 0);

        sd->UpdateNeighbouringAddresses();
        ColorSpecific<color_format, Coeffs, PlaneY, PlaneUV, is_field>::UpdateNeighbouringBlocks(sd);

        // First decode the "macroblock header", e.g., macroblock type,
        // intra-coding types.
        sd->DecodeMBTypePSlice_CAVLC();

        // decode macroblock having P type
        if (MBTYPE_PCM < sd->m_cur_mb.GlobalMacroblockInfo->mbtype)
        {
            DecodeMacroblock_P_CAVLC(sd);
        }
        else
        {
            memset((void *) sd->m_cur_mb.RefIdxs[0], -1, sizeof(H264DecoderMacroblockRefIdxs));
            memset((void *) sd->m_cur_mb.MVs[0], 0, sizeof(H264DecoderMacroblockMVs));

            // decode macroblock having I type
            if (MBTYPE_PCM > sd->m_cur_mb.GlobalMacroblockInfo->mbtype)
                DecodeMacroblock_I_CAVLC(sd);
            // macroblock has PCM type
            else
                DecodeMacroblock_PCM(sd);
        }

    } // void DecodeMacroblock_PSlice_CAVLC(H264SegmentDecoderMultiThreaded *sd)

    void DecodeMacroblock_BSlice_CAVLC(H264SegmentDecoderMultiThreaded *sd)
    {
        // reset macroblock info
        memset(sd->m_cur_mb.LocalMacroblockInfo, 0, sizeof(H264DecoderMacroblockLocalInfo));
        memset(sd->m_cur_mb.GlobalMacroblockInfo->sbtype, 0, sizeof(sd->m_cur_mb.GlobalMacroblockInfo->sbtype));
        sd->m_cur_mb.LocalMacroblockInfo->QP = (Ipp8s) sd->m_QuantPrev;
        sd->m_cur_mb.GlobalMacroblockInfo->slice_id = (Ipp16s) sd->m_pSlice->GetSliceNum();

        if (0 == sd->m_MBSkipCount)
            sd->m_MBSkipCount = sd->DecodeMBSkipRun_CAVLC();
        else
            sd->m_MBSkipCount -= 1;

        if (0 < sd->m_MBSkipCount)
        {
            // reset macroblock variables
            sd->m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_SKIPPED;
            pSetMBSkippedFlag(sd->m_cur_mb.GlobalMacroblockInfo);
            sd->m_prev_dquant = 0;

            if ((sd->m_isMBAFF) &&
                (0 == (sd->m_CurMBAddr & 1)))
            {
                // but we don't know the spatial structure of the current macroblock.
                // we need to decode next macroblock for obtaining the structure.
                if (1 == sd->m_MBSkipCount)
                {
                    sd->m_CurMBAddr += 1;
                    sd->m_CurMB_Y += 1;
                    // the next macroblock isn't skipped, obtain the structure
                    sd->DecodeMBFieldDecodingFlag_CAVLC();
                    // the next macroblock is skipped too
                    sd->m_CurMBAddr -= 1;
                    sd->m_CurMB_Y -= 1;
                }
                else
                    sd->DecodeMBFieldDecodingFlag();

                sd->UpdateNeighbouringAddresses();
            }
            else
            {
                if (sd->m_IsUseSpatialDirectMode)
                {
                    sd->UpdateNeighbouringAddresses();
                }
            }

            if (sd->m_IsUseSpatialDirectMode)
            {
                ColorSpecific<color_format, Coeffs, PlaneY, PlaneUV, is_field>::UpdateNeighbouringBlocks(sd);
            }

            sd->DecodeDirectMotionVectors(true);
            return;
        }

        // decode macroblock field flag
        if (sd->m_isMBAFF)
        {
            if (0 == (sd->m_CurMBAddr & 1))
                sd->DecodeMBFieldDecodingFlag_CAVLC();
        }
        else
            pSetMBFieldDecodingFlag(sd->m_cur_mb.GlobalMacroblockInfo, 0);

        sd->UpdateNeighbouringAddresses();
        ColorSpecific<color_format, Coeffs, PlaneY, PlaneUV, is_field>::UpdateNeighbouringBlocks(sd);

        // First decode the "macroblock header", e.g., macroblock type,
        // intra-coding types.
        sd->DecodeMBTypeBSlice_CAVLC();

        // decode macroblock having P type
        if (MBTYPE_PCM < sd->m_cur_mb.GlobalMacroblockInfo->mbtype)
        {
            DecodeMacroblock_B_CAVLC(sd);
        }
        else
        {
            memset((void *) sd->m_cur_mb.RefIdxs[0], -1, sizeof(H264DecoderMacroblockRefIdxs));
            memset((void *) sd->m_cur_mb.RefIdxs[1], -1, sizeof(H264DecoderMacroblockRefIdxs));
            memset((void *) sd->m_cur_mb.MVs[0], 0, sizeof(H264DecoderMacroblockMVs));
            memset((void *) sd->m_cur_mb.MVs[1], 0, sizeof(H264DecoderMacroblockMVs));

            // decode macroblock having I type
            if (MBTYPE_PCM > sd->m_cur_mb.GlobalMacroblockInfo->mbtype)
                DecodeMacroblock_I_CAVLC(sd);
            // macroblock has PCM type
            else
                DecodeMacroblock_PCM(sd);
        }

    } // void DecodeMacroblock_BSlice_CAVLC(H264SegmentDecoderMultiThreaded *sd)

    void DecodeMacroblock_I_CABAC(H264SegmentDecoderMultiThreaded *sd)
    {
        bool noSubMbPartSizeLessThan8x8Flag;

        // Reset buffer pointers to start
        // This works only as long as "batch size" for VLD and reconstruct
        // is the same. When/if want to make them different, need to change this.
        IntraType *pMBIntraTypes = sd->m_pMBIntraTypes + sd->m_CurMBAddr*NUM_INTRA_TYPE_ELEMENTS;

        // First decode the "macroblock header", e.g., macroblock type,
        // intra-coding types, motion vectors and CBP.

        // Get MB type, possibly change MBSKipCount to non-zero
        if (is_high_profile)
            noSubMbPartSizeLessThan8x8Flag = false;

        Ipp8u mbtype = sd->m_cur_mb.GlobalMacroblockInfo->mbtype;

        if (mbtype == MBTYPE_INTRA)
        {
            Ipp8u transform_size_8x8_mode_flag = 0;

            if ((is_high_profile) &&
                (sd->m_pPicParamSet->transform_8x8_mode_flag))
            {
                Ipp32s left_inc = sd->m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num>=0?
                    GetMB8x8TSFlag(sd->m_gmbinfo->mbs[sd->m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num]):0;
                Ipp32s top_inc = sd->m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num>=0?
                    GetMB8x8TSFlag(sd->m_gmbinfo->mbs[sd->m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num]):0;
                Ipp32u ctxIdxInc = top_inc + left_inc;
                transform_size_8x8_mode_flag  = (Ipp8u) sd->m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[TRANSFORM_SIZE_8X8_FLAG] + ctxIdxInc);
                pSetMB8x8TSFlag(sd->m_cur_mb.GlobalMacroblockInfo,transform_size_8x8_mode_flag);
            }

            if (transform_size_8x8_mode_flag)
                sd->DecodeIntraTypes8x8_CABAC(pMBIntraTypes, sd->m_IsUseConstrainedIntra);
            else
                sd->DecodeIntraTypes4x4_CABAC(pMBIntraTypes, sd->m_IsUseConstrainedIntra);
        }
        else
        {
            pMBIntraTypes[0] =
            pMBIntraTypes[1] =
            pMBIntraTypes[2] =
            pMBIntraTypes[3] = (sd->original_mb_type) & 0x03;
        }

        // decode chroma intra prediction mode
        if (color_format)
            sd->DecodeIntraPredChromaMode_CABAC();

        sd->DecodeEdgeType();

        // decode CBP
        if (mbtype != MBTYPE_INTRA_16x16)
        {
            sd->m_cur_mb.LocalMacroblockInfo->cbp = (Ipp8u) sd->DecodeCBP_CABAC(color_format);

            if (0 == sd->m_cur_mb.LocalMacroblockInfo->cbp)
            {
                sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_luma = 0;
                sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_chroma[0] = 0;
                sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_chroma[1] = 0;
                sd->m_prev_dquant = 0;
            }
        }

        // decode delta QP
        if ((sd->m_cur_mb.LocalMacroblockInfo->cbp) ||
            (mbtype == MBTYPE_INTRA_16x16))
        {
            if (is_high_profile && noSubMbPartSizeLessThan8x8Flag && sd->m_cur_mb.LocalMacroblockInfo->cbp&15)
            {
                Ipp8u transform_size_8x8_mode_flag = 0;
                if (sd->m_pPicParamSet->transform_8x8_mode_flag)
                {
                    Ipp32u ctxIdxInc;
                    Ipp32s left_inc = sd->m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num>=0?
                        GetMB8x8TSFlag(sd->m_gmbinfo->mbs[sd->m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num]):0;
                    Ipp32s top_inc = sd->m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num>=0?
                        GetMB8x8TSFlag(sd->m_gmbinfo->mbs[sd->m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num]):0;
                    ctxIdxInc = top_inc+left_inc;
                    transform_size_8x8_mode_flag  = (Ipp8u) sd->m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[TRANSFORM_SIZE_8X8_FLAG] + ctxIdxInc);
                    pSetMB8x8TSFlag(sd->m_cur_mb.GlobalMacroblockInfo,transform_size_8x8_mode_flag);
                }
            }

            // decode delta for quant value
            {
                sd->DecodeMBQPDelta_CABAC();
                sd->m_QuantPrev = sd->m_cur_mb.LocalMacroblockInfo->QP;
            }

            // Now, decode the coefficients
            if (MBTYPE_INTRA_16x16 != mbtype)
            {
                if (is_high_profile && pGetMB8x8TSFlag(sd->m_cur_mb.GlobalMacroblockInfo))
                    this->DecodeCoefficients8x8_CABAC(sd);
                else
                    this->DecodeCoefficients4x4_CABAC(sd);
            }
            else
                this->DecodeCoefficients16x16_CABAC(sd);
        }
    } // void DecodeMacroblock_I_CABAC(H264SegmentDecoderMultiThreaded *sd)

    void DecodeMacroblock_P_CABAC(H264SegmentDecoderMultiThreaded *sd)
    {
        bool noSubMbPartSizeLessThan8x8Flag;

        if (is_high_profile)
            noSubMbPartSizeLessThan8x8Flag = false;

        Ipp8u mbtype = sd->m_cur_mb.GlobalMacroblockInfo->mbtype;

        if (is_high_profile)
        {
            if (mbtype==MBTYPE_INTER_8x8 || mbtype==MBTYPE_INTER_8x8_REF0)
            {
                Ipp32s sum_partnum =
                    SbPartNumMinus1[sd->m_IsUseDirect8x8Inference][sd->m_cur_mb.GlobalMacroblockInfo->sbtype[0]]+
                    SbPartNumMinus1[sd->m_IsUseDirect8x8Inference][sd->m_cur_mb.GlobalMacroblockInfo->sbtype[1]]+
                    SbPartNumMinus1[sd->m_IsUseDirect8x8Inference][sd->m_cur_mb.GlobalMacroblockInfo->sbtype[2]]+
                    SbPartNumMinus1[sd->m_IsUseDirect8x8Inference][sd->m_cur_mb.GlobalMacroblockInfo->sbtype[3]];

                if (sum_partnum == 0)
                    noSubMbPartSizeLessThan8x8Flag = true;
            }
            else
                noSubMbPartSizeLessThan8x8Flag = true;
        }

        // Motion Vector Computation
        sd->DecodeMotionVectors_CABAC();

        // cbp
        sd->m_cur_mb.LocalMacroblockInfo->cbp = (Ipp8u) sd->DecodeCBP_CABAC(color_format);

        if (0 == sd->m_cur_mb.LocalMacroblockInfo->cbp)
        {
            sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_luma = 0;
            sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_chroma[0] = 0;
            sd->m_cur_mb.LocalMacroblockInfo->cbp4x4_chroma[1] = 0;
            sd->m_prev_dquant = 0;
        }
        else
        { // delta QP
            if (is_high_profile && noSubMbPartSizeLessThan8x8Flag && sd->m_cur_mb.LocalMacroblockInfo->cbp&15)
            {
                Ipp8u transform_size_8x8_mode_flag = 0;
                if (sd->m_pPicParamSet->transform_8x8_mode_flag)
                {
                    Ipp32u ctxIdxInc;
                    Ipp32s left_inc = sd->m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num>=0?
                        GetMB8x8TSFlag(sd->m_gmbinfo->mbs[sd->m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num]):0;
                    Ipp32s top_inc = sd->m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num>=0?
                        GetMB8x8TSFlag(sd->m_gmbinfo->mbs[sd->m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num]):0;
                    ctxIdxInc = top_inc+left_inc;
                    transform_size_8x8_mode_flag  = (Ipp8u) sd->m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[TRANSFORM_SIZE_8X8_FLAG] + ctxIdxInc);
                    pSetMB8x8TSFlag(sd->m_cur_mb.GlobalMacroblockInfo,transform_size_8x8_mode_flag);
                }
            }

            // decode delta for quant value
            sd->DecodeMBQPDelta_CABAC();