umc_h264_bs.cpp

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

        {3,2},{2,2},{2,2},{1,1},{1,3},{0,0},{0,0},{0,0} },  // 4 TotalZeros
    {   {3,5},{5,4},{3,4},{5,3},{5,3},{4,3},{3,2},
        {2,2},{1,3},{1,2},{3,3},{0,0},{0,0},{0,0},{0,0} },  // 5 TotalZeros
    {   {2,5},{4,4},{4,3},{4,3},{4,3},{3,3},{2,3},
        {2,3},{1,2},{1,4},{0,0},{0,0},{0,0},{0,0},{0,0} },  // 6 TotalZeros
    {   {3,6},{3,4},{3,3},{3,4},{3,3},{2,3},{1,4},
        {1,3},{1,5},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0} },  // 7 TotalZeros
    {   {2,6},{2,4},{2,4},{3,3},{2,4},{1,4},{1,3},
        {0,6},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0} },  // 8 TotalZeros
    {   {3,7},{3,5},{3,5},{2,4},{1,5},{1,3},{0,6},
        {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0} },  // 9 TotalZeros
    {   {2,7},{2,5},{2,5},{2,5},{1,4},{0,6},{0,0},
        {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0} },  // 10 TotalZeros
    {   {3,8},{3,6},{1,6},{1,5},{0,5},{0,0},{0,0},
        {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0} },  // 11 TotalZeros
    {   {2,8},{2,6},{1,5},{0,5},{0,0},{0,0},{0,0},
        {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0} },  // 12 TotalZeros
    {   {3,9},{1,6},{0,6},{0,0},{0,0},{0,0},{0,0},
        {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0} },  // 13 TotalZeros
    {   {2,9},{0,6},{0,0},{0,0},{0,0},{0,0},{0,0},
        {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0} },  // 14 TotalZeros
    {   {1,9},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
        {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0} }   // 15 TotalZeros
};

Status CH264pBs::PutTotalZeros(
                            Ipp32u uTotalZeros,
                            Ipp32u uTotalCoeffs,
                            bool bChromaDC
                            )
{
    Status ps = UMC_OK;

    uTotalCoeffs -= 1;

    if (bChromaDC) {

        PutBits(EncTotalZeros2x2[uTotalZeros][uTotalCoeffs].code,
            EncTotalZeros2x2[uTotalZeros][uTotalCoeffs].len);
    } else {
        PutBits(EncTotalZeros4x4[uTotalZeros][uTotalCoeffs].code,
            EncTotalZeros4x4[uTotalZeros][uTotalCoeffs].len);
    }

    return ps;
}

// Note, the following table is indexed by RunBefore & ZerosLeft-1
// Up to ZeroLeft = 7.  Above 7, Use 7.

static const struct_CodeEntry EncRuns[15][7] = {
    //    0     1     2     3     4     5     6+     <- (ZerosLeft-1)
    {   {1,1},{1,1},{3,2},{3,2},{3,2},{3,2},{7,3} }, // 0 RunBefore
    {   {0,1},{1,2},{2,2},{2,2},{2,2},{0,3},{6,3} }, // 1 RunBefore
    {   {0,0},{0,2},{1,2},{1,2},{3,3},{1,3},{5,3} }, // 2 RunBefore
    {   {0,0},{0,0},{0,2},{1,3},{2,3},{3,3},{4,3} }, // 3 RunBefore
    {   {0,0},{0,0},{0,0},{0,3},{1,3},{2,3},{3,3} }, // 4 RunBefore
    {   {0,0},{0,0},{0,0},{0,0},{0,3},{5,3},{2,3} }, // 5 RunBefore
    {   {0,0},{0,0},{0,0},{0,0},{0,0},{4,3},{1,3} }, // 6 RunBefore
    {   {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{1,4} }, // 7 RunBefore
    {   {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{1,5} }, // 8 RunBefore
    {   {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{1,6} }, // 9 RunBefore
    {   {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{1,7} }, // 10 RunBefore
    {   {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{1,8} }, // 11 RunBefore
    {   {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{1,9} }, // 12 RunBefore
    {   {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{1,10}}, // 13 RunBefore
    {   {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{1,11}}  // 14 RunBefore
};

Status CH264pBs::PutRuns(
                            Ipp8u* uRuns,
                            Ipp32u uTotalZeros,
                            Ipp32u uTotalCoeffs)
{
    Status ps = UMC_OK;
    Ipp32u cnt = 0;

    uTotalCoeffs--; // Don't write the last run, since it can be inferred.

    while (uTotalZeros && (cnt != uTotalCoeffs)) {
        Ipp32u zeros_idx = (uTotalZeros > 6) ? 6 : uTotalZeros-1;
        PutBits(EncRuns[uRuns[cnt]][zeros_idx].code,
            EncRuns[uRuns[cnt]][zeros_idx].len);
        uTotalZeros -= uRuns[cnt];
        cnt++;
    }

    return ps;
}

/**************************** cabac **********************************/
#if defined SPLIT_INTO_FIELDS
Status CH264pBs::MBFieldModeInfo_CABAC(int mb_field,int field_available_left,int field_available_above)
{
    if (mb_field==0)
        EncodeSingleBin_CABAC(field_available_left+field_available_above+ctxIdxOffset[MB_FIELD_DECODING_FLAG],0);
    else
        EncodeSingleBin_CABAC(field_available_left+field_available_above+ctxIdxOffset[MB_FIELD_DECODING_FLAG], 1);

    return UMC_OK;
}
#endif // SPLIT_INTO_FIELDS

Status CH264pBs::MBSkipFlagInfo_CABAC(EnumSliceType SliceType,
                                      T_EncodeMBData * , //cur_mb,
                                      T_EncodeMBData * left_mb,
                                      T_EncodeMBData * top_mb,
                                      bool skip_flag)
{
    int left_c=0, top_c = 0;

    if (IS_B_SLICE(SliceType))
    {
        if(left_mb && !(left_mb->uMBType== MBTYPE_DIRECT && left_mb->uCBP == 0))
            left_c = 1;

        if(top_mb &&  !(top_mb->uMBType == MBTYPE_DIRECT && top_mb->uCBP == 0))
            top_c = 1;
        EncodeSingleBin_CABAC (left_c+top_c+ctxIdxOffset[MB_SKIP_FLAG_B], skip_flag);
    }
    else
    {
        if(left_mb && left_mb->uMBSkipFlag==0)
            left_c = 1;

        if(top_mb &&  top_mb->uMBSkipFlag==0 )
            top_c = 1;
        EncodeSingleBin_CABAC (left_c+top_c+ctxIdxOffset[MB_SKIP_FLAG_P_SP], skip_flag);
    }
      return UMC_OK;
}

Status CH264pBs::MBTypeInfo_CABAC(EnumSliceType SliceType,int mb_type_cur,MB_Type type_cur, MB_Type type_left,MB_Type type_above )
{
    int a, b,c=0;
    int type_temp;
    int itype=mb_type_cur-1;int start_index = MB_TYPE_I;


    if(IS_INTRA_SLICE(SliceType))
    {
        b = (type_above >= NUMBER_OF_MBTYPES)?0:((type_above != MBTYPE_INTRA) ? 1 : 0 );
        a = (type_left >= NUMBER_OF_MBTYPES)?0:((type_left != MBTYPE_INTRA) ? 1 : 0 );
encoding_intra:

        if (type_cur==MBTYPE_INTRA) // 4x4 Intra
        {
            EncodeSingleBin_CABAC(ctxIdxOffset[start_index]+a+b,0);
        }
        else if( type_cur == MBTYPE_PCM) // PCM-MODE
        {
            EncodeSingleBin_CABAC(ctxIdxOffset[start_index]+a+b,1);
            EncodeFinalSingleBin_CABAC(1);
        }
        else // 16x16 Intra
        {
            EncodeSingleBin_CABAC(ctxIdxOffset[start_index]+a+b,1);
            EncodeFinalSingleBin_CABAC(0);
            EncodeSingleBin_CABAC(ctxIdxOffset[start_index] + 3+c,  itype/12 != 0); // coding of AC/no AC
            itype %= 12;
            if (itype<4)
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[start_index] + 4+c,  0);
            }
            else
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[start_index] + 4+c,  1);
                if (itype>=4 && itype<8)
                {
                    EncodeSingleBin_CABAC(ctxIdxOffset[start_index] + 5,  0);
                }
                else
                {
                    EncodeSingleBin_CABAC(ctxIdxOffset[start_index] + 5,  1);
                }
            }
            EncodeSingleBin_CABAC(ctxIdxOffset[start_index] + 6,  (itype&2) != 0 );
            EncodeSingleBin_CABAC(ctxIdxOffset[start_index] + 7-c,  (itype&1) != 0 );
        }
    }
    else // INTER
    {
        if (IS_B_SLICE(SliceType))
        {
            type_temp = mb_type_cur;
            b = (type_above >= NUMBER_OF_MBTYPES)?0:((type_above != MBTYPE_DIRECT) ? 1 : 0 );
            a = (type_left >= NUMBER_OF_MBTYPES)?0:((type_left != MBTYPE_DIRECT) ? 1 : 0 );
            if (mb_type_cur>=24) type_temp=24;

            if (type_temp==0)
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + a+b,  0);
            }
            else if (type_temp<=2)
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + a+b,  1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 3,  0);
                if (type_temp-1) EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  1);
                else      EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  0);
            }
            else if (type_temp<=10)
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + a+b,1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 3,  1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 4,  0);
                if (((type_temp-3)>>2)&0x01)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  0);
                if (((type_temp-3)>>1)&0x01)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  0);
                if ((type_temp-3)&0x01)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  0);
            }
            else if (type_temp==11 || type_temp==11*2)
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + a+b,1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 3,  1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 4,  1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  1);
                if (type_temp!=11)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  0);
            }
            else
            {
                if (type_temp > 22 ) type_temp--;

                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + a+b,1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 3,  1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 4,  1);

                if ((type_temp-12)&8)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  0);
                if ((type_temp-12)&4)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  0);
                if ((type_temp-12)&2)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  0);
                if ((type_temp-12)&1)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  0);
                //if (type_temp >12) type_temp++;
            }
        if( type_cur==MBTYPE_PCM )
        {
            EncodeFinalSingleBin_CABAC(1);
            return UMC_OK;
        }
        if(type_cur==MBTYPE_INTRA_16x16)
        {
            EncodeFinalSingleBin_CABAC(0);
            EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  (mb_type_cur-24)/12 != 0);
            mb_type_cur %= 12;

            type_temp = mb_type_cur >> 2;
            if (type_temp==0)
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 7,  0);
            }
            else
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 7,  1);
                if (type_temp==1)
                {
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 7,  0);
                }
                else
                {
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 7,  1);
                }
            }

            EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 8,  (mb_type_cur&2) != 0);
            EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 8,  (mb_type_cur&1) != 0);
        }

        }
        else // P slice
        {
            if (IS_INTRA_MBTYPE(type_cur))
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 0,  1);
                a=0;b=3;c=1;start_index = MB_TYPE_P_SP;itype-=5;
                goto encoding_intra;
            }
            else
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 0,  0);
                switch(mb_type_cur)
                {
                case 0:
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 1,  0);
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 2,  0);
                    break;
                case 1:
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 1,  1);
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 3,  1);
                    break;
                case 2:
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 1,  1);
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 3,  0);
                    break;
                case 3:
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 1,  0);
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 2,  1);
                    break;
                default:
                    return UMC_OPERATION_FAILED;
                }
            }
        }
        /*
        if (IS_B_SLICE(PicCodType))
        {
            if (type_temp==0)
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + a+b,  0);
            }
            else if (type_temp<=2)
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + a+b,  1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 4,  0);
                if (type_temp-1) EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  1);
                else      EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  0);
            }
            else if (type_temp<=10)
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + a+b,1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 4,  1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  0);
                if (((type_temp-3)>>2)&0x01)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  0);
                if (((type_temp-3)>>1)&0x01)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  0);
                if ((type_temp-3)&0x01)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  0);
            }
            else if (type_temp==11 || type_temp==11*2)
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + a+b,1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 4,  1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  1);
                if (type_temp!=11)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  0);
            }
            else
            {
            if (type_temp > 22 ) type_temp--;

                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + a+b,1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 4,  1);
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 5,  1);

                if (((type_temp-12)>>3)&1)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  0);
                if (((type_temp-12)>>2)&1)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  0);
                if (((type_temp-12)>>1)&1)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  0);
                if ((type_temp-12)&1)
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_B] + 6,  0);
                if (type_temp >12) type_temp++;
            }
        }

        if(type_temp==m16)
        {
            if( type_temp2==25 )
            {
                EncodeFinalSingleBin_CABAC(1);
                return UMC_OK;
            }
            EncodeFinalSingleBin_CABAC(0);

            type_temp = type_temp2/12;
            EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 8,  0);
            type_temp2 %= 12;

            type_temp = type_temp2 >> 2;
            if (type_temp==0)
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 9,  0);
            }
            else
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 9,  1);
                if (type_temp==1)
                {
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 9,  0);
                }
                else
                {
                    EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 9,  1);
                }
            }

            type_temp  = type_temp2 ;
            EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 10,  type_temp&2);
            EncodeSingleBin_CABAC(ctxIdxOffset[MB_TYPE_P_SP] + 10,  type_temp&1);
        }*/
    }
    return UMC_OK;
}

Status CH264pBs::SubTypeInfo_CABAC(EnumSliceType SliceType,int type)
{

    if (!IS_B_SLICE(SliceType))