source: SHVCSoftware/branches/SHM-2.1-dev/source/Lib/TLibEncoder/TEncCavlc.cpp @ 288

Last change on this file since 288 was 288, checked in by qualcomm, 12 years ago

Changes made to signaling of scaled reference layer offsets.

Patch incorporating changes made to signaling of scaled reference layer offsets during SHVC editing. The number of sets of scaled reference layer offsets is signaled. Changes to configuration files also included.

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