umc_base_bitstream.cpp

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

    {{30, 10}, {42, -30}, {29, 15}},
    {{24, 22}, {40, -24}, {24, 25}},
    {{33, 19}, {49, -29}, {34, 22}},
    {{22, 32}, {38, -12}, {31, 16}},
    {{26, 31}, {40, -10}, {35, 18}},
    {{21, 41}, {38, -3}, {31, 28}},
    {{26, 44}, {46, -5}, {33, 41}},
    {{23, 47}, {31, 20}, {36, 28}},
    {{16, 65}, {29, 30}, {27, 47}},
    {{14, 71}, {25, 44}, {21, 62}},
    {{8, 60}, {12, 48}, {18, 31}},
    {{6, 63}, {11, 49}, {19, 26}},
    {{17, 65}, {26, 45}, {36, 24}},
    {{21, 24}, {22, 22}, {24, 23}},
    {{23, 20}, {23, 22}, {27, 16}},
    {{26, 23}, {27, 21}, {24, 30}},
    {{27, 32}, {33, 20}, {31, 29}},
    {{28, 23}, {26, 28}, {22, 41}},
    {{28, 24}, {30, 24}, {22, 42}},
    {{23, 40}, {27, 34}, {16, 60}},
    {{24, 32}, {18, 42}, {15, 52}},
    {{28, 29}, {25, 39}, {14, 60}},
    {{23, 42}, {18, 50}, {3, 78}},
    {{19, 57}, {12, 70}, {-16, 123}},
    {{22, 53}, {21, 54}, {21, 53}},
    {{22, 61}, {14, 71}, {22, 56}},
    {{11, 86}, {11, 83}, {25, 61}},
};

void CBaseBitstream::InitializeContextVariablesInter_CABAC(long SliceQPy, long cabac_init_idc)
{
    long l;

    // See subclause 9.3.1.1 of H.264 standard

    // Initialize context(s) for mb_skip_flag & mb_type (P & SP slices)
    // & sub_mb_pred (P & SP slices)
    for (l = 11;l <= 23;l += 1)
    {
        InitializeContext(  &(context_array[l]),
                            M_and_N_for_ctxIdx_11_23[l - 11][cabac_init_idc].m,
                            M_and_N_for_ctxIdx_11_23[l - 11][cabac_init_idc].n,
                            SliceQPy);
    };

    // Initialize context(s) for mb_skip_flag & mb_type (B slices)
    // & sub_mb_pred (B slices)
    for (l = 24;l <= 39;l += 1)
    {
        InitializeContext(  &(context_array[l]),
                            M_and_N_for_ctxIdx_24_39[l - 24][cabac_init_idc].m,
                            M_and_N_for_ctxIdx_24_39[l - 24][cabac_init_idc].n,
                            SliceQPy);
    };

    // Initialize context(s) for mvd_10 & mvd_11
    for (l = 40;l <= 53;l += 1)
    {
        InitializeContext(  &(context_array[l]),
                            M_and_N_for_ctxIdx_40_53[l - 40][cabac_init_idc].m,
                            M_and_N_for_ctxIdx_40_53[l - 40][cabac_init_idc].n,
                            SliceQPy);
    };

    // Initialize context(s) for ref_idx_10 & ref_idx_11
    for (l = 54;l <= 59;l += 1)
    {
        InitializeContext(  &(context_array[l]),
                            M_and_N_for_ctxIdx_54_59[l - 54][cabac_init_idc].m,
                            M_and_N_for_ctxIdx_54_59[l - 54][cabac_init_idc].n,
                            SliceQPy);
    };

    // Initialize context(s) for mb_qp_delta &
    // intra_chroma_pred_mode & prev_intra4x4_pred_mode_flag &
    // rem_intra4x4_pred_mode
    for (l = 60;l <= 69;l += 1)
    {
        InitializeContext(  &(context_array[l]),
                            M_and_N_for_ctxIdx_60_69[l - 60].m,
                            M_and_N_for_ctxIdx_60_69[l - 60].n,
                            SliceQPy);
    };

    // Initalize context(s) for mb_field_decoding_flag &
    // coded_block_pattern(luma) & coded_block_pattern(chroma) &
    // coded_block_flag (P, SP & B slices)
    for (l = 70;l <= 104;l += 1)
    {
        InitializeContext(  &(context_array[l]),
                            M_and_N_for_ctxIdx_70_104_inter[l - 70][cabac_init_idc].m,
                            M_and_N_for_ctxIdx_70_104_inter[l - 70][cabac_init_idc].n,
                            SliceQPy);
    };

    // Initalize context(s) for significant_coeff_flag[] (frame coded)
    for (l = 105;l <= 165;l += 1)
    {
        InitializeContext(  &(context_array[l]),
                            M_and_N_for_ctxIdx_105_165_inter[l - 105][cabac_init_idc].m,
                            M_and_N_for_ctxIdx_105_165_inter[l - 105][cabac_init_idc].n,
                            SliceQPy);
    };

    // Initalize context(s) for last_significant_coeff_flag[] (frame coded)
    for (l = 166;l <= 226;l += 1)
    {
        InitializeContext(  &(context_array[l]),
                            M_and_N_for_ctxIdx_166_226_inter[l - 166][cabac_init_idc].m,
                            M_and_N_for_ctxIdx_166_226_inter[l - 166][cabac_init_idc].n,
                            SliceQPy);
    };

    // Initalize context(s) for coeff_abs_level_minus1[]
    for (l = 227;l <= 275;l += 1)
    {
        InitializeContext(  &(context_array[l]),
                            M_and_N_for_ctxIdx_227_275_inter[l - 227][cabac_init_idc].m,
                            M_and_N_for_ctxIdx_227_275_inter[l - 227][cabac_init_idc].n,
                            SliceQPy);
    };

    // Initalize context(s) for significant_coeff_flag[] (field coded)
    for (l = 277;l <= 337;l += 1)
    {
        InitializeContext(  &(context_array[l]),
                            M_and_N_for_ctxIdx_277_337_inter[l - 277][cabac_init_idc].m,
                            M_and_N_for_ctxIdx_277_337_inter[l - 277][cabac_init_idc].n,
                            SliceQPy);
    };

    // Initalize context(s) for last_significant_coeff_flag[] (field coded)
    for (l = 338;l <= 398;l += 1)
    {
        InitializeContext(  &(context_array[l]),
                            M_and_N_for_ctxIdx_338_398_inter[l - 338][cabac_init_idc].m,
                            M_and_N_for_ctxIdx_338_398_inter[l - 338][cabac_init_idc].n,
                            SliceQPy);
    };
    ResetBitStream_CABAC();

}; //void CBaseBitstream::InitializeContextVariablesInter_CABAC(long SliceQPy, long cabac_init_idc)

