source: 3DVCSoftware/branches/HTM-6.2-dev0/source/Lib/TLibDecoder/TDecCAVLC.cpp @ 433

Last change on this file since 433 was 433, checked in by tech, 11 years ago

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