Changeset 906 in SHVCSoftware for trunk/source/Lib/TLibEncoder

Timestamp:

15 Oct 2014, 07:25:10 (10 years ago)

Author:

seregin

Message:

merge SHM-dev

Location:

trunk

Files:

• . (modified) (1 prop)
• source (modified) (1 prop)
• source/Lib/TLibEncoder/SEIwrite.cpp (modified) (19 diffs)
• source/Lib/TLibEncoder/SEIwrite.h (modified) (4 diffs)
• source/Lib/TLibEncoder/TEnc3DAsymLUT.cpp (modified) (20 diffs)
• source/Lib/TLibEncoder/TEnc3DAsymLUT.h (modified) (6 diffs)
• source/Lib/TLibEncoder/TEncCavlc.cpp (modified) (56 diffs)
• source/Lib/TLibEncoder/TEncCavlc.h (modified) (1 diff)
• source/Lib/TLibEncoder/TEncCfg.h (modified) (11 diffs)
• source/Lib/TLibEncoder/TEncGOP.cpp (modified) (53 diffs)
• source/Lib/TLibEncoder/TEncGOP.h (modified) (3 diffs)
• source/Lib/TLibEncoder/TEncSearch.cpp (modified) (10 diffs)
• source/Lib/TLibEncoder/TEncSlice.cpp (modified) (22 diffs)
• source/Lib/TLibEncoder/TEncSlice.h (modified) (1 diff)
• source/Lib/TLibEncoder/TEncTop.cpp (modified) (21 diffs)
• source/Lib/TLibEncoder/TEncTop.h (modified) (6 diffs)

trunk/source/Lib/TLibEncoder/SEIwrite.cpp

@@ -92 +92 @@
     break;
 #endif
-#if Q0074_SEI_COLOR_MAPPING
-  case SEI::COLOR_MAPPING_INFO:
-    fprintf( g_hTrace, "=========== Color Mapping Info SEI message ===========\n");
+#if Q0074_COLOUR_REMAPPING_SEI
+  case SEI::COLOUR_REMAPPING_INFO:
+    fprintf( g_hTrace, "=========== Colour Remapping Information SEI message ===========\n");
     break;
 #endif
@@ -126 +126 @@
     fprintf( g_hTrace, "=========== Bitstream parition initial arrival time SEI message ===========\n");
     break;
+#if !REMOVE_BSP_HRD_SEI
   case SEI::BSP_HRD:
     fprintf( g_hTrace, "=========== Bitstream parition HRD parameters SEI message ===========\n");
     break;
+#endif
 #endif
 #if Q0078_ADD_LAYER_SETS
@@ -147 +149 @@
 
 #if O0164_MULTI_LAYER_HRD
+#if VPS_VUI_BSP_HRD_PARAMS
+void SEIWriter::xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComVPS *vps, TComSPS *sps, const SEIScalableNesting* nestingSeiPtr, const SEIBspNesting* bspNestingSeiPtr)
+#else
 void SEIWriter::xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComVPS *vps, TComSPS *sps, const SEIScalableNesting& nestingSei, const SEIBspNesting& bspNestingSei)
+#endif
 #else
 void SEIWriter::xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComSPS *sps)
 #endif
 {
+#if VPS_VUI_BSP_HRD_PARAMS
+  SEIScalableNesting nestingSei;
+  SEIBspNesting      bspNestingSei;
+  if( nestingSeiPtr )
+  {
+    nestingSei = *nestingSeiPtr;
+  }
+  if( bspNestingSeiPtr )
+  {
+    bspNestingSei = *bspNestingSeiPtr;
+  }
+#endif
   switch (sei.payloadType())
   {
@@ -160 +178 @@
     xWriteSEIActiveParameterSets(*static_cast<const SEIActiveParameterSets*>(& sei)); 
     break; 
+  case SEI::DECODED_PICTURE_HASH:
+    xWriteSEIDecodedPictureHash(*static_cast<const SEIDecodedPictureHash*>(&sei));
+    break;
+#if VPS_VUI_BSP_HRD_PARAMS
+  case SEI::DECODING_UNIT_INFO:
+    xWriteSEIDecodingUnitInfo(*static_cast<const SEIDecodingUnitInfo*>(& sei), sps, nestingSeiPtr, bspNestingSeiPtr, vps);
+    break;
+  case SEI::BUFFERING_PERIOD:
+    xWriteSEIBufferingPeriod(*static_cast<const SEIBufferingPeriod*>(&sei), sps, nestingSeiPtr, bspNestingSeiPtr, vps);
+    break;
+  case SEI::PICTURE_TIMING:
+    xWriteSEIPictureTiming(*static_cast<const SEIPictureTiming*>(&sei), sps, nestingSeiPtr, bspNestingSeiPtr, vps);
+    break;
+#else
   case SEI::DECODING_UNIT_INFO:
     xWriteSEIDecodingUnitInfo(*static_cast<const SEIDecodingUnitInfo*>(& sei), sps);
     break;
-  case SEI::DECODED_PICTURE_HASH:
-    xWriteSEIDecodedPictureHash(*static_cast<const SEIDecodedPictureHash*>(&sei));
-    break;
   case SEI::BUFFERING_PERIOD:
     xWriteSEIBufferingPeriod(*static_cast<const SEIBufferingPeriod*>(&sei), sps);
@@ -172 +201 @@
     xWriteSEIPictureTiming(*static_cast<const SEIPictureTiming*>(&sei), sps);
     break;
+#endif
   case SEI::RECOVERY_POINT:
     xWriteSEIRecoveryPoint(*static_cast<const SEIRecoveryPoint*>(&sei));
@@ -195 +225 @@
     break;
 #endif
-#if Q0074_SEI_COLOR_MAPPING
-  case SEI::COLOR_MAPPING_INFO:
-    xWriteSEIColorMappingInfo(*static_cast<const SEIColorMappingInfo*>(&sei));
+#if Q0074_COLOUR_REMAPPING_SEI
+  case SEI::COLOUR_REMAPPING_INFO:
+    xWriteSEIColourRemappingInfo(*static_cast<const SEIColourRemappingInfo*>(&sei));
     break;
 #endif
@@ -233 +263 @@
      xWriteSEIBspInitialArrivalTime(*static_cast<const SEIBspInitialArrivalTime*>(&sei), vps, sps, nestingSei, bspNestingSei);
      break;
+#if !REMOVE_BSP_HRD_SEI
    case SEI::BSP_HRD:
      xWriteSEIBspHrd(*static_cast<const SEIBspHrd*>(&sei), sps, nestingSei);
      break;
+#endif
 #endif
 #if Q0078_ADD_LAYER_SETS
@@ -283 +315 @@
 #endif
 #if O0164_MULTI_LAYER_HRD
+#if VPS_VUI_BSP_HRD_PARAMS
+  xWriteSEIpayloadData(bs_count, sei, vps, sps, nestingSei, bspNestingSei);
+#else
   xWriteSEIpayloadData(bs_count, sei, vps, sps, *nestingSei, *bspNestingSei);
+#endif
 #else
   xWriteSEIpayloadData(bs_count, sei, sps);
@@ -322 +358 @@
 
 #if O0164_MULTI_LAYER_HRD
+#if VPS_VUI_BSP_HRD_PARAMS
+  xWriteSEIpayloadData(bs, sei, vps, sps, nestingSei, bspNestingSei);
+#else
   xWriteSEIpayloadData(bs, sei, vps, sps, *nestingSei, *bspNestingSei);
+#endif
 #else
   xWriteSEIpayloadData(bs, sei, sps);
@@ -390 +430 @@
     WRITE_UVLC(sei.activeSeqParameterSetId[i], "active_seq_parameter_set_id"); 
   }
-  xWriteByteAlign();
-}
-
+#if R0247_SEI_ACTIVE
+  for (Int i = 1; i < sei.activeSeqParameterSetId.size(); i++)
+  {
+    WRITE_UVLC(sei.layerSpsIdx[i], "layer_sps_idx"); 
+  }
+#endif
+  xWriteByteAlign();
+}
+
+#if VPS_VUI_BSP_HRD_PARAMS
+Void SEIWriter::xWriteSEIDecodingUnitInfo(const SEIDecodingUnitInfo& sei, TComSPS *sps, const SEIScalableNesting* nestingSei, const SEIBspNesting* bspNestingSei, TComVPS *vps)
+#else
 Void SEIWriter::xWriteSEIDecodingUnitInfo(const SEIDecodingUnitInfo& sei, TComSPS *sps)
-{
+#endif
+{
+#if VPS_VUI_BSP_HRD_PARAMS
+  TComHRD *hrd;
+  if( bspNestingSei )   // If DU info SEI contained inside a BSP nesting SEI message
+  {
+    assert( nestingSei );
+    Int psIdx = bspNestingSei->m_seiPartitioningSchemeIdx;
+    Int seiOlsIdx = bspNestingSei->m_seiOlsIdx;
+    Int maxTemporalId = nestingSei->m_nestingMaxTemporalIdPlus1[0] - 1;
+    Int maxValues = vps->getNumBspSchedulesMinus1(seiOlsIdx, psIdx, maxTemporalId) + 1;
+    std::vector<Int> hrdIdx(maxValues, 0);
+    std::vector<TComHRD *> hrdVec;
+    std::vector<Int> syntaxElemLen(maxValues, 0);
+    for(Int i = 0; i < maxValues; i++)
+    {
+      hrdIdx[i] = vps->getBspHrdIdx( seiOlsIdx, psIdx, maxTemporalId, i, bspNestingSei->m_bspIdx);
+      hrdVec.push_back(vps->getBspHrd(hrdIdx[i]));
+    
+      syntaxElemLen[i] = hrdVec[i]->getInitialCpbRemovalDelayLengthMinus1() + 1;
+      if ( !(hrdVec[i]->getNalHrdParametersPresentFlag() || hrdVec[i]->getVclHrdParametersPresentFlag()) )
+      {
+        assert( syntaxElemLen[i] == 24 ); // Default of value init_cpb_removal_delay_length_minus1 is 23
+      }
+      if( i > 0 )
+      {
+        assert( hrdVec[i]->getSubPicCpbParamsPresentFlag()    == hrdVec[i-1]->getSubPicCpbParamsPresentFlag() );
+        assert( hrdVec[i]->getSubPicCpbParamsInPicTimingSEIFlag()   == hrdVec[i-1]->getSubPicCpbParamsInPicTimingSEIFlag() );
+        assert( hrdVec[i]->getDpbOutputDelayDuLengthMinus1()  == hrdVec[i-1]->getDpbOutputDelayDuLengthMinus1() );
+        // To be done: Check CpbDpbDelaysPresentFlag
+      }
+    }
+    hrd = hrdVec[0];
+  }
+  else
+  {
+    TComVUI *vui = sps->getVuiParameters();
+    hrd = vui->getHrdParameters();
+  }
+#else
   TComVUI *vui = sps->getVuiParameters();
+  TComHrd *hrd = vui->getHrdParameters();
+#endif
   WRITE_UVLC(sei.m_decodingUnitIdx, "decoding_unit_idx");
-  if(vui->getHrdParameters()->getSubPicCpbParamsInPicTimingSEIFlag())
-  {
-    WRITE_CODE( sei.m_duSptCpbRemovalDelay, (vui->getHrdParameters()->getDuCpbRemovalDelayLengthMinus1() + 1), "du_spt_cpb_removal_delay");
+  if(hrd->getSubPicCpbParamsInPicTimingSEIFlag())
+  {
+    WRITE_CODE( sei.m_duSptCpbRemovalDelay, (hrd->getDuCpbRemovalDelayLengthMinus1() + 1), "du_spt_cpb_removal_delay");
   }
   WRITE_FLAG( sei.m_dpbOutputDuDelayPresentFlag, "dpb_output_du_delay_present_flag");
   if(sei.m_dpbOutputDuDelayPresentFlag)
   {
-    WRITE_CODE(sei.m_picSptDpbOutputDuDelay, vui->getHrdParameters()->getDpbOutputDelayDuLengthMinus1() + 1, "pic_spt_dpb_output_du_delay");
-  }
-  xWriteByteAlign();
-}
-
+    WRITE_CODE(sei.m_picSptDpbOutputDuDelay,hrd->getDpbOutputDelayDuLengthMinus1() + 1, "pic_spt_dpb_output_du_delay");
+  }
+  xWriteByteAlign();
+}
+
+#if VPS_VUI_BSP_HRD_PARAMS
+Void SEIWriter::xWriteSEIBufferingPeriod(const SEIBufferingPeriod& sei, TComSPS *sps, const SEIScalableNesting* nestingSei, const SEIBspNesting* bspNestingSei, TComVPS *vps)
+#else
 Void SEIWriter::xWriteSEIBufferingPeriod(const SEIBufferingPeriod& sei, TComSPS *sps)
+#endif
 {
   Int i, nalOrVcl;
+#if VPS_VUI_BSP_HRD_PARAMS
+  TComHRD *hrd;
+  if( bspNestingSei )   // If BP SEI contained inside a BSP nesting SEI message
+  {
+    assert( nestingSei );
+    Int psIdx = bspNestingSei->m_seiPartitioningSchemeIdx;
+    Int seiOlsIdx = bspNestingSei->m_seiOlsIdx;
+    Int maxTemporalId = nestingSei->m_nestingMaxTemporalIdPlus1[0] - 1;
+    Int maxValues = vps->getNumBspSchedulesMinus1(seiOlsIdx, psIdx, maxTemporalId) + 1;
+    std::vector<Int> hrdIdx(maxValues, 0);
+    std::vector<TComHRD *> hrdVec;
+    std::vector<Int> syntaxElemLen(maxValues, 0);
+    for(i = 0; i < maxValues; i++)
+    {
+      hrdIdx[i] = vps->getBspHrdIdx( seiOlsIdx, psIdx, maxTemporalId, i, bspNestingSei->m_bspIdx);
+      hrdVec.push_back(vps->getBspHrd(hrdIdx[i]));
+    
+      syntaxElemLen[i] = hrdVec[i]->getInitialCpbRemovalDelayLengthMinus1() + 1;
+      if ( !(hrdVec[i]->getNalHrdParametersPresentFlag() || hrdVec[i]->getVclHrdParametersPresentFlag()) )
+      {
+        assert( syntaxElemLen[i] == 24 ); // Default of value init_cpb_removal_delay_length_minus1 is 23
+      }
+      if( i > 0 )
+      {
+        assert( hrdVec[i]->getCpbRemovalDelayLengthMinus1()   == hrdVec[i-1]->getCpbRemovalDelayLengthMinus1() );
+        assert( hrdVec[i]->getDpbOutputDelayDuLengthMinus1()  == hrdVec[i-1]->getDpbOutputDelayDuLengthMinus1() );
+        assert( hrdVec[i]->getSubPicCpbParamsPresentFlag()    == hrdVec[i-1]->getSubPicCpbParamsPresentFlag() );
+      }
+    }
+    hrd = hrdVec[i];
+  }
+  else
+  {
+    TComVUI *vui = sps->getVuiParameters();
+    hrd = vui->getHrdParameters();
+  }
+  // To be done: When contained in an BSP HRD SEI message, the hrd structure is to be chosen differently.
+#else
   TComVUI *vui = sps->getVuiParameters();
   TComHRD *hrd = vui->getHrdParameters();
+#endif
 
   WRITE_UVLC( sei.m_bpSeqParameterSetId, "bp_seq_parameter_set_id" );
@@ -452 +585 @@
   xWriteByteAlign();
 }
+#if VPS_VUI_BSP_HRD_PARAMS
+Void SEIWriter::xWriteSEIPictureTiming(const SEIPictureTiming& sei,  TComSPS *sps, const SEIScalableNesting* nestingSei, const SEIBspNesting* bspNestingSei, TComVPS *vps)
+#else
 Void SEIWriter::xWriteSEIPictureTiming(const SEIPictureTiming& sei,  TComSPS *sps)
+#endif
 {
   Int i;
+#if VPS_VUI_BSP_HRD_PARAMS
+  TComHRD *hrd;    
+  TComVUI *vui = sps->getVuiParameters(); 
+  if( bspNestingSei )   // If BP SEI contained inside a BSP nesting SEI message
+  {
+    assert( nestingSei );
+    Int psIdx = bspNestingSei->m_seiPartitioningSchemeIdx;
+    Int seiOlsIdx = bspNestingSei->m_seiOlsIdx;
+    Int maxTemporalId = nestingSei->m_nestingMaxTemporalIdPlus1[0] - 1;
+    Int maxValues = vps->getNumBspSchedulesMinus1(seiOlsIdx, psIdx, maxTemporalId) + 1;
+    std::vector<Int> hrdIdx(maxValues, 0);
+    std::vector<TComHRD *> hrdVec;
+    std::vector<Int> syntaxElemLen(maxValues, 0);
+    for(i = 0; i < maxValues; i++)
+    {
+      hrdIdx[i] = vps->getBspHrdIdx( seiOlsIdx, psIdx, maxTemporalId, i, bspNestingSei->m_bspIdx);
+      hrdVec.push_back(vps->getBspHrd(hrdIdx[i]));
+    
+      syntaxElemLen[i] = hrdVec[i]->getInitialCpbRemovalDelayLengthMinus1() + 1;
+      if ( !(hrdVec[i]->getNalHrdParametersPresentFlag() || hrdVec[i]->getVclHrdParametersPresentFlag()) )
+      {
+        assert( syntaxElemLen[i] == 24 ); // Default of value init_cpb_removal_delay_length_minus1 is 23
+      }
+      if( i > 0 )
+      {
+        assert( hrdVec[i]->getSubPicCpbParamsPresentFlag()    == hrdVec[i-1]->getSubPicCpbParamsPresentFlag() );
+        assert( hrdVec[i]->getSubPicCpbParamsInPicTimingSEIFlag()   == hrdVec[i-1]->getSubPicCpbParamsInPicTimingSEIFlag() );
+        assert( hrdVec[i]->getCpbRemovalDelayLengthMinus1()  == hrdVec[i-1]->getCpbRemovalDelayLengthMinus1() );
+        assert( hrdVec[i]->getDpbOutputDelayLengthMinus1()  == hrdVec[i-1]->getDpbOutputDelayLengthMinus1() );
+        assert( hrdVec[i]->getDpbOutputDelayDuLengthMinus1()  == hrdVec[i-1]->getDpbOutputDelayDuLengthMinus1() );
+        assert( hrdVec[i]->getDuCpbRemovalDelayLengthMinus1()  == hrdVec[i-1]->getDuCpbRemovalDelayLengthMinus1() );
+        // To be done: Check CpbDpbDelaysPresentFlag
+      }
+    }
+    hrd = hrdVec[0];
+  }
+  else
+  {
+    hrd = vui->getHrdParameters();
+  }
+  // To be done: When contained in an BSP HRD SEI message, the hrd structure is to be chosen differently.
+#else
   TComVUI *vui = sps->getVuiParameters();
   TComHRD *hrd = vui->getHrdParameters();
-
-  if( vui->getFrameFieldInfoPresentFlag() )
+#endif
+
+  if( vui->getFrameFieldInfoPresentFlag() ) // To be done: Check whether this is the correct invocation of vui when PT SEI contained in BSP nesting SEI
   {
     WRITE_CODE( sei.m_picStruct, 4,              "pic_struct" );
@@ -634 +814 @@
 }
 #endif
-#if Q0074_SEI_COLOR_MAPPING
-Void SEIWriter::xWriteSEIColorMappingInfo(const SEIColorMappingInfo& sei)
-{
-  WRITE_UVLC( sei.m_colorMapId,                    "colour_map_id" );
-  WRITE_FLAG( sei.m_colorMapCancelFlag,            "colour_map_cancel_flag" );
-  if( !sei.m_colorMapCancelFlag ) 
-  {
-    WRITE_FLAG( sei.m_colorMapPersistenceFlag,            "colour_map_persistence_flag" );
-    WRITE_FLAG( sei.m_colorMap_video_signal_type_present_flag,            "colour_map_video_signal_type_present_flag" );
-    if ( sei.m_colorMap_video_signal_type_present_flag )
-    {
-      WRITE_FLAG( sei.m_colorMap_video_full_range_flag,       "colour_map_video_full_range_flag" );
-      WRITE_CODE( sei.m_colorMap_primaries,                 8,      "colour_map_primaries" );
-      WRITE_CODE( sei.m_colorMap_transfer_characteristics,  8,      "colour_map_transfer_characteristics" );
-      WRITE_CODE( sei.m_colorMap_matrix_coeffs,             8,      "colour_map_matrix_coeffs" );
-    }
-  }
-
-  WRITE_CODE( sei.m_colour_map_coded_data_bit_depth,  5,  "colour_map_coded_data_bit_depth" );
-  WRITE_CODE( sei.m_colour_map_target_bit_depth,  5,      "colour_map_target_bit_depth" );
-  WRITE_UVLC( sei.m_colorMapModelId,                      "colour_map_model_id" );
-
-  assert( sei.m_colorMapModelId == 0 );
-  
-  for( Int i=0 ; i<3 ; i++ )
-  {
-    WRITE_CODE( sei.m_num_input_pivots[i] - 1,         8,      "num_input_pivots_minus1[i]" );
-    for( Int j=0 ; j<sei.m_num_input_pivots[i] ; j++ )
-    {
-      WRITE_CODE( sei.m_coded_input_pivot_value[i][j],  (( sei.m_colour_map_coded_data_bit_depth + 7 ) >> 3 ) << 3, "coded_input_pivot_value[i][j]" );
-      WRITE_CODE( sei.m_target_input_pivot_value[i][j], (( sei.m_colour_map_coded_data_bit_depth + 7 ) >> 3 ) << 3, "target_input_pivot_value[i][j]" );
-    }
-  }
-
-  WRITE_FLAG( sei.m_matrix_flag,            "matrix_flag" );
-  if( sei.m_matrix_flag )
-  {
-    WRITE_CODE( sei.m_log2_matrix_denom, 4, "log2_matrix_denom" );
-    for( Int i=0 ; i<3 ; i++ )
-    {
-      for( Int j=0 ; j<3 ; j++ )
-      {
-        WRITE_SVLC( sei.m_matrix_coef[i][j],  "matrix_coef[i][j]" );
-      }
-    }
-  }
-
-  for( Int i=0 ; i<3 ; i++ )
-  {
-    WRITE_CODE( sei.m_num_output_pivots[i] - 1,         8,      "num_output_pivots_minus1[i]" );
-    for( Int j=0 ; j<sei.m_num_output_pivots[i] ; j++ )
-    {
-      WRITE_CODE( sei.m_coded_output_pivot_value[i][j],  (( sei.m_colour_map_coded_data_bit_depth + 7 ) >> 3 ) << 3, "coded_output_pivot_value[i][j]" );
-      WRITE_CODE( sei.m_target_output_pivot_value[i][j], (( sei.m_colour_map_coded_data_bit_depth + 7 ) >> 3 ) << 3, "target_output_pivot_value[i][j]" );
-    }
-  }
-
+#if Q0074_COLOUR_REMAPPING_SEI
+Void SEIWriter::xWriteSEIColourRemappingInfo(const SEIColourRemappingInfo& sei)
+{
+  WRITE_UVLC( sei.m_colourRemapId,                             "colour_remap_id" );
+  WRITE_FLAG( sei.m_colourRemapCancelFlag,                     "colour_remap_cancel_flag" );
+  if( !sei.m_colourRemapCancelFlag ) 
+  {
+    WRITE_FLAG( sei.m_colourRemapPersistenceFlag,              "colour_remap_persistence_flag" );
+    WRITE_FLAG( sei.m_colourRemapVideoSignalInfoPresentFlag,   "colour_remap_video_signal_info_present_flag" );
+    if ( sei.m_colourRemapVideoSignalInfoPresentFlag )
+    {
+      WRITE_FLAG( sei.m_colourRemapFullRangeFlag,              "colour_remap_full_range_flag" );
+      WRITE_CODE( sei.m_colourRemapPrimaries,               8, "colour_remap_primaries" );
+      WRITE_CODE( sei.m_colourRemapTransferFunction,        8, "colour_remap_transfer_function" );
+      WRITE_CODE( sei.m_colourRemapMatrixCoefficients,      8, "colour_remap_matrix_coefficients" );
+    }
+    WRITE_CODE( sei.m_colourRemapInputBitDepth,             8, "colour_remap_input_bit_depth" );
+    WRITE_CODE( sei.m_colourRemapBitDepth,                  8, "colour_remap_bit_depth" );
+    for( Int c=0 ; c<3 ; c++ )
+    {
+      WRITE_CODE( sei.m_preLutNumValMinus1[c],              8, "pre_lut_num_val_minus1[c]" );
+      if( sei.m_preLutNumValMinus1[c]>0 )
+        for( Int i=0 ; i<=sei.m_preLutNumValMinus1[c] ; i++ )
+        {
+          WRITE_CODE( sei.m_preLutCodedValue[c][i], (( sei.m_colourRemapInputBitDepth + 7 ) >> 3 ) << 3, "pre_lut_coded_value[c][i]" );
+          WRITE_CODE( sei.m_preLutTargetValue[c][i], (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, "pre_lut_target_value[c][i]" );
+        }
+    }
+    WRITE_FLAG( sei.m_colourRemapMatrixPresentFlag,            "colour_remap_matrix_present_flag" );
+    if( sei.m_colourRemapMatrixPresentFlag )
+    {
+      WRITE_CODE( sei.m_log2MatrixDenom,                    4, "log2_matrix_denom" );
+      for( Int c=0 ; c<3 ; c++ )
+        for( Int i=0 ; i<3 ; i++ )
+          WRITE_SVLC( sei.m_colourRemapCoeffs[c][i],           "colour_remap_coeffs[c][i]" );
+    }
+
+    for( Int c=0 ; c<3 ; c++ )
+    {
+      WRITE_CODE( sei.m_postLutNumValMinus1[c],             8, "m_postLutNumValMinus1[c]" );
+      if( sei.m_postLutNumValMinus1[c]>0 )
+        for( Int i=0 ; i<=sei.m_postLutNumValMinus1[c] ; i++ )
+        {
+          WRITE_CODE( sei.m_postLutCodedValue[c][i], (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, "post_lut_coded_value[c][i]" );       
+          WRITE_CODE( sei.m_postLutTargetValue[c][i], (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, "post_lut_target_value[c][i]" );
+        }
+    }
+  }
   xWriteByteAlign();
 }
@@ -753 +924 @@
   {
     WRITE_FLAG( sei.m_defaultOpFlag,                 "default_op_flag"               );
-    WRITE_UVLC( sei.m_nestingNumOpsMinus1,           "nesting_num_ops"               );
+    WRITE_UVLC( sei.m_nestingNumOpsMinus1,           "nesting_num_ops_minus1"        );
     for (UInt i = (sei.m_defaultOpFlag ? 1 : 0); i <= sei.m_nestingNumOpsMinus1; i++)
     {
-      WRITE_CODE( sei.m_nestingNoOpMaxTemporalIdPlus1, 3, "nesting_no_op_max_temporal_id" );
-      WRITE_CODE( sei.m_nestingMaxTemporalIdPlus1[i], 3,  "nesting_max_temporal_id"       );
+      WRITE_CODE( sei.m_nestingMaxTemporalIdPlus1[i], 3,  "nesting_max_temporal_id_plus1" );
       WRITE_UVLC( sei.m_nestingOpIdx[i],                  "nesting_op_idx"                );
     }
@@ -766 +936 @@
     if (!sei.m_allLayersFlag)
     {
-      WRITE_CODE( sei.m_nestingNoOpMaxTemporalIdPlus1, 3, "nesting_no_op_max_temporal_id" );
-      WRITE_UVLC( sei.m_nestingNumLayersMinus1,           "nesting_num_layers"            );
+      WRITE_CODE( sei.m_nestingNoOpMaxTemporalIdPlus1, 3, "nesting_no_op_max_temporal_id_plus1" );
+      WRITE_UVLC( sei.m_nestingNumLayersMinus1,           "nesting_num_layers"                  );
       for (UInt i = 0; i <= sei.m_nestingNumLayersMinus1; i++)
       {
@@ -901 +1071 @@
     WRITE_FLAG( 0, "bsp_nesting_zero_bit" );
   }
-
+#if NESTING_SEI_EXTENSIBILITY
+  assert( sei.m_nestedSEIs.size() <= MAX_SEIS_IN_BSP_NESTING );
+  WRITE_UVLC( sei.m_nestedSEIs.size(), "num_seis_in_bsp_minus1" );
+#endif
   // write nested SEI messages
   for (SEIMessages::const_iterator it = sei.m_nestedSEIs.begin(); it != sei.m_nestedSEIs.end(); it++)
@@ -913 +1086 @@
   assert(vps->getVpsVuiPresentFlag());
 
+#if VPS_VUI_BSP_HRD_PARAMS
+  Int psIdx = bspNestingSei.m_seiPartitioningSchemeIdx;
+  Int seiOlsIdx = bspNestingSei.m_seiOlsIdx;
+  Int maxTemporalId = nestingSei.m_nestingMaxTemporalIdPlus1[0] - 1;
+  Int maxValues = vps->getNumBspSchedulesMinus1(seiOlsIdx, psIdx, maxTemporalId) + 1;
+  std::vector<Int> hrdIdx(maxValues, 0);
+  std::vector<TComHRD *> hrdVec;
+  std::vector<Int> syntaxElemLen(maxValues, 0);
+  for(Int i = 0; i < maxValues; i++)
+  {
+    hrdIdx[i] = vps->getBspHrdIdx( seiOlsIdx, psIdx, maxTemporalId, i, bspNestingSei.m_bspIdx);
+    hrdVec.push_back(vps->getBspHrd(hrdIdx[i]));
+    
+    syntaxElemLen[i] = hrdVec[i]->getInitialCpbRemovalDelayLengthMinus1() + 1;
+    if ( !(hrdVec[i]->getNalHrdParametersPresentFlag() || hrdVec[i]->getVclHrdParametersPresentFlag()) )
+    {
+      assert( syntaxElemLen[i] == 24 ); // Default of value init_cpb_removal_delay_length_minus1 is 23
+    }
+    if( i > 0 )
+    {
+      assert( hrdVec[i]->getNalHrdParametersPresentFlag() == hrdVec[i-1]->getNalHrdParametersPresentFlag() );
+      assert( hrdVec[i]->getVclHrdParametersPresentFlag() == hrdVec[i-1]->getVclHrdParametersPresentFlag() );
+    }
+  }
+  if (hrdVec[0]->getNalHrdParametersPresentFlag())
+  {
+    for(UInt i = 0; i < maxValues; i++)
+    {
+      WRITE_CODE( sei.m_nalInitialArrivalDelay[i], syntaxElemLen[i], "nal_initial_arrival_delay[i]" );
+    }
+  }
+  if( hrdVec[0]->getVclHrdParametersPresentFlag() )
+  {
+    for(UInt i = 0; i < maxValues; i++)
+    {
+      WRITE_CODE( sei.m_vclInitialArrivalDelay[i], syntaxElemLen[i], "vcl_initial_arrival_delay[i]" );
+    }
+  }
+#else
   UInt schedCombCnt = vps->getNumBspSchedCombinations(nestingSei.m_nestingOpIdx[0]);
   UInt len;
@@ -944 +1156 @@
     }
   }
+#if BSP_INIT_ARRIVAL_SEI
+  if( hrd->getVclHrdParametersPresentFlag() )
+#else
   else
+#endif
   {
     for(UInt i = 0; i < schedCombCnt; i++)
@@ -951 +1167 @@
     }
   }
-}
-
+#endif
+}
+
+#if !REMOVE_BSP_HRD_SEI
 Void SEIWriter::xWriteSEIBspHrd(const SEIBspHrd &sei, TComSPS *sps, const SEIScalableNesting &nestingSei)
 {
@@ -1004 +1222 @@
   }
 }
+#endif
 
 Void SEIWriter::xCodeHrdParameters( TComHRD *hrd, Bool commonInfPresentFlag, UInt maxNumSubLayersMinus1 )

trunk/source/Lib/TLibEncoder/SEIwrite.h

@@ -55 +55 @@
 protected:
 #if O0164_MULTI_LAYER_HRD
+#if VPS_VUI_BSP_HRD_PARAMS
+  Void xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComVPS *vps, TComSPS *sps, const SEIScalableNesting* nestingSei, const SEIBspNesting* bspNestingSei);
+#else
   Void xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComVPS *vps, TComSPS *sps, const SEIScalableNesting& nestingSei, const SEIBspNesting& bspNestingSei);
+#endif
 #else
   Void xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComSPS *sps);
@@ -61 +65 @@
   Void xWriteSEIuserDataUnregistered(const SEIuserDataUnregistered &sei);
   Void xWriteSEIActiveParameterSets(const SEIActiveParameterSets& sei);
+  Void xWriteSEIDecodedPictureHash(const SEIDecodedPictureHash& sei);
+#if VPS_VUI_BSP_HRD_PARAMS
+  Void xWriteSEIDecodingUnitInfo(const SEIDecodingUnitInfo& sei, TComSPS *sps, const SEIScalableNesting* nestingSei, const SEIBspNesting* bspNestingSei, TComVPS *vps);
+  Void xWriteSEIBufferingPeriod(const SEIBufferingPeriod& sei, TComSPS *sps, const SEIScalableNesting* nestingSei, const SEIBspNesting* bspNestingSei, TComVPS *vps);
+  Void xWriteSEIPictureTiming(const SEIPictureTiming& sei, TComSPS *sps, const SEIScalableNesting* nestingSei, const SEIBspNesting* bspNestingSei, TComVPS *vps);
+#else
   Void xWriteSEIDecodingUnitInfo(const SEIDecodingUnitInfo& sei, TComSPS *sps);
-  Void xWriteSEIDecodedPictureHash(const SEIDecodedPictureHash& sei);
   Void xWriteSEIBufferingPeriod(const SEIBufferingPeriod& sei, TComSPS *sps);
   Void xWriteSEIPictureTiming(const SEIPictureTiming& sei, TComSPS *sps);
+#endif
   TComSPS *m_pSPS;
   Void xWriteSEIRecoveryPoint(const SEIRecoveryPoint& sei);
@@ -75 +85 @@
   Void xWriteSEIKneeFunctionInfo(const SEIKneeFunctionInfo &sei);
 #endif
-#if Q0074_SEI_COLOR_MAPPING
-  Void xWriteSEIColorMappingInfo(const SEIColorMappingInfo& sei);
+#if Q0074_COLOUR_REMAPPING_SEI
+  Void xWriteSEIColourRemappingInfo(const SEIColourRemappingInfo& sei);
 #endif
   Void xWriteSEISOPDescription(const SEISOPDescription& sei);
@@ -104 +114 @@
   Void xWriteSEIBspNesting(TComBitIf& bs, const SEIBspNesting &sei, TComVPS *vps, TComSPS *sps, const SEIScalableNesting &nestingSei);
   Void xWriteSEIBspInitialArrivalTime(const SEIBspInitialArrivalTime &sei, TComVPS *vps, TComSPS *sps, const SEIScalableNesting &nestingSei, const SEIBspNesting &bspNestingSei);
+#if !REMOVE_BSP_HRD_SEI
   Void xWriteSEIBspHrd(const SEIBspHrd &sei, TComSPS *sps, const SEIScalableNesting &nestingSei);
+#endif
   Void xCodeHrdParameters( TComHRD *hrd, Bool commonInfPresentFlag, UInt maxNumSubLayersMinus1 );
 #endif

trunk/source/Lib/TLibEncoder/TEnc3DAsymLUT.cpp

@@ -14 +14 @@
   m_pColorInfoC = NULL;
   m_pEncCuboid = NULL;
+
   m_pBestEncCuboid = NULL;
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  m_nAccuFrameBit = 0;
+  m_nAccuFrameCGSBit = 0;
+  m_nPrevFrameCGSPartNumLog2 = 0;
+#else
   memset( m_nPrevFrameBit , 0 , sizeof( m_nPrevFrameBit ) );
   memset( m_nPrevFrameCGSBit , 0 , sizeof( m_nPrevFrameCGSBit ) );
   memset( m_nPrevFrameCGSPartNumLog2 , 0 , sizeof( m_nPrevFrameCGSPartNumLog2 ) );
   memset( m_nPrevFrameOverWritePPS , 0 , sizeof( m_nPrevFrameOverWritePPS ) );
+#endif
   m_dTotalFrameBit = 0;
   m_nTotalCGSBit = 0;
   m_nPPSBit = 0;
   m_pDsOrigPic = NULL;
+#if R0179_ENC_OPT_3DLUT_SIZE
+  m_pMaxColorInfo = NULL;
+  m_pMaxColorInfoC = NULL;
+
+  
+  // fixed m_dDistFactor
+  Double dTmpFactor[3];   
+  dTmpFactor[I_SLICE] = 1.0;
+  dTmpFactor[P_SLICE] = 4./3.;
+  dTmpFactor[B_SLICE] = 1.5; 
+  for( Int iSliceType = 0; iSliceType < 3; iSliceType++) 
+  {
+    for(Int iLayer = 0; iLayer < MAX_TLAYER; iLayer++)
+    {
+      m_dDistFactor[iSliceType][iLayer] = dTmpFactor[iSliceType]*(Double)(1<<iLayer);      
+    }
+  }
+  // initialization with approximate number of bits to code the LUT
+  m_nNumLUTBits[0][0] = 200; // 1x1x1
+  m_nNumLUTBits[1][0] = 400; // 2x1x1  
+  m_nNumLUTBits[1][1] = 1500; // 2x2x2  
+  m_nNumLUTBits[2][0] = 800; // 4x1x1
+  m_nNumLUTBits[2][1] = 3200; // 4x2x2  
+  m_nNumLUTBits[2][2] = 8500; // 4x4x4  
+  m_nNumLUTBits[3][0] = 1200; // 8x1x1
+  m_nNumLUTBits[3][1] = 4500; // 8x2x2  
+  m_nNumLUTBits[3][2] = 10000; // 8x4x4  
+  m_nNumLUTBits[3][3] = 12000; // 8x8x8
+#endif
 }
 
@@ -32 +68 @@
   }
 
-  TCom3DAsymLUT::create( nMaxOctantDepth , nInputBitDepth , nInputBitDepthC, nOutputBitDepth , nOutputBitDepthC, nMaxYPartNumLog2 );
+  TCom3DAsymLUT::create( nMaxOctantDepth , nInputBitDepth , nInputBitDepthC, nOutputBitDepth , nOutputBitDepthC, nMaxYPartNumLog2 
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+    , 1 << ( nInputBitDepthC - 1 ) , 1 << ( nInputBitDepthC - 1 )
+#endif
+    );
   xAllocate3DArray( m_pColorInfo , xGetYSize() , xGetUSize() , xGetVSize() );
   xAllocate3DArray( m_pColorInfoC , xGetYSize() , xGetUSize() , xGetVSize() );
   xAllocate3DArray( m_pEncCuboid , xGetYSize() , xGetUSize() , xGetVSize() );
   xAllocate3DArray( m_pBestEncCuboid , xGetYSize() , xGetUSize() , xGetVSize() );
+#if R0179_ENC_OPT_3DLUT_SIZE
+  xAllocate3DArray( m_pMaxColorInfo , xGetYSize() , xGetUSize() , xGetVSize() );
+  xAllocate3DArray( m_pMaxColorInfoC , xGetYSize() , xGetUSize() , xGetVSize() );
+
+  m_pEncCavlc = new TEncCavlc;
+  m_pBitstreamRedirect = new TComOutputBitstream;
+  m_pEncCavlc->setBitstream(m_pBitstreamRedirect);
+#endif
 }
 
@@ -45 +93 @@
   xFree3DArray( m_pEncCuboid );
   xFree3DArray( m_pBestEncCuboid );
+#if R0179_ENC_OPT_3DLUT_SIZE
+  xFree3DArray( m_pMaxColorInfo );
+  xFree3DArray( m_pMaxColorInfoC );
+  delete m_pBitstreamRedirect;
+  delete m_pEncCavlc;
+#endif 
   TCom3DAsymLUT::destroy();
 }
@@ -58 +112 @@
 }
 
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+Double TEnc3DAsymLUT::xxDeriveVertexPerColor( Double N , Double Ys , Double Yy , Double Yu , Double Yv , Double ys , Double us , Double vs , Double yy , Double yu , Double yv , Double uu , Double uv , Double vv , Double YY ,
+  Pel & rP0 , Pel & rP1 , Pel & rP3 , Pel & rP7 , Int nResQuantBit )
+{
+  Int nInitP0 = rP0;
+  Int nInitP1 = rP1;
+  Int nInitP3 = rP3;
+  Int nInitP7 = rP7;
+
+  const Int nOne = xGetNormCoeffOne();
+  Double dNorm = (N * yy * vv * uu - N * yy * uv * uv - N * yv * yv * uu - N * vv * yu * yu + 2 * N * yv * uv * yu - yy * vs * vs * uu + 2 * yy * vs * uv * us - yy * vv * us * us - 2 * vs * uv * yu * ys + uv * uv * ys * ys + vs * vs * yu * yu - 2 * yv * vs * us * yu + 2 * yv * vs * ys * uu - 2 * yv * uv * us * ys + 2 * vv * yu * ys * us - vv * uu * ys * ys + yv * yv * us * us);
+  if( N > 16 && dNorm != 0 )
+  {
+    Double dInitA = (-N * uu * yv * Yv + N * uu * Yy * vv - N * Yy * uv * uv + N * yv * uv * Yu - N * yu * Yu * vv + N * yu * uv * Yv + yu * us * Ys * vv - vs * ys * uv * Yu - yu * vs * us * Yv - yv * uv * us * Ys - yv * vs * us * Yu - yu * uv * vs * Ys - ys * us * uv * Yv + ys * us * Yu * vv + 2 * Yy * vs * uv * us + uu * yv * vs * Ys - uu * ys * Ys * vv + uu * vs * ys * Yv + ys * Ys * uv * uv - Yy * vv * us * us + yu * Yu * vs * vs + yv * Yv * us * us - uu * Yy * vs * vs) / dNorm;
+    Double dInitB = (N * yy * Yu * vv - N * yy * uv * Yv - N * Yu * yv * yv - N * yu * Yy * vv + N * uv * yv * Yy + N * yv * yu * Yv - yy * us * Ys * vv + yy * uv * vs * Ys - yy * Yu * vs * vs + yy * vs * us * Yv - uv * vs * ys * Yy - yv * yu * vs * Ys + yu * Yy * vs * vs + yu * ys * Ys * vv - uv * yv * ys * Ys + 2 * Yu * yv * vs * ys + us * ys * Yy * vv - vs * ys * yu * Yv + uv * ys * ys * Yv + us * Ys * yv * yv - Yu * ys * ys * vv - yv * ys * us * Yv - vs * us * yv * Yy) / dNorm;
+    Double dInitC = -(-N * yy * Yv * uu + N * yy * uv * Yu - N * yv * yu * Yu - N * uv * yu * Yy + N * Yv * yu * yu + N * yv * Yy * uu - yy * uv * us * Ys + yy * Yv * us * us + yy * vs * Ys * uu - yy * vs * us * Yu + yv * ys * us * Yu - vs * Ys * yu * yu - yv * ys * Ys * uu + vs * us * yu * Yy + vs * ys * yu * Yu - uv * Yu * ys * ys + Yv * uu * ys * ys - yv * Yy * us * us - 2 * Yv * yu * ys * us - vs * ys * Yy * uu + uv * us * ys * Yy + uv * yu * ys * Ys + yv * yu * us * Ys) / dNorm;
+    nInitP0 = ( Int )( dInitA * nOne + 0.5 ) >> nResQuantBit << nResQuantBit;
+    nInitP1 = ( Int )( dInitB * nOne + 0.5 ) >> nResQuantBit << nResQuantBit;
+    nInitP3 = ( Int )( dInitC * nOne + 0.5 ) >> nResQuantBit << nResQuantBit;
+  }
+
+  Int nMin = - ( 1 << ( m_nLUTBitDepth - 1 ) );
+  Int nMax = - nMin - ( 1 << nResQuantBit  );
+  Int nMask = ( 1 << nResQuantBit ) - 1;
+
+  Double dMinError = MAX_DOUBLE;
+  Int nTestRange = 2;
+  Int nStepSize = 1 << nResQuantBit;
+  for( Int i = - nTestRange ; i <= nTestRange ; i++ )
+  {
+    for( Int j = - nTestRange ; j <= nTestRange ; j++ )
+    {
+      for( Int k = - nTestRange ; k <= nTestRange ; k++ )
+      {
+        Int nTestP0 = Clip3( nMin , nMax , nInitP0 + i * nStepSize );
+        Int nTestP1 = Clip3( nMin , nMax , nInitP1 + j * nStepSize );
+        Int nTestP3 = Clip3( nMin , nMax , nInitP3 + k * nStepSize );
+        Double a = 1.0 * nTestP0 / nOne;
+        Double b = 1.0 * nTestP1 / nOne;
+        Double c = 1.0 * nTestP3 / nOne;
+        Double d = ( Ys - a * ys - b * us - c * vs ) / N;
+        nInitP7 = ( ( Int )d ) >> nResQuantBit << nResQuantBit;
+        for( Int m = 0 ; m < 2 ; m++ )
+        {
+          Int nTestP7 = Clip3( nMin , nMax , nInitP7 + m * nStepSize );
+          Double dError = xxCalEstDist( N , Ys , Yy , Yu , Yv , ys , us , vs , yy , yu , yv , uu , uv , vv , YY , a , b , c , nTestP7 );
+          if( dError < dMinError )
+          {
+            dMinError = dError;
+            rP0 = ( Pel )nTestP0;
+            rP1 = ( Pel )nTestP1;
+            rP3 = ( Pel )nTestP3;
+            rP7 = ( Pel )nTestP7;
+          }
+        }
+      }
+    }
+  }
+  assert( !( rP0 & nMask ) && !( rP1 & nMask ) && !( rP3 & nMask ) && !( rP7 & nMask ) );
+
+  return( dMinError );
+}
+#else
 Double TEnc3DAsymLUT::xxDeriveVertexPerColor( Double N , Double Ys , Double Yy , Double Yu , Double Yv , Double ys , Double us , Double vs , Double yy , Double yu , Double yv , Double uu , Double uv , Double vv , Double YY ,
   Int y0 , Int u0 , Int v0 , Int nLengthY , Int nLengthUV ,
@@ -134 +251 @@
   return( dMinError );
 }
-
+#endif
+
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+Double TEnc3DAsymLUT::estimateDistWithCur3DAsymLUT( TComPic * pCurPic , UInt refLayerIdc )
+{
+  xxCollectData( pCurPic , refLayerIdc );
+
+  Double dErrorLuma = 0 , dErrorChroma = 0;
+  Int nYSize = 1 << ( getCurOctantDepth() + getCurYPartNumLog2() );
+  Int nUVSize = 1 << getCurOctantDepth();
+  for( Int yIdx = 0 ; yIdx < nYSize ; yIdx++ )
+  {
+    for( Int uIdx = 0 ; uIdx < nUVSize ; uIdx++ )
+    {
+      for( Int vIdx = 0 ; vIdx < nUVSize ; vIdx++ )
+      {
+        SColorInfo & rCuboidColorInfo = m_pColorInfo[yIdx][uIdx][vIdx];
+        SColorInfo & rCuboidColorInfoC = m_pColorInfoC[yIdx][uIdx][vIdx];
+        SCuboid & rCuboid = xGetCuboid( yIdx , uIdx , vIdx );
+        if( rCuboidColorInfo.N > 0 )
+        {
+          dErrorLuma += xxCalEstDist( rCuboidColorInfo.N , rCuboidColorInfo.Ys , rCuboidColorInfo.Yy , rCuboidColorInfo.Yu , rCuboidColorInfo.Yv , rCuboidColorInfo.ys , rCuboidColorInfo.us , rCuboidColorInfo.vs , rCuboidColorInfo.yy , rCuboidColorInfo.yu , rCuboidColorInfo.yv , rCuboidColorInfo.uu , rCuboidColorInfo.uv , rCuboidColorInfo.vv , rCuboidColorInfo.YY ,
+            rCuboid.P[0].Y , rCuboid.P[1].Y , rCuboid.P[2].Y , rCuboid.P[3].Y );
+        }
+        if( rCuboidColorInfoC.N > 0 )
+        {
+          dErrorChroma += xxCalEstDist( rCuboidColorInfoC.N , rCuboidColorInfoC.Us , rCuboidColorInfoC.Uy , rCuboidColorInfoC.Uu , rCuboidColorInfoC.Uv , rCuboidColorInfoC.ys , rCuboidColorInfoC.us , rCuboidColorInfoC.vs , rCuboidColorInfoC.yy , rCuboidColorInfoC.yu , rCuboidColorInfoC.yv , rCuboidColorInfoC.uu , rCuboidColorInfoC.uv , rCuboidColorInfoC.vv , rCuboidColorInfoC.UU ,
+            rCuboid.P[0].U , rCuboid.P[1].U , rCuboid.P[2].U , rCuboid.P[3].U );
+          dErrorChroma += xxCalEstDist( rCuboidColorInfoC.N , rCuboidColorInfoC.Vs , rCuboidColorInfoC.Vy , rCuboidColorInfoC.Vu , rCuboidColorInfoC.Vv , rCuboidColorInfoC.ys , rCuboidColorInfoC.us , rCuboidColorInfoC.vs , rCuboidColorInfoC.yy , rCuboidColorInfoC.yu , rCuboidColorInfoC.yv , rCuboidColorInfoC.uu , rCuboidColorInfoC.uv , rCuboidColorInfoC.vv , rCuboidColorInfoC.VV ,
+            rCuboid.P[0].V , rCuboid.P[1].V , rCuboid.P[2].V , rCuboid.P[3].V );
+        }
+      }
+    }
+  }
+
+  return( dErrorLuma + dErrorChroma);
+}
+#else
 Double TEnc3DAsymLUT::estimateDistWithCur3DAsymLUT( TComPic * pCurPic , UInt refLayerIdc )
 {
@@ -174 +328 @@
   return( dErrorLuma + dErrorChroma);
 }
-
+#endif
+
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+#if R0179_ENC_OPT_3DLUT_SIZE
+Double TEnc3DAsymLUT::derive3DAsymLUT( TComSlice * pSlice , TComPic * pCurPic , UInt refLayerIdc , TEncCfg * pCfg , Bool bSignalPPS , Bool bElRapSliceTypeB, Double dFrameLambda )
+{
+  m_nLUTBitDepth = pCfg->getCGSLUTBit();
+
+  Int nBestAdaptCThresholdU = 1 << ( getInputBitDepthC() - 1 );
+  Int nBestAdaptCThresholdV = 1 << ( getInputBitDepthC() - 1 );
+  Int nAdaptCThresholdU, nAdaptCThresholdV;
+
+  Int nTmpLutBits[MAX_Y_SIZE][MAX_C_SIZE] ;
+  memset(nTmpLutBits, 0, sizeof(nTmpLutBits)); 
+
+  SLUTSize sMaxLutSize;  
+
+  // collect stats for the most partitions 
+  Int nCurYPartNumLog2 = 0 , nCurOctantDepth = 0; 
+  Int nMaxPartNumLog2 = xGetMaxPartNumLog2();
+
+  xxMapPartNum2DepthYPart( nMaxPartNumLog2 , nCurOctantDepth , nCurYPartNumLog2 ); 
+  xUpdatePartitioning( nCurOctantDepth , nCurYPartNumLog2, nBestAdaptCThresholdU, nBestAdaptCThresholdV ); 
+  xxCollectData( pCurPic , refLayerIdc );
+  xxCopyColorInfo(m_pMaxColorInfo, m_pColorInfo, m_pMaxColorInfoC, m_pColorInfoC); 
+ 
+  sMaxLutSize.iCPartNumLog2 = nCurOctantDepth; 
+  sMaxLutSize.iYPartNumLog2 = nCurOctantDepth + nCurYPartNumLog2; 
+
+  m_pBitstreamRedirect->clear();
+
+  // find the best partition based on RD cost 
+  Int i; 
+  Double dMinCost, dCurCost;
+
+  Int iBestLUTSizeIdx = 0;   
+  Int nBestResQuanBit = 0;
+  Double dCurError, dMinError; 
+  Int iNumBitsCurSize; 
+  Int iNumBitsCurSizeSave = m_pEncCavlc->getNumberOfWrittenBits(); 
+  Double dDistFactor = getDistFactor(pSlice->getSliceType(), pSlice->getDepth());
+
+  // check all LUT sizes 
+  xxGetAllLutSizes(pSlice);  
+  if (m_nTotalLutSizes == 0) // return if no valid size is found, LUT will not be updated
+  {
+    nCurOctantDepth = sMaxLutSize.iCPartNumLog2;
+    nCurYPartNumLog2 = sMaxLutSize.iYPartNumLog2-nCurOctantDepth; 
+    xUpdatePartitioning( nCurOctantDepth , nCurYPartNumLog2, nBestAdaptCThresholdU, nBestAdaptCThresholdV ); 
+    return MAX_DOUBLE; 
+  }
+
+  dMinCost = MAX_DOUBLE; dMinError = MAX_DOUBLE;
+  for (i = 0; i < m_nTotalLutSizes; i++)
+  {
+    // add up the stats
+    nCurOctantDepth = m_sLutSizes[i].iCPartNumLog2;
+    nCurYPartNumLog2 = m_sLutSizes[i].iYPartNumLog2-nCurOctantDepth; 
+    xUpdatePartitioning( nCurOctantDepth , nCurYPartNumLog2, nBestAdaptCThresholdU, nBestAdaptCThresholdV ); 
+    xxConsolidateData( &m_sLutSizes[i], &sMaxLutSize );
+  
+    dCurError = xxDeriveVertexes(nBestResQuanBit, m_pEncCuboid);
+
+    setResQuantBit( nBestResQuanBit );
+    xSaveCuboids( m_pEncCuboid ); 
+    m_pEncCavlc->xCode3DAsymLUT( this ); 
+    iNumBitsCurSize = m_pEncCavlc->getNumberOfWrittenBits();
+    dCurCost = dCurError/dDistFactor + dFrameLambda*(Double)(iNumBitsCurSize-iNumBitsCurSizeSave);  
+    nTmpLutBits[m_sLutSizes[i].iYPartNumLog2][m_sLutSizes[i].iCPartNumLog2] = iNumBitsCurSize-iNumBitsCurSizeSave; // store LUT size 
+    iNumBitsCurSizeSave = iNumBitsCurSize;
+    if(dCurCost < dMinCost )
+    {
+      SCuboid *** tmp = m_pBestEncCuboid;
+      m_pBestEncCuboid = m_pEncCuboid;
+      m_pEncCuboid = tmp;
+      dMinCost = dCurCost; 
+      dMinError = dCurError;
+      iBestLUTSizeIdx = i; 
+    }
+  }
+
+  nCurOctantDepth = m_sLutSizes[iBestLUTSizeIdx].iCPartNumLog2;
+  nCurYPartNumLog2 = m_sLutSizes[iBestLUTSizeIdx].iYPartNumLog2-nCurOctantDepth; 
+
+  xUpdatePartitioning( nCurOctantDepth , nCurYPartNumLog2, nBestAdaptCThresholdU, nBestAdaptCThresholdV ); 
+
+  Bool bUseNewColorInfo = false; 
+  if( pCfg->getCGSAdaptChroma() && nCurOctantDepth <= 1 ) // if the best size found so far has depth = 0 or 1, then check AdaptC U/V thresholds
+  {
+    nAdaptCThresholdU = ( Int )( m_dSumU / m_nNChroma + 0.5 );
+    nAdaptCThresholdV = ( Int )( m_dSumV / m_nNChroma + 0.5 );
+    if( !(nAdaptCThresholdU == nBestAdaptCThresholdU && nAdaptCThresholdV == nBestAdaptCThresholdV ) ) 
+    {
+      nCurOctantDepth = 1;
+      if( nCurOctantDepth + nCurYPartNumLog2 > getMaxYPartNumLog2()+getMaxOctantDepth() )
+        nCurYPartNumLog2 = getMaxYPartNumLog2()+getMaxOctantDepth()-nCurOctantDepth; 
+      xUpdatePartitioning( nCurOctantDepth , nCurYPartNumLog2 , nAdaptCThresholdU , nAdaptCThresholdV );
+      xxCollectData( pCurPic , refLayerIdc );
+
+      dCurError = xxDeriveVertexes( nBestResQuanBit , m_pEncCuboid ) ;
+      setResQuantBit( nBestResQuanBit );
+      xSaveCuboids( m_pEncCuboid ); 
+      m_pEncCavlc->xCode3DAsymLUT( this ); 
+      iNumBitsCurSize = m_pEncCavlc->getNumberOfWrittenBits();
+      dCurCost = dCurError/dDistFactor + dFrameLambda*(Double)(iNumBitsCurSize-iNumBitsCurSizeSave);  
+      iNumBitsCurSizeSave = iNumBitsCurSize;
+      if(dCurCost < dMinCost )
+      {
+        SCuboid *** tmp = m_pBestEncCuboid;
+        m_pBestEncCuboid = m_pEncCuboid;
+        m_pEncCuboid = tmp;
+        dMinCost = dCurCost; 
+        dMinError = dCurError;
+        nBestAdaptCThresholdU = nAdaptCThresholdU;
+        nBestAdaptCThresholdV = nAdaptCThresholdV;
+        bUseNewColorInfo = true; 
+      }
+    }
+  }
+
+  xUpdatePartitioning( nCurOctantDepth , nCurYPartNumLog2, nBestAdaptCThresholdU, nBestAdaptCThresholdV ); 
+
+  // check res_quant_bits only for the best table size and best U/V threshold
+  if( !bUseNewColorInfo ) 
+    xxConsolidateData( &m_sLutSizes[iBestLUTSizeIdx], &sMaxLutSize );
+
+  //    xxCollectData( pCurPic , refLayerIdc );
+  for( Int nResQuanBit = 1 ; nResQuanBit < 4 ; nResQuanBit++ )
+  {
+    dCurError = xxDeriveVertexes( nResQuanBit , m_pEncCuboid );
+
+    setResQuantBit( nResQuanBit );
+    xSaveCuboids( m_pEncCuboid ); 
+    m_pEncCavlc->xCode3DAsymLUT( this ); 
+    iNumBitsCurSize = m_pEncCavlc->getNumberOfWrittenBits();
+    dCurCost = dCurError/dDistFactor + dFrameLambda*(Double)(iNumBitsCurSize-iNumBitsCurSizeSave);   
+
+    iNumBitsCurSizeSave = iNumBitsCurSize;
+    if(dCurCost < dMinCost)
+    {
+      nBestResQuanBit = nResQuanBit;
+      SCuboid *** tmp = m_pBestEncCuboid;
+      m_pBestEncCuboid = m_pEncCuboid;
+      m_pEncCuboid = tmp;
+      dMinCost = dCurCost; 
+      dMinError = dCurError;
+    }
+    else
+    {
+      break;
+    }
+  }
+    
+  setResQuantBit( nBestResQuanBit );
+  xSaveCuboids( m_pBestEncCuboid );
+
+  // update LUT size stats 
+  for(Int iLutSizeY = 0; iLutSizeY < MAX_Y_SIZE; iLutSizeY++)
+  {
+    for(Int iLutSizeC = 0; iLutSizeC < MAX_C_SIZE; iLutSizeC++) 
+    {
+      if(nTmpLutBits[iLutSizeY][iLutSizeC] != 0) 
+        m_nNumLUTBits[iLutSizeY][iLutSizeC] =  (m_nNumLUTBits[iLutSizeY][iLutSizeC] + nTmpLutBits[iLutSizeY][iLutSizeC]*3+2)>>2; // update with new stats
+    }
+  }
+
+  // return cost rather than error
+  return( dMinCost );
+}
+#endif 
+
+
+Double TEnc3DAsymLUT::derive3DAsymLUT( TComSlice * pSlice , TComPic * pCurPic , UInt refLayerIdc , TEncCfg * pCfg , Bool bSignalPPS , Bool bElRapSliceTypeB )
+{
+  m_nLUTBitDepth = pCfg->getCGSLUTBit();
+  Int nCurYPartNumLog2 = 0 , nCurOctantDepth = 0; 
+  xxDerivePartNumLog2( pSlice , pCfg , nCurOctantDepth , nCurYPartNumLog2 , bSignalPPS , bElRapSliceTypeB );
+
+  Int nBestResQuanBit = 0;
+  Int nBestAdaptCThresholdU = 1 << ( getInputBitDepthC() - 1 );
+  Int nBestAdaptCThresholdV = 1 << ( getInputBitDepthC() - 1 );
+  Int nBestOctantDepth = nCurOctantDepth;
+  Int nBestYPartNumLog2 = nCurYPartNumLog2;
+  Int nTargetLoop = 1 + ( pCfg->getCGSAdaptChroma() && ( nCurOctantDepth == 1 || ( nCurOctantDepth * 3 + nCurYPartNumLog2 ) >= 5 ) );
+  Double dMinError = MAX_DOUBLE;
+  for( Int nLoop = 0 ; nLoop < nTargetLoop ; nLoop++ )
+  {
+    Int nAdaptCThresholdU = 1 << ( getInputBitDepthC() - 1 );
+    Int nAdaptCThresholdV = 1 << ( getInputBitDepthC() - 1 );
+    if( nLoop > 0 )
+    {
+      nAdaptCThresholdU = ( Int )( m_dSumU / m_nNChroma + 0.5 );
+      nAdaptCThresholdV = ( Int )( m_dSumV / m_nNChroma + 0.5 );
+      if( nCurOctantDepth > 1 )
+      {
+        nCurOctantDepth = 1;
+        nCurYPartNumLog2 = 2;
+      }
+      if( nAdaptCThresholdU == nBestAdaptCThresholdU && nAdaptCThresholdV == nBestAdaptCThresholdV 
+        && nCurOctantDepth == nBestOctantDepth && nCurYPartNumLog2 == nBestYPartNumLog2 )
+        break;
+    }
+
+    xUpdatePartitioning( nCurOctantDepth , nCurYPartNumLog2 , nAdaptCThresholdU , nAdaptCThresholdV );
+    xxCollectData( pCurPic , refLayerIdc );
+    for( Int nResQuanBit = 0 ; nResQuanBit < 4 ; nResQuanBit++ )
+    {
+      Double dError = xxDeriveVertexes( nResQuanBit , m_pEncCuboid ) / ( 1 + ( nResQuanBit > 0 ) * 0.001 * ( pSlice->getDepth() + 1 ) );
+      if( dError <= dMinError )
+      {
+        nBestResQuanBit = nResQuanBit;
+        nBestAdaptCThresholdU = nAdaptCThresholdU;
+        nBestAdaptCThresholdV = nAdaptCThresholdV;
+        nBestOctantDepth = nCurOctantDepth;
+        nBestYPartNumLog2 = nCurYPartNumLog2;
+        SCuboid *** tmp = m_pBestEncCuboid;
+        m_pBestEncCuboid = m_pEncCuboid;
+        m_pEncCuboid = tmp;
+        dMinError = dError;
+      }
+      else
+      {
+        break;
+      }
+    }
+  }
+
+  setResQuantBit( nBestResQuanBit );
+  xUpdatePartitioning( nBestOctantDepth , nBestYPartNumLog2 , nBestAdaptCThresholdU , nBestAdaptCThresholdV );
+
+  xSaveCuboids( m_pBestEncCuboid );
+  return( dMinError );
+}
+#else
 Double TEnc3DAsymLUT::derive3DAsymLUT( TComSlice * pSlice , TComPic * pCurPic , UInt refLayerIdc , TEncCfg * pCfg , Bool bSignalPPS , Bool bElRapSliceTypeB )
 {
@@ -204 +591 @@
   setResQuantBit( nBestResQuanBit );
   xSaveCuboids( m_pBestEncCuboid );
-
   return( dCurError );
 }
+#endif
 
 Double TEnc3DAsymLUT::xxDeriveVertexes( Int nResQuanBit , SCuboid *** pCurCuboid )
@@ -213 +600 @@
   Int nYSize = 1 << ( getCurOctantDepth() + getCurYPartNumLog2() );
   Int nUVSize = 1 << getCurOctantDepth();
+#if !R0151_CGS_3D_ASYMLUT_IMPROVE
   Int nLengthY = 1 << ( getInputBitDepthY() - getCurOctantDepth() - getCurYPartNumLog2() );
   Int nLengthUV = 1 << ( getInputBitDepthC() - getCurOctantDepth() );
+#endif
   for( Int yIdx = 0 ; yIdx < nYSize ; yIdx++ )
   {
@@ -224 +613 @@
         SColorInfo & rCuboidColorInfoC = m_pColorInfoC[yIdx][uIdx][vIdx];
         SCuboid & rCuboid = pCurCuboid[yIdx][uIdx][vIdx];
+#if !R0151_CGS_3D_ASYMLUT_IMPROVE
         Int y0 = yIdx << xGetYShift2Idx();
         Int u0 = uIdx << xGetUShift2Idx();
         Int v0 = vIdx << xGetVShift2Idx();
+#endif
         for( Int idxVertex = 0 ; idxVertex < 4 ; idxVertex++ )
         {
@@ -235 +626 @@
         {
           dErrorLuma += xxDeriveVertexPerColor( rCuboidColorInfo.N , rCuboidColorInfo.Ys , rCuboidColorInfo.Yy , rCuboidColorInfo.Yu , rCuboidColorInfo.Yv , rCuboidColorInfo.ys , rCuboidColorInfo.us , rCuboidColorInfo.vs , rCuboidColorInfo.yy , rCuboidColorInfo.yu , rCuboidColorInfo.yv , rCuboidColorInfo.uu , rCuboidColorInfo.uv , rCuboidColorInfo.vv , rCuboidColorInfo.YY ,
-            y0 , u0 , v0 , nLengthY , nLengthUV , rCuboid.P[0].Y , rCuboid.P[1].Y , rCuboid.P[2].Y , rCuboid.P[3].Y , nResQuanBit );
+#if !R0151_CGS_3D_ASYMLUT_IMPROVE
+            y0 , u0 , v0 , nLengthY , nLengthUV , 
+#endif
+            rCuboid.P[0].Y , rCuboid.P[1].Y , rCuboid.P[2].Y , rCuboid.P[3].Y , nResQuanBit );
         }
         if( rCuboidColorInfoC.N > 0 )
         {
           dErrorChroma += xxDeriveVertexPerColor( rCuboidColorInfoC.N , rCuboidColorInfoC.Us , rCuboidColorInfoC.Uy , rCuboidColorInfoC.Uu , rCuboidColorInfoC.Uv , rCuboidColorInfoC.ys , rCuboidColorInfoC.us , rCuboidColorInfoC.vs , rCuboidColorInfoC.yy , rCuboidColorInfoC.yu , rCuboidColorInfoC.yv , rCuboidColorInfoC.uu , rCuboidColorInfoC.uv , rCuboidColorInfoC.vv , rCuboidColorInfoC.UU ,
-            y0 , u0 , v0 , nLengthY , nLengthUV , rCuboid.P[0].U , rCuboid.P[1].U , rCuboid.P[2].U , rCuboid.P[3].U , nResQuanBit );
+#if !R0151_CGS_3D_ASYMLUT_IMPROVE
+            y0 , u0 , v0 , nLengthY , nLengthUV , 
+#endif
+            rCuboid.P[0].U , rCuboid.P[1].U , rCuboid.P[2].U , rCuboid.P[3].U , nResQuanBit );
           dErrorChroma += xxDeriveVertexPerColor( rCuboidColorInfoC.N , rCuboidColorInfoC.Vs , rCuboidColorInfoC.Vy , rCuboidColorInfoC.Vu , rCuboidColorInfoC.Vv , rCuboidColorInfoC.ys , rCuboidColorInfoC.us , rCuboidColorInfoC.vs , rCuboidColorInfoC.yy , rCuboidColorInfoC.yu , rCuboidColorInfoC.yv , rCuboidColorInfoC.uu , rCuboidColorInfoC.uv , rCuboidColorInfoC.vv , rCuboidColorInfoC.VV ,
-            y0 , u0 , v0 , nLengthY , nLengthUV , rCuboid.P[0].V , rCuboid.P[1].V , rCuboid.P[2].V , rCuboid.P[3].V , nResQuanBit );
+#if !R0151_CGS_3D_ASYMLUT_IMPROVE
+            y0 , u0 , v0 , nLengthY , nLengthUV , 
+#endif
+            rCuboid.P[0].V , rCuboid.P[1].V , rCuboid.P[2].V , rCuboid.P[3].V , nResQuanBit );
         }
 
@@ -276 +676 @@
   Int nStrideILRY = pRecPic->getStride();
   Int nStrideILRC = pRecPic->getCStride();
+#if R0179_ENC_OPT_3DLUT_SIZE
+  xReset3DArray( m_pColorInfo  , getMaxYSize() , getMaxCSize() , getMaxCSize() );
+  xReset3DArray( m_pColorInfoC , getMaxYSize() , getMaxCSize() , getMaxCSize() );
+#else
   xReset3DArray( m_pColorInfo , xGetYSize() , xGetUSize() , xGetVSize() );
   xReset3DArray( m_pColorInfoC , xGetYSize() , xGetUSize() , xGetVSize() );
+#endif
 
   //alignment padding
@@ -285 +690 @@
   TComSlice * pSlice = pCurPic->getSlice(pCurPic->getCurrSliceIdx());
   UInt refLayerId = pSlice->getVPS()->getRefLayerId(pSlice->getLayerId(), refLayerIdc);
+#if MOVE_SCALED_OFFSET_TO_PPS
+  const Window &scalEL = pSlice->getPPS()->getScaledRefLayerWindowForLayer(refLayerId); 
+#else
   const Window &scalEL = pSlice->getSPS()->getScaledRefLayerWindowForLayer(refLayerId); 
+#endif
   TComPicYuv *pcRecPicBL = pSlice->getBaseColPic(refLayerIdc)->getPicYuvRec();
   // borders of down-sampled picture
@@ -299 +708 @@
   // since we do data collection only for overlapped region, the border extension is good enough
 
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  m_dSumU = m_dSumV = 0;
+  m_nNChroma = 0;
+#endif
   for( Int i = top ; i <= bottom ; i++ )
   {
@@ -330 +743 @@
       }
 
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+      m_dSumU += u;
+      m_dSumV += v;
+      m_nNChroma++;
+#endif
       SColorInfo sColorInfo;
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+      SColorInfo & rCuboidColorInfo = m_pColorInfo[xGetYIdx(y)][xGetUIdx(u)][xGetVIdx(v)];
+#else
       SColorInfo & rCuboidColorInfo = m_pColorInfo[y>>xGetYShift2Idx()][u>>xGetUShift2Idx()][v>>xGetVShift2Idx()];
+#endif
       memset(&sColorInfo, 0, sizeof(SColorInfo));
       sColorInfo.Ys = Y;
@@ -358 +780 @@
         u = pIRLU[posIRLUV];
         v = pIRLV[posIRLUV];
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+        SColorInfo & rCuboidColorInfoC = m_pColorInfoC[xGetYIdx(y)][xGetUIdx(u)][xGetVIdx(v)];
+#else
         SColorInfo & rCuboidColorInfoC = m_pColorInfoC[y>>xGetYShift2Idx()][u>>xGetUShift2Idx()][v>>xGetVShift2Idx()];
+#endif
         sColorInfo.Us = U;
         sColorInfo.Vs = V;
@@ -389 +815 @@
 Void TEnc3DAsymLUT::xxDerivePartNumLog2( TComSlice * pSlice , TEncCfg * pcCfg , Int & rOctantDepth , Int & rYPartNumLog2 , Bool bSignalPPS , Bool bElRapSliceTypeB )
 {
+#if !R0151_CGS_3D_ASYMLUT_IMPROVE
   Int nSliceType = pSlice->getSliceType();
   // update slice type as what will be done later
@@ -406 +833 @@
 
   const Int nSliceTempLevel = pSlice->getDepth();
+#endif
   Int nPartNumLog2 = 4;
   if( pSlice->getBaseColPic( pSlice->getInterLayerPredLayerIdc( 0 ) )->getSlice( 0 )->isIntra() )
@@ -411 +839 @@
     nPartNumLog2 = xGetMaxPartNumLog2();
   }
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  if( m_nAccuFrameBit && pSlice->getPPS()->getCGSFlag() ) 
+  {
+    Double dBitCost = 1.0 * m_nAccuFrameCGSBit / m_nAccuFrameBit;
+    nPartNumLog2 = m_nPrevFrameCGSPartNumLog2;
+#else
   if( m_nPrevFrameBit[nSliceType][nSliceTempLevel] && pSlice->getPPS()->getCGSFlag() ) 
   {
     Double dBitCost = 1.0 * m_nPrevFrameCGSBit[nSliceType][nSliceTempLevel] / m_nPrevFrameBit[nSliceType][nSliceTempLevel];
     nPartNumLog2 = m_nPrevFrameCGSPartNumLog2[nSliceType][nSliceTempLevel];
+#endif
     Double dBitCostT = 0.03;
     if( dBitCost < dBitCostT / 6.0 )
@@ -425 +860 @@
     }
   }
+#if !R0151_CGS_3D_ASYMLUT_IMPROVE
   else
   {
     nPartNumLog2 -= nSliceTempLevel;
   }
-  nPartNumLog2 = Clip3( 0 , xGetMaxPartNumLog2() , nPartNumLog2 );
+#endif
+  nPartNumLog2 = Clip3( 0 , xGetMaxPartNumLog2()  , nPartNumLog2 );
   xxMapPartNum2DepthYPart( nPartNumLog2 , rOctantDepth , rYPartNumLog2 );
 }
@@ -453 +890 @@
 Void TEnc3DAsymLUT::updatePicCGSBits( TComSlice * pcSlice , Int nPPSBit )
 {
+#if !R0151_CGS_3D_ASYMLUT_IMPROVE
   const Int nSliceType = pcSlice->getSliceType();
   const Int nSliceTempLevel = pcSlice->getDepth();
-
+#endif
   for( Int i = 0; i < pcSlice->getActiveNumILRRefIdx(); i++ )
   {
     UInt refLayerIdc = pcSlice->getInterLayerPredLayerIdc(i);
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+    m_nAccuFrameBit += pcSlice->getPic()->getFrameBit() + pcSlice->getBaseColPic(refLayerIdc)->getFrameBit();
+#else
     m_nPrevFrameBit[nSliceType][nSliceTempLevel] = pcSlice->getPic()->getFrameBit() + pcSlice->getBaseColPic(refLayerIdc)->getFrameBit();
+#endif
     m_dTotalFrameBit += pcSlice->getPic()->getFrameBit() + pcSlice->getBaseColPic(refLayerIdc)->getFrameBit();
   }
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  m_nAccuFrameCGSBit += nPPSBit;
+  m_nTotalCGSBit += nPPSBit;
+  m_nPrevFrameCGSPartNumLog2 = getCurOctantDepth() * 3 + getCurYPartNumLog2();
+#else
   m_nPrevFrameOverWritePPS[nSliceType][nSliceTempLevel] = pcSlice->getCGSOverWritePPS();
   m_nPrevFrameCGSBit[nSliceType][nSliceTempLevel] = nPPSBit;
   m_nTotalCGSBit += nPPSBit;
   m_nPrevFrameCGSPartNumLog2[nSliceType][nSliceTempLevel] = getCurOctantDepth() * 3 + getCurYPartNumLog2();
-}
-
-#endif
+#endif
+#if R0179_ENC_OPT_3DLUT_SIZE
+  Int nCurELFrameBit = pcSlice->getPic()->getFrameBit();
+  const Int nSliceType = pcSlice->getSliceType();
+  const Int nSliceTempLevel = pcSlice->getDepth();
+  m_nPrevELFrameBit[nSliceType][nSliceTempLevel] = m_nPrevELFrameBit[nSliceType][nSliceTempLevel] == 0 ? nCurELFrameBit:((m_nPrevELFrameBit[nSliceType][nSliceTempLevel]+nCurELFrameBit)>>1);
+#endif 
+}
+
+#if R0179_ENC_OPT_3DLUT_SIZE
+
+Void TEnc3DAsymLUT::xxGetAllLutSizes(TComSlice *pSlice)
+{
+  Int iMaxYPartNumLog2, iMaxCPartNumLog2; 
+  Int iCurYPartNumLog2, iCurCPartNumLog2; 
+  Int iMaxAddYPartNumLog2; 
+  Int iNumELFrameBits = m_nPrevELFrameBit[pSlice->getSliceType()][pSlice->getDepth()];
+
+  xxMapPartNum2DepthYPart( xGetMaxPartNumLog2() , iMaxCPartNumLog2 , iMaxYPartNumLog2 );
+  iMaxAddYPartNumLog2 = iMaxYPartNumLog2; 
+  iMaxYPartNumLog2 += iMaxCPartNumLog2; 
+
+  //m_sLutSizes[0].iYPartNumLog2 = iMaxYPartNumLog2; 
+  //m_sLutSizes[0].iCPartNumLog2 = iMaxCPartNumLog2; 
+  m_nTotalLutSizes = 0; 
+
+
+  for(iCurYPartNumLog2 = iMaxYPartNumLog2; iCurYPartNumLog2 >= 0; iCurYPartNumLog2--) 
+  {
+    for(iCurCPartNumLog2 = iMaxCPartNumLog2; iCurCPartNumLog2 >= 0; iCurCPartNumLog2--) 
+    {
+       // try more sizes
+      if(iCurCPartNumLog2 <= iCurYPartNumLog2  && 
+         (m_nNumLUTBits[iCurYPartNumLog2][iCurCPartNumLog2] < (iNumELFrameBits>>1)) && 
+         m_nTotalLutSizes < MAX_NUM_LUT_SIZES)
+      {
+        m_sLutSizes[m_nTotalLutSizes].iYPartNumLog2 = iCurYPartNumLog2; 
+        m_sLutSizes[m_nTotalLutSizes].iCPartNumLog2 = iCurCPartNumLog2; 
+        m_nTotalLutSizes ++; 
+      }
+    }
+  }
+
+}
+
+Void TEnc3DAsymLUT::xxCopyColorInfo( SColorInfo *** dst, SColorInfo *** src ,  SColorInfo *** dstC, SColorInfo *** srcC )
+{
+  Int yIdx, uIdx, vIdx; 
+
+  // copy from pColorInfo to pMaxColorInfo
+  for(yIdx = 0; yIdx < xGetYSize(); yIdx++)
+  {
+    for(uIdx = 0; uIdx < xGetUSize(); uIdx++)
+    {
+      for(vIdx = 0; vIdx < xGetVSize(); vIdx++)
+      {
+        dst [yIdx][uIdx][vIdx] = src [yIdx][uIdx][vIdx];
+        dstC[yIdx][uIdx][vIdx] = srcC[yIdx][uIdx][vIdx];
+      }
+    }
+  }
+}
+
+Void TEnc3DAsymLUT::xxAddColorInfo( Int yIdx, Int uIdx, Int vIdx, Int iYDiffLog2, Int iCDiffLog2 )
+{
+  SColorInfo & rCuboidColorInfo  = m_pColorInfo [yIdx][uIdx][vIdx];
+  SColorInfo & rCuboidColorInfoC = m_pColorInfoC[yIdx][uIdx][vIdx];
+  
+  for( Int i = 0; i < (1<<iYDiffLog2); i++)
+  {
+    for (Int j = 0; j < (1<<iCDiffLog2); j++)
+    {
+      for(Int k = 0; k < (1<<iCDiffLog2); k++)
+      {
+        rCuboidColorInfo  += m_pMaxColorInfo [(yIdx<<iYDiffLog2)+i][(uIdx<<iCDiffLog2)+j][(vIdx<<iCDiffLog2)+k];
+        rCuboidColorInfoC += m_pMaxColorInfoC[(yIdx<<iYDiffLog2)+i][(uIdx<<iCDiffLog2)+j][(vIdx<<iCDiffLog2)+k];
+      }
+    }
+  }
+}
+
+Void TEnc3DAsymLUT::xxConsolidateData( SLUTSize *pCurLUTSize, SLUTSize *pMaxLUTSize )
+{
+  Int yIdx, uIdx, vIdx; 
+  Int iYDiffLog2, iCDiffLog2;
+  Int nYSize = 1<< pMaxLUTSize->iYPartNumLog2;
+  Int nCSize = 1<< pMaxLUTSize->iCPartNumLog2;
+
+  iYDiffLog2 = pMaxLUTSize->iYPartNumLog2-pCurLUTSize->iYPartNumLog2;
+  iCDiffLog2 = pMaxLUTSize->iCPartNumLog2-pCurLUTSize->iCPartNumLog2;
+
+  //assert(pMaxLUTSize->iCPartNumLog2 >= pCurLUTSize->iCPartNumLog2 && pMaxLUTSize->iYPartNumLog2 >= pCurLUTSize->iYPartNumLog2); 
+  if (iYDiffLog2 == 0 && iCDiffLog2 == 0) // shouldn't have to do anything 
+  {
+    xxCopyColorInfo(m_pColorInfo, m_pMaxColorInfo, m_pColorInfoC, m_pMaxColorInfoC);
+    return; 
+  }
+
+  xReset3DArray( m_pColorInfo  ,  1<<pMaxLUTSize->iYPartNumLog2, 1<<pMaxLUTSize->iCPartNumLog2, 1<<pMaxLUTSize->iCPartNumLog2 );
+  xReset3DArray( m_pColorInfoC ,  1<<pMaxLUTSize->iYPartNumLog2, 1<<pMaxLUTSize->iCPartNumLog2, 1<<pMaxLUTSize->iCPartNumLog2 );
+
+  for(yIdx = 0; yIdx < nYSize; yIdx++)
+  {
+    for(uIdx = 0; uIdx < nCSize; uIdx++)
+    {
+      for(vIdx = 0; vIdx < nCSize; vIdx++)
+      {
+        const SColorInfo & rCuboidSrc   = m_pMaxColorInfo [yIdx][uIdx][vIdx];
+        const SColorInfo & rCuboidSrcC  = m_pMaxColorInfoC[yIdx][uIdx][vIdx];
+        
+        Int yIdx2, uIdx2, vIdx2; 
+        yIdx2 = yIdx>>iYDiffLog2; 
+        uIdx2 = uIdx>>iCDiffLog2;
+        vIdx2 = vIdx>>iCDiffLog2; 
+
+        m_pColorInfo [yIdx2][uIdx2][vIdx2] += rCuboidSrc;
+        m_pColorInfoC[yIdx2][uIdx2][vIdx2] += rCuboidSrcC;
+      }
+    }
+  }
+}
+
+Void TEnc3DAsymLUT::update3DAsymLUTParam( TEnc3DAsymLUT * pSrc )
+{
+  assert( pSrc->getMaxOctantDepth() == getMaxOctantDepth() && pSrc->getMaxYPartNumLog2() == getMaxYPartNumLog2() );
+  xUpdatePartitioning( pSrc->getCurOctantDepth() , pSrc->getCurYPartNumLog2() 
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+    , pSrc->getAdaptChromaThresholdU() , pSrc->getAdaptChromaThresholdV()
+#endif
+    );
+  setResQuantBit( pSrc->getResQuantBit() );
+}
+
+#endif 
+#endif

trunk/source/Lib/TLibEncoder/TEnc3DAsymLUT.h

@@ -8 +8 @@
 #include "../TLibCommon/TComPic.h"
 #include "TEncCfg.h"
+#if R0179_ENC_OPT_3DLUT_SIZE
+#include "TEncCavlc.h"
+#define MAX_NUM_LUT_SIZES               10   // 4+3+2+1
+#define MAX_Y_SIZE                       4
+#define MAX_C_SIZE                       4
+#endif
 
 #if Q0048_CGS_3D_ASYMLUT
@@ -55 +61 @@
 }SColorInfo;
 
+#if R0179_ENC_OPT_3DLUT_SIZE
+typedef struct _LUTSize 
+{
+  Int iYPartNumLog2; 
+  Int iCPartNumLog2; 
+} SLUTSize; 
+#endif 
 
 class TEnc3DAsymLUT : public TCom3DAsymLUT
@@ -66 +79 @@
   Double derive3DAsymLUT( TComSlice * pSlice , TComPic * pCurPic , UInt refLayerIdc , TEncCfg * pCfg , Bool bSignalPPS , Bool bElRapSliceTypeB );
   Double estimateDistWithCur3DAsymLUT( TComPic * pCurPic , UInt refLayerIdc );
+#if R0179_ENC_OPT_3DLUT_SIZE
+  Double getDistFactor( Int iSliceType, Int iLayer) { return m_dDistFactor[iSliceType][iLayer];}
+  Double derive3DAsymLUT( TComSlice * pSlice , TComPic * pCurPic , UInt refLayerIdc , TEncCfg * pCfg , Bool bSignalPPS , Bool bElRapSliceTypeB, Double dFrameLambda );
+  Void   update3DAsymLUTParam( TEnc3DAsymLUT * pSrc );
+#endif
 
   Void  updatePicCGSBits( TComSlice * pcSlice , Int nPPSBit );
@@ -75 +93 @@
   SColorInfo *** m_pColorInfo;
   SColorInfo *** m_pColorInfoC;
+#if R0179_ENC_OPT_3DLUT_SIZE
+  SColorInfo *** m_pMaxColorInfo;
+  SColorInfo *** m_pMaxColorInfoC;
+#endif 
   TComPicYuv* m_pDsOrigPic;
   SCuboid *** m_pEncCuboid;
   SCuboid *** m_pBestEncCuboid;
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  Int   m_nAccuFrameBit;                  // base + enhancement layer
+  Int   m_nAccuFrameCGSBit;
+  Int   m_nPrevFrameCGSPartNumLog2;
+#else
   Int   m_nPrevFrameBit[3][MAX_TLAYER];                  // base + enhancement layer
   Int   m_nPrevFrameCGSBit[3][MAX_TLAYER];
   Int   m_nPrevFrameCGSPartNumLog2[3][MAX_TLAYER];
   Int   m_nPrevFrameOverWritePPS[3][MAX_TLAYER];
+#endif
   Double m_dTotalFrameBit;
   Int   m_nTotalCGSBit;
   Int   m_nPPSBit;
   Int   m_nLUTBitDepth;
+#if R0179_ENC_OPT_3DLUT_SIZE
+
+  Double m_dDistFactor[3][MAX_TLAYER];         
+  Int    m_nNumLUTBits[MAX_Y_SIZE][MAX_C_SIZE]; 
+  Int    m_nPrevELFrameBit[3][MAX_TLAYER];   
+
+
+  Int   m_nTotalLutSizes;
+  SLUTSize m_sLutSizes[MAX_NUM_LUT_SIZES];
+#endif 
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  Double m_dSumU;
+  Double m_dSumV;
+  Int    m_nNChroma;
+#endif
+#if R0179_ENC_OPT_3DLUT_SIZE
+  TComOutputBitstream  *m_pBitstreamRedirect;
+  TEncCavlc *m_pEncCavlc;
+#endif 
 
 private:
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  Double  xxDeriveVertexPerColor( Double N , Double Ys , Double Yy , Double Yu , Double Yv , Double ys , Double us , Double vs , Double yy , Double yu , Double yv , Double uu , Double uv , Double vv , Double YY ,
+    Pel & rP0 , Pel & rP1 , Pel & rP3 , Pel & rP7 , Int nResQuantBit );
+#else
   Double  xxDeriveVertexPerColor( Double N , Double Ys , Double Yy , Double Yu , Double Yv , Double ys , Double us , Double vs , Double yy , Double yu , Double yv , Double uu , Double uv , Double vv , Double YY ,
     Int y0 , Int u0 , Int v0 , Int nLengthY , Int nLengthUV ,
     Pel & rP0 , Pel & rP1 , Pel & rP3 , Pel & rP7 , Int nResQuantBit );
+#endif
   Void    xxDerivePartNumLog2( TComSlice * pSlice , TEncCfg * pcCfg , Int & rOctantDepth , Int & rYPartNumLog2 , Bool bSignalPPS , Bool bElRapSliceTypeB );
   Void    xxMapPartNum2DepthYPart( Int nPartNumLog2 , Int & rOctantDepth , Int & rYPartNumLog2 );
   Int     xxCoeff2Vertex( Double a , Double b , Double c , Double d , Int y , Int u , Int v ) { return ( ( Int )( a * y + b * u + c * v + d + 0.5 ) ); }
   Void    xxCollectData( TComPic * pCurPic , UInt refLayerIdc );
+
   Double  xxDeriveVertexes( Int nResQuantBit , SCuboid *** pCurCuboid );
   inline Double  xxCalEstDist( Double N , Double Ys , Double Yy , Double Yu , Double Yv , Double ys , Double us , Double vs , Double yy , Double yu , Double yv , Double uu , Double uv , Double vv , Double YY ,
@@ -100 +153 @@
   inline Double  xxCalEstDist( Double N , Double Ys , Double Yy , Double Yu , Double Yv , Double ys , Double us , Double vs , Double yy , Double yu , Double yv , Double uu , Double uv , Double vv , Double YY ,
     Double a , Double b , Double c , Double d );
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  inline Double  xxCalEstDist( Double N , Double Ys , Double Yy , Double Yu , Double Yv , Double ys , Double us , Double vs , Double yy , Double yu , Double yv , Double uu , Double uv , Double vv , Double YY ,
+    Pel nP0 , Pel nP1 , Pel nP3 , Pel nP7 );
+#endif
+#if R0179_ENC_OPT_3DLUT_SIZE
+  Void    xxConsolidateData( SLUTSize *pCurLUTSize, SLUTSize *pMaxLUTSize );
+  Void    xxGetAllLutSizes(TComSlice *pSlice);
+  Void    xxCopyColorInfo( SColorInfo *** dst, SColorInfo *** src ,  SColorInfo *** dstC, SColorInfo *** srcC ); 
+  Void    xxAddColorInfo( Int yIdx, Int uIdx, Int vIdx, Int iYDiffLog2, Int iCDiffLog2 );
+#endif 
 };
 
@@ -118 +181 @@
   return( dError );
 };
-#endif
-
-#endif
+
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+Double TEnc3DAsymLUT::xxCalEstDist( Double N , Double Ys , Double Yy , Double Yu , Double Yv , Double ys , Double us , Double vs , Double yy , Double yu , Double yv , Double uu , Double uv , Double vv , Double YY ,
+  Pel nP0 , Pel nP1 , Pel nP3 , Pel nP7 )
+{
+  const Int nOne = xGetNormCoeffOne();
+  Double a = 1.0 * nP0 / nOne;
+  Double b = 1.0 * nP1 / nOne;
+  Double c = 1.0 * nP3 / nOne;
+  Double d = nP7;
+  Double dError = N * d * d + 2 * b * c * uv + 2 * a * c * yv + 2 * a * b * yu - 2 * c * Yv - 2 * b * Yu - 2 * a * Yy + 2 * c * d * vs + 2 * b * d * us + 2 * a * d * ys + a * a * yy + c * c * vv + b * b * uu - 2 * d * Ys + YY;
+  return( dError );
+};
+#endif
+
+#endif
+
+#endif

trunk/source/Lib/TLibEncoder/TEncCavlc.cpp

@@ -193 +193 @@
   if( pcPPS->getTilesEnabledFlag() )
   {
-    WRITE_UVLC( pcPPS->getNumColumnsMinus1(),                                    "num_tile_columns_minus1" );
-    WRITE_UVLC( pcPPS->getNumRowsMinus1(),                                       "num_tile_rows_minus1" );
-    WRITE_FLAG( pcPPS->getUniformSpacingFlag(),                                  "uniform_spacing_flag" );
-    if( pcPPS->getUniformSpacingFlag() == 0 )
-    {
-      for(UInt i=0; i<pcPPS->getNumColumnsMinus1(); i++)
-      {
-        WRITE_UVLC( pcPPS->getColumnWidth(i)-1,                                  "column_width_minus1" );
-      }
-      for(UInt i=0; i<pcPPS->getNumRowsMinus1(); i++)
-      {
-        WRITE_UVLC( pcPPS->getRowHeight(i)-1,                                    "row_height_minus1" );
-      }
-    }
-    if(pcPPS->getNumColumnsMinus1() !=0 || pcPPS->getNumRowsMinus1() !=0)
+    WRITE_UVLC( pcPPS->getNumTileColumnsMinus1(),                                    "num_tile_columns_minus1" );
+    WRITE_UVLC( pcPPS->getTileNumRowsMinus1(),                                       "num_tile_rows_minus1" );
+    WRITE_FLAG( pcPPS->getTileUniformSpacingFlag(),                                  "uniform_spacing_flag" );
+    if( !pcPPS->getTileUniformSpacingFlag() )
+    {
+      for(UInt i=0; i<pcPPS->getNumTileColumnsMinus1(); i++)
+      {
+        WRITE_UVLC( pcPPS->getTileColumnWidth(i)-1,                                  "column_width_minus1" );
+      }
+      for(UInt i=0; i<pcPPS->getTileNumRowsMinus1(); i++)
+      {
+        WRITE_UVLC( pcPPS->getTileRowHeight(i)-1,                                    "row_height_minus1" );
+      }
+    }
+    if(pcPPS->getNumTileColumnsMinus1() !=0 || pcPPS->getTileNumRowsMinus1() !=0)
     {
       WRITE_FLAG( pcPPS->getLoopFilterAcrossTilesEnabledFlag()?1 : 0,          "loop_filter_across_tiles_enabled_flag");
@@ -225 +225 @@
   }
 
+#if !R0042_PROFILE_INDICATION
 #if SCALINGLIST_INFERRING
   if( pcPPS->getLayerId() > 0 )
@@ -241 +242 @@
   {
 #endif
+#endif
 
   WRITE_FLAG( pcPPS->getScalingListPresentFlag() ? 1 : 0,                          "pps_scaling_list_data_present_flag" ); 
@@ -247 +249 @@
     codeScalingList( m_pcSlice->getScalingList() );
   }
-
+#if !R0042_PROFILE_INDICATION
 #if SCALINGLIST_INFERRING
   }
+#endif
 #endif
 
@@ -256 +259 @@
   WRITE_FLAG( pcPPS->getSliceHeaderExtensionPresentFlag() ? 1 : 0, "slice_segment_header_extension_present_flag");
 #if P0166_MODIFIED_PPS_EXTENSION
+#if !R0042_PROFILE_INDICATION
   WRITE_FLAG( pcPPS->getExtensionFlag() ? 1 : 0, "pps_extension_flag" );
+#else
+  WRITE_FLAG( pcPPS->getExtensionFlag() ? 1 : 0, "pps_extension_present_flag" );
+#endif
 
   if( pcPPS->getExtensionFlag() )
   {
+#if !R0042_PROFILE_INDICATION
 #if !POC_RESET_IDC
     UInt ppsExtensionTypeFlag[8] = { 0, 1, 0, 0, 0, 0, 0, 0 };
@@ -273 +281 @@
     {
       WRITE_FLAG( pcPPS->getPocResetInfoPresentFlag() ? 1 : 0, "poc_reset_info_present_flag" );
+#if REF_REGION_OFFSET
+      WRITE_UVLC( pcPPS->getNumScaledRefLayerOffsets(),      "num_scaled_ref_layer_offsets" );
+      for(Int i = 0; i < pcPPS->getNumScaledRefLayerOffsets(); i++)
+      {
+        WRITE_CODE( pcPPS->getScaledRefLayerId(i), 6, "scaled_ref_layer_id" );
+        WRITE_FLAG( pcPPS->getScaledRefLayerOffsetPresentFlag(i) ? 1 : 0, "scaled_ref_layer_offset_prsent_flag" );
+        if (pcPPS->getScaledRefLayerOffsetPresentFlag(i))
+        {
+          Window scaledWindow = pcPPS->getScaledRefLayerWindow(i);
+          WRITE_SVLC( scaledWindow.getWindowLeftOffset()   >> 1, "scaled_ref_layer_left_offset" );
+          WRITE_SVLC( scaledWindow.getWindowTopOffset()    >> 1, "scaled_ref_layer_top_offset" );
+          WRITE_SVLC( scaledWindow.getWindowRightOffset()  >> 1, "scaled_ref_layer_right_offset" );
+          WRITE_SVLC( scaledWindow.getWindowBottomOffset() >> 1, "scaled_ref_layer_bottom_offset" );
+        }
+        WRITE_FLAG( pcPPS->getRefRegionOffsetPresentFlag(i) ? 1 : 0, "ref_region_offset_prsent_flag" );
+        if (pcPPS->getRefRegionOffsetPresentFlag(i))
+        {
+          Window refWindow = pcPPS->getRefLayerWindow(i);
+          WRITE_SVLC( refWindow.getWindowLeftOffset()   >> 1, "ref_layer_left_offset" );
+          WRITE_SVLC( refWindow.getWindowTopOffset()    >> 1, "ref_layer_top_offset" );
+          WRITE_SVLC( refWindow.getWindowRightOffset()  >> 1, "ref_layer_right_offset" );
+          WRITE_SVLC( refWindow.getWindowBottomOffset() >> 1, "ref_layer_bottom_offset" );
+        }
+#if R0209_GENERIC_PHASE
+        WRITE_FLAG( pcPPS->getResamplePhaseSetPresentFlag(i) ? 1 : 0, "resample_phase_set_present_flag" );
+        if (pcPPS->getResamplePhaseSetPresentFlag(i))
+        {
+          WRITE_UVLC( pcPPS->getPhaseHorLuma(i), "phase_hor_luma" );
+          WRITE_UVLC( pcPPS->getPhaseVerLuma(i), "phase_ver_luma" );
+          WRITE_UVLC( pcPPS->getPhaseHorChroma(i) + 8, "phase_hor_chroma_plus8" );
+          WRITE_UVLC( pcPPS->getPhaseVerChroma(i) + 8, "phase_ver_chroma_plus8" );
+        }
+#endif
+      }
+#else
+#if MOVE_SCALED_OFFSET_TO_PPS
+      WRITE_UVLC( pcPPS->getNumScaledRefLayerOffsets(),      "num_scaled_ref_layer_offsets" );
+      for(Int i = 0; i < pcPPS->getNumScaledRefLayerOffsets(); i++)
+      {
+        Window scaledWindow = pcPPS->getScaledRefLayerWindow(i);
+#if O0098_SCALED_REF_LAYER_ID
+        WRITE_CODE( pcPPS->getScaledRefLayerId(i), 6,          "scaled_ref_layer_id" );
+#endif
+        WRITE_SVLC( scaledWindow.getWindowLeftOffset()   >> 1, "scaled_ref_layer_left_offset" );
+        WRITE_SVLC( scaledWindow.getWindowTopOffset()    >> 1, "scaled_ref_layer_top_offset" );
+        WRITE_SVLC( scaledWindow.getWindowRightOffset()  >> 1, "scaled_ref_layer_right_offset" );
+        WRITE_SVLC( scaledWindow.getWindowBottomOffset() >> 1, "scaled_ref_layer_bottom_offset" );
+      }
+#endif
+#endif
 #if Q0048_CGS_3D_ASYMLUT
       UInt uiPos = getNumberOfWrittenBits();
@@ -285 +343 @@
 #endif
     }
+#else
+  WRITE_FLAG( 0, "pps_range_extension_flag" );
+  WRITE_FLAG( 1, "pps_multilayer_extension_flag" );
+  WRITE_CODE( 0, 6,  "pps_extension_6bits" );     
+
+  WRITE_FLAG( pcPPS->getPocResetInfoPresentFlag() ? 1 : 0, "poc_reset_info_present_flag" );
+#if SCALINGLIST_INFERRING
+  WRITE_FLAG( pcPPS->getInferScalingListFlag() ? 1 : 0, "pps_infer_scaling_list_flag" );
+  if( pcPPS->getInferScalingListFlag() )
+  {
+    // The value of pps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
+    assert( pcPPS->getScalingListRefLayerId() <= 62 );
+    WRITE_UVLC( pcPPS->getScalingListRefLayerId(), "pps_scaling_list_ref_layer_id" );
+  }
+#endif
+
+#if REF_REGION_OFFSET
+  WRITE_UVLC( pcPPS->getNumScaledRefLayerOffsets(),      "num_ref_loc_offsets" );
+  for(Int i = 0; i < pcPPS->getNumScaledRefLayerOffsets(); i++)
+  {
+    WRITE_CODE( pcPPS->getScaledRefLayerId(i), 6, "ref_loc_offset_layer_id" );
+    WRITE_FLAG( pcPPS->getScaledRefLayerOffsetPresentFlag(i) ? 1 : 0, "scaled_ref_layer_offset_prsent_flag" );
+    if (pcPPS->getScaledRefLayerOffsetPresentFlag(i))
+    {
+      Window scaledWindow = pcPPS->getScaledRefLayerWindow(i);
+      WRITE_SVLC( scaledWindow.getWindowLeftOffset()   >> 1, "scaled_ref_layer_left_offset" );
+      WRITE_SVLC( scaledWindow.getWindowTopOffset()    >> 1, "scaled_ref_layer_top_offset" );
+      WRITE_SVLC( scaledWindow.getWindowRightOffset()  >> 1, "scaled_ref_layer_right_offset" );
+      WRITE_SVLC( scaledWindow.getWindowBottomOffset() >> 1, "scaled_ref_layer_bottom_offset" );
+    }
+    WRITE_FLAG( pcPPS->getRefRegionOffsetPresentFlag(i) ? 1 : 0, "ref_region_offset_prsent_flag" );
+    if (pcPPS->getRefRegionOffsetPresentFlag(i))
+    {
+      Window refWindow = pcPPS->getRefLayerWindow(i);
+      WRITE_SVLC( refWindow.getWindowLeftOffset()   >> 1, "ref_region_left_offset" );
+      WRITE_SVLC( refWindow.getWindowTopOffset()    >> 1, "ref_region_top_offset" );
+      WRITE_SVLC( refWindow.getWindowRightOffset()  >> 1, "ref_region_right_offset" );
+      WRITE_SVLC( refWindow.getWindowBottomOffset() >> 1, "ref_region_bottom_offset" );
+    }
+#if R0209_GENERIC_PHASE
+    WRITE_FLAG( pcPPS->getResamplePhaseSetPresentFlag(i) ? 1 : 0, "resample_phase_set_present_flag" );
+    if (pcPPS->getResamplePhaseSetPresentFlag(i))
+    {
+      WRITE_UVLC( pcPPS->getPhaseHorLuma(i), "phase_hor_luma" );
+      WRITE_UVLC( pcPPS->getPhaseVerLuma(i), "phase_ver_luma" );
+      WRITE_UVLC( pcPPS->getPhaseHorChroma(i) + 8, "phase_hor_chroma_plus8" );
+      WRITE_UVLC( pcPPS->getPhaseVerChroma(i) + 8, "phase_ver_chroma_plus8" );
+    }
+#endif
+  }
+#else
+#if MOVE_SCALED_OFFSET_TO_PPS
+  WRITE_UVLC( pcPPS->getNumScaledRefLayerOffsets(),      "num_scaled_ref_layer_offsets" );
+  for(Int i = 0; i < pcPPS->getNumScaledRefLayerOffsets(); i++)
+  {
+    Window scaledWindow = pcPPS->getScaledRefLayerWindow(i);
+#if O0098_SCALED_REF_LAYER_ID
+    WRITE_CODE( pcPPS->getScaledRefLayerId(i), 6,          "scaled_ref_layer_id" );
+#endif
+    WRITE_SVLC( scaledWindow.getWindowLeftOffset()   >> 1, "scaled_ref_layer_left_offset" );
+    WRITE_SVLC( scaledWindow.getWindowTopOffset()    >> 1, "scaled_ref_layer_top_offset" );
+    WRITE_SVLC( scaledWindow.getWindowRightOffset()  >> 1, "scaled_ref_layer_right_offset" );
+    WRITE_SVLC( scaledWindow.getWindowBottomOffset() >> 1, "scaled_ref_layer_bottom_offset" );
+  }
+#endif
+#endif
+#if Q0048_CGS_3D_ASYMLUT
+  UInt uiPos = getNumberOfWrittenBits();
+  WRITE_FLAG( pcPPS->getCGSFlag() , "colour_mapping_enabled_flag" );
+  if( pcPPS->getCGSFlag() )
+  {
+    assert( pc3DAsymLUT != NULL );
+    xCode3DAsymLUT( pc3DAsymLUT );
+  }
+  pc3DAsymLUT->setPPSBit( getNumberOfWrittenBits() - uiPos );
+#endif
+#endif
   }
 #else