void CBaseBitstream::ResetBitStream_CABAC(void)
{
    m_lcodIRange=ENC_HALF_RANGE-2;
    m_lcodIOffset = 0;
    m_nRegister = 0;
    m_nReadyBits = 9;
    m_nOutstandingBits = 0;
    m_nSymCnt = 0;
    ByteAlignWithOnes();

}; //void CBaseBitstream::ResetBitStream_CABAC(void)


void CBaseBitstream::WriteByte_CABAC(void)
{
    PutByteAligned((Ipp8u)m_nRegister);
    m_nRegister = 0;
    m_nReadyBits = 8;
//  m_nOutstandingBits = 0;

}; //void CBaseBitstream::Load16Bits_CABAC(void)

void CBaseBitstream::WriteBits_CABAC(long lNum,long code)
{
    do
    {
        WriteBit_CABAC(code&1);
        code>>=1;
    }while (--lNum>0);
    return ;

}; //long CBaseBitstream::WriteBits_CABAC(long lNum)

void CBaseBitstream::WriteBit_CABAC(bool code)
{
    m_nRegister<<=1;
    m_nRegister|=(int)code;
    m_nReadyBits--;
    if (0 == m_nReadyBits)
        WriteByte_CABAC();

    return;

}; //long CBaseBitstream::WriteBits_CABAC(long lNum)

void CBaseBitstream::WriteOutstandingBit_CABAC(bool code)
{
      WriteBit_CABAC(code);
      while (m_nOutstandingBits > 0)
      {
        m_nOutstandingBits--;
        WriteBit_CABAC(!code);
      }

    return;

}; //long CBaseBitstream::WriteBits_CABAC(long lNum)
void CBaseBitstream::EncodeSingleBin_CABAC(long ctxIdx,bool code)
{
    unsigned short &pStateIdx = context_array[ctxIdx].pStateIdx;
    bool &valMPS = context_array[ctxIdx].valMPS;
    long &codIOffset = m_lcodIOffset;
    long &codIRange = m_lcodIRange;
    long qCodIRangeIdx;
    long codIRangeLPS;
    qCodIRangeIdx = ((codIRange >> 6) & 0x03);
    codIRangeLPS = rangeTabLPS[pStateIdx][qCodIRangeIdx];

    codIRange -= codIRangeLPS;

    if (code != valMPS )
    {
        codIOffset += codIRange;
        codIRange = codIRangeLPS;

        if (0 == pStateIdx)
            valMPS = !valMPS;
        pStateIdx = transIdxLPS[pStateIdx];
    }
    else
        pStateIdx = transIdxMPS[pStateIdx];


  /* renormalisation */
    while (codIRange  < ENC_QUARTER_RANGE)
    {
        if (codIOffset >= ENC_HALF_RANGE)
        {
            WriteOutstandingBit_CABAC(1);
            codIOffset  -= ENC_HALF_RANGE;
        }
        else
            if (codIOffset < ENC_QUARTER_RANGE)
            {
                WriteOutstandingBit_CABAC(0);
            }
            else
            {
                m_nOutstandingBits++;
                codIOffset  -= ENC_QUARTER_RANGE;
            }
        codIOffset  <<= 1;
        codIRange <<= 1;
    }
    m_nSymCnt++;
    return;

}; //long CBaseBitstream::EncodeSingleBin_CABAC(long ctxIdx)

