Changeset 748 in 3DVCSoftware for branches/HTM-9.1-dev0-ZTE/source/Lib/TLibEncoder/TEncCavlc.cpp

Timestamp:

18 Dec 2013, 09:00:24 (10 years ago)

Author:

zte

Message:

JCT3V-F0131, JCT3V-F0139

File:

• branches/HTM-9.1-dev0-ZTE/source/Lib/TLibEncoder/TEncCavlc.cpp (modified) (3 diffs)

branches/HTM-9.1-dev0-ZTE/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;
+
+            if ( NULL == (puiDltDiffValues = (UInt *)calloc(pcDLT->getNumDepthValues(i), sizeof(UInt))) )
+            {
+              exit(-1);
+            }
+
+            for (UInt d = 1; d < pcDLT->getNumDepthValues(i); d++)
+            {
+              puiDltDiffValues[d] = pcDLT->idx2DepthValue(i, d) - pcDLT->idx2DepthValue(i, (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 ( pcDLT->getNumDepthValues(i) > 1 )
+            {
+              uiNumBitsNonBitMap += 8;                        // u(v) bits for max_diff[ layerId ]
+            }
+
+            if ( pcDLT->getNumDepthValues(i) > 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 * (pcDLT->getNumDepthValues(i) - 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 == pcDLT->idx2DepthValue(i, 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(pcDLT->getNumDepthValues(i), 8, "num_depth_values_in_dlt[layerId]");    // num_entry
+
+              if ( pcDLT->getInterViewDltPredEnableFlag( i ) == false )   // Single-view DLT Diff Coding
+              {
+                // The condition if( pcVPS->getNumDepthValues(i) > 0 ) is always true since for Single-view Diff Coding, there is at least one depth value in depth component. 
+                if ( pcDLT->getNumDepthValues(i) > 1 )
+                {
+                  WRITE_CODE(uiMaxDiff, 8, "max_diff[ layerId ]");        // max_diff
+                }
+
+                if ( pcDLT->getNumDepthValues(i) > 2 )
+                {
+                  WRITE_CODE((uiMinDiff - 1), uiLengthMinDiff, "min_diff_minus1[ layerId ]");     // min_diff_minus1
+                }
+
+                WRITE_CODE(pcDLT->idx2DepthValue(i, 0), 8, "dlt_depth_value0[layerId]");          // entry0
+
+                if (uiMaxDiff > uiMinDiff)
+                {
+                  for (UInt d=1; d < pcDLT->getNumDepthValues(i); 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 )
@@ -1463 +1630 @@
         //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 +1643 @@
             WRITE_UVLC( pcVPS->idx2DepthValue(i, d), "dlt_depth_value[i][d]" );
           }
-        }        
+        }
+#endif
 #endif
 #if H_3D_INTER_SDC