source: 3DVCSoftware/branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncCavlc.cpp @ 539

Last change on this file since 539 was 539, checked in by orange, 11 years ago

Integrated QTLPC and added new line mark at the end of TComWedgelet.cpp for MERL

  • Property svn:eol-style set to native
File size: 67.2 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license. 
5 *
6 * Copyright (c) 2010-2013, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     TEncCavlc.cpp
35    \brief    CAVLC encoder class
36*/
37
38#include "../TLibCommon/CommonDef.h"
39#include "TEncCavlc.h"
40#include "SEIwrite.h"
41#include "../TLibCommon/TypeDef.h"
42
43//! \ingroup TLibEncoder
44//! \{
45
46#if ENC_DEC_TRACE
47
48Void  xTraceSPSHeader (TComSPS *pSPS)
49{
50#if H_MV_ENC_DEC_TRAC
51  fprintf( g_hTrace, "=========== Sequence Parameter Set ===========\n" );
52#else
53  fprintf( g_hTrace, "=========== Sequence Parameter Set ID: %d ===========\n", pSPS->getSPSId() );
54#endif
55}
56
57Void  xTracePPSHeader (TComPPS *pPPS)
58{
59#if H_MV_ENC_DEC_TRAC
60  fprintf( g_hTrace, "=========== Picture Parameter Set ===========\n" );
61#else
62  fprintf( g_hTrace, "=========== Picture Parameter Set ID: %d ===========\n", pPPS->getPPSId() );
63#endif
64}
65
66Void  xTraceSliceHeader (TComSlice *pSlice)
67{
68  fprintf( g_hTrace, "=========== Slice ===========\n");
69}
70
71#endif
72
73
74
75// ====================================================================================================================
76// Constructor / destructor / create / destroy
77// ====================================================================================================================
78
79TEncCavlc::TEncCavlc()
80{
81  m_pcBitIf           = NULL;
82  m_uiCoeffCost       = 0;
83}
84
85TEncCavlc::~TEncCavlc()
86{
87}
88
89
90// ====================================================================================================================
91// Public member functions
92// ====================================================================================================================
93
94Void TEncCavlc::resetEntropy()
95{
96}
97
98
99Void TEncCavlc::codeDFFlag(UInt uiCode, const Char *pSymbolName)
100{
101  WRITE_FLAG(uiCode, pSymbolName);
102}
103Void TEncCavlc::codeDFSvlc(Int iCode, const Char *pSymbolName)
104{
105  WRITE_SVLC(iCode, pSymbolName);
106}
107
108Void TEncCavlc::codeShortTermRefPicSet( TComSPS* pcSPS, TComReferencePictureSet* rps, Bool calledFromSliceHeader, Int idx)
109{
110#if PRINT_RPS_INFO
111  Int lastBits = getNumberOfWrittenBits();
112#endif
113  if (idx > 0)
114  {
115  WRITE_FLAG( rps->getInterRPSPrediction(), "inter_ref_pic_set_prediction_flag" ); // inter_RPS_prediction_flag
116  }
117  if (rps->getInterRPSPrediction())
118  {
119    Int deltaRPS = rps->getDeltaRPS();
120    if(calledFromSliceHeader)
121    {
122      WRITE_UVLC( rps->getDeltaRIdxMinus1(), "delta_idx_minus1" ); // delta index of the Reference Picture Set used for prediction minus 1
123    }
124
125    WRITE_CODE( (deltaRPS >=0 ? 0: 1), 1, "delta_rps_sign" ); //delta_rps_sign
126    WRITE_UVLC( abs(deltaRPS) - 1, "abs_delta_rps_minus1"); // absolute delta RPS minus 1
127
128    for(Int j=0; j < rps->getNumRefIdc(); j++)
129    {
130      Int refIdc = rps->getRefIdc(j);
131      WRITE_CODE( (refIdc==1? 1: 0), 1, "used_by_curr_pic_flag" ); //first bit is "1" if Idc is 1
132      if (refIdc != 1) 
133      {
134        WRITE_CODE( refIdc>>1, 1, "use_delta_flag" ); //second bit is "1" if Idc is 2, "0" otherwise.
135      }
136    }
137  }
138  else
139  {
140    WRITE_UVLC( rps->getNumberOfNegativePictures(), "num_negative_pics" );
141    WRITE_UVLC( rps->getNumberOfPositivePictures(), "num_positive_pics" );
142    Int prev = 0;
143    for(Int j=0 ; j < rps->getNumberOfNegativePictures(); j++)
144    {
145      WRITE_UVLC( prev-rps->getDeltaPOC(j)-1, "delta_poc_s0_minus1" );
146      prev = rps->getDeltaPOC(j);
147      WRITE_FLAG( rps->getUsed(j), "used_by_curr_pic_s0_flag"); 
148    }
149    prev = 0;
150    for(Int j=rps->getNumberOfNegativePictures(); j < rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures(); j++)
151    {
152      WRITE_UVLC( rps->getDeltaPOC(j)-prev-1, "delta_poc_s1_minus1" );
153      prev = rps->getDeltaPOC(j);
154      WRITE_FLAG( rps->getUsed(j), "used_by_curr_pic_s1_flag" ); 
155    }
156  }
157
158#if PRINT_RPS_INFO
159  printf("irps=%d (%2d bits) ", rps->getInterRPSPrediction(), getNumberOfWrittenBits() - lastBits);
160  rps->printDeltaPOC();
161#endif
162}
163
164
165Void TEncCavlc::codePPS( TComPPS* pcPPS )
166{
167#if ENC_DEC_TRACE 
168  xTracePPSHeader (pcPPS);
169#endif
170 
171  WRITE_UVLC( pcPPS->getPPSId(),                             "pps_pic_parameter_set_id" );
172  WRITE_UVLC( pcPPS->getSPSId(),                             "pps_seq_parameter_set_id" );
173  WRITE_FLAG( pcPPS->getDependentSliceSegmentsEnabledFlag()    ? 1 : 0, "dependent_slice_segments_enabled_flag" );
174  WRITE_FLAG( pcPPS->getOutputFlagPresentFlag() ? 1 : 0,     "output_flag_present_flag" );
175  WRITE_CODE( pcPPS->getNumExtraSliceHeaderBits(), 3,        "num_extra_slice_header_bits");
176  WRITE_FLAG( pcPPS->getSignHideFlag(), "sign_data_hiding_flag" );
177  WRITE_FLAG( pcPPS->getCabacInitPresentFlag() ? 1 : 0,   "cabac_init_present_flag" );
178  WRITE_UVLC( pcPPS->getNumRefIdxL0DefaultActive()-1,     "num_ref_idx_l0_default_active_minus1");
179  WRITE_UVLC( pcPPS->getNumRefIdxL1DefaultActive()-1,     "num_ref_idx_l1_default_active_minus1");
180
181  WRITE_SVLC( pcPPS->getPicInitQPMinus26(),                  "init_qp_minus26");
182  WRITE_FLAG( pcPPS->getConstrainedIntraPred() ? 1 : 0,      "constrained_intra_pred_flag" );
183  WRITE_FLAG( pcPPS->getUseTransformSkip() ? 1 : 0,  "transform_skip_enabled_flag" ); 
184  WRITE_FLAG( pcPPS->getUseDQP() ? 1 : 0, "cu_qp_delta_enabled_flag" );
185  if ( pcPPS->getUseDQP() )
186  {
187    WRITE_UVLC( pcPPS->getMaxCuDQPDepth(), "diff_cu_qp_delta_depth" );
188  }
189  WRITE_SVLC( pcPPS->getChromaCbQpOffset(),                   "pps_cb_qp_offset" );
190  WRITE_SVLC( pcPPS->getChromaCrQpOffset(),                   "pps_cr_qp_offset" );
191  WRITE_FLAG( pcPPS->getSliceChromaQpFlag() ? 1 : 0,          "pps_slice_chroma_qp_offsets_present_flag" );
192
193  WRITE_FLAG( pcPPS->getUseWP() ? 1 : 0,  "weighted_pred_flag" );   // Use of Weighting Prediction (P_SLICE)
194  WRITE_FLAG( pcPPS->getWPBiPred() ? 1 : 0, "weighted_bipred_flag" );  // Use of Weighting Bi-Prediction (B_SLICE)
195  WRITE_FLAG( pcPPS->getTransquantBypassEnableFlag() ? 1 : 0, "transquant_bypass_enable_flag" );
196  WRITE_FLAG( pcPPS->getTilesEnabledFlag()             ? 1 : 0, "tiles_enabled_flag" );
197  WRITE_FLAG( pcPPS->getEntropyCodingSyncEnabledFlag() ? 1 : 0, "entropy_coding_sync_enabled_flag" );
198  if( pcPPS->getTilesEnabledFlag() )
199  {
200    WRITE_UVLC( pcPPS->getNumColumnsMinus1(),                                    "num_tile_columns_minus1" );
201    WRITE_UVLC( pcPPS->getNumRowsMinus1(),                                       "num_tile_rows_minus1" );
202    WRITE_FLAG( pcPPS->getUniformSpacingFlag(),                                  "uniform_spacing_flag" );
203    if( pcPPS->getUniformSpacingFlag() == 0 )
204    {
205      for(UInt i=0; i<pcPPS->getNumColumnsMinus1(); i++)
206      {
207        WRITE_UVLC( pcPPS->getColumnWidth(i)-1,                                  "column_width_minus1" );
208      }
209      for(UInt i=0; i<pcPPS->getNumRowsMinus1(); i++)
210      {
211        WRITE_UVLC( pcPPS->getRowHeight(i)-1,                                    "row_height_minus1" );
212      }
213    }
214    if(pcPPS->getNumColumnsMinus1() !=0 || pcPPS->getNumRowsMinus1() !=0)
215    {
216      WRITE_FLAG( pcPPS->getLoopFilterAcrossTilesEnabledFlag()?1 : 0,          "loop_filter_across_tiles_enabled_flag");
217    }
218  }
219  WRITE_FLAG( pcPPS->getLoopFilterAcrossSlicesEnabledFlag()?1 : 0,        "loop_filter_across_slices_enabled_flag");
220  WRITE_FLAG( pcPPS->getDeblockingFilterControlPresentFlag()?1 : 0,       "deblocking_filter_control_present_flag");
221  if(pcPPS->getDeblockingFilterControlPresentFlag())
222  {
223    WRITE_FLAG( pcPPS->getDeblockingFilterOverrideEnabledFlag() ? 1 : 0,  "deblocking_filter_override_enabled_flag" ); 
224    WRITE_FLAG( pcPPS->getPicDisableDeblockingFilterFlag() ? 1 : 0,       "pps_disable_deblocking_filter_flag" );
225    if(!pcPPS->getPicDisableDeblockingFilterFlag())
226    {
227      WRITE_SVLC( pcPPS->getDeblockingFilterBetaOffsetDiv2(),             "pps_beta_offset_div2" );
228      WRITE_SVLC( pcPPS->getDeblockingFilterTcOffsetDiv2(),               "pps_tc_offset_div2" );
229    }
230  }
231  WRITE_FLAG( pcPPS->getScalingListPresentFlag() ? 1 : 0,                          "pps_scaling_list_data_present_flag" ); 
232  if( pcPPS->getScalingListPresentFlag() )
233  {
234#if SCALING_LIST_OUTPUT_RESULT
235    printf("PPS\n");
236#endif
237    codeScalingList( m_pcSlice->getScalingList() );
238  }
239  WRITE_FLAG( pcPPS->getListsModificationPresentFlag(), "lists_modification_present_flag");
240  WRITE_UVLC( pcPPS->getLog2ParallelMergeLevelMinus2(), "log2_parallel_merge_level_minus2");
241  WRITE_FLAG( pcPPS->getSliceHeaderExtensionPresentFlag() ? 1 : 0, "slice_segment_header_extension_present_flag");
242  WRITE_FLAG( 0, "pps_extension_flag" );
243}
244
245Void TEncCavlc::codeVUI( TComVUI *pcVUI, TComSPS* pcSPS )
246{
247#if ENC_DEC_TRACE
248  fprintf( g_hTrace, "----------- vui_parameters -----------\n");
249#endif
250  WRITE_FLAG(pcVUI->getAspectRatioInfoPresentFlag(),            "aspect_ratio_info_present_flag");
251  if (pcVUI->getAspectRatioInfoPresentFlag())
252  {
253    WRITE_CODE(pcVUI->getAspectRatioIdc(), 8,                   "aspect_ratio_idc" );
254    if (pcVUI->getAspectRatioIdc() == 255)
255    {
256      WRITE_CODE(pcVUI->getSarWidth(), 16,                      "sar_width");
257      WRITE_CODE(pcVUI->getSarHeight(), 16,                     "sar_height");
258    }
259  }
260  WRITE_FLAG(pcVUI->getOverscanInfoPresentFlag(),               "overscan_info_present_flag");
261  if (pcVUI->getOverscanInfoPresentFlag())
262  {
263    WRITE_FLAG(pcVUI->getOverscanAppropriateFlag(),             "overscan_appropriate_flag");
264  }
265  WRITE_FLAG(pcVUI->getVideoSignalTypePresentFlag(),            "video_signal_type_present_flag");
266  if (pcVUI->getVideoSignalTypePresentFlag())
267  {
268    WRITE_CODE(pcVUI->getVideoFormat(), 3,                      "video_format");
269    WRITE_FLAG(pcVUI->getVideoFullRangeFlag(),                  "video_full_range_flag");
270    WRITE_FLAG(pcVUI->getColourDescriptionPresentFlag(),        "colour_description_present_flag");
271    if (pcVUI->getColourDescriptionPresentFlag())
272    {
273      WRITE_CODE(pcVUI->getColourPrimaries(), 8,                "colour_primaries");
274      WRITE_CODE(pcVUI->getTransferCharacteristics(), 8,        "transfer_characteristics");
275      WRITE_CODE(pcVUI->getMatrixCoefficients(), 8,             "matrix_coefficients");
276    }
277  }
278
279  WRITE_FLAG(pcVUI->getChromaLocInfoPresentFlag(),              "chroma_loc_info_present_flag");
280  if (pcVUI->getChromaLocInfoPresentFlag())
281  {
282    WRITE_UVLC(pcVUI->getChromaSampleLocTypeTopField(),         "chroma_sample_loc_type_top_field");
283    WRITE_UVLC(pcVUI->getChromaSampleLocTypeBottomField(),      "chroma_sample_loc_type_bottom_field");
284  }
285
286  WRITE_FLAG(pcVUI->getNeutralChromaIndicationFlag(),           "neutral_chroma_indication_flag");
287  WRITE_FLAG(pcVUI->getFieldSeqFlag(),                          "field_seq_flag");
288  WRITE_FLAG(pcVUI->getFrameFieldInfoPresentFlag(),             "frame_field_info_present_flag");
289
290  Window defaultDisplayWindow = pcVUI->getDefaultDisplayWindow();
291  WRITE_FLAG(defaultDisplayWindow.getWindowEnabledFlag(),       "default_display_window_flag");
292  if( defaultDisplayWindow.getWindowEnabledFlag() )
293  {
294    WRITE_UVLC(defaultDisplayWindow.getWindowLeftOffset(),      "def_disp_win_left_offset");
295    WRITE_UVLC(defaultDisplayWindow.getWindowRightOffset(),     "def_disp_win_right_offset");
296    WRITE_UVLC(defaultDisplayWindow.getWindowTopOffset(),       "def_disp_win_top_offset");
297    WRITE_UVLC(defaultDisplayWindow.getWindowBottomOffset(),    "def_disp_win_bottom_offset");
298  }
299  TimingInfo *timingInfo = pcVUI->getTimingInfo();
300  WRITE_FLAG(timingInfo->getTimingInfoPresentFlag(),          "vui_timing_info_present_flag");
301  if(timingInfo->getTimingInfoPresentFlag())
302  {
303    WRITE_CODE(timingInfo->getNumUnitsInTick(), 32,           "vui_num_units_in_tick");
304    WRITE_CODE(timingInfo->getTimeScale(),      32,           "vui_time_scale");
305    WRITE_FLAG(timingInfo->getPocProportionalToTimingFlag(),  "vui_poc_proportional_to_timing_flag");
306    if(timingInfo->getPocProportionalToTimingFlag())
307    {
308      WRITE_UVLC(timingInfo->getNumTicksPocDiffOneMinus1(),   "vui_num_ticks_poc_diff_one_minus1");
309    }
310  WRITE_FLAG(pcVUI->getHrdParametersPresentFlag(),              "hrd_parameters_present_flag");
311  if( pcVUI->getHrdParametersPresentFlag() )
312  {
313    codeHrdParameters(pcVUI->getHrdParameters(), 1, pcSPS->getMaxTLayers() - 1 );
314  }
315  }
316
317  WRITE_FLAG(pcVUI->getBitstreamRestrictionFlag(),              "bitstream_restriction_flag");
318  if (pcVUI->getBitstreamRestrictionFlag())
319  {
320    WRITE_FLAG(pcVUI->getTilesFixedStructureFlag(),             "tiles_fixed_structure_flag");
321#if H_MV
322    if ( pcSPS->getLayerId() > 0 )
323    {
324      WRITE_FLAG( pcVUI->getTileBoundariesAlignedFlag( ) ? 1 : 0 , "tile_boundaries_aligned_flag" );
325    }
326#endif
327    WRITE_FLAG(pcVUI->getMotionVectorsOverPicBoundariesFlag(),  "motion_vectors_over_pic_boundaries_flag");
328    WRITE_FLAG(pcVUI->getRestrictedRefPicListsFlag(),           "restricted_ref_pic_lists_flag");
329    WRITE_UVLC(pcVUI->getMinSpatialSegmentationIdc(),           "min_spatial_segmentation_idc");
330    WRITE_UVLC(pcVUI->getMaxBytesPerPicDenom(),                 "max_bytes_per_pic_denom");
331    WRITE_UVLC(pcVUI->getMaxBitsPerMinCuDenom(),                "max_bits_per_mincu_denom");
332    WRITE_UVLC(pcVUI->getLog2MaxMvLengthHorizontal(),           "log2_max_mv_length_horizontal");
333    WRITE_UVLC(pcVUI->getLog2MaxMvLengthVertical(),             "log2_max_mv_length_vertical");
334  }
335}
336
337Void TEncCavlc::codeHrdParameters( TComHRD *hrd, Bool commonInfPresentFlag, UInt maxNumSubLayersMinus1 )
338{
339  if( commonInfPresentFlag )
340  {
341    WRITE_FLAG( hrd->getNalHrdParametersPresentFlag() ? 1 : 0 ,  "nal_hrd_parameters_present_flag" );
342    WRITE_FLAG( hrd->getVclHrdParametersPresentFlag() ? 1 : 0 ,  "vcl_hrd_parameters_present_flag" );
343    if( hrd->getNalHrdParametersPresentFlag() || hrd->getVclHrdParametersPresentFlag() )
344    {
345      WRITE_FLAG( hrd->getSubPicCpbParamsPresentFlag() ? 1 : 0,  "sub_pic_cpb_params_present_flag" );
346      if( hrd->getSubPicCpbParamsPresentFlag() )
347      {
348        WRITE_CODE( hrd->getTickDivisorMinus2(), 8,              "tick_divisor_minus2" );
349        WRITE_CODE( hrd->getDuCpbRemovalDelayLengthMinus1(), 5,  "du_cpb_removal_delay_length_minus1" );
350        WRITE_FLAG( hrd->getSubPicCpbParamsInPicTimingSEIFlag() ? 1 : 0, "sub_pic_cpb_params_in_pic_timing_sei_flag" );
351        WRITE_CODE( hrd->getDpbOutputDelayDuLengthMinus1(), 5,   "dpb_output_delay_du_length_minus1"  );
352      }
353      WRITE_CODE( hrd->getBitRateScale(), 4,                     "bit_rate_scale" );
354      WRITE_CODE( hrd->getCpbSizeScale(), 4,                     "cpb_size_scale" );
355      if( hrd->getSubPicCpbParamsPresentFlag() )
356      {
357        WRITE_CODE( hrd->getDuCpbSizeScale(), 4,                "du_cpb_size_scale" ); 
358      }
359      WRITE_CODE( hrd->getInitialCpbRemovalDelayLengthMinus1(), 5, "initial_cpb_removal_delay_length_minus1" );
360      WRITE_CODE( hrd->getCpbRemovalDelayLengthMinus1(),        5, "au_cpb_removal_delay_length_minus1" );
361      WRITE_CODE( hrd->getDpbOutputDelayLengthMinus1(),         5, "dpb_output_delay_length_minus1" );
362    }
363  }
364  Int i, j, nalOrVcl;
365  for( i = 0; i <= maxNumSubLayersMinus1; i ++ )
366  {
367    WRITE_FLAG( hrd->getFixedPicRateFlag( i ) ? 1 : 0,          "fixed_pic_rate_general_flag");
368    if( !hrd->getFixedPicRateFlag( i ) )
369    {
370      WRITE_FLAG( hrd->getFixedPicRateWithinCvsFlag( i ) ? 1 : 0, "fixed_pic_rate_within_cvs_flag");
371    }
372    else
373    {
374      hrd->setFixedPicRateWithinCvsFlag( i, true );
375    }
376    if( hrd->getFixedPicRateWithinCvsFlag( i ) )
377    {
378      WRITE_UVLC( hrd->getPicDurationInTcMinus1( i ),           "elemental_duration_in_tc_minus1");
379    }
380    else
381    {
382      WRITE_FLAG( hrd->getLowDelayHrdFlag( i ) ? 1 : 0,           "low_delay_hrd_flag");
383    }
384    if (!hrd->getLowDelayHrdFlag( i ))
385    {
386      WRITE_UVLC( hrd->getCpbCntMinus1( i ),                      "cpb_cnt_minus1");
387    }
388   
389    for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
390    {
391      if( ( ( nalOrVcl == 0 ) && ( hrd->getNalHrdParametersPresentFlag() ) ) ||
392          ( ( nalOrVcl == 1 ) && ( hrd->getVclHrdParametersPresentFlag() ) ) )
393      {
394        for( j = 0; j <= ( hrd->getCpbCntMinus1( i ) ); j ++ )
395        {
396          WRITE_UVLC( hrd->getBitRateValueMinus1( i, j, nalOrVcl ), "bit_rate_value_minus1");
397          WRITE_UVLC( hrd->getCpbSizeValueMinus1( i, j, nalOrVcl ), "cpb_size_value_minus1");
398          if( hrd->getSubPicCpbParamsPresentFlag() )
399          {
400            WRITE_UVLC( hrd->getDuCpbSizeValueMinus1( i, j, nalOrVcl ), "cpb_size_du_value_minus1"); 
401            WRITE_UVLC( hrd->getDuBitRateValueMinus1( i, j, nalOrVcl ), "bit_rate_du_value_minus1");
402          }
403          WRITE_FLAG( hrd->getCbrFlag( i, j, nalOrVcl ) ? 1 : 0, "cbr_flag");
404        }
405      }
406    }
407  }
408}
409
410#if H_3D
411Void TEncCavlc::codeSPS( TComSPS* pcSPS, Int viewIndex, Bool depthFlag )
412#else
413Void TEncCavlc::codeSPS( TComSPS* pcSPS )
414#endif
415{
416#if ENC_DEC_TRACE 
417  xTraceSPSHeader (pcSPS);
418#endif
419  WRITE_CODE( pcSPS->getVPSId (),          4,       "sps_video_parameter_set_id" );
420#if H_MV
421  if ( pcSPS->getLayerId() == 0 )
422  {
423#endif
424  WRITE_CODE( pcSPS->getMaxTLayers() - 1,  3,       "sps_max_sub_layers_minus1" );
425  WRITE_FLAG( pcSPS->getTemporalIdNestingFlag() ? 1 : 0,                             "sps_temporal_id_nesting_flag" );
426  codePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
427#if H_MV
428}
429#endif
430  WRITE_UVLC( pcSPS->getSPSId (),                   "sps_seq_parameter_set_id" );
431  WRITE_UVLC( pcSPS->getChromaFormatIdc (),         "chroma_format_idc" );
432  assert(pcSPS->getChromaFormatIdc () == 1);
433  // in the first version chroma_format_idc can only be equal to 1 (4:2:0)
434  if( pcSPS->getChromaFormatIdc () == 3 )
435  {
436    WRITE_FLAG( 0,                                  "separate_colour_plane_flag");
437  }
438
439  WRITE_UVLC( pcSPS->getPicWidthInLumaSamples (),   "pic_width_in_luma_samples" );
440  WRITE_UVLC( pcSPS->getPicHeightInLumaSamples(),   "pic_height_in_luma_samples" );
441  Window conf = pcSPS->getConformanceWindow();
442
443  WRITE_FLAG( conf.getWindowEnabledFlag(),          "conformance_window_flag" );
444  if (conf.getWindowEnabledFlag())
445  {
446    WRITE_UVLC( conf.getWindowLeftOffset()   / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc() ), "conf_win_left_offset" );
447    WRITE_UVLC( conf.getWindowRightOffset()  / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc() ), "conf_win_right_offset" );
448    WRITE_UVLC( conf.getWindowTopOffset()    / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc() ), "conf_win_top_offset" );
449    WRITE_UVLC( conf.getWindowBottomOffset() / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc() ), "conf_win_bottom_offset" );
450  }
451
452  WRITE_UVLC( pcSPS->getBitDepthY() - 8,             "bit_depth_luma_minus8" );
453  WRITE_UVLC( pcSPS->getBitDepthC() - 8,             "bit_depth_chroma_minus8" );
454
455  WRITE_UVLC( pcSPS->getBitsForPOC()-4,                 "log2_max_pic_order_cnt_lsb_minus4" );
456
457  const Bool subLayerOrderingInfoPresentFlag = 1;
458  WRITE_FLAG(subLayerOrderingInfoPresentFlag,       "sps_sub_layer_ordering_info_present_flag");
459  for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
460  {
461    WRITE_UVLC( pcSPS->getMaxDecPicBuffering(i) - 1,       "sps_max_dec_pic_buffering_minus1[i]" );
462    WRITE_UVLC( pcSPS->getNumReorderPics(i),               "sps_num_reorder_pics[i]" );
463    WRITE_UVLC( pcSPS->getMaxLatencyIncrease(i),           "sps_max_latency_increase_plus1[i]" );
464    if (!subLayerOrderingInfoPresentFlag)
465    {
466      break;
467    }
468  }
469  assert( pcSPS->getMaxCUWidth() == pcSPS->getMaxCUHeight() );
470 
471  WRITE_UVLC( pcSPS->getLog2MinCodingBlockSize() - 3,                                "log2_min_coding_block_size_minus3" );
472  WRITE_UVLC( pcSPS->getLog2DiffMaxMinCodingBlockSize(),                             "log2_diff_max_min_coding_block_size" );
473  WRITE_UVLC( pcSPS->getQuadtreeTULog2MinSize() - 2,                                 "log2_min_transform_block_size_minus2" );
474  WRITE_UVLC( pcSPS->getQuadtreeTULog2MaxSize() - pcSPS->getQuadtreeTULog2MinSize(), "log2_diff_max_min_transform_block_size" );
475  WRITE_UVLC( pcSPS->getQuadtreeTUMaxDepthInter() - 1,                               "max_transform_hierarchy_depth_inter" );
476  WRITE_UVLC( pcSPS->getQuadtreeTUMaxDepthIntra() - 1,                               "max_transform_hierarchy_depth_intra" );
477  WRITE_FLAG( pcSPS->getScalingListFlag() ? 1 : 0,                                   "scaling_list_enabled_flag" ); 
478  if(pcSPS->getScalingListFlag())
479  {
480    WRITE_FLAG( pcSPS->getScalingListPresentFlag() ? 1 : 0,                          "sps_scaling_list_data_present_flag" ); 
481    if(pcSPS->getScalingListPresentFlag())
482    {
483#if SCALING_LIST_OUTPUT_RESULT
484    printf("SPS\n");
485#endif
486      codeScalingList( m_pcSlice->getScalingList() );
487    }
488  }
489  WRITE_FLAG( pcSPS->getUseAMP() ? 1 : 0,                                            "amp_enabled_flag" );
490  WRITE_FLAG( pcSPS->getUseSAO() ? 1 : 0,                                            "sample_adaptive_offset_enabled_flag");
491
492  WRITE_FLAG( pcSPS->getUsePCM() ? 1 : 0,                                            "pcm_enabled_flag");
493  if( pcSPS->getUsePCM() )
494  {
495    WRITE_CODE( pcSPS->getPCMBitDepthLuma() - 1, 4,                                  "pcm_sample_bit_depth_luma_minus1" );
496    WRITE_CODE( pcSPS->getPCMBitDepthChroma() - 1, 4,                                "pcm_sample_bit_depth_chroma_minus1" );
497    WRITE_UVLC( pcSPS->getPCMLog2MinSize() - 3,                                      "log2_min_pcm_luma_coding_block_size_minus3" );
498    WRITE_UVLC( pcSPS->getPCMLog2MaxSize() - pcSPS->getPCMLog2MinSize(),             "log2_diff_max_min_pcm_luma_coding_block_size" );
499    WRITE_FLAG( pcSPS->getPCMFilterDisableFlag()?1 : 0,                              "pcm_loop_filter_disable_flag");
500  }
501
502  assert( pcSPS->getMaxTLayers() > 0 );         
503
504  TComRPSList* rpsList = pcSPS->getRPSList();
505  TComReferencePictureSet*      rps;
506
507  WRITE_UVLC(rpsList->getNumberOfReferencePictureSets(), "num_short_term_ref_pic_sets" );
508  for(Int i=0; i < rpsList->getNumberOfReferencePictureSets(); i++)
509  {
510    rps = rpsList->getReferencePictureSet(i);
511    codeShortTermRefPicSet(pcSPS,rps,false, i);
512  }
513  WRITE_FLAG( pcSPS->getLongTermRefsPresent() ? 1 : 0,         "long_term_ref_pics_present_flag" );
514  if (pcSPS->getLongTermRefsPresent()) 
515  {
516    WRITE_UVLC(pcSPS->getNumLongTermRefPicSPS(), "num_long_term_ref_pic_sps" );
517    for (UInt k = 0; k < pcSPS->getNumLongTermRefPicSPS(); k++)
518    {
519      WRITE_CODE( pcSPS->getLtRefPicPocLsbSps(k), pcSPS->getBitsForPOC(), "lt_ref_pic_poc_lsb_sps");
520      WRITE_FLAG( pcSPS->getUsedByCurrPicLtSPSFlag(k), "used_by_curr_pic_lt_sps_flag");
521    }
522  }
523  WRITE_FLAG( pcSPS->getTMVPFlagsPresent()  ? 1 : 0,           "sps_temporal_mvp_enable_flag" );
524
525  WRITE_FLAG( pcSPS->getUseStrongIntraSmoothing(),             "sps_strong_intra_smoothing_enable_flag" );
526
527  WRITE_FLAG( pcSPS->getVuiParametersPresentFlag(),             "vui_parameters_present_flag" );
528  if (pcSPS->getVuiParametersPresentFlag())
529  {
530      codeVUI(pcSPS->getVuiParameters(), pcSPS);
531  }
532
533#if H_MV
534  WRITE_FLAG( 1, "sps_extension_flag" );
535  WRITE_FLAG( pcSPS->getInterViewMvVertConstraintFlag() ? 1 : 0, "inter_view_mv_vert_constraint_flag" );
536  ////   sps_extension_vui_parameters( )
537  if( pcSPS->getVuiParameters()->getBitstreamRestrictionFlag() )
538  { 
539    WRITE_UVLC( pcSPS->getNumIlpRestrictedRefLayers( ),           "num_ilp_restricted_ref_layers" ); 
540    for( Int i = 0; i < pcSPS->getNumIlpRestrictedRefLayers( ); i++ ) 
541    { 
542      WRITE_UVLC( pcSPS->getMinSpatialSegmentOffsetPlus1( i ),    "min_spatial_segment_offset_plus1" ); 
543      if( pcSPS->getMinSpatialSegmentOffsetPlus1( i ) > 0 ) 
544      { 
545        WRITE_FLAG( pcSPS->getCtuBasedOffsetEnabledFlag( i ),      "ctu_based_offset_enabled_flag[ i ]"); 
546        if( pcSPS->getCtuBasedOffsetEnabledFlag( i ) ) 
547        {
548          WRITE_UVLC( pcSPS->getMinHorizontalCtuOffsetPlus1( i ), "min_horizontal_ctu_offset_plus1[ i ]"); 
549        }
550      } 
551    } 
552  } 
553
554#if H_3D_QTLPC
555  if( depthFlag )
556  {
557    WRITE_FLAG( pcSPS->getUseQTL() ? 1 : 0, "use_qtl_flag");
558    WRITE_FLAG( pcSPS->getUsePC()  ? 1 : 0, "use_pc_flag");
559  }
560#endif
561
562  ////   sps_extension_vui_parameters( ) END
563  WRITE_UVLC( 0, "sps_shvc_reserved_zero_idc" ); 
564#if !H_3D
565  WRITE_FLAG( 0, "sps_extension2_flag" );
566#else
567  WRITE_FLAG( 1, "sps_extension2_flag"  );
568  if (!depthFlag )
569  {
570    WRITE_UVLC( pcSPS->getCamParPrecision(), "cp_precision" );
571    WRITE_FLAG( pcSPS->hasCamParInSliceHeader() ? 1 : 0, "cp_in_slice_header_flag" );
572    if( !pcSPS->hasCamParInSliceHeader() )
573    {
574      for( UInt uiIndex = 0; uiIndex < viewIndex; uiIndex++ )
575      {
576        WRITE_SVLC( pcSPS->getCodedScale    ()[ uiIndex ],                                      "cp_scale" );
577        WRITE_SVLC( pcSPS->getCodedOffset   ()[ uiIndex ],                                      "cp_off" );
578        WRITE_SVLC( pcSPS->getInvCodedScale ()[ uiIndex ] + pcSPS->getCodedScale ()[ uiIndex ], "cp_inv_scale_plus_scale" );
579        WRITE_SVLC( pcSPS->getInvCodedOffset()[ uiIndex ] + pcSPS->getCodedOffset()[ uiIndex ], "cp_inv_off_plus_off" );
580      }
581    }
582  }
583
584  WRITE_FLAG( 0, "sps_extension3_flag" );
585#endif
586#else
587  WRITE_FLAG( 0, "sps_extension_flag" );
588#endif
589}
590
591Void TEncCavlc::codeVPS( TComVPS* pcVPS )
592{
593  WRITE_CODE( pcVPS->getVPSId(),                    4,        "vps_video_parameter_set_id" );
594  WRITE_CODE( 3,                                    2,        "vps_reserved_three_2bits" );
595#if H_MV
596  WRITE_CODE( pcVPS->getMaxLayers() - 1,            6,        "vps_max_layers_minus1" );
597#else
598  WRITE_CODE( 0,                                    6,        "vps_reserved_zero_6bits" );
599#endif
600  WRITE_CODE( pcVPS->getMaxTLayers() - 1,           3,        "vps_max_sub_layers_minus1" );
601  WRITE_FLAG( pcVPS->getTemporalNestingFlag(),                "vps_temporal_id_nesting_flag" );
602  assert (pcVPS->getMaxTLayers()>1||pcVPS->getTemporalNestingFlag());
603#if H_MV
604  WRITE_CODE( 0xffff,                              16,        "vps_extension_offset" );
605#else
606  WRITE_CODE( 0xffff,                              16,        "vps_reserved_ffff_16bits" );
607#endif
608  codePTL( pcVPS->getPTL(), true, pcVPS->getMaxTLayers() - 1 );
609  const Bool subLayerOrderingInfoPresentFlag = 1;
610  WRITE_FLAG(subLayerOrderingInfoPresentFlag,              "vps_sub_layer_ordering_info_present_flag");
611  for(UInt i=0; i <= pcVPS->getMaxTLayers()-1; i++)
612  {
613    WRITE_UVLC( pcVPS->getMaxDecPicBuffering(i) - 1,       "vps_max_dec_pic_buffering_minus1[i]" );
614    WRITE_UVLC( pcVPS->getNumReorderPics(i),               "vps_num_reorder_pics[i]" );
615    WRITE_UVLC( pcVPS->getMaxLatencyIncrease(i),           "vps_max_latency_increase_plus1[i]" );
616    if (!subLayerOrderingInfoPresentFlag)
617    {
618      break;
619    }
620  }
621
622  assert( pcVPS->getNumHrdParameters() <= MAX_VPS_NUM_HRD_PARAMETERS );
623#if H_MV
624  assert( pcVPS->getVpsMaxLayerId() < MAX_VPS_NUH_LAYER_ID_PLUS1 );
625  WRITE_CODE( pcVPS->getVpsMaxLayerId(), 6,                 "vps_max_layer_id" ); 
626 
627  WRITE_UVLC( pcVPS->getVpsNumLayerSetsMinus1(),  "vps_max_num_layer_sets_minus1" );
628  for( UInt opsIdx = 1; opsIdx <= pcVPS->getVpsNumLayerSetsMinus1(); opsIdx ++ )
629  {
630    // Operation point set
631    for( UInt i = 0; i <= pcVPS->getVpsMaxLayerId(); i ++ )
632    {
633#else
634  assert( pcVPS->getMaxNuhReservedZeroLayerId() < MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1 );
635  WRITE_CODE( pcVPS->getMaxNuhReservedZeroLayerId(), 6,     "vps_max_nuh_reserved_zero_layer_id" );
636  pcVPS->setMaxOpSets(1);
637  WRITE_UVLC( pcVPS->getMaxOpSets() - 1,                    "vps_max_op_sets_minus1" );
638  for( UInt opsIdx = 1; opsIdx <= ( pcVPS->getMaxOpSets() - 1 ); opsIdx ++ )
639  {
640    // Operation point set
641    for( UInt i = 0; i <= pcVPS->getMaxNuhReservedZeroLayerId(); i ++ )
642    {
643      // Only applicable for version 1
644      pcVPS->setLayerIdIncludedFlag( true, opsIdx, i );
645#endif
646      WRITE_FLAG( pcVPS->getLayerIdIncludedFlag( opsIdx, i ) ? 1 : 0, "layer_id_included_flag[opsIdx][i]" );
647    }
648  }
649  TimingInfo *timingInfo = pcVPS->getTimingInfo();
650  WRITE_FLAG(timingInfo->getTimingInfoPresentFlag(),          "vps_timing_info_present_flag");
651  if(timingInfo->getTimingInfoPresentFlag())
652  {
653    WRITE_CODE(timingInfo->getNumUnitsInTick(), 32,           "vps_num_units_in_tick");
654    WRITE_CODE(timingInfo->getTimeScale(),      32,           "vps_time_scale");
655    WRITE_FLAG(timingInfo->getPocProportionalToTimingFlag(),  "vps_poc_proportional_to_timing_flag");
656    if(timingInfo->getPocProportionalToTimingFlag())
657    {
658      WRITE_UVLC(timingInfo->getNumTicksPocDiffOneMinus1(),   "vps_num_ticks_poc_diff_one_minus1");
659    }
660    pcVPS->setNumHrdParameters( 0 );
661    WRITE_UVLC( pcVPS->getNumHrdParameters(),                 "vps_num_hrd_parameters" );
662
663    if( pcVPS->getNumHrdParameters() > 0 )
664    {
665      pcVPS->createHrdParamBuffer();
666    }
667    for( UInt i = 0; i < pcVPS->getNumHrdParameters(); i ++ )
668    {
669      // Only applicable for version 1
670      pcVPS->setHrdOpSetIdx( 0, i );
671      WRITE_UVLC( pcVPS->getHrdOpSetIdx( i ),                "hrd_op_set_idx" );
672      if( i > 0 )
673      {
674        WRITE_FLAG( pcVPS->getCprmsPresentFlag( i ) ? 1 : 0, "cprms_present_flag[i]" );
675      }
676      codeHrdParameters(pcVPS->getHrdParameters(i), pcVPS->getCprmsPresentFlag( i ), pcVPS->getMaxTLayers() - 1);
677    }
678  }
679#if H_MV
680  WRITE_FLAG( 1,                                             "vps_extension_flag" );
681
682  m_pcBitIf->writeAlignOne();                       
683
684  WRITE_FLAG( pcVPS->getAvcBaseLayerFlag() ? 1 : 0,          "avc_base_layer_flag" );
685  WRITE_FLAG( pcVPS->getSplittingFlag() ? 1 : 0,             "splitting_flag" );
686 
687  for( Int type = 0; type < MAX_NUM_SCALABILITY_TYPES; type++ )
688  {
689    WRITE_FLAG( pcVPS->getScalabilityMask( type ) ? 1 : 0,   "scalability_mask[i]" );
690  }
691
692  for( Int sIdx = 0; sIdx < pcVPS->getNumScalabilityTypes( ) - ( pcVPS->getSplittingFlag() ? 1 : 0 ); sIdx++ )
693  {
694    WRITE_CODE( pcVPS->getDimensionIdLen( sIdx ) - 1 , 3,    "dimension_id_len_minus1[j]");   
695  }
696
697  if ( pcVPS->getSplittingFlag() )
698  { // Ignore old dimension id length
699    pcVPS->setDimensionIdLen( pcVPS->getNumScalabilityTypes( ) - 1 ,pcVPS->inferLastDimsionIdLenMinus1() + 1 );       
700  }   
701
702
703  WRITE_FLAG( pcVPS->getVpsNuhLayerIdPresentFlag() ? 1 : 0,  "vps_nuh_layer_id_present_flag");
704
705  for( Int i = 0; i <= pcVPS->getMaxLayers() - 1; i++ )
706  {
707    if ( pcVPS->getVpsNuhLayerIdPresentFlag() && ( i > 0 ) )
708    {     
709      WRITE_CODE( pcVPS->getLayerIdInNuh( i ), 6,          "layer_id_in_nuh[i]");
710  }
711    else
712    {
713      assert( pcVPS->getLayerIdInNuh( i ) == i ); 
714  }
715
716    assert(  pcVPS->getLayerIdInVps( pcVPS->getLayerIdInNuh( i ) ) == i ); 
717
718    for( Int j = 0; j < pcVPS->getNumScalabilityTypes() ; j++ )
719  {
720      if ( !pcVPS->getSplittingFlag() )
721    {
722        WRITE_CODE( pcVPS->getDimensionId( i, j ), pcVPS->getDimensionIdLen( j ), "dimension_id[i][j]");     
723      }
724      else
725      {
726        assert( pcVPS->getDimensionId( i, j ) ==  pcVPS->inferDimensionId( i, j )  );
727      }
728    }
729  }
730
731  for( Int i = 1; i <= pcVPS->getMaxLayers() - 1; i++ )
732  {
733    for( Int j = 0; j < i; j++ )
734    {
735      WRITE_FLAG( pcVPS->getDirectDependencyFlag( i, j ),    "direct_dependency_flag[i][j]" );
736    }
737  }
738
739  for( Int i = 0; i < pcVPS->getMaxLayers() - 1; i++ )
740  {
741    WRITE_CODE( pcVPS->getMaxTidIlRefPicPlus1( i ), 3,       "max_tid_il_ref_pics_plus1[i]" );
742  }
743
744  WRITE_CODE( pcVPS->getVpsNumberLayerSetsMinus1( )    , 10,    "vps_number_layer_sets_minus1"      );
745  WRITE_CODE( pcVPS->getVpsNumProfileTierLevelMinus1( ), 6,     "vps_num_profile_tier_level_minus1" );
746
747  for( Int i = 1; i <= pcVPS->getVpsNumProfileTierLevelMinus1(); i++ )
748  {
749    WRITE_FLAG( pcVPS->getVpsProfilePresentFlag( i ) ? 1 : 0, "vps_profile_present_flag[i]" );
750    if( !pcVPS->getVpsProfilePresentFlag( i ) )
751    {   
752      WRITE_CODE( pcVPS->getProfileRefMinus1( i ), 6, "profile_ref_minus1[i]" );
753    }
754    codePTL( pcVPS->getPTL( i ), pcVPS->getVpsProfilePresentFlag( i ), pcVPS->getMaxTLayers() - 1 );
755  }
756
757  Int numOutputLayerSets = pcVPS->getVpsNumberLayerSetsMinus1( ) + 1; 
758
759  WRITE_FLAG( pcVPS->getMoreOutputLayerSetsThanDefaultFlag( ) ? 1 : 0, "more_output_layer_sets_than_default_flag" );
760
761  if ( pcVPS->getMoreOutputLayerSetsThanDefaultFlag( ) )
762  {
763    WRITE_CODE( pcVPS->getNumAddOutputLayerSetsMinus1( )    , 10,    "num_add_output_layer_sets_minus1"      );
764    numOutputLayerSets += ( pcVPS->getNumAddOutputLayerSetsMinus1( ) + 1 ); 
765  }
766
767  if( numOutputLayerSets > 1)
768  {
769    WRITE_FLAG( pcVPS->getDefaultOneTargetOutputLayerFlag( ) ? 1 : 0, "default_one_target_output_layer_flag" );
770  } 
771
772  for( Int i = 1; i < numOutputLayerSets; i++ )
773  {
774    if( i > pcVPS->getVpsNumberLayerSetsMinus1( ) )
775    {     
776      WRITE_UVLC( pcVPS->getOutputLayerSetIdxMinus1( i ),      "output_layer_set_idx_minus1[i]" );
777      for( Int j = 0; j < pcVPS->getNumLayersInIdList( j ) - 1 ; j++ )
778      {
779        WRITE_FLAG( pcVPS->getOutputLayerFlag( i, j) ? 1 : 0, "output_layer_flag" );
780      }     
781    }
782    if ( pcVPS->getProfileLevelTierIdxLen()  > 0 )
783    {     
784      WRITE_CODE( pcVPS->getProfileLevelTierIdx( i ), pcVPS->getProfileLevelTierIdxLen() ,"profile_level_tier_idx[ i ]" );   
785    }
786  }
787
788  WRITE_FLAG( pcVPS->getMaxOneActiveRefLayerFlag( ) ? 1 : 0, "max_one_active_ref_layer_flag" );
789  WRITE_UVLC( pcVPS->getDirectDepTypeLenMinus2 ( ),         "direct_dep_type_len_minus2"); 
790
791    for( Int i = 1; i <= pcVPS->getMaxLayers() - 1; i++ )
792    {
793      for( Int j = 0; j < i; j++ )
794      {
795        if (pcVPS->getDirectDependencyFlag( i, j) )
796        {       
797          assert ( pcVPS->getDirectDependencyType( i, j ) != -1 ); 
798          WRITE_CODE( pcVPS->getDirectDependencyType( i, j ),pcVPS->getDirectDepTypeLenMinus2( ) + 2,  "direct_dependency_type[i][j]" );
799        }
800      }
801    }
802
803    WRITE_FLAG ( 0,                    "vps_shvc_reserved_zero_flag" ); 
804
805#if H_3D_GEN 
806  WRITE_FLAG( 1,                                             "vps_extension2_flag" );
807  m_pcBitIf->writeAlignOne();     
808  for( Int i = 0; i <= pcVPS->getMaxLayers() - 1; i++ )
809  {
810    if (i!= 0)
811    {
812      if ( !( pcVPS->getDepthId( i ) == 1 ) )
813      {
814#if H_3D_IV_MERGE
815        WRITE_FLAG( pcVPS->getIvMvPredFlag         ( i ) ? 1 : 0 , "iv_mv_pred_flag[i]");
816#endif
817#if H_3D_ARP
818        WRITE_FLAG( pcVPS->getUseAdvRP             ( i ) ? 1 : 0,  "iv_res_pred_flag[i]"  );
819#endif
820#if H_3D_NBDV_REF
821        WRITE_FLAG( pcVPS->getDepthRefinementFlag  ( i ) ? 1 : 0 , "depth_refinement_flag[i]");
822#endif
823#if H_3D_VSP
824        WRITE_FLAG( pcVPS->getViewSynthesisPredFlag( i ) ? 1 : 0 , "view_synthesis_pred_flag[i]");
825#endif
826      }         
827      else
828      {
829        WRITE_FLAG( pcVPS->getVpsDepthModesFlag( i ) ? 1 : 0 ,          "vps_depth_modes_flag[i]" );
830        //WRITE_FLAG( pcVPS->getLimQtPredFlag    ( i ) ? 1 : 0 ,          "lim_qt_pred_flag[i]"     );
831#if H_3D_DIM_DLT
832        if( pcVPS->getVpsDepthModesFlag( i ) )
833        {
834          WRITE_FLAG( pcVPS->getUseDLTFlag( i ) ? 1 : 0, "dlt_flag[i]" );
835        }
836        if( pcVPS->getUseDLTFlag( i ) )
837        {
838          // code mapping
839          WRITE_UVLC(pcVPS->getNumDepthValues(i), "num_depth_values_in_dlt[i]");
840          for(Int d=0; d<pcVPS->getNumDepthValues(i); d++)
841          {
842            WRITE_UVLC( pcVPS->idx2DepthValue(i, d), "dlt_depth_value[i][d]" );
843          }
844        }       
845#endif
846      }
847    } 
848  }
849#if H_3D_TMVP
850  WRITE_FLAG( pcVPS->getIvMvScalingFlag( ) ? 1 : 0 ,          "iv_mv_scaling_flag" );
851#endif
852#else
853  WRITE_FLAG( 0,                                             "vps_extension2_flag" );
854#endif
855#else
856  WRITE_FLAG( 0,                     "vps_extension_flag" );
857#endif
858 
859  //future extensions here..
860 
861  return;
862}
863
864Void TEncCavlc::codeSliceHeader         ( TComSlice* pcSlice )
865{
866#if H_MV
867  TComVPS* vps = pcSlice->getVPS(); 
868#endif
869#if ENC_DEC_TRACE 
870  xTraceSliceHeader (pcSlice);
871#endif
872
873  //calculate number of bits required for slice address
874  Int maxSliceSegmentAddress = pcSlice->getPic()->getNumCUsInFrame();
875  Int bitsSliceSegmentAddress = 0;
876  while(maxSliceSegmentAddress>(1<<bitsSliceSegmentAddress)) 
877  {
878    bitsSliceSegmentAddress++;
879  }
880  Int ctuAddress;
881  if (pcSlice->isNextSlice())
882  {
883    // Calculate slice address
884    ctuAddress = (pcSlice->getSliceCurStartCUAddr()/pcSlice->getPic()->getNumPartInCU());
885  }
886  else
887  {
888    // Calculate slice address
889    ctuAddress = (pcSlice->getSliceSegmentCurStartCUAddr()/pcSlice->getPic()->getNumPartInCU());
890  }
891  //write slice address
892  Int sliceSegmentAddress = pcSlice->getPic()->getPicSym()->getCUOrderMap(ctuAddress);
893
894  WRITE_FLAG( sliceSegmentAddress==0, "first_slice_segment_in_pic_flag" );
895  if ( pcSlice->getRapPicFlag() )
896  {
897    WRITE_FLAG( 0, "no_output_of_prior_pics_flag" );
898  }
899  WRITE_UVLC( pcSlice->getPPS()->getPPSId(), "slice_pic_parameter_set_id" );
900  pcSlice->setDependentSliceSegmentFlag(!pcSlice->isNextSlice());
901  if ( pcSlice->getPPS()->getDependentSliceSegmentsEnabledFlag() && (sliceSegmentAddress!=0) )
902  {
903    WRITE_FLAG( pcSlice->getDependentSliceSegmentFlag() ? 1 : 0, "dependent_slice_segment_flag" );
904  }
905  if(sliceSegmentAddress>0)
906  {
907    WRITE_CODE( sliceSegmentAddress, bitsSliceSegmentAddress, "slice_segment_address" );
908  }
909  if ( !pcSlice->getDependentSliceSegmentFlag() )
910  {
911#if H_MV   
912    if ( pcSlice->getPPS()->getNumExtraSliceHeaderBits() > 0 )
913    {
914      WRITE_FLAG( pcSlice->getDiscardableFlag( ) ? 1 : 0 , "discardable_flag" );
915    }
916
917    for (Int i = 1; i < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)   
918#else
919    for (Int i = 0; i < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
920#endif
921    {
922      assert(!!"slice_reserved_undetermined_flag[]");
923      WRITE_FLAG(0, "slice_reserved_undetermined_flag[]");
924    }
925
926    WRITE_UVLC( pcSlice->getSliceType(),       "slice_type" );
927
928    if( pcSlice->getPPS()->getOutputFlagPresentFlag() )
929    {
930      WRITE_FLAG( pcSlice->getPicOutputFlag() ? 1 : 0, "pic_output_flag" );
931    }
932
933    // in the first version chroma_format_idc is equal to one, thus colour_plane_id will not be present
934    assert (pcSlice->getSPS()->getChromaFormatIdc() == 1 );
935    // if( separate_colour_plane_flag  ==  1 )
936    //   colour_plane_id                                      u(2)
937
938    if( !pcSlice->getIdrPicFlag() )
939    {
940      Int picOrderCntLSB = (pcSlice->getPOC()-pcSlice->getLastIDR()+(1<<pcSlice->getSPS()->getBitsForPOC()))%(1<<pcSlice->getSPS()->getBitsForPOC());
941      WRITE_CODE( picOrderCntLSB, pcSlice->getSPS()->getBitsForPOC(), "pic_order_cnt_lsb");
942      TComReferencePictureSet* rps = pcSlice->getRPS();
943     
944#if FIX1071
945      // check for bitstream restriction stating that:
946      // If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
947      // Ideally this process should not be repeated for each slice in a picture
948      if (pcSlice->isIRAP())
949      {
950          for (Int picIdx = 0; picIdx < rps->getNumberOfPictures(); picIdx++)
951          {
952          assert (!rps->getUsed(picIdx));
953          }
954        }
955#endif
956
957      if(pcSlice->getRPSidx() < 0)
958      {
959        WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag");
960        codeShortTermRefPicSet(pcSlice->getSPS(), rps, true, pcSlice->getSPS()->getRPSList()->getNumberOfReferencePictureSets());
961      }
962      else
963      {
964        WRITE_FLAG( 1, "short_term_ref_pic_set_sps_flag");
965        Int numBits = 0;
966        while ((1 << numBits) < pcSlice->getSPS()->getRPSList()->getNumberOfReferencePictureSets())
967        {
968          numBits++;
969        }
970        if (numBits > 0)
971        {
972          WRITE_CODE( pcSlice->getRPSidx(), numBits, "short_term_ref_pic_set_idx" );         
973        }
974      }
975      if(pcSlice->getSPS()->getLongTermRefsPresent())
976      {
977        Int numLtrpInSH = rps->getNumberOfLongtermPictures();
978        Int ltrpInSPS[MAX_NUM_REF_PICS];
979        Int numLtrpInSPS = 0;
980        UInt ltrpIndex;
981        Int counter = 0;
982        for(Int k = rps->getNumberOfPictures()-1; k > rps->getNumberOfPictures()-rps->getNumberOfLongtermPictures()-1; k--) 
983        {
984          if (findMatchingLTRP(pcSlice, &ltrpIndex, rps->getPOC(k), rps->getUsed(k))) 
985          {
986            ltrpInSPS[numLtrpInSPS] = ltrpIndex;
987            numLtrpInSPS++;
988          }
989          else
990          {
991            counter++;
992          }
993        }
994        numLtrpInSH -= numLtrpInSPS;
995
996        Int bitsForLtrpInSPS = 0;
997        while (pcSlice->getSPS()->getNumLongTermRefPicSPS() > (1 << bitsForLtrpInSPS))
998        {
999          bitsForLtrpInSPS++;
1000        }
1001        if (pcSlice->getSPS()->getNumLongTermRefPicSPS() > 0) 
1002        {
1003          WRITE_UVLC( numLtrpInSPS, "num_long_term_sps");
1004        }
1005        WRITE_UVLC( numLtrpInSH, "num_long_term_pics");
1006        // Note that the LSBs of the LT ref. pic. POCs must be sorted before.
1007        // Not sorted here because LT ref indices will be used in setRefPicList()
1008        Int prevDeltaMSB = 0, prevLSB = 0;
1009        Int offset = rps->getNumberOfNegativePictures() + rps->getNumberOfPositivePictures();
1010        for(Int i=rps->getNumberOfPictures()-1 ; i > offset-1; i--)
1011        {
1012          if (counter < numLtrpInSPS)
1013          {
1014            if (bitsForLtrpInSPS > 0)
1015            {
1016              WRITE_CODE( ltrpInSPS[counter], bitsForLtrpInSPS, "lt_idx_sps[i]");             
1017            }
1018          }
1019          else 
1020          {
1021            WRITE_CODE( rps->getPocLSBLT(i), pcSlice->getSPS()->getBitsForPOC(), "poc_lsb_lt");
1022            WRITE_FLAG( rps->getUsed(i), "used_by_curr_pic_lt_flag"); 
1023          }
1024          WRITE_FLAG( rps->getDeltaPocMSBPresentFlag(i), "delta_poc_msb_present_flag");
1025
1026          if(rps->getDeltaPocMSBPresentFlag(i))
1027          {
1028            Bool deltaFlag = false;
1029            //  First LTRP from SPS                 ||  First LTRP from SH                              || curr LSB            != prev LSB
1030            if( (i == rps->getNumberOfPictures()-1) || (i == rps->getNumberOfPictures()-1-numLtrpInSPS) || (rps->getPocLSBLT(i) != prevLSB) )
1031            {
1032              deltaFlag = true;
1033            }
1034            if(deltaFlag)
1035            {
1036              WRITE_UVLC( rps->getDeltaPocMSBCycleLT(i), "delta_poc_msb_cycle_lt[i]" );
1037            }
1038            else
1039            {             
1040              Int differenceInDeltaMSB = rps->getDeltaPocMSBCycleLT(i) - prevDeltaMSB;
1041              assert(differenceInDeltaMSB >= 0);
1042              WRITE_UVLC( differenceInDeltaMSB, "delta_poc_msb_cycle_lt[i]" );
1043            }
1044            prevLSB = rps->getPocLSBLT(i);
1045            prevDeltaMSB = rps->getDeltaPocMSBCycleLT(i);
1046          }
1047        }
1048      }
1049      if (pcSlice->getSPS()->getTMVPFlagsPresent())
1050      {
1051        WRITE_FLAG( pcSlice->getEnableTMVPFlag() ? 1 : 0, "slice_temporal_mvp_enable_flag" );
1052      }
1053    }
1054#if H_MV
1055    Int layerIdInVps       = pcSlice->getLayerIdInVps(); 
1056    if( pcSlice->getLayerId() > 0 && vps->getNumDirectRefLayers( layerIdInVps ) > 0 )
1057    {   
1058      WRITE_FLAG( pcSlice->getInterLayerPredEnabledFlag( ) ? 1 : 0 , "inter_layer_pred_enabled_flag" );
1059      if( pcSlice->getInterLayerPredEnabledFlag() && vps->getNumDirectRefLayers( layerIdInVps ) > 1 )
1060      {           
1061        if( !vps->getMaxOneActiveRefLayerFlag()) 
1062        {
1063          WRITE_CODE( pcSlice->getNumInterLayerRefPicsMinus1( ), pcSlice->getNumInterLayerRefPicsMinus1Len( ), "num_inter_layer_ref_pics_minus1" );
1064        }
1065        for( Int i = 0; i < pcSlice->getNumActiveRefLayerPics(); i++ )   
1066        {
1067          WRITE_CODE( pcSlice->getInterLayerPredLayerIdc( i ), pcSlice->getInterLayerPredLayerIdcLen( ), "inter_layer_pred_layer_idc" );
1068        }
1069      } 
1070    }
1071
1072    if( vps->getNumSamplePredRefLayers( layerIdInVps ) > 0  &&  pcSlice->getNumActiveRefLayerPics() > 0 )
1073    {
1074      WRITE_FLAG( pcSlice->getInterLayerSamplePredOnlyFlag( ) ? 1 : 0 , "inter_layer_sample_pred_only_flag" );
1075    }
1076
1077#endif
1078    if(pcSlice->getSPS()->getUseSAO())
1079    {
1080      if (pcSlice->getSPS()->getUseSAO())
1081      {
1082         WRITE_FLAG( pcSlice->getSaoEnabledFlag(), "slice_sao_luma_flag" );
1083         {
1084           SAOParam *saoParam = pcSlice->getPic()->getPicSym()->getSaoParam();
1085          WRITE_FLAG( saoParam->bSaoFlag[1], "slice_sao_chroma_flag" );
1086         }
1087      }
1088    }
1089
1090    //check if numrefidxes match the defaults. If not, override
1091
1092    if (!pcSlice->isIntra())
1093    {
1094      Bool overrideFlag = (pcSlice->getNumRefIdx( REF_PIC_LIST_0 )!=pcSlice->getPPS()->getNumRefIdxL0DefaultActive()||(pcSlice->isInterB()&&pcSlice->getNumRefIdx( REF_PIC_LIST_1 )!=pcSlice->getPPS()->getNumRefIdxL1DefaultActive()));
1095      WRITE_FLAG( overrideFlag ? 1 : 0,                               "num_ref_idx_active_override_flag");
1096      if (overrideFlag) 
1097      {
1098        WRITE_UVLC( pcSlice->getNumRefIdx( REF_PIC_LIST_0 ) - 1,      "num_ref_idx_l0_active_minus1" );
1099        if (pcSlice->isInterB())
1100        {
1101          WRITE_UVLC( pcSlice->getNumRefIdx( REF_PIC_LIST_1 ) - 1,    "num_ref_idx_l1_active_minus1" );
1102        }
1103        else
1104        {
1105          pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
1106        }
1107      }
1108    }
1109    else
1110    {
1111      pcSlice->setNumRefIdx(REF_PIC_LIST_0, 0);
1112      pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
1113    }
1114
1115    if( pcSlice->getPPS()->getListsModificationPresentFlag() && pcSlice->getNumRpsCurrTempList() > 1)
1116    {
1117      TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
1118      if(!pcSlice->isIntra())
1119      {
1120        WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0() ? 1 : 0,       "ref_pic_list_modification_flag_l0" );
1121        if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0())
1122        {
1123          Int numRpsCurrTempList0 = pcSlice->getNumRpsCurrTempList();
1124          if (numRpsCurrTempList0 > 1)
1125          {
1126            Int length = 1;
1127            numRpsCurrTempList0 --;
1128            while ( numRpsCurrTempList0 >>= 1) 
1129            {
1130              length ++;
1131            }
1132            for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_0 ); i++)
1133            {
1134              WRITE_CODE( refPicListModification->getRefPicSetIdxL0(i), length, "list_entry_l0");
1135            }
1136          }
1137        }
1138      }
1139      if(pcSlice->isInterB())
1140      {   
1141        WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1() ? 1 : 0,       "ref_pic_list_modification_flag_l1" );
1142        if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1())
1143        {
1144          Int numRpsCurrTempList1 = pcSlice->getNumRpsCurrTempList();
1145          if ( numRpsCurrTempList1 > 1 )
1146          {
1147            Int length = 1;
1148            numRpsCurrTempList1 --;
1149            while ( numRpsCurrTempList1 >>= 1)
1150            {
1151              length ++;
1152            }
1153            for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_1 ); i++)
1154            {
1155              WRITE_CODE( refPicListModification->getRefPicSetIdxL1(i), length, "list_entry_l1");
1156            }
1157          }
1158        }
1159      }
1160    }
1161   
1162    if (pcSlice->isInterB())
1163    {
1164      WRITE_FLAG( pcSlice->getMvdL1ZeroFlag() ? 1 : 0,   "mvd_l1_zero_flag");
1165    }
1166
1167    if(!pcSlice->isIntra())
1168    {
1169      if (!pcSlice->isIntra() && pcSlice->getPPS()->getCabacInitPresentFlag())
1170      {
1171        SliceType sliceType   = pcSlice->getSliceType();
1172        Int  encCABACTableIdx = pcSlice->getPPS()->getEncCABACTableIdx();
1173        Bool encCabacInitFlag = (sliceType!=encCABACTableIdx && encCABACTableIdx!=I_SLICE) ? true : false;
1174        pcSlice->setCabacInitFlag( encCabacInitFlag );
1175        WRITE_FLAG( encCabacInitFlag?1:0, "cabac_init_flag" );
1176      }
1177    }
1178
1179    if ( pcSlice->getEnableTMVPFlag() )
1180    {
1181#if H_MV
1182      if( pcSlice->getLayerId() > 0 && pcSlice->getNumActiveMotionPredRefLayers() > 0 )
1183      {
1184        WRITE_FLAG( pcSlice->getAltCollocatedIndicationFlag( ) ? 1 : 0 , "alt_collocated_indication_flag" );
1185      }
1186      if( pcSlice->getAltCollocatedIndicationFlag() && pcSlice->getNumActiveMotionPredRefLayers() > 1 ) 
1187      {         
1188        WRITE_UVLC( pcSlice->getCollocatedRefLayerIdx( ), "collocated_ref_layer_idx" );
1189      }     
1190      else 
1191      {
1192#endif
1193      if ( pcSlice->getSliceType() == B_SLICE )
1194      {
1195        WRITE_FLAG( pcSlice->getColFromL0Flag(), "collocated_from_l0_flag" );
1196      }
1197
1198      if ( pcSlice->getSliceType() != I_SLICE &&
1199        ((pcSlice->getColFromL0Flag()==1 && pcSlice->getNumRefIdx(REF_PIC_LIST_0)>1)||
1200        (pcSlice->getColFromL0Flag()==0  && pcSlice->getNumRefIdx(REF_PIC_LIST_1)>1)))
1201      {
1202        WRITE_UVLC( pcSlice->getColRefIdx(), "collocated_ref_idx" );
1203      }
1204    }
1205#if H_MV
1206    }
1207#endif
1208    if ( (pcSlice->getPPS()->getUseWP() && pcSlice->getSliceType()==P_SLICE) || (pcSlice->getPPS()->getWPBiPred() && pcSlice->getSliceType()==B_SLICE) )
1209    {
1210      xCodePredWeightTable( pcSlice );
1211    }
1212#if H_3D_IC
1213    else if( pcSlice->getViewIndex() && ( pcSlice->getSliceType() == P_SLICE || pcSlice->getSliceType() == B_SLICE ) )
1214    {
1215      WRITE_FLAG( pcSlice->getApplyIC() ? 1 : 0, "slice_ic_enable_flag" );
1216      if( pcSlice->getApplyIC() )
1217      {
1218        WRITE_FLAG( pcSlice->getIcSkipParseFlag() ? 1 : 0, "ic_skip_mergeidx0" );
1219      }
1220    }
1221#endif
1222
1223#if H_3D_IV_MERGE
1224    assert(pcSlice->getMaxNumMergeCand()<=MRG_MAX_NUM_CANDS_MEM);
1225#else
1226    assert(pcSlice->getMaxNumMergeCand()<=MRG_MAX_NUM_CANDS);
1227#endif
1228    if (!pcSlice->isIntra())
1229    {
1230#if H_3D_IV_MERGE
1231      Bool ivMvPredFlag = pcSlice->getVPS()->getIvMvPredFlag( pcSlice->getLayerIdInVps() ) ;
1232      WRITE_UVLC( ( ivMvPredFlag ? MRG_MAX_NUM_CANDS_MEM : MRG_MAX_NUM_CANDS ) - pcSlice->getMaxNumMergeCand(), "five_minus_max_num_merge_cand");
1233#else
1234      WRITE_UVLC(MRG_MAX_NUM_CANDS - pcSlice->getMaxNumMergeCand(), "five_minus_max_num_merge_cand");
1235#endif
1236    }
1237    Int iCode = pcSlice->getSliceQp() - ( pcSlice->getPPS()->getPicInitQPMinus26() + 26 );
1238    WRITE_SVLC( iCode, "slice_qp_delta" ); 
1239    if (pcSlice->getPPS()->getSliceChromaQpFlag())
1240    {
1241      iCode = pcSlice->getSliceQpDeltaCb();
1242      WRITE_SVLC( iCode, "slice_qp_delta_cb" );
1243      iCode = pcSlice->getSliceQpDeltaCr();
1244      WRITE_SVLC( iCode, "slice_qp_delta_cr" );
1245    }
1246    if (pcSlice->getPPS()->getDeblockingFilterControlPresentFlag())
1247    {
1248      if (pcSlice->getPPS()->getDeblockingFilterOverrideEnabledFlag() )
1249      {
1250        WRITE_FLAG(pcSlice->getDeblockingFilterOverrideFlag(), "deblocking_filter_override_flag");
1251      }
1252      if (pcSlice->getDeblockingFilterOverrideFlag())
1253      {
1254        WRITE_FLAG(pcSlice->getDeblockingFilterDisable(), "slice_disable_deblocking_filter_flag");
1255        if(!pcSlice->getDeblockingFilterDisable())
1256        {
1257          WRITE_SVLC (pcSlice->getDeblockingFilterBetaOffsetDiv2(), "slice_beta_offset_div2");
1258          WRITE_SVLC (pcSlice->getDeblockingFilterTcOffsetDiv2(),   "slice_tc_offset_div2");
1259        }
1260      }
1261    }
1262
1263    Bool isSAOEnabled = (!pcSlice->getSPS()->getUseSAO())?(false):(pcSlice->getSaoEnabledFlag()||pcSlice->getSaoEnabledFlagChroma());
1264    Bool isDBFEnabled = (!pcSlice->getDeblockingFilterDisable());
1265
1266    if(pcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag() && ( isSAOEnabled || isDBFEnabled ))
1267    {
1268      WRITE_FLAG(pcSlice->getLFCrossSliceBoundaryFlag()?1:0, "slice_loop_filter_across_slices_enabled_flag");
1269    }
1270  }
1271  if(pcSlice->getPPS()->getSliceHeaderExtensionPresentFlag())
1272  {
1273#if !H_3D
1274    WRITE_UVLC(0,"slice_header_extension_length");
1275#else
1276    WRITE_UVLC(0,"slice_header_extension_length"); //<- this element needs to be set to the correct value!!
1277
1278    if( pcSlice->getSPS()->hasCamParInSliceHeader() )
1279    {
1280      for( UInt uiId = 0; uiId < pcSlice->getViewIndex(); uiId++ )
1281      {
1282        WRITE_SVLC( pcSlice->getCodedScale    ()[ uiId ],                                     "cp_scale" );
1283        WRITE_SVLC( pcSlice->getCodedOffset   ()[ uiId ],                                     "cp_off" );
1284        WRITE_SVLC( pcSlice->getInvCodedScale ()[ uiId ] + pcSlice->getCodedScale ()[ uiId ], "cp_inv_scale_plus_scale" );
1285        WRITE_SVLC( pcSlice->getInvCodedOffset()[ uiId ] + pcSlice->getCodedOffset()[ uiId ], "cp_inv_off_plus_off" );
1286      }
1287    }
1288
1289    Bool sliceSegmentHeaderExtension2Flag = false; 
1290    WRITE_FLAG( sliceSegmentHeaderExtension2Flag ? 1 : 0 , "slice_segment_header_extension2_flag" ); 
1291    if ( sliceSegmentHeaderExtension2Flag )
1292    {
1293      WRITE_UVLC(0,"slice_header_extension2_length");
1294    }
1295#endif
1296  }
1297}
1298
1299Void TEncCavlc::codePTL( TComPTL* pcPTL, Bool profilePresentFlag, Int maxNumSubLayersMinus1)
1300{
1301  if(profilePresentFlag)
1302  {
1303    codeProfileTier(pcPTL->getGeneralPTL());    // general_...
1304  }
1305  WRITE_CODE( pcPTL->getGeneralPTL()->getLevelIdc(), 8, "general_level_idc" );
1306
1307  for (Int i = 0; i < maxNumSubLayersMinus1; i++)
1308  {
1309#if !H_MV
1310    if(profilePresentFlag)
1311    {
1312#endif
1313      WRITE_FLAG( pcPTL->getSubLayerProfilePresentFlag(i), "sub_layer_profile_present_flag[i]" );
1314#if !H_MV
1315    }
1316#endif
1317   
1318    WRITE_FLAG( pcPTL->getSubLayerLevelPresentFlag(i),   "sub_layer_level_present_flag[i]" );
1319  }
1320 
1321  if (maxNumSubLayersMinus1 > 0)
1322  {
1323    for (Int i = maxNumSubLayersMinus1; i < 8; i++)
1324    {
1325      WRITE_CODE(0, 2, "reserved_zero_2bits");
1326    }
1327  }
1328 
1329  for(Int i = 0; i < maxNumSubLayersMinus1; i++)
1330  {
1331    if( profilePresentFlag && pcPTL->getSubLayerProfilePresentFlag(i) )
1332    {
1333      codeProfileTier(pcPTL->getSubLayerPTL(i));  // sub_layer_...
1334    }
1335    if( pcPTL->getSubLayerLevelPresentFlag(i) )
1336    {
1337      WRITE_CODE( pcPTL->getSubLayerPTL(i)->getLevelIdc(), 8, "sub_layer_level_idc[i]" );
1338    }
1339  }
1340}
1341Void TEncCavlc::codeProfileTier( ProfileTierLevel* ptl )
1342{
1343  WRITE_CODE( ptl->getProfileSpace(), 2 ,     "XXX_profile_space[]");
1344  WRITE_FLAG( ptl->getTierFlag    (),         "XXX_tier_flag[]"    );
1345  WRITE_CODE( ptl->getProfileIdc  (), 5 ,     "XXX_profile_idc[]"  );   
1346  for(Int j = 0; j < 32; j++)
1347  {
1348    WRITE_FLAG( ptl->getProfileCompatibilityFlag(j), "XXX_profile_compatibility_flag[][j]");   
1349  }
1350
1351  WRITE_FLAG(ptl->getProgressiveSourceFlag(),   "general_progressive_source_flag");
1352  WRITE_FLAG(ptl->getInterlacedSourceFlag(),    "general_interlaced_source_flag");
1353  WRITE_FLAG(ptl->getNonPackedConstraintFlag(), "general_non_packed_constraint_flag");
1354  WRITE_FLAG(ptl->getFrameOnlyConstraintFlag(), "general_frame_only_constraint_flag");
1355 
1356  WRITE_CODE(0 , 16, "XXX_reserved_zero_44bits[0..15]");
1357  WRITE_CODE(0 , 16, "XXX_reserved_zero_44bits[16..31]");
1358  WRITE_CODE(0 , 12, "XXX_reserved_zero_44bits[32..43]");
1359    }
1360
1361/**
1362 - write wavefront substreams sizes for the slice header.
1363 .
1364 \param pcSlice Where we find the substream size information.
1365 */
1366Void  TEncCavlc::codeTilesWPPEntryPoint( TComSlice* pSlice )
1367{
1368  if (!pSlice->getPPS()->getTilesEnabledFlag() && !pSlice->getPPS()->getEntropyCodingSyncEnabledFlag())
1369  {
1370    return;
1371  }
1372  UInt numEntryPointOffsets = 0, offsetLenMinus1 = 0, maxOffset = 0;
1373  Int  numZeroSubstreamsAtStartOfSlice  = 0;
1374  UInt *entryPointOffset = NULL;
1375  if ( pSlice->getPPS()->getTilesEnabledFlag() )
1376  {
1377    numEntryPointOffsets = pSlice->getTileLocationCount();
1378    entryPointOffset     = new UInt[numEntryPointOffsets];
1379    for (Int idx=0; idx<pSlice->getTileLocationCount(); idx++)
1380    {
1381      if ( idx == 0 )
1382      {
1383        entryPointOffset [ idx ] = pSlice->getTileLocation( 0 );
1384      }
1385      else
1386      {
1387        entryPointOffset [ idx ] = pSlice->getTileLocation( idx ) - pSlice->getTileLocation( idx-1 );
1388      }
1389
1390      if ( entryPointOffset[ idx ] > maxOffset )
1391      {
1392        maxOffset = entryPointOffset[ idx ];
1393      }
1394    }
1395  }
1396  else if ( pSlice->getPPS()->getEntropyCodingSyncEnabledFlag() )
1397  {
1398    UInt* pSubstreamSizes               = pSlice->getSubstreamSizes();
1399    Int maxNumParts                       = pSlice->getPic()->getNumPartInCU();
1400    numZeroSubstreamsAtStartOfSlice       = pSlice->getSliceSegmentCurStartCUAddr()/maxNumParts/pSlice->getPic()->getFrameWidthInCU();
1401    Int  numZeroSubstreamsAtEndOfSlice    = pSlice->getPic()->getFrameHeightInCU()-1 - ((pSlice->getSliceSegmentCurEndCUAddr()-1)/maxNumParts/pSlice->getPic()->getFrameWidthInCU());
1402    numEntryPointOffsets                  = pSlice->getPPS()->getNumSubstreams() - numZeroSubstreamsAtStartOfSlice - numZeroSubstreamsAtEndOfSlice - 1;
1403    pSlice->setNumEntryPointOffsets(numEntryPointOffsets);
1404    entryPointOffset           = new UInt[numEntryPointOffsets];
1405    for (Int idx=0; idx<numEntryPointOffsets; idx++)
1406    {
1407      entryPointOffset[ idx ] = ( pSubstreamSizes[ idx+numZeroSubstreamsAtStartOfSlice ] >> 3 ) ;
1408      if ( entryPointOffset[ idx ] > maxOffset )
1409      {
1410        maxOffset = entryPointOffset[ idx ];
1411      }
1412    }
1413  }
1414  // Determine number of bits "offsetLenMinus1+1" required for entry point information
1415  offsetLenMinus1 = 0;
1416  while (maxOffset >= (1u << (offsetLenMinus1 + 1)))
1417  {
1418    offsetLenMinus1++;
1419    assert(offsetLenMinus1 + 1 < 32);   
1420  }
1421
1422  WRITE_UVLC(numEntryPointOffsets, "num_entry_point_offsets");
1423  if (numEntryPointOffsets>0)
1424  {
1425    WRITE_UVLC(offsetLenMinus1, "offset_len_minus1");
1426  }
1427
1428  for (UInt idx=0; idx<numEntryPointOffsets; idx++)
1429  {
1430    WRITE_CODE(entryPointOffset[ idx ]-1, offsetLenMinus1+1, "entry_point_offset_minus1");
1431  }
1432
1433  delete [] entryPointOffset;
1434}
1435
1436Void TEncCavlc::codeTerminatingBit      ( UInt uilsLast )
1437{
1438}
1439
1440Void TEncCavlc::codeSliceFinish ()
1441{
1442}
1443
1444Void TEncCavlc::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1445{
1446  assert(0);
1447}
1448
1449Void TEncCavlc::codePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1450{
1451  assert(0);
1452}
1453
1454Void TEncCavlc::codePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
1455{
1456  assert(0);
1457}
1458
1459Void TEncCavlc::codeMergeFlag    ( TComDataCU* pcCU, UInt uiAbsPartIdx )
1460{
1461  assert(0);
1462}
1463
1464Void TEncCavlc::codeMergeIndex    ( TComDataCU* pcCU, UInt uiAbsPartIdx )
1465{
1466  assert(0);
1467}
1468
1469#if H_3D_ARP
1470Void TEncCavlc::codeARPW( TComDataCU* pcCU, UInt uiAbsPartIdx )
1471{
1472  assert(0);
1473}
1474#endif
1475
1476#if H_3D_IC
1477Void TEncCavlc::codeICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
1478{
1479  assert(0);
1480}
1481#endif
1482
1483Void TEncCavlc::codeInterModeFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiEncMode )
1484{
1485  assert(0);
1486}
1487
1488Void TEncCavlc::codeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
1489{
1490  assert(0);
1491}
1492
1493Void TEncCavlc::codeSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
1494{
1495  assert(0);
1496}
1497
1498Void TEncCavlc::codeSplitFlag   ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1499{
1500  assert(0);
1501}
1502
1503Void TEncCavlc::codeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx )
1504{
1505  assert(0);
1506}
1507
1508Void TEncCavlc::codeQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth )
1509{
1510  assert(0);
1511}
1512
1513Void TEncCavlc::codeQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx )
1514{
1515  assert(0);
1516}
1517
1518Void TEncCavlc::codeQtCbfZero( TComDataCU* pcCU, TextType eType, UInt uiTrDepth )
1519{
1520  assert(0);
1521}
1522Void TEncCavlc::codeQtRootCbfZero( TComDataCU* pcCU )
1523{
1524  assert(0);
1525}
1526
1527Void TEncCavlc::codeTransformSkipFlags (TComDataCU* pcCU, UInt uiAbsPartIdx, UInt width, UInt height, TextType eTType )
1528{
1529  assert(0);
1530}
1531
1532/** Code I_PCM information.
1533 * \param pcCU pointer to CU
1534 * \param uiAbsPartIdx CU index
1535 * \returns Void
1536 */
1537Void TEncCavlc::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
1538{
1539  assert(0);
1540}
1541
1542Void TEncCavlc::codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool isMultiple)
1543{
1544  assert(0);
1545}
1546
1547Void TEncCavlc::codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx )
1548{
1549  assert(0);
1550}
1551
1552Void TEncCavlc::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
1553{
1554  assert(0);
1555}
1556
1557Void TEncCavlc::codeRefFrmIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1558{
1559  assert(0);
1560}
1561
1562Void TEncCavlc::codeMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1563{
1564  assert(0);
1565}
1566
1567Void TEncCavlc::codeDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx )
1568{
1569  Int iDQp  = pcCU->getQP( uiAbsPartIdx ) - pcCU->getRefQP( uiAbsPartIdx );
1570
1571  Int qpBdOffsetY =  pcCU->getSlice()->getSPS()->getQpBDOffsetY();
1572  iDQp = (iDQp + 78 + qpBdOffsetY + (qpBdOffsetY/2)) % (52 + qpBdOffsetY) - 26 - (qpBdOffsetY/2);
1573
1574  xWriteSvlc( iDQp );
1575 
1576  return;
1577}
1578
1579Void TEncCavlc::codeCoeffNxN    ( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType )
1580{
1581  assert(0);
1582}
1583
1584Void TEncCavlc::estBit( estBitsSbacStruct* pcEstBitsCabac, Int width, Int height, TextType eTType )
1585{
1586  // printf("error : no VLC mode support in this version\n");
1587  return;
1588}
1589
1590// ====================================================================================================================
1591// Protected member functions
1592// ====================================================================================================================
1593
1594/** code explicit wp tables
1595 * \param TComSlice* pcSlice
1596 * \returns Void
1597 */
1598Void TEncCavlc::xCodePredWeightTable( TComSlice* pcSlice )
1599{
1600  wpScalingParam  *wp;
1601  Bool            bChroma     = true; // color always present in HEVC ?
1602  Int             iNbRef       = (pcSlice->getSliceType() == B_SLICE ) ? (2) : (1);
1603  Bool            bDenomCoded  = false;
1604  UInt            uiMode = 0;
1605  UInt            uiTotalSignalledWeightFlags = 0;
1606  if ( (pcSlice->getSliceType()==P_SLICE && pcSlice->getPPS()->getUseWP()) || (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPred()) )
1607  {
1608    uiMode = 1; // explicit
1609  }
1610  if(uiMode == 1)
1611  {
1612
1613    for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ ) 
1614    {
1615      RefPicList  eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
1616
1617      for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ ) 
1618      {
1619        pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
1620        if ( !bDenomCoded ) 
1621        {
1622          Int iDeltaDenom;
1623          WRITE_UVLC( wp[0].uiLog2WeightDenom, "luma_log2_weight_denom" );     // ue(v): luma_log2_weight_denom
1624
1625          if( bChroma )
1626          {
1627            iDeltaDenom = (wp[1].uiLog2WeightDenom - wp[0].uiLog2WeightDenom);
1628            WRITE_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" );       // se(v): delta_chroma_log2_weight_denom
1629          }
1630          bDenomCoded = true;
1631        }
1632        WRITE_FLAG( wp[0].bPresentFlag, "luma_weight_lX_flag" );               // u(1): luma_weight_lX_flag
1633        uiTotalSignalledWeightFlags += wp[0].bPresentFlag;
1634      }
1635      if (bChroma) 
1636      {
1637        for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ ) 
1638        {
1639          pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
1640          WRITE_FLAG( wp[1].bPresentFlag, "chroma_weight_lX_flag" );           // u(1): chroma_weight_lX_flag
1641          uiTotalSignalledWeightFlags += 2*wp[1].bPresentFlag;
1642        }
1643      }
1644
1645      for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ ) 
1646      {
1647        pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
1648        if ( wp[0].bPresentFlag ) 
1649        {
1650          Int iDeltaWeight = (wp[0].iWeight - (1<<wp[0].uiLog2WeightDenom));
1651          WRITE_SVLC( iDeltaWeight, "delta_luma_weight_lX" );                  // se(v): delta_luma_weight_lX
1652          WRITE_SVLC( wp[0].iOffset, "luma_offset_lX" );                       // se(v): luma_offset_lX
1653        }
1654
1655        if ( bChroma ) 
1656        {
1657          if ( wp[1].bPresentFlag )
1658          {
1659            for ( Int j=1 ; j<3 ; j++ ) 
1660            {
1661              Int iDeltaWeight = (wp[j].iWeight - (1<<wp[1].uiLog2WeightDenom));
1662              WRITE_SVLC( iDeltaWeight, "delta_chroma_weight_lX" );            // se(v): delta_chroma_weight_lX
1663
1664              Int pred = ( 128 - ( ( 128*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) );
1665              Int iDeltaChroma = (wp[j].iOffset - pred);
1666              WRITE_SVLC( iDeltaChroma, "delta_chroma_offset_lX" );            // se(v): delta_chroma_offset_lX
1667            }
1668          }
1669        }
1670      }
1671    }
1672    assert(uiTotalSignalledWeightFlags<=24);
1673  }
1674}
1675
1676/** code quantization matrix
1677 *  \param scalingList quantization matrix information
1678 */
1679Void TEncCavlc::codeScalingList( TComScalingList* scalingList )
1680{
1681  UInt listId,sizeId;
1682  Bool scalingListPredModeFlag;
1683
1684#if SCALING_LIST_OUTPUT_RESULT
1685  Int startBit;
1686  Int startTotalBit;
1687  startBit = m_pcBitIf->getNumberOfWrittenBits();
1688  startTotalBit = m_pcBitIf->getNumberOfWrittenBits();
1689#endif
1690
1691    //for each size
1692    for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
1693    {
1694      for(listId = 0; listId < g_scalingListNum[sizeId]; listId++)
1695      {
1696#if SCALING_LIST_OUTPUT_RESULT
1697        startBit = m_pcBitIf->getNumberOfWrittenBits();
1698#endif
1699        scalingListPredModeFlag = scalingList->checkPredMode( sizeId, listId );
1700        WRITE_FLAG( scalingListPredModeFlag, "scaling_list_pred_mode_flag" );
1701        if(!scalingListPredModeFlag)// Copy Mode
1702        {
1703          WRITE_UVLC( (Int)listId - (Int)scalingList->getRefMatrixId (sizeId,listId), "scaling_list_pred_matrix_id_delta");
1704        }
1705        else// DPCM Mode
1706        {
1707          xCodeScalingList(scalingList, sizeId, listId);
1708        }
1709#if SCALING_LIST_OUTPUT_RESULT
1710        printf("Matrix [%d][%d] Bit %d\n",sizeId,listId,m_pcBitIf->getNumberOfWrittenBits() - startBit);
1711#endif
1712      }
1713    }
1714#if SCALING_LIST_OUTPUT_RESULT
1715  printf("Total Bit %d\n",m_pcBitIf->getNumberOfWrittenBits()-startTotalBit);
1716#endif
1717  return;
1718}
1719/** code DPCM
1720 * \param scalingList quantization matrix information
1721 * \param sizeIdc size index
1722 * \param listIdc list index
1723 */
1724Void TEncCavlc::xCodeScalingList(TComScalingList* scalingList, UInt sizeId, UInt listId)
1725{
1726  Int coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
1727  UInt* scan  = (sizeId == 0) ? g_auiSigLastScan [ SCAN_DIAG ] [ 1 ] :  g_sigLastScanCG32x32;
1728  Int nextCoef = SCALING_LIST_START_VALUE;
1729  Int data;
1730  Int *src = scalingList->getScalingListAddress(sizeId, listId);
1731    if( sizeId > SCALING_LIST_8x8 )
1732    {
1733      WRITE_SVLC( scalingList->getScalingListDC(sizeId,listId) - 8, "scaling_list_dc_coef_minus8");
1734      nextCoef = scalingList->getScalingListDC(sizeId,listId);
1735    }
1736    for(Int i=0;i<coefNum;i++)
1737    {
1738      data = src[scan[i]] - nextCoef;
1739      nextCoef = src[scan[i]];
1740      if(data > 127)
1741      {
1742        data = data - 256;
1743      }
1744      if(data < -128)
1745      {
1746        data = data + 256;
1747      }
1748
1749      WRITE_SVLC( data,  "scaling_list_delta_coef");
1750    }
1751}
1752Bool TEncCavlc::findMatchingLTRP ( TComSlice* pcSlice, UInt *ltrpsIndex, Int ltrpPOC, Bool usedFlag )
1753{
1754  // Bool state = true, state2 = false;
1755  Int lsb = ltrpPOC % (1<<pcSlice->getSPS()->getBitsForPOC());
1756  for (Int k = 0; k < pcSlice->getSPS()->getNumLongTermRefPicSPS(); k++)
1757  {
1758    if ( (lsb == pcSlice->getSPS()->getLtRefPicPocLsbSps(k)) && (usedFlag == pcSlice->getSPS()->getUsedByCurrPicLtSPSFlag(k)) )
1759    {
1760      *ltrpsIndex = k;
1761      return true;
1762    }
1763  }
1764  return false;
1765}
1766Bool TComScalingList::checkPredMode(UInt sizeId, UInt listId)
1767{
1768  for(Int predListIdx = (Int)listId ; predListIdx >= 0; predListIdx--)
1769  {
1770    if( !memcmp(getScalingListAddress(sizeId,listId),((listId == predListIdx) ?
1771      getScalingListDefaultAddress(sizeId, predListIdx): getScalingListAddress(sizeId, predListIdx)),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])) // check value of matrix
1772     && ((sizeId < SCALING_LIST_16x16) || (getScalingListDC(sizeId,listId) == getScalingListDC(sizeId,predListIdx)))) // check DC value
1773    {
1774      setRefMatrixId(sizeId, listId, predListIdx);
1775      return false;
1776    }
1777  }
1778  return true;
1779}
1780//! \}
Note: See TracBrowser for help on using the repository browser.