umc_h264_dec_bitstream_cabac.cpp

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

INITIALIZE_VALUES M_and_N_for_ctxIdx_402_459_inter[58][3] =
{
    {{-4, 79}, {-5, 85}, {-3, 78}},
    {{-7, 71}, {-6, 81}, {-8, 74}},
    {{-5, 69}, {-10,77}, {-9, 72}},
    {{-9, 70}, {-7, 81}, {-10,72}},
    {{-8 ,66}, {-17,80}, {-18,75}},
    {{-10,68}, {-18,73}, {-12,71}},
    {{-19,73}, {-4, 74}, {-11,63}},
    {{-12,69}, {-10,83}, {-5, 70}},
    {{-16,70}, {-9, 71}, {-17,75}},
    {{-15,67}, {-9, 67}, {-14,72}},
    {{-20,62}, {-1, 61}, {-16,67}},
    {{-19,70}, {-8, 66}, {-8, 53}},
    {{-16,66}, {-14,66}, {-14,59}},
    {{-22,65}, {0,  59}, {-9, 52}},
    {{-20,63}, {2,  59}, {-11,68}},
    {{9,  -2}, {17,-10}, {9,  -2}},
    {{26, -9}, {32,-13}, {30,-10}},
    {{33, -9}, {42, -9}, {31, -4}},
    {{39, -7}, {49, -5}, {33, -1}},
    {{41, -2}, {53,  0}, {33,  7}},
    {{45,  3}, {64,  3}, {31, 12}},
    {{49,  9}, {68, 10}, {37, 23}},
    {{45, 27}, {66, 27}, {31, 38}},
    {{36, 59}, {47, 57}, {20, 64}},
    {{-6, 66}, {-5, 71}, {-9, 71}},
    {{-7, 35}, {0,  24}, {-7, 37}},
    {{-7, 42}, {-1, 36}, {-8, 44}},
    {{-8, 45}, {-2, 42}, {-11,49}},
    {{-5, 48}, {-2, 52}, {-10,56}},
    {{-12,56}, {-9, 57}, {-12,59}},
    {{-6, 60}, {-6, 63}, {-8, 63}},
    {{-5, 62}, {-4, 65}, {-9, 67}},
    {{-8, 66}, {-4, 67}, {-6, 68}},
    {{-8, 76}, {-7, 82}, {-10,79}},
    {{-5, 85}, {-3, 81}, {-3, 78}},
    {{-6, 81}, {-3, 76}, {-8, 74}},
    {{-10,77}, {-7, 72}, {-9, 72}},
    {{-7, 81}, {-6, 78}, {-10,72}},
    {{-17,80}, {-12,72}, {-18,75}},
    {{-18,73}, {-14,68}, {-12,71}},
    {{-4, 74}, {-3, 70}, {-11,63}},
    {{-10,83}, {-6, 76}, {-5, 70}},
    {{-9, 71}, {-5, 66}, {-17,75}},
    {{-9, 67}, {-5, 62}, {-14,72}},
    {{-1, 61}, {0,  57}, {-16,67}},
    {{-8, 66}, {-4, 61}, {-8, 53}},
    {{-14,66}, {-9, 60}, {-14,59}},
    {{0,  59}, {1,  54}, {-9, 52}},
    {{2,  59}, {2,  58}, {-11,68}},
    {{21,-13}, {17,-10}, {9,  -2}},
    {{33,-14}, {32,-13}, {30,-10}},
    {{39, -7}, {42, -9}, {31, -4}},
    {{46, -2}, {49, -5}, {33, -1}},
    {{51,  2}, {53,  0}, {33,  7}},
    {{60,  6}, {64,  3}, {31, 12}},
    {{61, 17}, {68, 10}, {37, 23}},
    {{55, 34}, {66, 27}, {31, 38}},
    {{42, 62}, {47, 57}, {20, 64}},
};

} // namespace UMCH264DecodingFunctional
using namespace UMCH264DecodingFunctional;

namespace UMC
{

void H264Bitstream::InitializeContextVariablesIntra_CABAC(Ipp32s SliceQPy)
{
    Ipp32s l;

    SliceQPy = IPP_MAX(0, SliceQPy);

    // See subclause 9.3.1.1 of H.264 standard

    // Initialize context(s) for mb_type (SI & I slices)
    for (l = 0; l <= 10; l += 1)
    {
        InitializeContext(context_array + l,
                          M_and_N_for_ctxIdx_0_10[l - 0].m,
                          M_and_N_for_ctxIdx_0_10[l - 0].n,
                          SliceQPy
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // 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
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // Initialize context(s) for mb_field_decoding_flag &
    // coded_block_pattern(luma) & coded_block_pattern(chroma) &
    // coded_block_flag (SI & I slices)
    for (l = 70; l <= 104; l += 1)
    {
        InitializeContext(context_array + l,
                          M_and_N_for_ctxIdx_70_104_intra[l - 70].m,
                          M_and_N_for_ctxIdx_70_104_intra[l - 70].n,
                          SliceQPy
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // 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_intra[l - 105].m,
                          M_and_N_for_ctxIdx_105_165_intra[l - 105].n,
                          SliceQPy
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // 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_intra[l - 166].m,
                          M_and_N_for_ctxIdx_166_226_intra[l - 166].n,
                          SliceQPy
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // 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_intra[l - 227].m,
                          M_and_N_for_ctxIdx_227_275_intra[l - 227].n,
                          SliceQPy
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // ctxIdx equal to 276 is associated the end_of_slice_flag
    // Initial values associated with ctxIdx equal to 276
    // are specified to be pStateIdx = 63 and valMPS = 0
    context_array[276].pStateIdxAndVal = 63 * 2;

    // 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_intra[l - 277].m,
                          M_and_N_for_ctxIdx_277_337_intra[l - 277].n,
                          SliceQPy
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // 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_intra[l - 338].m,
                          M_and_N_for_ctxIdx_338_398_intra[l - 338].n,
                          SliceQPy
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    for (l = 399; l <= 401; l += 1)
    {
        InitializeContext(context_array + l,
                          M_and_N_for_ctxIdx_399_401_intra[l - 399].m,
                          M_and_N_for_ctxIdx_399_401_intra[l - 399].n,
                          SliceQPy
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    for (l = 402; l <= 459; l += 1)
    {
        InitializeContext(context_array + l,
                          M_and_N_for_ctxIdx_402_459_intra[l - 402].m,
                          M_and_N_for_ctxIdx_402_459_intra[l - 402].n,
                          SliceQPy
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

} // void H264Bitstream::InitializeContextVariablesIntra_CABAC(Ipp32s SliceQPy)

void H264Bitstream::InitializeContextVariablesInter_CABAC(Ipp32s SliceQPy,
                                                          Ipp32s cabac_init_idc)
{
    Ipp32s l;

    // See subclause 9.3.1.1 of H.264 standard
    SliceQPy = IPP_MAX(0, SliceQPy);

    // 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
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // 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
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // 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
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // 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
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // 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
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // 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
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // 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
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // 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
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // 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
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // 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
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    // 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
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    for (l = 399; l <= 401; l += 1)
    {
        InitializeContext(context_array + l,
                          M_and_N_for_ctxIdx_399_401_inter[l - 399][cabac_init_idc].m,
                          M_and_N_for_ctxIdx_399_401_inter[l - 399][cabac_init_idc].n,
                          SliceQPy
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

    for (l = 402; l <= 459; l += 1)
    {
        InitializeContext(context_array + l,
                          M_and_N_for_ctxIdx_402_459_inter[l - 402][cabac_init_idc].m,
                          M_and_N_for_ctxIdx_402_459_inter[l - 402][cabac_init_idc].n,
                          SliceQPy
#ifdef STORE_CABAC_BITS
#ifdef CABAC_CONTEXTS_COMP
                          , l
#endif
#endif
                          );
    }

} // void H264Bitstream::InitializeContextVariablesInter_CABAC(Ipp32s SliceQPy,

void H264Bitstream::InitializeDecodingEngine_CABAC()
{
    // See subclause 9.3.1.2 of H.264 standard

    AlignPointerRight();

    m_lcodIRange = 0x01fe;

    m_lcodIOffset = GetBits(9);

#if (CABAC_MAGIC_BITS > 0)
    m_lcodIRange = m_lcodIRange << CABAC_MAGIC_BITS;
    m_lcodIOffset = m_lcodIOffset << CABAC_MAGIC_BITS;
    {
        Ipp32u nBits;

        m_iMagicBits = (m_bitOffset % 16) + 1;
        nBits = GetBits(m_iMagicBits);
        m_lcodIOffset |= nBits << (16 - m_iMagicBits);

        m_pMagicBits = ((Ipp16u *) m_pbs) + ((15 == m_bitOffset) ? (1) : (0));
    }
#endif // (CABAC_MAGIC_BITS > 0)

} // void H264Bitstream::InitializeDecodingEngine_CABAC(void)

void H264Bitstream::TerminateDecode_CABAC(void)
{
#if (CABAC_MAGIC_BITS > 0)
    // restore source pointer
    m_pbs = (Ipp32u *) (((size_t) m_pMagicBits) & -0x04);
    m_bitOffset = (((size_t) m_pMagicBits) & 0x02) ? (15) : (31);
    // return prereaded bits
    ippiUngetNBits(m_pbs, m_bitOffset, m_iMagicBits);
    m_iMagicBits = 0;
    m_lcodIOffset &= -0x10000;
#endif
    AlignPointerRight();

} // void H264Bitstream::TerminateDecode_CABAC(void)

#ifdef STORE_CABAC_BITS
FILE *cabac_bits;
Ipp32s sym_cnt;
#endif

} // namespace UMC
#endif // UMC_ENABLE_H264_VIDEO_DECODER