Context navigation

TEncCavlc.cpp @ 85

Visit:

Last change on this file since 85 was 48, checked in by poznan-univ, 13 years ago
some bug fix on high level syntax fixed some compiler warning issues under windows and linux
Property svn:eol-style set to `native`
File size: 93.4 KB

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

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

JCT-3V 3D-HEVC

Context navigation

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

Download in other formats: