Changeset 531 in 3DVCSoftware


Ignore:
Timestamp:
11 Jul 2013, 16:03:14 (11 years ago)
Author:
tech
Message:

Merged HTM-DEV-0.3-dev1 Rev. 520.

Location:
branches/HTM-DEV-0.3-dev2
Files:
13 added
40 edited

Legend:

Unmodified
Added
Removed
  • branches/HTM-DEV-0.3-dev2/build/linux/lib/TLibCommon/makefile

    r479 r531  
    5555                        $(OBJ_DIR)/TComInterpolationFilter.o \
    5656                        $(OBJ_DIR)/libmd5.o \
     57                        $(OBJ_DIR)/TComWedgelet.o \
    5758                        $(OBJ_DIR)/TComWeightPrediction.o \
    5859                        $(OBJ_DIR)/TComRdCostWeightPrediction.o \
  • branches/HTM-DEV-0.3-dev2/build/vc10/TLibCommon_vc10.vcxproj

    r324 r531  
    166166    <ClCompile Include="..\..\source\Lib\TLibCommon\TComSlice.cpp" />
    167167    <ClCompile Include="..\..\source\Lib\TLibCommon\TComTrQuant.cpp" />
     168    <ClCompile Include="..\..\source\Lib\TLibCommon\TComWedgelet.cpp" />
    168169    <ClCompile Include="..\..\source\Lib\TLibCommon\TComWeightPrediction.cpp" />
    169170    <ClCompile Include="..\..\source\Lib\TLibCommon\TComYuv.cpp" />
     
    199200    <ClInclude Include="..\..\source\Lib\TLibCommon\TComSlice.h" />
    200201    <ClInclude Include="..\..\source\Lib\TLibCommon\TComTrQuant.h" />
     202    <ClInclude Include="..\..\source\Lib\TLibCommon\TComWedgelet.h" />
    201203    <ClInclude Include="..\..\source\Lib\TLibCommon\TComWeightPrediction.h" />
    202204    <ClInclude Include="..\..\source\Lib\TLibCommon\TComYuv.h" />
  • branches/HTM-DEV-0.3-dev2/build/vc8/TLibCommon_vc8.vcproj

    r324 r531  
    369369                        </File>
    370370                        <File
     371                                RelativePath="..\..\source\Lib\TLibCommon\TComWedgelet.cpp"
     372                                >
     373                        </File>
     374                        <File
    371375                                RelativePath="..\..\source\Lib\TLibCommon\TComWeightPrediction.cpp"
    372376                                >
     
    499503                        </File>
    500504                        <File
     505                                RelativePath="..\..\source\Lib\TLibCommon\TComWedgelet.h"
     506                                >
     507                        </File>
     508                        <File
    501509                                RelativePath="..\..\source\Lib\TLibCommon\TComWeightPrediction.h"
    502510                                >
  • branches/HTM-DEV-0.3-dev2/build/vc9/TLibCommon_vc9.vcproj

    r479 r531  
    372372                        </File>
    373373                        <File
     374                                RelativePath="..\..\source\Lib\TLibCommon\TComWedgelet.cpp"
     375                                >
     376                        </File>
     377                        <File
    374378                                RelativePath="..\..\source\Lib\TLibCommon\TComWeightPrediction.cpp"
    375379                                >
     
    502506                        </File>
    503507                        <File
     508                                RelativePath="..\..\source\Lib\TLibCommon\TComWedgelet.h"
     509                                >
     510                        </File>
     511                        <File
    504512                                RelativePath="..\..\source\Lib\TLibCommon\TComWeightPrediction.h"
    505513                                >
  • branches/HTM-DEV-0.3-dev2/cfg/3D-HEVC/baseCfg_2view+depth.cfg

    r516 r531  
    99InputFile_2                   : newspapercc_2.yuv                             
    1010InputFile_3                   : newspapercc_2_depth.yuv                             
    11 InputFile_4                   : newspapercc_6.yuv                               
    12 InputFile_5                   : newspapercc_6_depth.yuv                             
    1311
    1412BitstreamFile                 : stream.bit                         
     
    1816ReconFile_2                   : rec_2.yuv                           
    1917ReconFile_3                   : rec_2_depth.yuv                         
    20 ReconFile_4                   : rec_6.yuv                         
    21 ReconFile_5                   : rec_6_depth.yuv                           
    2218
    2319NumberOfLayers                : 4
     
    8884Frame7_l3:  B    5     7        0.68     0            0              0           3                4         -1 -5  1 3         1       1        5         1 0 1 1 1       1             -2                 2                  -1 
    8985Frame8_l3:  B    7     7        0.68     0            0              0           3                4         -1 -3 -7 1         1      -2        5         1 1 1 1 0       1             -2                 2                  -1 
    90 
    91 FrameI_l4:  P    0     3        0.442    0            0              0           1                0                            0                                          1             -4                 0                  -1 
    92 Frame1_l4:  B    8     4        0.442    0            0              0           4                4         -8 -10 -12 -16     0                                          1             -4                 1                  -1 
    93 Frame2_l4:  B    4     5        0.3536   0            0              0           3                3         -4 -6  4           1       4        5         1 1 0 0 1       1             -4                 1                  -1 
    94 Frame3_l4:  B    2     6        0.3536   0            0              0           3                4         -2 -4  2 6         1       2        4         1 1 1 1         1             -4                 1                  -1 
    95 Frame4_l4:  B    1     7        0.68     0            0              0           3                4         -1  1  3 7         1       1        5         1 0 1 1 1       1             -4                 1                  -1 
    96 Frame5_l4:  B    3     7        0.68     0            0              0           3                4         -1 -3  1 5         1      -2        5         1 1 1 1 0       1             -4                 2                  -1 
    97 Frame6_l4:  B    6     6        0.3536   0            0              0           3                4         -2 -4 -6 2         1      -3        5         1 1 1 1 0       1             -4                 2                  -1 
    98 Frame7_l4:  B    5     7        0.68     0            0              0           3                4         -1 -5  1 3         1       1        5         1 0 1 1 1       1             -4                 2                  -1 
    99 Frame8_l4:  B    7     7        0.68     0            0              0           3                4         -1 -3 -7 1         1      -2        5         1 1 1 1 0       1             -4                 2                  -1 
    100 
    101 FrameI_l5:  P    0     3        0.442    0            0              0           1                0                            0                                          1             -4                 0                  -1 
    102 Frame1_l5:  B    8     4        0.442    0            0              0           4                4         -8 -10 -12 -16     0                                          1             -4                 1                  -1 
    103 Frame2_l5:  B    4     5        0.3536   0            0              0           3                3         -4 -6  4           1       4        5         1 1 0 0 1       1             -4                 1                  -1 
    104 Frame3_l5:  B    2     6        0.3536   0            0              0           3                4         -2 -4  2 6         1       2        4         1 1 1 1         1             -4                 1                  -1 
    105 Frame4_l5:  B    1     7        0.68     0            0              0           3                4         -1  1  3 7         1       1        5         1 0 1 1 1       1             -4                 1                  -1 
    106 Frame5_l5:  B    3     7        0.68     0            0              0           3                4         -1 -3  1 5         1      -2        5         1 1 1 1 0       1             -4                 2                  -1 
    107 Frame6_l5:  B    6     6        0.3536   0            0              0           3                4         -2 -4 -6 2         1      -3        5         1 1 1 1 0       1             -4                 2                  -1 
    108 Frame7_l5:  B    5     7        0.68     0            0              0           3                4         -1 -5  1 3         1       1        5         1 0 1 1 1       1             -4                 2                  -1 
    109 Frame8_l5:  B    7     7        0.68     0            0              0           3                4         -1 -3 -7 1         1      -2        5         1 1 1 1 0       1             -4                 2                  -1 
    11086
    11187#=========== Motion Search =============
     
    203179#========== depth coding tools ==========
    204180VSO                       : 1                                      # use of view synthesis optimization for depth coding
     181DMM                                : 1
     182RBC                                : 1
     183SDC                                : 1
     184DLT                                : 1
    205185
    206186#========== view synthesis optimization (VSO) ==========
  • branches/HTM-DEV-0.3-dev2/cfg/3D-HEVC/baseCfg_3view+depth.cfg

    r516 r531  
    203203#========== depth coding tools ==========
    204204VSO                       : 1                                      # use of view synthesis optimization for depth coding
     205DMM                                : 1
     206RBC                                : 1
     207SDC                                : 1
     208DLT                                : 1
    205209
    206210#========== view synthesis optimization (VSO) ==========
  • branches/HTM-DEV-0.3-dev2/cfg/3D-HEVC/fullCfg.cfg

    r486 r531  
    206206#========== depth coding tools ==========
    207207VSO                       : 1                                      # use of view synthesis optimization for depth coding
     208DMM                                : 1
     209RBC                                : 1
     210SDC                                : 1
     211DLT                                : 1
    208212
    209213#========== view synthesis optimization (VSO) ==========
  • branches/HTM-DEV-0.3-dev2/source/App/TAppDecoder/TAppDecTop.cpp

    r521 r531  
    386386  // initialize global variables
    387387  initROM(); 
     388#if H_3D_DIM_DMM
     389  initWedgeLists();
     390#endif
    388391#else
    389392  // create decoder class
  • branches/HTM-DEV-0.3-dev2/source/App/TAppEncoder/TAppEncCfg.cpp

    r504 r531  
    389389#if H_3D
    390390  ("DepthFlag",             m_depthFlag          , std::vector<Int>(1,0), "Depth Flag")
     391#if H_3D_DIM
     392  ("DMM",                   m_useDMM,           true,  "Depth intra model modes")
     393  ("RBC",                   m_useRBC,           true,  "Region boundary chain mode")
     394  ("SDC",                   m_useSDC,           true,  "Simplified depth coding")
     395  ("DLT",                   m_useDLT,           true,  "Depth lookup table")
     396#endif
    391397#endif
    392398  ("LayerIdInNuh",          m_layerIdInNuh       , std::vector<Int>(1,0), "LayerId in Nuh")
     
    23162322  printf("ViewSynthesisPred:%d ", m_viewSynthesisPredFlag );
    23172323#endif
     2324#if H_3D_DIM
     2325  printf("DMM:%d ", m_useDMM );
     2326  printf("RBC:%d ", m_useRBC );
     2327  printf("SDC:%d ", m_useSDC );
     2328  printf("DLT:%d ", m_useDLT );
     2329#endif
    23182330  printf("\n\n"); 
    23192331
  • branches/HTM-DEV-0.3-dev2/source/App/TAppEncoder/TAppEncCfg.h

    r504 r531  
    421421  TRenModSetupStrParser       m_cRenModStrParser;
    422422#endif
     423#if H_3D_DIM
     424  Bool      m_useDMM;                                        ///< flag for using DMM
     425  Bool      m_useRBC;                                        ///< flag for using RBC
     426  Bool      m_useSDC;                                        ///< flag for using SDC
     427  Bool      m_useDLT;                                        ///< flag for using DLT
     428#endif
    423429#endif
    424430  // internal member functions
  • branches/HTM-DEV-0.3-dev2/source/App/TAppEncoder/TAppEncTop.cpp

    r504 r531  
    120120  xSetDirectDependencyFlags( vps );
    121121#if H_3D
     122#if H_3D_DIM
     123  for( Int layer = 0; layer < m_numberOfLayers; layer++ )
     124  {
     125    vps.setVpsDepthModesFlag( layer, ((vps.getDepthId( layer ) != 0) && (m_useDMM || m_useRBC || m_useSDC || m_useDLT)) ? true : false );
     126#if H_3D_DIM_DLT
     127    vps.setUseDLTFlag( layer , ((vps.getDepthId( layer ) != 0) && m_useDLT) ? true : false );
     128    if( vps.getUseDLTFlag( layer ) )
     129    {
     130      xAnalyzeInputBaseDepth(layer, max(m_iIntraPeriod, 24), &vps);
     131    }
     132#endif
     133  }
     134#endif
    122135  vps.initViewIndex();
    123136#if H_3D_GEN
     
    184197#if H_3D_IC
    185198    m_cTEncTop.setUseIC                        ( vps.getViewIndex( layer ) == 0 ? false : m_abUseIC[isDepth ? 1 : 0] );
     199#endif
     200  //========== Depth intra modes ==========
     201#if H_3D_DIM
     202    m_cTEncTop.setUseDMM                       ( isDepth ? m_useDMM               : false );
     203    m_cTEncTop.setUseRBC                       ( isDepth ? m_useRBC               : false );
     204    m_cTEncTop.setUseSDC                       ( isDepth ? m_useSDC               : false );
     205    m_cTEncTop.setUseDLT                       ( isDepth ? m_useDLT               : false );
    186206#endif
    187207#endif // H_3D
     
    562582  // initialize global variables
    563583  initROM();
     584#if H_3D_DIM_DMM
     585  initWedgeLists( true );
     586#endif
    564587
    565588  for( Int layer=0; layer < m_numberOfLayers; layer++)
     
    9891012}
    9901013
     1014#if H_3D_DIM_DLT
     1015Void TAppEncTop::xAnalyzeInputBaseDepth(UInt layer, UInt uiNumFrames, TComVPS* vps)
     1016{
     1017  TComPicYuv*       pcDepthPicYuvOrg = new TComPicYuv;
     1018  // allocate original YUV buffer
     1019  pcDepthPicYuvOrg->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
     1020 
     1021  TVideoIOYuv* depthVideoFile = new TVideoIOYuv;
     1022 
     1023  UInt uiMaxDepthValue = ((1 << g_bitDepthY)-1);
     1024 
     1025  Bool abValidDepths[256];
     1026 
     1027  depthVideoFile->open( m_pchInputFileList[layer], false, m_inputBitDepthY, m_inputBitDepthC, m_internalBitDepthY, m_internalBitDepthC );  // read  mode
     1028 
     1029  // initialize boolean array
     1030  for(Int p=0; p<=uiMaxDepthValue; p++)
     1031    abValidDepths[p] = false;
     1032 
     1033  Int iHeight   = pcDepthPicYuvOrg->getHeight();
     1034  Int iWidth    = pcDepthPicYuvOrg->getWidth();
     1035  Int iStride   = pcDepthPicYuvOrg->getStride();
     1036 
     1037  Pel* pInDM    = pcDepthPicYuvOrg->getLumaAddr();
     1038 
     1039  for(Int uiFrame=0; uiFrame < uiNumFrames; uiFrame++ )
     1040  {
     1041    depthVideoFile->read( pcDepthPicYuvOrg, m_aiPad );
     1042   
     1043    // check all pixel values
     1044    for (Int i=0; i<iHeight; i++)
     1045    {
     1046      Int rowOffset = i*iStride;
     1047     
     1048      for (Int j=0; j<iWidth; j++)
     1049      {
     1050        Pel depthValue = pInDM[rowOffset+j];
     1051        abValidDepths[depthValue] = true;
     1052      }
     1053    }
     1054  }
     1055 
     1056  depthVideoFile->close();
     1057 
     1058  pcDepthPicYuvOrg->destroy();
     1059  delete pcDepthPicYuvOrg;
     1060 
     1061  // convert boolean array to idx2Depth LUT
     1062  Int* aiIdx2DepthValue = (Int*) calloc(uiMaxDepthValue, sizeof(Int));
     1063  Int iNumDepthValues = 0;
     1064  for(Int p=0; p<=uiMaxDepthValue; p++)
     1065  {
     1066    if( abValidDepths[p] == true)
     1067    {
     1068      aiIdx2DepthValue[iNumDepthValues++] = p;
     1069    }
     1070  }
     1071 
     1072  if( uiNumFrames == 0 || numBitsForValue(iNumDepthValues) == g_bitDepthY )
     1073  {
     1074    // don't use DLT
     1075    vps->setUseDLTFlag(layer, false);
     1076  }
     1077 
     1078  // assign LUT
     1079  if( vps->getUseDLTFlag(layer) )
     1080    vps->setDepthLUTs(layer, aiIdx2DepthValue, iNumDepthValues);
     1081 
     1082  // free temporary memory
     1083  free(aiIdx2DepthValue);
     1084}
     1085#endif
     1086
    9911087#if H_MV
    9921088Void TAppEncTop::xSetDimensionIdAndLength( TComVPS& vps )
  • branches/HTM-DEV-0.3-dev2/source/App/TAppEncoder/TAppEncTop.h

    r479 r531  
    124124  Void xSetVPSExtension2( TComVPS& vps );
    125125#endif
     126#if H_3D_DIM_DLT
     127  Void  xAnalyzeInputBaseDepth(UInt layer, UInt uiNumFrames, TComVPS* vps);
     128#endif
    126129public:
    127130  TAppEncTop();
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/ContextTables.h

    r504 r531  
    106106#define CNU                          154      ///< dummy initialization value for unused context models 'Context model Not Used'
    107107
     108#if H_3D_DIM
     109#define NUM_DEPTH_INTRA_MODE_CTX      8       ///< number of context models for depth intra modes
     110#define NUM_DDC_FLAG_CTX              2       ///< number of context models for deltaDC flag (DMM or RBC)
     111#define NUM_DDC_DATA_CTX              2       ///< number of context models for deltaDC data (DMM or RBC)
     112#if H_3D_DIM_DMM
     113#define NUM_DMM1_DATA_CTX             1       ///< number of context models for DMM1 data
     114#define NUM_DMM2_DATA_CTX             1       ///< number of context models for DMM2 data
     115#define NUM_DMM3_DATA_CTX             1       ///< number of context models for DMM3 data
     116#endif
     117#if H_3D_DIM_RBC
     118#define NUM_RBC_DATA_CTX              1       ///< number of context models for RBC data
     119#endif
     120#endif
     121
     122#if H_3D_DIM_SDC
     123#define SDC_NUM_RESIDUAL_FLAG_CTX        1
     124#define SDC_NUM_RESIDUAL_CTX             1
     125#endif
    108126// ====================================================================================================================
    109127// Tables
     
    363381};
    364382#endif
     383#if H_3D_DIM
     384static const UChar
     385INIT_DEPTH_INTRA_MODE[3][NUM_DEPTH_INTRA_MODE_CTX] =
     386{
     387  {0,  0,  64,   0, CNU,   0, CNU, 0},
     388  {0, 64,   0, CNU,   0, CNU,   0, 0},
     389  {64, 0, CNU,   0, CNU,   0,   0, 0}
     390};
     391static const UChar
     392INIT_DDC_FLAG[3][NUM_DDC_FLAG_CTX] =
     393{
     394  {0 , CNU},
     395  {0 , CNU},
     396  {64, CNU}
     397};
     398static const UChar
     399INIT_DDC_DATA[3][NUM_DDC_DATA_CTX] =
     400{
     401  { CNU, CNU },
     402  { CNU, CNU },
     403  { CNU, CNU },
     404};
     405#if H_3D_DIM_DMM
     406static const UChar
     407INIT_DMM1_DATA[3][NUM_DMM1_DATA_CTX] =
     408{
     409  { CNU },
     410  { CNU },
     411  { CNU },
     412};
     413static const UChar
     414INIT_DMM2_DATA[3][NUM_DMM2_DATA_CTX] =
     415{
     416  { CNU },
     417  { CNU },
     418  { CNU },
     419};
     420static const UChar
     421INIT_DMM3_DATA[3][NUM_DMM3_DATA_CTX] =
     422{
     423  { CNU },
     424  { CNU },
     425  { CNU },
     426};
     427#endif
     428#if H_3D_DIM_RBC
     429static const UChar
     430INIT_RBC_DATA[3][NUM_RBC_DATA_CTX] =
     431{
     432  { CNU },
     433  { CNU },
     434  { CNU },
     435};
     436#endif
     437#if H_3D_DIM_SDC
     438static const UChar
     439INIT_SDC_RESIDUAL_FLAG[3][SDC_NUM_RESIDUAL_FLAG_CTX] =
     440{
     441  { CNU },
     442  { CNU },
     443  { CNU },
     444};
     445static const UChar
     446INIT_SDC_RESIDUAL[3][SDC_NUM_RESIDUAL_CTX] =
     447{
     448  { 155 },
     449  { 155 },
     450  { 155 },
     451};
     452#endif
     453#endif
    365454
    366455//! \}
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComDataCU.cpp

    r530 r531  
    109109  m_apiMVPNum[1]       = NULL;
    110110
     111#if H_3D_DIM
     112  for( Int i = 0; i < DIM_NUM_TYPE; i++ )
     113  {
     114    m_dimDeltaDC[i][0] = NULL;
     115    m_dimDeltaDC[i][1] = NULL;
     116  }
     117#if H_3D_DIM_DMM
     118  for( Int i = 0; i < DMM_NUM_TYPE; i++ )
     119  {
     120    m_dmmWedgeTabIdx[i] = NULL;
     121  }
     122  m_dmm2DeltaEnd    = NULL;
     123  m_dmm3IntraTabIdx = NULL;
     124#endif
     125#if H_3D_DIM_RBC
     126  m_pucEdgeCode     = NULL;
     127  m_pucEdgeNumber   = NULL;
     128  m_pucEdgeStartPos = NULL;
     129  m_pbEdgeLeftFirst = NULL;
     130  m_pbEdgePartition = NULL;
     131#endif
     132#if H_3D_DIM_SDC
     133  m_pbSDCFlag             = NULL;
     134  m_apSegmentDCOffset[0]  = NULL;
     135  m_apSegmentDCOffset[1]  = NULL;
     136#endif
     137#endif
     138
    111139  m_bDecSubCu          = false;
    112140  m_sliceStartCU        = 0;
     
    229257    m_pbICFlag           = (Bool* )xMalloc(Bool,   uiNumPartition);
    230258#endif
     259#if H_3D_DIM
     260    for( Int i = 0; i < DIM_NUM_TYPE; i++ )
     261    {
     262      m_dimDeltaDC[i][0] = (Pel* )xMalloc(Pel, uiNumPartition);
     263      m_dimDeltaDC[i][1] = (Pel* )xMalloc(Pel, uiNumPartition);
     264    }
     265#if H_3D_DIM_DMM
     266    for( Int i = 0; i < DMM_NUM_TYPE; i++ )
     267    {
     268      m_dmmWedgeTabIdx[i]    = (UInt*)xMalloc(UInt, uiNumPartition);
     269    }
     270    m_dmm2DeltaEnd    = (Int* )xMalloc(Int,  uiNumPartition);
     271    m_dmm3IntraTabIdx = (UInt*)xMalloc(UInt, uiNumPartition);
     272#endif
     273#if H_3D_DIM_RBC
     274    m_pucEdgeCode     = (UChar*)xMalloc(UChar, uiNumPartition * RBC_MAX_EDGE_NUM_PER_4x4);
     275    m_pucEdgeNumber   = (UChar*)xMalloc(UChar, uiNumPartition);
     276    m_pucEdgeStartPos = (UChar*)xMalloc(UChar, uiNumPartition);
     277    m_pbEdgeLeftFirst = (Bool*)xMalloc(Bool, uiNumPartition);
     278    m_pbEdgePartition = (Bool*)xMalloc(Bool, uiNumPartition * 16);
     279#endif
     280#if H_3D_DIM_SDC
     281    m_pbSDCFlag             = (Bool*)xMalloc(Bool, uiNumPartition);
     282    m_apSegmentDCOffset[0]  = (Pel*)xMalloc(Pel, uiNumPartition);
     283    m_apSegmentDCOffset[1]  = (Pel*)xMalloc(Pel, uiNumPartition);
     284#endif
     285#endif
    231286  }
    232287  else
     
    326381    m_acCUMvField[0].destroy();
    327382    m_acCUMvField[1].destroy();
    328    
     383
     384#if H_3D_DIM
     385    for( Int i = 0; i < DIM_NUM_TYPE; i++ )
     386    {
     387      if ( m_dimDeltaDC[i][0] ) { xFree( m_dimDeltaDC[i][0] ); m_dimDeltaDC[i][0] = NULL; }
     388      if ( m_dimDeltaDC[i][1] ) { xFree( m_dimDeltaDC[i][1] ); m_dimDeltaDC[i][1] = NULL; }
     389    }
     390#if H_3D_DIM_DMM
     391    for( Int i = 0; i < DMM_NUM_TYPE; i++ )
     392    {
     393      if ( m_dmmWedgeTabIdx[i] ) { xFree( m_dmmWedgeTabIdx[i] ); m_dmmWedgeTabIdx[i] = NULL; }
     394    }
     395    if ( m_dmm2DeltaEnd    ) { xFree( m_dmm2DeltaEnd    ); m_dmm2DeltaEnd    = NULL; }
     396    if ( m_dmm3IntraTabIdx ) { xFree( m_dmm3IntraTabIdx ); m_dmm3IntraTabIdx = NULL; }
     397#endif
     398#if H_3D_DIM_RBC
     399    if ( m_pbEdgeLeftFirst ) { xFree( m_pbEdgeLeftFirst ); m_pbEdgeLeftFirst = NULL; }
     400    if ( m_pucEdgeStartPos ) { xFree( m_pucEdgeStartPos ); m_pucEdgeStartPos = NULL; }
     401    if ( m_pucEdgeNumber   ) { xFree( m_pucEdgeNumber   ); m_pucEdgeNumber   = NULL; }
     402    if ( m_pucEdgeCode     ) { xFree( m_pucEdgeCode     ); m_pucEdgeCode     = NULL; }
     403    if ( m_pbEdgePartition ) { xFree( m_pbEdgePartition ); m_pbEdgePartition = NULL; }
     404#endif
     405#if H_3D_DIM_SDC
     406    if ( m_pbSDCFlag            ) { xFree(m_pbSDCFlag);             m_pbSDCFlag             = NULL; }
     407    if ( m_apSegmentDCOffset[0] ) { xFree(m_apSegmentDCOffset[0]);  m_apSegmentDCOffset[0]  = NULL; }
     408    if ( m_apSegmentDCOffset[1] ) { xFree(m_apSegmentDCOffset[1]);  m_apSegmentDCOffset[1]  = NULL; }
     409#endif
     410#endif   
    329411  }
    330412 
     
    462544    m_puhCbf[2][ui]=pcFrom->m_puhCbf[2][ui];
    463545    m_pbIPCMFlag[ui] = pcFrom->m_pbIPCMFlag[ui];
     546#if H_3D_DIM_SDC
     547    m_pbSDCFlag[ui] = pcFrom->m_pbSDCFlag[ui];
     548#endif
    464549  }
    465550 
     
    503588#if H_3D_IC
    504589    memset( m_pbICFlag          + firstElement, false,                    numElements * sizeof( *m_pbICFlag )   );
     590#endif
     591#if H_3D_DIM
     592    for( Int i = 0; i < DIM_NUM_TYPE; i++ )
     593    {
     594      memset( m_dimDeltaDC[i][0] + firstElement, 0,                       numElements * sizeof( *m_dimDeltaDC[i][0] ) );
     595      memset( m_dimDeltaDC[i][1] + firstElement, 0,                       numElements * sizeof( *m_dimDeltaDC[i][1] ) );
     596    }
     597#if H_3D_DIM_DMM
     598    for( Int i = 0; i < DMM_NUM_TYPE; i++ )
     599    {
     600      memset( m_dmmWedgeTabIdx[i] + firstElement, 0,                      numElements * sizeof( *m_dmmWedgeTabIdx[i] ) );
     601    }
     602    memset( m_dmm2DeltaEnd      + firstElement, 0,                        numElements * sizeof( *m_dmm2DeltaEnd    ) );
     603    memset( m_dmm3IntraTabIdx   + firstElement, 0,                        numElements * sizeof( *m_dmm3IntraTabIdx ) );
     604#endif
     605#if H_3D_DIM_RBC
     606    memset( m_pucEdgeCode       + firstElement, 0,                        numElements * sizeof( *m_pucEdgeCode     ) * RBC_MAX_EDGE_NUM_PER_4x4 );
     607    memset( m_pucEdgeNumber     + firstElement, 0,                        numElements * sizeof( *m_pucEdgeNumber   ) );
     608    memset( m_pucEdgeStartPos   + firstElement, 0,                        numElements * sizeof( *m_pucEdgeStartPos ) );
     609    memset( m_pbEdgeLeftFirst   + firstElement, false,                    numElements * sizeof( *m_pbEdgeLeftFirst ) );
     610    memset( m_pbEdgePartition   + firstElement, false,                    numElements * sizeof( *m_pbEdgePartition ) * 16 );
     611#endif
     612#if H_3D_DIM_SDC
     613    memset( m_pbSDCFlag             + firstElement,     0,                numElements * sizeof( *m_pbSDCFlag            ) );
     614    memset( m_apSegmentDCOffset[0]  + firstElement,     0,                numElements * sizeof( *m_apSegmentDCOffset[0] ) );
     615    memset( m_apSegmentDCOffset[1]  + firstElement,     0,                numElements * sizeof( *m_apSegmentDCOffset[1] ) );
     616#endif
    505617#endif
    506618  }
     
    648760      m_pbICFlag[ui]  = false;
    649761#endif
     762#if H_3D_DIM
     763      for( Int i = 0; i < DIM_NUM_TYPE; i++ )
     764      {
     765        m_dimDeltaDC[i][0] [ui] = 0;
     766        m_dimDeltaDC[i][1] [ui] = 0;
     767      }
     768#if H_3D_DIM_DMM
     769      for( Int i = 0; i < DMM_NUM_TYPE; i++ )
     770      {
     771        m_dmmWedgeTabIdx[i] [ui] = 0;
     772      }
     773      m_dmm2DeltaEnd    [ui] = 0;
     774      m_dmm3IntraTabIdx [ui] = 0;
     775#endif
     776#if H_3D_DIM_SDC
     777      m_pbSDCFlag           [ui] = false;
     778      m_apSegmentDCOffset[0][ui] = 0;
     779      m_apSegmentDCOffset[1][ui] = 0;
     780#endif
     781#endif
    650782    }
    651783  }
     
    735867  memset( m_pbICFlag,          0, iSizeInBool  );
    736868#endif
     869#if H_3D_DIM
     870  for( Int i = 0; i < DIM_NUM_TYPE; i++ )
     871  {
     872    memset( m_dimDeltaDC[i][0], 0, sizeof(Pel ) * m_uiNumPartition );
     873    memset( m_dimDeltaDC[i][1], 0, sizeof(Pel ) * m_uiNumPartition );
     874  }
     875#if H_3D_DIM_DMM
     876  for( Int i = 0; i < DMM_NUM_TYPE; i++ )
     877  {
     878    memset( m_dmmWedgeTabIdx[i], 0, sizeof(UInt) * m_uiNumPartition );
     879  }
     880  memset( m_dmm2DeltaEnd   , 0, sizeof(Int ) * m_uiNumPartition );
     881  memset( m_dmm3IntraTabIdx, 0, sizeof(UInt) * m_uiNumPartition );
     882#endif
     883#if H_3D_DIM_RBC
     884  memset( m_pucEdgeCode    , 0, iSizeInUchar * RBC_MAX_EDGE_NUM_PER_4x4 );
     885  memset( m_pucEdgeNumber  , 0, iSizeInUchar );
     886  memset( m_pucEdgeStartPos, 0, iSizeInUchar );
     887  memset( m_pbEdgeLeftFirst, 0, iSizeInBool );
     888  memset( m_pbEdgePartition, 0, iSizeInBool * 16 );
     889#endif
     890#if H_3D_DIM_SDC
     891  memset( m_pbSDCFlag,            0, sizeof(Bool) * m_uiNumPartition  );
     892  memset( m_apSegmentDCOffset[0], 0, sizeof(Pel) * m_uiNumPartition   );
     893  memset( m_apSegmentDCOffset[1], 0, sizeof(Pel) * m_uiNumPartition   );
     894#endif
     895#endif
     896
    737897  for (UInt ui = 0; ui < m_uiNumPartition; ui++)
    738898  {
     
    782942      m_pbICFlag          [ui] = pcCU->m_pbICFlag[uiPartOffset+ui];
    783943#endif
     944#if H_3D_DIM
     945      for( Int i = 0; i < DIM_NUM_TYPE; i++ )
     946      {
     947        m_dimDeltaDC[i][0] [ui] = pcCU->m_dimDeltaDC[i][0] [uiPartOffset+ui];
     948        m_dimDeltaDC[i][1] [ui] = pcCU->m_dimDeltaDC[i][1] [uiPartOffset+ui];
     949      }
     950#if H_3D_DIM_DMM
     951      for( Int i = 0; i < DMM_NUM_TYPE; i++ )
     952      {
     953        m_dmmWedgeTabIdx[i] [ui] = pcCU->m_dmmWedgeTabIdx[i] [uiPartOffset+ui];
     954      }
     955      m_dmm2DeltaEnd    [ui] = pcCU->m_dmm2DeltaEnd   [uiPartOffset+ui];
     956      m_dmm3IntraTabIdx [ui] = pcCU->m_dmm3IntraTabIdx[uiPartOffset+ui];
     957#endif
     958#if H_3D_DIM_SDC
     959      m_pbSDCFlag           [ui] = pcCU->m_pbSDCFlag            [ uiPartOffset + ui ];
     960      m_apSegmentDCOffset[0][ui] = pcCU->m_apSegmentDCOffset[0] [ uiPartOffset + ui ];
     961      m_apSegmentDCOffset[1][ui] = pcCU->m_apSegmentDCOffset[1] [ uiPartOffset + ui ];
     962#endif
     963#endif
    784964    }
    785965  }
     
    9131093  m_puhCbf[1]= pcCU->getCbf(TEXT_CHROMA_U)        + uiPart;
    9141094  m_puhCbf[2]= pcCU->getCbf(TEXT_CHROMA_V)        + uiPart;
    915  
     1095#if H_3D_DIM
     1096  for( Int i = 0; i < DIM_NUM_TYPE; i++ )
     1097  {
     1098    m_dimDeltaDC[i][0] = pcCU->getDimDeltaDC( i, 0 ) + uiPart;
     1099    m_dimDeltaDC[i][1] = pcCU->getDimDeltaDC( i, 1 ) + uiPart;
     1100  }
     1101#if H_3D_DIM_DMM
     1102  for( Int i = 0; i < DMM_NUM_TYPE; i++ )
     1103  {
     1104    m_dmmWedgeTabIdx[i] = pcCU->getDmmWedgeTabIdx( i ) + uiPart;
     1105  }
     1106  m_dmm2DeltaEnd    = pcCU->getDmm2DeltaEnd()    + uiPart;
     1107  m_dmm3IntraTabIdx = pcCU->getDmm3IntraTabIdx() + uiPart;
     1108#endif
     1109#if H_3D_DIM_RBC
     1110  m_pucEdgeCode     = pcCU->getEdgeCode( uiPart );
     1111  m_pucEdgeNumber   = pcCU->getEdgeNumber()      + uiPart;
     1112  m_pucEdgeStartPos = pcCU->getEdgeStartPos()    + uiPart;
     1113  m_pbEdgeLeftFirst = pcCU->getEdgeLeftFirst()   + uiPart;
     1114  m_pbEdgePartition = pcCU->getEdgePartition( uiPart );
     1115#endif
     1116#if H_3D_DIM_SDC
     1117  m_pbSDCFlag               = pcCU->getSDCFlag()              + uiPart;
     1118  m_apSegmentDCOffset[0]    = pcCU->getSDCSegmentDCOffset(0)  + uiPart;
     1119  m_apSegmentDCOffset[1]    = pcCU->getSDCSegmentDCOffset(1)  + uiPart;
     1120#endif
     1121#endif 
    9161122  m_puhDepth=pcCU->getDepth()                     + uiPart;
    9171123  m_puhWidth=pcCU->getWidth()                     + uiPart;
     
    10761282  memcpy( m_puhCbf[2] + uiOffset, pcCU->getCbf(TEXT_CHROMA_V), iSizeInUchar );
    10771283 
     1284#if H_3D_DIM
     1285  for( Int i = 0; i < DIM_NUM_TYPE; i++ )
     1286  {
     1287    memcpy( m_dimDeltaDC[i][0] + uiOffset, pcCU->getDimDeltaDC( i, 0 ), sizeof(Pel ) * uiNumPartition );
     1288    memcpy( m_dimDeltaDC[i][1] + uiOffset, pcCU->getDimDeltaDC( i, 1 ), sizeof(Pel ) * uiNumPartition );
     1289  }
     1290#if H_3D_DIM_DMM
     1291  for( Int i = 0; i < DMM_NUM_TYPE; i++ )
     1292  {
     1293    memcpy( m_dmmWedgeTabIdx[i] + uiOffset, pcCU->getDmmWedgeTabIdx( i ), sizeof(UInt) * uiNumPartition );
     1294  }
     1295  memcpy( m_dmm2DeltaEnd    + uiOffset, pcCU->getDmm2DeltaEnd()   , sizeof(Int ) * uiNumPartition );
     1296  memcpy( m_dmm3IntraTabIdx + uiOffset, pcCU->getDmm3IntraTabIdx(), sizeof(UInt) * uiNumPartition );
     1297#endif
     1298#if H_3D_DIM_RBC
     1299  memcpy( getEdgeCode( uiOffset ),       pcCU->getEdgeCode(0),      iSizeInUchar * RBC_MAX_EDGE_NUM_PER_4x4 );
     1300  memcpy( getEdgeNumber()    + uiOffset, pcCU->getEdgeNumber(),     iSizeInUchar );
     1301  memcpy( getEdgeStartPos()  + uiOffset, pcCU->getEdgeStartPos(),   iSizeInUchar );
     1302  memcpy( getEdgeLeftFirst() + uiOffset, pcCU->getEdgeLeftFirst(),  iSizeInBool );
     1303  memcpy( getEdgePartition( uiOffset ),  pcCU->getEdgePartition(0), iSizeInBool * 16 );
     1304#endif
     1305#if H_3D_DIM_SDC
     1306  memcpy( m_pbSDCFlag             + uiOffset, pcCU->getSDCFlag(),             iSizeInBool  );
     1307  memcpy( m_apSegmentDCOffset[0]  + uiOffset, pcCU->getSDCSegmentDCOffset(0), sizeof( Pel ) * uiNumPartition);
     1308  memcpy( m_apSegmentDCOffset[1]  + uiOffset, pcCU->getSDCSegmentDCOffset(1), sizeof( Pel ) * uiNumPartition);
     1309#endif
     1310#endif
     1311
    10781312  memcpy( m_puhDepth  + uiOffset, pcCU->getDepth(),  iSizeInUchar );
    10791313  memcpy( m_puhWidth  + uiOffset, pcCU->getWidth(),  iSizeInUchar );
     
    11691403  memcpy( rpcCU->getCbf(TEXT_CHROMA_V) + m_uiAbsIdxInLCU, m_puhCbf[2], iSizeInUchar );
    11701404 
     1405#if H_3D_DIM
     1406  for( Int i = 0; i < DIM_NUM_TYPE; i++ )
     1407  {
     1408    memcpy( rpcCU->getDimDeltaDC( i, 0 ) + m_uiAbsIdxInLCU, m_dimDeltaDC[i][0], sizeof(Pel ) * m_uiNumPartition );
     1409    memcpy( rpcCU->getDimDeltaDC( i, 1 ) + m_uiAbsIdxInLCU, m_dimDeltaDC[i][1], sizeof(Pel ) * m_uiNumPartition );
     1410  }
     1411#if H_3D_DIM_DMM
     1412  for( Int i = 0; i < DMM_NUM_TYPE; i++ )
     1413  {
     1414    memcpy( rpcCU->getDmmWedgeTabIdx( i ) + m_uiAbsIdxInLCU, m_dmmWedgeTabIdx[i], sizeof(UInt) * m_uiNumPartition );
     1415  }
     1416  memcpy( rpcCU->getDmm2DeltaEnd()    + m_uiAbsIdxInLCU, m_dmm2DeltaEnd   , sizeof(Int ) * m_uiNumPartition );
     1417  memcpy( rpcCU->getDmm3IntraTabIdx() + m_uiAbsIdxInLCU, m_dmm3IntraTabIdx, sizeof(UInt) * m_uiNumPartition );
     1418#endif
     1419#if H_3D_DIM_RBC
     1420  memcpy( rpcCU->getEdgeCode( m_uiAbsIdxInLCU ),         m_pucEdgeCode,     iSizeInUchar * RBC_MAX_EDGE_NUM_PER_4x4 );
     1421  memcpy( rpcCU->getEdgeNumber()      + m_uiAbsIdxInLCU, m_pucEdgeNumber,   iSizeInUchar );
     1422  memcpy( rpcCU->getEdgeStartPos()    + m_uiAbsIdxInLCU, m_pucEdgeStartPos, iSizeInUchar );
     1423  memcpy( rpcCU->getEdgeLeftFirst()   + m_uiAbsIdxInLCU, m_pbEdgeLeftFirst, iSizeInBool );
     1424  memcpy( rpcCU->getEdgePartition( m_uiAbsIdxInLCU ),    m_pbEdgePartition, iSizeInBool * 16 );
     1425#endif
     1426#if H_3D_DIM_SDC
     1427  memcpy( rpcCU->getSDCFlag()             + m_uiAbsIdxInLCU, m_pbSDCFlag,      iSizeInBool  );
     1428  memcpy( rpcCU->getSDCSegmentDCOffset(0) + m_uiAbsIdxInLCU, m_apSegmentDCOffset[0], sizeof( Pel ) * m_uiNumPartition);
     1429  memcpy( rpcCU->getSDCSegmentDCOffset(1) + m_uiAbsIdxInLCU, m_apSegmentDCOffset[1], sizeof( Pel ) * m_uiNumPartition);
     1430#endif
     1431#endif
     1432
    11711433  memcpy( rpcCU->getDepth()  + m_uiAbsIdxInLCU, m_puhDepth,  iSizeInUchar );
    11721434  memcpy( rpcCU->getWidth()  + m_uiAbsIdxInLCU, m_puhWidth,  iSizeInUchar );
     
    12501512  memcpy( rpcCU->getCbf(TEXT_CHROMA_V) + uiPartOffset, m_puhCbf[2], iSizeInUchar );
    12511513 
     1514#if H_3D_DIM
     1515  for( Int i = 0; i < DMM_NUM_TYPE; i++ )
     1516  {
     1517    memcpy( rpcCU->getDimDeltaDC( i, 0 ) + uiPartOffset, m_dimDeltaDC[i][0], sizeof(Pel ) * uiQNumPart );
     1518    memcpy( rpcCU->getDimDeltaDC( i, 1 ) + uiPartOffset, m_dimDeltaDC[i][1], sizeof(Pel ) * uiQNumPart );
     1519  }
     1520#if H_3D_DIM_DMM
     1521  for( Int i = 0; i < DMM_NUM_TYPE; i++ )
     1522  {
     1523    memcpy( rpcCU->getDmmWedgeTabIdx( i ) + uiPartOffset, m_dmmWedgeTabIdx[i], sizeof(UInt) * uiQNumPart );
     1524  }
     1525  memcpy( rpcCU->getDmm2DeltaEnd()    + uiPartOffset, m_dmm2DeltaEnd   , sizeof(Int ) * uiQNumPart );
     1526  memcpy( rpcCU->getDmm3IntraTabIdx() + uiPartOffset, m_dmm3IntraTabIdx, sizeof(UInt) * uiQNumPart );
     1527#endif
     1528#if H_3D_DIM_RBC
     1529  memcpy( rpcCU->getEdgeCode( uiPartOffset ),         m_pucEdgeCode,     iSizeInUchar * RBC_MAX_EDGE_NUM_PER_4x4 );
     1530  memcpy( rpcCU->getEdgeNumber()      + uiPartOffset, m_pucEdgeNumber,   iSizeInUchar );
     1531  memcpy( rpcCU->getEdgeStartPos()    + uiPartOffset, m_pucEdgeStartPos, iSizeInUchar );
     1532  memcpy( rpcCU->getEdgeLeftFirst()   + uiPartOffset, m_pbEdgeLeftFirst, iSizeInBool );
     1533  memcpy( rpcCU->getEdgePartition( uiPartOffset ),    m_pbEdgePartition, iSizeInBool * 16 );
     1534#endif
     1535#if H_3D_DIM_SDC
     1536  memcpy( rpcCU->getSDCFlag()             + uiPartOffset, m_pbSDCFlag,      iSizeInBool  );
     1537  memcpy( rpcCU->getSDCSegmentDCOffset(0) + uiPartOffset, m_apSegmentDCOffset[0], sizeof( Pel ) * uiQNumPart);
     1538  memcpy( rpcCU->getSDCSegmentDCOffset(1) + uiPartOffset, m_apSegmentDCOffset[1], sizeof( Pel ) * uiQNumPart);
     1539#endif
     1540#endif
     1541
    12521542  memcpy( rpcCU->getDepth()  + uiPartOffset, m_puhDepth,  iSizeInUchar );
    12531543  memcpy( rpcCU->getWidth()  + uiPartOffset, m_puhWidth,  iSizeInUchar );
     
    18122102 
    18132103  iLeftIntraDir  = pcTempCU ? ( pcTempCU->isIntra( uiTempPartIdx ) ? pcTempCU->getLumaIntraDir( uiTempPartIdx ) : DC_IDX ) : DC_IDX;
     2104#if H_3D_DIM
     2105  mapDepthModeToIntraDir( iLeftIntraDir );
     2106#endif
    18142107 
    18152108  // Get intra direction of above PU
     
    18172110 
    18182111  iAboveIntraDir = pcTempCU ? ( pcTempCU->isIntra( uiTempPartIdx ) ? pcTempCU->getLumaIntraDir( uiTempPartIdx ) : DC_IDX ) : DC_IDX;
     2112#if H_3D_DIM
     2113  mapDepthModeToIntraDir( iAboveIntraDir );
     2114#endif
    18192115 
    18202116  uiPredNum = 3;
     
    21732469  }
    21742470}
     2471
     2472#if H_3D_DIM_SDC
     2473Void TComDataCU::setSDCFlagSubParts ( Bool bSDCFlag, UInt uiAbsPartIdx, UInt uiDepth )
     2474{
     2475  assert( sizeof( *m_pbSDCFlag) == 1 );
     2476  memset( m_pbSDCFlag + uiAbsPartIdx, bSDCFlag, m_pcPic->getNumPartInCU() >> ( 2 * uiDepth ) );
     2477}
     2478
     2479Bool TComDataCU::getSDCAvailable( UInt uiAbsPartIdx )
     2480{
     2481  // check general CU information
     2482  if( !getSlice()->getIsDepth() || !isIntra(uiAbsPartIdx) || getPartitionSize(uiAbsPartIdx) != SIZE_2Nx2N )
     2483    return false;
     2484 
     2485  // check prediction mode
     2486  UInt uiLumaPredMode = getLumaIntraDir( uiAbsPartIdx ); 
     2487  if( uiLumaPredMode == DC_IDX || uiLumaPredMode == PLANAR_IDX || ( getDimType( uiLumaPredMode ) == DMM1_IDX && !isDimDeltaDC( uiLumaPredMode ) ) )
     2488    return true;
     2489 
     2490  // else
     2491  return false;
     2492}
     2493#endif
    21752494
    21762495Void TComDataCU::setMergeFlagSubParts ( Bool bMergeFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
     
    41904509  {
    41914510    uiDirMode = getLumaIntraDir(uiAbsPartIdx);
     4511#if H_3D_DIM
     4512    mapDepthModeToIntraDir( uiDirMode );
     4513#endif
    41924514    uiScanIdx = SCAN_DIAG;
    41934515    if (uiCTXIdx >3 && uiCTXIdx < 6) //if multiple scans supported for transform size
     
    42074529      // get luma mode from upper-left corner of current CU
    42084530      uiDirMode = getLumaIntraDir((uiAbsPartIdx/numParts)*numParts);
     4531#if H_3D_DIM
     4532      mapDepthModeToIntraDir( uiDirMode );
     4533#endif
    42094534    }
    42104535    uiScanIdx = SCAN_DIAG;
     
    52345559  return false;
    52355560}
    5236 #endif
     5561#if H_3D_DIM_DMM
     5562Void TComDataCU::setDmmWedgeTabIdxSubParts( UInt tabIdx, UInt dmmType, UInt uiAbsPartIdx, UInt uiDepth )
     5563{
     5564  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
     5565  for( UInt ui = 0; ui < uiCurrPartNumb; ui++ ) { m_dmmWedgeTabIdx[dmmType][uiAbsPartIdx+ui] = tabIdx; }
     5566}
     5567Void  TComDataCU::setDmm2DeltaEndSubParts( Int iDelta, UInt uiAbsPartIdx, UInt uiDepth )
     5568{
     5569  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
     5570  for( UInt ui = 0; ui < uiCurrPartNumb; ui++ ) { m_dmm2DeltaEnd[uiAbsPartIdx+ui] = iDelta; }
     5571}
     5572Void  TComDataCU::setDmm3IntraTabIdxSubParts( UInt uiTIdx, UInt uiAbsPartIdx, UInt uiDepth )
     5573{
     5574  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
     5575  for( UInt ui = 0; ui < uiCurrPartNumb; ui++ ) { m_dmm3IntraTabIdx[uiAbsPartIdx+ui] = uiTIdx; }
     5576}
     5577#endif
     5578#if H_3D_DIM_RBC
     5579Void TComDataCU::reconPartition( UInt uiAbsPartIdx, UInt uiDepth, Bool bLeft, UChar ucStartPos, UChar ucNumEdge, UChar* pucEdgeCode, Bool* pbRegion )
     5580{
     5581  Int iWidth;
     5582  Int iHeight;
     5583  if( uiDepth == 0 )
     5584  {
     5585    iWidth = 64;
     5586    iHeight = 64;
     5587  }
     5588  else if( uiDepth == 1 )
     5589  {
     5590    iWidth = 32;
     5591    iHeight = 32;
     5592  }
     5593  else if( uiDepth == 2 )
     5594  {
     5595    iWidth = 16;
     5596    iHeight = 16;
     5597  }
     5598  else if( uiDepth == 3 )
     5599  {
     5600    iWidth = 8;
     5601    iHeight = 8;
     5602  }
     5603  else // uiDepth == 4
     5604  {
     5605    iWidth = 4;
     5606    iHeight = 4;
     5607  }
     5608
     5609  Int iPtr = 0;
     5610  Int iX, iY;
     5611  Int iDir = -1;
     5612  Int iDiffX = 0, iDiffY = 0;
     5613
     5614  // 1. Edge Code -> Vert & Horz Edges
     5615  Bool*  pbEdge = (Bool*) xMalloc( Bool, 4 * iWidth * iHeight );
     5616
     5617  for( UInt ui = 0; ui < 4 * iWidth * iHeight; ui++ )
     5618    pbEdge  [ ui ] = false;
     5619
     5620  // Direction : left(0), right(1), top(2), bottom(3), left-top(4), right-top(5), left-bottom(6), right-bottom(7)
     5621  // Code      : 0deg(0), 45deg(1), -45deg(2), 90deg(3), -90deg(4), 135deg(5), -135deg(6)
     5622  const UChar tableDir[8][7] = { { 0, 6, 4, 3, 2, 7, 5 },
     5623  { 1, 5, 7, 2, 3, 4, 6 },
     5624  { 2, 4, 5, 0, 1, 6, 7 },
     5625  { 3, 7, 6, 1, 0, 5, 4 },
     5626  { 4, 0, 2, 6, 5, 3, 1 },
     5627  { 5, 2, 1, 4, 7, 0, 3 },
     5628  { 6, 3, 0, 7, 4, 1, 2 },
     5629  { 7, 1, 3, 5, 6, 2, 0 }};
     5630
     5631  UChar ucCode = pucEdgeCode[iPtr++];
     5632
     5633  if( !bLeft )
     5634  {
     5635    iX = ucStartPos;
     5636    iY = 0;
     5637
     5638    switch(ucCode)
     5639    {
     5640    case 0: // bottom
     5641      iDir = 3;
     5642      if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5643      break;
     5644    case 2: // left-bottom
     5645      iDir = 6;
     5646      if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5647      break;
     5648    case 1: // right-bottom
     5649      iDir = 7;
     5650      if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5651      if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5652      break;
     5653    case 4: // left
     5654      iDir = 0;
     5655      assert(false);
     5656      break;
     5657    case 3: // right
     5658      iDir = 1;
     5659      if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5660      if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5661      break;
     5662    }
     5663  }
     5664  else
     5665  {
     5666    iX = 0;
     5667    iY = ucStartPos;
     5668
     5669    switch(ucCode)
     5670    {
     5671    case 0: // right
     5672      iDir = 1;
     5673      if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5674      break;
     5675    case 1: // right-top
     5676      iDir = 5;
     5677      if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5678      if(iX < iWidth - 1) pbEdge[ 2 * (iX + 0) + 1 + iY * 4 * iWidth ] = true;
     5679      break;
     5680    case 2: // right-bottom
     5681      iDir = 7;
     5682      if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5683      break;
     5684    case 3: // top
     5685      iDir = 2;
     5686      if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5687      if(iX < iWidth - 1) pbEdge[ 2 * (iX + 0) + 1 + iY * 4 * iWidth ] = true;
     5688      break;
     5689    case 4: // bottom
     5690      iDir = 3;
     5691      assert(false);
     5692      break;
     5693    }
     5694  }
     5695
     5696  switch( iDir )
     5697  {
     5698  case 0: // left
     5699    iDiffX = -1;
     5700    iDiffY = 0;
     5701    break;
     5702  case 1: // right
     5703    iDiffX = +1;
     5704    iDiffY = 0;
     5705    break;
     5706  case 2: // top
     5707    iDiffX = 0;
     5708    iDiffY = -1;
     5709    break;
     5710  case 3: // bottom
     5711    iDiffX = 0;
     5712    iDiffY = +1;
     5713    break;
     5714  case 4: // left-top
     5715    iDiffX = -1;
     5716    iDiffY = -1;
     5717    break;
     5718  case 5: // right-top
     5719    iDiffX = +1;
     5720    iDiffY = -1;
     5721    break;
     5722  case 6: // left-bottom
     5723    iDiffX = -1;
     5724    iDiffY = +1;
     5725    break;
     5726  case 7: // right-bottom
     5727    iDiffX = +1;
     5728    iDiffY = +1;
     5729    break;
     5730  }
     5731
     5732  iX += iDiffX;
     5733  iY += iDiffY;
     5734
     5735  while( iPtr < ucNumEdge )
     5736  {
     5737    ucCode = pucEdgeCode[iPtr++];
     5738
     5739    Int iNewDir = tableDir[iDir][ucCode];
     5740
     5741    switch( iNewDir )
     5742    {
     5743    case 0: // left
     5744      iDiffX = -1;
     5745      iDiffY = 0;
     5746      break;
     5747    case 1: // right
     5748      iDiffX = +1;
     5749      iDiffY = 0;
     5750      break;
     5751    case 2: // top
     5752      iDiffX = 0;
     5753      iDiffY = -1;
     5754      break;
     5755    case 3: // bottom
     5756      iDiffX = 0;
     5757      iDiffY = +1;
     5758      break;
     5759    case 4: // left-top
     5760      iDiffX = -1;
     5761      iDiffY = -1;
     5762      break;
     5763    case 5: // right-top
     5764      iDiffX = +1;
     5765      iDiffY = -1;
     5766      break;
     5767    case 6: // left-bottom
     5768      iDiffX = -1;
     5769      iDiffY = +1;
     5770      break;
     5771    case 7: // right-bottom
     5772      iDiffX = +1;
     5773      iDiffY = +1;
     5774      break;
     5775    }
     5776
     5777    switch( iDir )
     5778    {
     5779    case 0: // left
     5780      switch( ucCode )
     5781      {
     5782      case 0:
     5783      case 2:
     5784        if(iY > 0) pbEdge[ 2 * iX + (2 * (iY - 1) + 1) * 2 * iWidth ] = true;
     5785        break;
     5786      case 1:
     5787      case 3:
     5788        if(iY > 0) pbEdge[ 2 * iX + (2 * (iY - 1) + 1) * 2 * iWidth ] = true;
     5789        if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5790        break;
     5791      case 4:
     5792      case 6:
     5793        // no
     5794        break;
     5795      case 5:
     5796        if(iY > 0) pbEdge[ 2 * iX + (2 * (iY - 1) + 1) * 2 * iWidth ] = true;
     5797        if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5798        if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5799        break;
     5800      }
     5801      break;
     5802    case 1: // right
     5803      switch( ucCode )
     5804      {
     5805      case 0:
     5806      case 2:
     5807        if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5808        break;
     5809      case 1:
     5810      case 3:
     5811        if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5812        if(iX < iWidth - 1) pbEdge[ 2 * (iX + 0) + 1 + iY * 4 * iWidth ] = true;
     5813        break;
     5814      case 4:
     5815      case 6:
     5816        // no
     5817        break;
     5818      case 5:
     5819        if(iY > 0) pbEdge[ 2 * iX + (2 * (iY - 1) + 1) * 2 * iWidth ] = true;
     5820        if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5821        if(iX < iWidth - 1) pbEdge[ 2 * (iX + 0) + 1 + iY * 4 * iWidth ] = true;
     5822        break;
     5823      }
     5824      break;
     5825    case 2: // top
     5826      switch( ucCode )
     5827      {
     5828      case 0:
     5829      case 2:
     5830        if(iX < iWidth - 1) pbEdge[ 2 * (iX + 0) + 1 + iY * 4 * iWidth ] = true;
     5831        break;
     5832      case 1:
     5833      case 3:
     5834        if(iY > 0) pbEdge[ 2 * iX + (2 * (iY - 1) + 1) * 2 * iWidth ] = true;
     5835        if(iX < iWidth - 1) pbEdge[ 2 * (iX + 0) + 1 + iY * 4 * iWidth ] = true;
     5836        break;
     5837      case 4:
     5838      case 6:
     5839        // no
     5840        break;
     5841      case 5:
     5842        if(iY > 0) pbEdge[ 2 * iX + (2 * (iY - 1) + 1) * 2 * iWidth ] = true;
     5843        if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5844        if(iX < iWidth - 1) pbEdge[ 2 * (iX + 0) + 1 + iY * 4 * iWidth ] = true;
     5845        break;
     5846      }
     5847      break;
     5848    case 3: // bottom
     5849      switch( ucCode )
     5850      {
     5851      case 0:
     5852      case 2:
     5853        if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5854        break;
     5855      case 1:
     5856      case 3:
     5857        if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5858        if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5859        break;
     5860      case 4:
     5861      case 6:
     5862        // no
     5863        break;
     5864      case 5:
     5865        if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5866        if(iX < iWidth - 1) pbEdge[ 2 * (iX + 0) + 1 + iY * 4 * iWidth ] = true;
     5867        if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5868        break;
     5869      }
     5870      break;
     5871    case 4: // left-top
     5872      switch( ucCode )
     5873      {
     5874      case 0:
     5875      case 1:
     5876        if(iY > 0) pbEdge[ 2 * iX + (2 * (iY - 1) + 1) * 2 * iWidth ] = true;
     5877        if(iX < iWidth - 1) pbEdge[ 2 * (iX + 0) + 1 + iY * 4 * iWidth ] = true;
     5878        break;
     5879      case 2:
     5880      case 4:
     5881        if(iX < iWidth - 1) pbEdge[ 2 * (iX + 0) + 1 + iY * 4 * iWidth ] = true;
     5882        break;
     5883      case 3:
     5884      case 5:
     5885        if(iY > 0) pbEdge[ 2 * iX + (2 * (iY - 1) + 1) * 2 * iWidth ] = true;
     5886        if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5887        if(iX < iWidth - 1) pbEdge[ 2 * (iX + 0) + 1 + iY * 4 * iWidth ] = true;
     5888        break;
     5889      case 6:
     5890        // no
     5891        break;
     5892      }
     5893      break;
     5894    case 5: // right-top
     5895      switch( ucCode )
     5896      {
     5897      case 0:
     5898      case 1:
     5899        if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5900        if(iX < iWidth - 1) pbEdge[ 2 * (iX + 0) + 1 + iY * 4 * iWidth ] = true;
     5901        break;
     5902      case 2:
     5903      case 4:
     5904        if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5905        break;
     5906      case 3:
     5907      case 5:
     5908        if(iY > 0) pbEdge[ 2 * iX + (2 * (iY - 1) + 1) * 2 * iWidth ] = true;
     5909        if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5910        if(iX < iWidth - 1) pbEdge[ 2 * (iX + 0) + 1 + iY * 4 * iWidth ] = true;
     5911        break;
     5912      case 6:
     5913        // no
     5914        break;
     5915      }
     5916      break;
     5917    case 6: // left-bottom
     5918      switch( ucCode )
     5919      {
     5920      case 0:
     5921      case 1:
     5922        if(iY > 0) pbEdge[ 2 * iX + (2 * (iY - 1) + 1) * 2 * iWidth ] = true;
     5923        if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5924        break;
     5925      case 2:
     5926      case 4:
     5927        if(iY > 0) pbEdge[ 2 * iX + (2 * (iY - 1) + 1) * 2 * iWidth ] = true;
     5928        break;
     5929      case 3:
     5930      case 5:
     5931        if(iY > 0) pbEdge[ 2 * iX + (2 * (iY - 1) + 1) * 2 * iWidth ] = true;
     5932        if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5933        if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5934        break;
     5935      case 6:
     5936        // no
     5937        break;
     5938      }
     5939      break;
     5940    case 7: // right-bottom
     5941      switch( ucCode )
     5942      {
     5943      case 0:
     5944      case 1:
     5945        if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5946        if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5947        break;
     5948      case 2:
     5949      case 4:
     5950        if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5951        break;
     5952      case 3:
     5953      case 5:
     5954        if(iX > 0) pbEdge[ 2 * (iX - 1) + 1 + iY * 4 * iWidth ] = true;
     5955        if(iX < iWidth - 1) pbEdge[ 2 * (iX + 0) + 1 + iY * 4 * iWidth ] = true;
     5956        if(iY < iHeight - 1) pbEdge[ 2 * iX + (2 * (iY + 0) + 1) * 2 * iWidth ] = true;
     5957        break;
     5958      case 6:
     5959        // no
     5960        break;
     5961      }
     5962      break;
     5963    }
     5964
     5965    assert( iX >= 0 && iX <= iWidth );
     5966    assert( iY >= 0 && iY <= iHeight );
     5967
     5968    iX += iDiffX;
     5969    iY += iDiffY;
     5970    iDir = iNewDir;
     5971  }
     5972
     5973  // finalize edge chain
     5974  if( iX == iWidth-1 )
     5975  {
     5976    if( iY == 0 )
     5977    {
     5978      if( iDir == 1 )
     5979      {
     5980        pbEdge[ 2 * iX + (2 * iY + 1) * 2 * iWidth ] = true;
     5981      }
     5982      else if( iDir == 5 )
     5983      {
     5984        pbEdge[ 2 * iX + (2 * iY + 1) * 2 * iWidth ] = true;
     5985      }
     5986      else
     5987      {
     5988        assert(false);
     5989      }
     5990    }
     5991    else if( iY == iHeight-1 )
     5992    {
     5993      if( iDir == 3 )
     5994      {
     5995        pbEdge[ 2 * iX - 1 + 2 * iY * 2 * iWidth ] = true;
     5996      }
     5997      else if( iDir == 7 )
     5998      {
     5999        pbEdge[ 2 * iX - 1 + 2 * iY * 2 * iWidth ] = true;
     6000      }
     6001      else
     6002      {
     6003        assert(false);
     6004      }
     6005    }
     6006    else
     6007    {
     6008      if( iDir == 1 )
     6009      {
     6010        pbEdge[ 2 * iX + (2 * iY + 1) * 2 * iWidth ] = true;
     6011      }
     6012      else if( iDir == 3 )
     6013      {
     6014        pbEdge[ 2 * iX - 1 + 2 * iY * 2 * iWidth ] = true;
     6015        pbEdge[ 2 * iX + (2 * iY + 1) * 2 * iWidth ] = true;
     6016      }
     6017      else if( iDir == 5 )
     6018      {
     6019        pbEdge[ 2 * iX + (2 * iY + 1) * 2 * iWidth ] = true;
     6020      }
     6021      else if( iDir == 7 )
     6022      {
     6023        pbEdge[ 2 * iX - 1 + 2 * iY * 2 * iWidth ] = true;
     6024        pbEdge[ 2 * iX + (2 * iY + 1) * 2 * iWidth ] = true;
     6025      }
     6026      else
     6027      {
     6028        assert(false);
     6029      }
     6030    }
     6031  }
     6032  else if( iX == 0 )
     6033  {
     6034    if( iY == 0 )
     6035    {
     6036      if( iDir == 2 )
     6037      {
     6038        pbEdge[ 2 * iX + 1 + 2 * iY * 2 * iWidth ] = true;
     6039      }
     6040      else if( iDir == 4 )
     6041      {
     6042        pbEdge[ 2 * iX + 1 + 2 * iY * 2 * iWidth ] = true;
     6043      }
     6044      else
     6045      {
     6046        assert(false);
     6047      }
     6048    }
     6049    else if( iY == iHeight-1 )
     6050    {
     6051      if( iDir == 0 )
     6052      {
     6053        pbEdge[ 2 * iX + (2 * iY - 1) * 2 * iWidth ] = true;
     6054      }
     6055      else if( iDir == 6 )
     6056      {
     6057        pbEdge[ 2 * iX + (2 * iY - 1) * 2 * iWidth ] = true;
     6058      }
     6059      else
     6060      {
     6061        assert(false);
     6062      }
     6063    }
     6064    else
     6065    {
     6066      if( iDir == 0 )
     6067      {
     6068        pbEdge[ 2 * iX + (2 * iY - 1) * 2 * iWidth ] = true;
     6069      }
     6070      else if( iDir == 2 )
     6071      {
     6072        pbEdge[ 2 * iX + 1 + 2 * iY * 2 * iWidth ] = true;
     6073        pbEdge[ 2 * iX + (2 * iY - 1) * 2 * iWidth ] = true;
     6074      }
     6075      else if( iDir == 4 )
     6076      {
     6077        pbEdge[ 2 * iX + 1 + 2 * iY * 2 * iWidth ] = true;
     6078        pbEdge[ 2 * iX + (2 * iY - 1) * 2 * iWidth ] = true;
     6079      }
     6080      else if( iDir == 6 )
     6081      {
     6082        pbEdge[ 2 * iX + (2 * iY - 1) * 2 * iWidth ] = true;
     6083      }
     6084      else
     6085      {
     6086        assert(false);
     6087      }
     6088    }
     6089  }
     6090  else if( iY == 0 )
     6091  {
     6092    if( iDir == 1 )
     6093    {
     6094      pbEdge[ 2 * iX + (2 * iY + 1) * 2 * iWidth ] = true;
     6095      pbEdge[ 2 * iX + 1 + 2 * iY * 2 * iWidth ] = true;
     6096    }
     6097    else if( iDir == 2 )
     6098    {
     6099      pbEdge[ 2 * iX + 1 + 2 * iY * 2 * iWidth ] = true;
     6100    }
     6101    else if( iDir == 4 )
     6102    {
     6103      pbEdge[ 2 * iX + 1 + 2 * iY * 2 * iWidth ] = true;
     6104    }
     6105    else if( iDir == 5 )
     6106    {
     6107      pbEdge[ 2 * iX + (2 * iY + 1) * 2 * iWidth ] = true;
     6108      pbEdge[ 2 * iX + 1 + 2 * iY * 2 * iWidth ] = true;
     6109    }
     6110    else
     6111    {
     6112      assert(false);
     6113    }
     6114  }
     6115  else if( iY == iHeight-1 )
     6116  {
     6117    if( iDir == 0 )
     6118    {
     6119      pbEdge[ 2 * iX + (2 * iY - 1) * 2 * iWidth ] = true;
     6120      pbEdge[ 2 * iX - 1 + 2 * iY * 2 * iWidth ] = true;
     6121    }
     6122    else if( iDir == 3 )
     6123    {
     6124      pbEdge[ 2 * iX - 1 + 2 * iY * 2 * iWidth ] = true;
     6125    }
     6126    else if( iDir == 6 )
     6127    {
     6128      pbEdge[ 2 * iX + (2 * iY - 1) * 2 * iWidth ] = true;
     6129      pbEdge[ 2 * iX - 1 + 2 * iY * 2 * iWidth ] = true;
     6130    }
     6131    else if( iDir == 7 )
     6132    {
     6133      pbEdge[ 2 * iX - 1 + 2 * iY * 2 * iWidth ] = true;
     6134    }
     6135    else
     6136    {
     6137      assert(false);
     6138    }
     6139  }
     6140  else
     6141  {
     6142    printf("reconPartiton: wrong termination\n");
     6143    assert(false);
     6144  }
     6145
     6146  // Reconstruct Region from Chain Code
     6147  Bool* pbVisit  = (Bool*) xMalloc( Bool, iWidth * iHeight );
     6148  Int*  piStack  = (Int* ) xMalloc( Int,  iWidth * iHeight );
     6149
     6150  for( UInt ui = 0; ui < iWidth * iHeight; ui++ )
     6151  {
     6152    pbRegion[ ui ] = true; // fill it as region 1 (we'll discover region 0 next)
     6153    pbVisit [ ui ] = false;
     6154  }
     6155
     6156  iPtr = 0;
     6157  piStack[iPtr++] = (0 << 8) | (0);
     6158  pbRegion[ 0 ] = false;
     6159
     6160  while(iPtr > 0)
     6161  {
     6162    Int iTmp = piStack[--iPtr];
     6163    Int iX1, iY1;
     6164    iX1 = iTmp & 0xff;
     6165    iY1 = (iTmp >> 8) & 0xff;
     6166
     6167    pbVisit[ iX1 + iY1 * iWidth ] = true;
     6168
     6169    assert( iX1 >= 0 && iX1 < iWidth );
     6170    assert( iY1 >= 0 && iY1 < iHeight );
     6171
     6172    if( iX1 > 0 && !pbEdge[ 2 * iX1 - 1 + 4 * iY1 * iWidth ] && !pbVisit[ iX1 - 1 + iY1 * iWidth ] )
     6173    {
     6174      piStack[iPtr++] = (iY1 << 8) | (iX1 - 1);
     6175      pbRegion[ iX1 - 1 + iY1 * iWidth ] = false;
     6176    }
     6177    if( iX1 < iWidth - 1 && !pbEdge[ 2 * iX1 + 1 + 4 * iY1 * iWidth ] && !pbVisit[ iX1 + 1 + iY1 * iWidth ] )
     6178    {
     6179      piStack[iPtr++] = (iY1 << 8) | (iX1 + 1);
     6180      pbRegion[ iX1 + 1 + iY1 * iWidth ] = false;
     6181    }
     6182    if( iY1 > 0 && !pbEdge[ 2 * iX1 + 2 * (2 * iY1 - 1) * iWidth ] && !pbVisit[ iX1 + (iY1 - 1) * iWidth ] )
     6183    {
     6184      piStack[iPtr++] = ((iY1 - 1) << 8) | iX1;
     6185      pbRegion[ iX1 + (iY1 - 1) * iWidth ] = false;
     6186    }
     6187    if( iY1 < iHeight - 1 && !pbEdge[ 2 * iX1 + 2 * (2 * iY1 + 1) * iWidth ] && !pbVisit[ iX1 + (iY1 + 1) * iWidth ] )
     6188    {
     6189      piStack[iPtr++] = ((iY1 + 1) << 8) | iX1;
     6190      pbRegion[ iX1 + (iY1 + 1) * iWidth ] = false;
     6191    }
     6192  }
     6193
     6194  xFree( pbEdge );
     6195  xFree( pbVisit );
     6196  xFree( piStack );
     6197}
     6198#endif
     6199#endif
     6200
    52376201//! \}
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComDataCU.h

    r530 r531  
    204204  Bool*         m_pbICFlag;           ///< array of IC flags
    205205#endif
     206#if H_3D_DIM
     207  Pel*          m_dimDeltaDC[DIM_NUM_TYPE][2];
     208#if H_3D_DIM_DMM
     209  UInt*         m_dmmWedgeTabIdx[DMM_NUM_TYPE];
     210  Int*          m_dmm2DeltaEnd;
     211  UInt*         m_dmm3IntraTabIdx;
     212#endif
     213#if H_3D_DIM_RBC
     214  UChar*        m_pucEdgeCode;          ///< array of edge code
     215  UChar*        m_pucEdgeNumber;        ///< total number of edge
     216  UChar*        m_pucEdgeStartPos;      ///< starting point position
     217  Bool*         m_pbEdgeLeftFirst;      ///< true if edge should be checked in left boundary first
     218  Bool*         m_pbEdgePartition;      ///< true if it belongs to region 1, otherwise, region 0
     219#endif
     220#if H_3D_DIM_SDC
     221  Bool*         m_pbSDCFlag;
     222  Pel*          m_apSegmentDCOffset[2];
     223#endif
     224#endif
     225
    206226  // -------------------------------------------------------------------------------------------------------------------
    207227  // misc. variables
     
    491511  UChar         getNumPartInter       ();
    492512  Bool          isFirstAbsZorderIdxInDepth (UInt uiAbsPartIdx, UInt uiDepth);
     513
     514#if H_3D_DIM
     515  Pel*  getDimDeltaDC                 ( UInt dimType, UInt segId )                      { return m_dimDeltaDC[dimType][segId];        }
     516  Pel   getDimDeltaDC                 ( UInt dimType, UInt segId, UInt uiIdx )          { return m_dimDeltaDC[dimType][segId][uiIdx]; }
     517  Void  setDimDeltaDC                 ( UInt dimType, UInt segId, UInt uiIdx, Pel val ) { m_dimDeltaDC[dimType][segId][uiIdx] = val;  }
     518#if H_3D_DIM_DMM
     519  UInt* getDmmWedgeTabIdx             ( UInt dmmType )                          { return m_dmmWedgeTabIdx[dmmType];          }       
     520  UInt  getDmmWedgeTabIdx             ( UInt dmmType, UInt uiIdx )              { return m_dmmWedgeTabIdx[dmmType][uiIdx];   }
     521  Void  setDmmWedgeTabIdx             ( UInt dmmType, UInt uiIdx, UInt tabIdx ) { m_dmmWedgeTabIdx[dmmType][uiIdx] = tabIdx; }
     522  Void  setDmmWedgeTabIdxSubParts     ( UInt tabIdx, UInt dmmType, UInt uiAbsPartIdx, UInt uiDepth );
     523
     524  Int*  getDmm2DeltaEnd               ()                      { return m_dmm2DeltaEnd;        }
     525  Int   getDmm2DeltaEnd               ( UInt uiIdx )          { return m_dmm2DeltaEnd[uiIdx]; }
     526  Void  setDmm2DeltaEnd               ( UInt uiIdx, Int iD )  { m_dmm2DeltaEnd[uiIdx] = iD;   }
     527  Void  setDmm2DeltaEndSubParts       ( Int iDelta, UInt uiAbsPartIdx, UInt uiDepth );
     528
     529  UInt* getDmm3IntraTabIdx            ()                      { return m_dmm3IntraTabIdx;        }
     530  UInt  getDmm3IntraTabIdx            ( UInt uiIdx )          { return m_dmm3IntraTabIdx[uiIdx]; }
     531  Void  setDmm3IntraTabIdx            ( UInt uiIdx, UInt uh ) { m_dmm3IntraTabIdx[uiIdx] = uh;   }
     532  Void  setDmm3IntraTabIdxSubParts    ( UInt uiTIdx, UInt uiAbsPartIdx, UInt uiDepth );
     533#endif
     534#if H_3D_DIM_RBC
     535  UChar* getEdgeCode( UInt uiIdx )                 { return &m_pucEdgeCode[uiIdx * RBC_MAX_EDGE_NUM_PER_4x4]; }
     536
     537  UChar* getEdgeNumber( )                          { return m_pucEdgeNumber;           }
     538  UChar  getEdgeNumber( UInt uiIdx )               { return m_pucEdgeNumber[uiIdx];    }
     539  Void   setEdgeNumber( UInt uiIdx, UChar val )    { m_pucEdgeNumber[uiIdx] = val;     }
     540
     541  UChar* getEdgeStartPos( )                        { return m_pucEdgeStartPos;         }
     542  UChar  getEdgeStartPos( UInt uiIdx )             { return m_pucEdgeStartPos[uiIdx];  }
     543  Void   setEdgeStartPos( UInt uiIdx, UChar val )  { m_pucEdgeStartPos[uiIdx] = val;   }
     544
     545  Bool*  getEdgeLeftFirst( )                       { return m_pbEdgeLeftFirst;         }
     546  Bool   getEdgeLeftFirst( UInt uiIdx )            { return m_pbEdgeLeftFirst[uiIdx];  }
     547  Void   setEdgeLeftFirst( UInt uiIdx, Bool val )  { m_pbEdgeLeftFirst[uiIdx] = val;   }
     548
     549  Bool*  getEdgePartition( UInt uiIdx )            { return &m_pbEdgePartition[uiIdx * 16]; }
     550
     551  Void   reconPartition( UInt uiAbsPartIdx, UInt uiDepth, Bool bLeft, UChar ucStartPos, UChar ucNumEdge, UChar* pucEdgeCode, Bool* pbRegion );
     552#endif
     553#if H_3D_DIM_SDC
     554  Bool*         getSDCFlag          ()                        { return m_pbSDCFlag;               }
     555  Bool          getSDCFlag          ( UInt uiIdx )            { return m_pbSDCFlag[uiIdx];        }
     556  Void          setSDCFlagSubParts  ( Bool bSDCFlag, UInt uiAbsPartIdx, UInt uiDepth );
     557 
     558  Bool          getSDCAvailable             ( UInt uiAbsPartIdx );
     559 
     560  Pel*          getSDCSegmentDCOffset( UInt uiSeg ) { return m_apSegmentDCOffset[uiSeg]; }
     561  Pel           getSDCSegmentDCOffset( UInt uiSeg, UInt uiPartIdx ) { return m_apSegmentDCOffset[uiSeg][uiPartIdx]; }
     562  Void          setSDCSegmentDCOffset( Pel pOffset, UInt uiSeg, UInt uiPartIdx) { m_apSegmentDCOffset[uiSeg][uiPartIdx] = pOffset; }
     563#endif
     564#endif
    493565 
    494566  // -------------------------------------------------------------------------------------------------------------------
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComPrediction.cpp

    r530 r531  
    410410}
    411411
     412#if H_3D_DIM
     413Void TComPrediction::predIntraLumaDepth( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiIntraMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bFastEnc )
     414{
     415  assert( iWidth == iHeight  );
     416  assert( iWidth >= DIM_MIN_SIZE && iWidth <= DIM_MAX_SIZE );
     417  assert( isDimMode( uiIntraMode ) );
     418
     419  UInt dimType    = getDimType  ( uiIntraMode );
     420  Bool dimDeltaDC = isDimDeltaDC( uiIntraMode );   
     421  Bool isDmmMode  = (dimType <  DMM_NUM_TYPE);
     422  Bool isRbcMode  = (dimType == RBC_IDX);
     423
     424  Bool* biSegPattern  = NULL;
     425  UInt  patternStride = 0;
     426
     427  // get partiton
     428#if H_3D_DIM_DMM
     429  TComWedgelet* dmmSegmentation = NULL;
     430  if( isDmmMode )
     431  {
     432    switch( dimType )
     433    {
     434    case( DMM1_IDX ):
     435      {
     436        dmmSegmentation = &(g_dmmWedgeLists[ g_aucConvertToBit[iWidth] ][ pcCU->getDmmWedgeTabIdx( dimType, uiAbsPartIdx ) ]);
     437      } break;
     438    case( DMM2_IDX ):
     439      {
     440        UInt uiTabIdx = 0;
     441        if( bFastEnc ) { uiTabIdx = pcCU->getDmmWedgeTabIdx( dimType, uiAbsPartIdx ); }
     442        else
     443        {
     444          uiTabIdx = xPredWedgeFromIntra( pcCU, uiAbsPartIdx, iWidth, iHeight, pcCU->getDmm2DeltaEnd( uiAbsPartIdx ) );
     445          pcCU->setDmmWedgeTabIdxSubParts( uiTabIdx, dimType, uiAbsPartIdx, (pcCU->getDepth(0) + (pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1)) );
     446        }
     447        dmmSegmentation = &(g_dmmWedgeLists[ g_aucConvertToBit[iWidth] ][ uiTabIdx ]);
     448      } break;
     449    case( DMM3_IDX ):
     450      {
     451        UInt uiTabIdx = 0;
     452        if( bFastEnc ) { uiTabIdx = pcCU->getDmmWedgeTabIdx( dimType, uiAbsPartIdx ); }
     453        else
     454        {
     455          uiTabIdx = xPredWedgeFromTex( pcCU, uiAbsPartIdx, iWidth, iHeight, pcCU->getDmm3IntraTabIdx( uiAbsPartIdx ) );
     456          pcCU->setDmmWedgeTabIdxSubParts( uiTabIdx, dimType, uiAbsPartIdx, (pcCU->getDepth(0) + (pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1)) );
     457        }
     458        dmmSegmentation = &(g_dmmWedgeLists[ g_aucConvertToBit[iWidth] ][ uiTabIdx ]);
     459      } break;
     460    case( DMM4_IDX ):
     461      {
     462        dmmSegmentation = new TComWedgelet( iWidth, iHeight );
     463        xPredContourFromTex( pcCU, uiAbsPartIdx, iWidth, iHeight, dmmSegmentation );
     464      } break;
     465    default: assert(0);
     466    }
     467    assert( dmmSegmentation );
     468    biSegPattern  = dmmSegmentation->getPattern();
     469    patternStride = dmmSegmentation->getStride ();
     470  }
     471#endif
     472#if H_3D_DIM_RBC
     473  if( isRbcMode )
     474  {
     475    biSegPattern  = pcCU->getEdgePartition( uiAbsPartIdx );
     476    patternStride = iWidth;
     477  }
     478#endif
     479
     480  // get predicted partition values
     481  assert( biSegPattern );
     482  Int* piMask = NULL;
     483  if( isDmmMode ) piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt ); // no filtering for DMM
     484  else            piMask = pcCU->getPattern()->getPredictorPtr( 0, g_aucConvertToBit[ iWidth ] + 2, m_piYuvExt );
     485  assert( piMask );
     486  Int maskStride = 2*iWidth + 1; 
     487  Int* ptrSrc = piMask+maskStride+1;
     488  Pel predDC1 = 0; Pel predDC2 = 0;
     489  xPredBiSegDCs( ptrSrc, maskStride, biSegPattern, patternStride, predDC1, predDC2 );
     490
     491  // set segment values with deltaDC offsets
     492  Pel segDC1 = 0;
     493  Pel segDC2 = 0;
     494  if( dimDeltaDC )
     495  {
     496    Pel deltaDC1 = pcCU->getDimDeltaDC( dimType, 0, uiAbsPartIdx );
     497    Pel deltaDC2 = pcCU->getDimDeltaDC( dimType, 1, uiAbsPartIdx );
     498#if H_3D_DIM_DMM
     499    if( isDmmMode )
     500    {
     501#if H_3D_DIM_DLT
     502      segDC1 = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC1 ) + deltaDC1 );
     503      segDC2 = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC2 ) + deltaDC2 );
     504#else
     505      segDC1 = ClipY( predDC1 + deltaDC1 );
     506      segDC2 = ClipY( predDC2 + deltaDC2 );
     507#endif
     508    }
     509#endif
     510#if H_3D_DIM_RBC
     511    if( isRbcMode )
     512    {
     513      xDeltaDCQuantScaleUp( pcCU, deltaDC1 );
     514      xDeltaDCQuantScaleUp( pcCU, deltaDC2 );
     515      segDC1 = ClipY( predDC1 + deltaDC1 );
     516      segDC2 = ClipY( predDC2 + deltaDC2 );
     517    }
     518#endif
     519  }
     520  else
     521  {
     522    segDC1 = predDC1;
     523    segDC2 = predDC2;
     524  }
     525
     526  // set prediction signal
     527  Pel* pDst = piPred;
     528  xAssignBiSegDCs( pDst, uiStride, biSegPattern, patternStride, segDC1, segDC2 );
     529
     530#if H_3D_DIM_DMM
     531  if( dimType == DMM4_IDX ) { dmmSegmentation->destroy(); delete dmmSegmentation; }
     532#endif
     533}
     534#endif
     535
    412536/** Function for checking identical motion.
    413537 * \param TComDataCU* pcCU
     
    689813      pYuvB0->multiplyARP( uiPartAddr , iWidth , iHeight , dW );
    690814    }
    691 
    692815    rpcYuvPred->addARP( rpcYuvPred , pYuvB0 , uiPartAddr , iWidth , iHeight , !bi );
    693816  }
     
    18561979#endif // H_3D_VSP
    18571980
     1981#if H_3D_DIM
     1982Void TComPrediction::xPredBiSegDCs( Int* ptrSrc, UInt srcStride, Bool* biSegPattern, Int patternStride, Pel& predDC1, Pel& predDC2 )
     1983{
     1984  Int  refDC1, refDC2;
     1985  const Int  iTR = (   patternStride - 1        ) - srcStride;
     1986  const Int  iTM = ( ( patternStride - 1 ) >> 1 ) - srcStride;
     1987  const Int  iLB = (   patternStride - 1        ) * srcStride - 1;
     1988  const Int  iLM = ( ( patternStride - 1 ) >> 1 ) * srcStride - 1;
     1989
     1990  Bool bL = ( biSegPattern[0] != biSegPattern[(patternStride-1)*patternStride] );
     1991  Bool bT = ( biSegPattern[0] != biSegPattern[(patternStride-1)]               );
     1992
     1993  if( bL == bT )
     1994  {
     1995    refDC1 = bL ? ( ptrSrc[iTR] + ptrSrc[iLB] )>>1 : 1<<( g_bitDepthY - 1 );
     1996    refDC2 =      ( ptrSrc[ -1] + ptrSrc[-(Int)srcStride] )>>1;
     1997  }
     1998  else
     1999  {
     2000    refDC1 = bL ? ptrSrc[iLB] : ptrSrc[iTR];
     2001    refDC2 = bL ? ptrSrc[iTM] : ptrSrc[iLM];
     2002  }
     2003
     2004  predDC1 = biSegPattern[0] ? refDC1 : refDC2;
     2005  predDC2 = biSegPattern[0] ? refDC2 : refDC1;
     2006}
     2007
     2008Void TComPrediction::xAssignBiSegDCs( Pel* ptrDst, UInt dstStride, Bool* biSegPattern, Int patternStride, Pel valDC1, Pel valDC2 )
     2009{
     2010  if( dstStride == patternStride )
     2011  {
     2012    for( UInt k = 0; k < (patternStride * patternStride); k++ )
     2013    {
     2014      if( true == biSegPattern[k] ) { ptrDst[k] = valDC2; }
     2015      else                          { ptrDst[k] = valDC1; }
     2016    }
     2017  }
     2018  else
     2019  {
     2020    Pel* piTemp = ptrDst;
     2021    for( UInt uiY = 0; uiY < patternStride; uiY++ )
     2022    {
     2023      for( UInt uiX = 0; uiX < patternStride; uiX++ )
     2024      {
     2025        if( true == biSegPattern[uiX] ) { piTemp[uiX] = valDC2; }
     2026        else                            { piTemp[uiX] = valDC1; }
     2027      }
     2028      piTemp       += dstStride;
     2029      biSegPattern += patternStride;
     2030    }
     2031  }
     2032}
     2033
     2034#if H_3D_DIM_DMM
     2035UInt TComPrediction::xPredWedgeFromIntra( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Int iDeltaEnd )
     2036{
     2037  UInt uiThisBlockSize = uiWidth;
     2038
     2039  TComDataCU* pcTempCU;
     2040  UInt        uiTempPartIdx;
     2041  // 1st: try continue above wedgelet
     2042  pcTempCU = pcCU->getPUAbove( uiTempPartIdx, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
     2043  if( pcTempCU && isDimMode( pcTempCU->getLumaIntraDir( uiTempPartIdx ) ) )
     2044  {
     2045    UInt dimType =  getDimType( pcTempCU->getLumaIntraDir( uiTempPartIdx ) );
     2046    if( DMM1_IDX == dimType || DMM2_IDX == dimType || DMM3_IDX == dimType )
     2047    {
     2048      // get offset between current and reference block
     2049      UInt uiOffsetX = 0, uiOffsetY = 0;
     2050      xGetBlockOffset( pcCU, uiAbsPartIdx, pcTempCU, uiTempPartIdx, uiOffsetX, uiOffsetY );
     2051
     2052      // get reference wedgelet
     2053      WedgeList* pacWedgeList = &g_dmmWedgeLists[(g_aucConvertToBit[(pcTempCU->getWidth( uiTempPartIdx )>>((pcTempCU->getPartitionSize( uiTempPartIdx ) == SIZE_NxN) ? 1 : 0))])];
     2054      TComWedgelet* pcRefWedgelet = &(pacWedgeList->at( pcTempCU->getDmmWedgeTabIdx( dimType, uiTempPartIdx ) ) );
     2055
     2056      // find wedgelet, if direction is suitable for continue wedge
     2057      if( pcRefWedgelet->checkPredDirAbovePossible( uiThisBlockSize, uiOffsetX ) )
     2058      {
     2059        UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
     2060        pcRefWedgelet->getPredDirStartEndAbove( uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, uiThisBlockSize, uiOffsetX, iDeltaEnd );
     2061        return xGetWedgePatternIdx( uiThisBlockSize, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
     2062      }
     2063    }
     2064  }
     2065
     2066  // 2nd: try continue left wedglelet
     2067  pcTempCU = pcCU->getPULeft( uiTempPartIdx, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
     2068  if( pcTempCU && isDimMode( pcTempCU->getLumaIntraDir( uiTempPartIdx ) ) )
     2069  {
     2070    UInt dimType = getDimType( pcTempCU->getLumaIntraDir( uiTempPartIdx ) );
     2071    if( DMM1_IDX == dimType || DMM2_IDX == dimType || DMM3_IDX == dimType )
     2072    {
     2073      // get offset between current and reference block
     2074      UInt uiOffsetX = 0, uiOffsetY = 0;
     2075      xGetBlockOffset( pcCU, uiAbsPartIdx, pcTempCU, uiTempPartIdx, uiOffsetX, uiOffsetY );
     2076
     2077      // get reference wedgelet
     2078      WedgeList* pacWedgeList = &g_dmmWedgeLists[(g_aucConvertToBit[(pcTempCU->getWidth( uiTempPartIdx )>>((pcTempCU->getPartitionSize( uiTempPartIdx ) == SIZE_NxN) ? 1 : 0))])];
     2079      TComWedgelet* pcRefWedgelet = &(pacWedgeList->at( pcTempCU->getDmmWedgeTabIdx( dimType, uiTempPartIdx ) ) );
     2080
     2081      // find wedgelet, if direction is suitable for continue wedge
     2082      if( pcRefWedgelet->checkPredDirLeftPossible( uiThisBlockSize, uiOffsetY ) )
     2083      {
     2084        UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
     2085        pcRefWedgelet->getPredDirStartEndLeft( uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, uiThisBlockSize, uiOffsetY, iDeltaEnd );
     2086        return xGetWedgePatternIdx( uiThisBlockSize, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
     2087      }
     2088    }
     2089  }
     2090
     2091  // 3rd: (default) make wedglet from intra dir and max slope point
     2092  Int iSlopeX = 0, iSlopeY = 0;
     2093  UInt uiStartPosX = 0, uiStartPosY = 0;
     2094  if( xGetWedgeIntraDirPredData( pcCU, uiAbsPartIdx, uiThisBlockSize, iSlopeX, iSlopeY, uiStartPosX, uiStartPosY ) )
     2095  {
     2096    UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
     2097    xGetWedgeIntraDirStartEnd( pcCU, uiAbsPartIdx, uiThisBlockSize, iSlopeX, iSlopeY, uiStartPosX, uiStartPosY, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, iDeltaEnd );
     2098    return xGetWedgePatternIdx( uiThisBlockSize, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
     2099  }
     2100
     2101  return 0;
     2102}
     2103
     2104UInt TComPrediction::xPredWedgeFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt intraTabIdx )
     2105{
     2106  TComPic*      pcPicTex = pcCU->getSlice()->getPicLists()->getPic( pcCU->getSlice()->getViewIndex(), false, pcCU->getSlice()->getPOC() );
     2107  assert( pcPicTex != NULL );
     2108  TComDataCU*   pcColTexCU = pcPicTex->getCU(pcCU->getAddr());
     2109  UInt          uiTexPartIdx = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
     2110  Int           uiColTexIntraDir = pcColTexCU->isIntra( uiTexPartIdx ) ? pcColTexCU->getLumaIntraDir( uiTexPartIdx ) : 255;
     2111
     2112  if( uiColTexIntraDir > DC_IDX && uiColTexIntraDir < 35 ) { return g_aauiWdgLstM3[g_aucConvertToBit[uiWidth]][uiColTexIntraDir-2].at(intraTabIdx); }
     2113  else                                                     { return g_dmmWedgeNodeLists[(g_aucConvertToBit[uiWidth])].at(intraTabIdx).getPatternIdx(); }
     2114}
     2115
     2116Void TComPrediction::xPredContourFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, TComWedgelet* pcContourWedge )
     2117{
     2118  pcContourWedge->clear();
     2119
     2120  // get copy of co-located texture luma block
     2121  TComYuv cTempYuv;
     2122  cTempYuv.create( uiWidth, uiHeight );
     2123  cTempYuv.clear();
     2124  Pel* piRefBlkY = cTempYuv.getLumaAddr();
     2125  xCopyTextureLumaBlock( pcCU, uiAbsPartIdx, piRefBlkY, uiWidth, uiHeight );
     2126  piRefBlkY = cTempYuv.getLumaAddr();
     2127
     2128  // find contour for texture luma block
     2129  UInt iDC = 0;
     2130  for( UInt k = 0; k < (uiWidth*uiHeight); k++ )
     2131  {
     2132    iDC += piRefBlkY[k];
     2133  }
     2134  iDC /= (uiWidth*uiHeight);
     2135  piRefBlkY = cTempYuv.getLumaAddr();
     2136
     2137  Bool* pabContourPattern = pcContourWedge->getPattern();
     2138  for( UInt k = 0; k < (uiWidth*uiHeight); k++ )
     2139  {
     2140    pabContourPattern[k] = (piRefBlkY[k] > iDC) ? true : false;
     2141  }
     2142
     2143  cTempYuv.destroy();
     2144}
     2145
     2146
     2147Void TComPrediction::xCopyTextureLumaBlock( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piDestBlockY, UInt uiWidth, UInt uiHeight )
     2148{
     2149  TComPicYuv* pcPicYuvRef = pcCU->getSlice()->getPicLists()->getPic( pcCU->getSlice()->getViewIndex(), false, pcCU->getSlice()->getPOC() )->getPicYuvRec();
     2150  assert( pcPicYuvRef != NULL );
     2151  Int         iRefStride = pcPicYuvRef->getStride();
     2152  Pel*        piRefY = pcPicYuvRef->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiAbsPartIdx );
     2153
     2154  for ( Int y = 0; y < uiHeight; y++ )
     2155  {
     2156    ::memcpy(piDestBlockY, piRefY, sizeof(Pel)*uiWidth);
     2157    piDestBlockY += uiWidth;
     2158    piRefY += iRefStride;
     2159  }
     2160}
     2161
     2162Void TComPrediction::xGetBlockOffset( TComDataCU* pcCU, UInt uiAbsPartIdx, TComDataCU* pcRefCU, UInt uiRefAbsPartIdx, UInt& ruiOffsetX, UInt& ruiOffsetY )
     2163{
     2164  ruiOffsetX = 0;
     2165  ruiOffsetY = 0;
     2166
     2167  // get offset between current and above/left block
     2168  UInt uiThisOriginX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
     2169  UInt uiThisOriginY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
     2170
     2171  UInt uiNumPartInRefCU = pcRefCU->getTotalNumPart();
     2172  UInt uiMaxDepthRefCU = 0;
     2173  while( uiNumPartInRefCU > 1 )
     2174  {
     2175    uiNumPartInRefCU >>= 2;
     2176    uiMaxDepthRefCU++;
     2177  }
     2178
     2179  UInt uiDepthRefPU = (pcRefCU->getDepth(uiRefAbsPartIdx)) + (pcRefCU->getPartitionSize(uiRefAbsPartIdx) == SIZE_2Nx2N ? 0 : 1);
     2180  UInt uiShifts = (uiMaxDepthRefCU - uiDepthRefPU)*2;
     2181  UInt uiRefBlockOriginPartIdx = (uiRefAbsPartIdx>>uiShifts)<<uiShifts;
     2182
     2183  UInt uiRefOriginX = pcRefCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiRefBlockOriginPartIdx] ];
     2184  UInt uiRefOriginY = pcRefCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiRefBlockOriginPartIdx] ];
     2185
     2186  if( (uiThisOriginX - uiRefOriginX) > 0 ) { ruiOffsetX = (UInt)(uiThisOriginX - uiRefOriginX); }
     2187  if( (uiThisOriginY - uiRefOriginY) > 0 ) { ruiOffsetY = (UInt)(uiThisOriginY - uiRefOriginY); }
     2188}
     2189
     2190Bool TComPrediction::xGetWedgeIntraDirPredData( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int& riSlopeX, Int& riSlopeY, UInt& ruiStartPosX, UInt& ruiStartPosY )
     2191{
     2192  riSlopeX = 0, riSlopeY = 0, ruiStartPosX = 0, ruiStartPosY = 0;
     2193
     2194  // 1st step: get wedge start point (max. slope)
     2195  Int* piSource = pcCU->getPattern()->getAdiOrgBuf( uiBlockSize, uiBlockSize, m_piYuvExt );
     2196  Int iSourceStride = ( uiBlockSize<<1 ) + 1;
     2197
     2198  UInt uiSlopeMaxAbove = 0, uiPosSlopeMaxAbove = 0;
     2199  for( UInt uiPosHor = 0; uiPosHor < (uiBlockSize-1); uiPosHor++ )
     2200  {
     2201    if( abs( piSource[uiPosHor+1] - piSource[uiPosHor] ) > uiSlopeMaxAbove )
     2202    {
     2203      uiSlopeMaxAbove = abs( piSource[uiPosHor+1] - piSource[uiPosHor] );
     2204      uiPosSlopeMaxAbove = uiPosHor;
     2205    }
     2206  }
     2207
     2208  UInt uiSlopeMaxLeft = 0, uiPosSlopeMaxLeft = 0;
     2209  for( UInt uiPosVer = 0; uiPosVer < (uiBlockSize-1); uiPosVer++ )
     2210  {
     2211    if( abs( piSource[(uiPosVer+1)*iSourceStride] - piSource[uiPosVer*iSourceStride] ) > uiSlopeMaxLeft )
     2212    {
     2213      uiSlopeMaxLeft = abs( piSource[(uiPosVer+1)*iSourceStride] - piSource[uiPosVer*iSourceStride] );
     2214      uiPosSlopeMaxLeft = uiPosVer;
     2215    }
     2216  }
     2217
     2218  if( uiSlopeMaxAbove == 0 && uiSlopeMaxLeft == 0 )
     2219  {
     2220    return false;
     2221  }
     2222
     2223  ruiStartPosX = ( uiSlopeMaxAbove >  uiSlopeMaxLeft  ) ? uiPosSlopeMaxAbove : 0;
     2224  ruiStartPosY = ( uiSlopeMaxLeft  >= uiSlopeMaxAbove ) ? uiPosSlopeMaxLeft  : 0;
     2225
     2226  // 2nd step: derive wedge direction
     2227  Int uiPreds[3] = {-1, -1, -1};
     2228  Int iMode = -1;
     2229  Int iPredNum = pcCU->getIntraDirLumaPredictor( uiAbsPartIdx, uiPreds, &iMode ); 
     2230
     2231  UInt uiDirMode = 0;
     2232  if( iMode >= 0 ) { iPredNum = iMode; }
     2233  if( iPredNum == 1 ) { uiDirMode = uiPreds[0]; }
     2234  if( iPredNum == 2 ) { uiDirMode = uiPreds[1]; }
     2235
     2236  if( uiDirMode < 2 ) { return false; } // no planar & DC
     2237
     2238  Bool modeHor       = (uiDirMode < 18);
     2239  Bool modeVer       = !modeHor;
     2240  Int intraPredAngle = modeVer ? (Int)uiDirMode - VER_IDX : modeHor ? -((Int)uiDirMode - HOR_IDX) : 0;
     2241  Int absAng         = abs(intraPredAngle);
     2242  Int signAng        = intraPredAngle < 0 ? -1 : 1;
     2243  Int angTable[9]    = {0,2,5,9,13,17,21,26,32};
     2244  absAng             = angTable[absAng];
     2245  intraPredAngle     = signAng * absAng;
     2246
     2247  // 3rd step: set slope for direction
     2248  if( modeHor )
     2249  {
     2250    riSlopeX = ( intraPredAngle > 0 ) ?            -32 :              32;
     2251    riSlopeY = ( intraPredAngle > 0 ) ? intraPredAngle : -intraPredAngle;
     2252  }
     2253  else if( modeVer )
     2254  {
     2255    riSlopeX = ( intraPredAngle > 0 ) ? intraPredAngle : -intraPredAngle;
     2256    riSlopeY = ( intraPredAngle > 0 ) ?            -32 :              32;
     2257  }
     2258
     2259  return true;
     2260}
     2261
     2262Void TComPrediction::xGetWedgeIntraDirStartEnd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int iDeltaX, Int iDeltaY, UInt uiPMSPosX, UInt uiPMSPosY, UChar& ruhXs, UChar& ruhYs, UChar& ruhXe, UChar& ruhYe, Int iDeltaEnd )
     2263{
     2264  ruhXs = 0;
     2265  ruhYs = 0;
     2266  ruhXe = 0;
     2267  ruhYe = 0;
     2268
     2269  // scaling of start pos and block size to wedge resolution
     2270  UInt uiScaledStartPosX = 0;
     2271  UInt uiScaledStartPosY = 0;
     2272  UInt uiScaledBlockSize = 0;
     2273  WedgeResolution eWedgeRes = g_dmmWedgeResolution[(UInt)g_aucConvertToBit[uiBlockSize]];
     2274  switch( eWedgeRes )
     2275  {
     2276  case( DOUBLE_PEL ): { uiScaledStartPosX = (uiPMSPosX>>1); uiScaledStartPosY = (uiPMSPosY>>1); uiScaledBlockSize = (uiBlockSize>>1); break; }
     2277  case(   FULL_PEL ): { uiScaledStartPosX =  uiPMSPosX;     uiScaledStartPosY =  uiPMSPosY;     uiScaledBlockSize =  uiBlockSize;     break; }
     2278  case(   HALF_PEL ): { uiScaledStartPosX = (uiPMSPosX<<1); uiScaledStartPosY = (uiPMSPosY<<1); uiScaledBlockSize = (uiBlockSize<<1); break; }
     2279  }
     2280  Int iMaxPos = (Int)uiScaledBlockSize - 1;
     2281
     2282  // case above
     2283  if( uiScaledStartPosX > 0 && uiScaledStartPosY == 0 )
     2284  {
     2285    ruhXs = (UChar)uiScaledStartPosX;
     2286    ruhYs = 0;
     2287
     2288    if( iDeltaY == 0 )
     2289    {
     2290      if( iDeltaX < 0 )
     2291      {
     2292        ruhXe = 0;
     2293        ruhYe = (UChar)std::min( std::max( iDeltaEnd, 0 ), iMaxPos );
     2294        return;
     2295      }
     2296      else
     2297      {
     2298        ruhXe = (UChar)iMaxPos;
     2299        ruhYe = (UChar)std::min( std::max( -iDeltaEnd, 0 ), iMaxPos );
     2300        std::swap( ruhXs, ruhXe );
     2301        std::swap( ruhYs, ruhYe );
     2302        return;
     2303      }
     2304    }
     2305
     2306    // regular case
     2307    Int iVirtualEndX = (Int)ruhXs + roftoi( (Double)iMaxPos * ((Double)iDeltaX / (Double)iDeltaY) );
     2308
     2309    if( iVirtualEndX < 0 )
     2310    {
     2311      Int iYe = roftoi( (Double)(0 - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) + iDeltaEnd;
     2312      if( iYe < (Int)uiScaledBlockSize )
     2313      {
     2314        ruhXe = 0;
     2315        ruhYe = (UChar)std::max( iYe, 0 );
     2316        return;
     2317      }
     2318      else
     2319      {
     2320        ruhXe = (UChar)std::min( (iYe - iMaxPos), iMaxPos );
     2321        ruhYe = (UChar)iMaxPos;
     2322        return;
     2323      }
     2324    }
     2325    else if( iVirtualEndX > iMaxPos )
     2326    {
     2327      Int iYe = roftoi( (Double)(iMaxPos - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) - iDeltaEnd;
     2328      if( iYe < (Int)uiScaledBlockSize )
     2329      {
     2330        ruhXe = (UChar)iMaxPos;
     2331        ruhYe = (UChar)std::max( iYe, 0 );
     2332        std::swap( ruhXs, ruhXe );
     2333        std::swap( ruhYs, ruhYe );
     2334        return;
     2335      }
     2336      else
     2337      {
     2338        ruhXe = (UChar)std::max( (iMaxPos - (iYe - iMaxPos)), 0 );
     2339        ruhYe = (UChar)iMaxPos;
     2340        return;
     2341      }
     2342    }
     2343    else
     2344    {
     2345      Int iXe = iVirtualEndX + iDeltaEnd;
     2346      if( iXe < 0 )
     2347      {
     2348        ruhXe = 0;
     2349        ruhYe = (UChar)std::max( (iMaxPos + iXe), 0 );
     2350        return;
     2351      }
     2352      else if( iXe > iMaxPos )
     2353      {
     2354        ruhXe = (UChar)iMaxPos;
     2355        ruhYe = (UChar)std::max( (iMaxPos - (iXe - iMaxPos)), 0 );
     2356        std::swap( ruhXs, ruhXe );
     2357        std::swap( ruhYs, ruhYe );
     2358        return;
     2359      }
     2360      else
     2361      {
     2362        ruhXe = (UChar)iXe;
     2363        ruhYe = (UChar)iMaxPos;
     2364        return;
     2365      }
     2366    }
     2367  }
     2368
     2369  // case left
     2370  if( uiScaledStartPosY > 0 && uiScaledStartPosX == 0 )
     2371  {
     2372    ruhXs = 0;
     2373    ruhYs = (UChar)uiScaledStartPosY;
     2374
     2375    if( iDeltaX == 0 )
     2376    {
     2377      if( iDeltaY < 0 )
     2378      {
     2379        ruhXe = (UChar)std::min( std::max( -iDeltaEnd, 0 ), iMaxPos );
     2380        ruhYe = 0;
     2381        std::swap( ruhXs, ruhXe );
     2382        std::swap( ruhYs, ruhYe );
     2383        return;
     2384      }
     2385      else
     2386      {
     2387        ruhXe = (UChar)std::min( std::max( iDeltaEnd, 0 ), iMaxPos );
     2388        ruhYe = (UChar)iMaxPos;
     2389        return;
     2390      }
     2391    }
     2392
     2393    // regular case
     2394    Int iVirtualEndY = (Int)ruhYs + roftoi( (Double)iMaxPos * ((Double)iDeltaY / (Double)iDeltaX) );
     2395
     2396    if( iVirtualEndY < 0 )
     2397    {
     2398      Int iXe = roftoi( (Double)(0 - (Int)ruhYs ) * ((Double)iDeltaX / (Double)iDeltaY) ) - iDeltaEnd;
     2399      if( iXe < (Int)uiScaledBlockSize )
     2400      {
     2401        ruhXe = (UChar)std::max( iXe, 0 );
     2402        ruhYe = 0;
     2403        std::swap( ruhXs, ruhXe );
     2404        std::swap( ruhYs, ruhYe );
     2405        return;
     2406      }
     2407      else
     2408      {
     2409        ruhXe = (UChar)iMaxPos;
     2410        ruhYe = (UChar)std::min( (iXe - iMaxPos), iMaxPos );
     2411        std::swap( ruhXs, ruhXe );
     2412        std::swap( ruhYs, ruhYe );
     2413        return;
     2414      }
     2415    }
     2416    else if( iVirtualEndY > (uiScaledBlockSize-1) )
     2417    {
     2418      Int iXe = roftoi( (Double)((Int)(uiScaledBlockSize-1) - (Int)ruhYs ) * ((Double)iDeltaX / (Double)iDeltaY) ) + iDeltaEnd;
     2419      if( iXe < (Int)uiScaledBlockSize )
     2420      {
     2421        ruhXe = (UChar)std::max( iXe, 0 );
     2422        ruhYe = (UChar)(uiScaledBlockSize-1);
     2423        return;
     2424      }
     2425      else
     2426      {
     2427        ruhXe = (UChar)iMaxPos;
     2428        ruhYe = (UChar)std::max( (iMaxPos - (iXe - iMaxPos)), 0 );
     2429        std::swap( ruhXs, ruhXe );
     2430        std::swap( ruhYs, ruhYe );
     2431        return;
     2432      }
     2433    }
     2434    else
     2435    {
     2436      Int iYe = iVirtualEndY - iDeltaEnd;
     2437      if( iYe < 0 )
     2438      {
     2439        ruhXe = (UChar)std::max( (iMaxPos + iYe), 0 );
     2440        ruhYe = 0;
     2441        std::swap( ruhXs, ruhXe );
     2442        std::swap( ruhYs, ruhYe );
     2443        return;
     2444      }
     2445      else if( iYe > iMaxPos )
     2446      {
     2447        ruhXe = (UChar)std::max( (iMaxPos - (iYe - iMaxPos)), 0 );
     2448        ruhYe = (UChar)iMaxPos;
     2449        return;
     2450      }
     2451      else
     2452      {
     2453        ruhXe = (UChar)iMaxPos;
     2454        ruhYe = (UChar)iYe;
     2455        std::swap( ruhXs, ruhXe );
     2456        std::swap( ruhYs, ruhYe );
     2457        return;
     2458      }
     2459    }
     2460  }
     2461
     2462  // case origin
     2463  if( uiScaledStartPosX == 0 && uiScaledStartPosY == 0 )
     2464  {
     2465    if( iDeltaX*iDeltaY < 0 )
     2466    {
     2467      return;
     2468    }
     2469
     2470    ruhXs = 0;
     2471    ruhYs = 0;
     2472
     2473    if( iDeltaY == 0 )
     2474    {
     2475      ruhXe = (UChar)iMaxPos;
     2476      ruhYe = 0;
     2477      std::swap( ruhXs, ruhXe );
     2478      std::swap( ruhYs, ruhYe );
     2479      return;
     2480    }
     2481
     2482    if( iDeltaX == 0 )
     2483    {
     2484      ruhXe = 0;
     2485      ruhYe = (UChar)iMaxPos;
     2486      return;
     2487    }
     2488
     2489    Int iVirtualEndX = (Int)ruhXs + roftoi( (Double)iMaxPos * ((Double)iDeltaX / (Double)iDeltaY) );
     2490
     2491    if( iVirtualEndX > iMaxPos )
     2492    {
     2493      Int iYe = roftoi( (Double)((Int)iMaxPos - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) - iDeltaEnd;
     2494      if( iYe < (Int)uiScaledBlockSize )
     2495      {
     2496        ruhXe = (UChar)(uiScaledBlockSize-1);
     2497        ruhYe = (UChar)std::max( iYe, 0 );
     2498        std::swap( ruhXs, ruhXe );
     2499        std::swap( ruhYs, ruhYe );
     2500        return;
     2501      }
     2502      else
     2503      {
     2504        ruhXe = (UChar)std::max( (iMaxPos - (iYe - iMaxPos)), 0 );
     2505        ruhYe = (UChar)(uiScaledBlockSize-1);
     2506        return;
     2507      }
     2508    }
     2509    else
     2510    {
     2511      Int iXe = iVirtualEndX + iDeltaEnd;
     2512      if( iXe < 0 )
     2513      {
     2514        ruhXe = 0;
     2515        ruhYe = (UChar)std::max( (iMaxPos + iXe), 0 );
     2516        return;
     2517      }
     2518      else if( iXe > iMaxPos )
     2519      {
     2520        ruhXe = (UChar)(uiScaledBlockSize-1);
     2521        ruhYe = (UChar)std::max( (iMaxPos - (iXe - iMaxPos)), 0 );
     2522        std::swap( ruhXs, ruhXe );
     2523        std::swap( ruhYs, ruhYe );
     2524        return;
     2525      }
     2526      else
     2527      {
     2528        ruhXe = (UChar)iXe;
     2529        ruhYe = (UChar)(uiScaledBlockSize-1);
     2530        return;
     2531      }
     2532    }
     2533  }
     2534}
     2535
     2536UInt TComPrediction::xGetWedgePatternIdx( UInt uiBlockSize, UChar uhXs, UChar uhYs, UChar uhXe, UChar uhYe )
     2537{
     2538  WedgeRefList* pcWedgeRefList = &g_dmmWedgeRefLists[(g_aucConvertToBit[uiBlockSize])];
     2539  for( UInt uiIdx = 0; uiIdx < pcWedgeRefList->size(); uiIdx++ )
     2540  {
     2541    TComWedgeRef* pcTestWedgeRef = &(pcWedgeRefList->at(uiIdx));
     2542    if( pcTestWedgeRef->getStartX() == uhXs && pcTestWedgeRef->getStartY() == uhYs && pcTestWedgeRef->getEndX() == uhXe && pcTestWedgeRef->getEndY() == uhYe )
     2543    {
     2544      return pcTestWedgeRef->getRefIdx();
     2545    }
     2546  }
     2547  return 0;
     2548}
     2549#endif
     2550#if H_3D_DIM_RBC
     2551Void TComPrediction::xDeltaDCQuantScaleUp( TComDataCU* pcCU, Pel& rDeltaDC )
     2552{
     2553  Int  iSign  = rDeltaDC < 0 ? -1 : 1;
     2554  UInt uiAbs  = abs( rDeltaDC );
     2555
     2556  Int iQp = pcCU->getQP(0);
     2557  Double dMax = (Double)( 1<<( g_bitDepthY - 1 ) );
     2558  Double dStepSize = Clip3( 1.0, dMax, pow( 2.0, iQp/10.0 - 2.0 ) );
     2559
     2560  rDeltaDC = iSign * roftoi( uiAbs * dStepSize );
     2561  return;
     2562}
     2563
     2564Void TComPrediction::xDeltaDCQuantScaleDown( TComDataCU*  pcCU, Pel& rDeltaDC )
     2565{
     2566  Int  iSign  = rDeltaDC < 0 ? -1 : 1;
     2567  UInt uiAbs  = abs( rDeltaDC );
     2568
     2569  Int iQp = pcCU->getQP(0);
     2570  Double dMax = (Double)( 1<<( g_bitDepthY - 1 ) );
     2571  Double dStepSize = Clip3( 1.0, dMax, pow( 2.0, iQp/10.0 - 2.0 ) );
     2572
     2573  rDeltaDC = iSign * roftoi( uiAbs / dStepSize );
     2574  return;
     2575}
     2576#endif
     2577#if H_3D_DIM_SDC
     2578Void TComPrediction::analyzeSegmentsSDC( Pel* pOrig, UInt uiStride, UInt uiSize, Pel* rpSegMeans, UInt uiNumSegments, Bool* pMask, UInt uiMaskStride )
     2579{
     2580  Int iSumDepth[2];
     2581  memset(iSumDepth, 0, sizeof(Int)*2);
     2582  Int iSumPix[2];
     2583  memset(iSumPix, 0, sizeof(Int)*2);
     2584 
     2585  Int subSamplePix;
     2586  if ( uiSize == 64 || uiSize == 32 )
     2587  {
     2588    subSamplePix = 2;
     2589  }
     2590  else
     2591  {
     2592    subSamplePix = 1;
     2593  }
     2594  for (Int y=0; y<uiSize; y+=subSamplePix)
     2595  {
     2596    for (Int x=0; x<uiSize; x+=subSamplePix)
     2597    {
     2598      UChar ucSegment = pMask?(UChar)pMask[x]:0;
     2599      assert( ucSegment < uiNumSegments );
     2600     
     2601      iSumDepth[ucSegment] += pOrig[x];
     2602      iSumPix[ucSegment]   += 1;
     2603    }
     2604   
     2605    pOrig  += uiStride*subSamplePix;
     2606    pMask  += uiMaskStride*subSamplePix;
     2607  }
     2608 
     2609  // compute mean for each segment
     2610  for( UChar ucSeg = 0; ucSeg < uiNumSegments; ucSeg++ )
     2611  {
     2612    if( iSumPix[ucSeg] > 0 )
     2613      rpSegMeans[ucSeg] = iSumDepth[ucSeg] / iSumPix[ucSeg];
     2614    else
     2615      rpSegMeans[ucSeg] = 0;  // this happens for zero-segments
     2616  }
     2617}
     2618#endif // H_3D_DIM_SDC
     2619#endif
    18582620//! \}
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComPrediction.h

    r530 r531  
    132132  Bool xCheckIdenticalMotion    ( TComDataCU* pcCU, UInt PartAddr);
    133133
     134#if H_3D_DIM
     135  // depth intra functions
     136  Void xPredBiSegDCs            ( Int* ptrSrc, UInt srcStride, Bool* biSegPattern, Int patternStride, Pel& predDC1, Pel& predDC2 );
     137  Void xAssignBiSegDCs          ( Pel* ptrDst, UInt dstStride, Bool* biSegPattern, Int patternStride, Pel   valDC1, Pel   valDC2 );
     138#if H_3D_DIM_DMM
     139  UInt xPredWedgeFromIntra      ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Int iDeltaEnd = 0 );
     140  UInt xPredWedgeFromTex        ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt intraTabIdx );
     141  Void xPredContourFromTex      ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, TComWedgelet* pcContourWedge );
     142
     143  Void xCopyTextureLumaBlock    ( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piDestBlockY, UInt uiWidth, UInt uiHeight );
     144
     145  Void xGetBlockOffset          ( TComDataCU* pcCU, UInt uiAbsPartIdx, TComDataCU* pcRefCU, UInt uiRefAbsPartIdx, UInt& ruiOffsetX, UInt& ruiOffsetY );
     146  Bool xGetWedgeIntraDirPredData( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int& riSlopeX, Int& riSlopeY, UInt& ruiStartPosX, UInt& ruiStartPosY );
     147  Void xGetWedgeIntraDirStartEnd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int iDeltaX, Int iDeltaY, UInt uiPMSPosX, UInt uiPMSPosY, UChar& ruhXs, UChar& ruhYs, UChar& ruhXe, UChar& ruhYe, Int iDeltaEnd = 0 );
     148  UInt xGetWedgePatternIdx      ( UInt uiBlockSize, UChar uhXs, UChar uhYs, UChar uhXe, UChar uhYe );
     149#endif
     150#if H_3D_DIM_RBC
     151  Void xDeltaDCQuantScaleUp     ( TComDataCU* pcCU, Pel& rDeltaDC );
     152  Void xDeltaDCQuantScaleDown   ( TComDataCU* pcCU, Pel& rDeltaDC );
     153#endif
     154#endif
     155
    134156public:
    135157  TComPrediction();
     
    148170  Void predIntraChromaAng         ( Int* piSrc, UInt uiDirMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft );
    149171 
     172#if H_3D_DIM
     173  // Depth intra
     174  Void predIntraLumaDepth         ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiIntraMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bFastEnc = false );
     175#if H_3D_DIM_SDC
     176  Void analyzeSegmentsSDC         ( Pel* pOrig, UInt uiStride, UInt uiSize, Pel* rpSegMeans, UInt uiNumSegments, Bool* pMask, UInt uiMaskStride );
     177#endif
     178#endif
     179
    150180  Pel  predIntraGetPredValDC      ( Int* pSrc, Int iSrcStride, UInt iWidth, UInt iHeight, Bool bAbove, Bool bLeft );
    151181 
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComRdCost.cpp

    r504 r531  
    505505  cDtParam.bUseIC       = false;
    506506#endif
    507 
    508507#if WEIGHTED_CHROMA_DISTORTION
    509508  if (eText == TEXT_CHROMA_U)
     
    603602    return xGetSADw( pcDtParam );
    604603  }
    605 
    606604#if H_3D_IC
    607605  if( pcDtParam->bUseIC )
     
    610608  }
    611609#endif
    612 
    613610  Pel* piOrg   = pcDtParam->pOrg;
    614611  Pel* piCur   = pcDtParam->pCur;
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComRom.cpp

    r521 r531  
    8282    delete[] g_auiSigLastScan[2][i];
    8383  }
     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  }
     102#endif
    84103}
    85104
     
    312331
    313332// ====================================================================================================================
     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 };
     349const UChar g_dmm3IntraTabIdxBits[6] =
     350{ //2x2   4x4   8x8 16x16 32x32 64x64
     351     0,    6,    9,    9,    9,    0 };
     352
     353extern std::vector< std::vector<TComWedgelet> >   g_dmmWedgeLists;
     354extern std::vector< std::vector<TComWedgeRef> >   g_dmmWedgeRefLists;
     355extern std::vector< std::vector<TComWedgeNode> >  g_dmmWedgeNodeLists;
     356#endif
     357
     358// ====================================================================================================================
    314359// Misc.
    315360// ====================================================================================================================
     
    554599#endif
    555600#endif
     601#if H_3D_DIM_DMM
     602std::vector< std::vector<TComWedgelet>  > g_dmmWedgeLists;
     603std::vector< std::vector<TComWedgeRef>  > g_dmmWedgeRefLists;
     604std::vector< std::vector<TComWedgeNode> > g_dmmWedgeNodeLists;
     605std::vector< std::vector< std::vector<UInt> > > g_aauiWdgLstM3;
     606
     607Void initWedgeLists( Bool initRefinements )
     608{
     609  if( !g_dmmWedgeLists.empty() ) return;
     610
     611  for( UInt ui = g_aucConvertToBit[DIM_MIN_SIZE]; ui < (g_aucConvertToBit[DIM_MAX_SIZE]+1); ui++ )
     612  {
     613    UInt uiWedgeBlockSize = ((UInt)DIM_MIN_SIZE)<<ui;
     614    std::vector<TComWedgelet> acWedgeList;
     615    std::vector<TComWedgeRef> acWedgeRefList;
     616    createWedgeList( uiWedgeBlockSize, uiWedgeBlockSize, acWedgeList, acWedgeRefList, g_dmmWedgeResolution[ui] );
     617    g_dmmWedgeLists.push_back( acWedgeList );
     618    g_dmmWedgeRefLists.push_back( acWedgeRefList );
     619
     620    // create WedgeNodeList
     621    std::vector<TComWedgeNode> acWedgeNodeList;
     622    for( UInt uiPos = 0; uiPos < acWedgeList.size(); uiPos++ )
     623    {
     624      if( acWedgeList[uiPos].getIsCoarse() )
     625      {
     626        TComWedgeNode cWedgeNode;
     627        cWedgeNode.setPatternIdx( uiPos );
     628
     629        if( initRefinements )
     630        {
     631          UInt uiRefPos = 0;
     632          for( Int iOffS = -1; iOffS <= 1; iOffS++ )
     633          {
     634            for( Int iOffE = -1; iOffE <= 1; iOffE++ )
     635            {
     636              if( iOffS == 0 && iOffE == 0 ) { continue; }
     637
     638              Int iSx = (Int)acWedgeList[uiPos].getStartX();
     639              Int iSy = (Int)acWedgeList[uiPos].getStartY();
     640              Int iEx = (Int)acWedgeList[uiPos].getEndX();
     641              Int iEy = (Int)acWedgeList[uiPos].getEndY();
     642
     643              switch( acWedgeList[uiPos].getOri() )
     644              {
     645              case( 0 ): { iSx += iOffS; iEy += iOffE; } break;
     646              case( 1 ): { iSy += iOffS; iEx -= iOffE; } break;
     647              case( 2 ): { iSx -= iOffS; iEy -= iOffE; } break;
     648              case( 3 ): { iSy -= iOffS; iEx += iOffE; } break;
     649              case( 4 ): { iSx += iOffS; iEx += iOffE; } break;
     650              case( 5 ): { iSy += iOffS; iEy += iOffE; } break;
     651              default: assert( 0 );
     652              }
     653
     654              for( UInt k = 0; k < acWedgeRefList.size(); k++ )
     655              {
     656                if( iSx == (Int)acWedgeRefList[k].getStartX() &&
     657                    iSy == (Int)acWedgeRefList[k].getStartY() &&
     658                    iEx == (Int)acWedgeRefList[k].getEndX()   &&
     659                    iEy == (Int)acWedgeRefList[k].getEndY()      )
     660                {
     661                  if( acWedgeRefList[k].getRefIdx() != cWedgeNode.getPatternIdx() )
     662                  {
     663                    Bool bNew = true;
     664                    for( UInt m = 0; m < uiRefPos; m++ ) { if( acWedgeRefList[k].getRefIdx() == cWedgeNode.getRefineIdx( m ) ) { bNew = false; break; } }
     665
     666                    if( bNew )
     667                    {
     668                      cWedgeNode.setRefineIdx( acWedgeRefList[k].getRefIdx(), uiRefPos );
     669                      uiRefPos++;
     670                      break;
     671                    }
     672                  }
     673                }
     674              }
     675            }
     676          }
     677        }
     678        acWedgeNodeList.push_back( cWedgeNode );
     679      }
     680    }
     681    g_dmmWedgeNodeLists.push_back( acWedgeNodeList );
     682  }
     683  return;
     684}
     685
     686Void createWedgeList( UInt uiWidth, UInt uiHeight, std::vector<TComWedgelet> &racWedgeList, std::vector<TComWedgeRef> &racWedgeRefList, WedgeResolution eWedgeRes )
     687{
     688  assert( uiWidth == uiHeight );
     689
     690  UChar    uhStartX = 0,    uhStartY = 0,    uhEndX = 0,    uhEndY = 0;
     691  Int   iStepStartX = 0, iStepStartY = 0, iStepEndX = 0, iStepEndY = 0;
     692
     693  UInt uiBlockSize = 0;
     694  switch( eWedgeRes )
     695  {
     696  case( DOUBLE_PEL ): { uiBlockSize = (uiWidth>>1); break; }
     697  case(   FULL_PEL ): { uiBlockSize =  uiWidth;     break; }
     698  case(   HALF_PEL ): { uiBlockSize = (uiWidth<<1); break; }
     699  }
     700
     701  TComWedgelet cTempWedgelet( uiWidth, uiHeight );
     702  for( UInt uiOri = 0; uiOri < 6; uiOri++ )
     703  {
     704    // init the edge line parameters for each of the 6 wedgelet types
     705    switch( uiOri )
     706    {
     707    case( 0 ): {  uhStartX = 0;               uhStartY = 0;               uhEndX = 0;               uhEndY = 0;               iStepStartX = +1; iStepStartY =  0; iStepEndX =  0; iStepEndY = +1; break; }
     708    case( 1 ): {  uhStartX = (uiBlockSize-1); uhStartY = 0;               uhEndX = (uiBlockSize-1); uhEndY = 0;               iStepStartX =  0; iStepStartY = +1; iStepEndX = -1; iStepEndY =  0; break; }
     709    case( 2 ): {  uhStartX = (uiBlockSize-1); uhStartY = (uiBlockSize-1); uhEndX = (uiBlockSize-1); uhEndY = (uiBlockSize-1); iStepStartX = -1; iStepStartY =  0; iStepEndX =  0; iStepEndY = -1; break; }
     710    case( 3 ): {  uhStartX = 0;               uhStartY = (uiBlockSize-1); uhEndX = 0;               uhEndY = (uiBlockSize-1); iStepStartX =  0; iStepStartY = -1; iStepEndX = +1; iStepEndY =  0; break; }
     711    case( 4 ): {  uhStartX = 0;               uhStartY = 0;               uhEndX = 0;               uhEndY = (uiBlockSize-1); iStepStartX = +1; iStepStartY =  0; iStepEndX = +1; iStepEndY =  0; break; }
     712    case( 5 ): {  uhStartX = (uiBlockSize-1); uhStartY = 0;               uhEndX = 0;               uhEndY = 0;               iStepStartX =  0; iStepStartY = +1; iStepEndX =  0; iStepEndY = +1; break; }
     713    }
     714
     715    for( Int iK = 0; iK < uiBlockSize; iK++ )
     716    {
     717      for( Int iL = 0; iL < uiBlockSize; iL++ )
     718      {
     719        cTempWedgelet.setWedgelet( uhStartX + (iK*iStepStartX) , uhStartY + (iK*iStepStartY), uhEndX + (iL*iStepEndX), uhEndY + (iL*iStepEndY), (UChar)uiOri, eWedgeRes, ((iL%2)==0 && (iK%2)==0) );
     720        addWedgeletToList( cTempWedgelet, racWedgeList, racWedgeRefList );
     721      }
     722    }
     723  }
     724
     725  UInt uiThrSz = DMM3_SIMPLIFY_TR;
     726  std::vector< std::vector<UInt> > auiWdgListSz;
     727  for( Int idxM=2; idxM<=34 ; idxM++)
     728  {
     729    std::vector<UInt> auiWdgList;
     730    for( Int idxW=0; idxW<racWedgeList.size(); idxW++)
     731    {
     732      UInt uiAbsDiff = abs(idxM-(Int)racWedgeList[idxW].getAng());
     733      if( uiAbsDiff <= uiThrSz )
     734      {
     735        auiWdgList.push_back(idxW);
     736      }
     737    }
     738    auiWdgListSz.push_back(auiWdgList);
     739  }
     740  g_aauiWdgLstM3.push_back(auiWdgListSz);
     741}
     742
     743Void addWedgeletToList( TComWedgelet cWedgelet, std::vector<TComWedgelet> &racWedgeList, std::vector<TComWedgeRef> &racWedgeRefList )
     744{
     745  Bool bValid = cWedgelet.checkNotPlain();
     746  if( bValid )
     747  {
     748    for( UInt uiPos = 0; uiPos < racWedgeList.size(); uiPos++ )
     749    {
     750      if( cWedgelet.checkIdentical( racWedgeList[uiPos].getPattern() ) )
     751      {
     752        TComWedgeRef cWedgeRef;
     753        cWedgeRef.setWedgeRef( cWedgelet.getStartX(), cWedgelet.getStartY(), cWedgelet.getEndX(), cWedgelet.getEndY(), uiPos );
     754        racWedgeRefList.push_back( cWedgeRef );
     755        bValid = false;
     756        return;
     757      }
     758    }
     759  }
     760  if( bValid )
     761  {
     762    for( UInt uiPos = 0; uiPos < racWedgeList.size(); uiPos++ )
     763    {
     764      if( cWedgelet.checkInvIdentical( racWedgeList[uiPos].getPattern() ) )
     765      {
     766        TComWedgeRef cWedgeRef;
     767        cWedgeRef.setWedgeRef( cWedgelet.getStartX(), cWedgelet.getStartY(), cWedgelet.getEndX(), cWedgelet.getEndY(), uiPos );
     768        racWedgeRefList.push_back( cWedgeRef );
     769        bValid = false;
     770        return;
     771      }
     772    }
     773  }
     774  if( bValid )
     775  {
     776    cWedgelet.findClosestAngle();
     777    racWedgeList.push_back( cWedgelet );
     778    TComWedgeRef cWedgeRef;
     779    cWedgeRef.setWedgeRef( cWedgelet.getStartX(), cWedgelet.getStartY(), cWedgelet.getEndX(), cWedgelet.getEndY(), (UInt)(racWedgeList.size()-1) );
     780    racWedgeRefList.push_back( cWedgeRef );
     781  }
     782}
     783#endif //H_3D_DIM_DMM
     784
    556785//! \}
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComRom.h

    r521 r531  
    4545#include<iostream>
    4646
     47#if H_3D_DIM
     48#include "TComWedgelet.h"
     49#endif
     50
    4751//! \ingroup TLibCommon
    4852//! \{
     
    148152
    149153extern const UChar g_aucConvertTxtTypeToIdx[4];
     154
     155#if H_3D_DIM
     156// ====================================================================================================================
     157// Depth coding modes
     158// ====================================================================================================================
     159__inline Void mapDepthModeToIntraDir( UInt& intraMode ) { if( isDimMode( intraMode ) ) intraMode = DC_IDX; }
     160__inline Void mapDepthModeToIntraDir(  Int& intraMode ) { if( isDimMode( intraMode ) ) intraMode = DC_IDX; }
     161
     162#if H_3D_DIM_SDC || H_3D_DIM_DLT
     163__inline UInt numBitsForValue( UInt value ) { UInt bits = 0; while (value != 0) { value >>= 1; bits++; } return bits; };
     164#endif
     165
     166#if H_3D_DIM_DMM
     167extern const WedgeResolution                                 g_dmmWedgeResolution [6];
     168extern const UChar                                           g_dmm1TabIdxBits     [6];
     169extern const UChar                                           g_dmm3IntraTabIdxBits[6];
     170
     171extern       std::vector< std::vector<TComWedgelet> >        g_dmmWedgeLists;
     172extern       std::vector< std::vector<TComWedgeRef> >        g_dmmWedgeRefLists;
     173extern       std::vector< std::vector<TComWedgeNode> >       g_dmmWedgeNodeLists;
     174extern       std::vector< std::vector< std::vector<UInt> > > g_aauiWdgLstM3;
     175
     176Void initWedgeLists( Bool initRefinements = false );
     177Void createWedgeList( UInt uiWidth, UInt uiHeight, std::vector<TComWedgelet> &racWedgeList, std::vector<TComWedgeRef> &racWedgeRefList, WedgeResolution eWedgeRes );
     178Void addWedgeletToList( TComWedgelet cWedgelet, std::vector<TComWedgelet> &racWedgeList, std::vector<TComWedgeRef> &racWedgeRefList );
     179#endif
     180#endif
    150181
    151182// ==========================================
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComSlice.cpp

    r521 r531  
    7373, m_pcPPS                         ( NULL )
    7474, m_pcPic                         ( NULL )
     75#if H_3D
     76, m_picLists                      ( NULL )
     77#endif
    7578, m_colFromL0Flag                 ( 1 )
    7679, m_colRefIdx                     ( 0 )
     
    970973
    971974  m_pcPic                = pSrc->m_pcPic;
    972 
     975#if H_3D
     976  m_picLists             = pSrc->m_picLists;
     977#endif
    973978  m_colFromL0Flag        = pSrc->m_colFromL0Flag;
    974979  m_colRefIdx            = pSrc->m_colRefIdx;
     
    15431548#if H_3D
    15441549    m_viewIndex         [i] = -1;
     1550    m_vpsDepthModesFlag [i] = false;
     1551#if H_3D_DIM_DLT
     1552    m_bUseDLTFlag         [i] = false;
     1553   
     1554    // allocate some memory and initialize with default mapping
     1555    m_iNumDepthmapValues[i] = ((1 << g_bitDepthY)-1)+1;
     1556    m_iBitsPerDepthValue[i] = numBitsForValue(m_iNumDepthmapValues[i]);
     1557   
     1558    m_iDepthValue2Idx[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
     1559    m_iIdx2DepthValue[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
     1560   
     1561    //default mapping
     1562    for (Int d=0; d<m_iNumDepthmapValues[i]; d++)
     1563    {
     1564      m_iDepthValue2Idx[i][d] = d;
     1565      m_iIdx2DepthValue[i][d] = d;
     1566    }
     1567#endif
    15451568#endif
    15461569
     
    15821605  if( m_cprmsPresentFlag != NULL )     delete[] m_cprmsPresentFlag;
    15831606}
     1607
     1608#if H_3D_DIM_DLT
     1609  Void TComVPS::setDepthLUTs(Int layerIdInVps, Int* idxToDepthValueTable, Int iNumDepthValues)
     1610  {
     1611    if( idxToDepthValueTable == NULL || iNumDepthValues == 0 ) // default mapping only
     1612      return;
     1613   
     1614    // copy idx2DepthValue to internal array
     1615    memcpy(m_iIdx2DepthValue[layerIdInVps], idxToDepthValueTable, iNumDepthValues*sizeof(UInt));
     1616   
     1617    UInt uiMaxDepthValue = ((1 << g_bitDepthY)-1);
     1618    for(Int p=0; p<=uiMaxDepthValue; p++)
     1619    {
     1620      Int iIdxDown    = 0;
     1621      Int iIdxUp      = iNumDepthValues-1;
     1622      Bool bFound     = false;
     1623     
     1624      // iterate over indices to find lower closest depth
     1625      Int i = 1;
     1626      while(!bFound && i<iNumDepthValues)
     1627      {
     1628        if( m_iIdx2DepthValue[layerIdInVps][i] > p )
     1629        {
     1630          iIdxDown  = i-1;
     1631          bFound    = true;
     1632        }
     1633       
     1634        i++;
     1635      }
     1636      // iterate over indices to find upper closest depth
     1637      i = iNumDepthValues-2;
     1638      bFound = false;
     1639      while(!bFound && i>=0)
     1640      {
     1641        if( m_iIdx2DepthValue[layerIdInVps][i] < p )
     1642        {
     1643          iIdxUp  = i+1;
     1644          bFound    = true;
     1645        }
     1646       
     1647        i--;
     1648      }
     1649     
     1650      // assert monotony
     1651      assert(iIdxDown<=iIdxUp);
     1652     
     1653      // assign closer depth value/idx
     1654      if( abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxDown]) < abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxUp]) )
     1655      {
     1656        m_iDepthValue2Idx[layerIdInVps][p] = iIdxDown;
     1657      }
     1658      else
     1659      {
     1660        m_iDepthValue2Idx[layerIdInVps][p] = iIdxUp;
     1661      }
     1662     
     1663    }
     1664   
     1665    // update DLT variables
     1666    m_iNumDepthmapValues[layerIdInVps] = iNumDepthValues;
     1667    m_iBitsPerDepthValue[layerIdInVps] = numBitsForValue(m_iNumDepthmapValues[layerIdInVps]);
     1668  }
     1669#endif
    15841670
    15851671#if H_MV
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComSlice.h

    r521 r531  
    537537  Bool        m_depthRefinementFlag      [ MAX_NUM_LAYERS ];
    538538#endif
     539  Bool        m_vpsDepthModesFlag        [MAX_NUM_LAYERS   ];
     540#if H_3D_DIM_DLT
     541  Bool        m_bUseDLTFlag              [MAX_NUM_LAYERS   ];
     542 
     543  Int         m_iBitsPerDepthValue       [MAX_NUM_LAYERS   ];
     544  Int         m_iNumDepthmapValues       [MAX_NUM_LAYERS   ];
     545  Int*        m_iDepthValue2Idx          [MAX_NUM_LAYERS   ];
     546  Int*        m_iIdx2DepthValue          [MAX_NUM_LAYERS   ];
     547#endif
     548
    539549#endif
    540550
     
    673683  Bool    getDepthRefinementFlag  ( Int layerIdInVps )            { return m_depthRefinementFlag[ layerIdInVps ]; };
    674684#endif
     685  Void    setVpsDepthModesFlag( Int layerIdInVps, Bool val )               { m_vpsDepthModesFlag[ layerIdInVps ] = val; }
     686  Bool    getVpsDepthModesFlag( Int layerIdInVps )                         { return m_vpsDepthModesFlag[ layerIdInVps ]; }
     687#if H_3D_DIM_DLT
     688  Bool    getUseDLTFlag      ( Int layerIdInVps )                         { return m_bUseDLTFlag[ layerIdInVps ]; }
     689  Void    setUseDLTFlag      ( Int layerIdInVps, Bool b ) { m_bUseDLTFlag[ layerIdInVps ]  = b;          }
     690 
     691  Int     getBitsPerDepthValue( Int layerIdInVps )        { return getUseDLTFlag(layerIdInVps)?m_iBitsPerDepthValue[layerIdInVps]:g_bitDepthY; }
     692  Int     getNumDepthValues( Int layerIdInVps )           { return getUseDLTFlag(layerIdInVps)?m_iNumDepthmapValues[layerIdInVps]:((1 << g_bitDepthY)-1); }
     693  Int     depthValue2idx( Int layerIdInVps, Pel value )   { return getUseDLTFlag(layerIdInVps)?m_iDepthValue2Idx[layerIdInVps][value]:value; }
     694  Pel     idx2DepthValue( Int layerIdInVps, UInt uiIdx )  { return getUseDLTFlag(layerIdInVps)?m_iIdx2DepthValue[layerIdInVps][uiIdx]:uiIdx; }
     695  Void    setDepthLUTs( Int layerIdInVps, Int* idx2DepthValue = NULL, Int iNumDepthValues = 0 );
     696#endif
     697
    675698#endif
    676699
     
    14551478  TComPPS*    m_pcPPS;
    14561479  TComPic*    m_pcPic;
     1480#if H_3D
     1481  TComPicLists* m_picLists;
     1482#endif
    14571483#if ADAPTIVE_QP_SELECTION
    14581484  TComTrQuant* m_pcTrQuant;
     
    15901616  Int       getNumRefIdx        ( RefPicList e )                { return  m_aiNumRefIdx[e];             }
    15911617  TComPic*  getPic              ()                              { return  m_pcPic;                      }
     1618#if H_3D
     1619  TComPicLists* getPicLists     ()                              { return m_picLists; }
     1620#endif
    15921621  TComPic*  getRefPic           ( RefPicList e, Int iRefIdx)    { return  m_apcRefPicList[e][iRefIdx];  }
    15931622  Int       getRefPOC           ( RefPicList e, Int iRefIdx)    { return  m_aiRefPOCList[e][iRefIdx];   }
     
    16641693  Void      setNumRefIdx        ( RefPicList e, Int i )         { m_aiNumRefIdx[e]    = i;      }
    16651694  Void      setPic              ( TComPic* p )                  { m_pcPic             = p;      }
     1695#if H_3D
     1696  Void      setPicLists         ( TComPicLists* p )             { m_picLists          = p;      }
     1697#endif
    16661698  Void      setDepth            ( Int iDepth )                  { m_iDepth            = iDepth; }
    16671699 
     
    18411873  Int* getDepthToDisparityB( Int refViewIdx ) { return m_depthToDisparityB[ refViewIdx ]; };
    18421874  Int* getDepthToDisparityF( Int refViewIdx ) { return m_depthToDisparityF[ refViewIdx ]; };
    1843  
     1875  Bool getVpsDepthModesFlag  ()  { return getVPS()->getVpsDepthModesFlag( getVPS()->getLayerIdInVps( m_layerId ) ); }
     1876
    18441877#endif
    18451878
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TypeDef.h

    r530 r531  
    133133#define H_3D_FIX                          1   // Temporary for minor fixes can be removed after merge
    134134#define H_3D_VSO_FIX_BORDRE_EXTENSION     1   // Temporary for minor fixes can be removed after merge
     135#define H_3D_DIM                          1   // DIM, Depth intra modes, includes:
     136                                              // HHI_DMM_WEDGE_INTRA
     137                                              // HHI_DMM_PRED_TEX
     138                                              // FIX_WEDGE_NOFLOAT_D0036
     139                                              // LGE_EDGE_INTRA_A0070
     140                                              // LGE_DMM3_SIMP_C0044
     141                                              // QC_DC_PREDICTOR_D0183
     142                                              // HHI_DELTADC_DLT_D0035
     143                                              // PKU_QC_DEPTH_INTRA_UNI_D0195
     144                                              // RWTH_SDC_DLT_B0036
     145                                              // INTEL_SDC64_D0193
     146                                              // RWTH_SDC_CTX_SIMPL_D0032
     147                                              // LGE_CONCATENATE_D0141
     148                                              // FIX_SDC_ENC_RD_WVSO_D0163
     149                                              // MTK_SAMPLE_BASED_SDC_D0110
     150
    135151#endif
    136152
     
    171187#if H_3D_ARP
    172188#define H_3D_ARP_WFNR                     3
     189#endif
     190///// ***** DEPTH INTRA MODES *********
     191#if H_3D_DIM
     192#define H_3D_DIM_DMM                      1   // Depth Modeling Modes
     193#define H_3D_DIM_RBC                      1   // Region Boundary Chain mode
     194#define H_3D_DIM_SDC                      1   // Simplified Depth Coding method
     195#define H_3D_DIM_DLT                      1   // Depth Lookup Table
     196#define H_3D_DIM_ENC                      1   // Depth Intra encoder optimizations, includes:
     197                                              // HHI_DEPTH_INTRA_SEARCH_RAU_C0160
     198                                              // LG_ZEROINTRADEPTHRESI_A0087
    173199#endif
    174200
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecCAVLC.cpp

    r521 r531  
    977977    {
    978978#if H_3D
     979      m_pcBitstream->readOutTrailingBits();
     980
     981      for( Int i = 0; i <= pcVPS->getMaxLayers() - 1; i++ )
     982      {
     983        if( pcVPS->getDepthId( i ) )
     984        {
     985          READ_FLAG( uiCode, "vps_depth_modes_flag[i]" );             pcVPS->setVpsDepthModesFlag( i, uiCode == 1 ? true : false );
     986         
     987#if H_3D_DIM_DLT
     988          if( pcVPS->getVpsDepthModesFlag( i ) )
     989          {
     990            READ_FLAG( uiCode, "use_dlt_flag[i]" );
     991            pcVPS->setUseDLTFlag( i, uiCode == 1 ? true : false );
     992            if( pcVPS->getUseDLTFlag( i ) )
     993            {
     994              // decode mapping
     995              UInt uiNumDepthValues;
     996              // parse number of values in DLT
     997              READ_UVLC(uiNumDepthValues, "num_dlt_depth_values[i]");
     998             
     999              // parse actual DLT values
     1000              Int* aiIdx2DepthValue = (Int*) calloc(uiNumDepthValues, sizeof(Int));
     1001              for(Int d=0; d<uiNumDepthValues; d++)
     1002              {
     1003                READ_UVLC(uiCode, "dlt_depth_value[i][d]");
     1004                aiIdx2DepthValue[d] = (Int)uiCode;
     1005              }
     1006             
     1007              pcVPS->setDepthLUTs(i, aiIdx2DepthValue, uiNumDepthValues);
     1008             
     1009              // clean memory
     1010              free(aiIdx2DepthValue);
     1011            }
     1012          }
     1013#endif
     1014        }
     1015      }
     1016
    9791017#if H_3D_GEN
    9801018      for( Int layer = 0; layer <= pcVPS->getMaxLayers() - 1; layer++ )
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecCu.cpp

    r521 r531  
    488488      break;
    489489    case MODE_INTRA:
     490#if H_3D_DIM_SDC
     491      if( m_ppcCU[uiDepth]->getSDCFlag(0) )
     492        xReconIntraSDC( m_ppcCU[uiDepth], 0, uiDepth );
     493      else
     494#endif
    490495      xReconIntraQT( m_ppcCU[uiDepth], uiDepth );
    491496      break;
     
    557562 
    558563  //===== get prediction signal =====
     564#if H_3D_DIM
     565  if( isDimMode( uiLumaPredMode ) )
     566  {
     567    m_pcPrediction->predIntraLumaDepth( pcCU, uiAbsPartIdx, uiLumaPredMode, piPred, uiStride, uiWidth, uiHeight );
     568  }
     569  else
     570  {
     571#endif
    559572  m_pcPrediction->predIntraLumaAng( pcCU->getPattern(), uiLumaPredMode, piPred, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail );
     573#if H_3D_DIM
     574  }
     575#endif
    560576 
    561577  //===== inverse transform =====
     
    645661    {
    646662      uiChromaPredMode = pcCU->getLumaIntraDir( 0 );
     663#if H_3D_DIM
     664      mapDepthModeToIntraDir( uiChromaPredMode );
     665#endif
    647666    }
    648667    m_pcPrediction->predIntraChromaAng( pPatChroma, uiChromaPredMode, piPred, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail ); 
     
    709728
    710729}
     730
     731#if H_3D_DIM_SDC
     732Void TDecCu::xReconIntraSDC( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
     733{
     734  UInt uiWidth        = pcCU->getWidth  ( 0 );
     735  UInt uiHeight       = pcCU->getHeight ( 0 );
     736 
     737  TComYuv* pcRecoYuv  = m_ppcYuvReco[uiDepth];
     738  TComYuv* pcPredYuv  = m_ppcYuvReco[uiDepth];
     739  TComYuv* pcResiYuv  = m_ppcYuvResi[uiDepth];
     740 
     741  UInt    uiStride    = pcRecoYuv->getStride  ();
     742  Pel*    piReco      = pcRecoYuv->getLumaAddr( uiAbsPartIdx );
     743  Pel*    piPred      = pcPredYuv->getLumaAddr( uiAbsPartIdx );
     744  Pel*    piResi      = pcResiYuv->getLumaAddr( uiAbsPartIdx );
     745 
     746  UInt    uiZOrder          = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
     747  Pel*    piRecIPred        = pcCU->getPic()->getPicYuvRec()->getLumaAddr( pcCU->getAddr(), uiZOrder );
     748  UInt    uiRecIPredStride  = pcCU->getPic()->getPicYuvRec()->getStride  ();
     749 
     750  UInt    uiLumaPredMode    = pcCU->getLumaIntraDir     ( uiAbsPartIdx );
     751 
     752  AOF( uiWidth == uiHeight );
     753  AOF( uiAbsPartIdx == 0 );
     754  AOF( pcCU->getSDCAvailable(uiAbsPartIdx) );
     755  AOF( pcCU->getSDCFlag(uiAbsPartIdx) );
     756 
     757  //===== init availability pattern =====
     758  Bool  bAboveAvail = false;
     759  Bool  bLeftAvail  = false;
     760  pcCU->getPattern()->initPattern   ( pcCU, 0, uiAbsPartIdx );
     761  pcCU->getPattern()->initAdiPattern( pcCU, uiAbsPartIdx, 0, m_pcPrediction->getPredicBuf(), m_pcPrediction->getPredicBufWidth(), m_pcPrediction->getPredicBufHeight(), bAboveAvail, bLeftAvail );
     762 
     763  //===== get prediction signal =====
     764#if H_3D_DIM
     765  if( isDimMode( uiLumaPredMode ) )
     766  {
     767    m_pcPrediction->predIntraLumaDepth( pcCU, uiAbsPartIdx, uiLumaPredMode, piPred, uiStride, uiWidth, uiHeight );
     768  }
     769  else
     770  {
     771#endif
     772    m_pcPrediction->predIntraLumaAng( pcCU->getPattern(), uiLumaPredMode, piPred, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail );
     773#if H_3D_DIM
     774  }
     775#endif
     776 
     777  // number of segments depends on prediction mode
     778  UInt uiNumSegments = 1;
     779  Bool* pbMask = NULL;
     780  UInt uiMaskStride = 0;
     781 
     782  if( getDimType( uiLumaPredMode ) == DMM1_IDX )
     783  {
     784    Int uiTabIdx = pcCU->getDmmWedgeTabIdx(DMM1_IDX, uiAbsPartIdx);
     785   
     786    WedgeList* pacWedgeList = &g_dmmWedgeLists[(g_aucConvertToBit[uiWidth])];
     787    TComWedgelet* pcWedgelet = &(pacWedgeList->at( uiTabIdx ));
     788   
     789    uiNumSegments = 2;
     790    pbMask = pcWedgelet->getPattern();
     791    uiMaskStride = pcWedgelet->getStride();
     792  }
     793 
     794  // get DC prediction for each segment
     795  Pel apDCPredValues[2];
     796  m_pcPrediction->analyzeSegmentsSDC(piPred, uiStride, uiWidth, apDCPredValues, uiNumSegments, pbMask, uiMaskStride);
     797 
     798  // reconstruct residual based on mask + DC residuals
     799  Pel apDCResiValues[2];
     800  for( UInt uiSegment = 0; uiSegment < uiNumSegments; uiSegment++ )
     801  {
     802#if H_3D_DIM_DLT
     803    Pel   pPredIdx    = pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), apDCPredValues[uiSegment] );
     804    Pel   pResiIdx    = pcCU->getSDCSegmentDCOffset(uiSegment, uiAbsPartIdx);
     805    Pel   pRecoValue  = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pPredIdx + pResiIdx );
     806   
     807    apDCResiValues[uiSegment]  = pRecoValue - apDCPredValues[uiSegment];
     808#else
     809    apDCResiValues[uiSegment]  = pcCU->getSDCSegmentDCOffset(uiSegment, uiAbsPartIdx);
     810#endif
     811  }
     812 
     813  //===== reconstruction =====
     814  Bool*pMask      = pbMask;
     815  Pel* pPred      = piPred;
     816  Pel* pResi      = piResi;
     817  Pel* pReco      = piReco;
     818  Pel* pRecIPred  = piRecIPred;
     819 
     820  for( UInt uiY = 0; uiY < uiHeight; uiY++ )
     821  {
     822    for( UInt uiX = 0; uiX < uiWidth; uiX++ )
     823    {
     824      UChar ucSegment = pMask?(UChar)pMask[uiX]:0;
     825      assert( ucSegment < uiNumSegments );
     826     
     827      Pel pResiDC = apDCResiValues[ucSegment];
     828     
     829      pReco    [ uiX ] = ClipY( pPred[ uiX ] + pResiDC );
     830      pRecIPred[ uiX ] = pReco[ uiX ];
     831    }
     832    pPred     += uiStride;
     833    pResi     += uiStride;
     834    pReco     += uiStride;
     835    pRecIPred += uiRecIPredStride;
     836    pMask     += uiMaskStride;
     837  }
     838 
     839  // clear UV
     840  UInt  uiStrideC     = pcPredYuv->getCStride();
     841  Pel   *pRecCb       = pcPredYuv->getCbAddr();
     842  Pel   *pRecCr       = pcPredYuv->getCrAddr();
     843 
     844  for (Int y=0; y<uiHeight/2; y++)
     845  {
     846    for (Int x=0; x<uiWidth/2; x++)
     847    {
     848      pRecCb[x] = 128;
     849      pRecCr[x] = 128;
     850    }
     851   
     852    pRecCb += uiStrideC;
     853    pRecCr += uiStrideC;
     854  }
     855}
     856#endif
    711857
    712858/** Function for deriving recontructed PU/CU Luma sample with QTree structure
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecCu.h

    r324 r531  
    115115  Void setdQPFlag               ( Bool b )                { m_bDecodeDQP = b;           }
    116116  Void xFillPCMBuffer           (TComDataCU* pCU, UInt depth);
     117#if H_3D_DIM_SDC
     118  Void xReconIntraSDC           ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
     119#endif
    117120};
    118121
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecEntropy.cpp

    r521 r531  
    144144  {
    145145    decodeIntraDirModeLuma  ( pcCU, uiAbsPartIdx, uiDepth );
     146#if H_3D_DIM_SDC
     147    if(!pcCU->getSDCFlag(uiAbsPartIdx))
     148#endif
    146149    decodeIntraDirModeChroma( pcCU, uiAbsPartIdx, uiDepth );
    147150  }
     
    166169    return;
    167170  }
     171#if H_3D_DIM_SDC
     172  if( pcCU->getSDCFlag(uiAbsPartIdx) )
     173  {
     174    return;
     175  }
     176#endif
    168177 
    169178  m_pcEntropyDecoderIf->parseIPCMInfo( pcCU, uiAbsPartIdx, uiDepth );
     
    614623  UInt uiChromaOffset = uiLumaOffset>>2;
    615624 
     625#if H_3D_DIM_SDC
     626  if( pcCU->getSDCFlag( uiAbsPartIdx ) )
     627  {
     628    assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
     629    assert( pcCU->getTransformIdx(uiAbsPartIdx) == 0 );
     630    assert( pcCU->getCbf(uiAbsPartIdx, TEXT_LUMA) == 1 );
     631    assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_U) == 1 );
     632    assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V) == 1 );
     633    return;
     634  }
     635#endif
     636 
    616637  if( pcCU->isIntra(uiAbsPartIdx) )
    617638  {
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecSbac.cpp

    r521 r531  
    8383, m_cTransformSkipSCModel     ( 1,             2,               NUM_TRANSFORMSKIP_FLAG_CTX    , m_contextModels + m_numContextModels, m_numContextModels)
    8484, m_CUTransquantBypassFlagSCModel( 1,          1,               NUM_CU_TRANSQUANT_BYPASS_FLAG_CTX, m_contextModels + m_numContextModels, m_numContextModels)
     85#if H_3D_DIM
     86, m_cDepthIntraModeSCModel    ( 1,             1,               NUM_DEPTH_INTRA_MODE_CTX      , m_contextModels + m_numContextModels, m_numContextModels)
     87, m_cDdcFlagSCModel           ( 1,             1,               NUM_DDC_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     88, m_cDdcDataSCModel           ( 1,             1,               NUM_DDC_DATA_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     89#if H_3D_DIM_DMM
     90, m_cDmm1DataSCModel          ( 1,             1,               NUM_DMM1_DATA_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
     91, m_cDmm2DataSCModel          ( 1,             1,               NUM_DMM2_DATA_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
     92, m_cDmm3DataSCModel          ( 1,             1,               NUM_DMM3_DATA_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
     93#endif
     94#if H_3D_DIM_RBC
     95, m_cRbcDataSCModel           ( 1,             1,               NUM_RBC_DATA_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     96#endif
     97#if H_3D_DIM_SDC
     98, m_cSDCResidualFlagSCModel     ( 1,             1,             SDC_NUM_RESIDUAL_FLAG_CTX     , m_contextModels + m_numContextModels, m_numContextModels)
     99, m_cSDCResidualSCModel         ( 1,             1,             SDC_NUM_RESIDUAL_CTX          , m_contextModels + m_numContextModels, m_numContextModels)
     100#endif
     101#endif
    85102{
    86103  assert( m_numContextModels <= MAX_NUM_CTX_MOD );
     
    149166  m_cTransformSkipSCModel.initBuffer     ( sliceType, qp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
    150167  m_CUTransquantBypassFlagSCModel.initBuffer( sliceType, qp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
     168
     169#if H_3D_DIM
     170  m_cDepthIntraModeSCModel.initBuffer    ( sliceType, qp, (UChar*)INIT_DEPTH_INTRA_MODE );
     171  m_cDdcFlagSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_DDC_FLAG );
     172  m_cDdcDataSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_DDC_DATA );
     173#if H_3D_DIM_DMM
     174  m_cDmm1DataSCModel.initBuffer          ( sliceType, qp, (UChar*)INIT_DMM1_DATA );
     175  m_cDmm2DataSCModel.initBuffer          ( sliceType, qp, (UChar*)INIT_DMM2_DATA );
     176  m_cDmm3DataSCModel.initBuffer          ( sliceType, qp, (UChar*)INIT_DMM3_DATA );
     177#endif
     178#if H_3D_DIM_RBC
     179  m_cRbcDataSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_RBC_DATA );
     180#endif
     181#if H_3D_DIM_SDC
     182  m_cSDCResidualFlagSCModel.initBuffer    ( sliceType, qp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
     183  m_cSDCResidualSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_SDC_RESIDUAL );
     184#endif
     185#endif
     186
    151187  m_uiLastDQpNonZero  = 0;
    152188 
     
    199235  m_cTransformSkipSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
    200236  m_CUTransquantBypassFlagSCModel.initBuffer( eSliceType, iQp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
     237
     238#if H_3D_DIM
     239  m_cDepthIntraModeSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_DEPTH_INTRA_MODE );
     240  m_cDdcFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DDC_FLAG );
     241  m_cDdcDataSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DDC_DATA );
     242#if H_3D_DIM_DMM
     243  m_cDmm1DataSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_DMM1_DATA );
     244  m_cDmm2DataSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_DMM2_DATA );
     245  m_cDmm3DataSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_DMM3_DATA );
     246#endif
     247#if H_3D_DIM_RBC
     248  m_cRbcDataSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_RBC_DATA );
     249#endif
     250#if H_3D_DIM_SDC
     251  m_cSDCResidualFlagSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
     252  m_cSDCResidualSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL );
     253#endif
     254#endif
    201255  m_pcTDecBinIf->start();
    202256}
     
    315369  }
    316370}
     371
     372#if H_3D_DIM
     373Void TDecSbac::xReadExGolombLevel( UInt& ruiSymbol, ContextModel& rcSCModel  )
     374{
     375  UInt uiSymbol;
     376  UInt uiCount = 0;
     377  do
     378  {
     379    m_pcTDecBinIf->decodeBin( uiSymbol, rcSCModel );
     380    uiCount++;
     381  }
     382  while( uiSymbol && ( uiCount != 13 ) );
     383
     384  ruiSymbol = uiCount - 1;
     385
     386  if( uiSymbol )
     387  {
     388    xReadEpExGolomb( uiSymbol, 0 );
     389    ruiSymbol += uiSymbol + 1;
     390  }
     391
     392  return;
     393}
     394
     395Void TDecSbac::xParseDimDeltaDC( Pel& rValDeltaDC, UInt dimType )
     396{
     397  UInt absValDeltaDC = 0;
     398  xReadExGolombLevel( absValDeltaDC, m_cDdcDataSCModel.get(0, 0, (RBC_IDX == dimType) ? 1 : 0) );
     399  rValDeltaDC = (Pel)absValDeltaDC;
     400
     401  if( rValDeltaDC != 0 )
     402  {
     403    UInt uiSign;
     404    m_pcTDecBinIf->decodeBinEP( uiSign );
     405    if ( uiSign )
     406    {
     407      rValDeltaDC = -rValDeltaDC;
     408    }
     409  }
     410}
     411#if H_3D_DIM_DMM
     412Void TDecSbac::xParseDmm1WedgeIdx( UInt& ruiTabIdx, Int iNumBit )
     413{
     414  UInt uiSymbol, uiIdx = 0;
     415  for( Int i = 0; i < iNumBit; i++ )
     416  {
     417    m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmm1DataSCModel.get(0, 0, 0) );
     418    uiIdx += uiSymbol << i;
     419  }
     420  ruiTabIdx = uiIdx;
     421}
     422Void TDecSbac::xParseDmm2Offset( Int& riOffset )
     423{
     424  Int iDeltaEnd = 0;
     425  if( DMM2_DELTAEND_MAX > 0 )
     426  {
     427    UInt uiFlag = 0;
     428    m_pcTDecBinIf->decodeBin( uiFlag, m_cDmm2DataSCModel.get(0, 0, 0) );
     429
     430    if( uiFlag )
     431    {
     432      UInt uiAbsValMinus1;
     433      UInt uiSymbol;
     434      m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmm2DataSCModel.get(0, 0, 0) ); uiAbsValMinus1  = uiSymbol;
     435      m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmm2DataSCModel.get(0, 0, 0) ); uiAbsValMinus1 |= uiSymbol << 1;
     436      iDeltaEnd = uiAbsValMinus1 + 1;
     437      UInt uiSign;
     438      m_pcTDecBinIf->decodeBinEP( uiSign );
     439      if( uiSign )
     440      {
     441        iDeltaEnd = -iDeltaEnd;
     442      }
     443    }
     444  }
     445  riOffset = iDeltaEnd;
     446}
     447Void TDecSbac::xParseDmm3WedgeIdx( UInt& ruiIntraIdx, Int iNumBit )
     448{
     449  UInt uiSymbol, uiIdx = 0;
     450  for( Int i = 0; i < iNumBit; i++ )
     451  {
     452    m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmm3DataSCModel.get(0, 0, 0) );
     453    uiIdx += uiSymbol << i;
     454  }
     455  ruiIntraIdx = uiIdx;
     456}
     457#endif
     458#if H_3D_DIM_RBC
     459Void TDecSbac::xParseRbcEdge( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
     460{
     461  UInt uiSymbol = 0;
     462
     463  // 1. Top(0) or Left(1)
     464  UChar ucLeft;
     465  m_pcTDecBinIf->decodeBinEP( uiSymbol );
     466  ucLeft = uiSymbol;
     467
     468  // 2. Start position (lowest bit first)
     469  UChar ucStart = 0;
     470  for( UInt ui = 0; ui < 6 - uiDepth; ui++ )
     471  {
     472    m_pcTDecBinIf->decodeBinEP( uiSymbol );
     473    ucStart |= (uiSymbol << ui);
     474  }
     475
     476  // 3. Number of edges
     477  UChar ucMax = 0;
     478  for( UInt ui = 0; ui < 7 - uiDepth; ui++ )
     479  {
     480    m_pcTDecBinIf->decodeBinEP( uiSymbol );
     481    ucMax |= (uiSymbol << ui);
     482  }
     483  ucMax++; // +1
     484
     485  // 4. Edges
     486  UChar* pucSymbolList = (UChar*) xMalloc( UChar, 256 * RBC_MAX_EDGE_NUM_PER_4x4 );
     487  for( Int iPtr = 0; iPtr < ucMax; iPtr++ )
     488  {
     489    UChar ucEdge = 0;
     490    UInt  uiReorderEdge = 0;
     491    for( UInt ui = 0; ui < 6; ui++ )
     492    {
     493      m_pcTDecBinIf->decodeBin( uiSymbol, m_cRbcDataSCModel.get( 0, 0, 0 ) );
     494      ucEdge <<= 1;
     495      ucEdge |= uiSymbol;
     496      if( uiSymbol == 0 )
     497        break;
     498    }
     499
     500    switch( ucEdge )
     501    {
     502    case 0 :  // "0"       
     503      uiReorderEdge = 0;
     504      break;
     505    case 2 :  // "10"
     506      uiReorderEdge = 1;
     507      break;
     508    case 6 :  // "110"
     509      uiReorderEdge = 2;
     510      break;
     511    case 14 : // "1110"
     512      uiReorderEdge = 3;
     513      break;
     514    case 30 : // "11110"
     515      uiReorderEdge = 4;
     516      break;
     517    case 62 : // "111110"
     518      uiReorderEdge = 5;
     519      break;
     520    case 63 : // "111111"
     521      uiReorderEdge = 6;
     522      break;
     523    default :
     524      printf("parseIntraEdgeChain: error (unknown code %d)\n",ucEdge);
     525      assert(false);
     526      break;
     527    }
     528    pucSymbolList[iPtr] = uiReorderEdge;
     529  }
     530  /////////////////////
     531  // Edge Reconstruction
     532  Bool* pbRegion = pcCU->getEdgePartition( uiAbsPartIdx );
     533  pcCU->reconPartition( uiAbsPartIdx, uiDepth, ucLeft == 1, ucStart, ucMax, pucSymbolList, pbRegion );
     534  xFree( pucSymbolList );
     535}
     536#endif
     537#if H_3D_DIM_SDC
     538Void TDecSbac::xParseSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiSegment )
     539{
     540  assert( pcCU->getSlice()->getIsDepth() );
     541  assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
     542  assert( pcCU->getSDCFlag(uiAbsPartIdx) );
     543  assert( uiSegment < 2 );
     544 
     545  UInt uiResidual = 0;
     546  UInt uiBit      = 0;
     547  UInt uiAbsIdx   = 0;
     548  UInt uiSign     = 0;
     549  Int  iIdx       = 0;
     550 
     551#if H_3D_DIM_DLT
     552  UInt uiMaxResidualBits = pcCU->getSlice()->getVPS()->getBitsPerDepthValue( pcCU->getSlice()->getLayerIdInVps() );
     553#else
     554  UInt uiMaxResidualBits = g_bitDepthY;
     555#endif
     556  assert( uiMaxResidualBits <= g_bitDepthY );
     557 
     558  m_pcTDecBinIf->decodeBin(uiResidual, m_cSDCResidualFlagSCModel.get( 0, 0, 0 ) );
     559 
     560  if (uiResidual)
     561  {
     562    // decode residual sign bit
     563    m_pcTDecBinIf->decodeBinEP(uiSign);
     564   
     565    // decode residual magnitude
     566    // prefix part
     567    UInt uiCount = 0;
     568#if H_3D_DIM_DLT
     569    UInt uiNumDepthValues = pcCU->getSlice()->getVPS()->getNumDepthValues( pcCU->getSlice()->getLayerIdInVps() );
     570#else
     571    UInt uiNumDepthValues = ((1 << g_bitDepthY)-1);
     572#endif
     573    UInt uiPrefixThreshold = ((uiNumDepthValues * 3) >> 2);
     574    for ( UInt ui = 0; ui < uiPrefixThreshold; ui++)
     575    {
     576      m_pcTDecBinIf->decodeBin( uiBit, m_cSDCResidualSCModel.get(0, 0, 0) );
     577      if ( uiBit == 0 )
     578        break;
     579      else
     580        uiCount++;
     581    }
     582    // suffix part
     583    if ( uiCount == uiPrefixThreshold )
     584    {
     585      for ( UInt ui = 0; ui < numBitsForValue(uiNumDepthValues - uiPrefixThreshold); ui++ )
     586      {
     587        m_pcTDecBinIf->decodeBinEP( uiBit );
     588        uiAbsIdx |= uiBit << ui;
     589      }
     590      uiAbsIdx += uiCount;
     591    }
     592    else
     593      uiAbsIdx = uiCount;
     594   
     595    uiAbsIdx += 1;
     596    iIdx =(Int)(uiSign ? -1 : 1)*uiAbsIdx;
     597  }
     598 
     599  pcCU->setSDCSegmentDCOffset(iIdx, uiSegment, uiAbsPartIdx);
     600}
     601#endif
     602#endif
    317603
    318604/** Parse I_PCM information.
     
    671957  for (j=0;j<partNum;j++)
    672958  {
     959#if H_3D_DIM
     960    if( pcCU->getSlice()->getVpsDepthModesFlag() )
     961    {
     962      parseIntraDepth( pcCU, absPartIdx+partOffset*j, depth );
     963    }
     964    if( pcCU->getLumaIntraDir( absPartIdx+partOffset*j ) < NUM_INTRA_MODE )
     965#if H_3D_DIM_SDC
     966      if( !pcCU->getSDCFlag( absPartIdx+partOffset*j ) )
     967#endif
     968    {
     969#endif
    673970    m_pcTDecBinIf->decodeBin( symbol, m_cCUIntraPredSCModel.get( 0, 0, 0) );
    674971    mpmPred[j] = symbol;
     
    676973    DTRACE_CU("prev_intra_luma_pred_flag", symbol)
    677974#endif
     975#if H_3D_DIM
     976    }
     977#endif
    678978  }
    679979  for (j=0;j<partNum;j++)
    680980  {
     981#if H_3D_DIM
     982    if( pcCU->getLumaIntraDir( absPartIdx+partOffset*j ) < NUM_INTRA_MODE )
     983#if H_3D_DIM_SDC
     984      if( !pcCU->getSDCFlag( absPartIdx+partOffset*j ) )
     985#endif
     986    {
     987#endif
    681988    Int preds[3] = {-1, -1, -1};
    682989    Int predNum = pcCU->getIntraDirLumaPredictor(absPartIdx+partOffset*j, preds); 
     
    7211028    }
    7221029    pcCU->setLumaIntraDirSubParts( (UChar)intraPredMode, absPartIdx+partOffset*j, depth );
     1030#if H_3D_DIM
     1031    }
     1032#endif
    7231033  }
    7241034}
     
    7531063  return;
    7541064}
     1065
     1066#if H_3D_DIM
     1067Void TDecSbac::parseIntraDepth( TComDataCU* pcCU, UInt absPartIdx, UInt depth )
     1068{
     1069  parseIntraDepthMode( pcCU, absPartIdx, depth );
     1070
     1071  UInt dir     = pcCU->getLumaIntraDir( absPartIdx );
     1072  UInt dimType = getDimType( dir );
     1073
     1074  switch( dimType )
     1075  {
     1076#if H_3D_DIM_DMM
     1077  case( DMM1_IDX ):
     1078    {
     1079      UInt uiTabIdx = 0;
     1080      xParseDmm1WedgeIdx( uiTabIdx, g_dmm1TabIdxBits[pcCU->getIntraSizeIdx(absPartIdx)] );
     1081      pcCU->setDmmWedgeTabIdxSubParts( uiTabIdx, dimType, absPartIdx, depth );
     1082    } break;
     1083  case( DMM2_IDX ):
     1084    {
     1085      Int iOffset = 0;
     1086      xParseDmm2Offset( iOffset );
     1087      pcCU->setDmm2DeltaEndSubParts( iOffset, absPartIdx, depth );
     1088    } break;
     1089  case( DMM3_IDX ):
     1090    {
     1091      UInt uiIntraIdx = 0;
     1092      xParseDmm3WedgeIdx( uiIntraIdx, g_dmm3IntraTabIdxBits[pcCU->getIntraSizeIdx(absPartIdx)] );
     1093      pcCU->setDmm3IntraTabIdxSubParts( uiIntraIdx, absPartIdx, depth );
     1094    } break;
     1095  case( DMM4_IDX ): break;
     1096#endif
     1097#if H_3D_DIM_RBC
     1098  case( RBC_IDX ):
     1099    {
     1100      xParseRbcEdge( pcCU, absPartIdx, depth );
     1101    } break;
     1102#endif
     1103  default: break;
     1104  }
     1105
     1106#if H_3D_DIM_SDC
     1107  if( pcCU->getSDCFlag(absPartIdx) )
     1108  {
     1109    assert(pcCU->getPartitionSize(absPartIdx)==SIZE_2Nx2N);
     1110    pcCU->setTrIdxSubParts(0, absPartIdx, depth);
     1111    pcCU->setCbfSubParts(1, 1, 1, absPartIdx, depth);
     1112
     1113    UInt uiNumSegments = ( dir == DC_IDX || dir == PLANAR_IDX )? 1 : 2;
     1114    for (UInt uiSeg=0; uiSeg<uiNumSegments; uiSeg++)
     1115    {
     1116      xParseSDCResidualData(pcCU, absPartIdx, depth, uiSeg);
     1117    }
     1118  }
     1119  else
     1120  {
     1121#endif
     1122    if( dimType < DIM_NUM_TYPE )
     1123    {
     1124      UInt symbol;
     1125      m_pcTDecBinIf->decodeBin( symbol, m_cDdcFlagSCModel.get(0, 0, (RBC_IDX == dimType) ? 1 : 0) );
     1126      if( symbol )
     1127      {
     1128        dir += symbol;
     1129        for( UInt segment = 0; segment < 2; segment++ )
     1130        {
     1131          Pel valDeltaDC = 0;
     1132          xParseDimDeltaDC( valDeltaDC, dimType );
     1133          pcCU->setDimDeltaDC( dimType, segment, absPartIdx, valDeltaDC );
     1134        }
     1135      }
     1136    }
     1137#if H_3D_DIM_SDC
     1138  }
     1139#endif
     1140
     1141  pcCU->setLumaIntraDirSubParts( (UChar)dir, absPartIdx, depth );
     1142}
     1143
     1144Void TDecSbac::parseIntraDepthMode( TComDataCU* pcCU, UInt absPartIdx, UInt depth )
     1145{
     1146  UInt puIdx = (pcCU->getWidth(absPartIdx) == 64) ? 2 : ( (pcCU->getPartitionSize(absPartIdx) == SIZE_NxN && pcCU->getWidth(absPartIdx) == 8) ? 0 : 1 );
     1147  UInt dir = 0;
     1148  Bool sdcFlag = 0;
     1149  UInt symbol = 1;
     1150  UInt modeCode = 0 ;
     1151  UInt binNum = 0;
     1152  UInt ctxDepthMode = 0;
     1153
     1154  if( puIdx == 2 )
     1155  {
     1156    while( binNum < 2 && symbol )
     1157    {
     1158      ctxDepthMode = puIdx*3 + binNum;
     1159      m_pcTDecBinIf->decodeBin( symbol, m_cDepthIntraModeSCModel.get(0,0,ctxDepthMode) );
     1160      modeCode = (modeCode<<1) + symbol;
     1161      binNum++;
     1162    }
     1163         if( modeCode == 0 ) { dir = PLANAR_IDX; sdcFlag = 1;}
     1164    else if( modeCode == 2 ) { dir = 0;          sdcFlag = 0;}
     1165    else if( modeCode == 3 ) { dir =     DC_IDX; sdcFlag = 1;}
     1166  }
     1167  else if( puIdx == 0 )
     1168  {
     1169    while( binNum < 3 && symbol )
     1170    {
     1171      ctxDepthMode = puIdx*3 + ((binNum >= 2) ? 2 : binNum);
     1172      m_pcTDecBinIf->decodeBin( symbol, m_cDepthIntraModeSCModel.get(0,0,ctxDepthMode) );
     1173      modeCode = (modeCode<<1) + symbol;
     1174      binNum++;
     1175    }
     1176         if( modeCode == 0 ) { dir = 0;                       sdcFlag = 0;}
     1177    else if( modeCode == 2 ) { dir = (2*DMM1_IDX+DIM_OFFSET); sdcFlag = 0;}
     1178    else if( modeCode == 6 ) { dir = (2*DMM3_IDX+DIM_OFFSET); sdcFlag = 0;}
     1179    else if( modeCode == 7 ) { dir = (2* RBC_IDX+DIM_OFFSET); sdcFlag = 0;}
     1180  }
     1181  else
     1182  {
     1183    ctxDepthMode = puIdx*3 ;
     1184    m_pcTDecBinIf->decodeBin( symbol, m_cDepthIntraModeSCModel.get(0,0,ctxDepthMode) );
     1185    modeCode = (modeCode<<1) + symbol;
     1186    if( !symbol )
     1187    {
     1188      ctxDepthMode = puIdx*3 + 1;
     1189      m_pcTDecBinIf->decodeBin( symbol, m_cDepthIntraModeSCModel.get(0,0,ctxDepthMode) );
     1190      modeCode = (modeCode<<1) + symbol;
     1191      if( symbol )
     1192      {
     1193        ctxDepthMode = puIdx*3 + 2;
     1194        m_pcTDecBinIf->decodeBin( symbol, m_cDepthIntraModeSCModel.get(0,0,ctxDepthMode) );
     1195        modeCode = (modeCode<<1) + symbol;
     1196      }
     1197    }
     1198    else
     1199    {
     1200      ctxDepthMode = puIdx*3 + 1;
     1201      m_pcTDecBinIf->decodeBin( symbol, m_cDepthIntraModeSCModel.get(0,0,ctxDepthMode) );
     1202      modeCode = (modeCode<<1) + symbol;
     1203      if( !symbol )
     1204      {
     1205        ctxDepthMode = puIdx*3 + 2;
     1206        m_pcTDecBinIf->decodeBin( symbol, m_cDepthIntraModeSCModel.get(0,0,ctxDepthMode) );
     1207        modeCode = (modeCode<<1) + symbol;
     1208      }
     1209      else
     1210      {
     1211        binNum = 0;
     1212        while( symbol && binNum < 3 )
     1213        {
     1214          ctxDepthMode = puIdx*3 + 2;
     1215          m_pcTDecBinIf->decodeBin( symbol, m_cDepthIntraModeSCModel.get(0,0,ctxDepthMode) );
     1216          modeCode = (modeCode<<1) + symbol;
     1217          binNum++;
     1218        }
     1219      }
     1220    }
     1221         if( modeCode == 0  ) { dir =  PLANAR_IDX;             sdcFlag = 1;}
     1222    else if( modeCode == 2  ) { dir = 5;                       sdcFlag = 0;}
     1223    else if( modeCode == 3  ) { dir = (2*DMM1_IDX+DIM_OFFSET); sdcFlag = 1;}
     1224    else if( modeCode == 4  ) { dir = (2*DMM1_IDX+DIM_OFFSET); sdcFlag = 0;}
     1225    else if( modeCode == 5  ) { dir = (2*DMM4_IDX+DIM_OFFSET); sdcFlag = 0;}
     1226    else if( modeCode == 6  ) { dir = (2*DMM3_IDX+DIM_OFFSET); sdcFlag = 0;}
     1227    else if( modeCode == 14 ) { dir =      DC_IDX;             sdcFlag = 1;}
     1228    else if( modeCode == 30 ) { dir = (2* RBC_IDX+DIM_OFFSET); sdcFlag = 0;}
     1229    else if( modeCode == 31 ) { dir = (2*DMM2_IDX+DIM_OFFSET); sdcFlag = 0;}
     1230  }
     1231  pcCU->setLumaIntraDirSubParts( (UChar)dir, absPartIdx, depth );
     1232#if H_3D_DIM_SDC
     1233  pcCU->setSDCFlagSubParts( sdcFlag, absPartIdx, depth );
     1234#endif
     1235}
     1236#endif
    7551237
    7561238Void TDecSbac::parseInterDir( TComDataCU* pcCU, UInt& ruiInterDir, UInt uiAbsPartIdx )
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecSbac.h

    r504 r531  
    9797  Void  xReadEpExGolomb     ( UInt& ruiSymbol, UInt uiCount );
    9898  Void  xReadCoefRemainExGolomb ( UInt &rSymbol, UInt &rParam );
     99#if H_3D_DIM
     100  Void  xReadExGolombLevel   ( UInt& ruiSymbol, ContextModel& rcSCModel  );
     101  Void  xParseDimDeltaDC     ( Pel& rValDeltaDC, UInt dimType );
     102#if H_3D_DIM_DMM
     103  Void  xParseDmm1WedgeIdx   ( UInt& ruiTabIdx, Int iNumBit );
     104  Void  xParseDmm2Offset     ( Int& riOffset );
     105  Void  xParseDmm3WedgeIdx   ( UInt& ruiIntraIdx, Int iNumBit );
     106#endif
     107#if H_3D_DIM_RBC
     108  Void  xParseRbcEdge        ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
     109#endif
     110#if H_3D_DIM_SDC
     111  Void  xParseSDCResidualData     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPart );
     112#endif
     113#endif
    99114private:
    100115  TComInputBitstream* m_pcBitstream;
     
    121136  Void parseIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    122137 
     138#if H_3D_DIM
     139  Void parseIntraDepth     ( TComDataCU* pcCU, UInt absPartIdx, UInt depth );
     140  Void parseIntraDepthMode ( TComDataCU* pcCU, UInt absPartIdx, UInt depth );
     141#endif
     142
    123143  Void parseInterDir      ( TComDataCU* pcCU, UInt& ruiInterDir, UInt uiAbsPartIdx );
    124144  Void parseRefFrmIdx     ( TComDataCU* pcCU, Int& riRefFrmIdx, RefPicList eRefList );
     
    183203  ContextModel3DBuffer m_cTransformSkipSCModel;
    184204  ContextModel3DBuffer m_CUTransquantBypassFlagSCModel;
     205
     206#if H_3D_DIM
     207  ContextModel3DBuffer m_cDepthIntraModeSCModel;
     208  ContextModel3DBuffer m_cDdcFlagSCModel;
     209  ContextModel3DBuffer m_cDdcDataSCModel;
     210#if H_3D_DIM_DMM
     211  ContextModel3DBuffer m_cDmm1DataSCModel;
     212  ContextModel3DBuffer m_cDmm2DataSCModel;
     213  ContextModel3DBuffer m_cDmm3DataSCModel;
     214#endif
     215#if H_3D_DIM_RBC
     216  ContextModel3DBuffer m_cRbcDataSCModel;
     217#endif
     218#if H_3D_DIM_SDC 
     219  ContextModel3DBuffer m_cSDCResidualFlagSCModel;
     220  ContextModel3DBuffer m_cSDCResidualSCModel;
     221#endif
     222#endif
    185223};
    186224
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecTop.cpp

    r521 r531  
    5252  m_aaiCodedScale          = new Int* [ MAX_NUM_LAYERS ];
    5353  m_aiViewId               = new Int  [ MAX_NUM_LAYERS ];
     54#if !H_3D_FIX 
    5455  m_aiLayerIdx             = new Int  [ MAX_NUM_LAYERS ];
     56#endif
    5557
    5658  m_bViewReceived          = new Bool [ MAX_NUM_LAYERS ];
     
    915917
    916918#endif
     919#if H_3D
     920    pcSlice->setPicLists( m_ivPicLists );
     921#endif
     922
    917923#if H_3D_GEN
    918924    pcSlice->setIvPicLists( m_ivPicLists );         
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecTop.h

    r479 r531  
    8989  Int**   m_aaiCodedScale;
    9090  Int*    m_aiViewId; 
     91#if !H_3D_FIX 
    9192  Int*    m_aiLayerIdx;
     93#endif
    9294
    9395  Bool*   m_bViewReceived;
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncCavlc.cpp

    r521 r531  
    752752#if H_3D_GEN 
    753753  WRITE_FLAG( 1,                                             "vps_extension2_flag" );
    754   for( Int layer = 0; layer <= pcVPS->getMaxLayers() - 1; layer++ )
    755   {
    756     if (layer != 0)
    757     {
    758       if ( !( pcVPS->getDepthId( layer ) == 1 ) )
     754  for( Int i = 0; i <= pcVPS->getMaxLayers() - 1; i++ )
     755  {
     756    if (i!= 0)
     757    {
     758      if ( !( pcVPS->getDepthId( i ) == 1 ) )
    759759      {
    760760#if H_3D_IV_MERGE
    761         WRITE_FLAG( pcVPS->getIvMvPredFlag         (layer) ? 1 : 0 , "iv_mv_pred_flag[i]");
     761        WRITE_FLAG( pcVPS->getIvMvPredFlag         ( i ) ? 1 : 0 , "iv_mv_pred_flag[i]");
    762762#endif
    763763#if H_3D_ARP
    764         WRITE_FLAG( pcVPS->getUseAdvRP             (layer) ? 1 : 0,  "advanced_residual_pred_flag"  );
     764        WRITE_FLAG( pcVPS->getUseAdvRP             ( i ) ? 1 : 0,  "advanced_residual_pred_flag"  );
    765765#endif
    766766#if H_3D_NBDV_REF
    767         WRITE_FLAG( pcVPS->getDepthRefinementFlag  (layer) ? 1 : 0 , "depth_refinement_flag[i]");
     767        WRITE_FLAG( pcVPS->getDepthRefinementFlag  ( i ) ? 1 : 0 , "depth_refinement_flag[i]");
    768768#endif
    769769#if H_3D_VSP
    770         WRITE_FLAG( pcVPS->getViewSynthesisPredFlag(layer) ? 1 : 0 , "view_synthesis_pred_flag[i]");
     770        WRITE_FLAG( pcVPS->getViewSynthesisPredFlag( i ) ? 1 : 0 , "view_synthesis_pred_flag[i]");
    771771#endif
    772772      }         
    773773    }       
     774    if( pcVPS->getDepthId( i ) )
     775    {
     776      WRITE_FLAG( pcVPS->getVpsDepthModesFlag( i ),          "vps_depth_modes_flag[i]" );
     777     
     778#if H_3D_DIM_DLT
     779      if( pcVPS->getVpsDepthModesFlag( i ) )
     780      {
     781        WRITE_FLAG( pcVPS->getUseDLTFlag( i ) ? 1 : 0, "use_dlt_flag[i]" );
     782        if( pcVPS->getUseDLTFlag( i ) )
     783        {
     784          // code mapping
     785          WRITE_UVLC(pcVPS->getNumDepthValues(i), "num_dlt_depth_values[i]");
     786          for(Int d=0; d<pcVPS->getNumDepthValues(i); d++)
     787          {
     788            WRITE_UVLC( pcVPS->idx2DepthValue(i, d), "dlt_depth_value[i][d]" );
     789          }
     790        }
     791      }
     792#endif
     793    }
     794
    774795  } 
    775796#else
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncCfg.h

    r504 r531  
    403403  Bool      m_bUseIC;
    404404#endif
     405
     406  //====== Depth Intra Modes ======
     407#if H_3D_DIM
     408  Bool      m_useDMM;
     409  Bool      m_useRBC;
     410  Bool      m_useSDC;
     411  Bool      m_useDLT;
     412#endif
     413
    405414#endif
    406415
     
    948957  Void      setDispCoeff                    ( Double  d )   { m_dDispCoeff  = d; }
    949958#endif // H_3D_VSO
     959
     960 //==== DIM  ==========
     961#if H_3D_DIM
     962  Bool      getUseDMM                       ()        { return m_useDMM; }
     963  Void      setUseDMM                       ( Bool b) { m_useDMM = b;    }
     964  Bool      getUseRBC                       ()        { return m_useRBC; }
     965  Void      setUseRBC                       ( Bool b) { m_useRBC = b;    }
     966  Bool      getUseSDC                       ()        { return m_useSDC; }
     967  Void      setUseSDC                       ( Bool b) { m_useSDC = b;    }
     968  Bool      getUseDLT                       ()        { return m_useDLT; }
     969  Void      setUseDLT                       ( Bool b) { m_useDLT = b;    }
     970#endif
    950971#endif // H_3D
    951972};
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncCu.cpp

    r521 r531  
    597597      m_LCUPredictionSAD += m_temporalSAD;
    598598      m_addSADDepth = uiDepth;
     599    }
     600#endif
     601
     602#if H_3D_DIM_ENC
     603    if( rpcBestCU->getSlice()->getIsDepth() && rpcBestCU->getSlice()->isIRAP() )
     604    {
     605      earlyDetectionSkipMode = false;
    599606    }
    600607#endif
     
    762769
    763770        // do normal intra modes
     771#if H_3D_DIM_ENC
     772        if ( !bEarlySkip || ( rpcBestCU->getSlice()->getIsDepth() && rpcBestCU->getSlice()->isIRAP() ) )
     773#else
    764774        if ( !bEarlySkip )
     775#endif
    765776        {
    766777          // speedup for inter frames
     
    768779            rpcBestCU->getCbf( 0, TEXT_LUMA     ) != 0   ||
    769780            rpcBestCU->getCbf( 0, TEXT_CHROMA_U ) != 0   ||
    770             rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) != 0     ) // avoid very complex intra if it is unlikely
     781              rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) != 0     
     782#if H_3D_DIM_ENC
     783            || ( rpcBestCU->getSlice()->getIsDepth() && rpcBestCU->getSlice()->isIRAP() )
     784#endif
     785            ) // avoid very complex intra if it is unlikely
    771786          {
    772787            xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
     
    17321747  m_ppcRecoYuvTemp[uiDepth]->copyToPicLuma(rpcTempCU->getPic()->getPicYuvRec(), rpcTempCU->getAddr(), rpcTempCU->getZorderIdxInCU() );
    17331748 
     1749#if H_3D_DIM_SDC
     1750  if( !rpcTempCU->getSDCFlag( 0 ) )
     1751#endif
    17341752  m_pcPredSearch  ->estIntraPredChromaQT( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth], uiPreCalcDistC );
    17351753 
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncEntropy.cpp

    r521 r531  
    257257    return;
    258258  }
     259#if H_3D_DIM_SDC
     260  if( pcCU->getSDCFlag(uiAbsPartIdx) )
     261  {
     262    return;
     263  }
     264#endif
    259265 
    260266  if( bRD )
     
    469475  {
    470476    encodeIntraDirModeLuma  ( pcCU, uiAbsPartIdx,true );
     477#if H_3D_DIM_SDC
     478    if(!pcCU->getSDCFlag(uiAbsPartIdx))
     479#endif
    471480    encodeIntraDirModeChroma( pcCU, uiAbsPartIdx, bRD );
    472481  }
     
    641650  UInt uiChromaOffset = uiLumaOffset>>2;
    642651   
     652#if H_3D_DIM_SDC
     653  if( pcCU->getSDCFlag( uiAbsPartIdx ) )
     654  {
     655    assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
     656    assert( pcCU->getTransformIdx(uiAbsPartIdx) == 0 );
     657    assert( pcCU->getCbf(uiAbsPartIdx, TEXT_LUMA) == 1 );
     658    assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_U) == 1 );
     659    assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V) == 1 );
     660    return;
     661  }
     662#endif
     663
    643664  if( pcCU->isIntra(uiAbsPartIdx) )
    644665  {
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncGOP.cpp

    r530 r531  
    706706#if H_3D
    707707    pcSlice->setIvPicLists( m_ivPicLists );         
     708#if H_3D
     709    pcSlice->setPicLists( m_ivPicLists );
     710#endif
    708711#if H_3D_IV_MERGE   
    709712    assert( !m_pcEncTop->getIsDepth() || ( pcSlice->getTexturePic() != 0 ) );
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncSbac.cpp

    r521 r531  
    8989, m_cTransformSkipSCModel     ( 1,             2,               NUM_TRANSFORMSKIP_FLAG_CTX    , m_contextModels + m_numContextModels, m_numContextModels)
    9090, m_CUTransquantBypassFlagSCModel( 1,          1,               NUM_CU_TRANSQUANT_BYPASS_FLAG_CTX, m_contextModels + m_numContextModels, m_numContextModels)
     91#if H_3D_DIM
     92, m_cDepthIntraModeSCModel    ( 1,             1,               NUM_DEPTH_INTRA_MODE_CTX      , m_contextModels + m_numContextModels, m_numContextModels)
     93, m_cDdcFlagSCModel           ( 1,             1,               NUM_DDC_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     94, m_cDdcDataSCModel           ( 1,             1,               NUM_DDC_DATA_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     95#if H_3D_DIM_DMM
     96, m_cDmm1DataSCModel          ( 1,             1,               NUM_DMM1_DATA_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
     97, m_cDmm2DataSCModel          ( 1,             1,               NUM_DMM2_DATA_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
     98, m_cDmm3DataSCModel          ( 1,             1,               NUM_DMM3_DATA_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
     99#endif
     100#if H_3D_DIM_RBC
     101, m_cRbcDataSCModel           ( 1,             1,               NUM_RBC_DATA_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     102#endif
     103#if H_3D_DIM_SDC
     104, m_cSDCResidualFlagSCModel   ( 1,             1,               SDC_NUM_RESIDUAL_FLAG_CTX     , m_contextModels + m_numContextModels, m_numContextModels)
     105, m_cSDCResidualSCModel       ( 1,             1,               SDC_NUM_RESIDUAL_CTX          , m_contextModels + m_numContextModels, m_numContextModels)
     106#endif
     107#endif
    91108{
    92109  assert( m_numContextModels <= MAX_NUM_CTX_MOD );
     
    146163  m_cTransformSkipSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
    147164  m_CUTransquantBypassFlagSCModel.initBuffer( eSliceType, iQp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
     165
     166#if H_3D_DIM
     167  m_cDepthIntraModeSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_DEPTH_INTRA_MODE );
     168  m_cDdcFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DDC_FLAG );
     169  m_cDdcDataSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DDC_DATA );
     170#if H_3D_DIM_DMM
     171  m_cDmm1DataSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_DMM1_DATA );
     172  m_cDmm2DataSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_DMM2_DATA );
     173  m_cDmm3DataSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_DMM3_DATA );
     174#endif
     175#if H_3D_DIM_RBC
     176  m_cRbcDataSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_RBC_DATA );
     177#endif
     178#if H_3D_DIM_SDC
     179  m_cSDCResidualFlagSCModel.initBuffer   ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
     180  m_cSDCResidualSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL );
     181#endif
     182#endif
    148183  // new structure
    149184  m_uiLastQp = iQp;
     
    206241      curCost += m_cTransformSkipSCModel.calcCost     ( curSliceType, qp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
    207242      curCost += m_CUTransquantBypassFlagSCModel.calcCost( curSliceType, qp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
     243#if H_3D_DIM
     244    if( m_pcSlice->getVpsDepthModesFlag() )
     245    {
     246      curCost += m_cDepthIntraModeSCModel.calcCost    ( curSliceType, qp, (UChar*)INIT_DEPTH_INTRA_MODE );
     247      curCost += m_cDdcFlagSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_DDC_FLAG );
     248      curCost += m_cDdcDataSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_DDC_DATA );
     249#if H_3D_DIM_DMM
     250      curCost += m_cDmm1DataSCModel.calcCost          ( curSliceType, qp, (UChar*)INIT_DMM1_DATA );
     251      curCost += m_cDmm2DataSCModel.calcCost          ( curSliceType, qp, (UChar*)INIT_DMM2_DATA );
     252      curCost += m_cDmm3DataSCModel.calcCost          ( curSliceType, qp, (UChar*)INIT_DMM3_DATA );
     253#endif
     254#if H_3D_DIM_RBC
     255      curCost += m_cRbcDataSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_RBC_DATA );
     256#endif
     257    }
     258#endif
    208259      if (curCost < bestCost)
    209260      {
     
    261312  m_cTransformSkipSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
    262313  m_CUTransquantBypassFlagSCModel.initBuffer( eSliceType, iQp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
     314
     315#if H_3D_DIM
     316  m_cDepthIntraModeSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_DEPTH_INTRA_MODE );
     317  m_cDdcFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DDC_FLAG );
     318  m_cDdcDataSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DDC_DATA );
     319#if H_3D_DIM_DMM
     320  m_cDmm1DataSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_DMM1_DATA );
     321  m_cDmm2DataSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_DMM2_DATA );
     322  m_cDmm3DataSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_DMM3_DATA );
     323#endif
     324#if H_3D_DIM_RBC
     325  m_cRbcDataSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_RBC_DATA );
     326#endif
     327#if H_3D_DIM_SDC
     328  m_cSDCResidualFlagSCModel.initBuffer   ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
     329  m_cSDCResidualSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL );
     330#endif
     331#endif
    263332  m_pcBinIf->start();
    264333}
     
    403472}
    404473
     474#if H_3D_DIM
     475Void TEncSbac::xWriteExGolombLevel( UInt uiSymbol, ContextModel& rcSCModel  )
     476{
     477  if( uiSymbol )
     478  {
     479    m_pcBinIf->encodeBin( 1, rcSCModel );
     480    UInt uiCount = 0;
     481    Bool bNoExGo = (uiSymbol < 13);
     482
     483    while( --uiSymbol && ++uiCount < 13 )
     484    {
     485      m_pcBinIf->encodeBin( 1, rcSCModel );
     486    }
     487    if( bNoExGo )
     488    {
     489      m_pcBinIf->encodeBin( 0, rcSCModel );
     490    }
     491    else
     492    {
     493      xWriteEpExGolomb( uiSymbol, 0 );
     494    }
     495  }
     496  else
     497  {
     498    m_pcBinIf->encodeBin( 0, rcSCModel );
     499  }
     500
     501  return;
     502}
     503
     504Void TEncSbac::xCodeDimDeltaDC( Pel valDeltaDC, UInt dimType )
     505{
     506  xWriteExGolombLevel( UInt( abs( valDeltaDC ) ), m_cDdcDataSCModel.get(0, 0, (RBC_IDX == dimType) ? 1 : 0) );
     507  if( valDeltaDC != 0 )
     508  {
     509    UInt uiSign = valDeltaDC > 0 ? 0 : 1;
     510    m_pcBinIf->encodeBinEP( uiSign );
     511  }
     512}
     513
     514#if H_3D_DIM_DMM
     515Void TEncSbac::xCodeDmm1WedgeIdx( UInt uiTabIdx, Int iNumBit )
     516{
     517  for ( Int i = 0; i < iNumBit; i++ )
     518  {
     519    m_pcBinIf->encodeBin( ( uiTabIdx >> i ) & 1, m_cDmm1DataSCModel.get(0, 0, 0) );
     520  }
     521}
     522
     523Void TEncSbac::xCodeDmm2Offset( Int iOffset )
     524{
     525  if( DMM2_DELTAEND_MAX > 0 )
     526  {
     527    m_pcBinIf->encodeBin( (iOffset != 0) , m_cDmm2DataSCModel.get(0, 0, 0) );
     528    if( iOffset != 0 )
     529    {
     530      UInt uiAbsValMinus1 = abs(iOffset)-1;
     531      m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x01),      m_cDmm2DataSCModel.get(0, 0, 0) );
     532      m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x02) >> 1, m_cDmm2DataSCModel.get(0, 0, 0) );
     533
     534      UInt uiSign = (iOffset > 0) ? 0 : 1;
     535      m_pcBinIf->encodeBinEP( uiSign );
     536    }
     537  }
     538}
     539
     540Void TEncSbac::xCodeDmm3WedgeIdx( UInt uiIntraIdx, Int iNumBit )
     541{
     542  for( Int i = 0; i < iNumBit; i++ )
     543  {
     544    m_pcBinIf->encodeBin( ( uiIntraIdx >> i ) & 1, m_cDmm3DataSCModel.get(0, 0, 0) );
     545  }
     546}
     547#endif
     548#if H_3D_DIM_RBC
     549Void TEncSbac::xCodeRbcEdge( TComDataCU* pcCU, UInt uiAbsPartIdx )
     550{
     551  UInt   uiDepth        = pcCU->getDepth( uiAbsPartIdx ) + (pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_NxN ? 1 : 0);
     552  UChar* pucSymbolList  = pcCU->getEdgeCode     ( uiAbsPartIdx );
     553  UChar  ucEdgeNumber   = pcCU->getEdgeNumber   ( uiAbsPartIdx );
     554  Bool   bLeft          = pcCU->getEdgeLeftFirst( uiAbsPartIdx );
     555  UChar  ucStart        = pcCU->getEdgeStartPos ( uiAbsPartIdx );
     556  UInt   uiSymbol;
     557
     558  // 1. Top(0) or Left(1)
     559  uiSymbol = (bLeft == false) ? 0 : 1;
     560  m_pcBinIf->encodeBinEP( uiSymbol );
     561
     562  // 2. Start position (lowest bit first)
     563  uiSymbol = ucStart;
     564  for( UInt ui = 6; ui > uiDepth; ui-- ) // 64(0)->6, 32(1)->5, 16(2)->4, 8(3)->3, 4(4)->2
     565  {
     566    m_pcBinIf->encodeBinEP( uiSymbol & 0x1 );
     567    uiSymbol >>= 1;
     568  }
     569
     570  // 3. Number of edges
     571  uiSymbol = ucEdgeNumber > 0 ? ucEdgeNumber - 1 : 0;
     572  for( UInt ui = 7; ui > uiDepth; ui-- ) // 64(0)->7, 32(1)->6, 16(2)->5, 8(3)->4, 4(4)->3
     573  {
     574    m_pcBinIf->encodeBinEP( uiSymbol & 0x1 );
     575    uiSymbol >>= 1;
     576  }
     577
     578  if(uiSymbol != 0)
     579  {
     580    printf(" ucEdgeNumber %d at depth %d\n",ucEdgeNumber, uiDepth);
     581    assert(false);
     582  }
     583
     584  // 4. Edges
     585  for( Int iPtr2 = 0; iPtr2 < ucEdgeNumber; iPtr2++ )
     586  {
     587    UInt uiReorderSymbol = pucSymbolList[iPtr2];
     588    for( UInt ui = 0; ui < uiReorderSymbol; ui++ )
     589    {
     590      m_pcBinIf->encodeBin( 1, m_cRbcDataSCModel.get( 0, 0, 0 ) );
     591    }
     592
     593    if( uiReorderSymbol != 6 )
     594      m_pcBinIf->encodeBin( 0, m_cRbcDataSCModel.get( 0, 0, 0 ) );
     595  }
     596}
     597#endif
     598#if H_3D_DIM_SDC
     599Void TEncSbac::xCodeSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiSegment )
     600{
     601  assert( pcCU->getSlice()->getIsDepth() );
     602  assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
     603  assert( pcCU->getSDCFlag(uiAbsPartIdx) );
     604  assert( uiSegment < 2 );
     605 
     606  Pel segmentDCOffset = pcCU->getSDCSegmentDCOffset(uiSegment, uiAbsPartIdx);
     607 
     608  UInt uiResidual = segmentDCOffset == 0 ? 0 : 1;
     609  UInt uiSign     = segmentDCOffset < 0 ? 1 : 0;
     610  UInt uiAbsIdx   = abs(segmentDCOffset);
     611
     612#if H_3D_DIM_DLT
     613  UInt uiMaxResidualBits = pcCU->getSlice()->getVPS()->getBitsPerDepthValue( pcCU->getSlice()->getLayerIdInVps() );
     614#else
     615  UInt uiMaxResidualBits = g_bitDepthY;
     616#endif
     617  assert( uiMaxResidualBits <= g_bitDepthY );
     618 
     619  // residual flag
     620  m_pcBinIf->encodeBin( uiResidual, m_cSDCResidualFlagSCModel.get( 0, 0, 0 ) );
     621 
     622  if (uiResidual)
     623  {
     624    // encode sign bit of residual
     625    m_pcBinIf->encodeBinEP( uiSign );
     626   
     627#if H_3D_DIM_DLT
     628    UInt uiNumDepthValues = pcCU->getSlice()->getVPS()->getNumDepthValues( pcCU->getSlice()->getLayerIdInVps() );
     629#else
     630    UInt uiNumDepthValues = ((1 << g_bitDepthY)-1);
     631#endif
     632    assert(uiAbsIdx <= uiNumDepthValues);
     633   
     634    // encode residual magnitude
     635    uiAbsIdx -= 1;
     636    // prefix part
     637    if ( uiAbsIdx == 0 )
     638      m_pcBinIf->encodeBin( 0, m_cSDCResidualSCModel.get(0, 0, 0) );
     639    else
     640    {
     641      UInt l = uiAbsIdx;
     642      UInt k = 0;
     643      UInt uiPrefixThreshold = ((uiNumDepthValues * 3) >> 2);
     644      while ( l > 0 && k < uiPrefixThreshold )
     645      {
     646        m_pcBinIf->encodeBin( 1, m_cSDCResidualSCModel.get(0, 0, 0) );
     647        l--;
     648        k++;
     649      }
     650      if ( uiAbsIdx < uiPrefixThreshold )
     651        m_pcBinIf->encodeBin( 0, m_cSDCResidualSCModel.get(0, 0, 0) );
     652      // suffix part
     653      else
     654      {
     655        uiAbsIdx -= uiPrefixThreshold;
     656        UInt uiSuffixLength = numBitsForValue(uiNumDepthValues - uiPrefixThreshold);
     657        UInt uiBitInfo = 0;
     658        for ( Int i = 0; i < uiSuffixLength; i++)
     659        {
     660          uiBitInfo = ( uiAbsIdx & ( 1 << i ) ) >> i;
     661          m_pcBinIf->encodeBinEP( uiBitInfo);
     662        }
     663      }
     664    }
     665   
     666  }
     667}
     668#endif
     669#endif
     670
    405671// SBAC RD
    406672Void  TEncSbac::load ( TEncSbac* pSrc)
     
    415681  this->m_cCUIntraPredSCModel      .copyFrom( &pSrc->m_cCUIntraPredSCModel       );
    416682}
    417 
     683#if H_3D_DIM
     684Void TEncSbac::loadIntraDepthMode( TEncSbac* pSrc)
     685{
     686  m_pcBinIf->copyState( pSrc->m_pcBinIf );
     687
     688  this->m_cDepthIntraModeSCModel .copyFrom( &pSrc->m_cDepthIntraModeSCModel );
     689  this->m_cDdcFlagSCModel        .copyFrom( &pSrc->m_cDdcFlagSCModel );
     690}
     691#endif
    418692
    419693Void  TEncSbac::store( TEncSbac* pDest)
     
    546820Void TEncSbac::codePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
    547821{
     822#if H_3D_DIM_SDC
     823  if ( pcCU->getSlice()->isIntra() )
     824  {
     825    assert( pcCU->isIntra(uiAbsPartIdx) );
     826    return;
     827  }
     828#endif
     829 
    548830  // get context function is here
    549831  Int iPredMode = pcCU->getPredictionMode( uiAbsPartIdx );
     
    7421024  {
    7431025    dir[j] = pcCU->getLumaIntraDir( absPartIdx+partOffset*j );
     1026#if H_3D_DIM
     1027    if( pcCU->getSlice()->getVpsDepthModesFlag() )
     1028    {
     1029      codeIntraDepth( pcCU, absPartIdx+partOffset*j );
     1030    }
     1031    if( pcCU->getLumaIntraDir( absPartIdx+partOffset*j ) < NUM_INTRA_MODE )
     1032#if H_3D_DIM_SDC
     1033      if( !pcCU->getSDCFlag( absPartIdx+partOffset*j ) )
     1034#endif
     1035    {
     1036#endif
    7441037    predNum[j] = pcCU->getIntraDirLumaPredictor(absPartIdx+partOffset*j, preds[j]); 
    7451038    for(UInt i = 0; i < predNum[j]; i++)
     
    7541047    DTRACE_CU("prev_intra_luma_pred_flag", (predIdx[j] != -1)? 1 : 0);
    7551048#endif
     1049#if H_3D_DIM
     1050    }
     1051#endif
     1052
    7561053  } 
    7571054  for (j=0;j<partNum;j++)
    7581055  {
     1056#if H_3D_DIM
     1057    if( pcCU->getLumaIntraDir( absPartIdx+partOffset*j ) < NUM_INTRA_MODE )
     1058#if H_3D_DIM_SDC
     1059      if( !pcCU->getSDCFlag( absPartIdx+partOffset*j ) )
     1060#endif
     1061    {
     1062#endif
    7591063    if(predIdx[j] != -1)
    7601064    {
     
    7911095#endif
    7921096    }
     1097#if H_3D_DIM
     1098    }
     1099#endif
    7931100  }
    7941101  return;
     
    8291136  return;
    8301137}
     1138
     1139#if H_3D_DIM
     1140Void TEncSbac::codeIntraDepth( TComDataCU* pcCU, UInt absPartIdx )
     1141{
     1142  codeIntraDepthMode( pcCU, absPartIdx );
     1143
     1144  UInt dir     = pcCU->getLumaIntraDir( absPartIdx );
     1145  UInt dimType = getDimType( dir );
     1146
     1147  switch( dimType )
     1148  {
     1149#if H_3D_DIM_DMM
     1150  case( DMM1_IDX ):
     1151    {
     1152      xCodeDmm1WedgeIdx( pcCU->getDmmWedgeTabIdx( dimType, absPartIdx ), g_dmm1TabIdxBits[pcCU->getIntraSizeIdx(absPartIdx)] );
     1153    } break;
     1154  case( DMM2_IDX ):
     1155    {
     1156      xCodeDmm2Offset( pcCU->getDmm2DeltaEnd( absPartIdx ) );
     1157    } break;
     1158  case( DMM3_IDX ):
     1159    {
     1160      xCodeDmm3WedgeIdx( pcCU->getDmm3IntraTabIdx( absPartIdx ), g_dmm3IntraTabIdxBits[pcCU->getIntraSizeIdx(absPartIdx)] );
     1161    } break;
     1162  case( DMM4_IDX ): break;
     1163#endif
     1164#if H_3D_DIM_RBC
     1165  case( RBC_IDX ):
     1166    {
     1167      assert( pcCU->getWidth( absPartIdx ) < 64 );
     1168      xCodeRbcEdge( pcCU, absPartIdx );
     1169    } break;
     1170#endif
     1171  default: break;
     1172  }
     1173
     1174#if H_3D_DIM_SDC
     1175  if( pcCU->getSDCFlag( absPartIdx ) )
     1176  {
     1177    assert(pcCU->getPartitionSize(absPartIdx)==SIZE_2Nx2N);
     1178    UInt uiNumSegments = ( dir == DC_IDX || dir == PLANAR_IDX )? 1 : 2;
     1179    for(UInt uiSeg=0; uiSeg<uiNumSegments; uiSeg++)
     1180    {
     1181      xCodeSDCResidualData(pcCU, absPartIdx, uiSeg);
     1182    }
     1183  }
     1184  else
     1185  {
     1186#endif
     1187    if( dimType < DIM_NUM_TYPE )
     1188    {
     1189      UInt dimDeltaDC = isDimDeltaDC( dir );
     1190      m_pcBinIf->encodeBin( dimDeltaDC, m_cDdcFlagSCModel.get(0, 0, (RBC_IDX == dimType) ? 1 : 0) );
     1191      if( dimDeltaDC )
     1192      {
     1193        for( UInt segment = 0; segment < 2; segment++ )
     1194        {
     1195          xCodeDimDeltaDC( pcCU->getDimDeltaDC( dimType, segment, absPartIdx ), dimType );
     1196        }
     1197      }
     1198    }
     1199#if H_3D_DIM_SDC
     1200  }
     1201#endif
     1202}
     1203
     1204Void TEncSbac::codeIntraDepthMode( TComDataCU* pcCU, UInt absPartIdx )
     1205{
     1206  UInt codeWordTable[3][9] =    {{0, 0, 0, 2, 0,6, 0, 0, 7},{0, 2, 3, 4, 5, 6, 14, 31, 30},{0, 2, 0, 0, 0, 0, 3, 0, 0}};
     1207  UInt codeWordLenTable[3][9] = {{0, 1, 0, 2, 0,3, 0, 0, 3},{2, 3, 3, 3, 3, 3,  4,  5,  5},{1, 2, 0, 0, 0, 0, 2, 0, 0}};
     1208  UInt dir = pcCU->getLumaIntraDir( absPartIdx );
     1209  UInt puIdx = (pcCU->getWidth(absPartIdx) == 64) ? 2 : ( (pcCU->getPartitionSize(absPartIdx) == SIZE_NxN && pcCU->getWidth(absPartIdx) == 8) ? 0 : 1 );
     1210  UInt codeIdx = 0;
     1211
     1212  if( dir < NUM_INTRA_MODE )
     1213  {
     1214    codeIdx = 1;
     1215  }
     1216  if( isDimMode( dir ) )
     1217  {
     1218    switch( getDimType( dir ) )
     1219    {
     1220    case DMM1_IDX: codeIdx = 3; break;
     1221    case DMM4_IDX: codeIdx = 4; break;
     1222    case DMM3_IDX: codeIdx = 5; break;
     1223    case DMM2_IDX: codeIdx = 7; break;
     1224    case  RBC_IDX: codeIdx = 8; break;
     1225    default:                    break;
     1226    }
     1227  }
     1228
     1229#if H_3D_DIM_SDC
     1230  if( pcCU->getSDCFlag( absPartIdx ) )
     1231  {
     1232    switch( dir )
     1233    {
     1234      case PLANAR_IDX:  codeIdx = 0; break;
     1235      case DC_IDX:      codeIdx = 6; break;
     1236      default:          codeIdx = 2; break;
     1237    }
     1238  }
     1239#endif
     1240  //mode coding
     1241  for( UInt i = 0; i < codeWordLenTable[puIdx][codeIdx]; i++ )
     1242  {
     1243    UInt bit = codeWordTable[puIdx][codeIdx] & ( 1<<(codeWordLenTable[puIdx][codeIdx] - i - 1) );
     1244    UInt ctxDepthMode = puIdx*3 + ( (i >= 2) ? 2 : i );
     1245    m_pcBinIf->encodeBin( bit!=0 , m_cDepthIntraModeSCModel.get(0, 0, ctxDepthMode) );
     1246  }
     1247}
     1248#endif
     1249
    8311250
    8321251Void TEncSbac::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncSbac.h

    r504 r531  
    8484  Void  load                   ( TEncSbac* pScr  );
    8585  Void  loadIntraDirModeLuma   ( TEncSbac* pScr  );
     86#if H_3D_DIM
     87  Void  loadIntraDepthMode     ( TEncSbac* pScr  );
     88#endif
    8689  Void  store                  ( TEncSbac* pDest );
    8790  Void  loadContexts           ( TEncSbac* pScr  );
     
    113116  Void  xWriteEpExGolomb     ( UInt uiSymbol, UInt uiCount );
    114117  Void  xWriteCoefRemainExGolomb ( UInt symbol, UInt &rParam );
     118  #if H_3D_DIM
     119  Void  xWriteExGolombLevel  ( UInt uiSymbol, ContextModel& rcSCModel  );
     120  Void  xCodeDimDeltaDC      ( Pel valDeltaDC, UInt dimType );
     121#if H_3D_DIM_DMM
     122  Void  xCodeDmm1WedgeIdx    ( UInt uiTabIdx, Int iNumBit );
     123  Void  xCodeDmm2Offset      ( Int iOffset );
     124  Void  xCodeDmm3WedgeIdx    ( UInt uiIntraIdx, Int iNumBit );
     125#endif
     126#if H_3D_DIM_RBC
     127  Void  xCodeRbcEdge         ( TComDataCU* pcCU, UInt uiAbsPartIdx );
     128#endif
     129#if H_3D_DIM_SDC
     130  Void  xCodeSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiSegment );
     131#endif
     132#endif
    115133 
    116134  Void  xCopyFrom            ( TEncSbac* pSrc );
     
    154172 
    155173  Void codeIntraDirChroma      ( TComDataCU* pcCU, UInt uiAbsPartIdx );
     174
     175#if H_3D_DIM
     176  Void codeIntraDepth          ( TComDataCU* pcCU, UInt absPartIdx );
     177  Void codeIntraDepthMode      ( TComDataCU* pcCU, UInt absPartIdx );
     178#endif
     179
    156180  Void codeInterDir            ( TComDataCU* pcCU, UInt uiAbsPartIdx );
    157181  Void codeRefFrmIdx           ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList );
     
    219243  ContextModel3DBuffer m_cTransformSkipSCModel;
    220244  ContextModel3DBuffer m_CUTransquantBypassFlagSCModel;
     245
     246#if H_3D_DIM
     247  ContextModel3DBuffer m_cDepthIntraModeSCModel;
     248  ContextModel3DBuffer m_cDdcFlagSCModel;
     249  ContextModel3DBuffer m_cDdcDataSCModel;
     250#if H_3D_DIM_DMM
     251  ContextModel3DBuffer m_cDmm1DataSCModel;
     252  ContextModel3DBuffer m_cDmm2DataSCModel;
     253  ContextModel3DBuffer m_cDmm3DataSCModel;
     254#endif
     255#if H_3D_DIM_RBC
     256  ContextModel3DBuffer m_cRbcDataSCModel;
     257#endif
     258#if H_3D_DIM_SDC 
     259  ContextModel3DBuffer m_cSDCResidualFlagSCModel;
     260  ContextModel3DBuffer m_cSDCResidualSCModel;
     261#endif
     262#endif
    221263};
    222264
  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncSearch.cpp

    r510 r531  
    10171017                                UInt&       ruiDist,
    10181018#endif
    1019                                 Int        default0Save1Load2 )
     1019                                Int        default0Save1Load2
     1020#if H_3D_DIM_ENC
     1021                                , Bool       zeroResi
     1022#endif
     1023                                )
    10201024{
    10211025  UInt    uiLumaPredMode    = pcCU     ->getLumaIntraDir     ( uiAbsPartIdx );
     
    10511055    pcCU->getPattern()->initAdiPattern( pcCU, uiAbsPartIdx, uiTrDepth, m_piYuvExt, m_iYuvExtStride, m_iYuvExtHeight, bAboveAvail, bLeftAvail );
    10521056    //===== get prediction signal =====
     1057#if H_3D_DIM
     1058    if( isDimMode( uiLumaPredMode ) )
     1059    {
     1060      predIntraLumaDepth( pcCU, uiAbsPartIdx, uiLumaPredMode, piPred, uiStride, uiWidth, uiHeight, true );
     1061    }
     1062    else
     1063    {
     1064#endif
    10531065    predIntraLumaAng( pcCU->getPattern(), uiLumaPredMode, piPred, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail );
     1066#if H_3D_DIM
     1067    }
     1068#endif
     1069
    10541070    // save prediction
    10551071    if(default0Save1Load2 == 1)
     
    10911107    for( UInt uiY = 0; uiY < uiHeight; uiY++ )
    10921108    {
     1109#if H_3D_DIM_ENC
     1110      if( zeroResi )
     1111      {
     1112        memset( pResi, 0, sizeof( Pel ) * uiWidth );
     1113        pResi += uiStride;
     1114      }
     1115      else
     1116      {
     1117#endif
    10931118      for( UInt uiX = 0; uiX < uiWidth; uiX++ )
    10941119      {
     
    10981123      pResi += uiStride;
    10991124      pPred += uiStride;
     1125#if H_3D_DIM_ENC
     1126      }
     1127#endif
    11001128    }
    11011129  }
     
    12281256  {
    12291257    uiChromaPredMode          = pcCU->getLumaIntraDir( 0 );
     1258#if H_3D_DIM
     1259    mapDepthModeToIntraDir( uiChromaPredMode );
     1260#endif
    12301261  }
    12311262 
     
    13931424                                Bool         bCheckFirst,
    13941425#endif
    1395                                 Double&      dRDCost )
     1426                                Double&      dRDCost
     1427#if H_3D_DIM_ENC
     1428                                , Bool        zeroResi
     1429#endif
     1430                                )
    13961431{
    13971432  UInt    uiFullDepth   = pcCU->getDepth( 0 ) +  uiTrDepth;
     
    14351470#endif
    14361471#endif
     1472#if H_3D_DIM
     1473  if( isDimMode( pcCU->getLumaIntraDir( uiAbsPartIdx ) ) )
     1474  {
     1475    bCheckSplit = false;
     1476  }
     1477#endif
     1478
    14371479  Double  dSingleCost   = MAX_DOUBLE;
    14381480#if H_3D_VSO
     
    16011643      //----- code luma block with given intra prediction mode and store Cbf-----
    16021644      dSingleCost   = 0.0;
     1645#if H_3D_DIM_ENC
     1646      xIntraCodingLumaBlk( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, uiSingleDistY, 0, zeroResi );
     1647#else
    16031648      xIntraCodingLumaBlk( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, uiSingleDistY );
     1649#endif
    16041650      if( bCheckSplit )
    16051651      {
     
    17961842}
    17971843
     1844#if H_3D_DIM_SDC
     1845Void TEncSearch::xIntraCodingSDC( TComDataCU* pcCU, UInt uiAbsPartIdx, TComYuv* pcOrgYuv, TComYuv* pcPredYuv, Dist& ruiDist, Double& dRDCost, Bool bResidual )
     1846{
     1847  UInt    uiLumaPredMode    = pcCU     ->getLumaIntraDir( uiAbsPartIdx );
     1848  UInt    uiWidth           = pcCU     ->getWidth   ( 0 );
     1849  UInt    uiHeight          = pcCU     ->getHeight  ( 0 );
     1850  UInt    uiStride          = pcOrgYuv ->getStride  ();
     1851  Pel*    piOrg             = pcOrgYuv ->getLumaAddr( uiAbsPartIdx );
     1852  Pel*    piPred            = pcPredYuv->getLumaAddr( uiAbsPartIdx );
     1853  Pel*    piReco            = pcPredYuv->getLumaAddr( uiAbsPartIdx );
     1854 
     1855  UInt    uiZOrder          = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
     1856  Pel*    piRecIPred        = pcCU->getPic()->getPicYuvRec()->getLumaAddr( pcCU->getAddr(), uiZOrder );
     1857  UInt    uiRecIPredStride  = pcCU->getPic()->getPicYuvRec()->getStride  ();
     1858 
     1859  AOF( uiWidth == uiHeight );
     1860  AOF( uiAbsPartIdx == 0 );
     1861  AOF( pcCU->getSDCAvailable(uiAbsPartIdx) );
     1862  AOF( pcCU->getSDCFlag(uiAbsPartIdx) );
     1863  AOF( uiLumaPredMode == DC_IDX || uiLumaPredMode == PLANAR_IDX || ( getDimType( uiLumaPredMode ) == DMM1_IDX && !isDimDeltaDC( uiLumaPredMode ) ) );
     1864  AOF( uiLumaPredMode == DC_IDX || uiLumaPredMode == PLANAR_IDX || uiWidth < 64  );
     1865 
     1866  //===== init availability pattern =====
     1867  Bool  bAboveAvail = false;
     1868  Bool  bLeftAvail  = false;
     1869  pcCU->getPattern()->initPattern   ( pcCU, 0, uiAbsPartIdx );
     1870  pcCU->getPattern()->initAdiPattern( pcCU, uiAbsPartIdx, 0, m_piYuvExt, m_iYuvExtStride, m_iYuvExtHeight, bAboveAvail, bLeftAvail );
     1871 
     1872  //===== get prediction signal =====
     1873#if H_3D_DIM
     1874  if( isDimMode( uiLumaPredMode ) )
     1875  {
     1876    predIntraLumaDepth( pcCU, uiAbsPartIdx, uiLumaPredMode, piPred, uiStride, uiWidth, uiHeight, true );
     1877  }
     1878  else
     1879  {
     1880#endif
     1881    predIntraLumaAng( pcCU->getPattern(), uiLumaPredMode, piPred, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail );
     1882#if H_3D_DIM
     1883  }
     1884#endif
     1885 
     1886  // number of segments depends on prediction mode
     1887  UInt uiNumSegments = 1;
     1888  Bool* pbMask = NULL;
     1889  UInt uiMaskStride = 0;
     1890   
     1891  if( getDimType( uiLumaPredMode ) == DMM1_IDX )
     1892  {
     1893    Int uiTabIdx = pcCU->getDmmWedgeTabIdx(DMM1_IDX, uiAbsPartIdx);
     1894   
     1895    WedgeList* pacWedgeList = &g_dmmWedgeLists[(g_aucConvertToBit[uiWidth])];
     1896    TComWedgelet* pcWedgelet = &(pacWedgeList->at( uiTabIdx ));
     1897   
     1898    uiNumSegments = 2;
     1899    pbMask = pcWedgelet->getPattern();
     1900    uiMaskStride = pcWedgelet->getStride();
     1901  }
     1902 
     1903  // get DC prediction for each segment
     1904  Pel apDCPredValues[2];
     1905  analyzeSegmentsSDC(piPred, uiStride, uiWidth, apDCPredValues, uiNumSegments, pbMask, uiMaskStride );
     1906 
     1907  // get original DC for each segment
     1908  Pel apDCOrigValues[2];
     1909  analyzeSegmentsSDC(piOrg, uiStride, uiWidth, apDCOrigValues, uiNumSegments, pbMask, uiMaskStride );
     1910 
     1911  for( UInt uiSegment = 0; uiSegment < uiNumSegments; uiSegment++ )
     1912  {
     1913    // remap reconstructed value to valid depth values
     1914    Pel pDCRec = bResidual?apDCOrigValues[uiSegment]:apDCPredValues[uiSegment];
     1915   
     1916    // get residual (idx)
     1917#if H_3D_DIM_DLT
     1918    Pel pResidualIdx = pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), pDCRec ) - pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), apDCPredValues[uiSegment] );
     1919#else
     1920    Pel pResidualIdx = pDCRec - apDCPredValues[uiSegment];
     1921#endif
     1922   
     1923    // save SDC DC offset
     1924    pcCU->setSDCSegmentDCOffset(pResidualIdx, uiSegment, uiAbsPartIdx);
     1925  }
     1926 
     1927  // reconstruct residual based on mask + DC residuals
     1928  Pel apDCResiValues[2];
     1929  for( UInt uiSegment = 0; uiSegment < uiNumSegments; uiSegment++ )
     1930  {
     1931#if H_3D_DIM_DLT
     1932    Pel   pPredIdx    = pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), apDCPredValues[uiSegment] );
     1933    Pel   pResiIdx    = pcCU->getSDCSegmentDCOffset(uiSegment, uiAbsPartIdx);
     1934    Pel   pRecoValue  = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pPredIdx + pResiIdx );
     1935   
     1936    apDCResiValues[uiSegment]  = pRecoValue - apDCPredValues[uiSegment];
     1937#else
     1938    apDCResiValues[uiSegment]  = pcCU->getSDCSegmentDCOffset(uiSegment, uiAbsPartIdx);
     1939#endif
     1940  }
     1941 
     1942  //===== reconstruction =====
     1943  Bool* pMask     = pbMask;
     1944  Pel* pPred      = piPred;
     1945  Pel* pReco      = piReco;
     1946  Pel* pRecIPred  = piRecIPred;
     1947 
     1948  for( UInt uiY = 0; uiY < uiHeight; uiY++ )
     1949  {
     1950    for( UInt uiX = 0; uiX < uiWidth; uiX++ )
     1951    {
     1952      UChar ucSegment = pMask?(UChar)pMask[uiX]:0;
     1953      assert( ucSegment < uiNumSegments );
     1954
     1955      Pel pResiDC = apDCResiValues[ucSegment];
     1956     
     1957      pReco    [ uiX ] = ClipY( pPred[ uiX ] + pResiDC );
     1958      pRecIPred[ uiX ] = pReco[ uiX ];
     1959    }
     1960    pPred     += uiStride;
     1961    pReco     += uiStride;
     1962    pRecIPred += uiRecIPredStride;
     1963    pMask     += uiMaskStride;
     1964  }
     1965 
     1966  // clear UV
     1967  UInt  uiStrideC     = pcPredYuv->getCStride();
     1968  Pel   *pRecCb       = pcPredYuv->getCbAddr();
     1969  Pel   *pRecCr       = pcPredYuv->getCrAddr();
     1970 
     1971  for (Int y=0; y<uiHeight/2; y++)
     1972  {
     1973    for (Int x=0; x<uiWidth/2; x++)
     1974    {
     1975      pRecCb[x] = 128;
     1976      pRecCr[x] = 128;
     1977    }
     1978   
     1979    pRecCb += uiStrideC;
     1980    pRecCr += uiStrideC;
     1981  }
     1982 
     1983  //===== determine distortion =====
     1984#if H_3D_VSO
     1985  if ( m_pcRdCost->getUseVSO() )
     1986    ruiDist = m_pcRdCost->getDistPartVSO  ( pcCU, uiAbsPartIdx, piReco, uiStride, piOrg, uiStride, uiWidth, uiHeight, false );
     1987  else
     1988#endif
     1989    ruiDist = m_pcRdCost->getDistPart(g_bitDepthY, piReco, uiStride, piOrg, uiStride, uiWidth, uiHeight );
     1990 
     1991  //===== determine rate and r-d cost =====
     1992  m_pcEntropyCoder->resetBits();
     1993 
     1994  // encode reduced intra header
     1995  m_pcEntropyCoder->encodePredMode( pcCU, 0, true );
     1996 
     1997  // encode pred direction + DC residual data
     1998  m_pcEntropyCoder->encodePredInfo( pcCU, 0, true );
     1999  UInt uiBits = m_pcEntropyCoder->getNumberOfWrittenBits();
     2000 
     2001#if H_3D_VSO
     2002  if ( m_pcRdCost->getUseLambdaScaleVSO())
     2003    dRDCost = m_pcRdCost->calcRdCostVSO( uiBits, ruiDist );
     2004  else
     2005#endif
     2006    dRDCost = m_pcRdCost->calcRdCost( uiBits, ruiDist );
     2007}
     2008#endif
    17982009
    17992010Void
     
    26322843    }
    26332844   
     2845#if H_3D_DIM
     2846    //===== determine set of depth intra modes to be tested =====
     2847    if( m_pcEncCfg->getIsDepth() && uiWidth >= DIM_MIN_SIZE && uiWidth <= DIM_MAX_SIZE && uiWidth == uiHeight )
     2848    {
     2849#if H_3D_DIM_DMM
     2850      if( m_pcEncCfg->getUseDMM() )
     2851      {
     2852        for( UInt dmmType = 0; dmmType < DMM_NUM_TYPE; dmmType++ )
     2853        {
     2854          UInt uiTabIdx = 0;
     2855          TComWedgelet* biSegmentation = NULL;
     2856          Pel deltaDC1 = 0; Pel deltaDC2 = 0;
     2857          switch( dmmType )
     2858          {
     2859          case( DMM1_IDX ):
     2860            {
     2861              xSearchDmm1Wedge( pcCU, uiPartOffset, piOrg, uiStride, uiWidth, uiHeight, uiTabIdx );
     2862              pcCU->setDmmWedgeTabIdxSubParts( uiTabIdx, dmmType,  uiPartOffset, uiDepth + uiInitTrDepth );
     2863              biSegmentation = &(g_dmmWedgeLists[(g_aucConvertToBit[uiWidth])][uiTabIdx]);
     2864            } break;
     2865          case( DMM2_IDX ):
     2866            {
     2867              if( uiWidth > 4 )
     2868              {
     2869                Int dmm2DeltaEnd = 0;
     2870                xSearchDmm2Wedge( pcCU, uiPartOffset, piOrg, uiStride, uiWidth, uiHeight, uiTabIdx, dmm2DeltaEnd );
     2871                pcCU->setDmmWedgeTabIdxSubParts( uiTabIdx, dmmType, uiPartOffset, uiDepth + uiInitTrDepth );
     2872                pcCU->setDmm2DeltaEndSubParts( dmm2DeltaEnd, uiPartOffset, uiDepth + uiInitTrDepth );
     2873                biSegmentation = &(g_dmmWedgeLists[(g_aucConvertToBit[uiWidth])][uiTabIdx]);
     2874              }
     2875            } break;
     2876          case( DMM3_IDX ):
     2877            {
     2878              UInt uiIntraTabIdx = 0;
     2879              xSearchDmm3Wedge( pcCU, uiPartOffset, piOrg, uiStride, uiWidth, uiHeight, uiTabIdx, uiIntraTabIdx );
     2880              pcCU->setDmmWedgeTabIdxSubParts( uiTabIdx, dmmType, uiPartOffset, uiDepth + uiInitTrDepth );
     2881              pcCU->setDmm3IntraTabIdxSubParts( uiIntraTabIdx, uiPartOffset, uiDepth + uiInitTrDepth );
     2882              biSegmentation = &(g_dmmWedgeLists[(g_aucConvertToBit[uiWidth])][uiTabIdx]);
     2883            } break;
     2884          case( DMM4_IDX ):
     2885            {
     2886              if( uiWidth > 4 )
     2887              {
     2888                biSegmentation = new TComWedgelet( uiWidth, uiHeight );
     2889                xPredContourFromTex( pcCU, uiPartOffset, uiWidth, uiHeight, biSegmentation );
     2890              }
     2891            } break;
     2892          default: assert(0);
     2893          }
     2894
     2895          if( biSegmentation )
     2896          {
     2897            xSearchDmmDeltaDCs( pcCU, uiPartOffset, piOrg, piPred, uiStride, biSegmentation->getPattern(), biSegmentation->getStride(), uiWidth, uiHeight, deltaDC1, deltaDC2 );
     2898            pcCU->setDimDeltaDC( dmmType, 0, uiPartOffset, deltaDC1 );
     2899            pcCU->setDimDeltaDC( dmmType, 1, uiPartOffset, deltaDC2 );
     2900
     2901            uiRdModeList[ numModesForFullRD++ ] = (2*dmmType  +DIM_OFFSET);
     2902            uiRdModeList[ numModesForFullRD++ ] = (2*dmmType+1+DIM_OFFSET);
     2903
     2904            if( DMM4_IDX == dmmType ) { biSegmentation->destroy(); delete biSegmentation; }
     2905          }
     2906        }
     2907      }
     2908#endif
     2909#if H_3D_DIM_RBC
     2910      if( m_pcEncCfg->getUseRBC() )
     2911      {
     2912        if( xSearchRbcEdge( pcCU, uiPartOffset, piOrg, uiStride, uiWidth, uiHeight ) )
     2913        {
     2914          Pel deltaDC1 = 0; Pel deltaDC2 = 0;
     2915          xSearchRbcDeltaDCs( pcCU, uiPartOffset, piOrg, piPred, uiStride, pcCU->getEdgePartition( uiPartOffset ), uiWidth, uiWidth, uiHeight, deltaDC1, deltaDC2 );
     2916          pcCU->setDimDeltaDC( RBC_IDX, 0, uiPartOffset, deltaDC1 );
     2917          pcCU->setDimDeltaDC( RBC_IDX, 1, uiPartOffset, deltaDC2 );
     2918
     2919          uiRdModeList[ numModesForFullRD++ ] = (2*RBC_IDX  +DIM_OFFSET);
     2920          uiRdModeList[ numModesForFullRD++ ] = (2*RBC_IDX+1+DIM_OFFSET);
     2921        }
     2922      }
     2923#endif
     2924    }
     2925#endif
     2926
    26342927    //===== check modes (using r-d costs) =====
    26352928#if HHI_RQT_INTRA_SPEEDUP_MOD
     
    26462939    UInt    uiBestPUDistC = 0;
    26472940    Double  dBestPUCost   = MAX_DOUBLE;
     2941#if H_3D_DIM_SDC
     2942    Bool    bBestUseSDC   = false;
     2943    Pel     apBestDCOffsets[2] = {0,0};
     2944#endif
    26482945    for( UInt uiMode = 0; uiMode < numModesForFullRD; uiMode++ )
    26492946    {
     
    26532950      pcCU->setLumaIntraDirSubParts ( uiOrgMode, uiPartOffset, uiDepth + uiInitTrDepth );
    26542951     
     2952#if H_3D_DIM_SDC
     2953      Bool bTestSDC = ( m_pcEncCfg->getUseSDC() && pcCU->getSDCAvailable(uiPartOffset) );
     2954     
     2955      for( UInt uiSDC=0; uiSDC<=(bTestSDC?1:0); uiSDC++ )
     2956      {
     2957        pcCU->setSDCFlagSubParts( (uiSDC != 0), uiPartOffset, uiDepth + uiInitTrDepth );
     2958#endif
     2959     
     2960#if H_3D_DIM_ENC || H_3D_DIM_SDC
     2961      Bool bTestZeroResi = false;
     2962#if H_3D_DIM_ENC
     2963      bTestZeroResi |= pcCU->getSlice()->getIsDepth() && pcCU->getSlice()->isIRAP();
     2964#endif
     2965#if H_3D_DIM_SDC
     2966      bTestZeroResi |= pcCU->getSDCFlag(uiPartOffset);
     2967#endif
     2968#endif
     2969     
     2970#if H_3D_DIM_ENC || H_3D_DIM_SDC     
     2971      for( UInt testZeroResi = 0; testZeroResi <= (bTestZeroResi ? 1 : 0) ; testZeroResi++ )
     2972      {
     2973#endif
    26552974      // set context models
    26562975      if( m_bUseSBACRD )
     
    26732992      }
    26742993#endif
     2994#if H_3D_DIM_SDC
     2995            if( pcCU->getSDCFlag(uiPartOffset) )
     2996            {
     2997              pcCU->setTrIdxSubParts(0, uiPartOffset, uiDepth + uiInitTrDepth);
     2998              pcCU->setCbfSubParts(1, 1, 1, uiPartOffset, uiDepth + uiInitTrDepth);
     2999             
     3000              // start encoding with SDC
     3001              xIntraCodingSDC(pcCU, uiPartOffset, pcOrgYuv, pcPredYuv, uiPUDistY, dPUCost, (testZeroResi!=0));
     3002            }
     3003            else
     3004            {
     3005#endif
    26753006#if HHI_RQT_INTRA_SPEEDUP
     3007#if H_3D_DIM_ENC
     3008      xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, true, dPUCost, (testZeroResi != 0) );
     3009#else
    26763010      xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, true, dPUCost );
     3011#endif
     3012#else
     3013#if H_3D_DIM_ENC
     3014      xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, dPUCost, (testZeroResi != 0) );
    26773015#else
    26783016      xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, dPUCost );
     3017#endif
     3018#endif
     3019#if H_3D_DIM_SDC
     3020            }
    26793021#endif
    26803022     
     
    26903032        uiBestPUDistC = uiPUDistC;
    26913033        dBestPUCost   = dPUCost;
     3034       
     3035#if H_3D_DIM_SDC
     3036        if( pcCU->getSDCFlag(uiPartOffset) )
     3037        {
     3038          bBestUseSDC = true;
     3039         
     3040          // copy reconstruction
     3041          pcPredYuv->copyPartToPartYuv(pcRecoYuv, uiPartOffset, uiWidth, uiHeight);
     3042         
     3043          // copy DC values
     3044          apBestDCOffsets[0] = pcCU->getSDCSegmentDCOffset(0, uiPartOffset);
     3045          apBestDCOffsets[1] = pcCU->getSDCSegmentDCOffset(1, uiPartOffset);
     3046        }
     3047        else
     3048        {
     3049          bBestUseSDC = false;
     3050#endif
     3051        xSetIntraResultQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcRecoYuv );
     3052       
     3053        UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth(0) + uiInitTrDepth ) << 1 );
     3054        ::memcpy( m_puhQTTempTrIdx,  pcCU->getTransformIdx()       + uiPartOffset, uiQPartNum * sizeof( UChar ) );
     3055        ::memcpy( m_puhQTTempCbf[0], pcCU->getCbf( TEXT_LUMA     ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
     3056        ::memcpy( m_puhQTTempCbf[1], pcCU->getCbf( TEXT_CHROMA_U ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
     3057        ::memcpy( m_puhQTTempCbf[2], pcCU->getCbf( TEXT_CHROMA_V ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
     3058        ::memcpy( m_puhQTTempTransformSkipFlag[0], pcCU->getTransformSkip(TEXT_LUMA)     + uiPartOffset, uiQPartNum * sizeof( UChar ) );
     3059        ::memcpy( m_puhQTTempTransformSkipFlag[1], pcCU->getTransformSkip(TEXT_CHROMA_U) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
     3060        ::memcpy( m_puhQTTempTransformSkipFlag[2], pcCU->getTransformSkip(TEXT_CHROMA_V) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
     3061#if H_3D_DIM_SDC
     3062        }
     3063#endif
     3064      }
     3065#if HHI_RQT_INTRA_SPEEDUP_MOD
     3066      else if( dPUCost < dSecondBestPUCost )
     3067      {
     3068        uiSecondBestMode  = uiOrgMode;
     3069        dSecondBestPUCost = dPUCost;
     3070      }
     3071#endif
     3072#if H_3D_DIM_ENC || H_3D_DIM_SDC
     3073      }
     3074#endif
     3075#if H_3D_DIM_SDC
     3076      } // SDC loop
     3077#endif
     3078    } // Mode loop
     3079   
     3080#if HHI_RQT_INTRA_SPEEDUP
     3081#if HHI_RQT_INTRA_SPEEDUP_MOD
     3082    for( UInt ui =0; ui < 2; ++ui )
     3083#endif
     3084    {
     3085#if HHI_RQT_INTRA_SPEEDUP_MOD
     3086      UInt uiOrgMode   = ui ? uiSecondBestMode  : uiBestPUMode;
     3087      if( uiOrgMode == MAX_UINT )
     3088      {
     3089        break;
     3090      }
     3091#else
     3092      UInt uiOrgMode = uiBestPUMode;
     3093#endif
     3094     
     3095      pcCU->setLumaIntraDirSubParts ( uiOrgMode, uiPartOffset, uiDepth + uiInitTrDepth );
     3096#if H_3D_DIM_SDC
     3097      pcCU->setSDCFlagSubParts(false, uiPartOffset, uiDepth + uiInitTrDepth);
     3098#endif
     3099     
     3100      // set context models
     3101      if( m_bUseSBACRD )
     3102      {
     3103        m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
     3104      }
     3105     
     3106      // determine residual for partition
     3107#if H_3D_VSO
     3108      Dist   uiPUDistY = 0;
     3109#else
     3110      UInt   uiPUDistY = 0;
     3111#endif
     3112      UInt   uiPUDistC = 0;
     3113      Double dPUCost   = 0.0;
     3114
     3115#if H_3D_VSO // M37
     3116      // reset Model
     3117      if( m_pcRdCost->getUseRenModel() )
     3118      {
     3119        m_pcRdCost->setRenModelData( pcCU, uiPartOffset, piOrg, uiStride, uiWidth, uiHeight );
     3120      }
     3121#endif
     3122      xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, false, dPUCost );
     3123     
     3124      // check r-d cost
     3125      if( dPUCost < dBestPUCost )
     3126      {
     3127        uiBestPUMode  = uiOrgMode;
     3128        uiBestPUDistY = uiPUDistY;
     3129        uiBestPUDistC = uiPUDistC;
     3130        dBestPUCost   = dPUCost;
     3131#if H_3D_DIM_SDC
     3132        bBestUseSDC   = false;
     3133#endif
    26923134       
    26933135        xSetIntraResultQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcRecoYuv );
     
    27023144        ::memcpy( m_puhQTTempTransformSkipFlag[2], pcCU->getTransformSkip(TEXT_CHROMA_V) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    27033145      }
    2704 #if HHI_RQT_INTRA_SPEEDUP_MOD
    2705       else if( dPUCost < dSecondBestPUCost )
    2706       {
    2707         uiSecondBestMode  = uiOrgMode;
    2708         dSecondBestPUCost = dPUCost;
    2709       }
    2710 #endif
    2711     } // Mode loop
    2712    
    2713 #if HHI_RQT_INTRA_SPEEDUP
    2714 #if HHI_RQT_INTRA_SPEEDUP_MOD
    2715     for( UInt ui =0; ui < 2; ++ui )
    2716 #endif
    2717     {
    2718 #if HHI_RQT_INTRA_SPEEDUP_MOD
    2719       UInt uiOrgMode   = ui ? uiSecondBestMode  : uiBestPUMode;
    2720       if( uiOrgMode == MAX_UINT )
    2721       {
    2722         break;
    2723       }
    2724 #else
    2725       UInt uiOrgMode = uiBestPUMode;
    2726 #endif
    2727      
    2728       pcCU->setLumaIntraDirSubParts ( uiOrgMode, uiPartOffset, uiDepth + uiInitTrDepth );
    2729      
    2730       // set context models
    2731       if( m_bUseSBACRD )
    2732       {
    2733         m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
    2734       }
    2735      
    2736       // determine residual for partition
    2737 #if H_3D_VSO
    2738       Dist   uiPUDistY = 0;
    2739 #else
    2740       UInt   uiPUDistY = 0;
    2741 #endif
    2742       UInt   uiPUDistC = 0;
    2743       Double dPUCost   = 0.0;
    2744 
    2745 #if H_3D_VSO // M37
    2746       // reset Model
    2747       if( m_pcRdCost->getUseRenModel() )
    2748       {
    2749         m_pcRdCost->setRenModelData( pcCU, uiPartOffset, piOrg, uiStride, uiWidth, uiHeight );
    2750       }
    2751 #endif
    2752       xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, false, dPUCost );
    2753      
    2754       // check r-d cost
    2755       if( dPUCost < dBestPUCost )
    2756       {
    2757         uiBestPUMode  = uiOrgMode;
    2758         uiBestPUDistY = uiPUDistY;
    2759         uiBestPUDistC = uiPUDistC;
    2760         dBestPUCost   = dPUCost;
    2761        
    2762         xSetIntraResultQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcRecoYuv );
    2763        
    2764         UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth(0) + uiInitTrDepth ) << 1 );
    2765         ::memcpy( m_puhQTTempTrIdx,  pcCU->getTransformIdx()       + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    2766         ::memcpy( m_puhQTTempCbf[0], pcCU->getCbf( TEXT_LUMA     ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    2767         ::memcpy( m_puhQTTempCbf[1], pcCU->getCbf( TEXT_CHROMA_U ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    2768         ::memcpy( m_puhQTTempCbf[2], pcCU->getCbf( TEXT_CHROMA_V ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    2769         ::memcpy( m_puhQTTempTransformSkipFlag[0], pcCU->getTransformSkip(TEXT_LUMA)     + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    2770         ::memcpy( m_puhQTTempTransformSkipFlag[1], pcCU->getTransformSkip(TEXT_CHROMA_U) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    2771         ::memcpy( m_puhQTTempTransformSkipFlag[2], pcCU->getTransformSkip(TEXT_CHROMA_V) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    2772       }
    27733146    } // Mode loop
    27743147#endif
     
    27773150    uiOverallDistY += uiBestPUDistY;
    27783151    uiOverallDistC += uiBestPUDistC;
     3152   
     3153#if H_3D_DIM_SDC
     3154    if( bBestUseSDC )
     3155    {
     3156      pcCU->setTrIdxSubParts(0, uiPartOffset, uiDepth + uiInitTrDepth);
     3157      pcCU->setCbfSubParts(1, 1, 1, uiPartOffset, uiDepth + uiInitTrDepth);
     3158     
     3159      //=== copy best DC segment values back to CU ====
     3160      pcCU->setSDCSegmentDCOffset(apBestDCOffsets[0], 0, uiPartOffset);
     3161      pcCU->setSDCSegmentDCOffset(apBestDCOffsets[1], 1, uiPartOffset);
     3162    }
     3163    else
     3164    {
     3165#endif
    27793166   
    27803167    //--- update transform index and cbf ---
     
    27873174    ::memcpy( pcCU->getTransformSkip(TEXT_CHROMA_U) + uiPartOffset, m_puhQTTempTransformSkipFlag[1], uiQPartNum * sizeof( UChar ) );
    27883175    ::memcpy( pcCU->getTransformSkip(TEXT_CHROMA_V) + uiPartOffset, m_puhQTTempTransformSkipFlag[2], uiQPartNum * sizeof( UChar ) );
     3176#if H_3D_DIM_SDC
     3177    }
     3178#endif
    27893179    //--- set reconstruction for next intra prediction blocks ---
    27903180    if( uiPU != uiNumPU - 1 )
     
    28543244    //=== update PU data ====
    28553245    pcCU->setLumaIntraDirSubParts     ( uiBestPUMode, uiPartOffset, uiDepth + uiInitTrDepth );
     3246#if H_3D_DIM_SDC
     3247    pcCU->setSDCFlagSubParts          ( bBestUseSDC, uiPartOffset, uiDepth + uiInitTrDepth );
     3248#endif
    28563249    pcCU->copyToPic                   ( uiDepth, uiPU, uiInitTrDepth );
    28573250  } // PU loop
     
    61946587    // Reload only contexts required for coding intra mode information
    61956588    m_pcRDGoOnSbacCoder->loadIntraDirModeLuma( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
     6589#if H_3D_DIM
     6590    m_pcRDGoOnSbacCoder->loadIntraDepthMode( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
     6591#endif
    61966592  }
    61976593 
     
    65226918}
    65236919
     6920  // -------------------------------------------------------------------------------------------------------------------
     6921  // Depth intra search
     6922  // -------------------------------------------------------------------------------------------------------------------
     6923#if H_3D_DIM
     6924Void TEncSearch::xCalcBiSegDCs( Pel* ptrSrc, UInt srcStride, Bool* biSegPattern, Int patternStride, Pel& valDC1, Pel& valDC2 )
     6925{
     6926  valDC1 = ( 1<<( g_bitDepthY - 1) );
     6927  valDC2 = ( 1<<( g_bitDepthY - 1) );
     6928
     6929  UInt uiDC1 = 0;
     6930  UInt uiDC2 = 0;
     6931  UInt uiNumPixDC1 = 0, uiNumPixDC2 = 0;
     6932  if( srcStride == patternStride )
     6933  {
     6934    for( UInt k = 0; k < (patternStride * patternStride); k++ )
     6935    {
     6936      if( true == biSegPattern[k] )
     6937      {
     6938        uiDC2 += ptrSrc[k];
     6939        uiNumPixDC2++;
     6940      }
     6941      else
     6942      {
     6943        uiDC1 += ptrSrc[k];
     6944        uiNumPixDC1++;
     6945      }
     6946    }
     6947  }
     6948  else
     6949  {
     6950    Pel* piTemp = ptrSrc;
     6951    for( UInt uiY = 0; uiY < patternStride; uiY++ )
     6952    {
     6953      for( UInt uiX = 0; uiX < patternStride; uiX++ )
     6954      {
     6955        if( true == biSegPattern[uiX] )
     6956        {
     6957          uiDC2 += piTemp[uiX];
     6958          uiNumPixDC2++;
     6959        }
     6960        else
     6961        {
     6962          uiDC1 += piTemp[uiX];
     6963          uiNumPixDC1++;
     6964        }
     6965      }
     6966      piTemp       += srcStride;
     6967      biSegPattern += patternStride;
     6968    }
     6969  }
     6970
     6971  if( uiNumPixDC1 > 0 ) { valDC1 = uiDC1 / uiNumPixDC1; }
     6972  if( uiNumPixDC2 > 0 ) { valDC2 = uiDC2 / uiNumPixDC2; }
     6973}
     6974
     6975#if H_3D_DIM_DMM
     6976Void TEncSearch::xSearchDmmDeltaDCs( TComDataCU* pcCU, UInt uiAbsPtIdx, Pel* piOrig, Pel* piPredic, UInt uiStride, Bool* biSegPattern, Int patternStride, UInt uiWidth, UInt uiHeight, Pel& rDeltaDC1, Pel& rDeltaDC2 )
     6977{
     6978  assert( biSegPattern );
     6979  Pel origDC1 = 0; Pel origDC2 = 0;
     6980  xCalcBiSegDCs  ( piOrig,   uiStride, biSegPattern, patternStride, origDC1, origDC2 );
     6981  xAssignBiSegDCs( piPredic, uiStride, biSegPattern, patternStride, origDC1, origDC2 );
     6982
     6983  Int* piMask = pcCU->getPattern()->getAdiOrgBuf( uiWidth, uiHeight, m_piYuvExt ); // no filtering for DMM
     6984  Int  maskStride = 2*uiWidth + 1;
     6985  Int* ptrSrc = piMask+maskStride+1;
     6986  Pel  predDC1 = 0; Pel predDC2 = 0;
     6987  xPredBiSegDCs( ptrSrc, maskStride, biSegPattern, patternStride, predDC1, predDC2 );
     6988
     6989  rDeltaDC1 = origDC1 - predDC1;
     6990  rDeltaDC2 = origDC2 - predDC2;
     6991
     6992#if H_3D_VSO
     6993  if( m_pcRdCost->getUseVSO() )
     6994  {
     6995    Pel fullDeltaDC1 = rDeltaDC1;
     6996    Pel fullDeltaDC2 = rDeltaDC2;
     6997
     6998    Dist uiBestDist      = RDO_DIST_MAX;
     6999    UInt  uiBestQStepDC1 = 0;
     7000    UInt  uiBestQStepDC2 = 0;
     7001
     7002    UInt uiDeltaDC1Max = abs(fullDeltaDC1);
     7003    UInt uiDeltaDC2Max = abs(fullDeltaDC2);
     7004
     7005    //VSO Level delta DC check range extension
     7006    uiDeltaDC1Max += (uiDeltaDC1Max>>1);
     7007    uiDeltaDC2Max += (uiDeltaDC2Max>>1);
     7008
     7009    // limit search range to [0, IBDI_MAX]
     7010    if( fullDeltaDC1 <  0 && uiDeltaDC1Max >                          abs(predDC1) ) { uiDeltaDC1Max =                          abs(predDC1); }
     7011    if( fullDeltaDC1 >= 0 && uiDeltaDC1Max > ((1 << g_bitDepthY)-1) - abs(predDC1) ) { uiDeltaDC1Max = ((1 << g_bitDepthY)-1) - abs(predDC1); }
     7012
     7013    if( fullDeltaDC2 <  0 && uiDeltaDC2Max >                          abs(predDC2) ) { uiDeltaDC2Max =                          abs(predDC2); }
     7014    if( fullDeltaDC2 >= 0 && uiDeltaDC2Max > ((1 << g_bitDepthY)-1) - abs(predDC2) ) { uiDeltaDC2Max = ((1 << g_bitDepthY)-1) - abs(predDC2); }
     7015
     7016    // init dist with original segment DCs
     7017    xAssignBiSegDCs( piPredic, uiStride, biSegPattern, patternStride, origDC1, origDC2 );
     7018
     7019    Dist uiOrgDist = RDO_DIST_MAX;
     7020    if( m_pcRdCost->getUseEstimatedVSD() )
     7021    {
     7022      uiOrgDist = m_pcRdCost->getDistPartVSD( pcCU, uiAbsPtIdx, piPredic, uiStride, piOrig, uiStride, uiWidth, uiHeight, false );
     7023    }
     7024    else
     7025    {
     7026      uiOrgDist = m_pcRdCost->getDistPartVSO( pcCU, uiAbsPtIdx, piPredic, uiStride, piOrig, uiStride, uiWidth, uiHeight, false );
     7027    }
     7028
     7029    uiBestDist     = uiOrgDist;
     7030    uiBestQStepDC1 = abs(fullDeltaDC1);
     7031    uiBestQStepDC2 = abs(fullDeltaDC2);
     7032
     7033    // coarse search with step size 4
     7034    for( UInt uiQStepDC1 = 0; uiQStepDC1 < uiDeltaDC1Max; uiQStepDC1 += 4 )
     7035    {
     7036      Pel testDC1 = ClipY( predDC1 + ((Int)(uiQStepDC1) * (( fullDeltaDC1 < 0 ) ? -1 : 1)) );
     7037      for( UInt uiQStepDC2 = 0; uiQStepDC2 < uiDeltaDC2Max; uiQStepDC2 += 4 )
     7038      {
     7039        Pel testDC2 = ClipY( predDC2 + ((Int)(uiQStepDC2) * (( fullDeltaDC2 < 0 ) ? -1 : 1)) );
     7040
     7041        xAssignBiSegDCs( piPredic, uiStride, biSegPattern, patternStride, testDC1, testDC2 );
     7042
     7043        Dist uiAct4Dist = RDO_DIST_MAX;
     7044        if( m_pcRdCost->getUseEstimatedVSD() )
     7045        {
     7046          uiAct4Dist = m_pcRdCost->getDistPartVSD( pcCU, uiAbsPtIdx, piPredic, uiStride, piOrig, uiStride, uiWidth, uiHeight, false );
     7047        }
     7048        else
     7049        {
     7050          uiAct4Dist = m_pcRdCost->getDistPartVSO( pcCU, uiAbsPtIdx, piPredic, uiStride, piOrig, uiStride, uiWidth, uiHeight, false );
     7051        }
     7052
     7053        if( uiAct4Dist < uiBestDist || uiBestDist == RDO_DIST_MAX )
     7054        {
     7055          uiBestDist     = uiAct4Dist;
     7056          uiBestQStepDC1 = uiQStepDC1;
     7057          uiBestQStepDC2 = uiQStepDC2;
     7058        }
     7059      }
     7060    }
     7061
     7062    // refinement +-3
     7063    for( UInt uiQStepDC1 = (UInt)max(0, ((Int)uiBestQStepDC1-3)); uiQStepDC1 <= (uiBestQStepDC1+3); uiQStepDC1++ )
     7064    {
     7065      Pel testDC1 = ClipY( predDC1 + ((Int)(uiQStepDC1) * (( fullDeltaDC1 < 0 ) ? -1 : 1)) );
     7066      for( UInt uiQStepDC2 = (UInt)max(0, ((Int)uiBestQStepDC2-3)); uiQStepDC2 <= (uiBestQStepDC2+3); uiQStepDC2++ )
     7067      {
     7068        Pel testDC2 = ClipY( predDC2 + ((Int)(uiQStepDC2) * (( fullDeltaDC2 < 0 ) ? -1 : 1)) );
     7069
     7070        xAssignBiSegDCs( piPredic, uiStride, biSegPattern, patternStride, testDC1, testDC2 );
     7071
     7072        Dist uiActDist = RDO_DIST_MAX;
     7073        if( m_pcRdCost->getUseEstimatedVSD() )
     7074        {
     7075          uiActDist = m_pcRdCost->getDistPartVSD( pcCU, uiAbsPtIdx, piPredic, uiStride, piOrig, uiStride, uiWidth, uiHeight, false );
     7076        }
     7077        else
     7078        {
     7079          uiActDist = m_pcRdCost->getDistPartVSO( pcCU, uiAbsPtIdx, piPredic, uiStride, piOrig, uiStride, uiWidth, uiHeight, false );
     7080        }
     7081
     7082        if( uiActDist < uiBestDist || uiBestDist == RDO_DIST_MAX )
     7083        {
     7084          uiBestDist     = uiActDist;
     7085          uiBestQStepDC1 = uiQStepDC1;
     7086          uiBestQStepDC2 = uiQStepDC2;
     7087        }
     7088      }
     7089    }
     7090    rDeltaDC1 = (Int)(uiBestQStepDC1) * (Int)(( fullDeltaDC1 < 0 ) ? -1 : 1);
     7091    rDeltaDC2 = (Int)(uiBestQStepDC2) * (Int)(( fullDeltaDC2 < 0 ) ? -1 : 1);
     7092  }
     7093#endif
     7094
     7095#if H_3D_DIM_DLT
     7096  rDeltaDC1 = pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), ClipY(predDC1 + rDeltaDC1) ) - pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC1 );
     7097  rDeltaDC2 = pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), ClipY(predDC2 + rDeltaDC2) ) - pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC2 );
     7098#endif
     7099}
     7100
     7101Void TEncSearch::xSearchDmm1Wedge( TComDataCU* pcCU, UInt uiAbsPtIdx, Pel* piRef, UInt uiRefStride, UInt uiWidth, UInt uiHeight, UInt& ruiTabIdx )
     7102{
     7103  ruiTabIdx = 0;
     7104
     7105  // local pred buffer
     7106  TComYuv cPredYuv;
     7107  cPredYuv.create( uiWidth, uiHeight );
     7108  cPredYuv.clear();
     7109
     7110  UInt uiPredStride = cPredYuv.getStride();
     7111  Pel* piPred       = cPredYuv.getLumaAddr();
     7112
     7113  Pel refDC1 = 0; Pel refDC2 = 0;
     7114  WedgeList*     pacWedgeList     = &g_dmmWedgeLists    [(g_aucConvertToBit[uiWidth])];
     7115  WedgeNodeList* pacWedgeNodeList = &g_dmmWedgeNodeLists[(g_aucConvertToBit[uiWidth])];
     7116
     7117  // coarse wedge search
     7118  Dist uiBestDist   = RDO_DIST_MAX;
     7119  UInt uiBestNodeId = 0;
     7120  for( UInt uiNodeId = 0; uiNodeId < pacWedgeNodeList->size(); uiNodeId++ )
     7121  {
     7122    TComWedgelet* pcWedgelet = &(pacWedgeList->at(pacWedgeNodeList->at(uiNodeId).getPatternIdx()));
     7123    xCalcBiSegDCs  ( piRef,  uiRefStride,  pcWedgelet->getPattern(), pcWedgelet->getStride(), refDC1, refDC2 );
     7124    xAssignBiSegDCs( piPred, uiPredStride, pcWedgelet->getPattern(), pcWedgelet->getStride(), refDC1, refDC2 );
     7125
     7126    Dist uiActDist = RDO_DIST_MAX;
     7127#if H_3D_VSO
     7128    if( m_pcRdCost->getUseVSO() )
     7129    {
     7130      if( m_pcRdCost->getUseEstimatedVSD() )
     7131      {
     7132        uiActDist = m_pcRdCost->getDistPartVSD( pcCU, uiAbsPtIdx, piPred, uiPredStride, piRef, uiRefStride, uiWidth, uiHeight, false );
     7133      }
     7134      else
     7135      {
     7136        uiActDist = m_pcRdCost->getDistPartVSO( pcCU, uiAbsPtIdx, piPred, uiPredStride, piRef, uiRefStride, uiWidth, uiHeight, false );
     7137      }
     7138    }
     7139    else
     7140#endif
     7141    {
     7142      uiActDist = m_pcRdCost->getDistPart( g_bitDepthY, piPred, uiPredStride, piRef, uiRefStride, uiWidth, uiHeight, TEXT_LUMA, DF_SAD );
     7143    }
     7144
     7145    if( uiActDist < uiBestDist || uiBestDist == RDO_DIST_MAX )
     7146    {
     7147      uiBestDist   = uiActDist;
     7148      uiBestNodeId = uiNodeId;
     7149    }
     7150  }
     7151
     7152  // refinement
     7153  Dist uiBestDistRef = uiBestDist;
     7154  UInt uiBestTabIdxRef  = pacWedgeNodeList->at(uiBestNodeId).getPatternIdx();
     7155  for( UInt uiRefId = 0; uiRefId < DMM_NUM_WEDGE_REFINES; uiRefId++ )
     7156  {
     7157    if( pacWedgeNodeList->at(uiBestNodeId).getRefineIdx( uiRefId ) != DMM_NO_WEDGEINDEX )
     7158    {
     7159      TComWedgelet* pcWedgelet = &(pacWedgeList->at(pacWedgeNodeList->at(uiBestNodeId).getRefineIdx( uiRefId )));
     7160      xCalcBiSegDCs  ( piRef,  uiRefStride,  pcWedgelet->getPattern(), pcWedgelet->getStride(), refDC1, refDC2 );
     7161      xAssignBiSegDCs( piPred, uiPredStride, pcWedgelet->getPattern(), pcWedgelet->getStride(), refDC1, refDC2 );
     7162
     7163      Dist uiActDist = RDO_DIST_MAX;
     7164#if H_3D_VSO
     7165      if( m_pcRdCost->getUseVSO() )
     7166      {
     7167        if( m_pcRdCost->getUseEstimatedVSD() ) //PM: use VSO instead of VSD here?
     7168        {
     7169          uiActDist = m_pcRdCost->getDistPartVSD( pcCU, uiAbsPtIdx, piPred, uiPredStride, piRef, uiRefStride, uiWidth, uiHeight, false );
     7170        }
     7171        else
     7172        {
     7173          uiActDist = m_pcRdCost->getDistPartVSO( pcCU, uiAbsPtIdx, piPred, uiPredStride, piRef, uiRefStride, uiWidth, uiHeight, false );
     7174        }
     7175      }
     7176      else
     7177#endif
     7178      {
     7179        uiActDist = m_pcRdCost->getDistPart( g_bitDepthY, piPred, uiPredStride, piRef, uiRefStride, uiWidth, uiHeight, TEXT_LUMA, DF_SAD );
     7180      }
     7181
     7182      if( uiActDist < uiBestDistRef || uiBestDistRef == RDO_DIST_MAX )
     7183      {
     7184        uiBestDistRef   = uiActDist;
     7185        uiBestTabIdxRef = pacWedgeNodeList->at(uiBestNodeId).getRefineIdx( uiRefId );
     7186      }
     7187    }
     7188  }
     7189
     7190  ruiTabIdx = uiBestTabIdxRef;
     7191
     7192  cPredYuv.destroy();
     7193  return;
     7194}
     7195
     7196Void TEncSearch::xSearchDmm2Wedge( TComDataCU* pcCU, UInt uiAbsPtIdx, Pel* piRef, UInt uiRefStride, UInt uiWidth, UInt uiHeight, UInt& ruiTabIdx, Int& riWedgeDeltaEnd )
     7197{
     7198  ruiTabIdx       = 0;
     7199  riWedgeDeltaEnd = 0;
     7200
     7201  // local pred buffer
     7202  TComYuv cPredYuv;
     7203  cPredYuv.create( uiWidth, uiHeight );
     7204  cPredYuv.clear();
     7205
     7206  UInt uiPredStride = cPredYuv.getStride();
     7207  Pel* piPred       = cPredYuv.getLumaAddr();
     7208
     7209
     7210  // regular wedge search
     7211  Dist uiBestDist    = RDO_DIST_MAX;
     7212  UInt uiBestTabIdx  = 0;
     7213  Int  iBestDeltaEnd = 0;
     7214
     7215  UInt uiIdx = 0;
     7216  Pel refDC1 = 0; Pel refDC2 = 0;
     7217  for( Int iTestDeltaEnd = -DMM2_DELTAEND_MAX; iTestDeltaEnd <= DMM2_DELTAEND_MAX; iTestDeltaEnd++ )
     7218  {
     7219    uiIdx = xPredWedgeFromIntra( pcCU, uiAbsPtIdx, uiWidth, uiHeight, iTestDeltaEnd );
     7220    TComWedgelet* pcWedgelet = &(g_dmmWedgeLists[(g_aucConvertToBit[uiWidth])][uiIdx]);
     7221    xCalcBiSegDCs  ( piRef,  uiRefStride,  pcWedgelet->getPattern(), pcWedgelet->getStride(), refDC1, refDC2 );
     7222    xAssignBiSegDCs( piPred, uiPredStride, pcWedgelet->getPattern(), pcWedgelet->getStride(), refDC1, refDC2 );
     7223
     7224    Dist uiActDist = RDO_DIST_MAX;
     7225#if H_3D_VSO
     7226    if( m_pcRdCost->getUseVSO() )
     7227    {
     7228      if( m_pcRdCost->getUseEstimatedVSD() )
     7229      {
     7230        uiActDist = m_pcRdCost->getDistPartVSD( pcCU, uiAbsPtIdx, piPred, uiPredStride, piRef, uiRefStride, uiWidth, uiHeight, false );
     7231      }
     7232      else
     7233      {
     7234        uiActDist = m_pcRdCost->getDistPartVSO( pcCU, uiAbsPtIdx, piPred, uiPredStride, piRef, uiRefStride, uiWidth, uiHeight, false );
     7235      }
     7236    }
     7237    else
     7238#endif
     7239    {
     7240      uiActDist = m_pcRdCost->getDistPart( g_bitDepthY, piPred, uiPredStride, piRef, uiRefStride, uiWidth, uiHeight, TEXT_LUMA, DF_SAD );
     7241    }
     7242
     7243    if( uiActDist < uiBestDist || uiBestDist == RDO_DIST_MAX )
     7244    {
     7245      uiBestDist    = uiActDist;
     7246      uiBestTabIdx  = uiIdx;
     7247      iBestDeltaEnd = iTestDeltaEnd;
     7248    }
     7249    else if( uiIdx == uiBestTabIdx && abs(iTestDeltaEnd) < abs(iBestDeltaEnd) )
     7250    {
     7251      iBestDeltaEnd = iTestDeltaEnd;
     7252    }
     7253  }
     7254
     7255  ruiTabIdx       = uiBestTabIdx;
     7256  riWedgeDeltaEnd = iBestDeltaEnd;
     7257
     7258  cPredYuv.destroy();
     7259  return;
     7260}
     7261
     7262Void TEncSearch::xSearchDmm3Wedge( TComDataCU* pcCU, UInt uiAbsPtIdx, Pel* piRef, UInt uiRefStride, UInt uiWidth, UInt uiHeight, UInt& ruiTabIdx, UInt& ruiIntraTabIdx )
     7263{
     7264  ruiTabIdx       = 0;
     7265  ruiIntraTabIdx  = 0;
     7266
     7267  // local pred buffer
     7268  TComYuv cPredYuv;
     7269  cPredYuv.create( uiWidth, uiHeight );
     7270  cPredYuv.clear();
     7271  Pel* piPred = cPredYuv.getLumaAddr();
     7272  UInt uiPredStride = cPredYuv.getStride();
     7273
     7274  // wedge search
     7275  UInt uiBestDist = MAX_UINT;
     7276  WedgeList* pacWedgeList = &g_dmmWedgeLists[(g_aucConvertToBit[uiWidth])];
     7277  Pel refDC1 = 0; Pel refDC2 = 0;
     7278
     7279  TComPic*      pcPicTex = pcCU->getSlice()->getPicLists()->getPic( pcCU->getSlice()->getViewIndex(), false, pcCU->getSlice()->getPOC() );
     7280  assert( pcPicTex != NULL );
     7281  TComDataCU* pcColTexCU = pcPicTex->getCU(pcCU->getAddr());
     7282  UInt      uiTexPartIdx = pcCU->getZorderIdxInCU() + uiAbsPtIdx;
     7283  Int   uiColTexIntraDir = pcColTexCU->isIntra( uiTexPartIdx ) ? pcColTexCU->getLumaIntraDir( uiTexPartIdx ) : 255;
     7284
     7285  std::vector< std::vector<UInt> > pauiWdgLstSz = g_aauiWdgLstM3[g_aucConvertToBit[uiWidth]];
     7286  if( uiColTexIntraDir > DC_IDX && uiColTexIntraDir < 35 )
     7287  {
     7288    std::vector<UInt>* pauiWdgLst = &pauiWdgLstSz[uiColTexIntraDir-2];
     7289    for( UInt uiIdxW = 0; uiIdxW < pauiWdgLst->size(); uiIdxW++ )
     7290    {
     7291      UInt uiIdx     =   pauiWdgLst->at(uiIdxW);
     7292      TComWedgelet* pcWedgelet = &(pacWedgeList->at(uiIdx));
     7293      xCalcBiSegDCs  ( piRef,  uiRefStride,  pcWedgelet->getPattern(), pcWedgelet->getStride(), refDC1, refDC2 );
     7294      xAssignBiSegDCs( piPred, uiPredStride, pcWedgelet->getPattern(), pcWedgelet->getStride(), refDC1, refDC2 );
     7295
     7296      UInt uiActDist = m_pcRdCost->getDistPart( g_bitDepthY, piPred, uiPredStride, piRef, uiRefStride, uiWidth, uiHeight, TEXT_LUMA, DF_SAD );
     7297      if( uiActDist < uiBestDist || uiBestDist == MAX_UINT )
     7298      {
     7299        uiBestDist     = uiActDist;
     7300        ruiTabIdx      = uiIdx;
     7301        ruiIntraTabIdx = uiIdxW;
     7302      }
     7303    }
     7304  }
     7305  else
     7306  {
     7307    WedgeNodeList* pacWedgeNodeList = &g_dmmWedgeNodeLists[(g_aucConvertToBit[uiWidth])];
     7308    UInt uiBestNodeDist = MAX_UINT;
     7309    UInt uiBestNodeId   = 0;
     7310    for( UInt uiNodeId = 0; uiNodeId < pacWedgeNodeList->size(); uiNodeId++ )
     7311    {
     7312      TComWedgelet* pcWedgelet = &(pacWedgeList->at(pacWedgeNodeList->at(uiNodeId).getPatternIdx()));
     7313      xCalcBiSegDCs  ( piRef,  uiRefStride,  pcWedgelet->getPattern(), pcWedgelet->getStride(), refDC1, refDC2 );
     7314      xAssignBiSegDCs( piPred, uiPredStride, pcWedgelet->getPattern(), pcWedgelet->getStride(), refDC1, refDC2 );
     7315
     7316      UInt uiActDist = m_pcRdCost->getDistPart( g_bitDepthY, piPred, uiPredStride, piRef, uiRefStride, uiWidth, uiHeight, TEXT_LUMA, DF_SAD );
     7317      if( uiActDist < uiBestNodeDist || uiBestNodeDist == MAX_UINT )
     7318      {
     7319        uiBestNodeDist = uiActDist;
     7320        uiBestNodeId   = uiNodeId;
     7321        ruiIntraTabIdx = uiNodeId;
     7322      }
     7323    }
     7324    ruiTabIdx = pacWedgeNodeList->at(uiBestNodeId).getPatternIdx();
     7325  }
     7326
     7327  cPredYuv.destroy();
     7328}
     7329#endif
     7330#if H_3D_DIM_RBC
     7331Void TEncSearch::xSearchRbcDeltaDCs( TComDataCU* pcCU, UInt uiAbsPtIdx, Pel* piOrig, Pel* piPredic, UInt uiStride, Bool* biSegPattern, Int patternStride, UInt uiWidth, UInt uiHeight, Pel& rDeltaDC1, Pel& rDeltaDC2 )
     7332{
     7333  assert( biSegPattern );
     7334  Pel origDC1 = 0; Pel origDC2 = 0;
     7335  xCalcBiSegDCs  ( piOrig,   uiStride, biSegPattern, patternStride, origDC1, origDC2 );
     7336  xAssignBiSegDCs( piPredic, uiStride, biSegPattern, patternStride, origDC1, origDC2 );
     7337
     7338  Int* piMask = pcCU->getPattern()->getAdiOrgBuf( uiWidth, uiHeight, m_piYuvExt ); // no filtering for DMM
     7339  Int  maskStride = 2*uiWidth + 1;
     7340  Int* ptrSrc = piMask+maskStride+1;
     7341  Pel  predDC1 = 0; Pel predDC2 = 0;
     7342  xPredBiSegDCs( ptrSrc, maskStride, biSegPattern, patternStride, predDC1, predDC2 );
     7343
     7344  rDeltaDC1 = origDC1 - predDC1;
     7345  rDeltaDC2 = origDC2 - predDC2;
     7346
     7347#if H_3D_VSO
     7348  if( m_pcRdCost->getUseVSO() )
     7349  {
     7350    Pel fullDeltaDC1 = rDeltaDC1;
     7351    Pel fullDeltaDC2 = rDeltaDC2;
     7352
     7353    xDeltaDCQuantScaleDown( pcCU, fullDeltaDC1 );
     7354    xDeltaDCQuantScaleDown( pcCU, fullDeltaDC2 );
     7355
     7356    Dist uiBestDist     = RDO_DIST_MAX;
     7357    UInt uiBestQStepDC1 = 0;
     7358    UInt uiBestQStepDC2 = 0;
     7359
     7360    UInt uiDeltaDC1Max = abs(fullDeltaDC1);
     7361    UInt uiDeltaDC2Max = abs(fullDeltaDC2);
     7362
     7363    //VSO Level delta DC check range extension
     7364    uiDeltaDC1Max += (uiDeltaDC1Max>>1);
     7365    uiDeltaDC2Max += (uiDeltaDC2Max>>1);
     7366
     7367    for( UInt uiQStepDC1 = 1; uiQStepDC1 <= uiDeltaDC1Max; uiQStepDC1++  )
     7368    {
     7369      Pel iLevelDeltaDC1 = (Pel)(uiQStepDC1) * (Pel)(( fullDeltaDC1 < 0 ) ? -1 : 1);
     7370      xDeltaDCQuantScaleUp( pcCU, iLevelDeltaDC1 );
     7371      Pel testDC1 = ClipY( predDC1 + iLevelDeltaDC1 );
     7372
     7373      for( UInt uiQStepDC2 = 1; uiQStepDC2 <= uiDeltaDC2Max; uiQStepDC2++  )
     7374      {
     7375        Pel iLevelDeltaDC2 = (Pel)(uiQStepDC2) * (Pel)(( fullDeltaDC2 < 0 ) ? -1 : 1);
     7376        xDeltaDCQuantScaleUp( pcCU, iLevelDeltaDC2 );
     7377        Pel testDC2 = ClipY( predDC2 + iLevelDeltaDC2 );
     7378
     7379        xAssignBiSegDCs( piPredic, uiStride, biSegPattern, patternStride, testDC1, testDC2 );
     7380
     7381        Dist uiActDist = RDO_DIST_MAX;
     7382        if( m_pcRdCost->getUseEstimatedVSD() )
     7383        {
     7384          uiActDist = m_pcRdCost->getDistPartVSD( pcCU, uiAbsPtIdx, piPredic, uiStride, piOrig, uiStride, uiWidth, uiHeight, false );
     7385        }
     7386        else
     7387        {
     7388          uiActDist = m_pcRdCost->getDistPartVSO( pcCU, uiAbsPtIdx, piPredic, uiStride, piOrig, uiStride, uiWidth, uiHeight, false );
     7389        }
     7390
     7391        if( uiActDist < uiBestDist || uiBestDist == RDO_DIST_MAX )
     7392        {
     7393          uiBestDist     = uiActDist;
     7394          uiBestQStepDC1 = uiQStepDC1;
     7395          uiBestQStepDC2 = uiQStepDC2;
     7396        }
     7397      }
     7398    }
     7399
     7400    fullDeltaDC1 = (Int)(uiBestQStepDC1) * (Int)(( fullDeltaDC1 < 0 ) ? -1 : 1);
     7401    fullDeltaDC2 = (Int)(uiBestQStepDC2) * (Int)(( fullDeltaDC2 < 0 ) ? -1 : 1);
     7402    xDeltaDCQuantScaleUp( pcCU, fullDeltaDC1 );
     7403    xDeltaDCQuantScaleUp( pcCU, fullDeltaDC2 );
     7404    rDeltaDC1 = fullDeltaDC1;
     7405    rDeltaDC2 = fullDeltaDC2;
     7406  }
     7407#endif
     7408
     7409  xDeltaDCQuantScaleDown( pcCU, rDeltaDC1 );
     7410  xDeltaDCQuantScaleDown( pcCU, rDeltaDC2 );
     7411}
     7412
     7413Bool TEncSearch::xSearchRbcEdge( TComDataCU* pcCU, UInt uiAbsPtIdx, Pel* piRef, UInt uiRefStride, Int iWidth, Int iHeight )
     7414{
     7415  Bool* pbEdge  = (Bool*) xMalloc( Bool, iWidth * iHeight * 4 );
     7416
     7417  Short* psDiffX = new Short[ iWidth * iHeight ];
     7418  Short* psDiffY = new Short[ iWidth * iHeight ];
     7419  Bool*  pbEdgeX = new Bool [ iWidth * iHeight ];
     7420  Bool*  pbEdgeY = new Bool [ iWidth * iHeight ];
     7421
     7422  // Find Horizontal Gradient & Edge Detection ((x+1, y) - (x,y))
     7423  for( Int y=0; y<iHeight; y++ )
     7424  {
     7425    Short* psDiffXPtr = &psDiffX[ y * iHeight ];
     7426    Bool*  pbEdgeXPtr = &pbEdgeX[ y * iHeight ];
     7427    for(Int x=0; x<iWidth-1; x++ )
     7428    {
     7429      *psDiffXPtr = piRef[ x+1 + y*uiRefStride ] - piRef[ x + y*uiRefStride ];
     7430      if(*psDiffXPtr >= RBC_THRESHOLD || *psDiffXPtr <= (-1)*RBC_THRESHOLD)
     7431      {
     7432        *pbEdgeXPtr = true;
     7433      }
     7434      else
     7435      {
     7436        *pbEdgeXPtr = false;
     7437      }
     7438
     7439      psDiffXPtr++;
     7440      pbEdgeXPtr++;
     7441    }
     7442  }
     7443
     7444  // Find Vertical Gradient & Edge Detection((x,y+1) - (x,y))
     7445  for( Int y=0; y<iHeight-1; y++ )
     7446  {
     7447    Short* psDiffYPtr = &psDiffY[ y * iHeight ];
     7448    Bool*  pbEdgeYPtr = &pbEdgeY[ y * iHeight ];
     7449    for(Int x=0; x<iWidth; x++ )
     7450    {
     7451      *psDiffYPtr = piRef[ x + (y+1)*uiRefStride ] - piRef[ x + y*uiRefStride ];
     7452      if(*psDiffYPtr >= RBC_THRESHOLD || *psDiffYPtr <= (-1)*RBC_THRESHOLD)
     7453      {
     7454        *pbEdgeYPtr = true;
     7455      }
     7456      else
     7457      {
     7458        *pbEdgeYPtr = false;
     7459      }
     7460
     7461      psDiffYPtr++;
     7462      pbEdgeYPtr++;
     7463    }
     7464  }
     7465
     7466  // Eliminate local maximum
     7467  for( Int y=0; y<iHeight; y++ )
     7468  {
     7469    Short* psDiffXPtr = &psDiffX[ y * iHeight ];
     7470    Bool*  pbEdgeXPtr = &pbEdgeX[ y * iHeight ];
     7471    for( Int x=0; x<iWidth-1; x++ )
     7472    {
     7473      UShort usAbs0=0, usAbs1=0, usAbs2=0;  // 0 : left, 1 : current, 2 : right
     7474
     7475      if( x > 0 && *(pbEdgeXPtr-1) == true )
     7476      {
     7477        if( *(psDiffXPtr-1) >= 0)
     7478        {
     7479          usAbs0 = *(psDiffXPtr-1);
     7480
     7481        }
     7482        else
     7483        {
     7484          usAbs0 = (-1) * *(psDiffXPtr-1);
     7485        }
     7486      }
     7487      if( *pbEdgeXPtr == true )
     7488      {
     7489        if( *(psDiffXPtr) >= 0)
     7490        {
     7491          usAbs1 = *(psDiffXPtr);
     7492        }
     7493        else
     7494        {
     7495          usAbs1 = (-1) * *(psDiffXPtr);
     7496        }
     7497      }
     7498      if( x < iWidth-2 && *(pbEdgeXPtr+1) == true )
     7499      {
     7500        if( *(psDiffXPtr+1) >= 0)
     7501        {
     7502          usAbs2 = *(psDiffXPtr+1);
     7503          //bSign2 = true;
     7504        }
     7505        else
     7506        {
     7507          usAbs2 = (-1) * *(psDiffXPtr+1);
     7508        }
     7509      }
     7510
     7511      if( x == 0 )
     7512      {
     7513        if( usAbs1 < usAbs2 )
     7514        {
     7515          *pbEdgeXPtr = false;
     7516        }
     7517      }
     7518      else if( x == iWidth-2 )
     7519      {
     7520        if( usAbs1 <= usAbs0 )
     7521          *pbEdgeXPtr = false;
     7522      }
     7523      else
     7524      {
     7525        if( usAbs2 > usAbs0 )
     7526        {
     7527          if( usAbs1 < usAbs2 )
     7528            *pbEdgeXPtr = false;
     7529        }
     7530        else
     7531        {
     7532          if( usAbs1 <= usAbs0 )
     7533            *pbEdgeXPtr = false;
     7534        }
     7535      }
     7536
     7537      psDiffXPtr++;
     7538      pbEdgeXPtr++;
     7539    }
     7540  }
     7541
     7542  for( Int y=0; y<iHeight-1; y++ )
     7543  {
     7544    Short* psDiffYPtr = &psDiffY[ y * iWidth ];
     7545    Bool*  pbEdgeYPtr = &pbEdgeY[ y * iWidth ];
     7546    for( Int x=0; x<iWidth; x++ )
     7547    {
     7548      UShort usAbs0=0, usAbs1=0, usAbs2=0;  // 0 : upper, 1 : current, 2 : bottom
     7549      if( y > 0 && *(pbEdgeYPtr-iWidth) == true )
     7550      {
     7551        if( *(psDiffYPtr-iWidth) >= 0)
     7552        {
     7553          usAbs0 = *(psDiffYPtr-iWidth);
     7554        }
     7555        else
     7556        {
     7557          usAbs0 = (-1) * *(psDiffYPtr-iWidth);         
     7558        }
     7559      }
     7560      if( *pbEdgeYPtr == true )
     7561      {
     7562        if( *(psDiffYPtr) >= 0)
     7563        {
     7564          usAbs1 = *(psDiffYPtr);
     7565        }
     7566        else
     7567        {
     7568          usAbs1 = (-1) * *(psDiffYPtr);
     7569        }