umc_h264_dec_decode_mb_types_cabac.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

} // void H264VideoDecoder::DecodeMBSkipAndFDF(Ipp32u *MBSkipFlag,

Status H264VideoDecoder::DecodeMBType_CABAC(
    Ipp32u *pMBIntraTypes,
    Ipp32u *MBSkipFlag,
    bool skip_next_fdf)
{
    // this variable used only in debug purposes

    Ipp32s uCodeNum;
    const Ipp8u ICBPTAB[6] = {0,16,32,15,31,47};
    Status status = UMC_OK;
    //    int left_c, top_c;

    switch(m_CurSliceHeader.slice_type)
    {
    case INTRASLICE:
        uCodeNum = Intra_MB_type_CABAC(/*pMB*/);
        if (uCodeNum == 0)
            m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTRA;
        else if (uCodeNum == 25)
            m_cur_mb.GlobalMacroblockInfo->mbtype  = MBTYPE_PCM;
        else
        {
            m_cur_mb.GlobalMacroblockInfo->mbtype  = MBTYPE_INTRA_16x16;
            uCodeNum--;
            m_cur_mb.LocalMacroblockInfo->cbp = ICBPTAB[(uCodeNum)>>2];
            //pMB->i16mode = (uCodeNum) & 0x03;
            pMBIntraTypes[0] = pMBIntraTypes[1] = pMBIntraTypes[2] =
                pMBIntraTypes[3] = (uCodeNum) & 0x03;
        }
        break;
    case PREDSLICE:
    case S_PREDSLICE:
        {
            if (!skip_next_fdf)
            {
                DecodeMBSkipAndFDF(MBSkipFlag,0);
            }
            if (!*MBSkipFlag)
            {
                uCodeNum = P_Picture_MB_type_CABAC();
            }
            else
            {
                goto done;
            }

            switch (uCodeNum)
            {
            case 0:
                // 16x16
                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_FORWARD;

                break;
            case 1:
                // 16x8
                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTER_16x8;
                break;
            case 2:
                // 8x16
                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTER_8x16;
                break;
            case 3:
                // 8x8
                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTER_8x8;
                {
                    // read subblock types
                    Ipp32u subblock;
                    Ipp8u sbtype;

                    for (subblock=0; subblock<4; subblock++)
                    {

                        //block type decoding
                        long ctxIdxInc = 0;
                        if (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_P_SP] + ctxIdxInc))
                        {
                            uCodeNum = 0;
                        }
                        else
                        {
                            ctxIdxInc = 1;
                            if (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_P_SP] + ctxIdxInc))
                            {
                                ctxIdxInc = 2;
                                if (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_P_SP] + ctxIdxInc))
                                    uCodeNum = 2;
                                else
                                    uCodeNum = 3;
                            }
                            else
                                uCodeNum = 1;
                        }

                        switch (uCodeNum)
                        {
                        case 0:
                            sbtype = SBTYPE_8x8;
                            break;
                        case 1:
                            sbtype = SBTYPE_8x4;
                            break;
                        case 2:
                            sbtype = SBTYPE_4x8;
                            break;
                        case 3:
                            sbtype = SBTYPE_4x4;
                            break;
                        default:
                            status = UMC_BAD_STREAM;
                            break;
                        }
                        m_cur_mb.GlobalMacroblockInfo->sbtype[subblock] = sbtype;
                    }    // for subblock
                }    // 8x8 subblocks
                break;

            case 4:
                status = UMC_BAD_STREAM;
                break;

            case 5:
                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTRA;
                break;

            default:
                if (uCodeNum < 30)
                {
                    m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTRA_16x16;
                    uCodeNum -= 6;
                    m_cur_mb.LocalMacroblockInfo->cbp = ICBPTAB[(uCodeNum)>>2];
                    //pMB->i16mode = (uCodeNum) & 0x03;
                    pMBIntraTypes[0] = pMBIntraTypes[1] = pMBIntraTypes[2] =
                        pMBIntraTypes[3] = (uCodeNum) & 0x03;
                }
                else
                    m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_PCM;
                break;
            }//switch (uCodeNum)

        }
        break;

    case BPREDSLICE:
        {

            if (!skip_next_fdf)
            {
                DecodeMBSkipAndFDF(/*pMB,*/MBSkipFlag,1);
            }


            if (!*MBSkipFlag)
            {
                m_cur_mb.LocalMacroblockInfo->cbp = 1;
                uCodeNum = B_Picture_MB_type_CABAC(/*pMB*/);
            }
            else
            {
                goto done;
            }

            if (uCodeNum < 23)
            {
                m_cur_mb.GlobalMacroblockInfo->mbtype = CodeToMBTypeB[uCodeNum];
                if (m_cur_mb.GlobalMacroblockInfo->mbtype == MBTYPE_INTER_16x8 ||
                    m_cur_mb.GlobalMacroblockInfo->mbtype == MBTYPE_INTER_8x16)
                {
                    // direction for the two subblocks
                    m_cur_mb.LocalMacroblockInfo->sbdir[0] = CodeToBDir[(uCodeNum-4)>>1][0];
                    m_cur_mb.LocalMacroblockInfo->sbdir[1] = CodeToBDir[(uCodeNum-4)>>1][1];

                }
                if (m_cur_mb.GlobalMacroblockInfo->mbtype == MBTYPE_INTER_8x8)
                {
                    // read subblock types and prediction direction
                    // read subblock types
                    Ipp32u subblock;
                    Ipp8u sbtype;
                    for (subblock=0; subblock<4; subblock++)
                    {
                        //block type decoding
                        long ctxIdxInc = 0;
                        long lRes = 0;

                        uCodeNum = -1;
                        while (-1 == uCodeNum)
                        {
                            // get bin string by 1 bin
                            lRes = (lRes << 1) | m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B] + ctxIdxInc);

                            // switch on partial bin string
                            switch (lRes)
                            {
                            case 0x0000:
                                uCodeNum = 0;
                                ctxIdxInc = 1;
                                break;
                            case 0x0001:
                                ctxIdxInc = 1;
                                break;

                            case 0x0002:
                                ctxIdxInc = 3;
                                break;

                            case 0x0003:
                                ctxIdxInc = 2;
                                break;

                            case 0x0004:
                                uCodeNum = 1;
                                break;

                            case 0x0005:
                                uCodeNum = 2;
                                break;

                            case 0x0006:
                            case 0x0007:
                                ctxIdxInc = 3;
                                break;

                            case 0x0018:
                                uCodeNum = 3;
                                break;

                            case 0x0019:
                                uCodeNum = 4;
                                break;

                            case 0x001a:
                                uCodeNum = 5;
                                break;

                            case 0x001b:
                                uCodeNum = 6;
                                break;

                            case 0x001e:
                                uCodeNum = 11;
                                break;

                            case 0x001f:
                                uCodeNum = 12;
                                break;

                            case 0x0038:
                                uCodeNum = 7;
                                break;

                            case 0x0039:
                                uCodeNum = 8;
                                break;

                            case 0x003a:
                                uCodeNum = 9;
                                break;

                            case 0x003b:
                                uCodeNum = 10;
                                break;

                            };
                        };

                        switch (uCodeNum)
                        {
                        case 0://DIRECT
                            sbtype = SBTYPE_DIRECT;
                            m_cur_mb.LocalMacroblockInfo->sbdir[subblock] = D_DIR_DIRECT;
                            break;
                        case 1:
                            sbtype = SBTYPE_8x8;
                            m_cur_mb.LocalMacroblockInfo->sbdir[subblock] = D_DIR_FWD;
                            break;
                        case 2:
                            sbtype = SBTYPE_8x8;
                            m_cur_mb.LocalMacroblockInfo->sbdir[subblock] = D_DIR_BWD;
                            break;
                        case 3:
                            sbtype = SBTYPE_8x8;
                            m_cur_mb.LocalMacroblockInfo->sbdir[subblock] = D_DIR_BIDIR;
                            break;
                        case 4:
                            sbtype = SBTYPE_8x4;
                            m_cur_mb.LocalMacroblockInfo->sbdir[subblock] = D_DIR_FWD;
                            break;
                        case 5:
                            sbtype = SBTYPE_4x8;
                            m_cur_mb.LocalMacroblockInfo->sbdir[subblock] = D_DIR_FWD;
                            break;
                        case 6:
                            sbtype = SBTYPE_8x4;
                            m_cur_mb.LocalMacroblockInfo->sbdir[subblock] = D_DIR_BWD;
                            break;
                        case 7:
                            sbtype = SBTYPE_4x8;
                            m_cur_mb.LocalMacroblockInfo->sbdir[subblock] = D_DIR_BWD;
                            break;
                        case 8:
                            sbtype = SBTYPE_8x4;
                            m_cur_mb.LocalMacroblockInfo->sbdir[subblock] = D_DIR_BIDIR;
                            break;
                        case 9:
                            sbtype = SBTYPE_4x8;
                            m_cur_mb.LocalMacroblockInfo->sbdir[subblock] = D_DIR_BIDIR;
                            break;
                        case 10:
                            sbtype = SBTYPE_4x4;
                            m_cur_mb.LocalMacroblockInfo->sbdir[subblock] = D_DIR_FWD;
                            break;
                        case 11:
                            sbtype = SBTYPE_4x4;
                            m_cur_mb.LocalMacroblockInfo->sbdir[subblock] = D_DIR_BWD;
                            break;
                        case 12:
                            sbtype = SBTYPE_4x4;
                            m_cur_mb.LocalMacroblockInfo->sbdir[subblock] = D_DIR_BIDIR;
                            break;
                        default:
                            status = UMC_BAD_STREAM;
                            break;
                        }
                        m_cur_mb.GlobalMacroblockInfo->sbtype[subblock] = sbtype;
                    }    // for subblock

                }    // 8x8 subblocks
            }
            else if (uCodeNum == 23)
            {
                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTRA;
            }
            else if (uCodeNum < 48)
            {
                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_INTRA_16x16;
                uCodeNum -= 24;
                m_cur_mb.LocalMacroblockInfo->cbp = ICBPTAB[(uCodeNum)>>2];
                pMBIntraTypes[0] = pMBIntraTypes[1] = pMBIntraTypes[2] =
                    pMBIntraTypes[3] = (uCodeNum) & 0x03;
            }
            else if (uCodeNum == 48)
            {
                m_cur_mb.GlobalMacroblockInfo->mbtype = MBTYPE_PCM;
            }
            else
            {
                status = UMC_BAD_STREAM;
            }

        };
        break;
    }//switch slice_type

    if (m_cur_mb.GlobalMacroblockInfo->mbtype == MBTYPE_INTRA_16x16)
    {
        // 16x16 INTRA, code includes prediction mode and cbp info
        *pMBIntraTypes = (Ipp8u)(uCodeNum & 3);    // 0..3, mode
        if (uCodeNum > 11)
        {
            m_cur_mb.LocalMacroblockInfo->cbp4x4 |= D_CBP_LUMA_AC;  // at least one luma AC coeff. present
            uCodeNum -= 12;    // for chroma cbp extraction
        }
        uCodeNum >>= 2;
        if (uCodeNum > 0)
        {
            m_cur_mb.LocalMacroblockInfo->cbp4x4 |= D_CBP_CHROMA_DC; // DC chroma coeff present
            if (uCodeNum > 1)
            {
                m_cur_mb.LocalMacroblockInfo->cbp4x4 |= D_CBP_CHROMA_AC; // at least one AC chroma coeff.
            }
        }
    }    // INTRA_16x16

done:
    m_cur_mb.LocalMacroblockInfo->mbtypeBS = m_cur_mb.GlobalMacroblockInfo->mbtype;
    return status;

} // Status H264VideoDecoder::DecodeMBType_CABAC(Ipp32u *pMBIntraTypes,


} // namespace UMC