Context navigation

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

Visit:

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

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

Download in other formats: