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

Timestamp:

27 Oct 2015, 11:33:16 (10 years ago)

Author:

tech

Message:

Merged 15.1-dev0-NICT@1355.

Location:

trunk/source/Lib/TLibDecoder

Files:

• SEIread.cpp (modified) (14 diffs)
• SEIread.h (modified) (4 diffs)
• SyntaxElementParser.cpp (modified) (2 diffs)
• SyntaxElementParser.h (modified) (6 diffs)
• TDecTop.cpp (modified) (139 diffs)

trunk/source/Lib/TLibDecoder/SEIread.cpp

@@ -99 +99 @@
 }
 
+Void SEIReader::sei_read_string(std::ostream *pOS, UInt uiBufSize, UChar* pucCode, UInt& ruiLength, const Char *pSymbolName)
+{
+  READ_STRING(uiBufSize, pucCode, ruiLength, pSymbolName);
+  if (pOS)
+  {
+    (*pOS) << "  " << pSymbolName << ": " << (const char*) pucCode << "\n";
+  }
+}
+
+#if NH_MV_SEI
+inline Void SEIReader::output_sei_message_header(SEI &sei, std::ostream *pDecodedMessageOutputStream, UInt payloadSize)
+#else
 static inline Void output_sei_message_header(SEI &sei, std::ostream *pDecodedMessageOutputStream, UInt payloadSize)
+#endif
 {
   if (pDecodedMessageOutputStream)
@@ -105 +118 @@
     std::string seiMessageHdr(SEI::getSEIMessageString(sei.payloadType())); seiMessageHdr+=" SEI message";
     (*pDecodedMessageOutputStream) << std::setfill('-') << std::setw(seiMessageHdr.size()) << "-" << std::setfill(' ') << "\n" << seiMessageHdr << " (" << payloadSize << " bytes)"<< "\n";
+#if NH_MV_SEI
+    (*pDecodedMessageOutputStream) << std::setfill(' ') << "LayerId: " << m_layerId << std::setw(2) << " Picture: " << m_decOrder << std::setw( 5 ) << std::endl;
+#endif
   }
 }
@@ -117 +133 @@
  * unmarshal a single SEI message from bitstream bs
  */
+#if NH_MV_LAYERS_NOT_PRESENT_SEI
+Void SEIReader::parseSEImessage(TComInputBitstream* bs, SEIMessages& seis, const NalUnitType nalUnitType, const TComVPS *vps, const TComSPS *sps, std::ostream *pDecodedMessageOutputStream)
+#else
 Void SEIReader::parseSEImessage(TComInputBitstream* bs, SEIMessages& seis, const NalUnitType nalUnitType, const TComSPS *sps, std::ostream *pDecodedMessageOutputStream)
+#endif
 {
   setBitstream(bs);
@@ -124 +144 @@
   do
   {
+#if NH_MV_LAYERS_NOT_PRESENT_SEI
+    xReadSEImessage(seis, nalUnitType, vps, sps, pDecodedMessageOutputStream);
+#else
     xReadSEImessage(seis, nalUnitType, sps, pDecodedMessageOutputStream);
-
+#endif
     /* SEI messages are an integer number of bytes, something has failed
     * in the parsing if bitstream not byte-aligned */
@@ -135 +158 @@
 }
 
+#if NH_MV_LAYERS_NOT_PRESENT_SEI
+Void SEIReader::xReadSEImessage(SEIMessages& seis, const NalUnitType nalUnitType, const TComVPS *vps, const TComSPS *sps, std::ostream *pDecodedMessageOutputStream)
+#else
 Void SEIReader::xReadSEImessage(SEIMessages& seis, const NalUnitType nalUnitType, const TComSPS *sps, std::ostream *pDecodedMessageOutputStream)
+#endif
 {
 #if ENC_DEC_TRACE
@@ -254 +281 @@
     case SEI::SCALABLE_NESTING:
       sei = new SEIScalableNesting;
+#if NH_MV_LAYERS_NOT_PRESENT_SEI
+      xParseSEIScalableNesting((SEIScalableNesting&) *sei, nalUnitType, payloadSize, vps, sps, pDecodedMessageOutputStream);
+#else
       xParseSEIScalableNesting((SEIScalableNesting&) *sei, nalUnitType, payloadSize, sps, pDecodedMessageOutputStream);
+#endif
       break;
     case SEI::TEMP_MOTION_CONSTRAINED_TILE_SETS:
@@ -277 +308 @@
       xParseSEIMasteringDisplayColourVolume((SEIMasteringDisplayColourVolume&) *sei, payloadSize, pDecodedMessageOutputStream);
       break;
-#if NH_MV
+#if !NH_MV_SEI
     case SEI::SUB_BITSTREAM_PROPERTY:
       sei = new SEISubBitstreamProperty;
       xParseSEISubBitstreamProperty((SEISubBitstreamProperty&) *sei, payloadSize, pDecodedMessageOutputStream );
       break;
+#else
+#if NH_MV_LAYERS_NOT_PRESENT_SEI
+    case SEI::LAYERS_NOT_PRESENT:
+      if (!vps)
+      {
+        printf ("Warning: Found Layers not present SEI message, but no active VPS is available. Ignoring.");
+      }
+      else
+      {
+        sei = new SEILayersNotPresent;
+        xParseSEILayersNotPresent((SEILayersNotPresent&) *sei, payloadSize, vps, pDecodedMessageOutputStream);
+      }
+      break;
+#endif
+    case SEI::INTER_LAYER_CONSTRAINED_TILE_SETS:
+      sei = new SEIInterLayerConstrainedTileSets;
+      xParseSEIInterLayerConstrainedTileSets((SEIInterLayerConstrainedTileSets&) *sei, payloadSize, pDecodedMessageOutputStream );
+      break;
+#if NH_MV_TBD
+    case SEI::BSP_NESTING:
+      sei = new SEIBspNesting;
+      xParseSEIBspNesting((SEIBspNesting&) *sei, payloadSize, pDecodedMessageOutputStream );
+      break;
+    case SEI::BSP_INITIAL_ARRIVAL_TIME:
+      sei = new SEIBspInitialArrivalTime;
+      xParseSEIBspInitialArrivalTime((SEIBspInitialArrivalTime&) *sei, payloadSize, pDecodedMessageOutputStream );
+      break;
+#endif
+    case SEI::SUB_BITSTREAM_PROPERTY:
+      sei = new SEISubBitstreamProperty;
+      xParseSEISubBitstreamProperty((SEISubBitstreamProperty&) *sei, payloadSize, pDecodedMessageOutputStream );
+      break;
+    case SEI::ALPHA_CHANNEL_INFO:
+      sei = new SEIAlphaChannelInfo;
+      xParseSEIAlphaChannelInfo((SEIAlphaChannelInfo&) *sei, payloadSize, pDecodedMessageOutputStream );
+      break;
+    case SEI::OVERLAY_INFO:
+      sei = new SEIOverlayInfo;
+      xParseSEIOverlayInfo((SEIOverlayInfo&) *sei, payloadSize, pDecodedMessageOutputStream );
+      break;
+    case SEI::TEMPORAL_MV_PREDICTION_CONSTRAINTS:
+      sei = new SEITemporalMvPredictionConstraints;
+      xParseSEITemporalMvPredictionConstraints((SEITemporalMvPredictionConstraints&) *sei, payloadSize, pDecodedMessageOutputStream );
+      break;
+#if NH_MV_SEI_TBD
+    case SEI::FRAME_FIELD_INFO:
+      sei = new SEIFrameFieldInfo;
+      xParseSEIFrameFieldInfo((SEIFrameFieldInfo&) *sei, payloadSize, pDecodedMessageOutputStream );
+      break;
+#endif
+    case SEI::THREE_DIMENSIONAL_REFERENCE_DISPLAYS_INFO:
+      sei = new SEIThreeDimensionalReferenceDisplaysInfo;
+      xParseSEIThreeDimensionalReferenceDisplaysInfo((SEIThreeDimensionalReferenceDisplaysInfo&) *sei, payloadSize, pDecodedMessageOutputStream );
+      break;
+#if SEI_DRI_F0169
+    case SEI::DEPTH_REPRESENTATION_INFO:
+        sei = new SEIDepthRepresentationInfo;
+        xParseSEIDepthRepresentationInfo((SEIDepthRepresentationInfo&) *sei, payloadSize, pDecodedMessageOutputStream );
+        break;
+#endif
+    case SEI::MULTIVIEW_SCENE_INFO:
+      sei = new SEIMultiviewSceneInfo;
+      xParseSEIMultiviewSceneInfo((SEIMultiviewSceneInfo&) *sei, payloadSize, pDecodedMessageOutputStream );
+      break;
+
+    case SEI::MULTIVIEW_ACQUISITION_INFO:
+      sei = new SEIMultiviewAcquisitionInfo;
+      xParseSEIMultiviewAcquisitionInfo((SEIMultiviewAcquisitionInfo&) *sei, payloadSize, pDecodedMessageOutputStream );
+      break;
+
+    case SEI::MULTIVIEW_VIEW_POSITION:
+      sei = new SEIMultiviewViewPosition;
+      xParseSEIMultiviewViewPosition((SEIMultiviewViewPosition&) *sei, payloadSize, pDecodedMessageOutputStream );
+      break;
+#if NH_3D
+    case SEI::ALTERNATIVE_DEPTH_INFO:
+      sei = new SEIAlternativeDepthInfo;
+      xParseSEIAlternativeDepthInfo((SEIAlternativeDepthInfo&) *sei, payloadSize, pDecodedMessageOutputStream );
+      break;
+#endif
 #endif
     default:
@@ -455 +566 @@
 Void SEIReader::xParseSEIActiveParameterSets(SEIActiveParameterSets& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
 {
-  UInt val; 
+  UInt val;
   output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
 
@@ -805 +916 @@
 }
 
+#if NH_MV_LAYERS_NOT_PRESENT_SEI
+Void SEIReader::xParseSEIScalableNesting(SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, const TComVPS *vps, const TComSPS *sps, std::ostream *pDecodedMessageOutputStream)
+#else
 Void SEIReader::xParseSEIScalableNesting(SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, const TComSPS *sps, std::ostream *pDecodedMessageOutputStream)
+#endif
 {
   UInt uiCode;
@@ -847 +962 @@
   do
   {
+#if NH_MV_LAYERS_NOT_PRESENT_SEI
+    xReadSEImessage(sei.m_nestedSEIs, nalUnitType, vps, sps, pDecodedMessageOutputStream);
+#else
     xReadSEImessage(sei.m_nestedSEIs, nalUnitType, sps, pDecodedMessageOutputStream);
+#endif
   } while (m_pcBitstream->getNumBitsLeft() > 8);
 
@@ -857 +976 @@
 
 #if NH_MV
+#if !NH_MV_SEI
 Void SEIReader::xParseSEISubBitstreamProperty(SEISubBitstreamProperty &sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream )
 {
@@ -872 +992 @@
     sei_read_code( pDecodedMessageOutputStream,  16, code, "avg_bit_rate[i]"                 ); sei.m_avgBitRate[i] = code;
     sei_read_code( pDecodedMessageOutputStream,  16, code, "max_bit_rate[i]"                 ); sei.m_maxBitRate[i] = code;
-  }  
+  }
 }
 
@@ -883 +1003 @@
   sei.m_maxBitRate.resize( sei.m_numAdditionalSubStreams );
 }
+#endif
 #endif
 
@@ -1101 +1222 @@
 }
 
+#if NH_MV_LAYERS_NOT_PRESENT_SEI
+Void SEIReader::xParseSEILayersNotPresent(SEILayersNotPresent &sei, UInt payloadSize, const TComVPS *vps, std::ostream *pDecodedMessageOutputStream)
+{
+  UInt code;
+
+  output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
+  sei_read_code( pDecodedMessageOutputStream, 4, code, "lnp_sei_active_vps_id" ); sei.m_lnpSeiActiveVpsId = code;
+  assert(vps->getVPSId() == sei.m_lnpSeiActiveVpsId);
+
+  sei.m_lnpSeiMaxLayers = vps->getMaxLayersMinus1() + 1;
+  sei.resizeDimI(sei.m_lnpSeiMaxLayers);
+  for (Int i = 0; i < sei.m_lnpSeiMaxLayers; i++)
+  {
+    sei_read_flag( pDecodedMessageOutputStream, code, "layer_not_present_flag" );
+    sei.m_layerNotPresentFlag[i] = (code == 1);
+  }
+};
+#endif
+
+Void SEIReader::xParseSEIInterLayerConstrainedTileSets(SEIInterLayerConstrainedTileSets& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
+{
+  UInt code;
+  output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
+
+  sei_read_flag( pDecodedMessageOutputStream, code, "il_all_tiles_exact_sample_value_match_flag" ); sei.m_ilAllTilesExactSampleValueMatchFlag = (code == 1);
+  sei_read_flag( pDecodedMessageOutputStream, code, "il_one_tile_per_tile_set_flag"              ); sei.m_ilOneTilePerTileSetFlag             = (code == 1);
+  if( !sei.m_ilOneTilePerTileSetFlag )
+  {
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "il_num_sets_in_message_minus1" ); sei.m_ilNumSetsInMessageMinus1 = code;
+    if( sei.m_ilNumSetsInMessageMinus1 )
+    {
+      sei_read_flag( pDecodedMessageOutputStream, code, "skipped_tile_set_present_flag" ); sei.m_skippedTileSetPresentFlag = (code == 1);
+    }
+    Int numSignificantSets = sei.m_ilNumSetsInMessageMinus1 - sei.m_skippedTileSetPresentFlag + 1;
+
+    sei.resizeDimI( numSignificantSets );
+    for( Int i = 0; i < numSignificantSets; i++ )
+    {
+      sei_read_uvlc( pDecodedMessageOutputStream, code, "ilcts_id"                        ); sei.m_ilctsId                  [i] = code;
+      sei_read_uvlc( pDecodedMessageOutputStream, code, "il_num_tile_rects_in_set_minus1" ); sei.m_ilNumTileRectsInSetMinus1[i] = code;
+
+      sei.resizeDimJ( i, sei.m_ilNumTileRectsInSetMinus1[ i ] + 1 );
+      for( Int j = 0; j  <=  sei.m_ilNumTileRectsInSetMinus1[ i ]; j++ )
+      {
+        sei_read_uvlc( pDecodedMessageOutputStream, code, "il_top_left_tile_index"     ); sei.m_ilTopLeftTileIndex    [i][j] = code;
+        sei_read_uvlc( pDecodedMessageOutputStream, code, "il_bottom_right_tile_index" ); sei.m_ilBottomRightTileIndex[i][j] = code;
+      }
+      sei_read_code( pDecodedMessageOutputStream, 2, code, "ilc_idc" ); sei.m_ilcIdc[i] = code;
+      if ( !sei.m_ilAllTilesExactSampleValueMatchFlag )
+      {
+        sei_read_flag( pDecodedMessageOutputStream, code, "il_exact_sample_value_match_flag" ); sei.m_ilExactSampleValueMatchFlag[i] = (code == 1);
+      }
+    }
+  }
+  else
+  {
+    sei_read_code( pDecodedMessageOutputStream, 2, code, "all_tiles_ilc_idc" ); sei.m_allTilesIlcIdc = code;
+  }
+};
+
+#if NH_MV_SEI_TBD
+Void SEIReader::xParseSEIBspNesting(SEIBspNesting& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
+{
+  UInt code;
+  output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
+
+  sei_read_uvlc( pDecodedMessageOutputStream, code, "sei_ols_idx" ); sei.m_seiOlsIdx = code;
+  sei_read_uvlc( pDecodedMessageOutputStream, code, "sei_partitioning_scheme_idx" ); sei.m_seiPartitioningSchemeIdx = code;
+  sei_read_uvlc( pDecodedMessageOutputStream, code, "bsp_idx" ); sei.m_bspIdx = code;
+  while( !ByteaLigned(() ) );
+  {
+    sei_read_code( pDecodedMessageOutputStream, *equalto0*/u1, code, "bsp_nesting_zero_bit" ); sei.m_bspNestingZeroBit = code;
+  }
+  sei_read_uvlc( pDecodedMessageOutputStream, code, "num_seis_in_bsp_minus1" ); sei.m_numSeisInBspMinus1 = code;
+  for( Int i = 0; i  <=  NumSeisInBspMinus1( ); i++ )
+  {
+    SeiMessage(() );
+  }
+};
+
+Void SEIReader::xParseSEIBspInitialArrivalTime(SEIBspInitialArrivalTime& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
+{
+  UInt code;
+  output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
+
+  psIdx = SeiPartitioningSchemeIdx();
+  if( nalInitialArrivalDelayPresent )
+  {
+    for( Int i = 0; i < BspSchedCnt( SeiOlsIdx(), psIdx, MaxTemporalId( 0 ) ); i++ )
+    {
+      sei_read_code( pDecodedMessageOutputStream, getNalInitialArrivalDelayLen ), code, "nal_initial_arrival_delay" ); sei.m_nalInitialArrivalDelay[i] = code;
+    }
+  }
+  if( vclInitialArrivalDelayPresent )
+  {
+    for( Int i = 0; i < BspSchedCnt( SeiOlsIdx(), psIdx, MaxTemporalId( 0 ) ); i++ )
+    {
+      sei_read_code( pDecodedMessageOutputStream, getVclInitialArrivalDelayLen ), code, "vcl_initial_arrival_delay" ); sei.m_vclInitialArrivalDelay[i] = code;
+    }
+  }
+};
+#endif
+
+Void SEIReader::xParseSEISubBitstreamProperty(SEISubBitstreamProperty& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
+{
+  UInt code;
+  output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
+
+  sei_read_code( pDecodedMessageOutputStream, 4, code, "sb_property_active_vps_id" ); sei.m_sbPropertyActiveVpsId = code;
+  sei_read_uvlc( pDecodedMessageOutputStream, code, "num_additional_sub_streams_minus1" ); sei.m_numAdditionalSubStreamsMinus1 = code;
+  sei.resizeArrays( );
+  for( Int i = 0; i  <=  sei.m_numAdditionalSubStreamsMinus1; i++ )
+  {
+    sei_read_code( pDecodedMessageOutputStream, 2, code, "sub_bitstream_mode" ); sei.m_subBitstreamMode[i] = code;
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "ols_idx_to_vps" ); sei.m_olsIdxToVps[i] = code;
+    sei_read_code( pDecodedMessageOutputStream, 3, code, "highest_sublayer_id" ); sei.m_highestSublayerId[i] = code;
+    sei_read_code( pDecodedMessageOutputStream, 16, code, "avg_sb_property_bit_rate" ); sei.m_avgSbPropertyBitRate[i] = code;
+    sei_read_code( pDecodedMessageOutputStream, 16, code, "max_sb_property_bit_rate" ); sei.m_maxSbPropertyBitRate[i] = code;
+  }
+};
+
+Void SEIReader::xParseSEIAlphaChannelInfo(SEIAlphaChannelInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
+{
+  UInt code;
+  output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
+
+  sei_read_flag( pDecodedMessageOutputStream, code, "alpha_channel_cancel_flag" ); sei.m_alphaChannelCancelFlag = (code == 1);
+  if( !sei.m_alphaChannelCancelFlag )
+  {
+    sei_read_code( pDecodedMessageOutputStream, 3, code, "alpha_channel_use_idc" ); sei.m_alphaChannelUseIdc = code;
+    sei_read_code( pDecodedMessageOutputStream, 3, code, "alpha_channel_bit_depth_minus8" ); sei.m_alphaChannelBitDepthMinus8 = code;
+    sei_read_code( pDecodedMessageOutputStream, sei.m_alphaChannelBitDepthMinus8+9, code, "alpha_transparent_value" ); sei.m_alphaTransparentValue = code;
+    sei_read_code( pDecodedMessageOutputStream, sei.m_alphaChannelBitDepthMinus8+9, code, "alpha_opaque_value" ); sei.m_alphaOpaqueValue = code;
+    sei_read_flag( pDecodedMessageOutputStream, code, "alpha_channel_incr_flag" ); sei.m_alphaChannelIncrFlag = (code == 1);
+    sei_read_flag( pDecodedMessageOutputStream, code, "alpha_channel_clip_flag" ); sei.m_alphaChannelClipFlag = (code == 1);
+    if( sei.m_alphaChannelClipFlag )
+    {
+      sei_read_flag( pDecodedMessageOutputStream, code, "alpha_channel_clip_type_flag" ); sei.m_alphaChannelClipTypeFlag = (code == 1);
+    }
+  }
+};
+
+Void SEIReader::xParseSEIOverlayInfo(SEIOverlayInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
+{
+  UInt code;
+  output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
+
+  sei_read_flag( pDecodedMessageOutputStream, code, "overlay_info_cancel_flag" ); sei.m_overlayInfoCancelFlag = (code == 1);
+  if( !sei.m_overlayInfoCancelFlag )
+  {
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "overlay_content_aux_id_minus128" );            sei.m_overlayContentAuxIdMinus128 = code;
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "overlay_label_aux_id_minus128" );              sei.m_overlayLabelAuxIdMinus128 = code;
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "overlay_alpha_aux_id_minus128" );              sei.m_overlayAlphaAuxIdMinus128 = code;
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "overlay_element_label_value_length_minus8" );  sei.m_overlayElementLabelValueLengthMinus8 = code;
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "num_overlays_minus1" );                        sei.m_numOverlaysMinus1 = code;
+
+    sei.m_overlayIdx.resize( sei.m_numOverlaysMinus1+1 );
+    sei.m_languageOverlayPresentFlag.resize( sei.m_numOverlaysMinus1+1 );
+    sei.m_overlayContentLayerId.resize     ( sei.m_numOverlaysMinus1+1 );
+    sei.m_overlayLabelPresentFlag.resize   ( sei.m_numOverlaysMinus1+1 );
+    sei.m_overlayLabelLayerId.resize       ( sei.m_numOverlaysMinus1+1 );
+    sei.m_overlayAlphaPresentFlag.resize   ( sei.m_numOverlaysMinus1+1 );
+    sei.m_overlayAlphaLayerId.resize       ( sei.m_numOverlaysMinus1+1 );
+    sei.m_numOverlayElementsMinus1.resize  ( sei.m_numOverlaysMinus1+1 );
+    sei.m_overlayElementLabelMin.resize    ( sei.m_numOverlaysMinus1+1 );
+    sei.m_overlayElementLabelMax.resize    ( sei.m_numOverlaysMinus1+1 );
+    for( Int i = 0; i  <=  sei.m_numOverlaysMinus1; i++ )
+    {
+      sei_read_uvlc( pDecodedMessageOutputStream, code, "overlay_idx" );                    sei.m_overlayIdx[i]                 = code;
+      sei_read_flag( pDecodedMessageOutputStream, code, "language_overlay_present_flag" );  sei.m_languageOverlayPresentFlag[i] = (code == 1);
+      sei_read_code( pDecodedMessageOutputStream, 6, code, "overlay_content_layer_id" );    sei.m_overlayContentLayerId[i]      = code;
+      sei_read_flag( pDecodedMessageOutputStream, code, "overlay_label_present_flag" );     sei.m_overlayLabelPresentFlag[i]    = (code == 1);
+      if( sei.m_overlayLabelPresentFlag[i] )
+      {
+        sei_read_code( pDecodedMessageOutputStream, 6, code, "overlay_label_layer_id" );     sei.m_overlayLabelLayerId[i]       = code;
+      }
+      sei_read_flag( pDecodedMessageOutputStream, code, "overlay_alpha_present_flag" );      sei.m_overlayAlphaPresentFlag[i]   = (code == 1);
+      if( sei.m_overlayAlphaPresentFlag[i] )
+      {
+        sei_read_code( pDecodedMessageOutputStream, 6, code, "overlay_alpha_layer_id" );     sei.m_overlayAlphaLayerId[i]       = code;
+      }
+      if( sei.m_overlayLabelPresentFlag[i] )
+      {
+        sei_read_uvlc( pDecodedMessageOutputStream, code, "num_overlay_elements_minus1" );   sei.m_numOverlayElementsMinus1[i]  = code;
+        sei.m_overlayElementLabelMin[i].resize( sei.m_numOverlayElementsMinus1[i]+1 );
+        sei.m_overlayElementLabelMax[i].resize( sei.m_numOverlayElementsMinus1[i]+1 );
+        for( Int j = 0; j  <=  sei.m_numOverlayElementsMinus1[i]; j++ )
+        {
+          sei_read_code( pDecodedMessageOutputStream, sei.m_overlayElementLabelValueLengthMinus8 + 8, code, "overlay_element_label_min" ); sei.m_overlayElementLabelMin[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.m_overlayElementLabelValueLengthMinus8 + 8, code, "overlay_element_label_max" ); sei.m_overlayElementLabelMax[i][j] = code;
+        }
+      }
+    }
+
+    // byte alignment
+    while ( m_pcBitstream->getNumBitsRead() % 8 != 0 )
+    {
+      sei_read_flag( pDecodedMessageOutputStream, code, "overlay_zero_bit" );
+      assert( code==0 );
+    }
+
+    UChar* sval = new UChar[sei.m_numStringBytesMax];
+    UInt slen;
+    sei.m_overlayLanguage   .resize( sei.m_numOverlaysMinus1 + 1 );
+    sei.m_overlayName       .resize( sei.m_numOverlaysMinus1 + 1 );
+    sei.m_overlayElementName.resize( sei.m_numOverlaysMinus1 + 1 );
+    for( Int i = 0; i  <=  sei.m_numOverlaysMinus1; i++ )
+    {
+      if( sei.m_languageOverlayPresentFlag[i] )
+      {
+        sei_read_string(pDecodedMessageOutputStream, sei.m_numStringBytesMax, sval, slen, "overlay_language");
+        sei.m_overlayLanguage[i] = std::string((const char*) sval);
+      }
+      sei_read_string(pDecodedMessageOutputStream, sei.m_numStringBytesMax, sval, slen, "overlay_name");
+      sei.m_overlayName[i] = std::string((const char*) sval);
+      if( sei.m_overlayLabelPresentFlag[i] )
+      {
+        sei.m_overlayElementName[i].resize( sei.m_numOverlayElementsMinus1[i]+1 );
+        for( Int j = 0; j  <=  sei.m_numOverlayElementsMinus1[i]; j++ )
+        {
+          sei_read_string(pDecodedMessageOutputStream, sei.m_numStringBytesMax, sval, slen, "overlay_element_name");
+          sei.m_overlayElementName[i][j] = std::string((const char*) sval);
+        }
+      }
+    }
+    delete [] sval;
+    sei_read_flag( pDecodedMessageOutputStream, code, "overlay_info_persistence_flag" ); sei.m_overlayInfoPersistenceFlag = (code == 1);
+  }
+};
+
+Void SEIReader::xParseSEITemporalMvPredictionConstraints(SEITemporalMvPredictionConstraints& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
+{
+  UInt code;
+  output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
+
+  sei_read_flag( pDecodedMessageOutputStream, code, "prev_pics_not_used_flag"     ); sei.m_prevPicsNotUsedFlag    = (code == 1);
+  sei_read_flag( pDecodedMessageOutputStream, code, "no_intra_layer_col_pic_flag" ); sei.m_noIntraLayerColPicFlag = (code == 1);
+};
+
+#if NH_MV_SEI_TBD
+Void SEIReader::xParseSEIFrameFieldInfo(SEIFrameFieldInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
+{
+  UInt code;
+  output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
+
+  sei_read_code( pDecodedMessageOutputStream, 4, code, "ffinfo_pic_struct" ); sei.m_ffinfoPicStruct = code;
+  sei_read_code( pDecodedMessageOutputStream, 2, code, "ffinfo_source_scan_type" ); sei.m_ffinfoSourceScanType = code;
+  sei_read_flag( pDecodedMessageOutputStream, code, "ffinfo_duplicate_flag" ); sei.m_ffinfoDuplicateFlag = (code == 1);
+};
+#endif
+
+Void SEIReader::xParseSEIThreeDimensionalReferenceDisplaysInfo(SEIThreeDimensionalReferenceDisplaysInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
+{
+  UInt code;
+  output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
+
+  sei_read_uvlc( pDecodedMessageOutputStream, code, "prec_ref_display_width" ); sei.m_precRefDisplayWidth = code;
+  sei_read_flag( pDecodedMessageOutputStream, code, "ref_viewing_distance_flag" ); sei.m_refViewingDistanceFlag = (code == 1);
+  if( sei.m_refViewingDistanceFlag )
+  {
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "prec_ref_viewing_dist" ); sei.m_precRefViewingDist = code;
+  }
+  sei_read_uvlc( pDecodedMessageOutputStream, code, "num_ref_displays_minus1" ); sei.m_numRefDisplaysMinus1 = code;
+  sei.resizeArrays( );
+  for( Int i = 0; i  <=  sei.getNumRefDisplaysMinus1( ); i++ )
+  {
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "left_view_id" ); sei.m_leftViewId[i] = code;
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "right_view_id" ); sei.m_rightViewId[i] = code;
+    sei_read_code( pDecodedMessageOutputStream, 6, code, "exponent_ref_display_width" ); sei.m_exponentRefDisplayWidth[i] = code;
+    sei_read_code( pDecodedMessageOutputStream, sei.getMantissaReferenceDisplayWidthLen(i), code, "mantissa_ref_display_width" ); sei.m_mantissaRefDisplayWidth[i] =  code      ;
+    if( sei.m_refViewingDistanceFlag )
+    {
+      sei_read_code( pDecodedMessageOutputStream, 6, code, "exponent_ref_viewing_distance" ); sei.m_exponentRefViewingDistance[i] = code;
+      sei_read_code( pDecodedMessageOutputStream, sei.getMantissaReferenceViewingDistanceLen(i), code, "mantissa_ref_viewing_distance" ); sei.m_mantissaRefViewingDistance[i] = code;
+    }
+    sei_read_flag( pDecodedMessageOutputStream, code, "additional_shift_present_flag" ); sei.m_additionalShiftPresentFlag[i] = (code == 1);
+    if( sei.m_additionalShiftPresentFlag[i] )
+    {
+      sei_read_code( pDecodedMessageOutputStream, 10, code, "num_sample_shift_plus512" ); sei.m_numSampleShiftPlus512[i] = code;
+    }
+  }
+  sei_read_flag( pDecodedMessageOutputStream, code, "three_dimensional_reference_displays_extension_flag" ); sei.m_threeDimensionalReferenceDisplaysExtensionFlag = (code == 1);
+};
+
+#if SEI_DRI_F0169
+Void SEIReader::xParseSEIDepthRepInfoElement(double& f,std::ostream *pDecodedMessageOutputStream)
+{
+    UInt val;
+    UInt x_sign,x_mantissa_len,x_mantissa;
+    Int x_exp;
+
+    sei_read_flag(pDecodedMessageOutputStream,     val,"da_sign_flag");  x_sign = val ? 1 : 0 ;
+    sei_read_code(pDecodedMessageOutputStream,  7, val, "da_exponent" );         x_exp = val-31;
+    sei_read_code(pDecodedMessageOutputStream,  5, val, "da_mantissa_len_minus1" );         x_mantissa_len = val+1;
+    sei_read_code(pDecodedMessageOutputStream,  x_mantissa_len, val, "da_mantissa" );         x_mantissa = val;
+    if (x_mantissa_len>=16)
+    {
+        f =1.0 +  (x_mantissa*1.0)/(1u<<(x_mantissa_len-16))/(256.0*256.0 );
+    }else
+    {
+        f =1.0 +  (x_mantissa*1.0)/(1u<<x_mantissa_len);
+    }
+    double m=1.0;
+    int i;
+    if (x_exp<0)
+    {
+        for(i=0;i<-x_exp;i++)
+            m = m * 2;
+
+        f = f/m;
+    }
+    else
+    {
+        for(i=0;i<x_exp;i++)
+            m = m * 2;
+
+        f= f * m;
+    }
+    if (x_sign==1)
+    {
+        f= -f;
+    }
+};
+
+Void SEIReader::xParseSEIDepthRepresentationInfo(SEIDepthRepresentationInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
+{
+    UInt code;
+    double zNear,zFar,dMin,dMax;
+    bool zNearFlag,zFarFlag,dMinFlag,dMaxFlag;
+    int depth_representation_type,disparityRefViewId,depthNonlinearRepresentationNumMinus1;
+    std::vector<int> DepthNonlinearRepresentationModel;
+
+    sei.clear();
+
+    output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
+
+    sei_read_flag( pDecodedMessageOutputStream, code, "z_near_flag" );    zNearFlag  = (code == 1);
+    sei_read_flag( pDecodedMessageOutputStream, code, "z_far_flag" );     zFarFlag = (code == 1);
+    sei_read_flag( pDecodedMessageOutputStream, code, "d_min_flag" );     dMinFlag = (code == 1);
+    sei_read_flag( pDecodedMessageOutputStream, code, "d_max_flag" );     dMaxFlag = (code == 1);
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "depth_representation_type" ); depth_representation_type = code;
+
+    sei.m_zNearFlag.push_back(zNearFlag);
+    sei.m_zFarFlag.push_back(zFarFlag);
+    sei.m_dMinFlag.push_back(dMinFlag);
+    sei.m_dMaxFlag.push_back(dMaxFlag);
+
+    sei.m_depthRepresentationType.push_back(IntAry1d(1,depth_representation_type));
+
+    if( dMinFlag  ||  dMaxFlag )
+    {
+        sei_read_uvlc( pDecodedMessageOutputStream, code, "disparity_ref_view_id" ); disparityRefViewId = code;
+        sei.m_disparityRefViewId.push_back(IntAry1d(1,disparityRefViewId));
+    }
+    if( zNearFlag )
+    {
+        xParseSEIDepthRepInfoElement(zNear , pDecodedMessageOutputStream);
+        sei.m_zNear.push_back(std::vector<double>(1,zNear));
+    }
+    if( zFarFlag )
+    {
+        xParseSEIDepthRepInfoElement(zFar , pDecodedMessageOutputStream);
+        sei.m_zFar.push_back(std::vector<double>(1,zFar));
+    }
+    if( dMinFlag )
+    {
+        xParseSEIDepthRepInfoElement(dMin , pDecodedMessageOutputStream);
+        sei.m_dMin.push_back(std::vector<double>(1,dMin));
+    }
+    if( dMaxFlag )
+    {
+        xParseSEIDepthRepInfoElement(dMax , pDecodedMessageOutputStream);
+        sei.m_dMax.push_back(std::vector<double>(1,dMax));
+    }
+    if( depth_representation_type  ==  3 )
+    {
+        sei_read_uvlc( pDecodedMessageOutputStream, code, "depth_nonlinear_representation_num_minus1" ); depthNonlinearRepresentationNumMinus1 = code;
+        sei.m_depthNonlinearRepresentationNumMinus1.push_back(IntAry1d(1,depthNonlinearRepresentationNumMinus1));
+        for( Int i = 1; i  <=  depthNonlinearRepresentationNumMinus1 + 1; i++ )
+        {
+            sei_read_uvlc(pDecodedMessageOutputStream,code,"DepthNonlinearRepresentationModel" ) ;
+            DepthNonlinearRepresentationModel.push_back(code);
+        }
+
+        sei.m_depth_nonlinear_representation_model.push_back(DepthNonlinearRepresentationModel);
+    }
+}
+#endif
+Void SEIReader::xParseSEIMultiviewSceneInfo(SEIMultiviewSceneInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
+{
+  UInt  code;
+  Int  sCode;
+  output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
+
+  sei_read_svlc( pDecodedMessageOutputStream, sCode, "min_disparity" )      ; sei.m_minDisparity      = sCode;
+  sei_read_uvlc( pDecodedMessageOutputStream, code , "max_disparity_range" ); sei.m_maxDisparityRange = code;
+};
+
+Void SEIReader::xParseSEIMultiviewAcquisitionInfo(SEIMultiviewAcquisitionInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
+{
+  UInt code;
+  output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
+
+  sei.resizeArrays( );
+  sei_read_flag( pDecodedMessageOutputStream, code, "intrinsic_param_flag" ); sei.m_intrinsicParamFlag = (code == 1);
+  sei_read_flag( pDecodedMessageOutputStream, code, "extrinsic_param_flag" ); sei.m_extrinsicParamFlag = (code == 1);
+  if( sei.m_intrinsicParamFlag )
+  {
+    sei_read_flag( pDecodedMessageOutputStream, code, "intrinsic_params_equal_flag" ); sei.m_intrinsicParamsEqualFlag = (code == 1);
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "prec_focal_length"           ); sei.m_precFocalLength          =  code      ;
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "prec_principal_point"        ); sei.m_precPrincipalPoint       =  code      ;
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "prec_skew_factor"            ); sei.m_precSkewFactor           =  code      ;
+
+    for( Int i = 0; i  <=  ( sei.m_intrinsicParamsEqualFlag ? 0 : sei.getNumViewsMinus1() ); i++ )
+    {
+      sei_read_flag( pDecodedMessageOutputStream,                                         code, "sign_focal_length_x"        ); sei.m_signFocalLengthX       [i] = (code == 1);
+      sei_read_code( pDecodedMessageOutputStream, 6,                                      code, "exponent_focal_length_x"    ); sei.m_exponentFocalLengthX   [i] =  code      ;
+      sei_read_code( pDecodedMessageOutputStream, sei.getMantissaFocalLengthXLen   ( i ), code, "mantissa_focal_length_x"    ); sei.m_mantissaFocalLengthX   [i] =  code      ;
+      sei_read_flag( pDecodedMessageOutputStream,                                         code, "sign_focal_length_y"        ); sei.m_signFocalLengthY       [i] = (code == 1);
+      sei_read_code( pDecodedMessageOutputStream, 6,                                      code, "exponent_focal_length_y"    ); sei.m_exponentFocalLengthY   [i] =  code      ;
+      sei_read_code( pDecodedMessageOutputStream, sei.getMantissaFocalLengthYLen   ( i ), code, "mantissa_focal_length_y"    ); sei.m_mantissaFocalLengthY   [i] =  code      ;
+      sei_read_flag( pDecodedMessageOutputStream,                                         code, "sign_principal_point_x"     ); sei.m_signPrincipalPointX    [i] = (code == 1);
+      sei_read_code( pDecodedMessageOutputStream, 6,                                      code, "exponent_principal_point_x" ); sei.m_exponentPrincipalPointX[i] =  code      ;
+      sei_read_code( pDecodedMessageOutputStream, sei.getMantissaPrincipalPointXLen( i ), code, "mantissa_principal_point_x" ); sei.m_mantissaPrincipalPointX[i] =  code      ;
+      sei_read_flag( pDecodedMessageOutputStream,                                         code, "sign_principal_point_y"     ); sei.m_signPrincipalPointY    [i] = (code == 1);
+      sei_read_code( pDecodedMessageOutputStream, 6,                                      code, "exponent_principal_point_y" ); sei.m_exponentPrincipalPointY[i] =  code      ;
+      sei_read_code( pDecodedMessageOutputStream, sei.getMantissaPrincipalPointYLen( i ), code, "mantissa_principal_point_y" ); sei.m_mantissaPrincipalPointY[i] =  code      ;
+      sei_read_flag( pDecodedMessageOutputStream,                                         code, "sign_skew_factor"           ); sei.m_signSkewFactor         [i] = (code == 1);
+      sei_read_code( pDecodedMessageOutputStream, 6,                                      code, "exponent_skew_factor"       ); sei.m_exponentSkewFactor     [i] =  code      ;
+      sei_read_code( pDecodedMessageOutputStream, sei.getMantissaSkewFactorLen     ( i ), code, "mantissa_skew_factor"       ); sei.m_mantissaSkewFactor     [i] =  code      ;
+    }
+  }
+  if( sei.m_extrinsicParamFlag )
+  {
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "prec_rotation_param"    ); sei.m_precRotationParam    = code;
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "prec_translation_param" ); sei.m_precTranslationParam = code;
+
+    for( Int i = 0; i  <=  sei.getNumViewsMinus1(); i++ )
+    {
+      for( Int j = 0; j  <=  2; j++ )  /* row */
+      {
+        for( Int k = 0; k  <=  2; k++ )  /* column */
+        {
+          sei_read_flag( pDecodedMessageOutputStream,                                 code, "sign_r"     ); sei.m_signR    [i][j][k] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 6,                              code, "exponent_r" ); sei.m_exponentR[i][j][k] =  code      ;
+          sei_read_code( pDecodedMessageOutputStream, sei.getMantissaRLen( i, j, k ), code, "mantissa_r" ); sei.m_mantissaR[i][j][k] =  code      ;
+        }
+        sei_read_flag( pDecodedMessageOutputStream,                              code, "sign_t"     ); sei.m_signT    [i][j] = (code == 1);
+        sei_read_code( pDecodedMessageOutputStream, 6,                           code, "exponent_t" ); sei.m_exponentT[i][j] =  code      ;
+        sei_read_code( pDecodedMessageOutputStream, sei.getMantissaTLen( i, j ), code, "mantissa_t" ); sei.m_mantissaT[i][j] =  code      ;
+      }
+    }
+  }
+};
+
+
+
+Void SEIReader::xParseSEIMultiviewViewPosition(SEIMultiviewViewPosition& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
+{
+  UInt code;
+  output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
+
+  sei_read_uvlc( pDecodedMessageOutputStream, code, "num_views_minus1" ); sei.m_numViewsMinus1 = code;
+  sei.m_viewPosition.resize( sei.m_numViewsMinus1 + 1 );
+  for( Int i = 0; i  <=  sei.m_numViewsMinus1; i++ )
+  {
+    sei_read_uvlc( pDecodedMessageOutputStream, code, "view_position" ); sei.m_viewPosition[i] = code;
+  }
+};
+
+#if NH_3D
+Void SEIReader::xParseSEIAlternativeDepthInfo(SEIAlternativeDepthInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
+{
+  UInt code;
+  Int scode;
+  output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
+
+  sei.resizeArrays( );
+  sei_read_flag( pDecodedMessageOutputStream, code, "alternative_depth_info_cancel_flag" ); sei.m_alternativeDepthInfoCancelFlag = (code == 1);
+  if( sei.m_alternativeDepthInfoCancelFlag  ==  0 )
+  {
+    sei_read_code( pDecodedMessageOutputStream, 2, code, "depth_type" ); sei.m_depthType = code;
+    if( sei.m_depthType  ==  0 )
+    {
+      sei_read_uvlc( pDecodedMessageOutputStream, code, "num_constituent_views_gvd_minus1" ); sei.m_numConstituentViewsGvdMinus1 = code;
+      sei_read_flag( pDecodedMessageOutputStream, code, "depth_present_gvd_flag" ); sei.m_depthPresentGvdFlag = (code == 1);
+      sei_read_flag( pDecodedMessageOutputStream, code, "z_gvd_flag" ); sei.m_zGvdFlag = (code == 1);
+      sei_read_flag( pDecodedMessageOutputStream, code, "intrinsic_param_gvd_flag" ); sei.m_intrinsicParamGvdFlag = (code == 1);
+      sei_read_flag( pDecodedMessageOutputStream, code, "rotation_gvd_flag" ); sei.m_rotationGvdFlag = (code == 1);
+      sei_read_flag( pDecodedMessageOutputStream, code, "translation_gvd_flag" ); sei.m_translationGvdFlag = (code == 1);
+      if( sei.m_zGvdFlag )
+      {
+        for( Int i = 0, j = 0; j <=  sei.m_numConstituentViewsGvdMinus1 + 1; j++ )
+        {
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_z_near_flag" ); sei.m_signGvdZNearFlag[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 7, code, "exp_gvd_z_near" ); sei.m_expGvdZNear[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, 5, code, "man_len_gvd_z_near_minus1" ); sei.m_manLenGvdZNearMinus1[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.m_manLenGvdZNearMinus1[i][j]+1, code, "man_gvd_z_near" ); sei.m_manGvdZNear[i][j] = code;
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_z_far_flag" ); sei.m_signGvdZFarFlag[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 7, code, "exp_gvd_z_far" ); sei.m_expGvdZFar[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, 5, code, "man_len_gvd_z_far_minus1" ); sei.m_manLenGvdZFarMinus1[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.m_manLenGvdZFarMinus1[i][j]+1, code, "man_gvd_z_far" ); sei.m_manGvdZFar[i][j] = code;
+        }
+      }
+      if( sei.m_intrinsicParamGvdFlag )
+      {
+        sei_read_uvlc( pDecodedMessageOutputStream, code, "prec_gvd_focal_length" ); sei.m_precGvdFocalLength = code;
+        sei_read_uvlc( pDecodedMessageOutputStream, code, "prec_gvd_principal_point" ); sei.m_precGvdPrincipalPoint = code;
+      }
+      if( sei.m_rotationGvdFlag )
+      {
+        sei_read_uvlc( pDecodedMessageOutputStream, code, "prec_gvd_rotation_param" ); sei.m_precGvdRotationParam = code;
+      }
+      if( sei.m_translationGvdFlag )
+      {
+        sei_read_uvlc( pDecodedMessageOutputStream, code, "prec_gvd_translation_param" ); sei.m_precGvdTranslationParam = code;
+      }
+      for( Int i = 0, j = 0; j <= sei.m_numConstituentViewsGvdMinus1 + 1; j++ )
+      {
+        if( sei.m_intrinsicParamGvdFlag )
+        {
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_focal_length_x" ); sei.m_signGvdFocalLengthX[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 6, code, "exp_gvd_focal_length_x" ); sei.m_expGvdFocalLengthX[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.getManGvdFocalLengthXLen(i,j), code, "man_gvd_focal_length_x" ); sei.m_manGvdFocalLengthX[i][j] = code;
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_focal_length_y" ); sei.m_signGvdFocalLengthY[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 6, code, "exp_gvd_focal_length_y" ); sei.m_expGvdFocalLengthY[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.getManGvdFocalLengthYLen(i,j), code, "man_gvd_focal_length_y" ); sei.m_manGvdFocalLengthY[i][j] = code;
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_principal_point_x" ); sei.m_signGvdPrincipalPointX[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 6, code, "exp_gvd_principal_point_x" ); sei.m_expGvdPrincipalPointX[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.getManGvdPrincipalPointXLen(i,j), code, "man_gvd_principal_point_x" ); sei.m_manGvdPrincipalPointX[i][j] = code;
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_principal_point_y" ); sei.m_signGvdPrincipalPointY[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 6, code, "exp_gvd_principal_point_y" ); sei.m_expGvdPrincipalPointY[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.getManGvdPrincipalPointYLen(i,j), code, "man_gvd_principal_point_y" ); sei.m_manGvdPrincipalPointY[i][j] = code;
+        }
+        if( sei.m_rotationGvdFlag )
+        {
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_r00" ); sei.m_signGvdR00[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 6, code, "exp_gvd_r00" ); sei.m_expGvdR00[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.m_precGvdRotationParam, code, "man_gvd_r00" ); sei.m_manGvdR00[i][j] = code;
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_r01" ); sei.m_signGvdR01[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 6, code, "exp_gvd_r01" ); sei.m_expGvdR01[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.m_precGvdRotationParam, code, "man_gvd_r01" ); sei.m_manGvdR01[i][j] = code;
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_r02" ); sei.m_signGvdR02[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 6, code, "exp_gvd_r02" ); sei.m_expGvdR02[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.m_precGvdRotationParam, code, "man_gvd_r02" ); sei.m_manGvdR02[i][j] = code;
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_r10" ); sei.m_signGvdR10[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 6, code, "exp_gvd_r10" ); sei.m_expGvdR10[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.m_precGvdRotationParam, code, "man_gvd_r10" ); sei.m_manGvdR10[i][j] = code;
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_r11" ); sei.m_signGvdR11[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 6, code, "exp_gvd_r11" ); sei.m_expGvdR11[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.m_precGvdRotationParam, code, "man_gvd_r11" ); sei.m_manGvdR11[i][j] = code;
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_r12" ); sei.m_signGvdR12[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 6, code, "exp_gvd_r12" ); sei.m_expGvdR12[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.m_precGvdRotationParam, code, "man_gvd_r12" ); sei.m_manGvdR12[i][j] = code;
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_r20" ); sei.m_signGvdR20[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 6, code, "exp_gvd_r20" ); sei.m_expGvdR20[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.m_precGvdRotationParam, code, "man_gvd_r20" ); sei.m_manGvdR20[i][j] = code;
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_r21" ); sei.m_signGvdR21[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 6, code, "exp_gvd_r21" ); sei.m_expGvdR21[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.m_precGvdRotationParam, code, "man_gvd_r21" ); sei.m_manGvdR21[i][j] = code;
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_r22" ); sei.m_signGvdR22[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 6, code, "exp_gvd_r22" ); sei.m_expGvdR22[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.m_precGvdRotationParam, code, "man_gvd_r22" ); sei.m_manGvdR22[i][j] = code;
+          //sei_read_code( pDecodedMessageOutputStream, sei.getManGvdRLen(i,j,k), code, "man_gvd_r" ); sei.m_manGvdR[i][j] = code;
+        }
+        if( sei.m_translationGvdFlag )
+        {
+          sei_read_flag( pDecodedMessageOutputStream, code, "sign_gvd_t_x" ); sei.m_signGvdTX[i][j] = (code == 1);
+          sei_read_code( pDecodedMessageOutputStream, 6, code, "exp_gvd_t_x" ); sei.m_expGvdTX[i][j] = code;
+          sei_read_code( pDecodedMessageOutputStream, sei.getManGvdTXLen(i,j), code, "man_gvd_t_x" ); sei.m_manGvdTX[i][j] = code;
+        }
+      }
+    }
+
+    if( sei.m_depthType  ==  1 )
+    {
+      sei_read_svlc( pDecodedMessageOutputStream, scode, "min_offset_x_int" ); sei.m_minOffsetXInt = scode;
+      sei_read_code( pDecodedMessageOutputStream, 8, code, "min_offset_x_frac" ); sei.m_minOffsetXFrac = code;
+      sei_read_svlc( pDecodedMessageOutputStream, scode, "max_offset_x_int" ); sei.m_maxOffsetXInt = scode;
+      sei_read_code( pDecodedMessageOutputStream, 8, code, "max_offset_x_frac" ); sei.m_maxOffsetXFrac = code;
+      sei_read_flag( pDecodedMessageOutputStream, code, "offset_y_present_flag" ); sei.m_offsetYPresentFlag = (code == 1);
+      if( sei.m_offsetYPresentFlag )
+      {
+        sei_read_svlc( pDecodedMessageOutputStream, scode, "min_offset_y_int" ); sei.m_minOffsetYInt = scode;
+        sei_read_code( pDecodedMessageOutputStream, 8, code, "min_offset_y_frac" ); sei.m_minOffsetYFrac = code;
+        sei_read_svlc( pDecodedMessageOutputStream, scode, "max_offset_y_int" ); sei.m_maxOffsetYInt = scode;
+        sei_read_code( pDecodedMessageOutputStream, 8, code, "max_offset_y_frac" ); sei.m_maxOffsetYFrac = code;
+      }
+      sei_read_flag( pDecodedMessageOutputStream, code, "warp_map_size_present_flag" ); sei.m_warpMapSizePresentFlag = (code == 1);
+      if( sei.m_warpMapSizePresentFlag )
+      {
+        sei_read_uvlc( pDecodedMessageOutputStream, code, "warp_map_width_minus2" ); sei.m_warpMapWidthMinus2 = code;
+        sei_read_uvlc( pDecodedMessageOutputStream, code, "warp_map_height_minus2" ); sei.m_warpMapHeightMinus2 = code;
+      }
+    }
+  }
+};
+#endif
+
 //! \}

trunk/source/Lib/TLibDecoder/SEIread.h

@@ -56 +56 @@
   SEIReader() {};
   virtual ~SEIReader() {};
+#if NH_MV_LAYERS_NOT_PRESENT_SEI
+  Void parseSEImessage(TComInputBitstream* bs, SEIMessages& seis, const NalUnitType nalUnitType, const TComVPS *vps, const TComSPS *sps, std::ostream *pDecodedMessageOutputStream);
+#else
   Void parseSEImessage(TComInputBitstream* bs, SEIMessages& seis, const NalUnitType nalUnitType, const TComSPS *sps, std::ostream *pDecodedMessageOutputStream);
+#endif
+#if NH_MV_SEI
+  Void setLayerId                            ( Int   layerId )   { m_layerId  = layerId; }; 
+  Void setDecOrder                           ( Int64 decOrder )  { m_decOrder = decOrder; }; 
+#endif
 protected:
+#if NH_MV_LAYERS_NOT_PRESENT_SEI
+  Void xReadSEImessage                        (SEIMessages& seis, const NalUnitType nalUnitType, const TComVPS *vps, const TComSPS *sps, std::ostream *pDecodedMessageOutputStream);
+#else
   Void xReadSEImessage                        (SEIMessages& seis, const NalUnitType nalUnitType, const TComSPS *sps, std::ostream *pDecodedMessageOutputStream);
+#endif
   Void xParseSEIuserDataUnregistered          (SEIuserDataUnregistered &sei,          UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
   Void xParseSEIActiveParameterSets           (SEIActiveParameterSets  &sei,          UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
@@ -74 +86 @@
   Void xParseSEIToneMappingInfo               (SEIToneMappingInfo& sei,               UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
   Void xParseSEISOPDescription                (SEISOPDescription &sei,                UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
+#if NH_MV_LAYERS_NOT_PRESENT_SEI
+  Void xParseSEIScalableNesting               (SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, const TComVPS *vps, const TComSPS *sps, std::ostream *pDecodedMessageOutputStream);
+#else
   Void xParseSEIScalableNesting               (SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, const TComSPS *sps, std::ostream *pDecodedMessageOutputStream);
+#endif
   Void xParseSEITempMotionConstraintsTileSets (SEITempMotionConstrainedTileSets& sei, UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
   Void xParseSEITimeCode                      (SEITimeCode& sei,                      UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
@@ -81 +97 @@
   Void xParseSEIMasteringDisplayColourVolume  (SEIMasteringDisplayColourVolume& sei,  UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
 #if NH_MV
+#if !NH_MV_SEI
   Void  xParseSEISubBitstreamProperty         (SEISubBitstreamProperty &sei        ,  UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
   Void  xResizeSubBitstreamPropertySeiArrays  (SEISubBitstreamProperty &sei);
+#endif
+#endif
+#if NH_MV_LAYERS_NOT_PRESENT_SEI
+  Void xParseSEILayersNotPresent              (SEILayersNotPresent &sei, UInt payloadSize, const TComVPS *vps ,std::ostream *pDecodedMessageOutputStream);
+#endif
+  Void xParseSEIInterLayerConstrainedTileSets (SEIInterLayerConstrainedTileSets& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream);
+#if NH_MV_SEI_TBD
+  Void xParseSEIBspNesting                    (SEIBspNesting& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream);
+  Void xParseSEIBspInitialArrivalTime         (SEIBspInitialArrivalTime& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream);
+#endif
+  Void xParseSEISubBitstreamProperty          (SEISubBitstreamProperty& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream);
+  Void xParseSEIAlphaChannelInfo              (SEIAlphaChannelInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream);
+  Void xParseSEIOverlayInfo                   (SEIOverlayInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream);
+  Void xParseSEITemporalMvPredictionConstraints(SEITemporalMvPredictionConstraints& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream);
+#if NH_MV_SEI_TBD
+  Void xParseSEIFrameFieldInfo                (SEIFrameFieldInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream);
+#endif
+  Void xParseSEIThreeDimensionalReferenceDisplaysInfo (SEIThreeDimensionalReferenceDisplaysInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream);
+#if SEI_DRI_F0169
+  Void xParseSEIDepthRepInfoElement           (double &f,std::ostream *pDecodedMessageOutputStream);
+  Void xParseSEIDepthRepresentationInfo       (SEIDepthRepresentationInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream);
+#endif
+  Void xParseSEIMultiviewSceneInfo            (SEIMultiviewSceneInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream);
+
+  Void xParseSEIMultiviewAcquisitionInfo      (SEIMultiviewAcquisitionInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream);
+
+#if NH_MV_SEI
+  Void xParseSEIMultiviewViewPosition         (SEIMultiviewViewPosition& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream);
+#endif
+#if NH_3D
+  Void xParseSEIAlternativeDepthInfo          (SEIAlternativeDepthInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream);
 #endif
 
@@ -89 +137 @@
   Void sei_read_svlc(std::ostream *pOS,                Int&  ruiCode, const Char *pSymbolName);
   Void sei_read_flag(std::ostream *pOS,                UInt& ruiCode, const Char *pSymbolName);
+  Void sei_read_string(std::ostream *pOS, UInt uiBufSize, UChar* pucCode, UInt& ruiLength, const Char *pSymbolName);
+#if NH_MV_SEI
+  inline Void output_sei_message_header(SEI &sei, std::ostream *pDecodedMessageOutputStream, UInt payloadSize);
+private: 
+  Int   m_layerId; 
+  Int64 m_decOrder;   
+#endif
 };
 

trunk/source/Lib/TLibDecoder/SyntaxElementParser.cpp

@@ -152 +152 @@
 }
 
+Void  SyntaxElementParser::xReadStringTr        (UInt buSize, UChar *pValue, UInt& rLength, const Char *pSymbolName)
+{
+#if RExt__DECODER_DEBUG_BIT_STATISTICS
+  xReadString (buSize, pValue, rLength, pSymbolName);
+#else
+  xReadString(buSize, pValue, rLength);
+#endif  
+  fprintf( g_hTrace, "%8lld  ", g_nSymbolCounter++ );
+  fprintf( g_hTrace, "%-50s st(v=%d)  : %s\n", pSymbolName, rLength, pValue ); 
+  fflush ( g_hTrace );
+}
+
 Void  xTraceAccessUnitDelimiter ()
 {
@@ -269 +281 @@
 }
 
+#if RExt__DECODER_DEBUG_BIT_STATISTICS
+Void  SyntaxElementParser::xReadString  (UInt bufSize, UChar *pVal, UInt& rLength, const Char *pSymbolName)
+#else
+Void  SyntaxElementParser::xReadString  (UInt bufSize, UChar *pVal, UInt& rLength)
+#endif
+{
+  assert( m_pcBitstream->getNumBitsRead() % 8 == 0 ); //always start reading at a byte-aligned position  
+  UInt val;
+  UInt i;
+  for (i=0 ; i<bufSize ; ++i ) 
+  {
+    m_pcBitstream->readByte( val );
+    pVal[i] = val;
+    if ( val == 0)
+    {
+      break;
+    }
+  }
+  rLength = i;
+  assert( pVal[rLength] == 0 );  
+}
+
 Void SyntaxElementParser::xReadRbspTrailingBits()
 {

trunk/source/Lib/TLibDecoder/SyntaxElementParser.h

@@ -49 +49 @@
 #define READ_SVLC(        code, name)     xReadSvlcTr (         code, name )
 #define READ_FLAG(        code, name)     xReadFlagTr (         code, name )
+#define READ_STRING(bufSize, code, length, name)   xReadStringTr ( bufSize, code, length, name )
 
 #else
@@ -58 +59 @@
 #define READ_SVLC(        code, name)     xReadSvlc (         code, name )
 #define READ_FLAG(        code, name)     xReadFlag (         code, name )
+#define READ_STRING(bufSize, code, length, name)   xReadString ( bufSize, code, length, name )
 
 #else
@@ -65 +67 @@
 #define READ_SVLC(        code, name)     xReadSvlc (         code )
 #define READ_FLAG(        code, name)     xReadFlag (         code )
+#define READ_STRING(bufSize, code, length, name)   xReadString ( bufSize, code, length )
 
 #endif
@@ -92 +95 @@
   Void  xReadSvlc    ( Int&   val, const Char *pSymbolName );
   Void  xReadFlag    ( UInt&  val, const Char *pSymbolName );
+  Void  xReadString  ( UInt bufSize, UChar *val, UInt& length, const Char *pSymbolName);
 #else
   Void  xReadCode    ( UInt   length, UInt& val );
@@ -97 +101 @@
   Void  xReadSvlc    ( Int&   val );
   Void  xReadFlag    ( UInt&  val );
+  Void  xReadString  ( UInt bufSize, UChar *val, UInt& length);
 #endif
 #if ENC_DEC_TRACE
@@ -103 +108 @@
   Void  xReadSvlcTr  (               Int& rValue, const Char *pSymbolName);
   Void  xReadFlagTr  (              UInt& rValue, const Char *pSymbolName);
+  Void  xReadStringTr(UInt bufSize, UChar *pValue, UInt& rLength, const Char *pSymbolName);
 #endif
 public:

trunk/source/Lib/TLibDecoder/TDecTop.cpp

@@ -59 +59 @@
   m_iLog2Precision   = LOG2_DISP_PREC_LUT;
   m_uiBitDepthForLUT = 8; // fixed
-  m_receivedIdc = NULL; 
-  m_vps         = NULL; 
+  m_receivedIdc = NULL;
+  m_vps         = NULL;
 }
 
@@ -75 +75 @@
   xDeleteArray( m_adBaseViewShiftLUT, MAX_NUM_LAYERS, MAX_NUM_LAYERS, 2 );
   xDeleteArray( m_aiBaseViewShiftLUT, MAX_NUM_LAYERS, MAX_NUM_LAYERS, 2 );
-  xDeleteArray( m_receivedIdc, m_vps->getNumViews() );
+  if ( m_receivedIdc != NULL )
+  {
+    xDeleteArray( m_receivedIdc, m_vps->getNumViews() );
+  }
 }
 
@@ -84 +87 @@
   assert( !isInitialized() ); // Only one initialization currently supported
   m_bInitialized            = true;
-  m_vps                     = vps; 
-  m_bCamParsVaryOverTime    = false;   
-  m_lastPoc                 = -1;   
-  m_firstReceivedPoc        = -2; 
+  m_vps                     = vps;
+  m_bCamParsVaryOverTime    = false;
+  m_lastPoc                 = -1;
+  m_firstReceivedPoc        = -2;
 
   for (Int i = 0; i <= vps->getMaxLayersMinus1(); i++)
   {
-    Int curViewIdxInVps = m_vps->getVoiInVps( m_vps->getViewIndex( m_vps->getLayerIdInNuh( i ) ) ) ; 
-    m_bCamParsVaryOverTime = m_bCamParsVaryOverTime || vps->getCpInSliceSegmentHeaderFlag( curViewIdxInVps );    
-  }
-
-  assert( m_receivedIdc == NULL ); 
-  m_receivedIdc = new Int*[ m_vps->getNumViews() ]; 
+    Int curViewIdxInVps = m_vps->getVoiInVps( m_vps->getViewIndex( m_vps->getLayerIdInNuh( i ) ) ) ;
+    m_bCamParsVaryOverTime = m_bCamParsVaryOverTime || vps->getCpInSliceSegmentHeaderFlag( curViewIdxInVps );
+  }
+
+  assert( m_receivedIdc == NULL );
+  m_receivedIdc = new Int*[ m_vps->getNumViews() ];
   for (Int i = 0; i < m_vps->getNumViews(); i++)
   {
-    m_receivedIdc[i] = new Int[ m_vps->getNumViews() ]; 
-  }
-
-  xResetReceivedIdc( true ); 
+    m_receivedIdc[i] = new Int[ m_vps->getNumViews() ];
+  }
+
+  xResetReceivedIdc( true );
 
   for (Int voiInVps = 0; voiInVps < m_vps->getNumViews(); voiInVps++ )
   {
-    if( !m_vps->getCpInSliceSegmentHeaderFlag( voiInVps ) ) 
+    if( !m_vps->getCpInSliceSegmentHeaderFlag( voiInVps ) )
     {
       for (Int baseVoiInVps = 0; baseVoiInVps < m_vps->getNumViews(); baseVoiInVps++ )
-      { 
+      {
         if( m_vps->getCpPresentFlag( voiInVps, baseVoiInVps ) )
         {
-          m_receivedIdc   [ baseVoiInVps ][ voiInVps ] = -1; 
+          m_receivedIdc   [ baseVoiInVps ][ voiInVps ] = -1;
           m_aaiCodedScale [ baseVoiInVps ][ voiInVps ] = m_vps->getCodedScale    (voiInVps) [ baseVoiInVps ];
           m_aaiCodedOffset[ baseVoiInVps ][ voiInVps ] = m_vps->getCodedOffset   (voiInVps) [ baseVoiInVps ];
 
-          m_receivedIdc   [ voiInVps ][ baseVoiInVps ] = -1; 
+          m_receivedIdc   [ voiInVps ][ baseVoiInVps ] = -1;
           m_aaiCodedScale [ voiInVps ][ baseVoiInVps ] = m_vps->getInvCodedScale (voiInVps) [ baseVoiInVps ];
           m_aaiCodedOffset[ voiInVps ][ baseVoiInVps ] = m_vps->getInvCodedOffset(voiInVps) [ baseVoiInVps ];
@@ -131 +134 @@
 {
   for (Int i = 0; i < m_vps->getNumViews(); i++)
-  {  
+  {
     for (Int j = 0; j < m_vps->getNumViews(); j++)
     {
       if ( overWriteFlag ||  ( m_receivedIdc[i][j] != -1 ) )
       {
-        m_receivedIdc[i][j] = 0; 
-      }      
+        m_receivedIdc[i][j] = 0;
+      }
     }
   }
@@ -171 +174 @@
 }
 
-Void 
+Void
   CamParsCollector::xInitLUTs( UInt uiSourceView, UInt uiTargetView, Int iScale, Int iOffset, Double****& radLUT, Int****& raiLUT)
 {
@@ -234 +237 @@
   if( m_firstReceivedPoc == -2 )
   {
-    m_firstReceivedPoc = curPoc; 
-  }
-
-  Bool newPocFlag = ( m_lastPoc != curPoc );  
+    m_firstReceivedPoc = curPoc;
+  }
+
+  Bool newPocFlag = ( m_lastPoc != curPoc );
 
   if ( newPocFlag )
-  {    
+  {
     if( m_lastPoc != -1 )
     {
@@ -246 +249 @@
     }
 
-    xResetReceivedIdc( false ); 
+    xResetReceivedIdc( false );
     m_lastPoc = pcSlice->getPOC();
   }
 
-  UInt voiInVps          = m_vps->getVoiInVps(pcSlice->getViewIndex());  
+  UInt voiInVps          = m_vps->getVoiInVps(pcSlice->getViewIndex());
   if( m_vps->getCpInSliceSegmentHeaderFlag( voiInVps ) ) // check consistency of slice parameters here
-  {   
+  {
     for( Int baseVoiInVps = 0; baseVoiInVps < m_vps->getNumViews(); baseVoiInVps++ )
-    {        
+    {
       if ( m_vps->getCpPresentFlag( voiInVps, baseVoiInVps ) )
       {
         if ( m_receivedIdc[ voiInVps ][ baseVoiInVps ] != 0 )
-        {      
+        {
           AOF( m_aaiCodedScale [ voiInVps ][ baseVoiInVps ] == pcSlice->getInvCodedScale () [ baseVoiInVps ] );
           AOF( m_aaiCodedOffset[ voiInVps ][ baseVoiInVps ] == pcSlice->getInvCodedOffset() [ baseVoiInVps ] );
         }
         else
-        {          
-          m_receivedIdc   [ voiInVps ][ baseVoiInVps ]  = 1; 
+        {
+          m_receivedIdc   [ voiInVps ][ baseVoiInVps ]  = 1;
           m_aaiCodedScale [ voiInVps ][ baseVoiInVps ]  = pcSlice->getInvCodedScale () [ baseVoiInVps ];
           m_aaiCodedOffset[ voiInVps ][ baseVoiInVps ]  = pcSlice->getInvCodedOffset() [ baseVoiInVps ];
@@ -270 +273 @@
         }
         if ( m_receivedIdc[ baseVoiInVps ][ voiInVps ] != 0 )
-        {      
+        {
           AOF( m_aaiCodedScale [ baseVoiInVps ][ voiInVps ] == pcSlice->getCodedScale    () [ baseVoiInVps ] );
           AOF( m_aaiCodedOffset[ baseVoiInVps ][ voiInVps ] == pcSlice->getCodedOffset   () [ baseVoiInVps ] );
         }
         else
-        {        
-          m_receivedIdc   [ baseVoiInVps ][ voiInVps ]  = 1; 
+        {
+          m_receivedIdc   [ baseVoiInVps ][ voiInVps ]  = 1;
           m_aaiCodedScale [ baseVoiInVps ][ voiInVps ]  = pcSlice->getCodedScale    () [ baseVoiInVps ];
           m_aaiCodedOffset[ baseVoiInVps ][ voiInVps ]  = pcSlice->getCodedOffset   () [ baseVoiInVps ];
@@ -283 +286 @@
       }
     }
-  }  
+  }
 }
 
@@ -295 +298 @@
       fprintf( m_pCodedScaleOffsetFile, "#ViewOrderIdx     ViewIdVal\n" );
       fprintf( m_pCodedScaleOffsetFile, "#------------ -------------\n" );
-      
+
       for( UInt voiInVps = 0; voiInVps < m_vps->getNumViews(); voiInVps++ )
       {
@@ -315 +318 @@
           {
             if ( m_receivedIdc[baseVoiInVps][voiInVps] != 0 )
-            {            
+            {
               fprintf( m_pCodedScaleOffsetFile, "%12d %12d %12d %12d %12d %12d %12d\n",
-                iS, iE, m_vps->getViewOIdxList( voiInVps ), m_vps->getViewOIdxList( baseVoiInVps ), 
-                m_aaiCodedScale [ baseVoiInVps ][ voiInVps ], 
+                iS, iE, m_vps->getViewOIdxList( voiInVps ), m_vps->getViewOIdxList( baseVoiInVps ),
+                m_aaiCodedScale [ baseVoiInVps ][ voiInVps ],
                 m_aaiCodedOffset[ baseVoiInVps ][ voiInVps ], m_vps->getCpPrecision() );
-            }            
+            }
           }
         }
@@ -334 +337 @@
 #if !NH_MV
   , m_associatedIRAPType(NAL_UNIT_INVALID)
-  , m_pocCRA(0)  
+  , m_pocCRA(0)
   , m_pocRandomAccess(MAX_INT)
   , m_cListPic()
@@ -426 +429 @@
     fclose( g_hTrace );
   }
-#endif  
+#endif
 #endif
   while (!m_prefixSEINALUs.empty())
@@ -465 +468 @@
 #endif
 #if NH_MV
-  m_cCavlcDecoder.setDecTop( this ); 
+  m_cCavlcDecoder.setDecTop( this );
 #endif
   m_cGopDecoder.init( &m_cEntropyDecoder, &m_cSbacDecoder, &m_cBinCABAC, &m_cCavlcDecoder, &m_cSliceDecoder, &m_cLoopFilter, &m_cSAO);
@@ -653 +656 @@
 #if NH_MV
     const TComVPS* vps = m_parameterSetManager.getVPS(sps->getVPSId());
-    assert (vps != 0); 
-    // TBD: check the condition on m_firstPicInLayerDecodedFlag 
+    assert (vps != 0);
+    // TBD: check the condition on m_firstPicInLayerDecodedFlag
     if (!m_parameterSetManager.activatePPS(m_apcSlicePilot->getPPSId(),m_apcSlicePilot->isIRAP() || !m_firstPicInLayerDecodedFlag[m_layerId] , m_layerId ) )
 #else
@@ -671 +674 @@
       {
         //, 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 
+        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 ); 
-      }
-    }
+      {
+        assert( sps->getMultiLayerExtSpsFlag() == 0 );
+      }
+    }
+#if NH_MV_SEI
+    m_seiReader.setLayerId ( newPic->getLayerId      ( ) );
+    m_seiReader.setDecOrder( newPic->getDecodingOrder( ) );
+#endif
 #endif
 
@@ -707 +714 @@
     m_apcSlicePilot->applyReferencePictureSet(m_cListPic, m_apcSlicePilot->getRPS());
 #else
-    m_pcPic = newPic; 
+    m_pcPic = newPic;
 #endif
 
@@ -723 +730 @@
 #if NH_MV
     pSlice->setPic( m_pcPic );
-    vps=pSlice->getVPS();  
+    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.
-    assert( pps->getLayerId() == m_layerId || pps->getLayerId( ) == 0 || vps->getDependencyFlag( m_layerId, pps->getLayerId() ) );   
+    assert( pps->getLayerId() == m_layerId || pps->getLayerId( ) == 0 || vps->getDependencyFlag( m_layerId, pps->getLayerId() ) );
     // The nuh_layer_id value of the NAL unit containing the SPS that is activated for a layer layerA with nuh_layer_id equal to nuhLayerIdA shall be equal to 0, or nuhLayerIdA, or the nuh_layer_id of a direct or indirect reference layer of layerA.
     assert( sps->getLayerId() == m_layerId || sps->getLayerId( ) == 0 || vps->getDependencyFlag( m_layerId, sps->getLayerId() ) );
@@ -775 +782 @@
   {
 #if NH_MV
-    assert( m_pcPic != NULL ); 
-    assert( newPic  == NULL ); 
+    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
@@ -832 +839 @@
     InputNALUnit &nalu=*m_prefixSEINALUs.front();
 #if NH_MV
+#if NH_MV_LAYERS_NOT_PRESENT_SEI
+    m_seiReader.parseSEImessage(&(nalu.getBitstream()), m_SEIs, nalu.m_nalUnitType, m_parameterSetManager.getActiveVPS(), m_parameterSetManager.getActiveSPS(getLayerId()), m_pDecodedSEIOutputStream);
+#else
     m_seiReader.parseSEImessage( &(nalu.getBitstream()), m_SEIs, nalu.m_nalUnitType, m_parameterSetManager.getActiveSPS( getLayerId() ), m_pDecodedSEIOutputStream );
+#endif
 #else
     m_seiReader.parseSEImessage( &(nalu.getBitstream()), m_SEIs, nalu.m_nalUnitType, m_parameterSetManager.getActiveSPS(), m_pDecodedSEIOutputStream );
@@ -855 +866 @@
   m_cEntropyDecoder.setBitstream      (&(nalu.getBitstream()));
 
-  assert( nalu.m_nuhLayerId == m_layerId );   
+  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.
-  m_apcSlicePilot->setLayerId( nalu.m_nuhLayerId ); 
-  m_cEntropyDecoder.decodeFirstSliceSegmentInPicFlag( m_apcSlicePilot );   
+  m_apcSlicePilot->setLayerId( nalu.m_nuhLayerId );
+  m_cEntropyDecoder.decodeFirstSliceSegmentInPicFlag( m_apcSlicePilot );
   if ( m_apcSlicePilot->getFirstSliceSegementInPicFlag() )
   {
-#endif  
+#endif
     m_uiSliceIdx = 0;
   }
@@ -908 +919 @@
   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()))
@@ -924 +935 @@
     else
     {
-      m_apcSlicePilot->setNoOutputPriorPicsFlag(false); 
+      m_apcSlicePilot->setNoOutputPriorPicsFlag(false);
     }
 
@@ -950 +961 @@
     }
   }
-  
+
   if (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA && m_craNoRaslOutputFlag) //Reset POC MSB when CRA has NoRaslOutputFlag equal to 1
   {
@@ -1044 +1055 @@
   {
     //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 
+    //  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 
+      pcSlice->getVPS()->getViewOrderIdx(pcSlice->getVPS()->getLayerIdInNuh(getLayerId()))==1
       )
     {
@@ -1061 +1072 @@
     m_pcPic->setViewIndex( getViewIndex() );
     m_pcPic->setIsDepth  ( getIsDepth  () );
-    pcSlice->setIvPicLists( m_dpb );         
-#endif
-#endif
-    
+    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.
@@ -1097 +1108 @@
         else
         {
-          assert( false ); 
+          assert( false );
         }
       }
@@ -1104 +1115 @@
 #endif
 #if NH_3D_ARP
-      pcSlice->setPocsInCurrRPSs(); 
+      pcSlice->setPocsInCurrRPSs();
       pcSlice->setARPStepNum(m_dpb);
-#endif     
+#endif
 #endif
 
@@ -1191 +1202 @@
     if ( decProcAnnexI() )
     {
-      pcSlice->checkInCompPredRefLayers(); 
+      pcSlice->checkInCompPredRefLayers();
     }
 #endif
@@ -1230 +1241 @@
   TComSPS* sps = new TComSPS();
 #if NH_MV
-  sps->setLayerId( getLayerId() ); 
+  sps->setLayerId( getLayerId() );
 #endif
 #if O0043_BEST_EFFORT_DECODING
@@ -1246 +1257 @@
   TComPPS* pps = new TComPPS();
 #if NH_MV
-  pps->setLayerId( getLayerId() ); 
+  pps->setLayerId( getLayerId() );
 #endif
 #if NH_3D_DLT
@@ -1304 +1315 @@
       {
 #if NH_MV
-        m_seiReader.parseSEImessage( &(nalu.getBitstream()), m_pcPic->getSEIs(), nalu.m_nalUnitType, m_parameterSetManager.getActiveSPS( getLayerId() ), m_pDecodedSEIOutputStream );
+#if NH_MV_LAYERS_NOT_PRESENT_SEI
+      m_seiReader.parseSEImessage( &(nalu.getBitstream()), m_pcPic->getSEIs(), nalu.m_nalUnitType, m_parameterSetManager.getActiveVPS(), m_parameterSetManager.getActiveSPS(getLayerId()), m_pDecodedSEIOutputStream);
+#else
+      m_seiReader.parseSEImessage( &(nalu.getBitstream()), m_pcPic->getSEIs(), nalu.m_nalUnitType, m_parameterSetManager.getActiveSPS( getLayerId() ), m_pDecodedSEIOutputStream );
+#endif
 #else
         m_seiReader.parseSEImessage( &(nalu.getBitstream()), m_pcPic->getSEIs(), nalu.m_nalUnitType, m_parameterSetManager.getActiveSPS(), m_pDecodedSEIOutputStream );
@@ -1332 +1347 @@
     case NAL_UNIT_CODED_SLICE_RASL_R:
 #if NH_MV
-      assert( false ); 
-      return 1; 
+      assert( false );
+      return 1;
 #else
       return xDecodeSlice(nalu, iSkipFrame, iPOCLastDisplay);
@@ -1506 +1521 @@
 {
   //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 
+  //  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).
 
@@ -1513 +1528 @@
   TComSlice* slice = m_apcSlicePilot;
   const Int nuhLayerId   = slice->getLayerId();
-  const TComVPS*   vps   = slice->getVPS(); 
-  const TComSPS*   sps   = slice->getSPS(); 
-
-  Int pocDecrementedInDpbFlag = m_pocDecrementedInDpbFlag[ nuhLayerId ]; 
+  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, 
+    //  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; 
+    pocDecrementedInDpbFlag = false;
   }
 
   //  The variable pocResettingFlag is derived as follows:
-  Bool pocResettingFlag; 
+  Bool pocResettingFlag;
   if ( isPocResettingPicture )
   {
-    //-  If the current picture is a POC resetting picture, the following applies:    
+    //-  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; 
+      pocResettingFlag = true;
     }
     else if ( pocDecrementedInDpbFlag )
     {
       //  -  Otherwise, if PocDecrementedInDPBFlag[ nuh_layer_id ] is equal to 1, pocResettingFlag is set equal to 0.
-      pocResettingFlag = false; 
+      pocResettingFlag = false;
     }
     else
     {
       //  -  Otherwise, pocResettingFlag is set equal to 1.
-      pocResettingFlag = true; 
+      pocResettingFlag = true;
     }
   }
@@ -1549 +1564 @@
   {
     //  -  Otherwise, pocResettingFlag is set equal to 0.
-    pocResettingFlag = false; 
-  }
-
-  Int picOrderCntMsb; 
-  Int picOrderCntVal; 
+    pocResettingFlag = false;
+  }
+
+  Int picOrderCntMsb;
+  Int picOrderCntVal;
 
   //  Depending on pocResettingFlag, the following applies:
@@ -1561 +1576 @@
     if( slice->getPocResetIdc()  ==  1 )
     {
-      picOrderCntVal = slice->getSlicePicOrderCntLsb(); 
-    }
-    else if (slice->getPocResetIdc()  ==  2 ) 
-    {
-      picOrderCntVal = 0; 
+      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(); 
+      picOrderCntMsb = xGetCurrMsb( slice->getSlicePicOrderCntLsb(), slice->getFullPocResetFlag() ? 0 : slice->getPocLsbVal(), 0, sps->getMaxPicOrderCntLsb() );
+      picOrderCntVal = picOrderCntMsb + slice->getSlicePicOrderCntLsb();
     }
   }
@@ -1580 +1595 @@
     if( slice->getPocMsbCycleValPresentFlag() )
     {
-      picOrderCntMsb = slice->getPocMsbCycleVal() * sps->getMaxPicOrderCntLsb(); 
+      picOrderCntMsb = slice->getPocMsbCycleVal() * sps->getMaxPicOrderCntLsb();
     }
     else if( !firstPicInLayerDecodedFlag  ||
@@ -1586 +1601 @@
     {
       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(); 
-  }  
+      Int prevPicOrderCntMsb = m_prevPicOrderCnt - prevPicOrderCntLsb;
+      picOrderCntMsb = xGetCurrMsb( slice->getSlicePicOrderCntLsb(), prevPicOrderCntLsb, prevPicOrderCntMsb, sps->getMaxPicOrderCntLsb() );
+    }
+    picOrderCntVal = picOrderCntMsb + slice->getSlicePicOrderCntLsb();
+  }
   return picOrderCntVal;
 }
@@ -1607 +1622 @@
     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 
+      // - 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() ] ); 
+      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 ); 
+      m_apcSlicePilot->setPocResetPeriodId( 0 );
     }
   }
   else
   {
-    m_lastPresentPocResetIdc[ m_apcSlicePilot->getLayerId() ] = m_apcSlicePilot->getPocResetPeriodId();  
+    m_lastPresentPocResetIdc[ m_apcSlicePilot->getLayerId() ] = m_apcSlicePilot->getPocResetPeriodId();
   }
 }
@@ -1627 +1642 @@
 
 Void TDecTop::decodePocAndRps( )
-{ 
+{
   assert( m_uiSliceIdx == 0 );
   Int nuhLayerId = m_pcPic->getLayerId();
@@ -1634 +1649 @@
     // 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 
+    // 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 
+    // 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 );
@@ -1654 +1669 @@
       // --> 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 
+      // 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 
+      // 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( );
@@ -1670 +1685 @@
       // 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 
+      // 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. 
+      // 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( );
@@ -1685 +1700 @@
   else
   {
-    assert( false ); 
+    assert( false );
   }
 }
 
 Void TDecTop::genUnavailableRefPics( )
-{ 
+{
   assert( m_uiSliceIdx == 0 );
   Int nuhLayerId = m_pcPic->getLayerId();
@@ -1699 +1714 @@
     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, 
+      // 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();       
+      x8331GenDecProcForGenUnavilRefPics();
     }
   }
@@ -1717 +1732 @@
       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, 
+        // 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(); 
+        xF833DecProcForGenUnavRefPics();
       }
 #if NH_MV_FIX_INIT_NUM_ACTIVE_REF_LAYER_PICS
-      TComDecodedRps* decRps = m_pcPic->getDecodedRps(); 
+      TComDecodedRps* decRps = m_pcPic->getDecodedRps();
       decRps->m_numActiveRefLayerPics0 = 0;
-      decRps->m_numActiveRefLayerPics1 = 0;      
+      decRps->m_numActiveRefLayerPics1 = 0;
 #endif
     }
@@ -1736 +1751 @@
       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 
+        // 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();
@@ -1744 +1759 @@
       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 
+        // 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(); 
+        xF833DecProcForGenUnavRefPics();
       }
 
@@ -1760 +1775 @@
   else
   {
-    assert( false ); 
-  }
-
-  xCheckUnavailableRefPics();      
+    assert( false );
+  }
+
+  xCheckUnavailableRefPics();
 }
 Void TDecTop::executeLoopFilters( )
 {
-  assert( m_pcPic != NULL ); 
+  assert( m_pcPic != NULL );
   if ( !m_pcPic->getHasGeneratedRefPics() && !m_pcPic->getIsGenerated() )
   {
@@ -1779 +1794 @@
   if( m_pcPic->isIrap() )
   {
-    m_prevIrapPoc           = m_pcPic->getPOC(); 
-    m_prevIrapDecodingOrder = m_pcPic->getDecodingOrder(); 
+    m_prevIrapPoc           = m_pcPic->getPOC();
+    m_prevIrapDecodingOrder = m_pcPic->getDecodingOrder();
   }
   if( m_pcPic->isStsa() )
@@ -1791 +1806 @@
 
 Void TDecTop::initFromActiveVps( const TComVPS* vps )
-{   
-  setViewId   ( vps->getViewId   ( getLayerId() )      );  
+{
+  setViewId   ( vps->getViewId   ( getLayerId() )      );
 #if NH_3D
-  setViewIndex( vps->getViewIndex( getLayerId() )      );  
-  setIsDepth  ( vps->getDepthId  ( getLayerId() ) == 1 );  
+  setViewIndex( vps->getViewIndex( getLayerId() )      );
+  setIsDepth  ( vps->getDepthId  ( getLayerId() ) == 1 );
 #endif
 
   if ( !vps->getVpsExtensionFlag() )
   {
-    m_decodingProcess = CLAUSE_8; 
+    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 ); 
+      // 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; 
+      m_smallestLayerId = 0;
     }
     else if ( targetDecLayerSetIdx <= vps->getVpsNumLayerSetsMinus1() && !vps->getVpsBaseLayerInternalFlag() )
     {
-      m_smallestLayerId = 0; 
+      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 ];    
+
+      // 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 ];    
+      m_smallestLayerId = vps->getTargetDecLayerIdList( targetDecLayerSetIdx )[ 0 ];
     }
 
@@ -1836 +1851 @@
     // Set profile
     Int lsIdx = vps->olsIdxToLsIdx( m_targetOlsIdx );
-    Int lIdx = -1; 
+    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); 
+      {
+        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 ); 
+      assert( profileIdc == 1 || profileIdc == 6 || profileIdc == 8 );
 
       if (  profileIdc == 6 )
@@ -1881 +1896 @@
 
   //  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 
+  //  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, 
+  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, 
+    //  -  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; 
+    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:  
-  
+    prevPicOrderCntMsb = m_prevTid0PicPicOrderCntMsb;
+  }
+
+  //  The variable PicOrderCntMsb of the current picture is derived as follows:
+
   Int slicePicOrderCntLsb = curSlice->getSlicePicOrderCntLsb();
 
-  Int picOrderCntMsb; 
+  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; 
+    picOrderCntMsb = 0;
   }
   else
   {
-    Int maxPicOrderCntLsb   = curSlice->getSPS()->getMaxPicOrderCntLsb(); 
+    Int maxPicOrderCntLsb   = curSlice->getSPS()->getMaxPicOrderCntLsb();
 
   //  -  Otherwise, PicOrderCntMsb is derived as follows:
@@ -1933 +1948 @@
     else
     {
-      picOrderCntMsb = prevPicOrderCntMsb; 
-    }
-  }
-  
+      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 
+  //  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 ); 
+  m_pcPic->getSlice(0)->setPOC( picOrderCntVal );
 
   // Update prevTid0Pic
@@ -1949 +1964 @@
   if( curSlice->getTemporalId() == 0  && !m_pcPic->isRasl() && !m_pcPic->isRadl() && !m_pcPic->isSlnr() )
   {
-    m_prevTid0PicSlicePicOrderCntLsb = slicePicOrderCntLsb;     
-    m_prevTid0PicPicOrderCntMsb      = picOrderCntMsb;  
+    m_prevTid0PicSlicePicOrderCntLsb = slicePicOrderCntLsb;
+    m_prevTid0PicPicOrderCntMsb      = picOrderCntMsb;
   }
 }
@@ -1957 +1972 @@
 {
   //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 
+  //  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(); 
+  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, 
+    //  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; 
+      m_pocDecrementedInDpbFlag[ i ] = 0;
     }
   }
 
   //  The variable pocResettingFlag is derived as follows:
-  Bool pocResettingFlag; 
+  Bool pocResettingFlag;
   if (m_pcPic->getIsPocResettingPic() )
   {
-    //-  If the current picture is a POC resetting picture, the following applies:    
+    //-  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; 
+      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; 
+      pocResettingFlag = false;
     }
     else
     {
       //  -  Otherwise, pocResettingFlag is set equal to 1.
-      pocResettingFlag = true; 
+      pocResettingFlag = true;
     }
   }
@@ -2000 +2015 @@
   {
     //  -  Otherwise, pocResettingFlag is set equal to 0.
-    pocResettingFlag = false; 
+    pocResettingFlag = false;
   }
 
   //  The list affectedLayerList is derived as follows:
-  std::vector<Int> affectedLayerList; 
+  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 ); 
+    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, 
+    //  -  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; 
+    affectedLayerList.push_back( nuhLayerId );
+    Int currNuhLayerId = nuhLayerId;
     for (Int j = 0; j <= vps->getNumPredictedLayers( currNuhLayerId )-1; j++ )
     {
@@ -2022 +2037 @@
     }
   }
-  
-  Int picOrderCntMsb; 
-  Int picOrderCntVal; 
+
+  Int picOrderCntMsb;
+  Int picOrderCntVal;
 
   //  Depending on pocResettingFlag, the following applies:
@@ -2033 +2048 @@
     {
       //-  The variables pocMsbDelta, pocLsbDelta and DeltaPocVal are derived as follows:
-      Int pocMsbDelta; 
-      Int pocLsbDelta; 
-      Int deltaPocVal;       
-
-      {
-        Int pocLsbVal; 
-        Int prevPicOrderCntLsb; 
-        Int prevPicOrderCntMsb; 
+      Int pocMsbDelta;
+      Int pocLsbDelta;
+      Int deltaPocVal;
+
+      {
+        Int pocLsbVal;
+        Int prevPicOrderCntLsb;
+        Int prevPicOrderCntMsb;
 
         if( slice->getPocResetIdc() ==  3 )
         {
-          pocLsbVal = slice->getPocLsbVal(); 
-        }      
+          pocLsbVal = slice->getPocLsbVal();
+        }
         else
         {
-          pocLsbVal = slice->getSlicePicOrderCntLsb(); 
+          pocLsbVal = slice->getSlicePicOrderCntLsb();
         }
 
@@ -2054 +2069 @@
         {
           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; 
+          prevPicOrderCntLsb = m_prevPicOrderCnt & ( sps->getMaxPicOrderCntLsb() - 1 );
+          prevPicOrderCntMsb = m_prevPicOrderCnt - prevPicOrderCntLsb;
+
+          pocMsbDelta = xGetCurrMsb( pocLsbVal, prevPicOrderCntLsb, prevPicOrderCntMsb, sps->getMaxPicOrderCntLsb() );
         }
-        deltaPocVal = pocMsbDelta + pocLsbDelta; 
-      }
-
-      //-  The PicOrderCntVal of each picture that has nuh_layer_id value nuhLayerId for which PocDecrementedInDPBFlag[ nuhLayerId ] is equal to 0 
+
+        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++ )
@@ -2080 +2095 @@
         if ( !m_pocDecrementedInDpbFlag[ affectedLayerList[i] ] )
         {
-          m_dpb->decrementPocsInSubDpb( affectedLayerList[i], deltaPocVal ); 
+          m_dpb->decrementPocsInSubDpb( affectedLayerList[i], deltaPocVal );
         }
       }
@@ -2087 +2102 @@
       for (Int i = 0; i < (Int) affectedLayerList.size(); i++ )
       {
-        m_pocDecrementedInDpbFlag[ affectedLayerList[i] ] = true; 
-      }
-    } 
+        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; 
+      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(); 
+       picOrderCntMsb = xGetCurrMsb( slice->getSlicePicOrderCntLsb(), slice->getFullPocResetFlag() ? 0 : slice->getPocLsbVal(), 0, sps->getMaxPicOrderCntLsb() );
+       picOrderCntVal = picOrderCntMsb + slice->getSlicePicOrderCntLsb();
     }
   }
@@ -2110 +2125 @@
     //-  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(); 
+      picOrderCntMsb = slice->getPocMsbCycleVal() * sps->getMaxPicOrderCntLsb();
     }
     else if( !m_firstPicInLayerDecodedFlag[ nuhLayerId ]  ||
@@ -2119 +2134 @@
     {
       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 ); 
-  
+        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 
+      //-  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; 
+      m_prevPicOrderCnt = picOrderCntVal;
     }
     else if ( slice->getPocResetIdc() == 3 &&  (
-      ( !m_firstPicInLayerDecodedFlag[ nuhLayerId ]) || 
-      ( m_firstPicInLayerDecodedFlag[ nuhLayerId ] && m_pcPic->getIsPocResettingPic() ) 
+      ( !m_firstPicInLayerDecodedFlag[ nuhLayerId ]) ||
+      ( m_firstPicInLayerDecodedFlag[ nuhLayerId ] && m_pcPic->getIsPocResettingPic() )
       ) )
     {
@@ -2149 +2164 @@
       //     -  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() ); 
+      m_prevPicOrderCnt = ( slice->getFullPocResetFlag() ? 0 : slice->getPocLsbVal() );
     }
   }
@@ -2156 +2171 @@
 Int TDecTop::xGetCurrMsb( Int cl, Int pl, Int pm, Int ml )
 {
-  Int currMsb; 
+  Int currMsb;
   if ((pl - cl) >= (ml/ 2))
   {
@@ -2163 +2178 @@
   else if ( (cl - pl) > (ml / 2))
   {
-    currMsb = pm - ml; 
+    currMsb = pm - ml;
   }
   else
   {
-    currMsb = pm; 
-  }
-
-  return currMsb;  
-}   
+    currMsb = pm;
+  }
+
+  return currMsb;
+}
 
 
@@ -2181 +2196 @@
   ///////////////////////////////////////////////////////////////////////////////////////
 
-  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 
+  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(); 
+  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 
+  {
+    // 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 
+    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, 
+  // 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(); 
+
+  TComDecodedRps* decRps = m_pcPic->getDecodedRps();
 
   std::vector<Int>& pocStCurrBefore = decRps->m_pocStCurrBefore;
@@ -2214 +2229 @@
   std::vector<Int>& pocLtFoll       = decRps->m_pocLtFoll;
 
-  Int& numPocStCurrBefore = decRps->m_numPocStCurrBefore; 
+  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; 
+  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, 
+    // - 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.
 
@@ -2233 +2248 @@
     pocLtCurr      .clear();
     pocLtFoll      .clear();
-    numPocStCurrBefore = 0; 
-    numPocStCurrAfter  = 0; 
-    numPocStFoll       = 0; 
-    numPocLtCurr       = 0; 
-    numPocLtFoll       = 0; 
+    numPocStCurrBefore = 0;
+    numPocStCurrAfter  = 0;
+    numPocStFoll       = 0;
+    numPocLtCurr       = 0;
+    numPocLtFoll       = 0;
   }
   else
@@ -2244 +2259 @@
     // -  Otherwise, the following applies:
 
-    Int j = 0; 
-    Int k = 0; 
+    Int j = 0;
+    Int k = 0;
     for( Int i = 0; i < stRps->getNumNegativePicsVar() ; i++ )
     {
@@ -2257 +2272 @@
       }
     }
-    numPocStCurrBefore = j;    
-
-    j = 0; 
+    numPocStCurrBefore = j;
+
+    j = 0;
     for (Int i = 0; i < stRps->getNumPositivePicsVar(); i++ )
     {
       if (stRps->getUsedByCurrPicS1Var( i ) )
       {
-        pocStCurrAfter.push_back( picOrderCntVal + stRps->getDeltaPocS1Var( i ) ); j++; 
+        pocStCurrAfter.push_back( picOrderCntVal + stRps->getDeltaPocS1Var( i ) ); j++;
       }
       else
@@ -2275 +2290 @@
 
 
-    j = 0; 
-    k = 0; 
+    j = 0;
+    k = 0;
     for( Int i = 0; i < slice->getNumLongTermSps( ) + slice->getNumLongTermPics(); i++ )
     {
-      Int pocLt = slice->getPocLsbLtVar( i ); 
+      Int pocLt = slice->getPocLsbLtVar( i );
       if( slice->getDeltaPocMsbPresentFlag( i ) )
       {
@@ -2286 +2301 @@
       }
 
-      if( slice->getUsedByCurrPicLtVar(i)) 
+      if( slice->getUsedByCurrPicLtVar(i))
       {
         pocLtCurr.push_back( pocLt );
-        currDeltaPocMsbPresentFlag.push_back( slice->getDeltaPocMsbPresentFlag( i ) ); j++; 
-      } 
+        currDeltaPocMsbPresentFlag.push_back( slice->getDeltaPocMsbPresentFlag( i ) ); j++;
+      }
       else
       {
         pocLtFoll.push_back( pocLt );
-        follDeltaPocMsbPresentFlag.push_back( slice->getDeltaPocMsbPresentFlag( i ) ); k++; 
+        follDeltaPocMsbPresentFlag.push_back( slice->getDeltaPocMsbPresentFlag( i ) ); k++;
       }
     }
@@ -2303 +2318 @@
   assert(numPocStCurrAfter  == pocStCurrAfter   .size() );
   assert(numPocStCurrBefore == pocStCurrBefore  .size() );
-  assert(numPocStFoll       == pocStFoll        .size() );  
-  assert(numPocLtCurr       == pocLtCurr        .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 
+  //   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, 
+      // 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, 
+      // -  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++ )
@@ -2328 +2343 @@
       }
 
-      // -  There shall be no j in the range of 0 to NumPocStCurrAfter - 1, inclusive, 
-      //    for which PocLtCurr[ i ] is equal to PocStCurrAfter[ 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++ )
       {
@@ -2335 +2350 @@
       }
 
-      // -  There shall be no j in the range of 0 to NumPocStFoll - 1, inclusive, 
+      // -  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++ )
@@ -2342 +2357 @@
       }
 
-      // -  There shall be no j in the range of 0 to NumPocLtCurr - 1, inclusive, 
+      // -  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 ] ) );
         }
@@ -2356 +2371 @@
   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, 
+    // 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, 
+      // -  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++ )
@@ -2367 +2382 @@
       }
 
-      // -  There shall be no j in the range of 0 to NumPocStCurrAfter - 1, inclusive, 
+      // -  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++ )
@@ -2374 +2389 @@
       }
 
-      // -  There shall be no j in the range of 0 to NumPocStFoll - 1, inclusive, 
+      // -  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++ )
@@ -2381 +2396 @@
       }
 
-      // -  There shall be no j in the range of 0 to NumPocLtFoll - 1, inclusive, 
+      // -  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++ )
@@ -2391 +2406 @@
       }
 
-      // -  There shall be no j in the range of 0 to NumPocLtCurr - 1, inclusive, 
+      // -  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++ )
@@ -2400 +2415 @@
   }
 
-  Int maxPicOrderCntLsb = sps->getMaxPicOrderCntLsb(); 
+  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, 
+    // 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, 
+      // -  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++ )
@@ -2442 +2457 @@
   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, 
+    // 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  )
@@ -2474 +2489 @@
         {
           assert(!( pocLtFoll[ i ] == ( pocLtFoll[ j ] & ( maxPicOrderCntLsb - 1 ) ) ) );
-        }          
+        }
       }
 
@@ -2487 +2502 @@
 
   if ( !annexFModifications )
-  {  
-    // The variable NumPicTotalCurr is derived as specified in clause 7.4.7.2. 
+  {
+    // 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:
@@ -2494 +2509 @@
     {
       // -  If the current picture is a BLA or CRA picture, the value of NumPicTotalCurr shall be equal to 0.
-      assert( slice->getNumPicTotalCurr() == 0 ); 
+      assert( slice->getNumPicTotalCurr() == 0 );
     }
     else
     {
-      // -  Otherwise, 
+      // -  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 
+        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.
 
@@ -2516 +2531 @@
   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 
+  //   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 
+  //   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.
 
@@ -2528 +2543 @@
   // 1.  The following applies:
 
-  TComSubDpb* dpb = m_dpb->getSubDpb( getLayerId(), false );   
+  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 ) );       
+  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 ] ));       
-    }    
+      refPicSetLtCurr.push_back(dpb->getPic( pocLtCurr[ i ] ));
+    }
   }
 
@@ -2551 +2566 @@
    else
    {
-     refPicSetLtFoll.push_back(dpb->getPic( pocLtFoll[ i ] ));       
+     refPicSetLtFoll.push_back(dpb->getPic( pocLtFoll[ i ] ));
    }
   }
-  
-  // 2.  All reference pictures that are included in RefPicSetLtCurr or RefPicSetLtFoll and have nuh_layer_id equal 
+
+  // 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++)
@@ -2561 +2576 @@
     if ( refPicSetLtCurr[i] != NULL )
     {
-      refPicSetLtCurr[i]->markAsUsedForLongTermReference(); 
-    }    
+      refPicSetLtCurr[i]->markAsUsedForLongTermReference();
+    }
   }
 
@@ -2569 +2584 @@
     if ( refPicSetLtFoll[i] != NULL )
     {
-      refPicSetLtFoll[i]->markAsUsedForLongTermReference(); 
-    }    
+      refPicSetLtFoll[i]->markAsUsedForLongTermReference();
+    }
   }
 
@@ -2577 +2592 @@
   for( Int i = 0; i < numPocStCurrBefore; i++ )
   {
-    refPicSetStCurrBefore.push_back(dpb->getShortTermRefPic( pocStCurrBefore[ i ] )); 
+    refPicSetStCurrBefore.push_back(dpb->getShortTermRefPic( pocStCurrBefore[ i ] ));
   }
 
@@ -2583 +2598 @@
   for( Int i = 0; i < numPocStCurrAfter; i++ )
   {
-    refPicSetStCurrAfter.push_back(dpb->getShortTermRefPic( pocStCurrAfter[ i ] )); 
+    refPicSetStCurrAfter.push_back(dpb->getShortTermRefPic( pocStCurrAfter[ i ] ));
   }
 
@@ -2589 +2604 @@
   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, 
+    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); 
+  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 
+    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:
 
@@ -2614 +2629 @@
 #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 
+      // -  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]; 
+      std::vector<TComPic*>* currSet = refPicSetsCurr[j];
       for (Int i = 0; i < currSet->size(); i++)
       {
-        TComPic* pic = (*currSet)[i]; 
+        TComPic* pic = (*currSet)[i];
 
         // -  The entry is equal to "no reference picture".
-        assert( ! (pic == NULL ) ); 
+        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() ) ); 
+        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() ) ); 
-      }      
+        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 
+
+  //  -  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++ )
-  {    
-    std::vector<TComPic*>* ltSet = refPicSetsLt[j]; 
+  {
+    std::vector<TComPic*>* ltSet = refPicSetsLt[j];
     for (Int i = 0; i < ltSet->size(); i++)
     {
-      TComPic* pic = (*ltSet)[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 
+        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]; 
+    {
+      std::vector<TComPic*>* aSet = refPicSetsAll[j];
       for (Int i = 0; i < aSet->size(); i++)
       {
-        TComPic* pic = (*aSet)[i]; 
+        TComPic* pic = (*aSet)[i];
         if( pic != NULL )
         {
-          assert( ! (pic->getTemporalId() >= m_pcPic->getTemporalId() ) ); 
+          assert( ! (pic->getTemporalId() >= m_pcPic->getTemporalId() ) );
         }
       }
@@ -2674 +2689 @@
   }
 
-  //   -  When the current picture is a step-wise temporal sub-layer access (STSA) picture, 
+  //   -  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.
@@ -2680 +2695 @@
   {
     for (Int j = 0; j < 3; j++ )
-    {    
-      std::vector<TComPic*>* cSet = refPicSetsCurr[j]; 
+    {
+      std::vector<TComPic*>* cSet = refPicSetsCurr[j];
       for (Int i = 0; i < cSet->size(); i++)
       {
-        TComPic* pic = (*cSet)[i]; 
+        TComPic* pic = (*cSet)[i];
         if( pic != NULL )
         {
-          assert( ! (pic->getTemporalId() == m_pcPic->getTemporalId() ) ); 
+          assert( ! (pic->getTemporalId() == m_pcPic->getTemporalId() ) );
         }
       }
@@ -2700 +2715 @@
   {
     for (Int j = 0; j < 3; j++ )
-    {    
-      std::vector<TComPic*>* cSet = refPicSetsCurr[j]; 
+    {
+      std::vector<TComPic*>* cSet = refPicSetsCurr[j];
       for (Int i = 0; i < cSet->size(); i++)
       {
-        TComPic* pic = (*cSet)[i]; 
+        TComPic* pic = (*cSet)[i];
         if( pic != NULL )
         {
-          assert( ! (pic->getTemporalId() == m_pcPic->getTemporalId() && pic->getDecodingOrder() < m_prevStsaDecOrder  ) ); 
+          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).
@@ -2718 +2733 @@
   {
     for (Int j = 0; j < 5; j++ )
-    {    
-      std::vector<TComPic*>* aSet = refPicSetsAll[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]; 
+        TComPic* pic = (*aSet)[i];
         if( pic != NULL )
-        {        
-          assert( ! (pic->getPOC()           < m_prevIrapPoc           ) );           
-          assert( ! (pic->getDecodingOrder() < m_prevIrapDecodingOrder ) ); 
+        {
+          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,
@@ -2740 +2755 @@
   {
     for (Int j = 0; j < 3; j++ )
-    {    
-      std::vector<TComPic*>* cSet = refPicSetsCurr[j]; 
+    {
+      std::vector<TComPic*>* cSet = refPicSetsCurr[j];
       for (Int i = 0; i < cSet->size(); i++)
       {
-        TComPic* pic = (*cSet)[i]; 
+        TComPic* pic = (*cSet)[i];
         if( pic != NULL )
         {
-          assert( ! (pic->getIsGeneratedCl833() ) ); 
+          assert( ! (pic->getIsGeneratedCl833() ) );
         }
       }
@@ -2758 +2773 @@
   {
     for (Int j = 0; j < 5; j++ )
-    {    
-      std::vector<TComPic*>* aSet = refPicSetsAll[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]; 
+         TComPic* pic = (*aSet)[i];
         if( pic != NULL )
-        {         
-          assert( ! (pic->getPOC()           < m_prevIrapPoc           ) ); 
-          assert( ! (pic->getDecodingOrder() < m_prevIrapDecodingOrder ) ); 
+        {
+          assert( ! (pic->getPOC()           < m_prevIrapPoc           ) );
+          assert( ! (pic->getDecodingOrder() < m_prevIrapDecodingOrder ) );
         }
       }
@@ -2778 +2793 @@
   {
     for (Int j = 0; j < 3; j++ )
-    {    
-      std::vector<TComPic*>* cSet = refPicSetsCurr[j]; 
+    {
+      std::vector<TComPic*>* cSet = refPicSetsCurr[j];
       for (Int i = 0; i < cSet->size(); i++)
-      {        
-        TComPic* pic = (*cSet)[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 
+          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() ) ); 
+          assert( ! (pic->getIsGeneratedCl833() ) );
           // -  A picture that precedes the associated IRAP picture in decoding order
-          assert( ! (pic->getDecodingOrder() < m_prevIrapDecodingOrder ) ); 
+          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; 
+    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 
+    //   -  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]; 
+    {
+      std::vector<TComPic*>* cSet = refPicSetsCurr[j];
       for (Int i = 0; i < cSet->size(); i++)
       {
-        TComPic* picB = (*cSet)[i]; 
+        TComPic* picB = (*cSet)[i];
         if( picB != NULL )
         {
-          Int tIdB = picB->getTemporalId(); 
+          Int tIdB = picB->getTemporalId();
 
           if (tIdB <= tIdA)
@@ -2821 +2836 @@
             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()  )  ); 
+              TComPic* picC = (*itP);
+              assert(! ( picC->getTemporalId() < tIdB && picC->getDecodingOrder() > picB->getDecodingOrder() && picC->getDecodingOrder() < picA->getDecodingOrder()  )  );
             }
           }
@@ -2828 +2843 @@
       }
     }
-  }    
+  }
 }
 
@@ -2839 +2854 @@
 
   // 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 
+  // -  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 ); 
+  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 
+    // -  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:
 
@@ -2860 +2875 @@
 
   // -  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 
+  // -  When the current picture is a CRA picture, there shall be no picture in RefPicSetStCurrBefore, RefPicSetStCurrAfter
   //    or RefPicSetLtCurr.
 
@@ -2867 +2882 @@
   if ( m_pcPic->isCra() )
   {
-    for (Int j = 0; j < 3; j++ )   
-    {    
-      std::vector<TComPic*>* cSet = refPicSetsCurr[j]; 
-      assert ( cSet->size() == 0 ); 
+    for (Int j = 0; j < 3; j++ )
+    {
+      std::vector<TComPic*>* cSet = refPicSetsCurr[j];
+      assert ( cSet->size() == 0 );
     }
   }
@@ -2876 +2891 @@
   // -  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(); 
+  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 
+  {
+    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.
   }
@@ -2892 +2907 @@
     {
       // -  Otherwise, when the current picture contains a P or B slice, the value of NumPicTotalCurr shall not be equal to 0.
-      assert( numPicTotalCurr != 0 ); 
+      assert( numPicTotalCurr != 0 );
     }
   }
@@ -2904 +2919 @@
   ////////////////////////////////////////////////////////////////////
 
-  // Outputs of this process are updated lists of inter-layer reference pictures RefPicSetInterLayer0 and RefPicSetInterLayer1 
+  // 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(); 
+  TComDecodedRps* decRps = m_pcPic->getDecodedRps();
+  TComSlice* slice       = m_pcPic->getSlice( 0 );
+  const TComVPS* vps     =  slice->getVPS();
 
   Int&                   numActiveRefLayerPics0 = decRps->m_numActiveRefLayerPics0;
@@ -2915 +2930 @@
 
   std::vector<TComPic*>& refPicSetInterLayer0   = decRps->m_refPicSetInterLayer0;
-  std::vector<TComPic*>& refPicSetInterLayer1   = decRps->m_refPicSetInterLayer1; 
+  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 
+  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 ); 
+  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 ) ); 
+  for( Int i = 0; i < slice->getNumActiveRefLayerPics(); i++ )
+  {
+    Int viewIdRefPicLayerIdi = vps->getViewId( slice->getRefPicLayerId( i ) );
 
     Bool refPicSet0Flag =
@@ -2944 +2959 @@
     {
       // 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 ] 
+      // nuh_layer_id equal to RefPicLayerId[ i ]
 
       if ( refPicSet0Flag )
@@ -2960 +2975 @@
       assert( ! picX->getSlice(0)->getDiscardableFlag() );
 
-      // If the current picture is a RADL picture, there shall be no entry in RefPicSetInterLayer0 or RefPicSetInterLayer1 
+      // 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() )
@@ -2992 +3007 @@
   ///////////////////////////////////////////////////////////////////////////////////////
 
-  // This process is invoked once per coded picture when the current picture is a 
+  // 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(); 
+  TComDecodedRps* decRps = m_pcPic->getDecodedRps();
 
   std::vector<TComPic*>& refPicSetStFoll      = decRps->m_refPicSetStFoll;
-  std::vector<TComPic*>& refPicSetLtFoll      = decRps->m_refPicSetLtFoll; 
+  std::vector<TComPic*>& refPicSetLtFoll      = decRps->m_refPicSetLtFoll;
 
   const std::vector<Int>& pocStFoll             = decRps->m_pocStFoll;
@@ -3005 +3020 @@
 
   const Int               numPocStFoll          = decRps->m_numPocStFoll;
-  const Int               numPocLtFoll          = decRps->m_numPocLtFoll;   
+  const Int               numPocLtFoll          = decRps->m_numPocLtFoll;
 
   // When this process is invoked, the following applies:
@@ -3012 +3027 @@
     if ( refPicSetStFoll[ i ] == NULL )
     {
-      //-  For each RefPicSetStFoll[ i ], with i in the range of 0 to NumPocStFoll - 1, inclusive, that is equal 
+      //-  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 );  
+      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 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".
@@ -3029 +3044 @@
 
       // -  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() ); 
+      genPic->setLayerId( m_pcPic-> getLayerId() );
 
       // Insert to DPB
-      m_dpb->addNewPic( genPic ); 
+      m_dpb->addNewPic( genPic );
     }
   }
@@ -3040 +3055 @@
     if ( refPicSetLtFoll[ i ] == NULL )
     {
-      //-  For each RefPicSetLtFoll[ i ], with i in the range of 0 to NumPocLtFoll - 1, inclusive, that is equal to 
+      //-  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 );  
+      TComPic* genPic = x8332GenOfOneUnavailPic( true );
 
       //-  The value of PicOrderCntVal for the generated picture is set equal to PocLtFoll[ i ].
@@ -3048 +3063 @@
 
       //  -  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 ); 
+      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".
@@ -3060 +3075 @@
 
       //  -  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() ); 
+      genPic->setLayerId( m_pcPic-> getLayerId() );
 
       // Insert to DPB
-      m_dpb->addNewPic( genPic ); 
+      m_dpb->addNewPic( genPic );
     }
   }
@@ -3075 +3090 @@
   ///////////////////////////////////////////////////////////////////////////////////////
 
-  TComPic* genPic = new TComPic; 
-  genPic->create( *m_pcPic->getSlice(0)->getSPS(), *m_pcPic->getSlice(0)->getPPS(), true ); 
-  genPic->setIsGenerated( true );     
-  genPic->setIsGeneratedCl833( calledFromCl8331 ); 
+  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;
 }
@@ -3086 +3101 @@
 {
   ///////////////////////////////////////////////////////////////////////////////////////
-  // F.8.1.7 Decoding process for generating unavailable reference pictures for pictures 
+  // 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.   
+  //  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; 
+  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; 
+  std::vector<TComPic*>& refPicSetLtCurr       = decRps->m_refPicSetLtCurr;
+  std::vector<TComPic*>& refPicSetLtFoll       = decRps->m_refPicSetLtFoll;
 
 
@@ -3109 +3124 @@
   const std::vector<Int>& pocLtFoll            = decRps->m_pocLtFoll;
 
-  const Int numPocStCurrBefore                 = decRps->m_numPocStCurrBefore; 
+  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(); 
+  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 
+      //-  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 );  
+      TComPic* genPic = x8332GenOfOneUnavailPic( false );
 
       //-  The value of PicOrderCntVal for the generated picture is set equal to PocStCurrBefore[ i ].
@@ -3128 +3143 @@
 
       //  -  The value of PicOutputFlag for the generated picture is set equal to 0.
-      genPic->setPicOutputFlag( false ); 
+      genPic->setPicOutputFlag( false );
 
       //  -  The generated picture is marked as "used for short-term reference".
@@ -3137 +3152 @@
 
       //  -  The value of nuh_layer_id for the generated picture is set equal to nuh_layer_id.
-      genPic->setLayerId( nuhLayerId ); 
+      genPic->setLayerId( nuhLayerId );
 
       // Insert to DPB
-      m_dpb->addNewPic( genPic ); 
+      m_dpb->addNewPic( genPic );
     }
   }
@@ -3148 +3163 @@
     if ( refPicSetStCurrAfter[ i ] == NULL )
     {
-      //  -  For each RefPicSetStCurrAfter[ i ], with i in the range of 0 to NumPocStCurrAfter - 1, inclusive, that is equal 
+      //  -  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 );  
+      TComPic* genPic = x8332GenOfOneUnavailPic( false );
 
       //  -  The value of PicOrderCntVal for the generated picture is set equal to PocStCurrAfter[ i ].
@@ -3156 +3171 @@
 
       //  -  The value of PicOutputFlag for the generated picture is set equal to 0.
-      genPic->setPicOutputFlag( false ); 
+      genPic->setPicOutputFlag( false );
 
       //  -  The generated picture is marked as "used for short-term reference".
@@ -3165 +3180 @@
 
       //  -  The value of nuh_layer_id for the generated picture is set equal to nuh_layer_id.
-      genPic->setLayerId( nuhLayerId ); 
+      genPic->setLayerId( nuhLayerId );
 
       // Insert to DPB
-      m_dpb->addNewPic( genPic ); 
+      m_dpb->addNewPic( genPic );
 
     }
@@ -3177 +3192 @@
     if ( refPicSetStFoll[ i ] == NULL )
     {
-      //  -  For each RefPicSetStFoll[ i ], with i in the range of 0 to NumPocStFoll - 1, inclusive, that is equal to "no 
+      //  -  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 );  
+      TComPic* genPic = x8332GenOfOneUnavailPic( false );
 
       //  -  The value of PicOrderCntVal for the generated picture is set equal to PocStFoll[ i ].
@@ -3185 +3200 @@
 
       //  -  The value of PicOutputFlag for the generated picture is set equal to 0.
-      genPic->setPicOutputFlag( false ); 
+      genPic->setPicOutputFlag( false );
 
       //  -  The generated picture is marked as "used for short-term reference".
@@ -3194 +3209 @@
 
       //  -  The value of nuh_layer_id for the generated picture is set equal to nuh_layer_id.
-      genPic->setLayerId( nuhLayerId ); 
+      genPic->setLayerId( nuhLayerId );
 
       // Insert to DPB
-      m_dpb->addNewPic( genPic ); 
-    }
-  }
-
-  Int maxPicOrderCntLsb = m_pcPic->getSlice(0)->getSPS()->getMaxPicOrderCntLsb();  
+      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 
+      //  -  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 );  
+      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 ] & ( 
+      //  -  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 ) ) ); 
+      genPic->getSlice(0)->setSlicePicOrderCntLsb( ( pocLtCurr[ i ] & ( maxPicOrderCntLsb - 1 ) ) );
 
       //  -  The value of PicOutputFlag for the generated picture is set equal to 0.
-      genPic->setPicOutputFlag( false ); 
+      genPic->setPicOutputFlag( false );
 
       //  -  The generated picture is marked as "used for long-term reference".
@@ -3227 +3242 @@
 
       //  -  The value of nuh_layer_id for the generated picture is set equal to nuh_layer_id.
-      genPic->setLayerId( nuhLayerId ); 
+      genPic->setLayerId( nuhLayerId );
 
       // Insert to DPB
-      m_dpb->addNewPic( genPic ); 
+      m_dpb->addNewPic( genPic );
     }
   }
@@ -3238 +3253 @@
     if ( refPicSetLtFoll[ i ] == NULL )
     {
-      //  -  For each RefPicSetLtFoll[ i ], with i in the range of 0 to NumPocLtFoll - 1, inclusive, that is equal to "no 
+      //  -  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 );  
+      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 ] & ( 
+      //  -  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 ) ) ); 
+      genPic->getSlice(0)->setSlicePicOrderCntLsb( ( pocLtCurr[ i ] & ( maxPicOrderCntLsb - 1 ) ) );
 
       //  -  The value of PicOutputFlag for the generated picture is set equal to 0.
-      genPic->setPicOutputFlag( false ); 
+      genPic->setPicOutputFlag( false );
 
       //  -  The generated picture is marked as "used for long-term reference".
@@ -3259 +3274 @@
 
       //  -  The value of nuh_layer_id for the generated picture is set equal to nuh_layer_id.
-      genPic->setLayerId( nuhLayerId ); 
+      genPic->setLayerId( nuhLayerId );
 
       // Insert to DPB
-      m_dpb->addNewPic( genPic ); 
+      m_dpb->addNewPic( genPic );
     }
   }
@@ -3280 +3295 @@
   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]; 
+  Bool hasGeneratedRefPic = false;
+  for (Int j = 0; j < 3; j++ )
+  {
+    std::vector<TComPic*>* cSet = refPicSetsCurr[j];
     for (Int i = 0 ; i < cSet->size();  i++ )
     {
@@ -3289 +3304 @@
       if ((*cSet)[i]->getIsGenerated() )
       {
-        hasGeneratedRefPic = true; 
-      }
-    }
-  }
-  m_pcPic->setHasGeneratedRefPics( hasGeneratedRefPic ); 
+        hasGeneratedRefPic = true;
+      }
+    }
+  }
+  m_pcPic->setHasGeneratedRefPics( hasGeneratedRefPic );
 }