umc_h264_bs.cpp

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

            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;
}

template <class PixType, class CoeffsType>
Status CH264pBs<PixType,CoeffsType>::SubTypeInfo_CABAC(EnumSliceType SliceType,Ipp32s type)
{
    if (!IS_B_SLICE(SliceType))
    {
        switch (type)
        {
        case 0:
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_P_SP],1);
            break;
        case 1:
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_P_SP]+0,0);
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_P_SP]+1,0);
            break;
        case 2:
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_P_SP]+0,0);
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_P_SP]+1,1);
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_P_SP]+2,1);
            break;
        case 3:
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_P_SP]+0,0);
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_P_SP]+1,1);
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_P_SP]+2,0);
            break;
        }
    } else {
        if (!type)
        {
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+0,0);
            return UMC_OK;
        } else {
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+0,1);
            type--;
        }
        if (type<2)
        {
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+1,0);
            if (!type)
                EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+3,0);
            else
                EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+3,1);
        }
        else if (type<6)
        {
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+1,1);
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+2,0);
            if (((type-2)>>1)&1)
                EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+3,1);
            else
                EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+3,0);
            if ((type-2)&1)
                EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+3,1);
            else
                EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+3,0);
        } else {
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+1,1);
            EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+2,1);
            if (((type-6)>>2)&1)
            {
                EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+3,1);
                if ((type-6)&1)
                    EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+3,1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+3,0);
            } else {
                EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+3,0);
                if (((type-6)>>1)&1)
                    EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+3,1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+3,0);
                if ((type-6)&1)
                    EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+3,1);
                else
                    EncodeSingleBin_CABAC(ctxIdxOffset[SUB_MB_TYPE_B]+3,0);
            }
        }
    }
    return UMC_OK;
}

template <class PixType, class CoeffsType>
Status CH264pBs<PixType,CoeffsType>::IntraPredMode_CABAC(Ipp32s mode)
{
    if (mode == -1)
        EncodeSingleBin_CABAC(ctxIdxOffset[PREV_INTRA4X4_PRED_MODE_FLAG],1);
    else
    {
        EncodeSingleBin_CABAC(ctxIdxOffset[PREV_INTRA4X4_PRED_MODE_FLAG],0);
        EncodeSingleBin_CABAC(ctxIdxOffset[REM_INTRA4X4_PRED_MODE],(mode&1) != 0);
        EncodeSingleBin_CABAC(ctxIdxOffset[REM_INTRA4X4_PRED_MODE],(mode&2) != 0);
        EncodeSingleBin_CABAC(ctxIdxOffset[REM_INTRA4X4_PRED_MODE],(mode&4)!= 0);
    }
    return UMC_OK;
}

template <class PixType, class CoeffsType>
Status CH264pBs<PixType,CoeffsType>::ChromaIntraPredMode_CABAC(Ipp32s mode,Ipp32s left_p, Ipp32s top_p)
{
    if (!mode)
        EncodeSingleBin_CABAC(ctxIdxOffset[INTRA_CHROMA_PRED_MODE]+left_p+top_p,0);
    else
    {
        EncodeSingleBin_CABAC(ctxIdxOffset[INTRA_CHROMA_PRED_MODE]+left_p+top_p,1);
        EncodeUnaryRepresentedSymbol_CABAC(ctxIdxOffset[INTRA_CHROMA_PRED_MODE]+3,0,mode-1,2);
    }
    return UMC_OK;
}

template <class PixType, class CoeffsType>
Status CH264pBs<PixType,CoeffsType>::MVD_CABAC(Ipp32s vector, Ipp32s left_p, Ipp32s top_p, Ipp32s contextbase)
{
    Ipp32s ctx_mod;

    if (labs(left_p) + labs(top_p) < 3)
    {
        ctx_mod = 0;
    } else {
        if (labs(left_p) + labs(top_p) <= 32)
            ctx_mod = 1;
        else
            ctx_mod = 2;
    }

    if (vector== 0)
    {
        EncodeSingleBin_CABAC(ctxIdxOffset[contextbase]+ctx_mod, 0);
    } else {
        EncodeSingleBin_CABAC(ctxIdxOffset[contextbase]+ctx_mod, 1);
        EncodeExGRepresentedMVS_CABAC(ctxIdxOffset[contextbase]+3,labs(vector)-1, 3);
        EncodeBypass_CABAC(vector<0);
    }
    return UMC_OK;
}

