Changeset 1185 in 3DVCSoftware


Ignore:
Timestamp:
7 Apr 2015, 21:52:03 (9 years ago)
Author:
tech
Message:

Clean up. Part I.

Location:
branches/HTM-14.0-dev0/source
Files:
46 edited

Legend:

Unmodified
Added
Removed
  • branches/HTM-14.0-dev0/source/App/TAppDecoder/TAppDecTop.cpp

    r1179 r1185  
    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
  • branches/HTM-14.0-dev0/source/App/TAppEncoder/TAppEncCfg.cpp

    r1179 r1185  
    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
  • branches/HTM-14.0-dev0/source/App/TAppEncoder/TAppEncCfg.h

    r1179 r1185  
    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
  • branches/HTM-14.0-dev0/source/App/TAppEncoder/TAppEncTop.cpp

    r1179 r1185  
    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
  • branches/HTM-14.0-dev0/source/App/TAppEncoder/TAppEncTop.h

    r1179 r1185  
    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 );
  • branches/HTM-14.0-dev0/source/Lib/TAppCommon/TAppComCamPara.cpp

    r1179 r1185  
    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
  • branches/HTM-14.0-dev0/source/Lib/TAppCommon/TAppComCamPara.h

    r1179 r1185  
    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;          }
  • branches/HTM-14.0-dev0/source/Lib/TLibCommon/ContextTables.h

    r1179 r1185  
    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
    5453#define NUM_DIS_FLAG_CTX              1
    5554#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
    61 #endif
    6255#define NUM_MERGE_FLAG_EXT_CTX        1       ///< number of context models for merge flag of merge extended
    6356#define NUM_MERGE_IDX_EXT_CTX         1       ///< number of context models for merge index of merge extended
     
    158151  { CNU,  CNU,  CNU, },
    159152};
    160 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     153#if H_3D
    161154static const UChar
    162155INIT_DIS_FLAG[3][NUM_DIS_FLAG_CTX] = 
     
    173166    { 137 },
    174167};
    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
    192168#endif
    193169static const UChar
  • branches/HTM-14.0-dev0/source/Lib/TLibCommon/TComDataCU.cpp

    r1179 r1185  
    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;
     
    186181
    187182    m_skipFlag           = new Bool[ uiNumPartition ];
    188 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     183#if H_3D
    189184    m_bDISFlag           = new Bool[ uiNumPartition ];
    190185    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
    196186#endif
    197187    m_pePartSize         = new Char[ uiNumPartition ];
     
    337327
    338328    if ( m_skipFlag           ) { delete[] m_skipFlag;          m_skipFlag          = NULL; }
    339 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     329#if H_3D
    340330    if ( m_bDISFlag           ) { delete[] m_bDISFlag;   m_bDISFlag     = NULL; }
    341331    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
    347332#endif
    348333    if ( m_pePartSize         ) { delete[] m_pePartSize;        m_pePartSize        = NULL; }
     
    506491    TComDataCU * pcFrom = pcPic->getCU(getAddr());
    507492    m_skipFlag[ui]   = pcFrom->getSkipFlag(ui);
    508 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     493#if H_3D
    509494    m_bDISFlag[ui]   = pcFrom->getDISFlag(ui);
    510495    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
    516496#endif
    517497    m_pePartSize[ui] = pcFrom->getPartitionSize(ui);
     
    566546  {
    567547    memset( m_skipFlag          + firstElement, false,                    numElements * sizeof( *m_skipFlag ) );
    568 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     548#if H_3D
    569549    memset( m_bDISFlag          + firstElement, false,                    numElements * sizeof( *m_bDISFlag ) );
    570550    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
    576551#endif
    577552    memset( m_pePartSize        + firstElement, SIZE_NONE,                numElements * sizeof( *m_pePartSize ) );
     
    758733      m_puhTransformSkip[2][ui] = 0;
    759734      m_skipFlag[ui]   = false;
    760 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     735#if H_3D
    761736      m_bDISFlag[ui]   = false;
    762737      m_uiDISType[ui]  = 0;
    763 #else
    764 #if H_3D_SINGLE_DEPTH
    765       m_singleDepthFlag[ui]     = false;
    766       m_apSingleDepthValue[ui]  = 0;
    767 #endif
    768738#endif
    769739      m_pePartSize[ui] = SIZE_NONE;
     
    891861  memset( m_puhCbf[2],          0, iSizeInUchar );
    892862  memset( m_puhDepth,     uiDepth, iSizeInUchar );
    893 #if H_3D_NBDV && !SEC_ARP_REM_ENC_RESTRICT_K0035
    894   m_pDvInfo->bDV = false;
    895 #endif
    896863#if H_3D_ARP
    897864  memset( m_puhARPW,            0, iSizeInUchar  );
     
    934901  {
    935902    m_skipFlag[ui]   = false;
    936 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     903#if H_3D
    937904    m_bDISFlag[ui]   = false;
    938905    m_uiDISType[ui]  = 0;
    939 #else
    940 #if H_3D_SINGLE_DEPTH
    941     m_singleDepthFlag[ui]   = false;
    942     m_apSingleDepthValue[ui]= 0;
    943 #endif
    944906#endif
    945907    m_pePartSize[ui] = SIZE_NONE;
     
    964926      m_puhTransformSkip[2][ui] = pcCU->getTransformSkip(uiPartOffset+ui,TEXT_CHROMA_V);
    965927      m_skipFlag[ui]   = pcCU->getSkipFlag(uiPartOffset+ui);
    966 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     928#if H_3D
    967929      m_bDISFlag[ui]    = pcCU->getDISFlag(uiPartOffset+ui);
    968930      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
    974931#endif
    975932      m_pePartSize[ui] = pcCU->getPartitionSize(uiPartOffset+ui);
     
    11181075 
    11191076  m_skipFlag=pcCU->getSkipFlag()          + uiPart;
    1120 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     1077#if H_3D
    11211078  m_bDISFlag     = pcCU->getDISFlag()     + uiPart;
    11221079  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
    11281080#endif
    11291081  m_phQP=pcCU->getQP()                    + uiPart;
     
    12601212 
    12611213  m_skipFlag           = pcCU->getSkipFlag ()             + uiAbsPartIdx;
    1262 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     1214#if H_3D
    12631215  m_bDISFlag           = pcCU->getDISFlag ()              + uiAbsPartIdx;
    12641216  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
    12701217#endif
    12711218  m_pePartSize         = pcCU->getPartitionSize ()        + uiAbsPartIdx;
     
    13401287  Int sizeInChar  = sizeof( Char ) * uiNumPartition;
    13411288  memcpy( m_skipFlag   + uiOffset, pcCU->getSkipFlag(),       sizeof( *m_skipFlag )   * uiNumPartition );
    1342 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     1289#if H_3D
    13431290  memcpy( m_bDISFlag   + uiOffset, pcCU->getDISFlag(),       sizeof( *m_bDISFlag )   * uiNumPartition );
    13441291  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
    13501292#endif
    13511293  memcpy( m_phQP       + uiOffset, pcCU->getQP(),             sizeInChar                        );
     
    14651407
    14661408  memcpy( rpcCU->getSkipFlag() + m_uiAbsIdxInLCU, m_skipFlag, sizeof( *m_skipFlag ) * m_uiNumPartition );
    1467 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     1409#if H_3D
    14681410  memcpy( rpcCU->getDISFlag()  + m_uiAbsIdxInLCU, m_bDISFlag,    sizeof( *m_bDISFlag )  * m_uiNumPartition );
    14691411  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
    14751412#endif
    14761413  memcpy( rpcCU->getQP() + m_uiAbsIdxInLCU, m_phQP, sizeInChar  );
     
    15851522  Int sizeInChar  = sizeof( Char ) * uiQNumPart;
    15861523  memcpy( rpcCU->getSkipFlag()       + uiPartOffset, m_skipFlag,   sizeof( *m_skipFlag )   * uiQNumPart );
    1587 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     1524#if H_3D
    15881525  memcpy( rpcCU->getDISFlag()  + uiPartOffset, m_bDISFlag,    sizeof( *m_bDISFlag )   * uiQNumPart );
    15891526  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
    15951527#endif
    15961528  memcpy( rpcCU->getQP() + uiPartOffset, m_phQP, sizeInChar );
     
    23882320    Int iPictureHeight = depthPicYuv->getHeight();
    23892321   
    2390 #if !HS_DBBP_CLEAN_K0048
    2391     Int iWidth  = uiWidth;
    2392     Int iHeight = uiHeight;
    2393 #endif
    23942322   
    23952323    Bool depthRefineFlag = false;
     
    24042332    }
    24052333   
    2406 #if HS_DBBP_CLEAN_K0048
    24072334    Int depthPosX = Clip3(0,   iPictureWidth - 1,  iBlkX + ((cDv.getHor()+2)>>2));
    24082335    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
    24132336   
    24142337    pDepthPels = depthPicYuv->getLumaAddr() + depthPosX + depthPosY * uiDepthStride;
     
    25002423  memset( m_skipFlag + absPartIdx, skip, m_pcPic->getNumPartInCU() >> ( 2 * depth ) );
    25012424}
    2502 
    2503 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2425#if H_3D
    25042426Void TComDataCU::setDISFlagSubParts( Bool bDIS, UInt absPartIdx, UInt depth )
    25052427{
     
    25122434    setSubPartT( uiDISType, m_uiDISType, uiAbsPartIdx, uiDepth, uiPUIdx );
    25132435}
    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
    25272436#endif
    25282437
     
    41804089                  TComMv cMv = cTexMvField.getMv() + cMvRounding;
    41814090                  cMv >>=2;         
    4182 #if !(NTT_BUG_FIX_TK54)
    4183                   this->clipMv( cMv );
    4184 #endif
    41854091                  pcMvFieldSP[2*iPartition + uiCurrRefListId].setMvField(cMv, iValidDepRef);
    41864092                }
     
    41974103              }
    41984104            }
    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
    42094105
    42104106            iPartition ++;
     
    54225318}
    54235319
    5424 #if SONY_MV_V_CONST_C0078
     5320#if H_MV
    54255321Void TComDataCU::checkMV_V (TComMv&  rcMv,  RefPicList eRefPicList, int iRefIdx )
    54265322{
     
    57805676  }
    57815677
    5782   if ( bIsCurrRefLongTerm || bIsColRefLongTerm ) // CY: this condition equals to both bIsCurrRefLongTerm and bIsColRefLongTerm being 1
     5678  if ( bIsCurrRefLongTerm || bIsColRefLongTerm )
    57835679  {
    57845680#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
    57915681    Int iCurrViewId    = m_pcSlice->getViewId ();
    57925682    Int iCurrRefViewId = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getViewId ();
    57935683    Int iColViewId     = pColCU->getSlice()->getViewId();
    57945684    Int iColRefViewId  = pColCU->getSlice()->getRefPic( eColRefPicList, pColCU->getCUMvField(eColRefPicList)->getRefIdx(uiAbsPartAddr))->getViewId();
    5795 #endif
    5796 #if H_3D_TMVP_SCALING_FIX_K0053
    57975685    iScale = 4096;
    57985686    if ( iCurrRefViewId != iCurrViewId && iColViewId != iColRefViewId )
    5799 #endif
    58005687      iScale = xGetDistScaleFactor( iCurrViewId, iCurrRefViewId, iColViewId, iColRefViewId );
    5801 #if H_3D_TMVP_FIX_TICKET_97
    58025688    if ( bMRG && iScale != 4096 && m_pcSlice->getIvMvScalingFlag( ) )
    5803 #else
    5804     if ( iScale != 4096 && m_pcSlice->getIvMvScalingFlag( ) )
    5805 #endif
    58065689    {
    58075690      rcMv = cColMv.scaleMv( iScale );
     
    58155698#endif
    58165699  }
    5817   else // CY: both bIsCurrRefLongTerm and bIsColRefLongTerm are 0
     5700  else
    58185701  {
    58195702    iScale = xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iColPOC, iColRefPOC);
     
    59805863#endif
    59815864#if H_3D_IV_MERGE
    5982 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    59835865Void TComDataCU::getDispforDepth (UInt uiPartIdx, UInt uiPartAddr, DisInfo* pDisp)
    5984 #else
    5985 Bool TComDataCU::getDispforDepth (UInt uiPartIdx, UInt uiPartAddr, DisInfo* pDisp)
    5986 #endif
    59875866{
    59885867
     
    60005879      pDisp->m_acNBDV = cMv;
    60015880      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
     5881  }
     5882}
     5883#endif
     5884
     5885#if H_3D
    60135886Bool TComDataCU::getNeighDepth ( UInt uiPartIdx, UInt uiPartAddr, Pel* pNeighDepth, Int index )
    60145887{
    6015 #if NEIGHBORING_PIX_AVAILABILITY_FIX
    60165888  UInt  uiPartIdxLT, uiPartIdxRT;
    60175889  this->deriveLeftRightTopIdxAdi( uiPartIdxLT, uiPartIdxRT, 0, 0 );
     
    60665938
    60675939  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 
     5940}
     5941#endif
    61365942#if H_3D_NBDV
    61375943//Notes from QC:
     
    61395945//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
    61405946//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
    61425947Void TComDataCU::getDisMvpCandNBDV( DisInfo* pDInfo
    6143 #else
    6144 Bool TComDataCU::getDisMvpCandNBDV( DisInfo* pDInfo
    6145 #endif
    61465948#if H_3D_NBDV_REF
    61475949, Bool bDepthRefine
     
    61515953  //// ******* Init variables ******* /////
    61525954  // Init disparity struct for results
    6153 #if !SEC_ARP_REM_ENC_RESTRICT_K0035
    6154   pDInfo->bDV = false;   
    6155 #endif
    61565955  pDInfo->m_aVIdxCan = -1;
    61575956
     
    62176016      if( bCheck )
    62186017      {
    6219 #if !(NTT_BUG_FIX_TK54)
    6220         clipMv(cColMv);
    6221 #endif
    62226018        pDInfo->m_acNBDV = cColMv;
    62236019        pDInfo->m_aVIdxCan  = iTargetViewIdx;
     
    62396035#else
    62406036        picDepth = getSlice()->getIvPic( true, iTargetViewIdx );
    6241 #if !BUG_FIX_TK65
    6242         assert(picDepth != NULL);
    6243 #endif
    62446037#endif
    62456038        if (picDepth && bDepthRefine)
     
    62486041        pDInfo->m_acDoNBDV  = cColMv;
    62496042#endif //H_3D_NBDV_REF
    6250 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    62516043        return;
    6252 #else
    6253         return true;
    6254 #endif
    62556044      }
    62566045    }
     
    62696058#endif
    62706059    ) )
    6271 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    62726060    return;
    6273 #else
    6274     return true;
    6275 #endif
    62766061
    62776062  //// ******* Get disparity from above block ******* /////
     
    62856070#endif
    62866071      ) )
    6287 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    62886072      return;
    6289 #else
    6290       return true;
    6291 #endif
    62926073  }
    62936074
     
    63026083        {
    63036084          TComMv cDispVec = cIDVInfo.m_acMvCand[iList][ curPos ];
    6304 #if !(NTT_BUG_FIX_TK54)
    6305           clipMv( cDispVec );
    6306 #endif
    63076085          pDInfo->m_acNBDV = cDispVec;
    63086086          pDInfo->m_aVIdxCan = cIDVInfo.m_aVIdxCan[iList][ curPos ];
     
    63246102#else
    63256103          TComPic* picDepth = getSlice()->getIvPic( true, pDInfo->m_aVIdxCan );
    6326 #if !BUG_FIX_TK65
    6327           assert(picDepth!=NULL);
    6328 #endif
    63296104#endif
    63306105
     
    63356110          pDInfo->m_acDoNBDV = cDispVec;
    63366111#endif
    6337 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    63386112          return;
    6339 #else
    6340           return true;
    6341 #endif
    63426113        }
    63436114      }
     
    63756146      pDInfo->m_acDoNBDV = defaultDV;
    63766147#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
     6148  }
    63846149}
    63856150
     
    64236188    Pel iDisp = getMcpFromDM( pcBaseViewDepthPicYuv, cMvPred, iBlkX, iBlkY, iWidth, iHeight, aiShiftLUT );
    64246189    cMvPred->setHor( iDisp );
    6425 #if !(NTT_BUG_FIX_TK54)
    6426     clipMv(*cMvPred);
    6427 #endif
    64286190  }
    64296191}
     
    64516213        if (refViewIdx != m_pcSlice->getViewIndex())
    64526214        {
    6453 #if !(NTT_BUG_FIX_TK54)
    6454           clipMv(cMvPred);
    6455 #endif
    64566215          pNbDvInfo->m_acNBDV = cMvPred;
    64576216          pNbDvInfo->m_aVIdxCan = refViewIdx;
     
    64726231#else
    64736232          picDepth   = getSlice()->getIvPic (true, refViewIdx );
    6474 #if !BUG_FIX_TK65
    6475           assert(picDepth != NULL);
    6476 #endif
    64776233#endif
    64786234          UInt uiPartIdx = 0;   //Notes from MTK: Please confirm that using 0 as partition index and partition address is correct for CU-level DoNBDV
     
    68706626#endif
    68716627#endif
    6872 #if !(NTT_BUG_FIX_TK54)
    6873                       clipMv( cMv );
    6874 #endif
    68756628                      paiPdmRefIdx  [ uiCurrRefListId ] = iPdmRefIdx;
    68766629                      pacPdmMv      [ uiCurrRefListId ] = cMv;
     
    69316684                            }
    69326685
    6933 #if !(NTT_BUG_FIX_TK54)
    6934                             clipMv( cMv );
    6935 #endif
    69366686                            bLoop_stop = true;
    69376687
     
    69546704
    69556705              }
    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
    69666706              iPartition ++;
    69676707            }
     
    69966736      Int         iBaseAbsPartIdx;
    69976737
    6998 #if SEC_SHIFTED_IVMC_POS_K0036
    69996738      Int offsetW = (iLoopCan == 0) ? 0 : ( iWidth  * 2 );
    70006739      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
    70056740
    70066741      Int         iBasePosX   = Clip3( 0, pcBaseRec->getWidth () - 1, iCurrPosX + ( (cDv.getHor() + offsetW + 2 ) >> 2 ) );
     
    70486783#endif
    70496784#endif
    7050 #if !(NTT_BUG_FIX_TK54)
    7051                     clipMv( cMv );
    7052 #endif
    70536785                    paiPdmRefIdx  [ (uiCurrRefListId + (iLoopCan<<2)) ] = iPdmRefIdx;
    70546786                    pacPdmMv      [ (uiCurrRefListId + (iLoopCan<<2)) ] = cMv;
     
    71046836#endif
    71056837            cMv.setVer( 0 );
    7106 #if !(NTT_BUG_FIX_TK54)
    7107             clipMv( cMv );
    7108 #endif
    71096838            pacPdmMv      [iRefListId + 2 + (iLoopCan<<2)] = cMv;
    71106839          }
  • branches/HTM-14.0-dev0/source/Lib/TLibCommon/TComDataCU.h

    r1179 r1185  
    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
     
    350345  Void         setSkipFlag           ( UInt idx, Bool skip)     { m_skipFlag[idx] = skip;   }
    351346  Void         setSkipFlagSubParts   ( Bool skip, UInt absPartIdx, UInt depth );
    352 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     347#if H_3D
    353348  Bool*        getDISFlag            ()                         { return m_bDISFlag;          }
    354349  Bool         getDISFlag            ( UInt idx)                { return m_bDISFlag[idx];     }
     
    360355  Void         getDISType            ( UInt idx, UInt uiDISType)     { m_uiDISType[idx] = uiDISType;   }
    361356  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 
    374357#endif
    375358  Char*         getPredictionMode     ()                        { return m_pePredMode;        }
     
    506489  );
    507490  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
    509491  Void          getDisMvpCandNBDV ( DisInfo* pDInfo
    510 #else
    511   Bool          getDisMvpCandNBDV ( DisInfo* pDInfo
    512 #endif
    513492#if H_3D_NBDV_REF
    514493   , Bool bDepthRefine = false
     
    517496   
    518497#if H_3D
    519 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    520498  Void          getDispforDepth  ( UInt uiPartIdx, UInt uiPartAddr, DisInfo* cDisp);
    521 #else
    522   Bool          getDispforDepth  ( UInt uiPartIdx, UInt uiPartAddr, DisInfo* cDisp);
    523 #endif
    524499  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
     500
    527501   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
    532502#endif
    533503#if H_3D_NBDV_REF
     
    625595 
    626596  Void          clipMv                ( TComMv&     rcMv     );
    627 #if SONY_MV_V_CONST_C0078
     597#if H_MV
    628598  Void          checkMV_V (TComMv&  rcMv,  RefPicList eRefPicList, int iRefIdx );
    629599#endif
  • branches/HTM-14.0-dev0/source/Lib/TLibCommon/TComMotionInfo.h

    r1179 r1185  
    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
  • branches/HTM-14.0-dev0/source/Lib/TLibCommon/TComPrediction.cpp

    r1179 r1185  
    630630
    631631#if H_3D_DBBP
    632 #if HS_DBBP_CLEAN_K0048
    633632PartSize TComPrediction::getPartitionSizeFromDepth(Pel* pDepthPels, UInt uiDepthStride, UInt uiSize, TComDataCU*& pcCU)
    634 #else
    635 PartSize TComPrediction::getPartitionSizeFromDepth(Pel* pDepthPels, UInt uiDepthStride, UInt uiSize)
    636 #endif
    637633{
    638634  // find virtual partitioning for this CU based on depth block
     
    643639  Int iSumDepth = 0;
    644640  Int iSubSample = 4;
    645 #if HS_DBBP_CLEAN_K0048
    646641  Int iPictureWidth = pcCU->getSlice()->getIvPic (true, pcCU->getDvInfo(0).m_aVIdxCan)->getPicYuvRec()->getWidth();
    647642  Int iPictureHeight = pcCU->getSlice()->getIvPic (true, pcCU->getDvInfo(0).m_aVIdxCan)->getPicYuvRec()->getHeight();
     
    675670    if (!(iBlkY+y+4>iPictureHeight))
    676671    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
    690672  }
    691673 
     
    705687    for (Int x=0; x<uiSize; x+=iSubSample)
    706688    {
    707 #if HS_DBBP_CLEAN_K0048
    708689      Int depthPel = 0;
    709690if (iBlkX+x>iPictureWidth)
     
    716697     t=x;
    717698}
    718 #else
    719       Int depthPel = pDepthPels[x];
    720 #endif
    721699     
    722700      // decide which segment this pixel belongs to
     
    747725   
    748726    // next row
    749 #if HS_DBBP_CLEAN_K0048
    750727    if (!(iBlkY+y+4>iPictureHeight))
    751 #endif
    752728    pDepthPels += uiDepthStride*iSubSample;
    753729  }
     
    773749}
    774750
    775 #if HS_DBBP_CLEAN_K0048
    776751Bool 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
    780752{
    781753  // segmentation of texture block --> mask IDs
     
    786758  Int uiMinDepth = MAX_INT;
    787759  Int uiMaxDepth = 0;
    788 #if HS_DBBP_CLEAN_K0048
    789760  uiMinDepth = pDepthPels[ 0 ];
    790761  uiMaxDepth = pDepthPels[ 0 ];
     
    848819    uiMaxDepth = std::max( uiMaxDepth, (Int)pDepthPels[ uiDepthStride * (uiHeight - 1) + uiWidth - 1 ]);
    849820  }
    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
    866821
    867822  // don't generate mask for blocks with small depth range (encoder decision)
     
    885840    for (Int x=0; x<uiHeight; x++)
    886841    {
    887 #if HS_DBBP_CLEAN_K0048
    888842      Int depthPel = 0;
    889843      if (iBlkX+x>iPictureWidth)
     
    896850        t=x;
    897851      }
    898 #else
    899       Int depthPel = pDepthPels[x];
    900 #endif
    901852
    902853      // decide which segment this pixel belongs to
     
    916867
    917868    // next row
    918 #if HS_DBBP_CLEAN_K0048
    919869    if (!(iBlkY+y+1>iPictureHeight))
    920 #endif
    921870      pDepthPels += uiDepthStride;
    922871    pMask += MAX_CU_SIZE;
     
    12931242  TComMv      cMv         = pcCU->getCUMvField( eRefPicList )->getMv( uiPartAddr );
    12941243  pcCU->clipMv(cMv);
    1295 #if SONY_MV_V_CONST_C0078
     1244#if H_MV
    12961245  pcCU->checkMV_V(cMv, eRefPicList, iRefIdx );
    12971246#endif
     
    13931342#if H_3D_NBDV
    13941343  DisInfo cDistparity;
    1395 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    13961344  cDistparity.m_acNBDV = pcCU->getDvInfo(0).m_acNBDV;
    13971345  cDistparity.m_aVIdxCan = pcCU->getDvInfo(uiPartAddr).m_aVIdxCan;
    13981346#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
    14081347  assert(0); // ARP can be applied only when a DV is available
    14091348#endif
    1410 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    14111349  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
     1350
    14191351  {
    14201352    Int arpRefIdx = pcCU->getSlice()->getFirstTRefIdx(eRefPicList);
     
    14681400      pYuvB0->clear(); pYuvB1->clear();
    14691401    }
    1470 #if !SEC_ARP_REM_ENC_RESTRICT_K0035
    1471     assert ( cDistparity.bDV );
    1472 #endif   
    14731402    TComMv cNBDV = cDistparity.m_acNBDV;
    14741403    pcCU->clipMv( cNBDV );
  • branches/HTM-14.0-dev0/source/Lib/TLibCommon/TComPrediction.h

    r1179 r1185  
    175175 
    176176#if H_3D_DBBP
    177 #if HS_DBBP_CLEAN_K0048
    178177  PartSize      getPartitionSizeFromDepth(Pel* pDepthPels, UInt uiDepthStride, UInt uiSize, TComDataCU*& pcCU);
    179178  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
    184179  Void          combineSegmentsWithMask( TComYuv* pInYuv[2], TComYuv* pOutYuv, Bool* pMask, UInt uiWidth, UInt uiHeight, UInt uiPartAddr, UInt partSize );
    185180#endif
  • branches/HTM-14.0-dev0/source/Lib/TLibCommon/TComRdCost.cpp

    r1179 r1185  
    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 )
  • branches/HTM-14.0-dev0/source/Lib/TLibCommon/TComRdCost.h

    r1179 r1185  
    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
  • branches/HTM-14.0-dev0/source/Lib/TLibCommon/TComRom.cpp

    r1179 r1185  
    745745  assert( uiWidth == uiHeight );
    746746
    747 #if SHARP_DMM_CLEAN_K0042
    748747  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
    753748
    754749  UInt uiBlockSize = 0;
     
    762757  for( UInt uiOri = 0; uiOri < 6; uiOri++ )
    763758  {
    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
     759
    778760    posEnd = (Int) racWedgeList.size();
    779761    if (uiOri == 0 || uiOri == 4)
    780762    {
    781 #endif
    782763    for( Int iK = 0; iK < uiBlockSize; iK += (uiWidth>=16 ?2:1))
    783764    {
    784765      for( Int iL = 0; iL < uiBlockSize; iL += ((uiWidth>=16 && uiOri<4)?2:1) )
    785766      {
    786 #if SHARP_DMM_CLEAN_K0042
    787767        Int xS = iK;
    788768        Int yS = 0;
     
    790770        Int yE = (uiOri == 0) ? iL : uiBlockSize - 1;
    791771        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
    795772        addWedgeletToList( cTempWedgelet, racWedgeList, racWedgeRefList );
    796773      }
    797774    }
    798 #if SHARP_DMM_CLEAN_K0042
    799775    }
    800776    else
     
    807783    }
    808784    posStart = posEnd;
    809 #endif
    810785  }
    811786
  • branches/HTM-14.0-dev0/source/Lib/TLibCommon/TComSlice.cpp

    r1179 r1185  
    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
     
    28582775, m_interViewMvVertConstraintFlag (false)
    28592776#endif
    2860 #if H_3D
    2861 #if !HHI_CAM_PARA_K0052
    2862 , m_bCamParInSliceHeader      (false)
    2863 #endif
    2864 #endif
    28652777{
    28662778  for ( Int i = 0; i < MAX_TLAYER; i++ )
     
    38853797      {
    38863798        Int layerIdInNuh = getRefPicLayerId( i );
    3887 #if HHI_RES_PRED_K0052
     3799
    38883800        TComPic* picV = getIvPic( getIsDepth(), getVPS()->getViewIndex( layerIdInNuh ) );
    38893801        assert( picV != NULL );
     
    39003812
    39013813        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
    39073814        {
    39083815          m_arpRefPicAvailable[eRefPicList][layerIdInNuh] = true;
     
    40873994    return;
    40883995
    4089 #if HHI_CAM_PARA_K0052
    40903996  m_numViews = getVPS()->getNumViews();
    4091 #endif
    40923997  /// GT: Allocation should be moved to a better place later;
    40933998  if ( m_depthToDisparityB == NULL )
    40943999  {
    4095 #if HHI_CAM_PARA_K0052   
    40964000    m_depthToDisparityB = new Int*[ m_numViews ];
    40974001    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
    41024002    {
    41034003      m_depthToDisparityB[ i ] = new Int[ Int(1 << g_bitDepthY) ];
     
    41084008  if ( m_depthToDisparityF == NULL )
    41094009  {
    4110 #if HHI_CAM_PARA_K0052   
    41114010    m_depthToDisparityF = new Int*[ m_numViews ];
    41124011    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
    41174012    {
    41184013      m_depthToDisparityF[ i ] = new Int[ Int(1 << g_bitDepthY) ];
     
    41254020  TComVPS* vps = getVPS();
    41264021
    4127 #if HHI_CAM_PARA_K0052
    41284022  Int log2Div = g_bitDepthY - 1 + vps->getCpPrecision();
    41294023  Int voiInVps = vps->getVoiInVps( getViewIndex() );
     
    41554049    }
    41564050  }
    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
    41814051}
    41824052#endif
     
    42224092  Bool depthFlag = getIsDepth();
    42234093
    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
    42964094  Bool nRLLG0 =  ( getVPS()->getNumRefListLayers( getLayerId() ) > 0 );     
    42974095
     
    43014099  m_ivMvScalingFlag        = sps3dExt->getIvMvScalingFlag      ( depthFlag )                                 ;                             
    43024100  m_ivResPredFlag          = sps3dExt->getIvResPredFlag        ( depthFlag ) && nRLLG0                       ;                               
    4303 #if HHI_CAM_PARA_K0052
    43044101  m_depthRefinementFlag    = sps3dExt->getDepthRefinementFlag  ( depthFlag )           && getInCompPredFlag() && m_cpAvailableFlag;
    43054102  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
    43104103  m_depthBasedBlkPartFlag  = sps3dExt->getDepthBasedBlkPartFlag( depthFlag )           && getInCompPredFlag();                         
    43114104  m_mpiFlag                = sps3dExt->getMpiFlag              ( depthFlag )           && getInCompPredFlag();
     
    43194112  m_mpiSubPbSize           =  1 << ( sps3dExt->getLog2MpiSubPbSizeMinus3( depthFlag ) + 3 );
    43204113
    4321 #endif
    43224114
    43234115#if H_3D_OUTPUT_ACTIVE_TOOLS
     
    43254117  std::cout << "DepthFlag:              :" << getIsDepth()             << std::endl;
    43264118  std::cout << "ViewOrderIdx:           :" << getViewIndex()           << std::endl;
    4327 #if HHI_INTER_COMP_PRED_K0052
    43284119  std::cout << "InterCmpPredAvailableFlag:" << getInCmpPredAvailFlag() << std::endl;
    43294120  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
    43354121 
    43364122  std::cout << "ivMvPredFlag            :" << m_ivMvPredFlag           << std::endl;
     
    43454131  std::cout << "qtPredFlag              :" << m_qtPredFlag             << std::endl;
    43464132  std::cout << "interSdcFlag            :" << m_interSdcFlag           << std::endl;
    4347 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    43484133  std::cout << "depthIntraSkipFlag      :" << m_depthIntraSkipFlag     << std::endl;   
    4349 #else
    4350   std::cout << "intraSingleFlag         :" << m_intraSingleFlag        << std::endl;   
    4351 #endif
    43524134  std::cout << "subPbSize               :" << m_subPbSize              << std::endl;
    43534135  std::cout << "mpiSubPbSize            :" << m_mpiSubPbSize           << std::endl;
  • branches/HTM-14.0-dev0/source/Lib/TLibCommon/TComSlice.h

    r1179 r1185  
    914914  // VPS EXTENSION 2 SYNTAX ELEMENTS
    915915#if H_3D
    916 #if HHI_CAM_PARA_K0052 
    917916  Int*        m_numCp; 
    918917  Int**       m_cpRefVoi;
     
    920919  Int         m_cpPrecision;
    921920  Bool*       m_cpInSliceSegmentHeaderFlag;
    922 #else
    923   UInt        m_uiCamParPrecision;
    924   Bool*       m_bCamParInSliceHeader;
    925   Bool*       m_bCamParPresent;
    926 #endif
    927921  Int         ***m_aaaiCodedScale ;
    928922  Int         ***m_aaaiCodedOffset;
    929923
    930 #if HHI_VIEW_ID_LIST_I5_J0107 ||  HHI_INTER_COMP_PRED_K0052
    931924  std::vector<Int>  m_viewOIdxList;
    932 #endif
    933 #if HHI_INTER_COMP_PRED_K0052
    934925  std::vector< std::vector<Bool> > m_viewCompLayerPresentFlag;
    935926  std::vector< std::vector<Int>  > m_viewCompLayerId;
    936 #endif
    937927#endif
    938928
     
    11631153  Int     getNumViews()                                                    { return m_numViews; }
    11641154  Void    initNumViews();
    1165 #if HHI_INTER_COMP_PRED_K0052
    11661155#if H_3D
    11671156  Void   initViewCompLayer( )
     
    11911180    }
    11921181  };
    1193 #endif
    1194 #endif
    1195 
    1196 #if HHI_VIEW_ID_LIST_I5_J0107 || HHI_INTER_COMP_PRED_K0052
     1182
     1183
    11971184  Int     getViewOIdxList( Int i )                                         { return m_viewOIdxList[i]; }
    1198 #if HHI_CAM_PARA_K0052
    11991185  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
     1186
    12051187  Int     getVoiInVps( Int viewOIdx )                                     
    1206 #else
    1207   Int     getInvViewOIdxList( Int viewOIdx )                                     
    1208 #endif
    12091188  {   
    12101189    for ( Int i = 0; i < m_viewOIdxList.size(); i++ )
     
    12191198  };
    12201199
    1221 #if HHI_CAM_PARA_K0052
    12221200  Bool    getViewCompLayerPresentFlag (Int i, Bool d ) { return  m_viewCompLayerPresentFlag[ getVoiInVps(i) ][d]; }
    12231201  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
    12281202#endif
    12291203  Bool    getDependencyFlag( Int i, Int j )                                { return m_dependencyFlag[i][j]; }
     
    13471321  Void createCamPars(Int iNumViews);
    13481322  Void deleteCamPars();
    1349 #if HHI_CAM_PARA_K0052
    13501323  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
     1324 
    13561325
    13571326  Void setCpPrecision( Int  val ) { m_cpPrecision = val; }
     
    14031372  Bool getCpPresentFlag( Int i, Int m )           { return m_cpPresentFlag[i][m]; }   
    14041373
    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
    14131374
    14141375
     
    17051666      m_qtPredFlag            [d] = false;
    17061667      m_interSdcFlag          [d] = false;
    1707 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    17081668      m_depthIntraSkipFlag    [d] = false;   
    1709 #else
    1710       m_intraSingleFlag       [d] = false;
    1711 #endif
    17121669    }
    17131670  }
     
    17521709  Bool getInterSdcFlag( Int d ) { return m_interSdcFlag[d]; }
    17531710
    1754 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    17551711  Void setDepthIntraSkipFlag( Int d, Bool flag ) { m_depthIntraSkipFlag[d] = flag; }
    17561712  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
    17611713
    17621714private:
     
    17751727  Bool        m_qtPredFlag            [2];
    17761728  Bool        m_interSdcFlag          [2];
    1777 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    17781729  Bool        m_depthIntraSkipFlag    [2]; 
    1779 #else
    1780   Bool        m_intraSingleFlag       [2]; 
    1781 #endif
    17821730};
    17831731
     
    18841832#if H_3D
    18851833  TComSps3dExtension m_sps3dExtension;
    1886 #if !HHI_CAM_PARA_K0052
    1887   UInt        m_uiCamParPrecision;
    1888   Bool        m_bCamParInSliceHeader;
    1889 #endif
    18901834  Int         m_aaiCodedScale [2][MAX_NUM_LAYERS];
    18911835  Int         m_aaiCodedOffset[2][MAX_NUM_LAYERS];
     
    25172461  UInt                 m_nARPStepNum;
    25182462  Int         m_aiFirstTRefIdx    [2];
    2519 #if HHI_RES_PRED_K0052
    25202463  std::vector<Int> m_pocsInCurrRPSs;
    2521 #endif
    25222464#endif
    25232465#if H_3D_IC
     
    25262468#endif
    25272469#if H_3D
    2528 #if HHI_INTER_COMP_PRED_K0052
    25292470  std::vector<Int> m_inCmpRefViewIdcs;
    25302471  Bool       m_inCmpPredAvailFlag;
    25312472  Bool       m_inCmpPredFlag;
    2532 #endif
    2533 #if HHI_CAM_PARA_K0052
    25342473  Bool       m_cpAvailableFlag;
    25352474  Int        m_numViews;
    2536 #endif
    25372475  TComPic*   m_ivPicsCurrPoc [2][MAX_NUM_LAYERS]; 
    25382476  Int**      m_depthToDisparityB;
     
    25402478#endif
    25412479#endif
    2542 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    25432480  Bool      m_bApplyDIS;
    2544 #else
    2545 #if H_3D_SINGLE_DEPTH
    2546   Bool      m_bApplySingleDepthMode;
    2547 #endif
    2548 #endif
    25492481#if H_3D_IC
    25502482  Int *m_aICEnableCandidate;
     
    25652497  Bool m_qtPredFlag           ;
    25662498  Bool m_interSdcFlag         ;
    2567 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    25682499  Bool m_depthIntraSkipFlag   ;
    2569 #else
    2570   Bool m_intraSingleFlag      ;
    2571 #endif
    25722500  Int  m_mpiSubPbSize         ;
    25732501  Int  m_subPbSize            ;
     
    26372565  Int       getRefPOC           ( RefPicList e, Int iRefIdx)    { return  m_aiRefPOCList[e][iRefIdx];   }
    26382566#if H_3D
    2639 #if HHI_INTER_COMP_PRED_K0052
    26402567  Bool      getInCmpPredAvailFlag( )                             { return m_inCmpPredAvailFlag;    }
    2641 #if HHI_CAM_PARA_K0052
    26422568  Bool      getCpAvailableFlag( )                             { return m_cpAvailableFlag;    }
    2643 #endif
    26442569  Bool      getInCompPredFlag( )                                 { return m_inCmpPredFlag;         }   
    26452570  Void      setInCompPredFlag( Bool b )                          { m_inCmpPredFlag = b;            }   
    26462571  Int       getInCmpRefViewIdcs( Int i )                         { return m_inCmpRefViewIdcs  [i]; }
    26472572  Int       getNumCurCmpLIds( )                                  { return (Int) m_inCmpRefViewIdcs.size(); }
    2648 #endif
    26492573  TComPic*  getIvPic            ( Bool depthFlag, Int viewIndex){ return  m_ivPicsCurrPoc[ depthFlag ? 1 : 0 ][ viewIndex ]; }
    26502574#endif
     
    28752799  Void      setFirstTRefIdx        ( RefPicList e, Int i )         { m_aiFirstTRefIdx[e]    = i;      }
    28762800  Bool      getArpRefPicAvailable( RefPicList e, Int viewIdx) {return m_arpRefPicAvailable[e][getVPS()->getLayerIdInNuh(viewIdx, 0)]; }
    2877 #if HHI_RES_PRED_K0052
    28782801  std::vector<Int> getPocsInCurrRPSs()                             { return m_pocsInCurrRPSs; };
    2879 #endif
    28802802#endif
    28812803  Void      setIsDepth            ( Bool isDepth )   { m_isDepth = isDepth; }
     
    28862808  Int*      getInvCodedScale      ()  { return m_aaiCodedScale [1]; }
    28872809  Int*      getInvCodedOffset     ()  { return m_aaiCodedOffset[1]; }
    2888 #if HHI_CAM_PARA_K0052
    28892810  Void      setCpScale( Int j, Int  val ) { m_aaiCodedScale[0][j] = val; }
    28902811  Int       getCpScale( Int j ) { return m_aaiCodedScale[0][j]; }
     
    28982819  Void      setCpInvOff( Int j, Int  val ) { m_aaiCodedOffset[1][j] = val; }
    28992820  Int       getCpInvOff( Int j ) { return m_aaiCodedOffset[1][j]; }
    2900 #endif
    29012821
    29022822#endif
     
    29062826  Void    setDepthToDisparityLUTs();
    29072827
    2908 #if HHI_CAM_PARA_K0052
    29092828  Int* getDepthToDisparityB( Int refViewIdx ) { return m_depthToDisparityB[ getVPS()->getVoiInVps( refViewIdx) ]; };
    29102829  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
    29152830#endif
    29162831#if H_3D_IC
     
    30152930#if H_3D
    30162931  // 3D-HEVC tool parameters
    3017 #if HHI_INTER_COMP_PRED_K0052
    30182932  Void deriveInCmpPredAndCpAvailFlag()
    30192933  {
     
    30322946    }
    30332947
    3034 #if HHI_CAM_PARA_K0052
    30352948    m_cpAvailableFlag = true;
    30362949    m_inCmpRefViewIdcs.clear();
    3037 #endif
    30382950    Bool allRefCmpLayersAvailFlag = true;
    30392951
     
    30412953    {     
    30422954      m_inCmpRefViewIdcs.push_back( getVPS()->getViewOrderIdx( curCmpLIds[ i ] ));
    3043 #if HHI_CAM_PARA_K0052
    30442955      if( !getVPS()->getCpPresentFlag( getVPS()->getVoiInVps( getViewIndex() ),  getVPS()->getVoiInVps( m_inCmpRefViewIdcs[ i ] ) ) )
    30452956      {
    30462957        m_cpAvailableFlag = false;
    30472958      }
    3048 #endif
    30492959      Bool refCmpCurLIdAvailFlag = false;
    30502960      if( getVPS()->getViewCompLayerPresentFlag( m_inCmpRefViewIdcs[ i ], !getIsDepth() ) )
     
    30872997  };
    30882998
    3089 #endif
    30902999
    30913000  Void init3dToolParameters();   
    3092 #if HHI_INTER_COMP_PRED_K0052
    30933001  Void checkInCompPredRefLayers()
    30943002  {
     
    31053013  };
    31063014
    3107 #endif
    31083015  Bool getIvMvPredFlag           ( ) { return m_ivMvPredFlag           ; };
    31093016  Bool getIvMvScalingFlag        ( ) { return m_ivMvScalingFlag        ; };
     
    31173024  Bool getQtPredFlag             ( ) { return m_qtPredFlag             ; };
    31183025  Bool getInterSdcFlag           ( ) { return m_interSdcFlag           ; };
    3119 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    31203026  Bool getDepthIntraSkipFlag     ( ) { return m_depthIntraSkipFlag     ; };
    3121 #else
    3122   Bool getIntraSingleFlag        ( ) { return m_intraSingleFlag        ; };
    3123 #endif
    31243027
    31253028  Int  getMpiSubPbSize           ( ) { return m_mpiSubPbSize           ; };
  • branches/HTM-14.0-dev0/source/Lib/TLibCommon/TComWedgelet.cpp

    r1179 r1185  
    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;
  • branches/HTM-14.0-dev0/source/Lib/TLibCommon/TComWedgelet.h

    r1179 r1185  
    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();
  • branches/HTM-14.0-dev0/source/Lib/TLibCommon/TypeDef.h

    r1179 r1185  
    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
    353308#endif
    354309
     
    384339                                              // HHI_DEPTH_INTRA_SEARCH_RAU_C0160
    385340                                              // 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
    390341
    391342#endif
     
    434385// TBD: Check if integration is necessary.
    435386
    436 #define H_MV_HLS_FIX                         1
     387
    437388#define H_MV_HLS_PTL_LIMITS                  0
    438389#define H_MV_HLS7_GEN                        0  // General changes (not tested)
    439 #define H_MV_ALIGN_HM_15                     1 
    440390
    441391// POC
  • branches/HTM-14.0-dev0/source/Lib/TLibDecoder/TDecCAVLC.cpp

    r1179 r1185  
    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() )
     
    24792389      rpcSlice->init3dToolParameters();
    24802390    }
    2481 #endif
    24822391#endif
    24832392#endif
     
    26622571    }
    26632572#if H_3D_IC
    2664 #if H_3D_ANNEX_SELECTION_FIX
    26652573    else if(    rpcSlice->getViewIndex() && ( rpcSlice->getSliceType() == P_SLICE || rpcSlice->getSliceType() == B_SLICE )
    26662574             && !rpcSlice->getIsDepth() && vps->getNumRefListLayers( layerId ) > 0
    26672575             && getDecTop()->decProcAnnexI()
    26682576           )
    2669 #else
    2670     else if( rpcSlice->getViewIndex() && ( rpcSlice->getSliceType() == P_SLICE || rpcSlice->getSliceType() == B_SLICE ) && !rpcSlice->getIsDepth() && vps->getNumRefListLayers( layerId ) > 0 )
    2671 #endif
    26722577    {
    26732578      UInt uiCodeTmp = 0;
     
    27662671    rpcSlice->setLFCrossSliceBoundaryFlag( (uiCode==1)?true:false);
    27672672
    2768 #if HHI_CAM_PARA_K0052
    27692673#if H_3D
    27702674    if ( getDecTop()->decProcAnnexI() )
     
    27842688    }
    27852689#endif
    2786 #endif
    27872690  }
    27882691 
     
    28082711  }
    28092712
    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
    28302713
    28312714  if(pps->getSliceHeaderExtensionPresentFlag())
     
    31002983  assert(0);
    31012984}
    3102 
    3103 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2985#if H_3D
    31042986Void TDecCavlc::parseDIS( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
    31052987{
    31062988  assert(0);
    31072989}
    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
    31152990#endif
    31162991
  • branches/HTM-14.0-dev0/source/Lib/TLibDecoder/TDecCAVLC.h

    r1179 r1185  
    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
  • branches/HTM-14.0-dev0/source/Lib/TLibDecoder/TDecCu.cpp

    r1179 r1185  
    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 );
     
    688656      break;
    689657    case MODE_INTRA:
    690 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     658#if H_3D
    691659      if( m_ppcCU[uiDepth]->getDISFlag(0) )
    692660      {
     
    700668#endif
    701669      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
    718670#endif
    719671      xReconIntraQT( m_ppcCU[uiDepth], uiDepth );
     
    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 
  • branches/HTM-14.0-dev0/source/Lib/TLibDecoder/TDecCu.h

    r1179 r1185  
    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
  • branches/HTM-14.0-dev0/source/Lib/TLibDecoder/TDecEntropy.cpp

    r1179 r1185  
    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))
     
    265238  pcSubCU->copyDVInfoFrom( pcCU, uiAbsPartIdx);
    266239#endif
    267 #if HHI_MOVE_SYN_K0052
     240#if H_3D
    268241  for ( UInt uiPartIdx = 0, uiSubPartIdx = uiAbsPartIdx; uiPartIdx < uiNumPU; uiPartIdx++, uiSubPartIdx += uiPUOffset )
    269242  {
     
    475448      decodeMergeIndex( pcCU, uiPartIdx, uiSubPartIdx, uiDepth );
    476449      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
    484450      if ( pcCU->getSlice()->getPPS()->getLog2ParallelMergeLevelMinus2() && ePartSize != SIZE_2Nx2N && pcSubCU->getWidth( 0 ) <= 8 && pcCU->getDBBPFlag(uiAbsPartIdx) == false )
    485 #else
    486       if ( pcCU->getSlice()->getPPS()->getLog2ParallelMergeLevelMinus2() && ePartSize != SIZE_2Nx2N && pcSubCU->getWidth( 0 ) <= 8 )
    487 #endif
    488451      {
    489452        pcSubCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uiDepth );
    490453        if ( !isMerged )
    491454        {
    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
    519455          pcSubCU->getInterMergeCandidates( 0, 0, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
    520 #endif
    521 #endif
    522456          isMerged = true;
    523457        }
     
    527461      {
    528462        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();
    536463        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
    557464      }
    558465      pcCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeIndex], uiSubPartIdx, uiPartIdx, uiDepth );
     
    567474          pcCU->getCUMvField( RefPicList( uiRefListIdx ) )->setAllMvd( cTmpMv, ePartSize, uiSubPartIdx, uiDepth, uiPartIdx );
    568475          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
     476        }
     477      }
    612478    }
    613479    else
     
    706572}
    707573
    708 #if HHI_MOVE_SYN_K0052
     574#if H_3D
    709575Void TDecEntropy::decodeMVPIdxPU( TComDataCU* pcSubCU, UInt uiPartAddr, UInt uiDepth, UInt uiPartIdx, RefPicList eRefList )
    710576{
     
    753619  pcSubCU->getCUMvField( eRefList )->setAllMv(cMv, ePartSize, uiPartAddr, 0, uiPartIdx);
    754620}
    755 
    756621#else
    757622Void TDecEntropy::decodeMVPIdxPU( TComDataCU* pcSubCU, UInt uiPartAddr, UInt uiDepth, UInt uiPartIdx, RefPicList eRefList )
     
    798663}
    799664#endif
     665
    800666Void TDecEntropy::xDecodeTransform( TComDataCU* pcCU, UInt offsetLuma, UInt offsetChroma, UInt uiAbsPartIdx, UInt uiDepth, UInt width, UInt height, UInt uiTrIdx, Bool& bCodeDQP, Int quadtreeTULog2MinSizeInCU)
    801667{
     
    1131997{
    1132998  pcCU->setSDCFlagSubParts( false, uiAbsPartIdx, uiDepth );
    1133 #if HHI_MOVE_SYN_K0052
    1134999  if ( pcCU->isSkipped( uiAbsPartIdx ) )
    11351000  {
    11361001    return;
    11371002  }
    1138 #endif
    11391003
    11401004
     
    11571021Void TDecEntropy::decodeDBBPFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    11581022{
    1159 #if HHI_MOVE_SYN_K0052
    11601023  if( pcCU->getSlice()->getDepthBasedBlkPartFlag() && (pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2NxN || pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_Nx2N) && pcCU->getWidth(uiAbsPartIdx) > 8 && pcCU->getSlice()->getDefaultRefViewIdxAvailableFlag() )
    11611024  {
    1162 #endif
    11631025    m_pcEntropyDecoderIf->parseDBBPFlag( pcCU, uiAbsPartIdx, uiDepth );
    1164 #if HHI_MOVE_SYN_K0052
    1165   }
    1166 #endif
     1026  }
    11671027}
    11681028#endif
  • branches/HTM-14.0-dev0/source/Lib/TLibDecoder/TDecEntropy.h

    r1179 r1185  
    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 );
  • branches/HTM-14.0-dev0/source/Lib/TLibDecoder/TDecGop.h

    r1179 r1185  
    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
  • branches/HTM-14.0-dev0/source/Lib/TLibDecoder/TDecSbac.cpp

    r1179 r1185  
    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 );
     
    594579#endif
    595580}
    596 
    597 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     581#if H_3D
    598582Void TDecSbac::parseDIS( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    599583{
     
    639623  }
    640624}
    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 
     625#endif
    691626/** parse merge flag
    692627 * \param pcCU
  • branches/HTM-14.0-dev0/source/Lib/TLibDecoder/TDecSbac.h

    r1179 r1185  
    125125 
    126126  Void parseSkipFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    127 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     127#if H_3D
    128128  Void parseDIS          ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    129 #else
    130 #if H_3D_SINGLE_DEPTH 
    131   Void parseSingleDepthMode      ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    132 #endif
    133129#endif
    134130  Void parseCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
     
    182178  ContextModel3DBuffer m_cCUSplitFlagSCModel;
    183179  ContextModel3DBuffer m_cCUSkipFlagSCModel;
    184 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     180#if H_3D
    185181  ContextModel3DBuffer m_cCUDISFlagSCModel;
    186182  ContextModel3DBuffer m_cCUDISTypeSCModel;
    187 #else
    188 #if H_3D_SINGLE_DEPTH
    189   ContextModel3DBuffer m_cCUSingleDepthFlagSCModel;
    190   ContextModel3DBuffer m_cSingleDepthValueSCModel;
    191 #endif
    192183#endif
    193184  ContextModel3DBuffer m_cCUMergeFlagExtSCModel;
  • branches/HTM-14.0-dev0/source/Lib/TLibDecoder/TDecTop.cpp

    r1179 r1185  
    7676  xDeleteArray( m_adBaseViewShiftLUT, MAX_NUM_LAYERS, MAX_NUM_LAYERS, 2 );
    7777  xDeleteArray( m_aiBaseViewShiftLUT, MAX_NUM_LAYERS, MAX_NUM_LAYERS, 2 );
    78 #if HHI_CAM_PARA_K0052
    7978  xDeleteArray( m_receivedIdc, m_vps->getNumViews() );
    80 #else
    81   xDeleteArray( m_receivedIdc, m_uiMaxViewIndex + 1 );
    82 #endif
    8379}
    8480
     
    9591  m_firstReceivedPoc        = -2;
    9692
    97 #if HHI_CAM_PARA_K0052 
    9893  for (Int i = 0; i <= vps->getMaxLayersMinus1(); i++)
    9994  {
     
    134129}
    135130
    136 #else
    137   m_uiMaxViewIndex            = -1;
    138   for (Int i = 0; i <= vps->getMaxLayersMinus1(); i++)
    139   {
    140     Int curViewIdx = m_vps->getViewIndex( m_vps->getLayerIdInNuh( i ));
    141     m_bCamParsVaryOverTime = m_bCamParsVaryOverTime || vps->hasCamParInSliceHeader( curViewIdx );
    142     m_uiMaxViewIndex = std::max( m_uiMaxViewIndex, curViewIdx  ) ;
    143   }
    144   assert( m_receivedIdc == NULL );
    145   m_receivedIdc = new Int*[ m_uiMaxViewIndex + 1];
    146   for (Int i = 0; i <= m_uiMaxViewIndex; i++)
    147   {
    148     m_receivedIdc[i] = new Int[ m_uiMaxViewIndex + 1 ];
    149   }
    150 
    151   xResetReceivedIdc( true );
    152 
    153   for (Int viewIndex = 0; viewIndex <= m_uiMaxViewIndex ; viewIndex++ )
    154   {
    155     if (m_vps->getCamParPresent( viewIndex ) )
    156     {   
    157       if( !m_vps->hasCamParInSliceHeader( viewIndex ) )
    158       {
    159         for (Int baseViewIndex = 0; baseViewIndex < viewIndex ; baseViewIndex++ )
    160         {
    161           m_receivedIdc   [ baseViewIndex ][ viewIndex ] = -1;
    162           m_aaiCodedScale [ baseViewIndex ][ viewIndex ] = m_vps->getCodedScale    (viewIndex) [ baseViewIndex ];
    163           m_aaiCodedOffset[ baseViewIndex ][ viewIndex ] = m_vps->getCodedOffset   (viewIndex) [ baseViewIndex ];
    164 
    165           m_receivedIdc   [ viewIndex ][ baseViewIndex ] = -1;
    166           m_aaiCodedScale [ viewIndex ][ baseViewIndex ] = m_vps->getInvCodedScale (viewIndex) [ baseViewIndex ];
    167           m_aaiCodedOffset[ viewIndex ][ baseViewIndex ] = m_vps->getInvCodedOffset(viewIndex) [ baseViewIndex ];
    168           xInitLUTs( baseViewIndex, viewIndex, m_aaiCodedScale[ baseViewIndex ][ viewIndex ], m_aaiCodedOffset[ baseViewIndex ][ viewIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
    169           xInitLUTs( viewIndex, baseViewIndex, m_aaiCodedScale[ viewIndex ][ baseViewIndex ], m_aaiCodedOffset[ viewIndex ][ baseViewIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
    170         }
    171       }
    172     }
    173   }
    174 }
    175 
    176 #endif
    177131
    178132
     
    181135CamParsCollector::xResetReceivedIdc( Bool overWriteFlag )
    182136{
    183 #if HHI_CAM_PARA_K0052
    184137  for (Int i = 0; i < m_vps->getNumViews(); i++)
    185138  { 
    186139    for (Int j = 0; j < m_vps->getNumViews(); j++)
    187140    {
    188 #else
    189   for (Int i = 0; i <= m_uiMaxViewIndex; i++)
    190   { 
    191     for (Int j = 0; j <= m_uiMaxViewIndex; j++)
    192     {
    193 #endif
    194141      if ( overWriteFlag ||  ( m_receivedIdc[i][j] != -1 ) )
    195142      {
     
    232179  CamParsCollector::xInitLUTs( UInt uiSourceView, UInt uiTargetView, Int iScale, Int iOffset, Double****& radLUT, Int****& raiLUT)
    233180{
    234 #if HHI_CAM_PARA_K0052
    235181  Int     iLog2DivLuma   = m_uiBitDepthForLUT + m_vps->getCpPrecision() + 1 - m_iLog2Precision;   AOF( iLog2DivLuma > 0 );
    236 #else
    237   Int     iLog2DivLuma   = m_uiBitDepthForLUT + m_vps->getCamParPrecision() + 1 - m_iLog2Precision;   AOF( iLog2DivLuma > 0 );
    238 #endif
    239182  Int     iLog2DivChroma = iLog2DivLuma + 1;
    240183
     
    313256  }
    314257
    315 #if HHI_CAM_PARA_K0052
    316258  UInt voiInVps          = m_vps->getVoiInVps(pcSlice->getViewIndex()); 
    317259  if( m_vps->getCpInSliceSegmentHeaderFlag( voiInVps ) ) // check consistency of slice parameters here
     
    348290    }
    349291  } 
    350 #else
    351   UInt uiViewIndex          = pcSlice->getViewIndex(); 
    352   if( m_vps->getCamParPresent( uiViewIndex ) )
    353   {   
    354     if( m_vps->hasCamParInSliceHeader( uiViewIndex ) ) // check consistency of slice parameters here
    355     {   
    356       for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < uiViewIndex; uiBaseViewIndex++ )
    357       {       
    358         if ( m_receivedIdc[ uiViewIndex ][ uiBaseViewIndex ] != 0 )
    359         {     
    360           AOF( m_aaiCodedScale [ uiViewIndex ][ uiBaseViewIndex ] == pcSlice->getInvCodedScale () [ uiBaseViewIndex ] );
    361           AOF( m_aaiCodedOffset[ uiViewIndex ][ uiBaseViewIndex ] == pcSlice->getInvCodedOffset() [ uiBaseViewIndex ] );
    362         }
    363         else
    364         {         
    365           m_receivedIdc   [ uiViewIndex ][ uiBaseViewIndex ]  = 1;
    366           m_aaiCodedScale [ uiViewIndex ][ uiBaseViewIndex ]  = pcSlice->getInvCodedScale () [ uiBaseViewIndex ];
    367           m_aaiCodedOffset[ uiViewIndex ][ uiBaseViewIndex ]  = pcSlice->getInvCodedOffset() [ uiBaseViewIndex ];
    368           xInitLUTs( uiViewIndex, uiBaseViewIndex, m_aaiCodedScale[ uiViewIndex ][ uiBaseViewIndex ], m_aaiCodedOffset[ uiViewIndex ][ uiBaseViewIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT);
    369         }
    370         if ( m_receivedIdc[ uiBaseViewIndex ][ uiViewIndex ] != 0 )
    371         {     
    372           AOF( m_aaiCodedScale [ uiBaseViewIndex ][ uiViewIndex ] == pcSlice->getCodedScale    () [ uiBaseViewIndex ] );
    373           AOF( m_aaiCodedOffset[ uiBaseViewIndex ][ uiViewIndex ] == pcSlice->getCodedOffset   () [ uiBaseViewIndex ] );
    374         }
    375         else
    376         {       
    377           m_receivedIdc   [ uiBaseViewIndex ][ uiViewIndex ]  = 1;
    378           m_aaiCodedScale [ uiBaseViewIndex ][ uiViewIndex ]  = pcSlice->getCodedScale    () [ uiBaseViewIndex ];
    379           m_aaiCodedOffset[ uiBaseViewIndex ][ uiViewIndex ]  = pcSlice->getCodedOffset   () [ uiBaseViewIndex ];
    380           xInitLUTs( uiBaseViewIndex, uiViewIndex, m_aaiCodedScale[ uiBaseViewIndex ][ uiViewIndex ], m_aaiCodedOffset[ uiBaseViewIndex ][ uiViewIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT);
    381         }
    382       }
    383     }
    384   }
    385 #endif
    386292
    387293
     
    408314    if( iPOC == m_firstReceivedPoc )
    409315    {
    410 #if HHI_CAM_PARA_K0052
    411316      fprintf( m_pCodedScaleOffsetFile, "#ViewOrderIdx     ViewIdVal\n" );
    412317      fprintf( m_pCodedScaleOffsetFile, "#------------ -------------\n" );
     
    436341                m_aaiCodedScale [ baseVoiInVps ][ voiInVps ],
    437342                m_aaiCodedOffset[ baseVoiInVps ][ voiInVps ], m_vps->getCpPrecision() );
    438 #else
    439       fprintf( m_pCodedScaleOffsetFile, "#  ViewIndex       ViewId\n" );
    440       fprintf( m_pCodedScaleOffsetFile, "#----------- ------------\n" );
    441       for( UInt uiViewIndex = 0; uiViewIndex <= m_uiMaxViewIndex; uiViewIndex++ )
    442       {
    443         fprintf( m_pCodedScaleOffsetFile, "%12d %12d\n", uiViewIndex, m_vps->getViewIdVal( uiViewIndex ) );
    444       }
    445       fprintf( m_pCodedScaleOffsetFile, "\n\n");
    446       fprintf( m_pCodedScaleOffsetFile, "# StartFrame     EndFrame   TargetView     BaseView   CodedScale  CodedOffset    Precision\n" );
    447       fprintf( m_pCodedScaleOffsetFile, "#----------- ------------ ------------ ------------ ------------ ------------ ------------\n" );
    448     }
    449     if( iPOC == m_firstReceivedPoc || m_bCamParsVaryOverTime  )
    450     {
    451       Int iS = iPOC;
    452       Int iE = ( m_bCamParsVaryOverTime ? iPOC : ~( 1 << 31 ) );
    453 #if HHI_CAM_PARA_K0052
    454       for( UInt uiViewIndex = 0; uiViewIndex < m_vps->getNumViews(); uiViewIndex++ )
    455       {
    456         for( UInt uiBaseIndex = 0; uiBaseIndex < m_vps->getNumViews(); uiBaseIndex++ )
    457 #else
    458       for( UInt uiViewIndex = 0; uiViewIndex <= m_uiMaxViewIndex; uiViewIndex++ )
    459       {
    460         for( UInt uiBaseIndex = 0; uiBaseIndex <= m_uiMaxViewIndex; uiBaseIndex++ )
    461 #endif
    462         {
    463           if( uiViewIndex != uiBaseIndex )
    464           {
    465             if ( m_receivedIdc[uiBaseIndex][uiViewIndex] != 0 )
    466             {           
    467 #if HHI_CAM_PARA_K0052
    468               fprintf( m_pCodedScaleOffsetFile, "%12d %12d %12d %12d %12d %12d %12d\n",
    469                 iS, iE, uiViewIndex, uiBaseIndex, m_aaiCodedScale[ uiBaseIndex ][ uiViewIndex ], m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ], m_vps->getCpPrecision() );
    470 #else
    471               fprintf( m_pCodedScaleOffsetFile, "%12d %12d %12d %12d %12d %12d %12d\n",
    472                 iS, iE, uiViewIndex, uiBaseIndex, m_aaiCodedScale[ uiBaseIndex ][ uiViewIndex ], m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ], m_vps->getCamParPrecision() );
    473 #endif
    474 #endif
    475343            }           
    476344          }
     
    556424  initROM();
    557425#endif
    558 #if H_3D_ANNEX_SELECTION_FIX
     426#if H_3D
    559427  m_cCavlcDecoder.setDecTop( this );
    560428#endif
     
    867735
    868736#endif
    869 #if H_3D
    870 #if !HHI_INTER_COMP_PRED_K0052
    871   m_apcSlicePilot->init3dToolParameters();
    872 #endif
    873 #endif
    874737  pps->setSPS(sps);
    875738  pps->setNumSubstreams(pps->getEntropyCodingSyncEnabledFlag() ? ((sps->getPicHeightInLumaSamples() + sps->getMaxCUHeight() - 1) / sps->getMaxCUHeight()) * (pps->getNumTileColumnsMinus1() + 1) : 1);
     
    1098961  xActivateParameterSets();
    1099962
    1100 #if SONY_MV_V_CONST_C0078
     963#if H_MV
    1101964  //Check Multiview Main profile constraint in G.11.1.1
    1102965  //  When ViewOrderIdx[ i ] derived according to any active VPS is equal to 1
     
    12301093  pcPic->setViewIndex( getViewIndex() );
    12311094  pcPic->setIsDepth  ( getIsDepth  () );
    1232 #endif
    1233 #endif
    1234 #if HHI_RES_PRED_K0052
    12351095  pcSlice->setIvPicLists( m_ivPicLists );         
    12361096#endif
     1097#endif
     1098
     1099
     1100
    12371101
    12381102  if (bNextSlice)
     
    12711135
    12721136#if H_3D
    1273 #if !HHI_RES_PRED_K0052
    1274     pcSlice->setIvPicLists( m_ivPicLists );         
    1275 #endif
    1276 
    1277 #if HHI_INTER_COMP_PRED_K0052
    12781137    pcSlice->checkInCompPredRefLayers();
    12791138#if H_3D_IV_MERGE
     
    12841143#endif
    12851144#endif   
    1286 #else
    1287 #if H_3D_IV_MERGE
    1288 #if H_3D_FCO
    1289     //assert( !getIsDepth() );
    1290 #else
    1291     assert( !getIsDepth() || ( pcSlice->getTexturePic() != 0 ) );
    1292 #endif
    1293 #endif   
    1294 #endif
    12951145#endif
    12961146#if H_MV
  • branches/HTM-14.0-dev0/source/Lib/TLibDecoder/TDecTop.h

    r1179 r1185  
    9797  TComVPS* m_vps;
    9898  Int**    m_receivedIdc;
    99 #if!HHI_CAM_PARA_K0052
    100   Int      m_uiMaxViewIndex;
    101 #endif
    10299  Int      m_lastPoc;
    103100  Int      m_firstReceivedPoc;
     
    244241  Bool                    m_isDepth;
    245242  CamParsCollector*       m_pcCamParsCollector;
    246 #endif
    247 #if H_3D_ANNEX_SELECTION_FIX
    248243  Int                     m_profileIdc;
    249244#endif
     
    305300  Bool                    getIsDepth            ()               { return m_isDepth;    }
    306301  Void                    setCamParsCollector( CamParsCollector* pcCamParsCollector ) { m_pcCamParsCollector = pcCamParsCollector; }
    307 #endif
    308 #if H_3D_ANNEX_SELECTION_FIX
     302
    309303  Void                    setProfileIdc()
    310304  {       
     
    331325  Bool                    decProcAnnexI()           { assert( m_profileIdc != -1 ); return ( m_profileIdc == 8); }   
    332326#endif
    333 
    334327#endif
    335328protected:
  • branches/HTM-14.0-dev0/source/Lib/TLibEncoder/TEncCavlc.cpp

    r1179 r1185  
    4040#include "SEIwrite.h"
    4141#include "../TLibCommon/TypeDef.h"
    42 #if H_3D_ANNEX_SELECTION_FIX
     42#if H_3D
    4343#include "TEncTop.h"
    4444#endif
     
    862862  WRITE_FLAG( pcPPS->getPocResetInfoPresentFlag( ) ? 1 : 0 , "poc_reset_info_present_flag" );
    863863  WRITE_FLAG( pcPPS->getPpsInferScalingListFlag( ) ? 1 : 0 , "pps_infer_scaling_list_flag" );
    864 #if FIX_TICKET_95
    865864  if (pcPPS->getPpsInferScalingListFlag())
    866865  {
    867866    WRITE_CODE( pcPPS->getPpsScalingListRefLayerId( ), 6, "pps_scaling_list_ref_layer_id" );
    868867  }
    869 #else   
    870   WRITE_CODE( pcPPS->getPpsScalingListRefLayerId( ), 6, "pps_scaling_list_ref_layer_id" );
    871 #endif
    872868  WRITE_UVLC( 0, "num_ref_loc_offsets" );
    873869  WRITE_FLAG( 0 , "colour_mapping_enabled_flag" );
     
    901897      WRITE_FLAG( sps3dExt->getQtPredFlag( d ) ? 1 : 0 , "qt_pred_flag" );
    902898      WRITE_FLAG( sps3dExt->getInterSdcFlag( d ) ? 1 : 0 , "inter_sdc_flag" );
    903 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    904899      WRITE_FLAG( sps3dExt->getDepthIntraSkipFlag( d ) ? 1 : 0 , "intra_skip_flag" );
    905 #else
    906       WRITE_FLAG( sps3dExt->getIntraSingleFlag( d ) ? 1 : 0 , "intra_single_flag" );
    907 #endif
    908900    }
    909901  }
     
    16141606Void TEncCavlc::codeVPS3dExtension( TComVPS* pcVPS )
    16151607{
    1616 #if HHI_CAM_PARA_K0052
    16171608  WRITE_UVLC( pcVPS->getCpPrecision( ), "cp_precision" );
    16181609  for (Int n = 1; n < pcVPS->getNumViews(); n++)
     
    16401631    }
    16411632  } 
    1642 #else
    1643   WRITE_UVLC( pcVPS->getCamParPrecision(), "cp_precision" );
    1644   for (UInt viewIndex=1; viewIndex<pcVPS->getNumViews(); viewIndex++)
    1645   {
    1646     WRITE_FLAG( pcVPS->getCamParPresent(viewIndex) ? 1 : 0, "cp_present_flag[i]" );
    1647     if ( pcVPS->getCamParPresent(viewIndex) )
    1648     {
    1649       WRITE_FLAG( pcVPS->hasCamParInSliceHeader(viewIndex) ? 1 : 0, "cp_in_slice_segment_header_flag[i]" );
    1650       if ( !pcVPS->hasCamParInSliceHeader(viewIndex) )
    1651       {
    1652         for( UInt uiIndex = 0; uiIndex < viewIndex; uiIndex++ )
    1653         {
    1654           WRITE_SVLC( pcVPS->getCodedScale    (viewIndex)[ uiIndex ],                                               "vps_cp_scale" );
    1655           WRITE_SVLC( pcVPS->getCodedOffset   (viewIndex)[ uiIndex ],                                               "vps_cp_off" );
    1656           WRITE_SVLC( pcVPS->getInvCodedScale (viewIndex)[ uiIndex ] + pcVPS->getCodedScale (viewIndex)[ uiIndex ], "vps_cp_inv_scale_plus_scale" );
    1657           WRITE_SVLC( pcVPS->getInvCodedOffset(viewIndex)[ uiIndex ] + pcVPS->getCodedOffset(viewIndex)[ uiIndex ], "vps_cp_inv_off_plus_off" );
    1658         }
    1659       }
    1660     }
    1661   }
    1662 #endif
    16631633}
    16641634#endif
     
    19451915#endif
    19461916
    1947 #if HHI_INTER_COMP_PRED_K0052
    19481917#if H_3D     
    19491918  if( getEncTop()->decProcAnnexI() )
     
    19541923      }
    19551924  }
    1956 #endif
    19571925#endif
    19581926    if(pcSlice->getSPS()->getUseSAO())
     
    20862054    }
    20872055#if H_3D_IC
    2088 #if H_3D_ANNEX_SELECTION_FIX
    20892056    else if( pcSlice->getViewIndex() && ( pcSlice->getSliceType() == P_SLICE || pcSlice->getSliceType() == B_SLICE )
    20902057      && !pcSlice->getIsDepth() && vps->getNumRefListLayers( layerId ) > 0
    20912058      && getEncTop()->decProcAnnexI()       
    20922059      )
    2093 #else
    2094     else if( pcSlice->getViewIndex() && ( pcSlice->getSliceType() == P_SLICE || pcSlice->getSliceType() == B_SLICE ) && !pcSlice->getIsDepth() && vps->getNumRefListLayers( layerId ) > 0 )
    2095 #endif
    20962060    {
    20972061      WRITE_FLAG( pcSlice->getApplyIC() ? 1 : 0, "slice_ic_enable_flag" );
     
    21482112      WRITE_FLAG(pcSlice->getLFCrossSliceBoundaryFlag()?1:0, "slice_loop_filter_across_slices_enabled_flag");
    21492113    }
    2150 #if HHI_CAM_PARA_K0052
    21512114#if H_3D
    21522115    if (getEncTop()->decProcAnnexI() )
     
    21662129    }
    21672130#endif
    2168 #endif
    2169   }
    2170 
    2171 #if !HHI_CAM_PARA_K0052 
    2172 #if H_3D
    2173 #if H_3D_FCO
    2174   if( pcSlice->getVPS()->hasCamParInSliceHeader( pcSlice->getViewIndex() ) && pcSlice->getIsDepth() )
    2175 #else
    2176   if( pcSlice->getVPS()->hasCamParInSliceHeader( pcSlice->getViewIndex() ) && !pcSlice->getIsDepth() )
    2177 #endif
    2178   {
    2179     for( UInt uiId = 0; uiId < pcSlice->getViewIndex(); uiId++ )
    2180     {
    2181       WRITE_SVLC( pcSlice->getCodedScale    ()[ uiId ],                                     "cp_scale" );
    2182       WRITE_SVLC( pcSlice->getCodedOffset   ()[ uiId ],                                     "cp_off" );
    2183       WRITE_SVLC( pcSlice->getInvCodedScale ()[ uiId ] + pcSlice->getCodedScale ()[ uiId ], "cp_inv_scale_plus_scale" );
    2184       WRITE_SVLC( pcSlice->getInvCodedOffset()[ uiId ] + pcSlice->getCodedOffset()[ uiId ], "cp_inv_off_plus_off" );
    2185     }
    2186   }
    2187 #endif
    2188 #endif
     2131  }
     2132
    21892133
    21902134
     
    25322476  assert(0);
    25332477}
    2534 
    2535 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2478#if H_3D
    25362479Void TEncCavlc::codeDIS( TComDataCU* pcCU, UInt uiAbsPartIdx )
    25372480{
    25382481  assert(0);
    25392482}
    2540 #else
    2541 #if H_3D_SINGLE_DEPTH
    2542 Void TEncCavlc::codeSingleDepthMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
    2543 {
    2544   assert(0);
    2545 }
    2546 #endif
    25472483#endif
    25482484
  • branches/HTM-14.0-dev0/source/Lib/TLibEncoder/TEncCavlc.h

    r1179 r1185  
    6868  TComSlice*    m_pcSlice;
    6969  UInt          m_uiCoeffCost;
    70 #if H_3D_ANNEX_SELECTION_FIX
     70#if H_3D
    7171  TEncTop*      m_encTop;
    7272#endif
     
    129129  Void codeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx );
    130130  Void codeSkipFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx );
    131 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     131#if H_3D
    132132  Void codeDIS           ( TComDataCU* pcCU, UInt uiAbsPartIdx );
    133 #else
    134 #if H_3D_SINGLE_DEPTH
    135   Void codeSingleDepthMode( TComDataCU* pcCU, UInt uiAbsPartIdx );
    136 #endif
    137133#endif
    138134  Void codeMergeFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx );
     
    187183  Void codeDFFlag       ( UInt uiCode, const Char *pSymbolName );
    188184  Void codeDFSvlc       ( Int   iCode, const Char *pSymbolName );
    189 #if H_3D_ANNEX_SELECTION_FIX
     185#if H_3D
    190186  TEncTop* getEncTop()               { return m_encTop; };
    191187  Void     setEncTop( TEncTop* et )  {  m_encTop = et; };
  • branches/HTM-14.0-dev0/source/Lib/TLibEncoder/TEncCfg.h

    r1179 r1185  
    7878  Int m_interViewRefPosL[2][MAX_NUM_REF_PICS]; 
    7979#endif
    80 #if HHI_INTER_COMP_PRED_K0052
     80#if H_3D
    8181  Bool m_interCompPredFlag;
    8282#endif
     
    9898  , m_numActiveRefLayerPics(0)
    9999#endif
    100 #if HHI_INTER_COMP_PRED_K0052
    101100#if H_3D
    102101  , m_interCompPredFlag(false)
    103 #endif
    104102#endif
    105103  {
     
    188186  Int       m_iSearchRange;                     //  0:Full frame
    189187  Int       m_bipredSearchRange;
    190 #if SONY_MV_V_CONST_C0078
     188#if H_MV
    191189  Bool      m_bUseDisparitySearchRangeRestriction;
    192190  Int       m_iVerticalDisparitySearchRange;
     
    380378
    381379  //====== Camera Parameters ======
    382 #if !HHI_CAM_PARA_K0052
    383   UInt      m_uiCamParPrecision;
    384   Bool      m_bCamParInSliceHeader;
    385   Int**     m_aaiCodedScale;
    386   Int**     m_aaiCodedOffset;
    387 #endif
    388380  TAppComCamPara* m_cameraParameters;
    389381 
     
    418410  Bool      m_bUseQTL;
    419411#endif
    420 #if H_3D_ANNEX_SELECTION_FIX
     412
    421413  Int m_profileIdc;
    422 #endif
    423414
    424415#endif
     
    435426  , m_isDepth(false)
    436427  , m_bUseVSO(false)
    437 #if H_3D_ANNEX_SELECTION_FIX
    438428  , m_profileIdc( -1 )
    439 #endif
    440429#endif
    441430#endif
     
    522511  Void      setSearchRange                  ( Int   i )      { m_iSearchRange = i; }
    523512  Void      setBipredSearchRange            ( Int   i )      { m_bipredSearchRange = i; }
    524 #if SONY_MV_V_CONST_C0078
     513#if H_MV
    525514  Void      setUseDisparitySearchRangeRestriction ( Bool   b )      { m_bUseDisparitySearchRangeRestriction = b; }
    526515  Void      setVerticalDisparitySearchRange ( Int   i )      { m_iVerticalDisparitySearchRange = i; }
     
    578567  Int       getFastSearch                   ()      { return  m_iFastSearch; }
    579568  Int       getSearchRange                  ()      { return  m_iSearchRange; }
    580 #if SONY_MV_V_CONST_C0078
     569#if H_MV
    581570  Bool      getUseDisparitySearchRangeRestriction ()      { return  m_bUseDisparitySearchRangeRestriction; }
    582571  Int       getVerticalDisparitySearchRange ()            { return  m_iVerticalDisparitySearchRange; }
     
    923912
    924913 //==== CAMERA PARAMETERS  ==========
    925 #if !HHI_CAM_PARA_K0052
    926   Void      setCamParPrecision              ( UInt  u )      { m_uiCamParPrecision      = u; }
    927   Void      setCamParInSliceHeader          ( Bool  b )      { m_bCamParInSliceHeader   = b; }
    928   Void      setCodedScale                   ( Int** p )      { m_aaiCodedScale          = p; }
    929   Void      setCodedOffset                  ( Int** p )      { m_aaiCodedOffset         = p; }
    930 #endif
    931914  Void      setCameraParameters             ( TAppComCamPara* c) { m_cameraParameters   = c; }
    932915
     
    976959  Bool      getUseQTL                       ()         { return m_bUseQTL; }
    977960#endif
    978 #if H_3D_ANNEX_SELECTION_FIX
    979961  Void                    setProfileIdc( Int a )    { assert( a == 1 || a == 6 || a == 8 ); m_profileIdc = a;  }
    980962  Bool                    decProcAnnexI()           { assert( m_profileIdc != -1 ); return ( m_profileIdc == 8); }   
    981 #endif
    982963
    983964#endif // H_3D
  • branches/HTM-14.0-dev0/source/Lib/TLibEncoder/TEncCu.cpp

    r1179 r1185  
    441441#if H_3D_VSP
    442442  DisInfo DvInfo;
    443 #if !SEC_ARP_REM_ENC_RESTRICT_K0035
    444   DvInfo.bDV = false;
    445 #endif
    446443  DvInfo.m_acNBDV.setZero();
    447444  DvInfo.m_aVIdxCan = 0;
     
    589586          if (rpcTempCU->getSlice()->getIsDepth() )
    590587          {
    591 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    592588            rpcTempCU->getDispforDepth(0, 0, &DvInfo);
    593 #else
    594             DvInfo.bDV = rpcTempCU->getDispforDepth(0, 0, &DvInfo);
    595 #endif
    596589          }
    597590          else
     
    600593#if H_3D_NBDV_REF
    601594          if( rpcTempCU->getSlice()->getDepthRefinementFlag() )
    602 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    603595            rpcTempCU->getDisMvpCandNBDV(&DvInfo, true);
    604 #else
    605             DvInfo.bDV = rpcTempCU->getDisMvpCandNBDV(&DvInfo, true);
    606 #endif
    607596          else
    608597#endif
    609 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    610598            rpcTempCU->getDisMvpCandNBDV(&DvInfo);
    611 #else
    612             DvInfo.bDV = rpcTempCU->getDisMvpCandNBDV(&DvInfo);
    613 #endif
    614599
    615600#if H_3D_IV_MERGE
     
    730715    }
    731716#endif
    732 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     717#if H_3D
    733718    rpcTempCU->initEstData( uiDepth, iMinQP, isAddLowestQP  );
    734719    if( rpcBestCU->getSlice()->getDepthIntraSkipFlag() )
     
    737722      rpcTempCU->initEstData( uiDepth, iMinQP, isAddLowestQP  );
    738723    }
    739 #else
    740 #if H_3D_SINGLE_DEPTH
    741     rpcTempCU->initEstData( uiDepth, iMinQP, isAddLowestQP  );
    742     if( rpcBestCU->getSlice()->getIntraSingleFlag() )
    743     {
    744       xCheckRDCostSingleDepth( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
    745       rpcTempCU->initEstData( uiDepth, iMinQP, isAddLowestQP  );
    746     }
    747 #endif
    748724#endif
    749725    if(!earlyDetectionSkipMode)
     
    10581034          // speedup for inter frames
    10591035          if( rpcBestCU->getSlice()->getSliceType() == I_SLICE ||
    1060               rpcBestCU->getCbf( 0, TEXT_LUMA     ) != 0   ||
    1061               rpcBestCU->getCbf( 0, TEXT_CHROMA_U ) != 0   ||
    1062               rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) != 0     
     1036            rpcBestCU->getCbf( 0, TEXT_LUMA     ) != 0   ||
     1037            rpcBestCU->getCbf( 0, TEXT_CHROMA_U ) != 0   ||
     1038            rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) != 0     
    10631039#if H_3D_DIM_ENC
    1064               || rpcBestCU->getSlice()->getIsDepth()
     1040            || rpcBestCU->getSlice()->getIsDepth()
    10651041#endif
    10661042            ) // avoid very complex intra if it is unlikely
     
    10681044#if H_3D_DIM
    10691045            Bool bOnlyIVP = false;
    1070 #if TICKET083_IVPFLAG_FIX
    10711046            Bool bUseIVP = true;
    1072 #endif
    10731047            if( rpcBestCU->getSlice()->getIsDepth() && !(rpcBestCU->getSlice()->isIRAP()) &&
    1074                 rpcBestCU->getSlice()->getSliceType() != I_SLICE &&
    1075                 rpcBestCU->getCbf( 0, TEXT_LUMA     ) == 0 &&
    1076                 rpcBestCU->getCbf( 0, TEXT_CHROMA_U ) == 0 &&
    1077                 rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) == 0
     1048              rpcBestCU->getSlice()->getSliceType() != I_SLICE &&
     1049              rpcBestCU->getCbf( 0, TEXT_LUMA     ) == 0 &&
     1050              rpcBestCU->getCbf( 0, TEXT_CHROMA_U ) == 0 &&
     1051              rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) == 0
    10781052              )
    10791053            {
    10801054              bOnlyIVP = true;
    1081 #if TICKET083_IVPFLAG_FIX
    10821055              bUseIVP = rpcBestCU->getSlice()->getIntraContourFlag();
    1083 #endif
    10841056            }
    1085 #if TICKET083_IVPFLAG_FIX
    10861057            if( bUseIVP )
    10871058            {
    1088 #endif
    1089             xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bOnlyIVP );
     1059              xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bOnlyIVP );
    10901060#else
    10911061            xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
     
    11201090#endif
    11211091            }
    1122 #if TICKET083_IVPFLAG_FIX
     1092#if H_3D
    11231093          }
    11241094#endif
    1125           }
     1095        }
    11261096        // test PCM
    11271097        if(pcPic->getSlice(0)->getSPS()->getUsePCM()
     
    16071577    return;
    16081578  }
    1609 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     1579#if H_3D
    16101580  m_pcEntropyCoder->encodeDIS( pcCU, uiAbsPartIdx );
    16111581  if(!pcCU->getDISFlag(uiAbsPartIdx))
    1612   {
    1613 #else
    1614 #if H_3D_SINGLE_DEPTH
    1615   m_pcEntropyCoder->encodeSingleDepthMode( pcCU, uiAbsPartIdx );
    1616   if(!pcCU->getSingleDepthFlag(uiAbsPartIdx))
    1617   {
    1618 #endif
    1619 #endif
     1582#endif
     1583  {
    16201584  m_pcEntropyCoder->encodePredMode( pcCU, uiAbsPartIdx );
    16211585 
    16221586  m_pcEntropyCoder->encodePartSize( pcCU, uiAbsPartIdx, uiDepth );
    16231587 
    1624 #if !HHI_MOVE_SYN_K0052
    1625 #if H_3D_DIM_SDC
    1626   m_pcEntropyCoder->encodeSDCFlag( pcCU, uiAbsPartIdx, false );
    1627 #endif
    1628 #endif
    16291588  if (pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N )
    16301589  {
     
    16321591    if(pcCU->getIPCMFlag(uiAbsPartIdx))
    16331592    {
    1634 #if HHI_MOVE_SYN_K0052
    16351593#if H_3D_DIM_SDC
    16361594      m_pcEntropyCoder->encodeSDCFlag( pcCU, uiAbsPartIdx, false );
    16371595#endif 
    1638 #endif
    16391596      // Encode slice finish
    16401597      finishCU(pcCU,uiAbsPartIdx,uiDepth);
     
    16451602  // prediction Info ( Intra : direction mode, Inter : Mv, reference idx )
    16461603  m_pcEntropyCoder->encodePredInfo( pcCU, uiAbsPartIdx );
    1647 #if HHI_MOVE_SYN_K0052
    16481604  m_pcEntropyCoder->encodeDBBPFlag( pcCU, uiAbsPartIdx );
    16491605#if H_3D_DIM_SDC
    16501606  m_pcEntropyCoder->encodeSDCFlag( pcCU, uiAbsPartIdx, false );
    16511607#endif 
    1652 #endif
    16531608#if H_3D_ARP
    16541609  m_pcEntropyCoder->encodeARPW( pcCU , uiAbsPartIdx );
     
    16651620#endif
    16661621  setdQPFlag( bCodeDQP );
    1667 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    1668   }
    1669 #else
    1670 #if H_3D_SINGLE_DEPTH
    1671   }
    1672 #endif
     1622#if H_3D
     1623  }
    16731624#endif
    16741625  // --- write terminating bit ---
     
    18891840#if H_3D_ARP
    18901841  Int nARPWMax = rpcTempCU->getSlice()->getARPStepNum() - 1;
    1891 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    18921842  if( nARPWMax < 0 || bICFlag )
    1893 #else
    1894   if( nARPWMax < 0 || !rpcTempCU->getDvInfo(0).bDV || bICFlag )
    1895 #endif
    18961843  {
    18971844    nARPWMax = 0;
     
    20592006
    20602007          rpcTempCU->setSkipFlagSubParts( rpcTempCU->getQtRootCbf(0) == 0, 0, uhDepth );
    2061 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2008#if H_3D
    20622009          rpcTempCU->setDISFlagSubParts( false, 0, uhDepth );
    2063 #else
    2064 #if H_3D_SINGLE_DEPTH
    2065           rpcTempCU->setSingleDepthFlagSubParts( false, 0, uhDepth );
    2066 #endif
    20672010#endif
    20682011#if H_3D_VSP // possible bug fix
     
    21052048              }
    21062049              rpcTempCU->setSkipFlagSubParts( false, 0, uhDepth );
    2107 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2050#if H_3D
    21082051              rpcTempCU->setDISFlagSubParts( false, 0, uhDepth );
    2109 #else
    2110 #if H_3D_SINGLE_DEPTH
    2111               rpcTempCU->setSingleDepthFlagSubParts( false, 0, uhDepth );
    2112 #endif
    21132052#endif
    21142053              rpcTempCU->setTrIdxSubParts( 0, 0, uhDepth );
     
    22332172  Bool bFirstTime = true;
    22342173  Int nARPWMax    = rpcTempCU->getSlice()->getARPStepNum() - 1;
    2235 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    22362174  if( nARPWMax < 0 || ePartSize != SIZE_2Nx2N || rpcTempCU->getICFlag(0) )
    2237 #else
    2238   if( nARPWMax < 0 || ePartSize != SIZE_2Nx2N || !rpcTempCU->getDvInfo(0).bDV || rpcTempCU->getICFlag(0) )
    2239 #endif
    22402175  {
    22412176    nARPWMax = 0;
     
    22632198 
    22642199  rpcTempCU->setSkipFlagSubParts( false, 0, uhDepth );
    2265 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2200#if H_3D
    22662201  rpcTempCU->setDISFlagSubParts( false, 0, uhDepth );
    2267 #else
    2268 #if H_3D_SINGLE_DEPTH
    2269   rpcTempCU->setSingleDepthFlagSubParts( false, 0, uhDepth );
    2270 #endif
    22712202#endif
    22722203  rpcTempCU->setPartSizeSubParts  ( ePartSize,  0, uhDepth );
     
    23772308      }
    23782309      rpcTempCU->setSkipFlagSubParts( false, 0, uhDepth );
    2379 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2310#if H_3D
    23802311      rpcTempCU->setDISFlagSubParts( false, 0, uhDepth );
    2381 #else
    2382 #if H_3D_SINGLE_DEPTH
    2383       rpcTempCU->setSingleDepthFlagSubParts( false, 0, uhDepth );
    2384 #endif
    23852312#endif
    23862313      rpcTempCU->setTrIdxSubParts( 0, 0, uhDepth );
     
    24922419}
    24932420
    2494 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    24952421Void TEncCu::xCheckRDCostDIS( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize eSize )
    24962422{
     
    25642490  xCheckBestMode(rpcBestCU, rpcTempCU, uiDepth);
    25652491}
    2566 #else
    2567 #if H_3D_SINGLE_DEPTH
    2568 Void TEncCu::xCheckRDCostSingleDepth( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize eSize )
    2569 {
    2570   UInt uiDepth = rpcTempCU->getDepth( 0 );
    2571   if( !rpcBestCU->getSlice()->getIsDepth() || (eSize != SIZE_2Nx2N))
    2572   {
    2573     return;
    2574   }
    2575  
    2576 #if H_3D_VSO // M5
    2577   if( m_pcRdCost->getUseRenModel() )
    2578   {
    2579     UInt  uiWidth     = m_ppcOrigYuv[uiDepth]->getWidth   ();
    2580     UInt  uiHeight    = m_ppcOrigYuv[uiDepth]->getHeight  ();
    2581     Pel*  piSrc       = m_ppcOrigYuv[uiDepth]->getLumaAddr();
    2582     UInt  uiSrcStride = m_ppcOrigYuv[uiDepth]->getStride  ();
    2583     m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
    2584   }
    2585 #endif
    2586 
    2587   rpcTempCU->setSkipFlagSubParts( false, 0, uiDepth );
    2588   rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uiDepth );
    2589   rpcTempCU->setPredModeSubParts( MODE_INTRA, 0, uiDepth );
    2590   rpcTempCU->setCUTransquantBypassSubParts( rpcTempCU->getCUTransquantBypass(0), 0, uiDepth );
    2591 
    2592   rpcTempCU->setTrIdxSubParts(0, 0, uiDepth);
    2593   rpcTempCU->setCbfSubParts(0, 1, 1, 0, uiDepth);
    2594   rpcTempCU->setSingleDepthFlagSubParts(true, 0, uiDepth);
    2595   rpcTempCU->setLumaIntraDirSubParts (DC_IDX, 0, uiDepth);
    2596 #if H_3D_DIM_SDC
    2597   rpcTempCU->setSDCFlagSubParts( false, 0, uiDepth);
    2598 #endif
    2599 
    2600   UInt uiPreCalcDistC;
    2601   m_pcPredSearch  ->estIntraPredSingleDepth      ( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth], uiPreCalcDistC, false );
    2602 
    2603 
    2604   m_ppcRecoYuvTemp[uiDepth]->copyToPicLuma(rpcTempCU->getPic()->getPicYuvRec(), rpcTempCU->getAddr(), rpcTempCU->getZorderIdxInCU() );
    2605  
    2606  
    2607   m_pcEntropyCoder->resetBits();
    2608   if ( rpcTempCU->getSlice()->getPPS()->getTransquantBypassEnableFlag())
    2609   {
    2610     m_pcEntropyCoder->encodeCUTransquantBypassFlag( rpcTempCU, 0,          true );
    2611   }
    2612   m_pcEntropyCoder->encodeSkipFlag ( rpcTempCU, 0,          true );
    2613   m_pcEntropyCoder->encodeSingleDepthMode( rpcTempCU, 0,          true );
    2614  
    2615 
    2616   m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
    2617  
    2618   rpcTempCU->getTotalBits() = m_pcEntropyCoder->getNumberOfWrittenBits();
    2619   rpcTempCU->getTotalBins() = ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
    2620 
    2621 
    2622 #if H_3D_VSO // M6
    2623   if( m_pcRdCost->getUseLambdaScaleVSO()) 
    2624     rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() ); 
    2625   else
    2626 #endif
    2627   rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
    2628  
    2629 
    2630   xCheckDQP( rpcTempCU );
    2631   xCheckBestMode(rpcBestCU, rpcTempCU, uiDepth);
    2632 }
    2633 #endif
    2634 #endif
    26352492
    26362493Void TEncCu::xCheckRDCostInterDBBP( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, Bool bUseMRG )
     
    26752532  AOF( uiDepthStride != 0 );
    26762533 
    2677 #if HS_DBBP_CLEAN_K0048
    26782534  PartSize eVirtualPartSize = m_pcPredSearch->getPartitionSizeFromDepth(pDepthPels, uiDepthStride, uiWidth, rpcTempCU);
    26792535
     
    26812537  Bool pMask[MAX_CU_SIZE*MAX_CU_SIZE];
    26822538  Bool bValidMask = m_pcPredSearch->getSegmentMaskFromDepth(pDepthPels, uiDepthStride, uiWidth, uiHeight, pMask, rpcTempCU);
    2683 #else
    2684   PartSize eVirtualPartSize = m_pcPredSearch->getPartitionSizeFromDepth(pDepthPels, uiDepthStride, uiWidth);
    2685  
    2686   // derive segmentation mask from depth
    2687   Bool pMask[MAX_CU_SIZE*MAX_CU_SIZE];
    2688   Bool bValidMask = m_pcPredSearch->getSegmentMaskFromDepth(pDepthPels, uiDepthStride, uiWidth, uiHeight, pMask);
    2689 #endif
    26902539 
    26912540  if( !bValidMask )
     
    27962645
    27972646  rpcTempCU->setSkipFlagSubParts( false, 0, uiDepth );
    2798 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2647#if H_3D
    27992648  rpcTempCU->setDISFlagSubParts( false, 0, uiDepth );
    2800 #else
    2801 #if H_3D_SINGLE_DEPTH
    2802   rpcTempCU->setSingleDepthFlagSubParts( false, 0, uiDepth );
    2803 #endif
    28042649#endif
    28052650  rpcTempCU->setPartSizeSubParts( eSize, 0, uiDepth );
     
    28202665 
    28212666#if H_3D_DIM_SDC
    2822 #if 0 // H_3D_DISABLE_CHROMA
    2823   if( !rpcTempCU->getSDCFlag( 0 ) && !rpcTempCU->getSlice()->getIsDepth() )
    2824 #else
    28252667  if( !rpcTempCU->getSDCFlag( 0 ) )
    2826 #endif
    28272668#endif
    28282669  m_pcPredSearch  ->estIntraPredChromaQT( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth], uiPreCalcDistC );
     
    28342675  }
    28352676  m_pcEntropyCoder->encodeSkipFlag ( rpcTempCU, 0,          true );
    2836 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2677#if H_3D
    28372678  m_pcEntropyCoder->encodeDIS( rpcTempCU, 0,          true );
    28382679  if(!rpcTempCU->getDISFlag(0))
    28392680  {
    2840 #else
    2841 #if H_3D_SINGLE_DEPTH
    2842   m_pcEntropyCoder->encodeSingleDepthMode( rpcTempCU, 0,          true );
    2843   if(!rpcTempCU->getSingleDepthFlag(0))
    2844   {
    2845 #endif
    28462681#endif
    28472682  m_pcEntropyCoder->encodePredMode( rpcTempCU, 0,          true );
    28482683  m_pcEntropyCoder->encodePartSize( rpcTempCU, 0, uiDepth, true );
    2849 #if !HHI_MOVE_SYN_K0052
     2684  m_pcEntropyCoder->encodePredInfo( rpcTempCU, 0,          true );
     2685  m_pcEntropyCoder->encodeIPCMInfo(rpcTempCU, 0, true );
    28502686#if H_3D_DIM_SDC
    28512687  m_pcEntropyCoder->encodeSDCFlag( rpcTempCU, 0, true );
    2852 #endif
    2853 #endif
    2854   m_pcEntropyCoder->encodePredInfo( rpcTempCU, 0,          true );
    2855   m_pcEntropyCoder->encodeIPCMInfo(rpcTempCU, 0, true );
    2856 #if HHI_MOVE_SYN_K0052
    2857 #if H_3D_DIM_SDC
    2858   m_pcEntropyCoder->encodeSDCFlag( rpcTempCU, 0, true );
    2859 #endif
    28602688#endif
    28612689
     
    28702698
    28712699  setdQPFlag( bCodeDQP );
    2872 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    2873   }
    2874 #else
    2875 #if H_3D_SINGLE_DEPTH
    2876   }
    2877 #endif
     2700#if H_3D
     2701  }
    28782702#endif
    28792703  m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
     
    29042728
    29052729  rpcTempCU->setSkipFlagSubParts( false, 0, uiDepth );
    2906 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2730#if H_3D
    29072731  rpcTempCU->setDISFlagSubParts( false, 0, uiDepth );
    2908 #else
    2909 #if H_3D_SINGLE_DEPTH
    2910   rpcTempCU->setSingleDepthFlagSubParts( false, 0, uiDepth );
    2911 #endif
    29122732#endif
    29132733  rpcTempCU->setIPCMFlag(0, true);
     
    29272747  }
    29282748  m_pcEntropyCoder->encodeSkipFlag ( rpcTempCU, 0,          true );
    2929 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2749#if H_3D
    29302750  m_pcEntropyCoder->encodeDIS( rpcTempCU, 0,          true );
    2931 #else
    2932 #if H_3D_SINGLE_DEPTH
    2933   m_pcEntropyCoder->encodeSingleDepthMode( rpcTempCU, 0,          true );
    2934 #endif
    29352751#endif
    29362752  m_pcEntropyCoder->encodePredMode ( rpcTempCU, 0,          true );
    29372753  m_pcEntropyCoder->encodePartSize ( rpcTempCU, 0, uiDepth, true );
    2938 #if !HHI_MOVE_SYN_K0052
     2754  m_pcEntropyCoder->encodeIPCMInfo ( rpcTempCU, 0, true );
    29392755#if H_3D_DIM_SDC
    29402756  m_pcEntropyCoder->encodeSDCFlag( rpcTempCU, 0, true );
    2941 #endif
    2942 #endif
    2943   m_pcEntropyCoder->encodeIPCMInfo ( rpcTempCU, 0, true );
    2944 #if HHI_MOVE_SYN_K0052
    2945 #if H_3D_DIM_SDC
    2946   m_pcEntropyCoder->encodeSDCFlag( rpcTempCU, 0, true );
    2947 #endif
    29482757#endif
    29492758  m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
  • branches/HTM-14.0-dev0/source/Lib/TLibEncoder/TEncCu.h

    r1179 r1185  
    159159  Void  xCheckRDCostInterDBBP( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, Bool bUseMRG = false );
    160160#endif
    161 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     161#if H_3D
    162162  Void  xCheckRDCostDIS   ( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize  );
    163 #else
    164 #if H_3D_SINGLE_DEPTH
    165   Void  xCheckRDCostSingleDepth   ( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize  );
    166 #endif
    167163#endif
    168164#if H_3D_DIM
  • branches/HTM-14.0-dev0/source/Lib/TLibEncoder/TEncEntropy.cpp

    r1179 r1185  
    111111  m_pcEntropyCoderIf->codeSkipFlag( pcCU, uiAbsPartIdx );
    112112}
    113 
    114 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     113#if H_3D
    115114Void TEncEntropy::encodeDIS( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
    116115{
     
    125124  m_pcEntropyCoderIf->codeDIS( pcCU, uiAbsPartIdx );
    126125}
    127 #else
    128 #if H_3D_SINGLE_DEPTH
    129 Void TEncEntropy::encodeSingleDepthMode( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
    130 {
    131   if(!pcCU->getSlice()->getIntraSingleFlag() )
    132   {
    133     return;
    134   }
    135   if( bRD )
    136   {
    137     uiAbsPartIdx = 0;
    138   }
    139   m_pcEntropyCoderIf->codeSingleDepthMode( pcCU, uiAbsPartIdx );
    140 }
    141 #endif
    142 #endif
    143 
     126#endif
    144127/** encode merge flag
    145128 * \param pcCU
     
    271254  m_pcEntropyCoderIf->codePartSize( pcCU, uiAbsPartIdx, uiDepth );
    272255 
    273 #if !HHI_MOVE_SYN_K0052
    274 #if H_3D_DBBP
    275   if( pcCU->getSlice()->getDepthBasedBlkPartFlag() && (pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2NxN || pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_Nx2N) && pcCU->getWidth(uiAbsPartIdx) > 8 && pcCU->getSlice()->getDefaultRefViewIdxAvailableFlag() )
    276   {
    277     encodeDBBPFlag(pcCU, uiAbsPartIdx, bRD);
    278   }
    279 #endif
    280 #endif
    281256}
    282257
     
    904879Void TEncEntropy::encodeDBBPFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
    905880{
    906 #if HHI_MOVE_SYN_K0052
    907881  if( pcCU->getSlice()->getDepthBasedBlkPartFlag() &&
    908882    ( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2NxN ||
     
    911885      pcCU->getSlice()->getDefaultRefViewIdxAvailableFlag() )
    912886  {
    913 #endif
    914887    if( bRD )
    915888    {
     
    917890    }
    918891    m_pcEntropyCoderIf->codeDBBPFlag( pcCU, uiAbsPartIdx );
    919 #if HHI_MOVE_SYN_K0052
    920   }
    921 #endif
     892  }
    922893}
    923894#endif
  • branches/HTM-14.0-dev0/source/Lib/TLibEncoder/TEncEntropy.h

    r1179 r1185  
    8282  virtual Void codeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
    8383  virtual Void codeSkipFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
    84 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     84#if H_3D
    8585  virtual Void codeDIS          ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
    86 #else
    87 #if H_3D_SINGLE_DEPTH
    88   virtual Void codeSingleDepthMode      ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
    89 #endif
    9086#endif
    9187  virtual Void codeMergeFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
     
    179175  Void encodeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
    180176  Void encodeSkipFlag          ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
    181 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     177#if H_3D
    182178  Void encodeDIS               ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD=false );
    183 #else
    184 #if H_3D_SINGLE_DEPTH
    185   Void encodeSingleDepthMode( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD=false );
    186 #endif
    187179#endif
    188180  Void encodePUWise       ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
  • branches/HTM-14.0-dev0/source/Lib/TLibEncoder/TEncGOP.cpp

    r1179 r1185  
    395395Void TEncGOP::initGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP)
    396396{
    397 #if H_MV_ALIGN_HM_15
    398397  xInitGOP( iPOCLast, iNumPicRcvd, rcListPic, rcListPicYuvRecOut, false );
    399 #else
    400   xInitGOP( iPOCLast, iNumPicRcvd, rcListPic, rcListPicYuvRecOut );
    401 #endif
    402398  m_iNumPicCoded = 0;
    403399}
     
    885881    Int numDirectRefLayers = vps    ->getNumDirectRefLayers( getLayerId() );
    886882#endif
    887 #if HHI_INTER_COMP_PRED_K0052
     883#if H_3D
    888884    pcSlice->setIvPicLists( m_ivPicLists );         
    889885
     
    893889    GOPEntry gopEntry      = m_pcCfg->getGOPEntry( (pcSlice->getRapPicFlag() && getLayerId() > 0) ? MAX_GOP : iGOPid );     
    894890#endif
     891
     892
    895893   
    896894    Bool interLayerPredLayerIdcPresentFlag = false;
     
    929927    assert( pcSlice->getNumActiveRefLayerPics() == gopEntry.m_numActiveRefLayerPics );
    930928   
    931 #if HHI_INTER_COMP_PRED_K0052
    932929#if H_3D
    933930    if ( m_pcEncTop->decProcAnnexI() )
     
    962959    pcSlice->setMaxNumMergeCand      ( m_pcCfg->getMaxNumMergeCand()   + ( ( pcSlice->getMpiFlag( ) || pcSlice->getIvMvPredFlag( ) || pcSlice->getViewSynthesisPredFlag( )   ) ? 1 : 0 ));
    963960#endif
    964 #endif
    965961
    966962    pcSlice->createInterLayerReferencePictureSet( m_ivPicLists, m_refPicSetInterLayer0, m_refPicSetInterLayer1 );
     
    10091005      }
    10101006    }
    1011 #endif
    1012 #if !HHI_INTER_COMP_PRED_K0052
    1013 #if H_3D
    1014     pcSlice->setIvPicLists( m_ivPicLists );         
    1015 #if H_3D_IV_MERGE   
    1016     assert( !m_pcEncTop->getIsDepth() || ( pcSlice->getTexturePic() != 0 ) );
    1017 #endif   
    1018 #endif
    10191007#endif
    10201008#if H_3D_IC
  • branches/HTM-14.0-dev0/source/Lib/TLibEncoder/TEncSbac.cpp

    r1179 r1185  
    5858, m_cCUSplitFlagSCModel       ( 1,             1,               NUM_SPLIT_FLAG_CTX            , m_contextModels + m_numContextModels, m_numContextModels )
    5959, m_cCUSkipFlagSCModel        ( 1,             1,               NUM_SKIP_FLAG_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
    60 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     60#if H_3D
    6161, m_cCUDISFlagSCModel         ( 1,             1,               NUM_DIS_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
    6262, m_cCUDISTypeSCModel         ( 1,             1,               NUM_DIS_TYPE_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
    63 #else
    64 #if H_3D_SINGLE_DEPTH
    65 , m_cCUSingleDepthFlagSCModel        ( 1,             1,               NUM_SINGLEDEPTH_FLAG_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
    66 , m_cSingleDepthValueSCModel         ( 1,             1,               NUM_SINGLE_DEPTH_VALUE_DATA_CTX      , m_contextModels + m_numContextModels, m_numContextModels)
    67 #endif
    6863#endif
    6964, m_cCUMergeFlagExtSCModel    ( 1,             1,               NUM_MERGE_FLAG_EXT_CTX        , m_contextModels + m_numContextModels, m_numContextModels)
     
    139134 
    140135  m_cCUSkipFlagSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
    141 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     136#if H_3D
    142137  m_cCUDISFlagSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DIS_FLAG );
    143138  m_cCUDISTypeSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DIS_TYPE );
    144 #else
    145 #if H_3D_SINGLE_DEPTH
    146   m_cCUSingleDepthFlagSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SINGLEDEPTH_FLAG );
    147   m_cSingleDepthValueSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_SINGLE_DEPTH_VALUE_DATA );
    148 #endif
    149139#endif
    150140  m_cCUMergeFlagExtSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT);
     
    224214      curCost  = m_cCUSplitFlagSCModel.calcCost       ( curSliceType, qp, (UChar*)INIT_SPLIT_FLAG );
    225215      curCost += m_cCUSkipFlagSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_SKIP_FLAG );
    226 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     216#if H_3D
    227217      curCost += m_cCUDISFlagSCModel.calcCost         ( curSliceType, qp, (UChar*)INIT_DIS_FLAG );
    228218      curCost += m_cCUDISTypeSCModel.calcCost         ( curSliceType, qp, (UChar*)INIT_DIS_TYPE );
    229 #else
    230 #if H_3D_SINGLE_DEPTH
    231       curCost += m_cCUSingleDepthFlagSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_SINGLEDEPTH_FLAG );
    232       curCost += m_cSingleDepthValueSCModel.calcCost         ( curSliceType, qp, (UChar*)INIT_SINGLE_DEPTH_VALUE_DATA );
    233 #endif
    234219#endif
    235220      curCost += m_cCUMergeFlagExtSCModel.calcCost    ( curSliceType, qp, (UChar*)INIT_MERGE_FLAG_EXT);
     
    302287 
    303288  m_cCUSkipFlagSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
    304 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     289#if H_3D
    305290  m_cCUDISFlagSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DIS_FLAG );
    306291  m_cCUDISTypeSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DIS_TYPE );
    307 #else
    308 #if H_3D_SINGLE_DEPTH
    309   m_cCUSingleDepthFlagSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SINGLEDEPTH_FLAG );
    310   m_cSingleDepthValueSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_SINGLE_DEPTH_VALUE_DATA );
    311 #endif
    312292#endif
    313293  m_cCUMergeFlagExtSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT);
     
    466446  m_pcBinIf->encodeBinsEP( bins, numBins );
    467447}
    468 
    469 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     448#if H_3D
    470449Void TEncSbac::codeDIS( TComDataCU* pcCU, UInt uiAbsPartIdx )
    471450{
     
    498477  }
    499478}
    500 #else
    501 #if H_3D_SINGLE_DEPTH
    502 Void TEncSbac::codeSingleDepthMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
    503 {
    504   UInt uiSymbol = pcCU->getSingleDepthFlag(uiAbsPartIdx ) ? 1 : 0;
    505   m_pcBinIf->encodeBin( uiSymbol, m_cCUSingleDepthFlagSCModel.get( 0, 0, 0 ) );
    506   if(uiSymbol)
    507   {
    508     UInt uiUnaryIdx = (UInt) pcCU->getSingleDepthValue(uiAbsPartIdx);
    509     UInt uiNumCand = SINGLE_DEPTH_MODE_CAND_LIST_SIZE;
    510     if ( uiNumCand > 1 )
    511     {
    512       for( UInt ui = 0; ui < uiNumCand - 1; ++ui )
    513       {
    514         const UInt uiSymbol2 = ui == uiUnaryIdx ? 0 : 1;
    515         if ( ui==0 )
    516         {
    517           m_pcBinIf->encodeBin( uiSymbol2, m_cSingleDepthValueSCModel.get( 0, 0, 0 ) );
    518         }
    519         else
    520         {
    521           m_pcBinIf->encodeBinEP( uiSymbol2 );
    522         }
    523         if( uiSymbol2 == 0 )
    524         {
    525           break;
    526         }
    527       }
    528     }
    529   }
    530 }
    531 #endif
    532 #endif
    533 
     479#endif
    534480/** Coding of coeff_abs_level_minus3
    535481 * \param uiSymbol value of coeff_abs_level_minus3
  • branches/HTM-14.0-dev0/source/Lib/TLibEncoder/TEncSbac.h

    r1179 r1185  
    146146  Void codeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx );
    147147  Void codeSkipFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx );
    148 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     148#if H_3D
    149149  Void codeDIS           ( TComDataCU* pcCU, UInt uiAbsPartIdx );
    150 #else
    151 #if H_3D_SINGLE_DEPTH
    152   Void codeSingleDepthMode( TComDataCU* pcCU, UInt uiAbsPartIdx );
    153 #endif
    154150#endif
    155151  Void codeMergeFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx );
     
    219215  ContextModel3DBuffer m_cCUSplitFlagSCModel;
    220216  ContextModel3DBuffer m_cCUSkipFlagSCModel;
    221 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     217#if H_3D
    222218  ContextModel3DBuffer m_cCUDISFlagSCModel;
    223219  ContextModel3DBuffer m_cCUDISTypeSCModel;
    224 #else
    225 #if H_3D_SINGLE_DEPTH
    226   ContextModel3DBuffer m_cCUSingleDepthFlagSCModel;
    227   ContextModel3DBuffer m_cSingleDepthValueSCModel;
    228 #endif
    229220#endif
    230221  ContextModel3DBuffer m_cCUMergeFlagExtSCModel;
  • branches/HTM-14.0-dev0/source/Lib/TLibEncoder/TEncSearch.cpp

    r1179 r1185  
    915915        }
    916916        m_pcEntropyCoder->encodeSkipFlag( pcCU, 0, true );
    917 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     917#if H_3D
    918918        m_pcEntropyCoder->encodeDIS(pcCU, 0, true );
    919919        if(!pcCU->getDISFlag(uiAbsPartIdx))
    920 #else
    921 #if H_3D_SINGLE_DEPTH
    922         m_pcEntropyCoder->encodeSingleDepthMode(pcCU, 0, true );
    923         if(!pcCU->getSingleDepthFlag(uiAbsPartIdx))
    924 #endif
    925920#endif
    926921          m_pcEntropyCoder->encodePredMode( pcCU, 0, true );
    927922      }
    928 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     923#if H_3D
    929924      else
    930925      {
    931926        m_pcEntropyCoder->encodeDIS(pcCU, 0, true );
    932927      }
    933 #else
    934 #if H_3D_SINGLE_DEPTH
    935       else
    936       {
    937         m_pcEntropyCoder->encodeSingleDepthMode(pcCU, 0, true );
    938       }
    939 #endif
    940 #endif
    941 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     928#endif
     929#if H_3D
    942930      if(!pcCU->getDISFlag(uiAbsPartIdx))
    943931      {
    944 #else
    945 #if H_3D_SINGLE_DEPTH
    946       if(!pcCU->getSingleDepthFlag(uiAbsPartIdx))
    947       {
    948 #endif
    949932#endif
    950933        m_pcEntropyCoder  ->encodePartSize( pcCU, 0, pcCU->getDepth(0), true );
    951934
    952 #if !HHI_MOVE_SYN_K0052
    953 #if H_3D_DIM_SDC
    954         m_pcEntropyCoder->encodeSDCFlag( pcCU, 0, true );
    955 #endif
    956 #endif
    957935        if (pcCU->isIntra(0) && pcCU->getPartitionSize(0) == SIZE_2Nx2N )
    958936        {
     
    960938          if ( pcCU->getIPCMFlag (0))
    961939          {
    962 #if HHI_MOVE_SYN_K0052
    963940#if H_3D_DIM_SDC
    964941            m_pcEntropyCoder->encodeSDCFlag( pcCU, 0, true );
    965942#endif
    966 #endif
    967943            return;
    968944          }
    969945        }
    970 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    971       }
    972 #else
    973 #if H_3D_SINGLE_DEPTH
    974       }
    975 #endif
    976 #endif
    977     }
    978 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     946#if H_3D
     947      }
     948#endif
     949    }
     950#if H_3D
    979951    if(!pcCU->getDISFlag(uiAbsPartIdx))
    980952    {
    981 #else
    982 #if H_3D_SINGLE_DEPTH
    983     if(!pcCU->getSingleDepthFlag(uiAbsPartIdx))
    984     {
    985 #endif
    986953#endif
    987954      // luma prediction mode
     
    992959          m_pcEntropyCoder->encodeIntraDirModeLuma ( pcCU, 0 );
    993960#if H_3D_DIM_SDC
    994 #if HHI_MOVE_SYN_K0052
    995 #if H_3D_DIM_SDC
    996961          m_pcEntropyCoder->encodeSDCFlag( pcCU, 0, true );</