Changeset 1412 in 3DVCSoftware for branches/HTM-16.2-dev/source/Lib/TLibEncoder/TEncTop.cpp

Timestamp:

12 Apr 2018, 11:12:21 (7 years ago)

Author:

tech

Message:

• Update HM-16.18
• Cleanups
• Encoder Extension

-- Representation formats
-- Parameter set sharing
-- GOP configuration

File:

• branches/HTM-16.2-dev/source/Lib/TLibEncoder/TEncTop.cpp (modified) (47 diffs)

branches/HTM-16.2-dev/source/Lib/TLibEncoder/TEncTop.cpp

@@ -4 +4 @@
  * granted under this license.
  *
- * Copyright (c) 2010-2016, ITU/ISO/IEC
+ * Copyright (c) 2010-2017, ITU/ISO/IEC
  * All rights reserved.
  *
@@ -54 +54 @@
 // ====================================================================================================================
 
-TEncTop::TEncTop()
-{
+#if !NH_MV
+TEncTop::TEncTop() :
+    m_spsMap(MAX_NUM_SPS)
+  , m_ppsMap(MAX_NUM_PPS) 
+#else
+   TEncTop::TEncTop( ParameterSetMap<TComSPS>& spsMap, ParameterSetMap<TComPPS>& ppsMap ) : 
+     m_spsMap(spsMap)
+   , m_ppsMap(ppsMap)
+#endif
+      {
+
   m_iPOCLast          = -1;
   m_iNumPicRcvd       =  0;
@@ -79 +88 @@
   m_ivPicLists = NULL;
 #endif
-#if NH_3D_IC
+#if NH_3D
   m_aICEnableCandidate = NULL;
   m_aICEnableNum = NULL;
@@ -91 +100 @@
 TEncTop::~TEncTop()
 {
-#if NH_3D_FIX_LEAK
-#if NH_3D_IC
+#if NH_3D
   if ( m_aICEnableCandidate != NULL )
   {
@@ -104 +112 @@
 #endif
 
-#endif
 #if ENC_DEC_TRACE
   if (g_hTrace != stdout)
@@ -222 +229 @@
 #endif
 {
+#if NH_MV
+  Int parameterSetId     =  getParameterSetId( );
+
+  TComSPS& sps0 = *(m_spsMap.allocatePS( parameterSetId ) ); // NOTE: implementations that use more than 1 SPS need to be aware of activation issues.
+  TComPPS& pps0 = *(m_ppsMap.allocatePS( parameterSetId ) );
+#else
+  TComSPS &sps0=*(m_spsMap.allocatePS(0)); // NOTE: implementations that use more than 1 SPS need to be aware of activation issues.
+  TComPPS &pps0=*(m_ppsMap.allocatePS(0));
+#endif
   // initialize SPS
 #if H_3D
   // Assuming that all PPS indirectly refer to the same VPS via different SPS
-  m_cSPS.setVPS(m_cVPS);
-#endif
-  xInitSPS();
-  xInitVPS();
-
-#if U0132_TARGET_BITS_SATURATION
+  sps.setVPS(m_cVPS);
+#endif
+
+#if NH_MV
+  Bool initParameterSets = getSendParameterSets();
+
+  if ( initParameterSets )
+  {
+    xInitSPS( sps0 );
+  }
+#else
+  xInitSPS( sps0 );
+  xInitVPS((*m_cVPS), sps0);
+#endif
+
   if (m_RCCpbSaturationEnabled)
   {
-    m_cRateCtrl.initHrdParam(m_cSPS.getVuiParameters()->getHrdParameters(), m_iFrameRate, m_RCInitialCpbFullness);
-  }
-#endif
+    m_cRateCtrl.initHrdParam(sps0.getVuiParameters()->getHrdParameters(), m_iFrameRate, m_RCInitialCpbFullness);
+  }
+
   m_cRdCost.setCostMode(m_costMode);
 
 #if NH_MV
-  // This seems to be incorrect, but irrelevant for the MV-HEVC
-  *(m_cVPS->getPTL()) = *m_cSPS.getPTL();
-  m_cVPS->getTimingInfo()->setTimingInfoPresentFlag       ( false );
-#endif
-  // initialize PPS
-  xInitPPS();
-  xInitRPS(isFieldCoding);
-
-  xInitPPSforTiles();
-#if NH_3D_IC
+  if ( initParameterSets )
+  {
+    // This seems to be incorrect, but irrelevant for the MV-HEVC
+    if (m_layerId == 0 )
+    {
+      *(m_cVPS->getPTL()) = *sps0.getPTL();
+      m_cVPS->getTimingInfo()->setTimingInfoPresentFlag       ( false );
+    }
+#endif
+    // initialize PPS
+    xInitPPS(pps0, sps0);
+    xInitRPS(sps0, isFieldCoding);
+    xInitScalingLists(sps0, pps0);
+
+    if (m_wcgChromaQpControl.isEnabled())
+    {
+#if NH_MV
+      AOT( true ); // This is currently not supported.
+#endif
+      TComPPS &pps1=*(m_ppsMap.allocatePS(1));
+      xInitPPS(pps1, sps0);
+      xInitScalingLists(sps0, pps1);
+    }
+#if NH_MV
+  }
+
+  // Copy initialized PS
+  m_activeSps    = sps0;
+  m_activePps    = pps0;
+  
+  // Infer layer specific values for copy
+  m_activeSps.inferRepFormat( m_cVPS, getLayerId(), initParameterSets );
+#endif
+
+#if NH_3D
   m_aICEnableCandidate = new Int[ 10 ];
   m_aICEnableNum = new Int[ 10 ];
@@ -258 +308 @@
   }
 #endif
+
 
   // initialize processing unit classes
@@ -263 +314 @@
   m_cSliceEncoder.init( this );
   m_cCuEncoder.   init( this );
+  m_cCuEncoder.setSliceEncoder(&m_cSliceEncoder);
 
 #if KWU_RC_MADPRED_E0227
@@ -273 +325 @@
                    m_useRDOQ,
                    m_useRDOQTS,
-#if T0196_SELECTIVE_RDOQ
                    m_useSelectiveRDOQ,
-#endif
                    true
                   ,m_useTransformSkipFast
@@ -287 +337 @@
 
   m_iMaxRefPicNum = 0;
-
-  xInitScalingLists();
-}
-
-Void TEncTop::xInitScalingLists()
+}
+
+Void TEncTop::xInitScalingLists(TComSPS &sps, TComPPS &pps)
 {
   // Initialise scaling lists
@@ -297 +345 @@
   const Int maxLog2TrDynamicRange[MAX_NUM_CHANNEL_TYPE] =
   {
-      m_cSPS.getMaxLog2TrDynamicRange(CHANNEL_TYPE_LUMA),
-      m_cSPS.getMaxLog2TrDynamicRange(CHANNEL_TYPE_CHROMA)
+      sps.getMaxLog2TrDynamicRange(CHANNEL_TYPE_LUMA),
+      sps.getMaxLog2TrDynamicRange(CHANNEL_TYPE_CHROMA)
   };
   if(getUseScalingListId() == SCALING_LIST_OFF)
   {
-    getTrQuant()->setFlatScalingList(maxLog2TrDynamicRange, m_cSPS.getBitDepths());
+    getTrQuant()->setFlatScalingList(maxLog2TrDynamicRange, sps.getBitDepths());
     getTrQuant()->setUseScalingList(false);
-    m_cSPS.setScalingListPresentFlag(false);
-    m_cPPS.setScalingListPresentFlag(false);
+    sps.setScalingListPresentFlag(false);
+    pps.setScalingListPresentFlag(false);
   }
   else if(getUseScalingListId() == SCALING_LIST_DEFAULT)
   {
-    m_cSPS.getScalingList().setDefaultScalingList ();
-    m_cSPS.setScalingListPresentFlag(false);
-    m_cPPS.setScalingListPresentFlag(false);
-
-    getTrQuant()->setScalingList(&(m_cSPS.getScalingList()), maxLog2TrDynamicRange, m_cSPS.getBitDepths());
+    sps.getScalingList().setDefaultScalingList ();
+    sps.setScalingListPresentFlag(false);
+    pps.setScalingListPresentFlag(false);
+
+    getTrQuant()->setScalingList(&(sps.getScalingList()), maxLog2TrDynamicRange, sps.getBitDepths());
     getTrQuant()->setUseScalingList(true);
   }
   else if(getUseScalingListId() == SCALING_LIST_FILE_READ)
   {
-    m_cSPS.getScalingList().setDefaultScalingList ();
-    if(m_cSPS.getScalingList().xParseScalingList(getScalingListFileName()))
+    sps.getScalingList().setDefaultScalingList ();
+    if(sps.getScalingList().xParseScalingList(getScalingListFileName()))
     {
       Bool bParsedScalingList=false; // Use of boolean so that assertion outputs useful string
@@ -325 +373 @@
       exit(1);
     }
-    m_cSPS.getScalingList().checkDcOfMatrix();
-    m_cSPS.setScalingListPresentFlag(m_cSPS.getScalingList().checkDefaultScalingList());
-    m_cPPS.setScalingListPresentFlag(false);
-    getTrQuant()->setScalingList(&(m_cSPS.getScalingList()), maxLog2TrDynamicRange, m_cSPS.getBitDepths());
+    sps.getScalingList().checkDcOfMatrix();
+    sps.setScalingListPresentFlag(sps.getScalingList().checkDefaultScalingList());
+    pps.setScalingListPresentFlag(false);
+    getTrQuant()->setScalingList(&(sps.getScalingList()), maxLog2TrDynamicRange, sps.getBitDepths());
     getTrQuant()->setUseScalingList(true);
   }
@@ -346 +394 @@
     for(UInt listId = 0; listId < SCALING_LIST_NUM; listId+=predListStep)
     {
-      m_cSPS.getScalingList().checkPredMode( sizeId, listId );
+        sps.getScalingList().checkPredMode( sizeId, listId );
     }
   }
@@ -362 +410 @@
 
   // get original YUV
-  xGetNewPicBuffer( pcPicCurr );
+
+  xGetNewPicBuffer( pcPicCurr, getParameterSetId() );
   pcPicYuvOrg->copyToPic( pcPicCurr->getPicYuvOrg() );
 
@@ -431 +480 @@
     TComPic* pcPicCurr = NULL;
 
-    xGetNewPicBuffer( pcPicCurr );
+    Int ppsID=-1; // Use default PPS ID
+    if (getWCGChromaQPControl().isEnabled())
+    {
+      ppsID=getdQPs()[ m_iPOCLast+1 ];
+    }
+    xGetNewPicBuffer( pcPicCurr, ppsID );
     pcPicYuvOrg->copyToPic( pcPicCurr->getPicYuvOrg() );
     pcPicYuvTrueOrg->copyToPic( pcPicCurr->getPicYuvTrueOrg() );
@@ -454 +508 @@
 #if NH_MV
   }
-  m_cGOPEncoder.compressPicInGOP(m_iPOCLast, m_iNumPicRcvd, *(m_ivPicLists->getSubDpb(getLayerId(), false) ), rcListPicYuvRecOut, accessUnitsOut, false, false, snrCSC, m_printFrameMSE, gopId);
+  m_cGOPEncoder.compressPicInGOP(m_iPOCLast, m_iNumPicRcvd, *(m_ivPicLists->getSubDpb(getLayerId(), false) ), rcListPicYuvRecOut, accessUnitsOut, false, false, snrCSC, m_printFrameMSE,  m_printMSSSIM, gopId);
 
   if( gopId + 1 == m_cGOPEncoder.getGOPSize() )
@@ -460 +514 @@
 #else
   // compress GOP
+#if JVET_F0064_MSSSIM
+  m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, false, false, snrCSC, m_printFrameMSE, m_printMSSSIM);
+#else
   m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, false, false, snrCSC, m_printFrameMSE);
+#endif
 #endif
   if ( m_RCEnableRateControl )
@@ -515 +573 @@
 
       TComPic *pcField;
-      xGetNewPicBuffer( pcField );
+      xGetNewPicBuffer( pcField, -1 );
       pcField->setReconMark (false);                     // where is this normally?
 
@@ -536 +594 @@
 
       pcField->getSlice(0)->setPOC( m_iPOCLast );        // superfluous?
+#if !REDUCED_ENCODER_MEMORY
       pcField->getPicYuvRec()->setBorderExtension(false);// where is this normally?
+#endif
 
       pcField->setTopField(isTopField);                  // interlaced requirement
@@ -570 +630 @@
     {
       // compress GOP
+#if JVET_F0064_MSSSIM
+      m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, true, isTff, snrCSC, m_printFrameMSE, m_printMSSSIM);
+#else
       m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, true, isTff, snrCSC, m_printFrameMSE);
+#endif
 
       iNumEncoded += m_iNumPicRcvd;
@@ -590 +654 @@
  \retval rpcPic obtained picture buffer
  */
-Void TEncTop::xGetNewPicBuffer ( TComPic*& rpcPic )
-{
+Void TEncTop::xGetNewPicBuffer ( TComPic*& rpcPic, Int ppsId )
+{
+  rpcPic=0;
+
+#if NH_MV
+  const TComPPS &pps = m_activePps;
+  const TComSPS &sps = m_activeSps;
+  
+  if ( ppsId > 0 )
+  {
+    assert( pps.getPPSId() == ppsId );
+    assert( sps.getSPSId() == pps.getSPSId() );
+  }
+#else
+  const TComSPS *pSPS=m_spsMap.getPS(pps.getSPSId());
   // At this point, the SPS and PPS can be considered activated - they are copied to the new TComPic.
+  const TComPPS *pPPS=(ppsId<0) ? m_ppsMap.getFirstPS() : m_ppsMap.getPS(ppsId);
+  assert (pPPS!=0);
+  const TComPPS &pps=*pPPS;
+  assert (pSPS!=0);
+
+  assert (pSPS!=0);
+  const TComSPS &sps=*pSPS;
+
+#endif
+
 
 #if NH_MV
   TComList<TComPic*>& cListPic = *(m_ivPicLists->getSubDpb(getLayerId(), false) );
   TComSlice::sortPicList(cListPic);
+  // Infer the correct rep format
+
+  // As 
 #else
   TComSlice::sortPicList(m_cListPic);
@@ -608 +698 @@
     Int iSize = Int( cListPic.size() );
 #else
+  // use an entry in the buffered list if the maximum number that need buffering has been reached:
+
   if (m_cListPic.size() >= (UInt)(m_iGOPSize + getMaxDecPicBuffering(MAX_TLAYER-1) + 2) )
   {
@@ -615 +707 @@
     for ( Int i = 0; i < iSize; i++ )
     {
-      rpcPic = *(iterPic++);
+      rpcPic = *iterPic;
       if(rpcPic->getSlice(0)->isReferenced() == false)
       {
         break;
       }
-    }
-  }
-  else
+      iterPic++;
+    }
+    // If PPS ID is the same, we will assume that it has not changed since it was last used
+    // and return the old object.
+    if (pps.getPPSId() == rpcPic->getPicSym()->getPPS().getPPSId())
+    {
+#if REDUCED_ENCODER_MEMORY
+      rpcPic->releaseAllReconstructionData();
+      rpcPic->prepareForEncoderSourcePicYuv();
+#endif
+    }
+    else
+    {
+      // the IDs differ - free up an entry in the list, and then create a new one, as with the case where the max buffering state has not been reached.
+      delete rpcPic;
+      cListPic.erase(iterPic);
+      rpcPic=0;
+    }
+  }
+
+  if (rpcPic==0)
   {
     if ( getUseAdaptiveQP() )
     {
       TEncPic* pcEPic = new TEncPic;
-      pcEPic->create( m_cSPS, m_cPPS, m_cPPS.getMaxCuDQPDepth()+1, false);
+#if REDUCED_ENCODER_MEMORY
+      pcEPic->create( sps, pps, pps.getMaxCuDQPDepth()+1);
+#else
+      pcEPic->create( sps, pps, pps.getMaxCuDQPDepth()+1, false);
+#endif
       rpcPic = pcEPic;
     }
@@ -633 +747 @@
     {
       rpcPic = new TComPic;
-      rpcPic->create( m_cSPS, m_cPPS, false );
+#if REDUCED_ENCODER_MEMORY
+      rpcPic->create( sps, pps, true, false );
+#else
+      rpcPic->create( sps, pps, false );
+#endif
     }
 
@@ -648 +766 @@
 
   rpcPic->getSlice(0)->setPOC( m_iPOCLast );
+#if !REDUCED_ENCODER_MEMORY
   // mark it should be extended
   rpcPic->getPicYuvRec()->setBorderExtension(false);
@@ -653 +772 @@
   rpcPic->getPicYuvOrg()->setBorderExtension(false);
 #endif
-
-}
-
-Void TEncTop::xInitVPS()
+#endif
+}
+
+Void TEncTop::xInitVPS(TComVPS &vps, const TComSPS &sps)
 {
   // The SPS must have already been set up.
@@ -663 +782 @@
   // Do initialization in TAppEncTop
 #else
-  *m_cVPS.getPTL() = *m_cSPS.getPTL();
-  m_cVPS.setMaxOpSets(1);
-  m_cVPS.getTimingInfo()->setTimingInfoPresentFlag       ( false );
-  m_cVPS.setNumHrdParameters( 0 );
-
-  m_cVPS.createHrdParamBuffer();
-  for( UInt i = 0; i < m_cVPS.getNumHrdParameters(); i ++ )
-  {
-    m_cVPS.setHrdOpSetIdx( 0, i );
-    m_cVPS.setCprmsPresentFlag( false, i );
+  *vps.getPTL() = *sps.getPTL();
+  vps.setMaxOpSets(1);
+  vps.getTimingInfo()->setTimingInfoPresentFlag       ( false );
+  vps.setNumHrdParameters( 0 );
+
+  vps.createHrdParamBuffer();
+  for( UInt i = 0; i < vps.getNumHrdParameters(); i ++ )
+  {
+    vps.setHrdOpSetIdx( 0, i );
+    vps.setCprmsPresentFlag( false, i );
     // Set up HrdParameters here.
   }
@@ -678 +797 @@
 }
 
-Void TEncTop::xInitSPS()
-{
-#if NH_MV
-  m_cSPS.setSPSId( getLayerIdInVps() );
-  m_cSPS.setLayerId( getLayerId() );
+Void TEncTop::xInitSPS(TComSPS &sps)
+{
+#if NH_MV
+  //AOF( sps.getSPSId() == getLayerIdInVps() );
+  sps.setLayerId( getLayerId() );
  // Code below needs to be moved to VPS
 #endif
-  ProfileTierLevel& profileTierLevel = *m_cSPS.getPTL()->getGeneralPTL();
+  ProfileTierLevel& profileTierLevel = *sps.getPTL()->getGeneralPTL();
   profileTierLevel.setLevelIdc(m_level);
   profileTierLevel.setTierFlag(m_levelTier);
@@ -714 +833 @@
    * that chooses the actual compatibility based upon options */
 #if NH_MV  
-  m_cSPS.setUpdateRepFormatFlag           ( false );    
-  Bool multiLayerExtensionFlag  = ( getLayerId() > 0 ) && ( m_cVPS->getNumRefLayers( getLayerId() ) > 0 ); 
+  sps.setUpdateRepFormatFlag           ( false );    
   
-  m_cSPS.setSpsExtOrMaxSubLayersMinus1( multiLayerExtensionFlag ? 7 : m_maxTempLayer - 1 );
+  Bool multiLayerExtensionFlag  =      ( getLayerId() > 0  &&  m_cVPS->getNumRefLayers( getLayerId() ) > 0 );
+  sps.setSpsExtOrMaxSubLayersMinus1( multiLayerExtensionFlag ? 7 : m_maxTempLayer - 1 );
   if ( multiLayerExtensionFlag )
   {
-    m_cSPS.setSpsInferScalingListFlag   ( true ); 
-    m_cSPS.setSpsScalingListRefLayerId( m_cVPS->getIdRefLayer( getLayerId(), 0 ) ); 
+    sps.setSpsInferScalingListFlag   ( true ); 
+    sps.setSpsScalingListRefLayerId( m_cVPS->getIdRefLayer( getLayerId(), 0 ) ); 
 #if NH_MV
     if ( m_bUseDisparitySearchRangeRestriction )
     {
-      m_cSPS.setInterViewMvVertConstraintFlag ( true ) ;
+      sps.setInterViewMvVertConstraintFlag ( true ) ;
     }
 #endif
   }  
-  m_cSPS.setSpsExtensionPresentFlag       ( true ); 
-  m_cSPS.setSpsMultilayerExtensionFlag    ( true ); 
+  sps.setSpsExtensionPresentFlag       ( true ); 
+  sps.setSpsMultilayerExtensionFlag    ( true ); 
 #if NH_3D
-  m_cSPS.setSps3dExtensionFlag            ( true ); 
-#endif
-#endif
-
-  m_cSPS.setPicWidthInLumaSamples  ( m_iSourceWidth      );
-  m_cSPS.setPicHeightInLumaSamples ( m_iSourceHeight     );
-  m_cSPS.setConformanceWindow      ( m_conformanceWindow );
-  m_cSPS.setMaxCUWidth             ( m_maxCUWidth        );
-  m_cSPS.setMaxCUHeight            ( m_maxCUHeight       );
-  m_cSPS.setMaxTotalCUDepth        ( m_maxTotalCUDepth   );
+  sps.setSps3dExtensionFlag            ( true ); 
+#endif
+#endif
+
+  sps.setPicWidthInLumaSamples  ( m_iSourceWidth      );
+  sps.setPicHeightInLumaSamples ( m_iSourceHeight     );
+  sps.setConformanceWindow      ( m_conformanceWindow );
+  sps.setMaxCUWidth             ( m_maxCUWidth        );
+  sps.setMaxCUHeight            ( m_maxCUHeight       );
+  sps.setMaxTotalCUDepth        ( m_maxTotalCUDepth   );
 #if NH_3D
   assert( !getIsDepth()  || m_chromaFormatIDC == CHROMA_400 ); 
 #endif
-  m_cSPS.setChromaFormatIdc( m_chromaFormatIDC);
-  m_cSPS.setLog2DiffMaxMinCodingBlockSize(m_log2DiffMaxMinCodingBlockSize);
-
-  Int minCUSize = m_cSPS.getMaxCUWidth() >> ( m_cSPS.getLog2DiffMaxMinCodingBlockSize() );
+  sps.setChromaFormatIdc( m_chromaFormatIDC);
+  sps.setLog2DiffMaxMinCodingBlockSize(m_log2DiffMaxMinCodingBlockSize);
+
+  Int minCUSize = sps.getMaxCUWidth() >> ( sps.getLog2DiffMaxMinCodingBlockSize() );
   Int log2MinCUSize = 0;
   while(minCUSize > 1)
@@ -756 +875 @@
   }
 
-  m_cSPS.setLog2MinCodingBlockSize(log2MinCUSize);
-
-  m_cSPS.setPCMLog2MinSize (m_uiPCMLog2MinSize);
-  m_cSPS.setUsePCM        ( m_usePCM           );
-  m_cSPS.setPCMLog2MaxSize( m_pcmLog2MaxSize  );
-
-  m_cSPS.setQuadtreeTULog2MaxSize( m_uiQuadtreeTULog2MaxSize );
-  m_cSPS.setQuadtreeTULog2MinSize( m_uiQuadtreeTULog2MinSize );
-  m_cSPS.setQuadtreeTUMaxDepthInter( m_uiQuadtreeTUMaxDepthInter    );
-  m_cSPS.setQuadtreeTUMaxDepthIntra( m_uiQuadtreeTUMaxDepthIntra    );
-
-  m_cSPS.setTMVPFlagsPresent((getTMVPModeId() == 2 || getTMVPModeId() == 1));
-
-  m_cSPS.setMaxTrSize   ( 1 << m_uiQuadtreeTULog2MaxSize );
-
-  m_cSPS.setUseAMP ( m_useAMP );
+  sps.setLog2MinCodingBlockSize(log2MinCUSize);
+
+  sps.setPCMLog2MinSize (m_uiPCMLog2MinSize);
+  sps.setUsePCM        ( m_usePCM           );
+  sps.setPCMLog2MaxSize( m_pcmLog2MaxSize  );
+
+  sps.setQuadtreeTULog2MaxSize( m_uiQuadtreeTULog2MaxSize );
+  sps.setQuadtreeTULog2MinSize( m_uiQuadtreeTULog2MinSize );
+  sps.setQuadtreeTUMaxDepthInter( m_uiQuadtreeTUMaxDepthInter    );
+  sps.setQuadtreeTUMaxDepthIntra( m_uiQuadtreeTUMaxDepthIntra    );
+
+  sps.setSPSTemporalMVPEnabledFlag((getTMVPModeId() == 2 || getTMVPModeId() == 1));
+
+  sps.setMaxTrSize   ( 1 << m_uiQuadtreeTULog2MaxSize );
+
+  sps.setUseAMP ( m_useAMP );
 
   for (UInt channelType = 0; channelType < MAX_NUM_CHANNEL_TYPE; channelType++)
   {
-    m_cSPS.setBitDepth      (ChannelType(channelType), m_bitDepth[channelType] );
+    sps.setBitDepth      (ChannelType(channelType), m_bitDepth[channelType] );
 #if O0043_BEST_EFFORT_DECODING
-    m_cSPS.setStreamBitDepth(ChannelType(channelType), m_bitDepth[channelType] );
-#endif
-    m_cSPS.setQpBDOffset  (ChannelType(channelType), (6 * (m_bitDepth[channelType] - 8)));
-    m_cSPS.setPCMBitDepth (ChannelType(channelType), m_PCMBitDepth[channelType]         );
-  }
-#if NH_MV
-  m_cSPS.inferRepFormat( m_cVPS, getLayerId(), true ); 
-#endif
-m_cSPS.setUseSAO( m_bUseSAO );
-
-  m_cSPS.setMaxTLayers( m_maxTempLayer );
-  m_cSPS.setTemporalIdNestingFlag( ( m_maxTempLayer == 1 ) ? true : false );
-
-  for (Int i = 0; i < min(m_cSPS.getMaxTLayers(),(UInt) MAX_TLAYER); i++ )
-  {
-    m_cSPS.setMaxDecPicBuffering(m_maxDecPicBuffering[i], i);
-    m_cSPS.setNumReorderPics(m_numReorderPics[i], i);
+    sps.setStreamBitDepth(ChannelType(channelType), m_bitDepth[channelType] );
+#endif
+    sps.setQpBDOffset  (ChannelType(channelType), (6 * (m_bitDepth[channelType] - 8)));
+    sps.setPCMBitDepth (ChannelType(channelType), m_PCMBitDepth[channelType]         );
+  }
+  sps.setUseSAO( m_bUseSAO );
+
+  sps.setMaxTLayers( m_maxTempLayer );
+  sps.setTemporalIdNestingFlag( ( m_maxTempLayer == 1 ) ? true : false );
+
+  for (Int i = 0; i < min(sps.getMaxTLayers(),(UInt) MAX_TLAYER); i++ )
+  {
+    sps.setMaxDecPicBuffering(m_maxDecPicBuffering[i], i);
+    sps.setNumReorderPics(m_numReorderPics[i], i);
   }
 #if NH_MV
@@ -804 +920 @@
       if ( m_cVPS->getNecessaryLayerFlag( ols, is ) )
       {      
-        m_cSPS.inferSpsMaxDecPicBufferingMinus1( m_cVPS, ols, targetDecLayerIdList[is], true );       
-      }
-    }
-  }
-#endif
-
-
-  m_cSPS.setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag );
-  m_cSPS.setScalingListFlag ( (m_useScalingListId == SCALING_LIST_OFF) ? 0 : 1 );
-  m_cSPS.setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
-  m_cSPS.setVuiParametersPresentFlag(getVuiParametersPresentFlag());
-
-  if (m_cSPS.getVuiParametersPresentFlag())
-  {
-    TComVUI* pcVUI = m_cSPS.getVuiParameters();
+        sps.inferSpsMaxDecPicBufferingMinus1( m_cVPS, ols, targetDecLayerIdList[is], true );       
+      }
+    }
+  }
+#endif
+
+
+  sps.setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag );
+  sps.setScalingListFlag ( (m_useScalingListId == SCALING_LIST_OFF) ? 0 : 1 );
+  sps.setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
+  sps.setVuiParametersPresentFlag(getVuiParametersPresentFlag());
+
+  if (sps.getVuiParametersPresentFlag())
+  {
+    TComVUI* pcVUI = sps.getVuiParameters();
     pcVUI->setAspectRatioInfoPresentFlag(getAspectRatioInfoPresentFlag());
     pcVUI->setAspectRatioIdc(getAspectRatioIdc());
@@ -855 +971 @@
     pcVUI->setLog2MaxMvLengthVertical(getLog2MaxMvLengthVertical());
   }
-  m_cSPS.setNumLongTermRefPicSPS(NUM_LONG_TERM_REF_PIC_SPS);
+  sps.setNumLongTermRefPicSPS(NUM_LONG_TERM_REF_PIC_SPS);
   assert (NUM_LONG_TERM_REF_PIC_SPS <= MAX_NUM_LONG_TERM_REF_PICS);
   for (Int k = 0; k < NUM_LONG_TERM_REF_PIC_SPS; k++)
   {
-    m_cSPS.setLtRefPicPocLsbSps(k, 0);
-    m_cSPS.setUsedByCurrPicLtSPSFlag(k, 0);
-  }
-
-#if U0132_TARGET_BITS_SATURATION
+    sps.setLtRefPicPocLsbSps(k, 0);
+    sps.setUsedByCurrPicLtSPSFlag(k, 0);
+  }
+
   if( getPictureTimingSEIEnabled() || getDecodingUnitInfoSEIEnabled() || getCpbSaturationEnabled() )
-#else
-  if( getPictureTimingSEIEnabled() || getDecodingUnitInfoSEIEnabled() )
-#endif
-  {
-    xInitHrdParameters();
+  {
+    xInitHrdParameters(sps);
   }
   if( getBufferingPeriodSEIEnabled() || getPictureTimingSEIEnabled() || getDecodingUnitInfoSEIEnabled() )
   {
-    m_cSPS.getVuiParameters()->setHrdParametersPresentFlag( true );
+    sps.getVuiParameters()->setHrdParametersPresentFlag( true );
   }
 
   // Set up SPS range extension settings
-  m_cSPS.getSpsRangeExtension().setTransformSkipRotationEnabledFlag(m_transformSkipRotationEnabledFlag);
-  m_cSPS.getSpsRangeExtension().setTransformSkipContextEnabledFlag(m_transformSkipContextEnabledFlag);
+  sps.getSpsRangeExtension().setTransformSkipRotationEnabledFlag(m_transformSkipRotationEnabledFlag);
+  sps.getSpsRangeExtension().setTransformSkipContextEnabledFlag(m_transformSkipContextEnabledFlag);
   for (UInt signallingModeIndex = 0; signallingModeIndex < NUMBER_OF_RDPCM_SIGNALLING_MODES; signallingModeIndex++)
   {
-    m_cSPS.getSpsRangeExtension().setRdpcmEnabledFlag(RDPCMSignallingMode(signallingModeIndex), m_rdpcmEnabledFlag[signallingModeIndex]);
-  }
-  m_cSPS.getSpsRangeExtension().setExtendedPrecisionProcessingFlag(m_extendedPrecisionProcessingFlag);
-  m_cSPS.getSpsRangeExtension().setIntraSmoothingDisabledFlag( m_intraSmoothingDisabledFlag );
-  m_cSPS.getSpsRangeExtension().setHighPrecisionOffsetsEnabledFlag(m_highPrecisionOffsetsEnabledFlag);
-  m_cSPS.getSpsRangeExtension().setPersistentRiceAdaptationEnabledFlag(m_persistentRiceAdaptationEnabledFlag);
-  m_cSPS.getSpsRangeExtension().setCabacBypassAlignmentEnabledFlag(m_cabacBypassAlignmentEnabledFlag);
-#if NH_MV
-  m_cSPS.setSpsRangeExtensionsFlag( m_cSPS.getSpsRangeExtension().settingsDifferFromDefaults() );
-#endif
-}
-#if U0132_TARGET_BITS_SATURATION
+    sps.getSpsRangeExtension().setRdpcmEnabledFlag(RDPCMSignallingMode(signallingModeIndex), m_rdpcmEnabledFlag[signallingModeIndex]);
+  }
+  sps.getSpsRangeExtension().setExtendedPrecisionProcessingFlag(m_extendedPrecisionProcessingFlag);
+  sps.getSpsRangeExtension().setIntraSmoothingDisabledFlag( m_intraSmoothingDisabledFlag );
+  sps.getSpsRangeExtension().setHighPrecisionOffsetsEnabledFlag(m_highPrecisionOffsetsEnabledFlag);
+  sps.getSpsRangeExtension().setPersistentRiceAdaptationEnabledFlag(m_persistentRiceAdaptationEnabledFlag);
+  sps.getSpsRangeExtension().setCabacBypassAlignmentEnabledFlag(m_cabacBypassAlignmentEnabledFlag);
+#if NH_MV
+  sps.setSpsRangeExtensionsFlag( sps.getSpsRangeExtension().settingsDifferFromDefaults() );
+#endif
+#if NH_3D
+  sps.setSps3dExtension( m_sps3dExtension );
+#endif
+}
 // calculate scale value of bitrate and initial delay
 Int calcScale(Int x)
 {
+  if (x==0)
+  {
+    return 0;
+  }
   UInt iMask = 0xffffffff;
   Int ScaleValue = 32;
@@ -907 +1025 @@
   return ScaleValue;
 }
-#endif
-Void TEncTop::xInitHrdParameters()
+Void TEncTop::xInitHrdParameters(TComSPS &sps)
 {
   Bool useSubCpbParams = (getSliceMode() > 0) || (getSliceSegmentMode() > 0);
   Int  bitRate         = getTargetBitrate();
   Bool isRandomAccess  = getIntraPeriod() > 0;
-# if U0132_TARGET_BITS_SATURATION
   Int cpbSize          = getCpbSize();
 
+  assert (cpbSize!=0);  // CPB size may not be equal to zero. ToDo: have a better default and check for level constraints
   if( !getVuiParametersPresentFlag() && !getCpbSaturationEnabled() )
-#else
-  if( !getVuiParametersPresentFlag() )
-#endif
   {
     return;
   }
 
-  TComVUI *vui = m_cSPS.getVuiParameters();
+  TComVUI *vui = sps.getVuiParameters();
   TComHRD *hrd = vui->getHrdParameters();
 
@@ -982 +1096 @@
   }
 
-#if U0132_TARGET_BITS_SATURATION
   if (calcScale(bitRate) <= 6)
   {
@@ -1000 +1113 @@
     hrd->setCpbSizeScale(calcScale(cpbSize) - 4);
   }
-#else
-  hrd->setBitRateScale( 4 );                                       // in units of 2^( 6 + 4 ) = 1,024 bps
-  hrd->setCpbSizeScale( 6 );                                       // in units of 2^( 4 + 6 ) = 1,024 bit
-#endif
 
   hrd->setDuCpbSizeScale( 6 );                                     // in units of 2^( 4 + 6 ) = 1,024 bit
@@ -1036 +1145 @@
     bitrateValue = bitRate / (1 << (6 + hrd->getBitRateScale()) );      // bitRate is in bits, so it needs to be scaled down
     // CpbSize[ i ] = ( cpb_size_value_minus1[ i ] + 1 ) * 2^( 4 + cpb_size_scale )
-#if U0132_TARGET_BITS_SATURATION
     cpbSizeValue = cpbSize / (1 << (4 + hrd->getCpbSizeScale()) );      // using bitRate results in 1 second CPB size
-#else
-    cpbSizeValue = bitRate / (1 << (4 + hrd->getCpbSizeScale()) );      // using bitRate results in 1 second CPB size
-#endif
-
 
     // DU CPB size could be smaller (i.e. bitrateValue / number of DUs), but we don't know 
@@ -1066 +1170 @@
 
 
-Void TEncTop::xInitPPS()
-{
-#if NH_MV
-  m_cPPS.setLayerId( getLayerId() );
+Void TEncTop::xInitPPS(TComPPS &pps, const TComSPS &sps) const
+{
+
+  // pps ID already initialised.
+  pps.setSPSId(sps.getSPSId());
+
+#if NH_MV
+  AOF( pps.getPPSId() ==  getLayerIdInVps() );
+  pps.setLayerId( getLayerId() );
 #if NH_3D
   // Check if this condition is still correct
@@ -1077 +1186 @@
 #endif
   {
-    m_cPPS.setListsModificationPresentFlag( true );
-  }
-  m_cPPS.setPPSId( getLayerIdInVps() );
-  m_cPPS.setSPSId( getLayerIdInVps() );
-  m_cPPS.setPpsMultilayerExtensionFlag    ( true ); 
+    pps.setListsModificationPresentFlag( true );
+  }
+  pps.setPpsMultilayerExtensionFlag    ( true ); 
 #if NH_3D
   // Might be used for DLT
-  m_cPPS.setPps3dExtensionFlag            ( getIsDepth() ); 
-#endif
-#endif
-
-#if NH_3D_DLT
+  pps.setPps3dExtensionFlag            ( getIsDepth() ); 
+#endif
+#endif
+
+#if NH_3D
+  // This should be done in TEncAppTop
+  TComDLT curDlt = m_cDLT;
   // create mapping from depth layer indexes to layer ids
   Int j=0;
@@ -1095 +1204 @@
     Int layerId = getVPS()->getLayerIdInNuh(i);
     if( getVPS()->getDepthId(layerId) )
-      m_cDLT.setDepthIdxToLayerId(j++, layerId);
-  }
-  m_cPPS.setDLT( m_cDLT );
-#endif
-
-  m_cPPS.setConstrainedIntraPred( m_bUseConstrainedIntraPred );
+      curDlt.setDepthIdxToLayerId(j++, layerId);
+  }
+  pps.setDLT( curDlt );
+#endif
+
+  pps.setConstrainedIntraPred( m_bUseConstrainedIntraPred );
   Bool bUseDQP = (getMaxCuDQPDepth() > 0)? true : false;
 
@@ -1108 +1217 @@
   }
 
+  if ( getLumaLevelToDeltaQPMapping().isEnabled() )
+  {
+    bUseDQP = true;
+  }
+
   if (m_costMode==COST_SEQUENCE_LEVEL_LOSSLESS || m_costMode==COST_LOSSLESS_CODING)
   {
@@ -1113 +1227 @@
   }
 
-
   if ( m_RCEnableRateControl )
   {
-    m_cPPS.setUseDQP(true);
-    m_cPPS.setMaxCuDQPDepth( 0 );
+    pps.setUseDQP(true);
+    pps.setMaxCuDQPDepth( 0 );
   }
   else if(bUseDQP)
   {
-    m_cPPS.setUseDQP(true);
-    m_cPPS.setMaxCuDQPDepth( m_iMaxCuDQPDepth );
+    pps.setUseDQP(true);
+    pps.setMaxCuDQPDepth( m_iMaxCuDQPDepth );
   }
   else
   {
-    m_cPPS.setUseDQP(false);
-    m_cPPS.setMaxCuDQPDepth( 0 );
+    pps.setUseDQP(false);
+    pps.setMaxCuDQPDepth( 0 );
   }
 
   if ( m_diffCuChromaQpOffsetDepth >= 0 )
   {
-    m_cPPS.getPpsRangeExtension().setDiffCuChromaQpOffsetDepth(m_diffCuChromaQpOffsetDepth);
-    m_cPPS.getPpsRangeExtension().clearChromaQpOffsetList();
-    m_cPPS.getPpsRangeExtension().setChromaQpOffsetListEntry(1, 6, 6);
+    pps.getPpsRangeExtension().setDiffCuChromaQpOffsetDepth(m_diffCuChromaQpOffsetDepth);
+    pps.getPpsRangeExtension().clearChromaQpOffsetList();
+    pps.getPpsRangeExtension().setChromaQpOffsetListEntry(1, 6, 6);
     /* todo, insert table entries from command line (NB, 0 should not be touched) */
   }
   else
   {
-    m_cPPS.getPpsRangeExtension().setDiffCuChromaQpOffsetDepth(0);
-    m_cPPS.getPpsRangeExtension().clearChromaQpOffsetList();
-  }
-  m_cPPS.getPpsRangeExtension().setCrossComponentPredictionEnabledFlag(m_crossComponentPredictionEnabledFlag);
-  m_cPPS.getPpsRangeExtension().setLog2SaoOffsetScale(CHANNEL_TYPE_LUMA,   m_log2SaoOffsetScale[CHANNEL_TYPE_LUMA  ]);
-  m_cPPS.getPpsRangeExtension().setLog2SaoOffsetScale(CHANNEL_TYPE_CHROMA, m_log2SaoOffsetScale[CHANNEL_TYPE_CHROMA]);
-
-  m_cPPS.setQpOffset(COMPONENT_Cb, m_chromaCbQpOffset );
-  m_cPPS.setQpOffset(COMPONENT_Cr, m_chromaCrQpOffset );
-#if W0038_CQP_ADJ
+    pps.getPpsRangeExtension().setDiffCuChromaQpOffsetDepth(0);
+    pps.getPpsRangeExtension().clearChromaQpOffsetList();
+  }
+  pps.getPpsRangeExtension().setCrossComponentPredictionEnabledFlag(m_crossComponentPredictionEnabledFlag);
+  pps.getPpsRangeExtension().setLog2SaoOffsetScale(CHANNEL_TYPE_LUMA,   m_log2SaoOffsetScale[CHANNEL_TYPE_LUMA  ]);
+  pps.getPpsRangeExtension().setLog2SaoOffsetScale(CHANNEL_TYPE_CHROMA, m_log2SaoOffsetScale[CHANNEL_TYPE_CHROMA]);
+
+  if (getWCGChromaQPControl().isEnabled())
+  {
+    const Int baseQp=m_iQP+pps.getPPSId();
+    const Double chromaQp = m_wcgChromaQpControl.chromaQpScale * baseQp + m_wcgChromaQpControl.chromaQpOffset;
+    const Double dcbQP = m_wcgChromaQpControl.chromaCbQpScale * chromaQp;
+    const Double dcrQP = m_wcgChromaQpControl.chromaCrQpScale * chromaQp;
+    const Int cbQP =(Int)(dcbQP + ( dcbQP < 0 ? -0.5 : 0.5) );
+    const Int crQP =(Int)(dcrQP + ( dcrQP < 0 ? -0.5 : 0.5) );
+    pps.setQpOffset(COMPONENT_Cb, Clip3( -12, 12, min(0, cbQP) + m_chromaCbQpOffset ));
+    pps.setQpOffset(COMPONENT_Cr, Clip3( -12, 12, min(0, crQP) + m_chromaCrQpOffset));
+  }
+  else
+  {
+    pps.setQpOffset(COMPONENT_Cb, m_chromaCbQpOffset );
+    pps.setQpOffset(COMPONENT_Cr, m_chromaCrQpOffset );
+  }
   Bool bChromaDeltaQPEnabled = false;
   {
@@ -1164 +1290 @@
     }
   }
-  m_cPPS.setSliceChromaQpFlag(bChromaDeltaQPEnabled);
-#endif
-
-  m_cPPS.setEntropyCodingSyncEnabledFlag( m_entropyCodingSyncEnabledFlag );
-  m_cPPS.setTilesEnabledFlag( (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0) );
-  m_cPPS.setUseWP( m_useWeightedPred );
-  m_cPPS.setWPBiPred( m_useWeightedBiPred );
-  m_cPPS.setOutputFlagPresentFlag( false );
-#if NH_MV
-  m_cPPS.setNumExtraSliceHeaderBits( 2 ); 
-#endif
-  m_cPPS.setSignHideFlag(getSignHideFlag());
+  pps.setSliceChromaQpFlag(bChromaDeltaQPEnabled);
+
+  pps.setEntropyCodingSyncEnabledFlag( m_entropyCodingSyncEnabledFlag );
+  pps.setTilesEnabledFlag( (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0) );
+  pps.setUseWP( m_useWeightedPred );
+  pps.setWPBiPred( m_useWeightedBiPred );
+  pps.setOutputFlagPresentFlag( false );
+#if NH_MV
+  pps.setNumExtraSliceHeaderBits( 2 ); 
+#endif
+  pps.setSignDataHidingEnabledFlag(getSignDataHidingEnabledFlag());
+
   if ( getDeblockingFilterMetric() )
   {
-    m_cPPS.setDeblockingFilterOverrideEnabledFlag(true);
-    m_cPPS.setPicDisableDeblockingFilterFlag(false);
+    pps.setDeblockingFilterOverrideEnabledFlag(true);
+    pps.setPPSDeblockingFilterDisabledFlag(false);
   }
   else
   {
-      m_cPPS.setDeblockingFilterOverrideEnabledFlag( !getLoopFilterOffsetInPPS() );
-      m_cPPS.setPicDisableDeblockingFilterFlag( getLoopFilterDisable() );
-    }
-
-  if (! m_cPPS.getPicDisableDeblockingFilterFlag())
-  {
-    m_cPPS.setDeblockingFilterBetaOffsetDiv2( getLoopFilterBetaOffset() );
-    m_cPPS.setDeblockingFilterTcOffsetDiv2( getLoopFilterTcOffset() );
+    pps.setDeblockingFilterOverrideEnabledFlag( !getLoopFilterOffsetInPPS() );
+    pps.setPPSDeblockingFilterDisabledFlag( getLoopFilterDisable() );
+    }
+
+  if (! pps.getPPSDeblockingFilterDisabledFlag())
+  {
+    pps.setDeblockingFilterBetaOffsetDiv2( getLoopFilterBetaOffset() );
+    pps.setDeblockingFilterTcOffsetDiv2( getLoopFilterTcOffset() );
   }
   else
   {
-    m_cPPS.setDeblockingFilterBetaOffsetDiv2(0);
-    m_cPPS.setDeblockingFilterTcOffsetDiv2(0);
+    pps.setDeblockingFilterBetaOffsetDiv2(0);
+    pps.setDeblockingFilterTcOffsetDiv2(0);
   }
 
   // deblockingFilterControlPresentFlag is true if any of the settings differ from the inferred values:
-  const Bool deblockingFilterControlPresentFlag = m_cPPS.getDeblockingFilterOverrideEnabledFlag() ||
-                                                  m_cPPS.getPicDisableDeblockingFilterFlag()      ||
-                                                  m_cPPS.getDeblockingFilterBetaOffsetDiv2() != 0 ||
-                                                  m_cPPS.getDeblockingFilterTcOffsetDiv2() != 0;
-
-  m_cPPS.setDeblockingFilterControlPresentFlag(deblockingFilterControlPresentFlag);
-
-  m_cPPS.setLog2ParallelMergeLevelMinus2   (m_log2ParallelMergeLevelMinus2 );
-  m_cPPS.setCabacInitPresentFlag(CABAC_INIT_PRESENT_FLAG);
-  m_cPPS.setLoopFilterAcrossSlicesEnabledFlag( m_bLFCrossSliceBoundaryFlag );
+  const Bool deblockingFilterControlPresentFlag = pps.getDeblockingFilterOverrideEnabledFlag() ||
+                                                  pps.getPPSDeblockingFilterDisabledFlag()     ||
+                                                  pps.getDeblockingFilterBetaOffsetDiv2() != 0 ||
+                                                  pps.getDeblockingFilterTcOffsetDiv2() != 0;
+
+  pps.setDeblockingFilterControlPresentFlag(deblockingFilterControlPresentFlag);
+
+  pps.setLog2ParallelMergeLevelMinus2   (m_log2ParallelMergeLevelMinus2 );
+  pps.setCabacInitPresentFlag(CABAC_INIT_PRESENT_FLAG);
+  pps.setLoopFilterAcrossSlicesEnabledFlag( m_bLFCrossSliceBoundaryFlag );
 
 
@@ -1233 +1359 @@
   }
   assert(bestPos <= 15);
-  m_cPPS.setNumRefIdxL0DefaultActive(bestPos);
-  m_cPPS.setNumRefIdxL1DefaultActive(bestPos);
-  m_cPPS.setTransquantBypassEnableFlag(getTransquantBypassEnableFlag());
-  m_cPPS.setUseTransformSkip( m_useTransformSkip );
-  m_cPPS.getPpsRangeExtension().setLog2MaxTransformSkipBlockSize( m_log2MaxTransformSkipBlockSize  );
+  pps.setNumRefIdxL0DefaultActive(bestPos);
+  pps.setNumRefIdxL1DefaultActive(bestPos);
+  pps.setTransquantBypassEnabledFlag(getTransquantBypassEnabledFlag());
+  pps.setUseTransformSkip( m_useTransformSkip );
+  pps.getPpsRangeExtension().setLog2MaxTransformSkipBlockSize( m_log2MaxTransformSkipBlockSize  );
 
   if (m_sliceSegmentMode != NO_SLICES)
   {
-    m_cPPS.setDependentSliceSegmentsEnabledFlag( true );
-  }
+    pps.setDependentSliceSegmentsEnabledFlag( true );
+  }
+
+  xInitPPSforTiles(pps);
 }
 
 //Function for initializing m_RPSList, a list of TComReferencePictureSet, based on the GOPEntry objects read from the config file.
-Void TEncTop::xInitRPS(Bool isFieldCoding)
+Void TEncTop::xInitRPS(TComSPS &sps, Bool isFieldCoding)
 {
   TComReferencePictureSet*      rps;
 
-  m_cSPS.createRPSList(getGOPSize() + m_extraRPSs + 1);
-  TComRPSList* rpsList = m_cSPS.getRPSList();
+  sps.createRPSList(getGOPSize() + m_extraRPSs + 1);
+  TComRPSList* rpsList = sps.getRPSList();
 
   for( Int i = 0; i < getGOPSize()+m_extraRPSs; i++)
   {
-    GOPEntry ge = getGOPEntry(i);
+    const GOPEntry &ge = getGOPEntry(i);
     rps = rpsList->getReferencePictureSet(i);
     rps->setNumberOfPictures(ge.m_numRefPics);
@@ -1480 +1608 @@
 }
 
-Void  TEncTop::xInitPPSforTiles()
-{
-  m_cPPS.setTileUniformSpacingFlag( m_tileUniformSpacingFlag );
-  m_cPPS.setNumTileColumnsMinus1( m_iNumColumnsMinus1 );
-  m_cPPS.setNumTileRowsMinus1( m_iNumRowsMinus1 );
+Void  TEncTop::xInitPPSforTiles(TComPPS &pps) 
+#if NH_MV
+  const
+#endif
+{
+  pps.setTileUniformSpacingFlag( m_tileUniformSpacingFlag );
+  pps.setNumTileColumnsMinus1( m_iNumColumnsMinus1 );
+  pps.setNumTileRowsMinus1( m_iNumRowsMinus1 );
   if( !m_tileUniformSpacingFlag )
   {
-    m_cPPS.setTileColumnWidth( m_tileColumnWidth );
-    m_cPPS.setTileRowHeight( m_tileRowHeight );
-  }
-  m_cPPS.setLoopFilterAcrossTilesEnabledFlag( m_loopFilterAcrossTilesEnabledFlag );
+    pps.setTileColumnWidth( m_tileColumnWidth );
+    pps.setTileRowHeight( m_tileRowHeight );
+  }
+  pps.setLoopFilterAcrossTilesEnabledFlag( m_loopFilterAcrossTilesEnabledFlag );
 
   // # substreams is "per tile" when tiles are independent.
@@ -1557 +1688 @@
 }
 
+#if JCTVC_Y0038_PARAMS
+#if NH_MV
+Void TEncTop::setParamSetChanged(Int id, Bool isPps )
+{
+  if ( isPps )
+  {
+    m_ppsMap.setChangedFlag(id);
+  }
+  else
+  {
+    m_spsMap.setChangedFlag(id);
+  }
+}
+#else
+
+Void TEncTop::setParamSetChanged(Int spsId, Int ppsId)
+{
+  m_ppsMap.setChangedFlag(ppsId);
+  m_spsMap.setChangedFlag(spsId);
+}
+#endif
+#endif
+
+Bool TEncTop::PPSNeedsWriting(Int ppsId)
+{
+  Bool bChanged=m_ppsMap.getChangedFlag(ppsId);
+  m_ppsMap.clearChangedFlag(ppsId);
+  return bChanged;
+}
+
+Bool TEncTop::SPSNeedsWriting(Int spsId)
+{
+  Bool bChanged=m_spsMap.getChangedFlag(spsId);
+  m_spsMap.clearChangedFlag(spsId);
+  return bChanged;
+}
+
+#if X0038_LAMBDA_FROM_QP_CAPABILITY
+Int TEncCfg::getQPForPicture(const UInt gopIndex, const TComSlice *pSlice) const
+{
+  const Int lumaQpBDOffset = pSlice->getSPS()->getQpBDOffset(CHANNEL_TYPE_LUMA);
+  Int qp;
+
+  if (getCostMode()==COST_LOSSLESS_CODING)
+  {
+    qp=LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP;
+  }
+  else
+  {
+    const SliceType sliceType=pSlice->getSliceType();
+
+    qp = getBaseQP();
+
+#if JVET_G0101_QP_SWITCHING
+    // modify QP if a fractional QP was originally specified, cause dQPs to be 0 or 1.
+    const Int* pdQPs = getdQPs();
+    if ( pdQPs )
+    {
+      qp += pdQPs[ pSlice->getPOC() ];
+    }
+#endif
+
+    if(sliceType==I_SLICE)
+    {
+      qp += getIntraQPOffset();
+    }
+    else
+    {
+      // Only adjust QP when not lossless
+      if (!(( getMaxDeltaQP() == 0 ) && (!getLumaLevelToDeltaQPMapping().isEnabled()) && (qp == -lumaQpBDOffset ) && (pSlice->getPPS()->getTransquantBypassEnabledFlag())))
+      {
+        const GOPEntry &gopEntry=getGOPEntry(gopIndex);
+        // adjust QP according to the QP offset for the GOP entry.
+        qp +=gopEntry.m_QPOffset;
+
+        // adjust QP according to QPOffsetModel for the GOP entry.
+        Double dqpOffset=qp*gopEntry.m_QPOffsetModelScale+gopEntry.m_QPOffsetModelOffset+0.5;
+        Int qpOffset = (Int)floor(Clip3<Double>(0.0, 3.0, dqpOffset));
+        qp += qpOffset ;
+      }
+    }
+
+#if !JVET_G0101_QP_SWITCHING
+    // modify QP if a fractional QP was originally specified, cause dQPs to be 0 or 1.
+    const Int* pdQPs = getdQPs();
+    if ( pdQPs )
+    {
+      qp += pdQPs[ pSlice->getPOC() ];
+    }
+#endif
+  }
+  qp = Clip3( -lumaQpBDOffset, MAX_QP, qp );
+  return qp;
+}
+#endif
+
+
 #if NH_MV
 Int TEncTop::getFrameId(Int iGOPid)  
@@ -1583 +1811 @@
   }
   return pcPic;
+}
+
+
+Int TEncTop::xGetPsIdAndPsLayerId( )
+{
+  // LayerId of the parameter set and the Parameter set id are always equal in HTM
+  return ( m_sendParameterSets ?  ( getLayerId() == 0 ?  0 : 1 )  : getLayerId() );
 }
 
@@ -1700 +1935 @@
   }
 }
-#endif
+
+
+#endif
+
 
 //! \}