source: 3DVCSoftware/branches/0.2-poznan-univ/source/Lib/TLibEncoder/TEncCavlc.cpp @ 11

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

Poznan disocclusion coding - CU Skip

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