/*!
 ****************************************************************************
 * \brief
 *    This function is used to arithmetically encode the coded
 *    block pattern of a given delta quant.
 ****************************************************************************
 */
template <class PixType, class CoeffsType>
Status CH264pBs<PixType,CoeffsType>::DQuant_CABAC(Ipp32s deltaQP,Ipp32s left_c)
{
    Ipp32s value;

    value = 2*labs(deltaQP)+(deltaQP<=0)-1;

    if (deltaQP==0)
    {
      EncodeSingleBin_CABAC(ctxIdxOffset[MB_QP_DELTA]+left_c,0);
    }
    else
    {
      EncodeSingleBin_CABAC(ctxIdxOffset[MB_QP_DELTA]+left_c,1);
      EncodeUnaryRepresentedSymbol_CABAC(ctxIdxOffset[MB_QP_DELTA]+2,1,value-1);
    }
    return UMC_OK;
}
  static Ipp32s sb_x[16] = {0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3};
  static Ipp32s sb_y[16] = {0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3};

#define WriteInsignificant for (j=prevnum+1;j<num;j++) EncodeSingleBin_CABAC(ctxIdxOffsetSig+j-c_data->uFirstCoeff,0)
#define WriteInsignificant_9_34 for (j=prevnum+1;j<num;j++) EncodeSingleBin_CABAC(ctxIdxOffsetSig+Table_9_34[!frame_block][j-c_data->uFirstCoeff],0)

template <class PixType, class CoeffsType>
Status CH264pBs<PixType,CoeffsType>::ResidualBlock_CABAC (T_Block_CABAC_Data<CoeffsType> *c_data,
                                      bool                            frame_block)
{
    Ipp32s ctxIdxOffsetSig;
    Ipp32s ctxIdxOffsetLastSig;
    Ipp32s ctxIdxOffsetAbsLevelMinus1;

    if(c_data->CtxBlockCat == 5) {
        if(frame_block) {
            ctxIdxOffsetSig = ctxIdxOffsetFrameCoded_BlockCat_5[SIGNIFICANT_COEFF_FLAG] + ctxIdxBlockCatOffset[SIGNIFICANT_COEFF_FLAG][c_data->CtxBlockCat];
            ctxIdxOffsetLastSig = ctxIdxOffsetFrameCoded_BlockCat_5[LAST_SIGNIFICANT_COEFF_FLAG] + ctxIdxBlockCatOffset[LAST_SIGNIFICANT_COEFF_FLAG][c_data->CtxBlockCat];
            ctxIdxOffsetAbsLevelMinus1 = ctxIdxOffsetFrameCoded_BlockCat_5[COEFF_ABS_LEVEL_MINUS1];
        }
        else {
            ctxIdxOffsetSig = ctxIdxOffsetFieldCoded_BlockCat_5[SIGNIFICANT_COEFF_FLAG] + ctxIdxBlockCatOffset[SIGNIFICANT_COEFF_FLAG][c_data->CtxBlockCat];
            ctxIdxOffsetLastSig = ctxIdxOffsetFieldCoded_BlockCat_5[LAST_SIGNIFICANT_COEFF_FLAG] + ctxIdxBlockCatOffset[LAST_SIGNIFICANT_COEFF_FLAG][c_data->CtxBlockCat];
            ctxIdxOffsetAbsLevelMinus1 = ctxIdxOffsetFieldCoded_BlockCat_5[COEFF_ABS_LEVEL_MINUS1];
        }
        Ipp32s i,j;
        for (i=0;i<c_data->uNumSigCoeffs;i++)
        {
            Ipp32s num=c_data->uSignificantMap[i];
            Ipp32s prevnum = i?c_data->uSignificantMap[i-1]:c_data->uFirstCoeff-1;
            if (num>prevnum+1)
            {
                WriteInsignificant_9_34;
            }
            if (num>=c_data->uLastCoeff) break;
            EncodeSingleBin_CABAC(ctxIdxOffsetSig + Table_9_34[!frame_block][num-c_data->uFirstCoeff],1);
            EncodeSingleBin_CABAC(ctxIdxOffsetLastSig + Table_9_34[2][num-c_data->uFirstCoeff],i==c_data->uNumSigCoeffs-1);
        }
    }
    else {
        if(frame_block) {
            ctxIdxOffsetSig = ctxIdxOffsetFrameCoded[SIGNIFICANT_COEFF_FLAG] + ctxIdxBlockCatOffset[SIGNIFICANT_COEFF_FLAG][c_data->CtxBlockCat];
            ctxIdxOffsetLastSig = ctxIdxOffsetFrameCoded[LAST_SIGNIFICANT_COEFF_FLAG] + ctxIdxBlockCatOffset[LAST_SIGNIFICANT_COEFF_FLAG][c_data->CtxBlockCat];
            ctxIdxOffsetAbsLevelMinus1 = ctxIdxOffsetFrameCoded[COEFF_ABS_LEVEL_MINUS1];
        }
        else {
            ctxIdxOffsetSig = ctxIdxOffsetFieldCoded[SIGNIFICANT_COEFF_FLAG] + ctxIdxBlockCatOffset[SIGNIFICANT_COEFF_FLAG][c_data->CtxBlockCat];
            ctxIdxOffsetLastSig = ctxIdxOffsetFieldCoded[LAST_SIGNIFICANT_COEFF_FLAG] + ctxIdxBlockCatOffset[LAST_SIGNIFICANT_COEFF_FLAG][c_data->CtxBlockCat];
            ctxIdxOffsetAbsLevelMinus1 = ctxIdxOffsetFieldCoded[COEFF_ABS_LEVEL_MINUS1];
        }

        Ipp32s i,j;
        for (i=0;i<c_data->uNumSigCoeffs;i++)
        {
            Ipp32s num=c_data->uSignificantMap[i];
            Ipp32s prevnum = i?c_data->uSignificantMap[i-1]:c_data->uFirstCoeff-1;
            if (num>prevnum+1)
            {
                if( c_data->CtxBlockCat == 3 ){
                    for (j=prevnum+1;j<num;j++) EncodeSingleBin_CABAC(ctxIdxOffsetSig+MIN(((j-c_data->uFirstCoeff)>>num8x8Cshift2),2),0);
                }else
                    WriteInsignificant;
            }
            if (num>=c_data->uLastCoeff) break;
            if( c_data->CtxBlockCat == 3 ){
                EncodeSingleBin_CABAC(ctxIdxOffsetSig+MIN(((num-c_data->uFirstCoeff)>>num8x8Cshift2),2),1);
                EncodeSingleBin_CABAC(ctxIdxOffsetLastSig+MIN(((num-c_data->uFirstCoeff)>>num8x8Cshift2),2),i==c_data->uNumSigCoeffs-1);
            }else{
                EncodeSingleBin_CABAC(ctxIdxOffsetSig+num-c_data->uFirstCoeff,1);
                EncodeSingleBin_CABAC(ctxIdxOffsetLastSig+num-c_data->uFirstCoeff,i==c_data->uNumSigCoeffs-1);
            }
        }
    }
    Ipp32s i;
    Ipp32s ctxinc1 = 1;
    Ipp32s ctxincg1 = 0;
    Ipp32s CtxInc;
    for (i=c_data->uNumSigCoeffs-1; i>=0; i--)
    {
        Ipp32s coef=c_data->uSignificantLevels[i];
        CtxInc = IPP_MIN(ctxinc1,4);
        EncodeSingleBin_CABAC(ctxIdxOffsetAbsLevelMinus1 + ctxIdxBlockCatOffset[COEFF_ABS_LEVEL_MINUS1][