Changeset 758 in 3DVCSoftware for trunk/source/Lib/TLibEncoder/TEncCavlc.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/TLibEncoder/TEncCavlc.cpp (modified) (6 diffs)

trunk/source/Lib/TLibEncoder/TEncCavlc.cpp

@@ -256 +256 @@
   WRITE_UVLC( pcPPS->getLog2ParallelMergeLevelMinus2(), "log2_parallel_merge_level_minus2");
   WRITE_FLAG( pcPPS->getSliceHeaderExtensionPresentFlag() ? 1 : 0, "slice_segment_header_extension_present_flag");
+
+#if !DLT_DIFF_CODING_IN_PPS
   WRITE_FLAG( 0, "pps_extension_flag" );
-}
+#else
+  WRITE_FLAG( 1, "pps_extension_flag" );
+  codePPSExtension( pcPPS ); 
+  WRITE_FLAG( 0, "pps_extension2_flag" );
+#endif
+}
+
+#if DLT_DIFF_CODING_IN_PPS
+Void  TEncCavlc::codePPSExtension        ( TComPPS* pcPPS )
+{
+  // Assuming that all PPS indirectly refer to the same VPS via different SPS
+  // There is no parsing dependency in decoding DLT in PPS. 
+  // The VPS information passed to decodePPS() is used to arrange the decoded DLT tables to their corresponding layers. 
+  // This is equivalent to the process of 
+  //   Step 1) decoding DLT tables based on the number of depth layers, and
+  //   Step 2) mapping DLT tables to the depth layers
+  // as descripted in the 3D-HEVC WD.
+  TComVPS* pcVPS = pcPPS->getSPS()->getVPS();
+
+  TComDLT* pcDLT = pcPPS->getDLT();
+
+  WRITE_FLAG( pcDLT->getDltPresentFlag() ? 1 : 0, "dlt_present_flag" );
+
+  if ( pcDLT->getDltPresentFlag() )
+  {
+    WRITE_CODE(pcDLT->getNumDepthViews(), 6, "pps_depth_layers_minus1");
+    WRITE_CODE((pcDLT->getDepthViewBitDepth() - 8), 4, "pps_bit_depth_for_depth_views_minus8");
+
+    for( Int i = 0; i <= pcVPS->getMaxLayersMinus1(); i++ )
+    {
+      if ( i != 0 )
+      {
+        if ( pcVPS->getDepthId( i ) == 1 )
+        {
+          WRITE_FLAG( pcDLT->getUseDLTFlag( i ) ? 1 : 0, "dlt_flag[i]" );
+
+          if ( pcDLT->getUseDLTFlag( i ) )
+          {
+            WRITE_FLAG( pcDLT->getInterViewDltPredEnableFlag( i ) ? 1 : 0, "inter_view_dlt_pred_enable_flag[ i ]");
+
+            // ----------------------------- determine whether to use bit-map -----------------------------
+            Bool bDltBitMapRepFlag       = false;
+            UInt uiNumBitsNonBitMap      = 0;
+            UInt uiNumBitsBitMap         = 0;
+
+            UInt uiMaxDiff               = 0;
+            UInt uiMinDiff               = 0xffffffff;
+            UInt uiLengthMinDiff         = 0;
+            UInt uiLengthDltDiffMinusMin = 0;
+
+            UInt* puiDltDiffValues       = NULL;
+            
+            Int aiIdx2DepthValue_coded[256];
+            UInt uiNumDepthValues_coded = 0;
+            
+            uiNumDepthValues_coded = pcDLT->getNumDepthValues(i);
+            for( UInt ui = 0; ui<uiNumDepthValues_coded; ui++ )
+            {
+              aiIdx2DepthValue_coded[ui] = pcDLT->idx2DepthValue(i, ui);
+            }
+            
+#if H_3D_DELTA_DLT
+            if( pcDLT->getInterViewDltPredEnableFlag( i ) )
+            {
+              AOF( pcVPS->getDepthId( 1 ) == 1 );
+              AOF( i > 1 );
+              // assumes ref layer id to be 1
+              Int* piRefDLT = pcDLT->idx2DepthValue( 1 );
+              UInt uiRefNum = pcDLT->getNumDepthValues( 1 );
+              pcDLT->getDeltaDLT(i, piRefDLT, uiRefNum, aiIdx2DepthValue_coded, &uiNumDepthValues_coded);
+            }
+#endif
+
+            if ( NULL == (puiDltDiffValues = (UInt *)calloc(uiNumDepthValues_coded, sizeof(UInt))) )
+            {
+              exit(-1);
+            }
+
+            for (UInt d = 1; d < uiNumDepthValues_coded; d++)
+            {
+              puiDltDiffValues[d] = aiIdx2DepthValue_coded[d] - aiIdx2DepthValue_coded[d-1];
+
+              if ( uiMaxDiff < puiDltDiffValues[d] )
+              {
+                uiMaxDiff = puiDltDiffValues[d];
+              }
+
+              if ( uiMinDiff > puiDltDiffValues[d] )
+              {
+                uiMinDiff = puiDltDiffValues[d];
+              }
+            }
+
+            // counting bits
+            // diff coding branch
+            uiNumBitsNonBitMap += 8;                          // u(v) bits for num_depth_values_in_dlt[layerId] (i.e. num_entry[ layerId ])
+
+            if ( uiNumDepthValues_coded > 1 )
+            {
+              uiNumBitsNonBitMap += 8;                        // u(v) bits for max_diff[ layerId ]
+            }
+
+            if ( uiNumDepthValues_coded > 2 )
+            {
+              uiLengthMinDiff    = (UInt) ceil(Log2(uiMaxDiff + 1));
+              uiNumBitsNonBitMap += uiLengthMinDiff;          // u(v)  bits for min_diff[ layerId ]
+            }
+
+            uiNumBitsNonBitMap += 8;                          // u(v) bits for dlt_depth_value0[ layerId ]
+
+            if (uiMaxDiff > uiMinDiff)
+            {
+              uiLengthDltDiffMinusMin = (UInt) ceil(Log2(uiMaxDiff - uiMinDiff + 1));
+              uiNumBitsNonBitMap += uiLengthDltDiffMinusMin * (uiNumDepthValues_coded - 1);  // u(v) bits for dlt_depth_value_diff_minus_min[ layerId ][ j ]
+            }
+
+            // bit map branch
+            uiNumBitsBitMap = 256;   // uiNumBitsBitMap = 1 << pcDLT->getDepthViewBitDepth(); 
+
+            // determine bDltBitMapFlag
+            bDltBitMapRepFlag = (uiNumBitsBitMap > uiNumBitsNonBitMap) ? false : true;
+
+            // ----------------------------- Actual coding -----------------------------
+            if ( pcDLT->getInterViewDltPredEnableFlag( i ) == false )
+            {
+              WRITE_FLAG( bDltBitMapRepFlag ? 1 : 0, "dlt_bit_map_rep_flag[ layerId ]" );
+            }
+            else
+            {
+              bDltBitMapRepFlag = false;
+            }
+
+            // bit map coding
+            if ( bDltBitMapRepFlag )
+            {
+              UInt uiDltArrayIndex = 0; 
+              for (UInt d=0; d < 256; d++)
+              {
+                if ( d == aiIdx2DepthValue_coded[uiDltArrayIndex] )
+                {                  
+                  WRITE_FLAG(1, "dlt_bit_map_flag[ layerId ][ j ]");
+                  uiDltArrayIndex++;
+                }
+                else
+                {
+                  WRITE_FLAG(0, "dlt_bit_map_flag[ layerId ][ j ]");
+                }
+              }
+            }
+            // Diff Coding
+            else
+            {
+              WRITE_CODE(uiNumDepthValues_coded, 8, "num_depth_values_in_dlt[layerId]");    // num_entry
+
+#if !H_3D_DELTA_DLT
+              if ( pcDLT->getInterViewDltPredEnableFlag( i ) == false )   // Single-view DLT Diff Coding
+#endif
+              {
+                // The condition if( uiNumDepthValues_coded > 0 ) is always true since for Single-view Diff Coding, there is at least one depth value in depth component.
+                if ( uiNumDepthValues_coded > 1 )
+                {
+                  WRITE_CODE(uiMaxDiff, 8, "max_diff[ layerId ]");        // max_diff
+                }
+
+                if ( uiNumDepthValues_coded > 2 )
+                {
+                  WRITE_CODE((uiMinDiff - 1), uiLengthMinDiff, "min_diff_minus1[ layerId ]");     // min_diff_minus1
+                }
+
+                WRITE_CODE(aiIdx2DepthValue_coded[0], 8, "dlt_depth_value0[layerId]");          // entry0
+
+                if (uiMaxDiff > uiMinDiff)
+                {
+                  for (UInt d=1; d < uiNumDepthValues_coded; d++)
+                  {
+                    WRITE_CODE( (puiDltDiffValues[d] - uiMinDiff), uiLengthDltDiffMinusMin, "dlt_depth_value_diff_minus_min[ layerId ][ j ]");    // entry_value_diff_minus_min[ k ]
+                  }
+                }
+              }
+            }
+
+            free(puiDltDiffValues);
+          }
+        }
+      }
+    }
+  }
+}
+#endif
 
 Void TEncCavlc::codeVUI( TComVUI *pcVUI, TComSPS* pcSPS )
@@ -671 +861 @@
 }
 #endif
-  if (!depthFlag )
-  {
-    WRITE_UVLC( pcSPS->getCamParPrecision(), "cp_precision" );
-    WRITE_FLAG( pcSPS->hasCamParInSliceHeader() ? 1 : 0, "cp_in_slice_header_flag" );
-    if( !pcSPS->hasCamParInSliceHeader() )
-    {
-      for( UInt uiIndex = 0; uiIndex < viewIndex; uiIndex++ )
-      {
-        WRITE_SVLC( pcSPS->getCodedScale    ()[ uiIndex ],                                      "cp_scale" );
-        WRITE_SVLC( pcSPS->getCodedOffset   ()[ uiIndex ],                                      "cp_off" );
-        WRITE_SVLC( pcSPS->getInvCodedScale ()[ uiIndex ] + pcSPS->getCodedScale ()[ uiIndex ], "cp_inv_scale_plus_scale" );
-        WRITE_SVLC( pcSPS->getInvCodedOffset()[ uiIndex ] + pcSPS->getCodedOffset()[ uiIndex ], "cp_inv_off_plus_off" );
-      }
-    }
-  }
+#if !CAM_HLS_F0136_F0045_F0082
+if (!depthFlag )
+{
+  WRITE_UVLC( pcSPS->getCamParPrecision(), "cp_precision" );
+  WRITE_FLAG( pcSPS->hasCamParInSliceHeader() ? 1 : 0, "cp_in_slice_header_flag" );
+  if( !pcSPS->hasCamParInSliceHeader() )
+  {
+    for( UInt uiIndex = 0; uiIndex < viewIndex; uiIndex++ )
+    {
+      WRITE_SVLC( pcSPS->getCodedScale    ()[ uiIndex ],                                      "cp_scale" );
+      WRITE_SVLC( pcSPS->getCodedOffset   ()[ uiIndex ],                                      "cp_off" );
+      WRITE_SVLC( pcSPS->getInvCodedScale ()[ uiIndex ] + pcSPS->getCodedScale ()[ uiIndex ], "cp_inv_scale_plus_scale" );
+      WRITE_SVLC( pcSPS->getInvCodedOffset()[ uiIndex ] + pcSPS->getCodedOffset()[ uiIndex ], "cp_inv_off_plus_off" );
+    }
+  }
+}
+#endif
 }
 #endif
@@ -1463 +1655 @@
         //WRITE_FLAG( pcVPS->getLimQtPredFlag    ( i ) ? 1 : 0 ,          "lim_qt_pred_flag[i]"     ); 
 #if H_3D_DIM_DLT
+#if !DLT_DIFF_CODING_IN_PPS
         if( pcVPS->getVpsDepthModesFlag( i ) )
         {
@@ -1475 +1668 @@
             WRITE_UVLC( pcVPS->idx2DepthValue(i, d), "dlt_depth_value[i][d]" );
           }
-        }        
+        }
+#endif
 #endif
 #if H_3D_INTER_SDC
@@ -1483 +1677 @@
     }  
   }
+#if CAM_HLS_F0136_F0045_F0082
+  WRITE_UVLC( pcVPS->getCamParPrecision(), "cp_precision" );
+  for (UInt viewIndex=0; viewIndex<pcVPS->getNumViews(); viewIndex++)
+  {
+    WRITE_FLAG( pcVPS->getCamParPresent(viewIndex) ? 1 : 0, "cp_present_flag[i]" );
+    if ( pcVPS->getCamParPresent(viewIndex) )
+    {
+      WRITE_FLAG( pcVPS->hasCamParInSliceHeader(viewIndex) ? 1 : 0, "cp_in_slice_segment_header_flag[i]" );
+      if ( !pcVPS->hasCamParInSliceHeader(viewIndex) )
+      {
+        for( UInt uiIndex = 0; uiIndex < viewIndex; uiIndex++ )
+        {
+          WRITE_SVLC( pcVPS->getCodedScale    (viewIndex)[ uiIndex ],                                               "vps_cp_scale" );
+          WRITE_SVLC( pcVPS->getCodedOffset   (viewIndex)[ uiIndex ],                                               "vps_cp_off" );
+          WRITE_SVLC( pcVPS->getInvCodedScale (viewIndex)[ uiIndex ] + pcVPS->getCodedScale (viewIndex)[ uiIndex ], "vps_cp_inv_scale_plus_scale" );
+          WRITE_SVLC( pcVPS->getInvCodedOffset(viewIndex)[ uiIndex ] + pcVPS->getCodedOffset(viewIndex)[ uiIndex ], "vps_cp_inv_off_plus_off" );
+        }
+      }
+    }
+  }
+#endif
 #if H_3D_TMVP
   WRITE_FLAG( pcVPS->getIvMvScalingFlag( ) ? 1 : 0 ,          "iv_mv_scaling_flag" );
@@ -1947 +2162 @@
     }
   }
+#if CAM_HLS_F0044
+#if QC_DEPTH_IV_MRG_F0125
+#if CAM_HLS_F0136_F0045_F0082
+  if( pcSlice->getVPS()->hasCamParInSliceHeader( pcSlice->getViewIndex() ) && !pcSlice->getIsDepth() )
+#else
+  if( pcSlice->getSPS()->hasCamParInSliceHeader() && !pcSlice->getIsDepth() )
+#endif
+#else
+  if( pcSlice->getSPS()->hasCamParInSliceHeader() )
+#endif
+  {
+    for( UInt uiId = 0; uiId < pcSlice->getViewIndex(); uiId++ )
+    {
+      WRITE_SVLC( pcSlice->getCodedScale    ()[ uiId ],                                     "cp_scale" );
+      WRITE_SVLC( pcSlice->getCodedOffset   ()[ uiId ],                                     "cp_off" );
+      WRITE_SVLC( pcSlice->getInvCodedScale ()[ uiId ] + pcSlice->getCodedScale ()[ uiId ], "cp_inv_scale_plus_scale" );
+      WRITE_SVLC( pcSlice->getInvCodedOffset()[ uiId ] + pcSlice->getCodedOffset()[ uiId ], "cp_inv_off_plus_off" );
+    }
+  }
+#endif
+
   if(pcSlice->getPPS()->getSliceHeaderExtensionPresentFlag())
   {
-#if !H_3D
+#if !H_3D || CAM_HLS_F0044
     WRITE_UVLC(0,"slice_header_extension_length");
 #else
     WRITE_UVLC(0,"slice_header_extension_length"); //<- this element needs to be set to the correct value!!
-
 #if QC_DEPTH_IV_MRG_F0125
+#if CAM_HLS_F0136_F0045_F0082
+    if( pcSlice->getVPS()->hasCamParInSliceHeader( pcSlice->getViewIndex() ) && !pcSlice->getIsDepth() )
+#else
     if( pcSlice->getSPS()->hasCamParInSliceHeader() && !pcSlice->getIsDepth() )
+#endif
 #else
     if( pcSlice->getSPS()->hasCamParInSliceHeader() )