Changeset 1196 in 3DVCSoftware


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

Merged 14.0-dev0@1187.

Location:
trunk/source
Files:
48 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/App/TAppDecoder/TAppDecTop.cpp

    r1179 r1196  
    248248            {
    249249              m_tDecTop[decIdx]->setTargetOptLayerSetIdx( m_targetOptLayerSetIdx );
    250 #if H_3D_ANNEX_SELECTION_FIX
     250#if H_3D
    251251              m_tDecTop[decIdx]->setProfileIdc( );
    252252#endif
    … …  
    10531053    m_tDecTop[ decIdx ]->setLayerInitilizedFlags( m_layerInitilizedFlags );
    10541054    m_tDecTop[ decIdx ]->setTargetOptLayerSetIdx( m_targetOptLayerSetIdx );   
    1055 #if H_3D_ANNEX_SELECTION_FIX
     1055#if H_3D
    10561056    m_tDecTop[ decIdx ]->setProfileIdc           ( );   
    10571057#endif

  • trunk/source/App/TAppEncoder/TAppEncCfg.cpp

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

  • trunk/source/App/TAppEncoder/TAppEncCfg.h

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

  • trunk/source/App/TAppEncoder/TAppEncTop.cpp

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

  • trunk/source/App/TAppEncoder/TAppEncTop.h

    r1179 r1196  
    142142  Void xSetDpbSize                ( TComVPS& vps );
    143143  Void xSetVPSVUI                 ( TComVPS& vps );
    144 #if HHI_CAM_PARA_K0052
    145144#if H_3D
    146145  Void xSetCamPara                ( TComVPS& vps );
    147 #endif
    148146#endif
    149147  GOPEntry* xGetGopEntry( Int layerIdInVps, Int poc );

  • trunk/source/Lib/TAppCommon/TAppComCamPara.cpp

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

  • trunk/source/Lib/TAppCommon/TAppComCamPara.h

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

  • trunk/source/Lib/TLibCommon/ContextTables.h

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

  • trunk/source/Lib/TLibCommon/TComDataCU.cpp

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

  • trunk/source/Lib/TLibCommon/TComDataCU.h

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

  • trunk/source/Lib/TLibCommon/TComMotionInfo.cpp

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

  • trunk/source/Lib/TLibCommon/TComMotionInfo.h

    r1179 r1196  
    6363typedef struct _DisCand
    6464{
    65 #if !SEC_ARP_REM_ENC_RESTRICT_K0035
    66   Bool bDV;
    67 #endif
    6865  TComMv m_acNBDV;              // DV from NBDV
    6966#if H_3D_NBDV_REF

  • trunk/source/Lib/TLibCommon/TComPrediction.cpp

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

  • trunk/source/Lib/TLibCommon/TComPrediction.h

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

  • trunk/source/Lib/TLibCommon/TComRdCost.cpp

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

  • trunk/source/Lib/TLibCommon/TComRdCost.h

    r1179 r1196  
    320320  static UInt xGetMaskedSSE     ( DistParam* pcDtParam );
    321321  static UInt xGetMaskedSAD     ( DistParam* pcDtParam );
    322 #if !RWTH_DBBP_NO_SATD_K0028
    323   static UInt xGetMaskedHADs    ( DistParam* pcDtParam );
    324 #endif
    325322  static UInt xGetMaskedVSD     ( DistParam* pcDtParam );
    326323#endif

  • trunk/source/Lib/TLibCommon/TComRom.cpp

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

  • trunk/source/Lib/TLibCommon/TComRom.h

    r1179 r1196  
    290290
    291291#if H_MV_ENC_DEC_TRAC
    292 #define DTRACE_CU(x,y)            
    293 #define DTRACE_PU(x,y)            
    294 #define DTRACE_TU(x,y)            
    295 
    296 #define DTRACE_CU_S(x)            
    297 #define DTRACE_PU_S(x)            
    298 #define DTRACE_TU_S(x)            
     292#define DTRACE_CU(x,y) ;            
     293#define DTRACE_PU(x,y) ;           
     294#define DTRACE_TU(x,y) ;           
     295
     296#define DTRACE_CU_S(x) ;           
     297#define DTRACE_PU_S(x) ;           
     298#define DTRACE_TU_S(x) ;           
    299299
    300300#endif

  • trunk/source/Lib/TLibCommon/TComSlice.cpp

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

  • trunk/source/Lib/TLibCommon/TComSlice.h

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

  • trunk/source/Lib/TLibCommon/TComWedgelet.cpp

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

  • trunk/source/Lib/TLibCommon/TComWedgelet.h

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

  • trunk/source/Lib/TLibCommon/TypeDef.h

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

  • trunk/source/Lib/TLibDecoder/TDecCAVLC.cpp

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

  • trunk/source/Lib/TLibDecoder/TDecCAVLC.h

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

  • trunk/source/Lib/TLibDecoder/TDecCu.cpp

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

  • trunk/source/Lib/TLibDecoder/TDecCu.h

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

  • trunk/source/Lib/TLibDecoder/TDecEntropy.cpp

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

  • trunk/source/Lib/TLibDecoder/TDecEntropy.h

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

  • trunk/source/Lib/TLibDecoder/TDecGop.h

    r1179 r1196  
    6363// Class definition
    6464// ====================================================================================================================
    65 #if H_3D_ANNEX_SELECTION_FIX
     65#if H_3D
    6666class TDecTop;
    6767#endif
    … …  
    8383  TDecSlice*            m_pcSliceDecoder;
    8484  TComLoopFilter*       m_pcLoopFilter;
    85 #if H_3D_ANNEX_SELECTION_FIX
     85#if H_3D
    8686  TDecTop*              m_decTop;
    8787#endif

  • trunk/source/Lib/TLibDecoder/TDecSbac.cpp

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

  • trunk/source/Lib/TLibDecoder/TDecSbac.h

    r1179 r1196  
    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;

  • trunk/source/Lib/TLibDecoder/TDecTop.cpp

    r1179 r1196  
    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
    386 
    387 
    388292}
    389293
    … …  
    408312    if( iPOC == m_firstReceivedPoc )
    409313    {
    410 #if HHI_CAM_PARA_K0052
    411314      fprintf( m_pCodedScaleOffsetFile, "#ViewOrderIdx     ViewIdVal\n" );
    412315      fprintf( m_pCodedScaleOffsetFile, "#------------ -------------\n" );
    … …  
    436339                m_aaiCodedScale [ baseVoiInVps ][ voiInVps ],
    437340                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
    475341            }           
    476342          }
    … …  
    481347}
    482348#endif
     349
    483350TDecTop::TDecTop()
    484351{
    … …  
    556423  initROM();
    557424#endif
    558 #if H_3D_ANNEX_SELECTION_FIX
     425#if H_3D
    559426  m_cCavlcDecoder.setDecTop( this );
    560427#endif
    … …  
    867734
    868735#endif
    869 #if H_3D
    870 #if !HHI_INTER_COMP_PRED_K0052
    871   m_apcSlicePilot->init3dToolParameters();
    872 #endif
    873 #endif
    874736  pps->setSPS(sps);
    875737  pps->setNumSubstreams(pps->getEntropyCodingSyncEnabledFlag() ? ((sps->getPicHeightInLumaSamples() + sps->getMaxCUHeight() - 1) / sps->getMaxCUHeight()) * (pps->getNumTileColumnsMinus1() + 1) : 1);
    … …  
    1098960  xActivateParameterSets();
    1099961
    1100 #if SONY_MV_V_CONST_C0078
     962#if H_MV
    1101963  //Check Multiview Main profile constraint in G.11.1.1
    1102964  //  When ViewOrderIdx[ i ] derived according to any active VPS is equal to 1
    … …  
    12301092  pcPic->setViewIndex( getViewIndex() );
    12311093  pcPic->setIsDepth  ( getIsDepth  () );
    1232 #endif
    1233 #endif
    1234 #if HHI_RES_PRED_K0052
    12351094  pcSlice->setIvPicLists( m_ivPicLists );         
    12361095#endif
     1096#endif
     1097
     1098
     1099
    12371100
    12381101  if (bNextSlice)
    … …  
    12711134
    12721135#if H_3D
    1273 #if !HHI_RES_PRED_K0052
    1274     pcSlice->setIvPicLists( m_ivPicLists );         
    1275 #endif
    1276 
    1277 #if HHI_INTER_COMP_PRED_K0052
    12781136    pcSlice->checkInCompPredRefLayers();
    12791137#if H_3D_IV_MERGE
    … …  
    12841142#endif
    12851143#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
    12951144#endif
    12961145#if H_MV
    … …  
    13471196#if  H_3D_TMVP
    13481197    if(pcSlice->getLayerId())
     1198    {
    13491199      pcSlice->generateAlterRefforTMVP();
     1200    }
    13501201#endif
    13511202  }
    … …  
    18001651}
    18011652
    1802 #if H_MV
    18031653Void TDecTop::xCeckNoClrasOutput()
    18041654{
    … …  
    18341684  return allRefLayersInitilizedFlag;
    18351685}
     1686
     1687#if H_3D
     1688Void TDecTop::setProfileIdc()
     1689{
     1690  if (m_targetOptLayerSetIdx != -1 )
     1691  {   
     1692    TComVPS* vps = getPrefetchedVPS();
     1693    Int lsIdx = vps->olsIdxToLsIdx( m_targetOptLayerSetIdx );
     1694    Int lIdx = -1;
     1695    for (Int j = 0; j < vps->getNumLayersInIdList( lsIdx ); j++ )
     1696    {
     1697      if ( vps->getLayerSetLayerIdList( lsIdx, j ) == getLayerId() )
     1698      {
     1699        lIdx = j;
     1700        break;
     1701      }       
     1702    }
     1703    assert( lIdx != -1 );
     1704
     1705    Int profileIdc = vps->getPTL( vps->getProfileTierLevelIdx( m_targetOptLayerSetIdx, lIdx ) )->getGeneralPTL()->getProfileIdc();
     1706    assert( profileIdc == 1 || profileIdc == 6 || profileIdc == 8 );
     1707    m_profileIdc = profileIdc;   
     1708  };
     1709}
    18361710#endif
    18371711#endif

  • trunk/source/Lib/TLibDecoder/TDecTop.h

    r1179 r1196  
    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
    309   Void                    setProfileIdc()
    310   {       
    311     if (m_targetOptLayerSetIdx != -1 )
    312     {   
    313       TComVPS* vps = getPrefetchedVPS();
    314       Int lsIdx = vps->olsIdxToLsIdx( m_targetOptLayerSetIdx );
    315       Int lIdx = -1;
    316       for (Int j = 0; j < vps->getNumLayersInIdList( lsIdx ); j++ )
    317       {
    318         if ( vps->getLayerSetLayerIdList( lsIdx, j ) == getLayerId() )
    319         {
    320           lIdx = j;
    321           break;
    322         }       
    323       }
    324       assert( lIdx != -1 );
    325 
    326       Int profileIdc = vps->getPTL( vps->getProfileTierLevelIdx( m_targetOptLayerSetIdx, lIdx ) )->getGeneralPTL()->getProfileIdc();
    327       assert( profileIdc == 1 || profileIdc == 6 || profileIdc == 8 );
    328       m_profileIdc = profileIdc;   
    329     };
    330   }
     302
     303  Void                    setProfileIdc();
    331304  Bool                    decProcAnnexI()           { assert( m_profileIdc != -1 ); return ( m_profileIdc == 8); }   
    332305#endif
    333 
    334306#endif
    335307protected:

  • trunk/source/Lib/TLibEncoder/TEncCavlc.cpp

    r1179 r1196  
    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

  • trunk/source/Lib/TLibEncoder/TEncCavlc.h

    r1179 r1196  
    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; };

  • trunk/source/Lib/TLibEncoder/TEncCfg.h

    r1179 r1196  
    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

  • trunk/source/Lib/TLibEncoder/TEncCu.cpp

    r1179 r1196  
    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;
    … …  
    544541        TComDataCU* pcTextureCU = pcTexture->getCU( rpcBestCU->getAddr() ); //Corresponding texture LCU
    545542        UInt uiCUIdx            = rpcBestCU->getZorderIdxInCU();
    546         assert(pcTextureCU->getDepth(uiCUIdx) >= uiDepth); //Depth cannot be more partitionned than the texture.
     543        assert(pcTextureCU->getDepth(uiCUIdx) >= uiDepth); //Depth cannot be more partitioned than the texture.
    547544        if (pcTextureCU->getDepth(uiCUIdx) > uiDepth || pcTextureCU->getPartitionSize(uiCUIdx) == SIZE_NxN) //Texture was split.
    548545        {
    … …  
    559556          {
    560557            if(pcTextureCU->getPartitionSize(uiCUIdx)==SIZE_2NxN || pcTextureCU->getPartitionSize(uiCUIdx)==SIZE_2NxnU|| pcTextureCU->getPartitionSize(uiCUIdx)==SIZE_2NxnD)
     558            {
    561559              bTry2NxN  = true;
     560            }
    562561            else
     562            {
    563563              bTryNx2N  = true;
     564            }
    564565          }
    565566        }
    … …  
    589590          if (rpcTempCU->getSlice()->getIsDepth() )
    590591          {
    591 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    592592            rpcTempCU->getDispforDepth(0, 0, &DvInfo);
    593 #else
    594             DvInfo.bDV = rpcTempCU->getDispforDepth(0, 0, &DvInfo);
    595 #endif
    596593          }
    597594          else
    … …  
    599596#endif
    600597#if H_3D_NBDV_REF
    601           if( rpcTempCU->getSlice()->getDepthRefinementFlag() )
    602 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    603             rpcTempCU->getDisMvpCandNBDV(&DvInfo, true);
    604 #else
    605             DvInfo.bDV = rpcTempCU->getDisMvpCandNBDV(&DvInfo, true);
    606 #endif
    607           else
     598            if( rpcTempCU->getSlice()->getDepthRefinementFlag() )
     599            {
     600              rpcTempCU->getDisMvpCandNBDV(&DvInfo, true);
     601            }
     602            else
    608603#endif
    609 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    610             rpcTempCU->getDisMvpCandNBDV(&DvInfo);
    611 #else
    612             DvInfo.bDV = rpcTempCU->getDisMvpCandNBDV(&DvInfo);
    613 #endif
    614 
     604            {
     605              rpcTempCU->getDisMvpCandNBDV(&DvInfo);
     606            }
    615607#if H_3D_IV_MERGE
    616608          }
    … …  
    639631          Bool bICFlag = uiICId ? true : false;
    640632#endif
    641         // 2Nx2N
    642         if(m_pcEncCfg->getUseEarlySkipDetection())
    643         {
     633          // 2Nx2N
     634          if(m_pcEncCfg->getUseEarlySkipDetection())
     635          {
     636#if H_3D_IC
     637            rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
     638#endif
     639#if  H_3D_FAST_TEXTURE_ENCODING
     640            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bFMD );  rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode  );//by Competition for inter_2Nx2N
     641#else
     642            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
     643            rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );//by Competition for inter_2Nx2N
     644#endif
     645#if H_3D_VSP
     646            rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
     647#endif
     648          }
     649          // SKIP
    644650#if H_3D_IC
    645651          rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
    646652#endif
     653          xCheckRDCostMerge2Nx2N( rpcBestCU, rpcTempCU, &earlyDetectionSkipMode );//by Merge for inter_2Nx2N
    647654#if  H_3D_FAST_TEXTURE_ENCODING
    648           xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bFMD );  rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode  );//by Competition for inter_2Nx2N
    649 #else
    650           xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
    651           rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );//by Competition for inter_2Nx2N
    652 #endif
     655          bFMD = bIVFMerge && rpcBestCU->isSkipped(0);
     656#endif
     657          rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    653658#if H_3D_VSP
    654659          rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    655660#endif
    656         }
    657         // SKIP
    658 #if H_3D_IC
    659         rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
    660 #endif
    661         xCheckRDCostMerge2Nx2N( rpcBestCU, rpcTempCU, &earlyDetectionSkipMode );//by Merge for inter_2Nx2N
    662 #if  H_3D_FAST_TEXTURE_ENCODING
    663         bFMD = bIVFMerge && rpcBestCU->isSkipped(0);
    664 #endif
    665         rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    666 #if H_3D_VSP
    667         rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    668 #endif
    669 
    670         if(!m_pcEncCfg->getUseEarlySkipDetection())
    671         {
    672           // 2Nx2N, NxN
     661
     662          if(!m_pcEncCfg->getUseEarlySkipDetection())
     663          {
     664            // 2Nx2N, NxN
    673665#if H_3D_IC
    674666            rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
    … …  
    677669            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bFMD );  rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    678670#else
    679           xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
    680           rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
     671            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
     672            rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    681673#endif
    682674#if H_3D_VSP
    683675            rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    684676#endif
    685          
     677
    686678#if H_3D_DBBP
    687           if( rpcTempCU->getSlice()->getDepthBasedBlkPartFlag() && rpcTempCU->getSlice()->getDefaultRefViewIdxAvailableFlag() )
    688           {
    689             xCheckRDCostInterDBBP( rpcBestCU, rpcTempCU, false );
    690             rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode  );
     679            if( rpcTempCU->getSlice()->getDepthBasedBlkPartFlag() && rpcTempCU->getSlice()->getDefaultRefViewIdxAvailableFlag() )
     680            {
     681              xCheckRDCostInterDBBP( rpcBestCU, rpcTempCU, false );
     682              rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode  );
    691683#if H_3D_VSP
    692             rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    693 #endif
    694           }
    695 #endif
    696          
     684              rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
     685#endif
     686            }
     687#endif
    697688            if(m_pcEncCfg->getUseCbfFastMode())
    698689            {
    699690              doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
    700691            }
    701         }
     692          }
    702693#if H_3D_IC
    703694        }
    … …  
    730721    }
    731722#endif
    732 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     723#if H_3D
    733724    rpcTempCU->initEstData( uiDepth, iMinQP, isAddLowestQP  );
    734725    if( rpcBestCU->getSlice()->getDepthIntraSkipFlag() )
    … …  
    737728      rpcTempCU->initEstData( uiDepth, iMinQP, isAddLowestQP  );
    738729    }
    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
    748730#endif
    749731    if(!earlyDetectionSkipMode)
    … …  
    10581040          // speedup for inter frames
    10591041          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     
     1042            rpcBestCU->getCbf( 0, TEXT_LUMA     ) != 0   ||
     1043            rpcBestCU->getCbf( 0, TEXT_CHROMA_U ) != 0   ||
     1044            rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) != 0     
    10631045#if H_3D_DIM_ENC
    1064               || rpcBestCU->getSlice()->getIsDepth()
     1046            || rpcBestCU->getSlice()->getIsDepth()
    10651047#endif
    10661048            ) // avoid very complex intra if it is unlikely
    … …  
    10681050#if H_3D_DIM
    10691051            Bool bOnlyIVP = false;
    1070 #if TICKET083_IVPFLAG_FIX
    10711052            Bool bUseIVP = true;
    1072 #endif
    10731053            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
     1054              rpcBestCU->getSlice()->getSliceType() != I_SLICE &&
     1055              rpcBestCU->getCbf( 0, TEXT_LUMA     ) == 0 &&
     1056              rpcBestCU->getCbf( 0, TEXT_CHROMA_U ) == 0 &&
     1057              rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) == 0
    10781058              )
    10791059            {
    10801060              bOnlyIVP = true;
    1081 #if TICKET083_IVPFLAG_FIX
    10821061              bUseIVP = rpcBestCU->getSlice()->getIntraContourFlag();
    1083 #endif
    10841062            }
    1085 #if TICKET083_IVPFLAG_FIX
    10861063            if( bUseIVP )
    10871064            {
    1088 #endif
    1089             xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bOnlyIVP );
     1065              xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bOnlyIVP );
    10901066#else
    10911067            xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
    … …  
    11201096#endif
    11211097            }
    1122 #if TICKET083_IVPFLAG_FIX
     1098#if H_3D
    11231099          }
    11241100#endif
    1125           }
     1101        }
    11261102        // test PCM
    11271103        if(pcPic->getSlice(0)->getSPS()->getUsePCM()
    … …  
    16071583    return;
    16081584  }
    1609 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     1585#if H_3D
    16101586  m_pcEntropyCoder->encodeDIS( pcCU, uiAbsPartIdx );
    16111587  if(!pcCU->getDISFlag(uiAbsPartIdx))
    16121588  {
    1613 #else
    1614 #if H_3D_SINGLE_DEPTH
    1615   m_pcEntropyCoder->encodeSingleDepthMode( pcCU, uiAbsPartIdx );
    1616   if(!pcCU->getSingleDepthFlag(uiAbsPartIdx))
    1617   {
    1618 #endif
    1619 #endif
     1589#endif
     1590
    16201591  m_pcEntropyCoder->encodePredMode( pcCU, uiAbsPartIdx );
    16211592 
    16221593  m_pcEntropyCoder->encodePartSize( pcCU, uiAbsPartIdx, uiDepth );
    16231594 
    1624 #if !HHI_MOVE_SYN_K0052
    1625 #if H_3D_DIM_SDC
    1626   m_pcEntropyCoder->encodeSDCFlag( pcCU, uiAbsPartIdx, false );
    1627 #endif
    1628 #endif
    16291595  if (pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N )
    16301596  {
    … …  
    16321598    if(pcCU->getIPCMFlag(uiAbsPartIdx))
    16331599    {
    1634 #if HHI_MOVE_SYN_K0052
    16351600#if H_3D_DIM_SDC
    16361601      m_pcEntropyCoder->encodeSDCFlag( pcCU, uiAbsPartIdx, false );
    16371602#endif 
    1638 #endif
    16391603      // Encode slice finish
    16401604      finishCU(pcCU,uiAbsPartIdx,uiDepth);
    … …  
    16451609  // prediction Info ( Intra : direction mode, Inter : Mv, reference idx )
    16461610  m_pcEntropyCoder->encodePredInfo( pcCU, uiAbsPartIdx );
    1647 #if HHI_MOVE_SYN_K0052
     1611#if H_3D
    16481612  m_pcEntropyCoder->encodeDBBPFlag( pcCU, uiAbsPartIdx );
     1613#endif
    16491614#if H_3D_DIM_SDC
    16501615  m_pcEntropyCoder->encodeSDCFlag( pcCU, uiAbsPartIdx, false );
    16511616#endif 
    1652 #endif
    16531617#if H_3D_ARP
    16541618  m_pcEntropyCoder->encodeARPW( pcCU , uiAbsPartIdx );
    … …  
    16651629#endif
    16661630  setdQPFlag( bCodeDQP );
    1667 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    1668   }
    1669 #else
    1670 #if H_3D_SINGLE_DEPTH
    1671   }
    1672 #endif
     1631#if H_3D
     1632  }
    16731633#endif
    16741634  // --- write terminating bit ---
    … …  
    18171777  Bool bICFlag = rpcTempCU->getICFlag( 0 );
    18181778#endif
    1819 #if H_3D_VSO // M1  //nececcary here?
     1779#if H_3D_VSO // M1  //necessary here?
    18201780  if( m_pcRdCost->getUseRenModel() )
    18211781  {
    … …  
    18891849#if H_3D_ARP
    18901850  Int nARPWMax = rpcTempCU->getSlice()->getARPStepNum() - 1;
    1891 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    18921851  if( nARPWMax < 0 || bICFlag )
    1893 #else
    1894   if( nARPWMax < 0 || !rpcTempCU->getDvInfo(0).bDV || bICFlag )
    1895 #endif
    18961852  {
    18971853    nARPWMax = 0;
    … …  
    19461902    {     
    19471903#if H_3D_IC
    1948         if( rpcTempCU->getSlice()->getApplyIC() && rpcTempCU->getSlice()->getIcSkipParseFlag() )
     1904      if( rpcTempCU->getSlice()->getApplyIC() && rpcTempCU->getSlice()->getIcSkipParseFlag() )
     1905      {
     1906        if( bICFlag && uiMergeCand == 0 )
    19491907        {
    1950           if( bICFlag && uiMergeCand == 0 )
    1951           {
    1952             continue;
    1953           }
     1908          continue;
    19541909        }
    1955 #endif
    1956         if(!(uiNoResidual==1 && mergeCandBuffer[uiMergeCand]==1))
    1957         {
     1910      }
     1911#endif
     1912      if(!(uiNoResidual==1 && mergeCandBuffer[uiMergeCand]==1))
     1913      {
    19581914        if( !(bestIsSkip && uiNoResidual == 0) )
    19591915        {
    … …  
    19941950#if H_3D_VSP
    19951951          {
    1996           if ( vspFlag[uiMergeCand] )
    1997           {
    1998             UInt partAddr;
    1999             Int vspSize;
    2000             Int width, height;
    2001             rpcTempCU->getPartIndexAndSize( 0, partAddr, width, height );
    2002             if( uhInterDirNeighbours[ uiMergeCand ] & 0x01 )
     1952            if ( vspFlag[uiMergeCand] )
    20031953            {
    2004               rpcTempCU->setMvFieldPUForVSP( rpcTempCU, partAddr, width, height, REF_PIC_LIST_0, cMvFieldNeighbours[ 2*uiMergeCand + 0 ].getRefIdx(), vspSize );
    2005               rpcTempCU->setVSPFlag( partAddr, vspSize );
     1954              UInt partAddr;
     1955              Int vspSize;
     1956              Int width, height;
     1957              rpcTempCU->getPartIndexAndSize( 0, partAddr, width, height );
     1958              if( uhInterDirNeighbours[ uiMergeCand ] & 0x01 )
     1959              {
     1960                rpcTempCU->setMvFieldPUForVSP( rpcTempCU, partAddr, width, height, REF_PIC_LIST_0, cMvFieldNeighbours[ 2*uiMergeCand + 0 ].getRefIdx(), vspSize );
     1961                rpcTempCU->setVSPFlag( partAddr, vspSize );
     1962              }
     1963              else
     1964              {
     1965                rpcTempCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMvFieldNeighbours[0 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
     1966              }
     1967              if( uhInterDirNeighbours[ uiMergeCand ] & 0x02 )
     1968              {
     1969                rpcTempCU->setMvFieldPUForVSP( rpcTempCU, partAddr, width, height, REF_PIC_LIST_1 , cMvFieldNeighbours[ 2*uiMergeCand + 1 ].getRefIdx(), vspSize );
     1970                rpcTempCU->setVSPFlag( partAddr, vspSize );
     1971              }
     1972              else
     1973              {
     1974                rpcTempCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMvFieldNeighbours[1 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
     1975              }
     1976              rpcTempCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeCand], 0, 0, uhDepth ); // interprets depth relative to LCU level
    20061977            }
    20071978            else
    20081979            {
     1980#endif
     1981              rpcTempCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeCand], 0, 0, uhDepth ); // interprets depth relative to LCU level
    20091982              rpcTempCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMvFieldNeighbours[0 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
     1983              rpcTempCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMvFieldNeighbours[1 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
     1984#if H_3D_VSP
    20101985            }
    2011             if( uhInterDirNeighbours[ uiMergeCand ] & 0x02 )
    2012             {
    2013               rpcTempCU->setMvFieldPUForVSP( rpcTempCU, partAddr, width, height, REF_PIC_LIST_1 , cMvFieldNeighbours[ 2*uiMergeCand + 1 ].getRefIdx(), vspSize );
    2014               rpcTempCU->setVSPFlag( partAddr, vspSize );
    2015             }
    2016             else
    2017             {
    2018               rpcTempCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMvFieldNeighbours[1 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
    2019             }
    2020             rpcTempCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeCand], 0, 0, uhDepth ); // interprets depth relative to LCU level
    20211986          }
    2022           else
     1987#endif
     1988          // do MC
     1989          m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
     1990          // estimate residual and encode everything
     1991#if H_3D_VSO //M2
     1992          if( m_pcRdCost->getUseRenModel() )
     1993          { //Reset
     1994            UInt  uiWidth     = m_ppcOrigYuv[uhDepth]->getWidth    ();
     1995            UInt  uiHeight    = m_ppcOrigYuv[uhDepth]->getHeight   ();
     1996            Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr ();
     1997            UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride   ();
     1998            m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
     1999          }
     2000#endif
     2001          m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
     2002            m_ppcOrigYuv    [uhDepth],
     2003            m_ppcPredYuvTemp[uhDepth],
     2004            m_ppcResiYuvTemp[uhDepth],
     2005            m_ppcResiYuvBest[uhDepth],
     2006            m_ppcRecoYuvTemp[uhDepth],
     2007            (uiNoResidual? true:false));
     2008
     2009
     2010          if ( uiNoResidual == 0 && rpcTempCU->getQtRootCbf(0) == 0 )
    20232011          {
    2024 #endif
    2025             rpcTempCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeCand], 0, 0, uhDepth ); // interprets depth relative to LCU level
    2026             rpcTempCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMvFieldNeighbours[0 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
    2027             rpcTempCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMvFieldNeighbours[1 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
    2028 #if H_3D_VSP
     2012            // If no residual when allowing for one, then set mark to not try case where residual is forced to 0
     2013            mergeCandBuffer[uiMergeCand] = 1;
    20292014          }
    2030         }
    2031 #endif
    2032        // do MC
    2033        m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
    2034        // estimate residual and encode everything
    2035 #if H_3D_VSO //M2
    2036        if( m_pcRdCost->getUseRenModel() )
    2037        { //Reset
    2038          UInt  uiWidth     = m_ppcOrigYuv[uhDepth]->getWidth    ();
    2039          UInt  uiHeight    = m_ppcOrigYuv[uhDepth]->getHeight   ();
    2040          Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr ();
    2041          UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride   ();
    2042          m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
    2043        }
    2044 #endif
    2045        m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
    2046          m_ppcOrigYuv    [uhDepth],
    2047          m_ppcPredYuvTemp[uhDepth],
    2048          m_ppcResiYuvTemp[uhDepth],
    2049          m_ppcResiYuvBest[uhDepth],
    2050          m_ppcRecoYuvTemp[uhDepth],
    2051          (uiNoResidual? true:false));
    2052 
    2053 
    2054           if ( uiNoResidual == 0 && rpcTempCU->getQtRootCbf(0) == 0 )
    2055          {
    2056             // If no residual when allowing for one, then set mark to not try case where residual is forced to 0
    2057            mergeCandBuffer[uiMergeCand] = 1;
    2058          }
    20592015
    20602016          rpcTempCU->setSkipFlagSubParts( rpcTempCU->getQtRootCbf(0) == 0, 0, uhDepth );
    2061 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2017#if H_3D
    20622018          rpcTempCU->setDISFlagSubParts( false, 0, uhDepth );
    2063 #else
    2064 #if H_3D_SINGLE_DEPTH
    2065           rpcTempCU->setSingleDepthFlagSubParts( false, 0, uhDepth );
    2066 #endif
    20672019#endif
    20682020#if H_3D_VSP // possible bug fix
    … …  
    21052057              }
    21062058              rpcTempCU->setSkipFlagSubParts( false, 0, uhDepth );
    2107 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2059#if H_3D
    21082060              rpcTempCU->setDISFlagSubParts( false, 0, uhDepth );
    2109 #else
    2110 #if H_3D_SINGLE_DEPTH
    2111               rpcTempCU->setSingleDepthFlagSubParts( false, 0, uhDepth );
    2112 #endif
    21132061#endif
    21142062              rpcTempCU->setTrIdxSubParts( 0, 0, uhDepth );
    … …  
    21522100          rpcTempCU->initEstData( uhDepth, orgQP, bTransquantBypassFlag );
    21532101
    2154       if( m_pcEncCfg->getUseFastDecisionForMerge() && !bestIsSkip )
     2102          if( m_pcEncCfg->getUseFastDecisionForMerge() && !bestIsSkip )
     2103          {
     2104#if H_3D_INTER_SDC
     2105            if( rpcTempCU->getSlice()->getInterSdcFlag() )
     2106            {
     2107              bestIsSkip = !rpcBestCU->getSDCFlag( 0 ) && ( rpcBestCU->getQtRootCbf(0) == 0 );
     2108            }
     2109            else
     2110            {
     2111#endif
     2112              bestIsSkip = rpcBestCU->getQtRootCbf(0) == 0;
     2113#if H_3D_INTER_SDC
     2114            }
     2115#endif
     2116          }
     2117        }
     2118      }
     2119    }
     2120
     2121    if(uiNoResidual == 0 && m_pcEncCfg->getUseEarlySkipDetection())
     2122    {
     2123      if(rpcBestCU->getQtRootCbf( 0 ) == 0)
    21552124      {
    2156 #if H_3D_INTER_SDC
    2157         if( rpcTempCU->getSlice()->getInterSdcFlag() )
     2125        if( rpcBestCU->getMergeFlag( 0 ))
    21582126        {
    2159           bestIsSkip = !rpcBestCU->getSDCFlag( 0 ) && ( rpcBestCU->getQtRootCbf(0) == 0 );
     2127          *earlyDetectionSkipMode = true;
    21602128        }
    21612129        else
    21622130        {
    2163 #endif
    2164         bestIsSkip = rpcBestCU->getQtRootCbf(0) == 0;
    2165 #if H_3D_INTER_SDC
    2166         }
    2167 #endif
    2168       }
    2169     }
    2170    }
    2171   }
    2172 
    2173   if(uiNoResidual == 0 && m_pcEncCfg->getUseEarlySkipDetection())
    2174   {
    2175     if(rpcBestCU->getQtRootCbf( 0 ) == 0)
    2176     {
    2177       if( rpcBestCU->getMergeFlag( 0 ))
    2178       {
    2179         *earlyDetectionSkipMode = true;
    2180       }
    2181       else
    2182       {
    2183         Int absoulte_MV=0;
    2184         for ( UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx++ )
    2185         {
    2186           if ( rpcBestCU->getSlice()->getNumRefIdx( RefPicList( uiRefListIdx ) ) > 0 )
     2131          Int absoulte_MV=0;
     2132          for ( UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx++ )
    21872133          {
    2188             TComCUMvField* pcCUMvField = rpcBestCU->getCUMvField(RefPicList( uiRefListIdx ));
    2189             Int iHor = pcCUMvField->getMvd( 0 ).getAbsHor();
    2190             Int iVer = pcCUMvField->getMvd( 0 ).getAbsVer();
    2191             absoulte_MV+=iHor+iVer;
     2134            if ( rpcBestCU->getSlice()->getNumRefIdx( RefPicList( uiRefListIdx ) ) > 0 )
     2135            {
     2136              TComCUMvField* pcCUMvField = rpcBestCU->getCUMvField(RefPicList( uiRefListIdx ));
     2137              Int iHor = pcCUMvField->getMvd( 0 ).getAbsHor();
     2138              Int iVer = pcCUMvField->getMvd( 0 ).getAbsVer();
     2139              absoulte_MV+=iHor+iVer;
     2140            }
     2141          }
     2142
     2143          if(absoulte_MV == 0)
     2144          {
     2145            *earlyDetectionSkipMode = true;
    21922146          }
    21932147        }
    2194 
    2195         if(absoulte_MV == 0)
    2196         {
    2197           *earlyDetectionSkipMode = true;
    2198         }
    21992148      }
    22002149    }
    22012150  }
    2202  }
    22032151#if H_3D_SPIVMP
    22042152 delete[] pcMvFieldSP;
    … …  
    22212169#endif
    22222170{
    2223 
    22242171#if H_3D
    22252172  const Bool bTransquantBypassFlag = rpcTempCU->getCUTransquantBypass(0);
    … …  
    22292176  {
    22302177#endif
    2231   UChar uhDepth = rpcTempCU->getDepth( 0 );
     2178    UChar uhDepth = rpcTempCU->getDepth( 0 );
    22322179#if H_3D_ARP
    2233   Bool bFirstTime = true;
    2234   Int nARPWMax    = rpcTempCU->getSlice()->getARPStepNum() - 1;
    2235 #if SEC_ARP_REM_ENC_RESTRICT_K0035
    2236   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
    2240   {
    2241     nARPWMax = 0;
    2242   }
    2243 
    2244   for( Int nARPW = 0; nARPW <= nARPWMax; nARPW++ )
    2245   {
    2246     if( !bFirstTime && rpcTempCU->getSlice()->getIvResPredFlag() )
    2247     {
    2248       rpcTempCU->initEstData( rpcTempCU->getDepth(0), rpcTempCU->getQP(0),bTransquantBypassFlag );     
    2249     }
    2250 #endif
    2251 #if H_3D_VSO // M3
    2252   if( m_pcRdCost->getUseRenModel() )
    2253   {
    2254     UInt  uiWidth     = m_ppcOrigYuv[uhDepth]->getWidth ( );
    2255     UInt  uiHeight    = m_ppcOrigYuv[uhDepth]->getHeight( );
    2256     Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr( );
    2257     UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride();
    2258     m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
    2259   }
    2260 #endif
    2261 
    2262   rpcTempCU->setDepthSubParts( uhDepth, 0 );
    2263  
    2264   rpcTempCU->setSkipFlagSubParts( false, 0, uhDepth );
    2265 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    2266   rpcTempCU->setDISFlagSubParts( false, 0, uhDepth );
    2267 #else
    2268 #if H_3D_SINGLE_DEPTH
    2269   rpcTempCU->setSingleDepthFlagSubParts( false, 0, uhDepth );
    2270 #endif
    2271 #endif
    2272   rpcTempCU->setPartSizeSubParts  ( ePartSize,  0, uhDepth );
    2273   rpcTempCU->setPredModeSubParts  ( MODE_INTER, 0, uhDepth );
    2274 
    2275 #if H_3D_ARP
    2276   rpcTempCU->setARPWSubParts( (UChar)nARPW , 0 , uhDepth );
    2277 #endif
    2278 
    2279 #if H_3D_ARP
    2280   if( bFirstTime == false && nARPWMax )
    2281   {
    2282     rpcTempCU->copyPartFrom( m_ppcWeightedTempCU[uhDepth] , 0 , uhDepth );
    2283     rpcTempCU->setARPWSubParts( (UChar)nARPW , 0 , uhDepth );
    2284 
    2285     m_pcPredSearch->motionCompensation( rpcTempCU , m_ppcPredYuvTemp[uhDepth] );
    2286   }
    2287   else
    2288   {
    2289     bFirstTime = false;
    2290 #endif
    2291 #if AMP_MRG
    2292   rpcTempCU->setMergeAMP (true);
    2293 #if  H_3D_FAST_TEXTURE_ENCODING
    2294   m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], bFMD, false, bUseMRG );
    2295 #else
    2296   m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], false, bUseMRG );
    2297 #endif
    2298 #else 
    2299   m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth] );
    2300 #endif
    2301 #if H_3D_ARP
    2302    if( nARPWMax )
    2303    {
    2304      m_ppcWeightedTempCU[uhDepth]->copyPartFrom( rpcTempCU , 0 , uhDepth );
    2305    }
    2306   }
    2307 #endif
    2308 
    2309 #if AMP_MRG
    2310   if ( !rpcTempCU->getMergeAMP() )
    2311   {
    2312 #if H_3D_ARP
    2313     if( nARPWMax )
    2314     {
    2315       continue;
    2316     }
    2317     else
    2318 #endif
    2319     return;
    2320   }
    2321 #endif
    2322 
    2323 #if KWU_RC_MADPRED_E0227
    2324   if ( m_pcEncCfg->getUseRateCtrl() && m_pcEncCfg->getLCULevelRC() && ePartSize == SIZE_2Nx2N && uhDepth <= m_addSADDepth )
    2325   {
    2326     UInt SAD = m_pcRdCost->getSADPart( g_bitDepthY, m_ppcPredYuvTemp[uhDepth]->getLumaAddr(), m_ppcPredYuvTemp[uhDepth]->getStride(),
    2327       m_ppcOrigYuv[uhDepth]->getLumaAddr(), m_ppcOrigYuv[uhDepth]->getStride(),
    2328       rpcTempCU->getWidth(0), rpcTempCU->getHeight(0) );
    2329     m_temporalSAD = (Int)SAD;
    2330   }
    2331 #endif
    2332   m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcResiYuvBest[uhDepth], m_ppcRecoYuvTemp[uhDepth], false );
    2333 #if H_3D_VSP // possible bug fix
    2334   if( rpcTempCU->getQtRootCbf(0)==0 )
    2335   {
    2336     rpcTempCU->setTrIdxSubParts(0, 0, uhDepth);
    2337   }
    2338 #endif
    2339 #if H_3D_VSO // M4
    2340   if( m_pcRdCost->getUseLambdaScaleVSO() )
    2341     rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
    2342   else
    2343 #endif
    2344   rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
    2345 #if H_3D_INTER_SDC
    2346   TComDataCU *rpcTempCUPre = rpcTempCU;
    2347 #endif
    2348   xCheckDQP( rpcTempCU );
    2349   xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
    2350 #if H_3D_INTER_SDC
    2351   if( rpcTempCU->getSlice()->getInterSdcFlag() && ePartSize == SIZE_2Nx2N)
    2352   {
    2353     Double dOffsetCost[3] = {MAX_DOUBLE,MAX_DOUBLE,MAX_DOUBLE};
    2354     for( Int uiOffest = 1 ; uiOffest <= 5 ; uiOffest++ )
    2355     {
    2356       if( uiOffest > 3)
     2180    Bool bFirstTime = true;
     2181    Int nARPWMax    = rpcTempCU->getSlice()->getARPStepNum() - 1;
     2182    if( nARPWMax < 0 || ePartSize != SIZE_2Nx2N || rpcTempCU->getICFlag(0) )
     2183    {
     2184      nARPWMax = 0;
     2185    }
     2186
     2187    for( Int nARPW = 0; nARPW <= nARPWMax; nARPW++ )
     2188    {
     2189      if( !bFirstTime && rpcTempCU->getSlice()->getIvResPredFlag() )
    23572190      {
    2358         if ( dOffsetCost[0] < (0.9*dOffsetCost[1]) && dOffsetCost[0] < (0.9*dOffsetCost[2]) )
    2359         {
    2360           continue;
    2361         }
    2362         if ( dOffsetCost[1] < dOffsetCost[0] && dOffsetCost[0] < dOffsetCost[2] &&  uiOffest == 5)
    2363         {
    2364           continue;
    2365         }
    2366         if ( dOffsetCost[0] < dOffsetCost[1] && dOffsetCost[2] < dOffsetCost[0] &&  uiOffest == 4)
    2367         {
    2368           continue;
    2369         }
     2191        rpcTempCU->initEstData( rpcTempCU->getDepth(0), rpcTempCU->getQP(0),bTransquantBypassFlag );     
    23702192      }
    2371 
    2372       if( rpcTempCU != rpcTempCUPre )
    2373       {
    2374         Int orgQP = rpcBestCU->getQP( 0 );
    2375         rpcTempCU->initEstData( uhDepth, orgQP ,bTransquantBypassFlag );     
    2376         rpcTempCU->copyPartFrom( rpcBestCU, 0, uhDepth );
    2377       }
    2378       rpcTempCU->setSkipFlagSubParts( false, 0, uhDepth );
    2379 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    2380       rpcTempCU->setDISFlagSubParts( false, 0, uhDepth );
    2381 #else
    2382 #if H_3D_SINGLE_DEPTH
    2383       rpcTempCU->setSingleDepthFlagSubParts( false, 0, uhDepth );
    2384 #endif
    2385 #endif
    2386       rpcTempCU->setTrIdxSubParts( 0, 0, uhDepth );
    2387       rpcTempCU->setCbfSubParts( 1, 1, 1, 0, uhDepth );
     2193#endif
    23882194#if H_3D_VSO // M3
    23892195      if( m_pcRdCost->getUseRenModel() )
    … …  
    23972203#endif
    23982204
    2399       Int iSdcOffset = 0;
    2400       if(uiOffest % 2 == 0)
     2205      rpcTempCU->setDepthSubParts( uhDepth, 0 );
     2206
     2207      rpcTempCU->setSkipFlagSubParts( false, 0, uhDepth );
     2208#if H_3D
     2209      rpcTempCU->setDISFlagSubParts( false, 0, uhDepth );
     2210#endif
     2211      rpcTempCU->setPartSizeSubParts  ( ePartSize,  0, uhDepth );
     2212      rpcTempCU->setPredModeSubParts  ( MODE_INTER, 0, uhDepth );
     2213#if H_3D_ARP
     2214      rpcTempCU->setARPWSubParts( (UChar)nARPW , 0 , uhDepth );
     2215#endif
     2216#if H_3D_ARP
     2217      if( bFirstTime == false && nARPWMax )
    24012218      {
    2402         iSdcOffset = uiOffest >> 1;
     2219        rpcTempCU->copyPartFrom( m_ppcWeightedTempCU[uhDepth] , 0 , uhDepth );
     2220        rpcTempCU->setARPWSubParts( (UChar)nARPW , 0 , uhDepth );
     2221
     2222        m_pcPredSearch->motionCompensation( rpcTempCU , m_ppcPredYuvTemp[uhDepth] );
    24032223      }
    24042224      else
    24052225      {
    2406         iSdcOffset = -1 * (uiOffest >> 1);
     2226        bFirstTime = false;
     2227#endif
     2228#if AMP_MRG
     2229        rpcTempCU->setMergeAMP (true);
     2230#if  H_3D_FAST_TEXTURE_ENCODING
     2231        m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], bFMD, false, bUseMRG );
     2232#else
     2233        m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], false, bUseMRG );
     2234#endif
     2235#else 
     2236        m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth] );
     2237#endif
     2238#if H_3D_ARP
     2239        if( nARPWMax )
     2240        {
     2241          m_ppcWeightedTempCU[uhDepth]->copyPartFrom( rpcTempCU , 0 , uhDepth );
     2242        }
    24072243      }
    2408       m_pcPredSearch->encodeResAndCalcRdInterSDCCU( rpcTempCU,
    2409         m_ppcOrigYuv[uhDepth],
    2410         ( rpcTempCU != rpcTempCUPre ) ? m_ppcPredYuvBest[uhDepth] : m_ppcPredYuvTemp[uhDepth],
    2411         m_ppcResiYuvTemp[uhDepth],
    2412         m_ppcRecoYuvTemp[uhDepth],
    2413         iSdcOffset,
    2414         uhDepth );
    2415       if (uiOffest <= 3 )
     2244#endif
     2245
     2246#if AMP_MRG
     2247      if ( !rpcTempCU->getMergeAMP() )
    24162248      {
    2417         dOffsetCost [uiOffest -1] = rpcTempCU->getTotalCost();
     2249#if H_3D_ARP
     2250        if( nARPWMax )
     2251        {
     2252          continue;
     2253        }
     2254        else
     2255#endif
     2256          return;
    24182257      }
    2419 
     2258#endif
     2259
     2260#if KWU_RC_MADPRED_E0227
     2261      if ( m_pcEncCfg->getUseRateCtrl() && m_pcEncCfg->getLCULevelRC() && ePartSize == SIZE_2Nx2N && uhDepth <= m_addSADDepth )
     2262      {
     2263        UInt SAD = m_pcRdCost->getSADPart( g_bitDepthY, m_ppcPredYuvTemp[uhDepth]->getLumaAddr(), m_ppcPredYuvTemp[uhDepth]->getStride(),
     2264          m_ppcOrigYuv[uhDepth]->getLumaAddr(), m_ppcOrigYuv[uhDepth]->getStride(),
     2265          rpcTempCU->getWidth(0), rpcTempCU->getHeight(0) );
     2266        m_temporalSAD = (Int)SAD;
     2267      }
     2268#endif
     2269      m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcResiYuvBest[uhDepth], m_ppcRecoYuvTemp[uhDepth], false );
     2270#if H_3D_VSP // possible bug fix
     2271      if( rpcTempCU->getQtRootCbf(0)==0 )
     2272      {
     2273        rpcTempCU->setTrIdxSubParts(0, 0, uhDepth);
     2274      }
     2275#endif
     2276#if H_3D_VSO // M4
     2277      if( m_pcRdCost->getUseLambdaScaleVSO() )
     2278        rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
     2279      else
     2280#endif
     2281        rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
     2282#if H_3D_INTER_SDC
     2283      TComDataCU *rpcTempCUPre = rpcTempCU;
     2284#endif
    24202285      xCheckDQP( rpcTempCU );
    24212286      xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
    2422     }
    2423 
    2424   }
     2287#if H_3D_INTER_SDC
     2288      if( rpcTempCU->getSlice()->getInterSdcFlag() && ePartSize == SIZE_2Nx2N)
     2289      {
     2290        Double dOffsetCost[3] = {MAX_DOUBLE,MAX_DOUBLE,MAX_DOUBLE};
     2291        for( Int uiOffest = 1 ; uiOffest <= 5 ; uiOffest++ )
     2292        {
     2293          if( uiOffest > 3)
     2294          {
     2295            if ( dOffsetCost[0] < (0.9*dOffsetCost[1]) && dOffsetCost[0] < (0.9*dOffsetCost[2]) )
     2296            {
     2297              continue;
     2298            }
     2299            if ( dOffsetCost[1] < dOffsetCost[0] && dOffsetCost[0] < dOffsetCost[2] &&  uiOffest == 5)
     2300            {
     2301              continue;
     2302            }
     2303            if ( dOffsetCost[0] < dOffsetCost[1] && dOffsetCost[2] < dOffsetCost[0] &&  uiOffest == 4)
     2304            {
     2305              continue;
     2306            }
     2307          }
     2308
     2309          if( rpcTempCU != rpcTempCUPre )
     2310          {
     2311            Int orgQP = rpcBestCU->getQP( 0 );
     2312            rpcTempCU->initEstData( uhDepth, orgQP ,bTransquantBypassFlag );     
     2313            rpcTempCU->copyPartFrom( rpcBestCU, 0, uhDepth );
     2314          }
     2315          rpcTempCU->setSkipFlagSubParts( false, 0, uhDepth );
     2316#if H_3D
     2317          rpcTempCU->setDISFlagSubParts( false, 0, uhDepth );
     2318#endif
     2319          rpcTempCU->setTrIdxSubParts( 0, 0, uhDepth );
     2320          rpcTempCU->setCbfSubParts( 1, 1, 1, 0, uhDepth );
     2321#if H_3D_VSO // M3
     2322          if( m_pcRdCost->getUseRenModel() )
     2323          {
     2324            UInt  uiWidth     = m_ppcOrigYuv[uhDepth]->getWidth ( );
     2325            UInt  uiHeight    = m_ppcOrigYuv[uhDepth]->getHeight( );
     2326            Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr( );
     2327            UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride();
     2328            m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
     2329          }
     2330#endif
     2331
     2332          Int iSdcOffset = 0;
     2333          if(uiOffest % 2 == 0)
     2334          {
     2335            iSdcOffset = uiOffest >> 1;
     2336          }
     2337          else
     2338          {
     2339            iSdcOffset = -1 * (uiOffest >> 1);
     2340          }
     2341          m_pcPredSearch->encodeResAndCalcRdInterSDCCU( rpcTempCU,
     2342            m_ppcOrigYuv[uhDepth],
     2343            ( rpcTempCU != rpcTempCUPre ) ? m_ppcPredYuvBest[uhDepth] : m_ppcPredYuvTemp[uhDepth],
     2344            m_ppcResiYuvTemp[uhDepth],
     2345            m_ppcRecoYuvTemp[uhDepth],
     2346            iSdcOffset,
     2347            uhDepth );
     2348          if (uiOffest <= 3 )
     2349          {
     2350            dOffsetCost [uiOffest -1] = rpcTempCU->getTotalCost();
     2351          }
     2352
     2353          xCheckDQP( rpcTempCU );
     2354          xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
     2355        }
     2356
     2357      }
    24252358#endif
    24262359#if H_3D_ARP
    2427   }
     2360    }
    24282361#endif
    24292362#if  H_3D_FAST_TEXTURE_ENCODING
    … …  
    24922425}
    24932426
    2494 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    24952427Void TEncCu::xCheckRDCostDIS( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize eSize )
    24962428{
    … …  
    25642496  xCheckBestMode(rpcBestCU, rpcTempCU, uiDepth);
    25652497}
    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
    26352498
    26362499Void TEncCu::xCheckRDCostInterDBBP( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, Bool bUseMRG )
    … …  
    26752538  AOF( uiDepthStride != 0 );
    26762539 
    2677 #if HS_DBBP_CLEAN_K0048
    26782540  PartSize eVirtualPartSize = m_pcPredSearch->getPartitionSizeFromDepth(pDepthPels, uiDepthStride, uiWidth, rpcTempCU);
    26792541
    … …  
    26812543  Bool pMask[MAX_CU_SIZE*MAX_CU_SIZE];
    26822544  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
    26902545 
    26912546  if( !bValidMask )
    … …  
    26962551  // find optimal motion/disparity vector for each segment
    26972552  DisInfo originalDvInfo = rpcTempCU->getDvInfo(0);
    2698   DBBPTmpData* pDBBPTmpData = rpcTempCU->getDBBPTmpData();
     2553  DbbpTmpData* pDBBPTmpData = rpcTempCU->getDBBPTmpData();
    26992554  TComYuv* apPredYuv[2] = { m_ppcRecoYuvTemp[uhDepth], m_ppcPredYuvTemp[uhDepth] };
    27002555 
    … …  
    27772632}
    27782633#endif
     2634
    27792635#if H_3D_DIM
    27802636Void TEncCu::xCheckRDCostIntra( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize eSize, Bool bOnlyIVP )
    … …  
    27962652
    27972653  rpcTempCU->setSkipFlagSubParts( false, 0, uiDepth );
    2798 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2654#if H_3D
    27992655  rpcTempCU->setDISFlagSubParts( false, 0, uiDepth );
    2800 #else
    2801 #if H_3D_SINGLE_DEPTH
    2802   rpcTempCU->setSingleDepthFlagSubParts( false, 0, uiDepth );
    2803 #endif
    28042656#endif
    28052657  rpcTempCU->setPartSizeSubParts( eSize, 0, uiDepth );
    … …  
    28202672 
    28212673#if H_3D_DIM_SDC
    2822 #if 0 // H_3D_DISABLE_CHROMA
    2823   if( !rpcTempCU->getSDCFlag( 0 ) && !rpcTempCU->getSlice()->getIsDepth() )
    2824 #else
    28252674  if( !rpcTempCU->getSDCFlag( 0 ) )
    28262675#endif
    2827 #endif
    2828   m_pcPredSearch  ->estIntraPredChromaQT( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth], uiPreCalcDistC );
     2676    m_pcPredSearch  ->estIntraPredChromaQT( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth], uiPreCalcDistC );
    28292677 
    28302678  m_pcEntropyCoder->resetBits();
    … …  
    28342682  }
    28352683  m_pcEntropyCoder->encodeSkipFlag ( rpcTempCU, 0,          true );
    2836 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2684#if H_3D
    28372685  m_pcEntropyCoder->encodeDIS( rpcTempCU, 0,          true );
    28382686  if(!rpcTempCU->getDISFlag(0))
    28392687  {
    2840 #else
    2841 #if H_3D_SINGLE_DEPTH
    2842   m_pcEntropyCoder->encodeSingleDepthMode( rpcTempCU, 0,          true );
    2843   if(!rpcTempCU->getSingleDepthFlag(0))
    2844   {
    2845 #endif
    2846 #endif
    2847   m_pcEntropyCoder->encodePredMode( rpcTempCU, 0,          true );
    2848   m_pcEntropyCoder->encodePartSize( rpcTempCU, 0, uiDepth, true );
    2849 #if !HHI_MOVE_SYN_K0052
     2688#endif
     2689    m_pcEntropyCoder->encodePredMode( rpcTempCU, 0,          true );
     2690    m_pcEntropyCoder->encodePartSize( rpcTempCU, 0, uiDepth, true );
     2691    m_pcEntropyCoder->encodePredInfo( rpcTempCU, 0,          true );
     2692    m_pcEntropyCoder->encodeIPCMInfo(rpcTempCU, 0, true );
    28502693#if H_3D_DIM_SDC
    2851   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
    2860 #endif
    2861 
    2862   // Encode Coefficients
    2863   Bool bCodeDQP = getdQPFlag();
     2694    m_pcEntropyCoder->encodeSDCFlag( rpcTempCU, 0, true );
     2695#endif
     2696
     2697    // Encode Coefficients
     2698    Bool bCodeDQP = getdQPFlag();
    28642699#if H_3D_DISABLE_CHROMA
    2865   m_pcEntropyCoder->encodeCoeff( rpcTempCU, 0, uiDepth, rpcTempCU->getWidth (0), rpcTempCU->getHeight(0), bCodeDQP, true );
    2866 #else
    2867   m_pcEntropyCoder->encodeCoeff( rpcTempCU, 0, uiDepth, rpcTempCU->getWidth (0), rpcTempCU->getHeight(0), bCodeDQP );
    2868 #endif
    2869 
    2870 
    2871   setdQPFlag( bCodeDQP );
    2872 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    2873   }
    2874 #else
    2875 #if H_3D_SINGLE_DEPTH
    2876   }
    2877 #endif
     2700    m_pcEntropyCoder->encodeCoeff( rpcTempCU, 0, uiDepth, rpcTempCU->getWidth (0), rpcTempCU->getHeight(0), bCodeDQP, true );
     2701#else
     2702    m_pcEntropyCoder->encodeCoeff( rpcTempCU, 0, uiDepth, rpcTempCU->getWidth (0), rpcTempCU->getHeight(0), bCodeDQP );
     2703#endif
     2704    setdQPFlag( bCodeDQP );
     2705#if H_3D
     2706  }
    28782707#endif
    28792708  m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
    28802709 
    28812710  rpcTempCU->getTotalBits() = m_pcEntropyCoder->getNumberOfWrittenBits();
    2882     rpcTempCU->getTotalBins() = ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
     2711  rpcTempCU->getTotalBins() = ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
    28832712#if H_3D_VSO // M6
    28842713  if( m_pcRdCost->getUseLambdaScaleVSO()) 
    … …  
    29042733
    29052734  rpcTempCU->setSkipFlagSubParts( false, 0, uiDepth );
    2906 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2735#if H_3D
    29072736  rpcTempCU->setDISFlagSubParts( false, 0, uiDepth );
    2908 #else
    2909 #if H_3D_SINGLE_DEPTH
    2910   rpcTempCU->setSingleDepthFlagSubParts( false, 0, uiDepth );
    2911 #endif
    29122737#endif
    29132738  rpcTempCU->setIPCMFlag(0, true);
    … …  
    29272752  }
    29282753  m_pcEntropyCoder->encodeSkipFlag ( rpcTempCU, 0,          true );
    2929 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2754#if H_3D
    29302755  m_pcEntropyCoder->encodeDIS( rpcTempCU, 0,          true );
    2931 #else
    2932 #if H_3D_SINGLE_DEPTH
    2933   m_pcEntropyCoder->encodeSingleDepthMode( rpcTempCU, 0,          true );
    2934 #endif
    29352756#endif
    29362757  m_pcEntropyCoder->encodePredMode ( rpcTempCU, 0,          true );
    29372758  m_pcEntropyCoder->encodePartSize ( rpcTempCU, 0, uiDepth, true );
    2938 #if !HHI_MOVE_SYN_K0052
     2759  m_pcEntropyCoder->encodeIPCMInfo ( rpcTempCU, 0, true );
    29392760#if H_3D_DIM_SDC
    29402761  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
    29482762#endif
    29492763  m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);

  • trunk/source/Lib/TLibEncoder/TEncCu.h

    r1179 r1196  
    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

  • trunk/source/Lib/TLibEncoder/TEncEntropy.cpp

    r1179 r1196  
    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
    … …  
    586561#endif
    587562#endif
    588     encodeIntraDirModeChroma( pcCU, uiAbsPartIdx, bRD );
     563      encodeIntraDirModeChroma( pcCU, uiAbsPartIdx, bRD );
    589564  }
    590565  else                                                                // if it is Inter mode, encode motion vector and reference index
    … …  
    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

  • trunk/source/Lib/TLibEncoder/TEncEntropy.h

    r1179 r1196  
    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 );

  • trunk/source/Lib/TLibEncoder/TEncGOP.cpp

    r1179 r1196  
    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

  • trunk/source/Lib/TLibEncoder/TEncSbac.cpp

    r1179 r1196  
    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);
    … …  
    270255      curCost += m_CUTransquantBypassFlagSCModel.calcCost( curSliceType, qp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
    271256#if H_3D_DIM
    272     if( m_pcSlice->getIntraSdcWedgeFlag() || m_pcSlice->getIntraContourFlag() )
    273     {
    274       curCost += m_cDepthIntraModeSCModel.calcCost    ( curSliceType, qp, (UChar*)INIT_DEPTH_INTRA_MODE );
    275       curCost += m_cDdcFlagSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_DDC_FLAG );
    276       curCost += m_cDdcDataSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_DDC_DATA );
    277       curCost += m_cAngleFlagSCModel.calcCost         ( curSliceType, qp, (UChar*)INIT_ANGLE_FLAG ); 
    278     }
     257      if( m_pcSlice->getIntraSdcWedgeFlag() || m_pcSlice->getIntraContourFlag() )
     258      {
     259        curCost += m_cDepthIntraModeSCModel.calcCost    ( curSliceType, qp, (UChar*)INIT_DEPTH_INTRA_MODE );
     260        curCost += m_cDdcFlagSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_DDC_FLAG );
     261        curCost += m_cDdcDataSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_DDC_DATA );
     262        curCost += m_cAngleFlagSCModel.calcCost         ( curSliceType, qp, (UChar*)INIT_ANGLE_FLAG ); 
     263      }
    279264#endif
    280265      if (curCost < bestCost)
    … …  
    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
    … …  
    680626  Bool bDepthMapDetect   = (pcTexture != NULL);
    681627  Bool bIntraSliceDetect = (pcCU->getSlice()->getSliceType() == I_SLICE);
    682  
     628
    683629  Bool rapPic     = (pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
    684630
    … …  
    718664    return;
    719665  }
    720  
     666
    721667#if H_MV_ENC_DEC_TRAC         
    722668  DTRACE_CU("part_mode", eSize )
    … …  
    726672    {
    727673#endif
    728   switch(eSize)
    729   {
    730     case SIZE_2Nx2N:
    731     {
    732       m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 0) );
    733       break;
    734     }
    735     case SIZE_2NxN:
    736     case SIZE_2NxnU:
    737     case SIZE_2NxnD:
    738     {
    739       m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
    740       m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 1) );
    741       if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
    742       {
    743         if (eSize == SIZE_2NxN)
    744         {
    745           m_pcBinIf->encodeBin(1, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
    746         }
    747         else
    748         {
    749           m_pcBinIf->encodeBin(0, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
    750           m_pcBinIf->encodeBinEP((eSize == SIZE_2NxnU? 0: 1));
    751         }
    752       }
    753       break;
    754     }
    755     case SIZE_Nx2N:
    756     case SIZE_nLx2N:
    757     case SIZE_nRx2N:
    758     {
    759       m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
    760       m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
    761       if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( pcCU->getWidth(uiAbsPartIdx) == 8 && pcCU->getHeight(uiAbsPartIdx) == 8 ) )
    762       {
    763         m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 2) );
    764       }
    765       if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
    766       {
    767         if (eSize == SIZE_Nx2N)
    768         {
    769           m_pcBinIf->encodeBin(1, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
    770         }
    771         else
    772         {
    773           m_pcBinIf->encodeBin(0, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
    774           m_pcBinIf->encodeBinEP((eSize == SIZE_nLx2N? 0: 1));
    775         }
    776       }
    777       break;
    778     }
    779     case SIZE_NxN:
    780     {
    781       if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( pcCU->getWidth(uiAbsPartIdx) == 8 && pcCU->getHeight(uiAbsPartIdx) == 8 ) )
    782       {
    783         m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
    784         m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
    785         m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 2) );
    786       }
    787       break;
    788     }
    789     default:
    790     {
    791       assert(0);
    792     }
    793   }
     674      switch(eSize)
     675      {
     676      case SIZE_2Nx2N:
     677        {
     678          m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 0) );
     679          break;
     680        }
     681      case SIZE_2NxN:
     682      case SIZE_2NxnU:
     683      case SIZE_2NxnD:
     684        {
     685          m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
     686          m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 1) );
     687          if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
     688          {
     689            if (eSize == SIZE_2NxN)
     690            {
     691              m_pcBinIf->encodeBin(1, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
     692            }
     693            else
     694            {
     695              m_pcBinIf->encodeBin(0, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
     696              m_pcBinIf->encodeBinEP((eSize == SIZE_2NxnU? 0: 1));
     697            }
     698          }
     699          break;
     700        }
     701      case SIZE_Nx2N:
     702      case SIZE_nLx2N:
     703      case SIZE_nRx2N:
     704        {
     705          m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
     706          m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
     707          if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( pcCU->getWidth(uiAbsPartIdx) == 8 && pcCU->getHeight(uiAbsPartIdx) == 8 ) )
     708          {
     709            m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 2) );
     710          }
     711          if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
     712          {
     713            if (eSize == SIZE_Nx2N)
     714            {
     715              m_pcBinIf->encodeBin(1, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
     716            }
     717            else
     718            {
     719              m_pcBinIf->encodeBin(0, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
     720              m_pcBinIf->encodeBinEP((eSize == SIZE_nLx2N? 0: 1));
     721            }
     722          }
     723          break;
     724        }
     725      case SIZE_NxN:
     726        {
     727          if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( pcCU->getWidth(uiAbsPartIdx) == 8 && pcCU->getHeight(uiAbsPartIdx) == 8 ) )
     728          {
     729            m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
     730            m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
     731            m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 2) );
     732          }
     733          break;
     734        }
     735      default:
     736        {
     737          assert(0);
     738        }
     739      }
    794740#if H_3D_QTLPC
    795741    }
    … …  
    11431089    {
    11441090#endif
    1145     if(predIdx[j] != -1)
    1146     {
    1147       m_pcBinIf->encodeBinEP( predIdx[j] ? 1 : 0 );
    1148       if (predIdx[j])
    1149       {
    1150         m_pcBinIf->encodeBinEP( predIdx[j]-1 );
    1151       }
     1091      if(predIdx[j] != -1)
     1092      {
     1093        m_pcBinIf->encodeBinEP( predIdx[j] ? 1 : 0 );
     1094        if (predIdx[j])
     1095        {
     1096          m_pcBinIf->encodeBinEP( predIdx[j]-1 );
     1097        }
    11521098#if H_MV_ENC_DEC_TRAC
    1153       DTRACE_CU("mpm_idx", predIdx[j] );
    1154 #endif
    1155     }
    1156     else
    1157     {
    1158       if (preds[j][0] > preds[j][1])
    1159       {
    1160         std::swap(preds[j][0], preds[j][1]);
    1161       }
    1162       if (preds[j][0] > preds[j][2])
    1163       {
    1164         std::swap(preds[j][0], preds[j][2]);
    1165       }
    1166       if (preds[j][1] > preds[j][2])
    1167       {
    1168         std::swap(preds[j][1], preds[j][2]);
    1169       }
    1170       for(Int i = (predNum[j] - 1); i >= 0; i--)
    1171       {
    1172         dir[j] = dir[j] > preds[j][i] ? dir[j] - 1 : dir[j];
    1173       }
    1174       m_pcBinIf->encodeBinsEP( dir[j], 5 );
     1099        DTRACE_CU("mpm_idx", predIdx[j] );
     1100#endif
     1101      }
     1102      else
     1103      {
     1104        if (preds[j][0] > preds[j][1])
     1105        {
     1106          std::swap(preds[j][0], preds[j][1]);
     1107        }
     1108        if (preds[j][0] > preds[j][2])
     1109        {
     1110          std::swap(preds[j][0], preds[j][2]);
     1111        }
     1112        if (preds[j][1] > preds[j][2])
     1113        {
     1114          std::swap(preds[j][1], preds[j][2]);
     1115        }
     1116        for(Int i = (predNum[j] - 1); i >= 0; i--)
     1117        {
     1118          dir[j] = dir[j] > preds[j][i] ? dir[j] - 1 : dir[j];
     1119        }
     1120        m_pcBinIf->encodeBinsEP( dir[j], 5 );
    11751121#if H_MV_ENC_DEC_TRAC
    1176       DTRACE_CU("rem_intra_luma_pred_mode", dir[j] );
    1177 #endif
    1178     }
     1122        DTRACE_CU("rem_intra_luma_pred_mode", dir[j] );
     1123#endif
     1124      }
    11791125#if H_3D_DIM
    11801126    }
    … …  
    15211467    {   
    15221468#endif
    1523     piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
    1524     uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
    1525     uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
    1526     uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
    1527 
    1528     for(uiY = 0; uiY < uiHeight; uiY++)
    1529     {
    1530       for(uiX = 0; uiX < uiWidth; uiX++)
    1531       {
    1532         UInt uiSample = piPCMSample[uiX];
    1533 
    1534         m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
    1535       }
    1536       piPCMSample += uiWidth;
    1537     }
    1538 
    1539     piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
    1540     uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
    1541     uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
    1542     uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
    1543 
    1544     for(uiY = 0; uiY < uiHeight; uiY++)
    1545     {
    1546       for(uiX = 0; uiX < uiWidth; uiX++)
    1547       {
    1548         UInt uiSample = piPCMSample[uiX];
    1549 
    1550         m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
    1551       }
    1552       piPCMSample += uiWidth;
    1553     }
     1469      piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
     1470      uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
     1471      uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
     1472      uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
     1473
     1474      for(uiY = 0; uiY < uiHeight; uiY++)
     1475      {
     1476        for(uiX = 0; uiX < uiWidth; uiX++)
     1477        {
     1478          UInt uiSample = piPCMSample[uiX];
     1479
     1480          m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
     1481        }
     1482        piPCMSample += uiWidth;
     1483      }
     1484
     1485      piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
     1486      uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
     1487      uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
     1488      uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
     1489
     1490      for(uiY = 0; uiY < uiHeight; uiY++)
     1491      {
     1492        for(uiX = 0; uiX < uiWidth; uiX++)
     1493        {
     1494          UInt uiSample = piPCMSample[uiX];
     1495
     1496          m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
     1497        }
     1498        piPCMSample += uiWidth;
     1499      }
    15541500#if H_3D_DISABLE_CHROMA
    15551501    }

  • trunk/source/Lib/TLibEncoder/TEncSbac.h

    r1179 r1196  
    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;

  • trunk/source/Lib/TLibEncoder/TEncSearch.cpp

    r1179 r1196  
    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 );
    997 #endif
    998 #endif
    999962          if( pcCU->getSlice()->getIsDepth() && ( !pcCU->getSDCFlag( 0 ) ) && getDimType( pcCU->getLumaIntraDir( 0 ) ) < DIM_NUM_TYPE )
    1000963          {
    … …  
    1013976          {
    1014977            m_pcEntropyCoder->encodeIntraDirModeLuma ( pcCU, uiPart * uiQNumParts );
    1015 
    1016 #if HHI_MOVE_SYN_K0052
     978#if H_3D_DIM_SDC
    1017979          }
    1018980          m_pcEntropyCoder->encodeSDCFlag( pcCU, 0, true );
    1019981          for( UInt uiPart = 0; uiPart < 4; uiPart++ )
    1020982          {
    1021 #endif
    1022 #if H_3D_DIM_SDC
    1023983            if( pcCU->getSlice()->getIsDepth() && ( !pcCU->getSDCFlag( uiPart * uiQNumParts ) ) && getDimType( pcCU->getLumaIntraDir( uiPart * uiQNumParts ) ) < DIM_NUM_TYPE )
    1024984            {
    … …  
    1032992          m_pcEntropyCoder->encodeIntraDirModeLuma ( pcCU, uiAbsPartIdx );
    1033993#if H_3D_DIM_SDC
    1034 #if HHI_MOVE_SYN_K0052
    1035994          if( uiAbsPartIdx == 0 ) 
    1036995          {
    1037996            m_pcEntropyCoder->encodeSDCFlag( pcCU, 0, true );
    1038997          }
    1039 #endif
    1040998          if( pcCU->getSlice()->getIsDepth() && ( !pcCU->getSDCFlag( uiAbsPartIdx ) ) && getDimType( pcCU->getLumaIntraDir( uiAbsPartIdx ) ) < DIM_NUM_TYPE )
    1041999          {
    … …  
    10441002#endif
    10451003        }
    1046       }
    1047 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
    1048     }
    1049 #else
    1050 #if H_3D_SINGLE_DEPTH
    1051     }
    1052 #endif
    1053 #endif
     1004#if H_3D
     1005      }
     1006#endif
     1007    }
    10541008  }
    10551009  if( bChroma )
    … …  
    19141868}
    19151869
    1916 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     1870#if H_3D
    19171871Void TEncSearch::xIntraCodingDIS( TComDataCU* pcCU, UInt uiAbsPartIdx, TComYuv* pcOrgYuv, TComYuv* pcPredYuv, Dist& ruiDist, Double& dRDCost, UInt uiPredMode )
    19181872{
    … …  
    20061960    dRDCost = m_pcRdCost->calcRdCost( uiBits, ruiDist );
    20071961}
    2008 #else
    2009 #if H_3D_SINGLE_DEPTH
    2010 Void TEncSearch::xIntraCodingSingleDepth( TComDataCU* pcCU, UInt uiAbsPartIdx, TComYuv* pcOrgYuv, TComYuv* pcPredYuv, Dist& ruiDist, Double& dRDCost, Int iTestDepthIdx, Pel *DepthNeighbor )
    2011 {
    2012   UInt    uiWidth           = pcCU     ->getWidth   ( 0 );
    2013   UInt    uiHeight          = pcCU     ->getHeight  ( 0 );
    2014   UInt    uiStride          = pcOrgYuv ->getStride  ();
    2015   Pel*    piOrg             = pcOrgYuv ->getLumaAddr( uiAbsPartIdx );
    2016   Pel*    piPred            = pcPredYuv->getLumaAddr( uiAbsPartIdx );
    2017 
    2018   AOF( uiWidth == uiHeight );
    2019   AOF( uiAbsPartIdx == 0 );
    2020   pcCU->setSingleDepthValueSubParts((Pel)iTestDepthIdx,uiAbsPartIdx, 0, pcCU->getDepth(0)); 
    2021   //===== reconstruction =====
    2022 
    2023   for( UInt uiY = 0; uiY < uiHeight; uiY++ )
    2024   {
    2025     for( UInt uiX = 0; uiX < uiWidth; uiX++ )
    2026     {
    2027     piPred[ uiX ] = DepthNeighbor[iTestDepthIdx];
    2028     }
    2029     piPred     += uiStride;
    2030   }
    2031 
    2032   // clear UV
    2033   UInt  uiStrideC     = pcPredYuv->getCStride();
    2034   Pel   *pRecCb       = pcPredYuv->getCbAddr();
    2035   Pel   *pRecCr       = pcPredYuv->getCrAddr();
    2036 
    2037   for (Int y=0; y<uiHeight/2; y++)
    2038   {
    2039     for (Int x=0; x<uiWidth/2; x++)
    2040     {
    2041       pRecCb[x] = 1<<(g_bitDepthC-1);
    2042       pRecCr[x] = 1<<(g_bitDepthC-1);
    2043     }
    2044 
    2045     pRecCb += uiStrideC;
    2046     pRecCr += uiStrideC;
    2047   }
    2048 
    2049   piPred            = pcPredYuv->getLumaAddr( uiAbsPartIdx );
    2050   //===== determine distortion =====
    2051 #if H_3D_VSO
    2052   if ( m_pcRdCost->getUseVSO() )
    2053     ruiDist = m_pcRdCost->getDistPartVSO  ( pcCU, uiAbsPartIdx, piPred, uiStride, piOrg, uiStride, uiWidth, uiHeight, false );
    2054   else
    2055 #endif
    2056     ruiDist = m_pcRdCost->getDistPart(g_bitDepthY, piPred, uiStride, piOrg, uiStride, uiWidth, uiHeight );
    2057 
    2058   //===== determine rate and r-d cost =====
    2059   m_pcEntropyCoder->resetBits();
    2060   m_pcEntropyCoder->encodeSingleDepthMode( pcCU, 0, true );
    2061   UInt uiBits = m_pcEntropyCoder->getNumberOfWrittenBits();
    2062 
    2063 #if H_3D_VSO
    2064   if ( m_pcRdCost->getUseLambdaScaleVSO())
    2065     dRDCost = m_pcRdCost->calcRdCostVSO( uiBits, ruiDist );
    2066   else
    2067 #endif
    2068     dRDCost = m_pcRdCost->calcRdCost( uiBits, ruiDist );
    2069 }
    2070 #endif
    2071 #endif
    2072 
     1962#endif
    20731963#if H_3D_DIM_SDC
    20741964Void TEncSearch::xIntraCodingSDC( TComDataCU* pcCU, UInt uiAbsPartIdx, TComYuv* pcOrgYuv, TComYuv* pcPredYuv, Dist& ruiDist, Double& dRDCost, Bool bZeroResidual, Int iSDCDeltaResi  )
    … …  
    23182208
    23192209  m_pcEntropyCoder->encodePartSize( pcCU, 0, pcCU->getDepth( 0 ), true );
    2320 #if !HHI_MOVE_SYN_K0052
    2321   m_pcEntropyCoder->encodeSDCFlag( pcCU, 0, true );
    2322 #endif
    23232210
    23242211  // encode pred direction + DC residual data
    23252212  m_pcEntropyCoder->encodePredInfo( pcCU, 0, true );
    2326 #if HHI_MOVE_SYN_K0052
     2213#if H_3D_DIM_SDC
    23272214  m_pcEntropyCoder->encodeSDCFlag( pcCU, 0, true );
    23282215#endif
    … …  
    30212908  pcCU->setChromIntraDirSubParts( uiBestMode, 0, pcCU->getDepth( 0 ) );
    30222909}
    3023 
    3024 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     2910#if H_3D
    30252911Void TEncSearch::estIntraPredDIS( TComDataCU* pcCU,
    30262912                                  TComYuv*    pcOrgYuv,
    … …  
    30812967  pcCU->getTotalDistortion() = uiBestDist;
    30822968}
    3083 #else
    3084 #if H_3D_SINGLE_DEPTH
    3085 Void
    3086 TEncSearch::estIntraPredSingleDepth( TComDataCU* pcCU,
    3087                            TComYuv*    pcOrgYuv,
    3088                            TComYuv*    pcPredYuv,
    3089                            TComYuv*    pcResiYuv,
    3090                            TComYuv*    pcRecoYuv,
    3091                            UInt&       ruiDistC,
    3092                            Bool        bLumaOnly )
    3093 {
    3094   UInt    uiDepth        = pcCU->getDepth(0);
    3095   UInt    uiWidth        = pcCU->getWidth (0);
    3096   UInt    uiHeight       = pcCU->getHeight(0);
    3097 
    3098 
    3099   Pel* piOrg         = pcOrgYuv ->getLumaAddr( 0, uiWidth );
    3100   UInt uiStride      = pcPredYuv->getStride();
    3101 
    3102   Int index=0;
    3103   Pel testDepth;
    3104   Pel DepthNeighbours[2];
    3105   //construction of depth candidates
    3106   for( Int i = 0; (i < 2)  && (index<SINGLE_DEPTH_MODE_CAND_LIST_SIZE) ; i++ )
    3107   {
    3108     if(!pcCU->getNeighDepth (0, 0, &testDepth, i))
    3109     {
    3110       continue;
    3111     }
    3112     DepthNeighbours[index]=testDepth;
    3113     index++;
    3114   }
    3115 
    3116   if(index==0)
    3117   {
    3118     DepthNeighbours[index]=1<<(g_bitDepthY-1);
    3119     index++;
    3120   }
    3121 
    3122   if(index==1)
    3123   {
    3124     DepthNeighbours[index]=ClipY(DepthNeighbours[0] + 1 );
    3125     index++;
    3126   }
    3127 
    3128 
    3129   Dist   uiDist = 0;
    3130   Double dCost   = 0.0;
    3131   Dist    uiBestDist = 0;
    3132   Double  dBestCost   = MAX_DOUBLE;
    3133   Pel     pBestSingleDepthValue = 0;
    3134 
    3135   for( Int testdepthidx = 0; testdepthidx < index ; testdepthidx++ )
    3136   {
    3137       // set context models
    3138       m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
    3139 
    3140       // determine residual for partition
    3141       uiDist = 0;
    3142       dCost   = 0.0;
    3143 #if H_3D_VSO // M36
    3144       if( m_pcRdCost->getUseRenModel() )
    3145       {
    3146         m_pcRdCost->setRenModelData( pcCU, 0, piOrg, uiStride, uiWidth, uiHeight );
    3147       }
    3148 #endif
    3149       xIntraCodingSingleDepth(pcCU, 0, pcOrgYuv, pcPredYuv, uiDist, dCost, testdepthidx, DepthNeighbours);
    3150       // check r-d cost
    3151       if( dCost < dBestCost )
    3152       {
    3153         uiBestDist = uiDist;
    3154         dBestCost   = dCost;
    3155         pBestSingleDepthValue = pcCU->getSingleDepthValue(0);
    3156         // copy reconstruction
    3157         pcPredYuv->copyPartToPartYuv(pcRecoYuv, 0, uiWidth, uiHeight);
    3158       }
    3159   } // depth index loop
    3160 
    3161 
    3162   pcCU->setSingleDepthValueSubParts((Pel)pBestSingleDepthValue,0, 0, uiDepth);
    3163   assert(pBestSingleDepthValue>=0);
    3164 
    3165   //===== reset context models =====
    3166   m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
    3167  
    3168   //===== set distortion (rate and r-d costs are determined later) =====
    3169   pcCU->getTotalDistortion() = uiBestDist;
    3170 }
    3171 
    3172 #endif
    3173 #endif
    3174 
     2969#endif
    31752970Void
    31762971TEncSearch::estIntraPredQT( TComDataCU* pcCU,
    … …  
    32213016    pcCU->getPattern()->initPattern   ( pcCU, uiInitTrDepth, uiPartOffset );
    32223017    pcCU->getPattern()->initAdiPattern( pcCU, uiPartOffset, uiInitTrDepth, m_piYuvExt, m_iYuvExtStride, m_iYuvExtHeight, bAboveAvail, bLeftAvail );
    3223    
     3018
    32243019    //===== determine set of modes to be tested (using prediction signal only) =====
    32253020    Int numModesAvailable     = 35; //total number of Intra modes
    … …  
    32293024    UInt uiRdModeList[FAST_UDI_MAX_RDMODE_NUM];
    32303025    Int numModesForFullRD = g_aucIntraModeNumFast[ uiWidthBit ];
    3231    
     3026
    32323027#if H_3D_DIM
    32333028    if( bOnlyIVP )
    … …  
    32383033    {
    32393034#endif
    3240     Bool doFastSearch = (numModesForFullRD != numModesAvailable);
    3241     if (doFastSearch)
    3242     {
    3243       assert(numModesForFullRD < numModesAvailable);
    3244 
    3245       for( Int i=0; i < numModesForFullRD; i++ )
    3246       {
    3247         CandCostList[ i ] = MAX_DOUBLE;
    3248       }
    3249       CandNum = 0;
    3250      
    3251       for( Int modeIdx = 0; modeIdx < numModesAvailable; modeIdx++ )
    3252       {
    3253         UInt uiMode = modeIdx;
    3254 
    3255         predIntraLumaAng( pcCU->getPattern(), uiMode, piPred, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail );
     3035      Bool doFastSearch = (numModesForFullRD != numModesAvailable);
     3036      if (doFastSearch)
     3037      {
     3038        assert(numModesForFullRD < numModesAvailable);
     3039
     3040        for( Int i=0; i < numModesForFullRD; i++ )
     3041        {
     3042          CandCostList[ i ] = MAX_DOUBLE;
     3043        }
     3044        CandNum = 0;
     3045
     3046        for( Int modeIdx = 0; modeIdx < numModesAvailable; modeIdx++ )
     3047        {
     3048          UInt uiMode = modeIdx;
     3049
     3050          predIntraLumaAng( pcCU->getPattern(), uiMode, piPred, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail );
    32563051#if H_3D_VSO // M34
    3257         Dist uiSad;
    3258         if ( m_pcRdCost->getUseVSO() )
    3259         {
    3260           if ( m_pcRdCost->getUseEstimatedVSD() )
    3261           {         
    3262             uiSad = (Dist) ( m_pcRdCost->getDistPartVSD( pcCU, uiPartOffset, piPred, uiStride, piOrg, uiStride, uiWidth, uiHeight, true ) );
     3052          Dist uiSad;
     3053          if ( m_pcRdCost->getUseVSO() )
     3054          {
     3055            if ( m_pcRdCost->getUseEstimatedVSD() )
     3056            {         
     3057              uiSad = (Dist) ( m_pcRdCost->getDistPartVSD( pcCU, uiPartOffset, piPred, uiStride, piOrg, uiStride, uiWidth, uiHeight, true ) );
     3058            }
     3059            else
     3060            {   
     3061              uiSad = m_pcRdCost->getDistPartVSO(pcCU, uiPartOffset, piPred, uiStride, piOrg, uiStride, uiWidth, uiHeight, true );
     3062            }
    32633063          }
    32643064          else
    3265           {   
    3266             uiSad = m_pcRdCost->getDistPartVSO(pcCU, uiPartOffset, piPred, uiStride, piOrg, uiStride, uiWidth, uiHeight, true );
     3065          {
     3066            uiSad = m_pcRdCost->calcHAD(g_bitDepthY, piOrg, uiStride, piPred, uiStride, uiWidth, uiHeight );
    32673067          }
    3268         }
    3269         else
    3270         {
    3271           uiSad = m_pcRdCost->calcHAD(g_bitDepthY, piOrg, uiStride, piPred, uiStride, uiWidth, uiHeight );
    3272         }
    32733068#else       
    3274         // use hadamard transform here
    3275         UInt uiSad = m_pcRdCost->calcHAD(g_bitDepthY, piOrg, uiStride, piPred, uiStride, uiWidth, uiHeight );
    3276 #endif
    3277        
    3278         UInt   iModeBits = xModeBitsIntra( pcCU, uiMode, uiPU, uiPartOffset, uiDepth, uiInitTrDepth );
     3069          // use hadamard transform here
     3070          UInt uiSad = m_pcRdCost->calcHAD(g_bitDepthY, piOrg, uiStride, piPred, uiStride, uiWidth, uiHeight );
     3071#endif
     3072
     3073          UInt   iModeBits = xModeBitsIntra( pcCU, uiMode, uiPU, uiPartOffset, uiDepth, uiInitTrDepth );
    32793074#if H_3D_VSO // M35
    3280         Double dLambda;
    3281         if ( m_pcRdCost->getUseLambdaScaleVSO() )
    3282         {
    3283           dLambda = m_pcRdCost->getUseRenModel() ? m_pcRdCost->getLambdaVSO() : m_pcRdCost->getSqrtLambdaVSO();
    3284         }
    3285         else       
    3286         {
    3287           dLambda = m_pcRdCost->getSqrtLambda();       
    3288         }
    3289 
    3290         Double cost      = (Double)uiSad + (Double)iModeBits * dLambda;
     3075          Double dLambda;
     3076          if ( m_pcRdCost->getUseLambdaScaleVSO() )
     3077          {
     3078            dLambda = m_pcRdCost->getUseRenModel() ? m_pcRdCost->getLambdaVSO() : m_pcRdCost->getSqrtLambdaVSO();
     3079          }
     3080          else       
     3081          {
     3082            dLambda = m_pcRdCost->getSqrtLambda();       
     3083          }
     3084
     3085          Double cost      = (Double)uiSad + (Double)iModeBits * dLambda;
    32913086#else
    3292         Double cost      = (Double)uiSad + (Double)iModeBits * m_pcRdCost->getSqrtLambda();
    3293 #endif
    3294        
    3295         CandNum += xUpdateCandList( uiMode, cost, numModesForFullRD, uiRdModeList, CandCostList );
    3296       }
    3297    
     3087          Double cost      = (Double)uiSad + (Double)iModeBits * m_pcRdCost->getSqrtLambda();
     3088#endif
     3089
     3090          CandNum += xUpdateCandList( uiMode, cost, numModesForFullRD, uiRdModeList, CandCostList );
     3091        }
     3092
    32983093#if FAST_UDI_USE_MPM
    3299       Int uiPreds[3] = {-1, -1, -1};
    3300       Int iMode = -1;
    3301       Int numCand = pcCU->getIntraDirLumaPredictor( uiPartOffset, uiPreds, &iMode );
    3302       if( iMode >= 0 )
    3303       {
    3304         numCand = iMode;
    3305       }
    3306      
    3307       for( Int j=0; j < numCand; j++)
    3308 
    3309       {
    3310         Bool mostProbableModeIncluded = false;
    3311         Int mostProbableMode = uiPreds[j];
    3312        
     3094        Int uiPreds[3] = {-1, -1, -1};
     3095        Int iMode = -1;
     3096        Int numCand = pcCU->getIntraDirLumaPredictor( uiPartOffset, uiPreds, &iMode );
     3097        if( iMode >= 0 )
     3098        {
     3099          numCand = iMode;
     3100        }
     3101
     3102        for( Int j=0; j < numCand; j++)
     3103
     3104        {
     3105          Bool mostProbableModeIncluded = false;
     3106          Int mostProbableMode = uiPreds[j];
     3107
     3108          for( Int i=0; i < numModesForFullRD; i++)
     3109          {
     3110            mostProbableModeIncluded |= (mostProbableMode == uiRdModeList[i]);
     3111          }
     3112          if (!mostProbableModeIncluded)
     3113          {
     3114            uiRdModeList[numModesForFullRD++] = mostProbableMode;
     3115          }
     3116        }
     3117#endif // FAST_UDI_USE_MPM
     3118      }
     3119      else
     3120      {
    33133121        for( Int i=0; i < numModesForFullRD; i++)
    33143122        {
    3315           mostProbableModeIncluded |= (mostProbableMode == uiRdModeList[i]);
    3316         }
    3317         if (!mostProbableModeIncluded)
    3318         {
    3319           uiRdModeList[numModesForFullRD++] = mostProbableMode;
    3320         }
    3321       }
    3322 #endif // FAST_UDI_USE_MPM
    3323     }
    3324     else
    3325     {
    3326       for( Int i=0; i < numModesForFullRD; i++)
    3327       {
    3328         uiRdModeList[i] = i;
    3329       }
    3330     }
     3123          uiRdModeList[i] = i;
     3124        }
     3125      }
    33313126#if H_3D_DIM
    33323127    }
    33333128#endif
    3334    
     3129
    33353130#if H_3D_DIM
    33363131    //===== determine set of depth intra modes to be tested =====
    33373132    if( m_pcEncCfg->getIsDepth() && uiWidth >= DIM_MIN_SIZE && uiWidth <= DIM_MAX_SIZE && uiWidth == uiHeight )
    33383133    {
    3339 #if TICKET083_IVPFLAG_FIX
    33403134      if( bOnlyIVP )
    3341 #else
    3342       if( bOnlyIVP && pcCU->getSlice()->getIntraContourFlag() )
    3343 #endif
    33443135      {
    33453136        TComWedgelet* dmm4Segmentation = new TComWedgelet( uiWidth, uiHeight );
    … …  
    33573148      {
    33583149#if H_3D_FAST_DEPTH_INTRA
    3359       Int  threshold    = max(((pcCU->getQP(0))>>3)-1,3);
    3360       Int  varThreshold = (Int)( threshold * threshold - 8 );
    3361       UInt varCU      = m_pcRdCost->calcVAR(piOrg, uiStride, uiWidth,uiHeight,pcCU->getDepth(0));
     3150        Int  threshold    = max(((pcCU->getQP(0))>>3)-1,3);
     3151        Int  varThreshold = (Int)( threshold * threshold - 8 );
     3152        UInt varCU      = m_pcRdCost->calcVAR(piOrg, uiStride, uiWidth,uiHeight,pcCU->getDepth(0));
    33623153#endif
    33633154
    33643155#if H_3D_DIM_DMM
    3365       if( ( ( m_pcEncCfg->getUseDMM() &&  pcCU->getSlice()->getIntraSdcWedgeFlag() )  || pcCU->getSlice()->getIntraContourFlag() )
     3156        if( ( ( m_pcEncCfg->getUseDMM() &&  pcCU->getSlice()->getIntraSdcWedgeFlag() )  || pcCU->getSlice()->getIntraContourFlag() )
    33663157#if H_3D_FAST_DEPTH_INTRA
    3367          && (uiRdModeList[0] != PLANAR_IDX || varCU >= varThreshold)
    3368 #endif
    3369         )
    3370       {
    3371         UInt uiStart, uiEnd;
    3372         if( ( m_pcEncCfg->getUseDMM() &&  pcCU->getSlice()->getIntraSdcWedgeFlag() ) &&  pcCU->getSlice()->getIntraContourFlag() )
    3373         {
    3374           uiStart = 0;
    3375           uiEnd   = 2;
    3376         }
    3377         else if( ( m_pcEncCfg->getUseDMM() &&  pcCU->getSlice()->getIntraSdcWedgeFlag() ) )
    3378         {
    3379           uiStart = 0;
    3380           uiEnd   = 1;
    3381         }
    3382         else if( pcCU->getSlice()->getIntraContourFlag() )
    3383         {
    3384           uiStart = 1;
    3385           uiEnd   = 2;
    3386         }
    3387         else
    3388         {
    3389           uiStart = 0;
    3390           uiEnd   = 0;
    3391         }
    3392         for( UInt dmmType = uiStart; dmmType < uiEnd; dmmType++ )
    3393         {
     3158          && (uiRdModeList[0] != PLANAR_IDX || varCU >= varThreshold)
     3159#endif
     3160          )
     3161        {
     3162          UInt uiStart, uiEnd;
     3163          if( ( m_pcEncCfg->getUseDMM() &&  pcCU->getSlice()->getIntraSdcWedgeFlag() ) &&  pcCU->getSlice()->getIntraContourFlag() )
     3164          {
     3165            uiStart = 0;
     3166            uiEnd   = 2;
     3167          }
     3168          else if( ( m_pcEncCfg->getUseDMM() &&  pcCU->getSlice()->getIntraSdcWedgeFlag() ) )
     3169          {
     3170            uiStart = 0;
     3171            uiEnd   = 1;
     3172          }
     3173          else if( pcCU->getSlice()->getIntraContourFlag() )
     3174          {
     3175            uiStart = 1;
     3176            uiEnd   = 2;
     3177          }
     3178          else
     3179          {
     3180            uiStart = 0;
     3181            uiEnd   = 0;
     3182          }
     3183          for( UInt dmmType = uiStart; dmmType < uiEnd; dmmType++ )
     3184          {
    33943185#if H_3D_FCO
    33953186            TComPic* picTexture  = pcCU->getSlice()->getIvPic(false, pcCU->getSlice()->getViewIndex() );
    … …  
    34003191#endif
    34013192            {
    3402                 continue;
     3193              continue;
    34033194            }
    34043195#endif
    3405           UInt uiTabIdx = 0;
    3406           TComWedgelet* biSegmentation = NULL;
    3407           Pel deltaDC1 = 0; Pel deltaDC2 = 0;
    3408           switch( dmmType )
    3409           {
    3410           case( DMM1_IDX ):
     3196            UInt uiTabIdx = 0;
     3197            TComWedgelet* biSegmentation = NULL;
     3198            Pel deltaDC1 = 0; Pel deltaDC2 = 0;
     3199            switch( dmmType )
    34113200            {
    3412               xSearchDmm1Wedge( pcCU, uiPartOffset, piOrg, uiStride, uiWidth, uiHeight, uiTabIdx );
    3413               pcCU->setDmmWedgeTabIdxSubParts( uiTabIdx, dmmType,  uiPartOffset, uiDepth + uiInitTrDepth );
    3414               biSegmentation = pcCU->isDMM1UpscaleMode( uiWidth ) ?
     3201            case( DMM1_IDX ):
     3202              {
     3203                xSearchDmm1Wedge( pcCU, uiPartOffset, piOrg, uiStride, uiWidth, uiHeight, uiTabIdx );
     3204                pcCU->setDmmWedgeTabIdxSubParts( uiTabIdx, dmmType,  uiPartOffset, uiDepth + uiInitTrDepth );
     3205                biSegmentation = pcCU->isDMM1UpscaleMode( uiWidth ) ?
    34153206                  &(g_dmmWedgeLists[(g_aucConvertToBit[pcCU->getDMM1BasePatternWidth(uiWidth)])][uiTabIdx]) : &(g_dmmWedgeLists[(g_aucConvertToBit[uiWidth])][uiTabIdx]);
    3416             } break;
    3417 
    3418           case( DMM4_IDX ):
     3207              } break;
     3208
     3209            case( DMM4_IDX ):
     3210              {
     3211                {
     3212                  biSegmentation = new TComWedgelet( uiWidth, uiHeight );
     3213                  xPredContourFromTex( pcCU, uiPartOffset, uiWidth, uiHeight, biSegmentation );
     3214                }
     3215              } break;
     3216            default: assert(0);
     3217            }
     3218
     3219            if( biSegmentation )
    34193220            {
     3221              if( dmmType == DMM1_IDX && pcCU->isDMM1UpscaleMode( uiWidth ) ){
     3222                xSearchDmmDeltaDCs( pcCU, uiPartOffset, piOrg, piPred, uiStride, biSegmentation->getScaledPattern(uiWidth), uiWidth, uiWidth, uiHeight, deltaDC1, deltaDC2 );
     3223              }
     3224              else
    34203225              {
    3421                 biSegmentation = new TComWedgelet( uiWidth, uiHeight );
    3422                 xPredContourFromTex( pcCU, uiPartOffset, uiWidth, uiHeight, biSegmentation );
     3226                xSearchDmmDeltaDCs( pcCU, uiPartOffset, piOrg, piPred, uiStride, biSegmentation->getPattern(), biSegmentation->getStride(), uiWidth, uiHeight, deltaDC1, deltaDC2 );
    34233227              }
    3424             } break;
    3425           default: assert(0);
     3228              pcCU->setDimDeltaDC( dmmType, 0, uiPartOffset, deltaDC1 );
     3229              pcCU->setDimDeltaDC( dmmType, 1, uiPartOffset, deltaDC2 );
     3230
     3231              uiRdModeList[ numModesForFullRD++ ] = (dmmType  +DIM_OFFSET);
     3232              if( DMM4_IDX == dmmType ) { biSegmentation->destroy(); delete biSegmentation; }
     3233            }
    34263234          }
    3427 
    3428           if( biSegmentation )
    3429           {
    3430             if( dmmType == DMM1_IDX && pcCU->isDMM1UpscaleMode( uiWidth ) ){
    3431                 xSearchDmmDeltaDCs( pcCU, uiPartOffset, piOrg, piPred, uiStride, biSegmentation->getScaledPattern(uiWidth), uiWidth, uiWidth, uiHeight, deltaDC1, deltaDC2 );
    3432             }
    3433             else
    3434             {
    3435                 xSearchDmmDeltaDCs( pcCU, uiPartOffset, piOrg, piPred, uiStride, biSegmentation->getPattern(), biSegmentation->getStride(), uiWidth, uiHeight, deltaDC1, deltaDC2 );
    3436             }
    3437             pcCU->setDimDeltaDC( dmmType, 0, uiPartOffset, deltaDC1 );
    3438             pcCU->setDimDeltaDC( dmmType, 1, uiPartOffset, deltaDC2 );
    3439 
    3440             uiRdModeList[ numModesForFullRD++ ] = (dmmType  +DIM_OFFSET);
    3441             if( DMM4_IDX == dmmType ) { biSegmentation->destroy(); delete biSegmentation; }
    3442           }
    3443         }
    3444       }
     3235        }
    34453236#if H_3D_DIM
    34463237      }
    … …  
    34543245    Double dSecondBestPUCost = MAX_DOUBLE;
    34553246#endif
    3456    
     3247
    34573248    UInt    uiBestPUMode  = 0;
    34583249#if H_3D_FAST_INTRA_SDC
    … …  
    34883279      // set luma prediction mode
    34893280#if !H_3D_FAST_INTRA_SDC
    3490      UInt uiOrgMode = uiRdModeList[uiMode]; 
    3491 #endif
    3492      
     3281      UInt uiOrgMode = uiRdModeList[uiMode]; 
     3282#endif
     3283
    34933284#if H_3D_FAST_INTRA_SDC
    34943285      UInt uiOrgMode;
    34953286      if (uiMode < numModesForFullRD)
    34963287      {   
    3497          uiOrgMode = uiRdModeList[uiMode];
     3288        uiOrgMode = uiRdModeList[uiMode];
    34983289      }
    34993290      else
    35003291      {
    3501            uiOrgMode = uiRdModeList[uiMode - numModesForFullRD];
    3502 
    3503            if (uiBestPUModeConv <= 1 )
    3504            {
    3505            if (uiOrgMode > 1 && varCU < 1) continue;         
    3506            }
    3507            else
    3508            {
    3509               if (uiOrgMode != uiBestPUModeConv && uiOrgMode != uiSecondBestPUModeConv && uiOrgMode != uiThirdBestPUModeConv
    3510                   && uiOrgMode > 1 && uiOrgMode < NUM_INTRA_MODE && varCU < 4)
    3511               continue;
    3512            }
    3513        }
     3292        uiOrgMode = uiRdModeList[uiMode - numModesForFullRD];
     3293
     3294        if (uiBestPUModeConv <= 1 )
     3295        {
     3296          if (uiOrgMode > 1 && varCU < 1) continue;         
     3297        }
     3298        else
     3299        {
     3300          if (uiOrgMode != uiBestPUModeConv && uiOrgMode != uiSecondBestPUModeConv && uiOrgMode != uiThirdBestPUModeConv
     3301            && uiOrgMode > 1 && uiOrgMode < NUM_INTRA_MODE && varCU < 4)
     3302            continue;
     3303        }
     3304      }
    35143305#endif
    35153306
    35163307      pcCU->setLumaIntraDirSubParts ( uiOrgMode, uiPartOffset, uiDepth + uiInitTrDepth );
    3517      
     3308
    35183309#if H_3D_DIM_SDC
    35193310#if H_3D_FAST_INTRA_SDC
    … …  
    35223313      Bool bTestSDC = ( m_pcEncCfg->getUseSDC() && pcCU->getSDCAvailable(uiPartOffset) );
    35233314#endif
    3524      
     3315
    35253316      for( UInt uiSDC=0; uiSDC<=(bTestSDC?1:0); uiSDC++ )
    35263317      {
    … …  
    35613352          }
    35623353#endif
    3563      
     3354
    35643355#if H_3D_DIM_ENC || H_3D_DIM_SDC
    3565       Bool bTestZeroResi = false;
     3356          Bool bTestZeroResi = false;
    35663357#if H_3D_DIM_ENC
    3567       bTestZeroResi |= pcCU->getSlice()->getIsDepth() && !pcCU->getSlice()->isIRAP();
     3358          bTestZeroResi |= pcCU->getSlice()->getIsDepth() && !pcCU->getSlice()->isIRAP();
    35683359#endif
    35693360#if H_3D_DIM_SDC
    3570       bTestZeroResi |= pcCU->getSDCFlag(uiPartOffset);
    3571 #endif
    3572       if( uiSDC != 0 && iSDCDeltaResi != 0 )
    3573       {
    3574         bTestZeroResi = false;
    3575       }
    3576 #endif
    3577      
     3361          bTestZeroResi |= pcCU->getSDCFlag(uiPartOffset);
     3362#endif
     3363          if( uiSDC != 0 && iSDCDeltaResi != 0 )
     3364          {
     3365            bTestZeroResi = false;
     3366          }
     3367#endif
     3368
    35783369#if H_3D_DIM_ENC || H_3D_DIM_SDC     
    3579       for( UInt testZeroResi = 0; testZeroResi <= (bTestZeroResi ? 1 : 0) ; testZeroResi++ )
    3580       {
    3581 #endif
    3582         // set context models
    3583         m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
    3584 
    3585         // determine residual for partition
     3370          for( UInt testZeroResi = 0; testZeroResi <= (bTestZeroResi ? 1 : 0) ; testZeroResi++ )
     3371          {
     3372#endif
     3373            // set context models
     3374            m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
     3375
     3376            // determine residual for partition
    35863377#if H_3D_VSO
    3587         Dist   uiPUDistY = 0;
     3378            Dist   uiPUDistY = 0;
    35883379#else
    3589         UInt   uiPUDistY = 0;
    3590 #endif
    3591         UInt   uiPUDistC = 0;
    3592         Double dPUCost   = 0.0;
     3380            UInt   uiPUDistY = 0;
     3381#endif
     3382            UInt   uiPUDistC = 0;
     3383            Double dPUCost   = 0.0;
    35933384#if H_3D_VSO // M36
    3594         if( m_pcRdCost->getUseRenModel() )
    3595         {
    3596           m_pcRdCost->setRenModelData( pcCU, uiPartOffset, piOrg, uiStride, uiWidth, uiHeight );
    3597         }
     3385            if( m_pcRdCost->getUseRenModel() )
     3386            {
     3387              m_pcRdCost->setRenModelData( pcCU, uiPartOffset, piOrg, uiStride, uiWidth, uiHeight );
     3388            }
    35983389#endif
    35993390#if H_3D_DIM_SDC
    3600         if( pcCU->getSDCFlag(uiPartOffset) )
    3601         {
    3602           pcCU->setTrIdxSubParts(0, uiPartOffset, uiDepth + uiInitTrDepth);
    3603           pcCU->setCbfSubParts(1, 1, 1, uiPartOffset, uiDepth + uiInitTrDepth);
    3604 
    3605           // start encoding with SDC
    3606           xIntraCodingSDC(pcCU, uiPartOffset, pcOrgYuv, pcPredYuv, uiPUDistY, dPUCost, ( testZeroResi != 0 ), iSDCDeltaResi );
    3607           if ( testZeroResi == 0 && iOffset <= 3 )
    3608           {
    3609             dOffsetCost [iOffset -1] = dPUCost;
    3610           }
    3611         }
    3612         else
    3613         {
     3391            if( pcCU->getSDCFlag(uiPartOffset) )
     3392            {
     3393              pcCU->setTrIdxSubParts(0, uiPartOffset, uiDepth + uiInitTrDepth);
     3394              pcCU->setCbfSubParts(1, 1, 1, uiPartOffset, uiDepth + uiInitTrDepth);
     3395
     3396              // start encoding with SDC
     3397              xIntraCodingSDC(pcCU, uiPartOffset, pcOrgYuv, pcPredYuv, uiPUDistY, dPUCost, ( testZeroResi != 0 ), iSDCDeltaResi );
     3398              if ( testZeroResi == 0 && iOffset <= 3 )
     3399              {
     3400                dOffsetCost [iOffset -1] = dPUCost;
     3401              }
     3402            }
     3403            else
     3404            {
    36143405#endif
    36153406#if HHI_RQT_INTRA_SPEEDUP
    36163407#if H_3D_DIM_ENC
    3617           xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, true, dPUCost, (testZeroResi != 0) );
     3408              xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, true, dPUCost, (testZeroResi != 0) );
    36183409#if H_3D_FAST_INTRA_SDC   
    3619       if( dPUCost < dBestPUCostConv )
    3620       {
    3621         uiThirdBestPUModeConv = uiSecondBestPUModeConv;
    3622         uiSecondBestPUModeConv = uiBestPUModeConv;
    3623         uiBestPUModeConv  = uiOrgMode;
    3624         dBestPUCostConv   = dPUCost;
    3625       }
     3410              if( dPUCost < dBestPUCostConv )
     3411              {
     3412                uiThirdBestPUModeConv = uiSecondBestPUModeConv;
     3413                uiSecondBestPUModeConv = uiBestPUModeConv;
     3414                uiBestPUModeConv  = uiOrgMode;
     3415                dBestPUCostConv   = dPUCost;
     3416              }
    36263417#endif
    36273418#else
    3628           xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, true, dPUCost );
     3419              xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, true, dPUCost );
    36293420#endif
    36303421#else
    36313422#if H_3D_DIM_ENC
    3632           xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, dPUCost, (testZeroResi != 0) );
     3423              xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, dPUCost, (testZeroResi != 0) );
    36333424#else
    3634           xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, dPUCost );
     3425              xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, dPUCost );
    36353426#endif
    36363427#endif
    36373428#if H_3D_DIM_SDC
    3638         }
    3639 #endif
    3640 
    3641         // check r-d cost
    3642         if( dPUCost < dBestPUCost )
    3643         {
     3429            }
     3430#endif
     3431
     3432            // check r-d cost
     3433            if( dPUCost < dBestPUCost )
     3434            {
    36443435#if HHI_RQT_INTRA_SPEEDUP_MOD
    3645           uiSecondBestMode  = uiBestPUMode;
    3646           dSecondBestPUCost = dBestPUCost;
    3647 #endif
    3648           uiBestPUMode  = uiOrgMode;
    3649           uiBestPUDistY = uiPUDistY;
    3650           uiBestPUDistC = uiPUDistC;
    3651           dBestPUCost   = dPUCost;
     3436              uiSecondBestMode  = uiBestPUMode;
     3437              dSecondBestPUCost = dBestPUCost;
     3438#endif
     3439              uiBestPUMode  = uiOrgMode;
     3440              uiBestPUDistY = uiPUDistY;
     3441              uiBestPUDistC = uiPUDistC;
     3442              dBestPUCost   = dPUCost;
    36523443
    36533444#if H_3D_DIM_SDC
    3654           if( pcCU->getSDCFlag(uiPartOffset) )
    3655           {
    3656             bBestUseSDC = true;
    3657 
    3658             // copy reconstruction
    3659             pcPredYuv->copyPartToPartYuv(pcRecoYuv, uiPartOffset, uiWidth, uiHeight);
    3660 
    3661             // copy DC values
    3662             apBestDCOffsets[0] = pcCU->getSDCSegmentDCOffset(0, uiPartOffset);
    3663             apBestDCOffsets[1] = pcCU->getSDCSegmentDCOffset(1, uiPartOffset);
     3445              if( pcCU->getSDCFlag(uiPartOffset) )
     3446              {
     3447                bBestUseSDC = true;
     3448
     3449                // copy reconstruction
     3450                pcPredYuv->copyPartToPartYuv(pcRecoYuv, uiPartOffset, uiWidth, uiHeight);
     3451
     3452                // copy DC values
     3453                apBestDCOffsets[0] = pcCU->getSDCSegmentDCOffset(0, uiPartOffset);
     3454                apBestDCOffsets[1] = pcCU->getSDCSegmentDCOffset(1, uiPartOffset);
     3455              }
     3456              else
     3457              {
     3458                bBestUseSDC = false;
     3459#endif
     3460                xSetIntraResultQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcRecoYuv );
     3461
     3462                UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth(0) + uiInitTrDepth ) << 1 );
     3463                ::memcpy( m_puhQTTempTrIdx,  pcCU->getTransformIdx()       + uiPartOffset, uiQPartNum * sizeof( UChar ) );
     3464                ::memcpy( m_puhQTTempCbf[0], pcCU->getCbf( TEXT_LUMA     ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
     3465                ::memcpy( m_puhQTTempCbf[1], pcCU->getCbf( TEXT_CHROMA_U ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
     3466                ::memcpy( m_puhQTTempCbf[2], pcCU->getCbf( TEXT_CHROMA_V ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
     3467                ::memcpy( m_puhQTTempTransformSkipFlag[0], pcCU->getTransformSkip(TEXT_LUMA)     + uiPartOffset, uiQPartNum * sizeof( UChar ) );
     3468                ::memcpy( m_puhQTTempTransformSkipFlag[1], pcCU->getTransformSkip(TEXT_CHROMA_U) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
     3469                ::memcpy( m_puhQTTempTransformSkipFlag[2], pcCU->getTransformSkip(TEXT_CHROMA_V) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
     3470#if H_3D_DIM_SDC
     3471              }
     3472#endif
     3473            }
     3474#if HHI_RQT_INTRA_SPEEDUP_MOD
     3475            else if( dPUCost < dSecondBestPUCost )
     3476            {
     3477              uiSecondBestMode  = uiOrgMode;
     3478              dSecondBestPUCost = dPUCost;
     3479            }
     3480#endif
     3481#if H_3D_DIM_ENC || H_3D_DIM_SDC
    36643482          }
    3665           else
    3666           {
    3667             bBestUseSDC = false;
    3668 #endif
    3669             xSetIntraResultQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcRecoYuv );
    3670 
    3671             UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth(0) + uiInitTrDepth ) << 1 );
    3672             ::memcpy( m_puhQTTempTrIdx,  pcCU->getTransformIdx()       + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    3673             ::memcpy( m_puhQTTempCbf[0], pcCU->getCbf( TEXT_LUMA     ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    3674             ::memcpy( m_puhQTTempCbf[1], pcCU->getCbf( TEXT_CHROMA_U ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    3675             ::memcpy( m_puhQTTempCbf[2], pcCU->getCbf( TEXT_CHROMA_V ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    3676             ::memcpy( m_puhQTTempTransformSkipFlag[0], pcCU->getTransformSkip(TEXT_LUMA)     + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    3677             ::memcpy( m_puhQTTempTransformSkipFlag[1], pcCU->getTransformSkip(TEXT_CHROMA_U) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    3678             ::memcpy( m_puhQTTempTransformSkipFlag[2], pcCU->getTransformSkip(TEXT_CHROMA_V) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    3679 #if H_3D_DIM_SDC
    3680           }
    3681 #endif
    3682         }
    3683 #if HHI_RQT_INTRA_SPEEDUP_MOD
    3684         else if( dPUCost < dSecondBestPUCost )
    3685         {
    3686           uiSecondBestMode  = uiOrgMode;
    3687           dSecondBestPUCost = dPUCost;
    3688         }
    3689 #endif
    3690 #if H_3D_DIM_ENC || H_3D_DIM_SDC
    3691       }
    36923483        } // SDC residual loop
    36933484#endif
    … …  
    36963487#endif
    36973488    } // Mode loop
    3698    
     3489
    36993490#if HHI_RQT_INTRA_SPEEDUP
    37003491#if HHI_RQT_INTRA_SPEEDUP_MOD
    … …  
    37113502      UInt uiOrgMode = uiBestPUMode;
    37123503#endif
    3713      
     3504
    37143505      pcCU->setLumaIntraDirSubParts ( uiOrgMode, uiPartOffset, uiDepth + uiInitTrDepth );
    37153506#if H_3D_DIM_SDC
    37163507      pcCU->setSDCFlagSubParts(false, uiPartOffset, uiDepth + uiInitTrDepth);
    37173508#endif
    3718      
     3509
    37193510      // set context models
    3720         m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
    3721      
     3511      m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
     3512
    37223513      // determine residual for partition
    37233514#if H_3D_VSO
    … …  
    37363527#endif
    37373528      xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, false, dPUCost );
    3738      
     3529
    37393530      // check r-d cost
    37403531      if( dPUCost < dBestPUCost )
    … …  
    37473538        bBestUseSDC   = false;
    37483539#endif
    3749        
     3540
    37503541        xSetIntraResultQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcRecoYuv );
    3751        
     3542
    37523543        UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth(0) + uiInitTrDepth ) << 1 );
    37533544        ::memcpy( m_puhQTTempTrIdx,  pcCU->getTransformIdx()       + uiPartOffset, uiQPartNum * sizeof( UChar ) );
    … …  
    37613552    } // Mode loop
    37623553#endif
    3763    
     3554
    37643555    //--- update overall distortion ---
    37653556    uiOverallDistY += uiBestPUDistY;
    37663557    uiOverallDistC += uiBestPUDistC;
    3767    
     3558
    37683559#if H_3D_DIM_SDC
    37693560    if( bBestUseSDC )
    … …  
    37713562      pcCU->setTrIdxSubParts(0, uiPartOffset, uiDepth + uiInitTrDepth);
    37723563      pcCU->setCbfSubParts(1, 1, 1, uiPartOffset, uiDepth + uiInitTrDepth);
    3773      
     3564
    37743565      //=== copy best DC segment values back to CU ====
    37753566      pcCU->setSDCSegmentDCOffset(apBestDCOffsets[0], 0, uiPartOffset);
    … …  
    37793570    {
    37803571#endif
    3781         //--- update transform index and cbf ---
    3782     UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth(0) + uiInitTrDepth ) << 1 );
    3783     ::memcpy( pcCU->getTransformIdx()       + uiPartOffset, m_puhQTTempTrIdx,  uiQPartNum * sizeof( UChar ) );
    3784     ::memcpy( pcCU->getCbf( TEXT_LUMA     ) + uiPartOffset, m_puhQTTempCbf[0], uiQPartNum * sizeof( UChar ) );
    3785     ::memcpy( pcCU->getCbf( TEXT_CHROMA_U ) + uiPartOffset, m_puhQTTempCbf[1], uiQPartNum * sizeof( UChar ) );
    3786     ::memcpy( pcCU->getCbf( TEXT_CHROMA_V ) + uiPartOffset, m_puhQTTempCbf[2], uiQPartNum * sizeof( UChar ) );
    3787     ::memcpy( pcCU->getTransformSkip(TEXT_LUMA)     + uiPartOffset, m_puhQTTempTransformSkipFlag[0], uiQPartNum * sizeof( UChar ) );
    3788     ::memcpy( pcCU->getTransformSkip(TEXT_CHROMA_U) + uiPartOffset, m_puhQTTempTransformSkipFlag[1], uiQPartNum * sizeof( UChar ) );
    3789     ::memcpy( pcCU->getTransformSkip(TEXT_CHROMA_V) + uiPartOffset, m_puhQTTempTransformSkipFlag[2], uiQPartNum * sizeof( UChar ) );
     3572      //--- update transform index and cbf ---
     3573      UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth(0) + uiInitTrDepth ) << 1 );
     3574      ::memcpy( pcCU->getTransformIdx()       + uiPartOffset, m_puhQTTempTrIdx,  uiQPartNum * sizeof( UChar ) );
     3575      ::memcpy( pcCU->getCbf( TEXT_LUMA     ) + uiPartOffset, m_puhQTTempCbf[0], uiQPartNum * sizeof( UChar ) );
     3576      ::memcpy( pcCU->getCbf( TEXT_CHROMA_U ) + uiPartOffset, m_puhQTTempCbf[1], uiQPartNum * sizeof( UChar ) );
     3577      ::memcpy( pcCU->getCbf( TEXT_CHROMA_V ) + uiPartOffset, m_puhQTTempCbf[2], uiQPartNum * sizeof( UChar ) );
     3578      ::memcpy( pcCU->getTransformSkip(TEXT_LUMA)     + uiPartOffset, m_puhQTTempTransformSkipFlag[0], uiQPartNum * sizeof( UChar ) );
     3579      ::memcpy( pcCU->getTransformSkip(TEXT_CHROMA_U) + uiPartOffset, m_puhQTTempTransformSkipFlag[1], uiQPartNum * sizeof( UChar ) );
     3580      ::memcpy( pcCU->getTransformSkip(TEXT_CHROMA_V) + uiPartOffset, m_puhQTTempTransformSkipFlag[2], uiQPartNum * sizeof( UChar ) );
    37903581#if H_3D_DIM_SDC
    37913582    }
    … …  
    38033594        bChromaSame  = true;
    38043595      }
    3805      
     3596
    38063597      UInt    uiCompWidth   = pcCU->getWidth ( 0 ) >> uiInitTrDepth;
    38073598      UInt    uiCompHeight  = pcCU->getHeight( 0 ) >> uiInitTrDepth;
    … …  
    38553646      }
    38563647    }
    3857    
     3648
    38583649    //=== update PU data ====
    38593650    pcCU->setLumaIntraDirSubParts     ( uiBestPUMode, uiPartOffset, uiDepth + uiInitTrDepth );
    … …  
    41833974 
    41843975#if H_3D_DBBP
    4185   DBBPTmpData* pDBBPTmpData = pcCU->getDBBPTmpData();
     3976  DbbpTmpData* pDBBPTmpData = pcCU->getDBBPTmpData();
    41863977  if( pcCU->getDBBPFlag(0) )
    41873978  {
    … …  
    51734964  {
    51744965#if H_3D_DBBP
    5175     DBBPTmpData* pDBBPTmpData = pcCU->getDBBPTmpData();
     4966    DbbpTmpData* pDBBPTmpData = pcCU->getDBBPTmpData();
    51764967    if( pcCU->getDBBPFlag(0) )
    51774968    {
    … …  
    55345325  TComMv      cMvPred = *pcMvPred;
    55355326 
    5536 #if SONY_MV_V_CONST_C0078
    5537   Bool bMv_VRng_Restricted = false;
     5327#if H_MV
     5328  Bool motVecVertRngRestricted = false;
    55385329  if( m_pcEncCfg->getUseDisparitySearchRangeRestriction()
    55395330       &&
    … …  
    55415332    )
    55425333  {
    5543       bMv_VRng_Restricted = true;
    5544   }
    5545   if ( bBi )  xSetSearchRange   ( pcCU, rcMv   , iSrchRng, cMvSrchRngLT, cMvSrchRngRB, bMv_VRng_Restricted, m_pcEncCfg->getVerticalDisparitySearchRange() );
    5546   else        xSetSearchRange   ( pcCU, cMvPred, iSrchRng, cMvSrchRngLT, cMvSrchRngRB, bMv_VRng_Restricted, m_pcEncCfg->getVerticalDisparitySearchRange() );
     5334      motVecVertRngRestricted = true;
     5335  }
     5336  if ( bBi )  xSetSearchRange   ( pcCU, rcMv   , iSrchRng, cMvSrchRngLT, cMvSrchRngRB, motVecVertRngRestricted, m_pcEncCfg->getVerticalDisparitySearchRange() );
     5337  else        xSetSearchRange   ( pcCU, cMvPred, iSrchRng, cMvSrchRngLT, cMvSrchRngRB, motVecVertRngRestricted, m_pcEncCfg->getVerticalDisparitySearchRange() );
    55475338#else
    55485339  if ( bBi )  xSetSearchRange   ( pcCU, rcMv   , iSrchRng, cMvSrchRngLT, cMvSrchRngRB );
    … …  
    56015392
    56025393
    5603 #if SONY_MV_V_CONST_C0078
     5394#if H_MV
    56045395Void TEncSearch::xSetSearchRange ( TComDataCU* pcCU, TComMv& cMvPred, Int iSrchRng, TComMv& rcMvSrchRngLT, TComMv& rcMvSrchRngRB, Bool bMv_VRng_Restricted, Int iVerDispSrchRng )
    56055396#else
    … …  
    56215412  rcMvSrchRngRB.setVer( cTmpMvPred.getVer() + (iSrchRng << iMvShift) );
    56225413 
    5623 #if SONY_MV_V_CONST_C0078
     5414#if H_MV
    56245415  if ( bMv_VRng_Restricted ) {
    56255416    Int iRestrictMvVrange = ( iVerDispSrchRng - 1 ) << iMvShift ; // -1 to consider subpel search
    … …  
    57325523  if( ! pcCU->getSlice()->getIsDepth() )
    57335524#endif
    5734   rcMv >>= 2;
     5525    rcMv >>= 2;
    57355526  // init TZSearchStruct
    57365527  IntTZSearchStruct cStruct;
    … …  
    73697160    const UInt uiQTTempAccessLayer = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
    73707161
    7371 #if 0 //H_3D_DISABLE_CHROMA
    7372     Bool  bCodeChroma   = !pcCU->getSlice()->getIsDepth();
    7373 #else
    73747162    Bool  bCodeChroma   = true;
    7375 #endif
    73767163    UInt  uiTrModeC     = uiTrMode;
    73777164    UInt  uiLog2TrSizeC = uiLog2TrSize-1;
    … …  
    75157302    }
    75167303    m_pcEntropyCoder->encodeSkipFlag ( pcCU, 0, true );
    7517 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     7304#if H_3D
    75187305    m_pcEntropyCoder->encodeDIS ( pcCU, 0, true );
    7519 #else
    7520 #if H_3D_SINGLE_DEPTH
    7521     m_pcEntropyCoder->encodeSingleDepthMode ( pcCU, 0, true );
    7522 #endif
    75237306#endif
    75247307    m_pcEntropyCoder->encodePredMode( pcCU, 0, true );
    75257308    m_pcEntropyCoder->encodePartSize( pcCU, 0, pcCU->getDepth(0), true );
    7526 #if !HHI_MOVE_SYN_K0052
     7309    m_pcEntropyCoder->encodePredInfo( pcCU, 0, true );
    75277310#if H_3D_DIM_SDC
    75287311    m_pcEntropyCoder->encodeSDCFlag( pcCU, 0, true );
    75297312#endif
    7530 #endif
    7531     m_pcEntropyCoder->encodePredInfo( pcCU, 0, true );
    7532 #if HHI_MOVE_SYN_K0052
    7533 #if H_3D_DIM_SDC
    7534     m_pcEntropyCoder->encodeSDCFlag( pcCU, 0, true );
    7535 #endif
    7536 #endif
    75377313#if H_3D_ARP
    75387314    m_pcEntropyCoder->encodeARPW( pcCU , 0  );
    … …  
    75417317    m_pcEntropyCoder->encodeICFlag( pcCU, 0, true );
    75427318#endif
    7543 #if HHI_MOVE_SYN_K0052
     7319#if H_3D
    75447320    m_pcEntropyCoder->encodeDBBPFlag( pcCU, 0, true );
    75457321#endif

  • trunk/source/Lib/TLibEncoder/TEncSearch.h

    r1179 r1196  
    191191                                  TComYuv*    pcRecoYuv,
    192192                                  UInt        uiPreCalcDistC );
    193 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     193#if H_3D
    194194  Void  estIntraPredDIS        ( TComDataCU* pcCU,
    195195                                 TComYuv*    pcOrgYuv,
    … …  
    199199                                 UInt&       ruiDistC,
    200200                                 Bool        bLumaOnly );
    201 #else
    202 #if H_3D_SINGLE_DEPTH
    203   Void  estIntraPredSingleDepth  ( TComDataCU* pcCU,
    204                                   TComYuv*    pcOrgYuv,
    205                                   TComYuv*    pcPredYuv,
    206                                   TComYuv*    pcResiYuv,
    207                                   TComYuv*    pcRecoYuv,
    208                                   UInt&       ruiDistC,
    209                                   Bool        bLumaOnly );
    210 #endif
    211 #endif
    212  
     201#endif 
    213202  /// encoder estimation - inter prediction (non-skip)
    214203  Void predInterSearch          ( TComDataCU* pcCU,
    … …  
    364353                                    UInt         uiAbsPartIdx,
    365354                                    UInt         stateU0V1Both2 );
    366 #if SEC_DEPTH_INTRA_SKIP_MODE_K0033
     355
     356#if H_3D
    367357  Void xIntraCodingDIS           ( TComDataCU* pcCU, UInt uiAbsPartIdx, TComYuv* pcOrgYuv, TComYuv* pcPredYuv, Dist& ruiDist, Double& dRDCost, UInt uiPredMode );
    368 #else
    369 #if H_3D_SINGLE_DEPTH
    370   Void xIntraCodingSingleDepth( TComDataCU* pcCU, UInt uiAbsPartIdx, TComYuv* pcOrgYuv, TComYuv* pcPredYuv, Dist& ruiDist, Double& dRDCost, Int iTestDepthIdx, Pel * DepthNeighbor );
    371 #endif
    372358#endif
    373359#if H_3D_DIM
    … …  
    480466                                    UInt&         ruiSAD );
    481467 
    482 #if SONY_MV_V_CONST_C0078
     468#if H_MV
    483469  Void xSetSearchRange           (  TComDataCU* pcCU,
    484470                                    TComMv& cMvPred,

  • trunk/source/Lib/TLibEncoder/TEncSlice.cpp

    r1179 r1196  
    215215  rpcSlice->setPicOutputFlag( true );
    216216  rpcSlice->setPOC( pocCurr );
    217 #if !HHI_INTER_COMP_PRED_K0052
    218 #if H_3D
    219     rpcSlice->init3dToolParameters();
    220 #endif
    221 #endif
    222217#if H_3D_IC
    223218  rpcSlice->setApplyIC( false );
    … …  
    612607  rpcSlice->setSliceSegmentMode     ( m_pcCfg->getSliceSegmentMode()     );
    613608  rpcSlice->setSliceSegmentArgument ( m_pcCfg->getSliceSegmentArgument() );
    614 #if !HHI_INTER_COMP_PRED_K0052
    615 #if H_3D_IV_MERGE
    616   rpcSlice->setMaxNumMergeCand      ( m_pcCfg->getMaxNumMergeCand()   + ( ( rpcSlice->getMpiFlag( ) || rpcSlice->getIvMvPredFlag( ) || rpcSlice->getViewSynthesisPredFlag( )   ) ? 1 : 0 ));
    617 #else
    618   rpcSlice->setMaxNumMergeCand        ( m_pcCfg->getMaxNumMergeCand()        );
    619 #endif
    620 #else
    621609#if !H_3D
    622610  rpcSlice->setMaxNumMergeCand        ( m_pcCfg->getMaxNumMergeCand()        );
    623 #endif
    624611#endif
    625612  xStoreWPparam( pPPS->getUseWP(), pPPS->getWPBiPred() );

  • trunk/source/Lib/TLibEncoder/TEncTop.cpp

    r1179 r1196  
    9191  m_aICEnableNum = NULL;
    9292#endif
    93 #if H_3D_ANNEX_SELECTION_FIX
     93#if H_3D
    9494  m_cCavlcCoder.setEncTop(this);
    9595#endif
    … …  
    417417#endif
    418418#if H_3D
    419 #if HHI_CAM_PARA_K0052
    420419  pcPicCurr->setScaleOffset( m_cameraParameters->getCodedScale(), m_cameraParameters->getCodedOffset() );
    421 #else
    422   pcPicCurr->setScaleOffset( m_aaiCodedScale, m_aaiCodedOffset );
    423 #endif
    424420#endif
    425421}
    … …  
    768764    m_cSPS.setSpsInferScalingListFlag   ( true );
    769765    m_cSPS.setSpsScalingListRefLayerId( m_cVPS->getIdRefLayer( getLayerId(), 0 ) );
    770 #if SONY_MV_V_CONST_C0078
     766#if H_MV
    771767    if ( m_bUseDisparitySearchRangeRestriction )
    772768    {
Note: See TracChangeset for help on using the changeset viewer.