umc_h264_segment_decoder_decode_mb_types_cabac.cpp

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

            // macroblock has I_16x16 type
            if (0 == m_pBitStream->DecodeSymbolEnd_CABAC())
            {
                Ipp32u code, mb_type;

                // luma CBP bit
                if (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 4))
                {
                    m_cur_mb.LocalMacroblockInfo->cbp = 0x0f;
                    mb_type = 16;
                }
                else
                {
                    m_cur_mb.LocalMacroblockInfo->cbp = 0x00;
                    mb_type = 0;
                }

                // chroma CBP bits
                if (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 5))
                {
                    if (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 5))
                    {
                        m_cur_mb.LocalMacroblockInfo->cbp |= 0x20;
                        mb_type |= 12;
                    }
                    else
                    {
                        m_cur_mb.LocalMacroblockInfo->cbp |= 0x10;
                        mb_type |= 8;
                    }
                }

                // prediction bits
                code = m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 6);
                code = (code << 1) |
                       m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 6);
                mb_type |= code;

                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTRA_16x16;
                original_mb_type = (Ipp8u) mb_type;
            }
            else
            {
                // we have I_PCM macroblock type
                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_PCM;
            }

        }
    }

} // void H264SegmentDecoder::DecodeMBTypePSlice_CABAC(void)

static
Ipp8u LargeSubMBSubDirBSlice[][2] =
{
    {D_DIR_FWD, D_DIR_FWD},
    {D_DIR_BWD, D_DIR_BWD},
    {D_DIR_FWD, D_DIR_BWD},
    {D_DIR_BWD, D_DIR_FWD},

    {D_DIR_FWD, D_DIR_BIDIR},
    {D_DIR_BWD, D_DIR_BIDIR},
    {D_DIR_BIDIR, D_DIR_FWD},
    {D_DIR_BIDIR, D_DIR_BWD},
    {D_DIR_BIDIR, D_DIR_BIDIR}
};

static
Ipp8u SmallSubMBSubDirBSlice[16] =
{
    (Ipp8u) -1,
    (Ipp8u) -1,
    D_DIR_FWD,
    D_DIR_FWD,
    D_DIR_FWD,
    D_DIR_FWD,
    D_DIR_BWD,
    D_DIR_BWD,
    D_DIR_BWD,
    D_DIR_BIDIR,
    D_DIR_BIDIR,
    D_DIR_FWD,
    D_DIR_BWD,
    D_DIR_BWD,
    D_DIR_BIDIR,
    D_DIR_BIDIR
};

static
Ipp8u SmallSubMBSubDivBSlice[16] =
{
    (Ipp8u) -1,
    (Ipp8u) -1,
    SBTYPE_8x4,
    SBTYPE_8x4,
    SBTYPE_4x8,
    SBTYPE_4x8,
    SBTYPE_8x4,
    SBTYPE_8x4,
    SBTYPE_4x8,
    SBTYPE_8x4,
    SBTYPE_4x8,
    SBTYPE_4x4,
    SBTYPE_4x4,
    SBTYPE_4x4,
    SBTYPE_4x4,
    SBTYPE_4x4
};

