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

Last change on this file since 1353 was 1352, checked in by seregin, 9 years ago

port rev 4430

  • Property svn:eol-style set to native
File size: 103.0 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-2015, 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
42//! \ingroup TLibEncoder
43//! \{
44
45#if ENC_DEC_TRACE
46
47Void  xTraceVPSHeader ()
48{
49  fprintf( g_hTrace, "=========== Video Parameter Set     ===========\n" );
50}
51
52Void  xTraceSPSHeader ()
53{
54  fprintf( g_hTrace, "=========== Sequence Parameter Set  ===========\n" );
55}
56
57Void  xTracePPSHeader ()
58{
59  fprintf( g_hTrace, "=========== Picture Parameter Set  ===========\n");
60}
61
62Void  xTraceSliceHeader ()
63{
64  fprintf( g_hTrace, "=========== Slice ===========\n");
65}
66
67#endif
68
69
70
71// ====================================================================================================================
72// Constructor / destructor / create / destroy
73// ====================================================================================================================
74
75TEncCavlc::TEncCavlc()
76{
77  m_pcBitIf           = NULL;
78}
79
80TEncCavlc::~TEncCavlc()
81{
82}
83
84
85// ====================================================================================================================
86// Public member functions
87// ====================================================================================================================
88
89Void TEncCavlc::resetEntropy(const TComSlice* /*pSlice*/)
90{
91}
92
93
94Void TEncCavlc::codeShortTermRefPicSet( const TComReferencePictureSet* rps, Bool calledFromSliceHeader, Int idx)
95{
96#if PRINT_RPS_INFO
97  Int lastBits = getNumberOfWrittenBits();
98#endif
99  if (idx > 0)
100  {
101  WRITE_FLAG( rps->getInterRPSPrediction(), "inter_ref_pic_set_prediction_flag" ); // inter_RPS_prediction_flag
102  }
103  if (rps->getInterRPSPrediction())
104  {
105    Int deltaRPS = rps->getDeltaRPS();
106    if(calledFromSliceHeader)
107    {
108      WRITE_UVLC( rps->getDeltaRIdxMinus1(), "delta_idx_minus1" ); // delta index of the Reference Picture Set used for prediction minus 1
109    }
110
111    WRITE_CODE( (deltaRPS >=0 ? 0: 1), 1, "delta_rps_sign" ); //delta_rps_sign
112    WRITE_UVLC( abs(deltaRPS) - 1, "abs_delta_rps_minus1"); // absolute delta RPS minus 1
113
114    for(Int j=0; j < rps->getNumRefIdc(); j++)
115    {
116      Int refIdc = rps->getRefIdc(j);
117      WRITE_CODE( (refIdc==1? 1: 0), 1, "used_by_curr_pic_flag" ); //first bit is "1" if Idc is 1
118      if (refIdc != 1)
119      {
120        WRITE_CODE( refIdc>>1, 1, "use_delta_flag" ); //second bit is "1" if Idc is 2, "0" otherwise.
121      }
122    }
123  }
124  else
125  {
126    WRITE_UVLC( rps->getNumberOfNegativePictures(), "num_negative_pics" );
127    WRITE_UVLC( rps->getNumberOfPositivePictures(), "num_positive_pics" );
128    Int prev = 0;
129    for(Int j=0 ; j < rps->getNumberOfNegativePictures(); j++)
130    {
131      WRITE_UVLC( prev-rps->getDeltaPOC(j)-1, "delta_poc_s0_minus1" );
132      prev = rps->getDeltaPOC(j);
133      WRITE_FLAG( rps->getUsed(j), "used_by_curr_pic_s0_flag");
134    }
135    prev = 0;
136    for(Int j=rps->getNumberOfNegativePictures(); j < rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures(); j++)
137    {
138      WRITE_UVLC( rps->getDeltaPOC(j)-prev-1, "delta_poc_s1_minus1" );
139      prev = rps->getDeltaPOC(j);
140      WRITE_FLAG( rps->getUsed(j), "used_by_curr_pic_s1_flag" );
141    }
142  }
143
144#if PRINT_RPS_INFO
145  printf("irps=%d (%2d bits) ", rps->getInterRPSPrediction(), getNumberOfWrittenBits() - lastBits);
146  rps->printDeltaPOC();
147#endif
148}
149
150
151#if CGS_3D_ASYMLUT
152Void TEncCavlc::codePPS( const TComPPS* pcPPS, TEnc3DAsymLUT * pc3DAsymLUT )
153#else
154Void TEncCavlc::codePPS( const TComPPS* pcPPS )
155#endif
156{
157#if ENC_DEC_TRACE
158  xTracePPSHeader ();
159#endif
160
161  WRITE_UVLC( pcPPS->getPPSId(),                             "pps_pic_parameter_set_id" );
162  WRITE_UVLC( pcPPS->getSPSId(),                             "pps_seq_parameter_set_id" );
163  WRITE_FLAG( pcPPS->getDependentSliceSegmentsEnabledFlag()    ? 1 : 0, "dependent_slice_segments_enabled_flag" );
164  WRITE_FLAG( pcPPS->getOutputFlagPresentFlag() ? 1 : 0,     "output_flag_present_flag" );
165  WRITE_CODE( pcPPS->getNumExtraSliceHeaderBits(), 3,        "num_extra_slice_header_bits");
166  WRITE_FLAG( pcPPS->getSignHideFlag(), "sign_data_hiding_flag" );
167  WRITE_FLAG( pcPPS->getCabacInitPresentFlag() ? 1 : 0,   "cabac_init_present_flag" );
168  WRITE_UVLC( pcPPS->getNumRefIdxL0DefaultActive()-1,     "num_ref_idx_l0_default_active_minus1");
169  WRITE_UVLC( pcPPS->getNumRefIdxL1DefaultActive()-1,     "num_ref_idx_l1_default_active_minus1");
170
171  WRITE_SVLC( pcPPS->getPicInitQPMinus26(),                  "init_qp_minus26");
172  WRITE_FLAG( pcPPS->getConstrainedIntraPred() ? 1 : 0,      "constrained_intra_pred_flag" );
173  WRITE_FLAG( pcPPS->getUseTransformSkip() ? 1 : 0,  "transform_skip_enabled_flag" );
174  WRITE_FLAG( pcPPS->getUseDQP() ? 1 : 0, "cu_qp_delta_enabled_flag" );
175  if ( pcPPS->getUseDQP() )
176  {
177    WRITE_UVLC( pcPPS->getMaxCuDQPDepth(), "diff_cu_qp_delta_depth" );
178  }
179
180  WRITE_SVLC( pcPPS->getQpOffset(COMPONENT_Cb), "pps_cb_qp_offset" );
181  WRITE_SVLC( pcPPS->getQpOffset(COMPONENT_Cr), "pps_cr_qp_offset" );
182
183  WRITE_FLAG( pcPPS->getSliceChromaQpFlag() ? 1 : 0,          "pps_slice_chroma_qp_offsets_present_flag" );
184
185  WRITE_FLAG( pcPPS->getUseWP() ? 1 : 0,  "weighted_pred_flag" );   // Use of Weighting Prediction (P_SLICE)
186  WRITE_FLAG( pcPPS->getWPBiPred() ? 1 : 0, "weighted_bipred_flag" );  // Use of Weighting Bi-Prediction (B_SLICE)
187  WRITE_FLAG( pcPPS->getTransquantBypassEnableFlag() ? 1 : 0, "transquant_bypass_enable_flag" );
188  WRITE_FLAG( pcPPS->getTilesEnabledFlag()             ? 1 : 0, "tiles_enabled_flag" );
189  WRITE_FLAG( pcPPS->getEntropyCodingSyncEnabledFlag() ? 1 : 0, "entropy_coding_sync_enabled_flag" );
190  if( pcPPS->getTilesEnabledFlag() )
191  {
192    WRITE_UVLC( pcPPS->getNumTileColumnsMinus1(),                                    "num_tile_columns_minus1" );
193    WRITE_UVLC( pcPPS->getNumTileRowsMinus1(),                                       "num_tile_rows_minus1" );
194    WRITE_FLAG( pcPPS->getTileUniformSpacingFlag(),                                  "uniform_spacing_flag" );
195    if( !pcPPS->getTileUniformSpacingFlag() )
196    {
197      for(UInt i=0; i<pcPPS->getNumTileColumnsMinus1(); i++)
198      {
199        WRITE_UVLC( pcPPS->getTileColumnWidth(i)-1,                                  "column_width_minus1" );
200      }
201      for(UInt i=0; i<pcPPS->getNumTileRowsMinus1(); i++)
202      {
203        WRITE_UVLC( pcPPS->getTileRowHeight(i)-1,                                    "row_height_minus1" );
204      }
205    }
206    if(pcPPS->getNumTileColumnsMinus1() !=0 || pcPPS->getNumTileRowsMinus1() !=0)
207    {
208      WRITE_FLAG( pcPPS->getLoopFilterAcrossTilesEnabledFlag()?1 : 0,          "loop_filter_across_tiles_enabled_flag");
209    }
210  }
211  WRITE_FLAG( pcPPS->getLoopFilterAcrossSlicesEnabledFlag()?1 : 0,        "pps_loop_filter_across_slices_enabled_flag");
212  WRITE_FLAG( pcPPS->getDeblockingFilterControlPresentFlag()?1 : 0,       "deblocking_filter_control_present_flag");
213  if(pcPPS->getDeblockingFilterControlPresentFlag())
214  {
215    WRITE_FLAG( pcPPS->getDeblockingFilterOverrideEnabledFlag() ? 1 : 0,  "deblocking_filter_override_enabled_flag" );
216    WRITE_FLAG( pcPPS->getPicDisableDeblockingFilterFlag() ? 1 : 0,       "pps_disable_deblocking_filter_flag" );
217    if(!pcPPS->getPicDisableDeblockingFilterFlag())
218    {
219      WRITE_SVLC( pcPPS->getDeblockingFilterBetaOffsetDiv2(),             "pps_beta_offset_div2" );
220      WRITE_SVLC( pcPPS->getDeblockingFilterTcOffsetDiv2(),               "pps_tc_offset_div2" );
221    }
222  }
223  WRITE_FLAG( pcPPS->getScalingListPresentFlag() ? 1 : 0,                          "pps_scaling_list_data_present_flag" );
224  if( pcPPS->getScalingListPresentFlag() )
225  {
226    codeScalingList( pcPPS->getScalingList() );
227  }
228  WRITE_FLAG( pcPPS->getListsModificationPresentFlag(), "lists_modification_present_flag");
229  WRITE_UVLC( pcPPS->getLog2ParallelMergeLevelMinus2(), "log2_parallel_merge_level_minus2");
230  WRITE_FLAG( pcPPS->getSliceHeaderExtensionPresentFlag() ? 1 : 0, "slice_segment_header_extension_present_flag");
231
232  Bool pps_extension_present_flag=false;
233  Bool pps_extension_flags[NUM_PPS_EXTENSION_FLAGS]={false};
234
235  pps_extension_flags[PPS_EXT__REXT] = pcPPS->getPpsRangeExtension().settingsDifferFromDefaults(pcPPS->getUseTransformSkip());
236
237  // Other PPS extension flags checked here.
238
239#if SVC_EXTENSION
240  pps_extension_flags[PPS_EXT__MLAYER] = pcPPS->getExtensionFlag() ? 1 : 0;
241#if CGS_3D_ASYMLUT
242  UInt bits = 0;
243#endif
244#endif
245
246  for(Int i=0; i<NUM_PPS_EXTENSION_FLAGS; i++)
247  {
248    pps_extension_present_flag|=pps_extension_flags[i];
249  }
250
251  WRITE_FLAG( (pps_extension_present_flag?1:0), "pps_extension_present_flag" );
252
253  if (pps_extension_present_flag)
254  {
255#if ENC_DEC_TRACE || RExt__DECODER_DEBUG_BIT_STATISTICS
256    static const char *syntaxStrings[]={ "pps_range_extension_flag",
257                                         "pps_multilayer_extension_flag",
258                                         "pps_extension_6bits[0]",
259                                         "pps_extension_6bits[1]",
260                                         "pps_extension_6bits[2]",
261                                         "pps_extension_6bits[3]",
262                                         "pps_extension_6bits[4]",
263                                         "pps_extension_6bits[5]" };
264#endif
265
266    for(Int i=0; i<NUM_PPS_EXTENSION_FLAGS; i++)
267    {
268      WRITE_FLAG( pps_extension_flags[i]?1:0, syntaxStrings[i] );
269    }
270
271    for(Int i=0; i<NUM_PPS_EXTENSION_FLAGS; i++) // loop used so that the order is determined by the enum.
272    {
273      if (pps_extension_flags[i])
274      {
275        switch (PPSExtensionFlagIndex(i))
276        {
277          case PPS_EXT__REXT:
278            {
279              const TComPPSRExt &ppsRangeExtension = pcPPS->getPpsRangeExtension();
280              if (pcPPS->getUseTransformSkip())
281              {
282                WRITE_UVLC( ppsRangeExtension.getLog2MaxTransformSkipBlockSize()-2,            "log2_max_transform_skip_block_size_minus2");
283              }
284
285              WRITE_FLAG((ppsRangeExtension.getCrossComponentPredictionEnabledFlag() ? 1 : 0), "cross_component_prediction_enabled_flag" );
286
287              WRITE_FLAG(UInt(ppsRangeExtension.getChromaQpOffsetListEnabledFlag()),           "chroma_qp_offset_list_enabled_flag" );
288              if (ppsRangeExtension.getChromaQpOffsetListEnabledFlag())
289              {
290                WRITE_UVLC(ppsRangeExtension.getDiffCuChromaQpOffsetDepth(),                   "diff_cu_chroma_qp_offset_depth");
291                WRITE_UVLC(ppsRangeExtension.getChromaQpOffsetListLen() - 1,                   "chroma_qp_offset_list_len_minus1");
292                /* skip zero index */
293                for (Int cuChromaQpOffsetIdx = 0; cuChromaQpOffsetIdx < ppsRangeExtension.getChromaQpOffsetListLen(); cuChromaQpOffsetIdx++)
294                {
295                  WRITE_SVLC(ppsRangeExtension.getChromaQpOffsetListEntry(cuChromaQpOffsetIdx+1).u.comp.CbOffset,     "cb_qp_offset_list[i]");
296                  WRITE_SVLC(ppsRangeExtension.getChromaQpOffsetListEntry(cuChromaQpOffsetIdx+1).u.comp.CrOffset,     "cr_qp_offset_list[i]");
297                }
298              }
299
300              WRITE_UVLC( ppsRangeExtension.getLog2SaoOffsetScale(CHANNEL_TYPE_LUMA),           "log2_sao_offset_scale_luma"   );
301              WRITE_UVLC( ppsRangeExtension.getLog2SaoOffsetScale(CHANNEL_TYPE_CHROMA),         "log2_sao_offset_scale_chroma" );
302            }
303            break;
304
305#if SVC_EXTENSION
306          case PPS_EXT__MLAYER:
307            WRITE_FLAG( pcPPS->getPocResetInfoPresentFlag() ? 1 : 0, "poc_reset_info_present_flag" );
308
309            WRITE_FLAG( pcPPS->getInferScalingListFlag() ? 1 : 0, "pps_infer_scaling_list_flag" );
310            if( pcPPS->getInferScalingListFlag() )
311            {
312              // The value of pps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
313              assert( pcPPS->getScalingListRefLayerId() <= 62 );
314              WRITE_CODE( pcPPS->getScalingListRefLayerId(), 6, "pps_scaling_list_ref_layer_id" );
315            }
316
317            WRITE_UVLC( pcPPS->getNumRefLayerLocationOffsets(),      "num_ref_loc_offsets" );
318            for(Int k = 0; k < pcPPS->getNumRefLayerLocationOffsets(); k++)
319            {
320              WRITE_CODE( pcPPS->getRefLocationOffsetLayerId(k), 6, "ref_loc_offset_layer_id" );
321              WRITE_FLAG( pcPPS->getScaledRefLayerOffsetPresentFlag(k) ? 1 : 0, "scaled_ref_layer_offset_prsent_flag" );
322              if( pcPPS->getScaledRefLayerOffsetPresentFlag(k) )
323              {
324                Window scaledWindow = pcPPS->getScaledRefLayerWindow(k);
325                WRITE_SVLC( scaledWindow.getWindowLeftOffset()   >> 1, "scaled_ref_layer_left_offset" );
326                WRITE_SVLC( scaledWindow.getWindowTopOffset()    >> 1, "scaled_ref_layer_top_offset" );
327                WRITE_SVLC( scaledWindow.getWindowRightOffset()  >> 1, "scaled_ref_layer_right_offset" );
328                WRITE_SVLC( scaledWindow.getWindowBottomOffset() >> 1, "scaled_ref_layer_bottom_offset" );
329              }
330
331              WRITE_FLAG( pcPPS->getRefRegionOffsetPresentFlag(k) ? 1 : 0, "ref_region_offset_prsent_flag" );
332
333              if( pcPPS->getRefRegionOffsetPresentFlag(k) )
334              {
335                const Window refWindow = pcPPS->getRefLayerWindow(k);
336                WRITE_SVLC( refWindow.getWindowLeftOffset()   >> 1, "ref_region_left_offset" );
337                WRITE_SVLC( refWindow.getWindowTopOffset()    >> 1, "ref_region_top_offset" );
338                WRITE_SVLC( refWindow.getWindowRightOffset()  >> 1, "ref_region_right_offset" );
339                WRITE_SVLC( refWindow.getWindowBottomOffset() >> 1, "ref_region_bottom_offset" );
340              }
341
342              WRITE_FLAG( pcPPS->getResamplePhaseSetPresentFlag(k) ? 1 : 0, "resample_phase_set_present_flag" );
343
344              if( pcPPS->getResamplePhaseSetPresentFlag(k) )
345              {
346                WRITE_UVLC( pcPPS->getPhaseHorLuma(k), "phase_hor_luma" );
347                WRITE_UVLC( pcPPS->getPhaseVerLuma(k), "phase_ver_luma" );
348                WRITE_UVLC( pcPPS->getPhaseHorChroma(k) + 8, "phase_hor_chroma_plus8" );
349                WRITE_UVLC( pcPPS->getPhaseVerChroma(k) + 8, "phase_ver_chroma_plus8" );
350              }
351            }
352#if CGS_3D_ASYMLUT
353            bits = getNumberOfWrittenBits();
354            WRITE_FLAG( pcPPS->getCGSFlag() , "colour_mapping_enabled_flag" );
355            if( pcPPS->getCGSFlag() )
356            {
357              assert( pc3DAsymLUT != NULL );
358              xCode3DAsymLUT( pc3DAsymLUT );
359            }
360            pc3DAsymLUT->setPPSBit( getNumberOfWrittenBits() - bits );
361#endif
362            break;
363#endif
364          default:
365            assert(pps_extension_flags[i]==false); // Should never get here with an active PPS extension flag.
366            break;
367        } // switch
368      } // if flag present
369    } // loop over PPS flags
370  } // pps_extension_present_flag is non-zero
371  xWriteRbspTrailingBits();
372}
373
374Void TEncCavlc::codeVUI( const TComVUI *pcVUI, const TComSPS* pcSPS )
375{
376#if ENC_DEC_TRACE
377  fprintf( g_hTrace, "----------- vui_parameters -----------\n");
378#endif
379  WRITE_FLAG(pcVUI->getAspectRatioInfoPresentFlag(),            "aspect_ratio_info_present_flag");
380  if (pcVUI->getAspectRatioInfoPresentFlag())
381  {
382    WRITE_CODE(pcVUI->getAspectRatioIdc(), 8,                   "aspect_ratio_idc" );
383    if (pcVUI->getAspectRatioIdc() == 255)
384    {
385      WRITE_CODE(pcVUI->getSarWidth(), 16,                      "sar_width");
386      WRITE_CODE(pcVUI->getSarHeight(), 16,                     "sar_height");
387    }
388  }
389  WRITE_FLAG(pcVUI->getOverscanInfoPresentFlag(),               "overscan_info_present_flag");
390  if (pcVUI->getOverscanInfoPresentFlag())
391  {
392    WRITE_FLAG(pcVUI->getOverscanAppropriateFlag(),             "overscan_appropriate_flag");
393  }
394  WRITE_FLAG(pcVUI->getVideoSignalTypePresentFlag(),            "video_signal_type_present_flag");
395  if (pcVUI->getVideoSignalTypePresentFlag())
396  {
397    WRITE_CODE(pcVUI->getVideoFormat(), 3,                      "video_format");
398    WRITE_FLAG(pcVUI->getVideoFullRangeFlag(),                  "video_full_range_flag");
399    WRITE_FLAG(pcVUI->getColourDescriptionPresentFlag(),        "colour_description_present_flag");
400    if (pcVUI->getColourDescriptionPresentFlag())
401    {
402      WRITE_CODE(pcVUI->getColourPrimaries(), 8,                "colour_primaries");
403      WRITE_CODE(pcVUI->getTransferCharacteristics(), 8,        "transfer_characteristics");
404      WRITE_CODE(pcVUI->getMatrixCoefficients(), 8,             "matrix_coeffs");
405    }
406  }
407
408  WRITE_FLAG(pcVUI->getChromaLocInfoPresentFlag(),              "chroma_loc_info_present_flag");
409  if (pcVUI->getChromaLocInfoPresentFlag())
410  {
411    WRITE_UVLC(pcVUI->getChromaSampleLocTypeTopField(),         "chroma_sample_loc_type_top_field");
412    WRITE_UVLC(pcVUI->getChromaSampleLocTypeBottomField(),      "chroma_sample_loc_type_bottom_field");
413  }
414
415  WRITE_FLAG(pcVUI->getNeutralChromaIndicationFlag(),           "neutral_chroma_indication_flag");
416  WRITE_FLAG(pcVUI->getFieldSeqFlag(),                          "field_seq_flag");
417  WRITE_FLAG(pcVUI->getFrameFieldInfoPresentFlag(),             "frame_field_info_present_flag");
418
419  Window defaultDisplayWindow = pcVUI->getDefaultDisplayWindow();
420  WRITE_FLAG(defaultDisplayWindow.getWindowEnabledFlag(),       "default_display_window_flag");
421  if( defaultDisplayWindow.getWindowEnabledFlag() )
422  {
423    WRITE_UVLC(defaultDisplayWindow.getWindowLeftOffset()  / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc()), "def_disp_win_left_offset");
424    WRITE_UVLC(defaultDisplayWindow.getWindowRightOffset() / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc()), "def_disp_win_right_offset");
425    WRITE_UVLC(defaultDisplayWindow.getWindowTopOffset()   / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc()), "def_disp_win_top_offset");
426    WRITE_UVLC(defaultDisplayWindow.getWindowBottomOffset()/ TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc()), "def_disp_win_bottom_offset");
427  }
428  const TimingInfo *timingInfo = pcVUI->getTimingInfo();
429  WRITE_FLAG(timingInfo->getTimingInfoPresentFlag(),          "vui_timing_info_present_flag");
430  if(timingInfo->getTimingInfoPresentFlag())
431  {
432    WRITE_CODE(timingInfo->getNumUnitsInTick(), 32,           "vui_num_units_in_tick");
433    WRITE_CODE(timingInfo->getTimeScale(),      32,           "vui_time_scale");
434    WRITE_FLAG(timingInfo->getPocProportionalToTimingFlag(),  "vui_poc_proportional_to_timing_flag");
435    if(timingInfo->getPocProportionalToTimingFlag())
436    {
437      WRITE_UVLC(timingInfo->getNumTicksPocDiffOneMinus1(),   "vui_num_ticks_poc_diff_one_minus1");
438    }
439    WRITE_FLAG(pcVUI->getHrdParametersPresentFlag(),              "vui_hrd_parameters_present_flag");
440    if( pcVUI->getHrdParametersPresentFlag() )
441    {
442      codeHrdParameters(pcVUI->getHrdParameters(), 1, pcSPS->getMaxTLayers() - 1 );
443    }
444  }
445
446  WRITE_FLAG(pcVUI->getBitstreamRestrictionFlag(),              "bitstream_restriction_flag");
447  if (pcVUI->getBitstreamRestrictionFlag())
448  {
449    WRITE_FLAG(pcVUI->getTilesFixedStructureFlag(),             "tiles_fixed_structure_flag");
450    WRITE_FLAG(pcVUI->getMotionVectorsOverPicBoundariesFlag(),  "motion_vectors_over_pic_boundaries_flag");
451    WRITE_FLAG(pcVUI->getRestrictedRefPicListsFlag(),           "restricted_ref_pic_lists_flag");
452    WRITE_UVLC(pcVUI->getMinSpatialSegmentationIdc(),           "min_spatial_segmentation_idc");
453    WRITE_UVLC(pcVUI->getMaxBytesPerPicDenom(),                 "max_bytes_per_pic_denom");
454    WRITE_UVLC(pcVUI->getMaxBitsPerMinCuDenom(),                "max_bits_per_min_cu_denom");
455    WRITE_UVLC(pcVUI->getLog2MaxMvLengthHorizontal(),           "log2_max_mv_length_horizontal");
456    WRITE_UVLC(pcVUI->getLog2MaxMvLengthVertical(),             "log2_max_mv_length_vertical");
457  }
458}
459
460Void TEncCavlc::codeHrdParameters( const TComHRD *hrd, Bool commonInfPresentFlag, UInt maxNumSubLayersMinus1 )
461{
462  if( commonInfPresentFlag )
463  {
464    WRITE_FLAG( hrd->getNalHrdParametersPresentFlag() ? 1 : 0 ,  "nal_hrd_parameters_present_flag" );
465    WRITE_FLAG( hrd->getVclHrdParametersPresentFlag() ? 1 : 0 ,  "vcl_hrd_parameters_present_flag" );
466    if( hrd->getNalHrdParametersPresentFlag() || hrd->getVclHrdParametersPresentFlag() )
467    {
468      WRITE_FLAG( hrd->getSubPicCpbParamsPresentFlag() ? 1 : 0,  "sub_pic_hrd_params_present_flag" );
469      if( hrd->getSubPicCpbParamsPresentFlag() )
470      {
471        WRITE_CODE( hrd->getTickDivisorMinus2(), 8,              "tick_divisor_minus2" );
472        WRITE_CODE( hrd->getDuCpbRemovalDelayLengthMinus1(), 5,  "du_cpb_removal_delay_increment_length_minus1" );
473        WRITE_FLAG( hrd->getSubPicCpbParamsInPicTimingSEIFlag() ? 1 : 0, "sub_pic_cpb_params_in_pic_timing_sei_flag" );
474        WRITE_CODE( hrd->getDpbOutputDelayDuLengthMinus1(), 5,   "dpb_output_delay_du_length_minus1"  );
475      }
476      WRITE_CODE( hrd->getBitRateScale(), 4,                     "bit_rate_scale" );
477      WRITE_CODE( hrd->getCpbSizeScale(), 4,                     "cpb_size_scale" );
478      if( hrd->getSubPicCpbParamsPresentFlag() )
479      {
480        WRITE_CODE( hrd->getDuCpbSizeScale(), 4,                "du_cpb_size_scale" );
481      }
482      WRITE_CODE( hrd->getInitialCpbRemovalDelayLengthMinus1(), 5, "initial_cpb_removal_delay_length_minus1" );
483      WRITE_CODE( hrd->getCpbRemovalDelayLengthMinus1(),        5, "au_cpb_removal_delay_length_minus1" );
484      WRITE_CODE( hrd->getDpbOutputDelayLengthMinus1(),         5, "dpb_output_delay_length_minus1" );
485    }
486  }
487  Int i, j, nalOrVcl;
488  for( i = 0; i <= maxNumSubLayersMinus1; i ++ )
489  {
490    WRITE_FLAG( hrd->getFixedPicRateFlag( i ) ? 1 : 0,          "fixed_pic_rate_general_flag");
491    Bool fixedPixRateWithinCvsFlag = true;
492    if( !hrd->getFixedPicRateFlag( i ) )
493    {
494      fixedPixRateWithinCvsFlag = hrd->getFixedPicRateWithinCvsFlag( i );
495      WRITE_FLAG( hrd->getFixedPicRateWithinCvsFlag( i ) ? 1 : 0, "fixed_pic_rate_within_cvs_flag");
496    }
497    if( fixedPixRateWithinCvsFlag )
498    {
499      WRITE_UVLC( hrd->getPicDurationInTcMinus1( i ),           "elemental_duration_in_tc_minus1");
500    }
501    else
502    {
503      WRITE_FLAG( hrd->getLowDelayHrdFlag( i ) ? 1 : 0,           "low_delay_hrd_flag");
504    }
505    if (!hrd->getLowDelayHrdFlag( i ))
506    {
507      WRITE_UVLC( hrd->getCpbCntMinus1( i ),                      "cpb_cnt_minus1");
508    }
509
510    for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
511    {
512      if( ( ( nalOrVcl == 0 ) && ( hrd->getNalHrdParametersPresentFlag() ) ) ||
513          ( ( nalOrVcl == 1 ) && ( hrd->getVclHrdParametersPresentFlag() ) ) )
514      {
515        for( j = 0; j <= ( hrd->getCpbCntMinus1( i ) ); j ++ )
516        {
517          WRITE_UVLC( hrd->getBitRateValueMinus1( i, j, nalOrVcl ), "bit_rate_value_minus1");
518          WRITE_UVLC( hrd->getCpbSizeValueMinus1( i, j, nalOrVcl ), "cpb_size_value_minus1");
519          if( hrd->getSubPicCpbParamsPresentFlag() )
520          {
521            WRITE_UVLC( hrd->getDuCpbSizeValueMinus1( i, j, nalOrVcl ), "cpb_size_du_value_minus1");
522            WRITE_UVLC( hrd->getDuBitRateValueMinus1( i, j, nalOrVcl ), "bit_rate_du_value_minus1");
523          }
524          WRITE_FLAG( hrd->getCbrFlag( i, j, nalOrVcl ) ? 1 : 0, "cbr_flag");
525        }
526      }
527    }
528  }
529}
530
531Void TEncCavlc::codeSPS( const TComSPS* pcSPS )
532{
533#if SVC_EXTENSION
534  Bool V1CompatibleSPSFlag = !(pcSPS->getLayerId() != 0 && pcSPS->getNumDirectRefLayers() != 0);
535#endif
536
537  const ChromaFormat format                = pcSPS->getChromaFormatIdc();
538  const Bool         chromaEnabled         = isChromaEnabled(format);
539
540#if ENC_DEC_TRACE
541  xTraceSPSHeader ();
542#endif
543  WRITE_CODE( pcSPS->getVPSId (),          4,       "sps_video_parameter_set_id" );
544#if SVC_EXTENSION
545  if(pcSPS->getLayerId() == 0)
546  {
547#endif
548  WRITE_CODE( pcSPS->getMaxTLayers() - 1,  3,       "sps_max_sub_layers_minus1" );
549#if SVC_EXTENSION
550  }
551  else
552  {
553    WRITE_CODE( V1CompatibleSPSFlag ? (pcSPS->getMaxTLayers() - 1) : 7,  3,       "sps_ext_or_max_sub_layers_minus1" );
554  }
555
556  if( V1CompatibleSPSFlag )
557  {
558#endif
559  WRITE_FLAG( pcSPS->getTemporalIdNestingFlag() ? 1 : 0, "sps_temporal_id_nesting_flag" );
560  codePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
561#if SVC_EXTENSION
562  }
563#endif
564  WRITE_UVLC( pcSPS->getSPSId (),                   "sps_seq_parameter_set_id" );
565#if SVC_EXTENSION
566  if( !V1CompatibleSPSFlag )
567  {
568    WRITE_FLAG( pcSPS->getUpdateRepFormatFlag(), "update_rep_format_flag" );
569 
570    if( pcSPS->getUpdateRepFormatFlag())
571    {
572      WRITE_CODE( pcSPS->getUpdateRepFormatIndex(), 8,   "sps_rep_format_idx");
573    }
574  }
575  else
576  {
577#endif
578  WRITE_UVLC( Int(pcSPS->getChromaFormatIdc ()),    "chroma_format_idc" );
579  if( format == CHROMA_444 )
580  {
581    WRITE_FLAG( 0,                                  "separate_colour_plane_flag");
582  }
583
584  WRITE_UVLC( pcSPS->getPicWidthInLumaSamples (),   "pic_width_in_luma_samples" );
585  WRITE_UVLC( pcSPS->getPicHeightInLumaSamples(),   "pic_height_in_luma_samples" );
586  Window conf = pcSPS->getConformanceWindow();
587
588  WRITE_FLAG( conf.getWindowEnabledFlag(),          "conformance_window_flag" );
589  if (conf.getWindowEnabledFlag())
590  {
591#if SVC_EXTENSION
592    WRITE_UVLC( conf.getWindowLeftOffset(),   "conf_win_left_offset"   );
593    WRITE_UVLC( conf.getWindowRightOffset(),  "conf_win_right_offset"  );
594    WRITE_UVLC( conf.getWindowTopOffset(),    "conf_win_top_offset"    );
595    WRITE_UVLC( conf.getWindowBottomOffset(), "conf_win_bottom_offset" );
596#else
597    WRITE_UVLC( conf.getWindowLeftOffset()   / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc() ), "conf_win_left_offset" );
598    WRITE_UVLC( conf.getWindowRightOffset()  / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc() ), "conf_win_right_offset" );
599    WRITE_UVLC( conf.getWindowTopOffset()    / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc() ), "conf_win_top_offset" );
600    WRITE_UVLC( conf.getWindowBottomOffset() / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc() ), "conf_win_bottom_offset" );
601#endif
602  }
603#if SVC_EXTENSION
604  }
605
606  if( V1CompatibleSPSFlag )
607  {
608#endif
609  WRITE_UVLC( pcSPS->getBitDepth(CHANNEL_TYPE_LUMA) - 8,                      "bit_depth_luma_minus8" );
610
611  WRITE_UVLC( chromaEnabled ? (pcSPS->getBitDepth(CHANNEL_TYPE_CHROMA) - 8):0,  "bit_depth_chroma_minus8" );
612#if SVC_EXTENSION
613  }
614#endif
615
616  WRITE_UVLC( pcSPS->getBitsForPOC()-4,                 "log2_max_pic_order_cnt_lsb_minus4" );
617
618#if SVC_EXTENSION
619  if( V1CompatibleSPSFlag )
620  {
621#endif
622  const Bool subLayerOrderingInfoPresentFlag = 1;
623  WRITE_FLAG(subLayerOrderingInfoPresentFlag,       "sps_sub_layer_ordering_info_present_flag");
624  for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
625  {
626    WRITE_UVLC( pcSPS->getMaxDecPicBuffering(i) - 1,       "sps_max_dec_pic_buffering_minus1[i]" );
627    WRITE_UVLC( pcSPS->getNumReorderPics(i),               "sps_max_num_reorder_pics[i]" );
628    WRITE_UVLC( pcSPS->getMaxLatencyIncrease(i),           "sps_max_latency_increase_plus1[i]" );
629    if (!subLayerOrderingInfoPresentFlag)
630    {
631      break;
632    }
633  }
634#if SVC_EXTENSION
635  }
636#endif
637  assert( pcSPS->getMaxCUWidth() == pcSPS->getMaxCUHeight() );
638  WRITE_UVLC( pcSPS->getLog2MinCodingBlockSize() - 3,                                "log2_min_luma_coding_block_size_minus3" );
639  WRITE_UVLC( pcSPS->getLog2DiffMaxMinCodingBlockSize(),                             "log2_diff_max_min_luma_coding_block_size" );
640  WRITE_UVLC( pcSPS->getQuadtreeTULog2MinSize() - 2,                                 "log2_min_luma_transform_block_size_minus2" );
641  WRITE_UVLC( pcSPS->getQuadtreeTULog2MaxSize() - pcSPS->getQuadtreeTULog2MinSize(), "log2_diff_max_min_luma_transform_block_size" );
642  WRITE_UVLC( pcSPS->getQuadtreeTUMaxDepthInter() - 1,                               "max_transform_hierarchy_depth_inter" );
643  WRITE_UVLC( pcSPS->getQuadtreeTUMaxDepthIntra() - 1,                               "max_transform_hierarchy_depth_intra" );
644  WRITE_FLAG( pcSPS->getScalingListFlag() ? 1 : 0,                                   "scaling_list_enabled_flag" );
645  if(pcSPS->getScalingListFlag())
646  {
647#if SVC_EXTENSION
648    if( !V1CompatibleSPSFlag )
649    {
650      WRITE_FLAG( pcSPS->getInferScalingListFlag() ? 1 : 0, "sps_infer_scaling_list_flag" );
651    }
652
653    if( pcSPS->getInferScalingListFlag() )
654    {
655      // The value of pps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
656      assert( pcSPS->getScalingListRefLayerId() <= 62 );
657
658      WRITE_CODE( pcSPS->getScalingListRefLayerId(), 6, "sps_scaling_list_ref_layer_id" );
659    }
660    else
661    {
662#endif
663    WRITE_FLAG( pcSPS->getScalingListPresentFlag() ? 1 : 0,                          "sps_scaling_list_data_present_flag" );
664    if(pcSPS->getScalingListPresentFlag())
665    {
666      codeScalingList( pcSPS->getScalingList() );
667    }
668#if SVC_EXTENSION
669    }
670#endif
671  }
672  WRITE_FLAG( pcSPS->getUseAMP() ? 1 : 0,                                            "amp_enabled_flag" );
673  WRITE_FLAG( pcSPS->getUseSAO() ? 1 : 0,                                            "sample_adaptive_offset_enabled_flag");
674
675  WRITE_FLAG( pcSPS->getUsePCM() ? 1 : 0,                                            "pcm_enabled_flag");
676  if( pcSPS->getUsePCM() )
677  {
678    WRITE_CODE( pcSPS->getPCMBitDepth(CHANNEL_TYPE_LUMA) - 1, 4,                            "pcm_sample_bit_depth_luma_minus1" );
679    WRITE_CODE( chromaEnabled ? (pcSPS->getPCMBitDepth(CHANNEL_TYPE_CHROMA) - 1) : 0, 4,    "pcm_sample_bit_depth_chroma_minus1" );
680    WRITE_UVLC( pcSPS->getPCMLog2MinSize() - 3,                                      "log2_min_pcm_luma_coding_block_size_minus3" );
681    WRITE_UVLC( pcSPS->getPCMLog2MaxSize() - pcSPS->getPCMLog2MinSize(),             "log2_diff_max_min_pcm_luma_coding_block_size" );
682    WRITE_FLAG( pcSPS->getPCMFilterDisableFlag()?1 : 0,                              "pcm_loop_filter_disable_flag");
683  }
684
685  assert( pcSPS->getMaxTLayers() > 0 );
686
687  const TComRPSList* rpsList = pcSPS->getRPSList();
688
689  WRITE_UVLC(rpsList->getNumberOfReferencePictureSets(), "num_short_term_ref_pic_sets" );
690  for(Int i=0; i < rpsList->getNumberOfReferencePictureSets(); i++)
691  {
692    const TComReferencePictureSet*rps = rpsList->getReferencePictureSet(i);
693    codeShortTermRefPicSet( rps,false, i);
694  }
695  WRITE_FLAG( pcSPS->getLongTermRefsPresent() ? 1 : 0,         "long_term_ref_pics_present_flag" );
696  if (pcSPS->getLongTermRefsPresent())
697  {
698    WRITE_UVLC(pcSPS->getNumLongTermRefPicSPS(), "num_long_term_ref_pics_sps" );
699    for (UInt k = 0; k < pcSPS->getNumLongTermRefPicSPS(); k++)
700    {
701      WRITE_CODE( pcSPS->getLtRefPicPocLsbSps(k), pcSPS->getBitsForPOC(), "lt_ref_pic_poc_lsb_sps");
702      WRITE_FLAG( pcSPS->getUsedByCurrPicLtSPSFlag(k), "used_by_curr_pic_lt_sps_flag[i]");
703    }
704  }
705  WRITE_FLAG( pcSPS->getTMVPFlagsPresent()  ? 1 : 0,           "sps_temporal_mvp_enable_flag" );
706
707  WRITE_FLAG( pcSPS->getUseStrongIntraSmoothing(),             "sps_strong_intra_smoothing_enable_flag" );
708
709  WRITE_FLAG( pcSPS->getVuiParametersPresentFlag(),             "vui_parameters_present_flag" );
710  if (pcSPS->getVuiParametersPresentFlag())
711  {
712      codeVUI(pcSPS->getVuiParameters(), pcSPS);
713  }
714
715  Bool sps_extension_present_flag=false;
716  Bool sps_extension_flags[NUM_SPS_EXTENSION_FLAGS]={false};
717
718  sps_extension_flags[SPS_EXT__REXT] = pcSPS->getSpsRangeExtension().settingsDifferFromDefaults();
719
720  // Other SPS extension flags checked here.
721#if SVC_EXTENSION
722  sps_extension_flags[SPS_EXT__MLAYER] = pcSPS->getExtensionFlag() ? 1 : 0;
723#endif
724
725  for(Int i=0; i<NUM_SPS_EXTENSION_FLAGS; i++)
726  {
727    sps_extension_present_flag|=sps_extension_flags[i];
728  }
729
730  WRITE_FLAG( (sps_extension_present_flag?1:0), "sps_extension_present_flag" );
731
732  if (sps_extension_present_flag)
733  {
734#if ENC_DEC_TRACE || RExt__DECODER_DEBUG_BIT_STATISTICS
735    static const char *syntaxStrings[]={ "sps_range_extension_flag",
736                                         "sps_multilayer_extension_flag",
737                                         "sps_extension_6bits[0]",
738                                         "sps_extension_6bits[1]",
739                                         "sps_extension_6bits[2]",
740                                         "sps_extension_6bits[3]",
741                                         "sps_extension_6bits[4]",
742                                         "sps_extension_6bits[5]" };
743#endif
744
745    for(Int i=0; i<NUM_SPS_EXTENSION_FLAGS; i++)
746    {
747      WRITE_FLAG( sps_extension_flags[i]?1:0, syntaxStrings[i] );
748    }
749
750    for(Int i=0; i<NUM_SPS_EXTENSION_FLAGS; i++) // loop used so that the order is determined by the enum.
751    {
752      if (sps_extension_flags[i])
753      {
754        switch (SPSExtensionFlagIndex(i))
755        {
756          case SPS_EXT__REXT:
757          {
758            const TComSPSRExt &spsRangeExtension=pcSPS->getSpsRangeExtension();
759
760            WRITE_FLAG( (spsRangeExtension.getTransformSkipRotationEnabledFlag() ? 1 : 0),      "transform_skip_rotation_enabled_flag");
761            WRITE_FLAG( (spsRangeExtension.getTransformSkipContextEnabledFlag() ? 1 : 0),       "transform_skip_context_enabled_flag");
762            WRITE_FLAG( (spsRangeExtension.getRdpcmEnabledFlag(RDPCM_SIGNAL_IMPLICIT) ? 1 : 0), "implicit_rdpcm_enabled_flag" );
763            WRITE_FLAG( (spsRangeExtension.getRdpcmEnabledFlag(RDPCM_SIGNAL_EXPLICIT) ? 1 : 0), "explicit_rdpcm_enabled_flag" );
764            WRITE_FLAG( (spsRangeExtension.getExtendedPrecisionProcessingFlag() ? 1 : 0),       "extended_precision_processing_flag" );
765            WRITE_FLAG( (spsRangeExtension.getIntraSmoothingDisabledFlag() ? 1 : 0),            "intra_smoothing_disabled_flag" );
766            WRITE_FLAG( (spsRangeExtension.getHighPrecisionOffsetsEnabledFlag() ? 1 : 0),       "high_precision_offsets_enabled_flag" );
767            WRITE_FLAG( (spsRangeExtension.getPersistentRiceAdaptationEnabledFlag() ? 1 : 0),   "persistent_rice_adaptation_enabled_flag" );
768            WRITE_FLAG( (spsRangeExtension.getCabacBypassAlignmentEnabledFlag() ? 1 : 0),       "cabac_bypass_alignment_enabled_flag" );
769            break;
770          }
771#if SVC_EXTENSION
772          case SPS_EXT__MLAYER:
773            codeSPSExtension( pcSPS ); //it is sps_multilayer_extension
774            break;
775#endif
776          default:
777            assert(sps_extension_flags[i]==false); // Should never get here with an active SPS extension flag.
778            break;
779        }
780      }
781    }
782  }
783  xWriteRbspTrailingBits();
784}
785
786Void TEncCavlc::codeVPS( const TComVPS* pcVPS )
787{
788#if ENC_DEC_TRACE
789  xTraceVPSHeader();
790#endif
791  WRITE_CODE( pcVPS->getVPSId(),                    4,        "vps_video_parameter_set_id" );
792#if SVC_EXTENSION
793  WRITE_FLAG( pcVPS->getBaseLayerInternalFlag(),              "vps_base_layer_internal_flag");
794  WRITE_FLAG( pcVPS->getBaseLayerAvailableFlag(),             "vps_base_layer_available_flag");
795  WRITE_CODE( pcVPS->getMaxLayers() - 1,            6,        "vps_max_layers_minus1" );
796  assert( pcVPS->getBaseLayerInternalFlag() || pcVPS->getMaxLayers() > 1 );
797#else
798  WRITE_FLAG(                                       1,        "vps_base_layer_internal_flag" );
799  WRITE_FLAG(                                       1,        "vps_base_layer_available_flag" );
800  WRITE_CODE( 0,                                    6,        "vps_max_layers_minus1" );
801#endif
802  WRITE_CODE( pcVPS->getMaxTLayers() - 1,           3,        "vps_max_sub_layers_minus1" );
803  WRITE_FLAG( pcVPS->getTemporalNestingFlag(),                "vps_temporal_id_nesting_flag" );
804  assert (pcVPS->getMaxTLayers()>1||pcVPS->getTemporalNestingFlag());
805  WRITE_CODE( 0xffff,                              16,        "vps_reserved_0xffff_16bits" );
806  codePTL( pcVPS->getPTL(), true, pcVPS->getMaxTLayers() - 1 );
807  const Bool subLayerOrderingInfoPresentFlag = 1;
808  WRITE_FLAG(subLayerOrderingInfoPresentFlag,              "vps_sub_layer_ordering_info_present_flag");
809  for(UInt i=0; i <= pcVPS->getMaxTLayers()-1; i++)
810  {
811    WRITE_UVLC( pcVPS->getMaxDecPicBuffering(i) - 1,       "vps_max_dec_pic_buffering_minus1[i]" );
812    WRITE_UVLC( pcVPS->getNumReorderPics(i),               "vps_max_num_reorder_pics[i]" );
813    WRITE_UVLC( pcVPS->getMaxLatencyIncrease(i),           "vps_max_latency_increase_plus1[i]" );
814    if (!subLayerOrderingInfoPresentFlag)
815    {
816      break;
817    }
818  }
819
820#if SVC_EXTENSION
821  assert( pcVPS->getNumHrdParameters() <= MAX_VPS_LAYER_SETS_PLUS1 );
822  assert( pcVPS->getMaxLayerId() < MAX_VPS_LAYER_IDX_PLUS1 );
823
824  WRITE_CODE( pcVPS->getMaxLayerId(), 6,                       "vps_max_layer_id" );
825  WRITE_UVLC(pcVPS->getVpsNumLayerSetsMinus1(),                "vps_num_layer_sets_minus1");
826
827  for( UInt opsIdx = 1; opsIdx <= pcVPS->getVpsNumLayerSetsMinus1(); opsIdx++ )
828  {
829    // Operation point set
830    for( UInt i = 0; i <= pcVPS->getMaxLayerId(); i ++ )
831    {
832#else
833  assert( pcVPS->getNumHrdParameters() <= MAX_VPS_NUM_HRD_PARAMETERS );
834  assert( pcVPS->getMaxNuhReservedZeroLayerId() < MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1 );
835  WRITE_CODE( pcVPS->getMaxNuhReservedZeroLayerId(), 6,     "vps_max_layer_id" );
836  WRITE_UVLC( pcVPS->getMaxOpSets() - 1,                    "vps_num_layer_sets_minus1" );
837  for( UInt opsIdx = 1; opsIdx <= ( pcVPS->getMaxOpSets() - 1 ); opsIdx ++ )
838  {
839    // Operation point set
840    for( UInt i = 0; i <= pcVPS->getMaxNuhReservedZeroLayerId(); i ++ )
841    {
842      // Only applicable for version 1
843      // pcVPS->setLayerIdIncludedFlag( true, opsIdx, i );
844#endif
845      WRITE_FLAG( pcVPS->getLayerIdIncludedFlag( opsIdx, i ) ? 1 : 0, "layer_id_included_flag[opsIdx][i]" );
846    }
847  }
848  const TimingInfo *timingInfo = pcVPS->getTimingInfo();
849  WRITE_FLAG(timingInfo->getTimingInfoPresentFlag(),          "vps_timing_info_present_flag");
850  if(timingInfo->getTimingInfoPresentFlag())
851  {
852    WRITE_CODE(timingInfo->getNumUnitsInTick(), 32,           "vps_num_units_in_tick");
853    WRITE_CODE(timingInfo->getTimeScale(),      32,           "vps_time_scale");
854    WRITE_FLAG(timingInfo->getPocProportionalToTimingFlag(),  "vps_poc_proportional_to_timing_flag");
855    if(timingInfo->getPocProportionalToTimingFlag())
856    {
857      WRITE_UVLC(timingInfo->getNumTicksPocDiffOneMinus1(),   "vps_num_ticks_poc_diff_one_minus1");
858    }
859    WRITE_UVLC( pcVPS->getNumHrdParameters(),                 "vps_num_hrd_parameters" );
860
861    if( pcVPS->getNumHrdParameters() > 0 )
862    {
863      for( UInt i = 0; i < pcVPS->getNumHrdParameters(); i ++ )
864      {
865        // Only applicable for version 1
866        WRITE_UVLC( pcVPS->getHrdOpSetIdx( i ),                "hrd_layer_set_idx" );
867        if( i > 0 )
868        {
869          WRITE_FLAG( pcVPS->getCprmsPresentFlag( i ) ? 1 : 0, "cprms_present_flag[i]" );
870        }
871        codeHrdParameters(pcVPS->getHrdParameters(i), pcVPS->getCprmsPresentFlag( i ), pcVPS->getMaxTLayers() - 1);
872      }
873    }
874  }
875#if SVC_EXTENSION
876  // When MaxLayersMinus1 is greater than 0, vps_extension_flag shall be equal to 1.
877  if( pcVPS->getMaxLayers() > 1 )
878  {
879    assert( pcVPS->getVpsExtensionFlag() == true );
880  }
881
882  WRITE_FLAG( pcVPS->getVpsExtensionFlag() ? 1 : 0,                     "vps_extension_flag" );
883
884  if( pcVPS->getVpsExtensionFlag() )
885  {
886    while ( m_pcBitIf->getNumberOfWrittenBits() % 8 != 0 )
887    {
888      WRITE_FLAG(1,                  "vps_extension_alignment_bit_equal_to_one");
889    }
890    codeVPSExtension(pcVPS);
891    WRITE_FLAG( 0,                     "vps_extension2_flag" );   // Flag value of 1 reserved
892  }
893#else
894  WRITE_FLAG( 0,                     "vps_extension_flag" );
895#endif   
896
897  //future extensions here..
898  xWriteRbspTrailingBits();
899}
900
901Void TEncCavlc::codeSliceHeader         ( TComSlice* pcSlice )
902{
903#if ENC_DEC_TRACE
904  xTraceSliceHeader ();
905#endif
906
907  const ChromaFormat format                = pcSlice->getSPS()->getChromaFormatIdc();
908  const UInt         numberValidComponents = getNumberValidComponents(format);
909  const Bool         chromaEnabled         = isChromaEnabled(format);
910
911  //calculate number of bits required for slice address
912  Int maxSliceSegmentAddress = pcSlice->getPic()->getNumberOfCtusInFrame();
913  Int bitsSliceSegmentAddress = 0;
914  while(maxSliceSegmentAddress>(1<<bitsSliceSegmentAddress))
915  {
916    bitsSliceSegmentAddress++;
917  }
918  const Int ctuTsAddress = pcSlice->getSliceSegmentCurStartCtuTsAddr();
919
920  //write slice address
921  const Int sliceSegmentRsAddress = pcSlice->getPic()->getPicSym()->getCtuTsToRsAddrMap(ctuTsAddress);
922
923  WRITE_FLAG( sliceSegmentRsAddress==0, "first_slice_segment_in_pic_flag" );
924  if ( pcSlice->getRapPicFlag() )
925  {
926    WRITE_FLAG( pcSlice->getNoOutputPriorPicsFlag() ? 1 : 0, "no_output_of_prior_pics_flag" );
927  }
928  WRITE_UVLC( pcSlice->getPPS()->getPPSId(), "slice_pic_parameter_set_id" );
929  if ( pcSlice->getPPS()->getDependentSliceSegmentsEnabledFlag() && (sliceSegmentRsAddress!=0) )
930  {
931    WRITE_FLAG( pcSlice->getDependentSliceSegmentFlag() ? 1 : 0, "dependent_slice_segment_flag" );
932  }
933  if(sliceSegmentRsAddress>0)
934  {
935    WRITE_CODE( sliceSegmentRsAddress, bitsSliceSegmentAddress, "slice_segment_address" );
936  }
937  if ( !pcSlice->getDependentSliceSegmentFlag() )
938  {
939#if SVC_EXTENSION
940    Int iBits = 0;
941    if(pcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits)
942    {
943      assert(!!"discardable_flag");
944
945      if (pcSlice->getDiscardableFlag())
946      {
947        assert(pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TRAIL_R &&
948          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TSA_R &&
949          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_STSA_R &&
950          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RADL_R &&
951          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RASL_R);
952      }
953
954      WRITE_FLAG(pcSlice->getDiscardableFlag(), "discardable_flag");
955      iBits++;
956    }
957
958    if( pcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits )
959    {
960      assert(!!"cross_layer_bla_flag");
961      WRITE_FLAG(pcSlice->getCrossLayerBLAFlag(), "cross_layer_bla_flag");
962      iBits++;
963    }
964
965    for (; iBits < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); iBits++)
966    {
967      assert(!!"slice_reserved_undetermined_flag[]");
968      WRITE_FLAG(0, "slice_reserved_undetermined_flag[]");
969    }
970#else //SVC_EXTENSION
971    for (Int i = 0; i < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
972    {
973      WRITE_FLAG(0, "slice_reserved_flag[]");
974    }
975#endif //SVC_EXTENSION
976
977    WRITE_UVLC( pcSlice->getSliceType(),       "slice_type" );
978
979    if( pcSlice->getPPS()->getOutputFlagPresentFlag() )
980    {
981      WRITE_FLAG( pcSlice->getPicOutputFlag() ? 1 : 0, "pic_output_flag" );
982    }
983
984#if SVC_EXTENSION
985    if( (pcSlice->getLayerId() > 0 && !pcSlice->getVPS()->getPocLsbNotPresentFlag( pcSlice->getVPS()->getLayerIdxInVps(pcSlice->getLayerId())) ) || !pcSlice->getIdrPicFlag())
986#else
987    if( !pcSlice->getIdrPicFlag() )
988#endif
989    {
990#if SVC_POC
991      Int picOrderCntLSB;
992      if( pcSlice->getPocResetIdc() == 2 )  // i.e. the LSB is reset
993      {
994        picOrderCntLSB = pcSlice->getPicOrderCntLsb();  // This will be the LSB value w.r.t to the previous POC reset period.
995      }
996      else
997      {
998        picOrderCntLSB = (pcSlice->getPOC() + (1<<pcSlice->getSPS()->getBitsForPOC())) & ((1<<pcSlice->getSPS()->getBitsForPOC())-1);
999      }
1000#else
1001      Int picOrderCntLSB = (pcSlice->getPOC()-pcSlice->getLastIDR()+(1<<pcSlice->getSPS()->getBitsForPOC())) & ((1<<pcSlice->getSPS()->getBitsForPOC())-1);
1002#endif
1003      WRITE_CODE( picOrderCntLSB, pcSlice->getSPS()->getBitsForPOC(), "slice_pic_order_cnt_lsb");
1004
1005#if SVC_EXTENSION
1006    }
1007    if( !pcSlice->getIdrPicFlag() )
1008    {
1009#endif
1010      const TComReferencePictureSet* rps = pcSlice->getRPS();
1011
1012      // check for bitstream restriction stating that:
1013      // If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
1014      // Ideally this process should not be repeated for each slice in a picture
1015#if SVC_EXTENSION
1016      if( pcSlice->getLayerId() == 0 )
1017#endif
1018      if (pcSlice->isIRAP())
1019      {
1020        for (Int picIdx = 0; picIdx < rps->getNumberOfPictures(); picIdx++)
1021        {
1022          assert (!rps->getUsed(picIdx));
1023        }
1024      }
1025
1026      if(pcSlice->getRPSidx() < 0)
1027      {
1028        WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag");
1029        codeShortTermRefPicSet( rps, true, pcSlice->getSPS()->getRPSList()->getNumberOfReferencePictureSets());
1030      }
1031      else
1032      {
1033        WRITE_FLAG( 1, "short_term_ref_pic_set_sps_flag");
1034        Int numBits = 0;
1035        while ((1 << numBits) < pcSlice->getSPS()->getRPSList()->getNumberOfReferencePictureSets())
1036        {
1037          numBits++;
1038        }
1039        if (numBits > 0)
1040        {
1041          WRITE_CODE( pcSlice->getRPSidx(), numBits, "short_term_ref_pic_set_idx" );
1042        }
1043      }
1044      if(pcSlice->getSPS()->getLongTermRefsPresent())
1045      {
1046        Int numLtrpInSH = rps->getNumberOfLongtermPictures();
1047        Int ltrpInSPS[MAX_NUM_REF_PICS];
1048        Int numLtrpInSPS = 0;
1049        UInt ltrpIndex;
1050        Int counter = 0;
1051        // WARNING: The following code only works only if a matching long-term RPS is
1052        //          found in the SPS for ALL long-term pictures
1053        //          The problem is that the SPS coded long-term pictures are moved to the
1054        //          beginning of the list which causes a mismatch when no reference picture
1055        //          list reordering is used
1056        //          NB: Long-term coding is currently not supported in general by the HM encoder
1057        for(Int k = rps->getNumberOfPictures()-1; k > rps->getNumberOfPictures()-rps->getNumberOfLongtermPictures()-1; k--)
1058        {
1059          if (findMatchingLTRP(pcSlice, &ltrpIndex, rps->getPOC(k), rps->getUsed(k)))
1060          {
1061            ltrpInSPS[numLtrpInSPS] = ltrpIndex;
1062            numLtrpInSPS++;
1063          }
1064          else
1065          {
1066            counter++;
1067          }
1068        }
1069        numLtrpInSH -= numLtrpInSPS;
1070        // check that either all long-term pictures are coded in SPS or in slice header (no mixing)
1071        assert (numLtrpInSH==0 || numLtrpInSPS==0); 
1072
1073        Int bitsForLtrpInSPS = 0;
1074        while (pcSlice->getSPS()->getNumLongTermRefPicSPS() > (1 << bitsForLtrpInSPS))
1075        {
1076          bitsForLtrpInSPS++;
1077        }
1078        if (pcSlice->getSPS()->getNumLongTermRefPicSPS() > 0)
1079        {
1080          WRITE_UVLC( numLtrpInSPS, "num_long_term_sps");
1081        }
1082        WRITE_UVLC( numLtrpInSH, "num_long_term_pics");
1083        // Note that the LSBs of the LT ref. pic. POCs must be sorted before.
1084        // Not sorted here because LT ref indices will be used in setRefPicList()
1085        Int prevDeltaMSB = 0, prevLSB = 0;
1086        Int offset = rps->getNumberOfNegativePictures() + rps->getNumberOfPositivePictures();
1087        counter = 0;
1088        // Warning: If some pictures are moved to ltrpInSPS, i is referring to a wrong index
1089        //          (mapping would be required)
1090        for(Int i=rps->getNumberOfPictures()-1 ; i > offset-1; i--, counter++)
1091        {
1092          if (counter < numLtrpInSPS)
1093          {
1094            if (bitsForLtrpInSPS > 0)
1095            {
1096              WRITE_CODE( ltrpInSPS[counter], bitsForLtrpInSPS, "lt_idx_sps[i]");
1097            }
1098          }
1099          else
1100          {
1101            WRITE_CODE( rps->getPocLSBLT(i), pcSlice->getSPS()->getBitsForPOC(), "poc_lsb_lt");
1102            WRITE_FLAG( rps->getUsed(i), "used_by_curr_pic_lt_flag");
1103          }
1104          WRITE_FLAG( rps->getDeltaPocMSBPresentFlag(i), "delta_poc_msb_present_flag");
1105
1106          if(rps->getDeltaPocMSBPresentFlag(i))
1107          {
1108            Bool deltaFlag = false;
1109            //  First LTRP from SPS                 ||  First LTRP from SH                              || curr LSB            != prev LSB
1110            if( (i == rps->getNumberOfPictures()-1) || (i == rps->getNumberOfPictures()-1-numLtrpInSPS) || (rps->getPocLSBLT(i) != prevLSB) )
1111            {
1112              deltaFlag = true;
1113            }
1114            if(deltaFlag)
1115            {
1116              WRITE_UVLC( rps->getDeltaPocMSBCycleLT(i), "delta_poc_msb_cycle_lt[i]" );
1117            }
1118            else
1119            {
1120              Int differenceInDeltaMSB = rps->getDeltaPocMSBCycleLT(i) - prevDeltaMSB;
1121              assert(differenceInDeltaMSB >= 0);
1122              WRITE_UVLC( differenceInDeltaMSB, "delta_poc_msb_cycle_lt[i]" );
1123            }
1124            prevLSB = rps->getPocLSBLT(i);
1125            prevDeltaMSB = rps->getDeltaPocMSBCycleLT(i);
1126          }
1127        }
1128      }
1129      if (pcSlice->getSPS()->getTMVPFlagsPresent())
1130      {
1131        WRITE_FLAG( pcSlice->getEnableTMVPFlag() ? 1 : 0, "slice_temporal_mvp_enabled_flag" );
1132      }
1133    }
1134
1135#if SVC_EXTENSION
1136    if((pcSlice->getLayerId() > 0) && !(pcSlice->getVPS()->getIlpSshSignalingEnabledFlag()) && (pcSlice->getNumILRRefIdx() > 0) )
1137    {
1138      WRITE_FLAG(pcSlice->getInterLayerPredEnabledFlag(),"inter_layer_pred_enabled_flag");
1139      if( pcSlice->getInterLayerPredEnabledFlag())
1140      {
1141        if(pcSlice->getNumILRRefIdx() > 1)
1142        {
1143          Int numBits = 1;
1144          while ((1 << numBits) < pcSlice->getNumILRRefIdx())
1145          {
1146            numBits++;
1147          }
1148          if( !pcSlice->getVPS()->getMaxOneActiveRefLayerFlag()) 
1149          {
1150            WRITE_CODE(pcSlice->getActiveNumILRRefIdx() - 1, numBits,"num_inter_layer_ref_pics_minus1");
1151          }       
1152
1153          if( pcSlice->getNumILRRefIdx() != pcSlice->getActiveNumILRRefIdx() )
1154          {
1155            for(Int i = 0; i < pcSlice->getActiveNumILRRefIdx(); i++ )
1156            {
1157              WRITE_CODE(pcSlice->getInterLayerPredLayerIdc(i),numBits,"inter_layer_pred_layer_idc[i]");   
1158            }
1159          }
1160        }
1161      }
1162    }     
1163#endif //SVC_EXTENSION
1164
1165    if(pcSlice->getSPS()->getUseSAO())
1166    {
1167       WRITE_FLAG( pcSlice->getSaoEnabledFlag(CHANNEL_TYPE_LUMA), "slice_sao_luma_flag" );
1168       if (chromaEnabled)
1169       {
1170         WRITE_FLAG( pcSlice->getSaoEnabledFlag(CHANNEL_TYPE_CHROMA), "slice_sao_chroma_flag" );
1171       }
1172    }
1173
1174    //check if numrefidxes match the defaults. If not, override
1175
1176    if (!pcSlice->isIntra())
1177    {
1178      Bool overrideFlag = (pcSlice->getNumRefIdx( REF_PIC_LIST_0 )!=pcSlice->getPPS()->getNumRefIdxL0DefaultActive()||(pcSlice->isInterB()&&pcSlice->getNumRefIdx( REF_PIC_LIST_1 )!=pcSlice->getPPS()->getNumRefIdxL1DefaultActive()));
1179      WRITE_FLAG( overrideFlag ? 1 : 0,                               "num_ref_idx_active_override_flag");
1180      if (overrideFlag)
1181      {
1182        WRITE_UVLC( pcSlice->getNumRefIdx( REF_PIC_LIST_0 ) - 1,      "num_ref_idx_l0_active_minus1" );
1183        if (pcSlice->isInterB())
1184        {
1185          WRITE_UVLC( pcSlice->getNumRefIdx( REF_PIC_LIST_1 ) - 1,    "num_ref_idx_l1_active_minus1" );
1186        }
1187        else
1188        {
1189          pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
1190        }
1191      }
1192    }
1193    else
1194    {
1195      pcSlice->setNumRefIdx(REF_PIC_LIST_0, 0);
1196      pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
1197    }
1198
1199    if( pcSlice->getPPS()->getListsModificationPresentFlag() && pcSlice->getNumRpsCurrTempList() > 1)
1200    {
1201      TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
1202      if(!pcSlice->isIntra())
1203      {
1204        WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0() ? 1 : 0,       "ref_pic_list_modification_flag_l0" );
1205        if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0())
1206        {
1207          Int numRpsCurrTempList0 = pcSlice->getNumRpsCurrTempList();
1208          if (numRpsCurrTempList0 > 1)
1209          {
1210            Int length = 1;
1211            numRpsCurrTempList0 --;
1212            while ( numRpsCurrTempList0 >>= 1)
1213            {
1214              length ++;
1215            }
1216            for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_0 ); i++)
1217            {
1218              WRITE_CODE( refPicListModification->getRefPicSetIdxL0(i), length, "list_entry_l0");
1219            }
1220          }
1221        }
1222      }
1223      if(pcSlice->isInterB())
1224      {
1225        WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1() ? 1 : 0,       "ref_pic_list_modification_flag_l1" );
1226        if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1())
1227        {
1228          Int numRpsCurrTempList1 = pcSlice->getNumRpsCurrTempList();
1229          if ( numRpsCurrTempList1 > 1 )
1230          {
1231            Int length = 1;
1232            numRpsCurrTempList1 --;
1233            while ( numRpsCurrTempList1 >>= 1)
1234            {
1235              length ++;
1236            }
1237            for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_1 ); i++)
1238            {
1239              WRITE_CODE( refPicListModification->getRefPicSetIdxL1(i), length, "list_entry_l1");
1240            }
1241          }
1242        }
1243      }
1244    }
1245
1246    if (pcSlice->isInterB())
1247    {
1248      WRITE_FLAG( pcSlice->getMvdL1ZeroFlag() ? 1 : 0,   "mvd_l1_zero_flag");
1249    }
1250
1251    if(!pcSlice->isIntra())
1252    {
1253      if (!pcSlice->isIntra() && pcSlice->getPPS()->getCabacInitPresentFlag())
1254      {
1255        SliceType sliceType   = pcSlice->getSliceType();
1256        SliceType  encCABACTableIdx = pcSlice->getEncCABACTableIdx();
1257        Bool encCabacInitFlag = (sliceType!=encCABACTableIdx && encCABACTableIdx!=I_SLICE) ? true : false;
1258        pcSlice->setCabacInitFlag( encCabacInitFlag );
1259        WRITE_FLAG( encCabacInitFlag?1:0, "cabac_init_flag" );
1260      }
1261    }
1262
1263    if ( pcSlice->getEnableTMVPFlag() )
1264    {
1265      if ( pcSlice->getSliceType() == B_SLICE )
1266      {
1267        WRITE_FLAG( pcSlice->getColFromL0Flag(), "collocated_from_l0_flag" );
1268      }
1269
1270      if ( pcSlice->getSliceType() != I_SLICE &&
1271        ((pcSlice->getColFromL0Flag()==1 && pcSlice->getNumRefIdx(REF_PIC_LIST_0)>1)||
1272        (pcSlice->getColFromL0Flag()==0  && pcSlice->getNumRefIdx(REF_PIC_LIST_1)>1)))
1273      {
1274        WRITE_UVLC( pcSlice->getColRefIdx(), "collocated_ref_idx" );
1275      }
1276    }
1277    if ( (pcSlice->getPPS()->getUseWP() && pcSlice->getSliceType()==P_SLICE) || (pcSlice->getPPS()->getWPBiPred() && pcSlice->getSliceType()==B_SLICE) )
1278    {
1279      xCodePredWeightTable( pcSlice );
1280    }
1281    assert(pcSlice->getMaxNumMergeCand()<=MRG_MAX_NUM_CANDS);
1282    if (!pcSlice->isIntra())
1283    {
1284      WRITE_UVLC(MRG_MAX_NUM_CANDS - pcSlice->getMaxNumMergeCand(), "five_minus_max_num_merge_cand");
1285    }
1286    Int iCode = pcSlice->getSliceQp() - ( pcSlice->getPPS()->getPicInitQPMinus26() + 26 );
1287    WRITE_SVLC( iCode, "slice_qp_delta" );
1288    if (pcSlice->getPPS()->getSliceChromaQpFlag())
1289    {
1290      if (numberValidComponents > COMPONENT_Cb)
1291      {
1292        WRITE_SVLC( pcSlice->getSliceChromaQpDelta(COMPONENT_Cb), "slice_cb_qp_offset" );
1293      }
1294      if (numberValidComponents > COMPONENT_Cr)
1295      {
1296        WRITE_SVLC( pcSlice->getSliceChromaQpDelta(COMPONENT_Cr), "slice_cr_qp_offset" );
1297      }
1298      assert(numberValidComponents <= COMPONENT_Cr+1);
1299    }
1300
1301    if (pcSlice->getPPS()->getPpsRangeExtension().getChromaQpOffsetListEnabledFlag())
1302    {
1303      WRITE_FLAG(pcSlice->getUseChromaQpAdj(), "cu_chroma_qp_offset_enabled_flag");
1304    }
1305
1306    if (pcSlice->getPPS()->getDeblockingFilterControlPresentFlag())
1307    {
1308      if (pcSlice->getPPS()->getDeblockingFilterOverrideEnabledFlag() )
1309      {
1310        WRITE_FLAG(pcSlice->getDeblockingFilterOverrideFlag(), "deblocking_filter_override_flag");
1311      }
1312      if (pcSlice->getDeblockingFilterOverrideFlag())
1313      {
1314        WRITE_FLAG(pcSlice->getDeblockingFilterDisable(), "slice_disable_deblocking_filter_flag");
1315        if(!pcSlice->getDeblockingFilterDisable())
1316        {
1317          WRITE_SVLC (pcSlice->getDeblockingFilterBetaOffsetDiv2(), "slice_beta_offset_div2");
1318          WRITE_SVLC (pcSlice->getDeblockingFilterTcOffsetDiv2(),   "slice_tc_offset_div2");
1319        }
1320      }
1321    }
1322
1323    Bool isSAOEnabled = pcSlice->getSPS()->getUseSAO() && (pcSlice->getSaoEnabledFlag(CHANNEL_TYPE_LUMA) || (chromaEnabled && pcSlice->getSaoEnabledFlag(CHANNEL_TYPE_CHROMA)));
1324    Bool isDBFEnabled = (!pcSlice->getDeblockingFilterDisable());
1325
1326    if(pcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag() && ( isSAOEnabled || isDBFEnabled ))
1327    {
1328      WRITE_FLAG(pcSlice->getLFCrossSliceBoundaryFlag()?1:0, "slice_loop_filter_across_slices_enabled_flag");
1329    }
1330  }
1331#if !SVC_EXTENSION
1332  if(pcSlice->getPPS()->getSliceHeaderExtensionPresentFlag())
1333  {
1334    WRITE_UVLC(0,"slice_segment_header_extension_length");
1335  }
1336#endif
1337}
1338
1339Void TEncCavlc::codePTL( const TComPTL* pcPTL, Bool profilePresentFlag, Int maxNumSubLayersMinus1)
1340{
1341  if(profilePresentFlag)
1342  {
1343    codeProfileTier(pcPTL->getGeneralPTL(), false);    // general_...
1344  }
1345  WRITE_CODE( Int(pcPTL->getGeneralPTL()->getLevelIdc()), 8, "general_level_idc" );
1346
1347  for (Int i = 0; i < maxNumSubLayersMinus1; i++)
1348  {
1349    WRITE_FLAG( pcPTL->getSubLayerProfilePresentFlag(i), "sub_layer_profile_present_flag[i]" );
1350    WRITE_FLAG( pcPTL->getSubLayerLevelPresentFlag(i),   "sub_layer_level_present_flag[i]" );
1351  }
1352
1353  if (maxNumSubLayersMinus1 > 0)
1354  {
1355    for (Int i = maxNumSubLayersMinus1; i < 8; i++)
1356    {
1357      WRITE_CODE(0, 2, "reserved_zero_2bits");
1358    }
1359  }
1360
1361  for(Int i = 0; i < maxNumSubLayersMinus1; i++)
1362  {
1363    if( pcPTL->getSubLayerProfilePresentFlag(i) )
1364    {
1365      codeProfileTier(pcPTL->getSubLayerPTL(i), true);  // sub_layer_...
1366    }
1367    if( pcPTL->getSubLayerLevelPresentFlag(i) )
1368    {
1369      WRITE_CODE( Int(pcPTL->getSubLayerPTL(i)->getLevelIdc()), 8, "sub_layer_level_idc[i]" );
1370    }
1371  }
1372}
1373
1374#if ENC_DEC_TRACE || RExt__DECODER_DEBUG_BIT_STATISTICS
1375Void TEncCavlc::codeProfileTier( const ProfileTierLevel* ptl, const Bool bIsSubLayer )
1376#define PTL_TRACE_TEXT(txt) bIsSubLayer?("sub_layer_" txt) : ("general_" txt)
1377#else
1378Void TEncCavlc::codeProfileTier( const ProfileTierLevel* ptl, const Bool /*bIsSubLayer*/ )
1379#define PTL_TRACE_TEXT(txt) txt
1380#endif
1381{
1382  WRITE_CODE( ptl->getProfileSpace(), 2 ,      PTL_TRACE_TEXT("profile_space"                   ));
1383  WRITE_FLAG( ptl->getTierFlag()==Level::HIGH, PTL_TRACE_TEXT("tier_flag"                       ));
1384#if SVC_EXTENSION
1385  WRITE_CODE( (ptl->getProfileIdc() == Profile::SCALABLEMAIN || ptl->getProfileIdc() == Profile::SCALABLEMAIN10) ? 7 : Int(ptl->getProfileIdc()), 5 ,  PTL_TRACE_TEXT("profile_idc")  );
1386#else
1387  WRITE_CODE( Int(ptl->getProfileIdc()), 5 ,   PTL_TRACE_TEXT("profile_idc"                     ));
1388#endif
1389  for(Int j = 0; j < 32; j++)
1390  {
1391    WRITE_FLAG( ptl->getProfileCompatibilityFlag(j), PTL_TRACE_TEXT("profile_compatibility_flag[][j]" ));
1392  }
1393
1394  WRITE_FLAG(ptl->getProgressiveSourceFlag(),   PTL_TRACE_TEXT("progressive_source_flag"         ));
1395  WRITE_FLAG(ptl->getInterlacedSourceFlag(),    PTL_TRACE_TEXT("interlaced_source_flag"          ));
1396  WRITE_FLAG(ptl->getNonPackedConstraintFlag(), PTL_TRACE_TEXT("non_packed_constraint_flag"      ));
1397  WRITE_FLAG(ptl->getFrameOnlyConstraintFlag(), PTL_TRACE_TEXT("frame_only_constraint_flag"      ));
1398
1399  if (ptl->getProfileIdc() == Profile::MAINREXT || ptl->getProfileIdc() == Profile::HIGHTHROUGHPUTREXT )
1400  {
1401    const UInt         bitDepthConstraint=ptl->getBitDepthConstraint();
1402    WRITE_FLAG(bitDepthConstraint<=12,          PTL_TRACE_TEXT("max_12bit_constraint_flag"       ));
1403    WRITE_FLAG(bitDepthConstraint<=10,          PTL_TRACE_TEXT("max_10bit_constraint_flag"       ));
1404    WRITE_FLAG(bitDepthConstraint<= 8,          PTL_TRACE_TEXT("max_8bit_constraint_flag"        ));
1405    const ChromaFormat chromaFmtConstraint=ptl->getChromaFormatConstraint();
1406    WRITE_FLAG(chromaFmtConstraint==CHROMA_422||chromaFmtConstraint==CHROMA_420||chromaFmtConstraint==CHROMA_400, PTL_TRACE_TEXT("max_422chroma_constraint_flag" ));
1407    WRITE_FLAG(chromaFmtConstraint==CHROMA_420||chromaFmtConstraint==CHROMA_400,                                  PTL_TRACE_TEXT("max_420chroma_constraint_flag" ));
1408    WRITE_FLAG(chromaFmtConstraint==CHROMA_400,                                                                   PTL_TRACE_TEXT("max_monochrome_constraint_flag"));
1409    WRITE_FLAG(ptl->getIntraConstraintFlag(),        PTL_TRACE_TEXT("intra_constraint_flag"           ));
1410    WRITE_FLAG(0,                                    PTL_TRACE_TEXT("one_picture_only_constraint_flag"));
1411    WRITE_FLAG(ptl->getLowerBitRateConstraintFlag(), PTL_TRACE_TEXT("lower_bit_rate_constraint_flag"  ));
1412#if SVC_EXTENSION
1413    WRITE_CODE(0, 32,  "general_reserved_zero_34bits");  WRITE_CODE(0, 2,  "general_reserved_zero_34bits");
1414  }
1415  else if( ptl->getProfileIdc() == Profile::SCALABLEMAIN || ptl->getProfileIdc() == Profile::SCALABLEMAIN10 )      // at encoder side, scalable-main10 profile has a profile idc equal to 8, which is converted to 7 during signalling
1416  {
1417    WRITE_FLAG(true,   "general_max_12bit_constraint_flag");
1418    WRITE_FLAG(true,   "general_max_10bit_constraint_flag");
1419    WRITE_FLAG((ptl->getProfileIdc() == Profile::SCALABLEMAIN) ? true : false, "general_max_8bit_constraint_flag");
1420    WRITE_FLAG(true,   "general_max_422chroma_constraint_flag");
1421    WRITE_FLAG(true,   "general_max_420chroma_constraint_flag");
1422    WRITE_FLAG(false,  "general_max_monochrome_constraint_flag");
1423    WRITE_FLAG(false,  "general_intra_constraint_flag");
1424    WRITE_FLAG(false,  "general_one_picture_only_constraint_flag");
1425    WRITE_FLAG(true,   "general_lower_bit_rate_constraint_flag");
1426    WRITE_CODE(0, 32,  "general_reserved_zero_34bits");  WRITE_CODE(0, 2,  "general_reserved_zero_34bits");
1427  }
1428  else
1429  {
1430    WRITE_CODE(0, 32,  "general_reserved_zero_43bits");  WRITE_CODE(0, 11,  "general_reserved_zero_43bits");
1431  }
1432#else
1433    WRITE_CODE(0 , 16, PTL_TRACE_TEXT("reserved_zero_34bits[0..15]"     ));
1434    WRITE_CODE(0 , 16, PTL_TRACE_TEXT("reserved_zero_34bits[16..31]"    ));
1435    WRITE_CODE(0 ,  2, PTL_TRACE_TEXT("reserved_zero_34bits[32..33]"    ));
1436  }
1437  else
1438  {
1439    WRITE_CODE(0x0000 , 16, PTL_TRACE_TEXT("reserved_zero_43bits[0..15]"     ));
1440    WRITE_CODE(0x0000 , 16, PTL_TRACE_TEXT("reserved_zero_43bits[16..31]"    ));
1441    WRITE_CODE(0x000  , 11, PTL_TRACE_TEXT("reserved_zero_43bits[32..42]"    ));
1442  }
1443#endif
1444  WRITE_FLAG(false,   PTL_TRACE_TEXT("inbld_flag" ));
1445#undef PTL_TRACE_TEXT
1446}
1447
1448/**
1449 * Write tiles and wavefront substreams sizes for the slice header (entry points).
1450 *
1451 * \param pSlice TComSlice structure that contains the substream size information.
1452 */
1453Void  TEncCavlc::codeTilesWPPEntryPoint( TComSlice* pSlice )
1454{
1455  if (!pSlice->getPPS()->getTilesEnabledFlag() && !pSlice->getPPS()->getEntropyCodingSyncEnabledFlag())
1456  {
1457    return;
1458  }
1459  UInt maxOffset = 0;
1460  for(Int idx=0; idx<pSlice->getNumberOfSubstreamSizes(); idx++)
1461  {
1462    UInt offset=pSlice->getSubstreamSize(idx);
1463    if ( offset > maxOffset )
1464    {
1465      maxOffset = offset;
1466    }
1467  }
1468
1469  // Determine number of bits "offsetLenMinus1+1" required for entry point information
1470  UInt offsetLenMinus1 = 0;
1471  while (maxOffset >= (1u << (offsetLenMinus1 + 1)))
1472  {
1473    offsetLenMinus1++;
1474    assert(offsetLenMinus1 + 1 < 32);
1475  }
1476
1477  WRITE_UVLC(pSlice->getNumberOfSubstreamSizes(), "num_entry_point_offsets");
1478  if (pSlice->getNumberOfSubstreamSizes()>0)
1479  {
1480    WRITE_UVLC(offsetLenMinus1, "offset_len_minus1");
1481
1482    for (UInt idx=0; idx<pSlice->getNumberOfSubstreamSizes(); idx++)
1483    {
1484      WRITE_CODE(pSlice->getSubstreamSize(idx)-1, offsetLenMinus1+1, "entry_point_offset_minus1");
1485    }
1486  }
1487}
1488
1489Void TEncCavlc::codeTerminatingBit      ( UInt /*uilsLast*/ )
1490{
1491}
1492
1493Void TEncCavlc::codeSliceFinish ()
1494{
1495}
1496
1497Void TEncCavlc::codeMVPIdx ( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, RefPicList /*eRefList*/ )
1498{
1499  assert(0);
1500}
1501
1502Void TEncCavlc::codePartSize( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
1503{
1504  assert(0);
1505}
1506
1507Void TEncCavlc::codePredMode( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/ )
1508{
1509  assert(0);
1510}
1511
1512Void TEncCavlc::codeMergeFlag    ( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/ )
1513{
1514  assert(0);
1515}
1516
1517Void TEncCavlc::codeMergeIndex    ( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/ )
1518{
1519  assert(0);
1520}
1521
1522Void TEncCavlc::codeInterModeFlag( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/, UInt /*uiEncMode*/ )
1523{
1524  assert(0);
1525}
1526
1527Void TEncCavlc::codeCUTransquantBypassFlag( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/ )
1528{
1529  assert(0);
1530}
1531
1532Void TEncCavlc::codeSkipFlag( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/ )
1533{
1534  assert(0);
1535}
1536
1537Void TEncCavlc::codeSplitFlag   ( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
1538{
1539  assert(0);
1540}
1541
1542Void TEncCavlc::codeTransformSubdivFlag( UInt /*uiSymbol*/, UInt /*uiCtx*/ )
1543{
1544  assert(0);
1545}
1546
1547Void TEncCavlc::codeQtCbf( TComTU& /*rTu*/, const ComponentID /*compID*/, const Bool /*lowestLevel*/ )
1548{
1549  assert(0);
1550}
1551
1552Void TEncCavlc::codeQtRootCbf( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/ )
1553{
1554  assert(0);
1555}
1556
1557Void TEncCavlc::codeQtCbfZero( TComTU& /*rTu*/, const ChannelType /*chType*/ )
1558{
1559  assert(0);
1560}
1561Void TEncCavlc::codeQtRootCbfZero( )
1562{
1563  assert(0);
1564}
1565
1566Void TEncCavlc::codeTransformSkipFlags (TComTU& /*rTu*/, ComponentID /*component*/ )
1567{
1568  assert(0);
1569}
1570
1571/** Code I_PCM information.
1572 * \param pcCU pointer to CU
1573 * \param uiAbsPartIdx CU index
1574 * \returns Void
1575 */
1576Void TEncCavlc::codeIPCMInfo( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/ )
1577{
1578  assert(0);
1579}
1580
1581Void TEncCavlc::codeIntraDirLumaAng( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, Bool /*isMultiple*/)
1582{
1583  assert(0);
1584}
1585
1586Void TEncCavlc::codeIntraDirChroma( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/ )
1587{
1588  assert(0);
1589}
1590
1591Void TEncCavlc::codeInterDir( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/ )
1592{
1593  assert(0);
1594}
1595
1596Void TEncCavlc::codeRefFrmIdx( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, RefPicList /*eRefList*/ )
1597{
1598  assert(0);
1599}
1600
1601Void TEncCavlc::codeMvd( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, RefPicList /*eRefList*/ )
1602{
1603  assert(0);
1604}
1605
1606Void TEncCavlc::codeCrossComponentPrediction( TComTU& /*rTu*/, ComponentID /*compID*/ )
1607{
1608  assert(0);
1609}
1610
1611Void TEncCavlc::codeDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx )
1612{
1613  Int iDQp  = pcCU->getQP( uiAbsPartIdx ) - pcCU->getRefQP( uiAbsPartIdx );
1614
1615#if SVC_EXTENSION
1616  Int qpBdOffsetY =  pcCU->getSlice()->getQpBDOffset(CHANNEL_TYPE_LUMA);
1617#else
1618  Int qpBdOffsetY =  pcCU->getSlice()->getSPS()->getQpBDOffset(CHANNEL_TYPE_LUMA);
1619#endif
1620  iDQp = (iDQp + 78 + qpBdOffsetY + (qpBdOffsetY/2)) % (52 + qpBdOffsetY) - 26 - (qpBdOffsetY/2);
1621
1622  xWriteSvlc( iDQp );
1623
1624  return;
1625}
1626
1627Void TEncCavlc::codeChromaQpAdjustment( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/ )
1628{
1629  assert(0);
1630}
1631
1632Void TEncCavlc::codeCoeffNxN    ( TComTU& /*rTu*/, TCoeff* /*pcCoef*/, const ComponentID /*compID*/ )
1633{
1634  assert(0);
1635}
1636
1637Void TEncCavlc::estBit( estBitsSbacStruct* /*pcEstBitsCabac*/, Int /*width*/, Int /*height*/, ChannelType /*chType*/ )
1638{
1639  // printf("error : no VLC mode support in this version\n");
1640  return;
1641}
1642
1643// ====================================================================================================================
1644// Protected member functions
1645// ====================================================================================================================
1646
1647//! Code weighted prediction tables
1648Void TEncCavlc::xCodePredWeightTable( TComSlice* pcSlice )
1649{
1650  WPScalingParam  *wp;
1651  const ChromaFormat    format                = pcSlice->getPic()->getChromaFormat();
1652  const UInt            numberValidComponents = getNumberValidComponents(format);
1653  const Bool            bChroma               = isChromaEnabled(format);
1654  const Int             iNbRef                = (pcSlice->getSliceType() == B_SLICE ) ? (2) : (1);
1655        Bool            bDenomCoded           = false;
1656        UInt            uiTotalSignalledWeightFlags = 0;
1657
1658  if ( (pcSlice->getSliceType()==P_SLICE && pcSlice->getPPS()->getUseWP()) || (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPred()) )
1659  {
1660    for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ ) // loop over l0 and l1 syntax elements
1661    {
1662      RefPicList  eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
1663
1664      // NOTE: wp[].uiLog2WeightDenom and wp[].bPresentFlag are actually per-channel-type settings.
1665
1666      for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
1667      {
1668        pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
1669        if ( !bDenomCoded )
1670        {
1671          Int iDeltaDenom;
1672          WRITE_UVLC( wp[COMPONENT_Y].uiLog2WeightDenom, "luma_log2_weight_denom" );
1673
1674          if( bChroma )
1675          {
1676            assert(wp[COMPONENT_Cb].uiLog2WeightDenom == wp[COMPONENT_Cr].uiLog2WeightDenom); // check the channel-type settings are consistent across components.
1677            iDeltaDenom = (wp[COMPONENT_Cb].uiLog2WeightDenom - wp[COMPONENT_Y].uiLog2WeightDenom);
1678            WRITE_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" );
1679          }
1680          bDenomCoded = true;
1681        }
1682        WRITE_FLAG( wp[COMPONENT_Y].bPresentFlag, iNumRef==0?"luma_weight_l0_flag[i]":"luma_weight_l1_flag[i]" );
1683        uiTotalSignalledWeightFlags += wp[COMPONENT_Y].bPresentFlag;
1684      }
1685      if (bChroma)
1686      {
1687        for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
1688        {
1689          pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
1690          assert(wp[COMPONENT_Cb].bPresentFlag == wp[COMPONENT_Cr].bPresentFlag); // check the channel-type settings are consistent across components.
1691          WRITE_FLAG( wp[COMPONENT_Cb].bPresentFlag, iNumRef==0?"chroma_weight_l0_flag[i]":"chroma_weight_l1_flag[i]" );
1692          uiTotalSignalledWeightFlags += 2*wp[COMPONENT_Cb].bPresentFlag;
1693        }
1694      }
1695
1696      for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
1697      {
1698        pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
1699        if ( wp[COMPONENT_Y].bPresentFlag )
1700        {
1701          Int iDeltaWeight = (wp[COMPONENT_Y].iWeight - (1<<wp[COMPONENT_Y].uiLog2WeightDenom));
1702          WRITE_SVLC( iDeltaWeight, iNumRef==0?"delta_luma_weight_l0[i]":"delta_luma_weight_l1[i]" );
1703          WRITE_SVLC( wp[COMPONENT_Y].iOffset, iNumRef==0?"luma_offset_l0[i]":"luma_offset_l1[i]" );
1704        }
1705
1706        if ( bChroma )
1707        {
1708          if ( wp[COMPONENT_Cb].bPresentFlag )
1709          {
1710            for ( Int j = COMPONENT_Cb ; j < numberValidComponents ; j++ )
1711            {
1712              assert(wp[COMPONENT_Cb].uiLog2WeightDenom == wp[COMPONENT_Cr].uiLog2WeightDenom);
1713              Int iDeltaWeight = (wp[j].iWeight - (1<<wp[COMPONENT_Cb].uiLog2WeightDenom));
1714              WRITE_SVLC( iDeltaWeight, iNumRef==0?"delta_chroma_weight_l0[i]":"delta_chroma_weight_l1[i]" );
1715
1716#if SVC_EXTENSION
1717              Int range=pcSlice->getSPS()->getSpsRangeExtension().getHighPrecisionOffsetsEnabledFlag() ? (1<<pcSlice->getBitDepth(CHANNEL_TYPE_CHROMA))/2 : 128;
1718#else
1719              Int range=pcSlice->getSPS()->getSpsRangeExtension().getHighPrecisionOffsetsEnabledFlag() ? (1<<pcSlice->getSPS()->getBitDepth(CHANNEL_TYPE_CHROMA))/2 : 128;
1720#endif
1721              Int pred = ( range - ( ( range*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) );
1722              Int iDeltaChroma = (wp[j].iOffset - pred);
1723              WRITE_SVLC( iDeltaChroma, iNumRef==0?"delta_chroma_offset_l0[i]":"delta_chroma_offset_l1[i]" );
1724            }
1725          }
1726        }
1727      }
1728    }
1729    assert(uiTotalSignalledWeightFlags<=24);
1730  }
1731}
1732
1733/** code quantization matrix
1734 *  \param scalingList quantization matrix information
1735 */
1736Void TEncCavlc::codeScalingList( const TComScalingList &scalingList )
1737{
1738  //for each size
1739  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
1740  {
1741    const Int predListStep = (sizeId == SCALING_LIST_32x32? (SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) : 1); // if 32x32, skip over chroma entries.
1742
1743    for(UInt listId = 0; listId < SCALING_LIST_NUM; listId+=predListStep)
1744    {
1745      Bool scalingListPredModeFlag = scalingList.getScalingListPredModeFlag(sizeId, listId);
1746      WRITE_FLAG( scalingListPredModeFlag, "scaling_list_pred_mode_flag" );
1747      if(!scalingListPredModeFlag)// Copy Mode
1748      {
1749        if (sizeId == SCALING_LIST_32x32)
1750        {
1751          // adjust the code, to cope with the missing chroma entries
1752          WRITE_UVLC( ((Int)listId - (Int)scalingList.getRefMatrixId (sizeId,listId)) / (SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES), "scaling_list_pred_matrix_id_delta");
1753        }
1754        else
1755        {
1756          WRITE_UVLC( (Int)listId - (Int)scalingList.getRefMatrixId (sizeId,listId), "scaling_list_pred_matrix_id_delta");
1757        }
1758      }
1759      else// DPCM Mode
1760      {
1761        xCodeScalingList(&scalingList, sizeId, listId);
1762      }
1763    }
1764  }
1765  return;
1766}
1767/** code DPCM
1768 * \param scalingList quantization matrix information
1769 * \param sizeId      size index
1770 * \param listId      list index
1771 */
1772Void TEncCavlc::xCodeScalingList(const TComScalingList* scalingList, UInt sizeId, UInt listId)
1773{
1774  Int coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
1775  UInt* scan  = g_scanOrder[SCAN_UNGROUPED][SCAN_DIAG][sizeId==0 ? 2 : 3][sizeId==0 ? 2 : 3];
1776  Int nextCoef = SCALING_LIST_START_VALUE;
1777  Int data;
1778  const Int *src = scalingList->getScalingListAddress(sizeId, listId);
1779    if( sizeId > SCALING_LIST_8x8 )
1780    {
1781      WRITE_SVLC( scalingList->getScalingListDC(sizeId,listId) - 8, "scaling_list_dc_coef_minus8");
1782      nextCoef = scalingList->getScalingListDC(sizeId,listId);
1783    }
1784    for(Int i=0;i<coefNum;i++)
1785    {
1786      data = src[scan[i]] - nextCoef;
1787      nextCoef = src[scan[i]];
1788      if(data > 127)
1789      {
1790        data = data - 256;
1791      }
1792      if(data < -128)
1793      {
1794        data = data + 256;
1795      }
1796
1797      WRITE_SVLC( data,  "scaling_list_delta_coef");
1798    }
1799}
1800Bool TEncCavlc::findMatchingLTRP ( TComSlice* pcSlice, UInt *ltrpsIndex, Int ltrpPOC, Bool usedFlag )
1801{
1802  // Bool state = true, state2 = false;
1803  Int lsb = ltrpPOC & ((1<<pcSlice->getSPS()->getBitsForPOC())-1);
1804  for (Int k = 0; k < pcSlice->getSPS()->getNumLongTermRefPicSPS(); k++)
1805  {
1806    if ( (lsb == pcSlice->getSPS()->getLtRefPicPocLsbSps(k)) && (usedFlag == pcSlice->getSPS()->getUsedByCurrPicLtSPSFlag(k)) )
1807    {
1808      *ltrpsIndex = k;
1809      return true;
1810    }
1811  }
1812  return false;
1813}
1814
1815Void TEncCavlc::codeExplicitRdpcmMode( TComTU& /*rTu*/, const ComponentID /*compID*/ )
1816 {
1817   assert(0);
1818 }
1819
1820#if SVC_EXTENSION
1821Void TEncCavlc::codeSliceHeaderExtn( TComSlice* slice, Int shBitsWrittenTillNow )
1822{
1823  Int tmpBitsBeforeWriting = getNumberOfWrittenBits();
1824  Int maxPocLsb = 1 << slice->getSPS()->getBitsForPOC();
1825  if(slice->getPPS()->getSliceHeaderExtensionPresentFlag())
1826  {
1827    // Derive the value of PocMsbValRequiredFlag
1828    slice->setPocMsbValRequiredFlag( (slice->getCraPicFlag() || slice->getBlaPicFlag())
1829                                  && (!slice->getVPS()->getVpsPocLsbAlignedFlag() ||
1830                                      (slice->getVPS()->getVpsPocLsbAlignedFlag() && slice->getVPS()->getNumDirectRefLayers(slice->getLayerId()) == 0))
1831                                   );
1832
1833    // Determine value of SH extension length.
1834    Int shExtnLengthInBit = 0;
1835    if( slice->getPPS()->getPocResetInfoPresentFlag() )
1836    {
1837      shExtnLengthInBit += 2;
1838    }
1839
1840    if( slice->getPocResetIdc() > 0 )
1841    {
1842      shExtnLengthInBit += 6;
1843    }
1844
1845    if( slice->getPocResetIdc() == 3 )
1846    {
1847      shExtnLengthInBit += (slice->getSPS()->getBitsForPOC() + 1);
1848    }
1849
1850    if( !slice->getPocMsbValRequiredFlag() && slice->getVPS()->getVpsPocLsbAlignedFlag() )
1851    {
1852      shExtnLengthInBit++;
1853    }
1854    else
1855    {
1856      if( slice->getPocMsbValRequiredFlag() )
1857      {
1858        slice->setPocMsbValPresentFlag( true );
1859      }
1860      else
1861      {
1862        slice->setPocMsbValPresentFlag( false );
1863      }
1864    }
1865
1866    if( slice->getPocMsbNeeded() )
1867    {
1868      slice->setPocMsbValPresentFlag(true);
1869    }
1870
1871    if( slice->getPocMsbValPresentFlag() )
1872    {
1873      UInt lengthVal = 1;
1874      UInt tempVal = (slice->getPocMsbVal() / maxPocLsb) + 1;
1875      assert ( tempVal );
1876      while( 1 != tempVal )
1877      {
1878        tempVal >>= 1;
1879        lengthVal += 2;
1880      }
1881      shExtnLengthInBit += lengthVal;
1882    }
1883
1884    Int shExtnAdditionalBits = 0;
1885
1886    if( shExtnLengthInBit % 8 != 0 )
1887    {
1888      shExtnAdditionalBits = 8 - (shExtnLengthInBit % 8);
1889    }
1890
1891    Int shExtnLength = (shExtnLengthInBit + shExtnAdditionalBits) / 8;
1892    WRITE_UVLC( shExtnLength, "slice_header_extension_length" );
1893
1894    if( slice->getPPS()->getPocResetInfoPresentFlag() )
1895    {
1896      WRITE_CODE( slice->getPocResetIdc(), 2,                                 "poc_reset_idc");
1897    }
1898    if( slice->getPocResetIdc() > 0 )
1899    {
1900      WRITE_CODE( slice->getPocResetPeriodId(), 6,                            "poc_reset_period_id");
1901    }
1902    if( slice->getPocResetIdc() == 3 ) 
1903    {
1904      WRITE_FLAG( slice->getFullPocResetFlag() ? 1 : 0,                       "full_poc_reset_flag");
1905      WRITE_CODE( slice->getPocLsbVal(), slice->getSPS()->getBitsForPOC(),  "poc_lsb_val");
1906    }
1907
1908    if( !slice->getPocMsbValRequiredFlag() && slice->getVPS()->getVpsPocLsbAlignedFlag() )
1909    {
1910      WRITE_FLAG( slice->getPocMsbValPresentFlag(),                           "poc_msb_cycle_val_present_flag" );
1911    }
1912
1913    if( slice->getPocMsbValPresentFlag() )
1914    {
1915      assert(slice->getPocMsbVal() % maxPocLsb == 0);
1916      WRITE_UVLC(slice->getPocMsbVal() / maxPocLsb, "poc_msb_cycle_val");
1917    }
1918
1919    for(Int i = 0; i < shExtnAdditionalBits; i++)
1920    {
1921      WRITE_FLAG( 1, "slice_segment_header_extension_data_bit");
1922    }
1923  }
1924
1925  shBitsWrittenTillNow += ( getNumberOfWrittenBits() - tmpBitsBeforeWriting );
1926 
1927  // Slice header byte_alignment() included in xAttachSliceDataToNalUnit
1928}
1929
1930Void TEncCavlc::codeVPSExtension( const TComVPS *vps )
1931{
1932  Int NumOutputLayersInOutputLayerSet[MAX_VPS_LAYER_SETS_PLUS1];
1933  Int OlsHighestOutputLayerId[MAX_VPS_LAYER_SETS_PLUS1];
1934
1935  if( vps->getMaxLayers() > 1 && vps->getBaseLayerInternalFlag() )
1936  {
1937    codePTL( vps->getPTL(1), false, vps->getMaxTLayers() - 1 );
1938  }
1939
1940  UInt i = 0, j = 0;
1941
1942  WRITE_FLAG( vps->getSplittingFlag(),                 "splitting_flag" );
1943
1944  for(i = 0; i < MAX_VPS_NUM_SCALABILITY_TYPES; i++)
1945  {
1946    WRITE_FLAG( vps->getScalabilityMask(i),            "scalability_mask[i]" );
1947  }
1948
1949  for(j = 0; j < vps->getNumScalabilityTypes() - vps->getSplittingFlag(); j++)
1950  {
1951    WRITE_CODE( vps->getDimensionIdLen(j) - 1, 3,      "dimension_id_len_minus1[j]" );
1952  }
1953
1954  // The value of dimBitOffset[ NumScalabilityTypes ] is set equal to 6.
1955  if(vps->getSplittingFlag())
1956  {
1957    UInt splDimSum=0;
1958    for(j = 0; j < vps->getNumScalabilityTypes(); j++)
1959    {
1960      splDimSum+=(vps->getDimensionIdLen(j));
1961    }
1962    assert(splDimSum<=6);
1963  }
1964
1965  WRITE_FLAG( vps->getNuhLayerIdPresentFlag(),         "vps_nuh_layer_id_present_flag" );
1966  for(i = 1; i < vps->getMaxLayers(); i++)
1967  {
1968    if( vps->getNuhLayerIdPresentFlag() )
1969    {
1970      WRITE_CODE( vps->getLayerIdInNuh(i),     6,      "layer_id_in_nuh[i]" );
1971    }
1972
1973    if( !vps->getSplittingFlag() )
1974    {
1975      for(j = 0; j < vps->getNumScalabilityTypes(); j++)
1976      {
1977        UInt bits = vps->getDimensionIdLen(j);
1978        WRITE_CODE( vps->getDimensionId(i, j),   bits,   "dimension_id[i][j]" );
1979      }
1980    }
1981  }
1982
1983  WRITE_CODE( vps->getViewIdLen( ), 4, "view_id_len" );
1984  assert ( vps->getNumViews() >= (1<<vps->getViewIdLen()) );
1985
1986  if ( vps->getViewIdLen() > 0 )
1987  {
1988    for( i = 0; i < vps->getNumViews(); i++ )
1989    {
1990      WRITE_CODE( vps->getViewIdVal( i ), vps->getViewIdLen( ), "view_id_val[i]" );
1991    }
1992  }
1993
1994  for( Int layerCtr = 1; layerCtr < vps->getMaxLayers(); layerCtr++)
1995  {
1996    for( Int refLayerCtr = 0; refLayerCtr < layerCtr; refLayerCtr++)
1997    {
1998      WRITE_FLAG(vps->getDirectDependencyFlag(layerCtr, refLayerCtr), "direct_dependency_flag[i][j]" );
1999    }
2000  }
2001
2002  if( vps->getNumIndependentLayers() > 1 )
2003  {
2004    WRITE_UVLC( vps->getNumAddLayerSets(), "num_add_layer_sets" );
2005
2006    for( i = 0; i < vps->getNumAddLayerSets(); i++ )
2007    {
2008      for( j = 1; j < vps->getNumIndependentLayers(); j++ )
2009      {
2010        Int len = 1;
2011        while( (1 << len) < (vps->getNumLayersInTreePartition(j) + 1) )
2012        {
2013          len++;
2014        }
2015        WRITE_CODE(vps->getHighestLayerIdxPlus1(i, j), len, "highest_layer_idx_plus1[i][j]");
2016      }
2017    }
2018  }
2019
2020  WRITE_FLAG( vps->getMaxTSLayersPresentFlag(), "vps_sub_layers_max_minus1_present_flag");
2021  if( vps->getMaxTSLayersPresentFlag() )
2022  {
2023    for( i = 0; i < vps->getMaxLayers(); i++ )
2024    {
2025      WRITE_CODE(vps->getMaxTSLayersMinus1(i), 3, "sub_layers_vps_max_minus1[i]" );
2026    }
2027  }
2028
2029   WRITE_FLAG( vps->getMaxTidRefPresentFlag(), "max_tid_ref_present_flag");
2030   if (vps->getMaxTidRefPresentFlag())
2031   {
2032     for( i = 0; i < vps->getMaxLayers() - 1; i++)
2033     {
2034       for( j = i+1; j <= vps->getMaxLayers() - 1; j++)
2035       {
2036         if(vps->getDirectDependencyFlag(j, i))
2037         {
2038           WRITE_CODE(vps->getMaxTidIlRefPicsPlus1(i,j), 3, "max_tid_il_ref_pics_plus1[i][j]" );
2039         }
2040       }
2041     }
2042   }
2043   WRITE_FLAG( vps->getIlpSshSignalingEnabledFlag(), "all_ref_layers_active_flag" );
2044
2045  // Profile-tier-level signalling
2046  WRITE_UVLC( vps->getNumProfileTierLevel() - 1, "vps_num_profile_tier_level_minus1"); 
2047
2048  Int const numBitsForPtlIdx = vps->calculateLenOfSyntaxElement( vps->getNumProfileTierLevel() );
2049
2050  //Do something here to make sure the loop is correct to consider base layer internal stuff
2051
2052  for( Int idx = vps->getBaseLayerInternalFlag() ? 2 : 1; idx < vps->getNumProfileTierLevel(); idx++ )
2053  {
2054    WRITE_FLAG( vps->getProfilePresentFlag(idx),       "vps_profile_present_flag[i]" );
2055
2056    codePTL( vps->getPTL(idx), vps->getProfilePresentFlag(idx), vps->getMaxTLayers() - 1 );
2057  }
2058
2059  Int numOutputLayerSets = vps->getNumOutputLayerSets();
2060  Int numAddOutputLayerSets = numOutputLayerSets - (Int)vps->getNumLayerSets();
2061
2062  // The value of num_add_olss shall be in the range of 0 to 1023, inclusive.
2063  assert( numAddOutputLayerSets >= 0 && numAddOutputLayerSets < 1024 );
2064
2065  if( vps->getNumLayerSets() > 1 )
2066  {
2067    WRITE_UVLC( numAddOutputLayerSets, "num_add_olss" );
2068    WRITE_CODE( vps->getDefaultTargetOutputLayerIdc(), 2, "default_output_layer_idc" );
2069  }
2070
2071  for(i = 1; i < numOutputLayerSets; i++)
2072  {
2073    Int layerSetIdxForOutputLayerSet = vps->getOutputLayerSetIdx(i);
2074    if( vps->getNumLayerSets() > 2 && i >= vps->getNumLayerSets() )
2075    {
2076      Int numBits = 1;
2077      while ((1 << numBits) < (vps->getNumLayerSets() - 1))
2078      {
2079        numBits++;
2080      }
2081      WRITE_CODE( vps->getOutputLayerSetIdx(i) - 1, numBits, "layer_set_idx_for_ols_minus1"); 
2082    }
2083
2084    if( i > vps->getVpsNumLayerSetsMinus1() || vps->getDefaultTargetOutputLayerIdc() >= 2 ) //Instead of == 2, >= 2 is used to follow the agreement that value 3 should be interpreted as 2
2085    {
2086      for( j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet); j++ )
2087      {
2088        WRITE_FLAG( vps->getOutputLayerFlag(i,j), "output_layer_flag[i][j]");
2089      }
2090    }
2091
2092    for( j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet); j++ )
2093    {
2094      if( vps->getNecessaryLayerFlag(i, j) && (vps->getNumProfileTierLevel() - 1) > 0 )
2095      {
2096        WRITE_CODE( vps->getProfileLevelTierIdx(i, j), numBitsForPtlIdx, "profile_tier_level_idx[i]" );
2097      }
2098    }
2099
2100    NumOutputLayersInOutputLayerSet[i] = 0;
2101
2102    for( j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet); j++ )
2103    {
2104      NumOutputLayersInOutputLayerSet[i] += vps->getOutputLayerFlag(i, j);
2105      if( vps->getOutputLayerFlag(i, j) )
2106      {
2107        OlsHighestOutputLayerId[i] = vps->getLayerSetLayerIdList(layerSetIdxForOutputLayerSet, j);
2108      }
2109    }
2110    if( NumOutputLayersInOutputLayerSet[i] == 1 && vps->getNumDirectRefLayers(OlsHighestOutputLayerId[i]) > 0 )
2111    {
2112      WRITE_FLAG(vps->getAltOuputLayerFlag(i), "alt_output_layer_flag[i]");
2113    }
2114
2115    assert( NumOutputLayersInOutputLayerSet[i] > 0 );
2116  }
2117
2118  // The value of vps_num_rep_formats_minus1 shall be in the range of 0 to 255, inclusive.
2119  assert( vps->getVpsNumRepFormats() > 0 && vps->getVpsNumRepFormats() <= 256 );
2120 
2121  WRITE_UVLC( vps->getVpsNumRepFormats() - 1, "vps_num_rep_formats_minus1" );
2122
2123  for(i = 0; i < vps->getVpsNumRepFormats(); i++)
2124  {
2125    // Write rep_format_structures
2126    codeRepFormat( vps->getVpsRepFormat(i) );
2127  }
2128
2129  if( vps->getVpsNumRepFormats() > 1 )
2130  {
2131    WRITE_FLAG( vps->getRepFormatIdxPresentFlag(), "rep_format_idx_present_flag"); 
2132  }
2133  else
2134  {
2135    // When not present, the value of rep_format_idx_present_flag is inferred to be equal to 0
2136    assert( !vps->getRepFormatIdxPresentFlag() );
2137  }
2138
2139  if( vps->getRepFormatIdxPresentFlag() )
2140  {
2141    for( i = vps->getBaseLayerInternalFlag() ? 1 : 0; i < vps->getMaxLayers(); i++ )
2142    {
2143      Int numBits = 1;
2144      while ((1 << numBits) < (vps->getVpsNumRepFormats()))
2145      {
2146        numBits++;
2147      }
2148      WRITE_CODE( vps->getVpsRepFormatIdx(i), numBits, "vps_rep_format_idx[i]" );
2149    }
2150  }
2151
2152  WRITE_FLAG(vps->getMaxOneActiveRefLayerFlag(), "max_one_active_ref_layer_flag");
2153
2154  WRITE_FLAG(vps->getVpsPocLsbAlignedFlag(), "vps_poc_lsb_aligned_flag");
2155
2156  for( i = 1; i< vps->getMaxLayers(); i++ )
2157  {
2158    if( vps->getNumDirectRefLayers( vps->getLayerIdInNuh(i) ) == 0  )
2159    {
2160      WRITE_FLAG(vps->getPocLsbNotPresentFlag(i), "poc_lsb_not_present_flag[i]");
2161    }
2162  }
2163 
2164  codeVpsDpbSizeTable(vps);
2165
2166  WRITE_UVLC( vps->getDirectDepTypeLen()-2,                           "direct_dep_type_len_minus2");
2167
2168  WRITE_FLAG(vps->getDefaultDirectDependencyTypeFlag(), "direct_dependency_all_layers_flag");
2169
2170  if( vps->getDefaultDirectDependencyTypeFlag() )
2171  {
2172    WRITE_CODE( vps->getDefaultDirectDependencyType(), vps->getDirectDepTypeLen(), "direct_dependency_all_layers_type" );
2173  }
2174  else
2175  {
2176    for( i = vps->getBaseLayerInternalFlag() ? 1 : 2; i < vps->getMaxLayers(); i++ )
2177    {
2178      for( j = vps->getBaseLayerInternalFlag() ? 0 : 1; j < i; j++ )
2179      {
2180        if (vps->getDirectDependencyFlag(i, j))
2181        {
2182          WRITE_CODE( vps->getDirectDependencyType(i, j), vps->getDirectDepTypeLen(), "direct_dependency_type[i][j]" );
2183        }
2184      }
2185    }
2186  }
2187
2188  // The value of vps_non_vui_extension_length shall be in the range of 0 to 4096, inclusive.
2189  assert( vps->getVpsNonVuiExtLength() >= 0 && vps->getVpsNonVuiExtLength() <= 4096 );
2190
2191  WRITE_UVLC( vps->getVpsNonVuiExtLength(), "vps_non_vui_extension_length" );
2192
2193  for( i = 1; i <= vps->getVpsNonVuiExtLength(); i++ )
2194  {
2195    WRITE_CODE(1, 8, "vps_non_vui_extension_data_byte");
2196  }
2197   
2198  WRITE_FLAG( vps->getVpsVuiPresentFlag() ? 1 : 0,                     "vps_vui_present_flag" );
2199
2200  if(vps->getVpsVuiPresentFlag())   // Should be conditioned on the value of vps_vui_present_flag
2201  {
2202    while ( m_pcBitIf->getNumberOfWrittenBits() % 8 != 0 )
2203    {
2204      WRITE_FLAG(1,                  "vps_vui_alignment_bit_equal_to_one");
2205    }
2206
2207    codeVPSVUI(vps); 
2208  }
2209}
2210
2211Void  TEncCavlc::codeRepFormat( const RepFormat *repFormat )
2212{
2213  WRITE_CODE( repFormat->getPicWidthVpsInLumaSamples (), 16, "pic_width_vps_in_luma_samples" );   
2214  WRITE_CODE( repFormat->getPicHeightVpsInLumaSamples(), 16, "pic_height_vps_in_luma_samples" ); 
2215  WRITE_FLAG( repFormat->getChromaAndBitDepthVpsPresentFlag(), "chroma_and_bit_depth_vps_present_flag" );
2216
2217  if( repFormat->getChromaAndBitDepthVpsPresentFlag() )
2218  {
2219    WRITE_CODE( repFormat->getChromaFormatVpsIdc(), 2, "chroma_format_vps_idc" );   
2220
2221    if( repFormat->getChromaFormatVpsIdc() == 3 )
2222    {
2223      WRITE_FLAG( repFormat->getSeparateColourPlaneVpsFlag(), "separate_colour_plane_vps_flag" );     
2224    }
2225
2226    assert( repFormat->getBitDepthVpsLuma() >= 8 );
2227    assert( repFormat->getBitDepthVpsChroma() >= 8 );
2228    WRITE_CODE( repFormat->getBitDepthVpsLuma() - 8,   4, "bit_depth_vps_luma_minus8" );           
2229    WRITE_CODE( repFormat->getBitDepthVpsChroma() - 8, 4, "bit_depth_vps_chroma_minus8" );
2230  }
2231
2232  Window conf = repFormat->getConformanceWindowVps();
2233
2234  WRITE_FLAG( conf.getWindowEnabledFlag(),    "conformance_window_vps_flag" );
2235  if (conf.getWindowEnabledFlag())
2236  {
2237    WRITE_UVLC( conf.getWindowLeftOffset(),   "conf_win_vps_left_offset"   );
2238    WRITE_UVLC( conf.getWindowRightOffset(),  "conf_win_vps_right_offset"  );
2239    WRITE_UVLC( conf.getWindowTopOffset(),    "conf_win_vps_top_offset"    );
2240    WRITE_UVLC( conf.getWindowBottomOffset(), "conf_win_vps_bottom_offset" );
2241  }
2242}
2243
2244Void TEncCavlc::codeVpsDpbSizeTable( const TComVPS *vps )
2245{
2246  for( Int i = 1; i < vps->getNumOutputLayerSets(); i++ )
2247  {
2248    Int layerSetIdxForOutputLayerSet = vps->getOutputLayerSetIdx( i );
2249
2250    WRITE_FLAG( vps->getSubLayerFlagInfoPresentFlag( i ), "sub_layer_flag_info_present_flag[i]");
2251
2252    for(Int j = 0; j <= vps->getMaxSLayersInLayerSetMinus1( layerSetIdxForOutputLayerSet ); j++)
2253    {
2254      if( j > 0 && vps->getSubLayerFlagInfoPresentFlag(i) )
2255      {
2256        WRITE_FLAG( vps->getSubLayerDpbInfoPresentFlag( i, j), "sub_layer_dpb_info_present_flag[i]"); 
2257      }
2258
2259      if( vps->getSubLayerDpbInfoPresentFlag(i, j) )
2260      {
2261        for(Int k = 0; k < vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ); k++)
2262        {
2263          if( vps->getNecessaryLayerFlag(i, k) && (vps->getBaseLayerInternalFlag() || (vps->getLayerSetLayerIdList(layerSetIdxForOutputLayerSet, k) != 0)) )
2264          {
2265            WRITE_UVLC( vps->getMaxVpsDecPicBufferingMinus1( i, k, j ), "max_vps_dec_pic_buffering_minus1[i][k][j]" );
2266          }
2267        }
2268
2269        WRITE_UVLC( vps->getMaxVpsNumReorderPics( i, j), "max_vps_num_reorder_pics[i][j]" );             
2270
2271        WRITE_UVLC( vps->getMaxVpsLatencyIncreasePlus1( i, j), "max_vps_latency_increase_plus1[i][j]" );       
2272      }
2273    }
2274  }
2275}
2276
2277Void TEncCavlc::codeVPSVUI( const TComVPS *vps )
2278{
2279  Int i,j;
2280  WRITE_FLAG(vps->getCrossLayerPictureTypeAlignFlag(), "cross_layer_pic_type_aligned_flag");
2281
2282  if( !vps->getCrossLayerPictureTypeAlignFlag() )
2283  {
2284    WRITE_FLAG(vps->getCrossLayerIrapAlignFlag(), "cross_layer_irap_aligned_flag");
2285  }
2286  else
2287  {
2288    // When not present, the value of cross_layer_irap_aligned_flag is inferred to be equal to vps_vui_present_flag,
2289    assert( vps->getCrossLayerIrapAlignFlag() == true );
2290  }
2291
2292  if( vps->getCrossLayerIrapAlignFlag() )
2293  {
2294    WRITE_FLAG(vps->getCrossLayerAlignedIdrOnlyFlag(), "all_layers_idr_aligned_flag");
2295  }
2296
2297  WRITE_FLAG( vps->getBitRatePresentVpsFlag(),        "bit_rate_present_vps_flag" );
2298  WRITE_FLAG( vps->getPicRatePresentVpsFlag(),        "pic_rate_present_vps_flag" );
2299
2300  if( vps->getBitRatePresentVpsFlag() || vps->getPicRatePresentVpsFlag() )
2301  {
2302    for( i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getNumLayerSets(); i++ )
2303    {
2304      for( j = 0; j <= vps->getMaxSLayersInLayerSetMinus1(i); j++ )
2305      {
2306        if( vps->getBitRatePresentVpsFlag() )
2307        {
2308          WRITE_FLAG( vps->getBitRatePresentFlag( i, j),        "bit_rate_present_flag[i][j]" );
2309        }
2310
2311        if( vps->getPicRatePresentVpsFlag() )
2312        {
2313          WRITE_FLAG( vps->getPicRatePresentFlag( i, j),        "pic_rate_present_flag[i][j]" );
2314        }
2315
2316        if( vps->getBitRatePresentFlag(i, j) )
2317        {
2318          WRITE_CODE( vps->getAvgBitRate( i, j ), 16, "avg_bit_rate[i][j]" );
2319          WRITE_CODE( vps->getAvgBitRate( i, j ), 16, "max_bit_rate[i][j]" );
2320        }
2321
2322        if( vps->getPicRatePresentFlag(i, j) )
2323        {
2324          WRITE_CODE( vps->getConstPicRateIdc( i, j), 2 , "constant_pic_rate_idc[i][j]" ); 
2325          WRITE_CODE( vps->getConstPicRateIdc( i, j), 16, "avg_pic_rate[i][j]"          ); 
2326        }
2327      }
2328    }
2329  }
2330
2331  WRITE_FLAG( vps->getVideoSigPresentVpsFlag(), "video_signal_info_idx_present_flag" );
2332  if (vps->getVideoSigPresentVpsFlag())
2333  {
2334    WRITE_CODE(vps->getNumVideoSignalInfo()-1, 4, "vps_num_video_signal_info_minus1" );
2335  }
2336
2337  for(i = 0; i < vps->getNumVideoSignalInfo(); i++)
2338  {
2339    WRITE_CODE(vps->getVideoVPSFormat(i), 3, "video_vps_format" );
2340    WRITE_FLAG(vps->getVideoFullRangeVpsFlag(i), "video_full_range_vps_flag" );
2341    WRITE_CODE(vps->getColorPrimaries(i), 8, "color_primaries_vps" );
2342    WRITE_CODE(vps->getTransCharacter(i), 8, "transfer_characteristics_vps" );
2343    WRITE_CODE(vps->getMaxtrixCoeff(i), 8, "matrix_coeffs_vps" );
2344  }
2345
2346  if( vps->getVideoSigPresentVpsFlag() && vps->getNumVideoSignalInfo() > 1 )
2347  {
2348    for( i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getMaxLayers(); i++ )
2349    {
2350      WRITE_CODE( vps->getVideoSignalInfoIdx(i), 4, "vps_video_signal_info_idx" );
2351    }
2352  }
2353
2354  WRITE_FLAG( vps->getTilesNotInUseFlag() ? 1 : 0 , "tiles_not_in_use_flag" );
2355
2356  if( !vps->getTilesNotInUseFlag() )
2357  {
2358    for( i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getMaxLayers(); i++ )
2359    {
2360      WRITE_FLAG( vps->getTilesInUseFlag(i) ? 1 : 0 , "tiles_in_use_flag[ i ]" );
2361
2362      if( vps->getTilesInUseFlag(i) )
2363      {
2364        WRITE_FLAG( vps->getLoopFilterNotAcrossTilesFlag(i) ? 1 : 0 , "loop_filter_not_across_tiles_flag[ i ]" );
2365      }
2366    }
2367
2368    for( i = vps->getBaseLayerInternalFlag() ? 1 : 2; i < vps->getMaxLayers(); i++ )
2369    {
2370      for(j = 0; j < vps->getNumDirectRefLayers(vps->getLayerIdInNuh(i)); j++)
2371      {
2372        UInt layerIdx = vps->getLayerIdxInVps(vps->getRefLayerId(vps->getLayerIdInNuh(i), j));
2373
2374        if( vps->getTilesInUseFlag(i) && vps->getTilesInUseFlag(layerIdx) )
2375        {
2376          WRITE_FLAG( vps->getTileBoundariesAlignedFlag(i,j) ? 1 : 0 , "tile_boundaries_aligned_flag[i][j]" );
2377        }
2378      }
2379    } 
2380  }
2381
2382  WRITE_FLAG( vps->getWppNotInUseFlag() ? 1 : 0 , "wpp_not_in_use_flag" );
2383
2384  if( !vps->getWppNotInUseFlag() )
2385  {
2386    for( i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getMaxLayers(); i++ )
2387    {
2388      WRITE_FLAG( vps->getWppInUseFlag(i) ? 1 : 0 , "wpp_in_use_flag[ i ]" );
2389    }
2390  }
2391
2392  WRITE_FLAG(vps->getSingleLayerForNonIrapFlag(), "single_layer_for_non_irap_flag" );
2393
2394  // When single_layer_for_non_irap_flag is equal to 0, higher_layer_irap_skip_flag shall be equal to 0
2395  if( !vps->getSingleLayerForNonIrapFlag() )
2396  {
2397    assert( !vps->getHigherLayerIrapSkipFlag() );
2398  }
2399
2400  WRITE_FLAG(vps->getHigherLayerIrapSkipFlag(), "higher_layer_irap_skip_flag" );
2401
2402  WRITE_FLAG( vps->getIlpRestrictedRefLayersFlag() ? 1 : 0 , "ilp_restricted_ref_layers_flag" );   
2403  if( vps->getIlpRestrictedRefLayersFlag())
2404  {
2405    for(i = 1; i < vps->getMaxLayers(); i++)
2406    {
2407      for(j = 0; j < vps->getNumDirectRefLayers(vps->getLayerIdInNuh(i)); j++)
2408      {
2409        if (vps->getBaseLayerInternalFlag() || vps->getRefLayerId(vps->getLayerIdInNuh(i), j))
2410        {
2411          WRITE_UVLC(vps->getMinSpatialSegmentOffsetPlus1( i, j),    "min_spatial_segment_offset_plus1[i][j]");
2412
2413          if( vps->getMinSpatialSegmentOffsetPlus1(i,j ) > 0 ) 
2414          { 
2415            WRITE_FLAG( vps->getCtuBasedOffsetEnabledFlag( i, j) ? 1 : 0 , "ctu_based_offset_enabled_flag[i][j]" );   
2416
2417            if(vps->getCtuBasedOffsetEnabledFlag(i,j)) 
2418            {
2419              WRITE_UVLC(vps->getMinHorizontalCtuOffsetPlus1( i, j),    "min_horizontal_ctu_offset_plus1[i][j]");           
2420            }
2421          }
2422        }
2423      } 
2424    }
2425  }
2426
2427#if O0164_MULTI_LAYER_HRD
2428  WRITE_FLAG(vps->getVpsVuiBspHrdPresentFlag(), "vps_vui_bsp_hrd_present_flag" );
2429
2430  if( vps->getVpsVuiBspHrdPresentFlag() )
2431  {
2432    codeVpsVuiBspHrdParams(vps);
2433  }
2434#endif
2435
2436  for( i = 1; i < vps->getMaxLayers(); i++ )
2437  {
2438    if( vps->getNumRefLayers(vps->getLayerIdInNuh(i)) == 0 ) 
2439    {
2440      WRITE_FLAG(vps->getBaseLayerPSCompatibilityFlag(i), "base_layer_parameter_set_compatibility_flag" );
2441    }
2442  }
2443}
2444
2445Void TEncCavlc::codeSPSExtension( const TComSPS* pcSPS )
2446{
2447  // more syntax elements to be written here
2448
2449  // Vertical MV component restriction is not used in SHVC CTC
2450  WRITE_FLAG( 0, "inter_view_mv_vert_constraint_flag" );
2451}
2452
2453Void TEncCavlc::codeVpsVuiBspHrdParams( const TComVPS* vps )
2454{
2455  WRITE_UVLC( vps->getVpsNumAddHrdParams(), "vps_num_add_hrd_params" );
2456
2457  for( Int i = vps->getNumHrdParameters(), j = 0; i < vps->getNumHrdParameters() + vps->getVpsNumAddHrdParams(); i++, j++ ) // j = i - vps->getNumHrdParameters()
2458  {
2459    if( i > 0 )
2460    {
2461      WRITE_FLAG( vps->getCprmsAddPresentFlag(j), "cprms_add_present_flag[i]" );
2462    }
2463
2464    WRITE_UVLC( vps->getNumSubLayerHrdMinus1(j), "num_sub_layer_hrd_minus1[i]" );
2465
2466    codeHrdParameters(vps->getBspHrd(j), i == 0 ? true : vps->getCprmsAddPresentFlag(j), vps->getNumSubLayerHrdMinus1(j));
2467  }
2468
2469  if( vps->getNumHrdParameters() + vps->getVpsNumAddHrdParams() > 0 )
2470  {
2471    for( Int h = 1; h < vps->getNumOutputLayerSets(); h++ )
2472    {
2473      Int lsIdx = vps->getOutputLayerSetIdx( h );
2474
2475      WRITE_UVLC( vps->getNumSignalledPartitioningSchemes(h), "num_signalled_partitioning_schemes[h]");
2476
2477      for( Int j = 1; j < vps->getNumSignalledPartitioningSchemes(h) + 1; j++ )
2478      {
2479        WRITE_UVLC( vps->getNumPartitionsInSchemeMinus1(h, j), "num_partitions_in_scheme_minus1[h][j]" );
2480
2481        for( Int k = 0; k <= vps->getNumPartitionsInSchemeMinus1(h, j); k++ )
2482        {
2483          for( Int r = 0; r < vps->getNumLayersInIdList( lsIdx ); r++ )
2484          {
2485            WRITE_FLAG( vps->getLayerIncludedInPartitionFlag(h, j, k, r), "layer_included_in_partition_flag[h][j][k][r]" );
2486          }
2487        }
2488      }
2489
2490      for( Int i = 0; i < vps->getNumSignalledPartitioningSchemes(h) + 1; i++ )
2491      {
2492        for( Int t = 0; t <= vps->getMaxSLayersInLayerSetMinus1(lsIdx); t++ )
2493        {
2494          WRITE_UVLC(vps->getNumBspSchedulesMinus1(h, i, t), "num_bsp_schedules_minus1[h][i][t]");
2495
2496          for( Int j = 0; j <= vps->getNumBspSchedulesMinus1(h, i, t); j++ )
2497          {
2498            for( Int k = 0; k <= vps->getNumPartitionsInSchemeMinus1(h, i); k++ )
2499            {
2500              if( vps->getNumHrdParameters() + vps->getVpsNumAddHrdParams() > 1 )
2501              {
2502                Int numBits = 1;
2503                while ((1 << numBits) < (vps->getNumHrdParameters() + vps->getVpsNumAddHrdParams()))
2504                {
2505                  numBits++;
2506                }
2507
2508                WRITE_CODE(vps->getBspHrdIdx(h, i, t, j, k), numBits, "bsp_hrd_idx[h][i][t][j][k]");
2509              }
2510
2511              WRITE_UVLC( vps->getBspSchedIdx(h, i, t, j, k), "bsp_sched_idx[h][i][t][j][k]");
2512            }
2513          }
2514        }
2515      }
2516    }
2517  }
2518}
2519
2520
2521#if CGS_3D_ASYMLUT
2522Void TEncCavlc::xCode3DAsymLUT( TCom3DAsymLUT * pc3DAsymLUT )
2523{
2524  UInt uiNumRefLayers = ( UInt )pc3DAsymLUT->getRefLayerNum();
2525  WRITE_UVLC( uiNumRefLayers - 1 , "num_cm_ref_layers_minus1" );
2526  for( UInt i = 0 ; i < uiNumRefLayers ; i++ )
2527  {
2528    WRITE_CODE( pc3DAsymLUT->getRefLayerId( i ) , 6 , "cm_ref_layer_id" );
2529  }
2530
2531  assert( pc3DAsymLUT->getCurOctantDepth() < 4 );
2532  WRITE_CODE( pc3DAsymLUT->getCurOctantDepth() , 2 , "cm_octant_depth" );
2533  assert( pc3DAsymLUT->getCurYPartNumLog2() < 4 );
2534  WRITE_CODE( pc3DAsymLUT->getCurYPartNumLog2() , 2 , "cm_y_part_num_log2" );
2535  assert( pc3DAsymLUT->getInputBitDepthY() < 16 );
2536
2537  WRITE_UVLC( pc3DAsymLUT->getInputBitDepthY() - 8 , "cm_input_luma_bit_depth_minus8" );
2538  WRITE_UVLC( pc3DAsymLUT->getInputBitDepthC() - 8 , "cm_input_chroma_bit_depth_minus8" );
2539  WRITE_UVLC( pc3DAsymLUT->getOutputBitDepthY() - 8 , "cm_output_luma_bit_depth_minus8" );
2540  WRITE_UVLC( pc3DAsymLUT->getOutputBitDepthC() - 8 , "cm_output_chroma_bit_depth_minus8" );
2541
2542  assert( pc3DAsymLUT->getResQuantBit() < 4 );
2543  WRITE_CODE( pc3DAsymLUT->getResQuantBit() , 2 , "cm_res_quant_bit" );
2544
2545  xFindDeltaBits( pc3DAsymLUT );
2546  assert(pc3DAsymLUT->getDeltaBits() >=1 && pc3DAsymLUT->getDeltaBits() <= 4);
2547  WRITE_CODE( pc3DAsymLUT->getDeltaBits()-1 , 2 , "cm_delta_bit" );
2548
2549  if( pc3DAsymLUT->getCurOctantDepth() == 1 )
2550  {
2551    WRITE_SVLC( pc3DAsymLUT->getAdaptChromaThresholdU() - ( 1 << ( pc3DAsymLUT->getInputBitDepthC() - 1 ) ) , "cm_adapt_threshold_u_delta" );
2552    WRITE_SVLC( pc3DAsymLUT->getAdaptChromaThresholdV() - ( 1 << ( pc3DAsymLUT->getInputBitDepthC() - 1 ) ) , "cm_adapt_threshold_v_delta" );
2553  }
2554
2555#if R0164_CGS_LUT_BUGFIX_CHECK
2556  pc3DAsymLUT->xInitCuboids();
2557#endif
2558  xCode3DAsymLUTOctant( pc3DAsymLUT , 0 , 0 , 0 , 0 , 1 << pc3DAsymLUT->getCurOctantDepth() );
2559#if R0164_CGS_LUT_BUGFIX_CHECK
2560  xCuboidsFilledCheck( false );
2561  pc3DAsymLUT->display( false );
2562#endif
2563}
2564
2565Void TEncCavlc::xCode3DAsymLUTOctant( TCom3DAsymLUT * pc3DAsymLUT , Int nDepth , Int yIdx , Int uIdx , Int vIdx , Int nLength )
2566{
2567  UInt uiOctantSplit = nDepth < pc3DAsymLUT->getCurOctantDepth();
2568  if( nDepth < pc3DAsymLUT->getCurOctantDepth() )
2569    WRITE_FLAG( uiOctantSplit , "split_octant_flag" );
2570  Int nYPartNum = 1 << pc3DAsymLUT->getCurYPartNumLog2();
2571  if( uiOctantSplit )
2572  {
2573    Int nHalfLength = nLength >> 1;
2574    for( Int l = 0 ; l < 2 ; l++ )
2575    {
2576      for( Int m = 0 ; m < 2 ; m++ )
2577      {
2578        for( Int n = 0 ; n < 2 ; n++ )
2579        {
2580          xCode3DAsymLUTOctant( pc3DAsymLUT , nDepth + 1 , yIdx + l * nHalfLength * nYPartNum , uIdx + m * nHalfLength , vIdx + n * nHalfLength , nHalfLength );
2581        }
2582      }
2583    }
2584  }
2585  else
2586  {
2587    Int nFLCbits = pc3DAsymLUT->getMappingShift()-pc3DAsymLUT->getResQuantBit()-pc3DAsymLUT->getDeltaBits() ; 
2588    nFLCbits = nFLCbits >= 0 ? nFLCbits : 0;
2589
2590    for( Int l = 0 ; l < nYPartNum ; l++ )
2591    {
2592      Int shift = pc3DAsymLUT->getCurOctantDepth() - nDepth ;
2593
2594      for( Int nVertexIdx = 0 ; nVertexIdx < 4 ; nVertexIdx++ )
2595      {
2596        SYUVP sRes = pc3DAsymLUT->getCuboidVertexResTree( yIdx + (l<<shift) , uIdx , vIdx , nVertexIdx );
2597
2598        UInt uiCodeVertex = sRes.Y != 0 || sRes.U != 0 || sRes.V != 0;
2599        WRITE_FLAG( uiCodeVertex , "coded_vertex_flag" );
2600        if( uiCodeVertex )
2601        {
2602          xWriteParam( sRes.Y, nFLCbits );
2603          xWriteParam( sRes.U, nFLCbits );
2604          xWriteParam( sRes.V, nFLCbits );
2605        }
2606      }
2607#if R0164_CGS_LUT_BUGFIX_CHECK
2608      pc3DAsymLUT->xSetExplicit( yIdx + (l<<shift) , uIdx , vIdx );
2609#endif
2610    }
2611  }
2612}
2613
2614Void TEncCavlc::xWriteParam( Int param, UInt rParam)
2615{
2616  Int codeNumber = abs(param);
2617  WRITE_UVLC(codeNumber / (1 << rParam), "quotient");
2618  WRITE_CODE((codeNumber % (1 << rParam)), rParam, "remainder");
2619  if (abs(param))
2620    WRITE_FLAG( param <0, "sign");
2621}
2622
2623Void TEncCavlc::xFindDeltaBits( TCom3DAsymLUT * pc3DAsymLUT )
2624{
2625  Int nDeltaBits; 
2626  Int nBestDeltaBits = -1; 
2627  Int nBestBits = MAX_INT; 
2628  for( nDeltaBits = 1; nDeltaBits < 5; nDeltaBits++)
2629  {
2630    Int nCurBits = 0;
2631    xTally3DAsymLUTOctantBits( pc3DAsymLUT , 0 , 0 , 0 , 0 , 1 << pc3DAsymLUT->getCurOctantDepth(), nDeltaBits, nCurBits );
2632    //printf("%d, %d, %d\n", nDeltaBits, nCurBits, nBestBits);
2633    if(nCurBits < nBestBits)
2634    {
2635      nBestDeltaBits = nDeltaBits; 
2636      nBestBits = nCurBits;
2637    }
2638  }
2639
2640  assert(nBestDeltaBits >=1 && nBestDeltaBits < 5);
2641  pc3DAsymLUT->setDeltaBits(nBestDeltaBits); 
2642}
2643
2644Void TEncCavlc::xTally3DAsymLUTOctantBits( TCom3DAsymLUT * pc3DAsymLUT , Int nDepth , Int yIdx , Int uIdx , Int vIdx , Int nLength, Int nDeltaBits, Int& nCurBits )
2645{
2646  UInt uiOctantSplit = nDepth < pc3DAsymLUT->getCurOctantDepth();
2647  if( nDepth < pc3DAsymLUT->getCurOctantDepth() )
2648    nCurBits ++; 
2649  Int nYPartNum = 1 << pc3DAsymLUT->getCurYPartNumLog2();
2650  if( uiOctantSplit )
2651  {
2652    Int nHalfLength = nLength >> 1;
2653    for( Int l = 0 ; l < 2 ; l++ )
2654    {
2655      for( Int m = 0 ; m < 2 ; m++ )
2656      {
2657        for( Int n = 0 ; n < 2 ; n++ )
2658        {
2659          xTally3DAsymLUTOctantBits( pc3DAsymLUT , nDepth + 1 , yIdx + l * nHalfLength * nYPartNum , uIdx + m * nHalfLength , vIdx + n * nHalfLength , nHalfLength, nDeltaBits, nCurBits );
2660        }
2661      }
2662    }
2663  }
2664  else
2665  {
2666    Int nFLCbits = pc3DAsymLUT->getMappingShift()-pc3DAsymLUT->getResQuantBit()-nDeltaBits ; 
2667    nFLCbits = nFLCbits >= 0 ? nFLCbits:0;
2668    //printf("nFLCbits = %d\n", nFLCbits);
2669
2670    for( Int l = 0 ; l < nYPartNum ; l++ )
2671    {
2672      for( Int nVertexIdx = 0 ; nVertexIdx < 4 ; nVertexIdx++ )
2673      {
2674        SYUVP sRes = pc3DAsymLUT->getCuboidVertexResTree( yIdx + l , uIdx , vIdx , nVertexIdx );
2675
2676        UInt uiCodeVertex = sRes.Y != 0 || sRes.U != 0 || sRes.V != 0;
2677        nCurBits++;
2678        if( uiCodeVertex )
2679        {
2680          xCheckParamBits( sRes.Y, nFLCbits, nCurBits );
2681          xCheckParamBits( sRes.U, nFLCbits, nCurBits );
2682          xCheckParamBits( sRes.V, nFLCbits, nCurBits );
2683        }
2684      }
2685    }
2686  }
2687}
2688
2689Void TEncCavlc::xCheckParamBits( Int param, Int rParam, Int &nBits)
2690{
2691  Int codeNumber = abs(param);
2692  Int codeQuotient = codeNumber >> rParam;
2693  Int qLen; 
2694
2695  UInt uiLength = 1;
2696  UInt uiTemp = ++codeQuotient;
2697   
2698  while( 1 != uiTemp )
2699  {
2700    uiTemp >>= 1;
2701    uiLength += 2;
2702  }
2703
2704  qLen  = (uiLength >> 1);
2705  qLen += ((uiLength+1) >> 1);
2706
2707  nBits += qLen; 
2708  nBits += rParam; 
2709  if (abs(param))
2710    nBits++; 
2711}
2712#endif //CGS_3D_ASYMLUT
2713
2714#endif //SVC_EXTENSION
2715//! \}
Note: See TracBrowser for help on using the repository browser.