Changeset 608 in 3DVCSoftware for trunk/source/Lib/TLibCommon/TComRom.cpp


Ignore:
Timestamp:
1 Sep 2013, 22:47:26 (11 years ago)
Author:
tech
Message:

Merged DEV-2.0-dev0@604.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/Lib/TLibCommon/TComRom.cpp

    r332 r608  
    44 * granted under this license. 
    55 *
    6  * Copyright (c) 2010-2012, ITU/ISO/IEC
     6 * Copyright (c) 2010-2013, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    6262  g_aucConvertToBit[ i ] = c;
    6363 
    64   // g_auiFrameScanXY[ g_aucConvertToBit[ transformSize ] ]: zigzag scan array for transformSize
    6564  c=2;
    6665  for ( i=0; i<MAX_CU_DEPTH; i++ )
    6766  {
    68     g_auiFrameScanXY[ i ] = new UInt[ c*c ];
    69     g_auiFrameScanX [ i ] = new UInt[ c*c ];
    70     g_auiFrameScanY [ i ] = new UInt[ c*c ];
    71     initFrameScanXY( g_auiFrameScanXY[i], g_auiFrameScanX[i], g_auiFrameScanY[i], c, c );
    7267    g_auiSigLastScan[0][i] = new UInt[ c*c ];
    7368    g_auiSigLastScan[1][i] = new UInt[ c*c ];
    7469    g_auiSigLastScan[2][i] = new UInt[ c*c ];
    75     g_auiSigLastScan[3][i] = new UInt[ c*c ];
    76     initSigLastScan( g_auiSigLastScan[0][i], g_auiSigLastScan[1][i], g_auiSigLastScan[2][i], g_auiSigLastScan[3][i], c, c, i);
     70    initSigLastScan( g_auiSigLastScan[0][i], g_auiSigLastScan[1][i], g_auiSigLastScan[2][i], c, c);
    7771
    7872    c <<= 1;
    7973  } 
    80 
    81   g_sigScanNSQT[0] = new UInt[ 64 ];  // 4x16
    82   g_sigScanNSQT[1] = new UInt[ 256 ]; // 8x32
    83   g_sigScanNSQT[2] = new UInt[ 64 ];  // 16x4
    84   g_sigScanNSQT[3] = new UInt[ 256 ]; // 32x8
    85  
    86   static int diagScanX[ 16 ] =
    87   {
    88     0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 1, 2, 3, 2, 3, 3
    89   };
    90   static int diagScanY[ 16 ] =
    91   {
    92     0, 1, 0, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 3, 2, 3
    93   };
    94  
    95   Int j;
    96   // 4x16 scan
    97   for (i = 0; i < 4; i++)
    98   {
    99     for (j = 0; j < 16; j++)
    100     {
    101       g_sigScanNSQT[ 0 ][ 16 * i + j ] = 16 * i + 4 * diagScanY[ j ] + diagScanX[ j ];
    102     }
    103   }
    104  
    105   // 8x32 scan
    106   for (i = 0; i < 16; i++)
    107   {
    108     Int x = g_sigCGScanNSQT[ 1 ][ i ] & 1;
    109     Int y = g_sigCGScanNSQT[ 1 ][ i ] >> 1;
    110    
    111     for (j = 0; j < 16; j++)
    112     {
    113       g_sigScanNSQT[ 1 ][ 16 * i + j ] = 32 * y + 4 * x + 8 * diagScanY[ j ] + diagScanX[ j ];
    114     }
    115   }
    116  
    117   // 16x4 scan
    118   for (i = 0; i < 4; i++)
    119   {
    120     for (j = 0; j < 16; j++)
    121     {
    122       g_sigScanNSQT[ 2 ][ 16 * i + j ] = 4 * i + 16 * diagScanY[ j ] + diagScanX[ j ];
    123     }
    124   }
    125  
    126   // 32x8 scan
    127   for (i = 0; i < 16; i++)
    128   {
    129     Int x = g_sigCGScanNSQT[ 3 ][ i ] & 7;
    130     Int y = g_sigCGScanNSQT[ 3 ][ i ] >> 3;
    131    
    132     for (j = 0; j < 16; j++)
    133     {
    134       g_sigScanNSQT[ 3 ][ 16 * i + j ] = 128 * y + 4 * x + 32 * diagScanY[ j ] + diagScanX[ j ];
    135     }
    136   }
    13774}
    13875
    13976Void destroyROM()
    14077{
    141   Int i;
    142  
    143   for ( i=0; i<MAX_CU_DEPTH; i++ )
    144   {
    145     delete[] g_auiFrameScanXY[i];
    146     delete[] g_auiFrameScanX [i];
    147     delete[] g_auiFrameScanY [i];
     78  for (Int i=0; i<MAX_CU_DEPTH; i++ )
     79  {
    14880    delete[] g_auiSigLastScan[0][i];
    14981    delete[] g_auiSigLastScan[1][i];
    15082    delete[] g_auiSigLastScan[2][i];
    151     delete[] g_auiSigLastScan[3][i];
    152   }
    153   for (i = 0; i < 4; i++)
    154   {
    155     delete[] g_sigScanNSQT[ i ];   
    156   }
    157 
    158 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    159   if ( !g_aacWedgeLists.empty() )
    160   {
    161     for ( UInt ui = 0; ui < g_aacWedgeLists.size(); ui++ )
    162     {
    163       g_aacWedgeLists[ui].clear();
    164     }
    165     g_aacWedgeLists.clear();
    166   }
    167 
    168   if ( !g_aacWedgeRefLists.empty() )
    169   {
    170     for ( UInt ui = 0; ui < g_aacWedgeRefLists.size(); ui++ )
    171     {
    172       g_aacWedgeRefLists[ui].clear();
    173     }
    174     g_aacWedgeRefLists.clear();
    175   }
    176 
    177   if ( !g_aacWedgeNodeLists.empty() )
    178   {
    179     for ( UInt ui = 0; ui < g_aacWedgeNodeLists.size(); ui++ )
    180     {
    181       g_aacWedgeNodeLists[ui].clear();
    182     }
    183     g_aacWedgeNodeLists.clear();
    184   }
    185 
     83  }
     84
     85#if H_3D_DIM_DMM
     86  if( !g_dmmWedgeLists.empty() )
     87  {
     88    for( UInt ui = 0; ui < g_dmmWedgeLists.size(); ui++ ) { g_dmmWedgeLists[ui].clear(); }
     89    g_dmmWedgeLists.clear();
     90  }
     91  if( !g_dmmWedgeRefLists.empty() )
     92  {
     93    for( UInt ui = 0; ui < g_dmmWedgeRefLists.size(); ui++ ) { g_dmmWedgeRefLists[ui].clear(); }
     94    g_dmmWedgeRefLists.clear();
     95  }
     96
     97  if( !g_dmmWedgeNodeLists.empty() )
     98  {
     99    for( UInt ui = 0; ui < g_dmmWedgeNodeLists.size(); ui++ ) { g_dmmWedgeNodeLists[ui].clear(); }
     100    g_dmmWedgeNodeLists.clear();
     101  }
    186102#endif
    187103}
     
    195111UInt g_uiMaxCUDepth  = MAX_CU_DEPTH;
    196112UInt g_uiAddCUDepth  = 0;
    197 
    198113UInt g_auiZscanToRaster [ MAX_NUM_SPU_W*MAX_NUM_SPU_W ] = { 0, };
    199114UInt g_auiRasterToZscan [ MAX_NUM_SPU_W*MAX_NUM_SPU_W ] = { 0, };
    200115UInt g_auiRasterToPelX  [ MAX_NUM_SPU_W*MAX_NUM_SPU_W ] = { 0, };
    201116UInt g_auiRasterToPelY  [ MAX_NUM_SPU_W*MAX_NUM_SPU_W ] = { 0, };
    202 UInt g_motionRefer   [ MAX_NUM_SPU_W*MAX_NUM_SPU_W ] = { 0, };
    203117
    204118UInt g_auiPUOffset[8] = { 0, 8, 4, 4, 2, 10, 1, 5};
     
    237151}
    238152
    239 /** generate motion data compression mapping table
    240 * \param uiMaxCUWidth, width of LCU
    241 * \param uiMaxCUHeight, hight of LCU
    242 * \param uiMaxDepth, max depth of LCU
    243 * \returns Void
    244 */
    245 Void initMotionReferIdx ( UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxDepth )
    246 {
    247   Int  minCUWidth  = (Int)uiMaxCUWidth  >> ( (Int)uiMaxDepth - 1 );
    248   Int  minCUHeight = (Int)uiMaxCUHeight >> ( (Int)uiMaxDepth - 1 );
    249 
    250   Int  numPartInWidth  = (Int)uiMaxCUWidth  / (Int)minCUWidth;
    251   Int  numPartInHeight = (Int)uiMaxCUHeight / (Int)minCUHeight;
    252 
    253   for ( Int i = 0; i < numPartInWidth*numPartInHeight; i++ )
    254   {
    255     g_motionRefer[i] = i;
    256   }
    257 
    258   Int compressionNum = 2;
    259 
    260   for ( Int i = numPartInWidth*(numPartInHeight-1); i < numPartInWidth*numPartInHeight; i += compressionNum*2)
    261   {
    262     for ( Int j = 1; j < compressionNum; j++ )
    263     {
    264       g_motionRefer[g_auiRasterToZscan[i+j]] = g_auiRasterToZscan[i];
    265     }
    266   }
    267 
    268   for ( Int i = numPartInWidth*(numPartInHeight-1)+compressionNum*2-1; i < numPartInWidth*numPartInHeight; i += compressionNum*2)
    269   {
    270     for ( Int j = 1; j < compressionNum; j++ )
    271     {
    272       g_motionRefer[g_auiRasterToZscan[i-j]] = g_auiRasterToZscan[i];
    273     }
    274   }
    275 }
    276 
    277153Void initRasterToPelXY ( UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxDepth )
    278154{
     
    305181};
    306182
    307 #if RWTH_SDC_DLT_B0036
    308 UInt g_auiSDCPredModes[RWTH_SDC_NUM_PRED_MODES] = { DC_IDX, DMM_WEDGE_FULL_IDX, PLANAR_IDX };
    309 #endif
    310183
    311184Int g_quantScales[6] =
     
    319192};
    320193
    321 const short g_aiT4[4][4] =
     194const Short g_aiT4[4][4] =
    322195{
    323196  { 64, 64, 64, 64},
     
    327200};
    328201
    329 const short g_aiT8[8][8] =
     202const Short g_aiT8[8][8] =
    330203{
    331204  { 64, 64, 64, 64, 64, 64, 64, 64},
     
    339212};
    340213
    341 const short g_aiT16[16][16] =
     214const Short g_aiT16[16][16] =
    342215{
    343216  { 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64},
     
    359232};
    360233
    361 const short g_aiT32[32][32] =
     234const Short g_aiT32[32][32] =
    362235{
    363236  { 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64},
     
    395268};
    396269
    397 const UChar g_aucChromaScale[52]=
    398 {
    399   0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,
    400   12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,
    401   28,29,29,30,31,32,32,33,34,34,35,35,36,36,37,37,
    402   37,38,38,38,39,39,39,39
     270const UChar g_aucChromaScale[58]=
     271{
     272   0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,
     273  17,18,19,20,21,22,23,24,25,26,27,28,29,29,30,31,32,
     274  33,33,34,34,35,35,36,36,37,37,38,39,40,41,42,43,44,
     275  45,46,47,48,49,50,51
    403276};
    404277
    405278
    406279// Mode-Dependent DCT/DST
    407 const short g_as_DST_MAT_4 [4][4]=
     280const Short g_as_DST_MAT_4 [4][4]=
    408281{
    409282  {29,   55,    74,   84},
     
    412285  {55,  -84,    74,  -29},
    413286};
    414 
    415287
    416288
     
    452324// ====================================================================================================================
    453325
    454 UInt g_uiBitDepth     = 8;    // base bit-depth
    455 UInt g_uiBitIncrement = 0;    // increments
    456 UInt g_uiIBDI_MAX     = 255;  // max. value after  IBDI
    457 UInt g_uiBASE_MAX     = 255;  // max. value before IBDI
     326Int  g_bitDepthY = 8;
     327Int  g_bitDepthC = 8;
    458328
    459329UInt g_uiPCMBitDepthLuma     = 8;    // PCM bit-depth
     
    461331
    462332// ====================================================================================================================
    463 // Depth model modes
    464 // ====================================================================================================================
    465 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    466 Int g_iDeltaDCsQuantOffset = 0;
    467 
    468 const WedgeResolution g_aeWedgeResolutionList[5] =
    469 {
    470   HALF_PEL,    //  4x4
    471   HALF_PEL,    //  8x8
    472   FULL_PEL,    // 16x16
    473   DOUBLE_PEL,  // 32x32
    474   DOUBLE_PEL   // 64x64
    475 };
    476 
    477 const UChar g_aucWedgeFullBitsListIdx[7] =
    478 {
    479   0,   //   2x2
    480   7,   //   4x4    WedgeListSize[  HALF_PEL]   86
    481   10,  //   8x8    WedgeListSize[  HALF_PEL]  782
    482   11,  //  16x16   WedgeListSize[  FULL_PEL] 1394
    483   11,  //  32x32   WedgeListSize[DOUBLE_PEL] 1503
    484   13,  //  64x64   WedgeListSize[DOUBLE_PEL] 6079
    485   0    // 128x128 
    486 };
    487 
    488 #if LGE_DMM3_SIMP_C0044
    489 const UChar g_aucWedgeTexPredBitsListIdx[7] =
    490 {
    491   0,   //   2x2
    492   6,   //   4x4   
    493   9,  //   8x8   
    494   9,  //  16x16   
    495   9,  //  32x32   
    496   0,  //  64x64   
    497   0    // 128x128 
    498 };
     333// Depth coding modes
     334// ====================================================================================================================
     335#if H_3D_DIM_DMM
     336const WedgeResolution g_dmmWedgeResolution[6] =
     337{
     338  HALF_PEL,    //   4x4
     339  HALF_PEL,    //   8x8
     340  FULL_PEL,    //  16x16
     341  DOUBLE_PEL,  //  32x32
     342  DOUBLE_PEL,  //  64x64
     343  DOUBLE_PEL   // 128x128
     344};
     345
     346const UChar g_dmm1TabIdxBits[6] =
     347{ //2x2   4x4   8x8 16x16 32x32 64x64
     348     0,    7,   10,   11,   11,   13 };
     349#if LGE_PKU_DMM3_OVERLAP_E0159
     350const UChar g_dmm3IntraTabIdxBits[6] =
     351{ //2x2   4x4   8x8 16x16 32x32 64x64
     352     0,    4,    7,    8,    8,    0 };
     353#else
     354const UChar g_dmm3IntraTabIdxBits[6] =
     355{ //2x2   4x4   8x8 16x16 32x32 64x64
     356     0,    6,    9,    9,    9,    0 };
    499357#endif
    500358
    501 const UChar g_aucIntraSizeIdxToWedgeSize[7] =
    502 {
    503   2,
    504   4,
    505   8,
    506   16,
    507   32,
    508   64,
    509   128
    510 };
     359extern std::vector< std::vector<TComWedgelet> >   g_dmmWedgeLists;
     360extern std::vector< std::vector<TComWedgeRef> >   g_dmmWedgeRefLists;
     361extern std::vector< std::vector<TComWedgeNode> >  g_dmmWedgeNodeLists;
    511362#endif
    512363
     
    521372const Bool g_bEncDecTraceEnable  = true;
    522373const Bool g_bEncDecTraceDisable = false;
     374Bool   g_HLSTraceEnable = true;
    523375Bool   g_bJustDoIt = false;
    524376UInt64 g_nSymbolCounter = 0;
     377#if H_MV_ENC_DEC_TRAC
     378Bool g_traceCU = true;
     379Bool g_tracePU = true;
     380Bool g_traceTU = true;
     381Bool g_disableHLSTrace = false;
     382UInt64 g_stopAtCounter   = 10803;
    525383#endif
     384#endif
    526385// ====================================================================================================================
    527386// Scanning order & context model mapping
     
    529388
    530389// scanning order table
    531 UInt* g_auiFrameScanXY[ MAX_CU_DEPTH  ];
    532 UInt* g_auiFrameScanX [ MAX_CU_DEPTH  ];
    533 UInt* g_auiFrameScanY [ MAX_CU_DEPTH  ];
    534 UInt* g_auiSigLastScan[4][ MAX_CU_DEPTH ];
    535 UInt *g_sigScanNSQT[ 4 ]; // scan for non-square partitions
    536 UInt g_sigCGScanNSQT[ 4 ][ 16 ] =
    537 {
    538   { 0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
    539   { 0, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 15 },
    540   { 0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
    541   { 0, 8, 1, 9, 2, 10, 3, 11, 4, 12, 5, 13, 6, 14, 7, 15 }
    542 };
    543 
    544 const UInt g_sigLastScan8x8[ 4 ][ 4 ] =
    545 {
    546   {0, 1, 2, 3},
    547   {0, 1, 2, 3},
     390UInt* g_auiSigLastScan[ 3 ][ MAX_CU_DEPTH ];
     391
     392const UInt g_sigLastScan8x8[ 3 ][ 4 ] =
     393{
     394  {0, 2, 1, 3},
    548395  {0, 1, 2, 3},
    549396  {0, 2, 1, 3}
     
    551398UInt g_sigLastScanCG32x32[ 64 ];
    552399
    553 UInt* g_auiNonSquareSigLastScan[ 4 ];
    554 
    555400const UInt g_uiMinInGroup[ 10 ] = {0,1,2,3,4,6,8,12,16,24};
    556401const UInt g_uiGroupIdx[ 32 ]   = {0,1,2,3,4,4,5,5,6,6,6,6,7,7,7,7,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9};
    557 const UInt g_uiLastCtx[ 28 ]    =
    558 {
    559   0,   1,  2,  2,                         // 4x4    4
    560   3,   4,  5,  5, 2,  2,                  // 8x8    6 
    561   6,   7,  8,  8, 9,  9, 2, 2,            // 16x16  8
    562   10, 11, 12, 12, 13, 13, 14, 14, 2, 2    // 32x32  10
    563 };
    564402
    565403// Rice parameters for absolute transform levels
     
    574412};
    575413
    576 const UInt g_aauiGoRiceUpdate[5][24] =
    577 {
    578   {
    579     0, 0, 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4
    580   },
    581   {
    582     1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4
    583   },
    584   {
    585     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4
    586   },
    587   {
    588     3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4
    589   },
    590   {
    591     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4
    592   }
    593 };
    594 
    595 // initialize g_auiFrameScanXY
    596 Void initFrameScanXY( UInt* pBuff, UInt* pBuffX, UInt* pBuffY, Int iWidth, Int iHeight )
    597 {
    598   Int x, y, c = 0;
    599  
    600   // starting point
    601   pBuffX[ c ] = 0;
    602   pBuffY[ c ] = 0;
    603   pBuff[ c++ ] = 0;
    604  
    605   // loop
    606   x=1; y=0;
    607   while (1)
    608   {
    609     // decrease loop
    610     while ( x>=0 )
    611     {
    612       if ( x >= 0 && x < iWidth && y >= 0 && y < iHeight )
    613       {
    614         pBuffX[ c ] = x;
    615         pBuffY[ c ] = y;
    616         pBuff[ c++ ] = x+y*iWidth;
    617       }
    618       x--; y++;
    619     }
    620     x=0;
    621    
    622     // increase loop
    623     while ( y>=0 )
    624     {
    625       if ( x >= 0 && x < iWidth && y >= 0 && y < iHeight )
    626       {
    627         pBuffX[ c ] = x;
    628         pBuffY[ c ] = y;
    629         pBuff[ c++ ] = x+y*iWidth;
    630       }
    631       x++; y--;
    632     }
    633     y=0;
    634    
    635     // termination condition
    636     if ( c >= iWidth*iHeight ) break;
    637   } 
    638 }
    639 
    640 Void initSigLastScan(UInt* pBuffZ, UInt* pBuffH, UInt* pBuffV, UInt* pBuffD, Int iWidth, Int iHeight, Int iDepth)
     414Void initSigLastScan(UInt* pBuffD, UInt* pBuffH, UInt* pBuffV, Int iWidth, Int iHeight)
    641415{
    642416  const UInt  uiNumScanPos  = UInt( iWidth * iWidth );
     
    652426  for( UInt uiScanLine = 0; uiNextScanPos < uiNumScanPos; uiScanLine++ )
    653427  {
    654     int    iPrimDim  = int( uiScanLine );
    655     int    iScndDim  = 0;
     428    Int    iPrimDim  = Int( uiScanLine );
     429    Int    iScndDim  = 0;
    656430    while( iPrimDim >= iWidth )
    657431    {
     
    688462      for( UInt uiScanLine = 0; uiNextScanPos < 16; uiScanLine++ )
    689463      {
    690         int    iPrimDim  = int( uiScanLine );
    691         int    iScndDim  = 0;
     464        Int    iPrimDim  = Int( uiScanLine );
     465        Int    iScndDim  = 0;
    692466        while( iPrimDim >= 4 )
    693467        {
     
    706480  }
    707481 
    708   memcpy(pBuffZ, g_auiFrameScanXY[iDepth], sizeof(UInt)*iWidth*iHeight);
    709 
    710482  UInt uiCnt = 0;
     483  if( iWidth > 2 )
     484  {
     485    UInt numBlkSide = iWidth >> 2;
     486    for(Int blkY=0; blkY < numBlkSide; blkY++)
     487    {
     488      for(Int blkX=0; blkX < numBlkSide; blkX++)
     489      {
     490        UInt offset    = blkY * 4 * iWidth + blkX * 4;
     491        for(Int y=0; y < 4; y++)
     492        {
     493          for(Int x=0; x < 4; x++)
     494          {
     495            pBuffH[uiCnt] = y*iWidth + x + offset;
     496            uiCnt ++;
     497          }
     498        }
     499      }
     500    }
     501
     502    uiCnt = 0;
     503    for(Int blkX=0; blkX < numBlkSide; blkX++)
     504    {
     505      for(Int blkY=0; blkY < numBlkSide; blkY++)
     506      {
     507        UInt offset    = blkY * 4 * iWidth + blkX * 4;
     508        for(Int x=0; x < 4; x++)
     509        {
     510          for(Int y=0; y < 4; y++)
     511          {
     512            pBuffV[uiCnt] = y*iWidth + x + offset;
     513            uiCnt ++;
     514          }
     515        }
     516      }
     517    }
     518  }
     519  else
     520  {
    711521  for(Int iY=0; iY < iHeight; iY++)
    712522  {
     
    727537    }
    728538  }   
    729 }
    730 
    731 Void initNonSquareSigLastScan(UInt* pBuffZ, UInt uiWidth, UInt uiHeight)
    732 {
    733 
    734   Int x, y, c = 0;
    735 
    736   // starting point
    737   pBuffZ[ c++ ] = 0;
    738 
    739   // loop
    740   if ( uiWidth > uiHeight )
    741   {
    742     x=0; y=1;
    743     while (1)
    744     {
    745       // increase loop
    746       while ( y>=0 )
    747       {
    748         if ( x >= 0 && x < uiWidth && y >= 0 && y < uiHeight )
    749         {
    750           pBuffZ[ c++ ] = x + y * uiWidth;
    751         }
    752         x++;
    753         y--;
    754       }
    755       y=0;
    756 
    757       // decrease loop
    758       while ( x>=0 )
    759       {
    760         if ( x >= 0 && x < uiWidth && y >= 0 && y < uiHeight )
    761         {
    762           pBuffZ[ c++ ] = x + y * uiWidth;
    763         }
    764         x--;
    765         y++;
    766       }
    767       x=0;
    768 
    769       // termination condition
    770       if ( c >= uiWidth * uiHeight )
    771         break;
    772     }
    773   }
    774   else
    775   {
    776     x=1; y=0;
    777     while (1)
    778     {
    779       // increase loop
    780       while ( x>=0 )
    781       {
    782         if ( x >= 0 && x < uiWidth && y >= 0 && y < uiHeight )
    783         {
    784           pBuffZ[ c++ ] = x + y * uiWidth;
    785         }
    786         x--;
    787         y++;
    788       }
    789       x=0;
    790 
    791       // decrease loop
    792       while ( y>=0 )
    793       {
    794         if ( x >= 0 && x < uiWidth && y >= 0 && y < uiHeight )
    795         {
    796           pBuffZ[ c++ ] = x + y * uiWidth;
    797         }
    798         x++;
    799         y--;
    800       }
    801       y=0;
    802 
    803       // termination condition
    804       if ( c >= uiWidth * uiHeight )
    805         break;
    806     }
    807   }
    808 }
    809 
    810 Int g_quantIntraDefault4x4[16] =
    811 {
    812   16,16,17,21,
    813   16,17,20,25,
    814   17,20,30,41,
    815   21,25,41,70
    816 };
    817 Int g_quantInterDefault4x4[16] =
    818 {
    819   16,16,17,21,
    820   16,17,21,24,
    821   17,21,24,36,
    822   21,24,36,57
     539  }
     540}
     541
     542Int g_quantTSDefault4x4[16] =
     543{
     544  16,16,16,16,
     545  16,16,16,16,
     546  16,16,16,16,
     547  16,16,16,16
    823548};
    824549
     
    851576Int  g_eTTable[4] = {0,3,1,2};
    852577
    853 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    854 std::vector< std::vector<TComWedgelet> > g_aacWedgeLists;
    855 std::vector< std::vector<TComWedgeRef> > g_aacWedgeRefLists;
    856 
     578#if H_MV_ENC_DEC_TRAC
     579#if ENC_DEC_TRACE
     580Void writeToTraceFile( Char* symbolName, Int val, Bool doIt )
     581{
     582  if ( ( ( g_nSymbolCounter >= COUNTER_START && g_nSymbolCounter <= COUNTER_END )|| g_bJustDoIt ) && doIt  )
     583  {
     584    if ( g_stopAtCounter == g_nSymbolCounter )
     585    {
     586      std::cout << "Break point here." << std::endl;
     587    }
     588    fprintf( g_hTrace, "%8lld  ", g_nSymbolCounter++ );
     589    fprintf( g_hTrace, "%-50s       : %d\n", symbolName, val );     
     590    fflush ( g_hTrace );
     591    g_nSymbolCounter++;
     592  }
     593}
     594
     595Void writeToTraceFile( Char* symbolName, Bool doIt )
     596{
     597  if ( ( ( g_nSymbolCounter >= COUNTER_START && g_nSymbolCounter <= COUNTER_END )|| g_bJustDoIt ) && doIt  )
     598  {
     599    fprintf( g_hTrace, "%s", symbolName );   
     600    fflush ( g_hTrace );
     601    g_nSymbolCounter++;
     602  }
     603}
     604
     605#endif
     606#endif
     607#if H_3D_DIM_DMM
     608std::vector< std::vector<TComWedgelet>  > g_dmmWedgeLists;
     609std::vector< std::vector<TComWedgeRef>  > g_dmmWedgeRefLists;
     610std::vector< std::vector<TComWedgeNode> > g_dmmWedgeNodeLists;
    857611std::vector< std::vector< std::vector<UInt> > > g_aauiWdgLstM3;
    858 std::vector< std::vector< TComWedgeNode> >      g_aacWedgeNodeLists;
    859 
    860 Void initWedgeLists()
    861 {
    862   for( UInt ui = g_aucConvertToBit[DMM_WEDGEMODEL_MIN_SIZE]; ui < (g_aucConvertToBit[DMM_WEDGEMODEL_MAX_SIZE]+1); ui++ )
    863   {
    864     UInt uiWedgeBlockSize = ((UInt)DMM_WEDGEMODEL_MIN_SIZE)<<ui;
     612
     613Void initWedgeLists( Bool initRefinements )
     614{
     615  if( !g_dmmWedgeLists.empty() ) return;
     616
     617  for( UInt ui = g_aucConvertToBit[DIM_MIN_SIZE]; ui < (g_aucConvertToBit[DIM_MAX_SIZE]+1); ui++ )
     618  {
     619    UInt uiWedgeBlockSize = ((UInt)DIM_MIN_SIZE)<<ui;
    865620    std::vector<TComWedgelet> acWedgeList;
    866621    std::vector<TComWedgeRef> acWedgeRefList;
    867     createWedgeList( uiWedgeBlockSize, uiWedgeBlockSize, acWedgeList, acWedgeRefList, g_aeWedgeResolutionList[ui] );
    868     g_aacWedgeLists.push_back( acWedgeList );
    869     g_aacWedgeRefLists.push_back( acWedgeRefList );
     622    createWedgeList( uiWedgeBlockSize, uiWedgeBlockSize, acWedgeList, acWedgeRefList, g_dmmWedgeResolution[ui] );
     623    g_dmmWedgeLists.push_back( acWedgeList );
     624    g_dmmWedgeRefLists.push_back( acWedgeRefList );
    870625
    871626    // create WedgeNodeList
     
    878633        cWedgeNode.setPatternIdx( uiPos );
    879634
    880         // set refinement idxs
    881         UInt uiRefPos = 0;
    882         for( Int iOffS = -1; iOffS <= 1; iOffS++ )
     635        if( initRefinements )
    883636        {
    884           for( Int iOffE = -1; iOffE <= 1; iOffE++ )
     637          UInt uiRefPos = 0;
     638          for( Int iOffS = -1; iOffS <= 1; iOffS++ )
    885639          {
    886             if( iOffS == 0 && iOffE == 0 ) { continue; }
    887 
    888             Int iSx = (Int)acWedgeList[uiPos].getStartX();
    889             Int iSy = (Int)acWedgeList[uiPos].getStartY();
    890             Int iEx = (Int)acWedgeList[uiPos].getEndX();
    891             Int iEy = (Int)acWedgeList[uiPos].getEndY();
    892 
    893             switch( acWedgeList[uiPos].getOri() )
     640            for( Int iOffE = -1; iOffE <= 1; iOffE++ )
    894641            {
    895             case( 0 ): { iSx += iOffS; iEy += iOffE; } break;
    896             case( 1 ): { iSy += iOffS; iEx -= iOffE; } break;
    897             case( 2 ): { iSx -= iOffS; iEy -= iOffE; } break;
    898             case( 3 ): { iSy -= iOffS; iEx += iOffE; } break;
    899             case( 4 ): { iSx += iOffS; iEx += iOffE; } break;
    900             case( 5 ): { iSy += iOffS; iEy += iOffE; } break;
    901             default: assert( 0 );
    902             }
    903 
    904             for( UInt k = 0; k < acWedgeRefList.size(); k++ )
    905             {
    906               if( iSx == (Int)acWedgeRefList[k].getStartX() &&
    907                 iSy == (Int)acWedgeRefList[k].getStartY() &&
    908                 iEx == (Int)acWedgeRefList[k].getEndX() &&
    909                 iEy == (Int)acWedgeRefList[k].getEndY()    )
     642              if( iOffS == 0 && iOffE == 0 ) { continue; }
     643
     644              Int iSx = (Int)acWedgeList[uiPos].getStartX();
     645              Int iSy = (Int)acWedgeList[uiPos].getStartY();
     646              Int iEx = (Int)acWedgeList[uiPos].getEndX();
     647              Int iEy = (Int)acWedgeList[uiPos].getEndY();
     648
     649              switch( acWedgeList[uiPos].getOri() )
    910650              {
    911                 if( acWedgeRefList[k].getRefIdx() != cWedgeNode.getPatternIdx() )
     651              case( 0 ): { iSx += iOffS; iEy += iOffE; } break;
     652              case( 1 ): { iSy += iOffS; iEx -= iOffE; } break;
     653              case( 2 ): { iSx -= iOffS; iEy -= iOffE; } break;
     654              case( 3 ): { iSy -= iOffS; iEx += iOffE; } break;
     655              case( 4 ): { iSx += iOffS; iEx += iOffE; } break;
     656              case( 5 ): { iSy += iOffS; iEy += iOffE; } break;
     657              default: assert( 0 );
     658              }
     659
     660              for( UInt k = 0; k < acWedgeRefList.size(); k++ )
     661              {
     662                if( iSx == (Int)acWedgeRefList[k].getStartX() &&
     663                    iSy == (Int)acWedgeRefList[k].getStartY() &&
     664                    iEx == (Int)acWedgeRefList[k].getEndX()   &&
     665                    iEy == (Int)acWedgeRefList[k].getEndY()      )
    912666                {
    913                   Bool bNew = true;
    914                   for( UInt m = 0; m < uiRefPos; m++ ) { if( acWedgeRefList[k].getRefIdx() == cWedgeNode.getRefineIdx( m ) ) { bNew = false; break; } }
    915 
    916                   if( bNew )
     667                  if( acWedgeRefList[k].getRefIdx() != cWedgeNode.getPatternIdx() )
    917668                  {
    918                     cWedgeNode.setRefineIdx( acWedgeRefList[k].getRefIdx(), uiRefPos );
    919                     uiRefPos++;
    920                     break;
     669                    Bool bNew = true;
     670                    for( UInt m = 0; m < uiRefPos; m++ ) { if( acWedgeRefList[k].getRefIdx() == cWedgeNode.getRefineIdx( m ) ) { bNew = false; break; } }
     671
     672                    if( bNew )
     673                    {
     674                      cWedgeNode.setRefineIdx( acWedgeRefList[k].getRefIdx(), uiRefPos );
     675                      uiRefPos++;
     676                      break;
     677                    }
    921678                  }
    922679                }
     
    928685      }
    929686    }
    930     g_aacWedgeNodeLists.push_back( acWedgeNodeList );
    931 
     687    g_dmmWedgeNodeLists.push_back( acWedgeNodeList );
    932688  }
    933689  return;
     
    972728    }
    973729  }
     730
    974731  UInt uiThrSz = DMM3_SIMPLIFY_TR;
    975 
    976732  std::vector< std::vector<UInt> > auiWdgListSz;
    977733  for( Int idxM=2; idxM<=34 ; idxM++)
     
    1024780  if( bValid )
    1025781  {
    1026     cWedgelet.findClosetAngle();
     782    cWedgelet.findClosestAngle();
    1027783    racWedgeList.push_back( cWedgelet );
    1028784    TComWedgeRef cWedgeRef;
     
    1031787  }
    1032788}
    1033 #endif //HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
     789#endif //H_3D_DIM_DMM
    1034790
    1035791//! \}
Note: See TracChangeset for help on using the changeset viewer.