Context navigation

source: 3DVCSoftware/trunk/source/Lib/TLibDecoder/TDecCAVLC.cpp @ 485

Visit:

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

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

Download in other formats: