Context navigation

TDecCAVLC.cpp @ 269

Visit:

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

Integration of JCT3V-C0137

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

From MediaTek
yiwen.chen@…

Property svn:eol-style set to native

File size: 107.5 KB

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	}
[210]	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
[210]	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
[210]	1469	#endif
[254]	1470	#if HHI_MPI \|\| OL_QTLIMIT_PREDCODING_B0068
[56]	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;
[210]	1481	#if !QC_MVHEVC_B0046
[56]	1482	Int iCode;
[210]	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");
[210]	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
[189]	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
[189]	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
[2]	1804	}
	1805	else
	1806	{
[56]	1807	READ_FLAG( uiCode, "depth_flag" );
	1808	if( uiCode )
	1809	{
	1810	READ_UVLC( uiCode, "view_id" );
	1811	READ_SVLC( iCode, "view_order_idx" );
	1812	pcSPS->initMultiviewSPSDepth ( uiCode, iCode );
	1813	#if DEPTH_MAP_GENERATION
	1814	pcSPS->setPredDepthMapGeneration( uiCode, true );
	1815	#endif
	1816	#if HHI_INTER_VIEW_RESIDUAL_PRED
	1817	pcSPS->setMultiviewResPredMode ( 0 );
	1818	#endif
	1819	}
	1820	else
	1821	{
	1822	UInt uiViewId, uiCamParPrecision;
	1823	Int iVOI;
	1824	Bool bCamParSlice;
	1825	READ_UVLC( uiViewId, "view_id" ); uiViewId++;
	1826	READ_SVLC( iVOI, "view_order_idx" );
	1827	READ_UVLC( uiCamParPrecision, "camera_parameter_precision" );
	1828	READ_FLAG( uiCode, "camera_parameter_in_slice_header" ); bCamParSlice = ( uiCode == 1 );
	1829	if( !bCamParSlice )
	1830	{
	1831	for( UInt uiBaseId = 0; uiBaseId < uiViewId; uiBaseId++ )
	1832	{
	1833	READ_SVLC( iCode, "coded_scale" ); m_aaiTempScale [ uiBaseId ][ uiViewId ] = iCode;
	1834	READ_SVLC( iCode, "coded_offset" ); m_aaiTempOffset[ uiBaseId ][ uiViewId ] = iCode;
	1835	READ_SVLC( iCode, "inverse_coded_scale_plus_coded_scale" ); m_aaiTempScale [ uiViewId ][ uiBaseId ] = iCode - m_aaiTempScale [ uiBaseId ][ uiViewId ];
	1836	READ_SVLC( iCode, "inverse_coded_offset_plus_coded_offset" ); m_aaiTempOffset[ uiViewId ][ uiBaseId ] = iCode - m_aaiTempOffset[ uiBaseId ][ uiViewId ];
	1837	}
	1838	}
	1839	pcSPS->initMultiviewSPS( uiViewId, iVOI, uiCamParPrecision, bCamParSlice, m_aaiTempScale, m_aaiTempOffset );
[2]	1840
[56]	1841	#if DEPTH_MAP_GENERATION
	1842	UInt uiPredDepthMapGeneration = 0, uiPdmPrecision = 0;
	1843	#if HHI_INTER_VIEW_MOTION_PRED
	1844	UInt uiMultiviewMvPredMode = 0;
	1845	#endif
	1846	#if HHI_INTER_VIEW_RESIDUAL_PRED
	1847	UInt uiMultiviewResPredMode = 0;
	1848	#endif
	1849	READ_UVLC( uiPredDepthMapGeneration, "Pdm_generation" );
	1850	if( uiPredDepthMapGeneration )
	1851	{
	1852	READ_UVLC( uiPdmPrecision, "Pdm_precision" );
	1853	for( UInt uiBaseId = 0; uiBaseId < uiViewId; uiBaseId++ )
	1854	{
	1855	READ_SVLC( iCode, "Pdm_scale_nom_delta" ); m_aaiTempPdmScaleNomDelta[ uiViewId ][ uiBaseId ] = iCode;
	1856	READ_SVLC( iCode, "Pdm_offset" ); m_aaiTempPdmOffset [ uiViewId ][ uiBaseId ] = iCode;
	1857	}
	1858	#if HHI_INTER_VIEW_MOTION_PRED
	1859	READ_UVLC( uiMultiviewMvPredMode, "multi_view_mv_pred_mode" );
	1860	#endif
	1861	#if HHI_INTER_VIEW_RESIDUAL_PRED
	1862	READ_FLAG( uiMultiviewResPredMode, "multi_view_residual_pred_mode" );
	1863	#endif
	1864	}
	1865	#if HHI_INTER_VIEW_MOTION_PRED
	1866	pcSPS->setPredDepthMapGeneration( uiViewId, false, uiPredDepthMapGeneration, uiMultiviewMvPredMode, uiPdmPrecision, m_aaiTempPdmScaleNomDelta, m_aaiTempPdmOffset );
	1867	#else
	1868	pcSPS->setPredDepthMapGeneration( uiViewId, false, uiPredDepthMapGeneration, 0, uiPdmPrecision, m_aaiTempPdmScaleNomDelta, m_aaiTempPdmOffset );
	1869	#endif
	1870	#endif
	1871	#if HHI_INTER_VIEW_RESIDUAL_PRED
	1872	pcSPS->setMultiviewResPredMode ( uiMultiviewResPredMode );
	1873	#endif
[2]	1874	}
	1875	}
[56]	1876	READ_FLAG( uiCode, "sps_extension2_flag");
	1877	if (uiCode)
[2]	1878	{
[56]	1879	while ( xMoreRbspData() )
	1880	{
	1881	READ_FLAG( uiCode, "sps_extension2_data_flag");
	1882	}
[2]	1883	}
	1884	}
[210]	1885	#endif
[2]	1886	}
	1887
[56]	1888	Void TDecCavlc::readTileMarker ( UInt& uiTileIdx, UInt uiBitsUsed )
[2]	1889	{
[56]	1890	xReadCode ( uiBitsUsed, uiTileIdx );
	1891	}
	1892
	1893	#if LCU_SYNTAX_ALF
[254]	1894	#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
	1895	Void TDecCavlc::parseSliceHeader (TComSlice& rpcSlice, ParameterSetManagerDecoder parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet, bool isDepth)
	1896	#else
[56]	1897	Void TDecCavlc::parseSliceHeader (TComSlice& rpcSlice, ParameterSetManagerDecoder parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet)
[254]	1898	#endif
[56]	1899	#else
	1900	Void TDecCavlc::parseSliceHeader (TComSlice& rpcSlice, ParameterSetManagerDecoder parameterSetManager, AlfCUCtrlInfo &alfCUCtrl)
[2]	1901	#endif
[56]	1902	{
	1903	UInt uiCode;
	1904	Int iCode;
	1905
	1906	#if ENC_DEC_TRACE
	1907	xTraceSliceHeader(rpcSlice);
	1908	#endif
	1909	Int numCUs = ((rpcSlice->getSPS()->getPicWidthInLumaSamples()+rpcSlice->getSPS()->getMaxCUWidth()-1)/rpcSlice->getSPS()->getMaxCUWidth())*((rpcSlice->getSPS()->getPicHeightInLumaSamples()+rpcSlice->getSPS()->getMaxCUHeight()-1)/rpcSlice->getSPS()->getMaxCUHeight());
	1910	Int maxParts = (1<<(rpcSlice->getSPS()->getMaxCUDepth()<<1));
	1911	Int numParts = (1<<(rpcSlice->getPPS()->getSliceGranularity()<<1));
	1912	UInt lCUAddress = 0;
	1913	Int reqBitsOuter = 0;
	1914	while(numCUs>(1<<reqBitsOuter))
[2]	1915	{
[56]	1916	reqBitsOuter++;
[2]	1917	}
[56]	1918	Int reqBitsInner = 0;
	1919	while((numParts)>(1<<reqBitsInner))
[2]	1920	{
[56]	1921	reqBitsInner++;
[2]	1922	}
[56]	1923
	1924	READ_FLAG( uiCode, "first_slice_in_pic_flag" );
	1925	UInt address;
	1926	UInt innerAddress = 0;
[189]	1927
	1928	#if LGE_ILLUCOMP_B0045
	1929	// IC flag is on only first_slice_in_pic
	1930	if (uiCode)
	1931	{
	1932	UInt uiCodeTmp = 0;
	1933	if ( rpcSlice->getSPS()->getViewId() && !rpcSlice->getSPS()->isDepth() )
	1934	{
	1935	READ_FLAG (uiCodeTmp, "applying IC flag");
	1936	}
	1937	rpcSlice->setApplyIC(uiCodeTmp);
	1938	}
	1939	#endif
	1940
[56]	1941	if(!uiCode)
[2]	1942	{
[56]	1943	READ_CODE( reqBitsOuter+reqBitsInner, address, "slice_address" );
	1944	lCUAddress = address >> reqBitsInner;
	1945	innerAddress = address - (lCUAddress<<reqBitsInner);
[2]	1946	}
[56]	1947	//set uiCode to equal slice start address (or entropy slice start address)
	1948	uiCode=(maxPartslCUAddress)+(innerAddress(maxParts>>(rpcSlice->getPPS()->getSliceGranularity()<<1)));
	1949
	1950	rpcSlice->setEntropySliceCurStartCUAddr( uiCode );
	1951	rpcSlice->setEntropySliceCurEndCUAddr(numCUs*maxParts);
[2]	1952
[56]	1953	// slice_type
	1954	READ_UVLC ( uiCode, "slice_type" ); rpcSlice->setSliceType((SliceType)uiCode);
	1955	// lightweight_slice_flag
	1956	READ_FLAG( uiCode, "entropy_slice_flag" );
	1957	Bool bEntropySlice = uiCode ? true : false;
[2]	1958
[56]	1959	if (bEntropySlice)
[2]	1960	{
[56]	1961	rpcSlice->setNextSlice ( false );
	1962	rpcSlice->setNextEntropySlice ( true );
[2]	1963	}
	1964	else
	1965	{
[56]	1966	rpcSlice->setNextSlice ( true );
	1967	rpcSlice->setNextEntropySlice ( false );
	1968
	1969	uiCode=(maxPartslCUAddress)+(innerAddress(maxParts>>(rpcSlice->getPPS()->getSliceGranularity()<<1)));
	1970	rpcSlice->setSliceCurStartCUAddr(uiCode);
	1971	rpcSlice->setSliceCurEndCUAddr(numCUs*maxParts);
[2]	1972	}
[56]	1973	TComPPS* pps = NULL;
	1974	TComSPS* sps = NULL;
[2]	1975
[56]	1976	if (!bEntropySlice)
[2]	1977	{
[56]	1978	READ_UVLC ( uiCode, "pic_parameter_set_id" ); rpcSlice->setPPSId(uiCode);
	1979	pps = parameterSetManager->getPrefetchedPPS(uiCode);
	1980	sps = parameterSetManager->getPrefetchedSPS(pps->getSPSId());
	1981	rpcSlice->setSPS(sps);
	1982	rpcSlice->setPPS(pps);
	1983	#if H0388
	1984	if( pps->getOutputFlagPresentFlag() )
[2]	1985	{
[56]	1986	READ_FLAG( uiCode, "pic_output_flag" );
	1987	rpcSlice->setPicOutputFlag( uiCode ? true : false );
[2]	1988	}
[56]	1989	else
	1990	{
	1991	rpcSlice->setPicOutputFlag( true );
	1992	}
[2]	1993	#endif
[210]	1994	#if QC_REM_IDV_B0046
	1995	#if !QC_MVHEVC_B0046
	1996	if(rpcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_IDR && rpcSlice->getSPS()->getViewId() == 0)
	1997	#else
	1998	if(rpcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_IDR && rpcSlice->getViewId() == 0)
	1999	#endif
	2000	#else
[56]	2001	if(rpcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_IDR)
[210]	2002	#endif
[56]	2003	{
	2004	READ_UVLC( uiCode, "idr_pic_id" ); //ignored
	2005	READ_FLAG( uiCode, "no_output_of_prior_pics_flag" ); //ignored
	2006	rpcSlice->setPOC(0);
	2007	TComReferencePictureSet* rps = rpcSlice->getLocalRPS();
	2008	rps->setNumberOfNegativePictures(0);
	2009	rps->setNumberOfPositivePictures(0);
	2010	rps->setNumberOfLongtermPictures(0);
	2011	rps->setNumberOfPictures(0);
	2012	rpcSlice->setRPS(rps);
	2013	}
	2014	else
[2]	2015	{
[56]	2016	READ_CODE(sps->getBitsForPOC(), uiCode, "pic_order_cnt_lsb");
	2017	Int iPOClsb = uiCode;
	2018	Int iPrevPOC = rpcSlice->getPrevPOC();
	2019	Int iMaxPOClsb = 1<< sps->getBitsForPOC();
	2020	Int iPrevPOClsb = iPrevPOC%iMaxPOClsb;
	2021	Int iPrevPOCmsb = iPrevPOC-iPrevPOClsb;
	2022	Int iPOCmsb;
	2023	if( ( iPOClsb < iPrevPOClsb ) && ( ( iPrevPOClsb - iPOClsb ) >= ( iMaxPOClsb / 2 ) ) )
[2]	2024	{
[56]	2025	iPOCmsb = iPrevPOCmsb + iMaxPOClsb;
[2]	2026	}
[56]	2027	else if( (iPOClsb > iPrevPOClsb ) && ( (iPOClsb - iPrevPOClsb ) > ( iMaxPOClsb / 2 ) ) )
	2028	{
	2029	iPOCmsb = iPrevPOCmsb - iMaxPOClsb;
	2030	}
	2031	else
	2032	{
	2033	iPOCmsb = iPrevPOCmsb;
	2034	}
	2035	rpcSlice->setPOC( iPOCmsb+iPOClsb );
[210]	2036	#if QC_REM_IDV_B0046
	2037	#if !QC_MVHEVC_B0046
	2038	if( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR && rpcSlice->getSPS()->getViewId() && rpcSlice->getPOC() == 0 )
	2039	#else
	2040	if( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR && rpcSlice->getViewId() && rpcSlice->getPOC() == 0 )
	2041	#endif
	2042	#else
[77]	2043	if( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDV && rpcSlice->getPOC() == 0 )
[210]	2044	#endif
[56]	2045	{
	2046	TComReferencePictureSet* rps = rpcSlice->getLocalRPS();
	2047	rps->setNumberOfNegativePictures(0);
	2048	rps->setNumberOfPositivePictures(0);
	2049	rps->setNumberOfLongtermPictures(0);
	2050	rps->setNumberOfPictures(0);
	2051	rpcSlice->setRPS(rps);
	2052	}
	2053	else
	2054	{
	2055	TComReferencePictureSet* rps;
	2056	READ_FLAG( uiCode, "short_term_ref_pic_set_sps_flag" );
	2057	if(uiCode == 0) // use short-term reference picture set explicitly signalled in slice header
	2058	{
	2059	rps = rpcSlice->getLocalRPS();
	2060	#if RPS_IN_SPS
	2061	parseShortTermRefPicSet(sps,rps, sps->getRPSList()->getNumberOfReferencePictureSets());
	2062	#else
	2063	parseShortTermRefPicSet(pps,rps, pps->getRPSList()->getNumberOfReferencePictureSets());
[2]	2064	#endif
[56]	2065	rpcSlice->setRPS(rps);
	2066	}
	2067	else // use reference to short-term reference picture set in PPS
	2068	{
	2069	#if RPS_IN_SPS
	2070	READ_UVLC( uiCode, "short_term_ref_pic_set_idx"); rpcSlice->setRPS(sps->getRPSList()->getReferencePictureSet(uiCode));
	2071	#else
	2072	READ_UVLC( uiCode, "short_term_ref_pic_set_idx"); rpcSlice->setRPS(pps->getRPSList()->getReferencePictureSet(uiCode));
[2]	2073	#endif
[56]	2074	rps = rpcSlice->getRPS();
	2075	}
	2076	#if RPS_IN_SPS
	2077	if(sps->getLongTermRefsPresent())
[2]	2078	#else
[56]	2079	if(pps->getLongTermRefsPresent())
[2]	2080	#endif
[56]	2081	{
	2082	Int offset = rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures();
	2083	READ_UVLC( uiCode, "num_long_term_pics"); rps->setNumberOfLongtermPictures(uiCode);
	2084	Int prev = 0;
	2085	#if LTRP_MULT
	2086	Int prevMsb=0;
	2087	Int prevDeltaPocLt=0;
	2088	#endif
	2089	for(Int j=rps->getNumberOfLongtermPictures()+offset-1 ; j > offset-1; j--)
	2090	{
	2091	READ_UVLC(uiCode,"delta_poc_lsb_lt");
	2092	prev += uiCode;
[2]	2093
[56]	2094	#if LTRP_MULT
	2095	READ_FLAG(uiCode,"delta_poc_msb_present_flag");
	2096	Int decDeltaPOCMsbPresent=uiCode;
[2]	2097
[56]	2098	if(decDeltaPOCMsbPresent==1)
	2099	{
	2100	READ_UVLC(uiCode, "delta_poc_msb_cycle_lt_minus1");
	2101	if( (j==(rps->getNumberOfLongtermPictures()+offset-1)) \|\| (prev!=prevDeltaPocLt) )
	2102	{
	2103	prevMsb=(1+uiCode);
	2104	}
	2105	else
	2106	{
	2107	prevMsb+=(1+uiCode);
	2108	}
	2109	Int decMaxPocLsb = 1<<rpcSlice->getSPS()->getBitsForPOC();
	2110	rps->setPOC(j,rpcSlice->getPOC()-prev-(prevMsb)*decMaxPocLsb);
	2111	rps->setDeltaPOC(j,-(Int)(prev+(prevMsb)*decMaxPocLsb));
	2112	}
	2113	else
	2114	{
[2]	2115	#endif
[56]	2116	rps->setPOC(j,rpcSlice->getPOC()-prev);
	2117	rps->setDeltaPOC(j,-(Int)prev);
	2118	#if LTRP_MULT
	2119	}
	2120	prevDeltaPocLt=prev;
	2121	#endif
	2122	READ_FLAG( uiCode, "used_by_curr_pic_lt_flag"); rps->setUsed(j,uiCode);
	2123	}
	2124	offset += rps->getNumberOfLongtermPictures();
	2125	rps->setNumberOfPictures(offset);
	2126	}
	2127	}
[2]	2128	}
	2129
[56]	2130	if(sps->getUseSAO() \|\| sps->getUseALF() \|\| sps->getScalingListFlag() \|\| sps->getUseDF())
[2]	2131	{
[56]	2132	//!!!KS: order is different in WD5!
	2133	if (sps->getUseALF())
[2]	2134	{
[56]	2135	READ_FLAG(uiCode, "slice_adaptive_loop_filter_flag");
	2136	rpcSlice->setAlfEnabledFlag((Bool)uiCode);
	2137	}
	2138	if (sps->getUseSAO())
	2139	{
	2140	#if SAO_UNIT_INTERLEAVING
	2141	READ_FLAG(uiCode, "slice_sao_interleaving_flag"); rpcSlice->setSaoInterleavingFlag(uiCode);
	2142	#endif
	2143	READ_FLAG(uiCode, "slice_sample_adaptive_offset_flag"); rpcSlice->setSaoEnabledFlag((Bool)uiCode);
	2144	#if SAO_UNIT_INTERLEAVING
	2145	if (rpcSlice->getSaoEnabledFlag() && rpcSlice->getSaoInterleavingFlag())
[2]	2146	{
[56]	2147	READ_FLAG(uiCode, "sao_cb_enable_flag"); rpcSlice->setSaoEnabledFlagCb((Bool)uiCode);
	2148	READ_FLAG(uiCode, "sao_cr_enable_flag"); rpcSlice->setSaoEnabledFlagCr((Bool)uiCode);
[2]	2149	}
	2150	else
	2151	{
[56]	2152	rpcSlice->setSaoEnabledFlagCb(0);
	2153	rpcSlice->setSaoEnabledFlagCr(0);
[2]	2154	}
[56]	2155	#endif
[2]	2156	}
[56]	2157	READ_UVLC ( uiCode, "aps_id" ); rpcSlice->setAPSId(uiCode);
	2158	}
	2159	if (!rpcSlice->isIntra())
	2160	{
	2161	READ_FLAG( uiCode, "num_ref_idx_active_override_flag");
	2162	if (uiCode)
[2]	2163	{
[56]	2164	READ_CODE (3, uiCode, "num_ref_idx_l0_active_minus1" ); rpcSlice->setNumRefIdx( REF_PIC_LIST_0, uiCode + 1 );
	2165	if (rpcSlice->isInterB())
[2]	2166	{
[56]	2167	READ_CODE (3, uiCode, "num_ref_idx_l1_active_minus1" ); rpcSlice->setNumRefIdx( REF_PIC_LIST_1, uiCode + 1 );
[2]	2168	}
	2169	else
	2170	{
[56]	2171	rpcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
[2]	2172	}
	2173	}
	2174	else
	2175	{
[56]	2176	rpcSlice->setNumRefIdx(REF_PIC_LIST_0, 0);
	2177	rpcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
[2]	2178	}
	2179	}
[56]	2180	TComRefPicListModification* refPicListModification = rpcSlice->getRefPicListModification();
	2181	if( !rpcSlice->isIntra() )
[2]	2182	{
[56]	2183	#if H0412_REF_PIC_LIST_RESTRICTION
[210]	2184	#if QC_MVHEVC_B0046
	2185	if( !rpcSlice->getViewId() \|\| !rpcSlice->getSPS()->getListsModificationPresentFlag() )
	2186	#else
[56]	2187	if( !rpcSlice->getSPS()->getListsModificationPresentFlag() )
[210]	2188	#endif
[2]	2189	{
[56]	2190	refPicListModification->setRefPicListModificationFlagL0( 0 );
[2]	2191	}
	2192	else
	2193	{
[56]	2194	#endif
	2195	READ_FLAG( uiCode, "ref_pic_list_modification_flag_l0" ); refPicListModification->setRefPicListModificationFlagL0( uiCode ? 1 : 0 );
	2196	#if H0412_REF_PIC_LIST_RESTRICTION
[2]	2197	}
[56]	2198	#endif
	2199
	2200	if(refPicListModification->getRefPicListModificationFlagL0())
[2]	2201	{
[56]	2202	uiCode = 0;
	2203	Int i = 0;
	2204	#if H0137_0138_LIST_MODIFICATION
	2205	Int NumPocTotalCurr = rpcSlice->getNumPocTotalCurrMvc();
	2206	if ( NumPocTotalCurr > 1 )
	2207	{
	2208	Int length = 1;
	2209	NumPocTotalCurr --;
	2210	while ( NumPocTotalCurr >>= 1)
	2211	{
	2212	length ++;
	2213	}
	2214	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
	2215	{
	2216	READ_CODE( length, uiCode, "list_entry_l0" );
	2217	refPicListModification->setRefPicSetIdxL0(i, uiCode );
	2218	}
	2219	}
	2220	else
	2221	{
	2222	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
	2223	{
	2224	refPicListModification->setRefPicSetIdxL0(i, 0 );
	2225	}
	2226	}
	2227	#else
	2228	Int list_modification_idc = 0;
	2229	while(list_modification_idc != 3)
	2230	{
	2231	READ_UVLC( uiCode, "list_modification_idc" ); refPicListModification->setListIdcL0(i, uiCode );
	2232	list_modification_idc = uiCode;
	2233	if(uiCode != 3)
	2234	{
	2235	READ_UVLC( uiCode, "ref_pic_set_idx" ); refPicListModification->setRefPicSetIdxL0(i, uiCode );
	2236	}
	2237	i++;
	2238	}
	2239	refPicListModification->setNumberOfRefPicListModificationsL0(i-1);
	2240	#endif
[2]	2241	}
[56]	2242	#if !H0137_0138_LIST_MODIFICATION
[2]	2243	else
	2244	{
[56]	2245	refPicListModification->setNumberOfRefPicListModificationsL0(0);
[2]	2246	}
[56]	2247	#endif
[2]	2248	}
[56]	2249	else
[2]	2250	{
[56]	2251	refPicListModification->setRefPicListModificationFlagL0(0);
	2252	#if !H0137_0138_LIST_MODIFICATION
	2253	refPicListModification->setNumberOfRefPicListModificationsL0(0);
	2254	#endif
[2]	2255	}
[56]	2256	if(rpcSlice->isInterB())
[2]	2257	{
[56]	2258	#if H0412_REF_PIC_LIST_RESTRICTION
[210]	2259	#if QC_MVHEVC_B0046
	2260	if( !rpcSlice->getViewId() \|\| !rpcSlice->getSPS()->getListsModificationPresentFlag() )
	2261	#else
[56]	2262	if( !rpcSlice->getSPS()->getListsModificationPresentFlag() )
[210]	2263	#endif
[2]	2264	{
[56]	2265	refPicListModification->setRefPicListModificationFlagL1( 0 );
[2]	2266	}
	2267	else
	2268	{
	2269	#endif
[56]	2270	READ_FLAG( uiCode, "ref_pic_list_modification_flag_l1" ); refPicListModification->setRefPicListModificationFlagL1( uiCode ? 1 : 0 );
	2271	#if H0412_REF_PIC_LIST_RESTRICTION
[2]	2272	}
	2273	#endif
[56]	2274	if(refPicListModification->getRefPicListModificationFlagL1())
[2]	2275	{
[56]	2276	uiCode = 0;
	2277	Int i = 0;
	2278	#if H0137_0138_LIST_MODIFICATION
	2279	Int NumPocTotalCurr = rpcSlice->getNumPocTotalCurrMvc();
	2280	if ( NumPocTotalCurr > 1 )
	2281	{
	2282	Int length = 1;
	2283	NumPocTotalCurr --;
	2284	while ( NumPocTotalCurr >>= 1)
	2285	{
	2286	length ++;
	2287	}
	2288	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
	2289	{
	2290	READ_CODE( length, uiCode, "list_entry_l1" );
	2291	refPicListModification->setRefPicSetIdxL1(i, uiCode );
	2292	}
	2293	}
	2294	else
	2295	{
	2296	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
	2297	{
	2298	refPicListModification->setRefPicSetIdxL1(i, 0 );
	2299	}
	2300	}
[2]	2301	#else
[56]	2302	Int list_modification_idc = 0;
	2303	while(list_modification_idc != 3)
	2304	{
	2305	READ_UVLC( uiCode, "list_modification_idc" ); refPicListModification->setListIdcL1(i, uiCode );
	2306	list_modification_idc = uiCode;
	2307	if(uiCode != 3)
	2308	{
	2309	READ_UVLC( uiCode, "ref_pic_set_idx" ); refPicListModification->setRefPicSetIdxL1(i, uiCode );
	2310	}
	2311	i++;
	2312	}
	2313	refPicListModification->setNumberOfRefPicListModificationsL1(i-1);
[2]	2314	#endif
	2315	}
[56]	2316	#if !H0137_0138_LIST_MODIFICATION
[2]	2317	else
	2318	{
[56]	2319	refPicListModification->setNumberOfRefPicListModificationsL1(0);
[2]	2320	}
	2321	#endif
[56]	2322	}
	2323	else
[2]	2324	{
[56]	2325	refPicListModification->setRefPicListModificationFlagL1(0);
	2326	#if !H0137_0138_LIST_MODIFICATION
	2327	refPicListModification->setNumberOfRefPicListModificationsL1(0);
	2328	#endif
[2]	2329	}
	2330	}
	2331	else
	2332	{
[56]	2333	// initialize from previous slice
	2334	pps = rpcSlice->getPPS();
	2335	sps = rpcSlice->getSPS();
[2]	2336	}
[56]	2337	// ref_pic_list_combination( )
	2338	//!!!KS: ref_pic_list_combination() should be conditioned on entropy_slice_flag
	2339	if (rpcSlice->isInterB())
[2]	2340	{
[56]	2341	READ_FLAG( uiCode, "ref_pic_list_combination_flag" ); rpcSlice->setRefPicListCombinationFlag( uiCode ? 1 : 0 );
	2342	if(uiCode)
[2]	2343	{
[56]	2344	READ_UVLC( uiCode, "num_ref_idx_lc_active_minus1" ); rpcSlice->setNumRefIdx( REF_PIC_LIST_C, uiCode + 1 );
	2345
	2346	#if H0412_REF_PIC_LIST_RESTRICTION
[210]	2347	#if QC_MVHEVC_B0046
	2348	if( rpcSlice->getViewId() && rpcSlice->getSPS()->getListsModificationPresentFlag() )
	2349	#else
	2350	if(rpcSlice->getSPS()->getListsModificationPresentFlag() )
	2351	#endif
[56]	2352	{
[2]	2353	#endif
[56]	2354	READ_FLAG( uiCode, "ref_pic_list_modification_flag_lc" ); rpcSlice->setRefPicListModificationFlagLC( uiCode ? 1 : 0 );
	2355	if(uiCode)
	2356	{
	2357	for (UInt i=0;i<rpcSlice->getNumRefIdx(REF_PIC_LIST_C);i++)
	2358	{
	2359	READ_FLAG( uiCode, "pic_from_list_0_flag" );
	2360	rpcSlice->setListIdFromIdxOfLC(i, uiCode);
	2361	#if H0137_0138_LIST_MODIFICATION
	2362	if (((rpcSlice->getListIdFromIdxOfLC(i) == REF_PIC_LIST_0) && (rpcSlice->getNumRefIdx( REF_PIC_LIST_0 ) == 1)) \|\| ((rpcSlice->getListIdFromIdxOfLC(i) == REF_PIC_LIST_1) && (rpcSlice->getNumRefIdx( REF_PIC_LIST_1 ) == 1)) )
	2363	{
	2364	uiCode = 0;
	2365	}
	2366	else
	2367	{
	2368	READ_UVLC( uiCode, "ref_idx_list_curr" );
	2369	}
	2370	#else
	2371	READ_UVLC( uiCode, "ref_idx_list_curr" );
	2372	#endif
	2373	rpcSlice->setRefIdxFromIdxOfLC(i, uiCode);
	2374	rpcSlice->setRefIdxOfLC((RefPicList)rpcSlice->getListIdFromIdxOfLC(i), rpcSlice->getRefIdxFromIdxOfLC(i), i);
	2375	}
	2376	}
	2377	#if H0412_REF_PIC_LIST_RESTRICTION
[2]	2378	}
	2379	else
	2380	{
[56]	2381	rpcSlice->setRefPicListModificationFlagLC(false);
[2]	2382	}
[56]	2383	#endif
[2]	2384	}
[56]	2385	else
[2]	2386	{
[56]	2387	rpcSlice->setRefPicListModificationFlagLC(false);
	2388	rpcSlice->setNumRefIdx(REF_PIC_LIST_C, 0);
[2]	2389	}
	2390	}
[56]	2391	else
[2]	2392	{
[56]	2393	rpcSlice->setRefPicListCombinationFlag(false);
[2]	2394	}
[56]	2395
	2396	#if H0111_MVD_L1_ZERO
	2397	if (rpcSlice->isInterB())
[2]	2398	{
[56]	2399	READ_FLAG( uiCode, "mvd_l1_zero_flag" ); rpcSlice->setMvdL1ZeroFlag( (uiCode ? true : false) );
[2]	2400	}
	2401	#endif
	2402
[56]	2403	#if CABAC_INIT_FLAG
	2404	rpcSlice->setCabacInitFlag( false ); // default
	2405	if(pps->getCabacInitPresentFlag() && !rpcSlice->isIntra())
[2]	2406	{
[56]	2407	READ_FLAG(uiCode, "cabac_init_flag");
	2408	rpcSlice->setCabacInitFlag( uiCode ? true : false );
[2]	2409	}
[56]	2410	#else
	2411	if(pps->getEntropyCodingMode() && !rpcSlice->isIntra())
[2]	2412	{
[56]	2413	READ_UVLC(uiCode, "cabac_init_idc");
	2414	rpcSlice->setCABACinitIDC(uiCode);
[2]	2415	}
[56]	2416	else if (pps->getEntropyCodingMode() && rpcSlice->isIntra())
	2417	{
	2418	rpcSlice->setCABACinitIDC(0);
	2419	}
	2420	#endif
[2]	2421
[56]	2422	if(!bEntropySlice)
	2423	{
	2424	READ_SVLC( iCode, "slice_qp_delta" );
	2425	rpcSlice->setSliceQp (26 + pps->getPicInitQPMinus26() + iCode);
[2]	2426
[56]	2427	#if H0736_AVC_STYLE_QP_RANGE
	2428	assert( rpcSlice->getSliceQp() >= -sps->getQpBDOffsetY() );
	2429	assert( rpcSlice->getSliceQp() <= 51 );
	2430	#endif
[2]	2431
[56]	2432	#if DBL_CONTROL
	2433	if (rpcSlice->getPPS()->getDeblockingFilterControlPresent())
[2]	2434	{
[56]	2435	if ( rpcSlice->getSPS()->getUseDF() )
[2]	2436	{
[56]	2437	READ_FLAG ( uiCode, "inherit_dbl_param_from_APS_flag" ); rpcSlice->setInheritDblParamFromAPS(uiCode ? 1 : 0);
	2438	} else
	2439	{
	2440	rpcSlice->setInheritDblParamFromAPS(0);
[2]	2441	}
[56]	2442	#else
	2443	READ_FLAG ( uiCode, "inherit_dbl_param_from_APS_flag" ); rpcSlice->setInheritDblParamFromAPS(uiCode ? 1 : 0);
	2444	#endif
	2445	if(!rpcSlice->getInheritDblParamFromAPS())
[2]	2446	{
[56]	2447	READ_FLAG ( uiCode, "disable_deblocking_filter_flag" ); rpcSlice->setLoopFilterDisable(uiCode ? 1 : 0);
	2448	if(!rpcSlice->getLoopFilterDisable())
	2449	{
	2450	READ_SVLC( iCode, "beta_offset_div2" ); rpcSlice->setLoopFilterBetaOffset(iCode);
	2451	READ_SVLC( iCode, "tc_offset_div2" ); rpcSlice->setLoopFilterTcOffset(iCode);
	2452	}
[2]	2453	}
[56]	2454	#if DBL_CONTROL
	2455	}
	2456	#endif
	2457	if ( rpcSlice->getSliceType() == B_SLICE )
	2458	{
	2459	READ_FLAG( uiCode, "collocated_from_l0_flag" );
	2460	rpcSlice->setColDir(uiCode);
[2]	2461	}
[56]	2462
	2463	#if COLLOCATED_REF_IDX
	2464	if ( rpcSlice->getSliceType() != I_SLICE &&
	2465	((rpcSlice->getColDir()==0 && rpcSlice->getNumRefIdx(REF_PIC_LIST_0)>1)\|\|
	2466	(rpcSlice->getColDir() ==1 && rpcSlice->getNumRefIdx(REF_PIC_LIST_1)>1)))
[2]	2467	{
[56]	2468	READ_UVLC( uiCode, "collocated_ref_idx" );
	2469	rpcSlice->setColRefIdx(uiCode);
[2]	2470	}
[56]	2471	#endif
	2472
	2473	if ( (pps->getUseWP() && rpcSlice->getSliceType()==P_SLICE) \|\| (pps->getWPBiPredIdc() && rpcSlice->getSliceType()==B_SLICE) )
[2]	2474	{
[56]	2475	xParsePredWeightTable(rpcSlice);
	2476	rpcSlice->initWpScaling();
[2]	2477	}
	2478	}
[56]	2479
	2480	if (!bEntropySlice)
[2]	2481	{
[56]	2482	if( rpcSlice->getSPS()->hasCamParInSliceHeader() )
[2]	2483	{
[56]	2484	UInt uiViewId = rpcSlice->getSPS()->getViewId();
	2485	for( UInt uiBaseId = 0; uiBaseId < uiViewId; uiBaseId++ )
[2]	2486	{
[56]	2487	READ_SVLC( iCode, "coded_scale" ); m_aaiTempScale [ uiBaseId ][ uiViewId ] = iCode;
	2488	READ_SVLC( iCode, "coded_offset" ); m_aaiTempOffset[ uiBaseId ][ uiViewId ] = iCode;
	2489	READ_SVLC( iCode, "inverse_coded_scale_plus_coded_scale" ); m_aaiTempScale [ uiViewId ][ uiBaseId ] = iCode - m_aaiTempScale [ uiBaseId ][ uiViewId ];
	2490	READ_SVLC( iCode, "inverse_coded_offset_plus_coded_offset" ); m_aaiTempOffset[ uiViewId ][ uiBaseId ] = iCode - m_aaiTempOffset[ uiBaseId ][ uiViewId ];
[2]	2491	}
[56]	2492	rpcSlice->initMultiviewSlice( m_aaiTempScale, m_aaiTempOffset );
[2]	2493	}
[56]	2494	}
	2495
	2496	#if ( HHI_MPI \|\| HHI_INTER_VIEW_MOTION_PRED )
	2497	#if ( HHI_MPI && HHI_INTER_VIEW_MOTION_PRED )
	2498	const int iExtraMergeCandidates = ( sps->getUseMVI() \|\| sps->getMultiviewMvPredMode() ) ? 1 : 0;
	2499	#elif HHI_MPI
	2500	const int iExtraMergeCandidates = sps->getUseMVI() ? 1 : 0;
[254]	2501	#elif MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
	2502	const int iExtraMergeCandidates = ( (isDepth \|\| sps->getMultiviewMvPredMode()) ) ? 1 : 0;
[56]	2503	#else
	2504	const int iExtraMergeCandidates = sps->getMultiviewMvPredMode() ? 1 : 0;
	2505	#endif
	2506	READ_UVLC( uiCode, "5_minus_max_num_merge_cand");
	2507	rpcSlice->setMaxNumMergeCand(MRG_MAX_NUM_CANDS + iExtraMergeCandidates - uiCode);
	2508	assert(rpcSlice->getMaxNumMergeCand()==(MRG_MAX_NUM_CANDS_SIGNALED+iExtraMergeCandidates));
	2509	#else
	2510	READ_UVLC( uiCode, "5_minus_max_num_merge_cand");
	2511	rpcSlice->setMaxNumMergeCand(MRG_MAX_NUM_CANDS - uiCode);
	2512	assert(rpcSlice->getMaxNumMergeCand()==MRG_MAX_NUM_CANDS_SIGNALED);
	2513	#endif
	2514
	2515	if (!bEntropySlice)
	2516	{
	2517	if(sps->getUseALF() && rpcSlice->getAlfEnabledFlag())
[2]	2518	{
[56]	2519	UInt uiNumLCUsInWidth = sps->getPicWidthInLumaSamples() / g_uiMaxCUWidth;
	2520	UInt uiNumLCUsInHeight = sps->getPicHeightInLumaSamples() / g_uiMaxCUHeight;
	2521
	2522	uiNumLCUsInWidth += ( sps->getPicWidthInLumaSamples() % g_uiMaxCUWidth ) ? 1 : 0;
	2523	uiNumLCUsInHeight += ( sps->getPicHeightInLumaSamples() % g_uiMaxCUHeight ) ? 1 : 0;
	2524
	2525	Int uiNumCUsInFrame = uiNumLCUsInWidth* uiNumLCUsInHeight;
	2526	#if LCU_SYNTAX_ALF
	2527	if(sps->getUseALFCoefInSlice())
[2]	2528	{
[56]	2529	alfParamSet.releaseALFParam();
	2530	alfParamSet.init();
	2531	Bool isAcrossSlice = sps->getLFCrossSliceBoundaryFlag();
	2532	Int numSUinLCU = 1<< (g_uiMaxCUDepth << 1);
	2533	Int firstLCUAddr = rpcSlice->getSliceCurStartCUAddr() / numSUinLCU;
	2534	xParseAlfParam(&alfParamSet, false, firstLCUAddr, isAcrossSlice, uiNumLCUsInWidth, uiNumLCUsInHeight);
[2]	2535	}
[56]	2536
	2537	if(!sps->getUseALFCoefInSlice())
[2]	2538	{
[56]	2539	#endif
	2540	xParseAlfCuControlParam(alfCUCtrl, uiNumCUsInFrame);
	2541	#if LCU_SYNTAX_ALF
[2]	2542	}
[56]	2543	#endif
	2544
[2]	2545	}
[56]	2546	}
	2547
	2548	//!!!KS: The following syntax is not aligned with the working draft, TRACE support needs to be added
	2549	rpcSlice->setTileMarkerFlag ( 0 ); // default
	2550	if (!bEntropySlice)
	2551	{
	2552	#if !REMOVE_TILE_DEPENDENCE
	2553	if (sps->getTileBoundaryIndependenceIdr())
	2554	{
	2555	#endif
	2556	xReadCode(1, uiCode); // read flag indicating if tile markers transmitted
	2557	rpcSlice->setTileMarkerFlag( uiCode );
	2558	#if !REMOVE_TILE_DEPENDENCE
	2559	}
	2560	#endif
	2561	}
	2562
	2563	#if TILES_WPP_ENTRY_POINT_SIGNALLING
	2564	Int tilesOrEntropyCodingSyncIdc = rpcSlice->getSPS()->getTilesOrEntropyCodingSyncIdc();
	2565	UInt *entryPointOffset = NULL;
	2566	UInt numEntryPointOffsets, offsetLenMinus1;
	2567
	2568	rpcSlice->setNumEntryPointOffsets ( 0 ); // default
	2569
	2570	if (tilesOrEntropyCodingSyncIdc>0)
	2571	{
	2572	READ_UVLC(numEntryPointOffsets, "num_entry_point_offsets"); rpcSlice->setNumEntryPointOffsets ( numEntryPointOffsets );
	2573	if (numEntryPointOffsets>0)
[2]	2574	{
[56]	2575	READ_UVLC(offsetLenMinus1, "offset_len_minus1");
[2]	2576	}
[56]	2577	entryPointOffset = new UInt[numEntryPointOffsets];
	2578	for (UInt idx=0; idx<numEntryPointOffsets; idx++)
[2]	2579	{
[56]	2580	Int bitsRead = m_pcBitstream->getNumBitsRead();
	2581	READ_CODE(offsetLenMinus1+1, uiCode, "entry_point_offset");
	2582	entryPointOffset[ idx ] = uiCode;
	2583	if ( idx == 0 && tilesOrEntropyCodingSyncIdc == 2 )
[2]	2584	{
[56]	2585	// Subtract distance from NALU header start to provide WPP 0-th substream the correct size.
	2586	entryPointOffset[ idx ] -= ( bitsRead + numEntryPointOffsets*(offsetLenMinus1+1) ) >> 3;
[2]	2587	}
[56]	2588	}
	2589	}
[2]	2590
[56]	2591	if ( tilesOrEntropyCodingSyncIdc == 1 ) // tiles
	2592	{
	2593	rpcSlice->setTileLocationCount( numEntryPointOffsets );
[2]	2594
[56]	2595	UInt prevPos = 0;
	2596	for (Int idx=0; idx<rpcSlice->getTileLocationCount(); idx++)
	2597	{
	2598	rpcSlice->setTileLocation( idx, prevPos + entryPointOffset [ idx ] );
	2599	prevPos += entryPointOffset[ idx ];
	2600	}
	2601	}
	2602	else if ( tilesOrEntropyCodingSyncIdc == 2 ) // wavefront
	2603	{
	2604	Int numSubstreams = pps->getNumSubstreams();
	2605	rpcSlice->allocSubstreamSizes(numSubstreams);
	2606	UInt *pSubstreamSizes = rpcSlice->getSubstreamSizes();
	2607	for (Int idx=0; idx<numSubstreams-1; idx++)
	2608	{
	2609	if ( idx < numEntryPointOffsets )
[2]	2610	{
[56]	2611	pSubstreamSizes[ idx ] = ( entryPointOffset[ idx ] << 3 ) ;
[2]	2612	}
	2613	else
	2614	{
[56]	2615	pSubstreamSizes[ idx ] = 0;
[2]	2616	}
	2617	}
[56]	2618	}
	2619
	2620	if (entryPointOffset)
	2621	{
	2622	delete [] entryPointOffset;
	2623	}
	2624	#else
	2625	#if WPP_SIMPLIFICATION
	2626	if (pps->getNumSubstreams() > 1)
	2627	#else
	2628	if (pps->getEntropyCodingSynchro())
	2629	#endif
	2630	{
	2631	UInt uiNumSubstreams = pps->getNumSubstreams();
	2632	rpcSlice->allocSubstreamSizes(uiNumSubstreams);
	2633	UInt *puiSubstreamSizes = rpcSlice->getSubstreamSizes();
	2634
	2635	for (UInt ui = 0; ui+1 < uiNumSubstreams; ui++)
[2]	2636	{
[56]	2637	xReadCode(2, uiCode);
	2638
	2639	switch ( uiCode )
[2]	2640	{
[56]	2641	case 0:
	2642	xReadCode(8, uiCode);
	2643	break;
	2644	case 1:
	2645	xReadCode(16, uiCode);
	2646	break;
	2647	case 2:
	2648	xReadCode(24, uiCode);
	2649	break;
	2650	case 3:
	2651	xReadCode(32, uiCode);
	2652	break;
	2653	default:
	2654	printf("Error in parseSliceHeader\n");
	2655	exit(-1);
	2656	break;
[2]	2657	}
[56]	2658	puiSubstreamSizes[ui] = uiCode;
[2]	2659	}
	2660	}
[56]	2661	#endif
[2]	2662
[56]	2663	if (!bEntropySlice)
	2664	{
	2665	// Reading location information
	2666	#if !REMOVE_TILE_DEPENDENCE
	2667	if (sps->getTileBoundaryIndependenceIdr())
	2668	{
	2669	#endif
	2670	#if !TILES_WPP_ENTRY_POINT_SIGNALLING
	2671	xReadCode(1, uiCode); // read flag indicating if location information signaled in slice header
	2672	Bool bTileLocationInformationInSliceHeaderFlag = (uiCode)? true : false;
[2]	2673
[56]	2674	if (bTileLocationInformationInSliceHeaderFlag)
	2675	{
	2676	// location count
	2677	xReadCode(5, uiCode); // number of tiles for which location information signaled
	2678	rpcSlice->setTileLocationCount ( uiCode + 1 );
[2]	2679
[56]	2680	xReadCode(5, uiCode); // number of bits used by diff
	2681	Int iBitsUsedByDiff = uiCode + 1;
[2]	2682
[56]	2683	// read out tile start location
	2684	Int iLastSize = 0;
	2685	for (UInt uiIdx=0; uiIdx<rpcSlice->getTileLocationCount(); uiIdx++)
	2686	{
	2687	Int iAbsDiff, iCurSize, iCurDiff;
	2688	if (uiIdx==0)
	2689	{
	2690	xReadCode(iBitsUsedByDiff-1, uiCode); iAbsDiff = uiCode;
	2691	rpcSlice->setTileLocation( uiIdx, iAbsDiff );
	2692	iCurDiff = iAbsDiff;
	2693	iLastSize = iAbsDiff;
	2694	}
	2695	else
	2696	{
	2697	xReadCode(1, uiCode); // read sign
	2698	Int iSign = (uiCode) ? -1 : +1;
	2699
	2700	xReadCode(iBitsUsedByDiff-1, uiCode); iAbsDiff = uiCode;
	2701	iCurDiff = (iSign) * iAbsDiff;
	2702	iCurSize = iLastSize + iCurDiff;
	2703	iLastSize = iCurSize;
	2704	rpcSlice->setTileLocation( uiIdx, rpcSlice->getTileLocation( uiIdx-1 ) + iCurSize ); // calculate byte location
	2705	}
	2706	}
	2707	}
	2708	#endif
	2709
	2710	// read out trailing bits
	2711	m_pcBitstream->readOutTrailingBits();
	2712	#if !REMOVE_TILE_DEPENDENCE
	2713	}
	2714	#endif
[2]	2715	}
	2716	return;
	2717	}
	2718
[56]	2719	Void TDecCavlc::xParseAlfCuControlParam(AlfCUCtrlInfo& cAlfParam, Int iNumCUsInPic)
[2]	2720	{
[56]	2721	UInt uiSymbol;
	2722	Int iSymbol;
[2]	2723
[56]	2724	READ_FLAG (uiSymbol, "alf_cu_control_flag");
	2725	cAlfParam.cu_control_flag = uiSymbol;
	2726	if (cAlfParam.cu_control_flag)
[2]	2727	{
[56]	2728	READ_UVLC (uiSymbol, "alf_cu_control_max_depth");
	2729	cAlfParam.alf_max_depth = uiSymbol;
[2]	2730
[56]	2731	READ_SVLC (iSymbol, "alf_length_cu_control_info");
	2732	cAlfParam.num_alf_cu_flag = (UInt)(iSymbol + iNumCUsInPic);
[2]	2733
[56]	2734	cAlfParam.alf_cu_flag.resize(cAlfParam.num_alf_cu_flag);
	2735
	2736	for(UInt i=0; i< cAlfParam.num_alf_cu_flag; i++)
	2737	{
	2738	READ_FLAG (cAlfParam.alf_cu_flag[i], "alf_cu_flag");
	2739	}
[2]	2740	}
[56]	2741	}
[2]	2742
[56]	2743	#if !CABAC_INIT_FLAG
	2744	Void TDecCavlc::resetEntropy (TComSlice* pcSlice)
	2745	{
[2]	2746	}
	2747	#endif
[56]	2748
	2749	Void TDecCavlc::parseTerminatingBit( UInt& ruiBit )
[2]	2750	{
[56]	2751	ruiBit = false;
	2752	Int iBitsLeft = m_pcBitstream->getNumBitsLeft();
	2753	if(iBitsLeft <= 8)
[2]	2754	{
[56]	2755	UInt uiPeekValue = m_pcBitstream->peekBits(iBitsLeft);
	2756	if (uiPeekValue == (1<<(iBitsLeft-1)))
	2757	{
	2758	ruiBit = true;
	2759	}
[2]	2760	}
	2761	}
	2762
[56]	2763	Void TDecCavlc::parseSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
[2]	2764	{
[56]	2765	assert(0);
	2766	}
[2]	2767
[189]	2768	#if LGE_ILLUCOMP_B0045
	2769	Void TDecCavlc::parseICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2770	{
	2771	assert(0);
	2772	}
	2773	#endif
	2774
[56]	2775	#if HHI_INTER_VIEW_MOTION_PRED
	2776	Void TDecCavlc::parseMVPIdx( Int& riMVPIdx, Int iAMVPCands )
[2]	2777	#else
[56]	2778	Void TDecCavlc::parseMVPIdx( Int& riMVPIdx )
[2]	2779	#endif
[56]	2780	{
	2781	assert(0);
	2782	}
[2]	2783
[56]	2784	Void TDecCavlc::parseSplitFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2785	{
	2786	assert(0);
	2787	}
[2]	2788
[56]	2789	Void TDecCavlc::parsePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2790	{
	2791	assert(0);
	2792	}
[2]	2793
[56]	2794	Void TDecCavlc::parsePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2795	{
	2796	assert(0);
	2797	}
[2]	2798
[56]	2799	/** Parse I_PCM information.
	2800	* \param pcCU pointer to CU
	2801	* \param uiAbsPartIdx CU index
	2802	* \param uiDepth CU depth
	2803	* \returns Void
	2804	*
	2805	* If I_PCM flag indicates that the CU is I_PCM, parse its PCM alignment bits and codes.
	2806	*/
	2807	Void TDecCavlc::parseIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2808	{
	2809	#if BURST_IPCM
	2810	assert(0);
[2]	2811	#else
[56]	2812	UInt uiSymbol;
[2]	2813
[56]	2814	xReadFlag( uiSymbol );
[2]	2815
[56]	2816	if ( uiSymbol )
	2817	{
	2818	Bool bIpcmFlag = true;
[2]	2819
[56]	2820	xReadPCMAlignZero();
[2]	2821
[56]	2822	pcCU->setPartSizeSubParts ( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
	2823	pcCU->setSizeSubParts ( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
	2824	pcCU->setIPCMFlagSubParts ( bIpcmFlag, uiAbsPartIdx, uiDepth );
[2]	2825
[56]	2826	UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
	2827	UInt uiLumaOffset = uiMinCoeffSize*uiAbsPartIdx;
	2828	UInt uiChromaOffset = uiLumaOffset>>2;
[2]	2829
[56]	2830	Pel* piPCMSample;
	2831	UInt uiWidth;
	2832	UInt uiHeight;
	2833	UInt uiSampleBits;
	2834	UInt uiX, uiY;
[2]	2835
[56]	2836	piPCMSample = pcCU->getPCMSampleY() + uiLumaOffset;
	2837	uiWidth = pcCU->getWidth(uiAbsPartIdx);
	2838	uiHeight = pcCU->getHeight(uiAbsPartIdx);
	2839	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
[2]	2840
[56]	2841	for(uiY = 0; uiY < uiHeight; uiY++)
[2]	2842	{
[56]	2843	for(uiX = 0; uiX < uiWidth; uiX++)
[2]	2844	{
[56]	2845	UInt uiSample;
	2846	xReadCode(uiSampleBits, uiSample);
	2847
	2848	piPCMSample[uiX] = uiSample;
[2]	2849	}
[56]	2850	piPCMSample += uiWidth;
[2]	2851	}
	2852
[56]	2853	piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
	2854	uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
	2855	uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
	2856	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
[2]	2857
[56]	2858	for(uiY = 0; uiY < uiHeight; uiY++)
[2]	2859	{
[56]	2860	for(uiX = 0; uiX < uiWidth; uiX++)
[2]	2861	{
[56]	2862	UInt uiSample;
	2863	xReadCode(uiSampleBits, uiSample);
	2864	piPCMSample[uiX] = uiSample;
[2]	2865	}
[56]	2866	piPCMSample += uiWidth;
[2]	2867	}
	2868
[56]	2869	piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
	2870	uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
	2871	uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
	2872	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
	2873
	2874	for(uiY = 0; uiY < uiHeight; uiY++)
[2]	2875	{
[56]	2876	for(uiX = 0; uiX < uiWidth; uiX++)
[2]	2877	{
[56]	2878	UInt uiSample;
	2879	xReadCode(uiSampleBits, uiSample);
	2880	piPCMSample[uiX] = uiSample;
[2]	2881	}
[56]	2882	piPCMSample += uiWidth;
[2]	2883	}
	2884	}
[56]	2885	#endif
[2]	2886	}
	2887
[56]	2888	Void TDecCavlc::parseIntraDirLumaAng ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2889	{
	2890	assert(0);
[2]	2891	}
	2892
[56]	2893	Void TDecCavlc::parseIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
[2]	2894	{
[56]	2895	assert(0);
[2]	2896	}
	2897
[56]	2898	Void TDecCavlc::parseInterDir( TComDataCU* pcCU, UInt& ruiInterDir, UInt uiAbsPartIdx, UInt uiDepth )
[2]	2899	{
[56]	2900	assert(0);
[2]	2901	}
	2902
[56]	2903	Void TDecCavlc::parseRefFrmIdx( TComDataCU* pcCU, Int& riRefFrmIdx, UInt uiAbsPartIdx, UInt uiDepth, RefPicList eRefList )
[2]	2904	{
[56]	2905	assert(0);
[2]	2906	}
	2907
[56]	2908	Void TDecCavlc::parseMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth, RefPicList eRefList )
[2]	2909	{
[56]	2910	assert(0);
[2]	2911	}
	2912
[56]	2913	Void TDecCavlc::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
[2]	2914	{
[56]	2915	#if H0736_AVC_STYLE_QP_RANGE
	2916	Int qp;
	2917	#else
	2918	UInt uiQp;
[2]	2919	#endif
[56]	2920	Int iDQp;
	2921
	2922	xReadSvlc( iDQp );
[2]	2923
[56]	2924	#if H0736_AVC_STYLE_QP_RANGE
	2925	Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
	2926	qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+ qpBdOffsetY)) - qpBdOffsetY;
	2927	#else
	2928	uiQp = pcCU->getRefQP( uiAbsPartIdx ) + iDQp;
	2929	#endif
	2930
	2931	UInt uiAbsQpCUPartIdx = (uiAbsPartIdx>>(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)))<<(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)) ;
	2932	UInt uiQpCUDepth = min(uiDepth,pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()) ;
	2933
	2934	#if H0736_AVC_STYLE_QP_RANGE
	2935	pcCU->setQPSubParts( qp, uiAbsQpCUPartIdx, uiQpCUDepth );
	2936	#else
	2937	pcCU->setQPSubParts( uiQp, uiAbsQpCUPartIdx, uiQpCUDepth );
	2938	#endif
[2]	2939	}
	2940
[56]	2941	Void TDecCavlc::parseCoeffNxN( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType )
[2]	2942	{
[56]	2943	assert(0);
[2]	2944	}
	2945
[56]	2946	Void TDecCavlc::parseTransformSubdivFlag( UInt& ruiSubdivFlag, UInt uiLog2TransformBlockSize )
[2]	2947	{
[56]	2948	assert(0);
[2]	2949	}
	2950
[56]	2951	Void TDecCavlc::parseQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth, UInt uiDepth )
[2]	2952	{
[56]	2953	assert(0);
[2]	2954	}
	2955
[56]	2956	Void TDecCavlc::parseQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt& uiQtRootCbf )
[2]	2957	{
[56]	2958	assert(0);
[2]	2959	}
	2960
	2961
[56]	2962	Void TDecCavlc::parseMergeFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx )
[2]	2963	{
[56]	2964	assert(0);
[2]	2965	}
	2966
	2967	Void TDecCavlc::parseMergeIndex ( TComDataCU* pcCU, UInt& ruiMergeIndex, UInt uiAbsPartIdx, UInt uiDepth )
	2968	{
[56]	2969	assert(0);
[2]	2970	}
	2971
[56]	2972	#if HHI_INTER_VIEW_RESIDUAL_PRED
[2]	2973	Void
	2974	TDecCavlc::parseResPredFlag( TComDataCU* pcCU, Bool& rbResPredFlag, UInt uiAbsPartIdx, UInt uiDepth )
	2975	{
[56]	2976	assert(0);
[2]	2977	}
[56]	2978	#endif
[2]	2979
[189]	2980	#if RWTH_SDC_DLT_B0036
	2981	Void TDecCavlc::parseSDCFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2982	{
	2983	assert(0);
	2984	}
	2985	Void TDecCavlc::parseSDCPredMode ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2986	{
	2987	assert(0);
	2988	}
	2989	Void TDecCavlc::parseSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPart )
	2990	{
	2991	assert(0);
	2992	}
	2993	#endif
	2994
[2]	2995	// ====================================================================================================================
	2996	// Protected member functions
	2997	// ====================================================================================================================
	2998
	2999	Void TDecCavlc::xReadCode (UInt uiLength, UInt& ruiCode)
	3000	{
	3001	assert ( uiLength > 0 );
	3002	m_pcBitstream->read (uiLength, ruiCode);
	3003	}
	3004
	3005	Void TDecCavlc::xReadUvlc( UInt& ruiVal)
	3006	{
	3007	UInt uiVal = 0;
	3008	UInt uiCode = 0;
	3009	UInt uiLength;
	3010	m_pcBitstream->read( 1, uiCode );
[56]	3011
[2]	3012	if( 0 == uiCode )
	3013	{
	3014	uiLength = 0;
[56]	3015
[2]	3016	while( ! ( uiCode & 1 ))
	3017	{
	3018	m_pcBitstream->read( 1, uiCode );
	3019	uiLength++;
	3020	}
[56]	3021
[2]	3022	m_pcBitstream->read( uiLength, uiVal );
[56]	3023
[2]	3024	uiVal += (1 << uiLength)-1;
	3025	}
[56]	3026
[2]	3027	ruiVal = uiVal;
	3028	}
	3029
	3030	Void TDecCavlc::xReadSvlc( Int& riVal)
	3031	{
	3032	UInt uiBits = 0;
	3033	m_pcBitstream->read( 1, uiBits );
	3034	if( 0 == uiBits )
	3035	{
	3036	UInt uiLength = 0;
[56]	3037
[2]	3038	while( ! ( uiBits & 1 ))
	3039	{
	3040	m_pcBitstream->read( 1, uiBits );
	3041	uiLength++;
	3042	}
[56]	3043
[2]	3044	m_pcBitstream->read( uiLength, uiBits );
[56]	3045
[2]	3046	uiBits += (1 << uiLength);
	3047	riVal = ( uiBits & 1) ? -(Int)(uiBits>>1) : (Int)(uiBits>>1);
	3048	}
	3049	else
	3050	{
	3051	riVal = 0;
	3052	}
	3053	}
	3054
	3055	Void TDecCavlc::xReadFlag (UInt& ruiCode)
	3056	{
	3057	m_pcBitstream->read( 1, ruiCode );
	3058	}
	3059
[210]	3060	#if QC_MVHEVC_B0046
	3061	/** Parse VPS alignment one bits.
	3062	* \returns Void
	3063	*/
	3064	Void TDecCavlc::xReadVPSAlignOne( )
	3065	{
	3066	UInt uiNumberOfBits = m_pcBitstream->getNumBitsUntilByteAligned();
	3067
	3068	if(uiNumberOfBits)
	3069	{
	3070	UInt uiBits;
	3071	UInt uiSymbol;
	3072
	3073	for(uiBits = 0; uiBits < uiNumberOfBits; uiBits++)
	3074	{
	3075	xReadFlag( uiSymbol );
	3076
	3077	if(!uiSymbol)
	3078	{
	3079	printf("\nWarning! vps_extension_byte_alignment_reserved_one_bit include a non-zero value.\n");
	3080	}
	3081	}
	3082	}
	3083	}
	3084	#endif
[56]	3085	/** Parse PCM alignment zero bits.
	3086	* \returns Void
	3087	*/
	3088	Void TDecCavlc::xReadPCMAlignZero( )
	3089	{
	3090	UInt uiNumberOfBits = m_pcBitstream->getNumBitsUntilByteAligned();
	3091
	3092	if(uiNumberOfBits)
	3093	{
	3094	UInt uiBits;
	3095	UInt uiSymbol;
	3096
	3097	for(uiBits = 0; uiBits < uiNumberOfBits; uiBits++)
	3098	{
	3099	xReadFlag( uiSymbol );
	3100
	3101	if(uiSymbol)
	3102	{
	3103	printf("\nWarning! pcm_align_zero include a non-zero value.\n");
	3104	}
	3105	}
	3106	}
	3107	}
	3108
[2]	3109	Void TDecCavlc::xReadUnaryMaxSymbol( UInt& ruiSymbol, UInt uiMaxSymbol )
	3110	{
	3111	if (uiMaxSymbol == 0)
	3112	{
	3113	ruiSymbol = 0;
	3114	return;
	3115	}
[56]	3116
[2]	3117	xReadFlag( ruiSymbol );
[56]	3118
[2]	3119	if (ruiSymbol == 0 \|\| uiMaxSymbol == 1)
	3120	{
	3121	return;
	3122	}
[56]	3123
[2]	3124	UInt uiSymbol = 0;
	3125	UInt uiCont;
[56]	3126
[2]	3127	do
	3128	{
	3129	xReadFlag( uiCont );
	3130	uiSymbol++;
	3131	}
	3132	while( uiCont && (uiSymbol < uiMaxSymbol-1) );
[56]	3133
[2]	3134	if( uiCont && (uiSymbol == uiMaxSymbol-1) )
	3135	{
	3136	uiSymbol++;
	3137	}
[56]	3138
[2]	3139	ruiSymbol = uiSymbol;
	3140	}
	3141
	3142	Void TDecCavlc::xReadExGolombLevel( UInt& ruiSymbol )
	3143	{
	3144	UInt uiSymbol ;
	3145	UInt uiCount = 0;
	3146	do
	3147	{
	3148	xReadFlag( uiSymbol );
	3149	uiCount++;
	3150	}
	3151	while( uiSymbol && (uiCount != 13));
[56]	3152
[2]	3153	ruiSymbol = uiCount-1;
[56]	3154
[2]	3155	if( uiSymbol )
	3156	{
	3157	xReadEpExGolomb( uiSymbol, 0 );
	3158	ruiSymbol += uiSymbol+1;
	3159	}
[56]	3160
[2]	3161	return;
	3162	}
	3163
	3164	Void TDecCavlc::xReadEpExGolomb( UInt& ruiSymbol, UInt uiCount )
	3165	{
	3166	UInt uiSymbol = 0;
	3167	UInt uiBit = 1;
[56]	3168
	3169
[2]	3170	while( uiBit )
	3171	{
	3172	xReadFlag( uiBit );
	3173	uiSymbol += uiBit << uiCount++;
	3174	}
[56]	3175
[2]	3176	uiCount--;
	3177	while( uiCount-- )
	3178	{
	3179	xReadFlag( uiBit );
	3180	uiSymbol += uiBit << uiCount;
	3181	}
[56]	3182
[2]	3183	ruiSymbol = uiSymbol;
[56]	3184
[2]	3185	return;
	3186	}
	3187
	3188	UInt TDecCavlc::xGetBit()
	3189	{
	3190	UInt ruiCode;
	3191	m_pcBitstream->read( 1, ruiCode );
	3192	return ruiCode;
	3193	}
	3194
[56]	3195
	3196	/** parse explicit wp tables
	3197	* \param TComSlice* pcSlice
	3198	* \returns Void
	3199	*/
	3200	Void TDecCavlc::xParsePredWeightTable( TComSlice* pcSlice )
[2]	3201	{
[56]	3202	wpScalingParam *wp;
	3203	Bool bChroma = true; // color always present in HEVC ?
	3204	TComPPS* pps = pcSlice->getPPS();
	3205	SliceType eSliceType = pcSlice->getSliceType();
	3206	Int iNbRef = (eSliceType == B_SLICE ) ? (2) : (1);
	3207	UInt uiLog2WeightDenomLuma, uiLog2WeightDenomChroma;
	3208	UInt uiMode = 0;
[2]	3209
[56]	3210	if ( (eSliceType==P_SLICE && pps->getUseWP()) \|\| (eSliceType==B_SLICE && pps->getWPBiPredIdc()==1 && pcSlice->getRefPicListCombinationFlag()==0) )
	3211	uiMode = 1; // explicit
	3212	else if ( eSliceType==B_SLICE && pps->getWPBiPredIdc()==2 )
	3213	uiMode = 2; // implicit
	3214	else if (eSliceType==B_SLICE && pps->getWPBiPredIdc()==1 && pcSlice->getRefPicListCombinationFlag())
	3215	uiMode = 3; // combined explicit
[2]	3216
[56]	3217	if ( uiMode == 1 ) // explicit
[2]	3218	{
[56]	3219	printf("\nTDecCavlc::xParsePredWeightTable(poc=%d) explicit...\n", pcSlice->getPOC());
	3220	Int iDeltaDenom;
	3221	// decode delta_luma_log2_weight_denom :
	3222	READ_UVLC( uiLog2WeightDenomLuma, "luma_log2_weight_denom" ); // ue(v): luma_log2_weight_denom
	3223	if( bChroma )
[2]	3224	{
[56]	3225	READ_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" ); // se(v): delta_chroma_log2_weight_denom
	3226	assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)>=0);
	3227	uiLog2WeightDenomChroma = (UInt)(iDeltaDenom + uiLog2WeightDenomLuma);
	3228	}
	3229
	3230	for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ )
	3231	{
	3232	RefPicList eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
	3233	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
[2]	3234	{
[56]	3235	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
	3236
	3237	wp[0].uiLog2WeightDenom = uiLog2WeightDenomLuma;
	3238	wp[1].uiLog2WeightDenom = uiLog2WeightDenomChroma;
	3239	wp[2].uiLog2WeightDenom = uiLog2WeightDenomChroma;
	3240
	3241	UInt uiCode;
	3242	READ_FLAG( uiCode, "luma_weight_lX_flag" ); // u(1): luma_weight_l0_flag
	3243	wp[0].bPresentFlag = ( uiCode == 1 );
	3244	if ( wp[0].bPresentFlag )
[2]	3245	{
[56]	3246	Int iDeltaWeight;
	3247	READ_SVLC( iDeltaWeight, "delta_luma_weight_lX" ); // se(v): delta_luma_weight_l0[i]
	3248	wp[0].iWeight = (iDeltaWeight + (1<<wp[0].uiLog2WeightDenom));
	3249	READ_SVLC( wp[0].iOffset, "luma_offset_lX" ); // se(v): luma_offset_l0[i]
[2]	3250	}
[56]	3251	else
[2]	3252	{
[56]	3253	wp[0].iWeight = (1 << wp[0].uiLog2WeightDenom);
	3254	wp[0].iOffset = 0;
[2]	3255	}
[56]	3256	if ( bChroma )
[2]	3257	{
[56]	3258	READ_FLAG( uiCode, "chroma_weight_lX_flag" ); // u(1): chroma_weight_l0_flag
	3259	wp[1].bPresentFlag = ( uiCode == 1 );
	3260	wp[2].bPresentFlag = ( uiCode == 1 );
	3261	if ( wp[1].bPresentFlag )
[2]	3262	{
[56]	3263	for ( Int j=1 ; j<3 ; j++ )
	3264	{
	3265	Int iDeltaWeight;
	3266	READ_SVLC( iDeltaWeight, "delta_chroma_weight_lX" ); // se(v): chroma_weight_l0[i][j]
	3267	wp[j].iWeight = (iDeltaWeight + (1<<wp[1].uiLog2WeightDenom));
	3268
	3269	Int iDeltaChroma;
	3270	READ_SVLC( iDeltaChroma, "delta_chroma_offset_lX" ); // se(v): delta_chroma_offset_l0[i][j]
	3271	wp[j].iOffset = iDeltaChroma - ( ( (g_uiIBDI_MAX>>1)*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) + (g_uiIBDI_MAX>>1);
	3272	}
[2]	3273	}
[56]	3274	else
[2]	3275	{
[56]	3276	for ( Int j=1 ; j<3 ; j++ )
	3277	{
	3278	wp[j].iWeight = (1 << wp[j].uiLog2WeightDenom);
	3279	wp[j].iOffset = 0;
	3280	}
[2]	3281	}
	3282	}
	3283	}
[56]	3284
	3285	for ( Int iRefIdx=pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx<MAX_NUM_REF ; iRefIdx++ )
[2]	3286	{
[56]	3287	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
	3288
	3289	wp[0].bPresentFlag = false;
	3290	wp[1].bPresentFlag = false;
	3291	wp[2].bPresentFlag = false;
[2]	3292	}
	3293	}
	3294	}
[56]	3295	else if ( uiMode == 2 ) // implicit
[2]	3296	{
[56]	3297	printf("\nTDecCavlc::xParsePredWeightTable(poc=%d) implicit...\n", pcSlice->getPOC());
[2]	3298	}
[56]	3299	else if ( uiMode == 3 ) // combined explicit
[2]	3300	{
[56]	3301	printf("\nTDecCavlc::xParsePredWeightTable(poc=%d) combined explicit...\n", pcSlice->getPOC());
	3302	Int iDeltaDenom;
	3303	// decode delta_luma_log2_weight_denom :
	3304	READ_UVLC ( uiLog2WeightDenomLuma, "luma_log2_weight_denom" ); // ue(v): luma_log2_weight_denom
	3305	if( bChroma )
[2]	3306	{
[56]	3307	READ_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" ); // ue(v): delta_chroma_log2_weight_denom
	3308	assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)>=0);
	3309	uiLog2WeightDenomChroma = (UInt)(iDeltaDenom + uiLog2WeightDenomLuma);
[2]	3310	}
[56]	3311
	3312	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(REF_PIC_LIST_C) ; iRefIdx++ )
[2]	3313	{
[56]	3314	pcSlice->getWpScalingLC(iRefIdx, wp);
	3315
	3316	wp[0].uiLog2WeightDenom = uiLog2WeightDenomLuma;
	3317	wp[1].uiLog2WeightDenom = uiLog2WeightDenomChroma;
	3318	wp[2].uiLog2WeightDenom = uiLog2WeightDenomChroma;
	3319
	3320	UInt uiCode;
	3321	READ_FLAG( uiCode, "luma_weight_lc_flag" ); // u(1): luma_weight_lc_flag
	3322	wp[0].bPresentFlag = ( uiCode == 1 );
	3323	if ( wp[0].bPresentFlag )
[2]	3324	{
[56]	3325	Int iDeltaWeight;
	3326	READ_SVLC( iDeltaWeight, "delta_luma_weight_lc" ); // se(v): delta_luma_weight_lc
	3327	wp[0].iWeight = (iDeltaWeight + (1<<wp[0].uiLog2WeightDenom));
	3328	READ_SVLC( wp[0].iOffset, "luma_offset_lc" ); // se(v): luma_offset_lc
[2]	3329	}
[56]	3330	else
[2]	3331	{
[56]	3332	wp[0].iWeight = (1 << wp[0].uiLog2WeightDenom);
	3333	wp[0].iOffset = 0;
[2]	3334	}
[56]	3335	if ( bChroma )
[2]	3336	{
[56]	3337	READ_FLAG( uiCode, "chroma_weight_lc_flag" ); // u(1): chroma_weight_lc_flag
	3338	wp[1].bPresentFlag = ( uiCode == 1 );
	3339	wp[2].bPresentFlag = ( uiCode == 1 );
	3340	if ( wp[1].bPresentFlag )
[2]	3341	{
[56]	3342	for ( Int j=1 ; j<3 ; j++ )
[2]	3343	{
[56]	3344	Int iDeltaWeight;
	3345	READ_SVLC( iDeltaWeight, "delta_chroma_weight_lc" ); // se(v): delta_chroma_weight_lc
	3346	wp[j].iWeight = (iDeltaWeight + (1<<wp[1].uiLog2WeightDenom));
	3347
	3348	Int iDeltaChroma;
	3349	READ_SVLC( iDeltaChroma, "delta_chroma_offset_lc" ); // se(v): delta_chroma_offset_lc
	3350	wp[j].iOffset = iDeltaChroma - ( ( (g_uiIBDI_MAX>>1)*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) + (g_uiIBDI_MAX>>1);
[2]	3351	}
	3352	}
[56]	3353	else
[2]	3354	{
[56]	3355	for ( Int j=1 ; j<3 ; j++ )
[2]	3356	{
[56]	3357	wp[j].iWeight = (1 << wp[j].uiLog2WeightDenom);
	3358	wp[j].iOffset = 0;
[2]	3359	}
	3360	}
	3361	}
	3362	}
	3363
[56]	3364	for ( Int iRefIdx=pcSlice->getNumRefIdx(REF_PIC_LIST_C) ; iRefIdx<2*MAX_NUM_REF ; iRefIdx++ )
[2]	3365	{
[56]	3366	pcSlice->getWpScalingLC(iRefIdx, wp);
[2]	3367
[56]	3368	wp[0].bPresentFlag = false;
	3369	wp[1].bPresentFlag = false;
	3370	wp[2].bPresentFlag = false;
[2]	3371	}
	3372	}
	3373	else
	3374	{
[56]	3375	printf("\n wrong weight pred table syntax \n ");
	3376	assert(0);
[2]	3377	}
	3378	}
	3379
[56]	3380	/** decode quantization matrix
	3381	* \param scalingList quantization matrix information
[2]	3382	*/
[56]	3383	Void TDecCavlc::parseScalingList(TComScalingList* scalingList)
[2]	3384	{
[56]	3385	UInt code, sizeId, listId;
	3386	Bool scalingListPredModeFlag;
	3387	READ_FLAG( code, "scaling_list_present_flag" );
	3388	scalingList->setScalingListPresentFlag ( (code==1)?true:false );
	3389	if(scalingList->getScalingListPresentFlag() == false)
[2]	3390	{
[56]	3391	//for each size
	3392	for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
[2]	3393	{
[56]	3394	for(listId = 0; listId < g_scalingListNum[sizeId]; listId++)
[2]	3395	{
[56]	3396	READ_FLAG( code, "scaling_list_pred_mode_flag");
	3397	scalingListPredModeFlag = (code) ? true : false;
	3398	if(!scalingListPredModeFlag) //Copy Mode
[2]	3399	{
[56]	3400	READ_UVLC( code, "scaling_list_pred_matrix_id_delta");
	3401	scalingList->setRefMatrixId (sizeId,listId,(UInt)((Int)(listId)-(code+1)));
	3402	#if SCALING_LIST
	3403	if( sizeId > SCALING_LIST_8x8 )
[2]	3404	{
[56]	3405	scalingList->setScalingListDC(sizeId,listId,scalingList->getScalingListDC(sizeId, scalingList->getRefMatrixId (sizeId,listId)));
[2]	3406	}
[56]	3407	#endif
	3408	scalingList->processRefMatrix( sizeId, listId, scalingList->getRefMatrixId (sizeId,listId));
	3409
[2]	3410	}
[56]	3411	else //DPCM Mode
[2]	3412	{
[56]	3413	xDecodeScalingList(scalingList, sizeId, listId);
[2]	3414	}
	3415	}
	3416	}
	3417	}
	3418
	3419	return;
	3420	}
[56]	3421	/** decode DPCM
	3422	* \param scalingList quantization matrix information
	3423	* \param sizeId size index
	3424	* \param listId list index
[2]	3425	*/
[56]	3426	Void TDecCavlc::xDecodeScalingList(TComScalingList *scalingList, UInt sizeId, UInt listId)
[2]	3427	{
[56]	3428	#if SCALING_LIST
	3429	Int i,coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
	3430	Int data;
	3431	Int scalingListDcCoefMinus8 = 0;
	3432	Int nextCoef = SCALING_LIST_START_VALUE;
	3433	UInt* scan = g_auiFrameScanXY [ (sizeId == 0)? 1 : 2 ];
	3434	Bool stopNow = false;
	3435	Int *dst = scalingList->getScalingListAddress(sizeId, listId);
[2]	3436
[56]	3437	scalingList->setUseDefaultScalingMatrixFlag(sizeId,listId,false);
	3438	if( sizeId > SCALING_LIST_8x8 )
[2]	3439	{
[56]	3440	READ_SVLC( scalingListDcCoefMinus8, "scaling_list_dc_coef_minus8");
	3441	scalingList->setScalingListDC(sizeId,listId,scalingListDcCoefMinus8 + 8);
	3442	if(scalingListDcCoefMinus8 == -8)
	3443	{
	3444	scalingList->processDefaultMarix(sizeId,listId);
	3445	}
[2]	3446	}
	3447
[56]	3448	if( !scalingList->getUseDefaultScalingMatrixFlag(sizeId,listId))
[2]	3449	{
[56]	3450	for(i = 0; i < coefNum && !stopNow ; i++)
[2]	3451	{
[56]	3452	READ_SVLC( data, "scaling_list_delta_coef");
	3453	nextCoef = (nextCoef + data + 256 ) % 256;
	3454	if(sizeId < SCALING_LIST_16x16)
[2]	3455	{
[56]	3456	if( i == 0 && nextCoef == 0 )
[2]	3457	{
[56]	3458	scalingList->processDefaultMarix(sizeId,listId);
	3459	stopNow = true;
[2]	3460	}
	3461	}
[56]	3462	if(!stopNow)
[2]	3463	{
[56]	3464	dst[scan[i]] = nextCoef;
[2]	3465	}
	3466	}
	3467	}
[56]	3468	#else
	3469	Int i,coefNum = g_scalingListSize[sizeId];
	3470	Int data;
	3471	Int nextCoef = SCALING_LIST_START_VALUE;
	3472	UInt* scan = g_auiFrameScanXY [ sizeId + 1 ];
	3473	Int *dst = scalingList->getScalingListAddress(sizeId, listId);
[2]	3474
[56]	3475	for(i = 0; i < coefNum; i++)
[2]	3476	{
[56]	3477	READ_SVLC( data, "scaling_list_delta_coef");
	3478	nextCoef = (nextCoef + data + 256 ) % 256;
	3479	dst[scan[i]] = nextCoef;
[2]	3480	}
[56]	3481	#endif
[2]	3482	}
	3483
[56]	3484	Void TDecCavlc::parseDFFlag(UInt& ruiVal, const Char *pSymbolName)
[2]	3485	{
[56]	3486	READ_FLAG(ruiVal, pSymbolName);
	3487	}
	3488	Void TDecCavlc::parseDFSvlc(Int& riVal, const Char *pSymbolName)
	3489	{
	3490	READ_SVLC(riVal, pSymbolName);
	3491	}
[2]	3492
[56]	3493	Bool TDecCavlc::xMoreRbspData()
	3494	{
	3495	Int bitsLeft = m_pcBitstream->getNumBitsLeft();
[2]	3496
[56]	3497	// if there are more than 8 bits, it cannot be rbsp_trailing_bits
	3498	if (bitsLeft > 8)
[2]	3499	{
[56]	3500	return true;
	3501	}
[2]	3502
[56]	3503	UChar lastByte = m_pcBitstream->peekBits(bitsLeft);
	3504	Int cnt = bitsLeft;
[2]	3505
[56]	3506	// remove trailing bits equal to zero
	3507	while ((cnt>0) && ((lastByte & 1) == 0))
	3508	{
	3509	lastByte >>= 1;
	3510	cnt--;
	3511	}
	3512	// remove bit equal to one
	3513	cnt--;
[2]	3514
[56]	3515	// we should not have a negative number of bits
	3516	assert (cnt>=0);
[2]	3517
[56]	3518	// we have more data, if cnt is not zero
	3519	return (cnt>0);
	3520	}
[2]	3521
[56]	3522	//! \}

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

JCT-3V 3D-HEVC

Context navigation

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

Download in other formats: