Context navigation

TDecCAVLC.cpp @ 1417

Visit:

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

A final release, as planned

Migrate to HTM 5.1
For VC project files, only VC9 file is updated
To be used as an additional anchor for CE1.h for 3rd JCTVC meeting at Geneva

Property svn:eol-style set to native

File size: 112.3 KB

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibDecoder/TDecCAVLC.cpp @ 1417

Download in other formats: