Changeset 1196 in 3DVCSoftware


Ignore:
Timestamp:
4 May 2015, 17:47:40 (10 years ago)
Author:
tech
Message:

Merged 14.0-dev0@1187.

Location:
trunk/source
Files:
48 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/App/TAppDecoder/TAppDecTop.cpp

    r1179 r1196  
    248248            {
    249249              m_tDecTop[decIdx]->setTargetOptLayerSetIdx( m_targetOptLayerSetIdx );
    250 #if H_3D_ANNEX_SELECTION_FIX
     250#if H_3D
    251251              m_tDecTop[decIdx]->setProfileIdc( );
    252252#endif
     
    10531053    m_tDecTop[ decIdx ]->setLayerInitilizedFlags( m_layerInitilizedFlags );
    10541054    m_tDecTop[ decIdx ]->setTargetOptLayerSetIdx( m_targetOptLayerSetIdx );   
    1055 #if H_3D_ANNEX_SELECTION_FIX
     1055#if H_3D
    10561056    m_tDecTop[ decIdx ]->setProfileIdc           ( );   
    10571057#endif
  • trunk/source/App/TAppEncoder/TAppEncCfg.cpp

    r1179 r1196  
    225225  }
    226226#endif
    227 #if HHI_INTER_COMP_PRED_K0052
    228227#if H_3D
    229228  in>>entry.m_interCompPredFlag;
    230 #endif
    231229#endif
    232230  return in;
     
    482480  ("FastSearch",              m_iFastSearch,                1, "0:Full search  1:Diamond  2:PMVFAST")
    483481  ("SearchRange,-sr",         m_iSearchRange,              96, "Motion search range")
    484 #if SONY_MV_V_CONST_C0078
     482#if H_MV
    485483  ("DispSearchRangeRestriction",  m_bUseDisparitySearchRangeRestriction, false, "restrict disparity search range")
    486484  ("VerticalDispSearchRange",     m_iVerticalDisparitySearchRange, 56, "vertical disparity search range")
     
    794792  ("QtPredFlag"            , m_qtPredFlag            , true                                           , "Quad tree prediction from texture to depth")
    795793  ("InterSdcFlag"          , m_interSdcFlag          , true                                           , "Inter depth DCs"                           )
    796 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    797794  ("DepthIntraSkip"        , m_depthIntraSkipFlag    , true                                           , "Depth intra skip mode"                     )
    798 #else
    799   ("IntraSingleFlag"       , m_intraSingleFlag       , true                                           , "Intra single mode"                         )
    800 #endif
    801795#endif //H_3D
    802796  ;
     
    15591553    {
    15601554      xConfirmPara( m_directRefLayers[i][j] < 0 || m_directRefLayers[i][j] >= i , "Reference layer id shall be greater than or equal to 0 and less than dependent layer id");
    1561 #if H_3D_DIRECT_DEP_TYPE
    15621555      xConfirmPara( m_dependencyTypes[i][j] < 0 || m_dependencyTypes[i][j] >  6 , "Dependency type shall be greater than or equal to 0 and less than 7");
    1563 #else
    1564       xConfirmPara( m_dependencyTypes[i][j] < 0 || m_dependencyTypes[i][j] >  2 , "Dependency type shall be greater than or equal to 0 and less than 3");
    1565 #endif
    15661556    }       
    15671557  } 
     
    15991589  xConfirmPara( m_iSearchRange < 0 ,                                                        "Search Range must be more than 0" );
    16001590  xConfirmPara( m_bipredSearchRange < 0 ,                                                   "Search Range must be more than 0" );
    1601 #if SONY_MV_V_CONST_C0078
     1591#if H_MV
    16021592  xConfirmPara( m_iVerticalDisparitySearchRange <= 0 ,                                      "Vertical Disparity Search Range must be more than 0" );
    16031593#endif
     
    17161706  xConfirmPara( m_pchCameraParameterFile    == 0                ,   "CameraParameterFile must be given");
    17171707  xConfirmPara( m_pchBaseViewCameraNumbers  == 0                ,   "BaseViewCameraNumbers must be given" );
    1718 #if BUG_FIX_TK65
    1719 #if HHI_CAM_PARA_K0052
    17201708  xConfirmPara( m_iNumberOfViews != m_cCameraData.getBaseViewNumbers().size() ,   "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
    1721 #else
    1722   xConfirmPara( ( ((UInt) m_numberOfLayers >> 1 ) != m_cCameraData.getBaseViewNumbers().size() ) && ( m_numberOfLayers != m_cCameraData.getBaseViewNumbers().size() ),   "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
    1723 #endif
    1724 #else
    1725   xConfirmPara( ((UInt) m_numberOfLayers >> 1 ) != m_cCameraData.getBaseViewNumbers().size(),   "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
    1726 #endif
    17271709  xConfirmPara    ( m_iCodedCamParPrecision < 0 || m_iCodedCamParPrecision > 5,       "CodedCamParsPrecision must be in range of 0..5" );
    17281710#if H_3D_VSO
     
    24772459  printf("Min PCM size                 : %d\n", 1 << m_uiPCMLog2MinSize);
    24782460  printf("Motion search range          : %d\n", m_iSearchRange );
    2479 #if SONY_MV_V_CONST_C0078
     2461#if H_MV
    24802462  printf("Disp search range restriction: %d\n", m_bUseDisparitySearchRangeRestriction );
    24812463  printf("Vertical disp search range   : %d\n", m_iVerticalDisparitySearchRange );
     
    26322614  printf( "QtPred:%d "                 , m_qtPredFlag             ? 1 : 0 );
    26332615  printf( "InterSdc:%d "               , m_interSdcFlag           ? 1 : 0 );
    2634 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    26352616  printf( "DepthIntraSkip:%d "         , m_depthIntraSkipFlag     ? 1 : 0 );
    2636 #else
    2637   printf( "IntraSingle:%d "            , m_intraSingleFlag        ? 1 : 0 );
    2638 #endif
    26392617#endif
    26402618
  • trunk/source/App/TAppEncoder/TAppEncCfg.h

    r1179 r1196  
    289289  Int       m_iSearchRange;                                   ///< ME search range
    290290  Int       m_bipredSearchRange;                              ///< ME search range for bipred refinement
    291 #if SONY_MV_V_CONST_C0078
     291#if H_MV
    292292  Bool      m_bUseDisparitySearchRangeRestriction;            ///< restrict vertical search range for inter-view prediction
    293293  Int       m_iVerticalDisparitySearchRange;                  ///< ME vertical search range for inter-view prediction
     
    488488  Bool                   m_qtPredFlag;
    489489  Bool                   m_interSdcFlag;
    490 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    491490  Bool                   m_depthIntraSkipFlag;
    492 #else
    493   Bool                   m_intraSingleFlag;
    494 #endif
    495491#endif
    496492  // internal member functions
     
    543539    Int iSpace = max(1, ENC_CFG_CONSOUT_SPACE - (Int) description.length() );
    544540   
    545     for ( Int i = 0; i < iSpace; i++ )
     541    for ( Int i = 0; i < iSpace; i++ )
     542    {
    546543      description.append( " " );
     544    }
    547545     
    548546    description.append( ":" );
    549547    printf( "%s", description.c_str() );
    550548
    551     for(Int i=0;i<rpcVector.size();i++)               
     549    for(Int i=0;i<rpcVector.size();i++)
     550    {
    552551      xPrintVectorElem( rpcVector[i] );
     552    }
    553553
    554554    printf("\n");
  • trunk/source/App/TAppEncoder/TAppEncTop.cpp

    r1179 r1196  
    140140  xSetVPSVUI               ( vps );
    141141#if H_3D
    142 #if HHI_CAM_PARA_K0052
    143142  xSetCamPara              ( vps );
    144 #endif
    145 #endif
    146 #if H_3D
    147143  m_ivPicLists.setVPS      ( &vps );
    148144  xDeriveDltArray          ( vps, dlt );
     
    201197      m_sps3dExtension.setQtPredFlag            ( d, m_qtPredFlag            );
    202198      m_sps3dExtension.setInterSdcFlag          ( d, m_interSdcFlag          );
    203 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    204199      m_sps3dExtension.setDepthIntraSkipFlag    ( d, m_depthIntraSkipFlag    ); 
    205 #else
    206       m_sps3dExtension.setIntraSingleFlag       ( d, m_intraSingleFlag       ); 
    207 #endif
    208200    }
    209201  }
     
    229221    //====== Camera Parameters =========
    230222    m_cTEncTop.setCameraParameters             ( &m_cCameraData );     
    231 #if !HHI_CAM_PARA_K0052
    232     m_cTEncTop.setCamParPrecision              ( m_cCameraData.getCamParsCodedPrecision  () );
    233     m_cTEncTop.setCamParInSliceHeader          ( m_cCameraData.getVaryingCameraParameters() );
    234 
    235     m_cTEncTop.setCodedScale                   ( m_cCameraData.getCodedScale             () );
    236     m_cTEncTop.setCodedOffset                  ( m_cCameraData.getCodedOffset            () );
    237 #endif
    238223#if H_3D_VSO
    239224    //====== VSO =========
     
    359344  m_cTEncTop.setBipredSearchRange            ( m_bipredSearchRange );
    360345
    361 #if SONY_MV_V_CONST_C0078
     346#if H_MV
    362347  m_cTEncTop.setUseDisparitySearchRangeRestriction ( m_bUseDisparitySearchRangeRestriction );
    363348  m_cTEncTop.setVerticalDisparitySearchRange ( m_iVerticalDisparitySearchRange );
     
    651636  }
    652637#endif
    653 #if H_3D_ANNEX_SELECTION_FIX
    654638#if H_3D
    655639 /// SET Profiles
     
    692676  }
    693677#endif
    694 #endif
    695678#if H_3D_VSO
    696679  if ( m_bUseVSO )
     
    799782{
    800783#if H_3D
    801 #if !HHI_CAM_PARA_K0052
    802   for ( Int viewIndex = 0; viewIndex < m_vps->getNumViews(); viewIndex++ )
    803   {
    804     m_vps->initCamParaVPS( viewIndex, true, m_cCameraData.getCamParsCodedPrecision(),
    805       m_cCameraData.getVaryingCameraParameters(), m_cCameraData.getCodedScale(), m_cCameraData.getCodedOffset() );
    806   }
    807 #endif
    808784#endif
    809785
     
    11431119      if (m_pchReconFileList[layerId])
    11441120      {
    1145 #if H_MV_ALIGN_HM_15
    11461121        m_acTVideoIOYuvReconFileList[layerId]->write( pcPicYuvRecTop, pcPicYuvRecBottom, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom, m_isTopFieldFirst );
    1147 #else
    1148         m_acTVideoIOYuvReconFileList[layerId]->write( pcPicYuvRecTop, pcPicYuvRecBottom, m_confLeft, m_confRight, m_confTop, m_confBottom, m_isTopFieldFirst );
    1149 #endif
    11501122      }
    11511123    }
     
    12001172      if (m_pchReconFileList[layerId])
    12011173      {
    1202 #if H_MV_ALIGN_HM_15
    12031174        m_acTVideoIOYuvReconFileList[layerId]->write( pcPicYuvRec, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom );
    1204 #else
    1205         m_acTVideoIOYuvReconFileList[layerId]->write( pcPicYuvRec, m_confLeft, m_confRight, m_confTop, m_confBottom );
    1206 #endif
    12071175      }   
    12081176    }
     
    13901358
    13911359
    1392 #if HHI_INTER_COMP_PRED_K0052
    13931360#if H_3D
    13941361  vps.initViewCompLayer( );
    13951362#endif
    1396 #endif
    13971363}
    13981364
     
    14121378  Bool defaultDirectDependencyFlag = false;
    14131379
    1414 #if H_3D_DIRECT_DEP_TYPE
    14151380  Int directDepTypeLenMinus2 = 0; 
    1416 #endif
    14171381  for( Int depLayer = 1; depLayer < m_numberOfLayers; depLayer++ )
    14181382  {
     
    14241388      vps.setDirectDependencyFlag( depLayer, refLayer, true);
    14251389      Int curDirectDependencyType = m_dependencyTypes[depLayer][i];
    1426 #if H_3D_DIRECT_DEP_TYPE       
    14271390      directDepTypeLenMinus2 = std::max( directDepTypeLenMinus2, gCeilLog2( curDirectDependencyType + 1  ) - 2 ); 
    1428 #endif
    14291391      if ( defaultDirectDependencyType != -1 )   
    14301392      {
     
    14441406  vps.setDefaultDirectDependencyType( defaultDirectDependencyFlag ? defaultDirectDependencyType : -1 );       
    14451407
    1446 #if H_3D_DIRECT_DEP_TYPE       
    14471408  assert( directDepTypeLenMinus2 <= 1 );
    14481409  vps.setDirectDepTypeLenMinus2( directDepTypeLenMinus2 );
    1449 #endif
    14501410
    14511411
     
    14951455#endif
    14961456              {
    1497 #if !HHI_INTER_COMP_PRED_K0052               
    1498                 Bool refAlwaysIntra = ( i == getGOPSize() ) && ( m_iIntraPeriod[ curLayerIdInVps ] % m_iIntraPeriod[ refLayerIdInVps ] == 0 );
    1499 #endif
    15001457                Bool refLayerZero   = ( i == getGOPSize() ) && ( refLayerIdInVps == 0 );
    1501 #if HHI_INTER_COMP_PRED_K0052
    1502                 // refAlwaysIntra actually not needed, since TemporalIds need to be aligned within an AU.
    1503                 // Thus, reference pictures of IRAP pictures have TemporalId equal to 0.
    15041458                maxTid = std::max( maxTid, refLayerZero ? 0 : geRef.m_temporalId );
    1505 #else
    1506                 maxTid = std::max( maxTid, ( refAlwaysIntra || refLayerZero ) ? 0 : geRef.m_temporalId );
    1507 #endif
    15081459              }
    15091460            }
     
    15131464        else
    15141465        {       
    1515 #if HHI_INTER_COMP_PRED_K0052
    15161466          if( m_depthFlag[ curLayerIdInVps ] && ( m_mpiFlag|| m_qtPredFlag || m_intraContourFlag ) )
    15171467          {         
     
    15521502            }
    15531503          }       
    1554 #else
    1555           if( m_depthFlag[ curLayerIdInVps ] && ( m_mpiFlag|| m_qtPredFlag || m_intraContourFlag ) )
    1556           {         
    1557             Int nuhLayerIdTex = vps.getLayerIdInNuh( vps.getViewIndex( curLayerIdInNuh ), false );
    1558             if ( nuhLayerIdTex == refLayerIdInNuh )
    1559             {
    1560               maxTid = std::max( maxTid, vps.getSubLayersVpsMaxMinus1( refLayerIdInVps) + 1 );
    1561             }
    1562           }
    1563           if( !m_depthFlag[ curLayerIdInVps ] && vps.getNumRefListLayers( curLayerIdInNuh) > 0  && ( m_depthRefinementFlag || m_viewSynthesisPredFlag || m_depthBasedBlkPartFlag ) )
    1564           { 
    1565             Int maxPresentTid =-1;
    1566             Bool allPresent = true;
    1567             for (Int i = 0; i < vps.getNumRefListLayers( curLayerIdInNuh); i++ )
    1568             {
    1569               Int nuhLayerIdDep = vps.getLayerIdInNuh( vps.getViewIndex( vps.getIdRefListLayer(curLayerIdInNuh, i ) ), true );
    1570               if ( nuhLayerIdDep== refLayerIdInNuh )
    1571               {
    1572                 maxPresentTid= std::max( maxTid, vps.getSubLayersVpsMaxMinus1( refLayerIdInVps) + 1 );             
    1573               }
    1574               else
    1575               {
    1576                 allPresent = false;
    1577               }
    1578             }
    1579 
    1580             if ( allPresent )
    1581             {
    1582               maxTid= std::max( maxTid, maxPresentTid );             
    1583             }
    1584           }       
    1585 #endif
    15861504        }
    15871505      } // if ( vps.getDirectDependencyFlag( curLayerIdInVps, refLayerIdInVps ) )
     
    18231741    // ToDo not supported yet.
    18241742    //repFormat->setSeparateColourPlaneVpsFlag( );
    1825 #if H_MV_FIX_CONF_WINDOW
    18261743    Bool conformanceWindowVpsFlag = ( m_confWinBottom != 0 ) || ( m_confWinRight != 0 ) || ( m_confWinTop != 0 ) || ( m_confWinBottom != 0 );
    18271744    repFormat->setConformanceWindowVpsFlag( conformanceWindowVpsFlag );
     
    18331750      repFormat->setConfWinVpsBottomOffset  ( m_confWinBottom / TComSPS::getWinUnitY( repFormat->getChromaFormatVpsIdc() ) );
    18341751    }
    1835 #else
    1836     repFormat->setConformanceWindowVpsFlag( true );
    1837     repFormat->setConfWinVpsLeftOffset    ( m_confWinLeft   / TComSPS::getWinUnitX( repFormat->getChromaFormatVpsIdc() ) );
    1838     repFormat->setConfWinVpsRightOffset   ( m_confWinRight  / TComSPS::getWinUnitX( repFormat->getChromaFormatVpsIdc() )  );
    1839     repFormat->setConfWinVpsTopOffset     ( m_confWinTop    / TComSPS::getWinUnitY( repFormat->getChromaFormatVpsIdc() )  );
    1840     repFormat->setConfWinVpsBottomOffset  ( m_confWinBottom / TComSPS::getWinUnitY( repFormat->getChromaFormatVpsIdc() ) );
    1841 #endif
    18421752    assert( vps.getRepFormat( j ) == NULL );
    18431753    vps.setRepFormat( j , repFormat );
     
    18611771
    18621772  repFormat->setConformanceWindowVpsFlag( true );
    1863 #if H_MV_ALIGN_HM_15
    18641773  repFormat->setConfWinVpsLeftOffset    ( m_confWinLeft   / TComSPS::getWinUnitX( repFormat->getChromaFormatVpsIdc() ) );
    18651774  repFormat->setConfWinVpsRightOffset   ( m_confWinRight  / TComSPS::getWinUnitX( repFormat->getChromaFormatVpsIdc() )  );
    18661775  repFormat->setConfWinVpsTopOffset     ( m_confWinTop    / TComSPS::getWinUnitY( repFormat->getChromaFormatVpsIdc() )  );
    18671776  repFormat->setConfWinVpsBottomOffset  ( m_confWinBottom / TComSPS::getWinUnitY( repFormat->getChromaFormatVpsIdc() ) );
    1868 #else
    1869   repFormat->setConfWinVpsLeftOffset    ( m_confLeft   / TComSPS::getWinUnitX( repFormat->getChromaFormatVpsIdc() ) );
    1870   repFormat->setConfWinVpsRightOffset   ( m_confRight  / TComSPS::getWinUnitX( repFormat->getChromaFormatVpsIdc() )  );
    1871   repFormat->setConfWinVpsTopOffset     ( m_confTop    / TComSPS::getWinUnitY( repFormat->getChromaFormatVpsIdc() )  );
    1872   repFormat->setConfWinVpsBottomOffset  ( m_confBottom / TComSPS::getWinUnitY( repFormat->getChromaFormatVpsIdc() ) );
    1873 #endif
    18741777  assert( vps.getRepFormat( 0 ) == NULL );
    18751778  vps.setRepFormat( 0 , repFormat );
     
    22502153}
    22512154
    2252 #if HHI_CAM_PARA_K0052
    22532155#if H_3D
    22542156Void TAppEncTop::xSetCamPara                ( TComVPS& vps )
     
    22852187}
    22862188#endif
    2287 #endif
    22882189
    22892190
  • trunk/source/App/TAppEncoder/TAppEncTop.h

    r1179 r1196  
    142142  Void xSetDpbSize                ( TComVPS& vps );
    143143  Void xSetVPSVUI                 ( TComVPS& vps );
    144 #if HHI_CAM_PARA_K0052
    145144#if H_3D
    146145  Void xSetCamPara                ( TComVPS& vps );
    147 #endif
    148146#endif
    149147  GOPEntry* xGetGopEntry( Int layerIdInVps, Int poc );
  • trunk/source/Lib/TAppCommon/TAppComCamPara.cpp

    r1179 r1196  
    399399
    400400
    401 #if !HHI_CAM_PARA_K0052
    402 Void
    403 TAppComCamPara::xGetViewOrderIndices( const std::vector<Int>& raiId2SortedId, std::vector<Int>& raiVOIdx )
    404 {
    405   AOF( raiId2SortedId.size() );
    406   raiVOIdx  =      raiId2SortedId;
    407   Int iSize = (Int)raiId2SortedId.size();
    408   Int iOffs =      raiId2SortedId[ 0 ];
    409   for( Int iIdx = 0; iIdx < iSize; iIdx++ )
    410   {
    411     raiVOIdx[ iIdx ] -= iOffs;
    412   }
    413 }
    414 #endif
    415401
    416402
     
    960946
    961947
    962 #if !HHI_CAM_PARA_K0052
    963 Void
    964 TAppComCamPara::xSetPdmConversionParams()
    965 {
    966   AOF( m_aiViewOrderIndex[ 0 ] == 0 );
    967   if ( m_bSetupFromCoded || m_iNumberOfBaseViews    <  2 )
    968   {
    969     return;
    970   }
    971 
    972   //--- determine (virtual) camera parameter shift between view order index 1 and base view (view order index 0) ---
    973   Double        dCamPosShift, dPicPosShift;
    974   Int           iMinAbsVOI    = (1<<30);
    975   Int           iMinAbsVOIId  = 0;
    976   for( Int iBaseId = 1; iBaseId < m_iNumberOfBaseViews; iBaseId++ )
    977   {
    978     Int iAbsVOI = ( m_aiViewOrderIndex[ iBaseId ] < 0 ? -m_aiViewOrderIndex[ iBaseId ] : m_aiViewOrderIndex[ iBaseId ] );
    979     if( iAbsVOI < iMinAbsVOI )
    980     {
    981       iMinAbsVOI   = iAbsVOI;
    982       iMinAbsVOIId = iBaseId;
    983     }
    984   }
    985   AOF( iMinAbsVOIId != 0 && iMinAbsVOI != 0 );
    986   xGetCameraShifts( 0, iMinAbsVOIId, m_uiFirstFrameId, dCamPosShift, dPicPosShift );
    987 
    988   //--- determine maximum absolute camera position shift, precision, and base scale ---
    989   Double  dMaxAbsCamPosShift = 0.0;
    990   for( Int iTargetId = 1; iTargetId < m_iNumberOfBaseViews; iTargetId++ )
    991   {
    992     for( Int iBaseId = 0; iBaseId < iTargetId; iBaseId++ )
    993     {
    994       xGetCameraShifts( (UInt)iBaseId, (UInt)iTargetId, m_uiFirstFrameId, dCamPosShift, dPicPosShift );
    995       dCamPosShift        = ( dCamPosShift < 0.0                ? -dCamPosShift : dCamPosShift       );
    996       dMaxAbsCamPosShift  = ( dCamPosShift > dMaxAbsCamPosShift ?  dCamPosShift : dMaxAbsCamPosShift );
    997     }
    998   }
    999 }
    1000 #endif
    1001948
    1002949
     
    12841231
    12851232  //===== set derived parameters =====
    1286 #if !HHI_CAM_PARA_K0052
    1287   xGetViewOrderIndices( m_aiBaseId2SortedId, m_aiViewOrderIndex );
    1288 #endif
    12891233  m_bCamParsVaryOverTime = xGetCamParsChangeFlag();
    12901234
  • trunk/source/Lib/TAppCommon/TAppComCamPara.h

    r1179 r1196  
    8585
    8686  // SPS and slice header related variables
    87 #if !HHI_CAM_PARA_K0052
    88   std::vector<Int>    m_aiViewOrderIndex;                     ///< list of view order indices
    89 #endif
    9087  UInt                m_uiCamParsCodedPrecision;              ///< precision for coding of camera parameters (x: max error in disparity is 2^(-x) luma samples)
    9188  Bool                m_bCamParsVaryOverTime;                 ///< flag specifying whether camera parameters vary for given frame numbers
     
    147144  // getting conversion parameters for disparity to virtual depth conversion
    148145  Void  xGetCameraShifts          ( UInt uiSourceView, UInt uiTargetView, UInt uiFrame, Double& rdCamPosShift, Double& rdPicPosShift );
    149 #if !HHI_CAM_PARA_K0052
    150   Void  xSetPdmConversionParams   ();
    151 #endif
    152146
    153147public:
     
    220214  Bool                getVaryingCameraParameters()  { return m_bCamParsVaryOverTime;    }
    221215  UInt                getCamParsCodedPrecision  ()  { return m_uiCamParsCodedPrecision; }
    222 #if !HHI_CAM_PARA_K0052
    223   std::vector<Int>&   getViewOrderIndex         ()  { return m_aiViewOrderIndex;        }
    224 #endif
    225216  Int**               getCodedScale             ()  { return m_aaiCodedScale;           }
    226217  Int**               getCodedOffset            ()  { return m_aaiCodedOffset;          }
  • trunk/source/Lib/TLibCommon/ContextTables.h

    r1179 r1196  
    5151#define NUM_SPLIT_FLAG_CTX            3       ///< number of context models for split flag
    5252#define NUM_SKIP_FLAG_CTX             3       ///< number of context models for skip flag
    53 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     53#if H_3D
    5454#define NUM_DIS_FLAG_CTX              1
    5555#define NUM_DIS_TYPE_CTX              1       
    56 #else
    57 #if H_3D_SINGLE_DEPTH
    58 #define NUM_SINGLEDEPTH_FLAG_CTX                     1
    59 #define NUM_SINGLE_DEPTH_VALUE_DATA_CTX              1       
    60 #endif
    6156#endif
    6257#define NUM_MERGE_FLAG_EXT_CTX        1       ///< number of context models for merge flag of merge extended
     
    158153  { CNU,  CNU,  CNU, },
    159154};
    160 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     155#if H_3D
    161156static const UChar
    162157INIT_DIS_FLAG[3][NUM_DIS_FLAG_CTX] = 
     
    173168    { 137 },
    174169};
    175 #else
    176 #if H_3D_SINGLE_DEPTH
    177 static const UChar
    178 INIT_SINGLEDEPTH_FLAG[3][NUM_SINGLEDEPTH_FLAG_CTX] = 
    179 {
    180   { 185 },
    181   { 185 },
    182   { 185 },
    183 };
    184 static const UChar
    185 INIT_SINGLE_DEPTH_VALUE_DATA[3][NUM_SINGLE_DEPTH_VALUE_DATA_CTX] =
    186 {
    187   { 137 },
    188   { 137 },
    189   { 137 },
    190 };
    191 #endif
    192170#endif
    193171static const UChar
  • trunk/source/Lib/TLibCommon/TComDataCU.cpp

    r1179 r1196  
    6060 
    6161  m_skipFlag           = NULL;
    62 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     62#if H_3D
    6363  m_bDISFlag           = NULL;
    6464  m_uiDISType          = NULL;
    65 #else
    66 #if H_3D_SINGLE_DEPTH
    67   m_singleDepthFlag     = NULL;
    68   m_apSingleDepthValue  = NULL;
    69 #endif
    7065#endif
    7166  m_pePartSize         = NULL;
     
    158153  m_pbDBBPFlag         = NULL;
    159154#endif
    160 
    161155}
    162156
     
    186180
    187181    m_skipFlag           = new Bool[ uiNumPartition ];
    188 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     182#if H_3D
    189183    m_bDISFlag           = new Bool[ uiNumPartition ];
    190184    m_uiDISType          = (UInt*)xMalloc(UInt, uiNumPartition);
    191 #else
    192 #if H_3D_SINGLE_DEPTH
    193     m_singleDepthFlag     = new Bool[ uiNumPartition ];
    194     m_apSingleDepthValue  = (Pel*)xMalloc(Pel, uiNumPartition);
    195 #endif
    196185#endif
    197186    m_pePartSize         = new Char[ uiNumPartition ];
     
    337326
    338327    if ( m_skipFlag           ) { delete[] m_skipFlag;          m_skipFlag          = NULL; }
    339 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     328#if H_3D
    340329    if ( m_bDISFlag           ) { delete[] m_bDISFlag;   m_bDISFlag     = NULL; }
    341330    if ( m_uiDISType         ) { xFree(m_uiDISType);  m_uiDISType    = NULL; }
    342 #else
    343 #if H_3D_SINGLE_DEPTH
    344     if ( m_singleDepthFlag    ) { delete[] m_singleDepthFlag;   m_singleDepthFlag     = NULL; }
    345     if ( m_apSingleDepthValue ) { xFree(m_apSingleDepthValue);  m_apSingleDepthValue  = NULL; }
    346 #endif
    347331#endif
    348332    if ( m_pePartSize         ) { delete[] m_pePartSize;        m_pePartSize        = NULL; }
     
    506490    TComDataCU * pcFrom = pcPic->getCU(getAddr());
    507491    m_skipFlag[ui]   = pcFrom->getSkipFlag(ui);
    508 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     492#if H_3D
    509493    m_bDISFlag[ui]   = pcFrom->getDISFlag(ui);
    510494    m_uiDISType[ui]  = pcFrom->getDISType(ui);
    511 #else
    512 #if H_3D_SINGLE_DEPTH
    513     m_singleDepthFlag[ui]    = pcFrom->getSingleDepthFlag(ui);
    514     m_apSingleDepthValue[ui] = pcFrom->getSingleDepthValue(ui);
    515 #endif
    516495#endif
    517496    m_pePartSize[ui] = pcFrom->getPartitionSize(ui);
     
    566545  {
    567546    memset( m_skipFlag          + firstElement, false,                    numElements * sizeof( *m_skipFlag ) );
    568 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     547#if H_3D
    569548    memset( m_bDISFlag          + firstElement, false,                    numElements * sizeof( *m_bDISFlag ) );
    570549    memset( m_uiDISType         + firstElement,     0,                    numElements * sizeof( *m_uiDISType) );
    571 #else
    572 #if H_3D_SINGLE_DEPTH
    573     memset( m_singleDepthFlag     + firstElement, false,                  numElements * sizeof( *m_singleDepthFlag ) );
    574     memset( m_apSingleDepthValue  + firstElement,     0,                  numElements * sizeof( *m_apSingleDepthValue ) );
    575 #endif
    576550#endif
    577551    memset( m_pePartSize        + firstElement, SIZE_NONE,                numElements * sizeof( *m_pePartSize ) );
     
    758732      m_puhTransformSkip[2][ui] = 0;
    759733      m_skipFlag[ui]   = false;
    760 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     734#if H_3D
    761735      m_bDISFlag[ui]   = false;
    762736      m_uiDISType[ui]  = 0;
    763 #else
    764 #if H_3D_SINGLE_DEPTH
    765       m_singleDepthFlag[ui]     = false;
    766       m_apSingleDepthValue[ui]  = 0;
    767 #endif
    768737#endif
    769738      m_pePartSize[ui] = SIZE_NONE;
     
    891860  memset( m_puhCbf[2],          0, iSizeInUchar );
    892861  memset( m_puhDepth,     uiDepth, iSizeInUchar );
    893 #if H_3D_NBDV && !SEC_ARP_REM_ENC_RESTRICT_K0035
    894   m_pDvInfo->bDV = false;
    895 #endif
    896862#if H_3D_ARP
    897863  memset( m_puhARPW,            0, iSizeInUchar  );
     
    934900  {
    935901    m_skipFlag[ui]   = false;
    936 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     902#if H_3D
    937903    m_bDISFlag[ui]   = false;
    938904    m_uiDISType[ui]  = 0;
    939 #else
    940 #if H_3D_SINGLE_DEPTH
    941     m_singleDepthFlag[ui]   = false;
    942     m_apSingleDepthValue[ui]= 0;
    943 #endif
    944905#endif
    945906    m_pePartSize[ui] = SIZE_NONE;
     
    964925      m_puhTransformSkip[2][ui] = pcCU->getTransformSkip(uiPartOffset+ui,TEXT_CHROMA_V);
    965926      m_skipFlag[ui]   = pcCU->getSkipFlag(uiPartOffset+ui);
    966 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     927#if H_3D
    967928      m_bDISFlag[ui]    = pcCU->getDISFlag(uiPartOffset+ui);
    968929      m_uiDISType[ui]   = pcCU->getDISType(uiPartOffset+ui);
    969 #else
    970 #if H_3D_SINGLE_DEPTH
    971       m_singleDepthFlag[ui]    = pcCU->getSingleDepthFlag(uiPartOffset+ui);
    972       m_apSingleDepthValue[ui] = pcCU->getSingleDepthValue(uiPartOffset+ui);
    973 #endif
    974930#endif
    975931      m_pePartSize[ui] = pcCU->getPartitionSize(uiPartOffset+ui);
     
    1000956      m_pbICFlag          [ui] = pcCU->m_pbICFlag[uiPartOffset+ui];
    1001957#endif
    1002 
    1003 
    1004958#if H_3D_DIM
    1005959      for( Int i = 0; i < DIM_NUM_TYPE; i++ )
     
    11181072 
    11191073  m_skipFlag=pcCU->getSkipFlag()          + uiPart;
    1120 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     1074#if H_3D
    11211075  m_bDISFlag     = pcCU->getDISFlag()     + uiPart;
    11221076  m_uiDISType    = pcCU->getDISType()     + uiPart;
    1123 #else
    1124 #if H_3D_SINGLE_DEPTH
    1125   m_singleDepthFlag     = pcCU->getSingleDepthFlag()   + uiPart;
    1126   m_apSingleDepthValue  = pcCU->getSingleDepthValue()  + uiPart;
    1127 #endif
    11281077#endif
    11291078  m_phQP=pcCU->getQP()                    + uiPart;
     
    11431092  m_pbSPIVMPFlag        = pcCU->getSPIVMPFlag()          + uiPart;
    11441093#endif
    1145 
    11461094#if H_3D_ARP
    11471095  m_puhARPW             = pcCU->getARPW()             + uiPart;
     
    11501098  m_pbICFlag            = pcCU->getICFlag()           + uiPart;
    11511099#endif
    1152 
    1153 
    11541100  m_puhLumaIntraDir     = pcCU->getLumaIntraDir()     + uiPart;
    11551101  m_puhChromaIntraDir   = pcCU->getChromaIntraDir()   + uiPart;
     
    12601206 
    12611207  m_skipFlag           = pcCU->getSkipFlag ()             + uiAbsPartIdx;
    1262 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     1208#if H_3D
    12631209  m_bDISFlag           = pcCU->getDISFlag ()              + uiAbsPartIdx;
    12641210  m_uiDISType          = pcCU->getDISType()               + uiAbsPartIdx;
    1265 #else
    1266 #if H_3D_SINGLE_DEPTH
    1267   m_singleDepthFlag     = pcCU->getSingleDepthFlag ()             + uiAbsPartIdx;
    1268   m_apSingleDepthValue  = pcCU->getSingleDepthValue ()            + uiAbsPartIdx;
    1269 #endif
    12701211#endif
    12711212  m_pePartSize         = pcCU->getPartitionSize ()        + uiAbsPartIdx;
     
    12951236#endif
    12961237#if H_3D_SPIVMP
    1297   m_pbSPIVMPFlag       = pcCU->getSPIVMPFlag()               + uiAbsPartIdx;
    1298 #endif
    1299 
     1238  m_pbSPIVMPFlag       = pcCU->getSPIVMPFlag()            + uiAbsPartIdx;
     1239#endif
    13001240  m_apiMVPIdx[eRefPicList] = pcCU->getMVPIdx(eRefPicList) + uiAbsPartIdx;
    1301   m_apiMVPNum[eRefPicList] = pcCU->getMVPNum(eRefPicList) + uiAbsPartIdx;
    1302  
     1241  m_apiMVPNum[eRefPicList] = pcCU->getMVPNum(eRefPicList) + uiAbsPartIdx; 
    13031242#if H_3D_ARP
    13041243  m_puhARPW            = pcCU->getARPW()                  + uiAbsPartIdx;
    1305 #endif
    1306 
    1307    
     1244#endif   
    13081245#if H_3D_DBBP
    13091246  m_pbDBBPFlag       = pcCU->getDBBPFlag()              + uiAbsPartIdx;
     
    13401277  Int sizeInChar  = sizeof( Char ) * uiNumPartition;
    13411278  memcpy( m_skipFlag   + uiOffset, pcCU->getSkipFlag(),       sizeof( *m_skipFlag )   * uiNumPartition );
    1342 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     1279#if H_3D
    13431280  memcpy( m_bDISFlag   + uiOffset, pcCU->getDISFlag(),       sizeof( *m_bDISFlag )   * uiNumPartition );
    13441281  memcpy( m_uiDISType  + uiOffset, pcCU->getDISType(),       sizeof( *m_uiDISType )  * uiNumPartition);
    1345 #else
    1346 #if H_3D_SINGLE_DEPTH
    1347   memcpy( m_singleDepthFlag     + uiOffset, pcCU->getSingleDepthFlag(),       sizeof( *m_singleDepthFlag )   * uiNumPartition );
    1348   memcpy( m_apSingleDepthValue  + uiOffset, pcCU->getSingleDepthValue(),      sizeof( *m_apSingleDepthValue ) * uiNumPartition);
    1349 #endif
    13501282#endif
    13511283  memcpy( m_phQP       + uiOffset, pcCU->getQP(),             sizeInChar                        );
     
    13581290  memcpy( m_piVSPFlag           + uiOffset, pcCU->getVSPFlag(),           sizeof( Char ) * uiNumPartition );
    13591291  memcpy( m_pDvInfo             + uiOffset, pcCU->getDvInfo(),            sizeof( *m_pDvInfo ) * uiNumPartition );
    1360 
    13611292#endif
    13621293#if H_3D_SPIVMP
     
    13741305  memcpy( m_puhCbf[1] + uiOffset, pcCU->getCbf(TEXT_CHROMA_U), iSizeInUchar );
    13751306  memcpy( m_puhCbf[2] + uiOffset, pcCU->getCbf(TEXT_CHROMA_V), iSizeInUchar );
    1376 
    1377 
    1378 
    13791307#if H_3D_DIM
    13801308  for( Int i = 0; i < DIM_NUM_TYPE; i++ )
     
    14651393
    14661394  memcpy( rpcCU->getSkipFlag() + m_uiAbsIdxInLCU, m_skipFlag, sizeof( *m_skipFlag ) * m_uiNumPartition );
    1467 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     1395#if H_3D
    14681396  memcpy( rpcCU->getDISFlag()  + m_uiAbsIdxInLCU, m_bDISFlag,    sizeof( *m_bDISFlag )  * m_uiNumPartition );
    14691397  memcpy( rpcCU->getDISType()  + m_uiAbsIdxInLCU, m_uiDISType,   sizeof( *m_uiDISType ) * m_uiNumPartition );
    1470 #else
    1471 #if H_3D_SINGLE_DEPTH
    1472   memcpy( rpcCU->getSingleDepthFlag()  + m_uiAbsIdxInLCU, m_singleDepthFlag,    sizeof( *m_singleDepthFlag ) * m_uiNumPartition );
    1473   memcpy( rpcCU->getSingleDepthValue() + m_uiAbsIdxInLCU, m_apSingleDepthValue, sizeof( *m_apSingleDepthValue ) * m_uiNumPartition);
    1474 #endif
    14751398#endif
    14761399  memcpy( rpcCU->getQP() + m_uiAbsIdxInLCU, m_phQP, sizeInChar  );
     
    14781401  memcpy( rpcCU->getDvInfo()         + m_uiAbsIdxInLCU, m_pDvInfo,    sizeof(* m_pDvInfo)     * m_uiNumPartition );
    14791402#endif
    1480 
    1481 
    14821403  memcpy( rpcCU->getPartitionSize()  + m_uiAbsIdxInLCU, m_pePartSize, sizeof( *m_pePartSize ) * m_uiNumPartition );
    14831404  memcpy( rpcCU->getPredictionMode() + m_uiAbsIdxInLCU, m_pePredMode, sizeof( *m_pePredMode ) * m_uiNumPartition );
     
    15851506  Int sizeInChar  = sizeof( Char ) * uiQNumPart;
    15861507  memcpy( rpcCU->getSkipFlag()       + uiPartOffset, m_skipFlag,   sizeof( *m_skipFlag )   * uiQNumPart );
    1587 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     1508#if H_3D
    15881509  memcpy( rpcCU->getDISFlag()  + uiPartOffset, m_bDISFlag,    sizeof( *m_bDISFlag )   * uiQNumPart );
    15891510  memcpy( rpcCU->getDISType()  + uiPartOffset, m_uiDISType,   sizeof( *m_uiDISType )  * uiQNumPart );
    1590 #else
    1591 #if H_3D_SINGLE_DEPTH
    1592   memcpy( rpcCU->getSingleDepthFlag()  + uiPartOffset, m_singleDepthFlag,    sizeof( *m_singleDepthFlag )   * uiQNumPart );
    1593   memcpy( rpcCU->getSingleDepthValue() + uiPartOffset, m_apSingleDepthValue, sizeof( *m_apSingleDepthValue ) * uiQNumPart);
    1594 #endif
    15951511#endif
    15961512  memcpy( rpcCU->getQP() + uiPartOffset, m_phQP, sizeInChar );
     
    16161532  memcpy( rpcCU->getCbf(TEXT_CHROMA_U) + uiPartOffset, m_puhCbf[1], iSizeInUchar );
    16171533  memcpy( rpcCU->getCbf(TEXT_CHROMA_V) + uiPartOffset, m_puhCbf[2], iSizeInUchar );
    1618 
    1619 
    16201534#if H_3D_DIM
    16211535  for( Int i = 0; i < DMM_NUM_TYPE; i++ )
     
    23522266  {
    23532267    return NULL;
    2354   }
    2355  
     2268  } 
    23562269#if H_3D_FCO
    23572270  TComPic* depthPic = getSlice()->getIvPic(true, getSlice()->getViewIndex() );
     
    23882301    Int iPictureHeight = depthPicYuv->getHeight();
    23892302   
    2390 #if !HS_DBBP_CLEAN_K0048
    2391     Int iWidth  = uiWidth;
    2392     Int iHeight = uiHeight;
    2393 #endif
    23942303   
    23952304    Bool depthRefineFlag = false;
     
    24042313    }
    24052314   
    2406 #if HS_DBBP_CLEAN_K0048
    24072315    Int depthPosX = Clip3(0,   iPictureWidth - 1,  iBlkX + ((cDv.getHor()+2)>>2));
    24082316    Int depthPosY = Clip3(0,   iPictureHeight - 1, iBlkY + ((cDv.getVer()+2)>>2));
    2409 #else
    2410     Int depthPosX = Clip3(0,   iPictureWidth - iWidth,  iBlkX + ((cDv.getHor()+2)>>2));
    2411     Int depthPosY = Clip3(0,   iPictureHeight- iHeight, iBlkY + ((cDv.getVer()+2)>>2));
    2412 #endif
    24132317   
    24142318    pDepthPels = depthPicYuv->getLumaAddr() + depthPosX + depthPosY * uiDepthStride;
     
    25002404  memset( m_skipFlag + absPartIdx, skip, m_pcPic->getNumPartInCU() >> ( 2 * depth ) );
    25012405}
    2502 
    2503 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2406#if H_3D
    25042407Void TComDataCU::setDISFlagSubParts( Bool bDIS, UInt absPartIdx, UInt depth )
    25052408{
     
    25122415    setSubPartT( uiDISType, m_uiDISType, uiAbsPartIdx, uiDepth, uiPUIdx );
    25132416}
    2514 #else
    2515 #if H_3D_SINGLE_DEPTH
    2516 Void TComDataCU::setSingleDepthFlagSubParts( Bool singleDepth, UInt absPartIdx, UInt depth )
    2517 {
    2518   assert( sizeof( *m_singleDepthFlag) == 1 );
    2519   memset( m_singleDepthFlag + absPartIdx, singleDepth, m_pcPic->getNumPartInCU() >> ( 2 * depth ) );
    2520 }
    2521 
    2522 Void TComDataCU::setSingleDepthValueSubParts(Pel singleDepthValue, UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth )
    2523 {
    2524   setSubPartT<Pel>( singleDepthValue, m_apSingleDepthValue, uiAbsPartIdx, uiDepth, uiPUIdx );
    2525 }
    2526 #endif
    25272417#endif
    25282418
     
    39413831#endif
    39423832#if H_3D_ARP
    3943   Bool bARPFlag = getARPW(uiAbsPartIdx)>0 ? true : false;
     3833  Bool bARPFlag = getARPW(uiAbsPartIdx) > 0;
    39443834#endif
    39453835#if H_3D_DBBP
     
    39743864    m_mergCands[MRG_A1].setCand( &pcMvFieldNeighbours[m_baseListidc<<1], puhInterDirNeighbours[m_baseListidc]
    39753865#if H_3D_VSP
    3976     ,
    3977       (pcCULeft->getVSPFlag(uiLeftPartIdx) != 0
     3866    , (pcCULeft->getVSPFlag(uiLeftPartIdx) != 0
    39783867#if H_3D_IC
    39793868      && !bICFlag
     
    39983887    m_mergCands[MRG_B1].setCand( &pcMvFieldNeighbours[m_baseListidc<<1], puhInterDirNeighbours[m_baseListidc]
    39993888#if H_3D_VSP
    4000     ,
    4001       false
     3889    , false
    40023890#endif
    40033891      , false
     
    40263914    m_mergCands[MRG_A0].setCand( &pcMvFieldNeighbours[m_baseListidc<<1], puhInterDirNeighbours[m_baseListidc]
    40273915#if H_3D_VSP
    4028     ,
    4029       false
     3916    , false
    40303917#endif
    40313918      , false
     
    40403927    m_mergCands[MRG_B2].setCand( &pcMvFieldNeighbours[m_baseListidc<<1], puhInterDirNeighbours[m_baseListidc]
    40413928#if H_3D_VSP
    4042     ,
    4043       false
     3929    , false
    40443930#endif
    40453931      , false
     
    40683954    TComPic * pcTexPic = m_pcSlice->getTexturePic();
    40693955#if H_3D_FCO
    4070 #if H_3D_FCO
    40713956    if (pcTexPic && pcTexPic->getReconMark())
    4072 #else
    4073     if (pcTexturePic->getReconMark())
    4074 #endif
    40753957    {
    40763958#endif   
     
    41073989      Int         iTexPosX, iTexPosY;
    41083990      const TComMv cMvRounding( 1 << ( 2 - 1 ), 1 << ( 2 - 1 ) );
    4109      
     3991
    41103992      Int         iCenterPosX = iCurrPosX + ( ( iWidth /  iPUWidth ) >> 1 )  * iPUWidth + ( iPUWidth >> 1 );
    41113993      Int         iCenterPosY = iCurrPosY + ( ( iHeight /  iPUHeight ) >> 1 )  * iPUHeight + (iPUHeight >> 1);
     
    41143996      if(iWidth == iPUWidth && iHeight == iPUHeight)
    41153997      {
    4116           iCenterPosX = iCurrPosX + (iWidth >> 1);
    4117           iCenterPosY = iCurrPosY + (iHeight >> 1);
     3998        iCenterPosX = iCurrPosX + (iWidth >> 1);
     3999        iCenterPosY = iCurrPosY + (iHeight >> 1);
    41184000      }
    41194001
     
    41514033      if ( bSPIVMPFlag == true )
    41524034      {   
    4153           iInterDirSaved = (cMvFieldSaved[0].getRefIdx()!=-1 ? 1: 0) + (cMvFieldSaved[1].getRefIdx()!=-1 ? 2: 0);
    4154           tmpDir = iInterDirSaved;
    4155           tmpMV[0] = cMvFieldSaved[0];
    4156           tmpMV[1] = cMvFieldSaved[1];
     4035        iInterDirSaved = (cMvFieldSaved[0].getRefIdx()!=-1 ? 1: 0) + (cMvFieldSaved[1].getRefIdx()!=-1 ? 2: 0);
     4036        tmpDir = iInterDirSaved;
     4037        tmpMV[0] = cMvFieldSaved[0];
     4038        tmpMV[1] = cMvFieldSaved[1];
    41574039      }
    41584040
     
    41804062                  TComMv cMv = cTexMvField.getMv() + cMvRounding;
    41814063                  cMv >>=2;         
    4182 #if !(NTT_BUG_FIX_TK54)
    4183                   this->clipMv( cMv );
    4184 #endif
    41854064                  pcMvFieldSP[2*iPartition + uiCurrRefListId].setMvField(cMv, iValidDepRef);
    41864065                }
     
    41974076              }
    41984077            }
    4199 #if !SHARP_SUBBLOCK_CLEAN_K0044
    4200             if (iPUHeight + iPUWidth == 12)
    4201             {
    4202               if (puhInterDirSP[iPartition] == 3)
    4203               {
    4204                 puhInterDirSP[iPartition] = 1;
    4205                 pcMvFieldSP[2*iPartition + 1].setMvField(TComMv(0,0), -1);
    4206               }
    4207             }
    4208 #endif
    42094078
    42104079            iPartition ++;
     
    43094178    if (!bRemoveSpa)
    43104179    {
    4311       Bool SPIVMPFlag = false;
     4180      Bool spiMvpFlag = false;
    43124181      if(!m_pcSlice->getIsDepth())
    43134182      {
    4314         SPIVMPFlag = true;
     4183        spiMvpFlag = true;
    43154184      }
    43164185#if H_3D_DBBP
    4317       SPIVMPFlag &= !bDBBPFlag;
    4318 #endif
    4319 
    4320       m_mergCands[MRG_IVMC].setCand( tmpMV, ivCandDir[0], false, SPIVMPFlag);
     4186      spiMvpFlag &= !bDBBPFlag;
     4187#endif
     4188
     4189      m_mergCands[MRG_IVMC].setCand( tmpMV, ivCandDir[0], false, spiMvpFlag);
    43214190
    43224191      if ( mrgCandIdx == iCount )
     
    54225291}
    54235292
    5424 #if SONY_MV_V_CONST_C0078
    5425 Void TComDataCU::checkMV_V (TComMv&  rcMv,  RefPicList eRefPicList, int iRefIdx )
     5293#if H_MV
     5294Void TComDataCU::checkMvVertRest (TComMv&  rcMv,  RefPicList eRefPicList, int iRefIdx )
    54265295{
    54275296  if ( getSlice()->getSPS()->getInterViewMvVertConstraintFlag() )
     
    57805649  }
    57815650
    5782   if ( bIsCurrRefLongTerm || bIsColRefLongTerm ) // CY: this condition equals to both bIsCurrRefLongTerm and bIsColRefLongTerm being 1
     5651  if ( bIsCurrRefLongTerm || bIsColRefLongTerm )
    57835652  {
    57845653#if H_3D_TMVP
    5785 #if !H_3D_FIX_TMVP_SCALING_VIEW_ID
    5786     Int iCurrViewId    = m_pcSlice->getViewIndex ();
    5787     Int iCurrRefViewId = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getViewIndex ();
    5788     Int iColViewId     = pColCU->getSlice()->getViewIndex();
    5789     Int iColRefViewId  = pColCU->getSlice()->getRefPic( eColRefPicList, pColCU->getCUMvField(eColRefPicList)->getRefIdx(uiAbsPartAddr))->getViewIndex();
    5790 #else
    57915654    Int iCurrViewId    = m_pcSlice->getViewId ();
    57925655    Int iCurrRefViewId = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getViewId ();
    57935656    Int iColViewId     = pColCU->getSlice()->getViewId();
    57945657    Int iColRefViewId  = pColCU->getSlice()->getRefPic( eColRefPicList, pColCU->getCUMvField(eColRefPicList)->getRefIdx(uiAbsPartAddr))->getViewId();
    5795 #endif
    5796 #if H_3D_TMVP_SCALING_FIX_K0053
    57975658    iScale = 4096;
    57985659    if ( iCurrRefViewId != iCurrViewId && iColViewId != iColRefViewId )
    5799 #endif
     5660    {
    58005661      iScale = xGetDistScaleFactor( iCurrViewId, iCurrRefViewId, iColViewId, iColRefViewId );
    5801 #if H_3D_TMVP_FIX_TICKET_97
     5662    }
    58025663    if ( bMRG && iScale != 4096 && m_pcSlice->getIvMvScalingFlag( ) )
    5803 #else
    5804     if ( iScale != 4096 && m_pcSlice->getIvMvScalingFlag( ) )
    5805 #endif
    58065664    {
    58075665      rcMv = cColMv.scaleMv( iScale );
     
    58155673#endif
    58165674  }
    5817   else // CY: both bIsCurrRefLongTerm and bIsColRefLongTerm are 0
     5675  else
    58185676  {
    58195677    iScale = xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iColPOC, iColRefPOC);
     
    59795837}
    59805838#endif
     5839
    59815840#if H_3D_IV_MERGE
    5982 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    59835841Void TComDataCU::getDispforDepth (UInt uiPartIdx, UInt uiPartAddr, DisInfo* pDisp)
    5984 #else
    5985 Bool TComDataCU::getDispforDepth (UInt uiPartIdx, UInt uiPartAddr, DisInfo* pDisp)
    5986 #endif
    5987 {
    5988 
     5842{
    59895843  assert(getPartitionSize( uiPartAddr ) == SIZE_2Nx2N);
    59905844
     
    59925846  if ( getSlice()->getDefaultRefViewIdxAvailableFlag() )
    59935847  {
    5994       Int iViewIdx = getSlice()->getDefaultRefViewIdx();
    5995       pDisp->m_aVIdxCan = iViewIdx;
    5996       Int iDisp     = getSlice()->getDepthToDisparityB( iViewIdx )[ (Int64) (1 << ( getSlice()->getSPS()->getBitDepthY() - 1 )) ];
    5997 
    5998       cMv.setHor(iDisp);
    5999       cMv.setVer(0);
    6000       pDisp->m_acNBDV = cMv;
    6001       pDisp->m_aVIdxCan = iViewIdx;
    6002 #if !SEC_ARP_REM_ENC_RESTRICT_K0035
    6003       return true;
    6004 #endif
    6005   }
    6006 #if !SEC_ARP_REM_ENC_RESTRICT_K0035
    6007   return false;
    6008 #endif
    6009 }
    6010 #endif
    6011 
    6012 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     5848    Int iViewIdx = getSlice()->getDefaultRefViewIdx();
     5849    pDisp->m_aVIdxCan = iViewIdx;
     5850    Int iDisp     = getSlice()->getDepthToDisparityB( iViewIdx )[ (Int64) (1 << ( getSlice()->getSPS()->getBitDepthY() - 1 )) ];
     5851
     5852    cMv.setHor(iDisp);
     5853    cMv.setVer(0);
     5854    pDisp->m_acNBDV = cMv;
     5855    pDisp->m_aVIdxCan = iViewIdx;
     5856  }
     5857}
     5858#endif
     5859
     5860#if H_3D
    60135861Bool TComDataCU::getNeighDepth ( UInt uiPartIdx, UInt uiPartAddr, Pel* pNeighDepth, Int index )
    60145862{
    6015 #if NEIGHBORING_PIX_AVAILABILITY_FIX
    60165863  UInt  uiPartIdxLT, uiPartIdxRT;
    60175864  this->deriveLeftRightTopIdxAdi( uiPartIdxLT, uiPartIdxRT, 0, 0 );
     
    60665913
    60675914  return bDepAvail;
    6068 #else
    6069   Bool bDepAvail = false;
    6070   Pel *pDepth  = this->getPic()->getPicYuvRec()->getLumaAddr();
    6071   Int iDepStride =  this->getPic()->getPicYuvRec()->getStride();
    6072 
    6073   Int xP, yP, nPSW, nPSH;
    6074   this->getPartPosition(uiPartIdx, xP, yP, nPSW, nPSH);
    6075   UInt PicHeight=this->getPic()->getPicYuvRec()->getHeight();
    6076   UInt PicWidth=this->getPic()->getPicYuvRec()->getWidth();
    6077   switch(index)
    6078   {
    6079   case 0: // Mid Left
    6080     if( ( xP != 0 ) && ( ( yP + ( nPSH >> 1 ) ) < PicHeight ) )
    6081     {
    6082       *pNeighDepth = pDepth[ (yP+(nPSH>>1)) * iDepStride + (xP-1) ];
    6083       bDepAvail = true;
    6084     }
    6085     break;
    6086   case 1: // Mid Above
    6087     if( ( yP != 0 ) && ( ( xP + ( nPSW >> 1 ) ) < PicWidth ) )
    6088     {
    6089       *pNeighDepth = pDepth[ (yP-1) * iDepStride + (xP + (nPSW>>1)) ];
    6090       bDepAvail = true;
    6091     }
    6092     break;
    6093   default:
    6094     break;
    6095   }
    6096   return bDepAvail;
    6097 #endif
    6098 }
    6099 #else
    6100 #if H_3D_SINGLE_DEPTH
    6101 Bool TComDataCU::getNeighDepth (UInt uiPartIdx, UInt uiPartAddr, Pel* pNeighDepth, Int index)
    6102 {
    6103 
    6104   Bool bDepAvail = false;
    6105   Pel *pDepth  = this->getPic()->getPicYuvRec()->getLumaAddr();
    6106   Int iDepStride =  this->getPic()->getPicYuvRec()->getStride();
    6107 
    6108   Int xP, yP, nPSW, nPSH;
    6109   this->getPartPosition(uiPartIdx, xP, yP, nPSW, nPSH);
    6110   UInt PicHeight=this->getPic()->getPicYuvRec()->getHeight();
    6111   UInt PicWidth=this->getPic()->getPicYuvRec()->getWidth();
    6112   switch(index)
    6113   {
    6114   case 0: // Mid Left
    6115     if( ( xP != 0 ) && ( ( yP + ( nPSH >> 1 ) ) < PicHeight ) )
    6116     {
    6117       *pNeighDepth = pDepth[ (yP+(nPSH>>1)) * iDepStride + (xP-1) ];
    6118       bDepAvail = true;
    6119     }
    6120     break;
    6121   case 1: // Mid Above
    6122     if( ( yP != 0 ) && ( ( xP + ( nPSW >> 1 ) ) < PicWidth ) )
    6123     {
    6124       *pNeighDepth = pDepth[ (yP-1) * iDepStride + (xP + (nPSW>>1)) ];
    6125       bDepAvail = true;
    6126     }
    6127     break;
    6128   default:
    6129       break;
    6130   }
    6131   return bDepAvail;
    6132 }
    6133 #endif
    6134 #endif
    6135 
     5915}
     5916#endif
    61365917#if H_3D_NBDV
    61375918//Notes from QC:
     
    61395920//TBD#2: set of DvMCP values need to be done as part of inter-view motion prediction process. Remove this comment once merge related integration is done
    61405921//To be checked: Parallel Merge features for NBDV, related to DV_DERIVATION_PARALLEL_B0096 and LGE_IVMP_PARALLEL_MERGE_B0136 are not integrated. The need of these features due to the adoption of CU-based NBDV is not clear. We need confirmation on this, especially by proponents
    6141 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    61425922Void TComDataCU::getDisMvpCandNBDV( DisInfo* pDInfo
    6143 #else
    6144 Bool TComDataCU::getDisMvpCandNBDV( DisInfo* pDInfo
    6145 #endif
    61465923#if H_3D_NBDV_REF
    61475924, Bool bDepthRefine
     
    61515928  //// ******* Init variables ******* /////
    61525929  // Init disparity struct for results
    6153 #if !SEC_ARP_REM_ENC_RESTRICT_K0035
    6154   pDInfo->bDV = false;   
    6155 #endif
    61565930  pDInfo->m_aVIdxCan = -1;
    61575931
     
    62175991      if( bCheck )
    62185992      {
    6219 #if !(NTT_BUG_FIX_TK54)
    6220         clipMv(cColMv);
    6221 #endif
    62225993        pDInfo->m_acNBDV = cColMv;
    62235994        pDInfo->m_aVIdxCan  = iTargetViewIdx;
     
    62396010#else
    62406011        picDepth = getSlice()->getIvPic( true, iTargetViewIdx );
    6241 #if !BUG_FIX_TK65
    6242         assert(picDepth != NULL);
    6243 #endif
    62446012#endif
    62456013        if (picDepth && bDepthRefine)
     6014        {
    62466015          estimateDVFromDM(iTargetViewIdx, uiPartIdx, picDepth, uiPartAddr, &cColMv );
    6247 
     6016        }
    62486017        pDInfo->m_acDoNBDV  = cColMv;
    62496018#endif //H_3D_NBDV_REF
    6250 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    62516019        return;
    6252 #else
    6253         return true;
    6254 #endif
    62556020      }
    62566021    }
     
    62696034#endif
    62706035    ) )
    6271 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    62726036    return;
    6273 #else
    6274     return true;
    6275 #endif
    62766037
    62776038  //// ******* Get disparity from above block ******* /////
     
    62856046#endif
    62866047      ) )
    6287 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    62886048      return;
    6289 #else
    6290       return true;
    6291 #endif
    62926049  }
    62936050
     
    63026059        {
    63036060          TComMv cDispVec = cIDVInfo.m_acMvCand[iList][ curPos ];
    6304 #if !(NTT_BUG_FIX_TK54)
    6305           clipMv( cDispVec );
    6306 #endif
    63076061          pDInfo->m_acNBDV = cDispVec;
    63086062          pDInfo->m_aVIdxCan = cIDVInfo.m_aVIdxCan[iList][ curPos ];
     
    63246078#else
    63256079          TComPic* picDepth = getSlice()->getIvPic( true, pDInfo->m_aVIdxCan );
    6326 #if !BUG_FIX_TK65
    6327           assert(picDepth!=NULL);
    6328 #endif
    63296080#endif
    63306081
     
    63356086          pDInfo->m_acDoNBDV = cDispVec;
    63366087#endif
    6337 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    63386088          return;
    6339 #else
    6340           return true;
    6341 #endif
    63426089        }
    63436090      }
     
    63506097  if (getSlice()->getDefaultRefViewIdxAvailableFlag())
    63516098  {
    6352       pDInfo->m_aVIdxCan = getSlice()->getDefaultRefViewIdx();
     6099    pDInfo->m_aVIdxCan = getSlice()->getDefaultRefViewIdx();
    63536100
    63546101#if H_3D_NBDV_REF
    6355           TComPic* picDepth = NULL;
     6102    TComPic* picDepth = NULL;
    63566103#if H_3D_FCO_VSP_DONBDV_E0163
    6357           picDepth  = getSlice()->getIvPic(true, getSlice()->getViewIndex() );
    6358       if ( picDepth->getPicYuvRec() != NULL ) 
    6359       {
    6360           defaultDV.setZero();
    6361       }
    6362       else // Go back with virtual depth
    6363       {
    6364           picDepth = getSlice()->getIvPic( true, getSlice()->getDefaultRefViewIdx());
    6365       }
    6366 
    6367       assert(picDepth != NULL);
     6104    picDepth  = getSlice()->getIvPic(true, getSlice()->getViewIndex() );
     6105    if ( picDepth->getPicYuvRec() != NULL ) 
     6106    {
     6107      defaultDV.setZero();
     6108    }
     6109    else // Go back with virtual depth
     6110    {
     6111      picDepth = getSlice()->getIvPic( true, getSlice()->getDefaultRefViewIdx());
     6112    }
     6113
     6114    assert(picDepth != NULL);
    63686115#else
    6369           picDepth = getSlice()->getIvPic( true, getSlice()->getDefaultRefViewIdx());
    6370 #endif
    6371       if (picDepth && bDepthRefine)
    6372       {
    6373           estimateDVFromDM(getSlice()->getDefaultRefViewIdx(), uiPartIdx, picDepth, uiPartAddr, &defaultDV ); // from base view
    6374       }
    6375       pDInfo->m_acDoNBDV = defaultDV;
    6376 #endif
    6377 #if !SEC_ARP_REM_ENC_RESTRICT_K0035
    6378       return true;
    6379 #endif
    6380   }
    6381 #if !SEC_ARP_REM_ENC_RESTRICT_K0035
    6382   return false;
    6383 #endif
     6116    picDepth = getSlice()->getIvPic( true, getSlice()->getDefaultRefViewIdx());
     6117#endif
     6118    if (picDepth && bDepthRefine)
     6119    {
     6120      estimateDVFromDM(getSlice()->getDefaultRefViewIdx(), uiPartIdx, picDepth, uiPartAddr, &defaultDV ); // from base view
     6121    }
     6122    pDInfo->m_acDoNBDV = defaultDV;
     6123#endif
     6124  }
    63846125}
    63856126
     
    64236164    Pel iDisp = getMcpFromDM( pcBaseViewDepthPicYuv, cMvPred, iBlkX, iBlkY, iWidth, iHeight, aiShiftLUT );
    64246165    cMvPred->setHor( iDisp );
    6425 #if !(NTT_BUG_FIX_TK54)
    6426     clipMv(*cMvPred);
    6427 #endif
    64286166  }
    64296167}
     
    64516189        if (refViewIdx != m_pcSlice->getViewIndex())
    64526190        {
    6453 #if !(NTT_BUG_FIX_TK54)
    6454           clipMv(cMvPred);
    6455 #endif
    64566191          pNbDvInfo->m_acNBDV = cMvPred;
    64576192          pNbDvInfo->m_aVIdxCan = refViewIdx;
     
    64726207#else
    64736208          picDepth   = getSlice()->getIvPic (true, refViewIdx );
    6474 #if !BUG_FIX_TK65
    6475           assert(picDepth != NULL);
    6476 #endif
    64776209#endif
    64786210          UInt uiPartIdx = 0;   //Notes from MTK: Please confirm that using 0 as partition index and partition address is correct for CU-level DoNBDV
     
    64806212
    64816213          if (picDepth && bDepthRefine)
     6214          {
    64826215            estimateDVFromDM(refViewIdx, uiPartIdx, picDepth, uiPartAddr, &cMvPred );
    6483 
     6216          }
    64846217          pNbDvInfo->m_acDoNBDV = cMvPred;
    64856218#endif
     
    68706603#endif
    68716604#endif
    6872 #if !(NTT_BUG_FIX_TK54)
    6873                       clipMv( cMv );
    6874 #endif
    68756605                      paiPdmRefIdx  [ uiCurrRefListId ] = iPdmRefIdx;
    68766606                      pacPdmMv      [ uiCurrRefListId ] = cMv;
     
    69046634                {
    69056635                  RefPicList  eCurrRefPicList = RefPicList( uiCurrRefListId );
    6906                   Bool bLoop_stop = false;
    6907                   for(Int iLoop = 0; iLoop < 2 && !bLoop_stop; ++iLoop)
     6636                  Bool bLoopStop = false;
     6637                  for(Int iLoop = 0; iLoop < 2 && !bLoopStop; ++iLoop)
    69086638                  {
    69096639                    RefPicList eBaseRefPicList = (iLoop ==1)? RefPicList( 1 -  uiCurrRefListId ) : RefPicList( uiCurrRefListId );
     
    69316661                            }
    69326662
    6933 #if !(NTT_BUG_FIX_TK54)
    6934                             clipMv( cMv );
    6935 #endif
    6936                             bLoop_stop = true;
     6663                            bLoopStop = true;
    69376664
    69386665                            pcMvFieldSP[2*iPartition + uiCurrRefListId].setMvField(cMv, iPdmRefIdx);
     
    69546681
    69556682              }
    6956 #if !SHARP_SUBBLOCK_CLEAN_K0044
    6957               if (iSPHeight + iSPWidth == 12)
    6958               {
    6959                 if (puhInterDirSP[iPartition] == 3)
    6960                 {
    6961                   puhInterDirSP[iPartition] = 1;
    6962                   pcMvFieldSP[2*iPartition + 1].setMvField(TComMv(0,0), -1);
    6963                 }
    6964               }
    6965 #endif
    69666683              iPartition ++;
    69676684            }
     
    69966713      Int         iBaseAbsPartIdx;
    69976714
    6998 #if SEC_SHIFTED_IVMC_POS_K0036
    69996715      Int offsetW = (iLoopCan == 0) ? 0 : ( iWidth  * 2 );
    70006716      Int offsetH = (iLoopCan == 0) ? 0 : ( iHeight * 2 );
    7001 #else
    7002       Int offsetW = (iLoopCan == 0) ? 0 : ( ((iWidth /2)*4) + 4 );
    7003       Int offsetH = (iLoopCan == 0) ? 0 : ( ((iHeight/2)*4) + 4 );
    7004 #endif
    70056717
    70066718      Int         iBasePosX   = Clip3( 0, pcBaseRec->getWidth () - 1, iCurrPosX + ( (cDv.getHor() + offsetW + 2 ) >> 2 ) );
     
    70486760#endif
    70496761#endif
    7050 #if !(NTT_BUG_FIX_TK54)
    7051                     clipMv( cMv );
    7052 #endif
    70536762                    paiPdmRefIdx  [ (uiCurrRefListId + (iLoopCan<<2)) ] = iPdmRefIdx;
    70546763                    pacPdmMv      [ (uiCurrRefListId + (iLoopCan<<2)) ] = cMv;
     
    71046813#endif
    71056814            cMv.setVer( 0 );
    7106 #if !(NTT_BUG_FIX_TK54)
    7107             clipMv( cMv );
    7108 #endif
    71096815            pacPdmMv      [iRefListId + 2 + (iLoopCan<<2)] = cMv;
    71106816          }
     
    71876893{
    71886894  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
    7189   for( UInt ui = 0; ui < uiCurrPartNumb; ui++ ) { m_dmmWedgeTabIdx[dmmType][uiAbsPartIdx+ui] = tabIdx; }
     6895  for( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
     6896  {
     6897    m_dmmWedgeTabIdx[dmmType][uiAbsPartIdx+ui] = tabIdx;
     6898  }
    71906899}
    71916900#endif
  • trunk/source/Lib/TLibCommon/TComDataCU.h

    r1179 r1196  
    7272  PartSize    eVirtualPartSize;
    7373  UInt        uiVirtualPartIndex;
    74 } DBBPTmpData;
     74} DbbpTmpData;
    7575#endif
    7676
     
    110110  // -------------------------------------------------------------------------------------------------------------------
    111111  Bool*         m_skipFlag;           ///< array of skip flags
    112 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     112#if H_3D
    113113  Bool*         m_bDISFlag;         
    114114  UInt*         m_uiDISType;
    115 #else
    116 #if H_3D_SINGLE_DEPTH
    117   Bool*         m_singleDepthFlag;           ///< array of single depth flags
    118   Pel*          m_apSingleDepthValue;
    119 #endif
    120115#endif
    121116  Char*         m_pePartSize;         ///< array of partition sizes
     
    178173#endif
    179174#if H_3D_VSP
    180   Char*         m_piVSPFlag;          ///< array of VSP flags to indicate whehter a block uses VSP or not
    181                                       ///< 0: non-VSP; 1: VSP
     175  Char*         m_piVSPFlag;          ///< array of VSP flags to indicate whehter a block uses VSP or not  ///< 0: non-VSP; 1: VSP
    182176#endif
    183177#if H_3D_SPIVMP
    184   Bool*         m_pbSPIVMPFlag;       ///< array of sub-PU IVMP flags to indicate whehter a block uses sub-PU IVMP
    185                                       ///< 0: non-SPIVMP; 1: SPIVMP
     178  Bool*         m_pbSPIVMPFlag;       ///< array of sub-PU IVMP flags to indicate whehter a block uses sub-PU IVMP ///< 0: non-SPIVMP; 1: SPIVMP
    186179#endif
    187180#if H_3D_ARP
     
    199192  Bool*         m_pbSDCFlag;
    200193  Pel*          m_apSegmentDCOffset[2];
    201   Pel          m_apDmmPredictor[2];
     194  Pel           m_apDmmPredictor[2];
    202195#endif
    203196#endif
    204197#if H_3D_DBBP
    205198  Bool*         m_pbDBBPFlag;        ///< array of DBBP flags
    206   DBBPTmpData   m_sDBBPTmpData;
     199  DbbpTmpData   m_sDBBPTmpData;
    207200#endif
    208201#if H_3D
     
    252245  Bool          xGetColMVP( RefPicList eRefPicList, Int uiCUAddr, Int uiPartUnitIdx, TComMv& rcMv, Int& riRefIdx
    253246#if H_3D_TMVP
    254   ,
    255   Bool bMRG = true
     247  ,  Bool bMRG = true
    256248#endif
    257249  );
     
    350342  Void         setSkipFlag           ( UInt idx, Bool skip)     { m_skipFlag[idx] = skip;   }
    351343  Void         setSkipFlagSubParts   ( Bool skip, UInt absPartIdx, UInt depth );
    352 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     344#if H_3D
    353345  Bool*        getDISFlag            ()                         { return m_bDISFlag;          }
    354346  Bool         getDISFlag            ( UInt idx)                { return m_bDISFlag[idx];     }
     
    360352  Void         getDISType            ( UInt idx, UInt uiDISType)     { m_uiDISType[idx] = uiDISType;   }
    361353  Void         setDISTypeSubParts    ( UInt uiDISType, UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth );
    362 #else
    363 #if H_3D_SINGLE_DEPTH
    364   Bool*        getSingleDepthFlag            ()                        { return m_singleDepthFlag;          }
    365   Bool         getSingleDepthFlag            (UInt idx)                { return m_singleDepthFlag[idx];     }
    366   Void         setSingleDepthFlag           ( UInt idx, Bool singleDepth)     { m_singleDepthFlag[idx] = singleDepth;   }
    367   Void         setSingleDepthFlagSubParts   ( Bool singleDepth, UInt absPartIdx, UInt depth );
    368 
    369   Pel*         getSingleDepthValue( ) { return m_apSingleDepthValue; }
    370   Pel          getSingleDepthValue            (UInt idx)                { return m_apSingleDepthValue[idx];     }
    371   Void         setSingleDepthValue           ( UInt idx, Pel pDepthValue)     { m_apSingleDepthValue[idx] = pDepthValue;   }
    372   Void         setSingleDepthValueSubParts   (Pel singleDepthValue, UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth );
    373 #endif 
    374354#endif
    375355  Char*         getPredictionMode     ()                        { return m_pePredMode;        }
     
    385365  Void          setDBBPFlag           ( UInt uiIdx, Bool b )    { m_pbDBBPFlag[uiIdx] = b;           }
    386366  Void          setDBBPFlagSubParts   ( Bool bDBBPFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
    387   DBBPTmpData*  getDBBPTmpData        () { return &m_sDBBPTmpData; }
     367  DbbpTmpData*  getDBBPTmpData        () { return &m_sDBBPTmpData; }
    388368#endif
    389369 
     
    506486  );
    507487  Bool          xGetColDisMV      ( Int currCandPic, RefPicList eRefPicList, Int refidx, Int uiCUAddr, Int uiPartUnitIdx, TComMv& rcMv, Int & iTargetViewIdx, Int & iStartViewIdx );
    508 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    509488  Void          getDisMvpCandNBDV ( DisInfo* pDInfo
    510 #else
    511   Bool          getDisMvpCandNBDV ( DisInfo* pDInfo
    512 #endif
    513489#if H_3D_NBDV_REF
    514490   , Bool bDepthRefine = false
     
    517493   
    518494#if H_3D
    519 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    520495  Void          getDispforDepth  ( UInt uiPartIdx, UInt uiPartAddr, DisInfo* cDisp);
    521 #else
    522   Bool          getDispforDepth  ( UInt uiPartIdx, UInt uiPartAddr, DisInfo* cDisp);
    523 #endif
    524496  Bool          getDispMvPredCan(UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDis, Int* iPdm );
    525 #endif
    526 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     497
    527498   Bool          getNeighDepth (UInt uiPartIdx, UInt uiPartAddr, Pel* pNeighDepth, Int index);
    528 #else
    529 #if H_3D_SINGLE_DEPTH
    530    Bool          getNeighDepth (UInt uiPartIdx, UInt uiPartAddr, Pel* pNeighDepth, Int index);
    531 #endif
    532499#endif
    533500#if H_3D_NBDV_REF
     
    625592 
    626593  Void          clipMv                ( TComMv&     rcMv     );
    627 #if SONY_MV_V_CONST_C0078
    628   Void          checkMV_V (TComMv&  rcMv,  RefPicList eRefPicList, int iRefIdx );
     594#if H_MV
     595  Void          checkMvVertRest (TComMv&  rcMv,  RefPicList eRefPicList, int iRefIdx );
    629596#endif
    630597  Void          getMvPredLeft         ( TComMv&     rcMvPred )   { rcMvPred = m_cMvFieldA.getMv(); }
  • trunk/source/Lib/TLibCommon/TComMotionInfo.cpp

    r1179 r1196  
    335335  Int iStartPelY = g_auiRasterToPelY[g_auiZscanToRaster[uiAbsPartIdx]];
    336336  Int iEndPelX = iStartPelX + iWidth;
    337   Int iEndPelY = iStartPelY + iHeight;
    338 
    339   Int iCurrRaster, uiPartAddr;
     337  Int iEndPelY = iStartPelY + iHeight; 
    340338
    341339  for (Int i=iStartPelY; i<iEndPelY; i+=pcCU->getPic()->getMinCUHeight())
     
    343341    for (Int j=iStartPelX; j < iEndPelX; j += pcCU->getPic()->getMinCUWidth())
    344342    {
    345       iCurrRaster = i / pcCU->getPic()->getMinCUHeight() * pcCU->getPic()->getNumPartInWidth() + j/pcCU->getPic()->getMinCUWidth();
    346       uiPartAddr = g_auiRasterToZscan[iCurrRaster];
     343      Int iCurrRaster = i / pcCU->getPic()->getMinCUHeight() * pcCU->getPic()->getNumPartInWidth() + j/pcCU->getPic()->getMinCUWidth();
     344      Int uiPartAddr = g_auiRasterToZscan[iCurrRaster];
    347345      uiPartAddr -= pcCU->getZorderIdxInCU(); 
    348346
  • trunk/source/Lib/TLibCommon/TComMotionInfo.h

    r1179 r1196  
    6363typedef struct _DisCand
    6464{
    65 #if !SEC_ARP_REM_ENC_RESTRICT_K0035
    66   Bool bDV;
    67 #endif
    6865  TComMv m_acNBDV;              // DV from NBDV
    6966#if H_3D_NBDV_REF
  • trunk/source/Lib/TLibCommon/TComPrediction.cpp

    r1179 r1196  
    5454  m_pDepthBlock = (Int*) malloc(MAX_NUM_SPU_W*MAX_NUM_SPU_W*sizeof(Int));
    5555  if (m_pDepthBlock == NULL)
     56  {
    5657      printf("ERROR: UKTGHU, No memory allocated.\n");
     58  }
    5759#endif
    5860}
     
    6264#if H_3D_VSP
    6365  if (m_pDepthBlock != NULL)
    64       free(m_pDepthBlock);
     66  {
     67    free(m_pDepthBlock);
     68  }
    6569  m_cYuvDepthOnVsp.destroy();
    6670#endif
     
    513517
    514518#if H_3D_DIM_DMM
    515   if( dimType == DMM4_IDX && dmm4Segmentation == NULL ) { dmmSegmentation->destroy(); delete dmmSegmentation; }
     519  if( dimType == DMM4_IDX && dmm4Segmentation == NULL )
     520  {
     521    dmmSegmentation->destroy();
     522    delete dmmSegmentation;
     523  }
    516524#endif
    517525}
     
    630638
    631639#if H_3D_DBBP
    632 #if HS_DBBP_CLEAN_K0048
    633640PartSize TComPrediction::getPartitionSizeFromDepth(Pel* pDepthPels, UInt uiDepthStride, UInt uiSize, TComDataCU*& pcCU)
    634 #else
    635 PartSize TComPrediction::getPartitionSizeFromDepth(Pel* pDepthPels, UInt uiDepthStride, UInt uiSize)
    636 #endif
    637641{
    638642  // find virtual partitioning for this CU based on depth block
    639643  // segmentation of texture block --> mask IDs
    640644  Pel*  pDepthBlockStart      = pDepthPels;
    641  
     645
    642646  // first compute average of depth block for thresholding
    643647  Int iSumDepth = 0;
    644648  Int iSubSample = 4;
    645 #if HS_DBBP_CLEAN_K0048
    646649  Int iPictureWidth = pcCU->getSlice()->getIvPic (true, pcCU->getDvInfo(0).m_aVIdxCan)->getPicYuvRec()->getWidth();
    647650  Int iPictureHeight = pcCU->getSlice()->getIvPic (true, pcCU->getDvInfo(0).m_aVIdxCan)->getPicYuvRec()->getHeight();
     
    653656  Int iBlkX = ( pcCU->getAddr() % pcCU->getSlice()->getIvPic (true, pcCU->getDvInfo(0).m_aVIdxCan)->getFrameWidthInCU() ) * g_uiMaxCUWidth  + g_auiRasterToPelX[ g_auiZscanToRaster[ pcCU->getZorderIdxInCU() ] ]+ ((cDv.getHor()+2)>>2);
    654657  Int iBlkY = ( pcCU->getAddr() / pcCU->getSlice()->getIvPic (true, pcCU->getDvInfo(0).m_aVIdxCan)->getFrameWidthInCU() ) * g_uiMaxCUHeight + g_auiRasterToPelY[ g_auiZscanToRaster[ pcCU->getZorderIdxInCU() ] ]+ ((cDv.getVer()+2)>>2);
     658 
    655659  UInt t=0;
    656660
    657661  for (Int y=0; y<uiSize; y+=iSubSample)
    658    {
     662  {
    659663    for (Int x=0; x<uiSize; x+=iSubSample)
    660    {
    661 if (iBlkX+x>iPictureWidth)
    662 {
    663     Int depthPel = pDepthPels[t];
    664     iSumDepth += depthPel;
    665 }
    666 else
    667 {
    668     Int depthPel = pDepthPels[x];
    669     t=x;
    670     iSumDepth += depthPel;
    671 }
    672    }
    673    
     664    {
     665      if (iBlkX+x>iPictureWidth)
     666      {
     667        Int depthPel = pDepthPels[t];
     668        iSumDepth += depthPel;
     669      }
     670      else
     671      {
     672        Int depthPel = pDepthPels[x];
     673        t=x;
     674        iSumDepth += depthPel;
     675      }
     676    }
     677
    674678    // next row
    675679    if (!(iBlkY+y+4>iPictureHeight))
    676     pDepthPels += uiDepthStride*iSubSample;
    677 #else
    678   for (Int y=0; y<uiSize; y+=iSubSample)
    679   {
    680     for (Int x=0; x<uiSize; x+=iSubSample)
    681     {
    682       Int depthPel = pDepthPels[x];
    683      
    684       iSumDepth += depthPel;
    685     }
    686    
    687     // next row
    688     pDepthPels += uiDepthStride*iSubSample;
    689 #endif
    690   }
    691  
     680    {
     681      pDepthPels += uiDepthStride*iSubSample;
     682    }
     683  }
     684
    692685  Int iSizeInBits = g_aucConvertToBit[uiSize] - g_aucConvertToBit[iSubSample];  // respect sub-sampling factor
    693686  Int iMean = iSumDepth >> iSizeInBits*2;       // iMean /= (uiSize*uiSize);
    694  
     687
    695688  // start again for segmentation
    696689  pDepthPels = pDepthBlockStart;
    697  
     690
    698691  // start mapping process
    699692  Int matchedPartSum[2][2] = {{0,0},{0,0}}; // counter for each part size and boolean option
    700693  PartSize virtualPartSizes[2] = { SIZE_Nx2N, SIZE_2NxN};
    701  
     694
    702695  UInt uiHalfSize = uiSize>>1;
    703696  for (Int y=0; y<uiSize; y+=iSubSample)
     
    705698    for (Int x=0; x<uiSize; x+=iSubSample)
    706699    {
    707 #if HS_DBBP_CLEAN_K0048
    708700      Int depthPel = 0;
    709 if (iBlkX+x>iPictureWidth)
    710 {
    711     depthPel = pDepthPels[t];
    712 }
    713 else
    714 {
    715     depthPel = pDepthPels[x];
    716      t=x;
    717 }
    718 #else
    719       Int depthPel = pDepthPels[x];
    720 #endif
    721      
     701      if (iBlkX+x>iPictureWidth)
     702      {
     703        depthPel = pDepthPels[t];
     704      }
     705      else
     706      {
     707        depthPel = pDepthPels[x];
     708        t=x;
     709      }
     710
    722711      // decide which segment this pixel belongs to
    723712      Int ucSegment = (Int)(depthPel>iMean);
    724      
     713
    725714      // Matched Filter to find optimal (conventional) partitioning
    726      
     715
    727716      // SIZE_Nx2N
    728717      if(x<uiHalfSize)  // left
     
    734723        matchedPartSum[0][1-ucSegment]++;
    735724      }
    736      
     725
    737726      // SIZE_2NxN
    738727      if(y<uiHalfSize)  // top
     
    745734      }
    746735    }
    747    
     736
    748737    // next row
    749 #if HS_DBBP_CLEAN_K0048
    750738    if (!(iBlkY+y+4>iPictureHeight))
    751 #endif
    752     pDepthPels += uiDepthStride*iSubSample;
    753   }
    754  
     739    {
     740      pDepthPels += uiDepthStride*iSubSample;
     741    }
     742  }
     743
    755744  PartSize matchedPartSize = SIZE_NONE;
    756  
     745
    757746  Int iMaxMatchSum = 0;
    758747  for(Int p=0; p<2; p++)  // loop over partition
     
    767756    }
    768757  }
    769  
     758
    770759  AOF( matchedPartSize != SIZE_NONE );
    771  
     760
    772761  return matchedPartSize;
    773762}
    774763
    775 #if HS_DBBP_CLEAN_K0048
    776764Bool TComPrediction::getSegmentMaskFromDepth( Pel* pDepthPels, UInt uiDepthStride, UInt uiWidth, UInt uiHeight, Bool* pMask, TComDataCU*& pcCU)
    777 #else
    778 Bool TComPrediction::getSegmentMaskFromDepth( Pel* pDepthPels, UInt uiDepthStride, UInt uiWidth, UInt uiHeight, Bool* pMask )
    779 #endif
    780765{
    781766  // segmentation of texture block --> mask IDs
     
    786771  Int uiMinDepth = MAX_INT;
    787772  Int uiMaxDepth = 0;
    788 #if HS_DBBP_CLEAN_K0048
    789773  uiMinDepth = pDepthPels[ 0 ];
    790774  uiMaxDepth = pDepthPels[ 0 ];
    791775  iSumDepth  = pDepthPels[ 0 ];
    792   UInt t=0;
     776 
    793777  Int iPictureWidth = pcCU->getSlice()->getIvPic (true, pcCU->getDvInfo(0).m_aVIdxCan)->getPicYuvRec()->getWidth();
    794778  Int iPictureHeight = pcCU->getSlice()->getIvPic (true, pcCU->getDvInfo(0).m_aVIdxCan)->getPicYuvRec()->getHeight(); 
     
    848832    uiMaxDepth = std::max( uiMaxDepth, (Int)pDepthPels[ uiDepthStride * (uiHeight - 1) + uiWidth - 1 ]);
    849833  }
    850 #else
    851   iSumDepth  = pDepthPels[ 0 ];
    852   iSumDepth += pDepthPels[ uiWidth - 1 ];
    853   iSumDepth += pDepthPels[ uiDepthStride * (uiHeight - 1) ];
    854   iSumDepth += pDepthPels[ uiDepthStride * (uiHeight - 1) + uiWidth - 1 ];
    855 
    856   uiMinDepth = pDepthPels[ 0 ];
    857   uiMinDepth = std::min( uiMinDepth, (Int)pDepthPels[ uiWidth - 1 ]);
    858   uiMinDepth = std::min( uiMinDepth, (Int)pDepthPels[ uiDepthStride * (uiHeight - 1) ]);
    859   uiMinDepth = std::min( uiMinDepth, (Int)pDepthPels[ uiDepthStride * (uiHeight - 1) + uiWidth - 1 ]);
    860 
    861   uiMaxDepth = pDepthPels[ 0 ];
    862   uiMaxDepth = std::max( uiMaxDepth, (Int)pDepthPels[ uiWidth - 1 ]);
    863   uiMaxDepth = std::max( uiMaxDepth, (Int)pDepthPels[ uiDepthStride * (uiHeight - 1) ]);
    864   uiMaxDepth = std::max( uiMaxDepth, (Int)pDepthPels[ uiDepthStride * (uiHeight - 1) + uiWidth - 1 ]);
    865 #endif
    866834
    867835  // don't generate mask for blocks with small depth range (encoder decision)
     
    880848
    881849  // generate mask
     850  UInt t=0;
    882851  UInt uiSumPix[2] = {0,0};
    883852  for (Int y=0; y<uiHeight; y++)
     
    885854    for (Int x=0; x<uiHeight; x++)
    886855    {
    887 #if HS_DBBP_CLEAN_K0048
    888856      Int depthPel = 0;
    889857      if (iBlkX+x>iPictureWidth)
     
    896864        t=x;
    897865      }
    898 #else
    899       Int depthPel = pDepthPels[x];
    900 #endif
    901866
    902867      // decide which segment this pixel belongs to
     
    916881
    917882    // next row
    918 #if HS_DBBP_CLEAN_K0048
    919883    if (!(iBlkY+y+1>iPictureHeight))
    920 #endif
    921884      pDepthPels += uiDepthStride;
    922885    pMask += MAX_CU_SIZE;
     
    1003966  }
    1004967
    1005   if ( tmpTar    ) { xFree(tmpTar);             tmpTar        = NULL; }
     968  if ( tmpTar    )
     969  {
     970    xFree(tmpTar);             
     971    tmpTar        = NULL;
     972  }
    1006973 
    1007974  // now combine chroma
     
    11061073  }
    11071074
    1108   if ( tmpTarU    ) { xFree(tmpTarU);             tmpTarU        = NULL; }
    1109   if ( tmpTarV    ) { xFree(tmpTarV);             tmpTarV        = NULL; }
     1075  if( tmpTarU )
     1076  {
     1077    xFree(tmpTarU);
     1078    tmpTarU        = NULL;
     1079  }
     1080  if ( tmpTarV    )
     1081  {
     1082    xFree(tmpTarV);
     1083    tmpTarV        = NULL;
     1084  }
    11101085}
    11111086#endif
     
    12931268  TComMv      cMv         = pcCU->getCUMvField( eRefPicList )->getMv( uiPartAddr );
    12941269  pcCU->clipMv(cMv);
    1295 #if SONY_MV_V_CONST_C0078
    1296   pcCU->checkMV_V(cMv, eRefPicList, iRefIdx );
     1270#if H_MV
     1271  pcCU->checkMvVertRest(cMv, eRefPicList, iRefIdx );
    12971272#endif
    12981273#if H_3D_ARP
     
    13931368#if H_3D_NBDV
    13941369  DisInfo cDistparity;
    1395 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    13961370  cDistparity.m_acNBDV = pcCU->getDvInfo(0).m_acNBDV;
    13971371  cDistparity.m_aVIdxCan = pcCU->getDvInfo(uiPartAddr).m_aVIdxCan;
    13981372#else
    1399   cDistparity.bDV           = pcCU->getDvInfo(uiPartAddr).bDV;
    1400   if( cDistparity.bDV )
    1401   {
    1402     cDistparity.m_acNBDV = pcCU->getDvInfo(0).m_acNBDV;
    1403     assert(pcCU->getDvInfo(uiPartAddr).bDV ==  pcCU->getDvInfo(0).bDV);
    1404     cDistparity.m_aVIdxCan = pcCU->getDvInfo(uiPartAddr).m_aVIdxCan;
    1405   }
    1406 #endif
    1407 #else
    14081373  assert(0); // ARP can be applied only when a DV is available
    14091374#endif
    1410 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    14111375  UChar dW = pcCU->getARPW ( uiPartAddr );
    1412 #else
    1413   UChar dW = cDistparity.bDV ? pcCU->getARPW ( uiPartAddr ) : 0;
    1414 #endif
    1415 
    1416 #if !SEC_ARP_REM_ENC_RESTRICT_K0035
    1417   if( cDistparity.bDV )
    1418 #endif
     1376
    14191377  {
    14201378    Int arpRefIdx = pcCU->getSlice()->getFirstTRefIdx(eRefPicList);
     
    14681426      pYuvB0->clear(); pYuvB1->clear();
    14691427    }
    1470 #if !SEC_ARP_REM_ENC_RESTRICT_K0035
    1471     assert ( cDistparity.bDV );
    1472 #endif   
    14731428    TComMv cNBDV = cDistparity.m_acNBDV;
    14741429    pcCU->clipMv( cNBDV );
     
    24382393    for( UInt k = 0; k < (patternStride * patternStride); k++ )
    24392394    {
    2440       if( true == biSegPattern[k] ) { ptrDst[k] = valDC2; }
    2441       else                          { ptrDst[k] = valDC1; }
     2395      if( true == biSegPattern[k] )
     2396      {
     2397        ptrDst[k] = valDC2;
     2398      }
     2399      else                         
     2400      {
     2401        ptrDst[k] = valDC1;
     2402      }
    24422403    }
    24432404  }
     
    24492410      for( UInt uiX = 0; uiX < patternStride; uiX++ )
    24502411      {
    2451         if( true == biSegPattern[uiX] ) { piTemp[uiX] = valDC2; }
    2452         else                            { piTemp[uiX] = valDC1; }
     2412        if( true == biSegPattern[uiX] )
     2413        {
     2414          piTemp[uiX] = valDC2;
     2415        }
     2416        else                           
     2417        {
     2418          piTemp[uiX] = valDC1;
     2419        }
    24532420      }
    24542421      piTemp       += dstStride;
     
    25202487  Int iSumPix[2];
    25212488  memset(iSumPix, 0, sizeof(Int)*2);
     2489
    25222490  for( Int i = 0; i < uiNumSegments; i++ )
    25232491  {
    2524     rpSegMeans[i] = 0;
    2525   }
    2526   if (orgDC == false)
     2492    rpSegMeans[i] = 0; 
     2493  }
     2494
     2495  if ( !orgDC )
    25272496  {
    25282497    Pel* pLeftTop = pOrig;
     
    25442513    subSamplePix = 1;
    25452514  }
     2515
    25462516  for (Int y=0; y<uiSize; y+=subSamplePix)
    25472517  {
     
    25632533  {
    25642534    if( iSumPix[ucSeg] > 0 )
     2535    {
    25652536      rpSegMeans[ucSeg] = iSumDepth[ucSeg] / iSumPix[ucSeg];
     2537    }
    25662538    else
     2539    {
    25672540      rpSegMeans[ucSeg] = 0;  // this happens for zero-segments
     2541    }
    25682542  }
    25692543}
  • trunk/source/Lib/TLibCommon/TComPrediction.h

    r1179 r1196  
    121121  Void xPredInterUniSubPU        ( TComDataCU *cu, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Bool bi, Int widthSubPU=4, Int heightSubPU=4 );
    122122#endif
    123 
    124   Void xWeightedAverage         ( TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, Int iRefIdx0, Int iRefIdx1, UInt uiPartAddr, Int iWidth, Int iHeight, TComYuv*& rpcYuvDst );
    125  
     123  Void xWeightedAverage         ( TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, Int iRefIdx0, Int iRefIdx1, UInt uiPartAddr, Int iWidth, Int iHeight, TComYuv*& rpcYuvDst ); 
    126124  Void xGetLLSPrediction ( TComPattern* pcPattern, Int* pSrc0, Int iSrcStride, Pel* pDst0, Int iDstStride, UInt uiWidth, UInt uiHeight, UInt uiExt0 );
    127125#if H_3D_IC
     
    175173 
    176174#if H_3D_DBBP
    177 #if HS_DBBP_CLEAN_K0048
    178175  PartSize      getPartitionSizeFromDepth(Pel* pDepthPels, UInt uiDepthStride, UInt uiSize, TComDataCU*& pcCU);
    179176  Bool          getSegmentMaskFromDepth( Pel* pDepthPels, UInt uiDepthStride, UInt uiWidth, UInt uiHeight, Bool* pMask, TComDataCU*& pcCU);
    180 #else
    181   PartSize      getPartitionSizeFromDepth(Pel* pDepthPels, UInt uiDepthStride, UInt uiSize);
    182   Bool          getSegmentMaskFromDepth( Pel* pDepthPels, UInt uiDepthStride, UInt uiWidth, UInt uiHeight, Bool* pMask );
    183 #endif
    184177  Void          combineSegmentsWithMask( TComYuv* pInYuv[2], TComYuv* pOutYuv, Bool* pMask, UInt uiWidth, UInt uiHeight, UInt uiPartAddr, UInt partSize );
    185178#endif
  • trunk/source/Lib/TLibCommon/TComRdCost.cpp

    r1179 r1196  
    341341    else if( eDFunc >= DF_HADS && eDFunc <= DF_HADS16N )
    342342    {
    343 #if !RWTH_DBBP_NO_SATD_K0028
    344       rcDistParam.DistFunc = TComRdCost::xGetMaskedHADs;
    345 #else
    346343      rcDistParam.DistFunc = TComRdCost::xGetMaskedSAD;
    347 #endif
    348344    }
    349345    else if( eDFunc >= DF_VSD && eDFunc <= DF_VSD16N )
     
    445441  if( m_bUseMask )
    446442  {
    447 #if !RWTH_DBBP_NO_SATD_K0028
    448     rcDistParam.DistFunc = (bHADME)?TComRdCost::xGetMaskedHADs:TComRdCost::xGetMaskedSAD;
    449 #else
    450443    rcDistParam.DistFunc = TComRdCost::xGetMaskedSAD;
    451 #endif
    452444  }
    453445#endif
     
    472464  if( m_bUseMask )
    473465  {
    474 #if !RWTH_DBBP_NO_SATD_K0028
    475     rcDP.DistFunc = (bHadamard)?TComRdCost::xGetMaskedHADs:TComRdCost::xGetMaskedSAD;
    476 #else
    477466    rcDP.DistFunc = TComRdCost::xGetMaskedSAD;
    478 #endif
    479467  }
    480468#endif
     
    729717}
    730718
    731 #if !RWTH_DBBP_NO_SATD_K0028
    732 UInt TComRdCost::xGetMaskedHADs( DistParam* pcDtParam )
    733 {
    734   AOF(!pcDtParam->bApplyWeight);
    735 #if H_3D_IC
    736   AOF(!pcDtParam->bUseIC);
    737 #endif
    738   Pel* piOrg   = pcDtParam->pOrg;
    739   Pel* piCur   = pcDtParam->pCur;
    740   Int  iRows   = pcDtParam->iRows;
    741   Int  iCols   = pcDtParam->iCols;
    742   Int  iStrideCur = pcDtParam->iStrideCur;
    743   Int  iStrideOrg = pcDtParam->iStrideOrg;
    744   Int  iStep  = pcDtParam->iStep;
    745  
    746   Int  x, y;
    747  
    748   UInt uiSum = 0;
    749  
    750 #if NS_HAD
    751   if( ( ( iRows % 8 == 0) && (iCols % 8 == 0) && ( iRows == iCols ) ) || ( ( iRows % 8 == 0 ) && (iCols % 8 == 0) && !pcDtParam->bUseNSHAD ) )
    752 #else
    753     if( ( iRows % 8 == 0) && (iCols % 8 == 0) )
    754 #endif
    755     {
    756       Int  iOffsetOrg = iStrideOrg<<3;
    757       Int  iOffsetCur = iStrideCur<<3;
    758       for ( y=0; y<iRows; y+= 8 )
    759       {
    760         for ( x=0; x<iCols; x+= 8 )
    761         {
    762           if( piOrg[x] != DBBP_INVALID_SHORT )
    763           {
    764             uiSum += xCalcHADs8x8( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
    765           }
    766         }
    767         piOrg += iOffsetOrg;
    768         piCur += iOffsetCur;
    769       }
    770     }
    771 #if NS_HAD
    772     else if ( ( iCols > 8 ) && ( iCols > iRows ) && pcDtParam->bUseNSHAD )
    773     {
    774       Int  iOffsetOrg = iStrideOrg<<2;
    775       Int  iOffsetCur = iStrideCur<<2;
    776       for ( y=0; y<iRows; y+= 4 )
    777       {
    778         for ( x=0; x<iCols; x+= 16 )
    779         {
    780           if( piOrg[x] != DBBP_INVALID_SHORT )
    781           {
    782             uiSum += xCalcHADs16x4( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
    783           }
    784         }
    785         piOrg += iOffsetOrg;
    786         piCur += iOffsetCur;
    787       }
    788     }
    789     else if ( ( iRows > 8 ) && ( iCols < iRows ) && pcDtParam->bUseNSHAD )
    790     {
    791       Int  iOffsetOrg = iStrideOrg<<4;
    792       Int  iOffsetCur = iStrideCur<<4;
    793       for ( y=0; y<iRows; y+= 16 )
    794       {
    795         for ( x=0; x<iCols; x+= 4 )
    796         {
    797           if( piOrg[x] != DBBP_INVALID_SHORT )
    798           {
    799             uiSum += xCalcHADs4x16( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
    800           }
    801         }
    802         piOrg += iOffsetOrg;
    803         piCur += iOffsetCur;
    804       }
    805     }
    806 #endif
    807     else if( ( iRows % 4 == 0) && (iCols % 4 == 0) )
    808     {
    809       Int  iOffsetOrg = iStrideOrg<<2;
    810       Int  iOffsetCur = iStrideCur<<2;
    811      
    812       for ( y=0; y<iRows; y+= 4 )
    813       {
    814         for ( x=0; x<iCols; x+= 4 )
    815         {
    816           if( piOrg[x] != DBBP_INVALID_SHORT )
    817           {
    818             uiSum += xCalcHADs4x4( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
    819           }
    820         }
    821         piOrg += iOffsetOrg;
    822         piCur += iOffsetCur;
    823       }
    824     }
    825     else if( ( iRows % 2 == 0) && (iCols % 2 == 0) )
    826     {
    827       Int  iOffsetOrg = iStrideOrg<<1;
    828       Int  iOffsetCur = iStrideCur<<1;
    829       for ( y=0; y<iRows; y+=2 )
    830       {
    831         for ( x=0; x<iCols; x+=2 )
    832         {
    833           if( piOrg[x] != DBBP_INVALID_SHORT )
    834           {
    835             uiSum += xCalcHADs2x2( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
    836           }
    837         }
    838         piOrg += iOffsetOrg;
    839         piCur += iOffsetCur;
    840       }
    841     }
    842     else
    843     {
    844       assert(false);
    845     }
    846  
    847   return uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8);
    848 }
    849 #endif
    850719
    851720UInt TComRdCost::xGetMaskedVSD( DistParam* pcDtParam )
     
    29932862UInt TComRdCost::getVSDEstimate( Int dDM, Pel* pOrg, Int iOrgStride,  Pel* pVirRec, Pel* pVirOrg, Int iVirStride, Int x, Int y )
    29942863{
    2995   Double dD;
    2996   Int iTemp;
    2997 
    2998   dD = ( (Double) ( dDM >> DISTORTION_PRECISION_ADJUSTMENT( g_bitDepthY - 8 ) ) ) * m_dDisparityCoeff;
     2864  Double  dD = ( (Double) ( dDM >> DISTORTION_PRECISION_ADJUSTMENT( g_bitDepthY - 8 ) ) ) * m_dDisparityCoeff;
    29992865
    30002866  Double dDepthWeight = ( pOrg[x] >=  ( (1<<(g_bitDepthY - 3)) + (1<<(g_bitDepthY - 2)) ) ? 4 : pOrg[x] > ((1<<g_bitDepthY) >> 4) ? (Float)(pOrg[x] - ((1<<g_bitDepthY) >> 4))/(Float)((1<<g_bitDepthY) >> 3) + 1 : 1.0 );
    30012867  Double dTemp = ( 0.5 * fabs(dD) * dDepthWeight * ( abs( (Int) pVirRec[ x+y*iVirStride ] - (Int) pVirRec[ x-1+y*iVirStride ] ) + abs( (Int) pVirRec[ x+y*iVirStride ] - (Int) pVirRec[ x+1+y*iVirStride ] ) ) );
    3002   iTemp = (Int) (((dTemp) < 0)? (Int)((dTemp) - 0.5) : (Int)((dTemp) + 0.5));
     2868  Int iTemp = (Int) (((dTemp) < 0)? (Int)((dTemp) - 0.5) : (Int)((dTemp) + 0.5));
    30032869
    30042870  return (UInt) ( (iTemp*iTemp)>>1 );
  • trunk/source/Lib/TLibCommon/TComRdCost.h

    r1179 r1196  
    320320  static UInt xGetMaskedSSE     ( DistParam* pcDtParam );
    321321  static UInt xGetMaskedSAD     ( DistParam* pcDtParam );
    322 #if !RWTH_DBBP_NO_SATD_K0028
    323   static UInt xGetMaskedHADs    ( DistParam* pcDtParam );
    324 #endif
    325322  static UInt xGetMaskedVSD     ( DistParam* pcDtParam );
    326323#endif
  • trunk/source/Lib/TLibCommon/TComRom.cpp

    r1179 r1196  
    104104  if( !g_dmmWedgeLists.empty() )
    105105  {
    106     for( UInt ui = 0; ui < g_dmmWedgeLists.size(); ui++ ) { g_dmmWedgeLists[ui].clear(); }
     106    for( UInt ui = 0; ui < g_dmmWedgeLists.size(); ui++ )
     107    {
     108      g_dmmWedgeLists[ui].clear();
     109    }
    107110    g_dmmWedgeLists.clear();
    108111  }
    109112  if( !g_dmmWedgeRefLists.empty() )
    110113  {
    111     for( UInt ui = 0; ui < g_dmmWedgeRefLists.size(); ui++ ) { g_dmmWedgeRefLists[ui].clear(); }
     114    for( UInt ui = 0; ui < g_dmmWedgeRefLists.size(); ui++ )
     115    {
     116      g_dmmWedgeRefLists[ui].clear();
     117    }
    112118    g_dmmWedgeRefLists.clear();
    113119  }
     
    115121  if( !g_dmmWedgeNodeLists.empty() )
    116122  {
    117     for( UInt ui = 0; ui < g_dmmWedgeNodeLists.size(); ui++ ) { g_dmmWedgeNodeLists[ui].clear(); }
     123    for( UInt ui = 0; ui < g_dmmWedgeNodeLists.size(); ui++ )
     124    {
     125      g_dmmWedgeNodeLists[ui].clear();
     126    }
    118127    g_dmmWedgeNodeLists.clear();
    119128  }
     
    745754  assert( uiWidth == uiHeight );
    746755
    747 #if SHARP_DMM_CLEAN_K0042
    748756  Int posStart = 0, posEnd = 0;
    749 #else
    750   UChar    uhStartX = 0,    uhStartY = 0,    uhEndX = 0,    uhEndY = 0;
    751   Int   iStepStartX = 0, iStepStartY = 0, iStepEndX = 0, iStepEndY = 0;
    752 #endif
    753757
    754758  UInt uiBlockSize = 0;
     
    762766  for( UInt uiOri = 0; uiOri < 6; uiOri++ )
    763767  {
    764 #if !SHARP_DMM_CLEAN_K0042
    765     // init the edge line parameters for each of the 6 wedgelet types
    766     switch( uiOri )
    767     {
    768     case( 0 ): {  uhStartX = 0;               uhStartY = 0;               uhEndX = 0;               uhEndY = 0;               iStepStartX = +1; iStepStartY =  0; iStepEndX =  0; iStepEndY = +1; break; }
    769     case( 1 ): {  uhStartX = (uiBlockSize-1); uhStartY = 0;               uhEndX = (uiBlockSize-1); uhEndY = 0;               iStepStartX =  0; iStepStartY = +1; iStepEndX = -1; iStepEndY =  0; break; }
    770     case( 2 ): {  uhStartX = (uiBlockSize-1); uhStartY = (uiBlockSize-1); uhEndX = (uiBlockSize-1); uhEndY = (uiBlockSize-1); iStepStartX = -1; iStepStartY =  0; iStepEndX =  0; iStepEndY = -1; break; }
    771     case( 3 ): {  uhStartX = 0;               uhStartY = (uiBlockSize-1); uhEndX = 0;               uhEndY = (uiBlockSize-1); iStepStartX =  0; iStepStartY = -1; iStepEndX = +1; iStepEndY =  0; break; }
    772     case( 4 ): {  uhStartX = 0;               uhStartY = 0;               uhEndX = 0;               uhEndY = (uiBlockSize-1); iStepStartX = +1; iStepStartY =  0; iStepEndX = +1; iStepEndY =  0; break; }
    773     case( 5 ): {  uhStartX = (uiBlockSize-1); uhStartY = 0;               uhEndX = 0;               uhEndY = 0;               iStepStartX =  0; iStepStartY = +1; iStepEndX =  0; iStepEndY = +1; break; }
    774     }
    775 #endif
    776 
    777 #if SHARP_DMM_CLEAN_K0042
     768
    778769    posEnd = (Int) racWedgeList.size();
    779770    if (uiOri == 0 || uiOri == 4)
    780771    {
    781 #endif
    782772    for( Int iK = 0; iK < uiBlockSize; iK += (uiWidth>=16 ?2:1))
    783773    {
    784774      for( Int iL = 0; iL < uiBlockSize; iL += ((uiWidth>=16 && uiOri<4)?2:1) )
    785775      {
    786 #if SHARP_DMM_CLEAN_K0042
    787776        Int xS = iK;
    788777        Int yS = 0;
     
    790779        Int yE = (uiOri == 0) ? iL : uiBlockSize - 1;
    791780        cTempWedgelet.setWedgelet( xS, yS, xE, yE, uiOri, eWedgeRes, ((iL%2)==0 && (iK%2)==0) );
    792 #else
    793         cTempWedgelet.setWedgelet( uhStartX + (iK*iStepStartX) , uhStartY + (iK*iStepStartY), uhEndX + (iL*iStepEndX), uhEndY + (iL*iStepEndY), (UChar)uiOri, eWedgeRes, ((iL%2)==0 && (iK%2)==0) );
    794 #endif
    795781        addWedgeletToList( cTempWedgelet, racWedgeList, racWedgeRefList );
    796782      }
    797783    }
    798 #if SHARP_DMM_CLEAN_K0042
    799784    }
    800785    else
     
    807792    }
    808793    posStart = posEnd;
    809 #endif
    810794  }
    811795
  • trunk/source/Lib/TLibCommon/TComRom.h

    r1179 r1196  
    290290
    291291#if H_MV_ENC_DEC_TRAC
    292 #define DTRACE_CU(x,y)            
    293 #define DTRACE_PU(x,y)            
    294 #define DTRACE_TU(x,y)            
    295 
    296 #define DTRACE_CU_S(x)            
    297 #define DTRACE_PU_S(x)            
    298 #define DTRACE_TU_S(x)            
     292#define DTRACE_CU(x,y) ;            
     293#define DTRACE_PU(x,y) ;           
     294#define DTRACE_TU(x,y) ;           
     295
     296#define DTRACE_CU_S(x) ;           
     297#define DTRACE_PU_S(x) ;           
     298#define DTRACE_TU_S(x) ;           
    299299
    300300#endif
  • trunk/source/Lib/TLibCommon/TComSlice.cpp

    r1179 r1196  
    137137#endif
    138138#if H_3D
    139 #if HHI_INTER_COMP_PRED_K0052
    140139, m_inCmpPredFlag                 ( false )
    141 #endif
    142 #if HHI_CAM_PARA_K0052
    143140, m_numViews                        ( 0    )
    144 #endif
    145141, m_depthToDisparityB             ( NULL )
    146142, m_depthToDisparityF             ( NULL )
    147 #endif
    148 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     143
    149144, m_bApplyDIS                     (false)
    150 #else
    151 #if H_3D_SINGLE_DEPTH
    152 , m_bApplySingleDepthMode         (false)
    153 #endif
    154145#endif
    155146#endif
     
    191182  m_iDefaultRefViewIdx = -1;
    192183  m_bDefaultRefViewIdxAvailableFlag = false;
    193 #if HHI_INTER_COMP_PRED_K0052
     184#if H_3D
    194185  m_ivMvPredFlag           = false;
    195186  m_ivMvScalingFlag        = false;
     
    214205  m_puiSubstreamSizes = NULL;
    215206#if H_3D
    216 #if HHI_CAM_PARA_K0052   
    217207  for( UInt i = 0; i < m_numViews; i++ )
    218 #else
    219   for( UInt i = 0; i < getViewIndex(); i++ )
    220 #endif
    221208  {
    222209    if ( m_depthToDisparityB && m_depthToDisparityB[ i ] )
     
    604591  UInt NumPocLtCurr = 0;
    605592  Int i;
    606 
    607 #if HHI_RES_PRED_K0052
     593#if H_3D
    608594  m_pocsInCurrRPSs.clear();
    609595#endif
    610 
    611596  for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++)
    612597  {
     
    619604      NumPocStCurr0++;
    620605      pcRefPic->setCheckLTMSBPresent(false); 
    621 #if HHI_RES_PRED_K0052
     606#if H_3D
    622607      m_pocsInCurrRPSs.push_back( pcRefPic->getPOC() );
    623608#endif
     
    635620      NumPocStCurr1++;
    636621      pcRefPic->setCheckLTMSBPresent(false); 
    637 #if HHI_RES_PRED_K0052
     622#if H_3D
    638623      m_pocsInCurrRPSs.push_back( pcRefPic->getPOC() );
    639624#endif
     
    650635      RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
    651636      NumPocLtCurr++;
    652 #if HHI_RES_PRED_K0052
     637#if H_3D
    653638      m_pocsInCurrRPSs.push_back( pcRefPic->getPOC() );
    654639#endif
     
    662647
    663648  Int numPocInterCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
    664 #if HHI_RES_PRED_K0052
     649#if H_3D
    665650  assert( numPocInterCurr == (Int) m_pocsInCurrRPSs.size() );
    666651#endif
     
    837822Void TComSlice::setCamparaSlice( Int** aaiScale, Int** aaiOffset )
    838823
    839 #if HHI_CAM_PARA_K0052
    840824  Int voiInVps      = m_pcVPS->getVoiInVps(getViewIndex() );
    841825  if( m_pcVPS->getNumCp( voiInVps ) > 0 )
     
    855839    }
    856840  }
    857 #else
    858   if( m_pcVPS->hasCamParInSliceHeader( m_viewIndex ) )
    859   {   
    860     for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < m_viewIndex; uiBaseViewIndex++ )
    861     {
    862       m_aaiCodedScale [ 0 ][ uiBaseViewIndex ] = aaiScale [ uiBaseViewIndex ][     m_viewIndex ];
    863       m_aaiCodedScale [ 1 ][ uiBaseViewIndex ] = aaiScale [     m_viewIndex ][ uiBaseViewIndex ];
    864       m_aaiCodedOffset[ 0 ][ uiBaseViewIndex ] = aaiOffset[ uiBaseViewIndex ][     m_viewIndex ];
    865       m_aaiCodedOffset[ 1 ][ uiBaseViewIndex ] = aaiOffset[     m_viewIndex ][ uiBaseViewIndex ];
    866     }
    867   }
    868 #endif
    869841}
    870842#endif
     
    11651137  }
    11661138#endif
    1167 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     1139#if H_3D
    11681140  m_bApplyDIS = pSrc->m_bApplyDIS;
    1169 #else
    1170 #if H_3D_SINGLE_DEPTH
    1171   m_bApplySingleDepthMode = pSrc->m_bApplySingleDepthMode;
    1172 #endif
    11731141#endif
    11741142#if H_3D_IC
     
    22172185{
    22182186  m_numViews = 1;
    2219 #if HHI_VIEW_ID_LIST_I5_J0107 || HHI_INTER_COMP_PRED_K0052
    22202187#if H_3D
    22212188  AOF( m_viewOIdxList.size() == 0 );
     
    22232190  m_viewOIdxList.push_back( 0 );       
    22242191#endif
    2225 #endif
    22262192
    22272193  for( Int i = 0; i <=  getMaxLayersMinus1(); i++ )
     
    22412207      {
    22422208        m_numViews++;
    2243 #if HHI_VIEW_ID_LIST_I5_J0107  || HHI_INTER_COMP_PRED_K0052
    22442209#if H_3D
    22452210        m_viewOIdxList.push_back( getViewOrderIdx( lId ) );       
    22462211#endif
    2247 #endif
    22482212      }
    22492213    }
     
    22712235    }
    22722236  }
    2273 #if !BUG_FIX_TK65
    2274   assert( foundLayerIdinNuh != -1 );
    2275 #endif
    22762237  return foundLayerIdinNuh;
    22772238}
     
    22812242  Int i = 0, j = 0;
    22822243
    2283 #if HHI_CAM_PARA_K0052
    22842244  m_numCp    = new Int [ iNumViews ];
    22852245  m_cpRefVoi = new Int*[ iNumViews ];
     
    22872247
    22882248  m_cpPresentFlag  = new Bool*[ iNumViews ];
    2289 #else
    2290   m_bCamParPresent = new Bool[ iNumViews ];
    2291   m_bCamParInSliceHeader = new Bool[ iNumViews ];
    2292 #endif
    22932249 
    22942250
     
    22972253  for ( i = 0; i < iNumViews ; i++ )
    22982254  {
    2299 #if HHI_CAM_PARA_K0052
    23002255    m_cpInSliceSegmentHeaderFlag[i] = false;     
    2301 #else
    2302     m_bCamParPresent[i] = false;
    2303     m_bCamParInSliceHeader[i] = false;
    2304 #endif
    23052256   
    23062257    m_aaaiCodedScale[i] = new Int*[ 2 ];
    23072258    m_aaaiCodedOffset[i] = new Int*[ 2 ];
    23082259
    2309 #if HHI_CAM_PARA_K0052
    23102260    m_numCp   [i] = 0;
    23112261    m_cpRefVoi[i] = new Int[ iNumViews ];
     
    23162266      m_cpPresentFlag[i][j] = false;
    23172267    }
    2318 #endif
    23192268    for ( j = 0; j < 2; j++ )
    23202269    {
     
    23352284  Int i = 0, j = 0;
    23362285
    2337 #if !HHI_CAM_PARA_K0052
    2338   if ( m_bCamParPresent != NULL )
    2339   {
    2340     delete [] m_bCamParPresent;
    2341   }
    2342   if ( m_bCamParInSliceHeader != NULL )
    2343   {
    2344     delete [] m_bCamParInSliceHeader;
    2345   }
    2346 #else
    23472286  if ( m_numCp != NULL )
    23482287  {
     
    23732312    delete [] m_cpInSliceSegmentHeaderFlag;
    23742313  }
    2375 #endif
    23762314
    23772315
     
    24042342
    24052343
    2406 #if !HHI_CAM_PARA_K0052
    2407 Void TComVPS::initCamParaVPS( UInt uiViewIndex, Bool bCamParPresent, UInt uiCamParPrecision, Bool bCamParSlice, Int** aaiScale, Int** aaiOffset )
    2408 {
    2409   AOT( uiViewIndex != 0 && !bCamParSlice && ( aaiScale == 0 || aaiOffset == 0 ) ); 
    2410 
    2411   m_uiCamParPrecision = ( ( uiViewIndex != 0 )? uiCamParPrecision : 0 );
    2412   m_bCamParPresent[ uiViewIndex ] = (( uiViewIndex != 0 )? bCamParPresent  : false );
    2413   m_bCamParInSliceHeader[ uiViewIndex ]  = ( (uiViewIndex != 0)? bCamParSlice  : false );
    2414 
    2415   if( !m_bCamParInSliceHeader[ uiViewIndex ] )
    2416   {
    2417     for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < uiViewIndex; uiBaseViewIndex++ )
    2418     {
    2419       m_aaaiCodedScale [ uiViewIndex ][ 0 ][ uiBaseViewIndex ] = aaiScale [ uiBaseViewIndex ][     uiViewIndex ];
    2420       m_aaaiCodedScale [ uiViewIndex ][ 1 ][ uiBaseViewIndex ] = aaiScale [     uiViewIndex ][ uiBaseViewIndex ];
    2421       m_aaaiCodedOffset[ uiViewIndex ][ 0 ][ uiBaseViewIndex ] = aaiOffset[ uiBaseViewIndex ][     uiViewIndex ];
    2422       m_aaaiCodedOffset[ uiViewIndex ][ 1 ][ uiBaseViewIndex ] = aaiOffset[     uiViewIndex ][ uiBaseViewIndex ];
    2423     }
    2424   }
    2425 }
    2426 #endif
    24272344
    24282345#endif // H_3D
     
    28042721}
    28052722
     2723#if H_3D
     2724Void TComVPS::initViewCompLayer()
     2725{
     2726  assert( m_viewCompLayerId.size() == 0 && m_viewCompLayerPresentFlag.size() == 0  );
     2727  for( Int i = 0; i < getNumViews(); i++ )
     2728  {
     2729    m_viewCompLayerId         .push_back( std::vector<Int>(0)  );
     2730    m_viewCompLayerPresentFlag.push_back( std::vector<Bool>(0) );     
     2731
     2732    for( Int depFlag = 0; depFlag  <=  1; depFlag++ )
     2733    {
     2734      Int iViewOIdx = getViewOIdxList( i );
     2735      Int layerId = -1;
     2736      for( Int j = 0; j  <=  getMaxLayersMinus1(); j++ )
     2737      {
     2738        Int jNuhLId = getLayerIdInNuh( j );
     2739        if( getVpsDepthFlag( jNuhLId ) == ( (Bool) depFlag )  &&  getViewOrderIdx( jNuhLId )  ==  iViewOIdx 
     2740          &&  getDependencyId( jNuhLId )  ==  0  &&  getAuxId( jNuhLId )  ==  0 )
     2741        {
     2742          layerId = jNuhLId;
     2743        }
     2744      }
     2745      m_viewCompLayerPresentFlag[ i ].push_back( layerId  !=  -1 );
     2746      m_viewCompLayerId         [ i ].push_back( layerId );       
     2747    }
     2748  }
     2749}
     2750
     2751Int TComVPS::getVoiInVps(Int viewOIdx)
     2752{
     2753  for ( Int i = 0; i < m_viewOIdxList.size(); i++ )
     2754  {
     2755    if  ( m_viewOIdxList[ i ] == viewOIdx )
     2756    {
     2757      return i;
     2758    }
     2759  }
     2760  assert( 0 );   
     2761  return -1;
     2762}
     2763
     2764Void TComVPS::deriveCpPresentFlag()
     2765{
     2766  for( Int nInVps = 0; nInVps < getNumViews(); nInVps++  )
     2767  {
     2768    for( Int mInVps = 0; mInVps < getNumViews(); mInVps++ )
     2769    {
     2770      m_cpPresentFlag[nInVps][mInVps] = 0;
     2771    }
     2772  }
     2773
     2774  for( Int n = 1; n < getNumViews(); n++ )
     2775  {
     2776    Int iInVps = getVoiInVps(  getViewOIdxList( n ) );     
     2777    for( Int m = 0; m < getNumCp( iInVps ); m++ )
     2778    {
     2779      m_cpPresentFlag[ iInVps ][ getVoiInVps( getCpRefVoi( iInVps, m ) ) ] = 1;
     2780    }
     2781  }
     2782}
     2783#endif
    28062784
    28072785#endif // H_MV
     
    28582836, m_interViewMvVertConstraintFlag (false)
    28592837#endif
    2860 #if H_3D
    2861 #if !HHI_CAM_PARA_K0052
    2862 , m_bCamParInSliceHeader      (false)
    2863 #endif
    2864 #endif
    28652838{
    28662839  for ( Int i = 0; i < MAX_TLAYER; i++ )
     
    38853858      {
    38863859        Int layerIdInNuh = getRefPicLayerId( i );
    3887 #if HHI_RES_PRED_K0052
     3860
    38883861        TComPic* picV = getIvPic( getIsDepth(), getVPS()->getViewIndex( layerIdInNuh ) );
    38893862        assert( picV != NULL );
     
    39003873
    39013874        if (getFirstTRefIdx(eRefPicList) >= 0 && refRpRefAvailFlag )
    3902 #else
    3903         Int viewIdx = getVPS()->getViewId( layerIdInNuh );
    3904         TComPic*pcPicPrev = ivPicLists->getPic(viewIdx, 0, prevPOC);
    3905         if (getFirstTRefIdx(eRefPicList) >= 0 && pcPicPrev && pcPicPrev->getSlice( 0 )->isReferenced())
    3906 #endif
    39073875        {
    39083876          m_arpRefPicAvailable[eRefPicList][layerIdInNuh] = true;
     
    39173885}
    39183886#endif
     3887
    39193888#if H_3D_IC
     3889// This is an encoder only function and should be moved to TEncSlice or TEncSearch!!
    39203890Void TComSlice::xSetApplyIC(Bool bUseLowLatencyICEnc)
    39213891{
     
    39813951  }
    39823952  else
    3983   {
    3984   Int iMaxPelValue = ( 1 << g_bitDepthY );
    3985   Int *aiRefOrgHist;
    3986   Int *aiCurrHist;
    3987   aiRefOrgHist = (Int *) xMalloc( Int,iMaxPelValue );
    3988   aiCurrHist   = (Int *) xMalloc( Int,iMaxPelValue );
    3989   memset( aiRefOrgHist, 0, iMaxPelValue*sizeof(Int) );
    3990   memset( aiCurrHist, 0, iMaxPelValue*sizeof(Int) );
    3991   // Reference Idx Number
    3992   Int iNumRefIdx = getNumRefIdx( REF_PIC_LIST_0 );
    3993   TComPic* pcCurrPic = NULL;
    3994   TComPic* pcRefPic = NULL;
    3995   TComPicYuv* pcCurrPicYuv = NULL;
    3996   TComPicYuv* pcRefPicYuvOrg = NULL;
    3997   pcCurrPic = getPic();
    3998   pcCurrPicYuv = pcCurrPic->getPicYuvOrg();
    3999   Int iWidth = pcCurrPicYuv->getWidth();
    4000   Int iHeight = pcCurrPicYuv->getHeight();
    4001 
    4002 
    4003   // Get InterView Reference picture
    4004   // !!!!! Assume only one Interview Reference Picture in L0
    4005   for ( Int i = 0; i < iNumRefIdx; i++ )
    4006   {
    4007     pcRefPic = getRefPic( REF_PIC_LIST_0, i );
    4008     if ( pcRefPic != NULL )
    4009     {
    4010       if ( pcCurrPic->getViewIndex() != pcRefPic->getViewIndex() )
    4011       {
    4012         pcRefPicYuvOrg = pcRefPic->getPicYuvOrg();
    4013       }
    4014     }
    4015   }
    4016 
    4017   if ( pcRefPicYuvOrg != NULL )
    4018   {
    4019     Pel* pCurrY = pcCurrPicYuv ->getLumaAddr();
    4020     Pel* pRefOrgY = pcRefPicYuvOrg  ->getLumaAddr();
    4021     Int iCurrStride = pcCurrPicYuv->getStride();
    4022     Int iRefStride = pcRefPicYuvOrg->getStride();
    4023     Int iSumOrgSAD = 0;
    4024     Double dThresholdOrgSAD = getIsDepth() ? 0.1 : 0.05;
    4025 
    4026     // Histogram building - luminance
    4027     for ( Int y = 0; y < iHeight; y++ )
    4028     {
    4029       for ( Int x = 0; x < iWidth; x++ )
    4030       {
    4031         aiCurrHist[pCurrY[x]]++;
    4032         aiRefOrgHist[pRefOrgY[x]]++;
    4033       }
    4034       pCurrY += iCurrStride;
    4035       pRefOrgY += iRefStride;
    4036     }
    4037     // Histogram SAD
    4038     for ( Int i = 0; i < iMaxPelValue; i++ )
    4039     {
    4040       iSumOrgSAD += abs( aiCurrHist[i] - aiRefOrgHist[i] );
    4041     }
    4042     // Setting
    4043     if ( iSumOrgSAD > Int( dThresholdOrgSAD * iWidth * iHeight ) )
    4044     {
    4045       m_bApplyIC = true;
    4046     }
    4047     else
    4048     {
    4049       m_bApplyIC = false;
    4050     }
    4051   }
    4052 
    4053   xFree( aiCurrHist   );
    4054   xFree( aiRefOrgHist );
    4055   aiCurrHist = NULL;
    4056   aiRefOrgHist = NULL;
     3953  {       
     3954    TComPic*    pcCurrPic = getPic();
     3955    TComPicYuv* pcCurrPicYuv = pcCurrPic->getPicYuvOrg();
     3956   
     3957    // Get InterView Reference picture
     3958    // !!!!! Assume only one Interview Reference Picture in L0
     3959    // GT: Is this assumption correct?
     3960
     3961    TComPicYuv* pcRefPicYuvOrg = NULL;
     3962    for ( Int i = 0; i < getNumRefIdx( REF_PIC_LIST_0 ); i++ )
     3963    {
     3964      TComPic* pcRefPic = getRefPic( REF_PIC_LIST_0, i );
     3965      if ( pcRefPic != NULL )
     3966      {
     3967        if ( pcCurrPic->getViewIndex() != pcRefPic->getViewIndex() )
     3968        {
     3969          pcRefPicYuvOrg = pcRefPic->getPicYuvOrg();
     3970        }
     3971      }
     3972    }
     3973
     3974    if ( pcRefPicYuvOrg != NULL )
     3975    {
     3976      // Histogram building - luminance
     3977      Int iMaxPelValue = ( 1 << g_bitDepthY );
     3978      Int *aiRefOrgHist = (Int *) xMalloc( Int,iMaxPelValue );
     3979      Int *aiCurrHist   = (Int *) xMalloc( Int,iMaxPelValue );
     3980      memset( aiRefOrgHist, 0, iMaxPelValue*sizeof(Int) );
     3981      memset( aiCurrHist, 0, iMaxPelValue*sizeof(Int) );
     3982
     3983      Int iWidth   = pcCurrPicYuv->getWidth();
     3984      Int iHeight  = pcCurrPicYuv->getHeight();
     3985
     3986      Pel* pCurrY   = pcCurrPicYuv ->getLumaAddr();
     3987      Pel* pRefOrgY = pcRefPicYuvOrg  ->getLumaAddr();
     3988      Int iCurrStride = pcCurrPicYuv->getStride();
     3989      Int iRefStride = pcRefPicYuvOrg->getStride();
     3990
     3991      for ( Int y = 0; y < iHeight; y++ )
     3992      {
     3993        for ( Int x = 0; x < iWidth; x++ )
     3994        {
     3995          aiCurrHist[pCurrY[x]]++;
     3996          aiRefOrgHist[pRefOrgY[x]]++;
     3997        }
     3998        pCurrY += iCurrStride;
     3999        pRefOrgY += iRefStride;
     4000      }
     4001
     4002      // Histogram SAD
     4003      Int iSumOrgSAD = 0;
     4004      for ( Int i = 0; i < iMaxPelValue; i++ )
     4005      {
     4006        iSumOrgSAD += abs( aiCurrHist[i] - aiRefOrgHist[i] );
     4007      }
     4008
     4009      // Setting
     4010      Double dThresholdOrgSAD = getIsDepth() ? 0.1 : 0.05;
     4011
     4012      if ( iSumOrgSAD > Int( dThresholdOrgSAD * iWidth * iHeight ) )
     4013      {
     4014        m_bApplyIC = true;
     4015      }
     4016      else
     4017      {
     4018        m_bApplyIC = false;
     4019      }
     4020
     4021      xFree( aiCurrHist   );
     4022      xFree( aiRefOrgHist );
     4023    }
    40574024  }//if(bUseLowLatencyICEnc)
    40584025}
     
    40874054    return;
    40884055
    4089 #if HHI_CAM_PARA_K0052
    40904056  m_numViews = getVPS()->getNumViews();
    4091 #endif
    40924057  /// GT: Allocation should be moved to a better place later;
    40934058  if ( m_depthToDisparityB == NULL )
    40944059  {
    4095 #if HHI_CAM_PARA_K0052   
    40964060    m_depthToDisparityB = new Int*[ m_numViews ];
    40974061    for ( Int i = 0; i < getVPS()->getNumViews(); i++ )
    4098 #else
    4099     m_depthToDisparityB = new Int*[ getViewIndex() ];
    4100     for ( Int i = 0; i < getViewIndex(); i++ )
    4101 #endif
    41024062    {
    41034063      m_depthToDisparityB[ i ] = new Int[ Int(1 << g_bitDepthY) ];
     
    41084068  if ( m_depthToDisparityF == NULL )
    41094069  {
    4110 #if HHI_CAM_PARA_K0052   
    41114070    m_depthToDisparityF = new Int*[ m_numViews ];
    41124071    for ( Int i = 0; i < m_numViews; i++ )
    4113 #else
    4114     m_depthToDisparityF= new Int*[ getViewIndex() ];
    4115     for ( Int i = 0; i < getViewIndex(); i++ )
    4116 #endif
    41174072    {
    41184073      m_depthToDisparityF[ i ] = new Int[ Int(1 << g_bitDepthY) ];
     
    41254080  TComVPS* vps = getVPS();
    41264081
    4127 #if HHI_CAM_PARA_K0052
    41284082  Int log2Div = g_bitDepthY - 1 + vps->getCpPrecision();
    41294083  Int voiInVps = vps->getVoiInVps( getViewIndex() );
     
    41554109    }
    41564110  }
    4157 #else
    4158   Int log2Div = g_bitDepthY - 1 + vps->getCamParPrecision();
    4159 
    4160   Int viewIndex = getViewIndex();
    4161 
    4162   Bool camParaSH = vps->hasCamParInSliceHeader( viewIndex );
    4163 
    4164   Int* codScale     = camParaSH ? m_aaiCodedScale [ 0 ] : vps->getCodedScale    ( viewIndex );
    4165   Int* codOffset    = camParaSH ? m_aaiCodedOffset[ 0 ] : vps->getCodedOffset   ( viewIndex );
    4166   Int* invCodScale  = camParaSH ? m_aaiCodedScale [ 1 ] : vps->getInvCodedScale ( viewIndex );
    4167   Int* invCodOffset = camParaSH ? m_aaiCodedOffset[ 1 ] : vps->getInvCodedOffset( viewIndex );
    4168 
    4169   for (Int i = 0; i <= ( getViewIndex() - 1); i++)
    4170   {
    4171     for ( Int d = 0; d <= ( ( 1 << g_bitDepthY ) - 1 ); d++ )
    4172     {
    4173       Int offset =    ( codOffset  [ i ] << g_bitDepthY ) + ( ( 1 << log2Div ) >> 1 );         
    4174       m_depthToDisparityB[ i ][ d ] = ( codScale [ i ] * d + offset ) >> log2Div;
    4175 
    4176       Int invOffset = ( invCodOffset[ i ] << g_bitDepthY ) + ( ( 1 << log2Div ) >> 1 );         
    4177       m_depthToDisparityF[ i ][ d ] = ( invCodScale[ i ] * d + invOffset ) >> log2Div;
    4178     }
    4179   }
    4180 #endif
    41814111}
    41824112#endif
     
    42224152  Bool depthFlag = getIsDepth();
    42234153
    4224 #if !HHI_INTER_COMP_PRED_K0052
    4225   Bool depthOfRefViewsAvailFlag = false;
    4226   Bool textOfCurViewAvailFlag = false;
    4227 
    4228   TComVPS* vps = getVPS();
    4229 
    4230   if( !depthFlag )
    4231   {
    4232     depthOfRefViewsAvailFlag = true;
    4233     for( Int i = 0; i <= vps->getNumRefListLayers( getLayerId() ) - 1; i++)
    4234     {
    4235       Bool curDepthAvailableFlag = false;   
    4236       for (Int j = 0; j <= vps->getMaxLayersMinus1(); j++ )
    4237       {
    4238         if ( vps->getDirectDependencyFlag( vps->getLayerIdInVps( getLayerId() ), j )
    4239           && vps->getVpsDepthFlag        ( vps->getLayerIdInNuh( j ) ) == 1
    4240           && vps->getViewOrderIdx( vps->getLayerIdInNuh( j ) ) == vps->getViewOrderIdx( vps->getIdRefListLayer( getLayerId(), i ) )
    4241           && vps->getDependencyId( vps->getLayerIdInNuh( j ) ) == 0
    4242           && vps->getAuxId       ( vps->getLayerIdInNuh( j ) ) == 0
    4243           )
    4244         {
    4245           curDepthAvailableFlag = true;
    4246         }
    4247       }
    4248       if ( !curDepthAvailableFlag )
    4249       {
    4250         depthOfRefViewsAvailFlag = false;
    4251       }   
    4252     }
    4253   }
    4254   else
    4255   {
    4256     for (Int j = 0; j <= vps->getMaxLayersMinus1(); j++ )
    4257     {
    4258       if ( vps->getDirectDependencyFlag( vps->getLayerIdInVps( getLayerId() ), j )
    4259         && vps->getVpsDepthFlag( vps->getLayerIdInNuh( j ) ) == 0
    4260         && vps->getViewOrderIdx( vps->getLayerIdInNuh( j ) ) == getViewIndex()
    4261         && vps->getDependencyId( vps->getLayerIdInNuh( j ) ) == 0
    4262         && vps->getAuxId       ( vps->getLayerIdInNuh( j ) ) == 0
    4263         )
    4264       {       
    4265         textOfCurViewAvailFlag = true;
    4266       }
    4267     }
    4268   }
    4269 
    4270 
    4271   Bool lidG0  = ( getLayerId() > 0 );
    4272   Bool nRLLG0 =  ( getVPS()->getNumRefListLayers( getLayerId() ) > 0 );     
    4273 
    4274   TComSps3dExtension* sps3dExt = getSPS()->getSps3dExtension();
    4275 
    4276   m_ivMvPredFlag           = sps3dExt->getIvMvPredFlag         ( depthFlag ) && lidG0 && nRLLG0                           ;                             
    4277   m_ivMvScalingFlag        = sps3dExt->getIvMvScalingFlag      ( depthFlag ) && lidG0                                    ;                             
    4278   m_ivResPredFlag          = sps3dExt->getIvResPredFlag        ( depthFlag ) && lidG0 && nRLLG0                           ;                               
    4279   m_depthRefinementFlag    = sps3dExt->getDepthRefinementFlag  ( depthFlag ) && lidG0           && depthOfRefViewsAvailFlag;                           
    4280   m_viewSynthesisPredFlag  = sps3dExt->getViewSynthesisPredFlag( depthFlag ) && lidG0 && nRLLG0 && depthOfRefViewsAvailFlag;                         
    4281   m_depthBasedBlkPartFlag  = sps3dExt->getDepthBasedBlkPartFlag( depthFlag ) && lidG0           && depthOfRefViewsAvailFlag;                         
    4282   m_mpiFlag                = sps3dExt->getMpiFlag              ( depthFlag ) && lidG0           &&   textOfCurViewAvailFlag;
    4283   m_intraContourFlag       = sps3dExt->getIntraContourFlag     ( depthFlag ) && lidG0           &&   textOfCurViewAvailFlag;
    4284   m_intraSdcWedgeFlag      = sps3dExt->getIntraSdcWedgeFlag    ( depthFlag ) && lidG0                                     ;                         
    4285   m_qtPredFlag             = sps3dExt->getQtPredFlag           ( depthFlag ) && lidG0           &&   textOfCurViewAvailFlag;
    4286   m_interSdcFlag           = sps3dExt->getInterSdcFlag         ( depthFlag ) && lidG0                                    ; 
    4287 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    4288   m_depthIntraSkipFlag     = sps3dExt->getDepthIntraSkipFlag   ( depthFlag ) && lidG0                                    ;                         
    4289 #else
    4290   m_intraSingleFlag        = sps3dExt->getIntraSingleFlag      ( depthFlag ) && lidG0                                    ;                         
    4291 #endif
    4292 
    4293   m_subPbSize              = lidG0 ? ( 1 << ( sps3dExt->getLog2SubPbSizeMinus3   ( depthFlag ) + 3 ) ) : getSPS()->getMaxCUWidth(); 
    4294   m_mpiSubPbSize           = 1 << ( sps3dExt->getLog2MpiSubPbSizeMinus3( depthFlag ) + 3 );
    4295 #else
    42964154  Bool nRLLG0 =  ( getVPS()->getNumRefListLayers( getLayerId() ) > 0 );     
    42974155
     
    43014159  m_ivMvScalingFlag        = sps3dExt->getIvMvScalingFlag      ( depthFlag )                                 ;                             
    43024160  m_ivResPredFlag          = sps3dExt->getIvResPredFlag        ( depthFlag ) && nRLLG0                       ;                               
    4303 #if HHI_CAM_PARA_K0052
    43044161  m_depthRefinementFlag    = sps3dExt->getDepthRefinementFlag  ( depthFlag )           && getInCompPredFlag() && m_cpAvailableFlag;
    43054162  m_viewSynthesisPredFlag  = sps3dExt->getViewSynthesisPredFlag( depthFlag ) && nRLLG0 && getInCompPredFlag() && m_cpAvailableFlag;
    4306 #else
    4307   m_depthRefinementFlag    = sps3dExt->getDepthRefinementFlag  ( depthFlag )           && getInCompPredFlag();                           
    4308   m_viewSynthesisPredFlag  = sps3dExt->getViewSynthesisPredFlag( depthFlag ) && nRLLG0 && getInCompPredFlag();                           
    4309 #endif
    43104163  m_depthBasedBlkPartFlag  = sps3dExt->getDepthBasedBlkPartFlag( depthFlag )           && getInCompPredFlag();                         
    43114164  m_mpiFlag                = sps3dExt->getMpiFlag              ( depthFlag )           && getInCompPredFlag();
     
    43194172  m_mpiSubPbSize           =  1 << ( sps3dExt->getLog2MpiSubPbSizeMinus3( depthFlag ) + 3 );
    43204173
    4321 #endif
    43224174
    43234175#if H_3D_OUTPUT_ACTIVE_TOOLS
     
    43254177  std::cout << "DepthFlag:              :" << getIsDepth()             << std::endl;
    43264178  std::cout << "ViewOrderIdx:           :" << getViewIndex()           << std::endl;
    4327 #if HHI_INTER_COMP_PRED_K0052
    43284179  std::cout << "InterCmpPredAvailableFlag:" << getInCmpPredAvailFlag() << std::endl;
    43294180  std::cout << "InterCompPredFlag       :"  << getInCompPredFlag()     << std::endl;
    4330   //std::cout << "TextOfCurViewAvailFlag  :" << textOfCurViewAvailFlag   << std::endl;
    4331 #else
    4332   std::cout << "DepthOfRefViewsAvailFlag:" << depthOfRefViewsAvailFlag << std::endl;
    4333   std::cout << "TextOfCurViewAvailFlag  :" << textOfCurViewAvailFlag   << std::endl;
    4334 #endif
    43354181 
    43364182  std::cout << "ivMvPredFlag            :" << m_ivMvPredFlag           << std::endl;
     
    43454191  std::cout << "qtPredFlag              :" << m_qtPredFlag             << std::endl;
    43464192  std::cout << "interSdcFlag            :" << m_interSdcFlag           << std::endl;
    4347 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    43484193  std::cout << "depthIntraSkipFlag      :" << m_depthIntraSkipFlag     << std::endl;   
    4349 #else
    4350   std::cout << "intraSingleFlag         :" << m_intraSingleFlag        << std::endl;   
    4351 #endif
    43524194  std::cout << "subPbSize               :" << m_subPbSize              << std::endl;
    43534195  std::cout << "mpiSubPbSize            :" << m_mpiSubPbSize           << std::endl;
    43544196#endif
    43554197}
     4198
     4199Void TComSlice::deriveInCmpPredAndCpAvailFlag()
     4200{
     4201  Int numCurCmpLIds = getIsDepth() ? 1 : getNumActiveRefLayerPics();
     4202  std::vector<Int> curCmpLIds;
     4203  if ( getIsDepth() )
     4204  {
     4205    curCmpLIds.push_back( getLayerId() );
     4206  }
     4207  else
     4208  {
     4209    for (Int i = 0; i < numCurCmpLIds; i++)
     4210    {
     4211      curCmpLIds.push_back( getRefPicLayerId( i ) );
     4212    }
     4213  }
     4214
     4215  m_cpAvailableFlag = true;
     4216  m_inCmpRefViewIdcs.clear();
     4217  Bool allRefCmpLayersAvailFlag = true;
     4218
     4219  for( Int i = 0; i <= numCurCmpLIds - 1; i++ )
     4220  {     
     4221    m_inCmpRefViewIdcs.push_back( getVPS()->getViewOrderIdx( curCmpLIds[ i ] ));
     4222    if( !getVPS()->getCpPresentFlag( getVPS()->getVoiInVps( getViewIndex() ),  getVPS()->getVoiInVps( m_inCmpRefViewIdcs[ i ] ) ) )
     4223    {
     4224      m_cpAvailableFlag = false;
     4225    }
     4226    Bool refCmpCurLIdAvailFlag = false;
     4227    if( getVPS()->getViewCompLayerPresentFlag( m_inCmpRefViewIdcs[ i ], !getIsDepth() ) )
     4228    {
     4229      Int j = getVPS()->getLayerIdInVps( getVPS()->getViewCompLayerId( m_inCmpRefViewIdcs[ i ],  !getIsDepth() ) );
     4230      if  ( getVPS()->getDirectDependencyFlag( getVPS()->getLayerIdInVps( getLayerId() ) ,  j ) &&
     4231        getVPS()->getSubLayersVpsMaxMinus1( j ) >= getTemporalId()   &&
     4232        ( getTemporalId() == 0 || getVPS()->getMaxTidIlRefPicsPlus1( j , getVPS()->getLayerIdInVps( getLayerId() ) ) > getTemporalId() )       
     4233        )
     4234      {
     4235        refCmpCurLIdAvailFlag = true;
     4236      }
     4237    }
     4238    if( !refCmpCurLIdAvailFlag )
     4239    {
     4240      allRefCmpLayersAvailFlag = false;
     4241    }
     4242  }
     4243
     4244  if( !allRefCmpLayersAvailFlag )
     4245  {
     4246    m_inCmpPredAvailFlag = false;
     4247  } 
     4248  else
     4249  {
     4250    TComSps3dExtension* sps3dExt = getSPS()->getSps3dExtension();
     4251    if( !getIsDepth() )
     4252    {
     4253      m_inCmpPredAvailFlag = sps3dExt->getViewSynthesisPredFlag( getIsDepth() ) ||
     4254        sps3dExt->getDepthBasedBlkPartFlag( getIsDepth() ) ||
     4255        sps3dExt->getDepthRefinementFlag  ( getIsDepth() );                           
     4256    }
     4257    else
     4258    {
     4259      m_inCmpPredAvailFlag = sps3dExt->getIntraContourFlag( getIsDepth() ) ||
     4260        sps3dExt->getQtPredFlag( getIsDepth() ) ||
     4261        sps3dExt->getMpiFlag( getIsDepth() );                                 
     4262    }
     4263  }
     4264}
     4265
     4266Void TComSlice::checkInCompPredRefLayers()
     4267{
     4268  if ( getInCompPredFlag() )
     4269  {
     4270    for (Int i = 0; i < getNumCurCmpLIds(); i++ )
     4271    {
     4272      assert( getIvPic(!getIsDepth(), getInCmpRefViewIdcs( i ) ) != NULL );       
     4273      //  It is a requirement of bitstream conformance that there
     4274      //  is a picture in the DPB with PicOrderCntVal equal to the PicOrderCntVal of the current picture,
     4275      //  and a nuh_layer_id value equal to ViewCompLayerId[ inCmpRefViewIdcs[ i ] ][ !DepthFlag ].
     4276    }
     4277  }
     4278}
     4279
    43564280#endif
    43574281
  • trunk/source/Lib/TLibCommon/TComSlice.h

    r1179 r1196  
    912912  Int         xGetDimBitOffset( Int j );
    913913  Void        xSetRefLayerFlags( Int currLayerId );
     914
    914915  // VPS EXTENSION 2 SYNTAX ELEMENTS
    915916#if H_3D
    916 #if HHI_CAM_PARA_K0052 
    917917  Int*        m_numCp; 
    918918  Int**       m_cpRefVoi;
     
    920920  Int         m_cpPrecision;
    921921  Bool*       m_cpInSliceSegmentHeaderFlag;
    922 #else
    923   UInt        m_uiCamParPrecision;
    924   Bool*       m_bCamParInSliceHeader;
    925   Bool*       m_bCamParPresent;
    926 #endif
    927922  Int         ***m_aaaiCodedScale ;
    928923  Int         ***m_aaaiCodedOffset;
    929924
    930 #if HHI_VIEW_ID_LIST_I5_J0107 ||  HHI_INTER_COMP_PRED_K0052
    931925  std::vector<Int>  m_viewOIdxList;
    932 #endif
    933 #if HHI_INTER_COMP_PRED_K0052
    934926  std::vector< std::vector<Bool> > m_viewCompLayerPresentFlag;
    935927  std::vector< std::vector<Int>  > m_viewCompLayerId;
    936 #endif
    937928#endif
    938929
     
    10211012  Void    setVpsNonVuiExtensionLength( Int  val )                          { m_vpsNonVuiExtensionLength = val; }
    10221013  Int     getVpsNonVuiExtensionLength(  )                                  { return m_vpsNonVuiExtensionLength; }
    1023 
     1014 
     1015  // VPS Extension
    10241016  Void    setSplittingFlag( Bool val )                                     { m_splittingFlag = val;  }
    10251017  Bool    getSplittingFlag()                                               { return m_splittingFlag; }
     
    11631155  Int     getNumViews()                                                    { return m_numViews; }
    11641156  Void    initNumViews();
    1165 #if HHI_INTER_COMP_PRED_K0052
    11661157#if H_3D
    1167   Void   initViewCompLayer( )
    1168   {
    1169     assert( m_viewCompLayerId.size() == 0 && m_viewCompLayerPresentFlag.size() == 0  );
    1170     for( Int i = 0; i < getNumViews(); i++ )
    1171     {
    1172       m_viewCompLayerId         .push_back( std::vector<Int>(0)  );
    1173       m_viewCompLayerPresentFlag.push_back( std::vector<Bool>(0) );     
    1174 
    1175       for( Int depFlag = 0; depFlag  <=  1; depFlag++ )
    1176       {
    1177         Int iViewOIdx = getViewOIdxList( i );
    1178         Int layerId = -1;
    1179         for( Int j = 0; j  <=  getMaxLayersMinus1(); j++ )
    1180         {
    1181           Int jNuhLId = getLayerIdInNuh( j );
    1182           if( getVpsDepthFlag( jNuhLId ) == ( (Bool) depFlag )  &&  getViewOrderIdx( jNuhLId )  ==  iViewOIdx 
    1183             &&  getDependencyId( jNuhLId )  ==  0  &&  getAuxId( jNuhLId )  ==  0 )
    1184           {
    1185             layerId = jNuhLId;
    1186           }
    1187         }
    1188         m_viewCompLayerPresentFlag[ i ].push_back( layerId  !=  -1 );
    1189         m_viewCompLayerId         [ i ].push_back( layerId );       
    1190       }
    1191     }
    1192   };
    1193 #endif
    1194 #endif
    1195 
    1196 #if HHI_VIEW_ID_LIST_I5_J0107 || HHI_INTER_COMP_PRED_K0052
     1158  Void   initViewCompLayer( );
    11971159  Int     getViewOIdxList( Int i )                                         { return m_viewOIdxList[i]; }
    1198 #if HHI_CAM_PARA_K0052
    11991160  std::vector<Int> getViewOIdxList( )                                               { return m_viewOIdxList; }
    1200 #endif
    1201 #endif
    1202 
    1203 #if HHI_INTER_COMP_PRED_K0052
    1204 #if HHI_CAM_PARA_K0052
    1205   Int     getVoiInVps( Int viewOIdx )                                     
    1206 #else
    1207   Int     getInvViewOIdxList( Int viewOIdx )                                     
    1208 #endif
    1209   {   
    1210     for ( Int i = 0; i < m_viewOIdxList.size(); i++ )
    1211     {
    1212       if  ( m_viewOIdxList[ i ] == viewOIdx )
    1213       {
    1214         return i;
    1215       }
    1216     }
    1217     assert( 0 );   
    1218     return -1;
    1219   };
    1220 
    1221 #if HHI_CAM_PARA_K0052
     1161
     1162  Int     getVoiInVps( Int viewOIdx );;
     1163
    12221164  Bool    getViewCompLayerPresentFlag (Int i, Bool d ) { return  m_viewCompLayerPresentFlag[ getVoiInVps(i) ][d]; }
    12231165  Bool    getViewCompLayerId          (Int i, Bool d ) { return  m_viewCompLayerId         [ getVoiInVps(i) ][d]; }
    1224 #else
    1225   Bool    getViewCompLayerPresentFlag (Int i, Bool d ) { return  m_viewCompLayerPresentFlag[ getInvViewOIdxList(i) ][d]; }
    1226   Bool    getViewCompLayerId          (Int i, Bool d ) { return  m_viewCompLayerId         [ getInvViewOIdxList(i) ][d]; }
    1227 #endif
    12281166#endif
    12291167  Bool    getDependencyFlag( Int i, Int j )                                { return m_dependencyFlag[i][j]; }
     
    13471285  Void createCamPars(Int iNumViews);
    13481286  Void deleteCamPars();
    1349 #if HHI_CAM_PARA_K0052
    13501287  Void initCamParaVPS( Int vOIdxInVps, Int numCp, Bool cpInSliceSegmentHeaderFlag, Int* cpRefVoi, Int** aaiScale, Int** aaiOffset );
    1351 #else
    1352   Void initCamParaVPS      (  UInt uiViewIndex, Bool bCamParPresent = false, UInt uiCamParPrecision = 0, Bool bCamParSlice = false, Int** aaiScale = 0, Int** aaiOffset = 0 );
    1353 #endif
    1354  
    1355 #if HHI_CAM_PARA_K0052
     1288 
    13561289
    13571290  Void setCpPrecision( Int  val ) { m_cpPrecision = val; }
     
    13801313
    13811314// Derived
    1382   Void deriveCpPresentFlag( )
    1383   {
    1384     for( Int nInVps = 0; nInVps < getNumViews(); nInVps++  )
    1385     {
    1386       for( Int mInVps = 0; mInVps < getNumViews(); mInVps++ )
    1387       {
    1388         m_cpPresentFlag[nInVps][mInVps] = 0;
    1389       }
    1390     }
    1391 
    1392    for( Int n = 1; n < getNumViews(); n++ )
    1393    {
    1394       Int iInVps = getVoiInVps(  getViewOIdxList( n ) );     
    1395       for( Int m = 0; m < getNumCp( iInVps ); m++ )
    1396       {
    1397          m_cpPresentFlag[ iInVps ][ getVoiInVps( getCpRefVoi( iInVps, m ) ) ] = 1;
    1398       }
    1399     }
    1400   }
     1315  Void deriveCpPresentFlag( );
    14011316
    14021317  Void setCpPresentFlag( Int i, Int m, Bool flag ) { m_cpPresentFlag[i][m] = flag; }
    14031318  Bool getCpPresentFlag( Int i, Int m )           { return m_cpPresentFlag[i][m]; }   
    14041319
    1405 #else
    1406   UInt getCamParPrecision    ()  { return m_uiCamParPrecision; }
    1407 
    1408   Bool getCamParPresent      ( Int viewIndex )  { return m_bCamParPresent[viewIndex]; }
    1409   Void setCamParPresent      ( Int viewIndex, Bool val )  { m_bCamParPresent[viewIndex] = val; }
    1410   Bool hasCamParInSliceHeader( Int viewIndex )  { return m_bCamParInSliceHeader[viewIndex]; }
    1411   Void setHasCamParInSliceHeader( Int viewIndex, Bool b )  { m_bCamParInSliceHeader[viewIndex] = b; }
    1412 #endif
    14131320
    14141321
     
    17051612      m_qtPredFlag            [d] = false;
    17061613      m_interSdcFlag          [d] = false;
    1707 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    17081614      m_depthIntraSkipFlag    [d] = false;   
    1709 #else
    1710       m_intraSingleFlag       [d] = false;
    1711 #endif
    17121615    }
    17131616  }
     
    17521655  Bool getInterSdcFlag( Int d ) { return m_interSdcFlag[d]; }
    17531656
    1754 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    17551657  Void setDepthIntraSkipFlag( Int d, Bool flag ) { m_depthIntraSkipFlag[d] = flag; }
    17561658  Bool getDepthIntraSkipFlag( Int d ) { return m_depthIntraSkipFlag[d]; }
    1757 #else
    1758   Void setIntraSingleFlag( Int d, Bool flag ) { m_intraSingleFlag[d] = flag; }
    1759   Bool getIntraSingleFlag( Int d ) { return m_intraSingleFlag[d]; }
    1760 #endif
    17611659
    17621660private:
     
    17751673  Bool        m_qtPredFlag            [2];
    17761674  Bool        m_interSdcFlag          [2];
    1777 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    17781675  Bool        m_depthIntraSkipFlag    [2]; 
    1779 #else
    1780   Bool        m_intraSingleFlag       [2]; 
    1781 #endif
    17821676};
    17831677
     
    18841778#if H_3D
    18851779  TComSps3dExtension m_sps3dExtension;
    1886 #if !HHI_CAM_PARA_K0052
    1887   UInt        m_uiCamParPrecision;
    1888   Bool        m_bCamParInSliceHeader;
    1889 #endif
    18901780  Int         m_aaiCodedScale [2][MAX_NUM_LAYERS];
    18911781  Int         m_aaiCodedOffset[2][MAX_NUM_LAYERS];
     
    25172407  UInt                 m_nARPStepNum;
    25182408  Int         m_aiFirstTRefIdx    [2];
    2519 #if HHI_RES_PRED_K0052
    25202409  std::vector<Int> m_pocsInCurrRPSs;
    2521 #endif
    25222410#endif
    25232411#if H_3D_IC
     
    25262414#endif
    25272415#if H_3D
    2528 #if HHI_INTER_COMP_PRED_K0052
    25292416  std::vector<Int> m_inCmpRefViewIdcs;
    25302417  Bool       m_inCmpPredAvailFlag;
    25312418  Bool       m_inCmpPredFlag;
    2532 #endif
    2533 #if HHI_CAM_PARA_K0052
    25342419  Bool       m_cpAvailableFlag;
    25352420  Int        m_numViews;
    2536 #endif
    25372421  TComPic*   m_ivPicsCurrPoc [2][MAX_NUM_LAYERS]; 
    25382422  Int**      m_depthToDisparityB;
     
    25402424#endif
    25412425#endif
    2542 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    25432426  Bool      m_bApplyDIS;
    2544 #else
    2545 #if H_3D_SINGLE_DEPTH
    2546   Bool      m_bApplySingleDepthMode;
    2547 #endif
    2548 #endif
    25492427#if H_3D_IC
    2550   Int *m_aICEnableCandidate;
    2551   Int *m_aICEnableNum;
     2428  Int*      m_aICEnableCandidate;
     2429  Int*      m_aICEnableNum;
    25522430#endif
    25532431  Int       m_iDefaultRefViewIdx;
     
    25652443  Bool m_qtPredFlag           ;
    25662444  Bool m_interSdcFlag         ;
    2567 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    25682445  Bool m_depthIntraSkipFlag   ;
    2569 #else
    2570   Bool m_intraSingleFlag      ;
    2571 #endif
    25722446  Int  m_mpiSubPbSize         ;
    25732447  Int  m_subPbSize            ;
     
    26372511  Int       getRefPOC           ( RefPicList e, Int iRefIdx)    { return  m_aiRefPOCList[e][iRefIdx];   }
    26382512#if H_3D
    2639 #if HHI_INTER_COMP_PRED_K0052
    26402513  Bool      getInCmpPredAvailFlag( )                             { return m_inCmpPredAvailFlag;    }
    2641 #if HHI_CAM_PARA_K0052
    26422514  Bool      getCpAvailableFlag( )                             { return m_cpAvailableFlag;    }
    2643 #endif
    26442515  Bool      getInCompPredFlag( )                                 { return m_inCmpPredFlag;         }   
    26452516  Void      setInCompPredFlag( Bool b )                          { m_inCmpPredFlag = b;            }   
    26462517  Int       getInCmpRefViewIdcs( Int i )                         { return m_inCmpRefViewIdcs  [i]; }
    26472518  Int       getNumCurCmpLIds( )                                  { return (Int) m_inCmpRefViewIdcs.size(); }
    2648 #endif
    26492519  TComPic*  getIvPic            ( Bool depthFlag, Int viewIndex){ return  m_ivPicsCurrPoc[ depthFlag ? 1 : 0 ][ viewIndex ]; }
    26502520#endif
     
    28752745  Void      setFirstTRefIdx        ( RefPicList e, Int i )         { m_aiFirstTRefIdx[e]    = i;      }
    28762746  Bool      getArpRefPicAvailable( RefPicList e, Int viewIdx) {return m_arpRefPicAvailable[e][getVPS()->getLayerIdInNuh(viewIdx, 0)]; }
    2877 #if HHI_RES_PRED_K0052
    28782747  std::vector<Int> getPocsInCurrRPSs()                             { return m_pocsInCurrRPSs; };
    2879 #endif
    28802748#endif
    28812749  Void      setIsDepth            ( Bool isDepth )   { m_isDepth = isDepth; }
     
    28862754  Int*      getInvCodedScale      ()  { return m_aaiCodedScale [1]; }
    28872755  Int*      getInvCodedOffset     ()  { return m_aaiCodedOffset[1]; }
    2888 #if HHI_CAM_PARA_K0052
    28892756  Void      setCpScale( Int j, Int  val ) { m_aaiCodedScale[0][j] = val; }
    28902757  Int       getCpScale( Int j ) { return m_aaiCodedScale[0][j]; }
     
    28982765  Void      setCpInvOff( Int j, Int  val ) { m_aaiCodedOffset[1][j] = val; }
    28992766  Int       getCpInvOff( Int j ) { return m_aaiCodedOffset[1][j]; }
    2900 #endif
    29012767
    29022768#endif
     
    29062772  Void    setDepthToDisparityLUTs();
    29072773
    2908 #if HHI_CAM_PARA_K0052
    29092774  Int* getDepthToDisparityB( Int refViewIdx ) { return m_depthToDisparityB[ getVPS()->getVoiInVps( refViewIdx) ]; };
    29102775  Int* getDepthToDisparityF( Int refViewIdx ) { return m_depthToDisparityF[ getVPS()->getVoiInVps( refViewIdx) ]; };
    2911 #else
    2912   Int* getDepthToDisparityB( Int refViewIdx ) { return m_depthToDisparityB[ refViewIdx ]; };
    2913   Int* getDepthToDisparityF( Int refViewIdx ) { return m_depthToDisparityF[ refViewIdx ]; };
    2914 #endif
    29152776#endif
    29162777#if H_3D_IC
     
    30152876#if H_3D
    30162877  // 3D-HEVC tool parameters
    3017 #if HHI_INTER_COMP_PRED_K0052
    3018   Void deriveInCmpPredAndCpAvailFlag()
    3019   {
    3020     Int numCurCmpLIds = getIsDepth() ? 1 : getNumActiveRefLayerPics();
    3021     std::vector<Int> curCmpLIds;
    3022     if ( getIsDepth() )
    3023     {
    3024       curCmpLIds.push_back( getLayerId() );
    3025     }
    3026     else
    3027     {
    3028       for (Int i = 0; i < numCurCmpLIds; i++)
    3029       {
    3030         curCmpLIds.push_back( getRefPicLayerId( i ) );
    3031       }
    3032     }
    3033 
    3034 #if HHI_CAM_PARA_K0052
    3035     m_cpAvailableFlag = true;
    3036     m_inCmpRefViewIdcs.clear();
    3037 #endif
    3038     Bool allRefCmpLayersAvailFlag = true;
    3039 
    3040     for( Int i = 0; i <= numCurCmpLIds - 1; i++ )
    3041     {     
    3042       m_inCmpRefViewIdcs.push_back( getVPS()->getViewOrderIdx( curCmpLIds[ i ] ));
    3043 #if HHI_CAM_PARA_K0052
    3044       if( !getVPS()->getCpPresentFlag( getVPS()->getVoiInVps( getViewIndex() ),  getVPS()->getVoiInVps( m_inCmpRefViewIdcs[ i ] ) ) )
    3045       {
    3046         m_cpAvailableFlag = false;
    3047       }
    3048 #endif
    3049       Bool refCmpCurLIdAvailFlag = false;
    3050       if( getVPS()->getViewCompLayerPresentFlag( m_inCmpRefViewIdcs[ i ], !getIsDepth() ) )
    3051       {
    3052         Int j = getVPS()->getLayerIdInVps( getVPS()->getViewCompLayerId( m_inCmpRefViewIdcs[ i ],  !getIsDepth() ) );
    3053         if  ( getVPS()->getDirectDependencyFlag( getVPS()->getLayerIdInVps( getLayerId() ) ,  j ) &&
    3054           getVPS()->getSubLayersVpsMaxMinus1( j ) >= getTemporalId()   &&
    3055           ( getTemporalId() == 0 || getVPS()->getMaxTidIlRefPicsPlus1( j , getVPS()->getLayerIdInVps( getLayerId() ) ) > getTemporalId() )       
    3056           )
    3057         {
    3058           refCmpCurLIdAvailFlag = true;
    3059         }
    3060       }
    3061       if( !refCmpCurLIdAvailFlag )
    3062       {
    3063         allRefCmpLayersAvailFlag = false;
    3064       }
    3065     }
    3066 
    3067     if( !allRefCmpLayersAvailFlag )
    3068     {
    3069       m_inCmpPredAvailFlag = false;
    3070     } 
    3071     else
    3072     {
    3073       TComSps3dExtension* sps3dExt = getSPS()->getSps3dExtension();
    3074       if( !getIsDepth() )
    3075       {
    3076         m_inCmpPredAvailFlag = sps3dExt->getViewSynthesisPredFlag( getIsDepth() ) ||
    3077           sps3dExt->getDepthBasedBlkPartFlag( getIsDepth() ) ||
    3078           sps3dExt->getDepthRefinementFlag  ( getIsDepth() );                           
    3079       }
    3080       else
    3081       {
    3082         m_inCmpPredAvailFlag = sps3dExt->getIntraContourFlag( getIsDepth() ) ||
    3083           sps3dExt->getQtPredFlag( getIsDepth() ) ||
    3084           sps3dExt->getMpiFlag( getIsDepth() );                                 
    3085       }
    3086     } 
    3087   };
    3088 
    3089 #endif
    3090 
     2878  Void deriveInCmpPredAndCpAvailFlag();
    30912879  Void init3dToolParameters();   
    3092 #if HHI_INTER_COMP_PRED_K0052
    3093   Void checkInCompPredRefLayers()
    3094   {
    3095     if ( getInCompPredFlag() )
    3096     {
    3097       for (Int i = 0; i < getNumCurCmpLIds(); i++ )
    3098       {
    3099         assert( getIvPic(!getIsDepth(), getInCmpRefViewIdcs( i ) ) != NULL );       
    3100         //  It is a requirement of bitstream conformance that there
    3101         //  is a picture in the DPB with PicOrderCntVal equal to the PicOrderCntVal of the current picture,
    3102         //  and a nuh_layer_id value equal to ViewCompLayerId[ inCmpRefViewIdcs[ i ] ][ !DepthFlag ].
    3103       }
    3104     }
    3105   };
    3106 
    3107 #endif
     2880  Void checkInCompPredRefLayers();;
     2881
    31082882  Bool getIvMvPredFlag           ( ) { return m_ivMvPredFlag           ; };
    31092883  Bool getIvMvScalingFlag        ( ) { return m_ivMvScalingFlag        ; };
     
    31172891  Bool getQtPredFlag             ( ) { return m_qtPredFlag             ; };
    31182892  Bool getInterSdcFlag           ( ) { return m_interSdcFlag           ; };
    3119 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    31202893  Bool getDepthIntraSkipFlag     ( ) { return m_depthIntraSkipFlag     ; };
    3121 #else
    3122   Bool getIntraSingleFlag        ( ) { return m_intraSingleFlag        ; };
    3123 #endif
    31242894
    31252895  Int  getMpiSubPbSize           ( ) { return m_mpiSubPbSize           ; };
  • trunk/source/Lib/TLibCommon/TComWedgelet.cpp

    r1179 r1196  
    177177}
    178178
    179 #if SHARP_DMM_CLEAN_K0042
    180179Void TComWedgelet::generateWedgePatternByRotate(const TComWedgelet &rcWedge, Int rotate)
    181180{
     
    210209  m_uiHeight = rcWedge.m_uiHeight;
    211210}
    212 #endif
    213211
    214212Void TComWedgelet::xGenerateWedgePattern()
     
    228226  xDrawEdgeLine( uhXs, uhYs, uhXe, uhYe, pbTempPattern, iTempStride );
    229227
    230 #if SHARP_DMM_CLEAN_K0042
    231228  Int shift = (m_eWedgeRes == HALF_PEL) ? 1 : 0;
    232229  Int endPos = uhYe>>shift;
     
    242239    m_pbPattern[k] = pbTempPattern[k];
    243240  };
    244 #else
    245   switch( m_uhOri )
    246   {
    247   case( 0 ): { for( UInt iX = 0;                 iX < uhXs;            iX++ ) { UInt iY = 0;                 while( pbTempPattern[(iY * iTempStride) + iX] == false ) { pbTempPattern[(iY * iTempStride) + iX] = true; iY++; } } } break;
    248   case( 1 ): { for( UInt iY = 0;                 iY < uhYs;            iY++ ) { UInt iX = uiTempBlockSize-1; while( pbTempPattern[(iY * iTempStride) + iX] == false ) { pbTempPattern[(iY * iTempStride) + iX] = true; iX--; } } } break;
    249   case( 2 ): { for( UInt iX = uiTempBlockSize-1; iX > uhXs;            iX-- ) { UInt iY = uiTempBlockSize-1; while( pbTempPattern[(iY * iTempStride) + iX] == false ) { pbTempPattern[(iY * iTempStride) + iX] = true; iY--; } } } break;
    250   case( 3 ): { for( UInt iY = uiTempBlockSize-1; iY > uhYs;            iY-- ) { UInt iX = 0;                 while( pbTempPattern[(iY * iTempStride) + iX] == false ) { pbTempPattern[(iY * iTempStride) + iX] = true; iX++; } } } break;
    251   case( 4 ):
    252     {
    253       if( (uhXs+uhXe) < uiTempBlockSize ) { for( UInt iY = 0; iY < uiTempBlockSize; iY++ ) { UInt iX = 0;                 while( pbTempPattern[(iY * iTempStride) + iX] == false ) { pbTempPattern[(iY * iTempStride) + iX] = true; iX++; } } }
    254       else                                { for( UInt iY = 0; iY < uiTempBlockSize; iY++ ) { UInt iX = uiTempBlockSize-1; while( pbTempPattern[(iY * iTempStride) + iX] == false ) { pbTempPattern[(iY * iTempStride) + iX] = true; iX--; } } }
    255     }
    256     break;
    257   case( 5 ):
    258     {
    259       if( (uhYs+uhYe) < uiTempBlockSize ) { for( UInt iX = 0; iX < uiTempBlockSize; iX++ ) { UInt iY = 0;                 while( pbTempPattern[(iY * iTempStride) + iX] == false ) { pbTempPattern[(iY * iTempStride) + iX] = true; iY++; } } }
    260       else                                { for( UInt iX = 0; iX < uiTempBlockSize; iX++ ) { UInt iY = uiTempBlockSize-1; while( pbTempPattern[(iY * iTempStride) + iX] == false ) { pbTempPattern[(iY * iTempStride) + iX] = true; iY--; } } }
    261     }
    262   }
    263 
    264   clear();
    265   switch( m_eWedgeRes )
    266   {
    267   case(   FULL_PEL ): { for( UInt k = 0; k < (m_uiWidth * m_uiHeight); k++ ) { m_pbPattern[k] = pbTempPattern[k]; }; } break;
    268   case(   HALF_PEL ): // sub-sampling by factor 2
    269     {
    270       Int iStride = getStride();
    271 
    272       UInt uiOffX, uiOffY;
    273       switch( m_uhOri )
    274       {
    275       case( 0 ): { uiOffX = 0; uiOffY = 0; } break;
    276       case( 1 ): { uiOffX = 1; uiOffY = 0; } break;
    277       case( 2 ): { uiOffX = 1; uiOffY = 1; } break;
    278       case( 3 ): { uiOffX = 0; uiOffY = 1; } break;
    279       case( 4 ):
    280         {
    281           if( (uhXs+uhXe) < uiTempBlockSize ) { uiOffX = 0; uiOffY = 0; }
    282           else                                { uiOffX = 1; uiOffY = 0; }
    283         }
    284         break;
    285       case( 5 ):
    286         {
    287           if( (uhYs+uhYe) < uiTempBlockSize ) { uiOffX = 0; uiOffY = 0; }
    288           else                                { uiOffX = 0; uiOffY = 1; }
    289         }
    290         break;
    291       default:   { uiOffX = 0; uiOffY = 0; } break;
    292       }
    293 
    294       for(Int iY = 0; iY < m_uiHeight; iY++)
    295       {
    296         for(Int iX = 0; iX < m_uiWidth; iX++)
    297         {
    298           m_pbPattern[(iY * iStride) + iX] = pbTempPattern[(((iY<<1)+uiOffY) * iTempStride) + ((iX<<1)+uiOffX)];
    299         }
    300       }
    301     }
    302     break;
    303   }
    304 #endif
    305241
    306242  if( pbTempPattern )
     
    345281  for( Int x = x0; x <= x1; x++ )
    346282  {
    347 #if SHARP_DMM_CLEAN_K0042
    348283    Int shift = (m_eWedgeRes == HALF_PEL) ? 1 : 0;
    349284    Int stride = iPatternStride >> shift;
    350285    if( steep ) { pbPattern[((x>>shift) * stride) + (y>>shift)] = true; }
    351286    else        { pbPattern[((y>>shift) * stride) + (x>>shift)] = true; }
    352 #else
    353     if( steep ) { pbPattern[(x * iPatternStride) + y] = true; }
    354     else        { pbPattern[(y * iPatternStride) + x] = true; }
    355 #endif
    356287
    357288    error += deltaerr;
  • trunk/source/Lib/TLibCommon/TComWedgelet.h

    r1179 r1196  
    124124  Bool*           getScaledPattern(UInt uiWidth);
    125125
    126 #if SHARP_DMM_CLEAN_K0042
    127126  Void  generateWedgePatternByRotate(const TComWedgelet &rcWedge, Int rotate);
    128 #endif
    129127  Void  setWedgelet( UChar uhXs, UChar uhYs, UChar uhXe, UChar uhYe, UChar uhOri, WedgeResolution eWedgeRes, Bool bIsCoarse = false );
    130128  Void  findClosestAngle();
  • trunk/source/Lib/TLibCommon/TypeDef.h

    r1179 r1196  
    6565#define H_3D          ( HEVC_EXT == 2)
    6666
    67 #if H_MV
    68 #define SONY_MV_V_CONST_C0078            1   // Control disparity vector search range via configuration file
    69 #define H_MV_FIX_CONF_WINDOW             1   
    70 #endif
    71 
    72 #define NTT_BUG_FIX_TK54    1
    73 #define BUG_FIX_TK65        1
    74 
    75 #define MTK_I0093           1
    76 
    77 #define RWTH_DBBP_NO_SATD_K0028       1
     67
    7868/////////////////////////////////////////////////////////////////////////////////////////
    7969///////////////////////////////////   MAJOR DEFINES   /////////////////////////////////// 
     
    8575
    8676#if H_3D
    87 #define SEC_DEPTH_INTRA_SKIP_MODE_K0033   1   // Depth intra skip mode
    88 
    89 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    90 #define NEIGHBORING_PIX_AVAILABILITY_FIX  1
    91 #endif
    92 
    93 
    9477#define H_3D_QTLPC                        1   // OL_QTLIMIT_PREDCODING_B0068 //JCT3V-B0068
    9578                                              // HHI_QTLPC_RAU_OFF_C0160 JCT3V-C0160 change 2: quadtree limitation and predictive coding switched off in random access units
     
    129112                                              // SHARP_ARP_CHROMA_I0104     
    130113                                              // MTK_I0072_IVARP_SCALING_FIX
    131 #define SEC_ARP_VIEW_REF_CHECK_J0037      1   // Signaling iv_res_pred_weight_idx when the current slice has both view and temporal reference picture(s), JCT3V-J0037 item1
    132 
    133 #define SEC_ARP_REM_ENC_RESTRICT_K0035    1   // Removal of encoder restriction of ARP, JCT3V-K0035
     114                                              // SEC_ARP_VIEW_REF_CHECK_J0037    Signaling iv_res_pred_weight_idx when the current slice has both view and temporal reference picture(s), JCT3V-J0037 item1
     115                                              // SEC_ARP_REM_ENC_RESTRICT_K0035    Removal of encoder restriction of ARP, JCT3V-K0035
    134116
    135117#define H_3D_IC                           1   // Illumination Compensation, JCT3V-B0045, JCT3V-C0046, JCT3V-D0060
     
    200182                                              // SEC_ADAPT_DISABLE_IVMP        Disabling IVMP merge candidates when IC is enabled, JCT3V-H0070
    201183                                              // SEC_SIMP_SHIFTED_DV_I0086     Simplification of Shifted DV candidate, JCT3V-I0086
    202 
    203 #define SEC_SHIFTED_IVMC_POS_K0036        1   // Position Derivation for Shifted-IVMC, JCT3V-K0036
     184                                              // SEC_SHIFTED_IVMC_POS_K0036    Position Derivation for Shifted-IVMC, JCT3V-K0036
    204185
    205186
    206187#define H_3D_TMVP                         1   // QC_TMVP_C0047
    207188                                              // Sony_M23639
    208 #if H_3D_TMVP
    209 #define H_3D_TMVP_SCALING_FIX_K0053       1   // QC/CY for K0053
    210 #endif
     189                                              // H_3D_TMVP_SCALING_FIX_K0053       1   // QC/CY for K0053
     190
    211191
    212192#define H_3D_DIM                          1   // DIM, Depth intra modes, includes:
     
    249229                                              // MTK_DLT_CODING_FIX_H0091
    250230                                              // HS_DMM_SIGNALLING_I0120
    251                                               // SHARP_DMM1_I0110 // LUT size reduction for DMM1 proposed in JCT3V-I0110
     231                                              // SHARP_DMM1_I0110 LUT size reduction for DMM1 proposed in JCT3V-I0110
    252232                                              // FAST_SDC_OFFSET_DECISION_I0084
    253233                                              // SEPARATE_FLAG_I0085
     
    256236                                              // MTK_DMM_SIM_J0035
    257237                                              // MTK_J0033
    258                                               // SHARP_DLT_SIMP_J0029              1   // DLT(DepthValue2Idx[]) table derivation cleanup
    259 
    260 #if !SEC_DEPTH_INTRA_SKIP_MODE_K0033
    261 #define H_3D_SINGLE_DEPTH                 1   // Single depth mode proposed in JCT3V-I0095
    262                                               // HS_SP_SIMP_J0066
    263                                               // SINGLE_DEPTH_SIMP_J0115           1
    264                                               // MTK_SINGLE_DEPTH_VPS_FLAG_J0060   1   // Add VPS control flags and remove slice header control flag for single depth, JCT3V-J0060
    265 #endif
     238                                              // SHARP_DLT_SIMP_J0029 DLT(DepthValue2Idx[]) table derivation cleanup
     239                                              // SHARP_DMM_CLEAN_K0042             1   // Generate DMM pattern with rotation
     240
    266241
    267242#define H_3D_INTER_SDC                    1   // INTER SDC, Inter simplified depth coding
     
    269244                                              // SEC_INTER_SDC_G0101 Improved inter SDC with multiple DC candidates
    270245
    271 #define H_3D_SPIVMP                       1   // H_3D_SPIVMP    // JCT3V-F0110: Sub-PU level inter-view motion prediction
     246#define H_3D_SPIVMP                       1   // H_3D_SPIVMP JCT3V-F0110: Sub-PU level inter-view motion prediction
    272247                                              // SEC_SPIVMP_MCP_SIZE_G0077, Apply SPIVMP only to 2Nx2N partition, JCT3V-G0077
    273248                                              // QC_SPIVMP_MPI_G0119 Sub-PU level MPI merge candidate
     
    280255                                              // SEC_DBBP_FILTERING_H0104
    281256                                              // MTK_DBBP_SIGNALING_H0094   
    282                                               // H_3D_FIX_DBBP_IVMP        Fix . Enable IVMP is always disabled, when DBBP is enabled. The original intention is to disable Sub-PU IVMP when DBBP is enabled, not to disable IVMP itself.
    283                                               // SEC_DBBP_EXPLICIT_SIG_I0077       1   // Remove the partition derivation and signal dbbp_flag only when the partition mode is 2NxN/Nx2N, JCT3V-I0077
     257                                              // H_3D_FIX_DBBP_IVMP Fix . Enable IVMP is always disabled, when DBBP is enabled. The original intention is to disable Sub-PU IVMP when DBBP is enabled, not to disable IVMP itself.
     258                                              // SEC_DBBP_EXPLICIT_SIG_I0077 Remove the partition derivation and signal dbbp_flag only when the partition mode is 2NxN/Nx2N, JCT3V-I0077
    284259                                              // Disallow DBBP in 8x8 CU, JCT3V-I0078
    285                                               // SHARP_DBBP_SIMPLE_FLTER_I0109     1   // Simple condition and one dimensional filter for DBBP
    286                                               // SEC_DBBP_DMM4_THRESHOLD_I0076     Simplification of threshold derivation for DBBP and DMM4, JCT3V-I0076
    287                                               // SEC_DBBP_VIEW_REF_CHECK_J0037     1   // Signaling dbbp_flag when the current slice has view reference picture(s), JCT3V-J0037 item4
    288 #define HS_DBBP_CLEAN_K0048     1
     260                                              // SHARP_DBBP_SIMPLE_FLTER_I0109 Simple condition and one dimensional filter for DBBP
     261                                              // SEC_DBBP_DMM4_THRESHOLD_I0076 Simplification of threshold derivation for DBBP and DMM4, JCT3V-I0076
     262                                              // SEC_DBBP_VIEW_REF_CHECK_J0037 Signaling dbbp_flag when the current slice has view reference picture(s), JCT3V-J0037 item4
     263                                              // RWTH_DBBP_NO_SATD_K0028
     264                                              // HS_DBBP_CLEAN_K0048
    289265
    290266#define H_3D_DDD                          1   // Disparity derived depth coding
    291267                                              // LGE_DDD_REMOVAL_J0042_J0030 DDD removal
    292268
     269#define H_3D_DIS                          1   // Depth intra skip
     270                                              // SEC_DEPTH_INTRA_SKIP_MODE_K0033  Depth intra skip mode
     271
    293272#define H_3D_FCO                          0   // Flexible coding order for 3D
    294 #if H_3D_FCO
    295 #define H_3D_FCO                          1
    296 #endif
    297273
    298274#define H_3D_FAST_INTRA_SDC               1   // I0123
     
    300276// OTHERS
    301277                                              // MTK_SONY_PROGRESSIVE_MV_COMPRESSION_E0170 // Progressive MV Compression, JCT3V-E0170
    302 #define H_3D_REN_MAX_DEV_OUT              0   // Output maximal possible shift deviation
     278
    303279#define H_3D_FAST_TEXTURE_ENCODING        1   // Fast merge mode decision and early CU determination for texture component of dependent view, JCT3V-E0173
    304280                                              // MTK_FAST_TEXTURE_ENCODING_E0173
    305281#if H_3D_DIM
    306 #define H_3D_FAST_DEPTH_INTRA             1   // Fast DMM and RBC Mode Selection
     282#define H_3D_FAST_DEPTH_INTRA             1   // Fast DMM Selection
    307283                                              // SCU_HS_FAST_DEPTH_INTRA_E0238_HHIFIX
    308284#endif
    309285
    310286//HLS
    311 //HHI_DEPENDENCY_SIGNALLING_I1_J0107
    312 //HHI_TOOL_PARAMETERS_I2_J0107
    313 //HHI_VPS_3D_EXTENSION_I3_J0107
     287                                             // HHI_DEPENDENCY_SIGNALLING_I1_J0107
     288                                             // HHI_TOOL_PARAMETERS_I2_J0107
     289                                             // HHI_VPS_3D_EXTENSION_I3_J0107
     290                                             // HHI_INTER_COMP_PRED_K0052
     291                                             // HHI_RES_PRED_K0052       
     292                                             // HHI_CAM_PARA_K0052       
     293                                             // H_3D_DIRECT_DEP_TYPE     
    314294
    315295// Rate Control
     
    319299#endif // H_3D
    320300
    321 
    322 
    323301/////////////////////////////////////////////////////////////////////////////////////////
    324302///////////////////////////////////   DERIVED DEFINES /////////////////////////////////// 
    325303/////////////////////////////////////////////////////////////////////////////////////////
    326304
    327 // Fixes
    328 
    329 #define FIX_TICKET_95                          1   // pps_scaling_list_ref_layer_id parsing
    330 
    331305#if H_3D
    332306#define H_3D_DISABLE_CHROMA                    1
    333 #define HHI_VIEW_ID_LIST_I5_J0107              0
    334 #define HHI_INTER_COMP_PRED_K0052              1
    335 #define HHI_RES_PRED_K0052                     1
    336 #define HHI_CAM_PARA_K0052                     1
    337 #define HHI_MOVE_SYN_K0052                     1
    338 #define H_3D_ANNEX_SELECTION_FIX               1
    339 #define H_3D_TMVP_FIX_TICKET_97                1
    340 #define H_3D_DIRECT_DEP_TYPE                   1
    341 #define H_3D_FIX_TMVP_SCALING_VIEW_ID          1
    342 #endif
    343 #define H_MV_FIX_REF_LAYER_PIC_FLAG            1
    344 #define H_MV_FIX_NUM_VIEWS                     1
    345307#define H_3D_OUTPUT_ACTIVE_TOOLS               0
    346 
    347 #if !SEC_DEPTH_INTRA_SKIP_MODE_K0033
    348 ///// ***** SINGLE DEPTH MODE *********
    349 #if H_3D_SINGLE_DEPTH
    350 #define SINGLE_DEPTH_MODE_CAND_LIST_SIZE            2 // size of the sample candidate list
    351 
    352 #endif
     308#define H_3D_REN_MAX_DEV_OUT                   0
    353309#endif
    354310
     
    384340                                              // HHI_DEPTH_INTRA_SEARCH_RAU_C0160
    385341                                              // LG_ZEROINTRADEPTHRESI_A0087
    386 #define SHARP_DMM_CLEAN_K0042             1   // Generate DMM pattern with rotation
    387 
    388 #define TICKET083_IVPFLAG_FIX             1
    389 #define SHARP_SUBBLOCK_CLEAN_K0044        1   // Remove unused bipred restriction
    390342
    391343#endif
     
    434386// TBD: Check if integration is necessary.
    435387
    436 #define H_MV_HLS_FIX                         1
     388
    437389#define H_MV_HLS_PTL_LIMITS                  0
    438390#define H_MV_HLS7_GEN                        0  // General changes (not tested)
    439 #define H_MV_ALIGN_HM_15                     1 
    440391
    441392// POC
  • trunk/source/Lib/TLibDecoder/TDecCAVLC.cpp

    r1179 r1196  
    3939#include "SEIread.h"
    4040#include "TDecSlice.h"
    41 #if H_3D_ANNEX_SELECTION_FIX
     41#if H_3D
    4242#include "TDecTop.h"
    4343#endif
     
    9393TDecCavlc::TDecCavlc()
    9494{
    95 #if !HHI_CAM_PARA_K0052
    96 #if H_3D
    97   m_aaiTempScale            = new Int* [ MAX_NUM_LAYERS ];
    98   m_aaiTempOffset           = new Int* [ MAX_NUM_LAYERS ];
    99   for( UInt uiVId = 0; uiVId < MAX_NUM_LAYERS; uiVId++ )
    100   {
    101     m_aaiTempScale            [ uiVId ] = new Int [ MAX_NUM_LAYERS ];
    102     m_aaiTempOffset           [ uiVId ] = new Int [ MAX_NUM_LAYERS ];
    103   }
    104 #endif
    105 #endif
    10695}
    10796
    10897TDecCavlc::~TDecCavlc()
    10998{
    110 #if !HHI_CAM_PARA_K0052
    111 #if H_3D
    112   for( UInt uiVId = 0; uiVId < MAX_NUM_LAYERS; uiVId++ )
    113   {
    114     delete [] m_aaiTempScale            [ uiVId ];
    115     delete [] m_aaiTempOffset           [ uiVId ];
    116   }
    117   delete [] m_aaiTempScale;
    118   delete [] m_aaiTempOffset;
    119 #endif
    120 #endif
    12199}
    122100
     
    10481026      READ_FLAG( uiCode, "qt_pred_flag" ); sps3dExt->setQtPredFlag( d, uiCode == 1 );
    10491027      READ_FLAG( uiCode, "inter_sdc_flag" ); sps3dExt->setInterSdcFlag( d, uiCode == 1 );
    1050 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    10511028      READ_FLAG( uiCode, "intra_skip_flag" ); sps3dExt->setDepthIntraSkipFlag( d, uiCode == 1 );
    1052 #else
    1053       READ_FLAG( uiCode, "intra_single_flag" ); sps3dExt->setIntraSingleFlag( d, uiCode == 1 );
    1054 #endif
    10551029    }
    10561030  }
     
    10631037  READ_FLAG( uiCode, "poc_reset_info_present_flag" ); pcPPS->setPocResetInfoPresentFlag( uiCode == 1 );
    10641038  READ_FLAG( uiCode, "pps_infer_scaling_list_flag" ); pcPPS->setPpsInferScalingListFlag( uiCode == 1 );
    1065 #if FIX_TICKET_95
    10661039  if (pcPPS->getPpsInferScalingListFlag())
    10671040  {
    10681041  READ_CODE( 6, uiCode, "pps_scaling_list_ref_layer_id" ); pcPPS->setPpsScalingListRefLayerId( uiCode );
    10691042  }
    1070 #else
    1071   READ_CODE( 6, uiCode, "pps_scaling_list_ref_layer_id" ); pcPPS->setPpsScalingListRefLayerId( uiCode );
    1072 #endif
    10731043
    10741044  UInt numRefLocOffsets;;
     
    13361306  }
    13371307
    1338 #if HHI_INTER_COMP_PRED_K0052
    13391308#if H_3D
    13401309  pcVPS->initViewCompLayer( );
    1341 #endif
    13421310#endif
    13431311
     
    19291897Void TDecCavlc::parseVPS3dExtension( TComVPS* pcVPS )
    19301898{
    1931 #if HHI_CAM_PARA_K0052
    19321899  UInt uiCode;   
    19331900  READ_UVLC( uiCode, "cp_precision"); pcVPS->setCpPrecision( uiCode ) ;
     
    19591926  }
    19601927  pcVPS->deriveCpPresentFlag();
    1961 #else
    1962   UInt uiCode;
    1963 
    1964   UInt uiCamParPrecision = 0;
    1965   Bool bCamParSlice      = false;
    1966   Bool bCamParPresentFlag = false;
    1967 
    1968   READ_UVLC( uiCamParPrecision, "cp_precision" );
    1969 #if HHI_VIEW_ID_LIST_I5_J0107
    1970   for (Int n = 1; n < pcVPS->getNumViews(); n++)
    1971   {
    1972     Int viewIndex = pcVPS->getViewOIdxList( n );
    1973 #else
    1974   for (UInt viewIndex=1; viewIndex<pcVPS->getNumViews(); viewIndex++)
    1975   {
    1976 #endif
    1977     pcVPS->setCamParPresent         ( viewIndex, false );
    1978     pcVPS->setHasCamParInSliceHeader( viewIndex, false );
    1979     READ_FLAG( uiCode, "cp_present_flag[i]" );                  bCamParPresentFlag = ( uiCode == 1);
    1980     if ( bCamParPresentFlag )
    1981     {
    1982       READ_FLAG( uiCode, "cp_in_slice_segment_header_flag[i]" );          bCamParSlice = ( uiCode == 1);
    1983       if ( !bCamParSlice )
    1984       {
    1985 #if HHI_VIEW_ID_LIST_I5_J0107
    1986         for( UInt m = 0; m < n; n++ )
    1987         {
    1988           Int uiBaseIndex = pcVPS->getViewOIdxList ( m );
    1989           Int iCode;
    1990           READ_SVLC( iCode, "vps_cp_scale" );                m_aaiTempScale  [ uiBaseIndex ][ viewIndex ]   = iCode;
    1991           READ_SVLC( iCode, "vps_cp_off" );                  m_aaiTempOffset [ uiBaseIndex ][ viewIndex ]   = iCode;
    1992           READ_SVLC( iCode, "vps_cp_inv_scale_plus_scale" ); m_aaiTempScale  [ viewIndex   ][ uiBaseIndex ] = iCode - m_aaiTempScale [ uiBaseIndex ][ viewIndex ];
    1993           READ_SVLC( iCode, "vps_cp_inv_off_plus_off" );     m_aaiTempOffset [ viewIndex   ][ uiBaseIndex ] = iCode - m_aaiTempOffset[ uiBaseIndex ][ viewIndex ];
    1994         }
    1995       }
    1996       pcVPS->initCamParaVPS( viewIndex, bCamParPresentFlag, uiCamParPrecision, bCamParSlice, m_aaiTempScale, m_aaiTempOffset );
    1997 #else
    1998         for( UInt uiBaseIndex = 0; uiBaseIndex < viewIndex; uiBaseIndex++ )
    1999         {
    2000           Int iCode;
    2001           READ_SVLC( iCode, "vps_cp_scale" );                m_aaiTempScale  [ uiBaseIndex ][ viewIndex ]   = iCode;
    2002           READ_SVLC( iCode, "vps_cp_off" );                  m_aaiTempOffset [ uiBaseIndex ][ viewIndex ]   = iCode;
    2003           READ_SVLC( iCode, "vps_cp_inv_scale_plus_scale" ); m_aaiTempScale  [ viewIndex   ][ uiBaseIndex ] = iCode - m_aaiTempScale [ uiBaseIndex ][ viewIndex ];
    2004           READ_SVLC( iCode, "vps_cp_inv_off_plus_off" );     m_aaiTempOffset [ viewIndex   ][ uiBaseIndex ] = iCode - m_aaiTempOffset[ uiBaseIndex ][ viewIndex ];
    2005         }
    2006       }
    2007       pcVPS->initCamParaVPS( viewIndex, bCamParPresentFlag, uiCamParPrecision, bCamParSlice, m_aaiTempScale, m_aaiTempOffset );
    2008 #endif
    2009     }
    2010   }
    2011 #endif
    20121928}
    20131929#endif
     
    20701986#endif
    20711987  rpcSlice->setSPS(sps);
    2072 #if !HHI_INTER_COMP_PRED_K0052
    2073 #if H_3D
    2074   rpcSlice->init3dToolParameters();
    2075 #endif
    2076 #endif
    20771988  rpcSlice->setPPS(pps);
    20781989  if( pps->getDependentSliceSegmentsEnabledFlag() && ( !firstSliceSegmentInPic ))
     
    24682379      }
    24692380    }
    2470 #if HHI_INTER_COMP_PRED_K0052
    24712381#if H_3D
    24722382    if ( getDecTop()->decProcAnnexI() )
     
    24812391#endif
    24822392#endif
    2483 #endif
    24842393    if(sps->getUseSAO())
    24852394    {
     
    24882397      if( rpcSlice->getSPS()->getChromaFormatIdc() != 0 )
    24892398      {
    2490       READ_FLAG(uiCode, "slice_sao_chroma_flag");  rpcSlice->setSaoEnabledFlagChroma((Bool)uiCode);
    2491     }
     2399        READ_FLAG(uiCode, "slice_sao_chroma_flag");  rpcSlice->setSaoEnabledFlagChroma((Bool)uiCode);
     2400      }
    24922401      else
    24932402      {
    24942403        rpcSlice->setSaoEnabledFlagChroma( false );
    24952404      }
    2496      
    24972405#else
    24982406      READ_FLAG(uiCode, "slice_sao_chroma_flag");  rpcSlice->setSaoEnabledFlagChroma((Bool)uiCode);
     
    26622570    }
    26632571#if H_3D_IC
    2664 #if H_3D_ANNEX_SELECTION_FIX
    26652572    else if(    rpcSlice->getViewIndex() && ( rpcSlice->getSliceType() == P_SLICE || rpcSlice->getSliceType() == B_SLICE )
    26662573             && !rpcSlice->getIsDepth() && vps->getNumRefListLayers( layerId ) > 0
    26672574             && getDecTop()->decProcAnnexI()
    26682575           )
    2669 #else
    2670     else if( rpcSlice->getViewIndex() && ( rpcSlice->getSliceType() == P_SLICE || rpcSlice->getSliceType() == B_SLICE ) && !rpcSlice->getIsDepth() && vps->getNumRefListLayers( layerId ) > 0 )
    2671 #endif
    26722576    {
    26732577      UInt uiCodeTmp = 0;
     
    27662670    rpcSlice->setLFCrossSliceBoundaryFlag( (uiCode==1)?true:false);
    27672671
    2768 #if HHI_CAM_PARA_K0052
    27692672#if H_3D
    27702673    if ( getDecTop()->decProcAnnexI() )
     
    27842687    }
    27852688#endif
    2786 #endif
    27872689  }
    27882690 
     
    28082710  }
    28092711
    2810 #if !HHI_CAM_PARA_K0052
    2811 #if H_3D
    2812 #if H_3D_FCO
    2813   if( rpcSlice->getVPS()->hasCamParInSliceHeader( rpcSlice->getViewIndex() )  && rpcSlice->getIsDepth() )
    2814 #else
    2815   if( rpcSlice->getVPS()->hasCamParInSliceHeader( rpcSlice->getViewIndex() )  && !rpcSlice->getIsDepth() )
    2816 #endif
    2817   {
    2818     UInt uiViewIndex = rpcSlice->getViewIndex();
    2819     for( UInt uiBaseIndex = 0; uiBaseIndex < uiViewIndex; uiBaseIndex++ )
    2820     {
    2821       READ_SVLC( iCode, "cp_scale" );                m_aaiTempScale [ uiBaseIndex ][ uiViewIndex ] = iCode;
    2822       READ_SVLC( iCode, "cp_off" );                  m_aaiTempOffset[ uiBaseIndex ][ uiViewIndex ] = iCode;
    2823       READ_SVLC( iCode, "cp_inv_scale_plus_scale" ); m_aaiTempScale [ uiViewIndex ][ uiBaseIndex ] = iCode - m_aaiTempScale [ uiBaseIndex ][ uiViewIndex ];
    2824       READ_SVLC( iCode, "cp_inv_off_plus_off" );     m_aaiTempOffset[ uiViewIndex ][ uiBaseIndex ] = iCode - m_aaiTempOffset[ uiBaseIndex ][ uiViewIndex ];
    2825     }
    2826     rpcSlice->setCamparaSlice( m_aaiTempScale, m_aaiTempOffset );
    2827   }
    2828 #endif
    2829 #endif
    28302712
    28312713  if(pps->getSliceHeaderExtensionPresentFlag())
     
    31002982  assert(0);
    31012983}
    3102 
    3103 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2984#if H_3D
    31042985Void TDecCavlc::parseDIS( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
    31052986{
    31062987  assert(0);
    31072988}
    3108 #else
    3109 #if H_3D_SINGLE_DEPTH
    3110 Void TDecCavlc::parseSingleDepthMode( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
    3111 {
    3112   assert(0);
    3113 }
    3114 #endif
    31152989#endif
    31162990
  • trunk/source/Lib/TLibDecoder/TDecCAVLC.h

    r1179 r1196  
    5252// Class definition
    5353// ====================================================================================================================
    54 #if H_3D_ANNEX_SELECTION_FIX
     54#if H_3D
    5555class TDecTop;
    5656#endif
    57 
    5857/// CAVLC decoder class
    5958class TDecCavlc : public SyntaxElementParser, public TDecEntropyIf
     
    6665  void  parseShortTermRefPicSet            (TComSPS* pcSPS, TComReferencePictureSet* pcRPS, Int idx);
    6766 
    68 
    69 #if !HHI_CAM_PARA_K0052
    7067#if H_3D
    71   Int**    m_aaiTempScale;
    72   Int**    m_aaiTempOffset;
    73 #endif
    74 #endif
    75 #if H_3D_ANNEX_SELECTION_FIX
    7668  TDecTop*  m_decTop;
    7769#endif
     
    118110  Void  parsePPS            ( TComPPS* pcPPS);
    119111#endif
    120 #if H_3D_ANNEX_SELECTION_FIX
     112#if H_3D
    121113  Void  setDecTop           ( TDecTop* decTop ) { m_decTop = decTop; };
    122114#endif
     
    136128 
    137129  Void  parseSkipFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    138 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     130#if H_3D
    139131  Void  parseDIS            ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    140 #else
    141 #if H_3D_SINGLE_DEPTH
    142   Void  parseSingleDepthMode        ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    143 #endif
    144132#endif
    145133  Void  parseCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
     
    182170  Void  parseScalingList               ( TComScalingList* scalingList );
    183171  Void xDecodeScalingList    ( TComScalingList *scalingList, UInt sizeId, UInt listId);
    184 
    185 #if H_3D_ANNEX_SELECTION_FIX
     172#if H_3D
    186173  TDecTop*  getDecTop()      { return m_decTop; };
    187174#endif
  • trunk/source/Lib/TLibDecoder/TDecCu.cpp

    r1179 r1196  
    310310#if H_3D_NBDV
    311311  DisInfo DvInfo;
    312 #if !SEC_ARP_REM_ENC_RESTRICT_K0035
    313   DvInfo.bDV = false;
    314 #endif
    315312  DvInfo.m_acNBDV.setZero();
    316313  DvInfo.m_aVIdxCan = 0;
     
    347344      if( pcCU->getSlice()->getIsDepth())
    348345      {
    349 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    350346        m_ppcCU[uiDepth]->getDispforDepth(0, 0, &DvInfo);
    351 #else
    352         DvInfo.bDV = m_ppcCU[uiDepth]->getDispforDepth(0, 0, &DvInfo);
    353 #endif
    354347      }
    355348      else
     
    359352      if( pcCU->getSlice()->getDepthBasedBlkPartFlag() )  //Notes from QC: please check the condition for DoNBDV. Remove this comment once it is done.
    360353      {
    361 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    362354        m_ppcCU[uiDepth]->getDisMvpCandNBDV(&DvInfo, true);
    363 #else
    364         DvInfo.bDV = m_ppcCU[uiDepth]->getDisMvpCandNBDV(&DvInfo, true);
    365 #endif
    366355      }
    367356      else
    368357#endif
    369358      {
    370 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    371359        m_ppcCU[uiDepth]->getDisMvpCandNBDV(&DvInfo);
    372 #else
    373         DvInfo.bDV = m_ppcCU[uiDepth]->getDisMvpCandNBDV(&DvInfo);
    374 #endif
    375360      }
    376361#if H_3D_IV_MERGE
     
    545530    return;
    546531  }
    547 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     532#if H_3D
    548533  m_pcEntropyDecoder->decodeDIS( pcCU, uiAbsPartIdx, uiDepth );
    549534  if(!pcCU->getDISFlag(uiAbsPartIdx))
    550535  {
    551 #else
    552 #if H_3D_SINGLE_DEPTH
    553   m_pcEntropyDecoder->decodeSingleDepthMode( pcCU, uiAbsPartIdx, uiDepth );
    554   if(!pcCU->getSingleDepthFlag(uiAbsPartIdx))
    555   {
    556 #endif
    557536#endif
    558537  m_pcEntropyDecoder->decodePredMode( pcCU, uiAbsPartIdx, uiDepth );
    559538  m_pcEntropyDecoder->decodePartSize( pcCU, uiAbsPartIdx, uiDepth );
    560539
    561 #if !HHI_MOVE_SYN_K0052
    562 #if H_3D_DIM_SDC
    563   m_pcEntropyDecoder->decodeSDCFlag( pcCU, uiAbsPartIdx, uiDepth );
    564 #endif
    565 #endif
    566540  if (pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N )
    567541  {
     
    570544    if(pcCU->getIPCMFlag(uiAbsPartIdx))
    571545    {
    572 #if HHI_MOVE_SYN_K0052
    573546#if H_3D_DIM_SDC
    574547      m_pcEntropyDecoder->decodeSDCFlag( pcCU, uiAbsPartIdx, uiDepth );
    575 #endif
    576548#endif
    577549      xFinishDecodeCU( pcCU, uiAbsPartIdx, uiDepth, ruiIsLast );
     
    593565  m_pcEntropyDecoder->decodeCoeff( pcCU, uiAbsPartIdx, uiDepth, uiCurrWidth, uiCurrHeight, bCodeDQP );
    594566  setdQPFlag( bCodeDQP );
    595 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    596   }
    597 #else
    598 #if H_3D_SINGLE_DEPTH
    599   }
    600 #endif
     567#if H_3D
     568  }
    601569#endif
    602570  xFinishDecodeCU( pcCU, uiAbsPartIdx, uiDepth, ruiIsLast );
     
    625593  UInt uiTPelY   = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
    626594  UInt uiBPelY   = uiTPelY + (g_uiMaxCUHeight>>uiDepth) - 1;
    627  
     595
    628596  UInt uiCurNumParts    = pcPic->getNumPartInCU() >> (uiDepth<<1);
    629597  TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
     
    633601    bBoundary = true;
    634602  }
    635  
     603
    636604  if( ( ( uiDepth < pcCU->getDepth( uiAbsPartIdx ) ) && ( uiDepth < g_uiMaxCUDepth - g_uiAddCUDepth ) ) || bBoundary )
    637605  {
     
    643611      uiLPelX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiIdx] ];
    644612      uiTPelY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiIdx] ];
    645      
     613
    646614      Bool binSlice = (pcCU->getSCUAddr()+uiIdx+uiQNumParts>pcSlice->getSliceSegmentCurStartCUAddr())&&(pcCU->getSCUAddr()+uiIdx<pcSlice->getSliceSegmentCurEndCUAddr());
    647615      if(binSlice&&( uiLPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiTPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
     
    649617        xDecompressCU(pcCU, uiIdx, uiNextDepth );
    650618      }
    651      
     619
    652620      uiIdx += uiQNumParts;
    653621    }
     
    657625  // Residual reconstruction
    658626  m_ppcYuvResi[uiDepth]->clear();
    659  
     627
    660628  m_ppcCU[uiDepth]->copySubCU( pcCU, uiAbsPartIdx, uiDepth );
    661629
    662630  switch( m_ppcCU[uiDepth]->getPredictionMode(0) )
    663631  {
    664     case MODE_INTER:
     632  case MODE_INTER:
    665633#if H_3D_DBBP
    666       if( m_ppcCU[uiDepth]->getDBBPFlag(0) )
    667       {
    668         xReconInterDBBP( m_ppcCU[uiDepth], uiAbsPartIdx, uiDepth );
    669       }
    670       else
    671       {
     634    if( m_ppcCU[uiDepth]->getDBBPFlag(0) )
     635    {
     636      xReconInterDBBP( m_ppcCU[uiDepth], uiAbsPartIdx, uiDepth );
     637    }
     638    else
     639    {
    672640#endif
    673641#if H_3D_INTER_SDC
     
    679647      {
    680648#endif
    681       xReconInter( m_ppcCU[uiDepth], uiDepth );
     649        xReconInter( m_ppcCU[uiDepth], uiDepth );
    682650#if H_3D_INTER_SDC
    683651      }
    684652#endif
    685653#if H_3D_DBBP
    686       }
    687 #endif
    688       break;
    689     case MODE_INTRA:
    690 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    691       if( m_ppcCU[uiDepth]->getDISFlag(0) )
    692       {
    693         xReconDIS( m_ppcCU[uiDepth], 0, uiDepth );
    694       }
     654    }
     655#endif
     656    break;
     657  case MODE_INTRA:
     658#if H_3D
     659    if( m_ppcCU[uiDepth]->getDISFlag(0) )
     660    {
     661      xReconDIS( m_ppcCU[uiDepth], 0, uiDepth );
     662    }
    695663#if H_3D_DIM_SDC
    696       else if( m_ppcCU[uiDepth]->getSDCFlag(0) )
    697       {
    698         xReconIntraSDC( m_ppcCU[uiDepth], 0, uiDepth );
    699       }
    700 #endif
    701       else
    702 #else
    703 #if H_3D_SINGLE_DEPTH
    704       if( m_ppcCU[uiDepth]->getSingleDepthFlag(0) )
    705         xReconIntraSingleDepth( m_ppcCU[uiDepth], 0, uiDepth );
    706 #if H_3D_DIM_SDC
    707       else if( m_ppcCU[uiDepth]->getSDCFlag(0) )
    708         xReconIntraSDC( m_ppcCU[uiDepth], 0, uiDepth );
    709 #endif
    710       else
    711 #else
    712 #if H_3D_DIM_SDC
    713       if( m_ppcCU[uiDepth]->getSDCFlag(0) )
    714         xReconIntraSDC( m_ppcCU[uiDepth], 0, uiDepth );
    715       else
    716 #endif
    717 #endif
     664    else if( m_ppcCU[uiDepth]->getSDCFlag(0) )
     665    {
     666      xReconIntraSDC( m_ppcCU[uiDepth], 0, uiDepth );
     667    }
     668#endif
     669    else
    718670#endif
    719671      xReconIntraQT( m_ppcCU[uiDepth], uiDepth );
    720       break;
    721     default:
    722       assert(0);
    723       break;
     672    break;
     673  default:
     674    assert(0);
     675    break;
    724676  }
    725677  if ( m_ppcCU[uiDepth]->isLosslessCoded(0) && (m_ppcCU[uiDepth]->getIPCMFlag(0) == false))
     
    727679    xFillPCMBuffer(m_ppcCU[uiDepth], uiDepth);
    728680  }
    729  
     681
    730682  xCopyToPic( m_ppcCU[uiDepth], pcPic, uiAbsPartIdx, uiDepth );
    731683}
     
    751703}
    752704
    753 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     705#if H_3D
    754706Void TDecCu::xReconDIS( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    755707{
     
    828780  }
    829781}
    830 #else
    831 #if H_3D_SINGLE_DEPTH
    832 Void TDecCu::xReconIntraSingleDepth( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    833 {
    834   UInt uiWidth        = pcCU->getWidth  ( 0 );
    835   UInt uiHeight       = pcCU->getHeight ( 0 );
    836 
    837   TComYuv* pcRecoYuv  = m_ppcYuvReco[uiDepth];
    838 
    839   UInt    uiStride    = pcRecoYuv->getStride  ();
    840   Pel*    piReco      = pcRecoYuv->getLumaAddr( uiAbsPartIdx );
    841 
    842 
    843   AOF( uiWidth == uiHeight );
    844   AOF( uiAbsPartIdx == 0 );
    845 
    846   //construction of depth candidates
    847   Pel testDepth;
    848   Pel DepthNeighbours[2];
    849   Int index =0;
    850   for( Int i = 0; (i < 2) && (index<SINGLE_DEPTH_MODE_CAND_LIST_SIZE) ; i++ )
    851   {
    852     if(!pcCU->getNeighDepth (0, uiAbsPartIdx, &testDepth, i))
    853     {
    854       continue;
    855     }
    856     DepthNeighbours[index]=testDepth;
    857     index++;
    858   }
    859 
    860   if(index==0)
    861   {
    862     DepthNeighbours[index]=1<<(g_bitDepthY-1);
    863     index++;
    864   }
    865 
    866   if(index==1)
    867   {
    868     DepthNeighbours[index]=ClipY(DepthNeighbours[0] + 1 );
    869     index++;
    870   }
    871 
    872   for( UInt uiY = 0; uiY < uiHeight; uiY++ )
    873   {
    874     for( UInt uiX = 0; uiX < uiWidth; uiX++ )
    875     {
    876       piReco[ uiX ] =DepthNeighbours[(Int)pcCU->getSingleDepthValue(uiAbsPartIdx)];
    877     }
    878     piReco     += uiStride;
    879   }
    880 
    881   // clear UV
    882   UInt  uiStrideC     = pcRecoYuv->getCStride();
    883   Pel   *pRecCb       = pcRecoYuv->getCbAddr();
    884   Pel   *pRecCr       = pcRecoYuv->getCrAddr();
    885 
    886   for (Int y=0; y<uiHeight/2; y++)
    887   {
    888     for (Int x=0; x<uiWidth/2; x++)
    889     {
    890       pRecCb[x] = 1<<(g_bitDepthC-1);
    891       pRecCr[x] = 1<<(g_bitDepthC-1);
    892     }
    893 
    894     pRecCb += uiStrideC;
    895     pRecCr += uiStrideC;
    896   }
    897 }
    898 #endif
    899 #endif
    900 
     782#endif
    901783#if H_3D_INTER_SDC
    902784Void TDecCu::xReconInterSDC( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
     
    962844  // compute mask by segmenting depth block
    963845  Bool pMask[MAX_CU_SIZE*MAX_CU_SIZE];
    964 #if HS_DBBP_CLEAN_K0048
    965846  Bool bValidMask = m_pcPrediction->getSegmentMaskFromDepth(pDepthPels, uiDepthStride, pcCU->getWidth(0), pcCU->getHeight(0), pMask, pcCU);
    966 #else
    967   Bool bValidMask = m_pcPrediction->getSegmentMaskFromDepth(pDepthPels, uiDepthStride, pcCU->getWidth(0), pcCU->getHeight(0), pMask);
    968 #endif
    969847  AOF(bValidMask);
    970848 
    971   DBBPTmpData* pDBBPTmpData = pcCU->getDBBPTmpData();
     849  DbbpTmpData* pDBBPTmpData = pcCU->getDBBPTmpData();
    972850  TComYuv* apSegPredYuv[2] = { m_ppcYuvReco[uiDepth], m_ppcYuvRecoDBBP[uiDepth] };
    973851 
  • trunk/source/Lib/TLibDecoder/TDecCu.h

    r1179 r1196  
    123123  Void setdQPFlag               ( Bool b )                { m_bDecodeDQP = b;           }
    124124  Void xFillPCMBuffer           (TComDataCU* pCU, UInt depth);
    125 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     125#if H_3D
    126126  Void xReconDIS               ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    127 #else
    128 #if H_3D_SINGLE_DEPTH
    129   Void xReconIntraSingleDepth( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    130 #endif
    131127#endif
    132128#if H_3D_DIM_SDC
  • trunk/source/Lib/TLibDecoder/TDecEntropy.cpp

    r1179 r1196  
    5252  m_pcEntropyDecoderIf->parseSkipFlag( pcCU, uiAbsPartIdx, uiDepth );
    5353}
    54 
    55 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     54#if H_3D
    5655Void TDecEntropy::decodeDIS( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    5756{
     
    6362  m_pcEntropyDecoderIf->parseDIS( pcCU, uiAbsPartIdx, uiDepth );
    6463}
    65 #else
    66 #if H_3D_SINGLE_DEPTH
    67 Void TDecEntropy::decodeSingleDepthMode( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    68 {
    69   if( !pcCU->getSlice()->getIntraSingleFlag() )
    70   {
    71     return;
    72   } 
    73 
    74   m_pcEntropyDecoderIf->parseSingleDepthMode( pcCU, uiAbsPartIdx, uiDepth );
    75 }
    76 #endif
    7764#endif
    7865
     
    161148{
    162149  m_pcEntropyDecoderIf->parsePartSize( pcCU, uiAbsPartIdx, uiDepth );
    163 #if !HHI_MOVE_SYN_K0052 
    164 #if H_3D_DBBP
    165 if( pcCU->getSlice()->getDepthBasedBlkPartFlag() && (pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2NxN || pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_Nx2N) && pcCU->getWidth(uiAbsPartIdx) > 8 && pcCU->getSlice()->getDefaultRefViewIdxAvailableFlag() )
    166   {
    167     decodeDBBPFlag(pcCU, uiAbsPartIdx, uiDepth);
    168   }
    169 #endif
    170 #endif
    171150}
    172151
     
    176155  {
    177156    decodeIntraDirModeLuma  ( pcCU, uiAbsPartIdx, uiDepth );
    178 #if HHI_MOVE_SYN_K0052
     157#if H_3D_DIM_SDC
    179158    decodeSDCFlag   ( pcCU, uiAbsPartIdx, uiDepth );   
    180 #endif
    181 #if H_3D_DIM_SDC
    182159#if H_3D_DISABLE_CHROMA
    183 #if !HHI_MOVE_SYN_K0052
    184     if(!pcCU->getSDCFlag(uiAbsPartIdx) && !pcCU->getSlice()->getIsDepth() )
    185 #else
    186160    if(!pcCU->getSDCFlag(uiAbsPartIdx) && pcCU->getSlice()->getSPS()->getChromaFormatIdc() != 0  )
    187 #endif
    188161#else
    189162    if(!pcCU->getSDCFlag(uiAbsPartIdx))
     
    247220#endif
    248221#if H_3D_SPIVMP
    249   Bool bSPIVMPFlag[MRG_MAX_NUM_CANDS_MEM];
    250   TComMvField*  pcMvFieldSP;
    251   UChar* puhInterDirSP;
    252   pcMvFieldSP = new TComMvField[pcCU->getPic()->getPicSym()->getNumPartition()*2];
    253   puhInterDirSP = new UChar[pcCU->getPic()->getPicSym()->getNumPartition()];
     222  Bool bSPIVMPFlag[MRG_MAX_NUM_CANDS_MEM];     
     223  TComMvField*  pcMvFieldSP = new TComMvField[pcCU->getPic()->getPicSym()->getNumPartition()*2];
     224  UChar* puhInterDirSP = new UChar[pcCU->getPic()->getPicSym()->getNumPartition()];
    254225#endif
    255226  for ( UInt ui = 0; ui < pcCU->getSlice()->getMaxNumMergeCand(); ui++ )
     
    265236  pcSubCU->copyDVInfoFrom( pcCU, uiAbsPartIdx);
    266237#endif
    267 #if HHI_MOVE_SYN_K0052
     238#if H_3D
    268239  for ( UInt uiPartIdx = 0, uiSubPartIdx = uiAbsPartIdx; uiPartIdx < uiNumPU; uiPartIdx++, uiSubPartIdx += uiPUOffset )
    269240  {
     
    475446      decodeMergeIndex( pcCU, uiPartIdx, uiSubPartIdx, uiDepth );
    476447      UInt uiMergeIndex = pcCU->getMergeIndex(uiSubPartIdx);
    477 #if H_3D_ARP
    478       decodeARPW  ( pcCU, uiAbsPartIdx, uiDepth );
    479 #endif
    480 #if H_3D_IC
    481       decodeICFlag( pcCU, uiAbsPartIdx, uiDepth );
    482 #endif
    483 #if H_3D_DBBP
    484       if ( pcCU->getSlice()->getPPS()->getLog2ParallelMergeLevelMinus2() && ePartSize != SIZE_2Nx2N && pcSubCU->getWidth( 0 ) <= 8 && pcCU->getDBBPFlag(uiAbsPartIdx) == false )
    485 #else
    486448      if ( pcCU->getSlice()->getPPS()->getLog2ParallelMergeLevelMinus2() && ePartSize != SIZE_2Nx2N && pcSubCU->getWidth( 0 ) <= 8 )
    487 #endif
    488449      {
    489450        pcSubCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uiDepth );
    490451        if ( !isMerged )
    491452        {
    492 #if H_3D_VSP
    493           Int vspFlag[MRG_MAX_NUM_CANDS_MEM];
    494           memset(vspFlag, 0, sizeof(Int)*MRG_MAX_NUM_CANDS_MEM);
    495 #if H_3D_SPIVMP
    496           memset(bSPIVMPFlag, false, sizeof(Bool)*MRG_MAX_NUM_CANDS_MEM);
    497 #endif
    498           pcSubCU->initAvailableFlags();
    499           pcSubCU->getInterMergeCandidates( 0, 0, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand);
    500           pcSubCU->xGetInterMergeCandidates( 0, 0, cMvFieldNeighbours, uhInterDirNeighbours
    501 #if H_3D_SPIVMP
    502             , pcMvFieldSP, puhInterDirSP
    503 #endif
    504             , numValidMergeCand );
    505           pcSubCU->buildMCL( cMvFieldNeighbours, uhInterDirNeighbours, vspFlag
    506 #if H_3D_SPIVMP
    507             , bSPIVMPFlag
    508 #endif
    509             , numValidMergeCand );
    510           pcCU->setVSPFlagSubParts( vspFlag[uiMergeIndex], uiSubPartIdx, uiPartIdx, uiDepth );
    511 
    512 #else
    513 #if H_3D
    514           pcSubCU->initAvailableFlags();
    515           pcSubCU->getInterMergeCandidates( 0, 0, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand);
    516           pcSubCU->xGetInterMergeCandidates( 0, 0, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
    517 
    518 #else
    519453          pcSubCU->getInterMergeCandidates( 0, 0, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
    520 #endif
    521 #endif
    522454          isMerged = true;
    523455        }
     
    527459      {
    528460        uiMergeIndex = pcCU->getMergeIndex(uiSubPartIdx);
    529 #if H_3D_VSP
    530         Int vspFlag[MRG_MAX_NUM_CANDS_MEM];
    531         memset(vspFlag, 0, sizeof(Int)*MRG_MAX_NUM_CANDS_MEM);
    532 #if H_3D_SPIVMP
    533         memset(bSPIVMPFlag, false, sizeof(Bool)*MRG_MAX_NUM_CANDS_MEM);
    534 #endif
    535         pcSubCU->initAvailableFlags();
    536461        pcSubCU->getInterMergeCandidates( uiSubPartIdx-uiAbsPartIdx, uiPartIdx, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, uiMergeIndex );
    537         pcSubCU->xGetInterMergeCandidates( uiSubPartIdx-uiAbsPartIdx, uiPartIdx, cMvFieldNeighbours, uhInterDirNeighbours
    538 #if H_3D_SPIVMP
    539           , pcMvFieldSP, puhInterDirSP
    540 #endif
    541           ,numValidMergeCand, uiMergeIndex );
    542         pcSubCU->buildMCL( cMvFieldNeighbours, uhInterDirNeighbours, vspFlag
    543 #if H_3D_SPIVMP
    544           , bSPIVMPFlag
    545 #endif
    546           ,numValidMergeCand );
    547         pcCU->setVSPFlagSubParts( vspFlag[uiMergeIndex], uiSubPartIdx, uiPartIdx, uiDepth );
    548 #else
    549 #if H_3D
    550         pcSubCU->initAvailableFlags();
    551         pcSubCU->getInterMergeCandidates( uiSubPartIdx-uiAbsPartIdx, uiPartIdx, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, uiMergeIndex );
    552         pcSubCU->xGetInterMergeCandidates( uiSubPartIdx-uiAbsPartIdx, uiPartIdx, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, uiMergeIndex );
    553 #else
    554         pcSubCU->getInterMergeCandidates( uiSubPartIdx-uiAbsPartIdx, uiPartIdx, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, uiMergeIndex );
    555 #endif
    556 #endif
    557462      }
    558463      pcCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeIndex], uiSubPartIdx, uiPartIdx, uiDepth );
     
    567472          pcCU->getCUMvField( RefPicList( uiRefListIdx ) )->setAllMvd( cTmpMv, ePartSize, uiSubPartIdx, uiDepth, uiPartIdx );
    568473          pcCU->getCUMvField( RefPicList( uiRefListIdx ) )->setAllMvField( cMvFieldNeighbours[ 2*uiMergeIndex + uiRefListIdx ], ePartSize, uiSubPartIdx, uiDepth, uiPartIdx );
    569 #if H_3D_VSP
    570 #if H_3D_DBBP
    571           if( pcCU->getVSPFlag( uiSubPartIdx ) != 0 && !pcCU->getDBBPFlag( uiAbsPartIdx ) )
    572 #else
    573           if( pcCU->getVSPFlag( uiSubPartIdx ) != 0 )
    574 #endif
    575           {
    576             if ( uhInterDirNeighbours[ uiMergeIndex ] & (1<<uiRefListIdx) )
    577             {
    578               UInt dummy;
    579               Int vspSize;
    580               Int width, height;
    581               pcCU->getPartIndexAndSize( uiPartIdx, dummy, width, height, uiSubPartIdx, pcCU->getTotalNumPart()==256 );
    582               pcCU->setMvFieldPUForVSP( pcCU, uiSubPartIdx, width, height, RefPicList( uiRefListIdx ), cMvFieldNeighbours[ 2*uiMergeIndex + uiRefListIdx ].getRefIdx(), vspSize );
    583               pcCU->setVSPFlag( uiSubPartIdx, vspSize );
    584             }
    585           }
    586 #endif
    587         }
    588       }
    589 #if H_3D_SPIVMP
    590       pcCU->setSPIVMPFlagSubParts(bSPIVMPFlag[uiMergeIndex], uiSubPartIdx, uiPartIdx, uiDepth ); 
    591       if (bSPIVMPFlag[uiMergeIndex] != 0)
    592       {
    593         Int iWidth, iHeight;
    594         UInt uiIdx;
    595         pcCU->getPartIndexAndSize( uiPartIdx, uiIdx, iWidth, iHeight, uiSubPartIdx, true );
    596 
    597         UInt uiSPAddr;
    598 
    599         Int iNumSPInOneLine, iNumSP, iSPWidth, iSPHeight;
    600 
    601         pcCU->getSPPara(iWidth, iHeight, iNumSP, iNumSPInOneLine, iSPWidth, iSPHeight);
    602 
    603         for (Int iPartitionIdx = 0; iPartitionIdx < iNumSP; iPartitionIdx++)
    604         {
    605           pcCU->getSPAbsPartIdx(uiSubPartIdx, iSPWidth, iSPHeight, iPartitionIdx, iNumSPInOneLine, uiSPAddr);
    606           pcCU->setInterDirSP(puhInterDirSP[iPartitionIdx], uiSPAddr, iSPWidth, iSPHeight);
    607           pcCU->getCUMvField( REF_PIC_LIST_0 )->setMvFieldSP(pcCU, uiSPAddr, pcMvFieldSP[2*iPartitionIdx], iSPWidth, iSPHeight);
    608           pcCU->getCUMvField( REF_PIC_LIST_1 )->setMvFieldSP(pcCU, uiSPAddr, pcMvFieldSP[2*iPartitionIdx + 1], iSPWidth, iSPHeight);
    609         }
    610       }
    611 #endif
     474        }
     475      }
    612476    }
    613477    else
     
    623487        }
    624488      }
    625 #if H_3D_ARP
    626       decodeARPW  ( pcCU, uiAbsPartIdx, uiDepth );
    627 #endif
    628 #if H_3D_IC
    629       decodeICFlag( pcCU, uiAbsPartIdx, uiDepth );
    630 #endif
    631489    }
    632490    if ( (pcCU->getInterDir(uiSubPartIdx) == 3) && pcSubCU->isBipredRestriction(uiPartIdx) )
     
    706564}
    707565
    708 #if HHI_MOVE_SYN_K0052
     566#if H_3D
    709567Void TDecEntropy::decodeMVPIdxPU( TComDataCU* pcSubCU, UInt uiPartAddr, UInt uiDepth, UInt uiPartIdx, RefPicList eRefList )
    710568{
     
    753611  pcSubCU->getCUMvField( eRefList )->setAllMv(cMv, ePartSize, uiPartAddr, 0, uiPartIdx);
    754612}
    755 
    756613#else
    757614Void TDecEntropy::decodeMVPIdxPU( TComDataCU* pcSubCU, UInt uiPartAddr, UInt uiDepth, UInt uiPartIdx, RefPicList eRefList )
     
    798655}
    799656#endif
     657
    800658Void TDecEntropy::xDecodeTransform( TComDataCU* pcCU, UInt offsetLuma, UInt offsetChroma, UInt uiAbsPartIdx, UInt uiDepth, UInt width, UInt height, UInt uiTrIdx, Bool& bCodeDQP, Int quadtreeTULog2MinSizeInCU)
    801659{
     
    869727      if (pcCU->getSlice()->getSPS()->getChromaFormatIdc() != 0 )     
    870728      {
    871       if( bFirstCbfOfCU || pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth - 1 ) )
    872       {
    873         m_pcEntropyDecoderIf->parseQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth, uiDepth );
    874       }
    875       if( bFirstCbfOfCU || pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth - 1 ) )
    876       {
    877         m_pcEntropyDecoderIf->parseQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth, uiDepth );
    878       }
    879     }
    880     else
    881     {
     729        if( bFirstCbfOfCU || pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth - 1 ) )
     730        {
     731          m_pcEntropyDecoderIf->parseQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth, uiDepth );
     732        }
     733        if( bFirstCbfOfCU || pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth - 1 ) )
     734        {
     735          m_pcEntropyDecoderIf->parseQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth, uiDepth );
     736        }
     737      }
     738      else
     739      {
    882740        if( bFirstCbfOfCU || pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth - 1 ) )
    883741        {
     
    1131989{
    1132990  pcCU->setSDCFlagSubParts( false, uiAbsPartIdx, uiDepth );
    1133 #if HHI_MOVE_SYN_K0052
    1134991  if ( pcCU->isSkipped( uiAbsPartIdx ) )
    1135992  {
    1136993    return;
    1137994  }
    1138 #endif
    1139995
    1140996
     
    11571013Void TDecEntropy::decodeDBBPFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    11581014{
    1159 #if HHI_MOVE_SYN_K0052
    11601015  if( pcCU->getSlice()->getDepthBasedBlkPartFlag() && (pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2NxN || pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_Nx2N) && pcCU->getWidth(uiAbsPartIdx) > 8 && pcCU->getSlice()->getDefaultRefViewIdxAvailableFlag() )
    11611016  {
    1162 #endif
    11631017    m_pcEntropyDecoderIf->parseDBBPFlag( pcCU, uiAbsPartIdx, uiDepth );
    1164 #if HHI_MOVE_SYN_K0052
    1165   }
    1166 #endif
     1018  }
    11671019}
    11681020#endif
  • trunk/source/Lib/TLibDecoder/TDecEntropy.h

    r1179 r1196  
    8585public:
    8686  virtual Void parseSkipFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
    87 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     87#if H_3D
    8888  virtual Void parseDIS           ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
    89 #else
    90 #if H_3D_SINGLE_DEPTH
    91   virtual Void parseSingleDepthMode       ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
    92 #endif
    9389#endif
    9490  virtual Void parseCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
     
    152148  Void decodeMvdPU        ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPartIdx, RefPicList eRefList );
    153149  Void decodeMVPIdxPU     ( TComDataCU* pcSubCU, UInt uiPartAddr, UInt uiDepth, UInt uiPartIdx, RefPicList eRefList );
    154 #if HHI_MOVE_SYN_K0052
    155   Void decodeMvsAMVP       ( TComDataCU* pcSubCU, UInt uiPartAddr, UInt uiDepth, UInt uiPartIdx, RefPicList eRefList );
    156 #endif 
     150#if H_3D
     151  Void decodeMvsAMVP       ( TComDataCU* pcSubCU, UInt uiPartAddr, UInt uiDepth, UInt uiPartIdx,
     152RefPicList eRefList );
     153#endif
    157154  Void    setEntropyDecoder           ( TDecEntropyIf* p );
    158155  Void    setBitstream                ( TComInputBitstream* p ) { m_pcEntropyDecoderIf->setBitstream(p);                    }
     
    177174  Void decodeSplitFlag         ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    178175  Void decodeSkipFlag          ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    179 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     176#if H_3D
    180177  Void decodeDIS               ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) ;
    181 #else
    182 #if H_3D_SINGLE_DEPTH
    183   Void decodeSingleDepthMode ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) ;
    184 #endif
    185178#endif
    186179  Void decodeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
  • trunk/source/Lib/TLibDecoder/TDecGop.h

    r1179 r1196  
    6363// Class definition
    6464// ====================================================================================================================
    65 #if H_3D_ANNEX_SELECTION_FIX
     65#if H_3D
    6666class TDecTop;
    6767#endif
     
    8383  TDecSlice*            m_pcSliceDecoder;
    8484  TComLoopFilter*       m_pcLoopFilter;
    85 #if H_3D_ANNEX_SELECTION_FIX
     85#if H_3D
    8686  TDecTop*              m_decTop;
    8787#endif
  • trunk/source/Lib/TLibDecoder/TDecSbac.cpp

    r1179 r1196  
    5252, m_cCUSplitFlagSCModel       ( 1,             1,               NUM_SPLIT_FLAG_CTX            , m_contextModels + m_numContextModels, m_numContextModels )
    5353, m_cCUSkipFlagSCModel        ( 1,             1,               NUM_SKIP_FLAG_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
    54 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     54#if H_3D
    5555, m_cCUDISFlagSCModel         ( 1,             1,               NUM_DIS_FLAG_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
    5656, m_cCUDISTypeSCModel         ( 1,             1,               NUM_DIS_TYPE_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
    57 #else
    58 #if H_3D_SINGLE_DEPTH
    59 , m_cCUSingleDepthFlagSCModel        ( 1,             1,               NUM_SINGLEDEPTH_FLAG_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
    60 , m_cSingleDepthValueSCModel         ( 1,             1,               NUM_SINGLE_DEPTH_VALUE_DATA_CTX      , m_contextModels + m_numContextModels, m_numContextModels)
    61 #endif
    6257#endif
    6358, m_cCUMergeFlagExtSCModel    ( 1,             1,               NUM_MERGE_FLAG_EXT_CTX        , m_contextModels + m_numContextModels, m_numContextModels)
     
    141136  m_cCUSplitFlagSCModel.initBuffer       ( sliceType, qp, (UChar*)INIT_SPLIT_FLAG );
    142137  m_cCUSkipFlagSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_SKIP_FLAG );
    143 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     138#if H_3D
    144139  m_cCUDISFlagSCModel.initBuffer         ( sliceType, qp, (UChar*)INIT_DIS_FLAG );
    145140  m_cCUDISTypeSCModel.initBuffer         ( sliceType, qp, (UChar*)INIT_DIS_TYPE );
    146 #else
    147 #if H_3D_SINGLE_DEPTH
    148   m_cCUSingleDepthFlagSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_SINGLEDEPTH_FLAG );
    149   m_cSingleDepthValueSCModel.initBuffer         ( sliceType, qp, (UChar*)INIT_SINGLE_DEPTH_VALUE_DATA );
    150 #endif
    151141#endif
    152142  m_cCUMergeFlagExtSCModel.initBuffer    ( sliceType, qp, (UChar*)INIT_MERGE_FLAG_EXT );
     
    217207  m_cCUSplitFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_SPLIT_FLAG );
    218208  m_cCUSkipFlagSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
    219 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     209#if H_3D
    220210  m_cCUDISFlagSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DIS_FLAG );
    221211  m_cCUDISTypeSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DIS_TYPE );
    222 #else
    223 #if H_3D_SINGLE_DEPTH
    224   m_cCUSingleDepthFlagSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SINGLEDEPTH_FLAG );
    225   m_cSingleDepthValueSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_SINGLE_DEPTH_VALUE_DATA );
    226 #endif
    227212#endif
    228213  m_cCUMergeFlagExtSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT );
     
    461446  UInt uiSymbol;
    462447
    463     m_pcTDecBinIf->decodeBinTrm(uiSymbol);
     448  m_pcTDecBinIf->decodeBinTrm(uiSymbol);
    464449
    465450#if H_MV_ENC_DEC_TRAC
    466       DTRACE_CU("pcm_flag", uiSymbol)
    467 #endif
    468     if (uiSymbol)
    469     {
     451  DTRACE_CU("pcm_flag", uiSymbol)
     452#endif
     453  if (uiSymbol)
     454  {
    470455    Bool bIpcmFlag = true;
    471456
     
    500485      piPCMSample += uiWidth;
    501486    }
    502 
    503 
    504487#if H_3D_DISABLE_CHROMA
    505488    if( pcCU->getSlice()->getSPS()->getChromaFormatIdc() != 0 )
    506489    {   
    507490#endif
    508     piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
    509     uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
    510     uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
    511     uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
    512 
    513     for(uiY = 0; uiY < uiHeight; uiY++)
    514     {
    515       for(uiX = 0; uiX < uiWidth; uiX++)
    516       {
    517         UInt uiSample;
    518         m_pcTDecBinIf->xReadPCMCode(uiSampleBits, uiSample);
    519         piPCMSample[uiX] = uiSample;
    520       }
    521       piPCMSample += uiWidth;
    522     }
    523 
    524     piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
    525     uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
    526     uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
    527     uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
    528 
    529     for(uiY = 0; uiY < uiHeight; uiY++)
    530     {
    531       for(uiX = 0; uiX < uiWidth; uiX++)
    532       {
    533         UInt uiSample;
    534         m_pcTDecBinIf->xReadPCMCode(uiSampleBits, uiSample);
    535         piPCMSample[uiX] = uiSample;
    536       }
    537       piPCMSample += uiWidth;
    538     }
     491      piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
     492      uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
     493      uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
     494      uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
     495
     496      for(uiY = 0; uiY < uiHeight; uiY++)
     497      {
     498        for(uiX = 0; uiX < uiWidth; uiX++)
     499        {
     500          UInt uiSample;
     501          m_pcTDecBinIf->xReadPCMCode(uiSampleBits, uiSample);
     502          piPCMSample[uiX] = uiSample;
     503        }
     504        piPCMSample += uiWidth;
     505      }
     506
     507      piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
     508      uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
     509      uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
     510      uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
     511
     512      for(uiY = 0; uiY < uiHeight; uiY++)
     513      {
     514        for(uiX = 0; uiX < uiWidth; uiX++)
     515        {
     516          UInt uiSample;
     517          m_pcTDecBinIf->xReadPCMCode(uiSampleBits, uiSample);
     518          piPCMSample[uiX] = uiSample;
     519        }
     520        piPCMSample += uiWidth;
     521      }
    539522#if H_3D_DISABLE_CHROMA
    540523    }
    541524#endif
    542 
    543 
    544525    m_pcTDecBinIf->start();
    545526  }
     
    594575#endif
    595576}
    596 
    597 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     577#if H_3D
    598578Void TDecSbac::parseDIS( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    599579{
     
    639619  }
    640620}
    641 #else
    642 #if H_3D_SINGLE_DEPTH
    643 Void TDecSbac::parseSingleDepthMode( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    644 {
    645   pcCU->setSingleDepthFlagSubParts( false,        uiAbsPartIdx, uiDepth );
    646   UInt uiSymbol = 0;
    647   m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUSingleDepthFlagSCModel.get( 0, 0, 0 ) );
    648   if( uiSymbol )
    649   {
    650     pcCU->setSingleDepthFlagSubParts( true,        uiAbsPartIdx, uiDepth );
    651     pcCU->setSkipFlagSubParts( false,        uiAbsPartIdx, uiDepth );
    652     pcCU->setSDCFlagSubParts( false,        uiAbsPartIdx, uiDepth );
    653     pcCU->setPredModeSubParts( MODE_INTRA,  uiAbsPartIdx, uiDepth );
    654     pcCU->setPartSizeSubParts( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
    655     pcCU->setLumaIntraDirSubParts (DC_IDX, uiAbsPartIdx, uiDepth );
    656     pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
    657     pcCU->setMergeFlagSubParts( false , uiAbsPartIdx, 0, uiDepth );
    658     pcCU->setTrIdxSubParts(0, uiAbsPartIdx, uiDepth);
    659     pcCU->setCbfSubParts(0, 1, 1, uiAbsPartIdx, uiDepth);
    660 
    661     UInt absValDeltaDC = 0;
    662 
    663     UInt uiUnaryIdx = 0;
    664     UInt uiNumCand = SINGLE_DEPTH_MODE_CAND_LIST_SIZE;
    665     if ( uiNumCand > 1 )
    666     {
    667       for( ; uiUnaryIdx < uiNumCand - 1; ++uiUnaryIdx )
    668       {
    669         UInt uiSymbol2 = 0;
    670         if ( uiUnaryIdx==0 )
    671         {
    672           m_pcTDecBinIf->decodeBin( uiSymbol2, m_cSingleDepthValueSCModel.get( 0, 0, 0 ) );
    673         }
    674         else
    675         {
    676           m_pcTDecBinIf->decodeBinEP( uiSymbol2);
    677         }
    678         if( uiSymbol2 == 0 )
    679         {
    680           break;
    681         }
    682       }
    683     }
    684     absValDeltaDC = uiUnaryIdx;
    685     pcCU->setSingleDepthValueSubParts((Pel)absValDeltaDC,uiAbsPartIdx, 0, uiDepth);
    686   }
    687 }
    688 #endif
    689 #endif
    690 
     621#endif
    691622/** parse merge flag
    692623 * \param pcCU
     
    772703#if H_3D_QTLPC
    773704  Bool bParseSplitFlag    = true;
    774 
    775  
    776705  Bool    bLimQtPredFlag = pcCU->getPic()->getSlice(0)->getQtPredFlag();
    777706  TComPic *pcTexture      = pcCU->getSlice()->getTexturePic();
     
    810739#endif
    811740  pcCU->setDepthSubParts( uiDepth + uiSymbol, uiAbsPartIdx );
    812  
     741
    813742  return;
    814743}
     
    827756#if H_3D_QTLPC
    828757  Bool bParsePartSize    = true;
    829  
     758
    830759  Bool    bLimQtPredFlag = pcCU->getPic()->getSlice(0)->getQtPredFlag();
    831760  TComPic *pcTexture     = pcCU->getSlice()->getTexturePic();
     
    859788#endif
    860789
    861  
     790
    862791  if ( pcCU->isIntra( uiAbsPartIdx ) )
    863792  {
     
    866795    {
    867796#endif
    868      uiSymbol = 1;
     797      uiSymbol = 1;
    869798      if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    870799      {
     
    899828      {
    900829#endif
    901       UInt uiMaxNumBits = 2;
    902       if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( (g_uiMaxCUWidth>>uiDepth) == 8 && (g_uiMaxCUHeight>>uiDepth) == 8 ) )
    903       {
    904         uiMaxNumBits ++;
    905       }
    906       for ( UInt ui = 0; ui < uiMaxNumBits; ui++ )
    907       {
    908         m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, ui) );
    909         if ( uiSymbol )
    910         {
    911           break;
    912         }
    913         uiMode++;
    914       }
    915       eMode = (PartSize) uiMode;
    916       if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
    917       {
    918         if (eMode == SIZE_2NxN)
    919         {
    920         m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
    921           if (uiSymbol == 0)
     830        UInt uiMaxNumBits = 2;
     831        if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( (g_uiMaxCUWidth>>uiDepth) == 8 && (g_uiMaxCUHeight>>uiDepth) == 8 ) )
     832        {
     833          uiMaxNumBits ++;
     834        }
     835        for ( UInt ui = 0; ui < uiMaxNumBits; ui++ )
     836        {
     837          m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, ui) );
     838          if ( uiSymbol )
    922839          {
    923             m_pcTDecBinIf->decodeBinEP(uiSymbol);
    924             eMode = (uiSymbol == 0? SIZE_2NxnU : SIZE_2NxnD);
     840            break;
    925841          }
    926         }
    927         else if (eMode == SIZE_Nx2N)
    928         {
    929         m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
    930           if (uiSymbol == 0)
     842          uiMode++;
     843        }
     844        eMode = (PartSize) uiMode;
     845        if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
     846        {
     847          if (eMode == SIZE_2NxN)
    931848          {
    932             m_pcTDecBinIf->decodeBinEP(uiSymbol);
    933             eMode = (uiSymbol == 0? SIZE_nLx2N : SIZE_nRx2N);
     849            m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
     850            if (uiSymbol == 0)
     851            {
     852              m_pcTDecBinIf->decodeBinEP(uiSymbol);
     853              eMode = (uiSymbol == 0? SIZE_2NxnU : SIZE_2NxnD);
     854            }
    934855          }
    935         }
    936       }
     856          else if (eMode == SIZE_Nx2N)
     857          {
     858            m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
     859            if (uiSymbol == 0)
     860            {
     861              m_pcTDecBinIf->decodeBinEP(uiSymbol);
     862              eMode = (uiSymbol == 0? SIZE_nLx2N : SIZE_nRx2N);
     863            }
     864          }
     865        }
    937866#if H_3D_QTLPC
    938867      }
     
    1060989    {
    1061990#endif
    1062     m_pcTDecBinIf->decodeBin( symbol, m_cCUIntraPredSCModel.get( 0, 0, 0) );
    1063     mpmPred[j] = symbol;
     991      m_pcTDecBinIf->decodeBin( symbol, m_cCUIntraPredSCModel.get( 0, 0, 0) );
     992      mpmPred[j] = symbol;
    1064993#if H_MV_ENC_DEC_TRAC         
    1065     DTRACE_CU("prev_intra_luma_pred_flag", symbol)
     994      DTRACE_CU("prev_intra_luma_pred_flag", symbol)
    1066995#endif
    1067996#if H_3D_DIM
     
    10751004    {
    10761005#endif
    1077     Int preds[3] = {-1, -1, -1};
    1078     Int predNum = pcCU->getIntraDirLumaPredictor(absPartIdx+partOffset*j, preds); 
    1079     if (mpmPred[j])
    1080     {
    1081       m_pcTDecBinIf->decodeBinEP( symbol );
    1082       if (symbol)
     1006      Int preds[3] = {-1, -1, -1};
     1007      Int predNum = pcCU->getIntraDirLumaPredictor(absPartIdx+partOffset*j, preds); 
     1008      if (mpmPred[j])
    10831009      {
    10841010        m_pcTDecBinIf->decodeBinEP( symbol );
    1085         symbol++;
    1086       }
     1011        if (symbol)
     1012        {
     1013          m_pcTDecBinIf->decodeBinEP( symbol );
     1014          symbol++;
     1015        }
    10871016#if H_MV_ENC_DEC_TRAC         
    1088       DTRACE_CU("mpm_idx", symbol)
    1089 #endif
    1090       intraPredMode = preds[symbol];
    1091     }
    1092     else
    1093     {
    1094       m_pcTDecBinIf->decodeBinsEP( symbol, 5 );
    1095       intraPredMode = symbol;
     1017        DTRACE_CU("mpm_idx", symbol)
     1018#endif
     1019          intraPredMode = preds[symbol];
     1020      }
     1021      else
     1022      {
     1023        m_pcTDecBinIf->decodeBinsEP( symbol, 5 );
     1024        intraPredMode = symbol;
    10961025#if H_MV_ENC_DEC_TRAC         
    1097       DTRACE_CU("rem_intra_luma_pred_mode", symbol)
     1026        DTRACE_CU("rem_intra_luma_pred_mode", symbol)
    10981027#endif       
    1099       //postponed sorting of MPMs (only in remaining branch)
    1100       if (preds[0] > preds[1])
    1101       {
    1102         std::swap(preds[0], preds[1]);
    1103       }
    1104