void H264SegmentDecoder::DecodeMBTypeBSlice_CABAC(void)
{
    Ipp32s ctxIdxInc;

    // calculate context index increment
    {
        Ipp32s condTermFlagA = 0, condTermFlagB = 0;
        Ipp32s nMBNum;

        // obtain left macroblock information
        nMBNum = m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num;
        if (0 <= nMBNum)
        {
            if (!GetMBDirectSkipFlag(m_gmbinfo->mbs[nMBNum]))
                condTermFlagA = 1;
        }

        // obtain above macroblock information
        nMBNum = m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num;
        if (0 <= nMBNum)
        {
            if (!GetMBDirectSkipFlag(m_gmbinfo->mbs[nMBNum]))
                condTermFlagB = 1;
        }

        ctxIdxInc = condTermFlagA + condTermFlagB;
    }

    // for translation bin string into mb type
    // see table 9-28 of the h264 standard

    // decode the type
    if (0 == m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] +
                                                 ctxIdxInc))
    {
        // B_Direct_16x16 type
        m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_DIRECT;
        pSetMBDirectFlag(m_cur_mb.GlobalMacroblockInfo);
        /*m_cur_mb.GlobalMacroblockInfo->sbtype[0] =
        m_cur_mb.GlobalMacroblockInfo->sbtype[1] =
        m_cur_mb.GlobalMacroblockInfo->sbtype[2] =
        m_cur_mb.GlobalMacroblockInfo->sbtype[3] = SBTYPE_DIRECT; DEBUG : we could set it later*/
    }
    else if (0 == m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] +
                                                      3))
    {
        // B_L0_16x16 & B_L1_16x16 types
        if (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5))
        {
            m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_BACKWARD;
        }
        else
        {
            m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_FORWARD;
        }
    }
    else
    {
        Ipp32u code;

        // get next 4 bins
        code = m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 4);
        code = m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5) +
               code * 2;
        code = m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5) +
               code * 2;
        code = m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5) +
               code * 2;

        if (0 == code)
        {
            // B_Bi_16x16 type
            m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_BIDIR;
        }
        else if (7 >= code)
        {
            if (code & 1)
                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTER_16x8;
            else
                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTER_8x16;

            // set the sub directions
            code = (code - 1) >> 1;
            m_cur_mb.LocalMacroblockInfo->sbdir[0] = LargeSubMBSubDirBSlice[code][0];
            m_cur_mb.LocalMacroblockInfo->sbdir[1] = LargeSubMBSubDirBSlice[code][1];
        }
        else if (14 == code)
        {
            m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTER_8x16;
            m_cur_mb.LocalMacroblockInfo->sbdir[0] = D_DIR_BWD;
            m_cur_mb.LocalMacroblockInfo->sbdir[1] = D_DIR_FWD;
        }
        else if (15 == code)
        {
            Ipp32s iSubBlock;

            // block has 8x8 subdivision
            m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTER_8x8;

            // we need to decode sub directions
            for (iSubBlock = 0; iSubBlock < 4; iSubBlock += 1)
            {
                // for translation bin string into sub-macroblock type
                // see table 9-29 of the h264 standard

                // the subblock has the direct type
                if (0 == m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]))
                {
                    m_cur_mb.GlobalMacroblockInfo->sbtype[iSubBlock] = SBTYPE_DIRECT;
                    m_cur_mb.LocalMacroblockInfo->sbdir[iSubBlock] = D_DIR_DIRECT;
                }
                // the subblock has 8x8 subdivision
                else if (0 == m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B] + 1))
                {
                    m_cur_mb.GlobalMacroblockInfo->sbtype[iSubBlock] = SBTYPE_8x8;
                    if (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B] + 3))
                        m_cur_mb.LocalMacroblockInfo->sbdir[iSubBlock] = D_DIR_BWD;
                    else
                        m_cur_mb.LocalMacroblockInfo->sbdir[iSubBlock] = D_DIR_FWD;
                }
                else
                {
                    code = m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B] + 2);
                    code = m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B] + 3) +
                           code * 2;
                    code = m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B] + 3) +
                           code * 2;

                    if (0 == code)
                    {
                        m_cur_mb.GlobalMacroblockInfo->sbtype[iSubBlock] = SBTYPE_8x8;
                        m_cur_mb.LocalMacroblockInfo->sbdir[iSubBlock] = D_DIR_BIDIR;
                    }
                    else
                    {
                        if ((4 == code) || (5 == code))
                        {
                            code = m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B] + 3) +
                                   code * 2;
                        }
                        else
                            code += code;

                        // get subdivision and directions
                        m_cur_mb.GlobalMacroblockInfo->sbtype[iSubBlock] = SmallSubMBSubDivBSlice[code];
                        m_cur_mb.LocalMacroblockInfo->sbdir[iSubBlock] = SmallSubMBSubDirBSlice[code];
                    }
                }
            }
        }
        else if (13 != code)
        {
            code = m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5) +
                   code * 2;

            if (code & 1)
                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTER_8x16;
            else
                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTER_16x8;

            // set the sub directions
            code = (code >> 1) & 0x07;
            m_cur_mb.LocalMacroblockInfo->sbdir[0] = LargeSubMBSubDirBSlice[4 + code][0];
            m_cur_mb.LocalMacroblockInfo->sbdir[1] = LargeSubMBSubDirBSlice[4 + code][1];
        }
        else
        {
            // macroblock has I_NxN type
            if (0 == m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] +
                                                         5))
            {
                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTRA;
            }
            // macroblock has I_16x16 type
            else if (0 == m_pBitStream->DecodeSymbolEnd_CABAC())
            {
                Ipp32u mb_type;

                // luma CBP bit
                if (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6))
                {
                    m_cur_mb.LocalMacroblockInfo->cbp = 0x0f;
                    mb_type = 16;
                }
                else
                {
                    m_cur_mb.LocalMacroblockInfo->cbp = 0x00;
                    mb_type = 0;
                }

                // chroma CBP bits
                if (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 7))
                {
                    if (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 7))
                    {
                        m_cur_mb.LocalMacroblockInfo->cbp |= 0x20;
                        mb_type |= 12;
                    }
                    else
                    {
                        m_cur_mb.LocalMacroblockInfo->cbp |= 0x10;
                        mb_type |= 8;
                    }
                }

                // prediction bits
                code = m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 8);
                code = (code << 1) |
                       m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 8);
                mb_type |= code;

                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTRA_16x16;
                original_mb_type = (Ipp8u) mb_type;
            }
            // macroblock has PCM type
            else
            {
                // we have I_PCM macroblock type
                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_PCM;
            }
        }
    }

} // void H264SegmentDecoder::DecodeMBTypeBSlice_CABAC(void)

} // namespace UMC
#endif // UMC_ENABLE_H264_VIDEO_DECODER