Changeset 758 in 3DVCSoftware for trunk/source/Lib/TLibCommon

Timestamp:

3 Jan 2014, 17:43:40 (11 years ago)

Author:

tech

Message:

Merged HTM-9.1-dev0-MediaTek@757. (3D-HEVC HLS)

Location:

trunk/source/Lib/TLibCommon

Files:

• TComPrediction.cpp (modified) (1 diff)
• TComSlice.cpp (modified) (14 diffs)
• TComSlice.h (modified) (11 diffs)
• TypeDef.h (modified) (4 diffs)

trunk/source/Lib/TLibCommon/TComPrediction.cpp ¶

@@ -506 +506 @@
     {
 #if H_3D_DIM_DLT
+#if DLT_DIFF_CODING_IN_PPS
+      segDC1 = pcCU->getSlice()->getPPS()->getDLT()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC1 ) + deltaDC1 );
+      segDC2 = pcCU->getSlice()->getPPS()->getDLT()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC2 ) + deltaDC2 );
+#else
       segDC1 = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC1 ) + deltaDC1 );
       segDC2 = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC2 ) + deltaDC2 );
+#endif
 #else
       segDC1 = ClipY( predDC1 + deltaDC1 );

trunk/source/Lib/TLibCommon/TComSlice.cpp ¶

@@ -782 +782 @@
 Void TComSlice::setCamparaSlice( Int** aaiScale, Int** aaiOffset )
 {  
+#if CAM_HLS_F0136_F0045_F0082
+  if( m_pcVPS->hasCamParInSliceHeader( m_viewIndex ) )
+#else
   if( m_pcSPS->hasCamParInSliceHeader() )
+#endif
   {    
     for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < m_viewIndex; uiBaseViewIndex++ )
@@ -1816 +1820 @@
     m_vpsDepthModesFlag [i] = false;
 #if H_3D_DIM_DLT
+#if !DLT_DIFF_CODING_IN_PPS
     m_bUseDLTFlag         [i] = false;
     
@@ -1832 +1837 @@
     }
 #endif
+#endif
 #if H_3D
     m_ivMvScalingFlag = true; 
@@ -1902 +1908 @@
     if (m_repFormat[ i ] != NULL )      delete m_repFormat[ i ];    
 #if H_3D_DIM_DLT
+#if !DLT_DIFF_CODING_IN_PPS
     if ( m_iDepthValue2Idx[i] != 0 ) 
     {
@@ -1914 +1921 @@
     }
 #endif
-  }
+#endif
+  }
+#endif
+#if CAM_HLS_F0136_F0045_F0082
+  deleteCamPars();
 #endif
 }
 
 #if H_3D_DIM_DLT
+#if !DLT_DIFF_CODING_IN_PPS
   Void TComVPS::setDepthLUTs(Int layerIdInVps, Int* idxToDepthValueTable, Int iNumDepthValues)
   {
@@ -1980 +1992 @@
   }
 #endif
+#endif
 
 #if H_MV
@@ -2066 +2079 @@
   return foundLayerIdinNuh;
 }
+#if CAM_HLS_F0136_F0045_F0082
+Void TComVPS::createCamPars(Int iNumViews)
+{
+  Int i = 0, j = 0;
+
+  m_bCamParPresent = new Bool[ iNumViews ];
+  m_bCamParInSliceHeader = new Bool[ iNumViews ];
+
+  m_aaaiCodedScale = new Int**[ iNumViews ];
+  m_aaaiCodedOffset = new Int**[ iNumViews ];
+  for ( i = 0; i < iNumViews ; i++ )
+  {
+    m_aaaiCodedScale[i] = new Int*[ 2 ];
+    m_aaaiCodedOffset[i] = new Int*[ 2 ];
+    for ( j = 0; j < 2; j++ )
+    {
+      m_aaaiCodedScale[i][j] = new Int[ MAX_NUM_LAYERS ];
+      m_aaaiCodedOffset[i][j] = new Int[ MAX_NUM_LAYERS ];
+      for ( Int k = 0; k < MAX_NUM_LAYERS; k++ )
+      {
+        m_aaaiCodedScale[i][j][k] = 0;
+        m_aaaiCodedOffset[i][j][k] = 0;
+      }
+    }
+  }
+}
+
+Void TComVPS::deleteCamPars()
+{
+  Int iNumViews = getNumViews();
+  Int i = 0, j = 0;
+
+  if ( m_bCamParPresent != NULL )
+  {
+    delete [] m_bCamParPresent;
+  }
+  if ( m_bCamParInSliceHeader != NULL )
+  {
+    delete [] m_bCamParInSliceHeader;
+  }
+
+  if ( m_aaaiCodedScale != NULL )
+  {
+    for ( i = 0; i < iNumViews ; i++ )
+    {
+      for ( j = 0; j < 2; j++ )
+      {
+        delete [] m_aaaiCodedScale[i][j];
+      }
+      delete [] m_aaaiCodedScale[i];
+    }
+    delete [] m_aaaiCodedScale;
+  }
+
+  if ( m_aaaiCodedOffset != NULL )
+  {
+    for ( i = 0; i < iNumViews ; i++ )
+    {
+      for ( j = 0; j < 2; j++ )
+      {
+        delete [] m_aaaiCodedOffset[i][j];
+      }
+      delete [] m_aaaiCodedOffset[i];
+    }
+    delete [] m_aaaiCodedOffset;
+  }
+}
+
+
+Void
+  TComVPS::initCamParaVPS( UInt uiViewIndex, Bool bCamParPresent, UInt uiCamParPrecision, Bool bCamParSlice, Int** aaiScale, Int** aaiOffset )
+{
+  AOT( uiViewIndex != 0 && !bCamParSlice && ( aaiScale == 0 || aaiOffset == 0 ) );  
+
+  m_uiCamParPrecision = ( ( uiViewIndex != 0 )? uiCamParPrecision : 0 );
+  m_bCamParPresent[ uiViewIndex ] = (( uiViewIndex != 0 )? bCamParPresent  : false );
+  m_bCamParInSliceHeader[ uiViewIndex ]  = ( (uiViewIndex != 0)? bCamParSlice  : false );
+
+  if( !m_bCamParInSliceHeader[ uiViewIndex ] )
+  {
+    for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < uiViewIndex; uiBaseViewIndex++ )
+    {
+      m_aaaiCodedScale [ uiViewIndex ][ 0 ][ uiBaseViewIndex ] = aaiScale [ uiBaseViewIndex ][     uiViewIndex ];
+      m_aaaiCodedScale [ uiViewIndex ][ 1 ][ uiBaseViewIndex ] = aaiScale [     uiViewIndex ][ uiBaseViewIndex ];
+      m_aaaiCodedOffset[ uiViewIndex ][ 0 ][ uiBaseViewIndex ] = aaiOffset[ uiBaseViewIndex ][     uiViewIndex ];
+      m_aaaiCodedOffset[ uiViewIndex ][ 1 ][ uiBaseViewIndex ] = aaiOffset[     uiViewIndex ][ uiBaseViewIndex ];
+    }
+  }
+}
+#endif // CAM_HLS_F0136_F0045_F0082
+
 #endif // H_3D
 
@@ -2444 +2548 @@
 , m_ppsInferScalingListFlag(false)
 , m_ppsScalingListRefLayerId(0)
+#if DLT_DIFF_CODING_IN_PPS
+, m_pcDLT(NULL)
+#endif
 #endif
 {
@@ -2463 +2570 @@
   delete m_scalingList;
 }
+
+#if DLT_DIFF_CODING_IN_PPS
+TComDLT::TComDLT()
+: m_bDltPresentFlag(false)
+, m_iNumDepthViews(0)
+, m_uiDepthViewBitDepth(8)
+{
+  m_uiDepthViewBitDepth = g_bitDepthY; 
+
+  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
+  {
+    m_bUseDLTFlag                 [i] = false;
+    m_bInterViewDltPredEnableFlag [i] = false;
+
+    // allocate some memory and initialize with default mapping
+    m_iNumDepthmapValues[i] = ((1 << m_uiDepthViewBitDepth)-1)+1;
+    m_iBitsPerDepthValue[i] = numBitsForValue(m_iNumDepthmapValues[i]);
+
+    m_iDepthValue2Idx[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
+    m_iIdx2DepthValue[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
+
+    //default mapping
+    for (Int d=0; d<m_iNumDepthmapValues[i]; d++)
+    {
+      m_iDepthValue2Idx[i][d] = d;
+      m_iIdx2DepthValue[i][d] = d;
+    }
+  }
+}
+
+TComDLT::~TComDLT()
+{
+  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
+  {
+    if ( m_iDepthValue2Idx[i] != NULL ) 
+    {
+      xFree( m_iDepthValue2Idx[i] );
+      m_iDepthValue2Idx[i] = NULL; 
+    }
+
+    if ( m_iIdx2DepthValue[i] != NULL ) 
+    {
+      xFree( m_iIdx2DepthValue[i] );
+      m_iIdx2DepthValue[i] = NULL; 
+    }
+  }
+}
+
+Void TComDLT::setDepthLUTs(Int layerIdInVps, Int* idxToDepthValueTable, Int iNumDepthValues)
+{
+  if( idxToDepthValueTable == NULL || iNumDepthValues == 0 ) // default mapping only
+    return;
+
+  // copy idx2DepthValue to internal array
+  memcpy(m_iIdx2DepthValue[layerIdInVps], idxToDepthValueTable, iNumDepthValues*sizeof(UInt));
+
+  UInt uiMaxDepthValue = ((1 << g_bitDepthY)-1);
+  for(Int p=0; p<=uiMaxDepthValue; p++)
+  {
+    Int iIdxDown    = 0;
+    Int iIdxUp      = iNumDepthValues-1;
+    Bool bFound     = false;
+
+    // iterate over indices to find lower closest depth
+    Int i = 1;
+    while(!bFound && i<iNumDepthValues)
+    {
+      if( m_iIdx2DepthValue[layerIdInVps][i] > p )
+      {
+        iIdxDown  = i-1;
+        bFound    = true;
+      }
+
+      i++;
+    }
+    // iterate over indices to find upper closest depth
+    i = iNumDepthValues-2;
+    bFound = false;
+    while(!bFound && i>=0)
+    {
+      if( m_iIdx2DepthValue[layerIdInVps][i] < p )
+      {
+        iIdxUp  = i+1;
+        bFound    = true;
+      }
+
+      i--;
+    }
+
+    // assert monotony
+    assert(iIdxDown<=iIdxUp);
+
+    // assign closer depth value/idx
+    if( abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxDown]) < abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxUp]) )
+    {
+      m_iDepthValue2Idx[layerIdInVps][p] = iIdxDown;
+    }
+    else
+    {
+      m_iDepthValue2Idx[layerIdInVps][p] = iIdxUp;
+    }
+
+  }
+
+  // update DLT variables
+  m_iNumDepthmapValues[layerIdInVps] = iNumDepthValues;
+  m_iBitsPerDepthValue[layerIdInVps] = numBitsForValue(m_iNumDepthmapValues[layerIdInVps]);
+}
+
+#if H_3D_DELTA_DLT
+Void TComDLT::getDeltaDLT( Int layerIdInVps, Int* piDLTInRef, UInt uiDLTInRefNum, Int* piDeltaDLTOut, UInt *puiDeltaDLTOutNum )
+{
+  Bool abBM0[ 256 ];
+  Bool abBM1[ 256 ];
+  
+  memset( abBM0, 0, sizeof( abBM0 ));
+  memset( abBM1, 0, sizeof( abBM1 ));
+  
+  // convert reference DLT to bit string
+  for( Int i = 0; i < uiDLTInRefNum; i++ )
+  {
+    abBM0[ piDLTInRef[ i ] ] = true;
+  }
+  // convert internal DLT to bit string
+  for( Int i = 0; i < m_iNumDepthmapValues[ layerIdInVps ]; i++ )
+  {
+    abBM1[ m_iIdx2DepthValue[ layerIdInVps ][ i ] ] = true;
+  }
+  
+  *puiDeltaDLTOutNum = 0;
+  for( Int i = 0; i < 256; i++ )
+  {
+    if( abBM0[ i ] ^ abBM1[ i ] )
+    {
+      piDeltaDLTOut[ *puiDeltaDLTOutNum ] = i;
+      *puiDeltaDLTOutNum = *puiDeltaDLTOutNum + 1;
+    }
+  }
+}
+
+Void TComDLT::setDeltaDLT( Int layerIdInVps, Int* piDLTInRef, UInt uiDLTInRefNum, Int* piDeltaDLTIn, UInt uiDeltaDLTInNum )
+{
+  Bool abBM0[ 256 ];
+  Bool abBM1[ 256 ];
+  
+  memset( abBM0, 0, sizeof( abBM0 ));
+  memset( abBM1, 0, sizeof( abBM1 ));
+  
+  // convert reference DLT to bit string
+  for( Int i = 0; i < uiDLTInRefNum; i++ )
+  {
+    abBM0[ piDLTInRef[ i ] ] = true;
+  }
+  // convert delta DLT to bit string
+  for( Int i = 0; i < uiDeltaDLTInNum; i++ )
+  {
+    abBM1[ piDeltaDLTIn[ i ] ] = true;
+  }
+  
+  Int aiIdx2DepthValue[256];
+  UInt uiNumDepthValues = 0;
+  memset( aiIdx2DepthValue, 0, sizeof( aiIdx2DepthValue ));
+  
+  for( Int i = 0; i < 256; i++ )
+  {
+    if( abBM0[ i ] ^ abBM1[ i ] )
+    {
+      aiIdx2DepthValue[ uiNumDepthValues++ ] = i;
+    }
+  }
+  
+  // update internal tables
+  setDepthLUTs(layerIdInVps, aiIdx2DepthValue, uiNumDepthValues);
+}
+#endif
+
+#endif
 
 #if H_MV
@@ -2525 +2809 @@
 #endif
 #if H_3D
+#if !CAM_HLS_F0136_F0045_F0082
 Void
 TComSPS::initCamParaSPS( UInt uiViewIndex, UInt uiCamParPrecision, Bool bCamParSlice, Int** aaiScale, Int** aaiOffset )
@@ -2546 +2831 @@
   }
 }
+#endif
 #endif
 TComReferencePictureSet::TComReferencePictureSet()
@@ -3257 +3543 @@
   assert( m_depthToDisparityF != NULL ); 
 
+#if CAM_HLS_F0136_F0045_F0082
+  TComVPS* vps = getVPS(); 
+#else
   TComSPS* sps = getSPS(); 
-
+#endif
+
+#if CAM_HLS_F0136_F0045_F0082
+  Int log2Div = g_bitDepthY - 1 + vps->getCamParPrecision();
+  Int viewIndex = getViewIndex();
+
+  Bool camParaSH = vps->hasCamParInSliceHeader( viewIndex );
+
+  Int* codScale     = camParaSH ? m_aaiCodedScale [ 0 ] : vps->getCodedScale    ( viewIndex ); 
+  Int* codOffset    = camParaSH ? m_aaiCodedOffset[ 0 ] : vps->getCodedOffset   ( viewIndex ); 
+  Int* invCodScale  = camParaSH ? m_aaiCodedScale [ 1 ] : vps->getInvCodedScale ( viewIndex ); 
+  Int* invCodOffset = camParaSH ? m_aaiCodedOffset[ 1 ] : vps->getInvCodedOffset( viewIndex ); 
+#else
   Int log2Div = g_bitDepthY - 1 + sps->getCamParPrecision();
 
@@ -3267 +3568 @@
   Int* invCodScale  = camParaSH ? m_aaiCodedScale [ 1 ] : sps->getInvCodedScale (); 
   Int* invCodOffset = camParaSH ? m_aaiCodedOffset[ 1 ] : sps->getInvCodedOffset(); 
+#endif
 
   for (Int i = 0; i <= ( getViewIndex() - 1); i++)
@@ -3707 +4009 @@
   // It is a requirement of bitstream conformance that bitstream partition with index j shall not include 
   // direct or indirect reference layers of any layers in bitstream partition i for any values of i and j 
-  // in the range of 0 to num_bitstream_partitions[ h ] – 1, inclusive, such that i is less than j.
+  // in the range of 0 to num_bitstream_partitions[ h ] ?1, inclusive, such that i is less than j.
 
   for ( Int partJ = 0; partJ < getNumBitstreamPartitions( h ); partJ++ )

trunk/source/Lib/TLibCommon/TComSlice.h ¶

@@ -849 +849 @@
 #endif
   Bool        m_vpsDepthModesFlag        [MAX_NUM_LAYERS   ];
+
 #if H_3D_DIM_DLT
+#if !DLT_DIFF_CODING_IN_PPS
   Bool        m_bUseDLTFlag              [MAX_NUM_LAYERS   ];
   
@@ -857 +859 @@
   Int*        m_iIdx2DepthValue          [MAX_NUM_LAYERS   ];
 #endif
+#endif
+
 #if H_3D
+#if CAM_HLS_F0136_F0045_F0082
+  UInt        m_uiCamParPrecision;
+  Bool*       m_bCamParInSliceHeader;
+  Bool*       m_bCamParPresent;
+  Int         ***m_aaaiCodedScale ;
+  Int         ***m_aaaiCodedOffset;
+#endif
   Bool        m_ivMvScalingFlag; 
 #endif
@@ -1035 +1046 @@
 #endif
 
-  Void    setProfileLevelTierIdx( Int outLayerSetIdx, Int val )            { m_profileLevelTierIdx[ outLayerSetIdx  = val ]; } 
+  Void    setProfileLevelTierIdx( Int outLayerSetIdx, Int val )            { m_profileLevelTierIdx[ outLayerSetIdx  = val ]; }
   Int     getProfileLevelTierIdx( Int outLayerSetIdx )                     { return m_profileLevelTierIdx[ outLayerSetIdx ]; } 
 #if H_MV_6_GEN_0153_28
@@ -1139 +1150 @@
   Void    setARPStepNum( Int layerIdInVps, UInt val )                      { m_uiARPStepNum[layerIdInVps]    = val;     }
 #endif
+#if CAM_HLS_F0136_F0045_F0082
+  Void createCamPars(Int iNumViews);
+  Void deleteCamPars();
+  Void initCamParaVPS      (  UInt uiViewIndex, Bool bCamParPresent = false, UInt uiCamParPrecision = 0, Bool bCamParSlice = false, Int** aaiScale = 0, Int** aaiOffset = 0 );
+  UInt getCamParPrecision    ()  { return m_uiCamParPrecision; }
+  Bool getCamParPresent      ( Int viewIndex )  { return m_bCamParPresent[viewIndex]; }
+  Bool hasCamParInSliceHeader( Int viewIndex )  { return m_bCamParInSliceHeader[viewIndex]; }
+  Void setHasCamParInSliceHeader( Int viewIndex, Bool b )  { m_bCamParInSliceHeader[viewIndex] = b; }
+  Int* getCodedScale         ( Int viewIndex )  { return m_aaaiCodedScale [viewIndex][0]; }
+  Int* getCodedOffset        ( Int viewIndex )  { return m_aaaiCodedOffset[viewIndex][0]; }
+  Int* getInvCodedScale      ( Int viewIndex )  { return m_aaaiCodedScale [viewIndex][1]; }
+  Int* getInvCodedOffset     ( Int viewIndex )  { return m_aaaiCodedOffset[viewIndex][1]; }
+#endif
+
 #if H_3D_IV_MERGE
   Void    setIvMvPredFlag     ( Int layerIdInVps, Bool val )  { m_ivMvPredFlag[ layerIdInVps ] = val; }
@@ -1157 +1182 @@
   Void    setVpsDepthModesFlag( Int layerIdInVps, Bool val )               { m_vpsDepthModesFlag[ layerIdInVps ] = val; }
   Bool    getVpsDepthModesFlag( Int layerIdInVps )                         { return m_vpsDepthModesFlag[ layerIdInVps ]; }
+
 #if H_3D_DIM_DLT
+#if !DLT_DIFF_CODING_IN_PPS
   Bool    getUseDLTFlag      ( Int layerIdInVps )                         { return m_bUseDLTFlag[ layerIdInVps ]; }
   Void    setUseDLTFlag      ( Int layerIdInVps, Bool b ) { m_bUseDLTFlag[ layerIdInVps ]  = b;          }
@@ -1167 +1194 @@
   Void    setDepthLUTs( Int layerIdInVps, Int* idx2DepthValue = NULL, Int iNumDepthValues = 0 );
 #endif
+#endif
 
   Bool    getIvMvScalingFlag   (  )                       { return m_ivMvScalingFlag; }
@@ -1181 +1209 @@
 #endif
 };
+
+#if DLT_DIFF_CODING_IN_PPS
+class TComDLT
+{
+private:
+  Bool        m_bDltPresentFlag;
+  Bool        m_bUseDLTFlag              [ MAX_NUM_LAYERS ];
+  Bool        m_bInterViewDltPredEnableFlag[ MAX_NUM_LAYERS ];
+
+  Int         m_iBitsPerDepthValue       [ MAX_NUM_LAYERS ];
+  Int         m_iNumDepthmapValues       [ MAX_NUM_LAYERS ];
+  Int*        m_iDepthValue2Idx          [ MAX_NUM_LAYERS ];
+  Int*        m_iIdx2DepthValue          [ MAX_NUM_LAYERS ];
+
+  Int         m_iNumDepthViews;
+  UInt        m_uiDepthViewBitDepth;
+
+public:
+  TComDLT();
+  ~TComDLT(); 
+
+  Bool    getDltPresentFlag  ()                           { return m_bDltPresentFlag; }
+  Void    setDltPresentFlag  ( Bool b )                   { m_bDltPresentFlag = b;    }
+
+  Bool    getUseDLTFlag      ( Int layerIdInVps )         { return m_bUseDLTFlag[ layerIdInVps ]; }
+  Void    setUseDLTFlag      ( Int layerIdInVps, Bool b ) { m_bUseDLTFlag[ layerIdInVps ]  = b;   }
+  
+  Bool    getInterViewDltPredEnableFlag( Int layerIdInVps )         { return m_bInterViewDltPredEnableFlag[ layerIdInVps ]; }
+  Void    setInterViewDltPredEnableFlag( Int layerIdInVps, Bool b ) { m_bInterViewDltPredEnableFlag[ layerIdInVps ] = b;    }
+
+  Void    setNumDepthViews   ( Int n )                    { m_iNumDepthViews = n; }
+  Int     getNumDepthViews   ()                           { return m_iNumDepthViews; }
+
+  Void    setDepthViewBitDepth( UInt n )                  { m_uiDepthViewBitDepth = n; }
+  UInt    getDepthViewBitDepth()                          { return m_uiDepthViewBitDepth; }
+
+  Int     getBitsPerDepthValue( Int layerIdInVps )        { return getUseDLTFlag(layerIdInVps)?m_iBitsPerDepthValue[layerIdInVps]:g_bitDepthY; }
+  Int     getNumDepthValues( Int layerIdInVps )           { return getUseDLTFlag(layerIdInVps)?m_iNumDepthmapValues[layerIdInVps]:((1 << g_bitDepthY)-1); }
+  Int     depthValue2idx( Int layerIdInVps, Pel value )   { return getUseDLTFlag(layerIdInVps)?m_iDepthValue2Idx[layerIdInVps][value]:value; }
+  Pel     idx2DepthValue( Int layerIdInVps, UInt uiIdx )  { return getUseDLTFlag(layerIdInVps)?m_iIdx2DepthValue[layerIdInVps][uiIdx]:uiIdx; }
+  Void    setDepthLUTs( Int layerIdInVps, Int* idx2DepthValue = NULL, Int iNumDepthValues = 0 );
+#if H_3D_DELTA_DLT
+  Int*    idx2DepthValue( Int layerIdInVps )  { return m_iIdx2DepthValue[layerIdInVps]; }
+  Void    getDeltaDLT( Int layerIdInVps, Int* piDLTInRef, UInt uiDLTInRefNum, Int* piDeltaDLTOut, UInt *puiDeltaDLTOutNum );
+  Void    setDeltaDLT( Int layerIdInVps, Int* piDLTInRef, UInt uiDLTInRefNum, Int* piDeltaDLTIn, UInt uiDeltaDLTInNum );
+#endif
+};
+#endif
 
 class Window
@@ -1725 +1801 @@
 #endif
 #if H_3D
+#if !CAM_HLS_F0136_F0045_F0082
   Void initCamParaSPS      (  UInt uiViewIndex, UInt uiCamParPrecision = 0, Bool bCamParSlice = false, Int** aaiScale = 0, Int** aaiOffset = 0 );
   UInt getCamParPrecision    ()  { return m_uiCamParPrecision; }
@@ -1735 +1812 @@
   Int* getInvCodedScale      ()  { return m_aaiCodedScale [1]; }
   Int* getInvCodedOffset     ()  { return m_aaiCodedOffset[1]; }
+#endif
 #endif
 #if H_MV
@@ -1840 +1918 @@
   Int  m_ppsScalingListRefLayerId;
 #endif
+
+#if DLT_DIFF_CODING_IN_PPS
+  TComDLT*  m_pcDLT; 
+#endif
+
 public:
   TComPPS();
@@ -1864 +1947 @@
   Void      setMinCuDQPSize     ( UInt u ) { m_uiMinCuDQPSize = u;    }
   UInt      getMinCuDQPSize     ()         { return m_uiMinCuDQPSize; }
+
+#if DLT_DIFF_CODING_IN_PPS
+  Void      setDLT              ( TComDLT* pcDLT ) { m_pcDLT = pcDLT; }
+  TComDLT*  getDLT              ()                 { return m_pcDLT; }
+#endif
 
   Void      setChromaCbQpOffset( Int i ) { m_chromaCbQpOffset = i;    }

trunk/source/Lib/TLibCommon/TypeDef.h ¶

@@ -175 +175 @@
 #endif
 
+#define CAM_HLS_F0136_F0045_F0082         1   // JCT3V-F0136/F0045: view order index based camera parameter signaling 
+                                              // JCT3V-F0082: the cp_in_slice_segment_layer_flag to be view specific and used as a condition of the presence of slice header level camera parameters
+#define CAM_HLS_F0044                     1   // JCT3V-F0044: move camera parameter from slice header extension to slice header
+
+
 // Rate Control
 #define KWU_FIX_URQ                       1
@@ -215 +220 @@
 #define H_3D_DIM_SDC                      1   // Simplified Depth Coding method
 #define H_3D_DIM_DLT                      1   // Depth Lookup Table
+
+#if H_3D_DIM_DLT
+#define DLT_DIFF_CODING_IN_PPS            1   // moving DLT syntax elements from VPS to PPS and differential coding of DLT values
+                                              // JCT3V-F0131, JCT3V-F0139
+#if DLT_DIFF_CODING_IN_PPS
+#define Log2( n ) ( log((double)n) / log(2.0) )
+#endif
+#define H_3D_DELTA_DLT                    1
+#endif
+
 #define H_3D_DIM_ENC                      1   // Depth Intra encoder optimizations, includes:
                                               // HHI_DEPTH_INTRA_SEARCH_RAU_C0160
@@ -262 +277 @@
 #define H_MV_FIX_SKIP_PICTURES                  1  // Fix related to skipping pictures. 
 #define H_MV_6_HRD_O0164_15                     1  // (HRD/O0164/Multilayer HRD) #15 Decision: Adopt, modified as follows: It was suggested to constrain the stalling based on the relative cpb removal times, which must be in decoding order. The "du_based_bpb_sync_flag" is not needed, in view of this. SEI in the highest layer of the layer set or (inclusive "or") VPS VUI is used to carry the parameters (at encoder discretion). SEI in higher layer and SEI in VUI do not need to repeat information available in some lower layer. Shall be after APS SEI and buffering period SEI and before all other SEI of all layers except other HRD related SEI.
-#define H_MV_6_HRD_O0217_13                     1  // (HRD/O0217/Sub-DPB based DPB operations) #13 Decision: Adopt – Specify a separate DPB capacity for each layer – no sharing of capacity across layers – each layer has its own parameters (max pictures, max latency, max reordering). This proposal would specify distinct parameters for each "output layer set" and to change the definition of an operation point to be specific to an output layer set instead of a 'layer set". Decision: Adopted this aspect as well.
+#define H_MV_6_HRD_O0217_13                     1  // (HRD/O0217/Sub-DPB based DPB operations) #13 Decision: Adopt ?Specify a separate DPB capacity for each layer ?no sharing of capacity across layers ?each layer has its own parameters (max pictures, max latency, max reordering). This proposal would specify distinct parameters for each "output layer set" and to change the definition of an operation point to be specific to an output layer set instead of a 'layer set". Decision: Adopted this aspect as well.
 #define H_MV_6_SHVC_O0098_36                    1  // (SHVC/O0098/Scaled ref layer offset) #36 Modify signalling of scaled reference layer offsets to allow signalling of any lower layer, rather than just a direct reference layer, in order to enable alignment of auxiliary pictures. In further JCT-VC and JCT-3V discussion, it was also agreed to use the same offset signalling for MV-HEVC as well as SHVC
 #define H_MV_6_GEN_0153_28                      1  //(Gen/O0153/output highest layer) #28 Add a flag in the VPS to indicate if startup process should output the highest available layer if the target output layer is not available.
@@ -291 +306 @@
 #define H_MV_6_PS_O0096_21                      1  // (PS/O0096/direct_dependency_type gating flag) #21 Add a gating flag in VPS extension to condition the presence of direct dependency type, with a default type signalled, from JCTVC-O0096 
 #define H_MV_6_PS_O0109_22                      1  // (PS/O0109/view_id_len) #22 Modify the VPS extension syntax and semantics to replace view_id_len_minus1 with view_id_len, always signal that syntax element, add a constraint that (1<<view_id_len) >= NumViews, and modify view_id_val semantics to infer value of 0 when not present, from discussion of JCTVC-O0109 
-#define H_MV_6_PS_O0109_23                      1  // (PS/O0109/profile_ref_minus1 constraint) #23 Modify the semantics of profile_ref_minus1[ i ] to replace “shall be less than i” with “shall be less than or equal to i”, from discussion of JCTVC-O0109 
+#define H_MV_6_PS_O0109_23                      1  // (PS/O0109/profile_ref_minus1 constraint) #23 Modify the semantics of profile_ref_minus1[ i ] to replace “shall be less than i?with “shall be less than or equal to i? from discussion of JCTVC-O0109 
 #define H_MV_6_PS_O0109_24                      1  // (PS/O0109/vps_vui_present_flag move) #24 Move the vps_vui_present_flag to precede vps_vui_offset, and make vps_vui_offset conditional on that flag, from JCTVC-O0109
 /////////////////////////////////////////////////////////////////////////////////////////