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

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

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

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