void CBaseBitstream::EncodeFinalSingleBin_CABAC(bool code)
{
    long &codIOffset = m_lcodIOffset;
    long &codIRange = m_lcodIRange;
    codIRange -=2;
    if (code)
    {
        codIOffset += codIRange ;
        codIRange  = 2;
    }

  /* renormalisation */
    while (codIRange  < ENC_QUARTER_RANGE)
    {
        if (codIOffset >= ENC_HALF_RANGE)
        {
            WriteOutstandingBit_CABAC(1);
            codIOffset  -= ENC_HALF_RANGE;
        }
        else
            if (codIOffset < ENC_QUARTER_RANGE)
            {
                WriteOutstandingBit_CABAC(0);
            }
            else
            {
                m_nOutstandingBits++;
                codIOffset  -= ENC_QUARTER_RANGE;
            }
        codIOffset  <<= 1;
        codIRange <<= 1;
    }
    m_nSymCnt++;
    return;

}; //long CBaseBitstream::EncodeSingleBin_CABAC(long ctxIdx)


void CBaseBitstream::EncodeBypass_CABAC(bool code)
{
    long &codIOffset = m_lcodIOffset;
    long &codIRange = m_lcodIRange;
    codIOffset*=2;

    if (code)
        codIOffset  += codIRange;

    if (codIOffset   >= ENC_FULL_RANGE)
    {
        WriteOutstandingBit_CABAC(1);
        codIOffset   -= ENC_FULL_RANGE;
    }
    else
        if (codIOffset < ENC_HALF_RANGE)
        {
            WriteOutstandingBit_CABAC(0);
        }
        else
        {
            m_nOutstandingBits++;
            codIOffset -= ENC_HALF_RANGE;
        }
    m_nSymCnt++;
    return;
}
#define FlushBitStream_CABAC while (m_nReadyBits!=8) WriteBit_CABAC(0)

void CBaseBitstream::TerminateEncode_CABAC()
{
    long &codIOffset = m_lcodIOffset;
    WriteOutstandingBit_CABAC((codIOffset >> (ENC_B_BITS-1)) & 1);
    WriteBit_CABAC((codIOffset  >> (ENC_B_BITS-2))&1);
    WriteBit_CABAC(1);
    FlushBitStream_CABAC;
    //ByteAlignWithZeros();
    return ;

};


void CBaseBitstream::EncodeUnaryRepresentedSymbol_CABAC(long ctxBase, long ctxIdx, long code,long suppremum)
{
  if (code==0)
  {
    EncodeSingleBin_CABAC(ctxBase, 0);
  }
  else
  {
    EncodeSingleBin_CABAC(ctxBase, 1);
    long temp=code;
    while ((--temp)>0)
        EncodeSingleBin_CABAC(ctxBase+ctxIdx, 1);
    if (code<suppremum)
        EncodeSingleBin_CABAC(ctxBase+ctxIdx, 0);
  }
  return;
}

void CBaseBitstream::EncodeExGRepresentedSymbol_CABAC(long code,long log2ex)
{
    for (;;)
    {
        if (code>= (1<<log2ex))
        {
            EncodeBypass_CABAC(1);
            code -= (1<<log2ex);
            log2ex++;
        }
        else
        {
            EncodeBypass_CABAC( 0);
                while (log2ex--)
                    EncodeBypass_CABAC((code>>log2ex)&1);
            return;
        }
    }
  return;
}

void CBaseBitstream::EncodeExGRepresentedLevels_CABAC(long ctxIdx, long code)
{

    int tempval,tempindex;

    if (code==0)
    {
        EncodeSingleBin_CABAC(ctxIdx, 0);
        return;
    }
    else
    {
        EncodeSingleBin_CABAC(ctxIdx, 1);
        tempval=code;
        tempindex=1;
        while (((--tempval)>0) && (++tempindex <= 13))
            EncodeSingleBin_CABAC(ctxIdx, 1);
        if (code < 13)
        {
            EncodeSingleBin_CABAC(ctxIdx, 0); ;
        }
        else
        {
            EncodeExGRepresentedSymbol_CABAC(code-13,0);
        }
    }
    return;
}

void CBaseBitstream::EncodeExGRepresentedMVS_CABAC(long ctxIdx, long code,long supp)
{
    long tempval,tempindex;
    int bin=1;
    int inc;

    if (code==0)
    {
        EncodeSingleBin_CABAC(ctxIdx, 0);
        return;
    }
    else
    {
        EncodeSingleBin_CABAC(ctxIdx, 1);
        tempval=code;
        tempindex=1;
        inc=1;
        while (((--tempval)>0) && (++tempindex <= 8))
        {
            EncodeSingleBin_CABAC(ctxIdx+inc, 1);
            if ((++bin)==2) inc++;
            if (bin==supp) inc++;
        }
        if (code < 8)
        {
            EncodeSingleBin_CABAC(ctxIdx+inc, 0); ;
        }
        else
        {
            EncodeExGRepresentedSymbol_CABAC(code-8,3);
        }
    }
  return;

}
} //namespace UMC