source: 3DVCSoftware/branches/HTM-5.1-dev2-Sony/source/Lib/TLibDecoder/TDecCAVLC.cpp @ 262

Last change on this file since 262 was 262, checked in by sony, 11 years ago

JCT2-C0115 Inter-view vector scaling for TMVP & flag
The macro is INTER_VIEW_VECTOR_SCALING_C0115.

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