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

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/TLibCommon/CommonDef.h (modified) (1 diff)
• source/Lib/TLibCommon/SEI.h (modified) (7 diffs)
• source/Lib/TLibCommon/TCom3DAsymLUT.cpp (modified) (15 diffs)
• source/Lib/TLibCommon/TCom3DAsymLUT.h (modified) (7 diffs)
• source/Lib/TLibCommon/TComDataCU.cpp (modified) (5 diffs)
• source/Lib/TLibCommon/TComDataCU.h (modified) (1 diff)
• source/Lib/TLibCommon/TComMotionInfo.h (modified) (1 diff)
• source/Lib/TLibCommon/TComPic.cpp (modified) (11 diffs)
• source/Lib/TLibCommon/TComPic.h (modified) (5 diffs)
• source/Lib/TLibCommon/TComPicSym.cpp (modified) (7 diffs)
• source/Lib/TLibCommon/TComPicSym.h (modified) (5 diffs)
• source/Lib/TLibCommon/TComPicYuv.cpp (modified) (5 diffs)
• source/Lib/TLibCommon/TComPicYuv.h (modified) (2 diffs)
• source/Lib/TLibCommon/TComPrediction.cpp (modified) (1 diff)
• source/Lib/TLibCommon/TComPrediction.h (modified) (1 diff)
• source/Lib/TLibCommon/TComSlice.cpp (modified) (44 diffs)
• source/Lib/TLibCommon/TComSlice.h (modified) (45 diffs)
• source/Lib/TLibCommon/TComUpsampleFilter.cpp (modified) (19 diffs)
• source/Lib/TLibCommon/TComUpsampleFilter.h (modified) (1 diff)
• source/Lib/TLibCommon/TypeDef.h (modified) (13 diffs)

trunk/source/Lib/TLibCommon/CommonDef.h

@@ -58 +58 @@
 #if SVC_EXTENSION
 #include <vector>
-#define NV_VERSION        "6.1 (HM-14.0)"                 ///< Current software version
+#define NV_VERSION        "7.0 (HM-15.0)"                 ///< Current software version
 #else
-#define NV_VERSION        "14.0"                ///< Current software version
+#define NV_VERSION        "15.0"                ///< Current software version
 #endif
 

trunk/source/Lib/TLibCommon/SEI.h

@@ -94 +94 @@
     BSP_NESTING                          = 140,
     BSP_INITIAL_ARRIVAL_TIME             = 141,
+#if !REMOVE_BSP_HRD_SEI
     BSP_HRD                              = 142,
 #endif
-#if Q0074_SEI_COLOR_MAPPING
-    COLOR_MAPPING_INFO                   = 143,
+#endif
+#if Q0074_COLOUR_REMAPPING_SEI
+    COLOUR_REMAPPING_INFO                = 143,
 #endif
 #if Q0078_ADD_LAYER_SETS
@@ -173 +175 @@
   Int numSpsIdsMinus1;
   std::vector<Int> activeSeqParameterSetId; 
+#if R0247_SEI_ACTIVE
+  std::vector<Int> layerSpsIdx; 
+#endif
 };
 
@@ -199 +204 @@
   UInt m_bpSeqParameterSetId;
   Bool m_rapCpbParamsPresentFlag;
-  Bool m_cpbDelayOffset;
-  Bool m_dpbDelayOffset;
+  UInt m_cpbDelayOffset;
+  UInt m_dpbDelayOffset;
   UInt m_initialCpbRemovalDelay         [MAX_CPB_CNT][2];
   UInt m_initialCpbRemovalDelayOffset   [MAX_CPB_CNT][2];
@@ -445 +450 @@
 };
 #endif
-#if Q0074_SEI_COLOR_MAPPING
-class SEIColorMappingInfo : public SEI
-{
-public:
-  PayloadType payloadType() const { return COLOR_MAPPING_INFO; }
-  SEIColorMappingInfo() {
-  }
-  virtual ~SEIColorMappingInfo() {}
-
-  Int   m_colorMapId;
-  Bool  m_colorMapCancelFlag;
-  Bool  m_colorMapPersistenceFlag;
-  Bool  m_colorMap_video_signal_type_present_flag;
-  Bool  m_colorMap_video_full_range_flag;
-  Int   m_colorMap_primaries;
-  Int   m_colorMap_transfer_characteristics;
-  Int   m_colorMap_matrix_coeffs;
-  Int   m_colorMapModelId;
-
-  Int   m_colour_map_coded_data_bit_depth;
-  Int   m_colour_map_target_bit_depth;
-
-  Int   m_num_input_pivots[3];
-  Int*  m_coded_input_pivot_value[3];
-  Int*  m_target_input_pivot_value[3];
-  
-  Bool  m_matrix_flag;
-  Int   m_log2_matrix_denom;
-  Int   m_matrix_coef[3][3];
-
-  Int   m_num_output_pivots[3];
-  Int*  m_coded_output_pivot_value[3];
-  Int*  m_target_output_pivot_value[3];
+#if Q0074_COLOUR_REMAPPING_SEI
+class SEIColourRemappingInfo : public SEI
+{
+public:
+  PayloadType payloadType() const { return COLOUR_REMAPPING_INFO; }
+  SEIColourRemappingInfo() {}
+  ~SEIColourRemappingInfo() {}
+ 
+  Int   m_colourRemapId;
+  Bool  m_colourRemapCancelFlag;
+  Bool  m_colourRemapPersistenceFlag;
+  Bool  m_colourRemapVideoSignalInfoPresentFlag;
+  Bool  m_colourRemapFullRangeFlag;
+  Int   m_colourRemapPrimaries;
+  Int   m_colourRemapTransferFunction;
+  Int   m_colourRemapMatrixCoefficients;
+  Int   m_colourRemapInputBitDepth;
+  Int   m_colourRemapBitDepth;
+  Int   m_preLutNumValMinus1[3];
+  std::vector<Int> m_preLutCodedValue[3];
+  std::vector<Int> m_preLutTargetValue[3];
+  Bool  m_colourRemapMatrixPresentFlag;
+  Int   m_log2MatrixDenom;
+  Int   m_colourRemapCoeffs[3][3];
+  Int   m_postLutNumValMinus1[3];
+  std::vector<Int> m_postLutCodedValue[3];
+  std::vector<Int> m_postLutTargetValue[3];
 };
 #endif
@@ -593 +592 @@
   Bool  m_callerOwnsSEIs;
   SEIMessages m_nestedSEIs;
+#if VPS_VUI_BSP_HRD_PARAMS
+  Int  m_seiPartitioningSchemeIdx;
+  Int  m_seiOlsIdx;
+#endif
 };
 
@@ -607 +610 @@
 };
 
+#if !REMOVE_BSP_HRD_SEI
 class SEIBspHrd : public SEI
 {
@@ -627 +631 @@
   TComHRD *hrd;
 };
+#endif
 
 #endif

trunk/source/Lib/TLibCommon/TCom3DAsymLUT.cpp

@@ -17 +17 @@
   m_pCuboid = NULL;
   m_nResQuanBit = 0;
+#if R0164_CGS_LUT_BUGFIX_CHECK
+  m_pCuboidExplicit = NULL;
+  m_pCuboidFilled = NULL;
+#endif
 }
 
@@ -24 +28 @@
 }
 
-Void TCom3DAsymLUT::create( Int nMaxOctantDepth , Int nInputBitDepth , Int nInputBitDepthC , Int nOutputBitDepth , Int nOutputBitDepthC , Int nMaxYPartNumLog2 )
+Void TCom3DAsymLUT::create( Int nMaxOctantDepth , Int nInputBitDepth , Int nInputBitDepthC , Int nOutputBitDepth , Int nOutputBitDepthC , Int nMaxYPartNumLog2 
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  , Int nAdaptCThresholdU , Int nAdaptCThresholdV
+#endif
+  )
 {
   m_nMaxOctantDepth = nMaxOctantDepth;
@@ -36 +44 @@
   m_nMaxPartNumLog2 = 3 * m_nMaxOctantDepth + m_nMaxYPartNumLog2;
 
-  xUpdatePartitioning( nMaxOctantDepth , nMaxYPartNumLog2 );
+  xUpdatePartitioning( nMaxOctantDepth , nMaxYPartNumLog2 
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+    , nAdaptCThresholdU , nAdaptCThresholdV
+#endif
+    );
 
   m_nYSize = 1 << ( m_nMaxOctantDepth + m_nMaxYPartNumLog2 );
@@ -48 +60 @@
   }
   xAllocate3DArray( m_pCuboid , m_nYSize , m_nUSize , m_nVSize );
+
+#if R0164_CGS_LUT_BUGFIX_CHECK
+  xAllocate3DArray( m_pCuboidExplicit , m_nYSize , m_nUSize , m_nVSize );
+  xAllocate3DArray( m_pCuboidFilled   , m_nYSize , m_nUSize , m_nVSize );
+#endif
 }
 
@@ -53 +70 @@
 {
   xFree3DArray( m_pCuboid );
-}
-
-Void TCom3DAsymLUT::xUpdatePartitioning( Int nCurOctantDepth , Int nCurYPartNumLog2 )
+#if R0164_CGS_LUT_BUGFIX_CHECK
+  xFree3DArray( m_pCuboidExplicit );
+  xFree3DArray( m_pCuboidFilled   );
+#endif
+}
+
+
+Void TCom3DAsymLUT::xUpdatePartitioning( Int nCurOctantDepth , Int nCurYPartNumLog2 
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  , Int nAdaptCThresholdU , Int nAdaptCThresholdV
+#endif
+  )
 {
   assert( nCurOctantDepth <= m_nMaxOctantDepth );
+#if R0179_CGS_SIZE_8x1x1
+  assert( nCurYPartNumLog2 + nCurOctantDepth <= m_nMaxYPartNumLog2 + m_nMaxOctantDepth );
+#else
   assert( nCurYPartNumLog2 <= m_nMaxYPartNumLog2 );
+#endif 
 
   m_nCurOctantDepth = nCurOctantDepth;
@@ -64 +94 @@
   m_nYShift2Idx = m_nInputBitDepthY - m_nCurOctantDepth - m_nCurYPartNumLog2;
   m_nUShift2Idx = m_nVShift2Idx = m_nInputBitDepthC - m_nCurOctantDepth;
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  m_nMappingShift = 10 + m_nInputBitDepthY - m_nOutputBitDepthY; 
+  m_nAdaptCThresholdU = nAdaptCThresholdU;
+  m_nAdaptCThresholdV = nAdaptCThresholdV;
+#else
   m_nMappingShift = m_nYShift2Idx + m_nUShift2Idx;
+#endif
   m_nMappingOffset = 1 << ( m_nMappingShift - 1 );
+
+#if R0179_ENC_OPT_3DLUT_SIZE
+  m_nYSize = 1 << ( m_nCurOctantDepth + m_nCurYPartNumLog2 );
+  m_nUSize = 1 << m_nCurOctantDepth;
+  m_nVSize = 1 << m_nCurOctantDepth;
+#endif
 }
 
@@ -159 +201 @@
   
   SYUVP sPred;
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  sPred.Y = sPred.U = sPred.V = 0;
+  if( nVertexIdx == 0 )
+    sPred.Y = xGetNormCoeffOne() << ( m_nOutputBitDepthY - m_nInputBitDepthY );
+  else if( nVertexIdx == 1 )
+    sPred.U = xGetNormCoeffOne() << ( m_nOutputBitDepthY - m_nInputBitDepthY );
+  else if( nVertexIdx == 2 )
+    sPred.V = xGetNormCoeffOne() << ( m_nOutputBitDepthY - m_nInputBitDepthY );
+#else
   sPred.Y = ( yIdx + m_nVertexIdxOffset[nVertexIdx][0] ) << ( m_nYShift2Idx + m_nDeltaBitDepth );
   sPred.U = ( uIdx + m_nVertexIdxOffset[nVertexIdx][1] ) << ( m_nUShift2Idx + m_nDeltaBitDepthC );
   sPred.V = ( vIdx + m_nVertexIdxOffset[nVertexIdx][2] ) << ( m_nVShift2Idx + m_nDeltaBitDepthC );
+#endif
   return( sPred );
 }
@@ -169 +221 @@
   SCuboid***  pCuboid = pCurCuboid ? pCurCuboid : m_pCuboid ;
 
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  SYUVP sPred;
+  if( yIdx == 0 )
+  {
+    sPred.Y = nVertexIdx == 0 ? 1024 : 0;
+    sPred.U = nVertexIdx == 1 ? 1024 : 0;
+    sPred.V = nVertexIdx == 2 ? 1024 : 0;
+  }
+  else
+  {
+    sPred = pCuboid[yIdx-1][uIdx][vIdx].P[nVertexIdx];
+  }
+#else
   // PredA
   SYUVP sPredA = xGetCuboidVertexPredA( yIdx , uIdx , vIdx , nVertexIdx );
@@ -196 +261 @@
   sPred.U = sPredA.U + sPredB.U;
   sPred.V = sPredA.V + sPredB.V;
-
+#endif
   return sPred ;
 }
@@ -220 +285 @@
   rYUVP.U = sPred.U + ( deltaU << m_nResQuanBit );
   rYUVP.V = sPred.V + ( deltaV << m_nResQuanBit );
+#if R0150_CGS_SIGNAL_CONSTRAINTS
+  // LUT coefficients are less than 12-bit
+  assert( -2048 <= rYUVP.Y && rYUVP.Y <= 2047 );
+  assert( -2048 <= rYUVP.U && rYUVP.U <= 2047 );
+  assert( -2048 <= rYUVP.V && rYUVP.V <= 2047 );
+#endif
 }
 
 Pel TCom3DAsymLUT::xMapY( Pel y , Pel u , Pel v )
 {
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  const SCuboid & rCuboid = m_pCuboid[xGetYIdx(y)][xGetUIdx(u)][xGetVIdx(v)];
+  Pel dstY = ( ( rCuboid.P[0].Y * y + rCuboid.P[1].Y * u + rCuboid.P[2].Y * v + m_nMappingOffset ) >> m_nMappingShift ) + rCuboid.P[3].Y;
+#else
   const SCuboid & rCuboid = m_pCuboid[y>>m_nYShift2Idx][u>>m_nUShift2Idx][v>>m_nVShift2Idx];
   Pel dstY = rCuboid.P[0].Y;
@@ -233 +308 @@
                    + ( ( deltaV * ( rCuboid.P[2].Y - rCuboid.P[1].Y ) ) << m_nYShift2Idx ) 
                    + m_nMappingOffset ) >> m_nMappingShift );
+#endif
   return( dstY );
 }
@@ -238 +314 @@
 SYUVP TCom3DAsymLUT::xMapUV( Pel y , Pel u , Pel v )
 {
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  const SCuboid & rCuboid = m_pCuboid[xGetYIdx(y)][xGetUIdx(u)][xGetVIdx(v)];
+  SYUVP dst;
+  dst.Y = 0;
+  dst.U = ( ( rCuboid.P[0].U * y + rCuboid.P[1].U * u + rCuboid.P[2].U * v + m_nMappingOffset ) >> m_nMappingShift ) + rCuboid.P[3].U;
+  dst.V = ( ( rCuboid.P[0].V * y + rCuboid.P[1].V * u + rCuboid.P[2].V * v + m_nMappingOffset ) >> m_nMappingShift ) + rCuboid.P[3].V;
+#else
   const SCuboid & rCuboid = m_pCuboid[y>>m_nYShift2Idx][u>>m_nUShift2Idx][v>>m_nVShift2Idx];
   SYUVP dst = rCuboid.P[0];
@@ -251 +334 @@
                     + ( ( deltaV * ( rCuboid.P[2].V - rCuboid.P[1].V ) ) << m_nYShift2Idx ) 
                     + m_nMappingOffset ) >> m_nMappingShift );
+#endif
   return( dst );
 }
@@ -256 +340 @@
 Void TCom3DAsymLUT::xSaveCuboids( SCuboid *** pSrcCuboid )
 {
+#if R0179_ENC_OPT_3DLUT_SIZE
+  memcpy( m_pCuboid[0][0] , pSrcCuboid[0][0] , sizeof( SCuboid ) * getMaxYSize() * getMaxCSize() * getMaxCSize() );
+#else
   memcpy( m_pCuboid[0][0] , pSrcCuboid[0][0] , sizeof( SCuboid ) * m_nYSize * m_nUSize * m_nVSize );
+#endif 
 }
 
@@ -262 +350 @@
 {
   assert( pSrc->getMaxOctantDepth() == getMaxOctantDepth() && pSrc->getMaxYPartNumLog2() == getMaxYPartNumLog2() );
-  xUpdatePartitioning( pSrc->getCurOctantDepth() , pSrc->getCurYPartNumLog2() );
+  xUpdatePartitioning( pSrc->getCurOctantDepth() , pSrc->getCurYPartNumLog2() 
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+    , pSrc->getAdaptChromaThresholdU() , pSrc->getAdaptChromaThresholdV()
+#endif
+    );
   setResQuantBit( pSrc->getResQuantBit() );
   xSaveCuboids( pSrc->m_pCuboid );
 }
 
-#endif
-
+#if R0164_CGS_LUT_BUGFIX_CHECK
+Void TCom3DAsymLUT::xInitCuboids( )
+{
+  // All vertices are initialized as non-exlicitly-encoded
+  for( Int yIdx = 0 ; yIdx < m_nYSize ; yIdx++ )
+  {
+    for( Int uIdx = 0 ; uIdx < m_nUSize ; uIdx++ )
+    {
+      for( Int vIdx = 0 ; vIdx < m_nVSize ; vIdx++ )
+      { 
+        m_pCuboidExplicit[yIdx][uIdx][vIdx] = false;
+        m_pCuboidFilled[yIdx][uIdx][vIdx]   = false;
+      }
+    }
+  }
+}
+
+Void TCom3DAsymLUT::xCuboidsFilledCheck( Int yIdx , Int uIdx , Int vIdx )
+{
+  if ( m_pCuboidFilled[yIdx][uIdx][vIdx] == false )
+  {
+    if( yIdx > 0) 
+      assert ( m_pCuboidFilled[yIdx-1][uIdx][vIdx] );
+
+    for ( Int nVertexIdx=0 ; nVertexIdx<4 ; nVertexIdx++ )
+      m_pCuboid[yIdx][uIdx][vIdx].P[nVertexIdx] = yIdx == 0 ? xGetCuboidVertexPredA( yIdx , uIdx , vIdx , nVertexIdx ): xGetCuboidVertexPredAll( yIdx , uIdx , vIdx , nVertexIdx );
+
+    m_pCuboidFilled[yIdx][uIdx][vIdx] = true ;
+  }
+}
+
+
+Void TCom3DAsymLUT::xCuboidsFilledCheck( Bool bDecode )
+{
+  Int ySize = 1 << ( getCurOctantDepth() + getCurYPartNumLog2() );
+  Int uSize = 1 << getCurOctantDepth();
+  Int vSize = 1 << getCurOctantDepth();
+  for( Int yIdx = 0 ; yIdx < ySize ; yIdx++ )
+  {
+    for( Int uIdx = 0 ; uIdx < uSize ; uIdx++ )
+    {
+      for( Int vIdx = 0 ; vIdx < vSize ; vIdx++ )
+      { 
+        if ( bDecode )
+          xCuboidsFilledCheck( yIdx , uIdx , vIdx );
+
+        assert( m_pCuboidFilled[yIdx][uIdx][vIdx] );
+      }
+    }
+  }
+
+}
+#endif
+
+#if R0150_CGS_SIGNAL_CONSTRAINTS
+Bool TCom3DAsymLUT::isRefLayer( UInt uiRefLayerId )
+{
+  Bool bIsRefLayer = false;
+  for( UInt i = 0 ; i < m_vRefLayerId.size() ; i++ )
+  {
+    if( m_vRefLayerId[i] == uiRefLayerId )
+    {
+      bIsRefLayer = true;
+      break;
+    }
+  }
+
+  return( bIsRefLayer );
+}
+#endif
+
+#if R0164_CGS_LUT_BUGFIX_CHECK
+Void  TCom3DAsymLUT::display( Bool bFilled )
+{
+  Int ySize = 1 << ( getCurOctantDepth() + getCurYPartNumLog2() );
+  Int uSize = 1 << getCurOctantDepth();
+  Int vSize = 1 << getCurOctantDepth();
+  Int vIdx=0;
+
+  printf("\n");
+  printf("3DLut Explicit flag:\n");
+  for( Int uIdx = 0 ; uIdx < uSize ; uIdx++ )
+  {
+    for( Int yIdx = 0 ; yIdx < ySize ; yIdx++ )
+    {
+      printf("%d\t", m_pCuboidExplicit[yIdx][uIdx][vIdx] );
+    }
+    printf("\n");
+  }
+
+  printf("3DLut values (explicit):\n");
+  for( Int uIdx = 0 ; uIdx < uSize ; uIdx++ )
+  {
+    for( Int yIdx = 0 ; yIdx < ySize ; yIdx++ )
+    {
+      if ( m_pCuboidExplicit[yIdx][uIdx][vIdx] )  printf("%d\t", m_pCuboid[yIdx][uIdx][vIdx].P[0].Y );
+      else                                        printf("?\t", m_pCuboid[yIdx][uIdx][vIdx].P[0].Y );
+    }
+    printf("\n");
+  }
+
+  printf("3DLut values (all):\n");
+  for( Int uIdx = 0 ; uIdx < uSize ; uIdx++ )
+  {
+    for( Int yIdx = 0 ; yIdx < ySize ; yIdx++ )
+    {
+      if ( bFilled ) {
+        if ( m_pCuboidFilled[yIdx][uIdx][vIdx] )  printf("%d\t"  , m_pCuboid[yIdx][uIdx][vIdx].P[0].Y );
+        else                                      printf("unk\t" , m_pCuboid[yIdx][uIdx][vIdx].P[0].Y );
+      }
+      else
+        printf("%d\t"  , m_pCuboid[yIdx][uIdx][vIdx].P[0].Y );
+    }
+    printf("\n");
+  }
+
+}
+#endif
+
+#endif
+

trunk/source/Lib/TLibCommon/TCom3DAsymLUT.h

@@ -4 +4 @@
 
 #include "TypeDef.h"
+#if R0150_CGS_SIGNAL_CONSTRAINTS
+#include <cassert>
+#include <vector>
+#endif
 
 #if Q0048_CGS_3D_ASYMLUT
@@ -25 +29 @@
   virtual ~TCom3DAsymLUT();
 
-  virtual Void  create( Int nMaxOctantDepth , Int nInputBitDepth , Int nInputBitDepthC , Int nOutputBitDepth , Int nOutputBitDepthC , Int nMaxYPartNumLog2 );
+  virtual Void  create( Int nMaxOctantDepth , Int nInputBitDepth , Int nInputBitDepthC , Int nOutputBitDepth , Int nOutputBitDepthC , Int nMaxYPartNumLog2 
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  , Int nAdaptCThresholdU , Int nAdaptCThresholdV
+#endif
+    );
   virtual Void  destroy();
 
@@ -36 +44 @@
   Int   getResQuantBit()     { return m_nResQuanBit; }
   Void  setResQuantBit(Int n){ m_nResQuanBit = n; }
+#if R0300_CGS_RES_COEFF_CODING 
+  Int   getMappingShift()     { return m_nMappingShift; }
+  Int   getDeltaBits()        { return m_nDeltaBits; }
+  Void  setDeltaBits(Int n)   { m_nDeltaBits = n; }
+#endif 
   Int   getMaxYPartNumLog2() { return m_nMaxYPartNumLog2; }
   Int   getCurYPartNumLog2() { return m_nCurYPartNumLog2; }
+#if R0150_CGS_SIGNAL_CONSTRAINTS
+  Void  addRefLayerId( UInt uiRefLayerId )  
+  { 
+    if( !isRefLayer( uiRefLayerId ) )
+      m_vRefLayerId.push_back( uiRefLayerId ); 
+  }
+  size_t  getRefLayerNum()     { return m_vRefLayerId.size();  }
+  UInt  getRefLayerId( UInt n )  { assert( n < m_vRefLayerId.size() ); return m_vRefLayerId[n];   }
+  Bool  isRefLayer( UInt uiRefLayerId );
+#endif
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  Void  setAdaptChromaThresholdU( Int n ) { m_nAdaptCThresholdU = n; }
+  Int   getAdaptChromaThresholdU()        { return m_nAdaptCThresholdU; }
+  Void  setAdaptChromaThresholdV( Int n ) { m_nAdaptCThresholdV = n;  }
+  Int   getAdaptChromaThresholdV()        { return m_nAdaptCThresholdV; }
+#endif
+#if R0179_ENC_OPT_3DLUT_SIZE
+  Int   getMaxYSize() { return 1<<(m_nMaxOctantDepth+m_nMaxYPartNumLog2); }
+  Int   getMaxCSize() { return 1<<m_nMaxOctantDepth; }
+#endif 
 
   Void  colorMapping( TComPicYuv * pcPicSrc,  TComPicYuv * pcPicDst );
@@ -45 +78 @@
   SYUVP getCuboidVertexResTree( Int yIdx , Int uIdx , Int vIdx , Int nVertexIdx );
   Void  setCuboidVertexResTree( Int yIdx , Int uIdx , Int vIdx , Int nVertexIdx , Int deltaY , Int deltaU , Int deltaV );
-
+#if R0164_CGS_LUT_BUGFIX_CHECK
+  Void  xInitCuboids( );
+  Void  xCuboidsFilledCheck( Int yIdx , Int uIdx , Int vIdx );
+  Void  xCuboidsFilledCheck( Bool bDecode );
+  Void  display( Bool bFilled=true );
+  Void  xSetExplicit( Int yIdx , Int uIdx , Int vIdx )  { m_pCuboidExplicit[yIdx][uIdx][vIdx] = true ; xSetFilled(yIdx,uIdx,vIdx); }
+  Void  xSetFilled( Int yIdx , Int uIdx , Int vIdx )    { m_pCuboidFilled[yIdx][uIdx][vIdx] = true ; }
+#endif
 
 private:
@@ -68 +108 @@
   Int   m_nMappingOffset;
   Int   m_nResQuanBit;
+#if R0300_CGS_RES_COEFF_CODING
+  Int   m_nDeltaBits;
+#endif
   SCuboid *** m_pCuboid;
   const static Int m_nVertexIdxOffset[4][3];
+#if R0150_CGS_SIGNAL_CONSTRAINTS
+  std::vector<UInt> m_vRefLayerId;
+#endif
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  Int   m_nAdaptCThresholdU;
+  Int   m_nAdaptCThresholdV;
+#endif
+#if R0164_CGS_LUT_BUGFIX_CHECK
+  Bool  *** m_pCuboidExplicit;
+  Bool  *** m_pCuboidFilled;
+#endif
 
 protected:
@@ -79 +133 @@
   Void xFree3DArray( T *** &p );
 
-  Void  xUpdatePartitioning( Int nCurOctantDepth , Int nCurYPartNumLog2 );
+  Void  xUpdatePartitioning( Int nCurOctantDepth , Int nCurYPartNumLog2 
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+    , Int nAdaptCThresholdU , Int nAdaptCThreshodV
+#endif
+    );
   SYUVP xGetCuboidVertexPredA( Int yIdx , Int uIdx , Int vIdx , Int nVertexIdx );
   Pel   xMapY( Pel y , Pel u , Pel v );
@@ -87 +145 @@
   Int   xGetUSize()  { return m_nUSize;  }
   Int   xGetVSize()  { return m_nVSize;  }
+#if R0151_CGS_3D_ASYMLUT_IMPROVE
+  Int   xGetYIdx(Pel y)  { return( y >> m_nYShift2Idx ); }
+  Int   xGetUIdx(Pel u)  { return( m_nCurOctantDepth == 1 ? u >= m_nAdaptCThresholdU : u >> m_nUShift2Idx ); }
+  Int   xGetVIdx(Pel v)  { return( m_nCurOctantDepth == 1 ? v >= m_nAdaptCThresholdV : v >> m_nVShift2Idx ); }
+  Int   xGetNormCoeffOne()    { return( 1 << m_nMappingShift ); }
+#else
   Int   xGetYShift2Idx() { return m_nYShift2Idx; }
   Int   xGetUShift2Idx() { return m_nUShift2Idx; }
   Int   xGetVShift2Idx() { return m_nVShift2Idx; } 
+#endif
   SCuboid & xGetCuboid( Int yIdx , Int uIdx , Int vIdx ){ return m_pCuboid[yIdx][uIdx][vIdx];  }
   Void  xSaveCuboids( SCuboid *** pSrcCuboid );

trunk/source/Lib/TLibCommon/TComDataCU.cpp

@@ -3481 +3481 @@
 
 #if SVC_EXTENSION
-TComDataCU*  TComDataCU::getBaseColCU( UInt refLayerIdc, UInt uiCuAbsPartIdx, UInt &uiCUAddrBase, UInt &uiAbsPartIdxBase, Int iMotionMapping )
+TComDataCU* TComDataCU::getBaseColCU( UInt refLayerIdc, UInt uiCuAbsPartIdx, UInt &uiCUAddrBase, UInt &uiAbsPartIdxBase, Bool motionMapping )
 {
   UInt uiPelX = getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiCuAbsPartIdx] ];
   UInt uiPelY = getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiCuAbsPartIdx] ];
 
-  return getBaseColCU( refLayerIdc, uiPelX, uiPelY, uiCUAddrBase, uiAbsPartIdxBase, iMotionMapping );
-}
-
-TComDataCU*  TComDataCU::getBaseColCU( UInt refLayerIdc, UInt uiPelX, UInt uiPelY, UInt &uiCUAddrBase, UInt &uiAbsPartIdxBase, Int iMotionMapping )
+  return getBaseColCU( refLayerIdc, uiPelX, uiPelY, uiCUAddrBase, uiAbsPartIdxBase, motionMapping );
+}
+
+TComDataCU* TComDataCU::getBaseColCU( UInt refLayerIdc, UInt pelX, UInt pelY, UInt &uiCUAddrBase, UInt &uiAbsPartIdxBase, Bool motionMapping )
 {
   TComPic* baseColPic = m_pcSlice->getBaseColPic(refLayerIdc);
 
-  uiPelX = (UInt)Clip3<UInt>(0, m_pcPic->getPicYuvRec()->getWidth() - 1, uiPelX);
-  uiPelY = (UInt)Clip3<UInt>(0, m_pcPic->getPicYuvRec()->getHeight() - 1, uiPelY);
+  UInt uiPelX = (UInt)Clip3<UInt>(0, m_pcPic->getPicYuvRec()->getWidth()  - 1, pelX);
+  UInt uiPelY = (UInt)Clip3<UInt>(0, m_pcPic->getPicYuvRec()->getHeight() - 1, pelY);
+
+#if REF_IDX_MFM
+  // centre of the collocated 16x16 block for motion mapping
+  if( motionMapping )
+  {
+    uiPelX = pelX + 8;
+    uiPelY = pelY + 8;
+  }
+#endif
 
 #if !LAYER_CTB
@@ -3500 +3509 @@
 #endif
 
+#if MOVE_SCALED_OFFSET_TO_PPS
+#if O0098_SCALED_REF_LAYER_ID
+  Int leftStartL = baseColPic->getSlice(0)->getPPS()->getScaledRefLayerWindowForLayer(baseColPic->getSlice(0)->getVPS()->getRefLayerId(getSlice()->getLayerId(), refLayerIdc)).getWindowLeftOffset();
+  Int topStartL  = baseColPic->getSlice(0)->getPPS()->getScaledRefLayerWindowForLayer(baseColPic->getSlice(0)->getVPS()->getRefLayerId(getSlice()->getLayerId(), refLayerIdc)).getWindowTopOffset();
+#else
+  Int leftStartL = baseColPic->getSlice(0)->getPPS()->getScaledRefLayerWindow(refLayerIdc).getWindowLeftOffset();
+  Int topStartL  = baseColPic->getSlice(0)->getPPS()->getScaledRefLayerWindow(refLayerIdc).getWindowTopOffset();
+#endif
+#else
 #if O0098_SCALED_REF_LAYER_ID
   Int leftStartL = baseColPic->getSlice(0)->getSPS()->getScaledRefLayerWindowForLayer(baseColPic->getSlice(0)->getVPS()->getRefLayerId(getSlice()->getLayerId(), refLayerIdc)).getWindowLeftOffset();
@@ -3507 +3525 @@
   Int topStartL  = baseColPic->getSlice(0)->getSPS()->getScaledRefLayerWindow(refLayerIdc).getWindowTopOffset();
 #endif
-
+#endif
+
+#if REF_REGION_OFFSET
+  const Window &windowRL = baseColPic->getSlice(0)->getPPS()->getRefLayerWindow(refLayerIdc);
+  Int iBX = (((uiPelX - leftStartL)*g_posScalingFactor[refLayerIdc][0] + (1<<15)) >> 16) + windowRL.getWindowLeftOffset();
+  Int iBY = (((uiPelY - topStartL )*g_posScalingFactor[refLayerIdc][1] + (1<<15)) >> 16) + windowRL.getWindowTopOffset();
+#else
 #if Q0200_CONFORMANCE_BL_SIZE
   Int chromaFormatIdc = baseColPic->getSlice(0)->getChromaFormatIdc();
@@ -3516 +3540 @@
   Int iBY = ((uiPelY - topStartL )*g_posScalingFactor[refLayerIdc][1] + (1<<15)) >> 16;
 #endif
+#endif
 
 #if REF_IDX_MFM
   // offset for collocated block in the motion mapping
-  if( iMotionMapping == 1 )
-  {
-    Bool unequalPictureSizeFlag = g_posScalingFactor[refLayerIdc][0] != 65536 || g_posScalingFactor[refLayerIdc][1] != 65536; //the condition should be updated according to the WD.
-
-    // actually, motion field compression is performed in the Void TComPic::compressMotion() function, but with (+4) the rounding may have effect on the picture boundary check.
-    if( unequalPictureSizeFlag )
-    {
+  if( motionMapping )
+  {
+    if( m_pcPic->equalPictureSizeAndOffsetFlag(refLayerIdc) )
+    {
+      // copy motion field from the same sample position for the case of 1x scaling ratio and same offset value between the current and reference layers
+      iBX = pelX;
+      iBY = pelY;
+    }
+    else
+    {
+      // actually, motion field compression is performed in the Void TComPic::compressMotion() function, but with (+4) the rounding may have effect on the picture boundary check.
       iBX = ( ( iBX + 4 ) >> 4 ) << 4;
       iBY = ( ( iBY + 4 ) >> 4 ) << 4;
-    }
-    else
-    {
-      iBX += 4;
-      iBY += 4;
     }
   }
@@ -3587 +3611 @@
 {
   // check BL mode
-  UInt          uiCUAddrBase = 0, uiAbsPartAddrBase = 0;
+  UInt uiCUAddrBase = 0, uiAbsPartAddrBase = 0;
   // the right reference layerIdc should be specified, currently it is set to m_layerId-1
-  TComDataCU*   pcTempCU = getBaseColCU(m_layerId - 1, uiAbsPartIdx, uiCUAddrBase, uiAbsPartAddrBase, 0 );
+  TComDataCU* pcTempCU = getBaseColCU(m_layerId - 1, uiAbsPartIdx, uiCUAddrBase, uiAbsPartAddrBase, false );
 
   if( pcTempCU->getPredictionMode( uiAbsPartAddrBase ) != MODE_INTRA )

trunk/source/Lib/TLibCommon/TComDataCU.h

@@ -469 +469 @@
   Bool xCheckZeroMVILRMvdL1Zero(Int iRefList, Int iRefIdx, Int MvpIdx);
 #endif
-  TComDataCU*   getBaseColCU( UInt refLayerIdc, UInt uiCuAbsPartIdx, UInt &uiCUAddrBase, UInt &uiAbsPartIdxBase, Int iMotionMapping = 0 );
-  TComDataCU*   getBaseColCU( UInt refLayerIdc, UInt uiPelX, UInt uiPelY, UInt &uiCUAddrBase, UInt &uiAbsPartIdxBase, Int iMotionMapping = 0 );
+  TComDataCU*   getBaseColCU( UInt refLayerIdc, UInt uiCuAbsPartIdx, UInt &uiCUAddrBase, UInt &uiAbsPartIdxBase, Bool motionMapping = false );
+  TComDataCU*   getBaseColCU( UInt refLayerIdc, UInt pelX, UInt pelY, UInt &uiCUAddrBase, UInt &uiAbsPartIdxBase, Bool motionMapping = false );
   Void          scaleBaseMV( UInt refLayerIdc, TComMvField& rcMvFieldEnhance, TComMvField& rcMvFieldBase );
 #endif

trunk/source/Lib/TLibCommon/TComMotionInfo.h

@@ -155 +155 @@
   Void compress(Char* pePredMode, Int scale); 
 
-#if AVC_SYNTAX
-  Void           setMv    (TComMv cMv,  Int iIdx )         { m_pcMv    [iIdx] = cMv; }
-  Void           setRefIdx(Int iRefIdx, Int iIdx   )       { m_piRefIdx[iIdx] =  iRefIdx; }
-#endif
-
 #if REF_IDX_MFM
   Void setMvField( TComMvField const& mvField, Int iIdx )

trunk/source/Lib/TLibCommon/TComPic.cpp

@@ -64 +64 @@
   memset( m_pcFullPelBaseRec, 0, sizeof( m_pcFullPelBaseRec ) );
   memset( m_bSpatialEnhLayer, false, sizeof( m_bSpatialEnhLayer ) );
+  memset( m_equalPictureSizeAndOffsetFlag, false, sizeof( m_equalPictureSizeAndOffsetFlag ) );
 #endif
   m_apcPicYuv[0]      = NULL;
@@ -84 +85 @@
   if (!bIsVirtual)
   {
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
+#if AUXILIARY_PICTURES
+    m_apcPicYuv[0]  = new TComPicYuv;  m_apcPicYuv[0]->create( iWidth, iHeight, chromaFormatIDC, uiMaxWidth, uiMaxHeight, uiMaxDepth, &conformanceWindow );
+#else
+    m_apcPicYuv[0]  = new TComPicYuv;  m_apcPicYuv[0]->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth, &conformanceWindow );
+#endif
+#else
 #if AUXILIARY_PICTURES
     m_apcPicYuv[0]  = new TComPicYuv;  m_apcPicYuv[0]->create( iWidth, iHeight, chromaFormatIDC, uiMaxWidth, uiMaxHeight, uiMaxDepth, pcSps );
@@ -89 +97 @@
     m_apcPicYuv[0]  = new TComPicYuv;  m_apcPicYuv[0]->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth, pcSps );
 #endif
-  }
+#endif
+  }
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
+#if AUXILIARY_PICTURES
+  m_apcPicYuv[1]  = new TComPicYuv;  m_apcPicYuv[1]->create( iWidth, iHeight, chromaFormatIDC, uiMaxWidth, uiMaxHeight, uiMaxDepth, &conformanceWindow );
+#else
+  m_apcPicYuv[1]  = new TComPicYuv;  m_apcPicYuv[1]->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth, &conformanceWindow );
+#endif
+#else
 #if AUXILIARY_PICTURES
   m_apcPicYuv[1]  = new TComPicYuv;  m_apcPicYuv[1]->create( iWidth, iHeight, chromaFormatIDC, uiMaxWidth, uiMaxHeight, uiMaxDepth, pcSps );
@@ -95 +111 @@
   m_apcPicYuv[1]  = new TComPicYuv;  m_apcPicYuv[1]->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth, pcSps );
 #endif
+#endif
 
   for( Int i = 0; i < MAX_LAYERS; i++ )
@@ -100 +117 @@
     if( m_bSpatialEnhLayer[i] )
     {
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
+#if AUXILIARY_PICTURES
+      m_pcFullPelBaseRec[i] = new TComPicYuv;  m_pcFullPelBaseRec[i]->create( iWidth, iHeight, chromaFormatIDC, uiMaxWidth, uiMaxHeight, uiMaxDepth, &conformanceWindow );
+#else
+      m_pcFullPelBaseRec[i] = new TComPicYuv;  m_pcFullPelBaseRec[i]->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth, &conformanceWindow );
+#endif
+#else
 #if AUXILIARY_PICTURES
       m_pcFullPelBaseRec[i] = new TComPicYuv;  m_pcFullPelBaseRec[i]->create( iWidth, iHeight, chromaFormatIDC, uiMaxWidth, uiMaxHeight, uiMaxDepth, pcSps );
 #else
       m_pcFullPelBaseRec[i] = new TComPicYuv;  m_pcFullPelBaseRec[i]->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth, pcSps );
+#endif
 #endif
     }
@@ -187 +212 @@
   for( Int i = 0; i < MAX_LAYERS; i++ )
   {
-    if( m_bSpatialEnhLayer[i] )
+    if( m_bSpatialEnhLayer[i] && m_pcFullPelBaseRec[i] )
     {
       m_pcFullPelBaseRec[i]->destroy();
@@ -260 +285 @@
 Void TComPic::copyUpsampledMvField(UInt refLayerIdc, TComPic* pcPicBase)
 {
-  UInt numPartitions   = 1<<(g_uiMaxCUDepth<<1);
-  UInt widthMinPU      = g_uiMaxCUWidth/(1<<g_uiMaxCUDepth);
-  UInt heightMinPU     = g_uiMaxCUHeight/(1<<g_uiMaxCUDepth);
-  Int  unitNum         = max (1, (Int)((16/widthMinPU)*(16/heightMinPU)) ); 
+  UInt numPartitions = 1<<(g_uiMaxCUDepth<<1);
+  UInt widthMinPU    = g_uiMaxCUWidth/(1<<g_uiMaxCUDepth);
+  UInt heightMinPU   = g_uiMaxCUHeight/(1<<g_uiMaxCUDepth);
+  Int  unitNum       = max (1, (Int)((16/widthMinPU)*(16/heightMinPU)) ); 
 
   for(UInt cuIdx = 0; cuIdx < getPicSym()->getNumberOfCUsInFrame(); cuIdx++)  //each LCU
@@ -277 +302 @@
 
       TComDataCU *pcColCU = 0;
-      pcColCU = pcCUDes->getBaseColCU(refLayerIdc, pelX + 8, pelY + 8, baseCUAddr, baseAbsPartIdx, 1);
+      pcColCU = pcCUDes->getBaseColCU(refLayerIdc, pelX, pelY, baseCUAddr, baseAbsPartIdx, true);
 
       if( pcColCU && (pcColCU->getPredictionMode(baseAbsPartIdx) != MODE_NONE) && (pcColCU->getPredictionMode(baseAbsPartIdx) != MODE_INTRA) )  //base layer unit not skip and invalid mode
@@ -306 +331 @@
       }
     }
-    memset( pcCUDes->getPartitionSize(), SIZE_2Nx2N, sizeof(Char)*numPartitions);
+    memset( pcCUDes->getPartitionSize(), SIZE_2Nx2N, sizeof(Char)*numPartitions );
   }
 }
@@ -332 +357 @@
 }
 #endif
-#endif
-
-#if AVC_SYNTAX
-Void TComPic::readBLSyntax( fstream* filestream, UInt numBytes )
-{
-  if( !filestream->good() )
-  {
-    return;
-  }
-
-  UInt   width      = this->getPicYuvRec()->getWidth();
-  UInt   height     = this->getPicYuvRec()->getHeight();
-
-  UInt64 poc        = (UInt64)this->getPOC();
-  UInt   partWidth  = width / 4;
-  UInt   partHeight = height / 4;
-
-  UInt numPartInWidth    = this->getNumPartInWidth();
-  UInt numPartInHeight   = this->getNumPartInHeight();
-  UInt numPartLCUInWidth = this->getFrameWidthInCU();
-
-  UInt64 uiPos = (UInt64)poc * width * height * numBytes / 16;
-   
-  filestream->seekg( uiPos, ios_base::beg );
-
-  for( Int i = 0; i < partHeight; i++ )
-  {
-    for( Int j = 0; j < partWidth; j++ )
-    {
-      UInt x = ( j / numPartInWidth );
-      UInt y = ( i / numPartInHeight );
-
-      UInt addrLCU = y * numPartLCUInWidth + x;
-      UInt partAddr = ( i - y * numPartInHeight ) * numPartInWidth + ( j - x * numPartInWidth );
-      partAddr = g_auiRasterToZscan[partAddr];
-      
-      TComDataCU* pcCU = this->getCU( addrLCU );
-      
-      TComMv mv;
-      Short temp;
-
-      // RefIdxL0
-      Char refIdxL0 = -1;
-      filestream->read( &refIdxL0, 1 );
-      assert( refIdxL0 >= -1 );
-      pcCU->getCUMvField( REF_PIC_LIST_0 )->setRefIdx( (Int)refIdxL0, partAddr );
-
-      // RefIdxL1
-      Char refIdxL1 = -1;
-      filestream->read( &refIdxL1, 1 );
-      assert( refIdxL1 >= -1 );
-      pcCU->getCUMvField( REF_PIC_LIST_1 )->setRefIdx( (Int)refIdxL1, partAddr );
-
-      // MV L0
-      temp = 0;
-      filestream->read( reinterpret_cast<char*>(&temp), 2 );
-      mv.setHor( (Short)temp );
-      temp = 0;
-      filestream->read( reinterpret_cast<char*>(&temp), 2 );
-      mv.setVer( (Short)temp );
-      pcCU->getCUMvField( REF_PIC_LIST_0 )->setMv( mv, partAddr );
-
-      // MV L1
-      temp = 0;
-      filestream->read( reinterpret_cast<char*>(&temp), 2 );
-      mv.setHor( (Short)temp );
-      temp = 0;
-      filestream->read( reinterpret_cast<char*>(&temp), 2 );
-      mv.setVer( (Short)temp );
-      pcCU->getCUMvField( REF_PIC_LIST_1 )->setMv( mv, partAddr );
-
-      // set dependent information
-      pcCU->setPredictionMode( partAddr, ( refIdxL0 == NOT_VALID && refIdxL1 == NOT_VALID ) ? MODE_INTRA : MODE_INTER );
-      UInt interDir = ( refIdxL0 != NOT_VALID ) + ( refIdxL1 != NOT_VALID && this->getSlice(0)->isInterB() ) * 2;
-      assert( interDir <= 3 );
-      pcCU->setInterDir( partAddr, interDir );      
-    }
-  }
-}
-#endif
-
-#if SYNTAX_OUTPUT
-Void TComPic::wrireBLSyntax( fstream* filestream, UInt numBytes )
-{
-  if( !filestream->good() )
-  {
-    return;
-  }
-
-  UInt   width       = this->getPicYuvRec()->getWidth();
-  UInt   height      = this->getPicYuvRec()->getHeight();
-
-  UInt64 poc        = (UInt64)this->getPOC();
-  UInt   partWidth  = width / 4;
-  UInt   partHeight = height / 4;
-
-  UInt numPartInWidth    = this->getNumPartInWidth();
-  UInt numPartInHeight   = this->getNumPartInHeight();
-  UInt numPartLCUInWidth = this->getFrameWidthInCU();
-
-  filestream->seekg( poc * width * height * numBytes / 16 );
-    
-  for( Int i = 0; i < partHeight; i++ )
-  {
-    for( Int j = 0; j < partWidth; j++ )
-    {
-      UInt x = ( j / numPartInWidth );
-      UInt y = ( i / numPartInHeight );
-
-      UInt addrLCU = y * numPartLCUInWidth + x;
-      UInt partAddr = ( i - y * numPartInHeight ) * numPartInWidth + ( j - x * numPartInWidth );
-      partAddr = g_auiRasterToZscan[partAddr];
-      
-      TComDataCU* pcCU = this->getCU( addrLCU );
-      
-      TComMv mv;
-      Short temp;
-      Char refIdxL0 = NOT_VALID, refIdxL1 = NOT_VALID;
-
-      // RefIdx
-      if( !pcCU->isIntra( partAddr ) )
-      {
-        refIdxL0 = (Char)pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( partAddr );
-        refIdxL1 = (Char)pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( partAddr );
-      }
-      assert( refIdxL0 >= - 1 && refIdxL1 >= - 1 );
-      filestream->put( refIdxL0 );
-      filestream->put( refIdxL1 );
-
-      // MV L0
-      mv.setZero();
-      if( refIdxL0 >= 0 )
-      {
-        mv = pcCU->getCUMvField( REF_PIC_LIST_0 )->getMv( partAddr );
-      }
-      temp = (Short)mv.getHor();
-      filestream->write( reinterpret_cast<char*>(&temp), 2 );
-      temp = (Short)mv.getVer();
-      filestream->write( reinterpret_cast<char*>(&temp), 2 );
-
-      // MV L1
-      mv.setZero();
-      if( refIdxL1 >= 0 )
-      {
-        mv = pcCU->getCUMvField( REF_PIC_LIST_1 )->getMv( partAddr );
-      }
-      temp = (Short)mv.getHor();
-      filestream->write( reinterpret_cast<char*>(&temp), 2 );
-      temp = (Short)mv.getVer();
-      filestream->write( reinterpret_cast<char*>(&temp), 2 );
-    }
-  }
-}
 #endif
 
@@ -529 +401 @@
 #endif
 
+#if WPP_FIX
+UInt TComPic::getSubstreamForLCUAddr(const UInt uiLCUAddr, const Bool bAddressInRaster, TComSlice *pcSlice)
+{
+  const Int iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
+  UInt uiSubStrm;
+
+  if (iNumSubstreams > 1) // wavefronts, and possibly tiles being used.
+  {
+    TComPicSym &picSym=*(getPicSym());
+    const UInt uiLCUAddrRaster = bAddressInRaster?uiLCUAddr : picSym.getCUOrderMap(uiLCUAddr);
+    const UInt uiWidthInLCUs  = picSym.getFrameWidthInCU();
+    const UInt uiTileIndex=picSym.getTileIdxMap(uiLCUAddrRaster);
+    const UInt widthInTiles=(picSym.getNumColumnsMinus1()+1);
+    TComTile *pTile=picSym.getTComTile(uiTileIndex);
+    const UInt uiTileStartLCU = pTile->getFirstCUAddr();
+    const UInt uiTileLCUY = uiTileStartLCU / uiWidthInLCUs;
+    // independent tiles => substreams are "per tile".  iNumSubstreams has already been multiplied.
+    const UInt uiLin = uiLCUAddrRaster / uiWidthInLCUs;
+          UInt uiStartingSubstreamForTile=(uiTileLCUY*widthInTiles) + (pTile->getTileHeight()*(uiTileIndex%widthInTiles));
+    uiSubStrm = uiStartingSubstreamForTile + (uiLin-uiTileLCUY);
+  }
+  else
+  {
+    // dependent tiles => substreams are "per frame".
+    uiSubStrm = 0;//uiLin % iNumSubstreams; // x modulo 1 = 0 !
+  }
+  return uiSubStrm;
+}
+#endif
+
+
 //! \}

trunk/source/Lib/TLibCommon/TComPic.h

@@ -45 +45 @@
 #include "TComBitStream.h"
 #include "SEI.h"
-#if AVC_BASE || SYNTAX_OUTPUT
+#if AVC_BASE
 #include <fstream>
 #endif
@@ -88 +88 @@
   Bool                  m_bSpatialEnhLayer[MAX_LAYERS];       // whether current layer is a spatial enhancement layer,
   TComPicYuv*           m_pcFullPelBaseRec[MAX_LAYERS];    // upsampled base layer recontruction for difference domain inter prediction
+#if REF_IDX_MFM
+  Bool                  m_equalPictureSizeAndOffsetFlag[MAX_LAYERS]; 
+#endif
 #endif
 #if Q0048_CGS_3D_ASYMLUT
@@ -203 +206 @@
 #endif
 #if REF_IDX_MFM
+  Bool          equalPictureSizeAndOffsetFlag(UInt refLayerIdc)             { return m_equalPictureSizeAndOffsetFlag[refLayerIdc]; }
+  Void          setEqualPictureSizeAndOffsetFlag(UInt refLayerIdc, Bool b)  { m_equalPictureSizeAndOffsetFlag[refLayerIdc] = b;    }
   Void          copyUpsampledMvField  ( UInt refLayerIdc, TComPic* pcPicBase );
   Void          initUpsampledMvField  ();
@@ -213 +218 @@
 #endif
   Void  copyUpsampledPictureYuv(TComPicYuv*   pcPicYuvIn, TComPicYuv*   pcPicYuvOut); 
-#if AVC_SYNTAX
-  Void readBLSyntax( fstream* filestream, UInt numBytes );
-#endif
-#endif
-#if SYNTAX_OUTPUT
-  Void wrireBLSyntax( fstream* filestream, UInt numBytes );
 #endif
 
@@ -229 +228 @@
   Void setCurrAuFlag(Bool x) {m_currAuFlag = x; }
 #endif
+#if WPP_FIX
+  UInt          getSubstreamForLCUAddr(const UInt uiLCUAddr, const Bool bAddressInRaster, TComSlice *pcSlice);
+#endif
 };// END CLASS DEFINITION TComPic
 

trunk/source/Lib/TLibCommon/TComPicSym.cpp

@@ -38 +38 @@
 #include "TComPicSym.h"
 #include "TComSampleAdaptiveOffset.h"
+#include "TComSlice.h"
 
 //! \ingroup TLibCommon
@@ -63 +64 @@
 ,m_iNumColumnsMinus1 (0)
 ,m_iNumRowsMinus1(0)
-,m_apcTComTile(NULL)
 ,m_puiCUOrderMap(0)
 ,m_puiTileIdxMap(NULL)
@@ -101 +101 @@
     delete [] m_apcTComSlice;
   }
-  m_apcTComSlice      = new TComSlice*[m_uiNumCUsInFrame*m_uiNumPartitions];  
+  m_apcTComSlice      = new TComSlice*[m_uiNumCUsInFrame];
   m_apcTComSlice[0]   = new TComSlice;
   m_uiNumAllocatedSlice = 1;
@@ -152 +152 @@
   delete [] m_apcTComDataCU;
   m_apcTComDataCU = NULL;
-
-#if SVC_EXTENSION
-  if( m_apcTComTile )
-  {
-#endif
-  for(Int i = 0; i < (m_iNumColumnsMinus1+1)*(m_iNumRowsMinus1+1); i++ )
-  {
-    delete m_apcTComTile[i];
-  }
-  delete [] m_apcTComTile;
-#if SVC_EXTENSION
-  }
-#endif
-
-  m_apcTComTile = NULL;
 
   delete [] m_puiCUOrderMap;
@@ -193 +178 @@
 Void TComPicSym::allocateNewSlice()
 {
+  assert ((m_uiNumAllocatedSlice + 1) <= m_uiNumCUsInFrame);
   m_apcTComSlice[m_uiNumAllocatedSlice ++] = new TComSlice;
   if (m_uiNumAllocatedSlice>=2)
@@ -225 +211 @@
 }
 
-Void TComPicSym::xCreateTComTileArray()
-{
-  m_apcTComTile = new TComTile*[(m_iNumColumnsMinus1+1)*(m_iNumRowsMinus1+1)];
-  for( UInt i=0; i<(m_iNumColumnsMinus1+1)*(m_iNumRowsMinus1+1); i++ )
-  {
-    m_apcTComTile[i] = new TComTile;
-  }
-}
-
-Void TComPicSym::xInitTiles()
-{
-  UInt  uiTileIdx;
-  UInt  uiColumnIdx = 0;
-  UInt  uiRowIdx = 0;
-  UInt  uiRightEdgePosInCU;
-  UInt  uiBottomEdgePosInCU;
-  Int   i, j;
+Void TComPicSym::initTiles(TComPPS *pps)
+{
+  //set NumColumnsMinus1 and NumRowsMinus1
+  setNumColumnsMinus1( pps->getNumTileColumnsMinus1() );
+  setNumRowsMinus1( pps->getTileNumRowsMinus1() );
+
+  const Int numCols = pps->getNumTileColumnsMinus1() + 1;
+  const Int numRows = pps->getTileNumRowsMinus1() + 1;
+  const Int numTiles = numRows * numCols;
+
+  // allocate memory for tile parameters
+  m_tileParameters.resize(numTiles);
+
+  if( pps->getTileUniformSpacingFlag() )
+  {
+    //set width and height for each (uniform) tile
+    for(Int row=0; row < numRows; row++)
+  {
+      for(Int col=0; col < numCols; col++)
+      {
+        const Int tileIdx = row * numCols + col;
+        m_tileParameters[tileIdx].setTileWidth( (col+1)*getFrameWidthInCU()/numCols
+                                              - (col*getFrameWidthInCU())/numCols );
+        m_tileParameters[tileIdx].setTileHeight( (row+1)*getFrameHeightInCU()/numRows
+                                               - (row*getFrameHeightInCU())/numRows );
+      }
+    }
+  }
+  else
+  {
+    //set the width for each tile
+    for(Int row=0; row < numRows; row++)
+    {
+      Int cumulativeTileWidth = 0;
+      for(Int col=0; col < getNumColumnsMinus1(); col++)
+      {
+        m_tileParameters[row * numCols + col].setTileWidth( pps->getTileColumnWidth(col) );
+        cumulativeTileWidth += pps->getTileColumnWidth(col);
+      }
+      m_tileParameters[row * numCols + getNumColumnsMinus1()].setTileWidth( getFrameWidthInCU()-cumulativeTileWidth );
+  }
+
+    //set the height for each tile
+    for(Int col=0; col < numCols; col++)
+    {
+      Int cumulativeTileHeight = 0;
+      for(Int row=0; row < getNumRowsMinus1(); row++)
+      {
+        m_tileParameters[row * numCols + col].setTileHeight( pps->getTileRowHeight(row) );
+        cumulativeTileHeight += pps->getTileRowHeight(row);
+      }
+      m_tileParameters[getNumRowsMinus1() * numCols + col].setTileHeight( getFrameHeightInCU()-cumulativeTileHeight );
+    }
+  }
+
+#if TILE_SIZE_CHECK
+  Int minWidth  = 1;
+  Int minHeight = 1;
+  const Int profileIdc = pps->getSPS()->getPTL()->getGeneralPTL()->getProfileIdc();
+  if (  profileIdc == Profile::MAIN || profileIdc == Profile::MAIN10)
+  {
+    if (pps->getTilesEnabledFlag())
+    {
+      minHeight = 64  / g_uiMaxCUHeight;
+      minWidth  = 256 / g_uiMaxCUWidth;
+    }
+  }
+  for(Int row=0; row < numRows; row++)
+  {
+    for(Int col=0; col < numCols; col++)
+    {
+      const Int tileIdx = row * numCols + col;
+      assert (m_tileParameters[tileIdx].getTileWidth() >= minWidth);
+      assert (m_tileParameters[tileIdx].getTileHeight() >= minHeight);
+    }
+  }
+#endif
 
   //initialize each tile of the current picture
-  for( uiRowIdx=0; uiRowIdx < m_iNumRowsMinus1+1; uiRowIdx++ )
-  {
-    for( uiColumnIdx=0; uiColumnIdx < m_iNumColumnsMinus1+1; uiColumnIdx++ )
-    {
-      uiTileIdx = uiRowIdx * (m_iNumColumnsMinus1+1) + uiColumnIdx;
+  for( Int row=0; row < numRows; row++ )
+  {
+    for( Int col=0; col < numCols; col++ )
+    {
+      const Int tileIdx = row * numCols + col;
 
       //initialize the RightEdgePosInCU for each tile
-      uiRightEdgePosInCU = 0;
-      for( i=0; i <= uiColumnIdx; i++ )
-      {
-        uiRightEdgePosInCU += this->getTComTile(uiRowIdx * (m_iNumColumnsMinus1+1) + i)->getTileWidth();
-      }
-      this->getTComTile(uiTileIdx)->setRightEdgePosInCU(uiRightEdgePosInCU-1);
+      Int rightEdgePosInCTU = 0;
+      for( Int i=0; i <= col; i++ )
+      {
+        rightEdgePosInCTU += m_tileParameters[row * numCols + i].getTileWidth();
+      }
+      m_tileParameters[tileIdx].setRightEdgePosInCU(rightEdgePosInCTU-1);
 
       //initialize the BottomEdgePosInCU for each tile
-      uiBottomEdgePosInCU = 0;
-      for( i=0; i <= uiRowIdx; i++ )
-      {
-        uiBottomEdgePosInCU += this->getTComTile(i * (m_iNumColumnsMinus1+1) + uiColumnIdx)->getTileHeight();
-      }
-      this->getTComTile(uiTileIdx)->setBottomEdgePosInCU(uiBottomEdgePosInCU-1);
+      Int bottomEdgePosInCTU = 0;
+      for( Int i=0; i <= row; i++ )
+      {
+        bottomEdgePosInCTU += m_tileParameters[i * numCols + col].getTileHeight();
+      }
+      m_tileParameters[tileIdx].setBottomEdgePosInCU(bottomEdgePosInCTU-1);
 
       //initialize the FirstCUAddr for each tile
-      this->getTComTile(uiTileIdx)->setFirstCUAddr( (this->getTComTile(uiTileIdx)->getBottomEdgePosInCU() - this->getTComTile(uiTileIdx)->getTileHeight() +1)*m_uiWidthInCU + 
-        this->getTComTile(uiTileIdx)->getRightEdgePosInCU() - this->getTComTile(uiTileIdx)->getTileWidth() + 1);
-    }
-  }
+      m_tileParameters[tileIdx].setFirstCUAddr( (m_tileParameters[tileIdx].getBottomEdgePosInCU() - m_tileParameters[tileIdx].getTileHeight() + 1) * getFrameWidthInCU() + 
+                                                 m_tileParameters[tileIdx].getRightEdgePosInCU() - m_tileParameters[tileIdx].getTileWidth() + 1);
+    }
+  }
+
+  Int  columnIdx = 0;
+  Int  rowIdx = 0;
 
   //initialize the TileIdxMap
-  for( i=0; i<m_uiNumCUsInFrame; i++)
-  {
-    for(j=0; j < m_iNumColumnsMinus1+1; j++)
-    {
-      if(i % m_uiWidthInCU <= this->getTComTile(j)->getRightEdgePosInCU())
-      {
-        uiColumnIdx = j;
-        j = m_iNumColumnsMinus1+1;
-      }
-    }
-    for(j=0; j < m_iNumRowsMinus1+1; j++)
-    {
-      if(i/m_uiWidthInCU <= this->getTComTile(j*(m_iNumColumnsMinus1 + 1))->getBottomEdgePosInCU())
-      {
-        uiRowIdx = j;
-        j = m_iNumRowsMinus1 + 1;
-      }
-    }
-    m_puiTileIdxMap[i] = uiRowIdx * (m_iNumColumnsMinus1 + 1) + uiColumnIdx;
-  }
-
+  for( Int i=0; i<m_uiNumCUsInFrame; i++)
+  {
+    for( Int col=0; col < numCols; col++)
+    {
+      if(i % getFrameWidthInCU() <= m_tileParameters[col].getRightEdgePosInCU())
+      {
+        columnIdx = col;
+        break;
+      }
+    }
+    for(Int row=0; row < numRows; row++)
+    {
+      if(i / getFrameWidthInCU() <= m_tileParameters[row*numCols].getBottomEdgePosInCU())
+      {
+        rowIdx = row;
+        break;
+      }
+    }
+    m_puiTileIdxMap[i] = rowIdx * numCols + columnIdx;
+  }
 }
 
@@ -441 +489 @@
 
 TComTile::TComTile()
+: m_uiTileWidth         (0)
+, m_uiTileHeight        (0)
+, m_uiRightEdgePosInCU  (0)
+, m_uiBottomEdgePosInCU (0)
+, m_uiFirstCUAddr       (0)
+
 {
 }

trunk/source/Lib/TLibCommon/TComPicSym.h

@@ -45 +45 @@
 #include "TComDataCU.h"
 class TComSampleAdaptiveOffset;
+class TComPPS;
 
 //! \ingroup TLibCommon
@@ -102 +103 @@
   Int           m_iNumColumnsMinus1; 
   Int           m_iNumRowsMinus1;
-  TComTile**    m_apcTComTile;
+  std::vector<TComTile> m_tileParameters;
   UInt*         m_puiCUOrderMap;       //the map of LCU raster scan address relative to LCU encoding order 
   UInt*         m_puiTileIdxMap;       //the map of the tile index relative to LCU raster scan address 
@@ -142 +143 @@
   Int          getNumRowsMinus1()                                    { return m_iNumRowsMinus1; }
   Int          getNumTiles()                                         { return (m_iNumRowsMinus1+1)*(m_iNumColumnsMinus1+1); }
-  TComTile*    getTComTile  ( UInt tileIdx )                         { return *(m_apcTComTile + tileIdx); }
+  TComTile*    getTComTile  ( UInt tileIdx )                         { return &(m_tileParameters[tileIdx]); }
   Void         setCUOrderMap( Int encCUOrder, Int cuAddr )           { *(m_puiCUOrderMap + encCUOrder) = cuAddr; }
   UInt         getCUOrderMap( Int encCUOrder )                       { return *(m_puiCUOrderMap + (encCUOrder>=m_uiNumCUsInFrame ? m_uiNumCUsInFrame : encCUOrder)); }
@@ -150 +151 @@
   UInt         getPicSCUEncOrder( UInt SCUAddr );
   UInt         getPicSCUAddr( UInt SCUEncOrder );
-  Void         xCreateTComTileArray();
-  Void         xInitTiles();
+  Void         initTiles(TComPPS *pps);
   UInt         xCalculateNxtCUAddr( UInt uiCurrCUAddr );
   SAOBlkParam* getSAOBlkParam() { return m_saoBlkParams;}
@@ -160 +160 @@
   UInt        getMaxCUWidth()           { return m_uiMaxCUWidth;                }
   UInt        getMaxCUHeight()          { return m_uiMaxCUHeight;               }
-#endif
-#if AVC_SYNTAX
-  UInt        getMaxCUWidth()           { return m_uiMaxCUWidth;                }
-  UInt        getMaxCUHeight()          { return m_uiMaxCUHeight;               }
-  UInt        getMaxDepth()             { return m_uhTotalDepth;               }
 #endif
 #if N0383_IL_CONSTRAINED_TILE_SETS_SEI

trunk/source/Lib/TLibCommon/TComPicYuv.cpp

@@ -69 +69 @@
 
 #if SVC_EXTENSION
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
+#if AUXILIARY_PICTURES
+Void TComPicYuv::create( Int iPicWidth, Int iPicHeight, ChromaFormat chromaFormatIDC, UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxCUDepth, Window* conformanceWindow )
+#else
+Void TComPicYuv::create( Int iPicWidth, Int iPicHeight, UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxCUDepth, Window* conformanceWindow )
+#endif
+#else // R0156_CONF_WINDOW_IN_REP_FORMAT
 #if AUXILIARY_PICTURES
 Void TComPicYuv::create( Int iPicWidth, Int iPicHeight, ChromaFormat chromaFormatIDC, UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxCUDepth, TComSPS* pcSps )
@@ -74 +81 @@
 Void TComPicYuv::create( Int iPicWidth, Int iPicHeight, UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxCUDepth, TComSPS* pcSps )
 #endif
+#endif
 #else
 Void TComPicYuv::create( Int iPicWidth, Int iPicHeight, UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxCUDepth )
@@ -82 +90 @@
   
 #if SVC_EXTENSION
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
+  if(conformanceWindow != NULL)
+  {
+    m_conformanceWindow = *conformanceWindow;
+  }
+#else
   if(pcSps != NULL)
   {
     m_conformanceWindow = pcSps->getConformanceWindow();
   }
+#endif
 #endif
 
@@ -366 +381 @@
 }
 
-#if SVC_EXTENSION
 Void TComPicYuv::dump( Char* pFileName, Bool bAdd, Int bitDepth )
 {
@@ -431 +445 @@
 }
 
-#endif
-
 //! \}

trunk/source/Lib/TLibCommon/TComPicYuv.h

@@ -111 +111 @@
   // ------------------------------------------------------------------------------------------------
 #if SVC_EXTENSION
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
+#if AUXILIARY_PICTURES
+  Void  create      ( Int iPicWidth, Int iPicHeight, ChromaFormat chromaFormatIDC, UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxCUDepth, Window* conformanceWindow = NULL);
+#else
+  Void  create      ( Int iPicWidth, Int iPicHeight, UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxCUDepth, Window* conformanceWindow = NULL);
+#endif
+#else
 #if AUXILIARY_PICTURES
   Void  create      ( Int iPicWidth, Int iPicHeight, ChromaFormat chromaFormatIDC, UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxCUDepth, TComSPS* pcSps = NULL);
 #else
   Void  create      ( Int iPicWidth, Int iPicHeight, UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxCUDepth, TComSPS* pcSps = NULL);
+#endif
 #endif
 #else
@@ -191 +199 @@
   Void convertToMonochrome();
 #endif
+#endif //SVC_EXTENSION
   Void dump( Char* pFileName, Bool bAdd, Int bitDepth );
-#endif //SVC_EXTENSION
 
 };// END CLASS DEFINITION TComPicYuv

trunk/source/Lib/TLibCommon/TComPrediction.cpp

@@ -796 +796 @@
 #else
 #if O0194_JOINT_US_BITSHIFT
+#if REF_REGION_OFFSET
+Void TComPrediction::upsampleBasePic( UInt refLayerIdc, TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window, const Window altRefWindow )
+{
+  m_cUsf.upsampleBasePic( refLayerIdc, pcUsPic, pcBasePic, pcTempPic, window, altRefWindow );
+}
+#else
 Void TComPrediction::upsampleBasePic( TComSlice* currSlice, UInt refLayerIdc, TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window)
 {
   m_cUsf.upsampleBasePic( refLayerIdc, pcUsPic, pcBasePic, pcTempPic, window);
 }
+#endif
 #else
 Void TComPrediction::upsampleBasePic( UInt refLayerIdc, TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window)

trunk/source/Lib/TLibCommon/TComPrediction.h

@@ -126 +126 @@
 #else
 #if O0194_JOINT_US_BITSHIFT
+#if REF_REGION_OFFSET
+  Void upsampleBasePic( TComSlice* currSlice, UInt refLayerIdc, TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window, const Window altRefWindow );
+#else
   Void upsampleBasePic( TComSlice* currSlice, UInt refLayerIdc, TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window );
+#endif
 #else
   Void upsampleBasePic( UInt refLayerIdc, TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window );

trunk/source/Lib/TLibCommon/TComSlice.cpp

@@ -36 +36 @@
 */
 
+#include <numeric>
 #include "CommonDef.h"
 #include "TComSlice.h"
@@ -47 +48 @@
 #if SVC_EXTENSION
 ParameterSetMap<TComVPS> ParameterSetManager::m_vpsMap(MAX_NUM_VPS);
+ParameterSetMap<TComSPS> ParameterSetManager::m_spsMap(MAX_NUM_SPS);
+ParameterSetMap<TComPPS> ParameterSetManager::m_ppsMap(MAX_NUM_PPS);
 Int ParameterSetManager::m_activeVPSId = -1;
 #endif
@@ -104 +107 @@
 , m_temporalLayerNonReferenceFlag ( false )
 , m_enableTMVPFlag                ( true )
+#if R0226_SLICE_TMVP
+, m_availableForTMVPRefFlag       ( true )
+#endif
 #if SVC_EXTENSION
 , m_layerId                     ( 0 )
@@ -124 +130 @@
 , m_pocMsbValRequiredFlag         ( false )
 , m_pocMsbValPresentFlag          ( false )
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+, m_pocMsbValNeeded               ( false )
+#endif
 #endif
 #if POC_RESET_IDC_DECODER || POC_RESET_IDC_ENCODER
@@ -215 +224 @@
   m_picOrderCntLsb = 0;
 #endif
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  m_pocMsbValNeeded  = false;
+  m_pocResetDeltaPoc = 0;
+#endif
 }
 
@@ -265 +278 @@
   }
 }
+
 Int TComSlice::getCurrMsb( Int currLsb, Int prevLsb, Int prevMsb, Int maxLsbVal )
 {
@@ -281 +295 @@
 }
 #endif
+
 /**
  - allocate table to contain substream sizes to be written to the slice header.
@@ -516 +531 @@
 #endif
 
-#if SVC_EXTENSION
-  for( i = 0; i < m_activeNumILRRefIdx; i++ )
-  {
-    UInt refLayerIdc = m_interLayerPredLayerIdc[i];
-    //inter-layer reference picture
-#if O0225_MAX_TID_FOR_REF_LAYERS
-    Int maxTidIlRefPicsPlus1 = ( m_layerId > 0 && m_activeNumILRRefIdx > 0)? m_pcVPS->getMaxTidIlRefPicsPlus1(ilpPic[refLayerIdc]->getSlice(0)->getLayerId(),m_layerId) : 0;
-#else
-    Int maxTidIlRefPicsPlus1 = ( m_layerId > 0 && m_activeNumILRRefIdx > 0)? m_pcVPS->getMaxTidIlRefPicsPlus1(ilpPic[refLayerIdc]->getSlice(0)->getLayerId()) : 0;
-#endif 
-    if( m_layerId > 0 && m_activeNumILRRefIdx > 0 && ( ( (Int)(ilpPic[refLayerIdc]->getSlice(0)->getTLayer())<=  maxTidIlRefPicsPlus1-1) || (maxTidIlRefPicsPlus1==0 && ilpPic[refLayerIdc]->getSlice(0)->getRapPicFlag()) )  ) 
-    {
-#if REF_IDX_MFM
-      if(!(m_eNalUnitType >= NAL_UNIT_CODED_SLICE_BLA_W_LP && m_eNalUnitType <= NAL_UNIT_CODED_SLICE_CRA) && getMFMEnabledFlag())
-      { 
-        ilpPic[refLayerIdc]->copyUpsampledMvField( refLayerIdc, m_pcBaseColPic[refLayerIdc] );
-      }
-      else
-      {
-        ilpPic[refLayerIdc]->initUpsampledMvField();
-      }
-#endif
-      ilpPic[refLayerIdc]->setIsLongTerm(1);
-    }
-  }
-#endif
   // ref_pic_list_init
   TComPic*  rpsCurrList0[MAX_NUM_REF+1];
@@ -595 +584 @@
         UInt refLayerId = m_pcVPS->getRefLayerId( m_layerId, refLayerIdc );
 #if RESAMPLING_CONSTRAINT_BUG_FIX
+#if MOVE_SCALED_OFFSET_TO_PPS
+#if O0098_SCALED_REF_LAYER_ID
+        const Window &scalEL = getPPS()->getScaledRefLayerWindowForLayer(refLayerId);
+#else
+        const Window &scalEL = getPPS()->getScaledRefLayerWindow(m_interLayerPredLayerIdc[i]);
+#endif
+#else
 #if O0098_SCALED_REF_LAYER_ID
         const Window &scalEL = getSPS()->getScaledRefLayerWindowForLayer(refLayerId);
 #else
         const Window &scalEL = getSPS()->getScaledRefLayerWindow(m_interLayerPredLayerIdc[i]);
+#endif
 #endif
         Int scalingOffset = ((scalEL.getWindowLeftOffset()   == 0 ) && 
@@ -1942 +1939 @@
   Int nrOfPositivePictures = 0;
   TComReferencePictureSet* pcRPS = this->getLocalRPS();
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  Bool pocsAdjusted = false;
+#endif
 
   // loop through all pictures in the Reference Picture Set
@@ -1954 +1954 @@
       rpcPic = *(iterPic++);
 
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+      // poc adjustement by poc reset needs to be taken into account here
+      Int deltaPOC = pReferencePictureSet->getDeltaPOC(i) - rpcPic->getPicSym()->getSlice(0)->getPocResetDeltaPoc();
+      if (rpcPic->getPicSym()->getSlice(0)->getPocResetDeltaPoc() != 0)
+      {
+        pocsAdjusted = true;
+      }
+
+      if (rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + deltaPOC && rpcPic->getSlice(0)->isReferenced())
+#else
       if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
+#endif
       {
         // This picture exists as a reference picture
         // and should be added to the explicit Reference Picture Set
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+        pcRPS->setDeltaPOC(k, deltaPOC);
+#else
         pcRPS->setDeltaPOC(k, pReferencePictureSet->getDeltaPOC(i));
+#endif
         pcRPS->setUsed(k, pReferencePictureSet->getUsed(i) && (!isRAP));
 #if ALLOW_RECOVERY_POINT_AS_RAP
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+        pcRPS->setUsed(k, pcRPS->getUsed(k) && !(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + deltaPOC < pocRandomAccess) ); 
+#else
         pcRPS->setUsed(k, pcRPS->getUsed(k) && !(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess) ); 
+#endif
 #endif
         if(pcRPS->getDeltaPOC(k) < 0)
@@ -2005 +2024 @@
     || useNewRPS
 #endif
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+    || pocsAdjusted  // inter RPS prediction does not work if POCs have been adjusted
+#endif
     )
   {
@@ -2139 +2161 @@
   UInt retVal, layerId = getLayerId();
 #if O0096_REP_FORMAT_INDEX
+#if R0279_REP_FORMAT_INBL
+  if ( layerId == 0 || sps->getV1CompatibleSPSFlag() == 1 )
+  {
+#if VPS_AVC_BL_FLAG_REMOVAL
+    if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
+#else
+    if( layerId == 0 && vps->getAvcBaseLayerFlag() )
+#endif
+#else
   if ( layerId == 0 )
   {
     if( vps->getAvcBaseLayerFlag() )
+#endif
     {
       retVal = vps->getVpsRepFormat(layerId)->getPicWidthVpsInLumaSamples();
@@ -2172 +2204 @@
   UInt retVal, layerId = getLayerId();
 #if O0096_REP_FORMAT_INDEX
-  if( layerId == 0 )
+#if R0279_REP_FORMAT_INBL
+  if ( layerId == 0 || sps->getV1CompatibleSPSFlag() == 1 )
+  {
+#if VPS_AVC_BL_FLAG_REMOVAL
+    if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
+#else
+    if( layerId == 0 && vps->getAvcBaseLayerFlag() )
+#endif
+#else
+  if ( layerId == 0 )
   {
     if( vps->getAvcBaseLayerFlag() )
+#endif
     {
       retVal = vps->getVpsRepFormat(layerId)->getPicHeightVpsInLumaSamples();
@@ -2214 +2256 @@
 #endif
 #if O0096_REP_FORMAT_INDEX
-  if( layerId == 0 )
+#if R0279_REP_FORMAT_INBL
+  if ( layerId == 0 || sps->getV1CompatibleSPSFlag() == 1 )
+  {
+#if VPS_AVC_BL_FLAG_REMOVAL
+    if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
+#else
+    if( layerId == 0 && vps->getAvcBaseLayerFlag() )
+#endif
+#else
+  if ( layerId == 0 )
   {
     if( vps->getAvcBaseLayerFlag() )
+#endif
     {
       retVal = vps->getVpsRepFormat(layerId)->getChromaFormatVpsIdc();
@@ -2247 +2299 @@
   UInt retVal, layerId = getLayerId();
 #if O0096_REP_FORMAT_INDEX
-  if( layerId == 0 )
+#if R0279_REP_FORMAT_INBL
+  if ( layerId == 0 || sps->getV1CompatibleSPSFlag() == 1 )
+#else
+  if ( layerId == 0 )
+#endif
   {
     retVal = sps->getBitDepthY();
@@ -2273 +2329 @@
   UInt retVal, layerId = getLayerId();
 #if O0096_REP_FORMAT_INDEX
-  if( layerId == 0 )
+#if R0279_REP_FORMAT_INBL
+  if ( layerId == 0 || sps->getV1CompatibleSPSFlag() == 1 )
+#else
+  if ( layerId == 0 )
+#endif
   {
     retVal = sps->getBitDepthC();
@@ -2301 +2361 @@
   return (getBitDepthC() - 8) * 6;
 }
+
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
+Window& TComSlice::getConformanceWindow()
+{
+  TComSPS *sps = getSPS();
+  TComVPS *vps = getVPS();
+  UInt layerId = getLayerId();
+#if O0096_REP_FORMAT_INDEX
+#if R0279_REP_FORMAT_INBL
+  if ( layerId == 0 || sps->getV1CompatibleSPSFlag() == 1 )
+  {
+#if VPS_AVC_BL_FLAG_REMOVAL
+    if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
+#else
+    if( layerId == 0 && vps->getAvcBaseLayerFlag() )
+#endif
+#else
+  if ( layerId == 0 )
+  {
+    if( vps->getAvcBaseLayerFlag() )
+#endif
+    {
+      return vps->getVpsRepFormat(layerId)->getConformanceWindowVps();
+    }
+    else
+    {
+      return sps->getConformanceWindow();
+    }
+  }
+  else
+  {
+    return vps->getVpsRepFormat( vps->getVpsRepFormatIdx(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : layerId) )->getConformanceWindowVps();
+  }
+#else
+  if( ( layerId == 0 ) || sps->getUpdateRepFormatFlag() )
+  {
+    return sps->getConformanceWindow();
+  }
+  else
+  {
+    return vps->getVpsRepFormat( vps->getVpsRepFormatIdx(layerId) )->getConformanceWindowVps();
+  }
+#endif
+}
+#endif
 
 RepFormat::RepFormat()
@@ -2323 +2428 @@
   m_bitDepthVpsLuma             = 0;
   m_bitDepthVpsChroma           = 0;
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
+  m_conformanceWindowVps.resetWindow();
+#endif
 }
 #endif
@@ -2333 +2441 @@
 TComVPS::TComVPS()
 : m_VPSId                     (  0)
+#if VPS_RESERVED_FLAGS
+, m_baseLayerInternalFlag     (true)
+, m_baseLayerAvailableFlag    (true)
+#endif
 , m_uiMaxTLayers              (  1)
 , m_uiMaxLayers               (  1)
@@ -2384 +2496 @@
 , m_vpsNonVuiExtLength (0)
 #endif
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+, m_vpsPocLsbAlignedFlag(false)
+#endif
 {
   for( Int i = 0; i < MAX_TLAYER; i++)
@@ -2392 +2507 @@
   }
 #if VPS_EXTN_MASK_AND_DIM_INFO
+#if VPS_AVC_BL_FLAG_REMOVAL
+  m_nonHEVCBaseLayerFlag = false;
+#else
   m_avcBaseLayerFlag = false;
+#endif
   m_splittingFlag = false;
   ::memset(m_scalabilityMask, 0, sizeof(m_scalabilityMask));
@@ -2422 +2541 @@
   ::memset(m_directDependencyType, 0, sizeof(m_directDependencyType));
 #endif
+#if !NECESSARY_LAYER_FLAG
 #if DERIVE_LAYER_ID_LIST_VARIABLES
   ::memset(m_layerSetLayerIdList,  0, sizeof(m_layerSetLayerIdList));
   ::memset(m_numLayerInIdList,     0, sizeof(m_numLayerInIdList   )); 
 #endif
+#endif
+#if !PER_LAYER_PTL
   ::memset(m_profileLevelTierIdx,  0, sizeof(m_profileLevelTierIdx));
+#endif
   m_maxOneActiveRefLayerFlag = true;
 #if O0062_POC_LSB_NOT_PRESENT_FLAG
@@ -2542 +2665 @@
 }
 #if DERIVE_LAYER_ID_LIST_VARIABLES
+#if NECESSARY_LAYER_FLAG
+Void TComVPS::deriveLayerIdListVariables()
+{
+  // For layer 0
+  m_numLayerInIdList.push_back(1);
+  m_layerSetLayerIdList.resize(m_numLayerSets);
+  m_layerSetLayerIdList[0].push_back(0);
+  
+  // For other layers
+  for( Int i = 1; i < m_numLayerSets; i++ )
+  {
+    for( Int m = 0; m <= m_maxLayerId; m++)
+    {
+      if( m_layerIdIncludedFlag[i][m] )
+      {
+        m_layerSetLayerIdList[i].push_back(m);
+      }
+    }
+    m_numLayerInIdList.push_back(m_layerSetLayerIdList[i].size());
+  }
+}
+#else
 Void TComVPS::deriveLayerIdListVariables()
 {
@@ -2564 +2709 @@
 }
 #endif
+#endif
 #if !RESOLUTION_BASED_DPB
 #if VPS_DPB_SIZE_TABLE
@@ -2660 +2806 @@
 Void TComVPS::setPredictedLayerIds()
 {
-  for (UInt i = 0; i < getMaxLayers() - 1; i++)
-  {
-    UInt iNuhLId = getLayerIdInNuh(i);
+  for (UInt i = 0; i < m_uiMaxLayers - 1; i++)
+  {
+    UInt iNuhLId = m_layerIdInNuh[i];
     UInt predIdx = 0;
     for (UInt j = iNuhLId + 1; j < MAX_NUM_LAYER_IDS; j++)
     {
-      if (getRecursiveRefLayerFlag(j, iNuhLId))
-      {
-        setPredictedLayerId(i, predIdx, j);
+      if( m_recursiveRefLayerFlag[j][iNuhLId] )
+      {
+        m_predictedLayerId[iNuhLId][predIdx] = j;
         predIdx++;
       }
     }
-    setNumPredictedLayers(iNuhLId, predIdx);
-  }
+    m_numPredictedLayers[iNuhLId] = predIdx;
+  }
+  m_numPredictedLayers[m_layerIdInNuh[m_uiMaxLayers-1]] = 0;
 }
 
@@ -2679 +2826 @@
 {
   Bool countedLayerIdxFlag[MAX_NUM_LAYER_IDS];
-
-  for (UInt i = 0; i <= getMaxLayers() - 1; i++)
-  {
-    countedLayerIdxFlag[i] = false;
-  }
+  memset( countedLayerIdxFlag, 0, sizeof(countedLayerIdxFlag) );
 
   Int numIndependentLayers = 0;
 
-  for (UInt i = 0; i <= getMaxLayers() - 1; i++)
-  {
-    UInt iNuhLId = getLayerIdInNuh(i);
-    if (getNumDirectRefLayers(iNuhLId) == 0)
-    {
-      setTreePartitionLayerId(numIndependentLayers, 0, iNuhLId);
-      setNumLayersInTreePartition(numIndependentLayers, 1);
-      for (UInt j = 0; j < getNumPredictedLayers(iNuhLId); j++)
-      {
-        if (!countedLayerIdxFlag[getLayerIdInVps(iNuhLId)])
-        {
-          setTreePartitionLayerId(numIndependentLayers, getNumLayersInTreePartition(numIndependentLayers), getPredictedLayerId(iNuhLId, j));
-          setNumLayersInTreePartition(numIndependentLayers, getNumLayersInTreePartition(numIndependentLayers) + 1);
-          countedLayerIdxFlag[getLayerIdInVps(getPredictedLayerId(iNuhLId, j))] = true;
+  for (UInt i = 0; i < m_uiMaxLayers; i++)
+  {
+    UInt iNuhLId = m_layerIdInNuh[i];
+    if( m_numDirectRefLayers[iNuhLId] == 0 )
+    {
+      m_treePartitionLayerIdList[numIndependentLayers][0] = iNuhLId;
+      m_numLayersInTreePartition[numIndependentLayers] = 1;
+      for( UInt j = 0; j < m_numPredictedLayers[iNuhLId]; j++ )
+      {
+        if( !countedLayerIdxFlag[m_layerIdInVps[iNuhLId]] )
+        {
+          m_treePartitionLayerIdList[numIndependentLayers][m_numLayersInTreePartition[numIndependentLayers]] = m_predictedLayerId[iNuhLId][j];
+          m_numLayersInTreePartition[numIndependentLayers] = m_numLayersInTreePartition[numIndependentLayers] + 1;
+          countedLayerIdxFlag[m_layerIdInVps[m_predictedLayerId[iNuhLId][j]]] = true;
         }
       }
@@ -2707 +2850 @@
   }
 
-  setNumIndependentLayers(numIndependentLayers);
+  m_numIndependentLayers = numIndependentLayers;
 }
 
 void TComVPS::setLayerIdIncludedFlagsForAddLayerSets()
 {
-  for (UInt i = 0; i < getNumAddLayerSets(); i++)
-  {
-    for (UInt j = 1; j < getNumIndependentLayers(); j++)
+  for (UInt i = 0; i < m_numAddLayerSets; i++)
+  {
+    for (UInt j = 1; j < m_numIndependentLayers; j++)
     {
       Int layerNum = 0;
-      Int lsIdx = getVpsNumLayerSetsMinus1() + 1 + i;
+      Int lsIdx = m_vpsNumLayerSetsMinus1 + 1 + i;
       for (Int layerId = 0; layerId < MAX_VPS_LAYER_ID_PLUS1; layerId++)
       {
-        setLayerIdIncludedFlag(false, lsIdx, layerId);
-      }
-      for (Int treeIdx = 1; treeIdx < getNumIndependentLayers(); treeIdx++)
-      {
-        for (Int layerCnt = 0; layerCnt < getHighestLayerIdxPlus1(i, j); layerCnt++)
-        {
-          setLayerSetLayerIdList(lsIdx, layerNum, getTreePartitionLayerId(treeIdx, layerCnt));
-          setLayerIdIncludedFlag(true, lsIdx, getTreePartitionLayerId(treeIdx, layerCnt));
+        m_layerIdIncludedFlag[lsIdx][layerId] = false;
+      }
+      for (Int treeIdx = 1; treeIdx < m_numIndependentLayers; treeIdx++)
+      {
+        for (Int layerCnt = 0; layerCnt < m_highestLayerIdxPlus1[i][j]; layerCnt++)
+        {
+          m_layerSetLayerIdList[lsIdx][layerNum] = m_treePartitionLayerIdList[treeIdx][layerCnt];
+          m_layerIdIncludedFlag[lsIdx][m_treePartitionLayerIdList[treeIdx][layerCnt]] = true;
           layerNum++;
         }
       }
-      setNumLayersInIdList(lsIdx, layerNum);
+      m_numLayerInIdList[lsIdx] = layerNum;
     }
   }
@@ -2979 +3122 @@
 }
 #endif
+#if NECESSARY_LAYER_FLAG
+Void TComVPS::deriveNecessaryLayerFlag()
+{
+  m_necessaryLayerFlag.empty();
+  m_numNecessaryLayers.empty();
+  // Assumed that output layer sets and variables RecursiveRefLayer are already derived
+  for( Int olsIdx = 0; olsIdx < getNumOutputLayerSets(); olsIdx++)
+  {
+    deriveNecessaryLayerFlag(olsIdx);
+  }
+}
+Void TComVPS::deriveNecessaryLayerFlag(Int const olsIdx)
+{
+  Int lsIdx = this->getOutputLayerSetIdx( olsIdx );
+  Int numLayersInLs = this->getNumLayersInIdList( lsIdx );
+  assert( m_necessaryLayerFlag.size() == olsIdx );   // Function should be called in the correct order.
+  m_necessaryLayerFlag.push_back( std::vector<Bool>( numLayersInLs, false ) ); // Initialize to false
+  for( Int lsLayerIdx = 0; lsLayerIdx < numLayersInLs; lsLayerIdx++ )
+  {
+    if( this->m_outputLayerFlag[olsIdx][lsLayerIdx] )
+    {
+      m_necessaryLayerFlag[olsIdx][lsLayerIdx] = true;
+      Int currNuhLayerId = this->m_layerSetLayerIdList[lsIdx][lsLayerIdx];
+      for( Int rLsLayerIdx = 0; rLsLayerIdx < lsLayerIdx; rLsLayerIdx++ )
+      {
+        Int refNuhLayerId = this->m_layerSetLayerIdList[lsIdx][rLsLayerIdx];
+        if( this->m_recursiveRefLayerFlag[currNuhLayerId][refNuhLayerId] )
+        {
+          m_necessaryLayerFlag[olsIdx][rLsLayerIdx] = true;
+        }
+      }
+    }
+  }
+  m_numNecessaryLayers.push_back(std::accumulate(m_necessaryLayerFlag[olsIdx].begin(), m_necessaryLayerFlag[olsIdx].end(), 0));
+}
+Void TComVPS::checkNecessaryLayerFlagCondition()
+{
+  /* It is a requirement of bitstream conformance that for each layer index layerIdx in the range of 
+  ( vps_base_layer_internal_flag ? 0 : 1 ) to MaxLayersMinus1, inclusive, there shall be at least one OLS with index olsIdx such that 
+  NecessaryLayerFlag[ olsIdx ][ lsLayerIdx ] is equal to 1 for the value of lsLayerIdx 
+  for which LayerSetLayerIdList[ OlsIdxToLsIdx[ olsIdx ] ][ lsLayerIdx ] is equal to layer_id_in_nuh[ layerIdx ]. */
+  for(Int layerIdx = this->getBaseLayerInternalFlag() ? 0 : 1; layerIdx < this->getMaxLayers(); layerIdx++)
+  {
+    Bool layerFoundNecessaryLayerFlag = false;
+    for(Int olsIdx = 0; olsIdx < this->getNumOutputLayerSets(); olsIdx++)
+    {
+      Int lsIdx = this->getOutputLayerSetIdx( olsIdx );
+      Int currNuhLayerId = this->getLayerIdInNuh( layerIdx );
+      std::vector<Int>::iterator iter = std::find( m_layerSetLayerIdList[lsIdx].begin(), m_layerSetLayerIdList[lsIdx].end(), currNuhLayerId );
+      if( iter != m_layerSetLayerIdList[lsIdx].end() ) // Layer present in layer set
+      {
+        size_t positionLayer = iter - m_layerSetLayerIdList[lsIdx].begin();
+        if( *(m_necessaryLayerFlag[olsIdx].begin() + positionLayer) == true )
+        {
+          layerFoundNecessaryLayerFlag = true;
+          break;
+        }
+      }
+    }
+    assert( layerFoundNecessaryLayerFlag );
+  }
+}
+#endif
+#if PER_LAYER_PTL
+Int TComVPS::calculateLenOfSyntaxElement( Int const numVal )
+{
+  Int numBits = 1;
+  while((1 << numBits) < numVal)
+  {
+    numBits++;
+  }
+  return numBits;
+}
+#endif
+#if SUB_LAYERS_IN_LAYER_SET
+Void TComVPS::calculateMaxSLInLayerSets()
+{
+  for(Int lsIdx = 0; lsIdx < getNumLayerSets(); lsIdx++)
+  {
+    UInt maxSLMinus1 = 0;
+    for(Int k = 0; k < getNumLayersInIdList(lsIdx); k++ ) {
+      Int  lId = getLayerSetLayerIdList(lsIdx, k);
+      maxSLMinus1 = std::max(maxSLMinus1, getMaxTSLayersMinus1(getLayerIdInVps(lId)));
+    }
+    setMaxSLayersInLayerSetMinus1(lsIdx,maxSLMinus1);
+  }
+}
+#endif
+
 #if RESOLUTION_BASED_DPB
 // RepFormat Assignment operator
@@ -2992 +3224 @@
     m_bitDepthVpsLuma                 = other.m_bitDepthVpsLuma;
     m_bitDepthVpsChroma               = other.m_bitDepthVpsChroma;
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
+    m_conformanceWindowVps            = other.m_conformanceWindowVps;
+#endif
   }
   return *this;
@@ -3016 +3251 @@
 , m_chromaFormatIdc           (CHROMA_420)
 , m_uiMaxTLayers              (  1)
+#if R0279_REP_FORMAT_INBL
+, m_bV1CompatibleSPSFlag      (  0)
+#endif
 // Structure
 , m_picWidthInLumaSamples     (352)
@@ -3052 +3290 @@
 , m_layerId                   ( 0 )
 , m_extensionFlag             ( false )
+#if !MOVE_SCALED_OFFSET_TO_PPS
 , m_numScaledRefLayerOffsets  ( 0 )
+#endif
 #if REPN_FORMAT_IN_VPS
 , m_updateRepFormatFlag       (false)
@@ -3075 +3315 @@
   ::memset(m_usedByCurrPicLtSPSFlag, 0, sizeof(m_usedByCurrPicLtSPSFlag));
 
+#if !MOVE_SCALED_OFFSET_TO_PPS
 #if P0312_VERT_PHASE_ADJ 
   ::memset(m_vertPhasePositionEnableFlag, 0, sizeof(m_vertPhasePositionEnableFlag));
+#endif
 #endif
 }
@@ -3208 +3450 @@
 const Int TComSPS::m_winUnitY[]={1,2,1,1};
 
+#if !MOVE_SCALED_OFFSET_TO_PPS
 #if O0098_SCALED_REF_LAYER_ID
 Window& TComSPS::getScaledRefLayerWindowForLayer(Int layerId)
@@ -3224 +3467 @@
   return win;
 }
+#endif
+#if REF_REGION_OFFSET
+Window& TComSPS::getRefLayerWindowForLayer(Int layerId)
+{
+  static Window win;
+
+  for (Int i = 0; i < m_numRefLayerOffsets; i++)
+  {
+    if (layerId == m_refLayerId[i])
+    {
+      return m_refLayerWindow[i];
+    }
+  }
+
+  win.resetWindow();  // reference region offsets are inferred to be zero when not present
+  return win;
+}
+#endif
 #endif
 
@@ -3246 +3507 @@
 , m_entropyCodingSyncEnabledFlag   (false)
 , m_loopFilterAcrossTilesEnabledFlag  (true)
-, m_uniformSpacingFlag           (0)
-, m_iNumColumnsMinus1            (0)
-, m_puiColumnWidth               (NULL)
-, m_iNumRowsMinus1               (0)
-, m_puiRowHeight                 (NULL)
-, m_iNumSubstreams             (1)
+, m_uniformSpacingFlag           (false)
+, m_numTileColumnsMinus1         (0)
+, m_numTileRowsMinus1            (0)
+, m_numSubstreams               (1)
 , m_signHideFlag(0)
 , m_cabacInitPresentFlag        (false)
@@ -3269 +3528 @@
 , m_pocResetInfoPresentFlag   (false)
 #endif
+#if MOVE_SCALED_OFFSET_TO_PPS
+, m_numScaledRefLayerOffsets  ( 0 )
+#endif
 #if Q0048_CGS_3D_ASYMLUT
 , m_nCGSFlag(0)
@@ -3277 +3539 @@
 {
   m_scalingList = new TComScalingList;
+#if REF_REGION_OFFSET
+  ::memset(m_scaledRefLayerOffsetPresentFlag,   0, sizeof(m_scaledRefLayerOffsetPresentFlag));
+  ::memset(m_refRegionOffsetPresentFlag,   0, sizeof(m_refRegionOffsetPresentFlag));
+#endif
+#if R0209_GENERIC_PHASE
+  ::memset(m_resamplePhaseSetPresentFlag,   0, sizeof(m_resamplePhaseSetPresentFlag));
+  ::memset(m_phaseHorLuma,   0, sizeof(m_phaseHorLuma));
+  ::memset(m_phaseVerLuma,   0, sizeof(m_phaseVerLuma));
+  ::memset(m_phaseHorChroma, 0, sizeof(m_phaseHorChroma));
+  ::memset(m_phaseVerChroma, 0, sizeof(m_phaseVerChroma));
+#endif
 }
 
 TComPPS::~TComPPS()
 {
-  if( m_iNumColumnsMinus1 > 0 && m_uniformSpacingFlag == 0 )
-  {
-    if (m_puiColumnWidth) delete [] m_puiColumnWidth; 
-    m_puiColumnWidth = NULL;
-  }
-  if( m_iNumRowsMinus1 > 0 && m_uniformSpacingFlag == 0 )
-  {
-    if (m_puiRowHeight) delete [] m_puiRowHeight;
-    m_puiRowHeight = NULL;
-  }
-
 #if SCALINGLIST_INFERRING
   if( !m_inferScalingListFlag )
@@ -3297 +3559 @@
   delete m_scalingList;
 }
+
+#if MOVE_SCALED_OFFSET_TO_PPS
+#if O0098_SCALED_REF_LAYER_ID
+Window& TComPPS::getScaledRefLayerWindowForLayer(Int layerId)
+{
+  static Window win;
+
+  for (Int i = 0; i < m_numScaledRefLayerOffsets; i++)
+  {
+    if (layerId == m_scaledRefLayerId[i])
+    {
+      return m_scaledRefLayerWindow[i];
+    }
+  }
+
+  win.resetWindow();  // scaled reference layer offsets are inferred to be zero when not present
+  return win;
+}
+#endif
+#if REF_REGION_OFFSET
+Window& TComPPS::getRefLayerWindowForLayer(Int layerId)
+{
+  static Window win;
+
+  for (Int i = 0; i < m_numScaledRefLayerOffsets; i++)
+  {
+    if (layerId == m_scaledRefLayerId[i])
+    {
+      return m_refLayerWindow[i];
+    }
+  }
+
+  win.resetWindow();  // reference region offsets are inferred to be zero when not present
+  return win;
+}
+#endif
+
+#if RESAMPLING_FIX
+#if R0209_GENERIC_PHASE
+Bool TComPPS::hasZeroResamplingPhase(Int refLayerIdc)
+{
+  Int phaseHorLuma   = this->getPhaseHorLuma(refLayerIdc);
+  Int phaseVerLuma   = this->getPhaseVerLuma(refLayerIdc);
+  Int phaseHorChroma = this->getPhaseHorChroma(refLayerIdc);
+  Int phaseVerChroma = this->getPhaseVerChroma(refLayerIdc);
+  return ( phaseHorLuma == 0 && phaseHorChroma == 0 && phaseVerLuma == 0 && phaseVerChroma == 0);
+}
+#endif
+#endif
+
+#endif
 
 TComReferencePictureSet::TComReferencePictureSet()
@@ -3718 +4031 @@
 ParameterSetManager::ParameterSetManager()
 #if SVC_EXTENSION
-: m_spsMap(MAX_NUM_SPS)
-, m_ppsMap(MAX_NUM_PPS)
-, m_activeSPSId(-1)
+: m_activeSPSId(-1)
 , m_activePPSId(-1)
 #else
@@ -3854 +4165 @@
 
 #if SVC_EXTENSION
-#if AVC_SYNTAX
-Void TComSlice::initBaseLayerRPL( TComSlice *pcSlice )
-{
-// Assumed that RPL of the base layer is same to the EL, otherwise this information should be also dumped and read from the metadata file
-  setPOC( pcSlice->getPOC() );
-  if( pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA )
-  {
-    setSliceType( I_SLICE );
-  }
-  else
-  {
-    setSliceType( pcSlice->getSliceType() );
-  }
-
-  if( this->isIntra() )
-  {
-    return;
-  }
-
-  //initialize reference POC of BL
-  for( Int iRefPicList = 0; iRefPicList < 2; iRefPicList++ )
-  {
-    RefPicList eRefPicList = RefPicList( iRefPicList );
-
-    assert( pcSlice->getNumRefIdx( eRefPicList) >= 0 );
-    setNumRefIdx( eRefPicList, pcSlice->getNumRefIdx( eRefPicList ) - 1 );
-    assert( getNumRefIdx( eRefPicList) <= MAX_NUM_REF);
-
-    for(Int refIdx = 0; refIdx < getNumRefIdx( eRefPicList ); refIdx++) 
-    {
-      setRefPOC( pcSlice->getRefPic( eRefPicList, refIdx )->getPOC(), eRefPicList, refIdx );
-      setRefPic( pcSlice->getRefPic( eRefPicList, refIdx ), eRefPicList, refIdx );
-      /*
-      // should be set if the base layer has its own instance of the reference picture lists, currently EL RPL is reused.
-      getRefPic( eRefPicList, refIdx )->setLayerId( 0 );
-      getRefPic( eRefPicList, refIdx )->setIsLongTerm( pcSlice->getRefPic( eRefPicList, refIdx )->getIsLongTerm() );      
-      */
-
-    }
-  }  
-  return;
-}
-#endif
-
 Bool TComSlice::setBaseColPic(  TComList<TComPic*>& rcListPic, UInt refLayerIdc )
 {  
@@ -3939 +4206 @@
 #endif
 
-#if REF_IDX_MFM
-Void TComSlice::setRefPOCListILP( TComPic** ilpPic, TComPic** pcRefPicRL )
-{
-  for( UInt i = 0; i < m_activeNumILRRefIdx; i++ )
-  {
-    UInt refLayerIdc = m_interLayerPredLayerIdc[i];
-
-    TComPic* pcRefPicBL = pcRefPicRL[refLayerIdc];
-
-    //set reference picture POC of each ILP reference 
-    Int thePoc = ilpPic[refLayerIdc]->getPOC(); 
-    assert(thePoc == pcRefPicBL->getPOC());
-
-    ilpPic[refLayerIdc]->getSlice(0)->setBaseColPic( refLayerIdc, pcRefPicBL );
-
-    //copy layer id from the reference layer    
-    ilpPic[refLayerIdc]->setLayerId( pcRefPicBL->getLayerId() );
-
-    //copy slice type from the reference layer
-    ilpPic[refLayerIdc]->getSlice(0)->setSliceType( pcRefPicBL->getSlice(0)->getSliceType() );
-
-    //copy "used for reference"
-    ilpPic[refLayerIdc]->getSlice(0)->setReferenced( pcRefPicBL->getSlice(0)->isReferenced() );
-
-    for( Int refList = 0; refList < 2; refList++ )
-    {
-      RefPicList refPicList = RefPicList( refList );
-
-      //set reference POC of ILP
-      ilpPic[refLayerIdc]->getSlice(0)->setNumRefIdx(refPicList, pcRefPicBL->getSlice(0)->getNumRefIdx(refPicList));
-      assert(ilpPic[refLayerIdc]->getSlice(0)->getNumRefIdx(refPicList) >= 0);
-      assert(ilpPic[refLayerIdc]->getSlice(0)->getNumRefIdx(refPicList) <= MAX_NUM_REF);
-
-      //initialize reference POC of ILP
-      for(Int refIdx = 0; refIdx < pcRefPicBL->getSlice(0)->getNumRefIdx(refPicList); refIdx++)
-      {
-        ilpPic[refLayerIdc]->getSlice(0)->setRefPOC(pcRefPicBL->getSlice(0)->getRefPOC(refPicList, refIdx), refPicList, refIdx);
-        ilpPic[refLayerIdc]->getSlice(0)->setRefPic(pcRefPicBL->getSlice(0)->getRefPic(refPicList, refIdx), refPicList, refIdx);
-      }
-
-      for(Int refIdx = pcRefPicBL->getSlice(0)->getNumRefIdx(refPicList); refIdx < MAX_NUM_REF; refIdx++) 
-      { 
-        ilpPic[refLayerIdc]->getSlice(0)->setRefPOC(0, refPicList, refIdx); 
-        ilpPic[refLayerIdc]->getSlice(0)->setRefPic(NULL, refPicList, refIdx); 
-      }
-
-      //copy reference pictures' marking from the reference layer
-      for(Int j = 0; j < MAX_NUM_REF + 1; j++)
-      {
-        ilpPic[refLayerIdc]->getSlice(0)->setIsUsedAsLongTerm(refList, j, pcRefPicBL->getSlice(0)->getIsUsedAsLongTerm(refList, j));
-      }
-    }
-  }
-  return;
-}
-#endif
-
 Void TComSlice::setILRPic(TComPic **pcIlpPic)
 {
@@ -4004 +4214 @@
     if( pcIlpPic[refLayerIdc] )
     {
-      pcIlpPic[refLayerIdc]->copyUpsampledPictureYuv( m_pcPic->getFullPelBaseRec( refLayerIdc ), pcIlpPic[refLayerIdc]->getPicYuvRec() );
+      TComPic* pcRefPicBL = m_pcBaseColPic[refLayerIdc];
+
+      // copy scalability ratio, it is needed to get the correct location for the motion field of the corresponding reference layer block
+      pcIlpPic[refLayerIdc]->setSpatialEnhLayerFlag( refLayerIdc, m_pcPic->isSpatialEnhLayer(refLayerIdc) );
+
+      pcIlpPic[refLayerIdc]->copyUpsampledPictureYuv( m_pcPic->getFullPelBaseRec( refLayerIdc ), pcIlpPic[refLayerIdc]->getPicYuvRec() );      
+      pcIlpPic[refLayerIdc]->getSlice(0)->setBaseColPic( refLayerIdc, pcRefPicBL );
+
+      //set reference picture POC of each ILP reference 
       pcIlpPic[refLayerIdc]->getSlice(0)->setPOC( m_iPOC );
-      pcIlpPic[refLayerIdc]->setLayerId( m_pcBaseColPic[refLayerIdc]->getLayerId() ); //set reference layerId
+
+      //set temporal Id 
+      pcIlpPic[refLayerIdc]->getSlice(0)->setTLayer( m_uiTLayer );
+
+      //copy layer id from the reference layer 
+      pcIlpPic[refLayerIdc]->setLayerId( pcRefPicBL->getLayerId() );
+
       pcIlpPic[refLayerIdc]->getPicYuvRec()->setBorderExtension( false );
       pcIlpPic[refLayerIdc]->getPicYuvRec()->extendPicBorder();
@@ -4013 +4237 @@
         pcIlpPic[refLayerIdc]->getPicSym()->getCU(j)->setLayerId( pcIlpPic[refLayerIdc]->getLayerId() );
       }
-    }
-  }
-}
-
+      pcIlpPic[refLayerIdc]->setIsLongTerm(1);
+
+#if REF_IDX_MFM
+      if( m_bMFMEnabledFlag && !(m_eNalUnitType >= NAL_UNIT_CODED_SLICE_BLA_W_LP && m_eNalUnitType <= NAL_UNIT_CODED_SLICE_CRA) )
+      {
+        //set reference picture POC of each ILP reference 
+        assert( pcIlpPic[refLayerIdc]->getPOC() == pcRefPicBL->getPOC() );
+
+        //copy slice type from the reference layer
+        pcIlpPic[refLayerIdc]->getSlice(0)->setSliceType( pcRefPicBL->getSlice(0)->getSliceType() );
+
+        //copy "used for reference"
+        pcIlpPic[refLayerIdc]->getSlice(0)->setReferenced( pcRefPicBL->getSlice(0)->isReferenced() );
+
+        for( Int refList = 0; refList < 2; refList++ )
+        {
+          RefPicList refPicList = RefPicList( refList );
+
+          //set reference POC of ILP
+          pcIlpPic[refLayerIdc]->getSlice(0)->setNumRefIdx(refPicList, pcRefPicBL->getSlice(0)->getNumRefIdx(refPicList));
+          assert(pcIlpPic[refLayerIdc]->getSlice(0)->getNumRefIdx(refPicList) >= 0);
+          assert(pcIlpPic[refLayerIdc]->getSlice(0)->getNumRefIdx(refPicList) <= MAX_NUM_REF);
+
+          //initialize reference POC of ILP
+          for(Int refIdx = 0; refIdx < pcRefPicBL->getSlice(0)->getNumRefIdx(refPicList); refIdx++)
+          {
+            pcIlpPic[refLayerIdc]->getSlice(0)->setRefPOC(pcRefPicBL->getSlice(0)->getRefPOC(refPicList, refIdx), refPicList, refIdx);
+            pcIlpPic[refLayerIdc]->getSlice(0)->setRefPic(pcRefPicBL->getSlice(0)->getRefPic(refPicList, refIdx), refPicList, refIdx);
+          }
+
+          for(Int refIdx = pcRefPicBL->getSlice(0)->getNumRefIdx(refPicList); refIdx < MAX_NUM_REF; refIdx++) 
+          { 
+            pcIlpPic[refLayerIdc]->getSlice(0)->setRefPOC(0, refPicList, refIdx); 
+            pcIlpPic[refLayerIdc]->getSlice(0)->setRefPic(NULL, refPicList, refIdx); 
+          }
+
+          //copy reference pictures' marking from the reference layer
+          for(Int j = 0; j < MAX_NUM_REF + 1; j++)
+          {
+            pcIlpPic[refLayerIdc]->getSlice(0)->setIsUsedAsLongTerm(refList, j, pcRefPicBL->getSlice(0)->getIsUsedAsLongTerm(refList, j));
+          }
+        }
+
+        pcIlpPic[refLayerIdc]->copyUpsampledMvField( refLayerIdc, m_pcBaseColPic[refLayerIdc] );
+      }
+      else
+      {
+        pcIlpPic[refLayerIdc]->initUpsampledMvField();
+      }
+#endif
+
+#if O0225_MAX_TID_FOR_REF_LAYERS
+      Int maxTidIlRefPicsPlus1 = m_pcVPS->getMaxTidIlRefPicsPlus1( pcIlpPic[refLayerIdc]->getSlice(0)->getLayerId(), m_layerId );
+#else
+      Int maxTidIlRefPicsPlus1 = m_pcVPS->getMaxTidIlRefPicsPlus1( pcIlpPic[refLayerIdc]->getSlice(0)->getLayerId() );
+#endif
+      assert( (Int)pcIlpPic[refLayerIdc]->getSlice(0)->getTLayer() < maxTidIlRefPicsPlus1 || ( !maxTidIlRefPicsPlus1 && pcIlpPic[refLayerIdc]->getSlice(0)->getRapPicFlag() ) );
+
+    }
+  }
+}
+
+Int TComSlice::getReferenceLayerIdc( UInt refLayerId )
+{ 
+  for( Int i = 0; i < m_activeNumILRRefIdx; i++ )
+  {
+    if( m_pcVPS->getRefLayerId(m_layerId, m_interLayerPredLayerIdc[i]) == refLayerId )
+    {
+      return m_interLayerPredLayerIdc[i];
+    }
+  }
+
+  return -1;
+}
 #endif //SVC_EXTENSION
 

trunk/source/Lib/TLibCommon/TComSlice.h

@@ -370 +370 @@
   UInt getNumDU                              ( )            { return m_numDU;          }
   Bool getCpbDpbDelaysPresentFlag() { return getNalHrdParametersPresentFlag() || getVclHrdParametersPresentFlag(); }
+
+#if VPS_VUI_BSP_HRD_PARAMS
+Void copyCommonInformation( TComHRD *refHrd )
+{
+  m_nalHrdParametersPresentFlag         = refHrd->getNalHrdParametersPresentFlag();
+  m_vclHrdParametersPresentFlag         = refHrd->getVclHrdParametersPresentFlag();
+  m_subPicCpbParamsPresentFlag          = refHrd->getSubPicCpbParamsPresentFlag();
+  m_tickDivisorMinus2                   = refHrd->getTickDivisorMinus2();
+  m_duCpbRemovalDelayLengthMinus1       = refHrd->getDuCpbRemovalDelayLengthMinus1();
+  m_subPicCpbParamsInPicTimingSEIFlag   = refHrd->getSubPicCpbParamsInPicTimingSEIFlag();
+  m_dpbOutputDelayDuLengthMinus1        = refHrd->getDpbOutputDelayDuLengthMinus1();
+  m_bitRateScale                        = refHrd->getBitRateScale();
+  m_cpbSizeScale                        = refHrd->getCpbSizeScale();
+  m_ducpbSizeScale                      = refHrd->getDuCpbSizeScale();
+  m_initialCpbRemovalDelayLengthMinus1  = refHrd->getInitialCpbRemovalDelayLengthMinus1();
+  m_cpbRemovalDelayLengthMinus1         = refHrd->getCpbRemovalDelayLengthMinus1();
+  m_dpbOutputDelayLengthMinus1          = refHrd->getDpbOutputDelayLengthMinus1();
+}
+#endif
 };
 
@@ -403 +422 @@
 };
 
+class Window
+{
+private:
+  Bool          m_enabledFlag;
+  Int           m_winLeftOffset;
+  Int           m_winRightOffset;
+  Int           m_winTopOffset;
+  Int           m_winBottomOffset;
+#if P0312_VERT_PHASE_ADJ
+  Bool          m_vertPhasePositionEnableFlag;
+#endif
+public:
+  Window()
+  : m_enabledFlag (false)
+  , m_winLeftOffset     (0)
+  , m_winRightOffset    (0)
+  , m_winTopOffset      (0)
+  , m_winBottomOffset   (0)
+#if P0312_VERT_PHASE_ADJ
+  , m_vertPhasePositionEnableFlag(false)  
+#endif
+  { }
+
+  Bool          getWindowEnabledFlag() const      { return m_enabledFlag; }
+#if P0312_VERT_PHASE_ADJ
+  Void          resetWindow()                     { m_enabledFlag = false; m_winLeftOffset = m_winRightOffset = m_winTopOffset = m_winBottomOffset = 0; m_vertPhasePositionEnableFlag = false; } 
+#else
+  Void          resetWindow()                     { m_enabledFlag = false; m_winLeftOffset = m_winRightOffset = m_winTopOffset = m_winBottomOffset = 0;} 
+#endif
+  Int           getWindowLeftOffset() const       { return m_enabledFlag ? m_winLeftOffset : 0; }
+  Void          setWindowLeftOffset(Int val)      { if(val) {m_winLeftOffset = val; m_enabledFlag = true;} }
+  Int           getWindowRightOffset() const      { return m_enabledFlag ? m_winRightOffset : 0; }
+  Void          setWindowRightOffset(Int val)     { if(val) {m_winRightOffset = val; m_enabledFlag = true;} }
+  Int           getWindowTopOffset() const        { return m_enabledFlag ? m_winTopOffset : 0; }
+  Void          setWindowTopOffset(Int val)       { if(val) {m_winTopOffset = val; m_enabledFlag = true;} }
+  Int           getWindowBottomOffset() const     { return m_enabledFlag ? m_winBottomOffset: 0; }
+  Void          setWindowBottomOffset(Int val)    { if(val) {m_winBottomOffset = val; m_enabledFlag = true;} }
+#if P0312_VERT_PHASE_ADJ
+  Bool          getVertPhasePositionEnableFlag() const     { return m_vertPhasePositionEnableFlag;  }
+  Void          setVertPhasePositionEnableFlag(Bool val)    { m_vertPhasePositionEnableFlag = val;  }
+#endif
+#if REF_REGION_OFFSET && RESAMPLING_FIX
+  Bool          hasEqualOffset(const Window& ref) const
+  {
+    return (    this->getWindowLeftOffset()   == ref.getWindowLeftOffset()
+             && this->getWindowTopOffset()    == ref.getWindowTopOffset()
+             && this->getWindowRightOffset()  == ref.getWindowRightOffset()
+             && this->getWindowBottomOffset() == ref.getWindowBottomOffset() );
+  }
+#endif
+
+#if P0312_VERT_PHASE_ADJ
+  Void          setWindow(Int offsetLeft, Int offsetLRight, Int offsetLTop, Int offsetLBottom, Bool vertPhasePositionEnableFlag = 0)
+#else
+  Void          setWindow(Int offsetLeft, Int offsetLRight, Int offsetLTop, Int offsetLBottom)
+#endif
+  {
+    if(offsetLeft || offsetLRight || offsetLTop || offsetLBottom) 
+    {
+      m_enabledFlag       = true;
+      m_winLeftOffset     = offsetLeft;
+      m_winRightOffset    = offsetLRight;
+      m_winTopOffset      = offsetLTop;
+      m_winBottomOffset   = offsetLBottom;
+    }
+#if P0312_VERT_PHASE_ADJ
+    m_vertPhasePositionEnableFlag = vertPhasePositionEnableFlag;    
+#endif
+  }
+};
+
 #if REPN_FORMAT_IN_VPS
 class RepFormat
@@ -420 +510 @@
   Int  m_bitDepthVpsChroma;             // coded as minus8
 
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
+  Window m_conformanceWindowVps;
+#endif
+
 public:
   RepFormat();
@@ -454 +548 @@
   Int  getBitDepthVpsChroma()           { return m_bitDepthVpsChroma;   }
   Void setBitDepthVpsChroma(Int x)      { m_bitDepthVpsChroma = x;      }
+
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
+  Window& getConformanceWindowVps()                           { return  m_conformanceWindowVps;             }
+  Void    setConformanceWindowVps(Window& conformanceWindow ) { m_conformanceWindowVps = conformanceWindow; }
+#endif
 };
 #endif
@@ -460 +559 @@
 private:
   Int         m_VPSId;
+#if VPS_RESERVED_FLAGS
+  Bool        m_baseLayerInternalFlag;
+  Bool        m_baseLayerAvailableFlag;
+#endif
   UInt        m_uiMaxTLayers;
   UInt        m_uiMaxLayers;
@@ -485 +588 @@
 #if DERIVE_LAYER_ID_LIST_VARIABLES
 #if Q0078_ADD_LAYER_SETS
+#if NECESSARY_LAYER_FLAG
+  std::vector< std::vector<Int> >     m_layerSetLayerIdList;
+  std::vector<Int>                      m_numLayerInIdList;;
+#else
   Int         m_layerSetLayerIdList[MAX_VPS_LAYER_SETS_PLUS1 + MAX_NUM_ADD_LAYER_SETS][MAX_VPS_LAYER_ID_PLUS1];
   Int         m_numLayerInIdList[MAX_VPS_LAYER_SETS_PLUS1 + MAX_NUM_ADD_LAYER_SETS];
+#endif
 #else
   Int         m_layerSetLayerIdList[MAX_VPS_LAYER_SETS_PLUS1][MAX_VPS_LAYER_ID_PLUS1];
@@ -510 +618 @@
   // ------------------------------------------
 #if VPS_EXTN_MASK_AND_DIM_INFO
+#if VPS_AVC_BL_FLAG_REMOVAL
+  Bool       m_nonHEVCBaseLayerFlag; 
+#else
   Bool       m_avcBaseLayerFlag;                                // For now, always set to true.
+#endif
   Bool       m_splittingFlag;
   Bool       m_scalabilityMask[MAX_VPS_NUM_SCALABILITY_TYPES];
@@ -576 +688 @@
 #endif
 #endif
+#if PER_LAYER_PTL
+  std::vector< std::vector<Int> >  m_profileLevelTierIdx;
+#else
   Int        m_profileLevelTierIdx[64];     
+#endif
   Bool       m_maxOneActiveRefLayerFlag;
 #if O0062_POC_LSB_NOT_PRESENT_FLAG
@@ -717 +833 @@
 #if O0164_MULTI_LAYER_HRD
   Bool       m_vpsVuiBspHrdPresentFlag;
+#if VPS_VUI_BSP_HRD_PARAMS
+  Int                 m_vpsNumAddHrdParams;
+  std::vector<Bool>   m_cprmsAddPresentFlag;
+  std::vector<Int>    m_numSubLayerHrdMinus1;
+  std::vector<TComHRD> m_bspHrd;
+  Int    m_numSignalledPartitioningSchemes[MAX_VPS_OUTPUT_LAYER_SETS_PLUS1];
+  Int    m_numPartitionsInSchemeMinus1    [MAX_VPS_OUTPUT_LAYER_SETS_PLUS1][16];
+  Int    m_layerIncludedInPartitionFlag   [MAX_VPS_OUTPUT_LAYER_SETS_PLUS1][16][MAX_LAYERS][MAX_LAYERS];
+  Int    m_numBspSchedulesMinus1          [MAX_VPS_OUTPUT_LAYER_SETS_PLUS1][16][MAX_TLAYER];
+  Int    m_bspHrdIdx                      [MAX_VPS_OUTPUT_LAYER_SETS_PLUS1][16][MAX_TLAYER][31][MAX_LAYERS];
+  Int    m_bspSchedIdx                    [MAX_VPS_OUTPUT_LAYER_SETS_PLUS1][16][MAX_TLAYER][31][MAX_LAYERS];
+#else
   UInt       m_vpsNumBspHrdParametersMinus1;
   Bool       m_bspCprmsPresentFlag[MAX_VPS_LAYER_SETS_PLUS1];
@@ -726 +854 @@
   UInt       m_bspCombSchedIdx[MAX_VPS_LAYER_SETS_PLUS1][16][16];
 #endif
+#endif
 
 #if P0182_VPS_VUI_PS_FLAG
@@ -741 +870 @@
   Int        m_vpsNonVuiExtLength;
 #endif
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  Bool       m_vpsPocLsbAlignedFlag;
+#endif
 #if RESOLUTION_BASED_DPB
   Int        m_subDpbAssigned            [MAX_VPS_LAYER_SETS_PLUS1][MAX_LAYERS];
+#endif
+#if NECESSARY_LAYER_FLAG
+  std::vector< std::vector<Bool> > m_necessaryLayerFlag;
+  std::vector<Int>               m_numNecessaryLayers;
 #endif
 #endif //SVC_EXTENSION
@@ -748 +884 @@
   TComVPS();
   virtual ~TComVPS();
+
+#if VPS_RESERVED_FLAGS
+  Void        setBaseLayerInternalFlag(Bool x) { m_baseLayerInternalFlag = x; }
+  Bool        getBaseLayerInternalFlag()         { return m_baseLayerInternalFlag; }
+  Void        setBaseLayerAvailableFlag(Bool x) { m_baseLayerAvailableFlag = x; }
+  Bool        getBaseLayerAvailableFlag()         { return m_baseLayerAvailableFlag; }
+#endif
 
   Void    createHrdParamBuffer()
@@ -759 +902 @@
   Void    createBspHrdParamBuffer(UInt numHrds)
   {
+#if VPS_VUI_BSP_HRD_PARAMS
+    m_bspHrd.resize( numHrds );
+    m_cprmsAddPresentFlag.resize( numHrds );
+    m_numSubLayerHrdMinus1.resize( numHrds );
+#else
     m_bspHrd    = new TComHRD[ numHrds ];
+#endif
 //    m_hrdOpSetIdx      = new UInt   [ getNumHrdParameters() ];
 //    m_cprmsPresentFlag = new Bool   [ getNumHrdParameters() ];
@@ -767 +916 @@
   Int getBspHrdParamBufferCpbCntMinus1(UInt i, UInt sl)
   {
+#if VPS_VUI_BSP_HRD_PARAMS
+    return m_bspHrd[i].getCpbCntMinus1(sl);
+#else
     return m_bspHrd->getCpbCntMinus1(sl);
+#endif
   }
 #endif
@@ -817 +970 @@
 #if DERIVE_LAYER_ID_LIST_VARIABLES
   Int     getLayerSetLayerIdList(Int set, Int layerId)          { return m_layerSetLayerIdList[set][layerId]; }
-  Void    setLayerSetLayerIdList(Int set, Int layerId, Int x)   { m_layerSetLayerIdList[set][layerId] = x   ; }
+  Void    setLayerSetLayerIdList(Int set, Int layerId, Int x)   { m_layerSetLayerIdList[set][layerId] = x;    }
 
   Int     getNumLayersInIdList(Int set)                          { return m_numLayerInIdList[set]; }
-  Void    setNumLayersInIdList(Int set, Int x)                   { m_numLayerInIdList[set] = x   ; }
+  Void    setNumLayersInIdList(Int set, Int x)                   { m_numLayerInIdList[set] = x;    }
 
   Void    deriveLayerIdListVariables();
@@ -861 +1014 @@
   Void    setNumLayerSets(UInt v)                               { m_numLayerSets = v;    }
 #if VPS_EXTN_MASK_AND_DIM_INFO
+#if VPS_AVC_BL_FLAG_REMOVAL
+  Bool   getNonHEVCBaseLayerFlag()                              { return m_nonHEVCBaseLayerFlag;       }
+  Void   setNonHEVCBaseLayerFlag(Bool x)                        { m_nonHEVCBaseLayerFlag = x;          }
+#else
   Bool   getAvcBaseLayerFlag()                                  { return m_avcBaseLayerFlag;       }
   Void   setAvcBaseLayerFlag(Bool x)                            { m_avcBaseLayerFlag = x;          }
+#endif
 
   Bool   getSplittingFlag()                                     { return m_splittingFlag;          }
@@ -964 +1122 @@
 #endif
 #endif
+#if PER_LAYER_PTL
+  Bool getNecessaryLayerFlag(Int const i, Int const j) { return m_necessaryLayerFlag[i][j]; }
+  std::vector< std::vector<Int> >* getProfileLevelTierIdx() { return &m_profileLevelTierIdx; }
+  std::vector<Int>* getProfileLevelTierIdx(Int const olsIdx) { return &m_profileLevelTierIdx[olsIdx]; }
+  Int    getProfileLevelTierIdx(Int const olsIdx, Int const layerIdx)     { return m_profileLevelTierIdx[olsIdx][layerIdx]; }
+  Void   setProfileLevelTierIdx(Int const olsIdx, Int const layerIdx, Int const ptlIdx)     { m_profileLevelTierIdx[olsIdx][layerIdx] = ptlIdx; }
+  Int calculateLenOfSyntaxElement( Int const numVal );
+#else
   Int    getProfileLevelTierIdx(Int i)                        { return m_profileLevelTierIdx[i]; }
   Void   setProfileLevelTierIdx(Int i, Int x)                 { m_profileLevelTierIdx[i] = x   ; }
+#endif
   Bool   getMaxOneActiveRefLayerFlag()                                          { return m_maxOneActiveRefLayerFlag;                      }
   Void   setMaxOneActiveRefLayerFlag(Bool x)                                    { m_maxOneActiveRefLayerFlag = x;                         }
@@ -971 +1138 @@
   UInt   getPocLsbNotPresentFlag(Int i)                                         { return m_pocLsbNotPresentFlag[i]; }
   Void   setPocLsbNotPresentFlag(Int i, Bool x)                                 { m_pocLsbNotPresentFlag[i] = x;    }
+#endif
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  Bool   getVpsPocLsbAlignedFlag()                                              { return m_vpsPocLsbAlignedFlag; }
+  Void   setVpsPocLsbAlignedFlag(Bool x)                                        { m_vpsPocLsbAlignedFlag = x; }
 #endif
 #if O0223_PICTURE_TYPES_ALIGN_FLAG
@@ -1074 +1245 @@
   Bool     getVpsVuiBspHrdPresentFlag()                         { return m_vpsVuiBspHrdPresentFlag;      }
   Void     setVpsVuiBspHrdPresentFlag(Bool x)                   { m_vpsVuiBspHrdPresentFlag = x;         }
+#if VPS_VUI_BSP_HRD_PARAMS
+  Int      getVpsNumAddHrdParams()                              { return m_vpsNumAddHrdParams; }
+  Void     setVpsNumAddHrdParams(Int  i)                   { m_vpsNumAddHrdParams = i;    }
+
+  Bool     getCprmsAddPresentFlag(Int i)                        { return m_cprmsAddPresentFlag[i];       }
+  Void     setCprmsAddPresentFlag(Int  i, Bool  val)  { m_cprmsAddPresentFlag[i] = val;        }
+
+  Int      getNumSubLayerHrdMinus1(Int i)           { return m_numSubLayerHrdMinus1[i]; }
+  Void     setNumSubLayerHrdMinus1(Int i, Int val)  { m_numSubLayerHrdMinus1[i] = val; }
+
+  TComHRD*  getBspHrd(Int i)           {return &m_bspHrd[i];}
+
+  Int      getNumSignalledPartitioningSchemes(Int  i)                    { return m_numSignalledPartitioningSchemes[i];    }
+  Void     setNumSignalledPartitioningSchemes(Int  i, Int  val)          { m_numSignalledPartitioningSchemes[i] = val;     }
+
+  Int      getNumPartitionsInSchemeMinus1(Int  i, Int j)  { return m_numPartitionsInSchemeMinus1[i][j];}
+  Void     setNumPartitionsInSchemeMinus1(Int i, Int j, Int val) { m_numPartitionsInSchemeMinus1[i][j] = val; }
+
+  Int      getLayerIncludedInPartitionFlag(Int  i, Int j, Int k, Int l)  { return m_layerIncludedInPartitionFlag[i][j][k][l];}
+  Void     setLayerIncludedInPartitionFlag(Int i, Int j, Int k, Int l, Int val) { m_layerIncludedInPartitionFlag[i][j][k][l] = val; }
+
+  Int      getNumBspSchedulesMinus1(Int  i, Int j, Int k)         { return m_numBspSchedulesMinus1[i][j][k];}
+  Void     setNumBspSchedulesMinus1(Int i, Int j, Int k, Int val) { m_numBspSchedulesMinus1[i][j][k] = val; }
+
+  Int      getBspSchedIdx(Int  i, Int j, Int k, Int l, Int m)  { return m_bspSchedIdx[i][j][k][l][m];}
+  Void     setBspSchedIdx(Int  i, Int j, Int k, Int l, Int m, Int val) { m_bspSchedIdx[i][j][k][l][m] = val; }
+
+  Int      getBspHrdIdx(Int  i, Int j, Int k, Int l, Int m)  { return m_bspHrdIdx[i][j][k][l][m];}
+  Void     setBspHrdIdx(Int  i, Int j, Int k, Int l, Int m, Int val) { m_bspHrdIdx[i][j][k][l][m] = val; }
+#else
   UInt     getVpsNumBspHrdParametersMinus1()                    { return m_vpsNumBspHrdParametersMinus1; }
   Void     setVpsNumBspHrdParametersMinus1(UInt i)              { m_vpsNumBspHrdParametersMinus1 = i;    }
@@ -1090 +1291 @@
   Void     setBspCombSchedIdx(UInt h, UInt i, UInt j, UInt val) { m_bspCombSchedIdx[h][i][j] = val;      }
 #endif
+#endif
 #if P0182_VPS_VUI_PS_FLAG
   Int    getSPSId       (Int layer)                   { return m_SPSId[layer];       }
@@ -1205 +1407 @@
   Void setBspHrdParameters( UInt hrdIdx, UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess );
 #endif
+#if NECESSARY_LAYER_FLAG
+  Void  deriveNecessaryLayerFlag();
+  Void  deriveNecessaryLayerFlag(Int const olsIdx);
+  Void  checkNecessaryLayerFlagCondition();
+#endif
+#if SUB_LAYERS_IN_LAYER_SET
+  Void  calculateMaxSLInLayerSets();
+#endif
 #endif //SVC_EXTENSION
 };
-
-class Window
-{
-private:
-  Bool          m_enabledFlag;
-  Int           m_winLeftOffset;
-  Int           m_winRightOffset;
-  Int           m_winTopOffset;
-  Int           m_winBottomOffset;
-#if P0312_VERT_PHASE_ADJ
-  Bool          m_vertPhasePositionEnableFlag;
-#endif
-public:
-  Window()
-  : m_enabledFlag (false)
-  , m_winLeftOffset     (0)
-  , m_winRightOffset    (0)
-  , m_winTopOffset      (0)
-  , m_winBottomOffset   (0)
-#if P0312_VERT_PHASE_ADJ
-  , m_vertPhasePositionEnableFlag(false)  
-#endif
-  { }
-
-  Bool          getWindowEnabledFlag() const      { return m_enabledFlag; }
-#if P0312_VERT_PHASE_ADJ 
-  Void          resetWindow()                     { m_enabledFlag = false; m_winLeftOffset = m_winRightOffset = m_winTopOffset = m_winBottomOffset = 0; m_vertPhasePositionEnableFlag = false; } 
-#else
-  Void          resetWindow()                     { m_enabledFlag = false; m_winLeftOffset = m_winRightOffset = m_winTopOffset = m_winBottomOffset = 0;} 
-#endif
-  Int           getWindowLeftOffset() const       { return m_enabledFlag ? m_winLeftOffset : 0; }
-  Void          setWindowLeftOffset(Int val)      { m_winLeftOffset = val; m_enabledFlag = true; }
-  Int           getWindowRightOffset() const      { return m_enabledFlag ? m_winRightOffset : 0; }
-  Void          setWindowRightOffset(Int val)     { m_winRightOffset = val; m_enabledFlag = true; }
-  Int           getWindowTopOffset() const        { return m_enabledFlag ? m_winTopOffset : 0; }
-  Void          setWindowTopOffset(Int val)       { m_winTopOffset = val; m_enabledFlag = true; }
-  Int           getWindowBottomOffset() const     { return m_enabledFlag ? m_winBottomOffset: 0; }
-  Void          setWindowBottomOffset(Int val)    { m_winBottomOffset = val; m_enabledFlag = true; }
-
-#if P0312_VERT_PHASE_ADJ
-  Bool          getVertPhasePositionEnableFlag() const     { return m_vertPhasePositionEnableFlag;  }
-  Void          setVertPhasePositionEnableFlag(Bool val)    { m_vertPhasePositionEnableFlag = val;  }
-  Void          setWindow(Int offsetLeft, Int offsetLRight, Int offsetLTop, Int offsetLBottom, Bool vertPhasePositionEnableFlag = 0)
-#else
-  Void          setWindow(Int offsetLeft, Int offsetLRight, Int offsetLTop, Int offsetLBottom)
-#endif
-  {
-    m_enabledFlag       = true;
-    m_winLeftOffset     = offsetLeft;
-    m_winRightOffset    = offsetLRight;
-    m_winTopOffset      = offsetLTop;
-    m_winBottomOffset   = offsetLBottom;
-#if P0312_VERT_PHASE_ADJ
-    m_vertPhasePositionEnableFlag = vertPhasePositionEnableFlag;    
-#endif
-  }
-};
-
 
 class TComVUI
@@ -1445 +1597 @@
   UInt        m_uiMaxTLayers;           // maximum number of temporal layers
 
+#if R0279_REP_FORMAT_INBL
+  Bool        m_bV1CompatibleSPSFlag;
+#endif
+
   // Structure
   UInt        m_picWidthInLumaSamples;
@@ -1514 +1670 @@
   Bool        m_extensionFlag;
   UInt        m_numScaledRefLayerOffsets;
+#if R0042_PROFILE_INDICATION  
+  Int         m_NumDirectRefLayers;
+#endif
 #if P0312_VERT_PHASE_ADJ
  Bool         m_vertPhasePositionEnableFlag[MAX_LAYERS];
 #endif
+#if !MOVE_SCALED_OFFSET_TO_PPS
 #if O0098_SCALED_REF_LAYER_ID
   UInt        m_scaledRefLayerId[MAX_LAYERS];
 #endif
   Window      m_scaledRefLayerWindow[MAX_LAYERS];
+#endif
 #if REPN_FORMAT_IN_VPS
-  Bool        m_updateRepFormatFlag;
+  Bool m_updateRepFormatFlag;
 #if O0096_REP_FORMAT_INDEX
   UInt        m_updateRepFormatIndex;
@@ -1532 +1693 @@
 #endif
 #endif //SVC_EXTENSION
+
 public:
   TComSPS();
@@ -1554 +1716 @@
   static Int getWinUnitY (Int chromaFormatIdc) { assert (chromaFormatIdc > 0 && chromaFormatIdc <= MAX_CHROMA_FORMAT_IDC); return m_winUnitY[chromaFormatIdc];      }
 #endif
-  
+
+#if R0279_REP_FORMAT_INBL //These two functions shall be used / called when the syntax element sps_ext_or_max_sub_layers_minus1 and V1CompatibleSPSFlag are implemented
+  Bool getV1CompatibleSPSFlag()        {return m_bV1CompatibleSPSFlag;}
+  Void setV1CompatibleSPSFlag(Bool x)       { m_bV1CompatibleSPSFlag = x;}
+#endif
+
   // structure
   Void setPicWidthInLumaSamples       ( UInt u ) { m_picWidthInLumaSamples = u;        }
@@ -1673 +1840 @@
   Int      getExtensionFlag()                  { return m_extensionFlag;  }
   Void     setExtensionFlag(Int n)             { m_extensionFlag = n;     }
+#if R0042_PROFILE_INDICATION
+  Int      getNumDirectRefLayers()                  { return  m_NumDirectRefLayers;  }
+  Void     setNumDirectRefLayers(Int n)             {  m_NumDirectRefLayers = n;     }
+#endif
+#if !MOVE_SCALED_OFFSET_TO_PPS
   UInt     getNumScaledRefLayerOffsets()       { return m_numScaledRefLayerOffsets; }
   Void     setNumScaledRefLayerOffsets(Int x)  { m_numScaledRefLayerOffsets = x;    }
@@ -1685 +1857 @@
 #endif
   Window&  getScaledRefLayerWindow( Int x )   { return m_scaledRefLayerWindow[x]; }
+#endif
 #if REPN_FORMAT_IN_VPS
   Bool     getUpdateRepFormatFlag()       { return m_updateRepFormatFlag; }
@@ -1761 +1934 @@
   
   Bool     m_loopFilterAcrossTilesEnabledFlag;
-  Int      m_uniformSpacingFlag;
-  Int      m_iNumColumnsMinus1;
-  UInt*    m_puiColumnWidth;
-  Int      m_iNumRowsMinus1;
-  UInt*    m_puiRowHeight;
-
-  Int      m_iNumSubstreams;
+  Bool             m_uniformSpacingFlag;
+  Int              m_numTileColumnsMinus1;
+  Int              m_numTileRowsMinus1;
+  std::vector<Int> m_tileColumnWidth;
+  std::vector<Int> m_tileRowHeight;
+
+  Int      m_numSubstreams;
 
   Int      m_signHideFlag;
@@ -1797 +1970 @@
   Bool     m_pocResetInfoPresentFlag;
 #endif
+#if MOVE_SCALED_OFFSET_TO_PPS
+  UInt     m_numScaledRefLayerOffsets;
+#if O0098_SCALED_REF_LAYER_ID
+  UInt     m_scaledRefLayerId[MAX_LAYERS];
+#endif
+  Window   m_scaledRefLayerWindow[MAX_LAYERS];
+#if REF_REGION_OFFSET
+  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];
+  Bool     m_resamplePhaseSetPresentFlag[MAX_LAYERS];
+#endif
+#endif
 #if Q0048_CGS_3D_ASYMLUT
   Int      m_nCGSFlag;
@@ -1855 +2047 @@
   Bool    getDependentSliceSegmentsEnabledFlag() const     { return m_dependentSliceSegmentsEnabledFlag; }
   Void    setDependentSliceSegmentsEnabledFlag(Bool val)   { m_dependentSliceSegmentsEnabledFlag = val; }
-  Bool    getTilesEnabledFlag() const                      { return m_tilesEnabledFlag; }
-  Void    setTilesEnabledFlag(Bool val)                    { m_tilesEnabledFlag = val; }
   Bool    getEntropyCodingSyncEnabledFlag() const          { return m_entropyCodingSyncEnabledFlag; }
   Void    setEntropyCodingSyncEnabledFlag(Bool val)        { m_entropyCodingSyncEnabledFlag = val; }
-  Void     setUniformSpacingFlag            ( Bool b )          { m_uniformSpacingFlag = b; }
-  Bool     getUniformSpacingFlag            ()                  { return m_uniformSpacingFlag; }
-  Void     setNumColumnsMinus1              ( Int i )           { m_iNumColumnsMinus1 = i; }
-  Int      getNumColumnsMinus1              ()                  { return m_iNumColumnsMinus1; }
-  Void     setColumnWidth ( UInt* columnWidth )
-  {
-    if( m_uniformSpacingFlag == 0 && m_iNumColumnsMinus1 > 0 )
-    {
-      m_puiColumnWidth = new UInt[ m_iNumColumnsMinus1 ];
-
-      for(Int i=0; i<m_iNumColumnsMinus1; i++)
-      {
-        m_puiColumnWidth[i] = columnWidth[i];
-      }
-    }
-  }
-  UInt     getColumnWidth  (UInt columnIdx) { return *( m_puiColumnWidth + columnIdx ); }
-  Void     setNumRowsMinus1( Int i )        { m_iNumRowsMinus1 = i; }
-  Int      getNumRowsMinus1()               { return m_iNumRowsMinus1; }
-  Void     setRowHeight    ( UInt* rowHeight )
-  {
-    if( m_uniformSpacingFlag == 0 && m_iNumRowsMinus1 > 0 )
-    {
-      m_puiRowHeight = new UInt[ m_iNumRowsMinus1 ];
-
-      for(Int i=0; i<m_iNumRowsMinus1; i++)
-      {
-        m_puiRowHeight[i] = rowHeight[i];
-      }
-    }
-  }
-  UInt     getRowHeight           (UInt rowIdx)    { return *( m_puiRowHeight + rowIdx ); }
-  Void     setNumSubstreams(Int iNumSubstreams)               { m_iNumSubstreams = iNumSubstreams; }
-  Int      getNumSubstreams()                                 { return m_iNumSubstreams; }
+
+  Void     setTilesEnabledFlag       (Bool val)                             { m_tilesEnabledFlag = val; }
+  Bool     getTilesEnabledFlag       () const                               { return m_tilesEnabledFlag; }
+  Void     setTileUniformSpacingFlag (Bool b)                               { m_uniformSpacingFlag = b; }
+  Bool     getTileUniformSpacingFlag () const                               { return m_uniformSpacingFlag; }
+  Void     setNumTileColumnsMinus1   (Int i)                                { m_numTileColumnsMinus1 = i; }
+  Int      getNumTileColumnsMinus1   () const                               { return m_numTileColumnsMinus1; }
+  Void     setTileColumnWidth        (const std::vector<Int>& columnWidth ) { m_tileColumnWidth = columnWidth; }
+  UInt     getTileColumnWidth        (UInt columnIdx) const                 { return  m_tileColumnWidth[columnIdx]; }
+  Void     setNumTileRowsMinus1      (Int i)                                { m_numTileRowsMinus1 = i; }
+  Int      getTileNumRowsMinus1      () const                               { return m_numTileRowsMinus1; }
+  Void     setTileRowHeight          (const std::vector<Int>& rowHeight)    { m_tileRowHeight = rowHeight;  }
+  UInt     getTileRowHeight          (UInt rowIdx) const                    { return m_tileRowHeight[rowIdx]; }
+
+  Void     setNumSubstreams    (Int numSubstreams)                     { m_numSubstreams = numSubstreams; }
+  Int      getNumSubstreams    ()                                      { return m_numSubstreams; }
 
   Void      setSignHideFlag( Int signHideFlag ) { m_signHideFlag = signHideFlag; }
@@ -1945 +2117 @@
   Void setPocResetInfoPresentFlag   (const Bool val)      { m_pocResetInfoPresentFlag = val; }
 #endif
+#if MOVE_SCALED_OFFSET_TO_PPS
+  UInt     getNumScaledRefLayerOffsets()       { return m_numScaledRefLayerOffsets; }
+  Void     setNumScaledRefLayerOffsets(Int x)  { m_numScaledRefLayerOffsets = x;    }
+#if O0098_SCALED_REF_LAYER_ID
+  UInt     getScaledRefLayerId(Int x)          { return m_scaledRefLayerId[x]; }
+  Void     setScaledRefLayerId(Int x, UInt id) { m_scaledRefLayerId[x] = id;   }
+  Window&  getScaledRefLayerWindowForLayer( Int layerId );
+#endif
+  Window&  getScaledRefLayerWindow( Int x )   { return m_scaledRefLayerWindow[x]; }
+#if REF_REGION_OFFSET
+  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 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; }
+#if RESAMPLING_FIX
+  Bool hasZeroResamplingPhase(Int layerId);
+#endif
+#endif
+#endif
 #if Q0048_CGS_3D_ASYMLUT
   Int     getCGSFlag()                { return m_nCGSFlag;  }
@@ -1994 +2199 @@
   Int         m_associatedIrapPocBeforeReset;
 #endif
-
   NalUnitType m_iAssociatedIRAPType;
   static Int  m_prevTid0POC;
@@ -2085 +2289 @@
 
   Bool       m_enableTMVPFlag;
+#if R0226_SLICE_TMVP
+  Bool       m_availableForTMVPRefFlag;
+#endif
 
 #if SVC_EXTENSION
@@ -2120 +2327 @@
   Bool        m_pocMsbValRequiredFlag;
   Bool        m_pocMsbValPresentFlag;
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  Bool        m_pocMsbValNeeded;
+  Int         m_pocResetDeltaPoc;
+#endif
 #endif
 #if POC_RESET_IDC_ENCODER
@@ -2392 +2603 @@
   Bool      getEnableTMVPFlag     ()              { return m_enableTMVPFlag;}
 
+#if R0226_SLICE_TMVP
+  Void      setAvailableForTMVPRefFlag     ( Bool   b )    { m_availableForTMVPRefFlag = b; }
+  Bool      getAvailableForTMVPRefFlag     ()              { return m_availableForTMVPRefFlag;}
+#endif
+
 #if SVC_EXTENSION
   Bool      setBaseColPic       ( TComList<TComPic*>& rcListPic , UInt refLayerIdc );
@@ -2407 +2623 @@
   TComPicYuv* getFullPelBaseRec   (UInt refLayerIdc)               { return  m_pcFullPelBaseRec[refLayerIdc];  }
 
-#if AVC_SYNTAX
-  Void      initBaseLayerRPL( TComSlice *pcSlice );
-#endif
-
   Void      setRefPicListModificationSvc();
   Int       getNumILRRefIdx     ( )                     { return  m_pcVPS->getNumDirectRefLayers( m_layerId ); }
-
-#if REF_IDX_MFM
-  Void      setRefPOCListILP(TComPic** ilpPic, TComPic** pcRefPicRL);
-#endif
 
   Int       getActiveNumILRRefIdx     ( )               { return  m_activeNumILRRefIdx; }
@@ -2444 +2652 @@
   Bool     isRASL()   { return (m_eNalUnitType == NAL_UNIT_CODED_SLICE_RASL_N || m_eNalUnitType == NAL_UNIT_CODED_SLICE_RASL_R); }
 
+#if POC_RESET_RESTRICTIONS
+  Bool     isIDR()    { return (m_eNalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL
+                                  || m_eNalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP); }
+  Bool     isCRA()    { return m_eNalUnitType == NAL_UNIT_CODED_SLICE_CRA; }
+  Bool     isBLA()    { return (m_eNalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP
+                                  || m_eNalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_RADL
+                                  || m_eNalUnitType == NAL_UNIT_CODED_SLICE_BLA_N_LP ); }
+  Bool     isSLNR()   { return (m_eNalUnitType == NAL_UNIT_CODED_SLICE_TRAIL_N
+                                  || m_eNalUnitType == NAL_UNIT_CODED_SLICE_TSA_N
+                                  || m_eNalUnitType == NAL_UNIT_CODED_SLICE_STSA_N
+                                  || m_eNalUnitType == NAL_UNIT_CODED_SLICE_RADL_N
+                                  || m_eNalUnitType == NAL_UNIT_CODED_SLICE_RASL_N
+                                  || m_eNalUnitType == NAL_UNIT_RESERVED_VCL_N10
+                                  || m_eNalUnitType == NAL_UNIT_RESERVED_VCL_N12
+                                  || m_eNalUnitType == NAL_UNIT_RESERVED_VCL_N14 ); }
+#endif
 #if POC_RESET_FLAG
   Bool      getPocResetFlag  ()                              { return m_bPocResetFlag;       }
@@ -2473 +2697 @@
   Int  getQpBDOffsetY();
   Int  getQpBDOffsetC();
+
+#if R0156_CONF_WINDOW_IN_REP_FORMAT
+  Window& getConformanceWindow();
+#endif
 #endif
 
@@ -2485 +2713 @@
   Int       getPocLsbVal         ()                              { return m_pocLsbVal;       }
   Void      setPocLsbVal       (Int b)                           { m_pocLsbVal = b;          }
+#if P0297_VPS_POC_LSB_ALIGNED_FLAG
+  Void      setPocMsbNeeded      (Bool x)                        { m_pocMsbValNeeded = x; }
+  Bool      getPocMsbNeeded      ()                              { return m_pocMsbValNeeded; }
+  Int       getPocResetDeltaPoc  ()                              { return m_pocResetDeltaPoc; }
+  Void      setPocResetDeltaPoc  (Int x)                         { m_pocResetDeltaPoc = x; }
+#endif
   Int       getPocMsbVal         ()                              { return m_pocMsbVal;       }
   Void      setPocMsbVal       (Int b)                           { m_pocMsbVal = b;          }
@@ -2512 +2746 @@
   Int       getCurrMsb( Int currLsb, Int prevLsb, Int prevMsb, Int maxLsbVal );
 #endif
-
+  Int       getReferenceLayerIdc( UInt refLayerId );
 
 #endif //SVC_EXTENSION
@@ -2567 +2801 @@
   }
 
-#if Q0078_ADD_LAYER_SETS
-  Void removePS(Int psId)
-  {
-    assert(psId < m_maxId);
-    if (m_paramsetMap.find(psId) != m_paramsetMap.end())
-    {
-      m_paramsetMap.erase(psId);
-    }
-  }
-#endif
-
-
 private:
   std::map<Int,T *> m_paramsetMap;
@@ -2601 +2823 @@
   TComSPS* getSPS(Int spsId)  { return m_spsMap.getPS(spsId); };
   TComSPS* getFirstSPS()      { return m_spsMap.getFirstPS(); };
-#if Q0078_ADD_LAYER_SETS
-  Void     removeSPS(Int spsId) { m_spsMap.removePS(spsId); };
-#endif
 
   //! store picture parameter set and take ownership of it 
@@ -2610 +2829 @@
   TComPPS* getPPS(Int ppsId)  { return m_ppsMap.getPS(ppsId); };
   TComPPS* getFirstPPS()      { return m_ppsMap.getFirstPS(); };
-#if Q0078_ADD_LAYER_SETS
-  Void     removePPS(Int ppsId) { m_ppsMap.removePS(ppsId); };
-#endif
 
   //! activate a SPS from a active parameter sets SEI message
@@ -2630 +2846 @@
 #if SVC_EXTENSION
   static ParameterSetMap<TComVPS> m_vpsMap;
+  static ParameterSetMap<TComSPS> m_spsMap; 
+  static ParameterSetMap<TComPPS> m_ppsMap;
 #else
   ParameterSetMap<TComVPS> m_vpsMap;
-#endif
   ParameterSetMap<TComSPS> m_spsMap; 
   ParameterSetMap<TComPPS> m_ppsMap;
+#endif
 
 #if SVC_EXTENSION
@@ -2648 +2866 @@
 
 #endif // __TCOMSLICE__
+

trunk/source/Lib/TLibCommon/TComUpsampleFilter.cpp

@@ -59 +59 @@
 #else
 #if O0194_JOINT_US_BITSHIFT
+#if REF_REGION_OFFSET
+Void TComUpsampleFilter::upsampleBasePic( TComSlice* currSlice, UInt refLayerIdc, TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window, const Window altRefWindow )
+#else
 Void TComUpsampleFilter::upsampleBasePic( TComSlice* currSlice, UInt refLayerIdc, TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window )
+#endif
 #else
 Void TComUpsampleFilter::upsampleBasePic( UInt refLayerIdc, TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window )
@@ -75 +79 @@
 #endif
 
+#if MOVE_SCALED_OFFSET_TO_PPS
+#if O0098_SCALED_REF_LAYER_ID
+  const Window &scalEL = currSlice->getPPS()->getScaledRefLayerWindowForLayer(refLayerId);
+#else
+  const Window &scalEL = currSlice->getPPS()->getScaledRefLayerWindow(refLayerIdc);
+#endif
+#if REF_REGION_OFFSET
+  const Window &windowRL = currSlice->getPPS()->getRefLayerWindow(refLayerIdc);
+#endif
+#else
 #if O0098_SCALED_REF_LAYER_ID
   const Window &scalEL = currSlice->getSPS()->getScaledRefLayerWindowForLayer(refLayerId);
 #else
   const Window &scalEL = currSlice->getSPS()->getScaledRefLayerWindow(refLayerIdc);
+#endif
 #endif
 
@@ -91 +106 @@
 
 #if Q0200_CONFORMANCE_BL_SIZE
+  const Window &confBL = currSlice->getBaseColPic(refLayerIdc)->getConformanceWindow();
+#endif
+#if Q0200_CONFORMANCE_BL_SIZE || REF_REGION_OFFSET
   Int chromaFormatIdc = currSlice->getBaseColPic(refLayerIdc)->getSlice(0)->getChromaFormatIdc();
-  const Window &confBL = currSlice->getBaseColPic(refLayerIdc)->getConformanceWindow();
   Int xScal = TComSPS::getWinUnitX( chromaFormatIdc );
   Int yScal = TComSPS::getWinUnitY( chromaFormatIdc );
+#endif
+#if R0209_GENERIC_PHASE
+  Int phaseHorLuma   = currSlice->getPPS()->getPhaseHorLuma(refLayerIdc);
+  Int phaseVerLuma   = currSlice->getPPS()->getPhaseVerLuma(refLayerIdc);
+  Int phaseHorChroma = currSlice->getPPS()->getPhaseHorChroma(refLayerIdc);
+  Int phaseVerChroma;
+  if (currSlice->getPPS()->getResamplePhaseSetPresentFlag(refLayerIdc))
+  {
+    phaseVerChroma = currSlice->getPPS()->getPhaseVerChroma(refLayerIdc);
+  }
+  else
+  {
+    Int refRegionHeight = heightBL - windowRL.getWindowTopOffset() - windowRL.getWindowBottomOffset();
+    phaseVerChroma = (4 * heightEL + (refRegionHeight >> 1)) / refRegionHeight - 4;
+  }
 #endif
 #if P0312_VERT_PHASE_ADJ
@@ -223 +255 @@
     Int   shiftY = 16;
 
+#if R0209_GENERIC_PHASE
+    Int phaseX = phaseHorLuma;
+    Int phaseY = phaseVerLuma;
+    Int addX = ( ( phaseX * scaleX + 8 ) >> 4 ) -  (1 << ( shiftX - 5 ));
+    Int addY = ( ( phaseY * scaleY + 8 ) >> 4 ) -  (1 << ( shiftX - 5 ));
+#if REF_REGION_OFFSET
+    Int refOffsetX = windowRL.getWindowLeftOffset() << 4;
+    Int refOffsetY = windowRL.getWindowTopOffset()  << 4;
+#else
+#if Q0200_CONFORMANCE_BL_SIZE
+    Int refOffsetX = ( confBL.getWindowLeftOffset() * xScal ) << 4;
+    Int refOffsetY = ( confBL.getWindowTopOffset()  * yScal ) << 4;
+#endif
+#endif
+#else
 #if O0215_PHASE_ALIGNMENT //for Luma, if Phase 0, then both PhaseX  and PhaseY should be 0. If symmetric: both PhaseX and PhaseY should be 2
     Int   phaseX = 2*phaseAlignFlag;
@@ -258 +305 @@
 #endif
 
+#if REF_REGION_OFFSET
+    Int refOffsetX = windowRL.getWindowLeftOffset() << 4;
+    Int refOffsetY = windowRL.getWindowTopOffset() << 4;
+#else
 #if Q0200_CONFORMANCE_BL_SIZE
     deltaX -= ( confBL.getWindowLeftOffset() * xScal ) << 4;
     deltaY -= ( confBL.getWindowTopOffset() * yScal ) << 4;
 #endif
+#endif
+#endif
 
     Int shiftXM4 = shiftX - 4;
@@ -272 +325 @@
     heightBL = min<Int>( pcBasePic->getHeight(), heightEL );
 
+#if R0220_REMOVE_EL_CLIP
+    Int phaseXL = scalEL.getWindowLeftOffset();
+    Int phaseYL = scalEL.getWindowTopOffset();
+    Int rlClipL = -(NTAPS_US_LUMA>>1);
+    Int rlClipR = widthBL -1 + (NTAPS_US_LUMA>>1);
+    Int rlClipT = -(NTAPS_US_LUMA>>1);
+    Int rlClipB = heightBL - 1 + (NTAPS_US_LUMA>>1);
+#else
     Int leftStartL = scalEL.getWindowLeftOffset();
     Int rightEndL  = pcUsPic->getWidth() - scalEL.getWindowRightOffset();
@@ -277 +338 @@
     Int bottomEndL = pcUsPic->getHeight() - scalEL.getWindowBottomOffset();
     Int leftOffset = leftStartL > 0 ? leftStartL : 0;
+#endif
 #if O0194_JOINT_US_BITSHIFT
     // g_bitDepthY was set to EL bit-depth, but shift1 should be calculated using BL bit-depth
@@ -293 +355 @@
     for( i = 0; i < widthEL; i++ )
     {
+#if R0220_REMOVE_EL_CLIP
+      Int x = i;
+#if R0209_GENERIC_PHASE
+      refPos16 = (((x - phaseXL)*scaleX - addX) >> shiftXM4) + refOffsetX;
+#else
+#if REF_REGION_OFFSET
+      refPos16 = (((x - phaseXL)*scaleX + addX) >> shiftXM4) - deltaX + refOffsetX;
+#else
+      refPos16 = (((x - phaseXL)*scaleX + addX) >> shiftXM4) - deltaX;
+#endif
+#endif
+#else
       Int x = Clip3( leftStartL, rightEndL - 1, i );
+#if REF_REGION_OFFSET
+      refPos16 = (((x - leftStartL)*scaleX + addX) >> shiftXM4) - deltaX + refOffsetX;
+#else
       refPos16 = (((x - leftStartL)*scaleX + addX) >> shiftXM4) - deltaX;
+#endif
+#endif
       phase    = refPos16 & 15;
       refPos   = refPos16 >> 4;
+#if R0220_REMOVE_EL_CLIP
+      refPos   = Clip3( rlClipL, rlClipR, refPos );
+#endif
       coeff = m_lumaFilter[phase];
 
@@ -325 +407 @@
     for( j = 0; j < pcTempPic->getHeight(); j++ )
     {
+#if R0220_REMOVE_EL_CLIP
+      Int y = j;
+#if R0209_GENERIC_PHASE
+      refPos16 = ((( y - phaseYL )*scaleY - addY) >> shiftYM4) + refOffsetY;
+#else
+#if REF_REGION_OFFSET
+      refPos16 = ((( y - phaseYL )*scaleY + addY) >> shiftYM4) - deltaY + refOffsetY;
+#else
+      refPos16 = ((( y - pahseYL )*scaleY + addY) >> shiftYM4) - deltaY;
+#endif
+#endif
+#else
       Int y = Clip3(topStartL, bottomEndL - 1, j);
+#if REF_REGION_OFFSET
+      refPos16 = ((( y - topStartL )*scaleY + addY) >> shiftYM4) - deltaY + refOffsetY;
+#else
       refPos16 = ((( y - topStartL )*scaleY + addY) >> shiftYM4) - deltaY;
+#endif
+#endif
       phase    = refPos16 & 15;
       refPos   = refPos16 >> 4;
+#if R0220_REMOVE_EL_CLIP
+      refPos = Clip3( rlClipT, rlClipB, refPos );
+#endif
       coeff = m_lumaFilter[phase];
 
       piSrcY = piTempBufY + (refPos -((NTAPS_US_LUMA>>1) - 1))*strideEL;
       Pel* piDstY0 = piDstBufY + j * strideEL;
-      piDstY = piDstY0 + leftOffset;
-      piSrcY += leftOffset;
-
-      for( i = min<Int>(rightEndL, pcTempPic->getWidth()) - max<Int>(0, leftStartL); i > 0; i-- )
+
+#if R0220_REMOVE_EL_CLIP
+      piDstY = piDstY0;
+
+      for( i = pcTempPic->getWidth(); i > 0; i-- )
       {
         *piDstY = ClipY( (sumLumaVer(piSrcY, coeff, strideEL) + iOffset) >> (nShift));
@@ -342 +445 @@
         piDstY++;
       }
+#else
+      piDstY = piDstY0 + leftOffset;
+      piSrcY += leftOffset;
+
+      for( i = min<Int>(rightEndL, pcTempPic->getWidth()) - max<Int>(0, leftStartL); i > 0; i-- )
+      {
+        *piDstY = ClipY( (sumLumaVer(piSrcY, coeff, strideEL) + iOffset) >> (nShift));
+        piSrcY++;
+        piDstY++;
+      }
 
       for( i = rightEndL; i < pcTempPic->getWidth(); i++ )
@@ -355 +468 @@
         piDstY++;
       }
-
+#endif
     }
 
@@ -374 +487 @@
     strideEL  = pcUsPic->getCStride();
 
+#if R0220_REMOVE_EL_CLIP
+    Int srlLOffsetC = scalEL.getWindowLeftOffset() >> 1;
+    Int srlTOffsetC = scalEL.getWindowTopOffset() >> 1;
+    rlClipL = -(NTAPS_US_CHROMA>>1);
+    rlClipR = widthBL -1 + (NTAPS_US_CHROMA>>1);
+    rlClipT = -(NTAPS_US_CHROMA>>1);
+    rlClipB = heightBL - 1 + (NTAPS_US_CHROMA>>1);
+#else
     Int leftStartC = scalEL.getWindowLeftOffset() >> 1;
     Int rightEndC  = (pcUsPic->getWidth() >> 1) - (scalEL.getWindowRightOffset() >> 1);
@@ -379 +500 @@
     Int bottomEndC = (pcUsPic->getHeight() >> 1) - (scalEL.getWindowBottomOffset() >> 1);
     leftOffset = leftStartC > 0 ? leftStartC : 0;
+#endif
     shiftX = 16;
     shiftY = 16;
 
+#if R0209_GENERIC_PHASE
+    addX = ( ( phaseHorChroma * scaleX + 8 ) >> 4 ) -  (1 << ( shiftX - 5 ));
+    addY = ( ( phaseVerChroma * scaleY + 8 ) >> 4 ) -  (1 << ( shiftX - 5 ));
+    Int refOffsetXC = (windowRL.getWindowLeftOffset() / xScal) << 4;
+    Int refOffsetYC = (windowRL.getWindowTopOffset()  / yScal) << 4;
+#else
 #if O0215_PHASE_ALIGNMENT
     Int phaseXC = phaseAlignFlag;
@@ -417 +545 @@
 #endif
 
+#if REF_REGION_OFFSET
+    Int refOffsetXC = (windowRL.getWindowLeftOffset() / xScal) << 4;
+    Int refOffsetYC  = (windowRL.getWindowTopOffset()  / yScal) << 4;
+#else
 #if Q0200_CONFORMANCE_BL_SIZE
     deltaX -= ( ( confBL.getWindowLeftOffset() * xScal ) >> 1 ) << 4;
     deltaY  -= ( ( confBL.getWindowTopOffset() * yScal ) >> 1 ) << 4;
+#endif
+#endif
 #endif
 
@@ -447 +581 @@
     for( i = 0; i < widthEL; i++ )
     {
+#if R0220_REMOVE_EL_CLIP
+      Int x = i;
+#if R0209_GENERIC_PHASE
+      refPos16 = (((x - srlLOffsetC)*scaleX - addX) >> shiftXM4) + refOffsetXC;
+#else
+#if REF_REGION_OFFSET
+      refPos16 = (((x - srlLOffsetC)*scaleX + addX) >> shiftXM4) - deltaX + refOffsetXC;
+#else
+      refPos16 = (((x - srlLOffsetC)*scaleX + addX) >> shiftXM4) - deltaX;
+#endif
+#endif
+#else
       Int x = Clip3(leftStartC, rightEndC - 1, i);
+#if REF_REGION_OFFSET
+      refPos16 = (((x - leftStartC)*scaleX + addX) >> shiftXM4) - deltaX + refOffsetXC;
+#else
       refPos16 = (((x - leftStartC)*scaleX + addX) >> shiftXM4) - deltaX;
+#endif
+#endif
       phase    = refPos16 & 15;
       refPos   = refPos16 >> 4;
+#if R0220_REMOVE_EL_CLIP
+      refPos   = Clip3(rlClipL, rlClipR, refPos);
+#endif
       coeff = m_chromaFilter[phase];
 
@@ -485 +639 @@
     for( j = 0; j < pcTempPic->getHeight() >> 1; j++ )
     {
+#if R0220_REMOVE_EL_CLIP
+      Int y = j;
+#if R0209_GENERIC_PHASE
+      refPos16 = (((y - srlTOffsetC)*scaleX - addY) >> shiftYM4) + refOffsetYC;
+#else
+#if REF_REGION_OFFSET
+      refPos16 = (((y - srlTOffsetC)*scaleY + addY) >> shiftYM4) - deltaY + refOffsetYC;
+#else
+      refPos16 = (((y - srlTOffsetC)*scaleY + addY) >> shiftYM4) - deltaY;
+#endif
+#endif
+#else
       Int y = Clip3(topStartC, bottomEndC - 1, j);
+#if REF_REGION_OFFSET
+      refPos16 = (((y - topStartC)*scaleY + addY) >> shiftYM4) - deltaY + refOffsetYC;
+#else
       refPos16 = (((y - topStartC)*scaleY + addY) >> shiftYM4) - deltaY;
+#endif
+#endif
       phase    = refPos16 & 15;
       refPos   = refPos16 >> 4;
+#if R0220_REMOVE_EL_CLIP
+      refPos = Clip3(rlClipT, rlClipB, refPos);
+#endif
       coeff = m_chromaFilter[phase];
 
@@ -496 +670 @@
       Pel* piDstU0 = piDstBufU + j*strideEL;
       Pel* piDstV0 = piDstBufV + j*strideEL;
-      piDstU = piDstU0 + leftOffset;
-      piDstV = piDstV0 + leftOffset;
-      piSrcU += leftOffset;
-      piSrcV += leftOffset;
-
-      for( i = min<Int>(rightEndC, pcTempPic->getWidth() >> 1) - max<Int>(0, leftStartC); i > 0; i-- )
+
+#if R0220_REMOVE_EL_CLIP
+      piDstU = piDstU0;
+      piDstV = piDstV0;
+
+      for( i = pcTempPic->getWidth() >> 1; i > 0; i-- )
       {
         *piDstU = ClipC( (sumChromaVer(piSrcU, coeff, strideEL) + iOffset) >> (nShift));
@@ -510 +684 @@
         piDstV++;
       }
+#else
+      piDstU = piDstU0 + leftOffset;
+      piDstV = piDstV0 + leftOffset;
+      piSrcU += leftOffset;
+      piSrcV += leftOffset;
+
+      for( i = min<Int>(rightEndC, pcTempPic->getWidth() >> 1) - max<Int>(0, leftStartC); i > 0; i-- )
+      {
+        *piDstU = ClipC( (sumChromaVer(piSrcU, coeff, strideEL) + iOffset) >> (nShift));
+        *piDstV = ClipC( (sumChromaVer(piSrcV, coeff, strideEL) + iOffset) >> (nShift));
+        piSrcU++;
+        piSrcV++;
+        piDstU++;
+        piDstV++;
+      }
 
       for( i = rightEndC; i < pcTempPic->getWidth() >> 1; i++ )
@@ -528 +717 @@
         piDstV++;
       }
+#endif
 
     }

trunk/source/Lib/TLibCommon/TComUpsampleFilter.h

@@ -51 +51 @@
 #else
 #if O0194_JOINT_US_BITSHIFT
+#if REF_REGION_OFFSET
+  Void upsampleBasePic( TComSlice* currSlice, UInt refLayerIdc, TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window, const Window altRefWindow );
+#else
   Void upsampleBasePic( TComSlice* currSlice, UInt refLayerIdc, TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window );
+#endif
 #else
   Void upsampleBasePic( UInt refLayerIdc, TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window );

trunk/source/Lib/TLibCommon/TypeDef.h

@@ -41 +41 @@
 #define SVC_EXTENSION                    1
 
-#define SYNTAX_BYTES                     10     ///< number of bytes taken by syntaxes per 4x4 block [RefIdxL0(1byte), RefIdxL1(1byte), MVxL0(2bytes), MVyL0(2bytes), MVxL1(2bytes), MVyL1(2bytes)]
 #if SVC_EXTENSION
 #define MAX_LAYERS                       8      ///< max number of layers the codec is supposed to handle
 
+#define SIGNALLING_BITRATE_PICRATE_FIX   1      ///< Fix for signalling of bitrate and picture rate info in VPS VUI to be more aligned to JCTVC-R1008
+#define INFERENCE_POC_MSB_VAL_PRESENT    1      ///< JCTVC-Q0146 -- poc_msb_val_present_flag shall be equal to 0 when slice_header_extension_length is (inferred to be ) equal to 0
+#define CROSS_LAYER_BLA_FLAG_FIX         1      ///< Fix for earlier implementation mistake that omit the signalling of cross_layer_bla_flag
+#define NON_REF_NAL_TYPE_DISCARDABLE     1      ///< JCTVC-P0041 -- If discardable picture is a non-IRAP, it must be a non-referenced sub-layer picture
+#define VPS_AVC_BL_FLAG_REMOVAL          1      ///< remove avc_base_layer_flag and direct the function its offer to vps_base_layer_internal_flag and vps_base_layer_available_flag
+#define VPS_RESERVED_FLAGS               1      ///< vps_base_layer_internal_flag and vps_base_layer_available_flag
+#define VPS_VUI_VST_PARAMS               1      ///< JCTVC-R0227: Related to signalling of VST parameters of the base layer.
 #define VPS_VUI_OFFSET                   1      ///< N0085: Signal VPS VUI offset in the VPS extension 
+#define REMOVE_BSP_HRD_SEI               1      ///< R0010: Remove bitstream partition HRD SEI message.
+#define NESTING_SEI_EXTENSIBILITY        1      ///< R0221: Signalling the number of SEI messages in bitstream partition nesting SEI message
+#define POC_RESET_RESTRICTIONS           1      ///< Restrictions on semantics of POC reset-related syntax elements, including one item from R0223
+#define POC_RESET_VALUE_RESTRICTION      1      ///< R0223: Restriction on the value of full_poc_reset_flag
+#define OUTPUT_LAYER_SETS_CONFIG         1
+#define MOVE_ADDN_LS_SIGNALLING          1      ///< JCTVC-R0238: (Ed.) Move additional layer set signalling in VPS extn.
+#define PTL_SIGNALLING                   1      ///< Overall macro for all PTL-related signalling
+#if PTL_SIGNALLING
+#define LIST_OF_PTL                      1      ///< JCTVC-R0272: Signalling the PTL for the 0-th OLS
+#define NECESSARY_LAYER_FLAG             1      ////< Derivation of NecessaryLayerFlag
+#define PER_LAYER_PTL                    1      ///< Signal profile-tier-level information for each layer.
+#endif
+#define BSP_INIT_ARRIVAL_SEI             1      ///< JCTVC-R0231: Make signalling of vcl_initial_arrival_delay independent of NalHrdBpPresentFlag
+#define SUB_LAYERS_IN_LAYER_SET          1      ///< Move calculation of MaxSubLayerInLayerSets to a separate function
+#define VPS_VUI_BSP_HRD_PARAMS           1      ///< JCTVC-R0231: Define the VPS VUI BSP hrd_params() as a separate function, and apply changes adopted.
 #define O0137_MAX_LAYERID                1      ///< JCTVC-O0137, JCTVC-O0200, JCTVC-O0223: restrict nuh_layer_id and vps_max_layers_minus1
 
-#define Q0108_TSA_STSA                   0      ///< JCTVC-Q0108, Remove cross-layer alignment constraints of TSA and STSA pictures, enable to have different prediction structures in different layers
+#define R0226_CONSTRAINT_TMVP_SEI        1      ///< JCTVC-R0226, Modification to semantics in temporal motion vector prediction constraints SEI message
+#define R0226_SLICE_TMVP                 1      ///< JCTVC-R0226, Regarding slice_temporal_mvp_enabled_flag
+#define R0279_REP_FORMAT_INBL            1      ///< JCTVC-R0279, For any independent non-base layer the used representation format is the one that is signalled in the active SPS for the layer
+#define R0227_VUI_BSP_HRD_FLAG           1      ///< JCTVC-R0227, Conformance checking such that VPS VUI HRD only present if VPS timing info is signalled
+#define R0227_REP_FORMAT_CONSTRAINT      1      ///< JCTVC-R0227, Conformance checking such that representation format of a particular layer shall not be greater than the one defined in VPS for that layer
+#define R0227_BR_PR_ADD_LAYER_SET        1      ///< JCTVC-R0227, Signalling of bit-rate and picture rate for additional layer set
+#define R0042_PROFILE_INDICATION         1      ///< JCTVC-R0042, Profile indication for additional layer sets
+
+#define Q0108_TSA_STSA                   1      ///< JCTVC-Q0108, Remove cross-layer alignment constraints of TSA and STSA pictures, enable to have different prediction structures in different layers
 #define Q0177_SPS_TEMP_NESTING_FIX       1      ///< JCTVC-Q0177; Fix the inference value of sps_temporal_id_nesting_flag when it is not present
 #define Q0177_EOS_CHECKS                 1      ///< JCTVC-Q0177; Put checks on handling EOS
@@ -54 +83 @@
 #define Q0146_SSH_EXT_DATA_BIT           1      ///< JCTVC-Q0146; Bug-fix -- the SSH_EXT_DATA_BIT can have any value -- not required to be 1
 
-#define Q0200_CONFORMANCE_BL_SIZE        1      ///< JCTVC-Q0200; use conformance picture size in re-sampling processs
-#define P0312_VERT_PHASE_ADJ             1      ///< JCTVC-P0312: vertical phase adjustment in re-sampling process (BoG report)
-#if P0312_VERT_PHASE_ADJ
-#define Q0120_PHASE_CALCULATION          1      ///< JCTVC-Q0120 phase offset derivation for combination of spatial scalibility and field coding.
-#endif
 #define P0130_EOB                        1      ///< JCTVC-P0130, set layer Id of EOB NALU to be fixed to 0
+#define T_ID_EOB_BUG_FIX                 1      ///< Bug fix for the value of temporal id of EOB NALU. It must be set to 0
 #define P0307_REMOVE_VPS_VUI_OFFSET      1      ///< JCTVC-P0307, remove implementation related to VPS VUI offset signalling
 #define P0307_VPS_NON_VUI_EXTENSION      1      ///< JCTVC-P0307, implementation related to NON VUI VPS Extension signalling
@@ -94 +119 @@
 #if Q0048_CGS_3D_ASYMLUT
 #define CGS_GCC_NO_VECTORIZATION         1
-#define O0194_WEIGHTED_PREDICTION_CGS    0
-#else
-#define O0194_WEIGHTED_PREDICTION_CGS    1      ///< JCTVC-O0194: Weighted prediciton for color gamut scalability
-#endif
+#define R0150_CGS_SIGNAL_CONSTRAINTS     1      ///< JCTVC-R0150: CGS signaling improvement and constraints
+#define R0151_CGS_3D_ASYMLUT_IMPROVE     1      ///< JCTVC-R0151: Non-uniform chroma partitioning and improved LUT coefficient coding
+#define R0164_CGS_LUT_BUGFIX             1      ///< JCTVC-R0164: Bug fix with LUT syntax
+#define R0164_CGS_LUT_BUGFIX_CHECK       0      ///< JCTVC-R0164: Add traces explicitly/non-explicitly encoded vertices and check if 3DLUT is correctly filled
+#define R0179_CGS_SIZE_8x1x1             1      ///< JCTVC-R0179: allow CGS LUT size to be 8x1x1 as well 
+#define R0300_CGS_RES_COEFF_CODING       1      ///< JCTVC-R0300: improved residual coefficient coding for R0151
+#define R0179_ENC_OPT_3DLUT_SIZE         0      ///< JCTVC-R0179: RD decision based LUT size selection 
+#endif
+#define O0194_WEIGHTED_PREDICTION_CGS    1      ///< JCTVC-O0194: Weighted prediction for colour gamut scalability
 #define POC_RESET_FLAG                   0      ///< JCTVC-N0244: POC reset flag for  layer pictures.
 #define POC_RESET_IDC                    1      ///< JCTVC-P0041: Include poc_reset_idc and related derivation - eventually will replace POC_RESET_FLAG
@@ -107 +137 @@
 #define UNAVAILABLE_PIC_BUGFIX           1
 #endif
+#if INFERENCE_POC_MSB_VAL_PRESENT
+#define POC_MSB_VAL_PRESENT_FLAG_SEM     0      ///< JCTVC-Q0146: Inference of poc_msb_val_present_flag
+#else
 #define POC_MSB_VAL_PRESENT_FLAG_SEM     1      ///< JCTVC-Q0146: Inference of poc_msb_val_present_flag
+#endif
 #define POC_RESET_INFO_INFERENCE         1      ///< JCTVC-Q0146: Infer the value of poc_reset_info_present_flag when not present
 #define NO_OUTPUT_OF_PRIOR_PICS          1      ///< Use no_output_of_prior_pics_flag
@@ -123 +157 @@
 #endif
 
+#define P0297_VPS_POC_LSB_ALIGNED_FLAG   1      ///< JCTVC-P0297: vps_poc_lsb_aligned_flag for cross-layer POC anchor picture derivation
+
 #define VPS_EXTN_MASK_AND_DIM_INFO       1      ///< Include avc_base_layer_flag, splitting_flag, scalability mask and dimension related info
 #if VPS_EXTN_MASK_AND_DIM_INFO
@@ -152 +188 @@
 
 #define AVC_BASE                         1      ///< YUV BL reading for AVC base SVC
-#if AVC_BASE
-#define AVC_SYNTAX                       0      ///< Syntax reading for AVC base
-#endif
 
 #define REF_IDX_MFM                      1      ///< JCTVC-L0336: motion vector mapping of inter-layer reference picture
@@ -193 +226 @@
 #define REP_FORMAT_FIX                   1      ///< update_rep_format_flag should be inferred to be equal to 0
 
+#define R0156_CONF_WINDOW_IN_REP_FORMAT  O0096_REP_FORMAT_INDEX ///< JCTVC-R0156: add conformance window cropping offsets to rep_format()
+
 #define RESAMPLING_CONSTRAINT_BUG_FIX    1
 #define O0098_SCALED_REF_LAYER_ID        1      ///< JCTVC-O0098: signal scaled reference id
@@ -226 +261 @@
 #define HRD_BPB                          1      ///< JCTVC-Q0101 Bitstream Partition Buffering Proposals
 #define DPB_CONSTRAINTS                  1      ///< JCTVC-Q0100 RPS DPB constraints
+#define DPB_INTERNAL_BL_SIG              1      ///< JCTVC-R0153: external base layer
+#define ALT_OPT_LAYER_FLAG               1      ///< JCTVC-R0154: proposal1 - alt_output_layer_flag[i] inference
+#define DEF_OPT_LAYER_IDC                1      ///< JCTVC-R0154: proposal2 - default_output_layer_idc and output_layer_flag[i][j]
+#define ISLICE_TYPE_NUMDIR               1      ///< JCTVC-R0155: Proposal 1 I slice_type
+#define OLS_IDX_CHK                      1      ///< JCTVC-R0155: Proposal 2 valid range for output_layer_set_idx_to_vps[i]
+#define R0340_RESAMPLING_MODIFICATION    1      ///< JCTVC-R0340: set of changes regarding resampling (as listed below)
+#if R0340_RESAMPLING_MODIFICATION
+#define MOVE_SCALED_OFFSET_TO_PPS        1      ///< JCTVC-R0013: move scaled reference layer offset from SPS to PPS
+#if MOVE_SCALED_OFFSET_TO_PPS
+#define REF_REGION_OFFSET                1      ///< JCTVC-Q0159/R0220: reference region offset
+#define R0209_GENERIC_PHASE              1      ///< JCTVC-R0209: resampling with generic phase
+#define R0220_REMOVE_EL_CLIP             1      ///< JCTVC-R0220: remove clip to scaled ref window in resampling process
+#define RESAMPLING_FIX                   1      ///< Resampling fix -- equal offset check and conformance check
+#endif
+#else
+#define Q0200_CONFORMANCE_BL_SIZE        1      ///< JCTVC-Q0200; use conformance picture size in re-sampling processs
+#define P0312_VERT_PHASE_ADJ             1      ///< JCTVC-P0312: vertical phase adjustment in re-sampling process (BoG report)
+#if P0312_VERT_PHASE_ADJ
+#define Q0120_PHASE_CALCULATION          1      ///< JCTVC-Q0120 phase offset derivation for combination of spatial scalibility and field coding.
+#endif
+#endif
 
 /// scalability types
@@ -234 +290 @@
   AUX_ID            = 3,
 };
+
+#define WPP_FIX                          1
 
 /// normative encoder constraints --------
@@ -255 +313 @@
 #define MAX_SUB_STREAMS                  1024
 #endif
-#define Q0074_SEI_COLOR_MAPPING          1      ///< JCTVC-Q0074, SEI Color Mapping
 #define LAYERS_NOT_PRESENT_SEI           1      ///< JCTVC-M0043: add layers not present SEI.
 #define N0383_IL_CONSTRAINED_TILE_SETS_SEI  1
 #define Q0189_TMVP_CONSTRAINTS           1      ///< JCTVC-Q0189: indicate constraints on TMVP
 #define Q0247_FRAME_FIELD_INFO           1      ///< JCTVC-Q0247: field_frame_info SEI message
-
-
-#else
-#define SYNTAX_OUTPUT                    0
+#define R0247_SEI_ACTIVE                 1      ///< JCTVC-R0247: active parameter sets SEI message
+
 #endif // SVC_EXTENSION
+#define Q0074_COLOUR_REMAPPING_SEI       1      ///< JCTVC-Q0074, JCTVC-R0344: SEI Colour Remapping Information
 
 
@@ -278 +334 @@
 #define SAO_SGN_FUNC 1
 
+#define TILE_SIZE_CHECK 1
+
 #define FIX1172 1 ///< fix ticket #1172
 
@@ -292 +350 @@
 #define MAX_NESTING_NUM_OPS         1024
 #define MAX_NESTING_NUM_LAYER       64
-
+#if NESTING_SEI_EXTENSIBILITY
+#define MAX_SEIS_IN_BSP_NESTING     64
+#endif
 #if SVC_EXTENSION
 #define MAX_VPS_OP_LAYER_SETS_PLUS1               (MAX_LAYERS+1)
 #define MAX_VPS_LAYER_SETS_PLUS1                  1024
+#define MAX_VPS_OUTPUT_LAYER_SETS_PLUS1           1024
 #define MAX_VPS_LAYER_ID_PLUS1                    MAX_LAYERS
 #else
@@ -438 +499 @@
 typedef       double              Double;
 typedef       float               Float;
-
 // ====================================================================================================================
 // 64-bit integer type