source: 3DVCSoftware/branches/0.3-poznan-univ/source/Lib/TLibEncoder/TEncCavlc.cpp @ 41

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

Adjustment for FlexCO, and high-level syntax improvement.

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