Changeset 1066 in 3DVCSoftware for trunk/source

Timestamp:

13 Oct 2014, 12:19:36 (10 years ago)

Author:

tech

Message:

Merged 12.0-dev1@1065.

Location:

trunk/source

Files:

• App/TAppDecoder/TAppDecCfg.cpp (modified) (1 diff)
• App/TAppDecoder/TAppDecCfg.h (modified) (1 diff)
• App/TAppDecoder/TAppDecTop.cpp (modified) (3 diffs)
• App/TAppEncoder/TAppEncCfg.cpp (modified) (24 diffs)
• App/TAppEncoder/TAppEncCfg.h (modified) (6 diffs)
• App/TAppEncoder/TAppEncTop.cpp (modified) (32 diffs)
• App/TAppEncoder/TAppEncTop.h (modified) (2 diffs)
• Lib/TLibCommon/TComDataCU.cpp (modified) (2 diffs)
• Lib/TLibCommon/TComRom.cpp (modified) (3 diffs)
• Lib/TLibCommon/TComRom.h (modified) (2 diffs)
• Lib/TLibCommon/TComSlice.cpp (modified) (44 diffs)
• Lib/TLibCommon/TComSlice.h (modified) (39 diffs)
• Lib/TLibCommon/TypeDef.h (modified) (10 diffs)
• Lib/TLibDecoder/TDecCAVLC.cpp (modified) (54 diffs)
• Lib/TLibDecoder/TDecCAVLC.h (modified) (1 diff)
• Lib/TLibDecoder/TDecCu.cpp (modified) (1 diff)
• Lib/TLibDecoder/TDecSbac.cpp (modified) (2 diffs)
• Lib/TLibDecoder/TDecTop.cpp (modified) (8 diffs)
• Lib/TLibEncoder/TEncCavlc.cpp (modified) (42 diffs)
• Lib/TLibEncoder/TEncCavlc.h (modified) (1 diff)
• Lib/TLibEncoder/TEncCu.cpp (modified) (2 diffs)
• Lib/TLibEncoder/TEncEntropy.cpp (modified) (2 diffs)
• Lib/TLibEncoder/TEncGOP.cpp (modified) (2 diffs)
• Lib/TLibEncoder/TEncGOP.h (modified) (1 diff)
• Lib/TLibEncoder/TEncSbac.cpp (modified) (2 diffs)
• Lib/TLibEncoder/TEncSearch.cpp (modified) (2 diffs)
• Lib/TLibEncoder/TEncTop.cpp (modified) (10 diffs)
• Lib/TLibEncoder/TEncTop.h (modified) (4 diffs)

trunk/source/App/TAppDecoder/TAppDecCfg.cpp

@@ -94 +94 @@
   ("TarDecLayerIdSetFile,l", cfg_TargetDecLayerIdSetFile, string(""), "targetDecLayerIdSet file name. The file should include white space separated LayerId values to be decoded. Omitting the option or a value of -1 in the file decodes all layers.")
   ("RespectDefDispWindow,w", m_respectDefDispWindow, 0, "Only output content inside the default display window\n")
+#if H_MV
+#if H_MV_HLS10_GEN_FIX
+  ("OutputVpsInfo,v", m_outputVpsInfo, false, "Output information about the layer dependencies and layer sets")
+#endif
+#endif
   ;
   po::setDefaults(opts);

trunk/source/App/TAppDecoder/TAppDecCfg.h

@@ -80 +80 @@
 
 #if H_MV
+#if H_MV_HLS10_GEN_FIX
+  Bool          m_outputVpsInfo;                     ///< Output VPS information 
+#endif
   Void xAppendToFileNameEnd( Char* pchInputFileName, const Char* pchStringToAppend, Char*& rpchOutputFileName); ///< create filenames
 #endif

trunk/source/App/TAppDecoder/TAppDecTop.cpp

@@ -239 +239 @@
           {
             TComVPS* vps = m_vps; 
-          if ( m_targetOptLayerSetIdx == -1 )
+            if ( m_targetOptLayerSetIdx == -1 )
+            {
+              // Not normative! Corresponds to specification by "External Means". (Should be set equal to 0, when no external means available. ) 
+              m_targetOptLayerSetIdx = vps->getVpsNumLayerSetsMinus1(); 
+            }
+
+            for (Int dI = 0; dI < m_numDecoders; dI++ )
+            {
+              m_tDecTop[decIdx]->setTargetOptLayerSetIdx( m_targetOptLayerSetIdx ); 
+            }
+
+            if ( m_targetOptLayerSetIdx < 0 || m_targetOptLayerSetIdx >= vps->getNumOutputLayerSets() )
+            {
+              fprintf(stderr, "\ntarget output layer set index must be in the range of 0 to %d, inclusive \n", vps->getNumOutputLayerSets() - 1 );            
+              exit(EXIT_FAILURE);
+            }
+            m_targetDecLayerIdSet = vps->getTargetDecLayerIdList( m_targetOptLayerSetIdx ); 
+          }
+#if H_MV_HLS10_GEN_FIX
+          if (m_outputVpsInfo )
           {
-            // Not normative! Corresponds to specification by "External Means". (Should be set equal to 0, when no external means available. ) 
-            m_targetOptLayerSetIdx = vps->getVpsNumLayerSetsMinus1(); 
+#if H_MV_HLS10_AUX
+            m_vps->printScalabilityId();
+#endif
+            m_vps->printLayerDependencies();
+            m_vps->printLayerSets();
+            m_vps->printPTL(); 
           }
-
-          for (Int dI = 0; dI < m_numDecoders; dI++ )
-          {
-            m_tDecTop[decIdx]->setTargetOptLayerSetIdx( m_targetOptLayerSetIdx ); 
-          }
-
-          if ( m_targetOptLayerSetIdx < 0 || m_targetOptLayerSetIdx >= vps->getNumOutputLayerSets() )
-          {
-            fprintf(stderr, "\ntarget output layer set index must be in the range of 0 to %d, inclusive \n", vps->getNumOutputLayerSets() - 1 );            
-            exit(EXIT_FAILURE);
-          }
-          m_targetDecLayerIdSet = vps->getTargetDecLayerIdList( m_targetOptLayerSetIdx ); 
-        }
-      }
+#endif
+        }
 #if H_3D
         if (nalu.m_nalUnitType == NAL_UNIT_VPS )
@@ -569 +580 @@
   Int dpbFullness = 0;
 #if H_MV
+#if H_MV_HLS10_ADD_LAYERSETS
+  TComSPS* activeSPS = m_tDecTop[ decIdx ]->getActiveSPS();
+#else
   // preliminary fix
   TComSPS* activeSPS = m_tDecTop[0]->getActiveSPS();
+#endif
 #else
   TComSPS* activeSPS = m_cTDecTop.getActiveSPS();
@@ -1140 +1155 @@
     Int curLayerId = m_tDecTop[dIdx]->getLayerId();
     Int curLayerIdxInVps = m_vps->getLayerIdInNuh( curLayerId  ); 
+#if H_MV_HLS10_REF_PRED_LAYERS
+    if ( m_vps->getDependencyFlag(optLayerIdxInVps, curLayerIdxInVps ) )
+#else
     if ( m_vps->getInDirectDependencyFlag(optLayerIdxInVps, curLayerIdxInVps ) )
+#endif
     {
       TComPic* curPic = m_ivPicLists.getPic( curLayerId, pocLastPic ); 

trunk/source/App/TAppEncoder/TAppEncCfg.cpp

@@ -241 +241 @@
   {"main-still-picture", Profile::MAINSTILLPICTURE},
 #if H_MV
+#if H_MV_HLS10_PTL
+  {"multiview-main", Profile::MULTIVIEWMAIN},
+#if H_3D
+  {"3d-main"       , Profile::MAIN3D},
+#endif
+
+#else
   {"main-stereo",    Profile::MAINSTEREO},
   {"main-multiview", Profile::MAINMULTIVIEW},
 #if H_3D
   {"main-3d"    , Profile::MAIN3D},
+#endif
 #endif
 #endif
@@ -333 +341 @@
 #if H_MV
   vector<Int>   cfg_dimensionLength; 
+#if H_MV_HLS10_PTL
+  string        cfg_profiles;
+  string        cfg_levels; 
+  string        cfg_tiers; 
+#endif
 #if H_3D 
   cfg_dimensionLength.push_back( 2  );  // depth
@@ -367 +380 @@
   ("NumberOfLayers",        m_numberOfLayers     , 1,                     "Number of layers")
 #if !H_3D
+#if H_MV_HLS10_AUX
+  ("ScalabilityMask",       m_scalabilityMask    , 2                    , "Scalability Mask: 2: Multiview, 8: Auxiliary, 10: Multiview + Auxiliary")    
+#else
   ("ScalabilityMask",       m_scalabilityMask    , 2                    , "Scalability Mask")    
+#endif
 #else
   ("ScalabilityMask",       m_scalabilityMask    , 3                    , "Scalability Mask, 1: Texture 3: Texture + Depth ")    
@@ -374 +391 @@
   ("ViewOrderIndex",        m_viewOrderIndex     , std::vector<Int>(1,0), "View Order Index per layer")
   ("ViewId",                m_viewId             , std::vector<Int>(1,0), "View Id per View Order Index")
+#if H_MV_HLS10_AUX
+  ("AuxId",                 m_auxId              , std::vector<Int>(1,0), "AuxId per layer")
+#endif
 #if H_3D
   ("DepthFlag",             m_depthFlag          , std::vector<Int>(1,0), "Depth Flag")
@@ -388 +408 @@
 #endif
 #endif
-  ("LayerIdInNuh",          m_layerIdInNuh       , std::vector<Int>(1,0), "LayerId in Nuh")
+#if H_MV_HLS10_GEN_FIX
+  ("TargetEncLayerIdList",  m_targetEncLayerIdList, std::vector<Int>(0,0), "LayerIds in Nuh to be encoded")  
+#endif
+  ("LayerIdInNuh",          m_layerIdInNuh       , std::vector<Int>(1,0), "LayerId in Nuh")  
   ("SplittingFlag",         m_splittingFlag      , false                , "Splitting Flag")    
 
@@ -394 +417 @@
   ("VpsNumLayerSets",       m_vpsNumLayerSets    , 1                    , "Number of layer sets")    
   ("LayerIdsInSet_%d",      m_layerIdsInSets     , std::vector<Int>(1,0), MAX_VPS_OP_SETS_PLUS1 ,"LayerIds of Layer set")  
+#if H_MV_HLS10_ADD_LAYERSETS
+  ("NumAddLayerSets"     , m_numAddLayerSets     , 0                                              , "NumAddLayerSets     ")
+  ("HighestLayerIdxPlus1_%d", m_highestLayerIdxPlus1, std::vector< Int  >(0,0)  ,MAX_VPS_NUM_ADD_LAYER_SETS, "HighestLayerIdxPlus1")
+#endif
   ("DefaultTargetOutputLayerIdc"     , m_defaultOutputLayerIdc     , 0, "Specifies output layers of layer sets, 0: output all layers, 1: output highest layer, 2: specified by LayerIdsInDefOutputLayerSet")
   ("OutputLayerSetIdx",     m_outputLayerSetIdx  , std::vector<Int>(0,0), "Indices of layer sets used as additional output layer sets")  
@@ -400 +427 @@
   ("LayerIdsInDefOutputLayerSet_%d", m_layerIdsInDefOutputLayerSet      , std::vector<Int>(0,0), MAX_VPS_OP_SETS_PLUS1, "Indices in VPS of output layers in layer set")  
   ("AltOutputLayerFlag",    m_altOutputLayerFlag , std::vector<Bool>(1,0), "Alt output layer flag")
+  
+#if H_MV_HLS10_PTL
+  ("ProfileTierLevelIdx_%d",  m_profileTierLevelIdx, std::vector<Int>(0), MAX_NUM_LAYERS, "Indices to profile level tier for ols")
+#else
   ("ProfileLevelTierIdx",   m_profileLevelTierIdx, std::vector<Int>(1,0), "Indices to profile level tier")
-  
+#endif
   // Layer dependencies
   ("DirectRefLayers_%d",    m_directRefLayers    , std::vector<Int>(0,0), MAX_NUM_LAYERS, "LayerIds of direct reference layers")
@@ -431 +462 @@
   
   // Profile and level
+#if H_MV_HLS10_PTL
+  ("Profile", cfg_profiles,   string(""),           "Profile in VpsProfileTierLevel (Indication only)")
+  ("Level",   cfg_levels ,    string(""),           "Level indication in VpsProfileTierLevel (Indication only)")
+  ("Tier",    cfg_tiers  ,    string(""),           "Tier indication in VpsProfileTierLevel (Indication only)")
+  ("InblFlag",m_inblFlag ,    std::vector<Bool>(0), "InblFlags in VpsProfileTierLevel (Indication only)" )
+#else
   ("Profile", m_profile,   Profile::NONE, "Profile to be used when encoding (Incomplete)")
   ("Level",   m_level,     Level::NONE,   "Level limit to be used, eg 5.1 (Incomplete)")
   ("Tier",    m_levelTier, Level::MAIN,   "Tier to use for interpretation of --Level")
-
+#endif
   ("ProgressiveSource", m_progressiveSourceFlag, false, "Indicate that source is progressive")
   ("InterlacedSource",  m_interlacedSourceFlag,  false, "Indicate that source is interlaced")
@@ -613 +650 @@
 #endif
 #if H_MV
-
+#if H_MV_HLS10_GEN_FIX
+// A lot of this stuff could should actually be derived by the encoder.
+#endif // H_MV_HLS10_GEN
   // VPS VUI
   ("VpsVuiPresentFlag"           , m_vpsVuiPresentFlag           , false                                           , "VpsVuiPresentFlag           ")
@@ -637 +676 @@
   ("CtuBasedOffsetEnabledFlag"   , m_ctuBasedOffsetEnabledFlag   , std::vector< Bool >(1,0)  ,MAX_NUM_LAYERS       , "CtuBasedOffsetEnabledFlag    per direct reference for the N-th layer")
   ("MinHorizontalCtuOffsetPlus1" , m_minHorizontalCtuOffsetPlus1 , std::vector< Int  >(1,0)  ,MAX_NUM_LAYERS       , "MinHorizontalCtuOffsetPlus1  per direct reference for the N-th layer")
+#if H_MV_HLS10_VPS_VUI
+  ("SingleLayerForNonIrapFlag", m_singleLayerForNonIrapFlag, false                                          , "SingleLayerForNonIrapFlag")
+  ("HigherLayerIrapSkipFlag"  , m_higherLayerIrapSkipFlag  , false                                          , "HigherLayerIrapSkipFlag  ")
+#endif
 #endif
 
@@ -742 +785 @@
   ("SEISubBitstreamAvgBitRate",               m_sbPropAvgBitRate,             std::vector< Int  >(1,0)  ,"Specifies average bit rate of the i-th sub-bitstream")
   ("SEISubBitstreamMaxBitRate",               m_sbPropMaxBitRate,             std::vector< Int  >(1,0)  ,"Specifies maximum bit rate of the i-th sub-bitstream")
+
+#if H_MV_HLS10_GEN_FIX
+  ("OutputVpsInfo",                           m_outputVpsInfo,                false                     ,"Output information about the layer dependencies and layer sets")
+#endif
 #endif
 #if H_3D
@@ -792 +839 @@
 #endif //H_3D
   ;
-  #if H_MV
+
+#if H_MV
   // parse coding structure
   for( Int k = 0; k < MAX_NUM_LAYERS; k++ )
@@ -1034 +1082 @@
   }
   m_iNumberOfViews = (Int) uniqueViewOrderIndices.size(); 
+#if H_MV_HLS10_AUX
+  xResizeVector( m_auxId );
+#endif
 
 #if H_3D
@@ -1067 +1118 @@
   xResizeVector( m_wppInUseFlag ); 
 
+#if H_MV_HLS10_ADD_LAYERSETS
+  for (Int olsIdx = 0; olsIdx < m_vpsNumLayerSets + m_numAddLayerSets + (Int) m_outputLayerSetIdx.size(); olsIdx++)
+#else
   for (Int olsIdx = 0; olsIdx < m_vpsNumLayerSets + (Int) m_outputLayerSetIdx.size(); olsIdx++)
+#endif
   {    
     m_altOutputLayerFlag.push_back( false );      
@@ -1177 +1232 @@
     }
   }
+
+#if H_MV
+#if H_MV_HLS10_PTL
+  // parse PTL
+  Bool anyEmpty = false; 
+  if( cfg_profiles.empty() )
+  {
+#if H_3D
+    cfg_profiles = string("main main 3d-main");
+#else
+    cfg_profiles = string("main main multiview-main");    
+#endif
+    fprintf(stderr, "\nWarning: No profiles given, using defaults: %s", cfg_profiles.c_str() );
+    anyEmpty = true; 
+  }
+
+  if( cfg_levels.empty() )
+  {
+    cfg_levels = string("none none none");
+    fprintf(stderr, "\nWarning: No levels given, using defaults: %s", cfg_levels.c_str() );
+    anyEmpty = true; 
+  }
+
+  if( cfg_tiers.empty() )
+  {
+    cfg_tiers = string("main main main");
+    fprintf(stderr, "\nWarning: No tiers given, using defaults: %s", cfg_tiers.c_str());
+    anyEmpty = true; 
+  }
+
+  if( m_inblFlag.empty() )
+  {
+    fprintf(stderr, "\nWarning: No inblFlags given, using defaults:");
+    for( Int i = 0; i < 3; i++)
+    {
+      m_inblFlag.push_back( false );
+      fprintf(stderr," %d", (Int) m_inblFlag[i]);
+    }
+    anyEmpty = true; 
+  }   
+
+  if ( anyEmpty )
+  {
+    fprintf( stderr, "\n" );
+  }
+
+  xReadStrToEnum( cfg_profiles, m_profile   ); 
+  xReadStrToEnum( cfg_levels,   m_level     ); 
+  xReadStrToEnum( cfg_tiers ,   m_levelTier ); 
+#endif
+#endif
 #if H_3D
   // set global varibles
@@ -1291 +1397 @@
     fprintf(stderr, "******************************************************************\n");
   }
+
+
+#if !H_MV_HLS10_PTL
   if( m_profile==Profile::NONE )
   {
@@ -1303 +1412 @@
     fprintf(stderr, "***************************************************************************\n");
   }
+#endif
 
   Bool check_failed = false; /* abort if there is a fatal configuration problem */
@@ -1321 +1431 @@
   xConfirmPara( m_scalabilityMask != 2 && m_scalabilityMask != 3, "Scalability Mask must be equal to 2 or 3. ");
 #else
+#if H_MV_HLS10_AUX
+  xConfirmPara( m_scalabilityMask != 2 && m_scalabilityMask != 8 && m_scalabilityMask != 10, "Scalability Mask must be equal to 2, 8 or 10");
+#else
   xConfirmPara( m_scalabilityMask != 2 , "Scalability Mask must be equal to 2. ");
+#endif
 #endif
 
@@ -1332 +1446 @@
 
   m_dimIds.push_back( m_viewOrderIndex );   
-  xConfirmPara(  m_dimensionIdLen.size() < m_dimIds.size(), "DimensionIdLen must be given for all dimensions. "   );   Int dimBitOffset[MAX_NUM_SCALABILITY_TYPES+1]; 
+#if H_MV_HLS10_AUX
+  for (Int i = 0; i < m_auxId.size(); i++)
+  {
+    xConfirmPara( !( ( m_auxId[i] >= 0 && m_auxId[i] <= 2 ) || ( m_auxId[i] >= 128 && m_auxId[i] <= 159 ) ) , "AuxId shall be in the range of 0 to 2, inclusive, or 128 to 159, inclusive");
+  }
+  if ( m_scalabilityMask & ( 1 << AUX_ID ) )
+  {
+    m_dimIds.push_back ( m_auxId );
+  }
+#endif  
+  xConfirmPara(  m_dimensionIdLen.size() < m_dimIds.size(), "DimensionIdLen must be given for all dimensions. "   );
+  Int dimBitOffset[MAX_NUM_SCALABILITY_TYPES+1]; 
 
   dimBitOffset[ 0 ] = 0; 
@@ -1428 +1553 @@
   {   
     Int refLayerSetIdx = m_outputLayerSetIdx[ lsIdx ]; 
+#if H_MV_HLS10_ADD_LAYERSETS
+    xConfirmPara(  refLayerSetIdx < 0 || refLayerSetIdx >= m_vpsNumLayerSets + m_numAddLayerSets, "Output layer set idx must be greater or equal to 0 and less than the VpsNumLayerSets plus NumAddLayerSets." );
+#else
     xConfirmPara(  refLayerSetIdx < 0 || refLayerSetIdx >= m_vpsNumLayerSets, "Output layer set idx must be greater or equal to 0 and less than the VpsNumLayerSets." );
-
+#endif
+#if !H_MV_HLS10_ADD_LAYERSETS
     for (Int i = 0; i < m_layerIdsInAddOutputLayerSet[ lsIdx ].size(); i++)
     {
@@ -1443 +1572 @@
       xConfirmPara( !isAlsoInLayerSet, "All output layers of a output layer set be included in corresponding layer set.");
     }
+#endif
   }
 
@@ -1454 +1584 @@
       anyDefaultOutputFlag = anyDefaultOutputFlag || ( m_layerIdsInDefOutputLayerSet[lsIdx].size() != 0 );
     }    
+#if H_MV_HLS10_ADD_LAYERSETS
+    if ( anyDefaultOutputFlag )
+    {    
+      printf( "\nWarning: Ignoring LayerIdsInDefOutputLayerSet parameters, since defaultTargetOuputLayerIdc is not equal 2.\n" );    
+    }
+#else
     printf( "\nWarning: Ignoring LayerIdsInDefOutputLayerSet parameters, since defaultTargetOuputLayerIdc is not equal 2.\n" );    
+#endif
   }
   else  
@@ -1476 +1613 @@
   }
 
+#if H_MV_HLS10_ADD_LAYERSETS
+  xConfirmPara( m_altOutputLayerFlag.size() < m_vpsNumLayerSets + m_numAddLayerSets + m_outputLayerSetIdx.size(), "The number of alt output layer flags must be equal to the number of layer set additional output layer sets plus the number of output layer set indices" );
+#else
   xConfirmPara( m_altOutputLayerFlag.size() < m_vpsNumLayerSets + m_outputLayerSetIdx.size(), "The number of Profile Level Tier indices must be equal to the number of layer set plus the number of output layer set indices" );
-  xConfirmPara( m_profileLevelTierIdx.size() < m_vpsNumLayerSets + m_outputLayerSetIdx.size(), "The number of Profile Level Tier indices must be equal to the number of layer set plus the number of output layer set indices" );
-
-  // Layer Dependencies  
+#endif
+
+  // PTL
+#if H_MV_HLS10_PTL
+    xConfirmPara( ( m_profile.size() != m_inblFlag.size() || m_profile.size() != m_level.size()  ||  m_profile.size() != m_levelTier.size() ), "The number of Profiles, Levels, Tiers and InblFlags must be equal." ); 
+
+    if ( m_numberOfLayers > 1)
+    {
+      xConfirmPara( m_profile.size() <= 1, "The number of profiles, tiers, levels, and inblFlags must be greater than 1.");
+      xConfirmPara( m_inblFlag[0], "VpsProfileTierLevel[0] must have inblFlag equal to 0");
+      if (m_profile.size() > 1 )
+      {
+        xConfirmPara( m_profile[0]  != m_profile[1], "The profile in VpsProfileTierLevel[1] must be equal to the profile in VpsProfileTierLevel[0].");
+        xConfirmPara( m_inblFlag[0] != m_inblFlag[1], "inblFlag in VpsProfileTierLevel[1] must be equal to the inblFlag in VpsProfileTierLevel[0].");
+      }
+    }
+#else
+    xConfirmPara( m_profileLevelTierIdx.size() < m_vpsNumLayerSets + m_outputLayerSetIdx.size(), "The number of Profile Level Tier indices must be equal to the number of layer set plus the number of output layer set indices" );
+#endif
+
+    // Layer Dependencies  
   for (Int i = 0; i < m_numberOfLayers; i++ )
   {
@@ -2341 +2499 @@
 #endif
 #if H_MV
+#if H_MV_HLS10_GEN_FIX
+  xPrintParaVector( "NuhLayerId"     , m_layerIdInNuh ); 
+  if ( m_targetEncLayerIdList.size() > 0)
+  {
+    xPrintParaVector( "TargetEncLayerIdList"     , m_targetEncLayerIdList ); 
+  }
+#endif
   xPrintParaVector( "ViewIdVal"     , m_viewId ); 
   xPrintParaVector( "ViewOrderIndex", m_viewOrderIndex ); 
+#if H_MV_HLS10_AUX
+  xPrintParaVector( "AuxId", m_auxId );
+#endif
 #endif
 #if H_3D

trunk/source/App/TAppEncoder/TAppEncCfg.h

@@ -78 +78 @@
   std::vector<Int>       m_viewId;                            ///< view id
   std::vector<Int>       m_viewOrderIndex;                    ///< view order index  
+#if H_MV_HLS10_AUX
+  std::vector<Int>       m_auxId;                             ///< auxiliary id
+#endif
 #if H_3D
   std::vector<Int>       m_depthFlag;                         ///< depth flag
+#endif
+#if H_MV_HLS10_GEN_FIX
+  std::vector<Int>       m_targetEncLayerIdList;              ///< layer Ids in Nuh to be encoded
 #endif
   std::vector<Int>       m_layerIdInNuh;                      ///< layer Id in Nuh for each layer 
@@ -89 +95 @@
   Int                    m_vpsNumLayerSets;                   ///< Number of layer sets
   std::vector< std::vector<Int> > m_layerIdsInSets;           ///< LayerIds in vps of layer set 
-  Int                    m_defaultOutputLayerIdc;       ///< Specifies output layers of layer sets, 0: output all layers, 1: output highest layers, 2: specified by LayerIdsInDefOuputLayerSet
+#if H_MV_HLS10_ADD_LAYERSETS
+  Int                    m_numAddLayerSets;                    ///< Number of additional layer sets
+  std::vector< std::vector<Int> > m_highestLayerIdxPlus1;      ///< HighestLayerIdxPlus1 for each additional layer set and each independent layer (value with index 0 will be ignored)
+#endif
+  Int                    m_defaultOutputLayerIdc;             ///< Specifies output layers of layer sets, 0: output all layers, 1: output highest layers, 2: specified by LayerIdsInDefOuputLayerSet
   std::vector<Int>       m_outputLayerSetIdx;                 ///< Indices of layer sets used as additional output layer sets  
   std::vector< std::vector<Int> > m_layerIdsInAddOutputLayerSet; ///< LayerIds in vps of additional output layers
   std::vector< std::vector<Int> > m_layerIdsInDefOutputLayerSet; ///< Indices in vps of output layers in layer sets
+#if H_MV_HLS10_ADD_LAYERSETS
+  std::vector< std::vector< Int > > m_profileTierLevelIdx;      ///< Indices of of profile, per layer in layer set
+#else
   std::vector<Int>       m_profileLevelTierIdx;               ///< Indices of of profile level tier
+#endif
   std::vector<Bool>      m_altOutputLayerFlag;                ///< Alt output layer flag
 
@@ -124 +138 @@
   std::vector< std::vector<Bool > > m_ctuBasedOffsetEnabledFlag;
   std::vector< std::vector<Int  > > m_minHorizontalCtuOffsetPlus1;
+#if H_MV_HLS10_VPS_VUI
+  Bool m_singleLayerForNonIrapFlag;
+  Bool m_higherLayerIrapSkipFlag;
+#endif // H_MV_HLS10_VPS_VUI
+
 
 #if H_3D_IV_MERGE
@@ -174 +193 @@
   
   // profile/level
+#if H_MV_HLS10_PTL
+#if H_MV
+  std::vector< Profile::Name > m_profile;
+  std::vector< Level::Tier   > m_levelTier;
+  std::vector< Level::Name   > m_level;
+  std::vector< Bool          > m_inblFlag; 
+#else
   Profile::Name m_profile;
   Level::Tier   m_levelTier;
   Level::Name   m_level;
+#endif
+#endif
+
   Bool m_progressiveSourceFlag;
   Bool m_interlacedSourceFlag;
   Bool m_nonPackedConstraintFlag;
   Bool m_frameOnlyConstraintFlag;
-  
   // coding structure
 #if H_MV
@@ -440 +468 @@
   std::vector<Int>  m_sbPropAvgBitRate;
   std::vector<Int>  m_sbPropMaxBitRate;
+#if H_MV_HLS10_GEN_FIX
+  Bool              m_outputVpsInfo;
+#endif
 #endif
 #if H_3D
@@ -506 +537 @@
   Void  xPrintUsage     ();                                   ///< print usage
 #if H_MV
+
+#if H_MV_HLS10_PTL
+  template<typename T>
+  Void xReadStrToEnum(string in, std::vector<T> &val)
+  {
+    val.clear(); 
+
+    char* cElement = NULL;
+    char* cString = new char[in.size()+1];
+    strcpy(cString, in.c_str());
+
+    cElement = strtok( cString, " " );
+    while ( cElement != NULL )
+    {
+      T profile;       
+      std::istringstream ss( cElement ); 
+      ss >> profile; 
+      val.push_back( profile ); 
+      cElement = strtok( NULL, " " );
+    }
+    delete[] cString;
+  }
+#endif
+
+
   template <typename T>
   Void xResizeVector(  std::vector<T> & rpcVector )

trunk/source/App/TAppEncoder/TAppEncTop.cpp

@@ -133 +133 @@
   xSetLayerIds             ( vps );   
   xSetDimensionIdAndLength ( vps );
-  xSetDependencies( vps );
+  xSetDependencies         ( vps );
+  xSetRepFormat            ( vps ); 
   xSetProfileTierLevel     ( vps ); 
-  xSetRepFormat            ( vps ); 
   xSetLayerSets            ( vps ); 
   xSetDpbSize              ( vps ); 
@@ -144 +144 @@
   xDeriveDltArray          ( vps, dlt );
 #endif
-
+#if H_MV_HLS10_GEN_FIX
+  if ( m_targetEncLayerIdList.size() == 0 )
+  {
+    for (Int i = 0; i < m_numberOfLayers; i++ )
+    {
+      m_targetEncLayerIdList.push_back( vps.getLayerIdInNuh( i ) );
+    }
+  }
+  for( Int i = (Int) m_targetEncLayerIdList.size()-1 ; i >= 0 ; i--)
+  {
+    Int iNuhLayerId = m_targetEncLayerIdList[i]; 
+    Bool allRefLayersPresent = true; 
+    for( Int j = 0; j < vps.getNumRefLayers( iNuhLayerId ); j++)
+    {
+      allRefLayersPresent = allRefLayersPresent && xLayerIdInTargetEncLayerIdList( vps.getIdRefLayer( iNuhLayerId, j) );
+    }
+    if ( !allRefLayersPresent )
+    {
+      printf("\nCannot encode layer with nuh_layer_id equal to %d since not all reference layers are in TargetEncLayerIdList\n", iNuhLayerId);
+      m_targetEncLayerIdList.erase( m_targetEncLayerIdList.begin() + i  );
+    }
+  }
+#endif
+
+#if H_MV_HLS10_ADD_LAYERSETS
+  if ( m_outputVpsInfo )
+  {  
+#if H_MV_HLS10_AUX
+    vps.printScalabilityId();
+#endif
+    vps.printLayerDependencies();
+    vps.printLayerSets(); 
+    vps.printPTL(); 
+  }
+#endif
 
   for(Int layerIdInVps = 0; layerIdInVps < m_numberOfLayers; layerIdInVps++)
@@ -200 +234 @@
     m_cTEncTop.setUseDMM                       ( isDepth ? m_useDMM               : false );
 #if SEPARATE_FLAG_I0085
+#if LGE_FCO_I0116
+    m_cTEncTop.setUseIVP                       ( vps.getViewIndex( layerId ) == 0 && isDepth ? m_useIVP               : false );
+#else
     m_cTEncTop.setUseIVP                       ( isDepth ? m_useIVP               : false );
+#endif
 #endif
     m_cTEncTop.setUseSDC                       ( isDepth ? m_useSDC               : false );
@@ -210 +248 @@
 #if !MTK_I0099_VPS_EX2 || MTK_I0099_FIX
 #if H_3D_QTLPC
+#if LGE_FCO_I0116
+    m_cTEncTop.setUseQTL                       ( vps.getViewIndex( layerId ) == 0 && isDepth ? m_bUseQTL               : false );
+#else
     m_cTEncTop.setUseQTL                       ( isDepth ? m_bUseQTL               : false );
+#endif
 #if !MTK_I0099_VPS_EX2    
     m_cTEncTop.setUsePC                        ( isDepth ? m_bUsePC                : false );
@@ -224 +266 @@
 #endif
 #if H_3D_IV_MERGE
-    m_cTEncTop.setUseMPI               ( isDepth ? m_bMPIFlag    : false );
+#if LGE_FCO_I0116
+    m_cTEncTop.setUseMPI                       ( vps.getViewIndex( layerId ) == 0 && isDepth ? m_bMPIFlag    : false );
+#else
+    m_cTEncTop.setUseMPI                       ( isDepth ? m_bMPIFlag    : false );
+#endif
 #endif
 #endif // H_3D
@@ -236 +282 @@
 #endif
 
+#if H_MV
+  m_cTEncTop.setProfile(m_profile[0]);
+  m_cTEncTop.setLevel  (m_levelTier[0], m_level[0]);
+#else
   m_cTEncTop.setProfile(m_profile);
   m_cTEncTop.setLevel(m_levelTier, m_level);
+#endif
   m_cTEncTop.setProgressiveSourceFlag(m_progressiveSourceFlag);
   m_cTEncTop.setInterlacedSourceFlag(m_interlacedSourceFlag);
@@ -789 +840 @@
   
 #if H_MV
+#if H_MV_HLS10_GEN_FIX
+  while ( (m_targetEncLayerIdList.size() != 0 ) && !allEos )
+#else
   while ( !allEos )
+#endif
   {
     for(Int layer=0; layer < m_numberOfLayers; layer++ )
     {
+#if H_MV_HLS10_GEN_FIX
+      if (!xLayerIdInTargetEncLayerIdList( m_vps->getLayerIdInNuh( layer ) ))
+      {
+        continue; 
+      }
+#endif
+
       Int frmCnt = 0;
       while ( !eos[layer] && !(frmCnt == gopSize))
@@ -832 +894 @@
       for(Int layer=0; layer < m_numberOfLayers; layer++ )
       {
+#if H_MV_HLS10_GEN_FIX
+        if (!xLayerIdInTargetEncLayerIdList( m_vps->getLayerIdInNuh( layer ) ))
+        {
+          continue; 
+        }
+#endif
+
 #if H_3D_VSO        
           if( m_bUseVSO && m_bUseEstimatedVSD && iNextPoc < m_framesToBeEncoded )
@@ -858 +927 @@
   for(Int layer=0; layer < m_numberOfLayers; layer++ )
   {
+#if H_MV_HLS10_GEN_FIX
+    if (!xLayerIdInTargetEncLayerIdList( m_vps->getLayerIdInNuh( layer ) ))
+    {
+      continue; 
+    }
+#endif
     m_acTEncTopList[layer]->printSummary( m_acTEncTopList[layer]->getNumAllPicCoded(), m_isField );
   }
@@ -1321 +1396 @@
   // Max sub layers, + presence flag
   Bool subLayersMaxMinus1PresentFlag = false; 
+#if !H_MV_FIX_SUB_LAYERS_MAX_MINUS1
   Int  subLayersMaxMinus1 = -1; 
+#endif
   for (Int curLayerIdInVps = 0; curLayerIdInVps < m_numberOfLayers; curLayerIdInVps++ )
-  {
-    Int curSubLayersMaxMinus1 = -1; 
+  {    
+    Int curSubLayersMaxMinus1 = 0; 
     for( Int i = 0; i < getGOPSize(); i++ ) 
     {
@@ -1332 +1409 @@
 
     vps.setSubLayersVpsMaxMinus1( curLayerIdInVps, curSubLayersMaxMinus1 ); 
+#if !H_MV_FIX_SUB_LAYERS_MAX_MINUS1
     if ( subLayersMaxMinus1 == -1 )
     {
@@ -1340 +1418 @@
       subLayersMaxMinus1PresentFlag = subLayersMaxMinus1PresentFlag || ( curSubLayersMaxMinus1 != subLayersMaxMinus1 ); 
     }
+#else
+    subLayersMaxMinus1PresentFlag = subLayersMaxMinus1PresentFlag || ( curSubLayersMaxMinus1 != vps.getMaxSubLayersMinus1() );
+#endif
   }
 
@@ -1348 +1429 @@
   Bool maxTidRefPresentFlag = false; 
   for ( Int refLayerIdInVps = 0; refLayerIdInVps < m_numberOfLayers; refLayerIdInVps++)
-    {
+  {
     for ( Int curLayerIdInVps = 1; curLayerIdInVps < m_numberOfLayers; curLayerIdInVps++)
-      {
+    {
       Int maxTid = -1; 
+#if H_MV_FIX_LOOP_GOPSIZE
+      for( Int i = 0; i < ( getGOPSize() + 1); i++ ) 
+      {        
+        GOPEntry geCur =  m_GOPListMvc[curLayerIdInVps][( i < getGOPSize()  ? i : MAX_GOP )];
+        GOPEntry geRef =  m_GOPListMvc[refLayerIdInVps][( i < getGOPSize()  ? i : MAX_GOP )];
+#else
       for( Int i = 0; i < getGOPSize(); i++ ) 
       {        
         GOPEntry geCur =  m_GOPListMvc[curLayerIdInVps][i];
-        GOPEntry geRef =  m_GOPListMvc[refLayerIdInVps][i];
-        
+        GOPEntry geRef =  m_GOPListMvc[refLayerIdInVps][i];     
+#endif
         for (Int j = 0; j < geCur.m_numActiveRefLayerPics; j++)
         {        
           if ( m_directRefLayers[ curLayerIdInVps ][ geCur.m_interLayerPredLayerIdc[ j ]] == refLayerIdInVps )
           {
+#if H_MV_FIX_LOOP_GOPSIZE
+            Bool refAlwaysIntra = ( i == getGOPSize() ) && ( m_iIntraPeriod[ curLayerIdInVps ] % m_iIntraPeriod[ refLayerIdInVps ] == 0 );
+            Bool refLayerZero   = ( i == getGOPSize() ) && ( refLayerIdInVps == 0 );
+            maxTid = std::max( maxTid, ( refAlwaysIntra || refLayerZero ) ? 0 : geRef.m_temporalId ); 
+#else
             maxTid = std::max( maxTid, geRef.m_temporalId ); 
+#endif
           }
         }
@@ -1487 +1580 @@
 Void TAppEncTop::xSetProfileTierLevel( TComVPS& vps )
 { 
+#if H_MV_HLS10_PTL
+
+  // SET PTL
+  assert( m_profile.size() == m_level.size() && m_profile.size() == m_levelTier.size() ); 
+  vps.setVpsNumProfileTierLevelMinus1( (Int) m_profile.size() - 1 );
+  for ( Int ptlIdx = 0; ptlIdx <= vps.getVpsNumProfileTierLevelMinus1(); ptlIdx++ )
+  {
+    if ( ptlIdx > 1 )
+    {
+      Bool vpsProfilePresentFlag = ( m_profile[ptlIdx] != m_profile[ptlIdx - 1] )
+        || ( m_inblFlag[ptlIdx ] != m_inblFlag[ptlIdx - 1] ); 
+      vps.setVpsProfilePresentFlag( ptlIdx, vpsProfilePresentFlag ); 
+    }
+
+    xSetProfileTierLevel( vps, ptlIdx, -1, m_profile[ptlIdx], m_level[ptlIdx], 
+      m_levelTier[ ptlIdx ], m_progressiveSourceFlag, m_interlacedSourceFlag,
+      m_nonPackedConstraintFlag, m_frameOnlyConstraintFlag,  m_inblFlag[ptlIdx] );     
+  }  
+#else
   const Int vpsNumProfileTierLevelMinus1 = 0; //TBD
   vps.setVpsNumProfileTierLevelMinus1( vpsNumProfileTierLevelMinus1 ); 
@@ -1494 +1606 @@
     vps.setVpsProfilePresentFlag( i, true ); 
   }
-}
-
+#endif
+}
+
+#if H_MV_HLS10_PTL
+Void TAppEncTop::xSetProfileTierLevel(TComVPS& vps, Int profileTierLevelIdx, Int subLayer, Profile::Name profile, Level::Name level, Level::Tier tier, Bool progressiveSourceFlag, Bool interlacedSourceFlag, Bool nonPackedConstraintFlag, Bool frameOnlyConstraintFlag, Bool inbldFlag)
+{
+  TComPTL* ptlStruct = vps.getPTL( profileTierLevelIdx );    
+  assert( ptlStruct != NULL ); 
+
+  ProfileTierLevel* ptl; 
+  if ( subLayer == -1 )
+  {
+    ptl = ptlStruct->getGeneralPTL();
+  }
+  else
+  {
+    ptl = ptlStruct->getSubLayerPTL(  subLayer );
+  }
+
+  assert( ptl != NULL );
+
+  ptl->setProfileIdc( profile );
+  ptl->setTierFlag  ( tier    );
+  ptl->setLevelIdc  ( level   );
+  ptl->setProfileCompatibilityFlag( profile, true );
+#if H_MV_HLS10_PTL_INBL_FIX
+  ptl->setInbldFlag( inbldFlag );
+#endif
+
+  switch ( profile )
+  {
+  case Profile::MAIN:
+    break; 
+  case Profile::MULTIVIEWMAIN:
+#if H_3D
+  case Profile::MAIN3D:
+#endif
+    ptl->setMax12bitConstraintFlag      ( true  ); 
+    ptl->setMax12bitConstraintFlag      ( true  );
+    ptl->setMax10bitConstraintFlag      ( true  );
+    ptl->setMax8bitConstraintFlag       ( true  );
+    ptl->setMax422chromaConstraintFlag  ( true  );
+    ptl->setMax420chromaConstraintFlag  ( true  );
+    ptl->setMaxMonochromeConstraintFlag ( false );
+    ptl->setIntraConstraintFlag         ( false ); 
+    ptl->setOnePictureOnlyConstraintFlag( false );
+    ptl->setLowerBitRateConstraintFlag  ( true  );        
+    break; 
+  default:
+    assert( 0 ); // other profiles currently not supported
+    break; 
+  }
+}
+#endif
 
 Void TAppEncTop::xSetRepFormat( TComVPS& vps )
@@ -1513 +1677 @@
   //repFormat->setSeparateColourPlaneVpsFlag( );
 
+#if H_MV_HLS10_GEN_VSP_CONF_WIN
+  repFormat->setConformanceWindowVpsFlag( true );
+  repFormat->setConfWinVpsLeftOffset    ( m_confLeft   / TComSPS::getWinUnitX( repFormat->getChromaFormatVpsIdc() ) );
+  repFormat->setConfWinVpsRightOffset   ( m_confRight  / TComSPS::getWinUnitX( repFormat->getChromaFormatVpsIdc() )  );
+  repFormat->setConfWinVpsTopOffset     ( m_confTop    / TComSPS::getWinUnitY( repFormat->getChromaFormatVpsIdc() )  );
+  repFormat->setConfWinVpsBottomOffset  ( m_confBottom / TComSPS::getWinUnitY( repFormat->getChromaFormatVpsIdc() ) ); 
+#endif
+
   assert( vps.getRepFormat( 0 ) == NULL ); 
   vps.setRepFormat( 0 , repFormat );
@@ -1528 +1700 @@
   {  
     Int currLsIdx = vps.olsIdxToLsIdx( i ); 
+#if !H_MV_HLS10_ADD_LAYERSETS
     std::vector<Int> targetDecLayerIdList = vps.getTargetDecLayerIdList( i ); 
+#endif
     Bool subLayerFlagInfoPresentFlag = false; 
 
@@ -1534 +1708 @@
     {   
       Bool subLayerDpbInfoPresentFlag = false; 
+#if !H_MV_HLS10_ADD_LAYERSETS
       assert( vps.getNumLayersInIdList( currLsIdx ) == targetDecLayerIdList.size() ); 
+#endif
       for( Int k = 0; k < vps.getNumLayersInIdList( currLsIdx ); k++ )   
       {
+#if H_MV_HLS10_DBP_SIZE
+        Int layerIdInVps = vps.getLayerIdInVps( vps.getLayerSetLayerIdList( currLsIdx, k ) );
+        if ( vps.getNecessaryLayerFlag( i,k ) && ( vps.getVpsBaseLayerInternalFlag() || vps.getLayerSetLayerIdList( currLsIdx, k ) != 0 ) )
+        {       
+          dpbSize->setMaxVpsDecPicBufferingMinus1( i, k, j, m_maxDecPicBufferingMvc[ layerIdInVps ][ j ] - 1 );
+          if ( j > 0 )
+          {
+            subLayerDpbInfoPresentFlag = subLayerDpbInfoPresentFlag || ( dpbSize->getMaxVpsDecPicBufferingMinus1( i, k, j ) != dpbSize->getMaxVpsDecPicBufferingMinus1( i, k, j - 1 ) );
+          }
+        }
+        else
+        {
+          if (vps.getNecessaryLayerFlag(i,k) && j == 0 && k == 0 )
+          {          
+            dpbSize->setMaxVpsDecPicBufferingMinus1(i, k ,j, 0 ); 
+          }
+        }
+#else
         Int layerIdInVps = vps.getLayerIdInVps( targetDecLayerIdList[k] );           
         dpbSize->setMaxVpsDecPicBufferingMinus1( i, k, j, m_maxDecPicBufferingMvc[ layerIdInVps ][ j ] - 1 );
+
         if ( j > 0 )
         {
           subLayerDpbInfoPresentFlag = subLayerDpbInfoPresentFlag || ( dpbSize->getMaxVpsDecPicBufferingMinus1( i, k, j ) != dpbSize->getMaxVpsDecPicBufferingMinus1( i, k, j - 1 ) );
         }
+#endif
       }        
 
       Int maxNumReorderPics = MIN_INT;
+#if H_MV_HLS10_DBP_SIZE
+      for ( Int idx = 0; idx < vps.getNumLayersInIdList( currLsIdx ); idx++ )
+      {
+        if (vps.getNecessaryLayerFlag(i, idx ))
+        {        
+          Int layerIdInVps = vps.getLayerIdInVps( vps.getLayerSetLayerIdList(currLsIdx, idx) );        
+          maxNumReorderPics = std::max( maxNumReorderPics, m_numReorderPicsMvc[ layerIdInVps ][ j ] ); 
+        }
+      }
+#else
       for ( Int idx = 0; idx < targetDecLayerIdList.size(); idx++ )
       {
@@ -1551 +1757 @@
         maxNumReorderPics = std::max( maxNumReorderPics, m_numReorderPicsMvc[ layerIdInVps ][ j ] ); 
       }
+#endif
       assert( maxNumReorderPics != MIN_INT ); 
 
@@ -1576 +1783 @@
 }
 
-
 Void TAppEncTop::xSetLayerSets( TComVPS& vps )
 {   
@@ -1598 +1804 @@
   // Additional output layer sets + profileLevelTierIdx
   vps.setDefaultOutputLayerIdc      ( m_defaultOutputLayerIdc );   
+#if H_MV_HLS10_ADD_LAYERSETS
+  if( vps.getNumIndependentLayers() == 0 && m_numAddLayerSets > 0  )
+  {
+    fprintf( stderr, "\nWarning: Ignoring additional layer sets since NumIndependentLayers is equal to 0.\n");            
+  }
+  else
+  {
+    vps.setNumAddLayerSets( m_numAddLayerSets ); 
+    if ( m_highestLayerIdxPlus1.size() < vps.getNumAddLayerSets() ) 
+    {
+      fprintf(stderr, "\nError: Number of highestLayerIdxPlus1 parameters must be greater than or equal to NumAddLayerSets\n");
+      exit(EXIT_FAILURE);
+    }
+
+    for (Int i = 0; i < vps.getNumAddLayerSets(); i++)
+    {
+      if ( m_highestLayerIdxPlus1[ i ].size() < vps.getNumIndependentLayers() ) 
+      {
+        fprintf(stderr, "Error: Number of elements in highestLayerIdxPlus1[ %d ] parameters must be greater than or equal to NumIndependentLayers(= %d)\n", i, vps.getNumIndependentLayers());
+        exit(EXIT_FAILURE);
+      }
+
+      for (Int j = 1; j < vps.getNumIndependentLayers(); j++)
+      {
+        if ( m_highestLayerIdxPlus1[ i ][ j ]  < 0 || m_highestLayerIdxPlus1[ i ][ j ] > vps.getNumLayersInTreePartition( j ) ) 
+        {
+          fprintf(stderr, "Error: highestLayerIdxPlus1[ %d ][ %d ] shall be in the range of 0 to NumLayersInTreePartition[ %d ] (= %d ), inclusive. \n", i, j, j, vps.getNumLayersInTreePartition( j ) );
+          exit(EXIT_FAILURE);
+        }
+        vps.setHighestLayerIdxPlus1( i, j, m_highestLayerIdxPlus1[ i ][ j ] ); 
+      }
+      vps.deriveAddLayerSetLayerIdList( i );
+    }        
+  }  
+#else
   vps.setNumAddLayerSets            ( 0                             );  
+#endif
   vps.setNumAddOlss                 ( numAddOuputLayerSets          ); 
   vps.initTargetLayerIdLists(); 
 
+#if H_MV_HLS10_ADD_LAYERSETS
+  for (Int olsIdx = 0; olsIdx < vps.getNumLayerSets() + numAddOuputLayerSets; olsIdx++)
+  {
+    Int addOutLsIdx = olsIdx - vps.getNumLayerSets();     
+#else
   for (Int olsIdx = 0; olsIdx < m_vpsNumLayerSets + numAddOuputLayerSets; olsIdx++)
   {
     Int addOutLsIdx = olsIdx - m_vpsNumLayerSets;     
-    
+#endif    
     vps.setLayerSetIdxForOlsMinus1( olsIdx, ( ( addOutLsIdx < 0 ) ?  olsIdx  : m_outputLayerSetIdx[ addOutLsIdx ] ) - 1 ); 
 
+#if H_MV_HLS10_ADD_LAYERSETS
+    Int lsIdx = vps.olsIdxToLsIdx( olsIdx );
+#else
     std::vector<Int>& layerIdList    = m_layerIdsInSets[ vps.olsIdxToLsIdx( olsIdx ) ];
-
+#endif
     if (vps.getDefaultOutputLayerIdc() == 2 || addOutLsIdx >= 0 )
     { 
+#if H_MV_HLS10_ADD_LAYERSETS
+      for ( Int i = 0; i < vps.getNumLayersInIdList( lsIdx ); i++)
+#else
       for ( Int i = 0; i < layerIdList.size(); i++)
+#endif
       {
         vps.setOutputLayerFlag( olsIdx, i, ( olsIdx == 0 && i == 0 ) ? vps.inferOutputLayerFlag(olsIdx, i ) : false ); // This is a software only fix for a bug in the spec. In spec outputLayerFlag neither present nor inferred for this case !
@@ -1622 +1876 @@
       for (Int j = 0; j < outLayerIdList.size(); j++)
       {   
+#if H_MV_HLS10_ADD_LAYERSETS
+        for ( Int i = 0; i < vps.getNumLayersInIdList( lsIdx ); i++)
+        {
+          if ( vps.getLayerSetLayerIdList( lsIdx, i ) == outLayerIdList[ j ] )
+#else
         for (Int i = 0; i < layerIdList.size(); i++ )
         {
           if ( layerIdList[ i ] == outLayerIdList[ j ] )
+#endif
           {
             vps.setOutputLayerFlag( olsIdx, i, true );       
@@ -1631 +1891 @@
           }
         }
-        assert( outputLayerInLayerSetFlag ); // The output layer is not not in the layer set.
+#if H_MV_HLS10_ADD_LAYERSETS
+        if ( !outputLayerInLayerSetFlag )
+        {
+          fprintf(stderr, "Error: Output layer %d in output layer set %d not in corresponding layer set %d \n", outLayerIdList[ j ], olsIdx , lsIdx );
+          exit(EXIT_FAILURE);
+        }
+#else
+        assert( outputLayerInLayerSetFlag ); // The output layer is not in the layer set.
+#endif
       }
     }
     else
     {
+#if H_MV_HLS10_ADD_LAYERSETS
+      for ( Int i = 0; i < vps.getNumLayersInIdList( lsIdx ); i++)
+#else
       for ( Int i = 0; i < layerIdList.size(); i++)
+#endif
       {
         vps.setOutputLayerFlag( olsIdx, i, vps.inferOutputLayerFlag( olsIdx, i ) );       
@@ -1642 +1914 @@
     }
 
+#if H_MV_HLS10_NESSECARY_LAYER
+    vps.deriveNecessaryLayerFlags( olsIdx ); 
+#endif
     vps.deriveTargetLayerIdList(  olsIdx ); 
 
+#if H_MV_HLS10_PTL
+    // SET profile_tier_level_index. 
+    if ( olsIdx == 0 )
+    {   
+      vps.setProfileTierLevelIdx( 0, 0 , vps.getMaxLayersMinus1() > 0 ? 1 : 0 ); 
+    }
+    else
+    {
+      if( (Int) m_profileTierLevelIdx[ olsIdx ].size() < vps.getNumLayersInIdList( lsIdx ) )
+      {
+        fprintf( stderr, "Warning: Not enough profileTierLevelIdx values given for the %d-th OLS. Inferring default values.\n", olsIdx ); 
+      }
+      for (Int j = 0; j < vps.getNumLayersInIdList( lsIdx ); j++)
+      {
+        if( j < (Int) m_profileTierLevelIdx[ olsIdx ].size() )
+        {
+          vps.setProfileTierLevelIdx(olsIdx, j, m_profileTierLevelIdx[olsIdx][j] );
+#if H_MV_HLS10_PTL_FIX
+          if( !vps.getNecessaryLayerFlag(olsIdx,j) && m_profileTierLevelIdx[ olsIdx ][ j ] != -1 )
+          {
+            fprintf( stderr, "Warning: The %d-th layer in the %d-th OLS is not necessary such that profileTierLevelIdx[%d][%d] will be ignored. Set value to -1 to suppress warning.\n", j,olsIdx,olsIdx,j ); 
+          }          
+        }
+        else if ( vps.getNecessaryLayerFlag(olsIdx,j) )
+#else
+        }
+        else
+#endif
+        {
+          // setting default values
+          if ( j == 0 || vps.getVpsNumProfileTierLevelMinus1() < 1 )
+          {
+            // set base layer as default
+            vps.setProfileTierLevelIdx(olsIdx, j, 1 );
+          }
+          else
+          {
+            // set VpsProfileTierLevel[2] as default
+            vps.setProfileTierLevelIdx(olsIdx, j, 2 ); 
+          }
+        }
+      }
+    }
+#else
     if ( olsIdx > 0 ) 
     {
       vps.setProfileLevelTierIdx( olsIdx, m_profileLevelTierIdx[ olsIdx ] ); 
     }
+#endif
    
     if ( vps.getNumOutputLayersInOutputLayerSet( olsIdx ) == 1 && 
@@ -1685 +2005 @@
     if( pcVPSVUI->getBitRatePresentVpsFlag( )  ||  pcVPSVUI->getPicRatePresentVpsFlag( ) )
     {
+#if H_MV_HLS10_VPS_VUI
+      for( Int i = 0; i  <  vps.getNumLayerSets(); i++ )
+#else
       for( Int i = 0; i  <=  vps.getVpsNumLayerSetsMinus1(); i++ )
+#endif
       {
         for( Int j = 0; j  <=  vps.getMaxTLayers(); j++ ) 
@@ -1734 +2058 @@
         for( Int j = 0; j < vps.getNumDirectRefLayers( vps.getLayerIdInNuh( i ) ) ; j++ )
         {  
+#if H_MV_HLS10_REF_PRED_LAYERS
+          Int layerIdx = vps.getLayerIdInVps( vps.getIdDirectRefLayer(vps.getLayerIdInNuh( i ) , j  ));  
+#else
           Int layerIdx = vps.getLayerIdInVps( vps.getRefLayerId(vps.getLayerIdInNuh( i ) , j  ));  
+#endif
           if( pcVPSVUI->getTilesInUseFlag( i )  &&  pcVPSVUI->getTilesInUseFlag( layerIdx ) )  
           {
@@ -1752 +2080 @@
       }
     }
+
+#if H_MV_HLS10_VPS_VUI
+  pcVPSVUI->setSingleLayerForNonIrapFlag( m_singleLayerForNonIrapFlag );
+  pcVPSVUI->setHigherLayerIrapSkipFlag( m_higherLayerIrapSkipFlag );
+#endif
 
     pcVPSVUI->setIlpRestrictedRefLayersFlag( m_ilpRestrictedRefLayersFlag );
@@ -1808 +2141 @@
   }
 }
-#endif
+#if H_MV_HLS10_GEN_FIX
+Bool TAppEncTop::xLayerIdInTargetEncLayerIdList(Int nuhLayerId)
+{
+  return  ( std::find(m_targetEncLayerIdList.begin(), m_targetEncLayerIdList.end(), nuhLayerId) != m_targetEncLayerIdList.end()) ;
+}
+#endif
+
+
+#endif
+
+
 #if H_3D
 Void TAppEncTop::xSetVPSExtension2( TComVPS& vps )
@@ -1816 +2159 @@
     Bool isDepth      = ( vps.getDepthId( layer ) == 1 ) ;
     Bool isLayerZero  = ( layer == 0 ); 
+#if LGE_FCO_I0116
+    Bool isDepthFirst = (layer > 1 ? true : false);
+#endif
 
 #if H_3D_ARP
@@ -1838 +2184 @@
     vps.setVpsDepthModesFlag( layer, isDepth && !isLayerZero && (m_useDMM || m_useSDC || m_useDLT ) );
 #if SEPARATE_FLAG_I0085
+#if LGE_FCO_I0116
+    vps.setIVPFlag          ( layer, isDepth && !isLayerZero && m_useIVP && !isDepthFirst );
+#else
     vps.setIVPFlag          ( layer, isDepth && !isLayerZero && m_useIVP );
+#endif
 #endif
 #endif
@@ -1866 +2216 @@
 #endif
 #if MTK_I0099_VPS_EX2
+#if LGE_FCO_I0116
+    vps.setLimQtPredFlag         ( layer, isDepth && m_bLimQtPredFlag && !isDepthFirst ); 
+#else
     vps.setLimQtPredFlag         ( layer, isDepth && m_bLimQtPredFlag ); 
+#endif
 #endif
 #if H_3D_NBDV_REF
@@ -1881 +2235 @@
 #endif
 #if H_3D_IV_MERGE
+#if LGE_FCO_I0116
+    vps.setMPIFlag( layer, !isLayerZero && isDepth && m_bMPIFlag && !isDepthFirst );
+#else
     vps.setMPIFlag( layer, !isLayerZero && isDepth && m_bMPIFlag );
+#endif
 #endif
   }  

trunk/source/App/TAppEncoder/TAppEncTop.h

@@ -132 +132 @@
   Void xSetLayerSets              ( TComVPS& vps );
   Void xSetProfileTierLevel       ( TComVPS& vps );
+
+#if H_MV_HLS10_PTL
+  Void xSetProfileTierLevel( TComVPS& vps, Int profileTierLevelIdx, Int subLayer,                              
+                             Profile::Name profile, Level::Name level, Level::Tier tier, 
+                             Bool progressiveSourceFlag, Bool interlacedSourceFlag, 
+                             Bool nonPackedConstraintFlag, Bool frameOnlyConstraintFlag, 
+                             Bool inbldFlag );
+#endif
   Void xSetRepFormat              ( TComVPS& vps );
   Void xSetDpbSize                ( TComVPS& vps );
@@ -137 +145 @@
   GOPEntry* xGetGopEntry( Int layerIdInVps, Int poc );
   Int  xGetMax( std::vector<Int>& vec);
+#if H_MV_HLS10_GEN_FIX
+  Bool xLayerIdInTargetEncLayerIdList( Int nuhLayerId );
+#endif
 #endif
 #if H_3D

trunk/source/Lib/TLibCommon/TComDataCU.cpp

@@ -4177 +4177 @@
     TComPic * pcTexPic = m_pcSlice->getTexturePic();
 #if H_3D_FCO
+#if LGE_FCO_I0116
+    if (pcTexPic && pcTexPic->getReconMark())
+#else
     if (pcTexturePic->getReconMark())
+#endif
     {
 #endif    
@@ -6160 +6164 @@
   TComMv cMv; 
 #if MTK_I0093
-  Int iDisp     = getSlice()->getDepthToDisparityB( 0 )[ 1 << ( getSlice()->getSPS()->getBitDepthY() - 1 ) ];
+#if H_3D_FIX_64BIT_SHIFT
+  Int iDisp     = getSlice()->getDepthToDisparityB( 0 )[ (Int64) (1 << ( getSlice()->getSPS()->getBitDepthY() - 1 )) ];
+#else
+  Int iDisp     = getSlice()->getDepthToDisparityB( 0 )[  1 << ( getSlice()->getSPS()->getBitDepthY() - 1 ) ];
+#endif
 #else
   Int iDisp     = getSlice()->getDepthToDisparityB( 0 )[ 128 ];

trunk/source/Lib/TLibCommon/TComRom.cpp

@@ -71 +71 @@
     c <<= 1;
   }  
+
+#if H_MV
+#if H_MV_HLS_PTL_LIMITS 
+ g_generalTierAndLevelLimits[ Level::LEVEL1   ] = TComGeneralTierAndLevelLimits(    36864,     350,  INT_MIN,   16,   1,   1 );
+ g_generalTierAndLevelLimits[ Level::LEVEL2   ] = TComGeneralTierAndLevelLimits(   122880,    1500,  INT_MIN,   16,   1,   1 );
+ g_generalTierAndLevelLimits[ Level::LEVEL2_1 ] = TComGeneralTierAndLevelLimits(   245760,    3000,  INT_MIN,   20,   1,   1 );
+ g_generalTierAndLevelLimits[ Level::LEVEL3   ] = TComGeneralTierAndLevelLimits(   552960,    6000,  INT_MIN,   30,   2,   2 );
+ g_generalTierAndLevelLimits[ Level::LEVEL3_1 ] = TComGeneralTierAndLevelLimits(   983040,   10000,  INT_MIN,   40,   3,   3 );
+ g_generalTierAndLevelLimits[ Level::LEVEL4   ] = TComGeneralTierAndLevelLimits(  2228224,   12000,    30000,   75,   5,   5 );
+ g_generalTierAndLevelLimits[ Level::LEVEL4_1 ] = TComGeneralTierAndLevelLimits(  2228224,   20000,    50000,   75,   5,   5 );
+ g_generalTierAndLevelLimits[ Level::LEVEL5   ] = TComGeneralTierAndLevelLimits(  8912896,   25000,   100000,  200,  11,  10 );
+ g_generalTierAndLevelLimits[ Level::LEVEL5_1 ] = TComGeneralTierAndLevelLimits(  8912896,   40000,   160000,  200,  11,  10 );
+ g_generalTierAndLevelLimits[ Level::LEVEL5_2 ] = TComGeneralTierAndLevelLimits(  8912896,   60000,   240000,  200,  11,  10 );
+ g_generalTierAndLevelLimits[ Level::LEVEL6   ] = TComGeneralTierAndLevelLimits( 35651584,   60000,   240000,  600,  22,  20 );
+ g_generalTierAndLevelLimits[ Level::LEVEL6_1 ] = TComGeneralTierAndLevelLimits( 35651584,  120000,   480000,  600,  22,  20 );
+ g_generalTierAndLevelLimits[ Level::LEVEL6_2 ] = TComGeneralTierAndLevelLimits( 35651584,  240000,   800000,  600,  22,  20 );
+#endif
+#endif
+
 }
 
@@ -369 +388 @@
 
 Char  g_aucConvertToBit  [ MAX_CU_SIZE+1 ];
-
+#if !MTK_LOW_LATENCY_IC_ENCODING_H0086_FIX
 #if H_3D_IC
 UInt g_aICEnableCANDIDATE[10] = { 0, };
 UInt g_aICEnableNUM[ 10 ] = { 0, };
 Int g_lastlayer=0;
+#endif
 #endif
 #if ENC_DEC_TRACE
@@ -383 +403 @@
 UInt64 g_nSymbolCounter = 0;
 #if H_MV_ENC_DEC_TRAC
-Bool g_traceCU = true; 
-Bool g_tracePU = true; 
-Bool g_traceTU = true; 
+Bool g_traceCU = false; 
+Bool g_tracePU = false; 
+Bool g_traceTU = false; 
 Bool g_disableHLSTrace = false; 
 UInt64 g_stopAtCounter       = 0; 

trunk/source/Lib/TLibCommon/TComRom.h

@@ -187 +187 @@
 // ==========================================
 
+#if H_MV_HLS_PTL_LIMITS
+class TComGeneralTierAndLevelLimits
+{
+public:
+  TComGeneralTierAndLevelLimits::TComGeneralTierAndLevelLimits
+  ( Int maxLumaPs, 
+    Int maxCPBMainTier, 
+    Int maxCPBHighTier, 
+    Int maxSliceSegmentsPerPicture, 
+    Int maxTileRows, 
+    Int maxTileCols )
+  : m_maxLumaPs                 ( maxLumaPs                     ),
+    m_maxCPBMainTier            ( maxCPBMainTier                ),
+    m_maxCPBHighTier            ( maxCPBHighTier                ),
+    m_maxSliceSegmentsPerPicture( maxSliceSegmentsPerPicture    ),
+    m_maxTileRows               ( maxTileRows                   ),
+    m_maxTileCols               ( maxTileCols                   );
+  {};
+
+  Int getMaxLumaPs                 ( ) { return m_maxLumaPs                 ; };
+  Int getMaxCPBMainTier            ( ) { return m_maxCPBMainTier            ; };
+  Int getMaxCPBHighTier            ( ) { return m_maxCPBHighTier            ; };
+  Int getMaxSliceSegmentsPerPicture( ) { return m_maxSliceSegmentsPerPicture; };
+  Int getMaxTileRows               ( ) { return m_maxTileRows               ; };
+  Int getMaxTileCols               ( ) { return m_maxTileCols               ; };
+
+private:
+  const Int m_maxLumaPs;
+  const Int m_maxCPBMainTier; 
+  const Int m_maxCPBHighTier;
+  const Int m_maxSliceSegmentsPerPicture; 
+  const Int m_maxTileRows; 
+  const Int m_maxTileCols; 
+};
+
+extern std::map< Level::Name, TComGeneralTierAndLevelLimits > g_generalTierAndLevelLimits;   
+
+#endif
 // ====================================================================================================================
 // Misc.
@@ -192 +230 @@
 
 extern       Char   g_aucConvertToBit  [ MAX_CU_SIZE+1 ];   // from width to log2(width)-2
-
+#if !MTK_LOW_LATENCY_IC_ENCODING_H0086_FIX
 #if H_3D_IC
 extern UInt g_aICEnableCANDIDATE[10];
 extern UInt g_aICEnableNUM[ 10 ]; //10 layers
 extern Int  g_lastlayer;
+#endif
 #endif
 

trunk/source/Lib/TLibCommon/TComSlice.cpp

@@ -1 @@
-/* The copyright in this software is being made available under the BSD
+/*  The copyright in this software is being made available under the BSD
  * License, included below. This software may be subject to other third party
  * and contributor rights, including patent rights, and no such rights are
@@ -103 +103 @@
 , m_temporalLayerNonReferenceFlag ( false )
 , m_enableTMVPFlag                ( true )
+#if I0044_SLICE_TMVP
+, m_availableForTMVPRefFlag       ( true )
+#endif
 #if H_MV
 , m_refPicSetInterLayer0           ( NULL )
@@ -725 +728 @@
 
         assert( rpsCurrList[li][ orgIdx ] != NULL ); 
+#if DISCARDABLE_PIC_RPS
+        assert( rpsCurrList[li][ orgIdx ]->getSlice(0)->getDiscardableFlag() == 0 );    // Inter-layer RPS shall not contain picture with discardable_flag = 1.
+#endif
         m_apcRefPicList    [li][rIdx] = rpsCurrList    [li][ orgIdx ];
         m_bIsUsedAsLongTerm[li][rIdx] = usedAsLongTerm [li][ orgIdx ] ; 
@@ -1875 +1881 @@
 #if H_MV
   m_vpsBaseLayerInternalFlag = true; 
+#if H_MV_HLS10_GEN_VSP_BASE_LAYER_AVAIL
+  m_vpsBaseLayerAvailableFlag = true; 
+#endif
 #endif
 
@@ -1900 +1909 @@
   {
     m_layerSetIdxForOlsMinus1[i]  = -1; 
+#if !H_MV_HLS10_PTL
     m_profileLevelTierIdx[i]      = 0; 
+#endif
     for ( Int j = 0; j < MAX_VPS_NUH_LAYER_ID_PLUS1; j++)
     {
+#if H_MV_HLS10_PTL
+#if H_MV_HLS10_PTL_FIX
+      m_profileTierLevelIdx[i][j] = -1; 
+#else
+      m_profileTierLevelIdx[i][j] = false; 
+#endif
+#endif
       m_outputLayerFlag[i][j] = false; 
     }
@@ -1966 +1984 @@
       m_directDependencyFlag[i][j] = false;
       m_directDependencyType[i][j] = -1; 
+#if H_MV_HLS10_REF_PRED_LAYERS
+      m_dependencyFlag  [i][j]    = false; 
+      m_idDirectRefLayer[i][j]    = -1; 
+      m_idPredictedLayer[i][j]    = -1; 
+      m_idRefLayer      [i][j]    = -1; 
+#else
       m_refLayerId[i][j]           = -1; 
+#endif
       m_maxTidIlRefPicsPlus1[i][j]  = 7;
     }
@@ -2050 +2075 @@
   assert( getVpsNumRepFormatsMinus1() <= 255 ); 
 
+#if H_MV_HLS10_ADD_LAYERSETS
+  // The value of num_add_layer_sets shall be in the range of 0 to 1023, inclusive. 
+  assert( getNumAddLayerSets() >= 0 && getNumAddLayerSets() <= 1023 ); 
+#endif
   return true; 
 }
@@ -2081 +2110 @@
 Void TComVPS::setRefLayers()
 {
+
+#if H_MV_HLS10_REF_PRED_LAYERS
+  for( Int i = 0; i  <=  getMaxLayersMinus1(); i++ )
+  {
+    for( Int j = 0; j  <=  getMaxLayersMinus1(); j++ )
+    {
+      m_dependencyFlag[ i ][ j ] = getDirectDependencyFlag( i , j );
+      for( Int k = 0; k < i; k++ )
+      {
+        if( getDirectDependencyFlag(i , k )  &&  m_dependencyFlag[k][j] )
+        {
+          m_dependencyFlag[ i ][ j ] = true;
+        }
+      }
+    }
+  }
+
+  for( Int i = 0; i  <=  getMaxLayersMinus1(); i++ )
+  {
+    Int iNuhLId = getLayerIdInNuh( i );
+    Int d = 0;
+    Int r = 0;
+    Int p = 0;
+    for( Int j = 0; j  <=  getMaxLayersMinus1(); j++ )
+    {
+      Int jNuhLid = getLayerIdInNuh( j );
+      if( getDirectDependencyFlag( i , j ) )
+      {
+        m_idDirectRefLayer[iNuhLId][d++] = jNuhLid;
+      }
+      if( getDependencyFlag( i , j ) )
+      {
+        m_idRefLayer      [iNuhLId][r++] = jNuhLid;
+      }
+      if( getDependencyFlag( j , i ) )
+      {
+        m_idPredictedLayer[iNuhLId][p++] = jNuhLid;
+      }
+    }
+    m_numDirectRefLayers[ iNuhLId ] = d;
+    m_numRefLayers      [ iNuhLId ] = r;
+    m_numPredictedLayers[ iNuhLId ] = p;
+  }
+  
+  Bool layerIdInListFlag[ 64 ]; 
+  for( Int i = 0; i  <=  63; i++ )
+  {
+    layerIdInListFlag[ i ] = 0;
+  }
+
+  Int k = 0; 
+  for( Int i = 0; i  <=  getMaxLayersMinus1(); i++ )
+  {
+    Int iNuhLId = getLayerIdInNuh( i );
+    if( getNumDirectRefLayers( iNuhLId )  ==  0 )
+    {
+      m_treePartitionLayerIdList[ k ][ 0 ] = iNuhLId;
+      Int h = 1;  
+      for( Int j = 0; j < getNumPredictedLayers( iNuhLId ); j++ )  
+      {
+        Int predLId = getIdPredictedLayer( iNuhLId, j );
+        if ( !layerIdInListFlag[ predLId ] )
+        {
+          m_treePartitionLayerIdList[ k ][ h++ ] = predLId;
+          layerIdInListFlag[ predLId ] = 1; 
+        }          
+      }
+      m_numLayersInTreePartition[ k++ ] = h;
+    }
+  }
+  m_numIndependentLayers = k;
+#else // H_MV_HLS10_GEN
+
   for( Int i = 0; i  <= getMaxLayersMinus1(); i++ )
   {
@@ -2116 +2218 @@
     }
   }
-
+  
   for( Int i = 0; i <= getMaxLayersMinus1(); i++ )  // Bug in spec "<" instead of "<=" 
   {
@@ -2136 +2238 @@
     countedLayerIdxFlag[ i ] = 0;
   }
- 
   for( Int i = 0, k = 0; i  <=  getMaxLayersMinus1(); i++ )
   {
@@ -2144 +2245 @@
       m_treePartitionLayerIdList[ k ][ 0 ] = iNuhLId;
       m_numLayersInTreePartition[ k ]      = 1;
+
       for( Int j = 0; j < m_numPredictedLayers[ iNuhLId ]; j++ )  
       {
@@ -2154 +2256 @@
       }
       k++;
-    }
-    m_numIndependentLayers = k;
-  }
-}
-
+
+      m_numIndependentLayers = k;
+    }
+  }
+#endif // H_MV_HLS10_GEN
+}
+
+#if !H_MV_HLS10_REF_PRED_LAYERS
 Int TComVPS::getRefLayerId( Int layerIdInNuh, Int idx )
 {
@@ -2166 +2271 @@
   return refLayerIdInNuh;
 }
+#endif
 
 Int TComVPS::getScalabilityId( Int layerIdInVps, ScalabilityType scalType )
@@ -2203 +2309 @@
   for ( i = 0; i < iNumViews ; i++ )
   {
+#if H_3D_FIX_UNINIT
+    m_bCamParPresent[i] = false; 
+#endif
     m_bCamParInSliceHeader[i] = false; 
     m_aaaiCodedScale[i] = new Int*[ 2 ];
@@ -2315 +2424 @@
 {
   assert( lsIdx >= 0 ); 
+#if H_MV_HLS10_ADD_LAYERSETS
+  assert( lsIdx <= getNumLayerSets() ); 
+#else
   assert( lsIdx <= getVpsNumLayerSetsMinus1() ); 
+#endif
   return (Int) m_layerSetLayerIdList[ lsIdx ].size(); 
 }
@@ -2339 +2452 @@
 }
 
+#if !H_MV_HLS10_REF_PRED_LAYERS
 Bool TComVPS::getInDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Int depth /*= 0 */ )
 {
+#if H_MV_HLS10_REF_PRED_LAYERS
+  // TBD: Remove getInDirectDependencyFlag entirely.
+  return getDependencyFlag( depLayeridInVps, refLayeridInVps );
+#else
   assert( depth < 65 ); 
   Bool dependentFlag = getDirectDependencyFlag( depLayeridInVps, refLayeridInVps ); 
@@ -2352 +2470 @@
   }
   return dependentFlag;
-}
+#endif
+}
+#endif
 
 Void TComVPS::deriveLayerSetLayerIdList()
@@ -2378 +2498 @@
 {  
   Int lsIdx = olsIdxToLsIdx( i );     
-  
+
   for( Int j = 0; j < getNumLayersInIdList( lsIdx ); j++ )
   {
-    m_targetDecLayerIdLists[i].push_back( m_layerSetLayerIdList[ lsIdx ][ j ] ); 
+#if H_MV_HLS10_NESSECARY_LAYER
+    if ( getNecessaryLayerFlag( i , j ))
+    {
+#endif
+      m_targetDecLayerIdLists[i].push_back( m_layerSetLayerIdList[ lsIdx ][ j ] ); 
+#if H_MV_HLS10_NESSECARY_LAYER
+    }
+#endif
+
     if( getOutputLayerFlag( i, j  ))
     {
@@ -2429 +2557 @@
 }
 
+#if !H_MV_HLS10_ADD_LAYERSETS
 Void TComVPS::inferDbpSizeLayerSetZero( TComSPS* sps, Bool encoder )
 {
@@ -2451 +2580 @@
   }
 }
-
+#endif
 Bool TComVPS::getAltOutputLayerFlagVar( Int i )
 {
@@ -2465 +2594 @@
 }
 
+#if !H_MV_HLS10_MAXNUMPICS
 Int TComVPS::getMaxNumPics( Int layerId )
 {
@@ -2483 +2613 @@
   return maxNumPics;
 }
-
+#endif
+
+#if !H_MV_HLS10_REF_PRED_LAYERS
 Void TComVPS::xSetRefLayerFlags( Int currLayerId )
 {
@@ -2496 +2628 @@
   }
 }
+
+#endif
+
+#if H_MV_HLS10_PTL_FIX
+Int TComVPS::inferProfileTierLevelIdx(Int i, Int j)
+{
+  Bool inferZero        = ( i == 0 && j == 0 &&  getVpsBaseLayerInternalFlag() );
+  Bool inferGreaterZero = getNecessaryLayerFlag(i,j) && ( getVpsNumProfileTierLevelMinus1() == 0 ); 
+  assert( inferZero || inferGreaterZero );
+
+  Bool ptlIdx = 0; // inference for greaterZero
+  if ( inferZero )
+  {
+    ptlIdx = getMaxLayersMinus1() > 0 ? 1 : 0; 
+    if ( inferGreaterZero )
+    {
+      assert( ptlIdx == 0 );  
+      // This should never happen since :
+      // When vps_max_layers_minus1 is greater than 0, the value of vps_num_profile_tier_level_minus1 shall be greater than or equal to 1.
+    }
+  }
+  return ptlIdx;
+}
+#endif
+
+#if H_MV_HLS10_ADD_LAYERSETS
+Void TComVPS::deriveAddLayerSetLayerIdList(Int i)
+{
+  assert( m_layerSetLayerIdList.size() ==  ( getVpsNumLayerSetsMinus1() + 1 + i ) ); 
+  std::vector<Int> layerSetLayerIdList;
+
+  for( Int treeIdx = 1; treeIdx < getNumIndependentLayers(); treeIdx++ )
+  { 
+    // The value of highest_layer_idx_plus1[ i ][ j ] shall be in the range of 0 to NumLayersInTreePartition[ j ], inclusive.
+    assert( getHighestLayerIdxPlus1( i, treeIdx ) >= 0 && getHighestLayerIdxPlus1( i, treeIdx ) <= getNumLayersInTreePartition( treeIdx ) );
+
+    for( Int layerCnt = 0; layerCnt < getHighestLayerIdxPlus1( i, treeIdx ); layerCnt++ )
+    {
+      layerSetLayerIdList.push_back( getTreePartitionLayerIdList( treeIdx, layerCnt ) );
+    }
+  }
+  m_layerSetLayerIdList.push_back( layerSetLayerIdList ); 
+
+  //It is a requirement of bitstream conformance that 
+  //NumLayersInIdList[ vps_num_layer_sets_minus1 + 1 + i ] shall be greater than 0.
+  assert( getNumLayersInIdList( getVpsNumLayerSetsMinus1() + 1 + i ) > 0 );
+}
+
+#endif
+
+#if H_MV_HLS10_NESSECARY_LAYER
+Void TComVPS::deriveNecessaryLayerFlags(Int olsIdx)
+{
+  AOF( olsIdx >= 0 && olsIdx < getNumOutputLayerSets() ); 
+  Int lsIdx = olsIdxToLsIdx( olsIdx );
+  for( Int lsLayerIdx = 0; lsLayerIdx < getNumLayersInIdList( lsIdx) ; lsLayerIdx++ )
+  {
+    m_necessaryLayerFlag[ olsIdx ][ lsLayerIdx ] = 0;
+  }
+  for( Int lsLayerIdx = 0; lsLayerIdx < getNumLayersInIdList( lsIdx ); lsLayerIdx++ )
+  {
+    if( getOutputLayerFlag( olsIdx, lsLayerIdx  ))
+    {
+      m_necessaryLayerFlag[ olsIdx ][ lsLayerIdx ] = 1;
+      Int currLayerId = getLayerSetLayerIdList( lsIdx, lsLayerIdx );
+      for( Int rLsLayerIdx = 0; rLsLayerIdx < lsLayerIdx; rLsLayerIdx++ )
+      {
+        Int refLayerId = getLayerSetLayerIdList( lsIdx, rLsLayerIdx );
+        if( getDependencyFlag( getLayerIdInVps( currLayerId ), getLayerIdInVps( refLayerId ) ) )
+        {
+          m_necessaryLayerFlag[ olsIdx ][ rLsLayerIdx ] = 1;
+        }
+      }
+    }
+  }
+  m_numNecessaryLayers[ olsIdx ] = 0;
+  for( Int lsLayerIdx = 0; lsLayerIdx < getNumLayersInIdList( lsIdx ); lsLayerIdx++ ) 
+  {
+    m_numNecessaryLayers[ olsIdx ]  +=  m_necessaryLayerFlag[ olsIdx ][ lsLayerIdx ];
+  }
+}
+#endif
+
+#if H_MV_HLS10_ADD_LAYERSETS
+Void TComVPS::printPTL()
+{
+  std::vector<Int> idx; 
+  std::vector<Int> num; 
+  std::vector< std::vector<Int> > ptlInfo; 
+
+  std::cout << std::right << std::setw(60) << std::setfill('-') << " " << std::setfill(' ') << std::endl << "PTLI" << std::endl; 
+
+  for ( Int i = 0; i <= getVpsNumProfileTierLevelMinus1(); i++ )
+  {
+    std::vector<Int> curPtlInfo;
+    ProfileTierLevel* ptl = getPTL( i )->getGeneralPTL(); 
+    curPtlInfo.push_back( (Int) ptl->getProfileIdc()  );
+    curPtlInfo.push_back( (Int) ptl->getTierFlag()    );
+    curPtlInfo.push_back( (Int) ptl->getLevelIdc()    );
+    curPtlInfo.push_back( (Int) ptl->getInbldFlag()   );
+
+    idx.push_back ( i );
+    num.push_back ( 4 ); 
+    ptlInfo.push_back( curPtlInfo );
+  } 
+
+  xPrintArray( "VpsProfileTierLevel", getVpsNumProfileTierLevelMinus1() + 1, idx, num, ptlInfo, false  ); 
+
+  num.clear(); 
+  idx.clear(); 
+  for (Int i = 0; i < getNumOutputLayerSets(); i++)
+  {
+    num.push_back ( getNumLayersInIdList( olsIdxToLsIdx( i ))  ); 
+    idx.push_back( i ); 
+  }
+
+  xPrintArray( "profile_tier_level_idx", getNumOutputLayerSets(), idx, num, m_profileTierLevelIdx, true );
+  std::cout << std::endl;
+}
+
+Void TComVPS::printLayerDependencies()
+{
+  vector<Int> fullArray;
+  vector<Int> range; 
+
+#if H_3D
+  vector<Int> depthId; 
+#endif
+
+#if H_MV_HLS10_AUX
+  vector<Int> viewOrderIndex;
+  vector<Int> auxId;
+  vector<Int> dependencyId; 
+  vector<Int> viewId; 
+#endif
+  for (Int i = 0; i <= getMaxLayersMinus1(); i++ )
+  {
+    fullArray.push_back( getMaxLayersMinus1() + 1 ); 
+    range.push_back( i ); 
+#if H_MV_HLS10_AUX      
+    viewOrderIndex.push_back( getViewIndex   ( i ) );
+    dependencyId  .push_back( getDependencyId( i ) );
+    auxId         .push_back( getAuxId       ( i ) );      
+    viewId        .push_back( getViewId      ( getLayerIdInNuh( i ) ) );
+#if H_3D  
+    depthId.push_back( getDepthId( i ) );
+#endif
+#endif
+  }
+  std::cout << std::right << std::setw(60) << std::setfill('-') << " " << std::setfill(' ') << std::endl << "Layer Dependencies" << std::endl; 
+  xPrintArray( "direct_dependency_flag", getMaxLayersMinus1()+1, range, fullArray, m_directDependencyFlag, false ); 
+  xPrintArray( "DependencyFlag", getMaxLayersMinus1()+1, range, fullArray, m_dependencyFlag, false ); 
+  xPrintArray( "layer_id_in_nuh", getMaxLayersMinus1()+1, m_layerIdInNuh, true  );     
+  xPrintArray( "IdPredictedLayer", getMaxLayersMinus1() + 1, m_layerIdInNuh, m_numPredictedLayers, m_idPredictedLayer, true );
+  xPrintArray( "IdRefLayer"      , getMaxLayersMinus1() + 1, m_layerIdInNuh, m_numRefLayers, m_idRefLayer, true );
+  xPrintArray( "IdDirectRefLayer", getMaxLayersMinus1() + 1, m_layerIdInNuh, m_numDirectRefLayers, m_idDirectRefLayer, true );
+  std::cout << std::endl;
+}
+
+#if H_MV_HLS10_AUX
+Void TComVPS::printScalabilityId()
+{
+  vector<Int> layerIdxInVps; 
+
+#if H_3D
+  vector<Int> depthId; 
+#endif
+
+  vector<Int> viewOrderIndex;
+  vector<Int> auxId;
+  vector<Int> dependencyId; 
+  vector<Int> viewId; 
+
+  for (Int i = 0; i <= getMaxLayersMinus1(); i++ )
+  {
+    Int layerIdInNuh = getLayerIdInNuh( i );
+    layerIdxInVps  .push_back( i ); 
+    viewOrderIndex.push_back( getViewIndex   ( layerIdInNuh ) );
+    dependencyId  .push_back( getDependencyId( layerIdInNuh ) );
+    auxId         .push_back( getAuxId       ( layerIdInNuh ) );      
+    viewId        .push_back( getViewId      ( layerIdInNuh ) );
+#if H_3D  
+    depthId       .push_back( getDepthId     ( layerIdInNuh ) );
+#endif
+  }
+
+  std::cout << std::right << std::setw(60) << std::setfill('-') << " " << std::setfill(' ') << std::endl << "Scalability Ids" << std::endl; 
+  xPrintArray( "layerIdxInVps"  , getMaxLayersMinus1()+1, layerIdxInVps,          false );
+  xPrintArray( "layer_id_in_nuh", getMaxLayersMinus1()+1, m_layerIdInNuh, false );     
+
+  xPrintArray( "ViewOrderIndex", getMaxLayersMinus1()+1, viewOrderIndex, false );     
+  xPrintArray( "DependencyId"  , getMaxLayersMinus1()+1, dependencyId  , false );     
+  xPrintArray( "AuxId"         , getMaxLayersMinus1()+1, auxId         , false );     
+  xPrintArray( "ViewId"        , getMaxLayersMinus1()+1, viewId        , false );     
+
+  std::cout << std::endl;
+}
+#endif
+
+Void TComVPS::printLayerSets()
+{
+  vector<Int> fullArray;
+  vector<Int> numLayersInIdList; 
+  vector<Int> rangeLayerSets; 
+
+
+  for (Int i = 0; i < getNumLayerSets(); i++ )
+  {
+    numLayersInIdList.push_back( getNumLayersInIdList( i ) );       
+    rangeLayerSets.push_back( i ); 
+  }
+
+  vector<Int> rangeOutputLayerSets; 
+  vector<Int> numOutputLayersInOutputLayerSet; 
+  vector<Int> numDecLayer; 
+  vector<Int> numLayersInLayerSetForOutputLayerSet; 
+  vector<Int> vOlsIdxToLsIdx;
+  for (Int i = 0; i < getNumOutputLayerSets(); i++ )
+  {
+    vOlsIdxToLsIdx.push_back( olsIdxToLsIdx(i));
+    numOutputLayersInOutputLayerSet.push_back( getNumOutputLayersInOutputLayerSet( i ) );       
+    numDecLayer.push_back( (Int) m_targetDecLayerIdLists[ i ].size() );
+    rangeOutputLayerSets.push_back( i ); 
+    numLayersInLayerSetForOutputLayerSet.push_back( getNumLayersInIdList( olsIdxToLsIdx( i ) ) );
+  }
+
+  vector<Int> rangeIndependentLayers;
+  for(Int i = 0; i < getNumIndependentLayers(); i++ )
+  {
+    rangeIndependentLayers.push_back( i );    
+  }
+
+  vector<Int> rangeAddLayerSets;
+  vector<Int> numHighestLayerIdxPlus1; 
+  for(Int i = 0; i < getNumAddLayerSets(); i++ )
+  {
+    rangeAddLayerSets.push_back( i );    
+    numHighestLayerIdxPlus1.push_back( getNumIndependentLayers() );
+  }
+
+  std::cout << std::right << std::setw(60) << std::setfill('-') << " " << std::setfill(' ') << std::endl << "Layer Sets" << std::endl;     
+  xPrintArray( "TreePartitionLayerIdList", getNumIndependentLayers(), rangeIndependentLayers, m_numLayersInTreePartition, m_treePartitionLayerIdList, true );
+  xPrintArray( "highest_layer_idx_plus1", getNumAddLayerSets(), rangeAddLayerSets, numHighestLayerIdxPlus1, m_highestLayerIdxPlus1, true ); 
+  xPrintArray( "LayerSetLayerIdList" , (Int) getNumLayerSets()      , rangeLayerSets      , numLayersInIdList, m_layerSetLayerIdList, true );
+  xPrintArray( "OlsIdxToLsIdx", (Int) vOlsIdxToLsIdx.size(), vOlsIdxToLsIdx, true ); 
+  xPrintArray( "OutputLayerFlag"     , getNumOutputLayerSets(), rangeOutputLayerSets, numLayersInLayerSetForOutputLayerSet, m_outputLayerFlag, true );
+  xPrintArray( "TargetOptLayerIdList", getNumOutputLayerSets(), rangeOutputLayerSets, numOutputLayersInOutputLayerSet, m_targetOptLayerIdLists, true );
+  xPrintArray( "NecessaryLayerFlag"  , getNumOutputLayerSets(), rangeOutputLayerSets, numLayersInLayerSetForOutputLayerSet, m_necessaryLayerFlag   , true );
+  xPrintArray( "TargetDecLayerIdList", getNumOutputLayerSets(), rangeOutputLayerSets, numDecLayer,                     m_targetDecLayerIdLists, true );
+  std::cout << endl;
+}
+
+#endif
 
 #endif // H_MV
@@ -2579 +2964 @@
 #endif
 
+#if !H_MV_HLS10_PPS
   m_numScaledRefLayerOffsets = 0; 
 
@@ -2590 +2976 @@
     m_scaledRefLayerLeftOffset     [i] = 0;
     m_scaledRefLayerTopOffset      [i] = 0;
-    m_scaledRefLayerRightOffset    [i] = 0;
+    m_scaledRefLayerRiFghtOffset    [i] = 0;
     m_scaledRefLayerBottomOffset   [i] = 0;
   }
+#endif
 #endif
 }
@@ -2967 +3354 @@
 Void TComSPS::inferRepFormat( TComVPS* vps, Int layerIdCurr )
 {
+#if H_MV_HLS10_MULTILAYERSPS
+  if ( getMultiLayerExtSpsFlag() )
+#else
   if ( layerIdCurr > 0 )
+#endif
   { 
     Int            repFormatIdx = getUpdateRepFormatFlag() ?  getSpsRepFormatIdx() : vps->getVpsRepFormatIdx( vps->getLayerIdInVps( layerIdCurr ) ) ;
     TComRepFormat* repFormat    = vps->getRepFormat( repFormatIdx ); 
-      setChromaFormatIdc( repFormat->getChromaFormatVpsIdc() );         
-      //// ToDo: add when supported: 
-      // setSeperateColourPlaneFlag( repFormat->getSeparateColourPlaneVpsFlag() ) ; 
-
-      setPicWidthInLumaSamples ( repFormat->getPicWidthVpsInLumaSamples()  ); 
-      setPicHeightInLumaSamples( repFormat->getPicHeightVpsInLumaSamples() ); 
-
-      setBitDepthY             ( repFormat->getBitDepthVpsLumaMinus8()   + 8 ); 
-      setQpBDOffsetY           ( (Int) (6*( getBitDepthY() - 8 )) );
-
-      setBitDepthC             ( repFormat->getBitDepthVpsChromaMinus8() + 8 ); 
-      setQpBDOffsetC           ( (Int) (6* ( getBitDepthC() -8 ) ) );
-    if ( getLayerId() > 0 && getUpdateRepFormatFlag() )
+    setChromaFormatIdc( repFormat->getChromaFormatVpsIdc() );         
+    //// ToDo: add when supported: 
+    // setSeperateColourPlaneFlag( repFormat->getSeparateColourPlaneVpsFlag() ) ; 
+
+    setPicWidthInLumaSamples ( repFormat->getPicWidthVpsInLumaSamples()  ); 
+    setPicHeightInLumaSamples( repFormat->getPicHeightVpsInLumaSamples() ); 
+
+    setBitDepthY             ( repFormat->getBitDepthVpsLumaMinus8()   + 8 ); 
+    setQpBDOffsetY           ( (Int) (6*( getBitDepthY() - 8 )) );
+
+    setBitDepthC             ( repFormat->getBitDepthVpsChromaMinus8() + 8 ); 
+    setQpBDOffsetC           ( (Int) (6* ( getBitDepthC() -8 ) ) );
+ #if H_MV_HLS10_GEN_VSP_CONF_WIN
+    Window &spsConf    = getConformanceWindow();    
+
+    // Scaled later
+    spsConf.setScaledFlag( false ); 
+    spsConf.setWindowLeftOffset  ( repFormat->getConfWinVpsLeftOffset()    );
+    spsConf.setWindowRightOffset ( repFormat->getConfWinVpsRightOffset()   );
+    spsConf.setWindowTopOffset   ( repFormat->getConfWinVpsTopOffset()     );
+    spsConf.setWindowBottomOffset( repFormat->getConfWinVpsBottomOffset()  );    
+#endif
+
+#if H_MV_HLS10_MULTILAYERSPS
+   if ( getMultiLayerExtSpsFlag() && getUpdateRepFormatFlag() )
+#else 
+   if ( getLayerId() > 0 && getUpdateRepFormatFlag() )
+#endif
     {
       assert( getChromaFormatIdc()      <=  repFormat->getChromaFormatVpsIdc()         ); 
@@ -3017 +3423 @@
   const std::vector<Int>& targetDecLayerIdList = vps->getTargetDecLayerIdList( vps->olsIdxToLsIdx( targetOptLayerSetIdx )); 
 
+#if H_MV_HLS10_MULTILAYERSPS
+  if ( getMultiLayerExtSpsFlag() )
+#else
   if (getLayerId() > 0 )
+#endif
   {
     Int layerIdx = 0;         
@@ -3035 +3445 @@
       Int maxDecPicBufferingMinus1 = vps->getDpbSize()->getMaxVpsDecPicBufferingMinus1( targetOptLayerSetIdx, layerIdx, i ) ; 
 
-      if ( encoder )
+#if H_MV_HLS10_MULTILAYERSPS
+      // This preliminary fix needs to be checked.
+      Int maxNumReorderPics       = vps->getDpbSize()->getMaxVpsNumReorderPics( targetOptLayerSetIdx, i ); 
+      Int maxLatencyIncreasePlus1 = vps->getDpbSize()->getMaxVpsLatencyIncreasePlus1( targetOptLayerSetIdx, i ); 
+#endif
+      if ( encoder )      
       {
         assert( getMaxDecPicBuffering( i ) - 1 == maxDecPicBufferingMinus1 ); 
+#if H_MV_HLS10_MULTILAYERSPS
+        // This preliminary fix needs to be checked.
+        assert( getNumReorderPics( i )     == maxNumReorderPics       ); 
+        assert( getMaxLatencyIncrease( i ) == maxLatencyIncreasePlus1 ); 
+#endif    
+
       }
       else
       {
+#if !H_MV_HLS10_MULTILAYERSPS
         setMaxDecPicBuffering(i, maxDecPicBufferingMinus1 + 1 ); 
-      }
-    }
+#else
+        // This preliminary fix needs to be checked.
+        setMaxDecPicBuffering( maxDecPicBufferingMinus1 + 1 , i); 
+        setNumReorderPics    ( maxNumReorderPics, i );
+        setMaxLatencyIncrease( maxLatencyIncreasePlus1 - 1 , i); 
+#endif
+      }
+    }    
   }
 }
@@ -3049 +3477 @@
 Void TComSPS::checkRpsMaxNumPics( TComVPS* vps, Int currLayerId )
 {
+#if !H_MV_HLS10_MAXNUMPICS
   // In spec, when rps is in SPS, nuh_layer_id of SPS is used instead 
   // of nuh_layer_id of slice (currLayerId), this seems to be a bug.
-
+#endif
   for (Int i = 0; i < getRPSList()->getNumberOfReferencePictureSets(); i++ )
   {
@@ -3057 +3486 @@
     if ( !rps->getInterRPSPrediction() )
     {
+#if H_MV_HLS10_MAXNUMPICS
+      rps->checkMaxNumPics( vps->getVpsExtensionFlag(), MAX_INT, getLayerId(), getMaxDecPicBuffering( getSpsMaxSubLayersMinus1() ) - 1 );   // INT_MAX to be replaced by DpbSize
+#else
       rps->checkMaxNumPics( vps->getVpsExtensionFlag(), vps->getMaxNumPics( currLayerId ), 
         getLayerId(), getMaxDecPicBuffering( getSpsMaxSubLayersMinus1() ) - 1 );  
-    }
-  }
-}
-
+#endif
+    }
+  }
+}
+
+#if H_MV_HLS10_MULTILAYERSPS
+Void TComSPS::inferSpsMaxSubLayersMinus1(Bool atPsActivation, TComVPS* vps)
+{
+  assert( getLayerId() != 0 ); 
+  if ( !atPsActivation   )
+  {
+    assert( vps == NULL );
+    if (getSpsExtOrMaxSubLayersMinus1() != 7)
+    {
+      setSpsMaxSubLayersMinus1( getSpsExtOrMaxSubLayersMinus1() );
+    }
+  }
+  else
+  {
+    assert( vps != NULL );
+    if (getSpsExtOrMaxSubLayersMinus1() == 7)
+    {
+      setSpsMaxSubLayersMinus1( vps->getMaxSubLayersMinus1() );
+    }
+  }
+}
+#endif
 #endif
 
@@ -3425 +3880 @@
 {
   TComVPS* vps = getVPS(); 
+#if H_MV_HLS10_REF_PRED_LAYERS
+  Int refLayerIdx = vps->getLayerIdInVps( vps->getIdDirectRefLayer( getLayerId(), i ) ); 
+#else
   Int refLayerIdx = vps->getLayerIdInVps( vps->getRefLayerId( getLayerId(), i ) ); 
+#endif
 
   Bool refLayerPicFlag = ( vps->getSubLayersVpsMaxMinus1( refLayerIdx ) >=  getTLayer() )  && ( getTLayer() == 0  ) &&
@@ -3496 +3955 @@
 Int TComSlice::getRefPicLayerId( Int i )
 {
+#if H_MV_HLS10_REF_PRED_LAYERS
+  return getVPS()->getIdDirectRefLayer( getLayerId(), getInterLayerPredLayerIdc( i ) );
+#else
   return getVPS()->getRefLayerId( getLayerId(), getInterLayerPredLayerIdc( i ) );
+#endif
 }
 
@@ -3602 +4065 @@
       m_bApplyIC = true;
       Int refLayer = curLayer-1;
-      if( (refLayer>=0) && (g_aICEnableCANDIDATE[refLayer]>0) )
+#if MTK_LOW_LATENCY_IC_ENCODING_H0086_FIX
+      Int ICEnableCandidate = getICEnableCandidate(refLayer);
+      Int ICEnableNum = getICEnableNum(refLayer);
+      if( (refLayer>=0) && (ICEnableCandidate>0) )
       {    
-        Double ratio=Double(g_aICEnableNUM[refLayer])/Double(g_aICEnableCANDIDATE[refLayer]);
+        Double ratio=Double(ICEnableNum/Double(ICEnableCandidate));
 
         if( ratio > IC_LOW_LATENCY_ENCODING_THRESHOLD)
-{
+        {
           m_bApplyIC=true;
         }
@@ -3615 +4081 @@
         }
       }
+      setICEnableCandidate(curLayer, 0);
+      setICEnableNum(curLayer, 0);
+#else
+      if( (refLayer>=0) && (g_aICEnableCANDIDATE[refLayer]>0) )
+      {    
+        Double ratio=Double(g_aICEnableNUM[refLayer])/Double(g_aICEnableCANDIDATE[refLayer]);
+
+        if( ratio > IC_LOW_LATENCY_ENCODING_THRESHOLD)
+{
+          m_bApplyIC=true;
+        }
+        else
+        {
+          m_bApplyIC=false;
+        }
+      }
       g_aICEnableNUM[curLayer]=0;
       g_aICEnableCANDIDATE[curLayer]=0;
       g_lastlayer=getDepth();
+#endif
     }
   }
@@ -3727 +4210 @@
 
 #if H_3D_DDD
+#if LGE_FCO_I0116
+  if( getIsDepth() && getViewIndex() > 0 && getVPS()->getMPIFlag(layerIdInVPS))
+#else
   if( getIsDepth() && getViewIndex() > 0 )
+#endif
   {
       TComSlice *pcTextSlice = getTexturePic()->getSlice( 0 );
@@ -4209 +4696 @@
 , m_nonPackedConstraintFlag(false)
 , m_frameOnlyConstraintFlag(false)
+#if H_MV_HLS10_PTL
+  , m_max12bitConstraintFlag      ( false )
+  , m_max10bitConstraintFlag      ( false )
+  , m_max8bitConstraintFlag       ( false )
+  , m_max422chromaConstraintFlag  ( false )
+  , m_max420chromaConstraintFlag  ( false )
+  , m_maxMonochromeConstraintFlag ( false )
+  , m_intraConstraintFlag         ( false )
+  , m_onePictureOnlyConstraintFlag( false )
+  , m_lowerBitRateConstraintFlag  ( false )
+  , m_inbldFlag                   ( false )
+#endif
 {
   ::memset(m_profileCompatibilityFlag, 0, sizeof(m_profileCompatibilityFlag));
 }
+
+#if H_MV_HLS10_PTL_INFER_FIX
+Bool ProfileTierLevel::getV2ConstraintsPresentFlag()
+{
+  return ( 
+    getProfileIdc( ) ==  4 || getProfileCompatibilityFlag( 4 ) || getProfileIdc( ) ==  5 || getProfileCompatibilityFlag( 5 )  ||
+    getProfileIdc( ) ==  6 || getProfileCompatibilityFlag( 6 ) || getProfileIdc( ) ==  7 || getProfileCompatibilityFlag( 7 ) 
+    );
+}
+
+Bool ProfileTierLevel::getInbldPresentFlag()
+{
+  return ( 
+    ( getProfileIdc() >= 1 && getProfileIdc() <= 5 )  || getProfileCompatibilityFlag( 1 ) || getProfileCompatibilityFlag( 2 ) || 
+    getProfileCompatibilityFlag( 3 ) || getProfileCompatibilityFlag( 4 )  ||   getProfileCompatibilityFlag( 5 ) 
+    );
+}
+
+Void ProfileTierLevel::copyV2ConstraintFlags(ProfileTierLevel* ptlRef)
+{
+  setMax12bitConstraintFlag         ( ptlRef->getMax12bitConstraintFlag       ( ) );
+  setMax10bitConstraintFlag         ( ptlRef->getMax10bitConstraintFlag       ( ) );
+  setMax8bitConstraintFlag          ( ptlRef->getMax8bitConstraintFlag        ( ) );
+  setMax422chromaConstraintFlag     ( ptlRef->getMax422chromaConstraintFlag   ( ) );
+  setMax420chromaConstraintFlag     ( ptlRef->getMax420chromaConstraintFlag   ( ) );
+  setMaxMonochromeConstraintFlag    ( ptlRef->getMaxMonochromeConstraintFlag  ( ) );
+  setIntraConstraintFlag            ( ptlRef->getIntraConstraintFlag          ( ) );
+  setOnePictureOnlyConstraintFlag   ( ptlRef->getOnePictureOnlyConstraintFlag ( ) );
+  setLowerBitRateConstraintFlag     ( ptlRef->getLowerBitRateConstraintFlag   ( ) );
+}
+
+Void ProfileTierLevel::copyProfile(ProfileTierLevel* ptlRef)
+{
+  setProfileSpace            ( ptlRef->getProfileSpace              ( ) );
+  setTierFlag                ( ptlRef->getTierFlag                  ( ) );
+  setProfileIdc              ( ptlRef->getProfileIdc                ( ) );
+  for (Int j = 0; j < 32; j++)
+  {      
+    setProfileCompatibilityFlag(j, ptlRef->getProfileCompatibilityFlag  ( j ) );            
+  }
+  setProgressiveSourceFlag   ( ptlRef->getProgressiveSourceFlag     ( ) );
+  setInterlacedSourceFlag    ( ptlRef->getInterlacedSourceFlag      ( ) );
+  setNonPackedConstraintFlag ( ptlRef->getNonPackedConstraintFlag   ( ) );
+  setFrameOnlyConstraintFlag ( ptlRef->getFrameOnlyConstraintFlag   ( ) );
+  copyV2ConstraintFlags      ( ptlRef );
+}
+
+#endif
 
 TComPTL::TComPTL()
@@ -4220 +4767 @@
 
 #if H_MV
+#if !H_MV_HLS10_PTL_INFER_FIX
 Void TComPTL::copyLevelFrom( TComPTL* source )
 {
@@ -4229 +4777 @@
   }
 }
+#else
+Void TComPTL::inferGeneralValues(Bool profilePresentFlag, Int k, TComPTL* refPTL)
+{
+  ProfileTierLevel* refProfileTierLevel = NULL; 
+  if ( k > 0 )
+  {    
+    assert( refPTL != NULL);
+    refProfileTierLevel = refPTL->getGeneralPTL(); 
+  }
+
+  ProfileTierLevel* curProfileTierLevel = getGeneralPTL( ); 
+
+  if( !profilePresentFlag )
+  {
+    assert( k > 0 ); 
+    assert( refProfileTierLevel != NULL ); 
+    curProfileTierLevel->copyProfile( refProfileTierLevel);
+  }
+  else
+  {
+    if ( !curProfileTierLevel->getV2ConstraintsPresentFlag() )
+    {
+      curProfileTierLevel->setMax12bitConstraintFlag         ( false );
+      curProfileTierLevel->setMax10bitConstraintFlag         ( false );
+      curProfileTierLevel->setMax8bitConstraintFlag          ( false );
+      curProfileTierLevel->setMax422chromaConstraintFlag     ( false );
+      curProfileTierLevel->setMax420chromaConstraintFlag     ( false );
+      curProfileTierLevel->setMaxMonochromeConstraintFlag    ( false );
+      curProfileTierLevel->setIntraConstraintFlag            ( false );
+      curProfileTierLevel->setOnePictureOnlyConstraintFlag   ( false );
+      curProfileTierLevel->setLowerBitRateConstraintFlag     ( false );   
+    }
+
+    if ( !curProfileTierLevel->getInbldPresentFlag() )
+    {
+      curProfileTierLevel->setInbldFlag( false ); 
+    }      
+  }
+}
+
+Void TComPTL::inferSubLayerValues(Int maxNumSubLayersMinus1, Int k, TComPTL* refPTL)
+{
+  assert( k == 0 || refPTL != NULL ); 
+
+  for (Int i = maxNumSubLayersMinus1; i >= 0; i--)
+  {
+    ProfileTierLevel* refProfileTierLevel;
+    if ( k != 0 )
+    {
+      refProfileTierLevel = refPTL->getSubLayerPTL( i );
+    }
+    else
+    {
+      if ( i == maxNumSubLayersMinus1)      
+      {
+        refProfileTierLevel = getGeneralPTL();
+      }
+      else
+      {
+        refProfileTierLevel = getSubLayerPTL( i + 1 );
+      }
+    }    
+
+    ProfileTierLevel* curProfileTierLevel = getSubLayerPTL( i ); 
+    if( !getSubLayerLevelPresentFlag( i ) )
+    {
+      curProfileTierLevel->setLevelIdc( refProfileTierLevel->getLevelIdc() ); 
+    }
+
+    if( !getSubLayerProfilePresentFlag( i ) )
+    {
+      curProfileTierLevel->copyProfile( refProfileTierLevel);
+    }
+    else
+    {
+      if ( !curProfileTierLevel->getV2ConstraintsPresentFlag() )
+      {
+        curProfileTierLevel->copyV2ConstraintFlags( refProfileTierLevel ); 
+      }
+
+      if ( !curProfileTierLevel->getInbldPresentFlag() )
+      {
+        curProfileTierLevel->setInbldFlag( refProfileTierLevel->getInbldFlag() ); 
+      }      
+    }     
+  }
+}
+
+#endif
 #endif
 //! \}
@@ -4271 +4908 @@
 
   m_vpsVuiBspHrdPresentFlag = false; 
+#if H_MV_HLS10_VPS_VUI_BSP
+  m_vpsVuiBspHrdParameters  = NULL;
+#else
   m_vpsVuiBspHrdParameters  = new TComVpsVuiBspHrdParameters();
+#endif
 }
 
@@ -4314 +4955 @@
     assert( getBitDepthVpsLumaMinus8          () == prevRepFormat->getBitDepthVpsLumaMinus8          () );
     assert( getBitDepthVpsChromaMinus8        () == prevRepFormat->getBitDepthVpsChromaMinus8        () );
-}
-}
-
+  }
+}
+
+#if !H_MV_HLS10_VPS_VUI_BSP
 Void TComVpsVuiBspHrdParameters::checkLayerInBspFlag( TComVPS* vps, Int h )
 {
@@ -4354 +4996 @@
   // When num_bitstream_partitions[ h ] is equal to 1 for any value of h in the range 1 to vps_num_layer_set_minus1, inclusive, 
   // the value of layer_in_bsp_flag[ h ][ 0 ][ j ] should be equal to 0 for at least one value of j in the range 0 to 
-  // NumLayersInIdList[ h ] − 1, inclusive. 
+  // NumLayersInIdList[ h ] ? 1, inclusive. 
 
 
@@ -4369 +5011 @@
   
   // For any value of h in the range 1 to vps_num_layer_set_minus1, inclusive, the value of layer_in_bsp_flag[ h ][ i ][ j ] 
-  // shall be equal to 1 for at most one value of i in the range of 0 to num_bitstream_partitions[ h ] − 1, inclusive. 
+  // shall be equal to 1 for at most one value of i in the range of 0 to num_bitstream_partitions[ h ] ? 1, inclusive. 
 
   for ( Int j = 0; j <= vps->getNumLayersInIdList( h ) - 1; j++ )
@@ -4395 +5037 @@
   //  assert(  getBspCombSchedIdx(h, i, j ) <= vps->getHrdParameters( getBspCombHrdIdx( h, i, j ) )->getCpbCntMinus1( highestTid ) );
 }
+#endif
+
+#if H_MV_HLS10_VPS_VUI_BSP
+
+TComVpsVuiBspHrdParameters::~TComVpsVuiBspHrdParameters()
+{
+  delete[] m_cprmsAddPresentFlag; 
+  delete[] m_numSubLayerHrdMinus1; 
+  delete[] m_hrdParameters; 
+
+  for (Int h = 0; h < m_numOls; h++)
+  {
+    if ( h > 0 )
+    {    
+      for (Int i = 0; i < getNumSignalledPartitioningSchemes(h)+1; i++)
+      {
+        for (Int t = 0; t < m_vps->getMaxSubLayersInLayerSetMinus1( m_vps->olsIdxToLsIdx(h) ) + 1; t++)
+        {        
+          for ( Int j = 0; j <= getNumBspSchedulesMinus1(h,i,j);j++ )
+          {
+            delete[] m_bspHrdIdx  [h][i][t][j]; 
+            delete[] m_bspSchedIdx[h][i][t][j];
+          }
+        }
+        delete[] m_numBspSchedulesMinus1[h][i];
+      }
+    }
+
+    for (Int j = 0; j <= getNumSignalledPartitioningSchemes(h ) + 1; j++ )
+    {
+      for (Int k = 0; k <= getNumPartitionsInSchemeMinus1(h,j); k++ )
+      {
+        delete[] m_layerIncludedInPartitionFlag[h][j][k];
+      }        
+    }
+    delete[] m_numPartitionsInSchemeMinus1[h];       
+  }
+  delete[] m_numSignalledPartitioningSchemes;
+}
+
+
+Int TComVpsVuiBspHrdParameters::getBspHrdIdxLen(TComVPS* vps)
+{
+  return gCeilLog2( vps->getNumHrdParameters() + getVpsNumAddHrdParams() );
+}
+
+Void TComVpsVuiBspHrdParameters::createAfterVpsNumAddHrdParams( TComVPS* vps )
+{
+  assert( vps == NULL ); 
+  m_vps = vps; 
+  m_offsetHrdParamIdx = vps->getNumHrdParameters(); 
+  m_numHrdParam       = vps->getNumHrdParameters() + getVpsNumAddHrdParams() - m_offsetHrdParamIdx;
+  m_numOls            = vps->getNumOutputLayerSets(); 
+
+  m_cprmsAddPresentFlag   = new Bool    [ m_numHrdParam ];
+  m_numSubLayerHrdMinus1  = new Int     [ m_numHrdParam ];
+  m_hrdParameters         = new TComHRD [ m_numHrdParam ];
+
+  m_numSignalledPartitioningSchemes = new Int    [ m_numOls ]; 
+  m_numPartitionsInSchemeMinus1     = new Int*   [ m_numOls ];
+  m_numBspSchedulesMinus1           = new Int**  [ m_numOls ]; 
+  m_bspHrdIdx                       = new Int****[ m_numOls ];
+  m_bspSchedIdx                     = new Int****[ m_numOls ];
+}
+
+Void TComVpsVuiBspHrdParameters::createAfterNumSignalledPartitioningSchemes( Int h )
+{
+  m_numPartitionsInSchemeMinus1 [h]    = new Int    [ getNumSignalledPartitioningSchemes(h) ];
+  m_layerIncludedInPartitionFlag[h]    = new Bool** [ getNumSignalledPartitioningSchemes(h) ];    
+
+  m_numBspSchedulesMinus1[h]           = new Int*   [ getNumSignalledPartitioningSchemes(h) + 1 ];
+  for (Int i = 0; i < getNumSignalledPartitioningSchemes(h) + 1; i++)
+  {
+    Int tMax = m_vps->getMaxSubLayersInLayerSetMinus1( m_vps->olsIdxToLsIdx(h) ) + 1;
+    m_numBspSchedulesMinus1[h][i] = new Int  [ tMax ];
+    m_bspHrdIdx            [h][i] = new Int**[ tMax ];
+    m_bspSchedIdx          [h][i] = new Int**[ tMax ];
+  }
+}
+
+Void TComVpsVuiBspHrdParameters::createAfterNumPartitionsInSchemeMinus1( Int h, Int j )
+{
+  m_layerIncludedInPartitionFlag[h][j] = new Bool*[ getNumPartitionsInSchemeMinus1(h,j)];
+  for( Int k = 0; k < getNumPartitionsInSchemeMinus1(h,j); k++ )
+  {
+    m_layerIncludedInPartitionFlag[h][j][k] = new Bool[ m_vps->getNumLayersInIdList( m_vps->olsIdxToLsIdx(h))];
+  }
+}
+
+Void TComVpsVuiBspHrdParameters::createAfterNumBspSchedulesMinus1( Int h, Int i, Int t )
+{
+  m_bspSchedIdx[h][i][t] = new Int* [ getNumBspSchedulesMinus1( h, i, t ) + 1 ];
+  m_bspHrdIdx  [h][i][t] = new Int* [ getNumBspSchedulesMinus1( h, i, t ) + 1 ];
+  for( Int j = 0; j < getNumBspSchedulesMinus1( h, i, t ) + 1; j++ )
+  {
+    m_bspSchedIdx[h][i][t][j] = new Int[ getNumPartitionsInSchemeMinus1( h, i ) ];
+    m_bspHrdIdx  [h][i][t][j] = new Int[ getNumPartitionsInSchemeMinus1( h, i ) ];
+  }
+}
+
+#endif
 
 Void TComVUI::inferVideoSignalInfo( TComVPS* vps, Int layerIdCurr )
@@ -4430 +5173 @@
       for (Int k = 0; k < MAX_NUM_LAYER_IDS; k++ )
       {
+#if H_MV_HLS10_ADD_LAYERSETS
+        m_maxVpsDecPicBufferingMinus1[i][k][j] = MIN_INT; 
+#else
         m_maxVpsDecPicBufferingMinus1[i][k][j] = 0; 
+#endif
       }
     }

trunk/source/Lib/TLibCommon/TComSlice.h

@@ -1 @@
-/* The copyright in this software is being made available under the BSD
+/* The copyright in this software is being made available under the BSD
  * License, included below. This software may be subject to other third party
  * and contributor rights, including patent rights, and no such rights are
@@ -45 +45 @@
 #include "TComRom.h"
 #include "TComList.h"
-
+#if H_MV_HLS10_GEN_FIX
+#if H_MV
+#include <ios>
+#include <iostream>
+#include <iomanip>
+#endif
+#endif
 //! \ingroup TLibCommon
 //! \{
@@ -201 +207 @@
   Bool m_frameOnlyConstraintFlag;
   
+#if H_MV_HLS10_PTL
+#if H_MV
+  Bool m_max12bitConstraintFlag;
+  Bool m_max10bitConstraintFlag;
+  Bool m_max8bitConstraintFlag;
+  Bool m_max422chromaConstraintFlag;
+  Bool m_max420chromaConstraintFlag;
+  Bool m_maxMonochromeConstraintFlag;
+  Bool m_intraConstraintFlag;
+  Bool m_onePictureOnlyConstraintFlag;
+  Bool m_lowerBitRateConstraintFlag;
+  Bool m_inbldFlag;
+#endif
+#endif
 public:
   ProfileTierLevel();
@@ -230 +250 @@
   Bool getFrameOnlyConstraintFlag() const { return m_frameOnlyConstraintFlag; }
   Void setFrameOnlyConstraintFlag(Bool b) { m_frameOnlyConstraintFlag = b; }
+
+#if H_MV
+#if H_MV_HLS10_PTL
+  Void setMax12bitConstraintFlag( Bool flag ) { m_max12bitConstraintFlag = flag; } 
+  Bool getMax12bitConstraintFlag(  ) { return m_max12bitConstraintFlag; } 
+  
+  Void setMax10bitConstraintFlag( Bool flag ) { m_max10bitConstraintFlag = flag; } 
+  Bool getMax10bitConstraintFlag(  ) { return m_max10bitConstraintFlag; } 
+  
+  Void setMax8bitConstraintFlag( Bool flag ) { m_max8bitConstraintFlag = flag; } 
+  Bool getMax8bitConstraintFlag(  ) { return m_max8bitConstraintFlag; } 
+  
+  Void setMax422chromaConstraintFlag( Bool flag ) { m_max422chromaConstraintFlag = flag; } 
+  Bool getMax422chromaConstraintFlag(  ) { return m_max422chromaConstraintFlag; } 
+  
+  Void setMax420chromaConstraintFlag( Bool flag ) { m_max420chromaConstraintFlag = flag; } 
+  Bool getMax420chromaConstraintFlag(  ) { return m_max420chromaConstraintFlag; } 
+  
+  Void setMaxMonochromeConstraintFlag( Bool flag ) { m_maxMonochromeConstraintFlag = flag; } 
+  Bool getMaxMonochromeConstraintFlag(  ) { return m_maxMonochromeConstraintFlag; } 
+  Void setIntraConstraintFlag( Bool flag ) { m_intraConstraintFlag = flag; } 
+  Bool getIntraConstraintFlag(  ) { return m_intraConstraintFlag; } 
+  
+  Void setOnePictureOnlyConstraintFlag( Bool flag ) { m_onePictureOnlyConstraintFlag = flag; } 
+  Bool getOnePictureOnlyConstraintFlag(  ) { return m_onePictureOnlyConstraintFlag; } 
+  
+  Void setLowerBitRateConstraintFlag( Bool flag ) { m_lowerBitRateConstraintFlag = flag; } 
+  Bool getLowerBitRateConstraintFlag(  ) { return m_lowerBitRateConstraintFlag; } 
+  
+  Void setInbldFlag( Bool flag ) { m_inbldFlag = flag; } 
+  Bool getInbldFlag(  ) { return m_inbldFlag; } 
+#endif
+#if H_MV_HLS10_PTL_INFER_FIX
+  Bool getV2ConstraintsPresentFlag();  
+  Bool getInbldPresentFlag();
+  Void copyV2ConstraintFlags( ProfileTierLevel* ptlRef );
+  Void copyProfile( ProfileTierLevel* ptlRef );
+#endif
+#endif
 };
 
@@ -251 +310 @@
   ProfileTierLevel* getSubLayerPTL(Int i)  { return &m_subLayerPTL[i]; }
 #if H_MV
+#if H_MV_HLS10_PTL_INFER_FIX
+  Void inferGeneralValues ( Bool profilePresentFlag  , Int k, TComPTL* refPTL );; 
+  Void inferSubLayerValues( Int maxNumSubLayersMinus1, Int k, TComPTL* refPTL );; 
+#else
   Void copyLevelFrom( TComPTL* source );
+#endif
 #endif
 };
@@ -359 +423 @@
   Void setCpbCntMinus1           ( Int layer, UInt value ) { m_HRD[layer].cpbCntMinus1 = value; }
   UInt getCpbCntMinus1           ( Int layer            )  { return m_HRD[layer].cpbCntMinus1; }
-
+  
   Void setBitRateValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].bitRateValueMinus1[cpbcnt][nalOrVcl] = value; }
   UInt getBitRateValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl             ) { return m_HRD[layer].bitRateValueMinus1[cpbcnt][nalOrVcl];  }
@@ -434 +498 @@
   Int  getMatrixCoeffsVps(  ) { return m_matrixCoeffsVps; } 
 };
+
 class TComVpsVuiBspHrdParameters
 {
+#if H_MV_HLS10_VPS_VUI_BSP
+
+  /* Not yet tested */
+private: 
+
+  Int   m_vpsNumAddHrdParams;
+  Bool* m_cprmsAddPresentFlag;
+  TComHRD* m_hrdParameters; 
+  Int*  m_numSubLayerHrdMinus1;
+  Int*  m_numSignalledPartitioningSchemes;
+  Int** m_numPartitionsInSchemeMinus1;
+
+  Bool****  m_layerIncludedInPartitionFlag;
+  Int***    m_numBspSchedulesMinus1;
+  Int*****  m_bspHrdIdx;
+  Int*****  m_bspSchedIdx;
+    
+  // Array sizes
+  Int      m_offsetHrdParamIdx;
+  Int      m_numHrdParam; 
+  Int      m_numOls; 
+  TComVPS* m_vps; 
+public:   
+
+  ~TComVpsVuiBspHrdParameters();
+  
+  Void createAfterVpsNumAddHrdParams( TComVPS* vps );
+  Void createAfterNumSignalledPartitioningSchemes(Int h );
+  Void createAfterNumPartitionsInSchemeMinus1(Int h, Int j);
+  Void createAfterNumBspSchedulesMinus1( Int h, Int i, Int t);
+
+  Void setVpsNumAddHrdParams( Int  val ) { m_vpsNumAddHrdParams = val; } 
+  Int  getVpsNumAddHrdParams(  ) { return m_vpsNumAddHrdParams; } 
+  
+  Void setCprmsAddPresentFlag( Int i, Bool flag ) { m_cprmsAddPresentFlag[i - m_offsetHrdParamIdx] = flag; } 
+  Bool getCprmsAddPresentFlag( Int i ) { return m_cprmsAddPresentFlag[i  - m_offsetHrdParamIdx]; } 
+  
+  Void setNumSubLayerHrdMinus1( Int i, Int  val ) { m_numSubLayerHrdMinus1[i  - m_offsetHrdParamIdx] = val; } 
+  Int  getNumSubLayerHrdMinus1( Int i ) { return m_numSubLayerHrdMinus1[i  - m_offsetHrdParamIdx]; } 
+  
+  Void setNumSignalledPartitioningSchemes( Int h, Int  val ) { m_numSignalledPartitioningSchemes[h] = val; } 
+  Int  getNumSignalledPartitioningSchemes( Int h ) { return m_numSignalledPartitioningSchemes[h]; } 
+  
+  Void setNumPartitionsInSchemeMinus1( Int h, Int j, Int  val ) { m_numPartitionsInSchemeMinus1[h][j] = val; } 
+  Int  getNumPartitionsInSchemeMinus1( Int h, Int j ) { return m_numPartitionsInSchemeMinus1[h][j]; } 
+  
+  Void setLayerIncludedInPartitionFlag( Int h, Int j, Int k, Int r, Bool flag ) { m_layerIncludedInPartitionFlag[h][j][k][r] = flag; } 
+  Bool getLayerIncludedInPartitionFlag( Int h, Int j, Int k, Int r ) { return m_layerIncludedInPartitionFlag[h][j][k][r]; } 
+  
+  Void setNumBspSchedulesMinus1( Int h, Int i, Int t, Int  val ) { m_numBspSchedulesMinus1[h][i][t] = val; } 
+  Int  getNumBspSchedulesMinus1( Int h, Int i, Int t ) { return m_numBspSchedulesMinus1[h][i][t]; } 
+  
+  Void setBspHrdIdx( Int h, Int i, Int t, Int j, Int k, Int  val ) { m_bspHrdIdx[h][i  - m_offsetHrdParamIdx][t][j][k] = val; } 
+  Int  getBspHrdIdx( Int h, Int i, Int t, Int j, Int k ) { return m_bspHrdIdx[h][i  - m_offsetHrdParamIdx][t][j][k]; } 
+  
+  Int  getBspHrdIdxLen( TComVPS* vps );
+
+  Void setBspSchedIdx( Int h, Int i, Int t, Int j, Int k, Int  val ) { m_bspSchedIdx[h][i - m_offsetHrdParamIdx][t][j][k] = val; } 
+  Int  getBspSchedIdx( Int h, Int i, Int t, Int j, Int k ) { return m_bspSchedIdx[h][i - m_offsetHrdParamIdx][t][j][k]; } 
+
+  Void setHrdParametermeters( Int k, TComHRD* val  ) {  *(m_hrdParameters + k ) = *val; }; 
+  TComHRD* getHrdParametermeters( Int k ) {  return m_hrdParameters + k; }; 
+#else 
 private: 
   Int  m_vpsNumBspHrdParametersMinus1;
@@ -475 +603 @@
   Void setHrdParametermeters( Int k, TComHRD* val  ) {  m_hrdParameters[k] = val; }; 
   TComHRD* getHrdParametermeters( Int k ) {  return m_hrdParameters[k]; }; 
+#endif
 };
 
@@ -501 +630 @@
   Bool m_wppNotInUseFlag;
   Bool m_wppInUseFlag                [MAX_NUM_LAYERS];
+#if H_MV_HLS10_VPS_VUI
+  Bool m_singleLayerForNonIrapFlag;
+  Bool m_higherLayerIrapSkipFlag;
+#endif
   Bool m_ilpRestrictedRefLayersFlag;
   Int  m_minSpatialSegmentOffsetPlus1[MAX_NUM_LAYERS][MAX_NUM_LAYERS];
@@ -574 +707 @@
   Void setWppInUseFlag( Int i, Bool flag ) { m_wppInUseFlag[i] = flag; } 
   Bool getWppInUseFlag( Int i ) { return m_wppInUseFlag[i]; } 
+
+#if H_MV_HLS10_VPS_VUI
+  Void setSingleLayerForNonIrapFlag( Bool flag ) { m_singleLayerForNonIrapFlag = flag; } 
+  Bool getSingleLayerForNonIrapFlag(  ) { return m_singleLayerForNonIrapFlag; } 
+
+  Void setHigherLayerIrapSkipFlag( Bool flag ) { m_higherLayerIrapSkipFlag = flag; } 
+  Bool getHigherLayerIrapSkipFlag(  ) { return m_higherLayerIrapSkipFlag; } 
+#endif
 
   Void setIlpRestrictedRefLayersFlag( Bool flag ) { m_ilpRestrictedRefLayersFlag = flag; } 
@@ -609 +750 @@
   Int  m_bitDepthVpsLumaMinus8;
   Int  m_bitDepthVpsChromaMinus8;
+#if H_MV_HLS10_GEN_VSP_CONF_WIN
+  Bool m_conformanceWindowVpsFlag;
+  Int  m_confWinVpsLeftOffset;
+  Int  m_confWinVpsRightOffset;
+  Int  m_confWinVpsTopOffset;
+  Int  m_confWinVpsBottomOffset;
+#endif
 
 public: 
+
+#if H_MV_HLS10_GEN_VSP_CONF_WIN
+  TComRepFormat()
+  { 
+  m_conformanceWindowVpsFlag = 0;
+  m_confWinVpsLeftOffset     = 0;
+  m_confWinVpsRightOffset    = 0;
+  m_confWinVpsTopOffset      = 0;
+  m_confWinVpsBottomOffset   = 0;
+  };  
+#else
   TComRepFormat() { };  
+#endif
 
   Void setChromaAndBitDepthVpsPresentFlag( Bool flag ) { m_chromaAndBitDepthVpsPresentFlag = flag; } 
@@ -635 +795 @@
   Void setBitDepthVpsChromaMinus8( Int  val ) { m_bitDepthVpsChromaMinus8 = val; } 
   Int  getBitDepthVpsChromaMinus8(  ) { return m_bitDepthVpsChromaMinus8; } 
+
+#if H_MV_HLS10_GEN_VSP_CONF_WIN
+  Void setConformanceWindowVpsFlag( Bool flag ) { m_conformanceWindowVpsFlag = flag; } 
+  Bool getConformanceWindowVpsFlag(  ) { return m_conformanceWindowVpsFlag; } 
+
+  Void setConfWinVpsLeftOffset( Int  val ) { m_confWinVpsLeftOffset = val; } 
+  Int  getConfWinVpsLeftOffset(  ) { return m_confWinVpsLeftOffset; } 
+
+  Void setConfWinVpsRightOffset( Int  val ) { m_confWinVpsRightOffset = val; } 
+  Int  getConfWinVpsRightOffset(  ) { return m_confWinVpsRightOffset; } 
+
+  Void setConfWinVpsTopOffset( Int  val ) { m_confWinVpsTopOffset = val; } 
+  Int  getConfWinVpsTopOffset(  ) { return m_confWinVpsTopOffset; } 
+
+  Void setConfWinVpsBottomOffset( Int  val ) { m_confWinVpsBottomOffset = val; } 
+  Int  getConfWinVpsBottomOffset(  ) { return m_confWinVpsBottomOffset; } 
+#endif
 };
 
@@ -657 +834 @@
 
   Void setMaxVpsDecPicBufferingMinus1( Int i, Int k, Int j, Int  val ) { m_maxVpsDecPicBufferingMinus1[i][k][j] = val; } 
+  #if H_MV_HLS10_ADD_LAYERSETS
+  Int  getMaxVpsDecPicBufferingMinus1( Int i, Int k, Int j ) { assert( m_maxVpsDecPicBufferingMinus1[i][k][j] >= 0 ); return m_maxVpsDecPicBufferingMinus1[i][k][j]; }     
+  #else
   Int  getMaxVpsDecPicBufferingMinus1( Int i, Int k, Int j ) { return m_maxVpsDecPicBufferingMinus1[i][k][j]; } 
+  #endif
 
   Void setMaxVpsNumReorderPics( Int i, Int j, Int  val ) { m_maxVpsNumReorderPics[i][j] = val; } 
@@ -672 +853 @@
 #if H_MV
   Bool        m_vpsBaseLayerInternalFlag;
+#if H_MV_HLS10_GEN_VSP_BASE_LAYER_AVAIL
+  Bool        m_vpsBaseLayerAvailableFlag;
+#endif // H_MV_HLS10_GEN
 #endif
 
@@ -741 +925 @@
   Int         m_layerSetIdxForOlsMinus1  [MAX_VPS_OUTPUTLAYER_SETS];  
   Bool        m_outputLayerFlag          [MAX_VPS_OUTPUTLAYER_SETS][MAX_VPS_NUH_LAYER_ID_PLUS1];
+#if H_MV_HLS10_PTL
+  Int         m_profileTierLevelIdx      [MAX_VPS_OUTPUTLAYER_SETS ][MAX_NUM_LAYERS];
+#else  
   Int         m_profileLevelTierIdx      [MAX_VPS_OUTPUTLAYER_SETS ];
+#endif
   Bool        m_altOutputLayerFlag       [MAX_VPS_OUTPUTLAYER_SETS];
   Bool        m_repFormatIdxPresentFlag;
@@ -770 +958 @@
   // VPS EXTENSION SEMANTICS VARIABLES
   Int         m_layerIdInVps             [MAX_NUM_LAYERS   ];
+#if H_MV_HLS10_REF_PRED_LAYERS
+  Int         m_dependencyFlag           [MAX_NUM_LAYERS][MAX_NUM_LAYERS]; 
+#endif
 
   Int         m_numDirectRefLayers       [MAX_NUM_LAYERS];
+#if H_MV_HLS10_REF_PRED_LAYERS
+  Int         m_idDirectRefLayer         [MAX_NUM_LAYERS][MAX_NUM_LAYERS];  
+#else
   Int         m_refLayerId               [MAX_NUM_LAYERS][MAX_NUM_LAYERS];  
+#endif
 
   Int         m_numRefLayers             [MAX_NUM_LAYER_IDS]; 
-  Int         m_numPredictedLayers       [MAX_NUM_LAYERS]; 
+#if H_MV_HLS10_REF_PRED_LAYERS
+  Int         m_idRefLayer               [MAX_NUM_LAYERS][MAX_NUM_LAYERS];  
+#endif
+
+
+  Int         m_numPredictedLayers       [MAX_NUM_LAYERS ]; 
+#if !H_MV_HLS10_REF_PRED_LAYERS
   Int         m_predictedLayerId         [MAX_NUM_LAYERS][MAX_NUM_LAYER_IDS];
+#else
+  Int         m_idPredictedLayer         [MAX_NUM_LAYERS][MAX_NUM_LAYER_IDS];
+#endif
   Int         m_numIndependentLayers; 
   Int         m_numLayersInTreePartition [MAX_NUM_LAYER_IDS];
   Int         m_treePartitionLayerIdList [MAX_NUM_LAYERS][MAX_NUM_LAYER_IDS];
+#if H_MV_HLS10_REF_PRED_LAYERS
   Bool        m_recursiveRefLayerFlag    [MAX_NUM_LAYER_IDS][MAX_NUM_LAYER_IDS]; 
-
+  #endif
   Int         m_viewIndex                [MAX_NUM_LAYERS   ];
   
@@ -788 +993 @@
   std::vector< std::vector< Int> >       m_layerSetLayerIdList; 
 
+#if H_MV_HLS10_NESSECARY_LAYER
+  Int        m_numNecessaryLayers        [MAX_VPS_OUTPUTLAYER_SETS];
+  Bool       m_necessaryLayerFlag        [MAX_VPS_OUTPUTLAYER_SETS][MAX_NUM_LAYERS]; 
+#endif
 
   Int         xGetDimBitOffset( Int j );
+#if H_MV_HLS10_REF_PRED_LAYERS
   Void        xSetRefLayerFlags( Int currLayerId );
+#endif
   // VPS EXTENSION 2 SYNTAX ELEMENTS
 #if H_3D_ARP
@@ -870 +1081 @@
   Void    setVpsBaseLayerInternalFlag( Bool flag ) { m_vpsBaseLayerInternalFlag = flag; } 
   Bool    getVpsBaseLayerInternalFlag(  )          { return m_vpsBaseLayerInternalFlag; } 
+#if H_MV_HLS10_GEN_VSP_BASE_LAYER_AVAIL
+  Void    setVpsBaseLayerAvailableFlag( Bool flag ) { m_vpsBaseLayerAvailableFlag = flag; } 
+  Bool    getVpsBaseLayerAvailableFlag(  )          { return m_vpsBaseLayerAvailableFlag; } 
+#endif
 #endif
 
@@ -877 +1092 @@
 #if H_MV    
   UInt    getMaxSubLayersMinus1()             { return m_uiMaxTLayers - 1;  }  // For consistency with draft spec
+#if H_MV_HLS10_GEN_FIX
+  Void    setMaxSubLayersMinus1(UInt val)     { m_uiMaxTLayers = (val + 1); };
+#endif
   UInt    getMaxLayersMinus1()                { return m_uiMaxLayersMinus1;  }; 
   Void    setMaxLayersMinus1(UInt l)          { m_uiMaxLayersMinus1 = l; }
@@ -916 +1134 @@
 
 #if H_MV
+#if H_MV_HLS10_PTL
+  TComPTL* getPTL( Int idx = 0 ) { return &m_pcPTL[idx]; }
+#else
   TComPTL* getPTL( Int layerSet = 0 ) { return &m_pcPTL[layerSet]; }
+#endif
 #else
   TComPTL* getPTL() { return &m_pcPTL; }
@@ -996 +1218 @@
   Void    setLayerSetIdxForOlsMinus1( Int outLayerSetIdx, Int val )        { m_layerSetIdxForOlsMinus1[ outLayerSetIdx ]  = val; } 
   Int     getLayerSetIdxForOlsMinus1( Int outLayerSetIdx )                 { return m_layerSetIdxForOlsMinus1[ outLayerSetIdx ]; } 
+#if VPS_MISC_UPDATES
+  Int     getLayerSetIdxForOlsMinus1Len( Int outLayerSetIdx )              { return gCeilLog2( getNumLayerSets() ); } 
+#endif
 
   Void    setOutputLayerFlag( Int outLayerSetIdx, Int i, Bool flag )       { m_outputLayerFlag[ outLayerSetIdx ][ i ] = flag; } 
@@ -1002 +1227 @@
   Bool    inferOutputLayerFlag( Int i, Int j );
 
+#if H_MV_HLS10_PTL
+  Void    setProfileTierLevelIdx( Int i, Int j, Int val )                  { m_profileTierLevelIdx[ i ][ j ] = val; }
+  Int     getProfileTierLevelIdx( Int i, Int j )                           { return m_profileTierLevelIdx[ i ][ j ]; } 
+#if H_MV_HLS10_PTL_FIX
+  Int     inferProfileTierLevelIdx( Int i, Int j );
+#endif
+#else
   Void    setProfileLevelTierIdx( Int outLayerSetIdx, Int val )            { m_profileLevelTierIdx[ outLayerSetIdx ] = val; }
   Int     getProfileLevelTierIdx( Int outLayerSetIdx )                     { return m_profileLevelTierIdx[ outLayerSetIdx ]; } 
+#endif
   
   Void    setAltOutputLayerFlag( Int i, Bool flag )                        { m_altOutputLayerFlag[i] = flag; } 
@@ -1033 +1266 @@
   TComDpbSize* getDpbSize( )                                               { return m_dpbSize;} 
   
+#if !H_MV_HLS10_ADD_LAYERSETS  
   Void    inferDbpSizeLayerSetZero( TComSPS* sps, Bool encoder );
-  
+#endif
+
   Void    setPocLsbNotPresentFlag( Int i, Bool flag )                      { m_pocLsbNotPresentFlag[i] = flag; } 
   Bool    getPocLsbNotPresentFlag( Int i )                                 { return m_pocLsbNotPresentFlag[i]; } 
@@ -1064 +1299 @@
 
   Int     getViewIndex    ( Int layerIdInNuh )                             { return getScalabilityId( getLayerIdInVps(layerIdInNuh), VIEW_ORDER_INDEX  ); }    
+#if H_MV_HLS10_AUX
+  Int     getAuxId        ( Int layerIdInNuh )                             { return getScalabilityId( getLayerIdInVps(layerIdInNuh), AUX_ID  ); }    
+  Int     getDependencyId ( Int layerIdInNuh )                             { return getScalabilityId( getLayerIdInVps(layerIdInNuh), DEPENDENCY_ID  ); }    
+#endif
   Int     getNumViews();
 
+#if H_MV_HLS10_REF_PRED_LAYERS
+  Bool    getDependencyFlag( Int i, Int j )                                { return m_dependencyFlag[i][j]; }
+#endif
   Int     getNumDirectRefLayers( Int layerIdInNuh )                        { return m_numDirectRefLayers[ layerIdInNuh ];  };                               
+#if !H_MV_HLS10_REF_PRED_LAYERS
   Int     getRefLayerId        ( Int layerIdInNuh, Int idx );; 
-
+#endif
   Int     getNumRefLayers            ( Int i )        { return m_numRefLayers[i]; } 
   Int     getNumPredictedLayers      ( Int i )        { return m_numPredictedLayers[i]; } 
+
+#if !H_MV_HLS10_REF_PRED_LAYERS  
   Int     getPredictedLayerId        ( Int i, Int j ) { return m_predictedLayerId[i][j]; } 
+#else
+  Int     getIdRefLayer              ( Int i, Int j ) { assert( j >= 0 && j < getNumRefLayers      ( i )); return m_idRefLayer      [i][j]; } 
+  Int     getIdPredictedLayer        ( Int i, Int j ) { assert( j >= 0 && j < getNumPredictedLayers( i )); return m_idPredictedLayer[i][j]; } 
+  Int     getIdDirectRefLayer        ( Int i, Int j ) { assert( j >= 0 && j < getNumDirectRefLayers( i )); return m_idDirectRefLayer[i][j]; } 
+#endif
   Int     getNumIndependentLayers    (  )             { return m_numIndependentLayers; } 
   Int     getNumLayersInTreePartition( Int i )        { return m_numLayersInTreePartition[i]; } 
@@ -1078 +1328 @@
   Int     getNumLayerSets( )                                               { return getVpsNumLayerSetsMinus1() + 1 + getNumAddLayerSets();  };  
   
+#if H_MV_HLS10_ADD_LAYERSETS
+  Int     getFirstAddLayerSetIdx()                    { return getVpsNumLayerSetsMinus1() + 1; } 
+  Int     getLastAddLayerSetIdx()                     { return getFirstAddLayerSetIdx() + getNumAddLayerSets() - 1; }
+#endif
   Bool    checkVPSExtensionSyntax(); 
   Int     scalTypeToScalIdx   ( ScalabilityType scalType );
 
+#if H_MV_HLS10_PTL
+  Int     getProfileTierLevelIdxLen()                                      { return gCeilLog2( getVpsNumProfileTierLevelMinus1() + 1 ); };       
+#else
   Int     getProfileLevelTierIdxLen()                                      { return gCeilLog2( getVpsNumProfileTierLevelMinus1() + 1 ); };       
+#endif
   Int     getVpsRepFormatIdxLen()                                          { return gCeilLog2( getVpsNumRepFormatsMinus1() + 1 ); };       
 
@@ -1092 +1350 @@
   Void    deriveLayerSetLayerIdList();
 
+#if H_MV_HLS10_ADD_LAYERSETS
+  Int     olsIdxToLsIdx( Int i )                                           { return ( i < getNumLayerSets() ) ? i  : getLayerSetIdxForOlsMinus1( i ) + 1 ; };
+#else
   Int     olsIdxToLsIdx( Int i )                                           { return ( i <= getVpsNumLayerSetsMinus1() ) ? i  : getLayerSetIdxForOlsMinus1( i ) + 1 ; };
-
+#endif
   Void    initTargetLayerIdLists  ( );
   Void    deriveTargetLayerIdList ( Int i );
-
   std::vector<Int> getTargetDecLayerIdList( Int targetDecLayerSetIdx )     { return m_targetDecLayerIdLists[targetDecLayerSetIdx]; }; 
   std::vector<Int> getTargetOptLayerIdList( Int targetOptLayerSetIdx )     { return m_targetOptLayerIdLists[targetOptLayerSetIdx]; }; 
@@ -1103 +1363 @@
   Int     getOlsHighestOutputLayerId( Int i )                              { return getTargetOptLayerIdList( i ).back(); };  
 
+#if H_MV_HLS10_ADD_LAYERSETS
+  Void    deriveAddLayerSetLayerIdList( Int i );
+#endif
+#if H_MV_HLS10_NESSECARY_LAYER
+  Void    deriveNecessaryLayerFlags( Int olsIdx );;
+  Int     getNecessaryLayerFlag( Int i, Int j )                            { AOF( i >= 0 && i < getNumOutputLayerSets() ); AOF( j >= 0 && j < getNumLayersInIdList( olsIdxToLsIdx( i ) )  );  return m_necessaryLayerFlag[i][j]; };  
+#endif
+
   Int     getMaxSubLayersInLayerSetMinus1( Int i );
   Int     getHighestLayerIdxPlus1Len( Int j )                                   { return gCeilLog2( getNumLayersInTreePartition( j ) + 1 );   }; 
-
-  Bool     getAltOutputLayerFlagVar( Int i );;
+  Bool    getAltOutputLayerFlagVar( Int i );;
 
   // inference
@@ -1113 +1380 @@
 
   // helpers
+#if !H_MV_HLS10_REF_PRED_LAYERS
   Bool    getInDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Int depth = 0 );
+#endif
+#if !H_MV_HLS10_MAXNUMPICS
   Int     getMaxNumPics( Int layerId );
+#endif
+#if H_MV_HLS10_ADD_LAYERSETS
+  Void    printPTL();
+  Void    printLayerDependencies();
+#if H_MV_HLS10_AUX
+  Void    printScalabilityId();;
+#endif
+  Void    printLayerSets();;
+
+
+
+  template <typename T, typename S, typename U> Void xPrintArray( const Char* name, Int numElemDim1, U idx, S numElemDim2, T vec, Bool printNumber, Bool printIdx = true )
+  {
+    std::cout << std::endl; 
+    for (Int j = 0; j < numElemDim1; j++ )
+    { 
+      std::cout << std::right << std::setw(27) << name; 
+      if (printIdx)
+      {
+        std::cout << "[" << std::right << std::setw(3) << idx[ j ] << "]" ; 
+      }
+      else
+      {
+        std::cout << std::right << std::setw(5) << " "; 
+      }
+      
+      if ( printNumber )
+      {
+        std::cout << " (" << std::right << std::setw(3) << numElemDim2[j] << ")";        
+      }          
+      else
+      {
+       std::cout << std::right << std::setw(6) << " ";              
+      }
+
+      std::cout << ":";
+      for (Int i = 0; i < numElemDim2[j]; i++)
+      {
+        std::cout << std::right << std::setw(3) << vec[j][i];
+      }   
+      std::cout << std::endl; 
+    }
+  }
+
+  template <typename T> Void xPrintArray( const char* name, Int numElem, T vec, Bool printNumber  )
+  {
+    std::vector<Int> numElemDim2(1, numElem);    
+    std::vector<T>   vec2       (1,  vec    );
+    std::vector<Int> idx2       (0); 
+    xPrintArray( name, 1, idx2, numElemDim2, vec2, printNumber, false );
+  }
+#endif
+
 
   /// VPS EXTENSION 2 SYNTAX ELEMENTS
@@ -1557 +1880 @@
   TComVPS*    m_pcVPS; 
   // SPS 
+#if H_MV_HLS10_MULTILAYERSPS
+  Int         m_spsMaxSubLayersMinus1;
+  Int         m_spsExtOrMaxSubLayersMinus1;
+#endif
   Bool        m_spsExtensionPresentFlag; 
 
@@ -1574 +1901 @@
   // SPS Extension 
   Bool        m_interViewMvVertConstraintFlag;
+#if !H_MV_HLS10_PPS
   Int         m_numScaledRefLayerOffsets;
   Int         m_scaledRefLayerId          [MAX_NUM_SCALED_REF_LAYERS];
@@ -1580 +1908 @@
   Int         m_scaledRefLayerRightOffset [MAX_NUM_LAYERS];
   Int         m_scaledRefLayerBottomOffset[MAX_NUM_LAYERS];
+#endif
 #endif
 #if H_3D
@@ -1683 +2012 @@
 #if H_MV
   UInt      getSpsMaxSubLayersMinus1()                { return ( m_uiMaxTLayers - 1); }
+#if H_MV_HLS10_MULTILAYERSPS
+  Void      setSpsMaxSubLayersMinus1( UInt val )       { setMaxTLayers( val + 1 ); }
+#endif
 #endif
 
@@ -1715 +2047 @@
   TComPTL* getPTL()     { return &m_pcPTL; }
 #if H_MV
+#if H_MV_HLS10_MULTILAYERSPS
+  Void setSpsExtOrMaxSubLayersMinus1( Int  val ) { m_spsExtOrMaxSubLayersMinus1 = val; } 
+  Int  getSpsExtOrMaxSubLayersMinus1(  ) { return m_spsExtOrMaxSubLayersMinus1; } 
+  Void inferSpsMaxSubLayersMinus1( Bool atPsActivation, TComVPS* vps  );
+
+  Bool getMultiLayerExtSpsFlag()            { return ( getLayerId() != 0  &&  getSpsExtOrMaxSubLayersMinus1() == 7 ); }
+#endif
   Void inferSpsMaxDecPicBufferingMinus1( TComVPS* vps, Int targetOptLayerSetIdx, Int currLayerId, Bool encoder );
 
@@ -1753 +2092 @@
   Bool getInterViewMvVertConstraintFlag()         { return m_interViewMvVertConstraintFlag;}
 
+#if !H_MV_HLS10_PPS
   Void setNumScaledRefLayerOffsets( Int  val )    { m_numScaledRefLayerOffsets = val; } 
   Int  getNumScaledRefLayerOffsets(  )            { return m_numScaledRefLayerOffsets; } 
@@ -1770 +2110 @@
   Void setScaledRefLayerBottomOffset( Int j, Int  val ) { m_scaledRefLayerBottomOffset[j] = val; } 
   Int  getScaledRefLayerBottomOffset( Int j )           { return m_scaledRefLayerBottomOffset[j]; } 
+#endif
   // Inference 
+
   Void inferRepFormat( TComVPS* vps, Int layerIdCurr );
   Void inferScalingList( TComSPS* spsSrc );
@@ -2195 +2537 @@
 
   Bool       m_enableTMVPFlag;
+#if I0044_SLICE_TMVP
+  Bool       m_availableForTMVPRefFlag;
+#endif
+
 #if H_MV
   std::vector<TComPic*>* m_refPicSetInterLayer0; 
@@ -2255 +2601 @@
 #if MTK_SINGLE_DEPTH_MODE_I0095
   Bool      m_bApplySingleDepthMode;
+#endif
+#if MTK_LOW_LATENCY_IC_ENCODING_H0086_FIX
+  Int *m_aICEnableCandidate;
+  Int *m_aICEnableNum;
 #endif
 public:
@@ -2527 +2877 @@
   Void      setEnableTMVPFlag     ( Bool   b )    { m_enableTMVPFlag = b; }
   Bool      getEnableTMVPFlag     ()              { return m_enableTMVPFlag;}
+#if I0044_SLICE_TMVP
+  Void      setAvailableForTMVPRefFlag     ( Bool   b )    { m_availableForTMVPRefFlag = b; }
+  Bool      getAvailableForTMVPRefFlag     ()              { return m_availableForTMVPRefFlag;}
+#endif
 
 #if H_MV
@@ -2567 +2921 @@
 #endif
 #endif
+#if MTK_LOW_LATENCY_IC_ENCODING_H0086_FIX
+  Void    setICEnableCandidate( Int* ICEnableCandidate)   { m_aICEnableCandidate = ICEnableCandidate; };
+  Void    setICEnableNum( Int* ICEnableNum)   { m_aICEnableNum = ICEnableNum; };
+  Void    setICEnableCandidate( UInt layer, Int value)   { m_aICEnableCandidate[ layer ] = value; };
+  Void    setICEnableNum( UInt layer, Int value)   { m_aICEnableNum[ layer ] = value; };
+
+  Int    getICEnableCandidate( Int layer){ return  m_aICEnableCandidate[ layer ]; }; 
+  Int    getICEnableNum( Int layer){ return m_aICEnableNum[ layer ]; }; 
+#endif
 #if H_MV
 // Additional slice header syntax elements

trunk/source/Lib/TLibCommon/TypeDef.h

@@ -123 +123 @@
                                               // SEC_IC_ARP_SIG_G0072, Disabling IC when ARP is enabled, option 1 in JCT3V-G0072, part 2 in JCT3V-G0121
                                               // MTK_LOW_LATENCY_IC_ENCODING_H0086  Low-latency IC encoding in JCT3V-H0086
+
+#define MTK_LOW_LATENCY_IC_ENCODING_H0086_FIX  1  // Remove the global variables used in JCT3V-H0086
+
 
 #define SEC_IC_NEIGHBOR_CLIP_I0080        1   // Clipping of neighboring sample position, JCT3V-I0080
@@ -225 +228 @@
 #endif
 
+#define H_3D_FIX_UNINIT                   1   // Fix uninitialized flag
 #define H_3D_INTER_SDC                    1   // INTER SDC, Inter simplified depth coding
                                               // LGE_INTER_SDC_E0156 Enable inter SDC for depth coding
@@ -251 +255 @@
 
 #define H_3D_FCO                          0   // Flexible coding order for 3D
+#if H_3D_FCO
+#define LGE_FCO_I0116                     1
+#endif
 
 #define SCU_HS_FAST_INTRA_SDC_I0123       1
@@ -275 +282 @@
 #define SEC_HLS_CLEANUP_I0100             1
 
+#define H_3D_FIX_64BIT_SHIFT              1
 #endif // H_3D
 
@@ -300 +308 @@
 #define H_3D_VSO_RM_ASSERTIONS            0   // Output VSO assertions
 #define H_3D_VSO_SYNTH_DIST_OUT           0   // Output of synthesized view distortion instead of depth distortion in encoder output
-#define H_3D_VSO_FIX                      0   // This fix should be enabled after verification 
+#define H_3D_VSO_FIX                      1   // This fix should be enabled after verification 
 #endif
 
@@ -381 +389 @@
 /////////////////////////////////////////////////////////////////////////////////
 // TBD: Check if integration is necessary. 
+
+
+
+//Added by Qualcomm for HLS
+#define DISCARDABLE_PIC_RPS              1      ///< JCT3V-G0131: Inter-layer RPS and temporal RPS should not contain picture with discardable_flag equal to 1
+#define VPS_MISC_UPDATES                 1      ///< Misc updates:JCT3V-0240, 
+#define NON_REF_NAL_TYPE_DISCARDABLE     1      ///< JCT3V-G0031: If discardable picture is a non-IRAP, it must be a non-referenced sub-layer picture
+#define INFERENCE_POC_MSB_VAL_PRESENT    1      ///< JCT3V-H0042: poc_msb_val_present_flag shall be equal to 0 when slice_header_extension_length is (inferred to be ) equal to 0
+#define INFERENCE_POC_RESET_INFO_PRESENT 1      ///< JCT3V-H0042: Infer the value of poc_reset_info_present_flag to be equal to 0 when no pps extension / pps extension for multilayer.
+#define I0044_SLICE_TMVP                 1      ///< JCT3V-I0044: Regarding slice_temporal_mvp_enabled_flag
+#define I0045_BR_PR_ADD_LAYER_SET        1      ///< JCT3V-I0045: Signalling of bit-rate and picture rate for additional layer set
+#define I0045_VPS_VUI_VST_PARAMS         1      ///< JCT3V-I0045: Related to signalling of VST parameters of the base layer.
+
+
+#define H_MV_HLS10_GEN                       0  // General changes (not tested)
+
+#define H_MV_HLS10_AUX                       1 // Auxiliary pictures
+#define H_MV_HLS10_GEN_FIX                   1
+#define H_MV_FIX_LOOP_GOPSIZE                1
+#define H_MV_FIX_SUB_LAYERS_MAX_MINUS1       1
+
+#define H_MV_HLS10_GEN_VSP_CONF_WIN          1  // VPS conformance window
+#define H_MV_HLS10_GEN_VSP_BASE_LAYER_AVAIL  1  // vps_base_layer_available
+#define H_MV_HLS10_REF_PRED_LAYERS           1  // reference and predicted layer derivation
+#define H_MV_HLS10_NESSECARY_LAYER           1  // necessary layers
+#define H_MV_HLS10_ADD_LAYERSETS             1  // additional layer sets
+#define H_MV_HLS10_DBP_SIZE                  1  // dpb size syntax structure
+#define H_MV_HLS10_MAXNUMPICS                1  // constraint on number of pictures in rps  
+#define H_MV_HLS10_PTL                       1  // profile tier level
+#define H_MV_HLS10_PTL_FIX                   1  // profile tier level fix
+#define H_MV_HLS10_PTL_INBL_FIX              1  // profile tier level fix 
+#define H_MV_HLS10_PTL_INFER_FIX             1  // fix inference ptl
+#define H_MV_HLS10_MULTILAYERSPS             1  // multilayer SPS extension 
+#define H_MV_HLS10_VPS_VUI                   1  // vsp vui
+#define H_MV_HLS10_VPS_VUI_BSP               1  // vsp vui bsp
+#define H_MV_HLS10_PPS                       1  // PPS modifications
+
+#define H_MV_HLS10_VPS_VUI_BSP_STORE         0  // Currently bsp vui bsp hrd parameters are not stored, some dynamic memory allocation with upper bounds is required. 
+
+
 #define H_MV_HLS7_GEN                        0  // General changes (not tested)
+
 
 // POC
@@ -457 +506 @@
 #define MAX_NESTING_NUM_LAYER       64
 
+#if H_MV_HLS10_VPS_VUI_BSP
+#define MAX_VPS_NUM_HRD_PARAMETERS                1024
+#define MAX_NUM_SUB_LAYERS                        7
+#define MAX_NUM_SIGNALLED_PARTITIONING_SCHEMES    16
+#else
 #define MAX_VPS_NUM_HRD_PARAMETERS                1
+#endif
+
 #define MAX_VPS_OP_SETS_PLUS1                     1024
 #if H_MV
+#if H_MV_HLS10_ADD_LAYERSETS
+#define MAX_VPS_NUM_ADD_LAYER_SETS                1024
+#endif
 #define MAX_VPS_NUH_LAYER_ID_PLUS1  63
 #define MAX_NUM_SCALABILITY_TYPES   16
@@ -474 +533 @@
 #define MAX_VPS_PROFILE_TIER_LEVEL      64
 #define MAX_VPS_ADD_OUTPUT_LAYER_SETS   1024
+#if H_MV_HLS10_ADD_LAYERSETS
+#define MAX_VPS_OUTPUTLAYER_SETS        ( MAX_VPS_ADD_OUTPUT_LAYER_SETS + MAX_VPS_OP_SETS_PLUS1 + MAX_VPS_OP_SETS_PLUS1 )
+#else
 #define MAX_VPS_OUTPUTLAYER_SETS        ( MAX_VPS_ADD_OUTPUT_LAYER_SETS + MAX_VPS_OP_SETS_PLUS1 )
+#endif
 #define  MAX_NUM_VIDEO_SIGNAL_INFO      16
 #define MAX_NUM_SCALED_REF_LAYERS       MAX_NUM_LAYERS-1
+#if !H_MV_HLS10_VPS_VUI_BSP
 #define MAX_NUM_BSP_HRD_PARAMETERS      100 ///< Maximum value is actually not specified
 #define MAX_NUM_BITSTREAM_PARTITIONS    100 ///< Maximum value is actually not specified 
 #define MAX_NUM_BSP_SCHED_COMBINATION   100 ///< Maximum value is actually not specified 
 #define MAX_SUB_STREAMS                 1024
+#endif
 #else
 #define MAX_NUM_LAYER_IDS                64
@@ -951 +1016 @@
     MAINSTILLPICTURE = 3,
 #if H_MV
+#if H_MV_HLS10_PTL
+    MULTIVIEWMAIN = 6,
+#if H_3D
+    MAIN3D = 8, 
+#endif
+#else
     MAINSTEREO = 4,
     MAINMULTIVIEW = 5,
 #if H_3D
     MAIN3D = 6, 
+#endif
 #endif
 #endif
@@ -997 +1069 @@
 #endif    
     VIEW_ORDER_INDEX  = 1,
+#if H_MV_HLS10_AUX
+    DEPENDENCY_ID = 2,
+    AUX_ID = 3,
+#endif    
   };
 #endif

trunk/source/Lib/TLibDecoder/TDecCAVLC.cpp

@@ -53 +53 @@
   }
   // To avoid mismatches
+#if H_MV_HLS10_GEN_FIX
+  fprintf( g_hTrace, "=========== Sequence Parameter Set LayerId: %d ===========\n", pSPS->getLayerId() );
+#else
   fprintf( g_hTrace, "=========== Sequence Parameter Set ===========\n" );
+#endif
 #else
   fprintf( g_hTrace, "=========== Sequence Parameter Set ID: %d ===========\n", pSPS->getSPSId() );
@@ -66 +70 @@
     return; 
   }
+#if H_MV_HLS10_GEN_FIX
+  fprintf( g_hTrace, "=========== Picture Parameter Set LayerId: %d ===========\n", pPPS->getLayerId() );
+#else
   fprintf( g_hTrace, "=========== Picture Parameter Set ===========\n" );
+#endif
 #else
   fprintf( g_hTrace, "=========== Picture Parameter Set ID: %d ===========\n", pPPS->getPPSId() );
@@ -334 +342 @@
     }
   }
+#if !H_MV_HLS10_PPS
 #if H_MV
   if ( pcPPS->getLayerId() > 0 )
@@ -347 +356 @@
   {  
 #endif
+#endif
   READ_FLAG( uiCode, "pps_scaling_list_data_present_flag" );           pcPPS->setScalingListPresentFlag( uiCode ? true : false );
   if(pcPPS->getScalingListPresentFlag ())
@@ -352 +362 @@
     parseScalingList( pcPPS->getScalingList() );
   }
-#if H_MV
-  }
-#endif
-
+#if !H_MV_HLS10_PPS
+#if H_MV
+  }
+#endif
+#endif
   READ_FLAG( uiCode, "lists_modification_present_flag");
   pcPPS->setListsModificationPresentFlag(uiCode);
@@ -389 +400 @@
     if ( pcPPS->getPpsMultilayerExtensionFlag() )
     { 
+#if H_MV_HLS10_PPS
+      parsePPSMultilayerExtension( pcPPS ); 
+#else
       READ_FLAG( uiCode, "poc_reset_info_present_flag" ); pcPPS->setPocResetInfoPresentFlag( uiCode == 1 );
       READ_FLAG( uiCode, "pps_extension_reserved_zero_flag" );
+#endif
     }
 #if !H_3D
@@ -415 +430 @@
   }
 }
+
 
 #if H_3D
@@ -759 +775 @@
   UInt  uiCode;
   READ_CODE( 4,  uiCode, "sps_video_parameter_set_id");          pcSPS->setVPSId        ( uiCode );
+
 #if H_MV
   if ( pcSPS->getLayerId() == 0 )
@@ -765 +782 @@
     READ_CODE( 3,  uiCode, "sps_max_sub_layers_minus1" );          pcSPS->setMaxTLayers   ( uiCode+1 );
     assert(uiCode <= 6);
+#if H_MV_HLS10_MULTILAYERSPS
+#if H_MV
+  }
+  else
+  {
+    READ_CODE( 3, uiCode, "sps_ext_or_max_sub_layers_minus1" ); pcSPS->setSpsExtOrMaxSubLayersMinus1( uiCode );    
+    pcSPS->inferSpsMaxSubLayersMinus1( false, NULL );
+  }
+  if ( !pcSPS->getMultiLayerExtSpsFlag() )
+  {
+#endif
+#endif
 
     READ_FLAG( uiCode, "sps_temporal_id_nesting_flag" );               pcSPS->setTemporalIdNestingFlag ( uiCode > 0 ? true : false );
@@ -774 +803 @@
 
     parsePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
+#if H_MV_HLS10_PTL_INFER_FIX
+    pcSPS->getPTL()->inferGeneralValues ( true, 0, NULL ); 
+    pcSPS->getPTL()->inferSubLayerValues( pcSPS->getMaxTLayers() - 1, 0, NULL );
+#endif
 #if H_MV
   }
@@ -780 +813 @@
   assert(uiCode <= 15);
 #if H_MV
+#if H_MV_HLS10_MULTILAYERSPS
+  if ( pcSPS->getMultiLayerExtSpsFlag() )
+#else 
   if ( pcSPS->getLayerId() > 0 )
+#endif
   {
     READ_FLAG( uiCode, "update_rep_format_flag" );               pcSPS->setUpdateRepFormatFlag( uiCode == 1 );
@@ -802 +839 @@
     READ_UVLC (    uiCode, "pic_width_in_luma_samples" );          pcSPS->setPicWidthInLumaSamples ( uiCode    );
     READ_UVLC (    uiCode, "pic_height_in_luma_samples" );         pcSPS->setPicHeightInLumaSamples( uiCode    );
-#if H_MV
-  }
+#if !H_MV_HLS10_MULTILAYERSPS
+#if H_MV
+  }
+#endif
 #endif
   READ_FLAG(     uiCode, "conformance_window_flag");
@@ -816 +855 @@
     READ_UVLC(   uiCode, "conf_win_top_offset" );                conf.setWindowTopOffset   ( uiCode  );
     READ_UVLC(   uiCode, "conf_win_bottom_offset" );             conf.setWindowBottomOffset( uiCode  );    
+#if H_MV_HLS10_MULTILAYERSPS
+  }
+#endif
 #else
     READ_UVLC(   uiCode, "conf_win_left_offset" );               conf.setWindowLeftOffset  ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc() ) );
@@ -825 +867 @@
 
 #if H_MV
+#if H_MV_HLS10_MULTILAYERSPS
+  if ( !pcSPS->getMultiLayerExtSpsFlag() )
+#else // H_MV_HLS10_GEN
   if ( pcSPS->getLayerId() == 0 )
+#endif // H_MV_HLS10_GEN
   { 
 #endif
@@ -845 +891 @@
 
 #if H_MV
+#if H_MV_HLS10_MULTILAYERSPS
+  if ( !pcSPS->getMultiLayerExtSpsFlag()) 
+#else 
   if ( pcSPS->getLayerId() == 0 ) 
+#endif
   {  
 #endif
@@ -904 +954 @@
   {
 #if H_MV
+#if H_MV_HLS10_MULTILAYERSPS
+    if ( pcSPS->getMultiLayerExtSpsFlag() )
+#else 
     if ( pcSPS->getLayerId() > 0 )
+#endif
     {    
       READ_FLAG( uiCode, "sps_infer_scaling_list_flag" ); pcSPS->setSpsInferScalingListFlag( uiCode == 1 );
@@ -1032 +1086 @@
   READ_FLAG( uiCode, "inter_view_mv_vert_constraint_flag" );    pcSPS->setInterViewMvVertConstraintFlag(uiCode == 1 ? true : false);
   
+#if !H_MV_HLS10_PPS
   READ_UVLC( uiCode, "num_scaled_ref_layer_offsets" ); pcSPS->setNumScaledRefLayerOffsets( uiCode );
 
@@ -1046 +1101 @@
     READ_FLAG( uiCode, "sps_multilayer_ext_reserved_zero_flag[ i ]" );
   }
+#endif
 }
 
@@ -1066 +1122 @@
 }
 #endif
+
+#if H_MV_HLS10_PPS
+Void TDecCavlc::parsePPSMultilayerExtension(TComPPS* pcPPS)
+{
+  UInt uiCode = 0; 
+  READ_FLAG( uiCode, "poc_reset_info_present_flag" ); pcPPS->setPocResetInfoPresentFlag( uiCode == 1 );
+  READ_FLAG( uiCode, "pps_infer_scaling_list_flag" ); pcPPS->setPpsInferScalingListFlag( uiCode == 1 );
+  READ_CODE( 6, uiCode, "pps_scaling_list_ref_layer_id" ); pcPPS->setPpsScalingListRefLayerId( uiCode );
+  READ_UVLC( uiCode, "num_ref_loc_offsets" ); assert( uiCode == 0 );
+}
+
+#endif
 #endif
 
@@ -1075 +1143 @@
 #if H_MV
   READ_FLAG( uiCode, "vps_base_layer_internal_flag" );            pcVPS->setVpsBaseLayerInternalFlag( uiCode == 1 );
+#if H_MV_HLS10_GEN_VSP_BASE_LAYER_AVAIL
+  READ_FLAG( uiCode, "vps_base_layer_available_flag" );           pcVPS->setVpsBaseLayerAvailableFlag( uiCode == 1 );
+#else
   READ_FLAG( uiCode, "vps_reserved_one_bit" );                    assert( uiCode == 1 ); 
+#endif
 #else
   READ_CODE( 2,  uiCode,  "vps_reserved_three_2bits" );           assert(uiCode == 3);
@@ -1090 +1162 @@
   READ_CODE( 16, uiCode,  "vps_reserved_ffff_16bits" );           assert(uiCode == 0xffff);
   parsePTL ( pcVPS->getPTL(), true, pcVPS->getMaxTLayers()-1);
+#if H_MV_HLS10_PTL_INFER_FIX
+#if H_MV
+  pcVPS->getPTL()->inferGeneralValues ( true, 0, NULL );
+  pcVPS->getPTL()->inferSubLayerValues( pcVPS->getMaxTLayers() - 1, 0, NULL );
+#endif
+#endif
   UInt subLayerOrderingInfoPresentFlag;
   READ_FLAG(subLayerOrderingInfoPresentFlag, "vps_sub_layer_ordering_info_present_flag");
@@ -1115 +1193 @@
   READ_CODE( 6, uiCode, "vps_max_layer_id" );   pcVPS->setVpsMaxLayerId( uiCode );
 
+#if H_MV_HLS10_GEN_FIX
+  READ_UVLC(    uiCode, "vps_num_layer_sets_minus1" );  pcVPS->setVpsNumLayerSetsMinus1( uiCode );
+#else
   READ_UVLC(    uiCode, "vps_max_num_layer_sets_minus1" );               pcVPS->setVpsNumLayerSetsMinus1( uiCode );
+#endif
   for( UInt opsIdx = 1; opsIdx <= pcVPS->getVpsNumLayerSetsMinus1(); opsIdx ++ )
   {
@@ -1204 +1286 @@
   UInt uiCode; 
 
+#if H_MV_HLS10_PTL
+  if( pcVPS->getMaxLayersMinus1() > 0  &&  pcVPS->getVpsBaseLayerInternalFlag() )
+  {
+    parsePTL( pcVPS->getPTL( 1 ),0, pcVPS->getMaxSubLayersMinus1()  );  
+    
+#if !H_MV_HLS10_PTL_INFER_FIX
+    // Copy Profile info
+    TComPTL temp = *pcVPS->getPTL( 1 );
+    *pcVPS->getPTL( 1 ) = *pcVPS->getPTL( 0 );
+    pcVPS->getPTL( 1 )->copyLevelFrom( &temp );
+#else
+    pcVPS->getPTL( 1 )->inferGeneralValues ( false, 1, pcVPS->getPTL( 0 ) );
+    pcVPS->getPTL( 1 )->inferSubLayerValues( pcVPS->getMaxSubLayersMinus1(), 1, pcVPS->getPTL( 0 ) );    
+#endif
+  }
+#endif 
+
   READ_FLAG( uiCode, "splitting_flag" );                          pcVPS->setSplittingFlag( uiCode == 1 ? true : false );
 
@@ -1275 +1374 @@
   }
   pcVPS->setRefLayers(); 
+
+#if H_MV_HLS10_ADD_LAYERSETS
+  if ( pcVPS->getNumIndependentLayers() > 1 ) 
+  {
+    READ_UVLC( uiCode, "num_add_layer_sets"      ); pcVPS->setNumAddLayerSets( uiCode );
+  }
+  for (Int i = 0; i < pcVPS->getNumAddLayerSets(); i++)
+  {
+    for (Int j = 1; j < pcVPS->getNumIndependentLayers(); j++)
+    {
+      READ_CODE( pcVPS->getHighestLayerIdxPlus1Len( j ) , uiCode, "highest_layer_idx_plus1" ); pcVPS->setHighestLayerIdxPlus1( i, j, uiCode );
+    }
+    pcVPS->deriveAddLayerSetLayerIdList( i );
+  }
+#endif
+
   READ_FLAG( uiCode, "vps_sub_layers_max_minus1_present_flag" ); pcVPS->setVpsSubLayersMaxMinus1PresentFlag( uiCode == 1 );
   if ( pcVPS->getVpsSubLayersMaxMinus1PresentFlag() )
@@ -1310 +1425 @@
   READ_UVLC( uiCode, "vps_num_profile_tier_level_minus1" );  pcVPS->setVpsNumProfileTierLevelMinus1( uiCode );  
 
+#if H_MV_HLS10_PTL
+  Int offsetVal =  ( pcVPS->getMaxLayersMinus1() > 0  &&  pcVPS->getVpsBaseLayerInternalFlag() ) ? 2 : 1;   
+  for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 2 : 1; i <= pcVPS->getVpsNumProfileTierLevelMinus1(); i++ )
+  {
+    READ_FLAG(  uiCode, "vps_profile_present_flag[i]" );    pcVPS->setVpsProfilePresentFlag( i, uiCode == 1 );
+    parsePTL ( pcVPS->getPTL( offsetVal ), pcVPS->getVpsProfilePresentFlag( i ), pcVPS->getMaxTLayers()-1);
+#if H_MV_HLS10_PTL_INFER_FIX
+    pcVPS->getPTL( offsetVal )->inferGeneralValues ( pcVPS->getVpsProfilePresentFlag( i ), offsetVal, pcVPS->getPTL( offsetVal - 1 ) );    
+    pcVPS->getPTL( offsetVal )->inferSubLayerValues( pcVPS->getMaxSubLayersMinus1()      , offsetVal, pcVPS->getPTL( offsetVal - 1 ) );    
+#else
+    if( !pcVPS->getVpsProfilePresentFlag( i ) )
+    {
+      TComPTL temp = *pcVPS->getPTL( offsetVal );
+      *pcVPS->getPTL( offsetVal ) = *pcVPS->getPTL( offsetVal - 1 );
+      pcVPS->getPTL( offsetVal )->copyLevelFrom( &temp );
+    }
+#endif
+    offsetVal++;
+  }
+#else 
   for( Int i = 1; i <= pcVPS->getVpsNumProfileTierLevelMinus1(); i++ )
   {
@@ -1321 +1456 @@
     }
   }
-
+#endif 
+
+#if !H_MV_HLS10_ADD_LAYERSETS
   if ( pcVPS->getNumIndependentLayers() > 1 ) 
   {
@@ -1333 +1470 @@
     }
   }
+#endif
+
   if (pcVPS->getNumLayerSets() > 1)
   {
@@ -1345 +1484 @@
   pcVPS->setLayerSetIdxForOlsMinus1(0, -1); 
 
+#if H_MV_HLS10_NESSECARY_LAYER
+  pcVPS->deriveNecessaryLayerFlags( 0 ); 
+#endif 
   pcVPS->deriveTargetLayerIdList( 0 ); 
 
+#if H_MV_HLS10_PTL_FIX
+  if (pcVPS->getVpsBaseLayerInternalFlag() )
+  {  
+    pcVPS->setProfileTierLevelIdx(0,0, pcVPS->inferProfileTierLevelIdx(0,0) );
+  }
+#endif
   for( Int i = 1; i < pcVPS->getNumOutputLayerSets( ); i++ )
   {
     if( i >= pcVPS->getNumLayerSets( ) )    
     {        
+#if !VPS_MISC_UPDATES
       READ_UVLC( uiCode,      "layer_set_idx_for_ols_minus1[i]" ); pcVPS->setLayerSetIdxForOlsMinus1( i, uiCode ); 
+#else
+      READ_CODE( pcVPS->getLayerSetIdxForOlsMinus1Len( i ), uiCode, "layer_set_idx_for_ols_minus1[i]" ); pcVPS->setLayerSetIdxForOlsMinus1( i, uiCode ); 
+#endif
     }
 
@@ -1368 +1520 @@
       }
     }
+#if H_MV_HLS10_NESSECARY_LAYER
+    pcVPS->deriveNecessaryLayerFlags( i ); 
+#endif
     pcVPS->deriveTargetLayerIdList( i ); 
 
+#if H_MV_HLS10_PTL
+    for ( Int j = 0; j < pcVPS->getNumLayersInIdList( pcVPS->olsIdxToLsIdx(i)); j++ )
+    {    
+      if (pcVPS->getNecessaryLayerFlag( i, j ) && pcVPS->getVpsNumProfileTierLevelMinus1() > 0 )
+      {
+        READ_CODE( pcVPS->getProfileTierLevelIdxLen(), uiCode,"profile_tier_level_idx[ i ][ j ]" );   pcVPS->setProfileTierLevelIdx( i, j, uiCode ); 
+      }
+#if H_MV_HLS10_PTL_FIX
+      if (pcVPS->getNecessaryLayerFlag( i, j ) && pcVPS->getVpsNumProfileTierLevelMinus1() == 0 )
+      {
+        pcVPS->setProfileTierLevelIdx( i , j, pcVPS->inferProfileTierLevelIdx( i, j) );
+      }
+#endif
+    }
+#else
     if ( pcVPS->getProfileLevelTierIdxLen()  > 0 )
-    {      
+    { 
       READ_CODE( pcVPS->getProfileLevelTierIdxLen(), uiCode,"profile_level_tier_idx[ i ]" );   pcVPS->setProfileLevelTierIdx( i , uiCode ); 
     }
+#endif
+
     if( pcVPS->getNumOutputLayersInOutputLayerSet( i ) == 1 && pcVPS->getNumDirectRefLayers( pcVPS->getOlsHighestOutputLayerId( i ) ) > 0 )
     {
@@ -1422 +1594 @@
   }
 
+#if !H_MV_HLS10_GEN_FIX
   READ_FLAG( uiCode, "vps_reserved_zero_flag" ); 
+#endif
   parseDpbSize( pcVPS ); 
 
@@ -1484 +1658 @@
   if ( pcRepFormat->getChromaAndBitDepthVpsPresentFlag() )
   {  
-  READ_CODE( 2,  uiCode, "chroma_format_vps_idc" );          pcRepFormat->setChromaFormatVpsIdc       ( uiCode );
-  if ( pcRepFormat->getChromaFormatVpsIdc() == 3 )
-  {
-    READ_FLAG( uiCode, "separate_colour_plane_vps_flag" ); pcRepFormat->setSeparateColourPlaneVpsFlag( uiCode == 1 ); 
-  }
-  READ_CODE( 4,  uiCode, "bit_depth_vps_luma_minus8" );      pcRepFormat->setBitDepthVpsLumaMinus8    ( uiCode );
-  READ_CODE( 4,  uiCode, "bit_depth_vps_chroma_minus8" );    pcRepFormat->setBitDepthVpsChromaMinus8  ( uiCode );
+    READ_CODE( 2,  uiCode, "chroma_format_vps_idc" );          pcRepFormat->setChromaFormatVpsIdc       ( uiCode );
+    if ( pcRepFormat->getChromaFormatVpsIdc() == 3 )
+    {
+      READ_FLAG( uiCode, "separate_colour_plane_vps_flag" ); pcRepFormat->setSeparateColourPlaneVpsFlag( uiCode == 1 ); 
+    }
+    READ_CODE( 4,  uiCode, "bit_depth_vps_luma_minus8" );      pcRepFormat->setBitDepthVpsLumaMinus8    ( uiCode );
+    READ_CODE( 4,  uiCode, "bit_depth_vps_chroma_minus8" );    pcRepFormat->setBitDepthVpsChromaMinus8  ( uiCode );
   }
   else
@@ -1496 +1670 @@
     pcRepFormat->inferChromaAndBitDepth(pcPrevRepFormat, false ); 
   }
+#if H_MV_HLS10_GEN_VSP_CONF_WIN
+  READ_FLAG( uiCode, "conformance_window_vps_flag" ); pcRepFormat->setConformanceWindowVpsFlag( uiCode == 1 );
+  if ( pcRepFormat->getConformanceWindowVpsFlag() )
+  {
+    READ_UVLC( uiCode, "conf_win_vps_left_offset" ); pcRepFormat->setConfWinVpsLeftOffset( uiCode );
+    READ_UVLC( uiCode, "conf_win_vps_right_offset" ); pcRepFormat->setConfWinVpsRightOffset( uiCode );
+    READ_UVLC( uiCode, "conf_win_vps_top_offset" ); pcRepFormat->setConfWinVpsTopOffset( uiCode );
+    READ_UVLC( uiCode, "conf_win_vps_bottom_offset" ); pcRepFormat->setConfWinVpsBottomOffset( uiCode );
+  }
+#endif 
 }
 
@@ -1521 +1705 @@
   if( pcVPSVUI->getBitRatePresentVpsFlag( )  ||  pcVPSVUI->getPicRatePresentVpsFlag( ) )
   {
+#if H_MV_HLS10_VPS_VUI
+    for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i  <  pcVPS->getNumLayerSets(); i++ )
+#else
     for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i  <=  pcVPS->getVpsNumLayerSetsMinus1(); i++ )
+#endif
     {
       for( Int j = 0; j  <=  pcVPS->getMaxSubLayersInLayerSetMinus1( i ); j++ ) 
@@ -1554 +1742 @@
   else
   {
+#if H_MV_HLS10_VPS_VUI
+    pcVPSVUI->setVpsNumVideoSignalInfoMinus1( pcVPS->getMaxLayersMinus1() - pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1 ); 
+#else
     pcVPSVUI->setVpsNumVideoSignalInfoMinus1( pcVPS->getMaxLayersMinus1() ); 
+#endif
   }
 
@@ -1565 +1757 @@
   }
 
+#if I0045_VPS_VUI_VST_PARAMS
+  if( pcVPSVUI->getVideoSignalInfoIdxPresentFlag() && pcVPSVUI->getVpsNumVideoSignalInfoMinus1() > 0 )
+  {
+    for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i <=  pcVPS->getMaxLayersMinus1(); i++ )
+    {
+      READ_CODE( 4, uiCode, "vps_video_signal_info_idx" ); pcVPSVUI->setVpsVideoSignalInfoIdx( i, uiCode );
+    }
+  }
+  else if ( !pcVPSVUI->getVideoSignalInfoIdxPresentFlag() )
+  {
+    for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i <=  pcVPS->getMaxLayersMinus1(); i++ )
+    {
+      pcVPSVUI->setVpsVideoSignalInfoIdx( i, i );
+    }
+  }
+  else
+  {
+    for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i <=  pcVPS->getMaxLayersMinus1(); i++ )
+    {
+      pcVPSVUI->setVpsVideoSignalInfoIdx( i, 0 );
+    }
+  }
+#else
   if( pcVPSVUI->getVideoSignalInfoIdxPresentFlag() && pcVPSVUI->getVpsNumVideoSignalInfoMinus1() > 0 )
   {
@@ -1580 +1795 @@
     }
   }
+#endif
   READ_FLAG( uiCode, "tiles_not_in_use_flag" ); pcVPSVUI->setTilesNotInUseFlag( uiCode == 1 );
   if( !pcVPSVUI->getTilesNotInUseFlag() ) 
@@ -1594 +1810 @@
     {
       for( Int j = 0; j < pcVPS->getNumDirectRefLayers( pcVPS->getLayerIdInNuh( i ) ) ; j++ )
-      {  
+      {
+#if H_MV_HLS10_REF_PRED_LAYERS
+        Int layerIdx = pcVPS->getLayerIdInVps(pcVPS->getIdDirectRefLayer(pcVPS->getLayerIdInNuh( i ) , j  ));  
+#else
         Int layerIdx = pcVPS->getLayerIdInVps(pcVPS->getRefLayerId(pcVPS->getLayerIdInNuh( i ) , j  ));  
+#endif
         if( pcVPSVUI->getTilesInUseFlag( i )  &&  pcVPSVUI->getTilesInUseFlag( layerIdx ) )  
         {
@@ -1613 +1833 @@
     }
   }
+#if H_MV_HLS10_VPS_VUI
+  READ_FLAG( uiCode, "single_layer_for_non_irap_flag" ); pcVPSVUI->setSingleLayerForNonIrapFlag( uiCode == 1 );
+  READ_FLAG( uiCode, "higher_layer_irap_skip_flag" ); pcVPSVUI->setHigherLayerIrapSkipFlag( uiCode == 1 );
+#else 
   READ_CODE( 3, uiCode, "vps_vui_reserved_zero_3bits" ); 
+#endif
   READ_FLAG( uiCode, "ilp_restricted_ref_layers_flag" ); pcVPSVUI->setIlpRestrictedRefLayersFlag( uiCode == 1 );
 
@@ -1622 +1847 @@
       for( Int j = 0; j < pcVPS->getNumDirectRefLayers( pcVPS->getLayerIdInNuh( i ) ); j++ )
       {
+#if H_MV_HLS10_REF_PRED_LAYERS
+        if( pcVPS->getVpsBaseLayerInternalFlag() || pcVPS->getIdDirectRefLayer( pcVPS->getLayerIdInNuh( i ), j ) > 0 )
+#else
         if( pcVPS->getVpsBaseLayerInternalFlag() || pcVPS->getRefLayerId( pcVPS->getLayerIdInNuh( i ), j ) > 0 )
+#endif
         {        
           READ_UVLC( uiCode, "min_spatial_segment_offset_plus1" ); pcVPSVUI->setMinSpatialSegmentOffsetPlus1( i, j, uiCode );
@@ -1641 +1870 @@
   if ( pcVPSVUI->getVpsVuiBspHrdPresentFlag( ) )
   {
+#if VPS_MISC_UPDATES
+    assert(pcVPS->getTimingInfo()->getTimingInfoPresentFlag() == 1);
+#endif
     parseVpsVuiBspHrdParameters( pcVPS ); 
   }
@@ -1661 +1893 @@
 
   TComVpsVuiBspHrdParameters*  vpsVuiBspHrdP = pcVPSVUI->getVpsVuiBspHrdParameters(); 
-  
+#if H_MV_HLS10_VPS_VUI_BSP
+  assert( vpsVuiBspHrdP == NULL ); 
+  vpsVuiBspHrdP = new TComVpsVuiBspHrdParameters; 
+  pcVPSVUI->setVpsVuiBspHrdParameters( vpsVuiBspHrdP ); 
+#else
   assert ( vpsVuiBspHrdP );
-
+#endif
   UInt uiCode; 
+#if H_MV_HLS10_VPS_VUI_BSP
+  READ_UVLC( uiCode, "vps_num_add_hrd_params" ); vpsVuiBspHrdP->setVpsNumAddHrdParams( uiCode );
+  vpsVuiBspHrdP->createAfterVpsNumAddHrdParams( pcVPS ); 
+  for( Int i = pcVPS->getNumHrdParameters(); i < pcVPS->getNumHrdParameters() + vpsVuiBspHrdP->getVpsNumAddHrdParams(); i++ )
+  {  
+    if( i > 0 )  
+    {
+      READ_FLAG( uiCode, "cprms_add_present_flag" ); vpsVuiBspHrdP->setCprmsAddPresentFlag( i, uiCode == 1 );
+    }
+    else
+    {
+       vpsVuiBspHrdP->setCprmsAddPresentFlag( i, true );
+    }
+
+    READ_UVLC( uiCode, "num_sub_layer_hrd_minus1" ); vpsVuiBspHrdP->setNumSubLayerHrdMinus1( i, uiCode );
+    TComHRD* hrdParameters = vpsVuiBspHrdP->getHrdParametermeters( i ); 
+    parseHrdParameters( hrdParameters, vpsVuiBspHrdP->getCprmsAddPresentFlag( i ), vpsVuiBspHrdP->getNumSubLayerHrdMinus1( i ) );     
+  }
+
+  vpsVuiBspHrdP->setNumPartitionsInSchemeMinus1( 0, 0, 0);
+  vpsVuiBspHrdP->createAfterNumPartitionsInSchemeMinus1( 0, 0 );
+
+  for( Int h = 0; h < pcVPS->getNumOutputLayerSets(); h++ )
+  { 
+    if ( h == 0)
+    {
+      vpsVuiBspHrdP->setNumSignalledPartitioningSchemes( h, 0 );
+    }
+    else
+    {
+      READ_UVLC( uiCode, "num_signalled_partitioning_schemes" ); vpsVuiBspHrdP->setNumSignalledPartitioningSchemes( h, uiCode );
+    }    
+    vpsVuiBspHrdP->createAfterNumSignalledPartitioningSchemes( h );
+
+    for( Int j = 0; j < vpsVuiBspHrdP->getNumSignalledPartitioningSchemes( h ) + 1; j++ )
+    { 
+      if ( j == 0 && h == 0 )
+      {
+        vpsVuiBspHrdP->setNumPartitionsInSchemeMinus1( h, j, uiCode );
+      }
+      else if( j == 0 )
+      {
+        vpsVuiBspHrdP->setNumPartitionsInSchemeMinus1( h, j, pcVPS->getNumLayersInIdList( h ) - 1 );
+      }
+      else
+      {
+        READ_UVLC( uiCode, "num_partitions_in_scheme_minus1" ); vpsVuiBspHrdP->setNumPartitionsInSchemeMinus1( h, j, uiCode );
+      }
+      vpsVuiBspHrdP->createAfterNumPartitionsInSchemeMinus1( h, j );
+
+      for( Int k = 0; k  <=  vpsVuiBspHrdP->getNumPartitionsInSchemeMinus1( h, j ); k++ )  
+      {
+        for( Int r = 0; r < pcVPS->getNumLayersInIdList(pcVPS->olsIdxToLsIdx( h ) )   ; r++ )  
+        {
+          if( h == 0 && j == 0 && k == 0 && r == 0 )
+          {
+             vpsVuiBspHrdP->setLayerIncludedInPartitionFlag( h, j, k, r, true );
+          }
+          else if ( h > 0 && j == 0 )
+          {
+             vpsVuiBspHrdP->setLayerIncludedInPartitionFlag( h, j, k, r, (k == r) );
+          }
+          else
+          {
+            READ_FLAG( uiCode, "layer_included_in_partition_flag" ); vpsVuiBspHrdP->setLayerIncludedInPartitionFlag( h, j, k, r, uiCode == 1 );
+          }          
+        }
+      }
+    }  
+    if ( h > 0 )
+    {
+      for( Int i = 0; i < vpsVuiBspHrdP->getNumSignalledPartitioningSchemes( h ) + 1; i++ )  
+      {
+        for( Int t = 0; t  <=  pcVPS->getMaxSubLayersInLayerSetMinus1( pcVPS->olsIdxToLsIdx( i ) ); t++ )
+        {  
+          READ_UVLC( uiCode, "num_bsp_schedules_minus1" ); vpsVuiBspHrdP->setNumBspSchedulesMinus1( h, i, t, uiCode );
+          vpsVuiBspHrdP->createAfterNumBspSchedulesMinus1( h, i, t );
+          for( Int j = 0; j  <=  vpsVuiBspHrdP->getNumBspSchedulesMinus1( h, i, t ); j++ )  
+          {
+            for( Int k = 0; k  <=  vpsVuiBspHrdP->getNumPartitionsInSchemeMinus1( h, j ); k++ )
+            {  
+              READ_CODE( vpsVuiBspHrdP->getBspHrdIdxLen( pcVPS ), uiCode, "bsp_hrd_idx" ); vpsVuiBspHrdP->setBspHrdIdx( h, i, t, j, k, uiCode );
+              READ_UVLC( uiCode, "bsp_sched_idx" ); vpsVuiBspHrdP->setBspSchedIdx( h, i, t, j, k, uiCode );
+            }  
+          }
+        }  
+      }
+    }
+  }  
+#else
   READ_UVLC( uiCode, "vps_num_bsp_hrd_parameters_minus1" ); vpsVuiBspHrdP->setVpsNumBspHrdParametersMinus1( uiCode );
   for( Int i = 0; i <= vpsVuiBspHrdP->getVpsNumBspHrdParametersMinus1( ); i++ )
@@ -1701 +2027 @@
     }  
   }  
-}  
+#endif  
+}
 
 Void TDecCavlc::parseVideoSignalInfo( TComVideoSignalInfo* pcVideoSignalInfo ) 
@@ -1733 +2060 @@
         for( Int k = 0; k < vps->getNumLayersInIdList( currLsIdx ); k++ )   
         {
+#if H_MV_HLS10_DBP_SIZE
+          if ( vps->getNecessaryLayerFlag( i, k ) && ( vps->getVpsBaseLayerInternalFlag() || ( vps->getLayerSetLayerIdList(vps->olsIdxToLsIdx(i),k) != 0 ) ))
+          {
+            READ_UVLC( uiCode, "max_vps_dec_pic_buffering_minus1" ); dpbSize->setMaxVpsDecPicBufferingMinus1( i, k, j, uiCode );
+          }
+          else
+          {
+            if ( vps->getNecessaryLayerFlag( i, k ) && ( j == 0 ) && ( k == 0 ))
+            {
+              dpbSize->setMaxVpsDecPicBufferingMinus1(i ,k, j, 0 );
+            }
+          }
+#else
           READ_UVLC( uiCode, "max_vps_dec_pic_buffering_minus1" ); dpbSize->setMaxVpsDecPicBufferingMinus1( i, k, j, uiCode );
+#endif
         }
         READ_UVLC( uiCode, "max_vps_num_reorder_pics" ); dpbSize->setMaxVpsNumReorderPics( i, j, uiCode );
@@ -1744 +2085 @@
           for( Int k = 0; k < vps->getNumLayersInIdList( vps->olsIdxToLsIdx( i ) ); k++ )   
           {
-            dpbSize->setMaxVpsDecPicBufferingMinus1( i, k, j, dpbSize->getMaxVpsDecPicBufferingMinus1( i,k, j - 1 ) );
+#if H_MV_HLS10_DBP_SIZE
+            if ( vps->getNecessaryLayerFlag(i, k ) )
+            {            
+#endif
+              dpbSize->setMaxVpsDecPicBufferingMinus1( i, k, j, dpbSize->getMaxVpsDecPicBufferingMinus1( i,k, j - 1 ) );
+#if H_MV_HLS10_DBP_SIZE
+            }
+#endif            
           }
           dpbSize->setMaxVpsNumReorderPics      ( i, j, dpbSize->getMaxVpsNumReorderPics      ( i, j - 1 ) );
@@ -1940 +2288 @@
   sps->inferScalingList( parameterSetManager->getActiveSPS( sps->getSpsScalingListRefLayerId() ) );   
   sps->inferSpsMaxDecPicBufferingMinus1( vps, targetOlsIdx, rpcSlice->getLayerId(), false ); 
+#if !H_MV_HLS10_ADD_LAYERSETS 
   vps->inferDbpSizeLayerSetZero( sps, false ); 
+#endif
 
   if ( sps->getVuiParametersPresentFlag() )
@@ -2008 +2358 @@
       esb++; 
       READ_FLAG( uiCode, "discardable_flag" ); rpcSlice->setDiscardableFlag( uiCode == 1 );
+#if NON_REF_NAL_TYPE_DISCARDABLE
+      if ( uiCode == 1 )
+      {
+        assert(rpcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TRAIL_R &&
+          rpcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TSA_R &&
+          rpcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_STSA_R &&
+          rpcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RADL_R &&
+          rpcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RASL_R);
+      }
+#endif
     }
 
@@ -2155 +2515 @@
           rps->checkMaxNumPics( 
             vps->getVpsExtensionFlag(), 
+#if H_MV_HLS10_MAXNUMPICS
+            MAX_INT,  // To be replaced by MaxDbpSize
+#else
             vps->getMaxNumPics( rpcSlice->getLayerId() ),
+#endif
             rpcSlice->getLayerId(), 
             sps->getMaxDecPicBuffering( sps->getSpsMaxSubLayersMinus1() ) - 1 );
@@ -2268 +2632 @@
         rps->checkMaxNumPics( 
           vps->getVpsExtensionFlag(), 
+#if H_MV_HLS10_MAXNUMPICS
+            MAX_INT,  // To be replaced by MaxDbpsize
+#else
           vps->getMaxNumPics( rpcSlice->getLayerId() ),
+#endif
           rpcSlice->getLayerId(), 
           sps->getMaxDecPicBuffering( sps->getSpsMaxSubLayersMinus1() ) - 1 );
@@ -2287 +2655 @@
       if (rpcSlice->getSPS()->getTMVPFlagsPresent())
       {
+#if I0044_SLICE_TMVP
+        READ_FLAG( uiCode, "slice_temporal_mvp_enabled_flag" );
+#else
         READ_FLAG( uiCode, "slice_temporal_mvp_enable_flag" );
+#endif
         rpcSlice->setEnableTMVPFlag( uiCode == 1 ? true : false ); 
       }
@@ -2637 +3009 @@
 
 #if H_3D
+#if LGE_FCO_I0116
+  if( rpcSlice->getVPS()->hasCamParInSliceHeader( rpcSlice->getViewIndex() )  && rpcSlice->getIsDepth() )
+#else
   if( rpcSlice->getVPS()->hasCamParInSliceHeader( rpcSlice->getViewIndex() )  && !rpcSlice->getIsDepth() )
+#endif
   {
     UInt uiViewIndex = rpcSlice->getViewIndex();
@@ -2723 +3099 @@
 #endif
   }
+#if INFERENCE_POC_MSB_VAL_PRESENT
+  else
+  {
+    rpcSlice->setSliceSegmentHeaderExtensionLength( 0 );
+    rpcSlice->setPocMsbValPresentFlag( false );
+  }
+#endif
 
 
@@ -2815 +3198 @@
       READ_FLAG( uiCode, "sub_layer_profile_present_flag[i]" ); rpcPTL->setSubLayerProfilePresentFlag(i, uiCode);
 #if H_MV
-    rpcPTL->setSubLayerProfilePresentFlag( i, profilePresentFlag && rpcPTL->getSubLayerProfilePresentFlag(i) );
+#if !H_MV_HLS10_PTL_INFER_FIX
+      rpcPTL->setSubLayerProfilePresentFlag( i, profilePresentFlag && rpcPTL->getSubLayerProfilePresentFlag(i) );
+#else
+      // When profilePresentFlag is equal to 0, sub_layer_profile_present_flag[ i ] shall be equal to 0.
+      assert( profilePresentFlag || !rpcPTL->getSubLayerProfilePresentFlag(i) );
+#endif
 #else
     }
@@ -2833 +3221 @@
   for(Int i = 0; i < maxNumSubLayersMinus1; i++)
   {
-    if( profilePresentFlag && rpcPTL->getSubLayerProfilePresentFlag(i) )
+#if H_MV_HLS10_PTL_INFER_FIX
+#if H_MV
+    if( rpcPTL->getSubLayerProfilePresentFlag(i) )         
+#else
+    if( profilePresentFlag && rpcPTL->getSubLayerProfilePresentFlag(i) )          
+#endif
+#else
+    if( profilePresentFlag && rpcPTL->getSubLayerProfilePresentFlag(i) )    
+#endif
     {
       parseProfileTier(rpcPTL->getSubLayerPTL(i));
@@ -2866 +3262 @@
   ptl->setFrameOnlyConstraintFlag(uiCode ? true : false);
   
+#if H_MV_HLS10_PTL
+#if H_MV_HLS10_PTL_INFER_FIX
+  if( ptl->getV2ConstraintsPresentFlag() )
+#else
+  if( ptl->getProfileIdc( ) ==  4 || ptl->getProfileCompatibilityFlag( 4 )  ||
+      ptl->getProfileIdc( ) ==  5 || ptl->getProfileCompatibilityFlag( 5 )  ||
+      ptl->getProfileIdc( ) ==  6 || ptl->getProfileCompatibilityFlag( 6 )  ||
+      ptl->getProfileIdc( ) ==  7 || ptl->getProfileCompatibilityFlag( 7 ) ) 
+#endif
+  {
+    READ_FLAG( uiCode, "max_12bit_constraint_flag" );        ptl->setMax12bitConstraintFlag      ( uiCode == 1 );
+    READ_FLAG( uiCode, "max_10bit_constraint_flag" );        ptl->setMax10bitConstraintFlag      ( uiCode == 1 );
+    READ_FLAG( uiCode, "max_8bit_constraint_flag" );         ptl->setMax8bitConstraintFlag       ( uiCode == 1 );
+    READ_FLAG( uiCode, "max_422chroma_constraint_flag" );    ptl->setMax422chromaConstraintFlag  ( uiCode == 1 );
+    READ_FLAG( uiCode, "max_420chroma_constraint_flag" );    ptl->setMax420chromaConstraintFlag  ( uiCode == 1 );
+    READ_FLAG( uiCode, "max_monochrome_constraint_flag" );   ptl->setMaxMonochromeConstraintFlag ( uiCode == 1 );
+    READ_FLAG( uiCode, "intra_constraint_flag" );            ptl->setIntraConstraintFlag         ( uiCode == 1 );
+    READ_FLAG( uiCode, "one_picture_only_constraint_flag" ); ptl->setOnePictureOnlyConstraintFlag( uiCode == 1 );
+    READ_FLAG( uiCode, "lower_bit_rate_constraint_flag" );   ptl->setLowerBitRateConstraintFlag  ( uiCode == 1 );    
+    READ_CODE(16, uiCode, "XXX_reserved_zero_34bits[0..15]");
+    READ_CODE(16, uiCode, "XXX_reserved_zero_34bits[16..31]");
+    READ_CODE(2 , uiCode, "XXX_reserved_zero_34bits[32..33]");
+  }
+  else
+  {
+    READ_CODE(16, uiCode, "XXX_reserved_zero_43bits[0..15]");
+    READ_CODE(16, uiCode, "XXX_reserved_zero_43bits[16..31]");
+    READ_CODE(11, uiCode, "XXX_reserved_zero_43bits[32..42]");
+  }
+#if H_MV_HLS10_PTL_INFER_FIX
+  if( ptl->getInbldPresentFlag() )
+#else
+  if( ( ptl->getProfileIdc() >= 1 && ptl->getProfileIdc() <= 5 )  ||
+    ptl->getProfileCompatibilityFlag( 1 ) || ptl->getProfileCompatibilityFlag( 2 )  ||
+    ptl->getProfileCompatibilityFlag( 3 ) || ptl->getProfileCompatibilityFlag( 4 )  ||
+    ptl->getProfileCompatibilityFlag( 5 ) )
+#endif
+  {
+    READ_FLAG( uiCode, "inbld_flag" ); ptl->setInbldFlag( uiCode == 1 );
+  }
+  else
+  {
+    READ_FLAG(uiCode, "reserved_zero_bit");
+  }
+#else
   READ_CODE(16, uiCode, "XXX_reserved_zero_44bits[0..15]");
   READ_CODE(16, uiCode, "XXX_reserved_zero_44bits[16..31]");
   READ_CODE(12, uiCode, "XXX_reserved_zero_44bits[32..43]");
+#endif
 }
 

trunk/source/Lib/TLibDecoder/TDecCAVLC.h

@@ -97 +97 @@
 #endif
 
+#if H_MV_HLS10_PPS
+#if H_MV
+  Void  parsePPSMultilayerExtension( TComPPS* pcPPS );
+#endif
+#endif
+
+
 #if H_3D
   Void  parsePPS            ( TComPPS* pcPPS, TComVPS* pcVPS );

trunk/source/Lib/TLibDecoder/TDecCu.cpp

@@ -859 +859 @@
   // get collocated depth block
   UInt uiDepthStride = 0;
+#if LGE_FCO_I0116
+  Pel* pDepthPels = pcCU->getVirtualDepthBlock(pcCU->getZorderIdxInCU(), pcCU->getWidth(0), pcCU->getHeight(0), uiDepthStride);
+#else
   Pel* pDepthPels = pcCU->getVirtualDepthBlock(0, pcCU->getWidth(0), pcCU->getHeight(0), uiDepthStride);
+#endif
   AOF( pDepthPels != NULL );
   AOF( uiDepthStride != 0 );

trunk/source/Lib/TLibDecoder/TDecSbac.cpp

@@ -794 +794 @@
 
 #if MTK_I0099_VPS_EX2
+#if LGE_FCO_I0116
+  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && bLimQtPredFlag && pcTexture->getReconMark())
+#else
   if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && bLimQtPredFlag)
+#endif
 #else
   if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTL() && sps->getUsePC())
@@ -854 +858 @@
   UInt uiTexturePart = uiMode;
 #if MTK_I0099_VPS_EX2
+#if LGE_FCO_I0116
+  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && bLimQtPredFlag && pcTexture->getReconMark())
+#else
   if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && bLimQtPredFlag )
+#endif
 #else
   if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTL() && sps->getUsePC())

trunk/source/Lib/TLibDecoder/TDecTop.cpp

@@ -229 +229 @@
   }
 
+#if !LGE_FCO_I0116
   if ( pcSlice->getIsDepth())
   {
     return;
   }
+#endif
 
   Int curPoc = pcSlice->getPOC();
@@ -667 +669 @@
 #if H_MV
   sps->inferSpsMaxDecPicBufferingMinus1( vps, m_targetOptLayerSetIdx, getLayerId(), false ); 
+#if !H_MV_HLS10_ADD_LAYERSETS 
   vps->inferDbpSizeLayerSetZero( sps, false ); 
+#endif
   // When the value of vps_num_rep_formats_minus1 in the active VPS is equal to 0
   if ( vps->getVpsNumRepFormatsMinus1() == 0 )
@@ -675 +679 @@
   }
   sps->checkRpsMaxNumPics( vps, getLayerId() ); 
+#if H_MV_HLS10_MULTILAYERSPS
+
+  if( sps->getLayerId() != 0 )
+  {
+    sps->inferSpsMaxSubLayersMinus1( true, vps ); 
+  }
+
+#if H_MV_HLS10_MULTILAYERSPS
+  // It is a requirement of bitstream conformance that, when the SPS is referred to by 
+  // any current picture that belongs to an independent non-base layer, the value of 
+  // MultiLayerExtSpsFlag derived from the SPS shall be equal to 0.
+
+  if ( m_layerId > 0 && vps->getNumRefLayers( m_layerId ) == 0 )
+  {  
+    assert( sps->getMultiLayerExtSpsFlag() == 0 ); 
+  }
+#endif
+
+  if( sps->getMultiLayerExtSpsFlag() )
+  {
+    sps->setTemporalIdNestingFlag( (sps->getMaxTLayers() > 1) ? vps->getTemporalNestingFlag() : true );
+  }
+#else
   if( m_layerId > 0 )
   {
     sps->setTemporalIdNestingFlag( (sps->getMaxTLayers() > 1) ? vps->getTemporalNestingFlag() : true );
   }
+#endif
 #endif
 
@@ -702 +730 @@
 #if H_MV
   m_apcSlicePilot->setVPS(vps);  
+#if H_MV_HLS10_REF_PRED_LAYERS
+  // The nuh_layer_id value of the NAL unit containing the PPS that is activated for a layer layerA with nuh_layer_id equal to nuhLayerIdA shall be equal to 0, or nuhLayerIdA, or the nuh_layer_id of a direct or indirect reference layer of layerA.
+  assert( pps->getLayerId() == m_layerId || pps->getLayerId( ) == 0 || vps->getDependencyFlag( m_layerId, pps->getLayerId() ) );   
+  // The nuh_layer_id value of the NAL unit containing the SPS that is activated for a layer layerA with nuh_layer_id equal to nuhLayerIdA shall be equal to 0, or nuhLayerIdA, or the nuh_layer_id of a direct or indirect reference layer of layerA.
+  assert( sps->getLayerId() == m_layerId || sps->getLayerId( ) == 0 || vps->getDependencyFlag( m_layerId, sps->getLayerId() ) );
+#else
   // The nuh_layer_id value of the NAL unit containing the PPS that is activated for a layer layerA with nuh_layer_id equal to nuhLayerIdA shall be equal to 0, or nuhLayerIdA, or the nuh_layer_id of a direct or indirect reference layer of layerA.
   assert( pps->getLayerId() == m_layerId || pps->getLayerId( ) == 0 || vps->getInDirectDependencyFlag( m_layerId, pps->getLayerId() ) );   
   // The nuh_layer_id value of the NAL unit containing the SPS that is activated for a layer layerA with nuh_layer_id equal to nuhLayerIdA shall be equal to 0, or nuhLayerIdA, or the nuh_layer_id of a direct or indirect reference layer of layerA.
   assert( sps->getLayerId() == m_layerId || sps->getLayerId( ) == 0 || vps->getInDirectDependencyFlag( m_layerId, sps->getLayerId() ) );
+#endif
   sps->inferRepFormat  ( vps , m_layerId ); 
   sps->inferScalingList( m_parameterSetManagerDecoder.getActiveSPS( sps->getSpsScalingListRefLayerId() ) ); 
+
 #endif
   pps->setSPS(sps);
@@ -909 +945 @@
    }
 #endif
+   
+#if I0044_SLICE_TMVP
+  if ( m_apcSlicePilot->getTLayer() == 0 && m_apcSlicePilot->getEnableTMVPFlag() == 0 )
+  {
+    //update all pics in the DPB such that they cannot be used for TMPV ref
+    TComList<TComPic*>::iterator  iterRefPic = m_cListPic.begin();  
+    while( iterRefPic != m_cListPic.end() )
+    {
+      TComPic *refPic = *iterRefPic;
+      if( ( refPic->getLayerId() == m_apcSlicePilot->getLayerId() ) && refPic->getReconMark() )
+      {
+        for(Int i = refPic->getNumAllocatedSlice()-1; i >= 0; i--)
+        {
+
+          TComSlice *refSlice = refPic->getSlice(i);
+          refSlice->setAvailableForTMVPRefFlag( false );
+        }
+      }
+      iterRefPic++;
+    }
+  }
+  m_apcSlicePilot->setAvailableForTMVPRefFlag( true );
+#endif
+
   xActivateParameterSets();
 
@@ -1133 +1193 @@
 #endif
     // For generalized B
+#if I0044_SLICE_TMVP
+    if( m_layerId > 0 && !pcSlice->isIntra() && pcSlice->getEnableTMVPFlag() )
+    {
+      TComPic* refPic = pcSlice->getRefPic(RefPicList(1 - pcSlice->getColFromL0Flag()), pcSlice->getColRefIdx());
+
+      assert ( refPic );
+      assert ( refPic->getPicSym()->getSlice(0)->getAvailableForTMVPRefFlag() == true );
+    }
+#endif
+
+    // For generalized B
     // note: maybe not existed case (always L0 is copied to L1 if L1 is empty)
     if (pcSlice->isInterB() && pcSlice->getNumRefIdx(REF_PIC_LIST_1) == 0)
@@ -1201 +1272 @@
 
 #if H_3D_IV_MERGE
+#if LGE_FCO_I0116
+  if( !pcSlice->getIsDepth() && m_pcCamParsCollector )
+#else
   if( pcSlice->getIsDepth() && m_pcCamParsCollector )
+#endif
   {
     m_pcCamParsCollector->copyCamParamForSlice( pcSlice );
@@ -1652 +1727 @@
   for (Int i = 0; i < vps->getNumDirectRefLayers( getLayerId()  ); i++ )
   {
+#if H_MV_HLS10_REF_PRED_LAYERS
+    Int refLayerId = vps->getIdDirectRefLayer( m_layerId, i ); 
+#else
     Int refLayerId = vps->getRefLayerId( m_layerId, i ); 
+#endif
     allRefLayersInitilizedFlag = allRefLayersInitilizedFlag && m_layerInitilizedFlag[ refLayerId ]; 
   }

trunk/source/Lib/TLibEncoder/TEncCavlc.cpp

@@ -49 +49 @@
 {
 #if H_MV_ENC_DEC_TRAC
+#if H_MV_HLS10_GEN_FIX
+  fprintf( g_hTrace, "=========== Sequence Parameter Set LayerId: %d ===========\n", pSPS->getLayerId() );
+#else
   fprintf( g_hTrace, "=========== Sequence Parameter Set ===========\n" );
+#endif
 #else
   fprintf( g_hTrace, "=========== Sequence Parameter Set ID: %d ===========\n", pSPS->getSPSId() );
@@ -58 +62 @@
 {
 #if H_MV_ENC_DEC_TRAC
+#if H_MV_HLS10_GEN_FIX
+  fprintf( g_hTrace, "=========== Picture Parameter Set LayerId: %d ===========\n", pPPS->getLayerId() );
+#else
   fprintf( g_hTrace, "=========== Picture Parameter Set ===========\n" );
+#endif
 #else
   fprintf( g_hTrace, "=========== Picture Parameter Set ID: %d ===========\n", pPPS->getPPSId() );
@@ -241 +249 @@
     }
   }
+#if !H_MV_HLS10_PPS
 #if H_MV
   if ( pcPPS->getLayerId() > 0 )
@@ -254 +263 @@
   {  
 #endif  
+#endif
   WRITE_FLAG( pcPPS->getScalingListPresentFlag() ? 1 : 0,                          "pps_scaling_list_data_present_flag" ); 
   if( pcPPS->getScalingListPresentFlag() )
@@ -259 +269 @@
     codeScalingList( m_pcSlice->getScalingList() );
   }
+#if !H_MV_HLS10_PPS 
 #if H_MV
   }
+#endif
 #endif
 #if PPS_FIX_DEPTH
@@ -301 +313 @@
     if ( pcPPS->getPpsMultilayerExtensionFlag() )
     { 
+#if H_MV_HLS10_PPS
+      codePPSMultilayerExtension( pcPPS );
+#else
       WRITE_FLAG( pcPPS->getPocResetInfoPresentFlag( ) ? 1 : 0 , "poc_reset_info_present_flag" );
       WRITE_FLAG( 0, "pps_extension_reserved_zero_flag" );
+#endif
     }
 
@@ -675 +691 @@
 #endif
   WRITE_CODE( pcSPS->getMaxTLayers() - 1,  3,       "sps_max_sub_layers_minus1" );
+#if H_MV_HLS10_MULTILAYERSPS
+#if H_MV
+  }
+  else
+  {
+    WRITE_CODE( pcSPS->getSpsExtOrMaxSubLayersMinus1( ), 3, "sps_ext_or_max_sub_layers_minus1" );
+  }
+  if ( !pcSPS->getMultiLayerExtSpsFlag() )
+  {
+#endif
+#endif
+
   WRITE_FLAG( pcSPS->getTemporalIdNestingFlag() ? 1 : 0,                             "sps_temporal_id_nesting_flag" );
   codePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
@@ -682 +710 @@
   WRITE_UVLC( pcSPS->getSPSId (),                   "sps_seq_parameter_set_id" );
 #if H_MV
+#if H_MV_HLS10_MULTILAYERSPS
+    if ( pcSPS->getMultiLayerExtSpsFlag() )
+#else 
   if ( pcSPS->getLayerId() > 0 )
+#endif
   {
     WRITE_FLAG( pcSPS->getUpdateRepFormatFlag( ) ? 1 : 0 , "update_rep_format_flag" );
@@ -703 +735 @@
   WRITE_UVLC( pcSPS->getPicWidthInLumaSamples (),   "pic_width_in_luma_samples" );
   WRITE_UVLC( pcSPS->getPicHeightInLumaSamples(),   "pic_height_in_luma_samples" );
+#if !H_MV_HLS10_MULTILAYERSPS
 #if H_MV
   }
+#endif
 #endif
   Window conf = pcSPS->getConformanceWindow();
@@ -716 +750 @@
     WRITE_UVLC( conf.getWindowBottomOffset() / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc() ), "conf_win_bottom_offset" );
   }
+#if H_MV_HLS10_MULTILAYERSPS
 #if H_MV
+}
+#endif
+#endif
+
+#if H_MV
+#if H_MV_HLS10_MULTILAYERSPS
+  if ( !pcSPS->getMultiLayerExtSpsFlag() )
+#else 
   if ( pcSPS->getLayerId() == 0 )
+#endif
   { 
 #endif
@@ -727 +771 @@
   WRITE_UVLC( pcSPS->getBitsForPOC()-4,                 "log2_max_pic_order_cnt_lsb_minus4" );
 #if H_MV
+#if H_MV_HLS10_MULTILAYERSPS
+  if ( !pcSPS->getMultiLayerExtSpsFlag()) 
+#else
   if ( pcSPS->getLayerId() == 0 ) 
+#endif
   {  
 #endif
@@ -758 +806 @@
   {
 #if H_MV
+#if H_MV_HLS10_MULTILAYERSPS
+    if ( pcSPS->getMultiLayerExtSpsFlag() )
+#else 
     if ( pcSPS->getLayerId() > 0 )
+#endif
     {    
       WRITE_FLAG( pcSPS->getSpsInferScalingListFlag( ) ? 1 : 0 , "sps_infer_scaling_list_flag" );
@@ -865 +917 @@
 {
   WRITE_FLAG( pcSPS->getInterViewMvVertConstraintFlag() ? 1 : 0, "inter_view_mv_vert_constraint_flag" );
-
+#if !H_MV_HLS10_PPS
   WRITE_UVLC( pcSPS->getNumScaledRefLayerOffsets( ), "num_scaled_ref_layer_offsets" );
 
@@ -880 +932 @@
     WRITE_FLAG( 0, "sps_multilayer_ext_reserved_zero_flag[ j ]" );
   }
-}
+#endif
+}
+
+
+#if H_MV_HLS10_PPS
+Void TEncCavlc::codePPSMultilayerExtension(TComPPS* pcPPS)
+{
+  WRITE_FLAG( pcPPS->getPocResetInfoPresentFlag( ) ? 1 : 0 , "poc_reset_info_present_flag" );
+  WRITE_FLAG( pcPPS->getPpsInferScalingListFlag( ) ? 1 : 0 , "pps_infer_scaling_list_flag" );
+  WRITE_CODE( pcPPS->getPpsScalingListRefLayerId( ), 6, "pps_scaling_list_ref_layer_id" );
+  WRITE_UVLC( 0, "num_ref_loc_offsets" );
+}
+#endif
+
 #endif
 
@@ -897 +962 @@
 #endif
 }
-#endif
+
+
+#endif
+
+
+
 
 Void TEncCavlc::codeVPS( TComVPS* pcVPS )
@@ -904 +974 @@
 #if H_MV
   WRITE_FLAG( pcVPS->getVpsBaseLayerInternalFlag( ) ? 1 : 0 , "vps_base_layer_internal_flag" );
+#if H_MV_HLS10_GEN_VSP_BASE_LAYER_AVAIL
+  WRITE_FLAG( pcVPS->getVpsBaseLayerAvailableFlag( ) ? 1 : 0 , "vps_base_layer_available_flag" );
+#else // H_MV_HLS10_GEN
   WRITE_FLAG( 1                                             , "vps_reserved_one_bit" );
+#endif // H_MV_HLS10_GEN
 #else
   WRITE_CODE( 3,                                    2,        "vps_reserved_three_2bits" );
@@ -930 +1004 @@
     }
   }
-
   assert( pcVPS->getNumHrdParameters() <= MAX_VPS_NUM_HRD_PARAMETERS );
 #if H_MV
   assert( pcVPS->getVpsMaxLayerId() < MAX_VPS_NUH_LAYER_ID_PLUS1 );
   WRITE_CODE( pcVPS->getVpsMaxLayerId(), 6,                 "vps_max_layer_id" );  
-  
+#if H_MV_HLS10_GEN_FIX
+  WRITE_UVLC( pcVPS->getVpsNumLayerSetsMinus1(),  "vps_num_layer_sets_minus1" );
+#else
   WRITE_UVLC( pcVPS->getVpsNumLayerSetsMinus1(),  "vps_max_num_layer_sets_minus1" );
+#endif
   for( UInt opsIdx = 1; opsIdx <= pcVPS->getVpsNumLayerSetsMinus1(); opsIdx ++ )
   {
@@ -1012 +1088 @@
 #if H_MV
 Void TEncCavlc::codeVPSExtension( TComVPS *pcVPS ) 
-{  
+{ 
+#if H_MV_HLS10_PTL
+  if( pcVPS->getMaxLayersMinus1() > 0  &&  pcVPS->getVpsBaseLayerInternalFlag() )
+  {
+    codePTL( pcVPS->getPTL( 1 ),0, pcVPS->getMaxSubLayersMinus1()  );
+  }
+#endif
+
   WRITE_FLAG( pcVPS->getSplittingFlag() ? 1 : 0,             "splitting_flag" );
 
@@ -1084 +1167 @@
   }
 
+#if H_MV_HLS10_ADD_LAYERSETS
+  if ( pcVPS->getNumIndependentLayers() > 1 ) 
+  {
+    WRITE_UVLC( pcVPS->getNumAddLayerSets( ), "num_add_layer_sets" );
+  }
+  for (Int i = 0; i < pcVPS->getNumAddLayerSets(); i++)
+  {
+    for (Int j = 1; j < pcVPS->getNumIndependentLayers(); j++)
+    {
+      WRITE_CODE( pcVPS->getHighestLayerIdxPlus1( i, j ), pcVPS->getHighestLayerIdxPlus1Len( j )  , "highest_layer_idx_plus1" );
+    }
+  
+  }
+#endif
+
+
   WRITE_FLAG( pcVPS->getVpsSubLayersMaxMinus1PresentFlag( ) ? 1 : 0 , "vps_sub_layers_max_minus1_present_flag" );
   if ( pcVPS->getVpsSubLayersMaxMinus1PresentFlag() )
@@ -1119 +1218 @@
   WRITE_UVLC( pcVPS->getVpsNumProfileTierLevelMinus1( ), "vps_num_profile_tier_level_minus1" );
 
+#if H_MV_HLS10_PTL
+  Int offsetVal =  ( pcVPS->getMaxLayersMinus1() > 0  &&  pcVPS->getVpsBaseLayerInternalFlag() ) ? 2 : 1;   
+  for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 2 : 1; i <= pcVPS->getVpsNumProfileTierLevelMinus1(); i++ )
+  {
+    WRITE_FLAG( pcVPS->getVpsProfilePresentFlag( i ) ? 1 : 0, "vps_profile_present_flag[i]" );
+    codePTL( pcVPS->getPTL( offsetVal ), pcVPS->getVpsProfilePresentFlag( i ), pcVPS->getMaxTLayers() - 1 );
+    offsetVal++;
+  }
+#else 
   for( Int i = 1; i <= pcVPS->getVpsNumProfileTierLevelMinus1(); i++ )
   {
@@ -1124 +1232 @@
     codePTL( pcVPS->getPTL( i ), pcVPS->getVpsProfilePresentFlag( i ), pcVPS->getMaxTLayers() - 1 );
   }
-
+#endif
+
+#if !H_MV_HLS10_ADD_LAYERSETS
   if ( pcVPS->getNumIndependentLayers() > 1 ) 
   {
@@ -1136 +1246 @@
     }
   }
+#endif
+
   if (pcVPS->getNumLayerSets() > 1)
   {
@@ -1146 +1258 @@
 
 
+#if H_MV_HLS10_PTL_FIX
+  if (pcVPS->getVpsBaseLayerInternalFlag() )
+  {  
+    assert( pcVPS->getProfileTierLevelIdx(0,0) == pcVPS->inferProfileTierLevelIdx(0,0) );
+  }
+#endif
 
 
@@ -1152 +1270 @@
     if( i >= pcVPS->getNumLayerSets( ) )    
     {      
+#if !VPS_MISC_UPDATES
       WRITE_UVLC( pcVPS->getLayerSetIdxForOlsMinus1( i ),      "layer_set_idx_for_ols_minus1[i]" );
+#else
+      WRITE_CODE( pcVPS->getLayerSetIdxForOlsMinus1( i ), pcVPS->getLayerSetIdxForOlsMinus1Len( i ) ,      "layer_set_idx_for_ols_minus1[i]" );
+#endif
     }
 
@@ -1169 +1291 @@
       }
     }        
-
-
+        
+#if H_MV_HLS10_PTL
+    for ( Int j = 0; j < pcVPS->getNumLayersInIdList( pcVPS->olsIdxToLsIdx(i)); j++ )
+    {    
+      if (pcVPS->getNecessaryLayerFlag( i, j ) && pcVPS->getVpsNumProfileTierLevelMinus1() > 0 )
+      {
+        WRITE_CODE( pcVPS->getProfileTierLevelIdx( i, j ), pcVPS->getProfileTierLevelIdxLen() ,"profile_tier_level_idx[ i ][ j ]" );   
+      }
+#if H_MV_HLS10_PTL_FIX
+      if (pcVPS->getNecessaryLayerFlag( i, j ) && pcVPS->getVpsNumProfileTierLevelMinus1() == 0 )
+      {
+        assert( pcVPS->getProfileTierLevelIdx( i , j ) == pcVPS->inferProfileTierLevelIdx( i, j ) );
+      }
+#endif
+
+    }
+#else
     if ( pcVPS->getProfileLevelTierIdxLen()  > 0 )
     {      
       WRITE_CODE( pcVPS->getProfileLevelTierIdx( i ), pcVPS->getProfileLevelTierIdxLen() ,"profile_level_tier_idx[ i ]" );   
     }
+#endif
     if( pcVPS->getNumOutputLayersInOutputLayerSet( i ) == 1 && pcVPS->getNumDirectRefLayers( pcVPS->getOlsHighestOutputLayerId( i ) ) > 0 )
     {
@@ -1224 +1362 @@
   }
 
+#if !H_MV_HLS10_GEN_FIX
   WRITE_FLAG( 0, "vps_reserved_zero_flag" );
+#endif
   codeDpbSize( pcVPS ); 
 
@@ -1301 +1441 @@
         for( Int k = 0; k < vps->getNumLayersInIdList( currLsIdx ); k++ )   
         {
+#if H_MV_HLS10_DBP_SIZE
+          if ( vps->getNecessaryLayerFlag( i, k ) && ( vps->getVpsBaseLayerInternalFlag() || ( vps->getLayerSetLayerIdList(vps->olsIdxToLsIdx(i),k) != 0 ) ))
+          {
+            WRITE_UVLC( dpbSize->getMaxVpsDecPicBufferingMinus1( i, k, j ), "max_vps_dec_pic_buffering_minus1" );
+          }
+          else
+          {
+            if ( vps->getNecessaryLayerFlag( i, k ) && ( j == 0 ) && ( k == 0 ) ) 
+            {
+              assert( dpbSize->getMaxVpsDecPicBufferingMinus1(i ,k, j ) ==  0 );
+            }
+          }
+#else
           WRITE_UVLC( dpbSize->getMaxVpsDecPicBufferingMinus1( i, k, j ), "max_vps_dec_pic_buffering_minus1" );
+#endif
         }
         WRITE_UVLC( dpbSize->getMaxVpsNumReorderPics( i, j ), "max_vps_num_reorder_pics" );
@@ -1312 +1466 @@
           for( Int k = 0; k < vps->getNumLayersInIdList( vps->olsIdxToLsIdx( i ) ); k++ )   
           {
-            assert( dpbSize->getMaxVpsDecPicBufferingMinus1( i, k, j ) == dpbSize->getMaxVpsDecPicBufferingMinus1( i,k, j - 1 ) );
+#if H_MV_HLS10_DBP_SIZE
+            if ( vps->getNecessaryLayerFlag(i, k ) )
+            {            
+#endif
+              assert( dpbSize->getMaxVpsDecPicBufferingMinus1( i, k, j ) == dpbSize->getMaxVpsDecPicBufferingMinus1( i,k, j - 1 ) );
+#if H_MV_HLS10_DBP_SIZE
+            }
+#endif  
           }
           assert( dpbSize->getMaxVpsNumReorderPics      ( i, j ) ==  dpbSize->getMaxVpsNumReorderPics      ( i, j - 1 ) );
@@ -1347 +1508 @@
     pcRepFormat->inferChromaAndBitDepth(pcPrevRepFormat, true ); 
   }
+#if H_MV_HLS10_GEN_VSP_CONF_WIN
+  WRITE_FLAG( pcRepFormat->getConformanceWindowVpsFlag( ) ? 1 : 0 , "conformance_window_vps_flag" );
+  if ( pcRepFormat->getConformanceWindowVpsFlag() )
+  {    
+    WRITE_UVLC( pcRepFormat->getConfWinVpsLeftOffset( ), "conf_win_vps_left_offset" );
+    WRITE_UVLC( pcRepFormat->getConfWinVpsRightOffset( ), "conf_win_vps_right_offset" );
+    WRITE_UVLC( pcRepFormat->getConfWinVpsTopOffset( ), "conf_win_vps_top_offset" );
+    WRITE_UVLC( pcRepFormat->getConfWinVpsBottomOffset( ), "conf_win_vps_bottom_offset" );
+  }
+#endif
 }
 
@@ -1371 +1542 @@
   if( pcVPSVUI->getBitRatePresentVpsFlag( )  ||  pcVPSVUI->getPicRatePresentVpsFlag( ) )
   {
+#if H_MV_HLS10_VPS_VUI
+    for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i < pcVPS->getNumLayerSets(); i++ )
+#else
     for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i  <=  pcVPS->getVpsNumLayerSetsMinus1(); i++ )
+#endif
     {
       for( Int j = 0; j  <=  pcVPS->getMaxSubLayersInLayerSetMinus1( i ); j++ ) 
@@ -1404 +1579 @@
   else
   {
+#if H_MV_HLS10_VPS_VUI
+    assert( pcVPSVUI->getVpsNumVideoSignalInfoMinus1() == pcVPS->getMaxLayersMinus1() - ( pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1)  ); 
+#else
     pcVPSVUI->setVpsNumVideoSignalInfoMinus1( pcVPS->getMaxLayersMinus1() ); 
+#endif
   }
 
@@ -1417 +1596 @@
   if( pcVPSVUI->getVideoSignalInfoIdxPresentFlag() && pcVPSVUI->getVpsNumVideoSignalInfoMinus1() > 0 )
   {
+#if I0045_VPS_VUI_VST_PARAMS
+    for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i <=  pcVPS->getMaxLayersMinus1(); i++ )
+    {
+      WRITE_CODE( pcVPSVUI->getVpsVideoSignalInfoIdx( i ), 4, "vps_video_signal_info_idx" );
+    }
+#else
     for( Int i = 1; i <=  pcVPS->getMaxLayersMinus1(); i++ )
     {
@@ -1429 +1614 @@
       assert( pcVPSVUI->getVpsVideoSignalInfoIdx( i  ) == ( pcVPSVUI->getVideoSignalInfoIdxPresentFlag() ? 0 : i ) ); 
     }
+#endif
   }
   WRITE_FLAG( pcVPSVUI->getTilesNotInUseFlag( ) ? 1 : 0 , "tiles_not_in_use_flag" );
@@ -1445 +1631 @@
       for( Int j = 0; j < pcVPS->getNumDirectRefLayers( pcVPS->getLayerIdInNuh( i ) ) ; j++ )
       {  
+#if H_MV_HLS10_REF_PRED_LAYERS
+        Int layerIdx = pcVPS->getLayerIdInVps(pcVPS->getIdRefLayer(pcVPS->getLayerIdInNuh( i ) , j  ));  
+#else
         Int layerIdx = pcVPS->getLayerIdInVps(pcVPS->getRefLayerId(pcVPS->getLayerIdInNuh( i ) , j  ));  
+#endif
         if( pcVPSVUI->getTilesInUseFlag( i )  &&  pcVPSVUI->getTilesInUseFlag( layerIdx ) )  
         {
@@ -1463 +1653 @@
     }
   }
+#if H_MV_HLS10_VPS_VUI
+  WRITE_FLAG( pcVPSVUI->getSingleLayerForNonIrapFlag( ) ? 1 : 0 , "single_layer_for_non_irap_flag" );
+  WRITE_FLAG( pcVPSVUI->getHigherLayerIrapSkipFlag( ) ? 1 : 0 , "higher_layer_irap_skip_flag" );
+#else
   WRITE_CODE( 0, 3, "vps_vui_reserved_zero_3bits" );
+#endif
   WRITE_FLAG( pcVPSVUI->getIlpRestrictedRefLayersFlag( ) ? 1 : 0 , "ilp_restricted_ref_layers_flag" );
 
@@ -1472 +1667 @@
       for( Int j = 0; j < pcVPS->getNumDirectRefLayers( pcVPS->getLayerIdInNuh( i ) ); j++ )
       {
+#if H_MV_HLS10_REF_PRED_LAYERS
+        if( pcVPS->getVpsBaseLayerInternalFlag() || pcVPS->getIdRefLayer( pcVPS->getLayerIdInNuh( i ), j ) > 0 )
+#else
         if( pcVPS->getVpsBaseLayerInternalFlag() || pcVPS->getRefLayerId( pcVPS->getLayerIdInNuh( i ), j ) > 0 )
+#endif
         {        
           WRITE_UVLC( pcVPSVUI->getMinSpatialSegmentOffsetPlus1( i, j ), "min_spatial_segment_offset_plus1" );
@@ -1514 +1713 @@
 
   assert ( vpsVuiBspHrdP );
-
   
+#if H_MV_HLS10_VPS_VUI_BSP
+  WRITE_UVLC( vpsVuiBspHrdP->getVpsNumAddHrdParams( ), "vps_num_add_hrd_params" );
+
+  for( Int i = pcVPS->getNumHrdParameters(); i < pcVPS->getNumHrdParameters() + vpsVuiBspHrdP->getVpsNumAddHrdParams(); i++ )
+  {  
+    if( i > 0 )  
+    {
+      WRITE_FLAG( vpsVuiBspHrdP->getCprmsAddPresentFlag( i ) ? 1 : 0 , "cprms_add_present_flag" );
+    }
+    WRITE_UVLC( vpsVuiBspHrdP->getNumSubLayerHrdMinus1( i ), "num_sub_layer_hrd_minus1" );
+    TComHRD* hrdParameters = vpsVuiBspHrdP->getHrdParametermeters( i ); 
+    codeHrdParameters( hrdParameters, vpsVuiBspHrdP->getCprmsAddPresentFlag( i ), vpsVuiBspHrdP->getNumSubLayerHrdMinus1( i ) );     
+  }
+
+  for( Int h = 1; h < pcVPS->getNumOutputLayerSets(); h++ )
+  {  
+    WRITE_UVLC( vpsVuiBspHrdP->getNumSignalledPartitioningSchemes( h ), "num_signalled_partitioning_schemes" );
+
+    for( Int j = 1; j < vpsVuiBspHrdP->getNumSignalledPartitioningSchemes( h ) + 1; j++ )
+    {  
+      WRITE_UVLC( vpsVuiBspHrdP->getNumPartitionsInSchemeMinus1( h, j ), "num_partitions_in_scheme_minus1" );
+      for( Int k = 0; k  <=  vpsVuiBspHrdP->getNumPartitionsInSchemeMinus1( h, j ); k++ )  
+      {
+        for( Int r = 0; r < pcVPS->getNumLayersInIdList(pcVPS->olsIdxToLsIdx( h ) )   ; r++ )  
+        {
+          WRITE_FLAG( vpsVuiBspHrdP->getLayerIncludedInPartitionFlag( h, j, k, r ) ? 1 : 0 , "layer_included_in_partition_flag" );
+        }
+      }
+    }  
+    for( Int i = 0; i < vpsVuiBspHrdP->getNumSignalledPartitioningSchemes( h ) + 1; i++ )  
+    {
+      for( Int t = 0; t  <=  pcVPS->getMaxSubLayersInLayerSetMinus1( pcVPS->olsIdxToLsIdx( h ) ); t++ )
+      {  
+        WRITE_UVLC( vpsVuiBspHrdP->getNumBspSchedulesMinus1( h, i, t ), "num_bsp_schedules_minus1" );
+        for( Int j = 0; j  <=  vpsVuiBspHrdP->getNumBspSchedulesMinus1( h, i, t ); j++ )  
+        {
+          for( Int k = 0; k  <=  vpsVuiBspHrdP->getNumPartitionsInSchemeMinus1( h, j ); k++ )
+          {  
+            WRITE_CODE( vpsVuiBspHrdP->getBspHrdIdx( h, i, t, j, k ), vpsVuiBspHrdP->getBspHrdIdxLen( pcVPS ), "bsp_hrd_idx" );
+            WRITE_UVLC( vpsVuiBspHrdP->getBspSchedIdx( h, i, t, j, k ), "bsp_sched_idx" );
+          }  
+        }
+      }  
+    }
+  }  
+
+#else // H_MV_HLS10_GEN
   WRITE_UVLC( vpsVuiBspHrdP->getVpsNumBspHrdParametersMinus1( ), "vps_num_bsp_hrd_parameters_minus1" );
   for( Int i = 0; i <= vpsVuiBspHrdP->getVpsNumBspHrdParametersMinus1( ); i++ )
@@ -1552 +1797 @@
       }
     }  
-  }  
+  }
+#endif  
 }  
-
 #endif
 
@@ -1733 +1978 @@
       esb++; 
       WRITE_FLAG( pcSlice->getDiscardableFlag( ) ? 1 : 0 , "discardable_flag" );
+#if NON_REF_NAL_TYPE_DISCARDABLE
+      if (pcSlice->getDiscardableFlag( ))
+      {
+        assert(pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TRAIL_R &&
+          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TSA_R &&
+          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_STSA_R &&
+          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RADL_R &&
+          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RASL_R);
+      }
+#endif
     }
 
@@ -1893 +2148 @@
       if (pcSlice->getSPS()->getTMVPFlagsPresent())
       {
+#if I0044_SLICE_TMVP
+        WRITE_FLAG( pcSlice->getEnableTMVPFlag() ? 1 : 0, "slice_temporal_mvp_enabled_flag" );
+#else
         WRITE_FLAG( pcSlice->getEnableTMVPFlag() ? 1 : 0, "slice_temporal_mvp_enable_flag" );
+#endif
       }
     }
@@ -2126 +2385 @@
   }
 #if H_3D
+#if LGE_FCO_I0116
+  if( pcSlice->getVPS()->hasCamParInSliceHeader( pcSlice->getViewIndex() ) && pcSlice->getIsDepth() )
+#else
   if( pcSlice->getVPS()->hasCamParInSliceHeader( pcSlice->getViewIndex() ) && !pcSlice->getIsDepth() )
+#endif
   {
     for( UInt uiId = 0; uiId < pcSlice->getViewIndex(); uiId++ )
@@ -2312 +2575 @@
   WRITE_FLAG(ptl->getFrameOnlyConstraintFlag(), "general_frame_only_constraint_flag");
   
+#if H_MV_HLS10_PTL
+#if H_MV_HLS10_PTL_INFER_FIX
+  if( ptl->getV2ConstraintsPresentFlag() ) 
+#else
+  if( ptl->getProfileIdc( ) ==  4 || ptl->getProfileCompatibilityFlag( 4 )  ||
+    ptl->getProfileIdc( ) ==  5 || ptl->getProfileCompatibilityFlag( 5 )  ||
+    ptl->getProfileIdc( ) ==  6 || ptl->getProfileCompatibilityFlag( 6 )  ||
+    ptl->getProfileIdc( ) ==  7 || ptl->getProfileCompatibilityFlag( 7 ) ) 
+#endif
+  {
+    WRITE_FLAG( ptl->getMax12bitConstraintFlag( ) ? 1 : 0 , "max_12bit_constraint_flag" );
+    WRITE_FLAG( ptl->getMax10bitConstraintFlag( ) ? 1 : 0 , "max_10bit_constraint_flag" );
+    WRITE_FLAG( ptl->getMax8bitConstraintFlag( ) ? 1 : 0 , "max_8bit_constraint_flag" );
+    WRITE_FLAG( ptl->getMax422chromaConstraintFlag( ) ? 1 : 0 , "max_422chroma_constraint_flag" );
+    WRITE_FLAG( ptl->getMax420chromaConstraintFlag( ) ? 1 : 0 , "max_420chroma_constraint_flag" );
+    WRITE_FLAG( ptl->getMaxMonochromeConstraintFlag( ) ? 1 : 0 , "max_monochrome_constraint_flag" );
+    WRITE_FLAG( ptl->getIntraConstraintFlag( ) ? 1 : 0 , "intra_constraint_flag" );
+    WRITE_FLAG( ptl->getOnePictureOnlyConstraintFlag( ) ? 1 : 0 , "one_picture_only_constraint_flag" );
+    WRITE_FLAG( ptl->getLowerBitRateConstraintFlag( ) ? 1 : 0 , "lower_bit_rate_constraint_flag" );
+    WRITE_CODE( 0, 16, "XXX_reserved_zero_34bits[0..15]");
+    WRITE_CODE( 0, 16, "XXX_reserved_zero_34bits[16..31]");
+    WRITE_CODE( 0, 2 , "XXX_reserved_zero_34bits[32..33]");
+  }
+  else
+  {
+    WRITE_CODE( 0, 16, "XXX_reserved_zero_43bits[0..15]");
+    WRITE_CODE( 0, 16, "XXX_reserved_zero_43bits[16..31]");
+    WRITE_CODE( 0, 11, "XXX_reserved_zero_43bits[32..42]");
+  }
+#if H_MV_HLS10_PTL_INFER_FIX
+    if( ptl->getInbldPresentFlag() )
+#else
+  if( ( ptl->getProfileIdc() >= 1 && ptl->getProfileIdc() <= 5 )  ||
+    ptl->getProfileCompatibilityFlag( 1 ) || ptl->getProfileCompatibilityFlag( 2 )  ||
+    ptl->getProfileCompatibilityFlag( 3 ) || ptl->getProfileCompatibilityFlag( 4 )  ||
+    ptl->getProfileCompatibilityFlag( 5 ) )
+#endif
+  {
+    WRITE_FLAG( ptl->getInbldFlag( ) ? 1 : 0 , "inbld_flag" );
+  }
+  else
+  {
+    WRITE_FLAG(0, "reserved_zero_bit");
+  }
+#else
   WRITE_CODE(0 , 16, "XXX_reserved_zero_44bits[0..15]");
   WRITE_CODE(0 , 16, "XXX_reserved_zero_44bits[16..31]");
   WRITE_CODE(0 , 12, "XXX_reserved_zero_44bits[32..43]");
-    }
+#endif
+}
 
 /**

trunk/source/Lib/TLibEncoder/TEncCavlc.h

@@ -107 +107 @@
   Void  codePPS                 ( TComPPS* pcPPS );
 
+#if H_MV_HLS10_PPS
+#if H_MV
+  Void codePPSMultilayerExtension( TComPPS* pcPPS );
+#endif
+#endif
+
 #if H_3D
   Void  codePPSExtension        ( TComPPS* pcPPS );

trunk/source/Lib/TLibEncoder/TEncCu.cpp

@@ -538 +538 @@
 #if MTK_I0099_VPS_EX2
 #if MTK_I0099_FIX
+#if LGE_FCO_I0116
+      if(depthMapDetect && !bIntraSliceDetect && !rapPic && ( m_pcEncCfg->getUseQTL() || bLimQtPredFalg ) && pcTexture->getReconMark())
+#else
       if(depthMapDetect && !bIntraSliceDetect && !rapPic && ( m_pcEncCfg->getUseQTL() || bLimQtPredFalg ))
+#endif
 #else
       if(depthMapDetect && !bIntraSliceDetect && !rapPic && bLimQtPredFalg)
@@ -2588 +2592 @@
   // fetch virtual depth block
   UInt uiDepthStride = 0;
+#if LGE_FCO_I0116
+  Pel* pDepthPels = rpcTempCU->getVirtualDepthBlock(rpcTempCU->getZorderIdxInCU(), uiWidth, uiHeight, uiDepthStride);
+#else
   Pel* pDepthPels = rpcTempCU->getVirtualDepthBlock(0, uiWidth, uiHeight, uiDepthStride);
+#endif
   AOF( pDepthPels != NULL );
   AOF( uiDepthStride != 0 );

trunk/source/Lib/TLibEncoder/TEncEntropy.cpp

@@ -185 +185 @@
   else
   {
+#if MTK_LOW_LATENCY_IC_ENCODING_H0086_FIX
+    Int ICEnableCandidate = pcCU->getSlice()->getICEnableCandidate(pcCU->getSlice()->getDepth());
+    Int ICEnableNum = pcCU->getSlice()->getICEnableNum(pcCU->getSlice()->getDepth());
+    ICEnableCandidate++;
+    if(pcCU->getICFlag(uiAbsPartIdx))
+    {
+      ICEnableNum++;
+    }
+    pcCU->getSlice()->setICEnableCandidate(pcCU->getSlice()->getDepth(), ICEnableCandidate);
+    pcCU->getSlice()->setICEnableNum(pcCU->getSlice()->getDepth(), ICEnableNum);
+#else
     g_aICEnableCANDIDATE[pcCU->getSlice()->getDepth()]++;
     if(pcCU->getICFlag(uiAbsPartIdx))
@@ -190 +201 @@
       g_aICEnableNUM[pcCU->getSlice()->getDepth()]++;
     }
+#endif
   }
   if( pcCU->isICFlagRequired( uiAbsPartIdx ) )

trunk/source/Lib/TLibEncoder/TEncGOP.cpp

@@ -160 +160 @@
 #endif
 #endif
-
+#if MTK_LOW_LATENCY_IC_ENCODING_H0086_FIX
+  m_aICEnableCandidate           = pcTEncTop->getICEnableCandidate(); 
+  m_aICEnableNum           = pcTEncTop->getICEnableNum(); 
+#endif
 #if KWU_FIX_URQ
   m_pcRateCtrl           = pcTEncTop->getRateCtrl();
@@ -968 +971 @@
 #endif    
 #endif
+#if MTK_LOW_LATENCY_IC_ENCODING_H0086_FIX
+    pcSlice->setICEnableCandidate( m_aICEnableCandidate );         
+    pcSlice->setICEnableNum( m_aICEnableNum );         
+#endif
     //  Slice info. refinement
 #if H_MV

trunk/source/Lib/TLibEncoder/TEncGOP.h

@@ -116 +116 @@
 #endif
 #endif
+#if MTK_LOW_LATENCY_IC_ENCODING_H0086_FIX
+  Int *m_aICEnableCandidate; 
+  Int *m_aICEnableNum; 
+#endif
   //--Adaptive Loop filter
   TEncSampleAdaptiveOffset*  m_pcSAO;

trunk/source/Lib/TLibEncoder/TEncSbac.cpp

@@ -732 +732 @@
   UInt uiTexturePart = eSize;
 #if MTK_I0099_VPS_EX2
+#if LGE_FCO_I0116
+  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && pcCU->getPic()->getReduceBitsFlag() && bLimQtPredFlag && pcTexture->getReconMark())
+#else
   if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && pcCU->getPic()->getReduceBitsFlag() && bLimQtPredFlag )
+#endif
 #else
   if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && pcCU->getPic()->getReduceBitsFlag() && sps->getUseQTL() && sps->getUsePC() )
@@ -1106 +1110 @@
 
 #if MTK_I0099_VPS_EX2
+#if LGE_FCO_I0116
+  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && pcCU->getPic()->getReduceBitsFlag() && bLimQtPredFlag && pcTexture->getReconMark() )
+#else
   if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && pcCU->getPic()->getReduceBitsFlag() && bLimQtPredFlag  )
+#endif
 #else
   if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && pcCU->getPic()->getReduceBitsFlag() && sps->getUseQTL() && sps->getUsePC())

trunk/source/Lib/TLibEncoder/TEncSearch.cpp

@@ -3083 +3083 @@
         Double dLambda;
         if ( m_pcRdCost->getUseLambdaScaleVSO() )
+        {
           dLambda = m_pcRdCost->getUseRenModel() ? m_pcRdCost->getLambdaVSO() : m_pcRdCost->getSqrtLambdaVSO();
+        }
         else        
+        {
           dLambda = m_pcRdCost->getSqrtLambda();        
-
-        Double cost      = (Double)uiSad + (Double)iModeBits * m_pcRdCost->getSqrtLambda();
+        }
+
+        Double cost      = (Double)uiSad + (Double)iModeBits * dLambda;
 #else
         Double cost      = (Double)uiSad + (Double)iModeBits * m_pcRdCost->getSqrtLambda();
@@ -3212 +3216 @@
 #if H_3D_FCO
             TComPic* picTexture  = pcCU->getSlice()->getIvPic(false, pcCU->getSlice()->getViewIndex() );
+#if LGE_FCO_I0116
+            if ( !picTexture->getReconMark() && (DMM4_IDX == dmmType ) )
+#else
             if ( !picTexture->getReconMark() && (DMM3_IDX == dmmType || DMM4_IDX == dmmType ) )
+#endif
             {
                 continue;

trunk/source/Lib/TLibEncoder/TEncTop.cpp

@@ -72 +72 @@
   ContextModel::buildNextStateTable();
 #endif
+#if H_MV_HLS10_GEN_FIX
+#if H_MV
+  m_iNumSubstreams         = 0; 
+#endif
+#endif
 
   m_pcSbacCoders           = NULL;
@@ -84 +89 @@
   m_ivPicLists = NULL;
 #endif
+#if MTK_LOW_LATENCY_IC_ENCODING_H0086_FIX
+  m_aICEnableCandidate = NULL;
+  m_aICEnableNum = NULL;
+#endif
 }
 
@@ -227 +236 @@
       for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
       {
+#if H_MV_HLS10_GEN_FIX
+#if H_MV
+        xDelete( false, m_pppcRDSbacCoder, iDepth, iCIIdx);
+        xDelete( false, m_pppcBinCoderCABAC, iDepth, iCIIdx);
+#else
         delete m_pppcRDSbacCoder[iDepth][iCIIdx];
         delete m_pppcBinCoderCABAC[iDepth][iCIIdx];
+#endif
+#endif
       }
     }
@@ -234 +250 @@
     for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
     {
+#if H_MV_HLS10_GEN_FIX
+#if H_MV
+      xDelete( true, m_pppcRDSbacCoder  , iDepth);
+      xDelete( true, m_pppcBinCoderCABAC, iDepth);
+#else
       delete [] m_pppcRDSbacCoder[iDepth];
       delete [] m_pppcBinCoderCABAC[iDepth];
-    }
-    
+#endif
+#endif
+    }
+
+#if H_MV_HLS10_GEN_FIX
+#if H_MV
+     xDelete( true, m_pppcRDSbacCoder  );
+     xDelete( true, m_pppcBinCoderCABAC);
+#else
     delete [] m_pppcRDSbacCoder;
     delete [] m_pppcBinCoderCABAC;
-
+#endif
+#endif
     for ( UInt ui = 0; ui < m_iNumSubstreams; ui++ )
     {
@@ -247 +276 @@
         for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
         {
+#if H_MV_HLS10_GEN_FIX
+#if H_MV
+          xDelete(false, m_ppppcRDSbacCoders  ,ui, iDepth, iCIIdx);
+          xDelete(false, m_ppppcBinCodersCABAC,ui, iDepth, iCIIdx);
+#else
           delete m_ppppcRDSbacCoders  [ui][iDepth][iCIIdx];
           delete m_ppppcBinCodersCABAC[ui][iDepth][iCIIdx];
+#endif
+#endif
         }
       }
@@ -254 +290 @@
       for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
       {
+#if H_MV_HLS10_GEN_FIX
+#if H_MV
+        xDelete(true, m_ppppcRDSbacCoders  ,ui, iDepth);
+        xDelete(true, m_ppppcBinCodersCABAC,ui, iDepth);        
+#else
         delete [] m_ppppcRDSbacCoders  [ui][iDepth];
         delete [] m_ppppcBinCodersCABAC[ui][iDepth];
-      }
+#endif
+#endif
+      }
+
+
+#if H_MV_HLS10_GEN_FIX
+#if H_MV
+      xDelete(true, m_ppppcRDSbacCoders,   ui);
+      xDelete(true, m_ppppcBinCodersCABAC, ui);      
+#else
       delete[] m_ppppcRDSbacCoders  [ui];
       delete[] m_ppppcBinCodersCABAC[ui];
-    }
+#endif
+#endif
+    }
+#if H_MV_HLS10_GEN_FIX
+#if H_MV
+    xDelete(true, m_ppppcRDSbacCoders    ) ;
+    xDelete(true, m_ppppcBinCodersCABAC);
+    xDelete(true, m_pcSbacCoders);
+    xDelete(true, m_pcBinCoderCABACs);
+    xDelete(true, m_pcRDGoOnSbacCoders);  
+    xDelete(true, m_pcRDGoOnBinCodersCABAC);
+    xDelete(true, m_pcBitCounters);
+    xDelete(true, m_pcRdCosts);
+#else
     delete[] m_ppppcRDSbacCoders;
     delete[] m_ppppcBinCodersCABAC;
@@ -268 +331 @@
   delete[] m_pcBitCounters;
   delete[] m_pcRdCosts;
-  
+#endif
+#endif
+
 #if !H_MV
     // destroy ROM
@@ -305 +370 @@
 
   xInitPPSforTiles();
-
+#if MTK_LOW_LATENCY_IC_ENCODING_H0086_FIX
+  m_aICEnableCandidate = new Int[ 10 ];
+  m_aICEnableNum = new Int[ 10 ];
+
+  for(int i=0;i<10;i++)
+  {
+    m_aICEnableCandidate[i]=0;
+    m_aICEnableNum[i]=0;
+  }
+#endif
   // initialize processing unit classes
   m_cGOPEncoder.  init( this );
@@ -695 +769 @@
 #if H_MV  
   m_cSPS.setUpdateRepFormatFlag           ( false );    
+#if H_MV_HLS10_MULTILAYERSPS  
+  Bool multiLayerExtensionFlag  = ( getLayerId() > 0 ) && ( m_cVPS->getNumRefLayers( getLayerId() ) > 0 ); 
+  
+  m_cSPS.setSpsExtOrMaxSubLayersMinus1( multiLayerExtensionFlag ? 7 : m_maxTempLayer - 1 );
+  if ( multiLayerExtensionFlag )
+  {
+    m_cSPS.setSpsInferScalingListFlag   ( true ); 
+    m_cSPS.setSpsScalingListRefLayerId( m_cVPS->getIdRefLayer( getLayerId(), 0 ) ); 
+  }
+#else
   m_cSPS.setSpsInferScalingListFlag       ( m_layerId > 0 && m_cVPS->getInDirectDependencyFlag( getLayerIdInVps(), 0 ) ); 
   m_cSPS.setSpsScalingListRefLayerId      ( 0              ); 
-  m_cSPS.setSpsExtensionPresentFlag              ( true ); 
+#endif
+  m_cSPS.setSpsExtensionPresentFlag       ( true ); 
   m_cSPS.setSpsMultilayerExtensionFlag    ( true ); 
 #if H_3D
@@ -778 +863 @@
     for( Int is = 0; is < targetDecLayerIdList.size(); is++  )
     {
+#if H_MV_HLS10_ADD_LAYERSETS
+      if ( m_cVPS->getNecessaryLayerFlag( ols, is ) )
+      {      
+        m_cSPS.inferSpsMaxDecPicBufferingMinus1( m_cVPS, ols, targetDecLayerIdList[is], true );       
+      }
+#else
       m_cSPS.inferSpsMaxDecPicBufferingMinus1( m_cVPS, ols, targetDecLayerIdList[is], true );       
-    }
-  }
-
+#endif
+    }
+  }
+#if !H_MV_HLS10_ADD_LAYERSETS 
   m_cVPS->inferDbpSizeLayerSetZero( &m_cSPS, true ); 
+#endif
 #endif
   m_cSPS.setPCMBitDepthLuma (g_uiPCMBitDepthLuma);

trunk/source/Lib/TLibEncoder/TEncTop.h

@@ -80 +80 @@
   TComPicLists*           m_ivPicLists;                   ///< access to picture lists of other layers 
 #endif
+#if MTK_LOW_LATENCY_IC_ENCODING_H0086_FIX
+  Int *m_aICEnableCandidate;
+  Int *m_aICEnableNum;
+#endif
   // encoder search
   TEncSearch              m_cSearch;                      ///< encoder search class
@@ -146 +150 @@
   Void  xInitPPSforTiles  ();
   Void  xInitRPS          (Bool isFieldCoding);           ///< initialize PPS from encoder options
-
+#if H_MV_HLS10_GEN_FIX
+#if H_MV
+
+  template <class T>     Void  xDelete( Bool ar, T inArray ) 
+  {
+    if( inArray != NULL)
+    {
+      if ( ar )
+      {      
+        delete[] inArray; 
+      }
+      else
+      {
+        delete inArray;
+      }
+    }
+  }
+
+  template <class T>     Void  xDelete( Bool ar, T inArray, Int idx1 ) 
+  {
+    if( inArray != NULL)
+    {
+        xDelete( ar, inArray[idx1]); 
+    }
+  }
+
+  template <class T>     Void  xDelete( Bool ar, T inArray, Int idx1, Int idx2 ) 
+  {
+    if( inArray != NULL )
+    {
+      xDelete( ar, inArray[idx1], idx2 ); 
+    }
+  }
+
+  template <class T>     Void  xDelete( Bool ar, T inArray, Int idx1, Int idx2, Int idx3 ) 
+  {
+    if( inArray != NULL )
+    {
+      xDelete( ar, inArray[idx1], idx2, idx3 ); 
+    }
+  }
+
+#endif
+#endif
 public:
   TEncTop();
@@ -161 +208 @@
 #if H_MV  
   TComPicLists* getIvPicLists() { return m_ivPicLists; }
+#endif
+#if MTK_LOW_LATENCY_IC_ENCODING_H0086_FIX
+  Int *getICEnableCandidate() { return m_aICEnableCandidate; }
+  Int *getICEnableNum() { return m_aICEnableNum; }
 #endif
   Void      deletePicBuffer ();
@@ -221 +272 @@
   Void                    setIvPicLists         ( TComPicLists* picLists) { m_ivPicLists = picLists; }
 #endif
+#if MTK_LOW_LATENCY_IC_ENCODING_H0086_FIX
+  Void                    setICEnableCandidate         ( Int* ICEnableCandidate) { m_aICEnableCandidate = ICEnableCandidate; }
+  Void                    setICEnableNum         ( Int* ICEnableNum) { m_aICEnableNum = ICEnableNum; }
+#endif
   // -------------------------------------------------------------------------------------------------------------------
   // encoder function