source: 3DVCSoftware/trunk/source/Lib/TLibDecoder/TDecCAVLC.cpp @ 1196

Last change on this file since 1196 was 1196, checked in by tech, 9 years ago

Merged 14.0-dev0@1187.

  • Property svn:eol-style set to native
File size: 123.7 KB
Line 
1/* The copyright in this software is being made available under the BSD
2* License, included below. This software may be subject to other third party
3* and contributor rights, including patent rights, and no such rights are
4* granted under this license. 
5*
6* Copyright (c) 2010-2015, ITU/ISO/IEC
7* All rights reserved.
8*
9* Redistribution and use in source and binary forms, with or without
10* modification, are permitted provided that the following conditions are met:
11*
12*  * Redistributions of source code must retain the above copyright notice,
13*    this list of conditions and the following disclaimer.
14*  * Redistributions in binary form must reproduce the above copyright notice,
15*    this list of conditions and the following disclaimer in the documentation
16*    and/or other materials provided with the distribution.
17*  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18*    be used to endorse or promote products derived from this software without
19*    specific prior written permission.
20*
21* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31* THE POSSIBILITY OF SUCH DAMAGE.
32*/
33
34/** \file     TDecCAVLC.cpp
35\brief    CAVLC decoder class
36*/
37
38#include "TDecCAVLC.h"
39#include "SEIread.h"
40#include "TDecSlice.h"
41#if H_3D
42#include "TDecTop.h"
43#endif
44//! \ingroup TLibDecoder
45//! \{
46
47#if ENC_DEC_TRACE
48
49Void  xTraceSPSHeader (TComSPS *pSPS)
50{
51#if H_MV_ENC_DEC_TRAC
52  if ( g_disableHLSTrace )
53  {
54    return; 
55  }
56  // To avoid mismatches
57  fprintf( g_hTrace, "=========== Sequence Parameter Set LayerId: %d ===========\n", pSPS->getLayerId() );
58#else
59  fprintf( g_hTrace, "=========== Sequence Parameter Set ID: %d ===========\n", pSPS->getSPSId() );
60#endif
61}
62
63Void  xTracePPSHeader (TComPPS *pPPS)
64{
65#if H_MV_ENC_DEC_TRAC
66  if ( g_disableHLSTrace )
67  {
68    return; 
69  }
70  fprintf( g_hTrace, "=========== Picture Parameter Set LayerId: %d ===========\n", pPPS->getLayerId() );
71#else
72  fprintf( g_hTrace, "=========== Picture Parameter Set ID: %d ===========\n", pPPS->getPPSId() );
73#endif
74}
75
76Void  xTraceSliceHeader (TComSlice *pSlice)
77{
78#if H_MV_ENC_DEC_TRAC
79  if ( g_disableHLSTrace )
80  {
81    return; 
82  }
83#endif
84  fprintf( g_hTrace, "=========== Slice ===========\n");
85}
86
87#endif
88
89// ====================================================================================================================
90// Constructor / destructor / create / destroy
91// ====================================================================================================================
92
93TDecCavlc::TDecCavlc()
94{
95}
96
97TDecCavlc::~TDecCavlc()
98{
99}
100
101// ====================================================================================================================
102// Public member functions
103// ====================================================================================================================
104
105void TDecCavlc::parseShortTermRefPicSet( TComSPS* sps, TComReferencePictureSet* rps, Int idx )
106{
107  UInt code;
108  UInt interRPSPred;
109  if (idx > 0)
110  {
111    READ_FLAG(interRPSPred, "inter_ref_pic_set_prediction_flag");  rps->setInterRPSPrediction(interRPSPred);
112  }
113  else
114  {
115    interRPSPred = false;
116    rps->setInterRPSPrediction(false);
117  }
118
119  if (interRPSPred) 
120  {
121    UInt bit;
122    if(idx == sps->getRPSList()->getNumberOfReferencePictureSets())
123    {
124      READ_UVLC(code, "delta_idx_minus1" ); // delta index of the Reference Picture Set used for prediction minus 1
125    }
126    else
127    {
128      code = 0;
129    }
130    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
131    Int rIdx =  idx - 1 - code;
132    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
133    TComReferencePictureSet*   rpsRef = sps->getRPSList()->getReferencePictureSet(rIdx);
134    Int k = 0, k0 = 0, k1 = 0;
135    READ_CODE(1, bit, "delta_rps_sign"); // delta_RPS_sign
136    READ_UVLC(code, "abs_delta_rps_minus1");  // absolute delta RPS minus 1
137    Int deltaRPS = (1 - 2 * bit) * (code + 1); // delta_RPS
138    for(Int j=0 ; j <= rpsRef->getNumberOfPictures(); j++)
139    {
140      READ_CODE(1, bit, "used_by_curr_pic_flag" ); //first bit is "1" if Idc is 1
141      Int refIdc = bit;
142      if (refIdc == 0) 
143      {
144        READ_CODE(1, bit, "use_delta_flag" ); //second bit is "1" if Idc is 2, "0" otherwise.
145        refIdc = bit<<1; //second bit is "1" if refIdc is 2, "0" if refIdc = 0.
146      }
147      if (refIdc == 1 || refIdc == 2)
148      {
149        Int deltaPOC = deltaRPS + ((j < rpsRef->getNumberOfPictures())? rpsRef->getDeltaPOC(j) : 0);
150        rps->setDeltaPOC(k, deltaPOC);
151        rps->setUsed(k, (refIdc == 1));
152
153        if (deltaPOC < 0)
154        {
155          k0++;
156        }
157        else 
158        {
159          k1++;
160        }
161        k++;
162      } 
163      rps->setRefIdc(j,refIdc); 
164    }
165    rps->setNumRefIdc(rpsRef->getNumberOfPictures()+1); 
166    rps->setNumberOfPictures(k);
167    rps->setNumberOfNegativePictures(k0);
168    rps->setNumberOfPositivePictures(k1);
169    rps->sortDeltaPOC();
170  }
171  else
172  {
173    READ_UVLC(code, "num_negative_pics");           rps->setNumberOfNegativePictures(code);
174    READ_UVLC(code, "num_positive_pics");           rps->setNumberOfPositivePictures(code);
175    Int prev = 0;
176    Int poc;
177    for(Int j=0 ; j < rps->getNumberOfNegativePictures(); j++)
178    {
179      READ_UVLC(code, "delta_poc_s0_minus1");
180      poc = prev-code-1;
181      prev = poc;
182      rps->setDeltaPOC(j,poc);
183      READ_FLAG(code, "used_by_curr_pic_s0_flag");  rps->setUsed(j,code);
184    }
185    prev = 0;
186    for(Int j=rps->getNumberOfNegativePictures(); j < rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures(); j++)
187    {
188      READ_UVLC(code, "delta_poc_s1_minus1");
189      poc = prev+code+1;
190      prev = poc;
191      rps->setDeltaPOC(j,poc);
192      READ_FLAG(code, "used_by_curr_pic_s1_flag");  rps->setUsed(j,code);
193    }
194    rps->setNumberOfPictures(rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures());
195  }
196#if PRINT_RPS_INFO
197  rps->printDeltaPOC();
198#endif
199}
200
201#if H_3D
202Void TDecCavlc::parsePPS(TComPPS* pcPPS, TComVPS* pcVPS )
203#else
204Void TDecCavlc::parsePPS(TComPPS* pcPPS)
205#endif
206{
207#if ENC_DEC_TRACE 
208  xTracePPSHeader (pcPPS);
209#endif
210  UInt  uiCode;
211
212  Int   iCode;
213
214  READ_UVLC( uiCode, "pps_pic_parameter_set_id");
215  assert(uiCode <= 63);
216  pcPPS->setPPSId (uiCode);
217 
218  READ_UVLC( uiCode, "pps_seq_parameter_set_id");
219  assert(uiCode <= 15);
220  pcPPS->setSPSId (uiCode);
221 
222  READ_FLAG( uiCode, "dependent_slice_segments_enabled_flag"    );    pcPPS->setDependentSliceSegmentsEnabledFlag   ( uiCode == 1 );
223  READ_FLAG( uiCode, "output_flag_present_flag" );                    pcPPS->setOutputFlagPresentFlag( uiCode==1 );
224
225  READ_CODE(3, uiCode, "num_extra_slice_header_bits");                pcPPS->setNumExtraSliceHeaderBits(uiCode);
226  READ_FLAG ( uiCode, "sign_data_hiding_flag" ); pcPPS->setSignHideFlag( uiCode );
227
228  READ_FLAG( uiCode,   "cabac_init_present_flag" );            pcPPS->setCabacInitPresentFlag( uiCode ? true : false );
229
230  READ_UVLC(uiCode, "num_ref_idx_l0_default_active_minus1");
231  assert(uiCode <= 14);
232  pcPPS->setNumRefIdxL0DefaultActive(uiCode+1);
233 
234  READ_UVLC(uiCode, "num_ref_idx_l1_default_active_minus1");
235  assert(uiCode <= 14);
236  pcPPS->setNumRefIdxL1DefaultActive(uiCode+1);
237 
238  READ_SVLC(iCode, "init_qp_minus26" );                            pcPPS->setPicInitQPMinus26(iCode);
239  READ_FLAG( uiCode, "constrained_intra_pred_flag" );              pcPPS->setConstrainedIntraPred( uiCode ? true : false );
240  READ_FLAG( uiCode, "transform_skip_enabled_flag" );               
241  pcPPS->setUseTransformSkip ( uiCode ? true : false ); 
242
243  READ_FLAG( uiCode, "cu_qp_delta_enabled_flag" );            pcPPS->setUseDQP( uiCode ? true : false );
244  if( pcPPS->getUseDQP() )
245  {
246    READ_UVLC( uiCode, "diff_cu_qp_delta_depth" );
247    pcPPS->setMaxCuDQPDepth( uiCode );
248  }
249  else
250  {
251    pcPPS->setMaxCuDQPDepth( 0 );
252  }
253  READ_SVLC( iCode, "pps_cb_qp_offset");
254  pcPPS->setChromaCbQpOffset(iCode);
255  assert( pcPPS->getChromaCbQpOffset() >= -12 );
256  assert( pcPPS->getChromaCbQpOffset() <=  12 );
257
258  READ_SVLC( iCode, "pps_cr_qp_offset");
259  pcPPS->setChromaCrQpOffset(iCode);
260  assert( pcPPS->getChromaCrQpOffset() >= -12 );
261  assert( pcPPS->getChromaCrQpOffset() <=  12 );
262
263  READ_FLAG( uiCode, "pps_slice_chroma_qp_offsets_present_flag" );
264  pcPPS->setSliceChromaQpFlag( uiCode ? true : false );
265
266  READ_FLAG( uiCode, "weighted_pred_flag" );          // Use of Weighting Prediction (P_SLICE)
267  pcPPS->setUseWP( uiCode==1 );
268  READ_FLAG( uiCode, "weighted_bipred_flag" );         // Use of Bi-Directional Weighting Prediction (B_SLICE)
269  pcPPS->setWPBiPred( uiCode==1 );
270
271  READ_FLAG( uiCode, "transquant_bypass_enable_flag");
272  pcPPS->setTransquantBypassEnableFlag(uiCode ? true : false);
273  READ_FLAG( uiCode, "tiles_enabled_flag"               );    pcPPS->setTilesEnabledFlag            ( uiCode == 1 );
274  READ_FLAG( uiCode, "entropy_coding_sync_enabled_flag" );    pcPPS->setEntropyCodingSyncEnabledFlag( uiCode == 1 );
275 
276  if( pcPPS->getTilesEnabledFlag() )
277  {
278    READ_UVLC ( uiCode, "num_tile_columns_minus1" );                pcPPS->setNumTileColumnsMinus1( uiCode ); 
279    READ_UVLC ( uiCode, "num_tile_rows_minus1" );                   pcPPS->setNumTileRowsMinus1( uiCode ); 
280    READ_FLAG ( uiCode, "uniform_spacing_flag" );                   pcPPS->setTileUniformSpacingFlag( uiCode == 1 );
281
282    if( !pcPPS->getTileUniformSpacingFlag())
283    {
284      std::vector<Int> columnWidth(pcPPS->getNumTileColumnsMinus1());
285      for(UInt i=0; i<pcPPS->getNumTileColumnsMinus1(); i++)
286      { 
287        READ_UVLC( uiCode, "column_width_minus1" ); 
288        columnWidth[i] = uiCode+1;
289      }
290      pcPPS->setTileColumnWidth(columnWidth);
291
292      std::vector<Int> rowHeight (pcPPS->getTileNumRowsMinus1());
293      for(UInt i=0; i<pcPPS->getTileNumRowsMinus1(); i++)
294      {
295        READ_UVLC( uiCode, "row_height_minus1" );
296        rowHeight[i] = uiCode + 1;
297      }
298      pcPPS->setTileRowHeight(rowHeight);
299    }
300
301    if(pcPPS->getNumTileColumnsMinus1() !=0 || pcPPS->getTileNumRowsMinus1() !=0)
302    {
303      READ_FLAG ( uiCode, "loop_filter_across_tiles_enabled_flag" );   pcPPS->setLoopFilterAcrossTilesEnabledFlag( uiCode ? true : false );
304    }
305  }
306  READ_FLAG( uiCode, "loop_filter_across_slices_enabled_flag" );       pcPPS->setLoopFilterAcrossSlicesEnabledFlag( uiCode ? true : false );
307  READ_FLAG( uiCode, "deblocking_filter_control_present_flag" );       pcPPS->setDeblockingFilterControlPresentFlag( uiCode ? true : false );
308  if(pcPPS->getDeblockingFilterControlPresentFlag())
309  {
310    READ_FLAG( uiCode, "deblocking_filter_override_enabled_flag" );    pcPPS->setDeblockingFilterOverrideEnabledFlag( uiCode ? true : false );
311    READ_FLAG( uiCode, "pps_disable_deblocking_filter_flag" );         pcPPS->setPicDisableDeblockingFilterFlag(uiCode ? true : false );
312    if(!pcPPS->getPicDisableDeblockingFilterFlag())
313    {
314      READ_SVLC ( iCode, "pps_beta_offset_div2" );                     pcPPS->setDeblockingFilterBetaOffsetDiv2( iCode );
315      READ_SVLC ( iCode, "pps_tc_offset_div2" );                       pcPPS->setDeblockingFilterTcOffsetDiv2( iCode );
316    }
317  }
318  READ_FLAG( uiCode, "pps_scaling_list_data_present_flag" );           pcPPS->setScalingListPresentFlag( uiCode ? true : false );
319  if(pcPPS->getScalingListPresentFlag ())
320  {
321    parseScalingList( pcPPS->getScalingList() );
322  }
323  READ_FLAG( uiCode, "lists_modification_present_flag");
324  pcPPS->setListsModificationPresentFlag(uiCode);
325
326  READ_UVLC( uiCode, "log2_parallel_merge_level_minus2");
327  pcPPS->setLog2ParallelMergeLevelMinus2 (uiCode);
328
329  READ_FLAG( uiCode, "slice_segment_header_extension_present_flag");
330  pcPPS->setSliceHeaderExtensionPresentFlag(uiCode);
331 
332#if H_MV
333  READ_FLAG( uiCode, "pps_extension_present_flag");
334#else
335  READ_FLAG( uiCode, "pps_extension_flag");
336#endif
337  if (uiCode)
338  {
339
340#if H_MV
341    READ_FLAG( uiCode, "pps_range_extensions_flag" ); pcPPS->setPpsRangeExtensionsFlag( uiCode == 1 );
342    READ_FLAG( uiCode, "pps_multilayer_extension_flag" ); pcPPS->setPpsMultilayerExtensionFlag( uiCode == 1 );
343#if !H_3D
344    READ_CODE( 6, uiCode, "pps_extension_6bits" ); pcPPS->setPpsExtension6bits( uiCode );
345#else
346    READ_FLAG( uiCode, "pps_3d_extension_flag" ); pcPPS->setPps3dExtensionFlag( uiCode == 1 );
347    READ_CODE( 5, uiCode, "pps_extension_5bits" ); pcPPS->setPpsExtension5bits( uiCode );
348#endif
349    if ( pcPPS->getPpsRangeExtensionsFlag() )
350    { 
351      assert(0); 
352    }
353
354    if ( pcPPS->getPpsMultilayerExtensionFlag() )
355    { 
356      parsePPSMultilayerExtension( pcPPS ); 
357    }
358#if !H_3D
359    if ( pcPPS->getPpsExtension6bits() )
360    {
361#else
362    if ( pcPPS->getPps3dExtensionFlag() )
363    { 
364      parsePPSExtension( pcPPS, pcVPS );
365    }
366    if ( pcPPS->getPpsExtension5bits() )
367    {
368#endif
369
370#endif
371
372      while ( xMoreRbspData() )
373      {
374        READ_FLAG( uiCode, "pps_extension_data_flag");
375      }
376#if H_MV
377    }
378#endif
379  }
380}
381
382
383#if H_3D
384Void TDecCavlc::parsePPSExtension( TComPPS* pcPPS, TComVPS* pcVPS )
385{
386  //Ed.(GT): pcVPS should not be used here. Needs to be fixed.
387  UInt uiCode = 0; 
388  TComDLT* pcDLT = new TComDLT;
389
390  READ_FLAG(uiCode, "dlt_present_flag");
391  pcDLT->setDltPresentFlag( (uiCode == 1) ? true : false );
392
393  if ( pcDLT->getDltPresentFlag() )
394  {
395    READ_CODE(6, uiCode, "pps_depth_layers_minus1");
396    pcDLT->setNumDepthViews( uiCode );
397
398    READ_CODE(4, uiCode, "pps_bit_depth_for_depth_views_minus8");
399    pcDLT->setDepthViewBitDepth( (uiCode+8) );
400
401    for( Int i = 0; i <= pcVPS->getMaxLayersMinus1(); i++ )
402    {
403      if ( i != 0 )
404      {
405        if( pcVPS->getDepthId( i ) == 1 ) 
406        {
407          READ_FLAG(uiCode, "dlt_flag[i]");
408          pcDLT->setUseDLTFlag(i, (uiCode == 1) ? true : false);
409
410          if ( pcDLT->getUseDLTFlag( i ) )
411          {
412            Bool bDltBitMapRepFlag    = false;
413            UInt uiMaxDiff            = 0xffffffff;
414            UInt uiMinDiff            = 0;
415            UInt uiCodeLength         = 0;
416
417            READ_FLAG(uiCode, "inter_view_dlt_pred_enable_flag[ i ]"); 
418
419            if( uiCode )
420            {
421                assert( pcDLT->getUseDLTFlag( 1 ));
422            }
423            pcDLT->setInterViewDltPredEnableFlag( i, (uiCode == 1) ? true : false );
424
425            if ( pcDLT->getInterViewDltPredEnableFlag( i ) == false )
426            {
427              READ_FLAG(uiCode, "dlt_bit_map_rep_flag[ layerId ]");
428              bDltBitMapRepFlag = (uiCode == 1) ? true : false; 
429            }
430            else
431            {
432              bDltBitMapRepFlag = false;
433            }
434           
435            UInt uiNumDepthValues = 0;
436            Int  aiIdx2DepthValue[256];
437
438            // Bit map
439            if ( bDltBitMapRepFlag )
440            {
441              for (UInt d=0; d<256; d++)
442              {
443                READ_FLAG(uiCode, "dlt_bit_map_flag[ layerId ][ j ]");
444                if (uiCode == 1)
445                {
446                  aiIdx2DepthValue[uiNumDepthValues] = d;
447                  uiNumDepthValues++;
448                }
449              }
450            }
451            // Diff Coding
452            else
453            {
454              READ_CODE(8, uiNumDepthValues, "num_depth_values_in_dlt[i]");   // num_entry
455
456              {
457                // The condition if( pcVPS->getNumDepthValues(i) > 0 ) is always true since for Single-view Diff Coding, there is at least one depth value in depth component.
458
459                if (uiNumDepthValues > 1)
460                {
461                  READ_CODE(8, uiCode, "max_diff[ layerId ]"); 
462                  uiMaxDiff = uiCode;
463                }
464                else
465                {
466                  uiMaxDiff = 0;           // when there is only one value in DLT
467                }
468
469                if (uiNumDepthValues > 2)
470                {
471                  uiCodeLength = (UInt) ceil(Log2(uiMaxDiff + 1));
472                  READ_CODE(uiCodeLength, uiCode, "min_diff_minus1[ layerId ]");
473                  uiMinDiff = uiCode + 1;
474                }
475                else
476                {
477                  uiMinDiff = uiMaxDiff;   // when there are only one or two values in DLT
478                }
479
480                READ_CODE(8, uiCode, "dlt_depth_value0[layerId]");   // entry0
481                aiIdx2DepthValue[0] = uiCode;
482
483                if (uiMaxDiff == uiMinDiff)
484                {
485                  for (UInt d=1; d<uiNumDepthValues; d++)
486                  {
487                    aiIdx2DepthValue[d] = aiIdx2DepthValue[d-1] + uiMinDiff + 0;
488                  }
489                }
490                else
491                {
492                  uiCodeLength = (UInt) ceil(Log2(uiMaxDiff - uiMinDiff + 1));
493                  for (UInt d=1; d<uiNumDepthValues; d++)
494                  {
495                    READ_CODE(uiCodeLength, uiCode, "dlt_depth_value_diff_minus_min[ layerId ][ j ]");
496                    aiIdx2DepthValue[d] = aiIdx2DepthValue[d-1] + uiMinDiff + uiCode;
497                  }
498                }
499
500              }
501            }
502           
503            if( pcDLT->getInterViewDltPredEnableFlag( i ) )
504            {
505              // interpret decoded values as delta DLT
506              AOF( pcVPS->getDepthId( 1 ) == 1 );
507              AOF( i > 1 );
508              // assumes ref layer id to be 1
509              Int* piRefDLT = pcDLT->idx2DepthValue( 1 );
510              UInt uiRefNum = pcDLT->getNumDepthValues( 1 );
511              pcDLT->setDeltaDLT(i, piRefDLT, uiRefNum, aiIdx2DepthValue, uiNumDepthValues);
512            }
513            else
514            {
515              // store final DLT
516              pcDLT->setDepthLUTs(i, aiIdx2DepthValue, uiNumDepthValues);
517            }
518
519          }
520        }
521      }
522    }
523  }
524
525  pcPPS->setDLT( pcDLT );
526}
527#endif
528
529Void  TDecCavlc::parseVUI(TComVUI* pcVUI, TComSPS *pcSPS)
530{
531#if ENC_DEC_TRACE
532  fprintf( g_hTrace, "----------- vui_parameters -----------\n");
533#endif
534  UInt  uiCode;
535
536  READ_FLAG(     uiCode, "aspect_ratio_info_present_flag");           pcVUI->setAspectRatioInfoPresentFlag(uiCode);
537  if (pcVUI->getAspectRatioInfoPresentFlag())
538  {
539    READ_CODE(8, uiCode, "aspect_ratio_idc");                         pcVUI->setAspectRatioIdc(uiCode);
540    if (pcVUI->getAspectRatioIdc() == 255)
541    {
542      READ_CODE(16, uiCode, "sar_width");                             pcVUI->setSarWidth(uiCode);
543      READ_CODE(16, uiCode, "sar_height");                            pcVUI->setSarHeight(uiCode);
544    }
545  }
546
547  READ_FLAG(     uiCode, "overscan_info_present_flag");               pcVUI->setOverscanInfoPresentFlag(uiCode);
548  if (pcVUI->getOverscanInfoPresentFlag())
549  {
550    READ_FLAG(   uiCode, "overscan_appropriate_flag");                pcVUI->setOverscanAppropriateFlag(uiCode);
551  }
552
553  READ_FLAG(     uiCode, "video_signal_type_present_flag");           pcVUI->setVideoSignalTypePresentFlag(uiCode);
554#if H_MV
555  assert( pcSPS->getLayerId() == 0 || !pcVUI->getVideoSignalTypePresentFlag() ); 
556#endif
557  if (pcVUI->getVideoSignalTypePresentFlag())
558  {
559    READ_CODE(3, uiCode, "video_format");                             pcVUI->setVideoFormat(uiCode);
560    READ_FLAG(   uiCode, "video_full_range_flag");                    pcVUI->setVideoFullRangeFlag(uiCode);
561    READ_FLAG(   uiCode, "colour_description_present_flag");          pcVUI->setColourDescriptionPresentFlag(uiCode);
562    if (pcVUI->getColourDescriptionPresentFlag())
563    {
564      READ_CODE(8, uiCode, "colour_primaries");                       pcVUI->setColourPrimaries(uiCode);
565      READ_CODE(8, uiCode, "transfer_characteristics");               pcVUI->setTransferCharacteristics(uiCode);
566      READ_CODE(8, uiCode, "matrix_coefficients");                    pcVUI->setMatrixCoefficients(uiCode);
567    }
568  }
569
570  READ_FLAG(     uiCode, "chroma_loc_info_present_flag");             pcVUI->setChromaLocInfoPresentFlag(uiCode);
571  if (pcVUI->getChromaLocInfoPresentFlag())
572  {
573    READ_UVLC(   uiCode, "chroma_sample_loc_type_top_field" );        pcVUI->setChromaSampleLocTypeTopField(uiCode);
574    READ_UVLC(   uiCode, "chroma_sample_loc_type_bottom_field" );     pcVUI->setChromaSampleLocTypeBottomField(uiCode);
575  }
576
577  READ_FLAG(     uiCode, "neutral_chroma_indication_flag");           pcVUI->setNeutralChromaIndicationFlag(uiCode);
578
579  READ_FLAG(     uiCode, "field_seq_flag");                           pcVUI->setFieldSeqFlag(uiCode);
580
581  READ_FLAG(uiCode, "frame_field_info_present_flag");                 pcVUI->setFrameFieldInfoPresentFlag(uiCode);
582
583  READ_FLAG(     uiCode, "default_display_window_flag");
584  if (uiCode != 0)
585  {
586    Window &defDisp = pcVUI->getDefaultDisplayWindow();
587#if H_MV
588    defDisp.setScaledFlag( false ); 
589    READ_UVLC(   uiCode, "def_disp_win_left_offset" );                defDisp.setWindowLeftOffset  ( uiCode );
590    READ_UVLC(   uiCode, "def_disp_win_right_offset" );               defDisp.setWindowRightOffset ( uiCode );
591    READ_UVLC(   uiCode, "def_disp_win_top_offset" );                 defDisp.setWindowTopOffset   ( uiCode );
592    READ_UVLC(   uiCode, "def_disp_win_bottom_offset" );              defDisp.setWindowBottomOffset( uiCode );
593#else
594    READ_UVLC(   uiCode, "def_disp_win_left_offset" );                defDisp.setWindowLeftOffset  ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc()) );
595    READ_UVLC(   uiCode, "def_disp_win_right_offset" );               defDisp.setWindowRightOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc()) );
596    READ_UVLC(   uiCode, "def_disp_win_top_offset" );                 defDisp.setWindowTopOffset   ( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc()) );
597    READ_UVLC(   uiCode, "def_disp_win_bottom_offset" );              defDisp.setWindowBottomOffset( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc()) );
598#endif
599  }
600  TimingInfo *timingInfo = pcVUI->getTimingInfo();
601  READ_FLAG(       uiCode, "vui_timing_info_present_flag");         timingInfo->setTimingInfoPresentFlag      (uiCode ? true : false);
602  if(timingInfo->getTimingInfoPresentFlag())
603  {
604    READ_CODE( 32, uiCode, "vui_num_units_in_tick");                timingInfo->setNumUnitsInTick             (uiCode);
605    READ_CODE( 32, uiCode, "vui_time_scale");                       timingInfo->setTimeScale                  (uiCode);
606    READ_FLAG(     uiCode, "vui_poc_proportional_to_timing_flag");  timingInfo->setPocProportionalToTimingFlag(uiCode ? true : false);
607    if(timingInfo->getPocProportionalToTimingFlag())
608    {
609      READ_UVLC(   uiCode, "vui_num_ticks_poc_diff_one_minus1");    timingInfo->setNumTicksPocDiffOneMinus1   (uiCode);
610    }
611  READ_FLAG(     uiCode, "hrd_parameters_present_flag");              pcVUI->setHrdParametersPresentFlag(uiCode);
612  if( pcVUI->getHrdParametersPresentFlag() )
613  {
614    parseHrdParameters( pcVUI->getHrdParameters(), 1, pcSPS->getMaxTLayers() - 1 );
615  }
616  }
617  READ_FLAG(     uiCode, "bitstream_restriction_flag");               pcVUI->setBitstreamRestrictionFlag(uiCode);
618  if (pcVUI->getBitstreamRestrictionFlag())
619  {
620    READ_FLAG(   uiCode, "tiles_fixed_structure_flag");               pcVUI->setTilesFixedStructureFlag(uiCode);
621    READ_FLAG(   uiCode, "motion_vectors_over_pic_boundaries_flag");  pcVUI->setMotionVectorsOverPicBoundariesFlag(uiCode);
622    READ_FLAG(   uiCode, "restricted_ref_pic_lists_flag");            pcVUI->setRestrictedRefPicListsFlag(uiCode);
623    READ_UVLC( uiCode, "min_spatial_segmentation_idc");            pcVUI->setMinSpatialSegmentationIdc(uiCode);
624    assert(uiCode < 4096);
625    READ_UVLC(   uiCode, "max_bytes_per_pic_denom" );                 pcVUI->setMaxBytesPerPicDenom(uiCode);
626    READ_UVLC(   uiCode, "max_bits_per_mincu_denom" );                pcVUI->setMaxBitsPerMinCuDenom(uiCode);
627    READ_UVLC(   uiCode, "log2_max_mv_length_horizontal" );           pcVUI->setLog2MaxMvLengthHorizontal(uiCode);
628    READ_UVLC(   uiCode, "log2_max_mv_length_vertical" );             pcVUI->setLog2MaxMvLengthVertical(uiCode);
629  }
630}
631
632Void TDecCavlc::parseHrdParameters(TComHRD *hrd, Bool commonInfPresentFlag, UInt maxNumSubLayersMinus1)
633{
634  UInt  uiCode;
635  if( commonInfPresentFlag )
636  {
637    READ_FLAG( uiCode, "nal_hrd_parameters_present_flag" );           hrd->setNalHrdParametersPresentFlag( uiCode == 1 ? true : false );
638    READ_FLAG( uiCode, "vcl_hrd_parameters_present_flag" );           hrd->setVclHrdParametersPresentFlag( uiCode == 1 ? true : false );
639    if( hrd->getNalHrdParametersPresentFlag() || hrd->getVclHrdParametersPresentFlag() )
640    {
641      READ_FLAG( uiCode, "sub_pic_cpb_params_present_flag" );         hrd->setSubPicCpbParamsPresentFlag( uiCode == 1 ? true : false );
642      if( hrd->getSubPicCpbParamsPresentFlag() )
643      {
644        READ_CODE( 8, uiCode, "tick_divisor_minus2" );                hrd->setTickDivisorMinus2( uiCode );
645        READ_CODE( 5, uiCode, "du_cpb_removal_delay_length_minus1" ); hrd->setDuCpbRemovalDelayLengthMinus1( uiCode );
646        READ_FLAG( uiCode, "sub_pic_cpb_params_in_pic_timing_sei_flag" ); hrd->setSubPicCpbParamsInPicTimingSEIFlag( uiCode == 1 ? true : false );
647        READ_CODE( 5, uiCode, "dpb_output_delay_du_length_minus1"  ); hrd->setDpbOutputDelayDuLengthMinus1( uiCode );
648      }
649      READ_CODE( 4, uiCode, "bit_rate_scale" );                       hrd->setBitRateScale( uiCode );
650      READ_CODE( 4, uiCode, "cpb_size_scale" );                       hrd->setCpbSizeScale( uiCode );
651      if( hrd->getSubPicCpbParamsPresentFlag() )
652      {
653        READ_CODE( 4, uiCode, "cpb_size_du_scale" );                  hrd->setDuCpbSizeScale( uiCode );
654      }
655      READ_CODE( 5, uiCode, "initial_cpb_removal_delay_length_minus1" ); hrd->setInitialCpbRemovalDelayLengthMinus1( uiCode );
656      READ_CODE( 5, uiCode, "au_cpb_removal_delay_length_minus1" );      hrd->setCpbRemovalDelayLengthMinus1( uiCode );
657      READ_CODE( 5, uiCode, "dpb_output_delay_length_minus1" );       hrd->setDpbOutputDelayLengthMinus1( uiCode );
658    }
659  }
660  Int i, j, nalOrVcl;
661  for( i = 0; i <= maxNumSubLayersMinus1; i ++ )
662  {
663    READ_FLAG( uiCode, "fixed_pic_rate_general_flag" );                     hrd->setFixedPicRateFlag( i, uiCode == 1 ? true : false  );
664    if( !hrd->getFixedPicRateFlag( i ) )
665    {
666      READ_FLAG( uiCode, "fixed_pic_rate_within_cvs_flag" );                hrd->setFixedPicRateWithinCvsFlag( i, uiCode == 1 ? true : false  );
667    }
668    else
669    {
670      hrd->setFixedPicRateWithinCvsFlag( i, true );
671    }
672    hrd->setLowDelayHrdFlag( i, 0 ); // Infered to be 0 when not present
673    hrd->setCpbCntMinus1   ( i, 0 ); // Infered to be 0 when not present
674    if( hrd->getFixedPicRateWithinCvsFlag( i ) )
675    {
676      READ_UVLC( uiCode, "elemental_duration_in_tc_minus1" );             hrd->setPicDurationInTcMinus1( i, uiCode );
677    }
678    else
679    {     
680      READ_FLAG( uiCode, "low_delay_hrd_flag" );                      hrd->setLowDelayHrdFlag( i, uiCode == 1 ? true : false  );
681    }
682    if (!hrd->getLowDelayHrdFlag( i ))
683    {
684      READ_UVLC( uiCode, "cpb_cnt_minus1" );                          hrd->setCpbCntMinus1( i, uiCode );     
685    }
686    for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
687    {
688      if( ( ( nalOrVcl == 0 ) && ( hrd->getNalHrdParametersPresentFlag() ) ) ||
689          ( ( nalOrVcl == 1 ) && ( hrd->getVclHrdParametersPresentFlag() ) ) )
690      {
691        for( j = 0; j <= ( hrd->getCpbCntMinus1( i ) ); j ++ )
692        {
693          READ_UVLC( uiCode, "bit_rate_value_minus1" );             hrd->setBitRateValueMinus1( i, j, nalOrVcl, uiCode );
694          READ_UVLC( uiCode, "cpb_size_value_minus1" );             hrd->setCpbSizeValueMinus1( i, j, nalOrVcl, uiCode );
695          if( hrd->getSubPicCpbParamsPresentFlag() )
696          {
697            READ_UVLC( uiCode, "cpb_size_du_value_minus1" );       hrd->setDuCpbSizeValueMinus1( i, j, nalOrVcl, uiCode );
698            READ_UVLC( uiCode, "bit_rate_du_value_minus1" );       hrd->setDuBitRateValueMinus1( i, j, nalOrVcl, uiCode );
699          }
700          READ_FLAG( uiCode, "cbr_flag" );                          hrd->setCbrFlag( i, j, nalOrVcl, uiCode == 1 ? true : false  );
701        }
702      }
703    }
704  }
705}
706
707Void TDecCavlc::parseSPS(TComSPS* pcSPS)
708{
709#if ENC_DEC_TRACE 
710  xTraceSPSHeader (pcSPS);
711#endif
712
713  UInt  uiCode;
714  READ_CODE( 4,  uiCode, "sps_video_parameter_set_id");          pcSPS->setVPSId        ( uiCode );
715
716#if H_MV
717  if ( pcSPS->getLayerId() == 0 )
718  {
719#endif
720    READ_CODE( 3,  uiCode, "sps_max_sub_layers_minus1" );          pcSPS->setMaxTLayers   ( uiCode+1 );
721    assert(uiCode <= 6);
722#if H_MV
723  }
724  else
725  {
726    READ_CODE( 3, uiCode, "sps_ext_or_max_sub_layers_minus1" ); pcSPS->setSpsExtOrMaxSubLayersMinus1( uiCode );   
727    pcSPS->inferSpsMaxSubLayersMinus1( false, NULL );
728  }
729  if ( !pcSPS->getMultiLayerExtSpsFlag() )
730  {
731#endif
732
733    READ_FLAG( uiCode, "sps_temporal_id_nesting_flag" );               pcSPS->setTemporalIdNestingFlag ( uiCode > 0 ? true : false );
734    if ( pcSPS->getMaxTLayers() == 1 )
735    {
736      // sps_temporal_id_nesting_flag must be 1 when sps_max_sub_layers_minus1 is 0
737      assert( uiCode == 1 );
738    }
739
740    parsePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
741#if H_MV
742    pcSPS->getPTL()->inferGeneralValues ( true, 0, NULL ); 
743    pcSPS->getPTL()->inferSubLayerValues( pcSPS->getMaxTLayers() - 1, 0, NULL );
744  }
745#endif
746  READ_UVLC(     uiCode, "sps_seq_parameter_set_id" );           pcSPS->setSPSId( uiCode );
747  assert(uiCode <= 15);
748#if H_MV
749  if ( pcSPS->getMultiLayerExtSpsFlag() )
750  {
751    READ_FLAG( uiCode, "update_rep_format_flag" );               pcSPS->setUpdateRepFormatFlag( uiCode == 1 );
752    if ( pcSPS->getUpdateRepFormatFlag() )
753    { 
754      READ_CODE( 8, uiCode, "sps_rep_format_idx" );                pcSPS->setSpsRepFormatIdx( uiCode );
755    }
756  }
757  else
758  {
759#endif
760    READ_UVLC(     uiCode, "chroma_format_idc" );                  pcSPS->setChromaFormatIdc( uiCode );
761    assert(uiCode <= 3);
762    // in the first version we only support chroma_format_idc equal to 1 (4:2:0), so separate_colour_plane_flag cannot appear in the bitstream
763#if !H_3D_DISABLE_CHROMA
764    assert (uiCode == 1);
765#endif
766    if( uiCode == 3 )
767    {
768      READ_FLAG(     uiCode, "separate_colour_plane_flag");        assert(uiCode == 0);
769    }
770
771    READ_UVLC (    uiCode, "pic_width_in_luma_samples" );          pcSPS->setPicWidthInLumaSamples ( uiCode    );
772    READ_UVLC (    uiCode, "pic_height_in_luma_samples" );         pcSPS->setPicHeightInLumaSamples( uiCode    );
773  READ_FLAG(     uiCode, "conformance_window_flag");
774  if (uiCode != 0)
775  {
776    Window &conf = pcSPS->getConformanceWindow();
777#if H_MV
778    // Needs to be scaled later, when ChromaFormatIdc is known.
779    conf.setScaledFlag( false ); 
780    READ_UVLC(   uiCode, "conf_win_left_offset" );               conf.setWindowLeftOffset  ( uiCode  );
781    READ_UVLC(   uiCode, "conf_win_right_offset" );              conf.setWindowRightOffset ( uiCode  );
782    READ_UVLC(   uiCode, "conf_win_top_offset" );                conf.setWindowTopOffset   ( uiCode  );
783    READ_UVLC(   uiCode, "conf_win_bottom_offset" );             conf.setWindowBottomOffset( uiCode  );   
784  }
785#else
786    READ_UVLC(   uiCode, "conf_win_left_offset" );               conf.setWindowLeftOffset  ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc() ) );
787    READ_UVLC(   uiCode, "conf_win_right_offset" );              conf.setWindowRightOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc() ) );
788    READ_UVLC(   uiCode, "conf_win_top_offset" );                conf.setWindowTopOffset   ( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc() ) );
789    READ_UVLC(   uiCode, "conf_win_bottom_offset" );             conf.setWindowBottomOffset( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc() ) );
790#endif
791  }
792
793#if H_MV
794  if ( !pcSPS->getMultiLayerExtSpsFlag() )
795  { 
796#endif
797    READ_UVLC(     uiCode, "bit_depth_luma_minus8" );
798    assert(uiCode <= 6);
799    pcSPS->setBitDepthY( uiCode + 8 );
800    pcSPS->setQpBDOffsetY( (Int) (6*uiCode) );
801
802    READ_UVLC( uiCode,    "bit_depth_chroma_minus8" );
803    assert(uiCode <= 6);
804    pcSPS->setBitDepthC( uiCode + 8 );
805    pcSPS->setQpBDOffsetC( (Int) (6*uiCode) );
806#if H_MV
807  }
808#endif
809
810  READ_UVLC( uiCode,    "log2_max_pic_order_cnt_lsb_minus4" );   pcSPS->setBitsForPOC( 4 + uiCode );
811  assert(uiCode <= 12);
812
813#if H_MV
814  if ( !pcSPS->getMultiLayerExtSpsFlag()) 
815  { 
816#endif
817    UInt subLayerOrderingInfoPresentFlag;
818    READ_FLAG(subLayerOrderingInfoPresentFlag, "sps_sub_layer_ordering_info_present_flag");
819
820    for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
821    {
822      READ_UVLC ( uiCode, "sps_max_dec_pic_buffering_minus1[i]");
823      pcSPS->setMaxDecPicBuffering( uiCode + 1, i);
824      READ_UVLC ( uiCode, "sps_num_reorder_pics[i]" );
825      pcSPS->setNumReorderPics(uiCode, i);
826      READ_UVLC ( uiCode, "sps_max_latency_increase_plus1[i]");
827      pcSPS->setMaxLatencyIncrease( uiCode, i );
828
829      if (!subLayerOrderingInfoPresentFlag)
830      {
831        for (i++; i <= pcSPS->getMaxTLayers()-1; i++)
832        {
833          pcSPS->setMaxDecPicBuffering(pcSPS->getMaxDecPicBuffering(0), i);
834          pcSPS->setNumReorderPics(pcSPS->getNumReorderPics(0), i);
835          pcSPS->setMaxLatencyIncrease(pcSPS->getMaxLatencyIncrease(0), i);
836        }
837        break;
838      }
839    }
840#if H_MV
841  }
842#endif
843
844  READ_UVLC( uiCode, "log2_min_coding_block_size_minus3" );
845  Int log2MinCUSize = uiCode + 3;
846  pcSPS->setLog2MinCodingBlockSize(log2MinCUSize);
847  READ_UVLC( uiCode, "log2_diff_max_min_coding_block_size" );
848  pcSPS->setLog2DiffMaxMinCodingBlockSize(uiCode);
849
850  if (pcSPS->getPTL()->getGeneralPTL()->getLevelIdc() >= Level::LEVEL5)
851  {
852    assert(log2MinCUSize + pcSPS->getLog2DiffMaxMinCodingBlockSize() >= 5);
853  }
854
855  Int maxCUDepthDelta = uiCode;
856  pcSPS->setMaxCUWidth  ( 1<<(log2MinCUSize + maxCUDepthDelta) ); 
857  pcSPS->setMaxCUHeight ( 1<<(log2MinCUSize + maxCUDepthDelta) );
858  READ_UVLC( uiCode, "log2_min_transform_block_size_minus2" );   pcSPS->setQuadtreeTULog2MinSize( uiCode + 2 );
859
860  READ_UVLC( uiCode, "log2_diff_max_min_transform_block_size" ); pcSPS->setQuadtreeTULog2MaxSize( uiCode + pcSPS->getQuadtreeTULog2MinSize() );
861  pcSPS->setMaxTrSize( 1<<(uiCode + pcSPS->getQuadtreeTULog2MinSize()) );
862
863  READ_UVLC( uiCode, "max_transform_hierarchy_depth_inter" );    pcSPS->setQuadtreeTUMaxDepthInter( uiCode+1 );
864  READ_UVLC( uiCode, "max_transform_hierarchy_depth_intra" );    pcSPS->setQuadtreeTUMaxDepthIntra( uiCode+1 );
865
866  Int addCuDepth = max (0, log2MinCUSize - (Int)pcSPS->getQuadtreeTULog2MinSize() );
867  pcSPS->setMaxCUDepth( maxCUDepthDelta + addCuDepth ); 
868
869  READ_FLAG( uiCode, "scaling_list_enabled_flag" );                 pcSPS->setScalingListFlag ( uiCode );
870  if(pcSPS->getScalingListFlag())
871  {
872#if H_MV
873    if ( pcSPS->getMultiLayerExtSpsFlag() )
874    {   
875      READ_FLAG( uiCode, "sps_infer_scaling_list_flag" ); pcSPS->setSpsInferScalingListFlag( uiCode == 1 );
876    }
877
878    if ( pcSPS->getSpsInferScalingListFlag() )
879    {
880      READ_CODE( 6, uiCode, "sps_scaling_list_ref_layer_id" ); pcSPS->setSpsScalingListRefLayerId( uiCode );
881    }
882    else
883    {   
884#endif
885      READ_FLAG( uiCode, "sps_scaling_list_data_present_flag" );                 pcSPS->setScalingListPresentFlag ( uiCode );
886      if(pcSPS->getScalingListPresentFlag ())
887      {
888        parseScalingList( pcSPS->getScalingList() );
889      }
890#if H_MV
891    }
892#endif
893  }
894  READ_FLAG( uiCode, "amp_enabled_flag" );                          pcSPS->setUseAMP( uiCode );
895  READ_FLAG( uiCode, "sample_adaptive_offset_enabled_flag" );       pcSPS->setUseSAO ( uiCode ? true : false );
896
897  READ_FLAG( uiCode, "pcm_enabled_flag" ); pcSPS->setUsePCM( uiCode ? true : false );
898  if( pcSPS->getUsePCM() )
899  {
900    READ_CODE( 4, uiCode, "pcm_sample_bit_depth_luma_minus1" );          pcSPS->setPCMBitDepthLuma   ( 1 + uiCode );
901    READ_CODE( 4, uiCode, "pcm_sample_bit_depth_chroma_minus1" );        pcSPS->setPCMBitDepthChroma ( 1 + uiCode );
902    READ_UVLC( uiCode, "log2_min_pcm_luma_coding_block_size_minus3" );   pcSPS->setPCMLog2MinSize (uiCode+3);
903    READ_UVLC( uiCode, "log2_diff_max_min_pcm_luma_coding_block_size" ); pcSPS->setPCMLog2MaxSize ( uiCode+pcSPS->getPCMLog2MinSize() );
904    READ_FLAG( uiCode, "pcm_loop_filter_disable_flag" );                 pcSPS->setPCMFilterDisableFlag ( uiCode ? true : false );
905  }
906
907  READ_UVLC( uiCode, "num_short_term_ref_pic_sets" );
908  assert(uiCode <= 64);
909  pcSPS->createRPSList(uiCode);
910
911  TComRPSList* rpsList = pcSPS->getRPSList();
912  TComReferencePictureSet* rps;
913
914  for(UInt i=0; i< rpsList->getNumberOfReferencePictureSets(); i++)
915  {
916    rps = rpsList->getReferencePictureSet(i);
917    parseShortTermRefPicSet(pcSPS,rps,i);
918  }
919  READ_FLAG( uiCode, "long_term_ref_pics_present_flag" );          pcSPS->setLongTermRefsPresent(uiCode);
920  if (pcSPS->getLongTermRefsPresent()) 
921  {
922    READ_UVLC( uiCode, "num_long_term_ref_pic_sps" );
923    pcSPS->setNumLongTermRefPicSPS(uiCode);
924    for (UInt k = 0; k < pcSPS->getNumLongTermRefPicSPS(); k++)
925    {
926      READ_CODE( pcSPS->getBitsForPOC(), uiCode, "lt_ref_pic_poc_lsb_sps" );
927      pcSPS->setLtRefPicPocLsbSps(k, uiCode);
928      READ_FLAG( uiCode,  "used_by_curr_pic_lt_sps_flag[i]");
929      pcSPS->setUsedByCurrPicLtSPSFlag(k, uiCode?1:0);
930    }
931  }
932  READ_FLAG( uiCode, "sps_temporal_mvp_enable_flag" );            pcSPS->setTMVPFlagsPresent(uiCode);
933
934  READ_FLAG( uiCode, "sps_strong_intra_smoothing_enable_flag" );  pcSPS->setUseStrongIntraSmoothing(uiCode);
935
936  READ_FLAG( uiCode, "vui_parameters_present_flag" );             pcSPS->setVuiParametersPresentFlag(uiCode);
937
938  if (pcSPS->getVuiParametersPresentFlag())
939  {
940    parseVUI(pcSPS->getVuiParameters(), pcSPS);
941  }
942
943
944#if H_MV
945  READ_FLAG( uiCode, "sps_extension_present_flag");
946  pcSPS->setSpsExtensionPresentFlag( uiCode ); 
947  if (pcSPS->getSpsExtensionPresentFlag( ) )
948#else
949  READ_FLAG( uiCode, "sps_extension_flag");
950  if (uiCode)
951#endif
952  {
953#if H_MV
954    READ_FLAG( uiCode, "sps_range_extensions_flag" ); pcSPS->setSpsRangeExtensionsFlag( uiCode == 1 );
955    READ_FLAG( uiCode, "sps_multilayer_extension_flag" ); pcSPS->setSpsMultilayerExtensionFlag( uiCode == 1 );
956#if !H_3D
957    READ_CODE( 6, uiCode, "sps_extension_6bits" ); pcSPS->setSpsExtension6bits( uiCode );
958#else
959    READ_FLAG( uiCode, "sps_3d_extension_flag" ); pcSPS->setSps3dExtensionFlag( uiCode == 1 );
960    READ_CODE( 5, uiCode, "sps_extension_5bits" ); pcSPS->setSpsExtension5bits( uiCode );
961#endif
962  }
963
964  if ( pcSPS->getSpsRangeExtensionsFlag() )
965  {
966    assert( 0 ); 
967  }
968
969  if ( pcSPS->getSpsMultilayerExtensionFlag() )
970  {
971    parseSPSExtension( pcSPS ); 
972  }
973
974#if H_3D
975  if ( pcSPS->getSps3dExtensionFlag() )
976  {
977    parseSPS3dExtension( pcSPS ); 
978  }
979
980  if ( pcSPS->getSpsExtension5bits() )
981  { 
982#else
983  if ( pcSPS->getSpsExtension6bits() )
984  { 
985#endif
986
987#endif
988    while ( xMoreRbspData() )
989    {
990      READ_FLAG( uiCode, "sps_extension_data_flag");
991    }
992  }
993}
994
995#if H_MV
996Void TDecCavlc::parseSPSExtension( TComSPS* pcSPS )
997{
998  UInt uiCode; 
999  READ_FLAG( uiCode, "inter_view_mv_vert_constraint_flag" );    pcSPS->setInterViewMvVertConstraintFlag(uiCode == 1 ? true : false);
1000 
1001}
1002
1003#if H_3D
1004Void TDecCavlc::parseSPS3dExtension( TComSPS* pcSPS )
1005{ 
1006  TComSps3dExtension* sps3dExt = pcSPS->getSps3dExtension(); 
1007  UInt uiCode; 
1008  for( Int d = 0; d  <=  1; d++ )
1009  {
1010    READ_FLAG( uiCode, "iv_mv_pred_flag" ); sps3dExt->setIvMvPredFlag( d, uiCode == 1 );
1011    READ_FLAG( uiCode, "iv_mv_scaling_flag" ); sps3dExt->setIvMvScalingFlag( d, uiCode == 1 );
1012    if( d  ==  0 )
1013    {
1014      READ_UVLC( uiCode, "log2_sub_pb_size_minus3" ); sps3dExt->setLog2SubPbSizeMinus3( d, uiCode );
1015      READ_FLAG( uiCode, "iv_res_pred_flag" ); sps3dExt->setIvResPredFlag( d, uiCode == 1 );
1016      READ_FLAG( uiCode, "depth_refinement_flag" ); sps3dExt->setDepthRefinementFlag( d, uiCode == 1 );
1017      READ_FLAG( uiCode, "view_synthesis_pred_flag" ); sps3dExt->setViewSynthesisPredFlag( d, uiCode == 1 );
1018      READ_FLAG( uiCode, "depth_based_blk_part_flag" ); sps3dExt->setDepthBasedBlkPartFlag( d, uiCode == 1 );
1019    }
1020    else 
1021    {
1022      READ_FLAG( uiCode, "mpi_flag" ); sps3dExt->setMpiFlag( d, uiCode == 1 );
1023      READ_UVLC( uiCode, "log2_mpi_sub_pb_size_minus3" ); sps3dExt->setLog2MpiSubPbSizeMinus3( d, uiCode );
1024      READ_FLAG( uiCode, "intra_contour_flag" ); sps3dExt->setIntraContourFlag( d, uiCode == 1 );
1025      READ_FLAG( uiCode, "intra_sdc_wedge_flag" ); sps3dExt->setIntraSdcWedgeFlag( d, uiCode == 1 );
1026      READ_FLAG( uiCode, "qt_pred_flag" ); sps3dExt->setQtPredFlag( d, uiCode == 1 );
1027      READ_FLAG( uiCode, "inter_sdc_flag" ); sps3dExt->setInterSdcFlag( d, uiCode == 1 );
1028      READ_FLAG( uiCode, "intra_skip_flag" ); sps3dExt->setDepthIntraSkipFlag( d, uiCode == 1 );
1029    }
1030  }
1031}
1032#endif
1033
1034Void TDecCavlc::parsePPSMultilayerExtension(TComPPS* pcPPS)
1035{
1036  UInt uiCode = 0; 
1037  READ_FLAG( uiCode, "poc_reset_info_present_flag" ); pcPPS->setPocResetInfoPresentFlag( uiCode == 1 );
1038  READ_FLAG( uiCode, "pps_infer_scaling_list_flag" ); pcPPS->setPpsInferScalingListFlag( uiCode == 1 );
1039  if (pcPPS->getPpsInferScalingListFlag())
1040  {
1041  READ_CODE( 6, uiCode, "pps_scaling_list_ref_layer_id" ); pcPPS->setPpsScalingListRefLayerId( uiCode );
1042  }
1043
1044  UInt numRefLocOffsets;; 
1045  READ_UVLC( numRefLocOffsets, "num_ref_loc_offsets" );
1046
1047  // All of the following stuff is not needed, but allowed to be present.
1048  for (Int i = 0; i < numRefLocOffsets; i++ )
1049  { 
1050    Int   iCode = 0; 
1051    READ_CODE( 6, uiCode, "ref_loc_offset_layer_id" ); 
1052    READ_FLAG( uiCode, "scaled_ref_layer_offset_present_flag" );
1053
1054    if (uiCode)
1055    {   
1056      READ_SVLC( iCode, "scaled_ref_layer_left_offset" );   
1057      READ_SVLC( iCode, "scaled_ref_layer_top_offset" );   
1058      READ_SVLC( iCode, "scaled_ref_layer_right_offset" ); 
1059      READ_SVLC( iCode, "scaled_ref_layer_bottom_offset" ); 
1060    }
1061
1062    READ_FLAG( uiCode, "ref_region_offset_present_flag" ); 
1063    if (uiCode)
1064    {   
1065      READ_SVLC( iCode, "ref_region_left_offset" );     
1066      READ_SVLC( iCode, "ref_region_top_offset" );     
1067      READ_SVLC( iCode, "ref_region_right_offset" );   
1068      READ_SVLC( iCode, "ref_region_bottom_offset" );   
1069    }
1070
1071    READ_FLAG( uiCode, "resample_phase_set_present_flag" );
1072    if (uiCode)
1073    {     
1074      READ_UVLC( uiCode, "phase_hor_luma" );             
1075      READ_UVLC( uiCode, "phase_ver_luma" );             
1076      READ_UVLC( uiCode, "phase_hor_chroma_plus8" );     
1077      READ_UVLC( uiCode, "phase_ver_chroma_plus8" );     
1078    }
1079  }
1080  READ_FLAG( uiCode, "colour_mapping_enabled_flag" );   
1081  // This is required to equal to 0 for Multiview Main profile.
1082  assert( uiCode == 0 ); 
1083}
1084
1085#endif
1086
1087Void TDecCavlc::parseVPS(TComVPS* pcVPS)
1088{
1089  UInt  uiCode;
1090 
1091  READ_CODE( 4,  uiCode,  "vps_video_parameter_set_id" );         pcVPS->setVPSId( uiCode );
1092#if H_MV
1093  READ_FLAG( uiCode, "vps_base_layer_internal_flag" );            pcVPS->setVpsBaseLayerInternalFlag( uiCode == 1 );
1094  READ_FLAG( uiCode, "vps_base_layer_available_flag" );           pcVPS->setVpsBaseLayerAvailableFlag( uiCode == 1 );
1095#else
1096  READ_CODE( 2,  uiCode,  "vps_reserved_three_2bits" );           assert(uiCode == 3);
1097#endif
1098#if H_MV
1099  READ_CODE( 6,  uiCode,  "vps_max_layers_minus1" );              pcVPS->setMaxLayersMinus1( std::min( uiCode, (UInt) ( MAX_NUM_LAYER_IDS-1) )  );
1100#else
1101  READ_CODE( 6,  uiCode,  "vps_reserved_zero_6bits" );            assert(uiCode == 0);
1102#endif
1103  READ_CODE( 3,  uiCode,  "vps_max_sub_layers_minus1" );          pcVPS->setMaxTLayers( uiCode + 1 );    assert(uiCode+1 <= MAX_TLAYER);
1104  READ_FLAG(     uiCode,  "vps_temporal_id_nesting_flag" );       pcVPS->setTemporalNestingFlag( uiCode ? true:false );
1105  assert (pcVPS->getMaxTLayers()>1||pcVPS->getTemporalNestingFlag());
1106
1107  READ_CODE( 16, uiCode,  "vps_reserved_ffff_16bits" );           assert(uiCode == 0xffff);
1108  parsePTL ( pcVPS->getPTL(), true, pcVPS->getMaxTLayers()-1);
1109#if H_MV
1110  pcVPS->getPTL()->inferGeneralValues ( true, 0, NULL );
1111  pcVPS->getPTL()->inferSubLayerValues( pcVPS->getMaxTLayers() - 1, 0, NULL );
1112#endif
1113  UInt subLayerOrderingInfoPresentFlag;
1114  READ_FLAG(subLayerOrderingInfoPresentFlag, "vps_sub_layer_ordering_info_present_flag");
1115  for(UInt i = 0; i <= pcVPS->getMaxTLayers()-1; i++)
1116  {
1117    READ_UVLC( uiCode,  "vps_max_dec_pic_buffering_minus1[i]" );     pcVPS->setMaxDecPicBuffering( uiCode + 1, i );
1118    READ_UVLC( uiCode,  "vps_num_reorder_pics[i]" );          pcVPS->setNumReorderPics( uiCode, i );
1119    READ_UVLC( uiCode,  "vps_max_latency_increase_plus1[i]" );      pcVPS->setMaxLatencyIncrease( uiCode, i );
1120
1121    if (!subLayerOrderingInfoPresentFlag)
1122    {
1123      for (i++; i <= pcVPS->getMaxTLayers()-1; i++)
1124      {
1125        pcVPS->setMaxDecPicBuffering(pcVPS->getMaxDecPicBuffering(0), i);
1126        pcVPS->setNumReorderPics(pcVPS->getNumReorderPics(0), i);
1127        pcVPS->setMaxLatencyIncrease(pcVPS->getMaxLatencyIncrease(0), i);
1128      }
1129      break;
1130    }
1131  }
1132
1133  assert( pcVPS->getNumHrdParameters() < MAX_VPS_OP_SETS_PLUS1 );
1134#if H_MV
1135  assert( pcVPS->getVpsMaxLayerId() < MAX_VPS_NUH_LAYER_ID_PLUS1 );
1136  READ_CODE( 6, uiCode, "vps_max_layer_id" );   pcVPS->setVpsMaxLayerId( uiCode );
1137
1138  READ_UVLC(    uiCode, "vps_num_layer_sets_minus1" );  pcVPS->setVpsNumLayerSetsMinus1( uiCode );
1139  for( UInt opsIdx = 1; opsIdx <= pcVPS->getVpsNumLayerSetsMinus1(); opsIdx ++ )
1140  {
1141    for( UInt i = 0; i <= pcVPS->getVpsMaxLayerId(); i ++ )
1142#else
1143  assert( pcVPS->getMaxNuhReservedZeroLayerId() < MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1 );
1144  READ_CODE( 6, uiCode, "vps_max_nuh_reserved_zero_layer_id" );   pcVPS->setMaxNuhReservedZeroLayerId( uiCode );
1145  READ_UVLC(    uiCode, "vps_max_op_sets_minus1" );               pcVPS->setMaxOpSets( uiCode + 1 );
1146  for( UInt opsIdx = 1; opsIdx <= ( pcVPS->getMaxOpSets() - 1 ); opsIdx ++ )
1147  {
1148    // Operation point set
1149    for( UInt i = 0; i <= pcVPS->getMaxNuhReservedZeroLayerId(); i ++ )
1150#endif
1151    {
1152      READ_FLAG( uiCode, "layer_id_included_flag[opsIdx][i]" );     pcVPS->setLayerIdIncludedFlag( uiCode == 1 ? true : false, opsIdx, i );
1153    }
1154  }
1155#if H_MV
1156  pcVPS->deriveLayerSetLayerIdList(); 
1157#endif
1158  TimingInfo *timingInfo = pcVPS->getTimingInfo();
1159  READ_FLAG(       uiCode, "vps_timing_info_present_flag");         timingInfo->setTimingInfoPresentFlag      (uiCode ? true : false);
1160  if(timingInfo->getTimingInfoPresentFlag())
1161  {
1162    READ_CODE( 32, uiCode, "vps_num_units_in_tick");                timingInfo->setNumUnitsInTick             (uiCode);
1163    READ_CODE( 32, uiCode, "vps_time_scale");                       timingInfo->setTimeScale                  (uiCode);
1164    READ_FLAG(     uiCode, "vps_poc_proportional_to_timing_flag");  timingInfo->setPocProportionalToTimingFlag(uiCode ? true : false);
1165    if(timingInfo->getPocProportionalToTimingFlag())
1166    {
1167      READ_UVLC(   uiCode, "vps_num_ticks_poc_diff_one_minus1");    timingInfo->setNumTicksPocDiffOneMinus1   (uiCode);
1168    }
1169    READ_UVLC( uiCode, "vps_num_hrd_parameters" );                  pcVPS->setNumHrdParameters( uiCode );
1170
1171    if( pcVPS->getNumHrdParameters() > 0 )
1172    {
1173      pcVPS->createHrdParamBuffer();
1174    }
1175    for( UInt i = 0; i < pcVPS->getNumHrdParameters(); i ++ )
1176    {
1177      READ_UVLC( uiCode, "hrd_op_set_idx" );                       pcVPS->setHrdOpSetIdx( uiCode, i );
1178      if( i > 0 )
1179      {
1180        READ_FLAG( uiCode, "cprms_present_flag[i]" );              pcVPS->setCprmsPresentFlag( uiCode == 1 ? true : false, i );
1181      }
1182      else
1183      {
1184        pcVPS->setCprmsPresentFlag( true, i );
1185      }
1186
1187      parseHrdParameters(pcVPS->getHrdParameters(i), pcVPS->getCprmsPresentFlag( i ), pcVPS->getMaxTLayers() - 1);
1188    }
1189  }
1190#if H_MV
1191  READ_FLAG( uiCode,  "vps_extension_flag" );                      pcVPS->setVpsExtensionFlag( uiCode == 1 ? true : false );
1192  if ( pcVPS->getVpsExtensionFlag() )
1193#else
1194  READ_FLAG( uiCode,  "vps_extension_flag" );
1195  if (uiCode)
1196#endif
1197  {
1198#if H_MV
1199    m_pcBitstream->readOutTrailingBits();
1200    parseVPSExtension( pcVPS );   
1201    READ_FLAG( uiCode,  "vps_extension2_flag" );
1202    if (uiCode)
1203    {
1204#if H_3D
1205      READ_FLAG( uiCode,  "vps_3d_extension_flag" );
1206      if ( uiCode )
1207      {
1208        m_pcBitstream->readOutTrailingBits();
1209        pcVPS->createCamPars(pcVPS->getNumViews());
1210        parseVPS3dExtension( pcVPS );   
1211      }
1212      READ_FLAG( uiCode,  "vps_extension3_flag" );
1213      if (uiCode)
1214      {     
1215#endif
1216#endif 
1217        while ( xMoreRbspData() )
1218        {
1219          READ_FLAG( uiCode, "vps_extension_data_flag");
1220        }
1221#if H_MV
1222#if H_3D
1223      }
1224#endif
1225    }
1226#endif
1227  }
1228  return; 
1229}
1230
1231#if H_MV
1232Void TDecCavlc::parseVPSExtension( TComVPS* pcVPS )
1233{
1234  UInt uiCode; 
1235
1236  if( pcVPS->getMaxLayersMinus1() > 0  &&  pcVPS->getVpsBaseLayerInternalFlag() )
1237  {
1238    parsePTL( pcVPS->getPTL( 1 ),0, pcVPS->getMaxSubLayersMinus1()  ); 
1239   
1240    pcVPS->getPTL( 1 )->inferGeneralValues ( false, 1, pcVPS->getPTL( 0 ) );
1241    pcVPS->getPTL( 1 )->inferSubLayerValues( pcVPS->getMaxSubLayersMinus1(), 1, pcVPS->getPTL( 0 ) );   
1242  }
1243
1244  READ_FLAG( uiCode, "splitting_flag" );                          pcVPS->setSplittingFlag( uiCode == 1 ? true : false );
1245
1246  for( Int sIdx = 0; sIdx < MAX_NUM_SCALABILITY_TYPES; sIdx++ )
1247  {
1248    READ_FLAG( uiCode,  "scalability_mask_flag[i]" );             pcVPS->setScalabilityMaskFlag( sIdx, uiCode == 1 ? true : false );     
1249  }
1250
1251  for( Int sIdx = 0; sIdx < pcVPS->getNumScalabilityTypes( ) - ( pcVPS->getSplittingFlag() ? 1 : 0 ); sIdx++ )
1252  {
1253    READ_CODE( 3, uiCode, "dimension_id_len_minus1[j]" );       pcVPS->setDimensionIdLen( sIdx, uiCode + 1 );
1254  }
1255
1256  if ( pcVPS->getSplittingFlag() )
1257  {
1258    pcVPS->setDimensionIdLen( pcVPS->getNumScalabilityTypes( ) - 1, pcVPS->inferLastDimsionIdLenMinus1() );       
1259  }
1260
1261  READ_FLAG( uiCode, "vps_nuh_layer_id_present_flag" );           pcVPS->setVpsNuhLayerIdPresentFlag( uiCode == 1 ? true : false );
1262
1263  for( Int i = 1; i <= pcVPS->getMaxLayersMinus1(); i++ )
1264  {
1265    if ( pcVPS->getVpsNuhLayerIdPresentFlag() )
1266    {
1267      READ_CODE( 6, uiCode, "layer_id_in_nuh[i]" );                pcVPS->setLayerIdInNuh( i, uiCode );
1268    }
1269    else
1270    {
1271      pcVPS->setLayerIdInNuh( i, i );; 
1272    }
1273
1274    pcVPS->setLayerIdInVps( pcVPS->getLayerIdInNuh( i ), i ); 
1275
1276    for( Int j = 0; j < pcVPS->getNumScalabilityTypes() ; j++ ) 
1277    {
1278      if ( !pcVPS->getSplittingFlag() )
1279      {
1280        READ_CODE( pcVPS->getDimensionIdLen( j ), uiCode, "dimension_id[i][j]" );  pcVPS->setDimensionId( i, j, uiCode );
1281      }
1282      else
1283      {
1284        pcVPS->setDimensionId( i, j, pcVPS->inferDimensionId( i, j)  );
1285      }
1286    }
1287  }
1288
1289  pcVPS->initNumViews(); 
1290
1291  READ_CODE( 4, uiCode, "view_id_len" ); pcVPS->setViewIdLen( uiCode );
1292
1293  if ( pcVPS->getViewIdLen( ) > 0 )
1294  {   
1295    for( Int i = 0; i < pcVPS->getNumViews(); i++ )
1296    {
1297      READ_CODE( pcVPS->getViewIdLen( ), uiCode, "view_id_val[i]" ); pcVPS->setViewIdVal( i, uiCode );
1298    }
1299  }
1300  else
1301  {
1302    for( Int i = 0; i < pcVPS->getNumViews(); i++ )
1303    {
1304      pcVPS->setViewIdVal( i, 0 ); 
1305    }
1306  }
1307
1308#if H_3D
1309  pcVPS->initViewCompLayer( ); 
1310#endif
1311
1312  for( Int i = 1; i <= pcVPS->getMaxLayersMinus1(); i++ )
1313  {
1314    for( Int j = 0; j < i; j++ )
1315    {
1316      READ_FLAG( uiCode, "direct_dependency_flag[i][j]" );             pcVPS->setDirectDependencyFlag( i, j, uiCode );
1317    }
1318  }
1319  pcVPS->setRefLayers(); 
1320
1321  if ( pcVPS->getNumIndependentLayers() > 1 ) 
1322  {
1323    READ_UVLC( uiCode, "num_add_layer_sets"      ); pcVPS->setNumAddLayerSets( uiCode );
1324  }
1325  for (Int i = 0; i < pcVPS->getNumAddLayerSets(); i++)
1326  {
1327    for (Int j = 1; j < pcVPS->getNumIndependentLayers(); j++)
1328    {
1329      READ_CODE( pcVPS->getHighestLayerIdxPlus1Len( j ) , uiCode, "highest_layer_idx_plus1" ); pcVPS->setHighestLayerIdxPlus1( i, j, uiCode );
1330    }
1331    pcVPS->deriveAddLayerSetLayerIdList( i );
1332  }
1333
1334  READ_FLAG( uiCode, "vps_sub_layers_max_minus1_present_flag" ); pcVPS->setVpsSubLayersMaxMinus1PresentFlag( uiCode == 1 );
1335  if ( pcVPS->getVpsSubLayersMaxMinus1PresentFlag() )
1336  {
1337    for (Int i = 0; i <= pcVPS->getMaxLayersMinus1(); i++ )
1338    {
1339      READ_CODE( 3, uiCode, "sub_layers_vps_max_minus1" ); pcVPS->setSubLayersVpsMaxMinus1( i, uiCode );   
1340      pcVPS->checkSubLayersVpsMaxMinus1( i ); 
1341    }
1342  } 
1343  else
1344  {
1345    for (Int i = 0; i <= pcVPS->getMaxLayersMinus1(); i++ )
1346    {
1347      pcVPS->setSubLayersVpsMaxMinus1( i, pcVPS->getMaxTLayers( ) - 1);   
1348    }
1349  }
1350  READ_FLAG( uiCode, "max_tid_ref_present_flag" ); pcVPS->setMaxTidRefPresentFlag( uiCode == 1 );
1351
1352  if ( pcVPS->getMaxTidRefPresentFlag() )
1353  {   
1354    for( Int i = 0; i < pcVPS->getMaxLayersMinus1(); i++ )
1355    {
1356      for( Int j = i + 1; j <= pcVPS->getMaxLayersMinus1(); j++ )
1357      {
1358        if ( pcVPS->getDirectDependencyFlag(j,i) )
1359        {
1360          READ_CODE( 3, uiCode, "max_tid_il_ref_pics_plus1" ); pcVPS->setMaxTidIlRefPicsPlus1( i, j, uiCode );
1361        }
1362      }
1363    }
1364  }
1365
1366  READ_FLAG( uiCode, "all_ref_layers_active_flag" );             pcVPS->setAllRefLayersActiveFlag( uiCode == 1 );
1367  READ_UVLC( uiCode, "vps_num_profile_tier_level_minus1" );  pcVPS->setVpsNumProfileTierLevelMinus1( uiCode ); 
1368
1369  Int offsetVal =  ( pcVPS->getMaxLayersMinus1() > 0  &&  pcVPS->getVpsBaseLayerInternalFlag() ) ? 2 : 1;   
1370  for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 2 : 1; i <= pcVPS->getVpsNumProfileTierLevelMinus1(); i++ )
1371  {
1372    READ_FLAG(  uiCode, "vps_profile_present_flag[i]" );    pcVPS->setVpsProfilePresentFlag( i, uiCode == 1 );
1373    parsePTL ( pcVPS->getPTL( offsetVal ), pcVPS->getVpsProfilePresentFlag( i ), pcVPS->getMaxTLayers()-1);
1374    pcVPS->getPTL( offsetVal )->inferGeneralValues ( pcVPS->getVpsProfilePresentFlag( i ), offsetVal, pcVPS->getPTL( offsetVal - 1 ) );   
1375    pcVPS->getPTL( offsetVal )->inferSubLayerValues( pcVPS->getMaxSubLayersMinus1()      , offsetVal, pcVPS->getPTL( offsetVal - 1 ) );   
1376    offsetVal++;
1377  }
1378
1379
1380  if (pcVPS->getNumLayerSets() > 1)
1381  {
1382    READ_UVLC( uiCode, "num_add_olss" ); pcVPS->setNumAddOlss( uiCode );
1383    READ_CODE( 2, uiCode, "default_output_layer_idc" ); pcVPS->setDefaultOutputLayerIdc( std::min( uiCode, (UInt) 2 ) );   
1384  }
1385
1386  pcVPS->initTargetLayerIdLists( ); 
1387
1388
1389  pcVPS->setOutputLayerFlag(0, 0, pcVPS->inferOutputLayerFlag( 0, 0 )); 
1390  pcVPS->setLayerSetIdxForOlsMinus1(0, -1); 
1391
1392  pcVPS->deriveNecessaryLayerFlags( 0 ); 
1393  pcVPS->deriveTargetLayerIdList( 0 ); 
1394
1395  if (pcVPS->getVpsBaseLayerInternalFlag() )
1396  { 
1397    pcVPS->setProfileTierLevelIdx(0,0, pcVPS->inferProfileTierLevelIdx(0,0) );
1398  }
1399  for( Int i = 1; i < pcVPS->getNumOutputLayerSets( ); i++ )
1400  {
1401    if( pcVPS->getNumLayerSets() > 2 && i >= pcVPS->getNumLayerSets( ) )   
1402    {       
1403      READ_CODE( pcVPS->getLayerSetIdxForOlsMinus1Len( i ), uiCode, "layer_set_idx_for_ols_minus1[i]" ); pcVPS->setLayerSetIdxForOlsMinus1( i, uiCode ); 
1404    }
1405
1406    if ( i > pcVPS->getVpsNumLayerSetsMinus1() || pcVPS->getDefaultOutputLayerIdc() == 2 )
1407    {       
1408      for( Int j = 0; j < pcVPS->getNumLayersInIdList( pcVPS->olsIdxToLsIdx( i ) ); j++ )
1409      {
1410        READ_FLAG( uiCode, "output_layer_flag" ); pcVPS->setOutputLayerFlag( i, j, uiCode == 1 ); 
1411      }
1412    }
1413    else
1414    { 
1415      for( Int j = 0; j < pcVPS->getNumLayersInIdList( pcVPS->olsIdxToLsIdx( i ) ); j++ )
1416      {             
1417        pcVPS->setOutputLayerFlag(i,j, pcVPS->inferOutputLayerFlag( i, j )); 
1418      }
1419    }
1420    pcVPS->deriveNecessaryLayerFlags( i ); 
1421    pcVPS->deriveTargetLayerIdList( i ); 
1422
1423    for ( Int j = 0; j < pcVPS->getNumLayersInIdList( pcVPS->olsIdxToLsIdx(i)); j++ )
1424    {   
1425      if (pcVPS->getNecessaryLayerFlag( i, j ) && pcVPS->getVpsNumProfileTierLevelMinus1() > 0 )
1426      {
1427        READ_CODE( pcVPS->getProfileTierLevelIdxLen(), uiCode,"profile_tier_level_idx[ i ][ j ]" );   pcVPS->setProfileTierLevelIdx( i, j, uiCode ); 
1428      }
1429      if (pcVPS->getNecessaryLayerFlag( i, j ) && pcVPS->getVpsNumProfileTierLevelMinus1() == 0 )
1430      {
1431        pcVPS->setProfileTierLevelIdx( i , j, pcVPS->inferProfileTierLevelIdx( i, j) );
1432      }
1433    }
1434
1435    if( pcVPS->getNumOutputLayersInOutputLayerSet( i ) == 1 && pcVPS->getNumDirectRefLayers( pcVPS->getOlsHighestOutputLayerId( i ) ) > 0 )
1436    {
1437      READ_FLAG( uiCode, "alt_output_layer_flag[ i ]" ); pcVPS->setAltOutputLayerFlag( i, uiCode == 1 );
1438    }
1439  }
1440
1441  READ_UVLC( uiCode, "vps_num_rep_formats_minus1" ); pcVPS->setVpsNumRepFormatsMinus1( uiCode );
1442
1443  for (Int i = 0; i <= pcVPS->getVpsNumRepFormatsMinus1(); i++ )
1444  { 
1445    assert( pcVPS->getRepFormat(i) == NULL ); 
1446    TComRepFormat* curRepFormat = new TComRepFormat(); 
1447    TComRepFormat* prevRepFormat = i > 0 ? pcVPS->getRepFormat( i - 1) : NULL; 
1448    parseRepFormat( i, curRepFormat ,  prevRepFormat); 
1449    pcVPS->setRepFormat(i, curRepFormat ); 
1450  }
1451
1452  if ( pcVPS->getVpsNumRepFormatsMinus1() > 0 )
1453  {
1454    READ_FLAG( uiCode, "rep_format_idx_present_flag" ); pcVPS->setRepFormatIdxPresentFlag( uiCode == 1 );
1455  }
1456  if( pcVPS->getRepFormatIdxPresentFlag() ) 
1457  {
1458    for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 1 : 0; i <=  pcVPS->getMaxLayersMinus1(); i++ )
1459    {
1460      READ_CODE( pcVPS->getVpsRepFormatIdxLen(), uiCode, "vps_rep_format_idx[i]" ); pcVPS->setVpsRepFormatIdx( i, uiCode );
1461    }
1462  }
1463  else
1464  {
1465    for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 1 : 0; i <=  pcVPS->getMaxLayersMinus1(); i++ )
1466    {
1467      pcVPS->setVpsRepFormatIdx( i, pcVPS->inferVpsRepFormatIdx( i ) );
1468    }
1469  }
1470
1471  READ_FLAG( uiCode, "max_one_active_ref_layer_flag" ); pcVPS->setMaxOneActiveRefLayerFlag ( uiCode == 1 ); 
1472
1473  READ_FLAG( uiCode, "vps_poc_lsb_aligned_flag" ); pcVPS->setVpsPocLsbAlignedFlag( uiCode == 1 );
1474  for( Int i = 1; i  <=  pcVPS->getMaxLayersMinus1(); i++ )
1475  {
1476    if( pcVPS->getNumDirectRefLayers( pcVPS->getLayerIdInNuh( i ) )  ==  0 )
1477    {     
1478      READ_FLAG( uiCode, "poc_lsb_not_present_flag" ); pcVPS->setPocLsbNotPresentFlag( i, uiCode == 1 );
1479    }
1480  }
1481
1482  parseDpbSize( pcVPS ); 
1483
1484  READ_UVLC( uiCode, "direct_dep_type_len_minus2")    ; pcVPS->setDirectDepTypeLenMinus2   ( uiCode ); 
1485
1486  READ_FLAG( uiCode, "default_direct_dependency_flag" ); pcVPS->setDefaultDirectDependencyFlag( uiCode == 1 );
1487  if ( pcVPS->getDefaultDirectDependencyFlag( ) )
1488  { 
1489    READ_CODE( pcVPS->getDirectDepTypeLenMinus2( ) + 2, uiCode, "default_direct_dependency_type" ); pcVPS->setDefaultDirectDependencyType( uiCode );
1490  }
1491
1492  for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ?  1 : 2; i <= pcVPS->getMaxLayersMinus1(); i++ )
1493  {
1494    for( Int j = pcVPS->getVpsBaseLayerInternalFlag() ?  0 : 1; j < i; j++ )
1495    {
1496      if (pcVPS->getDirectDependencyFlag( i, j) )
1497      {       
1498        if ( pcVPS->getDefaultDirectDependencyFlag( ) )
1499        { 
1500          pcVPS->setDirectDependencyType( i, j , pcVPS->getDefaultDirectDependencyType( ) );
1501        }
1502        else
1503        {
1504
1505          READ_CODE( pcVPS->getDirectDepTypeLenMinus2( ) + 2,  uiCode, "direct_dependency_type[i][j]" ); pcVPS->setDirectDependencyType( i, j , uiCode);
1506        }
1507      }
1508    }
1509  } 
1510  READ_UVLC( uiCode, "vps_non_vui_extension_length" ); pcVPS->setVpsNonVuiExtensionLength( uiCode ); 
1511  for ( Int i = 1; i <= pcVPS->getVpsNonVuiExtensionLength(); i++ )
1512  {
1513    READ_CODE( 8, uiCode, "vps_non_vui_extension_data_byte" );
1514  }
1515  READ_FLAG( uiCode, "vps_vui_present_flag" );  pcVPS->setVpsVuiPresentFlag( uiCode == 1 );
1516  if( pcVPS->getVpsVuiPresentFlag() )
1517  {
1518    m_pcBitstream->readOutTrailingBits(); // vps_vui_alignment_bit_equal_to_one
1519    parseVPSVUI( pcVPS ); 
1520  }     
1521  else
1522  {
1523    TComVPSVUI* pcVPSVUI = pcVPS->getVPSVUI( ); 
1524    assert( pcVPSVUI ); 
1525    pcVPSVUI->inferVpsVui( false ); 
1526  }
1527  pcVPS->checkVPSExtensionSyntax(); 
1528}
1529
1530Void TDecCavlc::parseRepFormat( Int i, TComRepFormat* pcRepFormat, TComRepFormat* pcPrevRepFormat )
1531{
1532  assert( pcRepFormat ); 
1533
1534  UInt uiCode; 
1535
1536  READ_CODE( 16, uiCode, "pic_width_vps_in_luma_samples" );  pcRepFormat->setPicWidthVpsInLumaSamples ( uiCode );
1537  READ_CODE( 16, uiCode, "pic_height_vps_in_luma_samples" ); pcRepFormat->setPicHeightVpsInLumaSamples( uiCode );
1538  READ_FLAG( uiCode, "chroma_and_bit_depth_vps_present_flag" ); pcRepFormat->setChromaAndBitDepthVpsPresentFlag( uiCode == 1 );
1539
1540  pcRepFormat->checkChromaAndBitDepthVpsPresentFlag( i ); 
1541
1542  if ( pcRepFormat->getChromaAndBitDepthVpsPresentFlag() )
1543  { 
1544    READ_CODE( 2,  uiCode, "chroma_format_vps_idc" );          pcRepFormat->setChromaFormatVpsIdc       ( uiCode );
1545    if ( pcRepFormat->getChromaFormatVpsIdc() == 3 )
1546    {
1547      READ_FLAG( uiCode, "separate_colour_plane_vps_flag" ); pcRepFormat->setSeparateColourPlaneVpsFlag( uiCode == 1 ); 
1548    }
1549    READ_CODE( 4,  uiCode, "bit_depth_vps_luma_minus8" );      pcRepFormat->setBitDepthVpsLumaMinus8    ( uiCode );
1550    READ_CODE( 4,  uiCode, "bit_depth_vps_chroma_minus8" );    pcRepFormat->setBitDepthVpsChromaMinus8  ( uiCode );
1551  }
1552  else
1553  {
1554    pcRepFormat->inferChromaAndBitDepth(pcPrevRepFormat, false ); 
1555  }
1556  READ_FLAG( uiCode, "conformance_window_vps_flag" ); pcRepFormat->setConformanceWindowVpsFlag( uiCode == 1 );
1557  if ( pcRepFormat->getConformanceWindowVpsFlag() )
1558  {
1559    READ_UVLC( uiCode, "conf_win_vps_left_offset" ); pcRepFormat->setConfWinVpsLeftOffset( uiCode );
1560    READ_UVLC( uiCode, "conf_win_vps_right_offset" ); pcRepFormat->setConfWinVpsRightOffset( uiCode );
1561    READ_UVLC( uiCode, "conf_win_vps_top_offset" ); pcRepFormat->setConfWinVpsTopOffset( uiCode );
1562    READ_UVLC( uiCode, "conf_win_vps_bottom_offset" ); pcRepFormat->setConfWinVpsBottomOffset( uiCode );
1563  }
1564}
1565
1566
1567Void TDecCavlc::parseVPSVUI( TComVPS* pcVPS )
1568{
1569  assert( pcVPS ); 
1570
1571  TComVPSVUI* pcVPSVUI = pcVPS->getVPSVUI( ); 
1572
1573  assert( pcVPSVUI ); 
1574
1575  UInt uiCode; 
1576  READ_FLAG( uiCode, "cross_layer_pic_type_aligned_flag" ); pcVPSVUI->setCrossLayerPicTypeAlignedFlag( uiCode == 1 );
1577  if ( !pcVPSVUI->getCrossLayerPicTypeAlignedFlag() )
1578  { 
1579    READ_FLAG( uiCode, "cross_layer_irap_aligned_flag" ); pcVPSVUI->setCrossLayerIrapAlignedFlag( uiCode == 1 );
1580  }
1581  if( pcVPSVUI->getCrossLayerIrapAlignedFlag( ) )
1582  {
1583    READ_FLAG( uiCode, "all_layers_idr_aligned_flag" ); pcVPSVUI->setAllLayersIdrAlignedFlag( uiCode == 1 );
1584  }
1585  READ_FLAG( uiCode, "bit_rate_present_vps_flag" ); pcVPSVUI->setBitRatePresentVpsFlag( uiCode == 1 );
1586  READ_FLAG( uiCode, "pic_rate_present_vps_flag" ); pcVPSVUI->setPicRatePresentVpsFlag( uiCode == 1 );
1587  if( pcVPSVUI->getBitRatePresentVpsFlag( )  ||  pcVPSVUI->getPicRatePresentVpsFlag( ) )
1588  {
1589    for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i  <  pcVPS->getNumLayerSets(); i++ )
1590    {
1591      for( Int j = 0; j  <=  pcVPS->getMaxSubLayersInLayerSetMinus1( i ); j++ ) 
1592      {
1593        if( pcVPSVUI->getBitRatePresentVpsFlag( ) )
1594        {
1595          READ_FLAG( uiCode, "bit_rate_present_flag" ); pcVPSVUI->setBitRatePresentFlag( i, j, uiCode == 1 );           
1596        }
1597        if( pcVPSVUI->getPicRatePresentVpsFlag( )  )
1598        {
1599          READ_FLAG( uiCode, "pic_rate_present_flag" ); pcVPSVUI->setPicRatePresentFlag( i, j, uiCode == 1 );
1600        }
1601        if( pcVPSVUI->getBitRatePresentFlag( i, j ) )
1602        {
1603          READ_CODE( 16, uiCode, "avg_bit_rate" ); pcVPSVUI->setAvgBitRate( i, j, uiCode );
1604          READ_CODE( 16, uiCode, "max_bit_rate" ); pcVPSVUI->setMaxBitRate( i, j, uiCode );
1605        }
1606        if( pcVPSVUI->getPicRatePresentFlag( i, j ) )
1607        {
1608          READ_CODE( 2,  uiCode, "constant_pic_rate_idc" ); pcVPSVUI->setConstantPicRateIdc( i, j, uiCode );
1609          READ_CODE( 16, uiCode, "avg_pic_rate" );          pcVPSVUI->setAvgPicRate( i, j, uiCode );
1610        }
1611      }
1612    }
1613  }
1614
1615  READ_FLAG( uiCode, "video_signal_info_idx_present_flag" ); pcVPSVUI->setVideoSignalInfoIdxPresentFlag( uiCode == 1 );
1616  if( pcVPSVUI->getVideoSignalInfoIdxPresentFlag() )
1617  {
1618    READ_CODE( 4, uiCode, "vps_num_video_signal_info_minus1" ); pcVPSVUI->setVpsNumVideoSignalInfoMinus1( uiCode );
1619  }
1620  else
1621  {
1622    pcVPSVUI->setVpsNumVideoSignalInfoMinus1( pcVPS->getMaxLayersMinus1() - pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1 ); 
1623  }
1624
1625  for( Int i = 0; i <= pcVPSVUI->getVpsNumVideoSignalInfoMinus1(); i++ )
1626  {
1627    assert( pcVPSVUI->getVideoSignalInfo( i ) == NULL ); 
1628    TComVideoSignalInfo* curVideoSignalInfo = new TComVideoSignalInfo();     
1629    parseVideoSignalInfo( curVideoSignalInfo ); 
1630    pcVPSVUI->setVideoSignalInfo(i, curVideoSignalInfo ); 
1631  }
1632
1633  if( pcVPSVUI->getVideoSignalInfoIdxPresentFlag() && pcVPSVUI->getVpsNumVideoSignalInfoMinus1() > 0 )
1634  {
1635    for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i <=  pcVPS->getMaxLayersMinus1(); i++ )
1636    {
1637      READ_CODE( 4, uiCode, "vps_video_signal_info_idx" ); pcVPSVUI->setVpsVideoSignalInfoIdx( i, uiCode );
1638    }
1639  }
1640  else if ( !pcVPSVUI->getVideoSignalInfoIdxPresentFlag() )
1641  {
1642    for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i <=  pcVPS->getMaxLayersMinus1(); i++ )
1643    {
1644      pcVPSVUI->setVpsVideoSignalInfoIdx( i, i );
1645    }
1646  }
1647  else
1648  {
1649    for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i <=  pcVPS->getMaxLayersMinus1(); i++ )
1650    {
1651      pcVPSVUI->setVpsVideoSignalInfoIdx( i, 0 );
1652    }
1653  }
1654
1655  READ_FLAG( uiCode, "tiles_not_in_use_flag" ); pcVPSVUI->setTilesNotInUseFlag( uiCode == 1 );
1656  if( !pcVPSVUI->getTilesNotInUseFlag() ) 
1657  {     
1658    for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i  <=  pcVPS->getMaxLayersMinus1(); i++ )
1659    {
1660      READ_FLAG( uiCode, "tiles_in_use_flag[i]" ); pcVPSVUI->setTilesInUseFlag( i, uiCode == 1 );
1661      if( pcVPSVUI->getTilesInUseFlag( i ) ) 
1662      {
1663        READ_FLAG( uiCode, "loop_filter_not_across_tiles_flag[i]" ); pcVPSVUI->setLoopFilterNotAcrossTilesFlag( i, uiCode == 1 );
1664      }
1665    } 
1666    for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 1 : 2; i  <=  pcVPS->getMaxLayersMinus1(); i++ ) 
1667    {
1668      for( Int j = 0; j < pcVPS->getNumDirectRefLayers( pcVPS->getLayerIdInNuh( i ) ) ; j++ )
1669      {
1670        Int layerIdx = pcVPS->getLayerIdInVps(pcVPS->getIdDirectRefLayer(pcVPS->getLayerIdInNuh( i ) , j  )); 
1671        if( pcVPSVUI->getTilesInUseFlag( i )  &&  pcVPSVUI->getTilesInUseFlag( layerIdx ) ) 
1672        {
1673          READ_FLAG( uiCode, "tile_boundaries_aligned_flag[i][j]" ); pcVPSVUI->setTileBoundariesAlignedFlag( i, j, uiCode == 1 );
1674        }
1675      } 
1676    }
1677  } 
1678 
1679  READ_FLAG( uiCode, "wpp_not_in_use_flag" ); pcVPSVUI->setWppNotInUseFlag( uiCode == 1 );
1680 
1681  if( !pcVPSVUI->getWppNotInUseFlag( ))
1682  {
1683    for( Int i = 0; i  <=  pcVPS->getMaxLayersMinus1(); i++ ) 
1684    {
1685      READ_FLAG( uiCode, "wpp_in_use_flag[i]" ); pcVPSVUI->setWppInUseFlag( i, uiCode == 1 );
1686    }
1687  }
1688  READ_FLAG( uiCode, "single_layer_for_non_irap_flag" ); pcVPSVUI->setSingleLayerForNonIrapFlag( uiCode == 1 );
1689  READ_FLAG( uiCode, "higher_layer_irap_skip_flag" ); pcVPSVUI->setHigherLayerIrapSkipFlag( uiCode == 1 );
1690  READ_FLAG( uiCode, "ilp_restricted_ref_layers_flag" ); pcVPSVUI->setIlpRestrictedRefLayersFlag( uiCode == 1 );
1691
1692  if( pcVPSVUI->getIlpRestrictedRefLayersFlag( ) )
1693  {
1694    for( Int i = 1; i  <=  pcVPS->getMaxLayersMinus1(); i++ )
1695    {
1696      for( Int j = 0; j < pcVPS->getNumDirectRefLayers( pcVPS->getLayerIdInNuh( i ) ); j++ )
1697      {
1698        if( pcVPS->getVpsBaseLayerInternalFlag() || pcVPS->getIdDirectRefLayer( pcVPS->getLayerIdInNuh( i ), j ) > 0 )
1699        {       
1700          READ_UVLC( uiCode, "min_spatial_segment_offset_plus1" ); pcVPSVUI->setMinSpatialSegmentOffsetPlus1( i, j, uiCode );
1701          if( pcVPSVUI->getMinSpatialSegmentOffsetPlus1( i, j ) > 0 )
1702          {
1703            READ_FLAG( uiCode, "ctu_based_offset_enabled_flag" ); pcVPSVUI->setCtuBasedOffsetEnabledFlag( i, j, uiCode == 1 );
1704            if( pcVPSVUI->getCtuBasedOffsetEnabledFlag( i, j ) )
1705            {
1706              READ_UVLC( uiCode, "min_horizontal_ctu_offset_plus1" ); pcVPSVUI->setMinHorizontalCtuOffsetPlus1( i, j, uiCode );
1707            }
1708          }
1709        }
1710      }
1711    }
1712  }
1713
1714  READ_FLAG( uiCode, "vps_vui_bsp_hrd_present_flag" ); pcVPSVUI->setVpsVuiBspHrdPresentFlag( uiCode == 1 );
1715  if ( pcVPSVUI->getVpsVuiBspHrdPresentFlag( ) )
1716  {
1717    assert(pcVPS->getTimingInfo()->getTimingInfoPresentFlag() == 1);
1718    parseVpsVuiBspHrdParameters( pcVPS ); 
1719  }
1720  for( Int i = 1; i  <=  pcVPS->getMaxLayersMinus1(); i++ )
1721  {
1722    if( pcVPS->getNumDirectRefLayers( pcVPS->getLayerIdInNuh( i )) == 0 ) 
1723    {
1724      READ_FLAG( uiCode, "base_layer_parameter_set_compatibility_flag" ); pcVPSVUI->setBaseLayerParameterSetCompatibilityFlag( i, uiCode == 1 );
1725    }
1726  }
1727}
1728
1729Void TDecCavlc::parseVpsVuiBspHrdParameters( TComVPS* pcVPS )
1730{
1731  assert( pcVPS ); 
1732
1733  TComVPSVUI* pcVPSVUI = pcVPS->getVPSVUI( ); 
1734
1735  assert( pcVPSVUI ); 
1736
1737  TComVpsVuiBspHrdParameters*  vpsVuiBspHrdP = pcVPSVUI->getVpsVuiBspHrdParameters(); 
1738  assert( vpsVuiBspHrdP == NULL ); 
1739  vpsVuiBspHrdP = new TComVpsVuiBspHrdParameters; 
1740  pcVPSVUI->setVpsVuiBspHrdParameters( vpsVuiBspHrdP ); 
1741  UInt uiCode; 
1742  READ_UVLC( uiCode, "vps_num_add_hrd_params" ); vpsVuiBspHrdP->setVpsNumAddHrdParams( uiCode );
1743  vpsVuiBspHrdP->createAfterVpsNumAddHrdParams( pcVPS ); 
1744  for( Int i = pcVPS->getNumHrdParameters(); i < pcVPS->getNumHrdParameters() + vpsVuiBspHrdP->getVpsNumAddHrdParams(); i++ )
1745  { 
1746    if( i > 0 ) 
1747    {
1748      READ_FLAG( uiCode, "cprms_add_present_flag" ); vpsVuiBspHrdP->setCprmsAddPresentFlag( i, uiCode == 1 );
1749    }
1750    else
1751    {
1752       vpsVuiBspHrdP->setCprmsAddPresentFlag( i, true );
1753    }
1754
1755    READ_UVLC( uiCode, "num_sub_layer_hrd_minus1" ); vpsVuiBspHrdP->setNumSubLayerHrdMinus1( i, uiCode );
1756    TComHRD* hrdParameters = vpsVuiBspHrdP->getHrdParametermeters( i ); 
1757    parseHrdParameters( hrdParameters, vpsVuiBspHrdP->getCprmsAddPresentFlag( i ), vpsVuiBspHrdP->getNumSubLayerHrdMinus1( i ) );     
1758  }
1759
1760  vpsVuiBspHrdP->setNumPartitionsInSchemeMinus1( 0, 0, 0);
1761  vpsVuiBspHrdP->createAfterNumPartitionsInSchemeMinus1( 0, 0 );
1762
1763  for( Int h = 0; h < pcVPS->getNumOutputLayerSets(); h++ )
1764  { 
1765    if ( h == 0)
1766    {
1767      vpsVuiBspHrdP->setNumSignalledPartitioningSchemes( h, 0 );
1768    }
1769    else
1770    {
1771      READ_UVLC( uiCode, "num_signalled_partitioning_schemes" ); vpsVuiBspHrdP->setNumSignalledPartitioningSchemes( h, uiCode );
1772    }   
1773    vpsVuiBspHrdP->createAfterNumSignalledPartitioningSchemes( h );
1774
1775    for( Int j = 0; j < vpsVuiBspHrdP->getNumSignalledPartitioningSchemes( h ) + 1; j++ )
1776    { 
1777      if ( j == 0 && h == 0 )
1778      {
1779        vpsVuiBspHrdP->setNumPartitionsInSchemeMinus1( h, j, uiCode );
1780      }
1781      else if( j == 0 )
1782      {
1783        vpsVuiBspHrdP->setNumPartitionsInSchemeMinus1( h, j, pcVPS->getNumLayersInIdList( h ) - 1 );
1784      }
1785      else
1786      {
1787        READ_UVLC( uiCode, "num_partitions_in_scheme_minus1" ); vpsVuiBspHrdP->setNumPartitionsInSchemeMinus1( h, j, uiCode );
1788      }
1789      vpsVuiBspHrdP->createAfterNumPartitionsInSchemeMinus1( h, j );
1790
1791      for( Int k = 0; k  <=  vpsVuiBspHrdP->getNumPartitionsInSchemeMinus1( h, j ); k++ ) 
1792      {
1793        for( Int r = 0; r < pcVPS->getNumLayersInIdList(pcVPS->olsIdxToLsIdx( h ) )   ; r++ ) 
1794        {
1795          if( h == 0 && j == 0 && k == 0 && r == 0 )
1796          {
1797             vpsVuiBspHrdP->setLayerIncludedInPartitionFlag( h, j, k, r, true );
1798          }
1799          else if ( h > 0 && j == 0 )
1800          {
1801             vpsVuiBspHrdP->setLayerIncludedInPartitionFlag( h, j, k, r, (k == r) );
1802          }
1803          else
1804          {
1805            READ_FLAG( uiCode, "layer_included_in_partition_flag" ); vpsVuiBspHrdP->setLayerIncludedInPartitionFlag( h, j, k, r, uiCode == 1 );
1806          }         
1807        }
1808      }
1809    } 
1810    if ( h > 0 )
1811    {
1812      for( Int i = 0; i < vpsVuiBspHrdP->getNumSignalledPartitioningSchemes( h ) + 1; i++ ) 
1813      {
1814        for( Int t = 0; t  <=  pcVPS->getMaxSubLayersInLayerSetMinus1( pcVPS->olsIdxToLsIdx( i ) ); t++ )
1815        { 
1816          READ_UVLC( uiCode, "num_bsp_schedules_minus1" ); vpsVuiBspHrdP->setNumBspSchedulesMinus1( h, i, t, uiCode );
1817          vpsVuiBspHrdP->createAfterNumBspSchedulesMinus1( h, i, t );
1818          for( Int j = 0; j  <=  vpsVuiBspHrdP->getNumBspSchedulesMinus1( h, i, t ); j++ ) 
1819          {
1820            for( Int k = 0; k  <=  vpsVuiBspHrdP->getNumPartitionsInSchemeMinus1( h, j ); k++ )
1821            { 
1822              READ_CODE( vpsVuiBspHrdP->getBspHrdIdxLen( pcVPS ), uiCode, "bsp_hrd_idx" ); vpsVuiBspHrdP->setBspHrdIdx( h, i, t, j, k, uiCode );
1823              READ_UVLC( uiCode, "bsp_sched_idx" ); vpsVuiBspHrdP->setBspSchedIdx( h, i, t, j, k, uiCode );
1824            } 
1825          }
1826        } 
1827      }
1828    }
1829  } 
1830}
1831
1832Void TDecCavlc::parseVideoSignalInfo( TComVideoSignalInfo* pcVideoSignalInfo ) 
1833{
1834  UInt uiCode; 
1835  READ_CODE( 3, uiCode, "video_vps_format" );             pcVideoSignalInfo->setVideoVpsFormat( uiCode );
1836  READ_FLAG( uiCode, "video_full_range_vps_flag" );       pcVideoSignalInfo->setVideoFullRangeVpsFlag( uiCode == 1 );
1837  READ_CODE( 8, uiCode, "colour_primaries_vps" );         pcVideoSignalInfo->setColourPrimariesVps( uiCode );
1838  READ_CODE( 8, uiCode, "transfer_characteristics_vps" ); pcVideoSignalInfo->setTransferCharacteristicsVps( uiCode );
1839  READ_CODE( 8, uiCode, "matrix_coeffs_vps" );            pcVideoSignalInfo->setMatrixCoeffsVps( uiCode );
1840}
1841
1842Void TDecCavlc::parseDpbSize( TComVPS* vps )
1843{
1844  UInt uiCode; 
1845  TComDpbSize* dpbSize = vps->getDpbSize(); 
1846  assert ( dpbSize != 0 ); 
1847
1848  for( Int i = 1; i < vps->getNumOutputLayerSets(); i++ )
1849  { 
1850    Int currLsIdx = vps->olsIdxToLsIdx( i ); 
1851    READ_FLAG( uiCode, "sub_layer_flag_info_present_flag" ); dpbSize->setSubLayerFlagInfoPresentFlag( i, uiCode == 1 );
1852    for( Int j = 0; j  <=  vps->getMaxSubLayersInLayerSetMinus1( currLsIdx ); j++ )
1853    { 
1854      if( j > 0  &&  dpbSize->getSubLayerDpbInfoPresentFlag( i, j )  ) 
1855      {
1856        READ_FLAG( uiCode, "sub_layer_dpb_info_present_flag" ); dpbSize->setSubLayerDpbInfoPresentFlag( i, j, uiCode == 1 );
1857      }
1858      if( dpbSize->getSubLayerDpbInfoPresentFlag( i, j ) )
1859      { 
1860        for( Int k = 0; k < vps->getNumLayersInIdList( currLsIdx ); k++ )   
1861        {
1862          if ( vps->getNecessaryLayerFlag( i, k ) && ( vps->getVpsBaseLayerInternalFlag() || ( vps->getLayerSetLayerIdList(vps->olsIdxToLsIdx(i),k) != 0 ) ))
1863          {
1864            READ_UVLC( uiCode, "max_vps_dec_pic_buffering_minus1" ); dpbSize->setMaxVpsDecPicBufferingMinus1( i, k, j, uiCode );
1865          }
1866          else
1867          {
1868            if ( vps->getNecessaryLayerFlag( i, k ) && ( j == 0 ) && ( k == 0 ))
1869            {
1870              dpbSize->setMaxVpsDecPicBufferingMinus1(i ,k, j, 0 );
1871            }
1872          }
1873        }
1874        READ_UVLC( uiCode, "max_vps_num_reorder_pics" ); dpbSize->setMaxVpsNumReorderPics( i, j, uiCode );
1875        READ_UVLC( uiCode, "max_vps_latency_increase_plus1" ); dpbSize->setMaxVpsLatencyIncreasePlus1( i, j, uiCode );
1876      }
1877      else
1878      {
1879        if ( j > 0 )
1880        {
1881          for( Int k = 0; k < vps->getNumLayersInIdList( vps->olsIdxToLsIdx( i ) ); k++ )   
1882          {
1883            if ( vps->getNecessaryLayerFlag(i, k ) )
1884            {           
1885              dpbSize->setMaxVpsDecPicBufferingMinus1( i, k, j, dpbSize->getMaxVpsDecPicBufferingMinus1( i,k, j - 1 ) );
1886            }
1887          }
1888          dpbSize->setMaxVpsNumReorderPics      ( i, j, dpbSize->getMaxVpsNumReorderPics      ( i, j - 1 ) );
1889          dpbSize->setMaxVpsLatencyIncreasePlus1( i, j, dpbSize->getMaxVpsLatencyIncreasePlus1( i, j - 1 ) );
1890        }
1891      }
1892    } 
1893  } 
1894}
1895
1896#if H_3D
1897Void TDecCavlc::parseVPS3dExtension( TComVPS* pcVPS )
1898{
1899  UInt uiCode;   
1900  READ_UVLC( uiCode, "cp_precision"); pcVPS->setCpPrecision( uiCode ) ;
1901 
1902  for (Int n = 1; n < pcVPS->getNumViews(); n++)
1903  {
1904    Int i      = pcVPS->getViewOIdxList( n );
1905    Int iInVps = pcVPS->getVoiInVps( i ); 
1906    READ_CODE( 6, uiCode, "num_cp" ); pcVPS->setNumCp( iInVps, uiCode );
1907
1908    if( pcVPS->getNumCp( iInVps ) > 0 )
1909    {
1910      READ_FLAG( uiCode, "cp_in_slice_segment_header_flag" ); pcVPS->setCpInSliceSegmentHeaderFlag( iInVps, uiCode == 1 );
1911      for( Int m = 0; m < pcVPS->getNumCp( iInVps ); m++ )
1912      {
1913        READ_UVLC( uiCode, "cp_ref_voi" ); pcVPS->setCpRefVoi( iInVps, m, uiCode );
1914        if( !pcVPS->getCpInSliceSegmentHeaderFlag( iInVps ) )
1915        {
1916          Int j      = pcVPS->getCpRefVoi( iInVps, m );
1917          Int jInVps = pcVPS->getVoiInVps( j ); 
1918          Int iCode;
1919          READ_SVLC( iCode, "vps_cp_scale" );                pcVPS->setVpsCpScale   ( iInVps, jInVps, iCode );
1920          READ_SVLC( iCode, "vps_cp_off" );                  pcVPS->setVpsCpOff     ( iInVps, jInVps, iCode );
1921          READ_SVLC( iCode, "vps_cp_inv_scale_plus_scale" ); pcVPS->setVpsCpInvScale( iInVps, jInVps, iCode - pcVPS->getVpsCpScale( iInVps, jInVps ) );
1922          READ_SVLC( iCode, "vps_cp_inv_off_plus_off" );     pcVPS->setVpsCpInvOff  ( iInVps, jInVps, iCode - pcVPS->getVpsCpOff  ( iInVps, jInVps ) );
1923        }
1924      }
1925    }   
1926  }
1927  pcVPS->deriveCpPresentFlag(); 
1928}
1929#endif
1930#endif
1931#if H_MV
1932Void TDecCavlc::parseSliceHeader (TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, Int targetOlsIdx)
1933#else
1934Void TDecCavlc::parseSliceHeader (TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager)
1935#endif
1936{
1937  UInt  uiCode;
1938  Int   iCode;
1939
1940#if ENC_DEC_TRACE
1941  xTraceSliceHeader(rpcSlice);
1942#endif
1943  TComPPS* pps = NULL;
1944  TComSPS* sps = NULL;
1945#if H_MV
1946  TComVPS* vps = NULL;
1947#endif
1948
1949  UInt firstSliceSegmentInPic;
1950  READ_FLAG( firstSliceSegmentInPic, "first_slice_segment_in_pic_flag" );
1951  if( rpcSlice->getRapPicFlag())
1952  { 
1953    READ_FLAG( uiCode, "no_output_of_prior_pics_flag" );  //ignored -- updated already
1954#if SETTING_NO_OUT_PIC_PRIOR
1955    rpcSlice->setNoOutputPriorPicsFlag(uiCode ? true : false);
1956#else
1957    rpcSlice->setNoOutputPicPrior( false );
1958#endif
1959  }
1960
1961  READ_UVLC (    uiCode, "slice_pic_parameter_set_id" );  rpcSlice->setPPSId(uiCode);
1962  pps = parameterSetManager->getPrefetchedPPS(uiCode);
1963  //!KS: need to add error handling code here, if PPS is not available
1964  assert(pps!=0);
1965  sps = parameterSetManager->getPrefetchedSPS(pps->getSPSId());
1966  //!KS: need to add error handling code here, if SPS is not available
1967  assert(sps!=0);
1968#if H_MV
1969  vps = parameterSetManager->getPrefetchedVPS(sps->getVPSId());
1970  assert( vps != NULL );
1971 
1972  sps->inferRepFormat  ( vps , rpcSlice->getLayerId() ); 
1973  sps->inferScalingList( parameterSetManager->getActiveSPS( sps->getSpsScalingListRefLayerId() ) );   
1974  sps->inferSpsMaxDecPicBufferingMinus1( vps, targetOlsIdx, rpcSlice->getLayerId(), false ); 
1975
1976  if ( sps->getVuiParametersPresentFlag() )
1977  {
1978    sps->getVuiParameters()->inferVideoSignalInfo( vps, rpcSlice->getLayerId() ); 
1979  }
1980  rpcSlice->setVPS(vps);     
1981  rpcSlice->setViewId   ( vps->getViewId   ( rpcSlice->getLayerId() )      );
1982  rpcSlice->setViewIndex( vps->getViewIndex( rpcSlice->getLayerId() )      ); 
1983#if H_3D 
1984  rpcSlice->setIsDepth  ( vps->getDepthId  ( rpcSlice->getLayerId() ) == 1 );
1985#endif
1986#endif
1987  rpcSlice->setSPS(sps);
1988  rpcSlice->setPPS(pps);
1989  if( pps->getDependentSliceSegmentsEnabledFlag() && ( !firstSliceSegmentInPic ))
1990  {
1991    READ_FLAG( uiCode, "dependent_slice_segment_flag" );       rpcSlice->setDependentSliceSegmentFlag(uiCode ? true : false);
1992  }
1993  else
1994  {
1995    rpcSlice->setDependentSliceSegmentFlag(false);
1996  }
1997  Int numCTUs = ((sps->getPicWidthInLumaSamples()+sps->getMaxCUWidth()-1)/sps->getMaxCUWidth())*((sps->getPicHeightInLumaSamples()+sps->getMaxCUHeight()-1)/sps->getMaxCUHeight());
1998  Int maxParts = (1<<(sps->getMaxCUDepth()<<1));
1999  UInt sliceSegmentAddress = 0;
2000  Int bitsSliceSegmentAddress = 0;
2001  while(numCTUs>(1<<bitsSliceSegmentAddress))
2002  {
2003    bitsSliceSegmentAddress++;
2004  }
2005
2006  if(!firstSliceSegmentInPic)
2007  {
2008    READ_CODE( bitsSliceSegmentAddress, sliceSegmentAddress, "slice_segment_address" );
2009  }
2010  //set uiCode to equal slice start address (or dependent slice start address)
2011  Int startCuAddress = maxParts*sliceSegmentAddress;
2012  rpcSlice->setSliceSegmentCurStartCUAddr( startCuAddress );
2013  rpcSlice->setSliceSegmentCurEndCUAddr(numCTUs*maxParts);
2014
2015  if (rpcSlice->getDependentSliceSegmentFlag())
2016  {
2017    rpcSlice->setNextSlice          ( false );
2018    rpcSlice->setNextSliceSegment ( true  );
2019  }
2020  else
2021  {
2022    rpcSlice->setNextSlice          ( true  );
2023    rpcSlice->setNextSliceSegment ( false );
2024
2025    rpcSlice->setSliceCurStartCUAddr(startCuAddress);
2026    rpcSlice->setSliceCurEndCUAddr(numCTUs*maxParts);
2027  }
2028 
2029#if H_MV
2030    UInt slicePicOrderCntLsb = 0;
2031#endif
2032
2033  if(!rpcSlice->getDependentSliceSegmentFlag())
2034  {
2035#if H_MV   
2036    Int esb = 0; //Don't use i, otherwise will shadow something below
2037
2038    if ( rpcSlice->getPPS()->getNumExtraSliceHeaderBits() > esb )
2039    {
2040      esb++; 
2041      READ_FLAG( uiCode, "discardable_flag" ); rpcSlice->setDiscardableFlag( uiCode == 1 );
2042      if ( uiCode == 1 )
2043      {
2044        assert(rpcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TRAIL_R &&
2045          rpcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TSA_R &&
2046          rpcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_STSA_R &&
2047          rpcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RADL_R &&
2048          rpcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RASL_R);
2049      }
2050    }
2051
2052    if ( rpcSlice->getPPS()->getNumExtraSliceHeaderBits() > esb )
2053    {
2054      esb++; 
2055      READ_FLAG( uiCode, "cross_layer_bla_flag" ); rpcSlice->setCrossLayerBlaFlag( uiCode == 1 );
2056    }
2057    rpcSlice->checkCrossLayerBlaFlag( ); 
2058
2059
2060    for (; esb < rpcSlice->getPPS()->getNumExtraSliceHeaderBits(); esb++)   
2061#else
2062    for (Int i = 0; i < rpcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
2063#endif     
2064    {
2065      READ_FLAG(uiCode, "slice_reserved_undetermined_flag[]"); // ignored
2066    }
2067
2068    READ_UVLC (    uiCode, "slice_type" );            rpcSlice->setSliceType((SliceType)uiCode);
2069    if( pps->getOutputFlagPresentFlag() )
2070    {
2071      READ_FLAG( uiCode, "pic_output_flag" );    rpcSlice->setPicOutputFlag( uiCode ? true : false );
2072    }
2073    else
2074    {
2075      rpcSlice->setPicOutputFlag( true );
2076    }
2077    // in the first version chroma_format_idc is equal to one, thus colour_plane_id will not be present
2078
2079#if H_3D_DISABLE_CHROMA
2080    assert (sps->getChromaFormatIdc() == 1 || rpcSlice->getIsDepth() );
2081    assert (sps->getChromaFormatIdc() == 0 || !rpcSlice->getIsDepth() );
2082#else
2083    assert (sps->getChromaFormatIdc() == 1 );
2084#endif
2085    // if( separate_colour_plane_flag  ==  1 )
2086    //   colour_plane_id                                      u(2)
2087
2088
2089#if H_MV
2090    Int iPOClsb = slicePicOrderCntLsb;  // Needed later
2091    if ( (rpcSlice->getLayerId() > 0 && !vps->getPocLsbNotPresentFlag( rpcSlice->getLayerIdInVps())) || !rpcSlice->getIdrPicFlag() )
2092    {
2093      READ_CODE(sps->getBitsForPOC(), slicePicOrderCntLsb, "slice_pic_order_cnt_lsb");       
2094    }   
2095    rpcSlice->setSlicePicOrderCntLsb( slicePicOrderCntLsb ); 
2096
2097    Bool picOrderCntMSBZeroFlag = false;     
2098
2099    // as in HM code. However are all cases for IRAP picture with NoRaslOutputFlag equal to 1 covered??
2100    picOrderCntMSBZeroFlag = picOrderCntMSBZeroFlag || ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP   ); 
2101    picOrderCntMSBZeroFlag = picOrderCntMSBZeroFlag || ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL ); 
2102    picOrderCntMSBZeroFlag = picOrderCntMSBZeroFlag || ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP   ); 
2103    picOrderCntMSBZeroFlag = picOrderCntMSBZeroFlag ||   rpcSlice->getIdrPicFlag(); 
2104
2105    // TBD picOrderCntMSBZeroFlag = picOrderCntMSBZeroFlag || ( rpcSlice->getLayerId() > 0 &&   !rpcSlice->getFirstPicInLayerDecodedFlag() );
2106
2107    Int picOrderCntMSB = 0; 
2108
2109    if ( !picOrderCntMSBZeroFlag )
2110    {
2111      Int prevPicOrderCnt    = rpcSlice->getPrevTid0POC();
2112      Int maxPicOrderCntLsb  = 1 << sps->getBitsForPOC();
2113      Int prevPicOrderCntLsb = prevPicOrderCnt & (maxPicOrderCntLsb - 1);
2114      Int prevPicOrderCntMsb = prevPicOrderCnt - prevPicOrderCntLsb;
2115           
2116      if( ( slicePicOrderCntLsb  <  prevPicOrderCntLsb ) && ( ( prevPicOrderCntLsb - slicePicOrderCntLsb )  >=  ( maxPicOrderCntLsb / 2 ) ) )
2117      {
2118        picOrderCntMSB = prevPicOrderCntMsb + maxPicOrderCntLsb;
2119      }
2120      else if( (slicePicOrderCntLsb  >  prevPicOrderCntLsb )  && ( (slicePicOrderCntLsb - prevPicOrderCntLsb )  >  ( maxPicOrderCntLsb / 2 ) ) ) 
2121      {
2122        picOrderCntMSB = prevPicOrderCntMsb - maxPicOrderCntLsb;
2123      }
2124      else
2125      {
2126        picOrderCntMSB = prevPicOrderCntMsb;
2127      }   
2128    }
2129     
2130    rpcSlice->setPOC( picOrderCntMSB + slicePicOrderCntLsb );
2131    if ( rpcSlice->getPocResetFlag() ) 
2132    {
2133      rpcSlice->setPocBeforeReset   ( rpcSlice->getPOC() ); 
2134      rpcSlice->setPOC              ( 0 );
2135    }     
2136#endif
2137
2138    if( rpcSlice->getIdrPicFlag() )
2139    {
2140#if !H_MV
2141      rpcSlice->setPOC(0);
2142#endif
2143      TComReferencePictureSet* rps = rpcSlice->getLocalRPS();
2144      rps->setNumberOfNegativePictures(0);
2145      rps->setNumberOfPositivePictures(0);
2146      rps->setNumberOfLongtermPictures(0);
2147      rps->setNumberOfPictures(0);
2148      rpcSlice->setRPS(rps);
2149#if H_MV
2150      rpcSlice->setEnableTMVPFlag(false);
2151#endif
2152    }
2153    else
2154    {
2155#if !H_MV
2156      READ_CODE(sps->getBitsForPOC(), uiCode, "pic_order_cnt_lsb"); 
2157      Int iPOClsb = uiCode;
2158      Int iPrevPOC = rpcSlice->getPrevTid0POC();
2159      Int iMaxPOClsb = 1<< sps->getBitsForPOC();
2160      Int iPrevPOClsb = iPrevPOC & (iMaxPOClsb - 1);
2161      Int iPrevPOCmsb = iPrevPOC-iPrevPOClsb;
2162      Int iPOCmsb;
2163      if( ( iPOClsb  <  iPrevPOClsb ) && ( ( iPrevPOClsb - iPOClsb )  >=  ( iMaxPOClsb / 2 ) ) )
2164      {
2165        iPOCmsb = iPrevPOCmsb + iMaxPOClsb;
2166      }
2167      else if( (iPOClsb  >  iPrevPOClsb )  && ( (iPOClsb - iPrevPOClsb )  >  ( iMaxPOClsb / 2 ) ) ) 
2168      {
2169        iPOCmsb = iPrevPOCmsb - iMaxPOClsb;
2170      }
2171      else
2172      {
2173        iPOCmsb = iPrevPOCmsb;
2174      }
2175      if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
2176        || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
2177        || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
2178      {
2179        // For BLA picture types, POCmsb is set to 0.
2180        iPOCmsb = 0;
2181      }
2182      rpcSlice->setPOC              (iPOCmsb+iPOClsb);
2183#endif
2184      TComReferencePictureSet* rps;
2185      rps = rpcSlice->getLocalRPS();
2186      rpcSlice->setRPS(rps);
2187      READ_FLAG( uiCode, "short_term_ref_pic_set_sps_flag" );
2188      if(uiCode == 0) // use short-term reference picture set explicitly signalled in slice header
2189      {       
2190        parseShortTermRefPicSet(sps,rps, sps->getRPSList()->getNumberOfReferencePictureSets());
2191#if H_MV
2192        if ( !rps->getInterRPSPrediction( ) )
2193        { // check sum of num_positive_pics and num_negative_pics
2194          rps->checkMaxNumPics( 
2195            vps->getVpsExtensionFlag(), 
2196            MAX_INT,  // To be replaced by MaxDbpSize
2197            rpcSlice->getLayerId(), 
2198            sps->getMaxDecPicBuffering( sps->getSpsMaxSubLayersMinus1() ) - 1 );
2199        }
2200#endif
2201      }
2202      else // use reference to short-term reference picture set in PPS
2203      {
2204        Int numBits = 0;
2205        while ((1 << numBits) < rpcSlice->getSPS()->getRPSList()->getNumberOfReferencePictureSets())
2206        {
2207          numBits++;
2208        }
2209        if (numBits > 0)
2210        {
2211          READ_CODE( numBits, uiCode, "short_term_ref_pic_set_idx");
2212        }
2213        else
2214        {
2215          uiCode = 0;
2216        }
2217        *rps = *(sps->getRPSList()->getReferencePictureSet(uiCode));
2218      }
2219      if(sps->getLongTermRefsPresent())
2220      {
2221        Int offset = rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures();
2222        UInt numOfLtrp = 0;
2223        UInt numLtrpInSPS = 0;
2224        if (rpcSlice->getSPS()->getNumLongTermRefPicSPS() > 0)
2225        {
2226          READ_UVLC( uiCode, "num_long_term_sps");
2227          numLtrpInSPS = uiCode;
2228          numOfLtrp += numLtrpInSPS;
2229          rps->setNumberOfLongtermPictures(numOfLtrp);
2230        }
2231        Int bitsForLtrpInSPS = 0;
2232        while (rpcSlice->getSPS()->getNumLongTermRefPicSPS() > (1 << bitsForLtrpInSPS))
2233        {
2234          bitsForLtrpInSPS++;
2235        }
2236        READ_UVLC( uiCode, "num_long_term_pics");             rps->setNumberOfLongtermPictures(uiCode);
2237        numOfLtrp += uiCode;
2238        rps->setNumberOfLongtermPictures(numOfLtrp);
2239        Int maxPicOrderCntLSB = 1 << rpcSlice->getSPS()->getBitsForPOC();
2240        Int prevDeltaMSB = 0, deltaPocMSBCycleLT = 0;;
2241        for(Int j=offset+rps->getNumberOfLongtermPictures()-1, k = 0; k < numOfLtrp; j--, k++)
2242        {
2243          Int pocLsbLt;
2244          if (k < numLtrpInSPS)
2245          {
2246            uiCode = 0;
2247            if (bitsForLtrpInSPS > 0)
2248            {
2249              READ_CODE(bitsForLtrpInSPS, uiCode, "lt_idx_sps[i]");
2250            }
2251            Int usedByCurrFromSPS=rpcSlice->getSPS()->getUsedByCurrPicLtSPSFlag(uiCode);
2252
2253            pocLsbLt = rpcSlice->getSPS()->getLtRefPicPocLsbSps(uiCode);
2254            rps->setUsed(j,usedByCurrFromSPS);
2255          }
2256          else
2257          {
2258            READ_CODE(rpcSlice->getSPS()->getBitsForPOC(), uiCode, "poc_lsb_lt"); pocLsbLt= uiCode;
2259            READ_FLAG( uiCode, "used_by_curr_pic_lt_flag");     rps->setUsed(j,uiCode);
2260          }
2261          READ_FLAG(uiCode,"delta_poc_msb_present_flag");
2262          Bool mSBPresentFlag = uiCode ? true : false;
2263          if(mSBPresentFlag)                 
2264          {
2265            READ_UVLC( uiCode, "delta_poc_msb_cycle_lt[i]" );
2266            Bool deltaFlag = false;
2267            //            First LTRP                               || First LTRP from SH
2268            if( (j == offset+rps->getNumberOfLongtermPictures()-1) || (j == offset+(numOfLtrp-numLtrpInSPS)-1) )
2269            {
2270              deltaFlag = true;
2271            }
2272            if(deltaFlag)
2273            {
2274              deltaPocMSBCycleLT = uiCode;
2275            }
2276            else
2277            {
2278              deltaPocMSBCycleLT = uiCode + prevDeltaMSB;             
2279            }
2280
2281            Int pocLTCurr = rpcSlice->getPOC() - deltaPocMSBCycleLT * maxPicOrderCntLSB
2282                                        - iPOClsb + pocLsbLt;
2283            rps->setPOC     (j, pocLTCurr); 
2284            rps->setDeltaPOC(j, - rpcSlice->getPOC() + pocLTCurr);
2285            rps->setCheckLTMSBPresent(j,true); 
2286          }
2287          else
2288          {
2289            rps->setPOC     (j, pocLsbLt);
2290            rps->setDeltaPOC(j, - rpcSlice->getPOC() + pocLsbLt);
2291            rps->setCheckLTMSBPresent(j,false); 
2292           
2293            // reset deltaPocMSBCycleLT for first LTRP from slice header if MSB not present
2294            if( j == offset+(numOfLtrp-numLtrpInSPS)-1 )
2295            {
2296              deltaPocMSBCycleLT = 0;
2297            }
2298          }
2299          prevDeltaMSB = deltaPocMSBCycleLT;
2300        }
2301        offset += rps->getNumberOfLongtermPictures();
2302        rps->setNumberOfPictures(offset);       
2303      } 
2304#if H_MV
2305      if ( !rps->getInterRPSPrediction( ) )
2306      { // check sum of NumPositivePics, NumNegativePics, num_long_term_sps and num_long_term_pics
2307        rps->checkMaxNumPics( 
2308          vps->getVpsExtensionFlag(), 
2309            MAX_INT,  // To be replaced by MaxDbpsize
2310          rpcSlice->getLayerId(), 
2311          sps->getMaxDecPicBuffering( sps->getSpsMaxSubLayersMinus1() ) - 1 );
2312      }
2313#endif
2314      if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
2315        || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
2316        || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
2317      {
2318        // In the case of BLA picture types, rps data is read from slice header but ignored
2319        rps = rpcSlice->getLocalRPS();
2320        rps->setNumberOfNegativePictures(0);
2321        rps->setNumberOfPositivePictures(0);
2322        rps->setNumberOfLongtermPictures(0);
2323        rps->setNumberOfPictures(0);
2324        rpcSlice->setRPS(rps);
2325      }
2326      if (rpcSlice->getSPS()->getTMVPFlagsPresent())
2327      {
2328#if H_MV
2329        READ_FLAG( uiCode, "slice_temporal_mvp_enabled_flag" );
2330#else
2331        READ_FLAG( uiCode, "slice_temporal_mvp_enable_flag" );
2332#endif
2333        rpcSlice->setEnableTMVPFlag( uiCode == 1 ? true : false ); 
2334      }
2335      else
2336      {
2337        rpcSlice->setEnableTMVPFlag(false);
2338      }
2339    }
2340#if H_MV
2341    Bool interLayerPredLayerIdcPresentFlag = false; 
2342    Int layerId       = rpcSlice->getLayerId(); 
2343#if H_3D
2344    if( rpcSlice->getLayerId() > 0 && !vps->getAllRefLayersActiveFlag() && vps->getNumRefListLayers( layerId ) > 0 )
2345#else
2346    if( rpcSlice->getLayerId() > 0 && !vps->getAllRefLayersActiveFlag() && vps->getNumDirectRefLayers( layerId ) > 0 )
2347#endif
2348    {   
2349      READ_FLAG( uiCode, "inter_layer_pred_enabled_flag" ); rpcSlice->setInterLayerPredEnabledFlag( uiCode == 1 );
2350#if H_3D
2351      if( rpcSlice->getInterLayerPredEnabledFlag() && vps->getNumRefListLayers( layerId ) > 1 )
2352#else
2353      if( rpcSlice->getInterLayerPredEnabledFlag() && vps->getNumDirectRefLayers( layerId ) > 1 )
2354#endif
2355      {           
2356        if( !vps->getMaxOneActiveRefLayerFlag()) 
2357        {
2358          READ_CODE( rpcSlice->getNumInterLayerRefPicsMinus1Len( ), uiCode, "num_inter_layer_ref_pics_minus1" ); rpcSlice->setNumInterLayerRefPicsMinus1( uiCode );
2359        }
2360#if H_3D
2361        if ( rpcSlice->getNumActiveRefLayerPics() != vps->getNumRefListLayers( layerId ) )
2362#else
2363        if ( rpcSlice->getNumActiveRefLayerPics() != vps->getNumDirectRefLayers( layerId ) )
2364#endif
2365        {
2366          interLayerPredLayerIdcPresentFlag = true; 
2367          for( Int idx = 0; idx < rpcSlice->getNumActiveRefLayerPics(); idx++ )   
2368          {
2369            READ_CODE( rpcSlice->getInterLayerPredLayerIdcLen( ), uiCode, "inter_layer_pred_layer_idc" ); rpcSlice->setInterLayerPredLayerIdc( idx, uiCode );
2370          }
2371        }
2372      } 
2373    }
2374    if ( !interLayerPredLayerIdcPresentFlag )
2375    {
2376      for( Int i = 0; i < rpcSlice->getNumActiveRefLayerPics(); i++ )   
2377      {
2378        rpcSlice->setInterLayerPredLayerIdc( i, rpcSlice->getRefLayerPicIdc( i ) );
2379      }
2380    }
2381#if H_3D
2382    if ( getDecTop()->decProcAnnexI() )
2383    {   
2384      rpcSlice->deriveInCmpPredAndCpAvailFlag();
2385      if ( rpcSlice->getInCmpPredAvailFlag() )
2386      {
2387        READ_FLAG(uiCode, "in_comp_pred_flag");  rpcSlice->setInCompPredFlag((Bool)uiCode);     
2388      }
2389      rpcSlice->init3dToolParameters(); 
2390    }
2391#endif
2392#endif
2393    if(sps->getUseSAO())
2394    {
2395      READ_FLAG(uiCode, "slice_sao_luma_flag");  rpcSlice->setSaoEnabledFlag((Bool)uiCode);
2396#if H_3D_DISABLE_CHROMA
2397      if( rpcSlice->getSPS()->getChromaFormatIdc() != 0 )
2398      {
2399        READ_FLAG(uiCode, "slice_sao_chroma_flag");  rpcSlice->setSaoEnabledFlagChroma((Bool)uiCode);
2400      }
2401      else
2402      {
2403        rpcSlice->setSaoEnabledFlagChroma( false );
2404      }
2405#else
2406      READ_FLAG(uiCode, "slice_sao_chroma_flag");  rpcSlice->setSaoEnabledFlagChroma((Bool)uiCode);
2407#endif
2408    }
2409
2410    if (rpcSlice->getIdrPicFlag())
2411    {
2412      rpcSlice->setEnableTMVPFlag(false);
2413    }
2414    if (!rpcSlice->isIntra())
2415    {
2416
2417      READ_FLAG( uiCode, "num_ref_idx_active_override_flag");
2418      if (uiCode)
2419      {
2420        READ_UVLC (uiCode, "num_ref_idx_l0_active_minus1" );  rpcSlice->setNumRefIdx( REF_PIC_LIST_0, uiCode + 1 );
2421        if (rpcSlice->isInterB())
2422        {
2423          READ_UVLC (uiCode, "num_ref_idx_l1_active_minus1" );  rpcSlice->setNumRefIdx( REF_PIC_LIST_1, uiCode + 1 );
2424        }
2425        else
2426        {
2427          rpcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
2428        }
2429      }
2430      else
2431      {
2432        rpcSlice->setNumRefIdx(REF_PIC_LIST_0, rpcSlice->getPPS()->getNumRefIdxL0DefaultActive());
2433        if (rpcSlice->isInterB())
2434        {
2435          rpcSlice->setNumRefIdx(REF_PIC_LIST_1, rpcSlice->getPPS()->getNumRefIdxL1DefaultActive());
2436        }
2437        else
2438        {
2439          rpcSlice->setNumRefIdx(REF_PIC_LIST_1,0);
2440        }
2441      }
2442    }
2443    // }
2444    TComRefPicListModification* refPicListModification = rpcSlice->getRefPicListModification();
2445    if(!rpcSlice->isIntra())
2446    {
2447      if( !rpcSlice->getPPS()->getListsModificationPresentFlag() || rpcSlice->getNumRpsCurrTempList() <= 1 )
2448      {
2449        refPicListModification->setRefPicListModificationFlagL0( 0 );
2450      }
2451      else
2452      {
2453        READ_FLAG( uiCode, "ref_pic_list_modification_flag_l0" ); refPicListModification->setRefPicListModificationFlagL0( uiCode ? 1 : 0 );
2454      }
2455
2456      if(refPicListModification->getRefPicListModificationFlagL0())
2457      { 
2458        uiCode = 0;
2459        Int i = 0;
2460        Int numRpsCurrTempList0 = rpcSlice->getNumRpsCurrTempList();
2461        if ( numRpsCurrTempList0 > 1 )
2462        {
2463          Int length = 1;
2464          numRpsCurrTempList0 --;
2465          while ( numRpsCurrTempList0 >>= 1) 
2466          {
2467            length ++;
2468          }
2469          for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
2470          {
2471            READ_CODE( length, uiCode, "list_entry_l0" );
2472            refPicListModification->setRefPicSetIdxL0(i, uiCode );
2473          }
2474        }
2475        else
2476        {
2477          for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
2478          {
2479            refPicListModification->setRefPicSetIdxL0(i, 0 );
2480          }
2481        }
2482      }
2483    }
2484    else
2485    {
2486      refPicListModification->setRefPicListModificationFlagL0(0);
2487    }
2488    if(rpcSlice->isInterB())
2489    {
2490      if( !rpcSlice->getPPS()->getListsModificationPresentFlag() || rpcSlice->getNumRpsCurrTempList() <= 1 )
2491      {
2492        refPicListModification->setRefPicListModificationFlagL1( 0 );
2493      }
2494      else
2495      {
2496        READ_FLAG( uiCode, "ref_pic_list_modification_flag_l1" ); refPicListModification->setRefPicListModificationFlagL1( uiCode ? 1 : 0 );
2497      }
2498      if(refPicListModification->getRefPicListModificationFlagL1())
2499      {
2500        uiCode = 0;
2501        Int i = 0;
2502        Int numRpsCurrTempList1 = rpcSlice->getNumRpsCurrTempList();
2503        if ( numRpsCurrTempList1 > 1 )
2504        {
2505          Int length = 1;
2506          numRpsCurrTempList1 --;
2507          while ( numRpsCurrTempList1 >>= 1) 
2508          {
2509            length ++;
2510          }
2511          for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
2512          {
2513            READ_CODE( length, uiCode, "list_entry_l1" );
2514            refPicListModification->setRefPicSetIdxL1(i, uiCode );
2515          }
2516        }
2517        else
2518        {
2519          for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
2520          {
2521            refPicListModification->setRefPicSetIdxL1(i, 0 );
2522          }
2523        }
2524      }
2525    } 
2526    else
2527    {
2528      refPicListModification->setRefPicListModificationFlagL1(0);
2529    }
2530    if (rpcSlice->isInterB())
2531    {
2532      READ_FLAG( uiCode, "mvd_l1_zero_flag" );       rpcSlice->setMvdL1ZeroFlag( (uiCode ? true : false) );
2533    }
2534
2535    rpcSlice->setCabacInitFlag( false ); // default
2536    if(pps->getCabacInitPresentFlag() && !rpcSlice->isIntra())
2537    {
2538      READ_FLAG(uiCode, "cabac_init_flag");
2539      rpcSlice->setCabacInitFlag( uiCode ? true : false );
2540    }
2541
2542    if ( rpcSlice->getEnableTMVPFlag() )
2543    {
2544      if ( rpcSlice->getSliceType() == B_SLICE )
2545      {
2546        READ_FLAG( uiCode, "collocated_from_l0_flag" );
2547        rpcSlice->setColFromL0Flag(uiCode);
2548      }
2549      else
2550      {
2551        rpcSlice->setColFromL0Flag( 1 );
2552      }
2553
2554      if ( rpcSlice->getSliceType() != I_SLICE &&
2555          ((rpcSlice->getColFromL0Flag() == 1 && rpcSlice->getNumRefIdx(REF_PIC_LIST_0) > 1)||
2556           (rpcSlice->getColFromL0Flag() == 0 && rpcSlice->getNumRefIdx(REF_PIC_LIST_1) > 1)))
2557      {
2558        READ_UVLC( uiCode, "collocated_ref_idx" );
2559        rpcSlice->setColRefIdx(uiCode);
2560      }
2561      else
2562      {
2563        rpcSlice->setColRefIdx(0);
2564      }
2565    }
2566    if ( (pps->getUseWP() && rpcSlice->getSliceType()==P_SLICE) || (pps->getWPBiPred() && rpcSlice->getSliceType()==B_SLICE) )
2567    {
2568      xParsePredWeightTable(rpcSlice);
2569      rpcSlice->initWpScaling();
2570    }
2571#if H_3D_IC
2572    else if(    rpcSlice->getViewIndex() && ( rpcSlice->getSliceType() == P_SLICE || rpcSlice->getSliceType() == B_SLICE ) 
2573             && !rpcSlice->getIsDepth() && vps->getNumRefListLayers( layerId ) > 0 
2574             && getDecTop()->decProcAnnexI()
2575           )
2576    {
2577      UInt uiCodeTmp = 0;
2578
2579      READ_FLAG ( uiCodeTmp, "slice_ic_enable_flag" );
2580      rpcSlice->setApplyIC( uiCodeTmp );
2581
2582      if ( uiCodeTmp )
2583      {
2584        READ_FLAG ( uiCodeTmp, "ic_skip_mergeidx0" );
2585        rpcSlice->setIcSkipParseFlag( uiCodeTmp );
2586      }
2587    }
2588#endif
2589    if (!rpcSlice->isIntra())
2590    {
2591      READ_UVLC( uiCode, "five_minus_max_num_merge_cand");
2592#if H_3D_IV_MERGE
2593      rpcSlice->setMaxNumMergeCand(( ( rpcSlice->getMpiFlag() || rpcSlice->getIvMvPredFlag() || rpcSlice->getViewSynthesisPredFlag() ) ? MRG_MAX_NUM_CANDS_MEM : MRG_MAX_NUM_CANDS) - uiCode);
2594#else
2595      rpcSlice->setMaxNumMergeCand(MRG_MAX_NUM_CANDS - uiCode);
2596#endif
2597    }
2598
2599    READ_SVLC( iCode, "slice_qp_delta" );
2600    rpcSlice->setSliceQp (26 + pps->getPicInitQPMinus26() + iCode);
2601
2602    assert( rpcSlice->getSliceQp() >= -sps->getQpBDOffsetY() );
2603    assert( rpcSlice->getSliceQp() <=  51 );
2604
2605    if (rpcSlice->getPPS()->getSliceChromaQpFlag())
2606    {
2607      READ_SVLC( iCode, "slice_qp_delta_cb" );
2608      rpcSlice->setSliceQpDeltaCb( iCode );
2609      assert( rpcSlice->getSliceQpDeltaCb() >= -12 );
2610      assert( rpcSlice->getSliceQpDeltaCb() <=  12 );
2611      assert( (rpcSlice->getPPS()->getChromaCbQpOffset() + rpcSlice->getSliceQpDeltaCb()) >= -12 );
2612      assert( (rpcSlice->getPPS()->getChromaCbQpOffset() + rpcSlice->getSliceQpDeltaCb()) <=  12 );
2613
2614      READ_SVLC( iCode, "slice_qp_delta_cr" );
2615      rpcSlice->setSliceQpDeltaCr( iCode );
2616      assert( rpcSlice->getSliceQpDeltaCr() >= -12 );
2617      assert( rpcSlice->getSliceQpDeltaCr() <=  12 );
2618      assert( (rpcSlice->getPPS()->getChromaCrQpOffset() + rpcSlice->getSliceQpDeltaCr()) >= -12 );
2619      assert( (rpcSlice->getPPS()->getChromaCrQpOffset() + rpcSlice->getSliceQpDeltaCr()) <=  12 );
2620    }
2621
2622    if (rpcSlice->getPPS()->getDeblockingFilterControlPresentFlag())
2623    {
2624      if(rpcSlice->getPPS()->getDeblockingFilterOverrideEnabledFlag())
2625      {
2626        READ_FLAG ( uiCode, "deblocking_filter_override_flag" );        rpcSlice->setDeblockingFilterOverrideFlag(uiCode ? true : false);
2627      }
2628      else
2629      { 
2630        rpcSlice->setDeblockingFilterOverrideFlag(0);
2631      }
2632      if(rpcSlice->getDeblockingFilterOverrideFlag())
2633      {
2634        READ_FLAG ( uiCode, "slice_disable_deblocking_filter_flag" );   rpcSlice->setDeblockingFilterDisable(uiCode ? 1 : 0);
2635        if(!rpcSlice->getDeblockingFilterDisable())
2636        {
2637          READ_SVLC( iCode, "slice_beta_offset_div2" );                       rpcSlice->setDeblockingFilterBetaOffsetDiv2(iCode);
2638          assert(rpcSlice->getDeblockingFilterBetaOffsetDiv2() >= -6 &&
2639                 rpcSlice->getDeblockingFilterBetaOffsetDiv2() <=  6);
2640          READ_SVLC( iCode, "slice_tc_offset_div2" );                         rpcSlice->setDeblockingFilterTcOffsetDiv2(iCode);
2641          assert(rpcSlice->getDeblockingFilterTcOffsetDiv2() >= -6 &&
2642                 rpcSlice->getDeblockingFilterTcOffsetDiv2() <=  6);
2643        }
2644      }
2645      else
2646      {
2647        rpcSlice->setDeblockingFilterDisable   ( rpcSlice->getPPS()->getPicDisableDeblockingFilterFlag() );
2648        rpcSlice->setDeblockingFilterBetaOffsetDiv2( rpcSlice->getPPS()->getDeblockingFilterBetaOffsetDiv2() );
2649        rpcSlice->setDeblockingFilterTcOffsetDiv2  ( rpcSlice->getPPS()->getDeblockingFilterTcOffsetDiv2() );
2650      }
2651    }
2652    else
2653    { 
2654      rpcSlice->setDeblockingFilterDisable       ( false );
2655      rpcSlice->setDeblockingFilterBetaOffsetDiv2( 0 );
2656      rpcSlice->setDeblockingFilterTcOffsetDiv2  ( 0 );
2657    }
2658
2659    Bool isSAOEnabled = (!rpcSlice->getSPS()->getUseSAO())?(false):(rpcSlice->getSaoEnabledFlag()||rpcSlice->getSaoEnabledFlagChroma());
2660    Bool isDBFEnabled = (!rpcSlice->getDeblockingFilterDisable());
2661
2662    if(rpcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag() && ( isSAOEnabled || isDBFEnabled ))
2663    {
2664      READ_FLAG( uiCode, "slice_loop_filter_across_slices_enabled_flag");
2665    }
2666    else
2667    {
2668      uiCode = rpcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag()?1:0;
2669    }
2670    rpcSlice->setLFCrossSliceBoundaryFlag( (uiCode==1)?true:false);
2671
2672#if H_3D
2673    if ( getDecTop()->decProcAnnexI() )
2674    {
2675      Int voiInVps = vps->getVoiInVps( rpcSlice->getViewIndex() ); 
2676      if( vps->getCpInSliceSegmentHeaderFlag( voiInVps ) && !rpcSlice->getIsDepth() )
2677      {
2678        for( Int m = 0; m < vps->getNumCp( voiInVps ); m++ )
2679        {
2680          Int jInVps = vps->getVoiInVps( vps->getCpRefVoi( voiInVps, m ));
2681          READ_SVLC( iCode, "cp_scale" );                rpcSlice->setCpScale   ( jInVps, iCode );
2682          READ_SVLC( iCode, "cp_off" );                  rpcSlice->setCpOff     ( jInVps, iCode );
2683          READ_SVLC( iCode, "cp_inv_scale_plus_scale" ); rpcSlice->setCpInvScale( jInVps, iCode - rpcSlice->getCpScale   ( jInVps ));
2684          READ_SVLC( iCode, "cp_inv_off_plus_off" );     rpcSlice->setCpInvOff  ( jInVps, iCode - rpcSlice->getCpOff     ( jInVps ));
2685        }
2686      }
2687    }
2688#endif
2689  }
2690 
2691    UInt *entryPointOffset          = NULL;
2692    UInt numEntryPointOffsets, offsetLenMinus1;
2693  if( pps->getTilesEnabledFlag() || pps->getEntropyCodingSyncEnabledFlag() )
2694  {
2695    READ_UVLC(numEntryPointOffsets, "num_entry_point_offsets"); rpcSlice->setNumEntryPointOffsets ( numEntryPointOffsets );
2696    if (numEntryPointOffsets>0)
2697    {
2698      READ_UVLC(offsetLenMinus1, "offset_len_minus1");
2699    }
2700    entryPointOffset = new UInt[numEntryPointOffsets];
2701    for (UInt idx=0; idx<numEntryPointOffsets; idx++)
2702    {
2703      READ_CODE(offsetLenMinus1+1, uiCode, "entry_point_offset_minus1");
2704      entryPointOffset[ idx ] = uiCode + 1;
2705    }
2706  }
2707  else
2708  {
2709    rpcSlice->setNumEntryPointOffsets ( 0 );
2710  }
2711
2712
2713  if(pps->getSliceHeaderExtensionPresentFlag())
2714  {
2715#if H_MV
2716    READ_UVLC( uiCode, "slice_segment_header_extension_length" ); rpcSlice->setSliceSegmentHeaderExtensionLength( uiCode );
2717    UInt posFollSliceSegHeaderExtLen = m_pcBitstream->getNumBitsRead();
2718
2719    if( rpcSlice->getPPS()->getPocResetInfoPresentFlag() )
2720    {
2721      READ_CODE( 2, uiCode, "poc_reset_idc" ); rpcSlice->setPocResetIdc( uiCode );
2722    }
2723    else
2724    {
2725      rpcSlice->setPocResetIdc( 0 );
2726    }
2727    rpcSlice->checkPocResetIdc(); 
2728
2729    if ( rpcSlice->getVPS()->getPocLsbNotPresentFlag(rpcSlice->getLayerId()) && slicePicOrderCntLsb > 0 )
2730    {
2731      assert( rpcSlice->getPocResetIdc() != 2 );
2732    }
2733
2734    if( rpcSlice->getPocResetIdc() !=  0 )
2735    {
2736      READ_CODE( 6, uiCode, "poc_reset_period_id" ); rpcSlice->setPocResetPeriodId( uiCode );
2737    }
2738    else
2739    {
2740      // TODO Copy poc_reset_period from earlier picture
2741      rpcSlice->setPocResetPeriodId( 0 );
2742    }
2743   
2744    if( rpcSlice->getPocResetIdc() ==  3 ) 
2745    {
2746      READ_FLAG( uiCode, "full_poc_reset_flag" ); rpcSlice->setFullPocResetFlag( uiCode == 1 );
2747      READ_CODE( rpcSlice->getPocLsbValLen() , uiCode, "poc_lsb_val" ); rpcSlice->setPocLsbVal( uiCode );
2748    }         
2749    rpcSlice->checkPocLsbVal(); 
2750
2751    // Derive the value of PocMs8bValRequiredFlag
2752
2753    if( !rpcSlice->getPocMsbValRequiredFlag() && rpcSlice->getVPS()->getVpsPocLsbAlignedFlag() )
2754    {
2755      READ_FLAG( uiCode, "poc_msb_val_present_flag" ); rpcSlice->setPocMsbValPresentFlag( uiCode == 1 );
2756    }
2757    else
2758    {
2759      rpcSlice->setPocMsbValPresentFlag( rpcSlice->inferPocMsbValPresentFlag( ) ); 
2760    }
2761
2762   
2763    if( rpcSlice->getPocMsbValPresentFlag() )
2764    {
2765      READ_UVLC( uiCode, "poc_msb_val" ); rpcSlice->setPocMsbVal( uiCode );
2766    }
2767
2768    while( ( m_pcBitstream->getNumBitsRead() - posFollSliceSegHeaderExtLen ) < rpcSlice->getSliceSegmentHeaderExtensionLength() * 8 )
2769    {
2770     READ_FLAG( uiCode, "slice_segment_header_extension_data_bit" );
2771    }
2772    assert( ( m_pcBitstream->getNumBitsRead() - posFollSliceSegHeaderExtLen ) == rpcSlice->getSliceSegmentHeaderExtensionLength() * 8  ); 
2773  }
2774#else
2775    READ_UVLC( uiCode, "slice_header_extension_length" );
2776    for(Int i=0; i<uiCode; i++)
2777    {
2778      UInt ignore;
2779      READ_CODE(8,ignore,"slice_header_extension_data_byte");
2780    } 
2781  }
2782#endif
2783  m_pcBitstream->readByteAlignment();
2784
2785  if( pps->getTilesEnabledFlag() || pps->getEntropyCodingSyncEnabledFlag() )
2786  {
2787    Int endOfSliceHeaderLocation = m_pcBitstream->getByteLocation();
2788   
2789    // Adjust endOfSliceHeaderLocation to account for emulation prevention bytes in the slice segment header
2790    for ( UInt curByteIdx  = 0; curByteIdx<m_pcBitstream->numEmulationPreventionBytesRead(); curByteIdx++ )
2791    {
2792      if ( m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) < endOfSliceHeaderLocation )
2793      {
2794        endOfSliceHeaderLocation++;
2795      }
2796    }
2797
2798    Int  curEntryPointOffset     = 0;
2799    Int  prevEntryPointOffset    = 0;
2800    for (UInt idx=0; idx<numEntryPointOffsets; idx++)
2801    {
2802      curEntryPointOffset += entryPointOffset[ idx ];
2803
2804      Int emulationPreventionByteCount = 0;
2805      for ( UInt curByteIdx  = 0; curByteIdx<m_pcBitstream->numEmulationPreventionBytesRead(); curByteIdx++ )
2806      {
2807        if ( m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) >= ( prevEntryPointOffset + endOfSliceHeaderLocation ) && 
2808             m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) <  ( curEntryPointOffset  + endOfSliceHeaderLocation ) )
2809        {
2810          emulationPreventionByteCount++;
2811        }
2812      }
2813
2814      entryPointOffset[ idx ] -= emulationPreventionByteCount;
2815      prevEntryPointOffset = curEntryPointOffset;
2816    }
2817
2818    if ( pps->getTilesEnabledFlag() )
2819    {
2820      rpcSlice->setTileLocationCount( numEntryPointOffsets );
2821
2822      UInt prevPos = 0;
2823      for (Int idx=0; idx<rpcSlice->getTileLocationCount(); idx++)
2824      {
2825        rpcSlice->setTileLocation( idx, prevPos + entryPointOffset [ idx ] );
2826        prevPos += entryPointOffset[ idx ];
2827      }
2828    }
2829    else if ( pps->getEntropyCodingSyncEnabledFlag() )
2830    {
2831    Int numSubstreams = rpcSlice->getNumEntryPointOffsets()+1;
2832      rpcSlice->allocSubstreamSizes(numSubstreams);
2833      UInt *pSubstreamSizes       = rpcSlice->getSubstreamSizes();
2834      for (Int idx=0; idx<numSubstreams-1; idx++)
2835      {
2836        if ( idx < numEntryPointOffsets )
2837        {
2838          pSubstreamSizes[ idx ] = ( entryPointOffset[ idx ] << 3 ) ;
2839        }
2840        else
2841        {
2842          pSubstreamSizes[ idx ] = 0;
2843        }
2844      }
2845    }
2846
2847    if (entryPointOffset)
2848    {
2849      delete [] entryPointOffset;
2850    }
2851  }
2852
2853  return;
2854}
2855 
2856Void TDecCavlc::parsePTL( TComPTL *rpcPTL, Bool profilePresentFlag, Int maxNumSubLayersMinus1 )
2857{
2858  UInt uiCode;
2859  if(profilePresentFlag)
2860  {
2861    parseProfileTier(rpcPTL->getGeneralPTL());
2862  }
2863  READ_CODE( 8, uiCode, "general_level_idc" );    rpcPTL->getGeneralPTL()->setLevelIdc(uiCode);
2864
2865  for (Int i = 0; i < maxNumSubLayersMinus1; i++)
2866  {
2867#if !H_MV
2868    if(profilePresentFlag)
2869    {
2870#endif
2871      READ_FLAG( uiCode, "sub_layer_profile_present_flag[i]" ); rpcPTL->setSubLayerProfilePresentFlag(i, uiCode);
2872#if H_MV
2873      // When profilePresentFlag is equal to 0, sub_layer_profile_present_flag[ i ] shall be equal to 0.
2874      assert( profilePresentFlag || !rpcPTL->getSubLayerProfilePresentFlag(i) );
2875#else
2876    }
2877#endif
2878    READ_FLAG( uiCode, "sub_layer_level_present_flag[i]"   ); rpcPTL->setSubLayerLevelPresentFlag  (i, uiCode);
2879  }
2880 
2881  if (maxNumSubLayersMinus1 > 0)
2882  {
2883    for (Int i = maxNumSubLayersMinus1; i < 8; i++)
2884    {
2885      READ_CODE(2, uiCode, "reserved_zero_2bits");
2886      assert(uiCode == 0);
2887    }
2888  }
2889 
2890  for(Int i = 0; i < maxNumSubLayersMinus1; i++)
2891  {
2892#if H_MV
2893    if( rpcPTL->getSubLayerProfilePresentFlag(i) )         
2894#else
2895    if( profilePresentFlag && rpcPTL->getSubLayerProfilePresentFlag(i) )         
2896#endif
2897    {
2898      parseProfileTier(rpcPTL->getSubLayerPTL(i));
2899    }
2900    if(rpcPTL->getSubLayerLevelPresentFlag(i))
2901    {
2902      READ_CODE( 8, uiCode, "sub_layer_level_idc[i]" );   rpcPTL->getSubLayerPTL(i)->setLevelIdc(uiCode);
2903    }
2904  }
2905}
2906
2907Void TDecCavlc::parseProfileTier(ProfileTierLevel *ptl)
2908{
2909  UInt uiCode;
2910  READ_CODE(2 , uiCode, "XXX_profile_space[]");   ptl->setProfileSpace(uiCode);
2911  READ_FLAG(    uiCode, "XXX_tier_flag[]"    );   ptl->setTierFlag    (uiCode ? 1 : 0);
2912  READ_CODE(5 , uiCode, "XXX_profile_idc[]"  );   ptl->setProfileIdc  (uiCode);
2913  for(Int j = 0; j < 32; j++)
2914  {
2915    READ_FLAG(  uiCode, "XXX_profile_compatibility_flag[][j]");   ptl->setProfileCompatibilityFlag(j, uiCode ? 1 : 0);
2916  }
2917  READ_FLAG(uiCode, "general_progressive_source_flag");
2918  ptl->setProgressiveSourceFlag(uiCode ? true : false);
2919
2920  READ_FLAG(uiCode, "general_interlaced_source_flag");
2921  ptl->setInterlacedSourceFlag(uiCode ? true : false);
2922 
2923  READ_FLAG(uiCode, "general_non_packed_constraint_flag");
2924  ptl->setNonPackedConstraintFlag(uiCode ? true : false);
2925 
2926  READ_FLAG(uiCode, "general_frame_only_constraint_flag");
2927  ptl->setFrameOnlyConstraintFlag(uiCode ? true : false);
2928 
2929#if H_MV
2930  if( ptl->getV2ConstraintsPresentFlag() )
2931  {
2932    READ_FLAG( uiCode, "max_12bit_constraint_flag" );        ptl->setMax12bitConstraintFlag      ( uiCode == 1 );
2933    READ_FLAG( uiCode, "max_10bit_constraint_flag" );        ptl->setMax10bitConstraintFlag      ( uiCode == 1 );
2934    READ_FLAG( uiCode, "max_8bit_constraint_flag" );         ptl->setMax8bitConstraintFlag       ( uiCode == 1 );
2935    READ_FLAG( uiCode, "max_422chroma_constraint_flag" );    ptl->setMax422chromaConstraintFlag  ( uiCode == 1 );
2936    READ_FLAG( uiCode, "max_420chroma_constraint_flag" );    ptl->setMax420chromaConstraintFlag  ( uiCode == 1 );
2937    READ_FLAG( uiCode, "max_monochrome_constraint_flag" );   ptl->setMaxMonochromeConstraintFlag ( uiCode == 1 );
2938    READ_FLAG( uiCode, "intra_constraint_flag" );            ptl->setIntraConstraintFlag         ( uiCode == 1 );
2939    READ_FLAG( uiCode, "one_picture_only_constraint_flag" ); ptl->setOnePictureOnlyConstraintFlag( uiCode == 1 );
2940    READ_FLAG( uiCode, "lower_bit_rate_constraint_flag" );   ptl->setLowerBitRateConstraintFlag  ( uiCode == 1 );   
2941    READ_CODE(16, uiCode, "XXX_reserved_zero_34bits[0..15]");
2942    READ_CODE(16, uiCode, "XXX_reserved_zero_34bits[16..31]");
2943    READ_CODE(2 , uiCode, "XXX_reserved_zero_34bits[32..33]");
2944  }
2945  else
2946  {
2947    READ_CODE(16, uiCode, "XXX_reserved_zero_43bits[0..15]");
2948    READ_CODE(16, uiCode, "XXX_reserved_zero_43bits[16..31]");
2949    READ_CODE(11, uiCode, "XXX_reserved_zero_43bits[32..42]");
2950  }
2951  if( ptl->getInbldPresentFlag() )
2952  {
2953    READ_FLAG( uiCode, "inbld_flag" ); ptl->setInbldFlag( uiCode == 1 );
2954  }
2955  else
2956  {
2957    READ_FLAG(uiCode, "reserved_zero_bit");
2958  }
2959#else
2960  READ_CODE(16, uiCode, "XXX_reserved_zero_44bits[0..15]");
2961  READ_CODE(16, uiCode, "XXX_reserved_zero_44bits[16..31]");
2962  READ_CODE(12, uiCode, "XXX_reserved_zero_44bits[32..43]");
2963#endif
2964}
2965
2966Void TDecCavlc::parseTerminatingBit( UInt& ruiBit )
2967{
2968  ruiBit = false;
2969  Int iBitsLeft = m_pcBitstream->getNumBitsLeft();
2970  if(iBitsLeft <= 8)
2971  {
2972    UInt uiPeekValue = m_pcBitstream->peekBits(iBitsLeft);
2973    if (uiPeekValue == (1<<(iBitsLeft-1)))
2974    {
2975      ruiBit = true;
2976    }
2977  }
2978}
2979
2980Void TDecCavlc::parseSkipFlag( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
2981{
2982  assert(0);
2983}
2984#if H_3D
2985Void TDecCavlc::parseDIS( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
2986{
2987  assert(0);
2988}
2989#endif
2990
2991Void TDecCavlc::parseCUTransquantBypassFlag( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
2992{
2993  assert(0);
2994}
2995
2996Void TDecCavlc::parseMVPIdx( Int& /*riMVPIdx*/ )
2997{
2998  assert(0);
2999}
3000
3001Void TDecCavlc::parseSplitFlag     ( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
3002{
3003  assert(0);
3004}
3005
3006Void TDecCavlc::parsePartSize( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
3007{
3008  assert(0);
3009}
3010
3011Void TDecCavlc::parsePredMode( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
3012{
3013  assert(0);
3014}
3015
3016/** Parse I_PCM information.
3017* \param pcCU pointer to CU
3018* \param uiAbsPartIdx CU index
3019* \param uiDepth CU depth
3020* \returns Void
3021*
3022* If I_PCM flag indicates that the CU is I_PCM, parse its PCM alignment bits and codes. 
3023*/
3024Void TDecCavlc::parseIPCMInfo( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
3025{
3026  assert(0);
3027}
3028
3029Void TDecCavlc::parseIntraDirLumaAng  ( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
3030{ 
3031  assert(0);
3032}
3033
3034Void TDecCavlc::parseIntraDirChroma( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
3035{
3036  assert(0);
3037}
3038
3039Void TDecCavlc::parseInterDir( TComDataCU* /*pcCU*/, UInt& /*ruiInterDir*/, UInt /*uiAbsPartIdx*/ )
3040{
3041  assert(0);
3042}
3043
3044Void TDecCavlc::parseRefFrmIdx( TComDataCU* /*pcCU*/, Int& /*riRefFrmIdx*/, RefPicList /*eRefList*/ )
3045{
3046  assert(0);
3047}
3048
3049Void TDecCavlc::parseMvd( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiPartIdx*/, UInt /*uiDepth*/, RefPicList /*eRefList*/ )
3050{
3051  assert(0);
3052}
3053
3054Void TDecCavlc::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
3055{
3056  Int qp;
3057  Int  iDQp;
3058
3059  xReadSvlc( iDQp );
3060
3061  Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
3062  qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+ qpBdOffsetY)) -  qpBdOffsetY;
3063
3064  UInt uiAbsQpCUPartIdx = (uiAbsPartIdx>>((g_uiMaxCUDepth - pcCU->getSlice()->getPPS()->getMaxCuDQPDepth())<<1))<<((g_uiMaxCUDepth - pcCU->getSlice()->getPPS()->getMaxCuDQPDepth())<<1) ;
3065  UInt uiQpCUDepth =   min(uiDepth,pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()) ;
3066
3067  pcCU->setQPSubParts( qp, uiAbsQpCUPartIdx, uiQpCUDepth );
3068}
3069
3070Void TDecCavlc::parseCoeffNxN( TComDataCU* /*pcCU*/, TCoeff* /*pcCoef*/, UInt /*uiAbsPartIdx*/, UInt /*uiWidth*/, UInt /*uiHeight*/, UInt /*uiDepth*/, TextType /*eTType*/ )
3071{
3072  assert(0);
3073}
3074
3075Void TDecCavlc::parseTransformSubdivFlag( UInt& /*ruiSubdivFlag*/, UInt /*uiLog2TransformBlockSize*/ )
3076{
3077  assert(0);
3078}
3079
3080Void TDecCavlc::parseQtCbf( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, TextType /*eType*/, UInt /*uiTrDepth*/, UInt /*uiDepth*/ )
3081{
3082  assert(0);
3083}
3084
3085Void TDecCavlc::parseQtRootCbf( UInt /*uiAbsPartIdx*/, UInt& /*uiQtRootCbf*/ )
3086{
3087  assert(0);
3088}
3089
3090Void TDecCavlc::parseTransformSkipFlags (TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*width*/, UInt /*height*/, UInt /*uiDepth*/, TextType /*eTType*/)
3091{
3092  assert(0);
3093}
3094
3095Void TDecCavlc::parseMergeFlag ( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/, UInt /*uiPUIdx*/ )
3096{
3097  assert(0);
3098}
3099
3100Void TDecCavlc::parseMergeIndex ( TComDataCU* /*pcCU*/, UInt& /*ruiMergeIndex*/ )
3101{
3102  assert(0);
3103}
3104
3105#if H_3D_ARP
3106Void TDecCavlc::parseARPW( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
3107{
3108  assert(0);
3109}
3110#endif
3111#if H_3D_IC
3112Void TDecCavlc::parseICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
3113{
3114  assert(0);
3115}
3116#endif
3117#if H_3D_INTER_SDC
3118Void TDecCavlc::parseDeltaDC( TComDataCU* /*pcCU*/, UInt /*uiAbsPartIdx*/, UInt /*uiDepth*/ )
3119{ 
3120  assert(0);
3121}
3122
3123Void TDecCavlc::parseSDCFlag    ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
3124{
3125  assert(0);
3126}
3127
3128#endif
3129#if H_3D_DBBP
3130  Void TDecCavlc::parseDBBPFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
3131  {
3132    assert(0);
3133  }
3134#endif
3135// ====================================================================================================================
3136// Protected member functions
3137// ====================================================================================================================
3138
3139/** parse explicit wp tables
3140* \param TComSlice* pcSlice
3141* \returns Void
3142*/
3143Void TDecCavlc::xParsePredWeightTable( TComSlice* pcSlice )
3144{
3145  wpScalingParam  *wp;
3146#if H_3D_DISABLE_CHROMA
3147  Bool            bChroma     = ( pcSlice->getSPS()->getChromaFormatIdc() != 0 ); 
3148#else
3149  Bool            bChroma     = true; // color always present in HEVC ?
3150#endif
3151  SliceType       eSliceType  = pcSlice->getSliceType();
3152  Int             iNbRef       = (eSliceType == B_SLICE ) ? (2) : (1);
3153  UInt            uiLog2WeightDenomLuma, uiLog2WeightDenomChroma;
3154  UInt            uiTotalSignalledWeightFlags = 0;
3155
3156  Int iDeltaDenom;
3157  // decode delta_luma_log2_weight_denom :
3158  READ_UVLC( uiLog2WeightDenomLuma, "luma_log2_weight_denom" );     // ue(v): luma_log2_weight_denom
3159  assert( uiLog2WeightDenomLuma <= 7 );
3160  if( bChroma ) 
3161  {
3162    READ_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" );     // se(v): delta_chroma_log2_weight_denom
3163    assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)>=0);
3164    assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)<=7);
3165    uiLog2WeightDenomChroma = (UInt)(iDeltaDenom + uiLog2WeightDenomLuma);
3166  }
3167  else
3168  { 
3169    // For some reasons this is also needed to fix a compiler warning when H_3D_DISABLE_CHROMA is equal to 0.
3170    uiLog2WeightDenomChroma = 0; 
3171  }
3172
3173
3174  for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ ) 
3175  {
3176    RefPicList  eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
3177    for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ ) 
3178    {
3179      pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
3180
3181      wp[0].uiLog2WeightDenom = uiLog2WeightDenomLuma;
3182      wp[1].uiLog2WeightDenom = uiLog2WeightDenomChroma;
3183      wp[2].uiLog2WeightDenom = uiLog2WeightDenomChroma;
3184
3185      UInt  uiCode;
3186      READ_FLAG( uiCode, "luma_weight_lX_flag" );           // u(1): luma_weight_l0_flag
3187      wp[0].bPresentFlag = ( uiCode == 1 );
3188      uiTotalSignalledWeightFlags += wp[0].bPresentFlag;
3189    }
3190    if ( bChroma ) 
3191    {
3192      UInt  uiCode;
3193      for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ ) 
3194      {
3195        pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
3196        READ_FLAG( uiCode, "chroma_weight_lX_flag" );      // u(1): chroma_weight_l0_flag
3197        wp[1].bPresentFlag = ( uiCode == 1 );
3198        wp[2].bPresentFlag = ( uiCode == 1 );
3199        uiTotalSignalledWeightFlags += 2*wp[1].bPresentFlag;
3200      }
3201    }
3202    for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ ) 
3203    {
3204      pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
3205      if ( wp[0].bPresentFlag ) 
3206      {
3207        Int iDeltaWeight;
3208        READ_SVLC( iDeltaWeight, "delta_luma_weight_lX" );  // se(v): delta_luma_weight_l0[i]
3209        assert( iDeltaWeight >= -128 );
3210        assert( iDeltaWeight <=  127 );
3211        wp[0].iWeight = (iDeltaWeight + (1<<wp[0].uiLog2WeightDenom));
3212        READ_SVLC( wp[0].iOffset, "luma_offset_lX" );       // se(v): luma_offset_l0[i]
3213        assert( wp[0].iOffset >= -128 );
3214        assert( wp[0].iOffset <=  127 );
3215      }
3216      else 
3217      {
3218        wp[0].iWeight = (1 << wp[0].uiLog2WeightDenom);
3219        wp[0].iOffset = 0;
3220      }
3221      if ( bChroma ) 
3222      {
3223        if ( wp[1].bPresentFlag ) 
3224        {
3225          for ( Int j=1 ; j<3 ; j++ ) 
3226          {
3227            Int iDeltaWeight;
3228            READ_SVLC( iDeltaWeight, "delta_chroma_weight_lX" );  // se(v): chroma_weight_l0[i][j]
3229            assert( iDeltaWeight >= -128 );
3230            assert( iDeltaWeight <=  127 );
3231            wp[j].iWeight = (iDeltaWeight + (1<<wp[1].uiLog2WeightDenom));
3232
3233            Int iDeltaChroma;
3234            READ_SVLC( iDeltaChroma, "delta_chroma_offset_lX" );  // se(v): delta_chroma_offset_l0[i][j]
3235            assert( iDeltaChroma >= -512 );
3236            assert( iDeltaChroma <=  511 );
3237            Int pred = ( 128 - ( ( 128*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) );
3238            wp[j].iOffset = Clip3(-128, 127, (iDeltaChroma + pred) );
3239          }
3240        }
3241        else 
3242        {
3243          for ( Int j=1 ; j<3 ; j++ ) 
3244          {
3245            wp[j].iWeight = (1 << wp[j].uiLog2WeightDenom);
3246            wp[j].iOffset = 0;
3247          }
3248        }
3249      }
3250    }
3251
3252    for ( Int iRefIdx=pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx<MAX_NUM_REF ; iRefIdx++ ) 
3253    {
3254      pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
3255
3256      wp[0].bPresentFlag = false;
3257      wp[1].bPresentFlag = false;
3258      wp[2].bPresentFlag = false;
3259    }
3260  }
3261  assert(uiTotalSignalledWeightFlags<=24);
3262}
3263
3264/** decode quantization matrix
3265* \param scalingList quantization matrix information
3266*/
3267Void TDecCavlc::parseScalingList(TComScalingList* scalingList)
3268{
3269  UInt  code, sizeId, listId;
3270  Bool scalingListPredModeFlag;
3271  //for each size
3272  for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3273  {
3274    for(listId = 0; listId <  g_scalingListNum[sizeId]; listId++)
3275    {
3276      READ_FLAG( code, "scaling_list_pred_mode_flag");
3277      scalingListPredModeFlag = (code) ? true : false;
3278      if(!scalingListPredModeFlag) //Copy Mode
3279      {
3280        READ_UVLC( code, "scaling_list_pred_matrix_id_delta");
3281        scalingList->setRefMatrixId (sizeId,listId,(UInt)((Int)(listId)-(code)));
3282        if( sizeId > SCALING_LIST_8x8 )
3283        {
3284          scalingList->setScalingListDC(sizeId,listId,((listId == scalingList->getRefMatrixId (sizeId,listId))? 16 :scalingList->getScalingListDC(sizeId, scalingList->getRefMatrixId (sizeId,listId))));
3285        }
3286        scalingList->processRefMatrix( sizeId, listId, scalingList->getRefMatrixId (sizeId,listId));
3287
3288      }
3289      else //DPCM Mode
3290      {
3291        xDecodeScalingList(scalingList, sizeId, listId);
3292      }
3293    }
3294  }
3295
3296  return;
3297}
3298/** decode DPCM
3299* \param scalingList  quantization matrix information
3300* \param sizeId size index
3301* \param listId list index
3302*/
3303Void TDecCavlc::xDecodeScalingList(TComScalingList *scalingList, UInt sizeId, UInt listId)
3304{
3305  Int i,coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
3306  Int data;
3307  Int scalingListDcCoefMinus8 = 0;
3308  Int nextCoef = SCALING_LIST_START_VALUE;
3309  UInt* scan  = (sizeId == 0) ? g_auiSigLastScan [ SCAN_DIAG ] [ 1 ] :  g_sigLastScanCG32x32;
3310  Int *dst = scalingList->getScalingListAddress(sizeId, listId);
3311
3312  if( sizeId > SCALING_LIST_8x8 )
3313  {
3314    READ_SVLC( scalingListDcCoefMinus8, "scaling_list_dc_coef_minus8");
3315    scalingList->setScalingListDC(sizeId,listId,scalingListDcCoefMinus8 + 8);
3316    nextCoef = scalingList->getScalingListDC(sizeId,listId);
3317  }
3318
3319  for(i = 0; i < coefNum; i++)
3320  {
3321    READ_SVLC( data, "scaling_list_delta_coef");
3322    nextCoef = (nextCoef + data + 256 ) % 256;
3323    dst[scan[i]] = nextCoef;
3324  }
3325}
3326
3327Bool TDecCavlc::xMoreRbspData()
3328{ 
3329  Int bitsLeft = m_pcBitstream->getNumBitsLeft();
3330
3331  // if there are more than 8 bits, it cannot be rbsp_trailing_bits
3332  if (bitsLeft > 8)
3333  {
3334    return true;
3335  }
3336
3337  UChar lastByte = m_pcBitstream->peekBits(bitsLeft);
3338  Int cnt = bitsLeft;
3339
3340  // remove trailing bits equal to zero
3341  while ((cnt>0) && ((lastByte & 1) == 0))
3342  {
3343    lastByte >>= 1;
3344    cnt--;
3345  }
3346  // remove bit equal to one
3347  cnt--;
3348
3349  // we should not have a negative number of bits
3350  assert (cnt>=0);
3351
3352  // we have more data, if cnt is not zero
3353  return (cnt>0);
3354}
3355
3356//! \}
3357
Note: See TracBrowser for help on using the repository browser.