Changeset 1317 in 3DVCSoftware for branches/HTM-15.0-dev0/source/Lib/TLibDecoder/TDecTop.cpp

Timestamp:

4 Sep 2015, 21:28:58 (9 years ago)

Author:

tech

Message:

Clean-ups. HLS.

File:

• branches/HTM-15.0-dev0/source/Lib/TLibDecoder/TDecTop.cpp (modified) (46 diffs)

branches/HTM-15.0-dev0/source/Lib/TLibDecoder/TDecTop.cpp

@@ -35 +35 @@
     \brief    decoder class
 */
-
 #include "NALread.h"
 #include "TDecTop.h"
@@ -127 +126 @@
   }
 }
-
-
-
 
 Void
@@ -290 +286 @@
 }
 
-
-#if !NH_3D_FIX_TICKET_101
-#if NH_3D_IV_MERGE
-Void
-CamParsCollector::copyCamParamForSlice( TComSlice* pcSlice )
-{
-  if( m_bCamParsVaryOverTime )
-  {
-    pcSlice->setCamparaSlice( m_aaiCodedScale, m_aaiCodedOffset );
-  }
-}
-#endif
-#endif
-
-
 Void
 CamParsCollector::xOutput( Int iPOC )
@@ -351 +332 @@
 TDecTop::TDecTop()
   : m_iMaxRefPicNum(0)
+#if !NH_MV
   , m_associatedIRAPType(NAL_UNIT_INVALID)
-  , m_pocCRA(0)
+  , m_pocCRA(0)  
   , m_pocRandomAccess(MAX_INT)
   , m_cListPic()
-#if !NH_MV
   , m_parameterSetManager()
 #endif
@@ -373 +354 @@
   , m_cSAO()
   , m_pcPic(NULL)
+#if !NH_MV
   , m_prevPOC(MAX_INT)
   , m_prevTid0POC(0)
@@ -383 +365 @@
   , m_isNoOutputPriorPics(false)
   , m_craNoRaslOutputFlag(false)
+#endif
 #if O0043_BEST_EFFORT_DECODING
   , m_forceDecodeBitDepth(8)
 #endif
   , m_pDecodedSEIOutputStream(NULL)
+#if !NH_MV
   , m_warningMessageSkipPicture(false)
+#endif
   , m_prefixSEINALUs()
+{
+#if !NH_MV
+#if ENC_DEC_TRACE
+  if (g_hTrace == NULL)
+  {
+    g_hTrace = fopen( "TraceDec.txt", "wb" );
+  }
+  g_bJustDoIt = g_bEncDecTraceDisable;
+  g_nSymbolCounter = 0;
+#endif
+#endif
+
+#if NH_MV
+  m_layerId                       = 0;
+  m_viewId                        = 0;
+
+#if NH_3D
+  m_viewIndex                     = 0;
+  m_isDepth                       = false;
+  m_pcCamParsCollector            = 0;
+#endif
+
+  m_decodingProcess               = CLAUSE_8;
+  m_targetOlsIdx                  = -1;
+  m_smallestLayerId               = -1;
+  m_isInOwnTargetDecLayerIdList   = 0;
+  m_prevPicOrderCnt               = 0;
+  m_pocDecrementedInDpbFlag       = NULL;
+  m_firstPicInLayerDecodedFlag    = NULL;
+  m_lastPresentPocResetIdc        = NULL;
+
+  m_prevIrapPoc                   = MIN_INT;
+  m_prevIrapDecodingOrder         = MIN_INT;
+  m_prevStsaDecOrder              = MIN_INT;
+  m_prevStsaTemporalId            = MIN_INT;
+#endif
+}
+
+TDecTop::~TDecTop()
 {
 #if ENC_DEC_TRACE
 #if NH_MV
-  if ( g_hTrace == NULL )
-  {
-#endif
-  if (g_hTrace == NULL)
-  {
-    g_hTrace = fopen( "TraceDec.txt", "wb" );
-  }
-  g_bJustDoIt = g_bEncDecTraceDisable;
-  g_nSymbolCounter = 0;
-#if NH_MV
-  }
-#endif
-#endif
-#if NH_MV
-  m_isLastNALWasEos = false;
-  m_layerId = 0;
-  m_viewId = 0;
-#if NH_3D
-  m_viewIndex = 0; 
-  m_isDepth = false;
-  m_pcCamParsCollector = 0;
-#endif
-#if NH_MV
-  m_targetOlsIdx = -1; 
-#endif
-#endif
-
-}
-
-TDecTop::~TDecTop()
-{
-#if ENC_DEC_TRACE
-#if H_MV_ENC_DEC_TRAC_FIX
   if (g_hTrace != stdout && g_hTrace != NULL)
+  {
+    fclose( g_hTrace );
+    g_hTrace = NULL;
+  }
 #else
   if (g_hTrace != stdout)
-#endif
   {
     fclose( g_hTrace );
-#if H_MV_ENC_DEC_TRAC_FIX
-    g_hTrace = NULL;
-#endif
-  }
+  }
+#endif  
 #endif
   while (!m_prefixSEINALUs.empty())
@@ -452 +444 @@
 Void TDecTop::destroy()
 {
+
+#if NH_MV
+  m_cSAO.destroy();
+  m_cLoopFilter.        destroy();
+#endif
+
   m_cGopDecoder.destroy();
 
@@ -474 +472 @@
 }
 
+#if !NH_MV
 Void TDecTop::deletePicBuffer ( )
 {
+
   TComList<TComPic*>::iterator  iterPic   = m_cListPic.begin();
   Int iSize = Int( m_cListPic.size() );
@@ -482 +482 @@
   {
     TComPic* pcPic = *(iterPic++);
-#if NH_MV
-    if( pcPic )
-    {
-#endif
     pcPic->destroy();
 
     delete pcPic;
     pcPic = NULL;
-#if NH_MV
-    }
-#endif
   }
 
@@ -499 +492 @@
   m_cLoopFilter.        destroy();
 
-#if !NH_MV
   // destroy ROM
   destroyROM();
-#endif
 }
 
 Void TDecTop::xGetNewPicBuffer ( const TComSPS &sps, const TComPPS &pps, TComPic*& rpcPic, const UInt temporalLayer )
 {
-#if NH_MV
-  if ( getLayerId() == 0 )
-  {  
-    m_iMaxRefPicNum = sps.getMaxDecPicBuffering(temporalLayer);     // m_uiMaxDecPicBuffering has the space for the picture currently being decoded
-  }
-  else
-  {
-    //GTCIC
-    //m_iMaxRefPicNum = pcSlice->getVPS()->getMaxDecPicBuffering(pcSlice->getTLayer());    
-#if H_MV_HLS7_GEN 
-    TComVPS* vps         = pcSlice->getVPS();
-    TComDpbSize* dpbSize = vps->getDpbSize(); 
-    Int lsIdx            = vps->olsIdxToLsIdx( getTargetOutputLayerSetIdx()); // Is this correct, seems to be missing in spec?
-    Int layerIdx         = vps->getIdxInLayerSet     ( lsIdx, getLayerId() ); 
-    Int subDpbIdx        = dpbSize->getSubDpbAssigned( lsIdx, layerIdx ); 
-    m_iMaxRefPicNum      = dpbSize->getMaxVpsDecPicBufferingMinus1(getTargetOutputLayerSetIdx(), subDpbIdx , vps->getSubLayersVpsMaxMinus1( vps->getLayerIdInVps( getLayerId() ) ) + 1 ) + 1 ;  
-#endif    
-  }
-#else
   m_iMaxRefPicNum = sps.getMaxDecPicBuffering(temporalLayer);     // m_uiMaxDecPicBuffering has the space for the picture currently being decoded
-#endif
   if (m_cListPic.size() < (UInt)m_iMaxRefPicNum)
   {
@@ -547 +518 @@
     {
       rpcPic->setOutputMark(false);
-#if NH_MV
-      rpcPic->setPicOutputFlag(false); 
-#endif
       bBufferIsAvailable = true;
       break;
@@ -557 +525 @@
     {
       rpcPic->setOutputMark(false);
-#if NH_MV
-      rpcPic->setPicOutputFlag(false); 
-#endif
       rpcPic->setReconMark( false );
       rpcPic->getPicYuvRec()->setBorderExtension( false );
@@ -577 +542 @@
   rpcPic->create ( sps, pps, true);
 }
-#if NH_MV
-Void TDecTop::endPicDecoding(Int& poc, TComList<TComPic*>*& rpcListPic, std::vector<Int>& targetDecLayerIdSet )
-#else
+
 Void TDecTop::executeLoopFilters(Int& poc, TComList<TComPic*>*& rpcListPic)
-#endif
 {
   if (!m_pcPic)
@@ -599 +561 @@
   rpcListPic          = &m_cListPic;
   m_cCuDecoder.destroy();
-#if NH_MV 
-  TComSlice::markIvRefPicsAsShortTerm( m_refPicSetInterLayer0, m_refPicSetInterLayer1 );  
-  TComSlice::markCurrPic( pcPic ); 
-#endif
   m_bFirstSliceInPicture  = true;
-
   return;
 }
@@ -623 +580 @@
     {
       pcPicTmp->setOutputMark(false);
-#if NH_MV
-      pcPicTmp->setPicOutputFlag(false); 
-#endif
     }
   }
@@ -673 +627 @@
   }
 }
-
-
+#endif
+
+
+#if NH_MV
+Void TDecTop::activatePSsAndInitPicOrSlice( TComPic* newPic )
+{
+  if ( m_apcSlicePilot->getFirstSliceSegementInPicFlag() )
+  {
+    assert( newPic != NULL );
+
+#else
 Void TDecTop::xActivateParameterSets()
 {
   if (m_bFirstSliceInPicture)
   {
+#endif
     const TComPPS *pps = m_parameterSetManager.getPPS(m_apcSlicePilot->getPPSId()); // this is a temporary PPS object. Do not store this value
     assert (pps != 0);
@@ -690 +654 @@
     const TComVPS* vps = m_parameterSetManager.getVPS(sps->getVPSId());
     assert (vps != 0); 
-    if (!m_parameterSetManager.activatePPS(m_apcSlicePilot->getPPSId(),m_apcSlicePilot->isIRAP(), m_layerId ) )
+    // TBD: check the condition on m_firstPicInLayerDecodedFlag 
+    if (!m_parameterSetManager.activatePPS(m_apcSlicePilot->getPPSId(),m_apcSlicePilot->isIRAP() || !m_firstPicInLayerDecodedFlag[m_layerId] , m_layerId ) )
 #else
     if (false == m_parameterSetManager.activatePPS(m_apcSlicePilot->getPPSId(),m_apcSlicePilot->isIRAP()))
@@ -700 +665 @@
 
 #if NH_MV
-  // When the value of vps_num_rep_formats_minus1 in the active VPS is equal to 0
-  if ( vps->getVpsNumRepFormatsMinus1() == 0 )
-  {
-    //, it is a requirement of bitstream conformance that the value of update_rep_format_flag shall be equal to 0.
-    assert( sps->getUpdateRepFormatFlag() == false ); 
-  }
-  sps->checkRpsMaxNumPics( vps, getLayerId() ); 
-
-  // 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 ); 
-  }
+    if ( decProcAnnexG() )
+    {
+      // When the value of vps_num_rep_formats_minus1 in the active VPS is equal to 0
+      if ( vps->getVpsNumRepFormatsMinus1() == 0 )
+      {
+        //, it is a requirement of bitstream conformance that the value of update_rep_format_flag shall be equal to 0.
+        assert( sps->getUpdateRepFormatFlag() == false ); 
+      }
+      sps->checkRpsMaxNumPics( vps, getLayerId() ); 
+
+      // 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
 
@@ -734 +702 @@
 
     //  Get a new picture buffer. This will also set up m_pcPic, and therefore give us a SPS and PPS pointer that we can use.
+#if !NH_MV
     xGetNewPicBuffer (*(sps), *(pps), m_pcPic, m_apcSlicePilot->getTLayer());
+
     m_apcSlicePilot->applyReferencePictureSet(m_cListPic, m_apcSlicePilot->getRPS());
-#if NH_MV
-    m_apcSlicePilot->createInterLayerReferencePictureSet( m_ivPicLists, m_refPicSetInterLayer0, m_refPicSetInterLayer1 ); 
+#else
+    m_pcPic = newPic; 
 #endif
 
@@ -752 +722 @@
 
 #if NH_MV
+    pSlice->setPic( m_pcPic );
     vps=pSlice->getVPS();  
     // 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.
@@ -803 +774 @@
   else
   {
+#if NH_MV
+    assert( m_pcPic != NULL ); 
+    assert( newPic  == NULL ); 
+#endif
     // make the slice-pilot a real slice, and set up the slice-pilot for the next slice
     m_pcPic->allocateNewSlice();
@@ -828 +803 @@
 
     // Check if any new SEI has arrived
-     if(!m_SEIs.empty())
-     {
-       // Currently only decoding Unit SEI message occurring between VCL NALUs copied
-       SEIMessages &picSEI = m_pcPic->getSEIs();
-       SEIMessages decodingUnitInfos = extractSeisByType (m_SEIs, SEI::DECODING_UNIT_INFO);
-       picSEI.insert(picSEI.end(), decodingUnitInfos.begin(), decodingUnitInfos.end());
-       deleteSEIs(m_SEIs);
-     }
-  }
-}
+    if(!m_SEIs.empty())
+    {
+      // Currently only decoding Unit SEI message occurring between VCL NALUs copied
+      SEIMessages &picSEI = m_pcPic->getSEIs();
+      SEIMessages decodingUnitInfos = extractSeisByType (m_SEIs, SEI::DECODING_UNIT_INFO);
+      picSEI.insert(picSEI.end(), decodingUnitInfos.begin(), decodingUnitInfos.end());
+      deleteSEIs(m_SEIs);
+    }
+  }
+}
+
 Void TDecTop::xParsePrefixSEIsForUnknownVCLNal()
 {
@@ -865 +841 @@
 }
 
-
-#if NH_MV
-Bool TDecTop::xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay, Bool newLayerFlag, Bool& sliceSkippedFlag  )
-{
-  assert( nalu.m_nuhLayerId == m_layerId ); 
+#if !NH_MV
+Bool TDecTop::xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay )
+{
+  m_apcSlicePilot->initSlice(); // the slice pilot is an object to prepare for a new slice
+  // it is not associated with picture, sps or pps structures.
+  if (m_bFirstSliceInPicture)
+  {
 #else
-Bool TDecTop::xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay )
-{
-#endif
+Void TDecTop::decodeSliceHeader(InputNALUnit &nalu )
+{
+  // Initialize entropy decoder
+  m_cEntropyDecoder.setEntropyDecoder (&m_cCavlcDecoder);
+  m_cEntropyDecoder.setBitstream      (&(nalu.getBitstream()));
+
+  assert( nalu.m_nuhLayerId == m_layerId );   
   m_apcSlicePilot->initSlice(); // the slice pilot is an object to prepare for a new slice
-                                // it is not associated with picture, sps or pps structures.
-
-  if (m_bFirstSliceInPicture)
-  {
+  // it is not associated with picture, sps or pps structures.
+  m_apcSlicePilot->setLayerId( nalu.m_nuhLayerId ); 
+  m_cEntropyDecoder.decodeFirstSliceSegmentInPicFlag( m_apcSlicePilot );   
+  if ( m_apcSlicePilot->getFirstSliceSegementInPicFlag() )
+  {
+#endif  
     m_uiSliceIdx = 0;
   }
@@ -889 +873 @@
   m_apcSlicePilot->setNalUnitType(nalu.m_nalUnitType);
   Bool nonReferenceFlag = (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TRAIL_N ||
-                           m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N   ||
-                           m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_STSA_N  ||
-                           m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N  ||
-                           m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N);
+    m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N   ||
+    m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_STSA_N  ||
+    m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N  ||
+    m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N);
   m_apcSlicePilot->setTemporalLayerNonReferenceFlag(nonReferenceFlag);
+#if !NH_MV
   m_apcSlicePilot->setReferenced(true); // Putting this as true ensures that picture is referenced the first time it is in an RPS
+#endif
   m_apcSlicePilot->setTLayerInfo(nalu.m_temporalId);
-
+#if NH_MV
+  m_cEntropyDecoder.decodeSliceHeader (m_apcSlicePilot, &m_parameterSetManager );
+#else
 #if ENC_DEC_TRACE
   const UInt64 originalSymbolCount = g_nSymbolCounter;
 #endif
+    m_cEntropyDecoder.decodeSliceHeader (m_apcSlicePilot, &m_parameterSetManager, m_prevTid0POC);
+#endif
 
 #if NH_MV
-  m_apcSlicePilot->setRefPicSetInterLayer( & m_refPicSetInterLayer0, &m_refPicSetInterLayer1 ); 
-  m_apcSlicePilot->setLayerId( nalu.m_nuhLayerId );
-#endif
-
-  m_cEntropyDecoder.decodeSliceHeader (m_apcSlicePilot, &m_parameterSetManager, m_prevTid0POC);
-
+}
+#else
   // set POC for dependent slices in skipped pictures
   if(m_apcSlicePilot->getDependentSliceSegmentFlag() && m_prevSliceSkipped)
@@ -915 +901 @@
 
   xUpdatePreviousTid0POC(m_apcSlicePilot);
-
   m_apcSlicePilot->setAssociatedIRAPPOC(m_pocCRA);
   m_apcSlicePilot->setAssociatedIRAPType(m_associatedIRAPType);
-#if NH_MV  
-  const TComVPS* vps     = m_apcSlicePilot->getVPS();
-  Int layerId            = nalu.m_nuhLayerId;   
-  setViewId   ( vps->getViewId   ( layerId )      );  
-#if NH_3D
-  setViewIndex( vps->getViewIndex( layerId )      );  
-  setIsDepth  ( vps->getDepthId  ( layerId ) == 1 );  
-  m_ivPicLists->setVPS( vps ); 
-#endif
-#endif
+
 
   //For inference of NoOutputOfPriorPicsFlag
   if (m_apcSlicePilot->getRapPicFlag())
   {
-    if ((m_apcSlicePilot->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && m_apcSlicePilot->getNalUnitType() <= NAL_UNIT_CODED_SLICE_IDR_N_LP) || 
+      if ((m_apcSlicePilot->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && m_apcSlicePilot->getNalUnitType() <= NAL_UNIT_CODED_SLICE_IDR_N_LP) || 
         (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA && m_bFirstSliceInSequence) ||
         (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA && m_apcSlicePilot->getHandleCraAsBlaFlag()))
-    {
-      m_apcSlicePilot->setNoRaslOutputFlag(true);
-    }
+      {
+        m_apcSlicePilot->setNoRaslOutputFlag(true);
+      }
     //the inference for NoOutputPriorPicsFlag
     if (!m_bFirstSliceInBitstream && m_apcSlicePilot->getRapPicFlag() && m_apcSlicePilot->getNoRaslOutputFlag())
@@ -948 +924 @@
     else
     {
-      m_apcSlicePilot->setNoOutputPriorPicsFlag(false);
+      m_apcSlicePilot->setNoOutputPriorPicsFlag(false); 
     }
 
@@ -974 +950 @@
     }
   }
-
+  
   if (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA && m_craNoRaslOutputFlag) //Reset POC MSB when CRA has NoRaslOutputFlag equal to 1
   {
@@ -985 +961 @@
     xUpdatePreviousTid0POC(m_apcSlicePilot);
   }
-#if NH_MV
-    xCeckNoClrasOutput();
-#endif
 
   // Skip pictures due to random access
-
-#if NH_MV
-  if (isRandomAccessSkipPicture(iSkipFrame, iPOCLastDisplay, vps))
-#else
   if (isRandomAccessSkipPicture(iSkipFrame, iPOCLastDisplay))
-#endif
   {
     m_prevSliceSkipped = true;
     m_skippedPOC = m_apcSlicePilot->getPOC();
-#if NH_MV
-    sliceSkippedFlag = true; 
-#endif
     return false;
   }
@@ -1009 +974 @@
     m_prevSliceSkipped = true;
     m_skippedPOC = m_apcSlicePilot->getPOC();
-#if NH_MV
-    sliceSkippedFlag = true; 
-#endif
     return false;
   }
@@ -1030 +992 @@
     {
       m_prevPOC = m_apcSlicePilot->getPOC();
+
 #if ENC_DEC_TRACE
       //rewind the trace counter since we didn't actually decode the slice
@@ -1038 +1001 @@
     m_prevPOC = m_apcSlicePilot->getPOC();
   }
-#if NH_MV
-  if ( newLayerFlag )
-  {
-    return false; 
-  }
-#if ENC_DEC_TRACE
-#if H_MV_ENC_DEC_TRAC
-  // parse remainder of SH
-   g_disableHLSTrace = false; 
-#endif
-#endif
-#endif
-
-#if NH_MV
-   // This part needs further testing !
-   if ( m_apcSlicePilot->getPocResetFlag() )
-   {   
-     xResetPocInPicBuffer();
-   }
-
-   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
 
   //detect lost reference picture and insert copy of earlier frame.
@@ -1093 +1015 @@
     m_prevPOC = m_apcSlicePilot->getPOC();
   }
-
   // actual decoding starts here
   xActivateParameterSets();
@@ -1103 +1024 @@
   TComSlice* pcSlice = m_pcPic->getPicSym()->getSlice(m_uiSliceIdx);
 
-  // When decoding the slice header, the stored start and end addresses were actually RS addresses, not TS addresses.
-  // Now, having set up the maps, convert them to the correct form.
-  pcSlice->setSliceSegmentCurStartCtuTsAddr( m_pcPic->getPicSym()->getCtuRsToTsAddrMap(pcSlice->getSliceSegmentCurStartCtuTsAddr()) );
-  pcSlice->setSliceSegmentCurEndCtuTsAddr( m_pcPic->getPicSym()->getCtuRsToTsAddrMap(pcSlice->getSliceSegmentCurEndCtuTsAddr()) );
-  if(!pcSlice->getDependentSliceSegmentFlag())
-  {
-    pcSlice->setSliceCurStartCtuTsAddr(m_pcPic->getPicSym()->getCtuRsToTsAddrMap(pcSlice->getSliceCurStartCtuTsAddr()));
-    pcSlice->setSliceCurEndCtuTsAddr(m_pcPic->getPicSym()->getCtuRsToTsAddrMap(pcSlice->getSliceCurEndCtuTsAddr()));
-  }
-
-  m_pcPic->setTLayer(nalu.m_temporalId);
+#endif
 
 #if NH_MV
-  //Check Multiview Main profile constraint in G.11.1.1
-  //  When ViewOrderIdx[ i ] derived according to any active VPS is equal to 1 
-  //  for the layer with nuh_layer_id equal to i in subBitstream, 
-  //  inter_view_mv_vert_constraint_flag shall be equal to 1 
-  //  in the sps_multilayer_extension( ) syntax structure in each active SPS for that layer.
-  if( pcSlice->getSPS()->getPTL()->getGeneralPTL()->getProfileIdc()==Profile::MULTIVIEWMAIN
+Void TDecTop::decodeSliceSegment(InputNALUnit &nalu )
+{
+  TComSlice* pcSlice = m_pcPic->getPicSym()->getSlice(m_uiSliceIdx);
+
+  if ( m_pcPic->getHasGeneratedRefPics() )
+  {
+    if ( pcSlice->getFirstSliceSegementInPicFlag() )
+    {
+      std::cout << std:: setfill(' ')
+        << "Layer "  << std::setw(2) << m_pcPic->getLayerId()
+        << "   POC " << std::setw(4) << m_pcPic->getPOC()
+        << " Reference pictures missing. Skipping picture." << std::endl;
+    }
+  }
+  else
+  {
+    //Check Multiview Main profile constraint in G.11.1.1
+    //  When ViewOrderIdx[ i ] derived according to any active VPS is equal to 1 
+    //  for the layer with nuh_layer_id equal to i in subBitstream, 
+    //  inter_view_mv_vert_constraint_flag shall be equal to 1 
+    //  in the sps_multilayer_extension( ) syntax structure in each active SPS for that layer.
+    if( pcSlice->getSPS()->getPTL()->getGeneralPTL()->getProfileIdc()==Profile::MULTIVIEWMAIN
       &&
       pcSlice->getVPS()->getViewOrderIdx(pcSlice->getVPS()->getLayerIdInNuh(getLayerId()))==1 
-     )
-  {
-    assert( pcSlice->getSPS()->getInterViewMvVertConstraintFlag()==1 );
-  }
-#endif
-#if NH_MV
-  m_pcPic->setLayerId( nalu.m_nuhLayerId );
-  m_pcPic->setViewId ( getViewId() );
+      )
+    {
+      assert( pcSlice->getSPS()->getInterViewMvVertConstraintFlag()==1 );
+    }
+
+    m_pcPic->setLayerId( nalu.m_nuhLayerId );
+    m_pcPic->setViewId ( getViewId() );
 #if NH_3D
-  m_pcPic->setViewIndex( getViewIndex() );
-  m_pcPic->setIsDepth  ( getIsDepth  () );
-  pcSlice->setIvPicLists( m_ivPicLists );         
-#endif
-#endif
-
-  if (!pcSlice->getDependentSliceSegmentFlag())
-  {
-    pcSlice->checkCRA(pcSlice->getRPS(), m_pocCRA, m_associatedIRAPType, m_cListPic );
-    // Set reference list
-#if NH_MV    
-    std::vector< TComPic* > tempRefPicLists[2];
-    std::vector< Bool     > usedAsLongTerm [2];
-    Int       numPocTotalCurr;
-
-    pcSlice->getTempRefPicLists( m_cListPic, m_refPicSetInterLayer0, m_refPicSetInterLayer1, tempRefPicLists, usedAsLongTerm, numPocTotalCurr);
-    pcSlice->setRefPicList     ( tempRefPicLists, usedAsLongTerm, numPocTotalCurr, true ); 
+    m_pcPic->setViewIndex( getViewIndex() );
+    m_pcPic->setIsDepth  ( getIsDepth  () );
+    pcSlice->setIvPicLists( m_dpb );         
+#endif
+#endif
+    
+    // When decoding the slice header, the stored start and end addresses were actually RS addresses, not TS addresses.
+    // Now, having set up the maps, convert them to the correct form.
+    pcSlice->setSliceSegmentCurStartCtuTsAddr( m_pcPic->getPicSym()->getCtuRsToTsAddrMap(pcSlice->getSliceSegmentCurStartCtuTsAddr()) );
+    pcSlice->setSliceSegmentCurEndCtuTsAddr( m_pcPic->getPicSym()->getCtuRsToTsAddrMap(pcSlice->getSliceSegmentCurEndCtuTsAddr()) );
+    if(!pcSlice->getDependentSliceSegmentFlag())
+    {
+      pcSlice->setSliceCurStartCtuTsAddr(m_pcPic->getPicSym()->getCtuRsToTsAddrMap(pcSlice->getSliceCurStartCtuTsAddr()));
+      pcSlice->setSliceCurEndCtuTsAddr(m_pcPic->getPicSym()->getCtuRsToTsAddrMap(pcSlice->getSliceCurEndCtuTsAddr()));
+    }
+
+    m_pcPic->setTLayer(nalu.m_temporalId);
+
+
+    if (!pcSlice->getDependentSliceSegmentFlag())
+    {
+#if !NH_MV
+      pcSlice->checkCRA(pcSlice->getRPS(), m_pocCRA, m_associatedIRAPType, m_cListPic );
+      // Set reference list
+      pcSlice->setRefPicList( m_cListPic, true );
+#else
+      if (pcSlice->getSliceType() != I_SLICE )
+      {
+        if( m_decProcPocAndRps == ANNEX_F )
+        {
+          pcSlice->f834decProcForRefPicListConst();
+        }
+        else if ( m_decProcPocAndRps == CLAUSE_8 )
+        {
+          pcSlice->cl834DecProcForRefPicListConst();
+        }
+        else
+        {
+          assert( false ); 
+        }
+      }
 #if NH_3D_NBDV
-    pcSlice->setDefaultRefView();
+      pcSlice->setDefaultRefView();
 #endif
 #if NH_3D_ARP
-    pcSlice->setARPStepNum(m_ivPicLists);
-#endif
-#else
-    pcSlice->setRefPicList( m_cListPic, true );
-#endif
-
-#if NH_3D
-    pcSlice->checkInCompPredRefLayers(); 
-#if NH_3D_IV_MERGE
-#if H_3D_FCO
-    //assert( !getIsDepth() );
-#else
-    assert( !getIsDepth() || ( pcSlice->getTexturePic() != 0 ) );
-#endif
-#endif    
-#endif
-#if NH_MV
-    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)
-    {
-      Int iNumRefIdx = pcSlice->getNumRefIdx(REF_PIC_LIST_0);
-      pcSlice->setNumRefIdx        ( REF_PIC_LIST_1, iNumRefIdx );
-
-      for (Int iRefIdx = 0; iRefIdx < iNumRefIdx; iRefIdx++)
-      {
-        pcSlice->setRefPic(pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx), REF_PIC_LIST_1, iRefIdx);
-      }
-    }
-    if (!pcSlice->isIntra())
-    {
-      Bool bLowDelay = true;
-      Int  iCurrPOC  = pcSlice->getPOC();
-      Int iRefIdx = 0;
-
-      for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_0) && bLowDelay; iRefIdx++)
-      {
-        if ( pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx)->getPOC() > iCurrPOC )
+      pcSlice->setPocsInCurrRPSs(); 
+      pcSlice->setARPStepNum(m_dpb);
+#endif     
+#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)
+      {
+        Int iNumRefIdx = pcSlice->getNumRefIdx(REF_PIC_LIST_0);
+        pcSlice->setNumRefIdx        ( REF_PIC_LIST_1, iNumRefIdx );
+
+        for (Int iRefIdx = 0; iRefIdx < iNumRefIdx; iRefIdx++)
         {
-          bLowDelay = false;
+          pcSlice->setRefPic(pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx), REF_PIC_LIST_1, iRefIdx);
         }
       }
-      if (pcSlice->isInterB())
-      {
-        for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_1) && bLowDelay; iRefIdx++)
+      if (!pcSlice->isIntra())
+      {
+        Bool bLowDelay = true;
+        Int  iCurrPOC  = pcSlice->getPOC();
+        Int iRefIdx = 0;
+
+        for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_0) && bLowDelay; iRefIdx++)
         {
-          if ( pcSlice->getRefPic(REF_PIC_LIST_1, iRefIdx)->getPOC() > iCurrPOC )
+          if ( pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx)->getPOC() > iCurrPOC )
           {
             bLowDelay = false;
           }
         }
-      }
-
-      pcSlice->setCheckLDC(bLowDelay);
-    }
-
-    //---------------
-    pcSlice->setRefPOCList();
+        if (pcSlice->isInterB())
+        {
+          for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_1) && bLowDelay; iRefIdx++)
+          {
+            if ( pcSlice->getRefPic(REF_PIC_LIST_1, iRefIdx)->getPOC() > iCurrPOC )
+            {
+              bLowDelay = false;
+            }
+          }
+        }
+
+        pcSlice->setCheckLDC(bLowDelay);
+      }
+
+      //---------------
+      pcSlice->setRefPOCList();
 #if  NH_3D_TMVP
-    if(pcSlice->getLayerId())
-    {
-      pcSlice->generateAlterRefforTMVP();
-    }
-#endif
-  }
-
-  m_pcPic->setCurrSliceIdx(m_uiSliceIdx);
-  if(pcSlice->getSPS()->getScalingListFlag())
-  {
-    TComScalingList scalingList;
-    if(pcSlice->getPPS()->getScalingListPresentFlag())
-    {
-      scalingList = pcSlice->getPPS()->getScalingList();
-    }
-    else if (pcSlice->getSPS()->getScalingListPresentFlag())
-    {
-      scalingList = pcSlice->getSPS()->getScalingList();
+      if(pcSlice->getLayerId())
+      {
+        pcSlice->generateAlterRefforTMVP();
+      }
+#endif
+    }
+
+    m_pcPic->setCurrSliceIdx(m_uiSliceIdx);
+    if(pcSlice->getSPS()->getScalingListFlag())
+    {
+      TComScalingList scalingList;
+      if(pcSlice->getPPS()->getScalingListPresentFlag())
+      {
+        scalingList = pcSlice->getPPS()->getScalingList();
+      }
+      else if (pcSlice->getSPS()->getScalingListPresentFlag())
+      {
+        scalingList = pcSlice->getSPS()->getScalingList();
+      }
+      else
+      {
+        scalingList.setDefaultScalingList();
+      }
+      m_cTrQuant.setScalingListDec(scalingList);
+      m_cTrQuant.setUseScalingList(true);
     }
     else
     {
-      scalingList.setDefaultScalingList();
-    }
-    m_cTrQuant.setScalingListDec(scalingList);
-    m_cTrQuant.setUseScalingList(true);
-  }
-  else
-  {
-    const Int maxLog2TrDynamicRange[MAX_NUM_CHANNEL_TYPE] =
-    {
+      const Int maxLog2TrDynamicRange[MAX_NUM_CHANNEL_TYPE] =
+      {
         pcSlice->getSPS()->getMaxLog2TrDynamicRange(CHANNEL_TYPE_LUMA),
         pcSlice->getSPS()->getMaxLog2TrDynamicRange(CHANNEL_TYPE_CHROMA)
-    };
-    m_cTrQuant.setFlatScalingList(maxLog2TrDynamicRange, pcSlice->getSPS()->getBitDepths());
-    m_cTrQuant.setUseScalingList(false);
-  }
-
-#if !NH_3D_FIX_TICKET_101
-#if NH_3D_IV_MERGE
-#if H_3D_FCO
-  if( !pcSlice->getIsDepth() && m_pcCamParsCollector )
+      };
+      m_cTrQuant.setFlatScalingList(maxLog2TrDynamicRange, pcSlice->getSPS()->getBitDepths());
+      m_cTrQuant.setUseScalingList(false);
+    }
+
+#if NH_3D
+    if ( decProcAnnexI() )
+    {
+      pcSlice->checkInCompPredRefLayers(); 
+    }
+#endif
+
+    //  Decode a picture
+    m_cGopDecoder.decompressSlice(&(nalu.getBitstream()), m_pcPic);
+
+#if NH_3D
+    if( m_pcCamParsCollector )
+    {
+      m_pcCamParsCollector->setSlice( pcSlice );
+    }
+#endif
+
+#if !NH_MV
+    m_bFirstSliceInPicture = false;
 #else
-  if( pcSlice->getIsDepth() && m_pcCamParsCollector )
-#endif
-  {
-    m_pcCamParsCollector->copyCamParamForSlice( pcSlice );
-  }
-#endif
-#endif
-  //  Decode a picture
-  m_cGopDecoder.decompressSlice(&(nalu.getBitstream()), m_pcPic);
-
-#if NH_3D
-  if( m_pcCamParsCollector )
-  {
-    m_pcCamParsCollector->setSlice( pcSlice );
-  }
-#endif
-
-  m_bFirstSliceInPicture = false;
+  }
+#endif
   m_uiSliceIdx++;
 
+#if !NH_MV
   return false;
-}
+#endif
+}
+
 
 Void TDecTop::xDecodeVPS(const std::vector<UChar> &naluData)
@@ -1333 +1264 @@
 
 #if NH_MV
-Bool TDecTop::decode(InputNALUnit& nalu, Int& iSkipFrame, Int& iPOCLastDisplay, Bool newLayerFlag, Bool& sliceSkippedFlag )
+Bool TDecTop::decodeNonVclNalu(InputNALUnit& nalu )
 #else
 Bool TDecTop::decode(InputNALUnit& nalu, Int& iSkipFrame, Int& iPOCLastDisplay)
@@ -1354 +1285 @@
     case NAL_UNIT_VPS:
       xDecodeVPS(nalu.getBitstream().getFifo());
-#if NH_MV
-      m_isLastNALWasEos = false;
-#endif
       return false;
 
@@ -1373 +1301 @@
 
     case NAL_UNIT_SUFFIX_SEI:
-#if NH_MV
-      if ( nalu.m_nalUnitType == NAL_UNIT_SUFFIX_SEI )
-      {
-        assert( m_isLastNALWasEos == false );
-      }
-#endif
       if (m_pcPic)
       {
@@ -1410 +1332 @@
     case NAL_UNIT_CODED_SLICE_RASL_R:
 #if NH_MV
-      if (nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_TRAIL_R || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_TRAIL_N ||
-          nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_TSA_R || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_TSA_N ||
-          nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_STSA_R || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_STSA_N ||
-          nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
-          nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N )
-      {
-        assert( m_isLastNALWasEos == false );
-      }
-      else
-      {
-        m_isLastNALWasEos = false;
-      }
-      return xDecodeSlice(nalu, iSkipFrame, iPOCLastDisplay, newLayerFlag, sliceSkippedFlag );
+      assert( false ); 
+      return 1; 
 #else
       return xDecodeSlice(nalu, iSkipFrame, iPOCLastDisplay);
@@ -1429 +1340 @@
 
     case NAL_UNIT_EOS:
-#if NH_MV
-      assert( m_isLastNALWasEos == false );
-      //Check layer id of the nalu. if it is not 0, give a warning message and just return without doing anything.
-      if (nalu.m_nuhLayerId > 0)
-      {
-        printf( "\nThis bitstream has EOS with non-zero layer id.\n" );
-        return false;
-      }
-      m_isLastNALWasEos = true;
-#endif
+#if !NH_MV
       m_associatedIRAPType = NAL_UNIT_INVALID;
       m_pocCRA = 0;
@@ -1445 +1347 @@
       m_prevSliceSkipped = false;
       m_skippedPOC = 0;
+#endif
       return false;
 
@@ -1465 +1368 @@
         fdReader.parseFillerData(&(nalu.getBitstream()),size);
         printf ("Note: found NAL_UNIT_FILLER_DATA with %u bytes payload.\n", size);
-#if NH_MV
-      assert( m_isLastNALWasEos == false );
-#endif
       return false;
       }
@@ -1528 +1428 @@
 }
 
+#if !NH_MV
 /** Function for checking if picture should be skipped because of association with a previous BLA picture
  * \param iPOCLastDisplay POC of last picture displayed
@@ -1558 +1459 @@
  * access point there is no guarantee that the decoder will not crash.
  */
-#if NH_MV
-Bool TDecTop::isRandomAccessSkipPicture(Int& iSkipFrame,  Int& iPOCLastDisplay, const TComVPS* vps)
-#else
 Bool TDecTop::isRandomAccessSkipPicture(Int& iSkipFrame,  Int& iPOCLastDisplay )
-#endif
 {
   if (iSkipFrame)
@@ -1569 +1466 @@
     return true;
   }
-#if NH_MV
-  else if ( !m_layerInitilizedFlag[ m_layerId ] ) // start of random access point, m_pocRandomAccess has not been set yet.
-#else
   else if (m_pocRandomAccess == MAX_INT) // start of random access point, m_pocRandomAccess has not been set yet.
-#endif
   {
     if (   m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA
@@ -1581 +1474 @@
     {
 
-#if NH_MV
-      if ( xAllRefLayersInitilized( vps ) )
-      {
-        m_layerInitilizedFlag[ m_layerId ] = true; 
-        m_pocRandomAccess = m_apcSlicePilot->getPOC();
-      }
-      else
-      {
-        return true; 
-      }
-#else
       // set the POC random access since we need to skip the reordered pictures in the case of CRA/CRANT/BLA/BLANT.
       m_pocRandomAccess = m_apcSlicePilot->getPOC();
-#endif
     }
     else if ( m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP )
     {
-#if NH_MV
-      if ( xAllRefLayersInitilized( vps) )
-      {
-        m_layerInitilizedFlag[ m_layerId ] = true; 
-        m_pocRandomAccess = -MAX_INT; // no need to skip the reordered pictures in IDR, they are decodable.
-      }
-      else 
-      {
-        return true; 
-      }
-#else
       m_pocRandomAccess = -MAX_INT; // no need to skip the reordered pictures in IDR, they are decodable.
-#endif
     }
     else
     {
-#if NH_MV
-      static Bool warningMessage[MAX_NUM_LAYERS];
-      static Bool warningInitFlag = false;
-      
-      if (!warningInitFlag)
-      {
-        for ( Int i = 0; i < MAX_NUM_LAYERS; i++)
-        {
-          warningMessage[i] = true; 
-        }
-        warningInitFlag = true; 
-      }
-
-      if ( warningMessage[getLayerId()] )
-      {
-        printf("\nLayer%3d   No valid random access point. VCL NAL units of this layer are discarded until next layer initialization picture. ", getLayerId() ); 
-        warningMessage[m_layerId] = false; 
-      }
-#else
       if(!m_warningMessageSkipPicture)
       {
@@ -1638 +1488 @@
         m_warningMessageSkipPicture = true;
       }
-#endif
       return true;
     }
@@ -1649 +1498 @@
   }
   // if we reach here, then the picture is not skipped.
-#if NH_MV
-  return !m_layerInitilizedFlag[ getLayerId() ]; 
+  return false;
+}
+
 #else
-  return false;
-#endif
-}
-#if NH_MV
-TComPic* TDecTop::getPic( Int poc )
-{
-  xGetPic( m_layerId, poc ); 
-  TComList<TComPic*>* listPic = getListPic();
-  TComPic* pcPic = NULL;
-  for(TComList<TComPic*>::iterator it=listPic->begin(); it!=listPic->end(); it++)
-  {
-    if( (*it)->getPOC() == poc )
-    {
-      pcPic = *it ;
-      break ;
-    }
-  }
-  return pcPic;
-}
-
-TComPic* TDecTop::xGetPic( Int layerId, Int poc )
+
+Int TDecTop::preDecodePoc( Bool firstPicInLayerDecodedFlag, Bool isFstPicOfAllLayOfPocResetPer, Bool isPocResettingPicture )
+{
+  //Output of this process is PicOrderCntVal, the picture order count of the current picture.
+  //  Picture order counts are used to identify pictures, for deriving motion parameters in merge mode and 
+  //  motion vector prediction and for decoder conformance checking (see clause F.13.5).
+
+  //  Each coded picture is associated with a picture order count variable, denoted as PicOrderCntVal.
+
+  TComSlice* slice = m_apcSlicePilot;
+  const Int nuhLayerId   = slice->getLayerId();
+  const TComVPS*   vps   = slice->getVPS(); 
+  const TComSPS*   sps   = slice->getSPS(); 
+
+  Int pocDecrementedInDpbFlag = m_pocDecrementedInDpbFlag[ nuhLayerId ]; 
+
+  if ( isFstPicOfAllLayOfPocResetPer )
+  {
+    //  When the current picture is the first picture among all layers of a POC resetting period, 
+    //  the variable PocDecrementedInDPBFlag[ i ] is set equal to 0 for each value of i in the range of 0 to 62, inclusive.
+    pocDecrementedInDpbFlag = false; 
+  }
+
+  //  The variable pocResettingFlag is derived as follows:
+  Bool pocResettingFlag; 
+  if ( isPocResettingPicture )
+  {
+    //-  If the current picture is a POC resetting picture, the following applies:    
+    if( vps->getVpsPocLsbAlignedFlag()  )
+    {
+      //  -  If vps_poc_lsb_aligned_flag is equal to 0, pocResettingFlag is set equal to 1.
+      pocResettingFlag = true; 
+    }
+    else if ( pocDecrementedInDpbFlag )
+    {
+      //  -  Otherwise, if PocDecrementedInDPBFlag[ nuh_layer_id ] is equal to 1, pocResettingFlag is set equal to 0.
+      pocResettingFlag = false; 
+    }
+    else
+    {
+      //  -  Otherwise, pocResettingFlag is set equal to 1.
+      pocResettingFlag = true; 
+    }
+  }
+  else
+  {
+    //  -  Otherwise, pocResettingFlag is set equal to 0.
+    pocResettingFlag = false; 
+  }
+
+  Int picOrderCntMsb; 
+  Int picOrderCntVal; 
+
+  //  Depending on pocResettingFlag, the following applies:
+  if ( pocResettingFlag )
+  {
+    //-  The PicOrderCntVal of the current picture is derived as follows:
+    if( slice->getPocResetIdc()  ==  1 )
+    {
+      picOrderCntVal = slice->getSlicePicOrderCntLsb(); 
+    }
+    else if (slice->getPocResetIdc()  ==  2 ) 
+    {
+      picOrderCntVal = 0; 
+    }
+    else
+    {
+      picOrderCntMsb = xGetCurrMsb( slice->getSlicePicOrderCntLsb(), slice->getFullPocResetFlag() ? 0 : slice->getPocLsbVal(), 0, sps->getMaxPicOrderCntLsb() ); 
+      picOrderCntVal = picOrderCntMsb + slice->getSlicePicOrderCntLsb(); 
+    }
+  }
+  else
+  {
+    //-  Otherwise (pocResettingFlag is equal to 0), the following applies:
+    //-  The PicOrderCntVal of the current picture is derived as follows:
+
+    if( slice->getPocMsbCycleValPresentFlag() )
+    {
+      picOrderCntMsb = slice->getPocMsbCycleVal() * sps->getMaxPicOrderCntLsb(); 
+    }
+    else if( !firstPicInLayerDecodedFlag  ||
+      slice->getNalUnitType()  ==  NAL_UNIT_CODED_SLICE_IDR_N_LP || slice->getNalUnitType() ==  NAL_UNIT_CODED_SLICE_IDR_W_RADL )
+    {
+      picOrderCntMsb = 0; //     (F 62)
+    }    
+    else
+    {
+      Int prevPicOrderCntLsb = m_prevPicOrderCnt & ( sps->getMaxPicOrderCntLsb() - 1 );
+      Int prevPicOrderCntMsb = m_prevPicOrderCnt - prevPicOrderCntLsb; 
+      picOrderCntMsb = xGetCurrMsb( slice->getSlicePicOrderCntLsb(), prevPicOrderCntLsb, prevPicOrderCntMsb, sps->getMaxPicOrderCntLsb() ); 
+    }
+    picOrderCntVal = picOrderCntMsb + slice->getSlicePicOrderCntLsb(); 
+  }  
+  return picOrderCntVal;
+}
+
+Void TDecTop::inferPocResetPeriodId()
+{
+  // Infer PocResetPeriodId
+  // When not present, the value of poc_reset_period_id is inferred as follows:
+
+  if ( !m_apcSlicePilot->getHasPocResetPeriodIdPresent() )
+  {
+    if ( m_lastPresentPocResetIdc[ m_apcSlicePilot->getLayerId() ] != MIN_INT )
+    {
+      // - If the previous picture picA that has poc_reset_period_id present in the slice segment header is present in the same layer 
+      //   of the bitstream as the current picture, the value of poc_reset_period_id is inferred to be equal to the value of the 
+      //   poc_reset_period_id of picA.
+
+      m_apcSlicePilot->setPocResetPeriodId( m_lastPresentPocResetIdc[ m_apcSlicePilot->getLayerId() ] ); 
+    }
+    else
+    {
+      //- Otherwise, the value of poc_reset_period_id is inferred to be equal to 0.
+      m_apcSlicePilot->setPocResetPeriodId( 0 ); 
+    }
+  }
+  else
+  {
+    m_lastPresentPocResetIdc[ m_apcSlicePilot->getLayerId() ] = m_apcSlicePilot->getPocResetPeriodId();  
+  }
+}
+
+
+Void TDecTop::decodePocAndRps( )
 { 
-  return m_ivPicLists->getPic( layerId, poc ) ;
-}
-
-Void TDecTop::xResetPocInPicBuffer()
-{
-  TComList<TComPic*>::iterator  iterPic   = m_cListPic.begin();
-  while (iterPic != m_cListPic.end())
-  {
-    TComPic* pic = *(iterPic++);
-    if ( pic->getReconMark() )
-    {
-      for( Int i = 0; i < pic->getNumAllocatedSlice(); i++)
-      {
-        TComSlice* slice = pic->getSlice( i ); 
-        slice->setPOC ( slice->getPOC() - m_apcSlicePilot->getPocBeforeReset() );            
-      }         
-    }     
-  }
-}
-
-Void TDecTop::xCeckNoClrasOutput()
-{
-  // This part needs further testing! 
-  if ( getLayerId() == 0 )
+  assert( m_uiSliceIdx == 0 );
+  Int nuhLayerId = m_pcPic->getLayerId();
+  if ( m_decProcPocAndRps == CLAUSE_8 )
+  {
+    // 8.1.3 Decoding process for a coded picture with nuh_layer_id equal to 0
+
+    // Variables and functions relating to picture order count are derived as 
+    // specified in clause 8.3.1. This needs to be invoked only for the first slice 
+    // segment of a picture.
+    x831DecProcForPicOrderCount( );
+
+    // The decoding process for RPS in clause 8.3.2 is invoked, wherein reference 
+    // pictures may be marked as "unused for reference" or "used for long-term 
+    // reference". This needs to be invoked only for the first slice segment of a 
+    // picture.
+    x832DecProcForRefPicSet    (  false );
+  }
+  else if( m_decProcPocAndRps == ANNEX_F )
+  {
+    // F.8.1.3 Common decoding process for a coded picture
+
+    if (nuhLayerId == 0 )
+    {
+      // F.8.1.4 Decoding process for a coded picture with nuh_layer_id equal to
+      // --> Clause 8.1.3 is invoked with replacments of 8.3.1, 8.3.2, and 8.3.3 by F.8.3.1, 8.3.2, and 8.3.3
+
+      // Variables and functions relating to picture order count are derived as 
+      // specified in clause 8.3.1. This needs to be invoked only for the first slice 
+      // segment of a picture.
+      xF831DecProcForPicOrderCount( );
+
+      // The decoding process for RPS in clause 8.3.2 is invoked, wherein reference 
+      // pictures may be marked as "unused for reference" or "used for long-term 
+      // reference". This needs to be invoked only for the first slice segment of a 
+      // picture.
+      xF832DecProcForRefPicSet( );
+    }
+    else
+    {
+      // F.8.1.5 Decoding process for starting the decoding of a coded picture with
+      // nuh_layer_id greater than 0
+
+      // Variables and functions relating to picture order count are derived in clause F.8.3.1. 
+      // This needs to be invoked only for the first slice segment of a picture. It is a requirement 
+      // of bitstream conformance that PicOrderCntVal of each picture in an access unit shall have the 
+      // same value during and at the end of decoding of the access unit
+      xF831DecProcForPicOrderCount( );
+
+      // The decoding process for RPS in clause F.8.3.2 is invoked, wherein only reference pictures with 
+      // nuh_layer_id equal to that of CurrPic may be marked as "unused for reference" or "used for 
+      // long-term reference" and any picture with a different value of nuh_layer_id is not marked. 
+      // This needs to be invoked only for the first slice segment of a picture.
+      xF832DecProcForRefPicSet( );
+    }
+  }
+  else
+  {
+    assert( false ); 
+  }
+}
+
+Void TDecTop::genUnavailableRefPics( )
+{ 
+  assert( m_uiSliceIdx == 0 );
+  Int nuhLayerId = m_pcPic->getLayerId();
+  if ( m_decProcPocAndRps == CLAUSE_8 )
+  {
+    // 8.1.3 Decoding process for a coded picture with nuh_layer_id equal to 0
+
+    if ( m_pcPic->isBla() || ( m_pcPic->isCra() && m_pcPic->getNoRaslOutputFlag() ) )
+    {
+      // When the current picture is a BLA picture or is a CRA picture 
+      // with NoRaslOutputFlag equal to 1, the decoding process for generating 
+      // unavailable reference pictures specified in clause 8.3.3 is invoked, 
+      // which needs to be invoked only for the first slice segment of a picture.
+      x8331GenDecProcForGenUnavilRefPics();       
+    }
+  }
+  else if( m_decProcPocAndRps == ANNEX_F )
+  {
+    // F.8.1.3 Common decoding process for a coded picture
+
+    if (nuhLayerId == 0 )
+    {
+      // F.8.1.4 Decoding process for a coded picture with nuh_layer_id equal to
+      // --> Clause 8.1.3 is invoked with replacments of 8.3.1, 8.3.2, and 8.3.3 by F.8.3.1, 8.3.2, and 8.3.3
+
+      if ( m_pcPic->isBla() || ( m_pcPic->isCra() && m_pcPic->getNoRaslOutputFlag() ) )
+      {
+        // When the current picture is a BLA picture or is a CRA picture 
+        // with NoRaslOutputFlag equal to 1, the decoding process for generating 
+        // unavailable reference pictures specified in clause 8.3.3 is invoked, 
+        // which needs to be invoked only for the first slice segment of a picture.
+        xF833DecProcForGenUnavRefPics(); 
+      }
+#if NH_MV_FIX_INIT_NUM_ACTIVE_REF_LAYER_PICS
+      TComDecodedRps* decRps = m_pcPic->getDecodedRps(); 
+      decRps->m_numActiveRefLayerPics0 = 0;
+      decRps->m_numActiveRefLayerPics1 = 0;      
+#endif
+    }
+    else
+    {
+      // F.8.1.5 Decoding process for starting the decoding of a coded picture with
+      // nuh_layer_id greater than 0
+
+      if ( !m_firstPicInLayerDecodedFlag[ nuhLayerId ] )
+      {
+        // When FirstPicInLayerDecodedFlag[ nuh_layer_id ] is equal to 0, the decoding process for generating 
+        // unavailable reference pictures for pictures first in decoding order within a layer specified in 
+        // clause F.8.1.7 is invoked, which needs to be invoked only for the first slice segment of a picture.
+        xF817DecProcForGenUnavRefPicForPicsFrstInDecOrderInLay();
+      }
+
+      if ( m_firstPicInLayerDecodedFlag[ nuhLayerId ] && ( m_pcPic->isIrap() && m_pcPic->getNoRaslOutputFlag() ) )
+      {
+        // When FirstPicInLayerDecodedFlag[ nuh_layer_id ] is equal to 1 and the current picture is an IRAP 
+        // picture with NoRaslOutputFlag equal to 1, the decoding process for generating unavailable reference 
+        // pictures specified in clause F.8.3.3 is invoked, which needs to be invoked only for the first slice 
+        // segment of a picture.
+        xF833DecProcForGenUnavRefPics(); 
+      }
+
+      if ( decProcAnnexG() )
+      {
+        // G.1.2 --> G.1.3
+        xG813DecProcForInterLayerRefPicSet();
+      }
+    }
+  }
+  else
+  {
+    assert( false ); 
+  }
+
+  xCheckUnavailableRefPics();      
+}
+Void TDecTop::executeLoopFilters( )
+{
+  assert( m_pcPic != NULL ); 
+  if ( !m_pcPic->getHasGeneratedRefPics() && !m_pcPic->getIsGenerated() )
+  {
+    m_cGopDecoder.filterPicture( m_pcPic );
+  }
+  m_cCuDecoder.destroy();
+}
+
+Void TDecTop::finalizePic()
+{
+  if( m_pcPic->isIrap() )
+  {
+    m_prevIrapPoc           = m_pcPic->getPOC(); 
+    m_prevIrapDecodingOrder = m_pcPic->getDecodingOrder(); 
+  }
+  if( m_pcPic->isStsa() )
+  {
+    m_prevStsaDecOrder      = m_pcPic->getDecodingOrder();
+    m_prevStsaTemporalId    = m_pcPic->getTemporalId()   ;
+  }
+}
+
+
+Void TDecTop::initFromActiveVps( const TComVPS* vps )
+{   
+  setViewId   ( vps->getViewId   ( getLayerId() )      );  
+#if NH_3D
+  setViewIndex( vps->getViewIndex( getLayerId() )      );  
+  setIsDepth  ( vps->getDepthId  ( getLayerId() ) == 1 );  
+#endif
+
+  if ( !vps->getVpsExtensionFlag() )
+  {
+    m_decodingProcess = CLAUSE_8; 
+    m_isInOwnTargetDecLayerIdList = ( getLayerId() ==  0 );
+  }
+  else
+  {  
+    if ( m_targetOlsIdx == -1 )
+    {
+      // Corresponds to specification by "External Means". (Should be set equal to 0, when no external means available. ) 
+      m_targetOlsIdx = vps->getVpsNumLayerSetsMinus1(); 
+    }
+
+    Int targetDecLayerSetIdx = vps->olsIdxToLsIdx( m_targetOlsIdx ); 
+
+    if ( targetDecLayerSetIdx <= vps->getVpsNumLayerSetsMinus1() && vps->getVpsBaseLayerInternalFlag() )
+    {
+      m_smallestLayerId = 0; 
+    }
+    else if ( targetDecLayerSetIdx <= vps->getVpsNumLayerSetsMinus1() && !vps->getVpsBaseLayerInternalFlag() )
+    {
+      m_smallestLayerId = 0; 
+    }
+    else if ( targetDecLayerSetIdx > vps->getVpsNumLayerSetsMinus1() && vps->getNumLayersInIdList( targetDecLayerSetIdx) == 1 )
+    {
+      
+      // m_smallestLayerId = 0;       
+      // For now don't do change of layer id here. 
+      m_smallestLayerId = vps->getTargetDecLayerIdList( targetDecLayerSetIdx )[ 0 ];    
+    }
+    else
+    {
+      m_smallestLayerId = vps->getTargetDecLayerIdList( targetDecLayerSetIdx )[ 0 ];    
+    }
+
+
+    // Set profile
+    Int lsIdx = vps->olsIdxToLsIdx( m_targetOlsIdx );
+    Int lIdx = -1; 
+    for (Int j = 0; j < vps->getNumLayersInIdList( lsIdx ) ; j++ )
+    {
+      if ( vps->getLayerSetLayerIdList( lsIdx, j ) == getLayerId() )
+      {        
+        lIdx = j;         
+        break; 
+      }        
+    }
+    m_isInOwnTargetDecLayerIdList = (lIdx != -1); 
+
+    if ( m_isInOwnTargetDecLayerIdList )
+    {
+      Int profileIdc = vps->getPTL( vps->getProfileTierLevelIdx( m_targetOlsIdx, lIdx ) )->getGeneralPTL()->getProfileIdc();
+      assert( profileIdc == 1 || profileIdc == 6 || profileIdc == 8 ); 
+
+      if (  profileIdc == 6 )
+      {
+        m_decodingProcess = ANNEX_G;
+      }
+      else if (profileIdc == 7 )
+      {
+        m_decodingProcess = ANNEX_H;
+      }
+      else if (profileIdc == 8 )
+      {
+        m_decodingProcess = ANNEX_I;
+      }
+    }
+  }
+}
+
+
+Bool TDecTop::getFirstSliceSegementInPicFlag()
+{
+  return m_apcSlicePilot->getFirstSliceSegementInPicFlag();
+}
+
+Void TDecTop::x831DecProcForPicOrderCount()
+{
+  /////////////////////////////////////////////////////
+  // 8.3.1 Decoding process for picture order count //
+  /////////////////////////////////////////////////////
+
+  //  Output of this process is PicOrderCntVal, the picture order count of the current picture.
+  //  Picture order counts are used to identify pictures, for deriving motion parameters in merge mode and 
+  //  motion vector prediction, and for decoder conformance checking (see clause C.5).
+  //  Each coded picture is associated with a picture order count variable, denoted as PicOrderCntVal.
+
+  const TComSlice* curSlice = m_pcPic->getSlice(0); 
+
+  Int prevPicOrderCntLsb = MIN_INT; 
+  Int prevPicOrderCntMsb = MIN_INT;  
+  if (!(m_pcPic->isIrap() && m_pcPic->getNoRaslOutputFlag() )  )  
+  {
+    //  When the current picture is not an IRAP picture with NoRaslOutputFlag equal to 1, 
+    //  the variables prevPicOrderCntLsb and prevPicOrderCntMsb are derived as follows:
+
+    //  -  Let prevTid0Pic be the previous picture in decoding order that has TemporalId equal to 0 and that is not a RASL picture, 
+    //     a RADL picture or an SLNR picture.
+
+    //  -  The variable prevPicOrderCntLsb is set equal to slice_pic_order_cnt_lsb of prevTid0Pic.
+    prevPicOrderCntLsb = m_prevTid0PicSlicePicOrderCntLsb; 
+
+    //  -  The variable prevPicOrderCntMsb is set equal to PicOrderCntMsb of prevTid0Pic.
+    prevPicOrderCntMsb = m_prevTid0PicPicOrderCntMsb; 
+  }
+
+  //  The variable PicOrderCntMsb of the current picture is derived as follows:  
+  
+  Int slicePicOrderCntLsb = curSlice->getSlicePicOrderCntLsb();
+
+  Int picOrderCntMsb; 
+
+  if (m_pcPic->isIrap() && m_pcPic->getNoRaslOutputFlag()  )
+  {
+    //-  If the current picture is an IRAP picture with NoRaslOutputFlag equal to 1, PicOrderCntMsb is set equal to 0.
+    picOrderCntMsb = 0; 
+  }
+  else
+  {
+    Int maxPicOrderCntLsb   = curSlice->getSPS()->getMaxPicOrderCntLsb(); 
+
+  //  -  Otherwise, PicOrderCntMsb is derived as follows:
+
+    if( ( slicePicOrderCntLsb < prevPicOrderCntLsb )  &&
+      ( ( prevPicOrderCntLsb - slicePicOrderCntLsb )  >=  ( maxPicOrderCntLsb / 2 ) ) )
+    {
+      picOrderCntMsb = prevPicOrderCntMsb + maxPicOrderCntLsb;   // (8 1)
+    }
+    else if( (slicePicOrderCntLsb > prevPicOrderCntLsb )  &&
+    ( ( slicePicOrderCntLsb - prevPicOrderCntLsb ) > ( maxPicOrderCntLsb / 2 ) ) )
+    {
+      picOrderCntMsb = prevPicOrderCntMsb - maxPicOrderCntLsb;
+    }
+    else
+    {
+      picOrderCntMsb = prevPicOrderCntMsb; 
+    }
+  }
+  
+  //PicOrderCntVal is derived as follows:
+  Int picOrderCntVal = picOrderCntMsb + slicePicOrderCntLsb; //   (8 2)
+
+  //  NOTE 1 - All IDR pictures will have PicOrderCntVal equal to 0 since slice_pic_order_cnt_lsb is inferred to be 0 for IDR 
+  //  pictures and prevPicOrderCntLsb and prevPicOrderCntMsb are both set equal to 0.
+
+  m_pcPic->getSlice(0)->setPOC( picOrderCntVal ); 
+
+  // Update prevTid0Pic
+  //   Let prevTid0Pic be the previous picture in decoding order that has TemporalId equal to 0 and that is not a RASL picture, a RADL picture or an SLNR picture.
+  if( curSlice->getTemporalId() == 0  && !m_pcPic->isRasl() && !m_pcPic->isRadl() && !m_pcPic->isSlnr() )
+  {
+    m_prevTid0PicSlicePicOrderCntLsb = slicePicOrderCntLsb;     
+    m_prevTid0PicPicOrderCntMsb      = picOrderCntMsb;  
+  }
+}
+
+Void TDecTop::xF831DecProcForPicOrderCount()
+{
+  //Output of this process is PicOrderCntVal, the picture order count of the current picture.
+  //  Picture order counts are used to identify pictures, for deriving motion parameters in merge mode and 
+  //  motion vector prediction and for decoder conformance checking (see clause F.13.5).
+
+  //  Each coded picture is associated with a picture order count variable, denoted as PicOrderCntVal.
+
+  const TComSlice* slice = m_pcPic->getSlice(0); 
+  const Int nuhLayerId   = m_pcPic->getLayerId(); 
+  const TComVPS*   vps   = slice->getVPS(); 
+  const TComSPS*   sps   = slice->getSPS(); 
+  if ( m_pcPic->getIsFstPicOfAllLayOfPocResetPer() )
+  {
+    //  When the current picture is the first picture among all layers of a POC resetting period, 
+    //  the variable PocDecrementedInDPBFlag[ i ] is set equal to 0 for each value of i in the range of 0 to 62, inclusive.
+    for (Int i = 0; i <= 62; i++)
+    {
+      m_pocDecrementedInDpbFlag[ i ] = 0; 
+    }
+  }
+
+  //  The variable pocResettingFlag is derived as follows:
+  Bool pocResettingFlag; 
+  if (m_pcPic->getIsPocResettingPic() )
+  {
+    //-  If the current picture is a POC resetting picture, the following applies:    
+    if( vps->getVpsPocLsbAlignedFlag()  )
+    {
+      //  -  If vps_poc_lsb_aligned_flag is equal to 0, pocResettingFlag is set equal to 1.
+      pocResettingFlag = true; 
+    }
+    else if ( m_pocDecrementedInDpbFlag[ nuhLayerId ] )
+    {
+      //  -  Otherwise, if PocDecrementedInDPBFlag[ nuh_layer_id ] is equal to 1, pocResettingFlag is set equal to 0.
+      pocResettingFlag = false; 
+    }
+    else
+    {
+      //  -  Otherwise, pocResettingFlag is set equal to 1.
+      pocResettingFlag = true; 
+    }
+  }
+  else
+  {
+    //  -  Otherwise, pocResettingFlag is set equal to 0.
+    pocResettingFlag = false; 
+  }
+
+  //  The list affectedLayerList is derived as follows:
+  std::vector<Int> affectedLayerList; 
+  if (! vps->getVpsPocLsbAlignedFlag() )
+  {
+    //-  If vps_poc_lsb_aligned_flag is equal to 0, affectedLayerList consists of the nuh_layer_id of the current picture.
+    affectedLayerList.push_back( nuhLayerId ); 
+  }
+  else
+  {
+    //  -  Otherwise, affectedLayerList consists of the nuh_layer_id of the current picture and the nuh_layer_id values 
+    //     equal to IdPredictedLayer[ currNuhLayerId ][ j ] for all values of j in the range of 0 to NumPredictedLayers[ currNuhLayerId ] - 1, 
+    //     inclusive, where currNuhLayerId is the nuh_layer_id value of the current picture.
+    affectedLayerList.push_back( nuhLayerId ); 
+    Int currNuhLayerId = nuhLayerId; 
+    for (Int j = 0; j <= vps->getNumPredictedLayers( currNuhLayerId )-1; j++ )
+    {
+      affectedLayerList.push_back( vps->getIdPredictedLayer(currNuhLayerId, j ) );
+    }
+  }
+  
+  Int picOrderCntMsb; 
+  Int picOrderCntVal; 
+
+  //  Depending on pocResettingFlag, the following applies:
+  if ( pocResettingFlag )
+  {
+    //-  If pocResettingFlag is equal to 1, the following applies:
+    if ( m_firstPicInLayerDecodedFlag[ nuhLayerId ] )
+    {
+      //-  The variables pocMsbDelta, pocLsbDelta and DeltaPocVal are derived as follows:
+      Int pocMsbDelta; 
+      Int pocLsbDelta; 
+      Int deltaPocVal;       
+
+      {
+        Int pocLsbVal; 
+        Int prevPicOrderCntLsb; 
+        Int prevPicOrderCntMsb; 
+
+        if( slice->getPocResetIdc() ==  3 )
+        {
+          pocLsbVal = slice->getPocLsbVal(); 
+        }      
+        else
+        {
+          pocLsbVal = slice->getSlicePicOrderCntLsb(); 
+        }
+
+        if( slice->getPocMsbCycleValPresentFlag() )
+        {
+          pocMsbDelta = slice->getPocMsbCycleVal() * sps->getMaxPicOrderCntLsb();   // (F 60)
+        }      
+        else
+        {
+          prevPicOrderCntLsb = m_prevPicOrderCnt & ( sps->getMaxPicOrderCntLsb() - 1 ); 
+          prevPicOrderCntMsb = m_prevPicOrderCnt - prevPicOrderCntLsb; 
+
+          pocMsbDelta = xGetCurrMsb( pocLsbVal, prevPicOrderCntLsb, prevPicOrderCntMsb, sps->getMaxPicOrderCntLsb() ); 
+        }
+
+        if( slice->getPocResetIdc() == 2 ||  ( slice->getPocResetIdc() == 3  &&  slice->getFullPocResetFlag() ) )
+        {
+          pocLsbDelta = pocLsbVal; 
+        }
+        else
+        {
+          pocLsbDelta = 0; 
+        }
+        deltaPocVal = pocMsbDelta + pocLsbDelta; 
+      }
+
+      //-  The PicOrderCntVal of each picture that has nuh_layer_id value nuhLayerId for which PocDecrementedInDPBFlag[ nuhLayerId ] is equal to 0 
+      //   and that is equal to any value in affectedLayerList is decremented by DeltaPocVal.
+      for (Int i = 0; i < (Int) affectedLayerList.size(); i++ )
+      {
+        if ( !m_pocDecrementedInDpbFlag[ affectedLayerList[i] ] )
+        {
+          m_dpb->decrementPocsInSubDpb( affectedLayerList[i], deltaPocVal ); 
+        }
+      }
+
+      //-  PocDecrementedInDPBFlag[ nuhLayerId ] is set equal to 1 for each value of nuhLayerId included in affectedLayerList.
+      for (Int i = 0; i < (Int) affectedLayerList.size(); i++ )
+      {
+        m_pocDecrementedInDpbFlag[ affectedLayerList[i] ] = true; 
+      }
+    } 
+
+    //-  The PicOrderCntVal of the current picture is derived as follows:
+    if( slice->getPocResetIdc()  ==  1 )
+    {
+      picOrderCntVal = slice->getSlicePicOrderCntLsb(); 
+    }
+    else if (slice->getPocResetIdc()  ==  2 ) 
+    {
+      picOrderCntVal = 0; 
+    }
+    else
+    {
+       picOrderCntMsb = xGetCurrMsb( slice->getSlicePicOrderCntLsb(), slice->getFullPocResetFlag() ? 0 : slice->getPocLsbVal(), 0, sps->getMaxPicOrderCntLsb() ); 
+       picOrderCntVal = picOrderCntMsb + slice->getSlicePicOrderCntLsb(); 
+    }
+  }
+  else
+  {
+    //-  Otherwise (pocResettingFlag is equal to 0), the following applies:
+    //-  The PicOrderCntVal of the current picture is derived as follows:
+    
+    if( slice->getPocMsbCycleValPresentFlag() )
+    {
+      picOrderCntMsb = slice->getPocMsbCycleVal() * sps->getMaxPicOrderCntLsb(); 
+    }
+    else if( !m_firstPicInLayerDecodedFlag[ nuhLayerId ]  ||
+    slice->getNalUnitType()  ==  NAL_UNIT_CODED_SLICE_IDR_N_LP || slice->getNalUnitType() ==  NAL_UNIT_CODED_SLICE_IDR_W_RADL )
+    {
+      picOrderCntMsb = 0; //     (F 62)
+    }    
+    else
+    {
+        Int prevPicOrderCntLsb = m_prevPicOrderCnt & ( sps->getMaxPicOrderCntLsb() - 1 );
+        Int prevPicOrderCntMsb = m_prevPicOrderCnt - prevPicOrderCntLsb; 
+        picOrderCntMsb = xGetCurrMsb( slice->getSlicePicOrderCntLsb(), prevPicOrderCntLsb, prevPicOrderCntMsb, sps->getMaxPicOrderCntLsb() ); 
+    }
+    picOrderCntVal = picOrderCntMsb + slice->getSlicePicOrderCntLsb(); 
+  }
+  
+  m_pcPic->getSlice(0)->setPOC( picOrderCntVal ); 
+  
+  for (Int lId = 0; lId < (Int) affectedLayerList.size(); lId++ )
+  {  
+    //  The value of PrevPicOrderCnt[ lId ] for each of the lId values included in affectedLayerList is derived as follows:
+
+    if (!m_pcPic->isRasl() && !m_pcPic->isRadl() && !m_pcPic->isSlnr() && slice->getTemporalId() == 0 && !slice->getDiscardableFlag() )
+    {
+      //-  If the current picture is not a RASL picture, a RADL picture or a sub-layer non-reference picture, and the current picture 
+      //   has TemporalId equal to 0 and discardable_flag equal to 0, PrevPicOrderCnt[ lId ] is set equal to PicOrderCntVal.
+      m_prevPicOrderCnt = picOrderCntVal; 
+    }
+    else if ( slice->getPocResetIdc() == 3 &&  (
+      ( !m_firstPicInLayerDecodedFlag[ nuhLayerId ]) || 
+      ( m_firstPicInLayerDecodedFlag[ nuhLayerId ] && m_pcPic->getIsPocResettingPic() ) 
+      ) )
+    {
+      //  -  Otherwise, when poc_reset_idc is equal to 3 and one of the following conditions is true, PrevPicOrderCnt[ lId ] is set equal to ( full_poc_reset_flag ? 0 : poc_lsb_val ):
+      //     -  FirstPicInLayerDecodedFlag[ nuh_layer_id ] is equal to 0.
+      //     -  FirstPicInLayerDecodedFlag[ nuh_layer_id ] is equal to 1 and the current picture is a POC resetting picture.
+      m_prevPicOrderCnt = ( slice->getFullPocResetFlag() ? 0 : slice->getPocLsbVal() ); 
+    }
+  }
+}
+
+Int TDecTop::xGetCurrMsb( Int cl, Int pl, Int pm, Int ml )
+{
+  Int currMsb; 
+  if ((pl - cl) >= (ml/ 2))
+  {
+    currMsb = pm + ml;
+  }
+  else if ( (cl - pl) > (ml / 2))
+  {
+    currMsb = pm - ml; 
+  }
+  else
+  {
+    currMsb = pm; 
+  }
+
+  return currMsb;  
+}   
+
+
+
+Void TDecTop::x832DecProcForRefPicSet(  Bool annexFModifications )
+{
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // 8.3.2 8.3.2 Decoding process for reference picture set
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  TComSlice* slice = m_pcPic->getSlice( 0 ); 
+  const TComSPS* sps = slice->getSPS(); 
+  //  This process is invoked once per picture, after decoding of a slice header but prior to the decoding of any coding unit and prior 
+  //  to the decoding process for reference picture list construction for the slice as specified in clause 8.3.3. 
+  //  This process may result in one or more reference pictures in the DPB being marked as "unused for reference" or 
+  //  "used for long-term reference".
+
+  // The variable currPicLayerId is set equal to nuh_layer_id of the current picture.
+  Int currPicLayerId = m_pcPic->getLayerId(); 
+  Int picOrderCntVal = m_pcPic->getPOC(); 
+
+  if (m_pcPic->isIrap() && m_pcPic->getNoRaslOutputFlag()  )
+  {     
+    // When the current picture is an IRAP picture with NoRaslOutputFlag equal to 1, 
+    // all reference pictures with nuh_layer_id equal to currPicLayerId currently in the 
+    // DPB (if any) are marked as "unused for reference".
+    m_dpb->markSubDpbAsUnusedForReference( currPicLayerId ); 
+  }
+  // Short-term reference pictures are identified by their PicOrderCntVal values. Long-term reference pictures are identified either by 
+  // their PicOrderCntVal values or their slice_pic_order_cnt_lsb values.
+
+  // Five lists of picture order count values are constructed to derive the RPS. These five lists are PocStCurrBefore, 
+  // PocStCurrAfter, PocStFoll, PocLtCurr and PocLtFoll, with NumPocStCurrBefore, NumPocStCurrAfter, NumPocStFoll, 
+  // NumPocLtCurr and NumPocLtFoll number of elements, respectively. The five lists and the five variables are derived as follows:
+  
+  TComDecodedRps* decRps = m_pcPic->getDecodedRps(); 
+
+  std::vector<Int>& pocStCurrBefore = decRps->m_pocStCurrBefore;
+  std::vector<Int>& pocStCurrAfter  = decRps->m_pocStCurrAfter;
+  std::vector<Int>& pocStFoll       = decRps->m_pocStFoll;
+  std::vector<Int>& pocLtCurr       = decRps->m_pocLtCurr;
+  std::vector<Int>& pocLtFoll       = decRps->m_pocLtFoll;
+
+  Int& numPocStCurrBefore = decRps->m_numPocStCurrBefore; 
+  Int& numPocStCurrAfter  = decRps->m_numPocStCurrAfter;
+  Int& numPocStFoll       = decRps->m_numPocStFoll;
+  Int& numPocLtCurr       = decRps->m_numPocLtCurr;
+  Int& numPocLtFoll       = decRps->m_numPocLtFoll;   
+
+  std::vector<Int> currDeltaPocMsbPresentFlag, follDeltaPocMsbPresentFlag; 
+
+  if (m_pcPic->isIdr() )
+  {
+    // - If the current picture is an IDR picture, PocStCurrBefore, PocStCurrAfter, PocStFoll, 
+    //   PocLtCurr and PocLtFoll are all set to be empty, and NumPocStCurrBefore, 
+    //   NumPocStCurrAfter, NumPocStFoll, NumPocLtCurr and NumPocLtFoll are all set equal to 0.
+
+    pocStCurrBefore.clear();
+    pocStCurrAfter .clear();
+    pocStFoll      .clear();
+    pocLtCurr      .clear();
+    pocLtFoll      .clear();
+    numPocStCurrBefore = 0; 
+    numPocStCurrAfter  = 0; 
+    numPocStFoll       = 0; 
+    numPocLtCurr       = 0; 
+    numPocLtFoll       = 0; 
+  }
+  else
+  {
+    const TComStRefPicSet* stRps  = slice->getStRps( slice->getCurrRpsIdx() );
+    // -  Otherwise, the following applies:
+
+    Int j = 0; 
+    Int k = 0; 
+    for( Int i = 0; i < stRps->getNumNegativePicsVar() ; i++ )
+    {
+      if( stRps->getUsedByCurrPicS0Var( i  ) )
+      {
+        pocStCurrBefore.push_back( picOrderCntVal + stRps->getDeltaPocS0Var( i ) ); j++;
+      }
+      else
+      {
+        pocStFoll      .push_back( picOrderCntVal + stRps->getDeltaPocS0Var( i ) ); k++;
+      }
+    }
+    numPocStCurrBefore = j;    
+
+    j = 0; 
+    for (Int i = 0; i < stRps->getNumPositivePicsVar(); i++ )
+    {
+      if (stRps->getUsedByCurrPicS1Var( i ) )
+      {
+        pocStCurrAfter.push_back( picOrderCntVal + stRps->getDeltaPocS1Var( i ) ); j++; 
+      }
+      else
+      {
+        pocStFoll     .push_back( picOrderCntVal + stRps->getDeltaPocS1Var( i ) ); k++;
+      }
+    }
+    numPocStCurrAfter = j;
+    numPocStFoll = k; //    (8 5)
+
+
+    j = 0; 
+    k = 0; 
+    for( Int i = 0; i < slice->getNumLongTermSps( ) + slice->getNumLongTermPics(); i++ )
+    {
+      Int pocLt = slice->getPocLsbLtVar( i ); 
+      if( slice->getDeltaPocMsbPresentFlag( i ) )
+      {
+        pocLt  +=  picOrderCntVal - slice->getDeltaPocMsbCycleLtVar( i ) * sps->getMaxPicOrderCntLsb() -
+          ( picOrderCntVal & ( sps->getMaxPicOrderCntLsb() - 1 ) );
+      }
+
+      if( slice->getUsedByCurrPicLtVar(i)) 
+      {
+        pocLtCurr.push_back( pocLt );
+        currDeltaPocMsbPresentFlag.push_back( slice->getDeltaPocMsbPresentFlag( i ) ); j++; 
+      } 
+      else
+      {
+        pocLtFoll.push_back( pocLt );
+        follDeltaPocMsbPresentFlag.push_back( slice->getDeltaPocMsbPresentFlag( i ) ); k++; 
+      }
+    }
+    numPocLtCurr = j;
+    numPocLtFoll = k;
+  }
+
+  assert(numPocStCurrAfter  == pocStCurrAfter   .size() );
+  assert(numPocStCurrBefore == pocStCurrBefore  .size() );
+  assert(numPocStFoll       == pocStFoll        .size() );  
+  assert(numPocLtCurr       == pocLtCurr        .size() );  
+  assert(numPocLtFoll       == pocLtFoll        .size() );
+
+  // where PicOrderCntVal is the picture order count of the current picture as specified in clause 8.3.1.
+
+  //   NOTE 2 - A value of CurrRpsIdx in the range of 0 to num_short_term_ref_pic_sets - 1, inclusive, 
+  //   indicates that a candidate short-term RPS from the active SPS for the current layer is being used, 
+  //   where CurrRpsIdx is the index of the candidate short-term RPS into the list of candidate short-term RPSs signalled 
+  //   in the active SPS for the current layer. CurrRpsIdx equal to num_short_term_ref_pic_sets indicates that 
+  //   the short-term RPS of the current picture is directly signalled in the slice header.
+
+  for (Int i = 0; i <= numPocLtCurr - 1; i++  )
+  {
+      // For each i in the range of 0 to NumPocLtCurr - 1, inclusive, when CurrDeltaPocMsbPresentFlag[ i ] is equal to 1, 
+      // it is a requirement of bitstream conformance that the following conditions apply:
+    if ( currDeltaPocMsbPresentFlag[i] )
+    {
+      // -  There shall be no j in the range of 0 to NumPocStCurrBefore - 1, inclusive, 
+      //    for which PocLtCurr[ i ] is equal to PocStCurrBefore[ j ].
+      for (Int j = 0; j <= numPocStCurrBefore - 1; j++ )
+      {
+        assert(!( pocLtCurr[ i ] == pocStCurrBefore[ j ] ) );
+      }
+
+      // -  There shall be no j in the range of 0 to NumPocStCurrAfter - 1, inclusive, 
+      //    for which PocLtCurr[ i ] is equal to PocStCurrAfter[ j ]. 
+      for (Int j = 0; j <= numPocStCurrAfter - 1; j++ )
+      {
+        assert(!( pocLtCurr[ i ] == pocStCurrAfter[ j ] ) );
+      }
+
+      // -  There shall be no j in the range of 0 to NumPocStFoll - 1, inclusive, 
+      //    for which PocLtCurr[ i ] is equal to PocStFoll[ j ].
+      for (Int j = 0; j <= numPocStFoll - 1; j++ )
+      {
+        assert(!( pocLtCurr[ i ] == pocStFoll[ j ] ) );
+      }
+
+      // -  There shall be no j in the range of 0 to NumPocLtCurr - 1, inclusive, 
+      //    where j is not equal to i, for which PocLtCurr[ i ] is equal to PocLtCurr[ j ].
+      for (Int j = 0; j <= numPocLtCurr - 1; j++ )
+      {
+        if ( i != j )
+        {        
+          assert(!( pocLtCurr[ i ] == pocLtCurr[ j ] ) );
+        }
+      }
+    }
+  }
+
+  for (Int i = 0; i <= numPocLtFoll - 1; i++  )
+  {
+    // For each i in the range of 0 to NumPocLtFoll - 1, inclusive, when FollDeltaPocMsbPresentFlag[ i ] is equal to 1, 
+    // it is a requirement of bitstream conformance that the following conditions apply:
+    if ( follDeltaPocMsbPresentFlag[i] )
+    {
+      // -  There shall be no j in the range of 0 to NumPocStCurrBefore - 1, inclusive, 
+      //    for which PocLtFoll[ i ] is equal to PocStCurrBefore[ j ].
+      for (Int j = 0; j <= numPocStCurrBefore - 1; j++ )
+      {
+        assert(!( pocLtFoll[ i ] == pocStCurrBefore[ j ] ) );
+      }
+
+      // -  There shall be no j in the range of 0 to NumPocStCurrAfter - 1, inclusive, 
+      //    for which PocLtFoll[ i ] is equal to PocStCurrAfter[ j ].
+      for (Int j = 0; j <= numPocStCurrAfter - 1; j++ )
+      {
+        assert(!( pocLtFoll[ i ] == pocStCurrAfter[ j ] ) );
+      }
+
+      // -  There shall be no j in the range of 0 to NumPocStFoll - 1, inclusive, 
+      //    for which PocLtFoll[ i ] is equal to PocStFoll[ j ].
+      for (Int j = 0; j <= numPocStFoll - 1; j++ )
+      {
+        assert(!( pocLtFoll[ i ] == pocStFoll[ j ] ) );
+      }
+
+      // -  There shall be no j in the range of 0 to NumPocLtFoll - 1, inclusive, 
+      //    where j is not equal to i, for which PocLtFoll[ i ] is equal to PocLtFoll[ j ].
+      for (Int j = 0; j <= numPocLtFoll - 1; j++ )
+      {
+        if (j != i)
+        {
+          assert(!( pocLtFoll[ i ] == pocLtFoll[ j ] ) );
+        }
+      }
+
+      // -  There shall be no j in the range of 0 to NumPocLtCurr - 1, inclusive, 
+      //    for which PocLtFoll[ i ] is equal to PocLtCurr[ j ].
+      for (Int j = 0; j <= numPocLtCurr - 1; j++ )
+      {
+        assert(!( pocLtFoll[ i ] == pocLtCurr[ j ] ) );
+      }
+    }
+  }
+
+  Int maxPicOrderCntLsb = sps->getMaxPicOrderCntLsb(); 
+  for (Int i = 0; i <= numPocLtCurr - 1; i++  )
+  {
+    // For each i in the range of 0 to NumPocLtCurr - 1, inclusive, when CurrDeltaPocMsbPresentFlag[ i ] is equal to 0, 
+    // it is a requirement of bitstream conformance that the following conditions apply:
+    if ( currDeltaPocMsbPresentFlag[ i ] == 0  )
+    {
+      // -  There shall be no j in the range of 0 to NumPocStCurrBefore - 1, inclusive, 
+      //    for which PocLtCurr[ i ] is equal to ( PocStCurrBefore[ j ] & ( MaxPicOrderCntLsb - 1 ) ).
+      for (Int j = 0; j <= numPocStCurrBefore - 1; j++ )
+      {
+        assert(!( pocLtCurr[ i ] == ( pocStCurrBefore[ j ] & ( maxPicOrderCntLsb - 1 ) ) ) );
+      }
+
+      // -  There shall be no j in the range of 0 to NumPocStCurrAfter - 1, inclusive,
+      //    for which PocLtCurr[ i ] is equal to ( PocStCurrAfter[ j ] & ( MaxPicOrderCntLsb - 1 ) ).
+      for (Int j = 0; j <= numPocStCurrAfter - 1; j++ )
+      {
+        assert(!( pocLtCurr[ i ] == ( pocStCurrAfter[ j ] & ( maxPicOrderCntLsb - 1 ) ) ) );
+      }
+
+      // -  There shall be no j in the range of 0 to NumPocStFoll - 1, inclusive,
+      //    for which PocLtCurr[ i ] is equal to ( PocStFoll[ j ] & ( MaxPicOrderCntLsb - 1 ) ).
+      for (Int j = 0; j <= numPocStFoll - 1; j++ )
+      {
+        assert(!( pocLtCurr[ i ] == ( pocStFoll[ j ] & ( maxPicOrderCntLsb - 1 ) ) ) );
+      }
+
+      // -  There shall be no j in the range of 0 to NumPocLtCurr - 1, inclusive,
+      //    where j is not equal to i, for which PocLtCurr[ i ] is equal to ( PocLtCurr[ j ] & ( MaxPicOrderCntLsb - 1 ) ).
+      for (Int j = 0; j <= numPocLtCurr - 1; j++ )
+      {
+        if (j != i)
+        {
+          assert(!( pocLtCurr[ i ] == ( pocLtCurr[ j ] & ( maxPicOrderCntLsb - 1 ) ) ) );
+        }
+      }
+    }
+  }
+
+  for (Int i = 0; i <= numPocLtFoll - 1; i++  )
+  {
+    // For each i in the range of 0 to NumPocLtFoll - 1, inclusive, when FollDeltaPocMsbPresentFlag[ i ] is equal to 0, 
+    // it is a requirement of bitstream conformance that the following conditions apply:
+    if ( follDeltaPocMsbPresentFlag[ i ] == 0  )
+    {
+      // -  There shall be no j in the range of 0 to NumPocStCurrBefore - 1, inclusive,
+      //    for which PocLtFoll[ i ] is equal to ( PocStCurrBefore[ j ] & ( MaxPicOrderCntLsb - 1 ) ).
+      for (Int j = 0; j <= numPocStCurrBefore - 1; j++ )
+      {
+        assert(!( pocLtFoll[ i ] == ( pocStCurrBefore[ j ] & ( maxPicOrderCntLsb - 1 ) ) ) );
+      }
+
+      // -  There shall be no j in the range of 0 to NumPocStCurrAfter - 1, inclusive,
+      //    for which PocLtFoll[ i ] is equal to ( PocStCurrAfter[ j ] & ( MaxPicOrderCntLsb - 1 ) ).
+      for (Int j = 0; j <= numPocStCurrAfter - 1; j++ )
+      {
+        assert(!( pocLtFoll[ i ] == ( pocStCurrAfter[ j ] & ( maxPicOrderCntLsb - 1 ) ) ) );
+      }
+
+      // -  There shall be no j in the range of 0 to NumPocStFoll - 1, inclusive,
+      //    for which PocLtFoll[ i ] is equal to ( PocStFoll[ j ] & ( MaxPicOrderCntLsb - 1 ) ).
+      for (Int j = 0; j <= numPocStFoll - 1; j++ )
+      {
+        assert(!( pocLtFoll[ i ] == ( pocStFoll[ j ] & ( maxPicOrderCntLsb - 1 ) ) ) );
+      }
+
+      // -  There shall be no j in the range of 0 to NumPocLtFoll - 1, inclusive,
+      //    where j is not equal to i, for which PocLtFoll[ i ] is equal to ( PocLtFoll[ j ] & ( MaxPicOrderCntLsb - 1 ) ).
+      for (Int j = 0; j <= numPocLtFoll - 1; j++ )
+      {
+        if (j != i)
+        {
+          assert(!( pocLtFoll[ i ] == ( pocLtFoll[ j ] & ( maxPicOrderCntLsb - 1 ) ) ) );
+        }          
+      }
+
+      // -  There shall be no j in the range of 0 to NumPocLtCurr - 1, inclusive,
+      //    for which PocLtFoll[ i ] is equal to ( PocLtCurr[ j ] & ( MaxPicOrderCntLsb - 1 ) ).
+      for (Int j = 0; j <= numPocLtCurr - 1; j++ )
+      {
+        assert(!( pocLtFoll[ i ] == ( pocLtCurr[ j ] & ( maxPicOrderCntLsb - 1 ) ) ) );
+      }
+    }
+  }
+
+  if ( !annexFModifications )
+  {  
+    // The variable NumPicTotalCurr is derived as specified in clause 7.4.7.2. 
+
+    // It is a requirement of bitstream conformance that the following applies to the value of NumPicTotalCurr:
+    if ( m_pcPic->isBla() || m_pcPic->isCra() )
+    {
+      // -  If the current picture is a BLA or CRA picture, the value of NumPicTotalCurr shall be equal to 0.
+      assert( slice->getNumPicTotalCurr() == 0 ); 
+    }
+    else
+    {
+      // -  Otherwise, 
+      if ( slice->isInterP() || slice->isInterB() )
+      {
+        // when the current picture contains a P or B slice, the value of NumPicTotalCurr shall not be equal to 0.
+        assert( slice->getNumPicTotalCurr() != 0 ); 
+      }
+    }
+  }
+    
+  // The RPS of the current picture consists of five RPS lists; RefPicSetStCurrBefore, RefPicSetStCurrAfter, RefPicSetStFoll, 
+  // RefPicSetLtCurr and RefPicSetLtFoll. RefPicSetStCurrBefore, RefPicSetStCurrAfter and RefPicSetStFoll are collectively 
+  // referred to as the short-term RPS. RefPicSetLtCurr and RefPicSetLtFoll are collectively referred to as the long-term RPS.
+
+  std::vector<TComPic*>& refPicSetStCurrBefore = decRps->m_refPicSetStCurrBefore;
+  std::vector<TComPic*>& refPicSetStCurrAfter  = decRps->m_refPicSetStCurrAfter ;
+  std::vector<TComPic*>& refPicSetStFoll       = decRps->m_refPicSetStFoll      ;
+  std::vector<TComPic*>& refPicSetLtCurr       = decRps->m_refPicSetLtCurr      ;
+  std::vector<TComPic*>& refPicSetLtFoll       = decRps->m_refPicSetLtFoll      ;
+  
+  std::vector<TComPic*>** refPicSetsCurr       = decRps->m_refPicSetsCurr       ;
+  std::vector<TComPic*>** refPicSetsLt         = decRps->m_refPicSetsLt         ;
+  std::vector<TComPic*>** refPicSetsAll        = decRps->m_refPicSetsAll        ;
+  //   NOTE 3 - RefPicSetStCurrBefore, RefPicSetStCurrAfter and RefPicSetLtCurr contain all reference pictures that may be 
+  //   used for inter prediction of the current picture and one or more pictures that follow the current picture in decoding order.
+  //   RefPicSetStFoll and RefPicSetLtFoll consist of all reference pictures that are not used for inter prediction of the current 
+  //   picture but may be used in inter prediction for one or more pictures that follow the current picture in decoding order.
+
+  // The derivation process for the RPS and picture marking are performed according to the following ordered steps:
+  // 1.  The following applies:
+
+  TComSubDpb* dpb = m_dpb->getSubDpb( getLayerId(), false );   
+  assert( refPicSetLtCurr.empty() );
+  for( Int i = 0; i < numPocLtCurr; i++ ) 
+  {
+    if( !currDeltaPocMsbPresentFlag[ i ] ) 
+    {    
+      refPicSetLtCurr.push_back( dpb->getPicFromLsb( pocLtCurr[ i ], maxPicOrderCntLsb ) );       
+    }
+    else
+    {
+      refPicSetLtCurr.push_back(dpb->getPic( pocLtCurr[ i ] ));       
+    }    
+  }
+
+  assert( refPicSetLtFoll.empty() );
+  for( Int i = 0; i < numPocLtFoll; i++ )
+  {
+   if( !follDeltaPocMsbPresentFlag[ i ] )
+   {
+     refPicSetLtFoll.push_back(dpb->getPicFromLsb(pocLtFoll[ i ], maxPicOrderCntLsb ));
+   }
+   else
+   {
+     refPicSetLtFoll.push_back(dpb->getPic( pocLtFoll[ i ] ));       
+   }
+  }
+  
+  // 2.  All reference pictures that are included in RefPicSetLtCurr or RefPicSetLtFoll and have nuh_layer_id equal 
+  //     to currPicLayerId are marked as "used for long-term reference".
+  for (Int i = 0; i < numPocLtCurr; i++)
+  {
+    if ( refPicSetLtCurr[i] != NULL )
+    {
+      refPicSetLtCurr[i]->markAsUsedForLongTermReference(); 
+    }    
+  }
+
+  for (Int i = 0; i < numPocLtFoll; i++)
+  {
+    if ( refPicSetLtFoll[i] != NULL )
+    {
+      refPicSetLtFoll[i]->markAsUsedForLongTermReference(); 
+    }    
+  }
+
+  // 3.  The following applies:
+  assert( refPicSetStCurrBefore.empty() );
+  for( Int i = 0; i < numPocStCurrBefore; i++ )
+  {
+    refPicSetStCurrBefore.push_back(dpb->getShortTermRefPic( pocStCurrBefore[ i ] )); 
+  }
+
+  assert( refPicSetStCurrAfter.empty() );
+  for( Int i = 0; i < numPocStCurrAfter; i++ )
+  {
+    refPicSetStCurrAfter.push_back(dpb->getShortTermRefPic( pocStCurrAfter[ i ] )); 
+  }
+
+  assert( refPicSetStFoll.empty() );
+  for( Int i = 0; i < numPocStFoll; i++ )
+  {
+    refPicSetStFoll.push_back(dpb->getShortTermRefPic( pocStFoll[ i ] )); 
+  }
+  
+  // 4.  All reference pictures in the DPB that are not included in RefPicSetLtCurr, RefPicSetLtFoll, RefPicSetStCurrBefore, 
+  //     RefPicSetStCurrAfter, or RefPicSetStFoll and have nuh_layer_id equal to currPicLayerId are marked as "unused for reference".
+  TComSubDpb picsToMark = (*dpb); 
+  for (Int j = 0; j < 5; j++ )
+  {
+    picsToMark.removePics( *refPicSetsAll[j] ); 
+  }  
+  picsToMark.markAllAsUnusedForReference(); 
+  
+  //     NOTE 4 - There may be one or more entries in the RPS lists that are equal to "no reference picture" because 
+  //     the corresponding pictures are not present in the DPB. Entries in RefPicSetStFoll or RefPicSetLtFoll that are equal 
+  //     to "no reference picture" should be ignored. An unintentional picture loss should be inferred for each entry in 
+  //     RefPicSetStCurrBefore, RefPicSetStCurrAfter, or RefPicSetLtCurr that is equal to "no reference picture".
+
+  //     NOTE 5 - A picture cannot be included in more than one of the five RPS lists.
+
+  
+  // It is a requirement of bitstream conformance that the RPS is restricted as follows:
+
+
+#if NH_MV_FIX_NO_REF_PICS_CHECK
+  if ( !annexFModifications || m_firstPicInLayerDecodedFlag[ m_pcPic->getLayerId() ] )
+  { 
+#endif
+    for (Int j = 0; j < 3; j++ )
+    {
+      // -  There shall be no entry in RefPicSetStCurrBefore, RefPicSetStCurrAfter or RefPicSetLtCurr 
+      //    for which one or more of the following are true:
+
+      std::vector<TComPic*>* currSet = refPicSetsCurr[j]; 
+      for (Int i = 0; i < currSet->size(); i++)
+      {
+        TComPic* pic = (*currSet)[i]; 
+
+        // -  The entry is equal to "no reference picture".
+        assert( ! (pic == NULL ) ); 
+
+        // -  The entry is an SLNR picture and has TemporalId equal to that of the current picture.
+        assert( !( pic->isSlnr() && pic->getTemporalId() == m_pcPic->getTemporalId() ) ); 
+
+        // -  The entry is a picture that has TemporalId greater than that of the current picture.
+        assert( !(  pic->getTemporalId() > m_pcPic->getTemporalId() ) ); 
+      }      
+    }
+#if NH_MV_FIX_NO_REF_PICS_CHECK
+  }
+#endif
+  
+  //  -  There shall be no entry in RefPicSetLtCurr or RefPicSetLtFoll for which the 
+  //     difference between the picture order count value of the current picture and the picture order count 
+  //     value of the entry is greater than or equal to 2^24.
+  for (Int j = 0; j < 2; j++ )
   {    
-    NalUnitType nut = m_apcSlicePilot->getNalUnitType(); 
-
-    Bool isBLA =  ( nut == NAL_UNIT_CODED_SLICE_BLA_W_LP  )  || ( nut == NAL_UNIT_CODED_SLICE_BLA_N_LP ) || ( nut == NAL_UNIT_CODED_SLICE_BLA_W_RADL ); 
-    Bool isIDR  = ( nut == NAL_UNIT_CODED_SLICE_IDR_W_RADL ) || ( nut == NAL_UNIT_CODED_SLICE_IDR_N_LP ); 
-    Bool noClrasOutputFlag  = isBLA || ( isIDR  &&  m_apcSlicePilot->getCrossLayerBlaFlag() ); 
-
-    if ( noClrasOutputFlag ) 
-    {
-      for (Int i = 0; i < MAX_NUM_LAYER_IDS; i++)
-      {
-        m_layerInitilizedFlag[i] = false; 
-      } 
-    }
-  }
-}
-
-Bool TDecTop::xAllRefLayersInitilized( const TComVPS* vps )
-{
-  Bool allRefLayersInitilizedFlag = true;   
-  for (Int i = 0; i < vps->getNumDirectRefLayers( getLayerId()  ); i++ )
-  {
-    Int refLayerId = vps->getIdDirectRefLayer( m_layerId, i ); 
-    allRefLayersInitilizedFlag = allRefLayersInitilizedFlag && m_layerInitilizedFlag[ refLayerId ]; 
-  }
-
-  return allRefLayersInitilizedFlag;
-}
-
-
-Void TDecTop::initFromActiveVps( const TComVPS* vps )
-{
-  if ( m_targetOlsIdx == -1 )
-  {
-    // Not normative! Corresponds to specification by "External Means". (Should be set equal to 0, when no external means available. ) 
-    m_targetOlsIdx = vps->getVpsNumLayerSetsMinus1(); 
-  }
-#if NH_3D
-  // Set profile
-  Int lsIdx = vps->olsIdxToLsIdx( m_targetOlsIdx );
-  Int lIdx = -1; 
-  for (Int j = 0; j < vps->getNumLayersInIdList( lsIdx ); j++ )
-  {
-    if ( vps->getLayerSetLayerIdList( lsIdx, j ) == getLayerId() )
-    {
-      lIdx = j; 
-      break; 
-    }        
-  }
-  assert( lIdx != -1 ); 
-
-  Int profileIdc = vps->getPTL( vps->getProfileTierLevelIdx( m_targetOlsIdx, lIdx ) )->getGeneralPTL()->getProfileIdc();
-  assert( profileIdc == 1 || profileIdc == 6 || profileIdc == 8 ); 
-  m_profileIdc = profileIdc;   
-#endif
-}
+    std::vector<TComPic*>* ltSet = refPicSetsLt[j]; 
+    for (Int i = 0; i < ltSet->size(); i++)
+    {
+      TComPic* pic = (*ltSet)[i]; 
+      if( pic != NULL )
+      {
+        assert(!( abs( m_pcPic->getPOC() - pic->getPOC() ) >= (1 << 24) )); 
+      }
+    }
+  }
+
+  //   -  When the current picture is a temporal sub-layer access (TSA) picture, there shall be no picture 
+  //      included in the RPS with TemporalId greater than or equal to the TemporalId of the current picture.
+  if (m_pcPic->isTsa() )
+  {
+    for (Int j = 0; j < 5; j++ )
+    {    
+      std::vector<TComPic*>* aSet = refPicSetsAll[j]; 
+      for (Int i = 0; i < aSet->size(); i++)
+      {
+        TComPic* pic = (*aSet)[i]; 
+        if( pic != NULL )
+        {
+          assert( ! (pic->getTemporalId() >= m_pcPic->getTemporalId() ) ); 
+        }
+      }
+    }
+  }
+
+  //   -  When the current picture is a step-wise temporal sub-layer access (STSA) picture, 
+  //      there shall be no picture included in RefPicSetStCurrBefore, RefPicSetStCurrAfter or RefPicSetLtCurr that has
+  //      TemporalId equal to that of the current picture.
+  if (m_pcPic->isStsa() )
+  {
+    for (Int j = 0; j < 3; j++ )
+    {    
+      std::vector<TComPic*>* cSet = refPicSetsCurr[j]; 
+      for (Int i = 0; i < cSet->size(); i++)
+      {
+        TComPic* pic = (*cSet)[i]; 
+        if( pic != NULL )
+        {
+          assert( ! (pic->getTemporalId() == m_pcPic->getTemporalId() ) ); 
+        }
+      }
+    }
+  }
+
+  //   -  When the current picture is a picture that follows, in decoding order, an STSA picture
+  //      that has TemporalId equal to that of the current picture, there shall be no picture that has
+  //      TemporalId equal to that of the current picture included in RefPicSetStCurrBefore, RefPicSetStCurrAfter
+  //      or RefPicSetLtCurr that precedes the STSA picture in decoding order.
+  if ( m_pcPic->getDecodingOrder() > m_prevStsaDecOrder && m_pcPic->getTemporalId() == m_prevStsaTemporalId  )
+  {
+    for (Int j = 0; j < 3; j++ )
+    {    
+      std::vector<TComPic*>* cSet = refPicSetsCurr[j]; 
+      for (Int i = 0; i < cSet->size(); i++)
+      {
+        TComPic* pic = (*cSet)[i]; 
+        if( pic != NULL )
+        {
+          assert( ! (pic->getTemporalId() == m_pcPic->getTemporalId() && pic->getDecodingOrder() < m_prevStsaDecOrder  ) ); 
+        }
+      }
+    }
+  }
+  
+  //   -  When the current picture is a CRA picture, there shall be no picture included in the RPS that
+  //      precedes, in output order or decoding order, any preceding IRAP picture in decoding order (when present).
+  if ( m_pcPic->isCra() )
+  {
+    for (Int j = 0; j < 5; j++ )
+    {    
+      std::vector<TComPic*>* aSet = refPicSetsAll[j]; 
+      for (Int i = 0; i < aSet->size(); i++)
+      {
+        // TBD check whether it sufficient to test only the last IRAP
+        TComPic* pic = (*aSet)[i]; 
+        if( pic != NULL )
+        {        
+          assert( ! (pic->getPOC()           < m_prevIrapPoc           ) );           
+          assert( ! (pic->getDecodingOrder() < m_prevIrapDecodingOrder ) ); 
+        }
+      }
+    }
+  }
+  
+  Bool isTrailingPicture = ( !m_pcPic->isIrap() ) && ( m_pcPic->getPOC() > m_prevIrapPoc );
+  //   -  When the current picture is a trailing picture, there shall be no picture in RefPicSetStCurrBefore,
+  //      RefPicSetStCurrAfter or RefPicSetLtCurr that was generated by the decoding process for generating unavailable
+  //      reference pictures as specified in clause 8.3.3.
+  if ( isTrailingPicture )
+  {
+    for (Int j = 0; j < 3; j++ )
+    {    
+      std::vector<TComPic*>* cSet = refPicSetsCurr[j]; 
+      for (Int i = 0; i < cSet->size(); i++)
+      {
+        TComPic* pic = (*cSet)[i]; 
+        if( pic != NULL )
+        {
+          assert( ! (pic->getIsGeneratedCl833() ) ); 
+        }
+      }
+    }
+  }
+
+  //   -  When the current picture is a trailing picture, there shall be no picture in the RPS that precedes the
+  //      associated IRAP picture in output order or decoding order.
+  if ( isTrailingPicture )
+  {
+    for (Int j = 0; j < 5; j++ )
+    {    
+      std::vector<TComPic*>* aSet = refPicSetsAll[j]; 
+      for (Int i = 0; i < aSet->size(); i++)
+      {
+        // TBD check whether it sufficient to test only the last IRAP
+         TComPic* pic = (*aSet)[i]; 
+        if( pic != NULL )
+        {         
+          assert( ! (pic->getPOC()           < m_prevIrapPoc           ) ); 
+          assert( ! (pic->getDecodingOrder() < m_prevIrapDecodingOrder ) ); 
+        }
+      }
+    }
+  }
+
+  //   -  When the current picture is a RADL picture, there shall be no picture included in RefPicSetStCurrBefore,
+  //      RefPicSetStCurrAfter or RefPicSetLtCurr that is any of the following:
+  if ( m_pcPic->isRadl() )
+  {
+    for (Int j = 0; j < 3; j++ )
+    {    
+      std::vector<TComPic*>* cSet = refPicSetsCurr[j]; 
+      for (Int i = 0; i < cSet->size(); i++)
+      {        
+        TComPic* pic = (*cSet)[i]; 
+        if( pic != NULL )
+        {        
+          // -  A RASL picture
+          assert( ! (pic->isRasl() ) ); 
+          // -  A picture that was generated by the decoding process for generating unavailable reference pictures 
+          //    as specified in clause 8.3.3
+          assert( ! (pic->getIsGeneratedCl833() ) ); 
+          // -  A picture that precedes the associated IRAP picture in decoding order
+          assert( ! (pic->getDecodingOrder() < m_prevIrapDecodingOrder ) ); 
+        }
+      }
+    }
+  }
+  
+  
+  if ( sps->getTemporalIdNestingFlag() )
+  {
+    // -  When sps_temporal_id_nesting_flag is equal to 1, the following applies:
+    //    -  Let tIdA be the value of TemporalId of the current picture picA.
+    TComPic* picA = m_pcPic; 
+    Int      tIdA = picA->getTemporalId();
+    //   -  Any picture picB with TemporalId equal to tIdB that is less than or equal to tIdA shall not be included in 
+    //      RefPicSetStCurrBefore, RefPicSetStCurrAfter or RefPicSetLtCurr of picA when there exists a picture picC that 
+    //      has TemporalId less than tIdB, follows picB in decoding order, and precedes picA in decoding order.
+    for (Int j = 0; j < 3; j++ )
+    {    
+      std::vector<TComPic*>* cSet = refPicSetsCurr[j]; 
+      for (Int i = 0; i < cSet->size(); i++)
+      {
+        TComPic* picB = (*cSet)[i]; 
+        if( picB != NULL )
+        {
+          Int tIdB = picB->getTemporalId(); 
+
+          if (tIdB <= tIdA)
+          {
+            for ( TComSubDpb::iterator itP = dpb->begin(); itP != dpb->end(); itP++ )
+            {
+              TComPic* picC = (*itP); 
+              assert(! ( picC->getTemporalId() < tIdB && picC->getDecodingOrder() > picB->getDecodingOrder() && picC->getDecodingOrder() < picA->getDecodingOrder()  )  ); 
+            }
+          }
+        }
+      }
+    }
+  }    
+}
+
+
+Void TDecTop::xF832DecProcForRefPicSet()
+{
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // F.8.3.2 Decoding process for reference picture set
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  // The specifications in clause 8.3.2 apply with the following changes:
+  // -  The references to clauses 7.4.7.2, 8.3.1, 8.3.3 and 8.3.4 are replaced with references to 
+  //    clauses F.7.4.7.2, F.8.3.1, F.8.3.3 and F.8.3.4, respectively.
+
+  x832DecProcForRefPicSet( true ); 
+
+  // -  The following specifications are added:
+  if (m_pcPic->isIrap() && m_pcPic->getLayerId() == m_smallestLayerId )
+  {
+    // -  When the current picture is an IRAP picture with nuh_layer_id equal to SmallestLayerId, 
+    //    all reference pictures with any value of nuh_layer_id currently in the DPB (if any) are marked 
+    //    as "unused for reference" when at least one of the following conditions is true:
+
+    if ( m_pcPic->getNoClrasOutputFlag() || m_pcPic->getActivatesNewVps() )
+    {
+      // -  The current picture has NoClrasOutputFlag is equal to 1.
+      // -  The current picture activates a new VPS.
+      m_dpb->markAllSubDpbAsUnusedForReference( );
+    }
+  }
+
+  // -  It is a requirement of bitstream conformance that the RPS is restricted as follows:
+  // -  When the current picture is a CRA picture, there shall be no picture in RefPicSetStCurrBefore, RefPicSetStCurrAfter 
+  //    or RefPicSetLtCurr.
+
+  std::vector<TComPic*>** refPicSetsCurr       = m_pcPic->getDecodedRps()->m_refPicSetsCurr;
+
+  if ( m_pcPic->isCra() )
+  {
+    for (Int j = 0; j < 3; j++ )   
+    {    
+      std::vector<TComPic*>* cSet = refPicSetsCurr[j]; 
+      assert ( cSet->size() == 0 ); 
+    }
+  }
+
+  // -  The constraints specified in clause 8.3.2 on the value of NumPicTotalCurr are replaced with the following:
+  //    -  It is a requirement of bitstream conformance that the following applies to the value of NumPicTotalCurr:
+  Int numPicTotalCurr = m_pcPic->getSlice(0)->getNumPicTotalCurr(); 
+  Int currPicLayerId  = m_pcPic->getLayerId(); 
+  const TComVPS* vps  = m_pcPic->getSlice(0)->getVPS(); 
+
+  if ( ( m_pcPic->isBla() || m_pcPic->isCra() ) && (  (currPicLayerId == 0 ) || ( vps->getNumDirectRefLayers( currPicLayerId ) == 0 ) ) )
+  {   
+    assert( numPicTotalCurr == 0 ); 
+    // -  If the current picture is a BLA or CRA picture and either currPicLayerId is equal to 0 or 
+    //     NumDirectRefLayers[ currPicLayerId ] is equal to 0, the value of NumPicTotalCurr shall be equal to 0.
+  }
+  else
+  {
+    // TBD: check all slices
+    if ( m_pcPic->getSlice(0)->getSliceType() == P_SLICE  ||  m_pcPic->getSlice(0)->getSliceType() == B_SLICE )
+    {
+      // -  Otherwise, when the current picture contains a P or B slice, the value of NumPicTotalCurr shall not be equal to 0.
+      assert( numPicTotalCurr != 0 ); 
+    }
+  }
+}
+
+
+Void TDecTop::xG813DecProcForInterLayerRefPicSet()
+{
+  ////////////////////////////////////////////////////////////////////
+  // G.8.1.3 Decoding process for inter-layer reference picture set //
+  ////////////////////////////////////////////////////////////////////
+
+  // Outputs of this process are updated lists of inter-layer reference pictures RefPicSetInterLayer0 and RefPicSetInterLayer1 
+  // and the variables NumActiveRefLayerPics0 and NumActiveRefLayerPics1.
+
+  TComDecodedRps* decRps = m_pcPic->getDecodedRps(); 
+  TComSlice* slice       = m_pcPic->getSlice( 0 ); 
+  const TComVPS* vps     =  slice->getVPS(); 
+
+  Int&                   numActiveRefLayerPics0 = decRps->m_numActiveRefLayerPics0;
+  Int&                   numActiveRefLayerPics1 = decRps->m_numActiveRefLayerPics1;
+
+  std::vector<TComPic*>& refPicSetInterLayer0   = decRps->m_refPicSetInterLayer0;
+  std::vector<TComPic*>& refPicSetInterLayer1   = decRps->m_refPicSetInterLayer1; 
+
+  // The variable currLayerId is set equal to nuh_layer_id of the current picture.
+  Int currLayerId = getLayerId(); 
+
+  // The lists RefPicSetInterLayer0 and RefPicSetInterLayer1 are first emptied, NumActiveRefLayerPics0 and NumActiveRefLayerPics1 
+  // are set equal to 0 and the following applies:
+
+  refPicSetInterLayer0.clear(); 
+  refPicSetInterLayer1.clear(); 
+
+  numActiveRefLayerPics0 = 0; 
+  numActiveRefLayerPics1 = 0; 
+
+  Int viewIdCurrLayerId  = vps->getViewId( currLayerId ); 
+  Int viewId0            = vps->getViewId( 0   );
+
+  for( Int i = 0; i < slice->getNumActiveRefLayerPics(); i++ )   
+  {
+    Int viewIdRefPicLayerIdi = vps->getViewId( slice->getRefPicLayerId( i ) ); 
+
+    Bool refPicSet0Flag =
+      ( ( viewIdCurrLayerId <=  viewId0  &&  viewIdCurrLayerId <=  viewIdRefPicLayerIdi )  ||
+      ( viewIdCurrLayerId >=  viewId0  &&  viewIdCurrLayerId >=  viewIdRefPicLayerIdi ) );
+
+    TComPic* picX = m_dpb->getAu(slice->getPOC(), false )->getPic( slice->getRefPicLayerId( i ) );
+    if ( picX != NULL )
+    {
+      // there is a picture picX in the DPB that is in the same access unit as the current picture and has
+      // nuh_layer_id equal to RefPicLayerId[ i ] 
+
+      if ( refPicSet0Flag )
+      {
+        refPicSetInterLayer0.push_back( picX );
+        refPicSetInterLayer0[ numActiveRefLayerPics0++ ]->markAsUsedForLongTermReference();
+      }
+      else
+      {
+        refPicSetInterLayer1.push_back( picX );
+        refPicSetInterLayer1[ numActiveRefLayerPics1++ ]->markAsUsedForLongTermReference();
+      }
+
+      // There shall be no picture that has discardable_flag equal to 1 in RefPicSetInterLayer0 or RefPicSetInterLayer1.
+      assert( ! picX->getSlice(0)->getDiscardableFlag() );
+
+      // If the current picture is a RADL picture, there shall be no entry in RefPicSetInterLayer0 or RefPicSetInterLayer1 
+      // that is a RASL picture.
+      if ( m_pcPic->isRadl() )
+      {
+        assert( ! picX->isRasl() );
+      }
+    }
+    else
+    {
+      if( refPicSet0Flag )
+      {
+        refPicSetInterLayer0.push_back( NULL ); // "no reference picture" (G 1)
+        numActiveRefLayerPics0++;
+      }
+      else
+      {
+        refPicSetInterLayer1.push_back( NULL ); // "no reference picture";
+        numActiveRefLayerPics1++;
+      }
+      // There shall be no entry equal to "no reference picture" in RefPicSetInterLayer0 or RefPicSetInterLayer1.
+      assert( false );
+    }
+  }
+}
+
+
+Void TDecTop::x8331GenDecProcForGenUnavilRefPics()
+{
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // 8.3.3.1  General decoding process for generating unavailable reference pictures ////
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  // This process is invoked once per coded picture when the current picture is a 
+  // BLA picture or is a CRA picture with NoRaslOutputFlag equal to 1.
+
+  assert( m_pcPic->isBla() || (m_pcPic->isCra() && m_pcPic->getNoRaslOutputFlag() ) );
+  TComDecodedRps* decRps = m_pcPic->getDecodedRps(); 
+
+  std::vector<TComPic*>& refPicSetStFoll      = decRps->m_refPicSetStFoll;
+  std::vector<TComPic*>& refPicSetLtFoll      = decRps->m_refPicSetLtFoll; 
+
+  const std::vector<Int>& pocStFoll             = decRps->m_pocStFoll;
+  const std::vector<Int>& pocLtFoll             = decRps->m_pocLtFoll;
+
+  const Int               numPocStFoll          = decRps->m_numPocStFoll;
+  const Int               numPocLtFoll          = decRps->m_numPocLtFoll;   
+
+  // When this process is invoked, the following applies:
+  for ( Int i = 0 ; i <= numPocStFoll - 1; i++ )
+  {
+    if ( refPicSetStFoll[ i ] == NULL )
+    {
+      //-  For each RefPicSetStFoll[ i ], with i in the range of 0 to NumPocStFoll - 1, inclusive, that is equal 
+      //   to "no reference picture", a picture is generated as specified in clause 8.3.3.2, and the following applies:
+      TComPic* genPic = x8332GenOfOneUnavailPic( true );  
+
+      // -  The value of PicOrderCntVal for the generated picture is set equal to PocStFoll[ i ].
+      genPic->getSlice(0)->setPOC( pocStFoll[ i ] );
+
+      //-  The value of PicOutputFlag for the generated picture is set equal to 0.  
+      genPic->setPicOutputFlag( false ); 
+
+      // -  The generated picture is marked as "used for short-term reference".
+      genPic->markAsUsedForShortTermReference();
+
+      // -  RefPicSetStFoll[ i ] is set to be the generated reference picture.
+      refPicSetStFoll[ i ] = genPic;
+
+      // -  The value of nuh_layer_id for the generated picture is set equal to nuh_layer_id of the current picture.
+      genPic->setLayerId( m_pcPic-> getLayerId() ); 
+
+      // Insert to DPB
+      m_dpb->addNewPic( genPic ); 
+    }
+  }
+
+  for ( Int i = 0 ; i <= numPocLtFoll - 1; i++ )
+  {
+    if ( refPicSetLtFoll[ i ] == NULL )
+    {
+      //-  For each RefPicSetLtFoll[ i ], with i in the range of 0 to NumPocLtFoll - 1, inclusive, that is equal to 
+      //   "no reference picture", a picture is generated as specified in clause 8.3.3.2, and the following applies:
+      TComPic* genPic = x8332GenOfOneUnavailPic( true );  
+
+      //-  The value of PicOrderCntVal for the generated picture is set equal to PocLtFoll[ i ].
+      genPic->getSlice(0)->setPOC( pocStFoll[ i ] );
+
+      //  -  The value of slice_pic_order_cnt_lsb for the generated picture is inferred to be equal to ( PocLtFoll[ i ] & ( MaxPicOrderCntLsb - 1 ) ).
+      genPic->getSlice(0)->setSlicePicOrderCntLsb( ( pocLtFoll[ i ] & ( m_pcPic->getSlice(0)->getSPS()->getMaxPicOrderCntLsb() - 1 ) ) ); 
+
+      //  -  The value of PicOutputFlag for the generated picture is set equal to 0.    
+      genPic->setPicOutputFlag( false ); 
+
+      //  -  The generated picture is marked as "used for long-term reference".
+      genPic->markAsUsedForLongTermReference();
+
+      //  -  RefPicSetLtFoll[ i ] is set to be the generated reference picture.
+      refPicSetLtFoll[ i ] = genPic;
+
+      //  -  The value of nuh_layer_id for the generated picture is set equal to nuh_layer_id of the current picture.
+      genPic->setLayerId( m_pcPic-> getLayerId() ); 
+
+      // Insert to DPB
+      m_dpb->addNewPic( genPic ); 
+    }
+  }
+}
+
+
+TComPic* TDecTop::x8332GenOfOneUnavailPic( Bool calledFromCl8331 )
+{
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // 8.3.3.2 Generation of one unavailable picture
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  TComPic* genPic = new TComPic; 
+  genPic->create( *m_pcPic->getSlice(0)->getSPS(), *m_pcPic->getSlice(0)->getPPS(), true ); 
+  genPic->setIsGenerated( true );     
+  genPic->setIsGeneratedCl833( calledFromCl8331 ); 
+  return genPic;
+}
+
+
+Void TDecTop::xF817DecProcForGenUnavRefPicForPicsFrstInDecOrderInLay()
+{
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // F.8.1.7 Decoding process for generating unavailable reference pictures for pictures 
+  //         first in decoding order within a layer
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  //  This process is invoked for a picture with nuh_layer_id equal to layerId, when FirstPicInLayerDecodedFlag[layerId ] is equal to 0.   
+  assert( !m_firstPicInLayerDecodedFlag[ getLayerId() ] );
+
+
+  TComDecodedRps* decRps = m_pcPic->getDecodedRps(); 
+
+  std::vector<TComPic*>& refPicSetStCurrBefore = decRps->m_refPicSetStCurrBefore; 
+  std::vector<TComPic*>& refPicSetStCurrAfter  = decRps->m_refPicSetStCurrAfter;
+  std::vector<TComPic*>& refPicSetStFoll       = decRps->m_refPicSetStFoll;
+  std::vector<TComPic*>& refPicSetLtCurr       = decRps->m_refPicSetLtCurr; 
+  std::vector<TComPic*>& refPicSetLtFoll       = decRps->m_refPicSetLtFoll; 
+
+
+  const std::vector<Int>& pocStCurrBefore      = decRps->m_pocStCurrBefore;
+  const std::vector<Int>& pocStCurrAfter       = decRps->m_pocStCurrAfter;
+  const std::vector<Int>& pocStFoll            = decRps->m_pocStFoll;
+  const std::vector<Int>& pocLtCurr            = decRps->m_pocLtCurr;
+  const std::vector<Int>& pocLtFoll            = decRps->m_pocLtFoll;
+
+  const Int numPocStCurrBefore                 = decRps->m_numPocStCurrBefore; 
+  const Int numPocStCurrAfter                  = decRps->m_numPocStCurrAfter;
+  const Int numPocStFoll                       = decRps->m_numPocStFoll;
+  const Int numPocLtCurr                       = decRps->m_numPocLtCurr;
+  const Int numPocLtFoll                       = decRps->m_numPocLtFoll;   
+
+  Int nuhLayerId = m_pcPic-> getLayerId(); 
+  for ( Int i = 0 ; i <= numPocStCurrBefore - 1; i++ )
+  {
+    if ( refPicSetStCurrBefore[ i ] == NULL )
+    {
+      //-  For each RefPicSetStCurrBefore[ i ], with i in the range of 0 to NumPocStCurrBefore - 1, inclusive, that is 
+      //  equal to "no reference picture", a picture is generated as specified in clause 8.3.3.2 and the following applies:
+      TComPic* genPic = x8332GenOfOneUnavailPic( false );  
+
+      //-  The value of PicOrderCntVal for the generated picture is set equal to PocStCurrBefore[ i ].
+      genPic->getSlice(0)->setPOC( pocStCurrBefore[ i ] );
+
+      //  -  The value of PicOutputFlag for the generated picture is set equal to 0.
+      genPic->setPicOutputFlag( false ); 
+
+      //  -  The generated picture is marked as "used for short-term reference".
+      genPic->markAsUsedForShortTermReference();
+
+      //  -  RefPicSetStCurrBefore[ i ] is set to be the generated reference picture.
+      refPicSetStCurrBefore[ i ] = genPic;
+
+      //  -  The value of nuh_layer_id for the generated picture is set equal to nuh_layer_id.
+      genPic->setLayerId( nuhLayerId ); 
+
+      // Insert to DPB
+      m_dpb->addNewPic( genPic ); 
+    }
+  }
+
+  for ( Int i = 0 ; i <= numPocStCurrAfter - 1; i++ )
+  {
+    if ( refPicSetStCurrAfter[ i ] == NULL )
+    {
+      //  -  For each RefPicSetStCurrAfter[ i ], with i in the range of 0 to NumPocStCurrAfter - 1, inclusive, that is equal 
+      //     to "no reference picture", a picture is generated as specified in clause 8.3.3.2 and the following applies:
+      TComPic* genPic = x8332GenOfOneUnavailPic( false );  
+
+      //  -  The value of PicOrderCntVal for the generated picture is set equal to PocStCurrAfter[ i ].
+      genPic->getSlice(0)->setPOC( pocStCurrAfter[ i ] );
+
+      //  -  The value of PicOutputFlag for the generated picture is set equal to 0.
+      genPic->setPicOutputFlag( false ); 
+
+      //  -  The generated picture is marked as "used for short-term reference".
+      genPic->markAsUsedForShortTermReference();
+
+      //  -  RefPicSetStCurrAfter[ i ] is set to be the generated reference picture.
+      refPicSetStCurrAfter[ i ] = genPic;
+
+      //  -  The value of nuh_layer_id for the generated picture is set equal to nuh_layer_id.
+      genPic->setLayerId( nuhLayerId ); 
+
+      // Insert to DPB
+      m_dpb->addNewPic( genPic ); 
+
+    }
+  }
+
+  for ( Int i = 0 ; i <= numPocStFoll - 1; i++ )
+  {
+    if ( refPicSetStFoll[ i ] == NULL )
+    {
+      //  -  For each RefPicSetStFoll[ i ], with i in the range of 0 to NumPocStFoll - 1, inclusive, that is equal to "no 
+      //     reference picture", a picture is generated as specified in clause 8.3.3.2 and the following applies:
+      TComPic* genPic = x8332GenOfOneUnavailPic( false );  
+
+      //  -  The value of PicOrderCntVal for the generated picture is set equal to PocStFoll[ i ].
+      genPic->getSlice(0)->setPOC( pocStFoll[ i ] );
+
+      //  -  The value of PicOutputFlag for the generated picture is set equal to 0.
+      genPic->setPicOutputFlag( false ); 
+
+      //  -  The generated picture is marked as "used for short-term reference".
+      genPic->markAsUsedForShortTermReference();
+
+      //  -  RefPicSetStFoll[ i ] is set to be the generated reference picture.
+      refPicSetStFoll[ i ] = genPic;
+
+      //  -  The value of nuh_layer_id for the generated picture is set equal to nuh_layer_id.
+      genPic->setLayerId( nuhLayerId ); 
+
+      // Insert to DPB
+      m_dpb->addNewPic( genPic ); 
+    }
+  }
+
+  Int maxPicOrderCntLsb = m_pcPic->getSlice(0)->getSPS()->getMaxPicOrderCntLsb();  
+  for ( Int i = 0 ; i <= numPocLtCurr - 1; i++ )
+  {
+    if ( refPicSetLtCurr[ i ] == NULL )
+    {
+      //  -  For each RefPicSetLtCurr[ i ], with i in the range of 0 to NumPocLtCurr - 1, inclusive, that is equal to "no 
+      //     reference picture", a picture is generated as specified in clause 8.3.3.2 and the following applies:
+      TComPic* genPic = x8332GenOfOneUnavailPic( false );  
+
+      //  -  The value of PicOrderCntVal for the generated picture is set equal to PocLtCurr[ i ].
+      genPic->getSlice(0)->setPOC( pocLtCurr[ i ] );
+
+      //  -  The value of slice_pic_order_cnt_lsb for the generated picture is inferred to be equal to ( PocLtCurr[ i ] & ( 
+      //     MaxPicOrderCntLsb - 1 ) ).
+      genPic->getSlice(0)->setSlicePicOrderCntLsb( ( pocLtCurr[ i ] & ( maxPicOrderCntLsb - 1 ) ) ); 
+
+      //  -  The value of PicOutputFlag for the generated picture is set equal to 0.
+      genPic->setPicOutputFlag( false ); 
+
+      //  -  The generated picture is marked as "used for long-term reference".
+      genPic->markAsUsedForLongTermReference();
+
+      //  -  RefPicSetLtCurr[ i ] is set to be the generated reference picture.
+      refPicSetLtCurr[ i ] = genPic;
+
+      //  -  The value of nuh_layer_id for the generated picture is set equal to nuh_layer_id.
+      genPic->setLayerId( nuhLayerId ); 
+
+      // Insert to DPB
+      m_dpb->addNewPic( genPic ); 
+    }
+  }
+
+  for ( Int i = 0 ; i <= numPocLtFoll - 1; i++ )
+  {
+    if ( refPicSetLtFoll[ i ] == NULL )
+    {
+      //  -  For each RefPicSetLtFoll[ i ], with i in the range of 0 to NumPocLtFoll - 1, inclusive, that is equal to "no 
+      //     reference picture", a picture is generated as specified in clause 8.3.3.2 and the following applies:
+      TComPic* genPic = x8332GenOfOneUnavailPic( false );  
+
+      //  -  The value of PicOrderCntVal for the generated picture is set equal to PocLtFoll[ i ].
+      genPic->getSlice(0)->setPOC( pocLtFoll[ i ] );
+
+      //  -  The value of slice_pic_order_cnt_lsb for the generated picture is inferred to be equal to ( PocLtCurr[ i ] & ( 
+      //     MaxPicOrderCntLsb - 1 ) ).
+      genPic->getSlice(0)->setSlicePicOrderCntLsb( ( pocLtCurr[ i ] & ( maxPicOrderCntLsb - 1 ) ) ); 
+
+      //  -  The value of PicOutputFlag for the generated picture is set equal to 0.
+      genPic->setPicOutputFlag( false ); 
+
+      //  -  The generated picture is marked as "used for long-term reference".
+      genPic->markAsUsedForLongTermReference();
+
+      //  -  RefPicSetLtFoll[ i ] is set to be the generated reference picture.
+      refPicSetLtFoll[ i ] = genPic;
+
+      //  -  The value of nuh_layer_id for the generated picture is set equal to nuh_layer_id.
+      genPic->setLayerId( nuhLayerId ); 
+
+      // Insert to DPB
+      m_dpb->addNewPic( genPic ); 
+    }
+  }
+}
+
+Void TDecTop::xF833DecProcForGenUnavRefPics()
+{
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // F.8.3.3 Decoding process for generating unavailable reference picture
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  x8331GenDecProcForGenUnavilRefPics();
+}
+
+Void TDecTop::xCheckUnavailableRefPics()
+{
+  std::vector<TComPic*>** refPicSetsCurr       = m_pcPic->getDecodedRps()->m_refPicSetsCurr;
+
+  Bool hasGeneratedRefPic = false; 
+  for (Int j = 0; j < 3; j++ )   
+  {    
+    std::vector<TComPic*>* cSet = refPicSetsCurr[j]; 
+    for (Int i = 0 ; i < cSet->size();  i++ )
+    {
+      assert( (*cSet)[i] != NULL );
+      if ((*cSet)[i]->getIsGenerated() )
+      {
+        hasGeneratedRefPic = true; 
+      }
+    }
+  }
+  m_pcPic->setHasGeneratedRefPics( hasGeneratedRefPic ); 
+}
+
 #endif