umc_h264_tables.cpp

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

// QP-dependent threshold will be classified as empty.
const Ipp32u EmptyThreshold[52] = {
    3, 4, 20, 26,
    31, 41, 47, 59,
    71, 77, 86, 95,
    103, 104, 106, 107,
    127, 134, 141, 167,
    185, 198, 205, 212,
    234, 294, 304, 314,
    325, 335, 346, 357,
    409, 461, 540, 653,
    741, 765, 790, 815,
    840, 1045, 1259, 1340,
    1556, 1772, 2006, 2069,
    2102, 2134, 2569, 3290
};

const IppiSize size16x16={16,16};
const IppiSize size16x8={16,8};
const IppiSize size8x16={8,16};
const IppiSize size8x8={8,8};
const IppiSize size8x4={8,4};
const IppiSize size4x8={4,8};
const IppiSize size4x4={4,4};
const IppiSize size4x2={4,2};
const IppiSize size2x4={2,4};
const IppiSize size2x2={2,2};

// Tuned for Stuart & MIB

const Ipp32u DirectBSkipMEThres[52] =
{
    4, 4, 5, 13,
    14, 14, 21, 26,
    26, 29, 31, 33,
    35, 35, 37, 37,
    39, 47, 47, 47,
    82, 88, 106, 131,
    141, 186, 214, 214,
    214, 221, 262, 310,
    332, 332, 343, 510,
    510, 601, 780, 860,
    1043, 1225, 1306, 1533,
    1533, 1635, 1859, 1859,
    2045, 2180, 2180, 2251
};

// Not Tuned!!!

const Ipp32u PSkipMEThres[52] =
{
    1, 1, 1, 1,
    1, 2, 3, 3,
    5, 7, 9, 12,
    16, 16, 19, 23,
    28, 35, 43, 52,
    63, 76, 86, 97,
    110, 107, 116, 125,
    134, 147, 167, 189,
    215, 265, 310, 362,
    424, 496, 563, 639,
    725, 756, 901, 1079,
    1299, 1573, 1914, 2341,
    2876, 5356, 6866, 8800
};

const Ipp32s BestOf5EarlyExitThres[52] =
{
    38, 38, 38, 38,
    38, 38, 38, 38,
    38, 46, 46, 46,
    50, 50, 50, 50,
    60, 60, 60, 68,
    68, 68, 68, 68,
    68, 71, 95, 95,
    95, 107, 153, 176,
    176, 176, 202, 209,
    209, 284, 294, 314,
    359, 371, 383, 383,
    396, 452, 516, 533,
    628, 739, 841, 1020
};


// Tables used for finding if a luma block is on the edge
// of a macroblock. JVT CD block order
// tab4, indexed by 8x8 block
const Ipp8u left_edge_tab4[4]       = {1,0,1,0};
const Ipp8u top_edge_tab4[4]        = {1,1,0,0};
const Ipp8u right_edge_tab4[4]      = {0,1,0,1};
// tab16, indexed by 4x4 subblock
const Ipp8u left_edge_tab16[16]     = {1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0};
const Ipp8u top_edge_tab16[16]      = {1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0};
const Ipp8u right_edge_tab16[16]    = {0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1};
// 8x4 and 4x8 tables, indexed by [8x8block*4 + subblock]
const Ipp8u left_edge_tab16_8x4[16]     = {1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0};
const Ipp8u top_edge_tab16_8x4[16]      = {1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0};
const Ipp8u right_edge_tab16_8x4[16]    = {0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0};
const Ipp8u left_edge_tab16_4x8[16]     = {1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0};
const Ipp8u top_edge_tab16_4x8[16]      = {1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0};
const Ipp8u right_edge_tab16_4x8[16]    = {0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0};

// Tables for MV prediction to find if upper right predictor is
// available, indexed by [8x8block*4 + subblock]
const Ipp8u above_right_avail_8x4[16] = {0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0};
const Ipp8u above_right_avail_4x8[16] = {0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,0};

// Table for 4x4 intra prediction to find if a subblock can use predictors
// from above right. Also used for motion vector prediction availability.
// JVT CD block order.
const Ipp8u above_right_avail_4x4[16] = {1,1,1,0,1,1,1,0,1,1,1,0,1,0,1,0};
const Ipp8u above_right_avail_4x4_lin[16] = {
    1,1,1,1,
    1,0,1,0,
    1,1,1,0,
    1,0,1,0
};

// Table for 4x4 intra prediction to find if a subblock can use predictors
// from below left. JVT CD block order.
const Ipp8u intra4x4_below_left_avail[16] = {1,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0};

// chroma vector mapping
const Ipp8u c2x2m[4][4] = {{0,0,1,1},{0,0,1,1},{2,2,3,3},{2,2,3,3}};

//////////////////////////////////////////////////////////
// scan matrices
Ipp32s dec_single_scan[2][16] = {
    {0,1,4,8,5,2,3,6,9,12,13,10,7,11,14,15},
    {0,4,1,8,12,5,9,13,2,6,10,14,3,7,11,15}
};

const Ipp32s dec_single_scan_p[4] = {0,1,2,3};
const Ipp32s dec_single_scan_p422[8] = {0,2,1,4,6,3,5,7};

Ipp16s enc_single_scan[2][16] = {
    {0,1,5,6,2,4,7,12,3,8,11,13,9,10,14,15},
    {0,2,8,12,1,5,9,13,3,6,10,14,4,7,11,15}
};

const Ipp32s dec_single_scan_8x8[2][64] = {
    {0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63},
    {0, 8, 16, 1, 9, 24, 32, 17, 2, 25, 40, 48, 56, 33, 10, 3, 18, 41, 49, 57, 26, 11, 4, 19, 34, 42, 50, 58, 27, 12, 5, 20, 35, 43, 51, 59, 28, 13, 6, 21, 36, 44, 52, 60, 29, 14, 22, 37, 45, 53, 61, 30, 7, 15, 38, 46, 54, 62, 23, 31, 39, 47, 55, 63}
};

Ipp16s enc_single_scan_8x8[2][64] = {
    { 0, 1, 5, 6, 14, 15, 27, 28, 2, 4, 7, 13, 16, 26, 29, 42, 3, 8, 12, 17, 25, 30, 41, 43, 9, 11, 18, 24, 31, 40, 44, 53, 10, 19, 23, 32, 39, 45, 52, 54, 20, 22, 33, 38, 46, 51, 55, 60, 21, 34, 37, 47, 50, 56, 59, 61, 35, 36, 48, 49, 57, 58, 62, 63},
    { 0, 3, 8, 15, 22, 30, 38, 52, 1, 4, 14, 21, 29, 37, 45, 53, 2, 7, 16, 23, 31, 39, 46, 58, 5, 9, 20, 28, 36, 44, 51, 59, 6, 13, 24, 32, 40, 47, 54, 60, 10, 17, 25, 33, 41, 48, 55, 61, 11, 18, 26, 34, 42, 49, 56, 62, 12, 19, 27, 35, 43, 50, 57, 63}
};

const Ipp32s gc_Zeroes[8*8] = { 0 };

const Ipp8u MbPartWidth[UMC_H264_ENCODER::NUMBER_OF_MBTYPES] = {
    16, // MBTYPE_INTRA
    16, // MBTYPE_INTRA_16x16 = 1,
    16, // MBTYPE_PCM = 2,             // Raw Pixel Coding, qualifies as a INTRA type...
    16, // MBTYPE_INTER = 3,           // 16x16
    16, // MBTYPE_INTER_16x8 = 4,
     8, // MBTYPE_INTER_8x16 = 5,
     8, // MBTYPE_INTER_8x8 = 6,
     8, // MBTYPE_INTER_8x8_REF0 = 7,  // same as MBTYPE_INTER_8x8, with all RefIdx=0
    16, // MBTYPE_FORWARD = 8,
    16, // MBTYPE_BACKWARD = 9,
    16, // MBTYPE_SKIPPED = 10,
    16, // MBTYPE_DIRECT = 11,
    16, // MBTYPE_BIDIR = 12,
    16, // MBTYPE_FWD_FWD_16x8 = 13,
     8, // MBTYPE_FWD_FWD_8x16 = 14,
    16, // MBTYPE_BWD_BWD_16x8 = 15,
     8, // MBTYPE_BWD_BWD_8x16 = 16,
    16, // MBTYPE_FWD_BWD_16x8 = 17,
     8, // MBTYPE_FWD_BWD_8x16 = 18,
    16, // MBTYPE_BWD_FWD_16x8 = 19,
     8, // MBTYPE_BWD_FWD_8x16 = 20,
    16, // MBTYPE_BIDIR_FWD_16x8 = 21,
     8, // MBTYPE_BIDIR_FWD_8x16 = 22,
    16, // MBTYPE_BIDIR_BWD_16x8 = 23,
     8, // MBTYPE_BIDIR_BWD_8x16 = 24,
    16, // MBTYPE_FWD_BIDIR_16x8 = 25,
     8, // MBTYPE_FWD_BIDIR_8x16 = 26,
    16, // MBTYPE_BWD_BIDIR_16x8 = 27,
     8, // MBTYPE_BWD_BIDIR_8x16 = 28,
    16, // MBTYPE_BIDIR_BIDIR_16x8 = 29,
     8, // MBTYPE_BIDIR_BIDIR_8x16 = 30,
     8  // MBTYPE_B_8x8 = 31,
};

const Ipp8u MbPartHeight[UMC_H264_ENCODER::NUMBER_OF_MBTYPES] = {
    16, // MBTYPE_INTRA
    16, // MBTYPE_INTRA_16x16 = 1,
    16, // MBTYPE_PCM = 2,             // Raw Pixel Coding, qualifies as a INTRA type...
    16, // MBTYPE_INTER = 3,           // 16x16
     8, // MBTYPE_INTER_16x8 = 4,
    16, // MBTYPE_INTER_8x16 = 5,
     8, // MBTYPE_INTER_8x8 = 6,
     8, // MBTYPE_INTER_8x8_REF0 = 7,  // same as MBTYPE_INTER_8x8, with all RefIdx=0
    16, // MBTYPE_FORWARD = 8,
    16, // MBTYPE_BACKWARD = 9,
    16, // MBTYPE_SKIPPED = 10,
    16, // MBTYPE_DIRECT = 11,
    16, // MBTYPE_BIDIR = 12,
     8, // MBTYPE_FWD_FWD_16x8 = 13,
    16, // MBTYPE_FWD_FWD_8x16 = 14,
     8, // MBTYPE_BWD_BWD_16x8 = 15,
    16, // MBTYPE_BWD_BWD_8x16 = 16,
     8, // MBTYPE_FWD_BWD_16x8 = 17,
    16, // MBTYPE_FWD_BWD_8x16 = 18,
     8, // MBTYPE_BWD_FWD_16x8 = 19,
    16, // MBTYPE_BWD_FWD_8x16 = 20,
     8, // MBTYPE_BIDIR_FWD_16x8 = 21,
    16, // MBTYPE_BIDIR_FWD_8x16 = 22,
     8, // MBTYPE_BIDIR_BWD_16x8 = 23,
    16, // MBTYPE_BIDIR_BWD_8x16 = 24,
     8, // MBTYPE_FWD_BIDIR_16x8 = 25,
    16, // MBTYPE_FWD_BIDIR_8x16 = 26,
     8, // MBTYPE_BWD_BIDIR_16x8 = 27,
    16, // MBTYPE_BWD_BIDIR_8x16 = 28,
     8, // MBTYPE_BIDIR_BIDIR_16x8 = 29,
    16, // MBTYPE_BIDIR_BIDIR_8x16 = 30,
     8  // MBTYPE_B_8x8 = 31,
};

const Ipp8u DefaultScalingList4x4[2][16] = {
    {6,13,20,28,13,20,28,32,20,28,32,37,28,32,37,42},
    {10,14,20,24,14,20,24,27,20,24,27,30,24,27,30,34}
};

const Ipp8u FlatScalingList4x4[16] = {
    16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16
};

const Ipp8u DefaultScalingList8x8[2][64] = {
    { 6,10,13,16,18,23,25,27,10,11,16,18,23,25,27,29,
     13,16,18,23,25,27,29,31,16,18,23,25,27,29,31,33,
     18,23,25,27,29,31,33,36,23,25,27,29,31,33,36,38,
     25,27,29,31,33,36,38,40,27,29,31,33,36,38,40,42},
    { 9,13,15,17,19,21,22,24,13,13,17,19,21,22,24,25,
     15,17,19,21,22,24,25,27,17,19,21,22,24,25,27,28,
     19,21,22,24,25,27,28,30,21,22,24,25,27,28,30,32,
     22,24,25,27,28,30,32,33,24,25,27,28,30,32,33,35}
};

const Ipp8u FlatScalingList8x8[64] = {
    16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
    16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
    16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
    16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16
};

const Ipp8u SubWidthC[4]  = { 1, 2, 2, 1 };
const Ipp8u SubHeightC[4] = { 1, 2, 1, 1 };

Ipp8u BitsForMV [BITSFORMV_OFFSET + 1 + BITSFORMV_OFFSET];

static const Ipp8u s_BitsForMV[128] = {
         1, 3, 5, 5, 7, 7, 7, 7, 9, 9, 9, 9, 9, 9, 9, 9,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
        13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
        15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
        15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15
};

class BitsForMV_Initializer
{
public:
    BitsForMV_Initializer ()
    {
        for (Ipp32s qp = 0; qp < 52; qp ++)
            for (Ipp32s mvl = 0; mvl <= BITSFORMV_OFFSET; mvl ++) {
                if (mvl < 128)
                    BitsForMV[BITSFORMV_OFFSET + mvl] = BitsForMV[BITSFORMV_OFFSET - mvl] = s_BitsForMV[mvl];
                else
                    BitsForMV[BITSFORMV_OFFSET + mvl] = BitsForMV[BITSFORMV_OFFSET - mvl] = s_BitsForMV[mvl >> 7] + 14;
            }
    }
};

BitsForMV_Initializer initBitsForMV;


Ipp16s glob_RDQM[52][BITSMAX];

static const Ipp32s qp_lambda[40] = // pow(2, qp/6)
{
    1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 6, 6, 7, 8, 9, 10, 11, 13, 14, 16, 18, 20, 23, 25, 29, 32, 36, 40, 45, 51, 57, 64, 72, 81, 91
};

class RDQM_Initializer
{
public:
    RDQM_Initializer ()
    {
        for (Ipp32s qp = 0; qp < 52; qp ++)
            for (Ipp32s bits = 0; bits < BITSMAX; bits ++)
                glob_RDQM[qp][bits] = qp_lambda[MAX(0, qp - 12)] * bits;
    }
};

RDQM_Initializer initRDQM;

} //namespace UMC_H264_ENCODER