Changeset 618 in 3DVCSoftware for branches/HTM-8.0-dev0/source/Lib/TLibCommon

Timestamp:

9 Sep 2013, 23:15:14 (11 years ago)

Author:

tech

Message:

Incorporated:

• MV-HEVC 5 HLS
• Cleanups
• Further ENC_DEC trace functionalities.
• Update cfg files.

Location:

branches/HTM-8.0-dev0/source/Lib/TLibCommon

Files:

• CommonDef.h (modified) (2 diffs)
• TComDataCU.cpp (modified) (2 diffs)
• TComRom.cpp (modified) (2 diffs)
• TComRom.h (modified) (1 diff)
• TComSlice.cpp (modified) (52 diffs)
• TComSlice.h (modified) (40 diffs)
• TComYuv.cpp (modified) (1 diff)
• TypeDef.h (modified) (2 diffs)

branches/HTM-8.0-dev0/source/Lib/TLibCommon/CommonDef.h

@@ -48 +48 @@
 #endif // _MSC_VER > 1000
 #include "TypeDef.h"
+#if H_MV
+#include <assert.h>
+#endif
 
 //! \ingroup TLibCommon
@@ -183 +186 @@
     return (t < 0) ? T(-1) : T(1);
 }
+
+#if H_MV5
+template <typename T>
+__inline T gCeilLog2( T val )
+{
+  assert( val > 0 ); 
+  Int ceilLog2 = 0;
+  while( val > ( 1 << ceilLog2 ) ) ceilLog2++;
+  return ceilLog2;
+}
+#endif
 
 #define RemoveBitIncrement( exp ) ( exp >> ( g_bitDepthY - 8 ) )

branches/HTM-8.0-dev0/source/Lib/TLibCommon/TComDataCU.cpp

@@ -4830 +4830 @@
 
   // use coldir.
+#if H_MV5
+  TComPic *pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? 1-getSlice()->getColFromL0Flag() : 0), getSlice()->getColRefIdx());
+#else
 #if H_MV
   TComPic *pColPic;  
@@ -4842 +4845 @@
 #else
   TComPic *pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? 1-getSlice()->getColFromL0Flag() : 0), getSlice()->getColRefIdx());
+#endif
 #endif
   TComDataCU *pColCU = pColPic->getCU( uiCUAddr );

branches/HTM-8.0-dev0/source/Lib/TLibCommon/TComRom.cpp

@@ -372 +372 @@
 const Bool g_bEncDecTraceEnable  = true;
 const Bool g_bEncDecTraceDisable = false;
-Bool   g_HLSTraceEnable = true;
+Bool   g_HLSTraceEnable = false;
 Bool   g_bJustDoIt = false;
 UInt64 g_nSymbolCounter = 0;
@@ -380 +380 @@
 Bool g_traceTU = true; 
 Bool g_disableHLSTrace = false; 
-UInt64 g_stopAtCounter   = 10803; 
+UInt64 g_stopAtCounter       = 48; 
+Bool g_traceCopyBack         = false; 
+Bool g_decTraceDispDer       = false; 
+Bool g_decTraceMvFromMerge   = false; 
 #endif
 #endif

branches/HTM-8.0-dev0/source/Lib/TLibCommon/TComRom.h

@@ -224 +224 @@
  extern Bool   g_tracePU; 
  extern Bool   g_traceTU; 
- extern Bool   g_disableHLSTrace; 
- extern UInt64 g_stopAtCounter; 
+ extern Bool   g_disableHLSTrace;       // USE g_HLSTraceEnable to toggle HLS trace. Not this one!
+ extern UInt64 g_stopAtCounter;         // Counter to set breakpoint. 
+ extern Bool   g_traceCopyBack;         // Output samples on copy back  
+ extern Bool   g_decTraceDispDer; // Trace derived disparity vectors (decoder only) 
+ extern Bool   g_decTraceMvFromMerge;   // Trace motion vectors obtained from merge (decoder only) 
 
 #define DTRACE_CU(x,y)             writeToTraceFile( x,y, g_traceCU );

branches/HTM-8.0-dev0/source/Lib/TLibCommon/TComSlice.cpp

@@ -101 +101 @@
 , m_enableTMVPFlag                ( true )
 #if H_MV
+#if H_MV5
+, m_refPicSetInterLayer0           ( NULL )
+, m_refPicSetInterLayer1           ( NULL )
+#else
 , m_refPicSetInterLayer           ( NULL )
+#endif
 , m_layerId                       (0)
 , m_viewId                        (0)
+#if H_MV5
+, m_viewIndex                     (0)
+#endif
 #if H_3D
+#if !H_MV5
 , m_viewIndex                     (0)
+#endif
 , m_isDepth                       (false)
+#endif
+#if H_MV5
+, m_pocResetFlag                  (false)
 #endif
 , m_discardableFlag               (false)
 , m_interLayerPredEnabledFlag     (false)
 , m_numInterLayerRefPicsMinus1    (0)
+#if !H_MV5
 , m_interLayerSamplePredOnlyFlag  (false)
 , m_altCollocatedIndicationFlag   (0)
 , m_collocatedRefLayerIdx         (0)
+#endif
 #if H_3D_IC
 , m_bApplyIC                      ( false )
@@ -149 +164 @@
   for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
   {
+#if H_MV5
+   m_interLayerPredLayerIdc[ i ] = i;
+#else
    m_interLayerPredLayerIdc[ i ] = 0;
+#endif
   }
 #endif
@@ -162 +181 @@
   {
     if ( m_depthToDisparityB && m_depthToDisparityB[ i ] )
+    {
       delete[] m_depthToDisparityB [ i ];
+    }
 
     if ( m_depthToDisparityF && m_depthToDisparityF[ i ] ) 
+    {
       delete[] m_depthToDisparityF [ i ];
   }
+  }
 
   if ( m_depthToDisparityF )
+  {
     delete[] m_depthToDisparityF; 
+  }
 
   m_depthToDisparityF = NULL;
@@ -362 +387 @@
   }
 }
-#if H_MV
-Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer , Bool checkNumPocTotalCurr)
-#else
+#if H_MV5
+#if !H_MV
 #if FIX1071
 Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
@@ -370 +394 @@
 Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic )
 #endif
-#endif
 {
 #if FIX1071
@@ -380 +403 @@
       ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
       ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
-      
+
       return;
     }
-    
-#if !H_MV
+
     m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
     m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
-#endif
   }
 
@@ -411 +432 @@
     }
   }
+
+  for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++)
+  {
+    if(m_pcRPS->getUsed(i))
+    {
+      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
+      pcRefPic->setIsLongTerm(0);
+      pcRefPic->getPicYuvRec()->extendPicBorder();
+      RefPicSetStCurr1[NumPocStCurr1] = pcRefPic;
+      NumPocStCurr1++;
+      pcRefPic->setCheckLTMSBPresent(false);  
+    }
+  }
+
+  for(i = m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()+m_pcRPS->getNumberOfLongtermPictures()-1; i > m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()-1 ; i--)
+  {
+    if(m_pcRPS->getUsed(i))
+    {
+      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
+      pcRefPic->setIsLongTerm(1);
+      pcRefPic->getPicYuvRec()->extendPicBorder();
+      RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
+      NumPocLtCurr++;
+    }
+    if(pcRefPic==NULL) 
+    {
+      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
+    }
+    pcRefPic->setCheckLTMSBPresent(m_pcRPS->getCheckLTMSBPresent(i));  
+  }
+
+  // ref_pic_list_init
+  TComPic*  rpsCurrList0[MAX_NUM_REF+1];
+  TComPic*  rpsCurrList1[MAX_NUM_REF+1];
+  Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
+
+#if FIX1071
+  if (checkNumPocTotalCurr)
+  {
+    // The variable NumPocTotalCurr is derived as specified in subclause 7.4.7.2. It is a requirement of bitstream conformance that the following applies to the value of NumPocTotalCurr:
+    // “ If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
+    // “ Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
+    if (getRapPicFlag())
+    {
+      assert(numPocTotalCurr == 0);
+    }
+
+    if (m_eSliceType == I_SLICE)
+    {
+      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
+      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
+
+      return;
+    }
+
+    assert(numPocTotalCurr > 0);
+
+    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
+    m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
+  }
+#endif
+
+  Int cIdx = 0;
+  for ( i=0; i<NumPocStCurr0; i++, cIdx++)
+  {
+    rpsCurrList0[cIdx] = RefPicSetStCurr0[i];
+  }
+  for ( i=0; i<NumPocStCurr1; i++, cIdx++)
+  {
+    rpsCurrList0[cIdx] = RefPicSetStCurr1[i];
+  }
+  for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
+  {
+    rpsCurrList0[cIdx] = RefPicSetLtCurr[i];
+  }
+  assert(cIdx == numPocTotalCurr);
+
+  if (m_eSliceType==B_SLICE)
+  {
+    cIdx = 0;
+    for ( i=0; i<NumPocStCurr1; i++, cIdx++)
+    {
+      rpsCurrList1[cIdx] = RefPicSetStCurr1[i];
+    }
+    for ( i=0; i<NumPocStCurr0; i++, cIdx++)
+    {
+      rpsCurrList1[cIdx] = RefPicSetStCurr0[i];
+    }
+    for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
+    {
+      rpsCurrList1[cIdx] = RefPicSetLtCurr[i];
+    }
+    assert(cIdx == numPocTotalCurr);
+  }
+
+  ::memset(m_bIsUsedAsLongTerm, 0, sizeof(m_bIsUsedAsLongTerm));
+
+  for (Int rIdx = 0; rIdx < m_aiNumRefIdx[0]; rIdx ++)
+  {
+    cIdx = m_RefPicListModification.getRefPicListModificationFlagL0() ? m_RefPicListModification.getRefPicSetIdxL0(rIdx) : rIdx % numPocTotalCurr;
+    assert(cIdx >= 0 && cIdx < numPocTotalCurr);
+    m_apcRefPicList[0][rIdx] = rpsCurrList0[ cIdx ];
+    m_bIsUsedAsLongTerm[0][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
+  }
+  if ( m_eSliceType != B_SLICE )
+  {
+    m_aiNumRefIdx[1] = 0;
+    ::memset( m_apcRefPicList[1], 0, sizeof(m_apcRefPicList[1]));
+  }
+  else
+  {
+    for (Int rIdx = 0; rIdx < m_aiNumRefIdx[1]; rIdx ++)
+    {
+      cIdx = m_RefPicListModification.getRefPicListModificationFlagL1() ? m_RefPicListModification.getRefPicSetIdxL1(rIdx) : rIdx % numPocTotalCurr;
+      assert(cIdx >= 0 && cIdx < numPocTotalCurr);
+      m_apcRefPicList[1][rIdx] = rpsCurrList1[ cIdx ];
+      m_bIsUsedAsLongTerm[1][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
+    }
+  }
+}
+
+#else
+Void TComSlice::getTempRefPicLists( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1,                                     
+                                   std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int& numPocTotalCurr, Bool checkNumPocTotalCurr )
+{
+  if (!checkNumPocTotalCurr)
+  {
+    if (m_eSliceType == I_SLICE)
+    {      
+      return;
+    }    
+  }
+
+  TComPic*  pcRefPic= NULL;
+  TComPic*  RefPicSetStCurr0[16];
+  TComPic*  RefPicSetStCurr1[16];
+  TComPic*  RefPicSetLtCurr[16];
+  UInt NumPocStCurr0 = 0;
+  UInt NumPocStCurr1 = 0;
+  UInt NumPocLtCurr = 0;
+  Int i;
+
+  for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++)
+  {
+    if(m_pcRPS->getUsed(i))
+    {
+      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
+      pcRefPic->setIsLongTerm(0);
+      pcRefPic->getPicYuvRec()->extendPicBorder();
+      RefPicSetStCurr0[NumPocStCurr0] = pcRefPic;
+      NumPocStCurr0++;
+      pcRefPic->setCheckLTMSBPresent(false);  
+    }
+  }
+  
+  for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++)
+  {
+    if(m_pcRPS->getUsed(i))
+    {
+      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
+      pcRefPic->setIsLongTerm(0);
+      pcRefPic->getPicYuvRec()->extendPicBorder();
+      RefPicSetStCurr1[NumPocStCurr1] = pcRefPic;
+      NumPocStCurr1++;
+      pcRefPic->setCheckLTMSBPresent(false);  
+    }
+  }
+  
+  for(i = m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()+m_pcRPS->getNumberOfLongtermPictures()-1; i > m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()-1 ; i--)
+  {
+    if(m_pcRPS->getUsed(i))
+    {
+      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
+      pcRefPic->setIsLongTerm(1);
+      pcRefPic->getPicYuvRec()->extendPicBorder();
+      RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
+      NumPocLtCurr++;
+    }
+    if(pcRefPic==NULL) 
+    {
+      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
+    }
+    pcRefPic->setCheckLTMSBPresent(m_pcRPS->getCheckLTMSBPresent(i));  
+  }
+
+  Int numPocInterCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr; 
+  numPocTotalCurr = numPocInterCurr + getNumActiveRefLayerPics( );
+  assert( numPocTotalCurr == getNumRpsCurrTempList() );
+
+  if (checkNumPocTotalCurr)
+  {
+    // The variable NumPocTotalCurr is derived as specified in subclause 7.4.7.2. It is a requirement of bitstream conformance that the following applies to the value of NumPocTotalCurr:
+    // - If nuh_layer_id is equal to 0 and the current picture is a BLA picture or a CRA picture, the value of NumPocTotalCurr shall be equal to 0.
+    // - Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
+    if ( getRapPicFlag() && m_layerId == 0 )
+    {
+      assert(numPocTotalCurr == 0);
+    }
+
+    if (m_eSliceType == I_SLICE)
+    {
+      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
+      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
+      
+      return;
+    }
+    
+    assert(numPocTotalCurr > 0);
+    
+    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
+    m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
+  }
+
+  std::vector<TComPic*>* refPicSetInterLayer[2] = { &refPicSetInterLayer0, &refPicSetInterLayer1}; 
+  Int numPocInterLayer[2] = { getNumActiveRefLayerPics0( ), getNumActiveRefLayerPics1( ) }; 
+  
+  TComPic**             refPicSetStCurr    [2] = { RefPicSetStCurr0, RefPicSetStCurr1 };
+  Int numPocStCurr[2] = { NumPocStCurr0, NumPocStCurr1 }; 
+
+  for (Int li = 0; li < ((m_eSliceType==B_SLICE) ? 2 : 1); li++)
+  { 
+    rpsCurrList   [li].resize(MAX_NUM_REF+1,NULL ); 
+    usedAsLongTerm[li].resize(MAX_NUM_REF+1,false); 
+
+    Int cIdx = 0;
+    for ( i=0; i < numPocStCurr[li]; i++, cIdx++)
+    {
+      rpsCurrList[li][cIdx] = refPicSetStCurr[li][i];
+      usedAsLongTerm [li][cIdx] = false;  
+    }
+
+    for ( i=0; i < numPocInterLayer[li];  i++, cIdx++)
+    {    
+      rpsCurrList[li][cIdx] = (*refPicSetInterLayer[li])[i];
+      usedAsLongTerm [li][cIdx] = true;  
+    }
+
+    for ( i=0; i < numPocStCurr[1-li]; i++, cIdx++)
+    {
+      rpsCurrList[li][cIdx] = refPicSetStCurr[1-li][i];
+      usedAsLongTerm [li][cIdx] = false;  
+    }
+
+    for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
+    {
+      rpsCurrList[li][cIdx] = RefPicSetLtCurr[i];
+      usedAsLongTerm [li][cIdx] = true;  
+    }
+
+    for ( i=0; i < numPocInterLayer[1-li];  i++, cIdx++)
+    {    
+      assert( cIdx < MAX_NUM_REF );    
+      rpsCurrList[li][cIdx] = (*refPicSetInterLayer[1-li])[i];
+      usedAsLongTerm [li][cIdx] = true;  
+    }
+
+    assert(cIdx == numPocTotalCurr);
+  }
+}
+
+Void TComSlice::setRefPicList( std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int numPocTotalCurr, Bool checkNumPocTotalCurr )
+
+{
+  if (!checkNumPocTotalCurr)
+  {
+    if (m_eSliceType == I_SLICE)
+    {
+      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
+      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
+
+      return;
+    }    
+  }
+
+  ::memset(m_bIsUsedAsLongTerm, 0, sizeof(m_bIsUsedAsLongTerm));
+
+  for (Int li = 0; li < 2; li++)
+  {
+    if ( m_eSliceType == P_SLICE && li == 1 )
+    {
+      m_aiNumRefIdx[1] = 0;
+      ::memset( m_apcRefPicList[1], 0, sizeof(m_apcRefPicList[1]));
+    } 
+    else
+    {
+      for (Int rIdx = 0; rIdx <= (m_aiNumRefIdx[ li ] - 1 ); rIdx ++)
+      { 
+        Bool listModified             =                m_RefPicListModification.getRefPicListModificationFlagL( li ); 
+        Int orgIdx                    = listModified ? m_RefPicListModification.getRefPicSetIdxL(li, rIdx) : (rIdx % numPocTotalCurr); 
+
+        assert( rpsCurrList[li][ orgIdx ] != NULL ); 
+        m_apcRefPicList    [li][rIdx] = rpsCurrList    [li][ orgIdx ];
+        m_bIsUsedAsLongTerm[li][rIdx] = usedAsLongTerm [li][ orgIdx ] ; 
+      }
+    }
+  }
+}
+#endif
+#else
+#if H_MV
+Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer , Bool checkNumPocTotalCurr)
+#else
+#if FIX1071
+Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
+#else
+Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic )
+#endif
+#endif
+{
+#if FIX1071
+  if (!checkNumPocTotalCurr)
+#endif
+  {
+    if (m_eSliceType == I_SLICE)
+    {
+      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
+      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
+      
+      return;
+    }
+    
+#if !H_MV
+    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
+    m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
+#endif
+  }
+
+  TComPic*  pcRefPic= NULL;
+  TComPic*  RefPicSetStCurr0[16];
+  TComPic*  RefPicSetStCurr1[16];
+  TComPic*  RefPicSetLtCurr[16];
+  UInt NumPocStCurr0 = 0;
+  UInt NumPocStCurr1 = 0;
+  UInt NumPocLtCurr = 0;
+  Int i;
+
+  for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++)
+  {
+    if(m_pcRPS->getUsed(i))
+    {
+      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
+      pcRefPic->setIsLongTerm(0);
+      pcRefPic->getPicYuvRec()->extendPicBorder();
+      RefPicSetStCurr0[NumPocStCurr0] = pcRefPic;
+      NumPocStCurr0++;
+      pcRefPic->setCheckLTMSBPresent(false);  
+    }
+  }
   
   for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++)
@@ -458 +827 @@
     // The variable NumPocTotalCurr is derived as specified in subclause 7.4.7.2. It is a requirement of bitstream conformance that the following applies to the value of NumPocTotalCurr:
 #if H_MV
-    // – If nuh_layer_id is equal to 0 and the current picture is a BLA picture or a CRA picture, the value of NumPocTotalCurr shall be equal to 0.
-    // – Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
+    // – If nuh_layer_id is equal to 0 and the current picture is a BLA picture or a CRA picture, the value of NumPocTotalCurr shall be equal to 0.
+    // – Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
     if ( getRapPicFlag() && m_layerId == 0 )
 #else
-    // – If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
-    // – Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
+    // – If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
+    // – Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
     if (getRapPicFlag())
 #endif
@@ -593 +962 @@
 }
 
+#endif
 Int TComSlice::getNumRpsCurrTempList()
 {
@@ -609 +979 @@
   }
 #if H_MV
+#if !H_MV5
   assert( ( numRpsCurrTempList == 0 ) || getInterRefEnabledInRPLFlag() ); 
+#endif
   numRpsCurrTempList = numRpsCurrTempList + getNumActiveRefLayerPics();
 #endif
@@ -923 +1295 @@
 #if H_MV
   // Additional slice header syntax elements 
+#if H_MV5
+  m_pocResetFlag               = pSrc->m_pocResetFlag; 
+#endif
   m_discardableFlag            = pSrc->m_discardableFlag; 
   m_interLayerPredEnabledFlag  = pSrc->m_interLayerPredEnabledFlag; 
@@ -931 +1306 @@
     m_interLayerPredLayerIdc[ layer ] = pSrc->m_interLayerPredLayerIdc[ layer ]; 
   }
-  
+#if !H_MV5
   m_interLayerSamplePredOnlyFlag = pSrc->m_interLayerSamplePredOnlyFlag;
   m_altCollocatedIndicationFlag  = pSrc->m_altCollocatedIndicationFlag ;   
@@ -941 +1316 @@
     m_interLayerPredLayerIdc[layer] = pSrc->m_interLayerPredLayerIdc[layer];
   }
+#endif
 #endif
 #if H_3D_IC
@@ -1405 +1781 @@
 : m_VPSId                     (  0)
 , m_uiMaxTLayers              (  1)
+#if H_MV5
+#if H_MV
+, m_uiMaxLayersMinus1         (  0)
+#else
 , m_uiMaxLayers               (  1)
+#endif
+#else
+, m_uiMaxLayers               (  1)
+#endif
 , m_bTemporalIdNestingFlag    (false)
 , m_numHrdParameters          (  0)
@@ -1416 +1800 @@
 , m_hrdOpSetIdx               (NULL)
 , m_cprmsPresentFlag          (NULL)
+#if H_MV5
+#if H_MV
+, m_vpsVUI                 (  NULL )
+#endif
+#endif
 {
   for( Int i = 0; i < MAX_TLAYER; i++)
@@ -1459 +1848 @@
 
   m_avcBaseLayerFlag = false;
+#if H_MV5
+  m_vpsVuiOffset     = 0; 
+#endif
   m_splittingFlag    = false;
   
   for( Int i = 0; i < MAX_NUM_SCALABILITY_TYPES; i++ )
   {
+#if H_MV5
+    m_scalabilityMaskFlag[i] = false;
+#else
     m_scalabilityMask[i] = false;
+#endif
     m_dimensionIdLen [i]  = -1; 
   }
@@ -1489 +1885 @@
     m_layerIdInNuh      [i] = ( i == 0 ) ? 0 : -1; 
     m_numDirectRefLayers[i] = 0; 
+#if H_MV5
+    m_maxTidIlRefPicPlus1[i] = 7;
+    m_vpsRepFormatIdx    [i] = 0; 
+    m_repFormat          [i] = NULL; 
+    m_viewIdVal          [i] = 0; 
+#else
     m_maxTidIlRefPicPlus1[i] = -1; 
+#endif
+
 #if H_3D
     m_viewIndex         [i] = -1; 
@@ -1531 +1935 @@
 #endif
   }
+#if H_MV5
+  m_vpsVUI = new TComVPSVUI; 
+#endif
 #if H_3D
   for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
@@ -1556 +1963 @@
   if( m_hrdOpSetIdx      != NULL )     delete[] m_hrdOpSetIdx;
   if( m_cprmsPresentFlag != NULL )     delete[] m_cprmsPresentFlag;
+#if H_MV5
+#if H_MV
+  if ( m_vpsVUI          != NULL )     delete m_vpsVUI; 
+  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
+  {
+    if (m_repFormat[ i ] != NULL )      delete m_repFormat[ i ];    
+#if H_3D_DIM_DLT
+    if ( m_iDepthValue2Idx[i] != 0 ) 
+    {
+       xFree( m_iDepthValue2Idx[i] );
+       m_iDepthValue2Idx[i] = 0; 
+    }
+
+    if ( m_iIdx2DepthValue[i] != 0 ) 
+    {
+      xFree( m_iIdx2DepthValue[i] );
+      m_iIdx2DepthValue[i] = 0; 
+    }
+#endif
+  }
+#endif
+#else
 #if H_3D_DIM_DLT
   for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
@@ -1572 +2001 @@
     }
   }
+#endif
 #endif
 }
@@ -1642 +2072 @@
 Bool TComVPS::checkVPSExtensionSyntax()
 {
+#if H_MV5
+  for( Int layer = 1; layer <= getMaxLayersMinus1(); layer++ )
+#else
   for( Int layer = 1; layer < getMaxLayers(); layer++ )
+#endif
   {
     // check layer_id_in_nuh constraint
@@ -1658 +2092 @@
 {
   assert( scalType >= 0 && scalType <= MAX_NUM_SCALABILITY_TYPES ); 
+#if H_MV5
+  assert( scalType == MAX_NUM_SCALABILITY_TYPES || getScalabilityMaskFlag( scalType ) );
+#else
   assert( scalType == MAX_NUM_SCALABILITY_TYPES || getScalabilityMask( scalType ) );
-
+#endif
   Int scalIdx = 0; 
   for( Int curScalType = 0; curScalType < scalType; curScalType++ )
   {
+#if H_MV5
+    scalIdx += ( getScalabilityMaskFlag( curScalType ) ? 1 : 0 );
+#else
     scalIdx += ( getScalabilityMask( curScalType ) ? 1 : 0 );
+#endif
+
   }
 
   return scalIdx; 
 }
-
+#if H_MV5
+Void TComVPS::setScalabilityMaskFlag( UInt val )
+{
+  for ( Int scalType = 0; scalType < MAX_NUM_SCALABILITY_TYPES; scalType++ ) 
+  {
+    setScalabilityMaskFlag( scalType, ( val & (1 << scalType ) ) != 0 );
+  }
+}
+#else
 Void TComVPS::setScalabilityMask( UInt val )
 {
@@ -1675 +2125 @@
 }
 
+#endif
+
+#if H_MV5
+Void TComVPS::setRefLayers()
+{
+  for( Int i = 0; i  <= getMaxLayersMinus1(); i++ )
+  {
+    Int iNuhLId = getLayerIdInNuh( i ); 
+    m_numDirectRefLayers[ iNuhLId ] = 0; 
+    for( Int j = 0; j < i; j++ )
+    {
+      if( getDirectDependencyFlag(i , j) )
+      {
+        m_refLayerId[ iNuhLId ][m_numDirectRefLayers[ iNuhLId ]++ ] = getLayerIdInNuh( j );
+      }
+    }
+  }
+}
+
+Int TComVPS::getRefLayerId( Int layerIdInNuh, Int idx )
+{
+  assert( idx >= 0 && idx < m_numDirectRefLayers[layerIdInNuh] );     
+  Int refLayerIdInNuh = m_refLayerId[ layerIdInNuh ][ idx ];    
+  assert ( refLayerIdInNuh >= 0 ); 
+  return refLayerIdInNuh;
+}
+
+Int TComVPS::getScalabilityId( Int layerIdInVps, ScalabilityType scalType )
+{
+  return getScalabilityMaskFlag( scalType ) ? getDimensionId( layerIdInVps, scalTypeToScalIdx( scalType ) ) : 0;
+}
+
+#if H_3D
+Int TComVPS::getLayerIdInNuh( Int viewIndex, Bool depthFlag )
+{
+  Int foundLayerIdinNuh = -1; 
+
+  for (Int layerIdInVps = 0 ; layerIdInVps <= getMaxLayersMinus1(); layerIdInVps++ )
+  {
+    Int layerIdInNuh = getLayerIdInNuh( layerIdInVps ); 
+    if( ( getViewIndex( layerIdInNuh ) == viewIndex ) && ( getDepthId( layerIdInNuh ) == ( depthFlag ? 1 : 0 ) )  )
+    {
+      foundLayerIdinNuh = layerIdInNuh; 
+      break; 
+    }
+  }
+  assert( foundLayerIdinNuh != -1 ); 
+
+  return foundLayerIdinNuh;
+}
+#endif // H_3D
+#else
 Void TComVPS::setRefLayers()
 {
@@ -1793 +2295 @@
 }
 
+#endif // H_MV5
+
 
 Int TComVPS::xGetDimBitOffset( Int j )
@@ -1832 +2336 @@
   return numLayersInIdList;
 }
+#if H_MV5
+Int TComVPS::getNumViews()
+{
+  Int numViews = 1; 
+  for( Int i = 0; i <=  getMaxLayersMinus1(); i++ )
+  {
+    Int lId = getLayerIdInNuh( i ); 
+    if ( i > 0 && ( getViewIndex( lId ) != getScalabilityId( i - 1, VIEW_ORDER_INDEX ) ) )
+    {
+      numViews++; 
+    }    
+  }
+
+  return numViews;
+}
+
+Bool TComVPS::getInDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Int depth /*= 0 */ )
+{
+  assert( depth < 65 ); 
+  Bool dependentFlag = getDirectDependencyFlag( depLayeridInVps, refLayeridInVps ); 
+
+  for( Int i = 0; i < depLayeridInVps && !dependentFlag; i++ )
+  {
+    if ( getDirectDependencyFlag( depLayeridInVps, i ) )
+    {
+      dependentFlag = getInDirectDependencyFlag( i, refLayeridInVps, depth++ ); 
+    }
+  }
+  return dependentFlag;
+}
+#endif
 #endif // H_MV
 
@@ -1882 +2417 @@
 , m_vuiParameters             ()
 #if H_MV
+#if H_MV5
+, m_pcVPS                     ( NULL )
+, m_spsInferScalingListFlag   ( false )
+, m_spsScalingListRefLayerId  ( 0 )
+, m_updateRepFormatFlag       ( true ) 
+, m_interViewMvVertConstraintFlag (false)
+#else
 , m_interViewMvVertConstraintFlag (false)
 , m_numIlpRestrictedRefLayers ( 0 )
+#endif
 #endif
 #if H_3D
@@ -1898 +2441 @@
   ::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
   ::memset(m_usedByCurrPicLtSPSFlag, 0, sizeof(m_usedByCurrPicLtSPSFlag));
+#if !H_MV5
 #if H_MV
   for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
@@ -1905 +2449 @@
     m_minHorizontalCtuOffsetPlus1 [ i ] = 0;
   }
+#endif
 #endif
 }
@@ -2058 +2603 @@
 , m_listsModificationPresentFlag(  0)
 , m_numExtraSliceHeaderBits(0)
+#if H_MV5
+#if H_MV
+, m_ppsInferScalingListFlag(false)
+, m_ppsScalingListRefLayerId(0)
+#endif
+#endif
 {
   m_scalingList = new TComScalingList;
@@ -2077 +2628 @@
 }
 
+#if H_MV5
+#if H_MV
+Void TComSPS::inferRepFormat( TComVPS* vps, Int layerIdCurr )
+{
+  if ( layerIdCurr > 0 )
+  { 
+    TComRepFormat* repFormat = vps->getRepFormat( vps->getVpsRepFormatIdx( vps->getLayerIdInVps( layerIdCurr ) ) ); 
+    if ( !getUpdateRepFormatFlag() )
+    {        
+      setChromaFormatIdc( repFormat->getChromaFormatVpsIdc() );         
+      //// ToDo: add when supported: 
+      // setSeperateColourPlaneFlag( repFormat->getSeparateColourPlaneVpsFlag() ) ; 
+
+      setPicWidthInLumaSamples ( repFormat->getPicWidthVpsInLumaSamples()  ); 
+      setPicHeightInLumaSamples( repFormat->getPicHeightVpsInLumaSamples() ); 
+
+      setBitDepthY             ( repFormat->getBitDepthVpsLumaMinus8()   + 8 ); 
+      setQpBDOffsetY           ( (Int) (6*( getBitDepthY() - 8 )) );
+
+      setBitDepthC             ( repFormat->getBitDepthVpsChromaMinus8() + 8 ); 
+      setQpBDOffsetC           ( (Int) (6* ( getBitDepthC() -8 ) ) );
+    }
+    else
+    {
+      assert( getChromaFormatIdc()      <=  repFormat->getChromaFormatVpsIdc()         ); 
+      //// ToDo: add when supported: 
+      // assert( getSeperateColourPlaneFlag() <=  repFormat->getSeparateColourPlaneVpsFlag() ) ; 
+
+      assert( getPicWidthInLumaSamples()  <= repFormat->getPicWidthVpsInLumaSamples()    ); 
+      assert( getPicHeightInLumaSamples() <= repFormat->getPicHeightVpsInLumaSamples()   ); 
+
+      assert( getBitDepthY()              <= repFormat->getBitDepthVpsLumaMinus8()   + 8 );         
+      assert( getBitDepthC()              <= repFormat->getBitDepthVpsChromaMinus8() + 8 ); 
+    }
+  }
+
+  // Set conformance window
+  Int scal = TComSPS::getWinUnitX( getChromaFormatIdc() ) ;
+  getConformanceWindow().scaleOffsets( scal );
+  getVuiParameters()->getDefaultDisplayWindow().scaleOffsets( scal );
+}
+
+Void TComSPS::inferScalingList( TComSPS* spsSrc )
+{
+  if ( getSpsInferScalingListFlag() ) 
+  {
+    assert( spsSrc != NULL ); 
+    assert( !spsSrc->getSpsInferScalingListFlag() );             
+    getScalingList()->inferFrom( spsSrc->getScalingList() ); 
+  }
+}
+#endif
+#endif
 #if H_3D
 Void
@@ -2346 +2950 @@
 
 #if H_MV
-Void TComSlice::createAndApplyIvReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer )
-{
-  refPicSetInterLayer.clear(); 
+#if H_MV5
+Void TComSlice::createInterLayerReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1 )
+{
+  refPicSetInterLayer0.clear(); 
+  refPicSetInterLayer1.clear(); 
 
   for( Int i = 0; i < getNumActiveRefLayerPics(); i++ ) 
@@ -2360 +2966 @@
     picRef->getSlice(0)->setReferenced( true );       
 
+    Int viewIdCur  = getVPS()->getViewId( getLayerId() ); 
+    Int viewIdZero = getVPS()->getViewId( 0 );
+    Int viewIdRef  = getVPS()->getViewId( layerIdRef ); 
+
+    if (  ( viewIdCur <= viewIdZero && viewIdCur <= viewIdRef ) || ( viewIdCur >= viewIdZero && viewIdCur >= viewIdRef ) )
+    {
+      refPicSetInterLayer0.push_back( picRef ); 
+    }
+    else
+    {
+      refPicSetInterLayer1.push_back( picRef ); 
+    }
+    // Consider to check here: 
+    // "If the current picture is a RADL picture, there shall be no entry in the RefPicSetInterLayer0 and RefPicSetInterLayer1 that is a RASL picture. "    
+  }
+}
+#else
+Void TComSlice::createAndApplyIvReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer )
+{
+  refPicSetInterLayer.clear(); 
+
+  for( Int i = 0; i < getNumActiveRefLayerPics(); i++ ) 
+  {
+    Int layerIdRef = getRefPicLayerId( i ); 
+    TComPic* picRef = ivPicLists->getPic( layerIdRef, getPOC() ) ; 
+    assert ( picRef != 0 ); 
+
+    picRef->getPicYuvRec()->extendPicBorder(); 
+    picRef->setIsLongTerm( true );        
+    picRef->getSlice(0)->setReferenced( true );       
+
     // Consider to check here: 
     // "If the current picture is a RADL picture, there shall be no entry in the RefPicSetInterLayer that is a RASL picture. "
@@ -2365 +3002 @@
   }
 }
-
+#endif
+
+#if H_MV5
+Void TComSlice::markIvRefPicsAsShortTerm( std::vector<TComPic*> refPicSetInterLayer0, std::vector<TComPic*> refPicSetInterLayer1 )
+{
+  // Mark as shortterm 
+  for ( Int i = 0; i < refPicSetInterLayer0.size(); i++ ) 
+  {
+    refPicSetInterLayer0[i]->setIsLongTerm( false ); 
+  }
+
+  for ( Int i = 0; i < refPicSetInterLayer1.size(); i++ ) 
+  {
+    refPicSetInterLayer1[i]->setIsLongTerm( false ); 
+  }
+
+}
+#else
 Void TComSlice::markIvRefPicsAsShortTerm( std::vector<TComPic*> refPicSetInterLayer )
 {
@@ -2375 +3029 @@
 }
 
+#endif
 Void TComSlice::markIvRefPicsAsUnused( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc )
 {
@@ -2380 +3035 @@
   if (targetDecLayerIdSet.size() == 0 )    
   {
+#if H_MV5
+    for ( Int layerIdInVps = 0; layerIdInVps <= vps->getMaxLayersMinus1(); layerIdInVps++ )
+#else
     for ( Int layerIdInVps = 0; layerIdInVps < vps->getMaxLayers(); layerIdInVps++ )
+#endif
     {
       targetDecLayerIdSet.push_back( vps->getLayerIdInNuh( layerIdInVps ) ); 
@@ -2391 +3050 @@
   {
     if ( targetDecLayerIdSet[ latestDecIdx ] == curLayerId )
+    {
       break; 
+  }        
   }        
 
@@ -2407 +3068 @@
           if ( vps->nuhLayerIdIncluded( targetDecLayerIdSet[ j ] ) )
           {
+#if H_MV5
+            for( Int k = 0; k < vpsSlice->getNumDirectRefLayers( targetDecLayerIdSet[ j ] ); k++ )
+            {
+              if ( targetDecLayerIdSet[ i ] == vpsSlice->getRefLayerId( targetDecLayerIdSet[ j ],  k  ) )
+#else
             Int targetDecLayerIdinVPS = vpsSlice->getLayerIdInVps( targetDecLayerIdSet[ j ] ); 
             for( Int k = 0; k < vpsSlice->getNumDirectRefLayers( targetDecLayerIdinVPS ); k++ )
+            {
               if ( targetDecLayerIdSet[ i ] == vpsSlice->getRefLayerId( targetDecLayerIdinVPS,  k  ) )
+#endif
+              {
                 remainingInterLayerReferencesFlag = true;
           }
         }
+          }
+        }
         if( !remainingInterLayerReferencesFlag )
+        {
           pcPic->getSlice(0)->setReferenced( false );                   
       }
@@ -2419 +3091 @@
   }
 }
-
+}
+
+#if H_MV5
+Void TComSlice::printRefPicList()
+#else
 Void TComSlice::xPrintRefPicList()
+#endif
 {  
   for ( Int li = 0; li < 2; li++)
@@ -2433 +3110 @@
   }
 }
+#if !H_MV5
 Int TComSlice::xCeilLog2( Int val )
 {
@@ -2440 +3118 @@
   return ceilLog2;
 }
+#endif
 
 Void TComSlice::markCurrPic( TComPic* currPic )
@@ -2454 +3133 @@
 }
 
+#if H_MV5
+Void TComSlice::setRefPicSetInterLayer( std::vector<TComPic*>* refPicSetInterLayer0, std::vector<TComPic*>* refPicSetInterLayer1 )
+{
+  m_refPicSetInterLayer0 = refPicSetInterLayer0; 
+  m_refPicSetInterLayer1 = refPicSetInterLayer1; 
+}
+
+TComPic* TComSlice::getPicFromRefPicSetInterLayer(Int setIdc, Int layerId )
+{
+  assert ( setIdc == 0 || setIdc == 1);   
+  std::vector<TComPic*>* refPicSetInterLayer = ( setIdc == 0 ? m_refPicSetInterLayer0 : m_refPicSetInterLayer1);   
+  assert( refPicSetInterLayer != 0 ); 
+  
+  TComPic* pcPic = NULL; 
+  for ( Int i = 0; i < (*refPicSetInterLayer).size(); i++ )
+  {
+    if ((*refPicSetInterLayer)[ i ]->getLayerId() == layerId )
+    {
+      pcPic = (*refPicSetInterLayer)[ i ]; 
+    }
+  }
+
+  assert(pcPic != NULL); 
+  return pcPic;
+}
+#else
 Void TComSlice::setRefPicSetInterLayer( std::vector<TComPic*>* refPicSetInterLayer )
 {
@@ -2474 +3179 @@
   return pcPic;
 }
-
+#endif
 Int TComSlice::getNumActiveRefLayerPics()
 {
   Int numActiveRefLayerPics; 
 
+#if H_MV5
+  if( getLayerId() == 0 || getVPS()->getNumDirectRefLayers( getLayerId() ) ==  0 )
+  {
+    numActiveRefLayerPics = 0; 
+  }
+  else if (getVPS()->getAllRefLayersActiveFlag() )
+  {
+    numActiveRefLayerPics = getVPS()->getNumDirectRefLayers( getLayerId() );
+  }
+  else if ( !getInterLayerPredEnabledFlag() )
+  {
+    numActiveRefLayerPics = 0; 
+  }
+  else if( getVPS()->getMaxOneActiveRefLayerFlag() || getVPS()->getNumDirectRefLayers( getLayerId() ) == 1 )
+#else
   if( getLayerId() == 0 || getVPS()->getNumDirectRefLayers( getLayerIdInVps() ) ==  0 || !getInterLayerPredEnabledFlag() )
   {
@@ -2484 +3204 @@
   }
   else if( getVPS()->getMaxOneActiveRefLayerFlag() || getVPS()->getNumDirectRefLayers( getLayerIdInVps() ) == 1 )
+#endif
   {
     numActiveRefLayerPics = 1; 
@@ -2496 +3217 @@
 Int TComSlice::getRefPicLayerId( Int i )
 {
+#if H_MV5
+  return getVPS()->getRefLayerId( getLayerId(), getInterLayerPredLayerIdc( i ) );
+#else
   return getVPS()->getRefLayerId( getLayerIdInVps(), getInterLayerPredLayerIdc( i ) );
-}
-
+#endif
+}
+
+#if !H_MV5
 Void TComSlice::setActiveMotionPredRefLayers()
 {
@@ -2527 +3253 @@
   return interRefEnabledInRPLFlag;
 }
+#endif
 #if H_3D_ARP
 Void TComSlice::setARPStepNum()                                  
@@ -2804 +3531 @@
 }
 
+#if H_MV5
+#if H_MV
+Void TComScalingList::inferFrom( TComScalingList* srcScLi )
+{
+  for(Int sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
+  {
+    for(Int listId = 0; listId <  g_scalingListNum[sizeId]; listId++)
+    {
+      setRefMatrixId  (sizeId,listId, srcScLi->getRefMatrixId  (sizeId,listId));
+      setScalingListDC(sizeId,listId, srcScLi->getScalingListDC(sizeId,listId));          
+      ::memcpy(getScalingListAddress(sizeId, listId),srcScLi->getScalingListAddress(sizeId, listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
+    }
+  }
+}
+#endif
+#endif
 /** initialization process of quantization matrix array
  */
@@ -2893 +3636 @@
 , m_ppsMap(MAX_NUM_PPS)
 , m_activeVPSId(-1)
+#if H_MV5
+#if !H_MV
 , m_activeSPSId(-1)
 , m_activePPSId(-1)
 {
+#else
+{
+  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
+  {
+    m_activeSPSId[ i ] = -1; 
+    m_activePPSId[ i ] = -1; 
+  }
+#endif
+#else
+, m_activeSPSId(-1)
+, m_activePPSId(-1)
+{
+#endif
 }
 
@@ -2905 +3663 @@
 //! activate a SPS from a active parameter sets SEI message
 //! \returns true, if activation is successful
+#if H_MV5
+#if H_MV
+Bool ParameterSetManager::activateSPSWithSEI(Int spsId, Int layerId )
+#else
 Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
+#endif
+#else
+Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
+#endif
 {
   TComSPS *sps = m_spsMap.getPS(spsId);
@@ -2914 +3680 @@
     {
       m_activeVPSId = vpsId;
+#if !H_MV5
       m_activeSPSId = spsId;
+#else
+#if H_MV
+      m_activeSPSId[ layerId ] = spsId;
+#else
+      m_activeSPSId = spsId;
+#endif
+#endif
       return true;
     }
@@ -2931 +3705 @@
 //! activate a PPS and depending on isIDR parameter also SPS and VPS
 //! \returns true, if activation is successful
+#if H_MV5
+#if H_MV
+Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP, Int layerId )
+#else
+Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
+#endif
+{
+  TComPPS *pps = m_ppsMap.getPS(ppsId);
+  if (pps)
+  {
+    Int spsId = pps->getSPSId();
+#if H_MV
+    if (!isIRAP && (spsId != m_activeSPSId[ layerId ]))
+#else
+    if (!isIRAP && (spsId != m_activeSPSId))
+#endif
+    {
+      printf("Warning: tried to activate PPS referring to a inactive SPS at non-IRAP.");
+      return false;
+    }
+
+    TComSPS *sps = m_spsMap.getPS(spsId);
+    if (sps)
+    {
+      Int vpsId = sps->getVPSId();
+      if (!isIRAP && (vpsId != m_activeVPSId))
+      {
+        printf("Warning: tried to activate PPS referring to a inactive VPS at non-IRAP.");
+        return false;
+      }
+      if (m_vpsMap.getPS(vpsId))
+      {
+#if H_MV
+        m_activePPSId[ layerId ] = ppsId;
+        m_activeVPSId = vpsId;
+        m_activeSPSId[ layerId ] = spsId;
+#else
+        m_activePPSId = ppsId;
+        m_activeVPSId = vpsId;
+        m_activeSPSId = spsId;
+#endif
+#else
 Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
 {
@@ -2960 +3776 @@
         m_activeVPSId = vpsId;
         m_activeSPSId = spsId;
+#endif
         return true;
       }
@@ -3021 +3838 @@
 #endif
 //! \}
+
+#if H_MV5
+#if H_MV
+TComVPSVUI::TComVPSVUI()
+{
+  m_bitRatePresentVpsFlag = false;
+  m_picRatePresentVpsFlag = false;
+  for ( Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++)
+  {    
+    for ( Int j = 0; j < MAX_TLAYER; j++)
+    {    
+      m_bitRatePresentFlag          [i][j] = false;
+      m_picRatePresentFlag          [i][j] = false;
+      m_avgBitRate                  [i][j] = -1;
+      m_maxBitRate                  [i][j] = -1;
+      m_constantPicRateIdc          [i][j] = -1;
+      m_avgPicRate                  [i][j] = -1;
+    }
+  }
+
+  m_ilpRestrictedRefLayersFlag = false;
+
+  for ( Int i = 0; i < MAX_NUM_LAYERS; i++)
+  {          
+    for ( Int j = 0; j < MAX_NUM_LAYERS; j++)
+    {    
+      m_tileBoundariesAlignedFlag   [i][j] = false;
+      m_minSpatialSegmentOffsetPlus1[i][j] = 0;
+      m_ctuBasedOffsetEnabledFlag   [i][j] = false;
+      m_minHorizontalCtuOffsetPlus1 [i][j] = -1;
+    }
+  }
+}
+#endif
+#endif

branches/HTM-8.0-dev0/source/Lib/TLibCommon/TComSlice.h

@@ -169 +169 @@
   Void     processRefMatrix               (UInt sizeId, UInt listId , UInt refListId );
   Bool     xParseScalingList              (Char* pchFile);
+#if H_MV5
+#if H_MV
+  Void     inferFrom                      ( TComScalingList* srcScLi );
+#endif
+#endif
 
 private:
@@ -402 +407 @@
 };
 
+#if H_MV5
+#if H_MV
+class TComVPSVUI
+{
+private:
+  Bool m_bitRatePresentVpsFlag;
+  Bool m_picRatePresentVpsFlag;
+  Bool m_bitRatePresentFlag          [MAX_VPS_OP_SETS_PLUS1][MAX_TLAYER];
+  Bool m_picRatePresentFlag          [MAX_VPS_OP_SETS_PLUS1][MAX_TLAYER];
+  Int  m_avgBitRate                  [MAX_VPS_OP_SETS_PLUS1][MAX_TLAYER];
+  Int  m_maxBitRate                  [MAX_VPS_OP_SETS_PLUS1][MAX_TLAYER];
+  Int  m_constantPicRateIdc          [MAX_VPS_OP_SETS_PLUS1][MAX_TLAYER];
+  Int  m_avgPicRate                  [MAX_VPS_OP_SETS_PLUS1][MAX_TLAYER];
+  Bool m_tileBoundariesAlignedFlag   [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
+  Bool m_ilpRestrictedRefLayersFlag;
+  Int  m_minSpatialSegmentOffsetPlus1[MAX_NUM_LAYERS][MAX_NUM_LAYERS];
+  Bool m_ctuBasedOffsetEnabledFlag   [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
+  Int  m_minHorizontalCtuOffsetPlus1 [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
+
+public: 
+  TComVPSVUI();;
+
+  Void setBitRatePresentVpsFlag( Bool flag ) { m_bitRatePresentVpsFlag = flag; } 
+  Bool getBitRatePresentVpsFlag(  ) { return m_bitRatePresentVpsFlag; } 
+
+  Void setPicRatePresentVpsFlag( Bool flag ) { m_picRatePresentVpsFlag = flag; } 
+  Bool getPicRatePresentVpsFlag(  ) { return m_picRatePresentVpsFlag; } 
+
+  Void setBitRatePresentFlag( Int i, Int j, Bool flag ) { m_bitRatePresentFlag[i][j] = flag; } 
+  Bool getBitRatePresentFlag( Int i, Int j ) { return m_bitRatePresentFlag[i][j]; } 
+
+  Void setPicRatePresentFlag( Int i, Int j, Bool flag ) { m_picRatePresentFlag[i][j] = flag; } 
+  Bool getPicRatePresentFlag( Int i, Int j ) { return m_picRatePresentFlag[i][j]; } 
+
+  Void setAvgBitRate( Int i, Int j, Int  val ) { m_avgBitRate[i][j] = val; } 
+  Int  getAvgBitRate( Int i, Int j ) { return m_avgBitRate[i][j]; } 
+
+  Void setMaxBitRate( Int i, Int j, Int  val ) { m_maxBitRate[i][j] = val; } 
+  Int  getMaxBitRate( Int i, Int j ) { return m_maxBitRate[i][j]; } 
+
+  Void setConstantPicRateIdc( Int i, Int j, Int  val ) { m_constantPicRateIdc[i][j] = val; } 
+  Int  getConstantPicRateIdc( Int i, Int j ) { return m_constantPicRateIdc[i][j]; } 
+
+  Void setAvgPicRate( Int i, Int j, Int  val ) { m_avgPicRate[i][j] = val; } 
+  Int  getAvgPicRate( Int i, Int j ) { return m_avgPicRate[i][j]; } 
+
+  Void setTileBoundariesAlignedFlag( Int i, Int j, Bool flag ) { m_tileBoundariesAlignedFlag[i][j] = flag; } 
+  Bool getTileBoundariesAlignedFlag( Int i, Int j ) { return m_tileBoundariesAlignedFlag[i][j]; } 
+
+  Void setIlpRestrictedRefLayersFlag( Bool flag ) { m_ilpRestrictedRefLayersFlag = flag; } 
+  Bool getIlpRestrictedRefLayersFlag(  ) { return m_ilpRestrictedRefLayersFlag; } 
+
+  Void setMinSpatialSegmentOffsetPlus1( Int i, Int j, Int  val ) { m_minSpatialSegmentOffsetPlus1[i][j] = val; } 
+  Int  getMinSpatialSegmentOffsetPlus1( Int i, Int j ) { return m_minSpatialSegmentOffsetPlus1[i][j]; } 
+
+  Void setCtuBasedOffsetEnabledFlag( Int i, Int j, Bool flag ) { m_ctuBasedOffsetEnabledFlag[i][j] = flag; } 
+  Bool getCtuBasedOffsetEnabledFlag( Int i, Int j ) { return m_ctuBasedOffsetEnabledFlag[i][j]; } 
+
+  Void setMinHorizontalCtuOffsetPlus1( Int i, Int j, Int  val ) { m_minHorizontalCtuOffsetPlus1[i][j] = val; } 
+  Int  getMinHorizontalCtuOffsetPlus1( Int i, Int j ) { return m_minHorizontalCtuOffsetPlus1[i][j]; } 
+
+};
+
+class TComRepFormat
+{
+private:
+  Int  m_chromaFormatVpsIdc;
+  Bool m_separateColourPlaneVpsFlag;
+  Int  m_picWidthVpsInLumaSamples;
+  Int  m_picHeightVpsInLumaSamples;
+  Int  m_bitDepthVpsLumaMinus8;
+  Int  m_bitDepthVpsChromaMinus8;
+
+public: 
+  TComRepFormat() { };  
+
+  Void setChromaFormatVpsIdc( Int  val ) { m_chromaFormatVpsIdc = val; } 
+  Int  getChromaFormatVpsIdc(  ) { return m_chromaFormatVpsIdc; } 
+
+  Void setSeparateColourPlaneVpsFlag( Bool flag ) { m_separateColourPlaneVpsFlag = flag; } 
+  Bool getSeparateColourPlaneVpsFlag(  ) { return m_separateColourPlaneVpsFlag; } 
+
+  Void setPicWidthVpsInLumaSamples( Int  val ) { m_picWidthVpsInLumaSamples = val; } 
+  Int  getPicWidthVpsInLumaSamples(  ) { return m_picWidthVpsInLumaSamples; } 
+
+  Void setPicHeightVpsInLumaSamples( Int  val ) { m_picHeightVpsInLumaSamples = val; } 
+  Int  getPicHeightVpsInLumaSamples(  ) { return m_picHeightVpsInLumaSamples; } 
+
+  Void setBitDepthVpsLumaMinus8( Int  val ) { m_bitDepthVpsLumaMinus8 = val; } 
+  Int  getBitDepthVpsLumaMinus8(  ) { return m_bitDepthVpsLumaMinus8; } 
+
+  Void setBitDepthVpsChromaMinus8( Int  val ) { m_bitDepthVpsChromaMinus8 = val; } 
+  Int  getBitDepthVpsChromaMinus8(  ) { return m_bitDepthVpsChromaMinus8; } 
+};
+#endif
+#endif
+
 class TComVPS
 {
@@ -407 +509 @@
   Int         m_VPSId;
   UInt        m_uiMaxTLayers;
+
+#if H_MV5
+#if H_MV
+  UInt        m_uiMaxLayersMinus1;
+#else
   UInt        m_uiMaxLayers;
+#endif
+#else
+  UInt        m_uiMaxLayers;
+#endif
   Bool        m_bTemporalIdNestingFlag;
   
@@ -440 +551 @@
   /// VPS EXTENSION SYNTAX ELEMENTS
   Bool        m_avcBaseLayerFlag;
+#if H_MV5
+  Int         m_vpsVuiOffset;
+#endif
   Bool        m_splittingFlag;
+#if H_MV5
+  Bool        m_scalabilityMaskFlag          [MAX_NUM_SCALABILITY_TYPES];
+#else
   Bool        m_scalabilityMask          [MAX_NUM_SCALABILITY_TYPES];
+#endif
   Int         m_dimensionIdLen           [MAX_NUM_SCALABILITY_TYPES];
   Bool        m_vpsNuhLayerIdPresentFlag;
   Int         m_layerIdInNuh             [MAX_NUM_LAYER_IDS];
   Int         m_dimensionId              [MAX_NUM_LAYER_IDS][MAX_NUM_SCALABILITY_TYPES];  
+#if H_MV5
+  Int         m_viewIdLenMinus1;
+  Int         m_viewIdVal                [MAX_NUM_LAYERS];
+#endif
   Bool        m_directDependencyFlag     [MAX_NUM_LAYER_IDS][MAX_NUM_LAYER_IDS];
+#if H_MV5
+  Bool        m_maxTidRefPresentFlag;
+#endif
   Int         m_maxTidIlRefPicPlus1      [MAX_NUM_LAYERS];
+#if H_MV5
+  Bool        m_allRefLayersActiveFlag;
+#endif
   Int         m_vpsNumberLayerSetsMinus1; 
   Int         m_vpsNumProfileTierLevelMinus1;   
@@ -458 +586 @@
   Bool        m_outputLayerFlag          [MAX_VPS_OUTPUTLAYER_SETS][MAX_VPS_NUH_LAYER_ID_PLUS1];
   Int         m_profileLevelTierIdx      [MAX_VPS_OUTPUTLAYER_SETS ];
+#if H_MV5
+  Bool        m_repFormatIdxPresentFlag;
+  Int         m_vpsNumRepFormatsMinus1;
+  Int         m_vpsRepFormatIdx          [MAX_NUM_LAYERS];
+  TComRepFormat* m_repFormat             [MAX_NUM_LAYERS]; 
+#endif
   Bool        m_maxOneActiveRefLayerFlag;       
+#if H_MV5
+  Bool        m_crossLayerIrapAlignedFlag;
+#endif
   Int         m_directDepTypeLenMinus2;         
+#if H_MV5
+  Bool        m_vpsVuiPresentFlag;
+  TComVPSVUI* m_vpsVUI; 
+#endif
   Int         m_directDependencyType     [MAX_NUM_LAYERS] [MAX_NUM_LAYERS];
 
@@ -475 +616 @@
   Bool        m_motionPredEnabledFlag    [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
   Int         m_motionPredRefLayerId     [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
+#if H_MV5
+  Int         m_viewIndex                [MAX_NUM_LAYERS   ];
+#else
 #if H_3D
   Int         m_viewIndex                [MAX_NUM_LAYERS   ];
@@ -480 +624 @@
 
   Int         xCeilLog2       ( Int val );
+#endif
   Int         xGetDimBitOffset( Int j );
   
+  // VPS EXTENSION 2 SYNTAX ELEMENTS
 #if H_3D_ARP
   UInt        m_uiUseAdvResPred          [MAX_NUM_LAYERS   ];
@@ -535 +681 @@
   Void    setMaxTLayers  (UInt t)             { m_uiMaxTLayers = t; }
   
+#if H_MV5
+#if H_MV    
+  UInt    getMaxLayersMinus1()                { return m_uiMaxLayersMinus1;  }; 
+  Void    setMaxLayersMinus1(UInt l)          { m_uiMaxLayersMinus1 = l; }
+#else
   UInt    getMaxLayers   ()                   { return m_uiMaxLayers;   }
   Void    setMaxLayers   (UInt l)             { m_uiMaxLayers = l; }
+#endif
+#else
+  UInt    getMaxLayers   ()                   { return m_uiMaxLayers;   }
+  Void    setMaxLayers   (UInt l)             { m_uiMaxLayers = l; }
+#endif
 
   Bool    getTemporalNestingFlag   ()         { return m_bTemporalIdNestingFlag;   }
@@ -579 +735 @@
   Bool    getAvcBaseLayerFlag()                                            { return m_avcBaseLayerFlag; } 
 
+#if H_MV5
+  Void    setVpsVuiOffset( Int  val )                                      { m_vpsVuiOffset = val; } 
+  Int     getVpsVuiOffset(  )                                              { return m_vpsVuiOffset; } 
+#endif
+
   Void    setSplittingFlag( Bool val )                                     { m_splittingFlag = val;  }
   Bool    getSplittingFlag()                                               { return m_splittingFlag; }
 
+#if H_MV5
+  Void    setScalabilityMaskFlag( UInt val );
+  Void    setScalabilityMaskFlag( Int scalType, Bool val )                     { m_scalabilityMaskFlag[scalType] = val;  }
+  Bool    getScalabilityMaskFlag( Int scalType )                               { return m_scalabilityMaskFlag[scalType]; }
+#else
   Void    setScalabilityMask( UInt val );
 
   Void    setScalabilityMask( Int scalType, Bool val )              { m_scalabilityMask[scalType] = val;  }
   Bool    getScalabilityMask( Int scalType )                        { return m_scalabilityMask[scalType]; }
-
+#endif
   Int     getNumScalabilityTypes( );
 
@@ -603 +769 @@
   Int     getDimensionId( Int layerIdInVps, Int scalIdx )                  { return m_dimensionId[layerIdInVps][scalIdx]; }
 
+#if H_MV5
+  Void    setViewIdLenMinus1( Int  val )                                   { m_viewIdLenMinus1 = val; } 
+  Int     getViewIdLenMinus1(  )                                           { return m_viewIdLenMinus1; } 
+
+  Void    setViewIdVal( Int viewOrderIndex, Int  val )                     { m_viewIdVal[viewOrderIndex] = val; } 
+  Int     getViewIdVal( Int viewOrderIndex )                               { return m_viewIdVal[viewOrderIndex]; } 
+#endif
   Void    setDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Bool val ) { m_directDependencyFlag[depLayeridInVps][refLayeridInVps] = val;  }
   Bool    getDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps )           { return m_directDependencyFlag[depLayeridInVps][refLayeridInVps]; }
 
+#if H_MV5
+  Void    setMaxTidRefPresentFlag( Bool flag )                             { m_maxTidRefPresentFlag = flag; } 
+  Bool    getMaxTidRefPresentFlag(  )                                      { return m_maxTidRefPresentFlag; } 
+#endif
   Void    setMaxTidIlRefPicPlus1( Int layerIdInVps, Int val )              { m_maxTidIlRefPicPlus1[ layerIdInVps ] = val;  } 
   Int     getMaxTidIlRefPicPlus1( Int layerIdInVps )                       { return m_maxTidIlRefPicPlus1[ layerIdInVps ]; } 
-  
+#if H_MV5
+  Void    setAllRefLayersActiveFlag( Bool flag )                           { m_allRefLayersActiveFlag = flag; } 
+  Bool    getAllRefLayersActiveFlag(  )                                    { return m_allRefLayersActiveFlag; } 
+#endif
   Void    setVpsNumberLayerSetsMinus1( Int val )                           { m_vpsNumberLayerSetsMinus1 = val;  } 
   Int     getVpsNumberLayerSetsMinus1( )                                   { return m_vpsNumberLayerSetsMinus1; } 
@@ -639 +819 @@
   Int     getProfileLevelTierIdx( Int outLayerSetIdx )                     { return m_profileLevelTierIdx[ outLayerSetIdx ]; } 
 
+#if H_MV5
+  Void    setRepFormatIdxPresentFlag( Bool flag )                          { m_repFormatIdxPresentFlag = flag; } 
+  Bool    getRepFormatIdxPresentFlag(  )                                   { return m_repFormatIdxPresentFlag; } 
+
+  Void    setVpsNumRepFormatsMinus1( Int  val )                            { m_vpsNumRepFormatsMinus1 = val; } 
+  Int     getVpsNumRepFormatsMinus1(  )                                    { return m_vpsNumRepFormatsMinus1; } 
+
+  Void    setVpsRepFormatIdx( Int i, Int  val )                            { m_vpsRepFormatIdx[i] = val; } 
+  Int     getVpsRepFormatIdx( Int i )                                      { return m_vpsRepFormatIdx[i]; } 
+
+  Void    setRepFormat( Int i, TComRepFormat* val )                        { m_repFormat[i] = val;  }
+  TComRepFormat* getRepFormat( Int i )                                     { return m_repFormat[i]; }
+#endif
   Void    setMaxOneActiveRefLayerFlag( Bool flag)                          { m_maxOneActiveRefLayerFlag = flag; } 
   Bool    getMaxOneActiveRefLayerFlag( )                                   { return m_maxOneActiveRefLayerFlag; } 
-
+#if H_MV5
+  Void    setCrossLayerIrapAlignedFlag( Bool flag )                        { m_crossLayerIrapAlignedFlag = flag; } 
+  Bool    getCrossLayerIrapAlignedFlag(  )                                 { return m_crossLayerIrapAlignedFlag; } 
+#endif
   Void    setDirectDepTypeLenMinus2( Int val)                              { m_directDepTypeLenMinus2 = val; } 
   Int     getDirectDepTypeLenMinus2( )                                     { return m_directDepTypeLenMinus2; } 
@@ -647 +843 @@
   Void    setDirectDependencyType( Int depLayeridInVps, Int refLayeridInVps, Int val) { m_directDependencyType[ depLayeridInVps ][ refLayeridInVps ] = val; } 
   Int     getDirectDependencyType( Int depLayeridInVps, Int refLayeridInVps)   { return m_directDependencyType[ depLayeridInVps ][ refLayeridInVps ]; } 
-
-
+#if H_MV5  
+  Void    setVpsVuiPresentFlag( Bool flag )                                { m_vpsVuiPresentFlag = flag; } 
+  Bool    getVpsVuiPresentFlag(  )                                         { return m_vpsVuiPresentFlag; } 
+
+  TComVPSVUI* getVPSVUI(  )                                                { return m_vpsVUI;  }
+#endif
   // VPS EXTENSION SEMANTICS VARIABLES
   Void    setLayerIdInVps( Int layerIdInNuh, Int val )                     { m_layerIdInVps[layerIdInNuh] = val;  }
@@ -654 +854 @@
 
   Int     getScalabilityId ( Int layerIdInVps, ScalabilityType scalType );
+#if H_MV5
+  Int     getViewId        ( Int layerIdInNuh )                            { return m_viewIdVal[ getViewIndex( getLayerIdInVps( layerIdInNuh) )]; }
+#else
   Int     getViewId  ( Int layerIdInVps )                                  { return getScalabilityId( layerIdInVps, VIEW_ID  ); }
 
+#endif
   Void    setRefLayers(); 
 
+#if H_MV5
+  Int     getViewIndex    ( Int layerIdInNuh )                             { return getScalabilityId( getLayerIdInVps(layerIdInNuh), VIEW_ORDER_INDEX  ); }    
+  Int     getNumViews();
+
+  Int     getNumDirectRefLayers( Int layerIdInNuh )                        { return m_numDirectRefLayers[ layerIdInNuh ];  };                               
+  Int     getRefLayerId        ( Int layerIdInNuh, Int idx );; 
+#else
   Int     getNumDirectRefLayers( Int layerIdInVps )          { return m_numDirectRefLayers[ layerIdInVps ];  };                               
   Int     getRefLayerId        ( Int layerIdInVps, Int idx );; 
@@ -668 +879 @@
   Bool    getMotionPredEnabledFlag ( Int layerIdInVps, Int idx ) { return m_motionPredEnabledFlag [layerIdInVps][idx]; } 
   Int     getMotionPredRefLayerId  ( Int layerIdInVps, Int idx ) { return m_motionPredRefLayerId  [layerIdInVps][idx]; } 
-
+#endif  
   Bool    checkVPSExtensionSyntax(); 
   Int     scalTypeToScalIdx   ( ScalabilityType scalType );
 
+  #if H_MV5
+Int     getProfileLevelTierIdxLen()                                      { return gCeilLog2( getVpsNumProfileTierLevelMinus1() + 1 ); };       
+#else
   Int     getProfileLevelTierIdxLen() { return xCeilLog2( getVpsNumProfileTierLevelMinus1() + 1 ); };       
+#endif
+
   Int     getNumLayersInIdList              ( Int lsIdx );; 
 
@@ -679 +895 @@
   Int     inferLastDimsionIdLenMinus1();
 
+#if H_MV5
+  // helpers
+  Bool    getInDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Int depth = 0 );
+#endif
+  /// VPS EXTENSION 2 SYNTAX ELEMENTS
 #if H_3D  
+#if H_MV5
+  Int     getDepthId      ( Int layerIdInNuh)                             { return getScalabilityId( getLayerIdInVps(layerIdInNuh), DEPTH_ID ); }
+#else
   Void    initViewIndex(); 
   Int     getViewIndex    ( Int layerIdInVps )                             { return m_viewIndex[ layerIdInVps ]; }    
   Int     getDepthId      ( Int layerIdInVps )                             { return getScalabilityId( layerIdInVps, DEPTH_ID ); }
+#endif
   Int     getLayerIdInNuh( Int viewIndex, Bool depthFlag );   
 
@@ -735 +960 @@
   Int           m_winTopOffset;
   Int           m_winBottomOffset;
+#if H_MV5
+#if H_MV
+  Bool          m_scaledFlag; 
+#endif
+#endif
 public:
   Window()
@@ -742 +972 @@
   , m_winTopOffset      (0)
   , m_winBottomOffset   (0)
+#if H_MV5
+#if H_MV
+  , m_scaledFlag(true)
+#endif
+#endif
   { }
 
@@ -755 +990 @@
   Void          setWindowBottomOffset(Int val)    { m_winBottomOffset = val; m_enabledFlag = true; }
 
+#if H_MV5
+#if H_MV
+  Void          setScaledFlag(Bool flag)          { m_scaledFlag = flag;  } 
+  Bool          getScaledFlag() const             { return m_scaledFlag;  } 
+  Void          scaleOffsets( Int scal )          
+  {
+    if (! m_scaledFlag )
+    {
+      m_scaledFlag         = true; 
+      m_winLeftOffset     *= scal; 
+      m_winRightOffset    *= scal; 
+      m_winTopOffset      *= scal; 
+      m_winBottomOffset   *= scal; 
+    }
+  }
+#endif
+#endif
   Void          setWindow(Int offsetLeft, Int offsetLRight, Int offsetLTop, Int offsetLBottom)
   {
@@ -802 +1054 @@
   TComHRD m_hrdParameters;
   TimingInfo m_timingInfo;
+#if !H_MV5
 #if H_MV
   Bool m_tileBoundariesAlignedFlag;
+#endif
 #endif
 
@@ -837 +1091 @@
     ,m_log2MaxMvLengthHorizontal(15)
     ,m_log2MaxMvLengthVertical(15)
+#if !H_MV5
 #if H_MV
     ,m_tileBoundariesAlignedFlag(true)
+#endif
 #endif
   {}
@@ -935 +1191 @@
   TComHRD* getHrdParameters                 ()             { return &m_hrdParameters; }
   TimingInfo* getTimingInfo() { return &m_timingInfo; }
+#if !H_MV5
 #if H_MV
 Bool getTileBoundariesAlignedFlag(  ) { return m_tileBoundariesAlignedFlag; } 
   Void setTileBoundariesAlignedFlag( Bool flag ) { m_tileBoundariesAlignedFlag = flag; } 
 #endif
+#endif
+
 };
 
@@ -1022 +1281 @@
   TComPTL     m_pcPTL;
 #if H_MV
+#if H_MV5
+  TComVPS*    m_pcVPS; 
+  // SPS 
+  Bool        m_spsInferScalingListFlag;
+  Int         m_spsScalingListRefLayerId;
+  Bool        m_updateRepFormatFlag;
+#endif
+  // SPS Extension 
   Bool        m_interViewMvVertConstraintFlag;
+#if !H_MV5
   Int         m_numIlpRestrictedRefLayers        ;
   Int         m_minSpatialSegmentOffsetPlus1[MAX_NUM_LAYERS];
   Bool        m_ctuBasedOffsetEnabledFlag   [MAX_NUM_LAYERS];
   Int         m_minHorizontalCtuOffsetPlus1 [MAX_NUM_LAYERS];
+#endif
 #endif
 #if H_3D
@@ -1163 +1432 @@
   TComPTL* getPTL()     { return &m_pcPTL; }
 #if H_MV
+#if H_MV5
+  Void      setVPS          ( TComVPS* pcVPS ) { m_pcVPS = pcVPS; }
+  TComVPS*  getVPS          () { return m_pcVPS; }
+
+  Void setSpsInferScalingListFlag( Bool flag ) { m_spsInferScalingListFlag = flag; } 
+  Bool getSpsInferScalingListFlag(  )          { return m_spsInferScalingListFlag; } 
+
+  Void setSpsScalingListRefLayerId( Int  val ) { m_spsScalingListRefLayerId = val; } 
+  Int  getSpsScalingListRefLayerId(  )         { return m_spsScalingListRefLayerId; } 
+
+  Void setUpdateRepFormatFlag( Bool flag )     { m_updateRepFormatFlag = flag; } 
+  Bool getUpdateRepFormatFlag(  )              { return m_updateRepFormatFlag; } 
+#endif
+  // SPS Extension 
   Void setInterViewMvVertConstraintFlag(Bool val) { m_interViewMvVertConstraintFlag = val; }
   Bool getInterViewMvVertConstraintFlag()         { return m_interViewMvVertConstraintFlag;}
-
-  ////  sps_extension_vui_parameters( )
+#if H_MV5
+  // Inference 
+  Void inferRepFormat( TComVPS* vps, Int layerIdCurr );
+
+  Void inferScalingList( TComSPS* spsSrc );
+#else
   Void setNumIlpRestrictedRefLayers   ( Int val )        { m_numIlpRestrictedRefLayers         = val;}
   Int  getNumIlpRestrictedRefLayers   ( )                { return m_numIlpRestrictedRefLayers        ;}
@@ -1178 +1465 @@
   Void setMinHorizontalCtuOffsetPlus1 ( Int i, Int val )   { m_minHorizontalCtuOffsetPlus1 [ i ] = val;}
   Int  getMinHorizontalCtuOffsetPlus1 ( Int i )            { return m_minHorizontalCtuOffsetPlus1 [ i ];}
+
+#endif
 #endif
 #if H_3D_QTLPC
@@ -1293 +1582 @@
   Int m_numExtraSliceHeaderBits;
 
+#if H_MV5
+#if H_MV
+  Int  m_layerId; 
+  Bool m_ppsInferScalingListFlag;
+  Int  m_ppsScalingListRefLayerId;
+#endif
+#endif
 public:
   TComPPS();
@@ -1414 +1710 @@
   Bool getSliceHeaderExtensionPresentFlag   ()                    { return m_sliceHeaderExtensionPresentFlag; }
   Void setSliceHeaderExtensionPresentFlag   (Bool val)            { m_sliceHeaderExtensionPresentFlag = val; }
+#if H_MV5
+#if H_MV
+  Void setLayerId( Int  val ) { m_layerId = val; } 
+  Int  getLayerId(  ) { return m_layerId; } 
+
+  Void setPpsInferScalingListFlag( Bool flag ) { m_ppsInferScalingListFlag = flag; } 
+  Bool getPpsInferScalingListFlag(  ) { return m_ppsInferScalingListFlag; } 
+
+  Void setPpsScalingListRefLayerId( Int  val ) { m_ppsScalingListRefLayerId = val; } 
+  Int  getPpsScalingListRefLayerId(  ) { return m_ppsScalingListRefLayerId; } 
+#endif
+#endif
 };
 
@@ -1446 +1754 @@
   Bool        m_PicOutputFlag;        ///< pic_output_flag 
   Int         m_iPOC;
+#if H_MV5
+#if H_MV
+  Int         m_iPOCBeforeReset; 
+#endif
+#endif
   Int         m_iLastIDR;
   static Int  m_prevPOC;
@@ -1540 +1853 @@
   Bool       m_enableTMVPFlag;
 #if H_MV
+#if H_MV5
+  std::vector<TComPic*>* m_refPicSetInterLayer0; 
+  std::vector<TComPic*>* m_refPicSetInterLayer1; 
+  Int        m_layerId; 
+  Int        m_viewId;
+  Int        m_viewIndex; 
+#if H_3D
+  Bool       m_isDepth;
+#endif
+#else
   std::vector<TComPic*>* m_refPicSetInterLayer; 
   Int        m_layerId; 
@@ -1547 +1870 @@
   Bool       m_isDepth;
 #endif
+#endif
 
 // Additional slice header syntax elements 
+#if H_MV5
+  Bool       m_pocResetFlag; 
+#endif
   Bool       m_discardableFlag;
   Bool       m_interLayerPredEnabledFlag;
   Int        m_numInterLayerRefPicsMinus1;
   Int        m_interLayerPredLayerIdc       [MAX_NUM_LAYERS];
+#if !H_MV5
   Bool       m_interLayerSamplePredOnlyFlag;
   Bool       m_altCollocatedIndicationFlag;
@@ -1560 +1888 @@
   Int        m_activeMotionPredRefLayerId   [ MAX_NUM_LAYER_IDS ];
 
+#endif
   Int        m_aaiCodedScale [2][MAX_NUM_LAYERS];
   Int        m_aaiCodedOffset[2][MAX_NUM_LAYERS];
@@ -1693 +2022 @@
   
 #if H_MV
+#if H_MV5
+  Void      setPocBeforeReset   ( Int i )                       { m_iPOCBeforeReset = i; }
+  Int       getPocBeforeReset   ( )                             { return m_iPOCBeforeReset; }
+#endif
   Int       getRefLayerId        ( RefPicList e, Int iRefIdx)    { return  m_aiRefLayerIdList[e][iRefIdx]; }
   Void      setRefLayerId        ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefLayerIdList[e][iRefIdx] = i; }
-#endif
-#if H_MV
+#if H_MV5
+  Void      getTempRefPicLists   ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1,                                     
+                                   std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int& numPocTotalCurr, Bool checkNumPocTotalCurr = false );
+
+  Void      setRefPicList        ( std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int numPocTotalCurr, Bool checkNumPocTotalCurr = false ); 
+#else
   Void      setRefPicList       ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& interLayerRefPicSet , Bool checkNumPocTotalCurr = false );
+#endif
 #else
 #if FIX1071
@@ -1746 +2084 @@
   Void applyReferencePictureSet( TComList<TComPic*>& rcListPic, TComReferencePictureSet *RPSList);
 #if H_MV
+#if !H_MV5
   Void createAndApplyIvReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer );
   static Void markIvRefPicsAsShortTerm    ( std::vector<TComPic*> refPicSetInterLayer );
+#else
+  Void createInterLayerReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1 );
+  static Void markIvRefPicsAsShortTerm    ( std::vector<TComPic*> refPicSetInterLayer0, std::vector<TComPic*> refPicSetInterLayer1 );
+#endif
   static Void markCurrPic                 ( TComPic* currPic );; 
   static Void markIvRefPicsAsUnused       ( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc  );
+#if H_MV5
+  Void        printRefPicList();
+#else
   Void        xPrintRefPicList();
+#endif
 #endif
   Bool isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic );
@@ -1837 +2184 @@
   Void      setViewId             ( Int viewId )     { m_viewId = viewId;   }
   Int       getViewId             ()                 { return m_viewId;     }
+#if H_MV5
+  Void      setViewIndex          ( Int viewIndex )  { m_viewIndex = viewIndex;   }
+  Int       getViewIndex          ()                 { return m_viewIndex;     }
+#endif
 #if H_3D
 #if H_3D_TMVP
@@ -1843 +2194 @@
   Int       getAlterRefIdx          ( RefPicList e )        { return  m_aiAlterRefIdx[e];     }
 #endif
+#if !H_MV5
   Void      setViewIndex          ( Int viewIndex )  { m_viewIndex = viewIndex;   }
   Int       getViewIndex          ()                 { return m_viewIndex;     }
+#endif
   Void      setIsDepth            ( Bool isDepth )   { m_isDepth = isDepth; }
   Bool      getIsDepth            ()                 { return m_isDepth; }
@@ -1865 +2218 @@
 #if H_MV
 // Additional slice header syntax elements
+
+#if H_MV5
+  Void setPocResetFlag( Bool flag ) { m_pocResetFlag = flag; } 
+  Bool getPocResetFlag(  ) { return m_pocResetFlag; } 
+#endif
+
 Void setDiscardableFlag( Bool flag ) { m_discardableFlag = flag; } 
 Bool getDiscardableFlag(  ) { return m_discardableFlag; } 
@@ -1877 +2236 @@
 Int  getInterLayerPredLayerIdc( Int i ) { return m_interLayerPredLayerIdc[i]; } 
 
+#if H_MV5 
+  // Additional variables derived in slice header semantics 
+  Int  getNumInterLayerRefPicsMinus1Len( ) { return gCeilLog2(  getVPS()->getNumDirectRefLayers( getLayerId() )); }
+  Int  getInterLayerPredLayerIdcLen    ( ) { return gCeilLog2(  getVPS()->getNumDirectRefLayers( getLayerId() )); }
+
+  Int  getNumActiveRefLayerPics( );
+
+  Int  getNumActiveRefLayerPics0( )        { return (Int) m_refPicSetInterLayer0->size();  };
+  Int  getNumActiveRefLayerPics1( )        { return (Int) m_refPicSetInterLayer1->size();  };
+
+  Int  getRefPicLayerId               ( Int i );
+
+  Void     setRefPicSetInterLayer       ( std::vector<TComPic*>* refPicSetInterLayer0, std::vector<TComPic*>* refPicSetInterLayer1);
+  TComPic* getPicFromRefPicSetInterLayer( Int setIdc, Int layerId );
+#else
 Void setInterLayerSamplePredOnlyFlag( Bool flag ) { m_interLayerSamplePredOnlyFlag = flag; } 
 Bool getInterLayerSamplePredOnlyFlag(  ) { return m_interLayerSamplePredOnlyFlag; } 
@@ -1903 +2277 @@
 TComPic* getPicFromRefPicSetInterLayer( Int layerId );
 
+#endif
 #endif
 protected:
@@ -1909 +2284 @@
 TComPic*  xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb);
 #if H_MV
+#if !H_MV5
   Int       xCeilLog2( Int val );
+#endif
   TComPic*  xGetInterLayerRefPic( std::vector<TComPic*>& rcListIlPic, Int layerId );  
 #endif
@@ -1991 +2368 @@
   //! activate a SPS from a active parameter sets SEI message
   //! \returns true, if activation is successful
+#if !H_MV5
   Bool activateSPSWithSEI(Int SPSId);
 
@@ -2010 +2388 @@
   Int m_activeSPSId;
   Int m_activePPSId;
+#else
+#if H_MV
+  Bool activateSPSWithSEI(Int SPSId, Int layerId );
+#else
+  Bool activateSPSWithSEI(Int SPSId);
+#endif
+
+  //! activate a PPS and depending on isIDR parameter also SPS and VPS
+  //! \returns true, if activation is successful
+#if H_MV
+  Bool activatePPS(Int ppsId, Bool isIRAP, Int layerId );
+#else
+  Bool activatePPS(Int ppsId, Bool isIRAP);
+#endif
+
+  TComVPS* getActiveVPS(){ return m_vpsMap.getPS(m_activeVPSId); };
+#if H_MV
+  TComSPS* getActiveSPS( Int layerId ){ return m_spsMap.getPS( m_activeSPSId[ layerId ] ); };
+  TComPPS* getActivePPS( Int layerId ){ return m_ppsMap.getPS( m_activePPSId[ layerId ] ); };
+#else
+  TComSPS* getActiveSPS(){ return m_spsMap.getPS(m_activeSPSId); };
+  TComPPS* getActivePPS(){ return m_ppsMap.getPS(m_activePPSId); };
+#endif
+protected:
+  
+  ParameterSetMap<TComVPS> m_vpsMap;
+  ParameterSetMap<TComSPS> m_spsMap; 
+  ParameterSetMap<TComPPS> m_ppsMap;
+
+  Int m_activeVPSId;
+#if H_MV
+  Int m_activeSPSId[ MAX_NUM_LAYERS ];
+  Int m_activePPSId[ MAX_NUM_LAYERS ];
+#else
+  Int m_activeSPSId;
+  Int m_activePPSId;
+#endif
+
+#endif
 };
 

branches/HTM-8.0-dev0/source/Lib/TLibCommon/TComYuv.cpp

@@ -110 +110 @@
   {
     ::memcpy( pDst, pSrc, sizeof(Pel)*iWidth);
+
+#if ENC_DEC_TRACE && H_MV_ENC_DEC_TRAC
+    if ( g_traceCopyBack && g_nSymbolCounter >= g_stopAtCounter )
+    { 
+      for ( Int x = 0; x < iWidth; x++)
+      {      
+        std::cout << pSrc[ x ] << " " ; 
+      }
+      std::cout << std::endl;
+    }
+#endif
+
     pDst += iDstStride;
     pSrc += iSrcStride;

branches/HTM-8.0-dev0/source/Lib/TLibCommon/TypeDef.h

@@ -70 +70 @@
 #if H_MV
 #define H_MV_ENC_DEC_TRAC                 1  //< CU/PU level tracking
+#define H_MV5                             1
 #endif
 
@@ -791 +792 @@
   enum ScalabilityType
   {
+#if H_MV5
+#if H_3D
+    DEPTH_ID = 0,    
+#endif    
+    VIEW_ORDER_INDEX  = 1,
+#else
     VIEW_ID  = 0,
 #if H_3D
     DEPTH_ID = 1,    
 #endif    
+#endif
   };
 #endif