Context navigation

TDecCAVLC.cpp @ 193

Visit:

Last change on this file since 193 was 50, checked in by nokia, 13 years ago
FCO bug-fix to 3DV-HTM version 0.4: decoder crushed with texture-only coding.
Property svn:eol-style set to `native`
File size: 98.3 KB

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/0.3-nokia/source/Lib/TLibDecoder/TDecCAVLC.cpp @ 193

Download in other formats: