Context navigation

TDecCAVLC.cpp @ 1417

Visit:

Last change on this file since 1417 was 254, checked in by mediatek-htm, 12 years ago

Integration of JCT3V-C0137

The added texture merging candidate is controlled by the MACRO "MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137"

From MediaTek
yiwen.chen@…

Property svn:eol-style set to native

File size: 107.5 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-2012, ITU/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 ITU/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	/** \file TDecCAVLC.cpp
35	\brief CAVLC decoder class
36	*/
37
38	#include "TDecCAVLC.h"
39	#include "SEIread.h"
40	#include "TDecSlice.h"
41
42	//! \ingroup TLibDecoder
43	//! \{
44
45	#if ENC_DEC_TRACE
46
47	#define READ_CODE(length, code, name) xReadCodeTr ( length, code, name )
48	#define READ_UVLC( code, name) xReadUvlcTr ( code, name )
49	#define READ_SVLC( code, name) xReadSvlcTr ( code, name )
50	#define READ_FLAG( code, name) xReadFlagTr ( code, name )
51
52	Void xTraceSPSHeader (TComSPS *pSPS)
53	{
54	fprintf( g_hTrace, "=========== Sequence Parameter Set ID: %d ===========\n", pSPS->getSPSId() );
55	}
56
57	Void xTracePPSHeader (TComPPS *pPPS)
58	{
59	fprintf( g_hTrace, "=========== Picture Parameter Set ID: %d ===========\n", pPPS->getPPSId() );
60	}
61
62	Void xTraceAPSHeader (TComAPS *pAPS)
63	{
64	fprintf( g_hTrace, "=========== Adaptation Parameter Set ===========\n");
65	}
66
67	Void xTraceSliceHeader (TComSlice *pSlice)
68	{
69	fprintf( g_hTrace, "=========== Slice ===========\n");
70	}
71
72
73	Void TDecCavlc::xReadCodeTr (UInt length, UInt& rValue, const Char *pSymbolName)
74	{
75	xReadCode (length, rValue);
76	fprintf( g_hTrace, "%8lld ", g_nSymbolCounter++ );
77	fprintf( g_hTrace, "%-40s u(%d) : %d\n", pSymbolName, length, rValue );
78	fflush ( g_hTrace );
79	}
80
81	Void TDecCavlc::xReadUvlcTr (UInt& rValue, const Char *pSymbolName)
82	{
83	xReadUvlc (rValue);
84	fprintf( g_hTrace, "%8lld ", g_nSymbolCounter++ );
85	fprintf( g_hTrace, "%-40s u(v) : %d\n", pSymbolName, rValue );
86	fflush ( g_hTrace );
87	}
88
89	Void TDecCavlc::xReadSvlcTr (Int& rValue, const Char *pSymbolName)
90	{
91	xReadSvlc(rValue);
92	fprintf( g_hTrace, "%8lld ", g_nSymbolCounter++ );
93	fprintf( g_hTrace, "%-40s s(v) : %d\n", pSymbolName, rValue );
94	fflush ( g_hTrace );
95	}
96
97	Void TDecCavlc::xReadFlagTr (UInt& rValue, const Char *pSymbolName)
98	{
99	xReadFlag(rValue);
100	fprintf( g_hTrace, "%8lld ", g_nSymbolCounter++ );
101	fprintf( g_hTrace, "%-40s u(1) : %d\n", pSymbolName, rValue );
102	fflush ( g_hTrace );
103	}
104
105	#else
106
107	#define READ_CODE(length, code, name) xReadCode ( length, code )
108	#define READ_UVLC( code, name) xReadUvlc ( code )
109	#define READ_SVLC( code, name) xReadSvlc ( code )
110	#define READ_FLAG( code, name) xReadFlag ( code )
111
112	#endif
113
114
115
116	// ====================================================================================================================
117	// Constructor / destructor / create / destroy
118	// ====================================================================================================================
119
120	TDecCavlc::TDecCavlc()
121	{
122	m_iSliceGranularity = 0;
123
124	m_aaiTempScale = new Int* [ MAX_VIEW_NUM ];
125	m_aaiTempOffset = new Int* [ MAX_VIEW_NUM ];
126	m_aaiTempPdmScaleNomDelta = new Int* [ MAX_VIEW_NUM ];
127	m_aaiTempPdmOffset = new Int* [ MAX_VIEW_NUM ];
128	for( UInt uiVId = 0; uiVId < MAX_VIEW_NUM; uiVId++ )
129	{
130	m_aaiTempScale [ uiVId ] = new Int [ MAX_VIEW_NUM ];
131	m_aaiTempOffset [ uiVId ] = new Int [ MAX_VIEW_NUM ];
132	m_aaiTempPdmScaleNomDelta [ uiVId ] = new Int [ MAX_VIEW_NUM ];
133	m_aaiTempPdmOffset [ uiVId ] = new Int [ MAX_VIEW_NUM ];
134	}
135	}
136
137	TDecCavlc::~TDecCavlc()
138	{
139	for( UInt uiVId = 0; uiVId < MAX_VIEW_NUM; uiVId++ )
140	{
141	delete [] m_aaiTempScale [ uiVId ];
142	delete [] m_aaiTempOffset [ uiVId ];
143	delete [] m_aaiTempPdmScaleNomDelta [ uiVId ];
144	delete [] m_aaiTempPdmOffset [ uiVId ];
145	}
146	delete [] m_aaiTempScale;
147	delete [] m_aaiTempOffset;
148	delete [] m_aaiTempPdmScaleNomDelta;
149	delete [] m_aaiTempPdmOffset;
150	}
151
152	// ====================================================================================================================
153	// Public member functions
154	// ====================================================================================================================
155
156	/**
157	* unmarshal a sequence of SEI messages from bitstream.
158	*/
159	void TDecCavlc::parseSEI(SEImessages& seis)
160	{
161	assert(!m_pcBitstream->getNumBitsUntilByteAligned());
162	do
163	{
164	parseSEImessage(*m_pcBitstream, seis);
165	/* SEI messages are an integer number of bytes, something has failed
166	* in the parsing if bitstream not byte-aligned */
167	assert(!m_pcBitstream->getNumBitsUntilByteAligned());
168	} while (0x80 != m_pcBitstream->peekBits(8));
169	assert(m_pcBitstream->getNumBitsLeft() == 8); /* rsbp_trailing_bits */
170	}
171	#if RPS_IN_SPS
172	void TDecCavlc::parseShortTermRefPicSet( TComSPS* sps, TComReferencePictureSet* rps, Int idx )
173	#else
174	void TDecCavlc::parseShortTermRefPicSet( TComPPS* pcPPS, TComReferencePictureSet* rps, Int idx )
175	#endif
176	{
177	UInt code;
178	UInt interRPSPred;
179	READ_FLAG(interRPSPred, "inter_ref_pic_set_prediction_flag"); rps->setInterRPSPrediction(interRPSPred);
180	if (interRPSPred)
181	{
182	UInt bit;
183	READ_UVLC(code, "delta_idx_minus1" ); // delta index of the Reference Picture Set used for prediction minus 1
184	Int rIdx = idx - 1 - code;
185	assert (rIdx <= idx && rIdx >= 0);
186	#if RPS_IN_SPS
187	TComReferencePictureSet* rpsRef = sps->getRPSList()->getReferencePictureSet(rIdx);
188	#else
189	TComReferencePictureSet* rpsRef = pcPPS->getRPSList()->getReferencePictureSet(rIdx);
190	#endif
191	Int k = 0, k0 = 0, k1 = 0;
192	READ_CODE(1, bit, "delta_rps_sign"); // delta_RPS_sign
193	READ_UVLC(code, "abs_delta_rps_minus1"); // absolute delta RPS minus 1
194	Int deltaRPS = (1 - (bit<<1)) * (code + 1); // delta_RPS
195	for(Int j=0 ; j <= rpsRef->getNumberOfPictures(); j++)
196	{
197	READ_CODE(1, bit, "used_by_curr_pic_flag" ); //first bit is "1" if Idc is 1
198	Int refIdc = bit;
199	if (refIdc == 0)
200	{
201	READ_CODE(1, bit, "use_delta_flag" ); //second bit is "1" if Idc is 2, "0" otherwise.
202	refIdc = bit<<1; //second bit is "1" if refIdc is 2, "0" if refIdc = 0.
203	}
204	if (refIdc == 1 \|\| refIdc == 2)
205	{
206	Int deltaPOC = deltaRPS + ((j < rpsRef->getNumberOfPictures())? rpsRef->getDeltaPOC(j) : 0);
207	rps->setDeltaPOC(k, deltaPOC);
208	rps->setUsed(k, (refIdc == 1));
209
210	if (deltaPOC < 0) {
211	k0++;
212	}
213	else
214	{
215	k1++;
216	}
217	k++;
218	}
219	rps->setRefIdc(j,refIdc);
220	}
221	rps->setNumRefIdc(rpsRef->getNumberOfPictures()+1);
222	rps->setNumberOfPictures(k);
223	rps->setNumberOfNegativePictures(k0);
224	rps->setNumberOfPositivePictures(k1);
225	rps->sortDeltaPOC();
226	}
227	else
228	{
229	READ_UVLC(code, "num_negative_pics"); rps->setNumberOfNegativePictures(code);
230	READ_UVLC(code, "num_positive_pics"); rps->setNumberOfPositivePictures(code);
231	Int prev = 0;
232	Int poc;
233	for(Int j=0 ; j < rps->getNumberOfNegativePictures(); j++)
234	{
235	READ_UVLC(code, "delta_poc_s0_minus1");
236	poc = prev-code-1;
237	prev = poc;
238	rps->setDeltaPOC(j,poc);
239	READ_FLAG(code, "used_by_curr_pic_s0_flag"); rps->setUsed(j,code);
240	}
241	prev = 0;
242	for(Int j=rps->getNumberOfNegativePictures(); j < rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures(); j++)
243	{
244	READ_UVLC(code, "delta_poc_s1_minus1");
245	poc = prev+code+1;
246	prev = poc;
247	rps->setDeltaPOC(j,poc);
248	READ_FLAG(code, "used_by_curr_pic_s1_flag"); rps->setUsed(j,code);
249	}
250	rps->setNumberOfPictures(rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures());
251	}
252	#if PRINT_RPS_INFO
253	rps->printDeltaPOC();
254	#endif
255	}
256
257	Void TDecCavlc::parseAPS(TComAPS* aps)
258	{
259	#if ENC_DEC_TRACE
260	xTraceAPSHeader(aps);
261	#endif
262
263	UInt uiCode;
264	READ_UVLC(uiCode, "aps_id"); aps->setAPSID(uiCode);
265	READ_FLAG(uiCode, "aps_scaling_list_data_present_flag"); aps->setScalingListEnabled( (uiCode==1)?true:false );
266	READ_FLAG(uiCode, "aps_deblocking_filter_flag"); aps->setLoopFilterOffsetInAPS( (uiCode==1)?true:false );
267	#if !SAO_UNIT_INTERLEAVING
268	READ_FLAG(uiCode, "aps_sample_adaptive_offset_flag"); aps->setSaoEnabled( (uiCode==1)?true:false );
269	#endif
270	#if !LCU_SYNTAX_ALF
271	READ_FLAG(uiCode, "aps_adaptive_loop_filter_flag"); aps->setAlfEnabled( (uiCode==1)?true:false );
272	#endif
273	if(aps->getScalingListEnabled())
274	{
275	parseScalingList( aps->getScalingList() );
276	}
277	#if DBL_CONTROL
278	if(aps->getLoopFilterOffsetInAPS())
279	{
280	xParseDblParam( aps );
281	}
282	#endif
283	#if SAO_UNIT_INTERLEAVING
284	READ_FLAG(uiCode, "aps_sao_interleaving_flag"); aps->setSaoInterleavingFlag( (uiCode==1)?true:false );
285	if(!aps->getSaoInterleavingFlag())
286	{
287	READ_FLAG(uiCode, "aps_sample_adaptive_offset_flag"); aps->setSaoEnabled( (uiCode==1)?true:false );
288	#endif
289	if(aps->getSaoEnabled())
290	{
291	aps->getSaoParam()->bSaoFlag[0] = true;
292	xParseSaoParam( aps->getSaoParam() );
293	}
294	#if SAO_UNIT_INTERLEAVING
295	}
296	#endif
297	#if LCU_SYNTAX_ALF
298	READ_FLAG(uiCode, "aps_adaptive_loop_filter_flag"); aps->setAlfEnabled( (uiCode==1)?true:false );
299	#endif
300	if(aps->getAlfEnabled())
301	{
302	#if !LCU_SYNTAX_ALF
303	aps->getAlfParam()->alf_flag = 1;
304	#endif
305	xParseAlfParam( aps->getAlfParam());
306	}
307	READ_FLAG( uiCode, "aps_extension_flag");
308	if (uiCode)
309	{
310	while ( xMoreRbspData() )
311	{
312	READ_FLAG( uiCode, "aps_extension_data_flag");
313	}
314	}
315
316	}
317
318	#if DBL_CONTROL
319	Void TDecCavlc::xParseDblParam ( TComAPS* aps )
320	{
321	UInt uiSymbol;
322	Int iSymbol;
323
324	parseDFFlag(uiSymbol, "loop_filter_disable");
325	aps->setLoopFilterDisable(uiSymbol?true:false);
326
327	if (!aps->getLoopFilterDisable())
328	{
329	parseDFSvlc(iSymbol, "beta_offset_div2");
330	aps->setLoopFilterBetaOffset(iSymbol);
331	parseDFSvlc(iSymbol, "tc_offset_div2");
332	aps->setLoopFilterTcOffset(iSymbol);
333	}
334	}
335	#endif
336	/** parse SAO parameters
337	* \param pSaoParam
338	*/
339	Void TDecCavlc::xParseSaoParam(SAOParam* pSaoParam)
340	{
341	UInt uiSymbol;
342
343	#if SAO_UNIT_INTERLEAVING
344	int i,j, compIdx;
345	int numCuInWidth;
346	int numCuInHeight;
347	Bool repeatedRow[3];
348	if (pSaoParam->bSaoFlag[0])
349	{
350	READ_FLAG (uiSymbol, "sao_cb_enable_flag"); pSaoParam->bSaoFlag[1] = uiSymbol? true:false;
351	READ_FLAG (uiSymbol, "sao_cr_enable_flag"); pSaoParam->bSaoFlag[2] = uiSymbol? true:false;
352	READ_UVLC (uiSymbol, "sao_num_lcu_in_width_minus1"); pSaoParam->numCuInWidth = uiSymbol + 1;
353	READ_UVLC (uiSymbol, "sao_num_lcu_in_height_minus1"); pSaoParam->numCuInHeight = uiSymbol + 1;
354	numCuInWidth = pSaoParam->numCuInWidth;
355	numCuInHeight = pSaoParam->numCuInHeight;
356
357	READ_FLAG (uiSymbol, "sao_one_luma_unit_flag"); pSaoParam->oneUnitFlag[0] = uiSymbol? true:false;
358	if (pSaoParam->oneUnitFlag[0] )
359	xParseSaoOffset(&(pSaoParam->saoLcuParam[0][0]));
360
361	if (pSaoParam->bSaoFlag[1])
362	{
363	READ_FLAG (uiSymbol, "sao_one_cb_unit_flag"); pSaoParam->oneUnitFlag[1] = uiSymbol? true:false;
364	if (pSaoParam->oneUnitFlag[1] )
365	xParseSaoOffset(&(pSaoParam->saoLcuParam[1][0]));
366	}
367	if (pSaoParam->bSaoFlag[2])
368	{
369	READ_FLAG (uiSymbol, "sao_one_cr_unit_flag"); pSaoParam->oneUnitFlag[2] = uiSymbol? true:false;
370	if (pSaoParam->oneUnitFlag[2] )
371	xParseSaoOffset(&(pSaoParam->saoLcuParam[2][0]));
372	}
373	for (j=0;j<numCuInHeight;j++)
374	{
375	for (compIdx=0;compIdx<3;compIdx++)
376	{
377	repeatedRow[compIdx] = 0;
378	}
379	for (i=0;i<numCuInWidth;i++)
380	{
381	for (compIdx=0; compIdx<3; compIdx++)
382	{
383	if (pSaoParam->bSaoFlag[compIdx] && !pSaoParam->oneUnitFlag[compIdx])
384	{
385	if (j>0 && i==0)
386	{
387	READ_FLAG (uiSymbol, "sao_repeat_row_flag"); repeatedRow[compIdx] = uiSymbol? true:false;
388	}
389	xParseSaoUnit (i,j, compIdx, pSaoParam, repeatedRow[compIdx]);
390	}
391	}
392	}
393	}
394	}
395	#else
396	if (pSaoParam->bSaoFlag[0])
397	{
398	xParseSaoSplitParam (pSaoParam, 0, 0);
399	xParseSaoOffsetParam(pSaoParam, 0, 0);
400	READ_FLAG (uiSymbol, "sao_flag_cb");
401	pSaoParam->bSaoFlag[1] = uiSymbol? true:false;
402	if (pSaoParam->bSaoFlag[1])
403	{
404	xParseSaoSplitParam (pSaoParam, 0, 1);
405	xParseSaoOffsetParam(pSaoParam, 0, 1);
406	}
407
408	READ_FLAG (uiSymbol, "sao_flag_cr");
409	pSaoParam->bSaoFlag[2] = uiSymbol? true:false;
410	if (pSaoParam->bSaoFlag[2])
411	{
412	xParseSaoSplitParam (pSaoParam, 0, 2);
413	xParseSaoOffsetParam(pSaoParam, 0, 2);
414	}
415	}
416	#endif
417	}
418	#if SAO_UNIT_INTERLEAVING
419	/** copy SAO parameter
420	* \param dst
421	* \param src
422	*/
423	inline Void copySaoOneLcuParam(SaoLcuParam* dst, SaoLcuParam* src)
424	{
425	Int i;
426	dst->partIdx = src->partIdx;
427	dst->typeIdx = src->typeIdx;
428	if (dst->typeIdx != -1)
429	{
430	if (dst->typeIdx == SAO_BO)
431	{
432	dst->bandPosition = src->bandPosition ;
433	}
434	else
435	{
436	dst->bandPosition = 0;
437	}
438	dst->length = src->length;
439	for (i=0;i<dst->length;i++)
440	{
441	dst->offset[i] = src->offset[i];
442	}
443	}
444	else
445	{
446	dst->length = 0;
447	for (i=0;i<SAO_BO_LEN;i++)
448	{
449	dst->offset[i] = 0;
450	}
451	}
452	}
453	/** parse SAO offset
454	* \param saoLcuParam SAO LCU parameters
455	*/
456	Void TDecCavlc::xParseSaoOffset(SaoLcuParam* saoLcuParam)
457	{
458	UInt uiSymbol;
459	Int iSymbol;
460	static Int typeLength[MAX_NUM_SAO_TYPE] = {
461	SAO_EO_LEN,
462	SAO_EO_LEN,
463	SAO_EO_LEN,
464	SAO_EO_LEN,
465	SAO_BO_LEN
466	};
467
468	READ_UVLC (uiSymbol, "sao_type_idx"); saoLcuParam->typeIdx = (Int)uiSymbol - 1;
469	if (uiSymbol)
470	{
471	saoLcuParam->length = typeLength[saoLcuParam->typeIdx];
472	if( saoLcuParam->typeIdx == SAO_BO )
473	{
474	READ_CODE( 5, uiSymbol, "sao_band_position"); saoLcuParam->bandPosition = uiSymbol;
475	for(Int i=0; i< saoLcuParam->length; i++)
476	{
477	READ_SVLC (iSymbol, "sao_offset"); saoLcuParam->offset[i] = iSymbol;
478	}
479	}
480	else if( saoLcuParam->typeIdx < 4 )
481	{
482	READ_UVLC (uiSymbol, "sao_offset"); saoLcuParam->offset[0] = uiSymbol;
483	READ_UVLC (uiSymbol, "sao_offset"); saoLcuParam->offset[1] = uiSymbol;
484	READ_UVLC (uiSymbol, "sao_offset"); saoLcuParam->offset[2] = -(Int)uiSymbol;
485	READ_UVLC (uiSymbol, "sao_offset"); saoLcuParam->offset[3] = -(Int)uiSymbol;
486	}
487	}
488	else
489	{
490	saoLcuParam->length = 0;
491	}
492	}
493
494	/** parse SAO unit
495	* \param rx x-axis location
496	* \param ry y-axis location
497	* \param compIdx color component index
498	* \param saoParam SAO parameters
499	* \param repeatedRow repeat row flag
500	*/
501	void TDecCavlc::xParseSaoUnit(Int rx, Int ry, Int compIdx, SAOParam* saoParam, Bool& repeatedRow )
502	{
503	int addr, addrUp, addrLeft;
504	int numCuInWidth = saoParam->numCuInWidth;
505	SaoLcuParam* saoOneLcu;
506	SaoLcuParam* saoOneLcuUp;
507	SaoLcuParam* saoOneLcuLeft;
508	UInt uiSymbol;
509	Int iSymbol;
510	Int runLeft;
511	UInt maxValue;
512
513	addr = rx + ry*numCuInWidth;
514	addrLeft = (addr%numCuInWidth == 0) ? -1 : addr - 1;
515	addrUp = (addr<numCuInWidth) ? -1 : addr - numCuInWidth;
516
517	saoOneLcu = &(saoParam->saoLcuParam[compIdx][addr]);
518	if (!repeatedRow)
519	{
520	runLeft = (addrLeft>=0 ) ? saoParam->saoLcuParam[compIdx][addrLeft].run : -1;
521	if (rx == 0 \|\| runLeft==0)
522	{
523	saoOneLcu->mergeLeftFlag = 0;
524	if (ry == 0)
525	{
526	maxValue = numCuInWidth-rx-1;
527	UInt length = 0;
528	UInt val = 0;
529	if (maxValue)
530	{
531	for(UInt i=0; i<32; i++)
532	{
533	if(maxValue&0x1)
534	{
535	length = i+1;
536	}
537	maxValue = (maxValue >> 1);
538	}
539	if(length)
540	{
541	READ_CODE(length, val, "sao_run_diff");
542	}
543	}
544	uiSymbol = val;
545	saoOneLcu->runDiff = uiSymbol;
546	xParseSaoOffset(saoOneLcu);
547	saoOneLcu->run = saoOneLcu->runDiff;
548	}
549	else
550	{
551	saoOneLcuUp = &(saoParam->saoLcuParam[compIdx][addrUp]);
552	READ_SVLC (iSymbol , "sao_run_diff" ); saoOneLcu->runDiff = iSymbol;
553	READ_FLAG (uiSymbol, "sao_merge_up_flag"); saoOneLcu->mergeUpFlag = uiSymbol? true:false;
554	if (!saoOneLcu->mergeUpFlag)
555	{
556	xParseSaoOffset(saoOneLcu);
557	}
558	else
559	{
560	saoOneLcuUp = &(saoParam->saoLcuParam[compIdx][addrUp]);
561	copySaoOneLcuParam(saoOneLcu, saoOneLcuUp);
562	}
563	saoOneLcu->run = saoOneLcu->runDiff + saoOneLcuUp->run;
564	}
565	}
566	else
567	{
568	saoOneLcuLeft = &(saoParam->saoLcuParam[compIdx][addrLeft]);
569	copySaoOneLcuParam(saoOneLcu, saoOneLcuLeft);
570	saoOneLcu->mergeLeftFlag = 1;
571	saoOneLcu->run = saoOneLcuLeft->run-1;
572	}
573	}
574	else
575	{
576	if (ry > 0)
577	{
578	saoOneLcuUp = &(saoParam->saoLcuParam[compIdx][addrUp]);
579	copySaoOneLcuParam(saoOneLcu, saoOneLcuUp);
580	saoOneLcu->mergeLeftFlag = 0;
581	saoOneLcu->run = saoOneLcuUp->run;
582	}
583	}
584	}
585
586	#else
587	/** Decode quadtree split flag
588	* \param pSaoParam, iPartIdx
589	*/
590	Void TDecCavlc::xParseSaoSplitParam(SAOParam* pSaoParam, Int iPartIdx, Int iYCbCr)
591	{
592	UInt uiSymbol;
593	SAOQTPart* pSaoPart = NULL;
594	pSaoPart= &(pSaoParam->psSaoPart[iYCbCr][iPartIdx]);
595
596	if(pSaoPart->PartLevel < pSaoParam->iMaxSplitLevel)
597	{
598	READ_FLAG (uiSymbol, "sao_split_flag");
599	pSaoPart->bSplit = uiSymbol? true:false;
600	if(pSaoPart->bSplit)
601	{
602	for (Int i=0;i<NUM_DOWN_PART;i++)
603	{
604	xParseSaoSplitParam(pSaoParam, pSaoPart->DownPartsIdx[i], iYCbCr);
605	}
606	}
607	}
608	else
609	{
610	pSaoPart->bSplit = false;
611	}
612	}
613
614	/** Decode SAO for one partition
615	* \param pSaoParam, iPartIdx
616	*/
617	Void TDecCavlc::xParseSaoOffsetParam(SAOParam* pSaoParam, Int iPartIdx, Int iYCbCr)
618	{
619	UInt uiSymbol;
620	Int iSymbol;
621	SAOQTPart* pSaoPart = NULL;
622	pSaoPart = &(pSaoParam->psSaoPart[iYCbCr][iPartIdx]);
623
624	static Int iTypeLength[MAX_NUM_SAO_TYPE] = {
625	SAO_EO_LEN,
626	SAO_EO_LEN,
627	SAO_EO_LEN,
628	SAO_EO_LEN,
629	SAO_BO_LEN,
630	SAO_BO_LEN
631	};
632	if(!pSaoPart->bSplit)
633	{
634	READ_UVLC (uiSymbol, "sao_type_idx");
635	if (uiSymbol)
636	{
637	pSaoPart->iBestType = uiSymbol-1;
638	pSaoPart->bEnableFlag = true;
639	}
640	else
641	{
642	pSaoPart->iBestType = -1;
643	pSaoPart->bEnableFlag = false;
644	}
645
646	if (pSaoPart->bEnableFlag)
647	{
648	pSaoPart->iLength = iTypeLength[pSaoPart->iBestType];
649	for(Int i=0; i< pSaoPart->iLength; i++)
650	{
651	READ_SVLC (iSymbol, "sao_offset");
652	pSaoPart->iOffset[i] = iSymbol;
653	}
654	}
655	return;
656	}
657
658	//split
659	if (pSaoPart->PartLevel < pSaoParam->iMaxSplitLevel)
660	{
661	for(Int i=0;i<NUM_DOWN_PART;i++)
662	{
663	xParseSaoOffsetParam(pSaoParam, pSaoPart->DownPartsIdx[i], iYCbCr);
664	}
665	}
666	}
667	#endif
668
669	#if LCU_SYNTAX_ALF
670	Void TDecCavlc::xParseAlfParam(AlfParamSet* pAlfParamSet, Bool bSentInAPS, Int firstLCUAddr, Bool acrossSlice, Int numLCUInWidth, Int numLCUInHeight)
671	{
672	Int numLCU;
673	UInt uiSymbol;
674	Bool isEnabled[NUM_ALF_COMPONENT];
675	Bool isUniParam[NUM_ALF_COMPONENT];
676
677	isEnabled[ALF_Y] = true;
678	READ_FLAG(uiSymbol, "alf_cb_enable_flag"); isEnabled[ALF_Cb] = ((uiSymbol ==1)?true:false);
679	READ_FLAG(uiSymbol, "alf_cr_enable_flag"); isEnabled[ALF_Cr] = ((uiSymbol ==1)?true:false);
680	READ_FLAG(uiSymbol, "alf_one_luma_unit_per_slice_flag"); isUniParam[ALF_Y] = ((uiSymbol ==1)?true:false);
681
682	isUniParam[ALF_Cb] = true;
683	if (isEnabled[ALF_Cb])
684	{
685	READ_FLAG(uiSymbol, "alf_one_cb_unit_per_slice_flag"); isUniParam[ALF_Cb] = ((uiSymbol ==1)?true:false);
686	}
687
688	isUniParam[ALF_Cr] = true;
689	if (isEnabled[ALF_Cr])
690	{
691	READ_FLAG(uiSymbol, "alf_one_cr_unit_per_slice_flag"); isUniParam[ALF_Cr] = ((uiSymbol ==1)?true:false);
692	}
693
694	if(bSentInAPS)
695	{
696	READ_UVLC(uiSymbol, "alf_num_lcu_in_width_minus1"); numLCUInWidth = uiSymbol+1;
697	READ_UVLC(uiSymbol, "alf_num_lcu_in_height_minus1"); numLCUInHeight = uiSymbol+1;
698	numLCU = numLCUInWidth*numLCUInHeight;
699	}
700	else //sent in slice header
701	{
702	READ_UVLC(uiSymbol, "alf_num_lcu_in_slice_minus1"); numLCU = uiSymbol+1;
703	}
704
705	assert(pAlfParamSet != NULL);
706
707	pAlfParamSet->create(numLCUInWidth, numLCUInHeight, numLCU);
708	for(Int compIdx = 0; compIdx < NUM_ALF_COMPONENT; compIdx++)
709	{
710	pAlfParamSet->isEnabled[compIdx] = isEnabled[compIdx];
711	pAlfParamSet->isUniParam[compIdx]= isUniParam[compIdx];
712	}
713
714	parseAlfParamSet(pAlfParamSet, firstLCUAddr, acrossSlice);
715	}
716
717
718	Void TDecCavlc::parseAlfParamSet(AlfParamSet* pAlfParamSet, Int firstLCUAddr, Bool alfAcrossSlice)
719	{
720	Int numLCUInWidth = pAlfParamSet->numLCUInWidth;
721	Int numLCU = pAlfParamSet->numLCU;
722
723	static Bool isRepeatedRow [NUM_ALF_COMPONENT];
724	static Int numStoredFilters[NUM_ALF_COMPONENT];
725	static Int* run [NUM_ALF_COMPONENT];
726
727	for(Int compIdx =0; compIdx < NUM_ALF_COMPONENT; compIdx++)
728	{
729	isRepeatedRow[compIdx] = false;
730	numStoredFilters[compIdx] = 0;
731
732	run[compIdx] = new Int[numLCU+1];
733	run[compIdx][0] = -1;
734	}
735
736	UInt uiSymbol;
737	Int iSymbol, ry, rx, addrUp;
738
739	for(Int i=0; i< numLCU; i++)
740	{
741	rx = (i+ firstLCUAddr)% numLCUInWidth;
742	ry = (i+ firstLCUAddr)/ numLCUInWidth;
743
744	for(Int compIdx =0; compIdx < NUM_ALF_COMPONENT; compIdx++)
745	{
746	AlfUnitParam& alfUnitParam = pAlfParamSet->alfUnitParam[compIdx][i];
747
748	if(pAlfParamSet->isEnabled[compIdx])
749	{
750	if(!pAlfParamSet->isUniParam[compIdx])
751	{
752	addrUp = i-numLCUInWidth;
753	if(rx ==0 && addrUp >=0)
754	{
755	READ_FLAG(uiSymbol, "alf_repeat_row _flag"); isRepeatedRow[compIdx] = ((uiSymbol ==1)?true:false);
756	}
757
758	if(isRepeatedRow[compIdx])
759	{
760	alfUnitParam.mergeType = ALF_MERGE_UP;
761	assert(addrUp >=0);
762	run[compIdx][i] = run[compIdx][addrUp];
763	}
764	else
765	{
766	if(rx == 0 \|\| run[compIdx][i] < 0)
767	{
768	if(addrUp < 0)
769	{
770	//alf_run_diff u(v)
771	parseAlfFixedLengthRun(uiSymbol, rx, numLCUInWidth);
772	run[compIdx][i] = uiSymbol;
773	}
774	else
775	{
776	//alf_run_diff s(v)
777	READ_SVLC(iSymbol, "alf_run_diff");
778	run[compIdx][i] = run[compIdx][addrUp] + iSymbol;
779	assert(run[compIdx][i] >= 0);
780	}
781
782	if(ry > 0 && (addrUp >=0 \|\| alfAcrossSlice))
783	{
784	//alf_merge_up_flag
785	READ_FLAG(uiSymbol, "alf_merge_up_flag"); alfUnitParam.mergeType = ((uiSymbol ==1)?ALF_MERGE_UP:ALF_MERGE_DISABLED);
786	}
787	else
788	{
789	alfUnitParam.mergeType = ALF_MERGE_DISABLED;
790	}
791
792	if(alfUnitParam.mergeType != ALF_MERGE_UP)
793	{
794	//alf_lcu_enable_flag
795	READ_FLAG(uiSymbol, "alf_lcu_enable_flag"); alfUnitParam.isEnabled = ((uiSymbol ==1)?true:false);
796
797	if(alfUnitParam.isEnabled)
798	{
799	if(numStoredFilters[compIdx] > 0)
800	{
801	//alf_new_filter_set_flag
802	READ_FLAG(uiSymbol, "alf_new_filter_set_flag"); alfUnitParam.isNewFilt = ((uiSymbol ==1)?true:false);
803
804	if(!alfUnitParam.isNewFilt)
805	{
806	//alf_stored_filter_set_idx
807	parseAlfStoredFilterIdx(uiSymbol, numStoredFilters[compIdx]);
808
809	alfUnitParam.storedFiltIdx = uiSymbol;
810
811	assert( alfUnitParam.storedFiltIdx < numStoredFilters[compIdx]);
812	}
813	}
814	else
815	{
816	alfUnitParam.isNewFilt = true;
817	}
818
819	if(alfUnitParam.isNewFilt)
820	{
821	alfUnitParam.alfFiltParam = new ALFParam(compIdx);
822	xParseAlfParam(alfUnitParam.alfFiltParam);
823	alfUnitParam.alfFiltParam->alf_flag = 1;
824
825	numStoredFilters[compIdx]++;
826	}
827	}
828
829	}
830	}
831	else
832	{
833	alfUnitParam.mergeType = ALF_MERGE_LEFT;
834	}
835
836	run[compIdx][i+1] = run[compIdx][i] -1;
837	}
838
839	}
840	else // uni-param
841	{
842	if(i == 0)
843	{
844	alfUnitParam.mergeType = ALF_MERGE_DISABLED;
845
846	//alf_lcu_enable_flag
847	READ_FLAG(uiSymbol, "alf_lcu_enable_flag"); alfUnitParam.isEnabled = ((uiSymbol ==1)?true:false);
848	if(alfUnitParam.isEnabled)
849	{
850	alfUnitParam.isNewFilt = true;
851	alfUnitParam.alfFiltParam = new ALFParam(compIdx);
852	xParseAlfParam(alfUnitParam.alfFiltParam);
853	alfUnitParam.alfFiltParam->alf_flag = 1;
854	}
855	}
856	else
857	{
858	alfUnitParam.mergeType = ALF_MERGE_FIRST;
859	}
860
861	}
862	}
863	else
864	{
865	alfUnitParam.mergeType = ALF_MERGE_DISABLED;
866	alfUnitParam.isEnabled = false;
867	}
868	}
869	}
870
871	for(Int compIdx =0; compIdx < NUM_ALF_COMPONENT; compIdx++)
872	{
873	delete[] run[compIdx];
874	}
875	}
876
877
878	Void TDecCavlc::parseAlfFixedLengthRun( UInt& idx, UInt rx, UInt numLCUInWidth )
879	{
880	assert(numLCUInWidth > rx);
881
882	UInt length = 0;
883	UInt maxNumRun = numLCUInWidth - rx - 1;
884
885	for(UInt i=0; i<32; i++)
886	{
887	if(maxNumRun&0x1)
888	{
889	length = i+1;
890	}
891	maxNumRun = (maxNumRun >> 1);
892	}
893
894	idx = 0;
895	if(length)
896	{
897	READ_CODE( length, idx, "alf_run_diff" );
898	}
899	else
900	{
901	idx = 0;
902	}
903	}
904
905
906	Void TDecCavlc::parseAlfStoredFilterIdx( UInt& idx, UInt numFilterSetsInBuffer )
907	{
908	assert(numFilterSetsInBuffer > 0);
909
910	UInt length = 0;
911	UInt maxValue = numFilterSetsInBuffer - 1;
912
913	for(UInt i=0; i<32; i++)
914	{
915	if(maxValue&0x1)
916	{
917	length = i+1;
918	}
919	maxValue = (maxValue >> 1);
920	}
921
922	idx = 0;
923	if(length)
924	{
925	READ_CODE( length, idx, "alf_stored_filter_set_idx" );
926	}
927	else
928	{
929	idx = 0;
930	}
931	}
932
933	#endif
934
935	Void TDecCavlc::xParseAlfParam(ALFParam* pAlfParam)
936	{
937	UInt uiSymbol;
938	Int iSymbol;
939	#if ALF_SINGLE_FILTER_SHAPE
940	Int sqrFiltLengthTab[NUM_ALF_FILTER_SHAPE] = {ALF_FILTER_LEN};
941	#else
942	Int sqrFiltLengthTab[2] = { 9, 9};
943	#endif
944
945	#if LCU_SYNTAX_ALF
946	switch(pAlfParam->componentID)
947	{
948	case ALF_Cb:
949	case ALF_Cr:
950	{
951	pAlfParam->filter_shape = ALF_CROSS9x7_SQUARE3x3;
952	pAlfParam->num_coeff = sqrFiltLengthTab[pAlfParam->filter_shape];
953	pAlfParam->filters_per_group = 1;
954	for(Int pos=0; pos< pAlfParam->num_coeff; pos++)
955	{
956	READ_SVLC(iSymbol, "alf_filt_coeff");
957	pAlfParam->coeffmulti[0][pos] = iSymbol;
958	}
959	}
960	break;
961	case ALF_Y:
962	{
963	#endif
964	pAlfParam->filters_per_group = 0;
965	memset (pAlfParam->filterPattern, 0 , sizeof(Int)*NO_VAR_BINS);
966	#if !LCU_SYNTAX_ALF
967	READ_FLAG (uiSymbol, "alf_region_adaptation_flag");
968	pAlfParam->alf_pcr_region_flag = uiSymbol;
969	#endif
970	#if ALF_SINGLE_FILTER_SHAPE
971	pAlfParam->filter_shape = 0;
972	#else
973	READ_UVLC (uiSymbol, "alf_length_luma_minus_5_div2");
974	pAlfParam->filter_shape = uiSymbol;
975	#endif
976	pAlfParam->num_coeff = sqrFiltLengthTab[pAlfParam->filter_shape];
977
978	// filters_per_fr
979	READ_UVLC (uiSymbol, "alf_no_filters_minus1");
980	pAlfParam->filters_per_group = uiSymbol + 1;
981
982	if(uiSymbol == 1) // filters_per_group == 2
983	{
984	READ_UVLC (uiSymbol, "alf_start_second_filter");
985	pAlfParam->startSecondFilter = uiSymbol;
986	pAlfParam->filterPattern [uiSymbol] = 1;
987	}
988	else if (uiSymbol > 1) // filters_per_group > 2
989	{
990	pAlfParam->filters_per_group = 1;
991	#if LCU_SYNTAX_ALF
992	#if ALF_16_BA_GROUPS
993	Int numMergeFlags = 16;
994	#else
995	Int numMergeFlags = 15;
996	#endif
997	#else
998	#if ALF_16_BA_GROUPS
999	Int numMergeFlags = 16;
1000	#else
1001	Int numMergeFlags = pAlfParam->alf_pcr_region_flag ? 16 : 15;
1002	#endif
1003	#endif
1004	for (Int i=1; i<numMergeFlags; i++)
1005	{
1006	READ_FLAG (uiSymbol, "alf_filter_pattern");
1007	pAlfParam->filterPattern[i] = uiSymbol;
1008	pAlfParam->filters_per_group += uiSymbol;
1009	}
1010	}
1011
1012	if (pAlfParam->filters_per_group > 1)
1013	{
1014	READ_FLAG (uiSymbol, "alf_pred_method");
1015	pAlfParam->predMethod = uiSymbol;
1016	}
1017	for(Int idx = 0; idx < pAlfParam->filters_per_group; ++idx)
1018	{
1019	READ_FLAG (uiSymbol,"alf_nb_pred_luma");
1020	pAlfParam->nbSPred[idx] = uiSymbol;
1021	}
1022
1023	#if ALF_SINGLE_FILTER_SHAPE
1024	Int minScanVal = MIN_SCAN_POS_CROSS;
1025	#else
1026	Int minScanVal = (pAlfParam->filter_shape == ALF_STAR5x5) ? 0: MIN_SCAN_POS_CROSS;
1027	#endif
1028
1029	// Determine maxScanVal
1030	Int maxScanVal = 0;
1031	Int *pDepthInt = pDepthIntTabShapes[pAlfParam->filter_shape];
1032	for(Int idx = 0; idx < pAlfParam->num_coeff; idx++)
1033	{
1034	maxScanVal = max(maxScanVal, pDepthInt[idx]);
1035	}
1036
1037	// Golomb parameters
1038	#if LCU_SYNTAX_ALF
1039	if( pAlfParam->filters_per_group > 1 )
1040	{
1041	#endif
1042	READ_UVLC (uiSymbol, "alf_min_kstart_minus1");
1043	pAlfParam->minKStart = 1 + uiSymbol;
1044
1045	Int kMin = pAlfParam->minKStart;
1046
1047	for(Int scanPos = minScanVal; scanPos < maxScanVal; scanPos++)
1048	{
1049	READ_FLAG (uiSymbol, "alf_golomb_index_bit");
1050	pAlfParam->kMinTab[scanPos] = kMin + uiSymbol;
1051	kMin = pAlfParam->kMinTab[scanPos];
1052	}
1053	#if LCU_SYNTAX_ALF
1054	}
1055	#endif
1056
1057	Int scanPos;
1058	for(Int idx = 0; idx < pAlfParam->filters_per_group; ++idx)
1059	{
1060	for(Int i = 0; i < pAlfParam->num_coeff; i++)
1061	{
1062	scanPos = pDepthInt[i] - 1;
1063	#if LCU_SYNTAX_ALF
1064	Int k = (pAlfParam->filters_per_group == 1) ? kTableTabShapes[ALF_CROSS9x7_SQUARE3x3][i] : pAlfParam->kMinTab[scanPos];
1065	pAlfParam->coeffmulti[idx][i] = xGolombDecode(k);
1066	#else
1067	pAlfParam->coeffmulti[idx][i] = xGolombDecode(pAlfParam->kMinTab[scanPos]);
1068	#endif
1069	}
1070	}
1071	#if LCU_SYNTAX_ALF
1072	}
1073	break;
1074	default:
1075	{
1076	printf("Not a legal component ID for ALF\n");
1077	assert(0);
1078	exit(-1);
1079	}
1080	}
1081	#else
1082	// filter parameters for chroma
1083	READ_UVLC (uiSymbol, "alf_chroma_idc");
1084	pAlfParam->chroma_idc = uiSymbol;
1085
1086	if(pAlfParam->chroma_idc)
1087	{
1088
1089	#if ALF_SINGLE_FILTER_SHAPE
1090	pAlfParam->filter_shape_chroma = 0;
1091	#else
1092	READ_UVLC (uiSymbol, "alf_length_chroma_minus_5_div2");
1093
1094	pAlfParam->filter_shape_chroma = uiSymbol;
1095	#endif
1096	pAlfParam->num_coeff_chroma = sqrFiltLengthTab[pAlfParam->filter_shape_chroma];
1097	// filter coefficients for chroma
1098	for(Int pos=0; pos<pAlfParam->num_coeff_chroma; pos++)
1099	{
1100	READ_SVLC (iSymbol, "alf_coeff_chroma");
1101	pAlfParam->coeff_chroma[pos] = iSymbol;
1102	}
1103	}
1104	#endif
1105	}
1106
1107	Int TDecCavlc::xGolombDecode(Int k)
1108	{
1109	UInt uiSymbol;
1110	Int q = -1;
1111	Int nr = 0;
1112	Int a;
1113
1114	uiSymbol = 1;
1115	while (uiSymbol)
1116	{
1117	xReadFlag(uiSymbol);
1118	q++;
1119	}
1120	for(a = 0; a < k; ++a) // read out the sequential log2(M) bits
1121	{
1122	xReadFlag(uiSymbol);
1123	if(uiSymbol)
1124	nr += 1 << a;
1125	}
1126	nr += q << k;
1127	if(nr != 0)
1128	{
1129	xReadFlag(uiSymbol);
1130	nr = (uiSymbol)? nr: -nr;
1131	}
1132	#if ENC_DEC_TRACE
1133	fprintf( g_hTrace, "%8lld ", g_nSymbolCounter++ );
1134	fprintf( g_hTrace, "%-40s ge(v) : %d\n", "alf_coeff_luma", nr );
1135	#endif
1136	return nr;
1137	}
1138
1139	#if TILES_OR_ENTROPY_SYNC_IDC
1140	Void TDecCavlc::parsePPS(TComPPS* pcPPS, ParameterSetManagerDecoder *parameterSet)
1141	#else
1142	Void TDecCavlc::parsePPS(TComPPS* pcPPS)
1143	#endif
1144	{
1145	#if ENC_DEC_TRACE
1146	xTracePPSHeader (pcPPS);
1147	#endif
1148	UInt uiCode;
1149
1150	Int iCode;
1151
1152	#if !RPS_IN_SPS
1153	TComRPSList* rpsList = pcPPS->getRPSList();
1154	#endif
1155	READ_UVLC( uiCode, "pic_parameter_set_id"); pcPPS->setPPSId (uiCode);
1156	READ_UVLC( uiCode, "seq_parameter_set_id"); pcPPS->setSPSId (uiCode);
1157
1158	#if MULTIBITS_DATA_HIDING
1159	READ_FLAG ( uiCode, "sign_data_hiding_flag" ); pcPPS->setSignHideFlag( uiCode );
1160	if( pcPPS->getSignHideFlag() )
1161	{
1162	READ_CODE( 4, uiCode, "sign_hiding_threshold"); pcPPS->setTSIG(uiCode);
1163	}
1164	#endif
1165
1166	#if CABAC_INIT_FLAG
1167	READ_FLAG( uiCode, "cabac_init_present_flag" ); pcPPS->setCabacInitPresentFlag( uiCode ? true : false );
1168	#endif
1169	#if !RPS_IN_SPS
1170	// RPS is put before entropy_coding_mode_flag
1171	// since entropy_coding_mode_flag will probably be removed from the WD
1172	TComReferencePictureSet* pcRPS;
1173
1174	READ_UVLC( uiCode, "num_short_term_ref_pic_sets" );
1175	rpsList->create(uiCode);
1176
1177	for(Int i=0; i< rpsList->getNumberOfReferencePictureSets(); i++)
1178	{
1179	pcRPS = rpsList->getReferencePictureSet(i);
1180	parseShortTermRefPicSet(pcPPS,pcRPS,i);
1181	}
1182	READ_FLAG( uiCode, "long_term_ref_pics_present_flag" ); pcPPS->setLongTermRefsPresent(uiCode);
1183	#endif
1184	// entropy_coding_mode_flag
1185	// We code the entropy_coding_mode_flag, it's needed for tests.
1186	READ_FLAG( uiCode, "entropy_coding_mode_flag" ); pcPPS->setEntropyCodingMode( uiCode ? true : false );
1187	if (pcPPS->getEntropyCodingMode())
1188	{
1189	#if !WPP_SIMPLIFICATION
1190	READ_UVLC( uiCode, "entropy_coding_synchro" ); pcPPS->setEntropyCodingSynchro( uiCode );
1191	READ_FLAG( uiCode, "cabac_istate_reset" ); pcPPS->setCabacIstateReset( uiCode ? true : false );
1192	#endif
1193	#if !TILES_OR_ENTROPY_SYNC_IDC
1194	#if !WPP_SIMPLIFICATION
1195	if ( pcPPS->getEntropyCodingSynchro() )
1196	#endif
1197	{
1198	READ_UVLC( uiCode, "num_substreams_minus1" ); pcPPS->setNumSubstreams(uiCode+1);
1199	}
1200	#endif
1201	}
1202	#if !H0566_TLA
1203	READ_UVLC( uiCode, "num_temporal_layer_switching_point_flags" ); pcPPS->setNumTLayerSwitchingFlags( uiCode );
1204	for ( UInt i = 0; i < pcPPS->getNumTLayerSwitchingFlags(); i++ )
1205	{
1206	READ_FLAG( uiCode, "temporal_layer_switching_point_flag" ); pcPPS->setTLayerSwitchingFlag( i, uiCode > 0 ? true : false );
1207	}
1208	#endif
1209
1210	// num_ref_idx_l0_default_active_minus1
1211	// num_ref_idx_l1_default_active_minus1
1212	READ_SVLC(iCode, "pic_init_qp_minus26" ); pcPPS->setPicInitQPMinus26(iCode);
1213	READ_FLAG( uiCode, "constrained_intra_pred_flag" ); pcPPS->setConstrainedIntraPred( uiCode ? true : false );
1214	READ_FLAG( uiCode, "enable_temporal_mvp_flag" ); pcPPS->setEnableTMVPFlag( uiCode ? true : false );
1215	READ_CODE( 2, uiCode, "slice_granularity" ); pcPPS->setSliceGranularity(uiCode);
1216
1217	// alf_param() ?
1218
1219	READ_UVLC( uiCode, "max_cu_qp_delta_depth");
1220	if(uiCode == 0)
1221	{
1222	pcPPS->setUseDQP (false);
1223	pcPPS->setMaxCuDQPDepth( 0 );
1224	}
1225	else
1226	{
1227	pcPPS->setUseDQP (true);
1228	pcPPS->setMaxCuDQPDepth(uiCode - 1);
1229	}
1230
1231	READ_SVLC( iCode, "chroma_qp_offset");
1232	pcPPS->setChromaQpOffset(iCode);
1233
1234	READ_SVLC( iCode, "chroma_qp_offset_2nd");
1235	pcPPS->setChromaQpOffset2nd(iCode);
1236
1237	READ_FLAG( uiCode, "weighted_pred_flag" ); // Use of Weighting Prediction (P_SLICE)
1238	pcPPS->setUseWP( uiCode==1 );
1239	READ_CODE( 2, uiCode, "weighted_bipred_idc" ); // Use of Bi-Directional Weighting Prediction (B_SLICE)
1240	pcPPS->setWPBiPredIdc( uiCode );
1241	//printf("TDecCavlc::parsePPS():\tm_bUseWeightPred=%d\tm_uiBiPredIdc=%d\n", pcPPS->getUseWP(), pcPPS->getWPBiPredIdc());
1242
1243	#if H0388
1244	READ_FLAG( uiCode, "output_flag_present_flag" );
1245	pcPPS->setOutputFlagPresentFlag( uiCode==1 );
1246	#endif
1247
1248	#if TILES_OR_ENTROPY_SYNC_IDC
1249	if(parameterSet->getPrefetchedSPS(pcPPS->getSPSId())->getTilesOrEntropyCodingSyncIdc()==1)
1250	{
1251	#endif
1252	READ_FLAG ( uiCode, "tile_info_present_flag" );
1253	pcPPS->setColumnRowInfoPresent(uiCode);
1254	READ_FLAG ( uiCode, "tile_control_present_flag" );
1255	pcPPS->setTileBehaviorControlPresentFlag(uiCode);
1256	if( pcPPS->getColumnRowInfoPresent() == 1 )
1257	{
1258	READ_UVLC ( uiCode, "num_tile_columns_minus1" );
1259	pcPPS->setNumColumnsMinus1( uiCode );
1260	READ_UVLC ( uiCode, "num_tile_rows_minus1" );
1261	pcPPS->setNumRowsMinus1( uiCode );
1262	READ_FLAG ( uiCode, "uniform_spacing_flag" );
1263	pcPPS->setUniformSpacingIdr( uiCode );
1264
1265	if( pcPPS->getUniformSpacingIdr() == 0 )
1266	{
1267	UInt* columnWidth = (UInt)malloc(pcPPS->getNumColumnsMinus1()sizeof(UInt));
1268	for(UInt i=0; i<pcPPS->getNumColumnsMinus1(); i++)
1269	{
1270	READ_UVLC( uiCode, "column_width" );
1271	columnWidth[i] = uiCode;
1272	}
1273	pcPPS->setColumnWidth(columnWidth);
1274	free(columnWidth);
1275
1276	UInt* rowHeight = (UInt)malloc(pcPPS->getNumRowsMinus1()sizeof(UInt));
1277	for(UInt i=0; i<pcPPS->getNumRowsMinus1(); i++)
1278	{
1279	READ_UVLC( uiCode, "row_height" );
1280	rowHeight[i] = uiCode;
1281	}
1282	pcPPS->setRowHeight(rowHeight);
1283	free(rowHeight);
1284	}
1285	}
1286
1287
1288	if(pcPPS->getTileBehaviorControlPresentFlag() == 1)
1289	{
1290	Int iNumColTilesMinus1 = (pcPPS->getColumnRowInfoPresent() == 1)?(pcPPS->getNumColumnsMinus1()):(pcPPS->getSPS()->getNumColumnsMinus1());
1291	Int iNumRowTilesMinus1 = (pcPPS->getColumnRowInfoPresent() == 1)?(pcPPS->getNumColumnsMinus1()):(pcPPS->getSPS()->getNumRowsMinus1());
1292	#if !REMOVE_TILE_DEPENDENCE
1293	pcPPS->setTileBoundaryIndependenceIdr( 1 ); //default
1294	#endif
1295	pcPPS->setLFCrossTileBoundaryFlag(true); //default
1296
1297	if(iNumColTilesMinus1 !=0 \|\| iNumRowTilesMinus1 !=0)
1298	{
1299	#if !REMOVE_TILE_DEPENDENCE
1300	READ_FLAG ( uiCode, "tile_boundary_independence_flag" );
1301	pcPPS->setTileBoundaryIndependenceIdr( uiCode );
1302
1303	if(pcPPS->getTileBoundaryIndependenceIdr() == 1)
1304	{
1305	#endif
1306	READ_FLAG ( uiCode, "loop_filter_across_tile_flag" );
1307	pcPPS->setLFCrossTileBoundaryFlag( (uiCode == 1)?true:false );
1308	#if !REMOVE_TILE_DEPENDENCE
1309	}
1310	#endif
1311	}
1312	}
1313	#if TILES_OR_ENTROPY_SYNC_IDC
1314	}
1315	else if(parameterSet->getPrefetchedSPS(pcPPS->getSPSId())->getTilesOrEntropyCodingSyncIdc()==2)
1316	{
1317	READ_UVLC( uiCode, "num_substreams_minus1" ); pcPPS->setNumSubstreams(uiCode+1);
1318	}
1319	#endif
1320
1321	#if DBL_CONTROL
1322	READ_FLAG( uiCode, "deblocking_filter_control_present_flag" );
1323	pcPPS->setDeblockingFilterControlPresent( uiCode ? true : false);
1324	#endif
1325	#if PARALLEL_MERGE
1326	READ_UVLC( uiCode, "log2_parallel_merge_level_minus2");
1327	assert(uiCode == LOG2_PARALLEL_MERGE_LEVEL_MINUS2);
1328	pcPPS->setLog2ParallelMergeLevelMinus2 (uiCode);
1329	#endif
1330
1331	READ_FLAG( uiCode, "pps_extension_flag");
1332	if (uiCode)
1333	{
1334	while ( xMoreRbspData() )
1335	{
1336	READ_FLAG( uiCode, "pps_extension_data_flag");
1337	}
1338	}
1339	}
1340	#if QC_MVHEVC_B0046
1341	Void TDecCavlc::parseVPS(TComVPS* pcVPS)
1342	{
1343	UInt uiCode;
1344	READ_CODE( 4, uiCode, "video_parameter_set_id" ); pcVPS->setVPSId( uiCode );
1345	READ_FLAG( uiCode, "temporal_id_nesting_flag" ); pcVPS->setTemporalNestingFlag( uiCode ? true:false );
1346	READ_CODE( 2, uiCode, "vps_reserved_zero_2bits" ); assert( !uiCode );
1347	READ_CODE( 6, uiCode, "vps_max_layers_minus1" ); pcVPS->setMaxLayers( uiCode + 1 );
1348	READ_CODE( 3, uiCode, "vps_max_sub_layers_minus1" ); pcVPS->setMaxTLayers( uiCode + 1 );
1349	READ_CODE( 12, uiCode, "vps_extension_offset" ); assert( !uiCode );
1350	for(UInt i = 0; i <= pcVPS->getMaxTLayers()-1; i++)
1351	{
1352	READ_UVLC( uiCode, "max_dec_pic_buffering[i]" ); pcVPS->setMaxDecPicBuffering( uiCode, i );
1353	READ_UVLC( uiCode, "num_reorder_pics[i]" ); pcVPS->setNumReorderPics( uiCode, i );
1354	READ_UVLC( uiCode, "max_latency_increase[i]" ); pcVPS->setMaxLatencyIncrease( uiCode, i );
1355	}
1356	READ_UVLC( uiCode, "vps_num_hrd_parameters" ); pcVPS->setNumHRDParameters(uiCode);
1357	assert(pcVPS->getNumHRDParameters()==0);
1358	for ( UInt i = 0; i < pcVPS->getNumHRDParameters(); i ++)
1359	{
1360	// if( i > 0 )
1361	//{
1362	// READ_UVLC (0, "op_num_layer_id_values_minus1[ opIdx ]");
1363	// for( i = 0; i <= op_num_layer_id_values_minus1[ opIdx ]; i++ )
1364	// READ_UVLC(0, 6, "op_layer_id[ opIdx ][ i ]");
1365	//}
1366	//hrd_parameters( i = = 0, vps_max_sub_layers_minus1 );
1367	}
1368
1369	READ_CODE( 1, uiCode, "bit_equal_to_one" ); assert( uiCode );
1370	//vps_extension_byte_alignment_reserved_one_bit
1371	xReadVPSAlignOne();
1372	READ_CODE( 8, uiCode, "num_additional_layer_operation_points" ); pcVPS->setNumAddiLayerOperationPoints( uiCode );
1373	READ_CODE( 8, uiCode, "num_additional_profile_level_sets" ); pcVPS->setNumAddiProLevelSets( uiCode);
1374
1375
1376	for(UInt i=0; i <= pcVPS->getMaxLayers()-1; i++)
1377	{
1378	READ_CODE( 4, uiCode, "num_types_zero_4bits[i]" ); assert( !uiCode );
1379	READ_CODE( 4, uiCode, "type_zero_4bits[i]" ); assert( !uiCode );
1380	READ_CODE( 8, uiCode, "view_id[i]" ); pcVPS->setViewId(uiCode, i);
1381	// WRITE_SVLC( pcVPS->getViewOrderIdx(i), "view_order_idx[i]" );
1382	if(i)
1383	{
1384	READ_CODE( 6, uiCode, "num_direct_ref_layers[ i ]" ); pcVPS->setNumDirectRefLayer(uiCode, i);
1385	for (UInt j = 0; j< pcVPS->getNumDirectRefLayer(i); j++)
1386	{
1387	READ_CODE( 6, uiCode, "ref_layer_id[i][j]" ); pcVPS->setDirectRefLayerId (uiCode, i, j);
1388	}
1389	}
1390	}
1391	for( UInt i=1; i<=pcVPS->getNumAddiProLevelSets(); i++)
1392	{
1393	//profile_tier_level
1394	}
1395	for( UInt i=1; i<= pcVPS->getNumAddiLayerOperationPoints(); i++)
1396	{
1397	if(pcVPS->getMaxLayers() == 3)
1398	{
1399	pcVPS->setNumOpLayerIdMinus1((i < pcVPS->getNumAddiLayerOperationPoints() ? 1: 2), (i-1));
1400	}
1401	else if( i==1 )
1402	{
1403	assert(pcVPS->getNumAddiLayerOperationPoints()==1);
1404	pcVPS->setNumOpLayerIdMinus1(pcVPS->getMaxLayers()-1, (i-1));
1405	}
1406	READ_UVLC( uiCode, "op_num_layer_id_values_minus1[ opIdx ]" ); pcVPS->setNumOpLayerIdMinus1(uiCode, i-1);
1407	for(UInt j = 0; j <= pcVPS->getNumOpLayerIdMinus1(i-1); j++ )
1408	{
1409	READ_UVLC( uiCode, "op_layer_id[ opIdx ][ i ]" ); pcVPS->setNumOpLayerId(uiCode, i-1, j);
1410	}
1411	if (pcVPS->getNumAddiProLevelSets())
1412	{
1413	//profile_level_idx[ i ]
1414	}
1415	}
1416	return;
1417	}
1418	#else
1419	#if VIDYO_VPS_INTEGRATION
1420	Void TDecCavlc::parseVPS(TComVPS* pcVPS)
1421	{
1422	UInt uiCode;
1423	Int iCode;
1424
1425	READ_CODE( 3, uiCode, "max_temporal_layers_minus1" ); pcVPS->setMaxTLayers( uiCode + 1 );
1426	READ_CODE( 5, uiCode, "max_layers_minus1" ); pcVPS->setMaxLayers( uiCode + 1 );
1427	READ_FLAG( uiCode, "temporal_id_nesting_flag" ); pcVPS->setTemporalNestingFlag( uiCode ? true:false );
1428	READ_UVLC( uiCode, "video_parameter_set_id" ); pcVPS->setVPSId( uiCode );
1429	for(UInt i = 0; i <= pcVPS->getMaxTLayers()-1; i++)
1430	{
1431	READ_UVLC( uiCode, "max_dec_pic_buffering[i]" ); pcVPS->setMaxDecPicBuffering( uiCode, i );
1432	READ_UVLC( uiCode, "num_reorder_pics[i]" ); pcVPS->setNumReorderPics( uiCode, i );
1433	READ_UVLC( uiCode, "max_latency_increase[i]" ); pcVPS->setMaxLatencyIncrease( uiCode, i );
1434	}
1435
1436	READ_CODE( 1, uiCode, "bit_equal_to_one" ); assert( uiCode );
1437
1438	if( pcVPS->getMaxLayers() - 1 > 0 )
1439	{
1440	READ_UVLC( uiCode, "extension_type" ); pcVPS->setExtensionType( uiCode );
1441
1442	pcVPS->setViewOrderIdx( 0, 0 );
1443	pcVPS->setViewId( 0, 0 );
1444	pcVPS->setDepthFlag( 0, 0 );
1445	for(UInt i = 1; i <= pcVPS->getMaxLayers()-1; i++)
1446	{
1447	READ_FLAG( uiCode, "dependent_flag[i]" ); pcVPS->setDependentFlag( uiCode ? true:false, i);
1448	if( pcVPS->getDependentFlag(i) )
1449	{
1450	READ_UVLC( uiCode, "delta_reference_layer_id_minus1[i]" ); pcVPS->setDependentLayer( i - uiCode + 1, i );
1451	if( pcVPS->getExtensionType() == VPS_EXTENSION_TYPE_MULTI_VIEW )
1452	{
1453	READ_UVLC( uiCode, "view_id[i]" ); pcVPS->setViewId( uiCode, i );
1454	READ_FLAG( uiCode, "depth_flag[i]" ); pcVPS->setDepthFlag( uiCode ? true:false, i );
1455	READ_SVLC( iCode, "view_order_idx[i]" ); pcVPS->setViewOrderIdx( iCode, i );
1456	}
1457
1458	}
1459	}
1460	}
1461
1462	READ_FLAG( uiCode, "vps_extension_flag" ); assert(!uiCode);
1463	//future extensions go here..
1464
1465	return;
1466	}
1467
1468	#endif
1469	#endif
1470	#if HHI_MPI \|\| OL_QTLIMIT_PREDCODING_B0068
1471	Void TDecCavlc::parseSPS(TComSPS* pcSPS, Bool bIsDepth)
1472	#else
1473	Void TDecCavlc::parseSPS(TComSPS* pcSPS)
1474	#endif
1475	{
1476	#if ENC_DEC_TRACE
1477	xTraceSPSHeader (pcSPS);
1478	#endif
1479
1480	UInt uiCode;
1481	#if !QC_MVHEVC_B0046
1482	Int iCode;
1483	#endif
1484	READ_CODE( 8, uiCode, "profile_idc" ); pcSPS->setProfileIdc( uiCode );
1485	READ_CODE( 8, uiCode, "reserved_zero_8bits" );
1486	READ_CODE( 8, uiCode, "level_idc" ); pcSPS->setLevelIdc( uiCode );
1487	READ_UVLC( uiCode, "seq_parameter_set_id" ); pcSPS->setSPSId( uiCode );
1488	#if VIDYO_VPS_INTEGRATION
1489	READ_UVLC( uiCode, "video_parameter_set_id" ); pcSPS->setVPSId( uiCode );
1490	#endif
1491	READ_UVLC( uiCode, "chroma_format_idc" ); pcSPS->setChromaFormatIdc( uiCode );
1492	READ_CODE( 3, uiCode, "max_temporal_layers_minus1" ); pcSPS->setMaxTLayers( uiCode+1 );
1493	READ_UVLC ( uiCode, "pic_width_in_luma_samples" ); pcSPS->setPicWidthInLumaSamples ( uiCode );
1494	READ_UVLC ( uiCode, "pic_height_in_luma_samples" ); pcSPS->setPicHeightInLumaSamples( uiCode );
1495	#if PIC_CROPPING
1496	READ_FLAG( uiCode, "pic_cropping_flag"); pcSPS->setPicCroppingFlag ( uiCode ? true : false );
1497	if (uiCode != 0)
1498	{
1499	READ_UVLC( uiCode, "pic_crop_left_offset" ); pcSPS->setPicCropLeftOffset( uiCode );
1500	READ_UVLC( uiCode, "pic_crop_right_offset" ); pcSPS->setPicCropRightOffset( uiCode );
1501	READ_UVLC( uiCode, "pic_crop_top_offset" ); pcSPS->setPicCropTopOffset( uiCode );
1502	READ_UVLC( uiCode, "pic_crop_bottom_offset" ); pcSPS->setPicCropBottomOffset( uiCode );
1503	}
1504	#endif
1505
1506	#if FULL_NBIT
1507	READ_UVLC( uiCode, "bit_depth_luma_minus8" );
1508	g_uiBitDepth = 8 + uiCode;
1509	g_uiBitIncrement = 0;
1510	pcSPS->setBitDepth(g_uiBitDepth);
1511	pcSPS->setBitIncrement(g_uiBitIncrement);
1512	#else
1513	READ_UVLC( uiCode, "bit_depth_luma_minus8" );
1514	g_uiBitDepth = 8;
1515	g_uiBitIncrement = uiCode;
1516	pcSPS->setBitDepth(g_uiBitDepth);
1517	pcSPS->setBitIncrement(g_uiBitIncrement);
1518	#endif
1519
1520	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
1521	g_iDeltaDCsQuantOffset = g_uiBitIncrement - 2;
1522	#endif
1523
1524	#if H0736_AVC_STYLE_QP_RANGE
1525	pcSPS->setQpBDOffsetY( (Int) (6*uiCode) );
1526	#endif
1527
1528	g_uiBASE_MAX = ((1<<(g_uiBitDepth))-1);
1529
1530	#if IBDI_NOCLIP_RANGE
1531	g_uiIBDI_MAX = g_uiBASE_MAX << g_uiBitIncrement;
1532	#else
1533	g_uiIBDI_MAX = ((1<<(g_uiBitDepth+g_uiBitIncrement))-1);
1534	#endif
1535	READ_UVLC( uiCode, "bit_depth_chroma_minus8" );
1536	#if H0736_AVC_STYLE_QP_RANGE
1537	pcSPS->setQpBDOffsetC( (Int) (6*uiCode) );
1538	#endif
1539
1540	READ_FLAG( uiCode, "pcm_enabled_flag" ); pcSPS->setUsePCM( uiCode ? true : false );
1541
1542	if( pcSPS->getUsePCM() )
1543	{
1544	READ_CODE( 4, uiCode, "pcm_bit_depth_luma_minus1" ); pcSPS->setPCMBitDepthLuma ( 1 + uiCode );
1545	READ_CODE( 4, uiCode, "pcm_bit_depth_chroma_minus1" ); pcSPS->setPCMBitDepthChroma ( 1 + uiCode );
1546	}
1547
1548	#if LOSSLESS_CODING
1549	READ_FLAG( uiCode, "qpprime_y_zero_transquant_bypass_flag" ); pcSPS->setUseLossless ( uiCode ? true : false );
1550	#endif
1551
1552	READ_UVLC( uiCode, "log2_max_pic_order_cnt_lsb_minus4" ); pcSPS->setBitsForPOC( 4 + uiCode );
1553	#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
1554	for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
1555	{
1556	READ_UVLC ( uiCode, "max_dec_pic_buffering");
1557	pcSPS->setMaxDecPicBuffering( uiCode, i);
1558	READ_UVLC ( uiCode, "num_reorder_pics" );
1559	pcSPS->setNumReorderPics(uiCode, i);
1560	READ_UVLC ( uiCode, "max_latency_increase");
1561	pcSPS->setMaxLatencyIncrease( uiCode, i );
1562	}
1563	#else
1564	READ_UVLC( uiCode, "max_num_ref_pics" ); pcSPS->setMaxNumberOfReferencePictures(uiCode);
1565	READ_UVLC( uiCode, "num_reorder_frames" ); pcSPS->setNumReorderFrames(uiCode);
1566	READ_UVLC ( uiCode, "max_dec_frame_buffering");
1567	pcSPS->setMaxDecFrameBuffering( uiCode );
1568	READ_UVLC ( uiCode, "max_latency_increase");
1569	pcSPS->setMaxLatencyIncrease( uiCode );
1570	#endif
1571
1572	#if H0412_REF_PIC_LIST_RESTRICTION
1573	READ_FLAG( uiCode, "restricted_ref_pic_lists_flag" );
1574	pcSPS->setRestrictedRefPicListsFlag( uiCode );
1575	if( pcSPS->getRestrictedRefPicListsFlag() )
1576	{
1577	READ_FLAG( uiCode, "lists_modification_present_flag" );
1578	pcSPS->setListsModificationPresentFlag(uiCode);
1579	}
1580	else
1581	{
1582	pcSPS->setListsModificationPresentFlag(true);
1583	}
1584	#endif
1585	READ_UVLC( uiCode, "log2_min_coding_block_size_minus3" );
1586	UInt log2MinCUSize = uiCode + 3;
1587	READ_UVLC( uiCode, "log2_diff_max_min_coding_block_size" );
1588	UInt uiMaxCUDepthCorrect = uiCode;
1589	pcSPS->setMaxCUWidth ( 1<<(log2MinCUSize + uiMaxCUDepthCorrect) ); g_uiMaxCUWidth = 1<<(log2MinCUSize + uiMaxCUDepthCorrect);
1590	pcSPS->setMaxCUHeight ( 1<<(log2MinCUSize + uiMaxCUDepthCorrect) ); g_uiMaxCUHeight = 1<<(log2MinCUSize + uiMaxCUDepthCorrect);
1591	READ_UVLC( uiCode, "log2_min_transform_block_size_minus2" ); pcSPS->setQuadtreeTULog2MinSize( uiCode + 2 );
1592
1593	READ_UVLC( uiCode, "log2_diff_max_min_transform_block_size" ); pcSPS->setQuadtreeTULog2MaxSize( uiCode + pcSPS->getQuadtreeTULog2MinSize() );
1594	pcSPS->setMaxTrSize( 1<<(uiCode + pcSPS->getQuadtreeTULog2MinSize()) );
1595
1596	if(log2MinCUSize == 3)
1597	{
1598	xReadFlag( uiCode ); pcSPS->setDisInter4x4( uiCode ? true : false );
1599	}
1600
1601	if( pcSPS->getUsePCM() )
1602	{
1603	READ_UVLC( uiCode, "log2_min_pcm_coding_block_size_minus3" ); pcSPS->setPCMLog2MinSize (uiCode+3);
1604	READ_UVLC( uiCode, "log2_diff_max_min_pcm_coding_block_size" ); pcSPS->setPCMLog2MaxSize ( uiCode+pcSPS->getPCMLog2MinSize() );
1605	}
1606
1607	READ_UVLC( uiCode, "max_transform_hierarchy_depth_inter" ); pcSPS->setQuadtreeTUMaxDepthInter( uiCode+1 );
1608	READ_UVLC( uiCode, "max_transform_hierarchy_depth_intra" ); pcSPS->setQuadtreeTUMaxDepthIntra( uiCode+1 );
1609	g_uiAddCUDepth = 0;
1610	while( ( pcSPS->getMaxCUWidth() >> uiMaxCUDepthCorrect ) > ( 1 << ( pcSPS->getQuadtreeTULog2MinSize() + g_uiAddCUDepth ) ) )
1611	{
1612	g_uiAddCUDepth++;
1613	}
1614	pcSPS->setMaxCUDepth( uiMaxCUDepthCorrect+g_uiAddCUDepth );
1615	g_uiMaxCUDepth = uiMaxCUDepthCorrect+g_uiAddCUDepth;
1616	// BB: these parameters may be removed completly and replaced by the fixed values
1617	pcSPS->setMinTrDepth( 0 );
1618	pcSPS->setMaxTrDepth( 1 );
1619	READ_FLAG( uiCode, "scaling_list_enabled_flag" ); pcSPS->setScalingListFlag ( uiCode );
1620	READ_FLAG( uiCode, "chroma_pred_from_luma_enabled_flag" ); pcSPS->setUseLMChroma ( uiCode ? true : false );
1621	READ_FLAG( uiCode, "deblocking_filter_in_aps_enabled_flag" ); pcSPS->setUseDF ( uiCode ? true : false );
1622	READ_FLAG( uiCode, "loop_filter_across_slice_flag" ); pcSPS->setLFCrossSliceBoundaryFlag( uiCode ? true : false);
1623	READ_FLAG( uiCode, "asymmetric_motion_partitions_enabled_flag" ); pcSPS->setUseAMP( uiCode );
1624	READ_FLAG( uiCode, "non_square_quadtree_enabled_flag" ); pcSPS->setUseNSQT( uiCode );
1625	READ_FLAG( uiCode, "sample_adaptive_offset_enabled_flag" ); pcSPS->setUseSAO ( uiCode ? true : false );
1626	READ_FLAG( uiCode, "adaptive_loop_filter_enabled_flag" ); pcSPS->setUseALF ( uiCode ? true : false );
1627	#if LCU_SYNTAX_ALF
1628	if(pcSPS->getUseALF())
1629	{
1630	READ_FLAG( uiCode, "alf_coef_in_slice_flag" ); pcSPS->setUseALFCoefInSlice ( uiCode ? true : false );
1631	}
1632	#endif
1633	if( pcSPS->getUsePCM() )
1634	{
1635	READ_FLAG( uiCode, "pcm_loop_filter_disable_flag" ); pcSPS->setPCMFilterDisableFlag ( uiCode ? true : false );
1636	}
1637
1638	READ_FLAG( uiCode, "temporal_id_nesting_flag" ); pcSPS->setTemporalIdNestingFlag ( uiCode > 0 ? true : false );
1639
1640
1641	#if RPS_IN_SPS
1642	TComRPSList* rpsList = pcSPS->getRPSList();
1643	TComReferencePictureSet* rps;
1644
1645	READ_UVLC( uiCode, "num_short_term_ref_pic_sets" );
1646	rpsList->create(uiCode);
1647
1648	for(UInt i=0; i< rpsList->getNumberOfReferencePictureSets(); i++)
1649	{
1650	rps = rpsList->getReferencePictureSet(i);
1651	parseShortTermRefPicSet(pcSPS,rps,i);
1652	}
1653	READ_FLAG( uiCode, "long_term_ref_pics_present_flag" ); pcSPS->setLongTermRefsPresent(uiCode);
1654	#endif
1655	#if !PIC_CROPPING
1656	//!!!KS: Syntax not in WD !!!
1657
1658	xReadUvlc ( uiCode ); pcSPS->setPadX ( uiCode );
1659	xReadUvlc ( uiCode ); pcSPS->setPadY ( uiCode );
1660	#endif
1661
1662	// AMVP mode for each depth (AM_NONE or AM_EXPL)
1663	for (Int i = 0; i < pcSPS->getMaxCUDepth(); i++)
1664	{
1665	xReadFlag( uiCode );
1666	pcSPS->setAMVPMode( i, (AMVP_MODE)uiCode );
1667	}
1668
1669	#if TILES_WPP_ENTRY_POINT_SIGNALLING
1670	READ_CODE(2, uiCode, "tiles_or_entropy_coding_sync_idc"); pcSPS->setTilesOrEntropyCodingSyncIdc(uiCode);
1671	#endif
1672
1673	#if TILES_OR_ENTROPY_SYNC_IDC
1674	if(pcSPS->getTilesOrEntropyCodingSyncIdc() == 1)
1675	{
1676	#endif
1677	READ_UVLC ( uiCode, "num_tile_columns_minus1" );
1678	pcSPS->setNumColumnsMinus1( uiCode );
1679	READ_UVLC ( uiCode, "num_tile_rows_minus1" );
1680	pcSPS->setNumRowsMinus1( uiCode );
1681	READ_FLAG ( uiCode, "uniform_spacing_flag" );
1682	pcSPS->setUniformSpacingIdr( uiCode );
1683	if( pcSPS->getUniformSpacingIdr() == 0 )
1684	{
1685	UInt* columnWidth = (UInt)malloc(pcSPS->getNumColumnsMinus1()sizeof(UInt));
1686	for(UInt i=0; i<pcSPS->getNumColumnsMinus1(); i++)
1687	{
1688	READ_UVLC( uiCode, "column_width" );
1689	columnWidth[i] = uiCode;
1690	}
1691	pcSPS->setColumnWidth(columnWidth);
1692	free(columnWidth);
1693
1694	UInt* rowHeight = (UInt)malloc(pcSPS->getNumRowsMinus1()sizeof(UInt));
1695	for(UInt i=0; i<pcSPS->getNumRowsMinus1(); i++)
1696	{
1697	READ_UVLC( uiCode, "row_height" );
1698	rowHeight[i] = uiCode;
1699	}
1700	pcSPS->setRowHeight(rowHeight);
1701	free(rowHeight);
1702	}
1703	#if !REMOVE_TILE_DEPENDENCE
1704	pcSPS->setTileBoundaryIndependenceIdr( 1 ); //default
1705	#endif
1706	pcSPS->setLFCrossTileBoundaryFlag(true); //default
1707
1708	if( pcSPS->getNumColumnsMinus1() !=0 \|\| pcSPS->getNumRowsMinus1() != 0)
1709	{
1710	#if !REMOVE_TILE_DEPENDENCE
1711	READ_FLAG ( uiCode, "tile_boundary_independence_flag" );
1712	pcSPS->setTileBoundaryIndependenceIdr( uiCode );
1713	if(pcSPS->getTileBoundaryIndependenceIdr() == 1)
1714	{
1715	#endif
1716	READ_FLAG ( uiCode, "loop_filter_across_tile_flag" );
1717	pcSPS->setLFCrossTileBoundaryFlag( (uiCode==1)?true:false);
1718	#if !REMOVE_TILE_DEPENDENCE
1719	}
1720	#endif
1721	}
1722	#if TILES_OR_ENTROPY_SYNC_IDC
1723	}
1724	#endif
1725	READ_FLAG( uiCode, "sps_extension_flag");
1726	#if !QC_MVHEVC_B0046
1727	if(uiCode)
1728	{
1729	READ_FLAG( uiCode, "interview_refs_present_flag");
1730	if(uiCode)
1731	{
1732	READ_UVLC( uiCode, "num_usable_interview_refs_minus1" );
1733	pcSPS->setNumberOfUsableInterViewRefs( uiCode + 1 );
1734
1735	Int prev = 0;
1736	for( Int j = 0 ; j < pcSPS->getNumberOfUsableInterViewRefs(); j++ )
1737	{
1738	READ_UVLC(uiCode, "delta_usable_interview_ref_minus1");
1739	pcSPS->setUsableInterViewRef( j, (prev - uiCode - 1) );
1740	prev = pcSPS->getUsableInterViewRef( j );
1741	}
1742	}
1743
1744	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
1745	READ_FLAG( uiCode, "enable_dmm_flag" );
1746	pcSPS->setUseDMM( uiCode );
1747	#endif
1748
1749	#if HHI_MPI
1750	if( bIsDepth )
1751	{
1752	READ_FLAG( uiCode, "use_mvi_flag" );
1753	pcSPS->setUseMVI( uiCode );
1754	}
1755	#endif
1756	#if OL_QTLIMIT_PREDCODING_B0068
1757	if( bIsDepth )
1758	{
1759	READ_FLAG( uiCode, "use_qtlpc_flag" );
1760	pcSPS->setUseQTLPC( uiCode );
1761	}
1762	#endif
1763
1764	#if RWTH_SDC_DLT_B0036
1765	if( bIsDepth )
1766	{
1767	READ_FLAG( uiCode, "use_dlt_flag" );
1768	pcSPS->setUseDLT( uiCode );
1769	if( pcSPS->getUseDLT() )
1770	{
1771	// decode mapping
1772	UInt uiNumDepthValues;
1773	// parse number of values in DLT
1774	xReadUvlc( uiNumDepthValues );
1775
1776	// parse actual DLT values
1777	UInt* auiIdx2DepthValue = (UInt*) calloc(uiNumDepthValues, sizeof(UInt));
1778	for(UInt d=0; d<uiNumDepthValues; d++)
1779	{
1780	xReadUvlc( uiCode );
1781	auiIdx2DepthValue[d] = uiCode;
1782	}
1783
1784	pcSPS->setDepthLUTs(auiIdx2DepthValue, uiNumDepthValues);
1785
1786	// clean memory
1787	free(auiIdx2DepthValue);
1788	}
1789	else
1790	pcSPS->setDepthLUTs();
1791	}
1792	#endif
1793
1794	READ_FLAG( uiCode, "base_view_flag" );
1795	if( uiCode )
1796	{ // baseview SPS -> set standard values
1797	pcSPS->initMultiviewSPS ( 0 );
1798	#if DEPTH_MAP_GENERATION
1799	pcSPS->setPredDepthMapGeneration( 0, false );
1800	#endif
1801	#if HHI_INTER_VIEW_RESIDUAL_PRED
1802	pcSPS->setMultiviewResPredMode ( 0 );
1803	#endif
1804	}
1805	else
1806	{
1807	READ_FLAG( uiCode, "depth_flag" );
1808	if( uiCode )
1809	{
1810	READ_UVLC( uiCode, "view_id" );
1811	READ_SVLC( iCode, "view_order_idx" );
1812	pcSPS->initMultiviewSPSDepth ( uiCode, iCode );
1813	#if DEPTH_MAP_GENERATION
1814	pcSPS->setPredDepthMapGeneration( uiCode, true );
1815	#endif
1816	#if HHI_INTER_VIEW_RESIDUAL_PRED
1817	pcSPS->setMultiviewResPredMode ( 0 );
1818	#endif
1819	}
1820	else
1821	{
1822	UInt uiViewId, uiCamParPrecision;
1823	Int iVOI;
1824	Bool bCamParSlice;
1825	READ_UVLC( uiViewId, "view_id" ); uiViewId++;
1826	READ_SVLC( iVOI, "view_order_idx" );
1827	READ_UVLC( uiCamParPrecision, "camera_parameter_precision" );
1828	READ_FLAG( uiCode, "camera_parameter_in_slice_header" ); bCamParSlice = ( uiCode == 1 );
1829	if( !bCamParSlice )
1830	{
1831	for( UInt uiBaseId = 0; uiBaseId < uiViewId; uiBaseId++ )
1832	{
1833	READ_SVLC( iCode, "coded_scale" ); m_aaiTempScale [ uiBaseId ][ uiViewId ] = iCode;
1834	READ_SVLC( iCode, "coded_offset" ); m_aaiTempOffset[ uiBaseId ][ uiViewId ] = iCode;
1835	READ_SVLC( iCode, "inverse_coded_scale_plus_coded_scale" ); m_aaiTempScale [ uiViewId ][ uiBaseId ] = iCode - m_aaiTempScale [ uiBaseId ][ uiViewId ];
1836	READ_SVLC( iCode, "inverse_coded_offset_plus_coded_offset" ); m_aaiTempOffset[ uiViewId ][ uiBaseId ] = iCode - m_aaiTempOffset[ uiBaseId ][ uiViewId ];
1837	}
1838	}
1839	pcSPS->initMultiviewSPS( uiViewId, iVOI, uiCamParPrecision, bCamParSlice, m_aaiTempScale, m_aaiTempOffset );
1840
1841	#if DEPTH_MAP_GENERATION
1842	UInt uiPredDepthMapGeneration = 0, uiPdmPrecision = 0;
1843	#if HHI_INTER_VIEW_MOTION_PRED
1844	UInt uiMultiviewMvPredMode = 0;
1845	#endif
1846	#if HHI_INTER_VIEW_RESIDUAL_PRED
1847	UInt uiMultiviewResPredMode = 0;
1848	#endif
1849	READ_UVLC( uiPredDepthMapGeneration, "Pdm_generation" );
1850	if( uiPredDepthMapGeneration )
1851	{
1852	READ_UVLC( uiPdmPrecision, "Pdm_precision" );
1853	for( UInt uiBaseId = 0; uiBaseId < uiViewId; uiBaseId++ )
1854	{
1855	READ_SVLC( iCode, "Pdm_scale_nom_delta" ); m_aaiTempPdmScaleNomDelta[ uiViewId ][ uiBaseId ] = iCode;
1856	READ_SVLC( iCode, "Pdm_offset" ); m_aaiTempPdmOffset [ uiViewId ][ uiBaseId ] = iCode;
1857	}
1858	#if HHI_INTER_VIEW_MOTION_PRED
1859	READ_UVLC( uiMultiviewMvPredMode, "multi_view_mv_pred_mode" );
1860	#endif
1861	#if HHI_INTER_VIEW_RESIDUAL_PRED
1862	READ_FLAG( uiMultiviewResPredMode, "multi_view_residual_pred_mode" );
1863	#endif
1864	}
1865	#if HHI_INTER_VIEW_MOTION_PRED
1866	pcSPS->setPredDepthMapGeneration( uiViewId, false, uiPredDepthMapGeneration, uiMultiviewMvPredMode, uiPdmPrecision, m_aaiTempPdmScaleNomDelta, m_aaiTempPdmOffset );
1867	#else
1868	pcSPS->setPredDepthMapGeneration( uiViewId, false, uiPredDepthMapGeneration, 0, uiPdmPrecision, m_aaiTempPdmScaleNomDelta, m_aaiTempPdmOffset );
1869	#endif
1870	#endif
1871	#if HHI_INTER_VIEW_RESIDUAL_PRED
1872	pcSPS->setMultiviewResPredMode ( uiMultiviewResPredMode );
1873	#endif
1874	}
1875	}
1876	READ_FLAG( uiCode, "sps_extension2_flag");
1877	if (uiCode)
1878	{
1879	while ( xMoreRbspData() )
1880	{
1881	READ_FLAG( uiCode, "sps_extension2_data_flag");
1882	}
1883	}
1884	}
1885	#endif
1886	}
1887
1888	Void TDecCavlc::readTileMarker ( UInt& uiTileIdx, UInt uiBitsUsed )
1889	{
1890	xReadCode ( uiBitsUsed, uiTileIdx );
1891	}
1892
1893	#if LCU_SYNTAX_ALF
1894	#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
1895	Void TDecCavlc::parseSliceHeader (TComSlice& rpcSlice, ParameterSetManagerDecoder parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet, bool isDepth)
1896	#else
1897	Void TDecCavlc::parseSliceHeader (TComSlice& rpcSlice, ParameterSetManagerDecoder parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet)
1898	#endif
1899	#else
1900	Void TDecCavlc::parseSliceHeader (TComSlice& rpcSlice, ParameterSetManagerDecoder parameterSetManager, AlfCUCtrlInfo &alfCUCtrl)
1901	#endif
1902	{
1903	UInt uiCode;
1904	Int iCode;
1905
1906	#if ENC_DEC_TRACE
1907	xTraceSliceHeader(rpcSlice);
1908	#endif
1909	Int numCUs = ((rpcSlice->getSPS()->getPicWidthInLumaSamples()+rpcSlice->getSPS()->getMaxCUWidth()-1)/rpcSlice->getSPS()->getMaxCUWidth())*((rpcSlice->getSPS()->getPicHeightInLumaSamples()+rpcSlice->getSPS()->getMaxCUHeight()-1)/rpcSlice->getSPS()->getMaxCUHeight());
1910	Int maxParts = (1<<(rpcSlice->getSPS()->getMaxCUDepth()<<1));
1911	Int numParts = (1<<(rpcSlice->getPPS()->getSliceGranularity()<<1));
1912	UInt lCUAddress = 0;
1913	Int reqBitsOuter = 0;
1914	while(numCUs>(1<<reqBitsOuter))
1915	{
1916	reqBitsOuter++;
1917	}
1918	Int reqBitsInner = 0;
1919	while((numParts)>(1<<reqBitsInner))
1920	{
1921	reqBitsInner++;
1922	}
1923
1924	READ_FLAG( uiCode, "first_slice_in_pic_flag" );
1925	UInt address;
1926	UInt innerAddress = 0;
1927
1928	#if LGE_ILLUCOMP_B0045
1929	// IC flag is on only first_slice_in_pic
1930	if (uiCode)
1931	{
1932	UInt uiCodeTmp = 0;
1933	if ( rpcSlice->getSPS()->getViewId() && !rpcSlice->getSPS()->isDepth() )
1934	{
1935	READ_FLAG (uiCodeTmp, "applying IC flag");
1936	}
1937	rpcSlice->setApplyIC(uiCodeTmp);
1938	}
1939	#endif
1940
1941	if(!uiCode)
1942	{
1943	READ_CODE( reqBitsOuter+reqBitsInner, address, "slice_address" );
1944	lCUAddress = address >> reqBitsInner;
1945	innerAddress = address - (lCUAddress<<reqBitsInner);
1946	}
1947	//set uiCode to equal slice start address (or entropy slice start address)
1948	uiCode=(maxPartslCUAddress)+(innerAddress(maxParts>>(rpcSlice->getPPS()->getSliceGranularity()<<1)));
1949
1950	rpcSlice->setEntropySliceCurStartCUAddr( uiCode );
1951	rpcSlice->setEntropySliceCurEndCUAddr(numCUs*maxParts);
1952
1953	// slice_type
1954	READ_UVLC ( uiCode, "slice_type" ); rpcSlice->setSliceType((SliceType)uiCode);
1955	// lightweight_slice_flag
1956	READ_FLAG( uiCode, "entropy_slice_flag" );
1957	Bool bEntropySlice = uiCode ? true : false;
1958
1959	if (bEntropySlice)
1960	{
1961	rpcSlice->setNextSlice ( false );
1962	rpcSlice->setNextEntropySlice ( true );
1963	}
1964	else
1965	{
1966	rpcSlice->setNextSlice ( true );
1967	rpcSlice->setNextEntropySlice ( false );
1968
1969	uiCode=(maxPartslCUAddress)+(innerAddress(maxParts>>(rpcSlice->getPPS()->getSliceGranularity()<<1)));
1970	rpcSlice->setSliceCurStartCUAddr(uiCode);
1971	rpcSlice->setSliceCurEndCUAddr(numCUs*maxParts);
1972	}
1973	TComPPS* pps = NULL;
1974	TComSPS* sps = NULL;
1975
1976	if (!bEntropySlice)
1977	{
1978	READ_UVLC ( uiCode, "pic_parameter_set_id" ); rpcSlice->setPPSId(uiCode);
1979	pps = parameterSetManager->getPrefetchedPPS(uiCode);
1980	sps = parameterSetManager->getPrefetchedSPS(pps->getSPSId());
1981	rpcSlice->setSPS(sps);
1982	rpcSlice->setPPS(pps);
1983	#if H0388
1984	if( pps->getOutputFlagPresentFlag() )
1985	{
1986	READ_FLAG( uiCode, "pic_output_flag" );
1987	rpcSlice->setPicOutputFlag( uiCode ? true : false );
1988	}
1989	else
1990	{
1991	rpcSlice->setPicOutputFlag( true );
1992	}
1993	#endif
1994	#if QC_REM_IDV_B0046
1995	#if !QC_MVHEVC_B0046
1996	if(rpcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_IDR && rpcSlice->getSPS()->getViewId() == 0)
1997	#else
1998	if(rpcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_IDR && rpcSlice->getViewId() == 0)
1999	#endif
2000	#else
2001	if(rpcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_IDR)
2002	#endif
2003	{
2004	READ_UVLC( uiCode, "idr_pic_id" ); //ignored
2005	READ_FLAG( uiCode, "no_output_of_prior_pics_flag" ); //ignored
2006	rpcSlice->setPOC(0);
2007	TComReferencePictureSet* rps = rpcSlice->getLocalRPS();
2008	rps->setNumberOfNegativePictures(0);
2009	rps->setNumberOfPositivePictures(0);
2010	rps->setNumberOfLongtermPictures(0);
2011	rps->setNumberOfPictures(0);
2012	rpcSlice->setRPS(rps);
2013	}
2014	else
2015	{
2016	READ_CODE(sps->getBitsForPOC(), uiCode, "pic_order_cnt_lsb");
2017	Int iPOClsb = uiCode;
2018	Int iPrevPOC = rpcSlice->getPrevPOC();
2019	Int iMaxPOClsb = 1<< sps->getBitsForPOC();
2020	Int iPrevPOClsb = iPrevPOC%iMaxPOClsb;
2021	Int iPrevPOCmsb = iPrevPOC-iPrevPOClsb;
2022	Int iPOCmsb;
2023	if( ( iPOClsb < iPrevPOClsb ) && ( ( iPrevPOClsb - iPOClsb ) >= ( iMaxPOClsb / 2 ) ) )
2024	{
2025	iPOCmsb = iPrevPOCmsb + iMaxPOClsb;
2026	}
2027	else if( (iPOClsb > iPrevPOClsb ) && ( (iPOClsb - iPrevPOClsb ) > ( iMaxPOClsb / 2 ) ) )
2028	{
2029	iPOCmsb = iPrevPOCmsb - iMaxPOClsb;
2030	}
2031	else
2032	{
2033	iPOCmsb = iPrevPOCmsb;
2034	}
2035	rpcSlice->setPOC( iPOCmsb+iPOClsb );
2036	#if QC_REM_IDV_B0046
2037	#if !QC_MVHEVC_B0046
2038	if( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR && rpcSlice->getSPS()->getViewId() && rpcSlice->getPOC() == 0 )
2039	#else
2040	if( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR && rpcSlice->getViewId() && rpcSlice->getPOC() == 0 )
2041	#endif
2042	#else
2043	if( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDV && rpcSlice->getPOC() == 0 )
2044	#endif
2045	{
2046	TComReferencePictureSet* rps = rpcSlice->getLocalRPS();
2047	rps->setNumberOfNegativePictures(0);
2048	rps->setNumberOfPositivePictures(0);
2049	rps->setNumberOfLongtermPictures(0);
2050	rps->setNumberOfPictures(0);
2051	rpcSlice->setRPS(rps);
2052	}
2053	else
2054	{
2055	TComReferencePictureSet* rps;
2056	READ_FLAG( uiCode, "short_term_ref_pic_set_sps_flag" );
2057	if(uiCode == 0) // use short-term reference picture set explicitly signalled in slice header
2058	{
2059	rps = rpcSlice->getLocalRPS();
2060	#if RPS_IN_SPS
2061	parseShortTermRefPicSet(sps,rps, sps->getRPSList()->getNumberOfReferencePictureSets());
2062	#else
2063	parseShortTermRefPicSet(pps,rps, pps->getRPSList()->getNumberOfReferencePictureSets());
2064	#endif
2065	rpcSlice->setRPS(rps);
2066	}
2067	else // use reference to short-term reference picture set in PPS
2068	{
2069	#if RPS_IN_SPS
2070	READ_UVLC( uiCode, "short_term_ref_pic_set_idx"); rpcSlice->setRPS(sps->getRPSList()->getReferencePictureSet(uiCode));
2071	#else
2072	READ_UVLC( uiCode, "short_term_ref_pic_set_idx"); rpcSlice->setRPS(pps->getRPSList()->getReferencePictureSet(uiCode));
2073	#endif
2074	rps = rpcSlice->getRPS();
2075	}
2076	#if RPS_IN_SPS
2077	if(sps->getLongTermRefsPresent())
2078	#else
2079	if(pps->getLongTermRefsPresent())
2080	#endif
2081	{
2082	Int offset = rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures();
2083	READ_UVLC( uiCode, "num_long_term_pics"); rps->setNumberOfLongtermPictures(uiCode);
2084	Int prev = 0;
2085	#if LTRP_MULT
2086	Int prevMsb=0;
2087	Int prevDeltaPocLt=0;
2088	#endif
2089	for(Int j=rps->getNumberOfLongtermPictures()+offset-1 ; j > offset-1; j--)
2090	{
2091	READ_UVLC(uiCode,"delta_poc_lsb_lt");
2092	prev += uiCode;
2093
2094	#if LTRP_MULT
2095	READ_FLAG(uiCode,"delta_poc_msb_present_flag");
2096	Int decDeltaPOCMsbPresent=uiCode;
2097
2098	if(decDeltaPOCMsbPresent==1)
2099	{
2100	READ_UVLC(uiCode, "delta_poc_msb_cycle_lt_minus1");
2101	if( (j==(rps->getNumberOfLongtermPictures()+offset-1)) \|\| (prev!=prevDeltaPocLt) )
2102	{
2103	prevMsb=(1+uiCode);
2104	}
2105	else
2106	{
2107	prevMsb+=(1+uiCode);
2108	}
2109	Int decMaxPocLsb = 1<<rpcSlice->getSPS()->getBitsForPOC();
2110	rps->setPOC(j,rpcSlice->getPOC()-prev-(prevMsb)*decMaxPocLsb);
2111	rps->setDeltaPOC(j,-(Int)(prev+(prevMsb)*decMaxPocLsb));
2112	}
2113	else
2114	{
2115	#endif
2116	rps->setPOC(j,rpcSlice->getPOC()-prev);
2117	rps->setDeltaPOC(j,-(Int)prev);
2118	#if LTRP_MULT
2119	}
2120	prevDeltaPocLt=prev;
2121	#endif
2122	READ_FLAG( uiCode, "used_by_curr_pic_lt_flag"); rps->setUsed(j,uiCode);
2123	}
2124	offset += rps->getNumberOfLongtermPictures();
2125	rps->setNumberOfPictures(offset);
2126	}
2127	}
2128	}
2129
2130	if(sps->getUseSAO() \|\| sps->getUseALF() \|\| sps->getScalingListFlag() \|\| sps->getUseDF())
2131	{
2132	//!!!KS: order is different in WD5!
2133	if (sps->getUseALF())
2134	{
2135	READ_FLAG(uiCode, "slice_adaptive_loop_filter_flag");
2136	rpcSlice->setAlfEnabledFlag((Bool)uiCode);
2137	}
2138	if (sps->getUseSAO())
2139	{
2140	#if SAO_UNIT_INTERLEAVING
2141	READ_FLAG(uiCode, "slice_sao_interleaving_flag"); rpcSlice->setSaoInterleavingFlag(uiCode);
2142	#endif
2143	READ_FLAG(uiCode, "slice_sample_adaptive_offset_flag"); rpcSlice->setSaoEnabledFlag((Bool)uiCode);
2144	#if SAO_UNIT_INTERLEAVING
2145	if (rpcSlice->getSaoEnabledFlag() && rpcSlice->getSaoInterleavingFlag())
2146	{
2147	READ_FLAG(uiCode, "sao_cb_enable_flag"); rpcSlice->setSaoEnabledFlagCb((Bool)uiCode);
2148	READ_FLAG(uiCode, "sao_cr_enable_flag"); rpcSlice->setSaoEnabledFlagCr((Bool)uiCode);
2149	}
2150	else
2151	{
2152	rpcSlice->setSaoEnabledFlagCb(0);
2153	rpcSlice->setSaoEnabledFlagCr(0);
2154	}
2155	#endif
2156	}
2157	READ_UVLC ( uiCode, "aps_id" ); rpcSlice->setAPSId(uiCode);
2158	}
2159	if (!rpcSlice->isIntra())
2160	{
2161	READ_FLAG( uiCode, "num_ref_idx_active_override_flag");
2162	if (uiCode)
2163	{
2164	READ_CODE (3, uiCode, "num_ref_idx_l0_active_minus1" ); rpcSlice->setNumRefIdx( REF_PIC_LIST_0, uiCode + 1 );
2165	if (rpcSlice->isInterB())
2166	{
2167	READ_CODE (3, uiCode, "num_ref_idx_l1_active_minus1" ); rpcSlice->setNumRefIdx( REF_PIC_LIST_1, uiCode + 1 );
2168	}
2169	else
2170	{
2171	rpcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
2172	}
2173	}
2174	else
2175	{
2176	rpcSlice->setNumRefIdx(REF_PIC_LIST_0, 0);
2177	rpcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
2178	}
2179	}
2180	TComRefPicListModification* refPicListModification = rpcSlice->getRefPicListModification();
2181	if( !rpcSlice->isIntra() )
2182	{
2183	#if H0412_REF_PIC_LIST_RESTRICTION
2184	#if QC_MVHEVC_B0046
2185	if( !rpcSlice->getViewId() \|\| !rpcSlice->getSPS()->getListsModificationPresentFlag() )
2186	#else
2187	if( !rpcSlice->getSPS()->getListsModificationPresentFlag() )
2188	#endif
2189	{
2190	refPicListModification->setRefPicListModificationFlagL0( 0 );
2191	}
2192	else
2193	{
2194	#endif
2195	READ_FLAG( uiCode, "ref_pic_list_modification_flag_l0" ); refPicListModification->setRefPicListModificationFlagL0( uiCode ? 1 : 0 );
2196	#if H0412_REF_PIC_LIST_RESTRICTION
2197	}
2198	#endif
2199
2200	if(refPicListModification->getRefPicListModificationFlagL0())
2201	{
2202	uiCode = 0;
2203	Int i = 0;
2204	#if H0137_0138_LIST_MODIFICATION
2205	Int NumPocTotalCurr = rpcSlice->getNumPocTotalCurrMvc();
2206	if ( NumPocTotalCurr > 1 )
2207	{
2208	Int length = 1;
2209	NumPocTotalCurr --;
2210	while ( NumPocTotalCurr >>= 1)
2211	{
2212	length ++;
2213	}
2214	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
2215	{
2216	READ_CODE( length, uiCode, "list_entry_l0" );
2217	refPicListModification->setRefPicSetIdxL0(i, uiCode );
2218	}
2219	}
2220	else
2221	{
2222	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
2223	{
2224	refPicListModification->setRefPicSetIdxL0(i, 0 );
2225	}
2226	}
2227	#else
2228	Int list_modification_idc = 0;
2229	while(list_modification_idc != 3)
2230	{
2231	READ_UVLC( uiCode, "list_modification_idc" ); refPicListModification->setListIdcL0(i, uiCode );
2232	list_modification_idc = uiCode;
2233	if(uiCode != 3)
2234	{
2235	READ_UVLC( uiCode, "ref_pic_set_idx" ); refPicListModification->setRefPicSetIdxL0(i, uiCode );
2236	}
2237	i++;
2238	}
2239	refPicListModification->setNumberOfRefPicListModificationsL0(i-1);
2240	#endif
2241	}
2242	#if !H0137_0138_LIST_MODIFICATION
2243	else
2244	{
2245	refPicListModification->setNumberOfRefPicListModificationsL0(0);
2246	}
2247	#endif
2248	}
2249	else
2250	{
2251	refPicListModification->setRefPicListModificationFlagL0(0);
2252	#if !H0137_0138_LIST_MODIFICATION
2253	refPicListModification->setNumberOfRefPicListModificationsL0(0);
2254	#endif
2255	}
2256	if(rpcSlice->isInterB())
2257	{
2258	#if H0412_REF_PIC_LIST_RESTRICTION
2259	#if QC_MVHEVC_B0046
2260	if( !rpcSlice->getViewId() \|\| !rpcSlice->getSPS()->getListsModificationPresentFlag() )
2261	#else
2262	if( !rpcSlice->getSPS()->getListsModificationPresentFlag() )
2263	#endif
2264	{
2265	refPicListModification->setRefPicListModificationFlagL1( 0 );
2266	}
2267	else
2268	{
2269	#endif
2270	READ_FLAG( uiCode, "ref_pic_list_modification_flag_l1" ); refPicListModification->setRefPicListModificationFlagL1( uiCode ? 1 : 0 );
2271	#if H0412_REF_PIC_LIST_RESTRICTION
2272	}
2273	#endif
2274	if(refPicListModification->getRefPicListModificationFlagL1())
2275	{
2276	uiCode = 0;
2277	Int i = 0;
2278	#if H0137_0138_LIST_MODIFICATION
2279	Int NumPocTotalCurr = rpcSlice->getNumPocTotalCurrMvc();
2280	if ( NumPocTotalCurr > 1 )
2281	{
2282	Int length = 1;
2283	NumPocTotalCurr --;
2284	while ( NumPocTotalCurr >>= 1)
2285	{
2286	length ++;
2287	}
2288	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
2289	{
2290	READ_CODE( length, uiCode, "list_entry_l1" );
2291	refPicListModification->setRefPicSetIdxL1(i, uiCode );
2292	}
2293	}
2294	else
2295	{
2296	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
2297	{
2298	refPicListModification->setRefPicSetIdxL1(i, 0 );
2299	}
2300	}
2301	#else
2302	Int list_modification_idc = 0;
2303	while(list_modification_idc != 3)
2304	{
2305	READ_UVLC( uiCode, "list_modification_idc" ); refPicListModification->setListIdcL1(i, uiCode );
2306	list_modification_idc = uiCode;
2307	if(uiCode != 3)
2308	{
2309	READ_UVLC( uiCode, "ref_pic_set_idx" ); refPicListModification->setRefPicSetIdxL1(i, uiCode );
2310	}
2311	i++;
2312	}
2313	refPicListModification->setNumberOfRefPicListModificationsL1(i-1);
2314	#endif
2315	}
2316	#if !H0137_0138_LIST_MODIFICATION
2317	else
2318	{
2319	refPicListModification->setNumberOfRefPicListModificationsL1(0);
2320	}
2321	#endif
2322	}
2323	else
2324	{
2325	refPicListModification->setRefPicListModificationFlagL1(0);
2326	#if !H0137_0138_LIST_MODIFICATION
2327	refPicListModification->setNumberOfRefPicListModificationsL1(0);
2328	#endif
2329	}
2330	}
2331	else
2332	{
2333	// initialize from previous slice
2334	pps = rpcSlice->getPPS();
2335	sps = rpcSlice->getSPS();
2336	}
2337	// ref_pic_list_combination( )
2338	//!!!KS: ref_pic_list_combination() should be conditioned on entropy_slice_flag
2339	if (rpcSlice->isInterB())
2340	{
2341	READ_FLAG( uiCode, "ref_pic_list_combination_flag" ); rpcSlice->setRefPicListCombinationFlag( uiCode ? 1 : 0 );
2342	if(uiCode)
2343	{
2344	READ_UVLC( uiCode, "num_ref_idx_lc_active_minus1" ); rpcSlice->setNumRefIdx( REF_PIC_LIST_C, uiCode + 1 );
2345
2346	#if H0412_REF_PIC_LIST_RESTRICTION
2347	#if QC_MVHEVC_B0046
2348	if( rpcSlice->getViewId() && rpcSlice->getSPS()->getListsModificationPresentFlag() )
2349	#else
2350	if(rpcSlice->getSPS()->getListsModificationPresentFlag() )
2351	#endif
2352	{
2353	#endif
2354	READ_FLAG( uiCode, "ref_pic_list_modification_flag_lc" ); rpcSlice->setRefPicListModificationFlagLC( uiCode ? 1 : 0 );
2355	if(uiCode)
2356	{
2357	for (UInt i=0;i<rpcSlice->getNumRefIdx(REF_PIC_LIST_C);i++)
2358	{
2359	READ_FLAG( uiCode, "pic_from_list_0_flag" );
2360	rpcSlice->setListIdFromIdxOfLC(i, uiCode);
2361	#if H0137_0138_LIST_MODIFICATION
2362	if (((rpcSlice->getListIdFromIdxOfLC(i) == REF_PIC_LIST_0) && (rpcSlice->getNumRefIdx( REF_PIC_LIST_0 ) == 1)) \|\| ((rpcSlice->getListIdFromIdxOfLC(i) == REF_PIC_LIST_1) && (rpcSlice->getNumRefIdx( REF_PIC_LIST_1 ) == 1)) )
2363	{
2364	uiCode = 0;
2365	}
2366	else
2367	{
2368	READ_UVLC( uiCode, "ref_idx_list_curr" );
2369	}
2370	#else
2371	READ_UVLC( uiCode, "ref_idx_list_curr" );
2372	#endif
2373	rpcSlice->setRefIdxFromIdxOfLC(i, uiCode);
2374	rpcSlice->setRefIdxOfLC((RefPicList)rpcSlice->getListIdFromIdxOfLC(i), rpcSlice->getRefIdxFromIdxOfLC(i), i);
2375	}
2376	}
2377	#if H0412_REF_PIC_LIST_RESTRICTION
2378	}
2379	else
2380	{
2381	rpcSlice->setRefPicListModificationFlagLC(false);
2382	}
2383	#endif
2384	}
2385	else
2386	{
2387	rpcSlice->setRefPicListModificationFlagLC(false);
2388	rpcSlice->setNumRefIdx(REF_PIC_LIST_C, 0);
2389	}
2390	}
2391	else
2392	{
2393	rpcSlice->setRefPicListCombinationFlag(false);
2394	}
2395
2396	#if H0111_MVD_L1_ZERO
2397	if (rpcSlice->isInterB())
2398	{
2399	READ_FLAG( uiCode, "mvd_l1_zero_flag" ); rpcSlice->setMvdL1ZeroFlag( (uiCode ? true : false) );
2400	}
2401	#endif
2402
2403	#if CABAC_INIT_FLAG
2404	rpcSlice->setCabacInitFlag( false ); // default
2405	if(pps->getCabacInitPresentFlag() && !rpcSlice->isIntra())
2406	{
2407	READ_FLAG(uiCode, "cabac_init_flag");
2408	rpcSlice->setCabacInitFlag( uiCode ? true : false );
2409	}
2410	#else
2411	if(pps->getEntropyCodingMode() && !rpcSlice->isIntra())
2412	{
2413	READ_UVLC(uiCode, "cabac_init_idc");
2414	rpcSlice->setCABACinitIDC(uiCode);
2415	}
2416	else if (pps->getEntropyCodingMode() && rpcSlice->isIntra())
2417	{
2418	rpcSlice->setCABACinitIDC(0);
2419	}
2420	#endif
2421
2422	if(!bEntropySlice)
2423	{
2424	READ_SVLC( iCode, "slice_qp_delta" );
2425	rpcSlice->setSliceQp (26 + pps->getPicInitQPMinus26() + iCode);
2426
2427	#if H0736_AVC_STYLE_QP_RANGE
2428	assert( rpcSlice->getSliceQp() >= -sps->getQpBDOffsetY() );
2429	assert( rpcSlice->getSliceQp() <= 51 );
2430	#endif
2431
2432	#if DBL_CONTROL
2433	if (rpcSlice->getPPS()->getDeblockingFilterControlPresent())
2434	{
2435	if ( rpcSlice->getSPS()->getUseDF() )
2436	{
2437	READ_FLAG ( uiCode, "inherit_dbl_param_from_APS_flag" ); rpcSlice->setInheritDblParamFromAPS(uiCode ? 1 : 0);
2438	} else
2439	{
2440	rpcSlice->setInheritDblParamFromAPS(0);
2441	}
2442	#else
2443	READ_FLAG ( uiCode, "inherit_dbl_param_from_APS_flag" ); rpcSlice->setInheritDblParamFromAPS(uiCode ? 1 : 0);
2444	#endif
2445	if(!rpcSlice->getInheritDblParamFromAPS())
2446	{
2447	READ_FLAG ( uiCode, "disable_deblocking_filter_flag" ); rpcSlice->setLoopFilterDisable(uiCode ? 1 : 0);
2448	if(!rpcSlice->getLoopFilterDisable())
2449	{
2450	READ_SVLC( iCode, "beta_offset_div2" ); rpcSlice->setLoopFilterBetaOffset(iCode);
2451	READ_SVLC( iCode, "tc_offset_div2" ); rpcSlice->setLoopFilterTcOffset(iCode);
2452	}
2453	}
2454	#if DBL_CONTROL
2455	}
2456	#endif
2457	if ( rpcSlice->getSliceType() == B_SLICE )
2458	{
2459	READ_FLAG( uiCode, "collocated_from_l0_flag" );
2460	rpcSlice->setColDir(uiCode);
2461	}
2462
2463	#if COLLOCATED_REF_IDX
2464	if ( rpcSlice->getSliceType() != I_SLICE &&
2465	((rpcSlice->getColDir()==0 && rpcSlice->getNumRefIdx(REF_PIC_LIST_0)>1)\|\|
2466	(rpcSlice->getColDir() ==1 && rpcSlice->getNumRefIdx(REF_PIC_LIST_1)>1)))
2467	{
2468	READ_UVLC( uiCode, "collocated_ref_idx" );
2469	rpcSlice->setColRefIdx(uiCode);
2470	}
2471	#endif
2472
2473	if ( (pps->getUseWP() && rpcSlice->getSliceType()==P_SLICE) \|\| (pps->getWPBiPredIdc() && rpcSlice->getSliceType()==B_SLICE) )
2474	{
2475	xParsePredWeightTable(rpcSlice);
2476	rpcSlice->initWpScaling();
2477	}
2478	}
2479
2480	if (!bEntropySlice)
2481	{
2482	if( rpcSlice->getSPS()->hasCamParInSliceHeader() )
2483	{
2484	UInt uiViewId = rpcSlice->getSPS()->getViewId();
2485	for( UInt uiBaseId = 0; uiBaseId < uiViewId; uiBaseId++ )
2486	{
2487	READ_SVLC( iCode, "coded_scale" ); m_aaiTempScale [ uiBaseId ][ uiViewId ] = iCode;
2488	READ_SVLC( iCode, "coded_offset" ); m_aaiTempOffset[ uiBaseId ][ uiViewId ] = iCode;
2489	READ_SVLC( iCode, "inverse_coded_scale_plus_coded_scale" ); m_aaiTempScale [ uiViewId ][ uiBaseId ] = iCode - m_aaiTempScale [ uiBaseId ][ uiViewId ];
2490	READ_SVLC( iCode, "inverse_coded_offset_plus_coded_offset" ); m_aaiTempOffset[ uiViewId ][ uiBaseId ] = iCode - m_aaiTempOffset[ uiBaseId ][ uiViewId ];
2491	}
2492	rpcSlice->initMultiviewSlice( m_aaiTempScale, m_aaiTempOffset );
2493	}
2494	}
2495
2496	#if ( HHI_MPI \|\| HHI_INTER_VIEW_MOTION_PRED )
2497	#if ( HHI_MPI && HHI_INTER_VIEW_MOTION_PRED )
2498	const int iExtraMergeCandidates = ( sps->getUseMVI() \|\| sps->getMultiviewMvPredMode() ) ? 1 : 0;
2499	#elif HHI_MPI
2500	const int iExtraMergeCandidates = sps->getUseMVI() ? 1 : 0;
2501	#elif MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
2502	const int iExtraMergeCandidates = ( (isDepth \|\| sps->getMultiviewMvPredMode()) ) ? 1 : 0;
2503	#else
2504	const int iExtraMergeCandidates = sps->getMultiviewMvPredMode() ? 1 : 0;
2505	#endif
2506	READ_UVLC( uiCode, "5_minus_max_num_merge_cand");
2507	rpcSlice->setMaxNumMergeCand(MRG_MAX_NUM_CANDS + iExtraMergeCandidates - uiCode);
2508	assert(rpcSlice->getMaxNumMergeCand()==(MRG_MAX_NUM_CANDS_SIGNALED+iExtraMergeCandidates));
2509	#else
2510	READ_UVLC( uiCode, "5_minus_max_num_merge_cand");
2511	rpcSlice->setMaxNumMergeCand(MRG_MAX_NUM_CANDS - uiCode);
2512	assert(rpcSlice->getMaxNumMergeCand()==MRG_MAX_NUM_CANDS_SIGNALED);
2513	#endif
2514
2515	if (!bEntropySlice)
2516	{
2517	if(sps->getUseALF() && rpcSlice->getAlfEnabledFlag())
2518	{
2519	UInt uiNumLCUsInWidth = sps->getPicWidthInLumaSamples() / g_uiMaxCUWidth;
2520	UInt uiNumLCUsInHeight = sps->getPicHeightInLumaSamples() / g_uiMaxCUHeight;
2521
2522	uiNumLCUsInWidth += ( sps->getPicWidthInLumaSamples() % g_uiMaxCUWidth ) ? 1 : 0;
2523	uiNumLCUsInHeight += ( sps->getPicHeightInLumaSamples() % g_uiMaxCUHeight ) ? 1 : 0;
2524
2525	Int uiNumCUsInFrame = uiNumLCUsInWidth* uiNumLCUsInHeight;
2526	#if LCU_SYNTAX_ALF
2527	if(sps->getUseALFCoefInSlice())
2528	{
2529	alfParamSet.releaseALFParam();
2530	alfParamSet.init();
2531	Bool isAcrossSlice = sps->getLFCrossSliceBoundaryFlag();
2532	Int numSUinLCU = 1<< (g_uiMaxCUDepth << 1);
2533	Int firstLCUAddr = rpcSlice->getSliceCurStartCUAddr() / numSUinLCU;
2534	xParseAlfParam(&alfParamSet, false, firstLCUAddr, isAcrossSlice, uiNumLCUsInWidth, uiNumLCUsInHeight);
2535	}
2536
2537	if(!sps->getUseALFCoefInSlice())
2538	{
2539	#endif
2540	xParseAlfCuControlParam(alfCUCtrl, uiNumCUsInFrame);
2541	#if LCU_SYNTAX_ALF
2542	}
2543	#endif
2544
2545	}
2546	}
2547
2548	//!!!KS: The following syntax is not aligned with the working draft, TRACE support needs to be added
2549	rpcSlice->setTileMarkerFlag ( 0 ); // default
2550	if (!bEntropySlice)
2551	{
2552	#if !REMOVE_TILE_DEPENDENCE
2553	if (sps->getTileBoundaryIndependenceIdr())
2554	{
2555	#endif
2556	xReadCode(1, uiCode); // read flag indicating if tile markers transmitted
2557	rpcSlice->setTileMarkerFlag( uiCode );
2558	#if !REMOVE_TILE_DEPENDENCE
2559	}
2560	#endif
2561	}
2562
2563	#if TILES_WPP_ENTRY_POINT_SIGNALLING
2564	Int tilesOrEntropyCodingSyncIdc = rpcSlice->getSPS()->getTilesOrEntropyCodingSyncIdc();
2565	UInt *entryPointOffset = NULL;
2566	UInt numEntryPointOffsets, offsetLenMinus1;
2567
2568	rpcSlice->setNumEntryPointOffsets ( 0 ); // default
2569
2570	if (tilesOrEntropyCodingSyncIdc>0)
2571	{
2572	READ_UVLC(numEntryPointOffsets, "num_entry_point_offsets"); rpcSlice->setNumEntryPointOffsets ( numEntryPointOffsets );
2573	if (numEntryPointOffsets>0)
2574	{
2575	READ_UVLC(offsetLenMinus1, "offset_len_minus1");
2576	}
2577	entryPointOffset = new UInt[numEntryPointOffsets];
2578	for (UInt idx=0; idx<numEntryPointOffsets; idx++)
2579	{
2580	Int bitsRead = m_pcBitstream->getNumBitsRead();
2581	READ_CODE(offsetLenMinus1+1, uiCode, "entry_point_offset");
2582	entryPointOffset[ idx ] = uiCode;
2583	if ( idx == 0 && tilesOrEntropyCodingSyncIdc == 2 )
2584	{
2585	// Subtract distance from NALU header start to provide WPP 0-th substream the correct size.
2586	entryPointOffset[ idx ] -= ( bitsRead + numEntryPointOffsets*(offsetLenMinus1+1) ) >> 3;
2587	}
2588	}
2589	}
2590
2591	if ( tilesOrEntropyCodingSyncIdc == 1 ) // tiles
2592	{
2593	rpcSlice->setTileLocationCount( numEntryPointOffsets );
2594
2595	UInt prevPos = 0;
2596	for (Int idx=0; idx<rpcSlice->getTileLocationCount(); idx++)
2597	{
2598	rpcSlice->setTileLocation( idx, prevPos + entryPointOffset [ idx ] );
2599	prevPos += entryPointOffset[ idx ];
2600	}
2601	}
2602	else if ( tilesOrEntropyCodingSyncIdc == 2 ) // wavefront
2603	{
2604	Int numSubstreams = pps->getNumSubstreams();
2605	rpcSlice->allocSubstreamSizes(numSubstreams);
2606	UInt *pSubstreamSizes = rpcSlice->getSubstreamSizes();
2607	for (Int idx=0; idx<numSubstreams-1; idx++)
2608	{
2609	if ( idx < numEntryPointOffsets )
2610	{
2611	pSubstreamSizes[ idx ] = ( entryPointOffset[ idx ] << 3 ) ;
2612	}
2613	else
2614	{
2615	pSubstreamSizes[ idx ] = 0;
2616	}
2617	}
2618	}
2619
2620	if (entryPointOffset)
2621	{
2622	delete [] entryPointOffset;
2623	}
2624	#else
2625	#if WPP_SIMPLIFICATION
2626	if (pps->getNumSubstreams() > 1)
2627	#else
2628	if (pps->getEntropyCodingSynchro())
2629	#endif
2630	{
2631	UInt uiNumSubstreams = pps->getNumSubstreams();
2632	rpcSlice->allocSubstreamSizes(uiNumSubstreams);
2633	UInt *puiSubstreamSizes = rpcSlice->getSubstreamSizes();
2634
2635	for (UInt ui = 0; ui+1 < uiNumSubstreams; ui++)
2636	{
2637	xReadCode(2, uiCode);
2638
2639	switch ( uiCode )
2640	{
2641	case 0:
2642	xReadCode(8, uiCode);
2643	break;
2644	case 1:
2645	xReadCode(16, uiCode);
2646	break;
2647	case 2:
2648	xReadCode(24, uiCode);
2649	break;
2650	case 3:
2651	xReadCode(32, uiCode);
2652	break;
2653	default:
2654	printf("Error in parseSliceHeader\n");
2655	exit(-1);
2656	break;
2657	}
2658	puiSubstreamSizes[ui] = uiCode;
2659	}
2660	}
2661	#endif
2662
2663	if (!bEntropySlice)
2664	{
2665	// Reading location information
2666	#if !REMOVE_TILE_DEPENDENCE
2667	if (sps->getTileBoundaryIndependenceIdr())
2668	{
2669	#endif
2670	#if !TILES_WPP_ENTRY_POINT_SIGNALLING
2671	xReadCode(1, uiCode); // read flag indicating if location information signaled in slice header
2672	Bool bTileLocationInformationInSliceHeaderFlag = (uiCode)? true : false;
2673
2674	if (bTileLocationInformationInSliceHeaderFlag)
2675	{
2676	// location count
2677	xReadCode(5, uiCode); // number of tiles for which location information signaled
2678	rpcSlice->setTileLocationCount ( uiCode + 1 );
2679
2680	xReadCode(5, uiCode); // number of bits used by diff
2681	Int iBitsUsedByDiff = uiCode + 1;
2682
2683	// read out tile start location
2684	Int iLastSize = 0;
2685	for (UInt uiIdx=0; uiIdx<rpcSlice->getTileLocationCount(); uiIdx++)
2686	{
2687	Int iAbsDiff, iCurSize, iCurDiff;
2688	if (uiIdx==0)
2689	{
2690	xReadCode(iBitsUsedByDiff-1, uiCode); iAbsDiff = uiCode;
2691	rpcSlice->setTileLocation( uiIdx, iAbsDiff );
2692	iCurDiff = iAbsDiff;
2693	iLastSize = iAbsDiff;
2694	}
2695	else
2696	{
2697	xReadCode(1, uiCode); // read sign
2698	Int iSign = (uiCode) ? -1 : +1;
2699
2700	xReadCode(iBitsUsedByDiff-1, uiCode); iAbsDiff = uiCode;
2701	iCurDiff = (iSign) * iAbsDiff;
2702	iCurSize = iLastSize + iCurDiff;
2703	iLastSize = iCurSize;
2704	rpcSlice->setTileLocation( uiIdx, rpcSlice->getTileLocation( uiIdx-1 ) + iCurSize ); // calculate byte location
2705	}
2706	}
2707	}
2708	#endif
2709
2710	// read out trailing bits
2711	m_pcBitstream->readOutTrailingBits();
2712	#if !REMOVE_TILE_DEPENDENCE
2713	}
2714	#endif
2715	}
2716	return;
2717	}
2718
2719	Void TDecCavlc::xParseAlfCuControlParam(AlfCUCtrlInfo& cAlfParam, Int iNumCUsInPic)
2720	{
2721	UInt uiSymbol;
2722	Int iSymbol;
2723
2724	READ_FLAG (uiSymbol, "alf_cu_control_flag");
2725	cAlfParam.cu_control_flag = uiSymbol;
2726	if (cAlfParam.cu_control_flag)
2727	{
2728	READ_UVLC (uiSymbol, "alf_cu_control_max_depth");
2729	cAlfParam.alf_max_depth = uiSymbol;
2730
2731	READ_SVLC (iSymbol, "alf_length_cu_control_info");
2732	cAlfParam.num_alf_cu_flag = (UInt)(iSymbol + iNumCUsInPic);
2733
2734	cAlfParam.alf_cu_flag.resize(cAlfParam.num_alf_cu_flag);
2735
2736	for(UInt i=0; i< cAlfParam.num_alf_cu_flag; i++)
2737	{
2738	READ_FLAG (cAlfParam.alf_cu_flag[i], "alf_cu_flag");
2739	}
2740	}
2741	}
2742
2743	#if !CABAC_INIT_FLAG
2744	Void TDecCavlc::resetEntropy (TComSlice* pcSlice)
2745	{
2746	}
2747	#endif
2748
2749	Void TDecCavlc::parseTerminatingBit( UInt& ruiBit )
2750	{
2751	ruiBit = false;
2752	Int iBitsLeft = m_pcBitstream->getNumBitsLeft();
2753	if(iBitsLeft <= 8)
2754	{
2755	UInt uiPeekValue = m_pcBitstream->peekBits(iBitsLeft);
2756	if (uiPeekValue == (1<<(iBitsLeft-1)))
2757	{
2758	ruiBit = true;
2759	}
2760	}
2761	}
2762
2763	Void TDecCavlc::parseSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2764	{
2765	assert(0);
2766	}
2767
2768	#if LGE_ILLUCOMP_B0045
2769	Void TDecCavlc::parseICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2770	{
2771	assert(0);
2772	}
2773	#endif
2774
2775	#if HHI_INTER_VIEW_MOTION_PRED
2776	Void TDecCavlc::parseMVPIdx( Int& riMVPIdx, Int iAMVPCands )
2777	#else
2778	Void TDecCavlc::parseMVPIdx( Int& riMVPIdx )
2779	#endif
2780	{
2781	assert(0);
2782	}
2783
2784	Void TDecCavlc::parseSplitFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2785	{
2786	assert(0);
2787	}
2788
2789	Void TDecCavlc::parsePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2790	{
2791	assert(0);
2792	}
2793
2794	Void TDecCavlc::parsePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2795	{
2796	assert(0);
2797	}
2798
2799	/** Parse I_PCM information.
2800	* \param pcCU pointer to CU
2801	* \param uiAbsPartIdx CU index
2802	* \param uiDepth CU depth
2803	* \returns Void
2804	*
2805	* If I_PCM flag indicates that the CU is I_PCM, parse its PCM alignment bits and codes.
2806	*/
2807	Void TDecCavlc::parseIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2808	{
2809	#if BURST_IPCM
2810	assert(0);
2811	#else
2812	UInt uiSymbol;
2813
2814	xReadFlag( uiSymbol );
2815
2816	if ( uiSymbol )
2817	{
2818	Bool bIpcmFlag = true;
2819
2820	xReadPCMAlignZero();
2821
2822	pcCU->setPartSizeSubParts ( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
2823	pcCU->setSizeSubParts ( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
2824	pcCU->setIPCMFlagSubParts ( bIpcmFlag, uiAbsPartIdx, uiDepth );
2825
2826	UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
2827	UInt uiLumaOffset = uiMinCoeffSize*uiAbsPartIdx;
2828	UInt uiChromaOffset = uiLumaOffset>>2;
2829
2830	Pel* piPCMSample;
2831	UInt uiWidth;
2832	UInt uiHeight;
2833	UInt uiSampleBits;
2834	UInt uiX, uiY;
2835
2836	piPCMSample = pcCU->getPCMSampleY() + uiLumaOffset;
2837	uiWidth = pcCU->getWidth(uiAbsPartIdx);
2838	uiHeight = pcCU->getHeight(uiAbsPartIdx);
2839	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
2840
2841	for(uiY = 0; uiY < uiHeight; uiY++)
2842	{
2843	for(uiX = 0; uiX < uiWidth; uiX++)
2844	{
2845	UInt uiSample;
2846	xReadCode(uiSampleBits, uiSample);
2847
2848	piPCMSample[uiX] = uiSample;
2849	}
2850	piPCMSample += uiWidth;
2851	}
2852
2853	piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
2854	uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
2855	uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
2856	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
2857
2858	for(uiY = 0; uiY < uiHeight; uiY++)
2859	{
2860	for(uiX = 0; uiX < uiWidth; uiX++)
2861	{
2862	UInt uiSample;
2863	xReadCode(uiSampleBits, uiSample);
2864	piPCMSample[uiX] = uiSample;
2865	}
2866	piPCMSample += uiWidth;
2867	}
2868
2869	piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
2870	uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
2871	uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
2872	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
2873
2874	for(uiY = 0; uiY < uiHeight; uiY++)
2875	{
2876	for(uiX = 0; uiX < uiWidth; uiX++)
2877	{
2878	UInt uiSample;
2879	xReadCode(uiSampleBits, uiSample);
2880	piPCMSample[uiX] = uiSample;
2881	}
2882	piPCMSample += uiWidth;
2883	}
2884	}
2885	#endif
2886	}
2887
2888	Void TDecCavlc::parseIntraDirLumaAng ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2889	{
2890	assert(0);
2891	}
2892
2893	Void TDecCavlc::parseIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2894	{
2895	assert(0);
2896	}
2897
2898	Void TDecCavlc::parseInterDir( TComDataCU* pcCU, UInt& ruiInterDir, UInt uiAbsPartIdx, UInt uiDepth )
2899	{
2900	assert(0);
2901	}
2902
2903	Void TDecCavlc::parseRefFrmIdx( TComDataCU* pcCU, Int& riRefFrmIdx, UInt uiAbsPartIdx, UInt uiDepth, RefPicList eRefList )
2904	{
2905	assert(0);
2906	}
2907
2908	Void TDecCavlc::parseMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth, RefPicList eRefList )
2909	{
2910	assert(0);
2911	}
2912
2913	Void TDecCavlc::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2914	{
2915	#if H0736_AVC_STYLE_QP_RANGE
2916	Int qp;
2917	#else
2918	UInt uiQp;
2919	#endif
2920	Int iDQp;
2921
2922	xReadSvlc( iDQp );
2923
2924	#if H0736_AVC_STYLE_QP_RANGE
2925	Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
2926	qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+ qpBdOffsetY)) - qpBdOffsetY;
2927	#else
2928	uiQp = pcCU->getRefQP( uiAbsPartIdx ) + iDQp;
2929	#endif
2930
2931	UInt uiAbsQpCUPartIdx = (uiAbsPartIdx>>(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)))<<(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)) ;
2932	UInt uiQpCUDepth = min(uiDepth,pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()) ;
2933
2934	#if H0736_AVC_STYLE_QP_RANGE
2935	pcCU->setQPSubParts( qp, uiAbsQpCUPartIdx, uiQpCUDepth );
2936	#else
2937	pcCU->setQPSubParts( uiQp, uiAbsQpCUPartIdx, uiQpCUDepth );
2938	#endif
2939	}
2940
2941	Void TDecCavlc::parseCoeffNxN( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType )
2942	{
2943	assert(0);
2944	}
2945
2946	Void TDecCavlc::parseTransformSubdivFlag( UInt& ruiSubdivFlag, UInt uiLog2TransformBlockSize )
2947	{
2948	assert(0);
2949	}
2950
2951	Void TDecCavlc::parseQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth, UInt uiDepth )
2952	{
2953	assert(0);
2954	}
2955
2956	Void TDecCavlc::parseQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt& uiQtRootCbf )
2957	{
2958	assert(0);
2959	}
2960
2961
2962	Void TDecCavlc::parseMergeFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx )
2963	{
2964	assert(0);
2965	}
2966
2967	Void TDecCavlc::parseMergeIndex ( TComDataCU* pcCU, UInt& ruiMergeIndex, UInt uiAbsPartIdx, UInt uiDepth )
2968	{
2969	assert(0);
2970	}
2971
2972	#if HHI_INTER_VIEW_RESIDUAL_PRED
2973	Void
2974	TDecCavlc::parseResPredFlag( TComDataCU* pcCU, Bool& rbResPredFlag, UInt uiAbsPartIdx, UInt uiDepth )
2975	{
2976	assert(0);
2977	}
2978	#endif
2979
2980	#if RWTH_SDC_DLT_B0036
2981	Void TDecCavlc::parseSDCFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2982	{
2983	assert(0);
2984	}
2985	Void TDecCavlc::parseSDCPredMode ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2986	{
2987	assert(0);
2988	}
2989	Void TDecCavlc::parseSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPart )
2990	{
2991	assert(0);
2992	}
2993	#endif
2994
2995	// ====================================================================================================================
2996	// Protected member functions
2997	// ====================================================================================================================
2998
2999	Void TDecCavlc::xReadCode (UInt uiLength, UInt& ruiCode)
3000	{
3001	assert ( uiLength > 0 );
3002	m_pcBitstream->read (uiLength, ruiCode);
3003	}
3004
3005	Void TDecCavlc::xReadUvlc( UInt& ruiVal)
3006	{
3007	UInt uiVal = 0;
3008	UInt uiCode = 0;
3009	UInt uiLength;
3010	m_pcBitstream->read( 1, uiCode );
3011
3012	if( 0 == uiCode )
3013	{
3014	uiLength = 0;
3015
3016	while( ! ( uiCode & 1 ))
3017	{
3018	m_pcBitstream->read( 1, uiCode );
3019	uiLength++;
3020	}
3021
3022	m_pcBitstream->read( uiLength, uiVal );
3023
3024	uiVal += (1 << uiLength)-1;
3025	}
3026
3027	ruiVal = uiVal;
3028	}
3029
3030	Void TDecCavlc::xReadSvlc( Int& riVal)
3031	{
3032	UInt uiBits = 0;
3033	m_pcBitstream->read( 1, uiBits );
3034	if( 0 == uiBits )
3035	{
3036	UInt uiLength = 0;
3037
3038	while( ! ( uiBits & 1 ))
3039	{
3040	m_pcBitstream->read( 1, uiBits );
3041	uiLength++;
3042	}
3043
3044	m_pcBitstream->read( uiLength, uiBits );
3045
3046	uiBits += (1 << uiLength);
3047	riVal = ( uiBits & 1) ? -(Int)(uiBits>>1) : (Int)(uiBits>>1);
3048	}
3049	else
3050	{
3051	riVal = 0;
3052	}
3053	}
3054
3055	Void TDecCavlc::xReadFlag (UInt& ruiCode)
3056	{
3057	m_pcBitstream->read( 1, ruiCode );
3058	}
3059
3060	#if QC_MVHEVC_B0046
3061	/** Parse VPS alignment one bits.
3062	* \returns Void
3063	*/
3064	Void TDecCavlc::xReadVPSAlignOne( )
3065	{
3066	UInt uiNumberOfBits = m_pcBitstream->getNumBitsUntilByteAligned();
3067
3068	if(uiNumberOfBits)
3069	{
3070	UInt uiBits;
3071	UInt uiSymbol;
3072
3073	for(uiBits = 0; uiBits < uiNumberOfBits; uiBits++)
3074	{
3075	xReadFlag( uiSymbol );
3076
3077	if(!uiSymbol)
3078	{
3079	printf("\nWarning! vps_extension_byte_alignment_reserved_one_bit include a non-zero value.\n");
3080	}
3081	}
3082	}
3083	}
3084	#endif
3085	/** Parse PCM alignment zero bits.
3086	* \returns Void
3087	*/
3088	Void TDecCavlc::xReadPCMAlignZero( )
3089	{
3090	UInt uiNumberOfBits = m_pcBitstream->getNumBitsUntilByteAligned();
3091
3092	if(uiNumberOfBits)
3093	{
3094	UInt uiBits;
3095	UInt uiSymbol;
3096
3097	for(uiBits = 0; uiBits < uiNumberOfBits; uiBits++)
3098	{
3099	xReadFlag( uiSymbol );
3100
3101	if(uiSymbol)
3102	{
3103	printf("\nWarning! pcm_align_zero include a non-zero value.\n");
3104	}
3105	}
3106	}
3107	}
3108
3109	Void TDecCavlc::xReadUnaryMaxSymbol( UInt& ruiSymbol, UInt uiMaxSymbol )
3110	{
3111	if (uiMaxSymbol == 0)
3112	{
3113	ruiSymbol = 0;
3114	return;
3115	}
3116
3117	xReadFlag( ruiSymbol );
3118
3119	if (ruiSymbol == 0 \|\| uiMaxSymbol == 1)
3120	{
3121	return;
3122	}
3123
3124	UInt uiSymbol = 0;
3125	UInt uiCont;
3126
3127	do
3128	{
3129	xReadFlag( uiCont );
3130	uiSymbol++;
3131	}
3132	while( uiCont && (uiSymbol < uiMaxSymbol-1) );
3133
3134	if( uiCont && (uiSymbol == uiMaxSymbol-1) )
3135	{
3136	uiSymbol++;
3137	}
3138
3139	ruiSymbol = uiSymbol;
3140	}
3141
3142	Void TDecCavlc::xReadExGolombLevel( UInt& ruiSymbol )
3143	{
3144	UInt uiSymbol ;
3145	UInt uiCount = 0;
3146	do
3147	{
3148	xReadFlag( uiSymbol );
3149	uiCount++;
3150	}
3151	while( uiSymbol && (uiCount != 13));
3152
3153	ruiSymbol = uiCount-1;
3154
3155	if( uiSymbol )
3156	{
3157	xReadEpExGolomb( uiSymbol, 0 );
3158	ruiSymbol += uiSymbol+1;
3159	}
3160
3161	return;
3162	}
3163
3164	Void TDecCavlc::xReadEpExGolomb( UInt& ruiSymbol, UInt uiCount )
3165	{
3166	UInt uiSymbol = 0;
3167	UInt uiBit = 1;
3168
3169
3170	while( uiBit )
3171	{
3172	xReadFlag( uiBit );
3173	uiSymbol += uiBit << uiCount++;
3174	}
3175
3176	uiCount--;
3177	while( uiCount-- )
3178	{
3179	xReadFlag( uiBit );
3180	uiSymbol += uiBit << uiCount;
3181	}
3182
3183	ruiSymbol = uiSymbol;
3184
3185	return;
3186	}
3187
3188	UInt TDecCavlc::xGetBit()
3189	{
3190	UInt ruiCode;
3191	m_pcBitstream->read( 1, ruiCode );
3192	return ruiCode;
3193	}
3194
3195
3196	/** parse explicit wp tables
3197	* \param TComSlice* pcSlice
3198	* \returns Void
3199	*/
3200	Void TDecCavlc::xParsePredWeightTable( TComSlice* pcSlice )
3201	{
3202	wpScalingParam *wp;
3203	Bool bChroma = true; // color always present in HEVC ?
3204	TComPPS* pps = pcSlice->getPPS();
3205	SliceType eSliceType = pcSlice->getSliceType();
3206	Int iNbRef = (eSliceType == B_SLICE ) ? (2) : (1);
3207	UInt uiLog2WeightDenomLuma, uiLog2WeightDenomChroma;
3208	UInt uiMode = 0;
3209
3210	if ( (eSliceType==P_SLICE && pps->getUseWP()) \|\| (eSliceType==B_SLICE && pps->getWPBiPredIdc()==1 && pcSlice->getRefPicListCombinationFlag()==0) )
3211	uiMode = 1; // explicit
3212	else if ( eSliceType==B_SLICE && pps->getWPBiPredIdc()==2 )
3213	uiMode = 2; // implicit
3214	else if (eSliceType==B_SLICE && pps->getWPBiPredIdc()==1 && pcSlice->getRefPicListCombinationFlag())
3215	uiMode = 3; // combined explicit
3216
3217	if ( uiMode == 1 ) // explicit
3218	{
3219	printf("\nTDecCavlc::xParsePredWeightTable(poc=%d) explicit...\n", pcSlice->getPOC());
3220	Int iDeltaDenom;
3221	// decode delta_luma_log2_weight_denom :
3222	READ_UVLC( uiLog2WeightDenomLuma, "luma_log2_weight_denom" ); // ue(v): luma_log2_weight_denom
3223	if( bChroma )
3224	{
3225	READ_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" ); // se(v): delta_chroma_log2_weight_denom
3226	assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)>=0);
3227	uiLog2WeightDenomChroma = (UInt)(iDeltaDenom + uiLog2WeightDenomLuma);
3228	}
3229
3230	for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ )
3231	{
3232	RefPicList eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
3233	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
3234	{
3235	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
3236
3237	wp[0].uiLog2WeightDenom = uiLog2WeightDenomLuma;
3238	wp[1].uiLog2WeightDenom = uiLog2WeightDenomChroma;
3239	wp[2].uiLog2WeightDenom = uiLog2WeightDenomChroma;
3240
3241	UInt uiCode;
3242	READ_FLAG( uiCode, "luma_weight_lX_flag" ); // u(1): luma_weight_l0_flag
3243	wp[0].bPresentFlag = ( uiCode == 1 );
3244	if ( wp[0].bPresentFlag )
3245	{
3246	Int iDeltaWeight;
3247	READ_SVLC( iDeltaWeight, "delta_luma_weight_lX" ); // se(v): delta_luma_weight_l0[i]
3248	wp[0].iWeight = (iDeltaWeight + (1<<wp[0].uiLog2WeightDenom));
3249	READ_SVLC( wp[0].iOffset, "luma_offset_lX" ); // se(v): luma_offset_l0[i]
3250	}
3251	else
3252	{
3253	wp[0].iWeight = (1 << wp[0].uiLog2WeightDenom);
3254	wp[0].iOffset = 0;
3255	}
3256	if ( bChroma )
3257	{
3258	READ_FLAG( uiCode, "chroma_weight_lX_flag" ); // u(1): chroma_weight_l0_flag
3259	wp[1].bPresentFlag = ( uiCode == 1 );
3260	wp[2].bPresentFlag = ( uiCode == 1 );
3261	if ( wp[1].bPresentFlag )
3262	{
3263	for ( Int j=1 ; j<3 ; j++ )
3264	{
3265	Int iDeltaWeight;
3266	READ_SVLC( iDeltaWeight, "delta_chroma_weight_lX" ); // se(v): chroma_weight_l0[i][j]
3267	wp[j].iWeight = (iDeltaWeight + (1<<wp[1].uiLog2WeightDenom));
3268
3269	Int iDeltaChroma;
3270	READ_SVLC( iDeltaChroma, "delta_chroma_offset_lX" ); // se(v): delta_chroma_offset_l0[i][j]
3271	wp[j].iOffset = iDeltaChroma - ( ( (g_uiIBDI_MAX>>1)*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) + (g_uiIBDI_MAX>>1);
3272	}
3273	}
3274	else
3275	{
3276	for ( Int j=1 ; j<3 ; j++ )
3277	{
3278	wp[j].iWeight = (1 << wp[j].uiLog2WeightDenom);
3279	wp[j].iOffset = 0;
3280	}
3281	}
3282	}
3283	}
3284
3285	for ( Int iRefIdx=pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx<MAX_NUM_REF ; iRefIdx++ )
3286	{
3287	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
3288
3289	wp[0].bPresentFlag = false;
3290	wp[1].bPresentFlag = false;
3291	wp[2].bPresentFlag = false;
3292	}
3293	}
3294	}
3295	else if ( uiMode == 2 ) // implicit
3296	{
3297	printf("\nTDecCavlc::xParsePredWeightTable(poc=%d) implicit...\n", pcSlice->getPOC());
3298	}
3299	else if ( uiMode == 3 ) // combined explicit
3300	{
3301	printf("\nTDecCavlc::xParsePredWeightTable(poc=%d) combined explicit...\n", pcSlice->getPOC());
3302	Int iDeltaDenom;
3303	// decode delta_luma_log2_weight_denom :
3304	READ_UVLC ( uiLog2WeightDenomLuma, "luma_log2_weight_denom" ); // ue(v): luma_log2_weight_denom
3305	if( bChroma )
3306	{
3307	READ_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" ); // ue(v): delta_chroma_log2_weight_denom
3308	assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)>=0);
3309	uiLog2WeightDenomChroma = (UInt)(iDeltaDenom + uiLog2WeightDenomLuma);
3310	}
3311
3312	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(REF_PIC_LIST_C) ; iRefIdx++ )
3313	{
3314	pcSlice->getWpScalingLC(iRefIdx, wp);
3315
3316	wp[0].uiLog2WeightDenom = uiLog2WeightDenomLuma;
3317	wp[1].uiLog2WeightDenom = uiLog2WeightDenomChroma;
3318	wp[2].uiLog2WeightDenom = uiLog2WeightDenomChroma;
3319
3320	UInt uiCode;
3321	READ_FLAG( uiCode, "luma_weight_lc_flag" ); // u(1): luma_weight_lc_flag
3322	wp[0].bPresentFlag = ( uiCode == 1 );
3323	if ( wp[0].bPresentFlag )
3324	{
3325	Int iDeltaWeight;
3326	READ_SVLC( iDeltaWeight, "delta_luma_weight_lc" ); // se(v): delta_luma_weight_lc
3327	wp[0].iWeight = (iDeltaWeight + (1<<wp[0].uiLog2WeightDenom));
3328	READ_SVLC( wp[0].iOffset, "luma_offset_lc" ); // se(v): luma_offset_lc
3329	}
3330	else
3331	{
3332	wp[0].iWeight = (1 << wp[0].uiLog2WeightDenom);
3333	wp[0].iOffset = 0;
3334	}
3335	if ( bChroma )
3336	{
3337	READ_FLAG( uiCode, "chroma_weight_lc_flag" ); // u(1): chroma_weight_lc_flag
3338	wp[1].bPresentFlag = ( uiCode == 1 );
3339	wp[2].bPresentFlag = ( uiCode == 1 );
3340	if ( wp[1].bPresentFlag )
3341	{
3342	for ( Int j=1 ; j<3 ; j++ )
3343	{
3344	Int iDeltaWeight;
3345	READ_SVLC( iDeltaWeight, "delta_chroma_weight_lc" ); // se(v): delta_chroma_weight_lc
3346	wp[j].iWeight = (iDeltaWeight + (1<<wp[1].uiLog2WeightDenom));
3347
3348	Int iDeltaChroma;
3349	READ_SVLC( iDeltaChroma, "delta_chroma_offset_lc" ); // se(v): delta_chroma_offset_lc
3350	wp[j].iOffset = iDeltaChroma - ( ( (g_uiIBDI_MAX>>1)*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) + (g_uiIBDI_MAX>>1);
3351	}
3352	}
3353	else
3354	{
3355	for ( Int j=1 ; j<3 ; j++ )
3356	{
3357	wp[j].iWeight = (1 << wp[j].uiLog2WeightDenom);
3358	wp[j].iOffset = 0;
3359	}
3360	}
3361	}
3362	}
3363
3364	for ( Int iRefIdx=pcSlice->getNumRefIdx(REF_PIC_LIST_C) ; iRefIdx<2*MAX_NUM_REF ; iRefIdx++ )
3365	{
3366	pcSlice->getWpScalingLC(iRefIdx, wp);
3367
3368	wp[0].bPresentFlag = false;
3369	wp[1].bPresentFlag = false;
3370	wp[2].bPresentFlag = false;
3371	}
3372	}
3373	else
3374	{
3375	printf("\n wrong weight pred table syntax \n ");
3376	assert(0);
3377	}
3378	}
3379
3380	/** decode quantization matrix
3381	* \param scalingList quantization matrix information
3382	*/
3383	Void TDecCavlc::parseScalingList(TComScalingList* scalingList)
3384	{
3385	UInt code, sizeId, listId;
3386	Bool scalingListPredModeFlag;
3387	READ_FLAG( code, "scaling_list_present_flag" );
3388	scalingList->setScalingListPresentFlag ( (code==1)?true:false );
3389	if(scalingList->getScalingListPresentFlag() == false)
3390	{
3391	//for each size
3392	for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3393	{
3394	for(listId = 0; listId < g_scalingListNum[sizeId]; listId++)
3395	{
3396	READ_FLAG( code, "scaling_list_pred_mode_flag");
3397	scalingListPredModeFlag = (code) ? true : false;
3398	if(!scalingListPredModeFlag) //Copy Mode
3399	{
3400	READ_UVLC( code, "scaling_list_pred_matrix_id_delta");
3401	scalingList->setRefMatrixId (sizeId,listId,(UInt)((Int)(listId)-(code+1)));
3402	#if SCALING_LIST
3403	if( sizeId > SCALING_LIST_8x8 )
3404	{
3405	scalingList->setScalingListDC(sizeId,listId,scalingList->getScalingListDC(sizeId, scalingList->getRefMatrixId (sizeId,listId)));
3406	}
3407	#endif
3408	scalingList->processRefMatrix( sizeId, listId, scalingList->getRefMatrixId (sizeId,listId));
3409
3410	}
3411	else //DPCM Mode
3412	{
3413	xDecodeScalingList(scalingList, sizeId, listId);
3414	}
3415	}
3416	}
3417	}
3418
3419	return;
3420	}
3421	/** decode DPCM
3422	* \param scalingList quantization matrix information
3423	* \param sizeId size index
3424	* \param listId list index
3425	*/
3426	Void TDecCavlc::xDecodeScalingList(TComScalingList *scalingList, UInt sizeId, UInt listId)
3427	{
3428	#if SCALING_LIST
3429	Int i,coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
3430	Int data;
3431	Int scalingListDcCoefMinus8 = 0;
3432	Int nextCoef = SCALING_LIST_START_VALUE;
3433	UInt* scan = g_auiFrameScanXY [ (sizeId == 0)? 1 : 2 ];
3434	Bool stopNow = false;
3435	Int *dst = scalingList->getScalingListAddress(sizeId, listId);
3436
3437	scalingList->setUseDefaultScalingMatrixFlag(sizeId,listId,false);
3438	if( sizeId > SCALING_LIST_8x8 )
3439	{
3440	READ_SVLC( scalingListDcCoefMinus8, "scaling_list_dc_coef_minus8");
3441	scalingList->setScalingListDC(sizeId,listId,scalingListDcCoefMinus8 + 8);
3442	if(scalingListDcCoefMinus8 == -8)
3443	{
3444	scalingList->processDefaultMarix(sizeId,listId);
3445	}
3446	}
3447
3448	if( !scalingList->getUseDefaultScalingMatrixFlag(sizeId,listId))
3449	{
3450	for(i = 0; i < coefNum && !stopNow ; i++)
3451	{
3452	READ_SVLC( data, "scaling_list_delta_coef");
3453	nextCoef = (nextCoef + data + 256 ) % 256;
3454	if(sizeId < SCALING_LIST_16x16)
3455	{
3456	if( i == 0 && nextCoef == 0 )
3457	{
3458	scalingList->processDefaultMarix(sizeId,listId);
3459	stopNow = true;
3460	}
3461	}
3462	if(!stopNow)
3463	{
3464	dst[scan[i]] = nextCoef;
3465	}
3466	}
3467	}
3468	#else
3469	Int i,coefNum = g_scalingListSize[sizeId];
3470	Int data;
3471	Int nextCoef = SCALING_LIST_START_VALUE;
3472	UInt* scan = g_auiFrameScanXY [ sizeId + 1 ];
3473	Int *dst = scalingList->getScalingListAddress(sizeId, listId);
3474
3475	for(i = 0; i < coefNum; i++)
3476	{
3477	READ_SVLC( data, "scaling_list_delta_coef");
3478	nextCoef = (nextCoef + data + 256 ) % 256;
3479	dst[scan[i]] = nextCoef;
3480	}
3481	#endif
3482	}
3483
3484	Void TDecCavlc::parseDFFlag(UInt& ruiVal, const Char *pSymbolName)
3485	{
3486	READ_FLAG(ruiVal, pSymbolName);
3487	}
3488	Void TDecCavlc::parseDFSvlc(Int& riVal, const Char *pSymbolName)
3489	{
3490	READ_SVLC(riVal, pSymbolName);
3491	}
3492
3493	Bool TDecCavlc::xMoreRbspData()
3494	{
3495	Int bitsLeft = m_pcBitstream->getNumBitsLeft();
3496
3497	// if there are more than 8 bits, it cannot be rbsp_trailing_bits
3498	if (bitsLeft > 8)
3499	{
3500	return true;
3501	}
3502
3503	UChar lastByte = m_pcBitstream->peekBits(bitsLeft);
3504	Int cnt = bitsLeft;
3505
3506	// remove trailing bits equal to zero
3507	while ((cnt>0) && ((lastByte & 1) == 0))
3508	{
3509	lastByte >>= 1;
3510	cnt--;
3511	}
3512	// remove bit equal to one
3513	cnt--;
3514
3515	// we should not have a negative number of bits
3516	assert (cnt>=0);
3517
3518	// we have more data, if cnt is not zero
3519	return (cnt>0);
3520	}
3521
3522	//! \}

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-5.1-dev2-Mediatek/source/Lib/TLibDecoder/TDecCAVLC.cpp @ 1417

Download in other formats: