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

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

Added Ericsson Extraction Tool

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