Changeset 648 in 3DVCSoftware


Ignore:
Timestamp:
19 Oct 2013, 18:46:09 (11 years ago)
Author:
tech
Message:

Macro removal part H_MV5.

Location:
branches/HTM-8.2-dev0-Cleanup/source
Files:
23 edited

Legend:

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

    r646 r648  
    500500        const Window &defDisp = m_respectDefDispWindow ? pcPic->getDefDisplayWindow() : Window();
    501501#if H_MV
    502 #if H_MV5
    503502        assert( conf   .getScaledFlag() );
    504503        assert( defDisp.getScaledFlag() );
    505 #endif
    506504        m_tVideoIOYuvReconFile[decIdx]->write( pcPic->getPicYuvRec(),
    507505#else
     
    577575        const Window &defDisp = m_respectDefDispWindow ? pcPic->getDefDisplayWindow() : Window();
    578576#if H_MV
    579 #if H_MV5
    580577        assert( conf   .getScaledFlag() );
    581578        assert( defDisp.getScaledFlag() );
    582 #endif
    583579        m_tVideoIOYuvReconFile[decIdx]->write( pcPic->getPicYuvRec(),
    584580#else
  • branches/HTM-8.2-dev0-Cleanup/source/App/TAppEncoder/TAppEncCfg.cpp

    r647 r648  
    228228    in>>entry.m_interViewRefPosL[1][i];
    229229  }
    230 #if !H_MV5
    231   if (entry.m_numActiveRefLayerPics > 0 )
    232   {
    233     in>>entry.m_collocatedRefLayerIdx;
    234   }
    235 #endif
    236230#endif
    237231  return in;
     
    373367  ("NumberOfLayers",        m_numberOfLayers     , 1,                     "Number of layers")
    374368#if !H_3D
    375 #if H_MV5
    376369  ("ScalabilityMask",       m_scalabilityMask    , 2                    , "Scalability Mask")   
    377 #else
    378   ("ScalabilityMask",       m_scalabilityMask    , 1                    , "Scalability Mask")   
    379 #endif
    380370#else
    381371  ("ScalabilityMask",       m_scalabilityMask    , 3                    , "Scalability Mask, 1: Texture 3: Texture + Depth ")   
    382372#endif 
    383373  ("DimensionIdLen",        m_dimensionIdLen     , cfg_dimensionLength  , "Number of bits used to store dimensions Id")
    384 #if H_MV5
    385374  ("ViewOrderIndex",        m_viewOrderIndex     , std::vector<Int>(1,0), "View Order Index per layer")
    386375  ("ViewId",                m_viewId             , std::vector<Int>(1,0), "View Id per View Order Index")
    387 #else
    388   ("ViewId",                m_viewId             , std::vector<Int>(1,0), "View Id")
    389 #endif
    390376#if H_3D
    391377  ("DepthFlag",             m_depthFlag          , std::vector<Int>(1,0), "Depth Flag")
     
    620606#endif
    621607
    622 #if H_MV5
    623608#if H_MV
    624609  // VPS VUI
     
    637622  ("CtuBasedOffsetEnabledFlag"   , m_ctuBasedOffsetEnabledFlag   , std::vector< Bool >(1,0)  ,MAX_NUM_LAYERS       , "CtuBasedOffsetEnabledFlag    per direct reference for the N-th layer")
    638623  ("MinHorizontalCtuOffsetPlus1" , m_minHorizontalCtuOffsetPlus1 , std::vector< Int  >(1,0)  ,MAX_NUM_LAYERS       , "MinHorizontalCtuOffsetPlus1  per direct reference for the N-th layer")
    639 #endif
    640624#endif
    641625
     
    782766    if( k == 0 )
    783767    {
    784 #if H_MV5
    785768      m_GOPListMvc[0][0].m_sliceType = 'I';
    786 #endif
    787769      for( Int i = 1; i < MAX_GOP + 1; i++ )
    788770      {
     
    988970  // allocate slice-based dQP values
    989971#if H_MV
    990 #if H_MV5
    991972  xResizeVector( m_viewOrderIndex    );
    992973
     
    1008989#if H_3D
    1009990  xResizeVector( m_depthFlag );
    1010 #endif
    1011 #else
    1012   xResizeVector( m_viewId    );
    1013 #if H_3D
    1014   xResizeVector( m_depthFlag );
    1015 
    1016   std::vector<Int> uniqueViewIds;
    1017   for( Int layer = 0; layer < m_numberOfLayers; layer++ )
    1018   {   
    1019     Bool isIn = false;
    1020     for ( Int i = 0 ; i < uniqueViewIds.size(); i++ )
    1021     {
    1022       isIn = isIn || ( m_viewId[ layer ] == uniqueViewIds[ i ] );
    1023     }
    1024     if ( !isIn )
    1025     {
    1026       uniqueViewIds.push_back( m_viewId[ layer ] );
    1027     }
    1028   }
    1029   m_iNumberOfViews = (Int) uniqueViewIds.size();
    1030 #endif
    1031 
    1032991#endif
    1033992  xResizeVector( m_fQP );
     
    13031262  xConfirmPara( (m_layerIdInNuh.size()!=1) && (m_layerIdInNuh.size() < m_numberOfLayers) , "LayerIdInNuh must be given for all layers. ");
    13041263 
    1305 #if H_MV5
    13061264#if H_3D
    13071265  xConfirmPara( m_scalabilityMask != 2 && m_scalabilityMask != 3, "Scalability Mask must be equal to 2 or 3. ");
     
    13181276
    13191277  m_dimIds.push_back( m_viewOrderIndex );   
    1320 #else
    1321 #if H_3D
    1322   xConfirmPara( m_scalabilityMask != 1 && m_scalabilityMask != 3, "Scalability Mask must be equal to 1 or 3. ");
    1323 #else
    1324   xConfirmPara( m_scalabilityMask != 1 , "Scalability Mask must be equal to 1. ");
    1325 #endif
    1326  
    1327   m_dimIds.push_back( m_viewId );
    1328   const Int viewDimPosition = 0;
    1329 #if H_3D
    1330   if ( m_scalabilityMask & ( 1 << DEPTH_ID ) )
    1331     m_dimIds.push_back( m_depthFlag );
    1332 #endif
    1333 
    1334 #endif
    13351278  xConfirmPara(  m_dimensionIdLen.size() < m_dimIds.size(), "DimensionIdLen must be given for all dimensions. "   );   Int dimBitOffset[MAX_NUM_SCALABILITY_TYPES+1];
    13361279
     
    13491292  {   
    13501293    xConfirmPara( m_dimIds[j].size() < m_numberOfLayers,  "DimensionId must be given for all layers and all dimensions. ");   
    1351 #if H_MV5   
    13521294    xConfirmPara( (m_dimIds[j][0] != 0)                 , "DimensionId of layer 0 must be 0. " );
    1353 #else
    1354     xConfirmPara( ( j != viewDimPosition ) &&  (m_dimIds[j][0] != 0), "DimensionId of layer 0 must be 0. " );
    1355 #endif
    13561295    xConfirmPara( m_dimensionIdLen[j] < 1 || m_dimensionIdLen[j] > 8, "DimensionIdLen must be greater than 0 and less than 9 in all dimensions. " );
    13571296     
     
    13961335     {
    13971336       Bool inc = m_dimIds[ lastDiff ][ i ] > m_dimIds[ lastDiff ][ j ];
    1398 #if H_MV5
    13991337       Bool shallBeButIsNotIncreasing = ( !inc  ) ;
    1400 #else
    1401        Bool shallBeButIsNotIncreasing = ( !inc && ( lastDiff != viewDimPosition ) ) ;
    1402 #endif
    14031338       if ( shallBeButIsNotIncreasing )
    14041339       {       
    14051340         printf( "\nError: Positions of Layers %d and %d is not increasing in dimension %d \n", i, j, lastDiff);       
    14061341       }
    1407 #if H_MV5
    14081342       xConfirmPara( shallBeButIsNotIncreasing,  "DimensionIds shall be increasing within one dimension. " );
    1409 #else
    1410        xConfirmPara( shallBeButIsNotIncreasing && ( lastDiff != viewDimPosition ),  "DimensionIds shall be increasing within one dimension. " );
    1411 #endif
    14121343     }
    14131344#endif
     
    14151346 }
    14161347
    1417 #if H_MV5
    14181348 /// ViewId
    14191349 xConfirmPara( m_viewId.size() != m_iNumberOfViews, "The number of ViewIds must be equal to the number of views." );
     
    14211351  /// Layer sets
    14221352  xConfirmPara( m_vpsNumLayerSets < 0 || m_vpsNumLayerSets > 1024, "VpsNumLayerSets must be greater than 0 and less than 1025. ") ;
    1423 #else
    1424   xConfirmPara( m_vpsNumLayerSets < 0 || m_vpsNumLayerSets > 1024, "VpsNumLayerSets must be greater than 0 and less than 1025") ;
    1425 #endif
    14261353  for( Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++ )
    14271354  {
     
    21852112  }
    21862113#endif
    2187 #if H_MV5
    21882114#if H_MV
    21892115  // VPS VUI
     
    22082134  }
    22092135#endif
    2210 #endif
    22112136
    22122137  xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagValue, "CUTransquantBypassFlagValue cannot be 1 when TransquantBypassEnableFlag is 0");
     
    22742199#endif
    22752200#if H_MV
    2276 #if H_MV5
    22772201  xPrintParaVector( "ViewIdVal"     , m_viewId );
    22782202  xPrintParaVector( "ViewOrderIndex", m_viewOrderIndex );
    2279 #else
    2280   xPrintParaVector( "ViewId", m_viewId );
    2281 #endif
    22822203#endif
    22832204#if H_3D
  • branches/HTM-8.2-dev0-Cleanup/source/App/TAppEncoder/TAppEncCfg.h

    r646 r648  
    6969  std::vector<char*>     m_pchReconFileList;                  ///< output reconstruction file names
    7070  Int                    m_numberOfLayers;                    ///< number of Layers to Encode
    71 #if H_MV5
    7271  Int                    m_iNumberOfViews;                    ///< number of Layers that are views
    73 #else
    74 #if H_3D
    75   Int                    m_iNumberOfViews;                    ///< number of Layers that are views
    76 #endif
    77 #endif
    7872#else
    7973  Char*     m_pchReconFile;                                   ///< output reconstruction file
     
    8377  std::vector< std::vector<Int> > m_dimIds;                   ///< dimension ids ( pointers to m_viewId and m_depthFlag
    8478  std::vector<Int>       m_viewId;                            ///< view id
    85 #if H_MV5
    8679  std::vector<Int>       m_viewOrderIndex;                    ///< view order index 
    87 #endif
    8880#if H_3D
    8981  std::vector<Int>       m_depthFlag;                         ///< depth flag
     
    10698  std::vector< std::vector<Int> > m_dependencyTypes;          ///< Dependency types of direct reference layers
    10799
    108 #if H_MV5
    109100  // VPS VUI
    110101  Bool m_vpsVuiPresentFlag;
     
    122113  std::vector< std::vector<Bool > > m_ctuBasedOffsetEnabledFlag;
    123114  std::vector< std::vector<Int  > > m_minHorizontalCtuOffsetPlus1;
    124 #endif
    125115
    126116#if H_3D_IV_MERGE
  • branches/HTM-8.2-dev0-Cleanup/source/App/TAppEncoder/TAppEncTop.cpp

    r646 r648  
    8888    vps.setTemporalNestingFlag(true);
    8989  }
    90 #if H_MV5
    9190  vps.setMaxLayersMinus1( m_numberOfLayers - 1);
    92 #else
    93   vps.setMaxLayers( m_numberOfLayers );
    94 #endif
    9591  for(Int i = 0; i < MAX_TLAYER; i++)
    9692  {
     
    124120  xSetDependencies( vps );
    125121  xSetProfileTierLevel     ( vps );
    126 #if H_MV5
    127122  xSetRepFormat            ( vps );
    128 #endif
    129123  xSetLayerSets            ( vps );
    130 #if H_MV5
    131124  xSetVPSVUI               ( vps );
    132 #endif
    133125#if H_3D
    134 #if !H_MV5
    135   vps.initViewIndex();
    136 #endif
    137126  xSetVPSExtension2        ( vps );
    138127  m_ivPicLists.setVPS      ( &vps );
     
    140129
    141130
    142 #if H_MV5
    143131  for(Int layerIdInVps = 0; layerIdInVps < m_numberOfLayers; layerIdInVps++)
    144 #else
    145   for(Int layer = 0; layer < m_numberOfLayers; layer++)
    146 #endif
    147132  {
    148133    m_frameRcvd                 .push_back(0);
     
    151136    m_acTVideoIOYuvReconFileList.push_back(new TVideoIOYuv);
    152137    m_picYuvRec                 .push_back(new TComList<TComPicYuv*>) ;
    153 #if H_MV5   
    154138    m_ivPicLists.push_back( m_acTEncTopList[ layerIdInVps ]->getListPic()  );
    155139    TEncTop& m_cTEncTop = *m_acTEncTopList[ layerIdInVps ];  // It is not a member, but this name helps avoiding code duplication !!!
     
    160144    m_cTEncTop.setViewId                       ( vps.getViewId      (  layerId ) );
    161145    m_cTEncTop.setViewIndex                    ( vps.getViewIndex   (  layerId ) );
    162 #else
    163     m_ivPicLists.push_back( m_acTEncTopList[ layer ]->getListPic()  );
    164     TEncTop& m_cTEncTop = *m_acTEncTopList[ layer ];  // It is not a member, but this name helps avoiding code duplication !!!
    165    
    166     m_cTEncTop.setLayerIdInVps                 ( layer );
    167     m_cTEncTop.setLayerId                      ( vps.getLayerIdInNuh( layer ) );   
    168     m_cTEncTop.setViewId                       ( vps.getViewId      ( layer ) );
    169 
    170 #endif
    171146#if H_3D
    172 #if H_MV5
    173147    Bool isDepth = ( vps.getDepthId     ( layerId ) != 0 ) ;
    174 #else
    175     Bool isDepth = ( vps.getDepthId     ( layer ) != 0 ) ;
    176     m_cTEncTop.setViewIndex                    ( vps.getViewIndex   ( layer ) );
    177 #endif
    178148    m_cTEncTop.setIsDepth                      ( isDepth );
    179149    //====== Camera Parameters =========
     
    201171    m_cTEncTop.setDWeight                      ( isDepth ? m_iDWeight             : 0     );
    202172#endif // H_3D_VSO
    203 #if H_MV5
    204173#if H_3D_ARP
    205174    //====== Advanced Inter-view Residual Prediction =========
     
    209178#if H_3D_IC
    210179    m_cTEncTop.setUseIC                        ( vps.getViewIndex( layerId ) == 0 ? false : m_abUseIC[isDepth ? 1 : 0] );
    211 #endif
    212 #else
    213 #if H_3D_ARP
    214     //====== Advanced Inter-view Residual Prediction =========
    215     m_cTEncTop.setUseAdvRP                     ( ( isDepth || 0==layer ) ? 0 : m_uiUseAdvResPred );
    216     m_cTEncTop.setARPStepNum                   ( ( isDepth || 0==layer ) ? 1 : H_3D_ARP_WFNR     );
    217 #endif
    218 #if H_3D_IC
    219     m_cTEncTop.setUseIC                        ( vps.getViewIndex( layer ) == 0 ? false : m_abUseIC[isDepth ? 1 : 0] );
    220 #endif
    221180#endif
    222181  //========== Depth intra modes ==========
     
    260219  m_cTEncTop.setGOPSize                      ( m_iGOPSize );
    261220#if H_MV
    262 #if H_MV5
    263221m_cTEncTop.setGopList                      ( m_GOPListMvc[layerIdInVps] );
    264222  m_cTEncTop.setExtraRPSs                    ( m_extraRPSsMvc[layerIdInVps] );
     
    269227  }
    270228#else
    271   m_cTEncTop.setGopList                      ( m_GOPListMvc[layer] );
    272   m_cTEncTop.setExtraRPSs                    ( m_extraRPSsMvc[layer] );
    273   for(Int i = 0; i < MAX_TLAYER; i++)
    274   {
    275     m_cTEncTop.setNumReorderPics             ( m_numReorderPicsMvc[layer][i], i );
    276     m_cTEncTop.setMaxDecPicBuffering         ( m_maxDecPicBufferingMvc[layer][i], i );
    277   }
    278 #endif
    279 #else
    280229  m_cTEncTop.setGopList                      ( m_GOPList );
    281230  m_cTEncTop.setExtraRPSs                    ( m_extraRPSs );
     
    291240  }
    292241#if H_MV
    293 #if H_MV5
    294242  m_cTEncTop.setQP                           ( m_iQP[layerIdInVps] );
    295243#else
    296   m_cTEncTop.setQP                           ( m_iQP[layer] );
    297 #endif
    298 #else
    299244  m_cTEncTop.setQP                           ( m_iQP );
    300245#endif
     
    303248
    304249#if H_MV
    305 #if H_MV5
    306250  m_cTEncTop.setMaxTempLayer                 ( m_maxTempLayerMvc[layerIdInVps] );
    307251#else
    308   m_cTEncTop.setMaxTempLayer                 ( m_maxTempLayerMvc[layer] );
    309 #endif
    310 #else
    311252  m_cTEncTop.setMaxTempLayer                 ( m_maxTempLayer );
    312253#endif
     
    317258  //====== Loop/Deblock Filter ========
    318259#if H_MV
    319 #if H_MV5
    320260  m_cTEncTop.setLoopFilterDisable            ( m_bLoopFilterDisable[layerIdInVps]);
    321 #else
    322   m_cTEncTop.setLoopFilterDisable            ( m_bLoopFilterDisable[layer]);
    323 #endif
    324261#else
    325262  m_cTEncTop.setLoopFilterDisable            ( m_bLoopFilterDisable       );
     
    351288
    352289#if H_MV
    353 #if H_MV5
    354290  if ((m_iMaxDeltaQP == 0 ) && (m_iQP[layerIdInVps] == lowestQP) && (m_useLossless == true))
    355 #else
    356   if ((m_iMaxDeltaQP == 0 ) && (m_iQP[layer] == lowestQP) && (m_useLossless == true))
    357 #endif
    358291#else
    359292  if ((m_iMaxDeltaQP == 0 ) && (m_iQP == lowestQP) && (m_useLossless == true))
     
    372305  m_cTEncTop.setUseLossless                  ( m_useLossless );
    373306#if H_MV
    374 #if H_MV5
    375307  m_cTEncTop.setdQPs                         ( m_aidQP[layerIdInVps]   );
    376 #else
    377   m_cTEncTop.setdQPs                         ( m_aidQP[layer]   );
    378 #endif
    379308#else
    380309  m_cTEncTop.setdQPs                         ( m_aidQP        );
     
    435364  m_cTEncTop.setLFCrossSliceBoundaryFlag( m_bLFCrossSliceBoundaryFlag );
    436365#if H_MV
    437 #if H_MV5
    438366  m_cTEncTop.setUseSAO ( m_bUseSAO[layerIdInVps] );
    439 #else
    440   m_cTEncTop.setUseSAO ( m_bUseSAO[layer] );
    441 #endif
    442367#else
    443368  m_cTEncTop.setUseSAO ( m_bUseSAO );
     
    13031228Void TAppEncTop::xSetDimensionIdAndLength( TComVPS& vps )
    13041229{   
    1305 #if H_MV5
    13061230  vps.setScalabilityMaskFlag( m_scalabilityMask );
    1307 #else
    1308   vps.setScalabilityMask( m_scalabilityMask );
    1309 #endif
    13101231  for( Int dim = 0; dim < m_dimIds.size(); dim++ )
    13111232  {
    13121233    vps.setDimensionIdLen( dim, m_dimensionIdLen[ dim ] );
    1313 #if H_MV5
    13141234    for( Int layer = 0; layer <= vps.getMaxLayersMinus1(); layer++ )
    1315 #else
    1316     for( Int layer = 0; layer < vps.getMaxLayers(); layer++ )
    1317 #endif
    13181235
    13191236    {       
     
    13221239  }
    13231240
    1324 #if H_MV5
    13251241  Int maxViewId = xGetMax( m_viewId );
    13261242
     
    13351251
    13361252  assert( m_iNumberOfViews == vps.getNumViews() );
    1337 #endif
    13381253}
    13391254
     
    13621277
    13631278  // Max temporal id for inter layer reference pictures + presence flag
    1364 #if H_MV5
    13651279  Bool maxTidRefPresentFlag = false;
    1366 #endif
    13671280  for ( Int refLayerIdInVps = 0; refLayerIdInVps < m_numberOfLayers; refLayerIdInVps++)
    13681281    {
     
    13851298    }
    13861299    vps.setMaxTidIlRefPicPlus1( refLayerIdInVps, maxTid + 1 );
    1387 #if H_MV5
    13881300    maxTidRefPresentFlag = maxTidRefPresentFlag || ( maxTid != 6 );   
    1389 #endif
    1390   }
    1391 
    1392 #if H_MV5
     1301  }
     1302
    13931303  vps.setMaxTidRefPresentFlag( maxTidRefPresentFlag );
    1394 #endif
    13951304  // Max one active ref layer flag
    13961305  Bool maxOneActiveRefLayerFlag = true; 
    1397 #if H_MV5
    13981306  for ( Int layerIdInVps = 1; layerIdInVps < m_numberOfLayers && maxOneActiveRefLayerFlag; layerIdInVps++)
    1399 #else
    1400   for ( Int currLayerIdInVps = 1; currLayerIdInVps < m_numberOfLayers && maxOneActiveRefLayerFlag; currLayerIdInVps++)
    1401 #endif
    14021307  {
    14031308    for( Int i = 0; i < ( getGOPSize() + 1) && maxOneActiveRefLayerFlag; i++ )
    14041309    {       
    1405 #if H_MV5
    14061310      GOPEntry ge =  m_GOPListMvc[layerIdInVps][ ( i < getGOPSize()  ? i : MAX_GOP ) ];
    1407 #else
    1408       GOPEntry ge =  m_GOPListMvc[currLayerIdInVps][ ( i < getGOPSize()  ? i : MAX_GOP ) ];
    1409 #endif
    14101311      maxOneActiveRefLayerFlag =  maxOneActiveRefLayerFlag && (ge.m_numActiveRefLayerPics <= 1);
    14111312    }           
     
    14151316 
    14161317 
    1417 #if H_MV5
    14181318  // All Ref layers active flag
    14191319  Bool allRefLayersActiveFlag = true;
     
    14311331  // Currently cross layer irap aligned is always true.   
    14321332  vps.setCrossLayerIrapAlignedFlag( true );
    1433 #endif
    14341333  vps.setRefLayers();
    14351334};
    14361335
    1437 #if H_MV5
    14381336GOPEntry* TAppEncTop::xGetGopEntry( Int layerIdInVps, Int poc )
    14391337{
     
    14501348  return geFound;
    14511349}
    1452 #endif
    14531350
    14541351Void TAppEncTop::xSetLayerIds( TComVPS& vps )
     
    14901387}
    14911388
    1492 #if H_MV5
    14931389
    14941390Void TAppEncTop::xSetRepFormat( TComVPS& vps )
     
    15151411  }
    15161412}
    1517 #endif
    15181413
    15191414Void TAppEncTop::xSetLayerSets( TComVPS& vps )
     
    15681463  }
    15691464}
    1570 #if H_MV5
    15711465
    15721466Void TAppEncTop::xSetVPSVUI( TComVPS& vps )
     
    16601554}
    16611555#endif
    1662 #endif
    16631556#if H_3D
    16641557Void TAppEncTop::xSetVPSExtension2( TComVPS& vps )
    16651558{
    1666 #if H_MV5
    16671559
    16681560  for ( Int layer = 0; layer <= vps.getMaxLayersMinus1(); layer++ )
    1669 #else
    1670   for ( Int layer = 0; layer < vps.getMaxLayers(); layer++ )
    1671 #endif
    16721561  {
    16731562    Bool isDepth      = ( vps.getDepthId( layer ) == 1 ) ;
  • branches/HTM-8.2-dev0-Cleanup/source/App/TAppEncoder/TAppEncTop.h

    r635 r648  
    124124  Void xSetLayerSets              ( TComVPS& vps );
    125125  Void xSetProfileTierLevel       ( TComVPS& vps );
    126 #if H_MV5
    127126  Void xSetRepFormat              ( TComVPS& vps );
    128127  Void xSetVPSVUI                 ( TComVPS& vps );
    129128  GOPEntry* xGetGopEntry( Int layerIdInVps, Int poc );
    130 #endif
    131129  Int  xGetMax( std::vector<Int>& vec);
    132130#endif
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibCommon/CommonDef.h

    r625 r648  
    187187}
    188188
    189 #if H_MV5
    190189template <typename T>
    191190__inline T gCeilLog2( T val )
     
    196195  return ceilLog2;
    197196}
    198 #endif
    199197
    200198#define RemoveBitIncrement( exp ) ( exp >> ( g_bitDepthY - 8 ) )
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibCommon/TComDataCU.cpp

    r647 r648  
    48044804
    48054805  // use coldir.
    4806 #if H_MV5
    48074806  TComPic *pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? 1-getSlice()->getColFromL0Flag() : 0), getSlice()->getColRefIdx());
    4808 #else
    4809 #if H_MV
    4810   TComPic *pColPic; 
    4811   if (getSlice()->getAltCollocatedIndicationFlag() )
    4812   {
    4813     pColPic = getSlice()->getPicFromRefPicSetInterLayer( getSlice()->getActiveMotionPredRefLayerId( getSlice()->getCollocatedRefLayerIdx() ));
    4814   }
    4815   else
    4816   {
    4817     pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? 1-getSlice()->getColFromL0Flag() : 0), getSlice()->getColRefIdx()); 
    4818   } 
    4819 #else
    4820   TComPic *pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? 1-getSlice()->getColFromL0Flag() : 0), getSlice()->getColRefIdx());
    4821 #endif
    4822 #endif
    48234807  TComDataCU *pColCU = pColPic->getCU( uiCUAddr );
    48244808  if(pColCU->getPic()==0||pColCU->getPartitionSize(uiPartUnitIdx)==SIZE_NONE)
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibCommon/TComSlice.cpp

    r646 r648  
    101101, m_enableTMVPFlag                ( true )
    102102#if H_MV
    103 #if H_MV5
    104103, m_refPicSetInterLayer0           ( NULL )
    105104, m_refPicSetInterLayer1           ( NULL )
    106 #else
    107 , m_refPicSetInterLayer           ( NULL )
    108 #endif
    109105, m_layerId                       (0)
    110106, m_viewId                        (0)
    111 #if H_MV5
    112107, m_viewIndex                     (0)
    113 #endif
    114108#if H_3D
    115 #if !H_MV5
    116 , m_viewIndex                     (0)
    117 #endif
    118109, m_isDepth                       (false)
    119110#endif
    120 #if H_MV5
    121111, m_pocResetFlag                  (false)
    122 #endif
    123112, m_discardableFlag               (false)
    124113, m_interLayerPredEnabledFlag     (false)
    125114, m_numInterLayerRefPicsMinus1    (0)
    126 #if !H_MV5
    127 , m_interLayerSamplePredOnlyFlag  (false)
    128 , m_altCollocatedIndicationFlag   (0)
    129 , m_collocatedRefLayerIdx         (0)
    130 #endif
    131115#if H_3D_IC
    132116, m_bApplyIC                      ( false )
     
    164148  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
    165149  {
    166 #if H_MV5
    167150   m_interLayerPredLayerIdc[ i ] = i;
    168 #else
    169    m_interLayerPredLayerIdc[ i ] = 0;
    170 #endif
    171151  }
    172152#endif
     
    387367  }
    388368}
    389 #if H_MV5
    390369#if !H_MV
    391370#if FIX1071
     
    730709}
    731710#endif
    732 #else
     711Int TComSlice::getNumRpsCurrTempList()
     712{
     713  Int numRpsCurrTempList = 0;
     714
     715  if (m_eSliceType == I_SLICE)
     716  {
     717    return 0;
     718  }
     719  for(UInt i=0; i < m_pcRPS->getNumberOfNegativePictures()+ m_pcRPS->getNumberOfPositivePictures() + m_pcRPS->getNumberOfLongtermPictures(); i++)
     720  {
     721    if(m_pcRPS->getUsed(i))
     722    {
     723      numRpsCurrTempList++;
     724    }
     725  }
    733726#if H_MV
    734 Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer , Bool checkNumPocTotalCurr)
    735 #else
    736 #if FIX1071
    737 Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
    738 #else
    739 Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic )
    740 #endif
    741 #endif
    742 {
    743 #if FIX1071
    744   if (!checkNumPocTotalCurr)
    745 #endif
    746   {
    747     if (m_eSliceType == I_SLICE)
    748     {
    749       ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
    750       ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
    751      
    752       return;
    753     }
    754    
    755 #if !H_MV
    756     m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
    757     m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
    758 #endif
    759   }
    760 
    761   TComPic*  pcRefPic= NULL;
    762   TComPic*  RefPicSetStCurr0[16];
    763   TComPic*  RefPicSetStCurr1[16];
    764   TComPic*  RefPicSetLtCurr[16];
    765   UInt NumPocStCurr0 = 0;
    766   UInt NumPocStCurr1 = 0;
    767   UInt NumPocLtCurr = 0;
    768   Int i;
    769 
    770   for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++)
    771   {
    772     if(m_pcRPS->getUsed(i))
    773     {
    774       pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
    775       pcRefPic->setIsLongTerm(0);
    776       pcRefPic->getPicYuvRec()->extendPicBorder();
    777       RefPicSetStCurr0[NumPocStCurr0] = pcRefPic;
    778       NumPocStCurr0++;
    779       pcRefPic->setCheckLTMSBPresent(false); 
    780     }
    781   }
    782  
    783   for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++)
    784   {
    785     if(m_pcRPS->getUsed(i))
    786     {
    787       pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
    788       pcRefPic->setIsLongTerm(0);
    789       pcRefPic->getPicYuvRec()->extendPicBorder();
    790       RefPicSetStCurr1[NumPocStCurr1] = pcRefPic;
    791       NumPocStCurr1++;
    792       pcRefPic->setCheckLTMSBPresent(false); 
    793     }
    794   }
    795  
    796   for(i = m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()+m_pcRPS->getNumberOfLongtermPictures()-1; i > m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()-1 ; i--)
    797   {
    798     if(m_pcRPS->getUsed(i))
    799     {
    800       pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
    801       pcRefPic->setIsLongTerm(1);
    802       pcRefPic->getPicYuvRec()->extendPicBorder();
    803       RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
    804       NumPocLtCurr++;
    805     }
    806     if(pcRefPic==NULL)
    807     {
    808       pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
    809     }
    810     pcRefPic->setCheckLTMSBPresent(m_pcRPS->getCheckLTMSBPresent(i)); 
    811   }
    812 
    813   // ref_pic_list_init
    814   TComPic*  rpsCurrList0[MAX_NUM_REF+1];
    815   TComPic*  rpsCurrList1[MAX_NUM_REF+1];
    816 #if H_MV
    817   Int numPocInterCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
    818   assert( numPocInterCurr == 0 || getInterRefEnabledInRPLFlag() );
    819   Int numPocTotalCurr = numPocInterCurr + getNumActiveRefLayerPics( );
    820   assert( numPocTotalCurr == getNumRpsCurrTempList() );
    821 #else
    822   Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
    823 #endif
    824 #if FIX1071
    825   if (checkNumPocTotalCurr)
    826   {
    827     // The variable NumPocTotalCurr is derived as specified in subclause 7.4.7.2. It is a requirement of bitstream conformance that the following applies to the value of NumPocTotalCurr:
    828 #if H_MV
    829     // ??If nuh_layer_id is equal to 0 and the current picture is a BLA picture or a CRA picture, the value of NumPocTotalCurr shall be equal to 0.
    830     // ??Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
    831     if ( getRapPicFlag() && m_layerId == 0 )
    832 #else
    833     // ??If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
    834     // ??Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
    835     if (getRapPicFlag())
    836 #endif
    837     {
    838       assert(numPocTotalCurr == 0);
    839     }
    840 
    841     if (m_eSliceType == I_SLICE)
    842     {
    843       ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
    844       ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
    845      
    846       return;
    847     }
    848    
    849     assert(numPocTotalCurr > 0);
    850    
    851     m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
    852     m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
    853   }
    854 #endif
    855 
    856   Int cIdx = 0;
    857 #if H_MV
    858   if ( getInterRefEnabledInRPLFlag() )
    859   { 
    860 #endif
    861   for ( i=0; i<NumPocStCurr0; i++, cIdx++)
    862   {
    863     rpsCurrList0[cIdx] = RefPicSetStCurr0[i];
    864   }
    865   for ( i=0; i<NumPocStCurr1; i++, cIdx++)
    866   {
    867     rpsCurrList0[cIdx] = RefPicSetStCurr1[i];
    868   }
    869   for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
    870   {
    871     rpsCurrList0[cIdx] = RefPicSetLtCurr[i];
    872   }
    873 #if H_MV
    874   }
    875   for ( i=0; i < getNumActiveRefLayerPics( );  i++, cIdx++)
    876     {
    877     assert( cIdx < MAX_NUM_REF );   
    878       rpsCurrList0[cIdx] = refPicSetInterLayer[i];
    879     }
    880 #endif
    881   assert(cIdx == numPocTotalCurr);
    882 
    883   if (m_eSliceType==B_SLICE)
    884   {
    885     cIdx = 0;
    886 #if H_MV
    887     if ( getInterRefEnabledInRPLFlag() )
    888     { 
    889 #endif
    890     for ( i=0; i<NumPocStCurr1; i++, cIdx++)
    891     {
    892       rpsCurrList1[cIdx] = RefPicSetStCurr1[i];
    893     }
    894     for ( i=0; i<NumPocStCurr0; i++, cIdx++)
    895     {
    896       rpsCurrList1[cIdx] = RefPicSetStCurr0[i];
    897     }
    898     for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
    899     {
    900       rpsCurrList1[cIdx] = RefPicSetLtCurr[i];
    901     }
    902 #if H_MV
    903     }
    904     for ( i=0; i < getNumActiveRefLayerPics( );  i++, cIdx++)
    905       {
    906       assert( cIdx < MAX_NUM_REF );   
    907         rpsCurrList1[cIdx] = refPicSetInterLayer[i];
    908       }
    909 #endif
    910     assert(cIdx == numPocTotalCurr);
    911   }
    912 
    913   ::memset(m_bIsUsedAsLongTerm, 0, sizeof(m_bIsUsedAsLongTerm));
    914 
    915 #if H_MV
    916   Int numPocSt = NumPocStCurr0 + NumPocStCurr1;
    917   assert(  getInterRefEnabledInRPLFlag( ) || numPocSt == 0 );
    918 
    919   for (Int li = 0; li < 2; li++)
    920   {
    921     if ( m_eSliceType == P_SLICE && li == 1 )
    922     {
    923       m_aiNumRefIdx[1] = 0;
    924       ::memset( m_apcRefPicList[1], 0, sizeof(m_apcRefPicList[1]));
    925     }
    926     else
    927     {
    928       for (Int rIdx = 0; rIdx <= (m_aiNumRefIdx[ li ] - 1 ); rIdx ++)
    929       {
    930         Bool listModified             =                m_RefPicListModification.getRefPicListModificationFlagL( li );
    931         Int orgIdx                    = listModified ? m_RefPicListModification.getRefPicSetIdxL(li, rIdx) : (rIdx % numPocTotalCurr);
    932 
    933         m_apcRefPicList    [li][rIdx] = ( li == 0 )  ? rpsCurrList0[ orgIdx  ] : rpsCurrList1[ orgIdx  ];
    934         m_bIsUsedAsLongTerm[li][rIdx] = ( orgIdx >= numPocSt ) ;
    935       }
    936     }
    937   }
    938 #else
    939   for (Int rIdx = 0; rIdx < m_aiNumRefIdx[0]; rIdx ++)
    940   {
    941     cIdx = m_RefPicListModification.getRefPicListModificationFlagL0() ? m_RefPicListModification.getRefPicSetIdxL0(rIdx) : rIdx % numPocTotalCurr;
    942     assert(cIdx >= 0 && cIdx < numPocTotalCurr);
    943     m_apcRefPicList[0][rIdx] = rpsCurrList0[ cIdx ];
    944     m_bIsUsedAsLongTerm[0][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
    945   }
    946   if ( m_eSliceType != B_SLICE )
    947   {
    948     m_aiNumRefIdx[1] = 0;
    949     ::memset( m_apcRefPicList[1], 0, sizeof(m_apcRefPicList[1]));
    950   }
    951   else
    952   {
    953     for (Int rIdx = 0; rIdx < m_aiNumRefIdx[1]; rIdx ++)
    954     {
    955       cIdx = m_RefPicListModification.getRefPicListModificationFlagL1() ? m_RefPicListModification.getRefPicSetIdxL1(rIdx) : rIdx % numPocTotalCurr;
    956       assert(cIdx >= 0 && cIdx < numPocTotalCurr);
    957       m_apcRefPicList[1][rIdx] = rpsCurrList1[ cIdx ];
    958       m_bIsUsedAsLongTerm[1][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
    959     }
    960   }
    961 #endif
    962 }
    963 
    964 #endif
    965 Int TComSlice::getNumRpsCurrTempList()
    966 {
    967   Int numRpsCurrTempList = 0;
    968 
    969   if (m_eSliceType == I_SLICE)
    970   {
    971     return 0;
    972   }
    973   for(UInt i=0; i < m_pcRPS->getNumberOfNegativePictures()+ m_pcRPS->getNumberOfPositivePictures() + m_pcRPS->getNumberOfLongtermPictures(); i++)
    974   {
    975     if(m_pcRPS->getUsed(i))
    976     {
    977       numRpsCurrTempList++;
    978     }
    979   }
    980 #if H_MV
    981 #if !H_MV5
    982   assert( ( numRpsCurrTempList == 0 ) || getInterRefEnabledInRPLFlag() );
    983 #endif
    984727  numRpsCurrTempList = numRpsCurrTempList + getNumActiveRefLayerPics();
    985728#endif
     
    12951038#if H_MV
    12961039  // Additional slice header syntax elements
    1297 #if H_MV5
    12981040  m_pocResetFlag               = pSrc->m_pocResetFlag;
    1299 #endif
    13001041  m_discardableFlag            = pSrc->m_discardableFlag;
    13011042  m_interLayerPredEnabledFlag  = pSrc->m_interLayerPredEnabledFlag;
     
    13061047    m_interLayerPredLayerIdc[ layer ] = pSrc->m_interLayerPredLayerIdc[ layer ];
    13071048  }
    1308 #if !H_MV5
    1309   m_interLayerSamplePredOnlyFlag = pSrc->m_interLayerSamplePredOnlyFlag;
    1310   m_altCollocatedIndicationFlag  = pSrc->m_altCollocatedIndicationFlag ;   
    1311   m_collocatedRefLayerIdx        = pSrc->m_collocatedRefLayerIdx       ;
    1312   m_numActiveMotionPredRefLayers = pSrc->m_numActiveMotionPredRefLayers;
    1313 
    1314   for (Int layer = 0; layer < MAX_NUM_LAYER_IDS; layer++)
    1315   {   
    1316     m_interLayerPredLayerIdc[layer] = pSrc->m_interLayerPredLayerIdc[layer];
    1317   }
    1318 #endif
    13191049#endif
    13201050#if H_3D_IC
     
    17811511: m_VPSId                     (  0)
    17821512, m_uiMaxTLayers              (  1)
    1783 #if H_MV5
    17841513#if H_MV
    17851514, m_uiMaxLayersMinus1         (  0)
    1786 #else
    1787 , m_uiMaxLayers               (  1)
    1788 #endif
    17891515#else
    17901516, m_uiMaxLayers               (  1)
     
    18001526, m_hrdOpSetIdx               (NULL)
    18011527, m_cprmsPresentFlag          (NULL)
    1802 #if H_MV5
    18031528#if H_MV
    18041529, m_vpsVUI                 (  NULL )
    1805 #endif
    18061530#endif
    18071531{
     
    18481572
    18491573  m_avcBaseLayerFlag = false;
    1850 #if H_MV5
    18511574  m_vpsVuiOffset     = 0;
    1852 #endif
    18531575  m_splittingFlag    = false;
    18541576 
    18551577  for( Int i = 0; i < MAX_NUM_SCALABILITY_TYPES; i++ )
    18561578  {
    1857 #if H_MV5
    18581579    m_scalabilityMaskFlag[i] = false;
    1859 #else
    1860     m_scalabilityMask[i] = false;
    1861 #endif
    18621580    m_dimensionIdLen [i]  = -1;
    18631581  }
     
    18851603    m_layerIdInNuh      [i] = ( i == 0 ) ? 0 : -1;
    18861604    m_numDirectRefLayers[i] = 0;
    1887 #if H_MV5
    18881605    m_maxTidIlRefPicPlus1[i] = 7;
    18891606    m_vpsRepFormatIdx    [i] = 0;
    18901607    m_repFormat          [i] = NULL;
    18911608    m_viewIdVal          [i] = 0;
    1892 #else
    1893     m_maxTidIlRefPicPlus1[i] = -1;
    1894 #endif
    18951609
    18961610#if H_3D
     
    19351649#endif
    19361650  }
    1937 #if H_MV5
    19381651  m_vpsVUI = new TComVPSVUI;
    1939 #endif
    19401652#if H_3D
    19411653  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
     
    19631675  if( m_hrdOpSetIdx      != NULL )     delete[] m_hrdOpSetIdx;
    19641676  if( m_cprmsPresentFlag != NULL )     delete[] m_cprmsPresentFlag;
    1965 #if H_MV5
    19661677#if H_MV
    19671678  if ( m_vpsVUI          != NULL )     delete m_vpsVUI;
     
    19831694#endif
    19841695  }
    1985 #endif
    1986 #else
    1987 #if H_3D_DIM_DLT
    1988   for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
    1989   {
    1990     if ( m_iDepthValue2Idx[i] != 0 )
    1991     {
    1992        xFree( m_iDepthValue2Idx[i] );
    1993        m_iDepthValue2Idx[i] = 0;
    1994     }
    1995 
    1996     if ( m_iIdx2DepthValue[i] != 0 )
    1997     {
    1998       xFree( m_iIdx2DepthValue[i] );
    1999       m_iIdx2DepthValue[i] = 0;
    2000 
    2001     }
    2002   }
    2003 #endif
    20041696#endif
    20051697}
     
    20721764Bool TComVPS::checkVPSExtensionSyntax()
    20731765{
    2074 #if H_MV5
    20751766  for( Int layer = 1; layer <= getMaxLayersMinus1(); layer++ )
    2076 #else
    2077   for( Int layer = 1; layer < getMaxLayers(); layer++ )
    2078 #endif
    20791767  {
    20801768    // check layer_id_in_nuh constraint
     
    20921780{
    20931781  assert( scalType >= 0 && scalType <= MAX_NUM_SCALABILITY_TYPES );
    2094 #if H_MV5
    20951782  assert( scalType == MAX_NUM_SCALABILITY_TYPES || getScalabilityMaskFlag( scalType ) );
    2096 #else
    2097   assert( scalType == MAX_NUM_SCALABILITY_TYPES || getScalabilityMask( scalType ) );
    2098 #endif
    20991783  Int scalIdx = 0;
    21001784  for( Int curScalType = 0; curScalType < scalType; curScalType++ )
    21011785  {
    2102 #if H_MV5
    21031786    scalIdx += ( getScalabilityMaskFlag( curScalType ) ? 1 : 0 );
    2104 #else
    2105     scalIdx += ( getScalabilityMask( curScalType ) ? 1 : 0 );
    2106 #endif
    21071787
    21081788  }
     
    21101790  return scalIdx;
    21111791}
    2112 #if H_MV5
    21131792Void TComVPS::setScalabilityMaskFlag( UInt val )
    21141793{
     
    21181797  }
    21191798}
    2120 #else
    2121 Void TComVPS::setScalabilityMask( UInt val )
    2122 {
    2123   for ( Int scalType = 0; scalType < MAX_NUM_SCALABILITY_TYPES; scalType++ )
    2124     setScalabilityMask( scalType, ( val & (1 << scalType ) ) != 0 );
    2125 }
    2126 
    2127 #endif
    2128 
    2129 #if H_MV5
     1799
    21301800Void TComVPS::setRefLayers()
    21311801{
     
    21761846}
    21771847#endif // H_3D
    2178 #else
    2179 Void TComVPS::setRefLayers()
    2180 {
    2181   for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
    2182   {
    2183     m_numSamplePredRefLayers[ i ] = 0;
    2184     m_numMotionPredRefLayers[ i ] = 0;
    2185     m_numDirectRefLayers[ i ] = 0;
    2186     for( Int j = 0; j < MAX_NUM_LAYERS; j++ ) {
    2187       m_samplePredEnabledFlag[ i ][ j ] = 0;
    2188       m_motionPredEnabledFlag[ i ][ j ] = 0;
    2189       m_refLayerId[ i ][ j ] = 0;
    2190       m_samplePredRefLayerId[ i ][ j ] = 0;
    2191       m_motionPredRefLayerId[ i ][ j ] = 0;
    2192     }
    2193   }
    2194 
    2195   for( Int i = 1; i  <= getMaxLayers()- 1; i++ )
    2196   {
    2197     for( Int j = 0; j < i; j++ )
    2198     {
    2199       if( getDirectDependencyFlag(i,j) )
    2200       {
    2201         m_refLayerId[ i ][m_numDirectRefLayers[ i ]++ ] = getLayerIdInNuh( j );
    2202 
    2203         m_samplePredEnabledFlag [ i ][ j ]  = ( (   getDirectDependencyType( i , j ) + 1 ) & 1 ) == 1;
    2204         m_numSamplePredRefLayers[ i ]      += m_samplePredEnabledFlag [ i ][ j ] ? 1 : 0;
    2205         m_motionPredEnabledFlag [ i ][ j ]  = ( ( ( getDirectDependencyType( i , j ) + 1 ) & 2 ) >> 1 ) == 1;
    2206         m_numMotionPredRefLayers[ i ]      += m_motionPredEnabledFlag  [ i][ j ] ? 1 : 0;
    2207       }
    2208     }
    2209   }
    2210 
    2211   for( Int i = 1, mIdx = 0, sIdx = 0; i <= getMaxLayers()- 1; i++ )
    2212   {   
    2213     for( Int j = 0 ; j < i; j++ )
    2214     {
    2215       if( m_motionPredEnabledFlag[ i ][ j ] )
    2216       {
    2217         m_motionPredRefLayerId[ i ][ mIdx++ ] = getLayerIdInNuh( j );
    2218       }
    2219      
    2220       if( m_samplePredEnabledFlag[ i ][ j ] )
    2221       {
    2222         m_samplePredRefLayerId[ i ][ sIdx++ ] = getLayerIdInNuh( j );
    2223       }
    2224     }
    2225   }
    2226 }
    2227 
    2228 Int TComVPS::getRefLayerId( Int layerIdInVps, Int idx )
    2229 {
    2230   assert( idx >= 0 && idx < m_numDirectRefLayers[layerIdInVps] );     
    2231   Int layerIdInNuh = m_refLayerId[ layerIdInVps ][ idx ];   
    2232   assert ( layerIdInNuh >= 0 );
    2233   return layerIdInNuh;
    2234 }
    2235 
    2236 Int TComVPS::getScalabilityId( Int layerIdInVps, ScalabilityType scalType )
    2237 {
    2238   return getScalabilityMask( scalType ) ? getDimensionId( layerIdInVps, scalTypeToScalIdx( scalType ) ) : 0;
    2239 }
    2240 
    2241 #if H_3D
    2242 Void TComVPS::initViewIndex()
    2243 {
    2244   Int viewIdList   [ MAX_NUM_LAYERS ]; // ed. should be changed to MAX_VIEW_ID
    2245   Int viewIndexList[ MAX_NUM_LAYERS ];
    2246   Int numViewIds = 0;
    2247 
    2248   for ( Int i = 0 ; i  <  m_uiMaxLayers; i++ )
    2249   {     
    2250     Int currViewId = getViewId( i );
    2251 
    2252     Bool viewIdInListFlag = false;
    2253     for ( Int j = 0; j < numViewIds; j ++ )
    2254     {
    2255       viewIdInListFlag  = viewIdInListFlag || ( currViewId  == viewIdList[ j ]  );
    2256     }
    2257 
    2258     if ( !viewIdInListFlag )
    2259     {
    2260       viewIdList   [ numViewIds ] = currViewId;
    2261       viewIndexList[ currViewId ] = numViewIds;
    2262 
    2263       numViewIds++;
    2264     } 
    2265 
    2266     m_viewIndex[ i ] = viewIndexList[ currViewId ];
    2267   }
    2268 }
    2269 
    2270 Int TComVPS::getLayerIdInNuh( Int viewIndex, Bool depthFlag )
    2271 {
    2272   Int foundlayerId = -1;
    2273 
    2274   for (Int layer = 0 ; layer < m_uiMaxLayers; layer++ )
    2275   {
    2276     if( ( getViewIndex( layer ) == viewIndex ) && ( getDepthId( layer ) == ( depthFlag ? 1 : 0 ) )  )
    2277     {
    2278       foundlayerId = layer;
    2279       break;
    2280     }
    2281   }
    2282   assert( foundlayerId != -1 );
    2283 
    2284   return getLayerIdInNuh( foundlayerId );
    2285 }
    2286 
    2287 #endif // H_3D
    2288 
    2289 Int TComVPS::xCeilLog2( Int val )
    2290 {
    2291   assert( val > 0 );
    2292   Int ceilLog2 = 0;
    2293   while( val > ( 1 << ceilLog2 ) ) ceilLog2++;
    2294   return ceilLog2;
    2295 }
    2296 
    2297 #endif // H_MV5
    22981848
    22991849
     
    23361886  return numLayersInIdList;
    23371887}
    2338 #if H_MV5
    23391888Int TComVPS::getNumViews()
    23401889{
     
    23661915  return dependentFlag;
    23671916}
    2368 #endif
    23691917#endif // H_MV
    23701918
     
    24171965, m_vuiParameters             ()
    24181966#if H_MV
    2419 #if H_MV5
    24201967, m_pcVPS                     ( NULL )
    24211968, m_spsInferScalingListFlag   ( false )
     
    24231970, m_updateRepFormatFlag       ( true )
    24241971, m_interViewMvVertConstraintFlag (false)
    2425 #else
    2426 , m_interViewMvVertConstraintFlag (false)
    2427 , m_numIlpRestrictedRefLayers ( 0 )
    2428 #endif
    24291972#endif
    24301973#if H_3D
     
    24411984  ::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
    24421985  ::memset(m_usedByCurrPicLtSPSFlag, 0, sizeof(m_usedByCurrPicLtSPSFlag));
    2443 #if !H_MV5
    2444 #if H_MV
    2445   for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
    2446   {
    2447     m_minSpatialSegmentOffsetPlus1[ i ] = 0;
    2448     m_ctuBasedOffsetEnabledFlag   [ i ] = false;
    2449     m_minHorizontalCtuOffsetPlus1 [ i ] = 0;
    2450   }
    2451 #endif
    2452 #endif
    24531986}
    24541987
     
    26032136, m_listsModificationPresentFlag(  0)
    26042137, m_numExtraSliceHeaderBits(0)
    2605 #if H_MV5
    26062138#if H_MV
    26072139, m_ppsInferScalingListFlag(false)
    26082140, m_ppsScalingListRefLayerId(0)
    26092141#endif
    2610 #endif
    26112142{
    26122143  m_scalingList = new TComScalingList;
     
    26282159}
    26292160
    2630 #if H_MV5
    26312161#if H_MV
    26322162Void TComSPS::inferRepFormat( TComVPS* vps, Int layerIdCurr )
     
    26792209  }
    26802210}
    2681 #endif
    26822211#endif
    26832212#if H_3D
     
    29502479
    29512480#if H_MV
    2952 #if H_MV5
    29532481Void TComSlice::createInterLayerReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1 )
    29542482{
     
    29822510  }
    29832511}
    2984 #else
    2985 Void TComSlice::createAndApplyIvReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer )
    2986 {
    2987   refPicSetInterLayer.clear();
    2988 
    2989   for( Int i = 0; i < getNumActiveRefLayerPics(); i++ )
    2990   {
    2991     Int layerIdRef = getRefPicLayerId( i );
    2992     TComPic* picRef = ivPicLists->getPic( layerIdRef, getPOC() ) ;
    2993     assert ( picRef != 0 );
    2994 
    2995     picRef->getPicYuvRec()->extendPicBorder();
    2996     picRef->setIsLongTerm( true );       
    2997     picRef->getSlice(0)->setReferenced( true );       
    2998 
    2999     // Consider to check here:
    3000     // "If the current picture is a RADL picture, there shall be no entry in the RefPicSetInterLayer that is a RASL picture. "
    3001     refPicSetInterLayer.push_back( picRef );
    3002   }
    3003 }
    3004 #endif
    3005 
    3006 #if H_MV5
     2512
    30072513Void TComSlice::markIvRefPicsAsShortTerm( std::vector<TComPic*> refPicSetInterLayer0, std::vector<TComPic*> refPicSetInterLayer1 )
    30082514{
     
    30192525
    30202526}
    3021 #else
    3022 Void TComSlice::markIvRefPicsAsShortTerm( std::vector<TComPic*> refPicSetInterLayer )
    3023 {
    3024   // Mark as shortterm
    3025   for ( Int i = 0; i < refPicSetInterLayer.size(); i++ )
    3026   {
    3027     refPicSetInterLayer[i]->setIsLongTerm( false );
    3028   }
    3029 }
    3030 
    3031 #endif
    30322527Void TComSlice::markIvRefPicsAsUnused( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc )
    30332528{
     
    30352530  if (targetDecLayerIdSet.size() == 0 )   
    30362531  {
    3037 #if H_MV5
    30382532    for ( Int layerIdInVps = 0; layerIdInVps <= vps->getMaxLayersMinus1(); layerIdInVps++ )
    3039 #else
    3040     for ( Int layerIdInVps = 0; layerIdInVps < vps->getMaxLayers(); layerIdInVps++ )
    3041 #endif
    30422533    {
    30432534      targetDecLayerIdSet.push_back( vps->getLayerIdInNuh( layerIdInVps ) );
     
    30682559          if ( vps->nuhLayerIdIncluded( targetDecLayerIdSet[ j ] ) )
    30692560          {
    3070 #if H_MV5
    30712561            for( Int k = 0; k < vpsSlice->getNumDirectRefLayers( targetDecLayerIdSet[ j ] ); k++ )
    30722562            {
    30732563              if ( targetDecLayerIdSet[ i ] == vpsSlice->getRefLayerId( targetDecLayerIdSet[ j ],  k  ) )
    3074 #else
    3075             Int targetDecLayerIdinVPS = vpsSlice->getLayerIdInVps( targetDecLayerIdSet[ j ] );
    3076             for( Int k = 0; k < vpsSlice->getNumDirectRefLayers( targetDecLayerIdinVPS ); k++ )
    3077             {
    3078               if ( targetDecLayerIdSet[ i ] == vpsSlice->getRefLayerId( targetDecLayerIdinVPS,  k  ) )
    3079 #endif
    30802564              {
    30812565                remainingInterLayerReferencesFlag = true;
     
    30932577}
    30942578
    3095 #if H_MV5
    30962579Void TComSlice::printRefPicList()
    3097 #else
    3098 Void TComSlice::xPrintRefPicList()
    3099 #endif
    31002580
    31012581  for ( Int li = 0; li < 2; li++)
     
    31102590  }
    31112591}
    3112 #if !H_MV5
    3113 Int TComSlice::xCeilLog2( Int val )
    3114 {
    3115   assert( val > 0 );
    3116   Int ceilLog2 = 0;
    3117   while( val > ( 1 << ceilLog2 ) ) ceilLog2++;
    3118   return ceilLog2;
    3119 }
    3120 #endif
    31212592
    31222593Void TComSlice::markCurrPic( TComPic* currPic )
     
    31332604}
    31342605
    3135 #if H_MV5
    31362606Void TComSlice::setRefPicSetInterLayer( std::vector<TComPic*>* refPicSetInterLayer0, std::vector<TComPic*>* refPicSetInterLayer1 )
    31372607{
     
    31582628  return pcPic;
    31592629}
    3160 #else
    3161 Void TComSlice::setRefPicSetInterLayer( std::vector<TComPic*>* refPicSetInterLayer )
    3162 {
    3163   m_refPicSetInterLayer = refPicSetInterLayer;
    3164 }
    3165 
    3166 TComPic* TComSlice::getPicFromRefPicSetInterLayer( Int layerId )
    3167 {
    3168   assert( m_refPicSetInterLayer != 0 );
    3169   assert( (*m_refPicSetInterLayer).size() == getNumActiveRefLayerPics() );
    3170   TComPic* pcPic = NULL;
    3171   for ( Int i = 0; i < getNumActiveRefLayerPics(); i++ )
    3172   {
    3173     if ((*m_refPicSetInterLayer)[ i ]->getLayerId() == layerId)
    3174     {
    3175       pcPic = (*m_refPicSetInterLayer)[ i ];
    3176     }
    3177   }
    3178   assert(pcPic != NULL);
    3179   return pcPic;
    3180 }
    3181 #endif
    31822630Int TComSlice::getNumActiveRefLayerPics()
    31832631{
    31842632  Int numActiveRefLayerPics;
    31852633
    3186 #if H_MV5
    31872634  if( getLayerId() == 0 || getVPS()->getNumDirectRefLayers( getLayerId() ) ==  0 )
    31882635  {
     
    31982645  }
    31992646  else if( getVPS()->getMaxOneActiveRefLayerFlag() || getVPS()->getNumDirectRefLayers( getLayerId() ) == 1 )
    3200 #else
    3201   if( getLayerId() == 0 || getVPS()->getNumDirectRefLayers( getLayerIdInVps() ) ==  0 || !getInterLayerPredEnabledFlag() )
    3202   {
    3203     numActiveRefLayerPics = 0;
    3204   }
    3205   else if( getVPS()->getMaxOneActiveRefLayerFlag() || getVPS()->getNumDirectRefLayers( getLayerIdInVps() ) == 1 )
    3206 #endif
    32072647  {
    32082648    numActiveRefLayerPics = 1;
     
    32172657Int TComSlice::getRefPicLayerId( Int i )
    32182658{
    3219 #if H_MV5
    32202659  return getVPS()->getRefLayerId( getLayerId(), getInterLayerPredLayerIdc( i ) );
    3221 #else
    3222   return getVPS()->getRefLayerId( getLayerIdInVps(), getInterLayerPredLayerIdc( i ) );
    3223 #endif
    3224 }
    3225 
    3226 #if !H_MV5
    3227 Void TComSlice::setActiveMotionPredRefLayers()
    3228 {
    3229   Int j = 0;
    3230   for( Int i = 0; i < getNumActiveRefLayerPics(); i++)
    3231   {
    3232     if( getVPS()->getMotionPredEnabledFlag( getLayerIdInVps(), getInterLayerPredLayerIdc( i ))  )
    3233     {
    3234       m_activeMotionPredRefLayerId[ j++ ] = getVPS()->getRefLayerId( getLayerIdInVps(), i );
    3235     }
    3236   }
    3237   m_numActiveMotionPredRefLayers = j;
    3238 
    3239   // Consider incorporating bitstream conformance tests on derived variables here.
    3240 }
    3241 
    3242 Bool TComSlice::getInterRefEnabledInRPLFlag()
    3243 {
    3244   Bool interRefEnabledInRPLFlag;
    3245   if ( getVPS()->getNumSamplePredRefLayers( getLayerIdInVps() ) > 0 && getNumActiveRefLayerPics() > 0 )
    3246   {
    3247     interRefEnabledInRPLFlag = !getInterLayerSamplePredOnlyFlag();
    3248   }
    3249   else
    3250   {
    3251     interRefEnabledInRPLFlag = 1;
    3252   }
    3253   return interRefEnabledInRPLFlag;
    3254 }
    3255 #endif
     2660}
     2661
    32562662#if H_3D_ARP
    32572663Void TComSlice::setARPStepNum()                                 
     
    35312937}
    35322938
    3533 #if H_MV5
    35342939#if H_MV
    35352940Void TComScalingList::inferFrom( TComScalingList* srcScLi )
     
    35452950  }
    35462951}
    3547 #endif
    35482952#endif
    35492953/** initialization process of quantization matrix array
     
    36363040, m_ppsMap(MAX_NUM_PPS)
    36373041, m_activeVPSId(-1)
    3638 #if H_MV5
    36393042#if !H_MV
    36403043, m_activeSPSId(-1)
     
    36493052  }
    36503053#endif
    3651 #else
    3652 , m_activeSPSId(-1)
    3653 , m_activePPSId(-1)
    3654 {
    3655 #endif
    36563054}
    36573055
     
    36633061//! activate a SPS from a active parameter sets SEI message
    36643062//! \returns true, if activation is successful
    3665 #if H_MV5
    36663063#if H_MV
    36673064Bool ParameterSetManager::activateSPSWithSEI(Int spsId, Int layerId )
     
    36693066Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
    36703067#endif
    3671 #else
    3672 Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
    3673 #endif
    36743068{
    36753069  TComSPS *sps = m_spsMap.getPS(spsId);
     
    36803074    {
    36813075      m_activeVPSId = vpsId;
    3682 #if !H_MV5
    3683       m_activeSPSId = spsId;
    3684 #else
    36853076#if H_MV
    36863077      m_activeSPSId[ layerId ] = spsId;
     
    36883079      m_activeSPSId = spsId;
    36893080#endif
    3690 #endif
    36913081      return true;
    36923082    }
     
    37053095//! activate a PPS and depending on isIDR parameter also SPS and VPS
    37063096//! \returns true, if activation is successful
    3707 #if H_MV5
    37083097#if H_MV
    37093098Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP, Int layerId )
     
    37423131        m_activeSPSId[ layerId ] = spsId;
    37433132#else
    3744         m_activePPSId = ppsId;
    3745         m_activeVPSId = vpsId;
    3746         m_activeSPSId = spsId;
    3747 #endif
    3748 #else
    3749 Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
    3750 {
    3751   TComPPS *pps = m_ppsMap.getPS(ppsId);
    3752   if (pps)
    3753   {
    3754     Int spsId = pps->getSPSId();
    3755 #if H_MV
    3756     // active parameter sets per layer should be used here
    3757 #else
    3758     if (!isIRAP && (spsId != m_activeSPSId))
    3759     {
    3760       printf("Warning: tried to activate PPS referring to a inactive SPS at non-IRAP.");
    3761       return false;
    3762     }
    3763 #endif
    3764     TComSPS *sps = m_spsMap.getPS(spsId);
    3765     if (sps)
    3766     {
    3767       Int vpsId = sps->getVPSId();
    3768       if (!isIRAP && (vpsId != m_activeVPSId))
    3769       {
    3770         printf("Warning: tried to activate PPS referring to a inactive VPS at non-IRAP.");
    3771         return false;
    3772       }
    3773       if (m_vpsMap.getPS(vpsId))
    3774       {
    37753133        m_activePPSId = ppsId;
    37763134        m_activeVPSId = vpsId;
     
    38283186//! \}
    38293187
    3830 #if H_MV5
    38313188#if H_MV
    38323189TComVPSVUI::TComVPSVUI()
     
    38613218}
    38623219#endif
    3863 #endif
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibCommon/TComSlice.h

    r646 r648  
    169169  Void     processRefMatrix               (UInt sizeId, UInt listId , UInt refListId );
    170170  Bool     xParseScalingList              (Char* pchFile);
    171 #if H_MV5
    172171#if H_MV
    173172  Void     inferFrom                      ( TComScalingList* srcScLi );
    174 #endif
    175173#endif
    176174
     
    407405};
    408406
    409 #if H_MV5
    410407#if H_MV
    411408class TComVPSVUI
     
    502499};
    503500#endif
    504 #endif
    505501
    506502class TComVPS
     
    510506  UInt        m_uiMaxTLayers;
    511507
    512 #if H_MV5
    513508#if H_MV
    514509  UInt        m_uiMaxLayersMinus1;
    515 #else
    516   UInt        m_uiMaxLayers;
    517 #endif
    518510#else
    519511  UInt        m_uiMaxLayers;
     
    551543  /// VPS EXTENSION SYNTAX ELEMENTS
    552544  Bool        m_avcBaseLayerFlag;
    553 #if H_MV5
    554545  Int         m_vpsVuiOffset;
    555 #endif
    556546  Bool        m_splittingFlag;
    557 #if H_MV5
    558547  Bool        m_scalabilityMaskFlag          [MAX_NUM_SCALABILITY_TYPES];
    559 #else
    560   Bool        m_scalabilityMask          [MAX_NUM_SCALABILITY_TYPES];
    561 #endif
    562548  Int         m_dimensionIdLen           [MAX_NUM_SCALABILITY_TYPES];
    563549  Bool        m_vpsNuhLayerIdPresentFlag;
    564550  Int         m_layerIdInNuh             [MAX_NUM_LAYER_IDS];
    565551  Int         m_dimensionId              [MAX_NUM_LAYER_IDS][MAX_NUM_SCALABILITY_TYPES]; 
    566 #if H_MV5
    567552  Int         m_viewIdLenMinus1;
    568553  Int         m_viewIdVal                [MAX_NUM_LAYERS];
    569 #endif
    570554  Bool        m_directDependencyFlag     [MAX_NUM_LAYER_IDS][MAX_NUM_LAYER_IDS];
    571 #if H_MV5
    572555  Bool        m_maxTidRefPresentFlag;
    573 #endif
    574556  Int         m_maxTidIlRefPicPlus1      [MAX_NUM_LAYERS];
    575 #if H_MV5
    576557  Bool        m_allRefLayersActiveFlag;
    577 #endif
    578558  Int         m_vpsNumberLayerSetsMinus1;
    579559  Int         m_vpsNumProfileTierLevelMinus1;   
     
    586566  Bool        m_outputLayerFlag          [MAX_VPS_OUTPUTLAYER_SETS][MAX_VPS_NUH_LAYER_ID_PLUS1];
    587567  Int         m_profileLevelTierIdx      [MAX_VPS_OUTPUTLAYER_SETS ];
    588 #if H_MV5
    589568  Bool        m_repFormatIdxPresentFlag;
    590569  Int         m_vpsNumRepFormatsMinus1;
    591570  Int         m_vpsRepFormatIdx          [MAX_NUM_LAYERS];
    592571  TComRepFormat* m_repFormat             [MAX_NUM_LAYERS];
    593 #endif
    594572  Bool        m_maxOneActiveRefLayerFlag;       
    595 #if H_MV5
    596573  Bool        m_crossLayerIrapAlignedFlag;
    597 #endif
    598574  Int         m_directDepTypeLenMinus2;         
    599 #if H_MV5
    600575  Bool        m_vpsVuiPresentFlag;
    601576  TComVPSVUI* m_vpsVUI;
    602 #endif
    603577  Int         m_directDependencyType     [MAX_NUM_LAYERS] [MAX_NUM_LAYERS];
    604578
     
    616590  Bool        m_motionPredEnabledFlag    [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
    617591  Int         m_motionPredRefLayerId     [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
    618 #if H_MV5
    619592  Int         m_viewIndex                [MAX_NUM_LAYERS   ];
    620 #else
    621 #if H_3D
    622   Int         m_viewIndex                [MAX_NUM_LAYERS   ];
    623 #endif
    624 
    625   Int         xCeilLog2       ( Int val );
    626 #endif
    627593  Int         xGetDimBitOffset( Int j );
    628594 
     
    681647  Void    setMaxTLayers  (UInt t)             { m_uiMaxTLayers = t; }
    682648 
    683 #if H_MV5
    684649#if H_MV   
    685650  UInt    getMaxLayersMinus1()                { return m_uiMaxLayersMinus1;  };
     
    689654  Void    setMaxLayers   (UInt l)             { m_uiMaxLayers = l; }
    690655#endif
    691 #else
    692   UInt    getMaxLayers   ()                   { return m_uiMaxLayers;   }
    693   Void    setMaxLayers   (UInt l)             { m_uiMaxLayers = l; }
    694 #endif
    695656
    696657  Bool    getTemporalNestingFlag   ()         { return m_bTemporalIdNestingFlag;   }
     
    735696  Bool    getAvcBaseLayerFlag()                                            { return m_avcBaseLayerFlag; }
    736697
    737 #if H_MV5
    738698  Void    setVpsVuiOffset( Int  val )                                      { m_vpsVuiOffset = val; }
    739699  Int     getVpsVuiOffset(  )                                              { return m_vpsVuiOffset; }
    740 #endif
    741700
    742701  Void    setSplittingFlag( Bool val )                                     { m_splittingFlag = val;  }
    743702  Bool    getSplittingFlag()                                               { return m_splittingFlag; }
    744703
    745 #if H_MV5
    746704  Void    setScalabilityMaskFlag( UInt val );
    747705  Void    setScalabilityMaskFlag( Int scalType, Bool val )                     { m_scalabilityMaskFlag[scalType] = val;  }
    748706  Bool    getScalabilityMaskFlag( Int scalType )                               { return m_scalabilityMaskFlag[scalType]; }
    749 #else
    750   Void    setScalabilityMask( UInt val );
    751 
    752   Void    setScalabilityMask( Int scalType, Bool val )              { m_scalabilityMask[scalType] = val;  }
    753   Bool    getScalabilityMask( Int scalType )                        { return m_scalabilityMask[scalType]; }
    754 #endif
    755707  Int     getNumScalabilityTypes( );
    756708
     
    769721  Int     getDimensionId( Int layerIdInVps, Int scalIdx )                  { return m_dimensionId[layerIdInVps][scalIdx]; }
    770722
    771 #if H_MV5
    772723  Void    setViewIdLenMinus1( Int  val )                                   { m_viewIdLenMinus1 = val; }
    773724  Int     getViewIdLenMinus1(  )                                           { return m_viewIdLenMinus1; }
     
    775726  Void    setViewIdVal( Int viewOrderIndex, Int  val )                     { m_viewIdVal[viewOrderIndex] = val; }
    776727  Int     getViewIdVal( Int viewOrderIndex )                               { return m_viewIdVal[viewOrderIndex]; }
    777 #endif
    778728  Void    setDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Bool val ) { m_directDependencyFlag[depLayeridInVps][refLayeridInVps] = val;  }
    779729  Bool    getDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps )           { return m_directDependencyFlag[depLayeridInVps][refLayeridInVps]; }
    780730
    781 #if H_MV5
    782731  Void    setMaxTidRefPresentFlag( Bool flag )                             { m_maxTidRefPresentFlag = flag; }
    783732  Bool    getMaxTidRefPresentFlag(  )                                      { return m_maxTidRefPresentFlag; }
    784 #endif
    785733  Void    setMaxTidIlRefPicPlus1( Int layerIdInVps, Int val )              { m_maxTidIlRefPicPlus1[ layerIdInVps ] = val;  }
    786734  Int     getMaxTidIlRefPicPlus1( Int layerIdInVps )                       { return m_maxTidIlRefPicPlus1[ layerIdInVps ]; }
    787 #if H_MV5
    788735  Void    setAllRefLayersActiveFlag( Bool flag )                           { m_allRefLayersActiveFlag = flag; }
    789736  Bool    getAllRefLayersActiveFlag(  )                                    { return m_allRefLayersActiveFlag; }
    790 #endif
    791737  Void    setVpsNumberLayerSetsMinus1( Int val )                           { m_vpsNumberLayerSetsMinus1 = val;  }
    792738  Int     getVpsNumberLayerSetsMinus1( )                                   { return m_vpsNumberLayerSetsMinus1; }
     
    819765  Int     getProfileLevelTierIdx( Int outLayerSetIdx )                     { return m_profileLevelTierIdx[ outLayerSetIdx ]; }
    820766
    821 #if H_MV5
    822767  Void    setRepFormatIdxPresentFlag( Bool flag )                          { m_repFormatIdxPresentFlag = flag; }
    823768  Bool    getRepFormatIdxPresentFlag(  )                                   { return m_repFormatIdxPresentFlag; }
     
    831776  Void    setRepFormat( Int i, TComRepFormat* val )                        { m_repFormat[i] = val;  }
    832777  TComRepFormat* getRepFormat( Int i )                                     { return m_repFormat[i]; }
    833 #endif
    834778  Void    setMaxOneActiveRefLayerFlag( Bool flag)                          { m_maxOneActiveRefLayerFlag = flag; }
    835779  Bool    getMaxOneActiveRefLayerFlag( )                                   { return m_maxOneActiveRefLayerFlag; }
    836 #if H_MV5
    837780  Void    setCrossLayerIrapAlignedFlag( Bool flag )                        { m_crossLayerIrapAlignedFlag = flag; }
    838781  Bool    getCrossLayerIrapAlignedFlag(  )                                 { return m_crossLayerIrapAlignedFlag; }
    839 #endif
    840782  Void    setDirectDepTypeLenMinus2( Int val)                              { m_directDepTypeLenMinus2 = val; }
    841783  Int     getDirectDepTypeLenMinus2( )                                     { return m_directDepTypeLenMinus2; }
     
    843785  Void    setDirectDependencyType( Int depLayeridInVps, Int refLayeridInVps, Int val) { m_directDependencyType[ depLayeridInVps ][ refLayeridInVps ] = val; }
    844786  Int     getDirectDependencyType( Int depLayeridInVps, Int refLayeridInVps)   { return m_directDependencyType[ depLayeridInVps ][ refLayeridInVps ]; }
    845 #if H_MV5 
    846787  Void    setVpsVuiPresentFlag( Bool flag )                                { m_vpsVuiPresentFlag = flag; }
    847788  Bool    getVpsVuiPresentFlag(  )                                         { return m_vpsVuiPresentFlag; }
    848789
    849790  TComVPSVUI* getVPSVUI(  )                                                { return m_vpsVUI;  }
    850 #endif
    851791  // VPS EXTENSION SEMANTICS VARIABLES
    852792  Void    setLayerIdInVps( Int layerIdInNuh, Int val )                     { m_layerIdInVps[layerIdInNuh] = val;  }
     
    854794
    855795  Int     getScalabilityId ( Int layerIdInVps, ScalabilityType scalType );
    856 #if H_MV5
    857796  Int     getViewId        ( Int layerIdInNuh )                            { return m_viewIdVal[ getViewIndex( getLayerIdInVps( layerIdInNuh) )]; }
    858 #else
    859   Int     getViewId  ( Int layerIdInVps )                                  { return getScalabilityId( layerIdInVps, VIEW_ID  ); }
    860 
    861 #endif
    862797  Void    setRefLayers();
    863798
    864 #if H_MV5
    865799  Int     getViewIndex    ( Int layerIdInNuh )                             { return getScalabilityId( getLayerIdInVps(layerIdInNuh), VIEW_ORDER_INDEX  ); }   
    866800  Int     getNumViews();
     
    868802  Int     getNumDirectRefLayers( Int layerIdInNuh )                        { return m_numDirectRefLayers[ layerIdInNuh ];  };                               
    869803  Int     getRefLayerId        ( Int layerIdInNuh, Int idx );;
    870 #else
    871   Int     getNumDirectRefLayers( Int layerIdInVps )          { return m_numDirectRefLayers[ layerIdInVps ];  };                               
    872   Int     getRefLayerId        ( Int layerIdInVps, Int idx );;
    873  
    874   Int     getNumSamplePredRefLayers( Int layerIdInVps )          { return m_numSamplePredRefLayers[layerIdInVps]; }
    875   Bool    getSamplePredEnabledFlag ( Int layerIdInVps, Int idx ) { return m_samplePredEnabledFlag [layerIdInVps][idx]; }
    876   Int     getSamplePredRefLayerId  ( Int layerIdInVps, Int idx ) { return m_samplePredRefLayerId  [layerIdInVps][idx]; }
    877 
    878   Int     getNumMotionPredRefLayers( Int layerIdInVps )          { return m_numMotionPredRefLayers[layerIdInVps]; }
    879   Bool    getMotionPredEnabledFlag ( Int layerIdInVps, Int idx ) { return m_motionPredEnabledFlag [layerIdInVps][idx]; }
    880   Int     getMotionPredRefLayerId  ( Int layerIdInVps, Int idx ) { return m_motionPredRefLayerId  [layerIdInVps][idx]; }
    881 #endif 
    882804  Bool    checkVPSExtensionSyntax();
    883805  Int     scalTypeToScalIdx   ( ScalabilityType scalType );
    884806
    885   #if H_MV5
    886807Int     getProfileLevelTierIdxLen()                                      { return gCeilLog2( getVpsNumProfileTierLevelMinus1() + 1 ); };       
    887 #else
    888   Int     getProfileLevelTierIdxLen() { return xCeilLog2( getVpsNumProfileTierLevelMinus1() + 1 ); };       
    889 #endif
    890808
    891809  Int     getNumLayersInIdList              ( Int lsIdx );;
     
    895813  Int     inferLastDimsionIdLenMinus1();
    896814
    897 #if H_MV5
    898815  // helpers
    899816  Bool    getInDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Int depth = 0 );
    900 #endif
    901817  /// VPS EXTENSION 2 SYNTAX ELEMENTS
    902818#if H_3D 
    903 #if H_MV5
    904819  Int     getDepthId      ( Int layerIdInNuh)                             { return getScalabilityId( getLayerIdInVps(layerIdInNuh), DEPTH_ID ); }
    905 #else
    906   Void    initViewIndex();
    907   Int     getViewIndex    ( Int layerIdInVps )                             { return m_viewIndex[ layerIdInVps ]; }   
    908   Int     getDepthId      ( Int layerIdInVps )                             { return getScalabilityId( layerIdInVps, DEPTH_ID ); }
    909 #endif
    910820  Int     getLayerIdInNuh( Int viewIndex, Bool depthFlag );   
    911821
     
    960870  Int           m_winTopOffset;
    961871  Int           m_winBottomOffset;
    962 #if H_MV5
    963872#if H_MV
    964873  Bool          m_scaledFlag;
    965 #endif
    966874#endif
    967875public:
     
    972880  , m_winTopOffset      (0)
    973881  , m_winBottomOffset   (0)
    974 #if H_MV5
    975882#if H_MV
    976883  , m_scaledFlag(true)
    977 #endif
    978884#endif
    979885  { }
     
    990896  Void          setWindowBottomOffset(Int val)    { m_winBottomOffset = val; m_enabledFlag = true; }
    991897
    992 #if H_MV5
    993898#if H_MV
    994899  Void          setScaledFlag(Bool flag)          { m_scaledFlag = flag;  }
     
    1005910    }
    1006911  }
    1007 #endif
    1008912#endif
    1009913  Void          setWindow(Int offsetLeft, Int offsetLRight, Int offsetLTop, Int offsetLBottom)
     
    1054958  TComHRD m_hrdParameters;
    1055959  TimingInfo m_timingInfo;
    1056 #if !H_MV5
    1057 #if H_MV
    1058   Bool m_tileBoundariesAlignedFlag;
    1059 #endif
    1060 #endif
    1061960
    1062961public:
     
    1091990    ,m_log2MaxMvLengthHorizontal(15)
    1092991    ,m_log2MaxMvLengthVertical(15)
    1093 #if !H_MV5
    1094 #if H_MV
    1095     ,m_tileBoundariesAlignedFlag(true)
    1096 #endif
    1097 #endif
    1098992  {}
    1099993
     
    11911085  TComHRD* getHrdParameters                 ()             { return &m_hrdParameters; }
    11921086  TimingInfo* getTimingInfo() { return &m_timingInfo; }
    1193 #if !H_MV5
    1194 #if H_MV
    1195 Bool getTileBoundariesAlignedFlag(  ) { return m_tileBoundariesAlignedFlag; }
    1196   Void setTileBoundariesAlignedFlag( Bool flag ) { m_tileBoundariesAlignedFlag = flag; }
    1197 #endif
    1198 #endif
    11991087
    12001088};
     
    12811169  TComPTL     m_pcPTL;
    12821170#if H_MV
    1283 #if H_MV5
    12841171  TComVPS*    m_pcVPS;
    12851172  // SPS
     
    12871174  Int         m_spsScalingListRefLayerId;
    12881175  Bool        m_updateRepFormatFlag;
    1289 #endif
    12901176  // SPS Extension
    12911177  Bool        m_interViewMvVertConstraintFlag;
    1292 #if !H_MV5
    1293   Int         m_numIlpRestrictedRefLayers        ;
    1294   Int         m_minSpatialSegmentOffsetPlus1[MAX_NUM_LAYERS];
    1295   Bool        m_ctuBasedOffsetEnabledFlag   [MAX_NUM_LAYERS];
    1296   Int         m_minHorizontalCtuOffsetPlus1 [MAX_NUM_LAYERS];
    1297 #endif
    12981178#endif
    12991179#if H_3D
     
    14321312  TComPTL* getPTL()     { return &m_pcPTL; }
    14331313#if H_MV
    1434 #if H_MV5
    14351314  Void      setVPS          ( TComVPS* pcVPS ) { m_pcVPS = pcVPS; }
    14361315  TComVPS*  getVPS          () { return m_pcVPS; }
     
    14441323  Void setUpdateRepFormatFlag( Bool flag )     { m_updateRepFormatFlag = flag; }
    14451324  Bool getUpdateRepFormatFlag(  )              { return m_updateRepFormatFlag; }
    1446 #endif
    14471325  // SPS Extension
    14481326  Void setInterViewMvVertConstraintFlag(Bool val) { m_interViewMvVertConstraintFlag = val; }
    14491327  Bool getInterViewMvVertConstraintFlag()         { return m_interViewMvVertConstraintFlag;}
    1450 #if H_MV5
    14511328  // Inference
    14521329  Void inferRepFormat( TComVPS* vps, Int layerIdCurr );
    14531330
    14541331  Void inferScalingList( TComSPS* spsSrc );
    1455 #else
    1456   Void setNumIlpRestrictedRefLayers   ( Int val )        { m_numIlpRestrictedRefLayers         = val;}
    1457   Int  getNumIlpRestrictedRefLayers   ( )                { return m_numIlpRestrictedRefLayers        ;}
    1458  
    1459   Void setMinSpatialSegmentOffsetPlus1( Int i, Int val ) { m_minSpatialSegmentOffsetPlus1[ i ] = val;}
    1460   Int  getMinSpatialSegmentOffsetPlus1( Int i )          { return m_minSpatialSegmentOffsetPlus1[ i ];}
    1461  
    1462   Void setCtuBasedOffsetEnabledFlag   ( Int i, Bool flag ) { m_ctuBasedOffsetEnabledFlag   [ i ] = flag;}
    1463   Bool getCtuBasedOffsetEnabledFlag   ( Int i )            { return m_ctuBasedOffsetEnabledFlag   [ i ];}
    1464 
    1465   Void setMinHorizontalCtuOffsetPlus1 ( Int i, Int val )   { m_minHorizontalCtuOffsetPlus1 [ i ] = val;}
    1466   Int  getMinHorizontalCtuOffsetPlus1 ( Int i )            { return m_minHorizontalCtuOffsetPlus1 [ i ];}
    1467 
    1468 #endif
    14691332#endif
    14701333#if H_3D_QTLPC
     
    15821445  Int m_numExtraSliceHeaderBits;
    15831446
    1584 #if H_MV5
    15851447#if H_MV
    15861448  Int  m_layerId;
    15871449  Bool m_ppsInferScalingListFlag;
    15881450  Int  m_ppsScalingListRefLayerId;
    1589 #endif
    15901451#endif
    15911452public:
     
    17101571  Bool getSliceHeaderExtensionPresentFlag   ()                    { return m_sliceHeaderExtensionPresentFlag; }
    17111572  Void setSliceHeaderExtensionPresentFlag   (Bool val)            { m_sliceHeaderExtensionPresentFlag = val; }
    1712 #if H_MV5
    17131573#if H_MV
    17141574  Void setLayerId( Int  val ) { m_layerId = val; }
     
    17201580  Void setPpsScalingListRefLayerId( Int  val ) { m_ppsScalingListRefLayerId = val; }
    17211581  Int  getPpsScalingListRefLayerId(  ) { return m_ppsScalingListRefLayerId; }
    1722 #endif
    17231582#endif
    17241583};
     
    17541613  Bool        m_PicOutputFlag;        ///< pic_output_flag
    17551614  Int         m_iPOC;
    1756 #if H_MV5
    17571615#if H_MV
    17581616  Int         m_iPOCBeforeReset;
    1759 #endif
    17601617#endif
    17611618  Int         m_iLastIDR;
     
    18531710  Bool       m_enableTMVPFlag;
    18541711#if H_MV
    1855 #if H_MV5
    18561712  std::vector<TComPic*>* m_refPicSetInterLayer0;
    18571713  std::vector<TComPic*>* m_refPicSetInterLayer1;
     
    18621718  Bool       m_isDepth;
    18631719#endif
    1864 #else
    1865   std::vector<TComPic*>* m_refPicSetInterLayer;
    1866   Int        m_layerId;
    1867   Int        m_viewId;
    1868 #if H_3D
    1869   Int        m_viewIndex;
    1870   Bool       m_isDepth;
    1871 #endif
    1872 #endif
    18731720
    18741721// Additional slice header syntax elements
    1875 #if H_MV5
    18761722  Bool       m_pocResetFlag;
    1877 #endif
    18781723  Bool       m_discardableFlag;
    18791724  Bool       m_interLayerPredEnabledFlag;
    18801725  Int        m_numInterLayerRefPicsMinus1;
    18811726  Int        m_interLayerPredLayerIdc       [MAX_NUM_LAYERS];
    1882 #if !H_MV5
    1883   Bool       m_interLayerSamplePredOnlyFlag;
    1884   Bool       m_altCollocatedIndicationFlag;
    1885   Int        m_collocatedRefLayerIdx;
    1886 // Additional slice header semantics variables
    1887   Int        m_numActiveMotionPredRefLayers;
    1888   Int        m_activeMotionPredRefLayerId   [ MAX_NUM_LAYER_IDS ];
    1889 
    1890 #endif
    18911727  Int        m_aaiCodedScale [2][MAX_NUM_LAYERS];
    18921728  Int        m_aaiCodedOffset[2][MAX_NUM_LAYERS];
     
    20221858 
    20231859#if H_MV
    2024 #if H_MV5
    20251860  Void      setPocBeforeReset   ( Int i )                       { m_iPOCBeforeReset = i; }
    20261861  Int       getPocBeforeReset   ( )                             { return m_iPOCBeforeReset; }
    2027 #endif
    20281862  Int       getRefLayerId        ( RefPicList e, Int iRefIdx)    { return  m_aiRefLayerIdList[e][iRefIdx]; }
    20291863  Void      setRefLayerId        ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefLayerIdList[e][iRefIdx] = i; }
    2030 #if H_MV5
    20311864  Void      getTempRefPicLists   ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1,                                     
    20321865                                   std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int& numPocTotalCurr, Bool checkNumPocTotalCurr = false );
    20331866
    20341867  Void      setRefPicList        ( std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int numPocTotalCurr, Bool checkNumPocTotalCurr = false );
    2035 #else
    2036   Void      setRefPicList       ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& interLayerRefPicSet , Bool checkNumPocTotalCurr = false );
    2037 #endif
    20381868#else
    20391869#if FIX1071
     
    20841914  Void applyReferencePictureSet( TComList<TComPic*>& rcListPic, TComReferencePictureSet *RPSList);
    20851915#if H_MV
    2086 #if !H_MV5
    2087   Void createAndApplyIvReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer );
    2088   static Void markIvRefPicsAsShortTerm    ( std::vector<TComPic*> refPicSetInterLayer );
    2089 #else
    20901916  Void createInterLayerReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1 );
    20911917  static Void markIvRefPicsAsShortTerm    ( std::vector<TComPic*> refPicSetInterLayer0, std::vector<TComPic*> refPicSetInterLayer1 );
    2092 #endif
    20931918  static Void markCurrPic                 ( TComPic* currPic );;
    20941919  static Void markIvRefPicsAsUnused       ( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc  );
    2095 #if H_MV5
    20961920  Void        printRefPicList();
    2097 #else
    2098   Void        xPrintRefPicList();
    2099 #endif
    21001921#endif
    21011922  Bool isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic );
     
    21842005  Void      setViewId             ( Int viewId )     { m_viewId = viewId;   }
    21852006  Int       getViewId             ()                 { return m_viewId;     }
    2186 #if H_MV5
    21872007  Void      setViewIndex          ( Int viewIndex )  { m_viewIndex = viewIndex;   }
    21882008  Int       getViewIndex          ()                 { return m_viewIndex;     }
    2189 #endif
    21902009#if H_3D
    21912010#if H_3D_TMVP
     
    21932012  Void      setAlterRefIdx          ( RefPicList e, Int i ) { m_aiAlterRefIdx[e]    = i;      }
    21942013  Int       getAlterRefIdx          ( RefPicList e )        { return  m_aiAlterRefIdx[e];     }
    2195 #endif
    2196 #if !H_MV5
    2197   Void      setViewIndex          ( Int viewIndex )  { m_viewIndex = viewIndex;   }
    2198   Int       getViewIndex          ()                 { return m_viewIndex;     }
    21992014#endif
    22002015  Void      setIsDepth            ( Bool isDepth )   { m_isDepth = isDepth; }
     
    22192034// Additional slice header syntax elements
    22202035
    2221 #if H_MV5
    22222036  Void setPocResetFlag( Bool flag ) { m_pocResetFlag = flag; }
    22232037  Bool getPocResetFlag(  ) { return m_pocResetFlag; }
    2224 #endif
    22252038
    22262039Void setDiscardableFlag( Bool flag ) { m_discardableFlag = flag; }
     
    22362049Int  getInterLayerPredLayerIdc( Int i ) { return m_interLayerPredLayerIdc[i]; }
    22372050
    2238 #if H_MV5
    22392051  // Additional variables derived in slice header semantics
    22402052  Int  getNumInterLayerRefPicsMinus1Len( ) { return gCeilLog2(  getVPS()->getNumDirectRefLayers( getLayerId() )); }
     
    22502062  Void     setRefPicSetInterLayer       ( std::vector<TComPic*>* refPicSetInterLayer0, std::vector<TComPic*>* refPicSetInterLayer1);
    22512063  TComPic* getPicFromRefPicSetInterLayer( Int setIdc, Int layerId );
    2252 #else
    2253 Void setInterLayerSamplePredOnlyFlag( Bool flag ) { m_interLayerSamplePredOnlyFlag = flag; }
    2254 Bool getInterLayerSamplePredOnlyFlag(  ) { return m_interLayerSamplePredOnlyFlag; }
    2255 
    2256 Void setAltCollocatedIndicationFlag( Bool flag ) { m_altCollocatedIndicationFlag = flag; }
    2257 Bool getAltCollocatedIndicationFlag(  ) { return m_altCollocatedIndicationFlag; }
    2258 
    2259 Void setCollocatedRefLayerIdx( Int  val ) { m_collocatedRefLayerIdx = val; }
    2260 Int  getCollocatedRefLayerIdx(  ) { return m_collocatedRefLayerIdx; }
    2261 
    2262 // Additional variables derived in slice header semantics
    2263 Int  getNumInterLayerRefPicsMinus1Len( ) { return xCeilLog2(  getVPS()->getNumDirectRefLayers( getLayerIdInVps() )); }
    2264 Int  getInterLayerPredLayerIdcLen    ( ) { return xCeilLog2(  getVPS()->getNumDirectRefLayers( getLayerIdInVps() )); }
    2265 
    2266 Int  getNumActiveRefLayerPics( );
    2267 Int  getRefPicLayerId               ( Int i );
    2268 
    2269 Void setActiveMotionPredRefLayers   ( );
    2270 
    2271 Int  getNumActiveMotionPredRefLayers(  )      { return m_numActiveMotionPredRefLayers; }
    2272 Int  getActiveMotionPredRefLayerId  ( Int i ) { return m_activeMotionPredRefLayerId[i]; }
    2273 
    2274 Bool getInterRefEnabledInRPLFlag( );
    2275 
    2276 Void     setRefPicSetInterLayer       ( std::vector<TComPic*>* m_refPicSetInterLayer );
    2277 TComPic* getPicFromRefPicSetInterLayer( Int layerId );
    2278 
    2279 #endif
    22802064#endif
    22812065protected:
     
    22842068TComPic*  xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb);
    22852069#if H_MV
    2286 #if !H_MV5
    2287   Int       xCeilLog2( Int val );
    2288 #endif
    22892070  TComPic*  xGetInterLayerRefPic( std::vector<TComPic*>& rcListIlPic, Int layerId ); 
    22902071#endif
     
    23682149  //! activate a SPS from a active parameter sets SEI message
    23692150  //! \returns true, if activation is successful
    2370 #if !H_MV5
    2371   Bool activateSPSWithSEI(Int SPSId);
    2372 
    2373   //! activate a PPS and depending on isIDR parameter also SPS and VPS
    2374   //! \returns true, if activation is successful
    2375   Bool activatePPS(Int ppsId, Bool isIRAP);
    2376 
    2377   TComVPS* getActiveVPS(){ return m_vpsMap.getPS(m_activeVPSId); };
    2378   TComSPS* getActiveSPS(){ return m_spsMap.getPS(m_activeSPSId); };
    2379   TComPPS* getActivePPS(){ return m_ppsMap.getPS(m_activePPSId); };
    2380 
    2381 protected:
    2382  
    2383   ParameterSetMap<TComVPS> m_vpsMap;
    2384   ParameterSetMap<TComSPS> m_spsMap;
    2385   ParameterSetMap<TComPPS> m_ppsMap;
    2386 
    2387   Int m_activeVPSId;
    2388   Int m_activeSPSId;
    2389   Int m_activePPSId;
    2390 #else
    23912151#if H_MV
    23922152  Bool activateSPSWithSEI(Int SPSId, Int layerId );
     
    24262186#endif
    24272187
    2428 #endif
    24292188};
    24302189
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibCommon/TypeDef.h

    r647 r648  
    181181#define KWU_RC_MADPRED_E0227              0  ///< JCT3V-E0227, inter-view MAD prediction
    182182
    183 
    184 /// FIXES
    185 #if H_MV
    186 #define H_MV5                             1   // Update to MV-HEVC 5 HLS
    187 #endif
    188183/////////////////////////////////////////////////////////////////////////////////////////
    189184///////////////////////////////////   DERIVED DEFINES /////////////////////////////////// 
     
    769764  enum ScalabilityType
    770765  {
    771 #if H_MV5
    772766#if H_3D
    773767    DEPTH_ID = 0,   
    774768#endif   
    775769    VIEW_ORDER_INDEX  = 1,
    776 #else
    777     VIEW_ID  = 0,
    778 #if H_3D
    779     DEPTH_ID = 1,   
    780 #endif   
    781 #endif
    782770  };
    783771#endif
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibDecoder/TDecCAVLC.cpp

    r646 r648  
    330330    }
    331331  }
    332 #if H_MV5
    333332#if H_MV
    334333  if ( pcPPS->getLayerId() > 0 )
     
    344343  { 
    345344#endif
    346 #endif
    347345  READ_FLAG( uiCode, "pps_scaling_list_data_present_flag" );           pcPPS->setScalingListPresentFlag( uiCode ? true : false );
    348346  if(pcPPS->getScalingListPresentFlag ())
     
    350348    parseScalingList( pcPPS->getScalingList() );
    351349  }
    352 #if H_MV5
    353 #if H_MV
    354   }
    355 #endif
     350#if H_MV
     351  }
    356352#endif
    357353
     
    430426  {
    431427    Window &defDisp = pcVUI->getDefaultDisplayWindow();
    432 #if !H_MV5
    433     READ_UVLC(   uiCode, "def_disp_win_left_offset" );                defDisp.setWindowLeftOffset  ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc()) );
    434     READ_UVLC(   uiCode, "def_disp_win_right_offset" );               defDisp.setWindowRightOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc()) );
    435     READ_UVLC(   uiCode, "def_disp_win_top_offset" );                 defDisp.setWindowTopOffset   ( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc()) );
    436     READ_UVLC(   uiCode, "def_disp_win_bottom_offset" );              defDisp.setWindowBottomOffset( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc()) );
    437 #else
    438428#if H_MV
    439429    defDisp.setScaledFlag( false );
     
    448438    READ_UVLC(   uiCode, "def_disp_win_bottom_offset" );              defDisp.setWindowBottomOffset( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc()) );
    449439#endif
    450 #endif
    451440  }
    452441  TimingInfo *timingInfo = pcVUI->getTimingInfo();
     
    471460  {
    472461    READ_FLAG(   uiCode, "tiles_fixed_structure_flag");               pcVUI->setTilesFixedStructureFlag(uiCode);
    473 #if !H_MV5
    474 #if H_MV
    475     if ( pcSPS->getLayerId() > 0 )
    476     {
    477       READ_FLAG( uiCode, "tile_boundaries_aligned_flag" ); pcVUI->setTileBoundariesAlignedFlag( uiCode == 1 );
    478     }
    479 #endif
    480 #endif
    481462    READ_FLAG(   uiCode, "motion_vectors_over_pic_boundaries_flag");  pcVUI->setMotionVectorsOverPicBoundariesFlag(uiCode);
    482463    READ_FLAG(   uiCode, "restricted_ref_pic_lists_flag");            pcVUI->setRestrictedRefPicListsFlag(uiCode);
     
    597578  READ_UVLC(     uiCode, "sps_seq_parameter_set_id" );           pcSPS->setSPSId( uiCode );
    598579  assert(uiCode <= 15);
    599 #if H_MV5
    600580#if H_MV
    601581  if ( pcSPS->getLayerId() > 0 )
     
    606586  if ( pcSPS->getUpdateRepFormatFlag() )
    607587  {
    608 #endif
    609588#endif
    610589  READ_UVLC(     uiCode, "chroma_format_idc" );                  pcSPS->setChromaFormatIdc( uiCode );
     
    619598  READ_UVLC (    uiCode, "pic_width_in_luma_samples" );          pcSPS->setPicWidthInLumaSamples ( uiCode    );
    620599  READ_UVLC (    uiCode, "pic_height_in_luma_samples" );         pcSPS->setPicHeightInLumaSamples( uiCode    );
    621 #if H_MV5
    622 #if H_MV
    623   }
    624 #endif
     600#if H_MV
     601  }
    625602#endif
    626603  READ_FLAG(     uiCode, "conformance_window_flag");
     
    628605  {
    629606    Window &conf = pcSPS->getConformanceWindow();
    630 #if H_MV5
    631607#if H_MV
    632608    // Needs to be scaled later, when ChromaFormatIdc is known.
     
    642618    READ_UVLC(   uiCode, "conf_win_bottom_offset" );             conf.setWindowBottomOffset( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc() ) );
    643619#endif
    644 #else
    645     READ_UVLC(   uiCode, "conf_win_left_offset" );               conf.setWindowLeftOffset  ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc() ) );
    646     READ_UVLC(   uiCode, "conf_win_right_offset" );              conf.setWindowRightOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc() ) );
    647     READ_UVLC(   uiCode, "conf_win_top_offset" );                conf.setWindowTopOffset   ( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc() ) );
    648     READ_UVLC(   uiCode, "conf_win_bottom_offset" );             conf.setWindowBottomOffset( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc() ) );
    649 #endif
    650   }
    651 
    652 #if H_MV5
     620  }
     621
    653622#if H_MV
    654623  if ( pcSPS->getUpdateRepFormatFlag() )
    655624  {
    656 #endif
    657625#endif
    658626  READ_UVLC(     uiCode, "bit_depth_luma_minus8" );
     
    665633  pcSPS->setBitDepthC( uiCode + 8 );
    666634  pcSPS->setQpBDOffsetC( (Int) (6*uiCode) );
    667 #if H_MV5
    668 #if H_MV
    669   }
    670 #endif
     635#if H_MV
     636  }
    671637#endif
    672638
     
    692658    pcSPS->setNumReorderPics(uiCode, i);
    693659#if H_MV
    694 #if H_MV5
    695660    READ_UVLC ( uiCode, "sps_max_latency_increase_plus1[i]");
    696 #else
    697     READ_UVLC ( uiCode, "sps_max_latency_increase[i]");
    698 #endif
    699661#else
    700662    READ_UVLC ( uiCode, "sps_max_latency_increase_plus1");
     
    736698  if(pcSPS->getScalingListFlag())
    737699  {
    738 #if H_MV5
    739700#if H_MV
    740701    if ( pcSPS->getLayerId() > 0 )
     
    750711    {   
    751712#endif
    752 #endif
    753713    READ_FLAG( uiCode, "sps_scaling_list_data_present_flag" );                 pcSPS->setScalingListPresentFlag ( uiCode );
    754714    if(pcSPS->getScalingListPresentFlag ())
     
    756716      parseScalingList( pcSPS->getScalingList() );
    757717    }
    758 #if H_MV5
    759 #if H_MV
    760     }
    761 #endif
     718#if H_MV
     719    }
    762720#endif
    763721  }
     
    814772  if (uiCode)
    815773  {
    816 #if !H_MV5
    817 #if !H_MV
    818     while ( xMoreRbspData() )
    819     {
    820       READ_FLAG( uiCode, "sps_extension_data_flag");
    821     }
    822 #else
    823     READ_FLAG( uiCode, "inter_view_mv_vert_constraint_flag" );    pcSPS->setInterViewMvVertConstraintFlag(uiCode == 1 ? true : false);
    824     ////   sps_extension_vui_parameters( )
    825     if( pcSPS->getVuiParameters()->getBitstreamRestrictionFlag() )
    826     { 
    827       READ_UVLC( uiCode, "num_ilp_restricted_ref_layers" ); pcSPS->setNumIlpRestrictedRefLayers( uiCode );
    828       for( Int i = 0; i < pcSPS->getNumIlpRestrictedRefLayers( ); i++ )
    829       { 
    830         READ_UVLC( uiCode, "min_spatial_segment_offset_plus1" ); pcSPS->setMinSpatialSegmentOffsetPlus1( i, uiCode );
    831         if( pcSPS->getMinSpatialSegmentOffsetPlus1( i ) > 0 )
    832         { 
    833           READ_FLAG( uiCode, "ctu_based_offset_enabled_flag[ i ]"); pcSPS->setCtuBasedOffsetEnabledFlag(i, uiCode == 1 );
    834           if( pcSPS->getCtuBasedOffsetEnabledFlag( i ) ) 
    835           {
    836             READ_UVLC( uiCode, "min_horizontal_ctu_offset_plus1[ i ]"); pcSPS->setMinHorizontalCtuOffsetPlus1( i, uiCode );
    837           }
    838         } 
    839       } 
    840     }
    841 
    842 #if H_3D_QTLPC
    843     if( depthFlag )
    844     {
    845       READ_FLAG( uiCode, "use_qtl_flag" );
    846       pcSPS->setUseQTL( uiCode );
    847       READ_FLAG( uiCode, "use_pc_flag" );
    848       pcSPS->setUsePC( uiCode );
    849     }
    850 #endif
    851     ////   sps_extension_vui_parameters( ) END
    852     READ_UVLC( uiCode, "sps_shvc_reserved_zero_idc" );
    853     READ_FLAG( uiCode, "sps_extension2_flag");
    854     if ( uiCode )
    855     {
    856 #if !H_3D
    857       while ( xMoreRbspData() )
    858       {
    859         READ_FLAG( uiCode, "sps_extension_data_flag");
    860       }
    861 #else
    862      
    863       UInt uiCamParPrecision = 0;
    864       Bool bCamParSlice      = false;
    865       if ( !depthFlag )
    866       {     
    867         READ_UVLC( uiCamParPrecision, "cp_precision" );
    868         READ_FLAG( uiCode, "cp_in_slice_header_flag" );    bCamParSlice = ( uiCode == 1 );
    869         if( !bCamParSlice )
    870         {       
    871           for( UInt uiBaseIndex = 0; uiBaseIndex < viewIndex; uiBaseIndex++ )
    872           {
    873             Int iCode;
    874             READ_SVLC( iCode, "cp_scale" );                m_aaiTempScale  [ uiBaseIndex ][ viewIndex ]   = iCode;
    875             READ_SVLC( iCode, "cp_off" );                  m_aaiTempOffset [ uiBaseIndex ][ viewIndex ]   = iCode;
    876             READ_SVLC( iCode, "cp_inv_scale_plus_scale" ); m_aaiTempScale  [ viewIndex   ][ uiBaseIndex ] = iCode - m_aaiTempScale [ uiBaseIndex ][ viewIndex ];
    877             READ_SVLC( iCode, "cp_inv_off_plus_off" );     m_aaiTempOffset [ viewIndex   ][ uiBaseIndex ] = iCode - m_aaiTempOffset[ uiBaseIndex ][ viewIndex ];
    878           }
    879         }
    880       }
    881       pcSPS->initCamParaSPS( viewIndex, uiCamParPrecision, bCamParSlice, m_aaiTempScale, m_aaiTempOffset );
    882       READ_FLAG( uiCode, "sps_extension3_flag");
    883       if ( uiCode )
    884       {
    885         while ( xMoreRbspData() )
    886         {
    887           READ_FLAG( uiCode, "sps_extension_data_flag");
    888         }
    889       }
    890 #endif // !H_3D
    891     }
    892 #endif // !H_MV
    893   }
    894 }
    895 #else
    896774#if H_MV
    897775    parseSPSExtension( pcSPS );
     
    918796  }
    919797}
    920 #endif
    921 #if H_MV5
    922798Void TDecCavlc::parseSPSExtension( TComSPS* pcSPS )
    923799{
     
    963839}
    964840#endif
    965 #endif
    966841
    967842Void TDecCavlc::parseVPS(TComVPS* pcVPS)
     
    972847  READ_CODE( 2,  uiCode,  "vps_reserved_three_2bits" );           assert(uiCode == 3);
    973848#if H_MV
    974 #if H_MV5
    975849  READ_CODE( 6,  uiCode,  "vps_max_layers_minus1" );              pcVPS->setMaxLayersMinus1( uiCode  );
    976 #else
    977   READ_CODE( 6,  uiCode,  "vps_max_layers_minus1" );              pcVPS->setMaxLayers( uiCode + 1 );
    978 #endif
    979850#else
    980851  READ_CODE( 6,  uiCode,  "vps_reserved_zero_6bits" );            assert(uiCode == 0);
     
    1061932  if (uiCode)
    1062933  {
    1063 #if !H_MV5
    1064 #if H_MV
    1065     m_pcBitstream->readOutTrailingBits();
    1066 
    1067     READ_FLAG( uiCode, "avc_base_layer_flag" );                     pcVPS->setAvcBaseLayerFlag( uiCode == 1 ? true : false );
    1068     READ_FLAG( uiCode, "splitting_flag" );                          pcVPS->setSplittingFlag( uiCode == 1 ? true : false );
    1069 
    1070     for( Int sIdx = 0; sIdx < MAX_NUM_SCALABILITY_TYPES; sIdx++ )
    1071     {
    1072       READ_FLAG( uiCode,  "scalability_mask[i]" );                  pcVPS->setScalabilityMask( sIdx, uiCode == 1 ? true : false );     
    1073     }
    1074 
    1075     for( Int sIdx = 0; sIdx < pcVPS->getNumScalabilityTypes( ) - ( pcVPS->getSplittingFlag() ? 1 : 0 ); sIdx++ )
    1076     {
    1077         READ_CODE( 3, uiCode, "dimension_id_len_minus1[j]" );       pcVPS->setDimensionIdLen( sIdx, uiCode + 1 );
    1078     }
    1079 
    1080     if ( pcVPS->getSplittingFlag() )
    1081       {
    1082       pcVPS->setDimensionIdLen( pcVPS->getNumScalabilityTypes( ) - 1, pcVPS->inferLastDimsionIdLenMinus1() );       
    1083       }
    1084 
    1085     READ_FLAG( uiCode, "vps_nuh_layer_id_present_flag" );           pcVPS->setVpsNuhLayerIdPresentFlag( uiCode == 1 ? true : false );
    1086 
    1087     for( Int i = 0; i <= pcVPS->getMaxLayers() - 1; i++ )
    1088     {
    1089       if ( pcVPS->getVpsNuhLayerIdPresentFlag() && ( i > 0 ) )
    1090       {
    1091         READ_CODE( 6, uiCode, "layer_id_in_nuh[i]" );                pcVPS->setLayerIdInNuh( i, uiCode );
    1092       }
    1093       else
    1094       {
    1095         pcVPS->setLayerIdInNuh( i, i );;
    1096     }
    1097 
    1098       pcVPS->setLayerIdInVps( pcVPS->getLayerIdInNuh( i ), i );
    1099    
    1100       for( Int j = 0; j < pcVPS->getNumScalabilityTypes() ; j++ )
    1101     {
    1102         if ( !pcVPS->getSplittingFlag() )
    1103       {
    1104           READ_CODE( pcVPS->getDimensionIdLen( j ), uiCode, "dimension_id[i][j]" );  pcVPS->setDimensionId( i, j, uiCode );
    1105         }
    1106         else
    1107         {
    1108           pcVPS->setDimensionId( i, j, pcVPS->inferDimensionId( i, j)  );
    1109         }
    1110       }
    1111     }
    1112 
    1113 
    1114     for( Int i = 1; i <= pcVPS->getMaxLayers() - 1; i++ )
    1115     {
    1116       for( Int j = 0; j < i; j++ )
    1117       {
    1118         READ_FLAG( uiCode, "direct_dependency_flag[i][j]" );             pcVPS->setDirectDependencyFlag( i, j, uiCode );
    1119       }
    1120     }
    1121 
    1122     for( Int i = 0; i < pcVPS->getMaxLayers() - 1; i++ )
    1123     {
    1124       READ_CODE( 3, uiCode,       "max_tid_il_ref_pics_plus1[i]" );      pcVPS->setMaxTidIlRefPicPlus1( i , uiCode );
    1125     }
    1126 
    1127     READ_CODE( 10, uiCode, "vps_number_layer_sets_minus1"      );  pcVPS->setVpsNumberLayerSetsMinus1    ( uiCode );
    1128     READ_CODE( 6,  uiCode, "vps_num_profile_tier_level_minus1" );  pcVPS->setVpsNumProfileTierLevelMinus1( uiCode );
    1129 
    1130     for( Int i = 1; i <= pcVPS->getVpsNumProfileTierLevelMinus1(); i++ )
    1131     {
    1132       READ_FLAG(  uiCode, "vps_profile_present_flag[i]" );    pcVPS->setVpsProfilePresentFlag( i, uiCode == 1 );
    1133       if( !pcVPS->getVpsProfilePresentFlag( i ) )
    1134       {
    1135         READ_CODE( 6, uiCode, "profile_ref_minus1[i]" ); pcVPS->setProfileRefMinus1( i, uiCode );
    1136       }
    1137       parsePTL ( pcVPS->getPTL( i ), pcVPS->getVpsProfilePresentFlag( i ), pcVPS->getMaxTLayers()-1);
    1138       if( !pcVPS->getVpsProfilePresentFlag( i ) )
    1139       {
    1140         TComPTL temp = *pcVPS->getPTL( i );
    1141         *pcVPS->getPTL( i ) = *pcVPS->getPTL( pcVPS->getProfileRefMinus1( i ) + 1 );
    1142         pcVPS->getPTL( i )->copyLevelFrom( &temp );
    1143       }
    1144     }
    1145 
    1146     Int numOutputLayerSets = pcVPS->getVpsNumberLayerSetsMinus1( ) + 1;
    1147 
    1148     READ_FLAG( uiCode, "more_output_layer_sets_than_default_flag" ); pcVPS->setMoreOutputLayerSetsThanDefaultFlag( uiCode == 1 );
    1149 
    1150     if ( pcVPS->getMoreOutputLayerSetsThanDefaultFlag( ) )
    1151     {
    1152       READ_CODE( 10, uiCode, "num_add_output_layer_sets_minus1"      ); pcVPS->setNumAddOutputLayerSetsMinus1( uiCode );
    1153       numOutputLayerSets += ( pcVPS->getNumAddOutputLayerSetsMinus1( ) + 1);
    1154     }
    1155 
    1156     if( numOutputLayerSets > 1)
    1157     {
    1158       READ_FLAG( uiCode, "default_one_target_output_layer_flag" ); pcVPS->setDefaultOneTargetOutputLayerFlag(  uiCode == 1);
    1159     } 
    1160 
    1161     for( Int i = 1; i < numOutputLayerSets; i++ )
    1162     {
    1163       if( i > pcVPS->getVpsNumberLayerSetsMinus1( ) )
    1164       {       
    1165         READ_UVLC( uiCode,      "output_layer_set_idx_minus1[i]" ); pcVPS->setOutputLayerSetIdxMinus1( i, uiCode );
    1166         for( Int j = 0; j < pcVPS->getNumLayersInIdList( j ) - 1; j++ )
    1167         {
    1168           READ_FLAG( uiCode, "output_layer_flag" ); pcVPS->setOutputLayerFlag( i, j, uiCode == 1 );
    1169         }       
    1170       }
    1171       if ( pcVPS->getProfileLevelTierIdxLen()  > 0 )
    1172       {     
    1173         READ_CODE( pcVPS->getProfileLevelTierIdxLen(), uiCode,"profile_level_tier_idx[ i ]" );   pcVPS->setProfileLevelTierIdx( i , uiCode );
    1174       }
    1175     }
    1176 
    1177     READ_FLAG( uiCode , "max_one_active_ref_layer_flag" ); pcVPS->setMaxOneActiveRefLayerFlag( uiCode == 1 );
    1178     READ_UVLC( uiCode,  "direct_dep_type_len_minus2"); pcVPS->setDirectDepTypeLenMinus2 ( uiCode );
    1179 
    1180     for( Int i = 1; i <= pcVPS->getMaxLayers() - 1; i++ )
    1181     {
    1182       for( Int j = 0; j < i; j++ )
    1183       {
    1184         if (pcVPS->getDirectDependencyFlag( i, j) )
    1185         {       
    1186           READ_CODE( pcVPS->getDirectDepTypeLenMinus2( ) + 2,  uiCode, "direct_dependency_type[i][j]" ); pcVPS->setDirectDependencyType( i, j , uiCode);
    1187         }
    1188       }
    1189     }
    1190 
    1191     READ_FLAG ( uiCode,                    "vps_shvc_reserved_zero_flag" );
    1192 
    1193 #if H_3D   
    1194     READ_FLAG( uiCode,  "vps_extension2_flag" );
    1195     if (uiCode)
    1196     {
    1197       m_pcBitstream->readOutTrailingBits();
    1198 
    1199       for( Int i = 0; i <= pcVPS->getMaxLayers() - 1; i++ )
    1200       {
    1201 
    1202 #if H_3D_ARP
    1203         pcVPS->setUseAdvRP  ( i, 0 );
    1204         pcVPS->setARPStepNum( i, 1 );
    1205 #endif 
    1206         if ( i != 0 )
    1207         {
    1208           if( !( pcVPS->getDepthId( i ) == 1 ) )
    1209           {
    1210 #if H_3D_IV_MERGE
    1211                 READ_FLAG( uiCode, "iv_mv_pred_flag[i]");          pcVPS->setIvMvPredFlag         ( i, uiCode == 1 ? true : false );
    1212 #endif
    1213 #if H_3D_ARP
    1214                 READ_FLAG( uiCode, "iv_res_pred_flag[i]"  );  pcVPS->setUseAdvRP  ( i, uiCode ); pcVPS->setARPStepNum( i, uiCode ? H_3D_ARP_WFNR : 1 );
    1215 
    1216 #endif
    1217 #if H_3D_NBDV_REF
    1218                 READ_FLAG( uiCode, "depth_refinement_flag[i]");    pcVPS->setDepthRefinementFlag  ( i, uiCode == 1 ? true : false );
    1219 #endif
    1220 #if H_3D_VSP
    1221                 READ_FLAG( uiCode, "view_synthesis_pred_flag[i]"); pcVPS->setViewSynthesisPredFlag( i, uiCode == 1 ? true : false );
    1222 #endif
    1223           }
    1224           else
    1225           {
    1226 
    1227             READ_FLAG( uiCode, "vps_depth_modes_flag[i]" );             pcVPS->setVpsDepthModesFlag( i, uiCode == 1 ? true : false );
    1228             //          READ_FLAG( uiCode, "lim_qt_pred_flag[i]");                  pcVPS->setLimQtPreFlag     ( i, uiCode == 1 ? true : false );
    1229 #if H_3D_DIM_DLT
    1230             if( pcVPS->getVpsDepthModesFlag( i ) )
    1231             {
    1232               READ_FLAG( uiCode, "dlt_flag[i]" );                       pcVPS->setUseDLTFlag( i, uiCode == 1 ? true : false );
    1233             }
    1234             if( pcVPS->getUseDLTFlag( i ) )
    1235             {
    1236               // decode mapping
    1237               UInt uiNumDepthValues;
    1238               // parse number of values in DLT
    1239               READ_UVLC(uiNumDepthValues, "num_depth_values_in_dlt[i]");
    1240 
    1241               // parse actual DLT values
    1242               Int* aiIdx2DepthValue = (Int*) calloc(uiNumDepthValues, sizeof(Int));
    1243               for(Int d=0; d<uiNumDepthValues; d++)
    1244               {
    1245                 READ_UVLC(uiCode, "dlt_depth_value[i][d]");
    1246                 aiIdx2DepthValue[d] = (Int)uiCode;
    1247               }
    1248 
    1249               pcVPS->setDepthLUTs(i, aiIdx2DepthValue, uiNumDepthValues);
    1250 
    1251               // clean memory
    1252               free(aiIdx2DepthValue);
    1253             }
    1254 #endif
    1255 #if H_3D_INTER_SDC
    1256             READ_FLAG( uiCode, "depth_inter_SDC_flag" );              pcVPS->setInterSDCFlag( i, uiCode ? true : false );
    1257 #endif
    1258           }
    1259         }
    1260       }
    1261       READ_FLAG( uiCode, "iv_mv_scaling_flag");                       pcVPS->setIvMvScalingFlag( uiCode == 1 ? true : false );
    1262     }
    1263 #endif
    1264     pcVPS->checkVPSExtensionSyntax();
    1265 
    1266     pcVPS->setRefLayers();
    1267 
    1268 #else
    1269     while ( xMoreRbspData() )
    1270     {
    1271       READ_FLAG( uiCode, "vps_extension_data_flag");
    1272     }
    1273 #endif   
    1274   }
    1275 
    1276 #if H_3D
    1277   pcVPS->initViewIndex();
    1278 #endif
    1279   return;
    1280 }
    1281 #else
    1282934#if H_MV
    1283935    m_pcBitstream->readOutTrailingBits();
     
    1306958  }
    1307959}
    1308 #endif
    1309 
    1310 #if H_MV5
     960
    1311961#if H_MV
    1312962Void TDecCavlc::parseVPSExtension( TComVPS* pcVPS )
     
    16491299}
    16501300#endif
    1651 #endif
    16521301
    16531302Void TDecCavlc::parseSliceHeader (TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager)
     
    16801329#if H_MV
    16811330  vps = parameterSetManager->getPrefetchedVPS(sps->getVPSId());
    1682 #if H_MV5
    16831331  assert( vps != NULL );
    16841332 
     
    16921340  rpcSlice->setIsDepth  ( vps->getDepthId  ( rpcSlice->getLayerId() ) == 1 );
    16931341#endif
    1694 #else
    1695   assert(vps!=0);
    1696   rpcSlice->setVPS(vps);     
    1697   rpcSlice->setViewId   ( vps->getViewId   ( rpcSlice->getLayerIdInVps() )      );
    1698 #if H_3D 
    1699   rpcSlice->setViewIndex( vps->getViewIndex( rpcSlice->getLayerIdInVps() )      ); 
    1700   rpcSlice->setIsDepth  ( vps->getDepthId  ( rpcSlice->getLayerIdInVps() ) == 1 );
    1701 #endif
    1702 #endif
    17031342#endif
    17041343  rpcSlice->setSPS(sps);
     
    17471386  {
    17481387#if H_MV   
    1749 #if H_MV5
    17501388    Int esb = 0; //Don't use i, otherwise will shadow something below
    17511389    if ( rpcSlice->getPPS()->getNumExtraSliceHeaderBits() > esb )
     
    17621400
    17631401    for (; esb < rpcSlice->getPPS()->getNumExtraSliceHeaderBits(); esb++)   
    1764 #else
    1765     if ( rpcSlice->getPPS()->getNumExtraSliceHeaderBits() > 0 )
    1766     {
    1767       READ_FLAG( uiCode, "discardable_flag" ); rpcSlice->setDiscardableFlag( uiCode == 1 );
    1768     }
    1769 
    1770     for (Int i = 1; i < rpcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)   
    1771 #endif
    17721402#else
    17731403    for (Int i = 0; i < rpcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
     
    18331463      }
    18341464      rpcSlice->setPOC              (iPOCmsb+iPOClsb);
    1835 #if H_MV5
    18361465#if H_MV
    18371466      if ( rpcSlice->getPocResetFlag() ) 
     
    18411470
    18421471      }     
    1843 #endif
    18441472#endif
    18451473      TComReferencePictureSet* rps;
     
    19701598    }
    19711599#if H_MV
    1972 #if H_MV5
    19731600    Int layerId       = rpcSlice->getLayerId();
    19741601    if( rpcSlice->getLayerId() > 0 && !vps->getAllRefLayersActiveFlag() && vps->getNumDirectRefLayers( layerId ) > 0 )    {   
     
    19891616      } 
    19901617    }
    1991 #else
    1992     Int layerIdInVps       = rpcSlice->getLayerIdInVps();
    1993     if( rpcSlice->getLayerId() > 0 && vps->getNumDirectRefLayers( layerIdInVps ) > 0 )
    1994     {   
    1995       READ_FLAG( uiCode, "inter_layer_pred_enabled_flag" ); rpcSlice->setInterLayerPredEnabledFlag( uiCode == 1 );
    1996       if( rpcSlice->getInterLayerPredEnabledFlag() && vps->getNumDirectRefLayers( layerIdInVps ) > 1 )
    1997       {           
    1998         if( !vps->getMaxOneActiveRefLayerFlag()) 
    1999         {
    2000           READ_CODE( rpcSlice->getNumInterLayerRefPicsMinus1Len( ), uiCode, "num_inter_layer_ref_pics_minus1" ); rpcSlice->setNumInterLayerRefPicsMinus1( uiCode );
    2001         }
    2002         for( Int i = 0; i < rpcSlice->getNumActiveRefLayerPics(); i++ )   
    2003         {
    2004           READ_CODE( rpcSlice->getInterLayerPredLayerIdcLen( ), uiCode, "inter_layer_pred_layer_idc" ); rpcSlice->setInterLayerPredLayerIdc( i, uiCode );
    2005         }
    2006       } 
    2007     }
    2008 
    2009     rpcSlice->setActiveMotionPredRefLayers( );
    2010 
    2011     if( vps->getNumSamplePredRefLayers( layerIdInVps ) > 0  &&  rpcSlice->getNumActiveRefLayerPics() > 0 )
    2012     {
    2013       READ_FLAG( uiCode, "inter_layer_sample_pred_only_flag" ); rpcSlice->setInterLayerSamplePredOnlyFlag( uiCode == 1 );
    2014     }
    2015 #endif
    20161618#endif
    20171619    if(sps->getUseSAO())
     
    21551757    if ( rpcSlice->getEnableTMVPFlag() )
    21561758    {
    2157 #if !H_MV5
    2158 #if H_MV
    2159       if( rpcSlice->getLayerId() > 0 && rpcSlice->getNumActiveMotionPredRefLayers() > 0 )
    2160       {
    2161         READ_FLAG( uiCode, "alt_collocated_indication_flag" ); rpcSlice->setAltCollocatedIndicationFlag( uiCode == 1 );
    2162       }
    2163 
    2164       if( rpcSlice->getAltCollocatedIndicationFlag() && rpcSlice->getNumActiveMotionPredRefLayers() > 1 )
    2165       {         
    2166         READ_UVLC( uiCode, "collocated_ref_layer_idx" ); rpcSlice->setCollocatedRefLayerIdx( uiCode );
    2167       }     
    2168       else
    2169       {
    2170 #endif
    2171 #endif
    21721759      if ( rpcSlice->getSliceType() == B_SLICE )
    21731760      {
     
    21911778        rpcSlice->setColRefIdx(0);
    21921779      }
    2193 #if !H_MV5
    2194 #if H_MV
    2195       }
    2196 #endif
    2197 #endif
    21981780    }
    21991781    if ( (pps->getUseWP() && rpcSlice->getSliceType()==P_SLICE) || (pps->getWPBiPred() && rpcSlice->getSliceType()==B_SLICE) )
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibDecoder/TDecCAVLC.h

    r646 r648  
    7676  Void  parseQtRootCbf      ( UInt uiAbsPartIdx, UInt& uiQtRootCbf );
    7777  Void  parseVPS            ( TComVPS* pcVPS );
    78 #if H_MV5
    7978#if H_MV
    8079  Void  parseVPSExtension   ( TComVPS* pcVPS );
     
    8685  Void  parseSPSExtension   ( TComSPS* pcSPS ); 
    8786#endif
    88 #endif
    8987#if H_3D
    90 #if H_MV5
    9188  Void  parseVPSExtension2  ( TComVPS* pcVPS );
    9289  Void  parseSPSExtension2  ( TComSPS* pcSPS, Int viewIndex, Bool depthFlag );
    93 #endif
    9490  Void  parseSPS            ( TComSPS* pcSPS, Int viewIndex, Bool depthFlag );
    9591#else
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibDecoder/TDecTop.cpp

    r647 r648  
    436436  Window defaultDisplayWindow = pcSlice->getSPS()->getVuiParametersPresentFlag() ? pcSlice->getSPS()->getVuiParameters()->getDefaultDisplayWindow() : Window();
    437437
    438 #if H_MV5
    439438#if H_MV
    440439    assert( conformanceWindow   .getScaledFlag() );
    441440    assert( defaultDisplayWindow.getScaledFlag() );
    442 #endif
    443441#endif
    444442  for( Int temporalLayer=0; temporalLayer < MAX_TLAYER; temporalLayer++)
     
    518516  m_cCuDecoder.destroy();       
    519517#if H_MV
    520 #if H_MV5
    521518  TComSlice::markIvRefPicsAsShortTerm( m_refPicSetInterLayer0, m_refPicSetInterLayer1 ); 
    522 #else
    523   TComSlice::markIvRefPicsAsShortTerm( m_refPicSetInterLayer ); 
    524 #endif
    525519  TComSlice::markCurrPic( pcPic );
    526520  TComSlice::markIvRefPicsAsUnused   ( m_ivPicLists, targetDecLayerIdSet, m_parameterSetManagerDecoder.getActiveVPS(), m_layerId, poc );
     
    591585  assert (sps != 0);
    592586
    593 #if H_MV5
    594587#if H_MV
    595588  TComVPS* vps = m_parameterSetManagerDecoder.getVPS(sps->getVPSId());
     
    599592  if (false == m_parameterSetManagerDecoder.activatePPS(m_apcSlicePilot->getPPSId(),m_apcSlicePilot->isIRAP()))
    600593#endif
    601 #else
    602   if (false == m_parameterSetManagerDecoder.activatePPS(m_apcSlicePilot->getPPSId(),m_apcSlicePilot->isIRAP()))
    603 #endif
    604594  {
    605595    printf ("Parameter set activation failed!");
     
    627617  m_apcSlicePilot->setSPS(sps);
    628618#if H_MV
    629 #if H_MV5
    630619  m_apcSlicePilot->setVPS(vps); 
    631620  sps->inferRepFormat  ( vps , m_layerId );
    632621  sps->inferScalingList( m_parameterSetManagerDecoder.getActiveSPS( sps->getSpsScalingListRefLayerId() ) );
    633 #else
    634   m_apcSlicePilot->setVPS( m_parameterSetManagerDecoder.getActiveVPS() );
    635 #endif
    636622#endif
    637623  pps->setSPS(sps);
     
    695681
    696682#if H_MV
    697 #if H_MV5
    698683  m_apcSlicePilot->setRefPicSetInterLayer( & m_refPicSetInterLayer0, &m_refPicSetInterLayer1 );
    699 #else
    700   m_apcSlicePilot->setRefPicSetInterLayer( & m_refPicSetInterLayer );
    701 #endif
    702684  m_apcSlicePilot->setLayerId( nalu.m_layerId );
    703685#endif
     
    706688#if H_MV 
    707689  TComVPS* vps     = m_apcSlicePilot->getVPS();
    708 #if H_MV5
    709690  Int layerId  = nalu.m_layerId;   
    710691  setViewId   ( vps->getViewId   ( layerId )      ); 
     
    714695  m_ivPicLists->setVPS( vps );
    715696#endif
    716 #else
    717   Int layerIdInVps = vps->getLayerIdInVps( nalu.m_layerId ); 
    718   setViewId   ( vps->getViewId   ( layerIdInVps )      ); 
    719 #if H_3D
    720   setViewIndex( vps->getViewIndex( layerIdInVps )      ); 
    721   setIsDepth  ( vps->getDepthId  ( layerIdInVps ) == 1 ); 
    722   m_ivPicLists->setVPS( vps );
    723 #endif
    724 #endif
    725697#endif
    726698    // Skip pictures due to random access
     
    763735#endif
    764736  // actual decoding starts here
    765 #if H_MV5
    766737#if H_MV
    767738   // This part needs further testing !
     
    771742   }
    772743#endif
    773 #endif
    774744  xActivateParameterSets();
    775745
     
    791761    m_apcSlicePilot->applyReferencePictureSet(m_cListPic, m_apcSlicePilot->getRPS());
    792762#if H_MV
    793 #if H_MV5
    794763    m_apcSlicePilot->createInterLayerReferencePictureSet( m_ivPicLists, m_refPicSetInterLayer0, m_refPicSetInterLayer1 );
    795 #else
    796     m_apcSlicePilot->createAndApplyIvReferencePictureSet( m_ivPicLists, m_refPicSetInterLayer );
    797 #endif
    798764#endif
    799765    //  Get a new picture buffer
     
    941907    // Set reference list
    942908#if H_MV   
    943 #if H_MV5
    944909    std::vector< TComPic* > tempRefPicLists[2];
    945910    std::vector< Bool     > usedAsLongTerm [2];
     
    948913    pcSlice->getTempRefPicLists( m_cListPic, m_refPicSetInterLayer0, m_refPicSetInterLayer1, tempRefPicLists, usedAsLongTerm, numPocTotalCurr);
    949914    pcSlice->setRefPicList     ( tempRefPicLists, usedAsLongTerm, numPocTotalCurr, true );
    950 #else
    951     pcSlice->setRefPicList( m_cListPic, m_refPicSetInterLayer, true );   
    952 #endif
    953915#if H_3D_ARP
    954916    pcSlice->setARPStepNum();
     
    10881050  TComVPS* vps = m_parameterSetManagerDecoder.getPrefetchedVPS( 0 );
    10891051  assert( vps != 0 );
    1090 #if H_MV5
    10911052  m_cEntropyDecoder.decodeSPS( sps, vps->getViewIndex( m_layerId ), ( vps->getDepthId( m_layerId ) == 1 ) );
    10921053#else
    1093   Int layerIdInVPS = vps->getLayerIdInVps( m_layerId );
    1094   m_cEntropyDecoder.decodeSPS( sps, vps->getViewIndex( layerIdInVPS ), ( vps->getDepthId( layerIdInVPS ) == 1 ) );
    1095 #endif
    1096 #else
    10971054  m_cEntropyDecoder.decodeSPS( sps );
    10981055#endif
     
    11031060{
    11041061  TComPPS* pps = new TComPPS();
    1105 #if H_MV5
    11061062#if H_MV
    11071063  pps->setLayerId( getLayerId() );
    1108 #endif
    11091064#endif
    11101065  m_cEntropyDecoder.decodePPS( pps );
     
    11161071  if(nalUnitType == NAL_UNIT_SUFFIX_SEI)
    11171072  {
    1118 #if H_MV5
    11191073#if H_MV
    11201074    m_seiReader.parseSEImessage( bs, m_pcPic->getSEIs(), nalUnitType, m_parameterSetManagerDecoder.getActiveSPS( m_layerId ) );
     
    11221076    m_seiReader.parseSEImessage( bs, m_pcPic->getSEIs(), nalUnitType, m_parameterSetManagerDecoder.getActiveSPS() );
    11231077#endif
    1124 #else
    1125     m_seiReader.parseSEImessage( bs, m_pcPic->getSEIs(), nalUnitType, m_parameterSetManagerDecoder.getActiveSPS() ); 
    1126 #endif
    11271078  }
    11281079  else
    11291080  {
    1130 #if H_MV5
    11311081#if H_MV
    11321082    m_seiReader.parseSEImessage( bs, m_SEIs, nalUnitType, m_parameterSetManagerDecoder.getActiveSPS( m_layerId ) );
     
    11341084    m_seiReader.parseSEImessage( bs, m_SEIs, nalUnitType, m_parameterSetManagerDecoder.getActiveSPS() );
    11351085#endif
    1136 #else
    1137     m_seiReader.parseSEImessage( bs, m_SEIs, nalUnitType, m_parameterSetManagerDecoder.getActiveSPS() );
    1138 #endif
    11391086    SEIMessages activeParamSets = getSeisByType(m_SEIs, SEI::ACTIVE_PARAMETER_SETS);
    11401087    if (activeParamSets.size()>0)
     
    11431090      m_parameterSetManagerDecoder.applyPrefetchedPS();
    11441091      assert(seiAps->activeSeqParamSetId.size()>0);
    1145 #if H_MV5
    11461092#if H_MV
    11471093      if (! m_parameterSetManagerDecoder.activateSPSWithSEI(seiAps->activeSeqParamSetId[0], m_layerId ))
    1148 #else
    1149       if (! m_parameterSetManagerDecoder.activateSPSWithSEI(seiAps->activeSeqParamSetId[0] ))
    1150 #endif
    11511094#else
    11521095      if (! m_parameterSetManagerDecoder.activateSPSWithSEI(seiAps->activeSeqParamSetId[0] ))
     
    13101253}
    13111254
    1312 #if H_MV5
    13131255Void TDecTop::xResetPocInPicBuffer()
    13141256{
     
    13281270}
    13291271#endif
    1330 #endif
    13311272//! \}
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibDecoder/TDecTop.h

    r622 r648  
    216216  Int                     m_viewId;
    217217  TComPicLists*           m_ivPicLists;
    218 #if H_MV5
    219218  std::vector<TComPic*>   m_refPicSetInterLayer0;
    220219  std::vector<TComPic*>   m_refPicSetInterLayer1;
    221 #else
    222   std::vector<TComPic*>   m_refPicSetInterLayer;
    223 #endif
    224220#if H_3D
    225221  Int                     m_viewIndex;
     
    279275  TComPic*  xGetPic( Int layerId, Int poc );
    280276  Bool      xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay, Bool newLayerFlag ); 
    281 #if H_MV5
    282277  Void      xResetPocInPicBuffer();
    283 #endif
    284278#else
    285279  Bool      xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay);
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibEncoder/TEncCavlc.cpp

    r646 r648  
    229229    }
    230230  }
    231 #if H_MV5
    232231#if H_MV
    233232  if ( pcPPS->getLayerId() > 0 )
     
    243242  { 
    244243#endif 
    245 #endif
    246244  WRITE_FLAG( pcPPS->getScalingListPresentFlag() ? 1 : 0,                          "pps_scaling_list_data_present_flag" );
    247245  if( pcPPS->getScalingListPresentFlag() )
     
    252250    codeScalingList( m_pcSlice->getScalingList() );
    253251  }
    254 #if H_MV5
    255252#if H_MV
    256253  }
    257 #endif
    258254#endif
    259255  WRITE_FLAG( pcPPS->getListsModificationPresentFlag(), "lists_modification_present_flag");
     
    339335  {
    340336    WRITE_FLAG(pcVUI->getTilesFixedStructureFlag(),             "tiles_fixed_structure_flag");
    341 #if !H_MV5
    342 #if H_MV
    343     if ( pcSPS->getLayerId() > 0 )
    344     {
    345       WRITE_FLAG( pcVUI->getTileBoundariesAlignedFlag( ) ? 1 : 0 , "tile_boundaries_aligned_flag" );
    346     }
    347 #endif
    348 #endif
    349337    WRITE_FLAG(pcVUI->getMotionVectorsOverPicBoundariesFlag(),  "motion_vectors_over_pic_boundaries_flag");
    350338    WRITE_FLAG(pcVUI->getRestrictedRefPicListsFlag(),           "restricted_ref_pic_lists_flag");
     
    451439#endif
    452440  WRITE_UVLC( pcSPS->getSPSId (),                   "sps_seq_parameter_set_id" );
    453 #if H_MV5
    454441#if H_MV
    455442  if ( pcSPS->getLayerId() > 0 )
     
    460447  if ( pcSPS->getUpdateRepFormatFlag() )
    461448  {
    462 #endif
    463449#endif
    464450  WRITE_UVLC( pcSPS->getChromaFormatIdc (),         "chroma_format_idc" );
     
    472458  WRITE_UVLC( pcSPS->getPicWidthInLumaSamples (),   "pic_width_in_luma_samples" );
    473459  WRITE_UVLC( pcSPS->getPicHeightInLumaSamples(),   "pic_height_in_luma_samples" );
    474 #if H_MV5
    475460#if H_MV
    476461  }
    477 #endif
    478462#endif
    479463  Window conf = pcSPS->getConformanceWindow();
     
    487471    WRITE_UVLC( conf.getWindowBottomOffset() / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc() ), "conf_win_bottom_offset" );
    488472  }
    489 #if H_MV5
    490473#if H_MV
    491474  if ( pcSPS->getUpdateRepFormatFlag() )
    492475  {
    493476#endif
    494 #endif
    495477  WRITE_UVLC( pcSPS->getBitDepthY() - 8,             "bit_depth_luma_minus8" );
    496478  WRITE_UVLC( pcSPS->getBitDepthC() - 8,             "bit_depth_chroma_minus8" );
    497 #if H_MV5
    498479#if H_MV
    499480  }
    500 #endif
    501481#endif
    502482  WRITE_UVLC( pcSPS->getBitsForPOC()-4,                 "log2_max_pic_order_cnt_lsb_minus4" );
     
    525505  if(pcSPS->getScalingListFlag())
    526506  {
    527 #if H_MV5
    528507#if H_MV
    529508    if ( pcSPS->getLayerId() > 0 )
     
    539518    {   
    540519#endif
    541 #endif
    542520    WRITE_FLAG( pcSPS->getScalingListPresentFlag() ? 1 : 0,                          "sps_scaling_list_data_present_flag" );
    543521    if(pcSPS->getScalingListPresentFlag())
     
    548526      codeScalingList( m_pcSlice->getScalingList() );
    549527    }
    550 #if H_MV5
    551528#if H_MV
    552529    }
    553 #endif
    554530#endif
    555531  }
     
    598574  }
    599575
    600 #if !H_MV5
    601 #if H_MV
    602   WRITE_FLAG( 1, "sps_extension_flag" );
    603   WRITE_FLAG( pcSPS->getInterViewMvVertConstraintFlag() ? 1 : 0, "inter_view_mv_vert_constraint_flag" );
    604   ////   sps_extension_vui_parameters( )
    605   if( pcSPS->getVuiParameters()->getBitstreamRestrictionFlag() )
    606   { 
    607     WRITE_UVLC( pcSPS->getNumIlpRestrictedRefLayers( ),           "num_ilp_restricted_ref_layers" );
    608     for( Int i = 0; i < pcSPS->getNumIlpRestrictedRefLayers( ); i++ )
    609     { 
    610       WRITE_UVLC( pcSPS->getMinSpatialSegmentOffsetPlus1( i ),    "min_spatial_segment_offset_plus1" );
    611       if( pcSPS->getMinSpatialSegmentOffsetPlus1( i ) > 0 )
    612       { 
    613         WRITE_FLAG( pcSPS->getCtuBasedOffsetEnabledFlag( i ),      "ctu_based_offset_enabled_flag[ i ]");
    614         if( pcSPS->getCtuBasedOffsetEnabledFlag( i ) ) 
    615         {
    616           WRITE_UVLC( pcSPS->getMinHorizontalCtuOffsetPlus1( i ), "min_horizontal_ctu_offset_plus1[ i ]");
    617         }
    618       } 
    619     } 
    620   }
    621 #if H_3D_QTLPC
    622   if( depthFlag )
    623   {
    624     WRITE_FLAG( pcSPS->getUseQTL() ? 1 : 0, "use_qtl_flag");
    625     WRITE_FLAG( pcSPS->getUsePC()  ? 1 : 0, "use_pc_flag");
    626   }
    627 #endif
    628   ////   sps_extension_vui_parameters( ) END
    629   WRITE_UVLC( 0, "sps_shvc_reserved_zero_idc" );
    630 #if !H_3D
    631   WRITE_FLAG( 0, "sps_extension2_flag" );
    632 #else
    633   WRITE_FLAG( 1, "sps_extension2_flag"  );
    634   if (!depthFlag )
    635   {
    636     WRITE_UVLC( pcSPS->getCamParPrecision(), "cp_precision" );
    637     WRITE_FLAG( pcSPS->hasCamParInSliceHeader() ? 1 : 0, "cp_in_slice_header_flag" );
    638     if( !pcSPS->hasCamParInSliceHeader() )
    639     {
    640       for( UInt uiIndex = 0; uiIndex < viewIndex; uiIndex++ )
    641       {
    642         WRITE_SVLC( pcSPS->getCodedScale    ()[ uiIndex ],                                      "cp_scale" );
    643         WRITE_SVLC( pcSPS->getCodedOffset   ()[ uiIndex ],                                      "cp_off" );
    644         WRITE_SVLC( pcSPS->getInvCodedScale ()[ uiIndex ] + pcSPS->getCodedScale ()[ uiIndex ], "cp_inv_scale_plus_scale" );
    645         WRITE_SVLC( pcSPS->getInvCodedOffset()[ uiIndex ] + pcSPS->getCodedOffset()[ uiIndex ], "cp_inv_off_plus_off" );
    646       }
    647     }
    648   }
    649 
    650   WRITE_FLAG( 0, "sps_extension3_flag" );
    651 #endif
    652 #else
    653   WRITE_FLAG( 0, "sps_extension_flag" );
    654 #endif
    655 }
    656 #else
    657576#if !H_MV
    658577  WRITE_FLAG( 0, "sps_extension_flag" );
     
    706625}
    707626#endif
    708 #endif
    709627
    710628Void TEncCavlc::codeVPS( TComVPS* pcVPS )
     
    713631  WRITE_CODE( 3,                                    2,        "vps_reserved_three_2bits" );
    714632#if H_MV
    715 #if H_MV5
    716633  WRITE_CODE( pcVPS->getMaxLayersMinus1(),       6,        "vps_max_layers_minus1" );
    717 #else
    718   WRITE_CODE( pcVPS->getMaxLayers() - 1,            6,        "vps_max_layers_minus1" );
    719 #endif
    720634#else
    721635  WRITE_CODE( 0,                                    6,        "vps_reserved_zero_6bits" );
     
    800714    }
    801715  }
    802 #if !H_MV5
    803 #if H_MV
    804   WRITE_FLAG( 1,                                             "vps_extension_flag" );
    805 
    806   m_pcBitIf->writeAlignOne();                       
    807 
    808   WRITE_FLAG( pcVPS->getAvcBaseLayerFlag() ? 1 : 0,          "avc_base_layer_flag" );
    809   WRITE_FLAG( pcVPS->getSplittingFlag() ? 1 : 0,             "splitting_flag" );
    810  
    811   for( Int type = 0; type < MAX_NUM_SCALABILITY_TYPES; type++ )
    812   {
    813     WRITE_FLAG( pcVPS->getScalabilityMask( type ) ? 1 : 0,   "scalability_mask[i]" );
    814   }
    815 
    816   for( Int sIdx = 0; sIdx < pcVPS->getNumScalabilityTypes( ) - ( pcVPS->getSplittingFlag() ? 1 : 0 ); sIdx++ )
    817   {
    818     WRITE_CODE( pcVPS->getDimensionIdLen( sIdx ) - 1 , 3,    "dimension_id_len_minus1[j]");   
    819   }
    820 
    821   if ( pcVPS->getSplittingFlag() )
    822   { // Ignore old dimension id length
    823     pcVPS->setDimensionIdLen( pcVPS->getNumScalabilityTypes( ) - 1 ,pcVPS->inferLastDimsionIdLenMinus1() + 1 );       
    824   }   
    825 
    826 
    827   WRITE_FLAG( pcVPS->getVpsNuhLayerIdPresentFlag() ? 1 : 0,  "vps_nuh_layer_id_present_flag");
    828 
    829   for( Int i = 0; i <= pcVPS->getMaxLayers() - 1; i++ )
    830   {
    831     if ( pcVPS->getVpsNuhLayerIdPresentFlag() && ( i > 0 ) )
    832     {     
    833       WRITE_CODE( pcVPS->getLayerIdInNuh( i ), 6,          "layer_id_in_nuh[i]");
    834   }
    835     else
    836     {
    837       assert( pcVPS->getLayerIdInNuh( i ) == i );
    838   }
    839 
    840     assert(  pcVPS->getLayerIdInVps( pcVPS->getLayerIdInNuh( i ) ) == i );
    841 
    842     for( Int j = 0; j < pcVPS->getNumScalabilityTypes() ; j++ )
    843   {
    844       if ( !pcVPS->getSplittingFlag() )
    845     {
    846         WRITE_CODE( pcVPS->getDimensionId( i, j ), pcVPS->getDimensionIdLen( j ), "dimension_id[i][j]");     
    847       }
    848       else
    849       {
    850         assert( pcVPS->getDimensionId( i, j ) ==  pcVPS->inferDimensionId( i, j )  );
    851       }
    852     }
    853   }
    854 
    855   for( Int i = 1; i <= pcVPS->getMaxLayers() - 1; i++ )
    856   {
    857     for( Int j = 0; j < i; j++ )
    858     {
    859       WRITE_FLAG( pcVPS->getDirectDependencyFlag( i, j ),    "direct_dependency_flag[i][j]" );
    860     }
    861   }
    862 
    863   for( Int i = 0; i < pcVPS->getMaxLayers() - 1; i++ )
    864   {
    865     WRITE_CODE( pcVPS->getMaxTidIlRefPicPlus1( i ), 3,       "max_tid_il_ref_pics_plus1[i]" );
    866   }
    867 
    868   WRITE_CODE( pcVPS->getVpsNumberLayerSetsMinus1( )    , 10,    "vps_number_layer_sets_minus1"      );
    869   WRITE_CODE( pcVPS->getVpsNumProfileTierLevelMinus1( ), 6,     "vps_num_profile_tier_level_minus1" );
    870 
    871   for( Int i = 1; i <= pcVPS->getVpsNumProfileTierLevelMinus1(); i++ )
    872   {
    873     WRITE_FLAG( pcVPS->getVpsProfilePresentFlag( i ) ? 1 : 0, "vps_profile_present_flag[i]" );
    874     if( !pcVPS->getVpsProfilePresentFlag( i ) )
    875     {   
    876       WRITE_CODE( pcVPS->getProfileRefMinus1( i ), 6, "profile_ref_minus1[i]" );
    877     }
    878     codePTL( pcVPS->getPTL( i ), pcVPS->getVpsProfilePresentFlag( i ), pcVPS->getMaxTLayers() - 1 );
    879   }
    880 
    881   Int numOutputLayerSets = pcVPS->getVpsNumberLayerSetsMinus1( ) + 1;
    882 
    883   WRITE_FLAG( pcVPS->getMoreOutputLayerSetsThanDefaultFlag( ) ? 1 : 0, "more_output_layer_sets_than_default_flag" );
    884 
    885   if ( pcVPS->getMoreOutputLayerSetsThanDefaultFlag( ) )
    886   {
    887     WRITE_CODE( pcVPS->getNumAddOutputLayerSetsMinus1( )    , 10,    "num_add_output_layer_sets_minus1"      );
    888     numOutputLayerSets += ( pcVPS->getNumAddOutputLayerSetsMinus1( ) + 1 );
    889   }
    890 
    891   if( numOutputLayerSets > 1)
    892   {
    893     WRITE_FLAG( pcVPS->getDefaultOneTargetOutputLayerFlag( ) ? 1 : 0, "default_one_target_output_layer_flag" );
    894   } 
    895 
    896   for( Int i = 1; i < numOutputLayerSets; i++ )
    897   {
    898     if( i > pcVPS->getVpsNumberLayerSetsMinus1( ) )
    899     {     
    900       WRITE_UVLC( pcVPS->getOutputLayerSetIdxMinus1( i ),      "output_layer_set_idx_minus1[i]" );
    901       for( Int j = 0; j < pcVPS->getNumLayersInIdList( j ) - 1 ; j++ )
    902       {
    903         WRITE_FLAG( pcVPS->getOutputLayerFlag( i, j) ? 1 : 0, "output_layer_flag" );
    904       }     
    905     }
    906     if ( pcVPS->getProfileLevelTierIdxLen()  > 0 )
    907     {     
    908       WRITE_CODE( pcVPS->getProfileLevelTierIdx( i ), pcVPS->getProfileLevelTierIdxLen() ,"profile_level_tier_idx[ i ]" );   
    909     }
    910   }
    911 
    912   WRITE_FLAG( pcVPS->getMaxOneActiveRefLayerFlag( ) ? 1 : 0, "max_one_active_ref_layer_flag" );
    913   WRITE_UVLC( pcVPS->getDirectDepTypeLenMinus2 ( ),         "direct_dep_type_len_minus2");
    914 
    915     for( Int i = 1; i <= pcVPS->getMaxLayers() - 1; i++ )
    916     {
    917       for( Int j = 0; j < i; j++ )
    918       {
    919         if (pcVPS->getDirectDependencyFlag( i, j) )
    920         {       
    921           assert ( pcVPS->getDirectDependencyType( i, j ) != -1 );
    922           WRITE_CODE( pcVPS->getDirectDependencyType( i, j ),pcVPS->getDirectDepTypeLenMinus2( ) + 2,  "direct_dependency_type[i][j]" );
    923         }
    924       }
    925     }
    926 
    927     WRITE_FLAG ( 0,                    "vps_shvc_reserved_zero_flag" );
    928 
    929 #if H_3D
    930   WRITE_FLAG( 1,                                             "vps_extension2_flag" );
    931   m_pcBitIf->writeAlignOne();     
    932   for( Int i = 0; i <= pcVPS->getMaxLayers() - 1; i++ )
    933   {
    934     if (i!= 0)
    935     {
    936       if ( !( pcVPS->getDepthId( i ) == 1 ) )
    937       {
    938 #if H_3D_IV_MERGE
    939         WRITE_FLAG( pcVPS->getIvMvPredFlag         ( i ) ? 1 : 0 , "iv_mv_pred_flag[i]");
    940 #endif
    941 #if H_3D_ARP
    942         WRITE_FLAG( pcVPS->getUseAdvRP             ( i ) ? 1 : 0,  "iv_res_pred_flag[i]"  );
    943 #endif
    944 #if H_3D_NBDV_REF
    945         WRITE_FLAG( pcVPS->getDepthRefinementFlag  ( i ) ? 1 : 0 , "depth_refinement_flag[i]");
    946 #endif
    947 #if H_3D_VSP
    948         WRITE_FLAG( pcVPS->getViewSynthesisPredFlag( i ) ? 1 : 0 , "view_synthesis_pred_flag[i]");
    949 #endif
    950       }         
    951       else
    952       {
    953         WRITE_FLAG( pcVPS->getVpsDepthModesFlag( i ) ? 1 : 0 ,          "vps_depth_modes_flag[i]" );
    954         //WRITE_FLAG( pcVPS->getLimQtPredFlag    ( i ) ? 1 : 0 ,          "lim_qt_pred_flag[i]"     );
    955 #if H_3D_DIM_DLT
    956         if( pcVPS->getVpsDepthModesFlag( i ) )
    957         {
    958           WRITE_FLAG( pcVPS->getUseDLTFlag( i ) ? 1 : 0, "dlt_flag[i]" );
    959         }
    960         if( pcVPS->getUseDLTFlag( i ) )
    961         {
    962           // code mapping
    963           WRITE_UVLC(pcVPS->getNumDepthValues(i), "num_depth_values_in_dlt[i]");
    964           for(Int d=0; d<pcVPS->getNumDepthValues(i); d++)
    965           {
    966             WRITE_UVLC( pcVPS->idx2DepthValue(i, d), "dlt_depth_value[i][d]" );
    967           }
    968         }       
    969 #endif
    970 #if H_3D_INTER_SDC
    971         WRITE_FLAG( pcVPS->getInterSDCFlag( i ) ? 1 : 0, "depth_inter_SDC_flag" );
    972 #endif
    973       }
    974     } 
    975   }
    976   WRITE_FLAG( pcVPS->getIvMvScalingFlag( ) ? 1 : 0 ,          "iv_mv_scaling_flag" );
    977 #else
    978   WRITE_FLAG( 0,                                             "vps_extension2_flag" );
    979 #endif
    980 #else
    981   WRITE_FLAG( 0,                     "vps_extension_flag" );
    982 #endif
    983  
    984   //future extensions here..
    985  
    986   return;
    987 }
    988 #else
    989716#if H_MV
    990717  WRITE_FLAG( 1,                     "vps_extension_flag" );
     
    1005732}
    1006733
    1007 #endif
    1008 
    1009 
    1010 #if H_MV5
     734
     735
    1011736#if H_MV
    1012737Void TEncCavlc::codeVPSExtension( TComVPS *pcVPS )
     
    13201045}
    13211046#endif
    1322 #endif
    13231047
    13241048Void TEncCavlc::codeSliceHeader         ( TComSlice* pcSlice )
     
    13701094  {
    13711095#if H_MV   
    1372 #if H_MV5
    13731096    Int esb = 0;  //Don't use i, otherwise will shadow something below
    13741097    if ( pcSlice->getPPS()->getNumExtraSliceHeaderBits() > esb )
     
    13851108
    13861109    for (; esb < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); esb++)   
    1387 #else
    1388     if ( pcSlice->getPPS()->getNumExtraSliceHeaderBits() > 0 )
    1389     {
    1390       WRITE_FLAG( pcSlice->getDiscardableFlag( ) ? 1 : 0 , "discardable_flag" );
    1391     }
    1392 
    1393     for (Int i = 1; i < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)   
    1394 #endif
    13951110#else
    13961111    for (Int i = 0; i < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
     
    15301245    }
    15311246#if H_MV
    1532 #if H_MV5
    15331247    Int layerId = pcSlice->getLayerId();
    15341248    if( pcSlice->getLayerId() > 0 && !vps->getAllRefLayersActiveFlag() && vps->getNumDirectRefLayers( layerId ) > 0 )
     
    15501264      } 
    15511265    }
    1552 #else
    1553     Int layerIdInVps       = pcSlice->getLayerIdInVps();
    1554     if( pcSlice->getLayerId() > 0 && vps->getNumDirectRefLayers( layerIdInVps ) > 0 )
    1555     {   
    1556       WRITE_FLAG( pcSlice->getInterLayerPredEnabledFlag( ) ? 1 : 0 , "inter_layer_pred_enabled_flag" );
    1557       if( pcSlice->getInterLayerPredEnabledFlag() && vps->getNumDirectRefLayers( layerIdInVps ) > 1 )
    1558       {           
    1559         if( !vps->getMaxOneActiveRefLayerFlag()) 
    1560         {
    1561           WRITE_CODE( pcSlice->getNumInterLayerRefPicsMinus1( ), pcSlice->getNumInterLayerRefPicsMinus1Len( ), "num_inter_layer_ref_pics_minus1" );
    1562         }
    1563         for( Int i = 0; i < pcSlice->getNumActiveRefLayerPics(); i++ )   
    1564         {
    1565           WRITE_CODE( pcSlice->getInterLayerPredLayerIdc( i ), pcSlice->getInterLayerPredLayerIdcLen( ), "inter_layer_pred_layer_idc" );
    1566         }
    1567       } 
    1568     }
    1569 
    1570     if( vps->getNumSamplePredRefLayers( layerIdInVps ) > 0  &&  pcSlice->getNumActiveRefLayerPics() > 0 )
    1571     {
    1572       WRITE_FLAG( pcSlice->getInterLayerSamplePredOnlyFlag( ) ? 1 : 0 , "inter_layer_sample_pred_only_flag" );
    1573     }
    1574 
    1575 #endif
    15761266#endif
    15771267    if(pcSlice->getSPS()->getUseSAO())
     
    16781368    if ( pcSlice->getEnableTMVPFlag() )
    16791369    {
    1680 #if !H_MV5
    1681 #if H_MV
    1682       if( pcSlice->getLayerId() > 0 && pcSlice->getNumActiveMotionPredRefLayers() > 0 )
    1683       {
    1684         WRITE_FLAG( pcSlice->getAltCollocatedIndicationFlag( ) ? 1 : 0 , "alt_collocated_indication_flag" );
    1685       }
    1686       if( pcSlice->getAltCollocatedIndicationFlag() && pcSlice->getNumActiveMotionPredRefLayers() > 1 )
    1687       {         
    1688         WRITE_UVLC( pcSlice->getCollocatedRefLayerIdx( ), "collocated_ref_layer_idx" );
    1689       }     
    1690       else
    1691       {
    1692 #endif
    1693 #endif
    16941370      if ( pcSlice->getSliceType() == B_SLICE )
    16951371      {
     
    17041380      }
    17051381    }
    1706 #if !H_MV5
    1707 #if H_MV
    1708     }
    1709 #endif
    1710 #endif
    17111382    if ( (pcSlice->getPPS()->getUseWP() && pcSlice->getSliceType()==P_SLICE) || (pcSlice->getPPS()->getWPBiPred() && pcSlice->getSliceType()==B_SLICE) )
    17121383    {
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibEncoder/TEncCavlc.h

    r646 r648  
    8484  UInt  getCoeffCost          ()                { return  m_uiCoeffCost;  }
    8585  Void  codeVPS                 ( TComVPS* pcVPS );
    86 #if H_MV5
    8786#if H_MV
    8887  Void  codeVPSExtension       ( TComVPS *pcVPS );
     
    9089  Void  codeVPSVUI             ( TComVPS* pcVPS );
    9190#endif
    92 #endif
    9391  Void  codeVUI                 ( TComVUI *pcVUI, TComSPS* pcSPS );
    94 #if H_MV5
    9592#if H_MV
    9693  Void  codeSPSExtension        ( TComSPS* pcSPS );
    9794#endif
    98 #endif
    9995#if H_3D
    100 #if H_MV5
    10196  Void  codeVPSExtension2       ( TComVPS* pcVPS );
    10297  Void  codeSPSExtension2       ( TComSPS* pcSPS, Int viewIndex, Bool depthFlag  );
    103 #endif
    10498  Void  codeSPS                 ( TComSPS* pcSPS, Int viewIndex, Bool depthFlag );
    10599#else
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibEncoder/TEncCfg.h

    r646 r648  
    7777  Int m_interLayerPredLayerIdc [MAX_NUM_REF_PICS];
    7878  Int m_interViewRefPosL[2][MAX_NUM_REF_PICS]; 
    79 #if !H_MV5
    80   Int m_collocatedRefLayerIdx;
    81 #endif
    8279#endif
    8380  GOPEntry()
     
    9794#if H_MV
    9895  , m_numActiveRefLayerPics(0)
    99 #if !H_MV5
    100   , m_collocatedRefLayerIdx(-1)
    101 #endif
    10296#endif
    10397  {
     
    375369  Int       m_layerIdInVps;
    376370  Int       m_viewId;
    377 #if H_MV5
    378371  Int       m_viewIndex;
    379 #endif
    380372#endif
    381373
    382374#if H_3D
    383 #if !H_MV5
    384   Int       m_viewIndex;
    385 #endif
    386375  Bool      m_isDepth;
    387376
     
    440429  , m_layerIdInVps(-1)
    441430  , m_viewId(-1)
    442 #if H_MV5
    443431  , m_viewIndex(-1)
    444 #endif
    445432#if H_3D
    446 #if !H_MV5
    447   , m_viewIndex(-1)
    448 #endif
    449433  , m_isDepth(false)
    450434  , m_bUseVSO(false)
     
    479463  Void      setViewId                        ( Int viewId  )      { m_viewId  = viewId;  }
    480464  Int       getViewId                        ()                   { return m_viewId;    }
    481 #if H_MV5
    482465  Void      setViewIndex                     ( Int viewIndex  )   { m_viewIndex  = viewIndex;  }
    483466  Int       getViewIndex                     ()                   { return m_viewIndex;    }
    484 #endif
    485467#if H_3D
    486 #if !H_MV5
    487   Void      setViewIndex                     ( Int viewIndex  )   { m_viewIndex  = viewIndex;  }
    488   Int       getViewIndex                     ()                   { return m_viewIndex;    }
    489 #endif
    490468  Void      setIsDepth                       ( Bool isDepth )   { m_isDepth = isDepth; }
    491469  Bool      getIsDepth                       ()                 { return m_isDepth; }
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibEncoder/TEncGOP.cpp

    r647 r648  
    476476
    477477
    478 #if H_MV5
    479478#if H_MV
    480479    m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, pocCurr, iNumPicRcvd, iGOPid, pcSlice, m_pcEncTop->getVPS(), m_pcEncTop->getSPS(), m_pcEncTop->getPPS(), getLayerId() );     
    481480#else
    482481    m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, pocCurr, iNumPicRcvd, iGOPid, pcSlice, m_pcEncTop->getSPS(), m_pcEncTop->getPPS() );
    483 #endif
    484 #else
    485 #if H_3D
    486     m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, pocCurr, iNumPicRcvd, iGOPid, pcSlice, m_pcEncTop->getVPS(), m_pcEncTop->getSPS(), m_pcEncTop->getPPS(), getLayerId() );     
    487 #else
    488     m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, pocCurr, iNumPicRcvd, iGOPid, pcSlice, m_pcEncTop->getSPS(), m_pcEncTop->getPPS() );
    489 #endif
    490482#endif
    491483    pcSlice->setLastIDR(m_iLastIDR);
    492484    pcSlice->setSliceIdx(0);
    493485#if H_MV
    494 #if H_MV5
    495486    pcSlice->setRefPicSetInterLayer ( &m_refPicSetInterLayer0, &m_refPicSetInterLayer1 );
    496 #else
    497     pcSlice->setRefPicSetInterLayer ( &m_refPicSetInterLayer );
    498 #endif
    499487    pcPic  ->setLayerId     ( getLayerId()   );
    500488    pcPic  ->setViewId      ( getViewId()    );   
     
    659647    refPicListModification->setRefPicListModificationFlagL1(0);
    660648#if H_MV
    661 #if H_MV5
    662649    if ( pcSlice->getPPS()->getNumExtraSliceHeaderBits() > 1 )
    663650    {
     
    703690    xSetRefPicListModificationsMv( tempRefPicLists, pcSlice, iGOPid );   
    704691#else
    705     if ( pcSlice->getPPS()->getNumExtraSliceHeaderBits() > 0 )
    706     {
    707       pcSlice->setDiscardableFlag           ( false );     
    708     }   
    709 
    710     TComVPS*           vps = pcSlice->getVPS();
    711     Int       layerIdInVps = vps    ->getLayerIdInVps( getLayerId());
    712     Int numDirectRefLayers = vps    ->getNumDirectRefLayers( layerIdInVps );
    713     GOPEntry gopEntry      = m_pcCfg->getGOPEntry( (pcSlice->getRapPicFlag() && getLayerId() > 0) ? MAX_GOP : iGOPid );     
    714    
    715     if ( getLayerId() > 0 && numDirectRefLayers > 0 )
    716     {         
    717       pcSlice->setInterLayerPredEnabledFlag ( gopEntry.m_numActiveRefLayerPics > 0 );     
    718       if ( pcSlice->getInterLayerPredEnabledFlag() && numDirectRefLayers > 1 )
    719       {
    720         if ( !vps->getMaxOneActiveRefLayerFlag() )
    721         {   
    722           pcSlice->setNumInterLayerRefPicsMinus1( gopEntry.m_numActiveRefLayerPics - 1 );
    723         }
    724         for (Int i = 0; i < gopEntry.m_numActiveRefLayerPics; i++ )
    725         {
    726           pcSlice->setInterLayerPredLayerIdc( i, gopEntry.m_interLayerPredLayerIdc[ i ] );
    727         }
    728       }
    729     }
    730     assert( pcSlice->getNumActiveRefLayerPics() == gopEntry.m_numActiveRefLayerPics );
    731    
    732     if ( vps->getNumSamplePredRefLayers( layerIdInVps ) > 0 && pcSlice->getNumActiveRefLayerPics() > 0)
    733     {
    734       pcSlice->setInterLayerSamplePredOnlyFlag( gopEntry.m_numRefPics == 0 );
    735     }   
    736 
    737     pcSlice->createAndApplyIvReferencePictureSet( m_ivPicLists, m_refPicSetInterLayer );
    738     pcSlice->setNumRefIdx(REF_PIC_LIST_0,min(gopEntry.m_numRefPicsActive,( pcSlice->getRPS()->getNumberOfPictures() + (Int) m_refPicSetInterLayer.size() ) ) );
    739     pcSlice->setNumRefIdx(REF_PIC_LIST_1,min(gopEntry.m_numRefPicsActive,( pcSlice->getRPS()->getNumberOfPictures() + (Int) m_refPicSetInterLayer.size() ) ) );
    740 
    741     xSetRefPicListModificationsMv( pcSlice, iGOPid );   
    742 
    743     pcSlice->setActiveMotionPredRefLayers( );
    744 
    745     if ( getLayerId() > 0 && pcSlice->getNumActiveMotionPredRefLayers() > 0 && pcSlice->getEnableTMVPFlag() &&
    746         ( pcSlice->getSliceType() == B_SLICE || pcSlice->getSliceType() == P_SLICE ))
    747     {
    748       pcSlice->setAltCollocatedIndicationFlag( gopEntry.m_collocatedRefLayerIdx >= 0 );
    749       if ( pcSlice->getNumActiveRefLayerPics() && pcSlice->getNumActiveMotionPredRefLayers() > 0 )
    750       {
    751         pcSlice->setCollocatedRefLayerIdx( gopEntry.m_collocatedRefLayerIdx );
    752       }
    753     }
    754 
    755 #endif
    756 #else
    757692    pcSlice->setNumRefIdx(REF_PIC_LIST_0,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
    758693    pcSlice->setNumRefIdx(REF_PIC_LIST_1,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
     
    764699
    765700    //  Set reference list
    766 #if H_MV5
    767701#if H_MV   
    768702    pcSlice->setRefPicList( tempRefPicLists, usedAsLongTerm, numPocTotalCurr );
     
    786720      }
    787721    }
    788 #endif
    789 #else
    790 #if H_MV   
    791     pcSlice->setRefPicList( rcListPic, m_refPicSetInterLayer );
    792 #if H_3D_ARP
    793     pcSlice->setARPStepNum();
    794     if(pcSlice->getARPStepNum() > 1)
    795     {
    796       for(Int iLayerId = 0; iLayerId < getLayerId(); iLayerId ++ )
    797       {
    798         Int  iViewIdx =   pcSlice->getVPS()->getViewIndex(iLayerId);
    799         Bool bIsDepth = ( pcSlice->getVPS()->getDepthId  ( iLayerId ) == 1 );
    800         if( iViewIdx<getViewIndex() && !bIsDepth )
    801         {
    802           pcSlice->setBaseViewRefPicList( m_ivPicLists->getPicList( iLayerId ), iViewIdx );
    803         }
    804       }
    805     }
    806 #endif
    807 #else
    808     pcSlice->setRefPicList ( rcListPic );
    809 #endif
    810722#endif
    811723#if H_3D
     
    21982110      pcPic->setReconMark   ( true );
    21992111#if H_MV
    2200 #if H_MV5
    22012112      TComSlice::markIvRefPicsAsShortTerm( m_refPicSetInterLayer0, m_refPicSetInterLayer1 ); 
    2202 #else
    2203       TComSlice::markIvRefPicsAsShortTerm( m_refPicSetInterLayer ); 
    2204 #endif
    22052113      std::vector<Int> temp;
    22062114      TComSlice::markCurrPic( pcPic );
     
    30342942
    30352943#if H_MV
    3036 #if H_MV5
    30372944Void TEncGOP::xSetRefPicListModificationsMv( std::vector<TComPic*> tempPicLists[2], TComSlice* pcSlice, UInt iGOPid )
    30382945{
     
    31183025  }
    31193026}
    3120 #else
    3121 Void TEncGOP::xSetRefPicListModificationsMv( TComSlice* pcSlice, UInt iGOPid )
    3122 {
    3123   Int layer    = pcSlice->getLayerIdInVps( );
    3124  
    3125   if( pcSlice->getSliceType() == I_SLICE || !(pcSlice->getPPS()->getListsModificationPresentFlag()) || pcSlice->getNumActiveRefLayerPics() == 0 )
    3126   {
    3127     return;
    3128   }
    3129 
    3130   // analyze inter-view modifications
    3131   GOPEntry ge = m_pcCfg->getGOPEntry( (pcSlice->getRapPicFlag() && ( layer > 0) ) ? MAX_GOP : iGOPid );
    3132   assert( ge.m_numActiveRefLayerPics == pcSlice->getNumActiveRefLayerPics() );
    3133  
    3134   Int maxRefListSize  = pcSlice->getNumRpsCurrTempList();
    3135   Int numTemporalRefs = maxRefListSize - pcSlice->getNumActiveRefLayerPics();
    3136 
    3137   for (Int li = 0; li < 2; li ++) // Loop over lists L0 and L1
    3138   {
    3139     // set inter-view modifications   
    3140     Int tempList[16];
    3141     for( Int k = 0; k < 16; k++ )
    3142     {
    3143       tempList[ k ] = -1;
    3144     }
    3145 
    3146     Bool isModified = false;
    3147     if ( maxRefListSize > 1 )
    3148     {
    3149       for( Int k = 0, orgIdx = numTemporalRefs; k < ge.m_numActiveRefLayerPics; k++, orgIdx++ )
    3150       {
    3151           Int targetIdx = ge.m_interViewRefPosL[ li ][ k ];
    3152 
    3153         isModified = ( targetIdx != orgIdx ) && ( targetIdx >= 0  );
    3154         if ( isModified )
    3155             {
    3156           assert( tempList[ targetIdx ] == -1 ); // Assert when two inter layer reference pictures are sorted to the same position
    3157               tempList[ targetIdx ] = orgIdx;             
    3158         }
    3159       }
    3160     }
    3161 
    3162     TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
    3163     refPicListModification->setRefPicListModificationFlagL( li, isModified ); 
    3164 
    3165       if( isModified )
    3166       {
    3167         Int temporalRefIdx = 0;
    3168         for( Int i = 0; i < pcSlice->getNumRefIdx( ( li == 0 ) ? REF_PIC_LIST_0 : REF_PIC_LIST_1 ); i++ )
    3169         {
    3170           if( tempList[i] >= 0 )
    3171           {
    3172             refPicListModification->setRefPicSetIdxL( li, i, tempList[i] );
    3173           }
    3174           else
    3175           {
    3176             refPicListModification->setRefPicSetIdxL( li, i, temporalRefIdx );
    3177             temporalRefIdx++;
    3178           }
    3179         }
    3180       }
    3181   }
    3182 }
    3183 #endif
    31843027#endif
    31853028//! \}
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibEncoder/TEncGOP.h

    r635 r648  
    102102#if H_MV
    103103  TComPicLists*           m_ivPicLists;
    104 #if H_MV5
    105104  std::vector<TComPic*>   m_refPicSetInterLayer0;
    106105  std::vector<TComPic*>   m_refPicSetInterLayer1;
    107 #else
    108   std::vector<TComPic*>   m_refPicSetInterLayer;
    109 #endif
    110106
    111107  Int                     m_pocLastCoded;
     
    223219  }
    224220#if H_MV
    225 #if H_MV5
    226221   Void  xSetRefPicListModificationsMv( std::vector<TComPic*> tempPicLists[2], TComSlice* pcSlice, UInt iGOPid );
    227 #else
    228    Void  xSetRefPicListModificationsMv( TComSlice* pcSlice, UInt iGOPid );
    229 #endif
    230222#endif
    231223  Void dblMetric( TComPic* pcPic, UInt uiNumSlices );
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibEncoder/TEncSlice.cpp

    r638 r648  
    187187 \param pPPS          PPS associated with the slice
    188188 */
    189 #if H_MV5
    190189#if H_MV
    191190Void TEncSlice::initEncSlice( TComPic* pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd, Int iGOPid, TComSlice*& rpcSlice, TComVPS* pVPS, TComSPS* pSPS, TComPPS *pPPS, Int layerId )
    192191#else
    193192Void TEncSlice::initEncSlice( TComPic* pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd, Int iGOPid, TComSlice*& rpcSlice, TComSPS* pSPS, TComPPS *pPPS )
    194 #endif
    195 #else
    196 #if H_3D
    197 Void TEncSlice::initEncSlice( TComPic* pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd, Int iGOPid, TComSlice*& rpcSlice, TComVPS* pVPS, TComSPS* pSPS, TComPPS *pPPS, Int layerId )
    198 #else
    199 Void TEncSlice::initEncSlice( TComPic* pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd, Int iGOPid, TComSlice*& rpcSlice, TComSPS* pSPS, TComPPS *pPPS )
    200 #endif
    201193#endif
    202194{
     
    206198  rpcSlice = pcPic->getSlice(0);
    207199
    208 #if H_MV5
    209200  rpcSlice->setVPS( pVPS );
    210201
     
    214205#if H_3D
    215206  rpcSlice->setIsDepth     ( pVPS->getDepthId     ( layerId ) != 0 );   
    216 #endif
    217 #else
    218 #if H_3D
    219   // GT: Should also be activated for MV-HEVC at some stage
    220   rpcSlice->setVPS( pVPS );
    221   Int vpsLayerId = pVPS->getLayerIdInNuh( layerId );
    222 
    223   rpcSlice->setLayerId     ( layerId );
    224   rpcSlice->setViewId      ( pVPS->getViewId      ( vpsLayerId ) );   
    225   rpcSlice->setViewIndex   ( pVPS->getViewIndex   ( vpsLayerId ) );
    226   rpcSlice->setIsDepth     ( pVPS->getDepthId     ( vpsLayerId ) != 0 );   
    227 #endif
    228207#endif
    229208  rpcSlice->setSPS( pSPS );
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibEncoder/TEncSlice.h

    r622 r648  
    116116 
    117117  /// preparation of slice encoding (reference marking, QP and lambda)
    118 #if H_MV5
    119118#if H_MV
    120119  Void    initEncSlice        ( TComPic* pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd,
     
    123122  Void    initEncSlice        ( TComPic*  pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd,
    124123                                Int iGOPid,   TComSlice*& rpcSlice, TComSPS* pSPS, TComPPS *pPPS );
    125 #endif
    126 #else
    127 #if H_3D
    128   Void    initEncSlice        ( TComPic* pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd,
    129                                 Int iGOPid, TComSlice*& rpcSlice, TComVPS* pVPS, TComSPS* pSPS, TComPPS *pPPS, Int layerId );
    130 #else
    131   Void    initEncSlice        ( TComPic*  pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd,
    132                                 Int iGOPid,   TComSlice*& rpcSlice, TComSPS* pSPS, TComPPS *pPPS );
    133 #endif
    134124#endif
    135125#if RATE_CONTROL_LAMBDA_DOMAIN
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibEncoder/TEncTop.cpp

    r646 r648  
    562562   * that chooses the actual compatibility based upon options */
    563563
    564 #if H_MV5
    565564#if H_MV 
    566565  m_cSPS.setUpdateRepFormatFlag           ( m_layerId == 0 );   
    567566  m_cSPS.setSpsInferScalingListFlag       ( m_layerId > 0 && m_cVPS->getInDirectDependencyFlag( getLayerIdInVps(), 0 ) );
    568567  m_cSPS.setSpsScalingListRefLayerId      ( 0              );
    569 #endif
    570568#endif
    571569  m_cSPS.setPicWidthInLumaSamples         ( m_iSourceWidth      );
     
    691689{
    692690#if H_MV
    693 #if H_MV5
    694691  m_cPPS.setLayerId( getLayerId() );
    695692  if( getVPS()->getNumDirectRefLayers( getLayerId() ) > 0 )
    696 #else
    697   if( getVPS()->getNumDirectRefLayers( getLayerIdInVps() ) > 0 )
    698 #endif
    699693  {
    700694    m_cPPS.setListsModificationPresentFlag( true );
     
    770764  m_cPPS.setOutputFlagPresentFlag( false );
    771765#if H_MV
    772 #if H_MV5
    773766  m_cPPS.setNumExtraSliceHeaderBits( 2 );
    774 #else
    775   m_cPPS.setNumExtraSliceHeaderBits( 1 );
    776 #endif
    777767#endif
    778768  m_cPPS.setSignHideFlag(getSignHideFlag());
  • branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibExtractor/TExtrTop.cpp

    r622 r648  
    100100Void TExtrTop::dumpVpsInfo( std::ostream& rcVpsInfoHandle )
    101101{
    102 #if H_MV5
    103102  rcVpsInfoHandle << "MaxLayers      = " << m_cVPS.getMaxLayersMinus1() + 1 << std::endl;
    104103  rcVpsInfoHandle << "MaxNuhLayerId  = " << m_cVPS.getVpsMaxLayerId() << std::endl;                     
     
    114113#endif
    115114    rcVpsInfoHandle << "ViewId         = " << m_cVPS.getViewId        ( layerId ) << std::endl;     
    116 #else
    117   rcVpsInfoHandle << "MaxLayers = "     << m_cVPS.getMaxLayers()     << std::endl;
    118   rcVpsInfoHandle << "MaxNuhLayerId = " << m_cVPS.getVpsMaxLayerId() << std::endl;
    119  
    120   for ( Int layerIdxInVps = 0; layerIdxInVps < m_cVPS.getMaxLayers(); layerIdxInVps++ )
    121   { 
    122     rcVpsInfoHandle << "LayerIdxInVps =  " << layerIdxInVps                           << std::endl;
    123     rcVpsInfoHandle << "LayerIdInNuh = "   << m_cVPS.getLayerIdInNuh( layerIdxInVps ) << std::endl;
    124     rcVpsInfoHandle << "ViewId = "         << m_cVPS.getViewId      ( layerIdxInVps ) << std::endl;
    125 #if H_3D
    126     rcVpsInfoHandle << "DepthFlag = "      << m_cVPS.getViewIndex   ( layerIdxInVps ) << std::endl;     
    127     rcVpsInfoHandle << "DepthFlag = "      << m_cVPS.getDepthId     ( layerIdxInVps ) << std::endl;     
    128 #endif
    129 #endif
    130115  }
    131116}
Note: See TracChangeset for help on using the changeset viewer.