Context navigation

TDecCAVLC.cpp @ 890

Visit:

Last change on this file since 890 was 889, checked in by qualcomm, 11 years ago

Fix for signalling of bitrate and picture rate info in VPS VUI to be more aligned to JCTVC-R1008

MACRO: SIGNALLING_BITRATE_PICRATE_FIX

submitted by Hendry (fhendry@…)

Property svn:eol-style set to native

File size: 156.1 KB

Rev	Line
[313]	1	/* The copyright in this software is being made available under the BSD
	2	* License, included below. This software may be subject to other third party
	3	* and contributor rights, including patent rights, and no such rights are
	4	* granted under this license.
	5	*
[595]	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
[313]	7	* All rights reserved.
	8	*
	9	* Redistribution and use in source and binary forms, with or without
	10	* modification, are permitted provided that the following conditions are met:
	11	*
	12	* * Redistributions of source code must retain the above copyright notice,
	13	* this list of conditions and the following disclaimer.
	14	* * Redistributions in binary form must reproduce the above copyright notice,
	15	* this list of conditions and the following disclaimer in the documentation
	16	* and/or other materials provided with the distribution.
	17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
	18	* be used to endorse or promote products derived from this software without
	19	* specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
	25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	31	* THE POSSIBILITY OF SUCH DAMAGE.
	32	*/
	33
	34	/** \file TDecCAVLC.cpp
	35	\brief CAVLC decoder class
	36	*/
	37
	38	#include "TDecCAVLC.h"
	39	#include "SEIread.h"
	40	#include "TDecSlice.h"
[713]	41	#if Q0048_CGS_3D_ASYMLUT
	42	#include "../TLibCommon/TCom3DAsymLUT.h"
	43	#endif
[313]	44
	45	//! \ingroup TLibDecoder
	46	//! \{
	47
	48	#if ENC_DEC_TRACE
	49
	50	Void xTraceSPSHeader (TComSPS *pSPS)
	51	{
	52	fprintf( g_hTrace, "=========== Sequence Parameter Set ID: %d ===========\n", pSPS->getSPSId() );
	53	}
	54
	55	Void xTracePPSHeader (TComPPS *pPPS)
	56	{
	57	fprintf( g_hTrace, "=========== Picture Parameter Set ID: %d ===========\n", pPPS->getPPSId() );
	58	}
	59
	60	Void xTraceSliceHeader (TComSlice *pSlice)
	61	{
	62	fprintf( g_hTrace, "=========== Slice ===========\n");
	63	}
	64
	65	#endif
	66
	67	// ====================================================================================================================
	68	// Constructor / destructor / create / destroy
	69	// ====================================================================================================================
	70
	71	TDecCavlc::TDecCavlc()
	72	{
	73	}
	74
	75	TDecCavlc::~TDecCavlc()
	76	{
	77
	78	}
	79
	80	// ====================================================================================================================
	81	// Public member functions
	82	// ====================================================================================================================
	83
	84	void TDecCavlc::parseShortTermRefPicSet( TComSPS* sps, TComReferencePictureSet* rps, Int idx )
	85	{
	86	UInt code;
	87	UInt interRPSPred;
	88	if (idx > 0)
	89	{
	90	READ_FLAG(interRPSPred, "inter_ref_pic_set_prediction_flag"); rps->setInterRPSPrediction(interRPSPred);
	91	}
	92	else
	93	{
	94	interRPSPred = false;
	95	rps->setInterRPSPrediction(false);
	96	}
	97
	98	if (interRPSPred)
	99	{
	100	UInt bit;
	101	if(idx == sps->getRPSList()->getNumberOfReferencePictureSets())
	102	{
	103	READ_UVLC(code, "delta_idx_minus1" ); // delta index of the Reference Picture Set used for prediction minus 1
	104	}
	105	else
	106	{
	107	code = 0;
	108	}
	109	assert(code <= idx-1); // delta_idx_minus1 shall not be larger than idx-1, otherwise we will predict from a negative row position that does not exist. When idx equals 0 there is no legal value and interRPSPred must be zero. See J0185-r2
	110	Int rIdx = idx - 1 - code;
	111	assert (rIdx <= idx-1 && rIdx >= 0); // Made assert tighter; if rIdx = idx then prediction is done from itself. rIdx must belong to range 0, idx-1, inclusive, see J0185-r2
	112	TComReferencePictureSet* rpsRef = sps->getRPSList()->getReferencePictureSet(rIdx);
	113	Int k = 0, k0 = 0, k1 = 0;
	114	READ_CODE(1, bit, "delta_rps_sign"); // delta_RPS_sign
	115	READ_UVLC(code, "abs_delta_rps_minus1"); // absolute delta RPS minus 1
	116	Int deltaRPS = (1 - 2 * bit) * (code + 1); // delta_RPS
	117	for(Int j=0 ; j <= rpsRef->getNumberOfPictures(); j++)
	118	{
	119	READ_CODE(1, bit, "used_by_curr_pic_flag" ); //first bit is "1" if Idc is 1
	120	Int refIdc = bit;
	121	if (refIdc == 0)
	122	{
	123	READ_CODE(1, bit, "use_delta_flag" ); //second bit is "1" if Idc is 2, "0" otherwise.
	124	refIdc = bit<<1; //second bit is "1" if refIdc is 2, "0" if refIdc = 0.
	125	}
	126	if (refIdc == 1 \|\| refIdc == 2)
	127	{
	128	Int deltaPOC = deltaRPS + ((j < rpsRef->getNumberOfPictures())? rpsRef->getDeltaPOC(j) : 0);
	129	rps->setDeltaPOC(k, deltaPOC);
	130	rps->setUsed(k, (refIdc == 1));
	131
	132	if (deltaPOC < 0)
	133	{
	134	k0++;
	135	}
	136	else
	137	{
	138	k1++;
	139	}
	140	k++;
	141	}
	142	rps->setRefIdc(j,refIdc);
	143	}
	144	rps->setNumRefIdc(rpsRef->getNumberOfPictures()+1);
	145	rps->setNumberOfPictures(k);
	146	rps->setNumberOfNegativePictures(k0);
	147	rps->setNumberOfPositivePictures(k1);
	148	rps->sortDeltaPOC();
	149	}
	150	else
	151	{
	152	READ_UVLC(code, "num_negative_pics"); rps->setNumberOfNegativePictures(code);
	153	READ_UVLC(code, "num_positive_pics"); rps->setNumberOfPositivePictures(code);
	154	Int prev = 0;
	155	Int poc;
	156	for(Int j=0 ; j < rps->getNumberOfNegativePictures(); j++)
	157	{
	158	READ_UVLC(code, "delta_poc_s0_minus1");
	159	poc = prev-code-1;
	160	prev = poc;
	161	rps->setDeltaPOC(j,poc);
	162	READ_FLAG(code, "used_by_curr_pic_s0_flag"); rps->setUsed(j,code);
	163	}
	164	prev = 0;
	165	for(Int j=rps->getNumberOfNegativePictures(); j < rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures(); j++)
	166	{
	167	READ_UVLC(code, "delta_poc_s1_minus1");
	168	poc = prev+code+1;
	169	prev = poc;
	170	rps->setDeltaPOC(j,poc);
	171	READ_FLAG(code, "used_by_curr_pic_s1_flag"); rps->setUsed(j,code);
	172	}
	173	rps->setNumberOfPictures(rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures());
	174	}
	175	#if PRINT_RPS_INFO
	176	rps->printDeltaPOC();
	177	#endif
	178	}
	179
[713]	180	Void TDecCavlc::parsePPS(TComPPS* pcPPS
	181	#if Q0048_CGS_3D_ASYMLUT
	182	, TCom3DAsymLUT * pc3DAsymLUT , Int nLayerID
	183	#endif
	184	)
[313]	185	{
	186	#if ENC_DEC_TRACE
	187	xTracePPSHeader (pcPPS);
	188	#endif
	189	UInt uiCode;
	190
	191	Int iCode;
	192
	193	READ_UVLC( uiCode, "pps_pic_parameter_set_id");
	194	assert(uiCode <= 63);
	195	pcPPS->setPPSId (uiCode);
[494]	196
[313]	197	READ_UVLC( uiCode, "pps_seq_parameter_set_id");
	198	assert(uiCode <= 15);
	199	pcPPS->setSPSId (uiCode);
[494]	200
[313]	201	READ_FLAG( uiCode, "dependent_slice_segments_enabled_flag" ); pcPPS->setDependentSliceSegmentsEnabledFlag ( uiCode == 1 );
	202	READ_FLAG( uiCode, "output_flag_present_flag" ); pcPPS->setOutputFlagPresentFlag( uiCode==1 );
	203
	204	READ_CODE(3, uiCode, "num_extra_slice_header_bits"); pcPPS->setNumExtraSliceHeaderBits(uiCode);
	205	READ_FLAG ( uiCode, "sign_data_hiding_flag" ); pcPPS->setSignHideFlag( uiCode );
	206
	207	READ_FLAG( uiCode, "cabac_init_present_flag" ); pcPPS->setCabacInitPresentFlag( uiCode ? true : false );
	208
	209	READ_UVLC(uiCode, "num_ref_idx_l0_default_active_minus1");
	210	assert(uiCode <= 14);
	211	pcPPS->setNumRefIdxL0DefaultActive(uiCode+1);
	212
	213	READ_UVLC(uiCode, "num_ref_idx_l1_default_active_minus1");
	214	assert(uiCode <= 14);
	215	pcPPS->setNumRefIdxL1DefaultActive(uiCode+1);
	216
	217	READ_SVLC(iCode, "init_qp_minus26" ); pcPPS->setPicInitQPMinus26(iCode);
	218	READ_FLAG( uiCode, "constrained_intra_pred_flag" ); pcPPS->setConstrainedIntraPred( uiCode ? true : false );
	219	READ_FLAG( uiCode, "transform_skip_enabled_flag" );
	220	pcPPS->setUseTransformSkip ( uiCode ? true : false );
	221
	222	READ_FLAG( uiCode, "cu_qp_delta_enabled_flag" ); pcPPS->setUseDQP( uiCode ? true : false );
	223	if( pcPPS->getUseDQP() )
	224	{
	225	READ_UVLC( uiCode, "diff_cu_qp_delta_depth" );
	226	pcPPS->setMaxCuDQPDepth( uiCode );
	227	}
	228	else
	229	{
	230	pcPPS->setMaxCuDQPDepth( 0 );
	231	}
	232	READ_SVLC( iCode, "pps_cb_qp_offset");
	233	pcPPS->setChromaCbQpOffset(iCode);
	234	assert( pcPPS->getChromaCbQpOffset() >= -12 );
	235	assert( pcPPS->getChromaCbQpOffset() <= 12 );
	236
	237	READ_SVLC( iCode, "pps_cr_qp_offset");
	238	pcPPS->setChromaCrQpOffset(iCode);
	239	assert( pcPPS->getChromaCrQpOffset() >= -12 );
	240	assert( pcPPS->getChromaCrQpOffset() <= 12 );
	241
	242	READ_FLAG( uiCode, "pps_slice_chroma_qp_offsets_present_flag" );
	243	pcPPS->setSliceChromaQpFlag( uiCode ? true : false );
	244
	245	READ_FLAG( uiCode, "weighted_pred_flag" ); // Use of Weighting Prediction (P_SLICE)
	246	pcPPS->setUseWP( uiCode==1 );
	247	READ_FLAG( uiCode, "weighted_bipred_flag" ); // Use of Bi-Directional Weighting Prediction (B_SLICE)
	248	pcPPS->setWPBiPred( uiCode==1 );
	249
	250	READ_FLAG( uiCode, "transquant_bypass_enable_flag");
	251	pcPPS->setTransquantBypassEnableFlag(uiCode ? true : false);
	252	READ_FLAG( uiCode, "tiles_enabled_flag" ); pcPPS->setTilesEnabledFlag ( uiCode == 1 );
	253	READ_FLAG( uiCode, "entropy_coding_sync_enabled_flag" ); pcPPS->setEntropyCodingSyncEnabledFlag( uiCode == 1 );
	254
	255	if( pcPPS->getTilesEnabledFlag() )
	256	{
[823]	257	READ_UVLC ( uiCode, "num_tile_columns_minus1" ); pcPPS->setNumTileColumnsMinus1( uiCode );
	258	READ_UVLC ( uiCode, "num_tile_rows_minus1" ); pcPPS->setNumTileRowsMinus1( uiCode );
	259	READ_FLAG ( uiCode, "uniform_spacing_flag" ); pcPPS->setTileUniformSpacingFlag( uiCode == 1 );
[313]	260
[823]	261	if( !pcPPS->getTileUniformSpacingFlag())
[313]	262	{
[823]	263	std::vector<Int> columnWidth(pcPPS->getNumTileColumnsMinus1());
	264	for(UInt i=0; i<pcPPS->getNumTileColumnsMinus1(); i++)
[313]	265	{
	266	READ_UVLC( uiCode, "column_width_minus1" );
	267	columnWidth[i] = uiCode+1;
	268	}
[823]	269	pcPPS->setTileColumnWidth(columnWidth);
[313]	270
[823]	271	std::vector<Int> rowHeight (pcPPS->getTileNumRowsMinus1());
	272	for(UInt i=0; i<pcPPS->getTileNumRowsMinus1(); i++)
[313]	273	{
	274	READ_UVLC( uiCode, "row_height_minus1" );
	275	rowHeight[i] = uiCode + 1;
	276	}
[823]	277	pcPPS->setTileRowHeight(rowHeight);
[313]	278	}
	279
[823]	280	if(pcPPS->getNumTileColumnsMinus1() !=0 \|\| pcPPS->getTileNumRowsMinus1() !=0)
[313]	281	{
	282	READ_FLAG ( uiCode, "loop_filter_across_tiles_enabled_flag" ); pcPPS->setLoopFilterAcrossTilesEnabledFlag( uiCode ? true : false );
	283	}
	284	}
	285	READ_FLAG( uiCode, "loop_filter_across_slices_enabled_flag" ); pcPPS->setLoopFilterAcrossSlicesEnabledFlag( uiCode ? true : false );
	286	READ_FLAG( uiCode, "deblocking_filter_control_present_flag" ); pcPPS->setDeblockingFilterControlPresentFlag( uiCode ? true : false );
	287	if(pcPPS->getDeblockingFilterControlPresentFlag())
	288	{
	289	READ_FLAG( uiCode, "deblocking_filter_override_enabled_flag" ); pcPPS->setDeblockingFilterOverrideEnabledFlag( uiCode ? true : false );
	290	READ_FLAG( uiCode, "pps_disable_deblocking_filter_flag" ); pcPPS->setPicDisableDeblockingFilterFlag(uiCode ? true : false );
	291	if(!pcPPS->getPicDisableDeblockingFilterFlag())
	292	{
	293	READ_SVLC ( iCode, "pps_beta_offset_div2" ); pcPPS->setDeblockingFilterBetaOffsetDiv2( iCode );
	294	READ_SVLC ( iCode, "pps_tc_offset_div2" ); pcPPS->setDeblockingFilterTcOffsetDiv2( iCode );
	295	}
	296	}
[442]	297
[540]	298	#if SCALINGLIST_INFERRING
	299	if( pcPPS->getLayerId() > 0 )
	300	{
	301	READ_FLAG( uiCode, "pps_infer_scaling_list_flag" );
	302	pcPPS->setInferScalingListFlag( uiCode );
	303	}
[442]	304
[540]	305	if( pcPPS->getInferScalingListFlag() )
[313]	306	{
[540]	307	READ_UVLC( uiCode, "pps_scaling_list_ref_layer_id" ); pcPPS->setScalingListRefLayerId( uiCode );
[442]	308
[540]	309	// The value of pps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
	310	assert( pcPPS->getScalingListRefLayerId() <= 62 );
[494]	311
[540]	312	pcPPS->setScalingListPresentFlag( false );
	313	}
	314	else
	315	{
	316	#endif
[442]	317
[825]	318	READ_FLAG( uiCode, "pps_scaling_list_data_present_flag" ); pcPPS->setScalingListPresentFlag( uiCode ? true : false );
[442]	319
[825]	320	if(pcPPS->getScalingListPresentFlag ())
	321	{
	322	parseScalingList( pcPPS->getScalingList() );
	323	}
[313]	324
[540]	325	#if SCALINGLIST_INFERRING
	326	}
	327	#endif
	328
[313]	329	READ_FLAG( uiCode, "lists_modification_present_flag");
	330	pcPPS->setListsModificationPresentFlag(uiCode);
	331
	332	READ_UVLC( uiCode, "log2_parallel_merge_level_minus2");
	333	pcPPS->setLog2ParallelMergeLevelMinus2 (uiCode);
	334
	335	READ_FLAG( uiCode, "slice_segment_header_extension_present_flag");
	336	pcPPS->setSliceHeaderExtensionPresentFlag(uiCode);
	337
	338	READ_FLAG( uiCode, "pps_extension_flag");
[815]	339	#if POC_RESET_INFO_INFERENCE
	340	pcPPS->setExtensionFlag( uiCode ? true : false );
	341
	342	if( pcPPS->getExtensionFlag() )
	343	#else
[313]	344	if (uiCode)
[815]	345	#endif
[313]	346	{
[644]	347	#if P0166_MODIFIED_PPS_EXTENSION
	348	UInt ppsExtensionTypeFlag[8];
	349	for (UInt i = 0; i < 8; i++)
	350	{
	351	READ_FLAG( ppsExtensionTypeFlag[i], "pps_extension_type_flag" );
	352	}
	353	#if !POC_RESET_IDC
	354	if (ppsExtensionTypeFlag[1])
	355	{
	356	#else
	357	if( ppsExtensionTypeFlag[0] )
	358	{
	359	READ_FLAG( uiCode, "poc_reset_info_present_flag" );
	360	pcPPS->setPocResetInfoPresentFlag(uiCode ? true : false);
[849]	361	#if REF_REGION_OFFSET
	362	READ_UVLC( uiCode, "num_scaled_ref_layer_offsets" ); pcPPS->setNumScaledRefLayerOffsets(uiCode);
	363	for(Int i = 0; i < pcPPS->getNumScaledRefLayerOffsets(); i++)
	364	{
	365	READ_CODE( 6, uiCode, "scaled_ref_layer_id" ); pcPPS->setScaledRefLayerId( i, uiCode );
	366	READ_FLAG( uiCode, "scaled_ref_layer_offset_present_flag" ); pcPPS->setScaledRefLayerOffsetPresentFlag( i, uiCode );
	367	if (uiCode)
	368	{
	369	Window& scaledWindow = pcPPS->getScaledRefLayerWindow(i);
	370	READ_SVLC( iCode, "scaled_ref_layer_left_offset" ); scaledWindow.setWindowLeftOffset (iCode << 1);
	371	READ_SVLC( iCode, "scaled_ref_layer_top_offset" ); scaledWindow.setWindowTopOffset (iCode << 1);
	372	READ_SVLC( iCode, "scaled_ref_layer_right_offset" ); scaledWindow.setWindowRightOffset (iCode << 1);
	373	READ_SVLC( iCode, "scaled_ref_layer_bottom_offset" ); scaledWindow.setWindowBottomOffset(iCode << 1);
	374	#if P0312_VERT_PHASE_ADJ
	375	READ_FLAG( uiCode, "vert_phase_position_enable_flag" ); scaledWindow.setVertPhasePositionEnableFlag(uiCode); pcPPS->setVertPhasePositionEnableFlag( pcPPS->getScaledRefLayerId(i), uiCode);
	376	#endif
	377	}
	378	READ_FLAG( uiCode, "ref_region_offset_present_flag" ); pcPPS->setRefRegionOffsetPresentFlag( i, uiCode );
	379	if (uiCode)
	380	{
	381	Window& refWindow = pcPPS->getRefLayerWindow(i);
	382	READ_SVLC( iCode, "ref_region_left_offset" ); refWindow.setWindowLeftOffset (iCode << 1);
	383	READ_SVLC( iCode, "ref_region_top_offset" ); refWindow.setWindowTopOffset (iCode << 1);
	384	READ_SVLC( iCode, "ref_region_right_offset" ); refWindow.setWindowRightOffset (iCode << 1);
	385	READ_SVLC( iCode, "ref_region_bottom_offset" ); refWindow.setWindowBottomOffset(iCode << 1);
	386	}
	387	#if R0209_GENERIC_PHASE
	388	READ_FLAG( uiCode, "resample_phase_set_present_flag" ); pcPPS->setResamplePhaseSetPresentFlag( i, uiCode );
	389	if (uiCode)
	390	{
	391	READ_UVLC( uiCode, "phase_hor_luma" ); pcPPS->setPhaseHorLuma ( i, uiCode );
	392	READ_UVLC( uiCode, "phase_ver_luma" ); pcPPS->setPhaseVerLuma ( i, uiCode );
	393	READ_UVLC( uiCode, "phase_hor_chroma_plus8" ); pcPPS->setPhaseHorChroma (i, uiCode - 8);
	394	READ_UVLC( uiCode, "phase_ver_chroma_plus8" ); pcPPS->setPhaseVerChroma (i, uiCode - 8);
	395	}
	396	#endif
	397	}
	398	#else
	399	#if MOVE_SCALED_OFFSET_TO_PPS
	400	READ_UVLC( uiCode, "num_scaled_ref_layer_offsets" ); pcPPS->setNumScaledRefLayerOffsets(uiCode);
	401	for(Int i = 0; i < pcPPS->getNumScaledRefLayerOffsets(); i++)
	402	{
	403	Window& scaledWindow = pcPPS->getScaledRefLayerWindow(i);
	404	#if O0098_SCALED_REF_LAYER_ID
	405	READ_CODE( 6, uiCode, "scaled_ref_layer_id" ); pcPPS->setScaledRefLayerId( i, uiCode );
	406	#endif
	407	READ_SVLC( iCode, "scaled_ref_layer_left_offset" ); scaledWindow.setWindowLeftOffset (iCode << 1);
	408	READ_SVLC( iCode, "scaled_ref_layer_top_offset" ); scaledWindow.setWindowTopOffset (iCode << 1);
	409	READ_SVLC( iCode, "scaled_ref_layer_right_offset" ); scaledWindow.setWindowRightOffset (iCode << 1);
	410	READ_SVLC( iCode, "scaled_ref_layer_bottom_offset" ); scaledWindow.setWindowBottomOffset(iCode << 1);
	411	#if P0312_VERT_PHASE_ADJ
	412	READ_FLAG( uiCode, "vert_phase_position_enable_flag" ); scaledWindow.setVertPhasePositionEnableFlag(uiCode); pcPPS->setVertPhasePositionEnableFlag( pcPPS->getScaledRefLayerId(i), uiCode);
	413	#endif
	414	}
	415	#endif
	416	#endif
[713]	417	#if Q0048_CGS_3D_ASYMLUT
	418	READ_FLAG( uiCode , "colour_mapping_enabled_flag" );
	419	pcPPS->setCGSFlag( uiCode );
	420	if( pcPPS->getCGSFlag() )
	421	{
	422	xParse3DAsymLUT( pc3DAsymLUT );
	423	pcPPS->setCGSOutputBitDepthY( pc3DAsymLUT->getOutputBitDepthY() );
	424	pcPPS->setCGSOutputBitDepthC( pc3DAsymLUT->getOutputBitDepthC() );
	425	}
[644]	426	#endif
[713]	427	#endif
[644]	428	}
[815]	429	#if POC_RESET_INFO_INFERENCE
	430	else // Extension type 0 absent
	431	{
	432	pcPPS->setPocResetInfoPresentFlag( false );
	433	}
	434	#endif
[644]	435	if (ppsExtensionTypeFlag[7])
	436	{
	437	#endif
	438
[825]	439	while ( xMoreRbspData() )
	440	{
	441	READ_FLAG( uiCode, "pps_extension_data_flag");
	442	}
[644]	443	#if P0166_MODIFIED_PPS_EXTENSION
	444	}
	445	#endif
[313]	446	}
[815]	447	#if POC_RESET_INFO_INFERENCE
	448	if( !pcPPS->getExtensionFlag() )
	449	{
	450	pcPPS->setPocResetInfoPresentFlag( false );
	451	}
	452	#endif
[313]	453	}
	454
	455	Void TDecCavlc::parseVUI(TComVUI* pcVUI, TComSPS *pcSPS)
	456	{
	457	#if ENC_DEC_TRACE
	458	fprintf( g_hTrace, "----------- vui_parameters -----------\n");
	459	#endif
	460	UInt uiCode;
	461
	462	READ_FLAG( uiCode, "aspect_ratio_info_present_flag"); pcVUI->setAspectRatioInfoPresentFlag(uiCode);
	463	if (pcVUI->getAspectRatioInfoPresentFlag())
	464	{
	465	READ_CODE(8, uiCode, "aspect_ratio_idc"); pcVUI->setAspectRatioIdc(uiCode);
	466	if (pcVUI->getAspectRatioIdc() == 255)
	467	{
	468	READ_CODE(16, uiCode, "sar_width"); pcVUI->setSarWidth(uiCode);
	469	READ_CODE(16, uiCode, "sar_height"); pcVUI->setSarHeight(uiCode);
	470	}
	471	}
	472
	473	READ_FLAG( uiCode, "overscan_info_present_flag"); pcVUI->setOverscanInfoPresentFlag(uiCode);
	474	if (pcVUI->getOverscanInfoPresentFlag())
	475	{
	476	READ_FLAG( uiCode, "overscan_appropriate_flag"); pcVUI->setOverscanAppropriateFlag(uiCode);
	477	}
	478
	479	READ_FLAG( uiCode, "video_signal_type_present_flag"); pcVUI->setVideoSignalTypePresentFlag(uiCode);
	480	if (pcVUI->getVideoSignalTypePresentFlag())
	481	{
	482	READ_CODE(3, uiCode, "video_format"); pcVUI->setVideoFormat(uiCode);
	483	READ_FLAG( uiCode, "video_full_range_flag"); pcVUI->setVideoFullRangeFlag(uiCode);
	484	READ_FLAG( uiCode, "colour_description_present_flag"); pcVUI->setColourDescriptionPresentFlag(uiCode);
	485	if (pcVUI->getColourDescriptionPresentFlag())
	486	{
	487	READ_CODE(8, uiCode, "colour_primaries"); pcVUI->setColourPrimaries(uiCode);
	488	READ_CODE(8, uiCode, "transfer_characteristics"); pcVUI->setTransferCharacteristics(uiCode);
	489	READ_CODE(8, uiCode, "matrix_coefficients"); pcVUI->setMatrixCoefficients(uiCode);
	490	}
	491	}
	492
	493	READ_FLAG( uiCode, "chroma_loc_info_present_flag"); pcVUI->setChromaLocInfoPresentFlag(uiCode);
	494	if (pcVUI->getChromaLocInfoPresentFlag())
	495	{
	496	READ_UVLC( uiCode, "chroma_sample_loc_type_top_field" ); pcVUI->setChromaSampleLocTypeTopField(uiCode);
	497	READ_UVLC( uiCode, "chroma_sample_loc_type_bottom_field" ); pcVUI->setChromaSampleLocTypeBottomField(uiCode);
	498	}
	499
	500	READ_FLAG( uiCode, "neutral_chroma_indication_flag"); pcVUI->setNeutralChromaIndicationFlag(uiCode);
	501
	502	READ_FLAG( uiCode, "field_seq_flag"); pcVUI->setFieldSeqFlag(uiCode);
	503
	504	READ_FLAG(uiCode, "frame_field_info_present_flag"); pcVUI->setFrameFieldInfoPresentFlag(uiCode);
	505
	506	READ_FLAG( uiCode, "default_display_window_flag");
	507	if (uiCode != 0)
	508	{
	509	Window &defDisp = pcVUI->getDefaultDisplayWindow();
	510	READ_UVLC( uiCode, "def_disp_win_left_offset" ); defDisp.setWindowLeftOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc()) );
	511	READ_UVLC( uiCode, "def_disp_win_right_offset" ); defDisp.setWindowRightOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc()) );
	512	READ_UVLC( uiCode, "def_disp_win_top_offset" ); defDisp.setWindowTopOffset ( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc()) );
	513	READ_UVLC( uiCode, "def_disp_win_bottom_offset" ); defDisp.setWindowBottomOffset( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc()) );
	514	}
	515	TimingInfo *timingInfo = pcVUI->getTimingInfo();
	516	READ_FLAG( uiCode, "vui_timing_info_present_flag"); timingInfo->setTimingInfoPresentFlag (uiCode ? true : false);
[815]	517	#if SVC_EXTENSION
[442]	518	if( pcSPS->getLayerId() > 0 )
	519	{
	520	assert( timingInfo->getTimingInfoPresentFlag() == false );
	521	}
	522	#endif
