Context navigation

source: 3DVCSoftware/branches/0.3-poznan-univ/source/Lib/TLibDecoder/TDecCAVLC.cpp @ 41

Visit:

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

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

Download in other formats: