Changeset 877 in 3DVCSoftware


Ignore:
Timestamp:
27 Mar 2014, 19:31:41 (10 years ago)
Author:
tech
Message:

Cleanups part 2.

Location:
branches/HTM-10.1-dev0/source/Lib
Files:
20 edited

Legend:

Unmodified
Added
Removed
  • branches/HTM-10.1-dev0/source/Lib/TLibCommon/ContextTables.h

    r876 r877  
    116116#if QC_GENERIC_SDC_G0122
    117117#define NUM_ANGLE_FLAG_CTX            3
    118 #if !QC_SDC_UNIFY_G0130
    119 #define NUM_INTRASDC_FLAG_CTX         3
    120 #endif
    121118#endif
    122119#endif
    123120
    124121#if H_3D_DIM_SDC
    125 #define SDC_NUM_RESIDUAL_FLAG_CTX        1
    126 #define SDC_NUM_RESIDUAL_CTX             1
    127 #endif
    128 
    129 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    130 #define NUM_INTER_SDC_FLAG_CTX        1      ///< number of context models for inter SDC flag
    131 #define NUM_INTER_SDC_SIGN_FLAG_CTX   1      ///< number of context models for sign of inter SDC residual
    132 #define NUM_INTER_SDC_RESIDUAL_CTX    1      ///< number of context models for abs of inter SDC residual
    133 #endif
    134 
    135 #if QC_SDC_UNIFY_G0130
     122#define SDC_NUM_RESIDUAL_FLAG_CTX     1
     123#define SDC_NUM_RESIDUAL_CTX          1
    136124#define NUM_SDC_FLAG_CTX              1      ///< number of context
    137125#endif
     
    404392  { 155, 170, 157 },
    405393};
    406 #if !QC_SDC_UNIFY_G0130
    407 static const UChar
    408 INIT_INTRASDC_FLAG[3][NUM_INTRASDC_FLAG_CTX] =
    409 {
    410   { 214, 229, 230 },
    411   { 215, 202, 174 },
    412   { 213, 201, 246 },
    413 };
    414 #endif
    415394#endif
    416395
     
    456435#endif
    457436
    458 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    459 static const UChar
    460 INIT_INTER_SDC_FLAG[3][NUM_INTER_SDC_FLAG_CTX] =
    461 {
    462   { CNU }, 
    463   { 154 },
    464   { 154 },
    465 };
    466 
    467 static const UChar
    468 INIT_INTER_SDC_SIGN_FLAG[3][NUM_INTER_SDC_SIGN_FLAG_CTX] =
    469 {
    470   { CNU }, 
    471   { 154 },
    472   { 154 },
    473 };
    474 
    475 static const UChar
    476 INIT_INTER_SDC_RESIDUAL[3][NUM_INTER_SDC_RESIDUAL_CTX] =
    477 {
    478   { CNU }, 
    479   { 154 },
    480   { 154 },
    481 };
    482 #endif
     437
    483438//! \}
    484 #if QC_SDC_UNIFY_G0130
     439#if H_3D_DIM_SDC
    485440static const UChar
    486441INIT_SDC_FLAG[3][NUM_SDC_FLAG_CTX] =
  • branches/HTM-10.1-dev0/source/Lib/TLibCommon/TComDataCU.cpp

    r876 r877  
    123123#if H_3D_DIM_SDC
    124124  m_pbSDCFlag             = NULL;
    125 #if QC_SDC_UNIFY_G0130 && !SEC_INTER_SDC_G0101
    126   for( Int i = 0; i < 4; i++ )
    127   {
    128     m_apSegmentDCOffset[i]  = NULL;
    129   }
    130 #else
    131125  m_apSegmentDCOffset[0]  = NULL;
    132126  m_apSegmentDCOffset[1]  = NULL;
    133 #endif
    134127#endif
    135128#endif
     
    153146#endif
    154147#if H_3D_INTER_SDC
    155 #if !QC_SDC_UNIFY_G0130
    156   m_pbInterSDCFlag       = NULL;
    157   for( Int i = 0; i < 4; i++ )
    158   {
    159     m_apSegmentInterDCOffset[i] = NULL;
    160   }
    161 #endif
    162 #if !SEC_INTER_SDC_G0101
    163   m_pucInterSDCMask       = NULL;
    164 #endif
    165148#endif
    166149#if H_3D_DBBP
     
    291274#if H_3D_DIM_SDC
    292275    m_pbSDCFlag             = (Bool*)xMalloc(Bool, uiNumPartition);
    293 #if QC_SDC_UNIFY_G0130 && !SEC_INTER_SDC_G0101
    294     for( Int i = 0; i < 4; i++ )
    295     {
    296       m_apSegmentDCOffset[i]  = (Pel*)xMalloc(Pel, uiNumPartition);
    297     }
    298 #else
    299276    m_apSegmentDCOffset[0]  = (Pel*)xMalloc(Pel, uiNumPartition);
    300277    m_apSegmentDCOffset[1]  = (Pel*)xMalloc(Pel, uiNumPartition);
    301278#endif
    302279#endif
    303 #endif
    304 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    305     m_pbInterSDCFlag     = (Bool*  )xMalloc(Bool,   uiNumPartition);
    306     for( Int i = 0; i < 4; i++ )
    307     {
    308       m_apSegmentInterDCOffset[i] = (Int*)xMalloc(Int, uiNumPartition);
    309     }
    310 #endif
    311280#if H_3D_DBBP
    312281    m_pbDBBPFlag         = (Bool*  )xMalloc(Bool,   uiNumPartition);
     
    318287    m_acCUMvField[1].setNumPartition(uiNumPartition );
    319288  }
    320 #if !SEC_INTER_SDC_G0101
    321 #if H_3D_INTER_SDC
    322   m_pucInterSDCMask     = (UChar*  )xMalloc(UChar,    g_uiMaxCUHeight*g_uiMaxCUWidth);
    323 #endif
    324 #endif
    325289  m_sliceStartCU        = (UInt*  )xMalloc(UInt, uiNumPartition);
    326290  m_sliceSegmentStartCU = (UInt*  )xMalloc(UInt, uiNumPartition);
     
    441405#if H_3D_DIM_SDC
    442406    if ( m_pbSDCFlag            ) { xFree(m_pbSDCFlag);             m_pbSDCFlag             = NULL; }
    443 #if QC_SDC_UNIFY_G0130 && !SEC_INTER_SDC_G0101
    444     for( Int i = 0; i < 4; i++ )
    445     {
    446       if ( m_apSegmentDCOffset[i] ) { xFree(m_apSegmentDCOffset[i]);  m_apSegmentDCOffset[i]  = NULL; }
    447     }
    448 #else
    449407    if ( m_apSegmentDCOffset[0] ) { xFree(m_apSegmentDCOffset[0]);  m_apSegmentDCOffset[0]  = NULL; }
    450408    if ( m_apSegmentDCOffset[1] ) { xFree(m_apSegmentDCOffset[1]);  m_apSegmentDCOffset[1]  = NULL; }
    451 #endif
    452409#endif   
    453410#endif   
    454 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    455     if ( m_pbInterSDCFlag     ) { xFree(m_pbInterSDCFlag);      m_pbInterSDCFlag    = NULL; }
    456     for(Int i = 0; i < 4; i++ )
    457     {
    458       if ( m_apSegmentInterDCOffset[i] ) { xFree( m_apSegmentInterDCOffset[i] ); m_apSegmentInterDCOffset[i] = NULL; }
    459   }
    460 #endif
    461411#if H_3D_DBBP
    462412    if ( m_pbDBBPFlag         ) { xFree(m_pbDBBPFlag);          m_pbDBBPFlag        = NULL; }
    463413#endif
    464414  }
    465 #if !SEC_INTER_SDC_G0101
    466 #if H_3D_INTER_SDC
    467   if ( m_pucInterSDCMask     ) { xFree(m_pucInterSDCMask);      m_pucInterSDCMask    = NULL; }
    468 #endif
    469 #endif
    470415  m_pcCUAboveLeft       = NULL;
    471416  m_pcCUAboveRight      = NULL;
     
    593538#if H_3D_DIM_SDC
    594539    m_pbSDCFlag[ui] = pcFrom->m_pbSDCFlag[ui];
    595 #endif
    596 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    597     m_pbInterSDCFlag[ui] = pcFrom->m_pbInterSDCFlag[ui];
    598540#endif
    599541#if H_3D_DBBP
     
    665607#if H_3D_DIM_SDC
    666608    memset( m_pbSDCFlag             + firstElement,     0,                numElements * sizeof( *m_pbSDCFlag            ) );
    667 #if QC_SDC_UNIFY_G0130 && !SEC_INTER_SDC_G0101
    668     for( Int i = 0; i < 4; i++ )
    669     {
    670       memset( m_apSegmentDCOffset[i]  + firstElement,     0,                numElements * sizeof( *m_apSegmentDCOffset[i] ) );
    671     }
    672 #else
    673609    memset( m_apSegmentDCOffset[0]  + firstElement,     0,                numElements * sizeof( *m_apSegmentDCOffset[0] ) );
    674610    memset( m_apSegmentDCOffset[1]  + firstElement,     0,                numElements * sizeof( *m_apSegmentDCOffset[1] ) );
    675611#endif
    676 #endif
    677 #endif
    678 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    679     memset( m_pbInterSDCFlag   + firstElement,     0,                    numElements * sizeof( *m_pbInterSDCFlag ) );
    680     for( Int i = 0; i < 4; i++ )
    681     {
    682       memset( m_apSegmentInterDCOffset[i] + firstElement,     0,         numElements * sizeof( *m_apSegmentInterDCOffset[i] ) );
    683     }
    684612#endif
    685613#if H_3D_DBBP
     
    853781#if H_3D_DIM_SDC
    854782      m_pbSDCFlag           [ui] = false;
    855 #if QC_SDC_UNIFY_G0130 && !SEC_INTER_SDC_G0101
    856       for( Int i = 0; i < 4; i++ )
    857       {
    858         m_apSegmentDCOffset[i][ui] = 0;
    859       }
    860 #else
    861783      m_apSegmentDCOffset[0][ui] = 0;
    862784      m_apSegmentDCOffset[1][ui] = 0;
    863785#endif
    864 #endif
    865 #endif
    866 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    867       m_pbInterSDCFlag[ui] = false;
    868       for( Int i = 0; i < 4; i++ )
    869       {
    870         m_apSegmentInterDCOffset[i][ui] = 0;
    871       }
    872786#endif
    873787#if H_3D_DBBP
     
    982896#if H_3D_DIM_SDC
    983897  memset( m_pbSDCFlag,            0, sizeof(Bool) * m_uiNumPartition  );
    984 #if QC_SDC_UNIFY_G0130 && !SEC_INTER_SDC_G0101
    985   for( Int i = 0; i < 4; i++ )
    986   {
    987     memset( m_apSegmentDCOffset[i], 0, sizeof(Pel) * m_uiNumPartition   );
    988   }
    989 #else
    990898  memset( m_apSegmentDCOffset[0], 0, sizeof(Pel) * m_uiNumPartition   );
    991899  memset( m_apSegmentDCOffset[1], 0, sizeof(Pel) * m_uiNumPartition   );
    992900#endif
    993 #endif
    994 #endif
    995 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    996   memset( m_pbInterSDCFlag,           0, sizeof( Bool ) * m_uiNumPartition );
    997   for( Int i = 0; i < 4; i++ )
    998   {
    999     memset( m_apSegmentInterDCOffset[i], 0, sizeof( Int ) * m_uiNumPartition );
    1000   }
    1001901#endif
    1002902#if H_3D_DBBP
     
    1075975#if H_3D_DIM_SDC
    1076976      m_pbSDCFlag           [ui] = pcCU->m_pbSDCFlag            [ uiPartOffset + ui ];
    1077 #if QC_SDC_UNIFY_G0130 && !SEC_INTER_SDC_G0101
    1078       for( Int i = 0; i < 4; i++ )
    1079       {
    1080         m_apSegmentDCOffset[i][ui] = pcCU->m_apSegmentDCOffset[i] [ uiPartOffset + ui ];
    1081       }
    1082 #else
    1083977      m_apSegmentDCOffset[0][ui] = pcCU->m_apSegmentDCOffset[0] [ uiPartOffset + ui ];
    1084978      m_apSegmentDCOffset[1][ui] = pcCU->m_apSegmentDCOffset[1] [ uiPartOffset + ui ];
    1085979#endif
    1086 #endif
    1087 #endif
    1088 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    1089       m_pbInterSDCFlag      [ui] = pcCU->m_pbInterSDCFlag    [ uiPartOffset + ui ];
    1090       for( Int i = 0; i < 4; i++ )
    1091       {
    1092         m_apSegmentInterDCOffset[i][ui] = pcCU->m_apSegmentInterDCOffset[i][ uiPartOffset + ui ];
    1093       }
    1094980#endif
    1095981#if H_3D_DBBP
     
    12461132#if H_3D_DIM_SDC
    12471133  m_pbSDCFlag               = pcCU->getSDCFlag()              + uiPart;
    1248 #if QC_SDC_UNIFY_G0130 && !SEC_INTER_SDC_G0101
    1249   for( Int i = 0; i < 4; i++ )
    1250   {
    1251     m_apSegmentDCOffset[i]    = pcCU->getSDCSegmentDCOffset(i)  + uiPart;
    1252   }
    1253 #else
    12541134  m_apSegmentDCOffset[0]    = pcCU->getSDCSegmentDCOffset(0)  + uiPart;
    12551135  m_apSegmentDCOffset[1]    = pcCU->getSDCSegmentDCOffset(1)  + uiPart;
    1256 #endif
    12571136#endif 
    12581137#endif 
    1259 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    1260   m_pbInterSDCFlag          = pcCU->getInterSDCFlag()       + uiPart;
    1261   for( Int i = 0; i < 4; i++ )
    1262   {
    1263     m_apSegmentInterDCOffset[i] = pcCU->getInterSDCSegmentDCOffset( i ) + uiPart;
    1264   }
    1265 #endif
    12661138#if H_3D_DBBP
    12671139  m_pbDBBPFlag              = pcCU->getDBBPFlag()         + uiPart;
     
    14651337#if H_3D_DIM_SDC
    14661338  memcpy( m_pbSDCFlag             + uiOffset, pcCU->getSDCFlag(),             iSizeInBool  );
    1467 #if QC_SDC_UNIFY_G0130 && !SEC_INTER_SDC_G0101
    1468   for( Int i = 0; i < 4; i++ )
    1469   {
    1470     memcpy( m_apSegmentDCOffset[i]  + uiOffset, pcCU->getSDCSegmentDCOffset(i), sizeof( Pel ) * uiNumPartition);
    1471   }
    1472 #else
    14731339  memcpy( m_apSegmentDCOffset[0]  + uiOffset, pcCU->getSDCSegmentDCOffset(0), sizeof( Pel ) * uiNumPartition);
    14741340  memcpy( m_apSegmentDCOffset[1]  + uiOffset, pcCU->getSDCSegmentDCOffset(1), sizeof( Pel ) * uiNumPartition);
    14751341#endif
    1476 #endif
    1477 #endif
    1478 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    1479   memcpy( m_pbInterSDCFlag  + uiOffset, pcCU->getInterSDCFlag(),      iSizeInBool  );
    1480   for( Int i = 0; i < 4; i++ )
    1481   {
    1482     memcpy( m_apSegmentInterDCOffset[i] + uiOffset, pcCU->getInterSDCSegmentDCOffset( i ), sizeof( Int ) * uiNumPartition);
    1483   }
    14841342#endif
    14851343#if H_3D_DBBP
     
    16021460#if H_3D_DIM_SDC
    16031461  memcpy( rpcCU->getSDCFlag()             + m_uiAbsIdxInLCU, m_pbSDCFlag,      iSizeInBool  );
    1604 #if QC_SDC_UNIFY_G0130 && !SEC_INTER_SDC_G0101
    1605   for( Int i = 0; i < 4; i++ )
    1606   {
    1607     memcpy( rpcCU->getSDCSegmentDCOffset(i) + m_uiAbsIdxInLCU, m_apSegmentDCOffset[i], sizeof( Pel ) * m_uiNumPartition);
    1608   }
    1609 #else
    16101462  memcpy( rpcCU->getSDCSegmentDCOffset(0) + m_uiAbsIdxInLCU, m_apSegmentDCOffset[0], sizeof( Pel ) * m_uiNumPartition);
    16111463  memcpy( rpcCU->getSDCSegmentDCOffset(1) + m_uiAbsIdxInLCU, m_apSegmentDCOffset[1], sizeof( Pel ) * m_uiNumPartition);
    16121464#endif
    1613 #endif
    1614 #endif
    1615 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    1616   memcpy( rpcCU->getInterSDCFlag() + m_uiAbsIdxInLCU, m_pbInterSDCFlag,      iSizeInBool  );
    1617   for( Int i = 0;i < 4; i++ )
    1618   {
    1619     memcpy( rpcCU->getInterSDCSegmentDCOffset( i ) + m_uiAbsIdxInLCU, m_apSegmentInterDCOffset[i], sizeof( Int ) * m_uiNumPartition);
    1620   }
    16211465#endif
    16221466#if H_3D_DBBP
     
    17261570#if H_3D_DIM_SDC
    17271571  memcpy( rpcCU->getSDCFlag()             + uiPartOffset, m_pbSDCFlag,      iSizeInBool  );
    1728 #if QC_SDC_UNIFY_G0130 && !SEC_INTER_SDC_G0101
    1729   for( Int i = 0; i < 4; i++ )
    1730   {
    1731     memcpy( rpcCU->getSDCSegmentDCOffset(i) + uiPartOffset, m_apSegmentDCOffset[i], sizeof( Pel ) * uiQNumPart);
    1732   }
    1733 #else
    17341572  memcpy( rpcCU->getSDCSegmentDCOffset(0) + uiPartOffset, m_apSegmentDCOffset[0], sizeof( Pel ) * uiQNumPart);
    17351573  memcpy( rpcCU->getSDCSegmentDCOffset(1) + uiPartOffset, m_apSegmentDCOffset[1], sizeof( Pel ) * uiQNumPart);
    17361574#endif
    1737 #endif
    1738 #endif
    1739 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    1740   memcpy( rpcCU->getInterSDCFlag() + uiPartOffset, m_pbInterSDCFlag,      iSizeInBool  );
    1741   for( Int i = 0; i < 4; i++ )
    1742   {
    1743     memcpy( rpcCU->getInterSDCSegmentDCOffset( i ) + uiPartOffset, m_apSegmentInterDCOffset[i], sizeof( Int ) * uiQNumPart);
    1744   }
    17451575#endif
    17461576#if H_3D_DBBP
     
    25452375#endif
    25462376
    2547 #if H_3D_INTER_SDC
    2548 #if !QC_SDC_UNIFY_G0130
    2549 Void TComDataCU::setInterSDCFlagSubParts ( Bool bInterSDCFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
    2550 {
    2551   setSubPart( bInterSDCFlag, m_pbInterSDCFlag, uiAbsPartIdx, uiDepth, uiPartIdx );
    2552 }
    2553 
    2554 UInt TComDataCU::getCtxInterSDCFlag( UInt uiAbsPartIdx )
    2555 {
    2556   return 0;
    2557 }
    2558 #endif
    2559 
    2560 #if !SEC_INTER_SDC_G0101
    2561 Void TComDataCU::xSetInterSDCCUMask( TComDataCU *pcCU, UChar *pMask )
    2562 {
    2563   UInt  uiWidth      = pcCU->getWidth ( 0 );
    2564   UInt  uiHeight     = pcCU->getHeight( 0 );
    2565   UInt  uiPartitionSize = pcCU->getPartitionSize( 0 );
    2566   UInt  uiXOffset = 0, uiYOffset = 0;
    2567 
    2568   switch( uiPartitionSize )
    2569   {
    2570   case SIZE_2NxN:
    2571     uiXOffset = uiWidth;      uiYOffset = uiHeight >> 1;   break;
    2572   case SIZE_2NxnU:
    2573     uiXOffset = uiWidth;      uiYOffset = uiHeight >> 2;   break;
    2574   case SIZE_2NxnD:
    2575     uiXOffset = uiWidth;      uiYOffset = ( uiHeight >> 1 ) + ( uiHeight >> 2 );   break;
    2576   case SIZE_Nx2N:
    2577     uiXOffset = uiWidth >> 1; uiYOffset = uiHeight; break;
    2578   case SIZE_nLx2N:
    2579     uiXOffset = uiWidth >> 2; uiYOffset = uiHeight; break;
    2580   case SIZE_nRx2N:
    2581     uiXOffset = ( uiWidth >> 1 ) + ( uiWidth >> 2 ); uiYOffset = uiHeight; break;
    2582   case SIZE_NxN:
    2583     uiXOffset = uiWidth >> 1; uiYOffset = uiHeight >> 1;  break;
    2584   default:
    2585     assert( uiPartitionSize == SIZE_2Nx2N );
    2586     uiXOffset = uiWidth;     uiYOffset = uiHeight;    break;
    2587   }
    2588 
    2589   UInt uiPelX, uiPelY;
    2590 
    2591   memset( pMask, 0, uiWidth*uiHeight );
    2592 
    2593   //mask
    2594   if( uiPartitionSize == SIZE_2NxN || uiPartitionSize == SIZE_2NxnD || uiPartitionSize == SIZE_2NxnU )
    2595   {
    2596     for( uiPelY = 0; uiPelY < uiYOffset; uiPelY++ )
    2597     {
    2598       for( uiPelX = 0; uiPelX < uiWidth; uiPelX++ )
    2599       {
    2600         pMask[uiPelX + uiPelY*uiWidth] = 0;
    2601       }
    2602     }
    2603 
    2604     for( ; uiPelY < uiHeight; uiPelY++ )
    2605     {
    2606       for( uiPelX = 0; uiPelX < uiWidth; uiPelX++ )
    2607       {
    2608         pMask[uiPelX + uiPelY*uiWidth] = 1;
    2609       }
    2610     }
    2611   }
    2612   else if( uiPartitionSize == SIZE_Nx2N || uiPartitionSize == SIZE_nLx2N || uiPartitionSize == SIZE_nRx2N )
    2613   {
    2614     for( uiPelY = 0; uiPelY < uiHeight; uiPelY++ )
    2615     {
    2616       for( uiPelX = 0; uiPelX < uiXOffset; uiPelX++ )
    2617       {
    2618         pMask[uiPelX + uiPelY*uiWidth] = 0;
    2619       }
    2620 
    2621       for( ; uiPelX < uiWidth; uiPelX++ )
    2622       {
    2623         pMask[uiPelX + uiPelY*uiWidth] = 1;
    2624       }
    2625     }
    2626   }
    2627   else if( uiPartitionSize == SIZE_NxN )
    2628   {
    2629     for( uiPelY = 0; uiPelY < uiYOffset; uiPelY++ )
    2630     {
    2631       for( uiPelX = 0; uiPelX < uiXOffset; uiPelX++ )
    2632       {
    2633         pMask[uiPelX + uiPelY*uiWidth] = 0;
    2634       }
    2635 
    2636       for( ; uiPelX < uiWidth; uiPelX++ )
    2637       {
    2638         pMask[uiPelX + uiPelY*uiWidth] = 1;
    2639       }
    2640     }
    2641 
    2642     for( ; uiPelY < uiHeight; uiPelY++ )
    2643     {
    2644       for( uiPelX = 0; uiPelX < uiXOffset; uiPelX++ )
    2645       {
    2646         pMask[uiPelX + uiPelY*uiWidth] = 2;
    2647       }
    2648 
    2649       for( ; uiPelX < uiWidth; uiPelX++ )
    2650       {
    2651         pMask[uiPelX + uiPelY*uiWidth] = 3;
    2652       }
    2653     }
    2654   }
    2655 
    2656 }
    2657 #endif
    2658 #endif
    2659 
    26602377#if QC_GENERIC_SDC_G0122
    26612378UInt TComDataCU::getCtxSDCFlag( UInt uiAbsPartIdx )
    26622379{
    2663 #if QC_SDC_UNIFY_G0130
    26642380  return 0;
    2665 #else
    2666   TComDataCU* pcTempCU;
    2667   UInt        uiTempPartIdx;
    2668   UInt        uiCtx = 0;
    2669 
    2670   // Get BCBP of left PU
    2671   pcTempCU = getPULeft( uiTempPartIdx, m_uiAbsIdxInLCU + uiAbsPartIdx );
    2672   uiCtx    = ( pcTempCU && pcTempCU->isIntra( uiTempPartIdx ) ) ? pcTempCU->getSDCFlag( uiTempPartIdx ) : 0;
    2673 
    2674   // Get BCBP of above PU
    2675   pcTempCU = getPUAbove( uiTempPartIdx, m_uiAbsIdxInLCU + uiAbsPartIdx );
    2676   uiCtx   += ( pcTempCU && pcTempCU->isIntra( uiTempPartIdx ) ) ? pcTempCU->getSDCFlag( uiTempPartIdx ) : 0;
    2677 
    2678   return uiCtx;
    2679 #endif
    26802381}
    26812382
     
    71936894      TComDataCU* pcBaseCU;
    71946895      Int iPartition = 0;
    7195 #if !KHU_SIMP_SPIVMP_G0147
    7196       Int iInterDirLast = 0;
    7197       TComMvField cMvFieldLast[2];
    7198 #endif
    71996896
    72006897      Int iDelX = iSPWidth/2;
    72016898      Int iDelY = iSPHeight/2;
    72026899
    7203 #if KHU_SIMP_SPIVMP_G0147
    72046900      Int         iCenterPosX = iCurrPosX + ( ( iWidth /  iSPWidth ) >> 1 )  * iSPWidth + ( iSPWidth >> 1 );
    72056901      Int         iCenterPosY = iCurrPosY + ( ( iHeight /  iSPHeight ) >> 1 )  * iSPHeight + (iSPHeight >> 1);
     
    72696965      if(availableMcDc[0])
    72706966      {
    7271 #endif
     6967
    72726968        Int         iBasePosX, iBasePosY;
    72736969        for (Int i=iCurrPosY; i < iCurrPosY + iHeight; i += iSPHeight)
     
    73287024            if (puhInterDirSP[iPartition] == 0)
    73297025            {
    7330 #if KHU_SIMP_SPIVMP_G0147
    73317026              puhInterDirSP[iPartition] = availableMcDc[0];
    73327027              pcMvFieldSP[2*iPartition].setMvField(pacPdmMv[0], paiPdmRefIdx[0]);
    73337028              pcMvFieldSP[2*iPartition + 1].setMvField(pacPdmMv[1], paiPdmRefIdx[1]);
    7334 #else
    7335               if (iInterDirLast != 0)
    7336               {
    7337                 puhInterDirSP[iPartition] = iInterDirLast;
    7338                 pcMvFieldSP[2*iPartition] = cMvFieldLast[0];
    7339                 pcMvFieldSP[2*iPartition + 1] = cMvFieldLast[1];
    7340               }
    7341 #endif
     7029
    73427030            }
    7343 #if !KHU_SIMP_SPIVMP_G0147
    7344             else
    7345             {
    7346               if (iInterDirLast ==0)
    7347               {
    7348                 availableMcDc[0] = puhInterDirSP[iPartition];
    7349                 paiPdmRefIdx  [ 0 ] = pcMvFieldSP[2*iPartition].getRefIdx();
    7350                 pacPdmMv      [ 0 ] = pcMvFieldSP[2*iPartition].getMv();
    7351                 paiPdmRefIdx  [ 1 ] = pcMvFieldSP[2*iPartition+1].getRefIdx();
    7352                 pacPdmMv      [ 1 ] = pcMvFieldSP[2*iPartition+1].getMv();
    7353 
    7354                 if (iPartition != 0)
    7355                 {
    7356                   for (Int iPart = iPartition-1; iPart >= 0; iPart--)
    7357                   {
    7358                     puhInterDirSP[iPart] = puhInterDirSP[iPartition];
    7359                     pcMvFieldSP[2*iPart] = pcMvFieldSP[2*iPartition];
    7360                     pcMvFieldSP[2*iPart + 1] = pcMvFieldSP[2*iPartition + 1];
    7361                   }
    7362                 }
    7363               }
    7364               iInterDirLast = puhInterDirSP[iPartition];
    7365               cMvFieldLast[0] = pcMvFieldSP[2*iPartition];
    7366               cMvFieldLast[1] = pcMvFieldSP[2*iPartition + 1];
    7367             }
    7368 #endif
    73697031            iPartition ++;
    7370 
    73717032          }
    73727033        }
    7373 #if KHU_SIMP_SPIVMP_G0147
    7374       }
    7375 #endif
     7034      }
    73767035    }
    73777036
  • branches/HTM-10.1-dev0/source/Lib/TLibCommon/TComDataCU.h

    r876 r877  
    192192#if H_3D_DIM_SDC
    193193  Bool*         m_pbSDCFlag;
    194 #if QC_SDC_UNIFY_G0130 && !SEC_INTER_SDC_G0101
    195   Pel*          m_apSegmentDCOffset[4];
    196 #else
    197194  Pel*          m_apSegmentDCOffset[2];
    198 #endif
    199 #endif
    200 #endif
    201 #if H_3D_INTER_SDC
    202 #if !QC_SDC_UNIFY_G0130
    203   Bool*         m_pbInterSDCFlag;
    204   Int*          m_apSegmentInterDCOffset[4];
    205 #endif
    206 #if !SEC_INTER_SDC_G0101
    207   UChar*        m_pucInterSDCMask;
    208195#endif
    209196#endif
     
    575562#endif
    576563#endif
    577 #if H_3D_INTER_SDC
    578 #if !QC_SDC_UNIFY_G0130
    579   Bool*         getInterSDCFlag     ()                        { return m_pbInterSDCFlag;               }
    580   Bool          getInterSDCFlag     ( UInt uiIdx )            { return m_pbInterSDCFlag[uiIdx];        }
    581   Void          setInterSDCFlagSubParts ( Bool bInterSDCFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
    582   UInt          getCtxInterSDCFlag  ( UInt uiAbsPartIdx );
    583   Int*          getInterSDCSegmentDCOffset( UInt uiSeg ) { return m_apSegmentInterDCOffset[uiSeg]; }
    584   Int           getInterSDCSegmentDCOffset( UInt uiSeg, UInt uiPartIdx ) { return m_apSegmentInterDCOffset[uiSeg][uiPartIdx]; }
    585   Void          setInterSDCSegmentDCOffset( Int pOffset, UInt uiSeg, UInt uiPartIdx) { m_apSegmentInterDCOffset[uiSeg][uiPartIdx] = pOffset; }
    586 
    587 #endif
    588 #if !SEC_INTER_SDC_G0101
    589   Void          xSetInterSDCCUMask( TComDataCU *pcCU, UChar *pMask );
    590 
    591   UChar*        getInterSDCMask     ()                        { return m_pucInterSDCMask;              }
    592 #endif
    593 #endif
    594564 
    595565  // -------------------------------------------------------------------------------------------------------------------
  • branches/HTM-10.1-dev0/source/Lib/TLibCommon/TypeDef.h

    r876 r877  
    183183                                              // SEC_DMM3_RBC_F0147 Removal of DMM3 and RBC from DMMs
    184184                                              // QC_DIM_DELTADC_UNIFY_F0132 Unify delta DC coding in depth intra modes
     185                                              // Unify intra SDC and inter SDC
     186
    185187
    186188#define H_3D_INTER_SDC                    1   // INTER SDC, Inter simplified depth coding
    187                                               // LGE_INTER_SDC_E0156  Enable inter SDC for depth coding
     189                                              // LGE_INTER_SDC_E0156 Enable inter SDC for depth coding
     190                                              // SEC_INTER_SDC_G0101 Improved inter SDC with multiple DC candidates
     191
    188192#define H_3D_SPIVMP                       1   // H_3D_SPIVMP    // JCT3V-F0110: Sub-PU level inter-view motion prediction
    189193                                              // SEC_SPIVMP_MCP_SIZE_G0077, Apply SPIVMP only to 2Nx2N partition, JCT3V-G0077
    190194                                              // QC_SPIVMP_MPI_G0119 Sub-PU level MPI merge candidate
     195                                              // Simplification on Sub-PU level temporal interview motion prediction
    191196#define H_3D_FCO                          0   // Flexible coding order for 3D
    192197
     
    313318#define SCU_HS_DEPTH_DC_PRED_G0143        1
    314319#define QC_GENERIC_SDC_G0122              1  // Generalize SDC to all depth intra modes
    315 #if H_3D_DIM_SDC && H_3D_INTER_SDC
    316 #define QC_SDC_UNIFY_G0130                1  // Unify intra SDC and inter SDC
    317 #define QC_SDC_UNIFY_G0130_FIX            1  // Fix bug of G0130
    318 #define QC_SDC_UNIFY_G0130_FIX2           1  // Fix bug of G0130
    319 #endif
    320 #define SEC_INTER_SDC_G0101               1  // Improved inter SDC with multiple DC candidates
    321 #endif
    322 
    323 #define KHU_SIMP_SPIVMP_G0147             1  // Simplification on Sub-PU level temporal interview motion prediction
     320#endif
     321
    324322
    325323#endif
  • branches/HTM-10.1-dev0/source/Lib/TLibDecoder/TDecCAVLC.cpp

    r876 r877  
    30933093#endif
    30943094#if H_3D_INTER_SDC
    3095 #if QC_SDC_UNIFY_G0130
    30963095Void TDecCavlc::parseDeltaDC( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
    30973096{
     
    31033102  assert(0);
    31043103}
    3105 #else
    3106 Void TDecCavlc::parseInterSDCFlag    ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    3107 {
    3108   assert(0);
    3109 }
    3110 
    3111 Void TDecCavlc::parseInterSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPart )
    3112 {
    3113   assert(0);
    3114 }
    3115 #endif
     3104
    31163105#endif
    31173106#if H_3D_DBBP
  • branches/HTM-10.1-dev0/source/Lib/TLibDecoder/TDecCAVLC.h

    r872 r877  
    124124#endif
    125125#if H_3D_INTER_SDC
    126 #if QC_SDC_UNIFY_G0130
    127126  Void  parseDeltaDC        ( TComDataCU* pcCU, UInt absPartIdx, UInt depth );
    128127  Void  parseSDCFlag        ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    129 #else
    130   Void  parseInterSDCFlag    ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    131   Void  parseInterSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPart );
    132 #endif
    133128#endif
    134129#if H_3D_DBBP
  • branches/HTM-10.1-dev0/source/Lib/TLibDecoder/TDecCu.cpp

    r876 r877  
    539539  m_pcEntropyDecoder->decodePartSize( pcCU, uiAbsPartIdx, uiDepth );
    540540
    541 #if QC_SDC_UNIFY_G0130
     541#if H_3D_DIM_SDC
    542542  m_pcEntropyDecoder->decodeSDCFlag( pcCU, uiAbsPartIdx, uiDepth );
    543543#endif
     
    561561  // prediction mode ( Intra : direction mode, Inter : Mv, reference idx )
    562562  m_pcEntropyDecoder->decodePredInfo( pcCU, uiAbsPartIdx, uiDepth, m_ppcCU[uiDepth]);
    563 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    564   m_pcEntropyDecoder->decodeInterSDCFlag( pcCU, uiAbsPartIdx, uiDepth );
    565 #endif
    566563  // Coefficient decoding
    567564  Bool bCodeDQP = getdQPFlag();
     
    651648#endif
    652649#if H_3D_INTER_SDC
    653 #if QC_SDC_UNIFY_G0130
    654650      if( m_ppcCU[uiDepth]->getSDCFlag( 0 ) )
    655 #else
    656       if( m_ppcCU[uiDepth]->getInterSDCFlag( 0 ) )
    657 #endif
    658651      {
    659652        xReconInterSDC( m_ppcCU[uiDepth], uiAbsPartIdx, uiDepth );
     
    718711  UInt  uiWidth      = pcCU->getWidth ( 0 );
    719712  UInt  uiHeight     = pcCU->getHeight( 0 );
    720 #if !SEC_INTER_SDC_G0101
    721   UChar* pMask       = pcCU->getInterSDCMask();
    722 
    723   memset( pMask, 0, uiWidth*uiHeight );
    724   pcCU->xSetInterSDCCUMask( pcCU, pMask );
    725 #endif
    726713
    727714  Pel  *pResi;
     
    734721    for( uiPelX = 0; uiPelX < uiWidth; uiPelX++ )
    735722    {
    736 #if SEC_INTER_SDC_G0101
    737723      pResi[ uiPelX ] = pcCU->getSDCSegmentDCOffset( 0, 0 );
    738 #else
    739       UChar uiSeg = pMask[ uiPelX + uiPelY*uiWidth ];
    740 #if QC_SDC_UNIFY_G0130
    741       pResi[ uiPelX ] = pcCU->getSDCSegmentDCOffset( uiSeg, 0 );
    742 #else
    743       pResi[ uiPelX ] = pcCU->getInterSDCSegmentDCOffset( uiSeg, 0 );
    744 #endif
    745 #endif
    746724    }
    747725    pResi += uiResiStride;
  • branches/HTM-10.1-dev0/source/Lib/TLibDecoder/TDecEntropy.cpp

    r876 r877  
    779779  UInt uiLumaOffset   = uiMinCoeffSize*uiAbsPartIdx;
    780780  UInt uiChromaOffset = uiLumaOffset>>2;
    781 #if QC_SDC_UNIFY_G0130
    782781#if H_3D_DIM_SDC
    783782  if( pcCU->getSDCFlag( uiAbsPartIdx ) && pcCU->isIntra( uiAbsPartIdx) )
     
    789788    assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V) == 1 );
    790789  }
    791 #endif
    792790
    793791#if H_3D_INTER_SDC
     
    799797  }
    800798#endif
    801 #if QC_SDC_UNIFY_G0130_FIX
    802799  if( pcCU->getSlice()->getIsDepth() && ( pcCU->getSDCFlag( uiAbsPartIdx ) || pcCU->isIntra( uiAbsPartIdx ) ) )
    803 #else
    804   if( pcCU->getSDCFlag( uiAbsPartIdx ) || pcCU->isIntra( uiAbsPartIdx ) )
    805 #endif
    806800  {
    807801    Int iPartNum = ( pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_NxN ) ? 4 : 1;
     
    824818    }
    825819  }
    826 #else
    827 #if H_3D_DIM_SDC
    828   if( pcCU->getSDCFlag( uiAbsPartIdx ) )
    829   {
    830     assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
    831     assert( pcCU->getTransformIdx(uiAbsPartIdx) == 0 );
    832     assert( pcCU->getCbf(uiAbsPartIdx, TEXT_LUMA) == 1 );
    833     assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_U) == 1 );
    834     assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V) == 1 );
    835     return;
    836   }
    837 #endif
    838  
    839 #if H_3D_INTER_SDC
    840   if( pcCU->getInterSDCFlag( uiAbsPartIdx ) )
    841   {
    842     assert( !pcCU->isSkipped( uiAbsPartIdx ) );
    843     assert( !pcCU->isIntra( uiAbsPartIdx) );
    844     assert( pcCU->getSlice()->getIsDepth() );
    845 
    846     decodeInterSDCResidualData( pcCU, uiAbsPartIdx, uiDepth );
    847     return;
    848   }
    849 #endif
    850820#endif
    851821
     
    875845
    876846#if H_3D_INTER_SDC
    877 #if QC_SDC_UNIFY_G0130
    878847Void TDecEntropy::decodeSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    879848{
     
    886855  }
    887856
    888 #if SEC_INTER_SDC_G0101
    889857  if( !pcCU->getSlice()->getIsDepth() || pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_2Nx2N || pcCU->isSkipped( uiAbsPartIdx ) )
    890 #else
    891   if( !pcCU->getSlice()->getIsDepth() || ( pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_2Nx2N ) || pcCU->isSkipped( uiAbsPartIdx ) )
    892 #endif
    893858  {
    894859    return;
    895860  }
    896861
    897 #if SEC_INTER_SDC_G0101
    898862  assert( pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N || ( !pcCU->isIntra( uiAbsPartIdx ) && !pcCU->isSkipped( uiAbsPartIdx ) ) );
    899 #else
    900   assert( ( pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N ) || ( !pcCU->isIntra( uiAbsPartIdx ) && !pcCU->isSkipped( uiAbsPartIdx ) ) );
    901 #endif
    902 
    903863  m_pcEntropyDecoderIf->parseSDCFlag( pcCU, uiAbsPartIdx, uiDepth );
    904864}
    905 
    906 #else
    907 Void TDecEntropy::decodeInterSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    908 {
    909   pcCU->setInterSDCFlagSubParts( false, uiAbsPartIdx, 0, uiDepth);
    910 
    911   if( !pcCU->getSlice()->getVPS()->getInterSDCFlag( pcCU->getSlice()->getLayerIdInVps() ) )
    912   {
    913     return;
    914   }
    915 
    916   if( !pcCU->getSlice()->getIsDepth() || pcCU->isIntra( uiAbsPartIdx ) || pcCU->isSkipped( uiAbsPartIdx ) )
    917   {
    918     return;
    919   }
    920 
    921   m_pcEntropyDecoderIf->parseInterSDCFlag( pcCU, uiAbsPartIdx, uiDepth );
    922 }
    923 
    924 Void TDecEntropy::decodeInterSDCResidualData( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    925 {
    926   if( !pcCU->getSlice()->getVPS()->getInterSDCFlag( pcCU->getSlice()->getLayerIdInVps() ) )
    927   {
    928     return;
    929   }
    930 
    931   if( !pcCU->getSlice()->getIsDepth() || pcCU->isIntra( uiAbsPartIdx ) || !pcCU->getInterSDCFlag( uiAbsPartIdx ) )
    932   {
    933     return;
    934   }
    935 
    936   UInt uiNumSegments = ( pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N ) ? 1 : ( pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_NxN ? 4 : 2 );
    937 
    938   // decode residual data for each segment
    939   for( UInt uiSeg = 0; uiSeg < uiNumSegments; uiSeg++ )
    940   {
    941     m_pcEntropyDecoderIf->parseInterSDCResidualData( pcCU, uiAbsPartIdx, uiDepth, uiSeg );
    942   }
    943 }
    944 #endif
    945865#endif
    946866#if H_3D_DBBP
  • branches/HTM-10.1-dev0/source/Lib/TLibDecoder/TDecEntropy.h

    r872 r877  
    9696#endif
    9797#if H_3D_INTER_SDC
    98 #if QC_SDC_UNIFY_G0130
    9998  virtual Void parseDeltaDC       ( TComDataCU* pcCU, UInt absPartIdx, UInt depth ) = 0;
    10099  virtual Void parseSDCFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
    101 #else
    102   virtual Void parseInterSDCFlag  ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
    103   virtual Void parseInterSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPart ) = 0;
    104 #endif
    105100#endif
    106101#if H_3D_DBBP
     
    187182#endif
    188183#if H_3D_INTER_SDC
    189 #if QC_SDC_UNIFY_G0130
    190184  Void decodeSDCFlag           ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    191 #else
    192   Void decodeInterSDCFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    193   Void decodeInterSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    194 #endif
    195185#endif
    196186#if H_3D_DBBP
  • branches/HTM-10.1-dev0/source/Lib/TLibDecoder/TDecSbac.cpp

    r876 r877  
    8888#if QC_GENERIC_SDC_G0122
    8989, m_cAngleFlagSCModel         ( 1,             1,               NUM_ANGLE_FLAG_CTX            , m_contextModels + m_numContextModels, m_numContextModels)
    90 #if !QC_SDC_UNIFY_G0130
    91 , m_cIntraSdcFlagSCModel      ( 1,             1,               NUM_INTRASDC_FLAG_CTX         , m_contextModels + m_numContextModels, m_numContextModels)
    92 #endif
    9390#endif
    9491#if H_3D_DIM_DMM
     
    10097#endif
    10198#endif
    102 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    103 , m_cInterSDCFlagSCModel             ( 1,             1,  NUM_INTER_SDC_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
    104 , m_cInterSDCResidualSCModel         ( 1,             1,  NUM_INTER_SDC_RESIDUAL_CTX       , m_contextModels + m_numContextModels, m_numContextModels)
    105 , m_cInterSDCResidualSignFlagSCModel ( 1,             1,  NUM_INTER_SDC_SIGN_FLAG_CTX      , m_contextModels + m_numContextModels, m_numContextModels)
    106 #endif
    107 #if QC_SDC_UNIFY_G0130
     99#if H_3D_DIM_SDC
    108100, m_cSDCFlagSCModel                  ( 1,             1,  NUM_SDC_FLAG_CTX                 , m_contextModels + m_numContextModels, m_numContextModels)
    109101#endif
     
    182174#if QC_GENERIC_SDC_G0122
    183175  m_cAngleFlagSCModel.initBuffer         ( sliceType, qp, (UChar*)INIT_ANGLE_FLAG );
    184 #if !QC_SDC_UNIFY_G0130
    185   m_cIntraSdcFlagSCModel.initBuffer      ( sliceType, qp, (UChar*)INIT_INTRASDC_FLAG );
    186 #endif
    187176#endif
    188177#if H_3D_DIM_DMM
     
    194183#endif
    195184#endif
    196 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    197   m_cInterSDCFlagSCModel.initBuffer       ( sliceType, qp, (UChar*)INIT_INTER_SDC_FLAG );
    198   m_cInterSDCResidualSCModel.initBuffer   ( sliceType, qp, (UChar*)INIT_INTER_SDC_RESIDUAL );
    199   m_cInterSDCResidualSignFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_INTER_SDC_SIGN_FLAG );
    200 #endif
    201 #if QC_SDC_UNIFY_G0130
     185#if H_3D_DIM_SDC
    202186  m_cSDCFlagSCModel.initBuffer            ( sliceType, qp, (UChar*)INIT_SDC_FLAG );
    203187#endif
     
    262246#if QC_GENERIC_SDC_G0122
    263247  m_cAngleFlagSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_ANGLE_FLAG );
    264 #if !QC_SDC_UNIFY_G0130
    265   m_cIntraSdcFlagSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_INTRASDC_FLAG );
    266 #endif
    267248#endif
    268249#if H_3D_DIM_DMM
     
    274255#endif
    275256#endif
    276 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    277   m_cInterSDCFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_INTER_SDC_FLAG );
    278   m_cInterSDCResidualSCModel.initBuffer   ( eSliceType, iQp, (UChar*)INIT_INTER_SDC_RESIDUAL );
    279   m_cInterSDCResidualSignFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_INTER_SDC_SIGN_FLAG );
    280 #endif
    281 #if QC_SDC_UNIFY_G0130
     257#if H_3D_DIM_SDC
    282258  m_cSDCFlagSCModel.initBuffer            ( eSliceType, iQp, (UChar*)INIT_SDC_FLAG );
    283259#endif
     
    11711147  }
    11721148
    1173 #if !QC_SDC_UNIFY_G0130
    1174   if( dimType < DIM_NUM_TYPE || pcCU->getSDCFlag( absPartIdx ) )
    1175   {
    1176     UInt symbol;
    1177 #if QC_GENERIC_SDC_G0122
    1178     UInt uiNumSegments = isDimMode( dir ) ? 2 : 1;
    1179 #else
    1180     UInt uiNumSegments = ( dir == PLANAR_IDX ) ? 1 : 2;
    1181 #endif
    1182 
    1183     if( pcCU->getSDCFlag( absPartIdx ) )
    1184     {
    1185       assert(pcCU->getPartitionSize(absPartIdx)==SIZE_2Nx2N);
    1186       pcCU->setTrIdxSubParts(0, absPartIdx, depth);
    1187       pcCU->setCbfSubParts(1, 1, 1, absPartIdx, depth);
    1188     }
    1189 
    1190     m_pcTDecBinIf->decodeBin( symbol, m_cDdcFlagSCModel.get(0, 0, uiNumSegments-1) );
    1191 
    1192     if( symbol )
    1193     {
    1194       if( !pcCU->getSDCFlag( absPartIdx ) )
    1195       {
    1196         dir += symbol;
    1197       }
    1198     }
    1199     for( UInt segment = 0; segment < uiNumSegments; segment++ )
    1200     {
    1201       Pel valDeltaDC = 0;
    1202       if( symbol )
    1203       {
    1204         xParseDimDeltaDC( valDeltaDC, uiNumSegments );
    1205       }
    1206 
    1207       if( pcCU->getSDCFlag( absPartIdx ) )
    1208       {
    1209         pcCU->setSDCSegmentDCOffset( valDeltaDC, segment, absPartIdx );
    1210       }
    1211       else
    1212       {
    1213         pcCU->setDimDeltaDC( dimType, segment, absPartIdx, valDeltaDC );
    1214       }
    1215     }
    1216   }
    1217 #endif
    12181149  pcCU->setLumaIntraDirSubParts( (UChar)dir, absPartIdx, depth );
    12191150}
     
    12341165  uiIsDimMode = uiSymbol ? 0 : 1;
    12351166  pcCU->setLumaIntraDirSubParts( 0, absPartIdx, depth );
    1236 #if !QC_SDC_UNIFY_G0130
    1237   if( pcCU->getPartitionSize( absPartIdx ) == SIZE_2Nx2N ) //SDC is allowed only in this case
    1238   {
    1239     m_pcTDecBinIf->decodeBin( uiSymbol, m_cIntraSdcFlagSCModel.get( 0, 0, pcCU->getCtxSDCFlag( absPartIdx ) ) );
    1240   }
    1241   else
    1242   {
    1243     uiSymbol = 0;
    1244   }
    1245 
    1246   pcCU->setSDCFlagSubParts( uiSymbol, absPartIdx, depth );
    1247 #endif
     1167
    12481168  //decode DMM index
    12491169  if( uiIsDimMode )
     
    22272147
    22282148#if H_3D_INTER_SDC
    2229 #if QC_SDC_UNIFY_G0130
    22302149Void TDecSbac::parseDeltaDC( TComDataCU* pcCU, UInt absPartIdx, UInt depth )
    22312150{
     
    22582177  else
    22592178  {
    2260 #if SEC_INTER_SDC_G0101
    22612179    uiNumSegments = 1;
    2262 #else
    2263     PartSize cPartSize = pcCU->getPartitionSize( absPartIdx );
    2264     uiNumSegments = ( cPartSize == SIZE_2Nx2N ) ? 1 : ( cPartSize == SIZE_NxN ? 4 : 2 );
    2265 #endif
    22662180    symbol = 1;
    22672181  }
     
    23142228  }
    23152229}
    2316 #else
    2317 Void TDecSbac::parseInterSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    2318 {
    2319   UInt uiSymbol = 0;
    2320   UInt uiCtxInterSDCFlag = pcCU->getCtxInterSDCFlag( uiAbsPartIdx );
    2321 
    2322   m_pcTDecBinIf->decodeBin( uiSymbol, m_cInterSDCFlagSCModel.get( 0, 0, uiCtxInterSDCFlag ) );
    2323 
    2324   if( uiSymbol )
    2325   {
    2326     pcCU->setInterSDCFlagSubParts( true, uiAbsPartIdx, 0, uiDepth );
    2327     pcCU->setTrIdxSubParts( 0, uiAbsPartIdx, uiDepth );
    2328     pcCU->setCbfSubParts( 1, 1, 1, uiAbsPartIdx, uiDepth );
    2329   }
    2330   else
    2331   {
    2332     pcCU->setInterSDCFlagSubParts( false, uiAbsPartIdx, 0, uiDepth);
    2333   }
    2334 }
    2335 
    2336 Void TDecSbac::parseInterSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiSegment )
    2337 {
    2338   UInt uiAbsIdx   = 0;
    2339   UInt uiSign     = 0;
    2340   Int  iIdx       = 0;
    2341 
    2342   xReadExGolombLevel( uiAbsIdx, m_cInterSDCResidualSCModel.get( 0, 0, 0 ) );
    2343 
    2344   uiAbsIdx++;
    2345   m_pcTDecBinIf->decodeBin( uiSign, m_cInterSDCResidualSignFlagSCModel.get( 0, 0, 0 ) );
    2346   iIdx = (Int)( uiSign ? -1 : 1 ) * uiAbsIdx;
    2347 
    2348   pcCU->setInterSDCSegmentDCOffset( iIdx, uiSegment, uiAbsPartIdx );
    2349 }
    2350 #endif
     2230
    23512231#endif
    23522232
  • branches/HTM-10.1-dev0/source/Lib/TLibDecoder/TDecSbac.h

    r872 r877  
    112112#endif
    113113#if H_3D_INTER_SDC
    114 #if QC_SDC_UNIFY_G0130
    115114  Void  parseDeltaDC         ( TComDataCU* pcCU, UInt absPartIdx, UInt depth );
    116115  Void  parseSDCFlag         ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    117 #else
    118   Void  parseInterSDCFlag    ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    119   Void  parseInterSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPart );
    120 #endif
    121116#endif
    122117#if H_3D_DBBP
     
    220215#if QC_GENERIC_SDC_G0122
    221216  ContextModel3DBuffer m_cAngleFlagSCModel;
    222 #if !QC_SDC_UNIFY_G0130
    223   ContextModel3DBuffer m_cIntraSdcFlagSCModel;
    224 #endif
    225217#endif
    226218#if H_3D_DIM_DMM
     
    232224#endif
    233225#endif
    234 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    235   ContextModel3DBuffer m_cInterSDCFlagSCModel;
    236   ContextModel3DBuffer m_cInterSDCResidualSCModel;
    237   ContextModel3DBuffer m_cInterSDCResidualSignFlagSCModel;
    238 #endif
    239 #if QC_SDC_UNIFY_G0130
     226#if H_3D_DIM_SDC 
    240227  ContextModel3DBuffer m_cSDCFlagSCModel;
    241228#endif
  • branches/HTM-10.1-dev0/source/Lib/TLibEncoder/TEncCavlc.cpp

    r876 r877  
    28142814
    28152815#if H_3D_INTER_SDC
    2816 #if QC_SDC_UNIFY_G0130
    28172816Void TEncCavlc::codeDeltaDC( TComDataCU* pcCU, UInt uiAbsPartIdx )
    28182817{
     
    28242823  assert(0);
    28252824}
    2826 #else
    2827 Void TEncCavlc::codeInterSDCFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx )
    2828 {
    2829   assert(0);
    2830 }
    2831 
    2832 Void TEncCavlc::codeInterSDCResidualData  ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiSegment )
    2833 {
    2834   assert(0);
    2835 }
    2836 #endif
     2825
    28372826#endif
    28382827   
  • branches/HTM-10.1-dev0/source/Lib/TLibEncoder/TEncCavlc.h

    r872 r877  
    133133#endif
    134134#if H_3D_INTER_SDC
    135 #if QC_SDC_UNIFY_G0130
    136135  Void codeDeltaDC       ( TComDataCU* pcCU, UInt uiAbsPartIdx );
    137136  Void codeSDCFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx );
    138 #else
    139   Void codeInterSDCFlag          ( TComDataCU* pcCU, UInt uiAbsPartIdx );
    140   Void codeInterSDCResidualData  ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiSegment );
    141 #endif
    142137#endif
    143138#if H_3D_DBBP
  • branches/HTM-10.1-dev0/source/Lib/TLibEncoder/TEncCu.cpp

    r876 r877  
    15421542  m_pcEntropyCoder->encodePartSize( pcCU, uiAbsPartIdx, uiDepth );
    15431543 
    1544 #if QC_SDC_UNIFY_G0130
     1544#if H_3D_DIM_SDC
    15451545  m_pcEntropyCoder->encodeSDCFlag( pcCU, uiAbsPartIdx, false );
    15461546#endif
     
    15661566  m_pcEntropyCoder->encodeICFlag  ( pcCU, uiAbsPartIdx );
    15671567#endif
    1568 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    1569   m_pcEntropyCoder->encodeInterSDCFlag( pcCU, uiAbsPartIdx, false );
    1570 #endif
    1571 
    15721568  // Encode Coefficients
    15731569  Bool bCodeDQP = getdQPFlag();
     
    19861982          if( rpcTempCU->getSlice()->getVPS()->getInterSDCFlag( rpcTempCU->getSlice()->getLayerIdInVps() ) && rpcTempCU->getSlice()->getIsDepth() && !uiNoResidual )
    19871983          {
    1988 #if SEC_INTER_SDC_G0101
    19891984            for( Int uiOffest = -2 ; uiOffest <= 2 ; uiOffest++ )
    19901985            {
     
    20182013              xCheckBestMode( rpcBestCU, rpcTempCU, uhDepth );
    20192014            }
    2020 #else
    2021             if( rpcTempCU != rpcTempCUPre )
    2022             {
    2023               rpcTempCU->initEstData( uhDepth, orgQP, bTransquantBypassFlag  );
    2024               rpcTempCU->copyPartFrom( rpcBestCU, 0, uhDepth );
    2025             }
    2026             rpcTempCU->setSkipFlagSubParts( false, 0, uhDepth );
    2027             rpcTempCU->setTrIdxSubParts( 0, 0, uhDepth );
    2028             rpcTempCU->setCbfSubParts( 1, 1, 1, 0, uhDepth );
    2029 #if H_3D_VSO //M2
    2030             if( m_pcRdCost->getUseRenModel() )
    2031             { //Reset
    2032               UInt  uiWidth     = m_ppcOrigYuv[uhDepth]->getWidth    ();
    2033               UInt  uiHeight    = m_ppcOrigYuv[uhDepth]->getHeight   ();
    2034               Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr ();
    2035               UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride   ();
    2036               m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
    2037             }
    2038 #endif
    2039             m_pcPredSearch->encodeResAndCalcRdInterSDCCU( rpcTempCU,
    2040               m_ppcOrigYuv[uhDepth],
    2041               ( rpcTempCU != rpcTempCUPre ) ? m_ppcPredYuvBest[uhDepth] : m_ppcPredYuvTemp[uhDepth],
    2042               m_ppcResiYuvTemp[uhDepth],
    2043               m_ppcRecoYuvTemp[uhDepth],
    2044               uhDepth );
    2045 
    2046             xCheckDQP( rpcTempCU );
    2047             xCheckBestMode( rpcBestCU, rpcTempCU, uhDepth );
    2048 #endif
    20492015          }
    20502016#endif
     
    22512217  xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
    22522218#if H_3D_INTER_SDC
    2253 #if SEC_INTER_SDC_G0101 // ONLY_2NX2N_SDC
    22542219  if( rpcTempCU->getSlice()->getVPS()->getInterSDCFlag( rpcTempCU->getSlice()->getLayerIdInVps() ) && rpcTempCU->getSlice()->getIsDepth() && ePartSize == SIZE_2Nx2N)
    2255 #else
    2256   if( rpcTempCU->getSlice()->getVPS()->getInterSDCFlag( rpcTempCU->getSlice()->getLayerIdInVps() ) && rpcTempCU->getSlice()->getIsDepth() )
    2257 #endif
    2258   {
    2259 #if SEC_INTER_SDC_G0101
     2220  {
    22602221    for( Int uiOffest = -2 ; uiOffest <= 2 ; uiOffest++ )
    22612222    {
     
    22952256      xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
    22962257    }
    2297 #else
    2298     if( rpcTempCU != rpcTempCUPre )
    2299     {
    2300       Int orgQP = rpcBestCU->getQP( 0 );
    2301       rpcTempCU->initEstData( uhDepth, orgQP );
    2302       rpcTempCU->copyPartFrom( rpcBestCU, 0, uhDepth );
    2303     }
    2304     rpcTempCU->setSkipFlagSubParts( false, 0, uhDepth );
    2305     rpcTempCU->setTrIdxSubParts( 0, 0, uhDepth );
    2306     rpcTempCU->setCbfSubParts( 1, 1, 1, 0, uhDepth );
    2307 #if H_3D_VSO // M3
    2308     if( m_pcRdCost->getUseRenModel() )
    2309     {
    2310       UInt  uiWidth     = m_ppcOrigYuv[uhDepth]->getWidth ( );
    2311       UInt  uiHeight    = m_ppcOrigYuv[uhDepth]->getHeight( );
    2312       Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr( );
    2313       UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride();
    2314       m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
    2315     }
    2316 #endif
    2317 
    2318     m_pcPredSearch->encodeResAndCalcRdInterSDCCU( rpcTempCU,
    2319       m_ppcOrigYuv[uhDepth],
    2320       ( rpcTempCU != rpcTempCUPre ) ? m_ppcPredYuvBest[uhDepth] : m_ppcPredYuvTemp[uhDepth],
    2321       m_ppcResiYuvTemp[uhDepth],
    2322       m_ppcRecoYuvTemp[uhDepth],
    2323       uhDepth );
    2324 
    2325   xCheckDQP( rpcTempCU );
    2326   xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
    2327 #endif
     2258
    23282259  }
    23292260#endif
     
    25682499  m_pcEntropyCoder->encodePredMode( rpcTempCU, 0,          true );
    25692500  m_pcEntropyCoder->encodePartSize( rpcTempCU, 0, uiDepth, true );
    2570 #if QC_SDC_UNIFY_G0130
     2501#if H_3D_DIM_SDC
    25712502  m_pcEntropyCoder->encodeSDCFlag( rpcTempCU, 0, true );
    25722503#endif
     
    26252556  m_pcEntropyCoder->encodePredMode ( rpcTempCU, 0,          true );
    26262557  m_pcEntropyCoder->encodePartSize ( rpcTempCU, 0, uiDepth, true );
    2627 #if QC_SDC_UNIFY_G0130
     2558#if H_3D_DIM_SDC
    26282559  m_pcEntropyCoder->encodeSDCFlag( rpcTempCU, 0, true );
    26292560#endif
  • branches/HTM-10.1-dev0/source/Lib/TLibEncoder/TEncEntropy.cpp

    r876 r877  
    666666  UInt uiLumaOffset   = uiMinCoeffSize*uiAbsPartIdx;
    667667  UInt uiChromaOffset = uiLumaOffset>>2;
    668 #if QC_SDC_UNIFY_G0130
    669668#if H_3D_DIM_SDC
    670669  if( pcCU->getSDCFlag( uiAbsPartIdx ) && pcCU->isIntra( uiAbsPartIdx ) )
     
    676675    assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V) == 1 );
    677676  }
    678 #endif
    679 
    680 #if H_3D_INTER_SDC
     677
    681678  if( pcCU->getSDCFlag( uiAbsPartIdx ) && !pcCU->isIntra( uiAbsPartIdx ) )
    682679  {
     
    685682    assert( pcCU->getSlice()->getIsDepth() );
    686683  }
    687 #endif
    688 #if QC_SDC_UNIFY_G0130_FIX
     684
    689685  if( pcCU->getSlice()->getIsDepth() && ( pcCU->getSDCFlag( uiAbsPartIdx ) || pcCU->isIntra( uiAbsPartIdx ) ) )
    690 #else
    691   if( pcCU->getSDCFlag( uiAbsPartIdx ) || pcCU->isIntra( uiAbsPartIdx ) )
    692 #endif
    693686  {
    694687    Int iPartNum = ( pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_NxN ) ? 4 : 1;
     
    711704    }
    712705  }
    713 #else
    714 #if H_3D_DIM_SDC
    715   if( pcCU->getSDCFlag( uiAbsPartIdx ) )
    716   {
    717     assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
    718     assert( pcCU->getTransformIdx(uiAbsPartIdx) == 0 );
    719     assert( pcCU->getCbf(uiAbsPartIdx, TEXT_LUMA) == 1 );
    720     assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_U) == 1 );
    721     assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V) == 1 );
    722     return;
    723   }
    724 #endif
    725 
    726 #if H_3D_INTER_SDC
    727   if( pcCU->getInterSDCFlag( uiAbsPartIdx ) )
    728   {
    729     assert( !pcCU->isSkipped( uiAbsPartIdx ) );
    730     assert( !pcCU->isIntra( uiAbsPartIdx) );
    731     assert( pcCU->getSlice()->getIsDepth() );
    732 
    733     encodeInterSDCResidualData( pcCU, uiAbsPartIdx, false );
    734     return;
    735   }
    736 #endif
    737706#endif
    738707
     
    795764
    796765#if H_3D_INTER_SDC
    797 #if QC_SDC_UNIFY_G0130
    798766Void TEncEntropy::encodeDeltaDC  ( TComDataCU* pcCU, UInt absPartIdx )
    799767{
     
    809777  }
    810778
    811 #if SEC_INTER_SDC_G0101
    812779  if( !pcCU->getSlice()->getIsDepth() || pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_2Nx2N || pcCU->isSkipped( uiAbsPartIdx ) )
    813 #else
    814   if( !pcCU->getSlice()->getIsDepth() || ( pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_2Nx2N ) || pcCU->isSkipped( uiAbsPartIdx ) )
    815 #endif
    816   {
    817     return;
    818   }
    819 
    820 #if SEC_INTER_SDC_G0101
     780  {
     781    return;
     782  }
     783
    821784  assert( pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N || ( !pcCU->isIntra( uiAbsPartIdx ) && !pcCU->isSkipped( uiAbsPartIdx ) ) );
    822 #else
    823   assert( ( pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N ) || ( !pcCU->isIntra( uiAbsPartIdx ) && !pcCU->isSkipped( uiAbsPartIdx ) ) );
    824 #endif
    825785
    826786  if( bRD )
     
    831791  m_pcEntropyCoderIf->codeSDCFlag( pcCU, uiAbsPartIdx );
    832792}
    833 #else
    834 Void TEncEntropy::encodeInterSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
    835 {
    836   if( !pcCU->getSlice()->getVPS()->getInterSDCFlag( pcCU->getSlice()->getLayerIdInVps() ) )
    837   {
    838     return;
    839   }
    840 
    841   if( !pcCU->getSlice()->getIsDepth() || pcCU->isIntra( uiAbsPartIdx ) || pcCU->isSkipped( uiAbsPartIdx ) )
    842   {
    843     return;
    844   }
    845 
    846   if( bRD )
    847   {
    848     uiAbsPartIdx = 0;
    849   }
    850 
    851   m_pcEntropyCoderIf->codeInterSDCFlag( pcCU, uiAbsPartIdx );
    852 }
    853 
    854 Void TEncEntropy::encodeInterSDCResidualData( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
    855 {
    856   if( !pcCU->getSlice()->getVPS()->getInterSDCFlag( pcCU->getSlice()->getLayerIdInVps() ) )
    857   {
    858     return;
    859   }
    860 
    861   if( !pcCU->getSlice()->getIsDepth() || pcCU->isIntra( uiAbsPartIdx ) || !pcCU->getInterSDCFlag( uiAbsPartIdx ) )
    862   {
    863     return;
    864   }
    865 
    866   if( bRD )
    867   {
    868     uiAbsPartIdx = 0;
    869   }
    870 
    871   // number of segments depends on prediction mode for INTRA
    872   UInt uiNumSegments = ( pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N ) ? 1 : ( pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_NxN ? 4 : 2 );
    873 
    874   // encode residual data for each segment
    875   for( UInt uiSeg = 0; uiSeg < uiNumSegments; uiSeg++ )
    876   {
    877     m_pcEntropyCoderIf->codeInterSDCResidualData( pcCU, uiAbsPartIdx, uiSeg );
    878   }
    879 }
    880 #endif
     793
    881794#endif
    882795#if H_3D_DBBP
  • branches/HTM-10.1-dev0/source/Lib/TLibEncoder/TEncEntropy.h

    r872 r877  
    9595#endif
    9696#if H_3D_INTER_SDC
    97 #if QC_SDC_UNIFY_G0130
    9897  virtual Void codeDeltaDC       ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
    9998  virtual Void codeSDCFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
    100 #else
    101   virtual Void codeInterSDCFlag  ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
    102   virtual Void codeInterSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiSegment ) = 0;
    103 #endif
    10499#endif
    105100#if H_3D_DBBP
     
    190185#endif
    191186#if H_3D_INTER_SDC
    192 #if QC_SDC_UNIFY_G0130
    193187  Void encodeDeltaDC      ( TComDataCU* pcCU, UInt absPartIdx );
    194188  Void encodeSDCFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
    195 #else
    196   Void encodeInterSDCFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
    197   Void encodeInterSDCResidualData( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD );
    198 #endif
    199189#endif
    200190#if H_3D_DBBP
  • branches/HTM-10.1-dev0/source/Lib/TLibEncoder/TEncSbac.cpp

    r876 r877  
    9494#if QC_GENERIC_SDC_G0122
    9595, m_cAngleFlagSCModel         ( 1,             1,               NUM_ANGLE_FLAG_CTX            , m_contextModels + m_numContextModels, m_numContextModels)
    96 #if !QC_SDC_UNIFY_G0130
    97 , m_cIntraSdcFlagSCModel      ( 1,             1,               NUM_INTRASDC_FLAG_CTX         , m_contextModels + m_numContextModels, m_numContextModels)
    98 #endif
    9996#endif
    10097#if H_3D_DIM_DMM
     
    106103#endif
    107104#endif
    108 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    109 , m_cInterSDCFlagSCModel             ( 1,             1,  NUM_INTER_SDC_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
    110 , m_cInterSDCResidualSCModel         ( 1,             1,  NUM_INTER_SDC_RESIDUAL_CTX       , m_contextModels + m_numContextModels, m_numContextModels)
    111 , m_cInterSDCResidualSignFlagSCModel ( 1,             1,  NUM_INTER_SDC_SIGN_FLAG_CTX      , m_contextModels + m_numContextModels, m_numContextModels)
    112 #endif
    113 #if QC_SDC_UNIFY_G0130
     105#if H_3D_DIM_SDC
    114106, m_cSDCFlagSCModel                  ( 1,             1,  NUM_SDC_FLAG_CTX                 , m_contextModels + m_numContextModels, m_numContextModels)
    115107#endif
     
    180172#if QC_GENERIC_SDC_G0122
    181173  m_cAngleFlagSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_ANGLE_FLAG );
    182 #if !QC_SDC_UNIFY_G0130
    183   m_cIntraSdcFlagSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_INTRASDC_FLAG );
    184 #endif
    185174#endif
    186175#if H_3D_DIM_DMM
     
    192181#endif
    193182#endif
    194 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    195   m_cInterSDCFlagSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_INTER_SDC_FLAG );
    196   m_cInterSDCResidualSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_INTER_SDC_RESIDUAL );
    197   m_cInterSDCResidualSignFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_INTER_SDC_SIGN_FLAG );
    198 #endif
    199 #if QC_SDC_UNIFY_G0130
     183#if H_3D_DIM_SDC
    200184  m_cSDCFlagSCModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_SDC_FLAG );
    201185#endif
     
    240224      curCost += m_cCUICFlagSCModel.calcCost          ( curSliceType, qp, (UChar*)INIT_IC_FLAG );
    241225#endif
    242 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    243       curCost += m_cInterSDCFlagSCModel.calcCost      ( curSliceType, qp, (UChar*)INIT_INTER_SDC_FLAG );
    244       curCost += m_cInterSDCResidualSCModel.calcCost  ( curSliceType, qp, (UChar*)INIT_INTER_SDC_RESIDUAL );
    245       curCost += m_cInterSDCResidualSignFlagSCModel.calcCost( curSliceType, qp, (UChar*)INIT_INTER_SDC_SIGN_FLAG );
    246 #endif
    247 #if QC_SDC_UNIFY_G0130
     226#if H_3D_DIM_SDC
    248227      curCost += m_cSDCFlagSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_SDC_FLAG );
    249228#endif
     
    281260#if QC_GENERIC_SDC_G0122
    282261      curCost += m_cAngleFlagSCModel.calcCost         ( curSliceType, qp, (UChar*)INIT_ANGLE_FLAG ); 
    283 #if !QC_SDC_UNIFY_G0130
    284       curCost += m_cIntraSdcFlagSCModel.calcCost      ( curSliceType, qp, (UChar*)INIT_INTRASDC_FLAG ); 
    285 #endif
    286262#endif
    287263#if H_3D_DIM_DMM
     
    350326#if QC_GENERIC_SDC_G0122
    351327  m_cAngleFlagSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_ANGLE_FLAG );
    352 #if !QC_SDC_UNIFY_G0130
    353   m_cIntraSdcFlagSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_INTRASDC_FLAG );
    354 #endif
    355328#endif
    356329#if H_3D_DIM_DMM
     
    362335#endif
    363336#endif
    364 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    365   m_cInterSDCFlagSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_INTER_SDC_FLAG );
    366   m_cInterSDCResidualSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_INTER_SDC_RESIDUAL );
    367   m_cInterSDCResidualSignFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_INTER_SDC_SIGN_FLAG );
    368 #endif
    369 #if QC_SDC_UNIFY_G0130
     337#if H_3D_DIM_SDC
    370338  m_cSDCFlagSCModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_SDC_FLAG );
    371339#endif
     
    674642#if QC_GENERIC_SDC_G0122
    675643  this->m_cAngleFlagSCModel      .copyFrom( &pSrc->m_cAngleFlagSCModel );
    676 #if !QC_SDC_UNIFY_G0130
    677   this->m_cIntraSdcFlagSCModel   .copyFrom( &pSrc->m_cIntraSdcFlagSCModel );
    678 #endif
    679644#endif
    680645}
     
    12901255  default: break;
    12911256  }
    1292 #if !QC_SDC_UNIFY_G0130
    1293   if( dimType < DIM_NUM_TYPE || pcCU->getSDCFlag( absPartIdx ) )
    1294   {
    1295     UInt dimDeltaDC;
    1296     Pel  deltaDC;
    1297 #if QC_GENERIC_SDC_G0122
    1298     UInt uiNumSegments = isDimMode( dir ) ? 2 : 1;
    1299 #else
    1300     UInt uiNumSegments = ( dir == PLANAR_IDX ) ? 1 : 2;
    1301 #endif
    1302     if( pcCU->getSDCFlag( absPartIdx ) )
    1303     {
    1304       if( uiNumSegments==1 )
    1305       {
    1306         dimDeltaDC = pcCU->getSDCSegmentDCOffset(0, absPartIdx) ? 1 : 0;
    1307       }
    1308       else
    1309       {
    1310         dimDeltaDC = ( pcCU->getSDCSegmentDCOffset(0, absPartIdx) || pcCU->getSDCSegmentDCOffset(1, absPartIdx) ) ? 1 : 0;
    1311       }
    1312     }
    1313     else
    1314     {
    1315       dimDeltaDC = isDimDeltaDC( dir );
    1316     }
    1317 
    1318     m_pcBinIf->encodeBin( dimDeltaDC, m_cDdcFlagSCModel.get(0, 0, uiNumSegments-1) );
    1319 
    1320     if( dimDeltaDC )
    1321     {
    1322       for( UInt segment = 0; segment < uiNumSegments; segment++ )
    1323       {
    1324         deltaDC = pcCU->getSDCFlag( absPartIdx ) ? pcCU->getSDCSegmentDCOffset(segment, absPartIdx) : pcCU->getDimDeltaDC( dimType, segment, absPartIdx );
    1325         xCodeDimDeltaDC( deltaDC, uiNumSegments );
    1326       }
    1327     }
    1328   }
    1329 #endif
    13301257}
    13311258
     
    13391266    m_pcBinIf->encodeBin( isDimMode( dir ) ? 0 : 1, m_cAngleFlagSCModel.get( 0, 0, pcCU->getCtxAngleFlag( absPartIdx ) ) );
    13401267  }
    1341 #if !QC_SDC_UNIFY_G0130
    1342   if( pcCU->getPartitionSize( absPartIdx ) == SIZE_2Nx2N ) //SDC is allowed only in this case
    1343   {
    1344     m_pcBinIf->encodeBin( pcCU->getSDCFlag( absPartIdx ) ? 1 : 0, m_cIntraSdcFlagSCModel.get( 0, 0, pcCU->getCtxSDCFlag( absPartIdx ) ) );
    1345 }
    1346 #endif
    13471268  if( isDimMode( dir ) )
    13481269  {
     
    24352356
    24362357#if H_3D_INTER_SDC
    2437 #if QC_SDC_UNIFY_G0130
    24382358Void TEncSbac::codeDeltaDC( TComDataCU* pcCU, UInt absPartIdx )
    24392359{
     
    24712391  else //all-zero inter SDC is not allowed
    24722392  {
    2473 #if SEC_INTER_SDC_G0101
    24742393    uiNumSegments = 1;
    2475 #else
    2476     PartSize cPartSize = pcCU->getPartitionSize( absPartIdx );
    2477     uiNumSegments = ( cPartSize == SIZE_2Nx2N ) ? 1 : ( cPartSize == SIZE_NxN ? 4 : 2 );
    2478 #endif
    24792394    dimDeltaDC = 1;
    24802395  }
     
    25082423  m_pcBinIf->encodeBin( uiSymbol, m_cSDCFlagSCModel.get( 0, 0, uiCtxSDCFlag ) );
    25092424}
    2510 #else
    2511 Void TEncSbac::codeInterSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
    2512 {
    2513   UInt uiSymbol = pcCU->getInterSDCFlag( uiAbsPartIdx ) ? 1 : 0;
    2514   UInt uiCtxInterSDCFlag = pcCU->getCtxInterSDCFlag( uiAbsPartIdx );
    2515 
    2516   m_pcBinIf->encodeBin( uiSymbol, m_cInterSDCFlagSCModel.get( 0, 0, uiCtxInterSDCFlag ) );
    2517 }
    2518 
    2519 Void TEncSbac::codeInterSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiSegment )
    2520 {
    2521   Pel segmentDCOffset = pcCU->getInterSDCSegmentDCOffset( uiSegment, uiAbsPartIdx );
    2522 
    2523   UInt uiSign     = segmentDCOffset < 0 ? 1 : 0;
    2524   UInt uiAbsIdx   = abs( segmentDCOffset );
    2525 
    2526   assert( uiAbsIdx > 0 );
    2527   uiAbsIdx--;
    2528   xWriteExGolombLevel( uiAbsIdx, m_cInterSDCResidualSCModel.get( 0, 0, 0 ) );
    2529   m_pcBinIf->encodeBin( uiSign, m_cInterSDCResidualSignFlagSCModel.get( 0, 0, 0 ) );
    2530 }
    2531 #endif
     2425
    25322426#endif
    25332427
  • branches/HTM-10.1-dev0/source/Lib/TLibEncoder/TEncSbac.h

    r872 r877  
    162162#endif
    163163#if H_3D_INTER_SDC
    164 #if QC_SDC_UNIFY_G0130
    165164  Void codeDeltaDC       ( TComDataCU* pcCU, UInt absPartIdx );
    166165  Void codeSDCFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx );
    167 #else
    168   Void codeInterSDCFlag  ( TComDataCU* pcCU, UInt uiAbsPartIdx );
    169   Void codeInterSDCResidualData  ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiSegment );
    170 #endif
    171166#endif
    172167#if H_3D_DBBP
     
    264259#if QC_GENERIC_SDC_G0122
    265260  ContextModel3DBuffer m_cAngleFlagSCModel;
    266 #if !QC_SDC_UNIFY_G0130
    267   ContextModel3DBuffer m_cIntraSdcFlagSCModel;
    268 #endif
    269261#endif
    270262#if H_3D_DIM_DMM
     
    276268#endif
    277269#endif
    278 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    279   ContextModel3DBuffer m_cInterSDCFlagSCModel;
    280   ContextModel3DBuffer m_cInterSDCResidualSCModel;
    281   ContextModel3DBuffer m_cInterSDCResidualSignFlagSCModel;
    282 #endif
    283 #if QC_SDC_UNIFY_G0130
     270#if H_3D_DIM_SDC
    284271  ContextModel3DBuffer m_cSDCFlagSCModel;
    285272#endif
  • branches/HTM-10.1-dev0/source/Lib/TLibEncoder/TEncSearch.cpp

    r876 r877  
    920920      m_pcEntropyCoder  ->encodePartSize( pcCU, 0, pcCU->getDepth(0), true );
    921921
    922 #if QC_SDC_UNIFY_G0130
     922#if H_3D_DIM_SDC
    923923      m_pcEntropyCoder->encodeSDCFlag( pcCU, 0, true );
    924924#endif
     
    939939      {
    940940        m_pcEntropyCoder->encodeIntraDirModeLuma ( pcCU, 0 );
    941 #if QC_SDC_UNIFY_G0130_FIX
     941#if H_3D_DIM_SDC
    942942        if( pcCU->getSlice()->getIsDepth() && ( !pcCU->getSDCFlag( 0 ) ) && getDimType( pcCU->getLumaIntraDir( 0 ) ) < DIM_NUM_TYPE )
    943943        {
     
    956956        {
    957957          m_pcEntropyCoder->encodeIntraDirModeLuma ( pcCU, uiPart * uiQNumParts );
    958 #if QC_SDC_UNIFY_G0130_FIX
     958#if H_3D_DIM_SDC
    959959          if( pcCU->getSlice()->getIsDepth() && ( !pcCU->getSDCFlag( uiPart * uiQNumParts ) ) && getDimType( pcCU->getLumaIntraDir( uiPart * uiQNumParts ) ) < DIM_NUM_TYPE )
    960960          {
     
    967967      {
    968968        m_pcEntropyCoder->encodeIntraDirModeLuma ( pcCU, uiAbsPartIdx );
    969 #if QC_SDC_UNIFY_G0130_FIX
     969#if H_3D_DIM_SDC
    970970        if( pcCU->getSlice()->getIsDepth() && ( !pcCU->getSDCFlag( uiAbsPartIdx ) ) && getDimType( pcCU->getLumaIntraDir( uiAbsPartIdx ) ) < DIM_NUM_TYPE )
    971971        {
     
    975975    }
    976976  }
    977 #if QC_SDC_UNIFY_G0130 && !QC_SDC_UNIFY_G0130_FIX
    978     Int iPartNum = ( pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_NxN ) ? 4 : 1;
    979     UInt uiPartOffset = ( pcCU->getPic()->getNumPartInCU() >> ( pcCU->getDepth( uiAbsPartIdx ) << 1 ) ) >> 2;
    980 
    981     if( !pcCU->getSDCFlag( uiAbsPartIdx ) )
    982     {
    983       for( Int iPart = 0; iPart < iPartNum; iPart++ )
    984       {
    985         if( getDimType( pcCU->getLumaIntraDir( uiAbsPartIdx + uiPartOffset*iPart ) ) < DIM_NUM_TYPE )
    986         {
    987           m_pcEntropyCoder->encodeDeltaDC( pcCU, uiAbsPartIdx + uiPartOffset*iPart );
    988         }
    989       }
    990     }
    991 #endif
     977
    992978  }
    993979  if( bChroma )
     
    21862172 
    21872173  // encode reduced intra header
    2188 #if QC_SDC_UNIFY_G0130
     2174#if H_3D_DIM_SDC
    21892175  if( !pcCU->getSlice()->isIntra() )
    21902176  {
     
    21972183  }
    21982184
    2199 #if QC_SDC_UNIFY_G0130_FIX2
    22002185  m_pcEntropyCoder->encodePartSize( pcCU, 0, pcCU->getDepth( 0 ), true );
    2201 #else
    2202   m_pcEntropyCoder->encodePartSize( pcCU, 0, true );
    2203 #endif
    22042186  m_pcEntropyCoder->encodeSDCFlag( pcCU, 0, true );
    22052187#else
     
    22092191  // encode pred direction + DC residual data
    22102192  m_pcEntropyCoder->encodePredInfo( pcCU, 0, true );
    2211 #if QC_SDC_UNIFY_G0130
     2193#if H_3D_DIM_SDC
    22122194  Bool bDummy = false;
    22132195  m_pcEntropyCoder->encodeCoeff( pcCU, 0, pcCU->getDepth( 0 ), uiWidth, uiHeight, bDummy );
     
    58755857
    58765858#if H_3D_INTER_SDC
    5877 #if SEC_INTER_SDC_G0101
    58785859Void TEncSearch::encodeResAndCalcRdInterSDCCU( TComDataCU* pcCU, TComYuv* pcOrg, TComYuv* pcPred, TComYuv* pcResi, TComYuv* pcRec, Int uiOffest, const UInt uiDepth )
    5879 #else
    5880 Void TEncSearch::encodeResAndCalcRdInterSDCCU( TComDataCU* pcCU, TComYuv* pcOrg, TComYuv* pcPred, TComYuv* pcResi, TComYuv* pcRec, const UInt uiDepth )
    5881 #endif
    58825860{
    58835861  if( !pcCU->getSlice()->getIsDepth() || pcCU->isIntra( 0 ) )
     
    58855863    return;
    58865864  }
    5887 #if QC_SDC_UNIFY_G0130
    58885865  pcCU->setSDCFlagSubParts( true, 0, uiDepth );
    5889 #else
    5890   pcCU->setInterSDCFlagSubParts( true, 0, 0, uiDepth );
    5891 #endif
    5892 
    5893   UInt  uiWidth      = pcCU->getWidth ( 0 );
    5894   UInt  uiHeight     = pcCU->getHeight( 0 );
    5895 #if SEC_INTER_SDC_G0101
    5896   UInt uiSegSize = 0;
    5897 #else
    5898   UChar* pMask       = pcCU->getInterSDCMask();
    5899   memset( pMask, 0, uiWidth*uiHeight );
    5900 
    5901   pcCU->xSetInterSDCCUMask( pcCU, pMask );
    5902 
    5903   UInt uiSegSize[4] = { 0, 0, 0, 0 };
    5904 #endif
     5866
     5867  UInt  uiWidth   = pcCU->getWidth ( 0 );
     5868  UInt  uiHeight  = pcCU->getHeight( 0 );
     5869  UInt  uiSegSize = 0;
     5870
    59055871  Pel *pPred, *pOrg;
    59065872  UInt uiPredStride = pcPred->getStride();
    59075873  UInt uiOrgStride  = pcOrg->getStride();
    59085874  UInt uiPelX, uiPelY;
    5909 #if !SEC_INTER_SDC_G0101
    5910   UInt uiPartitionSize = pcCU->getPartitionSize( 0 );
    5911   UInt uiSegmentNum = ( uiPartitionSize == SIZE_2Nx2N ) ? 1 : ( uiPartitionSize == SIZE_NxN ? 4 : 2 );
    5912 #endif
    59135875
    59145876  pPred = pcPred->getLumaAddr( 0 );
    59155877  pOrg  = pcOrg->getLumaAddr( 0 );
    5916 #if SEC_INTER_SDC_G0101
    59175878  Int pResDC = 0;
    5918 #else
    5919   Int pResDC[4] = { 0, 0, 0, 0};
    5920 #endif
    59215879
    59225880  //calculate dc value for prediction and original signal, and calculate residual and reconstruction
     
    59255883    for( uiPelX = 0; uiPelX < uiWidth; uiPelX++ )
    59265884    {
    5927 #if SEC_INTER_SDC_G0101
    59285885      pResDC += (Int)( pOrg [uiPelX] - pPred[uiPelX] );
    59295886      uiSegSize++;
    5930 #else
    5931       UChar uiSeg = pMask[ uiPelX + uiPelY*uiWidth ];
    5932       pResDC[uiSeg] += (Int)( pOrg [uiPelX] - pPred[uiPelX] );
    5933       uiSegSize[uiSeg]++;
    5934 #endif
    59355887    }
    59365888    pOrg  += uiOrgStride;
     
    59385890  }
    59395891
    5940 #if SEC_INTER_SDC_G0101
    59415892  Int iResiOffset = ( pResDC  > 0 ? ( uiSegSize >> 1 ) : -1*( uiSegSize >> 1 ) );
    59425893  pResDC          = ( pResDC + iResiOffset ) / (Int) uiSegSize;
    59435894
    59445895  pcCU->setSDCSegmentDCOffset( pResDC + uiOffest, 0, 0 );
    5945 #else
    5946   for( UInt uiSeg = 0; uiSeg < uiSegmentNum; uiSeg++ )
    5947   {
    5948     Int iResiOffset = ( pResDC [uiSeg] > 0 ? ( uiSegSize[uiSeg] >> 1 ) : -1*( uiSegSize[uiSeg] >> 1 ) );
    5949     pResDC [uiSeg]  = ( pResDC [uiSeg] + iResiOffset ) / (Int) uiSegSize[uiSeg];
    5950 #if QC_SDC_UNIFY_G0130
    5951     pcCU->setSDCSegmentDCOffset( pResDC[uiSeg], uiSeg, 0 );
    5952 #else
    5953     pcCU->setInterSDCSegmentDCOffset( pResDC[uiSeg], uiSeg, 0 );
    5954 #endif
    5955   }
    5956 #endif
     5896
    59575897
    59585898  Pel *pRec;
     
    59655905    for( uiPelX = 0; uiPelX < uiWidth; uiPelX++ )
    59665906    {
    5967 #if SEC_INTER_SDC_G0101
    59685907      pRec[ uiPelX ] = Clip3( 0, ( 1 << g_bitDepthY ) - 1, pPred[uiPelX] + pcCU->getSDCSegmentDCOffset(0, 0) );
    5969 #else
    5970       UChar uiSeg = pMask[ uiPelX + uiPelY*uiWidth ];
    5971       assert( uiSeg < uiSegmentNum );
    5972 
    5973       pRec[ uiPelX ] = Clip3( 0, ( 1 << g_bitDepthY ) - 1, pPred[uiPelX] + pResDC[uiSeg] );
    5974 #endif
    59755908    }
    59765909    pPred     += uiPredStride;
     
    60125945#endif
    60135946
    6014 #if QC_SDC_UNIFY_G0130
     5947#if H_3D_DIM_SDC
    60155948  Bool bNonSkip = false;
    60165949#else
    60175950  Bool bNonSkip = true;
    60185951#endif
    6019 #if SEC_INTER_SDC_G0101
    60205952  bNonSkip |= ( pcCU->getSDCSegmentDCOffset( 0, 0 ) != 0 ) ? 1 : 0;
    6021 #else
    6022   for( UInt uiSeg = 0; uiSeg < uiSegmentNum; uiSeg++ )
    6023   {
    6024 #if QC_SDC_UNIFY_G0130
    6025     bNonSkip |= ( pcCU->getSDCSegmentDCOffset( uiSeg, 0 ) != 0 ) ? 1 : 0;
    6026 #else
    6027     bNonSkip &= ( pcCU->getInterSDCSegmentDCOffset( uiSeg, 0 ) != 0 ) ? 1 : 0;
    6028 #endif
    6029   }
    6030 #endif
    6031 
    60325953  if( !bNonSkip )
    60335954  {
     
    71877108    m_pcEntropyCoder->encodePredMode( pcCU, 0, true );
    71887109    m_pcEntropyCoder->encodePartSize( pcCU, 0, pcCU->getDepth(0), true );
    7189 #if QC_SDC_UNIFY_G0130
     7110#if H_3D_DIM_SDC
    71907111    m_pcEntropyCoder->encodeSDCFlag( pcCU, 0, true );
    71917112#endif
     
    71967117#if H_3D_IC
    71977118    m_pcEntropyCoder->encodeICFlag( pcCU, 0, true );
    7198 #endif
    7199 #if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
    7200     m_pcEntropyCoder->encodeInterSDCFlag( pcCU, 0, true );
    72017119#endif
    72027120    Bool bDummy = false;
  • branches/HTM-10.1-dev0/source/Lib/TLibEncoder/TEncSearch.h

    r872 r877  
    218218    TComYuv* pcResi,
    219219    TComYuv* pcRec,
    220 #if SEC_INTER_SDC_G0101
    221220    Int      uiOffset,
    222 #endif
    223221    const UInt uiDepth );
    224222#endif
Note: See TracChangeset for help on using the changeset viewer.