@@ -340 +475 @@
   if( defaultDisplayWindow.getWindowEnabledFlag() )
   {
-    WRITE_UVLC(defaultDisplayWindow.getWindowLeftOffset(),      "def_disp_win_left_offset");
-    WRITE_UVLC(defaultDisplayWindow.getWindowRightOffset(),     "def_disp_win_right_offset");
-    WRITE_UVLC(defaultDisplayWindow.getWindowTopOffset(),       "def_disp_win_top_offset");
-    WRITE_UVLC(defaultDisplayWindow.getWindowBottomOffset(),    "def_disp_win_bottom_offset");
+    WRITE_UVLC(defaultDisplayWindow.getWindowLeftOffset()  / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc()), "def_disp_win_left_offset");
+    WRITE_UVLC(defaultDisplayWindow.getWindowRightOffset() / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc()), "def_disp_win_right_offset");
+    WRITE_UVLC(defaultDisplayWindow.getWindowTopOffset()   / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc()), "def_disp_win_top_offset");
+    WRITE_UVLC(defaultDisplayWindow.getWindowBottomOffset()/ TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc()), "def_disp_win_bottom_offset");
   }
   TimingInfo *timingInfo = pcVUI->getTimingInfo();
@@ -452 +587 @@
 Void TEncCavlc::codeSPS( TComSPS* pcSPS )
 {
+#if R0042_PROFILE_INDICATION
+  Bool bMultiLayerExtSpsFlag = (pcSPS->getNumDirectRefLayers() != 0 ) ; 
+#endif
 #if ENC_DEC_TRACE  
   xTraceSPSHeader (pcSPS);
@@ -461 +599 @@
 #endif
     WRITE_CODE( pcSPS->getMaxTLayers() - 1,  3,       "sps_max_sub_layers_minus1" );
+#if SVC_EXTENSION
+  }
+#if R0042_PROFILE_INDICATION
+  else
+  {
+    WRITE_CODE(bMultiLayerExtSpsFlag? 7:(pcSPS->getMaxTLayers() - 1) ,  3,       "sps_ext_or_max_sub_layers_minus1" );
+  }
+#endif
+#endif
+
+#if SVC_EXTENSION
+#if !R0042_PROFILE_INDICATION
+  if(pcSPS->getLayerId() == 0)
+#else
+  if(!bMultiLayerExtSpsFlag)
+#endif
+  {
+#endif
     WRITE_FLAG( pcSPS->getTemporalIdNestingFlag() ? 1 : 0,                             "sps_temporal_id_nesting_flag" );
 #if SVC_EXTENSION
@@ -466 +622 @@
 #endif
 #ifdef SPS_PTL_FIX
+#if !R0042_PROFILE_INDICATION
   if (pcSPS->getLayerId() == 0)
+#else
+  if(!bMultiLayerExtSpsFlag)
+#endif
   {
     codePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
@@ -475 +635 @@
   WRITE_UVLC( pcSPS->getSPSId (),                   "sps_seq_parameter_set_id" );
 #if REPN_FORMAT_IN_VPS
+#if !R0042_PROFILE_INDICATION
   if( pcSPS->getLayerId() > 0 )
+#else
+  if(bMultiLayerExtSpsFlag)
+#endif
   {
     WRITE_FLAG( pcSPS->getUpdateRepFormatFlag(), "update_rep_format_flag" );
   }
+#if R0042_PROFILE_INDICATION
+  if( bMultiLayerExtSpsFlag && pcSPS->getUpdateRepFormatFlag())
+  {
+    WRITE_CODE( pcSPS->getUpdateRepFormatIndex(), 8,   "sps_rep_format_idx");
+  }
+#endif
+
+#if R0042_PROFILE_INDICATION
+  if(!bMultiLayerExtSpsFlag)
+  {
+#endif
+#if !R0042_PROFILE_INDICATION
 #if O0096_REP_FORMAT_INDEX
   if( pcSPS->getLayerId() == 0 ) 
 #else
   if( pcSPS->getLayerId() == 0 || pcSPS->getUpdateRepFormatFlag() ) 
+#endif
 #endif
   {
@@ -498 +675 @@
 #if REPN_FORMAT_IN_VPS
   }
+#if !R0042_PROFILE_INDICATION
 #if O0096_REP_FORMAT_INDEX
   else if (pcSPS->getUpdateRepFormatFlag())
@@ -505 +683 @@
 #endif
 #endif
-  Window conf = pcSPS->getConformanceWindow();
-
-  WRITE_FLAG( conf.getWindowEnabledFlag(),          "conformance_window_flag" );
-  if (conf.getWindowEnabledFlag())
-  {
+#endif
+
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
 #if REPN_FORMAT_IN_VPS
-    WRITE_UVLC( conf.getWindowLeftOffset(),   "conf_win_left_offset"   );
-    WRITE_UVLC( conf.getWindowRightOffset(),  "conf_win_right_offset"  );
-    WRITE_UVLC( conf.getWindowTopOffset(),    "conf_win_top_offset"    );
-    WRITE_UVLC( conf.getWindowBottomOffset(), "conf_win_bottom_offset" );
-#else
-    WRITE_UVLC( conf.getWindowLeftOffset()   / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc() ), "conf_win_left_offset" );
-    WRITE_UVLC( conf.getWindowRightOffset()  / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc() ), "conf_win_right_offset" );
-    WRITE_UVLC( conf.getWindowTopOffset()    / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc() ), "conf_win_top_offset" );
-    WRITE_UVLC( conf.getWindowBottomOffset() / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc() ), "conf_win_bottom_offset" );
-#endif
-  }
-
-#if REPN_FORMAT_IN_VPS
+#if !R0042_PROFILE_INDICATION
 #if O0096_REP_FORMAT_INDEX
   if( pcSPS->getLayerId() == 0 ) 
@@ -529 +693 @@
   if( pcSPS->getLayerId() == 0 || pcSPS->getUpdateRepFormatFlag() ) 
 #endif  
+#endif
+  {
+#endif
+#endif
+    Window conf = pcSPS->getConformanceWindow();
+
+    WRITE_FLAG( conf.getWindowEnabledFlag(),          "conformance_window_flag" );
+    if (conf.getWindowEnabledFlag())
+    {
+#if REPN_FORMAT_IN_VPS
+      WRITE_UVLC( conf.getWindowLeftOffset(),   "conf_win_left_offset"   );
+      WRITE_UVLC( conf.getWindowRightOffset(),  "conf_win_right_offset"  );
+      WRITE_UVLC( conf.getWindowTopOffset(),    "conf_win_top_offset"    );
+      WRITE_UVLC( conf.getWindowBottomOffset(), "conf_win_bottom_offset" );
+#else
+      WRITE_UVLC( conf.getWindowLeftOffset()   / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc() ), "conf_win_left_offset" );
+      WRITE_UVLC( conf.getWindowRightOffset()  / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc() ), "conf_win_right_offset" );
+      WRITE_UVLC( conf.getWindowTopOffset()    / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc() ), "conf_win_top_offset" );
+      WRITE_UVLC( conf.getWindowBottomOffset() / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc() ), "conf_win_bottom_offset" );
+#endif
+    }
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
+#if REPN_FORMAT_IN_VPS
+  }
+#endif
+#endif
+
+#if REPN_FORMAT_IN_VPS
+#if !R0042_PROFILE_INDICATION
+#if O0096_REP_FORMAT_INDEX
+  if( pcSPS->getLayerId() == 0 ) 
+#else
+  if( pcSPS->getLayerId() == 0 || pcSPS->getUpdateRepFormatFlag() ) 
+#endif
+#endif
   {
     assert( pcSPS->getBitDepthY() >= 8 );
@@ -538 +737 @@
   }
 #endif
+#if R0042_PROFILE_INDICATION
+  }
+#endif
+
   WRITE_UVLC( pcSPS->getBitsForPOC()-4,                 "log2_max_pic_order_cnt_lsb_minus4" );
 
 #if SPS_DPB_PARAMS
+#if !R0042_PROFILE_INDICATION
   if( pcSPS->getLayerId() == 0 )
+#else
+  if(!bMultiLayerExtSpsFlag)
+#endif
   {
 #endif
@@ -571 +778 @@
   {
 #if SCALINGLIST_INFERRING
+#if !R0042_PROFILE_INDICATION
     if( pcSPS->getLayerId() > 0 )
+#else
+    if( bMultiLayerExtSpsFlag)
+#endif
     {
       WRITE_FLAG( pcSPS->getInferScalingListFlag() ? 1 : 0, "sps_infer_scaling_list_flag" );
@@ -640 +851 @@
 
 #if SVC_EXTENSION
+#if !R0042_PROFILE_INDICATION
   WRITE_FLAG( pcSPS->getExtensionFlag() ? 1 : 0, "sps_extension_flag" );
+#else
+  WRITE_FLAG( pcSPS->getExtensionFlag() ? 1 : 0, "sps_extension_present_flag" );
+#endif
 
   if( pcSPS->getExtensionFlag() )
   {
+#if !R0042_PROFILE_INDICATION
 #if O0142_CONDITIONAL_SPS_EXTENSION
     UInt spsExtensionTypeFlag[8] = { 0, 1, 0, 0, 0, 0, 0, 0 };
@@ -658 +874 @@
     WRITE_FLAG( 0, "sps_extension2_flag" );
 #endif
+#else
+    WRITE_FLAG( 0, "sps_range_extension_flag" );
+    WRITE_FLAG( 1, "sps_multilayer_extension_flag" );
+    WRITE_CODE( 0, 6,  "sps_extension_6bits" );   
+    codeSPSExtension( pcSPS ); //it is sps_multilayer_extension
+#endif
   }
 #else
@@ -672 +894 @@
   WRITE_FLAG( 0, "inter_view_mv_vert_constraint_flag" );
 
+#if !MOVE_SCALED_OFFSET_TO_PPS
   if( pcSPS->getLayerId() > 0 )
   {
@@ -690 +913 @@
     }
   }
+#endif
 }
 #endif //SVC_EXTENSION
@@ -706 +930 @@
 #endif
   WRITE_CODE( pcVPS->getVPSId(),                    4,        "vps_video_parameter_set_id" );
+#if VPS_RESERVED_FLAGS
+  WRITE_FLAG( pcVPS->getBaseLayerInternalFlag(),              "vps_base_layer_internal_flag");
+  WRITE_FLAG( pcVPS->getBaseLayerAvailableFlag(),             "vps_base_layer_available_flag");
+#else
   WRITE_CODE( 3,                                    2,        "vps_reserved_three_2bits" );
+#endif
 #if SVC_EXTENSION
   WRITE_CODE( pcVPS->getMaxLayers() - 1,            6,        "vps_max_layers_minus1" );            
@@ -774 +1003 @@
     }
   }
+#if !NECESSARY_FLAG   // Already called once in TAppEncTop.cpp
 #if DERIVE_LAYER_ID_LIST_VARIABLES
   pcVPS->deriveLayerIdListVariables();
+#endif
 #endif
   TimingInfo *timingInfo = pcVPS->getTimingInfo();
@@ -848 +1079 @@
   Int OlsHighestOutputLayerId[MAX_VPS_LAYER_SETS_PLUS1];
 #endif
+#if LIST_OF_PTL
+  if( vps->getMaxLayers() > 1 && vps->getBaseLayerInternalFlag() )
+  {
+    codePTL( vps->getPTLForExtn(1), false, vps->getMaxTLayers() - 1 );
+  }
+#endif
 #if VPS_EXTN_MASK_AND_DIM_INFO
   UInt i = 0, j = 0;
-
+#if !VPS_AVC_BL_FLAG_REMOVAL
   WRITE_FLAG( vps->getAvcBaseLayerFlag(),              "avc_base_layer_flag" );
+#endif
 #if !P0307_REMOVE_VPS_VUI_OFFSET
 #if O0109_MOVE_VPS_VUI_FLAG
@@ -948 +1186 @@
     }
   }
+#endif
+#if MOVE_ADDN_LS_SIGNALLING
+#if Q0078_ADD_LAYER_SETS
+  if (vps->getNumIndependentLayers() > 1)
+  {
+    WRITE_UVLC( vps->getNumAddLayerSets(), "num_add_layer_sets" );
+    for (i = 0; i < vps->getNumAddLayerSets(); i++)
+    {
+      for (j = 1; j < vps->getNumIndependentLayers(); j++)
+      {
+        int len = 1;
+        while ((1 << len) < (vps->getNumLayersInTreePartition(j) + 1))
+        {
+          len++;
+        }
+        WRITE_CODE(vps->getHighestLayerIdxPlus1(i, j), len, "highest_layer_idx_plus1[i][j]");
+      }
+    }
+  }
+#endif
 #endif
 #if VPS_TSLAYERS
@@ -985 +1243 @@
 #else
   WRITE_UVLC( vps->getNumProfileTierLevel() - 1, "vps_num_profile_tier_level_minus1"); 
-#endif
+#if PER_LAYER_PTL
+  Int const numBitsForPtlIdx = vps->calculateLenOfSyntaxElement( vps->getNumProfileTierLevel() );
+#endif
+#endif
+#if LIST_OF_PTL
+  assert( vps->getNumProfileTierLevel() == vps->getPTLForExtnPtr()->size());
+  for(Int idx = vps->getBaseLayerInternalFlag() ? 2 : 1; idx <= vps->getNumProfileTierLevel() - 1; idx++)
+#else
   for(Int idx = 1; idx <= vps->getNumProfileTierLevel() - 1; idx++)
+#endif
   {
     WRITE_FLAG( vps->getProfilePresentFlag(idx),       "vps_profile_present_flag[i]" );
@@ -999 +1265 @@
 #endif
 
+
+#if !MOVE_ADDN_LS_SIGNALLING
 #if Q0078_ADD_LAYER_SETS
   if (vps->getNumIndependentLayers() > 1)
@@ -1016 +1284 @@
     }
   }
+#endif
 #endif
 
@@ -1060 +1329 @@
   for(i = 1; i < numOutputLayerSets; i++)
   {
+    Int layerSetIdxForOutputLayerSet = vps->getOutputLayerSetIdx(i);
     if( i > (vps->getNumLayerSets() - 1) )
     {
@@ -1077 +1347 @@
     {
 #endif
-      Int lsIdx = vps->getOutputLayerSetIdx(i);
 #if NUM_OL_FLAGS
-      for(j = 0; j < vps->getNumLayersInIdList(lsIdx) ; j++)
+      for(j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet) ; j++)
 #else
       for(j = 0; j < vps->getNumLayersInIdList(lsIdx) - 1; j++)
@@ -1087 +1356 @@
       }
     }
+#if PER_LAYER_PTL
+    for(j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet) ; j++)
+    {
+      if( vps->getNecessaryLayerFlag(i, j) )
+      {
+        WRITE_CODE( vps->getProfileLevelTierIdx(i, j), numBitsForPtlIdx, "profile_level_tier_idx[i]" );
+      }
+    }
+#else
     Int numBits = 1;
     while ((1 << numBits) < (vps->getNumProfileTierLevel()))
@@ -1093 +1371 @@
     }
     WRITE_CODE( vps->getProfileLevelTierIdx(i), numBits, "profile_level_tier_idx[i]" );     
+#endif
 #if P0300_ALT_OUTPUT_LAYER_FLAG
     NumOutputLayersInOutputLayerSet[i] = 0;
-    Int layerSetIdxForOutputLayerSet = vps->getOutputLayerSetIdx(i);
     for (j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet); j++)
     {
@@ -1211 +1489 @@
 
   WRITE_FLAG(vps->getMaxOneActiveRefLayerFlag(), "max_one_active_ref_layer_flag");
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  WRITE_FLAG(vps->getVpsPocLsbAlignedFlag(), "vps_poc_lsb_aligned_flag");
+#endif
 #if O0062_POC_LSB_NOT_PRESENT_FLAG
   for(i = 1; i< vps->getMaxLayers(); i++)
@@ -1367 +1648 @@
   WRITE_CODE( repFormat->getBitDepthVpsChroma() - 8, 4, "bit_depth_chroma_minus8" );
 #endif
+
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
+  Window conf = repFormat->getConformanceWindowVps();
+
+  WRITE_FLAG( conf.getWindowEnabledFlag(),    "conformance_window_vps_flag" );
+  if (conf.getWindowEnabledFlag())
+  {
+    WRITE_UVLC( conf.getWindowLeftOffset(),   "conf_win_vps_left_offset"   );
+    WRITE_UVLC( conf.getWindowRightOffset(),  "conf_win_vps_right_offset"  );
+    WRITE_UVLC( conf.getWindowTopOffset(),    "conf_win_vps_top_offset"    );
+    WRITE_UVLC( conf.getWindowBottomOffset(), "conf_win_vps_bottom_offset" );
+  }
+#endif
 }
 #endif
@@ -1372 +1666 @@
 Void TEncCavlc::codeVpsDpbSizeTable(TComVPS *vps)
 {
+#if !SUB_LAYERS_IN_LAYER_SET  // MaxSLInLayerSets calculated earlier in the encoder
 #if DPB_PARAMS_MAXTLAYERS
 #if BITRATE_PICRATE_SIGNALLING
@@ -1400 +1695 @@
     }
 #endif
+#endif
     
     
@@ -1408 +1704 @@
 #endif
     WRITE_FLAG( vps->getSubLayerFlagInfoPresentFlag( i ), "sub_layer_flag_info_present_flag[i]");
+#if SUB_LAYERS_IN_LAYER_SET
+    for(Int j = 0; j <= vps->getMaxSLayersInLayerSetMinus1( layerSetIdxForOutputLayerSet ); j++)
+#else
 #if DPB_PARAMS_MAXTLAYERS
 #if BITRATE_PICRATE_SIGNALLING
@@ -1417 +1716 @@
     for(Int j = 0; j < vps->getMaxTLayers(); j++)
 #endif
+#endif
     {
       if( j > 0 && vps->getSubLayerFlagInfoPresentFlag(i) )
@@ -1434 +1734 @@
 #endif
         {
-          WRITE_UVLC( vps->getMaxVpsDecPicBufferingMinus1( i, k, j), "max_vps_dec_pic_buffering_minus1[i][k][j]" ); 
+#if DPB_INTERNAL_BL_SIG
+        if(vps->getBaseLayerInternalFlag()  || ( vps->getLayerSetLayerIdList(layerSetIdxForOutputLayerSet, k)   !=  0 ) )
+#endif
+          WRITE_UVLC( vps->getMaxVpsDecPicBufferingMinus1( i, k, j), "max_vps_dec_pic_buffering_minus1[i][k][j]" );
         }
         WRITE_UVLC( vps->getMaxVpsNumReorderPics( i, j), "max_vps_num_reorder_pics[i][j]" );              
@@ -1450 +1753 @@
     }
   }
+
+#if !SUB_LAYERS_IN_LAYER_SET
+#if BITRATE_PICRATE_SIGNALLING
+  if( MaxSubLayersInLayerSetMinus1 )
+  {
+    delete [] MaxSubLayersInLayerSetMinus1;
+  }
+#endif
+#endif
 }
 #endif
@@ -1479 +1791 @@
   {
 #if Q0078_ADD_LAYER_SETS
+#if R0227_BR_PR_ADD_LAYER_SET
+#if SIGNALLING_BITRATE_PICRATE_FIX
+    for( i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getNumLayerSets(); i++ )
+#else
+    for( i = 0; i < vps->getNumLayerSets(); i++ )
+#endif
+#else
     for( i = 0; i <= vps->getVpsNumLayerSetsMinus1(); i++ )
+#endif
 #else
     for( i = 0; i < vps->getNumLayerSets(); i++ )
@@ -1529 +1849 @@
   if (vps->getVideoSigPresentVpsFlag() && vps->getNumVideoSignalInfo() > 1 )
   {
+#if VPS_VUI_VST_PARAMS
+    for(i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getMaxLayers(); i++)
+    {
+      WRITE_CODE( vps->getVideoSignalInfoIdx(i), 4, "vps_video_signal_info_idx" );
+    }
+#else
     for (i=1; i < vps->getMaxLayers(); i++)
       WRITE_CODE(vps->getVideoSignalInfoIdx(i), 4, "vps_video_signal_info_idx" );
+#endif
   }
 #endif 
@@ -1645 +1972 @@
     if (vps->getVpsVuiBspHrdPresentFlag())
     {
+#if VPS_VUI_BSP_HRD_PARAMS
+      codeVpsVuiBspHrdParams(vps);
+#else
       WRITE_UVLC( vps->getVpsNumBspHrdParametersMinus1(), "vps_num_bsp_hrd_parameters_minus1" );
       for( i = 0; i <= vps->getVpsNumBspHrdParametersMinus1(); i++ )
@@ -1688 +2018 @@
         }
       }
+#endif
     }
 #endif
@@ -1786 +2117 @@
     }
 #else
+#if CROSS_LAYER_BLA_FLAG_FIX
+    Int iBits = 0;
+    if(pcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits)
+#else
     if (pcSlice->getPPS()->getNumExtraSliceHeaderBits()>0)
+#endif
     {
       assert(!!"discardable_flag");
+#if NON_REF_NAL_TYPE_DISCARDABLE
+      if (pcSlice->getDiscardableFlag())
+      {
+        assert(pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TRAIL_R &&
+          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TSA_R &&
+          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_STSA_R &&
+          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RADL_R &&
+          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RASL_R);
+      }
+#endif
       WRITE_FLAG(pcSlice->getDiscardableFlag(), "discardable_flag");
-    }
+#if CROSS_LAYER_BLA_FLAG_FIX
+      iBits++;
+#endif
+    }
+#if CROSS_LAYER_BLA_FLAG_FIX
+    if( pcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits )
+    {
+      assert(!!"cross_layer_bla_flag");
+      WRITE_FLAG(pcSlice->getCrossLayerBLAFlag(), "cross_layer_bla_flag");
+      iBits++;
+    }
+    for (; iBits < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); iBits++)
+#else
     for (Int i = 1; i < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
+#endif
     {
       assert(!!"slice_reserved_undetermined_flag[]");
@@ -1978 +2337 @@
       if (pcSlice->getSPS()->getTMVPFlagsPresent())
       {
+#if R0226_SLICE_TMVP
+        WRITE_FLAG( pcSlice->getEnableTMVPFlag() ? 1 : 0, "slice_temporal_mvp_enabled_flag" );
+#else
         WRITE_FLAG( pcSlice->getEnableTMVPFlag() ? 1 : 0, "slice_temporal_mvp_enable_flag" );
+#endif
       }
 #if N0065_LAYER_POC_ALIGNMENT && !SHM_FIX7
@@ -2262 +2625 @@
   }
   UInt numEntryPointOffsets = 0, offsetLenMinus1 = 0, maxOffset = 0;
+#if !WPP_FIX
   Int  numZeroSubstreamsAtStartOfSlice  = 0;
+#endif
   UInt *entryPointOffset = NULL;
   if ( pSlice->getPPS()->getTilesEnabledFlag() )
@@ -2289 +2654 @@
     UInt* pSubstreamSizes               = pSlice->getSubstreamSizes();
     Int maxNumParts                       = pSlice->getPic()->getNumPartInCU();
+#if WPP_FIX
+    Int  numZeroSubstreamsAtStartOfSlice  = pSlice->getPic()->getSubstreamForLCUAddr(pSlice->getSliceSegmentCurStartCUAddr()/maxNumParts, false, pSlice); 
+    Int  subStreamOfLastSegmentOfSlice    = pSlice->getPic()->getSubstreamForLCUAddr((pSlice->getSliceSegmentCurEndCUAddr()/maxNumParts)-1, false, pSlice); 
+    numEntryPointOffsets                  = subStreamOfLastSegmentOfSlice-numZeroSubstreamsAtStartOfSlice;
+#else
     numZeroSubstreamsAtStartOfSlice       = pSlice->getSliceSegmentCurStartCUAddr()/maxNumParts/pSlice->getPic()->getFrameWidthInCU();
     Int  numZeroSubstreamsAtEndOfSlice    = pSlice->getPic()->getFrameHeightInCU()-1 - ((pSlice->getSliceSegmentCurEndCUAddr()-1)/maxNumParts/pSlice->getPic()->getFrameWidthInCU());
     numEntryPointOffsets                  = pSlice->getPPS()->getNumSubstreams() - numZeroSubstreamsAtStartOfSlice - numZeroSubstreamsAtEndOfSlice - 1;
+#endif
     pSlice->setNumEntryPointOffsets(numEntryPointOffsets);
     entryPointOffset           = new UInt[numEntryPointOffsets];
@@ -2333 +2704 @@
   {
     // Derive the value of PocMsbValRequiredFlag
-    slice->setPocMsbValRequiredFlag( slice->getCraPicFlag() || slice->getBlaPicFlag()
-                                          /* || related to vps_poc_lsb_aligned_flag */
-                                          );
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+    slice->setPocMsbValRequiredFlag( (slice->getCraPicFlag() || slice->getBlaPicFlag())
+                                  && (!slice->getVPS()->getVpsPocLsbAlignedFlag() ||
+                                      (slice->getVPS()->getVpsPocLsbAlignedFlag() && slice->getVPS()->getNumDirectRefLayers(slice->getLayerId()) == 0))
+                                   );
+#else
+    slice->setPocMsbValRequiredFlag( slice->getCraPicFlag() || slice->getBlaPicFlag() );
+#endif
 
     // Determine value of SH extension length.
@@ -2353 +2729 @@
 
 
-    if( !slice->getPocMsbValRequiredFlag() /* &&  vps_poc_lsb_aligned_flag */ )
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+    if (!slice->getPocMsbValRequiredFlag() && slice->getVPS()->getVpsPocLsbAlignedFlag())
+#else
+    if (!slice->getPocMsbValRequiredFlag() /* &&  vps_poc_lsb_aligned_flag */)
+#endif
     {
       shExtnLengthInBit++;
@@ -2369 +2749 @@
     }
 
-    if( slice->getPocMsbValPresentFlag() )
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+    if (slice->getPocMsbNeeded())
+    {
+      slice->setPocMsbValPresentFlag(true);
+    }
+#endif
+
+    if (slice->getPocMsbValPresentFlag())
     {
       UInt lengthVal = 1;
@@ -2403 +2790 @@
     }
 
-    if( !slice->getPocMsbValRequiredFlag() /* &&  vps_poc_lsb_aligned_flag */ )
-    {
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+    if (!slice->getPocMsbValRequiredFlag() && slice->getVPS()->getVpsPocLsbAlignedFlag())
+#else
+    if (!slice->getPocMsbValRequiredFlag() /* &&  vps_poc_lsb_aligned_flag */)
+#endif
+    {
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+      WRITE_FLAG( slice->getPocMsbValPresentFlag(),                           "poc_msb_cycle_val_present_flag" );
+#else
       WRITE_FLAG( slice->getPocMsbValPresentFlag(),                           "poc_msb_val_present_flag" );
-    }
-    if( slice->getPocMsbValPresentFlag() )
-    {
-      assert( slice->getPocMsbVal() % maxPocLsb == 0 );
-      WRITE_UVLC( slice->getPocMsbVal() / maxPocLsb,                                      "poc_msb_val" );
+#endif
+    }
+    if (slice->getPocMsbValPresentFlag())
+    {
+      assert(slice->getPocMsbVal() % maxPocLsb == 0);
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+      WRITE_UVLC(slice->getPocMsbVal() / maxPocLsb, "poc_msb_cycle_val");
+#else
+      WRITE_UVLC(slice->getPocMsbVal() / maxPocLsb, "poc_msb_val");
+#endif
     }
     for (Int i = 0; i < shExtnAdditionalBits; i++)
@@ -2755 +3154 @@
 Void TEncCavlc::xCode3DAsymLUT( TCom3DAsymLUT * pc3DAsymLUT )
 {
+#if R0150_CGS_SIGNAL_CONSTRAINTS
+  UInt uiNumRefLayers = ( UInt )pc3DAsymLUT->getRefLayerNum();
+  WRITE_UVLC( uiNumRefLayers - 1 , "num_cm_ref_layers_minus1" );
+  for( UInt i = 0 ; i < uiNumRefLayers ; i++ )
+  {
+    WRITE_CODE( pc3DAsymLUT->getRefLayerId( i ) , 6 , "cm_ref_layer_id" );
+  }
+#endif
   assert( pc3DAsymLUT->getCurOctantDepth() < 4 );
   WRITE_CODE( pc3DAsymLUT->getCurOctantDepth() , 2 , "cm_octant_depth" );
@@ -2760 +3167 @@
   WRITE_CODE( pc3DAsymLUT->getCurYPartNumLog2() , 2 , "cm_y_part_num_log2" );
   assert( pc3DAsymLUT->getInputBitDepthY() < 16 );
+#if R0150_CGS_SIGNAL_CONSTRAINTS
+  WRITE_UVLC( pc3DAsymLUT->getInputBitDepthY() - 8 , "cm_input_luma_bit_depth_minus8" );
+  WRITE_UVLC( pc3DAsymLUT->getInputBitDepthC() - 8 , "cm_input_chroma_bit_depth_minus8" );
+  WRITE_UVLC( pc3DAsymLUT->getOutputBitDepthY() - 8 , "cm_output_luma_bit_depth_minus8" );
+  WRITE_UVLC( pc3DAsymLUT->getOutputBitDepthC() - 8 , "cm_output_chroma_bit_depth_minus8" );
+#else
   WRITE_CODE( pc3DAsymLUT->getInputBitDepthY() - 8 , 3 , "cm_input_bit_depth_minus8" );
   WRITE_SVLC(pc3DAsymLUT->getInputBitDepthC()-pc3DAsymLUT->getInputBitDepthY(), "cm_input_bit_depth_chroma delta");
@@ -2765 +3178 @@
   WRITE_CODE( pc3DAsymLUT->getOutputBitDepthY() - 8 , 3 , "cm_output_bit_depth_minus8" );
   WRITE_SVLC(pc3DAsymLUT->getOutputBitDepthC()-pc3DAsymLUT->getOutputBitDepthY(), "cm_output_bit_depth_chroma_delta");
+#endif
   assert( pc3DAsymLUT->getResQuantBit() < 4 );
   WRITE_CODE( pc3DAsymLUT->getResQuantBit() , 2 , "cm_res_quant_bit" );
-
+#if R0300_CGS_RES_COEFF_CODING
+  xFindDeltaBits( pc3DAsymLUT );
+  assert(pc3DAsymLUT->getDeltaBits() >=1 && pc3DAsymLUT->getDeltaBits() <= 4);
+  WRITE_CODE( pc3DAsymLUT->getDeltaBits()-1 , 2 , "cm_delta_bit" );
+#endif 
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  if( pc3DAsymLUT->getCurOctantDepth() == 1 )
+  {
+    WRITE_SVLC( pc3DAsymLUT->getAdaptChromaThresholdU() - ( 1 << ( pc3DAsymLUT->getInputBitDepthC() - 1 ) ) , "cm_adapt_threshold_u_delta" );
+    WRITE_SVLC( pc3DAsymLUT->getAdaptChromaThresholdV() - ( 1 << ( pc3DAsymLUT->getInputBitDepthC() - 1 ) ) , "cm_adapt_threshold_v_delta" );
+  }
+#endif
+
+#if R0164_CGS_LUT_BUGFIX_CHECK
+  pc3DAsymLUT->xInitCuboids();
+#endif
   xCode3DAsymLUTOctant( pc3DAsymLUT , 0 , 0 , 0 , 0 , 1 << pc3DAsymLUT->getCurOctantDepth() );
+#if R0164_CGS_LUT_BUGFIX_CHECK
+  xCuboidsFilledCheck( false );
+  pc3DAsymLUT->display( false );
+#endif
 }
 
@@ -2793 +3226 @@
   else
   {
+#if R0300_CGS_RES_COEFF_CODING
+    Int nFLCbits = pc3DAsymLUT->getMappingShift()-pc3DAsymLUT->getResQuantBit()-pc3DAsymLUT->getDeltaBits() ; 
+    nFLCbits = nFLCbits >= 0 ? nFLCbits : 0;
+#endif
     for( Int l = 0 ; l < nYPartNum ; l++ )
     {
+#if R0164_CGS_LUT_BUGFIX      
+      Int shift = pc3DAsymLUT->getCurOctantDepth() - nDepth ;
+#endif
       for( Int nVertexIdx = 0 ; nVertexIdx < 4 ; nVertexIdx++ )
       {
+#if R0164_CGS_LUT_BUGFIX 
+        SYUVP sRes = pc3DAsymLUT->getCuboidVertexResTree( yIdx + (l<<shift) , uIdx , vIdx , nVertexIdx );
+#else
         SYUVP sRes = pc3DAsymLUT->getCuboidVertexResTree( yIdx + l , uIdx , vIdx , nVertexIdx );
+#endif
         UInt uiCodeVertex = sRes.Y != 0 || sRes.U != 0 || sRes.V != 0;
         WRITE_FLAG( uiCodeVertex , "coded_vertex_flag" );
         if( uiCodeVertex )
         {
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+#if R0300_CGS_RES_COEFF_CODING
+          xWriteParam( sRes.Y, nFLCbits );
+          xWriteParam( sRes.U, nFLCbits );
+          xWriteParam( sRes.V, nFLCbits );
+#else
+          xWriteParam( sRes.Y );
+          xWriteParam( sRes.U );
+          xWriteParam( sRes.V );
+#endif
+#else
           WRITE_SVLC( sRes.Y , "resY" );
           WRITE_SVLC( sRes.U , "resU" );
           WRITE_SVLC( sRes.V , "resV" );
-        }
-      }
-    }
-  }
-}
+#endif
+        }
+      }
+#if R0164_CGS_LUT_BUGFIX_CHECK
+      pc3DAsymLUT->xSetExplicit( yIdx + (l<<shift) , uIdx , vIdx );
+#endif
+    }
+  }
+}
+
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+#if R0300_CGS_RES_COEFF_CODING
+Void TEncCavlc::xWriteParam( Int param, UInt rParam)
+#else
+Void TEncCavlc::xWriteParam( Int param)
+#endif
+{
+#if !R0300_CGS_RES_COEFF_CODING
+  const UInt rParam = 7;
+#endif
+  Int codeNumber = abs(param);
+  WRITE_UVLC(codeNumber / (1 << rParam), "quotient");
+  WRITE_CODE((codeNumber % (1 << rParam)), rParam, "remainder");
+  if (abs(param))
+    WRITE_FLAG( param <0, "sign");
+}
+#endif
+
+#if R0300_CGS_RES_COEFF_CODING
+Void TEncCavlc::xFindDeltaBits( TCom3DAsymLUT * pc3DAsymLUT )
+{
+  Int nDeltaBits; 
+  Int nBestDeltaBits = -1; 
+  Int nBestBits = MAX_INT; 
+  for( nDeltaBits = 1; nDeltaBits < 5; nDeltaBits++)
+  {
+    Int nCurBits = 0;
+    xTally3DAsymLUTOctantBits( pc3DAsymLUT , 0 , 0 , 0 , 0 , 1 << pc3DAsymLUT->getCurOctantDepth(), nDeltaBits, nCurBits );
+    //printf("%d, %d, %d\n", nDeltaBits, nCurBits, nBestBits); 
+    if(nCurBits < nBestBits)
+    {
+      nBestDeltaBits = nDeltaBits; 
+      nBestBits = nCurBits;
+    }
+  }
+
+  assert(nBestDeltaBits >=1 && nBestDeltaBits < 5);
+  pc3DAsymLUT->setDeltaBits(nBestDeltaBits); 
+}
+
+Void TEncCavlc::xTally3DAsymLUTOctantBits( TCom3DAsymLUT * pc3DAsymLUT , Int nDepth , Int yIdx , Int uIdx , Int vIdx , Int nLength, Int nDeltaBits, Int& nCurBits )
+{
+  UInt uiOctantSplit = nDepth < pc3DAsymLUT->getCurOctantDepth();
+  if( nDepth < pc3DAsymLUT->getCurOctantDepth() )
+    nCurBits ++; 
+  Int nYPartNum = 1 << pc3DAsymLUT->getCurYPartNumLog2();
+  if( uiOctantSplit )
+  {
+    Int nHalfLength = nLength >> 1;
+    for( Int l = 0 ; l < 2 ; l++ )
+    {
+      for( Int m = 0 ; m < 2 ; m++ )
+      {
+        for( Int n = 0 ; n < 2 ; n++ )
+        {
+          xTally3DAsymLUTOctantBits( pc3DAsymLUT , nDepth + 1 , yIdx + l * nHalfLength * nYPartNum , uIdx + m * nHalfLength , vIdx + n * nHalfLength , nHalfLength, nDeltaBits, nCurBits );
+        }
+      }
+    }
+  }
+  else
+  {
+    Int nFLCbits = pc3DAsymLUT->getMappingShift()-pc3DAsymLUT->getResQuantBit()-nDeltaBits ; 
+    nFLCbits = nFLCbits >= 0 ? nFLCbits:0;
+    //printf("nFLCbits = %d\n", nFLCbits);
+
+    for( Int l = 0 ; l < nYPartNum ; l++ )
+    {
+      for( Int nVertexIdx = 0 ; nVertexIdx < 4 ; nVertexIdx++ )
+      {
+        SYUVP sRes = pc3DAsymLUT->getCuboidVertexResTree( yIdx + l , uIdx , vIdx , nVertexIdx );
+
+        UInt uiCodeVertex = sRes.Y != 0 || sRes.U != 0 || sRes.V != 0;
+        nCurBits++;
+        if( uiCodeVertex )
+        {
+          xCheckParamBits( sRes.Y, nFLCbits, nCurBits );
+          xCheckParamBits( sRes.U, nFLCbits, nCurBits );
+          xCheckParamBits( sRes.V, nFLCbits, nCurBits );
+        }
+      }
+    }
+  }
+}
+
+Void TEncCavlc::xCheckParamBits( Int param, Int rParam, Int &nBits)
+{
+  Int codeNumber = abs(param);
+  Int codeQuotient = codeNumber >> rParam;
+  Int qLen; 
+
+  UInt uiLength = 1;
+  UInt uiTemp = ++codeQuotient;
+    
+  while( 1 != uiTemp )
+  {
+    uiTemp >>= 1;
+    uiLength += 2;
+  }
+
+  qLen  = (uiLength >> 1);
+  qLen += ((uiLength+1) >> 1);
+
+  nBits += qLen; 
+  nBits += rParam; 
+  if (abs(param))
+    nBits++; 
+}
+#endif
+#if VPS_VUI_BSP_HRD_PARAMS
+Void TEncCavlc::codeVpsVuiBspHrdParams(TComVPS * const vps)
+{
+  WRITE_UVLC( vps->getVpsNumAddHrdParams(), "vps_num_add_hrd_params" );
+  for( Int i = vps->getNumHrdParameters(), j = 0; i < vps->getNumHrdParameters() + vps->getVpsNumAddHrdParams(); i++, j++ ) // j = i - vps->getNumHrdParameters()
+  {
+    if( i > 0 )
+    {
+      WRITE_FLAG( vps->getCprmsAddPresentFlag(j), "cprms_add_present_flag[i]" );
+    }
+    WRITE_UVLC( vps->getNumSubLayerHrdMinus1(j), "num_sub_layer_hrd_minus1[i]" );
+    codeHrdParameters(vps->getBspHrd(j), i == 0 ? true : vps->getCprmsAddPresentFlag(j), vps->getNumSubLayerHrdMinus1(j));
+  }
+  for( Int h = 1; h < vps->getNumOutputLayerSets(); h++ )
+  {
+    Int lsIdx = vps->getOutputLayerSetIdx( h );
+    WRITE_UVLC( vps->getNumSignalledPartitioningSchemes(h), "num_signalled_partitioning_schemes[h]");
+    for( Int j = 0; j < vps->getNumSignalledPartitioningSchemes(h); j++ )
+    {
+      WRITE_UVLC( vps->getNumPartitionsInSchemeMinus1(h, j), "num_partitions_in_scheme_minus1[h][j]" );
+      for( Int k = 0; k <= vps->getNumPartitionsInSchemeMinus1(h, j); k++ )
+      {
+        for( Int r = 0; r < vps->getNumLayersInIdList( lsIdx ); r++ )
+        {
+          WRITE_FLAG( vps->getLayerIncludedInPartitionFlag(h, j, k, r), "layer_included_in_partition_flag[h][j][k][r]" );
+        }
+      }
+    }
+    for( Int i = 0; i < vps->getNumSignalledPartitioningSchemes(h) + 1; i++ )
+    {
+      for( Int t = 0; t <= vps->getMaxSLayersInLayerSetMinus1(lsIdx); t++ )
+      {
+        WRITE_UVLC(vps->getNumBspSchedulesMinus1(h, i, t), "num_bsp_schedules_minus1[h][i][t]");
+        for( Int j = 0; j <= vps->getNumBspSchedulesMinus1(h, i, t); j++ )
+        {
+          for( Int k = 0; k < vps->getNumPartitionsInSchemeMinus1(h, i); k++ )
+          {
+            WRITE_UVLC( vps->getBspHrdIdx(h, i, t, j, k),   "bsp_comb_hrd_idx[h][i][t][j][k]");
+            WRITE_UVLC( vps->getBspSchedIdx(h, i, t, j, k), "bsp_comb_sched_idx[h][i][t][j][k]");
+          }
+        }
+      }
+    }
+  }
+}
+#endif
 #endif
 //! \}

trunk/source/Lib/TLibEncoder/TEncCavlc.h

@@ -169 +169 @@
   Void  codeVpsDpbSizeTable    (TComVPS *vps);
 #endif
-#if Q0048_CGS_3D_ASYMLUT
+#if VPS_VUI_BSP_HRD_PARAMS
+  Void  codeVpsVuiBspHrdParams  (TComVPS * const);
+#endif
+#if Q0048_CGS_3D_ASYMLUT
+#if R0179_ENC_OPT_3DLUT_SIZE
+public:
+  Void xCode3DAsymLUT( TCom3DAsymLUT * pc3DAsymLUT );
+protected:
+  Void xCode3DAsymLUTOctant( TCom3DAsymLUT * pc3DAsymLUT , Int nDepth , Int yIdx , Int uIdx , Int vIdx , Int nLength );
+#else
 protected:
   Void xCode3DAsymLUT( TCom3DAsymLUT * pc3DAsymLUT );
   Void xCode3DAsymLUTOctant( TCom3DAsymLUT * pc3DAsymLUT , Int nDepth , Int yIdx , Int uIdx , Int vIdx , Int nLength );
 #endif
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+#if R0300_CGS_RES_COEFF_CODING
+  Void xWriteParam( Int param, UInt nFLCBits);
+  Void xCheckParamBits( Int param, Int nFLCBits, Int & nCurBits);
+  Void xTally3DAsymLUTOctantBits( TCom3DAsymLUT * pc3DAsymLUT , Int nDepth , Int yIdx , Int uIdx , Int vIdx , Int nLength, Int nDeltaBits, Int &nCurBits); 
+  Void xFindDeltaBits( TCom3DAsymLUT * pc3DAsymLUT );
+#else
+  Void xWriteParam( Int param);
+#endif
+#endif
+#endif
 #endif //SVC_EXTENSION
 

trunk/source/Lib/TLibEncoder/TEncCfg.h

@@ -107 +107 @@
   Int       m_iSourceWidth;
   Int       m_iSourceHeight;
-  Int       m_conformanceMode;
   Window    m_conformanceWindow;
   Int       m_framesToBeEncoded;
@@ -208 +207 @@
   Bool      m_bPCMFilterDisableFlag;
   Bool      m_loopFilterAcrossTilesEnabledFlag;
-  Int       m_iUniformSpacingIdr;
+  Bool      m_tileUniformSpacingFlag;
   Int       m_iNumColumnsMinus1;
-  UInt*     m_puiColumnWidth;
   Int       m_iNumRowsMinus1;
-  UInt*     m_puiRowHeight;
+  std::vector<Int> m_tileColumnWidth;
+  std::vector<Int> m_tileRowHeight;
 
   Int       m_iWaveFrontSynchro;
@@ -248 +247 @@
   Int*      m_codedPivotValue;
   Int*      m_targetPivotValue;
-#if P0050_KNEE_FUNCTION_SEI
-  Bool      m_kneeSEIEnabled;
-  Int       m_kneeSEIId;
-  Bool      m_kneeSEICancelFlag;
-  Bool      m_kneeSEIPersistenceFlag;
-  Bool      m_kneeSEIMappingFlag;
-  Int       m_kneeSEIInputDrange;
-  Int       m_kneeSEIInputDispLuminance;
-  Int       m_kneeSEIOutputDrange;
-  Int       m_kneeSEIOutputDispLuminance;
-  Int       m_kneeSEINumKneePointsMinus1;
-  Int*      m_kneeSEIInputKneePoint;
-  Int*      m_kneeSEIOutputKneePoint;
-#endif
-#if Q0074_SEI_COLOR_MAPPING
-  Char*     m_seiColorMappingFile;
-#endif
   Int       m_framePackingSEIEnabled;
   Int       m_framePackingSEIType;
@@ -276 +258 @@
   Int       m_SOPDescriptionSEIEnabled;
   Int       m_scalableNestingSEIEnabled;
-#if Q0189_TMVP_CONSTRAINTS
-  Int       m_TMVPConstraintsSEIEnabled;
-#endif
   //====== Weighted Prediction ========
   Bool      m_useWeightedPred;       //< Use of Weighting Prediction (P_SLICE)
@@ -388 +367 @@
   Int  m_nCGSMaxYPartNumLog2;
   Int  m_nCGSLUTBit;
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  Int  m_nCGSAdaptiveChroma;
+#endif
+#if R0179_ENC_OPT_3DLUT_SIZE
+  Int  m_nCGSLutSizeRDO;
+#endif
+#endif
+#if P0050_KNEE_FUNCTION_SEI
+  Bool      m_kneeSEIEnabled;
+  Int       m_kneeSEIId;
+  Bool      m_kneeSEICancelFlag;
+  Bool      m_kneeSEIPersistenceFlag;
+  Bool      m_kneeSEIMappingFlag;
+  Int       m_kneeSEIInputDrange;
+  Int       m_kneeSEIInputDispLuminance;
+  Int       m_kneeSEIOutputDrange;
+  Int       m_kneeSEIOutputDispLuminance;
+  Int       m_kneeSEINumKneePointsMinus1;
+  Int*      m_kneeSEIInputKneePoint;
+  Int*      m_kneeSEIOutputKneePoint;
+#endif
+#if Q0189_TMVP_CONSTRAINTS
+  Int       m_TMVPConstraintsSEIEnabled;
 #endif
 #endif //SVC_EXTENSION
+#if Q0074_COLOUR_REMAPPING_SEI
+  Char*     m_colourRemapSEIFile;          ///< SEI Colour Remapping File (initialized from external file)
+  Int       m_colourRemapSEIId;
+  Bool      m_colourRemapSEICancelFlag;
+  Bool      m_colourRemapSEIPersistenceFlag;
+  Bool      m_colourRemapSEIVideoSignalInfoPresentFlag;
+  Bool      m_colourRemapSEIFullRangeFlag;
+  Int       m_colourRemapSEIPrimaries;
+  Int       m_colourRemapSEITransferFunction;
+  Int       m_colourRemapSEIMatrixCoefficients;
+  Int       m_colourRemapSEIInputBitDepth;
+  Int       m_colourRemapSEIBitDepth;
+  Int       m_colourRemapSEIPreLutNumValMinus1[3];
+  Int*      m_colourRemapSEIPreLutCodedValue[3];
+  Int*      m_colourRemapSEIPreLutTargetValue[3];
+  Bool      m_colourRemapSEIMatrixPresentFlag;
+  Int       m_colourRemapSEILog2MatrixDenom;
+  Int       m_colourRemapSEICoeffs[3][3];
+  Int       m_colourRemapSEIPostLutNumValMinus1[3];
+  Int*      m_colourRemapSEIPostLutCodedValue[3];
+  Int*      m_colourRemapSEIPostLutTargetValue[3];
+#endif
 
 public:
   TEncCfg()
-  : m_puiColumnWidth()
-  , m_puiRowHeight()
+  : m_tileColumnWidth()
+  , m_tileRowHeight()
   {}
 
   virtual ~TEncCfg()
-  {
-    delete[] m_puiColumnWidth;
-    delete[] m_puiRowHeight;
-  }
+  {}
   
   Void setProfile(Profile::Name profile) { m_profile = profile; }
@@ -412 +433 @@
 
   Window   &getConformanceWindow()                           { return m_conformanceWindow; }
-#if P0312_VERT_PHASE_ADJ 
+#if P0312_VERT_PHASE_ADJ && !R0209_GENERIC_PHASE
   Void      setConformanceWindow (Int confLeft, Int confRight, Int confTop, Int confBottom ) { m_conformanceWindow.setWindow (confLeft, confRight, confTop, confBottom, false); }
 #else
@@ -437 +458 @@
   Void      setMaxRefPicNum                 ( Int iMaxRefPicNum )           { m_iMaxRefPicNum = iMaxRefPicNum;  }
 
-  Bool      getMaxTempLayer                 ()                              { return m_maxTempLayer;              } 
+  Int       getMaxTempLayer                 ()                              { return m_maxTempLayer;              } 
   Void      setMaxTempLayer                 ( Int maxTempLayer )            { m_maxTempLayer = maxTempLayer;      }
   //======== Transform =============
@@ -582 +603 @@
   Void  setLFCrossTileBoundaryFlag               ( Bool   val  )       { m_loopFilterAcrossTilesEnabledFlag = val; }
   Bool  getLFCrossTileBoundaryFlag               ()                    { return m_loopFilterAcrossTilesEnabledFlag;   }
-  Void  setUniformSpacingIdr           ( Int i )           { m_iUniformSpacingIdr = i; }
-  Int   getUniformSpacingIdr           ()                  { return m_iUniformSpacingIdr; }
+  Void  setTileUniformSpacingFlag      ( Bool b )          { m_tileUniformSpacingFlag = b; }
+  Bool  getTileUniformSpacingFlag      ()                  { return m_tileUniformSpacingFlag; }
   Void  setNumColumnsMinus1            ( Int i )           { m_iNumColumnsMinus1 = i; }
   Int   getNumColumnsMinus1            ()                  { return m_iNumColumnsMinus1; }
-  Void  setColumnWidth ( UInt* columnWidth )
-  {
-    if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
-    {
-      Int  m_iWidthInCU = ( m_iSourceWidth%g_uiMaxCUWidth ) ? m_iSourceWidth/g_uiMaxCUWidth + 1 : m_iSourceWidth/g_uiMaxCUWidth;
-      m_puiColumnWidth = new UInt[ m_iNumColumnsMinus1 ];
-
-      for(Int i=0; i<m_iNumColumnsMinus1; i++)
-      {
-        m_puiColumnWidth[i] = columnWidth[i];
-        printf("col: m_iWidthInCU= %4d i=%4d width= %4d\n",m_iWidthInCU,i,m_puiColumnWidth[i]); //AFU
-      }
-    }
-  }
-  UInt  getColumnWidth                 ( UInt columnidx )  { return *( m_puiColumnWidth + columnidx ); }
+  Void  setColumnWidth ( const std::vector<Int>& columnWidth ) { m_tileColumnWidth = columnWidth; }
+  UInt  getColumnWidth                 ( UInt columnIdx )      { return m_tileColumnWidth[columnIdx]; }
   Void  setNumRowsMinus1               ( Int i )           { m_iNumRowsMinus1 = i; }
   Int   getNumRowsMinus1               ()                  { return m_iNumRowsMinus1; }
-  Void  setRowHeight (UInt* rowHeight)
-  {
-    if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
-    {
-      Int  m_iHeightInCU = ( m_iSourceHeight%g_uiMaxCUHeight ) ? m_iSourceHeight/g_uiMaxCUHeight + 1 : m_iSourceHeight/g_uiMaxCUHeight;
-      m_puiRowHeight = new UInt[ m_iNumRowsMinus1 ];
-
-      for(Int i=0; i<m_iNumRowsMinus1; i++)
-      {
-        m_puiRowHeight[i] = rowHeight[i];
-        printf("row: m_iHeightInCU=%4d i=%4d height=%4d\n",m_iHeightInCU,i,m_puiRowHeight[i]); //AFU
-      }
-    }
-  }
-  UInt  getRowHeight                   ( UInt rowIdx )     { return *( m_puiRowHeight + rowIdx ); }
+  Void  setRowHeight ( const std::vector<Int>& rowHeight)      { m_tileRowHeight = rowHeight; }
+  UInt  getRowHeight                   ( UInt rowIdx )         { return m_tileRowHeight[rowIdx]; }
   Void  xCheckGSParameters();
   Void  setWaveFrontSynchro(Int iWaveFrontSynchro)       { m_iWaveFrontSynchro = iWaveFrontSynchro; }
@@ -711 +706 @@
   Int*  getKneeSEIOutputKneePoint()                          { return m_kneeSEIOutputKneePoint; }
 #endif
-#if Q0074_SEI_COLOR_MAPPING
-  Void  setColorMappingInfoSEIFile( Char* nameFile )         {  m_seiColorMappingFile = nameFile; }
-  Char* getColorMappingInfoSEIFile()                         {  return m_seiColorMappingFile; }
+#if Q0074_COLOUR_REMAPPING_SEI
+  Void  setCRISEIFile( Char* pch )                           { m_colourRemapSEIFile = pch; }
+  Char* getCRISEIFile()                                      { return m_colourRemapSEIFile; }
+  Void  setCRISEIId(Int i)                                   { m_colourRemapSEIId = i; }
+  Int   getCRISEIId()                                        { return m_colourRemapSEIId; }
+  Void  setCRISEICancelFlag(Bool b)                          { m_colourRemapSEICancelFlag = b; }
+  Bool  getCRISEICancelFlag()                                { return m_colourRemapSEICancelFlag; }
+  Void  setCRISEIPersistenceFlag(Bool b)                     { m_colourRemapSEIPersistenceFlag = b; }
+  Bool  getCRISEIPersistenceFlag()                           { return m_colourRemapSEIPersistenceFlag; }
+  Void  setCRISEIVideoSignalInfoPresentFlag(Bool b)          { m_colourRemapSEIVideoSignalInfoPresentFlag = b; }
+  Bool  getCRISEIVideoSignalInfoPresentFlag()                { return m_colourRemapSEIVideoSignalInfoPresentFlag; }
+  Void  setCRISEIFullRangeFlag(Bool b)                       { m_colourRemapSEIFullRangeFlag = b; }
+  Bool  getCRISEIFullRangeFlag()                             { return m_colourRemapSEIFullRangeFlag; }
+  Void  setCRISEIPrimaries(Int i)                            { m_colourRemapSEIPrimaries = i; }
+  Int   getCRISEIPrimaries()                                 { return m_colourRemapSEIPrimaries; }  
+  Void  setCRISEITransferFunction(Int i)                     { m_colourRemapSEITransferFunction = i; }
+  Int   getCRISEITransferFunction()                          { return m_colourRemapSEITransferFunction; }  
+  Void  setCRISEIMatrixCoefficients(Int i)                   { m_colourRemapSEIMatrixCoefficients = i; }
+  Int   getCRISEIMatrixCoefficients()                        { return m_colourRemapSEIMatrixCoefficients; }
+  Void  setCRISEIInputBitDepth(Int i)                        { m_colourRemapSEIInputBitDepth = i; }
+  Int   getCRISEIInputBitDepth()                             { return m_colourRemapSEIInputBitDepth; } 
+  Void  setCRISEIBitDepth(Int i)                             { m_colourRemapSEIBitDepth = i; }
+  Int   getCRISEIBitDepth()                                  { return m_colourRemapSEIBitDepth; } 
+  Void  setCRISEIPreLutNumValMinus1(Int *i)                  { for(Int c=0 ; c<3 ; c++) m_colourRemapSEIPreLutNumValMinus1[c] = i[c]; }
+  Int   getCRISEIPreLutNumValMinus1(Int i)                   { return m_colourRemapSEIPreLutNumValMinus1[i]; }
+  Void  setCRISEIPreLutCodedValue(Int **i)                   { for(Int c=0 ; c<3 ; c++) m_colourRemapSEIPreLutCodedValue[c] = i[c]; }
+  Int*  getCRISEIPreLutCodedValue(Int i)                     { return m_colourRemapSEIPreLutCodedValue[i]; }
+  Void  setCRISEIPreLutTargetValue(Int **i)                  { for(Int c=0 ; c<3 ; c++) m_colourRemapSEIPreLutTargetValue[c] = i[c]; }
+  Int*  getCRISEIPreLutTargetValue(Int i)                    { return m_colourRemapSEIPreLutTargetValue[i]; }
+  Void  setCRISEIMatrixPresentFlag(Bool b)                   { m_colourRemapSEIMatrixPresentFlag = b; }
+  Bool  getCRISEIMatrixPresentFlag()                         { return m_colourRemapSEIMatrixPresentFlag; }
+  Void  setCRISEILog2MatrixDenom(Int i)                      { m_colourRemapSEILog2MatrixDenom = i; }
+  Int   getCRISEILog2MatrixDenom()                           { return m_colourRemapSEILog2MatrixDenom; } 
+  Void  setCRISEICoeffs(Int i[3][3])                         { for(Int c=0 ; c<3 ; c++) for(Int j=0 ; j<3 ; j++) m_colourRemapSEICoeffs[c][j] = i[c][j]; }
+  Int*  getCRISEICoeffs(Int i)                               { return m_colourRemapSEICoeffs[i]; }
+  Void  setCRISEIPostLutNumValMinus1(Int *i)                 { for(Int c=0 ; c<3 ; c++) m_colourRemapSEIPostLutNumValMinus1[c] = i[c]; }
+  Int   getCRISEIPostLutNumValMinus1(Int i)                  { return m_colourRemapSEIPostLutNumValMinus1[i]; }
+  Void  setCRISEIPostLutCodedValue(Int **i)                  { for(Int c=0 ; c<3 ; c++) m_colourRemapSEIPostLutCodedValue[c] = i[c]; }
+  Int*  getCRISEIPostLutCodedValue(Int i)                    { return m_colourRemapSEIPostLutCodedValue[i]; }
+  Void  setCRISEIPostLutTargetValue(Int **i)                 { for(Int c=0 ; c<3 ; c++) m_colourRemapSEIPostLutTargetValue[c] = i[c]; }
+  Int*  getCRISEIPostLutTargetValue(Int i)                   { return m_colourRemapSEIPostLutTargetValue[i]; }
 #endif
   Void  setFramePackingArrangementSEIEnabled(Int b)      { m_framePackingSEIEnabled = b; }
@@ -865 +898 @@
   UInt      getNumLayer           () { return m_numLayer;             }  
   Void      setNumLayer           (UInt uiNum)   { m_numLayer = uiNum;  }
-  Void      setConformanceMode    (Int mode)     { m_conformanceMode = mode; }
   Void      setConformanceWindow(Window& conformanceWindow ) { m_conformanceWindow = conformanceWindow; }
   Void      setElRapSliceTypeB(Int bEnabled) {m_elRapSliceBEnabled = bEnabled;}
@@ -971 +1003 @@
   Void      setCGSLUTBit(Int n)           { m_nCGSLUTBit = n;    }
   Int       getCGSLUTBit()                { return m_nCGSLUTBit; }
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  Void      setCGSAdaptChroma(Int n)      { m_nCGSAdaptiveChroma = n;  }
+  Int       getCGSAdaptChroma()           { return m_nCGSAdaptiveChroma; }
+#endif
+#if R0179_ENC_OPT_3DLUT_SIZE
+  Void      setCGSLutSizeRDO(Int n)      { m_nCGSLutSizeRDO = n;  }
+  Int       getCGSLutSizeRDO()           { return m_nCGSLutSizeRDO; }
+#endif
 #endif
 #endif

trunk/source/Lib/TLibEncoder/TEncGOP.cpp

@@ -49 +49 @@
 #include <time.h>
 #include <math.h>
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+#include <limits.h>
+#endif
 
 using namespace std;
@@ -202 +205 @@
   seiActiveParameterSets->m_selfContainedCvsFlag = false;
   seiActiveParameterSets->m_noParameterSetUpdateFlag = false;
+#if !R0247_SEI_ACTIVE
   seiActiveParameterSets->numSpsIdsMinus1 = 0;
   seiActiveParameterSets->activeSeqParameterSetId.resize(seiActiveParameterSets->numSpsIdsMinus1 + 1); 
   seiActiveParameterSets->activeSeqParameterSetId[0] = sps->getSPSId();
+#else
+  seiActiveParameterSets->numSpsIdsMinus1 = m_pcCfg->getNumLayer()-1;
+  seiActiveParameterSets->activeSeqParameterSetId.resize(seiActiveParameterSets->numSpsIdsMinus1 + 1); 
+  seiActiveParameterSets->layerSpsIdx.resize(seiActiveParameterSets->numSpsIdsMinus1+ 1);  
+  for (Int c=0; c <= seiActiveParameterSets->numSpsIdsMinus1; c++)
+  {
+     seiActiveParameterSets->activeSeqParameterSetId[c] = c;
+  }
+  for (Int c=1; c <= seiActiveParameterSets->numSpsIdsMinus1; c++)
+  {
+     seiActiveParameterSets->layerSpsIdx[c] = c;
+  }
+#endif
   return seiActiveParameterSets;
 }
@@ -365 +382 @@
 #endif
 
-#if Q0074_SEI_COLOR_MAPPING
-SEIColorMappingInfo*  TEncGOP::xCreateSEIColorMappingInfo( Char* file )
+#if Q0074_COLOUR_REMAPPING_SEI
+SEIColourRemappingInfo*  TEncGOP::xCreateSEIColourRemappingInfo()
 {
-  SEIColorMappingInfo *seiColorMappingInfo = new SEIColorMappingInfo();
-
-  FILE* fic = fopen( file, "r" );
-
-  Int iVal, retval;
-
-  retval = fscanf( fic, "%d", &seiColorMappingInfo->m_colorMapId );
-  retval = fscanf( fic, "%d", &iVal );
-  seiColorMappingInfo->m_colorMapCancelFlag = iVal;
-  if( !seiColorMappingInfo->m_colorMapCancelFlag )
-  {
-    retval = fscanf( fic, "%d", &iVal );
-    seiColorMappingInfo->m_colorMapPersistenceFlag = iVal;
-    retval = fscanf( fic, "%d", &iVal );
-    seiColorMappingInfo->m_colorMap_video_signal_type_present_flag = iVal;
-    if( seiColorMappingInfo->m_colorMap_video_signal_type_present_flag )
-    {
-      retval = fscanf( fic, "%d", &iVal );
-      seiColorMappingInfo->m_colorMap_video_full_range_flag = iVal;
-      retval = fscanf( fic, "%d", &seiColorMappingInfo->m_colorMap_primaries );
-      retval = fscanf( fic, "%d", &seiColorMappingInfo->m_colorMap_transfer_characteristics );
-      retval = fscanf( fic, "%d", &seiColorMappingInfo->m_colorMap_matrix_coeffs );
-    }
-  }
-
-  retval = fscanf( fic, "%d", &seiColorMappingInfo->m_colour_map_coded_data_bit_depth );
-  retval = fscanf( fic, "%d", &seiColorMappingInfo->m_colour_map_target_bit_depth );
-  retval = fscanf( fic, "%d", &iVal );
-  seiColorMappingInfo->m_colorMapModelId = iVal;
-
-  assert( seiColorMappingInfo->m_colorMapModelId == 0 );
-  
-  for( Int i=0 ; i<3 ; i++ )
-  {
-    retval = fscanf( fic, "%d", &seiColorMappingInfo->m_num_input_pivots[i] );
-    seiColorMappingInfo->m_coded_input_pivot_value[i]   = new Int[ seiColorMappingInfo->m_num_input_pivots[i] ];
-    seiColorMappingInfo->m_target_input_pivot_value[i]  = new Int[ seiColorMappingInfo->m_num_input_pivots[i] ];
-    for( Int j=0 ; j<seiColorMappingInfo->m_num_input_pivots[i] ; j++ )
-    {
-      retval = fscanf( fic, "%d", &seiColorMappingInfo->m_coded_input_pivot_value[i][j] );
-      retval = fscanf( fic, "%d", &seiColorMappingInfo->m_target_input_pivot_value[i][j] );
-    }
-  }
-
-  retval = fscanf( fic, "%d", &iVal );
-  seiColorMappingInfo->m_matrix_flag = iVal;
-  if( seiColorMappingInfo->m_matrix_flag )
-  {
-    retval = fscanf( fic, "%d", &seiColorMappingInfo->m_log2_matrix_denom );
-    for( Int i=0 ; i<3 ; i++ )
-    {
-      for( Int j=0 ; j<3 ; j++ )
-      {
-        retval = fscanf( fic, "%d", &seiColorMappingInfo->m_matrix_coef[i][j] );
-      }
-    }
-  }
-
-  for( Int i=0 ; i<3 ; i++ )
-  {
-    retval = fscanf( fic, "%d", &seiColorMappingInfo->m_num_output_pivots[i] );
-    seiColorMappingInfo->m_coded_output_pivot_value[i]   = new Int[ seiColorMappingInfo->m_num_output_pivots[i] ];
-    seiColorMappingInfo->m_target_output_pivot_value[i]  = new Int[ seiColorMappingInfo->m_num_output_pivots[i] ];
-    for( Int j=0 ; j<seiColorMappingInfo->m_num_output_pivots[i] ; j++ )
-    {
-      retval = fscanf( fic, "%d", &seiColorMappingInfo->m_coded_output_pivot_value[i][j] );
-      retval = fscanf( fic, "%d", &seiColorMappingInfo->m_target_output_pivot_value[i][j] );
-    }
-  }
-
-  fclose( fic );
-
-  if( retval != 1 )
-  {
-    printf("Error: can't read color mapping information\n");
-  }
-
-  return seiColorMappingInfo;
+  SEIColourRemappingInfo *seiColourRemappingInfo = new SEIColourRemappingInfo();
+  seiColourRemappingInfo->m_colourRemapId         = m_pcCfg->getCRISEIId();
+  seiColourRemappingInfo->m_colourRemapCancelFlag = m_pcCfg->getCRISEICancelFlag();
+  if( !seiColourRemappingInfo->m_colourRemapCancelFlag )
+  {
+    seiColourRemappingInfo->m_colourRemapPersistenceFlag            = m_pcCfg->getCRISEIPersistenceFlag();
+    seiColourRemappingInfo->m_colourRemapVideoSignalInfoPresentFlag = m_pcCfg->getCRISEIVideoSignalInfoPresentFlag();
+    if( seiColourRemappingInfo->m_colourRemapVideoSignalInfoPresentFlag )
+    {
+      seiColourRemappingInfo->m_colourRemapFullRangeFlag           = m_pcCfg->getCRISEIFullRangeFlag();
+      seiColourRemappingInfo->m_colourRemapPrimaries               = m_pcCfg->getCRISEIPrimaries();
+      seiColourRemappingInfo->m_colourRemapTransferFunction        = m_pcCfg->getCRISEITransferFunction();
+      seiColourRemappingInfo->m_colourRemapMatrixCoefficients      = m_pcCfg->getCRISEIMatrixCoefficients();
+    }
+    seiColourRemappingInfo->m_colourRemapInputBitDepth             = m_pcCfg->getCRISEIInputBitDepth();
+    seiColourRemappingInfo->m_colourRemapBitDepth                  = m_pcCfg->getCRISEIBitDepth();
+    for( Int c=0 ; c<3 ; c++ )
+    {
+      seiColourRemappingInfo->m_preLutNumValMinus1[c] = m_pcCfg->getCRISEIPreLutNumValMinus1(c);
+      if( seiColourRemappingInfo->m_preLutNumValMinus1[c]>0 )
+      {
+        seiColourRemappingInfo->m_preLutCodedValue[c].resize(seiColourRemappingInfo->m_preLutNumValMinus1[c]+1);
+        seiColourRemappingInfo->m_preLutTargetValue[c].resize(seiColourRemappingInfo->m_preLutNumValMinus1[c]+1);
+        for( Int i=0 ; i<=seiColourRemappingInfo->m_preLutNumValMinus1[c] ; i++)
+        {
+          seiColourRemappingInfo->m_preLutCodedValue[c][i]  = (m_pcCfg->getCRISEIPreLutCodedValue(c))[i];
+          seiColourRemappingInfo->m_preLutTargetValue[c][i] = (m_pcCfg->getCRISEIPreLutTargetValue(c))[i];
+        }
+      }
+    }
+    seiColourRemappingInfo->m_colourRemapMatrixPresentFlag = m_pcCfg->getCRISEIMatrixPresentFlag();
+    if( seiColourRemappingInfo->m_colourRemapMatrixPresentFlag )
+    {
+      seiColourRemappingInfo->m_log2MatrixDenom = m_pcCfg->getCRISEILog2MatrixDenom();
+      for( Int c=0 ; c<3 ; c++ )
+        for( Int i=0 ; i<3 ; i++ )
+          seiColourRemappingInfo->m_colourRemapCoeffs[c][i] = (m_pcCfg->getCRISEICoeffs(c))[i];
+    }
+    for( Int c=0 ; c<3 ; c++ )
+    {
+      seiColourRemappingInfo->m_postLutNumValMinus1[c] = m_pcCfg->getCRISEIPostLutNumValMinus1(c);
+      if( seiColourRemappingInfo->m_postLutNumValMinus1[c]>0 )
+      {
+        seiColourRemappingInfo->m_postLutCodedValue[c].resize(seiColourRemappingInfo->m_postLutNumValMinus1[c]+1);
+        seiColourRemappingInfo->m_postLutTargetValue[c].resize(seiColourRemappingInfo->m_postLutNumValMinus1[c]+1);
+        for( Int i=0 ; i<=seiColourRemappingInfo->m_postLutNumValMinus1[c] ; i++)
+        {
+          seiColourRemappingInfo->m_postLutCodedValue[c][i]  = (m_pcCfg->getCRISEIPostLutCodedValue(c))[i];
+          seiColourRemappingInfo->m_postLutTargetValue[c][i] = (m_pcCfg->getCRISEIPostLutTargetValue(c))[i];
+        }
+      }
+    }
+  }
+  return seiColourRemappingInfo;
 }
 #endif
@@ -453 +446 @@
   OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
 
-  if(m_pcCfg->getActiveParameterSetsSEIEnabled())
+  if(m_pcCfg->getActiveParameterSetsSEIEnabled()
+#if R0247_SEI_ACTIVE
+    && m_layerId == 0
+#endif
+    )
   {
     SEIActiveParameterSets *sei = xCreateSEIActiveParameterSets (sps);
@@ -532 +529 @@
   }
 #endif
-#if Q0074_SEI_COLOR_MAPPING
-  if(m_pcCfg->getColorMappingInfoSEIFile())
-  {
-    SEIColorMappingInfo *sei = xCreateSEIColorMappingInfo( m_pcCfg->getColorMappingInfoSEIFile() );
+#if Q0074_COLOUR_REMAPPING_SEI
+  if(strlen(m_pcCfg->getCRISEIFile()))
+  {
+    SEIColourRemappingInfo *sei = xCreateSEIColourRemappingInfo ();
       
 #if SVC_EXTENSION
-    nalu = NALUnit(NAL_UNIT_PREFIX_SEI, 0, m_layerId);  // temporalId = 0 ?
+    nalu = NALUnit(NAL_UNIT_PREFIX_SEI, 0, sps->getLayerId());  // SEI-CRI is applied per layer
 #else
     nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
@@ -609 +606 @@
   TEncSbac* pcSbacCoders = NULL;
   TComOutputBitstream* pcSubstreamsOut = NULL;
-#if Q0108_TSA_STSA
-  Int flagTSTA = 0;
-#endif
 
   xInitGOP( iPOCLast, iNumPicRcvd, rcListPic, rcListPicYuvRecOut, isField );
@@ -918 +912 @@
     determinePocResetIdc(pocCurr, pcSlice);
 
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+    Bool pocResettingFlag = false;
+
+    if (pcSlice->getPocResetIdc() != 0)
+    {
+      if (pcSlice->getVPS()->getVpsPocLsbAlignedFlag())
+      {
+        pocResettingFlag = true;
+      }
+      else if (m_pcEncTop->getPocDecrementedInDPBFlag())
+      {
+        pocResettingFlag = false;
+      }
+      else
+      {
+        pocResettingFlag = true;
+      }
+    }
+#endif
+
     // If reset, do the following steps:
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+    if( pocResettingFlag )
+#else
     if( pcSlice->getPocResetIdc() )
+#endif
     {
       updatePocValuesOfPics(pocCurr, pcSlice);
@@ -1020 +1038 @@
       // inferring of the scaling list can be moved to the config file
       UInt refLayerId = 0;
+#if VPS_AVC_BL_FLAG_REMOVAL
+      if( m_layerId > 0 && !m_pcEncTop->getVPS()->getNonHEVCBaseLayerFlag() && m_pcEncTop->getVPS()->getRecursiveRefLayerFlag( m_layerId, refLayerId ) )
+#else
       if( m_layerId > 0 && !m_pcEncTop->getVPS()->getAvcBaseLayerFlag() && m_pcEncTop->getVPS()->getRecursiveRefLayerFlag( m_layerId, refLayerId ) )
+#endif
       {
         m_pcEncTop->getSPS()->setInferScalingListFlag( true );
@@ -1050 +1072 @@
       // inferring of the scaling list can be moved to the config file
       UInt refLayerId = 0;
+#if VPS_AVC_BL_FLAG_REMOVAL
+      if( m_layerId > 0 && !m_pcEncTop->getVPS()->getNonHEVCBaseLayerFlag() && m_pcEncTop->getVPS()->getRecursiveRefLayerFlag( m_layerId, refLayerId ) )
+#else
       if( m_layerId > 0 && !m_pcEncTop->getVPS()->getAvcBaseLayerFlag() && m_pcEncTop->getVPS()->getRecursiveRefLayerFlag( m_layerId, refLayerId ) )
+#endif
       {
         m_pcEncTop->getSPS()->setInferScalingListFlag( true );
@@ -1135 +1161 @@
 #endif
 
+#if REF_REGION_OFFSET
+        const Window &windowRL  = m_pcEncTop->getRefLayerWindowForLayer(pcSlice->getVPS()->getRefLayerId(m_layerId, refLayerIdc));
+        Int widthBL   = pcSlice->getBaseColPic(refLayerIdc)->getPicYuvRec()->getWidth() - windowRL.getWindowLeftOffset() - windowRL.getWindowRightOffset();
+        Int heightBL  = pcSlice->getBaseColPic(refLayerIdc)->getPicYuvRec()->getHeight() - windowRL.getWindowTopOffset() - windowRL.getWindowBottomOffset();
+#else
         Int widthBL   = pcSlice->getBaseColPic(refLayerIdc)->getPicYuvRec()->getWidth();
         Int heightBL  = pcSlice->getBaseColPic(refLayerIdc)->getPicYuvRec()->getHeight();
@@ -1143 +1174 @@
         heightBL -= ( confBL.getWindowTopOffset() + confBL.getWindowBottomOffset() ) * TComSPS::getWinUnitY( chromaFormatIdc );
 #endif
+#endif
         Int widthEL   = pcPic->getPicYuvRec()->getWidth()  - scalEL.getWindowLeftOffset() - scalEL.getWindowRightOffset();
         Int heightEL  = pcPic->getPicYuvRec()->getHeight() - scalEL.getWindowTopOffset()  - scalEL.getWindowBottomOffset();
+
+#if RESAMPLING_FIX
+#if REF_REGION_OFFSET
+        // conformance check: the values of RefLayerRegionWidthInSamplesY, RefLayerRegionHeightInSamplesY, ScaledRefRegionWidthInSamplesY and ScaledRefRegionHeightInSamplesY shall be greater than 0
+        assert(widthEL > 0 && heightEL > 0 && widthBL > 0 && widthEL > 0);
+
+        // conformance check: ScaledRefRegionWidthInSamplesY shall be greater or equal to RefLayerRegionWidthInSamplesY and ScaledRefRegionHeightInSamplesY shall be greater or equal to RefLayerRegionHeightInSamplesY
+        assert(widthEL >= widthBL && heightEL >= heightBL);
+
+#if R0209_GENERIC_PHASE
+        // conformance check: when ScaledRefRegionWidthInSamplesY is equal to RefLayerRegionWidthInSamplesY, PhaseHorY shall be equal to 0, when ScaledRefRegionWidthInSamplesC is equal to RefLayerRegionWidthInSamplesC, PhaseHorC shall be equal to 0, when ScaledRefRegionHeightInSamplesY is equal to RefLayerRegionHeightInSamplesY, PhaseVerY shall be equal to 0, and when ScaledRefRegionHeightInSamplesC is equal to RefLayerRegionHeightInSamplesC, PhaseVerC shall be equal to 0.
+        Int phaseHorLuma   = pcSlice->getPPS()->getPhaseHorLuma(refLayerIdc);
+        Int phaseVerLuma   = pcSlice->getPPS()->getPhaseVerLuma(refLayerIdc);
+        Int phaseHorChroma = pcSlice->getPPS()->getPhaseHorChroma(refLayerIdc);
+        Int phaseVerChroma = pcSlice->getPPS()->getPhaseVerChroma(refLayerIdc);
+        assert( ( (widthEL  != widthBL)  || (phaseHorLuma == 0 && phaseHorChroma == 0) )
+             && ( (heightEL != heightBL) || (phaseVerLuma == 0 && phaseVerChroma == 0) ) );
+#endif
+#endif
+#endif
 
         g_mvScalingFactor[refLayerIdc][0] = widthEL  == widthBL  ? 4096 : Clip3(-4096, 4095, ((widthEL  << 8) + (widthBL  >> 1)) / widthBL);
@@ -1156 +1208 @@
         if( pcSlice->getPPS()->getCGSFlag() )
         {
+#if R0150_CGS_SIGNAL_CONSTRAINTS
+          // all reference layers are currently taken as CGS reference layers
+          m_Enc3DAsymLUTPPS.addRefLayerId( pcSlice->getVPS()->getRefLayerId(m_layerId, refLayerIdc) );
+          m_Enc3DAsymLUTPicUpdate.addRefLayerId( pcSlice->getVPS()->getRefLayerId(m_layerId, refLayerIdc) );
+#endif
           if(g_posScalingFactor[refLayerIdc][0] < (1<<16) || g_posScalingFactor[refLayerIdc][1] < (1<<16)) //if(pcPic->isSpatialEnhLayer(refLayerIdc))
           {
@@ -1207 +1264 @@
 #if O0194_JOINT_US_BITSHIFT
 #if Q0048_CGS_3D_ASYMLUT 
-            m_pcPredSearch->upsampleBasePic( pcSlice, refLayerIdc, pcPic->getFullPelBaseRec(refLayerIdc), pBaseColRec, pcPic->getPicYuvRec(), scalEL );
-#else
-            m_pcPredSearch->upsampleBasePic( pcSlice, refLayerIdc, pcPic->getFullPelBaseRec(refLayerIdc), pcSlice->getBaseColPic(refLayerIdc)->getPicYuvRec(), pcPic->getPicYuvRec(), scalEL );
+#if REF_REGION_OFFSET
+          m_pcPredSearch->upsampleBasePic( pcSlice, refLayerIdc, pcPic->getFullPelBaseRec(refLayerIdc), pBaseColRec, pcPic->getPicYuvRec(), scalEL, altRL );
+#else
+          m_pcPredSearch->upsampleBasePic( pcSlice, refLayerIdc, pcPic->getFullPelBaseRec(refLayerIdc), pBaseColRec, pcPic->getPicYuvRec(), scalEL );
+#endif
+#else
+          m_pcPredSearch->upsampleBasePic( pcSlice, refLayerIdc, pcPic->getFullPelBaseRec(refLayerIdc), pcSlice->getBaseColPic(refLayerIdc)->getPicYuvRec(), pcPic->getPicYuvRec(), scalEL );
 #endif
 #else
@@ -1270 +1331 @@
         }
       }
-
+#if ISLICE_TYPE_NUMDIR
+      if( pcSlice->getActiveNumILRRefIdx() == 0 && pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA && (m_pcEncTop->getNumDirectRefLayers() == 0) )
+#else
       if( pcSlice->getActiveNumILRRefIdx() == 0 && pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA )
+#endif
       {
         pcSlice->setSliceType(I_SLICE);
@@ -1395 +1459 @@
       if(pcSlice->isTemporalLayerSwitchingPoint(rcListPic) || pcSlice->getSPS()->getTemporalIdNestingFlag())
       {
-#if !Q0108_TSA_STSA
+#if SVC_EXTENSION && !Q0108_TSA_STSA
         if( pcSlice->getLayerId() > 0 )
         {
@@ -1494 +1558 @@
         if(isSTSA==true)
         {    
-#if !Q0108_TSA_STSA
+#if SVC_EXTENSION && !Q0108_TSA_STSA
           if( pcSlice->getLayerId() > 0 )
           {
@@ -1563 +1627 @@
       }
     }
+
+    arrangeLongtermPicturesInRPS(pcSlice, rcListPic);
+    TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
+    refPicListModification->setRefPicListModificationFlagL0(0);
+    refPicListModification->setRefPicListModificationFlagL1(0);
+    pcSlice->setNumRefIdx(REF_PIC_LIST_0,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
+    pcSlice->setNumRefIdx(REF_PIC_LIST_1,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
+
+#if SVC_EXTENSION
+    if( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() )
+    {
+#if POC_RESET_FLAG || POC_RESET_IDC_ENCODER
+      if ( pocCurr > 0 && pcSlice->isRADL() && pcPic->getSlice(0)->getBaseColPic(pcPic->getSlice(0)->getInterLayerPredLayerIdc(0))->getSlice(0)->isRASL())
+#else
+      if (pcSlice->getPOC()>0  && pcSlice->isRADL() && pcPic->getSlice(0)->getBaseColPic(pcPic->getSlice(0)->getInterLayerPredLayerIdc(0))->getSlice(0)->isRASL())
+#endif
+      {
+        pcSlice->setActiveNumILRRefIdx(0);
+        pcSlice->setInterLayerPredEnabledFlag(0);
+      }
+      if( pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA )
+      {
+        pcSlice->setNumRefIdx(REF_PIC_LIST_0, pcSlice->getActiveNumILRRefIdx());
+        pcSlice->setNumRefIdx(REF_PIC_LIST_1, pcSlice->getActiveNumILRRefIdx());
+      }
+      else
+      {
+        pcSlice->setNumRefIdx(REF_PIC_LIST_0, pcSlice->getNumRefIdx(REF_PIC_LIST_0)+pcSlice->getActiveNumILRRefIdx());
+        pcSlice->setNumRefIdx(REF_PIC_LIST_1, pcSlice->getNumRefIdx(REF_PIC_LIST_1)+pcSlice->getActiveNumILRRefIdx());
+      }
+
+      // check for the reference pictures whether there is at least one either temporal picture or ILRP with sample prediction type
+      if( pcSlice->getNumRefIdx( REF_PIC_LIST_0 ) - pcSlice->getActiveNumILRRefIdx() == 0 && pcSlice->getNumRefIdx( REF_PIC_LIST_1 ) - pcSlice->getActiveNumILRRefIdx() == 0 )
+      {
+        Bool foundSamplePredPicture = false;                
+
+        for( Int i = 0; i < pcSlice->getActiveNumILRRefIdx(); i++ )
+        {
+          if( m_ppcTEncTop[m_layerId]->getSamplePredEnabledFlag( pcSlice->getVPS()->getRefLayerId( m_layerId, pcSlice->getInterLayerPredLayerIdc(i) ) ) )
+          {
+            foundSamplePredPicture = true;
+            break;
+          }
+        }
+
+        if( !foundSamplePredPicture )
+        {
+          pcSlice->setSliceType(I_SLICE);
+          pcSlice->setInterLayerPredEnabledFlag(0);
+          pcSlice->setActiveNumILRRefIdx(0);
+        }
+      }
+    }
+#endif //SVC_EXTENSION
+
 #if Q0108_TSA_STSA
-    else if( ( pcSlice->getTLayer() == 0 && pcSlice->getLayerId() > 0)    // only for enhancement layer and with temporal layer 0
-       && !( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N     
+   if( ( pcSlice->getTLayer() == 0 && pcSlice->getLayerId() > 0  )    // only for enhancement layer and with temporal layer 0
+     && !( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N     
           || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_R
           || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N
@@ -1576 +1695 @@
     {
         Bool isSTSA=true;
+        Bool isIntra=false;
+
+        for( Int i = 0; i < pcSlice->getLayerId(); i++)
+        {
+          TComList<TComPic *> *cListPic = m_ppcTEncTop[i]->getListPic();
+          TComPic *lowerLayerPic = pcSlice->getRefPic(*cListPic, pcSlice->getPOC());
+          if( lowerLayerPic && pcSlice->getVPS()->getDirectDependencyFlag(pcSlice->getLayerId(), i) )
+          {
+            if( lowerLayerPic->getSlice(0)->getSliceType() == I_SLICE)
+            { 
+              isIntra = true;
+            }
+          }
+        }
+
         for(Int ii=iGOPid+1; ii < m_pcCfg->getGOPSize() && isSTSA; ii++)
         {
@@ -1605 +1739 @@
           }
         }
-        if(isSTSA==true)
+        if(isSTSA==true && isIntra == false)
         {    
-#if !Q0108_TSA_STSA
-          if( pcSlice->getLayerId() > 0 )
-          {
-            Bool oneRefLayerSTSA = false, oneRefLayerNotSTSA = false;
-            for( Int i = 0; i < pcSlice->getLayerId(); i++)
-            {
-              TComList<TComPic *> *cListPic = m_ppcTEncTop[i]->getListPic();
-              TComPic *lowerLayerPic = pcSlice->getRefPic(*cListPic, pcSlice->getPOC());
-              if( lowerLayerPic && pcSlice->getVPS()->getDirectDependencyFlag(pcSlice->getLayerId(), i) )
-              {
-                if( ( lowerLayerPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_STSA_N ) ||
-                    ( lowerLayerPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_STSA_R ) 
-                  )
-                {
-                  if(pcSlice->getTemporalLayerNonReferenceFlag() )
-                  {
-                    pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_N);
-                  }
-                  else
-                  {
-                    pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_R );
-                  }
-                  oneRefLayerSTSA = true;
-                }
-                else
-                {
-                  oneRefLayerNotSTSA = true;
-                }
-              }
-            }
-            assert( !( oneRefLayerNotSTSA && oneRefLayerSTSA ) ); // Only one variable should be true - failure of this assert means
-                                                                  // that two independent reference layers that are not dependent on
-                                                                  // each other, but are reference for current layer have inconsistency
-            if( oneRefLayerNotSTSA /*&& !oneRefLayerSTSA*/ )          // No reference layer is STSA - set current as TRAIL
-            {
-              if(pcSlice->getTemporalLayerNonReferenceFlag() )
-              {
-                pcSlice->setNalUnitType( NAL_UNIT_CODED_SLICE_TRAIL_N );
-              }
-              else
-              {
-                pcSlice->setNalUnitType( NAL_UNIT_CODED_SLICE_TRAIL_R );
-              }
-            }
-            else  // This means there is no reference layer picture for current picture in this AU
-            {
-              if(pcSlice->getTemporalLayerNonReferenceFlag() )
-              {
-                pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_N);
-              }
-              else
-              {
-                pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_R );
-              }
-            }
-          }
-#else
           if(pcSlice->getTemporalLayerNonReferenceFlag())
           {
             pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_N);
-            flagTSTA = 1;
           }
           else
           {
             pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_R);
-            flagTSTA = 1;
-          }
-#endif
-        }
-    }
-#endif
-
-    arrangeLongtermPicturesInRPS(pcSlice, rcListPic);
-    TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
-    refPicListModification->setRefPicListModificationFlagL0(0);
-    refPicListModification->setRefPicListModificationFlagL1(0);
-    pcSlice->setNumRefIdx(REF_PIC_LIST_0,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
-    pcSlice->setNumRefIdx(REF_PIC_LIST_1,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
-
-#if SVC_EXTENSION
-    if( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() )
-    {
-#if POC_RESET_FLAG || POC_RESET_IDC_ENCODER
-      if ( pocCurr > 0 && pcSlice->isRADL() && pcPic->getSlice(0)->getBaseColPic(pcPic->getSlice(0)->getInterLayerPredLayerIdc(0))->getSlice(0)->isRASL())
-#else
-      if (pcSlice->getPOC()>0  && pcSlice->isRADL() && pcPic->getSlice(0)->getBaseColPic(pcPic->getSlice(0)->getInterLayerPredLayerIdc(0))->getSlice(0)->isRASL())
-#endif
-      {
-        pcSlice->setActiveNumILRRefIdx(0);
-        pcSlice->setInterLayerPredEnabledFlag(0);
-      }
-#if Q0108_TSA_STSA
-     if( ( pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA ) || flagTSTA == 1 )
-#else
-     if( pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA )
-#endif
-      {
-        pcSlice->setNumRefIdx(REF_PIC_LIST_0, pcSlice->getActiveNumILRRefIdx());
-        pcSlice->setNumRefIdx(REF_PIC_LIST_1, pcSlice->getActiveNumILRRefIdx());
-      }
-      else
-      {
-        pcSlice->setNumRefIdx(REF_PIC_LIST_0, pcSlice->getNumRefIdx(REF_PIC_LIST_0)+pcSlice->getActiveNumILRRefIdx());
-        pcSlice->setNumRefIdx(REF_PIC_LIST_1, pcSlice->getNumRefIdx(REF_PIC_LIST_1)+pcSlice->getActiveNumILRRefIdx());
-      }
-
-      // check for the reference pictures whether there is at least one either temporal picture or ILRP with sample prediction type
-      if( pcSlice->getNumRefIdx( REF_PIC_LIST_0 ) - pcSlice->getActiveNumILRRefIdx() == 0 && pcSlice->getNumRefIdx( REF_PIC_LIST_1 ) - pcSlice->getActiveNumILRRefIdx() == 0 )
-      {
-        Bool foundSamplePredPicture = false;                
-
-        for( Int i = 0; i < pcSlice->getActiveNumILRRefIdx(); i++ )
-        {
-          if( m_ppcTEncTop[m_layerId]->getSamplePredEnabledFlag( pcSlice->getVPS()->getRefLayerId( m_layerId, pcSlice->getInterLayerPredLayerIdc(i) ) ) )
-          {
-            foundSamplePredPicture = true;
-            break;
-          }
-        }
-
-        if( !foundSamplePredPicture )
-        {
-          pcSlice->setSliceType(I_SLICE);
-          pcSlice->setInterLayerPredEnabledFlag(0);
-          pcSlice->setActiveNumILRRefIdx(0);
-        }
-      }
-    }
-#endif //SVC_EXTENSION
+          }
+        }
+    }
+#endif
 
 #if ADAPTIVE_QP_SELECTION
@@ -1750 +1766 @@
     if(m_layerId ==  0 || ( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() == 0 ) )
     {
-      pcSlice->setRefPicList( rcListPic);
+      pcSlice->setRefPicList( rcListPic );
     }
 
@@ -1756 +1772 @@
     {
       pcSlice->setILRPic( m_pcEncTop->getIlpList() );
-#if REF_IDX_MFM
-      if( pcSlice->getMFMEnabledFlag() )
-      {
-        pcSlice->setRefPOCListILP(m_pcEncTop->getIlpList(), pcSlice->getBaseColPic());
-      }
-#else
+#if !REF_IDX_MFM
       //  Set reference list
       pcSlice->setRefPicList ( rcListPic );
@@ -2110 +2121 @@
     UInt uiRealEndAddress = uiExternalAddress*pcPic->getNumPartInCU()+uiInternalAddress;
 
-    UInt uiCummulativeTileWidth;
-    UInt uiCummulativeTileHeight;
     Int  p, j;
     UInt uiEncCUAddr;
 
-    //set NumColumnsMinus1 and NumRowsMinus1
-    pcPic->getPicSym()->setNumColumnsMinus1( pcSlice->getPPS()->getNumColumnsMinus1() );
-    pcPic->getPicSym()->setNumRowsMinus1( pcSlice->getPPS()->getNumRowsMinus1() );
-
-    //create the TComTileArray
-    pcPic->getPicSym()->xCreateTComTileArray();
-
-    if( pcSlice->getPPS()->getUniformSpacingFlag() == 1 )
-    {
-      //set the width for each tile
-      for(j=0; j < pcPic->getPicSym()->getNumRowsMinus1()+1; j++)
-      {
-        for(p=0; p < pcPic->getPicSym()->getNumColumnsMinus1()+1; p++)
-        {
-          pcPic->getPicSym()->getTComTile( j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p )->
-            setTileWidth( (p+1)*pcPic->getPicSym()->getFrameWidthInCU()/(pcPic->getPicSym()->getNumColumnsMinus1()+1) 
-            - (p*pcPic->getPicSym()->getFrameWidthInCU())/(pcPic->getPicSym()->getNumColumnsMinus1()+1) );
-        }
-      }
-
-      //set the height for each tile
-      for(j=0; j < pcPic->getPicSym()->getNumColumnsMinus1()+1; j++)
-      {
-        for(p=0; p < pcPic->getPicSym()->getNumRowsMinus1()+1; p++)
-        {
-          pcPic->getPicSym()->getTComTile( p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j )->
-            setTileHeight( (p+1)*pcPic->getPicSym()->getFrameHeightInCU()/(pcPic->getPicSym()->getNumRowsMinus1()+1) 
-            - (p*pcPic->getPicSym()->getFrameHeightInCU())/(pcPic->getPicSym()->getNumRowsMinus1()+1) );   
-        }
-      }
-    }
-    else
-    {
-      //set the width for each tile
-      for(j=0; j < pcPic->getPicSym()->getNumRowsMinus1()+1; j++)
-      {
-        uiCummulativeTileWidth = 0;
-        for(p=0; p < pcPic->getPicSym()->getNumColumnsMinus1(); p++)
-        {
-          pcPic->getPicSym()->getTComTile( j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p )->setTileWidth( pcSlice->getPPS()->getColumnWidth(p) );
-          uiCummulativeTileWidth += pcSlice->getPPS()->getColumnWidth(p);
-        }
-        pcPic->getPicSym()->getTComTile(j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p)->setTileWidth( pcPic->getPicSym()->getFrameWidthInCU()-uiCummulativeTileWidth );
-      }
-
-      //set the height for each tile
-      for(j=0; j < pcPic->getPicSym()->getNumColumnsMinus1()+1; j++)
-      {
-        uiCummulativeTileHeight = 0;
-        for(p=0; p < pcPic->getPicSym()->getNumRowsMinus1(); p++)
-        {
-          pcPic->getPicSym()->getTComTile( p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j )->setTileHeight( pcSlice->getPPS()->getRowHeight(p) );
-          uiCummulativeTileHeight += pcSlice->getPPS()->getRowHeight(p);
-        }
-        pcPic->getPicSym()->getTComTile(p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j)->setTileHeight( pcPic->getPicSym()->getFrameHeightInCU()-uiCummulativeTileHeight );
-      }
-    }
-    //intialize each tile of the current picture
-    pcPic->getPicSym()->xInitTiles();
+    pcPic->getPicSym()->initTiles(pcSlice->getPPS());
 
 #if N0383_IL_CONSTRAINED_TILE_SETS_SEI
@@ -2183 +2134 @@
 
     // Allocate some coders, now we know how many tiles there are.
+#if WPP_FIX
+    const Int iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
+#else
     Int iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
+#endif
 
     //generate the Coding Order Map and Inverse Coding Order Map
@@ -2215 +2170 @@
     startCUAddrSliceSegmentIdx++;
 #if AVC_BASE
+#if VPS_AVC_BL_FLAG_REMOVAL
+    if( m_layerId == 0 && m_pcEncTop->getVPS()->getNonHEVCBaseLayerFlag() )
+#else
     if( m_layerId == 0 && m_pcEncTop->getVPS()->getAvcBaseLayerFlag() )
+#endif
     {
       pcPic->getPicYuvOrg()->copyToPic( pcPic->getPicYuvRec() );
@@ -2225 +2184 @@
       }
 #endif
-#if AVC_SYNTAX
-      pcPic->readBLSyntax( m_ppcTEncTop[0]->getBLSyntaxFile(), SYNTAX_BYTES );
-#endif
+
+      if( pcSubstreamsOut )
+      {
+        delete[] pcSubstreamsOut;
+        pcSubstreamsOut = NULL;
+      }
+
+      if( pcBitstreamRedirect )
+      {
+        delete pcBitstreamRedirect;
+        pcBitstreamRedirect = NULL;
+      }
+
       return;
     }
@@ -2318 +2287 @@
       OutputNALUnit nalu( NAL_UNIT_VPS, 0, 0 ); // The value of nuh_layer_id of VPS NAL unit shall be equal to 0.
 #if AVC_BASE
+#if VPS_AVC_BL_FLAG_REMOVAL
+      if( ( m_layerId == 1 && m_pcEncTop->getVPS()->getNonHEVCBaseLayerFlag() ) || ( m_layerId == 0 && !m_pcEncTop->getVPS()->getNonHEVCBaseLayerFlag() ) )
+#else
       if( ( m_layerId == 1 && m_pcEncTop->getVPS()->getAvcBaseLayerFlag() ) || ( m_layerId == 0 && !m_pcEncTop->getVPS()->getAvcBaseLayerFlag() ) )
+#endif
 #else
       if( m_layerId == 0 )
@@ -2418 +2391 @@
       if (pcSlice->getLayerId() == 0 && m_pcEncTop->getVPS()->getVpsVuiBspHrdPresentFlag())
       {
-        nalu = NALUnit(NAL_UNIT_PREFIX_SEI, 0, 1);
-        m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
-        m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-        SEIScalableNesting *scalableBspNestingSei = xCreateBspNestingSEI(pcSlice);
-        m_seiWriter.writeSEImessage(nalu.m_Bitstream, *scalableBspNestingSei, m_pcEncTop->getVPS(), pcSlice->getSPS());
-        writeRBSPTrailingBits(nalu.m_Bitstream);
-
-        UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
-        UInt offsetPosition = m_activeParameterSetSEIPresentInAU 
-          + m_bufferingPeriodSEIPresentInAU 
-          + m_pictureTimingSEIPresentInAU
-          + m_nestedPictureTimingSEIPresentInAU;  // Insert SEI after APS, BP and PT SEI
-        AccessUnit::iterator it;
-        for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
-        {
-          it++;
-        }
-        accessUnit.insert(it, new NALUnitEBSP(nalu));
+#if VPS_VUI_BSP_HRD_PARAMS
+        TComVPS *vps = m_pcEncTop->getVPS();
+        for(Int i = 0; i < vps->getNumOutputLayerSets(); i++)
+        {
+          for(Int k = 0; k < vps->getNumSignalledPartitioningSchemes(i); k++)
+          {
+            for(Int l = 0; l < vps->getNumPartitionsInSchemeMinus1(i, k)+1; l++)
+            {
+#endif
+              nalu = NALUnit(NAL_UNIT_PREFIX_SEI, 0, 1);
+              m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
+              m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
+#if VPS_VUI_BSP_HRD_PARAMS
+              SEIScalableNesting *scalableBspNestingSei = xCreateBspNestingSEI(pcSlice, i, k, l);
+#else
+              SEIScalableNesting *scalableBspNestingSei = xCreateBspNestingSEI(pcSlice);
+#endif
+              m_seiWriter.writeSEImessage(nalu.m_Bitstream, *scalableBspNestingSei, m_pcEncTop->getVPS(), pcSlice->getSPS());
+              writeRBSPTrailingBits(nalu.m_Bitstream);
+
+              UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
+              UInt offsetPosition = m_activeParameterSetSEIPresentInAU 
+                + m_bufferingPeriodSEIPresentInAU 
+                + m_pictureTimingSEIPresentInAU
+                + m_nestedPictureTimingSEIPresentInAU;  // Insert SEI after APS, BP and PT SEI
+              AccessUnit::iterator it;
+              for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
+              {
+                it++;
+              }
+              accessUnit.insert(it, new NALUnitEBSP(nalu));
+#if VPS_VUI_BSP_HRD_PARAMS
+            }
+          }
+        }
+#endif
       }
 #endif
@@ -2842 +2833 @@
 
 #if SETTING_NO_OUT_PIC_PRIOR
+          pcSlice->setNoRaslOutputFlag(false);
           if (pcSlice->isIRAP())
           {
@@ -2849 +2841 @@
             }
             //the inference for NoOutputPriorPicsFlag
+            // KJS: This cannot happen at the encoder
             if (!m_bFirst && pcSlice->isIRAP() && pcSlice->getNoRaslOutputFlag())
             {
@@ -2876 +2869 @@
             m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
             m_pcEntropyCoder->resetEntropy    ();
+#if WPP_FIX
+            for ( UInt ui = 0 ; ui < iNumSubstreams ; ui++ ) 
+#else
             for ( UInt ui = 0 ; ui < pcSlice->getPPS()->getNumSubstreams() ; ui++ )
+#endif
             {
               m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[ui], pcSlice );
@@ -2888 +2885 @@
             m_pcSbacCoder->init( (TEncBinIf*)m_pcBinCABAC );
             {
+#if WPP_FIX
+              for ( UInt ui = 0 ; ui < iNumSubstreams ; ui++ )
+#else
               for ( UInt ui = 0 ; ui < pcSlice->getPPS()->getNumSubstreams() ; ui++ )
+#endif
               {
                 m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[ui], pcSlice );
@@ -2915 +2916 @@
 
           pcSlice->setTileOffstForMultES( uiOneBitstreamPerSliceLength );
-            pcSlice->setTileLocationCount ( 0 );
+          pcSlice->setTileLocationCount ( 0 );
           m_pcSliceEncoder->encodeSlice(pcPic, pcSubstreamsOut);
 
@@ -2942 +2943 @@
 
               Bool bNextSubstreamInNewTile = ((ui+1) < iNumSubstreams)&& ((ui+1)%uiNumSubstreamsPerTile == 0);
+#if WPP_FIX
+              if (bNextSubstreamInNewTile &&  !pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag() ) 
+#else
               if (bNextSubstreamInNewTile)
+#endif
               {
                 pcSlice->setTileLocation(ui/uiNumSubstreamsPerTile, pcSlice->getTileOffstForMultES()+(uiTotalCodedSize>>3));
               }
+#if WPP_FIX
+              if (ui+1 < iNumSubstreams)
+              {
+                puiSubstreamSizes[ui] = pcSubstreamsOut[ui].getNumberOfWrittenBits() + (pcSubstreamsOut[ui].countStartCodeEmulations()<<3);
+              }
+#else
               if (ui+1 < pcSlice->getPPS()->getNumSubstreams())
               {
                 puiSubstreamSizes[ui] = pcSubstreamsOut[ui].getNumberOfWrittenBits() + (pcSubstreamsOut[ui].countStartCodeEmulations()<<3);
               }
+#endif
             }
 
@@ -2966 +2978 @@
             // Substreams...
             TComOutputBitstream *pcOut = pcBitstreamRedirect;
-          Int offs = 0;
+#if WPP_FIX 
+            Int numZeroSubstreamsAtStartOfSlice = 0; 
+            Int numSubstreamsToCode = pcSlice->getPPS()->getNumSubstreams(); 
+            if (pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag()) 
+            { 
+              Int  maxNumParts                      = pcPic->getNumPartInCU(); 
+              numZeroSubstreamsAtStartOfSlice  = pcPic->getSubstreamForLCUAddr(pcSlice->getSliceSegmentCurStartCUAddr()/maxNumParts, false, pcSlice); 
+              // 1st line present for WPP. 
+              numSubstreamsToCode  = pcSlice->getNumEntryPointOffsets()+1; 
+            } 
+            for ( UInt ui = 0 ; ui < numSubstreamsToCode; ui++ ) 
+            { 
+              pcOut->addSubstream(&pcSubstreamsOut[ui+numZeroSubstreamsAtStartOfSlice]); 
+            } 
+#else 
+            Int offs = 0;
           Int nss = pcSlice->getPPS()->getNumSubstreams();
           if (pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag())
@@ -2978 +3005 @@
             pcOut->addSubstream(&pcSubstreamsOut[ui+offs]);
             }
+#endif
           }
 
@@ -3396 +3424 @@
       pcPicYuvRecOut->setReconstructed(true);
 #endif
-
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+      m_pcEncTop->setFirstPicInLayerDecodedFlag(true);
+#endif
       pcPic->setReconMark   ( true );
       m_bFirst = false;
@@ -3455 +3485 @@
   // If BL picture in the AU is IDR, and another picture is not IDR, set the poc_reset_idc to 2
   // If BL picture is IRAP, and another picture is non-IRAP, then the poc_reset_idc is equal to 1 or 2.
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  slice->setPocMsbNeeded(false);
+#endif
   if( slice->getSliceIdx() == 0 ) // First slice - compute, copy for other slices
   {
@@ -3514 +3547 @@
         {
           slice->setPocResetIdc( 2 ); // Full reset needed
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+          if (slice->getVPS()->getVpsPocLsbAlignedFlag() && slice->getVPS()->getNumDirectRefLayers(slice->getLayerId()) == 0)
+          {
+            slice->setPocMsbNeeded(true);  // Force msb writing
+          }
+#endif
         }
         else
@@ -3530 +3569 @@
         Int periodId = rand() % 64;
         m_lastPocPeriodId = (periodId == m_lastPocPeriodId) ? (periodId + 1) % 64 : periodId ;
+
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+        for (UInt i = 0; i < MAX_LAYERS; i++)
+        {
+          m_ppcTEncTop[i]->setPocDecrementedInDPBFlag(false);
+        }
+#endif
       }
       else
@@ -3546 +3592 @@
 Void TEncGOP::updatePocValuesOfPics(Int const pocCurr, TComSlice *const slice)
 {
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  UInt affectedLayerList[MAX_NUM_LAYER_IDS];
+  Int  numAffectedLayers;
+
+  affectedLayerList[0] = m_layerId;
+  numAffectedLayers = 1;
+
+  if (m_pcEncTop->getVPS()->getVpsPocLsbAlignedFlag())
+  {
+    for (UInt j = 0; j < m_pcEncTop->getVPS()->getNumPredictedLayers(m_layerId); j++)
+    {
+      affectedLayerList[j + 1] = m_pcEncTop->getVPS()->getPredictedLayerId(m_layerId, j);
+    }
+    numAffectedLayers = m_pcEncTop->getVPS()->getNumPredictedLayers(m_layerId) + 1;
+  }
+#endif
 
   Int pocAdjustValue = pocCurr - m_pcEncTop->getPocAdjustmentValue();
@@ -3553 +3615 @@
 
   maxPocLsb   = 1 << slice->getSPS()->getBitsForPOC();
+
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  Int adjustedPocValue = pocCurr;
+
+  if (m_pcEncTop->getFirstPicInLayerDecodedFlag())
+  {
+#endif
+
   pocLsbVal   = (slice->getPocResetIdc() == 3)
                 ? slice->getPocLsbVal()
@@ -3561 +3631 @@
                 : 0; 
   deltaPocVal = pocMsbDelta  + pocLsbDelta;
-  
+
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  Int origDeltaPocVal = deltaPocVal;  // original value needed when updating POC adjustment value
+
+  if (slice->getPocMsbNeeded())  // IDR picture in base layer, non-IDR picture in other layers, poc_lsb_aligned_flag = 1
+  {
+    if (slice->getLayerId() == 0)
+    {
+      Int highestPoc = INT_MIN;
+      // Find greatest POC in DPB for layer 0
+      for (TComList<TComPic*>::iterator iterPic = m_pcEncTop->getListPic()->begin(); iterPic != m_pcEncTop->getListPic()->end(); ++iterPic)
+      {
+        TComPic *dpbPic = *iterPic;
+        if (dpbPic->getReconMark() && dpbPic->getLayerId() == 0 && dpbPic->getPOC() > highestPoc)
+        {
+          highestPoc = dpbPic->getPOC();
+        }
+      }
+      deltaPocVal = (highestPoc - (highestPoc & (maxPocLsb - 1))) + 1*maxPocLsb;
+      m_pcEncTop->setCurrPocMsb(deltaPocVal);
+    }
+    else
+    {
+      deltaPocVal = m_ppcTEncTop[0]->getCurrPocMsb();  // copy from base layer
+    }
+    slice->setPocMsbVal(deltaPocVal);
+  }
+#endif
+
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  for (UInt layerIdx = 0; layerIdx < numAffectedLayers; layerIdx++)
+  {
+    if (!m_ppcTEncTop[affectedLayerList[layerIdx]]->getPocDecrementedInDPBFlag())
+    {
+      m_ppcTEncTop[affectedLayerList[layerIdx]]->setPocDecrementedInDPBFlag(true);
+
+      // Decrement value of associatedIrapPoc of the TEncGop object
+      m_ppcTEncTop[affectedLayerList[layerIdx]]->getGOPEncoder()->m_associatedIRAPPOC -= deltaPocVal;
+
+      // Decrememnt the value of m_pocCRA
+      m_ppcTEncTop[affectedLayerList[layerIdx]]->getGOPEncoder()->m_pocCRA -= deltaPocVal;
+
+      TComList<TComPic*>::iterator  iterPic = m_ppcTEncTop[affectedLayerList[layerIdx]]->getListPic()->begin();
+      while (iterPic != m_ppcTEncTop[affectedLayerList[layerIdx]]->getListPic()->end())
+#else
   // Decrement value of associatedIrapPoc of the TEncGop object
   this->m_associatedIRAPPOC -= deltaPocVal;
@@ -3571 +3685 @@
   TComList<TComPic*>::iterator  iterPic = getListPic()->begin();  
   while( iterPic != getListPic()->end() )
+#endif
   {
     TComPic *dpbPic = *iterPic;
@@ -3595 +3710 @@
         // Update value of associatedIrapPoc of each slice
         dpbPicSlice->setAssociatedIRAPPOC( dpbPicSlice->getAssociatedIRAPPOC() - deltaPocVal );
+
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+        if (slice->getPocMsbNeeded())
+        {
+          // this delta value is needed when computing delta POCs in reference picture set initialization
+          dpbPicSlice->setPocResetDeltaPoc(dpbPicSlice->getPocResetDeltaPoc() + (deltaPocVal - pocLsbVal));
+        }
+#endif
       }
     }
     iterPic++;
   }
-  
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+    }
+  }
+#endif
+
   // Actual POC value before reset
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  adjustedPocValue = pocCurr - m_pcEncTop->getPocAdjustmentValue();
+#else
   Int adjustedPocValue = pocCurr - m_pcEncTop->getPocAdjustmentValue();
+#endif
 
   // Set MSB value before reset
   Int tempLsbVal = adjustedPocValue & (maxPocLsb - 1);
-  slice->setPocMsbVal( adjustedPocValue - tempLsbVal);
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  if (!slice->getPocMsbNeeded())  // set poc msb normally if special msb handling is not needed
+  {
+#endif
+    slice->setPocMsbVal(adjustedPocValue - tempLsbVal);
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  }
+#endif
 
   // Set LSB value before reset - this is needed in the case of resetIdc = 2
@@ -3611 +3749 @@
 
   // Cumulative delta
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  deltaPocVal = origDeltaPocVal;  // restore deltaPoc for correct adjustment value update
+#endif
   m_pcEncTop->setPocAdjustmentValue( m_pcEncTop->getPocAdjustmentValue() + deltaPocVal );
+
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  }
+#endif
 
   // New LSB value, after reset
@@ -3738 +3883 @@
   assert (m_iGopSize > 0);
   
-  return;
-}
-
-Void TEncGOP::xInitGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut )
-{
-  assert( iNumPicRcvd > 0 );
-  //  Exception for the first frame
-  if ( iPOCLast == 0 )
-  {
-    m_iGopSize    = 1;
-  }
-  else
-    m_iGopSize    = m_pcCfg->getGOPSize();
-  
-  assert (m_iGopSize > 0); 
-
   return;
 }
@@ -4090 +4219 @@
       {
 #if POC_RESET_IDC_ENCODER
-        printf( "%d(%d)", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex), pcSlice->getRefPic(RefPicList(iRefList), iRefIndex)->getLayerId() );
+        UInt refLayerId = pcSlice->getRefPic(RefPicList(iRefList), iRefIndex)->getLayerId();
+        UInt refLayerIdc = pcSlice->getReferenceLayerIdc(refLayerId);
+        assert( g_posScalingFactor[refLayerIdc][0] );
+        assert( g_posScalingFactor[refLayerIdc][1] );
+
+        printf( "%d(%d, {%1.2f, %1.2f}x)", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex), refLayerId, 65536.0/g_posScalingFactor[refLayerIdc][0], 65536.0/g_posScalingFactor[refLayerIdc][1] );
 #else
         printf( "%d(%d)", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex)-pcSlice->getLastIDR(), pcSlice->getRefPic(RefPicList(iRefList), iRefIndex)->getLayerId() );
@@ -4120 +4254 @@
   if( m_layerId && pcSlice->getPPS()->getCGSFlag() )
   {
+#if R0179_ENC_OPT_3DLUT_SIZE
+      m_Enc3DAsymLUTPicUpdate.update3DAsymLUTParam( &m_Enc3DAsymLUTPPS );
+#else
+    if( m_Enc3DAsymLUTPPS.getPPSBit() > 0 )
+      m_Enc3DAsymLUTPicUpdate.copy3DAsymLUT( &m_Enc3DAsymLUTPPS );
+#endif
     m_Enc3DAsymLUTPicUpdate.updatePicCGSBits( pcSlice , m_Enc3DAsymLUTPPS.getPPSBit() );
   }
@@ -4771 +4911 @@
 
 #if O0164_MULTI_LAYER_HRD
+#if VPS_VUI_BSP_HRD_PARAMS
+SEIScalableNesting* TEncGOP::xCreateBspNestingSEI(TComSlice *pcSlice, Int olsIdx, Int partitioningSchemeIdx, Int bspIdx)
+#else
 SEIScalableNesting* TEncGOP::xCreateBspNestingSEI(TComSlice *pcSlice)
+#endif
 {
   SEIScalableNesting *seiScalableNesting = new SEIScalableNesting();
@@ -4784 +4928 @@
   seiScalableNesting->m_defaultOpFlag                 = 0;
   seiScalableNesting->m_nestingNumOpsMinus1           = 0;      //nesting_num_ops_minus1
+#if VPS_VUI_BSP_HRD_PARAMS
+  seiScalableNesting->m_nestingOpIdx[0]               = pcSlice->getVPS()->getOutputLayerSetIdx(olsIdx);
+  seiScalableNesting->m_nestingMaxTemporalIdPlus1[0]  = 6 + 1;
+#else
   seiScalableNesting->m_nestingOpIdx[0]               = 1;
+#endif
   seiScalableNesting->m_allLayersFlag                 = 0;
   seiScalableNesting->m_nestingNoOpMaxTemporalIdPlus1 = 6 + 1;  //nesting_no_op_max_temporal_id_plus1
@@ -4830 +4979 @@
   seiBspNesting->m_nestedSEIs.push_back(seiBufferingPeriod);
   seiBspNesting->m_nestedSEIs.push_back(seiBspInitialArrivalTime);
+#if VPS_VUI_BSP_HRD_PARAMS
+  seiBspNesting->m_bspIdx = bspIdx;
+  seiBspNesting->m_seiOlsIdx = olsIdx;
+  seiBspNesting->m_seiPartitioningSchemeIdx = partitioningSchemeIdx;
+#endif
   seiScalableNesting->m_nestedSEIs.push_back(seiBspNesting); // BSP nesting SEI is contained in scalable nesting SEI
 
@@ -4842 +4996 @@
   m_Enc3DAsymLUTPPS.setPPSBit( 0 );
   Double dErrorUpdatedPPS = 0 , dErrorPPS = 0;
-  dErrorUpdatedPPS = m_Enc3DAsymLUTPicUpdate.derive3DAsymLUT( pSlice , pCurPic , refLayerIdc , pCfg , bSignalPPS , m_pcEncTop->getElRapSliceTypeB() );
+
+#if R0179_ENC_OPT_3DLUT_SIZE
+  Int nTLthres = m_pcCfg->getCGSLutSizeRDO() ? 2:7;
+  Double dFrameLambda; 
+#if FULL_NBIT
+  Int    SHIFT_QP = 12 + 6 * (pSlice->getBitDepthY() - 8);
+#else
+  Int    SHIFT_QP = 12; 
+#endif 
+  Int QP = pSlice->getSliceQp();
+
+  // set frame lambda
+  dFrameLambda = 0.68 * pow (2, (QP  - SHIFT_QP) / 3.0) * (m_pcCfg->getGOPSize() > 1 && pSlice->isInterB()? 2 : 1);
+
+  if(m_pcCfg->getCGSLutSizeRDO() == 1 && (!bSignalPPS && (pSlice->getDepth() < nTLthres))) 
+    dErrorUpdatedPPS = m_Enc3DAsymLUTPicUpdate.derive3DAsymLUT( pSlice , pCurPic , refLayerIdc , pCfg , bSignalPPS , m_pcEncTop->getElRapSliceTypeB(), dFrameLambda );
+  else if (pSlice->getDepth() >= nTLthres)
+    dErrorUpdatedPPS = MAX_DOUBLE;
+  else // if (m_pcCfg->getCGSLutSizeRDO() = 0 || bSignalPPS)
+#endif   
+    dErrorUpdatedPPS = m_Enc3DAsymLUTPicUpdate.derive3DAsymLUT( pSlice , pCurPic , refLayerIdc , pCfg , bSignalPPS , m_pcEncTop->getElRapSliceTypeB() );
+
+
   if( bSignalPPS )
   {
@@ -4850 +5026 @@
   else if( nCGSFlag )
   {
-    dErrorPPS = m_Enc3DAsymLUTPPS.estimateDistWithCur3DAsymLUT( pCurPic , refLayerIdc );
-    Double dFactor = pCfg->getIntraPeriod() == 1 ? 0.99 : 0.9;
-    pSlice->setCGSOverWritePPS( dErrorUpdatedPPS < dFactor * dErrorPPS );
+#if R0179_ENC_OPT_3DLUT_SIZE
+    if(pSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_R || pSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N) 
+    {
+      pSlice->setCGSOverWritePPS( 0 ); 
+    }
+    else if (pSlice->getDepth() >= nTLthres) 
+    {
+      pSlice->setCGSOverWritePPS( 0 ); 
+    }
+    else
+    {
+#endif    
+      dErrorPPS = m_Enc3DAsymLUTPPS.estimateDistWithCur3DAsymLUT( pCurPic , refLayerIdc );
+      Double dFactor = pCfg->getIntraPeriod() == 1 ? 0.99 : 0.9;
+
+#if R0179_ENC_OPT_3DLUT_SIZE 
+      if( m_pcCfg->getCGSLutSizeRDO() )
+      {
+        dErrorPPS = dErrorPPS/m_Enc3DAsymLUTPicUpdate.getDistFactor(pSlice->getSliceType(), pSlice->getDepth()); 
+      }
+#endif
+      pSlice->setCGSOverWritePPS( dErrorUpdatedPPS < dFactor * dErrorPPS );
+#if R0179_ENC_OPT_3DLUT_SIZE
+    }
+#endif
     if( pSlice->getCGSOverWritePPS() )
     {

trunk/source/Lib/TLibEncoder/TEncGOP.h

@@ -207 +207 @@
 protected:
   
-  Void xInitGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, Bool isField );
-  Void  xInitGOP          ( Int iPOC, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut );
-  Void  xGetBuffer        ( TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, Int iNumPicRcvd, Int iTimeOffset, TComPic*& rpcPic, TComPicYuv*& rpcPicYuvRecOut, Int pocCurr, Bool isField );
+  Void  xInitGOP          ( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, bool isField );
+  Void  xGetBuffer        ( TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, Int iNumPicRcvd, Int iTimeOffset, TComPic*& rpcPic, TComPicYuv*& rpcPicYuvRecOut, Int pocCurr, bool isField );
   
   Void  xCalculateAddPSNR ( TComPic* pcPic, TComPicYuv* pcPicD, const AccessUnit&, Double dEncTime );
@@ -226 +225 @@
   SEIKneeFunctionInfo*    xCreateSEIKneeFunctionInfo();
 #endif
-#if Q0074_SEI_COLOR_MAPPING
-  SEIColorMappingInfo*    xCreateSEIColorMappingInfo( Char* file );
+#if Q0074_COLOUR_REMAPPING_SEI
+  SEIColourRemappingInfo* xCreateSEIColourRemappingInfo();
 #endif
 
@@ -254 +253 @@
 #endif
 #if O0164_MULTI_LAYER_HRD
+#if VPS_VUI_BSP_HRD_PARAMS
+  SEIScalableNesting* xCreateBspNestingSEI(TComSlice *pcSlice, Int olsIdx, Int partitioningSchemeIdx, Int bspIdx);
+#else
   SEIScalableNesting* xCreateBspNestingSEI(TComSlice *pcSlice);
+#endif
 #endif
 #if Q0048_CGS_3D_ASYMLUT

trunk/source/Lib/TLibEncoder/TEncSearch.cpp

@@ -4896 +4896 @@
     if( bCodeChroma )
     {
+      m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
+      m_pcEntropyCoder->resetBits();
       m_pcEntropyCoder->encodeQtCbf   ( pcCU, uiAbsPartIdx, TEXT_CHROMA_U, uiTrMode );
       m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrU, uiAbsPartIdx, trWidthC, trHeightC, uiDepth, TEXT_CHROMA_U );
-      uiSingleBitsU = m_pcEntropyCoder->getNumberOfWrittenBits() - uiSingleBitsY;
+      uiSingleBitsU = m_pcEntropyCoder->getNumberOfWrittenBits();
       
+      m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
+      m_pcEntropyCoder->resetBits();
       m_pcEntropyCoder->encodeQtCbf   ( pcCU, uiAbsPartIdx, TEXT_CHROMA_V, uiTrMode );
       m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrV, uiAbsPartIdx, trWidthC, trHeightC, uiDepth, TEXT_CHROMA_V );
-      uiSingleBitsV = m_pcEntropyCoder->getNumberOfWrittenBits() - ( uiSingleBitsY + uiSingleBitsU );
+      uiSingleBitsV = m_pcEntropyCoder->getNumberOfWrittenBits();
     }
     
@@ -4939 +4943 @@
       {
         const Double singleCostY = m_pcRdCost->calcRdCost( uiSingleBitsY, uiNonzeroDistY );
+        m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
         m_pcEntropyCoder->resetBits();
         m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_LUMA,     uiTrMode );
@@ -4964 +4969 @@
     else if( checkTransformSkipY )
     {
+      m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
       m_pcEntropyCoder->resetBits();
       m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_LUMA, uiTrMode );
@@ -5015 +5021 @@
         {
           const Double dSingleCostU = m_pcRdCost->calcRdCost( uiSingleBitsU, uiNonzeroDistU );
+          m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
           m_pcEntropyCoder->resetBits();
           m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_CHROMA_U,     uiTrMode );
@@ -5040 +5047 @@
       else if( checkTransformSkipUV )
       {
+        m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
         m_pcEntropyCoder->resetBits();
         m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_CHROMA_U, uiTrMode );
@@ -5084 +5092 @@
         {
           const Double dSingleCostV = m_pcRdCost->calcRdCost( uiSingleBitsV, uiNonzeroDistV );
+          m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
           m_pcEntropyCoder->resetBits();
           m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_CHROMA_V,     uiTrMode );
@@ -5109 +5118 @@
       else if( checkTransformSkipUV )
       {
+        m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
         m_pcEntropyCoder->resetBits();
         m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_CHROMA_V, uiTrMode );
@@ -5287 +5297 @@
       pcCU->setCbfSubParts( uiAbsSumTransformSkipV ? uiSetCbf : 0, TEXT_CHROMA_V, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC );
 
-      m_pcEntropyCoder->resetBits();
       uiSingleBitsU = 0;
       uiSingleBitsV = 0;
@@ -5293 +5302 @@
       if( uiAbsSumTransformSkipU )
       {
+        m_pcEntropyCoder->resetBits();
         m_pcEntropyCoder->encodeQtCbf   ( pcCU, uiAbsPartIdx, TEXT_CHROMA_U, uiTrMode );
         m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrU, uiAbsPartIdx, trWidthC, trHeightC, uiDepth, TEXT_CHROMA_U );
@@ -5335 +5345 @@
       if( uiAbsSumTransformSkipV )
       {
+        m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
+        m_pcEntropyCoder->resetBits();
         m_pcEntropyCoder->encodeQtCbf   ( pcCU, uiAbsPartIdx, TEXT_CHROMA_V, uiTrMode );
         m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrV, uiAbsPartIdx, trWidthC, trHeightC, uiDepth, TEXT_CHROMA_V );
-        uiSingleBitsV = m_pcEntropyCoder->getNumberOfWrittenBits() - uiSingleBitsU;
+        uiSingleBitsV = m_pcEntropyCoder->getNumberOfWrittenBits();
 
         curChromaQpOffset = pcCU->getSlice()->getPPS()->getChromaCrQpOffset() + pcCU->getSlice()->getSliceQpDeltaCr();

trunk/source/Lib/TLibEncoder/TEncSlice.cpp

@@ -836 +836 @@
 Void TEncSlice::compressSlice( TComPic*& rpcPic )
 {
+#if !WPP_FIX
   UInt  uiCUAddr;
+#endif
   UInt   uiStartCUAddr;
   UInt   uiBoundingCUAddr;
@@ -907 +909 @@
   TEncSbac**** ppppcRDSbacCoders    = pcEncTop->getRDSbacCoders();
   TComBitCounter* pcBitCounters     = pcEncTop->getBitCounters();
+#if WPP_FIX
+  const Int  iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
+  const UInt uiTilesAcross  = rpcPic->getPicSym()->getNumColumnsMinus1()+1;
+#else
   Int  iNumSubstreams = 1;
   UInt uiTilesAcross  = 0;
@@ -912 +918 @@
   iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
   uiTilesAcross = rpcPic->getPicSym()->getNumColumnsMinus1()+1;
+#endif
   delete[] m_pcBufferSbacCoders;
   delete[] m_pcBufferBinCoderCABACs;
@@ -943 +950 @@
   UInt uiWidthInLCUs  = rpcPic->getPicSym()->getFrameWidthInCU();
   //UInt uiHeightInLCUs = rpcPic->getPicSym()->getFrameHeightInCU();
+#if WPP_FIX
+  UInt      uiTileCol               = 0; 
+  Bool      depSliceSegmentsEnabled = pcSlice->getPPS()->getDependentSliceSegmentsEnabledFlag(); 
+  UInt      uiCUAddr                = rpcPic->getPicSym()->getCUOrderMap( uiStartCUAddr /rpcPic->getNumPartInCU()); 
+  UInt      currentTileIdx          = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr); 
+  TComTile *pCurrentTile            = rpcPic->getPicSym()->getTComTile(currentTileIdx); 
+  UInt      uiTileStartLCU          = pCurrentTile->getFirstCUAddr();
+#else
   UInt uiCol=0, uiLin=0, uiSubStrm=0;
   UInt uiTileCol      = 0;
@@ -950 +965 @@
   uiCUAddr = rpcPic->getPicSym()->getCUOrderMap( uiStartCUAddr /rpcPic->getNumPartInCU());
   uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr();
+#endif
   if( depSliceSegmentsEnabled )
   {
     if((pcSlice->getSliceSegmentCurStartCUAddr()!= pcSlice->getSliceCurStartCUAddr())&&(uiCUAddr != uiTileStartLCU))
     {
+#if WPP_FIX
+      UInt uiSubStrm=0;
+#endif
       if( m_pcCfg->getWaveFrontsynchro() )
       {
+#if WPP_FIX
+        uiTileCol = currentTileIdx % (rpcPic->getPicSym()->getNumColumnsMinus1()+1); 
+         m_pcBufferSbacCoders[uiTileCol].loadContexts( CTXMem[1] ); 
+         //uiCUAddr = rpcPic->getPicSym()->getCUOrderMap( uiStartCUAddr /rpcPic->getNumPartInCU()); 
+         uiSubStrm=rpcPic->getSubstreamForLCUAddr(uiCUAddr, true, pcSlice); 
+         if ( pCurrentTile->getTileWidth() < 2) 
+         { 
+           CTXMem[0]->loadContexts(m_pcSbacCoder); 
+         } 
+#else
         uiTileCol = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1);
         m_pcBufferSbacCoders[uiTileCol].loadContexts( CTXMem[1] );
@@ -972 +1001 @@
           }
         }
+#endif
       }
       m_pppcRDSbacCoder[0][CI_CURR_BEST]->loadContexts( CTXMem[0] );
@@ -998 +1028 @@
     uiTileCol = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1); // what column of tiles are we in?
     uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr();
+#if WPP_FIX
+    UInt uiTileLCUX = uiTileStartLCU % uiWidthInLCUs; 
+    //UInt uiSliceStartLCU = pcSlice->getSliceCurStartCUAddr(); 
+    UInt uiCol     = uiCUAddr % uiWidthInLCUs; 
+    UInt uiSubStrm=rpcPic->getSubstreamForLCUAddr(uiCUAddr, true, pcSlice); 
+
+    if ( ((iNumSubstreams > 1) || depSliceSegmentsEnabled ) && (uiCol == uiTileLCUX) && m_pcCfg->getWaveFrontsynchro())
+#else 
     uiTileLCUX = uiTileStartLCU % uiWidthInLCUs;
     //UInt uiSliceStartLCU = pcSlice->getSliceCurStartCUAddr();
@@ -1015 +1053 @@
     }
     if ( ((pcSlice->getPPS()->getNumSubstreams() > 1) || depSliceSegmentsEnabled ) && (uiCol == uiTileLCUX) && m_pcCfg->getWaveFrontsynchro())
+#endif
     {
       // We'll sync if the TR is available.
@@ -1138 +1177 @@
     ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]->load( m_pppcRDSbacCoder[0][CI_CURR_BEST] );
     //Store probabilties of second LCU in line into buffer
+#if WPP_FIX
+    if ( ( uiCol == uiTileLCUX+1) && (depSliceSegmentsEnabled || (iNumSubstreams > 1)) && m_pcCfg->getWaveFrontsynchro()) 
+#else
     if ( ( uiCol == uiTileLCUX+1) && (depSliceSegmentsEnabled || (pcSlice->getPPS()->getNumSubstreams() > 1)) && m_pcCfg->getWaveFrontsynchro())
+#endif
     {
       m_pcBufferSbacCoders[uiTileCol].loadContexts(ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]);
@@ -1177 +1220 @@
     m_uiPicDist      += pcCU->getTotalDistortion();
   }
+#if WPP_FIX
+  if ((iNumSubstreams > 1) && !depSliceSegmentsEnabled)
+#else
   if ((pcSlice->getPPS()->getNumSubstreams() > 1) && !depSliceSegmentsEnabled)
+#endif
   {
     pcSlice->setNextSlice( true );
@@ -1239 +1286 @@
   TEncTop* pcEncTop = (TEncTop*) m_pcCfg;
   TEncSbac* pcSbacCoders = pcEncTop->getSbacCoders(); //coder for each substream
+#if WPP_FIX
+  const Int iNumSubstreams = pcSlice->getPPS()->getNumSubstreams(); 
+#else
   Int iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
+#endif
   UInt uiBitsOriginallyInSubstreams = 0;
   {
@@ -1260 +1311 @@
 
   UInt uiWidthInLCUs  = rpcPic->getPicSym()->getFrameWidthInCU();
+#if WPP_FIX
+  UInt uiCol=0, uiSubStrm=0;
+#else
   UInt uiCol=0, uiLin=0, uiSubStrm=0;
+#endif
   UInt uiTileCol      = 0;
   UInt uiTileStartLCU = 0;
@@ -1268 +1323 @@
                                                                                                an encoding order index, so we need to convert the index (uiStartCUAddr)
                                                                                                into the real raster scan address (uiCUAddr) via the CUOrderMap */
+#if WPP_FIX
+  UInt currentTileIdx=rpcPic->getPicSym()->getTileIdxMap(uiCUAddr); 
+  TComTile *pCurrentTile=rpcPic->getPicSym()->getTComTile(currentTileIdx); 
+  uiTileStartLCU = pCurrentTile->getFirstCUAddr(); 
+#else
   uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr();
+#endif
   if( depSliceSegmentsEnabled )
   {
+#if WPP_FIX
+    if( pcSlice->isNextSlice()|| uiCUAddr == uiTileStartLCU)
+#else
     if( pcSlice->isNextSlice()||
         uiCUAddr == rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr())
+#endif
     {
       if(m_pcCfg->getWaveFrontsynchro())
@@ -1284 +1349 @@
       if(m_pcCfg->getWaveFrontsynchro())
       {
+#if WPP_FIX
+        uiTileCol = currentTileIdx % (rpcPic->getPicSym()->getNumColumnsMinus1()+1);
+#else
         uiTileCol = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1);
+#endif
         m_pcBufferSbacCoders[uiTileCol].loadContexts( CTXMem[1] );
+#if WPP_FIX
+        uiCUAddr = rpcPic->getPicSym()->getCUOrderMap( uiStartCUAddr /rpcPic->getNumPartInCU()); 
+        uiSubStrm=rpcPic->getSubstreamForLCUAddr(uiCUAddr, true, pcSlice); 
+        if ( pCurrentTile->getTileWidth() < 2) 
+        { 
+          CTXMem[0]->loadContexts(m_pcSbacCoder); 
+        } 
+#else
         Int iNumSubstreamsPerTile = iNumSubstreams/rpcPic->getPicSym()->getNumTiles();
         uiLin     = uiCUAddr / uiWidthInLCUs;
@@ -1299 +1376 @@
           }
         }
+#endif
       }
       pcSbacCoders[uiSubStrm].loadContexts( CTXMem[0] );
@@ -1314 +1392 @@
     //UInt uiSliceStartLCU = pcSlice->getSliceCurStartCUAddr();
     uiCol     = uiCUAddr % uiWidthInLCUs;
+#if WPP_FIX
+    uiSubStrm=rpcPic->getSubstreamForLCUAddr(uiCUAddr, true, pcSlice);
+#else
     uiLin     = uiCUAddr / uiWidthInLCUs;
     if (pcSlice->getPPS()->getNumSubstreams() > 1)
@@ -1327 +1408 @@
       uiSubStrm = uiLin % iNumSubstreams;
     }
+#endif
 
     m_pcEntropyCoder->setBitstream( &pcSubstreams[uiSubStrm] );
     // Synchronize cabac probabilities with upper-right LCU if it's available and we're at the start of a line.
+#if WPP_FIX
+    if (((iNumSubstreams > 1) || depSliceSegmentsEnabled) && (uiCol == uiTileLCUX) && m_pcCfg->getWaveFrontsynchro())
+#else
     if (((pcSlice->getPPS()->getNumSubstreams() > 1) || depSliceSegmentsEnabled) && (uiCol == uiTileLCUX) && m_pcCfg->getWaveFrontsynchro())
+#endif
     {
       // We'll sync if the TR is available.
@@ -1368 +1454 @@
         // When tiles are independent, we have "substreams per tile".  Each substream has already been terminated, and we no longer
         // have to perform it here.
+#if WPP_FIX
+        if (iNumSubstreams <= 1)
+#else
         if (pcSlice->getPPS()->getNumSubstreams() > 1)
         {
@@ -1373 +1462 @@
         }
         else
+#endif
         {
           SliceType sliceType  = pcSlice->getSliceType();
@@ -1448 +1538 @@
     pcSbacCoders[uiSubStrm].load(m_pcSbacCoder);   //load back status of the entropy coder after encoding the LCU into relevant bitstream entropy coder
     //Store probabilties of second LCU in line into buffer
+#if WPP_FIX
+    if ( (depSliceSegmentsEnabled || (iNumSubstreams > 1)) && (uiCol == uiTileLCUX+1) && m_pcCfg->getWaveFrontsynchro())
+#else
     if ( (depSliceSegmentsEnabled || (pcSlice->getPPS()->getNumSubstreams() > 1)) && (uiCol == uiTileLCUX+1) && m_pcCfg->getWaveFrontsynchro())
+#endif
     {
       m_pcBufferSbacCoders[uiTileCol].loadContexts( &pcSbacCoders[uiSubStrm] );
@@ -1480 +1574 @@
 }
 
+#if WPP_FIX 
+Void TEncSlice::calculateBoundingCUAddrForSlice(UInt &uiStartCUAddrSlice, UInt &uiBoundingCUAddrSlice, Bool &bReachedTileBoundary, TComPic*& rpcPic, Bool bEncodeSlice, Int sliceMode, Int sliceArgument, UInt uiSliceCurEndCUAddr) 
+{ 
+  TComSlice* pcSlice = rpcPic->getSlice(getSliceIdx()); 
+  UInt uiNumberOfCUsInFrame = rpcPic->getNumCUsInFrame(); 
+  const UInt scaleCUAddr = rpcPic->getNumPartInCU(); // due to fine granularity slices all addresses are scaled. 
+  uiBoundingCUAddrSlice=0; 
+  bReachedTileBoundary=false; 
+
+  switch (sliceMode) 
+  { 
+  case FIXED_NUMBER_OF_LCU: 
+    { 
+      UInt uiCUAddrIncrement    = sliceArgument; 
+      uiBoundingCUAddrSlice     = ((uiStartCUAddrSlice + uiCUAddrIncrement) < uiNumberOfCUsInFrame*scaleCUAddr) ? (uiStartCUAddrSlice + uiCUAddrIncrement) : uiNumberOfCUsInFrame*scaleCUAddr; 
+    } 
+    break; 
+  case FIXED_NUMBER_OF_BYTES: 
+    if (bEncodeSlice) 
+      uiBoundingCUAddrSlice     = uiSliceCurEndCUAddr; 
+    else 
+      uiBoundingCUAddrSlice     = uiNumberOfCUsInFrame*scaleCUAddr; 
+    break; 
+  case FIXED_NUMBER_OF_TILES: 
+    { 
+      UInt tileIdx              = rpcPic->getPicSym()->getTileIdxMap( rpcPic->getPicSym()->getCUOrderMap(uiStartCUAddrSlice/scaleCUAddr) ); 
+      UInt uiCUAddrIncrement    = 0; 
+      UInt tileTotalCount       = (rpcPic->getPicSym()->getNumColumnsMinus1()+1) * (rpcPic->getPicSym()->getNumRowsMinus1()+1); 
+
+      for(UInt tileIdxIncrement = 0; tileIdxIncrement < sliceArgument; tileIdxIncrement++) 
+      { 
+        if((tileIdx + tileIdxIncrement) < tileTotalCount) 
+        { 
+          UInt tileWidthInLcu   = rpcPic->getPicSym()->getTComTile(tileIdx + tileIdxIncrement)->getTileWidth(); 
+          UInt tileHeightInLcu  = rpcPic->getPicSym()->getTComTile(tileIdx + tileIdxIncrement)->getTileHeight(); 
+          uiCUAddrIncrement    += (tileWidthInLcu * tileHeightInLcu * scaleCUAddr); 
+        } 
+      } 
+
+      uiBoundingCUAddrSlice     = ((uiStartCUAddrSlice + uiCUAddrIncrement) < uiNumberOfCUsInFrame*scaleCUAddr) ? (uiStartCUAddrSlice + uiCUAddrIncrement) : uiNumberOfCUsInFrame*scaleCUAddr; 
+    } 
+    break; 
+  default: 
+    uiBoundingCUAddrSlice       = uiNumberOfCUsInFrame*scaleCUAddr; 
+    break; 
+  } 
+
+  // Adjust for tiles and wavefronts. 
+  if ((sliceMode == FIXED_NUMBER_OF_LCU || sliceMode == FIXED_NUMBER_OF_BYTES) && 
+    (m_pcCfg->getNumRowsMinus1() > 0 || m_pcCfg->getNumColumnsMinus1() > 0)) 
+  { 
+    const UInt lcuEncAddrStart = (uiStartCUAddrSlice+scaleCUAddr-1)/scaleCUAddr; 
+    const UInt lcuAddr = rpcPic->getPicSym()->getCUOrderMap(lcuEncAddrStart); 
+    const UInt startTileIdx = rpcPic->getPicSym()->getTileIdxMap(lcuAddr); 
+    const Bool bWavefrontsEnabled = m_pcCfg->getWaveFrontsynchro(); 
+
+    TComTile *pStartingTile = rpcPic->getPicSym()->getTComTile(startTileIdx); 
+    const UInt uiTileStartLCUEncAddr      = rpcPic->getPicSym()->getInverseCUOrderMap(pStartingTile->getFirstCUAddr()); 
+    const UInt uiTileStartWidth           = pStartingTile->getTileWidth(); 
+    const UInt uiTileStartHeight          = pStartingTile->getTileHeight(); 
+    const UInt uiTileLastLCUEncAddr_excl  = uiTileStartLCUEncAddr + uiTileStartWidth*uiTileStartHeight; 
+    const UInt tileBoundingCUAddrSlice    = uiTileLastLCUEncAddr_excl * scaleCUAddr; 
+
+    const UInt lcuColumnOfStartingTile=((lcuEncAddrStart-uiTileStartLCUEncAddr)%uiTileStartWidth); 
+    if (bWavefrontsEnabled && lcuColumnOfStartingTile!=0) 
+    { 
+      // WPP: if a slice does not start at the beginning of a CTB row, it must end within the same CTB row 
+      const UInt numberOfLCUsToEndOfRow=uiTileStartWidth-lcuColumnOfStartingTile; 
+      const UInt wavefrontTileBoundingCUAddrSlice = (lcuEncAddrStart+numberOfLCUsToEndOfRow)*scaleCUAddr; 
+      if (wavefrontTileBoundingCUAddrSlice < uiBoundingCUAddrSlice) 
+      { 
+        uiBoundingCUAddrSlice = wavefrontTileBoundingCUAddrSlice; 
+      } 
+    } 
+
+    if (tileBoundingCUAddrSlice < uiBoundingCUAddrSlice) 
+    { 
+      uiBoundingCUAddrSlice = tileBoundingCUAddrSlice; 
+      bReachedTileBoundary = true; 
+    } 
+  } 
+  else if (pcSlice->getPPS()->getNumSubstreams() > 1 && (uiStartCUAddrSlice % (rpcPic->getFrameWidthInCU()*scaleCUAddr) != 0)) 
+  { 
+    // WPP: if a slice does not start at the beginning of a CTB row, it must end within the same CTB row 
+    uiBoundingCUAddrSlice = min(uiBoundingCUAddrSlice, uiStartCUAddrSlice - (uiStartCUAddrSlice % (rpcPic->getFrameWidthInCU()*scaleCUAddr)) + (rpcPic->getFrameWidthInCU()*scaleCUAddr)); 
+  } 
+
+  //calculate real slice start address (fine granularity slices) 
+  { 
+    UInt uiInternalAddress = rpcPic->getPicSym()->getPicSCUAddr(uiStartCUAddrSlice) % scaleCUAddr; 
+    UInt uiExternalAddress = rpcPic->getPicSym()->getPicSCUAddr(uiStartCUAddrSlice) / scaleCUAddr; 
+    UInt uiPosX = ( uiExternalAddress % rpcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ]; 
+    UInt uiPosY = ( uiExternalAddress / rpcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ]; 
+#if REPN_FORMAT_IN_VPS
+    UInt uiWidth = pcSlice->getPicWidthInLumaSamples();
+    UInt uiHeight = pcSlice->getPicHeightInLumaSamples();
+#else
+    UInt uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples(); 
+    UInt uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples(); 
+#endif
+    while((uiPosX>=uiWidth||uiPosY>=uiHeight)&&!(uiPosX>=uiWidth&&uiPosY>=uiHeight)) 
+    { 
+      uiInternalAddress++; 
+      if(uiInternalAddress>=scaleCUAddr) 
+      { 
+        uiInternalAddress=0; 
+        uiExternalAddress = rpcPic->getPicSym()->getCUOrderMap(rpcPic->getPicSym()->getInverseCUOrderMap(uiExternalAddress)+1); 
+      } 
+      uiPosX = ( uiExternalAddress % rpcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ]; 
+      uiPosY = ( uiExternalAddress / rpcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ]; 
+    } 
+    UInt uiRealStartAddress = rpcPic->getPicSym()->getPicSCUEncOrder(uiExternalAddress*scaleCUAddr+uiInternalAddress); 
+
+    uiStartCUAddrSlice=uiRealStartAddress; 
+  } 
+} 
+
+/** Determines the starting and bounding LCU address of current slice / dependent slice 
+* \param bEncodeSlice Identifies if the calling function is compressSlice() [false] or encodeSlice() [true] 
+* \returns Updates uiStartCUAddr, uiBoundingCUAddr with appropriate LCU address 
+*/ 
+Void TEncSlice::xDetermineStartAndBoundingCUAddr  ( UInt& startCUAddr, UInt& boundingCUAddr, TComPic*& rpcPic, Bool bEncodeSlice ) 
+{ 
+  TComSlice* pcSlice = rpcPic->getSlice(getSliceIdx()); 
+
+  // Non-dependent slice 
+  UInt uiStartCUAddrSlice   = pcSlice->getSliceCurStartCUAddr(); 
+  Bool bTileBoundarySlice   = false; 
+  UInt uiBoundingCUAddrSlice; 
+  calculateBoundingCUAddrForSlice(uiStartCUAddrSlice, uiBoundingCUAddrSlice, bTileBoundarySlice, rpcPic, bEncodeSlice, m_pcCfg->getSliceMode(), m_pcCfg->getSliceArgument(), pcSlice->getSliceCurEndCUAddr()); 
+  pcSlice->setSliceCurEndCUAddr( uiBoundingCUAddrSlice ); 
+  pcSlice->setSliceCurStartCUAddr(uiStartCUAddrSlice); 
+
+  // Dependent slice 
+  UInt startCUAddrSliceSegment    = pcSlice->getSliceSegmentCurStartCUAddr(); 
+  Bool bTileBoundarySliceSegment  = false; 
+  UInt boundingCUAddrSliceSegment; 
+  calculateBoundingCUAddrForSlice(startCUAddrSliceSegment, boundingCUAddrSliceSegment, bTileBoundarySliceSegment, rpcPic, bEncodeSlice, m_pcCfg->getSliceSegmentMode(), m_pcCfg->getSliceSegmentArgument(), pcSlice->getSliceSegmentCurEndCUAddr()); 
+  pcSlice->setSliceSegmentCurEndCUAddr( boundingCUAddrSliceSegment ); 
+  pcSlice->setSliceSegmentCurStartCUAddr(startCUAddrSliceSegment); 
+
+  // Make a joint decision based on reconstruction and dependent slice bounds 
+  startCUAddr    = max(uiStartCUAddrSlice   , startCUAddrSliceSegment   ); 
+  boundingCUAddr = min(uiBoundingCUAddrSlice, boundingCUAddrSliceSegment); 
+
+
+  if (!bEncodeSlice) 
+  { 
+    // For fixed number of LCU within an entropy and reconstruction slice we already know whether we will encounter end of entropy and/or reconstruction slice 
+    // first. Set the flags accordingly. 
+    if ( (m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_LCU && m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_LCU) 
+      || (m_pcCfg->getSliceMode()==0 && m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_LCU) 
+      || (m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_LCU && m_pcCfg->getSliceSegmentMode()==0) 
+      || (m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_TILES && m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_LCU) 
+      || (m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_TILES && m_pcCfg->getSliceSegmentMode()==0) 
+      || (m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_TILES && m_pcCfg->getSliceMode()==0) 
+      || bTileBoundarySlice || bTileBoundarySliceSegment ) 
+    { 
+      if (uiBoundingCUAddrSlice < boundingCUAddrSliceSegment) 
+      { 
+        pcSlice->setNextSlice       ( true ); 
+        pcSlice->setNextSliceSegment( false ); 
+      } 
+      else if (uiBoundingCUAddrSlice > boundingCUAddrSliceSegment) 
+      { 
+        pcSlice->setNextSlice       ( false ); 
+        pcSlice->setNextSliceSegment( true ); 
+      } 
+      else 
+      { 
+        pcSlice->setNextSlice       ( true ); 
+        pcSlice->setNextSliceSegment( true ); 
+      } 
+    } 
+    else 
+    { 
+      pcSlice->setNextSlice       ( false ); 
+      pcSlice->setNextSliceSegment( false ); 
+    } 
+  } 
+} 
+#else 
 /** Determines the starting and bounding LCU address of current slice / dependent slice
  * \param bEncodeSlice Identifies if the calling function is compressSlice() [false] or encodeSlice() [true]
@@ -1816 +2092 @@
   }
 }
+#endif
 
 Double TEncSlice::xGetQPValueAccordingToLambda ( Double lambda )

trunk/source/Lib/TLibEncoder/TEncSlice.h

@@ -150 +150 @@
   Void      setCtxMem( TEncSbac* sb, Int b )   { CTXMem[b] = sb; }
 
+#if WPP_FIX 
+  Void     calculateBoundingCUAddrForSlice(UInt &uiStartCUAddrSlice, UInt &uiBoundingCUAddrSlice, Bool &bReachedTileBoundary, TComPic*& rpcPic, Bool bEncodeSlice, Int sliceMode, Int sliceArgument, UInt uiSliceCurEndCUAddr); 
+#endif
+
 private:
   Double  xGetQPValueAccordingToLambda ( Double lambda );

trunk/source/Lib/TLibEncoder/TEncTop.cpp

@@ -98 +98 @@
   m_noOutputOfPriorPicsFlags   = false;
 #endif
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  m_pocDecrementedInDPBFlag    = false;
+#endif
 #endif //SVC_EXTENSION
 }
@@ -323 +326 @@
   /* set the VPS profile information */
   *m_cVPS.getPTL() = *m_cSPS.getPTL();
+#if VPS_VUI_BSP_HRD_PARAMS
+  m_cVPS.getTimingInfo()->setTimingInfoPresentFlag       ( true );
+#else
   m_cVPS.getTimingInfo()->setTimingInfoPresentFlag       ( false );
+#endif
   // initialize PPS
   m_cPPS.setSPS(&m_cSPS);
@@ -779 +786 @@
         for(UInt i = 0; i < m_cVPS.getNumDirectRefLayers( m_layerId ); i++ )
         {
+#if MOVE_SCALED_OFFSET_TO_PPS
+#if O0098_SCALED_REF_LAYER_ID
+          const Window scalEL = getPPS()->getScaledRefLayerWindowForLayer(m_cVPS.getRefLayerId(m_layerId, i));
+#else
+          const Window scalEL = getPPS()->getScaledRefLayerWindow(i);
+#endif
+#else
 #if O0098_SCALED_REF_LAYER_ID
           const Window scalEL = getSPS()->getScaledRefLayerWindowForLayer(m_cVPS.getRefLayerId(m_layerId, i));
@@ -784 +798 @@
           const Window scalEL = getSPS()->getScaledRefLayerWindow(i);
 #endif
+#endif
+#if REF_REGION_OFFSET
+          const Window altRL  = getPPS()->getRefLayerWindowForLayer(m_cVPS.getRefLayerId(m_layerId, i));
+#if RESAMPLING_FIX
+          Bool equalOffsets = scalEL.hasEqualOffset(altRL);
+#if R0209_GENERIC_PHASE
+          Bool zeroPhase = getPPS()->hasZeroResamplingPhase(m_cVPS.getRefLayerId(m_layerId, i));
+#endif
+#else
+          Bool zeroOffsets = ( scalEL.getWindowLeftOffset() == 0 && scalEL.getWindowRightOffset() == 0 && scalEL.getWindowTopOffset() == 0 && scalEL.getWindowBottomOffset() == 0
+                               && altRL.getWindowLeftOffset() == 0 && altRL.getWindowRightOffset() == 0 && altRL.getWindowTopOffset() == 0 && altRL.getWindowBottomOffset() == 0);
+#endif
+#else
           Bool zeroOffsets = ( scalEL.getWindowLeftOffset() == 0 && scalEL.getWindowRightOffset() == 0 && scalEL.getWindowTopOffset() == 0 && scalEL.getWindowBottomOffset() == 0 );
+#endif
 
 #if VPS_EXTN_DIRECT_REF_LAYERS
@@ -795 +823 @@
           Bool sameBitDepths = ( g_bitDepthYLayer[m_layerId] == g_bitDepthYLayer[refLayerId] ) && ( g_bitDepthCLayer[m_layerId] == g_bitDepthCLayer[refLayerId] );
 
-          if( m_iSourceWidth != pcEncTopBase->getSourceWidth() || m_iSourceHeight != pcEncTopBase->getSourceHeight() || !zeroOffsets || !sameBitDepths 
+#if REF_IDX_MFM
+          if( m_iSourceWidth == pcEncTopBase->getSourceWidth() && m_iSourceHeight == pcEncTopBase->getSourceHeight() && equalOffsets && zeroPhase )
+          {
+            pcEPic->setEqualPictureSizeAndOffsetFlag( i, true );
+          }
+
+          if( !pcEPic->equalPictureSizeAndOffsetFlag(i) || !sameBitDepths 
+#else
+          if( m_iSourceWidth != pcEncTopBase->getSourceWidth() || m_iSourceHeight != pcEncTopBase->getSourceHeight() || !sameBitDepths 
+#if REF_REGION_OFFSET && RESAMPLING_FIX
+            || !equalOffsets
+#if R0209_GENERIC_PHASE
+            || !zeroPhase
+#endif
+#else
+            || !zeroOffsets
+#endif
+#endif
 #if Q0048_CGS_3D_ASYMLUT
             || m_cPPS.getCGSFlag() > 0
@@ -804 +849 @@
             )
 #else
-          if(m_iSourceWidth != pcEncTopBase->getSourceWidth() || m_iSourceHeight != pcEncTopBase->getSourceHeight() || !zeroOffsets )
+          if(m_iSourceWidth != pcEncTopBase->getSourceWidth() || m_iSourceHeight != pcEncTopBase->getSourceHeight()
+#if REF_REGION_OFFSET && RESAMPLING_FIX
+            || !equalOffsets
+#if R0209_GENERIC_PHASE
+            || !zeroPhase
+#endif
+#else
+            || !zeroOffsets
+#endif
+          )
 #endif
           {
@@ -839 +893 @@
         for(UInt i = 0; i < m_cVPS.getNumDirectRefLayers( m_layerId ); i++ )
         {
+#if MOVE_SCALED_OFFSET_TO_PPS
+#if O0098_SCALED_REF_LAYER_ID
+          const Window scalEL = getPPS()->getScaledRefLayerWindowForLayer(m_cVPS.getRefLayerId(m_layerId, i));
+#else
+          const Window scalEL = getPPS()->getScaledRefLayerWindow(i);
+#endif
+#else
 #if O0098_SCALED_REF_LAYER_ID
           const Window scalEL = getSPS()->getScaledRefLayerWindowForLayer(m_cVPS.getRefLayerId(m_layerId, i));
@@ -844 +905 @@
           const Window scalEL = getSPS()->getScaledRefLayerWindow(i);
 #endif
+#endif
+#if REF_REGION_OFFSET
+          const Window altRL  = getPPS()->getRefLayerWindowForLayer(m_cVPS.getRefLayerId(m_layerId, i));
+#if RESAMPLING_FIX
+          Bool equalOffsets = scalEL.hasEqualOffset(altRL);
+#if R0209_GENERIC_PHASE
+          Bool zeroPhase = getPPS()->hasZeroResamplingPhase(m_cVPS.getRefLayerId(m_layerId, i));
+#endif
+#else
+          Bool zeroOffsets = ( scalEL.getWindowLeftOffset() == 0 && scalEL.getWindowRightOffset() == 0 && scalEL.getWindowTopOffset() == 0 && scalEL.getWindowBottomOffset() == 0
+                               && altRL.getWindowLeftOffset() == 0 && altRL.getWindowRightOffset() == 0 && altRL.getWindowTopOffset() == 0 && altRL.getWindowBottomOffset() == 0);
+#endif
+#else
           Bool zeroOffsets = ( scalEL.getWindowLeftOffset() == 0 && scalEL.getWindowRightOffset() == 0 && scalEL.getWindowTopOffset() == 0 && scalEL.getWindowBottomOffset() == 0 );
+#endif
 
 #if VPS_EXTN_DIRECT_REF_LAYERS
@@ -855 +930 @@
           Bool sameBitDepths = ( g_bitDepthYLayer[m_layerId] == g_bitDepthYLayer[refLayerId] ) && ( g_bitDepthCLayer[m_layerId] == g_bitDepthCLayer[refLayerId] );
 
-          if( m_iSourceWidth != pcEncTopBase->getSourceWidth() || m_iSourceHeight != pcEncTopBase->getSourceHeight() || !zeroOffsets || !sameBitDepths 
+          if( m_iSourceWidth != pcEncTopBase->getSourceWidth() || m_iSourceHeight != pcEncTopBase->getSourceHeight() || !sameBitDepths 
+#if REF_REGION_OFFSET && RESAMPLING_FIX
+            || !equalOffsets 
+#if R0209_GENERIC_PHASE
+            || !zeroPhase
+#endif
+#else
+            || !zeroOffsets 
+#endif
 #if Q0048_CGS_3D_ASYMLUT
             || m_cPPS.getCGSFlag() > 0
@@ -864 +947 @@
 )
 #else
-          if(m_iSourceWidth != pcEncTopBase->getSourceWidth() || m_iSourceHeight != pcEncTopBase->getSourceHeight() || !zeroOffsets )
+          if(m_iSourceWidth != pcEncTopBase->getSourceWidth() || m_iSourceHeight != pcEncTopBase->getSourceHeight()
+#if REF_REGION_OFFSET && RESAMPLING_FIX
+            || !equalOffsets 
+#if R0209_GENERIC_PHASE
+            || !zeroPhase
+#endif
+#else
+            || !zeroOffsets 
+#endif
+          )
 #endif
           {
@@ -905 +997 @@
 #if SVC_EXTENSION
   m_cSPS.setExtensionFlag( m_layerId > 0 ? true : false );
-
+#if R0042_PROFILE_INDICATION
+  m_cSPS.setNumDirectRefLayers(m_numAddLayerSets);
+#endif
 #if Q0078_ADD_LAYER_SETS
-  if (getNumDirectRefLayers() == 0 && getNumAddLayerSets() > 0)
+  if( !m_numDirectRefLayers && m_numAddLayerSets )
   {
     m_cSPS.setLayerId(0); // layer ID 0 for independent layers
@@ -918 +1012 @@
   m_cSPS.setLayerId(m_layerId);
 #endif
+#if !MOVE_SCALED_OFFSET_TO_PPS
   m_cSPS.setNumScaledRefLayerOffsets(m_numScaledRefLayerOffsets);
   for(Int i = 0; i < m_cSPS.getNumScaledRefLayerOffsets(); i++)
@@ -929 +1024 @@
 #endif
   }
+#endif
 #endif //SVC_EXTENSION
   ProfileTierLevel& profileTierLevel = *m_cSPS.getPTL()->getGeneralPTL();
@@ -1041 +1137 @@
   {
     TComVUI* pcVUI = m_cSPS.getVuiParameters();
-    pcVUI->setAspectRatioInfoPresentFlag(getAspectRatioIdc() != -1);
+    pcVUI->setAspectRatioInfoPresentFlag(getAspectRatioInfoPresentFlag());
     pcVUI->setAspectRatioIdc(getAspectRatioIdc());
     pcVUI->setSarWidth(getSarWidth());
@@ -1177 +1273 @@
 
 #if Q0078_ADD_LAYER_SETS
-  if (getNumDirectRefLayers() == 0 && getNumAddLayerSets() > 0)
+  if( !m_numDirectRefLayers && m_numAddLayerSets )
   {
     m_cPPS.setLayerId(0); // layer ID 0 for independent layers
@@ -1203 +1299 @@
   {
     m_cPPS.setNumExtraSliceHeaderBits( 3 );
+  }
+#endif
+#if MOVE_SCALED_OFFSET_TO_PPS
+  m_cPPS.setNumScaledRefLayerOffsets(m_numScaledRefLayerOffsets);
+  for(Int i = 0; i < m_cPPS.getNumScaledRefLayerOffsets(); i++)
+  {
+#if O0098_SCALED_REF_LAYER_ID
+    m_cPPS.setScaledRefLayerId(i, m_scaledRefLayerId[i]);
+#endif
+    m_cPPS.getScaledRefLayerWindow(i) = m_scaledRefLayerWindow[i];
+#if REF_REGION_OFFSET
+    m_cPPS.getRefLayerWindow(i) = m_refLayerWindow[i];
+    m_cPPS.setScaledRefLayerOffsetPresentFlag( m_scaledRefLayerId[i], m_scaledRefLayerOffsetPresentFlag[i] );
+    m_cPPS.setRefRegionOffsetPresentFlag( m_scaledRefLayerId[i], m_refRegionOffsetPresentFlag[i] );
+#endif
+#if R0209_GENERIC_PHASE
+    m_cPPS.setResamplePhaseSetPresentFlag( m_scaledRefLayerId[i], m_resamplePhaseSetPresentFlag[i] );
+    m_cPPS.setPhaseHorLuma( m_scaledRefLayerId[i], m_phaseHorLuma[i] );
+    m_cPPS.setPhaseVerLuma( m_scaledRefLayerId[i], m_phaseVerLuma[i] );
+    m_cPPS.setPhaseHorChroma( m_scaledRefLayerId[i], m_phaseHorChroma[i] );
+    m_cPPS.setPhaseVerChroma( m_scaledRefLayerId[i], m_phaseVerChroma[i] );
+#endif
+#if P0312_VERT_PHASE_ADJ
+    m_cPPS.setVertPhasePositionEnableFlag( m_scaledRefLayerId[i], m_scaledRefLayerWindow[i].getVertPhasePositionEnableFlag() );
+#endif
   }
 #endif
@@ -1477 +1598 @@
 Void  TEncTop::xInitPPSforTiles()
 {
-  m_cPPS.setUniformSpacingFlag( m_iUniformSpacingIdr );
-  m_cPPS.setNumColumnsMinus1( m_iNumColumnsMinus1 );
-  m_cPPS.setNumRowsMinus1( m_iNumRowsMinus1 );
-  if( m_iUniformSpacingIdr == 0 )
-  {
-    m_cPPS.setColumnWidth( m_puiColumnWidth );
-    m_cPPS.setRowHeight( m_puiRowHeight );
+  m_cPPS.setTileUniformSpacingFlag( m_tileUniformSpacingFlag );
+  m_cPPS.setNumTileColumnsMinus1( m_iNumColumnsMinus1 );
+  m_cPPS.setNumTileRowsMinus1( m_iNumRowsMinus1 );
+  if( !m_tileUniformSpacingFlag )
+  {
+    m_cPPS.setTileColumnWidth( m_tileColumnWidth );
+    m_cPPS.setTileRowHeight( m_tileRowHeight );
   }
   m_cPPS.setLoopFilterAcrossTilesEnabledFlag( m_loopFilterAcrossTilesEnabledFlag );
 
   // # substreams is "per tile" when tiles are independent.
-  if (m_iWaveFrontSynchro
-    )
+  if (m_iWaveFrontSynchro )
   {
     m_cPPS.setNumSubstreams(m_iWaveFrontSubstreams * (m_iNumColumnsMinus1+1));
@@ -1515 +1635 @@
   }
 
-  if( m_iNumColumnsMinus1 && m_iUniformSpacingIdr==0 )
+  if( m_iNumColumnsMinus1 && !m_tileUniformSpacingFlag )
   {
     for(Int i=0; i<m_iNumColumnsMinus1; i++)
     {
-      uiCummulativeColumnWidth += m_puiColumnWidth[i];
+      uiCummulativeColumnWidth += m_tileColumnWidth[i];
     }
 
@@ -1542 +1662 @@
   }
 
-  if( m_iNumRowsMinus1 && m_iUniformSpacingIdr==0 )
+  if( m_iNumRowsMinus1 && !m_tileUniformSpacingFlag )
   {
     for(Int i=0; i<m_iNumRowsMinus1; i++)
-    {
-      uiCummulativeRowHeight += m_puiRowHeight[i];
-    }
+      uiCummulativeRowHeight += m_tileRowHeight[i];
 
     if( uiCummulativeRowHeight >= iHeightInCU )
@@ -1646 +1764 @@
 
     Int  numReorderPics[MAX_TLAYER];
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
+    Window &conformanceWindow = repFormat->getConformanceWindowVps();
+#else
     Window &conformanceWindow = m_cSPS.getConformanceWindow();
+#endif
     Window defaultDisplayWindow = m_cSPS.getVuiParametersPresentFlag() ? m_cSPS.getVuiParameters()->getDefaultDisplayWindow() : Window();
 
@@ -1685 +1807 @@
   return win;
 }
+#if REF_REGION_OFFSET
+Window& TEncTop::getRefLayerWindowForLayer(Int layerId)
+{
+  static Window win;
+
+  for (Int i = 0; i < m_numScaledRefLayerOffsets; i++)
+  {
+    if (layerId == m_refLayerId[i])
+    {
+      return m_refLayerWindow[i];
+    }
+  }
+
+  win.resetWindow();  // reference offsets are inferred to be zero when not present
+  return win;
+}
+#endif
 #endif
 

trunk/source/Lib/TLibEncoder/TEncTop.h

@@ -125 +125 @@
   static Int              m_iSPSIdCnt;                    ///< next Id number for SPS    
   static Int              m_iPPSIdCnt;                    ///< next Id number for PPS    
-#if AVC_SYNTAX
-  fstream*                m_pBLSyntaxFile;
-#endif
   TEncTop**               m_ppcTEncTop;
   TEncTop*                getLayerEnc(UInt layer)   { return m_ppcTEncTop[layer]; }
@@ -139 +136 @@
 #endif
   Window                  m_scaledRefLayerWindow[MAX_LAYERS];
+#if REF_REGION_OFFSET
+  UInt                    m_numRefLayerOffsets;
+  UInt                    m_refLayerId[MAX_LAYERS];
+  Window                  m_refLayerWindow[MAX_LAYERS];
+  Bool                    m_scaledRefLayerOffsetPresentFlag[MAX_LAYERS];
+  Bool                    m_refRegionOffsetPresentFlag[MAX_LAYERS];
+#endif
+#if R0209_GENERIC_PHASE
+  Int                     m_phaseHorLuma  [MAX_LAYERS];
+  Int                     m_phaseVerLuma  [MAX_LAYERS];
+  Int                     m_phaseHorChroma[MAX_LAYERS];
+  Int                     m_phaseVerChroma[MAX_LAYERS];
+  Int                     m_resamplePhaseSetPresentFlag[MAX_LAYERS];
+#endif
 #if P0312_VERT_PHASE_ADJ
   Bool                    m_vertPhasePositionEnableFlag[MAX_LAYERS];
@@ -156 +167 @@
 #if Q0078_ADD_LAYER_SETS
   int                     m_numAddLayerSets;
+#endif
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  Bool                    m_pocDecrementedInDPBFlag;
+  Int                     m_currPocMsb;
 #endif
 #endif //SVC_EXTENSION
@@ -232 +247 @@
 #endif
   Window&   getScaledRefLayerWindow(Int x)                 { return m_scaledRefLayerWindow[x];        }
+#if REF_REGION_OFFSET
+  Void      setNumRefLayerOffsets(Int x) { m_numRefLayerOffsets = x; }
+  UInt      getNumRefLayerOffsets() { return m_numRefLayerOffsets; }
+  Void      setRefLayerId(Int x, UInt id) { m_refLayerId[x] = id;   }
+  UInt      getRefLayerId(Int x)          { return m_refLayerId[x]; }
+  Window&   getRefLayerWindowForLayer(Int layerId);
+  Window&   getRefLayerWindow(Int x)            { return m_refLayerWindow[x]; }
+  Bool      getScaledRefLayerOffsetPresentFlag(Int x) { return m_scaledRefLayerOffsetPresentFlag[x]; }
+  Void      setScaledRefLayerOffsetPresentFlag(Int x, Bool b) { m_scaledRefLayerOffsetPresentFlag[x] = b; }
+  Bool      getRefRegionOffsetPresentFlag(Int x) { return m_refRegionOffsetPresentFlag[x]; }
+  Void      setRefRegionOffsetPresentFlag(Int x, Bool b) { m_refRegionOffsetPresentFlag[x] = b; }
+#endif
 #if P0312_VERT_PHASE_ADJ
   Void      setVertPhasePositionEnableFlag(Int x, Bool b)  { m_vertPhasePositionEnableFlag[x] = b;    }
   UInt      getVertPhasePositionEnableFlag(Int x)          { return m_vertPhasePositionEnableFlag[x]; }
+#endif
+#if R0209_GENERIC_PHASE
+  Int getPhaseHorLuma(Int x) { return m_phaseHorLuma[x]; }
+  Int getPhaseVerLuma(Int x) { return m_phaseVerLuma[x]; }
+  Int getPhaseHorChroma(Int x) { return m_phaseHorChroma[x]; }
+  Int getPhaseVerChroma(Int x) { return m_phaseVerChroma[x]; }
+  Void setPhaseHorLuma(Int x, Int val) { m_phaseHorLuma[x] = val; }
+  Void setPhaseVerLuma(Int x, Int val) { m_phaseVerLuma[x] = val; }
+  Void setPhaseHorChroma(Int x, Int val) { m_phaseHorChroma[x] = val; }
+  Void setPhaseVerChroma(Int x, Int val) { m_phaseVerChroma[x] = val; }
+  Bool getResamplePhaseSetPresentFlag(Int x) { return m_resamplePhaseSetPresentFlag[x]; }
+  Void setResamplePhaseSetPresentFlag(Int x, Bool b) { m_resamplePhaseSetPresentFlag[x] = b; }
 #endif
 
@@ -245 +284 @@
   Void      setInterLayerWeightedPredFlag(Bool flag)   { m_interLayerWeightedPredFlag = flag; }
   Bool      getInterLayerWeightedPredFlag()            { return m_interLayerWeightedPredFlag; }
-#endif
-#if AVC_SYNTAX
-  Void      setBLSyntaxFile( fstream* pFile ) { m_pBLSyntaxFile = pFile; }
-  fstream*  getBLSyntaxFile() { return m_pBLSyntaxFile; }
 #endif
   Void      encode( TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int iPicIdInGOP );
@@ -275 +310 @@
   Int  getNumAddLayerSets()                  { return m_numAddLayerSets; }
 #endif
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  Void setPocDecrementedInDPBFlag(Bool x)    { m_pocDecrementedInDPBFlag = x; }
+  Bool getPocDecrementedInDPBFlag()          { return m_pocDecrementedInDPBFlag; }
+  Void setCurrPocMsb(Int poc)                { m_currPocMsb = poc; }
+  Int  getCurrPocMsb()                       { return m_currPocMsb; }
+#endif
 #else //SVC_EXTENSION
   Void encode( Bool bEos, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut,