source: 3DVCSoftware/branches/HTM-6.2-dev1-LG/source/Lib/TLibDecoder/TDecCAVLC.cpp @ 1404

Last change on this file since 1404 was 408, checked in by lg, 12 years ago

D0135->D0092->D0091

  • Property svn:eol-style set to native
File size: 93.8 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-2012, 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
42//! \ingroup TLibDecoder
43//! \{
44
45#if ENC_DEC_TRACE
46
47#define READ_CODE(length, code, name)     xReadCodeTr ( length, code, name )
48#define READ_UVLC(        code, name)     xReadUvlcTr (         code, name )
49#define READ_SVLC(        code, name)     xReadSvlcTr (         code, name )
50#define READ_FLAG(        code, name)     xReadFlagTr (         code, name )
51
52Void  xTraceSPSHeader (TComSPS *pSPS)
53{
54  fprintf( g_hTrace, "=========== Sequence Parameter Set ID: %d ===========\n", pSPS->getSPSId() );
55}
56
57Void  xTracePPSHeader (TComPPS *pPPS)
58{
59  fprintf( g_hTrace, "=========== Picture Parameter Set ID: %d ===========\n", pPPS->getPPSId() );
60}
61
62Void  xTraceAPSHeader (TComAPS *pAPS)
63{
64  fprintf( g_hTrace, "=========== Adaptation Parameter Set ===========\n");
65}
66
67Void  xTraceSliceHeader (TComSlice *pSlice)
68{
69  fprintf( g_hTrace, "=========== Slice ===========\n");
70}
71
72
73Void  TDecCavlc::xReadCodeTr           (UInt length, UInt& rValue, const Char *pSymbolName)
74{
75  xReadCode (length, rValue);
76  fprintf( g_hTrace, "%8lld  ", g_nSymbolCounter++ );
77  fprintf( g_hTrace, "%-40s u(%d) : %d\n", pSymbolName, length, rValue ); 
78  fflush ( g_hTrace );
79}
80
81Void  TDecCavlc::xReadUvlcTr           (UInt& rValue, const Char *pSymbolName)
82{
83  xReadUvlc (rValue);
84  fprintf( g_hTrace, "%8lld  ", g_nSymbolCounter++ );
85  fprintf( g_hTrace, "%-40s u(v) : %d\n", pSymbolName, rValue ); 
86  fflush ( g_hTrace );
87}
88
89Void  TDecCavlc::xReadSvlcTr           (Int& rValue, const Char *pSymbolName)
90{
91  xReadSvlc(rValue);
92  fprintf( g_hTrace, "%8lld  ", g_nSymbolCounter++ );
93  fprintf( g_hTrace, "%-40s s(v) : %d\n", pSymbolName, rValue ); 
94  fflush ( g_hTrace );
95}
96
97Void  TDecCavlc::xReadFlagTr           (UInt& rValue, const Char *pSymbolName)
98{
99  xReadFlag(rValue);
100  fprintf( g_hTrace, "%8lld  ", g_nSymbolCounter++ );
101  fprintf( g_hTrace, "%-40s u(1) : %d\n", pSymbolName, rValue ); 
102  fflush ( g_hTrace );
103}
104
105#else
106
107#define READ_CODE(length, code, name)     xReadCode ( length, code )
108#define READ_UVLC(        code, name)     xReadUvlc (         code )
109#define READ_SVLC(        code, name)     xReadSvlc (         code )
110#define READ_FLAG(        code, name)     xReadFlag (         code )
111
112#endif
113
114
115
116// ====================================================================================================================
117// Constructor / destructor / create / destroy
118// ====================================================================================================================
119
120TDecCavlc::TDecCavlc()
121{
122  m_iSliceGranularity = 0;
123
124  m_aaiTempScale            = new Int* [ MAX_VIEW_NUM ];
125  m_aaiTempOffset           = new Int* [ MAX_VIEW_NUM ];
126  m_aaiTempPdmScaleNomDelta = new Int* [ MAX_VIEW_NUM ];
127  m_aaiTempPdmOffset        = new Int* [ MAX_VIEW_NUM ];
128  for( UInt uiVId = 0; uiVId < MAX_VIEW_NUM; uiVId++ )
129  {
130    m_aaiTempScale            [ uiVId ] = new Int [ MAX_VIEW_NUM ];
131    m_aaiTempOffset           [ uiVId ] = new Int [ MAX_VIEW_NUM ];
132    m_aaiTempPdmScaleNomDelta [ uiVId ] = new Int [ MAX_VIEW_NUM ];
133    m_aaiTempPdmOffset        [ uiVId ] = new Int [ MAX_VIEW_NUM ];
134  }
135}
136
137TDecCavlc::~TDecCavlc()
138{
139  for( UInt uiVId = 0; uiVId < MAX_VIEW_NUM; uiVId++ )
140  {
141    delete [] m_aaiTempScale            [ uiVId ];
142    delete [] m_aaiTempOffset           [ uiVId ];
143    delete [] m_aaiTempPdmScaleNomDelta [ uiVId ];
144    delete [] m_aaiTempPdmOffset        [ uiVId ];
145  }
146  delete [] m_aaiTempScale;
147  delete [] m_aaiTempOffset;
148  delete [] m_aaiTempPdmScaleNomDelta;
149  delete [] m_aaiTempPdmOffset;
150}
151
152// ====================================================================================================================
153// Public member functions
154// ====================================================================================================================
155
156/**
157 * unmarshal a sequence of SEI messages from bitstream.
158 */
159void TDecCavlc::parseSEI(SEImessages& seis)
160{
161  assert(!m_pcBitstream->getNumBitsUntilByteAligned());
162  do
163  {
164    parseSEImessage(*m_pcBitstream, seis);
165    /* SEI messages are an integer number of bytes, something has failed
166     * in the parsing if bitstream not byte-aligned */
167    assert(!m_pcBitstream->getNumBitsUntilByteAligned());
168  } while (0x80 != m_pcBitstream->peekBits(8));
169  assert(m_pcBitstream->getNumBitsLeft() == 8); /* rsbp_trailing_bits */
170}
171void TDecCavlc::parseShortTermRefPicSet( TComSPS* sps, TComReferencePictureSet* rps, Int idx )
172{
173  UInt code;
174  UInt interRPSPred;
175  READ_FLAG(interRPSPred, "inter_ref_pic_set_prediction_flag");  rps->setInterRPSPrediction(interRPSPred);
176  if (interRPSPred) 
177  {
178    UInt bit;
179    READ_UVLC(code, "delta_idx_minus1" ); // delta index of the Reference Picture Set used for prediction minus 1
180    Int rIdx =  idx - 1 - code;
181    assert (rIdx <= idx && rIdx >= 0);
182    TComReferencePictureSet*   rpsRef = sps->getRPSList()->getReferencePictureSet(rIdx);
183    Int k = 0, k0 = 0, k1 = 0;
184    READ_CODE(1, bit, "delta_rps_sign"); // delta_RPS_sign
185    READ_UVLC(code, "abs_delta_rps_minus1");  // absolute delta RPS minus 1
186    Int deltaRPS = (1 - (bit<<1)) * (code + 1); // delta_RPS
187    for(Int j=0 ; j <= rpsRef->getNumberOfPictures(); j++)
188    {
189      READ_CODE(1, bit, "used_by_curr_pic_flag" ); //first bit is "1" if Idc is 1
190      Int refIdc = bit;
191      if (refIdc == 0) 
192      {
193        READ_CODE(1, bit, "use_delta_flag" ); //second bit is "1" if Idc is 2, "0" otherwise.
194        refIdc = bit<<1; //second bit is "1" if refIdc is 2, "0" if refIdc = 0.
195      }
196      if (refIdc == 1 || refIdc == 2)
197      {
198        Int deltaPOC = deltaRPS + ((j < rpsRef->getNumberOfPictures())? rpsRef->getDeltaPOC(j) : 0);
199        rps->setDeltaPOC(k, deltaPOC);
200        rps->setUsed(k, (refIdc == 1));
201
202        if (deltaPOC < 0) {
203          k0++;
204        }
205        else 
206        {
207          k1++;
208        }
209        k++;
210      } 
211      rps->setRefIdc(j,refIdc); 
212    }
213    rps->setNumRefIdc(rpsRef->getNumberOfPictures()+1); 
214    rps->setNumberOfPictures(k);
215    rps->setNumberOfNegativePictures(k0);
216    rps->setNumberOfPositivePictures(k1);
217    rps->sortDeltaPOC();
218  }
219  else
220  {
221    READ_UVLC(code, "num_negative_pics");           rps->setNumberOfNegativePictures(code);
222    READ_UVLC(code, "num_positive_pics");           rps->setNumberOfPositivePictures(code);
223    Int prev = 0;
224    Int poc;
225    for(Int j=0 ; j < rps->getNumberOfNegativePictures(); j++)
226    {
227      READ_UVLC(code, "delta_poc_s0_minus1");
228      poc = prev-code-1;
229      prev = poc;
230      rps->setDeltaPOC(j,poc);
231      READ_FLAG(code, "used_by_curr_pic_s0_flag");  rps->setUsed(j,code);
232    }
233    prev = 0;
234    for(Int j=rps->getNumberOfNegativePictures(); j < rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures(); j++)
235    {
236      READ_UVLC(code, "delta_poc_s1_minus1");
237      poc = prev+code+1;
238      prev = poc;
239      rps->setDeltaPOC(j,poc);
240      READ_FLAG(code, "used_by_curr_pic_s1_flag");  rps->setUsed(j,code);
241    }
242    rps->setNumberOfPictures(rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures());
243  }
244#if PRINT_RPS_INFO
245  rps->printDeltaPOC();
246#endif
247}
248
249Void TDecCavlc::parseAPS(TComAPS* aps)
250{
251#if ENC_DEC_TRACE 
252  xTraceAPSHeader(aps);
253#endif
254
255  UInt uiCode;
256  READ_UVLC(uiCode, "aps_id");                             aps->setAPSID(uiCode);
257  READ_FLAG(uiCode, "aps_scaling_list_data_present_flag"); aps->setScalingListEnabled( (uiCode==1)?true:false );
258  READ_FLAG(uiCode, "aps_deblocking_filter_flag");         aps->setLoopFilterOffsetInAPS( (uiCode==1)?true:false );
259  if(aps->getScalingListEnabled())
260  {
261    parseScalingList( aps->getScalingList() );
262  }
263  if(aps->getLoopFilterOffsetInAPS())
264  {
265    xParseDblParam( aps );   
266  }
267#if !LGE_SAO_MIGRATION_D0091
268  READ_FLAG(uiCode, "aps_sao_interleaving_flag");      aps->setSaoInterleavingFlag( (uiCode==1)?true:false );
269  if(!aps->getSaoInterleavingFlag())
270  {
271    READ_FLAG(uiCode, "aps_sample_adaptive_offset_flag");      aps->setSaoEnabled( (uiCode==1)?true:false );
272  if(aps->getSaoEnabled())
273  {
274    aps->getSaoParam()->bSaoFlag[0] = true;
275    xParseSaoParam( aps->getSaoParam() );
276  }
277  }
278#endif
279  READ_FLAG(uiCode, "aps_adaptive_loop_filter_flag");      aps->setAlfEnabled( (uiCode==1)?true:false );
280  if(aps->getAlfEnabled())
281  {
282    xParseAlfParam( aps->getAlfParam());
283  }
284  READ_FLAG( uiCode, "aps_extension_flag");
285  if (uiCode)
286  {
287    while ( xMoreRbspData() )
288    {
289      READ_FLAG( uiCode, "aps_extension_data_flag");
290    }
291  }
292
293}
294
295Void  TDecCavlc::xParseDblParam       ( TComAPS* aps )
296{
297  UInt uiSymbol;
298  Int iSymbol;
299
300  parseDFFlag(uiSymbol, "loop_filter_disable");
301  aps->setLoopFilterDisable(uiSymbol?true:false);
302
303  if (!aps->getLoopFilterDisable())
304  {
305    parseDFSvlc(iSymbol, "beta_offset_div2");
306    aps->setLoopFilterBetaOffset(iSymbol);
307    parseDFSvlc(iSymbol, "tc_offset_div2");
308    aps->setLoopFilterTcOffset(iSymbol);
309  }
310}
311#if !LGE_SAO_MIGRATION_D0091
312/** parse SAO parameters
313 * \param pSaoParam
314 */
315Void TDecCavlc::xParseSaoParam(SAOParam* pSaoParam)
316{
317  UInt uiSymbol;
318
319  int i,j, compIdx; 
320  int numCuInWidth; 
321  int numCuInHeight; 
322  Bool repeatedRow[3];
323  if (pSaoParam->bSaoFlag[0])                                                                   
324  {     
325    READ_FLAG (uiSymbol, "sao_cb_enable_flag");            pSaoParam->bSaoFlag[1]   = uiSymbol? true:false; 
326    READ_FLAG (uiSymbol, "sao_cr_enable_flag");            pSaoParam->bSaoFlag[2]   = uiSymbol? true:false; 
327    READ_UVLC (uiSymbol, "sao_num_lcu_in_width_minus1");   pSaoParam->numCuInWidth  = uiSymbol + 1;                         
328    READ_UVLC (uiSymbol, "sao_num_lcu_in_height_minus1");  pSaoParam->numCuInHeight = uiSymbol + 1;                         
329    numCuInWidth  = pSaoParam->numCuInWidth;
330    numCuInHeight = pSaoParam->numCuInHeight;
331
332    READ_FLAG (uiSymbol, "sao_one_luma_unit_flag");  pSaoParam->oneUnitFlag[0] = uiSymbol? true:false; 
333    if (pSaoParam->oneUnitFlag[0] )
334      xParseSaoOffset(&(pSaoParam->saoLcuParam[0][0]));
335
336    if (pSaoParam->bSaoFlag[1])
337    {
338      READ_FLAG (uiSymbol, "sao_one_cb_unit_flag");  pSaoParam->oneUnitFlag[1] = uiSymbol? true:false; 
339      if (pSaoParam->oneUnitFlag[1] )
340        xParseSaoOffset(&(pSaoParam->saoLcuParam[1][0]));
341    }
342    if (pSaoParam->bSaoFlag[2])
343    {
344      READ_FLAG (uiSymbol, "sao_one_cr_unit_flag");  pSaoParam->oneUnitFlag[2] = uiSymbol? true:false; 
345      if (pSaoParam->oneUnitFlag[2] )
346        xParseSaoOffset(&(pSaoParam->saoLcuParam[2][0]));
347    }
348    for (j=0;j<numCuInHeight;j++)
349    {
350      for (compIdx=0;compIdx<3;compIdx++)
351      {
352        repeatedRow[compIdx] = 0;
353      }
354      for (i=0;i<numCuInWidth;i++)
355      {
356        for (compIdx=0; compIdx<3; compIdx++)
357        {
358          if (pSaoParam->bSaoFlag[compIdx]  && !pSaoParam->oneUnitFlag[compIdx]) 
359          {
360            if (j>0 && i==0) 
361            {
362              READ_FLAG (uiSymbol, "sao_repeat_row_flag");  repeatedRow[compIdx] = uiSymbol? true:false; 
363            }
364            xParseSaoUnit (i,j, compIdx, pSaoParam, repeatedRow[compIdx]);
365          }
366        }
367      }
368    }
369  }
370}
371/** copy SAO parameter
372 * \param dst 
373 * \param src
374 */
375inline Void copySaoOneLcuParam(SaoLcuParam* dst,  SaoLcuParam* src)
376{
377  Int i;
378  dst->partIdx = src->partIdx;
379  dst->typeIdx = src->typeIdx;
380  if (dst->typeIdx != -1)
381  {
382    if (dst->typeIdx == SAO_BO)
383    {
384      dst->bandPosition = src->bandPosition ;
385    }
386    else
387    {
388      dst->bandPosition = 0;
389    }
390    dst->length  = src->length;
391    for (i=0;i<dst->length;i++)
392    {
393      dst->offset[i] = src->offset[i];
394    }
395  }
396  else
397  {
398    dst->length  = 0;
399    for (i=0;i<SAO_BO_LEN;i++)
400    {
401      dst->offset[i] = 0;
402    }
403  }
404}
405/** parse SAO offset
406 * \param saoLcuParam SAO LCU parameters
407 */
408Void TDecCavlc::xParseSaoOffset(SaoLcuParam* saoLcuParam)
409{
410  UInt uiSymbol;
411  Int iSymbol;
412  static Int typeLength[MAX_NUM_SAO_TYPE] = {
413    SAO_EO_LEN,
414    SAO_EO_LEN,
415    SAO_EO_LEN,
416    SAO_EO_LEN,
417    SAO_BO_LEN
418  }; 
419
420  READ_UVLC (uiSymbol, "sao_type_idx");   saoLcuParam->typeIdx = (Int)uiSymbol - 1;       
421  if (uiSymbol)
422  {
423    saoLcuParam->length = typeLength[saoLcuParam->typeIdx];
424    if( saoLcuParam->typeIdx == SAO_BO )
425    {
426      READ_CODE( 5, uiSymbol, "sao_band_position"); saoLcuParam->bandPosition = uiSymbol; 
427      for(Int i=0; i< saoLcuParam->length; i++)
428      {
429        READ_SVLC (iSymbol, "sao_offset");    saoLcuParam->offset[i] = iSymbol;   
430      }   
431    }
432    else if( saoLcuParam->typeIdx < 4 )
433    {
434      READ_UVLC (uiSymbol, "sao_offset");  saoLcuParam->offset[0] = uiSymbol;
435      READ_UVLC (uiSymbol, "sao_offset");  saoLcuParam->offset[1] = uiSymbol;
436      READ_UVLC (uiSymbol, "sao_offset");  saoLcuParam->offset[2] = -(Int)uiSymbol;
437      READ_UVLC (uiSymbol, "sao_offset");  saoLcuParam->offset[3] = -(Int)uiSymbol;
438    }
439  }
440  else
441  {
442    saoLcuParam->length = 0;
443  }
444}
445
446/** parse SAO unit
447 * \param rx x-axis location
448 * \param ry y-axis location
449 * \param compIdx color component index
450 * \param saoParam SAO parameters
451 * \param repeatedRow repeat row flag
452 */
453void TDecCavlc::xParseSaoUnit(Int rx, Int ry, Int compIdx, SAOParam* saoParam, Bool& repeatedRow )
454{
455  int addr, addrUp, addrLeft; 
456  int numCuInWidth  = saoParam->numCuInWidth;
457  SaoLcuParam* saoOneLcu;
458  SaoLcuParam* saoOneLcuUp;
459  SaoLcuParam* saoOneLcuLeft;
460  UInt uiSymbol;
461  Int  iSymbol;
462  Int  runLeft;
463  UInt maxValue;
464
465  addr      =  rx + ry*numCuInWidth;
466  addrLeft  =  (addr%numCuInWidth == 0) ? -1 : addr - 1;
467  addrUp    =  (addr<numCuInWidth)      ? -1 : addr - numCuInWidth;
468
469  saoOneLcu = &(saoParam->saoLcuParam[compIdx][addr]);     
470  if (!repeatedRow)
471  {
472    runLeft = (addrLeft>=0 )  ? saoParam->saoLcuParam[compIdx][addrLeft].run : -1;
473    if (rx == 0 || runLeft==0)
474    {
475      saoOneLcu->mergeLeftFlag = 0;
476      if (ry == 0)
477      {
478        maxValue = numCuInWidth-rx-1;
479        UInt length = 0;
480        UInt val = 0;
481        if (maxValue)
482        {
483          for(UInt i=0; i<32; i++)
484          {
485            if(maxValue&0x1)
486            {
487              length = i+1;
488            }
489            maxValue = (maxValue >> 1);
490          }
491          if(length)
492          {
493            READ_CODE(length, val, "sao_run_diff");
494          }
495        }
496        uiSymbol = val;
497        saoOneLcu->runDiff = uiSymbol; 
498        xParseSaoOffset(saoOneLcu);
499        saoOneLcu->run = saoOneLcu->runDiff;
500      }
501      else 
502      {
503        saoOneLcuUp = &(saoParam->saoLcuParam[compIdx][addrUp]);
504        READ_SVLC (iSymbol , "sao_run_diff"     );  saoOneLcu->runDiff = iSymbol; 
505        READ_FLAG (uiSymbol, "sao_merge_up_flag");  saoOneLcu->mergeUpFlag   = uiSymbol? true:false;
506        if (!saoOneLcu->mergeUpFlag)
507        {
508          xParseSaoOffset(saoOneLcu);
509        }
510        else
511        {
512          saoOneLcuUp = &(saoParam->saoLcuParam[compIdx][addrUp]);
513          copySaoOneLcuParam(saoOneLcu, saoOneLcuUp);
514        }
515        saoOneLcu->run = saoOneLcu->runDiff + saoOneLcuUp->run;
516      }
517    }
518    else
519    {
520      saoOneLcuLeft = &(saoParam->saoLcuParam[compIdx][addrLeft]);
521      copySaoOneLcuParam(saoOneLcu, saoOneLcuLeft);
522      saoOneLcu->mergeLeftFlag = 1;
523      saoOneLcu->run = saoOneLcuLeft->run-1;
524    }
525  }
526  else
527  {
528    if (ry > 0)
529    {
530      saoOneLcuUp = &(saoParam->saoLcuParam[compIdx][addrUp]);
531      copySaoOneLcuParam(saoOneLcu, saoOneLcuUp);
532      saoOneLcu->mergeLeftFlag = 0;
533      saoOneLcu->run = saoOneLcuUp->run;
534    }
535  }
536}
537#endif
538
539Void TDecCavlc::xParseAlfParam(AlfParamSet* pAlfParamSet, Bool bSentInAPS, Int firstLCUAddr, Bool acrossSlice, Int numLCUInWidth, Int numLCUInHeight)
540{
541  Int  numLCU;
542  UInt uiSymbol;
543  Bool isEnabled[NUM_ALF_COMPONENT];
544  Bool isUniParam[NUM_ALF_COMPONENT];
545 
546  isEnabled[ALF_Y] = true;
547  READ_FLAG(uiSymbol, "alf_cb_enable_flag");  isEnabled[ALF_Cb] = ((uiSymbol ==1)?true:false);
548  READ_FLAG(uiSymbol, "alf_cr_enable_flag");  isEnabled[ALF_Cr] = ((uiSymbol ==1)?true:false);
549  READ_FLAG(uiSymbol, "alf_one_luma_unit_per_slice_flag");   isUniParam[ALF_Y] = ((uiSymbol ==1)?true:false);
550 
551  isUniParam[ALF_Cb] = true;
552  if (isEnabled[ALF_Cb])
553  {
554    READ_FLAG(uiSymbol, "alf_one_cb_unit_per_slice_flag");   isUniParam[ALF_Cb] = ((uiSymbol ==1)?true:false);
555  }
556 
557  isUniParam[ALF_Cr] = true;
558  if (isEnabled[ALF_Cr])
559  {
560    READ_FLAG(uiSymbol, "alf_one_cr_unit_per_slice_flag");   isUniParam[ALF_Cr] = ((uiSymbol ==1)?true:false);
561  }
562 
563  if(bSentInAPS)
564  {
565    READ_UVLC(uiSymbol, "alf_num_lcu_in_width_minus1");  numLCUInWidth = uiSymbol+1;
566    READ_UVLC(uiSymbol, "alf_num_lcu_in_height_minus1");  numLCUInHeight = uiSymbol+1;
567    numLCU = numLCUInWidth*numLCUInHeight;
568  }
569  else //sent in slice header
570  {
571    READ_UVLC(uiSymbol, "alf_num_lcu_in_slice_minus1");  numLCU = uiSymbol+1;
572  }
573 
574  assert(pAlfParamSet != NULL);
575 
576  pAlfParamSet->create(numLCUInWidth, numLCUInHeight, numLCU);
577  for(Int compIdx = 0; compIdx < NUM_ALF_COMPONENT; compIdx++)
578  {
579    pAlfParamSet->isEnabled[compIdx] = isEnabled[compIdx];
580    pAlfParamSet->isUniParam[compIdx]= isUniParam[compIdx];
581  }
582 
583  parseAlfParamSet(pAlfParamSet, firstLCUAddr, acrossSlice);
584}
585
586
587Void TDecCavlc::parseAlfParamSet(AlfParamSet* pAlfParamSet, Int firstLCUAddr, Bool alfAcrossSlice)
588{
589  Int numLCUInWidth = pAlfParamSet->numLCUInWidth;
590  Int numLCU        = pAlfParamSet->numLCU;
591 
592  static Bool isRepeatedRow   [NUM_ALF_COMPONENT];
593  static Int  numStoredFilters[NUM_ALF_COMPONENT];
594  static Int* run             [NUM_ALF_COMPONENT];
595 
596  for(Int compIdx =0; compIdx < NUM_ALF_COMPONENT; compIdx++)
597  {
598    isRepeatedRow[compIdx]    = false;
599    numStoredFilters[compIdx] = 0;
600   
601    run[compIdx] = new Int[numLCU+1];
602    run[compIdx][0] = -1; 
603  }
604 
605  UInt uiSymbol;
606  Int  iSymbol, ry, rx, addrUp;
607 
608  for(Int i=0; i< numLCU; i++)
609  {
610    rx    = (i+ firstLCUAddr)% numLCUInWidth;
611    ry    = (i+ firstLCUAddr)/ numLCUInWidth;
612   
613    for(Int compIdx =0; compIdx < NUM_ALF_COMPONENT; compIdx++)
614    {
615      AlfUnitParam& alfUnitParam = pAlfParamSet->alfUnitParam[compIdx][i];
616     
617      if(pAlfParamSet->isEnabled[compIdx])
618      {
619        if(!pAlfParamSet->isUniParam[compIdx])
620        {
621          addrUp = i-numLCUInWidth;
622          if(rx ==0 && addrUp >=0)
623          {
624            READ_FLAG(uiSymbol, "alf_repeat_row _flag"); isRepeatedRow[compIdx] = ((uiSymbol ==1)?true:false);
625          }
626         
627          if(isRepeatedRow[compIdx])
628          {
629            alfUnitParam.mergeType = ALF_MERGE_UP;
630            assert(addrUp >=0);
631            run[compIdx][i] = run[compIdx][addrUp];
632          }
633          else
634          {
635            if(rx == 0 || run[compIdx][i] < 0)
636            {             
637              if(addrUp < 0)
638              {
639                //alf_run_diff u(v)
640                parseAlfFixedLengthRun(uiSymbol, rx, numLCUInWidth);
641                run[compIdx][i] = uiSymbol;
642              }
643              else
644              {
645                //alf_run_diff s(v)
646                READ_SVLC(iSymbol, "alf_run_diff");
647                run[compIdx][i] = run[compIdx][addrUp] + iSymbol;
648                assert(run[compIdx][i] >= 0);
649              }
650             
651              if(ry > 0 && (addrUp >=0 || alfAcrossSlice))
652              {
653                //alf_merge_up_flag
654                READ_FLAG(uiSymbol, "alf_merge_up_flag");  alfUnitParam.mergeType = ((uiSymbol ==1)?ALF_MERGE_UP:ALF_MERGE_DISABLED);
655              }
656              else
657              {
658                alfUnitParam.mergeType = ALF_MERGE_DISABLED;
659              }
660             
661              if(alfUnitParam.mergeType != ALF_MERGE_UP)
662              {
663                //alf_lcu_enable_flag
664                READ_FLAG(uiSymbol, "alf_lcu_enable_flag");  alfUnitParam.isEnabled = ((uiSymbol ==1)?true:false);
665               
666                if(alfUnitParam.isEnabled)
667                {
668                  if(numStoredFilters[compIdx] > 0)
669                  {
670                    //alf_new_filter_set_flag
671                    READ_FLAG(uiSymbol, "alf_new_filter_set_flag");  alfUnitParam.isNewFilt = ((uiSymbol ==1)?true:false);
672                   
673                    if(!alfUnitParam.isNewFilt)
674                    {
675                      //alf_stored_filter_set_idx
676                      parseAlfStoredFilterIdx(uiSymbol, numStoredFilters[compIdx]);
677                     
678                      alfUnitParam.storedFiltIdx = uiSymbol;
679                     
680                      assert( alfUnitParam.storedFiltIdx < numStoredFilters[compIdx]);
681                    }
682                  }
683                  else
684                  {
685                    alfUnitParam.isNewFilt = true;
686                  }
687                 
688                  if(alfUnitParam.isNewFilt)
689                  {
690                    alfUnitParam.alfFiltParam = new ALFParam(compIdx);
691                    xParseAlfParam(alfUnitParam.alfFiltParam);
692                    alfUnitParam.alfFiltParam->alf_flag = 1;
693                   
694                    numStoredFilters[compIdx]++;
695                  }
696                }
697               
698              }
699            }
700            else
701            {
702              alfUnitParam.mergeType = ALF_MERGE_LEFT;
703            }
704           
705            run[compIdx][i+1] = run[compIdx][i] -1;
706          }
707         
708        }
709        else // uni-param
710        {
711          if(i == 0)
712          {
713            alfUnitParam.mergeType = ALF_MERGE_DISABLED;
714           
715            //alf_lcu_enable_flag
716            READ_FLAG(uiSymbol, "alf_lcu_enable_flag");  alfUnitParam.isEnabled = ((uiSymbol ==1)?true:false);
717            if(alfUnitParam.isEnabled)
718            {
719              alfUnitParam.isNewFilt = true;
720              alfUnitParam.alfFiltParam = new ALFParam(compIdx);
721              xParseAlfParam(alfUnitParam.alfFiltParam);
722              alfUnitParam.alfFiltParam->alf_flag = 1;
723            }
724          }
725          else
726          {
727            alfUnitParam.mergeType = ALF_MERGE_FIRST;
728          }
729         
730        }
731      }
732      else
733      {
734        alfUnitParam.mergeType = ALF_MERGE_DISABLED;
735        alfUnitParam.isEnabled = false;
736      }
737    }
738  }
739 
740  for(Int compIdx =0; compIdx < NUM_ALF_COMPONENT; compIdx++)
741  {
742    delete[] run[compIdx];
743  }
744}
745
746
747Void TDecCavlc::parseAlfFixedLengthRun( UInt& idx, UInt rx, UInt numLCUInWidth )
748{
749  assert(numLCUInWidth > rx);
750 
751  UInt length = 0; 
752  UInt maxNumRun = numLCUInWidth - rx - 1; 
753 
754  for(UInt i=0; i<32; i++)
755  {
756    if(maxNumRun&0x1)
757    {
758      length = i+1;
759    }
760    maxNumRun = (maxNumRun >> 1);
761  }
762 
763  idx = 0;
764  if(length)
765  {
766    READ_CODE( length, idx, "alf_run_diff" );
767  }
768  else
769  {
770    idx = 0;
771  }
772}
773
774
775Void TDecCavlc::parseAlfStoredFilterIdx( UInt& idx, UInt numFilterSetsInBuffer )
776{
777  assert(numFilterSetsInBuffer > 0);
778 
779  UInt length = 0; 
780  UInt maxValue = numFilterSetsInBuffer - 1;
781 
782  for(UInt i=0; i<32; i++)
783  {
784    if(maxValue&0x1)
785    {
786      length = i+1;
787    }
788    maxValue = (maxValue >> 1);
789  }
790 
791  idx = 0;
792  if(length)
793  {
794    READ_CODE( length, idx, "alf_stored_filter_set_idx" );
795  }
796  else
797  {
798    idx = 0;
799  }
800}
801
802
803Void TDecCavlc::xParseAlfParam(ALFParam* pAlfParam)
804{
805  UInt uiSymbol;
806  Int iSymbol;
807  Int sqrFiltLengthTab[NUM_ALF_FILTER_SHAPE] = {ALF_FILTER_LEN}; 
808
809  switch(pAlfParam->componentID)
810  {
811  case ALF_Cb:
812  case ALF_Cr:
813    {
814      pAlfParam->filter_shape = ALF_CROSS9x7_SQUARE3x3;
815      pAlfParam->num_coeff = sqrFiltLengthTab[pAlfParam->filter_shape];
816      pAlfParam->filters_per_group = 1;
817      for(Int pos=0; pos< pAlfParam->num_coeff; pos++)
818      {
819        READ_SVLC(iSymbol, "alf_filt_coeff");
820        pAlfParam->coeffmulti[0][pos] = iSymbol;
821      }
822    }
823    break;
824  case ALF_Y:
825    {
826  pAlfParam->filters_per_group = 0;
827  memset (pAlfParam->filterPattern, 0 , sizeof(Int)*NO_VAR_BINS);
828  pAlfParam->filter_shape = 0;
829  pAlfParam->num_coeff = sqrFiltLengthTab[pAlfParam->filter_shape];
830
831  // filters_per_fr
832  READ_UVLC (uiSymbol, "alf_no_filters_minus1");
833  pAlfParam->filters_per_group = uiSymbol + 1;
834
835  if(uiSymbol == 1) // filters_per_group == 2
836  {
837    READ_UVLC (uiSymbol, "alf_start_second_filter");
838    pAlfParam->startSecondFilter = uiSymbol;
839    pAlfParam->filterPattern [uiSymbol] = 1;
840  }
841  else if (uiSymbol > 1) // filters_per_group > 2
842  {
843    pAlfParam->filters_per_group = 1;
844    Int numMergeFlags = 16;
845    for (Int i=1; i<numMergeFlags; i++) 
846    {
847      READ_FLAG (uiSymbol,  "alf_filter_pattern");
848      pAlfParam->filterPattern[i] = uiSymbol;
849      pAlfParam->filters_per_group += uiSymbol;
850    }
851  }
852
853  if (pAlfParam->filters_per_group > 1)
854  {
855    READ_FLAG (uiSymbol, "alf_pred_method");
856    pAlfParam->predMethod = uiSymbol;
857  }
858  for(Int idx = 0; idx < pAlfParam->filters_per_group; ++idx)
859  {
860    READ_FLAG (uiSymbol,"alf_nb_pred_luma");
861    pAlfParam->nbSPred[idx] = uiSymbol;
862  }
863
864  Int minScanVal = MIN_SCAN_POS_CROSS;
865
866  // Determine maxScanVal
867  Int maxScanVal = 0;
868  Int *pDepthInt = pDepthIntTabShapes[pAlfParam->filter_shape];
869  for(Int idx = 0; idx < pAlfParam->num_coeff; idx++)
870  {
871    maxScanVal = max(maxScanVal, pDepthInt[idx]);
872  }
873
874  // Golomb parameters
875  if( pAlfParam->filters_per_group > 1 )
876  {
877  READ_UVLC (uiSymbol, "alf_min_kstart_minus1");
878  pAlfParam->minKStart = 1 + uiSymbol;
879
880  Int kMin = pAlfParam->minKStart;
881
882  for(Int scanPos = minScanVal; scanPos < maxScanVal; scanPos++)
883  {
884    READ_FLAG (uiSymbol, "alf_golomb_index_bit");
885    pAlfParam->kMinTab[scanPos] = kMin + uiSymbol;
886    kMin = pAlfParam->kMinTab[scanPos];
887  }
888  }
889
890  Int scanPos;
891  for(Int idx = 0; idx < pAlfParam->filters_per_group; ++idx)
892  {
893    for(Int i = 0; i < pAlfParam->num_coeff; i++)
894    {
895      scanPos = pDepthInt[i] - 1;
896      Int k = (pAlfParam->filters_per_group == 1) ? kTableTabShapes[ALF_CROSS9x7_SQUARE3x3][i] : pAlfParam->kMinTab[scanPos];
897      pAlfParam->coeffmulti[idx][i] = xGolombDecode(k);
898    }
899  }
900    }
901    break;
902  default:
903    {
904      printf("Not a legal component ID for ALF\n");
905      assert(0);
906      exit(-1);
907    }
908  }
909}
910
911Int TDecCavlc::xGolombDecode(Int k)
912{
913  UInt uiSymbol;
914  Int q = -1;
915  Int nr = 0;
916  Int a;
917
918  uiSymbol = 1;
919  while (uiSymbol)
920  {
921    xReadFlag(uiSymbol);
922    q++;
923  }
924  for(a = 0; a < k; ++a)          // read out the sequential log2(M) bits
925  {
926    xReadFlag(uiSymbol);
927    if(uiSymbol)
928      nr += 1 << a;
929  }
930  nr += q << k;
931  if(nr != 0)
932  {
933    xReadFlag(uiSymbol);
934    nr = (uiSymbol)? nr: -nr;
935  }
936#if ENC_DEC_TRACE
937  fprintf( g_hTrace, "%8lld  ", g_nSymbolCounter++ );
938  fprintf( g_hTrace, "%-40s ge(v) : %d\n", "alf_coeff_luma", nr ); 
939#endif
940  return nr;
941}
942
943Void TDecCavlc::parsePPS(TComPPS* pcPPS, ParameterSetManagerDecoder *parameterSet)
944{
945#if ENC_DEC_TRACE 
946  xTracePPSHeader (pcPPS);
947#endif
948  UInt  uiCode;
949
950  Int   iCode;
951
952  READ_UVLC( uiCode, "pic_parameter_set_id");                      pcPPS->setPPSId (uiCode);
953  READ_UVLC( uiCode, "seq_parameter_set_id");                      pcPPS->setSPSId (uiCode);
954
955  READ_FLAG ( uiCode, "sign_data_hiding_flag" ); pcPPS->setSignHideFlag( uiCode );
956  if( pcPPS->getSignHideFlag() )
957  {
958    READ_CODE( 4, uiCode, "sign_hiding_threshold"); pcPPS->setTSIG(uiCode);
959  }
960
961#if CABAC_INIT_FLAG
962  READ_FLAG( uiCode,   "cabac_init_present_flag" );            pcPPS->setCabacInitPresentFlag( uiCode ? true : false );
963#endif
964  // entropy_coding_mode_flag
965  // We code the entropy_coding_mode_flag, it's needed for tests.
966  READ_FLAG( uiCode, "entropy_coding_mode_flag" );                 pcPPS->setEntropyCodingMode( uiCode ? true : false );
967  if (pcPPS->getEntropyCodingMode())
968  {
969  }
970 
971  // num_ref_idx_l0_default_active_minus1
972  // num_ref_idx_l1_default_active_minus1
973  READ_SVLC(iCode, "pic_init_qp_minus26" );                        pcPPS->setPicInitQPMinus26(iCode);
974  READ_FLAG( uiCode, "constrained_intra_pred_flag" );              pcPPS->setConstrainedIntraPred( uiCode ? true : false );
975  READ_FLAG( uiCode, "enable_temporal_mvp_flag" );                 pcPPS->setEnableTMVPFlag( uiCode ? true : false );
976  READ_CODE( 2, uiCode, "slice_granularity" );                     pcPPS->setSliceGranularity(uiCode);
977
978  // alf_param() ?
979
980  READ_UVLC( uiCode, "max_cu_qp_delta_depth");
981  if(uiCode == 0)
982  {
983    pcPPS->setUseDQP (false);
984    pcPPS->setMaxCuDQPDepth( 0 );
985  }
986  else
987  {
988    pcPPS->setUseDQP (true);
989    pcPPS->setMaxCuDQPDepth(uiCode - 1);
990  }
991
992  READ_SVLC( iCode, "chroma_qp_offset");
993  pcPPS->setChromaQpOffset(iCode);
994
995  READ_SVLC( iCode, "chroma_qp_offset_2nd");
996  pcPPS->setChromaQpOffset2nd(iCode);
997
998  READ_FLAG( uiCode, "weighted_pred_flag" );          // Use of Weighting Prediction (P_SLICE)
999  pcPPS->setUseWP( uiCode==1 );
1000  READ_CODE( 2, uiCode, "weighted_bipred_idc" );      // Use of Bi-Directional Weighting Prediction (B_SLICE)
1001  pcPPS->setWPBiPredIdc( uiCode );
1002//printf("TDecCavlc::parsePPS():\tm_bUseWeightPred=%d\tm_uiBiPredIdc=%d\n", pcPPS->getUseWP(), pcPPS->getWPBiPredIdc());
1003
1004  READ_FLAG( uiCode, "output_flag_present_flag" );
1005  pcPPS->setOutputFlagPresentFlag( uiCode==1 );
1006
1007  if(parameterSet->getPrefetchedSPS(pcPPS->getSPSId())->getTilesOrEntropyCodingSyncIdc()==1)
1008  {
1009    READ_FLAG ( uiCode, "tile_info_present_flag" );
1010    pcPPS->setColumnRowInfoPresent(uiCode);
1011    READ_FLAG ( uiCode, "tile_control_present_flag" );
1012    pcPPS->setTileBehaviorControlPresentFlag(uiCode);
1013    if( pcPPS->getColumnRowInfoPresent() == 1 )
1014    {
1015      READ_UVLC ( uiCode, "num_tile_columns_minus1" );   
1016      pcPPS->setNumColumnsMinus1( uiCode ); 
1017      READ_UVLC ( uiCode, "num_tile_rows_minus1" ); 
1018      pcPPS->setNumRowsMinus1( uiCode ); 
1019      READ_FLAG ( uiCode, "uniform_spacing_flag" ); 
1020      pcPPS->setUniformSpacingIdr( uiCode );
1021
1022      if( pcPPS->getUniformSpacingIdr() == 0 )
1023      {
1024        UInt* columnWidth = (UInt*)malloc(pcPPS->getNumColumnsMinus1()*sizeof(UInt));
1025        for(UInt i=0; i<pcPPS->getNumColumnsMinus1(); i++)
1026        { 
1027          READ_UVLC( uiCode, "column_width" ); 
1028          columnWidth[i] = uiCode; 
1029        }
1030        pcPPS->setColumnWidth(columnWidth);
1031        free(columnWidth);
1032
1033        UInt* rowHeight = (UInt*)malloc(pcPPS->getNumRowsMinus1()*sizeof(UInt));
1034        for(UInt i=0; i<pcPPS->getNumRowsMinus1(); i++)
1035        {
1036          READ_UVLC( uiCode, "row_height" ); 
1037          rowHeight[i] = uiCode; 
1038        }
1039        pcPPS->setRowHeight(rowHeight);
1040        free(rowHeight); 
1041      }
1042    }
1043
1044
1045    if(pcPPS->getTileBehaviorControlPresentFlag() == 1)
1046    {
1047      Int iNumColTilesMinus1 = (pcPPS->getColumnRowInfoPresent() == 1)?(pcPPS->getNumColumnsMinus1()):(pcPPS->getSPS()->getNumColumnsMinus1());
1048      Int iNumRowTilesMinus1 = (pcPPS->getColumnRowInfoPresent() == 1)?(pcPPS->getNumColumnsMinus1()):(pcPPS->getSPS()->getNumRowsMinus1());
1049      pcPPS->setLFCrossTileBoundaryFlag(true); //default
1050
1051      if(iNumColTilesMinus1 !=0 || iNumRowTilesMinus1 !=0)
1052      {
1053          READ_FLAG ( uiCode, "loop_filter_across_tile_flag" ); 
1054          pcPPS->setLFCrossTileBoundaryFlag( (uiCode == 1)?true:false );
1055      }
1056    }
1057  }
1058  else if(parameterSet->getPrefetchedSPS(pcPPS->getSPSId())->getTilesOrEntropyCodingSyncIdc()==2)
1059  {
1060    READ_UVLC( uiCode, "num_substreams_minus1" );                pcPPS->setNumSubstreams(uiCode+1);
1061  }
1062
1063  READ_FLAG( uiCode, "deblocking_filter_control_present_flag" ); 
1064  pcPPS->setDeblockingFilterControlPresent( uiCode ? true : false);
1065  READ_UVLC( uiCode, "log2_parallel_merge_level_minus2");
1066  assert(uiCode == LOG2_PARALLEL_MERGE_LEVEL_MINUS2);
1067  pcPPS->setLog2ParallelMergeLevelMinus2 (uiCode);
1068
1069  READ_FLAG( uiCode, "pps_extension_flag");
1070  if (uiCode)
1071  {
1072    while ( xMoreRbspData() )
1073    {
1074      READ_FLAG( uiCode, "pps_extension_data_flag");
1075    }
1076  }
1077}
1078#if QC_MVHEVC_B0046
1079Void TDecCavlc::parseVPS(TComVPS* pcVPS)
1080{
1081  UInt  uiCode;
1082  READ_CODE( 4, uiCode,  "video_parameter_set_id"   );       pcVPS->setVPSId( uiCode );
1083  READ_FLAG( uiCode,     "temporal_id_nesting_flag" );       pcVPS->setTemporalNestingFlag( uiCode ? true:false );
1084  READ_CODE( 2, uiCode,  "vps_reserved_zero_2bits" );         assert( !uiCode );
1085  READ_CODE( 6, uiCode,  "vps_max_layers_minus1" );               pcVPS->setMaxLayers( uiCode + 1 );
1086  READ_CODE( 3, uiCode,  "vps_max_sub_layers_minus1" );      pcVPS->setMaxTLayers( uiCode + 1 );
1087  READ_CODE( 12, uiCode, "vps_extension_offset"      );      assert( !uiCode );
1088  for(UInt i = 0; i <= pcVPS->getMaxTLayers()-1; i++)
1089  {
1090    READ_UVLC( uiCode,  "max_dec_pic_buffering[i]" );     pcVPS->setMaxDecPicBuffering( uiCode, i );
1091    READ_UVLC( uiCode,  "num_reorder_pics[i]" );          pcVPS->setNumReorderPics( uiCode, i );
1092    READ_UVLC( uiCode,  "max_latency_increase[i]" );      pcVPS->setMaxLatencyIncrease( uiCode, i );
1093  }
1094  READ_UVLC( uiCode,                 "vps_num_hrd_parameters"   ); pcVPS->setNumHRDParameters(uiCode);
1095  assert(pcVPS->getNumHRDParameters()==0);
1096  for ( UInt i = 0; i < pcVPS->getNumHRDParameters(); i ++)
1097  {
1098   //   if( i > 0 ) 
1099    //{
1100    //  READ_UVLC (0, "op_num_layer_id_values_minus1[ opIdx ]");
1101    //  for( i = 0; i <= op_num_layer_id_values_minus1[ opIdx ]; i++ ) 
1102    //    READ_UVLC(0, 6, "op_layer_id[ opIdx ][ i ]");
1103    //} 
1104    //hrd_parameters( i  = =  0, vps_max_sub_layers_minus1 ); 
1105  }
1106 
1107  READ_CODE( 1, uiCode, "bit_equal_to_one" );             assert( uiCode );
1108  //vps_extension_byte_alignment_reserved_one_bit
1109  xReadVPSAlignOne();
1110  READ_CODE( 8, uiCode, "num_additional_layer_operation_points" );     pcVPS->setNumAddiLayerOperationPoints( uiCode );
1111  READ_CODE( 8, uiCode, "num_additional_profile_level_sets"     );     pcVPS->setNumAddiProLevelSets( uiCode);
1112
1113
1114  for(UInt i=0; i <= pcVPS->getMaxLayers()-1; i++)
1115  {
1116    READ_CODE( 4,  uiCode,             "num_types_zero_4bits[i]" );   assert( !uiCode );
1117    READ_CODE( 4,  uiCode,             "type_zero_4bits[i]"      );   assert( !uiCode );
1118    READ_CODE( 8,  uiCode,             "view_id[i]" );                pcVPS->setViewId(uiCode, i);
1119    // WRITE_SVLC( pcVPS->getViewOrderIdx(i),                  "view_order_idx[i]" );
1120    if(i)
1121    {
1122      READ_CODE( 6, uiCode,  "num_direct_ref_layers[ i ]" );    pcVPS->setNumDirectRefLayer(uiCode, i);
1123      for (UInt j = 0; j< pcVPS->getNumDirectRefLayer(i); j++)
1124      {
1125        READ_CODE( 6, uiCode, "ref_layer_id[i][j]" );         pcVPS->setDirectRefLayerId (uiCode, i, j);
1126      }
1127    }
1128  }
1129  for( UInt i=1; i<=pcVPS->getNumAddiProLevelSets(); i++)
1130  {
1131    //profile_tier_level
1132  }
1133  for( UInt i=1; i<= pcVPS->getNumAddiLayerOperationPoints(); i++)
1134  {   
1135    if(pcVPS->getMaxLayers() == 3)
1136    {
1137      pcVPS->setNumOpLayerIdMinus1((i < pcVPS->getNumAddiLayerOperationPoints() ? 1: 2), (i-1)); 
1138    }
1139    else if( i==1 )
1140    {
1141      assert(pcVPS->getNumAddiLayerOperationPoints()==1);
1142      pcVPS->setNumOpLayerIdMinus1(pcVPS->getMaxLayers()-1, (i-1)); 
1143    }
1144    READ_UVLC( uiCode,           "op_num_layer_id_values_minus1[ opIdx ]" ); pcVPS->setNumOpLayerIdMinus1(uiCode, i-1);
1145    for(UInt j = 0; j <= pcVPS->getNumOpLayerIdMinus1(i-1); j++ )
1146    {
1147      READ_UVLC( uiCode,           "op_layer_id[ opIdx ][ i ]" ); pcVPS->setNumOpLayerId(uiCode, i-1, j);
1148    }
1149    if (pcVPS->getNumAddiProLevelSets())
1150    {
1151      //profile_level_idx[ i ]
1152    }
1153  }
1154  return;
1155}
1156#else
1157#if VIDYO_VPS_INTEGRATION
1158Void TDecCavlc::parseVPS(TComVPS* pcVPS)
1159{
1160  UInt  uiCode;
1161  Int   iCode;
1162 
1163  READ_CODE( 3, uiCode, "max_temporal_layers_minus1" );   pcVPS->setMaxTLayers( uiCode + 1 );
1164  READ_CODE( 5, uiCode, "max_layers_minus1" );            pcVPS->setMaxLayers( uiCode + 1 );
1165  READ_FLAG( uiCode,  "temporal_id_nesting_flag" );       pcVPS->setTemporalNestingFlag( uiCode ? true:false );
1166  READ_UVLC( uiCode,  "video_parameter_set_id" );         pcVPS->setVPSId( uiCode );
1167  for(UInt i = 0; i <= pcVPS->getMaxTLayers()-1; i++)
1168  {
1169    READ_UVLC( uiCode,  "max_dec_pic_buffering[i]" );     pcVPS->setMaxDecPicBuffering( uiCode, i );
1170    READ_UVLC( uiCode,  "num_reorder_pics[i]" );          pcVPS->setNumReorderPics( uiCode, i );
1171    READ_UVLC( uiCode,  "max_latency_increase[i]" );      pcVPS->setMaxLatencyIncrease( uiCode, i );
1172  }
1173 
1174  READ_CODE( 1, uiCode, "bit_equal_to_one" );             assert( uiCode );
1175 
1176  if( pcVPS->getMaxLayers() - 1 > 0 )
1177  {
1178    READ_UVLC( uiCode,  "extension_type" );               pcVPS->setExtensionType( uiCode );
1179   
1180    pcVPS->setViewOrderIdx( 0, 0 );
1181    pcVPS->setViewId( 0, 0 );
1182    pcVPS->setDepthFlag( 0, 0 );
1183    for(UInt i = 1; i <= pcVPS->getMaxLayers()-1; i++)
1184    {
1185      READ_FLAG( uiCode, "dependent_flag[i]" );           pcVPS->setDependentFlag( uiCode ? true:false, i);
1186      if( pcVPS->getDependentFlag(i) )
1187      {
1188        READ_UVLC( uiCode,  "delta_reference_layer_id_minus1[i]" ); pcVPS->setDependentLayer( i - uiCode + 1, i );
1189        if( pcVPS->getExtensionType() == VPS_EXTENSION_TYPE_MULTI_VIEW )
1190        {
1191          READ_UVLC( uiCode,  "view_id[i]" );             pcVPS->setViewId( uiCode, i );
1192          READ_FLAG( uiCode,  "depth_flag[i]" );          pcVPS->setDepthFlag( uiCode ? true:false, i ); 
1193          READ_SVLC( iCode,  "view_order_idx[i]" );       pcVPS->setViewOrderIdx( iCode, i );
1194        }
1195       
1196      }
1197    }
1198#if INTER_VIEW_VECTOR_SCALING_C0115
1199    READ_FLAG( uiCode,  "inter_view_vector_scaling_flag" );    pcVPS->setIVScalingFlag( uiCode ? true:false); 
1200#endif
1201  }
1202 
1203  READ_FLAG( uiCode,  "vps_extension_flag" );          assert(!uiCode);
1204  //future extensions go here..
1205 
1206  return;
1207}
1208
1209#endif
1210#endif
1211#if HHI_MPI || H3D_QTL
1212Void TDecCavlc::parseSPS(TComSPS* pcSPS, Bool bIsDepth)
1213#else
1214Void TDecCavlc::parseSPS(TComSPS* pcSPS)
1215#endif
1216{
1217#if ENC_DEC_TRACE 
1218  xTraceSPSHeader (pcSPS);
1219#endif
1220 
1221  UInt  uiCode;
1222#if !QC_MVHEVC_B0046
1223  Int   iCode;
1224#endif
1225  READ_CODE( 8,  uiCode, "profile_idc" );                        pcSPS->setProfileIdc( uiCode );
1226  READ_CODE( 8,  uiCode, "reserved_zero_8bits" );
1227  READ_CODE( 8,  uiCode, "level_idc" );                          pcSPS->setLevelIdc( uiCode );
1228  READ_UVLC(     uiCode, "seq_parameter_set_id" );               pcSPS->setSPSId( uiCode );
1229#if VIDYO_VPS_INTEGRATION
1230  READ_UVLC(     uiCode, "video_parameter_set_id" );             pcSPS->setVPSId( uiCode );
1231#endif
1232  READ_UVLC(     uiCode, "chroma_format_idc" );                  pcSPS->setChromaFormatIdc( uiCode );
1233  READ_CODE( 3,  uiCode, "max_temporal_layers_minus1" );         pcSPS->setMaxTLayers( uiCode+1 );
1234  READ_UVLC (    uiCode, "pic_width_in_luma_samples" );          pcSPS->setPicWidthInLumaSamples ( uiCode    );
1235  READ_UVLC (    uiCode, "pic_height_in_luma_samples" );         pcSPS->setPicHeightInLumaSamples( uiCode    );
1236  READ_FLAG(     uiCode, "pic_cropping_flag");                   pcSPS->setPicCroppingFlag ( uiCode ? true : false );
1237  if (uiCode != 0)
1238  {
1239    READ_UVLC(   uiCode, "pic_crop_left_offset" );               pcSPS->setPicCropLeftOffset( uiCode );
1240    READ_UVLC(   uiCode, "pic_crop_right_offset" );              pcSPS->setPicCropRightOffset( uiCode );
1241    READ_UVLC(   uiCode, "pic_crop_top_offset" );                pcSPS->setPicCropTopOffset( uiCode );
1242    READ_UVLC(   uiCode, "pic_crop_bottom_offset" );             pcSPS->setPicCropBottomOffset( uiCode );
1243  }
1244
1245#if FULL_NBIT
1246  READ_UVLC(     uiCode, "bit_depth_luma_minus8" );
1247  g_uiBitDepth = 8 + uiCode;
1248  g_uiBitIncrement = 0;
1249  pcSPS->setBitDepth(g_uiBitDepth);
1250  pcSPS->setBitIncrement(g_uiBitIncrement);
1251#else
1252  READ_UVLC(     uiCode, "bit_depth_luma_minus8" );
1253  g_uiBitDepth = 8;
1254  g_uiBitIncrement = uiCode;
1255  pcSPS->setBitDepth(g_uiBitDepth);
1256  pcSPS->setBitIncrement(g_uiBitIncrement);
1257#endif
1258 
1259#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
1260  g_iDeltaDCsQuantOffset = g_uiBitIncrement - 2;
1261#endif
1262
1263  pcSPS->setQpBDOffsetY( (Int) (6*uiCode) );
1264
1265  g_uiBASE_MAX  = ((1<<(g_uiBitDepth))-1);
1266 
1267#if IBDI_NOCLIP_RANGE
1268  g_uiIBDI_MAX  = g_uiBASE_MAX << g_uiBitIncrement;
1269#else
1270  g_uiIBDI_MAX  = ((1<<(g_uiBitDepth+g_uiBitIncrement))-1);
1271#endif
1272  READ_UVLC( uiCode,    "bit_depth_chroma_minus8" );
1273  pcSPS->setQpBDOffsetC( (Int) (6*uiCode) );
1274
1275  READ_FLAG( uiCode, "pcm_enabled_flag" ); pcSPS->setUsePCM( uiCode ? true : false );
1276
1277  if( pcSPS->getUsePCM() )
1278  {
1279    READ_CODE( 4, uiCode, "pcm_bit_depth_luma_minus1" );           pcSPS->setPCMBitDepthLuma   ( 1 + uiCode );
1280    READ_CODE( 4, uiCode, "pcm_bit_depth_chroma_minus1" );         pcSPS->setPCMBitDepthChroma ( 1 + uiCode );
1281  }
1282
1283#if LOSSLESS_CODING
1284  READ_FLAG( uiCode, "qpprime_y_zero_transquant_bypass_flag" );    pcSPS->setUseLossless ( uiCode ? true : false );
1285#endif
1286
1287  READ_UVLC( uiCode,    "log2_max_pic_order_cnt_lsb_minus4" );   pcSPS->setBitsForPOC( 4 + uiCode );
1288  for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
1289  {
1290    READ_UVLC ( uiCode, "max_dec_pic_buffering");
1291    pcSPS->setMaxDecPicBuffering( uiCode, i);
1292    READ_UVLC ( uiCode, "num_reorder_pics" );
1293    pcSPS->setNumReorderPics(uiCode, i);
1294    READ_UVLC ( uiCode, "max_latency_increase");
1295    pcSPS->setMaxLatencyIncrease( uiCode, i );
1296  }
1297
1298  READ_FLAG( uiCode, "restricted_ref_pic_lists_flag" );
1299  pcSPS->setRestrictedRefPicListsFlag( uiCode );
1300  if( pcSPS->getRestrictedRefPicListsFlag() )
1301  {
1302    READ_FLAG( uiCode, "lists_modification_present_flag" );
1303    pcSPS->setListsModificationPresentFlag(uiCode);
1304  }
1305  else 
1306  {
1307    pcSPS->setListsModificationPresentFlag(true);
1308  }
1309  READ_UVLC( uiCode, "log2_min_coding_block_size_minus3" );
1310  UInt log2MinCUSize = uiCode + 3;
1311  READ_UVLC( uiCode, "log2_diff_max_min_coding_block_size" );
1312  UInt uiMaxCUDepthCorrect = uiCode;
1313  pcSPS->setMaxCUWidth  ( 1<<(log2MinCUSize + uiMaxCUDepthCorrect) ); g_uiMaxCUWidth  = 1<<(log2MinCUSize + uiMaxCUDepthCorrect);
1314  pcSPS->setMaxCUHeight ( 1<<(log2MinCUSize + uiMaxCUDepthCorrect) ); g_uiMaxCUHeight = 1<<(log2MinCUSize + uiMaxCUDepthCorrect);
1315  READ_UVLC( uiCode, "log2_min_transform_block_size_minus2" );   pcSPS->setQuadtreeTULog2MinSize( uiCode + 2 );
1316
1317  READ_UVLC( uiCode, "log2_diff_max_min_transform_block_size" ); pcSPS->setQuadtreeTULog2MaxSize( uiCode + pcSPS->getQuadtreeTULog2MinSize() );
1318  pcSPS->setMaxTrSize( 1<<(uiCode + pcSPS->getQuadtreeTULog2MinSize()) );
1319
1320  if(log2MinCUSize == 3)
1321  {
1322    xReadFlag( uiCode ); pcSPS->setDisInter4x4( uiCode ? true : false );
1323  }
1324
1325  if( pcSPS->getUsePCM() )
1326  {
1327    READ_UVLC( uiCode, "log2_min_pcm_coding_block_size_minus3" );  pcSPS->setPCMLog2MinSize (uiCode+3); 
1328    READ_UVLC( uiCode, "log2_diff_max_min_pcm_coding_block_size" ); pcSPS->setPCMLog2MaxSize ( uiCode+pcSPS->getPCMLog2MinSize() );
1329  }
1330
1331  READ_UVLC( uiCode, "max_transform_hierarchy_depth_inter" );    pcSPS->setQuadtreeTUMaxDepthInter( uiCode+1 );
1332  READ_UVLC( uiCode, "max_transform_hierarchy_depth_intra" );    pcSPS->setQuadtreeTUMaxDepthIntra( uiCode+1 );
1333  g_uiAddCUDepth = 0;
1334  while( ( pcSPS->getMaxCUWidth() >> uiMaxCUDepthCorrect ) > ( 1 << ( pcSPS->getQuadtreeTULog2MinSize() + g_uiAddCUDepth )  ) )
1335  {
1336    g_uiAddCUDepth++;
1337  }
1338  pcSPS->setMaxCUDepth( uiMaxCUDepthCorrect+g_uiAddCUDepth  ); 
1339  g_uiMaxCUDepth  = uiMaxCUDepthCorrect+g_uiAddCUDepth;
1340  // BB: these parameters may be removed completly and replaced by the fixed values
1341  pcSPS->setMinTrDepth( 0 );
1342  pcSPS->setMaxTrDepth( 1 );
1343  READ_FLAG( uiCode, "scaling_list_enabled_flag" );                 pcSPS->setScalingListFlag ( uiCode );
1344  READ_FLAG( uiCode, "chroma_pred_from_luma_enabled_flag" );        pcSPS->setUseLMChroma ( uiCode ? true : false ); 
1345  READ_FLAG( uiCode, "deblocking_filter_in_aps_enabled_flag" );     pcSPS->setUseDF ( uiCode ? true : false ); 
1346  READ_FLAG( uiCode, "loop_filter_across_slice_flag" );             pcSPS->setLFCrossSliceBoundaryFlag( uiCode ? true : false);
1347  READ_FLAG( uiCode, "asymmetric_motion_partitions_enabled_flag" ); pcSPS->setUseAMP( uiCode );
1348  READ_FLAG( uiCode, "non_square_quadtree_enabled_flag" );          pcSPS->setUseNSQT( uiCode );
1349  READ_FLAG( uiCode, "sample_adaptive_offset_enabled_flag" );       pcSPS->setUseSAO ( uiCode ? true : false ); 
1350  READ_FLAG( uiCode, "adaptive_loop_filter_enabled_flag" );         pcSPS->setUseALF ( uiCode ? true : false );
1351  if(pcSPS->getUseALF())
1352  {
1353    READ_FLAG( uiCode, "alf_coef_in_slice_flag" );      pcSPS->setUseALFCoefInSlice ( uiCode ? true : false );
1354  }
1355  if( pcSPS->getUsePCM() )
1356  {
1357    READ_FLAG( uiCode, "pcm_loop_filter_disable_flag" );           pcSPS->setPCMFilterDisableFlag ( uiCode ? true : false );
1358  }
1359
1360  READ_FLAG( uiCode, "temporal_id_nesting_flag" );               pcSPS->setTemporalIdNestingFlag ( uiCode > 0 ? true : false );
1361
1362
1363  TComRPSList* rpsList = pcSPS->getRPSList();
1364  TComReferencePictureSet* rps;
1365
1366  READ_UVLC( uiCode, "num_short_term_ref_pic_sets" );
1367  rpsList->create(uiCode);
1368
1369  for(UInt i=0; i< rpsList->getNumberOfReferencePictureSets(); i++)
1370  {
1371    rps = rpsList->getReferencePictureSet(i);
1372    parseShortTermRefPicSet(pcSPS,rps,i);
1373  }
1374  READ_FLAG( uiCode, "long_term_ref_pics_present_flag" );          pcSPS->setLongTermRefsPresent(uiCode);
1375 
1376  // AMVP mode for each depth (AM_NONE or AM_EXPL)
1377  for (Int i = 0; i < pcSPS->getMaxCUDepth(); i++)
1378  {
1379    xReadFlag( uiCode );
1380    pcSPS->setAMVPMode( i, (AMVP_MODE)uiCode );
1381  }
1382
1383  READ_CODE(2, uiCode, "tiles_or_entropy_coding_sync_idc");         pcSPS->setTilesOrEntropyCodingSyncIdc(uiCode);
1384
1385  if(pcSPS->getTilesOrEntropyCodingSyncIdc() == 1)
1386  {
1387    READ_UVLC ( uiCode, "num_tile_columns_minus1" );
1388    pcSPS->setNumColumnsMinus1( uiCode ); 
1389    READ_UVLC ( uiCode, "num_tile_rows_minus1" ); 
1390    pcSPS->setNumRowsMinus1( uiCode ); 
1391    READ_FLAG ( uiCode, "uniform_spacing_flag" ); 
1392    pcSPS->setUniformSpacingIdr( uiCode );
1393    if( pcSPS->getUniformSpacingIdr() == 0 )
1394    {
1395      UInt* columnWidth = (UInt*)malloc(pcSPS->getNumColumnsMinus1()*sizeof(UInt));
1396      for(UInt i=0; i<pcSPS->getNumColumnsMinus1(); i++)
1397      { 
1398        READ_UVLC( uiCode, "column_width" );
1399        columnWidth[i] = uiCode; 
1400      }
1401      pcSPS->setColumnWidth(columnWidth);
1402      free(columnWidth);
1403
1404      UInt* rowHeight = (UInt*)malloc(pcSPS->getNumRowsMinus1()*sizeof(UInt));
1405      for(UInt i=0; i<pcSPS->getNumRowsMinus1(); i++)
1406      {
1407        READ_UVLC( uiCode, "row_height" );
1408        rowHeight[i] = uiCode; 
1409      }
1410      pcSPS->setRowHeight(rowHeight);
1411      free(rowHeight); 
1412    }
1413    pcSPS->setLFCrossTileBoundaryFlag(true); //default
1414
1415    if( pcSPS->getNumColumnsMinus1() !=0 || pcSPS->getNumRowsMinus1() != 0)
1416    {
1417        READ_FLAG ( uiCode, "loop_filter_across_tile_flag" ); 
1418        pcSPS->setLFCrossTileBoundaryFlag( (uiCode==1)?true:false);
1419    }
1420  }
1421  READ_FLAG( uiCode, "sps_extension_flag");
1422#if !QC_MVHEVC_B0046
1423  if(uiCode)
1424  {
1425    READ_FLAG( uiCode, "interview_refs_present_flag");
1426    if(uiCode)
1427    {
1428      READ_UVLC( uiCode, "num_usable_interview_refs_minus1" );
1429      pcSPS->setNumberOfUsableInterViewRefs( uiCode + 1 );
1430
1431      Int prev = 0;
1432      for( Int j = 0 ; j < pcSPS->getNumberOfUsableInterViewRefs(); j++ )
1433      {
1434        READ_UVLC(uiCode, "delta_usable_interview_ref_minus1");
1435        pcSPS->setUsableInterViewRef( j, (prev - uiCode - 1) );
1436        prev = pcSPS->getUsableInterViewRef( j );
1437      }
1438    }
1439
1440#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
1441    READ_FLAG( uiCode, "enable_dmm_flag" ); 
1442    pcSPS->setUseDMM( uiCode );
1443#endif
1444
1445#if HHI_MPI
1446    if( bIsDepth )
1447    {
1448      READ_FLAG( uiCode, "use_mvi_flag" );
1449      pcSPS->setUseMVI( uiCode );
1450    }
1451#endif
1452#if H3D_QTL
1453    if( bIsDepth )
1454    {
1455      READ_FLAG( uiCode, "use_qtlpc_flag" );
1456      pcSPS->setUseQTLPC( uiCode );
1457    }
1458#endif
1459   
1460#if RWTH_SDC_DLT_B0036
1461    if( bIsDepth )
1462    {
1463      READ_FLAG( uiCode, "use_dlt_flag" );
1464      pcSPS->setUseDLT( uiCode );
1465      if( pcSPS->getUseDLT() )
1466      {
1467        // decode mapping
1468        UInt uiNumDepthValues;
1469        // parse number of values in DLT
1470        xReadUvlc( uiNumDepthValues );
1471       
1472        // parse actual DLT values
1473        UInt* auiIdx2DepthValue = (UInt*) calloc(uiNumDepthValues, sizeof(UInt));
1474        for(UInt d=0; d<uiNumDepthValues; d++)
1475        {
1476          xReadUvlc( uiCode );
1477          auiIdx2DepthValue[d] = uiCode;
1478        }
1479       
1480        pcSPS->setDepthLUTs(auiIdx2DepthValue, uiNumDepthValues);
1481       
1482        // clean memory
1483        free(auiIdx2DepthValue);
1484      }
1485      else
1486        pcSPS->setDepthLUTs();
1487    }
1488#endif
1489
1490    READ_FLAG( uiCode, "base_view_flag" );
1491    if( uiCode )
1492    { // baseview SPS -> set standard values
1493      pcSPS->initMultiviewSPS         ( 0 );
1494#if DEPTH_MAP_GENERATION
1495      pcSPS->setPredDepthMapGeneration( 0, false );
1496#endif
1497#if H3D_IVRP
1498    pcSPS->setMultiviewResPredMode  ( 0 );
1499#endif
1500    }
1501    else
1502    {
1503      READ_FLAG( uiCode, "depth_flag" ); 
1504      if( uiCode )
1505      {
1506#if FCO_FIX_SPS_CHANGE
1507        UInt  uiViewId, uiCamParPrecision;
1508        Int   iVOI;
1509        Bool  bCamParSlice;
1510        READ_UVLC( uiCode, "view_id" ); 
1511        READ_SVLC( iCode, "view_order_idx" );
1512        uiViewId = uiCode;
1513        iVOI = iCode;
1514
1515        if ( uiViewId == 0 )
1516        {
1517          pcSPS->initMultiviewSPSDepth    ( uiViewId, iVOI );
1518        }
1519        else
1520        {
1521          READ_UVLC( uiCamParPrecision, "camera_parameter_precision" );
1522          READ_FLAG( uiCode, "camera_parameter_in_slice_header" );    bCamParSlice = ( uiCode == 1 );
1523          if( !bCamParSlice )
1524          {
1525            for( UInt uiBaseId = 0; uiBaseId < uiViewId; uiBaseId++ )
1526            {
1527              READ_SVLC( iCode, "coded_scale" );   m_aaiTempScale [ uiBaseId ][ uiViewId ] = iCode;
1528              READ_SVLC( iCode, "coded_offset" );   m_aaiTempOffset[ uiBaseId ][ uiViewId ] = iCode;
1529              READ_SVLC( iCode, "inverse_coded_scale_plus_coded_scale" );   m_aaiTempScale [ uiViewId ][ uiBaseId ] = iCode - m_aaiTempScale [ uiBaseId ][ uiViewId ];
1530              READ_SVLC( iCode, "inverse_coded_offset_plus_coded_offset" );   m_aaiTempOffset[ uiViewId ][ uiBaseId ] = iCode - m_aaiTempOffset[ uiBaseId ][ uiViewId ];
1531            }
1532          }
1533          pcSPS->initMultiviewSPSDepth( uiViewId, iVOI, uiCamParPrecision, bCamParSlice, m_aaiTempScale, m_aaiTempOffset );
1534
1535        }
1536#else
1537        READ_UVLC( uiCode, "view_id" ); 
1538        READ_SVLC(  iCode, "view_order_idx" ); 
1539        pcSPS->initMultiviewSPSDepth    ( uiCode, iCode );
1540#endif
1541#if DEPTH_MAP_GENERATION
1542#if FCO_FIX_SPS_CHANGE
1543        pcSPS->setPredDepthMapGeneration( uiViewId, true );
1544#else
1545        pcSPS->setPredDepthMapGeneration( uiCode, true );
1546#endif
1547#endif
1548#if H3D_IVRP
1549      pcSPS->setMultiviewResPredMode  ( 0 );
1550#endif
1551      }
1552      else
1553      {
1554        UInt  uiViewId, uiCamParPrecision;
1555        Int   iVOI;
1556        Bool  bCamParSlice;
1557        READ_UVLC( uiViewId, "view_id" );  uiViewId++;
1558        READ_SVLC( iVOI, "view_order_idx" );
1559        READ_UVLC( uiCamParPrecision, "camera_parameter_precision" );
1560        READ_FLAG( uiCode, "camera_parameter_in_slice_header" );    bCamParSlice = ( uiCode == 1 );
1561        if( !bCamParSlice )
1562        {
1563          for( UInt uiBaseId = 0; uiBaseId < uiViewId; uiBaseId++ )
1564          {
1565            READ_SVLC( iCode, "coded_scale" );   m_aaiTempScale [ uiBaseId ][ uiViewId ] = iCode;
1566            READ_SVLC( iCode, "coded_offset" );   m_aaiTempOffset[ uiBaseId ][ uiViewId ] = iCode;
1567            READ_SVLC( iCode, "inverse_coded_scale_plus_coded_scale" );   m_aaiTempScale [ uiViewId ][ uiBaseId ] = iCode - m_aaiTempScale [ uiBaseId ][ uiViewId ];
1568            READ_SVLC( iCode, "inverse_coded_offset_plus_coded_offset" );   m_aaiTempOffset[ uiViewId ][ uiBaseId ] = iCode - m_aaiTempOffset[ uiBaseId ][ uiViewId ];
1569          }
1570        }
1571        pcSPS->initMultiviewSPS( uiViewId, iVOI, uiCamParPrecision, bCamParSlice, m_aaiTempScale, m_aaiTempOffset );
1572
1573#if DEPTH_MAP_GENERATION
1574        UInt uiPredDepthMapGeneration = 0, uiPdmPrecision = 0;
1575#if H3D_IVMP
1576        UInt uiMultiviewMvPredMode = 0;
1577#endif
1578#if H3D_IVRP
1579      UInt uiMultiviewResPredMode = 0;
1580#endif
1581        READ_UVLC( uiPredDepthMapGeneration, "Pdm_generation" );
1582        if( uiPredDepthMapGeneration )
1583        {
1584          READ_UVLC( uiPdmPrecision, "Pdm_precision" );
1585          for( UInt uiBaseId = 0; uiBaseId < uiViewId; uiBaseId++ )
1586          {
1587            READ_SVLC( iCode, "Pdm_scale_nom_delta" );   m_aaiTempPdmScaleNomDelta[ uiViewId ][ uiBaseId ] = iCode;
1588            READ_SVLC( iCode, "Pdm_offset" );   m_aaiTempPdmOffset       [ uiViewId ][ uiBaseId ] = iCode;
1589          }
1590#if H3D_IVMP
1591          READ_UVLC( uiMultiviewMvPredMode, "multi_view_mv_pred_mode" );
1592#endif
1593#if H3D_IVRP
1594          READ_FLAG( uiMultiviewResPredMode, "multi_view_residual_pred_mode" );
1595#endif
1596        }
1597#if H3D_IVMP
1598        pcSPS->setPredDepthMapGeneration( uiViewId, false, uiPredDepthMapGeneration, uiMultiviewMvPredMode, uiPdmPrecision, m_aaiTempPdmScaleNomDelta, m_aaiTempPdmOffset );
1599#else
1600        pcSPS->setPredDepthMapGeneration( uiViewId, false, uiPredDepthMapGeneration, 0, uiPdmPrecision, m_aaiTempPdmScaleNomDelta, m_aaiTempPdmOffset );
1601#endif
1602#endif
1603#if H3D_IVRP
1604      pcSPS->setMultiviewResPredMode  ( uiMultiviewResPredMode );
1605#endif
1606      }
1607
1608#if MTK_D0156
1609
1610      pcSPS->setUseVSPCompensation( false );
1611      pcSPS->setUseDVPRefine( false );
1612
1613      //Comments: Currently, BVSP and DoNBDV are not used for depth coding
1614#if MERL_VSP_COMPENSATION_C0152
1615      READ_FLAG( uiCode, "view_synthesis_pred_flag" );pcSPS->setUseVSPCompensation( uiCode ? true : false );
1616#endif
1617      READ_FLAG( uiCode, "dv_refine_flag" );          pcSPS->setUseDVPRefine( uiCode ? true : false );
1618#endif
1619    }
1620    READ_FLAG( uiCode, "sps_extension2_flag");
1621    if (uiCode)
1622    {
1623      while ( xMoreRbspData() )
1624      {
1625        READ_FLAG( uiCode, "sps_extension2_data_flag");
1626      }
1627    }
1628  }
1629#endif
1630}
1631
1632Void TDecCavlc::readTileMarker   ( UInt& uiTileIdx, UInt uiBitsUsed )
1633{
1634  xReadCode ( uiBitsUsed, uiTileIdx );
1635}
1636
1637#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
1638Void TDecCavlc::parseSliceHeader (TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet, bool isDepth)
1639#else
1640Void TDecCavlc::parseSliceHeader (TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet)
1641#endif
1642{
1643  UInt  uiCode;
1644  Int   iCode;
1645 
1646#if ENC_DEC_TRACE
1647  xTraceSliceHeader(rpcSlice);
1648#endif
1649  Int numCUs = ((rpcSlice->getSPS()->getPicWidthInLumaSamples()+rpcSlice->getSPS()->getMaxCUWidth()-1)/rpcSlice->getSPS()->getMaxCUWidth())*((rpcSlice->getSPS()->getPicHeightInLumaSamples()+rpcSlice->getSPS()->getMaxCUHeight()-1)/rpcSlice->getSPS()->getMaxCUHeight());
1650  Int maxParts = (1<<(rpcSlice->getSPS()->getMaxCUDepth()<<1));
1651  Int numParts = (1<<(rpcSlice->getPPS()->getSliceGranularity()<<1));
1652  UInt lCUAddress = 0;
1653  Int reqBitsOuter = 0;
1654  while(numCUs>(1<<reqBitsOuter))
1655  {
1656    reqBitsOuter++;
1657  }
1658  Int reqBitsInner = 0;
1659  while((numParts)>(1<<reqBitsInner)) 
1660  {
1661    reqBitsInner++;
1662  }
1663
1664  READ_FLAG( uiCode, "first_slice_in_pic_flag" );
1665  UInt address;
1666  UInt innerAddress = 0;
1667
1668#if LGE_ILLUCOMP_B0045
1669  // IC flag is on only first_slice_in_pic
1670  if (uiCode)
1671  {
1672    UInt uiCodeTmp = 0;
1673    if ( rpcSlice->getSPS()->getViewId() 
1674#if !LGE_ILLUCOMP_DEPTH_C0046
1675        && !rpcSlice->getSPS()->isDepth()
1676#endif
1677        )
1678    {
1679      READ_FLAG (uiCodeTmp, "applying IC flag");
1680    }
1681    rpcSlice->setApplyIC(uiCodeTmp);
1682#if SHARP_ILLUCOMP_PARSE_D0060
1683    if (rpcSlice->getApplyIC())
1684    {
1685      READ_FLAG (uiCodeTmp, "ic_skip_mergeidx0");
1686      rpcSlice->setIcSkipParseFlag(uiCodeTmp);
1687    }
1688#endif
1689  }
1690#endif
1691
1692  if(!uiCode)
1693  {
1694    READ_CODE( reqBitsOuter+reqBitsInner, address, "slice_address" );
1695    lCUAddress = address >> reqBitsInner;
1696    innerAddress = address - (lCUAddress<<reqBitsInner);
1697  }
1698  //set uiCode to equal slice start address (or entropy slice start address)
1699  uiCode=(maxParts*lCUAddress)+(innerAddress*(maxParts>>(rpcSlice->getPPS()->getSliceGranularity()<<1)));
1700 
1701  rpcSlice->setEntropySliceCurStartCUAddr( uiCode );
1702  rpcSlice->setEntropySliceCurEndCUAddr(numCUs*maxParts);
1703
1704  //   slice_type
1705  READ_UVLC (    uiCode, "slice_type" );            rpcSlice->setSliceType((SliceType)uiCode);
1706  // lightweight_slice_flag
1707  READ_FLAG( uiCode, "entropy_slice_flag" );
1708  Bool bEntropySlice = uiCode ? true : false;
1709
1710  if (bEntropySlice)
1711  {
1712    rpcSlice->setNextSlice        ( false );
1713    rpcSlice->setNextEntropySlice ( true  );
1714  }
1715  else
1716  {
1717    rpcSlice->setNextSlice        ( true  );
1718    rpcSlice->setNextEntropySlice ( false );
1719   
1720    uiCode=(maxParts*lCUAddress)+(innerAddress*(maxParts>>(rpcSlice->getPPS()->getSliceGranularity()<<1)));
1721    rpcSlice->setSliceCurStartCUAddr(uiCode);
1722    rpcSlice->setSliceCurEndCUAddr(numCUs*maxParts);
1723  }
1724  TComPPS* pps = NULL;
1725  TComSPS* sps = NULL;
1726
1727  if (!bEntropySlice)
1728  {
1729    READ_UVLC (    uiCode, "pic_parameter_set_id" );  rpcSlice->setPPSId(uiCode);
1730    pps = parameterSetManager->getPrefetchedPPS(uiCode);
1731    sps = parameterSetManager->getPrefetchedSPS(pps->getSPSId());
1732    rpcSlice->setSPS(sps);
1733    rpcSlice->setPPS(pps);
1734    if( pps->getOutputFlagPresentFlag() )
1735    {
1736      READ_FLAG( uiCode, "pic_output_flag" );
1737      rpcSlice->setPicOutputFlag( uiCode ? true : false );
1738    }
1739    else
1740    {
1741      rpcSlice->setPicOutputFlag( true );
1742    }
1743#if QC_REM_IDV_B0046
1744#if !QC_MVHEVC_B0046
1745  if(rpcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_IDR && rpcSlice->getSPS()->getViewId() == 0) 
1746#else
1747  if(rpcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_IDR && rpcSlice->getViewId() == 0) 
1748#endif
1749#else
1750    if(rpcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_IDR) 
1751#endif
1752    { 
1753      READ_UVLC( uiCode, "idr_pic_id" );  //ignored
1754      READ_FLAG( uiCode, "no_output_of_prior_pics_flag" );  //ignored
1755      rpcSlice->setPOC(0);
1756      TComReferencePictureSet* rps = rpcSlice->getLocalRPS();
1757      rps->setNumberOfNegativePictures(0);
1758      rps->setNumberOfPositivePictures(0);
1759      rps->setNumberOfLongtermPictures(0);
1760      rps->setNumberOfPictures(0);
1761      rpcSlice->setRPS(rps);
1762    }
1763    else
1764    {
1765      READ_CODE(sps->getBitsForPOC(), uiCode, "pic_order_cnt_lsb"); 
1766      Int iPOClsb = uiCode;
1767      Int iPrevPOC = rpcSlice->getPrevPOC();
1768      Int iMaxPOClsb = 1<< sps->getBitsForPOC();
1769      Int iPrevPOClsb = iPrevPOC%iMaxPOClsb;
1770      Int iPrevPOCmsb = iPrevPOC-iPrevPOClsb;
1771      Int iPOCmsb;
1772      if( ( iPOClsb  <  iPrevPOClsb ) && ( ( iPrevPOClsb - iPOClsb )  >=  ( iMaxPOClsb / 2 ) ) )
1773      {
1774        iPOCmsb = iPrevPOCmsb + iMaxPOClsb;
1775      }
1776      else if( (iPOClsb  >  iPrevPOClsb )  && ( (iPOClsb - iPrevPOClsb )  >  ( iMaxPOClsb / 2 ) ) ) 
1777      {
1778        iPOCmsb = iPrevPOCmsb - iMaxPOClsb;
1779      }
1780      else
1781      {
1782        iPOCmsb = iPrevPOCmsb;
1783      }
1784      rpcSlice->setPOC( iPOCmsb+iPOClsb );
1785#if QC_REM_IDV_B0046
1786#if !QC_MVHEVC_B0046
1787      if( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR &&  rpcSlice->getSPS()->getViewId() && rpcSlice->getPOC() == 0 )
1788#else
1789      if( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR &&  rpcSlice->getViewId() && rpcSlice->getPOC() == 0 )
1790#endif
1791#else
1792      if( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDV && rpcSlice->getPOC() == 0 )
1793#endif
1794      {
1795        TComReferencePictureSet* rps = rpcSlice->getLocalRPS();
1796        rps->setNumberOfNegativePictures(0);
1797        rps->setNumberOfPositivePictures(0);
1798        rps->setNumberOfLongtermPictures(0);
1799        rps->setNumberOfPictures(0);
1800        rpcSlice->setRPS(rps);
1801      }
1802      else
1803      {
1804        TComReferencePictureSet* rps;
1805        READ_FLAG( uiCode, "short_term_ref_pic_set_sps_flag" );
1806        if(uiCode == 0) // use short-term reference picture set explicitly signalled in slice header
1807        {
1808          rps = rpcSlice->getLocalRPS();
1809          parseShortTermRefPicSet(sps,rps, sps->getRPSList()->getNumberOfReferencePictureSets());
1810          rpcSlice->setRPS(rps);
1811        }
1812        else // use reference to short-term reference picture set in PPS
1813        {
1814          READ_UVLC( uiCode, "short_term_ref_pic_set_idx"); rpcSlice->setRPS(sps->getRPSList()->getReferencePictureSet(uiCode));
1815          rps = rpcSlice->getRPS();
1816        }
1817        if(sps->getLongTermRefsPresent())
1818        {
1819          Int offset = rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures();
1820          READ_UVLC( uiCode, "num_long_term_pics");             rps->setNumberOfLongtermPictures(uiCode);
1821          Int prev = 0;
1822          Int prevMsb=0;
1823          Int prevDeltaPocLt=0;
1824          for(Int j=rps->getNumberOfLongtermPictures()+offset-1 ; j > offset-1; j--)
1825          {
1826            READ_UVLC(uiCode,"delta_poc_lsb_lt"); 
1827            prev += uiCode;
1828
1829            READ_FLAG(uiCode,"delta_poc_msb_present_flag");
1830            Int decDeltaPOCMsbPresent=uiCode;
1831
1832            if(decDeltaPOCMsbPresent==1)
1833            {
1834              READ_UVLC(uiCode, "delta_poc_msb_cycle_lt_minus1");
1835              if(  (j==(rps->getNumberOfLongtermPictures()+offset-1)) || (prev!=prevDeltaPocLt) )
1836              {
1837                prevMsb=(1+uiCode); 
1838              }
1839              else
1840              {
1841                prevMsb+=(1+uiCode); 
1842              }
1843              Int decMaxPocLsb = 1<<rpcSlice->getSPS()->getBitsForPOC();
1844              rps->setPOC(j,rpcSlice->getPOC()-prev-(prevMsb)*decMaxPocLsb); 
1845              rps->setDeltaPOC(j,-(Int)(prev+(prevMsb)*decMaxPocLsb));
1846            }
1847            else
1848            {
1849              rps->setPOC(j,rpcSlice->getPOC()-prev);         
1850              rps->setDeltaPOC(j,-(Int)prev);
1851            }
1852            prevDeltaPocLt=prev;
1853            READ_FLAG( uiCode, "used_by_curr_pic_lt_flag");     rps->setUsed(j,uiCode);
1854          }
1855          offset += rps->getNumberOfLongtermPictures();
1856          rps->setNumberOfPictures(offset);       
1857        } 
1858      }
1859    }
1860
1861    if(sps->getUseSAO() || sps->getUseALF() || sps->getScalingListFlag() || sps->getUseDF())
1862    {
1863      //!!!KS: order is different in WD5!
1864      if (sps->getUseALF())
1865      {
1866        READ_FLAG(uiCode, "slice_adaptive_loop_filter_flag");
1867        rpcSlice->setAlfEnabledFlag((Bool)uiCode);
1868      }
1869      if (sps->getUseSAO())
1870      {
1871#if LGE_SAO_MIGRATION_D0091
1872        READ_FLAG(uiCode, "slice_sao_luma_flag");  rpcSlice->setSaoEnabledFlag((Bool)uiCode);
1873        READ_FLAG(uiCode, "slice_sao_chroma_flag");  rpcSlice->setSaoEnabledFlagChroma((Bool)uiCode);
1874#else
1875        READ_FLAG(uiCode, "slice_sao_interleaving_flag");        rpcSlice->setSaoInterleavingFlag(uiCode);
1876        READ_FLAG(uiCode, "slice_sample_adaptive_offset_flag");  rpcSlice->setSaoEnabledFlag((Bool)uiCode);
1877        if (rpcSlice->getSaoEnabledFlag() && rpcSlice->getSaoInterleavingFlag())
1878        {
1879          READ_FLAG(uiCode, "sao_cb_enable_flag");  rpcSlice->setSaoEnabledFlagCb((Bool)uiCode);
1880          READ_FLAG(uiCode, "sao_cr_enable_flag");  rpcSlice->setSaoEnabledFlagCr((Bool)uiCode);
1881        }
1882        else
1883        {
1884          rpcSlice->setSaoEnabledFlagCb(0);
1885          rpcSlice->setSaoEnabledFlagCr(0);
1886        }
1887#endif
1888      }
1889      READ_UVLC (    uiCode, "aps_id" );  rpcSlice->setAPSId(uiCode);
1890    }
1891    if (!rpcSlice->isIntra())
1892    {
1893      READ_FLAG( uiCode, "num_ref_idx_active_override_flag");
1894      if (uiCode)
1895      {
1896        READ_CODE (3, uiCode, "num_ref_idx_l0_active_minus1" );  rpcSlice->setNumRefIdx( REF_PIC_LIST_0, uiCode + 1 );
1897        if (rpcSlice->isInterB())
1898        {
1899          READ_CODE (3, uiCode, "num_ref_idx_l1_active_minus1" );  rpcSlice->setNumRefIdx( REF_PIC_LIST_1, uiCode + 1 );
1900        }
1901        else
1902        {
1903          rpcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
1904        }
1905      }
1906      else
1907      {
1908        rpcSlice->setNumRefIdx(REF_PIC_LIST_0, 0);
1909        rpcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
1910      }
1911    }
1912    TComRefPicListModification* refPicListModification = rpcSlice->getRefPicListModification();
1913    if( !rpcSlice->isIntra() )
1914    {
1915#if QC_MVHEVC_B0046
1916    if( !rpcSlice->getViewId() || !rpcSlice->getSPS()->getListsModificationPresentFlag() )
1917#else
1918      if( !rpcSlice->getSPS()->getListsModificationPresentFlag() )
1919#endif
1920      {
1921        refPicListModification->setRefPicListModificationFlagL0( 0 );
1922      }
1923      else
1924      {
1925        READ_FLAG( uiCode, "ref_pic_list_modification_flag_l0" ); refPicListModification->setRefPicListModificationFlagL0( uiCode ? 1 : 0 );
1926      }
1927     
1928      if(refPicListModification->getRefPicListModificationFlagL0())
1929      {
1930        uiCode = 0;
1931        Int i = 0;
1932        Int NumPocTotalCurr = rpcSlice->getNumPocTotalCurrMvc();
1933        if ( NumPocTotalCurr > 1 )
1934        {
1935          Int length = 1;
1936          NumPocTotalCurr --;
1937          while ( NumPocTotalCurr >>= 1) 
1938          {
1939            length ++;
1940          }
1941          for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
1942          {
1943            READ_CODE( length, uiCode, "list_entry_l0" );
1944            refPicListModification->setRefPicSetIdxL0(i, uiCode );
1945          }
1946        }
1947        else
1948        {
1949          for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
1950          {
1951            refPicListModification->setRefPicSetIdxL0(i, 0 );
1952          }
1953        }
1954      }
1955    }
1956    else
1957    {
1958      refPicListModification->setRefPicListModificationFlagL0(0);
1959    }
1960    if(rpcSlice->isInterB())
1961    {
1962#if QC_MVHEVC_B0046
1963    if( !rpcSlice->getViewId() || !rpcSlice->getSPS()->getListsModificationPresentFlag() )
1964#else
1965      if( !rpcSlice->getSPS()->getListsModificationPresentFlag() )
1966#endif
1967      {
1968        refPicListModification->setRefPicListModificationFlagL1( 0 );
1969      }
1970      else
1971      {
1972        READ_FLAG( uiCode, "ref_pic_list_modification_flag_l1" ); refPicListModification->setRefPicListModificationFlagL1( uiCode ? 1 : 0 );
1973      }
1974      if(refPicListModification->getRefPicListModificationFlagL1())
1975      {
1976        uiCode = 0;
1977        Int i = 0;
1978        Int NumPocTotalCurr = rpcSlice->getNumPocTotalCurrMvc();
1979        if ( NumPocTotalCurr > 1 )
1980        {
1981          Int length = 1;
1982          NumPocTotalCurr --;
1983          while ( NumPocTotalCurr >>= 1) 
1984          {
1985            length ++;
1986          }
1987          for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
1988          {
1989            READ_CODE( length, uiCode, "list_entry_l1" );
1990            refPicListModification->setRefPicSetIdxL1(i, uiCode );
1991          }
1992        }
1993        else
1994        {
1995          for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
1996          {
1997            refPicListModification->setRefPicSetIdxL1(i, 0 );
1998          }
1999        }
2000      }
2001    } 
2002    else
2003    {
2004      refPicListModification->setRefPicListModificationFlagL1(0);
2005    }
2006  }
2007  else
2008  {
2009    // initialize from previous slice
2010    pps = rpcSlice->getPPS();
2011    sps = rpcSlice->getSPS();
2012  }
2013  // ref_pic_list_combination( )
2014  //!!!KS: ref_pic_list_combination() should be conditioned on entropy_slice_flag
2015  if (rpcSlice->isInterB())
2016  {
2017    READ_FLAG( uiCode, "ref_pic_list_combination_flag" );       rpcSlice->setRefPicListCombinationFlag( uiCode ? 1 : 0 );
2018    if(uiCode)
2019    {
2020      READ_UVLC( uiCode, "num_ref_idx_lc_active_minus1" );      rpcSlice->setNumRefIdx( REF_PIC_LIST_C, uiCode + 1 );
2021     
2022#if QC_MVHEVC_B0046
2023    if( rpcSlice->getViewId() && rpcSlice->getSPS()->getListsModificationPresentFlag() )
2024#else
2025    if(rpcSlice->getSPS()->getListsModificationPresentFlag() )
2026#endif
2027      {
2028        READ_FLAG( uiCode, "ref_pic_list_modification_flag_lc" ); rpcSlice->setRefPicListModificationFlagLC( uiCode ? 1 : 0 );
2029        if(uiCode)
2030        {
2031          for (UInt i=0;i<rpcSlice->getNumRefIdx(REF_PIC_LIST_C);i++)
2032          {
2033            READ_FLAG( uiCode, "pic_from_list_0_flag" );
2034            rpcSlice->setListIdFromIdxOfLC(i, uiCode);
2035          if (((rpcSlice->getListIdFromIdxOfLC(i) == REF_PIC_LIST_0) && (rpcSlice->getNumRefIdx( REF_PIC_LIST_0 ) == 1)) || ((rpcSlice->getListIdFromIdxOfLC(i) == REF_PIC_LIST_1) && (rpcSlice->getNumRefIdx( REF_PIC_LIST_1 ) == 1)) )
2036          {
2037            uiCode = 0;
2038          }
2039          else
2040          {
2041            READ_UVLC( uiCode, "ref_idx_list_curr" );
2042          }
2043            rpcSlice->setRefIdxFromIdxOfLC(i, uiCode);
2044            rpcSlice->setRefIdxOfLC((RefPicList)rpcSlice->getListIdFromIdxOfLC(i), rpcSlice->getRefIdxFromIdxOfLC(i), i);
2045          }
2046        }
2047      }
2048      else
2049      {
2050        rpcSlice->setRefPicListModificationFlagLC(false);
2051      }
2052    }
2053    else
2054    {
2055      rpcSlice->setRefPicListModificationFlagLC(false);
2056      rpcSlice->setNumRefIdx(REF_PIC_LIST_C, 0);
2057    }
2058  }
2059  else
2060  {
2061    rpcSlice->setRefPicListCombinationFlag(false);     
2062  }
2063 
2064  if (rpcSlice->isInterB())
2065  {
2066    READ_FLAG( uiCode, "mvd_l1_zero_flag" );       rpcSlice->setMvdL1ZeroFlag( (uiCode ? true : false) );
2067  }
2068
2069#if CABAC_INIT_FLAG
2070  rpcSlice->setCabacInitFlag( false ); // default
2071  if(pps->getCabacInitPresentFlag() && !rpcSlice->isIntra())
2072  {
2073    READ_FLAG(uiCode, "cabac_init_flag");
2074    rpcSlice->setCabacInitFlag( uiCode ? true : false );
2075  }
2076#else
2077  if(pps->getEntropyCodingMode() && !rpcSlice->isIntra())
2078  {
2079    READ_UVLC(uiCode, "cabac_init_idc");
2080    rpcSlice->setCABACinitIDC(uiCode);
2081  }
2082  else if (pps->getEntropyCodingMode() && rpcSlice->isIntra())
2083  {
2084    rpcSlice->setCABACinitIDC(0);
2085  }
2086#endif
2087
2088  if(!bEntropySlice)
2089  {
2090    READ_SVLC( iCode, "slice_qp_delta" ); 
2091    rpcSlice->setSliceQp (26 + pps->getPicInitQPMinus26() + iCode);
2092
2093    assert( rpcSlice->getSliceQp() >= -sps->getQpBDOffsetY() );
2094    assert( rpcSlice->getSliceQp() <=  51 );
2095
2096    if (rpcSlice->getPPS()->getDeblockingFilterControlPresent())
2097    {
2098      if ( rpcSlice->getSPS()->getUseDF() )
2099      {
2100        READ_FLAG ( uiCode, "inherit_dbl_param_from_APS_flag" ); rpcSlice->setInheritDblParamFromAPS(uiCode ? 1 : 0);
2101      } else
2102      {
2103        rpcSlice->setInheritDblParamFromAPS(0);
2104      }
2105      if(!rpcSlice->getInheritDblParamFromAPS())
2106      {
2107        READ_FLAG ( uiCode, "disable_deblocking_filter_flag" );  rpcSlice->setLoopFilterDisable(uiCode ? 1 : 0);
2108        if(!rpcSlice->getLoopFilterDisable())
2109        {
2110          READ_SVLC( iCode, "beta_offset_div2" ); rpcSlice->setLoopFilterBetaOffset(iCode);
2111          READ_SVLC( iCode, "tc_offset_div2" ); rpcSlice->setLoopFilterTcOffset(iCode);
2112        }
2113      }
2114   }
2115    if ( rpcSlice->getSliceType() == B_SLICE )
2116    {
2117      READ_FLAG( uiCode, "collocated_from_l0_flag" );
2118      rpcSlice->setColDir(uiCode);
2119    }
2120
2121#if COLLOCATED_REF_IDX
2122    if ( rpcSlice->getSliceType() != I_SLICE &&
2123      ((rpcSlice->getColDir()==0 && rpcSlice->getNumRefIdx(REF_PIC_LIST_0)>1)||
2124      (rpcSlice->getColDir() ==1 && rpcSlice->getNumRefIdx(REF_PIC_LIST_1)>1)))
2125    {
2126      READ_UVLC( uiCode, "collocated_ref_idx" );
2127      rpcSlice->setColRefIdx(uiCode);
2128    }
2129#endif
2130   
2131    if ( (pps->getUseWP() && rpcSlice->getSliceType()==P_SLICE) || (pps->getWPBiPredIdc() && rpcSlice->getSliceType()==B_SLICE) )
2132    {
2133      xParsePredWeightTable(rpcSlice);
2134      rpcSlice->initWpScaling();
2135    }
2136  }
2137 
2138  if (!bEntropySlice)
2139  {
2140    if( rpcSlice->getSPS()->hasCamParInSliceHeader() )
2141    {
2142      UInt uiViewId = rpcSlice->getSPS()->getViewId();
2143      for( UInt uiBaseId = 0; uiBaseId < uiViewId; uiBaseId++ )
2144      {
2145        READ_SVLC( iCode, "coded_scale" );   m_aaiTempScale [ uiBaseId ][ uiViewId ] = iCode;
2146        READ_SVLC( iCode, "coded_offset" );   m_aaiTempOffset[ uiBaseId ][ uiViewId ] = iCode;
2147        READ_SVLC( iCode, "inverse_coded_scale_plus_coded_scale" );   m_aaiTempScale [ uiViewId ][ uiBaseId ] = iCode - m_aaiTempScale [ uiBaseId ][ uiViewId ];
2148        READ_SVLC( iCode, "inverse_coded_offset_plus_coded_offset" );   m_aaiTempOffset[ uiViewId ][ uiBaseId ] = iCode - m_aaiTempOffset[ uiBaseId ][ uiViewId ];
2149      }
2150      rpcSlice->initMultiviewSlice( m_aaiTempScale, m_aaiTempOffset );
2151    }
2152  }
2153
2154#if ( HHI_MPI || H3D_IVMP )
2155  #if ( HHI_MPI && H3D_IVMP )
2156  const int iExtraMergeCandidates = ( sps->getUseMVI() || sps->getMultiviewMvPredMode() ) ? 1 : 0;
2157  #elif HHI_MPI
2158  const int iExtraMergeCandidates = sps->getUseMVI() ? 1 : 0;
2159  #elif MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
2160  const int iExtraMergeCandidates = (  (isDepth || sps->getMultiviewMvPredMode()) ) ? 1 : 0;   
2161  #else
2162  const int iExtraMergeCandidates = sps->getMultiviewMvPredMode() ? 1 : 0;
2163  #endif
2164  READ_UVLC( uiCode, "5_minus_max_num_merge_cand");
2165  rpcSlice->setMaxNumMergeCand(MRG_MAX_NUM_CANDS + iExtraMergeCandidates - uiCode);
2166  assert(rpcSlice->getMaxNumMergeCand()==(MRG_MAX_NUM_CANDS_SIGNALED+iExtraMergeCandidates));
2167#else
2168  READ_UVLC( uiCode, "5_minus_max_num_merge_cand");
2169  rpcSlice->setMaxNumMergeCand(MRG_MAX_NUM_CANDS - uiCode);
2170  assert(rpcSlice->getMaxNumMergeCand()==MRG_MAX_NUM_CANDS_SIGNALED);
2171#endif
2172
2173  if (!bEntropySlice)
2174  {
2175    if(sps->getUseALF() && rpcSlice->getAlfEnabledFlag())
2176    {
2177      UInt uiNumLCUsInWidth   = sps->getPicWidthInLumaSamples()  / g_uiMaxCUWidth;
2178      UInt uiNumLCUsInHeight  = sps->getPicHeightInLumaSamples() / g_uiMaxCUHeight;
2179
2180      uiNumLCUsInWidth  += ( sps->getPicWidthInLumaSamples() % g_uiMaxCUWidth ) ? 1 : 0;
2181      uiNumLCUsInHeight += ( sps->getPicHeightInLumaSamples() % g_uiMaxCUHeight ) ? 1 : 0;
2182
2183      Int uiNumCUsInFrame = uiNumLCUsInWidth* uiNumLCUsInHeight; 
2184      if(sps->getUseALFCoefInSlice())
2185      {
2186        alfParamSet.releaseALFParam();
2187        alfParamSet.init();
2188        Bool isAcrossSlice = sps->getLFCrossSliceBoundaryFlag();   
2189        Int numSUinLCU    = 1<< (g_uiMaxCUDepth << 1); 
2190        Int firstLCUAddr   = rpcSlice->getSliceCurStartCUAddr() / numSUinLCU; 
2191        xParseAlfParam(&alfParamSet, false, firstLCUAddr, isAcrossSlice, uiNumLCUsInWidth, uiNumLCUsInHeight);
2192      }
2193
2194      if(!sps->getUseALFCoefInSlice())
2195      {
2196      xParseAlfCuControlParam(alfCUCtrl, uiNumCUsInFrame);
2197      }
2198
2199    }
2200  }
2201 
2202  //!!!KS: The following syntax is not aligned with the working draft, TRACE support needs to be added
2203  rpcSlice->setTileMarkerFlag ( 0 ); // default
2204  if (!bEntropySlice)
2205  {
2206    xReadCode(1, uiCode); // read flag indicating if tile markers transmitted
2207    rpcSlice->setTileMarkerFlag( uiCode );
2208  }
2209
2210  Int tilesOrEntropyCodingSyncIdc = rpcSlice->getSPS()->getTilesOrEntropyCodingSyncIdc();
2211  UInt *entryPointOffset          = NULL;
2212  UInt numEntryPointOffsets, offsetLenMinus1;
2213
2214  rpcSlice->setNumEntryPointOffsets ( 0 ); // default
2215 
2216  if (tilesOrEntropyCodingSyncIdc>0)
2217  {
2218    READ_UVLC(numEntryPointOffsets, "num_entry_point_offsets"); rpcSlice->setNumEntryPointOffsets ( numEntryPointOffsets );
2219    if (numEntryPointOffsets>0)
2220    {
2221      READ_UVLC(offsetLenMinus1, "offset_len_minus1");
2222    }
2223    entryPointOffset = new UInt[numEntryPointOffsets];
2224    for (UInt idx=0; idx<numEntryPointOffsets; idx++)
2225    {
2226      Int bitsRead = m_pcBitstream->getNumBitsRead();
2227      READ_CODE(offsetLenMinus1+1, uiCode, "entry_point_offset");
2228      entryPointOffset[ idx ] = uiCode;
2229      if ( idx == 0 && tilesOrEntropyCodingSyncIdc == 2 )
2230      {
2231        // Subtract distance from NALU header start to provide WPP 0-th substream the correct size.
2232        entryPointOffset[ idx ] -= ( bitsRead + numEntryPointOffsets*(offsetLenMinus1+1) ) >> 3;
2233      }
2234    }
2235  }
2236
2237  if ( tilesOrEntropyCodingSyncIdc == 1 ) // tiles
2238  {
2239    rpcSlice->setTileLocationCount( numEntryPointOffsets );
2240
2241    UInt prevPos = 0;
2242    for (Int idx=0; idx<rpcSlice->getTileLocationCount(); idx++)
2243    {
2244      rpcSlice->setTileLocation( idx, prevPos + entryPointOffset [ idx ] );
2245      prevPos += entryPointOffset[ idx ];
2246    }
2247  }
2248  else if ( tilesOrEntropyCodingSyncIdc == 2 ) // wavefront
2249  {
2250    Int numSubstreams = pps->getNumSubstreams();
2251    rpcSlice->allocSubstreamSizes(numSubstreams);
2252    UInt *pSubstreamSizes       = rpcSlice->getSubstreamSizes();
2253    for (Int idx=0; idx<numSubstreams-1; idx++)
2254    {
2255      if ( idx < numEntryPointOffsets )
2256      {
2257        pSubstreamSizes[ idx ] = ( entryPointOffset[ idx ] << 3 ) ;
2258      }
2259      else
2260      {
2261        pSubstreamSizes[ idx ] = 0;
2262      }
2263    }
2264  }
2265
2266  if (entryPointOffset)
2267  {
2268    delete [] entryPointOffset;
2269  }
2270
2271  if (!bEntropySlice)
2272  {
2273    // Reading location information
2274
2275      // read out trailing bits
2276    m_pcBitstream->readOutTrailingBits();
2277  }
2278  return;
2279}
2280
2281Void TDecCavlc::xParseAlfCuControlParam(AlfCUCtrlInfo& cAlfParam, Int iNumCUsInPic)
2282{
2283  UInt uiSymbol;
2284  Int iSymbol;
2285
2286  READ_FLAG (uiSymbol, "alf_cu_control_flag");
2287  cAlfParam.cu_control_flag = uiSymbol;
2288  if (cAlfParam.cu_control_flag)
2289  {
2290    READ_UVLC (uiSymbol, "alf_cu_control_max_depth"); 
2291    cAlfParam.alf_max_depth = uiSymbol;
2292
2293    READ_SVLC (iSymbol, "alf_length_cu_control_info");
2294    cAlfParam.num_alf_cu_flag = (UInt)(iSymbol + iNumCUsInPic);
2295
2296    cAlfParam.alf_cu_flag.resize(cAlfParam.num_alf_cu_flag);
2297
2298    for(UInt i=0; i< cAlfParam.num_alf_cu_flag; i++)
2299    {
2300      READ_FLAG (cAlfParam.alf_cu_flag[i], "alf_cu_flag");
2301    }
2302  }
2303}
2304
2305#if !CABAC_INIT_FLAG
2306Void TDecCavlc::resetEntropy          (TComSlice* pcSlice)
2307{
2308}
2309#endif
2310
2311Void TDecCavlc::parseTerminatingBit( UInt& ruiBit )
2312{
2313  ruiBit = false;
2314  Int iBitsLeft = m_pcBitstream->getNumBitsLeft();
2315  if(iBitsLeft <= 8)
2316  {
2317    UInt uiPeekValue = m_pcBitstream->peekBits(iBitsLeft);
2318    if (uiPeekValue == (1<<(iBitsLeft-1)))
2319    {
2320      ruiBit = true;
2321    }
2322  }
2323}
2324
2325Void TDecCavlc::parseSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2326{
2327  assert(0);
2328}
2329
2330#if LGE_ILLUCOMP_B0045
2331Void TDecCavlc::parseICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2332{
2333  assert(0);
2334}
2335#endif
2336
2337#if H3D_IVMP
2338Void TDecCavlc::parseMVPIdx( Int& riMVPIdx, Int iAMVPCands )
2339#else
2340Void TDecCavlc::parseMVPIdx( Int& riMVPIdx )
2341#endif
2342{
2343  assert(0);
2344}
2345
2346Void TDecCavlc::parseSplitFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2347{
2348  assert(0);
2349}
2350
2351Void TDecCavlc::parsePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2352{
2353  assert(0);
2354}
2355
2356Void TDecCavlc::parsePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2357{
2358  assert(0);
2359}
2360
2361/** Parse I_PCM information.
2362 * \param pcCU pointer to CU
2363 * \param uiAbsPartIdx CU index
2364 * \param uiDepth CU depth
2365 * \returns Void
2366 *
2367 * If I_PCM flag indicates that the CU is I_PCM, parse its PCM alignment bits and codes. 
2368 */
2369Void TDecCavlc::parseIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2370{
2371  assert(0);
2372}
2373
2374Void TDecCavlc::parseIntraDirLumaAng  ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2375{ 
2376  assert(0);
2377}
2378
2379Void TDecCavlc::parseIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2380{
2381  assert(0);
2382}
2383
2384Void TDecCavlc::parseInterDir( TComDataCU* pcCU, UInt& ruiInterDir, UInt uiAbsPartIdx, UInt uiDepth )
2385{
2386  assert(0);
2387}
2388
2389Void TDecCavlc::parseRefFrmIdx( TComDataCU* pcCU, Int& riRefFrmIdx, UInt uiAbsPartIdx, UInt uiDepth, RefPicList eRefList )
2390{
2391  assert(0);
2392}
2393
2394Void TDecCavlc::parseMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth, RefPicList eRefList )
2395{
2396  assert(0);
2397}
2398
2399Void TDecCavlc::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2400{
2401  Int qp;
2402  Int  iDQp;
2403 
2404  xReadSvlc( iDQp );
2405
2406  Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
2407  qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+ qpBdOffsetY)) -  qpBdOffsetY;
2408
2409  UInt uiAbsQpCUPartIdx = (uiAbsPartIdx>>(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)))<<(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)) ;
2410  UInt uiQpCUDepth =   min(uiDepth,pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()) ;
2411
2412  pcCU->setQPSubParts( qp, uiAbsQpCUPartIdx, uiQpCUDepth );
2413}
2414
2415Void TDecCavlc::parseCoeffNxN( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType )
2416{
2417  assert(0);
2418}
2419
2420Void TDecCavlc::parseTransformSubdivFlag( UInt& ruiSubdivFlag, UInt uiLog2TransformBlockSize )
2421{
2422  assert(0);
2423}
2424
2425Void TDecCavlc::parseQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth, UInt uiDepth )
2426{
2427  assert(0);
2428}
2429
2430Void TDecCavlc::parseQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt& uiQtRootCbf )
2431{
2432  assert(0);
2433}
2434
2435
2436Void TDecCavlc::parseMergeFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx )
2437{
2438  assert(0);
2439}
2440
2441Void TDecCavlc::parseMergeIndex ( TComDataCU* pcCU, UInt& ruiMergeIndex, UInt uiAbsPartIdx, UInt uiDepth )
2442{
2443  assert(0);
2444}
2445
2446#if H3D_IVRP
2447Void
2448TDecCavlc::parseResPredFlag( TComDataCU* pcCU, Bool& rbResPredFlag, UInt uiAbsPartIdx, UInt uiDepth )
2449{
2450  assert(0);
2451}
2452#endif
2453
2454#if RWTH_SDC_DLT_B0036
2455Void TDecCavlc::parseSDCFlag    ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2456{
2457  assert(0);
2458}
2459Void TDecCavlc::parseSDCPredMode    ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2460{
2461  assert(0);
2462}
2463Void TDecCavlc::parseSDCResidualData     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPart )
2464{
2465  assert(0);
2466}
2467#endif
2468
2469// ====================================================================================================================
2470// Protected member functions
2471// ====================================================================================================================
2472
2473Void TDecCavlc::xReadCode (UInt uiLength, UInt& ruiCode)
2474{
2475  assert ( uiLength > 0 );
2476  m_pcBitstream->read (uiLength, ruiCode);
2477}
2478
2479Void TDecCavlc::xReadUvlc( UInt& ruiVal)
2480{
2481  UInt uiVal = 0;
2482  UInt uiCode = 0;
2483  UInt uiLength;
2484  m_pcBitstream->read( 1, uiCode );
2485 
2486  if( 0 == uiCode )
2487  {
2488    uiLength = 0;
2489   
2490    while( ! ( uiCode & 1 ))
2491    {
2492      m_pcBitstream->read( 1, uiCode );
2493      uiLength++;
2494    }
2495   
2496    m_pcBitstream->read( uiLength, uiVal );
2497   
2498    uiVal += (1 << uiLength)-1;
2499  }
2500 
2501  ruiVal = uiVal;
2502}
2503
2504Void TDecCavlc::xReadSvlc( Int& riVal)
2505{
2506  UInt uiBits = 0;
2507  m_pcBitstream->read( 1, uiBits );
2508  if( 0 == uiBits )
2509  {
2510    UInt uiLength = 0;
2511   
2512    while( ! ( uiBits & 1 ))
2513    {
2514      m_pcBitstream->read( 1, uiBits );
2515      uiLength++;
2516    }
2517   
2518    m_pcBitstream->read( uiLength, uiBits );
2519   
2520    uiBits += (1 << uiLength);
2521    riVal = ( uiBits & 1) ? -(Int)(uiBits>>1) : (Int)(uiBits>>1);
2522  }
2523  else
2524  {
2525    riVal = 0;
2526  }
2527}
2528
2529Void TDecCavlc::xReadFlag (UInt& ruiCode)
2530{
2531  m_pcBitstream->read( 1, ruiCode );
2532}
2533
2534#if QC_MVHEVC_B0046
2535/** Parse VPS alignment one bits.
2536 * \returns Void
2537 */
2538Void TDecCavlc::xReadVPSAlignOne( )
2539{
2540  UInt uiNumberOfBits = m_pcBitstream->getNumBitsUntilByteAligned();
2541
2542  if(uiNumberOfBits)
2543  {
2544    UInt uiBits;
2545    UInt uiSymbol;
2546
2547    for(uiBits = 0; uiBits < uiNumberOfBits; uiBits++)
2548    {
2549      xReadFlag( uiSymbol );
2550
2551      if(!uiSymbol)
2552      {
2553        printf("\nWarning! vps_extension_byte_alignment_reserved_one_bit include a non-zero value.\n");
2554      }
2555    }
2556  }
2557}
2558#endif
2559/** Parse PCM alignment zero bits.
2560 * \returns Void
2561 */
2562Void TDecCavlc::xReadPCMAlignZero( )
2563{
2564  UInt uiNumberOfBits = m_pcBitstream->getNumBitsUntilByteAligned();
2565
2566  if(uiNumberOfBits)
2567  {
2568    UInt uiBits;
2569    UInt uiSymbol;
2570
2571    for(uiBits = 0; uiBits < uiNumberOfBits; uiBits++)
2572    {
2573      xReadFlag( uiSymbol );
2574
2575      if(uiSymbol)
2576      {
2577        printf("\nWarning! pcm_align_zero include a non-zero value.\n");
2578      }
2579    }
2580  }
2581}
2582
2583Void TDecCavlc::xReadUnaryMaxSymbol( UInt& ruiSymbol, UInt uiMaxSymbol )
2584{
2585  if (uiMaxSymbol == 0)
2586  {
2587    ruiSymbol = 0;
2588    return;
2589  }
2590 
2591  xReadFlag( ruiSymbol );
2592 
2593  if (ruiSymbol == 0 || uiMaxSymbol == 1)
2594  {
2595    return;
2596  }
2597 
2598  UInt uiSymbol = 0;
2599  UInt uiCont;
2600 
2601  do
2602  {
2603    xReadFlag( uiCont );
2604    uiSymbol++;
2605  }
2606  while( uiCont && (uiSymbol < uiMaxSymbol-1) );
2607 
2608  if( uiCont && (uiSymbol == uiMaxSymbol-1) )
2609  {
2610    uiSymbol++;
2611  }
2612 
2613  ruiSymbol = uiSymbol;
2614}
2615
2616Void TDecCavlc::xReadExGolombLevel( UInt& ruiSymbol )
2617{
2618  UInt uiSymbol ;
2619  UInt uiCount = 0;
2620  do
2621  {
2622    xReadFlag( uiSymbol );
2623    uiCount++;
2624  }
2625  while( uiSymbol && (uiCount != 13));
2626 
2627  ruiSymbol = uiCount-1;
2628 
2629  if( uiSymbol )
2630  {
2631    xReadEpExGolomb( uiSymbol, 0 );
2632    ruiSymbol += uiSymbol+1;
2633  }
2634 
2635  return;
2636}
2637
2638Void TDecCavlc::xReadEpExGolomb( UInt& ruiSymbol, UInt uiCount )
2639{
2640  UInt uiSymbol = 0;
2641  UInt uiBit = 1;
2642 
2643 
2644  while( uiBit )
2645  {
2646    xReadFlag( uiBit );
2647    uiSymbol += uiBit << uiCount++;
2648  }
2649 
2650  uiCount--;
2651  while( uiCount-- )
2652  {
2653    xReadFlag( uiBit );
2654    uiSymbol += uiBit << uiCount;
2655  }
2656 
2657  ruiSymbol = uiSymbol;
2658 
2659  return;
2660}
2661
2662UInt TDecCavlc::xGetBit()
2663{
2664  UInt ruiCode;
2665  m_pcBitstream->read( 1, ruiCode );
2666  return ruiCode;
2667}
2668
2669
2670/** parse explicit wp tables
2671 * \param TComSlice* pcSlice
2672 * \returns Void
2673 */
2674Void TDecCavlc::xParsePredWeightTable( TComSlice* pcSlice )
2675{
2676  wpScalingParam  *wp;
2677  Bool            bChroma     = true; // color always present in HEVC ?
2678  TComPPS*        pps         = pcSlice->getPPS();
2679  SliceType       eSliceType  = pcSlice->getSliceType();
2680  Int             iNbRef       = (eSliceType == B_SLICE ) ? (2) : (1);
2681  UInt            uiLog2WeightDenomLuma, uiLog2WeightDenomChroma;
2682  UInt            uiMode      = 0;
2683
2684  if ( (eSliceType==P_SLICE && pps->getUseWP()) || (eSliceType==B_SLICE && pps->getWPBiPredIdc()==1 && pcSlice->getRefPicListCombinationFlag()==0) )
2685    uiMode = 1; // explicit
2686  else if ( eSliceType==B_SLICE && pps->getWPBiPredIdc()==2 )
2687    uiMode = 2; // implicit
2688  else if (eSliceType==B_SLICE && pps->getWPBiPredIdc()==1 && pcSlice->getRefPicListCombinationFlag())
2689    uiMode = 3; // combined explicit
2690
2691  if ( uiMode == 1 )  // explicit
2692  {
2693    printf("\nTDecCavlc::xParsePredWeightTable(poc=%d) explicit...\n", pcSlice->getPOC());
2694    Int iDeltaDenom;
2695    // decode delta_luma_log2_weight_denom :
2696    READ_UVLC( uiLog2WeightDenomLuma, "luma_log2_weight_denom" );     // ue(v): luma_log2_weight_denom
2697    if( bChroma ) 
2698    {
2699      READ_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" );     // se(v): delta_chroma_log2_weight_denom
2700      assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)>=0);
2701      uiLog2WeightDenomChroma = (UInt)(iDeltaDenom + uiLog2WeightDenomLuma);
2702    }
2703
2704    for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ ) 
2705    {
2706      RefPicList  eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
2707      for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ ) 
2708      {
2709        pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
2710
2711        wp[0].uiLog2WeightDenom = uiLog2WeightDenomLuma;
2712        wp[1].uiLog2WeightDenom = uiLog2WeightDenomChroma;
2713        wp[2].uiLog2WeightDenom = uiLog2WeightDenomChroma;
2714
2715        UInt  uiCode;
2716        READ_FLAG( uiCode, "luma_weight_lX_flag" );           // u(1): luma_weight_l0_flag
2717        wp[0].bPresentFlag = ( uiCode == 1 );
2718        if ( wp[0].bPresentFlag ) 
2719        {
2720          Int iDeltaWeight;
2721          READ_SVLC( iDeltaWeight, "delta_luma_weight_lX" );  // se(v): delta_luma_weight_l0[i]
2722          wp[0].iWeight = (iDeltaWeight + (1<<wp[0].uiLog2WeightDenom));
2723          READ_SVLC( wp[0].iOffset, "luma_offset_lX" );       // se(v): luma_offset_l0[i]
2724        }
2725        else 
2726        {
2727          wp[0].iWeight = (1 << wp[0].uiLog2WeightDenom);
2728          wp[0].iOffset = 0;
2729        }
2730        if ( bChroma ) 
2731        {
2732          READ_FLAG( uiCode, "chroma_weight_lX_flag" );      // u(1): chroma_weight_l0_flag
2733          wp[1].bPresentFlag = ( uiCode == 1 );
2734          wp[2].bPresentFlag = ( uiCode == 1 );
2735          if ( wp[1].bPresentFlag ) 
2736          {
2737            for ( Int j=1 ; j<3 ; j++ ) 
2738            {
2739              Int iDeltaWeight;
2740              READ_SVLC( iDeltaWeight, "delta_chroma_weight_lX" );  // se(v): chroma_weight_l0[i][j]
2741              wp[j].iWeight = (iDeltaWeight + (1<<wp[1].uiLog2WeightDenom));
2742
2743              Int iDeltaChroma;
2744              READ_SVLC( iDeltaChroma, "delta_chroma_offset_lX" );  // se(v): delta_chroma_offset_l0[i][j]
2745              wp[j].iOffset = iDeltaChroma - ( ( (g_uiIBDI_MAX>>1)*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) + (g_uiIBDI_MAX>>1);
2746            }
2747          }
2748          else 
2749          {
2750            for ( Int j=1 ; j<3 ; j++ ) 
2751            {
2752              wp[j].iWeight = (1 << wp[j].uiLog2WeightDenom);
2753              wp[j].iOffset = 0;
2754            }
2755          }
2756        }
2757      }
2758
2759      for ( Int iRefIdx=pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx<MAX_NUM_REF ; iRefIdx++ ) 
2760      {
2761        pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
2762
2763        wp[0].bPresentFlag = false;
2764        wp[1].bPresentFlag = false;
2765        wp[2].bPresentFlag = false;
2766      }
2767    }
2768  }
2769  else if ( uiMode == 2 )  // implicit
2770  {
2771    printf("\nTDecCavlc::xParsePredWeightTable(poc=%d) implicit...\n", pcSlice->getPOC());
2772  }
2773  else if ( uiMode == 3 )  // combined explicit
2774  {
2775    printf("\nTDecCavlc::xParsePredWeightTable(poc=%d) combined explicit...\n", pcSlice->getPOC());
2776    Int iDeltaDenom;
2777    // decode delta_luma_log2_weight_denom :
2778    READ_UVLC ( uiLog2WeightDenomLuma, "luma_log2_weight_denom" );     // ue(v): luma_log2_weight_denom
2779    if( bChroma ) 
2780    {
2781      READ_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" );      // ue(v): delta_chroma_log2_weight_denom
2782      assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)>=0);
2783      uiLog2WeightDenomChroma = (UInt)(iDeltaDenom + uiLog2WeightDenomLuma);
2784    }
2785
2786    for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(REF_PIC_LIST_C) ; iRefIdx++ ) 
2787    {
2788      pcSlice->getWpScalingLC(iRefIdx, wp);
2789
2790      wp[0].uiLog2WeightDenom = uiLog2WeightDenomLuma;
2791      wp[1].uiLog2WeightDenom = uiLog2WeightDenomChroma;
2792      wp[2].uiLog2WeightDenom = uiLog2WeightDenomChroma;
2793
2794      UInt  uiCode;
2795      READ_FLAG( uiCode, "luma_weight_lc_flag" );                  // u(1): luma_weight_lc_flag
2796      wp[0].bPresentFlag = ( uiCode == 1 );
2797      if ( wp[0].bPresentFlag ) 
2798      {
2799        Int iDeltaWeight;
2800        READ_SVLC( iDeltaWeight, "delta_luma_weight_lc" );          // se(v): delta_luma_weight_lc
2801        wp[0].iWeight = (iDeltaWeight + (1<<wp[0].uiLog2WeightDenom));
2802        READ_SVLC( wp[0].iOffset, "luma_offset_lc" );               // se(v): luma_offset_lc
2803      }
2804      else 
2805      {
2806        wp[0].iWeight = (1 << wp[0].uiLog2WeightDenom);
2807        wp[0].iOffset = 0;
2808      }
2809      if ( bChroma ) 
2810      {
2811        READ_FLAG( uiCode, "chroma_weight_lc_flag" );                // u(1): chroma_weight_lc_flag
2812        wp[1].bPresentFlag = ( uiCode == 1 );
2813        wp[2].bPresentFlag = ( uiCode == 1 );
2814        if ( wp[1].bPresentFlag ) 
2815        {
2816          for ( Int j=1 ; j<3 ; j++ ) 
2817          {
2818            Int iDeltaWeight;
2819            READ_SVLC( iDeltaWeight, "delta_chroma_weight_lc" );      // se(v): delta_chroma_weight_lc
2820            wp[j].iWeight = (iDeltaWeight + (1<<wp[1].uiLog2WeightDenom));
2821
2822            Int iDeltaChroma;
2823            READ_SVLC( iDeltaChroma, "delta_chroma_offset_lc" );      // se(v): delta_chroma_offset_lc
2824            wp[j].iOffset = iDeltaChroma - ( ( (g_uiIBDI_MAX>>1)*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) + (g_uiIBDI_MAX>>1);
2825          }
2826        }
2827        else 
2828        {
2829          for ( Int j=1 ; j<3 ; j++ ) 
2830          {
2831            wp[j].iWeight = (1 << wp[j].uiLog2WeightDenom);
2832            wp[j].iOffset = 0;
2833          }
2834        }
2835      }
2836    }
2837
2838    for ( Int iRefIdx=pcSlice->getNumRefIdx(REF_PIC_LIST_C) ; iRefIdx<2*MAX_NUM_REF ; iRefIdx++ ) 
2839    {
2840      pcSlice->getWpScalingLC(iRefIdx, wp);
2841
2842      wp[0].bPresentFlag = false;
2843      wp[1].bPresentFlag = false;
2844      wp[2].bPresentFlag = false;
2845    }
2846  }
2847  else
2848  {
2849    printf("\n wrong weight pred table syntax \n ");
2850    assert(0);
2851  }
2852}
2853
2854/** decode quantization matrix
2855 * \param scalingList quantization matrix information
2856 */
2857Void TDecCavlc::parseScalingList(TComScalingList* scalingList)
2858{
2859  UInt  code, sizeId, listId;
2860  Bool scalingListPredModeFlag;
2861  READ_FLAG( code, "scaling_list_present_flag" );
2862  scalingList->setScalingListPresentFlag ( (code==1)?true:false );
2863  if(scalingList->getScalingListPresentFlag() == false)
2864  {
2865      //for each size
2866    for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2867    {
2868      for(listId = 0; listId <  g_scalingListNum[sizeId]; listId++)
2869      {
2870        READ_FLAG( code, "scaling_list_pred_mode_flag");
2871        scalingListPredModeFlag = (code) ? true : false;
2872        if(!scalingListPredModeFlag) //Copy Mode
2873        {
2874          READ_UVLC( code, "scaling_list_pred_matrix_id_delta");
2875          scalingList->setRefMatrixId (sizeId,listId,(UInt)((Int)(listId)-(code+1)));
2876          if( sizeId > SCALING_LIST_8x8 )
2877          {
2878            scalingList->setScalingListDC(sizeId,listId,scalingList->getScalingListDC(sizeId, scalingList->getRefMatrixId (sizeId,listId)));
2879          }
2880          scalingList->processRefMatrix( sizeId, listId, scalingList->getRefMatrixId (sizeId,listId));
2881         
2882        }
2883        else //DPCM Mode
2884        {
2885          xDecodeScalingList(scalingList, sizeId, listId);
2886        }
2887      }
2888    }
2889  }
2890
2891  return;
2892}
2893/** decode DPCM
2894 * \param scalingList  quantization matrix information
2895 * \param sizeId size index
2896 * \param listId list index
2897 */
2898Void TDecCavlc::xDecodeScalingList(TComScalingList *scalingList, UInt sizeId, UInt listId)
2899{
2900  Int i,coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
2901  Int data;
2902  Int scalingListDcCoefMinus8 = 0;
2903  Int nextCoef = SCALING_LIST_START_VALUE;
2904  UInt* scan  = g_auiFrameScanXY [ (sizeId == 0)? 1 : 2 ];
2905  Bool stopNow = false;
2906  Int *dst = scalingList->getScalingListAddress(sizeId, listId);
2907
2908  scalingList->setUseDefaultScalingMatrixFlag(sizeId,listId,false);
2909  if( sizeId > SCALING_LIST_8x8 )
2910  {
2911    READ_SVLC( scalingListDcCoefMinus8, "scaling_list_dc_coef_minus8");
2912    scalingList->setScalingListDC(sizeId,listId,scalingListDcCoefMinus8 + 8);
2913    if(scalingListDcCoefMinus8 == -8)
2914    {
2915      scalingList->processDefaultMarix(sizeId,listId);
2916    }
2917  }
2918
2919  if( !scalingList->getUseDefaultScalingMatrixFlag(sizeId,listId))
2920  {
2921    for(i = 0; i < coefNum && !stopNow ; i++)
2922    {
2923      READ_SVLC( data, "scaling_list_delta_coef");
2924      nextCoef = (nextCoef + data + 256 ) % 256;
2925      if(sizeId < SCALING_LIST_16x16)
2926      {
2927        if( i == 0 && nextCoef == 0 )
2928        {
2929          scalingList->processDefaultMarix(sizeId,listId);
2930          stopNow = true;
2931        }
2932      }
2933      if(!stopNow)
2934      {
2935        dst[scan[i]] = nextCoef;
2936      }
2937    }
2938  }
2939}
2940
2941Void TDecCavlc::parseDFFlag(UInt& ruiVal, const Char *pSymbolName)
2942{
2943  READ_FLAG(ruiVal, pSymbolName);
2944}
2945Void TDecCavlc::parseDFSvlc(Int&  riVal, const Char *pSymbolName)
2946{
2947  READ_SVLC(riVal, pSymbolName);
2948}
2949
2950Bool TDecCavlc::xMoreRbspData()
2951{ 
2952  Int bitsLeft = m_pcBitstream->getNumBitsLeft();
2953
2954  // if there are more than 8 bits, it cannot be rbsp_trailing_bits
2955  if (bitsLeft > 8)
2956  {
2957    return true;
2958  }
2959
2960  UChar lastByte = m_pcBitstream->peekBits(bitsLeft);
2961  Int cnt = bitsLeft;
2962
2963  // remove trailing bits equal to zero
2964  while ((cnt>0) && ((lastByte & 1) == 0))
2965  {
2966    lastByte >>= 1;
2967    cnt--;
2968  }
2969  // remove bit equal to one
2970  cnt--;
2971
2972  // we should not have a negative number of bits
2973  assert (cnt>=0);
2974
2975  // we have more data, if cnt is not zero
2976  return (cnt>0);
2977}
2978
2979//! \}
Note: See TracBrowser for help on using the repository browser.