Context navigation

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

Visit:

Last change on this file since 41 was 41, checked in by poznan-univ, 13 years ago
Adjustment for FlexCO, and high-level syntax improvement.
Property svn:eol-style set to `native`
File size: 91.6 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: