source: 3DVCSoftware/branches/0.3-poznan-univ/source/Lib/TLibDecoder/TDecCAVLC.cpp @ 48

Last change on this file since 48 was 48, checked in by poznan-univ, 12 years ago

some bug fix on high level syntax
fixed some compiler warning issues under windows and linux

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