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

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

Adjustment for FlexCO, and high-level syntax improvement.

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