Changeset 758 in 3DVCSoftware for trunk/source/Lib/TLibCommon/TComSlice.cpp

Timestamp:

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

Author:

tech

Message:

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

File:

• trunk/source/Lib/TLibCommon/TComSlice.cpp (modified) (14 diffs)

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++ )