[313]	523	if(timingInfo->getTimingInfoPresentFlag())
	524	{
	525	READ_CODE( 32, uiCode, "vui_num_units_in_tick"); timingInfo->setNumUnitsInTick (uiCode);
	526	READ_CODE( 32, uiCode, "vui_time_scale"); timingInfo->setTimeScale (uiCode);
	527	READ_FLAG( uiCode, "vui_poc_proportional_to_timing_flag"); timingInfo->setPocProportionalToTimingFlag(uiCode ? true : false);
	528	if(timingInfo->getPocProportionalToTimingFlag())
	529	{
	530	READ_UVLC( uiCode, "vui_num_ticks_poc_diff_one_minus1"); timingInfo->setNumTicksPocDiffOneMinus1 (uiCode);
	531	}
[825]	532	READ_FLAG( uiCode, "hrd_parameters_present_flag"); pcVUI->setHrdParametersPresentFlag(uiCode);
	533	if( pcVUI->getHrdParametersPresentFlag() )
	534	{
	535	parseHrdParameters( pcVUI->getHrdParameters(), 1, pcSPS->getMaxTLayers() - 1 );
	536	}
[313]	537	}
	538	READ_FLAG( uiCode, "bitstream_restriction_flag"); pcVUI->setBitstreamRestrictionFlag(uiCode);
	539	if (pcVUI->getBitstreamRestrictionFlag())
	540	{
	541	READ_FLAG( uiCode, "tiles_fixed_structure_flag"); pcVUI->setTilesFixedStructureFlag(uiCode);
	542	READ_FLAG( uiCode, "motion_vectors_over_pic_boundaries_flag"); pcVUI->setMotionVectorsOverPicBoundariesFlag(uiCode);
	543	READ_FLAG( uiCode, "restricted_ref_pic_lists_flag"); pcVUI->setRestrictedRefPicListsFlag(uiCode);
	544	READ_UVLC( uiCode, "min_spatial_segmentation_idc"); pcVUI->setMinSpatialSegmentationIdc(uiCode);
	545	assert(uiCode < 4096);
	546	READ_UVLC( uiCode, "max_bytes_per_pic_denom" ); pcVUI->setMaxBytesPerPicDenom(uiCode);
	547	READ_UVLC( uiCode, "max_bits_per_mincu_denom" ); pcVUI->setMaxBitsPerMinCuDenom(uiCode);
	548	READ_UVLC( uiCode, "log2_max_mv_length_horizontal" ); pcVUI->setLog2MaxMvLengthHorizontal(uiCode);
	549	READ_UVLC( uiCode, "log2_max_mv_length_vertical" ); pcVUI->setLog2MaxMvLengthVertical(uiCode);
	550	}
	551	}
	552
	553	Void TDecCavlc::parseHrdParameters(TComHRD *hrd, Bool commonInfPresentFlag, UInt maxNumSubLayersMinus1)
	554	{
	555	UInt uiCode;
	556	if( commonInfPresentFlag )
	557	{
	558	READ_FLAG( uiCode, "nal_hrd_parameters_present_flag" ); hrd->setNalHrdParametersPresentFlag( uiCode == 1 ? true : false );
	559	READ_FLAG( uiCode, "vcl_hrd_parameters_present_flag" ); hrd->setVclHrdParametersPresentFlag( uiCode == 1 ? true : false );
	560	if( hrd->getNalHrdParametersPresentFlag() \|\| hrd->getVclHrdParametersPresentFlag() )
	561	{
	562	READ_FLAG( uiCode, "sub_pic_cpb_params_present_flag" ); hrd->setSubPicCpbParamsPresentFlag( uiCode == 1 ? true : false );
	563	if( hrd->getSubPicCpbParamsPresentFlag() )
	564	{
	565	READ_CODE( 8, uiCode, "tick_divisor_minus2" ); hrd->setTickDivisorMinus2( uiCode );
	566	READ_CODE( 5, uiCode, "du_cpb_removal_delay_length_minus1" ); hrd->setDuCpbRemovalDelayLengthMinus1( uiCode );
	567	READ_FLAG( uiCode, "sub_pic_cpb_params_in_pic_timing_sei_flag" ); hrd->setSubPicCpbParamsInPicTimingSEIFlag( uiCode == 1 ? true : false );
	568	READ_CODE( 5, uiCode, "dpb_output_delay_du_length_minus1" ); hrd->setDpbOutputDelayDuLengthMinus1( uiCode );
	569	}
	570	READ_CODE( 4, uiCode, "bit_rate_scale" ); hrd->setBitRateScale( uiCode );
	571	READ_CODE( 4, uiCode, "cpb_size_scale" ); hrd->setCpbSizeScale( uiCode );
	572	if( hrd->getSubPicCpbParamsPresentFlag() )
	573	{
	574	READ_CODE( 4, uiCode, "cpb_size_du_scale" ); hrd->setDuCpbSizeScale( uiCode );
	575	}
	576	READ_CODE( 5, uiCode, "initial_cpb_removal_delay_length_minus1" ); hrd->setInitialCpbRemovalDelayLengthMinus1( uiCode );
	577	READ_CODE( 5, uiCode, "au_cpb_removal_delay_length_minus1" ); hrd->setCpbRemovalDelayLengthMinus1( uiCode );
	578	READ_CODE( 5, uiCode, "dpb_output_delay_length_minus1" ); hrd->setDpbOutputDelayLengthMinus1( uiCode );
	579	}
	580	}
	581	Int i, j, nalOrVcl;
	582	for( i = 0; i <= maxNumSubLayersMinus1; i ++ )
	583	{
	584	READ_FLAG( uiCode, "fixed_pic_rate_general_flag" ); hrd->setFixedPicRateFlag( i, uiCode == 1 ? true : false );
	585	if( !hrd->getFixedPicRateFlag( i ) )
	586	{
	587	READ_FLAG( uiCode, "fixed_pic_rate_within_cvs_flag" ); hrd->setFixedPicRateWithinCvsFlag( i, uiCode == 1 ? true : false );
	588	}
	589	else
	590	{
	591	hrd->setFixedPicRateWithinCvsFlag( i, true );
	592	}
	593	hrd->setLowDelayHrdFlag( i, 0 ); // Infered to be 0 when not present
	594	hrd->setCpbCntMinus1 ( i, 0 ); // Infered to be 0 when not present
	595	if( hrd->getFixedPicRateWithinCvsFlag( i ) )
	596	{
	597	READ_UVLC( uiCode, "elemental_duration_in_tc_minus1" ); hrd->setPicDurationInTcMinus1( i, uiCode );
	598	}
	599	else
	600	{
	601	READ_FLAG( uiCode, "low_delay_hrd_flag" ); hrd->setLowDelayHrdFlag( i, uiCode == 1 ? true : false );
	602	}
	603	if (!hrd->getLowDelayHrdFlag( i ))
	604	{
	605	READ_UVLC( uiCode, "cpb_cnt_minus1" ); hrd->setCpbCntMinus1( i, uiCode );
	606	}
	607	for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
	608	{
	609	if( ( ( nalOrVcl == 0 ) && ( hrd->getNalHrdParametersPresentFlag() ) ) \|\|
[825]	610	( ( nalOrVcl == 1 ) && ( hrd->getVclHrdParametersPresentFlag() ) ) )
[313]	611	{
	612	for( j = 0; j <= ( hrd->getCpbCntMinus1( i ) ); j ++ )
	613	{
	614	READ_UVLC( uiCode, "bit_rate_value_minus1" ); hrd->setBitRateValueMinus1( i, j, nalOrVcl, uiCode );
	615	READ_UVLC( uiCode, "cpb_size_value_minus1" ); hrd->setCpbSizeValueMinus1( i, j, nalOrVcl, uiCode );
	616	if( hrd->getSubPicCpbParamsPresentFlag() )
	617	{
	618	READ_UVLC( uiCode, "cpb_size_du_value_minus1" ); hrd->setDuCpbSizeValueMinus1( i, j, nalOrVcl, uiCode );
	619	READ_UVLC( uiCode, "bit_rate_du_value_minus1" ); hrd->setDuBitRateValueMinus1( i, j, nalOrVcl, uiCode );
	620	}
	621	READ_FLAG( uiCode, "cbr_flag" ); hrd->setCbrFlag( i, j, nalOrVcl, uiCode == 1 ? true : false );
	622	}
	623	}
	624	}
	625	}
	626	}
	627
[644]	628	#if SVC_EXTENSION && !SPS_DPB_PARAMS
[313]	629	Void TDecCavlc::parseSPS(TComSPS* pcSPS, ParameterSetManagerDecoder *parameterSetManager)
	630	#else
	631	Void TDecCavlc::parseSPS(TComSPS* pcSPS)
	632	#endif
	633	{
	634	#if ENC_DEC_TRACE
	635	xTraceSPSHeader (pcSPS);
	636	#endif
	637
	638	UInt uiCode;
	639	READ_CODE( 4, uiCode, "sps_video_parameter_set_id"); pcSPS->setVPSId ( uiCode );
[494]	640	#if SVC_EXTENSION
[313]	641	if(pcSPS->getLayerId() == 0)
	642	{
	643	#endif
	644	READ_CODE( 3, uiCode, "sps_max_sub_layers_minus1" ); pcSPS->setMaxTLayers ( uiCode+1 );
	645	assert(uiCode <= 6);
[494]	646
[313]	647	READ_FLAG( uiCode, "sps_temporal_id_nesting_flag" ); pcSPS->setTemporalIdNestingFlag ( uiCode > 0 ? true : false );
[494]	648	#if SVC_EXTENSION
[313]	649	}
[644]	650	#if !SPS_DPB_PARAMS
[313]	651	else
	652	{
	653	pcSPS->setMaxTLayers ( parameterSetManager->getPrefetchedVPS(pcSPS->getVPSId())->getMaxTLayers() );
	654	pcSPS->setTemporalIdNestingFlag( parameterSetManager->getPrefetchedVPS(pcSPS->getVPSId())->getTemporalNestingFlag() );
	655	}
[442]	656	#endif
[644]	657	#endif
	658
[815]	659	#if !Q0177_SPS_TEMP_NESTING_FIX //This part is not needed anymore as it is already covered by implementation in TDecTop::xActivateParameterSets()
[313]	660	if ( pcSPS->getMaxTLayers() == 1 )
	661	{
	662	// sps_temporal_id_nesting_flag must be 1 when sps_max_sub_layers_minus1 is 0
[494]	663	#if SVC_EXTENSION
[644]	664	#if !SPS_DPB_PARAMS
[313]	665	assert( pcSPS->getTemporalIdNestingFlag() == true );
[644]	666	#endif
[313]	667	#else
	668	assert( uiCode == 1 );
	669	#endif
	670	}
[815]	671	#endif
	672
[442]	673	#ifdef SPS_PTL_FIX
	674	if ( pcSPS->getLayerId() == 0)
	675	{
	676	parsePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
	677	}
	678	#else
	679	parsePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
	680	#endif
[313]	681
	682	READ_UVLC( uiCode, "sps_seq_parameter_set_id" ); pcSPS->setSPSId( uiCode );
	683	assert(uiCode <= 15);
[442]	684
	685	#if REPN_FORMAT_IN_VPS
	686	if( pcSPS->getLayerId() > 0 )
[313]	687	{
[494]	688	READ_FLAG( uiCode, "update_rep_format_flag" );
[442]	689	pcSPS->setUpdateRepFormatFlag( uiCode ? true : false );
[313]	690	}
[442]	691	else
	692	{
[713]	693	#if REP_FORMAT_FIX
	694	pcSPS->setUpdateRepFormatFlag( false );
	695	#else
[442]	696	pcSPS->setUpdateRepFormatFlag( true );
[713]	697	#endif
[442]	698	}
[540]	699	#if O0096_REP_FORMAT_INDEX
	700	if( pcSPS->getLayerId() == 0 )
	701	#else
[494]	702	if( pcSPS->getLayerId() == 0 \|\| pcSPS->getUpdateRepFormatFlag() )
[540]	703	#endif
[442]	704	{
	705	#endif
[494]	706	#if AUXILIARY_PICTURES
	707	READ_UVLC( uiCode, "chroma_format_idc" ); pcSPS->setChromaFormatIdc( ChromaFormat(uiCode) );
	708	#else
[442]	709	READ_UVLC( uiCode, "chroma_format_idc" ); pcSPS->setChromaFormatIdc( uiCode );
[494]	710	#endif
[442]	711	assert(uiCode <= 3);
	712	// in the first version we only support chroma_format_idc equal to 1 (4:2:0), so separate_colour_plane_flag cannot appear in the bitstream
	713	assert (uiCode == 1);
	714	if( uiCode == 3 )
	715	{
	716	READ_FLAG( uiCode, "separate_colour_plane_flag"); assert(uiCode == 0);
	717	}
[313]	718
[442]	719	READ_UVLC ( uiCode, "pic_width_in_luma_samples" ); pcSPS->setPicWidthInLumaSamples ( uiCode );
	720	READ_UVLC ( uiCode, "pic_height_in_luma_samples" ); pcSPS->setPicHeightInLumaSamples( uiCode );
	721	#if REPN_FORMAT_IN_VPS
	722	}
[540]	723	#if O0096_REP_FORMAT_INDEX
	724	else if ( pcSPS->getUpdateRepFormatFlag() )
	725	{
	726	READ_CODE(8, uiCode, "update_rep_format_index");
	727	pcSPS->setUpdateRepFormatIndex(uiCode);
	728	}
[442]	729	#endif
[540]	730	#endif
[869]	731
	732	#if R0156_CONF_WINDOW_IN_REP_FORMAT
	733	#if REPN_FORMAT_IN_VPS
	734	#if O0096_REP_FORMAT_INDEX
	735	if( pcSPS->getLayerId() == 0 )
	736	#else
	737	if( pcSPS->getLayerId() == 0 \|\| pcSPS->getUpdateRepFormatFlag() )
	738	#endif
[313]	739	{
[869]	740	#endif
	741	#endif
	742	READ_FLAG( uiCode, "conformance_window_flag");
	743	if (uiCode != 0)
	744	{
	745	Window &conf = pcSPS->getConformanceWindow();
[442]	746	#if REPN_FORMAT_IN_VPS
[869]	747	READ_UVLC( uiCode, "conf_win_left_offset" ); conf.setWindowLeftOffset ( uiCode );
	748	READ_UVLC( uiCode, "conf_win_right_offset" ); conf.setWindowRightOffset ( uiCode );
	749	READ_UVLC( uiCode, "conf_win_top_offset" ); conf.setWindowTopOffset ( uiCode );
	750	READ_UVLC( uiCode, "conf_win_bottom_offset" ); conf.setWindowBottomOffset( uiCode );
[442]	751	#else
[869]	752	READ_UVLC( uiCode, "conf_win_left_offset" ); conf.setWindowLeftOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc() ) );
	753	READ_UVLC( uiCode, "conf_win_right_offset" ); conf.setWindowRightOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc() ) );
	754	READ_UVLC( uiCode, "conf_win_top_offset" ); conf.setWindowTopOffset ( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc() ) );
	755	READ_UVLC( uiCode, "conf_win_bottom_offset" ); conf.setWindowBottomOffset( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc() ) );
[442]	756	#endif
[869]	757	}
	758	#if R0156_CONF_WINDOW_IN_REP_FORMAT
	759	#if REPN_FORMAT_IN_VPS
[313]	760	}
[869]	761	#endif
	762	#endif
	763
[442]	764	#if REPN_FORMAT_IN_VPS
[540]	765	#if O0096_REP_FORMAT_INDEX
	766	if( pcSPS->getLayerId() == 0 )
	767	#else
[494]	768	if( pcSPS->getLayerId() == 0 \|\| pcSPS->getUpdateRepFormatFlag() )
[540]	769	#endif
[442]	770	{
	771	#endif
	772	READ_UVLC( uiCode, "bit_depth_luma_minus8" );
	773	assert(uiCode <= 6);
	774	pcSPS->setBitDepthY( uiCode + 8 );
	775	pcSPS->setQpBDOffsetY( (Int) (6*uiCode) );
[313]	776
[442]	777	READ_UVLC( uiCode, "bit_depth_chroma_minus8" );
	778	assert(uiCode <= 6);
	779	pcSPS->setBitDepthC( uiCode + 8 );
	780	pcSPS->setQpBDOffsetC( (Int) (6*uiCode) );
	781	#if REPN_FORMAT_IN_VPS
	782	}
	783	#endif
[313]	784	READ_UVLC( uiCode, "log2_max_pic_order_cnt_lsb_minus4" ); pcSPS->setBitsForPOC( 4 + uiCode );
	785	assert(uiCode <= 12);
	786
[644]	787	#if SPS_DPB_PARAMS
	788	if( pcSPS->getLayerId() == 0 )
[313]	789	{
[644]	790	#endif
	791	UInt subLayerOrderingInfoPresentFlag;
	792	READ_FLAG(subLayerOrderingInfoPresentFlag, "sps_sub_layer_ordering_info_present_flag");
[313]	793
[644]	794	for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
[313]	795	{
[713]	796	READ_UVLC ( uiCode, "sps_max_dec_pic_buffering_minus1[i]");
[644]	797	pcSPS->setMaxDecPicBuffering( uiCode + 1, i);
[713]	798	READ_UVLC ( uiCode, "sps_num_reorder_pics[i]" );
[644]	799	pcSPS->setNumReorderPics(uiCode, i);
[713]	800	READ_UVLC ( uiCode, "sps_max_latency_increase_plus1[i]");
[644]	801	pcSPS->setMaxLatencyIncrease( uiCode, i );
	802
	803	if (!subLayerOrderingInfoPresentFlag)
[313]	804	{
[644]	805	for (i++; i <= pcSPS->getMaxTLayers()-1; i++)
	806	{
	807	pcSPS->setMaxDecPicBuffering(pcSPS->getMaxDecPicBuffering(0), i);
	808	pcSPS->setNumReorderPics(pcSPS->getNumReorderPics(0), i);
	809	pcSPS->setMaxLatencyIncrease(pcSPS->getMaxLatencyIncrease(0), i);
	810	}
	811	break;
[313]	812	}
	813	}
[644]	814	#if SPS_DPB_PARAMS
[313]	815	}
[644]	816	#endif
[313]	817	READ_UVLC( uiCode, "log2_min_coding_block_size_minus3" );
	818	Int log2MinCUSize = uiCode + 3;
	819	pcSPS->setLog2MinCodingBlockSize(log2MinCUSize);
	820	READ_UVLC( uiCode, "log2_diff_max_min_coding_block_size" );
	821	pcSPS->setLog2DiffMaxMinCodingBlockSize(uiCode);
[825]	822
[595]	823	if (pcSPS->getPTL()->getGeneralPTL()->getLevelIdc() >= Level::LEVEL5)
	824	{
	825	assert(log2MinCUSize + pcSPS->getLog2DiffMaxMinCodingBlockSize() >= 5);
	826	}
[825]	827
[313]	828	Int maxCUDepthDelta = uiCode;
	829	pcSPS->setMaxCUWidth ( 1<<(log2MinCUSize + maxCUDepthDelta) );
	830	pcSPS->setMaxCUHeight ( 1<<(log2MinCUSize + maxCUDepthDelta) );
	831	READ_UVLC( uiCode, "log2_min_transform_block_size_minus2" ); pcSPS->setQuadtreeTULog2MinSize( uiCode + 2 );
	832
	833	READ_UVLC( uiCode, "log2_diff_max_min_transform_block_size" ); pcSPS->setQuadtreeTULog2MaxSize( uiCode + pcSPS->getQuadtreeTULog2MinSize() );
	834	pcSPS->setMaxTrSize( 1<<(uiCode + pcSPS->getQuadtreeTULog2MinSize()) );
	835
	836	READ_UVLC( uiCode, "max_transform_hierarchy_depth_inter" ); pcSPS->setQuadtreeTUMaxDepthInter( uiCode+1 );
	837	READ_UVLC( uiCode, "max_transform_hierarchy_depth_intra" ); pcSPS->setQuadtreeTUMaxDepthIntra( uiCode+1 );
	838
	839	Int addCuDepth = max (0, log2MinCUSize - (Int)pcSPS->getQuadtreeTULog2MinSize() );
	840	pcSPS->setMaxCUDepth( maxCUDepthDelta + addCuDepth );
[442]	841	READ_FLAG( uiCode, "scaling_list_enabled_flag" ); pcSPS->setScalingListFlag ( uiCode );
[313]	842
	843	if(pcSPS->getScalingListFlag())
	844	{
[540]	845	#if SCALINGLIST_INFERRING
	846	if( pcSPS->getLayerId() > 0 )
[313]	847	{
[540]	848	READ_FLAG( uiCode, "sps_infer_scaling_list_flag" ); pcSPS->setInferScalingListFlag( uiCode );
	849	}
[442]	850
[540]	851	if( pcSPS->getInferScalingListFlag() )
	852	{
	853	READ_UVLC( uiCode, "sps_scaling_list_ref_layer_id" ); pcSPS->setScalingListRefLayerId( uiCode );
[442]	854
[540]	855	// The value of pps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
	856	assert( pcSPS->getScalingListRefLayerId() <= 62 );
[442]	857
[540]	858	pcSPS->setScalingListPresentFlag( false );
	859	}
	860	else
	861	{
	862	#endif
[825]	863	READ_FLAG( uiCode, "sps_scaling_list_data_present_flag" ); pcSPS->setScalingListPresentFlag ( uiCode );
	864	if(pcSPS->getScalingListPresentFlag ())
	865	{
	866	parseScalingList( pcSPS->getScalingList() );
	867	}
[540]	868	#if SCALINGLIST_INFERRING
	869	}
[442]	870	#endif
[313]	871	}
	872	READ_FLAG( uiCode, "amp_enabled_flag" ); pcSPS->setUseAMP( uiCode );
	873	READ_FLAG( uiCode, "sample_adaptive_offset_enabled_flag" ); pcSPS->setUseSAO ( uiCode ? true : false );
	874
	875	READ_FLAG( uiCode, "pcm_enabled_flag" ); pcSPS->setUsePCM( uiCode ? true : false );
	876	if( pcSPS->getUsePCM() )
	877	{
	878	READ_CODE( 4, uiCode, "pcm_sample_bit_depth_luma_minus1" ); pcSPS->setPCMBitDepthLuma ( 1 + uiCode );
	879	READ_CODE( 4, uiCode, "pcm_sample_bit_depth_chroma_minus1" ); pcSPS->setPCMBitDepthChroma ( 1 + uiCode );
	880	READ_UVLC( uiCode, "log2_min_pcm_luma_coding_block_size_minus3" ); pcSPS->setPCMLog2MinSize (uiCode+3);
	881	READ_UVLC( uiCode, "log2_diff_max_min_pcm_luma_coding_block_size" ); pcSPS->setPCMLog2MaxSize ( uiCode+pcSPS->getPCMLog2MinSize() );
	882	READ_FLAG( uiCode, "pcm_loop_filter_disable_flag" ); pcSPS->setPCMFilterDisableFlag ( uiCode ? true : false );
	883	}
	884
	885	READ_UVLC( uiCode, "num_short_term_ref_pic_sets" );
	886	assert(uiCode <= 64);
	887	pcSPS->createRPSList(uiCode);
	888
	889	TComRPSList* rpsList = pcSPS->getRPSList();
	890	TComReferencePictureSet* rps;
	891
	892	for(UInt i=0; i< rpsList->getNumberOfReferencePictureSets(); i++)
	893	{
	894	rps = rpsList->getReferencePictureSet(i);
	895	parseShortTermRefPicSet(pcSPS,rps,i);
	896	}
	897	READ_FLAG( uiCode, "long_term_ref_pics_present_flag" ); pcSPS->setLongTermRefsPresent(uiCode);
	898	if (pcSPS->getLongTermRefsPresent())
	899	{
	900	READ_UVLC( uiCode, "num_long_term_ref_pic_sps" );
	901	pcSPS->setNumLongTermRefPicSPS(uiCode);
	902	for (UInt k = 0; k < pcSPS->getNumLongTermRefPicSPS(); k++)
	903	{
	904	READ_CODE( pcSPS->getBitsForPOC(), uiCode, "lt_ref_pic_poc_lsb_sps" );
	905	pcSPS->setLtRefPicPocLsbSps(k, uiCode);
	906	READ_FLAG( uiCode, "used_by_curr_pic_lt_sps_flag[i]");
	907	pcSPS->setUsedByCurrPicLtSPSFlag(k, uiCode?1:0);
	908	}
	909	}
	910	READ_FLAG( uiCode, "sps_temporal_mvp_enable_flag" ); pcSPS->setTMVPFlagsPresent(uiCode);
	911	READ_FLAG( uiCode, "sps_strong_intra_smoothing_enable_flag" ); pcSPS->setUseStrongIntraSmoothing(uiCode);
	912
	913	READ_FLAG( uiCode, "vui_parameters_present_flag" ); pcSPS->setVuiParametersPresentFlag(uiCode);
	914
	915	if (pcSPS->getVuiParametersPresentFlag())
	916	{
	917	parseVUI(pcSPS->getVuiParameters(), pcSPS);
	918	}
	919
	920	READ_FLAG( uiCode, "sps_extension_flag");
[815]	921
	922	#if SVC_EXTENSION
	923	pcSPS->setExtensionFlag( uiCode ? true : false );
	924
	925	if( pcSPS->getExtensionFlag() )
[313]	926	{
[540]	927	#if O0142_CONDITIONAL_SPS_EXTENSION
	928	UInt spsExtensionTypeFlag[8];
	929	for (UInt i = 0; i < 8; i++)
	930	{
	931	READ_FLAG( spsExtensionTypeFlag[i], "sps_extension_type_flag" );
	932	}
	933	if (spsExtensionTypeFlag[1])
	934	{
	935	parseSPSExtension( pcSPS );
	936	}
	937	if (spsExtensionTypeFlag[7])
	938	{
	939	#else
[313]	940	parseSPSExtension( pcSPS );
	941	READ_FLAG( uiCode, "sps_extension2_flag");
	942	if(uiCode)
	943	{
	944	#endif
	945	while ( xMoreRbspData() )
	946	{
	947	READ_FLAG( uiCode, "sps_extension_data_flag");
	948	}
	949	}
[815]	950	}
	951	#else
	952	if (uiCode)
	953	{
	954	while ( xMoreRbspData() )
	955	{
	956	READ_FLAG( uiCode, "sps_extension_data_flag");
	957	}
	958	}
[313]	959	#endif
	960	}
	961
[815]	962	#if SVC_EXTENSION
[313]	963	Void TDecCavlc::parseSPSExtension( TComSPS* pcSPS )
	964	{
	965	UInt uiCode;
	966	// more syntax elements to be parsed here
[442]	967
	968	READ_FLAG( uiCode, "inter_view_mv_vert_constraint_flag" );
	969	// Vertical MV component restriction is not used in SHVC CTC
	970	assert( uiCode == 0 );
[588]	971
[849]	972	#if !MOVE_SCALED_OFFSET_TO_PPS
[313]	973	if( pcSPS->getLayerId() > 0 )
	974	{
[494]	975	Int iCode;
[313]	976	READ_UVLC( uiCode, "num_scaled_ref_layer_offsets" ); pcSPS->setNumScaledRefLayerOffsets(uiCode);
	977	for(Int i = 0; i < pcSPS->getNumScaledRefLayerOffsets(); i++)
	978	{
	979	Window& scaledWindow = pcSPS->getScaledRefLayerWindow(i);
[540]	980	#if O0098_SCALED_REF_LAYER_ID
[644]	981	READ_CODE( 6, uiCode, "scaled_ref_layer_id" ); pcSPS->setScaledRefLayerId( i, uiCode );
[540]	982	#endif
[313]	983	READ_SVLC( iCode, "scaled_ref_layer_left_offset" ); scaledWindow.setWindowLeftOffset (iCode << 1);
	984	READ_SVLC( iCode, "scaled_ref_layer_top_offset" ); scaledWindow.setWindowTopOffset (iCode << 1);
	985	READ_SVLC( iCode, "scaled_ref_layer_right_offset" ); scaledWindow.setWindowRightOffset (iCode << 1);
	986	READ_SVLC( iCode, "scaled_ref_layer_bottom_offset" ); scaledWindow.setWindowBottomOffset(iCode << 1);
[644]	987	#if P0312_VERT_PHASE_ADJ
	988	READ_FLAG( uiCode, "vert_phase_position_enable_flag" ); scaledWindow.setVertPhasePositionEnableFlag(uiCode); pcSPS->setVertPhasePositionEnableFlag( pcSPS->getScaledRefLayerId(i), uiCode);
	989	#endif
[313]	990	}
	991	}
[849]	992	#endif
[313]	993	}
	994	#endif
	995
	996	Void TDecCavlc::parseVPS(TComVPS* pcVPS)
	997	{
	998	UInt uiCode;
	999
	1000	READ_CODE( 4, uiCode, "vps_video_parameter_set_id" ); pcVPS->setVPSId( uiCode );
[836]	1001	#if VPS_RESERVED_FLAGS
	1002	READ_FLAG( uiCode, "vps_base_layer_internal_flag"); pcVPS->setBaseLayerInternalFlag( uiCode ? true : false );
	1003	READ_FLAG( uiCode, "vps_base_layer_available_flag"); pcVPS->setBaseLayerAvailableFlag( uiCode ? true : false );
[874]	1004	#if VPS_AVC_BL_FLAG_REMOVAL
	1005	pcVPS->setNonHEVCBaseLayerFlag( (pcVPS->getBaseLayerAvailableFlag() && !pcVPS->getBaseLayerInternalFlag()) ? true : false);
	1006	#endif
[836]	1007	#else
[313]	1008	READ_CODE( 2, uiCode, "vps_reserved_three_2bits" ); assert(uiCode == 3);
[836]	1009	#endif
[815]	1010	#if SVC_EXTENSION
[547]	1011	#if O0137_MAX_LAYERID
	1012	READ_CODE( 6, uiCode, "vps_max_layers_minus1" ); pcVPS->setMaxLayers( min( 62u, uiCode) + 1 );
[313]	1013	#else
[547]	1014	READ_CODE( 6, uiCode, "vps_max_layers_minus1" ); pcVPS->setMaxLayers( uiCode + 1 );
	1015	#endif
	1016	#else
[313]	1017	READ_CODE( 6, uiCode, "vps_reserved_zero_6bits" ); assert(uiCode == 0);
	1018	#endif
[713]	1019	READ_CODE( 3, uiCode, "vps_max_sub_layers_minus1" ); pcVPS->setMaxTLayers( uiCode + 1 ); assert(uiCode+1 <= MAX_TLAYER);
[313]	1020	READ_FLAG( uiCode, "vps_temporal_id_nesting_flag" ); pcVPS->setTemporalNestingFlag( uiCode ? true:false );
	1021	assert (pcVPS->getMaxTLayers()>1\|\|pcVPS->getTemporalNestingFlag());
[588]	1022	#if !P0125_REVERT_VPS_EXTN_OFFSET_TO_RESERVED
[442]	1023	#if VPS_EXTN_OFFSET
	1024	READ_CODE( 16, uiCode, "vps_extension_offset" ); pcVPS->setExtensionOffset( uiCode );
	1025	#else
[313]	1026	READ_CODE( 16, uiCode, "vps_reserved_ffff_16bits" ); assert(uiCode == 0xffff);
[442]	1027	#endif
[588]	1028	#else
	1029	READ_CODE( 16, uiCode, "vps_reserved_ffff_16bits" ); assert(uiCode == 0xffff);
	1030	#endif
[313]	1031	parsePTL ( pcVPS->getPTL(), true, pcVPS->getMaxTLayers()-1);
	1032	UInt subLayerOrderingInfoPresentFlag;
	1033	READ_FLAG(subLayerOrderingInfoPresentFlag, "vps_sub_layer_ordering_info_present_flag");
	1034	for(UInt i = 0; i <= pcVPS->getMaxTLayers()-1; i++)
	1035	{
	1036	READ_UVLC( uiCode, "vps_max_dec_pic_buffering_minus1[i]" ); pcVPS->setMaxDecPicBuffering( uiCode + 1, i );
	1037	READ_UVLC( uiCode, "vps_num_reorder_pics[i]" ); pcVPS->setNumReorderPics( uiCode, i );
	1038	READ_UVLC( uiCode, "vps_max_latency_increase_plus1[i]" ); pcVPS->setMaxLatencyIncrease( uiCode, i );
	1039
	1040	if (!subLayerOrderingInfoPresentFlag)
	1041	{
	1042	for (i++; i <= pcVPS->getMaxTLayers()-1; i++)
	1043	{
	1044	pcVPS->setMaxDecPicBuffering(pcVPS->getMaxDecPicBuffering(0), i);
	1045	pcVPS->setNumReorderPics(pcVPS->getNumReorderPics(0), i);
	1046	pcVPS->setMaxLatencyIncrease(pcVPS->getMaxLatencyIncrease(0), i);
	1047	}
	1048	break;
	1049	}
	1050	}
	1051
[815]	1052	#if SVC_EXTENSION
[313]	1053	assert( pcVPS->getNumHrdParameters() < MAX_VPS_LAYER_SETS_PLUS1 );
	1054	assert( pcVPS->getMaxLayerId() < MAX_VPS_LAYER_ID_PLUS1 );
	1055	READ_CODE( 6, uiCode, "vps_max_layer_id" ); pcVPS->setMaxLayerId( uiCode );
[815]	1056	#if Q0078_ADD_LAYER_SETS
	1057	READ_UVLC(uiCode, "vps_num_layer_sets_minus1"); pcVPS->setVpsNumLayerSetsMinus1(uiCode);
	1058	pcVPS->setNumLayerSets(pcVPS->getVpsNumLayerSetsMinus1() + 1);
	1059	for (UInt opsIdx = 1; opsIdx <= pcVPS->getVpsNumLayerSetsMinus1(); opsIdx++)
	1060	#else
[313]	1061	READ_UVLC( uiCode, "vps_num_layer_sets_minus1" ); pcVPS->setNumLayerSets( uiCode + 1 );
	1062	for( UInt opsIdx = 1; opsIdx <= ( pcVPS->getNumLayerSets() - 1 ); opsIdx ++ )
[815]	1063	#endif
[313]	1064	{
	1065	// Operation point set
	1066	for( UInt i = 0; i <= pcVPS->getMaxLayerId(); i ++ )
	1067	#else
	1068	assert( pcVPS->getNumHrdParameters() < MAX_VPS_OP_SETS_PLUS1 );
	1069	assert( pcVPS->getMaxNuhReservedZeroLayerId() < MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1 );
	1070	READ_CODE( 6, uiCode, "vps_max_nuh_reserved_zero_layer_id" ); pcVPS->setMaxNuhReservedZeroLayerId( uiCode );
	1071	READ_UVLC( uiCode, "vps_max_op_sets_minus1" ); pcVPS->setMaxOpSets( uiCode + 1 );
	1072	for( UInt opsIdx = 1; opsIdx <= ( pcVPS->getMaxOpSets() - 1 ); opsIdx ++ )
	1073	{
	1074	// Operation point set
	1075	for( UInt i = 0; i <= pcVPS->getMaxNuhReservedZeroLayerId(); i ++ )
	1076	#endif
	1077	{
	1078	READ_FLAG( uiCode, "layer_id_included_flag[opsIdx][i]" ); pcVPS->setLayerIdIncludedFlag( uiCode == 1 ? true : false, opsIdx, i );
	1079	}
	1080	}
	1081	#if DERIVE_LAYER_ID_LIST_VARIABLES
	1082	pcVPS->deriveLayerIdListVariables();
	1083	#endif
	1084	TimingInfo *timingInfo = pcVPS->getTimingInfo();
	1085	READ_FLAG( uiCode, "vps_timing_info_present_flag"); timingInfo->setTimingInfoPresentFlag (uiCode ? true : false);
	1086	if(timingInfo->getTimingInfoPresentFlag())
	1087	{
	1088	READ_CODE( 32, uiCode, "vps_num_units_in_tick"); timingInfo->setNumUnitsInTick (uiCode);
	1089	READ_CODE( 32, uiCode, "vps_time_scale"); timingInfo->setTimeScale (uiCode);
	1090	READ_FLAG( uiCode, "vps_poc_proportional_to_timing_flag"); timingInfo->setPocProportionalToTimingFlag(uiCode ? true : false);
	1091	if(timingInfo->getPocProportionalToTimingFlag())
	1092	{
	1093	READ_UVLC( uiCode, "vps_num_ticks_poc_diff_one_minus1"); timingInfo->setNumTicksPocDiffOneMinus1 (uiCode);
	1094	}
	1095	READ_UVLC( uiCode, "vps_num_hrd_parameters" ); pcVPS->setNumHrdParameters( uiCode );
	1096
	1097	if( pcVPS->getNumHrdParameters() > 0 )
	1098	{
	1099	pcVPS->createHrdParamBuffer();
	1100	}
	1101	for( UInt i = 0; i < pcVPS->getNumHrdParameters(); i ++ )
	1102	{
	1103	READ_UVLC( uiCode, "hrd_op_set_idx" ); pcVPS->setHrdOpSetIdx( uiCode, i );
	1104	if( i > 0 )
	1105	{
	1106	READ_FLAG( uiCode, "cprms_present_flag[i]" ); pcVPS->setCprmsPresentFlag( uiCode == 1 ? true : false, i );
	1107	}
[823]	1108	else
	1109	{
	1110	pcVPS->setCprmsPresentFlag( true, i );
	1111	}
	1112
[313]	1113	parseHrdParameters(pcVPS->getHrdParameters(i), pcVPS->getCprmsPresentFlag( i ), pcVPS->getMaxTLayers() - 1);
	1114	}
	1115	}
[713]	1116
[815]	1117	#if SVC_EXTENSION
[713]	1118	READ_FLAG( uiCode, "vps_extension_flag" ); pcVPS->setVpsExtensionFlag( uiCode ? true : false );
	1119
	1120	// When MaxLayersMinus1 is greater than 0, vps_extension_flag shall be equal to 1.
	1121	if( pcVPS->getMaxLayers() > 1 )
[313]	1122	{
[713]	1123	assert( pcVPS->getVpsExtensionFlag() == true );
	1124	}
	1125
	1126	if( pcVPS->getVpsExtensionFlag() )
	1127	{
[442]	1128	while ( m_pcBitstream->getNumBitsRead() % 8 != 0 )
	1129	{
	1130	READ_FLAG( uiCode, "vps_extension_alignment_bit_equal_to_one"); assert(uiCode == 1);
	1131	}
[313]	1132	parseVPSExtension(pcVPS);
	1133	READ_FLAG( uiCode, "vps_entension2_flag" );
	1134	if(uiCode)
	1135	{
	1136	while ( xMoreRbspData() )
	1137	{
	1138	READ_FLAG( uiCode, "vps_extension_data_flag");
	1139	}
	1140	}
[713]	1141	}
	1142	else
	1143	{
	1144	// set default parameters when syntax elements are not present
	1145	defaultVPSExtension(pcVPS);
	1146	}
[313]	1147	#else
[713]	1148	READ_FLAG( uiCode, "vps_extension_flag" );
	1149	if (uiCode)
	1150	{
[313]	1151	while ( xMoreRbspData() )
	1152	{
	1153	READ_FLAG( uiCode, "vps_extension_data_flag");
	1154	}
[713]	1155	}
[313]	1156	#endif
	1157
	1158	return;
	1159	}
	1160
[494]	1161	#if SVC_EXTENSION
[313]	1162	Void TDecCavlc::parseVPSExtension(TComVPS *vps)
	1163	{
	1164	UInt uiCode;
	1165	// ... More syntax elements to be parsed here
[644]	1166	#if P0300_ALT_OUTPUT_LAYER_FLAG
	1167	Int NumOutputLayersInOutputLayerSet[MAX_VPS_LAYER_SETS_PLUS1];
	1168	Int OlsHighestOutputLayerId[MAX_VPS_LAYER_SETS_PLUS1];
	1169	#endif
[864]	1170	#if LIST_OF_PTL
	1171	if( vps->getMaxLayers() > 1 && vps->getBaseLayerInternalFlag() )
	1172	{
	1173	vps->setProfilePresentFlag(1, false);
	1174	vps->getPTLForExtnPtr()->empty();
	1175	vps->getPTLForExtnPtr()->resize(2);
	1176	vps->getPTLForExtn(1)->copyProfileInfo( vps->getPTL() );
	1177	parsePTL( vps->getPTLForExtn(1), vps->getProfilePresentFlag(1), vps->getMaxTLayers() - 1 );
	1178	}
	1179	#endif
[313]	1180	#if VPS_EXTN_MASK_AND_DIM_INFO
	1181	UInt numScalabilityTypes = 0, i = 0, j = 0;
	1182
[874]	1183	#if !VPS_AVC_BL_FLAG_REMOVAL
[313]	1184	READ_FLAG( uiCode, "avc_base_layer_flag" ); vps->setAvcBaseLayerFlag(uiCode ? true : false);
[874]	1185	#endif
[547]	1186
[588]	1187	#if !P0307_REMOVE_VPS_VUI_OFFSET
[547]	1188	#if O0109_MOVE_VPS_VUI_FLAG
	1189	READ_FLAG( uiCode, "vps_vui_present_flag"); vps->setVpsVuiPresentFlag(uiCode ? true : false);
	1190	if ( uiCode )
	1191	{
	1192	#endif
	1193	#if VPS_VUI_OFFSET
[825]	1194	READ_CODE( 16, uiCode, "vps_vui_offset" ); vps->setVpsVuiOffset( uiCode );
[547]	1195	#endif
	1196	#if O0109_MOVE_VPS_VUI_FLAG
	1197	}
	1198	#endif
[588]	1199	#endif
[313]	1200	READ_FLAG( uiCode, "splitting_flag" ); vps->setSplittingFlag(uiCode ? true : false);
	1201
	1202	for(i = 0; i < MAX_VPS_NUM_SCALABILITY_TYPES; i++)
	1203	{
	1204	READ_FLAG( uiCode, "scalability_mask[i]" ); vps->setScalabilityMask(i, uiCode ? true : false);
	1205	numScalabilityTypes += uiCode;
	1206	}
	1207	vps->setNumScalabilityTypes(numScalabilityTypes);
	1208
	1209	for(j = 0; j < numScalabilityTypes - vps->getSplittingFlag(); j++)
	1210	{
	1211	READ_CODE( 3, uiCode, "dimension_id_len_minus1[j]" ); vps->setDimensionIdLen(j, uiCode + 1);
	1212	}
[494]	1213
[815]	1214	// The value of dimBitOffset[ NumScalabilityTypes ] is set equal to 6.
[313]	1215	if(vps->getSplittingFlag())
	1216	{
	1217	UInt numBits = 0;
	1218	for(j = 0; j < numScalabilityTypes - 1; j++)
	1219	{
	1220	numBits += vps->getDimensionIdLen(j);
	1221	}
	1222	assert( numBits < 6 );
	1223	vps->setDimensionIdLen(numScalabilityTypes-1, 6 - numBits);
	1224	numBits = 6;
	1225	}
	1226
	1227	READ_FLAG( uiCode, "vps_nuh_layer_id_present_flag" ); vps->setNuhLayerIdPresentFlag(uiCode ? true : false);
	1228	vps->setLayerIdInNuh(0, 0);
	1229	vps->setLayerIdInVps(0, 0);
	1230	for(i = 1; i < vps->getMaxLayers(); i++)
	1231	{
	1232	if( vps->getNuhLayerIdPresentFlag() )
	1233	{
	1234	READ_CODE( 6, uiCode, "layer_id_in_nuh[i]" ); vps->setLayerIdInNuh(i, uiCode);
	1235	assert( uiCode > vps->getLayerIdInNuh(i-1) );
	1236	}
	1237	else
	1238	{
	1239	vps->setLayerIdInNuh(i, i);
	1240	}
	1241	vps->setLayerIdInVps(vps->getLayerIdInNuh(i), i);
	1242
[494]	1243	if( !vps->getSplittingFlag() )
	1244	{
[825]	1245	for(j = 0; j < numScalabilityTypes; j++)
	1246	{
	1247	READ_CODE( vps->getDimensionIdLen(j), uiCode, "dimension_id[i][j]" ); vps->setDimensionId(i, j, uiCode);
[494]	1248	#if !AUXILIARY_PICTURES
[825]	1249	assert( uiCode <= vps->getMaxLayerId() );
[494]	1250	#endif
[825]	1251	}
[313]	1252	}
	1253	}
	1254	#endif
[494]	1255	#if VIEW_ID_RELATED_SIGNALING
	1256	// if ( pcVPS->getNumViews() > 1 )
	1257	// However, this is a bug in the text since, view_id_len_minus1 is needed to parse view_id_val.
[442]	1258	{
[547]	1259	#if O0109_VIEW_ID_LEN
	1260	READ_CODE( 4, uiCode, "view_id_len" ); vps->setViewIdLen( uiCode );
	1261	#else
[442]	1262	READ_CODE( 4, uiCode, "view_id_len_minus1" ); vps->setViewIdLenMinus1( uiCode );
[547]	1263	#endif
[442]	1264	}
	1265
[547]	1266	#if O0109_VIEW_ID_LEN
	1267	if ( vps->getViewIdLen() > 0 )
	1268	{
	1269	for( i = 0; i < vps->getNumViews(); i++ )
	1270	{
	1271	READ_CODE( vps->getViewIdLen( ), uiCode, "view_id_val[i]" ); vps->setViewIdVal( i, uiCode );
	1272	}
	1273	}
	1274	#else
[442]	1275	for( i = 0; i < vps->getNumViews(); i++ )
	1276	{
	1277	READ_CODE( vps->getViewIdLenMinus1( ) + 1, uiCode, "view_id_val[i]" ); vps->setViewIdVal( i, uiCode );
	1278	}
	1279	#endif
[547]	1280	#endif // view id related signaling
[313]	1281	#if VPS_EXTN_DIRECT_REF_LAYERS
	1282	// For layer 0
	1283	vps->setNumDirectRefLayers(0, 0);
	1284	// For other layers
	1285	for( Int layerCtr = 1; layerCtr <= vps->getMaxLayers() - 1; layerCtr++)
	1286	{
	1287	UInt numDirectRefLayers = 0;
	1288	for( Int refLayerCtr = 0; refLayerCtr < layerCtr; refLayerCtr++)
	1289	{
	1290	READ_FLAG(uiCode, "direct_dependency_flag[i][j]" ); vps->setDirectDependencyFlag(layerCtr, refLayerCtr, uiCode? true : false);
	1291	if(uiCode)
	1292	{
	1293	vps->setRefLayerId(layerCtr, numDirectRefLayers, refLayerCtr);
	1294	numDirectRefLayers++;
	1295	}
	1296	}
	1297	vps->setNumDirectRefLayers(layerCtr, numDirectRefLayers);
	1298	}
	1299	#endif
[815]	1300	#if Q0078_ADD_LAYER_SETS
	1301	#if O0092_0094_DEPENDENCY_CONSTRAINT // Moved here
	1302	vps->setNumRefLayers();
	1303
	1304	if (vps->getMaxLayers() > MAX_REF_LAYERS)
	1305	{
	1306	for (i = 1; i < vps->getMaxLayers(); i++)
	1307	{
	1308	assert(vps->getNumRefLayers(vps->getLayerIdInNuh(i)) <= MAX_REF_LAYERS);
	1309	}
	1310	}
	1311	#endif
	1312	vps->setPredictedLayerIds();
	1313	vps->setTreePartitionLayerIdList();
	1314	#endif
[862]	1315	#if MOVE_ADDN_LS_SIGNALLING
	1316	#if Q0078_ADD_LAYER_SETS
	1317	if (vps->getNumIndependentLayers() > 1)
	1318	{
	1319	READ_UVLC(uiCode, "num_add_layer_sets"); vps->setNumAddLayerSets(uiCode);
	1320	for (i = 0; i < vps->getNumAddLayerSets(); i++)
	1321	{
	1322	for (j = 1; j < vps->getNumIndependentLayers(); j++)
	1323	{
	1324	int len = 1;
	1325	while ((1 << len) < (vps->getNumLayersInTreePartition(j) + 1))
	1326	{
	1327	len++;
	1328	}
	1329	READ_CODE(len, uiCode, "highest_layer_idx_plus1[i][j]"); vps->setHighestLayerIdxPlus1(i, j, uiCode);
	1330	}
	1331	}
	1332	vps->setNumLayerSets(vps->getNumLayerSets() + vps->getNumAddLayerSets());
	1333	vps->setLayerIdIncludedFlagsForAddLayerSets();
	1334	}
	1335	#endif
	1336	#endif
[540]	1337	#if VPS_TSLAYERS
[713]	1338	READ_FLAG( uiCode, "vps_sub_layers_max_minus1_present_flag"); vps->setMaxTSLayersPresentFlag(uiCode ? true : false);
	1339
	1340	if (vps->getMaxTSLayersPresentFlag())
	1341	{
	1342	for(i = 0; i < vps->getMaxLayers(); i++)
[540]	1343	{
[713]	1344	READ_CODE( 3, uiCode, "sub_layers_vps_max_minus1[i]" ); vps->setMaxTSLayersMinus1(i, uiCode);
[540]	1345	}
[713]	1346	}
	1347	else
	1348	{
	1349	for( i = 0; i < vps->getMaxLayers(); i++)
[540]	1350	{
[713]	1351	vps->setMaxTSLayersMinus1(i, vps->getMaxTLayers()-1);
[540]	1352	}
[713]	1353	}
[540]	1354	#endif
[442]	1355	READ_FLAG( uiCode, "max_tid_ref_present_flag"); vps->setMaxTidRefPresentFlag(uiCode ? true : false);
	1356	if (vps->getMaxTidRefPresentFlag())
[345]	1357	{
	1358	for(i = 0; i < vps->getMaxLayers() - 1; i++)
	1359	{
[494]	1360	#if O0225_MAX_TID_FOR_REF_LAYERS
[825]	1361	for( j = i+1; j <= vps->getMaxLayers() - 1; j++)
	1362	{
	1363	if(vps->getDirectDependencyFlag(j, i))
	1364	{
[885]	1365	READ_CODE( 3, uiCode, "max_tid_il_ref_pics_plus1[i][j]" ); vps->setMaxTidIlRefPicsPlus1(i, j, uiCode);
[825]	1366	}
	1367	}
[494]	1368	#else
[442]	1369	READ_CODE( 3, uiCode, "max_tid_il_ref_pics_plus1[i]" ); vps->setMaxTidIlRefPicsPlus1(i, uiCode);
	1370	assert( uiCode <= vps->getMaxTLayers());
	1371	#endif
[345]	1372	}
	1373	}
[494]	1374	else
[345]	1375	{
	1376	for(i = 0; i < vps->getMaxLayers() - 1; i++)
	1377	{
[494]	1378	#if O0225_MAX_TID_FOR_REF_LAYERS
[825]	1379	for( j = i+1; j <= vps->getMaxLayers() - 1; j++)
	1380	{
	1381	vps->setMaxTidIlRefPicsPlus1(i, j, 7);
	1382	}
[494]	1383	#else
[442]	1384	vps->setMaxTidIlRefPicsPlus1(i, 7);
[494]	1385	#endif
[345]	1386	}
	1387	}
[815]	1388	READ_FLAG( uiCode, "all_ref_layers_active_flag" ); vps->setIlpSshSignalingEnabledFlag(uiCode ? true : false);
[313]	1389	#if VPS_EXTN_PROFILE_INFO
	1390	// Profile-tier-level signalling
[588]	1391	#if !VPS_EXTN_UEV_CODING
[313]	1392	READ_CODE( 10, uiCode, "vps_number_layer_sets_minus1" ); assert( uiCode == (vps->getNumLayerSets() - 1) );
	1393	READ_CODE( 6, uiCode, "vps_num_profile_tier_level_minus1"); vps->setNumProfileTierLevel( uiCode + 1 );
[588]	1394	#else
	1395	READ_UVLC( uiCode, "vps_num_profile_tier_level_minus1"); vps->setNumProfileTierLevel( uiCode + 1 );
	1396	#endif
[866]	1397	#if PER_LAYER_PTL
	1398	Int const numBitsForPtlIdx = vps->calculateLenOfSyntaxElement( vps->getNumProfileTierLevel() );
	1399	#endif
[313]	1400	vps->getPTLForExtnPtr()->resize(vps->getNumProfileTierLevel());
[864]	1401	#if LIST_OF_PTL
	1402	for(Int idx = vps->getBaseLayerInternalFlag() ? 2 : 1; idx <= vps->getNumProfileTierLevel() - 1; idx++)
	1403	#else
[313]	1404	for(Int idx = 1; idx <= vps->getNumProfileTierLevel() - 1; idx++)
[864]	1405	#endif
[313]	1406	{
	1407	READ_FLAG( uiCode, "vps_profile_present_flag[i]" ); vps->setProfilePresentFlag(idx, uiCode ? true : false);
	1408	if( !vps->getProfilePresentFlag(idx) )
	1409	{
[588]	1410	#if P0048_REMOVE_PROFILE_REF
	1411	// Copy profile information from previous one
	1412	vps->getPTLForExtn(idx)->copyProfileInfo( (idx==1) ? vps->getPTL() : vps->getPTLForExtn( idx - 1 ) );
	1413	#else
[313]	1414	READ_CODE( 6, uiCode, "profile_ref_minus1[i]" ); vps->setProfileLayerSetRef(idx, uiCode + 1);
[547]	1415	#if O0109_PROF_REF_MINUS1
	1416	assert( vps->getProfileLayerSetRef(idx) <= idx );
	1417	#else
[313]	1418	assert( vps->getProfileLayerSetRef(idx) < idx );
[547]	1419	#endif
[313]	1420	// Copy profile information as indicated
	1421	vps->getPTLForExtn(idx)->copyProfileInfo( vps->getPTLForExtn( vps->getProfileLayerSetRef(idx) ) );
[588]	1422	#endif
[313]	1423	}
	1424	parsePTL( vps->getPTLForExtn(idx), vps->getProfilePresentFlag(idx), vps->getMaxTLayers() - 1 );
	1425	}
	1426	#endif
	1427
[862]	1428	#if !MOVE_ADDN_LS_SIGNALLING
[815]	1429	#if Q0078_ADD_LAYER_SETS
	1430	if (vps->getNumIndependentLayers() > 1)
	1431	{
	1432	READ_UVLC(uiCode, "num_add_layer_sets"); vps->setNumAddLayerSets(uiCode);
	1433	for (i = 0; i < vps->getNumAddLayerSets(); i++)
	1434	{
	1435	for (j = 1; j < vps->getNumIndependentLayers(); j++)
	1436	{
	1437	int len = 1;
	1438	while ((1 << len) < (vps->getNumLayersInTreePartition(j) + 1))
	1439	{
	1440	len++;
	1441	}
	1442	READ_CODE(len, uiCode, "highest_layer_idx_plus1[i][j]"); vps->setHighestLayerIdxPlus1(i, j, uiCode);
	1443	}
	1444	}
	1445	vps->setNumLayerSets(vps->getNumLayerSets() + vps->getNumAddLayerSets());
	1446	vps->setLayerIdIncludedFlagsForAddLayerSets();
	1447	}
	1448	#endif
[862]	1449	#endif
[815]	1450
[588]	1451	#if !VPS_EXTN_UEV_CODING
[313]	1452	READ_FLAG( uiCode, "more_output_layer_sets_than_default_flag" ); vps->setMoreOutputLayerSetsThanDefaultFlag( uiCode ? true : false );
	1453	Int numOutputLayerSets = 0;
	1454	if(! vps->getMoreOutputLayerSetsThanDefaultFlag() )
	1455	{
	1456	numOutputLayerSets = vps->getNumLayerSets();
	1457	}
	1458	else
	1459	{
	1460	READ_CODE( 10, uiCode, "num_add_output_layer_sets" ); vps->setNumAddOutputLayerSets( uiCode );
	1461	numOutputLayerSets = vps->getNumLayerSets() + vps->getNumAddOutputLayerSets();
	1462	}
[588]	1463	#else
[713]	1464
	1465	#if Q0165_NUM_ADD_OUTPUT_LAYER_SETS
	1466	if( vps->getNumLayerSets() > 1 )
	1467	{
[815]	1468	READ_UVLC( uiCode, "num_add_olss" ); vps->setNumAddOutputLayerSets( uiCode );
	1469	READ_CODE( 2, uiCode, "default_output_layer_idc" ); vps->setDefaultTargetOutputLayerIdc( uiCode );
[713]	1470	}
	1471	else
	1472	{
	1473	vps->setNumAddOutputLayerSets( 0 );
	1474	}
	1475	#else
[588]	1476	READ_UVLC( uiCode, "num_add_output_layer_sets" ); vps->setNumAddOutputLayerSets( uiCode );
[713]	1477	#endif
	1478
[815]	1479	// The value of num_add_olss shall be in the range of 0 to 1023, inclusive.
[713]	1480	assert( vps->getNumAddOutputLayerSets() >= 0 && vps->getNumAddOutputLayerSets() < 1024 );
	1481
[588]	1482	Int numOutputLayerSets = vps->getNumLayerSets() + vps->getNumAddOutputLayerSets();
	1483	#endif
	1484
	1485	#if P0295_DEFAULT_OUT_LAYER_IDC
[713]	1486	#if !Q0165_NUM_ADD_OUTPUT_LAYER_SETS
[313]	1487	if( numOutputLayerSets > 1 )
	1488	{
[588]	1489	READ_CODE( 2, uiCode, "default_target_output_layer_idc" ); vps->setDefaultTargetOutputLayerIdc( uiCode );
	1490	}
[713]	1491	#endif
[588]	1492	vps->setNumOutputLayerSets( numOutputLayerSets );
[865]	1493	#if NECESSARY_LAYER_FLAG
	1494	// Default output layer set
	1495	vps->setOutputLayerSetIdx(0, 0);
	1496	vps->setOutputLayerFlag(0, 0, true);
	1497	vps->deriveNecessaryLayerFlag(0);
[866]	1498	#if PER_LAYER_PTL
	1499	vps->getProfileLevelTierIdx()->resize(numOutputLayerSets);
	1500	vps->getProfileLevelTierIdx(0)->push_back( vps->getBaseLayerInternalFlag() && vps->getMaxLayers() > 1 ? 1 : 0);
[865]	1501	#endif
[866]	1502	#endif
[588]	1503	for(i = 1; i < numOutputLayerSets; i++)
	1504	{
	1505	if( i > (vps->getNumLayerSets() - 1) )
	1506	{
	1507	Int numBits = 1;
	1508	while ((1 << numBits) < (vps->getNumLayerSets() - 1))
	1509	{
	1510	numBits++;
	1511	}
[815]	1512	READ_CODE( numBits, uiCode, "layer_set_idx_for_ols_minus1"); vps->setOutputLayerSetIdx( i, uiCode + 1);
[588]	1513	}
	1514	else
	1515	{
	1516	vps->setOutputLayerSetIdx( i, i );
	1517	}
[866]	1518	Int layerSetIdxForOutputLayerSet = vps->getOutputLayerSetIdx(i);
[815]	1519	#if Q0078_ADD_LAYER_SETS
	1520	if ( i > vps->getVpsNumLayerSetsMinus1() \|\| vps->getDefaultTargetOutputLayerIdc() >= 2 )
	1521	#else
[588]	1522	if ( i > (vps->getNumLayerSets() - 1) \|\| vps->getDefaultTargetOutputLayerIdc() >= 2 )
[815]	1523	#endif
[588]	1524	{
[644]	1525	#if NUM_OL_FLAGS
[866]	1526	for(j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet); j++)
[644]	1527	#else
[588]	1528	for(j = 0; j < vps->getNumLayersInIdList(lsIdx) - 1; j++)
[644]	1529	#endif
[588]	1530	{
	1531	READ_FLAG( uiCode, "output_layer_flag[i][j]"); vps->setOutputLayerFlag(i, j, uiCode);
	1532	}
	1533	}
	1534	else
	1535	{
	1536	// i <= (vps->getNumLayerSets() - 1)
	1537	// Assign OutputLayerFlag depending on default_one_target_output_layer_flag
	1538	if( vps->getDefaultTargetOutputLayerIdc() == 1 )
	1539	{
[866]	1540	for(j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet); j++)
[588]	1541	{
[866]	1542	vps->setOutputLayerFlag(i, j, (j == (vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet)-1)) && (vps->getDimensionId(j,1) == 0) );
[588]	1543	}
	1544	}
	1545	else if ( vps->getDefaultTargetOutputLayerIdc() == 0 )
	1546	{
[866]	1547	for(j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet); j++)
[588]	1548	{
	1549	vps->setOutputLayerFlag(i, j, 1);
	1550	}
	1551	}
	1552	}
[865]	1553	#if NECESSARY_LAYER_FLAG
	1554	vps->deriveNecessaryLayerFlag(i);
	1555	#endif
[866]	1556	#if PER_LAYER_PTL
	1557	vps->getProfileLevelTierIdx(i)->assign(vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet), -1);
	1558	for(j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet) ; j++)
	1559	{
	1560	if( vps->getNecessaryLayerFlag(i, j) )
	1561	{
	1562	READ_CODE( numBitsForPtlIdx, uiCode, "profile_level_tier_idx[i]" );
	1563	vps->setProfileLevelTierIdx(i, j, uiCode );
	1564	}
	1565	}
	1566	#else
[588]	1567	Int numBits = 1;
	1568	while ((1 << numBits) < (vps->getNumProfileTierLevel()))
	1569	{
	1570	numBits++;
	1571	}
	1572	READ_CODE( numBits, uiCode, "profile_level_tier_idx[i]" ); vps->setProfileLevelTierIdx(i, uiCode);
[866]	1573	#endif
[644]	1574	#if P0300_ALT_OUTPUT_LAYER_FLAG
	1575	NumOutputLayersInOutputLayerSet[i] = 0;
	1576	for (j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet); j++)
	1577	{
	1578	NumOutputLayersInOutputLayerSet[i] += vps->getOutputLayerFlag(i, j);
	1579	if (vps->getOutputLayerFlag(i, j))
	1580	{
	1581	OlsHighestOutputLayerId[i] = vps->getLayerSetLayerIdList(layerSetIdxForOutputLayerSet, j);
	1582	}
	1583	}
	1584	if (NumOutputLayersInOutputLayerSet[i] == 1 && vps->getNumDirectRefLayers(OlsHighestOutputLayerId[i]) > 0)
	1585	{
	1586	READ_FLAG(uiCode, "alt_output_layer_flag[i]");
	1587	vps->setAltOuputLayerFlag(i, uiCode ? true : false);
	1588	}
[713]	1589	#if Q0165_OUTPUT_LAYER_SET
	1590	assert( NumOutputLayersInOutputLayerSet[i]>0 );
[644]	1591	#endif
[713]	1592
	1593	#endif
[588]	1594	}
[865]	1595	#if NECESSARY_LAYER_FLAG
	1596	vps->checkNecessaryLayerFlagCondition();
	1597	#endif
[588]	1598	#else
	1599	if( numOutputLayerSets > 1 )
	1600	{
[547]	1601	#if O0109_DEFAULT_ONE_OUT_LAYER_IDC
	1602	READ_CODE( 2, uiCode, "default_one_target_output_layer_idc" ); vps->setDefaultOneTargetOutputLayerIdc( uiCode );
	1603	#else
[313]	1604	READ_FLAG( uiCode, "default_one_target_output_layer_flag" ); vps->setDefaultOneTargetOutputLayerFlag( uiCode ? true : false );
[547]	1605	#endif
[313]	1606	}
	1607	vps->setNumOutputLayerSets( numOutputLayerSets );
	1608
	1609	for(i = 1; i < numOutputLayerSets; i++)
	1610	{
	1611	if( i > (vps->getNumLayerSets() - 1) )
	1612	{
	1613	Int numBits = 1;
	1614	while ((1 << numBits) < (vps->getNumLayerSets() - 1))
	1615	{
	1616	numBits++;
	1617	}
	1618	READ_CODE( numBits, uiCode, "output_layer_set_idx_minus1"); vps->setOutputLayerSetIdx( i, uiCode + 1);
	1619	Int lsIdx = vps->getOutputLayerSetIdx(i);
[644]	1620	#if NUM_OL_FLAGS
	1621	for(j = 0; j < vps->getNumLayersInIdList(lsIdx) ; j++)
	1622	#else
[313]	1623	for(j = 0; j < vps->getNumLayersInIdList(lsIdx) - 1; j++)
[644]	1624	#endif
[313]	1625	{
	1626	READ_FLAG( uiCode, "output_layer_flag[i][j]"); vps->setOutputLayerFlag(i, j, uiCode);
	1627	}
	1628	}
	1629	else
	1630	{
[540]	1631	#if VPS_DPB_SIZE_TABLE
	1632	vps->setOutputLayerSetIdx( i, i );
	1633	#endif
[313]	1634	// i <= (vps->getNumLayerSets() - 1)
	1635	// Assign OutputLayerFlag depending on default_one_target_output_layer_flag
	1636	Int lsIdx = i;
[547]	1637	#if O0109_DEFAULT_ONE_OUT_LAYER_IDC
	1638	if( vps->getDefaultOneTargetOutputLayerIdc() == 1 )
	1639	{
	1640	for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++)
	1641	{
	1642	#if O0135_DEFAULT_ONE_OUT_SEMANTIC
	1643	vps->setOutputLayerFlag(i, j, (j == (vps->getNumLayersInIdList(lsIdx)-1)) && (vps->getDimensionId(j,1)==0) );
	1644	#else
	1645	vps->setOutputLayerFlag(i, j, (j == (vps->getNumLayersInIdList(lsIdx)-1)));
	1646	#endif
	1647	}
	1648	}
	1649	else if ( vps->getDefaultOneTargetOutputLayerIdc() == 0 )
	1650	{
	1651	for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++)
	1652	{
	1653	vps->setOutputLayerFlag(i, j, 1);
	1654	}
	1655	}
	1656	else
	1657	{
	1658	// Other values of default_one_target_output_layer_idc than 0 and 1 are reserved for future use.
	1659	}
	1660	#else
[313]	1661	if( vps->getDefaultOneTargetOutputLayerFlag() )
	1662	{
	1663	for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++)
	1664	{
	1665	vps->setOutputLayerFlag(i, j, (j == (vps->getNumLayersInIdList(lsIdx)-1)));
	1666	}
	1667	}
	1668	else
	1669	{
	1670	for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++)
	1671	{
	1672	vps->setOutputLayerFlag(i, j, 1);
	1673	}
	1674	}
[547]	1675	#endif
[313]	1676	}
	1677	Int numBits = 1;
	1678	while ((1 << numBits) < (vps->getNumProfileTierLevel()))
	1679	{
	1680	numBits++;
	1681	}
	1682	READ_CODE( numBits, uiCode, "profile_level_tier_idx[i]" ); vps->setProfileLevelTierIdx(i, uiCode);
	1683	}
[588]	1684	#endif
[494]	1685
[644]	1686	#if !P0300_ALT_OUTPUT_LAYER_FLAG
[540]	1687	#if O0153_ALT_OUTPUT_LAYER_FLAG
	1688	if( vps->getMaxLayers() > 1 )
	1689	{
	1690	READ_FLAG( uiCode, "alt_output_layer_flag");
	1691	vps->setAltOuputLayerFlag( uiCode ? true : false );
	1692	}
	1693	#endif
[644]	1694	#endif
[540]	1695
[442]	1696	#if REPN_FORMAT_IN_VPS
[713]	1697	#if Q0195_REP_FORMAT_CLEANUP
	1698	READ_UVLC( uiCode, "vps_num_rep_formats_minus1" );
	1699	vps->setVpsNumRepFormats( uiCode + 1 );
	1700
	1701	// The value of vps_num_rep_formats_minus1 shall be in the range of 0 to 255, inclusive.
	1702	assert( vps->getVpsNumRepFormats() > 0 && vps->getVpsNumRepFormats() <= 256 );
	1703
	1704	for(i = 0; i < vps->getVpsNumRepFormats(); i++)
	1705	{
	1706	// Read rep_format_structures
	1707	parseRepFormat( vps->getVpsRepFormat(i), i > 0 ? vps->getVpsRepFormat(i-1) : 0 );
	1708	}
	1709
	1710	// Default assignment for layer 0
	1711	vps->setVpsRepFormatIdx( 0, 0 );
	1712
	1713	if( vps->getVpsNumRepFormats() > 1 )
	1714	{
	1715	READ_FLAG( uiCode, "rep_format_idx_present_flag");
	1716	vps->setRepFormatIdxPresentFlag( uiCode ? true : false );
	1717	}
	1718	else
	1719	{
	1720	// When not present, the value of rep_format_idx_present_flag is inferred to be equal to 0
	1721	vps->setRepFormatIdxPresentFlag( false );
	1722	}
	1723
	1724	if( vps->getRepFormatIdxPresentFlag() )
	1725	{
	1726	for(i = 1; i < vps->getMaxLayers(); i++)
	1727	{
	1728	Int numBits = 1;
	1729	while ((1 << numBits) < (vps->getVpsNumRepFormats()))
	1730	{
	1731	numBits++;
	1732	}
	1733	READ_CODE( numBits, uiCode, "vps_rep_format_idx[i]" );
	1734	vps->setVpsRepFormatIdx( i, uiCode );
	1735	}
	1736	}
	1737	else
	1738	{
	1739	// When not present, the value of vps_rep_format_idx[ i ] is inferred to be equal to Min (i, vps_num_rep_formats_minus1)
	1740	for(i = 1; i < vps->getMaxLayers(); i++)
	1741	{
	1742	vps->setVpsRepFormatIdx( i, min( (Int)i, vps->getVpsNumRepFormats()-1 ) );
	1743	}
	1744	}
	1745	#else
[494]	1746	READ_FLAG( uiCode, "rep_format_idx_present_flag");
[442]	1747	vps->setRepFormatIdxPresentFlag( uiCode ? true : false );
	1748
	1749	if( vps->getRepFormatIdxPresentFlag() )
	1750	{
[540]	1751	#if O0096_REP_FORMAT_INDEX
[588]	1752	#if !VPS_EXTN_UEV_CODING
[540]	1753	READ_CODE( 8, uiCode, "vps_num_rep_formats_minus1" );
	1754	#else
[588]	1755	READ_UVLC( uiCode, "vps_num_rep_formats_minus1" );
	1756	#endif
	1757	#else
[442]	1758	READ_CODE( 4, uiCode, "vps_num_rep_formats_minus1" );
[540]	1759	#endif
[442]	1760	vps->setVpsNumRepFormats( uiCode + 1 );
	1761	}
	1762	else
	1763	{
	1764	// default assignment
	1765	assert (vps->getMaxLayers() <= 16); // If max_layers_is more than 15, num_rep_formats has to be signaled
	1766	vps->setVpsNumRepFormats( vps->getMaxLayers() );
	1767	}
[713]	1768
	1769	// The value of vps_num_rep_formats_minus1 shall be in the range of 0 to 255, inclusive.
	1770	assert( vps->getVpsNumRepFormats() > 0 && vps->getVpsNumRepFormats() <= 256 );
	1771
[442]	1772	for(i = 0; i < vps->getVpsNumRepFormats(); i++)
	1773	{
	1774	// Read rep_format_structures
[713]	1775	parseRepFormat( vps->getVpsRepFormat(i), i > 0 ? vps->getVpsRepFormat(i-1) : 0 );
[442]	1776	}
[494]	1777
[442]	1778	// Default assignment for layer 0
	1779	vps->setVpsRepFormatIdx( 0, 0 );
	1780	if( vps->getRepFormatIdxPresentFlag() )
	1781	{
	1782	for(i = 1; i < vps->getMaxLayers(); i++)
	1783	{
	1784	if( vps->getVpsNumRepFormats() > 1 )
	1785	{
[540]	1786	#if O0096_REP_FORMAT_INDEX
[588]	1787	#if !VPS_EXTN_UEV_CODING
[540]	1788	READ_CODE( 8, uiCode, "vps_rep_format_idx[i]" );
	1789	#else
[588]	1790	Int numBits = 1;
	1791	while ((1 << numBits) < (vps->getVpsNumRepFormats()))
	1792	{
	1793	numBits++;
	1794	}
	1795	READ_CODE( numBits, uiCode, "vps_rep_format_idx[i]" );
	1796	#endif
	1797	#else
[442]	1798	READ_CODE( 4, uiCode, "vps_rep_format_idx[i]" );
[540]	1799	#endif
[442]	1800	vps->setVpsRepFormatIdx( i, uiCode );
	1801	}
	1802	else
	1803	{
	1804	// default assignment - only one rep_format() structure
	1805	vps->setVpsRepFormatIdx( i, 0 );
	1806	}
	1807	}
	1808	}
	1809	else
	1810	{
	1811	// default assignment - each layer assigned each rep_format() structure in the order signaled
	1812	for(i = 1; i < vps->getMaxLayers(); i++)
	1813	{
	1814	vps->setVpsRepFormatIdx( i, i );
	1815	}
	1816	}
	1817	#endif
[713]	1818	#endif
[588]	1819	#if RESOLUTION_BASED_DPB
	1820	vps->assignSubDpbIndices();
	1821	#endif
[442]	1822	READ_FLAG(uiCode, "max_one_active_ref_layer_flag" );
	1823	vps->setMaxOneActiveRefLayerFlag(uiCode);
[494]	1824	#if O0062_POC_LSB_NOT_PRESENT_FLAG
	1825	for(i = 1; i< vps->getMaxLayers(); i++)
[313]	1826	{
[494]	1827	if( vps->getNumDirectRefLayers( vps->getLayerIdInNuh(i) ) == 0 )
[313]	1828	{
[494]	1829	READ_FLAG(uiCode, "poc_lsb_not_present_flag[i]");
	1830	vps->setPocLsbNotPresentFlag(i, uiCode);
[313]	1831	}
	1832	}
	1833	#endif
[494]	1834	#if O0215_PHASE_ALIGNMENT
	1835	READ_FLAG( uiCode, "cross_layer_phase_alignment_flag"); vps->setPhaseAlignFlag( uiCode == 1 ? true : false );
[313]	1836	#endif
[494]	1837
[815]	1838	#if !IRAP_ALIGN_FLAG_IN_VPS_VUI
[494]	1839	READ_FLAG(uiCode, "cross_layer_irap_aligned_flag" );
	1840	vps->setCrossLayerIrapAlignFlag(uiCode);
	1841	#endif
	1842
[540]	1843	#if VPS_DPB_SIZE_TABLE
[588]	1844	parseVpsDpbSizeTable(vps);
[540]	1845	#endif
[588]	1846
	1847	#if VPS_EXTN_DIRECT_REF_LAYERS
[313]	1848	READ_UVLC( uiCode, "direct_dep_type_len_minus2"); vps->setDirectDepTypeLen(uiCode+2);
[540]	1849	#if O0096_DEFAULT_DEPENDENCY_TYPE
	1850	READ_FLAG(uiCode, "default_direct_dependency_type_flag");
	1851	vps->setDefaultDirectDependecyTypeFlag(uiCode == 1? true : false);
	1852	if (vps->getDefaultDirectDependencyTypeFlag())
	1853	{
	1854	READ_CODE( vps->getDirectDepTypeLen(), uiCode, "default_direct_dependency_type" );
	1855	vps->setDefaultDirectDependecyType(uiCode);
	1856	}
	1857	#endif
[313]	1858	for(i = 1; i < vps->getMaxLayers(); i++)
	1859	{
	1860	for(j = 0; j < i; j++)
	1861	{
	1862	if (vps->getDirectDependencyFlag(i, j))
	1863	{
[540]	1864	#if O0096_DEFAULT_DEPENDENCY_TYPE
	1865	if (vps->getDefaultDirectDependencyTypeFlag())
	1866	{
	1867	vps->setDirectDependencyType(i, j, vps->getDefaultDirectDependencyType());
	1868	}
	1869	else
	1870	{
	1871	READ_CODE( vps->getDirectDepTypeLen(), uiCode, "direct_dependency_type[i][j]" );
	1872	vps->setDirectDependencyType(i, j, uiCode);
	1873	}
	1874	#else
	1875	READ_CODE( vps->getDirectDepTypeLen(), uiCode, "direct_dependency_type[i][j]" );
	1876	vps->setDirectDependencyType(i, j, uiCode);
	1877	#endif
[313]	1878	}
	1879	}
	1880	}
	1881	#endif
[815]	1882	#if !Q0078_ADD_LAYER_SETS
	1883	#if O0092_0094_DEPENDENCY_CONSTRAINT // Moved up
	1884	vps->setNumRefLayers();
	1885
[540]	1886	if(vps->getMaxLayers() > MAX_REF_LAYERS)
	1887	{
	1888	for(i = 1;i < vps->getMaxLayers(); i++)
[442]	1889	{
[540]	1890	assert( vps->getNumRefLayers(vps->getLayerIdInNuh(i)) <= MAX_REF_LAYERS);
[442]	1891	}
[540]	1892	}
[442]	1893	#endif
[815]	1894	#endif
[442]	1895
[588]	1896	#if P0307_VPS_NON_VUI_EXTENSION
	1897	READ_UVLC( uiCode, "vps_non_vui_extension_length"); vps->setVpsNonVuiExtLength((Int)uiCode);
[713]	1898
	1899	// The value of vps_non_vui_extension_length shall be in the range of 0 to 4096, inclusive.
	1900	assert( vps->getVpsNonVuiExtLength() >= 0 && vps->getVpsNonVuiExtLength() <= 4096 );
	1901
[644]	1902	#if P0307_VPS_NON_VUI_EXT_UPDATE
	1903	Int nonVuiExtByte = uiCode;
	1904	for (i = 1; i <= nonVuiExtByte; i++)
	1905	{
	1906	READ_CODE( 8, uiCode, "vps_non_vui_extension_data_byte" ); //just parse and discard for now.
	1907	}
	1908	#else
[588]	1909	if ( vps->getVpsNonVuiExtLength() > 0 )
	1910	{
	1911	printf("\n\nUp to the current spec, the value of vps_non_vui_extension_length is supposed to be 0\n");
	1912	}
	1913	#endif
[644]	1914	#endif
[588]	1915
[547]	1916	#if !O0109_O0199_FLAGS_TO_VUI
[313]	1917	#if M0040_ADAPTIVE_RESOLUTION_CHANGE
	1918	READ_FLAG(uiCode, "single_layer_for_non_irap_flag" ); vps->setSingleLayerForNonIrapFlag(uiCode == 1 ? true : false);
	1919	#endif
[540]	1920	#if HIGHER_LAYER_IRAP_SKIP_FLAG
	1921	READ_FLAG(uiCode, "higher_layer_irap_skip_flag" ); vps->setHigherLayerIrapSkipFlag(uiCode == 1 ? true : false);
	1922	#endif
[547]	1923	#endif
[442]	1924
[588]	1925	#if P0307_REMOVE_VPS_VUI_OFFSET
	1926	READ_FLAG( uiCode, "vps_vui_present_flag"); vps->setVpsVuiPresentFlag(uiCode ? true : false);
	1927	#endif
	1928
[547]	1929	#if O0109_MOVE_VPS_VUI_FLAG
	1930	if ( vps->getVpsVuiPresentFlag() )
	1931	#else
[442]	1932	READ_FLAG( uiCode, "vps_vui_present_flag" );
	1933	if (uiCode)
[547]	1934	#endif
[442]	1935	{
	1936	while ( m_pcBitstream->getNumBitsRead() % 8 != 0 )
	1937	{
	1938	READ_FLAG( uiCode, "vps_vui_alignment_bit_equal_to_one"); assert(uiCode == 1);
	1939	}
	1940	parseVPSVUI(vps);
	1941	}
[713]	1942	else
	1943	{
	1944	// set default values for VPS VUI
	1945	defaultVPSVUI( vps );
	1946	}
[313]	1947	}
[713]	1948
	1949	Void TDecCavlc::defaultVPSExtension( TComVPS* vps )
	1950	{
	1951	// set default parameters when they are not present
	1952	Int i, j;
	1953
	1954	// When layer_id_in_nuh[ i ] is not present, the value is inferred to be equal to i.
	1955	for(i = 0; i < vps->getMaxLayers(); i++)
	1956	{
	1957	vps->setLayerIdInNuh(i, i);
	1958	vps->setLayerIdInVps(vps->getLayerIdInNuh(i), i);
	1959	}
	1960
	1961	// When not present, sub_layers_vps_max_minus1[ i ] is inferred to be equal to vps_max_sub_layers_minus1.
	1962	for( i = 0; i < vps->getMaxLayers(); i++)
	1963	{
	1964	vps->setMaxTSLayersMinus1(i, vps->getMaxTLayers()-1);
	1965	}
	1966
	1967	// When not present, max_tid_il_ref_pics_plus1[ i ][ j ] is inferred to be equal to 7.
	1968	for( i = 0; i < vps->getMaxLayers() - 1; i++ )
	1969	{
	1970	#if O0225_MAX_TID_FOR_REF_LAYERS
	1971	for( j = i + 1; j < vps->getMaxLayers(); j++ )
	1972	{
	1973	vps->setMaxTidIlRefPicsPlus1(i, j, 7);
	1974	}
	1975	#else
	1976	vps->setMaxTidIlRefPicsPlus1(i, 7);
[313]	1977	#endif
[713]	1978	}
[825]	1979
[815]	1980	// When not present, the value of num_add_olss is inferred to be equal to 0.
	1981	// NumOutputLayerSets = num_add_olss + NumLayerSets
[713]	1982	vps->setNumOutputLayerSets( vps->getNumLayerSets() );
	1983
	1984	// For i in the range of 0 to NumOutputLayerSets-1, inclusive, the variable LayerSetIdxForOutputLayerSet[ i ] is derived as specified in the following:
[815]	1985	// LayerSetIdxForOutputLayerSet[ i ] = ( i <= vps_number_layer_sets_minus1 ) ? i : layer_set_idx_for_ols_minus1[ i ] + 1
[713]	1986	for( i = 1; i < vps->getNumOutputLayerSets(); i++ )
	1987	{
	1988	vps->setOutputLayerSetIdx( i, i );
	1989	Int lsIdx = vps->getOutputLayerSetIdx(i);
	1990
	1991	for( j = 0; j < vps->getNumLayersInIdList(lsIdx); j++ )
	1992	{
[825]	1993	vps->setOutputLayerFlag(i, j, 1);
[713]	1994	}
	1995	}
	1996
	1997	// The value of sub_layer_dpb_info_present_flag[ i ][ 0 ] for any possible value of i is inferred to be equal to 1
	1998	// When not present, the value of sub_layer_dpb_info_present_flag[ i ][ j ] for j greater than 0 and any possible value of i, is inferred to be equal to be equal to 0.
	1999	for( i = 1; i < vps->getNumOutputLayerSets(); i++ )
	2000	{
	2001	vps->setSubLayerDpbInfoPresentFlag( i, 0, true );
	2002	}
[825]	2003
[713]	2004	// When not present, the value of vps_num_rep_formats_minus1 is inferred to be equal to MaxLayersMinus1.
	2005	vps->setVpsNumRepFormats( vps->getMaxLayers() );
	2006
	2007	// When not present, the value of rep_format_idx_present_flag is inferred to be equal to 0
	2008	vps->setRepFormatIdxPresentFlag( false );
	2009
	2010	if( !vps->getRepFormatIdxPresentFlag() )
	2011	{
	2012	// When not present, the value of vps_rep_format_idx[ i ] is inferred to be equal to Min(i, vps_num_rep_formats_minus1).
	2013	for(i = 1; i < vps->getMaxLayers(); i++)
	2014	{
	2015	vps->setVpsRepFormatIdx( i, min( (Int)i, vps->getVpsNumRepFormats() - 1 ) );
	2016	}
	2017	}
	2018
	2019	// vps_poc_lsb_aligned_flag
	2020	// When not present, vps_poc_lsb_aligned_flag is inferred to be equal to 0.
[825]	2021
[713]	2022	#if O0062_POC_LSB_NOT_PRESENT_FLAG
	2023	// When not present, poc_lsb_not_present_flag[ i ] is inferred to be equal to 0.
	2024	for(i = 1; i< vps->getMaxLayers(); i++)
	2025	{
	2026	vps->setPocLsbNotPresentFlag(i, 0);
	2027	}
	2028	#endif
	2029
	2030	// set default values for VPS VUI
	2031	defaultVPSVUI( vps );
	2032	}
	2033
	2034	Void TDecCavlc::defaultVPSVUI( TComVPS* vps )
	2035	{
	2036	// When not present, the value of all_layers_idr_aligned_flag is inferred to be equal to 0.
	2037	vps->setCrossLayerIrapAlignFlag( false );
	2038
	2039	#if M0040_ADAPTIVE_RESOLUTION_CHANGE
	2040	// When single_layer_for_non_irap_flag is not present, it is inferred to be equal to 0.
	2041	vps->setSingleLayerForNonIrapFlag( false );
	2042	#endif
	2043
	2044	#if HIGHER_LAYER_IRAP_SKIP_FLAG
	2045	// When higher_layer_irap_skip_flag is not present it is inferred to be equal to 0
	2046	vps->setHigherLayerIrapSkipFlag( false );
	2047	#endif
	2048	}
	2049
[442]	2050	#if REPN_FORMAT_IN_VPS
[713]	2051	Void TDecCavlc::parseRepFormat( RepFormat repFormat, RepFormat repFormatPrev )
[442]	2052	{
	2053	UInt uiCode;
[713]	2054	#if REPN_FORMAT_CONTROL_FLAG
	2055	READ_CODE( 16, uiCode, "pic_width_vps_in_luma_samples" ); repFormat->setPicWidthVpsInLumaSamples ( uiCode );
	2056	READ_CODE( 16, uiCode, "pic_height_vps_in_luma_samples" ); repFormat->setPicHeightVpsInLumaSamples( uiCode );
	2057	READ_FLAG( uiCode, "chroma_and_bit_depth_vps_present_flag" ); repFormat->setChromaAndBitDepthVpsPresentFlag( uiCode ? true : false );
[540]	2058
[713]	2059	if( !repFormatPrev )
	2060	{
	2061	// The value of chroma_and_bit_depth_vps_present_flag of the first rep_format( ) syntax structure in the VPS shall be equal to 1
	2062	assert( repFormat->getChromaAndBitDepthVpsPresentFlag() );
	2063	}
	2064
[540]	2065	if( repFormat->getChromaAndBitDepthVpsPresentFlag() )
	2066	{
[713]	2067	READ_CODE( 2, uiCode, "chroma_format_vps_idc" );
[494]	2068	#if AUXILIARY_PICTURES
[713]	2069	repFormat->setChromaFormatVpsIdc( ChromaFormat(uiCode) );
[540]	2070	#else
[713]	2071	repFormat->setChromaFormatVpsIdc( uiCode );
[540]	2072	#endif
	2073
	2074	if( repFormat->getChromaFormatVpsIdc() == 3 )
	2075	{
[713]	2076	READ_FLAG( uiCode, "separate_colour_plane_vps_flag" ); repFormat->setSeparateColourPlaneVpsFlag( uiCode ? true : false );
[540]	2077	}
	2078
[713]	2079	READ_CODE( 4, uiCode, "bit_depth_vps_luma_minus8" ); repFormat->setBitDepthVpsLuma ( uiCode + 8 );
	2080	READ_CODE( 4, uiCode, "bit_depth_vps_chroma_minus8" ); repFormat->setBitDepthVpsChroma( uiCode + 8 );
	2081	}
	2082	else if( repFormatPrev )
	2083	{
	2084	// chroma_and_bit_depth_vps_present_flag equal to 0 specifies that the syntax elements, chroma_format_vps_idc, separate_colour_plane_vps_flag, bit_depth_vps_luma_minus8, and
	2085	// bit_depth_vps_chroma_minus8 are not present and inferred from the previous rep_format( ) syntax structure in the VPS.
[540]	2086
[713]	2087	repFormat->setChromaFormatVpsIdc ( repFormatPrev->getChromaFormatVpsIdc() );
	2088	repFormat->setSeparateColourPlaneVpsFlag( repFormatPrev->getSeparateColourPlaneVpsFlag() );
	2089	repFormat->setBitDepthVpsLuma ( repFormatPrev->getBitDepthVpsLuma() );
	2090	repFormat->setBitDepthVpsChroma ( repFormatPrev->getBitDepthVpsChroma() );
[540]	2091	}
[869]	2092
[540]	2093	#else
	2094	#if AUXILIARY_PICTURES
[494]	2095	READ_CODE( 2, uiCode, "chroma_format_idc" ); repFormat->setChromaFormatVpsIdc( ChromaFormat(uiCode) );
	2096	#else
[442]	2097	READ_CODE( 2, uiCode, "chroma_format_idc" ); repFormat->setChromaFormatVpsIdc( uiCode );
[494]	2098	#endif
[825]	2099
[442]	2100	if( repFormat->getChromaFormatVpsIdc() == 3 )
	2101	{
	2102	READ_FLAG( uiCode, "separate_colour_plane_flag"); repFormat->setSeparateColourPlaneVpsFlag(uiCode ? true : false);
	2103	}
[313]	2104
[442]	2105	READ_CODE ( 16, uiCode, "pic_width_in_luma_samples" ); repFormat->setPicWidthVpsInLumaSamples ( uiCode );
	2106	READ_CODE ( 16, uiCode, "pic_height_in_luma_samples" ); repFormat->setPicHeightVpsInLumaSamples( uiCode );
[494]	2107
[442]	2108	READ_CODE( 4, uiCode, "bit_depth_luma_minus8" ); repFormat->setBitDepthVpsLuma ( uiCode + 8 );
	2109	READ_CODE( 4, uiCode, "bit_depth_chroma_minus8" ); repFormat->setBitDepthVpsChroma( uiCode + 8 );
[540]	2110	#endif
[869]	2111
	2112	#if R0156_CONF_WINDOW_IN_REP_FORMAT
	2113	READ_FLAG( uiCode, "conformance_window_vps_flag" );
	2114	if( uiCode != 0)
	2115	{
	2116	Window &conf = repFormat->getConformanceWindowVps();
	2117	READ_UVLC( uiCode, "conf_win_vps_left_offset" ); conf.setWindowLeftOffset ( uiCode );
	2118	READ_UVLC( uiCode, "conf_win_vps_right_offset" ); conf.setWindowRightOffset ( uiCode );
	2119	READ_UVLC( uiCode, "conf_win_vps_top_offset" ); conf.setWindowTopOffset ( uiCode );
	2120	READ_UVLC( uiCode, "conf_win_vps_bottom_offset" ); conf.setWindowBottomOffset( uiCode );
	2121	}
	2122	#endif
[442]	2123	}
	2124	#endif
[588]	2125	#if VPS_DPB_SIZE_TABLE
	2126	Void TDecCavlc::parseVpsDpbSizeTable( TComVPS *vps )
	2127	{
	2128	UInt uiCode;
[872]	2129	#if SUB_LAYERS_IN_LAYER_SET
	2130	vps->calculateMaxSLInLayerSets();
	2131	#else
[644]	2132	#if DPB_PARAMS_MAXTLAYERS
[815]	2133	#if BITRATE_PICRATE_SIGNALLING
[825]	2134	Int * MaxSubLayersInLayerSetMinus1 = new Int[vps->getNumLayerSets()];
	2135	for(Int i = 0; i < vps->getNumLayerSets(); i++)
[815]	2136	#else
[825]	2137	Int * MaxSubLayersInLayerSetMinus1 = new Int[vps->getNumOutputLayerSets()];
	2138	for(Int i = 1; i < vps->getNumOutputLayerSets(); i++)
[815]	2139	#endif
[825]	2140	{
	2141	UInt maxSLMinus1 = 0;
[644]	2142	#if CHANGE_NUMSUBDPB_IDX
[825]	2143	Int optLsIdx = vps->getOutputLayerSetIdx( i );
[644]	2144	#else
[825]	2145	Int optLsIdx = i;
[644]	2146	#endif
[815]	2147	#if BITRATE_PICRATE_SIGNALLING
[825]	2148	optLsIdx = i;
[815]	2149	#endif
[825]	2150	for(Int k = 0; k < vps->getNumLayersInIdList(optLsIdx); k++ ) {
	2151	Int lId = vps->getLayerSetLayerIdList(optLsIdx, k);
	2152	maxSLMinus1 = max(maxSLMinus1, vps->getMaxTSLayersMinus1(vps->getLayerIdInVps(lId)));
	2153	}
	2154	MaxSubLayersInLayerSetMinus1[ i ] = maxSLMinus1;
[815]	2155	#if BITRATE_PICRATE_SIGNALLING
[825]	2156	vps->setMaxSLayersInLayerSetMinus1(i,MaxSubLayersInLayerSetMinus1[ i ]);
[815]	2157	#endif
[825]	2158	}
[644]	2159	#endif
[872]	2160	#endif
[825]	2161
[588]	2162	#if !RESOLUTION_BASED_DPB
	2163	vps->deriveNumberOfSubDpbs();
	2164	#endif
	2165	for(Int i = 1; i < vps->getNumOutputLayerSets(); i++)
	2166	{
	2167	#if CHANGE_NUMSUBDPB_IDX
	2168	Int layerSetIdxForOutputLayerSet = vps->getOutputLayerSetIdx( i );
	2169	#endif
	2170	READ_FLAG( uiCode, "sub_layer_flag_info_present_flag[i]"); vps->setSubLayerFlagInfoPresentFlag( i, uiCode ? true : false );
[872]	2171	#if SUB_LAYERS_IN_LAYER_SET
	2172	for(Int j = 0; j <= vps->getMaxSLayersInLayerSetMinus1( layerSetIdxForOutputLayerSet ); j++)
	2173	#else
[644]	2174	#if DPB_PARAMS_MAXTLAYERS
[815]	2175	#if BITRATE_PICRATE_SIGNALLING
	2176	for(Int j = 0; j <= MaxSubLayersInLayerSetMinus1[ vps->getOutputLayerSetIdx( i ) ]; j++)
	2177	#else
[713]	2178	for(Int j = 0; j <= MaxSubLayersInLayerSetMinus1[ i ]; j++)
[815]	2179	#endif
[644]	2180	#else
	2181	for(Int j = 0; j <= vps->getMaxTLayers(); j++)
	2182	#endif
[872]	2183	#endif
[588]	2184	{
	2185	if( j > 0 && vps->getSubLayerFlagInfoPresentFlag(i) )
	2186	{
	2187	READ_FLAG( uiCode, "sub_layer_dpb_info_present_flag[i]"); vps->setSubLayerDpbInfoPresentFlag( i, j, uiCode ? true : false);
	2188	}
	2189	else
	2190	{
	2191	if( j == 0 ) // Always signal for the first sub-layer
	2192	{
	2193	vps->setSubLayerDpbInfoPresentFlag( i, j, true );
	2194	}
	2195	else // if (j != 0) && !vps->getSubLayerFlagInfoPresentFlag(i)
	2196	{
	2197	vps->setSubLayerDpbInfoPresentFlag( i, j, false );
	2198	}
	2199	}
	2200	if( vps->getSubLayerDpbInfoPresentFlag(i, j) ) // If sub-layer DPB information is present
	2201	{
	2202	#if CHANGE_NUMSUBDPB_IDX
	2203	for(Int k = 0; k < vps->getNumSubDpbs(layerSetIdxForOutputLayerSet); k++)
	2204	#else
	2205	for(Int k = 0; k < vps->getNumSubDpbs(i); k++)
	2206	#endif
	2207	{
	2208	READ_UVLC( uiCode, "max_vps_dec_pic_buffering_minus1[i][k][j]" ); vps->setMaxVpsDecPicBufferingMinus1( i, k, j, uiCode );
	2209	}
	2210	READ_UVLC( uiCode, "max_vps_num_reorder_pics[i][j]" ); vps->setMaxVpsNumReorderPics( i, j, uiCode);
	2211	#if RESOLUTION_BASED_DPB
	2212	if( vps->getNumSubDpbs(layerSetIdxForOutputLayerSet) != vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ) )
	2213	{
	2214	for(Int k = 0; k < vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ); k++)
	2215	{
	2216	READ_UVLC( uiCode, "max_vps_layer_dec_pic_buff_minus1[i][k][j]" ); vps->setMaxVpsLayerDecPicBuffMinus1( i, k, j, uiCode);
	2217	}
	2218	}
	2219	else // vps->getNumSubDpbs(layerSetIdxForOutputLayerSet) == vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet )
	2220	{
	2221	for(Int k = 0; k < vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ); k++)
	2222	{
	2223	vps->setMaxVpsLayerDecPicBuffMinus1( i, k, j, vps->getMaxVpsDecPicBufferingMinus1( i, k, j));
	2224	}
	2225	}
	2226	#endif
	2227	READ_UVLC( uiCode, "max_vps_latency_increase_plus1[i][j]" ); vps->setMaxVpsLatencyIncreasePlus1( i, j, uiCode);
	2228	}
	2229	}
[644]	2230	for(Int j = vps->getMaxTLayers(); j < MAX_TLAYER; j++)
	2231	{
	2232	vps->setSubLayerDpbInfoPresentFlag( i, j, false );
	2233	}
[588]	2234	}
[644]	2235
[872]	2236	#if !SUB_LAYERS_IN_LAYER_SET
[824]	2237	#if BITRATE_PICRATE_SIGNALLING
	2238	if( MaxSubLayersInLayerSetMinus1 )
	2239	{
	2240	delete [] MaxSubLayersInLayerSetMinus1;
	2241	}
	2242	#endif
[872]	2243	#endif
[824]	2244
[644]	2245	// Infer values when not signalled
	2246	for(Int i = 1; i < vps->getNumOutputLayerSets(); i++)
	2247	{
	2248	Int layerSetIdxForOutputLayerSet = vps->getOutputLayerSetIdx( i );
	2249	for(Int j = 0; j < MAX_TLAYER; j++)
	2250	{
	2251	if( !vps->getSubLayerDpbInfoPresentFlag(i, j) ) // If sub-layer DPB information is NOT present
	2252	{
[815]	2253	#if RESOLUTION_BASED_DPB
[644]	2254	for(Int k = 0; k < vps->getNumSubDpbs(layerSetIdxForOutputLayerSet); k++)
[815]	2255	#else
	2256	for(Int k = 0; k < vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ); k++)
	2257	#endif
[644]	2258	{
	2259	vps->setMaxVpsDecPicBufferingMinus1( i, k, j, vps->getMaxVpsDecPicBufferingMinus1( i, k, j - 1 ) );
	2260	}
	2261	vps->setMaxVpsNumReorderPics( i, j, vps->getMaxVpsNumReorderPics( i, j - 1) );
[815]	2262	#if RESOLUTION_BASED_DPB
[644]	2263	for(Int k = 0; k < vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ); k++)
	2264	{
	2265	vps->setMaxVpsLayerDecPicBuffMinus1( i, k, j, vps->getMaxVpsLayerDecPicBuffMinus1( i, k, j - 1));
	2266	}
[815]	2267	#endif
[644]	2268	vps->setMaxVpsLatencyIncreasePlus1( i, j, vps->getMaxVpsLatencyIncreasePlus1( i, j - 1 ) );
	2269	}
	2270	}
	2271	}
[588]	2272	}
	2273	#endif
[815]	2274
[442]	2275	Void TDecCavlc::parseVPSVUI(TComVPS *vps)
	2276	{
	2277	UInt i,j;
	2278	UInt uiCode;
[540]	2279	#if O0223_PICTURE_TYPES_ALIGN_FLAG
	2280	READ_FLAG(uiCode, "cross_layer_pic_type_aligned_flag" );
	2281	vps->setCrossLayerPictureTypeAlignFlag(uiCode);
	2282	if (!uiCode)
	2283	{
	2284	#endif
[494]	2285	#if IRAP_ALIGN_FLAG_IN_VPS_VUI
[540]	2286	READ_FLAG(uiCode, "cross_layer_irap_aligned_flag" );
	2287	vps->setCrossLayerIrapAlignFlag(uiCode);
[644]	2288	#if P0068_CROSS_LAYER_ALIGNED_IDR_ONLY_FOR_IRAP_FLAG
[815]	2289	if( uiCode )
[644]	2290	{
[815]	2291	READ_FLAG( uiCode, "all_layers_idr_aligned_flag" );
	2292	vps->setCrossLayerAlignedIdrOnlyFlag(uiCode);
[644]	2293	}
[494]	2294	#endif
[644]	2295	#endif
[540]	2296	#if O0223_PICTURE_TYPES_ALIGN_FLAG
	2297	}
	2298	else
	2299	{
	2300	vps->setCrossLayerIrapAlignFlag(true);
	2301	}
	2302	#endif
[815]	2303
[442]	2304	READ_FLAG( uiCode, "bit_rate_present_vps_flag" ); vps->setBitRatePresentVpsFlag( uiCode ? true : false );
	2305	READ_FLAG( uiCode, "pic_rate_present_vps_flag" ); vps->setPicRatePresentVpsFlag( uiCode ? true : false );
	2306
[889]	2307	#if SIGNALLING_BITRATE_PICRATE_FIX
	2308	if ( vps->getBitRatePresentVpsFlag() \|\| vps->getPicRatePresentVpsFlag() )
	2309	{
	2310	for( i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getNumLayerSets(); i++ )
	2311	{
	2312	for( Int j = 0; j <= vps->getMaxSLayersInLayerSetMinus1( i ); j++ )
	2313	{
	2314	if( vps->getBitRatePresentVpsFlag() )
	2315	{
	2316	READ_FLAG( uiCode, "bit_rate_present_flag[i][j]" ); vps->setBitRatePresentFlag( i, j, uiCode ? true : false );
	2317	}
	2318	if( vps->getPicRatePresentVpsFlag( ) )
	2319	{
	2320	READ_FLAG( uiCode, "pic_rate_present_flag[i][j]" ); vps->setPicRatePresentFlag( i, j, uiCode ? true : false );
	2321	}
	2322	if( vps->getBitRatePresentFlag( i, j ) )
	2323	{
	2324	READ_CODE( 16, uiCode, "avg_bit_rate" ); vps->setAvgBitRate( i, j, uiCode );
	2325	READ_CODE( 16, uiCode, "max_bit_rate" ); vps->setMaxBitRate( i, j, uiCode );
	2326	}
	2327	else
	2328	{
	2329	vps->setAvgBitRate( i, j, 0 );
	2330	vps->setMaxBitRate( i, j, 0 );
	2331	}
	2332	if( vps->getPicRatePresentFlag( i, j ) )
	2333	{
	2334	READ_CODE( 2, uiCode, "constant_pic_rate_idc" ); vps->setConstPicRateIdc( i, j, uiCode );
	2335	READ_CODE( 16, uiCode, "avg_pic_rate" ); vps->setAvgPicRate( i, j, uiCode );
	2336	}
	2337	else
	2338	{
	2339	vps->setConstPicRateIdc( i, j, 0 );
	2340	vps->setAvgPicRate( i, j, 0 );
	2341	}
	2342	}
	2343	}
	2344	}
	2345	#else
[442]	2346	Bool parseFlag = vps->getBitRatePresentVpsFlag() \|\| vps->getPicRatePresentVpsFlag();
[815]	2347
	2348	#if Q0078_ADD_LAYER_SETS
[837]	2349	#if R0227_BR_PR_ADD_LAYER_SET
	2350	for( i = 0; i < vps->getNumLayerSets(); i++ )
	2351	#else
[815]	2352	for( i = 0; i <= vps->getVpsNumLayerSetsMinus1(); i++ )
[837]	2353	#endif
[815]	2354	#else
	2355	for( i = 0; i < vps->getNumLayerSets(); i++ )
	2356	#endif
[442]	2357	{
[815]	2358	#if BITRATE_PICRATE_SIGNALLING
	2359	for( j = 0; j <= vps->getMaxSLayersInLayerSetMinus1(i); j++ )
	2360	#else
	2361	for( j = 0; j < vps->getMaxTLayers(); j++ )
	2362	#endif
[442]	2363	{
[815]	2364	if( parseFlag && vps->getBitRatePresentVpsFlag() )
[442]	2365	{
[815]	2366	READ_FLAG( uiCode, "bit_rate_present_flag[i][j]" ); vps->setBitRatePresentFlag( i, j, uiCode ? true : false );
[442]	2367	}
[815]	2368	else
	2369	{
	2370	vps->setBitRatePresentFlag( i, j, false );
	2371	}
	2372	if( parseFlag && vps->getPicRatePresentVpsFlag() )
	2373	{
	2374	READ_FLAG( uiCode, "pic_rate_present_flag[i][j]" ); vps->setPicRatePresentFlag( i, j, uiCode ? true : false );
	2375	}
	2376	else
	2377	{
	2378	vps->setPicRatePresentFlag( i, j, false );
	2379	}
	2380	if( parseFlag && vps->getBitRatePresentFlag(i, j) )
	2381	{
	2382	READ_CODE( 16, uiCode, "avg_bit_rate[i][j]" ); vps->setAvgBitRate( i, j, uiCode );
	2383	READ_CODE( 16, uiCode, "max_bit_rate[i][j]" ); vps->setMaxBitRate( i, j, uiCode );
	2384	}
	2385	else
	2386	{
	2387	vps->setAvgBitRate( i, j, 0 );
	2388	vps->setMaxBitRate( i, j, 0 );
	2389	}
	2390	if( parseFlag && vps->getPicRatePresentFlag(i, j) )
	2391	{
	2392	READ_CODE( 2 , uiCode, "constant_pic_rate_idc[i][j]" ); vps->setConstPicRateIdc( i, j, uiCode );
	2393	READ_CODE( 16, uiCode, "avg_pic_rate[i][j]" ); vps->setAvgPicRate( i, j, uiCode );
	2394	}
	2395	else
	2396	{
	2397	vps->setConstPicRateIdc( i, j, 0 );
	2398	vps->setAvgPicRate ( i, j, 0 );
	2399	}
[442]	2400	}
	2401	}
[889]	2402	#endif
[588]	2403	#if VPS_VUI_VIDEO_SIGNAL_MOVE
	2404	READ_FLAG( uiCode, "video_signal_info_idx_present_flag" ); vps->setVideoSigPresentVpsFlag( uiCode == 1 );
	2405	if (vps->getVideoSigPresentVpsFlag())
	2406	{
	2407	READ_CODE(4, uiCode, "vps_num_video_signal_info_minus1" ); vps->setNumVideoSignalInfo(uiCode + 1);
	2408	}
	2409	else
	2410	{
[839]	2411	#if VPS_VUI_VST_PARAMS
	2412	vps->setNumVideoSignalInfo(vps->getMaxLayers() - vps->getBaseLayerInternalFlag() ? 0 : 1);
	2413	#else
[588]	2414	vps->setNumVideoSignalInfo(vps->getMaxLayers());
[839]	2415	#endif
[588]	2416	}
	2417
	2418	for(i = 0; i < vps->getNumVideoSignalInfo(); i++)
	2419	{
	2420	READ_CODE(3, uiCode, "video_vps_format" ); vps->setVideoVPSFormat(i,uiCode);
	2421	READ_FLAG(uiCode, "video_full_range_vps_flag" ); vps->setVideoFullRangeVpsFlag(i,uiCode);
	2422	READ_CODE(8, uiCode, "color_primaries_vps" ); vps->setColorPrimaries(i,uiCode);
	2423	READ_CODE(8, uiCode, "transfer_characteristics_vps" ); vps->setTransCharacter(i,uiCode);
	2424	READ_CODE(8, uiCode, "matrix_coeffs_vps" );vps->setMaxtrixCoeff(i,uiCode);
	2425	}
[839]	2426	#if VPS_VUI_VST_PARAMS
	2427	if( vps->getVideoSigPresentVpsFlag() && vps->getNumVideoSignalInfo() > 1 )
	2428	{
	2429	for(i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getMaxLayers(); i++)
	2430	{
	2431	READ_CODE(4, uiCode, "vps_video_signal_info_idx" ); vps->setVideoSignalInfoIdx(i, uiCode);
	2432	}
	2433	}
	2434	else if ( !vps->getVideoSigPresentVpsFlag() )
	2435	{
	2436	for(i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getMaxLayers(); i++)
	2437	{
	2438	vps->setVideoSignalInfoIdx( i, i );
	2439	}
	2440	}
	2441	else // ( vps->getNumVideoSignalInfo() = 0 )
	2442	{
	2443	for(i = vps->getBaseLayerInternalFlag() ? 0 : 1; i < vps->getMaxLayers(); i++)
	2444	{
	2445	vps->setVideoSignalInfoIdx( i, 0 );
	2446	}
	2447	}
	2448	#else
[588]	2449	if(!vps->getVideoSigPresentVpsFlag())
	2450	{
	2451	for (i=0; i < vps->getMaxLayers(); i++)
	2452	{
	2453	vps->setVideoSignalInfoIdx(i,i);
	2454	}
	2455	}
	2456	else {
	2457	vps->setVideoSignalInfoIdx(0,0);
	2458	if (vps->getNumVideoSignalInfo() > 1 )
	2459	{
	2460	for (i=1; i < vps->getMaxLayers(); i++)
	2461	READ_CODE(4, uiCode, "vps_video_signal_info_idx" ); vps->setVideoSignalInfoIdx(i, uiCode);
	2462	}
	2463	else {
	2464	for (i=1; i < vps->getMaxLayers(); i++)
	2465	{
	2466	vps->setVideoSignalInfoIdx(i,0);
	2467	}
	2468	}
	2469	}
[839]	2470	#endif
[588]	2471	#endif
[540]	2472	#if VPS_VUI_TILES_NOT_IN_USE__FLAG
	2473	UInt layerIdx;
	2474	READ_FLAG( uiCode, "tiles_not_in_use_flag" ); vps->setTilesNotInUseFlag(uiCode == 1);
	2475	if (!uiCode)
	2476	{
	2477	for(i = 0; i < vps->getMaxLayers(); i++)
	2478	{
	2479	READ_FLAG( uiCode, "tiles_in_use_flag[ i ]" ); vps->setTilesInUseFlag(i, (uiCode == 1));
	2480	if (uiCode)
	2481	{
	2482	READ_FLAG( uiCode, "loop_filter_not_across_tiles_flag[ i ]" ); vps->setLoopFilterNotAcrossTilesFlag(i, (uiCode == 1));
	2483	}
	2484	else
	2485	{
	2486	vps->setLoopFilterNotAcrossTilesFlag(i, false);
	2487	}
	2488	}
	2489	#endif
[815]	2490
[540]	2491	for(i = 1; i < vps->getMaxLayers(); i++)
	2492	{
	2493	for(j = 0; j < vps->getNumDirectRefLayers(vps->getLayerIdInNuh(i)); j++)
	2494	{
	2495	#if VPS_VUI_TILES_NOT_IN_USE__FLAG
	2496	layerIdx = vps->getLayerIdInVps(vps->getRefLayerId(vps->getLayerIdInNuh(i), j));
	2497	if (vps->getTilesInUseFlag(i) && vps->getTilesInUseFlag(layerIdx)) {
	2498	READ_FLAG( uiCode, "tile_boundaries_aligned_flag[i][j]" ); vps->setTileBoundariesAlignedFlag(i,j,(uiCode == 1));
	2499	}
	2500	#else
	2501	READ_FLAG( uiCode, "tile_boundaries_aligned_flag[i][j]" ); vps->setTileBoundariesAlignedFlag(i,j,(uiCode == 1));
	2502	#endif
	2503	}
	2504	}
	2505	#if VPS_VUI_TILES_NOT_IN_USE__FLAG
	2506	}
	2507	#endif
	2508	#if VPS_VUI_WPP_NOT_IN_USE__FLAG
	2509	READ_FLAG( uiCode, "wpp_not_in_use_flag" ); vps->setWppNotInUseFlag(uiCode == 1);
	2510	if (!uiCode)
[442]	2511	{
[540]	2512	for(i = 0; i < vps->getMaxLayers(); i++)
[442]	2513	{
[540]	2514	READ_FLAG( uiCode, "wpp_in_use_flag[ i ]" ); vps->setWppInUseFlag(i, (uiCode == 1));
[442]	2515	}
[494]	2516	}
	2517	#endif
[547]	2518
	2519	#if O0109_O0199_FLAGS_TO_VUI
	2520	#if M0040_ADAPTIVE_RESOLUTION_CHANGE
	2521	READ_FLAG(uiCode, "single_layer_for_non_irap_flag" ); vps->setSingleLayerForNonIrapFlag(uiCode == 1 ? true : false);
	2522	#endif
	2523	#if HIGHER_LAYER_IRAP_SKIP_FLAG
	2524	READ_FLAG(uiCode, "higher_layer_irap_skip_flag" ); vps->setHigherLayerIrapSkipFlag(uiCode == 1 ? true : false);
[713]	2525
	2526	// When single_layer_for_non_irap_flag is equal to 0, higher_layer_irap_skip_flag shall be equal to 0
	2527	if( !vps->getSingleLayerForNonIrapFlag() )
	2528	{
	2529	assert( !vps->getHigherLayerIrapSkipFlag() );
	2530	}
[547]	2531	#endif
	2532	#endif
[644]	2533	#if P0312_VERT_PHASE_ADJ
	2534	READ_FLAG( uiCode, "vps_vui_vert_phase_in_use_flag" ); vps->setVpsVuiVertPhaseInUseFlag(uiCode);
	2535	#endif
[442]	2536	#if N0160_VUI_EXT_ILP_REF
[588]	2537	READ_FLAG( uiCode, "ilp_restricted_ref_layers_flag" ); vps->setIlpRestrictedRefLayersFlag( uiCode == 1 );
	2538	if( vps->getIlpRestrictedRefLayersFlag())
[442]	2539	{
	2540	for(i = 1; i < vps->getMaxLayers(); i++)
	2541	{
	2542	for(j = 0; j < vps->getNumDirectRefLayers(vps->getLayerIdInNuh(i)); j++)
	2543	{
[494]	2544	READ_UVLC( uiCode, "min_spatial_segment_offset_plus1[i][j]" ); vps->setMinSpatialSegmentOffsetPlus1( i, j, uiCode );
	2545	if( vps->getMinSpatialSegmentOffsetPlus1(i,j ) > 0 )
	2546	{
	2547	READ_FLAG( uiCode, "ctu_based_offset_enabled_flag[i][j]"); vps->setCtuBasedOffsetEnabledFlag(i, j, uiCode == 1 );
	2548	if(vps->getCtuBasedOffsetEnabledFlag(i,j))
[442]	2549	{
[494]	2550	READ_UVLC( uiCode, "min_horizontal_ctu_offset_plus1[i][j]"); vps->setMinHorizontalCtuOffsetPlus1( i,j, uiCode );
[442]	2551	}
[494]	2552	}
	2553	}
[442]	2554	}
	2555	}
[494]	2556	#endif
[540]	2557	#if VPS_VUI_VIDEO_SIGNAL
[588]	2558	#if VPS_VUI_VIDEO_SIGNAL_MOVE
	2559	#else
[825]	2560	READ_FLAG( uiCode, "video_signal_info_idx_present_flag" ); vps->setVideoSigPresentVpsFlag( uiCode == 1 );
	2561	if (vps->getVideoSigPresentVpsFlag())
	2562	{
	2563	READ_CODE(4, uiCode, "vps_num_video_signal_info_minus1" ); vps->setNumVideoSignalInfo(uiCode + 1);
	2564	}
	2565	else
	2566	{
	2567	vps->setNumVideoSignalInfo(vps->getMaxLayers());
	2568	}
	2569
	2570
	2571	for(i = 0; i < vps->getNumVideoSignalInfo(); i++)
	2572	{
	2573	READ_CODE(3, uiCode, "video_vps_format" ); vps->setVideoVPSFormat(i,uiCode);
	2574	READ_FLAG(uiCode, "video_full_range_vps_flag" ); vps->setVideoFullRangeVpsFlag(i,uiCode);
	2575	READ_CODE(8, uiCode, "color_primaries_vps" ); vps->setColorPrimaries(i,uiCode);
	2576	READ_CODE(8, uiCode, "transfer_characteristics_vps" ); vps->setTransCharacter(i,uiCode);
	2577	READ_CODE(8, uiCode, "matrix_coeffs_vps" );vps->setMaxtrixCoeff(i,uiCode);
	2578	}
	2579	if(!vps->getVideoSigPresentVpsFlag())
	2580	{
	2581	for (i=0; i < vps->getMaxLayers(); i++)
[540]	2582	{
[825]	2583	vps->setVideoSignalInfoIdx(i,i);
[540]	2584	}
[825]	2585	}
	2586	else {
	2587	vps->setVideoSignalInfoIdx(0,0);
	2588	if (vps->getNumVideoSignalInfo() > 1 )
[540]	2589	{
[825]	2590	for (i=1; i < vps->getMaxLayers(); i++)
	2591	READ_CODE(4, uiCode, "vps_video_signal_info_idx" ); vps->setVideoSignalInfoIdx(i, uiCode);
[540]	2592	}
	2593	else {
[825]	2594	for (i=1; i < vps->getMaxLayers(); i++)
	2595	{
	2596	vps->setVideoSignalInfoIdx(i,0);
	2597	}
[540]	2598	}
[825]	2599	}
[588]	2600	#endif
[540]	2601	#endif
[644]	2602
	2603	#if O0164_MULTI_LAYER_HRD
[825]	2604	READ_FLAG(uiCode, "vps_vui_bsp_hrd_present_flag" ); vps->setVpsVuiBspHrdPresentFlag(uiCode);
	2605	if (vps->getVpsVuiBspHrdPresentFlag())
	2606	{
[843]	2607	#if R0227_VUI_BSP_HRD_FLAG
	2608	assert (vps->getTimingInfo()->getTimingInfoPresentFlag() == 1);
	2609	#endif
[825]	2610	READ_UVLC( uiCode, "vps_num_bsp_hrd_parameters_minus1" ); vps->setVpsNumBspHrdParametersMinus1(uiCode);
	2611	vps->createBspHrdParamBuffer(vps->getVpsNumBspHrdParametersMinus1() + 1);
	2612	for( i = 0; i <= vps->getVpsNumBspHrdParametersMinus1(); i++ )
[644]	2613	{
[825]	2614	if( i > 0 )
[644]	2615	{
[825]	2616	READ_FLAG( uiCode, "bsp_cprms_present_flag[i]" ); vps->setBspCprmsPresentFlag(i, uiCode);
[644]	2617	}
[825]	2618	parseHrdParameters(vps->getBspHrd(i), i==0 ? 1 : vps->getBspCprmsPresentFlag(i), vps->getMaxTLayers()-1);
	2619	}
[815]	2620	#if Q0078_ADD_LAYER_SETS
[825]	2621	for (UInt h = 1; h <= vps->getVpsNumLayerSetsMinus1(); h++)
[815]	2622	#else
[825]	2623	for( UInt h = 1; h <= (vps->getNumLayerSets()-1); h++ )
[815]	2624	#endif
[825]	2625	{
	2626	READ_UVLC( uiCode, "num_bitstream_partitions[i]"); vps->setNumBitstreamPartitions(h, uiCode);
[815]	2627	#if HRD_BPB
[825]	2628	Int chkPart=0;
[815]	2629	#endif
[825]	2630	for( i = 0; i < vps->getNumBitstreamPartitions(h); i++ )
	2631	{
	2632	for( j = 0; j <= (vps->getMaxLayers()-1); j++ )
[644]	2633	{
[825]	2634	if( vps->getLayerIdIncludedFlag(h, j) )
[644]	2635	{
[825]	2636	READ_FLAG( uiCode, "layer_in_bsp_flag[h][i][j]" ); vps->setLayerInBspFlag(h, i, j, uiCode);
[644]	2637	}
[825]	2638	}
[815]	2639	#if HRD_BPB
[825]	2640	chkPart+=vps->getLayerInBspFlag(h, i, j);
[815]	2641	#endif
[825]	2642	}
[815]	2643	#if HRD_BPB
[825]	2644	assert(chkPart<=1);
[815]	2645	#endif
	2646	#if HRD_BPB
[825]	2647	if(vps->getNumBitstreamPartitions(h)==1)
	2648	{
	2649	Int chkPartition1=0; Int chkPartition2=0;
	2650	for( j = 0; j <= (vps->getMaxLayers()-1); j++ )
[815]	2651	{
[825]	2652	if( vps->getLayerIdIncludedFlag(h, j) )
[815]	2653	{
[825]	2654	chkPartition1+=vps->getLayerInBspFlag(h, 0, j);
	2655	chkPartition2++;
[815]	2656	}
	2657	}
[825]	2658	assert(chkPartition1!=chkPartition2);
	2659	}
[815]	2660	#endif
[825]	2661	if (vps->getNumBitstreamPartitions(h))
	2662	{
[815]	2663	#if Q0182_MULTI_LAYER_HRD_UPDATE
[825]	2664	READ_UVLC( uiCode, "num_bsp_sched_combinations_minus1[h]"); vps->setNumBspSchedCombinations(h, uiCode + 1);
[815]	2665	#else
[825]	2666	READ_UVLC( uiCode, "num_bsp_sched_combinations[h]"); vps->setNumBspSchedCombinations(h, uiCode);
[815]	2667	#endif
[825]	2668	for( i = 0; i < vps->getNumBspSchedCombinations(h); i++ )
	2669	{
	2670	for( j = 0; j < vps->getNumBitstreamPartitions(h); j++ )
[644]	2671	{
[825]	2672	READ_UVLC( uiCode, "bsp_comb_hrd_idx[h][i][j]"); vps->setBspCombHrdIdx(h, i, j, uiCode);
[815]	2673	#if HRD_BPB
[825]	2674	assert(uiCode <= vps->getVpsNumBspHrdParametersMinus1());
[815]	2675	#endif
[825]	2676
	2677	READ_UVLC( uiCode, "bsp_comb_sched_idx[h][i][j]"); vps->setBspCombSchedIdx(h, i, j, uiCode);
[815]	2678	#if HRD_BPB
[825]	2679	assert(uiCode <= vps->getBspHrdParamBufferCpbCntMinus1(uiCode,vps->getMaxTLayers()-1));
[815]	2680	#endif
[644]	2681	}
	2682	}
	2683	}
	2684	}
[825]	2685	}
[644]	2686	#endif
	2687
	2688	#if P0182_VPS_VUI_PS_FLAG
[825]	2689	for(i = 1; i < vps->getMaxLayers(); i++)
	2690	{
	2691	if (vps->getNumRefLayers(vps->getLayerIdInNuh(i)) == 0)
[644]	2692	{
[825]	2693	READ_FLAG( uiCode, "base_layer_parameter_set_compatibility_flag" );
	2694	vps->setBaseLayerPSCompatibilityFlag( i, uiCode );
[644]	2695	}
[825]	2696	else
	2697	{
	2698	vps->setBaseLayerPSCompatibilityFlag( i, 0 );
	2699	}
	2700	}
[644]	2701	#endif
[442]	2702	}
[494]	2703	#endif //SVC_EXTENSION
	2704
[313]	2705	Void TDecCavlc::parseSliceHeader (TComSlice& rpcSlice, ParameterSetManagerDecoder parameterSetManager)
	2706	{
	2707	UInt uiCode;
	2708	Int iCode;
	2709
	2710	#if ENC_DEC_TRACE
	2711	xTraceSliceHeader(rpcSlice);
	2712	#endif
	2713	TComPPS* pps = NULL;
	2714	TComSPS* sps = NULL;
	2715
	2716	UInt firstSliceSegmentInPic;
	2717	READ_FLAG( firstSliceSegmentInPic, "first_slice_segment_in_pic_flag" );
	2718	if( rpcSlice->getRapPicFlag())
	2719	{
[713]	2720	READ_FLAG( uiCode, "no_output_of_prior_pics_flag" ); //ignored -- updated already
	2721	#if SETTING_NO_OUT_PIC_PRIOR
	2722	rpcSlice->setNoOutputPriorPicsFlag(uiCode ? true : false);
[644]	2723	#else
[713]	2724	rpcSlice->setNoOutputPicPrior( false );
[644]	2725	#endif
[313]	2726	}
	2727	READ_UVLC ( uiCode, "slice_pic_parameter_set_id" ); rpcSlice->setPPSId(uiCode);
	2728	pps = parameterSetManager->getPrefetchedPPS(uiCode);
	2729	//!KS: need to add error handling code here, if PPS is not available
	2730	assert(pps!=0);
	2731	sps = parameterSetManager->getPrefetchedSPS(pps->getSPSId());
	2732	//!KS: need to add error handling code here, if SPS is not available
	2733	assert(sps!=0);
	2734	rpcSlice->setSPS(sps);
	2735	rpcSlice->setPPS(pps);
[838]	2736
	2737	#if R0227_REP_FORMAT_CONSTRAINT //Conformance checking for rep format -- rep format of current picture of current layer shall never be greater rep format defined in VPS for the current layer
	2738	TComVPS* vps = NULL;
	2739	vps = parameterSetManager->getPrefetchedVPS(sps->getVPSId());
[848]	2740	#if R0279_REP_FORMAT_INBL
	2741	if ( vps->getVpsExtensionFlag() == 1 && (rpcSlice->getLayerId() == 0 \|\| sps->getV1CompatibleSPSFlag() == 1) )
	2742	{
	2743	assert( sps->getPicWidthInLumaSamples() <= vps->getVpsRepFormat( vps->getVpsRepFormatIdx(rpcSlice->getLayerId()) )->getPicWidthVpsInLumaSamples() );
	2744	assert( sps->getPicHeightInLumaSamples() <= vps->getVpsRepFormat( vps->getVpsRepFormatIdx(rpcSlice->getLayerId()) )->getPicHeightVpsInLumaSamples() );
	2745	assert( sps->getChromaFormatIdc() <= vps->getVpsRepFormat( vps->getVpsRepFormatIdx(rpcSlice->getLayerId()) )->getChromaFormatVpsIdc() );
	2746	assert( sps->getBitDepthY() <= vps->getVpsRepFormat( vps->getVpsRepFormatIdx(rpcSlice->getLayerId()) )->getBitDepthVpsLuma() );
	2747	assert( sps->getBitDepthC() <= vps->getVpsRepFormat( vps->getVpsRepFormatIdx(rpcSlice->getLayerId()) )->getBitDepthVpsChroma() );
	2748	#else
[844]	2749	if ( rpcSlice->getLayerId() == 0 && vps->getVpsExtensionFlag() == 1 )
[838]	2750	{
	2751	assert( sps->getPicWidthInLumaSamples() <= vps->getVpsRepFormat( vps->getVpsRepFormatIdx(0) )->getPicWidthVpsInLumaSamples() );
	2752	assert( sps->getPicHeightInLumaSamples() <= vps->getVpsRepFormat( vps->getVpsRepFormatIdx(0) )->getPicHeightVpsInLumaSamples() );
	2753	assert( sps->getChromaFormatIdc() <= vps->getVpsRepFormat( vps->getVpsRepFormatIdx(0) )->getChromaFormatVpsIdc() );
	2754	assert( sps->getBitDepthY() <= vps->getVpsRepFormat( vps->getVpsRepFormatIdx(0) )->getBitDepthVpsLuma() );
	2755	assert( sps->getBitDepthC() <= vps->getVpsRepFormat( vps->getVpsRepFormatIdx(0) )->getBitDepthVpsChroma() );
[848]	2756	#endif
[838]	2757	}
[844]	2758	else if ( vps->getVpsExtensionFlag() == 1 )
[838]	2759	{
	2760	assert(vps->getVpsRepFormat( vps->getVpsRepFormatIdx(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : rpcSlice->getLayerId()))->getPicWidthVpsInLumaSamples() <= vps->getVpsRepFormat( vps->getVpsRepFormatIdx(rpcSlice->getLayerId()))->getPicWidthVpsInLumaSamples());
	2761	assert(vps->getVpsRepFormat( vps->getVpsRepFormatIdx(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : rpcSlice->getLayerId()))->getPicHeightVpsInLumaSamples() <= vps->getVpsRepFormat( vps->getVpsRepFormatIdx(rpcSlice->getLayerId()))->getPicHeightVpsInLumaSamples());
	2762	assert(vps->getVpsRepFormat( vps->getVpsRepFormatIdx(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : rpcSlice->getLayerId()))->getChromaFormatVpsIdc() <= vps->getVpsRepFormat( vps->getVpsRepFormatIdx(rpcSlice->getLayerId()))->getChromaFormatVpsIdc());
	2763	assert(vps->getVpsRepFormat( vps->getVpsRepFormatIdx(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : rpcSlice->getLayerId()))->getBitDepthVpsLuma() <= vps->getVpsRepFormat( vps->getVpsRepFormatIdx(rpcSlice->getLayerId()))->getBitDepthVpsLuma());
	2764	assert(vps->getVpsRepFormat( vps->getVpsRepFormatIdx(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : rpcSlice->getLayerId()))->getBitDepthVpsChroma() <= vps->getVpsRepFormat( vps->getVpsRepFormatIdx(rpcSlice->getLayerId()))->getBitDepthVpsChroma());
	2765	}
	2766	#endif
	2767
[313]	2768	if( pps->getDependentSliceSegmentsEnabledFlag() && ( !firstSliceSegmentInPic ))
	2769	{
	2770	READ_FLAG( uiCode, "dependent_slice_segment_flag" ); rpcSlice->setDependentSliceSegmentFlag(uiCode ? true : false);
	2771	}
	2772	else
	2773	{
	2774	rpcSlice->setDependentSliceSegmentFlag(false);
	2775	}
[442]	2776	#if REPN_FORMAT_IN_VPS
	2777	Int numCTUs = ((rpcSlice->getPicWidthInLumaSamples()+sps->getMaxCUWidth()-1)/sps->getMaxCUWidth())*((rpcSlice->getPicHeightInLumaSamples()+sps->getMaxCUHeight()-1)/sps->getMaxCUHeight());
	2778	#else
[313]	2779	Int numCTUs = ((sps->getPicWidthInLumaSamples()+sps->getMaxCUWidth()-1)/sps->getMaxCUWidth())*((sps->getPicHeightInLumaSamples()+sps->getMaxCUHeight()-1)/sps->getMaxCUHeight());
[442]	2780	#endif
[313]	2781	Int maxParts = (1<<(sps->getMaxCUDepth()<<1));
	2782	UInt sliceSegmentAddress = 0;
	2783	Int bitsSliceSegmentAddress = 0;
	2784	while(numCTUs>(1<<bitsSliceSegmentAddress))
	2785	{
	2786	bitsSliceSegmentAddress++;
	2787	}
	2788
	2789	if(!firstSliceSegmentInPic)
	2790	{
	2791	READ_CODE( bitsSliceSegmentAddress, sliceSegmentAddress, "slice_segment_address" );
	2792	}
	2793	//set uiCode to equal slice start address (or dependent slice start address)
	2794	Int startCuAddress = maxParts*sliceSegmentAddress;
	2795	rpcSlice->setSliceSegmentCurStartCUAddr( startCuAddress );
	2796	rpcSlice->setSliceSegmentCurEndCUAddr(numCTUs*maxParts);
	2797
	2798	if (rpcSlice->getDependentSliceSegmentFlag())
	2799	{
	2800	rpcSlice->setNextSlice ( false );
	2801	rpcSlice->setNextSliceSegment ( true );
	2802	}
	2803	else
	2804	{
	2805	rpcSlice->setNextSlice ( true );
	2806	rpcSlice->setNextSliceSegment ( false );
	2807
	2808	rpcSlice->setSliceCurStartCUAddr(startCuAddress);
	2809	rpcSlice->setSliceCurEndCUAddr(numCTUs*maxParts);
	2810	}
	2811
[815]	2812	#if Q0142_POC_LSB_NOT_PRESENT
	2813	#if SHM_FIX7
[825]	2814	Int iPOClsb = 0;
[815]	2815	#endif
	2816	#endif
	2817
[313]	2818	if(!rpcSlice->getDependentSliceSegmentFlag())
	2819	{
[494]	2820	#if SVC_EXTENSION
[442]	2821	#if POC_RESET_FLAG
[494]	2822	Int iBits = 0;
[442]	2823	if(rpcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits)
	2824	{
	2825	READ_FLAG(uiCode, "poc_reset_flag"); rpcSlice->setPocResetFlag( uiCode ? true : false );
	2826	iBits++;
	2827	}
	2828	if(rpcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits)
	2829	{
[588]	2830	#if DISCARDABLE_PIC_RPS
	2831	READ_FLAG(uiCode, "discardable_flag"); rpcSlice->setDiscardableFlag( uiCode ? true : false );
	2832	#else
[442]	2833	READ_FLAG(uiCode, "discardable_flag"); // ignored
[588]	2834	#endif
[442]	2835	iBits++;
	2836	}
[540]	2837	#if O0149_CROSS_LAYER_BLA_FLAG
	2838	if(rpcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits)
	2839	{
	2840	READ_FLAG(uiCode, "cross_layer_bla_flag"); rpcSlice->setCrossLayerBLAFlag( uiCode ? true : false );
	2841	iBits++;
	2842	}
	2843	#endif
[442]	2844	for (; iBits < rpcSlice->getPPS()->getNumExtraSliceHeaderBits(); iBits++)
	2845	{
	2846	READ_FLAG(uiCode, "slice_reserved_undetermined_flag[]"); // ignored
	2847	}
	2848	#else
[887]	2849	#if CROSS_LAYER_BLA_FLAG_FIX
	2850	Int iBits = 0;
	2851	if(rpcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits)
	2852	#else
[313]	2853	if(rpcSlice->getPPS()->getNumExtraSliceHeaderBits()>0)
[887]	2854	#endif
[313]	2855	{
	2856	READ_FLAG(uiCode, "discardable_flag"); // ignored
[886]	2857	#if NON_REF_NAL_TYPE_DISCARDABLE
	2858	rpcSlice->setDiscardableFlag( uiCode ? true : false );
	2859	if (uiCode)
	2860	{
	2861	assert(rpcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TRAIL_R &&
	2862	rpcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TSA_R &&
	2863	rpcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_STSA_R &&
	2864	rpcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RADL_R &&
	2865	rpcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RASL_R);
	2866	}
	2867	#endif
[887]	2868	#if CROSS_LAYER_BLA_FLAG_FIX
	2869	iBits++;
	2870	#endif
[313]	2871	}
[887]	2872	#if CROSS_LAYER_BLA_FLAG_FIX
	2873	if(rpcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits)
	2874	{
	2875	READ_FLAG(uiCode, "cross_layer_bla_flag"); rpcSlice->setCrossLayerBLAFlag( uiCode ? true : false );
	2876	iBits++;
	2877	}
	2878	for ( ; iBits < rpcSlice->getPPS()->getNumExtraSliceHeaderBits(); iBits++)
	2879	#else
[313]	2880	for (Int i = 1; i < rpcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
[887]	2881	#endif
[313]	2882	{
	2883	READ_FLAG(uiCode, "slice_reserved_undetermined_flag[]"); // ignored
	2884	}
[494]	2885	#endif
	2886	#else //SVC_EXTENSION
[313]	2887	for (Int i = 0; i < rpcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
	2888	{
	2889	READ_FLAG(uiCode, "slice_reserved_undetermined_flag[]"); // ignored
	2890	}
[494]	2891	#endif //SVC_EXTENSION
[313]	2892
	2893	READ_UVLC ( uiCode, "slice_type" ); rpcSlice->setSliceType((SliceType)uiCode);
	2894	if( pps->getOutputFlagPresentFlag() )
	2895	{
	2896	READ_FLAG( uiCode, "pic_output_flag" ); rpcSlice->setPicOutputFlag( uiCode ? true : false );
	2897	}
	2898	else
	2899	{
	2900	rpcSlice->setPicOutputFlag( true );
	2901	}
	2902	// in the first version chroma_format_idc is equal to one, thus colour_plane_id will not be present
	2903	assert (sps->getChromaFormatIdc() == 1 );
	2904	// if( separate_colour_plane_flag == 1 )
	2905	// colour_plane_id u(2)
	2906
	2907	if( rpcSlice->getIdrPicFlag() )
	2908	{
	2909	rpcSlice->setPOC(0);
	2910	TComReferencePictureSet* rps = rpcSlice->getLocalRPS();
	2911	rps->setNumberOfNegativePictures(0);
	2912	rps->setNumberOfPositivePictures(0);
	2913	rps->setNumberOfLongtermPictures(0);
	2914	rps->setNumberOfPictures(0);
	2915	rpcSlice->setRPS(rps);
	2916	}
[442]	2917	#if N0065_LAYER_POC_ALIGNMENT
[815]	2918	#if !Q0142_POC_LSB_NOT_PRESENT
[494]	2919	#if SHM_FIX7
	2920	Int iPOClsb = 0;
	2921	#endif
[815]	2922	#endif
[494]	2923	#if O0062_POC_LSB_NOT_PRESENT_FLAG
	2924	if( ( rpcSlice->getLayerId() > 0 && !rpcSlice->getVPS()->getPocLsbNotPresentFlag( rpcSlice->getVPS()->getLayerIdInVps(rpcSlice->getLayerId())) ) \|\| !rpcSlice->getIdrPicFlag())
	2925	#else
[442]	2926	if( rpcSlice->getLayerId() > 0 \|\| !rpcSlice->getIdrPicFlag() )
[494]	2927	#endif
[442]	2928	#else
[313]	2929	else
[442]	2930	#endif
[313]	2931	{
	2932	READ_CODE(sps->getBitsForPOC(), uiCode, "pic_order_cnt_lsb");
[815]	2933	#if POC_RESET_IDC_DECODER
	2934	rpcSlice->setPicOrderCntLsb( uiCode );
	2935	#endif
[494]	2936	#if SHM_FIX7
	2937	iPOClsb = uiCode;
	2938	#else
[313]	2939	Int iPOClsb = uiCode;
[494]	2940	#endif
[442]	2941	Int iPrevPOC = rpcSlice->getPrevTid0POC();
[313]	2942	Int iMaxPOClsb = 1<< sps->getBitsForPOC();
[442]	2943	Int iPrevPOClsb = iPrevPOC & (iMaxPOClsb - 1);
[313]	2944	Int iPrevPOCmsb = iPrevPOC-iPrevPOClsb;
	2945	Int iPOCmsb;
	2946	if( ( iPOClsb < iPrevPOClsb ) && ( ( iPrevPOClsb - iPOClsb ) >= ( iMaxPOClsb / 2 ) ) )
	2947	{
	2948	iPOCmsb = iPrevPOCmsb + iMaxPOClsb;
	2949	}
	2950	else if( (iPOClsb > iPrevPOClsb ) && ( (iPOClsb - iPrevPOClsb ) > ( iMaxPOClsb / 2 ) ) )
	2951	{
	2952	iPOCmsb = iPrevPOCmsb - iMaxPOClsb;
	2953	}
	2954	else
	2955	{
	2956	iPOCmsb = iPrevPOCmsb;
	2957	}
	2958	if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
	2959	\|\| rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
	2960	\|\| rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
	2961	{
	2962	// For BLA picture types, POCmsb is set to 0.
	2963	iPOCmsb = 0;
	2964	}
	2965	rpcSlice->setPOC (iPOCmsb+iPOClsb);
	2966
[442]	2967	#if N0065_LAYER_POC_ALIGNMENT
[494]	2968	#if SHM_FIX7
[825]	2969	}
[494]	2970	#endif
[815]	2971	#if POC_RESET_IDC_DECODER
[825]	2972	else
	2973	{
	2974	rpcSlice->setPicOrderCntLsb( 0 );
	2975	}
	2976	#endif
	2977	if( !rpcSlice->getIdrPicFlag() )
	2978	{
	2979	#endif
	2980	TComReferencePictureSet* rps;
	2981	rps = rpcSlice->getLocalRPS();
	2982	rpcSlice->setRPS(rps);
	2983	READ_FLAG( uiCode, "short_term_ref_pic_set_sps_flag" );
	2984	if(uiCode == 0) // use short-term reference picture set explicitly signalled in slice header
[815]	2985	{
[825]	2986	parseShortTermRefPicSet(sps,rps, sps->getRPSList()->getNumberOfReferencePictureSets());
[815]	2987	}
[825]	2988	else // use reference to short-term reference picture set in PPS
	2989	{
	2990	Int numBits = 0;
	2991	while ((1 << numBits) < rpcSlice->getSPS()->getRPSList()->getNumberOfReferencePictureSets())
[442]	2992	{
[825]	2993	numBits++;
	2994	}
	2995	if (numBits > 0)
[313]	2996	{
[825]	2997	READ_CODE( numBits, uiCode, "short_term_ref_pic_set_idx");
[313]	2998	}
[825]	2999	else
[313]	3000	{
[825]	3001	uiCode = 0;
[313]	3002	}
[825]	3003	rps = (sps->getRPSList()->getReferencePictureSet(uiCode));
	3004	}
	3005	if(sps->getLongTermRefsPresent())
	3006	{
	3007	Int offset = rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures();
	3008	UInt numOfLtrp = 0;
	3009	UInt numLtrpInSPS = 0;
	3010	if (rpcSlice->getSPS()->getNumLongTermRefPicSPS() > 0)
[313]	3011	{
[825]	3012	READ_UVLC( uiCode, "num_long_term_sps");
	3013	numLtrpInSPS = uiCode;
	3014	numOfLtrp += numLtrpInSPS;
	3015	rps->setNumberOfLongtermPictures(numOfLtrp);
	3016	}
	3017	Int bitsForLtrpInSPS = 0;
	3018	while (rpcSlice->getSPS()->getNumLongTermRefPicSPS() > (1 << bitsForLtrpInSPS))
	3019	{
	3020	bitsForLtrpInSPS++;
	3021	}
	3022	READ_UVLC( uiCode, "num_long_term_pics"); rps->setNumberOfLongtermPictures(uiCode);
	3023	numOfLtrp += uiCode;
	3024	rps->setNumberOfLongtermPictures(numOfLtrp);
	3025	Int maxPicOrderCntLSB = 1 << rpcSlice->getSPS()->getBitsForPOC();
	3026	Int prevDeltaMSB = 0, deltaPocMSBCycleLT = 0;;
	3027	for(Int j=offset+rps->getNumberOfLongtermPictures()-1, k = 0; k < numOfLtrp; j--, k++)
	3028	{
	3029	Int pocLsbLt;
	3030	if (k < numLtrpInSPS)
[313]	3031	{
[825]	3032	uiCode = 0;
	3033	if (bitsForLtrpInSPS > 0)
	3034	{
	3035	READ_CODE(bitsForLtrpInSPS, uiCode, "lt_idx_sps[i]");
	3036	}
	3037	Int usedByCurrFromSPS=rpcSlice->getSPS()->getUsedByCurrPicLtSPSFlag(uiCode);
	3038
	3039	pocLsbLt = rpcSlice->getSPS()->getLtRefPicPocLsbSps(uiCode);
	3040	rps->setUsed(j,usedByCurrFromSPS);
[313]	3041	}
[825]	3042	else
[313]	3043	{
[825]	3044	READ_CODE(rpcSlice->getSPS()->getBitsForPOC(), uiCode, "poc_lsb_lt"); pocLsbLt= uiCode;
	3045	READ_FLAG( uiCode, "used_by_curr_pic_lt_flag"); rps->setUsed(j,uiCode);
[313]	3046	}
[825]	3047	READ_FLAG(uiCode,"delta_poc_msb_present_flag");
	3048	Bool mSBPresentFlag = uiCode ? true : false;
	3049	if(mSBPresentFlag)
[313]	3050	{
[825]	3051	READ_UVLC( uiCode, "delta_poc_msb_cycle_lt[i]" );
	3052	Bool deltaFlag = false;
	3053	// First LTRP \|\| First LTRP from SH
	3054	if( (j == offset+rps->getNumberOfLongtermPictures()-1) \|\| (j == offset+(numOfLtrp-numLtrpInSPS)-1) )
[313]	3055	{
[825]	3056	deltaFlag = true;
[313]	3057	}
[825]	3058	if(deltaFlag)
	3059	{
	3060	deltaPocMSBCycleLT = uiCode;
	3061	}
[313]	3062	else
	3063	{
[825]	3064	deltaPocMSBCycleLT = uiCode + prevDeltaMSB;
[313]	3065	}
	3066
[825]	3067	Int pocLTCurr = rpcSlice->getPOC() - deltaPocMSBCycleLT * maxPicOrderCntLSB
	3068	- iPOClsb + pocLsbLt;
	3069	rps->setPOC (j, pocLTCurr);
	3070	rps->setDeltaPOC(j, - rpcSlice->getPOC() + pocLTCurr);
	3071	rps->setCheckLTMSBPresent(j,true);
	3072	}
	3073	else
	3074	{
	3075	rps->setPOC (j, pocLsbLt);
	3076	rps->setDeltaPOC(j, - rpcSlice->getPOC() + pocLsbLt);
	3077	rps->setCheckLTMSBPresent(j,false);
	3078
	3079	// reset deltaPocMSBCycleLT for first LTRP from slice header if MSB not present
	3080	if( j == offset+(numOfLtrp-numLtrpInSPS)-1 )
[313]	3081	{
[825]	3082	deltaPocMSBCycleLT = 0;
[313]	3083	}
	3084	}
[825]	3085	prevDeltaMSB = deltaPocMSBCycleLT;
[313]	3086	}
[825]	3087	offset += rps->getNumberOfLongtermPictures();
	3088	rps->setNumberOfPictures(offset);
	3089	}
[815]	3090	#if DPB_CONSTRAINTS
[825]	3091	if(rpcSlice->getVPS()->getVpsExtensionFlag()==1)
	3092	{
[815]	3093	#if Q0078_ADD_LAYER_SETS
[825]	3094	for (Int ii = 1; ii < (rpcSlice->getVPS()->getVpsNumLayerSetsMinus1() + 1); ii++) // prevent assert error when num_add_layer_sets > 0
[815]	3095	#else
[825]	3096	for (Int ii=1; ii< rpcSlice->getVPS()->getNumOutputLayerSets(); ii++ )
[815]	3097	#endif
[825]	3098	{
	3099	Int layerSetIdxForOutputLayerSet = rpcSlice->getVPS()->getOutputLayerSetIdx( ii );
	3100	Int chkAssert=0;
	3101	for(Int kk = 0; kk < rpcSlice->getVPS()->getNumLayersInIdList(layerSetIdxForOutputLayerSet); kk++)
	3102	{
	3103	if(rpcSlice->getLayerId()==rpcSlice->getVPS()->getLayerSetLayerIdList(layerSetIdxForOutputLayerSet, kk))
[815]	3104	{
[825]	3105	chkAssert=1;
[815]	3106	}
[825]	3107	}
	3108	if(chkAssert)
	3109	{
	3110	// There may be something wrong here (layer id assumed to be layer idx?)
	3111	assert(rps->getNumberOfNegativePictures() <= rpcSlice->getVPS()->getMaxVpsDecPicBufferingMinus1(ii , rpcSlice->getLayerId() , rpcSlice->getVPS()->getMaxSLayersInLayerSetMinus1(ii)));
	3112	assert(rps->getNumberOfPositivePictures() <= rpcSlice->getVPS()->getMaxVpsDecPicBufferingMinus1(ii , rpcSlice->getLayerId() , rpcSlice->getVPS()->getMaxSLayersInLayerSetMinus1(ii)) - rps->getNumberOfNegativePictures());
	3113	assert((rps->getNumberOfPositivePictures() + rps->getNumberOfNegativePictures() + rps->getNumberOfLongtermPictures()) <= rpcSlice->getVPS()->getMaxVpsDecPicBufferingMinus1(ii , rpcSlice->getLayerId() , rpcSlice->getVPS()->getMaxSLayersInLayerSetMinus1(ii)));
	3114	}
[313]	3115	}
[825]	3116
	3117
[313]	3118	}
[825]	3119	if(rpcSlice->getLayerId() == 0)
	3120	{
	3121	assert(rps->getNumberOfNegativePictures() <= rpcSlice->getSPS()->getMaxDecPicBuffering(rpcSlice->getSPS()->getMaxTLayers()-1) );
	3122	assert(rps->getNumberOfPositivePictures() <= rpcSlice->getSPS()->getMaxDecPicBuffering(rpcSlice->getSPS()->getMaxTLayers()-1) -rps->getNumberOfNegativePictures());
	3123	assert((rps->getNumberOfPositivePictures() + rps->getNumberOfNegativePictures() + rps->getNumberOfLongtermPictures()) <= rpcSlice->getSPS()->getMaxDecPicBuffering(rpcSlice->getSPS()->getMaxTLayers()-1));
	3124	}
[442]	3125	#endif
[825]	3126	if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
	3127	\|\| rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
	3128	\|\| rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
	3129	{
	3130	// In the case of BLA picture types, rps data is read from slice header but ignored
	3131	rps = rpcSlice->getLocalRPS();
	3132	rps->setNumberOfNegativePictures(0);
	3133	rps->setNumberOfPositivePictures(0);
	3134	rps->setNumberOfLongtermPictures(0);
	3135	rps->setNumberOfPictures(0);
	3136	rpcSlice->setRPS(rps);
[442]	3137	}
[825]	3138	if (rpcSlice->getSPS()->getTMVPFlagsPresent())
	3139	{
[850]	3140	#if R0226_SLICE_TMVP
	3141	READ_FLAG( uiCode, "slice_temporal_mvp_enabled_flag" );
	3142	#else
[825]	3143	READ_FLAG( uiCode, "slice_temporal_mvp_enable_flag" );
[850]	3144	#endif
[825]	3145	rpcSlice->setEnableTMVPFlag( uiCode == 1 ? true : false );
	3146	}
	3147	else
	3148	{
	3149	rpcSlice->setEnableTMVPFlag(false);
	3150	}
	3151	#if N0065_LAYER_POC_ALIGNMENT && !SHM_FIX7
	3152	}
	3153	#endif
	3154	}
[313]	3155
[442]	3156	#if SVC_EXTENSION
[825]	3157	rpcSlice->setActiveNumILRRefIdx(0);
	3158	if((rpcSlice->getLayerId() > 0) && !(rpcSlice->getVPS()->getIlpSshSignalingEnabledFlag()) && (rpcSlice->getNumILRRefIdx() > 0) )
	3159	{
	3160	READ_FLAG(uiCode,"inter_layer_pred_enabled_flag");
	3161	rpcSlice->setInterLayerPredEnabledFlag(uiCode);
	3162	if( rpcSlice->getInterLayerPredEnabledFlag())
[313]	3163	{
[825]	3164	if(rpcSlice->getNumILRRefIdx() > 1)
[313]	3165	{
[825]	3166	Int numBits = 1;
	3167	while ((1 << numBits) < rpcSlice->getNumILRRefIdx())
[313]	3168	{
[825]	3169	numBits++;
	3170	}
	3171	if( !rpcSlice->getVPS()->getMaxOneActiveRefLayerFlag())
	3172	{
	3173	READ_CODE( numBits, uiCode,"num_inter_layer_ref_pics_minus1" );
	3174	rpcSlice->setActiveNumILRRefIdx(uiCode + 1);
	3175	}
	3176	else
	3177	{
	3178	#if P0079_DERIVE_NUMACTIVE_REF_PICS
	3179	for( Int i = 0; i < rpcSlice->getNumILRRefIdx(); i++ )
[313]	3180	{
[713]	3181	#if Q0060_MAX_TID_REF_EQUAL_TO_ZERO
[825]	3182	if((rpcSlice->getVPS()->getMaxTidIlRefPicsPlus1(rpcSlice->getVPS()->getLayerIdInVps(i),rpcSlice->getLayerId()) > rpcSlice->getTLayer() \|\| rpcSlice->getTLayer()==0) &&
	3183	(rpcSlice->getVPS()->getMaxTSLayersMinus1(rpcSlice->getVPS()->getLayerIdInVps(i)) >= rpcSlice->getTLayer()) )
[713]	3184	#else
[825]	3185	if(rpcSlice->getVPS()->getMaxTidIlRefPicsPlus1(rpcSlice->getVPS()->getLayerIdInVps(i),rpcSlice->getLayerId()) > rpcSlice->getTLayer() &&
	3186	(rpcSlice->getVPS()->getMaxTSLayersMinus1(rpcSlice->getVPS()->getLayerIdInVps(i)) >= rpcSlice->getTLayer()) )
[713]	3187	#endif
[825]	3188	{
	3189	rpcSlice->setActiveNumILRRefIdx(1);
	3190	break;
[588]	3191	}
[825]	3192	}
[588]	3193	#else
[825]	3194	rpcSlice->setActiveNumILRRefIdx(1);
[588]	3195	#endif
[825]	3196	}
[815]	3197
[825]	3198	if( rpcSlice->getActiveNumILRRefIdx() == rpcSlice->getNumILRRefIdx() )
	3199	{
	3200	for( Int i = 0; i < rpcSlice->getActiveNumILRRefIdx(); i++ )
[345]	3201	{
[825]	3202	rpcSlice->setInterLayerPredLayerIdc(i,i);
[345]	3203	}
[825]	3204	}
	3205	else
	3206	{
	3207	for(Int i = 0; i < rpcSlice->getActiveNumILRRefIdx(); i++ )
[345]	3208	{
[825]	3209	READ_CODE( numBits,uiCode,"inter_layer_pred_layer_idc[i]" );
	3210	rpcSlice->setInterLayerPredLayerIdc(uiCode,i);
[313]	3211	}
	3212	}
[825]	3213	}
	3214	else
	3215	{
[540]	3216	#if O0225_TID_BASED_IL_RPS_DERIV && TSLAYERS_IL_RPS
[713]	3217	#if Q0060_MAX_TID_REF_EQUAL_TO_ZERO
[825]	3218	if((rpcSlice->getVPS()->getMaxTidIlRefPicsPlus1(0,rpcSlice->getLayerId()) > rpcSlice->getTLayer() \|\| rpcSlice->getTLayer()==0) &&
	3219	(rpcSlice->getVPS()->getMaxTSLayersMinus1(0) >= rpcSlice->getTLayer()) )
[713]	3220	#else
[825]	3221	if( (rpcSlice->getVPS()->getMaxTidIlRefPicsPlus1(0,rpcSlice->getLayerId()) > rpcSlice->getTLayer()) &&
	3222	(rpcSlice->getVPS()->getMaxTSLayersMinus1(0) >= rpcSlice->getTLayer()) )
[713]	3223	#endif
[540]	3224	{
	3225	#endif
[313]	3226	rpcSlice->setActiveNumILRRefIdx(1);
	3227	rpcSlice->setInterLayerPredLayerIdc(0,0);
[540]	3228	#if O0225_TID_BASED_IL_RPS_DERIV && TSLAYERS_IL_RPS
[313]	3229	}
[540]	3230	#endif
[313]	3231	}
	3232	}
[825]	3233	}
	3234	else if( rpcSlice->getVPS()->getIlpSshSignalingEnabledFlag() == true && (rpcSlice->getLayerId() > 0 ))
	3235	{
	3236	rpcSlice->setInterLayerPredEnabledFlag(true);
[540]	3237
	3238	#if O0225_TID_BASED_IL_RPS_DERIV && TSLAYERS_IL_RPS
[825]	3239	Int numRefLayerPics = 0;
	3240	Int i = 0;
	3241	Int refLayerPicIdc [MAX_VPS_LAYER_ID_PLUS1];
	3242	for(i = 0, numRefLayerPics = 0; i < rpcSlice->getNumILRRefIdx(); i++ )
	3243	{
[713]	3244	#if Q0060_MAX_TID_REF_EQUAL_TO_ZERO
[825]	3245	if((rpcSlice->getVPS()->getMaxTidIlRefPicsPlus1(rpcSlice->getVPS()->getLayerIdInVps(i),rpcSlice->getLayerId()) > rpcSlice->getTLayer() \|\| rpcSlice->getTLayer()==0) &&
	3246	(rpcSlice->getVPS()->getMaxTSLayersMinus1(rpcSlice->getVPS()->getLayerIdInVps(i)) >= rpcSlice->getTLayer()) )
[713]	3247	#else
[825]	3248	if(rpcSlice->getVPS()->getMaxTidIlRefPicsPlus1(rpcSlice->getVPS()->getLayerIdInVps(i),rpcSlice->getLayerId()) > rpcSlice->getTLayer() &&
	3249	(rpcSlice->getVPS()->getMaxTSLayersMinus1(rpcSlice->getVPS()->getLayerIdInVps(i)) >= rpcSlice->getTLayer()) )
[713]	3250	#endif
[825]	3251	{
	3252	refLayerPicIdc[ numRefLayerPics++ ] = i;
[540]	3253	}
[825]	3254	}
	3255	rpcSlice->setActiveNumILRRefIdx(numRefLayerPics);
	3256	for( i = 0; i < rpcSlice->getActiveNumILRRefIdx(); i++ )
	3257	{
	3258	rpcSlice->setInterLayerPredLayerIdc(refLayerPicIdc[i],i);
	3259	}
[540]	3260	#else
[825]	3261	rpcSlice->setActiveNumILRRefIdx(rpcSlice->getNumILRRefIdx());
	3262	for( Int i = 0; i < rpcSlice->getActiveNumILRRefIdx(); i++ )
	3263	{
	3264	rpcSlice->setInterLayerPredLayerIdc(i,i);
	3265	}
[540]	3266	#endif
[825]	3267	}
[644]	3268	#if P0312_VERT_PHASE_ADJ
[849]	3269	for(Int i = 0; i < rpcSlice->getActiveNumILRRefIdx(); i++ )
[644]	3270	{
[849]	3271	UInt refLayerIdc = rpcSlice->getInterLayerPredLayerIdc(i);
	3272	#if !MOVE_SCALED_OFFSET_TO_PPS
	3273	if( rpcSlice->getSPS()->getVertPhasePositionEnableFlag(refLayerIdc) )
	3274	#else
	3275	if( rpcSlice->getPPS()->getVertPhasePositionEnableFlag(refLayerIdc) )
	3276	#endif
	3277	{
	3278	READ_FLAG( uiCode, "vert_phase_position_flag" ); rpcSlice->setVertPhasePositionFlag( uiCode? true : false, refLayerIdc );
	3279	}
[825]	3280	}
[644]	3281	#endif
[815]	3282	#endif //SVC_EXTENSION
[313]	3283
[825]	3284	if(sps->getUseSAO())
	3285	{
	3286	READ_FLAG(uiCode, "slice_sao_luma_flag"); rpcSlice->setSaoEnabledFlag((Bool)uiCode);
[494]	3287	#if AUXILIARY_PICTURES
[825]	3288	ChromaFormat format;
[494]	3289	#if REPN_FORMAT_IN_VPS
[540]	3290	#if O0096_REP_FORMAT_INDEX
[825]	3291	if( sps->getLayerId() == 0 )
	3292	{
	3293	format = sps->getChromaFormatIdc();
	3294	}
	3295	else
	3296	{
	3297	format = rpcSlice->getVPS()->getVpsRepFormat( sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : rpcSlice->getVPS()->getVpsRepFormatIdx(sps->getLayerId()) )->getChromaFormatVpsIdc();
[713]	3298	#if Q0195_REP_FORMAT_CLEANUP
[825]	3299	assert( (sps->getUpdateRepFormatFlag()==false && rpcSlice->getVPS()->getVpsNumRepFormats()==1) \|\| rpcSlice->getVPS()->getVpsNumRepFormats() > 1 ); //conformance check
[713]	3300	#endif
[825]	3301	}
[540]	3302	#else
[825]	3303	if( ( sps->getLayerId() == 0 ) \|\| sps->getUpdateRepFormatFlag() )
	3304	{
	3305	format = sps->getChromaFormatIdc();
	3306	}
	3307	else
	3308	{
	3309	format = rpcSlice->getVPS()->getVpsRepFormat( rpcSlice->getVPS()->getVpsRepFormatIdx(sps->getLayerId()) )->getChromaFormatVpsIdc();
	3310	}
[540]	3311	#endif
[494]	3312	#else
[825]	3313	format = sps->getChromaFormatIdc();
[494]	3314	#endif
[825]	3315	if (format != CHROMA_400)
	3316	{
[494]	3317	#endif
[313]	3318	READ_FLAG(uiCode, "slice_sao_chroma_flag"); rpcSlice->setSaoEnabledFlagChroma((Bool)uiCode);
[494]	3319	#if AUXILIARY_PICTURES
[313]	3320	}
[825]	3321	else
[313]	3322	{
[825]	3323	rpcSlice->setSaoEnabledFlagChroma(false);
[313]	3324	}
[825]	3325	#endif
	3326	}
	3327
	3328	if (rpcSlice->getIdrPicFlag())
	3329	{
	3330	rpcSlice->setEnableTMVPFlag(false);
	3331	}
	3332	if (!rpcSlice->isIntra())
	3333	{
	3334
	3335	READ_FLAG( uiCode, "num_ref_idx_active_override_flag");
	3336	if (uiCode)
[313]	3337	{
[825]	3338	READ_UVLC (uiCode, "num_ref_idx_l0_active_minus1" ); rpcSlice->setNumRefIdx( REF_PIC_LIST_0, uiCode + 1 );
	3339	if (rpcSlice->isInterB())
[313]	3340	{
[825]	3341	READ_UVLC (uiCode, "num_ref_idx_l1_active_minus1" ); rpcSlice->setNumRefIdx( REF_PIC_LIST_1, uiCode + 1 );
[313]	3342	}
	3343	else
	3344	{
[825]	3345	rpcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
[313]	3346	}
	3347	}
[825]	3348	else
[313]	3349	{
[825]	3350	rpcSlice->setNumRefIdx(REF_PIC_LIST_0, rpcSlice->getPPS()->getNumRefIdxL0DefaultActive());
	3351	if (rpcSlice->isInterB())
[313]	3352	{
[825]	3353	rpcSlice->setNumRefIdx(REF_PIC_LIST_1, rpcSlice->getPPS()->getNumRefIdxL1DefaultActive());
[313]	3354	}
	3355	else
	3356	{
[825]	3357	rpcSlice->setNumRefIdx(REF_PIC_LIST_1,0);
[313]	3358	}
[825]	3359	}
	3360	}
	3361	// }
	3362	TComRefPicListModification* refPicListModification = rpcSlice->getRefPicListModification();
	3363	if(!rpcSlice->isIntra())
	3364	{
	3365	if( !rpcSlice->getPPS()->getListsModificationPresentFlag() \|\| rpcSlice->getNumRpsCurrTempList() <= 1 )
	3366	{
	3367	refPicListModification->setRefPicListModificationFlagL0( 0 );
	3368	}
	3369	else
	3370	{
	3371	READ_FLAG( uiCode, "ref_pic_list_modification_flag_l0" ); refPicListModification->setRefPicListModificationFlagL0( uiCode ? 1 : 0 );
	3372	}
[313]	3373
[825]	3374	if(refPicListModification->getRefPicListModificationFlagL0())
	3375	{
	3376	uiCode = 0;
	3377	Int i = 0;
	3378	Int numRpsCurrTempList0 = rpcSlice->getNumRpsCurrTempList();
	3379	if ( numRpsCurrTempList0 > 1 )
[313]	3380	{
[825]	3381	Int length = 1;
	3382	numRpsCurrTempList0 --;
	3383	while ( numRpsCurrTempList0 >>= 1)
[313]	3384	{
[825]	3385	length ++;
[313]	3386	}
[825]	3387	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
[313]	3388	{
[825]	3389	READ_CODE( length, uiCode, "list_entry_l0" );
	3390	refPicListModification->setRefPicSetIdxL0(i, uiCode );
[313]	3391	}
	3392	}
[825]	3393	else
	3394	{
	3395	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
	3396	{
	3397	refPicListModification->setRefPicSetIdxL0(i, 0 );
	3398	}
	3399	}
[313]	3400	}
[825]	3401	}
	3402	else
	3403	{
	3404	refPicListModification->setRefPicListModificationFlagL0(0);
	3405	}
	3406	if(rpcSlice->isInterB())
	3407	{
	3408	if( !rpcSlice->getPPS()->getListsModificationPresentFlag() \|\| rpcSlice->getNumRpsCurrTempList() <= 1 )
	3409	{
	3410	refPicListModification->setRefPicListModificationFlagL1( 0 );
	3411	}
[313]	3412	else
	3413	{
[825]	3414	READ_FLAG( uiCode, "ref_pic_list_modification_flag_l1" ); refPicListModification->setRefPicListModificationFlagL1( uiCode ? 1 : 0 );
[313]	3415	}
[825]	3416	if(refPicListModification->getRefPicListModificationFlagL1())
[313]	3417	{
[825]	3418	uiCode = 0;
	3419	Int i = 0;
	3420	Int numRpsCurrTempList1 = rpcSlice->getNumRpsCurrTempList();
	3421	if ( numRpsCurrTempList1 > 1 )
[313]	3422	{
[825]	3423	Int length = 1;
	3424	numRpsCurrTempList1 --;
	3425	while ( numRpsCurrTempList1 >>= 1)
	3426	{
	3427	length ++;
	3428	}
	3429	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
	3430	{
	3431	READ_CODE( length, uiCode, "list_entry_l1" );
	3432	refPicListModification->setRefPicSetIdxL1(i, uiCode );
	3433	}
[313]	3434	}
	3435	else
	3436	{
[825]	3437	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
[313]	3438	{
[825]	3439	refPicListModification->setRefPicSetIdxL1(i, 0 );
[313]	3440	}
	3441	}
	3442	}
[825]	3443	}
	3444	else
	3445	{
	3446	refPicListModification->setRefPicListModificationFlagL1(0);
	3447	}
	3448	if (rpcSlice->isInterB())
	3449	{
	3450	READ_FLAG( uiCode, "mvd_l1_zero_flag" ); rpcSlice->setMvdL1ZeroFlag( (uiCode ? true : false) );
	3451	}
	3452
	3453	rpcSlice->setCabacInitFlag( false ); // default
	3454	if(pps->getCabacInitPresentFlag() && !rpcSlice->isIntra())
	3455	{
	3456	READ_FLAG(uiCode, "cabac_init_flag");
	3457	rpcSlice->setCabacInitFlag( uiCode ? true : false );
	3458	}
	3459
	3460	if ( rpcSlice->getEnableTMVPFlag() )
	3461	{
	3462	#if SVC_EXTENSION && REF_IDX_MFM
	3463	// set motion mapping flag
	3464	rpcSlice->setMFMEnabledFlag( ( rpcSlice->getNumMotionPredRefLayers() > 0 && rpcSlice->getActiveNumILRRefIdx() && !rpcSlice->isIntra() ) ? true : false );
	3465	#endif
	3466	if ( rpcSlice->getSliceType() == B_SLICE )
[313]	3467	{
[825]	3468	READ_FLAG( uiCode, "collocated_from_l0_flag" );
	3469	rpcSlice->setColFromL0Flag(uiCode);
[313]	3470	}
[825]	3471	else
[313]	3472	{
[825]	3473	rpcSlice->setColFromL0Flag( 1 );
[313]	3474	}
	3475
[825]	3476	if ( rpcSlice->getSliceType() != I_SLICE &&
	3477	((rpcSlice->getColFromL0Flag() == 1 && rpcSlice->getNumRefIdx(REF_PIC_LIST_0) > 1)\|\|
	3478	(rpcSlice->getColFromL0Flag() == 0 && rpcSlice->getNumRefIdx(REF_PIC_LIST_1) > 1)))
[313]	3479	{
[825]	3480	READ_UVLC( uiCode, "collocated_ref_idx" );
	3481	rpcSlice->setColRefIdx(uiCode);
[313]	3482	}
[825]	3483	else
[313]	3484	{
[825]	3485	rpcSlice->setColRefIdx(0);
[313]	3486	}
[825]	3487	}
	3488	if ( (pps->getUseWP() && rpcSlice->getSliceType()==P_SLICE) \|\| (pps->getWPBiPred() && rpcSlice->getSliceType()==B_SLICE) )
	3489	{
	3490	xParsePredWeightTable(rpcSlice);
	3491	rpcSlice->initWpScaling();
	3492	}
	3493	if (!rpcSlice->isIntra())
	3494	{
	3495	READ_UVLC( uiCode, "five_minus_max_num_merge_cand");
	3496	rpcSlice->setMaxNumMergeCand(MRG_MAX_NUM_CANDS - uiCode);
	3497	}
[313]	3498
[825]	3499	READ_SVLC( iCode, "slice_qp_delta" );
	3500	rpcSlice->setSliceQp (26 + pps->getPicInitQPMinus26() + iCode);
[313]	3501
[442]	3502	#if REPN_FORMAT_IN_VPS
[494]	3503	#if O0194_DIFFERENT_BITDEPTH_EL_BL
[825]	3504	g_bitDepthYLayer[rpcSlice->getLayerId()] = rpcSlice->getBitDepthY();
	3505	g_bitDepthCLayer[rpcSlice->getLayerId()] = rpcSlice->getBitDepthC();
[494]	3506	#endif
[825]	3507	assert( rpcSlice->getSliceQp() >= -rpcSlice->getQpBDOffsetY() );
[442]	3508	#else
[825]	3509	assert( rpcSlice->getSliceQp() >= -sps->getQpBDOffsetY() );
[442]	3510	#endif
[825]	3511	assert( rpcSlice->getSliceQp() <= 51 );
[313]	3512
[825]	3513	if (rpcSlice->getPPS()->getSliceChromaQpFlag())
	3514	{
	3515	READ_SVLC( iCode, "slice_qp_delta_cb" );
	3516	rpcSlice->setSliceQpDeltaCb( iCode );
	3517	assert( rpcSlice->getSliceQpDeltaCb() >= -12 );
	3518	assert( rpcSlice->getSliceQpDeltaCb() <= 12 );
	3519	assert( (rpcSlice->getPPS()->getChromaCbQpOffset() + rpcSlice->getSliceQpDeltaCb()) >= -12 );
	3520	assert( (rpcSlice->getPPS()->getChromaCbQpOffset() + rpcSlice->getSliceQpDeltaCb()) <= 12 );
[313]	3521
[825]	3522	READ_SVLC( iCode, "slice_qp_delta_cr" );
	3523	rpcSlice->setSliceQpDeltaCr( iCode );
	3524	assert( rpcSlice->getSliceQpDeltaCr() >= -12 );
	3525	assert( rpcSlice->getSliceQpDeltaCr() <= 12 );
	3526	assert( (rpcSlice->getPPS()->getChromaCrQpOffset() + rpcSlice->getSliceQpDeltaCr()) >= -12 );
	3527	assert( (rpcSlice->getPPS()->getChromaCrQpOffset() + rpcSlice->getSliceQpDeltaCr()) <= 12 );
	3528	}
[313]	3529
[825]	3530	if (rpcSlice->getPPS()->getDeblockingFilterControlPresentFlag())
	3531	{
	3532	if(rpcSlice->getPPS()->getDeblockingFilterOverrideEnabledFlag())
[313]	3533	{
[825]	3534	READ_FLAG ( uiCode, "deblocking_filter_override_flag" ); rpcSlice->setDeblockingFilterOverrideFlag(uiCode ? true : false);
[313]	3535	}
	3536	else
	3537	{
[825]	3538	rpcSlice->setDeblockingFilterOverrideFlag(0);
[313]	3539	}
[825]	3540	if(rpcSlice->getDeblockingFilterOverrideFlag())
[313]	3541	{
[825]	3542	READ_FLAG ( uiCode, "slice_disable_deblocking_filter_flag" ); rpcSlice->setDeblockingFilterDisable(uiCode ? 1 : 0);
	3543	if(!rpcSlice->getDeblockingFilterDisable())
	3544	{
	3545	READ_SVLC( iCode, "slice_beta_offset_div2" ); rpcSlice->setDeblockingFilterBetaOffsetDiv2(iCode);
	3546	assert(rpcSlice->getDeblockingFilterBetaOffsetDiv2() >= -6 &&
	3547	rpcSlice->getDeblockingFilterBetaOffsetDiv2() <= 6);
	3548	READ_SVLC( iCode, "slice_tc_offset_div2" ); rpcSlice->setDeblockingFilterTcOffsetDiv2(iCode);
	3549	assert(rpcSlice->getDeblockingFilterTcOffsetDiv2() >= -6 &&
	3550	rpcSlice->getDeblockingFilterTcOffsetDiv2() <= 6);
	3551	}
[313]	3552	}
	3553	else
	3554	{
[825]	3555	rpcSlice->setDeblockingFilterDisable ( rpcSlice->getPPS()->getPicDisableDeblockingFilterFlag() );
	3556	rpcSlice->setDeblockingFilterBetaOffsetDiv2( rpcSlice->getPPS()->getDeblockingFilterBetaOffsetDiv2() );
	3557	rpcSlice->setDeblockingFilterTcOffsetDiv2 ( rpcSlice->getPPS()->getDeblockingFilterTcOffsetDiv2() );
[313]	3558	}
	3559	}
[825]	3560	else
	3561	{
	3562	rpcSlice->setDeblockingFilterDisable ( false );
	3563	rpcSlice->setDeblockingFilterBetaOffsetDiv2( 0 );
	3564	rpcSlice->setDeblockingFilterTcOffsetDiv2 ( 0 );
	3565	}
[313]	3566
[825]	3567	Bool isSAOEnabled = (!rpcSlice->getSPS()->getUseSAO())?(false):(rpcSlice->getSaoEnabledFlag()\|\|rpcSlice->getSaoEnabledFlagChroma());
	3568	Bool isDBFEnabled = (!rpcSlice->getDeblockingFilterDisable());
	3569
	3570	if(rpcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag() && ( isSAOEnabled \|\| isDBFEnabled ))
[313]	3571	{
[825]	3572	READ_FLAG( uiCode, "slice_loop_filter_across_slices_enabled_flag");
[313]	3573	}
	3574	else
	3575	{
[825]	3576	uiCode = rpcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag()?1:0;
[313]	3577	}
[825]	3578	rpcSlice->setLFCrossSliceBoundaryFlag( (uiCode==1)?true:false);
[313]	3579
[825]	3580	}
	3581
	3582	UInt *entryPointOffset = NULL;
	3583	UInt numEntryPointOffsets, offsetLenMinus1;
	3584	if( pps->getTilesEnabledFlag() \|\| pps->getEntropyCodingSyncEnabledFlag() )
	3585	{
	3586	READ_UVLC(numEntryPointOffsets, "num_entry_point_offsets"); rpcSlice->setNumEntryPointOffsets ( numEntryPointOffsets );
	3587	if (numEntryPointOffsets>0)
	3588	{
	3589	READ_UVLC(offsetLenMinus1, "offset_len_minus1");
	3590	}
	3591	entryPointOffset = new UInt[numEntryPointOffsets];
	3592	for (UInt idx=0; idx<numEntryPointOffsets; idx++)
	3593	{
	3594	READ_CODE(offsetLenMinus1+1, uiCode, "entry_point_offset_minus1");
	3595	entryPointOffset[ idx ] = uiCode + 1;
	3596	}
	3597	}
	3598	else
	3599	{
	3600	rpcSlice->setNumEntryPointOffsets ( 0 );
	3601	}
	3602
[644]	3603	#if POC_RESET_IDC_SIGNALLING
[825]	3604	Int sliceHeaderExtensionLength = 0;
	3605	if(pps->getSliceHeaderExtensionPresentFlag())
	3606	{
	3607	READ_UVLC( uiCode, "slice_header_extension_length"); sliceHeaderExtensionLength = uiCode;
	3608	}
	3609	else
	3610	{
	3611	sliceHeaderExtensionLength = 0;
[888]	3612	#if INFERENCE_POC_MSB_VAL_PRESENT
	3613	rpcSlice->setPocMsbValPresentFlag( false );
	3614	#endif
[825]	3615	}
	3616	UInt startBits = m_pcBitstream->getNumBitsRead(); // Start counter of # SH Extn bits
	3617	if( sliceHeaderExtensionLength > 0 )
	3618	{
	3619	if( rpcSlice->getPPS()->getPocResetInfoPresentFlag() )
[313]	3620	{
[825]	3621	READ_CODE( 2, uiCode, "poc_reset_idc"); rpcSlice->setPocResetIdc(uiCode);
[851]	3622	#if POC_RESET_RESTRICTIONS
	3623	/* The value of poc_reset_idc shall not be equal to 1 or 2 for a RASL picture, a RADL picture,
	3624	a sub-layer non-reference picture, or a picture that has TemporalId greater than 0,
	3625	or a picture that has discardable_flag equal to 1. */
	3626	if( rpcSlice->getPocResetIdc() == 1 \|\| rpcSlice->getPocResetIdc() == 2 )
	3627	{
	3628	assert( !rpcSlice->isRASL() );
	3629	assert( !rpcSlice->isRADL() );
	3630	assert( !rpcSlice->isSLNR() );
	3631	assert( rpcSlice->getTLayer() == 0 );
	3632	assert( rpcSlice->getDiscardableFlag() == 0 );
	3633	}
	3634
	3635	// The value of poc_reset_idc of a CRA or BLA picture shall be less than 3.
	3636	if( rpcSlice->getPocResetIdc() == 3)
	3637	{
	3638	assert( ! ( rpcSlice->isCRA() \|\| rpcSlice->isBLA() ) );
	3639	}
	3640	#endif
[644]	3641	}
	3642	else
	3643	{
[825]	3644	rpcSlice->setPocResetIdc( 0 );
[644]	3645	}
[825]	3646	#if Q0142_POC_LSB_NOT_PRESENT
	3647	if ( rpcSlice->getVPS()->getPocLsbNotPresentFlag(rpcSlice->getLayerId()) && iPOClsb > 0 )
[644]	3648	{
[825]	3649	assert( rpcSlice->getPocResetIdc() != 2 );
	3650	}
	3651	#endif
	3652	if( rpcSlice->getPocResetIdc() > 0 )
	3653	{
	3654	READ_CODE(6, uiCode, "poc_reset_period_id"); rpcSlice->setPocResetPeriodId(uiCode);
	3655	}
	3656	else
	3657	{
	3658
	3659	rpcSlice->setPocResetPeriodId( 0 );
	3660	}
	3661
	3662	if (rpcSlice->getPocResetIdc() == 3)
	3663	{
	3664	READ_FLAG( uiCode, "full_poc_reset_flag"); rpcSlice->setFullPocResetFlag((uiCode == 1) ? true : false);
	3665	READ_CODE(rpcSlice->getSPS()->getBitsForPOC(), uiCode,"poc_lsb_val"); rpcSlice->setPocLsbVal(uiCode);
[815]	3666	#if Q0142_POC_LSB_NOT_PRESENT
[825]	3667	if ( rpcSlice->getVPS()->getPocLsbNotPresentFlag(rpcSlice->getLayerId()) && rpcSlice->getFullPocResetFlag() )
[815]	3668	{
[825]	3669	assert( rpcSlice->getPocLsbVal() == 0 );
[815]	3670	}
	3671	#endif
[825]	3672	}
	3673
	3674	// Derive the value of PocMsbValRequiredFlag
	3675	rpcSlice->setPocMsbValRequiredFlag( rpcSlice->getCraPicFlag() \|\| rpcSlice->getBlaPicFlag()
	3676	/* \|\| related to vps_poc_lsb_aligned_flag */
	3677	);
	3678
	3679	if( !rpcSlice->getPocMsbValRequiredFlag() /* vps_poc_lsb_aligned_flag */ )
	3680	{
	3681	READ_FLAG( uiCode, "poc_msb_val_present_flag"); rpcSlice->setPocMsbValPresentFlag( uiCode ? true : false );
	3682	}
	3683	else
	3684	{
	3685	#if POC_MSB_VAL_PRESENT_FLAG_SEM
	3686	if( sliceHeaderExtensionLength == 0 )
[644]	3687	{
[825]	3688	rpcSlice->setPocMsbValPresentFlag( false );
[644]	3689	}
[825]	3690	else if( rpcSlice->getPocMsbValRequiredFlag() )
	3691	#else
	3692	if( rpcSlice->getPocMsbValRequiredFlag() )
[815]	3693	#endif
[644]	3694	{
[825]	3695	rpcSlice->setPocMsbValPresentFlag( true );
[644]	3696	}
	3697	else
	3698	{
[825]	3699	rpcSlice->setPocMsbValPresentFlag( false );
[644]	3700	}
[825]	3701	}
[644]	3702
[815]	3703	#if !POC_RESET_IDC_DECODER
[825]	3704	Int maxPocLsb = 1 << rpcSlice->getSPS()->getBitsForPOC();
[815]	3705	#endif
[825]	3706	if( rpcSlice->getPocMsbValPresentFlag() )
	3707	{
	3708	READ_UVLC( uiCode, "poc_msb_val"); rpcSlice->setPocMsbVal( uiCode );
[815]	3709
	3710	#if !POC_RESET_IDC_DECODER
[825]	3711	// Update POC of the slice based on this MSB val
	3712	Int pocLsb = rpcSlice->getPOC() % maxPocLsb;
	3713	rpcSlice->setPOC((rpcSlice->getPocMsbVal() * maxPocLsb) + pocLsb);
	3714	}
	3715	else
	3716	{
	3717	rpcSlice->setPocMsbVal( rpcSlice->getPOC() / maxPocLsb );
[815]	3718	#endif
[825]	3719	}
[644]	3720
[825]	3721	// Read remaining bits in the slice header extension.
	3722	UInt endBits = m_pcBitstream->getNumBitsRead();
	3723	Int counter = (endBits - startBits) % 8;
	3724	if( counter )
	3725	{
	3726	counter = 8 - counter;
	3727	}
[644]	3728
[825]	3729	while( counter )
	3730	{
[815]	3731	#if Q0146_SSH_EXT_DATA_BIT
[825]	3732	READ_FLAG( uiCode, "slice_segment_header_extension_data_bit" );
[815]	3733	#else
[825]	3734	READ_FLAG( uiCode, "slice_segment_header_extension_reserved_bit" ); assert( uiCode == 1 );
[815]	3735	#endif
[825]	3736	counter--;
[644]	3737	}
[825]	3738	}
[644]	3739	#else
[825]	3740	if(pps->getSliceHeaderExtensionPresentFlag())
	3741	{
	3742	READ_UVLC(uiCode,"slice_header_extension_length");
	3743	for(Int i=0; i<uiCode; i++)
[644]	3744	{
[825]	3745	UInt ignore;
	3746	READ_CODE(8,ignore,"slice_header_extension_data_byte");
	3747	}
	3748	}
	3749	#endif
	3750	m_pcBitstream->readByteAlignment();
	3751
	3752	if( pps->getTilesEnabledFlag() \|\| pps->getEntropyCodingSyncEnabledFlag() )
	3753	{
	3754	Int endOfSliceHeaderLocation = m_pcBitstream->getByteLocation();
	3755
	3756	// Adjust endOfSliceHeaderLocation to account for emulation prevention bytes in the slice segment header
	3757	for ( UInt curByteIdx = 0; curByteIdx<m_pcBitstream->numEmulationPreventionBytesRead(); curByteIdx++ )
	3758	{
	3759	if ( m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) < endOfSliceHeaderLocation )
[313]	3760	{
[825]	3761	endOfSliceHeaderLocation++;
[313]	3762	}
	3763	}
	3764
[825]	3765	Int curEntryPointOffset = 0;
	3766	Int prevEntryPointOffset = 0;
	3767	for (UInt idx=0; idx<numEntryPointOffsets; idx++)
[313]	3768	{
[825]	3769	curEntryPointOffset += entryPointOffset[ idx ];
[494]	3770
[825]	3771	Int emulationPreventionByteCount = 0;
[313]	3772	for ( UInt curByteIdx = 0; curByteIdx<m_pcBitstream->numEmulationPreventionBytesRead(); curByteIdx++ )
	3773	{
[825]	3774	if ( m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) >= ( prevEntryPointOffset + endOfSliceHeaderLocation ) &&
	3775	m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) < ( curEntryPointOffset + endOfSliceHeaderLocation ) )
[313]	3776	{
[825]	3777	emulationPreventionByteCount++;
[313]	3778	}
	3779	}
	3780
[825]	3781	entryPointOffset[ idx ] -= emulationPreventionByteCount;
	3782	prevEntryPointOffset = curEntryPointOffset;
	3783	}
[313]	3784
[825]	3785	if ( pps->getTilesEnabledFlag() )
	3786	{
	3787	rpcSlice->setTileLocationCount( numEntryPointOffsets );
[313]	3788
[825]	3789	UInt prevPos = 0;
	3790	for (Int idx=0; idx<rpcSlice->getTileLocationCount(); idx++)
	3791	{
	3792	rpcSlice->setTileLocation( idx, prevPos + entryPointOffset [ idx ] );
	3793	prevPos += entryPointOffset[ idx ];
[313]	3794	}
[825]	3795	}
	3796	else if ( pps->getEntropyCodingSyncEnabledFlag() )
	3797	{
	3798	Int numSubstreams = rpcSlice->getNumEntryPointOffsets()+1;
	3799	rpcSlice->allocSubstreamSizes(numSubstreams);
	3800	UInt *pSubstreamSizes = rpcSlice->getSubstreamSizes();
	3801	for (Int idx=0; idx<numSubstreams-1; idx++)
[313]	3802	{
[825]	3803	if ( idx < numEntryPointOffsets )
[313]	3804	{
[825]	3805	pSubstreamSizes[ idx ] = ( entryPointOffset[ idx ] << 3 ) ;
[313]	3806	}
[825]	3807	else
[313]	3808	{
[825]	3809	pSubstreamSizes[ idx ] = 0;
[313]	3810	}
	3811	}
[825]	3812	}
[313]	3813
[825]	3814	if (entryPointOffset)
	3815	{
	3816	delete [] entryPointOffset;
[313]	3817	}
[825]	3818	}
[313]	3819
[825]	3820	return;
[313]	3821	}
	3822
	3823	Void TDecCavlc::parsePTL( TComPTL *rpcPTL, Bool profilePresentFlag, Int maxNumSubLayersMinus1 )
	3824	{
	3825	UInt uiCode;
	3826	if(profilePresentFlag)
	3827	{
	3828	parseProfileTier(rpcPTL->getGeneralPTL());
	3829	}
	3830	READ_CODE( 8, uiCode, "general_level_idc" ); rpcPTL->getGeneralPTL()->setLevelIdc(uiCode);
	3831
	3832	for (Int i = 0; i < maxNumSubLayersMinus1; i++)
	3833	{
	3834	if(profilePresentFlag)
	3835	{
	3836	READ_FLAG( uiCode, "sub_layer_profile_present_flag[i]" ); rpcPTL->setSubLayerProfilePresentFlag(i, uiCode);
	3837	}
	3838	READ_FLAG( uiCode, "sub_layer_level_present_flag[i]" ); rpcPTL->setSubLayerLevelPresentFlag (i, uiCode);
	3839	}
	3840
	3841	if (maxNumSubLayersMinus1 > 0)
	3842	{
	3843	for (Int i = maxNumSubLayersMinus1; i < 8; i++)
	3844	{
	3845	READ_CODE(2, uiCode, "reserved_zero_2bits");
	3846	assert(uiCode == 0);
	3847	}
	3848	}
	3849
	3850	for(Int i = 0; i < maxNumSubLayersMinus1; i++)
	3851	{
	3852	if( profilePresentFlag && rpcPTL->getSubLayerProfilePresentFlag(i) )
	3853	{
	3854	parseProfileTier(rpcPTL->getSubLayerPTL(i));
	3855	}
	3856	if(rpcPTL->getSubLayerLevelPresentFlag(i))
	3857	{
	3858	READ_CODE( 8, uiCode, "sub_layer_level_idc[i]" ); rpcPTL->getSubLayerPTL(i)->setLevelIdc(uiCode);
	3859	}
	3860	}
	3861	}
	3862
	3863	Void TDecCavlc::parseProfileTier(ProfileTierLevel *ptl)
	3864	{
	3865	UInt uiCode;
	3866	READ_CODE(2 , uiCode, "XXX_profile_space[]"); ptl->setProfileSpace(uiCode);
	3867	READ_FLAG( uiCode, "XXX_tier_flag[]" ); ptl->setTierFlag (uiCode ? 1 : 0);
	3868	READ_CODE(5 , uiCode, "XXX_profile_idc[]" ); ptl->setProfileIdc (uiCode);
	3869	for(Int j = 0; j < 32; j++)
	3870	{
	3871	READ_FLAG( uiCode, "XXX_profile_compatibility_flag[][j]"); ptl->setProfileCompatibilityFlag(j, uiCode ? 1 : 0);
	3872	}
	3873	READ_FLAG(uiCode, "general_progressive_source_flag");
	3874	ptl->setProgressiveSourceFlag(uiCode ? true : false);
	3875
	3876	READ_FLAG(uiCode, "general_interlaced_source_flag");
	3877	ptl->setInterlacedSourceFlag(uiCode ? true : false);
	3878
	3879	READ_FLAG(uiCode, "general_non_packed_constraint_flag");
	3880	ptl->setNonPackedConstraintFlag(uiCode ? true : false);
	3881
	3882	READ_FLAG(uiCode, "general_frame_only_constraint_flag");
	3883	ptl->setFrameOnlyConstraintFlag(uiCode ? true : false);
	3884
	3885	READ_CODE(16, uiCode, "XXX_reserved_zero_44bits[0..15]");
	3886	READ_CODE(16, uiCode, "XXX_reserved_zero_44bits[16..31]");
	3887	READ_CODE(12, uiCode, "XXX_reserved_zero_44bits[32..43]");
	3888	}
	3889
	3890	Void TDecCavlc::parseTerminatingBit( UInt& ruiBit )
	3891	{
	3892	ruiBit = false;
	3893	Int iBitsLeft = m_pcBitstream->getNumBitsLeft();
	3894	if(iBitsLeft <= 8)
	3895	{
	3896	UInt uiPeekValue = m_pcBitstream->peekBits(iBitsLeft);
	3897	if (uiPeekValue == (1<<(iBitsLeft-1)))
	3898	{
	3899	ruiBit = true;
	3900	}
	3901	}
	3902	}
	3903
	3904	Void TDecCavlc::parseSkipFlag( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
	3905	{
	3906	assert(0);
	3907	}
	3908
	3909	Void TDecCavlc::parseCUTransquantBypassFlag( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
	3910	{
	3911	assert(0);
	3912	}
	3913
	3914	Void TDecCavlc::parseMVPIdx( Int& /riMVPIdx/ )
	3915	{
	3916	assert(0);
	3917	}
	3918
	3919	Void TDecCavlc::parseSplitFlag ( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
	3920	{
	3921	assert(0);
	3922	}
	3923
	3924	Void TDecCavlc::parsePartSize( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
	3925	{
	3926	assert(0);
	3927	}
	3928
	3929	Void TDecCavlc::parsePredMode( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
	3930	{
	3931	assert(0);
	3932	}
	3933
	3934	/** Parse I_PCM information.
	3935	* \param pcCU pointer to CU
	3936	* \param uiAbsPartIdx CU index
	3937	* \param uiDepth CU depth
	3938	* \returns Void
	3939	*
	3940	* If I_PCM flag indicates that the CU is I_PCM, parse its PCM alignment bits and codes.
	3941	*/
	3942	Void TDecCavlc::parseIPCMInfo( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
	3943	{
	3944	assert(0);
	3945	}
	3946
	3947	Void TDecCavlc::parseIntraDirLumaAng ( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
	3948	{
	3949	assert(0);
	3950	}
	3951
	3952	Void TDecCavlc::parseIntraDirChroma( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
	3953	{
	3954	assert(0);
	3955	}
	3956
	3957	Void TDecCavlc::parseInterDir( TComDataCU* /pcCU/, UInt& /ruiInterDir/, UInt /uiAbsPartIdx/ )
	3958	{
	3959	assert(0);
	3960	}
	3961
	3962	Void TDecCavlc::parseRefFrmIdx( TComDataCU* /pcCU/, Int& /riRefFrmIdx/, RefPicList /eRefList/ )
	3963	{
	3964	assert(0);
	3965	}
	3966
	3967	Void TDecCavlc::parseMvd( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiPartIdx/, UInt /uiDepth/, RefPicList /eRefList/ )
	3968	{
	3969	assert(0);
	3970	}
	3971
	3972	Void TDecCavlc::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	3973	{
	3974	Int qp;
	3975	Int iDQp;
	3976
	3977	xReadSvlc( iDQp );
	3978
[442]	3979	#if REPN_FORMAT_IN_VPS
	3980	Int qpBdOffsetY = pcCU->getSlice()->getQpBDOffsetY();
	3981	#else
[313]	3982	Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
[442]	3983	#endif
[313]	3984	qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+ qpBdOffsetY)) - qpBdOffsetY;
	3985
	3986	UInt uiAbsQpCUPartIdx = (uiAbsPartIdx>>((g_uiMaxCUDepth - pcCU->getSlice()->getPPS()->getMaxCuDQPDepth())<<1))<<((g_uiMaxCUDepth - pcCU->getSlice()->getPPS()->getMaxCuDQPDepth())<<1) ;
	3987	UInt uiQpCUDepth = min(uiDepth,pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()) ;
	3988
	3989	pcCU->setQPSubParts( qp, uiAbsQpCUPartIdx, uiQpCUDepth );
	3990	}
	3991
	3992	Void TDecCavlc::parseCoeffNxN( TComDataCU* /pcCU/, TCoeff* /pcCoef/, UInt /uiAbsPartIdx/, UInt /uiWidth/, UInt /uiHeight/, UInt /uiDepth/, TextType /eTType/ )
	3993	{
	3994	assert(0);
	3995	}
	3996
	3997	Void TDecCavlc::parseTransformSubdivFlag( UInt& /ruiSubdivFlag/, UInt /uiLog2TransformBlockSize/ )
	3998	{
	3999	assert(0);
	4000	}
	4001
	4002	Void TDecCavlc::parseQtCbf( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, TextType /eType/, UInt /uiTrDepth/, UInt /uiDepth/ )
	4003	{
	4004	assert(0);
	4005	}
	4006
	4007	Void TDecCavlc::parseQtRootCbf( UInt /uiAbsPartIdx/, UInt& /uiQtRootCbf/ )
	4008	{
	4009	assert(0);
	4010	}
	4011
	4012	Void TDecCavlc::parseTransformSkipFlags (TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /width/, UInt /height/, UInt /uiDepth/, TextType /eTType/)
	4013	{
	4014	assert(0);
	4015	}
	4016
	4017	Void TDecCavlc::parseMergeFlag ( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/, UInt /uiPUIdx/ )
	4018	{
	4019	assert(0);
	4020	}
	4021
	4022	Void TDecCavlc::parseMergeIndex ( TComDataCU* /pcCU/, UInt& /ruiMergeIndex/ )
	4023	{
	4024	assert(0);
	4025	}
	4026
	4027	// ====================================================================================================================
	4028	// Protected member functions
	4029	// ====================================================================================================================
	4030
	4031	/** parse explicit wp tables
	4032	* \param TComSlice* pcSlice
	4033	* \returns Void
	4034	*/
	4035	Void TDecCavlc::xParsePredWeightTable( TComSlice* pcSlice )
	4036	{
	4037	wpScalingParam *wp;
	4038	Bool bChroma = true; // color always present in HEVC ?
	4039	SliceType eSliceType = pcSlice->getSliceType();
	4040	Int iNbRef = (eSliceType == B_SLICE ) ? (2) : (1);
[494]	4041	#if SVC_EXTENSION
	4042	UInt uiLog2WeightDenomLuma = 0, uiLog2WeightDenomChroma = 0;
	4043	#else
[313]	4044	UInt uiLog2WeightDenomLuma, uiLog2WeightDenomChroma;
[494]	4045	#endif
[313]	4046	UInt uiTotalSignalledWeightFlags = 0;
	4047
	4048	Int iDeltaDenom;
[494]	4049	#if AUXILIARY_PICTURES
	4050	if (pcSlice->getChromaFormatIdc() == CHROMA_400)
	4051	{
	4052	bChroma = false;
	4053	}
	4054	#endif
[313]	4055	// decode delta_luma_log2_weight_denom :
	4056	READ_UVLC( uiLog2WeightDenomLuma, "luma_log2_weight_denom" ); // ue(v): luma_log2_weight_denom
	4057	assert( uiLog2WeightDenomLuma <= 7 );
	4058	if( bChroma )
	4059	{
	4060	READ_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" ); // se(v): delta_chroma_log2_weight_denom
	4061	assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)>=0);
	4062	assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)<=7);
	4063	uiLog2WeightDenomChroma = (UInt)(iDeltaDenom + uiLog2WeightDenomLuma);
	4064	}
	4065
	4066	for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ )
	4067	{
	4068	RefPicList eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
	4069	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
	4070	{
	4071	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
	4072
	4073	wp[0].uiLog2WeightDenom = uiLog2WeightDenomLuma;
[494]	4074	#if AUXILIARY_PICTURES
	4075	if (!bChroma)
	4076	{
	4077	wp[1].uiLog2WeightDenom = 0;
	4078	wp[2].uiLog2WeightDenom = 0;
	4079	}
	4080	else
	4081	{
	4082	#endif
[825]	4083	wp[1].uiLog2WeightDenom = uiLog2WeightDenomChroma;
	4084	wp[2].uiLog2WeightDenom = uiLog2WeightDenomChroma;
[494]	4085	#if AUXILIARY_PICTURES
	4086	}
	4087	#endif
[313]	4088
	4089	UInt uiCode;
	4090	READ_FLAG( uiCode, "luma_weight_lX_flag" ); // u(1): luma_weight_l0_flag
	4091	wp[0].bPresentFlag = ( uiCode == 1 );
	4092	uiTotalSignalledWeightFlags += wp[0].bPresentFlag;
	4093	}
	4094	if ( bChroma )
	4095	{
	4096	UInt uiCode;
	4097	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
	4098	{
	4099	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
	4100	READ_FLAG( uiCode, "chroma_weight_lX_flag" ); // u(1): chroma_weight_l0_flag
	4101	wp[1].bPresentFlag = ( uiCode == 1 );
	4102	wp[2].bPresentFlag = ( uiCode == 1 );
	4103	uiTotalSignalledWeightFlags += 2*wp[1].bPresentFlag;
	4104	}
	4105	}
	4106	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
	4107	{
	4108	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
	4109	if ( wp[0].bPresentFlag )
	4110	{
	4111	Int iDeltaWeight;
	4112	READ_SVLC( iDeltaWeight, "delta_luma_weight_lX" ); // se(v): delta_luma_weight_l0[i]
	4113	assert( iDeltaWeight >= -128 );
	4114	assert( iDeltaWeight <= 127 );
	4115	wp[0].iWeight = (iDeltaWeight + (1<<wp[0].uiLog2WeightDenom));
	4116	READ_SVLC( wp[0].iOffset, "luma_offset_lX" ); // se(v): luma_offset_l0[i]
	4117	assert( wp[0].iOffset >= -128 );
	4118	assert( wp[0].iOffset <= 127 );
	4119	}
	4120	else
	4121	{
	4122	wp[0].iWeight = (1 << wp[0].uiLog2WeightDenom);
	4123	wp[0].iOffset = 0;
	4124	}
	4125	if ( bChroma )
	4126	{
	4127	if ( wp[1].bPresentFlag )
	4128	{
	4129	for ( Int j=1 ; j<3 ; j++ )
	4130	{
	4131	Int iDeltaWeight;
	4132	READ_SVLC( iDeltaWeight, "delta_chroma_weight_lX" ); // se(v): chroma_weight_l0[i][j]
	4133	assert( iDeltaWeight >= -128 );
	4134	assert( iDeltaWeight <= 127 );
	4135	wp[j].iWeight = (iDeltaWeight + (1<<wp[1].uiLog2WeightDenom));
	4136
	4137	Int iDeltaChroma;
	4138	READ_SVLC( iDeltaChroma, "delta_chroma_offset_lX" ); // se(v): delta_chroma_offset_l0[i][j]
	4139	assert( iDeltaChroma >= -512 );
	4140	assert( iDeltaChroma <= 511 );
	4141	Int pred = ( 128 - ( ( 128*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) );
	4142	wp[j].iOffset = Clip3(-128, 127, (iDeltaChroma + pred) );
	4143	}
	4144	}
	4145	else
	4146	{
	4147	for ( Int j=1 ; j<3 ; j++ )
	4148	{
	4149	wp[j].iWeight = (1 << wp[j].uiLog2WeightDenom);
	4150	wp[j].iOffset = 0;
	4151	}
	4152	}
	4153	}
	4154	}
	4155
	4156	for ( Int iRefIdx=pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx<MAX_NUM_REF ; iRefIdx++ )
	4157	{
	4158	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
	4159
	4160	wp[0].bPresentFlag = false;
	4161	wp[1].bPresentFlag = false;
	4162	wp[2].bPresentFlag = false;
	4163	}
	4164	}
	4165	assert(uiTotalSignalledWeightFlags<=24);
	4166	}
	4167
	4168	/** decode quantization matrix
	4169	* \param scalingList quantization matrix information
	4170	*/
	4171	Void TDecCavlc::parseScalingList(TComScalingList* scalingList)
	4172	{
	4173	UInt code, sizeId, listId;
	4174	Bool scalingListPredModeFlag;
	4175	//for each size
	4176	for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
	4177	{
	4178	for(listId = 0; listId < g_scalingListNum[sizeId]; listId++)
	4179	{
	4180	READ_FLAG( code, "scaling_list_pred_mode_flag");
	4181	scalingListPredModeFlag = (code) ? true : false;
	4182	if(!scalingListPredModeFlag) //Copy Mode
	4183	{
	4184	READ_UVLC( code, "scaling_list_pred_matrix_id_delta");
	4185	scalingList->setRefMatrixId (sizeId,listId,(UInt)((Int)(listId)-(code)));
	4186	if( sizeId > SCALING_LIST_8x8 )
	4187	{
	4188	scalingList->setScalingListDC(sizeId,listId,((listId == scalingList->getRefMatrixId (sizeId,listId))? 16 :scalingList->getScalingListDC(sizeId, scalingList->getRefMatrixId (sizeId,listId))));
	4189	}
	4190	scalingList->processRefMatrix( sizeId, listId, scalingList->getRefMatrixId (sizeId,listId));
	4191
	4192	}
	4193	else //DPCM Mode
	4194	{
	4195	xDecodeScalingList(scalingList, sizeId, listId);
	4196	}
	4197	}
	4198	}
	4199
	4200	return;
	4201	}
	4202	/** decode DPCM
	4203	* \param scalingList quantization matrix information
	4204	* \param sizeId size index
	4205	* \param listId list index
	4206	*/
	4207	Void TDecCavlc::xDecodeScalingList(TComScalingList *scalingList, UInt sizeId, UInt listId)
	4208	{
	4209	Int i,coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
	4210	Int data;
	4211	Int scalingListDcCoefMinus8 = 0;
	4212	Int nextCoef = SCALING_LIST_START_VALUE;
	4213	UInt* scan = (sizeId == 0) ? g_auiSigLastScan [ SCAN_DIAG ] [ 1 ] : g_sigLastScanCG32x32;
	4214	Int *dst = scalingList->getScalingListAddress(sizeId, listId);
	4215
	4216	if( sizeId > SCALING_LIST_8x8 )
	4217	{
	4218	READ_SVLC( scalingListDcCoefMinus8, "scaling_list_dc_coef_minus8");
	4219	scalingList->setScalingListDC(sizeId,listId,scalingListDcCoefMinus8 + 8);
	4220	nextCoef = scalingList->getScalingListDC(sizeId,listId);
	4221	}
	4222
	4223	for(i = 0; i < coefNum; i++)
	4224	{
	4225	READ_SVLC( data, "scaling_list_delta_coef");
	4226	nextCoef = (nextCoef + data + 256 ) % 256;
	4227	dst[scan[i]] = nextCoef;
	4228	}
	4229	}
	4230
	4231	Bool TDecCavlc::xMoreRbspData()
	4232	{
	4233	Int bitsLeft = m_pcBitstream->getNumBitsLeft();
	4234
	4235	// if there are more than 8 bits, it cannot be rbsp_trailing_bits
	4236	if (bitsLeft > 8)
	4237	{
	4238	return true;
	4239	}
	4240
	4241	UChar lastByte = m_pcBitstream->peekBits(bitsLeft);
	4242	Int cnt = bitsLeft;
	4243
	4244	// remove trailing bits equal to zero
	4245	while ((cnt>0) && ((lastByte & 1) == 0))
	4246	{
	4247	lastByte >>= 1;
	4248	cnt--;
	4249	}
	4250	// remove bit equal to one
	4251	cnt--;
	4252
	4253	// we should not have a negative number of bits
	4254	assert (cnt>=0);
	4255
	4256	// we have more data, if cnt is not zero
	4257	return (cnt>0);
	4258	}
[540]	4259
[713]	4260	#if Q0048_CGS_3D_ASYMLUT
	4261	Void TDecCavlc::xParse3DAsymLUT( TCom3DAsymLUT * pc3DAsymLUT )
	4262	{
[825]	4263	#if R0150_CGS_SIGNAL_CONSTRAINTS
	4264	UInt uiNumRefLayersM1;
	4265	READ_UVLC( uiNumRefLayersM1 , "num_cm_ref_layers_minus1" );
	4266	assert( uiNumRefLayersM1 <= 61 );
	4267	for( UInt i = 0 ; i <= uiNumRefLayersM1 ; i++ )
	4268	{
	4269	UInt uiRefLayerId;
	4270	READ_CODE( 6 , uiRefLayerId , "cm_ref_layer_id" );
	4271	pc3DAsymLUT->addRefLayerId( uiRefLayerId );
	4272	}
	4273	#endif
[713]	4274	UInt uiCurOctantDepth , uiCurPartNumLog2 , uiInputBitDepthM8 , uiOutputBitDepthM8 , uiResQaunBit;
[826]	4275	#if R0300_CGS_RES_COEFF_CODING
	4276	UInt uiDeltaBits;
	4277	#endif
[713]	4278	READ_CODE( 2 , uiCurOctantDepth , "cm_octant_depth" );
	4279	READ_CODE( 2 , uiCurPartNumLog2 , "cm_y_part_num_log2" );
[825]	4280	#if R0150_CGS_SIGNAL_CONSTRAINTS
	4281	UInt uiChromaInputBitDepthM8 , uiChromaOutputBitDepthM8;
[882]	4282	READ_UVLC( uiInputBitDepthM8 , "cm_input_luma_bit_depth_minus8" );
	4283	READ_UVLC( uiChromaInputBitDepthM8 , "cm_input_chroma_bit_depth_minus8" );
	4284	READ_UVLC( uiOutputBitDepthM8 , "cm_output_luma_bit_depth_minus8" );
	4285	READ_UVLC( uiChromaOutputBitDepthM8 , "cm_output_chroma_bit_depth_minus8" );
[825]	4286	#else
[713]	4287	READ_CODE( 3 , uiInputBitDepthM8 , "cm_input_bit_depth_minus8" );
	4288	Int iInputBitDepthCDelta;
	4289	READ_SVLC(iInputBitDepthCDelta, "cm_input_bit_depth_chroma delta");
	4290	READ_CODE( 3 , uiOutputBitDepthM8 , "cm_output_bit_depth_minus8" );
	4291	Int iOutputBitDepthCDelta;
	4292	READ_SVLC(iOutputBitDepthCDelta, "cm_output_bit_depth_chroma_delta");
[825]	4293	#endif
[713]	4294	READ_CODE( 2 , uiResQaunBit , "cm_res_quant_bit" );
[826]	4295	#if R0300_CGS_RES_COEFF_CODING
	4296	READ_CODE( 2 , uiDeltaBits , "cm_flc_bits" );
	4297	pc3DAsymLUT->setDeltaBits(uiDeltaBits + 1);
	4298	#endif
	4299
[825]	4300	#if R0151_CGS_3D_ASYMLUT_IMPROVE
	4301	#if R0150_CGS_SIGNAL_CONSTRAINTS
	4302	Int nAdaptCThresholdU = 1 << ( uiChromaInputBitDepthM8 + 8 - 1 );
	4303	Int nAdaptCThresholdV = 1 << ( uiChromaInputBitDepthM8 + 8 - 1 );
	4304	#else
	4305	Int nAdaptCThresholdU = 1 << ( uiInputBitDepthM8 + 8 + iInputBitDepthCDelta - 1 );
	4306	Int nAdaptCThresholdV = 1 << ( uiInputBitDepthM8 + 8 + iInputBitDepthCDelta - 1 );
	4307	#endif
	4308	if( uiCurOctantDepth == 1 )
	4309	{
	4310	Int delta = 0;
	4311	READ_SVLC( delta , "cm_adapt_threshold_u_delta" );
	4312	nAdaptCThresholdU += delta;
	4313	READ_SVLC( delta , "cm_adapt_threshold_v_delta" );
	4314	nAdaptCThresholdV += delta;
	4315	}
	4316	#endif
[713]	4317	pc3DAsymLUT->destroy();
[825]	4318	pc3DAsymLUT->create( uiCurOctantDepth , uiInputBitDepthM8 + 8 ,
	4319	#if R0150_CGS_SIGNAL_CONSTRAINTS
	4320	uiChromaInputBitDepthM8 + 8 ,
	4321	#else
	4322	uiInputBitDepthM8 + 8 + iInputBitDepthCDelta,
	4323	#endif
	4324	uiOutputBitDepthM8 + 8 ,
	4325	#if R0150_CGS_SIGNAL_CONSTRAINTS
	4326	uiChromaOutputBitDepthM8 + 8 ,
	4327	#else
	4328	uiOutputBitDepthM8 + 8 + iOutputBitDepthCDelta ,
	4329	#endif
	4330	uiCurPartNumLog2
	4331	#if R0151_CGS_3D_ASYMLUT_IMPROVE
	4332	, nAdaptCThresholdU , nAdaptCThresholdV
	4333	#endif
	4334	);
[713]	4335	pc3DAsymLUT->setResQuantBit( uiResQaunBit );
	4336
[852]	4337	#if R0164_CGS_LUT_BUGFIX_CHECK
[825]	4338	pc3DAsymLUT->xInitCuboids();
	4339	#endif
[713]	4340	xParse3DAsymLUTOctant( pc3DAsymLUT , 0 , 0 , 0 , 0 , 1 << pc3DAsymLUT->getCurOctantDepth() );
[825]	4341	#if R0164_CGS_LUT_BUGFIX
[852]	4342	#if R0164_CGS_LUT_BUGFIX_CHECK
	4343	printf("============= Before 'xCuboidsFilledCheck()': ================\n");
	4344	pc3DAsymLUT->display();
	4345	pc3DAsymLUT->xCuboidsFilledCheck( false );
	4346	printf("============= After 'xCuboidsFilledCheck()': =================\n");
	4347	pc3DAsymLUT->display();
[825]	4348	#endif
[852]	4349	#endif
[713]	4350	}
	4351
	4352	Void TDecCavlc::xParse3DAsymLUTOctant( TCom3DAsymLUT * pc3DAsymLUT , Int nDepth , Int yIdx , Int uIdx , Int vIdx , Int nLength )
	4353	{
	4354	UInt uiOctantSplit = nDepth < pc3DAsymLUT->getCurOctantDepth();
	4355	if( nDepth < pc3DAsymLUT->getCurOctantDepth() )
	4356	READ_FLAG( uiOctantSplit , "split_octant_flag" );
	4357	Int nYPartNum = 1 << pc3DAsymLUT->getCurYPartNumLog2();
	4358	if( uiOctantSplit )
	4359	{
	4360	Int nHalfLength = nLength >> 1;
	4361	for( Int l = 0 ; l < 2 ; l++ )
	4362	{
	4363	for( Int m = 0 ; m < 2 ; m++ )
	4364	{
	4365	for( Int n = 0 ; n < 2 ; n++ )
	4366	{
	4367	xParse3DAsymLUTOctant( pc3DAsymLUT , nDepth + 1 , yIdx + l * nHalfLength * nYPartNum , uIdx + m * nHalfLength , vIdx + n * nHalfLength , nHalfLength );
	4368	}
	4369	}
	4370	}
	4371	}
	4372	else
	4373	{
[826]	4374	#if R0300_CGS_RES_COEFF_CODING
	4375	Int nFLCbits = pc3DAsymLUT->getMappingShift()-pc3DAsymLUT->getResQuantBit()-pc3DAsymLUT->getDeltaBits() ;
	4376	nFLCbits = nFLCbits >= 0 ? nFLCbits:0;
	4377	#endif
[713]	4378	for( Int l = 0 ; l < nYPartNum ; l++ )
	4379	{
[825]	4380	#if R0164_CGS_LUT_BUGFIX
[878]	4381	Int shift = pc3DAsymLUT->getCurOctantDepth() - nDepth ;
[825]	4382	#endif
[713]	4383	for( Int nVertexIdx = 0 ; nVertexIdx < 4 ; nVertexIdx++ )
	4384	{
	4385	UInt uiCodeVertex = 0;
	4386	Int deltaY = 0 , deltaU = 0 , deltaV = 0;
	4387	READ_FLAG( uiCodeVertex , "coded_vertex_flag" );
	4388	if( uiCodeVertex )
	4389	{
[825]	4390	#if R0151_CGS_3D_ASYMLUT_IMPROVE
[826]	4391	#if R0300_CGS_RES_COEFF_CODING
	4392	xReadParam( deltaY, nFLCbits );
	4393	xReadParam( deltaU, nFLCbits );
	4394	xReadParam( deltaV, nFLCbits );
	4395	#else
[825]	4396	xReadParam( deltaY );
	4397	xReadParam( deltaU );
	4398	xReadParam( deltaV );
[826]	4399	#endif
[825]	4400	#else
[713]	4401	READ_SVLC( deltaY , "resY" );
	4402	READ_SVLC( deltaU , "resU" );
	4403	READ_SVLC( deltaV , "resV" );
[825]	4404	#endif
[713]	4405	}
[825]	4406	#if R0164_CGS_LUT_BUGFIX
	4407	pc3DAsymLUT->setCuboidVertexResTree( yIdx + (l<<shift) , uIdx , vIdx , nVertexIdx , deltaY , deltaU , deltaV );
[852]	4408	for (Int m = 1; m < (1<<shift); m++) {
	4409	pc3DAsymLUT->setCuboidVertexResTree( yIdx + (l<<shift) + m , uIdx , vIdx , nVertexIdx , 0 , 0 , 0 );
	4410	#if R0164_CGS_LUT_BUGFIX_CHECK
	4411	pc3DAsymLUT->xSetFilled( yIdx + (l<<shift) + m , uIdx , vIdx );
	4412	#endif
	4413	}
[825]	4414	#else
[713]	4415	pc3DAsymLUT->setCuboidVertexResTree( yIdx + l , uIdx , vIdx , nVertexIdx , deltaY , deltaU , deltaV );
[825]	4416	#endif
[713]	4417	}
[852]	4418	#if R0164_CGS_LUT_BUGFIX_CHECK
[825]	4419	pc3DAsymLUT->xSetExplicit( yIdx + (l<<shift) , uIdx , vIdx );
	4420	#endif
[713]	4421	}
[852]	4422	#if R0164_CGS_LUT_BUGFIX
	4423	for ( Int u=0 ; u<nLength ; u++ ) {
	4424	for ( Int v=0 ; v<nLength ; v++ ) {
	4425	if ( u!=0 \|\| v!=0 ) {
	4426	for ( Int y=0 ; y<nLength*nYPartNum ; y++ ) {
	4427	for( Int nVertexIdx = 0 ; nVertexIdx < 4 ; nVertexIdx++ )
	4428	{
	4429	pc3DAsymLUT->setCuboidVertexResTree( yIdx + y , uIdx + u , vIdx + v , nVertexIdx , 0 , 0 , 0 );
	4430	#if R0164_CGS_LUT_BUGFIX_CHECK
	4431	pc3DAsymLUT->xSetFilled( yIdx + y , uIdx + u , vIdx + v );
	4432	#endif
	4433	}
	4434	}
	4435	}
	4436	}
	4437	}
	4438	#endif
[713]	4439	}
	4440	}
[825]	4441
	4442	#if R0151_CGS_3D_ASYMLUT_IMPROVE
[826]	4443	#if R0300_CGS_RES_COEFF_CODING
	4444	Void TDecCavlc::xReadParam( Int& param, Int rParam )
	4445	#else
[825]	4446	Void TDecCavlc::xReadParam( Int& param )
[826]	4447	#endif
[825]	4448	{
[826]	4449	#if !R0300_CGS_RES_COEFF_CODING
[825]	4450	const UInt rParam = 7;
[826]	4451	#endif
[825]	4452	UInt prefix;
	4453	UInt codeWord ;
	4454	UInt rSymbol;
	4455	UInt sign;
	4456
	4457	READ_UVLC( prefix, "quotient") ;
	4458	READ_CODE (rParam, codeWord, "remainder");
	4459	rSymbol = (prefix<<rParam) + codeWord;
	4460
	4461	if(rSymbol)
	4462	{
	4463	READ_FLAG(sign, "sign");
	4464	param = sign ? -(Int)(rSymbol) : (Int)(rSymbol);
	4465	}
	4466	else param = 0;
	4467	}
[713]	4468	#endif
[825]	4469	#endif
[313]	4470	//! \}
	4471

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

JCT-VC SHVC

Context navigation

source: SHVCSoftware/branches/SHM-dev/source/Lib/TLibDecoder/TDecCAVLC.cpp @ 890

Download in other formats: