umc_h264_bs.cpp

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

    {
        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;
}
Status CH264pBs::IntraPredMode_CABAC(int 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;
}
Status CH264pBs::ChromaIntraPredMode_CABAC(int mode,int left_p, int 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;
}


Status CH264pBs::MVD_CABAC(int vector,int left_p,int top_p,int contextbase)
{

    int 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.
 ****************************************************************************
 */
Status CH264pBs::DQuant_CABAC(int deltaQP,int left_c)
{
    int 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 int sb_x[16] = {0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3};
  static int sb_y[16] = {0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3};
#define BIT_SET(x,n)  ((int)(((x)&(1<<(n)))>>(n)))

Status CH264pBs::CodedBlockFlagLumaDC(T_EncodeMBData *curMB, T_EncodeMBData *leftMB,T_EncodeMBData *topMB, bool cbpbit)
{
    int upper_bit   = IS_TRUEINTRA_MBTYPE(curMB->uMBType);
    int left_bit    = IS_TRUEINTRA_MBTYPE(curMB->uMBType);
    int CtxInc;
    if (cbpbit)
    {
        curMB->cbp_bits   |= 1;
    }
    if (topMB)
    {
        upper_bit = BIT_SET(topMB->cbp_bits,0);
    }
    if (leftMB)
    {
        left_bit = BIT_SET(leftMB->cbp_bits,0);
    }
    CtxInc = 2*upper_bit+left_bit;

    EncodeSingleBin_CABAC(ctxIdxOffsetFrameCoded[CODED_BLOCK_FLAG]+ ctxIdxBlockCatOffset[CODED_BLOCK_FLAG][BLOCK_LUMA_DC_LEVELS]+CtxInc,cbpbit);
    return UMC_OK;
}
Status CH264pBs::CodedBlockFlagChromaDC(T_EncodeMBData *curMB, T_EncodeMBData *leftMB,T_EncodeMBData *topMB, int block_num,bool cbpbit)
{
    int upper_bit   = IS_TRUEINTRA_MBTYPE(curMB->uMBType);
    int left_bit    = IS_TRUEINTRA_MBTYPE(curMB->uMBType);
    int CtxInc;
    if (cbpbit)
    {
        curMB->cbp_bits   |= (1<<(17+block_num-U_DC_RLE));
    }
    if (topMB)
    {
        upper_bit = BIT_SET(topMB->cbp_bits,17+block_num-U_DC_RLE);
    }
    if (leftMB)
    {
        left_bit = BIT_SET(leftMB->cbp_bits,17+block_num-U_DC_RLE);
    }
    CtxInc = 2*upper_bit+left_bit;

    EncodeSingleBin_CABAC(ctxIdxOffsetFrameCoded[CODED_BLOCK_FLAG]+ ctxIdxBlockCatOffset[CODED_BLOCK_FLAG][BLOCK_CHROMA_DC_LEVELS]+CtxInc,cbpbit);
    return UMC_OK;
}
Status CH264pBs::CodedBlockFlagLuma(T_EncodeMBData *curMB, T_EncodeMBData *leftMB,T_EncodeMBData *topMB,int block_num,int type, bool cbpbit)
{

    int bit         = 1 + sb_x[block_num] + 4*sb_y[block_num];
    int upper_bit   = IS_TRUEINTRA_MBTYPE(curMB->uMBType);
    int left_bit    = IS_TRUEINTRA_MBTYPE(curMB->uMBType);
    int CtxInc;


    if (cbpbit)
    {
        curMB->cbp_bits   |= (1<<bit);
    }

    //--- get bits from neighbouring blocks ---
    if (!sb_y[block_num])
    {
        if (topMB)
        {
            upper_bit = BIT_SET(topMB->cbp_bits,bit+12);
        }
    }
    else
    {
        upper_bit = BIT_SET(curMB->cbp_bits,bit-4);
    }
    if (!sb_x[block_num])
    {
        if (leftMB)
        {
            left_bit = BIT_SET(leftMB->cbp_bits,bit+3);
        }
    }
    else
    {
        left_bit = BIT_SET(curMB->cbp_bits,bit-1);
    }
    CtxInc = 2*upper_bit+left_bit;

    EncodeSingleBin_CABAC(ctxIdxOffsetFrameCoded[CODED_BLOCK_FLAG]+ ctxIdxBlockCatOffset[CODED_BLOCK_FLAG][type]+CtxInc,cbpbit);
    return UMC_OK;
}
Status CH264pBs::CodedBlockFlagChroma(T_EncodeMBData *curMB, T_EncodeMBData *leftMB,T_EncodeMBData *topMB,int block_num,bool cbpbit)
{

    int uvsel = block_num>=20;

    int upper_bit   = IS_TRUEINTRA_MBTYPE(curMB->uMBType);
    int left_bit    = IS_TRUEINTRA_MBTYPE(curMB->uMBType);
    int CtxInc;
    int crsb_y = (block_num-4*uvsel > 17);
    int crsb_x = (block_num & 1);
    int bit = uvsel ? 23 + 2 * crsb_y + crsb_x :
                          19 + 2 * crsb_y + crsb_x;

    if (cbpbit)
    {
        curMB->cbp_bits   |= (1<<bit);
    }

    //--- get bits from neighbouring blocks ---
    if (!crsb_y )
    {
        if (topMB)
        {
            upper_bit = BIT_SET(topMB->cbp_bits,bit + 2);
        }
    }
    else
    {
        upper_bit = BIT_SET(curMB->cbp_bits,bit - 2);
    }
    if (!crsb_x )
    {
        if (leftMB)
        {
            left_bit = BIT_SET(leftMB->cbp_bits,bit + 1);
        }
    }
    else
    {
        left_bit = BIT_SET(curMB->cbp_bits,bit-1);
    }
    CtxInc = 2*upper_bit+left_bit;

    EncodeSingleBin_CABAC(ctxIdxOffsetFrameCoded[CODED_BLOCK_FLAG]+ ctxIdxBlockCatOffset[CODED_BLOCK_FLAG][BLOCK_CHROMA_AC_LEVELS]+CtxInc,cbpbit);
    return UMC_OK;
}

Status CH264pBs::CBP_BIT_CABAC (bool cbpbit, int ctxbase,int ctxindex)
{
    EncodeSingleBin_CABAC(ctxbase+ctxindex,cbpbit);
    return UMC_OK;
}

Status CH264pBs::CBP_CABAC(T_EncodeMBData *curMB, T_EncodeMBData *leftMB,T_EncodeMBData *topMB)
{

  int left_c, top_c;
  int cbp = curMB->uCBP;
  int mask;

  int i, j;

    for(i = 0; i < 2; i++)
    {
        for(j = 0; j < 2; j++)
        {
            if(!i)
            {
                if (topMB)
                    top_c = (!(topMB->uCBP&(1<<(j + 2)))) ? 1 : 0;
                else
                    top_c = 0;
            }
            else
            {
                top_c = ((cbp & (1 << j)) == 0) ? 1 : 0;
            }

            if(!j)
            {
                if (leftMB)
                    left_c = (!(leftMB->uCBP &(1 << (2*i + 1)))) ? 1 : 0;
                else
                    left_c = 0;
            }
            else
            {
                left_c = ( ((cbp & (1 << (2*i))) == 0) ? 1 : 0);
            }

            mask = (1<<(2*i + j));

            long ctxIdxInc = left_c + 2 * top_c;
            EncodeSingleBin_CABAC(ctxIdxOffset[CODED_BLOCK_PATTERN_LUMA] + ctxIdxInc,(cbp&mask) != 0);
        }
    }

  // CHROMA part
    left_c = top_c = 0;
    if (topMB)
        top_c = (topMB->uCBP > 15) ?   1 : 0;
    else
      top_c = 0;
    if (leftMB)
        left_c = (leftMB->uCBP > 15) ? 1 : 0;

    long ctxIdxInc = left_c + 2 * top_c;
    EncodeSingleBin_CABAC(ctxIdxOffset[CODED_BLOCK_PATTERN_CHROMA] + ctxIdxInc,cbp>15);
    if (cbp>15)
    {
        top_c = 0;
        left_c = 0;
        if (topMB)
            top_c = ((topMB->uCBP>>4)==2) ?   1 : 0;
        if (leftMB)
            left_c = ((leftMB->uCBP>>4)==2) ? 1 : 0;

        ctxIdxInc = left_c + 2 * top_c;
        EncodeSingleBin_CABAC(ctxIdxOffset[CODED_BLOCK_PATTERN_CHROMA] + ctxIdxInc+4,((cbp>>4) == 2));
    }

    return UMC_OK;
}



#define WriteInsignificant for (j=prevnum+1;j<num;j++) EncodeSingleBin_CABAC(ctxIdxOffsetSig+j-c_data->uFirstCoeff,0)

Status CH264pBs::ResidualBlock_CABAC (T_Block_CABAC_Data *c_data,
                                           bool                frame_block)
{
    int ctxIdxOffsetSig;
    int ctxIdxOffsetLastSig;
    int ctxIdxOffsetAbsLevelMinus1;

    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 = ctxIdxOffsetFrameCoded[COEFF_ABS_LEVEL_MINUS1];
    }

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

        if (coef)
        {
            CtxInc = 5+min(ctxincg1,4);
            EncodeExGRepresentedLevels_CABAC(ctxIdxOffsetAbsLevelMinus1 + ctxIdxBlockCatOffset[COEFF_ABS_LEVEL_MINUS1][c_data->CtxBlockCat]+CtxInc, coef-1);
            ctxinc1 = 0;
            ctxincg1++;
        }
        else if (ctxinc1)
        {
            ctxinc1++;
        }
        EncodeBypass_CABAC(c_data->uSignificantSigns[i] != 0);
    }
    return UMC_OK;
}

} //namespace UMC