source: SHVCSoftware/branches/SHM-upgrade/source/Lib/TLibDecoder/TDecCAVLC.cpp @ 1311

Last change on this file since 1311 was 1014, checked in by seregin, 10 years ago

port the fix for the ticket #60 (rev 1013)

  • Property svn:eol-style set to native
File size: 172.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-2014, 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     TDecCAVLC.cpp
35\brief    CAVLC decoder class
36*/
37
38#include "TDecCAVLC.h"
39#include "SEIread.h"
40#include "TDecSlice.h"
41#include "TLibCommon/TComChromaFormat.h"
42#if RExt__DECODER_DEBUG_BIT_STATISTICS
43#include "TLibCommon/TComCodingStatistics.h"
44#endif
45#if Q0048_CGS_3D_ASYMLUT
46#include "../TLibCommon/TCom3DAsymLUT.h"
47#endif
48
49//! \ingroup TLibDecoder
50//! \{
51
52#if ENC_DEC_TRACE
53
54Void  xTraceSPSHeader (TComSPS *pSPS)
55{
56  fprintf( g_hTrace, "=========== Sequence Parameter Set ID: %d ===========\n", pSPS->getSPSId() );
57}
58
59Void  xTracePPSHeader (TComPPS *pPPS)
60{
61  fprintf( g_hTrace, "=========== Picture Parameter Set ID: %d ===========\n", pPPS->getPPSId() );
62}
63
64Void  xTraceSliceHeader (TComSlice *pSlice)
65{
66  fprintf( g_hTrace, "=========== Slice ===========\n");
67}
68
69#endif
70
71// ====================================================================================================================
72// Constructor / destructor / create / destroy
73// ====================================================================================================================
74
75TDecCavlc::TDecCavlc()
76{
77}
78
79TDecCavlc::~TDecCavlc()
80{
81
82}
83
84// ====================================================================================================================
85// Public member functions
86// ====================================================================================================================
87
88Void TDecCavlc::parseShortTermRefPicSet( TComSPS* sps, TComReferencePictureSet* rps, Int idx )
89{
90  UInt code;
91  UInt interRPSPred;
92  if (idx > 0)
93  {
94    READ_FLAG(interRPSPred, "inter_ref_pic_set_prediction_flag");  rps->setInterRPSPrediction(interRPSPred);
95  }
96  else
97  {
98    interRPSPred = false;
99    rps->setInterRPSPrediction(false);
100  }
101
102  if (interRPSPred)
103  {
104    UInt bit;
105    if(idx == sps->getRPSList()->getNumberOfReferencePictureSets())
106    {
107      READ_UVLC(code, "delta_idx_minus1" ); // delta index of the Reference Picture Set used for prediction minus 1
108    }
109    else
110    {
111      code = 0;
112    }
113    assert(code <= idx-1); // delta_idx_minus1 shall not be larger than idx-1, otherwise we will predict from a negative row position that does not exist. When idx equals 0 there is no legal value and interRPSPred must be zero. See J0185-r2
114    Int rIdx =  idx - 1 - code;
115    assert (rIdx <= idx-1 && rIdx >= 0); // Made assert tighter; if rIdx = idx then prediction is done from itself. rIdx must belong to range 0, idx-1, inclusive, see J0185-r2
116    TComReferencePictureSet*   rpsRef = sps->getRPSList()->getReferencePictureSet(rIdx);
117    Int k = 0, k0 = 0, k1 = 0;
118    READ_CODE(1, bit, "delta_rps_sign"); // delta_RPS_sign
119    READ_UVLC(code, "abs_delta_rps_minus1");  // absolute delta RPS minus 1
120    Int deltaRPS = (1 - 2 * bit) * (code + 1); // delta_RPS
121    for(Int j=0 ; j <= rpsRef->getNumberOfPictures(); j++)
122    {
123      READ_CODE(1, bit, "used_by_curr_pic_flag" ); //first bit is "1" if Idc is 1
124      Int refIdc = bit;
125      if (refIdc == 0)
126      {
127        READ_CODE(1, bit, "use_delta_flag" ); //second bit is "1" if Idc is 2, "0" otherwise.
128        refIdc = bit<<1; //second bit is "1" if refIdc is 2, "0" if refIdc = 0.
129      }
130      if (refIdc == 1 || refIdc == 2)
131      {
132        Int deltaPOC = deltaRPS + ((j < rpsRef->getNumberOfPictures())? rpsRef->getDeltaPOC(j) : 0);
133        rps->setDeltaPOC(k, deltaPOC);
134        rps->setUsed(k, (refIdc == 1));
135
136        if (deltaPOC < 0)
137        {
138          k0++;
139        }
140        else
141        {
142          k1++;
143        }
144        k++;
145      }
146      rps->setRefIdc(j,refIdc);
147    }
148    rps->setNumRefIdc(rpsRef->getNumberOfPictures()+1);
149    rps->setNumberOfPictures(k);
150    rps->setNumberOfNegativePictures(k0);
151    rps->setNumberOfPositivePictures(k1);
152    rps->sortDeltaPOC();
153  }
154  else
155  {
156    READ_UVLC(code, "num_negative_pics");           rps->setNumberOfNegativePictures(code);
157    READ_UVLC(code, "num_positive_pics");           rps->setNumberOfPositivePictures(code);
158    Int prev = 0;
159    Int poc;
160    for(Int j=0 ; j < rps->getNumberOfNegativePictures(); j++)
161    {
162      READ_UVLC(code, "delta_poc_s0_minus1");
163      poc = prev-code-1;
164      prev = poc;
165      rps->setDeltaPOC(j,poc);
166      READ_FLAG(code, "used_by_curr_pic_s0_flag");  rps->setUsed(j,code);
167    }
168    prev = 0;
169    for(Int j=rps->getNumberOfNegativePictures(); j < rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures(); j++)
170    {
171      READ_UVLC(code, "delta_poc_s1_minus1");
172      poc = prev+code+1;
173      prev = poc;
174      rps->setDeltaPOC(j,poc);
175      READ_FLAG(code, "used_by_curr_pic_s1_flag");  rps->setUsed(j,code);
176    }
177    rps->setNumberOfPictures(rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures());
178  }
179#if PRINT_RPS_INFO
180  rps->printDeltaPOC();
181#endif
182}
183
184#if Q0048_CGS_3D_ASYMLUT
185Void TDecCavlc::parsePPS(TComPPS* pcPPS, TCom3DAsymLUT * pc3DAsymLUT, Int nLayerID)
186#else
187Void TDecCavlc::parsePPS(TComPPS* pcPPS)
188#endif
189
190{
191#if ENC_DEC_TRACE
192  xTracePPSHeader (pcPPS);
193#endif
194  UInt  uiCode;
195
196  Int   iCode;
197
198  READ_UVLC( uiCode, "pps_pic_parameter_set_id");
199  assert(uiCode <= 63);
200  pcPPS->setPPSId (uiCode);
201
202  READ_UVLC( uiCode, "pps_seq_parameter_set_id");
203  assert(uiCode <= 15);
204  pcPPS->setSPSId (uiCode);
205
206  READ_FLAG( uiCode, "dependent_slice_segments_enabled_flag"    );    pcPPS->setDependentSliceSegmentsEnabledFlag   ( uiCode == 1 );
207
208  READ_FLAG( uiCode, "output_flag_present_flag" );                    pcPPS->setOutputFlagPresentFlag( uiCode==1 );
209
210  READ_CODE(3, uiCode, "num_extra_slice_header_bits");                pcPPS->setNumExtraSliceHeaderBits(uiCode);
211
212  READ_FLAG ( uiCode, "sign_data_hiding_flag" ); pcPPS->setSignHideFlag( uiCode );
213
214  READ_FLAG( uiCode,   "cabac_init_present_flag" );            pcPPS->setCabacInitPresentFlag( uiCode ? true : false );
215
216  READ_UVLC(uiCode, "num_ref_idx_l0_default_active_minus1");
217  assert(uiCode <= 14);
218  pcPPS->setNumRefIdxL0DefaultActive(uiCode+1);
219
220  READ_UVLC(uiCode, "num_ref_idx_l1_default_active_minus1");
221  assert(uiCode <= 14);
222  pcPPS->setNumRefIdxL1DefaultActive(uiCode+1);
223
224  READ_SVLC(iCode, "init_qp_minus26" );                            pcPPS->setPicInitQPMinus26(iCode);
225  READ_FLAG( uiCode, "constrained_intra_pred_flag" );              pcPPS->setConstrainedIntraPred( uiCode ? true : false );
226  READ_FLAG( uiCode, "transform_skip_enabled_flag" );
227  pcPPS->setUseTransformSkip ( uiCode ? true : false );
228
229  READ_FLAG( uiCode, "cu_qp_delta_enabled_flag" );            pcPPS->setUseDQP( uiCode ? true : false );
230  if( pcPPS->getUseDQP() )
231  {
232    READ_UVLC( uiCode, "diff_cu_qp_delta_depth" );
233    pcPPS->setMaxCuDQPDepth( uiCode );
234  }
235  else
236  {
237    pcPPS->setMaxCuDQPDepth( 0 );
238  }
239  READ_SVLC( iCode, "pps_cb_qp_offset");
240  pcPPS->setQpOffset(COMPONENT_Cb, iCode);
241  assert( pcPPS->getQpOffset(COMPONENT_Cb) >= -12 );
242  assert( pcPPS->getQpOffset(COMPONENT_Cb) <=  12 );
243
244  READ_SVLC( iCode, "pps_cr_qp_offset");
245  pcPPS->setQpOffset(COMPONENT_Cr, iCode);
246  assert( pcPPS->getQpOffset(COMPONENT_Cr) >= -12 );
247  assert( pcPPS->getQpOffset(COMPONENT_Cr) <=  12 );
248
249  assert(MAX_NUM_COMPONENT<=3);
250
251  READ_FLAG( uiCode, "pps_slice_chroma_qp_offsets_present_flag" );
252  pcPPS->setSliceChromaQpFlag( uiCode ? true : false );
253
254  READ_FLAG( uiCode, "weighted_pred_flag" );          // Use of Weighting Prediction (P_SLICE)
255  pcPPS->setUseWP( uiCode==1 );
256  READ_FLAG( uiCode, "weighted_bipred_flag" );         // Use of Bi-Directional Weighting Prediction (B_SLICE)
257  pcPPS->setWPBiPred( uiCode==1 );
258
259  READ_FLAG( uiCode, "transquant_bypass_enable_flag");
260  pcPPS->setTransquantBypassEnableFlag(uiCode ? true : false);
261  READ_FLAG( uiCode, "tiles_enabled_flag"               );    pcPPS->setTilesEnabledFlag            ( uiCode == 1 );
262  READ_FLAG( uiCode, "entropy_coding_sync_enabled_flag" );    pcPPS->setEntropyCodingSyncEnabledFlag( uiCode == 1 );
263
264  if( pcPPS->getTilesEnabledFlag() )
265  {
266    READ_UVLC ( uiCode, "num_tile_columns_minus1" );                pcPPS->setNumTileColumnsMinus1( uiCode ); 
267    READ_UVLC ( uiCode, "num_tile_rows_minus1" );                   pcPPS->setNumTileRowsMinus1( uiCode ); 
268    READ_FLAG ( uiCode, "uniform_spacing_flag" );                   pcPPS->setTileUniformSpacingFlag( uiCode == 1 );
269
270    const UInt tileColumnsMinus1 = pcPPS->getNumTileColumnsMinus1();
271    const UInt tileRowsMinus1    = pcPPS->getNumTileRowsMinus1();
272 
273    if ( !pcPPS->getTileUniformSpacingFlag())
274    {
275      if (tileColumnsMinus1 > 0)
276      {
277        std::vector<Int> columnWidth(tileColumnsMinus1);
278        for(UInt i = 0; i < tileColumnsMinus1; i++)
279        { 
280          READ_UVLC( uiCode, "column_width_minus1" ); 
281          columnWidth[i] = uiCode+1;
282        }
283        pcPPS->setTileColumnWidth(columnWidth);
284      }
285
286      if (tileRowsMinus1 > 0)
287      {
288        std::vector<Int> rowHeight (tileRowsMinus1);
289        for(UInt i = 0; i < tileRowsMinus1; i++)
290        {
291          READ_UVLC( uiCode, "row_height_minus1" );
292          rowHeight[i] = uiCode + 1;
293        }
294        pcPPS->setTileRowHeight(rowHeight);
295      }
296    }
297
298    if ((tileColumnsMinus1 + tileRowsMinus1) != 0)
299    {
300      READ_FLAG ( uiCode, "loop_filter_across_tiles_enabled_flag" );   pcPPS->setLoopFilterAcrossTilesEnabledFlag( uiCode ? true : false );
301    }
302  }
303  READ_FLAG( uiCode, "loop_filter_across_slices_enabled_flag" );       pcPPS->setLoopFilterAcrossSlicesEnabledFlag( uiCode ? true : false );
304  READ_FLAG( uiCode, "deblocking_filter_control_present_flag" );       pcPPS->setDeblockingFilterControlPresentFlag( uiCode ? true : false );
305  if(pcPPS->getDeblockingFilterControlPresentFlag())
306  {
307    READ_FLAG( uiCode, "deblocking_filter_override_enabled_flag" );    pcPPS->setDeblockingFilterOverrideEnabledFlag( uiCode ? true : false );
308    READ_FLAG( uiCode, "pps_disable_deblocking_filter_flag" );         pcPPS->setPicDisableDeblockingFilterFlag(uiCode ? true : false );
309    if(!pcPPS->getPicDisableDeblockingFilterFlag())
310    {
311      READ_SVLC ( iCode, "pps_beta_offset_div2" );                     pcPPS->setDeblockingFilterBetaOffsetDiv2( iCode );
312      READ_SVLC ( iCode, "pps_tc_offset_div2" );                       pcPPS->setDeblockingFilterTcOffsetDiv2( iCode );
313    }
314  }
315  READ_FLAG( uiCode, "pps_scaling_list_data_present_flag" );           pcPPS->setScalingListPresentFlag( uiCode ? true : false );
316  if(pcPPS->getScalingListPresentFlag ())
317  {
318    parseScalingList( pcPPS->getScalingList() );
319  }
320
321  READ_FLAG( uiCode, "lists_modification_present_flag");
322  pcPPS->setListsModificationPresentFlag(uiCode);
323
324  READ_UVLC( uiCode, "log2_parallel_merge_level_minus2");
325  pcPPS->setLog2ParallelMergeLevelMinus2 (uiCode);
326
327  READ_FLAG( uiCode, "slice_segment_header_extension_present_flag");
328  pcPPS->setSliceHeaderExtensionPresentFlag(uiCode);
329
330  READ_FLAG( uiCode, "pps_extension_present_flag");
331
332#if SVC_EXTENSION
333  pcPPS->setExtensionFlag( uiCode ? true : false );
334  if( pcPPS->getExtensionFlag() )
335#else
336  if (uiCode)
337#endif
338  {
339    Bool pps_extension_flags[NUM_PPS_EXTENSION_FLAGS];
340    for(Int i=0; i<NUM_PPS_EXTENSION_FLAGS; i++)
341    {
342      READ_FLAG( uiCode, "pps_extension_flag[]" );
343      pps_extension_flags[i] = uiCode!=0;
344    }
345
346    Bool bSkipTrailingExtensionBits=false;
347    for(Int i=0; i<NUM_PPS_EXTENSION_FLAGS; i++) // loop used so that the order is determined by the enum.
348    {
349      if (pps_extension_flags[i])
350      {
351        switch (PPSExtensionFlagIndex(i))
352        {
353          case PPS_EXT__REXT:
354            assert(!bSkipTrailingExtensionBits);
355
356            if (pcPPS->getUseTransformSkip())
357            {
358              READ_UVLC( uiCode, "log2_transform_skip_max_size_minus2");
359              pcPPS->setTransformSkipLog2MaxSize(uiCode+2);
360            }
361
362            READ_FLAG( uiCode, "cross_component_prediction_flag");
363            pcPPS->setUseCrossComponentPrediction(uiCode != 0);
364
365            READ_FLAG( uiCode, "chroma_qp_adjustment_enabled_flag");
366            if (uiCode == 0)
367            {
368              pcPPS->clearChromaQpAdjTable();
369              pcPPS->setMaxCuChromaQpAdjDepth(0);
370            }
371            else
372            {
373              READ_UVLC(uiCode, "diff_cu_chroma_qp_adjustment_depth"); pcPPS->setMaxCuChromaQpAdjDepth(uiCode);
374              UInt tableSizeMinus1 = 0;
375              READ_UVLC(tableSizeMinus1, "chroma_qp_adjustment_table_size_minus1");
376              /* skip zero index */
377              for (Int chromaQpAdjustmentIndex = 1; chromaQpAdjustmentIndex <= (tableSizeMinus1 + 1); chromaQpAdjustmentIndex++)
378              {
379                Int cbOffset;
380                Int crOffset;
381                READ_SVLC(cbOffset, "cb_qp_adjustnemt[i]");
382                READ_SVLC(crOffset, "cr_qp_adjustnemt[i]");
383                pcPPS->setChromaQpAdjTableAt(chromaQpAdjustmentIndex, cbOffset, crOffset);
384              }
385              assert(pcPPS->getChromaQpAdjTableSize() == tableSizeMinus1 + 1);
386            }
387
388            READ_UVLC( uiCode, "sao_luma_bit_shift");
389            pcPPS->setSaoOffsetBitShift(CHANNEL_TYPE_LUMA, uiCode);
390            READ_UVLC( uiCode, "sao_chroma_bit_shift");
391            pcPPS->setSaoOffsetBitShift(CHANNEL_TYPE_CHROMA, uiCode);
392            break;
393
394#if SVC_EXTENSION
395          case PPS_EXT__MLAYER:
396            READ_FLAG( uiCode, "poc_reset_info_present_flag" );
397            pcPPS->setPocResetInfoPresentFlag(uiCode ? true : false);
398
399#if SCALINGLIST_INFERRING
400            READ_FLAG( uiCode, "pps_infer_scaling_list_flag" );
401            pcPPS->setInferScalingListFlag( uiCode );
402
403            if( pcPPS->getInferScalingListFlag() )
404            {
405              READ_CODE( 6, uiCode, "pps_scaling_list_ref_layer_id" ); 
406              pcPPS->setScalingListRefLayerId( uiCode );
407              // The value of pps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
408              assert( pcPPS->getScalingListRefLayerId() <= 62 );
409              pcPPS->setScalingListPresentFlag( false );
410            }
411#endif
412
413#if REF_REGION_OFFSET
414            READ_UVLC( uiCode,      "num_ref_loc_offsets" ); pcPPS->setNumScaledRefLayerOffsets(uiCode);
415            for(Int k = 0; k < pcPPS->getNumScaledRefLayerOffsets(); k++)
416            {
417              READ_CODE( 6, uiCode,  "ref_loc_offset_layer_id" );  pcPPS->setScaledRefLayerId( k, uiCode );
418              READ_FLAG( uiCode, "scaled_ref_layer_offset_present_flag" );   pcPPS->setScaledRefLayerOffsetPresentFlag( k, uiCode );
419              if (uiCode)
420              {
421                Window& scaledWindow = pcPPS->getScaledRefLayerWindow(k);
422                READ_SVLC( iCode, "scaled_ref_layer_left_offset" );    scaledWindow.setWindowLeftOffset  (iCode << 1);
423                READ_SVLC( iCode, "scaled_ref_layer_top_offset" );     scaledWindow.setWindowTopOffset   (iCode << 1);
424                READ_SVLC( iCode, "scaled_ref_layer_right_offset" );   scaledWindow.setWindowRightOffset (iCode << 1);
425                READ_SVLC( iCode, "scaled_ref_layer_bottom_offset" );  scaledWindow.setWindowBottomOffset(iCode << 1);
426#if P0312_VERT_PHASE_ADJ
427                READ_FLAG( uiCode, "vert_phase_position_enable_flag" ); scaledWindow.setVertPhasePositionEnableFlag(uiCode);  pcPPS->setVertPhasePositionEnableFlag( pcPPS->getScaledRefLayerId(i), uiCode);
428#endif
429              }
430              READ_FLAG( uiCode, "ref_region_offset_present_flag" );   pcPPS->setRefRegionOffsetPresentFlag( k, uiCode );
431              if (uiCode)
432              {
433                Window& refWindow = pcPPS->getRefLayerWindow(k);
434                READ_SVLC( iCode, "ref_region_left_offset" );    refWindow.setWindowLeftOffset  (iCode << 1);
435                READ_SVLC( iCode, "ref_region_top_offset" );     refWindow.setWindowTopOffset   (iCode << 1);
436                READ_SVLC( iCode, "ref_region_right_offset" );   refWindow.setWindowRightOffset (iCode << 1);
437                READ_SVLC( iCode, "ref_region_bottom_offset" );  refWindow.setWindowBottomOffset(iCode << 1);
438              }
439#if R0209_GENERIC_PHASE
440              READ_FLAG( uiCode, "resample_phase_set_present_flag" );   pcPPS->setResamplePhaseSetPresentFlag( k, uiCode );
441              if (uiCode)
442              {
443                READ_UVLC( uiCode, "phase_hor_luma" );    pcPPS->setPhaseHorLuma ( k, uiCode );
444                READ_UVLC( uiCode, "phase_ver_luma" );    pcPPS->setPhaseVerLuma ( k, uiCode );
445                READ_UVLC( uiCode, "phase_hor_chroma_plus8" );  pcPPS->setPhaseHorChroma (k, uiCode - 8);
446                READ_UVLC( uiCode, "phase_ver_chroma_plus8" );  pcPPS->setPhaseVerChroma (k, uiCode - 8);
447              }
448#endif
449            }
450#else
451#if MOVE_SCALED_OFFSET_TO_PPS
452            READ_UVLC( uiCode,      "num_scaled_ref_layer_offsets" ); pcPPS->setNumScaledRefLayerOffsets(uiCode);
453            for(Int k = 0; k < pcPPS->getNumScaledRefLayerOffsets(); k++)
454            {
455              Window& scaledWindow = pcPPS->getScaledRefLayerWindow(k);
456#if O0098_SCALED_REF_LAYER_ID
457              READ_CODE( 6,  uiCode,  "scaled_ref_layer_id" );       pcPPS->setScaledRefLayerId( k, uiCode );
458#endif
459              READ_SVLC( iCode, "scaled_ref_layer_left_offset" );    scaledWindow.setWindowLeftOffset  (iCode << 1);
460              READ_SVLC( iCode, "scaled_ref_layer_top_offset" );     scaledWindow.setWindowTopOffset   (iCode << 1);
461              READ_SVLC( iCode, "scaled_ref_layer_right_offset" );   scaledWindow.setWindowRightOffset (iCode << 1);
462              READ_SVLC( iCode, "scaled_ref_layer_bottom_offset" );  scaledWindow.setWindowBottomOffset(iCode << 1);
463#if P0312_VERT_PHASE_ADJ
464              READ_FLAG( uiCode, "vert_phase_position_enable_flag" ); scaledWindow.setVertPhasePositionEnableFlag(uiCode);  pcPPS->setVertPhasePositionEnableFlag( pcPPS->getScaledRefLayerId(k), uiCode);
465#endif
466            }
467#endif
468#endif
469#if Q0048_CGS_3D_ASYMLUT
470            READ_FLAG( uiCode , "colour_mapping_enabled_flag" ); 
471            pcPPS->setCGSFlag( uiCode );
472            if( pcPPS->getCGSFlag() )
473            {
474#if R0157_RESTRICT_PPSID_FOR_CGS_LUT
475              // when pps_pic_parameter_set_id greater than or equal to 8, colour_mapping_enabled_flag shall be equal to 0
476              assert( pcPPS->getPPSId() < 8 );
477#endif
478              xParse3DAsymLUT( pc3DAsymLUT );
479              pcPPS->setCGSOutputBitDepthY( pc3DAsymLUT->getOutputBitDepthY() );
480              pcPPS->setCGSOutputBitDepthC( pc3DAsymLUT->getOutputBitDepthC() );
481            }
482#endif
483            break;
484#endif
485          default:
486            bSkipTrailingExtensionBits=true;
487            break;
488        }
489      }
490    }
491    if (bSkipTrailingExtensionBits)
492    {
493      while ( xMoreRbspData() )
494      {
495        READ_FLAG( uiCode, "pps_extension_data_flag");
496      }
497    }
498  }
499}
500
501Void  TDecCavlc::parseVUI(TComVUI* pcVUI, TComSPS *pcSPS)
502{
503#if ENC_DEC_TRACE
504  fprintf( g_hTrace, "----------- vui_parameters -----------\n");
505#endif
506  UInt  uiCode;
507
508  READ_FLAG(     uiCode, "aspect_ratio_info_present_flag");           pcVUI->setAspectRatioInfoPresentFlag(uiCode);
509  if (pcVUI->getAspectRatioInfoPresentFlag())
510  {
511    READ_CODE(8, uiCode, "aspect_ratio_idc");                         pcVUI->setAspectRatioIdc(uiCode);
512    if (pcVUI->getAspectRatioIdc() == 255)
513    {
514      READ_CODE(16, uiCode, "sar_width");                             pcVUI->setSarWidth(uiCode);
515      READ_CODE(16, uiCode, "sar_height");                            pcVUI->setSarHeight(uiCode);
516    }
517  }
518
519  READ_FLAG(     uiCode, "overscan_info_present_flag");               pcVUI->setOverscanInfoPresentFlag(uiCode);
520  if (pcVUI->getOverscanInfoPresentFlag())
521  {
522    READ_FLAG(   uiCode, "overscan_appropriate_flag");                pcVUI->setOverscanAppropriateFlag(uiCode);
523  }
524
525  READ_FLAG(     uiCode, "video_signal_type_present_flag");           pcVUI->setVideoSignalTypePresentFlag(uiCode);
526  if (pcVUI->getVideoSignalTypePresentFlag())
527  {
528    READ_CODE(3, uiCode, "video_format");                             pcVUI->setVideoFormat(uiCode);
529    READ_FLAG(   uiCode, "video_full_range_flag");                    pcVUI->setVideoFullRangeFlag(uiCode);
530    READ_FLAG(   uiCode, "colour_description_present_flag");          pcVUI->setColourDescriptionPresentFlag(uiCode);
531    if (pcVUI->getColourDescriptionPresentFlag())
532    {
533      READ_CODE(8, uiCode, "colour_primaries");                       pcVUI->setColourPrimaries(uiCode);
534      READ_CODE(8, uiCode, "transfer_characteristics");               pcVUI->setTransferCharacteristics(uiCode);
535      READ_CODE(8, uiCode, "matrix_coefficients");                    pcVUI->setMatrixCoefficients(uiCode);
536    }
537  }
538
539  READ_FLAG(     uiCode, "chroma_loc_info_present_flag");             pcVUI->setChromaLocInfoPresentFlag(uiCode);
540  if (pcVUI->getChromaLocInfoPresentFlag())
541  {
542    READ_UVLC(   uiCode, "chroma_sample_loc_type_top_field" );        pcVUI->setChromaSampleLocTypeTopField(uiCode);
543    READ_UVLC(   uiCode, "chroma_sample_loc_type_bottom_field" );     pcVUI->setChromaSampleLocTypeBottomField(uiCode);
544  }
545
546  READ_FLAG(     uiCode, "neutral_chroma_indication_flag");           pcVUI->setNeutralChromaIndicationFlag(uiCode);
547
548  READ_FLAG(     uiCode, "field_seq_flag");                           pcVUI->setFieldSeqFlag(uiCode);
549
550  READ_FLAG(uiCode, "frame_field_info_present_flag");                 pcVUI->setFrameFieldInfoPresentFlag(uiCode);
551
552  READ_FLAG(     uiCode, "default_display_window_flag");
553  if (uiCode != 0)
554  {
555    Window &defDisp = pcVUI->getDefaultDisplayWindow();
556    READ_UVLC(   uiCode, "def_disp_win_left_offset" );                defDisp.setWindowLeftOffset  ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc()) );
557    READ_UVLC(   uiCode, "def_disp_win_right_offset" );               defDisp.setWindowRightOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc()) );
558    READ_UVLC(   uiCode, "def_disp_win_top_offset" );                 defDisp.setWindowTopOffset   ( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc()) );
559    READ_UVLC(   uiCode, "def_disp_win_bottom_offset" );              defDisp.setWindowBottomOffset( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc()) );
560  }
561
562  TimingInfo *timingInfo = pcVUI->getTimingInfo();
563  READ_FLAG(       uiCode, "vui_timing_info_present_flag");         timingInfo->setTimingInfoPresentFlag      (uiCode ? true : false);
564#if SVC_EXTENSION
565  if( pcSPS->getLayerId() > 0 )
566  {
567    assert( timingInfo->getTimingInfoPresentFlag() == false );
568  }
569#endif
570  if(timingInfo->getTimingInfoPresentFlag())
571  {
572    READ_CODE( 32, uiCode, "vui_num_units_in_tick");                timingInfo->setNumUnitsInTick             (uiCode);
573    READ_CODE( 32, uiCode, "vui_time_scale");                       timingInfo->setTimeScale                  (uiCode);
574    READ_FLAG(     uiCode, "vui_poc_proportional_to_timing_flag");  timingInfo->setPocProportionalToTimingFlag(uiCode ? true : false);
575    if(timingInfo->getPocProportionalToTimingFlag())
576    {
577      READ_UVLC(   uiCode, "vui_num_ticks_poc_diff_one_minus1");    timingInfo->setNumTicksPocDiffOneMinus1   (uiCode);
578    }
579
580    READ_FLAG(     uiCode, "hrd_parameters_present_flag");              pcVUI->setHrdParametersPresentFlag(uiCode);
581    if( pcVUI->getHrdParametersPresentFlag() )
582    {
583      parseHrdParameters( pcVUI->getHrdParameters(), 1, pcSPS->getMaxTLayers() - 1 );
584    }
585  }
586
587  READ_FLAG(     uiCode, "bitstream_restriction_flag");               pcVUI->setBitstreamRestrictionFlag(uiCode);
588  if (pcVUI->getBitstreamRestrictionFlag())
589  {
590    READ_FLAG(   uiCode, "tiles_fixed_structure_flag");               pcVUI->setTilesFixedStructureFlag(uiCode);
591    READ_FLAG(   uiCode, "motion_vectors_over_pic_boundaries_flag");  pcVUI->setMotionVectorsOverPicBoundariesFlag(uiCode);
592    READ_FLAG(   uiCode, "restricted_ref_pic_lists_flag");            pcVUI->setRestrictedRefPicListsFlag(uiCode);
593    READ_UVLC( uiCode, "min_spatial_segmentation_idc");            pcVUI->setMinSpatialSegmentationIdc(uiCode);
594    assert(uiCode < 4096);
595    READ_UVLC(   uiCode, "max_bytes_per_pic_denom" );                 pcVUI->setMaxBytesPerPicDenom(uiCode);
596    READ_UVLC(   uiCode, "max_bits_per_mincu_denom" );                pcVUI->setMaxBitsPerMinCuDenom(uiCode);
597    READ_UVLC(   uiCode, "log2_max_mv_length_horizontal" );           pcVUI->setLog2MaxMvLengthHorizontal(uiCode);
598    READ_UVLC(   uiCode, "log2_max_mv_length_vertical" );             pcVUI->setLog2MaxMvLengthVertical(uiCode);
599  }
600}
601
602Void TDecCavlc::parseHrdParameters(TComHRD *hrd, Bool commonInfPresentFlag, UInt maxNumSubLayersMinus1)
603{
604  UInt  uiCode;
605  if( commonInfPresentFlag )
606  {
607    READ_FLAG( uiCode, "nal_hrd_parameters_present_flag" );           hrd->setNalHrdParametersPresentFlag( uiCode == 1 ? true : false );
608    READ_FLAG( uiCode, "vcl_hrd_parameters_present_flag" );           hrd->setVclHrdParametersPresentFlag( uiCode == 1 ? true : false );
609    if( hrd->getNalHrdParametersPresentFlag() || hrd->getVclHrdParametersPresentFlag() )
610    {
611      READ_FLAG( uiCode, "sub_pic_cpb_params_present_flag" );         hrd->setSubPicCpbParamsPresentFlag( uiCode == 1 ? true : false );
612      if( hrd->getSubPicCpbParamsPresentFlag() )
613      {
614        READ_CODE( 8, uiCode, "tick_divisor_minus2" );                hrd->setTickDivisorMinus2( uiCode );
615        READ_CODE( 5, uiCode, "du_cpb_removal_delay_length_minus1" ); hrd->setDuCpbRemovalDelayLengthMinus1( uiCode );
616        READ_FLAG( uiCode, "sub_pic_cpb_params_in_pic_timing_sei_flag" ); hrd->setSubPicCpbParamsInPicTimingSEIFlag( uiCode == 1 ? true : false );
617        READ_CODE( 5, uiCode, "dpb_output_delay_du_length_minus1"  ); hrd->setDpbOutputDelayDuLengthMinus1( uiCode );
618      }
619      READ_CODE( 4, uiCode, "bit_rate_scale" );                       hrd->setBitRateScale( uiCode );
620      READ_CODE( 4, uiCode, "cpb_size_scale" );                       hrd->setCpbSizeScale( uiCode );
621      if( hrd->getSubPicCpbParamsPresentFlag() )
622      {
623        READ_CODE( 4, uiCode, "cpb_size_du_scale" );                  hrd->setDuCpbSizeScale( uiCode );
624      }
625      READ_CODE( 5, uiCode, "initial_cpb_removal_delay_length_minus1" ); hrd->setInitialCpbRemovalDelayLengthMinus1( uiCode );
626      READ_CODE( 5, uiCode, "au_cpb_removal_delay_length_minus1" );      hrd->setCpbRemovalDelayLengthMinus1( uiCode );
627      READ_CODE( 5, uiCode, "dpb_output_delay_length_minus1" );       hrd->setDpbOutputDelayLengthMinus1( uiCode );
628    }
629#if VPS_VUI_BSP_HRD_PARAMS
630    else
631    {
632      hrd->setInitialCpbRemovalDelayLengthMinus1( 23 );
633      // Add inferred values for other syntax elements here.
634    }
635#endif
636  }
637  Int i, j, nalOrVcl;
638  for( i = 0; i <= maxNumSubLayersMinus1; i ++ )
639  {
640    READ_FLAG( uiCode, "fixed_pic_rate_general_flag" );                     hrd->setFixedPicRateFlag( i, uiCode == 1 ? true : false  );
641    if( !hrd->getFixedPicRateFlag( i ) )
642    {
643      READ_FLAG( uiCode, "fixed_pic_rate_within_cvs_flag" );                hrd->setFixedPicRateWithinCvsFlag( i, uiCode == 1 ? true : false  );
644    }
645    else
646    {
647      hrd->setFixedPicRateWithinCvsFlag( i, true );
648    }
649
650    hrd->setLowDelayHrdFlag( i, 0 ); // Infered to be 0 when not present
651    hrd->setCpbCntMinus1   ( i, 0 ); // Infered to be 0 when not present
652
653    if( hrd->getFixedPicRateWithinCvsFlag( i ) )
654    {
655      READ_UVLC( uiCode, "elemental_duration_in_tc_minus1" );             hrd->setPicDurationInTcMinus1( i, uiCode );
656    }
657    else
658    {
659      READ_FLAG( uiCode, "low_delay_hrd_flag" );                      hrd->setLowDelayHrdFlag( i, uiCode == 1 ? true : false  );
660    }
661    if (!hrd->getLowDelayHrdFlag( i ))
662    {
663      READ_UVLC( uiCode, "cpb_cnt_minus1" );                          hrd->setCpbCntMinus1( i, uiCode );
664    }
665
666    for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
667    {
668      if( ( ( nalOrVcl == 0 ) && ( hrd->getNalHrdParametersPresentFlag() ) ) ||
669          ( ( nalOrVcl == 1 ) && ( hrd->getVclHrdParametersPresentFlag() ) ) )
670      {
671        for( j = 0; j <= ( hrd->getCpbCntMinus1( i ) ); j ++ )
672        {
673          READ_UVLC( uiCode, "bit_rate_value_minus1" );             hrd->setBitRateValueMinus1( i, j, nalOrVcl, uiCode );
674          READ_UVLC( uiCode, "cpb_size_value_minus1" );             hrd->setCpbSizeValueMinus1( i, j, nalOrVcl, uiCode );
675          if( hrd->getSubPicCpbParamsPresentFlag() )
676          {
677            READ_UVLC( uiCode, "cpb_size_du_value_minus1" );       hrd->setDuCpbSizeValueMinus1( i, j, nalOrVcl, uiCode );
678            READ_UVLC( uiCode, "bit_rate_du_value_minus1" );       hrd->setDuBitRateValueMinus1( i, j, nalOrVcl, uiCode );
679          }
680          READ_FLAG( uiCode, "cbr_flag" );                          hrd->setCbrFlag( i, j, nalOrVcl, uiCode == 1 ? true : false  );
681        }
682      }
683    }
684  }
685}
686
687Void TDecCavlc::parseSPS(TComSPS* pcSPS)
688{
689#if ENC_DEC_TRACE
690  xTraceSPSHeader (pcSPS);
691#endif
692
693  UInt  uiCode;
694  READ_CODE( 4,  uiCode, "sps_video_parameter_set_id");          pcSPS->setVPSId        ( uiCode );
695
696#if SVC_EXTENSION
697  UInt uiTmp = 0;
698 
699  if(pcSPS->getLayerId() == 0)
700  {
701#endif
702  READ_CODE( 3,  uiCode, "sps_max_sub_layers_minus1" );          pcSPS->setMaxTLayers   ( uiCode+1 );
703  assert(uiCode <= 6);
704#if SVC_EXTENSION
705  }
706  else
707  {
708    READ_CODE( 3,  uiCode, "sps_ext_or_max_sub_layers_minus1" );     uiTmp = uiCode;
709
710    if( uiTmp != 7 )
711    {
712      pcSPS->setMaxTLayers(uiTmp + 1);
713    }
714  }
715
716  Bool V1CompatibleSPSFlag = !( pcSPS->getLayerId() != 0 && uiTmp == 7 );
717
718  if( V1CompatibleSPSFlag )
719  {
720#endif
721  READ_FLAG( uiCode, "sps_temporal_id_nesting_flag" );           pcSPS->setTemporalIdNestingFlag ( uiCode > 0 ? true : false );
722  parsePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
723#if SVC_EXTENSION
724  }
725#else
726  if ( pcSPS->getMaxTLayers() == 1 )
727  {
728    // sps_temporal_id_nesting_flag must be 1 when sps_max_sub_layers_minus1 is 0
729    assert( uiCode == 1 );
730  }
731#endif
732
733  READ_UVLC(     uiCode, "sps_seq_parameter_set_id" );           pcSPS->setSPSId( uiCode );
734  assert(uiCode <= 15);
735
736#if SVC_EXTENSION
737  if( !V1CompatibleSPSFlag )
738  {
739    READ_FLAG( uiCode, "update_rep_format_flag" );
740    pcSPS->setUpdateRepFormatFlag( uiCode ? true : false );
741   
742    if( pcSPS->getUpdateRepFormatFlag() )
743    {
744      READ_CODE(8, uiCode, "sps_rep_format_idx");
745      pcSPS->setUpdateRepFormatIndex(uiCode);
746    }
747  }
748  else
749  {
750    pcSPS->setUpdateRepFormatFlag( false );
751#endif
752  READ_UVLC(     uiCode, "chroma_format_idc" );                  pcSPS->setChromaFormatIdc( ChromaFormat(uiCode) );
753  assert(uiCode <= 3);
754
755  if( pcSPS->getChromaFormatIdc() == CHROMA_444 )
756  {
757    READ_FLAG(     uiCode, "separate_colour_plane_flag");        assert(uiCode == 0);
758  }
759
760  READ_UVLC (    uiCode, "pic_width_in_luma_samples" );          pcSPS->setPicWidthInLumaSamples ( uiCode    );
761  READ_UVLC (    uiCode, "pic_height_in_luma_samples" );         pcSPS->setPicHeightInLumaSamples( uiCode    );
762  READ_FLAG(     uiCode, "conformance_window_flag");
763  if (uiCode != 0)
764  {
765    Window &conf = pcSPS->getConformanceWindow();
766#if REPN_FORMAT_IN_VPS
767    READ_UVLC(   uiCode, "conf_win_left_offset" );               conf.setWindowLeftOffset  ( uiCode );
768    READ_UVLC(   uiCode, "conf_win_right_offset" );              conf.setWindowRightOffset ( uiCode );
769    READ_UVLC(   uiCode, "conf_win_top_offset" );                conf.setWindowTopOffset   ( uiCode );
770    READ_UVLC(   uiCode, "conf_win_bottom_offset" );             conf.setWindowBottomOffset( uiCode );
771#else
772    READ_UVLC(   uiCode, "conf_win_left_offset" );               conf.setWindowLeftOffset  ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc() ) );
773    READ_UVLC(   uiCode, "conf_win_right_offset" );              conf.setWindowRightOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc() ) );
774    READ_UVLC(   uiCode, "conf_win_top_offset" );                conf.setWindowTopOffset   ( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc() ) );
775    READ_UVLC(   uiCode, "conf_win_bottom_offset" );             conf.setWindowBottomOffset( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc() ) );
776#endif
777  }
778
779  READ_UVLC(     uiCode, "bit_depth_luma_minus8" );
780#if O0043_BEST_EFFORT_DECODING
781  const UInt forceDecodeBitDepth = pcSPS->getForceDecodeBitDepth();
782  g_bitDepthInStream[CHANNEL_TYPE_LUMA] = 8 + uiCode;
783  if (forceDecodeBitDepth != 0)
784  {
785    uiCode = forceDecodeBitDepth - 8;
786  }
787#endif
788  assert(uiCode <= 8);
789
790  pcSPS->setBitDepth(CHANNEL_TYPE_LUMA, 8 + uiCode);
791#if O0043_BEST_EFFORT_DECODING
792  pcSPS->setQpBDOffset(CHANNEL_TYPE_LUMA, (Int) (6*(g_bitDepthInStream[CHANNEL_TYPE_LUMA]-8)) );
793#else
794  pcSPS->setQpBDOffset(CHANNEL_TYPE_LUMA, (Int) (6*uiCode) );
795#endif
796
797  READ_UVLC( uiCode,    "bit_depth_chroma_minus8" );
798#if O0043_BEST_EFFORT_DECODING
799  g_bitDepthInStream[CHANNEL_TYPE_CHROMA] = 8 + uiCode;
800  if (forceDecodeBitDepth != 0)
801  {
802    uiCode = forceDecodeBitDepth - 8;
803  }
804#endif
805  assert(uiCode <= 8);
806  pcSPS->setBitDepth(CHANNEL_TYPE_CHROMA, 8 + uiCode);
807#if O0043_BEST_EFFORT_DECODING
808  pcSPS->setQpBDOffset(CHANNEL_TYPE_CHROMA,  (Int) (6*(g_bitDepthInStream[CHANNEL_TYPE_CHROMA]-8)) );
809#else
810  pcSPS->setQpBDOffset(CHANNEL_TYPE_CHROMA,  (Int) (6*uiCode) );
811#endif
812
813#if SVC_EXTENSION
814  }
815#endif
816
817
818  READ_UVLC( uiCode,    "log2_max_pic_order_cnt_lsb_minus4" );   pcSPS->setBitsForPOC( 4 + uiCode );
819  assert(uiCode <= 12);
820
821#if SVC_EXTENSION
822  if( V1CompatibleSPSFlag ) 
823  {
824#endif
825  UInt subLayerOrderingInfoPresentFlag;
826  READ_FLAG(subLayerOrderingInfoPresentFlag, "sps_sub_layer_ordering_info_present_flag");
827
828  for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
829  {
830    READ_UVLC ( uiCode, "sps_max_dec_pic_buffering_minus1[i]");
831    pcSPS->setMaxDecPicBuffering( uiCode + 1, i);
832    READ_UVLC ( uiCode, "sps_num_reorder_pics[i]" );
833    pcSPS->setNumReorderPics(uiCode, i);
834    READ_UVLC ( uiCode, "sps_max_latency_increase_plus1[i]");
835    pcSPS->setMaxLatencyIncrease( uiCode, i );
836
837    if (!subLayerOrderingInfoPresentFlag)
838    {
839      for (i++; i <= pcSPS->getMaxTLayers()-1; i++)
840      {
841        pcSPS->setMaxDecPicBuffering(pcSPS->getMaxDecPicBuffering(0), i);
842        pcSPS->setNumReorderPics(pcSPS->getNumReorderPics(0), i);
843        pcSPS->setMaxLatencyIncrease(pcSPS->getMaxLatencyIncrease(0), i);
844      }
845      break;
846    }
847  }
848#if SVC_EXTENSION
849  }
850#endif
851  READ_UVLC( uiCode, "log2_min_coding_block_size_minus3" );
852  Int log2MinCUSize = uiCode + 3;
853  pcSPS->setLog2MinCodingBlockSize(log2MinCUSize);
854  READ_UVLC( uiCode, "log2_diff_max_min_coding_block_size" );
855  pcSPS->setLog2DiffMaxMinCodingBlockSize(uiCode);
856 
857  if (pcSPS->getPTL()->getGeneralPTL()->getLevelIdc() >= Level::LEVEL5)
858  {
859    assert(log2MinCUSize + pcSPS->getLog2DiffMaxMinCodingBlockSize() >= 5);
860  }
861 
862  Int maxCUDepthDelta = uiCode;
863  pcSPS->setMaxCUWidth  ( 1<<(log2MinCUSize + maxCUDepthDelta) );
864  pcSPS->setMaxCUHeight ( 1<<(log2MinCUSize + maxCUDepthDelta) );
865  READ_UVLC( uiCode, "log2_min_transform_block_size_minus2" );   pcSPS->setQuadtreeTULog2MinSize( uiCode + 2 );
866
867  READ_UVLC( uiCode, "log2_diff_max_min_transform_block_size" ); pcSPS->setQuadtreeTULog2MaxSize( uiCode + pcSPS->getQuadtreeTULog2MinSize() );
868  pcSPS->setMaxTrSize( 1<<(uiCode + pcSPS->getQuadtreeTULog2MinSize()) );
869
870  READ_UVLC( uiCode, "max_transform_hierarchy_depth_inter" );    pcSPS->setQuadtreeTUMaxDepthInter( uiCode+1 );
871  READ_UVLC( uiCode, "max_transform_hierarchy_depth_intra" );    pcSPS->setQuadtreeTUMaxDepthIntra( uiCode+1 );
872
873  Int addCuDepth = max (0, log2MinCUSize - (Int)pcSPS->getQuadtreeTULog2MinSize() );
874  pcSPS->setMaxCUDepth( maxCUDepthDelta + addCuDepth  + getMaxCUDepthOffset(pcSPS->getChromaFormatIdc(), pcSPS->getQuadtreeTULog2MinSize()) );
875
876  READ_FLAG( uiCode, "scaling_list_enabled_flag" );                 pcSPS->setScalingListFlag ( uiCode );
877  if(pcSPS->getScalingListFlag())
878  {
879#if SVC_EXTENSION
880    if( !V1CompatibleSPSFlag )
881    {
882      READ_FLAG( uiCode, "sps_infer_scaling_list_flag" ); pcSPS->setInferScalingListFlag( uiCode );
883    }
884
885    if( pcSPS->getInferScalingListFlag() )
886    {
887      READ_CODE( 6, uiCode, "sps_scaling_list_ref_layer_id" ); pcSPS->setScalingListRefLayerId( uiCode );
888
889      // The value of sps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
890      assert( pcSPS->getScalingListRefLayerId() <= 62 );
891
892      pcSPS->setScalingListPresentFlag( false );
893    }
894    else
895    {
896#endif
897    READ_FLAG( uiCode, "sps_scaling_list_data_present_flag" );                 pcSPS->setScalingListPresentFlag ( uiCode );
898    if(pcSPS->getScalingListPresentFlag ())
899    {
900      parseScalingList( pcSPS->getScalingList() );
901    }
902#if SVC_EXTENSION
903    }
904#endif
905  }
906  READ_FLAG( uiCode, "amp_enabled_flag" );                          pcSPS->setUseAMP( uiCode );
907  READ_FLAG( uiCode, "sample_adaptive_offset_enabled_flag" );       pcSPS->setUseSAO ( uiCode ? true : false );
908
909  READ_FLAG( uiCode, "pcm_enabled_flag" ); pcSPS->setUsePCM( uiCode ? true : false );
910  if( pcSPS->getUsePCM() )
911  {
912    READ_CODE( 4, uiCode, "pcm_sample_bit_depth_luma_minus1" );          pcSPS->setPCMBitDepth    ( CHANNEL_TYPE_LUMA, 1 + uiCode );
913    READ_CODE( 4, uiCode, "pcm_sample_bit_depth_chroma_minus1" );        pcSPS->setPCMBitDepth    ( CHANNEL_TYPE_CHROMA, 1 + uiCode );
914    READ_UVLC( uiCode, "log2_min_pcm_luma_coding_block_size_minus3" );   pcSPS->setPCMLog2MinSize (uiCode+3);
915    READ_UVLC( uiCode, "log2_diff_max_min_pcm_luma_coding_block_size" ); pcSPS->setPCMLog2MaxSize ( uiCode+pcSPS->getPCMLog2MinSize() );
916    READ_FLAG( uiCode, "pcm_loop_filter_disable_flag" );                 pcSPS->setPCMFilterDisableFlag ( uiCode ? true : false );
917  }
918
919  READ_UVLC( uiCode, "num_short_term_ref_pic_sets" );
920  assert(uiCode <= 64);
921  pcSPS->createRPSList(uiCode);
922
923  TComRPSList* rpsList = pcSPS->getRPSList();
924  TComReferencePictureSet* rps;
925
926  for(UInt i=0; i< rpsList->getNumberOfReferencePictureSets(); i++)
927  {
928    rps = rpsList->getReferencePictureSet(i);
929    parseShortTermRefPicSet(pcSPS,rps,i);
930  }
931  READ_FLAG( uiCode, "long_term_ref_pics_present_flag" );          pcSPS->setLongTermRefsPresent(uiCode);
932  if (pcSPS->getLongTermRefsPresent())
933  {
934    READ_UVLC( uiCode, "num_long_term_ref_pic_sps" );
935    pcSPS->setNumLongTermRefPicSPS(uiCode);
936    for (UInt k = 0; k < pcSPS->getNumLongTermRefPicSPS(); k++)
937    {
938      READ_CODE( pcSPS->getBitsForPOC(), uiCode, "lt_ref_pic_poc_lsb_sps" );
939      pcSPS->setLtRefPicPocLsbSps(k, uiCode);
940      READ_FLAG( uiCode,  "used_by_curr_pic_lt_sps_flag[i]");
941      pcSPS->setUsedByCurrPicLtSPSFlag(k, uiCode?1:0);
942    }
943  }
944  READ_FLAG( uiCode, "sps_temporal_mvp_enable_flag" );            pcSPS->setTMVPFlagsPresent(uiCode);
945
946  READ_FLAG( uiCode, "sps_strong_intra_smoothing_enable_flag" );  pcSPS->setUseStrongIntraSmoothing(uiCode);
947
948  READ_FLAG( uiCode, "vui_parameters_present_flag" );             pcSPS->setVuiParametersPresentFlag(uiCode);
949
950  if (pcSPS->getVuiParametersPresentFlag())
951  {
952    parseVUI(pcSPS->getVuiParameters(), pcSPS);
953  }
954
955  READ_FLAG( uiCode, "sps_extension_present_flag");
956
957#if SVC_EXTENSION
958  pcSPS->setExtensionFlag( uiCode ? true : false );
959
960  if( pcSPS->getExtensionFlag() )
961#else
962  if (uiCode)
963#endif
964  {
965    Bool sps_extension_flags[NUM_SPS_EXTENSION_FLAGS];
966    for(Int i=0; i<NUM_SPS_EXTENSION_FLAGS; i++)
967    {
968      READ_FLAG( uiCode, "sps_extension_flag[]" );
969      sps_extension_flags[i] = uiCode!=0;
970    }
971
972    Bool bSkipTrailingExtensionBits=false;
973    for(Int i=0; i<NUM_SPS_EXTENSION_FLAGS; i++) // loop used so that the order is determined by the enum.
974    {
975      if (sps_extension_flags[i])
976      {
977        switch (SPSExtensionFlagIndex(i))
978        {
979          case SPS_EXT__REXT:
980            assert(!bSkipTrailingExtensionBits);
981
982            READ_FLAG( uiCode, "transform_skip_rotation_enabled_flag");     pcSPS->setUseResidualRotation                    (uiCode != 0);
983            READ_FLAG( uiCode, "transform_skip_context_enabled_flag");      pcSPS->setUseSingleSignificanceMapContext        (uiCode != 0);
984            READ_FLAG( uiCode, "residual_dpcm_implicit_enabled_flag");      pcSPS->setUseResidualDPCM(RDPCM_SIGNAL_IMPLICIT, (uiCode != 0));
985            READ_FLAG( uiCode, "residual_dpcm_explicit_enabled_flag");      pcSPS->setUseResidualDPCM(RDPCM_SIGNAL_EXPLICIT, (uiCode != 0));
986            READ_FLAG( uiCode, "extended_precision_processing_flag");       pcSPS->setUseExtendedPrecision                   (uiCode != 0);
987            READ_FLAG( uiCode, "intra_smoothing_disabled_flag");            pcSPS->setDisableIntraReferenceSmoothing         (uiCode != 0);
988            READ_FLAG( uiCode, "high_precision_prediction_weighting_flag"); pcSPS->setUseHighPrecisionPredictionWeighting    (uiCode != 0);
989            READ_FLAG( uiCode, "golomb_rice_parameter_adaptation_flag");    pcSPS->setUseGolombRiceParameterAdaptation       (uiCode != 0);
990            READ_FLAG( uiCode, "cabac_bypass_alignment_enabled_flag");      pcSPS->setAlignCABACBeforeBypass                 (uiCode != 0);
991            break;
992#if SVC_EXTENSION
993          case SPS_EXT__MLAYER:
994            parseSPSExtension( pcSPS );
995            break;
996#endif
997          default:
998            bSkipTrailingExtensionBits=true;
999            break;
1000        }
1001      }
1002    }
1003    if (bSkipTrailingExtensionBits)
1004    {
1005      while ( xMoreRbspData() )
1006      {
1007        READ_FLAG( uiCode, "sps_extension_data_flag");
1008      }
1009    }
1010  }
1011}
1012
1013Void TDecCavlc::parseVPS(TComVPS* pcVPS)
1014{
1015  UInt  uiCode;
1016
1017  READ_CODE( 4,  uiCode,  "vps_video_parameter_set_id" );         pcVPS->setVPSId( uiCode );
1018#if VPS_RESERVED_FLAGS
1019  READ_FLAG( uiCode, "vps_base_layer_internal_flag");             pcVPS->setBaseLayerInternalFlag( uiCode ? true : false );
1020  READ_FLAG( uiCode, "vps_base_layer_available_flag");            pcVPS->setBaseLayerAvailableFlag( uiCode ? true : false );
1021#if VPS_AVC_BL_FLAG_REMOVAL
1022  pcVPS->setNonHEVCBaseLayerFlag( (pcVPS->getBaseLayerAvailableFlag() && !pcVPS->getBaseLayerInternalFlag()) ? true : false);
1023#endif
1024#else
1025  READ_CODE( 2,  uiCode,  "vps_reserved_three_2bits" );           assert(uiCode == 3);
1026#endif
1027#if SVC_EXTENSION
1028#if O0137_MAX_LAYERID
1029  READ_CODE( 6,  uiCode,  "vps_max_layers_minus1" );              pcVPS->setMaxLayers( min( 62u, uiCode) + 1 );
1030#else
1031  READ_CODE( 6,  uiCode,  "vps_max_layers_minus1" );              pcVPS->setMaxLayers( uiCode + 1 );
1032#endif
1033  assert( pcVPS->getBaseLayerInternalFlag() || pcVPS->getMaxLayers() > 1 );
1034#else
1035  READ_CODE( 6,  uiCode,  "vps_reserved_zero_6bits" );            assert(uiCode == 0);
1036#endif
1037  READ_CODE( 3,  uiCode,  "vps_max_sub_layers_minus1" );          pcVPS->setMaxTLayers( uiCode + 1 );    assert(uiCode+1 <= MAX_TLAYER);
1038  READ_FLAG(     uiCode,  "vps_temporal_id_nesting_flag" );       pcVPS->setTemporalNestingFlag( uiCode ? true:false );
1039  assert (pcVPS->getMaxTLayers()>1||pcVPS->getTemporalNestingFlag());
1040#if !P0125_REVERT_VPS_EXTN_OFFSET_TO_RESERVED
1041#if VPS_EXTN_OFFSET
1042  READ_CODE( 16, uiCode,  "vps_extension_offset" );               pcVPS->setExtensionOffset( uiCode );
1043#else
1044  READ_CODE( 16, uiCode,  "vps_reserved_ffff_16bits" );           assert(uiCode == 0xffff);
1045#endif
1046#else
1047  READ_CODE( 16, uiCode,  "vps_reserved_ffff_16bits" );           assert(uiCode == 0xffff);
1048#endif
1049  parsePTL ( pcVPS->getPTL(), true, pcVPS->getMaxTLayers()-1);
1050  UInt subLayerOrderingInfoPresentFlag;
1051  READ_FLAG(subLayerOrderingInfoPresentFlag, "vps_sub_layer_ordering_info_present_flag");
1052  for(UInt i = 0; i <= pcVPS->getMaxTLayers()-1; i++)
1053  {
1054    READ_UVLC( uiCode,  "vps_max_dec_pic_buffering_minus1[i]" );     pcVPS->setMaxDecPicBuffering( uiCode + 1, i );
1055    READ_UVLC( uiCode,  "vps_num_reorder_pics[i]" );          pcVPS->setNumReorderPics( uiCode, i );
1056    READ_UVLC( uiCode,  "vps_max_latency_increase_plus1[i]" );      pcVPS->setMaxLatencyIncrease( uiCode, i );
1057
1058    if (!subLayerOrderingInfoPresentFlag)
1059    {
1060      for (i++; i <= pcVPS->getMaxTLayers()-1; i++)
1061      {
1062        pcVPS->setMaxDecPicBuffering(pcVPS->getMaxDecPicBuffering(0), i);
1063        pcVPS->setNumReorderPics(pcVPS->getNumReorderPics(0), i);
1064        pcVPS->setMaxLatencyIncrease(pcVPS->getMaxLatencyIncrease(0), i);
1065      }
1066      break;
1067    }
1068  }
1069
1070#if SVC_EXTENSION
1071  assert( pcVPS->getNumHrdParameters() < MAX_VPS_LAYER_SETS_PLUS1 );
1072  assert( pcVPS->getMaxLayerId()       < MAX_VPS_LAYER_ID_PLUS1 );
1073  READ_CODE( 6, uiCode, "vps_max_layer_id" );           pcVPS->setMaxLayerId( uiCode );
1074#if Q0078_ADD_LAYER_SETS
1075  READ_UVLC(uiCode, "vps_num_layer_sets_minus1");  pcVPS->setVpsNumLayerSetsMinus1(uiCode);
1076  pcVPS->setNumLayerSets(pcVPS->getVpsNumLayerSetsMinus1() + 1);
1077  for (UInt opsIdx = 1; opsIdx <= pcVPS->getVpsNumLayerSetsMinus1(); opsIdx++)
1078#else
1079  READ_UVLC(    uiCode, "vps_num_layer_sets_minus1" );  pcVPS->setNumLayerSets( uiCode + 1 );
1080  for( UInt opsIdx = 1; opsIdx <= ( pcVPS->getNumLayerSets() - 1 ); opsIdx ++ )
1081#endif
1082  {
1083    // Operation point set
1084    for( UInt i = 0; i <= pcVPS->getMaxLayerId(); i ++ )
1085#else
1086  assert( pcVPS->getNumHrdParameters() < MAX_VPS_OP_SETS_PLUS1 );
1087  assert( pcVPS->getMaxNuhReservedZeroLayerId() < MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1 );
1088  READ_CODE( 6, uiCode, "vps_max_nuh_reserved_zero_layer_id" );   pcVPS->setMaxNuhReservedZeroLayerId( uiCode );
1089  READ_UVLC(    uiCode, "vps_max_op_sets_minus1" );               pcVPS->setMaxOpSets( uiCode + 1 );
1090  for( UInt opsIdx = 1; opsIdx <= ( pcVPS->getMaxOpSets() - 1 ); opsIdx ++ )
1091  {
1092    // Operation point set
1093    for( UInt i = 0; i <= pcVPS->getMaxNuhReservedZeroLayerId(); i ++ )
1094#endif
1095    {
1096      READ_FLAG( uiCode, "layer_id_included_flag[opsIdx][i]" );   pcVPS->setLayerIdIncludedFlag( uiCode == 1 ? true : false, opsIdx, i );
1097    }
1098  }
1099#if DERIVE_LAYER_ID_LIST_VARIABLES
1100  pcVPS->deriveLayerIdListVariables();
1101#endif
1102  TimingInfo *timingInfo = pcVPS->getTimingInfo();
1103  READ_FLAG(       uiCode, "vps_timing_info_present_flag");         timingInfo->setTimingInfoPresentFlag      (uiCode ? true : false);
1104  if(timingInfo->getTimingInfoPresentFlag())
1105  {
1106    READ_CODE( 32, uiCode, "vps_num_units_in_tick");                timingInfo->setNumUnitsInTick             (uiCode);
1107    READ_CODE( 32, uiCode, "vps_time_scale");                       timingInfo->setTimeScale                  (uiCode);
1108    READ_FLAG(     uiCode, "vps_poc_proportional_to_timing_flag");  timingInfo->setPocProportionalToTimingFlag(uiCode ? true : false);
1109    if(timingInfo->getPocProportionalToTimingFlag())
1110    {
1111      READ_UVLC(   uiCode, "vps_num_ticks_poc_diff_one_minus1");    timingInfo->setNumTicksPocDiffOneMinus1   (uiCode);
1112    }
1113
1114    READ_UVLC( uiCode, "vps_num_hrd_parameters" );                  pcVPS->setNumHrdParameters( uiCode );
1115
1116    if( pcVPS->getNumHrdParameters() > 0 )
1117    {
1118      pcVPS->createHrdParamBuffer();
1119    }
1120    for( UInt i = 0; i < pcVPS->getNumHrdParameters(); i ++ )
1121    {
1122      READ_UVLC( uiCode, "hrd_op_set_idx" );                       pcVPS->setHrdOpSetIdx( uiCode, i );
1123      if( i > 0 )
1124      {
1125        READ_FLAG( uiCode, "cprms_present_flag[i]" );               pcVPS->setCprmsPresentFlag( uiCode == 1 ? true : false, i );
1126      }
1127      else
1128      {
1129        pcVPS->setCprmsPresentFlag( true, i );
1130      }
1131
1132      parseHrdParameters(pcVPS->getHrdParameters(i), pcVPS->getCprmsPresentFlag( i ), pcVPS->getMaxTLayers() - 1);
1133    }
1134  }
1135
1136#if SVC_EXTENSION
1137  READ_FLAG( uiCode,  "vps_extension_flag" );      pcVPS->setVpsExtensionFlag( uiCode ? true : false );
1138
1139  // When MaxLayersMinus1 is greater than 0, vps_extension_flag shall be equal to 1.
1140  if( pcVPS->getMaxLayers() > 1 )
1141  {
1142    assert( pcVPS->getVpsExtensionFlag() == true );
1143  }
1144
1145  if( pcVPS->getVpsExtensionFlag()  )
1146  {
1147    while ( m_pcBitstream->getNumBitsRead() % 8 != 0 )
1148    {
1149      READ_FLAG( uiCode, "vps_extension_alignment_bit_equal_to_one"); assert(uiCode == 1);
1150    }
1151    parseVPSExtension(pcVPS);
1152    READ_FLAG( uiCode, "vps_entension2_flag" );
1153    if(uiCode)
1154    {
1155      while ( xMoreRbspData() )
1156      {
1157        READ_FLAG( uiCode, "vps_extension_data_flag");
1158      }
1159    }
1160  }
1161  else
1162  {
1163    // set default parameters when syntax elements are not present
1164    defaultVPSExtension(pcVPS);   
1165  }
1166#else
1167  READ_FLAG( uiCode,  "vps_extension_flag" );
1168  if (uiCode)
1169  {
1170    while ( xMoreRbspData() )
1171    {
1172      READ_FLAG( uiCode, "vps_extension_data_flag");
1173    }
1174  }
1175#endif
1176
1177  return;
1178}
1179
1180Void TDecCavlc::parseSliceHeader (TComSlice* pcSlice, ParameterSetManagerDecoder *parameterSetManager)
1181{
1182  UInt  uiCode;
1183  Int   iCode;
1184
1185#if ENC_DEC_TRACE
1186  xTraceSliceHeader(pcSlice);
1187#endif
1188  TComPPS* pps = NULL;
1189  TComSPS* sps = NULL;
1190
1191  UInt firstSliceSegmentInPic;
1192  READ_FLAG( firstSliceSegmentInPic, "first_slice_segment_in_pic_flag" );
1193  if( pcSlice->getRapPicFlag())
1194  {
1195    READ_FLAG( uiCode, "no_output_of_prior_pics_flag" );  //ignored -- updated already
1196    pcSlice->setNoOutputPriorPicsFlag(uiCode ? true : false);
1197  }
1198  READ_UVLC (    uiCode, "slice_pic_parameter_set_id" );  pcSlice->setPPSId(uiCode);
1199  pps = parameterSetManager->getPrefetchedPPS(uiCode);
1200  //!KS: need to add error handling code here, if PPS is not available
1201  assert(pps!=0);
1202  sps = parameterSetManager->getPrefetchedSPS(pps->getSPSId());
1203  //!KS: need to add error handling code here, if SPS is not available
1204  assert(sps!=0);
1205  pcSlice->setSPS(sps);
1206  pcSlice->setPPS(pps);
1207
1208  const ChromaFormat chFmt = sps->getChromaFormatIdc();
1209  const UInt numValidComp=getNumberValidComponents(chFmt);
1210  const Bool bChroma=(chFmt!=CHROMA_400);
1211
1212  if( pps->getDependentSliceSegmentsEnabledFlag() && ( !firstSliceSegmentInPic ))
1213  {
1214    READ_FLAG( uiCode, "dependent_slice_segment_flag" );       pcSlice->setDependentSliceSegmentFlag(uiCode ? true : false);
1215  }
1216  else
1217  {
1218    pcSlice->setDependentSliceSegmentFlag(false);
1219  }
1220#if REPN_FORMAT_IN_VPS
1221  Int numCTUs = ((pcSlice->getPicWidthInLumaSamples()+sps->getMaxCUWidth()-1)/sps->getMaxCUWidth())*((pcSlice->getPicHeightInLumaSamples()+sps->getMaxCUHeight()-1)/sps->getMaxCUHeight());
1222#else
1223  Int numCTUs = ((sps->getPicWidthInLumaSamples()+sps->getMaxCUWidth()-1)/sps->getMaxCUWidth())*((sps->getPicHeightInLumaSamples()+sps->getMaxCUHeight()-1)/sps->getMaxCUHeight());
1224#endif 
1225  UInt sliceSegmentAddress = 0;
1226  Int bitsSliceSegmentAddress = 0;
1227  while(numCTUs>(1<<bitsSliceSegmentAddress))
1228  {
1229    bitsSliceSegmentAddress++;
1230  }
1231
1232  if(!firstSliceSegmentInPic)
1233  {
1234    READ_CODE( bitsSliceSegmentAddress, sliceSegmentAddress, "slice_segment_address" );
1235  }
1236  //set uiCode to equal slice start address (or dependent slice start address)
1237  pcSlice->setSliceSegmentCurStartCtuTsAddr( sliceSegmentAddress );// this is actually a Raster-Scan (RS) address, but we do not have the RS->TS conversion table defined yet.
1238  pcSlice->setSliceSegmentCurEndCtuTsAddr(numCTUs);                // Set end as the last CTU of the picture.
1239
1240  if (!pcSlice->getDependentSliceSegmentFlag())
1241  {
1242    pcSlice->setSliceCurStartCtuTsAddr(sliceSegmentAddress); // this is actually a Raster-Scan (RS) address, but we do not have the RS->TS conversion table defined yet.
1243    pcSlice->setSliceCurEndCtuTsAddr(numCTUs);
1244  }
1245
1246#if Q0142_POC_LSB_NOT_PRESENT
1247#if SHM_FIX7
1248  Int iPOClsb = 0;
1249#endif
1250#endif
1251
1252  if(!pcSlice->getDependentSliceSegmentFlag())
1253  {
1254#if SVC_EXTENSION
1255#if POC_RESET_FLAG
1256    Int iBits = 0;
1257    if(pcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits)
1258    {
1259      READ_FLAG(uiCode, "poc_reset_flag");      pcSlice->setPocResetFlag( uiCode ? true : false );
1260      iBits++;
1261    }
1262    if(pcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits)
1263    {
1264#if DISCARDABLE_PIC_RPS
1265      READ_FLAG(uiCode, "discardable_flag"); pcSlice->setDiscardableFlag( uiCode ? true : false );
1266#else
1267      READ_FLAG(uiCode, "discardable_flag"); // ignored
1268#endif
1269      iBits++;
1270    }
1271#if O0149_CROSS_LAYER_BLA_FLAG
1272    if(pcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits)
1273    {
1274      READ_FLAG(uiCode, "cross_layer_bla_flag");  pcSlice->setCrossLayerBLAFlag( uiCode ? true : false );
1275      iBits++;
1276    }
1277#endif
1278    for (; iBits < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); iBits++)
1279    {
1280      READ_FLAG(uiCode, "slice_reserved_undetermined_flag[]"); // ignored
1281    }
1282#else
1283#if CROSS_LAYER_BLA_FLAG_FIX
1284    Int iBits = 0;
1285    if(pcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits)
1286#else
1287    if(pcSlice->getPPS()->getNumExtraSliceHeaderBits()>0)
1288#endif
1289    {
1290      READ_FLAG(uiCode, "discardable_flag"); // ignored
1291#if NON_REF_NAL_TYPE_DISCARDABLE
1292      pcSlice->setDiscardableFlag( uiCode ? true : false );
1293      if (uiCode)
1294      {
1295        assert(pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TRAIL_R &&
1296          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TSA_R &&
1297          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_STSA_R &&
1298          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RADL_R &&
1299          pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RASL_R);
1300      }
1301#endif
1302#if CROSS_LAYER_BLA_FLAG_FIX
1303      iBits++;
1304#endif
1305    }
1306#if CROSS_LAYER_BLA_FLAG_FIX
1307    if(pcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits)
1308    {
1309      READ_FLAG(uiCode, "cross_layer_bla_flag");  pcSlice->setCrossLayerBLAFlag( uiCode ? true : false );
1310      iBits++;
1311    }
1312    for ( ; iBits < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); iBits++)
1313#else
1314    for (Int i = 1; i < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
1315#endif
1316    {
1317      READ_FLAG(uiCode, "slice_reserved_undetermined_flag[]"); // ignored
1318    }
1319#endif
1320#else //SVC_EXTENSION
1321    for (Int i = 0; i < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
1322    {
1323      READ_FLAG(uiCode, "slice_reserved_undetermined_flag[]"); // ignored
1324    }
1325#endif //SVC_EXTENSION
1326
1327    READ_UVLC (    uiCode, "slice_type" );            pcSlice->setSliceType((SliceType)uiCode);
1328    if( pps->getOutputFlagPresentFlag() )
1329    {
1330      READ_FLAG( uiCode, "pic_output_flag" );    pcSlice->setPicOutputFlag( uiCode ? true : false );
1331    }
1332    else
1333    {
1334      pcSlice->setPicOutputFlag( true );
1335    }
1336
1337    if( pcSlice->getIdrPicFlag() )
1338    {
1339      pcSlice->setPOC(0);
1340      TComReferencePictureSet* rps = pcSlice->getLocalRPS();
1341      rps->setNumberOfNegativePictures(0);
1342      rps->setNumberOfPositivePictures(0);
1343      rps->setNumberOfLongtermPictures(0);
1344      rps->setNumberOfPictures(0);
1345      pcSlice->setRPS(rps);
1346    }
1347#if N0065_LAYER_POC_ALIGNMENT
1348#if O0062_POC_LSB_NOT_PRESENT_FLAG
1349    if( ( pcSlice->getLayerId() > 0 && !pcSlice->getVPS()->getPocLsbNotPresentFlag( pcSlice->getVPS()->getLayerIdInVps(pcSlice->getLayerId())) ) || !pcSlice->getIdrPicFlag() )
1350#else
1351    if( pcSlice->getLayerId() > 0 || !pcSlice->getIdrPicFlag() )
1352#endif
1353#else
1354    else
1355#endif
1356    {
1357      READ_CODE(sps->getBitsForPOC(), uiCode, "pic_order_cnt_lsb");
1358#if POC_RESET_IDC_DECODER
1359      pcSlice->setPicOrderCntLsb( uiCode );
1360#endif
1361#if SVC_EXTENSION
1362      iPOClsb = uiCode;
1363#else
1364      Int iPOClsb = uiCode;
1365#endif
1366      Int iPrevPOC = pcSlice->getPrevTid0POC();
1367      Int iMaxPOClsb = 1<< sps->getBitsForPOC();
1368      Int iPrevPOClsb = iPrevPOC & (iMaxPOClsb - 1);
1369      Int iPrevPOCmsb = iPrevPOC-iPrevPOClsb;
1370      Int iPOCmsb;
1371      if( ( iPOClsb  <  iPrevPOClsb ) && ( ( iPrevPOClsb - iPOClsb )  >=  ( iMaxPOClsb / 2 ) ) )
1372      {
1373        iPOCmsb = iPrevPOCmsb + iMaxPOClsb;
1374      }
1375      else if( (iPOClsb  >  iPrevPOClsb )  && ( (iPOClsb - iPrevPOClsb )  >  ( iMaxPOClsb / 2 ) ) )
1376      {
1377        iPOCmsb = iPrevPOCmsb - iMaxPOClsb;
1378      }
1379      else
1380      {
1381        iPOCmsb = iPrevPOCmsb;
1382      }
1383      if ( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
1384        || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
1385        || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
1386      {
1387        // For BLA picture types, POCmsb is set to 0.
1388        iPOCmsb = 0;
1389      }
1390      pcSlice->setPOC              (iPOCmsb+iPOClsb);
1391
1392#if N0065_LAYER_POC_ALIGNMENT
1393    }
1394#if POC_RESET_IDC_DECODER
1395    else
1396    {
1397      pcSlice->setPicOrderCntLsb( 0 );
1398    }
1399#endif
1400    if( !pcSlice->getIdrPicFlag() )
1401    {
1402#endif
1403      TComReferencePictureSet* rps;
1404      rps = pcSlice->getLocalRPS();
1405      pcSlice->setRPS(rps);
1406      READ_FLAG( uiCode, "short_term_ref_pic_set_sps_flag" );
1407      if(uiCode == 0) // use short-term reference picture set explicitly signalled in slice header
1408      {
1409        parseShortTermRefPicSet(sps,rps, sps->getRPSList()->getNumberOfReferencePictureSets());
1410      }
1411      else // use reference to short-term reference picture set in PPS
1412      {
1413        Int numBits = 0;
1414        while ((1 << numBits) < pcSlice->getSPS()->getRPSList()->getNumberOfReferencePictureSets())
1415        {
1416          numBits++;
1417        }
1418        if (numBits > 0)
1419        {
1420          READ_CODE( numBits, uiCode, "short_term_ref_pic_set_idx");
1421        }
1422        else
1423        {
1424          uiCode = 0;
1425       
1426        }
1427        *rps = *(sps->getRPSList()->getReferencePictureSet(uiCode));
1428      }
1429      if(sps->getLongTermRefsPresent())
1430      {
1431        Int offset = rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures();
1432        UInt numOfLtrp = 0;
1433        UInt numLtrpInSPS = 0;
1434        if (pcSlice->getSPS()->getNumLongTermRefPicSPS() > 0)
1435        {
1436          READ_UVLC( uiCode, "num_long_term_sps");
1437          numLtrpInSPS = uiCode;
1438          numOfLtrp += numLtrpInSPS;
1439          rps->setNumberOfLongtermPictures(numOfLtrp);
1440        }
1441        Int bitsForLtrpInSPS = 0;
1442        while (pcSlice->getSPS()->getNumLongTermRefPicSPS() > (1 << bitsForLtrpInSPS))
1443        {
1444          bitsForLtrpInSPS++;
1445        }
1446        READ_UVLC( uiCode, "num_long_term_pics");             rps->setNumberOfLongtermPictures(uiCode);
1447        numOfLtrp += uiCode;
1448        rps->setNumberOfLongtermPictures(numOfLtrp);
1449        Int maxPicOrderCntLSB = 1 << pcSlice->getSPS()->getBitsForPOC();
1450        Int prevDeltaMSB = 0, deltaPocMSBCycleLT = 0;
1451        for(Int j=offset+rps->getNumberOfLongtermPictures()-1, k = 0; k < numOfLtrp; j--, k++)
1452        {
1453          Int pocLsbLt;
1454          if (k < numLtrpInSPS)
1455          {
1456            uiCode = 0;
1457            if (bitsForLtrpInSPS > 0)
1458            {
1459              READ_CODE(bitsForLtrpInSPS, uiCode, "lt_idx_sps[i]");
1460            }
1461            Int usedByCurrFromSPS=pcSlice->getSPS()->getUsedByCurrPicLtSPSFlag(uiCode);
1462
1463            pocLsbLt = pcSlice->getSPS()->getLtRefPicPocLsbSps(uiCode);
1464            rps->setUsed(j,usedByCurrFromSPS);
1465          }
1466          else
1467          {
1468            READ_CODE(pcSlice->getSPS()->getBitsForPOC(), uiCode, "poc_lsb_lt"); pocLsbLt= uiCode;
1469            READ_FLAG( uiCode, "used_by_curr_pic_lt_flag");     rps->setUsed(j,uiCode);
1470          }
1471          READ_FLAG(uiCode,"delta_poc_msb_present_flag");
1472          Bool mSBPresentFlag = uiCode ? true : false;
1473          if(mSBPresentFlag)
1474          {
1475            READ_UVLC( uiCode, "delta_poc_msb_cycle_lt[i]" );
1476            Bool deltaFlag = false;
1477            //            First LTRP                               || First LTRP from SH
1478            if( (j == offset+rps->getNumberOfLongtermPictures()-1) || (j == offset+(numOfLtrp-numLtrpInSPS)-1) )
1479            {
1480              deltaFlag = true;
1481            }
1482            if(deltaFlag)
1483            {
1484              deltaPocMSBCycleLT = uiCode;
1485            }
1486            else
1487            {
1488              deltaPocMSBCycleLT = uiCode + prevDeltaMSB;
1489            }
1490
1491            Int pocLTCurr = pcSlice->getPOC() - deltaPocMSBCycleLT * maxPicOrderCntLSB
1492                                        - iPOClsb + pocLsbLt;
1493            rps->setPOC     (j, pocLTCurr);
1494            rps->setDeltaPOC(j, - pcSlice->getPOC() + pocLTCurr);
1495            rps->setCheckLTMSBPresent(j,true);
1496          }
1497          else
1498          {
1499            rps->setPOC     (j, pocLsbLt);
1500            rps->setDeltaPOC(j, - pcSlice->getPOC() + pocLsbLt);
1501            rps->setCheckLTMSBPresent(j,false);
1502
1503            // reset deltaPocMSBCycleLT for first LTRP from slice header if MSB not present
1504            if( j == offset+(numOfLtrp-numLtrpInSPS)-1 )
1505            {
1506              deltaPocMSBCycleLT = 0;
1507            }
1508          }
1509          prevDeltaMSB = deltaPocMSBCycleLT;
1510        }
1511        offset += rps->getNumberOfLongtermPictures();
1512        rps->setNumberOfPictures(offset);
1513      }
1514#if DPB_CONSTRAINTS
1515      if(pcSlice->getVPS()->getVpsExtensionFlag()==1)
1516      {
1517#if Q0078_ADD_LAYER_SETS
1518        for (Int ii = 1; ii < (pcSlice->getVPS()->getVpsNumLayerSetsMinus1() + 1); ii++)  // prevent assert error when num_add_layer_sets > 0
1519#else
1520        for (Int ii=1; ii< pcSlice->getVPS()->getNumOutputLayerSets(); ii++ )
1521#endif
1522        {
1523          Int layerSetIdxForOutputLayerSet = pcSlice->getVPS()->getOutputLayerSetIdx( ii );
1524          Int chkAssert=0;
1525          for(Int kk = 0; kk < pcSlice->getVPS()->getNumLayersInIdList(layerSetIdxForOutputLayerSet); kk++)
1526          {
1527#if R0235_SMALLEST_LAYER_ID
1528            if( pcSlice->getVPS()->getNecessaryLayerFlag(ii, kk) && pcSlice->getLayerId() == pcSlice->getVPS()->getLayerSetLayerIdList(layerSetIdxForOutputLayerSet, kk) )
1529#else
1530            if(pcSlice->getLayerId() == pcSlice->getVPS()->getLayerSetLayerIdList(layerSetIdxForOutputLayerSet, kk))
1531#endif
1532            {
1533              chkAssert=1;
1534            }
1535          }
1536          if(chkAssert)
1537          {
1538            // There may be something wrong here (layer id assumed to be layer idx?)
1539            assert(rps->getNumberOfNegativePictures() <= pcSlice->getVPS()->getMaxVpsDecPicBufferingMinus1(ii , pcSlice->getLayerId() , pcSlice->getVPS()->getMaxSLayersInLayerSetMinus1(ii)));
1540            assert(rps->getNumberOfPositivePictures() <= pcSlice->getVPS()->getMaxVpsDecPicBufferingMinus1(ii , pcSlice->getLayerId() , pcSlice->getVPS()->getMaxSLayersInLayerSetMinus1(ii)) - rps->getNumberOfNegativePictures());
1541            assert((rps->getNumberOfPositivePictures() + rps->getNumberOfNegativePictures() + rps->getNumberOfLongtermPictures()) <= pcSlice->getVPS()->getMaxVpsDecPicBufferingMinus1(ii , pcSlice->getLayerId() , pcSlice->getVPS()->getMaxSLayersInLayerSetMinus1(ii)));
1542          }
1543        }
1544
1545
1546      }
1547      if(pcSlice->getLayerId() == 0)
1548      {
1549        assert(rps->getNumberOfNegativePictures() <= pcSlice->getSPS()->getMaxDecPicBuffering(pcSlice->getSPS()->getMaxTLayers()-1) );
1550        assert(rps->getNumberOfPositivePictures() <= pcSlice->getSPS()->getMaxDecPicBuffering(pcSlice->getSPS()->getMaxTLayers()-1) -rps->getNumberOfNegativePictures());
1551        assert((rps->getNumberOfPositivePictures() + rps->getNumberOfNegativePictures() + rps->getNumberOfLongtermPictures()) <= pcSlice->getSPS()->getMaxDecPicBuffering(pcSlice->getSPS()->getMaxTLayers()-1));
1552      }
1553#endif
1554      if ( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
1555        || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
1556        || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
1557      {
1558        // In the case of BLA picture types, rps data is read from slice header but ignored
1559        rps = pcSlice->getLocalRPS();
1560        rps->setNumberOfNegativePictures(0);
1561        rps->setNumberOfPositivePictures(0);
1562        rps->setNumberOfLongtermPictures(0);
1563        rps->setNumberOfPictures(0);
1564        pcSlice->setRPS(rps);
1565      }
1566      if (pcSlice->getSPS()->getTMVPFlagsPresent())
1567      {
1568        READ_FLAG( uiCode, "slice_temporal_mvp_enable_flag" );
1569        pcSlice->setEnableTMVPFlag( uiCode == 1 ? true : false );
1570      }
1571      else
1572      {
1573        pcSlice->setEnableTMVPFlag(false);
1574      }
1575    }
1576
1577#if SVC_EXTENSION
1578    pcSlice->setActiveNumILRRefIdx(0);
1579    if((pcSlice->getLayerId() > 0) && !(pcSlice->getVPS()->getIlpSshSignalingEnabledFlag()) && (pcSlice->getNumILRRefIdx() > 0) )
1580    {
1581      READ_FLAG(uiCode,"inter_layer_pred_enabled_flag");
1582      pcSlice->setInterLayerPredEnabledFlag(uiCode);
1583      if( pcSlice->getInterLayerPredEnabledFlag())
1584      {
1585        if(pcSlice->getNumILRRefIdx() > 1)
1586        {
1587          Int numBits = 1;
1588          while ((1 << numBits) < pcSlice->getNumILRRefIdx())
1589          {
1590            numBits++;
1591          }
1592          if( !pcSlice->getVPS()->getMaxOneActiveRefLayerFlag())
1593          {
1594            READ_CODE( numBits, uiCode,"num_inter_layer_ref_pics_minus1" );
1595            pcSlice->setActiveNumILRRefIdx(uiCode + 1);
1596          }
1597          else
1598          {
1599#if P0079_DERIVE_NUMACTIVE_REF_PICS
1600            for( Int i = 0; i < pcSlice->getNumILRRefIdx(); i++ ) 
1601            {
1602#if Q0060_MAX_TID_REF_EQUAL_TO_ZERO
1603              if((pcSlice->getVPS()->getMaxTidIlRefPicsPlus1(pcSlice->getVPS()->getLayerIdInVps(i),pcSlice->getLayerId()) >  pcSlice->getTLayer() || pcSlice->getTLayer()==0) &&
1604                (pcSlice->getVPS()->getMaxTSLayersMinus1(pcSlice->getVPS()->getLayerIdInVps(i)) >=  pcSlice->getTLayer()) )
1605#else
1606              if(pcSlice->getVPS()->getMaxTidIlRefPicsPlus1(pcSlice->getVPS()->getLayerIdInVps(i),pcSlice->getLayerId()) >  pcSlice->getTLayer() &&
1607                (pcSlice->getVPS()->getMaxTSLayersMinus1(pcSlice->getVPS()->getLayerIdInVps(i)) >=  pcSlice->getTLayer()) )
1608#endif
1609              {         
1610                pcSlice->setActiveNumILRRefIdx(1);
1611                break;
1612              }
1613            }
1614#else
1615            pcSlice->setActiveNumILRRefIdx(1);
1616#endif
1617          }
1618
1619          if( pcSlice->getActiveNumILRRefIdx() == pcSlice->getNumILRRefIdx() )
1620          {
1621            for( Int i = 0; i < pcSlice->getActiveNumILRRefIdx(); i++ )
1622            {
1623              pcSlice->setInterLayerPredLayerIdc(i,i);
1624            }
1625          }
1626          else
1627          {
1628            for(Int i = 0; i < pcSlice->getActiveNumILRRefIdx(); i++ )
1629            {
1630              READ_CODE( numBits,uiCode,"inter_layer_pred_layer_idc[i]" );
1631              pcSlice->setInterLayerPredLayerIdc(uiCode,i);
1632            }
1633          }
1634        }
1635        else
1636        {
1637#if O0225_TID_BASED_IL_RPS_DERIV && TSLAYERS_IL_RPS
1638#if Q0060_MAX_TID_REF_EQUAL_TO_ZERO
1639          if((pcSlice->getVPS()->getMaxTidIlRefPicsPlus1(0,pcSlice->getLayerId()) >  pcSlice->getTLayer() || pcSlice->getTLayer()==0) &&
1640            (pcSlice->getVPS()->getMaxTSLayersMinus1(0) >=  pcSlice->getTLayer()) )
1641#else
1642          if( (pcSlice->getVPS()->getMaxTidIlRefPicsPlus1(0,pcSlice->getLayerId()) >  pcSlice->getTLayer()) &&
1643            (pcSlice->getVPS()->getMaxTSLayersMinus1(0) >=  pcSlice->getTLayer()) )
1644#endif
1645          {
1646#endif
1647            pcSlice->setActiveNumILRRefIdx(1);
1648            pcSlice->setInterLayerPredLayerIdc(0,0);
1649#if O0225_TID_BASED_IL_RPS_DERIV && TSLAYERS_IL_RPS
1650          }
1651#endif
1652        }
1653      }
1654    }
1655    else if( pcSlice->getVPS()->getIlpSshSignalingEnabledFlag() == true &&  (pcSlice->getLayerId() > 0 ))
1656    {
1657      pcSlice->setInterLayerPredEnabledFlag(true);
1658
1659#if O0225_TID_BASED_IL_RPS_DERIV && TSLAYERS_IL_RPS
1660      Int   numRefLayerPics = 0;
1661      Int   i = 0;
1662      Int   refLayerPicIdc  [MAX_VPS_LAYER_ID_PLUS1];
1663      for(i = 0, numRefLayerPics = 0;  i < pcSlice->getNumILRRefIdx(); i++ ) 
1664      {
1665#if Q0060_MAX_TID_REF_EQUAL_TO_ZERO
1666        if((pcSlice->getVPS()->getMaxTidIlRefPicsPlus1(pcSlice->getVPS()->getLayerIdInVps(i),pcSlice->getLayerId()) >  pcSlice->getTLayer() || pcSlice->getTLayer()==0) &&
1667          (pcSlice->getVPS()->getMaxTSLayersMinus1(pcSlice->getVPS()->getLayerIdInVps(i)) >=  pcSlice->getTLayer()) )
1668#else
1669        if(pcSlice->getVPS()->getMaxTidIlRefPicsPlus1(pcSlice->getVPS()->getLayerIdInVps(i),pcSlice->getLayerId()) >  pcSlice->getTLayer() &&
1670          (pcSlice->getVPS()->getMaxTSLayersMinus1(pcSlice->getVPS()->getLayerIdInVps(i)) >=  pcSlice->getTLayer()) )
1671#endif
1672        {         
1673          refLayerPicIdc[ numRefLayerPics++ ] = i;
1674        }
1675      }
1676      pcSlice->setActiveNumILRRefIdx(numRefLayerPics);
1677      for( i = 0; i < pcSlice->getActiveNumILRRefIdx(); i++ )
1678      {
1679        pcSlice->setInterLayerPredLayerIdc(refLayerPicIdc[i],i);
1680      }     
1681#else
1682      pcSlice->setActiveNumILRRefIdx(pcSlice->getNumILRRefIdx());
1683      for( Int i = 0; i < pcSlice->getActiveNumILRRefIdx(); i++ )
1684      {
1685        pcSlice->setInterLayerPredLayerIdc(i,i);
1686      }
1687#endif
1688    }
1689#if P0312_VERT_PHASE_ADJ
1690    for(Int i = 0; i < pcSlice->getActiveNumILRRefIdx(); i++ ) 
1691    {
1692      UInt refLayerIdc = pcSlice->getInterLayerPredLayerIdc(i);
1693#if !MOVE_SCALED_OFFSET_TO_PPS
1694      if( pcSlice->getSPS()->getVertPhasePositionEnableFlag(refLayerIdc) )
1695#else
1696      if( pcSlice->getPPS()->getVertPhasePositionEnableFlag(refLayerIdc) )
1697#endif
1698      {
1699        READ_FLAG( uiCode, "vert_phase_position_flag" ); pcSlice->setVertPhasePositionFlag( uiCode? true : false, refLayerIdc );
1700      }
1701    }
1702#endif
1703#endif //SVC_EXTENSION
1704
1705    if(sps->getUseSAO())
1706    {
1707      READ_FLAG(uiCode, "slice_sao_luma_flag");  pcSlice->setSaoEnabledFlag(CHANNEL_TYPE_LUMA, (Bool)uiCode);
1708#if SVC_EXTENSION
1709      ChromaFormat format;
1710      if( sps->getLayerId() == 0 )
1711      {
1712        format = sps->getChromaFormatIdc();
1713      }
1714      else
1715      {
1716        format = pcSlice->getVPS()->getVpsRepFormat( sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : pcSlice->getVPS()->getVpsRepFormatIdx( pcSlice->getVPS()->getLayerIdInVps(sps->getLayerId()) ) )->getChromaFormatVpsIdc();
1717#if Q0195_REP_FORMAT_CLEANUP
1718        assert( (sps->getUpdateRepFormatFlag()==false && pcSlice->getVPS()->getVpsNumRepFormats()==1) || pcSlice->getVPS()->getVpsNumRepFormats() > 1 ); //conformance check
1719#endif
1720      }
1721      if (format != CHROMA_400)
1722#else
1723      if (bChroma)
1724#endif
1725      {
1726        READ_FLAG(uiCode, "slice_sao_chroma_flag");  pcSlice->setSaoEnabledFlag(CHANNEL_TYPE_CHROMA, (Bool)uiCode);
1727      }
1728#if SVC_EXTENSION
1729      else
1730      {
1731        pcSlice->setSaoEnabledFlag(CHANNEL_TYPE_CHROMA, false);
1732      }
1733#endif
1734    }
1735
1736    if (pcSlice->getIdrPicFlag())
1737    {
1738      pcSlice->setEnableTMVPFlag(false);
1739    }
1740    if (!pcSlice->isIntra())
1741    {
1742
1743      READ_FLAG( uiCode, "num_ref_idx_active_override_flag");
1744      if (uiCode)
1745      {
1746        READ_UVLC (uiCode, "num_ref_idx_l0_active_minus1" );  pcSlice->setNumRefIdx( REF_PIC_LIST_0, uiCode + 1 );
1747        if (pcSlice->isInterB())
1748        {
1749          READ_UVLC (uiCode, "num_ref_idx_l1_active_minus1" );  pcSlice->setNumRefIdx( REF_PIC_LIST_1, uiCode + 1 );
1750        }
1751        else
1752        {
1753          pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
1754        }
1755      }
1756      else
1757      {
1758        pcSlice->setNumRefIdx(REF_PIC_LIST_0, pcSlice->getPPS()->getNumRefIdxL0DefaultActive());
1759        if (pcSlice->isInterB())
1760        {
1761          pcSlice->setNumRefIdx(REF_PIC_LIST_1, pcSlice->getPPS()->getNumRefIdxL1DefaultActive());
1762        }
1763        else
1764        {
1765          pcSlice->setNumRefIdx(REF_PIC_LIST_1,0);
1766        }
1767      }
1768    }
1769    // }
1770    TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
1771    if(!pcSlice->isIntra())
1772    {
1773      if( !pcSlice->getPPS()->getListsModificationPresentFlag() || pcSlice->getNumRpsCurrTempList() <= 1 )
1774      {
1775        refPicListModification->setRefPicListModificationFlagL0( 0 );
1776      }
1777      else
1778      {
1779        READ_FLAG( uiCode, "ref_pic_list_modification_flag_l0" ); refPicListModification->setRefPicListModificationFlagL0( uiCode ? 1 : 0 );
1780      }
1781
1782      if(refPicListModification->getRefPicListModificationFlagL0())
1783      {
1784        uiCode = 0;
1785        Int i = 0;
1786        Int numRpsCurrTempList0 = pcSlice->getNumRpsCurrTempList();
1787        if ( numRpsCurrTempList0 > 1 )
1788        {
1789          Int length = 1;
1790          numRpsCurrTempList0 --;
1791          while ( numRpsCurrTempList0 >>= 1)
1792          {
1793            length ++;
1794          }
1795          for (i = 0; i < pcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
1796          {
1797            READ_CODE( length, uiCode, "list_entry_l0" );
1798            refPicListModification->setRefPicSetIdxL0(i, uiCode );
1799          }
1800        }
1801        else
1802        {
1803          for (i = 0; i < pcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
1804          {
1805            refPicListModification->setRefPicSetIdxL0(i, 0 );
1806          }
1807        }
1808      }
1809    }
1810    else
1811    {
1812      refPicListModification->setRefPicListModificationFlagL0(0);
1813    }
1814    if(pcSlice->isInterB())
1815    {
1816      if( !pcSlice->getPPS()->getListsModificationPresentFlag() || pcSlice->getNumRpsCurrTempList() <= 1 )
1817      {
1818        refPicListModification->setRefPicListModificationFlagL1( 0 );
1819      }
1820      else
1821      {
1822        READ_FLAG( uiCode, "ref_pic_list_modification_flag_l1" ); refPicListModification->setRefPicListModificationFlagL1( uiCode ? 1 : 0 );
1823      }
1824      if(refPicListModification->getRefPicListModificationFlagL1())
1825      {
1826        uiCode = 0;
1827        Int i = 0;
1828        Int numRpsCurrTempList1 = pcSlice->getNumRpsCurrTempList();
1829        if ( numRpsCurrTempList1 > 1 )
1830        {
1831          Int length = 1;
1832          numRpsCurrTempList1 --;
1833          while ( numRpsCurrTempList1 >>= 1)
1834          {
1835            length ++;
1836          }
1837          for (i = 0; i < pcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
1838          {
1839            READ_CODE( length, uiCode, "list_entry_l1" );
1840            refPicListModification->setRefPicSetIdxL1(i, uiCode );
1841          }
1842        }
1843        else
1844        {
1845          for (i = 0; i < pcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
1846          {
1847            refPicListModification->setRefPicSetIdxL1(i, 0 );
1848          }
1849        }
1850      }
1851    }
1852    else
1853    {
1854      refPicListModification->setRefPicListModificationFlagL1(0);
1855    }
1856    if (pcSlice->isInterB())
1857    {
1858      READ_FLAG( uiCode, "mvd_l1_zero_flag" );       pcSlice->setMvdL1ZeroFlag( (uiCode ? true : false) );
1859    }
1860
1861    pcSlice->setCabacInitFlag( false ); // default
1862    if(pps->getCabacInitPresentFlag() && !pcSlice->isIntra())
1863    {
1864      READ_FLAG(uiCode, "cabac_init_flag");
1865      pcSlice->setCabacInitFlag( uiCode ? true : false );
1866    }
1867
1868    if ( pcSlice->getEnableTMVPFlag() )
1869    {
1870#if SVC_EXTENSION && REF_IDX_MFM
1871      // set motion mapping flag
1872      pcSlice->setMFMEnabledFlag( ( pcSlice->getNumMotionPredRefLayers() > 0 && pcSlice->getActiveNumILRRefIdx() && !pcSlice->isIntra() ) ? true : false );
1873#endif
1874      if ( pcSlice->getSliceType() == B_SLICE )
1875      {
1876        READ_FLAG( uiCode, "collocated_from_l0_flag" );
1877        pcSlice->setColFromL0Flag(uiCode);
1878      }
1879      else
1880      {
1881        pcSlice->setColFromL0Flag( 1 );
1882      }
1883
1884      if ( pcSlice->getSliceType() != I_SLICE &&
1885          ((pcSlice->getColFromL0Flag() == 1 && pcSlice->getNumRefIdx(REF_PIC_LIST_0) > 1)||
1886           (pcSlice->getColFromL0Flag() == 0 && pcSlice->getNumRefIdx(REF_PIC_LIST_1) > 1)))
1887      {
1888        READ_UVLC( uiCode, "collocated_ref_idx" );
1889        pcSlice->setColRefIdx(uiCode);
1890      }
1891      else
1892      {
1893        pcSlice->setColRefIdx(0);
1894      }
1895    }
1896    if ( (pps->getUseWP() && pcSlice->getSliceType()==P_SLICE) || (pps->getWPBiPred() && pcSlice->getSliceType()==B_SLICE) )
1897    {
1898      xParsePredWeightTable(pcSlice);
1899      pcSlice->initWpScaling();
1900    }
1901    if (!pcSlice->isIntra())
1902    {
1903      READ_UVLC( uiCode, "five_minus_max_num_merge_cand");
1904      pcSlice->setMaxNumMergeCand(MRG_MAX_NUM_CANDS - uiCode);
1905    }
1906
1907    READ_SVLC( iCode, "slice_qp_delta" );
1908    pcSlice->setSliceQp (26 + pps->getPicInitQPMinus26() + iCode);
1909
1910#if REPN_FORMAT_IN_VPS
1911#if O0194_DIFFERENT_BITDEPTH_EL_BL
1912    g_bitDepthLayer[CHANNEL_TYPE_LUMA][pcSlice->getLayerId()] = pcSlice->getBitDepthY();
1913    g_bitDepthLayer[CHANNEL_TYPE_CHROMA][pcSlice->getLayerId()] = pcSlice->getBitDepthC();
1914#endif
1915    assert( pcSlice->getSliceQp() >= -pcSlice->getQpBDOffsetY() );
1916#else   
1917    assert( pcSlice->getSliceQp() >= -sps->getQpBDOffset(CHANNEL_TYPE_LUMA) );
1918#endif
1919    assert( pcSlice->getSliceQp() <=  51 );
1920
1921    if (pcSlice->getPPS()->getSliceChromaQpFlag())
1922    {
1923      if (numValidComp>COMPONENT_Cb)
1924      {
1925        READ_SVLC( iCode, "slice_qp_delta_cb" );
1926        pcSlice->setSliceChromaQpDelta(COMPONENT_Cb, iCode );
1927        assert( pcSlice->getSliceChromaQpDelta(COMPONENT_Cb) >= -12 );
1928        assert( pcSlice->getSliceChromaQpDelta(COMPONENT_Cb) <=  12 );
1929        assert( (pcSlice->getPPS()->getQpOffset(COMPONENT_Cb) + pcSlice->getSliceChromaQpDelta(COMPONENT_Cb)) >= -12 );
1930        assert( (pcSlice->getPPS()->getQpOffset(COMPONENT_Cb) + pcSlice->getSliceChromaQpDelta(COMPONENT_Cb)) <=  12 );
1931      }
1932
1933      if (numValidComp>COMPONENT_Cr)
1934      {
1935        READ_SVLC( iCode, "slice_qp_delta_cr" );
1936        pcSlice->setSliceChromaQpDelta(COMPONENT_Cr, iCode );
1937        assert( pcSlice->getSliceChromaQpDelta(COMPONENT_Cr) >= -12 );
1938        assert( pcSlice->getSliceChromaQpDelta(COMPONENT_Cr) <=  12 );
1939        assert( (pcSlice->getPPS()->getQpOffset(COMPONENT_Cr) + pcSlice->getSliceChromaQpDelta(COMPONENT_Cr)) >= -12 );
1940        assert( (pcSlice->getPPS()->getQpOffset(COMPONENT_Cr) + pcSlice->getSliceChromaQpDelta(COMPONENT_Cr)) <=  12 );
1941      }
1942    }
1943
1944    if (pcSlice->getPPS()->getChromaQpAdjTableSize() > 0)
1945    {
1946      READ_FLAG(uiCode, "slice_chroma_qp_adjustment_enabled_flag"); pcSlice->setUseChromaQpAdj(uiCode != 0);
1947    }
1948    else pcSlice->setUseChromaQpAdj(false);
1949
1950    if (pcSlice->getPPS()->getDeblockingFilterControlPresentFlag())
1951    {
1952      if(pcSlice->getPPS()->getDeblockingFilterOverrideEnabledFlag())
1953      {
1954        READ_FLAG ( uiCode, "deblocking_filter_override_flag" );        pcSlice->setDeblockingFilterOverrideFlag(uiCode ? true : false);
1955      }
1956      else
1957      {
1958        pcSlice->setDeblockingFilterOverrideFlag(0);
1959      }
1960      if(pcSlice->getDeblockingFilterOverrideFlag())
1961      {
1962        READ_FLAG ( uiCode, "slice_disable_deblocking_filter_flag" );   pcSlice->setDeblockingFilterDisable(uiCode ? 1 : 0);
1963        if(!pcSlice->getDeblockingFilterDisable())
1964        {
1965          READ_SVLC( iCode, "slice_beta_offset_div2" );                       pcSlice->setDeblockingFilterBetaOffsetDiv2(iCode);
1966          assert(pcSlice->getDeblockingFilterBetaOffsetDiv2() >= -6 &&
1967                 pcSlice->getDeblockingFilterBetaOffsetDiv2() <=  6);
1968          READ_SVLC( iCode, "slice_tc_offset_div2" );                         pcSlice->setDeblockingFilterTcOffsetDiv2(iCode);
1969          assert(pcSlice->getDeblockingFilterTcOffsetDiv2() >= -6 &&
1970                 pcSlice->getDeblockingFilterTcOffsetDiv2() <=  6);
1971        }
1972      }
1973      else
1974      {
1975        pcSlice->setDeblockingFilterDisable   ( pcSlice->getPPS()->getPicDisableDeblockingFilterFlag() );
1976        pcSlice->setDeblockingFilterBetaOffsetDiv2( pcSlice->getPPS()->getDeblockingFilterBetaOffsetDiv2() );
1977        pcSlice->setDeblockingFilterTcOffsetDiv2  ( pcSlice->getPPS()->getDeblockingFilterTcOffsetDiv2() );
1978      }
1979    }
1980    else
1981    {
1982      pcSlice->setDeblockingFilterDisable       ( false );
1983      pcSlice->setDeblockingFilterBetaOffsetDiv2( 0 );
1984      pcSlice->setDeblockingFilterTcOffsetDiv2  ( 0 );
1985    }
1986
1987    Bool isSAOEnabled = pcSlice->getSPS()->getUseSAO() && (pcSlice->getSaoEnabledFlag(CHANNEL_TYPE_LUMA) || (bChroma && pcSlice->getSaoEnabledFlag(CHANNEL_TYPE_CHROMA)));
1988    Bool isDBFEnabled = (!pcSlice->getDeblockingFilterDisable());
1989
1990    if(pcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag() && ( isSAOEnabled || isDBFEnabled ))
1991    {
1992      READ_FLAG( uiCode, "slice_loop_filter_across_slices_enabled_flag");
1993    }
1994    else
1995    {
1996      uiCode = pcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag()?1:0;
1997    }
1998    pcSlice->setLFCrossSliceBoundaryFlag( (uiCode==1)?true:false);
1999
2000  }
2001
2002  std::vector<UInt> entryPointOffset;
2003  if( pps->getTilesEnabledFlag() || pps->getEntropyCodingSyncEnabledFlag() )
2004  {
2005    UInt numEntryPointOffsets;
2006    UInt offsetLenMinus1;
2007    READ_UVLC(numEntryPointOffsets, "num_entry_point_offsets");
2008    if (numEntryPointOffsets>0)
2009    {
2010      READ_UVLC(offsetLenMinus1, "offset_len_minus1");
2011      entryPointOffset.resize(numEntryPointOffsets);
2012      for (UInt idx=0; idx<numEntryPointOffsets; idx++)
2013      {
2014        READ_CODE(offsetLenMinus1+1, uiCode, "entry_point_offset_minus1");
2015        entryPointOffset[ idx ] = uiCode + 1;
2016      }
2017    }
2018  }
2019
2020#if POC_RESET_IDC_SIGNALLING
2021  Int sliceHeaderExtensionLength = 0;
2022  if(pps->getSliceHeaderExtensionPresentFlag())
2023  {
2024    READ_UVLC( uiCode, "slice_header_extension_length"); sliceHeaderExtensionLength = uiCode;
2025  }
2026  else
2027  {
2028    sliceHeaderExtensionLength = 0;
2029#if INFERENCE_POC_MSB_VAL_PRESENT
2030    pcSlice->setPocMsbValPresentFlag( false );
2031#endif
2032  }
2033  UInt startBits = m_pcBitstream->getNumBitsRead();     // Start counter of # SH Extn bits
2034  if( sliceHeaderExtensionLength > 0 )
2035  {
2036    if( pcSlice->getPPS()->getPocResetInfoPresentFlag() )
2037    {
2038      READ_CODE( 2, uiCode,       "poc_reset_idc"); pcSlice->setPocResetIdc(uiCode);
2039#if POC_RESET_RESTRICTIONS
2040      /* The value of poc_reset_idc shall not be equal to 1 or 2 for a RASL picture, a RADL picture,
2041      a sub-layer non-reference picture, or a picture that has TemporalId greater than 0,
2042      or a picture that has discardable_flag equal to 1. */
2043      if( pcSlice->getPocResetIdc() == 1 || pcSlice->getPocResetIdc() == 2 )
2044      {
2045        assert( !pcSlice->isRASL() );
2046        assert( !pcSlice->isRADL() );
2047        assert( !pcSlice->isSLNR() );
2048        assert( pcSlice->getTLayer() == 0 );
2049        assert( pcSlice->getDiscardableFlag() == 0 );
2050      }
2051
2052      // The value of poc_reset_idc of a CRA or BLA picture shall be less than 3.
2053      if( pcSlice->getPocResetIdc() == 3)
2054      {
2055        assert( ! ( pcSlice->isCRA() || pcSlice->isBLA() ) );
2056      }
2057#endif
2058    }
2059    else
2060    {
2061      pcSlice->setPocResetIdc( 0 );
2062    }
2063#if Q0142_POC_LSB_NOT_PRESENT
2064    if ( pcSlice->getVPS()->getPocLsbNotPresentFlag( pcSlice->getVPS()->getLayerIdInVps(pcSlice->getLayerId()) ) && iPOClsb > 0 )
2065    {
2066      assert( pcSlice->getPocResetIdc() != 2 );
2067    }
2068#endif
2069    if( pcSlice->getPocResetIdc() > 0 )
2070    {
2071      READ_CODE(6, uiCode,      "poc_reset_period_id"); pcSlice->setPocResetPeriodId(uiCode);
2072    }
2073    else
2074    {
2075
2076      pcSlice->setPocResetPeriodId( 0 );
2077    }
2078
2079    if (pcSlice->getPocResetIdc() == 3)
2080    {
2081      READ_FLAG( uiCode,        "full_poc_reset_flag"); pcSlice->setFullPocResetFlag((uiCode == 1) ? true : false);
2082      READ_CODE(pcSlice->getSPS()->getBitsForPOC(), uiCode,"poc_lsb_val"); pcSlice->setPocLsbVal(uiCode);
2083#if Q0142_POC_LSB_NOT_PRESENT
2084      if ( pcSlice->getVPS()->getPocLsbNotPresentFlag( pcSlice->getVPS()->getLayerIdInVps(pcSlice->getLayerId()) ) && pcSlice->getFullPocResetFlag() )
2085      {
2086        assert( pcSlice->getPocLsbVal() == 0 );
2087      }
2088#endif
2089    }
2090
2091    // Derive the value of PocMsbValRequiredFlag
2092#if P0297_VPS_POC_LSB_ALIGNED_FLAG
2093    pcSlice->setPocMsbValRequiredFlag( (pcSlice->getCraPicFlag() || pcSlice->getBlaPicFlag())
2094      && (!pcSlice->getVPS()->getVpsPocLsbAlignedFlag() ||
2095      (pcSlice->getVPS()->getVpsPocLsbAlignedFlag() && pcSlice->getVPS()->getNumDirectRefLayers(pcSlice->getLayerId()) == 0))
2096      );
2097#else
2098    pcSlice->setPocMsbValRequiredFlag( pcSlice->getCraPicFlag() || pcSlice->getBlaPicFlag() );
2099#endif
2100
2101#if P0297_VPS_POC_LSB_ALIGNED_FLAG
2102    if (!pcSlice->getPocMsbValRequiredFlag() && pcSlice->getVPS()->getVpsPocLsbAlignedFlag())
2103#else
2104    if (!pcSlice->getPocMsbValRequiredFlag() /* vps_poc_lsb_aligned_flag */)
2105#endif
2106    {
2107#if P0297_VPS_POC_LSB_ALIGNED_FLAG
2108      READ_FLAG(uiCode, "poc_msb_cycle_val_present_flag"); pcSlice->setPocMsbValPresentFlag(uiCode ? true : false);
2109#else
2110      READ_FLAG(uiCode, "poc_msb_val_present_flag"); pcSlice->setPocMsbValPresentFlag(uiCode ? true : false);
2111#endif
2112    }
2113    else
2114    {
2115#if POC_MSB_VAL_PRESENT_FLAG_SEM
2116      if( sliceHeaderExtensionLength == 0 )
2117      {
2118        pcSlice->setPocMsbValPresentFlag( false );
2119      }
2120      else if( pcSlice->getPocMsbValRequiredFlag() )
2121#else
2122      if( pcSlice->getPocMsbValRequiredFlag() )
2123#endif
2124      {
2125        pcSlice->setPocMsbValPresentFlag( true );
2126      }
2127      else
2128      {
2129        pcSlice->setPocMsbValPresentFlag( false );
2130      }
2131    }
2132
2133#if !POC_RESET_IDC_DECODER
2134    Int maxPocLsb  = 1 << pcSlice->getSPS()->getBitsForPOC();
2135#endif
2136    if( pcSlice->getPocMsbValPresentFlag() )
2137    {
2138#if P0297_VPS_POC_LSB_ALIGNED_FLAG
2139      READ_UVLC( uiCode,    "poc_msb_cycle_val");             pcSlice->setPocMsbVal( uiCode );
2140#else
2141      READ_UVLC( uiCode,    "poc_msb_val");             pcSlice->setPocMsbVal( uiCode );
2142#endif
2143
2144#if !POC_RESET_IDC_DECODER
2145      // Update POC of the slice based on this MSB val
2146      Int pocLsb     = pcSlice->getPOC() % maxPocLsb;
2147      pcSlice->setPOC((pcSlice->getPocMsbVal() * maxPocLsb) + pocLsb);
2148    }
2149    else
2150    {
2151      pcSlice->setPocMsbVal( pcSlice->getPOC() / maxPocLsb );
2152#endif
2153    }
2154
2155    // Read remaining bits in the slice header extension.
2156    UInt endBits = m_pcBitstream->getNumBitsRead();
2157    Int counter = (endBits - startBits) % 8;
2158    if( counter )
2159    {
2160      counter = 8 - counter;
2161    }
2162
2163    while( counter )
2164    {
2165#if Q0146_SSH_EXT_DATA_BIT
2166      READ_FLAG( uiCode, "slice_segment_header_extension_data_bit" );
2167#else
2168      READ_FLAG( uiCode, "slice_segment_header_extension_reserved_bit" ); assert( uiCode == 1 );
2169#endif
2170      counter--;
2171    }
2172  }
2173#else
2174  if(pps->getSliceHeaderExtensionPresentFlag())
2175  {
2176    READ_UVLC(uiCode,"slice_header_extension_length");
2177    for(Int i=0; i<uiCode; i++)
2178    {
2179      UInt ignore;
2180      READ_CODE(8,ignore,"slice_header_extension_data_byte");
2181    }
2182  }
2183#endif
2184#if RExt__DECODER_DEBUG_BIT_STATISTICS
2185  TComCodingStatistics::IncrementStatisticEP(STATS__BYTE_ALIGNMENT_BITS,m_pcBitstream->readByteAlignment(),0);
2186#else
2187  m_pcBitstream->readByteAlignment();
2188#endif
2189
2190  pcSlice->clearSubstreamSizes();
2191
2192  if( pps->getTilesEnabledFlag() || pps->getEntropyCodingSyncEnabledFlag() )
2193  {
2194    Int endOfSliceHeaderLocation = m_pcBitstream->getByteLocation();
2195
2196    // Adjust endOfSliceHeaderLocation to account for emulation prevention bytes in the slice segment header
2197    for ( UInt curByteIdx  = 0; curByteIdx<m_pcBitstream->numEmulationPreventionBytesRead(); curByteIdx++ )
2198    {
2199      if ( m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) < endOfSliceHeaderLocation )
2200      {
2201        endOfSliceHeaderLocation++;
2202      }
2203    }
2204
2205    Int  curEntryPointOffset     = 0;
2206    Int  prevEntryPointOffset    = 0;
2207    for (UInt idx=0; idx<entryPointOffset.size(); idx++)
2208    {
2209      curEntryPointOffset += entryPointOffset[ idx ];
2210
2211      Int emulationPreventionByteCount = 0;
2212      for ( UInt curByteIdx  = 0; curByteIdx<m_pcBitstream->numEmulationPreventionBytesRead(); curByteIdx++ )
2213      {
2214        if ( m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) >= ( prevEntryPointOffset + endOfSliceHeaderLocation ) &&
2215             m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) <  ( curEntryPointOffset  + endOfSliceHeaderLocation ) )
2216        {
2217          emulationPreventionByteCount++;
2218        }
2219      }
2220
2221      entryPointOffset[ idx ] -= emulationPreventionByteCount;
2222      prevEntryPointOffset = curEntryPointOffset;
2223      pcSlice->addSubstreamSize(entryPointOffset [ idx ] );
2224    }
2225  }
2226
2227  return;
2228}
2229
2230Void TDecCavlc::parsePTL( TComPTL *rpcPTL, Bool profilePresentFlag, Int maxNumSubLayersMinus1 )
2231{
2232  UInt uiCode;
2233  if(profilePresentFlag)
2234  {
2235    parseProfileTier(rpcPTL->getGeneralPTL());
2236  }
2237  READ_CODE( 8, uiCode, "general_level_idc" );    rpcPTL->getGeneralPTL()->setLevelIdc(Level::Name(uiCode));
2238
2239  for (Int i = 0; i < maxNumSubLayersMinus1; i++)
2240  {
2241#if MULTIPLE_PTL_SUPPORT
2242    READ_FLAG( uiCode, "sub_layer_profile_present_flag[i]" ); rpcPTL->setSubLayerProfilePresentFlag(i, uiCode);
2243#else
2244    if(profilePresentFlag)
2245    {
2246      READ_FLAG( uiCode, "sub_layer_profile_present_flag[i]" ); rpcPTL->setSubLayerProfilePresentFlag(i, uiCode);
2247    }
2248#endif
2249    READ_FLAG( uiCode, "sub_layer_level_present_flag[i]"   ); rpcPTL->setSubLayerLevelPresentFlag  (i, uiCode);
2250  }
2251
2252  if (maxNumSubLayersMinus1 > 0)
2253  {
2254    for (Int i = maxNumSubLayersMinus1; i < 8; i++)
2255    {
2256      READ_CODE(2, uiCode, "reserved_zero_2bits");
2257      assert(uiCode == 0);
2258    }
2259  }
2260
2261  for(Int i = 0; i < maxNumSubLayersMinus1; i++)
2262  {
2263#if MULTIPLE_PTL_SUPPORT
2264    if( rpcPTL->getSubLayerProfilePresentFlag(i) )
2265#else
2266    if( profilePresentFlag && rpcPTL->getSubLayerProfilePresentFlag(i) )
2267#endif
2268    {
2269      parseProfileTier(rpcPTL->getSubLayerPTL(i));
2270    }
2271    if(rpcPTL->getSubLayerLevelPresentFlag(i))
2272    {
2273      READ_CODE( 8, uiCode, "sub_layer_level_idc[i]" );   rpcPTL->getSubLayerPTL(i)->setLevelIdc(Level::Name(uiCode));
2274    }
2275  }
2276}
2277
2278Void TDecCavlc::parseProfileTier(ProfileTierLevel *ptl)
2279{
2280  UInt uiCode;
2281  READ_CODE(2 , uiCode, "XXX_profile_space[]");   ptl->setProfileSpace(uiCode);
2282  READ_FLAG(    uiCode, "XXX_tier_flag[]"    );   ptl->setTierFlag    (uiCode ? Level::HIGH : Level::MAIN);
2283  READ_CODE(5 , uiCode, "XXX_profile_idc[]"  );   ptl->setProfileIdc  (Profile::Name(uiCode));
2284  for(Int j = 0; j < 32; j++)
2285  {
2286    READ_FLAG(  uiCode, "XXX_profile_compatibility_flag[][j]");   ptl->setProfileCompatibilityFlag(j, uiCode ? 1 : 0);
2287  }
2288  READ_FLAG(uiCode, "general_progressive_source_flag");
2289  ptl->setProgressiveSourceFlag(uiCode ? true : false);
2290
2291  READ_FLAG(uiCode, "general_interlaced_source_flag");
2292  ptl->setInterlacedSourceFlag(uiCode ? true : false);
2293
2294  READ_FLAG(uiCode, "general_non_packed_constraint_flag");
2295  ptl->setNonPackedConstraintFlag(uiCode ? true : false);
2296
2297  READ_FLAG(uiCode, "general_frame_only_constraint_flag");
2298  ptl->setFrameOnlyConstraintFlag(uiCode ? true : false);
2299
2300  if (ptl->getProfileIdc() == Profile::MAINREXT || ptl->getProfileIdc() == Profile::HIGHTHROUGHPUTREXT )
2301  {
2302    UInt maxBitDepth=16;
2303    READ_FLAG(    uiCode, "general_max_12bit_constraint_flag" ); if (uiCode) maxBitDepth=12;
2304    READ_FLAG(    uiCode, "general_max_10bit_constraint_flag" ); if (uiCode) maxBitDepth=10;
2305    READ_FLAG(    uiCode, "general_max_8bit_constraint_flag"  ); if (uiCode) maxBitDepth=8;
2306    ptl->setBitDepthConstraint(maxBitDepth);
2307    ChromaFormat chromaFmtConstraint=CHROMA_444;
2308    READ_FLAG(    uiCode, "general_max_422chroma_constraint_flag"  ); if (uiCode) chromaFmtConstraint=CHROMA_422;
2309    READ_FLAG(    uiCode, "general_max_420chroma_constraint_flag"  ); if (uiCode) chromaFmtConstraint=CHROMA_420;
2310    READ_FLAG(    uiCode, "general_max_monochrome_constraint_flag" ); if (uiCode) chromaFmtConstraint=CHROMA_400;
2311    ptl->setChromaFormatConstraint(chromaFmtConstraint);
2312    READ_FLAG(    uiCode, "general_intra_constraint_flag");          ptl->setIntraConstraintFlag(uiCode != 0);
2313    READ_FLAG(    uiCode, "general_one_picture_only_constraint_flag");
2314    READ_FLAG(    uiCode, "general_lower_bit_rate_constraint_flag"); ptl->setLowerBitRateConstraintFlag(uiCode != 0);
2315#if MULTIPLE_PTL_SUPPORT
2316    READ_CODE(32, uiCode, "general_reserved_zero_34bits");  READ_CODE(2, uiCode, "general_reserved_zero_34bits");
2317  }
2318  else if( ptl->getProfileIdc() == Profile::SCALABLEMAIN )
2319  {
2320    READ_FLAG(    uiCode, "general_max_12bit_constraint_flag" ); assert (uiCode == 1);
2321    READ_FLAG(    uiCode, "general_max_10bit_constraint_flag" ); assert (uiCode == 1);
2322    READ_FLAG(    uiCode, "general_max_8bit_constraint_flag"  ); ptl->setProfileIdc  ((uiCode) ? Profile::SCALABLEMAIN : Profile::SCALABLEMAIN10);
2323    READ_FLAG(    uiCode, "general_max_422chroma_constraint_flag"  ); assert (uiCode == 1);
2324    READ_FLAG(    uiCode, "general_max_420chroma_constraint_flag"  ); assert (uiCode == 1);
2325    READ_FLAG(    uiCode, "general_max_monochrome_constraint_flag" ); assert (uiCode == 0);
2326    READ_FLAG(    uiCode, "general_intra_constraint_flag"); assert (uiCode == 0);
2327    READ_FLAG(    uiCode, "general_one_picture_only_constraint_flag"); assert (uiCode == 0);
2328    READ_FLAG(    uiCode, "general_lower_bit_rate_constraint_flag"); assert (uiCode == 1);
2329    READ_CODE(32, uiCode, "general_reserved_zero_34bits");  READ_CODE(2, uiCode, "general_reserved_zero_34bits");
2330  }
2331  else
2332  {
2333    ptl->setBitDepthConstraint((ptl->getProfileIdc() == Profile::MAIN10)?10:8);
2334    ptl->setChromaFormatConstraint(CHROMA_420);
2335    ptl->setIntraConstraintFlag(false);
2336    ptl->setLowerBitRateConstraintFlag(true);
2337    READ_CODE(32,  uiCode, "general_reserved_zero_43bits");  READ_CODE(11,  uiCode, "general_reserved_zero_43bits");
2338  }
2339
2340  if( ( ptl->getProfileIdc() >= 1 && ptl->getProfileIdc() <= 5 ) || 
2341      ptl->getProfileCompatibilityFlag(1) || ptl->getProfileCompatibilityFlag(2) || 
2342      ptl->getProfileCompatibilityFlag(3) || ptl->getProfileCompatibilityFlag(4) || 
2343      ptl->getProfileCompatibilityFlag(5)                                           )
2344  {
2345    READ_FLAG(uiCode, "general_inbld_flag");
2346  }
2347  else
2348  {
2349    READ_FLAG(uiCode, "general_reserved_zero_bit");
2350  }
2351#else
2352    READ_CODE(16, uiCode, "XXX_reserved_zero_35bits[0..15]");
2353    READ_CODE(16, uiCode, "XXX_reserved_zero_35bits[16..31]");
2354    READ_CODE(3,  uiCode, "XXX_reserved_zero_35bits[32..34]");
2355  }
2356  else
2357  {
2358    ptl->setBitDepthConstraint((ptl->getProfileIdc() == Profile::MAIN10)?10:8);
2359    ptl->setChromaFormatConstraint(CHROMA_420);
2360    ptl->setIntraConstraintFlag(false);
2361    ptl->setLowerBitRateConstraintFlag(true);
2362    READ_CODE(16, uiCode, "XXX_reserved_zero_44bits[0..15]");
2363    READ_CODE(16, uiCode, "XXX_reserved_zero_44bits[16..31]");
2364    READ_CODE(12, uiCode, "XXX_reserved_zero_44bits[32..43]");
2365  }
2366#endif
2367}
2368
2369Void TDecCavlc::parseTerminatingBit( UInt& ruiBit )
2370{
2371  ruiBit = false;
2372  Int iBitsLeft = m_pcBitstream->getNumBitsLeft();
2373  if(iBitsLeft <= 8)
2374  {
2375    UInt uiPeekValue = m_pcBitstream->peekBits(iBitsLeft);
2376    if (uiPeekValue == (1<<(iBitsLeft-1)))
2377    {
2378      ruiBit = true;
2379    }
2380  }
2381}
2382
2383Void TDecCavlc::parseRemainingBytes( Bool noTrailingBytesExpected )
2384{
2385  if (noTrailingBytesExpected)
2386  {
2387    const UInt numberOfRemainingSubstreamBytes=m_pcBitstream->getNumBitsLeft();
2388    assert (numberOfRemainingSubstreamBytes == 0);
2389  }
2390  else
2391  {
2392    while (m_pcBitstream->getNumBitsLeft())
2393    {
2394      UInt trailingNullByte=m_pcBitstream->readByte();
2395      if (trailingNullByte!=0)
2396      {
2397        printf("Trailing byte should be 0, but has value %02x\n", trailingNullByte);
2398        assert(trailingNullByte==0);
2399      }
2400    }
2401  }
2402}
2403
2404Void TDecCavlc::parseSkipFlag( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
2405{
2406  assert(0);
2407}
2408
2409Void TDecCavlc::parseCUTransquantBypassFlag( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
2410{
2411  assert(0);
2412}
2413
2414Void TDecCavlc::parseMVPIdx( Int& /*riMVPIdx*/ )
2415{
2416  assert(0);
2417}
2418
2419Void TDecCavlc::parseSplitFlag     ( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
2420{
2421  assert(0);
2422}
2423
2424Void TDecCavlc::parsePartSize( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
2425{
2426  assert(0);
2427}
2428
2429Void TDecCavlc::parsePredMode( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
2430{
2431  assert(0);
2432}
2433
2434/** Parse I_PCM information.
2435* \param pcCU pointer to CU
2436* \param uiAbsPartIdx CU index
2437* \param uiDepth CU depth
2438* \returns Void
2439*
2440* If I_PCM flag indicates that the CU is I_PCM, parse its PCM alignment bits and codes.
2441*/
2442Void TDecCavlc::parseIPCMInfo( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
2443{
2444  assert(0);
2445}
2446
2447Void TDecCavlc::parseIntraDirLumaAng  ( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
2448{
2449  assert(0);
2450}
2451
2452Void TDecCavlc::parseIntraDirChroma( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
2453{
2454  assert(0);
2455}
2456
2457Void TDecCavlc::parseInterDir( TComDataCU* /*pcCU*/, UInt& /*ruiInterDir*/, UInt /*uiAbsPartIdx*/ )
2458{
2459  assert(0);
2460}
2461
2462Void TDecCavlc::parseRefFrmIdx( TComDataCU* /*pcCU*/, Int& /*riRefFrmIdx*/, RefPicList /*eRefList*/ )
2463{
2464  assert(0);
2465}
2466
2467Void TDecCavlc::parseMvd( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiPartIdx*/, UInt /*uiDepth*/, RefPicList /*eRefList*/ )
2468{
2469  assert(0);
2470}
2471
2472Void TDecCavlc::parseCrossComponentPrediction( class TComTU& /*rTu*/, ComponentID /*compID*/ )
2473{
2474  assert(0);
2475}
2476
2477Void TDecCavlc::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2478{
2479  Int qp;
2480  Int  iDQp;
2481
2482#if RExt__DECODER_DEBUG_BIT_STATISTICS
2483  READ_SVLC(iDQp, "delta_qp");
2484#else
2485  xReadSvlc( iDQp );
2486#endif
2487
2488#if REPN_FORMAT_IN_VPS
2489  Int qpBdOffsetY = pcCU->getSlice()->getQpBDOffsetY();
2490#else
2491  Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffset(CHANNEL_TYPE_LUMA);
2492#endif
2493  qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+ qpBdOffsetY)) -  qpBdOffsetY;
2494
2495  UInt uiAbsQpCUPartIdx = (uiAbsPartIdx>>((g_uiMaxCUDepth - pcCU->getSlice()->getPPS()->getMaxCuDQPDepth())<<1))<<((g_uiMaxCUDepth - pcCU->getSlice()->getPPS()->getMaxCuDQPDepth())<<1) ;
2496  UInt uiQpCUDepth =   min(uiDepth,pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()) ;
2497
2498  pcCU->setQPSubParts( qp, uiAbsQpCUPartIdx, uiQpCUDepth );
2499}
2500
2501Void TDecCavlc::parseChromaQpAdjustment( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
2502{
2503  assert(0);
2504}
2505
2506Void TDecCavlc::parseCoeffNxN( TComTU &/*rTu*/, ComponentID /*compID*/ )
2507{
2508  assert(0);
2509}
2510
2511Void TDecCavlc::parseTransformSubdivFlag( UInt& /*ruiSubdivFlag*/, UInt /*uiLog2TransformBlockSize*/ )
2512{
2513  assert(0);
2514}
2515
2516Void TDecCavlc::parseQtCbf( TComTU &/*rTu*/, const ComponentID /*compID*/, const Bool /*lowestLevel*/ )
2517{
2518  assert(0);
2519}
2520
2521Void TDecCavlc::parseQtRootCbf( UInt /*uiAbsPartIdx*/, UInt& /*uiQtRootCbf*/ )
2522{
2523  assert(0);
2524}
2525
2526Void TDecCavlc::parseTransformSkipFlags (TComTU &/*rTu*/, ComponentID /*component*/)
2527{
2528  assert(0);
2529}
2530
2531Void TDecCavlc::parseMergeFlag ( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/, UInt /*uiPUIdx*/ )
2532{
2533  assert(0);
2534}
2535
2536Void TDecCavlc::parseMergeIndex ( TComDataCU* /*pcCU*/, UInt& /*ruiMergeIndex*/ )
2537{
2538  assert(0);
2539}
2540
2541// ====================================================================================================================
2542// Protected member functions
2543// ====================================================================================================================
2544
2545/** parse explicit wp tables
2546* \param TComSlice* pcSlice
2547* \returns Void
2548*/
2549Void TDecCavlc::xParsePredWeightTable( TComSlice* pcSlice )
2550{
2551        WPScalingParam *wp;
2552        TComSPS        *sps          = pcSlice->getSPS();
2553  const ChromaFormat    chFmt        = sps->getChromaFormatIdc();
2554  const Int             numValidComp = Int(getNumberValidComponents(chFmt));
2555  const Bool            bChroma      = (chFmt!=CHROMA_400);
2556  const SliceType       eSliceType   = pcSlice->getSliceType();
2557  const Int             iNbRef       = (eSliceType == B_SLICE ) ? (2) : (1);
2558        UInt            uiLog2WeightDenomLuma=0, uiLog2WeightDenomChroma=0;
2559        UInt            uiTotalSignalledWeightFlags = 0;
2560
2561  Int iDeltaDenom;
2562  // decode delta_luma_log2_weight_denom :
2563  READ_UVLC( uiLog2WeightDenomLuma, "luma_log2_weight_denom" );     // ue(v): luma_log2_weight_denom
2564  assert( uiLog2WeightDenomLuma <= 7 );
2565  if( bChroma )
2566  {
2567    READ_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" );     // se(v): delta_chroma_log2_weight_denom
2568    assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)>=0);
2569    assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)<=7);
2570    uiLog2WeightDenomChroma = (UInt)(iDeltaDenom + uiLog2WeightDenomLuma);
2571  }
2572
2573  for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ )
2574  {
2575    RefPicList  eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
2576    for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
2577    {
2578      pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
2579
2580      wp[COMPONENT_Y].uiLog2WeightDenom = uiLog2WeightDenomLuma;
2581      for(Int j=1; j<numValidComp; j++)
2582      {
2583        wp[j].uiLog2WeightDenom = uiLog2WeightDenomChroma;
2584      }
2585
2586      UInt  uiCode;
2587      READ_FLAG( uiCode, "luma_weight_lX_flag" );           // u(1): luma_weight_l0_flag
2588      wp[COMPONENT_Y].bPresentFlag = ( uiCode == 1 );
2589      uiTotalSignalledWeightFlags += wp[COMPONENT_Y].bPresentFlag;
2590    }
2591    if ( bChroma )
2592    {
2593      UInt  uiCode;
2594      for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
2595      {
2596        pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
2597        READ_FLAG( uiCode, "chroma_weight_lX_flag" );      // u(1): chroma_weight_l0_flag
2598        for(Int j=1; j<numValidComp; j++)
2599        {
2600          wp[j].bPresentFlag = ( uiCode == 1 );
2601        }
2602        uiTotalSignalledWeightFlags += 2*wp[COMPONENT_Cb].bPresentFlag;
2603      }
2604    }
2605    for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
2606    {
2607      pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
2608      if ( wp[COMPONENT_Y].bPresentFlag )
2609      {
2610        Int iDeltaWeight;
2611        READ_SVLC( iDeltaWeight, "delta_luma_weight_lX" );  // se(v): delta_luma_weight_l0[i]
2612        assert( iDeltaWeight >= -128 );
2613        assert( iDeltaWeight <=  127 );
2614        wp[COMPONENT_Y].iWeight = (iDeltaWeight + (1<<wp[COMPONENT_Y].uiLog2WeightDenom));
2615        READ_SVLC( wp[COMPONENT_Y].iOffset, "luma_offset_lX" );       // se(v): luma_offset_l0[i]
2616        Int range=sps->getUseHighPrecisionPredictionWeighting() ? (1<<g_bitDepth[CHANNEL_TYPE_LUMA])/2 : 128;
2617        assert( wp[0].iOffset >= -range );
2618        assert( wp[0].iOffset <   range );
2619      }
2620      else
2621      {
2622        wp[COMPONENT_Y].iWeight = (1 << wp[COMPONENT_Y].uiLog2WeightDenom);
2623        wp[COMPONENT_Y].iOffset = 0;
2624      }
2625      if ( bChroma )
2626      {
2627        if ( wp[COMPONENT_Cb].bPresentFlag )
2628        {
2629          Int range=sps->getUseHighPrecisionPredictionWeighting() ? (1<<g_bitDepth[CHANNEL_TYPE_CHROMA])/2 : 128;
2630          for ( Int j=1 ; j<numValidComp ; j++ )
2631          {
2632            Int iDeltaWeight;
2633            READ_SVLC( iDeltaWeight, "delta_chroma_weight_lX" );  // se(v): chroma_weight_l0[i][j]
2634            assert( iDeltaWeight >= -128 );
2635            assert( iDeltaWeight <=  127 );
2636            wp[j].iWeight = (iDeltaWeight + (1<<wp[j].uiLog2WeightDenom));
2637
2638            Int iDeltaChroma;
2639            READ_SVLC( iDeltaChroma, "delta_chroma_offset_lX" );  // se(v): delta_chroma_offset_l0[i][j]
2640            assert( iDeltaChroma >= -4*range);
2641            assert( iDeltaChroma <   4*range);
2642            Int pred = ( range - ( ( range*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) );
2643            wp[j].iOffset = Clip3(-range, range-1, (iDeltaChroma + pred) );
2644          }
2645        }
2646        else
2647        {
2648          for ( Int j=1 ; j<numValidComp ; j++ )
2649          {
2650            wp[j].iWeight = (1 << wp[j].uiLog2WeightDenom);
2651            wp[j].iOffset = 0;
2652          }
2653        }
2654      }
2655    }
2656
2657    for ( Int iRefIdx=pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx<MAX_NUM_REF ; iRefIdx++ )
2658    {
2659      pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
2660
2661      wp[0].bPresentFlag = false;
2662      wp[1].bPresentFlag = false;
2663      wp[2].bPresentFlag = false;
2664    }
2665  }
2666  assert(uiTotalSignalledWeightFlags<=24);
2667}
2668
2669/** decode quantization matrix
2670* \param scalingList quantization matrix information
2671*/
2672Void TDecCavlc::parseScalingList(TComScalingList* scalingList)
2673{
2674  UInt  code, sizeId, listId;
2675  Bool scalingListPredModeFlag;
2676  //for each size
2677  for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2678  {
2679    for(listId = 0; listId <  SCALING_LIST_NUM; listId++)
2680    {
2681      if ((sizeId==SCALING_LIST_32x32) && (listId%(SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) != 0))
2682      {
2683        Int *src = scalingList->getScalingListAddress(sizeId, listId);
2684        const Int size = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
2685        const Int *srcNextSmallerSize = scalingList->getScalingListAddress(sizeId-1, listId);
2686        for(Int i=0; i<size; i++)
2687        {
2688          src[i] = srcNextSmallerSize[i];
2689        }
2690        scalingList->setScalingListDC(sizeId,listId,(sizeId > SCALING_LIST_8x8) ? scalingList->getScalingListDC(sizeId-1, listId) : src[0]);
2691      }
2692      else
2693      {
2694        READ_FLAG( code, "scaling_list_pred_mode_flag");
2695        scalingListPredModeFlag = (code) ? true : false;
2696        if(!scalingListPredModeFlag) //Copy Mode
2697        {
2698          READ_UVLC( code, "scaling_list_pred_matrix_id_delta");
2699
2700          if (sizeId==SCALING_LIST_32x32)
2701            code*=(SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES); // Adjust the decoded code for this size, to cope with the missing 32x32 chroma entries.
2702
2703          scalingList->setRefMatrixId (sizeId,listId,(UInt)((Int)(listId)-(code)));
2704          if( sizeId > SCALING_LIST_8x8 )
2705          {
2706            scalingList->setScalingListDC(sizeId,listId,((listId == scalingList->getRefMatrixId (sizeId,listId))? 16 :scalingList->getScalingListDC(sizeId, scalingList->getRefMatrixId (sizeId,listId))));
2707          }
2708          scalingList->processRefMatrix( sizeId, listId, scalingList->getRefMatrixId (sizeId,listId));
2709
2710        }
2711        else //DPCM Mode
2712        {
2713          xDecodeScalingList(scalingList, sizeId, listId);
2714        }
2715      }
2716    }
2717  }
2718
2719  return;
2720}
2721/** decode DPCM
2722* \param scalingList  quantization matrix information
2723* \param sizeId size index
2724* \param listId list index
2725*/
2726Void TDecCavlc::xDecodeScalingList(TComScalingList *scalingList, UInt sizeId, UInt listId)
2727{
2728  Int i,coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
2729  Int data;
2730  Int scalingListDcCoefMinus8 = 0;
2731  Int nextCoef = SCALING_LIST_START_VALUE;
2732  UInt* scan  = g_scanOrder[SCAN_UNGROUPED][SCAN_DIAG][sizeId==0 ? 2 : 3][sizeId==0 ? 2 : 3];
2733  Int *dst = scalingList->getScalingListAddress(sizeId, listId);
2734
2735  if( sizeId > SCALING_LIST_8x8 )
2736  {
2737    READ_SVLC( scalingListDcCoefMinus8, "scaling_list_dc_coef_minus8");
2738    scalingList->setScalingListDC(sizeId,listId,scalingListDcCoefMinus8 + 8);
2739    nextCoef = scalingList->getScalingListDC(sizeId,listId);
2740  }
2741
2742  for(i = 0; i < coefNum; i++)
2743  {
2744    READ_SVLC( data, "scaling_list_delta_coef");
2745    nextCoef = (nextCoef + data + 256 ) % 256;
2746    dst[scan[i]] = nextCoef;
2747  }
2748}
2749
2750Bool TDecCavlc::xMoreRbspData()
2751{
2752  Int bitsLeft = m_pcBitstream->getNumBitsLeft();
2753
2754  // if there are more than 8 bits, it cannot be rbsp_trailing_bits
2755  if (bitsLeft > 8)
2756  {
2757    return true;
2758  }
2759
2760  UChar lastByte = m_pcBitstream->peekBits(bitsLeft);
2761  Int cnt = bitsLeft;
2762
2763  // remove trailing bits equal to zero
2764  while ((cnt>0) && ((lastByte & 1) == 0))
2765  {
2766    lastByte >>= 1;
2767    cnt--;
2768  }
2769  // remove bit equal to one
2770  cnt--;
2771
2772  // we should not have a negative number of bits
2773  assert (cnt>=0);
2774
2775  // we have more data, if cnt is not zero
2776  return (cnt>0);
2777}
2778
2779Void TDecCavlc::parseExplicitRdpcmMode( TComTU &rTu, ComponentID compID )
2780{
2781  assert(0);
2782}
2783
2784#if SVC_EXTENSION
2785Void TDecCavlc::parseVPSExtension(TComVPS *vps)
2786{
2787  UInt uiCode;
2788  // ... More syntax elements to be parsed here
2789#if P0300_ALT_OUTPUT_LAYER_FLAG
2790  Int NumOutputLayersInOutputLayerSet[MAX_VPS_LAYER_SETS_PLUS1];
2791  Int OlsHighestOutputLayerId[MAX_VPS_LAYER_SETS_PLUS1];
2792#endif
2793#if LIST_OF_PTL
2794  if( vps->getMaxLayers() > 1 && vps->getBaseLayerInternalFlag() )
2795  {
2796    vps->setProfilePresentFlag(1, false);
2797#if MULTIPLE_PTL_SUPPORT
2798    parsePTL( vps->getPTL(1), vps->getProfilePresentFlag(1), vps->getMaxTLayers() - 1 );
2799#else
2800    vps->getPTLForExtnPtr()->empty();
2801    vps->getPTLForExtnPtr()->resize(2);
2802    vps->getPTLForExtn(1)->copyProfileInfo( vps->getPTL() );
2803    parsePTL( vps->getPTLForExtn(1), vps->getProfilePresentFlag(1), vps->getMaxTLayers() - 1 );
2804#endif
2805  }
2806#endif
2807#if VPS_EXTN_MASK_AND_DIM_INFO
2808  UInt numScalabilityTypes = 0, i = 0, j = 0;
2809
2810#if !VPS_AVC_BL_FLAG_REMOVAL
2811  READ_FLAG( uiCode, "avc_base_layer_flag" ); vps->setAvcBaseLayerFlag(uiCode ? true : false);
2812#endif
2813
2814#if !P0307_REMOVE_VPS_VUI_OFFSET
2815#if O0109_MOVE_VPS_VUI_FLAG
2816  READ_FLAG( uiCode, "vps_vui_present_flag"); vps->setVpsVuiPresentFlag(uiCode ? true : false);
2817  if ( uiCode )
2818  {
2819#endif
2820#if VPS_VUI_OFFSET
2821    READ_CODE( 16, uiCode, "vps_vui_offset" );  vps->setVpsVuiOffset( uiCode );
2822#endif
2823#if O0109_MOVE_VPS_VUI_FLAG
2824  }
2825#endif
2826#endif
2827  READ_FLAG( uiCode, "splitting_flag" ); vps->setSplittingFlag(uiCode ? true : false);
2828
2829  for(i = 0; i < MAX_VPS_NUM_SCALABILITY_TYPES; i++)
2830  {
2831    READ_FLAG( uiCode, "scalability_mask[i]" ); vps->setScalabilityMask(i, uiCode ? true : false);
2832    numScalabilityTypes += uiCode;
2833  }
2834  vps->setNumScalabilityTypes(numScalabilityTypes);
2835
2836  for(j = 0; j < numScalabilityTypes - vps->getSplittingFlag(); j++)
2837  {
2838    READ_CODE( 3, uiCode, "dimension_id_len_minus1[j]" ); vps->setDimensionIdLen(j, uiCode + 1);
2839  }
2840
2841  // The value of dimBitOffset[ NumScalabilityTypes ] is set equal to 6.
2842  if(vps->getSplittingFlag())
2843  {
2844    UInt numBits = 0;
2845    for(j = 0; j < numScalabilityTypes - 1; j++)
2846    {
2847      numBits += vps->getDimensionIdLen(j);
2848    }
2849    assert( numBits < 6 );
2850    vps->setDimensionIdLen(numScalabilityTypes-1, 6 - numBits);
2851    numBits = 6;
2852  }
2853
2854  READ_FLAG( uiCode, "vps_nuh_layer_id_present_flag" ); vps->setNuhLayerIdPresentFlag(uiCode ? true : false);
2855  vps->setLayerIdInNuh(0, 0);
2856  vps->setLayerIdInVps(0, 0);
2857  for(i = 1; i < vps->getMaxLayers(); i++)
2858  {
2859    if( vps->getNuhLayerIdPresentFlag() )
2860    {
2861      READ_CODE( 6, uiCode, "layer_id_in_nuh[i]" ); vps->setLayerIdInNuh(i, uiCode);
2862      assert( uiCode > vps->getLayerIdInNuh(i-1) );
2863    }
2864    else
2865    {
2866      vps->setLayerIdInNuh(i, i);
2867    }
2868    vps->setLayerIdInVps(vps->getLayerIdInNuh(i), i);
2869
2870    if( !vps->getSplittingFlag() )
2871    {
2872      for(j = 0; j < numScalabilityTypes; j++)
2873      {
2874        READ_CODE( vps->getDimensionIdLen(j), uiCode, "dimension_id[i][j]" ); vps->setDimensionId(i, j, uiCode);
2875#if !AUXILIARY_PICTURES
2876        assert( uiCode <= vps->getMaxLayerId() );
2877#endif
2878      }
2879    }
2880  }
2881#endif
2882#if VIEW_ID_RELATED_SIGNALING
2883  // if ( pcVPS->getNumViews() > 1 )
2884  //   However, this is a bug in the text since, view_id_len_minus1 is needed to parse view_id_val.
2885  {
2886#if O0109_VIEW_ID_LEN
2887    READ_CODE( 4, uiCode, "view_id_len" ); vps->setViewIdLen( uiCode );
2888#else
2889    READ_CODE( 4, uiCode, "view_id_len_minus1" ); vps->setViewIdLenMinus1( uiCode );
2890#endif
2891  }
2892
2893#if O0109_VIEW_ID_LEN
2894  if ( vps->getViewIdLen() > 0 )
2895  {
2896    for(  i = 0; i < vps->getNumViews(); i++ )
2897    {
2898      READ_CODE( vps->getViewIdLen( ), uiCode, "view_id_val[i]" ); vps->setViewIdVal( i, uiCode );
2899    }
2900  }
2901#else
2902  for(  i = 0; i < vps->getNumViews(); i++ )
2903  {
2904    READ_CODE( vps->getViewIdLenMinus1( ) + 1, uiCode, "view_id_val[i]" ); vps->setViewIdVal( i, uiCode );
2905  }
2906#endif
2907#endif // view id related signaling
2908#if VPS_EXTN_DIRECT_REF_LAYERS
2909  // For layer 0
2910  vps->setNumDirectRefLayers(0, 0);
2911  // For other layers
2912  for( Int layerCtr = 1; layerCtr <= vps->getMaxLayers() - 1; layerCtr++)
2913  {
2914    UInt numDirectRefLayers = 0;
2915    for( Int refLayerCtr = 0; refLayerCtr < layerCtr; refLayerCtr++)
2916    {
2917      READ_FLAG(uiCode, "direct_dependency_flag[i][j]" ); vps->setDirectDependencyFlag(layerCtr, refLayerCtr, uiCode? true : false);
2918      if(uiCode)
2919      {
2920        vps->setRefLayerId(layerCtr, numDirectRefLayers, refLayerCtr);
2921        numDirectRefLayers++;
2922      }
2923    }
2924    vps->setNumDirectRefLayers(layerCtr, numDirectRefLayers);
2925  }
2926#endif
2927#if Q0078_ADD_LAYER_SETS
2928#if O0092_0094_DEPENDENCY_CONSTRAINT // Moved here
2929  vps->setNumRefLayers();
2930
2931  if (vps->getMaxLayers() > MAX_REF_LAYERS)
2932  {
2933    for (i = 1; i < vps->getMaxLayers(); i++)
2934    {
2935      assert(vps->getNumRefLayers(vps->getLayerIdInNuh(i)) <= MAX_REF_LAYERS);
2936    }
2937  }
2938#endif
2939  vps->setPredictedLayerIds();
2940  vps->setTreePartitionLayerIdList();
2941#endif
2942#if MOVE_ADDN_LS_SIGNALLING
2943#if Q0078_ADD_LAYER_SETS
2944  if (vps->getNumIndependentLayers() > 1)
2945  {
2946    READ_UVLC(uiCode, "num_add_layer_sets"); vps->setNumAddLayerSets(uiCode);
2947    for (i = 0; i < vps->getNumAddLayerSets(); i++)
2948    {
2949      for (j = 1; j < vps->getNumIndependentLayers(); j++)
2950      {
2951        int len = 1;
2952        while ((1 << len) < (vps->getNumLayersInTreePartition(j) + 1))
2953        {
2954          len++;
2955        }
2956        READ_CODE(len, uiCode, "highest_layer_idx_plus1[i][j]"); vps->setHighestLayerIdxPlus1(i, j, uiCode);
2957      }
2958    }
2959    vps->setNumLayerSets(vps->getNumLayerSets() + vps->getNumAddLayerSets());
2960#if FIX_LAYER_ID_INIT
2961    vps->deriveLayerIdListVariablesForAddLayerSets();
2962#else
2963    vps->setLayerIdIncludedFlagsForAddLayerSets();
2964#endif
2965  }
2966  else
2967  {
2968    vps->setNumAddLayerSets(0);
2969  }
2970#endif
2971#endif
2972#if VPS_TSLAYERS
2973  READ_FLAG( uiCode, "vps_sub_layers_max_minus1_present_flag"); vps->setMaxTSLayersPresentFlag(uiCode ? true : false);
2974
2975  if (vps->getMaxTSLayersPresentFlag())
2976  {
2977    for(i = 0; i < vps->getMaxLayers(); i++)
2978    {
2979      READ_CODE( 3, uiCode, "sub_layers_vps_max_minus1[i]" ); vps->setMaxTSLayersMinus1(i, uiCode);
2980    }
2981  }
2982  else
2983  {
2984    for( i = 0; i < vps->getMaxLayers(); i++)
2985    {
2986      vps->setMaxTSLayersMinus1(i, vps->getMaxTLayers()-1);
2987    }
2988  }
2989#endif
2990  READ_FLAG( uiCode, "max_tid_ref_present_flag"); vps->setMaxTidRefPresentFlag(uiCode ? true : false);
2991  if (vps->getMaxTidRefPresentFlag())
2992  {
2993    for(i = 0; i < vps->getMaxLayers() - 1; i++)
2994    {
2995#if O0225_MAX_TID_FOR_REF_LAYERS
2996      for( j = i+1; j <= vps->getMaxLayers() - 1; j++)
2997      {
2998        if(vps->getDirectDependencyFlag(j, i))
2999        {
3000          READ_CODE( 3, uiCode, "max_tid_il_ref_pics_plus1[i][j]" ); vps->setMaxTidIlRefPicsPlus1(i, j, uiCode);         
3001        }
3002      }
3003#else
3004      READ_CODE( 3, uiCode, "max_tid_il_ref_pics_plus1[i]" ); vps->setMaxTidIlRefPicsPlus1(i, uiCode);
3005      assert( uiCode <= vps->getMaxTLayers());
3006#endif
3007    }
3008  }
3009  else
3010  {
3011    for(i = 0; i < vps->getMaxLayers() - 1; i++)
3012    {
3013#if O0225_MAX_TID_FOR_REF_LAYERS
3014      for( j = i+1; j <= vps->getMaxLayers() - 1; j++)
3015      {
3016        vps->setMaxTidIlRefPicsPlus1(i, j, 7);
3017      }
3018#else
3019      vps->setMaxTidIlRefPicsPlus1(i, 7);
3020#endif
3021    }
3022  }
3023  READ_FLAG( uiCode, "all_ref_layers_active_flag" ); vps->setIlpSshSignalingEnabledFlag(uiCode ? true : false);
3024#if VPS_EXTN_PROFILE_INFO
3025  // Profile-tier-level signalling
3026#if !VPS_EXTN_UEV_CODING
3027  READ_CODE( 10, uiCode, "vps_number_layer_sets_minus1" );     assert( uiCode == (vps->getNumLayerSets() - 1) );
3028  READ_CODE(  6, uiCode, "vps_num_profile_tier_level_minus1"); vps->setNumProfileTierLevel( uiCode + 1 );
3029#else
3030  READ_UVLC(  uiCode, "vps_num_profile_tier_level_minus1"); vps->setNumProfileTierLevel( uiCode + 1 );
3031#endif
3032#if PER_LAYER_PTL
3033  Int const numBitsForPtlIdx = vps->calculateLenOfSyntaxElement( vps->getNumProfileTierLevel() );
3034#endif
3035#if !MULTIPLE_PTL_SUPPORT
3036  vps->getPTLForExtnPtr()->resize(vps->getNumProfileTierLevel());
3037#endif
3038#if LIST_OF_PTL
3039  for(Int idx = vps->getBaseLayerInternalFlag() ? 2 : 1; idx <= vps->getNumProfileTierLevel() - 1; idx++)
3040#else
3041  for(Int idx = 1; idx <= vps->getNumProfileTierLevel() - 1; idx++)
3042#endif
3043  {
3044    READ_FLAG( uiCode, "vps_profile_present_flag[i]" ); vps->setProfilePresentFlag(idx, uiCode ? true : false);
3045    if( !vps->getProfilePresentFlag(idx) )
3046    {
3047#if P0048_REMOVE_PROFILE_REF
3048      // Copy profile information from previous one
3049#if MULTIPLE_PTL_SUPPORT
3050      vps->getPTL(idx)->copyProfileInfo( vps->getPTL( idx - 1 ) );
3051#else
3052      vps->getPTLForExtn(idx)->copyProfileInfo( (idx==1) ? vps->getPTL() : vps->getPTLForExtn( idx - 1 ) );
3053#endif
3054#else
3055      READ_CODE( 6, uiCode, "profile_ref_minus1[i]" ); vps->setProfileLayerSetRef(idx, uiCode + 1);
3056#if O0109_PROF_REF_MINUS1
3057      assert( vps->getProfileLayerSetRef(idx) <= idx );
3058#else
3059      assert( vps->getProfileLayerSetRef(idx) < idx );
3060#endif
3061      // Copy profile information as indicated
3062      vps->getPTLForExtn(idx)->copyProfileInfo( vps->getPTLForExtn( vps->getProfileLayerSetRef(idx) ) );
3063#endif
3064    }
3065#if MULTIPLE_PTL_SUPPORT
3066    parsePTL( vps->getPTL(idx), vps->getProfilePresentFlag(idx), vps->getMaxTLayers() - 1 );
3067#else
3068    parsePTL( vps->getPTLForExtn(idx), vps->getProfilePresentFlag(idx), vps->getMaxTLayers() - 1 );
3069#endif
3070  }
3071#endif
3072
3073#if !MOVE_ADDN_LS_SIGNALLING
3074#if Q0078_ADD_LAYER_SETS
3075  if (vps->getNumIndependentLayers() > 1)
3076  {
3077    READ_UVLC(uiCode, "num_add_layer_sets"); vps->setNumAddLayerSets(uiCode);
3078    for (i = 0; i < vps->getNumAddLayerSets(); i++)
3079    {
3080      for (j = 1; j < vps->getNumIndependentLayers(); j++)
3081      {
3082        int len = 1;
3083        while ((1 << len) < (vps->getNumLayersInTreePartition(j) + 1))
3084        {
3085          len++;
3086        }
3087        READ_CODE(len, uiCode, "highest_layer_idx_plus1[i][j]"); vps->setHighestLayerIdxPlus1(i, j, uiCode);
3088      }
3089    }
3090    vps->setNumLayerSets(vps->getNumLayerSets() + vps->getNumAddLayerSets());
3091    vps->setLayerIdIncludedFlagsForAddLayerSets();
3092  }
3093#endif
3094#endif
3095
3096#if !VPS_EXTN_UEV_CODING
3097  READ_FLAG( uiCode, "more_output_layer_sets_than_default_flag" ); vps->setMoreOutputLayerSetsThanDefaultFlag( uiCode ? true : false );
3098  Int numOutputLayerSets = 0;
3099  if(! vps->getMoreOutputLayerSetsThanDefaultFlag() )
3100  {
3101    numOutputLayerSets = vps->getNumLayerSets();
3102  }
3103  else
3104  {
3105    READ_CODE( 10, uiCode, "num_add_output_layer_sets" );          vps->setNumAddOutputLayerSets( uiCode );
3106    numOutputLayerSets = vps->getNumLayerSets() + vps->getNumAddOutputLayerSets();
3107  }
3108#else
3109
3110#if Q0165_NUM_ADD_OUTPUT_LAYER_SETS
3111  if( vps->getNumLayerSets() > 1 )
3112  {
3113    READ_UVLC( uiCode, "num_add_olss" );            vps->setNumAddOutputLayerSets( uiCode );
3114    READ_CODE( 2, uiCode, "default_output_layer_idc" );   vps->setDefaultTargetOutputLayerIdc( uiCode );
3115  }
3116  else
3117  {
3118    vps->setNumAddOutputLayerSets( 0 );
3119  }
3120#else
3121  READ_UVLC( uiCode, "num_add_output_layer_sets" );          vps->setNumAddOutputLayerSets( uiCode );
3122#endif
3123
3124  // The value of num_add_olss shall be in the range of 0 to 1023, inclusive.
3125  assert( vps->getNumAddOutputLayerSets() >= 0 && vps->getNumAddOutputLayerSets() < 1024 );
3126
3127  Int numOutputLayerSets = vps->getNumLayerSets() + vps->getNumAddOutputLayerSets();
3128#endif
3129
3130#if P0295_DEFAULT_OUT_LAYER_IDC
3131#if !Q0165_NUM_ADD_OUTPUT_LAYER_SETS
3132  if( numOutputLayerSets > 1 )
3133  {
3134    READ_CODE( 2, uiCode, "default_target_output_layer_idc" );   vps->setDefaultTargetOutputLayerIdc( uiCode );
3135  }
3136#endif
3137  vps->setNumOutputLayerSets( numOutputLayerSets );
3138#if NECESSARY_LAYER_FLAG
3139  // Default output layer set
3140  vps->setOutputLayerSetIdx(0, 0);
3141  vps->setOutputLayerFlag(0, 0, true);
3142  vps->deriveNecessaryLayerFlag(0);
3143#if PER_LAYER_PTL
3144  vps->getProfileLevelTierIdx()->resize(numOutputLayerSets);
3145  vps->getProfileLevelTierIdx(0)->push_back( vps->getBaseLayerInternalFlag() && vps->getMaxLayers() > 1 ? 1 : 0);
3146#endif
3147#endif
3148  for(i = 1; i < numOutputLayerSets; i++)
3149  {
3150#if VPS_FIX_TO_MATCH_SPEC
3151    if( vps->getNumLayerSets() > 2 && i >= vps->getNumLayerSets() )
3152#else
3153    if( i > (vps->getNumLayerSets() - 1) )
3154#endif
3155    {
3156      Int numBits = 1;
3157      while ((1 << numBits) < (vps->getNumLayerSets() - 1))
3158      {
3159        numBits++;
3160      }
3161      READ_CODE( numBits, uiCode, "layer_set_idx_for_ols_minus1");   vps->setOutputLayerSetIdx( i, uiCode + 1);
3162    }
3163    else
3164    {
3165      vps->setOutputLayerSetIdx( i, i );
3166    }
3167    Int layerSetIdxForOutputLayerSet = vps->getOutputLayerSetIdx(i);
3168#if Q0078_ADD_LAYER_SETS
3169#if VPS_FIX_TO_MATCH_SPEC
3170    if( i > vps->getVpsNumLayerSetsMinus1() || vps->getDefaultTargetOutputLayerIdc() == 2 )
3171#else
3172    if( i > vps->getVpsNumLayerSetsMinus1() || vps->getDefaultTargetOutputLayerIdc() >= 2 )
3173#endif
3174#else
3175#if VPS_FIX_TO_MATCH_SPEC
3176    if( i > (vps->getNumLayerSets() - 1) || vps->getDefaultTargetOutputLayerIdc() == 2 )
3177#else
3178    if( i > (vps->getNumLayerSets() - 1) || vps->getDefaultTargetOutputLayerIdc() >= 2 )
3179#endif
3180#endif
3181    {
3182#if NUM_OL_FLAGS
3183      for(j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet); j++)
3184#else
3185      for(j = 0; j < vps->getNumLayersInIdList(lsIdx) - 1; j++)
3186#endif
3187      {
3188        READ_FLAG( uiCode, "output_layer_flag[i][j]"); vps->setOutputLayerFlag(i, j, uiCode);
3189      }
3190    }
3191    else
3192    {
3193      // i <= (vps->getNumLayerSets() - 1)
3194      // Assign OutputLayerFlag depending on default_one_target_output_layer_flag
3195      if( vps->getDefaultTargetOutputLayerIdc() == 1 )
3196      {
3197        for(j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet); j++)
3198        {
3199#if DEF_OPT_LAYER_IDC
3200          vps->setOutputLayerFlag(i, j, (j == (vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet)-1))  );
3201
3202#else
3203          vps->setOutputLayerFlag(i, j, (j == (vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet)-1)) && (vps->getDimensionId(j,1) == 0) );
3204#endif
3205        }
3206      }
3207      else if ( vps->getDefaultTargetOutputLayerIdc() == 0 )
3208      {
3209        for(j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet); j++)
3210        {
3211          vps->setOutputLayerFlag(i, j, 1);
3212        }
3213      }
3214    }
3215#if NECESSARY_LAYER_FLAG
3216    vps->deriveNecessaryLayerFlag(i); 
3217#endif
3218#if PER_LAYER_PTL
3219    vps->getProfileLevelTierIdx(i)->assign(vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet), -1);
3220    for(j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet) ; j++)
3221    {
3222#if VPS_FIX_TO_MATCH_SPEC
3223      if( vps->getNecessaryLayerFlag(i, j) && (vps->getNumProfileTierLevel()-1) > 0 )
3224#else
3225      if( vps->getNecessaryLayerFlag(i, j) )
3226#endif
3227      {
3228        READ_CODE( numBitsForPtlIdx, uiCode, "profile_tier_level_idx[i]" ); 
3229        vps->setProfileLevelTierIdx(i, j, uiCode );
3230
3231#if MULTIPLE_PTL_SUPPORT
3232        //For conformance checking
3233        //Conformance of a layer in an output operation point associated with an OLS in a bitstream to the Scalable Main profile is indicated as follows:
3234        //If OpTid of the output operation point is equal to vps_max_sub_layer_minus1, the conformance is indicated by general_profile_idc being equal to 7 or general_profile_compatibility_flag[ 7 ] being equal to 1
3235        //Conformance of a layer in an output operation point associated with an OLS in a bitstream to the Scalable Main 10 profile is indicated as follows:
3236        //If OpTid of the output operation point is equal to vps_max_sub_layer_minus1, the conformance is indicated by general_profile_idc being equal to 7 or general_profile_compatibility_flag[ 7 ] being equal to 1
3237        //The following assert may be updated / upgraded to take care of general_profile_compatibility_flag.
3238#if R0235_SMALLEST_LAYER_ID
3239        // The assertion below is not valid for independent non-base layers
3240        if (vps->getNumAddLayerSets() == 0)
3241        {
3242#endif
3243        if( j > 0 && vps->getLayerSetLayerIdList(layerSetIdxForOutputLayerSet, j) != 0 && vps->getLayerSetLayerIdList(layerSetIdxForOutputLayerSet, j - 1) != 0 && vps->getNecessaryLayerFlag(i, j-1) )
3244        {
3245          assert(vps->getPTL(vps->getProfileLevelTierIdx(i, j))->getGeneralPTL()->getProfileIdc() == vps->getPTL(vps->getProfileLevelTierIdx(i, j - 1))->getGeneralPTL()->getProfileIdc() ||
3246                 vps->getPTL(vps->getProfileLevelTierIdx(i, j - 1))->getGeneralPTL()->getProfileCompatibilityFlag(vps->getPTL(vps->getProfileLevelTierIdx(i, j))->getGeneralPTL()->getProfileIdc()) || 
3247                 vps->getPTL(vps->getProfileLevelTierIdx(i, j))->getGeneralPTL()->getProfileCompatibilityFlag(vps->getPTL(vps->getProfileLevelTierIdx(i, j - 1))->getGeneralPTL()->getProfileIdc())  );
3248        }
3249#if R0235_SMALLEST_LAYER_ID
3250        }
3251#endif
3252#endif
3253      }
3254    }
3255#else
3256    Int numBits = 1;
3257    while ((1 << numBits) < (vps->getNumProfileTierLevel()))
3258    {
3259      numBits++;
3260    }
3261    READ_CODE( numBits, uiCode, "profile_tier_level_idx[i]" );     vps->setProfileLevelTierIdx(i, uiCode);
3262#endif
3263#if P0300_ALT_OUTPUT_LAYER_FLAG
3264    NumOutputLayersInOutputLayerSet[i] = 0;
3265    for (j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet); j++)
3266    {
3267      NumOutputLayersInOutputLayerSet[i] += vps->getOutputLayerFlag(i, j);
3268      if (vps->getOutputLayerFlag(i, j))
3269      {
3270        OlsHighestOutputLayerId[i] = vps->getLayerSetLayerIdList(layerSetIdxForOutputLayerSet, j);
3271      }
3272    }
3273    if (NumOutputLayersInOutputLayerSet[i] == 1 && vps->getNumDirectRefLayers(OlsHighestOutputLayerId[i]) > 0)
3274    {
3275      READ_FLAG(uiCode, "alt_output_layer_flag[i]");
3276      vps->setAltOuputLayerFlag(i, uiCode ? true : false);
3277    }
3278#if ALT_OPT_LAYER_FLAG
3279    else
3280    {
3281          uiCode=0;
3282          vps->setAltOuputLayerFlag(i, uiCode ? true : false);
3283    }
3284#endif
3285#if Q0165_OUTPUT_LAYER_SET
3286    assert( NumOutputLayersInOutputLayerSet[i]>0 );
3287#endif
3288
3289#endif
3290  }
3291#if NECESSARY_LAYER_FLAG
3292  vps->checkNecessaryLayerFlagCondition(); 
3293#endif
3294#else
3295  if( numOutputLayerSets > 1 )
3296  {
3297#if O0109_DEFAULT_ONE_OUT_LAYER_IDC
3298    READ_CODE( 2, uiCode, "default_one_target_output_layer_idc" );   vps->setDefaultOneTargetOutputLayerIdc( uiCode );
3299#else
3300    READ_FLAG( uiCode, "default_one_target_output_layer_flag" );   vps->setDefaultOneTargetOutputLayerFlag( uiCode ? true : false );
3301#endif
3302  }
3303  vps->setNumOutputLayerSets( numOutputLayerSets );
3304
3305  for(i = 1; i < numOutputLayerSets; i++)
3306  {
3307    if( i > (vps->getNumLayerSets() - 1) )
3308    {
3309      Int numBits = 1;
3310      while ((1 << numBits) < (vps->getNumLayerSets() - 1))
3311      {
3312        numBits++;
3313      }
3314      READ_CODE( numBits, uiCode, "output_layer_set_idx_minus1");   vps->setOutputLayerSetIdx( i, uiCode + 1);
3315      Int lsIdx = vps->getOutputLayerSetIdx(i);
3316#if NUM_OL_FLAGS
3317      for(j = 0; j < vps->getNumLayersInIdList(lsIdx) ; j++)
3318#else
3319      for(j = 0; j < vps->getNumLayersInIdList(lsIdx) - 1; j++)
3320#endif
3321      {
3322        READ_FLAG( uiCode, "output_layer_flag[i][j]"); vps->setOutputLayerFlag(i, j, uiCode);
3323      }
3324    }
3325    else
3326    {
3327#if VPS_DPB_SIZE_TABLE
3328      vps->setOutputLayerSetIdx( i, i );
3329#endif
3330      // i <= (vps->getNumLayerSets() - 1)
3331      // Assign OutputLayerFlag depending on default_one_target_output_layer_flag
3332      Int lsIdx = i;
3333#if O0109_DEFAULT_ONE_OUT_LAYER_IDC
3334      if( vps->getDefaultOneTargetOutputLayerIdc() == 1 )
3335      {
3336        for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++)
3337        {
3338#if O0135_DEFAULT_ONE_OUT_SEMANTIC
3339#if DEF_OPT_LAYER_IDC
3340        vps->setOutputLayerFlag(i, j, (j == (vps->getNumLayersInIdList(lsIdx)-1)) );
3341#else
3342          vps->setOutputLayerFlag(i, j, (j == (vps->getNumLayersInIdList(lsIdx)-1)) && (vps->getDimensionId(j,1)==0) );
3343#endif
3344#else
3345          vps->setOutputLayerFlag(i, j, (j == (vps->getNumLayersInIdList(lsIdx)-1)));
3346#endif
3347        }
3348      }
3349      else if ( vps->getDefaultOneTargetOutputLayerIdc() == 0 )
3350      {
3351        for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++)
3352        {
3353          vps->setOutputLayerFlag(i, j, 1);
3354        }
3355      }
3356      else
3357      {
3358        // Other values of default_one_target_output_layer_idc than 0 and 1 are reserved for future use.
3359      }
3360#else
3361      if( vps->getDefaultOneTargetOutputLayerFlag() )
3362      {
3363        for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++)
3364        {
3365          vps->setOutputLayerFlag(i, j, (j == (vps->getNumLayersInIdList(lsIdx)-1)));
3366        }
3367      }
3368      else
3369      {
3370        for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++)
3371        {
3372          vps->setOutputLayerFlag(i, j, 1);
3373        }
3374      }
3375#endif
3376    }
3377    Int numBits = 1;
3378    while ((1 << numBits) < (vps->getNumProfileTierLevel()))
3379    {
3380      numBits++;
3381    }
3382    READ_CODE( numBits, uiCode, "profile_level_tier_idx[i]" );     vps->setProfileLevelTierIdx(i, uiCode);
3383  }
3384#endif
3385
3386#if !P0300_ALT_OUTPUT_LAYER_FLAG
3387#if O0153_ALT_OUTPUT_LAYER_FLAG
3388  if( vps->getMaxLayers() > 1 )
3389  {
3390    READ_FLAG( uiCode, "alt_output_layer_flag");
3391    vps->setAltOuputLayerFlag( uiCode ? true : false );
3392  }
3393#endif
3394#endif
3395
3396#if REPN_FORMAT_IN_VPS
3397#if Q0195_REP_FORMAT_CLEANUP
3398  READ_UVLC( uiCode, "vps_num_rep_formats_minus1" );
3399  vps->setVpsNumRepFormats( uiCode + 1 );
3400
3401  // The value of vps_num_rep_formats_minus1 shall be in the range of 0 to 255, inclusive.
3402  assert( vps->getVpsNumRepFormats() > 0 && vps->getVpsNumRepFormats() <= 256 );
3403
3404  for(i = 0; i < vps->getVpsNumRepFormats(); i++)
3405  {
3406    // Read rep_format_structures
3407    parseRepFormat( vps->getVpsRepFormat(i), i > 0 ? vps->getVpsRepFormat(i-1) : 0 );
3408  }
3409
3410  // Default assignment for layer 0
3411  vps->setVpsRepFormatIdx( 0, 0 );
3412
3413  if( vps->getVpsNumRepFormats() > 1 )
3414  {
3415    READ_FLAG( uiCode, "rep_format_idx_present_flag");
3416    vps->setRepFormatIdxPresentFlag( uiCode ? true : false );
3417  }
3418  else
3419  {
3420    // When not present, the value of rep_format_idx_present_flag is inferred to be equal to 0
3421    vps->setRepFormatIdxPresentFlag( false );
3422  }
3423
3424  if( vps->getRepFormatIdxPresentFlag() )
3425  {
3426#if VPS_FIX_TO_MATCH_SPEC
3427    for( i = vps->getBaseLayerInternalFlag() ? 1 : 0; i < vps->getMaxLayers(); i++ )
3428#else
3429    for (i = 1; i < vps->getMaxLayers(); i++)
3430#endif
3431    {
3432      Int numBits = 1;
3433      while ((1 << numBits) < (vps->getVpsNumRepFormats()))
3434      {
3435        numBits++;
3436      }
3437      READ_CODE( numBits, uiCode, "vps_rep_format_idx[i]" );
3438      vps->setVpsRepFormatIdx( i, uiCode );
3439    }
3440  }
3441  else
3442  {
3443    // When not present, the value of vps_rep_format_idx[ i ] is inferred to be equal to Min (i, vps_num_rep_formats_minus1)
3444    for(i = 1; i < vps->getMaxLayers(); i++)
3445    {
3446      vps->setVpsRepFormatIdx( i, min( (Int)i, vps->getVpsNumRepFormats()-1 ) );
3447    }
3448  }
3449#else
3450  READ_FLAG( uiCode, "rep_format_idx_present_flag");
3451  vps->setRepFormatIdxPresentFlag( uiCode ? true : false );
3452
3453  if( vps->getRepFormatIdxPresentFlag() )
3454  {
3455#if O0096_REP_FORMAT_INDEX
3456#if !VPS_EXTN_UEV_CODING
3457    READ_CODE( 8, uiCode, "vps_num_rep_formats_minus1" );
3458#else
3459    READ_UVLC( uiCode, "vps_num_rep_formats_minus1" );
3460#endif
3461#else
3462    READ_CODE( 4, uiCode, "vps_num_rep_formats_minus1" );
3463#endif
3464    vps->setVpsNumRepFormats( uiCode + 1 );
3465  }
3466  else
3467  {
3468    // default assignment
3469    assert (vps->getMaxLayers() <= 16);       // If max_layers_is more than 15, num_rep_formats has to be signaled
3470    vps->setVpsNumRepFormats( vps->getMaxLayers() );
3471  }
3472
3473  // The value of vps_num_rep_formats_minus1 shall be in the range of 0 to 255, inclusive.
3474  assert( vps->getVpsNumRepFormats() > 0 && vps->getVpsNumRepFormats() <= 256 );
3475
3476  for(i = 0; i < vps->getVpsNumRepFormats(); i++)
3477  {
3478    // Read rep_format_structures
3479    parseRepFormat( vps->getVpsRepFormat(i), i > 0 ? vps->getVpsRepFormat(i-1) : 0 );
3480  }
3481
3482  // Default assignment for layer 0
3483  vps->setVpsRepFormatIdx( 0, 0 );
3484  if( vps->getRepFormatIdxPresentFlag() )
3485  {
3486    for(i = 1; i < vps->getMaxLayers(); i++)
3487    {
3488      if( vps->getVpsNumRepFormats() > 1 )
3489      {
3490#if O0096_REP_FORMAT_INDEX
3491#if !VPS_EXTN_UEV_CODING
3492        READ_CODE( 8, uiCode, "vps_rep_format_idx[i]" );
3493#else
3494        Int numBits = 1;
3495        while ((1 << numBits) < (vps->getVpsNumRepFormats()))
3496        {
3497          numBits++;
3498        }
3499        READ_CODE( numBits, uiCode, "vps_rep_format_idx[i]" );
3500#endif
3501#else
3502        READ_CODE( 4, uiCode, "vps_rep_format_idx[i]" );
3503#endif
3504        vps->setVpsRepFormatIdx( i, uiCode );
3505      }
3506      else
3507      {
3508        // default assignment - only one rep_format() structure
3509        vps->setVpsRepFormatIdx( i, 0 );
3510      }
3511    }
3512  }
3513  else
3514  {
3515    // default assignment - each layer assigned each rep_format() structure in the order signaled
3516    for(i = 1; i < vps->getMaxLayers(); i++)
3517    {
3518      vps->setVpsRepFormatIdx( i, i );
3519    }
3520  }
3521#endif
3522#endif
3523#if RESOLUTION_BASED_DPB
3524  vps->assignSubDpbIndices();
3525#endif
3526  READ_FLAG(uiCode, "max_one_active_ref_layer_flag" );
3527  vps->setMaxOneActiveRefLayerFlag(uiCode);
3528#if P0297_VPS_POC_LSB_ALIGNED_FLAG
3529  READ_FLAG(uiCode, "vps_poc_lsb_aligned_flag");
3530  vps->setVpsPocLsbAlignedFlag(uiCode);
3531#endif
3532#if O0062_POC_LSB_NOT_PRESENT_FLAG
3533  for(i = 1; i< vps->getMaxLayers(); i++)
3534  {
3535    if( vps->getNumDirectRefLayers( vps->getLayerIdInNuh(i) ) == 0  )
3536    {
3537      READ_FLAG(uiCode, "poc_lsb_not_present_flag[i]");
3538      vps->setPocLsbNotPresentFlag(i, uiCode);
3539    }
3540  }
3541#endif
3542#if O0215_PHASE_ALIGNMENT
3543  READ_FLAG( uiCode, "cross_layer_phase_alignment_flag"); vps->setPhaseAlignFlag( uiCode == 1 ? true : false );
3544#endif
3545
3546#if !IRAP_ALIGN_FLAG_IN_VPS_VUI
3547  READ_FLAG(uiCode, "cross_layer_irap_aligned_flag" );
3548  vps->setCrossLayerIrapAlignFlag(uiCode);
3549#endif
3550
3551#if VPS_DPB_SIZE_TABLE
3552  parseVpsDpbSizeTable(vps);
3553#endif
3554
3555#if VPS_EXTN_DIRECT_REF_LAYERS
3556  READ_UVLC( uiCode,           "direct_dep_type_len_minus2"); vps->setDirectDepTypeLen(uiCode+2);
3557#if O0096_DEFAULT_DEPENDENCY_TYPE
3558  READ_FLAG(uiCode, "default_direct_dependency_type_flag"); 
3559  vps->setDefaultDirectDependecyTypeFlag(uiCode == 1? true : false);
3560  if (vps->getDefaultDirectDependencyTypeFlag())
3561  {
3562    READ_CODE( vps->getDirectDepTypeLen(), uiCode, "default_direct_dependency_type" ); 
3563    vps->setDefaultDirectDependecyType(uiCode);
3564  }
3565#endif
3566
3567#if VPS_FIX_TO_MATCH_SPEC
3568  for( i = vps->getBaseLayerInternalFlag() ? 1 : 2; i < vps->getMaxLayers(); i++ )
3569#else
3570  for(i = 1; i < vps->getMaxLayers(); i++)
3571#endif
3572  {
3573#if VPS_FIX_TO_MATCH_SPEC
3574    for( j = vps->getBaseLayerInternalFlag() ? 0 : 1; j < i; j++ )
3575#else
3576    for(j = 0; j < i; j++)
3577#endif
3578    {
3579      if (vps->getDirectDependencyFlag(i, j))
3580      {
3581#if O0096_DEFAULT_DEPENDENCY_TYPE
3582        if (vps->getDefaultDirectDependencyTypeFlag())
3583        {
3584          vps->setDirectDependencyType(i, j, vps->getDefaultDirectDependencyType());
3585        }
3586        else
3587        {
3588          READ_CODE( vps->getDirectDepTypeLen(), uiCode, "direct_dependency_type[i][j]" ); 
3589          vps->setDirectDependencyType(i, j, uiCode);
3590        }
3591#else
3592        READ_CODE( vps->getDirectDepTypeLen(), uiCode, "direct_dependency_type[i][j]" ); 
3593        vps->setDirectDependencyType(i, j, uiCode);
3594#endif
3595      }
3596    }
3597  }
3598#endif
3599#if !Q0078_ADD_LAYER_SETS
3600#if O0092_0094_DEPENDENCY_CONSTRAINT // Moved up
3601  vps->setNumRefLayers();
3602
3603  if(vps->getMaxLayers() > MAX_REF_LAYERS)
3604  {
3605    for(i = 1;i < vps->getMaxLayers(); i++)
3606    {
3607      assert( vps->getNumRefLayers(vps->getLayerIdInNuh(i)) <= MAX_REF_LAYERS);
3608    }
3609  }
3610#endif
3611#endif
3612
3613#if P0307_VPS_NON_VUI_EXTENSION
3614  READ_UVLC( uiCode,           "vps_non_vui_extension_length"); vps->setVpsNonVuiExtLength((Int)uiCode);
3615
3616  // The value of vps_non_vui_extension_length shall be in the range of 0 to 4096, inclusive.
3617  assert( vps->getVpsNonVuiExtLength() >= 0 && vps->getVpsNonVuiExtLength() <= 4096 );
3618
3619#if P0307_VPS_NON_VUI_EXT_UPDATE
3620  Int nonVuiExtByte = uiCode;
3621  for (i = 1; i <= nonVuiExtByte; i++)
3622  {
3623    READ_CODE( 8, uiCode, "vps_non_vui_extension_data_byte" ); //just parse and discard for now.
3624  }
3625#else
3626  if ( vps->getVpsNonVuiExtLength() > 0 )
3627  {
3628    printf("\n\nUp to the current spec, the value of vps_non_vui_extension_length is supposed to be 0\n");
3629  }
3630#endif
3631#endif
3632
3633#if !O0109_O0199_FLAGS_TO_VUI
3634#if M0040_ADAPTIVE_RESOLUTION_CHANGE
3635  READ_FLAG(uiCode, "single_layer_for_non_irap_flag" ); vps->setSingleLayerForNonIrapFlag(uiCode == 1 ? true : false);
3636#endif
3637#if HIGHER_LAYER_IRAP_SKIP_FLAG
3638  READ_FLAG(uiCode, "higher_layer_irap_skip_flag" ); vps->setHigherLayerIrapSkipFlag(uiCode == 1 ? true : false);
3639#endif
3640#endif
3641
3642#if P0307_REMOVE_VPS_VUI_OFFSET
3643  READ_FLAG( uiCode, "vps_vui_present_flag"); vps->setVpsVuiPresentFlag(uiCode ? true : false);
3644#endif
3645
3646#if O0109_MOVE_VPS_VUI_FLAG
3647  if ( vps->getVpsVuiPresentFlag() )
3648#else
3649  READ_FLAG( uiCode,  "vps_vui_present_flag" );
3650  if (uiCode)
3651#endif
3652  {
3653    while ( m_pcBitstream->getNumBitsRead() % 8 != 0 )
3654    {
3655      READ_FLAG( uiCode, "vps_vui_alignment_bit_equal_to_one"); assert(uiCode == 1);
3656    }
3657    parseVPSVUI(vps);
3658  }
3659  else
3660  {
3661    // set default values for VPS VUI
3662    defaultVPSVUI( vps );
3663  }
3664}
3665
3666Void TDecCavlc::defaultVPSExtension( TComVPS* vps )
3667{
3668  // set default parameters when they are not present
3669  Int i, j;
3670
3671  // When layer_id_in_nuh[ i ] is not present, the value is inferred to be equal to i.
3672  for(i = 0; i < vps->getMaxLayers(); i++)
3673  {
3674    vps->setLayerIdInNuh(i, i);
3675    vps->setLayerIdInVps(vps->getLayerIdInNuh(i), i);
3676  }
3677
3678  // When not present, sub_layers_vps_max_minus1[ i ] is inferred to be equal to vps_max_sub_layers_minus1.
3679  for( i = 0; i < vps->getMaxLayers(); i++)
3680  {
3681    vps->setMaxTSLayersMinus1(i, vps->getMaxTLayers()-1);
3682  }
3683
3684  // When not present, max_tid_il_ref_pics_plus1[ i ][ j ] is inferred to be equal to 7.
3685  for( i = 0; i < vps->getMaxLayers() - 1; i++ )
3686  {
3687#if O0225_MAX_TID_FOR_REF_LAYERS
3688    for( j = i + 1; j < vps->getMaxLayers(); j++ )
3689    {
3690      vps->setMaxTidIlRefPicsPlus1(i, j, 7);
3691    }
3692#else
3693    vps->setMaxTidIlRefPicsPlus1(i, 7);
3694#endif
3695  }
3696
3697  // When not present, the value of num_add_olss is inferred to be equal to 0.
3698  // NumOutputLayerSets = num_add_olss + NumLayerSets
3699  vps->setNumOutputLayerSets( vps->getNumLayerSets() );
3700
3701  // For i in the range of 0 to NumOutputLayerSets-1, inclusive, the variable LayerSetIdxForOutputLayerSet[ i ] is derived as specified in the following:
3702  // LayerSetIdxForOutputLayerSet[ i ] = ( i <= vps_number_layer_sets_minus1 ) ? i : layer_set_idx_for_ols_minus1[ i ] + 1
3703  for( i = 1; i < vps->getNumOutputLayerSets(); i++ )
3704  {
3705    vps->setOutputLayerSetIdx( i, i );
3706    Int lsIdx = vps->getOutputLayerSetIdx(i);
3707
3708    for( j = 0; j < vps->getNumLayersInIdList(lsIdx); j++ )
3709    {
3710      vps->setOutputLayerFlag(i, j, 1);
3711    }
3712  }
3713
3714  // The value of sub_layer_dpb_info_present_flag[ i ][ 0 ] for any possible value of i is inferred to be equal to 1
3715  // When not present, the value of sub_layer_dpb_info_present_flag[ i ][ j ] for j greater than 0 and any possible value of i, is inferred to be equal to be equal to 0.
3716  for( i = 1; i < vps->getNumOutputLayerSets(); i++ )
3717  {
3718    vps->setSubLayerDpbInfoPresentFlag( i, 0, true );
3719  }
3720
3721  // When not present, the value of vps_num_rep_formats_minus1 is inferred to be equal to MaxLayersMinus1.
3722  vps->setVpsNumRepFormats( vps->getMaxLayers() );
3723
3724  // When not present, the value of rep_format_idx_present_flag is inferred to be equal to 0
3725  vps->setRepFormatIdxPresentFlag( false );
3726
3727  if( !vps->getRepFormatIdxPresentFlag() )
3728  {
3729    // When not present, the value of vps_rep_format_idx[ i ] is inferred to be equal to Min(i, vps_num_rep_formats_minus1).
3730    for(i = 1; i < vps->getMaxLayers(); i++)
3731    {
3732      vps->setVpsRepFormatIdx( i, min( (Int)i, vps->getVpsNumRepFormats() - 1 ) );
3733    }
3734  }
3735
3736#if P0297_VPS_POC_LSB_ALIGNED_FLAG
3737  vps->setVpsPocLsbAlignedFlag(false);
3738#endif
3739
3740#if O0062_POC_LSB_NOT_PRESENT_FLAG
3741  // When not present, poc_lsb_not_present_flag[ i ] is inferred to be equal to 0.
3742  for(i = 1; i< vps->getMaxLayers(); i++)
3743  {
3744    vps->setPocLsbNotPresentFlag(i, 0);
3745  }
3746#endif
3747
3748  // set default values for VPS VUI
3749  defaultVPSVUI( vps );
3750}
3751
3752Void TDecCavlc::defaultVPSVUI( TComVPS* vps )
3753{
3754  // When not present, the value of all_layers_idr_aligned_flag is inferred to be equal to 0.
3755  vps->setCrossLayerIrapAlignFlag( false );
3756
3757#if M0040_ADAPTIVE_RESOLUTION_CHANGE
3758  // When single_layer_for_non_irap_flag is not present, it is inferred to be equal to 0.
3759  vps->setSingleLayerForNonIrapFlag( false );
3760#endif
3761
3762#if HIGHER_LAYER_IRAP_SKIP_FLAG
3763  // When higher_layer_irap_skip_flag is not present it is inferred to be equal to 0
3764  vps->setHigherLayerIrapSkipFlag( false );
3765#endif
3766}
3767
3768#if REPN_FORMAT_IN_VPS
3769Void  TDecCavlc::parseRepFormat( RepFormat *repFormat, RepFormat *repFormatPrev )
3770{
3771  UInt uiCode;
3772#if REPN_FORMAT_CONTROL_FLAG 
3773  READ_CODE( 16, uiCode, "pic_width_vps_in_luma_samples" );        repFormat->setPicWidthVpsInLumaSamples ( uiCode );
3774  READ_CODE( 16, uiCode, "pic_height_vps_in_luma_samples" );       repFormat->setPicHeightVpsInLumaSamples( uiCode );
3775  READ_FLAG( uiCode, "chroma_and_bit_depth_vps_present_flag" );    repFormat->setChromaAndBitDepthVpsPresentFlag( uiCode ? true : false ); 
3776
3777  if( !repFormatPrev )
3778  {
3779    // The value of chroma_and_bit_depth_vps_present_flag of the first rep_format( ) syntax structure in the VPS shall be equal to 1
3780    assert( repFormat->getChromaAndBitDepthVpsPresentFlag() );
3781  }
3782
3783  if( repFormat->getChromaAndBitDepthVpsPresentFlag() )
3784  {
3785    READ_CODE( 2, uiCode, "chroma_format_vps_idc" );
3786#if AUXILIARY_PICTURES
3787    repFormat->setChromaFormatVpsIdc( ChromaFormat(uiCode) );
3788#else
3789    repFormat->setChromaFormatVpsIdc( uiCode );
3790#endif
3791
3792    if( repFormat->getChromaFormatVpsIdc() == 3 )
3793    {
3794      READ_FLAG( uiCode, "separate_colour_plane_vps_flag" );       repFormat->setSeparateColourPlaneVpsFlag( uiCode ? true : false );
3795    }
3796
3797    READ_CODE( 4, uiCode, "bit_depth_vps_luma_minus8" );           repFormat->setBitDepthVpsLuma  ( uiCode + 8 );
3798    READ_CODE( 4, uiCode, "bit_depth_vps_chroma_minus8" );         repFormat->setBitDepthVpsChroma( uiCode + 8 );
3799  }
3800  else if( repFormatPrev )
3801  {
3802    // chroma_and_bit_depth_vps_present_flag equal to 0 specifies that the syntax elements, chroma_format_vps_idc, separate_colour_plane_vps_flag, bit_depth_vps_luma_minus8, and
3803    // bit_depth_vps_chroma_minus8 are not present and inferred from the previous rep_format( ) syntax structure in the VPS.
3804
3805    repFormat->setChromaFormatVpsIdc        ( repFormatPrev->getChromaFormatVpsIdc() );
3806    repFormat->setSeparateColourPlaneVpsFlag( repFormatPrev->getSeparateColourPlaneVpsFlag() );
3807    repFormat->setBitDepthVpsLuma           ( repFormatPrev->getBitDepthVpsLuma() );
3808    repFormat->setBitDepthVpsChroma         ( repFormatPrev->getBitDepthVpsChroma() );
3809  }
3810
3811#else
3812#if AUXILIARY_PICTURES
3813  READ_CODE( 2, uiCode, "chroma_format_idc" );               repFormat->setChromaFormatVpsIdc( ChromaFormat(uiCode) );
3814#else
3815  READ_CODE( 2, uiCode, "chroma_format_idc" );               repFormat->setChromaFormatVpsIdc( uiCode );
3816#endif
3817
3818  if( repFormat->getChromaFormatVpsIdc() == 3 )
3819  {
3820    READ_FLAG( uiCode, "separate_colour_plane_flag");        repFormat->setSeparateColourPlaneVpsFlag(uiCode ? true : false);
3821  }
3822
3823  READ_CODE ( 16, uiCode, "pic_width_in_luma_samples" );     repFormat->setPicWidthVpsInLumaSamples ( uiCode );
3824  READ_CODE ( 16, uiCode, "pic_height_in_luma_samples" );    repFormat->setPicHeightVpsInLumaSamples( uiCode );
3825
3826  READ_CODE( 4, uiCode, "bit_depth_luma_minus8" );           repFormat->setBitDepthVpsLuma  ( uiCode + 8 );
3827  READ_CODE( 4, uiCode, "bit_depth_chroma_minus8" );         repFormat->setBitDepthVpsChroma( uiCode + 8 );
3828#endif
3829
3830#if R0156_CONF_WINDOW_IN_REP_FORMAT
3831  READ_FLAG( uiCode, "conformance_window_vps_flag" );
3832  if( uiCode != 0) 
3833  {
3834    Window &conf = repFormat->getConformanceWindowVps();
3835    READ_UVLC( uiCode, "conf_win_vps_left_offset" );         conf.setWindowLeftOffset  ( uiCode );
3836    READ_UVLC( uiCode, "conf_win_vps_right_offset" );        conf.setWindowRightOffset ( uiCode );
3837    READ_UVLC( uiCode, "conf_win_vps_top_offset" );          conf.setWindowTopOffset   ( uiCode );
3838    READ_UVLC( uiCode, "conf_win_vps_bottom_offset" );       conf.setWindowBottomOffset( uiCode );
3839  }
3840#endif
3841}
3842#endif
3843#if VPS_DPB_SIZE_TABLE
3844Void TDecCavlc::parseVpsDpbSizeTable( TComVPS *vps )
3845{
3846  UInt uiCode;
3847#if SUB_LAYERS_IN_LAYER_SET
3848  vps->calculateMaxSLInLayerSets();
3849#else
3850#if DPB_PARAMS_MAXTLAYERS
3851#if BITRATE_PICRATE_SIGNALLING
3852  Int * MaxSubLayersInLayerSetMinus1 = new Int[vps->getNumLayerSets()];
3853  for(Int i = 0; i < vps->getNumLayerSets(); i++)
3854#else
3855  Int * MaxSubLayersInLayerSetMinus1 = new Int[vps->getNumOutputLayerSets()];
3856  for(Int i = 1; i < vps->getNumOutputLayerSets(); i++)
3857#endif
3858  {
3859    UInt maxSLMinus1 = 0;
3860#if CHANGE_NUMSUBDPB_IDX
3861    Int optLsIdx = vps->getOutputLayerSetIdx( i );
3862#else
3863    Int optLsIdx = i;
3864#endif
3865#if BITRATE_PICRATE_SIGNALLING
3866    optLsIdx = i;
3867#endif
3868    for(Int k = 0; k < vps->getNumLayersInIdList(optLsIdx); k++ ) {
3869      Int  lId = vps->getLayerSetLayerIdList(optLsIdx, k);
3870      maxSLMinus1 = max(maxSLMinus1, vps->getMaxTSLayersMinus1(vps->getLayerIdInVps(lId)));
3871    }
3872    MaxSubLayersInLayerSetMinus1[ i ] = maxSLMinus1;
3873#if BITRATE_PICRATE_SIGNALLING
3874    vps->setMaxSLayersInLayerSetMinus1(i,MaxSubLayersInLayerSetMinus1[ i ]);
3875#endif
3876  }
3877#endif
3878#endif
3879
3880#if !RESOLUTION_BASED_DPB
3881  vps->deriveNumberOfSubDpbs();
3882#endif
3883  for(Int i = 1; i < vps->getNumOutputLayerSets(); i++)
3884  {
3885#if CHANGE_NUMSUBDPB_IDX
3886    Int layerSetIdxForOutputLayerSet = vps->getOutputLayerSetIdx( i );
3887#endif
3888    READ_FLAG( uiCode, "sub_layer_flag_info_present_flag[i]");  vps->setSubLayerFlagInfoPresentFlag( i, uiCode ? true : false );
3889#if SUB_LAYERS_IN_LAYER_SET
3890    for(Int j = 0; j <= vps->getMaxSLayersInLayerSetMinus1( layerSetIdxForOutputLayerSet ); j++)
3891#else
3892#if DPB_PARAMS_MAXTLAYERS
3893#if BITRATE_PICRATE_SIGNALLING
3894    for(Int j = 0; j <= MaxSubLayersInLayerSetMinus1[ vps->getOutputLayerSetIdx( i ) ]; j++)
3895#else
3896    for(Int j = 0; j <= MaxSubLayersInLayerSetMinus1[ i ]; j++)
3897#endif
3898#else
3899    for(Int j = 0; j <= vps->getMaxTLayers(); j++)
3900#endif
3901#endif
3902    {
3903      if( j > 0 && vps->getSubLayerFlagInfoPresentFlag(i) )
3904      {
3905        READ_FLAG( uiCode, "sub_layer_dpb_info_present_flag[i]");  vps->setSubLayerDpbInfoPresentFlag( i, j, uiCode ? true : false);
3906      }
3907      else
3908      {
3909        if( j == 0 )  // Always signal for the first sub-layer
3910        {
3911          vps->setSubLayerDpbInfoPresentFlag( i, j, true );
3912        }
3913        else // if (j != 0) && !vps->getSubLayerFlagInfoPresentFlag(i)
3914        {
3915          vps->setSubLayerDpbInfoPresentFlag( i, j, false );
3916        }
3917      }
3918      if( vps->getSubLayerDpbInfoPresentFlag(i, j) )  // If sub-layer DPB information is present
3919      {
3920#if CHANGE_NUMSUBDPB_IDX
3921        for(Int k = 0; k < vps->getNumSubDpbs(layerSetIdxForOutputLayerSet); k++)
3922#else
3923        for(Int k = 0; k < vps->getNumSubDpbs(i); k++)
3924#endif
3925        {
3926#if DPB_INTERNAL_BL_SIG
3927            uiCode=0;
3928
3929#if VPS_FIX_TO_MATCH_SPEC
3930        if( vps->getNecessaryLayerFlag(i, k) && ( vps->getBaseLayerInternalFlag() || vps->getLayerSetLayerIdList(layerSetIdxForOutputLayerSet, k) ) )
3931#else
3932        if(vps->getBaseLayerInternalFlag() || ( vps->getLayerSetLayerIdList(layerSetIdxForOutputLayerSet, k) !=  0 ) )
3933#endif
3934#endif
3935          READ_UVLC( uiCode, "max_vps_dec_pic_buffering_minus1[i][k][j]" ); vps->setMaxVpsDecPicBufferingMinus1( i, k, j, uiCode );
3936        }
3937        READ_UVLC( uiCode, "max_vps_num_reorder_pics[i][j]" );              vps->setMaxVpsNumReorderPics( i, j, uiCode);
3938#if RESOLUTION_BASED_DPB
3939        if( vps->getNumSubDpbs(layerSetIdxForOutputLayerSet) != vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ) ) 
3940        {
3941          for(Int k = 0; k < vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ); k++)
3942          {
3943            READ_UVLC( uiCode, "max_vps_layer_dec_pic_buff_minus1[i][k][j]" ); vps->setMaxVpsLayerDecPicBuffMinus1( i, k, j, uiCode);
3944          }
3945        }
3946        else  // vps->getNumSubDpbs(layerSetIdxForOutputLayerSet) == vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet )
3947        {         
3948          for(Int k = 0; k < vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ); k++)
3949          {
3950            vps->setMaxVpsLayerDecPicBuffMinus1( i, k, j, vps->getMaxVpsDecPicBufferingMinus1( i, k, j));
3951          }
3952        }
3953#endif
3954        READ_UVLC( uiCode, "max_vps_latency_increase_plus1[i][j]" );        vps->setMaxVpsLatencyIncreasePlus1( i, j, uiCode);
3955      }
3956    }
3957    for(Int j = vps->getMaxTLayers(); j < MAX_TLAYER; j++)
3958    {
3959      vps->setSubLayerDpbInfoPresentFlag( i, j, false );
3960    }
3961  }
3962
3963#if !SUB_LAYERS_IN_LAYER_SET
3964#if BITRATE_PICRATE_SIGNALLING
3965  if( MaxSubLayersInLayerSetMinus1 )
3966  {
3967    delete [] MaxSubLayersInLayerSetMinus1;
3968  }
3969#endif
3970#endif
3971
3972  // Infer values when not signalled
3973  for(Int i = 1; i < vps->getNumOutputLayerSets(); i++)
3974  {
3975    Int layerSetIdxForOutputLayerSet = vps->getOutputLayerSetIdx( i );
3976    for(Int j = 0; j < MAX_TLAYER; j++)
3977    {
3978      if( !vps->getSubLayerDpbInfoPresentFlag(i, j) )  // If sub-layer DPB information is NOT present
3979      {
3980#if RESOLUTION_BASED_DPB
3981        for(Int k = 0; k < vps->getNumSubDpbs(layerSetIdxForOutputLayerSet); k++)
3982#else
3983        for(Int k = 0; k < vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ); k++)
3984#endif
3985        {
3986          vps->setMaxVpsDecPicBufferingMinus1( i, k, j, vps->getMaxVpsDecPicBufferingMinus1( i, k, j - 1 ) );
3987        }
3988        vps->setMaxVpsNumReorderPics( i, j, vps->getMaxVpsNumReorderPics( i, j - 1) );
3989#if RESOLUTION_BASED_DPB
3990        for(Int k = 0; k < vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ); k++)
3991        {
3992          vps->setMaxVpsLayerDecPicBuffMinus1( i, k, j, vps->getMaxVpsLayerDecPicBuffMinus1( i, k, j - 1));
3993        }
3994#endif
3995        vps->setMaxVpsLatencyIncreasePlus1( i, j, vps->getMaxVpsLatencyIncreasePlus1( i, j - 1 ) );
3996      }
3997    }
3998  }
3999}
4000#endif
4001
4002Void TDecCavlc::parseVPSVUI(TComVPS *vps)
4003{
4004  UInt i,j;
4005  UInt uiCode;
4006#if O0223_PICTURE_TYPES_ALIGN_FLAG
4007  READ_FLAG(uiCode, "cross_layer_pic_type_aligned_flag" );
4008  vps->setCrossLayerPictureTypeAlignFlag(uiCode);
4009  if (!uiCode) 
4010  {
4011#endif
4012#if IRAP_ALIGN_FLAG_IN_VPS_VUI
4013    READ_FLAG(uiCode, "cross_layer_irap_aligned_flag" );
4014    vps->setCrossLayerIrapAlignFlag(uiCode);
4015#endif
4016#if O0223_PICTURE_TYPES_ALIGN_FLAG
4017  }
4018  else
4019  {
4020    vps->setCrossLayerIrapAlignFlag(true);
4021  }
4022#endif
4023#if P0068_CROSS_LAYER_ALIGNED_IDR_ONLY_FOR_IRAP_FLAG
4024  if( uiCode )
4025  {
4026    READ_FLAG( uiCode, "all_layers_idr_aligned_flag" );
4027    vps->setCrossLayerAlignedIdrOnlyFlag(uiCode);
4028  }
4029#endif
4030
4031  READ_FLAG( uiCode,        "bit_rate_present_vps_flag" );  vps->setBitRatePresentVpsFlag( uiCode ? true : false );
4032  READ_FLAG( uiCode,        "pic_rate_present_vps_flag" );  vps->setPicRatePresentVpsFlag( uiCode ? true : false );
4033
4034#if SIGNALLING_BITRATE_PICRATE_FIX
4035  if ( vps->getBitRatePresentVpsFlag() || vps->getPicRatePresentVpsFlag() )
4036  {
4037    for( i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getNumLayerSets(); i++ )
4038    {
4039      for( j = 0; j <= vps->getMaxSLayersInLayerSetMinus1( i ); j++ ) 
4040      {
4041        if( vps->getBitRatePresentVpsFlag() )
4042        {
4043          READ_FLAG( uiCode, "bit_rate_present_flag[i][j]" ); vps->setBitRatePresentFlag( i, j, uiCode ? true : false );           
4044        }
4045        if( vps->getPicRatePresentVpsFlag( )  )
4046        {
4047          READ_FLAG( uiCode, "pic_rate_present_flag[i][j]" ); vps->setPicRatePresentFlag( i, j, uiCode ? true : false );
4048        }
4049        if( vps->getBitRatePresentFlag( i, j ) )
4050        {
4051          READ_CODE( 16, uiCode, "avg_bit_rate" ); vps->setAvgBitRate( i, j, uiCode );
4052          READ_CODE( 16, uiCode, "max_bit_rate" ); vps->setMaxBitRate( i, j, uiCode );
4053        }
4054        else
4055        {
4056          vps->setAvgBitRate( i, j, 0 );
4057          vps->setMaxBitRate( i, j, 0 );
4058        }
4059        if( vps->getPicRatePresentFlag( i, j ) )
4060        {
4061          READ_CODE( 2,  uiCode, "constant_pic_rate_idc" ); vps->setConstPicRateIdc( i, j, uiCode );
4062          READ_CODE( 16, uiCode, "avg_pic_rate" );          vps->setAvgPicRate( i, j, uiCode );
4063        }
4064        else
4065        {
4066          vps->setConstPicRateIdc( i, j, 0 );
4067          vps->setAvgPicRate( i, j, 0 );
4068        }
4069      }
4070    }
4071  }
4072#else
4073  Bool parseFlag = vps->getBitRatePresentVpsFlag() || vps->getPicRatePresentVpsFlag();
4074
4075#if Q0078_ADD_LAYER_SETS
4076#if R0227_BR_PR_ADD_LAYER_SET
4077  for( i = 0; i < vps->getNumLayerSets(); i++ )
4078#else
4079  for( i = 0; i <= vps->getVpsNumLayerSetsMinus1(); i++ )
4080#endif
4081#else
4082  for( i = 0; i < vps->getNumLayerSets(); i++ )
4083#endif
4084  {
4085#if BITRATE_PICRATE_SIGNALLING
4086    for( j = 0; j <= vps->getMaxSLayersInLayerSetMinus1(i); j++ )
4087#else
4088    for( j = 0; j < vps->getMaxTLayers(); j++ )
4089#endif
4090    {
4091      if( parseFlag && vps->getBitRatePresentVpsFlag() )
4092      {
4093        READ_FLAG( uiCode,        "bit_rate_present_flag[i][j]" );  vps->setBitRatePresentFlag( i, j, uiCode ? true : false );
4094      }
4095      else
4096      {
4097        vps->setBitRatePresentFlag( i, j, false );
4098      }
4099      if( parseFlag && vps->getPicRatePresentVpsFlag() )
4100      {
4101        READ_FLAG( uiCode,        "pic_rate_present_flag[i][j]" );  vps->setPicRatePresentFlag( i, j, uiCode ? true : false );
4102      }
4103      else
4104      {
4105        vps->setPicRatePresentFlag( i, j, false );
4106      }
4107      if( parseFlag && vps->getBitRatePresentFlag(i, j) )
4108      {
4109        READ_CODE( 16, uiCode,    "avg_bit_rate[i][j]" ); vps->setAvgBitRate( i, j, uiCode );
4110        READ_CODE( 16, uiCode,    "max_bit_rate[i][j]" ); vps->setMaxBitRate( i, j, uiCode );
4111      }
4112      else
4113      {
4114        vps->setAvgBitRate( i, j, 0 );
4115        vps->setMaxBitRate( i, j, 0 );
4116      }
4117      if( parseFlag && vps->getPicRatePresentFlag(i, j) )
4118      {
4119        READ_CODE( 2 , uiCode,    "constant_pic_rate_idc[i][j]" ); vps->setConstPicRateIdc( i, j, uiCode );
4120        READ_CODE( 16, uiCode,    "avg_pic_rate[i][j]"          ); vps->setAvgPicRate( i, j, uiCode );
4121      }
4122      else
4123      {
4124        vps->setConstPicRateIdc( i, j, 0 );
4125        vps->setAvgPicRate     ( i, j, 0 );
4126      }
4127    }
4128  }
4129#endif
4130#if VPS_VUI_VIDEO_SIGNAL_MOVE
4131  READ_FLAG( uiCode, "video_signal_info_idx_present_flag" ); vps->setVideoSigPresentVpsFlag( uiCode == 1 );
4132  if (vps->getVideoSigPresentVpsFlag())
4133  {
4134    READ_CODE(4, uiCode, "vps_num_video_signal_info_minus1" ); vps->setNumVideoSignalInfo(uiCode + 1);
4135  }
4136  else
4137  {
4138#if VPS_VUI_VST_PARAMS
4139    vps->setNumVideoSignalInfo(vps->getMaxLayers() - vps->getBaseLayerInternalFlag() ? 0 : 1);
4140#else
4141    vps->setNumVideoSignalInfo(vps->getMaxLayers());
4142#endif
4143  }
4144
4145  for(i = 0; i < vps->getNumVideoSignalInfo(); i++)
4146  {
4147    READ_CODE(3, uiCode, "video_vps_format" ); vps->setVideoVPSFormat(i,uiCode);
4148    READ_FLAG(uiCode, "video_full_range_vps_flag" ); vps->setVideoFullRangeVpsFlag(i,uiCode);
4149    READ_CODE(8, uiCode, "color_primaries_vps" ); vps->setColorPrimaries(i,uiCode);
4150    READ_CODE(8, uiCode, "transfer_characteristics_vps" ); vps->setTransCharacter(i,uiCode);
4151    READ_CODE(8, uiCode, "matrix_coeffs_vps" );vps->setMaxtrixCoeff(i,uiCode);
4152  }
4153#if VPS_VUI_VST_PARAMS
4154  if( vps->getVideoSigPresentVpsFlag() && vps->getNumVideoSignalInfo() > 1 )
4155  {
4156    for(i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getMaxLayers(); i++)
4157    {
4158      READ_CODE(4, uiCode, "vps_video_signal_info_idx" ); vps->setVideoSignalInfoIdx(i, uiCode);
4159    }
4160  }
4161  else if ( !vps->getVideoSigPresentVpsFlag() )
4162  {
4163    for(i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getMaxLayers(); i++)
4164    {
4165      vps->setVideoSignalInfoIdx( i, i );
4166    }
4167  }
4168  else // ( vps->getNumVideoSignalInfo() = 0 )
4169  {
4170    for(i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getMaxLayers(); i++)
4171    {
4172      vps->setVideoSignalInfoIdx( i, 0 );
4173    }
4174  }
4175#else
4176  if(!vps->getVideoSigPresentVpsFlag())
4177  {
4178    for (i=0; i < vps->getMaxLayers(); i++)
4179    {
4180      vps->setVideoSignalInfoIdx(i,i);
4181    }
4182  }
4183  else {
4184    vps->setVideoSignalInfoIdx(0,0);
4185    if (vps->getNumVideoSignalInfo() > 1 )
4186    {
4187      for (i=1; i < vps->getMaxLayers(); i++)
4188        READ_CODE(4, uiCode, "vps_video_signal_info_idx" ); vps->setVideoSignalInfoIdx(i, uiCode);
4189    }
4190    else {
4191      for (i=1; i < vps->getMaxLayers(); i++)
4192      {
4193        vps->setVideoSignalInfoIdx(i,0);
4194      }
4195    }
4196  }
4197#endif
4198#endif
4199#if VPS_VUI_TILES_NOT_IN_USE__FLAG
4200  UInt layerIdx;
4201  READ_FLAG( uiCode, "tiles_not_in_use_flag" ); vps->setTilesNotInUseFlag(uiCode == 1);
4202  if (!uiCode)
4203  {
4204#if VPS_FIX_TO_MATCH_SPEC
4205    for( i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getMaxLayers(); i++ )
4206#else
4207    for (i = 0; i < vps->getMaxLayers(); i++)
4208#endif
4209    {
4210      READ_FLAG( uiCode, "tiles_in_use_flag[ i ]" ); vps->setTilesInUseFlag(i, (uiCode == 1));
4211      if (uiCode)
4212      {
4213        READ_FLAG( uiCode, "loop_filter_not_across_tiles_flag[ i ]" ); vps->setLoopFilterNotAcrossTilesFlag(i, (uiCode == 1));
4214      }
4215      else
4216      {
4217        vps->setLoopFilterNotAcrossTilesFlag(i, false);
4218      }
4219    }
4220#endif
4221
4222#if VPS_FIX_TO_MATCH_SPEC
4223      for( i = vps->getBaseLayerInternalFlag() ? 1 : 2; i < vps->getMaxLayers(); i++ )
4224#else
4225      for (i = 1; i < vps->getMaxLayers(); i++)
4226#endif
4227    {
4228      for(j = 0; j < vps->getNumDirectRefLayers(vps->getLayerIdInNuh(i)); j++)
4229      {
4230#if VPS_VUI_TILES_NOT_IN_USE__FLAG
4231        layerIdx = vps->getLayerIdInVps(vps->getRefLayerId(vps->getLayerIdInNuh(i), j));
4232        if (vps->getTilesInUseFlag(i) && vps->getTilesInUseFlag(layerIdx)) {
4233          READ_FLAG( uiCode, "tile_boundaries_aligned_flag[i][j]" ); vps->setTileBoundariesAlignedFlag(i,j,(uiCode == 1));
4234        }
4235#else
4236        READ_FLAG( uiCode, "tile_boundaries_aligned_flag[i][j]" ); vps->setTileBoundariesAlignedFlag(i,j,(uiCode == 1));
4237#endif
4238      }
4239    }
4240#if VPS_VUI_TILES_NOT_IN_USE__FLAG
4241  }
4242#endif
4243#if VPS_VUI_WPP_NOT_IN_USE__FLAG
4244  READ_FLAG( uiCode, "wpp_not_in_use_flag" ); vps->setWppNotInUseFlag(uiCode == 1);
4245  if (!uiCode)
4246  {
4247#if VPS_FIX_TO_MATCH_SPEC
4248      for (i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getMaxLayers(); i++)
4249#else
4250      for (i = 0; i < vps->getMaxLayers(); i++)
4251#endif
4252    {
4253      READ_FLAG( uiCode, "wpp_in_use_flag[ i ]" ); vps->setWppInUseFlag(i, (uiCode == 1));
4254    }
4255  }
4256#endif
4257
4258#if O0109_O0199_FLAGS_TO_VUI
4259#if M0040_ADAPTIVE_RESOLUTION_CHANGE
4260  READ_FLAG(uiCode, "single_layer_for_non_irap_flag" ); vps->setSingleLayerForNonIrapFlag(uiCode == 1 ? true : false);
4261#endif
4262#if HIGHER_LAYER_IRAP_SKIP_FLAG
4263  READ_FLAG(uiCode, "higher_layer_irap_skip_flag" ); vps->setHigherLayerIrapSkipFlag(uiCode == 1 ? true : false);
4264
4265  // When single_layer_for_non_irap_flag is equal to 0, higher_layer_irap_skip_flag shall be equal to 0
4266  if( !vps->getSingleLayerForNonIrapFlag() )
4267  {
4268    assert( !vps->getHigherLayerIrapSkipFlag() );
4269  }
4270#endif
4271#endif
4272#if P0312_VERT_PHASE_ADJ
4273  READ_FLAG( uiCode, "vps_vui_vert_phase_in_use_flag" ); vps->setVpsVuiVertPhaseInUseFlag(uiCode);
4274#endif
4275#if N0160_VUI_EXT_ILP_REF
4276  READ_FLAG( uiCode, "ilp_restricted_ref_layers_flag" ); vps->setIlpRestrictedRefLayersFlag( uiCode == 1 );
4277  if( vps->getIlpRestrictedRefLayersFlag())
4278  {
4279    for(i = 1; i < vps->getMaxLayers(); i++)
4280    {
4281      for(j = 0; j < vps->getNumDirectRefLayers(vps->getLayerIdInNuh(i)); j++)
4282      {
4283#if VPS_FIX_TO_MATCH_SPEC
4284        if( vps->getBaseLayerInternalFlag() || vps->getRefLayerId(vps->getLayerIdInNuh(i), j) )
4285        {
4286#endif
4287          READ_UVLC( uiCode, "min_spatial_segment_offset_plus1[i][j]" ); vps->setMinSpatialSegmentOffsetPlus1( i, j, uiCode );
4288          if( vps->getMinSpatialSegmentOffsetPlus1(i,j ) > 0 )
4289          {
4290            READ_FLAG( uiCode, "ctu_based_offset_enabled_flag[i][j]"); vps->setCtuBasedOffsetEnabledFlag(i, j, uiCode == 1 );
4291            if(vps->getCtuBasedOffsetEnabledFlag(i,j))
4292            {
4293              READ_UVLC( uiCode, "min_horizontal_ctu_offset_plus1[i][j]"); vps->setMinHorizontalCtuOffsetPlus1( i,j, uiCode );
4294            }
4295          }
4296#if VPS_FIX_TO_MATCH_SPEC
4297        }
4298#endif
4299      }
4300    }
4301  }
4302#endif
4303#if VPS_VUI_VIDEO_SIGNAL
4304#if VPS_VUI_VIDEO_SIGNAL_MOVE
4305#else
4306  READ_FLAG( uiCode, "video_signal_info_idx_present_flag" ); vps->setVideoSigPresentVpsFlag( uiCode == 1 );
4307  if (vps->getVideoSigPresentVpsFlag())
4308  {
4309    READ_CODE(4, uiCode, "vps_num_video_signal_info_minus1" ); vps->setNumVideoSignalInfo(uiCode + 1);
4310  }
4311  else
4312  {
4313    vps->setNumVideoSignalInfo(vps->getMaxLayers());
4314  }
4315
4316
4317  for(i = 0; i < vps->getNumVideoSignalInfo(); i++)
4318  {
4319    READ_CODE(3, uiCode, "video_vps_format" ); vps->setVideoVPSFormat(i,uiCode);
4320    READ_FLAG(uiCode, "video_full_range_vps_flag" ); vps->setVideoFullRangeVpsFlag(i,uiCode);
4321    READ_CODE(8, uiCode, "color_primaries_vps" ); vps->setColorPrimaries(i,uiCode);
4322    READ_CODE(8, uiCode, "transfer_characteristics_vps" ); vps->setTransCharacter(i,uiCode);
4323    READ_CODE(8, uiCode, "matrix_coeffs_vps" );vps->setMaxtrixCoeff(i,uiCode);
4324  }
4325  if(!vps->getVideoSigPresentVpsFlag())
4326  {
4327    for (i=0; i < vps->getMaxLayers(); i++)
4328    {
4329      vps->setVideoSignalInfoIdx(i,i);
4330    }
4331  }
4332  else {
4333    vps->setVideoSignalInfoIdx(0,0);
4334    if (vps->getNumVideoSignalInfo() > 1 )
4335    {
4336      for (i=1; i < vps->getMaxLayers(); i++)
4337        READ_CODE(4, uiCode, "vps_video_signal_info_idx" ); vps->setVideoSignalInfoIdx(i, uiCode);
4338    }
4339    else {
4340      for (i=1; i < vps->getMaxLayers(); i++)
4341      {
4342        vps->setVideoSignalInfoIdx(i,0);
4343      }
4344    }
4345  }
4346#endif
4347#endif
4348
4349#if O0164_MULTI_LAYER_HRD
4350  READ_FLAG(uiCode, "vps_vui_bsp_hrd_present_flag" ); vps->setVpsVuiBspHrdPresentFlag(uiCode);
4351  if (vps->getVpsVuiBspHrdPresentFlag())
4352  {
4353#if VPS_VUI_BSP_HRD_PARAMS
4354    parseVpsVuiBspHrdParams(vps);
4355#else
4356#if R0227_VUI_BSP_HRD_FLAG
4357    assert (vps->getTimingInfo()->getTimingInfoPresentFlag() == 1);
4358#endif
4359    READ_UVLC( uiCode, "vps_num_bsp_hrd_parameters_minus1" ); vps->setVpsNumBspHrdParametersMinus1(uiCode);
4360    vps->createBspHrdParamBuffer(vps->getVpsNumBspHrdParametersMinus1() + 1);
4361    for( i = 0; i <= vps->getVpsNumBspHrdParametersMinus1(); i++ )
4362    {
4363      if( i > 0 )
4364      {
4365        READ_FLAG( uiCode, "bsp_cprms_present_flag[i]" ); vps->setBspCprmsPresentFlag(i, uiCode);
4366      }
4367      parseHrdParameters(vps->getBspHrd(i), i==0 ? 1 : vps->getBspCprmsPresentFlag(i), vps->getMaxTLayers()-1);
4368    }
4369#if Q0078_ADD_LAYER_SETS
4370    for (UInt h = 1; h <= vps->getVpsNumLayerSetsMinus1(); h++)
4371#else
4372    for( UInt h = 1; h <= (vps->getNumLayerSets()-1); h++ )
4373#endif
4374    {
4375      READ_UVLC( uiCode, "num_bitstream_partitions[i]"); vps->setNumBitstreamPartitions(h, uiCode);
4376#if HRD_BPB
4377      Int chkPart=0;
4378#endif
4379      for( i = 0; i < vps->getNumBitstreamPartitions(h); i++ )
4380      {
4381        for( j = 0; j <= (vps->getMaxLayers()-1); j++ )
4382        {
4383          if( vps->getLayerIdIncludedFlag(h, j) )
4384          {
4385            READ_FLAG( uiCode, "layer_in_bsp_flag[h][i][j]" ); vps->setLayerInBspFlag(h, i, j, uiCode);
4386          }
4387        }
4388#if HRD_BPB
4389        chkPart+=vps->getLayerInBspFlag(h, i, j);
4390#endif
4391      }
4392#if HRD_BPB
4393      assert(chkPart<=1);
4394#endif
4395#if HRD_BPB
4396      if(vps->getNumBitstreamPartitions(h)==1)
4397      {
4398        Int chkPartition1=0; Int chkPartition2=0;
4399        for( j = 0; j <= (vps->getMaxLayers()-1); j++ )
4400        {
4401          if( vps->getLayerIdIncludedFlag(h, j) )
4402          {
4403            chkPartition1+=vps->getLayerInBspFlag(h, 0, j);
4404            chkPartition2++;
4405          }
4406        }
4407        assert(chkPartition1!=chkPartition2);
4408      }
4409#endif
4410      if (vps->getNumBitstreamPartitions(h))
4411      {
4412#if Q0182_MULTI_LAYER_HRD_UPDATE
4413        READ_UVLC( uiCode, "num_bsp_sched_combinations_minus1[h]"); vps->setNumBspSchedCombinations(h, uiCode + 1);
4414#else
4415        READ_UVLC( uiCode, "num_bsp_sched_combinations[h]"); vps->setNumBspSchedCombinations(h, uiCode);
4416#endif
4417        for( i = 0; i < vps->getNumBspSchedCombinations(h); i++ )
4418        {
4419          for( j = 0; j < vps->getNumBitstreamPartitions(h); j++ )
4420          {
4421            READ_UVLC( uiCode, "bsp_comb_hrd_idx[h][i][j]"); vps->setBspCombHrdIdx(h, i, j, uiCode);
4422#if HRD_BPB
4423            assert(uiCode <= vps->getVpsNumBspHrdParametersMinus1());
4424#endif
4425
4426            READ_UVLC( uiCode, "bsp_comb_sched_idx[h][i][j]"); vps->setBspCombSchedIdx(h, i, j, uiCode);
4427#if HRD_BPB
4428            assert(uiCode <= vps->getBspHrdParamBufferCpbCntMinus1(uiCode,vps->getMaxTLayers()-1));
4429#endif
4430          }
4431        }
4432      }
4433    }
4434#endif
4435  }
4436#endif
4437#if P0182_VPS_VUI_PS_FLAG
4438  for(i = 1; i < vps->getMaxLayers(); i++)
4439  {
4440    if (vps->getNumRefLayers(vps->getLayerIdInNuh(i)) == 0)
4441    {
4442      READ_FLAG( uiCode, "base_layer_parameter_set_compatibility_flag" ); 
4443      vps->setBaseLayerPSCompatibilityFlag( i, uiCode );
4444    }
4445    else
4446    {
4447      vps->setBaseLayerPSCompatibilityFlag( i, 0 );
4448    }
4449  }
4450#endif
4451}
4452
4453Void TDecCavlc::parseSPSExtension( TComSPS* pcSPS )
4454{
4455  UInt uiCode;
4456  // more syntax elements to be parsed here
4457
4458  READ_FLAG( uiCode, "inter_view_mv_vert_constraint_flag" );
4459  // Vertical MV component restriction is not used in SHVC CTC
4460  assert( uiCode == 0 );
4461
4462#if !MOVE_SCALED_OFFSET_TO_PPS
4463  if( pcSPS->getLayerId() > 0 )
4464  {
4465    Int iCode;
4466    READ_UVLC( uiCode,      "num_scaled_ref_layer_offsets" ); pcSPS->setNumScaledRefLayerOffsets(uiCode);
4467    for(Int i = 0; i < pcSPS->getNumScaledRefLayerOffsets(); i++)
4468    {
4469      Window& scaledWindow = pcSPS->getScaledRefLayerWindow(i);
4470#if O0098_SCALED_REF_LAYER_ID
4471      READ_CODE( 6,  uiCode,  "scaled_ref_layer_id" );       pcSPS->setScaledRefLayerId( i, uiCode );
4472#endif
4473      READ_SVLC( iCode, "scaled_ref_layer_left_offset" );    scaledWindow.setWindowLeftOffset  (iCode << 1);
4474      READ_SVLC( iCode, "scaled_ref_layer_top_offset" );     scaledWindow.setWindowTopOffset   (iCode << 1);
4475      READ_SVLC( iCode, "scaled_ref_layer_right_offset" );   scaledWindow.setWindowRightOffset (iCode << 1);
4476      READ_SVLC( iCode, "scaled_ref_layer_bottom_offset" );  scaledWindow.setWindowBottomOffset(iCode << 1);
4477#if P0312_VERT_PHASE_ADJ
4478      READ_FLAG( uiCode, "vert_phase_position_enable_flag" ); scaledWindow.setVertPhasePositionEnableFlag(uiCode);  pcSPS->setVertPhasePositionEnableFlag( pcSPS->getScaledRefLayerId(i), uiCode);   
4479#endif
4480    }
4481  }
4482#endif
4483}
4484#endif
4485
4486#if Q0048_CGS_3D_ASYMLUT
4487Void TDecCavlc::xParse3DAsymLUT( TCom3DAsymLUT * pc3DAsymLUT )
4488{
4489#if R0150_CGS_SIGNAL_CONSTRAINTS
4490  UInt uiNumRefLayersM1;
4491  READ_UVLC( uiNumRefLayersM1 , "num_cm_ref_layers_minus1" );
4492  assert( uiNumRefLayersM1 <= 61 );
4493  for( UInt i = 0 ; i <= uiNumRefLayersM1 ; i++ )
4494  {
4495    UInt uiRefLayerId;
4496    READ_CODE( 6 , uiRefLayerId , "cm_ref_layer_id" );
4497    pc3DAsymLUT->addRefLayerId( uiRefLayerId );
4498  }
4499#endif
4500  UInt uiCurOctantDepth , uiCurPartNumLog2 , uiInputBitDepthM8 , uiOutputBitDepthM8 , uiResQaunBit;
4501#if R0300_CGS_RES_COEFF_CODING
4502  UInt uiDeltaBits; 
4503#endif
4504  READ_CODE( 2 , uiCurOctantDepth , "cm_octant_depth" ); 
4505  READ_CODE( 2 , uiCurPartNumLog2 , "cm_y_part_num_log2" );     
4506#if R0150_CGS_SIGNAL_CONSTRAINTS
4507  UInt uiChromaInputBitDepthM8 , uiChromaOutputBitDepthM8;
4508  READ_UVLC( uiInputBitDepthM8 , "cm_input_luma_bit_depth_minus8" );
4509  READ_UVLC( uiChromaInputBitDepthM8 , "cm_input_chroma_bit_depth_minus8" );
4510  READ_UVLC( uiOutputBitDepthM8 , "cm_output_luma_bit_depth_minus8" );
4511  READ_UVLC( uiChromaOutputBitDepthM8 , "cm_output_chroma_bit_depth_minus8" );
4512#else
4513  READ_CODE( 3 , uiInputBitDepthM8 , "cm_input_bit_depth_minus8" );
4514  Int iInputBitDepthCDelta;
4515  READ_SVLC(iInputBitDepthCDelta, "cm_input_bit_depth_chroma delta");
4516  READ_CODE( 3 , uiOutputBitDepthM8 , "cm_output_bit_depth_minus8" ); 
4517  Int iOutputBitDepthCDelta;
4518  READ_SVLC(iOutputBitDepthCDelta, "cm_output_bit_depth_chroma_delta");
4519#endif
4520  READ_CODE( 2 , uiResQaunBit , "cm_res_quant_bit" );
4521#if R0300_CGS_RES_COEFF_CODING
4522  READ_CODE( 2 , uiDeltaBits , "cm_flc_bits" );
4523  pc3DAsymLUT->setDeltaBits(uiDeltaBits + 1);
4524#endif
4525
4526#if R0151_CGS_3D_ASYMLUT_IMPROVE
4527#if R0150_CGS_SIGNAL_CONSTRAINTS
4528  Int nAdaptCThresholdU = 1 << ( uiChromaInputBitDepthM8 + 8 - 1 );
4529  Int nAdaptCThresholdV = 1 << ( uiChromaInputBitDepthM8 + 8 - 1 );
4530#else
4531  Int nAdaptCThresholdU = 1 << ( uiInputBitDepthM8 + 8 + iInputBitDepthCDelta - 1 );
4532  Int nAdaptCThresholdV = 1 << ( uiInputBitDepthM8 + 8 + iInputBitDepthCDelta - 1 );
4533#endif
4534  if( uiCurOctantDepth == 1 )
4535  {
4536    Int delta = 0;
4537    READ_SVLC( delta , "cm_adapt_threshold_u_delta" );
4538    nAdaptCThresholdU += delta;
4539    READ_SVLC( delta , "cm_adapt_threshold_v_delta" );
4540    nAdaptCThresholdV += delta;
4541  }
4542#endif
4543  pc3DAsymLUT->destroy();
4544  pc3DAsymLUT->create( uiCurOctantDepth , uiInputBitDepthM8 + 8 , 
4545#if R0150_CGS_SIGNAL_CONSTRAINTS
4546    uiChromaInputBitDepthM8 + 8 ,
4547#else
4548    uiInputBitDepthM8 + 8 + iInputBitDepthCDelta, 
4549#endif
4550    uiOutputBitDepthM8 + 8 , 
4551#if R0150_CGS_SIGNAL_CONSTRAINTS
4552    uiChromaOutputBitDepthM8 + 8 ,
4553#else
4554    uiOutputBitDepthM8 + 8 + iOutputBitDepthCDelta ,
4555#endif
4556    uiCurPartNumLog2
4557#if R0151_CGS_3D_ASYMLUT_IMPROVE
4558    , nAdaptCThresholdU , nAdaptCThresholdV
4559#endif   
4560    );
4561  pc3DAsymLUT->setResQuantBit( uiResQaunBit );
4562
4563#if R0164_CGS_LUT_BUGFIX_CHECK
4564  pc3DAsymLUT->xInitCuboids();
4565#endif
4566  xParse3DAsymLUTOctant( pc3DAsymLUT , 0 , 0 , 0 , 0 , 1 << pc3DAsymLUT->getCurOctantDepth() );
4567#if R0164_CGS_LUT_BUGFIX
4568#if R0164_CGS_LUT_BUGFIX_CHECK
4569  printf("============= Before 'xCuboidsFilledCheck()': ================\n");
4570  pc3DAsymLUT->display();
4571  pc3DAsymLUT->xCuboidsFilledCheck( false );
4572  printf("============= After 'xCuboidsFilledCheck()': =================\n");
4573  pc3DAsymLUT->display();
4574#endif
4575#endif
4576}
4577
4578Void TDecCavlc::xParse3DAsymLUTOctant( TCom3DAsymLUT * pc3DAsymLUT , Int nDepth , Int yIdx , Int uIdx , Int vIdx , Int nLength )
4579{
4580  UInt uiOctantSplit = nDepth < pc3DAsymLUT->getCurOctantDepth();
4581  if( nDepth < pc3DAsymLUT->getCurOctantDepth() )
4582    READ_FLAG( uiOctantSplit , "split_octant_flag" );
4583  Int nYPartNum = 1 << pc3DAsymLUT->getCurYPartNumLog2();
4584  if( uiOctantSplit )
4585  {
4586    Int nHalfLength = nLength >> 1;
4587    for( Int l = 0 ; l < 2 ; l++ )
4588    {
4589      for( Int m = 0 ; m < 2 ; m++ )
4590      {
4591        for( Int n = 0 ; n < 2 ; n++ )
4592        {
4593          xParse3DAsymLUTOctant( pc3DAsymLUT , nDepth + 1 , yIdx + l * nHalfLength * nYPartNum , uIdx + m * nHalfLength , vIdx + n * nHalfLength , nHalfLength );
4594        }
4595      }
4596    }
4597  }
4598  else
4599  {
4600#if R0300_CGS_RES_COEFF_CODING
4601    Int nFLCbits = pc3DAsymLUT->getMappingShift()-pc3DAsymLUT->getResQuantBit()-pc3DAsymLUT->getDeltaBits() ; 
4602    nFLCbits = nFLCbits >= 0 ? nFLCbits:0;
4603#endif
4604    for( Int l = 0 ; l < nYPartNum ; l++ )
4605    {
4606#if R0164_CGS_LUT_BUGFIX
4607      Int shift = pc3DAsymLUT->getCurOctantDepth() - nDepth ;
4608#endif
4609      for( Int nVertexIdx = 0 ; nVertexIdx < 4 ; nVertexIdx++ )
4610      {
4611        UInt uiCodeVertex = 0;
4612        Int deltaY = 0 , deltaU = 0 , deltaV = 0;
4613        READ_FLAG( uiCodeVertex , "coded_vertex_flag" );
4614        if( uiCodeVertex )
4615        {
4616#if R0151_CGS_3D_ASYMLUT_IMPROVE
4617#if R0300_CGS_RES_COEFF_CODING
4618          xReadParam( deltaY, nFLCbits );
4619          xReadParam( deltaU, nFLCbits );
4620          xReadParam( deltaV, nFLCbits );
4621#else
4622          xReadParam( deltaY );
4623          xReadParam( deltaU );
4624          xReadParam( deltaV );
4625#endif
4626#else
4627          READ_SVLC( deltaY , "resY" );
4628          READ_SVLC( deltaU , "resU" );
4629          READ_SVLC( deltaV , "resV" );
4630#endif
4631        }
4632#if R0164_CGS_LUT_BUGFIX
4633        pc3DAsymLUT->setCuboidVertexResTree( yIdx + (l<<shift) , uIdx , vIdx , nVertexIdx , deltaY , deltaU , deltaV );
4634        for (Int m = 1; m < (1<<shift); m++) {
4635          pc3DAsymLUT->setCuboidVertexResTree( yIdx + (l<<shift) + m , uIdx , vIdx , nVertexIdx , 0 , 0 , 0 );
4636#if R0164_CGS_LUT_BUGFIX_CHECK
4637          pc3DAsymLUT->xSetFilled( yIdx + (l<<shift) + m , uIdx , vIdx );
4638#endif
4639        }
4640#else
4641        pc3DAsymLUT->setCuboidVertexResTree( yIdx + l , uIdx , vIdx , nVertexIdx , deltaY , deltaU , deltaV );
4642#endif
4643      }
4644#if R0164_CGS_LUT_BUGFIX_CHECK
4645      pc3DAsymLUT->xSetExplicit( yIdx + (l<<shift) , uIdx , vIdx );
4646#endif
4647    }
4648#if R0164_CGS_LUT_BUGFIX
4649    for ( Int u=0 ; u<nLength ; u++ ) {
4650      for ( Int v=0 ; v<nLength ; v++ ) {
4651        if ( u!=0 || v!=0 ) {
4652          for ( Int y=0 ; y<nLength*nYPartNum ; y++ ) {
4653            for( Int nVertexIdx = 0 ; nVertexIdx < 4 ; nVertexIdx++ )
4654            {
4655              pc3DAsymLUT->setCuboidVertexResTree( yIdx + y , uIdx + u , vIdx + v , nVertexIdx , 0 , 0 , 0 );
4656#if R0164_CGS_LUT_BUGFIX_CHECK
4657              pc3DAsymLUT->xSetFilled( yIdx + y , uIdx + u , vIdx + v );
4658#endif
4659            }
4660          }
4661        }
4662      }
4663    }
4664#endif
4665  }
4666}
4667
4668#if R0151_CGS_3D_ASYMLUT_IMPROVE
4669#if R0300_CGS_RES_COEFF_CODING
4670Void TDecCavlc::xReadParam( Int& param, Int rParam )
4671#else
4672Void TDecCavlc::xReadParam( Int& param )
4673#endif
4674{
4675#if !R0300_CGS_RES_COEFF_CODING
4676  const UInt rParam = 7;
4677#endif
4678  UInt prefix;
4679  UInt codeWord ;
4680  UInt rSymbol;
4681  UInt sign;
4682
4683  READ_UVLC( prefix, "quotient")  ;
4684  READ_CODE (rParam, codeWord, "remainder");
4685  rSymbol = (prefix<<rParam) + codeWord;
4686
4687  if(rSymbol)
4688  {
4689    READ_FLAG(sign, "sign");
4690    param = sign ? -(Int)(rSymbol) : (Int)(rSymbol);
4691  }
4692  else param = 0;
4693}
4694#endif
4695#if VPS_VUI_BSP_HRD_PARAMS
4696Void TDecCavlc::parseVpsVuiBspHrdParams( TComVPS *vps )
4697{
4698  UInt uiCode;
4699  assert (vps->getTimingInfo()->getTimingInfoPresentFlag() == 1);
4700  READ_UVLC( uiCode, "vps_num_add_hrd_params" ); vps->setVpsNumAddHrdParams(uiCode);
4701  vps->createBspHrdParamBuffer(vps->getVpsNumAddHrdParams()); // Also allocates m_cprmsAddPresentFlag and m_numSubLayerHrdMinus
4702
4703  for( Int i = vps->getNumHrdParameters(), j = 0; i < vps->getNumHrdParameters() + vps->getVpsNumAddHrdParams(); i++, j++ ) // j = i - vps->getNumHrdParameters()
4704  {
4705    if( i > 0 )
4706    {
4707      READ_FLAG( uiCode, "cprms_add_present_flag[i]" );   vps->setCprmsAddPresentFlag(j, uiCode ? true : false);
4708    }
4709    else
4710    {
4711      // i == 0
4712      if( vps->getNumHrdParameters() == 0 )
4713      {
4714        vps->setCprmsAddPresentFlag(0, true);
4715      }
4716    }
4717    READ_UVLC( uiCode, "num_sub_layer_hrd_minus1[i]" ); vps->setNumSubLayerHrdMinus1(j, uiCode );
4718    assert( uiCode <= vps->getMaxTLayers() - 1 );
4719   
4720    parseHrdParameters( vps->getBspHrd(j), vps->getCprmsAddPresentFlag(j), vps->getNumSubLayerHrdMinus1(j) );
4721    if( i > 0 && !vps->getCprmsAddPresentFlag(i) )
4722    {
4723      // Copy common information parameters
4724      if( i == vps->getNumHrdParameters() )
4725      {
4726        vps->getBspHrd(j)->copyCommonInformation( vps->getHrdParameters( vps->getNumHrdParameters() - 1 ) );
4727      }
4728      else
4729      {
4730        vps->getBspHrd(j)->copyCommonInformation( vps->getBspHrd( j - 1 ) );
4731      }
4732    }
4733  }
4734#if VPS_FIX_TO_MATCH_SPEC
4735  if( vps->getNumHrdParameters() + vps->getVpsNumAddHrdParams() > 0 )
4736  {
4737#endif
4738    for (Int h = 1; h < vps->getNumOutputLayerSets(); h++)
4739    {
4740      Int lsIdx = vps->getOutputLayerSetIdx(h);
4741      READ_UVLC(uiCode, "num_signalled_partitioning_schemes[h]"); vps->setNumSignalledPartitioningSchemes(h, uiCode);
4742#if VPS_FIX_TO_MATCH_SPEC
4743      for (Int j = 1; j < vps->getNumSignalledPartitioningSchemes(h) + 1; j++)
4744#else
4745      for (Int j = 0; j < vps->getNumSignalledPartitioningSchemes(h); j++)
4746#endif
4747      {
4748        READ_UVLC(uiCode, "num_partitions_in_scheme_minus1[h][j]"); vps->setNumPartitionsInSchemeMinus1(h, j, uiCode);
4749        for (Int k = 0; k <= vps->getNumPartitionsInSchemeMinus1(h, j); k++)
4750        {
4751          for (Int r = 0; r < vps->getNumLayersInIdList(lsIdx); r++)
4752          {
4753            READ_FLAG(uiCode, "layer_included_in_partition_flag[h][j][k][r]"); vps->setLayerIncludedInPartitionFlag(h, j, k, r, uiCode ? true : false);
4754          }
4755        }
4756      }
4757      for (Int i = 0; i < vps->getNumSignalledPartitioningSchemes(h) + 1; i++)
4758      {
4759        for (Int t = 0; t <= vps->getMaxSLayersInLayerSetMinus1(lsIdx); t++)
4760        {
4761          READ_UVLC(uiCode, "num_bsp_schedules_minus1[h][i][t]");              vps->setNumBspSchedulesMinus1(h, i, t, uiCode);
4762          for (Int j = 0; j <= vps->getNumBspSchedulesMinus1(h, i, t); j++)
4763          {
4764#if VPS_FIX_TO_MATCH_SPEC
4765            for( Int k = 0; k <= vps->getNumPartitionsInSchemeMinus1(h, i); k++ )
4766#else
4767            for (Int k = 0; k < vps->getNumPartitionsInSchemeMinus1(h, i); k++)
4768#endif
4769            {
4770#if VPS_FIX_TO_MATCH_SPEC
4771              if( vps->getNumHrdParameters() + vps->getVpsNumAddHrdParams() > 1 )
4772              {
4773                Int numBits = 1;
4774                while ((1 << numBits) < (vps->getNumHrdParameters() + vps->getVpsNumAddHrdParams()))
4775                {
4776                  numBits++;
4777                }
4778                READ_CODE(numBits, uiCode, "bsp_comb_hrd_idx[h][i][t][j][k]");      vps->setBspHrdIdx(h, i, t, j, k, uiCode);
4779              }
4780#else
4781              READ_UVLC(uiCode, "bsp_comb_hrd_idx[h][i][t][j][k]");      vps->setBspHrdIdx(h, i, t, j, k, uiCode);
4782#endif
4783              READ_UVLC(uiCode, "bsp_comb_sched_idx[h][i][t][j][k]");    vps->setBspSchedIdx(h, i, t, j, k, uiCode);
4784            }
4785          }
4786        }
4787      }
4788
4789      // To be done: Check each layer included in not more than one BSP in every partitioning scheme,
4790      // and other related checks associated with layers in bitstream partitions.
4791
4792    }
4793#if VPS_FIX_TO_MATCH_SPEC
4794  }
4795#endif
4796}
4797#endif
4798#endif
4799//! \}
4800
Note: See TracBrowser for help on using the repository browser.