Changeset 1321 in 3DVCSoftware for trunk/source/Lib/TLibDecoder

Timestamp:

7 Sep 2015, 18:16:33 (9 years ago)

Author:

tech

Message:

Merged 15.0-dev0@1320.

Location:

trunk/source/Lib/TLibDecoder

Files:

• TDecCAVLC.cpp (modified) (20 diffs)
• TDecCAVLC.h (modified) (2 diffs)
• TDecCu.cpp (modified) (4 diffs)
• TDecEntropy.cpp (modified) (2 diffs)
• TDecEntropy.h (modified) (2 diffs)
• TDecSbac.h (modified) (1 diff)
• TDecTop.cpp (modified) (46 diffs)
• TDecTop.h (modified) (5 diffs)

trunk/source/Lib/TLibDecoder/TDecCAVLC.cpp

@@ -66 +66 @@
   fprintf( g_hTrace, "=========== Picture Parameter Set  ===========\n");
 }
+
+Void  xTraceSliceHeader ()
+{
+  fprintf( g_hTrace, "=========== Slice ===========\n");
+}
+
 #endif
 #endif
@@ -85 +91 @@
 // ====================================================================================================================
 
+#if NH_MV
+Void TDecCavlc::parseShortTermRefPicSet( TComSPS* sps, TComStRefPicSet* stRps, Int stRpsIdx )
+{
+  UInt uiCode;  
+  if( stRpsIdx  !=  0 )
+  {
+    READ_FLAG( uiCode, "inter_ref_pic_set_prediction_flag" ); stRps->setInterRefPicSetPredictionFlag( uiCode == 1 );
+  }
+  if( stRps->getInterRefPicSetPredictionFlag() )
+  {
+    if( stRpsIdx  ==  sps->getNumShortTermRefPicSets() )
+    {
+      READ_UVLC( uiCode, "delta_idx_minus1" ); stRps->setDeltaIdxMinus1( uiCode );
+    }
+    READ_FLAG( uiCode, "delta_rps_sign" ); stRps->setDeltaRpsSign( uiCode == 1 );
+    READ_UVLC( uiCode, "abs_delta_rps_minus1" ); stRps->setAbsDeltaRpsMinus1( uiCode );
+    for( Int j = 0; j  <=  sps->getStRefPicSet( stRps->getRefRpsIdx( stRpsIdx ) )->getNumDeltaPocs() ; j++ )
+    {
+      READ_FLAG( uiCode, "used_by_curr_pic_flag" ); stRps->setUsedByCurrPicFlag( j, uiCode == 1 );
+      if( !stRps->getUsedByCurrPicFlag( j ) )
+      {
+        READ_FLAG( uiCode, "use_delta_flag" ); stRps->setUseDeltaFlag( j, uiCode == 1 );
+      }
+    }
+  }
+  else
+  {
+    READ_UVLC( uiCode, "num_negative_pics" ); stRps->setNumNegativePics( uiCode );
+    READ_UVLC( uiCode, "num_positive_pics" ); stRps->setNumPositivePics( uiCode );
+    for( Int i = 0; i < stRps->getNumNegativePics( ); i++ )
+    {
+      READ_UVLC( uiCode, "delta_poc_s0_minus1" ); stRps->setDeltaPocS0Minus1( i, uiCode );
+      READ_FLAG( uiCode, "used_by_curr_pic_s0_flag" ); stRps->setUsedByCurrPicS0Flag( i, uiCode == 1 );
+    }
+    for( Int i = 0; i < stRps->getNumPositivePics( ); i++ )
+    {
+      READ_UVLC( uiCode, "delta_poc_s1_minus1" ); stRps->setDeltaPocS1Minus1( i, uiCode );
+      READ_FLAG( uiCode, "used_by_curr_pic_s1_flag" ); stRps->setUsedByCurrPicS1Flag( i, uiCode == 1 );
+    }
+  }
+  stRps->inferRps( stRpsIdx, sps, false );
+}
+#else
 Void TDecCavlc::parseShortTermRefPicSet( TComSPS* sps, TComReferencePictureSet* rps, Int idx )
 {
@@ -180 +229 @@
 #endif
 }
+#endif
 
 Void TDecCavlc::parsePPS(TComPPS* pcPPS)
@@ -507 +557 @@
   {
     READ_CODE(6, uiCode, "pps_depth_layers_minus1");
-#if NH_3D_VER141_DEC_COMP_FLAG
-    pcDLT->setNumDepthViews( uiCode );
-#else
     pcDLT->setNumDepthViews( uiCode+1 );
-#endif
     
     READ_CODE(4, uiCode, "pps_bit_depth_for_depth_layers_minus8");
     pcDLT->setDepthViewBitDepth( (uiCode+8) );
     
-#if NH_3D_DLT_FIX
     for( Int i = 0; i <= pcDLT->getNumDepthViews()-1; i++ )
-#else
-    for( Int i = 0; i <= pcDLT->getNumDepthViews(); i++ )
-#endif
     {
       Int layerId = pcDLT->getDepthIdxToLayerId(i);
@@ -866 +908 @@
 #if NH_MV
     pcSPS->getPTL()->inferGeneralValues ( true, 0, NULL ); 
-    pcSPS->getPTL()->inferSubLayerValues( pcSPS->getMaxTLayers() - 1, 0, NULL );
+    pcSPS->getPTL()->inferSubLayerValues( pcSPS->getSpsMaxSubLayersMinus1(), 0, NULL );
   }
 #endif
@@ -972 +1014 @@
     pcSPS->setNumReorderPics(uiCode, i);
     READ_UVLC ( uiCode, "sps_max_latency_increase_plus1[i]");
+#if NH_MV
+    pcSPS->setSpsMaxLatencyIncreasePlus1( uiCode, i );
+#else
     pcSPS->setMaxLatencyIncrease( uiCode, i );
+#endif
 
     if (!subLayerOrderingInfoPresentFlag)
@@ -980 +1026 @@
         pcSPS->setMaxDecPicBuffering(pcSPS->getMaxDecPicBuffering(0), i);
         pcSPS->setNumReorderPics(pcSPS->getNumReorderPics(0), i);
+#if NH_MV
+        pcSPS->setSpsMaxLatencyIncreasePlus1(pcSPS->getSpsMaxLatencyIncreasePlus1(0), i);
+#else
         pcSPS->setMaxLatencyIncrease(pcSPS->getMaxLatencyIncrease(0), i);
+#endif
       }
       break;
@@ -1053 +1103 @@
 
   READ_UVLC( uiCode, "num_short_term_ref_pic_sets" );
+
   assert(uiCode <= 64);
+#if NH_MV
+  pcSPS->setNumShortTermRefPicSets( uiCode );  
+  pcSPS->initStRefPicSets();
+
+  for(Int i=0; i< pcSPS->getNumShortTermRefPicSets(); i++ )
+  {
+    parseShortTermRefPicSet(pcSPS,pcSPS->getStRefPicSet(i),i);
+  }
+
+  READ_FLAG( uiCode, "long_term_ref_pics_present_flag" );          pcSPS->setLongTermRefPicsPresentFlag(uiCode);
+  if (pcSPS->getLongTermRefPicsPresentFlag() )
+#else
   pcSPS->createRPSList(uiCode);
 
@@ -1064 +1127 @@
     parseShortTermRefPicSet(pcSPS,rps,i);
   }
+
   READ_FLAG( uiCode, "long_term_ref_pics_present_flag" );          pcSPS->setLongTermRefsPresent(uiCode);
   if (pcSPS->getLongTermRefsPresent())
+#endif
   {
     READ_UVLC( uiCode, "num_long_term_ref_pics_sps" );
@@ -2149 +2214 @@
 #endif
 
+#if NH_MV
+Void TDecCavlc::parseFirstSliceSegmentInPicFlag(TComSlice* pcSlice )
+{
+#if ENC_DEC_TRACE
+#if NH_MV
+  tracePSHeader( "Slice", pcSlice->getLayerId() ); 
+#else
+  xTraceSliceHeader();
+#endif
+#endif
+
+  UInt uiCode;
+  READ_FLAG( uiCode, "first_slice_segment_in_pic_flag" );
+  pcSlice->setFirstSliceSegementInPicFlag( uiCode ); 
+}
+
+Void TDecCavlc::parseSliceHeader (TComSlice* pcSlice, ParameterSetManager *parameterSetManager )
+#else
 Void TDecCavlc::parseSliceHeader (TComSlice* pcSlice, ParameterSetManager *parameterSetManager, const Int prevTid0POC)
+#endif
 {
   UInt  uiCode;
   Int   iCode;
 
+#if !NH_MV
 #if ENC_DEC_TRACE
-#if NH_MV
-  tracePSHeader( "Slice", pcSlice->getLayerId() ); 
-#else
   xTraceSliceHeader();
 #endif
@@ -2167 +2249 @@
 #endif
 
+#if NH_MV
+  // This has been parsed before in parseFirstSliceSegmentFlag(TComSlice* pcSlice )
+  UInt firstSliceSegmentInPic = pcSlice->getFirstSliceSegementInPicFlag();   
+#else
   UInt firstSliceSegmentInPic;
   READ_FLAG( firstSliceSegmentInPic, "first_slice_segment_in_pic_flag" );
+#endif
   if( pcSlice->getRapPicFlag())
   {
@@ -2184 +2271 @@
   vps = parameterSetManager->getVPS(sps->getVPSId());
   assert( vps != NULL );  
+  
   m_decTop->initFromActiveVps( vps );
+  
+  if ( !m_decTop->getIsInOwnTargetDecLayerIdList() )
+  {
+    return; 
+  }
+
+  pcSlice->setDecodingProcess( m_decTop->getDecodingProcess() ); 
   Int targetOlsIdx = m_decTop->getTargetOlsIdx(); 
 
@@ -2241 +2336 @@
   pcSlice->setSliceSegmentCurStartCtuTsAddr( sliceSegmentAddress );// this is actually a Raster-Scan (RS) address, but we do not have the RS->TS conversion table defined yet.
   pcSlice->setSliceSegmentCurEndCtuTsAddr(numCTUs);                // Set end as the last CTU of the picture.
-
-#if NH_MV
-    UInt slicePicOrderCntLsb = 0;
-#endif
 
 
@@ -2303 +2394 @@
 
 #if NH_MV
-    Int iPOClsb = slicePicOrderCntLsb;  // Needed later
     if ( (pcSlice->getLayerId() > 0 && !vps->getPocLsbNotPresentFlag( pcSlice->getLayerIdInVps())) || !pcSlice->getIdrPicFlag() )
     {
-      READ_CODE(sps->getBitsForPOC(), slicePicOrderCntLsb, "slice_pic_order_cnt_lsb");        
-    }    
-    pcSlice->setSlicePicOrderCntLsb( slicePicOrderCntLsb ); 
-
-    Bool picOrderCntMSBZeroFlag = false;     
-
-    // as in HM code. However are all cases for IRAP picture with NoRaslOutputFlag equal to 1 covered??
-    picOrderCntMSBZeroFlag = picOrderCntMSBZeroFlag || ( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP   ); 
-    picOrderCntMSBZeroFlag = picOrderCntMSBZeroFlag || ( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL ); 
-    picOrderCntMSBZeroFlag = picOrderCntMSBZeroFlag || ( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP   ); 
-    picOrderCntMSBZeroFlag = picOrderCntMSBZeroFlag ||   pcSlice->getIdrPicFlag(); 
-
-    // TBD picOrderCntMSBZeroFlag = picOrderCntMSBZeroFlag || ( rpcSlice->getLayerId() > 0 &&   !rpcSlice->getFirstPicInLayerDecodedFlag() ); 
-
-    Int picOrderCntMSB = 0; 
-
-    if ( !picOrderCntMSBZeroFlag )
-    {
-      Int prevPicOrderCnt    = prevTid0POC;
-      Int maxPicOrderCntLsb  = 1 << sps->getBitsForPOC();
-      Int prevPicOrderCntLsb = prevPicOrderCnt & (maxPicOrderCntLsb - 1);
-      Int prevPicOrderCntMsb = prevPicOrderCnt - prevPicOrderCntLsb;
-            
-      if( ( slicePicOrderCntLsb  <  prevPicOrderCntLsb ) && ( ( prevPicOrderCntLsb - slicePicOrderCntLsb )  >=  ( maxPicOrderCntLsb / 2 ) ) )
-      {
-        picOrderCntMSB = prevPicOrderCntMsb + maxPicOrderCntLsb;
-      }
-      else if( (slicePicOrderCntLsb  >  prevPicOrderCntLsb )  && ( (slicePicOrderCntLsb - prevPicOrderCntLsb )  >  ( maxPicOrderCntLsb / 2 ) ) ) 
-      {
-        picOrderCntMSB = prevPicOrderCntMsb - maxPicOrderCntLsb;
-      }
-      else
-      {
-        picOrderCntMSB = prevPicOrderCntMsb;
-      }   
-    }
-      
-    pcSlice->setPOC( picOrderCntMSB + slicePicOrderCntLsb );
-    if ( pcSlice->getPocResetFlag() )  
-    {
-      pcSlice->setPocBeforeReset   ( pcSlice->getPOC() ); 
-      pcSlice->setPOC              ( 0 );
-    }      
-#endif
-
-    if( pcSlice->getIdrPicFlag() )
-    {
-#if !NH_MV
-      pcSlice->setPOC(0);
-#endif
-      TComReferencePictureSet* rps = pcSlice->getLocalRPS();
-      (*rps)=TComReferencePictureSet();
-      pcSlice->setRPS(rps);
-#if NH_MV
-      pcSlice->setEnableTMVPFlag(false);
-#endif
-    }
+      READ_CODE(sps->getBitsForPOC(), uiCode, "slice_pic_order_cnt_lsb"); pcSlice->setSlicePicOrderCntLsb( uiCode );
+    } 
     else
     {
-#if !NH_MV
-      READ_CODE(sps->getBitsForPOC(), uiCode, "slice_pic_order_cnt_lsb");
-      Int iPOClsb = uiCode;
-      Int iPrevPOC = prevTid0POC;
-      Int iMaxPOClsb = 1<< sps->getBitsForPOC();
-      Int iPrevPOClsb = iPrevPOC & (iMaxPOClsb - 1);
-      Int iPrevPOCmsb = iPrevPOC-iPrevPOClsb;
-      Int iPOCmsb;
-      if( ( iPOClsb  <  iPrevPOClsb ) && ( ( iPrevPOClsb - iPOClsb )  >=  ( iMaxPOClsb / 2 ) ) )
-      {
-        iPOCmsb = iPrevPOCmsb + iMaxPOClsb;
-      }
-      else if( (iPOClsb  >  iPrevPOClsb )  && ( (iPOClsb - iPrevPOClsb )  >  ( iMaxPOClsb / 2 ) ) )
-      {
-        iPOCmsb = iPrevPOCmsb - iMaxPOClsb;
-      }
-      else
-      {
-        iPOCmsb = iPrevPOCmsb;
-      }
-      if ( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
-        || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
-        || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
-      {
-        // For BLA picture types, POCmsb is set to 0.
-        iPOCmsb = 0;
-      }
-      pcSlice->setPOC              (iPOCmsb+iPOClsb);
-#endif
-      TComReferencePictureSet* rps;
-      rps = pcSlice->getLocalRPS();
-      (*rps)=TComReferencePictureSet();
-
-      pcSlice->setRPS(rps);
-      READ_FLAG( uiCode, "short_term_ref_pic_set_sps_flag" );
-      if(uiCode == 0) // use short-term reference picture set explicitly signalled in slice header
-      {
-        parseShortTermRefPicSet(sps,rps, sps->getRPSList()->getNumberOfReferencePictureSets());
-#if NH_MV
-        if ( !rps->getInterRPSPrediction( ) )
-        { // check sum of num_positive_pics and num_negative_pics
-          rps->checkMaxNumPics( 
-            vps->getVpsExtensionFlag(), 
-            MAX_INT,  // To be replaced by MaxDbpSize
-            pcSlice->getLayerId(), 
-            sps->getMaxDecPicBuffering( sps->getSpsMaxSubLayersMinus1() ) - 1 );
-        }
-#endif
-
-      }
-      else // use reference to short-term reference picture set in PPS
-      {
-        Int numBits = 0;
-        while ((1 << numBits) < sps->getRPSList()->getNumberOfReferencePictureSets())
-        {
-          numBits++;
-        }
-        if (numBits > 0)
-        {
-          READ_CODE( numBits, uiCode, "short_term_ref_pic_set_idx");
-        }
-        else
-        {
-          uiCode = 0;
-       
-        }
-        *rps = *(sps->getRPSList()->getReferencePictureSet(uiCode));
-      }
-      if(sps->getLongTermRefsPresent())
-      {
-        Int offset = rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures();
-        UInt numOfLtrp = 0;
-        UInt numLtrpInSPS = 0;
-        if (sps->getNumLongTermRefPicSPS() > 0)
-        {
-          READ_UVLC( uiCode, "num_long_term_sps");
-          numLtrpInSPS = uiCode;
-          numOfLtrp += numLtrpInSPS;
-          rps->setNumberOfLongtermPictures(numOfLtrp);
-        }
-        Int bitsForLtrpInSPS = 0;
-        while (sps->getNumLongTermRefPicSPS() > (1 << bitsForLtrpInSPS))
-        {
-          bitsForLtrpInSPS++;
-        }
-        READ_UVLC( uiCode, "num_long_term_pics");             rps->setNumberOfLongtermPictures(uiCode);
-        numOfLtrp += uiCode;
-        rps->setNumberOfLongtermPictures(numOfLtrp);
-        Int maxPicOrderCntLSB = 1 << sps->getBitsForPOC();
-        Int prevDeltaMSB = 0, deltaPocMSBCycleLT = 0;
-        for(Int j=offset+rps->getNumberOfLongtermPictures()-1, k = 0; k < numOfLtrp; j--, k++)
-        {
-          Int pocLsbLt;
-          if (k < numLtrpInSPS)
+      pcSlice->setSlicePicOrderCntLsb( 0 );
+    }
+
+    if( pcSlice->getNalUnitType()  != NAL_UNIT_CODED_SLICE_IDR_W_RADL  &&  pcSlice->getNalUnitType() !=  NAL_UNIT_CODED_SLICE_IDR_N_LP )
+    {      
+      READ_FLAG( uiCode, "short_term_ref_pic_set_sps_flag" ); pcSlice->setShortTermRefPicSetSpsFlag( uiCode == 1 );
+      if( !pcSlice->getShortTermRefPicSetSpsFlag() )
+      {
+        parseShortTermRefPicSet( sps, pcSlice->getLocalStRps( ), sps->getNumShortTermRefPicSets() );
+      }
+      else if( sps->getNumShortTermRefPicSets() > 1 )
+      {
+        READ_CODE( pcSlice->getShortTermRefPicSetIdxLen() , uiCode, "short_term_ref_pic_set_idx" ); pcSlice->setShortTermRefPicSetIdx( uiCode );
+      }
+      if( sps->getLongTermRefPicsPresentFlag() )
+      {
+        if( sps->getNumLongTermRefPicsSps() > 0 )
+        {
+          READ_UVLC( uiCode, "num_long_term_sps" ); pcSlice->setNumLongTermSps( uiCode );
+        }
+        READ_UVLC( uiCode, "num_long_term_pics" ); pcSlice->setNumLongTermPics( uiCode );
+        for( Int i = 0; i < pcSlice->getNumLongTermSps() + pcSlice->getNumLongTermPics( ); i++ )
+        {
+          if( i < pcSlice->getNumLongTermSps() )
           {
-            uiCode = 0;
-            if (bitsForLtrpInSPS > 0)
+            if( sps->getNumLongTermRefPicsSps() > 1 )
             {
-              READ_CODE(bitsForLtrpInSPS, uiCode, "lt_idx_sps[i]");
+              READ_CODE( pcSlice->getLtIdxSpsLen() , uiCode, "lt_idx_sps" ); pcSlice->setLtIdxSps( i, uiCode );
             }
-            Bool usedByCurrFromSPS=sps->getUsedByCurrPicLtSPSFlag(uiCode);
-
-            pocLsbLt = sps->getLtRefPicPocLsbSps(uiCode);
-            rps->setUsed(j,usedByCurrFromSPS);
           }
           else
           {
-            READ_CODE(sps->getBitsForPOC(), uiCode, "poc_lsb_lt"); pocLsbLt= uiCode;
-            READ_FLAG( uiCode, "used_by_curr_pic_lt_flag");     rps->setUsed(j,uiCode);
+            READ_CODE( pcSlice->getPocLsbLtLen() , uiCode, "poc_lsb_lt" ); pcSlice->setPocLsbLt( i, uiCode );
+            READ_FLAG( uiCode, "used_by_curr_pic_lt_flag" ); pcSlice->setUsedByCurrPicLtFlag( i, uiCode == 1 );
           }
-          READ_FLAG(uiCode,"delta_poc_msb_present_flag");
-          Bool mSBPresentFlag = uiCode ? true : false;
-          if(mSBPresentFlag)
+          READ_FLAG( uiCode, "delta_poc_msb_present_flag" ); pcSlice->setDeltaPocMsbPresentFlag( i, uiCode == 1 );
+          if( pcSlice->getDeltaPocMsbPresentFlag( i ) )
           {
-            READ_UVLC( uiCode, "delta_poc_msb_cycle_lt[i]" );
-            Bool deltaFlag = false;
-            //            First LTRP                               || First LTRP from SH
-            if( (j == offset+rps->getNumberOfLongtermPictures()-1) || (j == offset+(numOfLtrp-numLtrpInSPS)-1) )
-            {
-              deltaFlag = true;
-            }
-            if(deltaFlag)
-            {
-              deltaPocMSBCycleLT = uiCode;
-            }
-            else
-            {
-              deltaPocMSBCycleLT = uiCode + prevDeltaMSB;
-            }
-
-            Int pocLTCurr = pcSlice->getPOC() - deltaPocMSBCycleLT * maxPicOrderCntLSB
-                                        - iPOClsb + pocLsbLt;
-            rps->setPOC     (j, pocLTCurr);
-            rps->setDeltaPOC(j, - pcSlice->getPOC() + pocLTCurr);
-            rps->setCheckLTMSBPresent(j,true);
+            READ_UVLC( uiCode, "delta_poc_msb_cycle_lt" ); pcSlice->setDeltaPocMsbCycleLt( i, uiCode );
           }
-          else
-          {
+        }
+      }
+      if( sps->getSpsTemporalMvpEnabledFlag() )
+      {
+        READ_FLAG( uiCode, "slice_temporal_mvp_enabled_flag" ); pcSlice->setSliceTemporalMvpEnabledFlag( uiCode == 1 );
+      }
+    }
+#else
+if( pcSlice->getIdrPicFlag() )
+{
+  pcSlice->setPOC(0);
+  TComReferencePictureSet* rps = pcSlice->getLocalRPS();
+  (*rps)=TComReferencePictureSet();
+  pcSlice->setRPS(rps);
+}
+else
+{
+  READ_CODE(sps->getBitsForPOC(), uiCode, "slice_pic_order_cnt_lsb");
+  Int iPOClsb = uiCode;
+  Int iPrevPOC = prevTid0POC;
+  Int iMaxPOClsb = 1<< sps->getBitsForPOC();
+  Int iPrevPOClsb = iPrevPOC & (iMaxPOClsb - 1);
+  Int iPrevPOCmsb = iPrevPOC-iPrevPOClsb;
+  Int iPOCmsb;
+  if( ( iPOClsb  <  iPrevPOClsb ) && ( ( iPrevPOClsb - iPOClsb )  >=  ( iMaxPOClsb / 2 ) ) )
+  {
+    iPOCmsb = iPrevPOCmsb + iMaxPOClsb;
+  }
+  else if( (iPOClsb  >  iPrevPOClsb )  && ( (iPOClsb - iPrevPOClsb )  >  ( iMaxPOClsb / 2 ) ) )
+  {
+    iPOCmsb = iPrevPOCmsb - iMaxPOClsb;
+  }
+  else
+  {
+    iPOCmsb = iPrevPOCmsb;
+  }
+  if ( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
+    || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
+    || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
+  {
+    // For BLA picture types, POCmsb is set to 0.
+    iPOCmsb = 0;
+  }
+  pcSlice->setPOC              (iPOCmsb+iPOClsb);
+
+  TComReferencePictureSet* rps;
+  rps = pcSlice->getLocalRPS();
+  (*rps)=TComReferencePictureSet();
+
+  pcSlice->setRPS(rps);
+  READ_FLAG( uiCode, "short_term_ref_pic_set_sps_flag" );
+  if(uiCode == 0) // use short-term reference picture set explicitly signalled in slice header
+  {
+    parseShortTermRefPicSet(sps,rps, sps->getRPSList()->getNumberOfReferencePictureSets());
+  }
+  else // use reference to short-term reference picture set in PPS
+  {
+    Int numBits = 0;
+    while ((1 << numBits) < sps->getRPSList()->getNumberOfReferencePictureSets())
+    {
+      numBits++;
+    }
+    if (numBits > 0)
+    {
+      READ_CODE( numBits, uiCode, "short_term_ref_pic_set_idx");
+    }
+    else
+    {
+      uiCode = 0;       
+    }
+    *rps = *(sps->getRPSList()->getReferencePictureSet(uiCode));
+  }
+  if(sps->getLongTermRefsPresent())
+  {
+    Int offset = rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures();
+    UInt numOfLtrp = 0;
+    UInt numLtrpInSPS = 0;
+    if (sps->getNumLongTermRefPicSPS() > 0)
+    {
+      READ_UVLC( uiCode, "num_long_term_sps");
+      numLtrpInSPS = uiCode;
+      numOfLtrp += numLtrpInSPS;
+      rps->setNumberOfLongtermPictures(numOfLtrp);
+    }
+    Int bitsForLtrpInSPS = 0;
+    while (sps->getNumLongTermRefPicSPS() > (1 << bitsForLtrpInSPS))
+    {
+      bitsForLtrpInSPS++;
+    }
+    READ_UVLC( uiCode, "num_long_term_pics");             rps->setNumberOfLongtermPictures(uiCode);
+    numOfLtrp += uiCode;
+    rps->setNumberOfLongtermPictures(numOfLtrp);
+    Int maxPicOrderCntLSB = 1 << sps->getBitsForPOC();
+    Int prevDeltaMSB = 0, deltaPocMSBCycleLT = 0;
+    for(Int j=offset+rps->getNumberOfLongtermPictures()-1, k = 0; k < numOfLtrp; j--, k++)
+    {
+      Int pocLsbLt;
+      if (k < numLtrpInSPS)
+      {
+        uiCode = 0;
+        if (bitsForLtrpInSPS > 0)
+        {
+          READ_CODE(bitsForLtrpInSPS, uiCode, "lt_idx_sps[i]");
+        }
+        Bool usedByCurrFromSPS=sps->getUsedByCurrPicLtSPSFlag(uiCode);
+
+        pocLsbLt = sps->getLtRefPicPocLsbSps(uiCode);
+        rps->setUsed(j,usedByCurrFromSPS);
+      }
+      else
+      {
+        READ_CODE(sps->getBitsForPOC(), uiCode, "poc_lsb_lt"); pocLsbLt= uiCode;
+        READ_FLAG( uiCode, "used_by_curr_pic_lt_flag");     rps->setUsed(j,uiCode);
+      }
+      READ_FLAG(uiCode,"delta_poc_msb_present_flag");
+      Bool mSBPresentFlag = uiCode ? true : false;
+      if(mSBPresentFlag)
+      {
+        READ_UVLC( uiCode, "delta_poc_msb_cycle_lt[i]" );
+        Bool deltaFlag = false;
+        //            First LTRP                               || First LTRP from SH
+        if( (j == offset+rps->getNumberOfLongtermPictures()-1) || (j == offset+(numOfLtrp-numLtrpInSPS)-1) )
+        {
+          deltaFlag = true;
+        }
+        if(deltaFlag)
+        {
+          deltaPocMSBCycleLT = uiCode;
+        }
+        else
+        {
+          deltaPocMSBCycleLT = uiCode + prevDeltaMSB;
+        }
+
+        Int pocLTCurr = pcSlice->getPOC() - deltaPocMSBCycleLT * maxPicOrderCntLSB
+          - iPOClsb + pocLsbLt;
+        rps->setPOC     (j, pocLTCurr);
+        rps->setDeltaPOC(j, - pcSlice->getPOC() + pocLTCurr);
+        rps->setCheckLTMSBPresent(j,true);
+      }
+      else
+      {
             rps->setPOC     (j, pocLsbLt);
             rps->setDeltaPOC(j, - pcSlice->getPOC() + pocLsbLt);
-            rps->setCheckLTMSBPresent(j,false);
-
-            // reset deltaPocMSBCycleLT for first LTRP from slice header if MSB not present
-            if( j == offset+(numOfLtrp-numLtrpInSPS)-1 )
-            {
-              deltaPocMSBCycleLT = 0;
-            }
-          }
-          prevDeltaMSB = deltaPocMSBCycleLT;
-        }
-        offset += rps->getNumberOfLongtermPictures();
-        rps->setNumberOfPictures(offset);
-      }
-#if NH_MV
-      if ( !rps->getInterRPSPrediction( ) )
-      { // check sum of NumPositivePics, NumNegativePics, num_long_term_sps and num_long_term_pics 
-        rps->checkMaxNumPics( 
-          vps->getVpsExtensionFlag(), 
-            MAX_INT,  // To be replaced by MaxDbpsize
-          pcSlice->getLayerId(), 
-          sps->getMaxDecPicBuffering( sps->getSpsMaxSubLayersMinus1() ) - 1 );
-      }
-#endif
-
-      if ( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
-        || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
-        || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
-      {
-        // In the case of BLA picture types, rps data is read from slice header but ignored
-        rps = pcSlice->getLocalRPS();
-        (*rps)=TComReferencePictureSet();
-        pcSlice->setRPS(rps);
-      }
-      if (sps->getTMVPFlagsPresent())
-      {
-#if NH_MV
-        READ_FLAG( uiCode, "slice_temporal_mvp_enabled_flag" );
-#else
-        READ_FLAG( uiCode, "slice_temporal_mvp_enabled_flag" );
-#endif
-        pcSlice->setEnableTMVPFlag( uiCode == 1 ? true : false );
-      }
-      else
-      {
-        pcSlice->setEnableTMVPFlag(false);
-      }
-    }
+        rps->setCheckLTMSBPresent(j,false);
+
+        // reset deltaPocMSBCycleLT for first LTRP from slice header if MSB not present
+        if( j == offset+(numOfLtrp-numLtrpInSPS)-1 )
+        {
+          deltaPocMSBCycleLT = 0;
+        }
+      }
+      prevDeltaMSB = deltaPocMSBCycleLT;
+    }
+    offset += rps->getNumberOfLongtermPictures();
+    rps->setNumberOfPictures(offset);
+  }
+
+  if ( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
+    || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
+    || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
+  {
+    // In the case of BLA picture types, rps data is read from slice header but ignored
+    rps = pcSlice->getLocalRPS();
+    (*rps)=TComReferencePictureSet();
+    pcSlice->setRPS(rps);
+  }
+  if (sps->getTMVPFlagsPresent())
+  {
+    READ_FLAG( uiCode, "slice_temporal_mvp_enabled_flag" );
+    pcSlice->setEnableTMVPFlag( uiCode == 1 ? true : false );
+  }
+  else
+  {
+    pcSlice->setEnableTMVPFlag(false);
+  }
+}
+#endif
+
 #if NH_MV
     Bool interLayerPredLayerIdcPresentFlag = false; 
@@ -2649 +2716 @@
     }
     // }
+#if NH_MV
+    
+    const Int numPicTotalCurr = pcSlice->getNumPicTotalCurr(); 
+    if( pcSlice->getSliceType() == P_SLICE || pcSlice->getSliceType() == B_SLICE )
+    {
+      if( pps->getListsModificationPresentFlag() && numPicTotalCurr > 1 )
+      {
+        TComRefPicListModification* rplMod = pcSlice->getRefPicListModification();
+        READ_FLAG( uiCode, "ref_pic_list_modification_flag_l0" ); rplMod->setRefPicListModificationFlagL0( uiCode == 1 );
+        if( rplMod->getRefPicListModificationFlagL0() )
+        {
+          for( Int i = 0; i  <=  pcSlice->getNumRefIdxL0ActiveMinus1( ); i++ )
+          {
+            READ_CODE( rplMod->getListEntryLXLen( numPicTotalCurr ) , uiCode, "list_entry_l0" ); rplMod->setListEntryL0( i, uiCode );
+          }
+        }
+
+        if( pcSlice->getSliceType() == B_SLICE )
+        {
+          READ_FLAG( uiCode, "ref_pic_list_modification_flag_l1" ); rplMod->setRefPicListModificationFlagL1( uiCode == 1 );
+          if( rplMod->getRefPicListModificationFlagL1() )
+          {
+            for( Int i = 0; i  <=  pcSlice->getNumRefIdxL1ActiveMinus1( ); i++ )
+            {
+              READ_CODE( rplMod->getListEntryLXLen( numPicTotalCurr ), uiCode, "list_entry_l1" ); rplMod->setListEntryL1( i, uiCode );
+            }
+          }
+        }
+      }
+    }
+#else
     TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
     if(!pcSlice->isIntra())
@@ -2735 +2833 @@
       refPicListModification->setRefPicListModificationFlagL1(0);
     }
+#endif
+
     if (pcSlice->isInterB())
     {
@@ -2898 +2998 @@
     {
       Int voiInVps = vps->getVoiInVps( pcSlice->getViewIndex() ); 
-#if NH_3D_FIX_TICKET_101
       if( vps->getCpInSliceSegmentHeaderFlag( voiInVps ) )
-#else
-      if( vps->getCpInSliceSegmentHeaderFlag( voiInVps ) && !pcSlice->getIsDepth() )
-#endif
       {
         for( Int m = 0; m < vps->getNumCp( voiInVps ); m++ )
@@ -2952 +3048 @@
     pcSlice->checkPocResetIdc(); 
 
+#if NH_MV
+    if ( pcSlice->getVPS()->getPocLsbNotPresentFlag(pcSlice->getLayerId()) && pcSlice->getSlicePicOrderCntLsb() > 0 )
+#else
     if ( pcSlice->getVPS()->getPocLsbNotPresentFlag(pcSlice->getLayerId()) && slicePicOrderCntLsb > 0 )
+#endif
     {
       assert( pcSlice->getPocResetIdc() != 2 );
@@ -2959 +3059 @@
     if( pcSlice->getPocResetIdc() !=  0 )
     {
-      READ_CODE( 6, uiCode, "poc_reset_period_id" ); pcSlice->setPocResetPeriodId( uiCode );
+      READ_CODE( 6, uiCode, "poc_reset_period_id" ); pcSlice->setPocResetPeriodId( uiCode );      
+      pcSlice->setHasPocResetPeriodIdPresent( true );
     }
     else
     {
       // TODO Copy poc_reset_period from earlier picture
+#if NH_MV
+      pcSlice->setHasPocResetPeriodIdPresent( false);
+#else
       pcSlice->setPocResetPeriodId( 0 );
+#endif
     }
     
@@ -2972 +3077 @@
       READ_CODE( pcSlice->getPocLsbValLen() , uiCode, "poc_lsb_val" ); pcSlice->setPocLsbVal( uiCode );
     }          
-    pcSlice->checkPocLsbVal(); 
-
-    // Derive the value of PocMs8bValRequiredFlag
+    pcSlice->checkPocLsbVal();        
 
     if( !pcSlice->getPocMsbValRequiredFlag() && pcSlice->getVPS()->getVpsPocLsbAlignedFlag() )
     {
+#if NH_MV
+      READ_FLAG( uiCode, "poc_msb_cycle_val_present_flag" ); pcSlice->setPocMsbCycleValPresentFlag( uiCode == 1 );
+#else
       READ_FLAG( uiCode, "poc_msb_val_present_flag" ); pcSlice->setPocMsbValPresentFlag( uiCode == 1 );
+#endif
     }
     else
     {
+#if NH_MV
+      pcSlice->setPocMsbCycleValPresentFlag( pcSlice->inferPocMsbCycleValPresentFlag( ) ); 
+#else
       pcSlice->setPocMsbValPresentFlag( pcSlice->inferPocMsbValPresentFlag( ) ); 
+#endif
     }
 
     
+#if NH_MV
+    if( pcSlice->getPocMsbCycleValPresentFlag() )
+#else
     if( pcSlice->getPocMsbValPresentFlag() )
-    {
+#endif
+    {
+#if NH_MV
+      READ_UVLC( uiCode, "poc_msb_val" ); pcSlice->setPocMsbCycleVal( uiCode );
+#else
       READ_UVLC( uiCode, "poc_msb_val" ); pcSlice->setPocMsbVal( uiCode );
+#endif
     }
 

trunk/source/Lib/TLibDecoder/TDecCAVLC.h

@@ -64 +64 @@
 protected:
 
+#if NH_MV
+  Void  parseShortTermRefPicSet            (TComSPS* pcSPS, TComStRefPicSet* pcRPS, Int stRpsIdx );
+#else
   Void  parseShortTermRefPicSet            (TComSPS* pcSPS, TComReferencePictureSet* pcRPS, Int idx);
+#endif
 
 #if NH_MV
@@ -104 +108 @@
   Void  parseProfileTier    (ProfileTierLevel *ptl, const Bool bIsSubLayer);
   Void  parseHrdParameters  (TComHRD *hrd, Bool cprms_present_flag, UInt tempLevelHigh);
+#if NH_MV
+  Void  parseFirstSliceSegmentInPicFlag( TComSlice* pcSlice );
+  Void  parseSliceHeader    ( TComSlice* pcSlice, ParameterSetManager *parameterSetManager );
+#else
   Void  parseSliceHeader    ( TComSlice* pcSlice, ParameterSetManager *parameterSetManager, const Int prevTid0POC);
+#endif
+
   Void  parseTerminatingBit ( UInt& ruiBit );
   Void  parseRemainingBytes ( Bool noTrailingBytesExpected );

trunk/source/Lib/TLibDecoder/TDecCu.cpp

@@ -531 +531 @@
         pcCU->getCUMvField( REF_PIC_LIST_1 )->setMvFieldSP(pcCU, uiSPAddr, pcMvFieldSP[2*iPartitionIdx + 1], iSPWidth, iSPHeight);
       }
+#if ENC_DEC_TRACE && H_MV_ENC_DEC_TRAC
+      if ( g_traceSubPBMotion )
+      {
+        std::cout << std::setfill(' ')                          << std::setw( 15 )
+          << "Num"                                              << std::setw( 15 )
+          << "Dir "                                             << std::setw( 15 )
+          <<  "L0 RefIdx"                                       << std::setw( 15 )
+          <<  "L0 Hor"                                          << std::setw( 15 )
+          <<  "L0 Ver"                                          << std::setw( 15 )
+          <<  "L1 RefIdx"                                       << std::setw( 15 )
+          <<  "L1 Hor"                                          << std::setw( 15 )
+          <<  "L1 Ver"                                          << std::setw( 15 )
+          << std::endl; 
+
+        for (Int iPartitionIdx = 0; iPartitionIdx < iNumSP; iPartitionIdx++)
+        {
+          UChar        dir = puhInterDirSP[iPartitionIdx]; 
+          TComMvField& mv0 = pcMvFieldSP  [2*iPartitionIdx];
+          TComMvField& mv1 = pcMvFieldSP  [2*iPartitionIdx+1];
+
+          std::cout << std::setfill(' ')                                  << std::setw( 15 )
+            << iPartitionIdx                                              << std::setw( 15 )
+            << (UInt) dir                                                 << std::setw( 15 )
+            << ((dir & 1) ? mv0.getRefIdx()       : MIN_INT)              << std::setw( 15 )
+            << ((dir & 1) ? mv0.getMv().getHor()  : MIN_INT)              << std::setw( 15 )
+            << ((dir & 1) ? mv0.getMv().getVer()  : MIN_INT)              << std::setw( 15 )
+            << ((dir & 2) ? mv1.getRefIdx()       : MIN_INT)              << std::setw( 15 )
+            << ((dir & 2) ? mv1.getMv().getHor()  : MIN_INT)              << std::setw( 15 )
+            << ((dir & 2) ? mv1.getMv().getVer()  : MIN_INT)              << std::setw( 15 )
+            << std::endl;
+        }
+      }
+#endif
     }
     delete[] pcMvFieldSP;
@@ -779 +812 @@
   const ChromaFormat chFmt     = rTu.GetChromaFormat();
 
+  DEBUG_STRING_NEW(sTemp)
   if ( pcCU->getDISType(uiAbsPartIdx) == 0 )
   {
@@ -1271 +1305 @@
     TComTURecurse tuRecurseWithPU(tuRecurseCU, false, TComTU::DONT_SPLIT);
 
+    DEBUG_STRING_NEW(sTemp)
     m_pcPrediction->initIntraPatternChType( tuRecurseWithPU, COMPONENT_Y, false DEBUG_STRING_PASS_INTO(sTemp) );
 
@@ -1321 +1356 @@
       
       //===== init pattern for luma prediction =====
-      
+      DEBUG_STRING_NEW(sTemp)
       m_pcPrediction->initIntraPatternChType( tuRecurseWithPU, COMPONENT_Y, bUseFilter  DEBUG_STRING_PASS_INTO(sTemp) );
       

trunk/source/Lib/TLibDecoder/TDecEntropy.cpp

@@ -238 +238 @@
   UInt uiNumPU = ( ePartSize == SIZE_2Nx2N ? 1 : ( ePartSize == SIZE_NxN ? 4 : 2 ) );
   UInt uiPUOffset = ( g_auiPUOffset[UInt( ePartSize )] << ( ( pcCU->getSlice()->getSPS()->getMaxTotalCUDepth() - uiDepth ) << 1 ) ) >> 4;
+
+#if NH_3D_MLC
 //#if H_3D_IV_MERGE
-#if NH_3D_MLC
   TComMvField cMvFieldNeighbours[MRG_MAX_NUM_CANDS_MEM << 1]; // double length for mv of both lists
   UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS_MEM];
@@ -651 +652 @@
 #endif
         }
-      }
+      } 
 #if NH_3D_IC
       decodeICFlag( pcCU, uiAbsPartIdx, uiDepth );

trunk/source/Lib/TLibDecoder/TDecEntropy.h

@@ -67 +67 @@
   virtual Void  parseSPS                  ( TComSPS* pcSPS )     = 0;
   virtual Void  parsePPS                  ( TComPPS* pcPPS )     = 0;
-  virtual Void parseSliceHeader          ( TComSlice* pcSlice, ParameterSetManager *parameterSetManager, const Int prevTid0POC)       = 0;
+#if NH_MV
+  virtual Void  parseFirstSliceSegmentInPicFlag( TComSlice* pcSlice ) = 0;
+  virtual Void  parseSliceHeader          ( TComSlice* pcSlice, ParameterSetManager *parameterSetManager )       = 0;
+#else
+  virtual Void  parseSliceHeader          ( TComSlice* pcSlice, ParameterSetManager *parameterSetManager, const Int prevTid0POC)       = 0;
+#endif
 
   virtual Void parseTerminatingBit       ( UInt& ruilsLast )                                     = 0;
@@ -156 +161 @@
   Void    decodeSPS                   ( TComSPS* pcSPS ) { m_pcEntropyDecoderIf->parseSPS(pcSPS); }
   Void    decodePPS                   ( TComPPS* pcPPS ) { m_pcEntropyDecoderIf->parsePPS(pcPPS); }
+#if NH_MV
+  Void    decodeFirstSliceSegmentInPicFlag ( TComSlice* pcSlice )  { m_pcEntropyDecoderIf->parseFirstSliceSegmentInPicFlag( pcSlice );         }
+#endif
+#if NH_MV
+  Void    decodeSliceHeader           ( TComSlice* pcSlice, ParameterSetManager *parameterSetManager )  { m_pcEntropyDecoderIf->parseSliceHeader(pcSlice, parameterSetManager);         }
+#else
   Void    decodeSliceHeader           ( TComSlice* pcSlice, ParameterSetManager *parameterSetManager, const Int prevTid0POC)  { m_pcEntropyDecoderIf->parseSliceHeader(pcSlice, parameterSetManager, prevTid0POC);         }
+#endif
   Void    decodeTerminatingBit        ( UInt& ruiIsLast )       { m_pcEntropyDecoderIf->parseTerminatingBit(ruiIsLast);     }
   Void    decodeRemainingBytes( Bool noTrailingBytesExpected ) { m_pcEntropyDecoderIf->parseRemainingBytes(noTrailingBytesExpected); }

trunk/source/Lib/TLibDecoder/TDecSbac.h

@@ -80 +80 @@
   Void  parseSPS                  ( TComSPS* /*pcSPS*/ ) {}
   Void  parsePPS                  ( TComPPS* /*pcPPS*/ ) {}
+#if NH_MV
+  Void  parseFirstSliceSegmentInPicFlag( TComSlice* /*pcSlice*/ ) {}
+  Void  parseSliceHeader          ( TComSlice* /*pcSlice*/, ParameterSetManager* /*parameterSetManager*/ ) {}
+#else
   Void  parseSliceHeader          ( TComSlice* /*pcSlice*/, ParameterSetManager* /*parameterSetManager*/, const Int /*prevTid0POC*/) {}
+#endif
   Void  parseTerminatingBit       ( UInt& ruiBit );
   Void  parseRemainingBytes       ( Bool noTrailingBytesExpected);

trunk/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
 

trunk/source/Lib/TLibDecoder/TDecTop.h

@@ -81 +81 @@
   Int**** getBaseViewShiftLUTI()  { return m_aiBaseViewShiftLUT;   }
 
-#if !NH_3D_FIX_TICKET_101
-#if NH_3D_IV_MERGE
-  Void  copyCamParamForSlice( TComSlice* pcSlice );
-#endif
-#endif
-
 private:
   Void xResetReceivedIdc( Bool overWriteFlag ); 
@@ -182 +176 @@
 {
 private:
-  Int                     m_iMaxRefPicNum;
-
-  NalUnitType             m_associatedIRAPType; ///< NAL unit type of the associated IRAP picture
-  Int                     m_pocCRA;            ///< POC number of the latest CRA picture
-  Int                     m_pocRandomAccess;   ///< POC number of the random access point (the first IDR or CRA picture)
-
-  TComList<TComPic*>      m_cListPic;         //  Dynamic buffer
-#if NH_MV
-  Bool*                    m_layerInitilizedFlag; // initialization Layers
-  static ParameterSetManager m_parameterSetManager;  // storage for parameter sets 
-  Int                      m_targetOlsIdx; 
-#else
-  ParameterSetManager     m_parameterSetManager;  // storage for parameter sets
-#endif
+  Int                         m_iMaxRefPicNum;
+                              
+  NalUnitType                 m_associatedIRAPType; ///< NAL unit type of the associated IRAP picture
+#if !NH_MV
+  Int                         m_pocCRA;            ///< POC number of the latest CRA picture
+  Int                         m_pocRandomAccess;   ///< POC number of the random access point (the first IDR or CRA picture)
+  
+  TComList<TComPic*>           m_cListPic;         //  Dynamic buffer
+  ParameterSetManager          m_parameterSetManager;  // storage for parameter sets
+#endif
+
   TComSlice*              m_apcSlicePilot;
 
@@ -215 +206 @@
 
   Bool isSkipPictureForBLA(Int& iPOCLastDisplay);
-#if NH_MV
-  Bool isRandomAccessSkipPicture(Int& iSkipFrame,  Int& iPOCLastDisplay, const TComVPS* vps);
-#else
+#if !NH_MV
   Bool isRandomAccessSkipPicture(Int& iSkipFrame,  Int& iPOCLastDisplay);
 #endif
+
   TComPic*                m_pcPic;
   UInt                    m_uiSliceIdx;
+#if !NH_MV
   Int                     m_prevPOC;
   Int                     m_prevTid0POC;
-  Bool                    m_bFirstSliceInPicture;
+  Bool                    m_bFirstSliceInPicture;  
   Bool                    m_bFirstSliceInSequence;
   Bool                    m_prevSliceSkipped;
@@ -232 +223 @@
   Bool                    m_isNoOutputPriorPics;
   Bool                    m_craNoRaslOutputFlag;    //value of variable NoRaslOutputFlag of the last CRA pic
+#endif
+  
 #if O0043_BEST_EFFORT_DECODING
   UInt                    m_forceDecodeBitDepth;
 #endif
+
+
   std::ostream           *m_pDecodedSEIOutputStream;
 
+#if !NH_MV
   Bool                    m_warningMessageSkipPicture;
+#endif
+
 #if NH_MV
-  Bool                    m_isLastNALWasEos;
-#endif
-
-#if NH_MV
-  // For NH_MV m_bFirstSliceInSequence indicates first slice in sequence of the particular layer  
+  // Class interface 
+  static ParameterSetManager  m_parameterSetManager;  // storage for parameter sets 
+  TComPicLists*           m_dpb; 
+#if NH_3D
+  CamParsCollector*       m_pcCamParsCollector;
+#endif
+
+  // Layer identification
   Int                     m_layerId;
   Int                     m_viewId;
-  TComPicLists*           m_ivPicLists;
-  std::vector<TComPic*>   m_refPicSetInterLayer0; 
-  std::vector<TComPic*>   m_refPicSetInterLayer1; 
-#if NH_3D
+#if NH_3D                 
   Int                     m_viewIndex; 
   Bool                    m_isDepth;
-  CamParsCollector*       m_pcCamParsCollector;
-  Int                     m_profileIdc;
-#endif
+#endif
+
+  // Layer set
+  Int                     m_targetOlsIdx; 
+  Int                     m_smallestLayerId; 
+  Bool                    m_isInOwnTargetDecLayerIdList;   
+
+  // Decoding processes 
+  DecodingProcess         m_decodingProcess;
+  DecodingProcess         m_decProcPocAndRps;
+
+  // Decoding state
+  Bool*                   m_firstPicInLayerDecodedFlag;   
+    
+  Int                     m_prevPicOrderCnt; 
+  Int                     m_prevTid0PicPicOrderCntMsb;
+  Int                     m_prevTid0PicSlicePicOrderCntLsb;
+  
+  Int*                    m_lastPresentPocResetIdc;
+  Bool*                   m_pocDecrementedInDpbFlag; 
+
+  Int                     m_prevIrapPoc;
+  Int64                   m_prevIrapDecodingOrder;
+  Int64                   m_prevStsaDecOrder;
+  Int                     m_prevStsaTemporalId;
 #endif
 
@@ -268 +288 @@
 
   Void  init();
-#if NH_MV  
-  Bool  decode(InputNALUnit& nalu, Int& iSkipFrame, Int& iPOCLastDisplay, Bool newLayer, Bool& sliceSkippedFlag );
-  Bool  decode(InputNALUnit& nalu, Int& iSkipFrame, Int& iPOCLastDisplay, Bool newLayer );
-#else  
+#if !NH_MV
   Bool  decode(InputNALUnit& nalu, Int& iSkipFrame, Int& iPOCLastDisplay);
-#endif
   Void  deletePicBuffer();
 
-#if NH_MV
-  const TComVPS* getActiveVPS() { return m_parameterSetManager.getActiveVPS( ); }
-  const TComSPS* getActiveSPS() { return m_parameterSetManager.getActiveSPS( m_layerId ); }
-#endif
-
-#if NH_MV
-  Void endPicDecoding(Int& poc, TComList<TComPic*>*& rpcListPic,  std::vector<Int>& targetDecLayerIdSet);  
-#else  
   Void  executeLoopFilters(Int& poc, TComList<TComPic*>*& rpcListPic);
-#endif
   Void  checkNoOutputPriorPics (TComList<TComPic*>* rpcListPic);
 
   Bool  getNoOutputPriorPicsFlag () { return m_isNoOutputPriorPics; }
   Void  setNoOutputPriorPicsFlag (Bool val) { m_isNoOutputPriorPics = val; }
+  
   Void  setFirstSliceInPicture (bool val)  { m_bFirstSliceInPicture = val; }
+
   Bool  getFirstSliceInSequence ()         { return m_bFirstSliceInSequence; }
   Void  setFirstSliceInSequence (bool val) { m_bFirstSliceInSequence = val; }
+#endif
+
 #if O0043_BEST_EFFORT_DECODING
   Void  setForceDecodeBitDepth(UInt bitDepth) { m_forceDecodeBitDepth = bitDepth; }
 #endif
+
   Void  setDecodedSEIMessageOutputStream(std::ostream *pOpStream) { m_pDecodedSEIOutputStream = pOpStream; }
   UInt  getNumberOfChecksumErrorsDetected() const { return m_cGopDecoder.getNumberOfChecksumErrorsDetected(); }
+
 #if NH_MV    
-  TComPic*                getPic                ( Int poc );
-  TComList<TComPic*>*     getListPic            ()               { return &m_cListPic;  }  
-  Void                    setIvPicLists         ( TComPicLists* picLists) { m_ivPicLists = picLists; }
-  Void                    setLayerInitilizedFlags( Bool* val )    { m_layerInitilizedFlag = val; }
-  Void                    setTargetOlsIdx       ( Int targetOlsIdx ) { m_targetOlsIdx = targetOlsIdx; }    
-  Int                     getTargetOlsIdx       ( )                  { return m_targetOlsIdx; }    
-  Int                     getCurrPoc            ()               { return m_apcSlicePilot->getPOC(); }
-  Void                    setLayerId            ( Int layer)     { m_layerId = layer;   }
-  Int                     getLayerId            ()               { return m_layerId;    }
-  Void                    setViewId             ( Int viewId  )  { m_viewId  = viewId;  }
-  Int                     getViewId             ()               { return m_viewId;     }  
-  Void                    initFromActiveVps     ( const TComVPS* vps );
+
+  /////////////////////////
+  // For access from TAppDecTop
+  /////////////////////////
+
+  // Non VCL decoding
+  Bool       decodeNonVclNalu            ( InputNALUnit& nalu );                                    
+                                    
+  // Start picture decoding         
+  Int        preDecodePoc                ( Bool firstPicInLayerDecodedFlag, Bool isFstPicOfAllLayOfPocResetPer, Bool isPocResettingPicture ); 
+  Void       inferPocResetPeriodId       ( );
+  Void       decodeSliceHeader           ( InputNALUnit &nalu );    
+
+  // Picture decoding 
+  Void       activatePSsAndInitPicOrSlice( TComPic* newPic ); 
+  Void       decodePocAndRps             ( );
+  Void       genUnavailableRefPics       ( );                               
+  Void       decodeSliceSegment          ( InputNALUnit &nalu );
+                                    
+  // End Picture decoding           
+  Void       executeLoopFilters          ( );
+  Void       finalizePic( );
+  
+  //////////////////////////
+  // For access from slice 
+  /////////////////////////
+  Void       initFromActiveVps           ( const TComVPS* vps );
+
+  //////////////////////////
+  // General access
+  /////////////////////////
+  
+  // Picture identification 
+  Void       setLayerId            ( Int layer )       { m_layerId = layer;   }
+  Int        getLayerId            ( )                 { return m_layerId;    }
+  Void       setViewId             ( Int viewId )      { m_viewId  = viewId;  }
+  Int        getViewId             ( )                 { return m_viewId;     }  
 #if NH_3D    
-  Void                    setViewIndex          ( Int viewIndex  )  { m_viewIndex  = viewIndex;  }
-  Int                     getViewIndex          ()               { return m_viewIndex;     }  
-  Void                    setIsDepth            ( Bool isDepth ) { m_isDepth = isDepth; }
-  Bool                    getIsDepth            ()               { return m_isDepth;    }
-  Void                    setCamParsCollector( CamParsCollector* pcCamParsCollector ) { m_pcCamParsCollector = pcCamParsCollector; }
-
-
-  Bool                    decProcAnnexI()           { assert( m_profileIdc != -1 ); return ( m_profileIdc == 8); }    
-#endif
+  Void       setViewIndex          ( Int viewIndex )   { m_viewIndex  = viewIndex;  }
+  Int        getViewIndex          ( )                 { return m_viewIndex;     }  
+  Void       setIsDepth            ( Bool isDepth )    { m_isDepth = isDepth; }
+  Bool       getIsDepth            ( )                 { return m_isDepth;    }
+#endif
+
+  // Classes
+  Void       setDpb                ( TComPicLists* picLists) { m_dpb = picLists; }
+#if NH_3D                                       
+  Void       setCamParsCollector   ( CamParsCollector* pcCamParsCollector ) { m_pcCamParsCollector = pcCamParsCollector; }
+#endif
+
+  // Slice pilot access
+  TComSlice* getSlicePilot                ( )               { return m_apcSlicePilot; }
+                                                                         
+  // Decoding state                                                      
+  Bool      getFirstSliceSegementInPicFlag( );              
+  Void      setFirstPicInLayerDecodedFlag(Bool* val )      { m_firstPicInLayerDecodedFlag = val;  }
+  Void      setPocDecrementedInDPBFlag   (Bool* val )      { m_pocDecrementedInDpbFlag = val;  }  
+  Void      setLastPresentPocResetIdc    (Int*  val )      { m_lastPresentPocResetIdc  = val;  }
+                                                           
+  // Layer sets                                                          
+  Void      setTargetOlsIdx        ( Int targetOlsIdx )    { m_targetOlsIdx = targetOlsIdx; }    
+  Int       getTargetOlsIdx        ( )                     { return m_targetOlsIdx; }    
+  Int       getSmallestLayerId     ( )                     { return m_smallestLayerId; }    
+  Bool      getIsInOwnTargetDecLayerIdList()               { return m_isInOwnTargetDecLayerIdList; }
+                                                                         
+  // Decoding processes identification                                   
+  Bool      decProcClause8( )                              { return ( m_decodingProcess == CLAUSE_8 ); }
+  Bool      decProcAnnexF ( )                              { return ( decProcAnnexG() || decProcAnnexH() || decProcAnnexI() ); }
+  Bool      decProcAnnexG ( )                              { return ( m_decodingProcess == ANNEX_G || decProcAnnexI() ); }
+  Bool      decProcAnnexH ( )                              { return ( m_decodingProcess == ANNEX_H  ); }
+  Bool      decProcAnnexI ( )                              { return ( m_decodingProcess == ANNEX_I  ); }
+                                                                         
+  DecodingProcess getDecodingProcess ( ) const                   { return m_decodingProcess;                }
+  Void      setDecProcPocAndRps( DecodingProcess decProc ) { m_decProcPocAndRps = decProc; }    
 #endif
 
 protected:
-  Void  xGetNewPicBuffer  (const TComSPS &sps, const TComPPS &pps, TComPic*& rpcPic, const UInt temporalLayer);
-  Void  xCreateLostPicture (Int iLostPOC);
-
+
+#if !NH_MV
+  Void      xGetNewPicBuffer  (const TComSPS &sps, const TComPPS &pps, TComPic*& rpcPic, const UInt temporalLayer);
+  Void      xCreateLostPicture (Int iLostPOC);
   Void      xActivateParameterSets();
-#if NH_MV  
-  TComPic*  xGetPic( Int layerId, Int poc ); 
-  Bool      xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay, Bool newLayerFlag, Bool& sliceSkippedFlag );  
-  Void      xResetPocInPicBuffer();
-  Void      xCeckNoClrasOutput();
-
-  Bool      xAllRefLayersInitilized( const TComVPS* vps );
-#else
-  Bool      xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay);
-#endif
+  Bool      xDecodeSlice                   (InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay);
+#endif
+
   Void      xDecodeVPS(const std::vector<UChar> &naluData);
   Void      xDecodeSPS(const std::vector<UChar> &naluData);
-  Void      xDecodePPS(const std::vector<UChar> &naluData);
+  Void      xDecodePPS(const std::vector<UChar> &naluData);  
+#if !NH_MV
   Void      xUpdatePreviousTid0POC( TComSlice *pSlice ) { if ((pSlice->getTLayer()==0) && (pSlice->isReferenceNalu() && (pSlice->getNalUnitType()!=NAL_UNIT_CODED_SLICE_RASL_R)&& (pSlice->getNalUnitType()!=NAL_UNIT_CODED_SLICE_RADL_R))) { m_prevTid0POC=pSlice->getPOC(); } }
+#endif
 
   Void      xParsePrefixSEImessages();
   Void      xParsePrefixSEIsForUnknownVCLNal();
 
+#if NH_MV
+  // POC 
+  Void      x831DecProcForPicOrderCount         ( );
+  Void      xF831DecProcForPicOrderCount        ( );
+  Int       xGetCurrMsb                         ( Int cl, Int pl, Int pm, Int ml ); 
+
+  //RPS                                         
+  Void      x832DecProcForRefPicSet             ( Bool annexFModifications ); 
+  Void      xF832DecProcForRefPicSet            ( );
+  Void      xG813DecProcForInterLayerRefPicSet  ( );
+
+  // Unavailable Pics 
+  Void      x8331GenDecProcForGenUnavilRefPics  ( );
+  TComPic*  x8332GenOfOneUnavailPic             ( Bool calledFromCl8331 );
+  Void      xF817DecProcForGenUnavRefPicForPicsFrstInDecOrderInLay();
+  Void      xF833DecProcForGenUnavRefPics       ( );  
+  Void      xCheckUnavailableRefPics            ( ); 
+#endif
+
 };// END CLASS DEFINITION TDecTop
 
 
 //! \}
-
 #endif // __TDECTOP__