source: 3DVCSoftware/branches/0.3-ericsson/source/Lib/TLibDecoder/TDecCAVLC.cpp

Last change on this file was 40, checked in by ericsson, 13 years ago

Ericsson integration: integrated bitstream extractor; implemented NALu header according to HEVC CD, using reserved_one_5bit as layer_id_plus1
  • Property svn:eol-style set to native
File size: 98.3 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-2011, 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 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
35
36/** \file     TDecCAVLC.cpp
37    \brief    CAVLC decoder class
38*/
39
40#include "TDecCAVLC.h"
41#include "SEIread.h"
42
43// ====================================================================================================================
44// Constructor / destructor / create / destroy
45// ====================================================================================================================
46
47TDecCavlc::TDecCavlc()
48{
49  m_bAlfCtrl = false;
50  m_uiMaxAlfCtrlDepth = 0;
51
52  m_aaiTempScale            = new Int* [ MAX_NUMBER_VIEWS ];
53  m_aaiTempOffset           = new Int* [ MAX_NUMBER_VIEWS ];
54  m_aaiTempPdmScaleNomDelta = new Int* [ MAX_NUMBER_VIEWS ];
55  m_aaiTempPdmOffset        = new Int* [ MAX_NUMBER_VIEWS ];
56  for( UInt uiVId = 0; uiVId < MAX_NUMBER_VIEWS; uiVId++ )
57  {
58    m_aaiTempScale            [ uiVId ] = new Int [ MAX_NUMBER_VIEWS ];
59    m_aaiTempOffset           [ uiVId ] = new Int [ MAX_NUMBER_VIEWS ];
60    m_aaiTempPdmScaleNomDelta [ uiVId ] = new Int [ MAX_NUMBER_VIEWS ];
61    m_aaiTempPdmOffset        [ uiVId ] = new Int [ MAX_NUMBER_VIEWS ];
62  }
63}
64
65TDecCavlc::~TDecCavlc()
66{
67  for( UInt uiVId = 0; uiVId < MAX_NUMBER_VIEWS; uiVId++ )
68  {
69    delete [] m_aaiTempScale            [ uiVId ];
70    delete [] m_aaiTempOffset           [ uiVId ];
71    delete [] m_aaiTempPdmScaleNomDelta [ uiVId ];
72    delete [] m_aaiTempPdmOffset        [ uiVId ];
73  }
74  delete [] m_aaiTempScale;
75  delete [] m_aaiTempOffset;
76  delete [] m_aaiTempPdmScaleNomDelta;
77  delete [] m_aaiTempPdmOffset;
78}
79
80// ====================================================================================================================
81// Public member functions
82// ====================================================================================================================
83
84#if BITSTREAM_EXTRACTION
85Void  TDecCavlc::parseNalUnitHeader ( NalUnitType& eNalUnitType, UInt& TemporalId, UInt& uiLayerId )
86{
87  UInt  uiCode;
88
89  xReadCode ( 1, uiCode ); assert( 0 == uiCode); // forbidden_zero_bit
90  xReadCode ( 1, uiCode );                       // nal_ref_flag
91  xReadCode ( 6, uiCode );                       // nal_unit_type
92  eNalUnitType = (NalUnitType) uiCode;
93
94  xReadCode(3, uiCode); // temporal_id
95  TemporalId = uiCode;
96  xReadCode(5, uiCode); // layer_id_plus1
97  assert( 1 <= uiCode );
98  uiLayerId = uiCode - 1;
99}
100#else
101Void  TDecCavlc::parseNalUnitHeader ( NalUnitType& eNalUnitType, UInt& TemporalId, Bool& bOutputFlag )
102{
103  UInt  uiCode;
104
105  xReadCode ( 1, uiCode ); assert( 0 == uiCode); // forbidden_zero_bit
106  xReadCode ( 2, uiCode );                       // nal_ref_idc
107  xReadCode ( 5, uiCode );                       // nal_unit_type
108  eNalUnitType = (NalUnitType) uiCode;
109
110  if ( (eNalUnitType == NAL_UNIT_CODED_SLICE) || (eNalUnitType == NAL_UNIT_CODED_SLICE_IDR) || (eNalUnitType == NAL_UNIT_CODED_SLICE_CDR) )
111  {
112    xReadCode(3, uiCode); // temporal_id
113    TemporalId = uiCode;
114    xReadFlag(uiCode);    // output_flag
115    bOutputFlag = (0!=uiCode);
116    xReadCode(4, uiCode); // reserved_one_4bits
117  }
118  else
119  {
120    TemporalId = 0;
121    bOutputFlag = true;
122  }
123}
124#endif
125
126/**
127 * unmarshal a sequence of SEI messages from bitstream.
128 */
129void TDecCavlc::parseSEI(SEImessages& seis)
130{
131  assert(!m_pcBitstream->getBitsUntilByteAligned());
132  do {
133    parseSEImessage(*m_pcBitstream, seis);
134    /* SEI messages are an integer number of bytes, something has failed
135     * in the parsing if bitstream not byte-aligned */
136    assert(!m_pcBitstream->getBitsUntilByteAligned());
137  } while (0x80 != m_pcBitstream->peekBits(8));
138  assert(m_pcBitstream->getBitsLeft() == 8); /* rsbp_trailing_bits */
139}
140
141Void TDecCavlc::parsePPS(TComPPS* pcPPS)
142{
143  UInt  uiCode;
144
145  xReadUvlc( uiCode ); pcPPS->setPPSId( uiCode );
146  xReadUvlc( uiCode ); pcPPS->setSPSId( uiCode );
147#if CONSTRAINED_INTRA_PRED
148  xReadFlag ( uiCode ); pcPPS->setConstrainedIntraPred( uiCode ? true : false );
149#endif
150
151#ifdef WEIGHT_PRED
152  xReadCode( 1, uiCode );           // Use of Weighting Prediction (P_SLICE)
153  pcPPS->setUseWP( uiCode==1 );
154  xReadCode( 2, uiCode );           // Use of Bi-Directional Weighting Prediction (B_SLICE)
155  pcPPS->setWPBiPredIdc( uiCode );
156  printf("TDecCavlc::parsePPS():\tm_bUseWeightPred=%d\tm_uiBiPredIdc=%d\n", pcPPS->getUseWP(), pcPPS->getWPBiPredIdc());
157#endif
158  return;
159}
160
161Void TDecCavlc::parseSPS(TComSPS* pcSPS)
162{
163  UInt  uiCode;
164  Int   iCode;
165
166  // Structure
167  xReadUvlc ( uiCode ); pcSPS->setSPSId       ( uiCode    );
168  xReadUvlc ( uiCode ); pcSPS->setWidth       ( uiCode    );
169  xReadUvlc ( uiCode ); pcSPS->setHeight      ( uiCode    );
170  xReadUvlc ( uiCode ); pcSPS->setPadX        ( uiCode    );
171  xReadUvlc ( uiCode ); pcSPS->setPadY        ( uiCode    );
172
173  xReadUvlc ( uiCode );
174  pcSPS->setMaxCUWidth  ( uiCode    ); g_uiMaxCUWidth  = uiCode;
175  pcSPS->setMaxCUHeight ( uiCode    ); g_uiMaxCUHeight = uiCode;
176
177  xReadUvlc ( uiCode );
178  pcSPS->setMaxCUDepth  ( uiCode+1  ); g_uiMaxCUDepth  = uiCode + 1;
179  UInt uiMaxCUDepthCorrect = uiCode;
180
181  xReadUvlc( uiCode ); pcSPS->setQuadtreeTULog2MinSize( uiCode + 2 );
182  xReadUvlc( uiCode ); pcSPS->setQuadtreeTULog2MaxSize( uiCode + pcSPS->getQuadtreeTULog2MinSize() );
183  pcSPS->setMaxTrSize( 1<<(uiCode + pcSPS->getQuadtreeTULog2MinSize()) );
184  xReadUvlc ( uiCode ); pcSPS->setQuadtreeTUMaxDepthInter( uiCode+1 );
185  xReadUvlc ( uiCode ); pcSPS->setQuadtreeTUMaxDepthIntra( uiCode+1 );
186  g_uiAddCUDepth = 0;
187  while( ( pcSPS->getMaxCUWidth() >> uiMaxCUDepthCorrect ) > ( 1 << ( pcSPS->getQuadtreeTULog2MinSize() + g_uiAddCUDepth )  ) ) g_uiAddCUDepth++;
188  pcSPS->setMaxCUDepth( uiMaxCUDepthCorrect+g_uiAddCUDepth  ); g_uiMaxCUDepth  = uiMaxCUDepthCorrect+g_uiAddCUDepth;
189  // BB: these parameters may be removed completly and replaced by the fixed values
190  pcSPS->setMinTrDepth( 0 );
191  pcSPS->setMaxTrDepth( 1 );
192
193  xReadUvlc( uiCode ); pcSPS->setCodedPictureBufferSize( uiCode );
194
195  // Tool on/off
196  xReadFlag( uiCode ); pcSPS->setUseALF ( uiCode ? true : false );
197  xReadFlag( uiCode ); pcSPS->setUseDQP ( uiCode ? true : false );
198#if !HHI_NO_LowDelayCoding
199  xReadFlag( uiCode ); pcSPS->setUseLDC ( uiCode ? true : false );
200#endif
201  xReadFlag( uiCode ); pcSPS->setUseMRG ( uiCode ? true : false ); // SOPH:
202
203#if LM_CHROMA
204  xReadFlag( uiCode ); pcSPS->setUseLMChroma ( uiCode ? true : false );
205#endif
206
207#if HHI_RMP_SWITCH
208  xReadFlag( uiCode ); pcSPS->setUseRMP( uiCode ? true : false );
209#endif
210
211  // AMVP mode for each depth (AM_NONE or AM_EXPL)
212  for (Int i = 0; i < pcSPS->getMaxCUDepth(); i++)
213  {
214    xReadFlag( uiCode );
215    pcSPS->setAMVPMode( i, (AMVP_MODE)uiCode );
216  }
217
218  // Bit-depth information
219#if FULL_NBIT
220  xReadUvlc( uiCode );
221  g_uiBitDepth = 8 + uiCode;
222  g_uiBitIncrement = 0;
223  pcSPS->setBitDepth(g_uiBitDepth);
224  pcSPS->setBitIncrement(g_uiBitIncrement);
225#else
226#if ENABLE_IBDI
227  xReadUvlc( uiCode ); pcSPS->setBitDepth     ( uiCode+8 ); g_uiBitDepth     = uiCode + 8;
228  xReadUvlc( uiCode ); pcSPS->setBitIncrement ( uiCode   ); g_uiBitIncrement = uiCode;
229#else
230  xReadUvlc( uiCode );
231  g_uiBitDepth = 8;
232  g_uiBitIncrement = uiCode;
233  pcSPS->setBitDepth(g_uiBitDepth);
234  pcSPS->setBitIncrement(g_uiBitIncrement);
235#endif
236#endif
237
238  g_uiBASE_MAX  = ((1<<(g_uiBitDepth))-1);
239
240#if IBDI_NOCLIP_RANGE
241  g_uiIBDI_MAX  = g_uiBASE_MAX << g_uiBitIncrement;
242#else
243  g_uiIBDI_MAX  = ((1<<(g_uiBitDepth+g_uiBitIncrement))-1);
244#endif
245
246#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
247  g_dDeltaDCsQuantOffset = Double(g_uiBitIncrement) -  2.0;
248#endif
249
250#if MTK_NONCROSS_INLOOP_FILTER
251  xReadFlag( uiCode );
252  pcSPS->setLFCrossSliceBoundaryFlag( uiCode ? true : false);
253#endif
254#if MTK_SAO
255  xReadFlag( uiCode ); pcSPS->setUseSAO       ( uiCode ? true : false );
256#endif
257
258  xReadFlag( uiCode ); // SPS base view flag
259  if( uiCode )
260  { // baseview SPS -> set standard values
261    pcSPS->initMultiviewSPS         ( 0 );
262#if DEPTH_MAP_GENERATION
263    pcSPS->setPredDepthMapGeneration( 0, false );
264#endif
265#if HHI_INTER_VIEW_RESIDUAL_PRED
266    pcSPS->setMultiviewResPredMode  ( 0 );
267#endif
268  }
269  else
270  {
271    xReadFlag  ( uiCode ); // depth flag
272    if( uiCode )
273    {
274      xReadUvlc( uiCode ); // view id
275      xReadSvlc(  iCode ); // view order index
276      pcSPS->initMultiviewSPSDepth    ( uiCode, iCode );
277#if DEPTH_MAP_GENERATION
278      pcSPS->setPredDepthMapGeneration( uiCode, true );
279#endif
280#if HHI_INTER_VIEW_RESIDUAL_PRED
281      pcSPS->setMultiviewResPredMode  ( 0 );
282#endif
283#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
284      xReadFlag( uiCode );
285      pcSPS->setUseDMM( uiCode ? true : false );
286#endif
287#if HHI_MPI
288      xReadFlag( uiCode );
289      pcSPS->setUseMVI( uiCode ? true : false );
290#endif
291    }
292    else
293    {
294      UInt  uiViewId, uiCamParPrecision;
295      Int   iVOI;
296      Bool  bCamParSlice;
297      xReadUvlc( uiViewId );  uiViewId++;
298      xReadSvlc( iVOI );
299      xReadUvlc( uiCamParPrecision );
300      xReadFlag( uiCode );    bCamParSlice = ( uiCode == 1 );
301      if( !bCamParSlice )
302      {
303        for( UInt uiBaseId = 0; uiBaseId < uiViewId; uiBaseId++ )
304        {
305          xReadSvlc( iCode );   m_aaiTempScale [ uiBaseId ][ uiViewId ] = iCode;
306          xReadSvlc( iCode );   m_aaiTempOffset[ uiBaseId ][ uiViewId ] = iCode;
307          xReadSvlc( iCode );   m_aaiTempScale [ uiViewId ][ uiBaseId ] = iCode - m_aaiTempScale [ uiBaseId ][ uiViewId ];
308          xReadSvlc( iCode );   m_aaiTempOffset[ uiViewId ][ uiBaseId ] = iCode - m_aaiTempOffset[ uiBaseId ][ uiViewId ];
309        }
310      }
311      pcSPS->initMultiviewSPS( uiViewId, iVOI, uiCamParPrecision, bCamParSlice, m_aaiTempScale, m_aaiTempOffset );
312     
313#if DEPTH_MAP_GENERATION
314      UInt uiPredDepthMapGeneration = 0, uiPdmPrecision = 0;
315#if HHI_INTER_VIEW_MOTION_PRED
316      UInt uiMultiviewMvPredMode = 0;
317#endif
318#if HHI_INTER_VIEW_RESIDUAL_PRED
319      UInt uiMultiviewResPredMode = 0;
320#endif
321      xReadUvlc( uiPredDepthMapGeneration );
322      if( uiPredDepthMapGeneration )
323      {
324        xReadUvlc  ( uiPdmPrecision );
325        for( UInt uiBaseId = 0; uiBaseId < uiViewId; uiBaseId++ )
326        {
327          xReadSvlc( iCode );   m_aaiTempPdmScaleNomDelta[ uiViewId ][ uiBaseId ] = iCode;
328          xReadSvlc( iCode );   m_aaiTempPdmOffset       [ uiViewId ][ uiBaseId ] = iCode;
329        }
330#if HHI_INTER_VIEW_MOTION_PRED
331        xReadUvlc  ( uiMultiviewMvPredMode );
332#endif
333#if HHI_INTER_VIEW_RESIDUAL_PRED
334        xReadFlag  ( uiMultiviewResPredMode );
335#endif
336      }
337#if HHI_INTER_VIEW_MOTION_PRED
338      pcSPS->setPredDepthMapGeneration( uiViewId, false, uiPredDepthMapGeneration, uiMultiviewMvPredMode, uiPdmPrecision, m_aaiTempPdmScaleNomDelta, m_aaiTempPdmOffset );
339#else
340      pcSPS->setPredDepthMapGeneration( uiViewId, false, uiPredDepthMapGeneration, 0, uiPdmPrecision, m_aaiTempPdmScaleNomDelta, m_aaiTempPdmOffset );
341#endif
342#if HHI_INTER_VIEW_RESIDUAL_PRED
343      pcSPS->setMultiviewResPredMode  ( uiMultiviewResPredMode );
344#endif
345#endif
346#if HHI_MPI
347      pcSPS->setUseMVI( false );
348#endif
349    }
350  }
351
352  return;
353}
354
355Void TDecCavlc::parseSliceHeader (TComSlice*& rpcSlice)
356{
357  UInt  uiCode;
358  Int   iCode;
359
360  xReadFlag ( uiCode );
361  Bool bEntropySlice = uiCode ? true : false;
362  if (!bEntropySlice)
363  {
364    xReadUvlc ( uiCode ); rpcSlice->setPPSId( uiCode );
365    xReadCode (10, uiCode);  rpcSlice->setPOC              (uiCode);             // 9 == SPS->Log2MaxFrameNum()
366    xReadUvlc (   uiCode);  rpcSlice->setSliceType        ((SliceType)uiCode);
367    xReadSvlc (    iCode);  rpcSlice->setSliceQp          (iCode);
368  }
369  if (bEntropySlice)
370  {
371    rpcSlice->setNextSlice        ( false );
372    rpcSlice->setNextEntropySlice ( true  );
373
374    xReadUvlc(uiCode);
375    rpcSlice->setEntropySliceCurStartCUAddr( uiCode ); // start CU addr for entropy slice
376  }
377  else
378  {
379    rpcSlice->setNextSlice        ( true  );
380    rpcSlice->setNextEntropySlice ( false );
381
382    xReadUvlc(uiCode);
383    rpcSlice->setSliceCurStartCUAddr( uiCode );        // start CU addr for slice
384    rpcSlice->setEntropySliceCurStartCUAddr( uiCode ); // start CU addr for entropy slice
385
386    xReadFlag ( uiCode );
387    rpcSlice->setSymbolMode( uiCode );
388
389    if (!rpcSlice->isIntra())
390      xReadFlag (   uiCode);
391    else
392      uiCode = 1;
393
394    rpcSlice->setReferenced       (uiCode ? true : false);
395
396#if !HIGH_ACCURACY_BI
397#ifdef ROUNDING_CONTROL_BIPRED
398    if(!rpcSlice->isIntra())
399    {
400      xReadFlag( uiCode );
401      Bool b = (uiCode != 0);
402      rpcSlice->setRounding(b);
403    }
404#endif
405#else
406#if !HIGH_ACCURACY_BI
407    if(!rpcSlice->isIntra())
408    {
409      rpcSlice->setRounding(false);
410    }
411#endif
412#endif
413
414    xReadFlag (   uiCode);  rpcSlice->setLoopFilterDisable(uiCode ? 1 : 0);
415
416    if (!rpcSlice->isIntra())
417    {
418      xReadCode (3, uiCode);  rpcSlice->setNumRefIdx      (REF_PIC_LIST_0, uiCode);
419    }
420    else
421    {
422      rpcSlice->setNumRefIdx(REF_PIC_LIST_0, 0);
423    }
424    if (rpcSlice->isInterB())
425    {
426      xReadCode (3, uiCode);  rpcSlice->setNumRefIdx      (REF_PIC_LIST_1, uiCode);
427    }
428    else
429    {
430      rpcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
431    }
432
433    if (!rpcSlice->isIntra())
434    {
435      for(Int i = 0; i<rpcSlice->getNumRefIdx(REF_PIC_LIST_0);i++)
436      {
437        xReadFlag( uiCode ) ;
438        if( uiCode ) // interview
439        {
440          xReadUvlc( uiCode ) ;
441          rpcSlice->setRefViewIdx(uiCode, REF_PIC_LIST_0, i) ;
442          rpcSlice->setRefPOC(rpcSlice->getPOC(), REF_PIC_LIST_0, i) ;
443        }
444        else
445        {
446          xReadSvlc( iCode ) ;
447          rpcSlice->setRefPOC(rpcSlice->getPOC()-iCode, REF_PIC_LIST_0, i) ;
448          rpcSlice->setRefViewIdx(rpcSlice->getViewIdx(), REF_PIC_LIST_0, i) ;
449        }
450      }
451    }
452    else
453    {
454      rpcSlice->setNumRefIdx(REF_PIC_LIST_0, 0);
455    }
456    if( rpcSlice->isInterB())
457    {
458      for(Int i = 0; i<rpcSlice->getNumRefIdx(REF_PIC_LIST_1);i++)
459      {
460        xReadFlag( uiCode ) ;
461        if( uiCode ) // interview
462        {
463          xReadUvlc( uiCode ) ;
464          rpcSlice->setRefViewIdx(uiCode, REF_PIC_LIST_1, i) ;
465          rpcSlice->setRefPOC(rpcSlice->getPOC(), REF_PIC_LIST_1, i) ;
466        }
467        else
468        {
469          xReadSvlc( iCode ) ;
470          rpcSlice->setRefPOC(rpcSlice->getPOC()-iCode, REF_PIC_LIST_1, i) ;
471          rpcSlice->setRefViewIdx(rpcSlice->getViewIdx(), REF_PIC_LIST_1, i) ;
472        }
473      }
474    }
475    else
476    {
477      rpcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
478    }
479
480#if DCM_COMB_LIST
481    if (rpcSlice->isInterB())
482    {
483      xReadFlag (uiCode);      rpcSlice->setRefPicListCombinationFlag(uiCode ? 1 : 0);
484      if(uiCode)
485      {
486        xReadUvlc(uiCode);      rpcSlice->setNumRefIdx      (REF_PIC_LIST_C, uiCode+1);
487
488        xReadFlag (uiCode);     rpcSlice->setRefPicListModificationFlagLC(uiCode ? 1 : 0);
489        if(uiCode)
490        {
491          for (UInt i=0;i<rpcSlice->getNumRefIdx(REF_PIC_LIST_C);i++)
492          {
493            xReadFlag(uiCode);
494            rpcSlice->setListIdFromIdxOfLC(i, uiCode);
495            xReadUvlc(uiCode);
496            rpcSlice->setRefIdxFromIdxOfLC(i, uiCode);
497            rpcSlice->setRefIdxOfLC((RefPicList)rpcSlice->getListIdFromIdxOfLC(i), rpcSlice->getRefIdxFromIdxOfLC(i), i);
498          }
499        }
500      }
501      else
502      {
503        rpcSlice->setRefPicListCombinationFlag(false);
504        rpcSlice->setRefPicListModificationFlagLC(false);
505        rpcSlice->setNumRefIdx(REF_PIC_LIST_C, -1);
506      }
507    }
508#endif
509
510#if AMVP_NEIGH_COL
511    if ( rpcSlice->getSliceType() == B_SLICE )
512    {
513      xReadFlag (uiCode);
514      rpcSlice->setColDir(uiCode);
515    }
516#endif
517
518#ifdef WEIGHT_PRED
519    if ( (rpcSlice->getPPS()->getUseWP() && rpcSlice->getSliceType()==P_SLICE) || (rpcSlice->getPPS()->getWPBiPredIdc() && rpcSlice->getSliceType()==B_SLICE) )
520    {
521      parseWeightPredTable(rpcSlice);
522      rpcSlice->initWpScaling();
523      rpcSlice->displayWpScaling();
524    }
525#endif
526    if( rpcSlice->getPPS()->getPPSId() != rpcSlice->getPPSId() )
527    {
528      return;
529    }
530
531
532    if( rpcSlice->getSPS()->hasCamParInSliceHeader() )
533    {
534      UInt uiViewId = rpcSlice->getSPS()->getViewId();
535      for( UInt uiBaseId = 0; uiBaseId < uiViewId; uiBaseId++ )
536      {
537        xReadSvlc( iCode );   m_aaiTempScale [ uiBaseId ][ uiViewId ] = iCode;
538        xReadSvlc( iCode );   m_aaiTempOffset[ uiBaseId ][ uiViewId ] = iCode;
539        xReadSvlc( iCode );   m_aaiTempScale [ uiViewId ][ uiBaseId ] = iCode - m_aaiTempScale [ uiBaseId ][ uiViewId ];
540        xReadSvlc( iCode );   m_aaiTempOffset[ uiViewId ][ uiBaseId ] = iCode - m_aaiTempOffset[ uiBaseId ][ uiViewId ];
541      }
542      rpcSlice->initMultiviewSlice( m_aaiTempScale, m_aaiTempOffset );
543    }
544  }
545  return;
546}
547
548Void TDecCavlc::resetEntropy          (TComSlice* pcSlice)
549{
550  m_bRunLengthCoding = ! pcSlice->isIntra();
551  m_uiRun = 0;
552
553#if !CAVLC_COEF_LRG_BLK
554  ::memcpy(m_uiLPTableD8,        g_auiLPTableD8,        10*128*sizeof(UInt));
555#endif
556  ::memcpy(m_uiLPTableD4,        g_auiLPTableD4,        3*32*sizeof(UInt));
557  ::memcpy(m_uiLastPosVlcIndex,  g_auiLastPosVlcIndex,  10*sizeof(UInt));
558
559#if CAVLC_RQT_CBP
560  ::memcpy(m_uiCBP_YUV_TableD, g_auiCBP_YUV_TableD, 4*8*sizeof(UInt));
561  ::memcpy(m_uiCBP_YS_TableD,  g_auiCBP_YS_TableD,  2*4*sizeof(UInt));
562  ::memcpy(m_uiCBP_YCS_TableD, g_auiCBP_YCS_TableD, 2*8*sizeof(UInt));
563  ::memcpy(m_uiCBP_4Y_TableD,  g_auiCBP_4Y_TableD,  2*15*sizeof(UInt));
564  m_uiCBP_4Y_VlcIdx = 0;
565#else
566  m_uiCbpVlcIdx[0] = 0;
567  m_uiCbpVlcIdx[1] = 0;
568  ::memcpy(m_uiCBPTableD,        g_auiCBPTableD,        2*8*sizeof(UInt));
569  ::memcpy(m_uiBlkCBPTableD,     g_auiBlkCBPTableD,     2*15*sizeof(UInt));
570  m_uiBlkCbpVlcIdx = 0;
571#endif
572
573#if UNIFY_INTER_TABLE
574  ::memcpy(m_uiMI1TableD, g_auiComMI1TableD, 9*sizeof(UInt));
575#else
576  ::memcpy(m_uiMI1TableD,        g_auiMI1TableD,        8*sizeof(UInt));
577  ::memcpy(m_uiMI2TableD,        g_auiMI2TableD,        15*sizeof(UInt));
578
579#if DCM_COMB_LIST
580  if ( pcSlice->getNoBackPredFlag() || pcSlice->getNumRefIdx(REF_PIC_LIST_C)>0)
581#else
582  if ( pcSlice->getNoBackPredFlag() )
583#endif
584  {
585    ::memcpy(m_uiMI1TableD,        g_auiMI1TableDNoL1,        8*sizeof(UInt));
586    ::memcpy(m_uiMI2TableD,        g_auiMI2TableDNoL1,        15*sizeof(UInt));
587  }
588
589#if MS_LCEC_ONE_FRAME
590  if ( pcSlice->getNumRefIdx(REF_PIC_LIST_0) <= 1 && pcSlice->getNumRefIdx(REF_PIC_LIST_1) <= 1 )
591  {
592    if ( pcSlice->getNoBackPredFlag() || ( pcSlice->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcSlice->getNumRefIdx(REF_PIC_LIST_C) <= 1 ) )
593    {
594      ::memcpy(m_uiMI1TableD,        g_auiMI1TableDOnly1RefNoL1,        8*sizeof(UInt));
595    }
596    else
597    {
598      ::memcpy(m_uiMI1TableD,        g_auiMI1TableDOnly1Ref,        8*sizeof(UInt));
599    }
600  }
601#endif
602#if MS_LCEC_LOOKUP_TABLE_EXCEPTION
603  if (pcSlice->getNumRefIdx(REF_PIC_LIST_C)>0)
604  {
605    m_uiMI1TableD[8] = 8;
606  }
607  else  // GPB case
608  {
609    m_uiMI1TableD[8] = m_uiMI1TableD[6];
610    m_uiMI1TableD[6] = 8;
611  }
612#endif
613#endif
614
615#if LCEC_INTRA_MODE
616#if MTK_DCM_MPM
617  ::memcpy(m_uiIntraModeTableD17[0], g_auiIntraModeTableD17[0], 16*sizeof(UInt));
618  ::memcpy(m_uiIntraModeTableD34[0], g_auiIntraModeTableD34[0], 33*sizeof(UInt));
619  ::memcpy(m_uiIntraModeTableD17[1], g_auiIntraModeTableD17[1], 16*sizeof(UInt));
620  ::memcpy(m_uiIntraModeTableD34[1], g_auiIntraModeTableD34[1], 33*sizeof(UInt));
621#else
622  ::memcpy(m_uiIntraModeTableD17, g_auiIntraModeTableD17, 16*sizeof(UInt));
623  ::memcpy(m_uiIntraModeTableD34, g_auiIntraModeTableD34, 33*sizeof(UInt));
624#endif
625#endif
626#if QC_LCEC_INTER_MODE
627  ::memcpy(m_uiSplitTableD, g_auiInterModeTableD, 4*7*sizeof(UInt));
628#endif
629  m_uiMITableVlcIdx = 0;
630
631#if CAVLC_COUNTER_ADAPT
632#if CAVLC_RQT_CBP
633  ::memset(m_ucCBP_YUV_TableCounter, 0, 4*4*sizeof(UChar));
634  ::memset(m_ucCBP_4Y_TableCounter,  0, 2*2*sizeof(UChar));
635  ::memset(m_ucCBP_YCS_TableCounter, 0, 2*4*sizeof(UChar));
636  ::memset(m_ucCBP_YS_TableCounter,  0, 2*3*sizeof(UChar));
637#else
638  ::memset(m_ucCBFTableCounter,        0,        2*4*sizeof(UChar));
639  ::memset(m_ucBlkCBPTableCounter,     0,        2*2*sizeof(UChar));
640#endif
641
642  ::memset(m_ucMI1TableCounter,        0,          4*sizeof(UChar));
643  ::memset(m_ucSplitTableCounter,      0,        4*4*sizeof(UChar));
644
645#if CAVLC_RQT_CBP
646  m_ucCBP_YUV_TableCounterSum[0] = m_ucCBP_YUV_TableCounterSum[1] = m_ucCBP_YUV_TableCounterSum[2] = m_ucCBP_YUV_TableCounterSum[3] = 0;
647  m_ucCBP_4Y_TableCounterSum[0] = m_ucCBP_4Y_TableCounterSum[1] = 0;
648  m_ucCBP_YCS_TableCounterSum[0] = m_ucCBP_YCS_TableCounterSum[1] = 0;
649  m_ucCBP_YS_TableCounterSum[0] = m_ucCBP_YS_TableCounterSum[1] = 0;
650#else
651  m_ucCBFTableCounterSum[0] = m_ucCBFTableCounterSum[1] = 0;
652  m_ucBlkCBPTableCounterSum[0] = m_ucBlkCBPTableCounterSum[1] = 0;
653#endif
654
655  m_ucSplitTableCounterSum[0] = m_ucSplitTableCounterSum[1] = m_ucSplitTableCounterSum[2]= m_ucSplitTableCounterSum[3] = 0;
656  m_ucMI1TableCounterSum = 0;
657#endif
658}
659
660Void TDecCavlc::parseTerminatingBit( UInt& ruiBit )
661{
662  ruiBit = false;
663  Int iBitsLeft = m_pcBitstream->getBitsLeft();
664  if(iBitsLeft <= 8)
665  {
666    UInt uiPeekValue = m_pcBitstream->peekBits(iBitsLeft);
667    if (uiPeekValue == (1<<(iBitsLeft-1)))
668      ruiBit = true;
669  }
670}
671
672Void TDecCavlc::parseAlfCtrlDepth              ( UInt& ruiAlfCtrlDepth )
673{
674  UInt uiSymbol;
675  xReadUnaryMaxSymbol(uiSymbol, g_uiMaxCUDepth-1);
676  ruiAlfCtrlDepth = uiSymbol;
677}
678
679Void TDecCavlc::parseAlfCtrlFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
680{
681  if (!m_bAlfCtrl)
682    return;
683
684  if( uiDepth > m_uiMaxAlfCtrlDepth && !pcCU->isFirstAbsZorderIdxInDepth(uiAbsPartIdx, m_uiMaxAlfCtrlDepth))
685  {
686    return;
687  }
688
689  UInt uiSymbol;
690  xReadFlag( uiSymbol );
691
692  if (uiDepth > m_uiMaxAlfCtrlDepth)
693  {
694    pcCU->setAlfCtrlFlagSubParts( uiSymbol, uiAbsPartIdx, m_uiMaxAlfCtrlDepth);
695  }
696  else
697  {
698    pcCU->setAlfCtrlFlagSubParts( uiSymbol, uiAbsPartIdx, uiDepth );
699  }
700}
701
702Void TDecCavlc::parseSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
703{
704#if QC_LCEC_INTER_MODE
705  return;
706#else
707
708  if( pcCU->getSlice()->isIntra() )
709  {
710    return;
711  }
712
713  UInt uiSymbol = 0;
714  xReadFlag( uiSymbol );
715
716  if( uiSymbol )
717  {
718    pcCU->setPredModeSubParts( MODE_SKIP,  uiAbsPartIdx, uiDepth );
719    pcCU->setPartSizeSubParts( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
720    pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
721#if HHI_MRG_SKIP
722    pcCU->setMergeFlagSubParts( true , uiAbsPartIdx, 0, uiDepth );
723#else
724    TComMv cZeroMv(0,0);
725    pcCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvd    ( cZeroMv, SIZE_2Nx2N, uiAbsPartIdx, 0, uiDepth );
726    pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvd    ( cZeroMv, SIZE_2Nx2N, uiAbsPartIdx, 0, uiDepth );
727
728    pcCU->setTrIdxSubParts( 0, uiAbsPartIdx, uiDepth );
729    pcCU->setCbfSubParts  ( 0, 0, 0, uiAbsPartIdx, uiDepth );
730
731    if ( pcCU->getSlice()->isInterP() )
732    {
733      pcCU->setInterDirSubParts( 1, uiAbsPartIdx, 0, uiDepth );
734
735      if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) > 0 )
736        pcCU->getCUMvField( REF_PIC_LIST_0 )->setAllRefIdx(  0, SIZE_2Nx2N, uiAbsPartIdx, 0, uiDepth );
737      if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) > 0 )
738        pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllRefIdx( NOT_VALID, SIZE_2Nx2N, uiAbsPartIdx, 0, uiDepth );
739    }
740    else
741    {
742      pcCU->setInterDirSubParts( 3, uiAbsPartIdx, 0, uiDepth );
743
744      if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) > 0 )
745        pcCU->getCUMvField( REF_PIC_LIST_0 )->setAllRefIdx(  0, SIZE_2Nx2N, uiAbsPartIdx, 0, uiDepth );
746      if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) > 0 )
747        pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllRefIdx( 0, SIZE_2Nx2N, uiAbsPartIdx, 0, uiDepth );
748    }
749  }
750#endif // HHI_MRG_SKIP
751#endif // QC_LCEC_INTER_MODE
752}
753
754/** parse the motion vector predictor index
755 * \param pcCU
756 * \param riMVPIdx
757 * \param iMVPNum
758 * \param uiAbsPartIdx
759 * \param uiDepth
760 * \param eRefList
761 * \returns Void
762 */
763Void TDecCavlc::parseMVPIdx( TComDataCU* pcCU, Int& riMVPIdx, Int iMVPNum, UInt uiAbsPartIdx, UInt uiDepth, RefPicList eRefList )
764{
765  UInt uiSymbol;
766  xReadUnaryMaxSymbol(uiSymbol, iMVPNum-1);
767  riMVPIdx = uiSymbol;
768}
769
770Void TDecCavlc::parseViewIdx(Int& riViewIdx)
771{
772  UInt uiSymbol;
773  xReadUnaryMaxSymbol(uiSymbol, MAX_NUMBER_VIEWS);
774  riViewIdx = uiSymbol;
775}
776
777#if QC_LCEC_INTER_MODE
778/** parse the split flag
779 * \param pcCU
780 * \param uiAbsPartIdx
781 * \param uiDepth
782 * \returns Void
783 */
784Void TDecCavlc::parseSplitFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
785{
786  if (pcCU->getSlice()->isIntra())
787  {
788    if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
789    {
790      pcCU->setDepthSubParts( uiDepth, uiAbsPartIdx );
791      return ;
792    }
793
794    UInt uiSymbol;
795    xReadFlag( uiSymbol );
796    pcCU->setDepthSubParts( uiDepth + uiSymbol, uiAbsPartIdx );
797
798    return ;
799  }
800  UInt tmp=0;
801  UInt cx=0;
802  UInt uiMode ;
803  {
804    UInt iMaxLen= (uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth)?5:6;
805    while (tmp==0 && cx<iMaxLen)
806    {
807      xReadFlag( tmp );
808      cx++;
809    };
810    if(tmp!=0)
811      cx--;
812
813    UInt uiDepthRemember = uiDepth;
814    if ( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
815    {
816      uiDepth = 3;
817    }
818    UInt x = m_uiSplitTableD[uiDepth][cx];
819    /* Adapt table */
820    uiMode = x;
821#if CAVLC_COUNTER_ADAPT
822    adaptCodeword(cx, m_ucSplitTableCounter[uiDepth],  m_ucSplitTableCounterSum[uiDepth],   m_uiSplitTableD[uiDepth],  NULL, 4 );
823#else
824    if (cx>0)
825    {
826      UInt cy = Max(0,cx-1);
827      UInt y = m_uiSplitTableD[uiDepth][cy];
828      m_uiSplitTableD[uiDepth][cy] = x;
829      m_uiSplitTableD[uiDepth][cx] = y;
830    }
831#endif
832    uiDepth = uiDepthRemember;
833  }
834  if (uiMode==0)
835  {
836    pcCU->setDepthSubParts( uiDepth + 1, uiAbsPartIdx );
837  }
838  else
839  {
840    pcCU->setPartSizeSubParts( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
841    pcCU->setMergeFlagSubParts(false, uiAbsPartIdx,0, uiDepth );
842    pcCU->setDepthSubParts( uiDepth    , uiAbsPartIdx );
843    if (uiMode ==1)
844    {
845      TComMv cZeroMv(0,0);
846      pcCU->setPredModeSubParts( MODE_SKIP,  uiAbsPartIdx, uiDepth );
847      pcCU->setPartSizeSubParts( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
848      pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
849      pcCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvd    ( cZeroMv, SIZE_2Nx2N, uiAbsPartIdx, 0, uiDepth );
850      pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvd    ( cZeroMv, SIZE_2Nx2N, uiAbsPartIdx, 0, uiDepth );
851      pcCU->setTrIdxSubParts( 0, uiAbsPartIdx, uiDepth );
852      pcCU->setCbfSubParts  ( 0, 0, 0, uiAbsPartIdx, uiDepth );
853
854#if HHI_MRG_SKIP
855      pcCU->setMergeFlagSubParts( true, uiAbsPartIdx, 0, uiDepth );
856#else
857      if ( pcCU->getSlice()->isInterP() )
858      {
859        pcCU->setInterDirSubParts( 1, uiAbsPartIdx, 0, uiDepth );
860
861        if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) > 0 )
862          pcCU->getCUMvField( REF_PIC_LIST_0 )->setAllRefIdx(  0, SIZE_2Nx2N, uiAbsPartIdx, 0, uiDepth );
863        if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) > 0 )
864          pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllRefIdx( NOT_VALID, SIZE_2Nx2N, uiAbsPartIdx, 0, uiDepth );
865      }
866      else
867      {
868        pcCU->setInterDirSubParts( 3, uiAbsPartIdx, 0, uiDepth );
869
870        if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) > 0 )
871          pcCU->getCUMvField( REF_PIC_LIST_0 )->setAllRefIdx(  0, SIZE_2Nx2N, uiAbsPartIdx, 0, uiDepth );
872        if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) > 0 )
873          pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllRefIdx( 0, SIZE_2Nx2N, uiAbsPartIdx, 0, uiDepth );
874      }
875#endif
876    }
877    else if (uiMode==2)
878    {
879      pcCU->setPredModeSubParts( MODE_INTER, uiAbsPartIdx, uiDepth );
880      pcCU->setPartSizeSubParts( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
881      pcCU->setMergeFlagSubParts(true, uiAbsPartIdx,0, uiDepth );
882      pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
883    }
884    else if (uiMode==6)
885    {
886#if MTK_DISABLE_INTRA_NxN_SPLIT && HHI_DISABLE_INTER_NxN_SPLIT
887      if (uiDepth != g_uiMaxCUDepth - g_uiAddCUDepth)
888      {
889        pcCU->setPredModeSubParts( MODE_INTRA, uiAbsPartIdx, uiDepth );
890        pcCU->setPartSizeSubParts( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
891        pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
892        UInt uiTrLevel = 0;
893        UInt uiWidthInBit  = g_aucConvertToBit[pcCU->getWidth(uiAbsPartIdx)]+2;
894        UInt uiTrSizeInBit = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxTrSize()]+2;
895        uiTrLevel          = uiWidthInBit >= uiTrSizeInBit ? uiWidthInBit - uiTrSizeInBit : 0;
896        pcCU->setTrIdxSubParts( uiTrLevel, uiAbsPartIdx, uiDepth );
897      }
898      else
899#endif
900      {
901        pcCU->setPredModeSubParts( MODE_INTER, uiAbsPartIdx, uiDepth );
902        pcCU->setPartSizeSubParts( SIZE_NxN, uiAbsPartIdx, uiDepth );
903      }
904    }
905    else
906    {
907      pcCU->setPredModeSubParts( MODE_INTER, uiAbsPartIdx, uiDepth );
908      pcCU->setPartSizeSubParts( PartSize(uiMode-3), uiAbsPartIdx, uiDepth );
909      pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
910    }
911  }
912}
913#else
914Void TDecCavlc::parseSplitFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
915{
916  if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
917  {
918    pcCU->setDepthSubParts( uiDepth, uiAbsPartIdx );
919    return ;
920  }
921
922  UInt uiSymbol;
923  xReadFlag( uiSymbol );
924  pcCU->setDepthSubParts( uiDepth + uiSymbol, uiAbsPartIdx );
925
926  return ;
927}
928#endif
929
930#if QC_LCEC_INTER_MODE
931
932/** parse partition size
933 * \param pcCU
934 * \param uiAbsPartIdx
935 * \param uiDepth
936 * \returns Void
937 */
938Void TDecCavlc::parsePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
939{
940  UInt uiMode=0;
941  if ( pcCU->getSlice()->isIntra()&& pcCU->isIntra( uiAbsPartIdx ) )
942  {
943#if MTK_DISABLE_INTRA_NxN_SPLIT
944    uiMode = 1;
945    if ( uiDepth == (g_uiMaxCUDepth - g_uiAddCUDepth ))
946#endif
947    {
948      UInt uiSymbol;
949      xReadFlag( uiSymbol );
950      uiMode = uiSymbol ? 1 : 2;
951    }
952  }
953#if MTK_DISABLE_INTRA_NxN_SPLIT && HHI_DISABLE_INTER_NxN_SPLIT
954  else if (uiDepth != (g_uiMaxCUDepth - g_uiAddCUDepth ) || pcCU->getPartitionSize(uiAbsPartIdx ) != SIZE_NxN)
955#else
956  else if (pcCU->getPartitionSize(uiAbsPartIdx ) != SIZE_NxN)
957#endif
958  {
959    return;
960  }
961  else
962  {
963    UInt uiSymbol;
964    xReadFlag( uiSymbol );
965    if(uiSymbol)
966    {
967      uiMode = 1;
968    }
969    else
970    {
971#if (MTK_DISABLE_INTRA_NxN_SPLIT && !HHI_DISABLE_INTER_NxN_SPLIT) || (!MTK_DISABLE_INTRA_NxN_SPLIT && HHI_DISABLE_INTER_NxN_SPLIT )
972      if ( uiDepth != (g_uiMaxCUDepth - g_uiAddCUDepth ))
973      {
974#if MTK_DISABLE_INTRA_NxN_SPLIT && !HHI_DISABLE_INTER_NxN_SPLIT
975        uiMode = 0;
976#elif !MTK_DISABLE_INTRA_NxN_SPLIT && HHI_DISABLE_INTER_NxN_SPLIT
977        uiMode = 2;
978#endif
979      }
980      else
981#endif
982      {
983        xReadFlag( uiSymbol );
984        uiMode = uiSymbol ? 2 : 0;
985      }
986    }
987  }
988  PartSize ePartSize;
989  PredMode eMode;
990  if (uiMode > 0)
991  {
992    eMode = MODE_INTRA;
993    ePartSize = (uiMode==1) ? SIZE_2Nx2N:SIZE_NxN;
994  }
995  else
996  {
997    eMode = MODE_INTER;
998    ePartSize = SIZE_NxN;
999  }
1000  pcCU->setPredModeSubParts( eMode    , uiAbsPartIdx, uiDepth );
1001  pcCU->setPartSizeSubParts( ePartSize, uiAbsPartIdx, uiDepth );
1002  pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
1003
1004  if( pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTRA )
1005  {
1006    UInt uiTrLevel = 0;
1007    UInt uiWidthInBit  = g_aucConvertToBit[pcCU->getWidth(uiAbsPartIdx)] + 2;
1008    UInt uiTrSizeInBit = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxTrSize()] + 2;
1009    uiTrLevel          = uiWidthInBit >= uiTrSizeInBit ? uiWidthInBit - uiTrSizeInBit : 0;
1010    if( pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_NxN )
1011    {
1012      pcCU->setTrIdxSubParts( 1 + uiTrLevel, uiAbsPartIdx, uiDepth );
1013    }
1014    else
1015    {
1016      pcCU->setTrIdxSubParts( uiTrLevel, uiAbsPartIdx, uiDepth );
1017    }
1018  }
1019}
1020#else
1021Void TDecCavlc::parsePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1022{
1023  UInt uiSymbol, uiMode = 0;
1024  PartSize eMode;
1025
1026  if ( pcCU->isIntra( uiAbsPartIdx ) )
1027  {
1028#if MTK_DISABLE_INTRA_NxN_SPLIT
1029    eMode = SIZE_2Nx2N;
1030    if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
1031#endif
1032    {
1033      xReadFlag( uiSymbol );
1034      eMode = uiSymbol ? SIZE_2Nx2N : SIZE_NxN;
1035    }
1036  }
1037  else
1038  {
1039#if HHI_RMP_SWITCH
1040    if ( !pcCU->getSlice()->getSPS()->getUseRMP())
1041    {
1042      xReadFlag( uiSymbol );
1043      if( uiSymbol )
1044        uiMode = 0;
1045      else
1046        uiMode = 3;
1047    }
1048    else
1049#endif
1050    {
1051      UInt uiMaxNumBits = 3;
1052      for ( UInt ui = 0; ui < uiMaxNumBits; ui++ )
1053      {
1054        xReadFlag( uiSymbol );
1055        if ( uiSymbol )
1056        {
1057          break;
1058        }
1059        uiMode++;
1060      }
1061    }
1062    eMode = (PartSize) uiMode;
1063
1064    if (pcCU->getSlice()->isInterB() && uiMode == 3)
1065    {
1066#if HHI_DISABLE_INTER_NxN_SPLIT
1067      uiSymbol = 0;
1068      if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
1069#endif
1070      {
1071        xReadFlag( uiSymbol );
1072      }
1073
1074      if (uiSymbol == 0)
1075      {
1076        pcCU->setPredModeSubParts( MODE_INTRA, uiAbsPartIdx, uiDepth );
1077#if MTK_DISABLE_INTRA_NxN_SPLIT
1078        if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
1079#endif
1080        {
1081          xReadFlag( uiSymbol );
1082        }
1083        if (uiSymbol == 0)
1084          eMode = SIZE_2Nx2N;
1085      }
1086    }
1087
1088  }
1089
1090  pcCU->setPartSizeSubParts( eMode, uiAbsPartIdx, uiDepth );
1091  pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
1092
1093  UInt uiTrLevel = 0;
1094
1095  UInt uiWidthInBit  = g_aucConvertToBit[pcCU->getWidth(uiAbsPartIdx)]+2;
1096  UInt uiTrSizeInBit = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxTrSize()]+2;
1097  uiTrLevel          = uiWidthInBit >= uiTrSizeInBit ? uiWidthInBit - uiTrSizeInBit : 0;
1098
1099  if( pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTRA )
1100  {
1101    if( pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_NxN )
1102    {
1103      pcCU->setTrIdxSubParts( 1+uiTrLevel, uiAbsPartIdx, uiDepth );
1104    }
1105    else
1106    {
1107      pcCU->setTrIdxSubParts( uiTrLevel, uiAbsPartIdx, uiDepth );
1108    }
1109  }
1110}
1111#endif
1112
1113/** parse prediction mode
1114 * \param pcCU
1115 * \param uiAbsPartIdx
1116 * \param uiDepth
1117 * \returns Void
1118 */
1119Void TDecCavlc::parsePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1120{
1121  if( pcCU->getSlice()->isIntra() )
1122  {
1123    pcCU->setPredModeSubParts( MODE_INTRA, uiAbsPartIdx, uiDepth );
1124    return ;
1125  }
1126#if !QC_LCEC_INTER_MODE
1127  UInt uiSymbol;
1128  Int  iPredMode = MODE_INTER;
1129
1130  if ( pcCU->getSlice()->isInterB() )
1131  {
1132    pcCU->setPredModeSubParts( (PredMode)iPredMode, uiAbsPartIdx, uiDepth );
1133    return;
1134  }
1135  xReadFlag( uiSymbol );
1136  iPredMode += uiSymbol;
1137
1138  pcCU->setPredModeSubParts( (PredMode)iPredMode, uiAbsPartIdx, uiDepth );
1139#endif
1140}
1141
1142#if LCEC_INTRA_MODE
1143#if MTK_DCM_MPM
1144Void TDecCavlc::parseIntraDirLumaAng  ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1145{
1146  Int  uiIPredMode = 0;
1147  Int  iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
1148
1149  Int uiPreds[2] = {-1, -1};
1150  Int uiPredNum = pcCU->getIntraDirLumaPredictor(uiAbsPartIdx, uiPreds);
1151
1152  if ( g_aucIntraModeBitsAng[iIntraIdx] < 5 )
1153  {
1154     UInt uiSymbol;
1155     xReadFlag( uiSymbol );
1156     if ( uiSymbol )
1157     {
1158       if(uiPredNum == 1)
1159       {
1160        uiIPredMode = uiPreds[0];
1161       }
1162       else
1163       {
1164        xReadFlag( uiSymbol );
1165        uiIPredMode = uiPreds[uiSymbol];
1166       }
1167     }
1168     else
1169     {
1170      xReadFlag( uiSymbol ); uiIPredMode  = uiSymbol;
1171      if ( g_aucIntraModeBitsAng[iIntraIdx] > 2 ) { xReadFlag( uiSymbol ); uiIPredMode |= uiSymbol << 1; }
1172      if ( g_aucIntraModeBitsAng[iIntraIdx] > 3 ) { xReadFlag( uiSymbol ); uiIPredMode |= uiSymbol << 2; }
1173
1174      for(UInt i = 0; i < uiPredNum; i++)
1175      {
1176        if(uiIPredMode >= uiPreds[i]) { uiIPredMode ++;}
1177      }
1178
1179    }
1180  }
1181  else
1182  {
1183  Int  iDir, iDirLarger, iRankIntraMode, iRankIntraModeLarger;
1184
1185  const UInt *huff;
1186  const UInt *lengthHuff;
1187  UInt  totMode;
1188  UInt  *m_uiIntraModeTableD;
1189
1190  if ( g_aucIntraModeBitsAng[iIntraIdx] == 5 )
1191  {
1192  totMode = (uiPredNum == 1)? 17: 16;
1193  huff = huff17_2[uiPredNum - 1];
1194  lengthHuff = lengthHuff17_2[uiPredNum - 1];
1195  m_uiIntraModeTableD = m_uiIntraModeTableD17[uiPredNum - 1];
1196  }
1197  else
1198  {
1199  totMode = (uiPredNum == 1)? 34: 33;
1200  huff = huff34_2[uiPredNum - 1];
1201  lengthHuff = lengthHuff34_2[uiPredNum - 1];
1202  m_uiIntraModeTableD = m_uiIntraModeTableD34[uiPredNum - 1];
1203  }
1204
1205  UInt uiCode;
1206  UInt uiLength = lengthHuff[totMode - 1];
1207
1208  m_pcBitstream->pseudoRead(uiLength,uiCode);
1209  if ((uiCode>>(uiLength- lengthHuff[0])) == huff[0])
1210  {
1211      m_pcBitstream->read(lengthHuff[0],uiCode);
1212
1213     if(uiPredNum == 1)
1214     {
1215        uiIPredMode = uiPreds[0];
1216     }
1217     else if(uiPredNum == 2)
1218     {
1219        UInt uiPredIdx= 0;
1220        xReadFlag( uiPredIdx );
1221        uiIPredMode = uiPreds[uiPredIdx];
1222     }
1223
1224  }
1225  else
1226  {
1227      iRankIntraMode = 0;
1228
1229      for(Int i = 1; i < totMode; i++)
1230     {
1231        if( (uiCode>>(uiLength- lengthHuff[i])) == huff[i])
1232        {
1233          m_pcBitstream->read(lengthHuff[i], uiCode);
1234          iRankIntraMode = i;
1235          break;
1236        }
1237      }
1238
1239     iRankIntraMode --;
1240     iDir = m_uiIntraModeTableD[iRankIntraMode];
1241     iRankIntraModeLarger = Max(0,iRankIntraMode-1);
1242     iDirLarger = m_uiIntraModeTableD[iRankIntraModeLarger];
1243     m_uiIntraModeTableD[iRankIntraModeLarger] = iDir;
1244     m_uiIntraModeTableD[iRankIntraMode] = iDirLarger;
1245
1246     for(UInt i = 0; i < uiPredNum; i++)
1247     {
1248       if(iDir >= uiPreds[i])
1249       {
1250         iDir ++;
1251       }
1252     }
1253
1254     uiIPredMode = iDir;
1255
1256
1257    }
1258  }
1259#if ADD_PLANAR_MODE
1260  if (uiIPredMode == 2)
1261  {
1262    UInt planarFlag;
1263    xReadFlag( planarFlag );
1264    if ( planarFlag )
1265    {
1266      uiIPredMode = PLANAR_IDX;
1267    }
1268  }
1269#endif
1270
1271  pcCU->setLumaIntraDirSubParts( (UChar)uiIPredMode, uiAbsPartIdx, uiDepth );
1272}
1273#else
1274Void TDecCavlc::parseIntraDirLumaAng  ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1275{
1276  UInt uiSymbol;
1277  Int  uiIPredMode;
1278  Int  iMostProbable = pcCU->getMostProbableIntraDirLuma( uiAbsPartIdx );
1279  Int  iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
1280  Int  iDir, iDirLarger, iRankIntraMode, iRankIntraModeLarger;
1281
1282  Int  iLeft          = pcCU->getLeftIntraDirLuma( uiAbsPartIdx );
1283  Int  iAbove         = pcCU->getAboveIntraDirLuma( uiAbsPartIdx );
1284  UInt ind=(iLeft==iAbove)? 0 : 1;
1285
1286  const UInt *huff17=huff17_2[ind];
1287  const UInt *lengthHuff17=lengthHuff17_2[ind];
1288  const UInt *huff34=huff34_2[ind];
1289  const UInt *lengthHuff34=lengthHuff34_2[ind];
1290
1291  if ( g_aucIntraModeBitsAng[iIntraIdx] < 5 )
1292  {
1293    xReadFlag( uiSymbol );
1294    if ( uiSymbol )
1295      uiIPredMode = iMostProbable;
1296    else
1297    {
1298      xReadFlag( uiSymbol ); uiIPredMode  = uiSymbol;
1299      if ( g_aucIntraModeBitsAng[iIntraIdx] > 2 ) { xReadFlag( uiSymbol ); uiIPredMode |= uiSymbol << 1; }
1300      if ( g_aucIntraModeBitsAng[iIntraIdx] > 3 ) { xReadFlag( uiSymbol ); uiIPredMode |= uiSymbol << 2; }
1301      if(uiIPredMode >= iMostProbable)
1302        uiIPredMode ++;
1303    }
1304  }
1305  else if ( g_aucIntraModeBitsAng[iIntraIdx] == 5 )
1306  {
1307    UInt uiCode;
1308    UInt uiLength = lengthHuff17[15];
1309    m_pcBitstream->pseudoRead(uiLength,uiCode);
1310    if ((uiCode>>(uiLength- lengthHuff17[0])) == huff17[0])
1311    {
1312      m_pcBitstream->read(lengthHuff17[0],uiCode);
1313      uiIPredMode = iMostProbable;
1314    }
1315    else
1316    {
1317      iRankIntraMode = 0;
1318      for (Int i=1;i<17;i++)
1319      {
1320        if( (uiCode>>(uiLength- lengthHuff17[i])) == huff17[i])
1321        {
1322          m_pcBitstream->read(lengthHuff17[i], uiCode);
1323          iRankIntraMode = i;
1324          break;
1325        }
1326      }
1327
1328      if ( iRankIntraMode > 0 )
1329        iRankIntraMode --;
1330      iDir = m_uiIntraModeTableD17[iRankIntraMode];
1331
1332      iRankIntraModeLarger = Max(0,iRankIntraMode-1);
1333      iDirLarger = m_uiIntraModeTableD17[iRankIntraModeLarger];
1334
1335      m_uiIntraModeTableD17[iRankIntraModeLarger] = iDir;
1336      m_uiIntraModeTableD17[iRankIntraMode] = iDirLarger;
1337
1338      uiIPredMode = (iDir>=iMostProbable? iDir+1: iDir);
1339    }
1340  }
1341  else
1342  {
1343    UInt uiCode;
1344    UInt uiLength = lengthHuff34[32];
1345    m_pcBitstream->pseudoRead(uiLength,uiCode);
1346    if ((uiCode>>(uiLength- lengthHuff34[0])) == huff34[0])
1347    {
1348      m_pcBitstream->read(lengthHuff34[0],uiCode);
1349      uiIPredMode = iMostProbable;
1350    }
1351    else
1352    {
1353      iRankIntraMode = 0;
1354      for (Int i=1;i<34;i++)
1355      {
1356        if( (uiCode>>(uiLength- lengthHuff34[i])) == huff34[i])
1357        {
1358          m_pcBitstream->read(lengthHuff34[i], uiCode);
1359          iRankIntraMode = i;
1360          break;
1361        }
1362      }
1363
1364      if ( iRankIntraMode > 0 )
1365        iRankIntraMode --;
1366      iDir = m_uiIntraModeTableD34[iRankIntraMode];
1367
1368      iRankIntraModeLarger = Max(0,iRankIntraMode-1);
1369      iDirLarger = m_uiIntraModeTableD34[iRankIntraModeLarger];
1370
1371      m_uiIntraModeTableD34[iRankIntraModeLarger] = iDir;
1372      m_uiIntraModeTableD34[iRankIntraMode] = iDirLarger;
1373
1374      uiIPredMode = (iDir>=iMostProbable? iDir+1: iDir);
1375    }
1376  }
1377
1378#if ADD_PLANAR_MODE
1379  if (uiIPredMode == 2)
1380  {
1381    UInt planarFlag;
1382    xReadFlag( planarFlag );
1383    if ( planarFlag )
1384    {
1385      uiIPredMode = PLANAR_IDX;
1386    }
1387  }
1388#endif
1389  pcCU->setLumaIntraDirSubParts( (UChar)uiIPredMode, uiAbsPartIdx, uiDepth );
1390}
1391#endif
1392#else
1393Void TDecCavlc::parseIntraDirLumaAng  ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1394{
1395  UInt uiSymbol;
1396  Int  uiIPredMode;
1397  Int  iMostProbable = pcCU->getMostProbableIntraDirLuma( uiAbsPartIdx );
1398
1399  xReadFlag( uiSymbol );
1400
1401  if ( uiSymbol )
1402    uiIPredMode = iMostProbable;
1403  else
1404  {
1405    Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
1406    if ( g_aucIntraModeBitsAng[iIntraIdx] < 6 )
1407    {
1408      xReadFlag( uiSymbol ); uiIPredMode  = uiSymbol;
1409      if ( g_aucIntraModeBitsAng[iIntraIdx] > 2 ) { xReadFlag( uiSymbol ); uiIPredMode |= uiSymbol << 1; }
1410      if ( g_aucIntraModeBitsAng[iIntraIdx] > 3 ) { xReadFlag( uiSymbol ); uiIPredMode |= uiSymbol << 2; }
1411      if ( g_aucIntraModeBitsAng[iIntraIdx] > 4 ) { xReadFlag( uiSymbol ); uiIPredMode |= uiSymbol << 3; }
1412    }
1413    else
1414    {
1415      xReadFlag( uiSymbol ); uiIPredMode  = uiSymbol;
1416      xReadFlag( uiSymbol ); uiIPredMode |= uiSymbol << 1;
1417      xReadFlag( uiSymbol ); uiIPredMode |= uiSymbol << 2;
1418      xReadFlag( uiSymbol ); uiIPredMode |= uiSymbol << 3;
1419      xReadFlag( uiSymbol ); uiIPredMode |= uiSymbol << 4;
1420
1421      if (uiIPredMode == 31)
1422      { // Escape coding for the last two modes
1423        xReadFlag( uiSymbol );
1424        uiIPredMode = uiSymbol ? 32 : 31;
1425      }
1426    }
1427
1428    if (uiIPredMode >= iMostProbable)
1429      uiIPredMode++;
1430  }
1431
1432#if ADD_PLANAR_MODE
1433  if (uiIPredMode == 2)
1434  {
1435    UInt planarFlag;
1436    xReadFlag( planarFlag );
1437    if ( planarFlag )
1438    {
1439      uiIPredMode = PLANAR_IDX;
1440    }
1441  }
1442#endif
1443  pcCU->setLumaIntraDirSubParts( (UChar)uiIPredMode, uiAbsPartIdx, uiDepth );
1444}
1445#endif
1446
1447Void TDecCavlc::parseIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1448{
1449  UInt uiSymbol;
1450#if CHROMA_CODEWORD
1451  UInt uiMode = pcCU->getLumaIntraDir(uiAbsPartIdx);
1452#if ADD_PLANAR_MODE
1453  if ( (uiMode == 2 ) || (uiMode == PLANAR_IDX) )
1454  {
1455    uiMode = 4;
1456  }
1457#endif
1458#if LM_CHROMA
1459  Int  iMaxMode = pcCU->getSlice()->getSPS()->getUseLMChroma() ? 3 : 4;
1460
1461  Int  iMax = uiMode < iMaxMode ? 3 : 4;
1462
1463  xReadUnaryMaxSymbol( uiSymbol, iMax );
1464
1465  //switch codeword
1466  if (uiSymbol == 0)
1467  {
1468    uiSymbol = 4;
1469  }
1470  else if (uiSymbol == 1 && pcCU->getSlice()->getSPS()->getUseLMChroma())
1471  {
1472    uiSymbol = 3;
1473  }
1474  else
1475  {
1476#if CHROMA_CODEWORD_SWITCH
1477    uiSymbol = ChromaMapping[iMax-3][uiSymbol];
1478#endif
1479
1480    if (pcCU->getSlice()->getSPS()->getUseLMChroma())
1481       uiSymbol --;
1482
1483    if (uiSymbol <= uiMode)
1484       uiSymbol --;
1485  }
1486
1487#else // -- LM_CHROMA
1488
1489  Int  iMax = uiMode < 4 ? 3 : 4;
1490  xReadUnaryMaxSymbol( uiSymbol, iMax );
1491
1492  //switch codeword
1493  if (uiSymbol == 0)
1494  {
1495    uiSymbol = 4;
1496  }
1497#if CHROMA_CODEWORD_SWITCH
1498  else
1499  {
1500    uiSymbol = ChromaMapping[iMax-3][uiSymbol];
1501    if (uiSymbol <= uiMode)
1502    {
1503      uiSymbol --;
1504    }
1505  }
1506#else
1507  else if (uiSymbol <= uiMode)
1508  {
1509    uiSymbol --;
1510  }
1511#endif
1512#endif // --> LM_CHROMA
1513
1514  //printf("uiMode %d, chroma %d, codeword %d, imax %d\n", uiMode, uiSymbol, uiRead, iMax);
1515#else
1516  xReadFlag( uiSymbol );
1517
1518  if ( uiSymbol )
1519  {
1520    xReadUnaryMaxSymbol( uiSymbol, 3 );
1521    uiSymbol++;
1522  }
1523#endif
1524
1525#if ADD_PLANAR_MODE
1526  if (uiSymbol == 2)
1527  {
1528#if CHROMA_CODEWORD
1529    uiMode = pcCU->getLumaIntraDir(uiAbsPartIdx);
1530    if (uiMode == 2)
1531    {
1532      uiSymbol = PLANAR_IDX;
1533    }
1534    else if (uiMode != PLANAR_IDX)
1535#endif
1536    {
1537      UInt planarFlag;
1538      xReadFlag( planarFlag );
1539      if ( planarFlag )
1540      {
1541        uiSymbol = PLANAR_IDX;
1542      }
1543    }
1544  }
1545#endif
1546  pcCU->setChromIntraDirSubParts( uiSymbol, uiAbsPartIdx, uiDepth );
1547
1548  return ;
1549}
1550
1551Void TDecCavlc::parseInterDir( TComDataCU* pcCU, UInt& ruiInterDir, UInt uiAbsPartIdx, UInt uiDepth )
1552{
1553  UInt uiSymbol;
1554
1555#if UNIFY_INTER_TABLE
1556#if DCM_COMB_LIST
1557  UInt uiNumRefIdxOfLC = pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C);
1558#endif
1559  #define min(a, b) (((a) < (b)) ? (a) : (b))
1560#if DCM_COMB_LIST
1561  UInt uiValNumRefIdxOfLC = min(4,pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C));
1562#endif
1563  UInt uiValNumRefIdxOfL0 = min(2,pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_0));
1564  UInt uiValNumRefIdxOfL1 = min(2,pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_1));
1565
1566  if ( pcCU->getSlice()->getRefIdxCombineCoding() )
1567  {
1568    UInt uiIndex,tmp;
1569#if CAVLC_COUNTER_ADAPT
1570    Int x,cx;
1571#else
1572    Int x,cx,y,cy;
1573#endif
1574
1575    UInt *m_uiMITableD = m_uiMI1TableD;
1576
1577    UInt uiMaxVal;
1578#if DCM_COMB_LIST
1579    if (uiNumRefIdxOfLC > 0)
1580    {
1581      uiMaxVal = uiValNumRefIdxOfLC + uiValNumRefIdxOfL0*uiValNumRefIdxOfL1;
1582    }
1583    else
1584#endif
1585    if (pcCU->getSlice()->getNoBackPredFlag())
1586    {
1587      uiMaxVal = uiValNumRefIdxOfL0 + uiValNumRefIdxOfL0*uiValNumRefIdxOfL1;
1588    }
1589    else
1590    {
1591      uiMaxVal = uiValNumRefIdxOfL0 + uiValNumRefIdxOfL1 + uiValNumRefIdxOfL0*uiValNumRefIdxOfL1;
1592    }
1593
1594    xReadUnaryMaxSymbol( tmp, uiMaxVal );
1595
1596    x = m_uiMITableD[tmp];
1597    uiIndex = x;
1598
1599    /* Adapt table */
1600
1601    cx = tmp;
1602#if CAVLC_COUNTER_ADAPT
1603    adaptCodeword(cx, m_ucMI1TableCounter,  m_ucMI1TableCounterSum,  m_uiMITableD,  NULL, 4 );
1604#else
1605    cy = Max(0,cx-1);
1606    y = m_uiMITableD[cy];
1607    m_uiMITableD[cy] = x;
1608    m_uiMITableD[cx] = y;
1609    m_uiMITableVlcIdx += cx == m_uiMITableVlcIdx ? 0 : (cx < m_uiMITableVlcIdx ? -1 : 1);
1610#endif
1611
1612    if (uiIndex < uiMaxVal)
1613    {
1614#if DCM_COMB_LIST
1615      if (uiNumRefIdxOfLC > 0)
1616      {
1617        if (uiIndex < uiValNumRefIdxOfLC)
1618        {
1619          ruiInterDir = 1;
1620          m_iRefFrame0[uiAbsPartIdx] = uiIndex;
1621        }
1622        else
1623        {
1624          UInt uiTmp = uiIndex-uiValNumRefIdxOfLC;
1625          ruiInterDir = 3;
1626
1627          m_iRefFrame0[uiAbsPartIdx] = uiTmp/uiValNumRefIdxOfL1; //uiValNumRefIdxOfL1 == 1 or 2, so division can be converted to shift op
1628          m_iRefFrame1[uiAbsPartIdx] = uiTmp%uiValNumRefIdxOfL1;
1629        }
1630      }
1631      else
1632#endif
1633      if (pcCU->getSlice()->getNoBackPredFlag())
1634      {
1635        if (uiIndex < uiValNumRefIdxOfL0)
1636        {
1637          ruiInterDir = 1;
1638          m_iRefFrame0[uiAbsPartIdx] = uiIndex;
1639        }
1640        else
1641        {
1642          UInt uiTmp = uiIndex-uiValNumRefIdxOfL0;
1643          ruiInterDir = 3;
1644
1645          m_iRefFrame0[uiAbsPartIdx] = uiTmp/uiValNumRefIdxOfL1; //uiValNumRefIdxOfL1 == 1 or 2, so division can be converted to shift op
1646          m_iRefFrame1[uiAbsPartIdx] = uiTmp%uiValNumRefIdxOfL1;
1647        }
1648      }
1649      else
1650      {
1651        if (uiIndex < uiValNumRefIdxOfL0)
1652        {
1653          ruiInterDir = 1;
1654          m_iRefFrame0[uiAbsPartIdx] = uiIndex;
1655        }
1656        else if (uiIndex < uiValNumRefIdxOfL1)
1657        {
1658          ruiInterDir = 2;
1659          m_iRefFrame1[uiAbsPartIdx] = uiIndex-uiValNumRefIdxOfL0;
1660        }
1661        else
1662        {
1663          UInt uiTmp = uiIndex-uiValNumRefIdxOfL0-uiValNumRefIdxOfL1;
1664          ruiInterDir = 3;
1665
1666          m_iRefFrame0[uiAbsPartIdx] = uiTmp/uiValNumRefIdxOfL1; //uiValNumRefIdxOfL1 == 1 or 2, so division can be converted to shift op
1667          m_iRefFrame1[uiAbsPartIdx] = uiTmp%uiValNumRefIdxOfL1;
1668        }
1669      }
1670
1671      return;
1672    }
1673  }
1674#else  //UNIFY_INTER_TABLE
1675#if MS_LCEC_LOOKUP_TABLE_EXCEPTION
1676  if ( pcCU->getSlice()->getRefIdxCombineCoding() )
1677#else
1678  if(pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) <= 2 && pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) <= 2)
1679#endif
1680  {
1681    UInt uiIndex,uiInterDir,tmp;
1682
1683#if CAVLC_COUNTER_ADAPT
1684    Int x,cx;
1685#else
1686    Int x,cx,y,cy;
1687#endif
1688
1689#if MS_LCEC_LOOKUP_TABLE_MAX_VALUE
1690    UInt uiMaxVal = 7;
1691#if MS_LCEC_LOOKUP_TABLE_EXCEPTION
1692    uiMaxVal = 8;
1693#endif
1694    if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) <= 1 && pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) <= 1 )
1695    {
1696      if ( pcCU->getSlice()->getNoBackPredFlag() || ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) <= 1 ) )
1697      {
1698        uiMaxVal = 1;
1699      }
1700      else
1701      {
1702        uiMaxVal = 2;
1703      }
1704    }
1705    else if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) <= 2 && pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) <= 2 )
1706    {
1707      if ( pcCU->getSlice()->getNoBackPredFlag() || ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) <= 2 ) )
1708      {
1709        uiMaxVal = 5;
1710      }
1711      else
1712      {
1713        uiMaxVal = 7;
1714      }
1715    }
1716    else if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) <= 0 )
1717    {
1718      uiMaxVal = 4+1+MS_LCEC_UNI_EXCEPTION_THRES;
1719    }
1720
1721    xReadUnaryMaxSymbol( tmp, uiMaxVal );
1722#else
1723    UInt vlcn = g_auiMITableVlcNum[m_uiMITableVlcIdx];
1724    tmp = xReadVlc( vlcn );
1725#endif
1726
1727    UInt *m_uiMITableD = m_uiMI1TableD;
1728    x = m_uiMITableD[tmp];
1729    uiIndex = x;
1730
1731    /* Adapt table */
1732
1733    cx = tmp;
1734
1735#if CAVLC_COUNTER_ADAPT
1736    adaptCodeword(cx, m_ucMI1TableCounter,  m_ucMI1TableCounterSum,  m_uiMITableD,  NULL, 4 );
1737#else
1738    cy = Max(0,cx-1);
1739    y = m_uiMITableD[cy];
1740    m_uiMITableD[cy] = x;
1741    m_uiMITableD[cx] = y;
1742    m_uiMITableVlcIdx += cx == m_uiMITableVlcIdx ? 0 : (cx < m_uiMITableVlcIdx ? -1 : 1);
1743#endif
1744    {
1745      uiInterDir = Min(2,uiIndex>>1);
1746#if MS_LCEC_LOOKUP_TABLE_EXCEPTION
1747      if ( uiIndex >=4 )
1748      {
1749        uiInterDir = 2;
1750      }
1751      else
1752      {
1753        uiInterDir = 0;
1754      }
1755#endif
1756#if DCM_COMB_LIST
1757      if(uiInterDir!=2 && pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C)>0)
1758      {
1759        uiInterDir = 0;
1760        m_iRefFrame0[uiAbsPartIdx] = uiIndex;
1761      }
1762      else
1763#endif
1764      if (uiInterDir==0)
1765      {
1766#if MS_LCEC_LOOKUP_TABLE_EXCEPTION
1767        m_iRefFrame0[uiAbsPartIdx] = uiIndex;
1768#else
1769        m_iRefFrame0[uiAbsPartIdx] = uiIndex&1;
1770#endif
1771      }
1772      else if (uiInterDir==1)
1773        m_iRefFrame1[uiAbsPartIdx] = uiIndex&1;
1774      else
1775      {
1776        m_iRefFrame0[uiAbsPartIdx] = (uiIndex>>1)&1;
1777        m_iRefFrame1[uiAbsPartIdx] = (uiIndex>>0)&1;
1778      }
1779    }
1780    ruiInterDir = uiInterDir+1;
1781#if MS_LCEC_LOOKUP_TABLE_EXCEPTION
1782    if ( x < 8 )
1783#endif
1784    {
1785      return;
1786    }
1787  }
1788#endif //UNIFY_INTER_TABLE
1789
1790#if MS_LCEC_LOOKUP_TABLE_EXCEPTION
1791  m_iRefFrame0[uiAbsPartIdx] = 1000;
1792  m_iRefFrame1[uiAbsPartIdx] = 1000;
1793#endif
1794
1795  xReadFlag( uiSymbol );
1796
1797  if ( uiSymbol )
1798  {
1799    uiSymbol = 2;
1800  }
1801#if DCM_COMB_LIST
1802  else if(pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0)
1803  {
1804    uiSymbol = 0;
1805  }
1806#endif
1807  else if ( pcCU->getSlice()->getNoBackPredFlag() )
1808  {
1809    uiSymbol = 0;
1810  }
1811  else
1812  {
1813    xReadFlag( uiSymbol );
1814  }
1815  uiSymbol++;
1816  ruiInterDir = uiSymbol;
1817  return;
1818}
1819
1820Void TDecCavlc::parseRefFrmIdx( TComDataCU* pcCU, Int& riRefFrmIdx, UInt uiAbsPartIdx, UInt uiDepth, RefPicList eRefList )
1821{
1822  UInt uiSymbol;
1823
1824  if (pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) <= 2 && pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) <= 2 && pcCU->getSlice()->isInterB())
1825  {
1826#if DCM_COMB_LIST
1827    if(pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C ) > 0 && eRefList==REF_PIC_LIST_C)
1828    {
1829      riRefFrmIdx = m_iRefFrame0[uiAbsPartIdx];
1830    }
1831    else
1832#endif
1833    if (eRefList==REF_PIC_LIST_0)
1834    {
1835      riRefFrmIdx = m_iRefFrame0[uiAbsPartIdx];
1836    }
1837    if (eRefList==REF_PIC_LIST_1)
1838    {
1839      riRefFrmIdx = m_iRefFrame1[uiAbsPartIdx];
1840    }
1841    return;
1842  }
1843
1844#if MS_LCEC_LOOKUP_TABLE_EXCEPTION
1845  if ( ( m_iRefFrame0[uiAbsPartIdx] != 1000 || m_iRefFrame1[uiAbsPartIdx] != 1000 ) &&
1846      pcCU->getSlice()->getRefIdxCombineCoding() )
1847  {
1848    if(pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C ) > 0 && eRefList==REF_PIC_LIST_C )
1849    {
1850      riRefFrmIdx = m_iRefFrame0[uiAbsPartIdx];
1851    }
1852    else if (eRefList==REF_PIC_LIST_0)
1853    {
1854      riRefFrmIdx = m_iRefFrame0[uiAbsPartIdx];
1855    }
1856    else if (eRefList==REF_PIC_LIST_1)
1857    {
1858      riRefFrmIdx = m_iRefFrame1[uiAbsPartIdx];
1859    }
1860    return;
1861  }
1862
1863  UInt uiRefFrmIdxMinus = 0;
1864  if ( pcCU->getSlice()->getRefIdxCombineCoding() )
1865  {
1866    if ( pcCU->getInterDir( uiAbsPartIdx ) != 3 )
1867    {
1868      if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 )
1869      {
1870        uiRefFrmIdxMinus = 4;
1871      }
1872      else
1873      {
1874        uiRefFrmIdxMinus = MS_LCEC_UNI_EXCEPTION_THRES+1;
1875      }
1876    }
1877    else if ( eRefList == REF_PIC_LIST_1 && pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiAbsPartIdx ) < 2 )
1878    {
1879      uiRefFrmIdxMinus = 2;
1880    }
1881  }
1882  if ( pcCU->getSlice()->getNumRefIdx( eRefList ) - uiRefFrmIdxMinus <= 1 )
1883  {
1884    uiSymbol = 0;
1885    riRefFrmIdx = uiSymbol;
1886    riRefFrmIdx += uiRefFrmIdxMinus;
1887    return;
1888  }
1889#endif
1890
1891  xReadFlag ( uiSymbol );
1892  if ( uiSymbol )
1893  {
1894#if MS_LCEC_LOOKUP_TABLE_EXCEPTION
1895    xReadUnaryMaxSymbol( uiSymbol, pcCU->getSlice()->getNumRefIdx( eRefList )-2 - uiRefFrmIdxMinus );
1896#else
1897    xReadUnaryMaxSymbol( uiSymbol, pcCU->getSlice()->getNumRefIdx( eRefList )-2 );
1898#endif
1899
1900    uiSymbol++;
1901  }
1902  riRefFrmIdx = uiSymbol;
1903#if MS_LCEC_LOOKUP_TABLE_EXCEPTION
1904  riRefFrmIdx += uiRefFrmIdxMinus;
1905#endif
1906
1907  return;
1908}
1909
1910Void TDecCavlc::parseMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth, RefPicList eRefList )
1911{
1912  Int iHor, iVer;
1913  UInt uiAbsPartIdxL, uiAbsPartIdxA;
1914  Int iHorPred, iVerPred;
1915
1916  TComDataCU* pcCUL   = pcCU->getPULeft ( uiAbsPartIdxL, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
1917  TComDataCU* pcCUA   = pcCU->getPUAbove( uiAbsPartIdxA, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
1918
1919  TComCUMvField* pcCUMvFieldL = ( pcCUL == NULL || pcCUL->isIntra( uiAbsPartIdxL ) ) ? NULL : pcCUL->getCUMvField( eRefList );
1920  TComCUMvField* pcCUMvFieldA = ( pcCUA == NULL || pcCUA->isIntra( uiAbsPartIdxA ) ) ? NULL : pcCUA->getCUMvField( eRefList );
1921
1922  iHorPred = ( (pcCUMvFieldL == NULL) ? 0 : pcCUMvFieldL->getMvd( uiAbsPartIdxL ).getAbsHor() ) +
1923  ( (pcCUMvFieldA == NULL) ? 0 : pcCUMvFieldA->getMvd( uiAbsPartIdxA ).getAbsHor() );
1924  iVerPred = ( (pcCUMvFieldL == NULL) ? 0 : pcCUMvFieldL->getMvd( uiAbsPartIdxL ).getAbsVer() ) +
1925  ( (pcCUMvFieldA == NULL) ? 0 : pcCUMvFieldA->getMvd( uiAbsPartIdxA ).getAbsVer() );
1926
1927  TComMv cTmpMv( 0, 0 );
1928  pcCU->getCUMvField( eRefList )->setAllMv( cTmpMv, pcCU->getPartitionSize( uiAbsPartIdx ), uiAbsPartIdx, uiPartIdx, uiDepth );
1929
1930  xReadSvlc( iHor );
1931  xReadSvlc( iVer );
1932
1933  // set mvd
1934  TComMv cMv( iHor, iVer );
1935  pcCU->getCUMvField( eRefList )->setAllMvd( cMv, pcCU->getPartitionSize( uiAbsPartIdx ), uiAbsPartIdx, uiPartIdx, uiDepth );
1936
1937  return;
1938}
1939
1940Void TDecCavlc::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1941{
1942  UInt uiDQp;
1943  Int  iDQp;
1944
1945  xReadFlag( uiDQp );
1946
1947  if ( uiDQp == 0 )
1948  {
1949    uiDQp = pcCU->getSlice()->getSliceQp();
1950  }
1951  else
1952  {
1953    xReadSvlc( iDQp );
1954    uiDQp = pcCU->getSlice()->getSliceQp() + iDQp;
1955  }
1956
1957  pcCU->setQPSubParts( uiDQp, uiAbsPartIdx, uiDepth );
1958}
1959
1960#if CAVLC_RQT_CBP
1961/** Function for parsing cbf and split
1962 * \param pcCU pointer to CU
1963 * \param uiAbsPartIdx CU index
1964 * \param uiTrDepth Transform depth
1965 * \param uiDepth CU Depth
1966 * \param uiSubdiv split flag
1967 * \returns
1968 * This function performs parsing for cbf and split flag
1969 */
1970Void TDecCavlc::parseCbfTrdiv( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiTrDepth, UInt uiDepth, UInt& uiSubdiv )
1971{
1972  UInt uiCbf,tmp;
1973  UInt uiCBP,uiCbfY,uiCbfU,uiCbfV;
1974  UInt n,cx;
1975  UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiDepth ] + 2;
1976  UInt uiQPartNumParent  = pcCU->getPic()->getNumPartInCU() >> ((uiDepth-1) << 1);
1977  UInt uiQPartNumCurr    = pcCU->getPic()->getNumPartInCU() >> ((uiDepth) << 1);
1978
1979  UInt uiFlagPattern = xGetFlagPattern( pcCU, uiAbsPartIdx, uiDepth, uiSubdiv );
1980
1981  n = pcCU->isIntra( uiAbsPartIdx ) ? 0 : 1;
1982  uiCbfY = uiCbfU = uiCbfV = 0;
1983
1984  if(uiFlagPattern < 8)
1985  {
1986    if( uiLog2TrSize > pcCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() )
1987    {
1988      if(uiFlagPattern & 0x04)
1989      {
1990        xReadFlag(uiCbfU);
1991      }
1992      if(uiFlagPattern & 0x02)
1993      {
1994        xReadFlag(uiCbfV);
1995      }
1996    }
1997    else
1998    {
1999      uiCbfU = pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth - 1)?1:0;
2000      uiCbfV = pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth - 1)?1:0;
2001    }
2002    if(uiFlagPattern & 0x01)
2003    {
2004      parseTransformSubdivFlag( uiSubdiv, 0);
2005    }
2006  }
2007  else
2008  {
2009    if(uiFlagPattern == 8)
2010    {
2011      if (uiAbsPartIdx % uiQPartNumParent ==0)
2012      {
2013        parseBlockCbf(pcCU, uiAbsPartIdx, TEXT_LUMA, uiTrDepth,uiDepth, uiQPartNumCurr);
2014      }
2015      uiCbfY = ( pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA ) >> uiTrDepth) & 0x1;
2016      if( uiLog2TrSize <= pcCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() )
2017      {
2018        uiCbfU = pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth - 1)?1:0;
2019        uiCbfV = pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth - 1)?1:0;
2020      }
2021    }
2022    else if(uiFlagPattern == 9)
2023    {
2024      bool bNeedToDecode = true;
2025      if ( n==1 && (uiAbsPartIdx%uiQPartNumParent) / uiQPartNumCurr == 3 )  // last one
2026      {
2027        UInt uiTempAbsPartIdx = uiAbsPartIdx/uiQPartNumParent*uiQPartNumParent;
2028        if ( pcCU->getCbf( uiTempAbsPartIdx + uiQPartNumCurr*0, TEXT_LUMA, uiTrDepth ) ||
2029          pcCU->getCbf( uiTempAbsPartIdx + uiQPartNumCurr*1, TEXT_LUMA, uiTrDepth ) ||
2030          pcCU->getCbf( uiTempAbsPartIdx + uiQPartNumCurr*2, TEXT_LUMA, uiTrDepth ) )
2031        {
2032          bNeedToDecode = true;
2033        }
2034        else
2035        {
2036          bNeedToDecode = false;
2037          xReadFlag( uiSubdiv );
2038          uiCbfY = 1;
2039        }
2040      }
2041      if ( bNeedToDecode )
2042      {
2043        UInt uiSymbol;
2044        xReadUnaryMaxSymbol(cx, n?2:3);
2045        uiSymbol = m_uiCBP_YS_TableD[n][cx];
2046        uiCbfY = uiSymbol >> 1;
2047        uiSubdiv = uiSymbol & 0x01;
2048        adaptCodeword(cx, m_ucCBP_YS_TableCounter[n],  m_ucCBP_YS_TableCounterSum[n],  m_uiCBP_YS_TableD[n],  NULL, 3);
2049      }
2050    }
2051    else if (uiFlagPattern == 14)
2052    {
2053      UInt  uiIdx = uiTrDepth? (2 + n) : n;
2054      xReadUnaryMaxSymbol(cx, 7);
2055      uiCBP = m_uiCBP_YUV_TableD[uiIdx][cx];
2056      adaptCodeword(cx,  m_ucCBP_YUV_TableCounter[uiIdx],  m_ucCBP_YUV_TableCounterSum[uiIdx],  m_uiCBP_YUV_TableD[uiIdx],  NULL, 4);
2057      uiCbfY = (uiCBP>>2)&1;
2058      uiCbfU = (uiCBP>>1)&1;
2059      uiCbfV = (uiCBP>>0)&1;
2060    }
2061    else if ( uiFlagPattern == 11 || uiFlagPattern == 13 || uiFlagPattern == 15)
2062    {
2063      UInt uiSymbol, i;
2064      m_pcBitstream->pseudoRead(6, uiSymbol);
2065      for (i=0;i<8;i++)
2066      {
2067        if( (uiSymbol>>(6 - g_auiCBP_YCS_TableLen[n][i])) == g_auiCBP_YCS_Table[n][i] && g_auiCBP_YCS_TableLen[n][i])
2068        {
2069          m_pcBitstream->read(g_auiCBP_YCS_TableLen[n][i],uiSymbol);
2070          uiSymbol =i;
2071          break;
2072        }
2073      }
2074
2075      uiCBP = m_uiCBP_YCS_TableD[n][uiSymbol];
2076      adaptCodeword(uiSymbol, m_ucCBP_YCS_TableCounter[n], m_ucCBP_YCS_TableCounterSum[n],  m_uiCBP_YCS_TableD[n],  NULL, 4);
2077      uiCbfY = uiCBP >> 2;
2078      UInt uiCbfUV = (uiCBP >> 1)& 0x01;
2079      uiSubdiv = uiCBP & 0x01;
2080
2081      uiCbfU = 0; uiCbfV = 0;
2082      if (uiFlagPattern == 15)
2083      {
2084        if(uiCbfUV)
2085        {
2086          xReadUnaryMaxSymbol( uiSymbol , 2);
2087          uiSymbol = n? (uiSymbol + 1): (3 - uiSymbol);
2088          uiCbfU = uiSymbol >> 1;
2089          uiCbfV = uiSymbol & 0x01;
2090        }
2091      }
2092      else
2093      {
2094        uiCbfU = (uiFlagPattern & 0x04) ?  uiCbfUV: 0;
2095        uiCbfV = (uiFlagPattern & 0x02) ?  uiCbfUV: 0;
2096      }
2097    }
2098    else if (uiFlagPattern == 10 || uiFlagPattern == 12)
2099    {
2100      UInt uiSymbol;
2101      xReadUnaryMaxSymbol(tmp, 3);
2102      uiSymbol = g_auiCBP_YC_TableD[n][tmp];
2103      uiCbfY = uiSymbol >> 1;
2104
2105      uiCbfU = uiCbfV = 0;
2106      if(uiSymbol & 0x01)
2107      {
2108        uiCbfU = (uiFlagPattern & 0x04)? 1 : 0;
2109        uiCbfV = (uiFlagPattern & 0x02)? 1 : 0;
2110      }
2111    }
2112  }
2113
2114  uiCbf = pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA );
2115  pcCU->setCbfSubParts( uiCbf | ( uiCbfY << uiTrDepth ), TEXT_LUMA, uiAbsPartIdx, uiDepth );
2116
2117  uiCbf = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U );
2118  pcCU->setCbfSubParts( uiCbf | ( uiCbfU << uiTrDepth ), TEXT_CHROMA_U, uiAbsPartIdx, uiDepth );
2119
2120  uiCbf = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V );
2121  pcCU->setCbfSubParts( uiCbf | ( uiCbfV << uiTrDepth ), TEXT_CHROMA_V, uiAbsPartIdx, uiDepth );
2122
2123  if(!pcCU->isIntra(uiAbsPartIdx) && uiCbfY == 0 && uiCbfU == 0 && uiCbfV == 0)
2124  {
2125    uiSubdiv = 0;
2126  }
2127
2128  return;
2129}
2130
2131/** Function for parsing cbf and split
2132 * \param pcCU pointer to CU
2133 * \param uiAbsPartIdx CU index
2134 * \param uiDepth CU Depth
2135 * \param uiSubdiv split flag
2136 * \returns flag pattern
2137 * This function gets flagpattern for cbf and split flag
2138 */
2139UInt TDecCavlc::xGetFlagPattern( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt& uiSubdiv )
2140{
2141  const UInt uiLog2TrafoSize = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth()]+2 - uiDepth;
2142  UInt uiTrDepth =  uiDepth - pcCU->getDepth( uiAbsPartIdx );
2143  UInt patternYUV, patternDiv;
2144  UInt bY, bU, bV;
2145
2146
2147  UInt uiFullDepth = pcCU->getDepth(uiAbsPartIdx) + uiTrDepth;
2148  UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiFullDepth ] + 2;
2149  if(uiTrDepth == 0)
2150  {
2151    patternYUV = 7;
2152  }
2153  else if( uiLog2TrSize > pcCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() )
2154  {
2155    bY = pcCU->getCbf(uiAbsPartIdx, TEXT_LUMA, uiTrDepth - 1)?1:0;
2156    bU = pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth - 1)?1:0;
2157    bV = pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth - 1)?1:0;
2158    patternYUV = (bY<<2) + (bU<<1) + bV;
2159  }
2160  else
2161  {
2162    bY = pcCU->getCbf(uiAbsPartIdx, TEXT_LUMA, uiTrDepth - 1)?1:0;
2163    patternYUV = bY<<2;
2164  }
2165
2166
2167  if( pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTRA && pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_NxN && uiDepth == pcCU->getDepth(uiAbsPartIdx) )
2168  {
2169    patternDiv = 0; uiSubdiv = 1;
2170  }
2171  else if( uiLog2TrafoSize > pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() )
2172  {
2173    patternDiv = 0; uiSubdiv = 1;
2174  }
2175  else if( uiLog2TrafoSize == pcCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() )
2176  {
2177    patternDiv = 0; uiSubdiv = 0;
2178  }
2179  else if( uiLog2TrafoSize == pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) )
2180  {
2181    patternDiv = 0; uiSubdiv = 0;
2182  }
2183  else
2184  {
2185    patternDiv = 1;
2186  }
2187
2188  return ((patternYUV<<1)+patternDiv);
2189}
2190#endif
2191Void TDecCavlc::parseCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth, UInt uiDepth )
2192{
2193  if (eType == TEXT_ALL)
2194  {
2195    UInt uiCbf,tmp;
2196    UInt uiCBP,uiCbfY,uiCbfU,uiCbfV;
2197
2198#if CAVLC_COUNTER_ADAPT
2199    Int n, cx;
2200#else
2201    Int n,x,cx,y,cy;
2202#endif
2203
2204    /* Start adaptation */
2205    n = pcCU->isIntra( uiAbsPartIdx ) ? 0 : 1;
2206#if CAVLC_RQT_CBP
2207    UInt vlcn = 0;
2208#else
2209    UInt vlcn = g_auiCbpVlcNum[n][m_uiCbpVlcIdx[n]];
2210#endif
2211    tmp = xReadVlc( vlcn );
2212#if CAVLC_RQT_CBP
2213    uiCBP = m_uiCBP_YUV_TableD[n][tmp];
2214#else
2215    uiCBP = m_uiCBPTableD[n][tmp];
2216#endif
2217
2218    /* Adapt LP table */
2219    cx = tmp;
2220
2221#if CAVLC_COUNTER_ADAPT
2222#if CAVLC_RQT_CBP
2223    adaptCodeword(cx, m_ucCBP_YUV_TableCounter[n],  m_ucCBP_YUV_TableCounterSum[n],  m_uiCBP_YUV_TableD[n],  NULL, 4);
2224#else
2225    adaptCodeword(cx, m_ucCBFTableCounter[n],  m_ucCBFTableCounterSum[n],  m_uiCBPTableD[n],  NULL, 4);
2226#endif
2227#else
2228    cy = Max(0,cx-1);
2229    x = uiCBP;
2230    y = m_uiCBPTableD[n][cy];
2231    m_uiCBPTableD[n][cy] = x;
2232    m_uiCBPTableD[n][cx] = y;
2233    m_uiCbpVlcIdx[n] += cx == m_uiCbpVlcIdx[n] ? 0 : (cx < m_uiCbpVlcIdx[n] ? -1 : 1);
2234#endif
2235
2236    uiCbfY = (uiCBP>>0)&1;
2237    uiCbfU = (uiCBP>>1)&1;
2238    uiCbfV = (uiCBP>>2)&1;
2239
2240    uiCbf = pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA );
2241    pcCU->setCbfSubParts( uiCbf | ( uiCbfY << uiTrDepth ), TEXT_LUMA, uiAbsPartIdx, uiDepth );
2242
2243    uiCbf = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U );
2244    pcCU->setCbfSubParts( uiCbf | ( uiCbfU << uiTrDepth ), TEXT_CHROMA_U, uiAbsPartIdx, uiDepth );
2245
2246    uiCbf = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V );
2247    pcCU->setCbfSubParts( uiCbf | ( uiCbfV << uiTrDepth ), TEXT_CHROMA_V, uiAbsPartIdx, uiDepth );
2248  }
2249}
2250
2251Void TDecCavlc::parseBlockCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth, UInt uiDepth, UInt uiQPartNum )
2252{
2253  assert(uiTrDepth > 0);
2254  UInt uiCbf4, uiCbf;
2255
2256#if CAVLC_COUNTER_ADAPT
2257  Int cx;
2258#else
2259  Int x,cx,y,cy;
2260#endif
2261
2262  UInt tmp;
2263
2264  UInt n = (pcCU->isIntra(uiAbsPartIdx) && eType == TEXT_LUMA)? 0:1;
2265#if CAVLC_RQT_CBP
2266  UInt vlcn = (n==0)?g_auiCBP_4Y_VlcNum[m_uiCBP_4Y_VlcIdx]:11;
2267#else
2268  UInt vlcn = (n==0)?g_auiBlkCbpVlcNum[m_uiBlkCbpVlcIdx]:11;
2269#endif
2270  tmp = xReadVlc( vlcn );
2271#if CAVLC_RQT_CBP
2272  uiCbf4 = m_uiCBP_4Y_TableD[n][tmp];
2273#else
2274  uiCbf4 = m_uiBlkCBPTableD[n][tmp];
2275#endif
2276
2277  cx = tmp;
2278
2279#if CAVLC_COUNTER_ADAPT
2280#if CAVLC_RQT_CBP
2281  adaptCodeword(cx, m_ucCBP_4Y_TableCounter[n], m_ucCBP_4Y_TableCounterSum[n], m_uiCBP_4Y_TableD[n], NULL, 2);
2282#else
2283  adaptCodeword(cx, m_ucBlkCBPTableCounter[n],  m_ucBlkCBPTableCounterSum[n],  m_uiBlkCBPTableD[n],  NULL, 2);
2284#endif
2285#else
2286  cy = Max(0,cx-1);
2287  x = uiCbf4;
2288  y = m_uiBlkCBPTableD[n][cy];
2289  m_uiBlkCBPTableD[n][cy] = x;
2290  m_uiBlkCBPTableD[n][cx] = y;
2291#endif
2292
2293#if CAVLC_RQT_CBP
2294  if(n==0)
2295    m_uiCBP_4Y_VlcIdx += cx == m_uiCBP_4Y_VlcIdx ? 0 : (cx < m_uiCBP_4Y_VlcIdx ? -1 : 1);
2296#else
2297  if(n==0)
2298    m_uiBlkCbpVlcIdx += cx == m_uiBlkCbpVlcIdx ? 0 : (cx < m_uiBlkCbpVlcIdx ? -1 : 1);
2299#endif
2300
2301  uiCbf4++;
2302  uiCbf = pcCU->getCbf( uiAbsPartIdx, eType );
2303  pcCU->setCbfSubParts( uiCbf | ( ((uiCbf4>>3)&0x01) << uiTrDepth ), eType, uiAbsPartIdx, uiDepth ); uiAbsPartIdx += uiQPartNum;
2304  uiCbf = pcCU->getCbf( uiAbsPartIdx, eType );
2305  pcCU->setCbfSubParts( uiCbf | ( ((uiCbf4>>2)&0x01) << uiTrDepth ), eType, uiAbsPartIdx, uiDepth ); uiAbsPartIdx += uiQPartNum;
2306  uiCbf = pcCU->getCbf( uiAbsPartIdx, eType );
2307  pcCU->setCbfSubParts( uiCbf | ( ((uiCbf4>>1)&0x01) << uiTrDepth ), eType, uiAbsPartIdx, uiDepth ); uiAbsPartIdx += uiQPartNum;
2308  uiCbf = pcCU->getCbf( uiAbsPartIdx, eType );
2309  pcCU->setCbfSubParts( uiCbf | ( (uiCbf4&0x01) << uiTrDepth ), eType, uiAbsPartIdx, uiDepth );
2310
2311  return;
2312}
2313
2314Void TDecCavlc::parseCoeffNxN( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType )
2315{
2316
2317  if ( uiWidth > pcCU->getSlice()->getSPS()->getMaxTrSize() )
2318  {
2319    uiWidth  = pcCU->getSlice()->getSPS()->getMaxTrSize();
2320    uiHeight = pcCU->getSlice()->getSPS()->getMaxTrSize();
2321  }
2322  UInt uiSize   = uiWidth*uiHeight;
2323
2324  // point to coefficient
2325  TCoeff* piCoeff = pcCoef;
2326
2327  // initialize scan
2328  const UInt*  pucScan;
2329
2330#if CAVLC_COEF_LRG_BLK
2331  UInt maxBlSize = (eTType==TEXT_LUMA)? 32:8;
2332  UInt uiBlSize = Min(maxBlSize,uiWidth);
2333  UInt uiConvBit = g_aucConvertToBit[ pcCU->isIntra( uiAbsPartIdx ) ? uiWidth : uiBlSize];
2334  UInt uiNoCoeff = uiBlSize*uiBlSize;
2335#else
2336  //UInt uiConvBit = g_aucConvertToBit[ Min(8,uiWidth) ];
2337  UInt uiConvBit = g_aucConvertToBit[ pcCU->isIntra( uiAbsPartIdx ) ? uiWidth : Min(8,uiWidth)    ];
2338#endif
2339  pucScan        = g_auiFrameScanXY  [ uiConvBit + 1 ];
2340
2341#if QC_MDCS
2342  UInt uiBlkPos;
2343#if CAVLC_COEF_LRG_BLK
2344  UInt uiLog2BlkSize = g_aucConvertToBit[ pcCU->isIntra( uiAbsPartIdx ) ? uiWidth : uiBlSize] + 2;
2345#else
2346  UInt uiLog2BlkSize = g_aucConvertToBit[ pcCU->isIntra( uiAbsPartIdx ) ? uiWidth : Min(8,uiWidth)    ] + 2;
2347#endif
2348  const UInt uiScanIdx = pcCU->getCoefScanIdx(uiAbsPartIdx, uiWidth, eTType==TEXT_LUMA, pcCU->isIntra(uiAbsPartIdx));
2349#endif //QC_MDCS
2350
2351  UInt uiDecodeDCCoeff = 0;
2352  Int dcCoeff = 0;
2353  if (pcCU->isIntra(uiAbsPartIdx))
2354  {
2355    UInt uiAbsPartIdxL, uiAbsPartIdxA;
2356    TComDataCU* pcCUL   = pcCU->getPULeft (uiAbsPartIdxL, pcCU->getZorderIdxInCU() + uiAbsPartIdx);
2357    TComDataCU* pcCUA   = pcCU->getPUAbove(uiAbsPartIdxA, pcCU->getZorderIdxInCU() + uiAbsPartIdx);
2358    if (pcCUL == NULL && pcCUA == NULL)
2359    {
2360      uiDecodeDCCoeff = 1;
2361      dcCoeff = xReadVlc(eTType == TEXT_LUMA ? 3 : 1);
2362      if (dcCoeff)
2363      {
2364        UInt sign;
2365        xReadFlag(sign);
2366        if (sign)
2367        {
2368          dcCoeff = -dcCoeff;
2369        }
2370      }
2371    }
2372  }
2373
2374  UInt uiScanning;
2375
2376#if CAVLC_COEF_LRG_BLK
2377  static TCoeff scoeff[1024];
2378#else
2379  TCoeff scoeff[64];
2380#endif
2381  Int iBlockType;
2382  if( uiSize == 2*2 )
2383  {
2384    // hack: re-use 4x4 coding
2385#if QC_MOD_LCEC
2386    if (eTType==TEXT_CHROMA_U || eTType==TEXT_CHROMA_V)
2387      iBlockType = eTType-2;
2388    else
2389      iBlockType = 2 + ( pcCU->isIntra(uiAbsPartIdx) ? 0 : pcCU->getSlice()->getSliceType() );
2390#else
2391    iBlockType = pcCU->isIntra(uiAbsPartIdx) ? 0 : pcCU->getSlice()->getSliceType();
2392#endif
2393
2394#if CAVLC_COEF_LRG_BLK
2395    xParseCoeff( scoeff, iBlockType, 4 );
2396#else
2397    xParseCoeff4x4( scoeff, iBlockType );
2398#endif
2399
2400    for (uiScanning=0; uiScanning<4; uiScanning++)
2401    {
2402#if QC_MDCS
2403      uiBlkPos = g_auiSigLastScan[uiScanIdx][uiLog2BlkSize-1][uiScanning];
2404      piCoeff[ uiBlkPos ] =  scoeff[15-uiScanning];
2405#else
2406      piCoeff[ pucScan[ uiScanning ] ] = scoeff[15-uiScanning];
2407#endif //QC_MDCS
2408    }
2409  }
2410  else if ( uiSize == 4*4 )
2411  {
2412#if QC_MOD_LCEC
2413    if (eTType==TEXT_CHROMA_U || eTType==TEXT_CHROMA_V)
2414      iBlockType = eTType-2;
2415    else
2416      iBlockType = 2 + ( pcCU->isIntra(uiAbsPartIdx) ? 0 : pcCU->getSlice()->getSliceType() );
2417#else
2418    iBlockType = pcCU->isIntra(uiAbsPartIdx) ? 0 : pcCU->getSlice()->getSliceType();
2419#endif
2420#if CAVLC_COEF_LRG_BLK
2421    xParseCoeff( scoeff, iBlockType, 4 );
2422#else
2423    xParseCoeff4x4( scoeff, iBlockType );
2424#endif
2425
2426    for (uiScanning=0; uiScanning<16; uiScanning++)
2427    {
2428#if QC_MDCS
2429      uiBlkPos = g_auiSigLastScan[uiScanIdx][uiLog2BlkSize-1][uiScanning];
2430      piCoeff[ uiBlkPos ] =  scoeff[15-uiScanning];
2431#else
2432      piCoeff[ pucScan[ uiScanning ] ] = scoeff[15-uiScanning];
2433#endif //QC_MDCS
2434    }
2435  }
2436  else if ( uiSize == 8*8 )
2437  {
2438    if (eTType==TEXT_CHROMA_U || eTType==TEXT_CHROMA_V) //8x8 specific
2439      iBlockType = eTType-2;
2440    else
2441      iBlockType = 2 + ( pcCU->isIntra(uiAbsPartIdx) ? 0 : pcCU->getSlice()->getSliceType() );
2442#if CAVLC_COEF_LRG_BLK
2443    xParseCoeff( scoeff, iBlockType, 8 );
2444#else
2445    xParseCoeff8x8( scoeff, iBlockType );
2446#endif
2447
2448    for (uiScanning=0; uiScanning<64; uiScanning++)
2449    {
2450#if QC_MDCS
2451      uiBlkPos = g_auiSigLastScan[uiScanIdx][uiLog2BlkSize-1][uiScanning];
2452      piCoeff[ uiBlkPos ] =  scoeff[63-uiScanning];
2453#else
2454      piCoeff[ pucScan[ uiScanning ] ] = scoeff[63-uiScanning];
2455#endif //QC_MDCS
2456    }
2457
2458  }
2459  else
2460  {
2461    if (!pcCU->isIntra( uiAbsPartIdx ))
2462    {
2463      memset(piCoeff,0,sizeof(TCoeff)*uiSize);
2464      if (eTType==TEXT_CHROMA_U || eTType==TEXT_CHROMA_V)
2465        iBlockType = eTType-2;
2466      else
2467        iBlockType = 5 + ( pcCU->isIntra(uiAbsPartIdx) ? 0 : pcCU->getSlice()->getSliceType() );
2468#if CAVLC_COEF_LRG_BLK
2469      xParseCoeff( scoeff, iBlockType, uiBlSize );
2470#else
2471      xParseCoeff8x8( scoeff, iBlockType );
2472#endif
2473
2474#if CAVLC_COEF_LRG_BLK
2475      for (uiScanning=0; uiScanning<uiNoCoeff; uiScanning++)
2476      {
2477#if QC_MDCS
2478        uiBlkPos = g_auiSigLastScan[uiScanIdx][uiLog2BlkSize-1][uiScanning];
2479        uiBlkPos = (uiBlkPos/uiBlSize)* uiWidth + (uiBlkPos&(uiBlSize-1));
2480        piCoeff[ uiBlkPos ] =  scoeff[uiNoCoeff-uiScanning-1];
2481#else
2482        piCoeff[(pucScan[uiScanning]/uiBlSize)*uiWidth + (pucScan[uiScanning]&(uiBlSize-1))]=scoeff[uiNoCoeff-uiScanning-1];
2483#endif
2484      }
2485#else
2486      for (uiScanning=0; uiScanning<64; uiScanning++)
2487      {
2488#if QC_MDCS
2489        uiBlkPos = g_auiSigLastScan[uiScanIdx][uiLog2BlkSize-1][uiScanning];
2490        uiBlkPos = (uiBlkPos/8)* uiWidth + uiBlkPos%8;
2491        piCoeff[ uiBlkPos ] =  scoeff[63-uiScanning];
2492#else
2493        piCoeff[(pucScan[uiScanning]/8)*uiWidth + (pucScan[uiScanning]%8)] = scoeff[63-uiScanning];
2494#endif //QC_MDCS
2495      }
2496#endif
2497      return;
2498    }
2499
2500    if(pcCU->isIntra( uiAbsPartIdx ))
2501    {
2502      memset(piCoeff,0,sizeof(TCoeff)*uiSize);
2503
2504      if (eTType==TEXT_CHROMA_U || eTType==TEXT_CHROMA_V)
2505        iBlockType = eTType-2;
2506      else
2507        iBlockType = 5 + ( pcCU->isIntra(uiAbsPartIdx) ? 0 : pcCU->getSlice()->getSliceType() );
2508
2509#if CAVLC_COEF_LRG_BLK
2510      xParseCoeff( scoeff, iBlockType, uiBlSize );
2511      for (uiScanning=0; uiScanning<uiNoCoeff; uiScanning++)
2512      {
2513#if QC_MDCS
2514        uiBlkPos = g_auiSigLastScan[uiScanIdx][uiLog2BlkSize-1][uiScanning];
2515        piCoeff[ uiBlkPos ] =  scoeff[uiNoCoeff - uiScanning - 1];
2516#else
2517        piCoeff[ pucScan[ uiScanning ] ] = scoeff[uiNoCoeff - uiScanning - 1];
2518#endif //QC_MDCS
2519      }
2520#else
2521      xParseCoeff8x8( scoeff, iBlockType );
2522
2523      for (uiScanning=0; uiScanning<64; uiScanning++)
2524      {
2525#if QC_MDCS
2526        uiBlkPos = g_auiSigLastScan[uiScanIdx][uiLog2BlkSize-1][uiScanning];
2527        piCoeff[ uiBlkPos ] =  scoeff[63-uiScanning];
2528#else
2529        piCoeff[ pucScan[ uiScanning ] ] = scoeff[63-uiScanning];
2530#endif //QC_MDCS
2531      }
2532#endif
2533    }
2534  }
2535
2536  if (uiDecodeDCCoeff == 1)
2537  {
2538    piCoeff[0] = dcCoeff;
2539  }
2540
2541  return ;
2542}
2543
2544Void TDecCavlc::parseTransformSubdivFlag( UInt& ruiSubdivFlag, UInt uiLog2TransformBlockSize )
2545{
2546  xReadFlag( ruiSubdivFlag );
2547}
2548
2549Void TDecCavlc::parseQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth, UInt uiDepth )
2550{
2551  UInt uiSymbol;
2552  xReadFlag( uiSymbol );
2553  pcCU->setCbfSubParts( uiSymbol << uiTrDepth, eType, uiAbsPartIdx, uiDepth );
2554}
2555
2556Void TDecCavlc::parseQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt& uiQtRootCbf )
2557{
2558  UInt uiSymbol;
2559  xReadFlag( uiSymbol );
2560  uiQtRootCbf = uiSymbol;
2561}
2562
2563Void TDecCavlc::parseAlfFlag (UInt& ruiVal)
2564{
2565  xReadFlag( ruiVal );
2566}
2567
2568#if TSB_ALF_HEADER
2569Void TDecCavlc::parseAlfFlagNum( UInt& ruiVal, UInt minValue, UInt depth )
2570{
2571  UInt uiLength = 0;
2572  UInt maxValue = (minValue << (depth*2));
2573  UInt temp = maxValue - minValue;
2574  for(UInt i=0; i<32; i++)
2575  {
2576    if(temp&0x1)
2577    {
2578      uiLength = i+1;
2579    }
2580    temp = (temp >> 1);
2581  }
2582  if(uiLength)
2583  {
2584    xReadCode( uiLength, ruiVal );
2585  }
2586  else
2587  {
2588    ruiVal = 0;
2589  }
2590  ruiVal += minValue;
2591}
2592
2593Void TDecCavlc::parseAlfCtrlFlag( UInt &ruiAlfCtrlFlag )
2594{
2595  UInt uiSymbol;
2596  xReadFlag( uiSymbol );
2597  ruiAlfCtrlFlag = uiSymbol;
2598}
2599#endif
2600
2601Void TDecCavlc::parseAlfUvlc (UInt& ruiVal)
2602{
2603  xReadUvlc( ruiVal );
2604}
2605
2606Void TDecCavlc::parseAlfSvlc (Int&  riVal)
2607{
2608  xReadSvlc( riVal );
2609}
2610
2611
2612
2613#if MTK_SAO
2614Void TDecCavlc::parseAoFlag (UInt& ruiVal)
2615{
2616  xReadFlag( ruiVal );
2617}
2618Void TDecCavlc::parseAoUvlc (UInt& ruiVal)
2619{
2620  xReadUvlc( ruiVal );
2621}
2622
2623Void TDecCavlc::parseAoSvlc (Int&  riVal)
2624{
2625  xReadSvlc( riVal );
2626}
2627#endif
2628
2629Void TDecCavlc::parseMergeFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx )
2630{
2631#if QC_LCEC_INTER_MODE
2632  if (pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N )
2633    return;
2634#endif
2635  UInt uiSymbol;
2636  xReadFlag( uiSymbol );
2637  pcCU->setMergeFlagSubParts( uiSymbol ? true : false, uiAbsPartIdx, uiPUIdx, uiDepth );
2638}
2639
2640
2641#if HHI_INTER_VIEW_MOTION_PRED || HHI_MPI
2642Void
2643TDecCavlc::parseMergeIndexMV( TComDataCU* pcCU, UInt& ruiMergeIndex, UInt uiAbsPartIdx, UInt uiDepth )
2644{
2645  UInt  uiNumCand = 0;
2646#if HHI_MPI
2647  const Bool bMVIAvailable = pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE;
2648  const UInt uiMviMergePos = bMVIAvailable ? HHI_MPI_MERGE_POS : MRG_MAX_NUM_CANDS;
2649  if( bMVIAvailable )
2650    uiNumCand++;
2651#endif
2652  for( UInt uiIdx = 0; uiIdx < MRG_MAX_NUM_CANDS; uiIdx++ )
2653  {
2654    if( pcCU->getNeighbourCandIdx( uiIdx, uiAbsPartIdx ) == uiIdx + 1 )
2655    {
2656      uiNumCand++;
2657    }
2658  }
2659  AOF( uiNumCand > 1 );
2660  UInt uiUnaryIdx = 0;
2661  for( ; uiUnaryIdx < uiNumCand - 1; uiUnaryIdx++ )
2662  {
2663    UInt uiSymbol = 0;
2664    xReadFlag( uiSymbol );
2665    if( uiSymbol == 0 )
2666    {
2667      break;
2668    }
2669  }
2670  ruiMergeIndex = uiUnaryIdx;
2671  for( UInt uiIdx = 0; uiIdx <= ruiMergeIndex; uiIdx++ )
2672  {
2673#if HHI_MPI
2674    if( uiIdx > uiMviMergePos )
2675    {
2676      if( pcCU->getNeighbourCandIdx( uiIdx - 1, uiAbsPartIdx ) != uiIdx )
2677      {
2678        ruiMergeIndex++;
2679      }
2680    }
2681    else if( uiIdx < uiMviMergePos )
2682#endif
2683    if( pcCU->getNeighbourCandIdx( uiIdx, uiAbsPartIdx ) != uiIdx + 1 )
2684    {
2685      ruiMergeIndex++;
2686    }
2687  }
2688#if HHI_MPI
2689  if( ruiMergeIndex > uiMviMergePos )
2690  {
2691    ruiMergeIndex--;
2692  }
2693  else if( ruiMergeIndex == uiMviMergePos )
2694  {
2695    pcCU->setTextureModeDepthSubParts( uiDepth, uiAbsPartIdx, uiDepth );
2696  }
2697#endif
2698}
2699#endif
2700
2701
2702/** parse merge index
2703 * \param pcCU
2704 * \param ruiMergeIndex
2705 * \param uiAbsPartIdx
2706 * \param uiDepth
2707 * \returns Void
2708 */
2709Void TDecCavlc::parseMergeIndex ( TComDataCU* pcCU, UInt& ruiMergeIndex, UInt uiAbsPartIdx, UInt uiDepth )
2710{
2711#if HHI_INTER_VIEW_MOTION_PRED || HHI_MPI
2712  if(
2713#if HHI_INTER_VIEW_MOTION_PRED
2714      ( pcCU->getSlice()->getSPS()->getViewId() > 0 && ( pcCU->getSlice()->getSPS()->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) == PDM_USE_FOR_MERGE ) ||
2715#endif
2716#if HHI_MPI
2717      ( pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N ) ||
2718#endif
2719      0
2720    )
2721  {
2722    parseMergeIndexMV( pcCU, ruiMergeIndex, uiAbsPartIdx, uiDepth );
2723    return;
2724  }
2725#endif
2726
2727  Bool bLeftInvolved = false;
2728  Bool bAboveInvolved = false;
2729  Bool bCollocatedInvolved = false;
2730  Bool bCornerInvolved = false;
2731  UInt uiNumCand = 0;
2732  for( UInt uiIter = 0; uiIter < MRG_MAX_NUM_CANDS; ++uiIter )
2733  {
2734    if( pcCU->getNeighbourCandIdx( uiIter, uiAbsPartIdx ) == uiIter + 1 )
2735    {
2736      uiNumCand++;
2737      if( uiIter == 0 )
2738      {
2739        bLeftInvolved = true;
2740      }
2741      else if( uiIter == 1 )
2742      {
2743        bAboveInvolved = true;
2744      }
2745      else if( uiIter == 2 )
2746      {
2747        bCollocatedInvolved = true;
2748      }
2749      else if( uiIter == 3 )
2750      {
2751        bCornerInvolved = true;
2752      }
2753    }
2754  }
2755  assert( uiNumCand > 1 );
2756  UInt uiUnaryIdx = 0;
2757  for( ; uiUnaryIdx < uiNumCand - 1; ++uiUnaryIdx )
2758  {
2759    UInt uiSymbol = 0;
2760    xReadFlag( uiSymbol );
2761    if( uiSymbol == 0 )
2762    {
2763      break;
2764    }
2765  }
2766  if( !bLeftInvolved )
2767  {
2768    ++uiUnaryIdx;
2769  }
2770  if( !bAboveInvolved && uiUnaryIdx >= 1 )
2771  {
2772    ++uiUnaryIdx;
2773  }
2774  if( !bCollocatedInvolved && uiUnaryIdx >= 2 )
2775  {
2776    ++uiUnaryIdx;
2777  }
2778  if( !bCornerInvolved && uiUnaryIdx >= 3 )
2779  {
2780    ++uiUnaryIdx;
2781  }
2782  ruiMergeIndex = uiUnaryIdx;
2783}
2784
2785
2786Void
2787TDecCavlc::parseResPredFlag( TComDataCU* pcCU, Bool& rbResPredFlag, UInt uiAbsPartIdx, UInt uiDepth )
2788{
2789  UInt uiSymbol = 0;
2790  xReadFlag( uiSymbol );
2791  rbResPredFlag = ( uiSymbol != 0 );
2792}
2793
2794
2795// ====================================================================================================================
2796// Protected member functions
2797// ====================================================================================================================
2798
2799Void TDecCavlc::xReadCode (UInt uiLength, UInt& ruiCode)
2800{
2801  assert ( uiLength > 0 );
2802  m_pcBitstream->read (uiLength, ruiCode);
2803}
2804
2805Void TDecCavlc::xReadUvlc( UInt& ruiVal)
2806{
2807  UInt uiVal = 0;
2808  UInt uiCode = 0;
2809  UInt uiLength;
2810  m_pcBitstream->read( 1, uiCode );
2811
2812  if( 0 == uiCode )
2813  {
2814    uiLength = 0;
2815
2816    while( ! ( uiCode & 1 ))
2817    {
2818      m_pcBitstream->read( 1, uiCode );
2819      uiLength++;
2820    }
2821
2822    m_pcBitstream->read( uiLength, uiVal );
2823
2824    uiVal += (1 << uiLength)-1;
2825  }
2826
2827  ruiVal = uiVal;
2828}
2829
2830Void TDecCavlc::xReadSvlc( Int& riVal)
2831{
2832  UInt uiBits = 0;
2833  m_pcBitstream->read( 1, uiBits );
2834  if( 0 == uiBits )
2835  {
2836    UInt uiLength = 0;
2837
2838    while( ! ( uiBits & 1 ))
2839    {
2840      m_pcBitstream->read( 1, uiBits );
2841      uiLength++;
2842    }
2843
2844    m_pcBitstream->read( uiLength, uiBits );
2845
2846    uiBits += (1 << uiLength);
2847    riVal = ( uiBits & 1) ? -(Int)(uiBits>>1) : (Int)(uiBits>>1);
2848  }
2849  else
2850  {
2851    riVal = 0;
2852  }
2853}
2854
2855Void TDecCavlc::xReadFlag (UInt& ruiCode)
2856{
2857  m_pcBitstream->read( 1, ruiCode );
2858}
2859
2860Void TDecCavlc::xReadUnaryMaxSymbol( UInt& ruiSymbol, UInt uiMaxSymbol )
2861{
2862  if (uiMaxSymbol == 0)
2863  {
2864    ruiSymbol = 0;
2865    return;
2866  }
2867
2868  xReadFlag( ruiSymbol );
2869
2870  if (ruiSymbol == 0 || uiMaxSymbol == 1)
2871  {
2872    return;
2873  }
2874
2875  UInt uiSymbol = 0;
2876  UInt uiCont;
2877
2878  do
2879  {
2880    xReadFlag( uiCont );
2881    uiSymbol++;
2882  }
2883  while( uiCont && (uiSymbol < uiMaxSymbol-1) );
2884
2885  if( uiCont && (uiSymbol == uiMaxSymbol-1) )
2886  {
2887    uiSymbol++;
2888  }
2889
2890  ruiSymbol = uiSymbol;
2891}
2892
2893Void TDecCavlc::xReadExGolombLevel( UInt& ruiSymbol )
2894{
2895  UInt uiSymbol ;
2896  UInt uiCount = 0;
2897  do
2898  {
2899    xReadFlag( uiSymbol );
2900    uiCount++;
2901  }
2902  while( uiSymbol && (uiCount != 13));
2903
2904  ruiSymbol = uiCount-1;
2905
2906  if( uiSymbol )
2907  {
2908    xReadEpExGolomb( uiSymbol, 0 );
2909    ruiSymbol += uiSymbol+1;
2910  }
2911
2912  return;
2913}
2914
2915Void TDecCavlc::xReadEpExGolomb( UInt& ruiSymbol, UInt uiCount )
2916{
2917  UInt uiSymbol = 0;
2918  UInt uiBit = 1;
2919
2920
2921  while( uiBit )
2922  {
2923    xReadFlag( uiBit );
2924    uiSymbol += uiBit << uiCount++;
2925  }
2926
2927  uiCount--;
2928  while( uiCount-- )
2929  {
2930    xReadFlag( uiBit );
2931    uiSymbol += uiBit << uiCount;
2932  }
2933
2934  ruiSymbol = uiSymbol;
2935
2936  return;
2937}
2938
2939UInt TDecCavlc::xGetBit()
2940{
2941  UInt ruiCode;
2942  m_pcBitstream->read( 1, ruiCode );
2943  return ruiCode;
2944}
2945
2946Int TDecCavlc::xReadVlc( Int n )
2947{
2948#if CAVLC_COEF_LRG_BLK
2949  assert( n>=0 && n<=13 );
2950#else
2951  assert( n>=0 && n<=11 );
2952#endif
2953
2954  UInt zeroes=0, done=0, tmp;
2955  UInt cw, bit;
2956  UInt val = 0;
2957  UInt first;
2958  UInt lead = 0;
2959
2960  if (n < 5)
2961  {
2962    while (!done && zeroes < 6)
2963    {
2964      xReadFlag( bit );
2965      if (bit)
2966      {
2967        if (n)
2968        {
2969          xReadCode( n, cw );
2970        }
2971        else
2972        {
2973          cw = 0;
2974        }
2975        done = 1;
2976      }
2977      else
2978      {
2979        zeroes++;
2980      }
2981    }
2982    if ( done )
2983    {
2984      val = (zeroes<<n)+cw;
2985    }
2986    else
2987    {
2988      lead = n;
2989      while (!done)
2990      {
2991        xReadFlag( first );
2992        if ( !first )
2993        {
2994          lead++;
2995        }
2996        else
2997        {
2998          if ( lead )
2999          {
3000            xReadCode( lead, tmp );
3001          }
3002          else
3003          {
3004            tmp = 0;
3005          }
3006          val = 6 * (1 << n) + (1 << lead) + tmp - (1 << n);
3007          done = 1;
3008        }
3009      }
3010    }
3011  }
3012  else if (n < 8)
3013  {
3014    while (!done)
3015    {
3016      xReadFlag( bit );
3017      if ( bit )
3018      {
3019        xReadCode( n-4, cw );
3020        done = 1;
3021      }
3022      else
3023      {
3024        zeroes++;
3025      }
3026    }
3027    val = (zeroes<<(n-4))+cw;
3028  }
3029  else if (n == 8)
3030  {
3031    if ( xGetBit() )
3032    {
3033      val = 0;
3034    }
3035    else if ( xGetBit() )
3036    {
3037      val = 1;
3038    }
3039    else
3040    {
3041      val = 2;
3042    }
3043  }
3044  else if (n == 9)
3045  {
3046    if ( xGetBit() )
3047    {
3048      if ( xGetBit() )
3049      {
3050        xReadCode(3, val);
3051        val += 3;
3052      }
3053      else if ( xGetBit() )
3054      {
3055        val = xGetBit() + 1;
3056      }
3057      else
3058      {
3059        val = 0;
3060      }
3061    }
3062    else
3063    {
3064      while (!done)
3065      {
3066        xReadFlag( bit );
3067        if ( bit )
3068        {
3069          xReadCode(4, cw);
3070          done = 1;
3071        }
3072        else
3073        {
3074          zeroes++;
3075        }
3076      }
3077      val = (zeroes<<4)+cw+11;
3078    }
3079  }
3080  else if (n == 10)
3081  {
3082    while (!done)
3083    {
3084      xReadFlag( first );
3085      if ( !first )
3086      {
3087        lead++;
3088      }
3089      else
3090      {
3091        if ( !lead )
3092        {
3093          val = 0;
3094        }
3095        else
3096        {
3097          xReadCode(lead, val);
3098          val += (1<<lead);
3099          val--;
3100        }
3101        done = 1;
3102      }
3103    }
3104  }
3105  else if (n == 11)
3106  {
3107    UInt code;
3108    xReadCode(3, val);
3109    if(val)
3110    {
3111      xReadCode(1, code);
3112      val = (val<<1)|code;
3113      val--;
3114    }
3115  }
3116#if CAVLC_COEF_LRG_BLK
3117  else if (n == 12)
3118  {
3119    while (!done)
3120    {
3121      m_pcBitstream->pseudoRead(32,val);
3122      if (val)
3123      {
3124        tmp = 31;
3125        while(!done)
3126        {
3127          if( val>>tmp )
3128          {
3129            xReadCode(32-tmp, val);
3130            lead += 31-tmp;
3131            xReadCode(6, val);
3132            val += (lead<<6);
3133            done = 1;
3134          }
3135          tmp--;
3136        }
3137      }
3138      else
3139      {
3140        xReadCode(32, val);
3141        lead += 32;
3142      }
3143    }
3144  }
3145  else if (n == 13)
3146  {
3147    while (!done)
3148    {
3149      m_pcBitstream->pseudoRead(32,val);
3150      if (val)
3151      {
3152        tmp = 31;
3153        while(!done)
3154        {
3155          if(val>>tmp)
3156          {
3157            xReadCode(32-tmp, cw);
3158            zeroes += 31-tmp;
3159            xReadCode(4, cw);
3160            done = 1;
3161          }
3162          tmp--;
3163        }
3164      }
3165      else
3166      {
3167        xReadCode(32, val);
3168        zeroes += 32;
3169      }
3170    }
3171    val = (zeroes<<4)+cw;
3172  }
3173#endif
3174
3175  return val;
3176}
3177
3178#if !CAVLC_COEF_LRG_BLK
3179Void TDecCavlc::xParseCoeff4x4( TCoeff* scoeff, Int n )
3180{
3181  Int i;
3182  UInt sign;
3183  Int tmp;
3184  Int vlc,cn,this_pos;
3185  Int maxrun;
3186  Int last_position;
3187  Int atable[5] = {4,6,14,28,0xfffffff};
3188  Int vlc_adaptive=0;
3189  Int done;
3190  LastCoeffStruct combo;
3191
3192#if QC_MOD_LCEC
3193  Int nTab;
3194  Int tr1;
3195  nTab=max(0,n-2);
3196#endif
3197
3198  for (i = 0; i < 16; i++)
3199  {
3200    scoeff[i] = 0;
3201  }
3202
3203  {
3204    /* Get the last nonzero coeff */
3205    Int x,y,cx,cy,vlcNum;
3206    Int vlcTable[8] = {2,2,2};
3207
3208    /* Decode according to current LP table */
3209#if QC_MOD_LCEC
3210    vlcNum = vlcTable[nTab];
3211    tmp = xReadVlc( vlcNum );
3212    cn = m_uiLPTableD4[nTab][tmp];
3213#else
3214    vlcNum = vlcTable[n];
3215
3216    tmp = xReadVlc( vlcNum );
3217    cn = m_uiLPTableD4[n][tmp];
3218#endif
3219    combo.level = (cn>15);
3220    combo.last_pos = cn&0x0f;
3221
3222    /* Adapt LP table */
3223    cx = tmp;
3224    cy = Max( 0, cx-1 );
3225    x = cn;
3226#if QC_MOD_LCEC
3227    y = m_uiLPTableD4[nTab][cy];
3228    m_uiLPTableD4[nTab][cy] = x;
3229    m_uiLPTableD4[nTab][cx] = y;
3230#else
3231    y = m_uiLPTableD4[n][cy];
3232    m_uiLPTableD4[n][cy] = x;
3233    m_uiLPTableD4[n][cx] = y;
3234#endif
3235  }
3236
3237  if ( combo.level == 1 )
3238  {
3239    tmp = xReadVlc( 0 );
3240    sign = tmp&1;
3241    tmp = (tmp>>1)+2;
3242  }
3243  else
3244  {
3245    tmp = 1;
3246    xReadFlag( sign );
3247  }
3248
3249#if QC_MOD_LCEC
3250  if (tmp>1)
3251  {
3252    tr1=0;
3253  }
3254  else
3255  {
3256    tr1=1;
3257  }
3258#endif
3259
3260  if ( sign )
3261  {
3262    tmp = -tmp;
3263  }
3264
3265  last_position = combo.last_pos;
3266  this_pos = 15 - last_position;
3267  scoeff[this_pos] = tmp;
3268  i = this_pos;
3269  i++;
3270
3271  done = 0;
3272  {
3273    while (!done && i < 16)
3274    {
3275      maxrun = 15-i;
3276#if QC_MOD_LCEC
3277      if(n==2)
3278        vlc = g_auiVlcTable8x8Intra[maxrun];
3279      else
3280        vlc = g_auiVlcTable8x8Inter[maxrun];
3281#else
3282      if (maxrun > 27)
3283      {
3284        maxrun = 28;
3285        vlc = 3;
3286      }
3287      else
3288      {
3289        vlc = g_auiVlcTable8x8[maxrun];
3290      }
3291#endif
3292
3293      /* Go into run mode */
3294      cn = xReadVlc( vlc );
3295#if QC_MOD_LCEC
3296      if(n==2)
3297      {
3298        xRunLevelIndInv(&combo, maxrun, g_auiLumaRunTr14x4[tr1][maxrun], cn);
3299      }
3300      else
3301#endif
3302      {
3303#if RUNLEVEL_TABLE_CUT
3304        xRunLevelIndInterInv(&combo, maxrun, cn);
3305#else
3306        combo = g_acstructLumaRun8x8[maxrun][cn];
3307#endif
3308      }
3309      i += combo.last_pos;
3310      /* No sign for last zeroes */
3311      if (i < 16)
3312      {
3313        if (combo.level == 1)
3314        {
3315          tmp = xReadVlc( 0 );
3316          sign = tmp&1;
3317          tmp = (tmp>>1)+2;
3318          done = 1;
3319        }
3320        else
3321        {
3322          tmp = 1;
3323          xReadFlag( sign );
3324        }
3325        if ( sign )
3326        {
3327          tmp = -tmp;
3328        }
3329        scoeff[i] = tmp;
3330      }
3331      i++;
3332#if QC_MOD_LCEC
3333      if (tr1>0 && tr1<MAX_TR1)
3334      {
3335        tr1++;
3336      }
3337#endif
3338    }
3339  }
3340  if (i < 16)
3341  {
3342    /* Get the rest in level mode */
3343    while ( i < 16 )
3344    {
3345      tmp = xReadVlc( vlc_adaptive );
3346      if ( tmp > atable[vlc_adaptive] )
3347      {
3348        vlc_adaptive++;
3349      }
3350      if ( tmp )
3351      {
3352        xReadFlag( sign );
3353        if ( sign )
3354        {
3355          tmp = -tmp;
3356        }
3357      }
3358      scoeff[i] = tmp;
3359      i++;
3360    }
3361  }
3362
3363  return;
3364}
3365#endif
3366
3367#if QC_MOD_LCEC
3368
3369Void TDecCavlc::xRunLevelIndInv(LastCoeffStruct *combo, Int maxrun, UInt lrg1Pos, UInt cn)
3370{
3371  int lev, run;
3372  if (lrg1Pos>0)
3373  {
3374    if(cn < min(lrg1Pos, maxrun+2))
3375    {
3376      lev = 0;
3377      run = cn;
3378    }
3379    else if(cn < (maxrun<<1) + 4 - (Int)lrg1Pos)
3380    {
3381      if((cn+lrg1Pos)&1)
3382      {
3383        lev = 0;
3384        run = (cn + lrg1Pos - 1) >> 1;
3385      }
3386      else
3387      {
3388        lev = 1;
3389        run = (cn - lrg1Pos)>>1;
3390      }
3391    }
3392    else
3393    {
3394      lev = 1;
3395      run = cn - maxrun - 2;
3396    }
3397  }
3398  else
3399  {
3400    if( cn & 1 )
3401    {
3402      lev = 0; run = (cn-1)>>1;
3403    }
3404    else
3405    {
3406      run = cn >> 1;
3407      lev = (run <= maxrun)?1:0;
3408    }
3409  }
3410  combo->level = lev;
3411  combo->last_pos = run;
3412}
3413
3414#if RUNLEVEL_TABLE_CUT
3415/** Function for deriving run and level value in CAVLC run-level coding
3416 * \param combo pointer to a struct of run and level
3417 * \param maxrun maximum length of run for a given coefficient location
3418 * \param cn codeword index
3419 * \returns
3420 * This function derives run and level value in CAVLC run-level coding based on codeword index and maximum run value.
3421 */
3422Void TDecCavlc::xRunLevelIndInterInv(LastCoeffStruct *combo, Int maxrun, UInt cn)
3423{
3424  if (maxrun<28)
3425  {
3426    if(cn > maxrun+1)
3427    {
3428      combo->level = 1;
3429      combo->last_pos = g_acstructLumaRun8x8[maxrun][cn-maxrun-1];
3430    }
3431    else
3432    {
3433      combo->level = 0;
3434      combo->last_pos = g_acstructLumaRun8x8[maxrun][cn];
3435    }
3436  }
3437  else
3438  {
3439    if(cn<maxrun+2)
3440    {
3441      combo->level = 0;
3442      combo->last_pos = cn;
3443    }
3444    else
3445    {
3446      combo->level = 1;
3447      combo->last_pos = cn-maxrun-2;
3448    }
3449  }
3450}
3451#endif
3452#endif
3453
3454
3455#if !CAVLC_COEF_LRG_BLK
3456Void TDecCavlc::xParseCoeff8x8(TCoeff* scoeff, int n)
3457{
3458  Int i;
3459  UInt sign;
3460  Int tmp;
3461  LastCoeffStruct combo;
3462  Int vlc,cn,this_pos;
3463  Int maxrun;
3464  Int last_position;
3465  Int atable[5] = {4,6,14,28,0xfffffff};
3466  Int vlc_adaptive=0;
3467  Int done;
3468#if QC_MOD_LCEC
3469  Int tr1;
3470#endif
3471
3472  static const Int switch_thr[10] = {49,49,0,49,49,0,49,49,49,49};
3473  Int sum_big_coef = 0;
3474
3475  for (i = 0; i < 64; i++)
3476  {
3477    scoeff[i] = 0;
3478  }
3479
3480  /* Get the last nonzero coeff */
3481  {
3482    Int x,y,cx,cy,vlcNum;
3483
3484    /* Decode according to current LP table */
3485    // ADAPT_VLC_NUM
3486    vlcNum = g_auiLastPosVlcNum[n][Min(16,m_uiLastPosVlcIndex[n])];
3487    tmp = xReadVlc( vlcNum );
3488    cn = m_uiLPTableD8[n][tmp];
3489    combo.level = (cn>63);
3490    combo.last_pos = cn&0x3f;
3491
3492    /* Adapt LP table */
3493    cx = tmp;
3494    cy = Max(0,cx-1);
3495    x = cn;
3496    y = m_uiLPTableD8[n][cy];
3497    m_uiLPTableD8[n][cy] = x;
3498    m_uiLPTableD8[n][cx] = y;
3499
3500    // ADAPT_VLC_NUM
3501    m_uiLastPosVlcIndex[n] += cx == m_uiLastPosVlcIndex[n] ? 0 : (cx < m_uiLastPosVlcIndex[n] ? -1 : 1);
3502  }
3503
3504  if (combo.level == 1)
3505  {
3506    tmp = xReadVlc( 0 );
3507    sign = tmp&1;
3508    tmp = (tmp>>1)+2;
3509  }
3510  else
3511  {
3512    tmp = 1;
3513    xReadFlag( sign );
3514  }
3515
3516#if QC_MOD_LCEC
3517  if (tmp>1)
3518  {
3519    tr1=0;
3520  }
3521  else
3522  {
3523    tr1=1;
3524  }
3525#endif
3526
3527  if ( sign )
3528  {
3529    tmp = -tmp;
3530  }
3531
3532  last_position = combo.last_pos;
3533  this_pos = 63 - last_position;
3534  scoeff[this_pos] = tmp;
3535  i = this_pos;
3536  i++;
3537
3538  done = 0;
3539  {
3540    while (!done && i < 64)
3541    {
3542      maxrun = 63-i;
3543#if QC_MOD_LCEC
3544      if (n == 2 || n == 5)
3545        vlc = g_auiVlcTable8x8Intra[Min(maxrun,28)];
3546      else
3547        vlc = g_auiVlcTable8x8Inter[Min(maxrun,28)];
3548#else
3549      if (maxrun > 27)
3550      {
3551        maxrun = 28;
3552        vlc = 3;
3553      }
3554      else
3555      {
3556        vlc = g_auiVlcTable8x8[maxrun];
3557      }
3558#endif
3559
3560      /* Go into run mode */
3561      cn = xReadVlc( vlc );
3562#if QC_MOD_LCEC
3563      if (n == 2 || n == 5)
3564        xRunLevelIndInv(&combo, maxrun, g_auiLumaRunTr18x8[tr1][min(maxrun,28)], cn);
3565      else
3566#if RUNLEVEL_TABLE_CUT
3567        xRunLevelIndInterInv(&combo, maxrun, cn);
3568#else
3569        combo = g_acstructLumaRun8x8[Min(maxrun,28)][cn];
3570#endif
3571#else
3572      combo = g_acstructLumaRun8x8[maxrun][cn];
3573#endif
3574      i += combo.last_pos;
3575      /* No sign for last zeroes */
3576      if (i < 64)
3577      {
3578        if (combo.level == 1)
3579        {
3580          tmp = xReadVlc( 0 );
3581          sign = tmp&1;
3582          tmp = (tmp>>1)+2;
3583
3584          sum_big_coef += tmp;
3585          if (i > switch_thr[n] || sum_big_coef > 2)
3586          {
3587            done = 1;
3588          }
3589        }
3590        else
3591        {
3592          tmp = 1;
3593          xReadFlag( sign );
3594        }
3595        if ( sign )
3596        {
3597          tmp = -tmp;
3598        }
3599        scoeff[i] = tmp;
3600      }
3601      i++;
3602#if QC_MOD_LCEC
3603      if (tr1==0 || combo.level != 0)
3604      {
3605        tr1=0;
3606      }
3607      else if( tr1 < MAX_TR1)
3608      {
3609        tr1++;
3610      }
3611#endif
3612    }
3613  }
3614  if (i < 64)
3615  {
3616    /* Get the rest in level mode */
3617    while (i<64)
3618    {
3619      tmp = xReadVlc( vlc_adaptive );
3620
3621      if (tmp>atable[vlc_adaptive])
3622      {
3623        vlc_adaptive++;
3624      }
3625      if (tmp)
3626      {
3627        xReadFlag( sign );
3628        if ( sign )
3629        {
3630          tmp = -tmp;
3631        }
3632      }
3633      scoeff[i] = tmp;
3634      i++;
3635    }
3636  }
3637  return;
3638}
3639#endif
3640
3641
3642#if CAVLC_COEF_LRG_BLK
3643/** Function for parsing a block of transform coeffcients in CAVLC.
3644 * \param scoeff pointer to transform coefficient buffer
3645 * \param n block type information, e.g. luma, chroma, intra, inter, etc.
3646 * \param blSize block size
3647 * \returns
3648 * This function performs parsing for a block of transform coefficient in CAVLC.
3649 */
3650Void TDecCavlc::xParseCoeff(TCoeff* scoeff, int n, Int blSize)
3651{
3652  static const Int switch_thr[10] = {49,49,0,49,49,0,49,49,49,49};
3653  Int i, noCoeff=blSize*blSize;;
3654  UInt sign;
3655  LastCoeffStruct combo;
3656  Int cn, maxrun, tmprun;
3657  Int atable[5] = {4,6,14,28,0xfffffff};
3658  Int done, tr1, tmp;
3659  Int sum_big_coef = 0;
3660
3661  memset(scoeff,0,sizeof(TCoeff)*noCoeff);
3662
3663  /* Get the last nonzero coeff */
3664  if(blSize >=8 )
3665  {
3666    /* Decode according to current LP table */
3667    // ADAPT_VLC_NUM
3668    tmp = g_auiLastPosVlcNum[n][Min(16,m_uiLastPosVlcIndex[n])];
3669    cn = xReadVlc( tmp );
3670    xLastLevelIndInv(combo.level, combo.last_pos, blSize, cn);
3671
3672    /* Adapt LP table */
3673    cn = (blSize==8)?cn:(cn>>2);
3674    // ADAPT_VLC_NUM
3675    m_uiLastPosVlcIndex[n] += cn == m_uiLastPosVlcIndex[n] ? 0 : (cn < m_uiLastPosVlcIndex[n] ? -1 : 1);
3676  }
3677  else
3678  {
3679    /* Get the last nonzero coeff */
3680    Int y,cy;
3681    Int nTab = max(0,n-2);
3682
3683    /* Decode according to current LP table */
3684    tmp = xReadVlc( 2 );
3685    cn = m_uiLPTableD4[nTab][tmp];
3686    combo.level = (cn>15)?1:0;
3687    combo.last_pos = cn&0x0f;
3688
3689    /* Adapt LP table */
3690    cy = Max( 0, tmp-1 );
3691    y = m_uiLPTableD4[nTab][cy];
3692    m_uiLPTableD4[nTab][cy] = cn;
3693    m_uiLPTableD4[nTab][tmp] = y;
3694  }
3695
3696  if (combo.level == 1)
3697  {
3698    tmp = xReadVlc( 0 );
3699    sign = tmp&1;
3700    tmp = (tmp>>1)+2;
3701    tr1=0;
3702  }
3703  else
3704  {
3705    tmp = 1;
3706    xReadFlag( sign );
3707    tr1=1;
3708  }
3709
3710  i = noCoeff - 1 - combo.last_pos;
3711  scoeff[i++] = sign? -tmp:tmp;
3712
3713  done = 0;
3714  const UInt *vlcTable = (n == 2||n == 5)? ((blSize<=8)? g_auiVlcTable8x8Intra:g_auiVlcTable16x16Intra):
3715    ((blSize<=8)? g_auiVlcTable8x8Inter:g_auiVlcTable16x16Inter);
3716  const UInt **pLumaRunTr1 = (blSize==4)? g_pLumaRunTr14x4:g_pLumaRunTr18x8;
3717  while (!done && i < noCoeff)
3718  {
3719    maxrun = noCoeff - 1 -i;
3720    tmprun = min(maxrun,28);
3721    tmp = vlcTable[tmprun];
3722
3723    /* Go into run mode */
3724    cn = xReadVlc( tmp );
3725    if (n == 2 || n == 5)
3726    {
3727      xRunLevelIndInv(&combo, maxrun, pLumaRunTr1[tr1][tmprun], cn);
3728    }
3729    else
3730    {
3731      xRunLevelIndInterInv(&combo, maxrun, cn);
3732    }
3733
3734    i += combo.last_pos;
3735    if (i < noCoeff)
3736    {
3737      if (combo.level == 1)
3738      {
3739        tmp = xReadVlc( 0 );
3740        sign = tmp&1;
3741        tmp = (tmp>>1)+2;
3742
3743        sum_big_coef += tmp;
3744        if (blSize==4 ||i > switch_thr[n] || sum_big_coef > 2)
3745        {
3746          done = 1;
3747        }
3748      }
3749      else
3750      {
3751        tmp = 1;
3752        xReadFlag( sign );
3753      }
3754      scoeff[i++] = sign? -tmp:tmp;
3755    }
3756
3757    if (tr1==0 || combo.level != 0)
3758    {
3759      tr1=0;
3760    }
3761    else if( tr1 < MAX_TR1)
3762    {
3763      tr1++;
3764    }
3765  }
3766
3767  if (i < noCoeff)
3768  {
3769    /* Get the rest in level mode */
3770    Int vlc_adaptive = 0;
3771    while (i < noCoeff)
3772    {
3773      tmp = xReadVlc( vlc_adaptive );
3774
3775      if (tmp)
3776      {
3777        xReadFlag( sign );
3778        scoeff[i] = sign?-tmp:tmp;
3779        if (tmp > atable[vlc_adaptive])
3780        {
3781          vlc_adaptive++;
3782        }
3783      }
3784      i++;
3785    }
3786  }
3787
3788  return;
3789}
3790
3791#endif
3792
3793#ifdef WEIGHT_PRED
3794Void TDecCavlc::parseWeightPredTable( TComSlice* pcSlice )
3795{
3796  wpScalingParam  *wp;
3797  Bool            bChroma     = true; // color always present in HEVC ?
3798  TComPPS*        pps         = pcSlice->getPPS();
3799  SliceType       eSliceType  = pcSlice->getSliceType();
3800  Int             nbRef       = (eSliceType == B_SLICE ) ? (2) : (1);
3801  UInt            uiLog2WeightDenomLuma, uiLog2WeightDenomChroma;
3802  UInt            uiMode      = 0;
3803
3804  if ( (eSliceType==P_SLICE && pps->getUseWP()) || (eSliceType==B_SLICE && pps->getWPBiPredIdc()==1) )
3805    uiMode = 1;
3806  else if ( eSliceType==B_SLICE && pps->getWPBiPredIdc()==2 )
3807    uiMode = 2;
3808
3809  if ( uiMode == 1 )  // explicit
3810  {
3811    printf("\nTDecCavlc::parseWeightPredTable(poc=%d) explicit...\n", pcSlice->getPOC());
3812
3813    // decode luma_log2_weight_denom :
3814    xReadUvlc( uiLog2WeightDenomLuma );     // ue(v): luma_log2_weight_denom
3815    if( bChroma ) {                         // color always present in HEVC ?
3816      xReadUvlc( uiLog2WeightDenomChroma ); // ue(v): chroma_log2_weight_denom
3817    }
3818
3819    for ( Int numRef=0 ; numRef<nbRef ; numRef++ ) {
3820      RefPicList  eRefPicList = ( numRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
3821      for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ ) {
3822        pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
3823
3824        wp[0].uiLog2WeightDenom = uiLog2WeightDenomLuma;
3825        wp[1].uiLog2WeightDenom = uiLog2WeightDenomChroma;
3826        wp[2].uiLog2WeightDenom = uiLog2WeightDenomChroma;
3827
3828        UInt  uiCode;
3829        xReadFlag( uiCode );           // u(1): luma_weight_l0_flag
3830        wp[0].bPresentFlag = ( uiCode == 1 );
3831        if ( wp[0].bPresentFlag ) {
3832          xReadSvlc( wp[0].iWeight ); // se(v): luma_weight_l0[i]
3833          xReadSvlc( wp[0].iOffset ); // se(v): luma_offset_l0[i]
3834        }
3835        else {
3836          wp[0].iWeight = (1 << wp[0].uiLog2WeightDenom);
3837          wp[0].iOffset = 0;
3838        }
3839        if ( bChroma ) {
3840          xReadFlag( uiCode );           // u(1): chroma_weight_l0_flag
3841          wp[1].bPresentFlag = ( uiCode == 1 );
3842          wp[2].bPresentFlag = ( uiCode == 1 );
3843          if ( wp[1].bPresentFlag ) {
3844            for ( Int j=1 ; j<3 ; j++ ) {
3845              xReadSvlc( wp[j].iWeight ); // se(v): chroma_weight_l0[i][j]
3846              xReadSvlc( wp[j].iOffset ); // se(v): chroma_offset_l0[i][j]
3847            }
3848          }
3849          else {
3850            for ( Int j=1 ; j<3 ; j++ ) {
3851              wp[j].iWeight = (1 << wp[j].uiLog2WeightDenom);
3852              wp[j].iOffset = 0;
3853            }
3854          }
3855        }
3856      }
3857
3858      // Just for displayWpScaling():
3859      for ( Int iRefIdx=pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx<MAX_NUM_REF ; iRefIdx++ ) {
3860        pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
3861
3862        wp[0].bPresentFlag = false;
3863        wp[1].bPresentFlag = false;
3864        wp[2].bPresentFlag = false;
3865      }
3866
3867    }
3868
3869  }
3870  else if ( uiMode == 2 )  // implicit
3871  {
3872    printf("\nTDecCavlc::parseWeightPredTable(poc=%d) implicit...\n", pcSlice->getPOC());
3873  }
3874  else
3875    assert(0);
3876}
3877#endif
Note: See TracBrowser for help on using the repository browser.