umc_h264_tables.cpp

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

// All 4x4 blocks of a 16x16 block with a SAD below this
// QP-dependent threshold will be classified as empty.
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
};

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

// Tuned for Stuart & MIB

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!!!

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

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

// used for SSE2 AIModeSelect
Ipp16u uSADTable[11];

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

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




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

const Ipp8u MbPartWidth[UMC::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::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,
};

#if 0

//
//  This chunk of code will read the dec_aic_prob table above and
//  output the new enc_aic_prob table based on it...
//
#include <stdio.h>

void main() {

Ipp8u a,b,p,t;

char acmt[10][255] = {
    "\t// A = outside\n",
    "\t// A = mode0\n",
    "\t// A = mode1\n",
    "\t// A = mode2\n",
    "\t// A = mode3\n",
    "\t// A = mode4\n",
    "\t// A = mode5\n",
    "\t// A = mode6\n",
    "\t// A = mode7\n",
    "\t// A = mode8\n"
};

char bcmt[10][255] = {
    " // B = outside\n",
    " // B = mode0\n",
    " // B = mode1\n",
    " // B = mode2\n",
    " // B = mode3\n",
    " // B = mode4\n",
    " // B = mode5\n",
    " // B = mode6\n",
    " // B = mode7\n",
    " // B = mode8\n"
};

printf("const Ipp8u enc_aic_prob[10/*A*/][10/*B*/][9/*prob*/] = \n");
printf("{\n");

for (a=0; a<10; a++) {
    printf("\t{%s",acmt[a]);
    for (b=0; b<10; b++) {
        printf("\t\t{");
        for (p=0; p<9; p++) {
            for (t=0; !((p == dec_aic_prob[a][b][t]) || (t==9)); t++);
            printf("%d,",t);
        }
        printf("},%s",bcmt[b]);
    }
    printf("\t},\n");
}

printf("};\n");
}

#endif // 0

} //namespace UMC