source: 3DVCSoftware/trunk/source/Lib/TLibEncoder/TEncCavlc.cpp @ 5

Last change on this file since 5 was 5, checked in by hhi, 12 years ago

Clean version with cfg-files

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