Context navigation

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

Visit:

Last change on this file since 599 was 595, checked in by seregin, 11 years ago
merge with SHM-5.0-dev branch
Property svn:eol-style set to `native`
File size: 111.4 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	* All rights reserved.
8	*
9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions are met:
11	*
12	* * Redistributions of source code must retain the above copyright notice,
13	* this list of conditions and the following disclaimer.
14	* * Redistributions in binary form must reproduce the above copyright notice,
15	* this list of conditions and the following disclaimer in the documentation
16	* and/or other materials provided with the distribution.
17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18	* be used to endorse or promote products derived from this software without
19	* specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31	* THE POSSIBILITY OF SUCH DAMAGE.
32	*/
33
34	/** \file TDecCAVLC.cpp
35	\brief CAVLC decoder class
36	*/
37
38	#include "TDecCAVLC.h"
39	#include "SEIread.h"
40	#include "TDecSlice.h"
41
42	//! \ingroup TLibDecoder
43	//! \{
44
45	#if ENC_DEC_TRACE
46
47	Void xTraceSPSHeader (TComSPS *pSPS)
48	{
49	fprintf( g_hTrace, "=========== Sequence Parameter Set ID: %d ===========\n", pSPS->getSPSId() );
50	}
51
52	Void xTracePPSHeader (TComPPS *pPPS)
53	{
54	fprintf( g_hTrace, "=========== Picture Parameter Set ID: %d ===========\n", pPPS->getPPSId() );
55	}
56
57	Void xTraceSliceHeader (TComSlice *pSlice)
58	{
59	fprintf( g_hTrace, "=========== Slice ===========\n");
60	}
61
62	#endif
63
64	// ====================================================================================================================
65	// Constructor / destructor / create / destroy
66	// ====================================================================================================================
67
68	TDecCavlc::TDecCavlc()
69	{
70	}
71
72	TDecCavlc::~TDecCavlc()
73	{
74
75	}
76
77	// ====================================================================================================================
78	// Public member functions
79	// ====================================================================================================================
80
81	void TDecCavlc::parseShortTermRefPicSet( TComSPS* sps, TComReferencePictureSet* rps, Int idx )
82	{
83	UInt code;
84	UInt interRPSPred;
85	if (idx > 0)
86	{
87	READ_FLAG(interRPSPred, "inter_ref_pic_set_prediction_flag"); rps->setInterRPSPrediction(interRPSPred);
88	}
89	else
90	{
91	interRPSPred = false;
92	rps->setInterRPSPrediction(false);
93	}
94
95	if (interRPSPred)
96	{
97	UInt bit;
98	if(idx == sps->getRPSList()->getNumberOfReferencePictureSets())
99	{
100	READ_UVLC(code, "delta_idx_minus1" ); // delta index of the Reference Picture Set used for prediction minus 1
101	}
102	else
103	{
104	code = 0;
105	}
106	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
107	Int rIdx = idx - 1 - code;
108	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
109	TComReferencePictureSet* rpsRef = sps->getRPSList()->getReferencePictureSet(rIdx);
110	Int k = 0, k0 = 0, k1 = 0;
111	READ_CODE(1, bit, "delta_rps_sign"); // delta_RPS_sign
112	READ_UVLC(code, "abs_delta_rps_minus1"); // absolute delta RPS minus 1
113	Int deltaRPS = (1 - 2 * bit) * (code + 1); // delta_RPS
114	for(Int j=0 ; j <= rpsRef->getNumberOfPictures(); j++)
115	{
116	READ_CODE(1, bit, "used_by_curr_pic_flag" ); //first bit is "1" if Idc is 1
117	Int refIdc = bit;
118	if (refIdc == 0)
119	{
120	READ_CODE(1, bit, "use_delta_flag" ); //second bit is "1" if Idc is 2, "0" otherwise.
121	refIdc = bit<<1; //second bit is "1" if refIdc is 2, "0" if refIdc = 0.
122	}
123	if (refIdc == 1 \|\| refIdc == 2)
124	{
125	Int deltaPOC = deltaRPS + ((j < rpsRef->getNumberOfPictures())? rpsRef->getDeltaPOC(j) : 0);
126	rps->setDeltaPOC(k, deltaPOC);
127	rps->setUsed(k, (refIdc == 1));
128
129	if (deltaPOC < 0)
130	{
131	k0++;
132	}
133	else
134	{
135	k1++;
136	}
137	k++;
138	}
139	rps->setRefIdc(j,refIdc);
140	}
141	rps->setNumRefIdc(rpsRef->getNumberOfPictures()+1);
142	rps->setNumberOfPictures(k);
143	rps->setNumberOfNegativePictures(k0);
144	rps->setNumberOfPositivePictures(k1);
145	rps->sortDeltaPOC();
146	}
147	else
148	{
149	READ_UVLC(code, "num_negative_pics"); rps->setNumberOfNegativePictures(code);
150	READ_UVLC(code, "num_positive_pics"); rps->setNumberOfPositivePictures(code);
151	Int prev = 0;
152	Int poc;
153	for(Int j=0 ; j < rps->getNumberOfNegativePictures(); j++)
154	{
155	READ_UVLC(code, "delta_poc_s0_minus1");
156	poc = prev-code-1;
157	prev = poc;
158	rps->setDeltaPOC(j,poc);
159	READ_FLAG(code, "used_by_curr_pic_s0_flag"); rps->setUsed(j,code);
160	}
161	prev = 0;
162	for(Int j=rps->getNumberOfNegativePictures(); j < rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures(); j++)
163	{
164	READ_UVLC(code, "delta_poc_s1_minus1");
165	poc = prev+code+1;
166	prev = poc;
167	rps->setDeltaPOC(j,poc);
168	READ_FLAG(code, "used_by_curr_pic_s1_flag"); rps->setUsed(j,code);
169	}
170	rps->setNumberOfPictures(rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures());
171	}
172	#if PRINT_RPS_INFO
173	rps->printDeltaPOC();
174	#endif
175	}
176
177	Void TDecCavlc::parsePPS(TComPPS* pcPPS)
178	{
179	#if ENC_DEC_TRACE
180	xTracePPSHeader (pcPPS);
181	#endif
182	UInt uiCode;
183
184	Int iCode;
185
186	READ_UVLC( uiCode, "pps_pic_parameter_set_id");
187	assert(uiCode <= 63);
188	pcPPS->setPPSId (uiCode);
189
190	READ_UVLC( uiCode, "pps_seq_parameter_set_id");
191	assert(uiCode <= 15);
192	pcPPS->setSPSId (uiCode);
193
194	READ_FLAG( uiCode, "dependent_slice_segments_enabled_flag" ); pcPPS->setDependentSliceSegmentsEnabledFlag ( uiCode == 1 );
195	READ_FLAG( uiCode, "output_flag_present_flag" ); pcPPS->setOutputFlagPresentFlag( uiCode==1 );
196
197	READ_CODE(3, uiCode, "num_extra_slice_header_bits"); pcPPS->setNumExtraSliceHeaderBits(uiCode);
198	READ_FLAG ( uiCode, "sign_data_hiding_flag" ); pcPPS->setSignHideFlag( uiCode );
199
200	READ_FLAG( uiCode, "cabac_init_present_flag" ); pcPPS->setCabacInitPresentFlag( uiCode ? true : false );
201
202	READ_UVLC(uiCode, "num_ref_idx_l0_default_active_minus1");
203	assert(uiCode <= 14);
204	pcPPS->setNumRefIdxL0DefaultActive(uiCode+1);
205
206	READ_UVLC(uiCode, "num_ref_idx_l1_default_active_minus1");
207	assert(uiCode <= 14);
208	pcPPS->setNumRefIdxL1DefaultActive(uiCode+1);
209
210	READ_SVLC(iCode, "init_qp_minus26" ); pcPPS->setPicInitQPMinus26(iCode);
211	READ_FLAG( uiCode, "constrained_intra_pred_flag" ); pcPPS->setConstrainedIntraPred( uiCode ? true : false );
212	READ_FLAG( uiCode, "transform_skip_enabled_flag" );
213	pcPPS->setUseTransformSkip ( uiCode ? true : false );
214
215	READ_FLAG( uiCode, "cu_qp_delta_enabled_flag" ); pcPPS->setUseDQP( uiCode ? true : false );
216	if( pcPPS->getUseDQP() )
217	{
218	READ_UVLC( uiCode, "diff_cu_qp_delta_depth" );
219	pcPPS->setMaxCuDQPDepth( uiCode );
220	}
221	else
222	{
223	pcPPS->setMaxCuDQPDepth( 0 );
224	}
225	READ_SVLC( iCode, "pps_cb_qp_offset");
226	pcPPS->setChromaCbQpOffset(iCode);
227	assert( pcPPS->getChromaCbQpOffset() >= -12 );
228	assert( pcPPS->getChromaCbQpOffset() <= 12 );
229
230	READ_SVLC( iCode, "pps_cr_qp_offset");
231	pcPPS->setChromaCrQpOffset(iCode);
232	assert( pcPPS->getChromaCrQpOffset() >= -12 );
233	assert( pcPPS->getChromaCrQpOffset() <= 12 );
234
235	READ_FLAG( uiCode, "pps_slice_chroma_qp_offsets_present_flag" );
236	pcPPS->setSliceChromaQpFlag( uiCode ? true : false );
237
238	READ_FLAG( uiCode, "weighted_pred_flag" ); // Use of Weighting Prediction (P_SLICE)
239	pcPPS->setUseWP( uiCode==1 );
240	READ_FLAG( uiCode, "weighted_bipred_flag" ); // Use of Bi-Directional Weighting Prediction (B_SLICE)
241	pcPPS->setWPBiPred( uiCode==1 );
242
243	READ_FLAG( uiCode, "transquant_bypass_enable_flag");
244	pcPPS->setTransquantBypassEnableFlag(uiCode ? true : false);
245	READ_FLAG( uiCode, "tiles_enabled_flag" ); pcPPS->setTilesEnabledFlag ( uiCode == 1 );
246	READ_FLAG( uiCode, "entropy_coding_sync_enabled_flag" ); pcPPS->setEntropyCodingSyncEnabledFlag( uiCode == 1 );
247
248	if( pcPPS->getTilesEnabledFlag() )
249	{
250	READ_UVLC ( uiCode, "num_tile_columns_minus1" ); pcPPS->setNumColumnsMinus1( uiCode );
251	READ_UVLC ( uiCode, "num_tile_rows_minus1" ); pcPPS->setNumRowsMinus1( uiCode );
252	READ_FLAG ( uiCode, "uniform_spacing_flag" ); pcPPS->setUniformSpacingFlag( uiCode );
253
254	if( !pcPPS->getUniformSpacingFlag())
255	{
256	UInt* columnWidth = (UInt)malloc(pcPPS->getNumColumnsMinus1()sizeof(UInt));
257	for(UInt i=0; i<pcPPS->getNumColumnsMinus1(); i++)
258	{
259	READ_UVLC( uiCode, "column_width_minus1" );
260	columnWidth[i] = uiCode+1;
261	}
262	pcPPS->setColumnWidth(columnWidth);
263	free(columnWidth);
264
265	UInt* rowHeight = (UInt)malloc(pcPPS->getNumRowsMinus1()sizeof(UInt));
266	for(UInt i=0; i<pcPPS->getNumRowsMinus1(); i++)
267	{
268	READ_UVLC( uiCode, "row_height_minus1" );
269	rowHeight[i] = uiCode + 1;
270	}
271	pcPPS->setRowHeight(rowHeight);
272	free(rowHeight);
273	}
274
275	if(pcPPS->getNumColumnsMinus1() !=0 \|\| pcPPS->getNumRowsMinus1() !=0)
276	{
277	READ_FLAG ( uiCode, "loop_filter_across_tiles_enabled_flag" ); pcPPS->setLoopFilterAcrossTilesEnabledFlag( uiCode ? true : false );
278	}
279	}
280	READ_FLAG( uiCode, "loop_filter_across_slices_enabled_flag" ); pcPPS->setLoopFilterAcrossSlicesEnabledFlag( uiCode ? true : false );
281	READ_FLAG( uiCode, "deblocking_filter_control_present_flag" ); pcPPS->setDeblockingFilterControlPresentFlag( uiCode ? true : false );
282	if(pcPPS->getDeblockingFilterControlPresentFlag())
283	{
284	READ_FLAG( uiCode, "deblocking_filter_override_enabled_flag" ); pcPPS->setDeblockingFilterOverrideEnabledFlag( uiCode ? true : false );
285	READ_FLAG( uiCode, "pps_disable_deblocking_filter_flag" ); pcPPS->setPicDisableDeblockingFilterFlag(uiCode ? true : false );
286	if(!pcPPS->getPicDisableDeblockingFilterFlag())
287	{
288	READ_SVLC ( iCode, "pps_beta_offset_div2" ); pcPPS->setDeblockingFilterBetaOffsetDiv2( iCode );
289	READ_SVLC ( iCode, "pps_tc_offset_div2" ); pcPPS->setDeblockingFilterTcOffsetDiv2( iCode );
290	}
291	}
292
293	#if SCALINGLIST_INFERRING
294	if( pcPPS->getLayerId() > 0 )
295	{
296	READ_FLAG( uiCode, "pps_infer_scaling_list_flag" );
297	pcPPS->setInferScalingListFlag( uiCode );
298	}
299
300	if( pcPPS->getInferScalingListFlag() )
301	{
302	READ_UVLC( uiCode, "pps_scaling_list_ref_layer_id" ); pcPPS->setScalingListRefLayerId( uiCode );
303
304	// The value of pps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
305	assert( pcPPS->getScalingListRefLayerId() <= 62 );
306
307	pcPPS->setScalingListPresentFlag( false );
308	}
309	else
310	{
311	#endif
312
313	READ_FLAG( uiCode, "pps_scaling_list_data_present_flag" ); pcPPS->setScalingListPresentFlag( uiCode ? true : false );
314
315	if(pcPPS->getScalingListPresentFlag ())
316	{
317	parseScalingList( pcPPS->getScalingList() );
318	}
319
320	#if SCALINGLIST_INFERRING
321	}
322	#endif
323
324	READ_FLAG( uiCode, "lists_modification_present_flag");
325	pcPPS->setListsModificationPresentFlag(uiCode);
326
327	READ_UVLC( uiCode, "log2_parallel_merge_level_minus2");
328	pcPPS->setLog2ParallelMergeLevelMinus2 (uiCode);
329
330	READ_FLAG( uiCode, "slice_segment_header_extension_present_flag");
331	pcPPS->setSliceHeaderExtensionPresentFlag(uiCode);
332
333	READ_FLAG( uiCode, "pps_extension_flag");
334	if (uiCode)
335	{
336	while ( xMoreRbspData() )
337	{
338	READ_FLAG( uiCode, "pps_extension_data_flag");
339	}
340	}
341	}
342
343	Void TDecCavlc::parseVUI(TComVUI* pcVUI, TComSPS *pcSPS)
344	{
345	#if ENC_DEC_TRACE
346	fprintf( g_hTrace, "----------- vui_parameters -----------\n");
347	#endif
348	UInt uiCode;
349
350	READ_FLAG( uiCode, "aspect_ratio_info_present_flag"); pcVUI->setAspectRatioInfoPresentFlag(uiCode);
351	if (pcVUI->getAspectRatioInfoPresentFlag())
352	{
353	READ_CODE(8, uiCode, "aspect_ratio_idc"); pcVUI->setAspectRatioIdc(uiCode);
354	if (pcVUI->getAspectRatioIdc() == 255)
355	{
356	READ_CODE(16, uiCode, "sar_width"); pcVUI->setSarWidth(uiCode);
357	READ_CODE(16, uiCode, "sar_height"); pcVUI->setSarHeight(uiCode);
358	}
359	}
360
361	READ_FLAG( uiCode, "overscan_info_present_flag"); pcVUI->setOverscanInfoPresentFlag(uiCode);
362	if (pcVUI->getOverscanInfoPresentFlag())
363	{
364	READ_FLAG( uiCode, "overscan_appropriate_flag"); pcVUI->setOverscanAppropriateFlag(uiCode);
365	}
366
367	READ_FLAG( uiCode, "video_signal_type_present_flag"); pcVUI->setVideoSignalTypePresentFlag(uiCode);
368	if (pcVUI->getVideoSignalTypePresentFlag())
369	{
370	READ_CODE(3, uiCode, "video_format"); pcVUI->setVideoFormat(uiCode);
371	READ_FLAG( uiCode, "video_full_range_flag"); pcVUI->setVideoFullRangeFlag(uiCode);
372	READ_FLAG( uiCode, "colour_description_present_flag"); pcVUI->setColourDescriptionPresentFlag(uiCode);
373	if (pcVUI->getColourDescriptionPresentFlag())
374	{
375	READ_CODE(8, uiCode, "colour_primaries"); pcVUI->setColourPrimaries(uiCode);
376	READ_CODE(8, uiCode, "transfer_characteristics"); pcVUI->setTransferCharacteristics(uiCode);
377	READ_CODE(8, uiCode, "matrix_coefficients"); pcVUI->setMatrixCoefficients(uiCode);
378	}
379	}
380
381	READ_FLAG( uiCode, "chroma_loc_info_present_flag"); pcVUI->setChromaLocInfoPresentFlag(uiCode);
382	if (pcVUI->getChromaLocInfoPresentFlag())
383	{
384	READ_UVLC( uiCode, "chroma_sample_loc_type_top_field" ); pcVUI->setChromaSampleLocTypeTopField(uiCode);
385	READ_UVLC( uiCode, "chroma_sample_loc_type_bottom_field" ); pcVUI->setChromaSampleLocTypeBottomField(uiCode);
386	}
387
388	READ_FLAG( uiCode, "neutral_chroma_indication_flag"); pcVUI->setNeutralChromaIndicationFlag(uiCode);
389
390	READ_FLAG( uiCode, "field_seq_flag"); pcVUI->setFieldSeqFlag(uiCode);
391
392	READ_FLAG(uiCode, "frame_field_info_present_flag"); pcVUI->setFrameFieldInfoPresentFlag(uiCode);
393
394	READ_FLAG( uiCode, "default_display_window_flag");
395	if (uiCode != 0)
396	{
397	Window &defDisp = pcVUI->getDefaultDisplayWindow();
398	READ_UVLC( uiCode, "def_disp_win_left_offset" ); defDisp.setWindowLeftOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc()) );
399	READ_UVLC( uiCode, "def_disp_win_right_offset" ); defDisp.setWindowRightOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc()) );
400	READ_UVLC( uiCode, "def_disp_win_top_offset" ); defDisp.setWindowTopOffset ( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc()) );
401	READ_UVLC( uiCode, "def_disp_win_bottom_offset" ); defDisp.setWindowBottomOffset( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc()) );
402	}
403	TimingInfo *timingInfo = pcVUI->getTimingInfo();
404	READ_FLAG( uiCode, "vui_timing_info_present_flag"); timingInfo->setTimingInfoPresentFlag (uiCode ? true : false);
405	#if TIMING_INFO_NONZERO_LAYERID_SPS
406	if( pcSPS->getLayerId() > 0 )
407	{
408	assert( timingInfo->getTimingInfoPresentFlag() == false );
409	}
410	#endif
411	if(timingInfo->getTimingInfoPresentFlag())
412	{
413	READ_CODE( 32, uiCode, "vui_num_units_in_tick"); timingInfo->setNumUnitsInTick (uiCode);
414	READ_CODE( 32, uiCode, "vui_time_scale"); timingInfo->setTimeScale (uiCode);
415	READ_FLAG( uiCode, "vui_poc_proportional_to_timing_flag"); timingInfo->setPocProportionalToTimingFlag(uiCode ? true : false);
416	if(timingInfo->getPocProportionalToTimingFlag())
417	{
418	READ_UVLC( uiCode, "vui_num_ticks_poc_diff_one_minus1"); timingInfo->setNumTicksPocDiffOneMinus1 (uiCode);
419	}
420	READ_FLAG( uiCode, "hrd_parameters_present_flag"); pcVUI->setHrdParametersPresentFlag(uiCode);
421	if( pcVUI->getHrdParametersPresentFlag() )
422	{
423	parseHrdParameters( pcVUI->getHrdParameters(), 1, pcSPS->getMaxTLayers() - 1 );
424	}
425	}
426	READ_FLAG( uiCode, "bitstream_restriction_flag"); pcVUI->setBitstreamRestrictionFlag(uiCode);
427	if (pcVUI->getBitstreamRestrictionFlag())
428	{
429	READ_FLAG( uiCode, "tiles_fixed_structure_flag"); pcVUI->setTilesFixedStructureFlag(uiCode);
430	READ_FLAG( uiCode, "motion_vectors_over_pic_boundaries_flag"); pcVUI->setMotionVectorsOverPicBoundariesFlag(uiCode);
431	READ_FLAG( uiCode, "restricted_ref_pic_lists_flag"); pcVUI->setRestrictedRefPicListsFlag(uiCode);
432	READ_UVLC( uiCode, "min_spatial_segmentation_idc"); pcVUI->setMinSpatialSegmentationIdc(uiCode);
433	assert(uiCode < 4096);
434	READ_UVLC( uiCode, "max_bytes_per_pic_denom" ); pcVUI->setMaxBytesPerPicDenom(uiCode);
435	READ_UVLC( uiCode, "max_bits_per_mincu_denom" ); pcVUI->setMaxBitsPerMinCuDenom(uiCode);
436	READ_UVLC( uiCode, "log2_max_mv_length_horizontal" ); pcVUI->setLog2MaxMvLengthHorizontal(uiCode);
437	READ_UVLC( uiCode, "log2_max_mv_length_vertical" ); pcVUI->setLog2MaxMvLengthVertical(uiCode);
438	}
439	}
440
441	Void TDecCavlc::parseHrdParameters(TComHRD *hrd, Bool commonInfPresentFlag, UInt maxNumSubLayersMinus1)
442	{
443	UInt uiCode;
444	if( commonInfPresentFlag )
445	{
446	READ_FLAG( uiCode, "nal_hrd_parameters_present_flag" ); hrd->setNalHrdParametersPresentFlag( uiCode == 1 ? true : false );
447	READ_FLAG( uiCode, "vcl_hrd_parameters_present_flag" ); hrd->setVclHrdParametersPresentFlag( uiCode == 1 ? true : false );
448	if( hrd->getNalHrdParametersPresentFlag() \|\| hrd->getVclHrdParametersPresentFlag() )
449	{
450	READ_FLAG( uiCode, "sub_pic_cpb_params_present_flag" ); hrd->setSubPicCpbParamsPresentFlag( uiCode == 1 ? true : false );
451	if( hrd->getSubPicCpbParamsPresentFlag() )
452	{
453	READ_CODE( 8, uiCode, "tick_divisor_minus2" ); hrd->setTickDivisorMinus2( uiCode );
454	READ_CODE( 5, uiCode, "du_cpb_removal_delay_length_minus1" ); hrd->setDuCpbRemovalDelayLengthMinus1( uiCode );
455	READ_FLAG( uiCode, "sub_pic_cpb_params_in_pic_timing_sei_flag" ); hrd->setSubPicCpbParamsInPicTimingSEIFlag( uiCode == 1 ? true : false );
456	READ_CODE( 5, uiCode, "dpb_output_delay_du_length_minus1" ); hrd->setDpbOutputDelayDuLengthMinus1( uiCode );
457	}
458	READ_CODE( 4, uiCode, "bit_rate_scale" ); hrd->setBitRateScale( uiCode );
459	READ_CODE( 4, uiCode, "cpb_size_scale" ); hrd->setCpbSizeScale( uiCode );
460	if( hrd->getSubPicCpbParamsPresentFlag() )
461	{
462	READ_CODE( 4, uiCode, "cpb_size_du_scale" ); hrd->setDuCpbSizeScale( uiCode );
463	}
464	READ_CODE( 5, uiCode, "initial_cpb_removal_delay_length_minus1" ); hrd->setInitialCpbRemovalDelayLengthMinus1( uiCode );
465	READ_CODE( 5, uiCode, "au_cpb_removal_delay_length_minus1" ); hrd->setCpbRemovalDelayLengthMinus1( uiCode );
466	READ_CODE( 5, uiCode, "dpb_output_delay_length_minus1" ); hrd->setDpbOutputDelayLengthMinus1( uiCode );
467	}
468	}
469	Int i, j, nalOrVcl;
470	for( i = 0; i <= maxNumSubLayersMinus1; i ++ )
471	{
472	READ_FLAG( uiCode, "fixed_pic_rate_general_flag" ); hrd->setFixedPicRateFlag( i, uiCode == 1 ? true : false );
473	if( !hrd->getFixedPicRateFlag( i ) )
474	{
475	READ_FLAG( uiCode, "fixed_pic_rate_within_cvs_flag" ); hrd->setFixedPicRateWithinCvsFlag( i, uiCode == 1 ? true : false );
476	}
477	else
478	{
479	hrd->setFixedPicRateWithinCvsFlag( i, true );
480	}
481	hrd->setLowDelayHrdFlag( i, 0 ); // Infered to be 0 when not present
482	hrd->setCpbCntMinus1 ( i, 0 ); // Infered to be 0 when not present
483	if( hrd->getFixedPicRateWithinCvsFlag( i ) )
484	{
485	READ_UVLC( uiCode, "elemental_duration_in_tc_minus1" ); hrd->setPicDurationInTcMinus1( i, uiCode );
486	}
487	else
488	{
489	READ_FLAG( uiCode, "low_delay_hrd_flag" ); hrd->setLowDelayHrdFlag( i, uiCode == 1 ? true : false );
490	}
491	if (!hrd->getLowDelayHrdFlag( i ))
492	{
493	READ_UVLC( uiCode, "cpb_cnt_minus1" ); hrd->setCpbCntMinus1( i, uiCode );
494	}
495	for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
496	{
497	if( ( ( nalOrVcl == 0 ) && ( hrd->getNalHrdParametersPresentFlag() ) ) \|\|
498	( ( nalOrVcl == 1 ) && ( hrd->getVclHrdParametersPresentFlag() ) ) )
499	{
500	for( j = 0; j <= ( hrd->getCpbCntMinus1( i ) ); j ++ )
501	{
502	READ_UVLC( uiCode, "bit_rate_value_minus1" ); hrd->setBitRateValueMinus1( i, j, nalOrVcl, uiCode );
503	READ_UVLC( uiCode, "cpb_size_value_minus1" ); hrd->setCpbSizeValueMinus1( i, j, nalOrVcl, uiCode );
504	if( hrd->getSubPicCpbParamsPresentFlag() )
505	{
506	READ_UVLC( uiCode, "cpb_size_du_value_minus1" ); hrd->setDuCpbSizeValueMinus1( i, j, nalOrVcl, uiCode );
507	READ_UVLC( uiCode, "bit_rate_du_value_minus1" ); hrd->setDuBitRateValueMinus1( i, j, nalOrVcl, uiCode );
508	}
509	READ_FLAG( uiCode, "cbr_flag" ); hrd->setCbrFlag( i, j, nalOrVcl, uiCode == 1 ? true : false );
510	}
511	}
512	}
513	}
514	}
515
516	#if SVC_EXTENSION
517	Void TDecCavlc::parseSPS(TComSPS* pcSPS, ParameterSetManagerDecoder *parameterSetManager)
518	#else
519	Void TDecCavlc::parseSPS(TComSPS* pcSPS)
520	#endif
521	{
522	#if ENC_DEC_TRACE
523	xTraceSPSHeader (pcSPS);
524	#endif
525
526	UInt uiCode;
527	READ_CODE( 4, uiCode, "sps_video_parameter_set_id"); pcSPS->setVPSId ( uiCode );
528	#if SVC_EXTENSION
529	if(pcSPS->getLayerId() == 0)
530	{
531	#endif
532	READ_CODE( 3, uiCode, "sps_max_sub_layers_minus1" ); pcSPS->setMaxTLayers ( uiCode+1 );
533	assert(uiCode <= 6);
534
535	READ_FLAG( uiCode, "sps_temporal_id_nesting_flag" ); pcSPS->setTemporalIdNestingFlag ( uiCode > 0 ? true : false );
536	#if SVC_EXTENSION
537	}
538	else
539	{
540	pcSPS->setMaxTLayers ( parameterSetManager->getPrefetchedVPS(pcSPS->getVPSId())->getMaxTLayers() );
541	pcSPS->setTemporalIdNestingFlag( parameterSetManager->getPrefetchedVPS(pcSPS->getVPSId())->getTemporalNestingFlag() );
542	}
543	#endif
544	if ( pcSPS->getMaxTLayers() == 1 )
545	{
546	// sps_temporal_id_nesting_flag must be 1 when sps_max_sub_layers_minus1 is 0
547	#if SVC_EXTENSION
548	assert( pcSPS->getTemporalIdNestingFlag() == true );
549	#else
550	assert( uiCode == 1 );
551	#endif
552	}
553	#ifdef SPS_PTL_FIX
554	if ( pcSPS->getLayerId() == 0)
555	{
556	parsePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
557	}
558	#else
559	parsePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
560	#endif
561
562	READ_UVLC( uiCode, "sps_seq_parameter_set_id" ); pcSPS->setSPSId( uiCode );
563	assert(uiCode <= 15);
564
565	#if REPN_FORMAT_IN_VPS
566	if( pcSPS->getLayerId() > 0 )
567	{
568	READ_FLAG( uiCode, "update_rep_format_flag" );
569	pcSPS->setUpdateRepFormatFlag( uiCode ? true : false );
570	}
571	else
572	{
573	pcSPS->setUpdateRepFormatFlag( true );
574	}
575	#if O0096_REP_FORMAT_INDEX
576	if( pcSPS->getLayerId() == 0 )
577	#else
578	if( pcSPS->getLayerId() == 0 \|\| pcSPS->getUpdateRepFormatFlag() )
579	#endif
580	{
581	#endif
582	#if AUXILIARY_PICTURES
583	READ_UVLC( uiCode, "chroma_format_idc" ); pcSPS->setChromaFormatIdc( ChromaFormat(uiCode) );
584	#else
585	READ_UVLC( uiCode, "chroma_format_idc" ); pcSPS->setChromaFormatIdc( uiCode );
586	#endif
587	assert(uiCode <= 3);
588	// 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
589	assert (uiCode == 1);
590	if( uiCode == 3 )
591	{
592	READ_FLAG( uiCode, "separate_colour_plane_flag"); assert(uiCode == 0);
593	}
594
595	READ_UVLC ( uiCode, "pic_width_in_luma_samples" ); pcSPS->setPicWidthInLumaSamples ( uiCode );
596	READ_UVLC ( uiCode, "pic_height_in_luma_samples" ); pcSPS->setPicHeightInLumaSamples( uiCode );
597	#if REPN_FORMAT_IN_VPS
598	}
599	#if O0096_REP_FORMAT_INDEX
600	else if ( pcSPS->getUpdateRepFormatFlag() )
601	{
602	READ_CODE(8, uiCode, "update_rep_format_index");
603	pcSPS->setUpdateRepFormatIndex(uiCode);
604	}
605	#endif
606	#endif
607	READ_FLAG( uiCode, "conformance_window_flag");
608	if (uiCode != 0)
609	{
610	Window &conf = pcSPS->getConformanceWindow();
611	#if REPN_FORMAT_IN_VPS
612	READ_UVLC( uiCode, "conf_win_left_offset" ); conf.setWindowLeftOffset ( uiCode );
613	READ_UVLC( uiCode, "conf_win_right_offset" ); conf.setWindowRightOffset ( uiCode );
614	READ_UVLC( uiCode, "conf_win_top_offset" ); conf.setWindowTopOffset ( uiCode );
615	READ_UVLC( uiCode, "conf_win_bottom_offset" ); conf.setWindowBottomOffset( uiCode );
616	#else
617	READ_UVLC( uiCode, "conf_win_left_offset" ); conf.setWindowLeftOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc() ) );
618	READ_UVLC( uiCode, "conf_win_right_offset" ); conf.setWindowRightOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc() ) );
619	READ_UVLC( uiCode, "conf_win_top_offset" ); conf.setWindowTopOffset ( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc() ) );
620	READ_UVLC( uiCode, "conf_win_bottom_offset" ); conf.setWindowBottomOffset( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc() ) );
621	#endif
622	}
623	#if REPN_FORMAT_IN_VPS
624	#if O0096_REP_FORMAT_INDEX
625	if( pcSPS->getLayerId() == 0 )
626	#else
627	if( pcSPS->getLayerId() == 0 \|\| pcSPS->getUpdateRepFormatFlag() )
628	#endif
629	{
630	#endif
631	READ_UVLC( uiCode, "bit_depth_luma_minus8" );
632	assert(uiCode <= 6);
633	pcSPS->setBitDepthY( uiCode + 8 );
634	pcSPS->setQpBDOffsetY( (Int) (6*uiCode) );
635
636	READ_UVLC( uiCode, "bit_depth_chroma_minus8" );
637	assert(uiCode <= 6);
638	pcSPS->setBitDepthC( uiCode + 8 );
639	pcSPS->setQpBDOffsetC( (Int) (6*uiCode) );
640	#if REPN_FORMAT_IN_VPS
641	}
642	#endif
643	READ_UVLC( uiCode, "log2_max_pic_order_cnt_lsb_minus4" ); pcSPS->setBitsForPOC( 4 + uiCode );
644	assert(uiCode <= 12);
645
646	UInt subLayerOrderingInfoPresentFlag;
647	READ_FLAG(subLayerOrderingInfoPresentFlag, "sps_sub_layer_ordering_info_present_flag");
648
649	for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
650	{
651	READ_UVLC ( uiCode, "sps_max_dec_pic_buffering_minus1");
652	pcSPS->setMaxDecPicBuffering( uiCode + 1, i);
653	READ_UVLC ( uiCode, "sps_num_reorder_pics" );
654	pcSPS->setNumReorderPics(uiCode, i);
655	READ_UVLC ( uiCode, "sps_max_latency_increase_plus1");
656	pcSPS->setMaxLatencyIncrease( uiCode, i );
657
658	if (!subLayerOrderingInfoPresentFlag)
659	{
660	for (i++; i <= pcSPS->getMaxTLayers()-1; i++)
661	{
662	pcSPS->setMaxDecPicBuffering(pcSPS->getMaxDecPicBuffering(0), i);
663	pcSPS->setNumReorderPics(pcSPS->getNumReorderPics(0), i);
664	pcSPS->setMaxLatencyIncrease(pcSPS->getMaxLatencyIncrease(0), i);
665	}
666	break;
667	}
668	}
669
670	READ_UVLC( uiCode, "log2_min_coding_block_size_minus3" );
671	Int log2MinCUSize = uiCode + 3;
672	pcSPS->setLog2MinCodingBlockSize(log2MinCUSize);
673	READ_UVLC( uiCode, "log2_diff_max_min_coding_block_size" );
674	pcSPS->setLog2DiffMaxMinCodingBlockSize(uiCode);
675
676	if (pcSPS->getPTL()->getGeneralPTL()->getLevelIdc() >= Level::LEVEL5)
677	{
678	assert(log2MinCUSize + pcSPS->getLog2DiffMaxMinCodingBlockSize() >= 5);
679	}
680
681	Int maxCUDepthDelta = uiCode;
682	pcSPS->setMaxCUWidth ( 1<<(log2MinCUSize + maxCUDepthDelta) );
683	pcSPS->setMaxCUHeight ( 1<<(log2MinCUSize + maxCUDepthDelta) );
684	READ_UVLC( uiCode, "log2_min_transform_block_size_minus2" ); pcSPS->setQuadtreeTULog2MinSize( uiCode + 2 );
685
686	READ_UVLC( uiCode, "log2_diff_max_min_transform_block_size" ); pcSPS->setQuadtreeTULog2MaxSize( uiCode + pcSPS->getQuadtreeTULog2MinSize() );
687	pcSPS->setMaxTrSize( 1<<(uiCode + pcSPS->getQuadtreeTULog2MinSize()) );
688
689	READ_UVLC( uiCode, "max_transform_hierarchy_depth_inter" ); pcSPS->setQuadtreeTUMaxDepthInter( uiCode+1 );
690	READ_UVLC( uiCode, "max_transform_hierarchy_depth_intra" ); pcSPS->setQuadtreeTUMaxDepthIntra( uiCode+1 );
691
692	Int addCuDepth = max (0, log2MinCUSize - (Int)pcSPS->getQuadtreeTULog2MinSize() );
693	pcSPS->setMaxCUDepth( maxCUDepthDelta + addCuDepth );
694	READ_FLAG( uiCode, "scaling_list_enabled_flag" ); pcSPS->setScalingListFlag ( uiCode );
695
696	if(pcSPS->getScalingListFlag())
697	{
698	#if SCALINGLIST_INFERRING
699	if( pcSPS->getLayerId() > 0 )
700	{
701	READ_FLAG( uiCode, "sps_infer_scaling_list_flag" ); pcSPS->setInferScalingListFlag( uiCode );
702	}
703
704	if( pcSPS->getInferScalingListFlag() )
705	{
706	READ_UVLC( uiCode, "sps_scaling_list_ref_layer_id" ); pcSPS->setScalingListRefLayerId( uiCode );
707
708	// The value of pps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
709	assert( pcSPS->getScalingListRefLayerId() <= 62 );
710
711	pcSPS->setScalingListPresentFlag( false );
712	}
713	else
714	{
715	#endif
716	READ_FLAG( uiCode, "sps_scaling_list_data_present_flag" ); pcSPS->setScalingListPresentFlag ( uiCode );
717	if(pcSPS->getScalingListPresentFlag ())
718	{
719	parseScalingList( pcSPS->getScalingList() );
720	}
721	#if SCALINGLIST_INFERRING
722	}
723	#endif
724	}
725	READ_FLAG( uiCode, "amp_enabled_flag" ); pcSPS->setUseAMP( uiCode );
726	READ_FLAG( uiCode, "sample_adaptive_offset_enabled_flag" ); pcSPS->setUseSAO ( uiCode ? true : false );
727
728	READ_FLAG( uiCode, "pcm_enabled_flag" ); pcSPS->setUsePCM( uiCode ? true : false );
729	if( pcSPS->getUsePCM() )
730	{
731	READ_CODE( 4, uiCode, "pcm_sample_bit_depth_luma_minus1" ); pcSPS->setPCMBitDepthLuma ( 1 + uiCode );
732	READ_CODE( 4, uiCode, "pcm_sample_bit_depth_chroma_minus1" ); pcSPS->setPCMBitDepthChroma ( 1 + uiCode );
733	READ_UVLC( uiCode, "log2_min_pcm_luma_coding_block_size_minus3" ); pcSPS->setPCMLog2MinSize (uiCode+3);
734	READ_UVLC( uiCode, "log2_diff_max_min_pcm_luma_coding_block_size" ); pcSPS->setPCMLog2MaxSize ( uiCode+pcSPS->getPCMLog2MinSize() );
735	READ_FLAG( uiCode, "pcm_loop_filter_disable_flag" ); pcSPS->setPCMFilterDisableFlag ( uiCode ? true : false );
736	}
737
738	READ_UVLC( uiCode, "num_short_term_ref_pic_sets" );
739	assert(uiCode <= 64);
740	pcSPS->createRPSList(uiCode);
741
742	TComRPSList* rpsList = pcSPS->getRPSList();
743	TComReferencePictureSet* rps;
744
745	for(UInt i=0; i< rpsList->getNumberOfReferencePictureSets(); i++)
746	{
747	rps = rpsList->getReferencePictureSet(i);
748	parseShortTermRefPicSet(pcSPS,rps,i);
749	}
750	READ_FLAG( uiCode, "long_term_ref_pics_present_flag" ); pcSPS->setLongTermRefsPresent(uiCode);
751	if (pcSPS->getLongTermRefsPresent())
752	{
753	READ_UVLC( uiCode, "num_long_term_ref_pic_sps" );
754	pcSPS->setNumLongTermRefPicSPS(uiCode);
755	for (UInt k = 0; k < pcSPS->getNumLongTermRefPicSPS(); k++)
756	{
757	READ_CODE( pcSPS->getBitsForPOC(), uiCode, "lt_ref_pic_poc_lsb_sps" );
758	pcSPS->setLtRefPicPocLsbSps(k, uiCode);
759	READ_FLAG( uiCode, "used_by_curr_pic_lt_sps_flag[i]");
760	pcSPS->setUsedByCurrPicLtSPSFlag(k, uiCode?1:0);
761	}
762	}
763	READ_FLAG( uiCode, "sps_temporal_mvp_enable_flag" ); pcSPS->setTMVPFlagsPresent(uiCode);
764	READ_FLAG( uiCode, "sps_strong_intra_smoothing_enable_flag" ); pcSPS->setUseStrongIntraSmoothing(uiCode);
765
766	READ_FLAG( uiCode, "vui_parameters_present_flag" ); pcSPS->setVuiParametersPresentFlag(uiCode);
767
768	if (pcSPS->getVuiParametersPresentFlag())
769	{
770	parseVUI(pcSPS->getVuiParameters(), pcSPS);
771	}
772
773	READ_FLAG( uiCode, "sps_extension_flag");
774	if (uiCode)
775	{
776	#if SPS_EXTENSION
777
778	#if O0142_CONDITIONAL_SPS_EXTENSION
779	UInt spsExtensionTypeFlag[8];
780	for (UInt i = 0; i < 8; i++)
781	{
782	READ_FLAG( spsExtensionTypeFlag[i], "sps_extension_type_flag" );
783	}
784	if (spsExtensionTypeFlag[1])
785	{
786	parseSPSExtension( pcSPS );
787	}
788	if (spsExtensionTypeFlag[7])
789	{
790	#else
791	parseSPSExtension( pcSPS );
792	READ_FLAG( uiCode, "sps_extension2_flag");
793	if(uiCode)
794	{
795	#endif
796
797	#endif
798	while ( xMoreRbspData() )
799	{
800	READ_FLAG( uiCode, "sps_extension_data_flag");
801	}
802	#if SPS_EXTENSION
803	}
804	#endif
805	}
806	}
807
808	#if SPS_EXTENSION
809	Void TDecCavlc::parseSPSExtension( TComSPS* pcSPS )
810	{
811	UInt uiCode;
812	// more syntax elements to be parsed here
813
814	READ_FLAG( uiCode, "inter_view_mv_vert_constraint_flag" );
815	// Vertical MV component restriction is not used in SHVC CTC
816	assert( uiCode == 0 );
817
818	if( pcSPS->getLayerId() > 0 )
819	{
820	Int iCode;
821	READ_UVLC( uiCode, "num_scaled_ref_layer_offsets" ); pcSPS->setNumScaledRefLayerOffsets(uiCode);
822	for(Int i = 0; i < pcSPS->getNumScaledRefLayerOffsets(); i++)
823	{
824	Window& scaledWindow = pcSPS->getScaledRefLayerWindow(i);
825	#if O0098_SCALED_REF_LAYER_ID
826	READ_CODE( 6, uiCode, "scaled_ref_layer_left_id" ); pcSPS->setScaledRefLayerId( i, uiCode );
827	#endif
828	READ_SVLC( iCode, "scaled_ref_layer_left_offset" ); scaledWindow.setWindowLeftOffset (iCode << 1);
829	READ_SVLC( iCode, "scaled_ref_layer_top_offset" ); scaledWindow.setWindowTopOffset (iCode << 1);
830	READ_SVLC( iCode, "scaled_ref_layer_right_offset" ); scaledWindow.setWindowRightOffset (iCode << 1);
831	READ_SVLC( iCode, "scaled_ref_layer_bottom_offset" ); scaledWindow.setWindowBottomOffset(iCode << 1);
832	}
833	}
834	}
835	#endif
836
837	Void TDecCavlc::parseVPS(TComVPS* pcVPS)
838	{
839	UInt uiCode;
840
841	READ_CODE( 4, uiCode, "vps_video_parameter_set_id" ); pcVPS->setVPSId( uiCode );
842	READ_CODE( 2, uiCode, "vps_reserved_three_2bits" ); assert(uiCode == 3);
843	#if VPS_RENAME
844	#if O0137_MAX_LAYERID
845	READ_CODE( 6, uiCode, "vps_max_layers_minus1" ); pcVPS->setMaxLayers( min( 62u, uiCode) + 1 );
846	#else
847	READ_CODE( 6, uiCode, "vps_max_layers_minus1" ); pcVPS->setMaxLayers( uiCode + 1 );
848	#endif
849	#else
850	READ_CODE( 6, uiCode, "vps_reserved_zero_6bits" ); assert(uiCode == 0);
851	#endif
852	READ_CODE( 3, uiCode, "vps_max_sub_layers_minus1" ); pcVPS->setMaxTLayers( uiCode + 1 );
853	READ_FLAG( uiCode, "vps_temporal_id_nesting_flag" ); pcVPS->setTemporalNestingFlag( uiCode ? true:false );
854	assert (pcVPS->getMaxTLayers()>1\|\|pcVPS->getTemporalNestingFlag());
855	#if !P0125_REVERT_VPS_EXTN_OFFSET_TO_RESERVED
856	#if VPS_EXTN_OFFSET
857	READ_CODE( 16, uiCode, "vps_extension_offset" ); pcVPS->setExtensionOffset( uiCode );
858	#else
859	READ_CODE( 16, uiCode, "vps_reserved_ffff_16bits" ); assert(uiCode == 0xffff);
860	#endif
861	#else
862	READ_CODE( 16, uiCode, "vps_reserved_ffff_16bits" ); assert(uiCode == 0xffff);
863	#endif
864	parsePTL ( pcVPS->getPTL(), true, pcVPS->getMaxTLayers()-1);
865	UInt subLayerOrderingInfoPresentFlag;
866	READ_FLAG(subLayerOrderingInfoPresentFlag, "vps_sub_layer_ordering_info_present_flag");
867	for(UInt i = 0; i <= pcVPS->getMaxTLayers()-1; i++)
868	{
869	READ_UVLC( uiCode, "vps_max_dec_pic_buffering_minus1[i]" ); pcVPS->setMaxDecPicBuffering( uiCode + 1, i );
870	READ_UVLC( uiCode, "vps_num_reorder_pics[i]" ); pcVPS->setNumReorderPics( uiCode, i );
871	READ_UVLC( uiCode, "vps_max_latency_increase_plus1[i]" ); pcVPS->setMaxLatencyIncrease( uiCode, i );
872
873	if (!subLayerOrderingInfoPresentFlag)
874	{
875	for (i++; i <= pcVPS->getMaxTLayers()-1; i++)
876	{
877	pcVPS->setMaxDecPicBuffering(pcVPS->getMaxDecPicBuffering(0), i);
878	pcVPS->setNumReorderPics(pcVPS->getNumReorderPics(0), i);
879	pcVPS->setMaxLatencyIncrease(pcVPS->getMaxLatencyIncrease(0), i);
880	}
881	break;
882	}
883	}
884
885	#if VPS_RENAME
886	assert( pcVPS->getNumHrdParameters() < MAX_VPS_LAYER_SETS_PLUS1 );
887	assert( pcVPS->getMaxLayerId() < MAX_VPS_LAYER_ID_PLUS1 );
888	READ_CODE( 6, uiCode, "vps_max_layer_id" ); pcVPS->setMaxLayerId( uiCode );
889	READ_UVLC( uiCode, "vps_num_layer_sets_minus1" ); pcVPS->setNumLayerSets( uiCode + 1 );
890	for( UInt opsIdx = 1; opsIdx <= ( pcVPS->getNumLayerSets() - 1 ); opsIdx ++ )
891	{
892	// Operation point set
893	for( UInt i = 0; i <= pcVPS->getMaxLayerId(); i ++ )
894	#else
895	assert( pcVPS->getNumHrdParameters() < MAX_VPS_OP_SETS_PLUS1 );
896	assert( pcVPS->getMaxNuhReservedZeroLayerId() < MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1 );
897	READ_CODE( 6, uiCode, "vps_max_nuh_reserved_zero_layer_id" ); pcVPS->setMaxNuhReservedZeroLayerId( uiCode );
898	READ_UVLC( uiCode, "vps_max_op_sets_minus1" ); pcVPS->setMaxOpSets( uiCode + 1 );
899	for( UInt opsIdx = 1; opsIdx <= ( pcVPS->getMaxOpSets() - 1 ); opsIdx ++ )
900	{
901	// Operation point set
902	for( UInt i = 0; i <= pcVPS->getMaxNuhReservedZeroLayerId(); i ++ )
903	#endif
904	{
905	READ_FLAG( uiCode, "layer_id_included_flag[opsIdx][i]" ); pcVPS->setLayerIdIncludedFlag( uiCode == 1 ? true : false, opsIdx, i );
906	}
907	}
908	#if DERIVE_LAYER_ID_LIST_VARIABLES
909	pcVPS->deriveLayerIdListVariables();
910	#endif
911	TimingInfo *timingInfo = pcVPS->getTimingInfo();
912	READ_FLAG( uiCode, "vps_timing_info_present_flag"); timingInfo->setTimingInfoPresentFlag (uiCode ? true : false);
913	if(timingInfo->getTimingInfoPresentFlag())
914	{
915	READ_CODE( 32, uiCode, "vps_num_units_in_tick"); timingInfo->setNumUnitsInTick (uiCode);
916	READ_CODE( 32, uiCode, "vps_time_scale"); timingInfo->setTimeScale (uiCode);
917	READ_FLAG( uiCode, "vps_poc_proportional_to_timing_flag"); timingInfo->setPocProportionalToTimingFlag(uiCode ? true : false);
918	if(timingInfo->getPocProportionalToTimingFlag())
919	{
920	READ_UVLC( uiCode, "vps_num_ticks_poc_diff_one_minus1"); timingInfo->setNumTicksPocDiffOneMinus1 (uiCode);
921	}
922	READ_UVLC( uiCode, "vps_num_hrd_parameters" ); pcVPS->setNumHrdParameters( uiCode );
923
924	if( pcVPS->getNumHrdParameters() > 0 )
925	{
926	pcVPS->createHrdParamBuffer();
927	}
928	for( UInt i = 0; i < pcVPS->getNumHrdParameters(); i ++ )
929	{
930	READ_UVLC( uiCode, "hrd_op_set_idx" ); pcVPS->setHrdOpSetIdx( uiCode, i );
931	if( i > 0 )
932	{
933	READ_FLAG( uiCode, "cprms_present_flag[i]" ); pcVPS->setCprmsPresentFlag( uiCode == 1 ? true : false, i );
934	}
935	parseHrdParameters(pcVPS->getHrdParameters(i), pcVPS->getCprmsPresentFlag( i ), pcVPS->getMaxTLayers() - 1);
936	}
937	}
938	READ_FLAG( uiCode, "vps_extension_flag" );
939	if (uiCode)
940	{
941	#if VPS_EXTNS
942	while ( m_pcBitstream->getNumBitsRead() % 8 != 0 )
943	{
944	READ_FLAG( uiCode, "vps_extension_alignment_bit_equal_to_one"); assert(uiCode == 1);
945	}
946	parseVPSExtension(pcVPS);
947	READ_FLAG( uiCode, "vps_entension2_flag" );
948	if(uiCode)
949	{
950	while ( xMoreRbspData() )
951	{
952	READ_FLAG( uiCode, "vps_extension_data_flag");
953	}
954	}
955	#else
956	while ( xMoreRbspData() )
957	{
958	READ_FLAG( uiCode, "vps_extension_data_flag");
959	}
960	#endif
961	}
962
963	return;
964	}
965
966	#if SVC_EXTENSION
967	#if VPS_EXTNS
968	Void TDecCavlc::parseVPSExtension(TComVPS *vps)
969	{
970	UInt uiCode;
971	// ... More syntax elements to be parsed here
972	#if VPS_EXTN_MASK_AND_DIM_INFO
973	UInt numScalabilityTypes = 0, i = 0, j = 0;
974
975	READ_FLAG( uiCode, "avc_base_layer_flag" ); vps->setAvcBaseLayerFlag(uiCode ? true : false);
976
977	#if !P0307_REMOVE_VPS_VUI_OFFSET
978	#if O0109_MOVE_VPS_VUI_FLAG
979	READ_FLAG( uiCode, "vps_vui_present_flag"); vps->setVpsVuiPresentFlag(uiCode ? true : false);
980	if ( uiCode )
981	{
982	#endif
983	#if VPS_VUI_OFFSET
984	READ_CODE( 16, uiCode, "vps_vui_offset" ); vps->setVpsVuiOffset( uiCode );
985	#endif
986	#if O0109_MOVE_VPS_VUI_FLAG
987	}
988	#endif
989	#endif
990	READ_FLAG( uiCode, "splitting_flag" ); vps->setSplittingFlag(uiCode ? true : false);
991
992	for(i = 0; i < MAX_VPS_NUM_SCALABILITY_TYPES; i++)
993	{
994	READ_FLAG( uiCode, "scalability_mask[i]" ); vps->setScalabilityMask(i, uiCode ? true : false);
995	numScalabilityTypes += uiCode;
996	}
997	vps->setNumScalabilityTypes(numScalabilityTypes);
998
999	for(j = 0; j < numScalabilityTypes - vps->getSplittingFlag(); j++)
1000	{
1001	READ_CODE( 3, uiCode, "dimension_id_len_minus1[j]" ); vps->setDimensionIdLen(j, uiCode + 1);
1002	}
1003
1004	if(vps->getSplittingFlag())
1005	{
1006	UInt numBits = 0;
1007	for(j = 0; j < numScalabilityTypes - 1; j++)
1008	{
1009	numBits += vps->getDimensionIdLen(j);
1010	}
1011	assert( numBits < 6 );
1012	vps->setDimensionIdLen(numScalabilityTypes-1, 6 - numBits);
1013	numBits = 6;
1014	}
1015
1016	READ_FLAG( uiCode, "vps_nuh_layer_id_present_flag" ); vps->setNuhLayerIdPresentFlag(uiCode ? true : false);
1017	vps->setLayerIdInNuh(0, 0);
1018	vps->setLayerIdInVps(0, 0);
1019	for(i = 1; i < vps->getMaxLayers(); i++)
1020	{
1021	if( vps->getNuhLayerIdPresentFlag() )
1022	{
1023	READ_CODE( 6, uiCode, "layer_id_in_nuh[i]" ); vps->setLayerIdInNuh(i, uiCode);
1024	assert( uiCode > vps->getLayerIdInNuh(i-1) );
1025	}
1026	else
1027	{
1028	vps->setLayerIdInNuh(i, i);
1029	}
1030	vps->setLayerIdInVps(vps->getLayerIdInNuh(i), i);
1031
1032	if( !vps->getSplittingFlag() )
1033	{
1034	for(j = 0; j < numScalabilityTypes; j++)
1035	{
1036	READ_CODE( vps->getDimensionIdLen(j), uiCode, "dimension_id[i][j]" ); vps->setDimensionId(i, j, uiCode);
1037	#if !AUXILIARY_PICTURES
1038	assert( uiCode <= vps->getMaxLayerId() );
1039	#endif
1040	}
1041	}
1042	}
1043	#endif
1044	#if VIEW_ID_RELATED_SIGNALING
1045	// if ( pcVPS->getNumViews() > 1 )
1046	// However, this is a bug in the text since, view_id_len_minus1 is needed to parse view_id_val.
1047	{
1048	#if O0109_VIEW_ID_LEN
1049	READ_CODE( 4, uiCode, "view_id_len" ); vps->setViewIdLen( uiCode );
1050	#else
1051	READ_CODE( 4, uiCode, "view_id_len_minus1" ); vps->setViewIdLenMinus1( uiCode );
1052	#endif
1053	}
1054
1055	#if O0109_VIEW_ID_LEN
1056	if ( vps->getViewIdLen() > 0 )
1057	{
1058	for( i = 0; i < vps->getNumViews(); i++ )
1059	{
1060	READ_CODE( vps->getViewIdLen( ), uiCode, "view_id_val[i]" ); vps->setViewIdVal( i, uiCode );
1061	}
1062	}
1063	#else
1064	for( i = 0; i < vps->getNumViews(); i++ )
1065	{
1066	READ_CODE( vps->getViewIdLenMinus1( ) + 1, uiCode, "view_id_val[i]" ); vps->setViewIdVal( i, uiCode );
1067	}
1068	#endif
1069	#endif // view id related signaling
1070	#if VPS_EXTN_DIRECT_REF_LAYERS
1071	// For layer 0
1072	vps->setNumDirectRefLayers(0, 0);
1073	// For other layers
1074	for( Int layerCtr = 1; layerCtr <= vps->getMaxLayers() - 1; layerCtr++)
1075	{
1076	UInt numDirectRefLayers = 0;
1077	for( Int refLayerCtr = 0; refLayerCtr < layerCtr; refLayerCtr++)
1078	{
1079	READ_FLAG(uiCode, "direct_dependency_flag[i][j]" ); vps->setDirectDependencyFlag(layerCtr, refLayerCtr, uiCode? true : false);
1080	if(uiCode)
1081	{
1082	vps->setRefLayerId(layerCtr, numDirectRefLayers, refLayerCtr);
1083	numDirectRefLayers++;
1084	}
1085	}
1086	vps->setNumDirectRefLayers(layerCtr, numDirectRefLayers);
1087	}
1088	#endif
1089	#if VPS_TSLAYERS
1090	READ_FLAG( uiCode, "vps_sub_layers_max_minus1_present_flag"); vps->setMaxTSLayersPresentFlag(uiCode ? true : false);
1091	if (vps->getMaxTSLayersPresentFlag())
1092	{
1093	for(i = 0; i < vps->getMaxLayers() - 1; i++)
1094	{
1095	READ_CODE( 3, uiCode, "sub_layers_vps_max_minus1[i]" ); vps->setMaxTSLayersMinus1(i, uiCode);
1096	}
1097	}
1098	else
1099	{
1100	for( i = 0; i < vps->getMaxLayers() - 1; i++)
1101	{
1102	vps->setMaxTSLayersMinus1(i, vps->getMaxTLayers()-1);
1103	}
1104	}
1105	#endif
1106	#if N0120_MAX_TID_REF_PRESENT_FLAG
1107	READ_FLAG( uiCode, "max_tid_ref_present_flag"); vps->setMaxTidRefPresentFlag(uiCode ? true : false);
1108	if (vps->getMaxTidRefPresentFlag())
1109	{
1110	for(i = 0; i < vps->getMaxLayers() - 1; i++)
1111	{
1112	#if O0225_MAX_TID_FOR_REF_LAYERS
1113	for( j = i+1; j <= vps->getMaxLayers() - 1; j++)
1114	{
1115	if(vps->getDirectDependencyFlag(j, i))
1116	{
1117	READ_CODE( 3, uiCode, "max_tid_il_ref_pics_plus1[i][j]" ); vps->setMaxTidIlRefPicsPlus1(i, j, uiCode);
1118	assert( uiCode <= vps->getMaxTLayers());
1119	}
1120	}
1121	#else
1122	READ_CODE( 3, uiCode, "max_tid_il_ref_pics_plus1[i]" ); vps->setMaxTidIlRefPicsPlus1(i, uiCode);
1123	#if N0120_MAX_TID_REF_CFG
1124	assert( uiCode <= vps->getMaxTLayers());
1125	#else
1126	assert( uiCode <= vps->getMaxTLayers()+ 1 );
1127	#endif
1128	#endif
1129	}
1130	}
1131	else
1132	{
1133	for(i = 0; i < vps->getMaxLayers() - 1; i++)
1134	{
1135	#if O0225_MAX_TID_FOR_REF_LAYERS
1136	for( j = i+1; j <= vps->getMaxLayers() - 1; j++)
1137	{
1138	vps->setMaxTidIlRefPicsPlus1(i, j, 7);
1139	}
1140	#else
1141	vps->setMaxTidIlRefPicsPlus1(i, 7);
1142	#endif
1143	}
1144	}
1145	#else
1146	for(i = 0; i < vps->getMaxLayers() - 1; i++)
1147	{
1148	#if O0225_MAX_TID_FOR_REF_LAYERS
1149	for( j = i+1; j <= vps->getMaxLayers() - 1; j++)
1150	{
1151	if(vps->getDirectDependencyFlag(j, i))
1152	{
1153	READ_CODE( 3, uiCode, "max_tid_il_ref_pics_plus1[i][j]" ); vps->setMaxTidIlRefPicsPlus1(i, j, uiCode);
1154	assert( uiCode <= vps->getMaxTLayers() );
1155	}
1156	}
1157	#else
1158	READ_CODE( 3, uiCode, "max_tid_il_ref_pics_plus1[i]" ); vps->setMaxTidIlRefPicsPlus1(i, uiCode);
1159	assert( uiCode <= vps->getMaxTLayers() );
1160	#endif
1161	}
1162	#endif
1163	#if ILP_SSH_SIG
1164	READ_FLAG( uiCode, "all_ref_layers_active_flag" ); vps->setIlpSshSignalingEnabledFlag(uiCode ? true : false);
1165	#endif
1166	#if VPS_EXTN_PROFILE_INFO
1167	// Profile-tier-level signalling
1168	#if !VPS_EXTN_UEV_CODING
1169	READ_CODE( 10, uiCode, "vps_number_layer_sets_minus1" ); assert( uiCode == (vps->getNumLayerSets() - 1) );
1170	READ_CODE( 6, uiCode, "vps_num_profile_tier_level_minus1"); vps->setNumProfileTierLevel( uiCode + 1 );
1171	#else
1172	READ_UVLC( uiCode, "vps_num_profile_tier_level_minus1"); vps->setNumProfileTierLevel( uiCode + 1 );
1173	#endif
1174	vps->getPTLForExtnPtr()->resize(vps->getNumProfileTierLevel());
1175	for(Int idx = 1; idx <= vps->getNumProfileTierLevel() - 1; idx++)
1176	{
1177	READ_FLAG( uiCode, "vps_profile_present_flag[i]" ); vps->setProfilePresentFlag(idx, uiCode ? true : false);
1178	if( !vps->getProfilePresentFlag(idx) )
1179	{
1180	#if P0048_REMOVE_PROFILE_REF
1181	// Copy profile information from previous one
1182	vps->getPTLForExtn(idx)->copyProfileInfo( (idx==1) ? vps->getPTL() : vps->getPTLForExtn( idx - 1 ) );
1183	#else
1184	READ_CODE( 6, uiCode, "profile_ref_minus1[i]" ); vps->setProfileLayerSetRef(idx, uiCode + 1);
1185	#if O0109_PROF_REF_MINUS1
1186	assert( vps->getProfileLayerSetRef(idx) <= idx );
1187	#else
1188	assert( vps->getProfileLayerSetRef(idx) < idx );
1189	#endif
1190	// Copy profile information as indicated
1191	vps->getPTLForExtn(idx)->copyProfileInfo( vps->getPTLForExtn( vps->getProfileLayerSetRef(idx) ) );
1192	#endif
1193	}
1194	parsePTL( vps->getPTLForExtn(idx), vps->getProfilePresentFlag(idx), vps->getMaxTLayers() - 1 );
1195	}
1196	#endif
1197
1198	#if !VPS_EXTN_UEV_CODING
1199	READ_FLAG( uiCode, "more_output_layer_sets_than_default_flag" ); vps->setMoreOutputLayerSetsThanDefaultFlag( uiCode ? true : false );
1200	Int numOutputLayerSets = 0;
1201	if(! vps->getMoreOutputLayerSetsThanDefaultFlag() )
1202	{
1203	numOutputLayerSets = vps->getNumLayerSets();
1204	}
1205	else
1206	{
1207	READ_CODE( 10, uiCode, "num_add_output_layer_sets" ); vps->setNumAddOutputLayerSets( uiCode );
1208	numOutputLayerSets = vps->getNumLayerSets() + vps->getNumAddOutputLayerSets();
1209	}
1210	#else
1211	READ_UVLC( uiCode, "num_add_output_layer_sets" ); vps->setNumAddOutputLayerSets( uiCode );
1212	Int numOutputLayerSets = vps->getNumLayerSets() + vps->getNumAddOutputLayerSets();
1213	#endif
1214
1215	#if P0295_DEFAULT_OUT_LAYER_IDC
1216	if( numOutputLayerSets > 1 )
1217	{
1218	READ_CODE( 2, uiCode, "default_target_output_layer_idc" ); vps->setDefaultTargetOutputLayerIdc( uiCode );
1219	}
1220	vps->setNumOutputLayerSets( numOutputLayerSets );
1221
1222	for(i = 1; i < numOutputLayerSets; i++)
1223	{
1224	if( i > (vps->getNumLayerSets() - 1) )
1225	{
1226	Int numBits = 1;
1227	while ((1 << numBits) < (vps->getNumLayerSets() - 1))
1228	{
1229	numBits++;
1230	}
1231	READ_CODE( numBits, uiCode, "output_layer_set_idx_minus1"); vps->setOutputLayerSetIdx( i, uiCode + 1);
1232	}
1233	else
1234	{
1235	vps->setOutputLayerSetIdx( i, i );
1236	}
1237	if ( i > (vps->getNumLayerSets() - 1) \|\| vps->getDefaultTargetOutputLayerIdc() >= 2 )
1238	{
1239	Int lsIdx = vps->getOutputLayerSetIdx(i);
1240	for(j = 0; j < vps->getNumLayersInIdList(lsIdx) - 1; j++)
1241	{
1242	READ_FLAG( uiCode, "output_layer_flag[i][j]"); vps->setOutputLayerFlag(i, j, uiCode);
1243	}
1244	}
1245	else
1246	{
1247	// i <= (vps->getNumLayerSets() - 1)
1248	// Assign OutputLayerFlag depending on default_one_target_output_layer_flag
1249	Int lsIdx = i;
1250	if( vps->getDefaultTargetOutputLayerIdc() == 1 )
1251	{
1252	for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++)
1253	{
1254	vps->setOutputLayerFlag(i, j, (j == (vps->getNumLayersInIdList(lsIdx)-1)) && (vps->getDimensionId(j,1) == 0) );
1255	}
1256	}
1257	else if ( vps->getDefaultTargetOutputLayerIdc() == 0 )
1258	{
1259	for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++)
1260	{
1261	vps->setOutputLayerFlag(i, j, 1);
1262	}
1263	}
1264	}
1265	Int numBits = 1;
1266	while ((1 << numBits) < (vps->getNumProfileTierLevel()))
1267	{
1268	numBits++;
1269	}
1270	READ_CODE( numBits, uiCode, "profile_level_tier_idx[i]" ); vps->setProfileLevelTierIdx(i, uiCode);
1271	}
1272	#else
1273	if( numOutputLayerSets > 1 )
1274	{
1275	#if O0109_DEFAULT_ONE_OUT_LAYER_IDC
1276	READ_CODE( 2, uiCode, "default_one_target_output_layer_idc" ); vps->setDefaultOneTargetOutputLayerIdc( uiCode );
1277	#else
1278	READ_FLAG( uiCode, "default_one_target_output_layer_flag" ); vps->setDefaultOneTargetOutputLayerFlag( uiCode ? true : false );
1279	#endif
1280	}
1281	vps->setNumOutputLayerSets( numOutputLayerSets );
1282
1283	for(i = 1; i < numOutputLayerSets; i++)
1284	{
1285	if( i > (vps->getNumLayerSets() - 1) )
1286	{
1287	Int numBits = 1;
1288	while ((1 << numBits) < (vps->getNumLayerSets() - 1))
1289	{
1290	numBits++;
1291	}
1292	READ_CODE( numBits, uiCode, "output_layer_set_idx_minus1"); vps->setOutputLayerSetIdx( i, uiCode + 1);
1293	Int lsIdx = vps->getOutputLayerSetIdx(i);
1294	for(j = 0; j < vps->getNumLayersInIdList(lsIdx) - 1; j++)
1295	{
1296	READ_FLAG( uiCode, "output_layer_flag[i][j]"); vps->setOutputLayerFlag(i, j, uiCode);
1297	}
1298	}
1299	else
1300	{
1301	#if VPS_DPB_SIZE_TABLE
1302	vps->setOutputLayerSetIdx( i, i );
1303	#endif
1304	// i <= (vps->getNumLayerSets() - 1)
1305	// Assign OutputLayerFlag depending on default_one_target_output_layer_flag
1306	Int lsIdx = i;
1307	#if O0109_DEFAULT_ONE_OUT_LAYER_IDC
1308	if( vps->getDefaultOneTargetOutputLayerIdc() == 1 )
1309	{
1310	for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++)
1311	{
1312	#if O0135_DEFAULT_ONE_OUT_SEMANTIC
1313	vps->setOutputLayerFlag(i, j, (j == (vps->getNumLayersInIdList(lsIdx)-1)) && (vps->getDimensionId(j,1)==0) );
1314	#else
1315	vps->setOutputLayerFlag(i, j, (j == (vps->getNumLayersInIdList(lsIdx)-1)));
1316	#endif
1317	}
1318	}
1319	else if ( vps->getDefaultOneTargetOutputLayerIdc() == 0 )
1320	{
1321	for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++)
1322	{
1323	vps->setOutputLayerFlag(i, j, 1);
1324	}
1325	}
1326	else
1327	{
1328	// Other values of default_one_target_output_layer_idc than 0 and 1 are reserved for future use.
1329	}
1330	#else
1331	if( vps->getDefaultOneTargetOutputLayerFlag() )
1332	{
1333	for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++)
1334	{
1335	vps->setOutputLayerFlag(i, j, (j == (vps->getNumLayersInIdList(lsIdx)-1)));
1336	}
1337	}
1338	else
1339	{
1340	for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++)
1341	{
1342	vps->setOutputLayerFlag(i, j, 1);
1343	}
1344	}
1345	#endif
1346	}
1347	Int numBits = 1;
1348	while ((1 << numBits) < (vps->getNumProfileTierLevel()))
1349	{
1350	numBits++;
1351	}
1352	READ_CODE( numBits, uiCode, "profile_level_tier_idx[i]" ); vps->setProfileLevelTierIdx(i, uiCode);
1353	}
1354	#endif
1355
1356	#if O0153_ALT_OUTPUT_LAYER_FLAG
1357	if( vps->getMaxLayers() > 1 )
1358	{
1359	READ_FLAG( uiCode, "alt_output_layer_flag");
1360	vps->setAltOuputLayerFlag( uiCode ? true : false );
1361	}
1362	#endif
1363
1364	#if REPN_FORMAT_IN_VPS
1365	READ_FLAG( uiCode, "rep_format_idx_present_flag");
1366	vps->setRepFormatIdxPresentFlag( uiCode ? true : false );
1367
1368	if( vps->getRepFormatIdxPresentFlag() )
1369	{
1370	#if O0096_REP_FORMAT_INDEX
1371	#if !VPS_EXTN_UEV_CODING
1372	READ_CODE( 8, uiCode, "vps_num_rep_formats_minus1" );
1373	#else
1374	READ_UVLC( uiCode, "vps_num_rep_formats_minus1" );
1375	#endif
1376	#else
1377	READ_CODE( 4, uiCode, "vps_num_rep_formats_minus1" );
1378	#endif
1379	vps->setVpsNumRepFormats( uiCode + 1 );
1380	}
1381	else
1382	{
1383	// default assignment
1384	assert (vps->getMaxLayers() <= 16); // If max_layers_is more than 15, num_rep_formats has to be signaled
1385	vps->setVpsNumRepFormats( vps->getMaxLayers() );
1386	}
1387	for(i = 0; i < vps->getVpsNumRepFormats(); i++)
1388	{
1389	// Read rep_format_structures
1390	parseRepFormat( vps->getVpsRepFormat(i) );
1391	}
1392
1393	// Default assignment for layer 0
1394	vps->setVpsRepFormatIdx( 0, 0 );
1395	if( vps->getRepFormatIdxPresentFlag() )
1396	{
1397	for(i = 1; i < vps->getMaxLayers(); i++)
1398	{
1399	if( vps->getVpsNumRepFormats() > 1 )
1400	{
1401	#if O0096_REP_FORMAT_INDEX
1402	#if !VPS_EXTN_UEV_CODING
1403	READ_CODE( 8, uiCode, "vps_rep_format_idx[i]" );
1404	#else
1405	Int numBits = 1;
1406	while ((1 << numBits) < (vps->getVpsNumRepFormats()))
1407	{
1408	numBits++;
1409	}
1410	READ_CODE( numBits, uiCode, "vps_rep_format_idx[i]" );
1411	#endif
1412	#else
1413	READ_CODE( 4, uiCode, "vps_rep_format_idx[i]" );
1414	#endif
1415	vps->setVpsRepFormatIdx( i, uiCode );
1416	}
1417	else
1418	{
1419	// default assignment - only one rep_format() structure
1420	vps->setVpsRepFormatIdx( i, 0 );
1421	}
1422	}
1423	}
1424	else
1425	{
1426	// default assignment - each layer assigned each rep_format() structure in the order signaled
1427	for(i = 1; i < vps->getMaxLayers(); i++)
1428	{
1429	vps->setVpsRepFormatIdx( i, i );
1430	}
1431	}
1432	#endif
1433	#if RESOLUTION_BASED_DPB
1434	vps->assignSubDpbIndices();
1435	#endif
1436	READ_FLAG(uiCode, "max_one_active_ref_layer_flag" );
1437	vps->setMaxOneActiveRefLayerFlag(uiCode);
1438	#if O0062_POC_LSB_NOT_PRESENT_FLAG
1439	for(i = 1; i< vps->getMaxLayers(); i++)
1440	{
1441	if( vps->getNumDirectRefLayers( vps->getLayerIdInNuh(i) ) == 0 )
1442	{
1443	READ_FLAG(uiCode, "poc_lsb_not_present_flag[i]");
1444	vps->setPocLsbNotPresentFlag(i, uiCode);
1445	}
1446	}
1447	#endif
1448	#if O0215_PHASE_ALIGNMENT
1449	READ_FLAG( uiCode, "cross_layer_phase_alignment_flag"); vps->setPhaseAlignFlag( uiCode == 1 ? true : false );
1450	#endif
1451
1452	#if N0147_IRAP_ALIGN_FLAG && !IRAP_ALIGN_FLAG_IN_VPS_VUI
1453	READ_FLAG(uiCode, "cross_layer_irap_aligned_flag" );
1454	vps->setCrossLayerIrapAlignFlag(uiCode);
1455	#endif
1456
1457	#if VPS_DPB_SIZE_TABLE
1458	parseVpsDpbSizeTable(vps);
1459	#endif
1460
1461	#if VPS_EXTN_DIRECT_REF_LAYERS
1462	READ_UVLC( uiCode, "direct_dep_type_len_minus2"); vps->setDirectDepTypeLen(uiCode+2);
1463	#if O0096_DEFAULT_DEPENDENCY_TYPE
1464	READ_FLAG(uiCode, "default_direct_dependency_type_flag");
1465	vps->setDefaultDirectDependecyTypeFlag(uiCode == 1? true : false);
1466	if (vps->getDefaultDirectDependencyTypeFlag())
1467	{
1468	READ_CODE( vps->getDirectDepTypeLen(), uiCode, "default_direct_dependency_type" );
1469	vps->setDefaultDirectDependecyType(uiCode);
1470	}
1471	#endif
1472	for(i = 1; i < vps->getMaxLayers(); i++)
1473	{
1474	for(j = 0; j < i; j++)
1475	{
1476	if (vps->getDirectDependencyFlag(i, j))
1477	{
1478	#if O0096_DEFAULT_DEPENDENCY_TYPE
1479	if (vps->getDefaultDirectDependencyTypeFlag())
1480	{
1481	vps->setDirectDependencyType(i, j, vps->getDefaultDirectDependencyType());
1482	}
1483	else
1484	{
1485	READ_CODE( vps->getDirectDepTypeLen(), uiCode, "direct_dependency_type[i][j]" );
1486	vps->setDirectDependencyType(i, j, uiCode);
1487	}
1488	#else
1489	READ_CODE( vps->getDirectDepTypeLen(), uiCode, "direct_dependency_type[i][j]" );
1490	vps->setDirectDependencyType(i, j, uiCode);
1491	#endif
1492	}
1493	}
1494	}
1495	#endif
1496	#if O0092_0094_DEPENDENCY_CONSTRAINT
1497	for(i = 1; i < vps->getMaxLayers(); i++)
1498	{
1499	vps->setNumRefLayers(vps->getLayerIdInNuh(i)); // identify the number of direct and indirect reference layers of current layer and set recursiveRefLayersFlags
1500	}
1501	if(vps->getMaxLayers() > MAX_REF_LAYERS)
1502	{
1503	for(i = 1;i < vps->getMaxLayers(); i++)
1504	{
1505	assert( vps->getNumRefLayers(vps->getLayerIdInNuh(i)) <= MAX_REF_LAYERS);
1506	}
1507	}
1508	#endif
1509
1510	#if P0307_VPS_NON_VUI_EXTENSION
1511	READ_UVLC( uiCode, "vps_non_vui_extension_length"); vps->setVpsNonVuiExtLength((Int)uiCode);
1512	if ( vps->getVpsNonVuiExtLength() > 0 )
1513	{
1514	printf("\n\nUp to the current spec, the value of vps_non_vui_extension_length is supposed to be 0\n");
1515	}
1516	#endif
1517
1518	#if !O0109_O0199_FLAGS_TO_VUI
1519	#if M0040_ADAPTIVE_RESOLUTION_CHANGE
1520	READ_FLAG(uiCode, "single_layer_for_non_irap_flag" ); vps->setSingleLayerForNonIrapFlag(uiCode == 1 ? true : false);
1521	#endif
1522	#if HIGHER_LAYER_IRAP_SKIP_FLAG
1523	READ_FLAG(uiCode, "higher_layer_irap_skip_flag" ); vps->setHigherLayerIrapSkipFlag(uiCode == 1 ? true : false);
1524	#endif
1525	#endif
1526
1527	#if P0307_REMOVE_VPS_VUI_OFFSET
1528	READ_FLAG( uiCode, "vps_vui_present_flag"); vps->setVpsVuiPresentFlag(uiCode ? true : false);
1529	#endif
1530
1531	#if O0109_MOVE_VPS_VUI_FLAG
1532	if ( vps->getVpsVuiPresentFlag() )
1533	#else
1534	READ_FLAG( uiCode, "vps_vui_present_flag" );
1535	if (uiCode)
1536	#endif
1537	{
1538	#if VPS_VUI
1539	while ( m_pcBitstream->getNumBitsRead() % 8 != 0 )
1540	{
1541	READ_FLAG( uiCode, "vps_vui_alignment_bit_equal_to_one"); assert(uiCode == 1);
1542	}
1543	parseVPSVUI(vps);
1544	#endif
1545	}
1546	}
1547	#endif
1548	#if REPN_FORMAT_IN_VPS
1549	Void TDecCavlc::parseRepFormat ( RepFormat *repFormat )
1550	{
1551	UInt uiCode;
1552	#if REPN_FORMAT_CONTROL_FLAG
1553	READ_FLAG ( uiCode, "chroma_and_bit_depth_vps_present_flag"); repFormat->setChromaAndBitDepthVpsPresentFlag(uiCode ? true : false);
1554	READ_CODE ( 16, uiCode, "pic_width_in_luma_samples" ); repFormat->setPicWidthVpsInLumaSamples ( uiCode );
1555	READ_CODE ( 16, uiCode, "pic_height_in_luma_samples" ); repFormat->setPicHeightVpsInLumaSamples( uiCode );
1556
1557	if( repFormat->getChromaAndBitDepthVpsPresentFlag() )
1558	{
1559	#if AUXILIARY_PICTURES
1560	READ_CODE( 2, uiCode, "chroma_format_idc" ); repFormat->setChromaFormatVpsIdc( ChromaFormat(uiCode) );
1561	#else
1562	READ_CODE( 2, uiCode, "chroma_format_idc" ); repFormat->setChromaFormatVpsIdc( uiCode );
1563	#endif
1564
1565	if( repFormat->getChromaFormatVpsIdc() == 3 )
1566	{
1567	READ_FLAG( uiCode, "separate_colour_plane_flag"); repFormat->setSeparateColourPlaneVpsFlag(uiCode ? true : false);
1568	}
1569
1570
1571	READ_CODE( 4, uiCode, "bit_depth_luma_minus8" ); repFormat->setBitDepthVpsLuma ( uiCode + 8 );
1572	READ_CODE( 4, uiCode, "bit_depth_chroma_minus8" ); repFormat->setBitDepthVpsChroma( uiCode + 8 );
1573	}
1574	#else
1575	#if AUXILIARY_PICTURES
1576	READ_CODE( 2, uiCode, "chroma_format_idc" ); repFormat->setChromaFormatVpsIdc( ChromaFormat(uiCode) );
1577	#else
1578	READ_CODE( 2, uiCode, "chroma_format_idc" ); repFormat->setChromaFormatVpsIdc( uiCode );
1579	#endif
1580
1581	if( repFormat->getChromaFormatVpsIdc() == 3 )
1582	{
1583	READ_FLAG( uiCode, "separate_colour_plane_flag"); repFormat->setSeparateColourPlaneVpsFlag(uiCode ? true : false);
1584	}
1585
1586	READ_CODE ( 16, uiCode, "pic_width_in_luma_samples" ); repFormat->setPicWidthVpsInLumaSamples ( uiCode );
1587	READ_CODE ( 16, uiCode, "pic_height_in_luma_samples" ); repFormat->setPicHeightVpsInLumaSamples( uiCode );
1588
1589	READ_CODE( 4, uiCode, "bit_depth_luma_minus8" ); repFormat->setBitDepthVpsLuma ( uiCode + 8 );
1590	READ_CODE( 4, uiCode, "bit_depth_chroma_minus8" ); repFormat->setBitDepthVpsChroma( uiCode + 8 );
1591	#endif
1592	}
1593	#endif
1594	#if VPS_DPB_SIZE_TABLE
1595	Void TDecCavlc::parseVpsDpbSizeTable( TComVPS *vps )
1596	{
1597	UInt uiCode;
1598	#if !RESOLUTION_BASED_DPB
1599	vps->deriveNumberOfSubDpbs();
1600	#endif
1601	for(Int i = 1; i < vps->getNumOutputLayerSets(); i++)
1602	{
1603	#if CHANGE_NUMSUBDPB_IDX
1604	Int layerSetIdxForOutputLayerSet = vps->getOutputLayerSetIdx( i );
1605	#endif
1606	READ_FLAG( uiCode, "sub_layer_flag_info_present_flag[i]"); vps->setSubLayerFlagInfoPresentFlag( i, uiCode ? true : false );
1607	for(Int j = 0; j < vps->getMaxTLayers(); j++)
1608	{
1609	if( j > 0 && vps->getSubLayerFlagInfoPresentFlag(i) )
1610	{
1611	READ_FLAG( uiCode, "sub_layer_dpb_info_present_flag[i]"); vps->setSubLayerDpbInfoPresentFlag( i, j, uiCode ? true : false);
1612	}
1613	else
1614	{
1615	if( j == 0 ) // Always signal for the first sub-layer
1616	{
1617	vps->setSubLayerDpbInfoPresentFlag( i, j, true );
1618	}
1619	else // if (j != 0) && !vps->getSubLayerFlagInfoPresentFlag(i)
1620	{
1621	vps->setSubLayerDpbInfoPresentFlag( i, j, false );
1622	}
1623	}
1624	if( vps->getSubLayerDpbInfoPresentFlag(i, j) ) // If sub-layer DPB information is present
1625	{
1626	#if CHANGE_NUMSUBDPB_IDX
1627	for(Int k = 0; k < vps->getNumSubDpbs(layerSetIdxForOutputLayerSet); k++)
1628	#else
1629	for(Int k = 0; k < vps->getNumSubDpbs(i); k++)
1630	#endif
1631	{
1632	READ_UVLC( uiCode, "max_vps_dec_pic_buffering_minus1[i][k][j]" ); vps->setMaxVpsDecPicBufferingMinus1( i, k, j, uiCode );
1633	}
1634	READ_UVLC( uiCode, "max_vps_num_reorder_pics[i][j]" ); vps->setMaxVpsNumReorderPics( i, j, uiCode);
1635	#if RESOLUTION_BASED_DPB
1636	if( vps->getNumSubDpbs(layerSetIdxForOutputLayerSet) != vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ) )
1637	{
1638	for(Int k = 0; k < vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ); k++)
1639	{
1640	READ_UVLC( uiCode, "max_vps_layer_dec_pic_buff_minus1[i][k][j]" ); vps->setMaxVpsLayerDecPicBuffMinus1( i, k, j, uiCode);
1641	}
1642	}
1643	else // vps->getNumSubDpbs(layerSetIdxForOutputLayerSet) == vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet )
1644	{
1645	for(Int k = 0; k < vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ); k++)
1646	{
1647	vps->setMaxVpsLayerDecPicBuffMinus1( i, k, j, vps->getMaxVpsDecPicBufferingMinus1( i, k, j));
1648	}
1649	}
1650	#endif
1651	READ_UVLC( uiCode, "max_vps_latency_increase_plus1[i][j]" ); vps->setMaxVpsLatencyIncreasePlus1( i, j, uiCode);
1652	}
1653	}
1654	}
1655	}
1656	#endif
1657	#if VPS_VUI
1658	Void TDecCavlc::parseVPSVUI(TComVPS *vps)
1659	{
1660	UInt i,j;
1661	UInt uiCode;
1662	#if O0223_PICTURE_TYPES_ALIGN_FLAG
1663	READ_FLAG(uiCode, "cross_layer_pic_type_aligned_flag" );
1664	vps->setCrossLayerPictureTypeAlignFlag(uiCode);
1665	if (!uiCode)
1666	{
1667	#endif
1668	#if IRAP_ALIGN_FLAG_IN_VPS_VUI
1669	READ_FLAG(uiCode, "cross_layer_irap_aligned_flag" );
1670	vps->setCrossLayerIrapAlignFlag(uiCode);
1671	#endif
1672	#if O0223_PICTURE_TYPES_ALIGN_FLAG
1673	}
1674	else
1675	{
1676	vps->setCrossLayerIrapAlignFlag(true);
1677	}
1678	#endif
1679	#if VPS_VUI_BITRATE_PICRATE
1680	READ_FLAG( uiCode, "bit_rate_present_vps_flag" ); vps->setBitRatePresentVpsFlag( uiCode ? true : false );
1681	READ_FLAG( uiCode, "pic_rate_present_vps_flag" ); vps->setPicRatePresentVpsFlag( uiCode ? true : false );
1682
1683	Bool parseFlag = vps->getBitRatePresentVpsFlag() \|\| vps->getPicRatePresentVpsFlag();
1684	{
1685	for( i = 0; i < vps->getNumLayerSets(); i++ )
1686	{
1687	for( j = 0; j < vps->getMaxTLayers(); j++ )
1688	{
1689	if( parseFlag && vps->getBitRatePresentVpsFlag() )
1690	{
1691	READ_FLAG( uiCode, "bit_rate_present_vps_flag[i][j]" ); vps->setBitRatePresentFlag( i, j, uiCode ? true : false );
1692	}
1693	else
1694	{
1695	vps->setBitRatePresentFlag( i, j, false );
1696	}
1697	if( parseFlag && vps->getPicRatePresentVpsFlag() )
1698	{
1699	READ_FLAG( uiCode, "pic_rate_present_vps_flag[i][j]" ); vps->setPicRatePresentFlag( i, j, uiCode ? true : false );
1700	}
1701	else
1702	{
1703	vps->setPicRatePresentFlag( i, j, false );
1704	}
1705	if( parseFlag && vps->getBitRatePresentFlag(i, j) )
1706	{
1707	READ_CODE( 16, uiCode, "avg_bit_rate[i][j]" ); vps->setAvgBitRate( i, j, uiCode );
1708	READ_CODE( 16, uiCode, "max_bit_rate[i][j]" ); vps->setMaxBitRate( i, j, uiCode );
1709	}
1710	else
1711	{
1712	vps->setAvgBitRate( i, j, 0 );
1713	vps->setMaxBitRate( i, j, 0 );
1714	}
1715	if( parseFlag && vps->getPicRatePresentFlag(i, j) )
1716	{
1717	READ_CODE( 2 , uiCode, "constant_pic_rate_idc[i][j]" ); vps->setConstPicRateIdc( i, j, uiCode );
1718	READ_CODE( 16, uiCode, "avg_pic_rate[i][j]" ); vps->setAvgPicRate( i, j, uiCode );
1719	}
1720	else
1721	{
1722	vps->setConstPicRateIdc( i, j, 0 );
1723	vps->setAvgPicRate ( i, j, 0 );
1724	}
1725	}
1726	}
1727	}
1728	#endif
1729	#if VPS_VUI_VIDEO_SIGNAL_MOVE
1730	READ_FLAG( uiCode, "video_signal_info_idx_present_flag" ); vps->setVideoSigPresentVpsFlag( uiCode == 1 );
1731	if (vps->getVideoSigPresentVpsFlag())
1732	{
1733	READ_CODE(4, uiCode, "vps_num_video_signal_info_minus1" ); vps->setNumVideoSignalInfo(uiCode + 1);
1734	}
1735	else
1736	{
1737	vps->setNumVideoSignalInfo(vps->getMaxLayers());
1738	}
1739
1740
1741	for(i = 0; i < vps->getNumVideoSignalInfo(); i++)
1742	{
1743	READ_CODE(3, uiCode, "video_vps_format" ); vps->setVideoVPSFormat(i,uiCode);
1744	READ_FLAG(uiCode, "video_full_range_vps_flag" ); vps->setVideoFullRangeVpsFlag(i,uiCode);
1745	READ_CODE(8, uiCode, "color_primaries_vps" ); vps->setColorPrimaries(i,uiCode);
1746	READ_CODE(8, uiCode, "transfer_characteristics_vps" ); vps->setTransCharacter(i,uiCode);
1747	READ_CODE(8, uiCode, "matrix_coeffs_vps" );vps->setMaxtrixCoeff(i,uiCode);
1748	}
1749	if(!vps->getVideoSigPresentVpsFlag())
1750	{
1751	for (i=0; i < vps->getMaxLayers(); i++)
1752	{
1753	vps->setVideoSignalInfoIdx(i,i);
1754	}
1755	}
1756	else {
1757	vps->setVideoSignalInfoIdx(0,0);
1758	if (vps->getNumVideoSignalInfo() > 1 )
1759	{
1760	for (i=1; i < vps->getMaxLayers(); i++)
1761	READ_CODE(4, uiCode, "vps_video_signal_info_idx" ); vps->setVideoSignalInfoIdx(i, uiCode);
1762	}
1763	else {
1764	for (i=1; i < vps->getMaxLayers(); i++)
1765	{
1766	vps->setVideoSignalInfoIdx(i,0);
1767	}
1768	}
1769	}
1770	#endif
1771	#if VPS_VUI_TILES_NOT_IN_USE__FLAG
1772	UInt layerIdx;
1773	READ_FLAG( uiCode, "tiles_not_in_use_flag" ); vps->setTilesNotInUseFlag(uiCode == 1);
1774	if (!uiCode)
1775	{
1776	for(i = 0; i < vps->getMaxLayers(); i++)
1777	{
1778	READ_FLAG( uiCode, "tiles_in_use_flag[ i ]" ); vps->setTilesInUseFlag(i, (uiCode == 1));
1779	if (uiCode)
1780	{
1781	READ_FLAG( uiCode, "loop_filter_not_across_tiles_flag[ i ]" ); vps->setLoopFilterNotAcrossTilesFlag(i, (uiCode == 1));
1782	}
1783	else
1784	{
1785	vps->setLoopFilterNotAcrossTilesFlag(i, false);
1786	}
1787	}
1788	#endif
1789	#if TILE_BOUNDARY_ALIGNED_FLAG
1790	for(i = 1; i < vps->getMaxLayers(); i++)
1791	{
1792	for(j = 0; j < vps->getNumDirectRefLayers(vps->getLayerIdInNuh(i)); j++)
1793	{
1794	#if VPS_VUI_TILES_NOT_IN_USE__FLAG
1795	layerIdx = vps->getLayerIdInVps(vps->getRefLayerId(vps->getLayerIdInNuh(i), j));
1796	if (vps->getTilesInUseFlag(i) && vps->getTilesInUseFlag(layerIdx)) {
1797	READ_FLAG( uiCode, "tile_boundaries_aligned_flag[i][j]" ); vps->setTileBoundariesAlignedFlag(i,j,(uiCode == 1));
1798	}
1799	#else
1800	READ_FLAG( uiCode, "tile_boundaries_aligned_flag[i][j]" ); vps->setTileBoundariesAlignedFlag(i,j,(uiCode == 1));
1801	#endif
1802	}
1803	}
1804	#endif
1805	#if VPS_VUI_TILES_NOT_IN_USE__FLAG
1806	}
1807	#endif
1808	#if VPS_VUI_WPP_NOT_IN_USE__FLAG
1809	READ_FLAG( uiCode, "wpp_not_in_use_flag" ); vps->setWppNotInUseFlag(uiCode == 1);
1810	if (!uiCode)
1811	{
1812	for(i = 0; i < vps->getMaxLayers(); i++)
1813	{
1814	READ_FLAG( uiCode, "wpp_in_use_flag[ i ]" ); vps->setWppInUseFlag(i, (uiCode == 1));
1815	}
1816	}
1817	#endif
1818
1819	#if O0109_O0199_FLAGS_TO_VUI
1820	#if M0040_ADAPTIVE_RESOLUTION_CHANGE
1821	READ_FLAG(uiCode, "single_layer_for_non_irap_flag" ); vps->setSingleLayerForNonIrapFlag(uiCode == 1 ? true : false);
1822	#endif
1823	#if HIGHER_LAYER_IRAP_SKIP_FLAG
1824	READ_FLAG(uiCode, "higher_layer_irap_skip_flag" ); vps->setHigherLayerIrapSkipFlag(uiCode == 1 ? true : false);
1825	#endif
1826	#endif
1827
1828	#if N0160_VUI_EXT_ILP_REF
1829	READ_FLAG( uiCode, "ilp_restricted_ref_layers_flag" ); vps->setIlpRestrictedRefLayersFlag( uiCode == 1 );
1830	if( vps->getIlpRestrictedRefLayersFlag())
1831	{
1832	for(i = 1; i < vps->getMaxLayers(); i++)
1833	{
1834	for(j = 0; j < vps->getNumDirectRefLayers(vps->getLayerIdInNuh(i)); j++)
1835	{
1836	READ_UVLC( uiCode, "min_spatial_segment_offset_plus1[i][j]" ); vps->setMinSpatialSegmentOffsetPlus1( i, j, uiCode );
1837	if( vps->getMinSpatialSegmentOffsetPlus1(i,j ) > 0 )
1838	{
1839	READ_FLAG( uiCode, "ctu_based_offset_enabled_flag[i][j]"); vps->setCtuBasedOffsetEnabledFlag(i, j, uiCode == 1 );
1840	if(vps->getCtuBasedOffsetEnabledFlag(i,j))
1841	{
1842	READ_UVLC( uiCode, "min_horizontal_ctu_offset_plus1[i][j]"); vps->setMinHorizontalCtuOffsetPlus1( i,j, uiCode );
1843	}
1844	}
1845	}
1846	}
1847	}
1848	#endif
1849	#if VPS_VUI_VIDEO_SIGNAL
1850	#if VPS_VUI_VIDEO_SIGNAL_MOVE
1851	#else
1852	READ_FLAG( uiCode, "video_signal_info_idx_present_flag" ); vps->setVideoSigPresentVpsFlag( uiCode == 1 );
1853	if (vps->getVideoSigPresentVpsFlag())
1854	{
1855	READ_CODE(4, uiCode, "vps_num_video_signal_info_minus1" ); vps->setNumVideoSignalInfo(uiCode + 1);
1856	}
1857	else
1858	{
1859	vps->setNumVideoSignalInfo(vps->getMaxLayers());
1860	}
1861
1862
1863	for(i = 0; i < vps->getNumVideoSignalInfo(); i++)
1864	{
1865	READ_CODE(3, uiCode, "video_vps_format" ); vps->setVideoVPSFormat(i,uiCode);
1866	READ_FLAG(uiCode, "video_full_range_vps_flag" ); vps->setVideoFullRangeVpsFlag(i,uiCode);
1867	READ_CODE(8, uiCode, "color_primaries_vps" ); vps->setColorPrimaries(i,uiCode);
1868	READ_CODE(8, uiCode, "transfer_characteristics_vps" ); vps->setTransCharacter(i,uiCode);
1869	READ_CODE(8, uiCode, "matrix_coeffs_vps" );vps->setMaxtrixCoeff(i,uiCode);
1870	}
1871	if(!vps->getVideoSigPresentVpsFlag())
1872	{
1873	for (i=0; i < vps->getMaxLayers(); i++)
1874	{
1875	vps->setVideoSignalInfoIdx(i,i);
1876	}
1877	}
1878	else {
1879	vps->setVideoSignalInfoIdx(0,0);
1880	if (vps->getNumVideoSignalInfo() > 1 )
1881	{
1882	for (i=1; i < vps->getMaxLayers(); i++)
1883	READ_CODE(4, uiCode, "vps_video_signal_info_idx" ); vps->setVideoSignalInfoIdx(i, uiCode);
1884	}
1885	else {
1886	for (i=1; i < vps->getMaxLayers(); i++)
1887	{
1888	vps->setVideoSignalInfoIdx(i,0);
1889	}
1890	}
1891	}
1892	#endif
1893	#endif
1894	}
1895	#endif
1896	#endif //SVC_EXTENSION
1897
1898	Void TDecCavlc::parseSliceHeader (TComSlice& rpcSlice, ParameterSetManagerDecoder parameterSetManager)
1899	{
1900	UInt uiCode;
1901	Int iCode;
1902
1903	#if ENC_DEC_TRACE
1904	xTraceSliceHeader(rpcSlice);
1905	#endif
1906	TComPPS* pps = NULL;
1907	TComSPS* sps = NULL;
1908
1909	UInt firstSliceSegmentInPic;
1910	READ_FLAG( firstSliceSegmentInPic, "first_slice_segment_in_pic_flag" );
1911	if( rpcSlice->getRapPicFlag())
1912	{
1913	READ_FLAG( uiCode, "no_output_of_prior_pics_flag" ); //ignored
1914	}
1915	READ_UVLC ( uiCode, "slice_pic_parameter_set_id" ); rpcSlice->setPPSId(uiCode);
1916	pps = parameterSetManager->getPrefetchedPPS(uiCode);
1917	//!KS: need to add error handling code here, if PPS is not available
1918	assert(pps!=0);
1919	sps = parameterSetManager->getPrefetchedSPS(pps->getSPSId());
1920	//!KS: need to add error handling code here, if SPS is not available
1921	assert(sps!=0);
1922	rpcSlice->setSPS(sps);
1923	rpcSlice->setPPS(pps);
1924	if( pps->getDependentSliceSegmentsEnabledFlag() && ( !firstSliceSegmentInPic ))
1925	{
1926	READ_FLAG( uiCode, "dependent_slice_segment_flag" ); rpcSlice->setDependentSliceSegmentFlag(uiCode ? true : false);
1927	}
1928	else
1929	{
1930	rpcSlice->setDependentSliceSegmentFlag(false);
1931	}
1932	#if REPN_FORMAT_IN_VPS
1933	Int numCTUs = ((rpcSlice->getPicWidthInLumaSamples()+sps->getMaxCUWidth()-1)/sps->getMaxCUWidth())*((rpcSlice->getPicHeightInLumaSamples()+sps->getMaxCUHeight()-1)/sps->getMaxCUHeight());
1934	#else
1935	Int numCTUs = ((sps->getPicWidthInLumaSamples()+sps->getMaxCUWidth()-1)/sps->getMaxCUWidth())*((sps->getPicHeightInLumaSamples()+sps->getMaxCUHeight()-1)/sps->getMaxCUHeight());
1936	#endif
1937	Int maxParts = (1<<(sps->getMaxCUDepth()<<1));
1938	UInt sliceSegmentAddress = 0;
1939	Int bitsSliceSegmentAddress = 0;
1940	while(numCTUs>(1<<bitsSliceSegmentAddress))
1941	{
1942	bitsSliceSegmentAddress++;
1943	}
1944
1945	if(!firstSliceSegmentInPic)
1946	{
1947	READ_CODE( bitsSliceSegmentAddress, sliceSegmentAddress, "slice_segment_address" );
1948	}
1949	//set uiCode to equal slice start address (or dependent slice start address)
1950	Int startCuAddress = maxParts*sliceSegmentAddress;
1951	rpcSlice->setSliceSegmentCurStartCUAddr( startCuAddress );
1952	rpcSlice->setSliceSegmentCurEndCUAddr(numCTUs*maxParts);
1953
1954	if (rpcSlice->getDependentSliceSegmentFlag())
1955	{
1956	rpcSlice->setNextSlice ( false );
1957	rpcSlice->setNextSliceSegment ( true );
1958	}
1959	else
1960	{
1961	rpcSlice->setNextSlice ( true );
1962	rpcSlice->setNextSliceSegment ( false );
1963
1964	rpcSlice->setSliceCurStartCUAddr(startCuAddress);
1965	rpcSlice->setSliceCurEndCUAddr(numCTUs*maxParts);
1966	}
1967
1968	if(!rpcSlice->getDependentSliceSegmentFlag())
1969	{
1970	#if SVC_EXTENSION
1971	#if POC_RESET_FLAG
1972	Int iBits = 0;
1973	if(rpcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits)
1974	{
1975	READ_FLAG(uiCode, "poc_reset_flag"); rpcSlice->setPocResetFlag( uiCode ? true : false );
1976	iBits++;
1977	}
1978	if(rpcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits)
1979	{
1980	#if DISCARDABLE_PIC_RPS
1981	READ_FLAG(uiCode, "discardable_flag"); rpcSlice->setDiscardableFlag( uiCode ? true : false );
1982	#else
1983	READ_FLAG(uiCode, "discardable_flag"); // ignored
1984	#endif
1985	iBits++;
1986	}
1987	#if O0149_CROSS_LAYER_BLA_FLAG
1988	if(rpcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits)
1989	{
1990	READ_FLAG(uiCode, "cross_layer_bla_flag"); rpcSlice->setCrossLayerBLAFlag( uiCode ? true : false );
1991	iBits++;
1992	}
1993	#endif
1994	for (; iBits < rpcSlice->getPPS()->getNumExtraSliceHeaderBits(); iBits++)
1995	{
1996	READ_FLAG(uiCode, "slice_reserved_undetermined_flag[]"); // ignored
1997	}
1998	#else
1999	if(rpcSlice->getPPS()->getNumExtraSliceHeaderBits()>0)
2000	{
2001	READ_FLAG(uiCode, "discardable_flag"); // ignored
2002	}
2003	for (Int i = 1; i < rpcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
2004	{
2005	READ_FLAG(uiCode, "slice_reserved_undetermined_flag[]"); // ignored
2006	}
2007	#endif
2008	#else //SVC_EXTENSION
2009	for (Int i = 0; i < rpcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
2010	{
2011	READ_FLAG(uiCode, "slice_reserved_undetermined_flag[]"); // ignored
2012	}
2013	#endif //SVC_EXTENSION
2014
2015	READ_UVLC ( uiCode, "slice_type" ); rpcSlice->setSliceType((SliceType)uiCode);
2016	if( pps->getOutputFlagPresentFlag() )
2017	{
2018	READ_FLAG( uiCode, "pic_output_flag" ); rpcSlice->setPicOutputFlag( uiCode ? true : false );
2019	}
2020	else
2021	{
2022	rpcSlice->setPicOutputFlag( true );
2023	}
2024	// in the first version chroma_format_idc is equal to one, thus colour_plane_id will not be present
2025	assert (sps->getChromaFormatIdc() == 1 );
2026	// if( separate_colour_plane_flag == 1 )
2027	// colour_plane_id u(2)
2028
2029	if( rpcSlice->getIdrPicFlag() )
2030	{
2031	rpcSlice->setPOC(0);
2032	TComReferencePictureSet* rps = rpcSlice->getLocalRPS();
2033	rps->setNumberOfNegativePictures(0);
2034	rps->setNumberOfPositivePictures(0);
2035	rps->setNumberOfLongtermPictures(0);
2036	rps->setNumberOfPictures(0);
2037	rpcSlice->setRPS(rps);
2038	}
2039	#if N0065_LAYER_POC_ALIGNMENT
2040	#if SHM_FIX7
2041	Int iPOClsb = 0;
2042	#endif
2043	#if O0062_POC_LSB_NOT_PRESENT_FLAG
2044	if( ( rpcSlice->getLayerId() > 0 && !rpcSlice->getVPS()->getPocLsbNotPresentFlag( rpcSlice->getVPS()->getLayerIdInVps(rpcSlice->getLayerId())) ) \|\| !rpcSlice->getIdrPicFlag())
2045	#else
2046	if( rpcSlice->getLayerId() > 0 \|\| !rpcSlice->getIdrPicFlag() )
2047	#endif
2048	#else
2049	else
2050	#endif
2051	{
2052	READ_CODE(sps->getBitsForPOC(), uiCode, "pic_order_cnt_lsb");
2053	#if SHM_FIX7
2054	iPOClsb = uiCode;
2055	#else
2056	Int iPOClsb = uiCode;
2057	#endif
2058	Int iPrevPOC = rpcSlice->getPrevTid0POC();
2059	Int iMaxPOClsb = 1<< sps->getBitsForPOC();
2060	Int iPrevPOClsb = iPrevPOC & (iMaxPOClsb - 1);
2061	Int iPrevPOCmsb = iPrevPOC-iPrevPOClsb;
2062	Int iPOCmsb;
2063	if( ( iPOClsb < iPrevPOClsb ) && ( ( iPrevPOClsb - iPOClsb ) >= ( iMaxPOClsb / 2 ) ) )
2064	{
2065	iPOCmsb = iPrevPOCmsb + iMaxPOClsb;
2066	}
2067	else if( (iPOClsb > iPrevPOClsb ) && ( (iPOClsb - iPrevPOClsb ) > ( iMaxPOClsb / 2 ) ) )
2068	{
2069	iPOCmsb = iPrevPOCmsb - iMaxPOClsb;
2070	}
2071	else
2072	{
2073	iPOCmsb = iPrevPOCmsb;
2074	}
2075	if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
2076	\|\| rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
2077	\|\| rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
2078	{
2079	// For BLA picture types, POCmsb is set to 0.
2080	iPOCmsb = 0;
2081	}
2082	rpcSlice->setPOC (iPOCmsb+iPOClsb);
2083
2084	#if N0065_LAYER_POC_ALIGNMENT
2085	#if SHM_FIX7
2086	}
2087	#endif
2088	if( !rpcSlice->getIdrPicFlag() )
2089	{
2090	#endif
2091	TComReferencePictureSet* rps;
2092	rps = rpcSlice->getLocalRPS();
2093	rpcSlice->setRPS(rps);
2094	READ_FLAG( uiCode, "short_term_ref_pic_set_sps_flag" );
2095	if(uiCode == 0) // use short-term reference picture set explicitly signalled in slice header
2096	{
2097	parseShortTermRefPicSet(sps,rps, sps->getRPSList()->getNumberOfReferencePictureSets());
2098	}
2099	else // use reference to short-term reference picture set in PPS
2100	{
2101	Int numBits = 0;
2102	while ((1 << numBits) < rpcSlice->getSPS()->getRPSList()->getNumberOfReferencePictureSets())
2103	{
2104	numBits++;
2105	}
2106	if (numBits > 0)
2107	{
2108	READ_CODE( numBits, uiCode, "short_term_ref_pic_set_idx");
2109	}
2110	else
2111	{
2112	uiCode = 0;
2113	}
2114	rps = (sps->getRPSList()->getReferencePictureSet(uiCode));
2115	}
2116	if(sps->getLongTermRefsPresent())
2117	{
2118	Int offset = rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures();
2119	UInt numOfLtrp = 0;
2120	UInt numLtrpInSPS = 0;
2121	if (rpcSlice->getSPS()->getNumLongTermRefPicSPS() > 0)
2122	{
2123	READ_UVLC( uiCode, "num_long_term_sps");
2124	numLtrpInSPS = uiCode;
2125	numOfLtrp += numLtrpInSPS;
2126	rps->setNumberOfLongtermPictures(numOfLtrp);
2127	}
2128	Int bitsForLtrpInSPS = 0;
2129	while (rpcSlice->getSPS()->getNumLongTermRefPicSPS() > (1 << bitsForLtrpInSPS))
2130	{
2131	bitsForLtrpInSPS++;
2132	}
2133	READ_UVLC( uiCode, "num_long_term_pics"); rps->setNumberOfLongtermPictures(uiCode);
2134	numOfLtrp += uiCode;
2135	rps->setNumberOfLongtermPictures(numOfLtrp);
2136	Int maxPicOrderCntLSB = 1 << rpcSlice->getSPS()->getBitsForPOC();
2137	Int prevDeltaMSB = 0, deltaPocMSBCycleLT = 0;;
2138	for(Int j=offset+rps->getNumberOfLongtermPictures()-1, k = 0; k < numOfLtrp; j--, k++)
2139	{
2140	Int pocLsbLt;
2141	if (k < numLtrpInSPS)
2142	{
2143	uiCode = 0;
2144	if (bitsForLtrpInSPS > 0)
2145	{
2146	READ_CODE(bitsForLtrpInSPS, uiCode, "lt_idx_sps[i]");
2147	}
2148	Int usedByCurrFromSPS=rpcSlice->getSPS()->getUsedByCurrPicLtSPSFlag(uiCode);
2149
2150	pocLsbLt = rpcSlice->getSPS()->getLtRefPicPocLsbSps(uiCode);
2151	rps->setUsed(j,usedByCurrFromSPS);
2152	}
2153	else
2154	{
2155	READ_CODE(rpcSlice->getSPS()->getBitsForPOC(), uiCode, "poc_lsb_lt"); pocLsbLt= uiCode;
2156	READ_FLAG( uiCode, "used_by_curr_pic_lt_flag"); rps->setUsed(j,uiCode);
2157	}
2158	READ_FLAG(uiCode,"delta_poc_msb_present_flag");
2159	Bool mSBPresentFlag = uiCode ? true : false;
2160	if(mSBPresentFlag)
2161	{
2162	READ_UVLC( uiCode, "delta_poc_msb_cycle_lt[i]" );
2163	Bool deltaFlag = false;
2164	// First LTRP \|\| First LTRP from SH
2165	if( (j == offset+rps->getNumberOfLongtermPictures()-1) \|\| (j == offset+(numOfLtrp-numLtrpInSPS)-1) )
2166	{
2167	deltaFlag = true;
2168	}
2169	if(deltaFlag)
2170	{
2171	deltaPocMSBCycleLT = uiCode;
2172	}
2173	else
2174	{
2175	deltaPocMSBCycleLT = uiCode + prevDeltaMSB;
2176	}
2177
2178	Int pocLTCurr = rpcSlice->getPOC() - deltaPocMSBCycleLT * maxPicOrderCntLSB
2179	- iPOClsb + pocLsbLt;
2180	rps->setPOC (j, pocLTCurr);
2181	rps->setDeltaPOC(j, - rpcSlice->getPOC() + pocLTCurr);
2182	rps->setCheckLTMSBPresent(j,true);
2183	}
2184	else
2185	{
2186	rps->setPOC (j, pocLsbLt);
2187	rps->setDeltaPOC(j, - rpcSlice->getPOC() + pocLsbLt);
2188	rps->setCheckLTMSBPresent(j,false);
2189
2190	// reset deltaPocMSBCycleLT for first LTRP from slice header if MSB not present
2191	if( j == offset+(numOfLtrp-numLtrpInSPS)-1 )
2192	{
2193	deltaPocMSBCycleLT = 0;
2194	}
2195	}
2196	prevDeltaMSB = deltaPocMSBCycleLT;
2197	}
2198	offset += rps->getNumberOfLongtermPictures();
2199	rps->setNumberOfPictures(offset);
2200	}
2201	if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
2202	\|\| rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
2203	\|\| rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
2204	{
2205	// In the case of BLA picture types, rps data is read from slice header but ignored
2206	rps = rpcSlice->getLocalRPS();
2207	rps->setNumberOfNegativePictures(0);
2208	rps->setNumberOfPositivePictures(0);
2209	rps->setNumberOfLongtermPictures(0);
2210	rps->setNumberOfPictures(0);
2211	rpcSlice->setRPS(rps);
2212	}
2213	if (rpcSlice->getSPS()->getTMVPFlagsPresent())
2214	{
2215	READ_FLAG( uiCode, "slice_temporal_mvp_enable_flag" );
2216	rpcSlice->setEnableTMVPFlag( uiCode == 1 ? true : false );
2217	}
2218	else
2219	{
2220	rpcSlice->setEnableTMVPFlag(false);
2221	}
2222	#if N0065_LAYER_POC_ALIGNMENT && !SHM_FIX7
2223	}
2224	#endif
2225	}
2226
2227	#if SVC_EXTENSION
2228	rpcSlice->setActiveNumILRRefIdx(0);
2229	#if ILP_SSH_SIG
2230	#if ILP_SSH_SIG_FIX
2231	if((sps->getLayerId() > 0) && !(rpcSlice->getVPS()->getIlpSshSignalingEnabledFlag()) && (rpcSlice->getNumILRRefIdx() > 0) )
2232	#else
2233	if((sps->getLayerId() > 0) && rpcSlice->getVPS()->getIlpSshSignalingEnabledFlag() && (rpcSlice->getNumILRRefIdx() > 0) )
2234	#endif
2235	#else
2236	if((sps->getLayerId() > 0) && (rpcSlice->getNumILRRefIdx() > 0) )
2237	#endif
2238	{
2239	READ_FLAG(uiCode,"inter_layer_pred_enabled_flag");
2240	rpcSlice->setInterLayerPredEnabledFlag(uiCode);
2241	if( rpcSlice->getInterLayerPredEnabledFlag())
2242	{
2243	if(rpcSlice->getNumILRRefIdx() > 1)
2244	{
2245	Int numBits = 1;
2246	while ((1 << numBits) < rpcSlice->getNumILRRefIdx())
2247	{
2248	numBits++;
2249	}
2250	if( !rpcSlice->getVPS()->getMaxOneActiveRefLayerFlag())
2251	{
2252	READ_CODE( numBits, uiCode,"num_inter_layer_ref_pics_minus1" );
2253	rpcSlice->setActiveNumILRRefIdx(uiCode + 1);
2254	}
2255	else
2256	{
2257	#if P0079_DERIVE_NUMACTIVE_REF_PICS
2258	Int numRefLayerPics = 0;
2259	Int i = 0;
2260	Int refLayerPicIdc [MAX_VPS_LAYER_ID_PLUS1];
2261	for(i = 0, numRefLayerPics = 0; i < rpcSlice->getNumILRRefIdx(); i++ )
2262	{
2263	if(rpcSlice->getVPS()->getMaxTidIlRefPicsPlus1(rpcSlice->getVPS()->getLayerIdInVps(i),rpcSlice->getLayerId()) > rpcSlice->getTLayer() &&
2264	(rpcSlice->getVPS()->getMaxTSLayersMinus1(rpcSlice->getVPS()->getLayerIdInVps(i)) >= rpcSlice->getTLayer()) )
2265	{
2266	refLayerPicIdc[ numRefLayerPics++ ] = i;
2267	}
2268	}
2269	if (numRefLayerPics)
2270	rpcSlice->setActiveNumILRRefIdx(1);
2271	#else
2272	rpcSlice->setActiveNumILRRefIdx(1);
2273	#endif
2274	}
2275	#if ILP_NUM_REF_CHK
2276	if( rpcSlice->getActiveNumILRRefIdx() == rpcSlice->getNumILRRefIdx() )
2277	{
2278	for( Int i = 0; i < rpcSlice->getActiveNumILRRefIdx(); i++ )
2279	{
2280	rpcSlice->setInterLayerPredLayerIdc(i,i);
2281	}
2282	}
2283	else
2284	{
2285	#endif
2286	for(Int i = 0; i < rpcSlice->getActiveNumILRRefIdx(); i++ )
2287	{
2288	READ_CODE( numBits,uiCode,"inter_layer_pred_layer_idc[i]" );
2289	rpcSlice->setInterLayerPredLayerIdc(uiCode,i);
2290	}
2291	#if ILP_NUM_REF_CHK
2292	}
2293	#endif
2294	}
2295	else
2296	{
2297	#if O0225_TID_BASED_IL_RPS_DERIV && TSLAYERS_IL_RPS
2298	if( (rpcSlice->getVPS()->getMaxTidIlRefPicsPlus1(0,rpcSlice->getLayerId()) > rpcSlice->getTLayer()) &&
2299	(rpcSlice->getVPS()->getMaxTSLayersMinus1(0) >= rpcSlice->getTLayer()) )
2300	{
2301	#endif
2302	rpcSlice->setActiveNumILRRefIdx(1);
2303	rpcSlice->setInterLayerPredLayerIdc(0,0);
2304	#if O0225_TID_BASED_IL_RPS_DERIV && TSLAYERS_IL_RPS
2305	}
2306	#endif
2307	}
2308	}
2309	}
2310	#if ILP_SSH_SIG
2311	#if ILP_SSH_SIG_FIX
2312	else if( rpcSlice->getVPS()->getIlpSshSignalingEnabledFlag() == true && (rpcSlice->getLayerId() > 0 ))
2313	#else
2314	else if( rpcSlice->getVPS()->getIlpSshSignalingEnabledFlag() == false )
2315	#endif
2316	{
2317	rpcSlice->setInterLayerPredEnabledFlag(true);
2318
2319	#if O0225_TID_BASED_IL_RPS_DERIV && TSLAYERS_IL_RPS
2320	Int numRefLayerPics = 0;
2321	Int i = 0;
2322	Int refLayerPicIdc [MAX_VPS_LAYER_ID_PLUS1];
2323	for(i = 0, numRefLayerPics = 0; i < rpcSlice->getNumILRRefIdx(); i++ )
2324	{
2325	if(rpcSlice->getVPS()->getMaxTidIlRefPicsPlus1(rpcSlice->getVPS()->getLayerIdInVps(i),rpcSlice->getLayerId()) > rpcSlice->getTLayer() &&
2326	(rpcSlice->getVPS()->getMaxTSLayersMinus1(rpcSlice->getVPS()->getLayerIdInVps(i)) >= rpcSlice->getTLayer()) )
2327	{
2328	refLayerPicIdc[ numRefLayerPics++ ] = i;
2329	}
2330	}
2331	rpcSlice->setActiveNumILRRefIdx(numRefLayerPics);
2332	for( i = 0; i < rpcSlice->getActiveNumILRRefIdx(); i++ )
2333	{
2334	rpcSlice->setInterLayerPredLayerIdc(refLayerPicIdc[i],i);
2335	}
2336	#else
2337	rpcSlice->setActiveNumILRRefIdx(rpcSlice->getNumILRRefIdx());
2338	for( Int i = 0; i < rpcSlice->getActiveNumILRRefIdx(); i++ )
2339	{
2340	rpcSlice->setInterLayerPredLayerIdc(i,i);
2341	}
2342	#endif
2343	}
2344	#endif
2345	#endif
2346
2347	if(sps->getUseSAO())
2348	{
2349	READ_FLAG(uiCode, "slice_sao_luma_flag"); rpcSlice->setSaoEnabledFlag((Bool)uiCode);
2350	#if AUXILIARY_PICTURES
2351	ChromaFormat format;
2352	#if REPN_FORMAT_IN_VPS
2353	#if O0096_REP_FORMAT_INDEX
2354	if( sps->getLayerId() == 0 )
2355	{
2356	format = sps->getChromaFormatIdc();
2357	}
2358	else
2359	{
2360	format = rpcSlice->getVPS()->getVpsRepFormat( sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : rpcSlice->getVPS()->getVpsRepFormatIdx(sps->getLayerId()) )->getChromaFormatVpsIdc();
2361	}
2362	#else
2363	if( ( sps->getLayerId() == 0 ) \|\| sps->getUpdateRepFormatFlag() )
2364	{
2365	format = sps->getChromaFormatIdc();
2366	}
2367	else
2368	{
2369	format = rpcSlice->getVPS()->getVpsRepFormat( rpcSlice->getVPS()->getVpsRepFormatIdx(sps->getLayerId()) )->getChromaFormatVpsIdc();
2370	}
2371	#endif
2372	#else
2373	format = sps->getChromaFormatIdc();
2374	#endif
2375	if (format != CHROMA_400)
2376	{
2377	#endif
2378	READ_FLAG(uiCode, "slice_sao_chroma_flag"); rpcSlice->setSaoEnabledFlagChroma((Bool)uiCode);
2379	#if AUXILIARY_PICTURES
2380	}
2381	else
2382	{
2383	rpcSlice->setSaoEnabledFlagChroma(false);
2384	}
2385	#endif
2386	}
2387
2388	if (rpcSlice->getIdrPicFlag())
2389	{
2390	rpcSlice->setEnableTMVPFlag(false);
2391	}
2392	if (!rpcSlice->isIntra())
2393	{
2394
2395	READ_FLAG( uiCode, "num_ref_idx_active_override_flag");
2396	if (uiCode)
2397	{
2398	READ_UVLC (uiCode, "num_ref_idx_l0_active_minus1" ); rpcSlice->setNumRefIdx( REF_PIC_LIST_0, uiCode + 1 );
2399	if (rpcSlice->isInterB())
2400	{
2401	READ_UVLC (uiCode, "num_ref_idx_l1_active_minus1" ); rpcSlice->setNumRefIdx( REF_PIC_LIST_1, uiCode + 1 );
2402	}
2403	else
2404	{
2405	rpcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
2406	}
2407	}
2408	else
2409	{
2410	rpcSlice->setNumRefIdx(REF_PIC_LIST_0, rpcSlice->getPPS()->getNumRefIdxL0DefaultActive());
2411	if (rpcSlice->isInterB())
2412	{
2413	rpcSlice->setNumRefIdx(REF_PIC_LIST_1, rpcSlice->getPPS()->getNumRefIdxL1DefaultActive());
2414	}
2415	else
2416	{
2417	rpcSlice->setNumRefIdx(REF_PIC_LIST_1,0);
2418	}
2419	}
2420	}
2421	// }
2422	TComRefPicListModification* refPicListModification = rpcSlice->getRefPicListModification();
2423	if(!rpcSlice->isIntra())
2424	{
2425	if( !rpcSlice->getPPS()->getListsModificationPresentFlag() \|\| rpcSlice->getNumRpsCurrTempList() <= 1 )
2426	{
2427	refPicListModification->setRefPicListModificationFlagL0( 0 );
2428	}
2429	else
2430	{
2431	READ_FLAG( uiCode, "ref_pic_list_modification_flag_l0" ); refPicListModification->setRefPicListModificationFlagL0( uiCode ? 1 : 0 );
2432	}
2433
2434	if(refPicListModification->getRefPicListModificationFlagL0())
2435	{
2436	uiCode = 0;
2437	Int i = 0;
2438	Int numRpsCurrTempList0 = rpcSlice->getNumRpsCurrTempList();
2439	if ( numRpsCurrTempList0 > 1 )
2440	{
2441	Int length = 1;
2442	numRpsCurrTempList0 --;
2443	while ( numRpsCurrTempList0 >>= 1)
2444	{
2445	length ++;
2446	}
2447	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
2448	{
2449	READ_CODE( length, uiCode, "list_entry_l0" );
2450	refPicListModification->setRefPicSetIdxL0(i, uiCode );
2451	}
2452	}
2453	else
2454	{
2455	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
2456	{
2457	refPicListModification->setRefPicSetIdxL0(i, 0 );
2458	}
2459	}
2460	}
2461	}
2462	else
2463	{
2464	refPicListModification->setRefPicListModificationFlagL0(0);
2465	}
2466	if(rpcSlice->isInterB())
2467	{
2468	if( !rpcSlice->getPPS()->getListsModificationPresentFlag() \|\| rpcSlice->getNumRpsCurrTempList() <= 1 )
2469	{
2470	refPicListModification->setRefPicListModificationFlagL1( 0 );
2471	}
2472	else
2473	{
2474	READ_FLAG( uiCode, "ref_pic_list_modification_flag_l1" ); refPicListModification->setRefPicListModificationFlagL1( uiCode ? 1 : 0 );
2475	}
2476	if(refPicListModification->getRefPicListModificationFlagL1())
2477	{
2478	uiCode = 0;
2479	Int i = 0;
2480	Int numRpsCurrTempList1 = rpcSlice->getNumRpsCurrTempList();
2481	if ( numRpsCurrTempList1 > 1 )
2482	{
2483	Int length = 1;
2484	numRpsCurrTempList1 --;
2485	while ( numRpsCurrTempList1 >>= 1)
2486	{
2487	length ++;
2488	}
2489	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
2490	{
2491	READ_CODE( length, uiCode, "list_entry_l1" );
2492	refPicListModification->setRefPicSetIdxL1(i, uiCode );
2493	}
2494	}
2495	else
2496	{
2497	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
2498	{
2499	refPicListModification->setRefPicSetIdxL1(i, 0 );
2500	}
2501	}
2502	}
2503	}
2504	else
2505	{
2506	refPicListModification->setRefPicListModificationFlagL1(0);
2507	}
2508	if (rpcSlice->isInterB())
2509	{
2510	READ_FLAG( uiCode, "mvd_l1_zero_flag" ); rpcSlice->setMvdL1ZeroFlag( (uiCode ? true : false) );
2511	}
2512
2513	rpcSlice->setCabacInitFlag( false ); // default
2514	if(pps->getCabacInitPresentFlag() && !rpcSlice->isIntra())
2515	{
2516	READ_FLAG(uiCode, "cabac_init_flag");
2517	rpcSlice->setCabacInitFlag( uiCode ? true : false );
2518	}
2519
2520	if ( rpcSlice->getEnableTMVPFlag() )
2521	{
2522	#if SVC_EXTENSION && REF_IDX_MFM
2523	// set motion mapping flag
2524	rpcSlice->setMFMEnabledFlag( ( rpcSlice->getNumMotionPredRefLayers() > 0 && rpcSlice->getActiveNumILRRefIdx() ) ? true : false );
2525	#endif
2526	if ( rpcSlice->getSliceType() == B_SLICE )
2527	{
2528	READ_FLAG( uiCode, "collocated_from_l0_flag" );
2529	rpcSlice->setColFromL0Flag(uiCode);
2530	}
2531	else
2532	{
2533	rpcSlice->setColFromL0Flag( 1 );
2534	}
2535
2536	if ( rpcSlice->getSliceType() != I_SLICE &&
2537	((rpcSlice->getColFromL0Flag() == 1 && rpcSlice->getNumRefIdx(REF_PIC_LIST_0) > 1)\|\|
2538	(rpcSlice->getColFromL0Flag() == 0 && rpcSlice->getNumRefIdx(REF_PIC_LIST_1) > 1)))
2539	{
2540	READ_UVLC( uiCode, "collocated_ref_idx" );
2541	rpcSlice->setColRefIdx(uiCode);
2542	}
2543	else
2544	{
2545	rpcSlice->setColRefIdx(0);
2546	}
2547	}
2548	if ( (pps->getUseWP() && rpcSlice->getSliceType()==P_SLICE) \|\| (pps->getWPBiPred() && rpcSlice->getSliceType()==B_SLICE) )
2549	{
2550	xParsePredWeightTable(rpcSlice);
2551	rpcSlice->initWpScaling();
2552	}
2553	if (!rpcSlice->isIntra())
2554	{
2555	READ_UVLC( uiCode, "five_minus_max_num_merge_cand");
2556	rpcSlice->setMaxNumMergeCand(MRG_MAX_NUM_CANDS - uiCode);
2557	}
2558
2559	READ_SVLC( iCode, "slice_qp_delta" );
2560	rpcSlice->setSliceQp (26 + pps->getPicInitQPMinus26() + iCode);
2561
2562	#if REPN_FORMAT_IN_VPS
2563	#if O0194_DIFFERENT_BITDEPTH_EL_BL
2564	g_bitDepthYLayer[rpcSlice->getLayerId()] = rpcSlice->getBitDepthY();
2565	g_bitDepthCLayer[rpcSlice->getLayerId()] = rpcSlice->getBitDepthC();
2566	#endif
2567	assert( rpcSlice->getSliceQp() >= -rpcSlice->getQpBDOffsetY() );
2568	#else
2569	assert( rpcSlice->getSliceQp() >= -sps->getQpBDOffsetY() );
2570	#endif
2571	assert( rpcSlice->getSliceQp() <= 51 );
2572
2573	if (rpcSlice->getPPS()->getSliceChromaQpFlag())
2574	{
2575	READ_SVLC( iCode, "slice_qp_delta_cb" );
2576	rpcSlice->setSliceQpDeltaCb( iCode );
2577	assert( rpcSlice->getSliceQpDeltaCb() >= -12 );
2578	assert( rpcSlice->getSliceQpDeltaCb() <= 12 );
2579	assert( (rpcSlice->getPPS()->getChromaCbQpOffset() + rpcSlice->getSliceQpDeltaCb()) >= -12 );
2580	assert( (rpcSlice->getPPS()->getChromaCbQpOffset() + rpcSlice->getSliceQpDeltaCb()) <= 12 );
2581
2582	READ_SVLC( iCode, "slice_qp_delta_cr" );
2583	rpcSlice->setSliceQpDeltaCr( iCode );
2584	assert( rpcSlice->getSliceQpDeltaCr() >= -12 );
2585	assert( rpcSlice->getSliceQpDeltaCr() <= 12 );
2586	assert( (rpcSlice->getPPS()->getChromaCrQpOffset() + rpcSlice->getSliceQpDeltaCr()) >= -12 );
2587	assert( (rpcSlice->getPPS()->getChromaCrQpOffset() + rpcSlice->getSliceQpDeltaCr()) <= 12 );
2588	}
2589
2590	if (rpcSlice->getPPS()->getDeblockingFilterControlPresentFlag())
2591	{
2592	if(rpcSlice->getPPS()->getDeblockingFilterOverrideEnabledFlag())
2593	{
2594	READ_FLAG ( uiCode, "deblocking_filter_override_flag" ); rpcSlice->setDeblockingFilterOverrideFlag(uiCode ? true : false);
2595	}
2596	else
2597	{
2598	rpcSlice->setDeblockingFilterOverrideFlag(0);
2599	}
2600	if(rpcSlice->getDeblockingFilterOverrideFlag())
2601	{
2602	READ_FLAG ( uiCode, "slice_disable_deblocking_filter_flag" ); rpcSlice->setDeblockingFilterDisable(uiCode ? 1 : 0);
2603	if(!rpcSlice->getDeblockingFilterDisable())
2604	{
2605	READ_SVLC( iCode, "slice_beta_offset_div2" ); rpcSlice->setDeblockingFilterBetaOffsetDiv2(iCode);
2606	assert(rpcSlice->getDeblockingFilterBetaOffsetDiv2() >= -6 &&
2607	rpcSlice->getDeblockingFilterBetaOffsetDiv2() <= 6);
2608	READ_SVLC( iCode, "slice_tc_offset_div2" ); rpcSlice->setDeblockingFilterTcOffsetDiv2(iCode);
2609	assert(rpcSlice->getDeblockingFilterTcOffsetDiv2() >= -6 &&
2610	rpcSlice->getDeblockingFilterTcOffsetDiv2() <= 6);
2611	}
2612	}
2613	else
2614	{
2615	rpcSlice->setDeblockingFilterDisable ( rpcSlice->getPPS()->getPicDisableDeblockingFilterFlag() );
2616	rpcSlice->setDeblockingFilterBetaOffsetDiv2( rpcSlice->getPPS()->getDeblockingFilterBetaOffsetDiv2() );
2617	rpcSlice->setDeblockingFilterTcOffsetDiv2 ( rpcSlice->getPPS()->getDeblockingFilterTcOffsetDiv2() );
2618	}
2619	}
2620	else
2621	{
2622	rpcSlice->setDeblockingFilterDisable ( false );
2623	rpcSlice->setDeblockingFilterBetaOffsetDiv2( 0 );
2624	rpcSlice->setDeblockingFilterTcOffsetDiv2 ( 0 );
2625	}
2626
2627	Bool isSAOEnabled = (!rpcSlice->getSPS()->getUseSAO())?(false):(rpcSlice->getSaoEnabledFlag()\|\|rpcSlice->getSaoEnabledFlagChroma());
2628	Bool isDBFEnabled = (!rpcSlice->getDeblockingFilterDisable());
2629
2630	if(rpcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag() && ( isSAOEnabled \|\| isDBFEnabled ))
2631	{
2632	READ_FLAG( uiCode, "slice_loop_filter_across_slices_enabled_flag");
2633	}
2634	else
2635	{
2636	uiCode = rpcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag()?1:0;
2637	}
2638	rpcSlice->setLFCrossSliceBoundaryFlag( (uiCode==1)?true:false);
2639
2640	}
2641
2642	UInt *entryPointOffset = NULL;
2643	UInt numEntryPointOffsets, offsetLenMinus1;
2644	if( pps->getTilesEnabledFlag() \|\| pps->getEntropyCodingSyncEnabledFlag() )
2645	{
2646	READ_UVLC(numEntryPointOffsets, "num_entry_point_offsets"); rpcSlice->setNumEntryPointOffsets ( numEntryPointOffsets );
2647	if (numEntryPointOffsets>0)
2648	{
2649	READ_UVLC(offsetLenMinus1, "offset_len_minus1");
2650	}
2651	entryPointOffset = new UInt[numEntryPointOffsets];
2652	for (UInt idx=0; idx<numEntryPointOffsets; idx++)
2653	{
2654	READ_CODE(offsetLenMinus1+1, uiCode, "entry_point_offset_minus1");
2655	entryPointOffset[ idx ] = uiCode + 1;
2656	}
2657	}
2658	else
2659	{
2660	rpcSlice->setNumEntryPointOffsets ( 0 );
2661	}
2662
2663	if(pps->getSliceHeaderExtensionPresentFlag())
2664	{
2665	READ_UVLC(uiCode,"slice_header_extension_length");
2666	for(Int i=0; i<uiCode; i++)
2667	{
2668	UInt ignore;
2669	READ_CODE(8,ignore,"slice_header_extension_data_byte");
2670	}
2671	}
2672	m_pcBitstream->readByteAlignment();
2673
2674	if( pps->getTilesEnabledFlag() \|\| pps->getEntropyCodingSyncEnabledFlag() )
2675	{
2676	Int endOfSliceHeaderLocation = m_pcBitstream->getByteLocation();
2677
2678	// Adjust endOfSliceHeaderLocation to account for emulation prevention bytes in the slice segment header
2679	for ( UInt curByteIdx = 0; curByteIdx<m_pcBitstream->numEmulationPreventionBytesRead(); curByteIdx++ )
2680	{
2681	if ( m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) < endOfSliceHeaderLocation )
2682	{
2683	endOfSliceHeaderLocation++;
2684	}
2685	}
2686
2687	Int curEntryPointOffset = 0;
2688	Int prevEntryPointOffset = 0;
2689	for (UInt idx=0; idx<numEntryPointOffsets; idx++)
2690	{
2691	curEntryPointOffset += entryPointOffset[ idx ];
2692
2693	Int emulationPreventionByteCount = 0;
2694	for ( UInt curByteIdx = 0; curByteIdx<m_pcBitstream->numEmulationPreventionBytesRead(); curByteIdx++ )
2695	{
2696	if ( m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) >= ( prevEntryPointOffset + endOfSliceHeaderLocation ) &&
2697	m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) < ( curEntryPointOffset + endOfSliceHeaderLocation ) )
2698	{
2699	emulationPreventionByteCount++;
2700	}
2701	}
2702
2703	entryPointOffset[ idx ] -= emulationPreventionByteCount;
2704	prevEntryPointOffset = curEntryPointOffset;
2705	}
2706
2707	if ( pps->getTilesEnabledFlag() )
2708	{
2709	rpcSlice->setTileLocationCount( numEntryPointOffsets );
2710
2711	UInt prevPos = 0;
2712	for (Int idx=0; idx<rpcSlice->getTileLocationCount(); idx++)
2713	{
2714	rpcSlice->setTileLocation( idx, prevPos + entryPointOffset [ idx ] );
2715	prevPos += entryPointOffset[ idx ];
2716	}
2717	}
2718	else if ( pps->getEntropyCodingSyncEnabledFlag() )
2719	{
2720	Int numSubstreams = rpcSlice->getNumEntryPointOffsets()+1;
2721	rpcSlice->allocSubstreamSizes(numSubstreams);
2722	UInt *pSubstreamSizes = rpcSlice->getSubstreamSizes();
2723	for (Int idx=0; idx<numSubstreams-1; idx++)
2724	{
2725	if ( idx < numEntryPointOffsets )
2726	{
2727	pSubstreamSizes[ idx ] = ( entryPointOffset[ idx ] << 3 ) ;
2728	}
2729	else
2730	{
2731	pSubstreamSizes[ idx ] = 0;
2732	}
2733	}
2734	}
2735
2736	if (entryPointOffset)
2737	{
2738	delete [] entryPointOffset;
2739	}
2740	}
2741
2742	return;
2743	}
2744
2745	Void TDecCavlc::parsePTL( TComPTL *rpcPTL, Bool profilePresentFlag, Int maxNumSubLayersMinus1 )
2746	{
2747	UInt uiCode;
2748	if(profilePresentFlag)
2749	{
2750	parseProfileTier(rpcPTL->getGeneralPTL());
2751	}
2752	READ_CODE( 8, uiCode, "general_level_idc" ); rpcPTL->getGeneralPTL()->setLevelIdc(uiCode);
2753
2754	for (Int i = 0; i < maxNumSubLayersMinus1; i++)
2755	{
2756	if(profilePresentFlag)
2757	{
2758	READ_FLAG( uiCode, "sub_layer_profile_present_flag[i]" ); rpcPTL->setSubLayerProfilePresentFlag(i, uiCode);
2759	}
2760	READ_FLAG( uiCode, "sub_layer_level_present_flag[i]" ); rpcPTL->setSubLayerLevelPresentFlag (i, uiCode);
2761	}
2762
2763	if (maxNumSubLayersMinus1 > 0)
2764	{
2765	for (Int i = maxNumSubLayersMinus1; i < 8; i++)
2766	{
2767	READ_CODE(2, uiCode, "reserved_zero_2bits");
2768	assert(uiCode == 0);
2769	}
2770	}
2771
2772	for(Int i = 0; i < maxNumSubLayersMinus1; i++)
2773	{
2774	if( profilePresentFlag && rpcPTL->getSubLayerProfilePresentFlag(i) )
2775	{
2776	parseProfileTier(rpcPTL->getSubLayerPTL(i));
2777	}
2778	if(rpcPTL->getSubLayerLevelPresentFlag(i))
2779	{
2780	READ_CODE( 8, uiCode, "sub_layer_level_idc[i]" ); rpcPTL->getSubLayerPTL(i)->setLevelIdc(uiCode);
2781	}
2782	}
2783	}
2784
2785	Void TDecCavlc::parseProfileTier(ProfileTierLevel *ptl)
2786	{
2787	UInt uiCode;
2788	READ_CODE(2 , uiCode, "XXX_profile_space[]"); ptl->setProfileSpace(uiCode);
2789	READ_FLAG( uiCode, "XXX_tier_flag[]" ); ptl->setTierFlag (uiCode ? 1 : 0);
2790	READ_CODE(5 , uiCode, "XXX_profile_idc[]" ); ptl->setProfileIdc (uiCode);
2791	for(Int j = 0; j < 32; j++)
2792	{
2793	READ_FLAG( uiCode, "XXX_profile_compatibility_flag[][j]"); ptl->setProfileCompatibilityFlag(j, uiCode ? 1 : 0);
2794	}
2795	READ_FLAG(uiCode, "general_progressive_source_flag");
2796	ptl->setProgressiveSourceFlag(uiCode ? true : false);
2797
2798	READ_FLAG(uiCode, "general_interlaced_source_flag");
2799	ptl->setInterlacedSourceFlag(uiCode ? true : false);
2800
2801	READ_FLAG(uiCode, "general_non_packed_constraint_flag");
2802	ptl->setNonPackedConstraintFlag(uiCode ? true : false);
2803
2804	READ_FLAG(uiCode, "general_frame_only_constraint_flag");
2805	ptl->setFrameOnlyConstraintFlag(uiCode ? true : false);
2806
2807	READ_CODE(16, uiCode, "XXX_reserved_zero_44bits[0..15]");
2808	READ_CODE(16, uiCode, "XXX_reserved_zero_44bits[16..31]");
2809	READ_CODE(12, uiCode, "XXX_reserved_zero_44bits[32..43]");
2810	}
2811
2812	Void TDecCavlc::parseTerminatingBit( UInt& ruiBit )
2813	{
2814	ruiBit = false;
2815	Int iBitsLeft = m_pcBitstream->getNumBitsLeft();
2816	if(iBitsLeft <= 8)
2817	{
2818	UInt uiPeekValue = m_pcBitstream->peekBits(iBitsLeft);
2819	if (uiPeekValue == (1<<(iBitsLeft-1)))
2820	{
2821	ruiBit = true;
2822	}
2823	}
2824	}
2825
2826	Void TDecCavlc::parseSkipFlag( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
2827	{
2828	assert(0);
2829	}
2830
2831	Void TDecCavlc::parseCUTransquantBypassFlag( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
2832	{
2833	assert(0);
2834	}
2835
2836	Void TDecCavlc::parseMVPIdx( Int& /riMVPIdx/ )
2837	{
2838	assert(0);
2839	}
2840
2841	Void TDecCavlc::parseSplitFlag ( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
2842	{
2843	assert(0);
2844	}
2845
2846	Void TDecCavlc::parsePartSize( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
2847	{
2848	assert(0);
2849	}
2850
2851	Void TDecCavlc::parsePredMode( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
2852	{
2853	assert(0);
2854	}
2855
2856	/** Parse I_PCM information.
2857	* \param pcCU pointer to CU
2858	* \param uiAbsPartIdx CU index
2859	* \param uiDepth CU depth
2860	* \returns Void
2861	*
2862	* If I_PCM flag indicates that the CU is I_PCM, parse its PCM alignment bits and codes.
2863	*/
2864	Void TDecCavlc::parseIPCMInfo( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
2865	{
2866	assert(0);
2867	}
2868
2869	Void TDecCavlc::parseIntraDirLumaAng ( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
2870	{
2871	assert(0);
2872	}
2873
2874	Void TDecCavlc::parseIntraDirChroma( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
2875	{
2876	assert(0);
2877	}
2878
2879	Void TDecCavlc::parseInterDir( TComDataCU* /pcCU/, UInt& /ruiInterDir/, UInt /uiAbsPartIdx/ )
2880	{
2881	assert(0);
2882	}
2883
2884	Void TDecCavlc::parseRefFrmIdx( TComDataCU* /pcCU/, Int& /riRefFrmIdx/, RefPicList /eRefList/ )
2885	{
2886	assert(0);
2887	}
2888
2889	Void TDecCavlc::parseMvd( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiPartIdx/, UInt /uiDepth/, RefPicList /eRefList/ )
2890	{
2891	assert(0);
2892	}
2893
2894	Void TDecCavlc::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2895	{
2896	Int qp;
2897	Int iDQp;
2898
2899	xReadSvlc( iDQp );
2900
2901	#if REPN_FORMAT_IN_VPS
2902	Int qpBdOffsetY = pcCU->getSlice()->getQpBDOffsetY();
2903	#else
2904	Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
2905	#endif
2906	qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+ qpBdOffsetY)) - qpBdOffsetY;
2907
2908	UInt uiAbsQpCUPartIdx = (uiAbsPartIdx>>((g_uiMaxCUDepth - pcCU->getSlice()->getPPS()->getMaxCuDQPDepth())<<1))<<((g_uiMaxCUDepth - pcCU->getSlice()->getPPS()->getMaxCuDQPDepth())<<1) ;
2909	UInt uiQpCUDepth = min(uiDepth,pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()) ;
2910
2911	pcCU->setQPSubParts( qp, uiAbsQpCUPartIdx, uiQpCUDepth );
2912	}
2913
2914	Void TDecCavlc::parseCoeffNxN( TComDataCU* /pcCU/, TCoeff* /pcCoef/, UInt /uiAbsPartIdx/, UInt /uiWidth/, UInt /uiHeight/, UInt /uiDepth/, TextType /eTType/ )
2915	{
2916	assert(0);
2917	}
2918
2919	Void TDecCavlc::parseTransformSubdivFlag( UInt& /ruiSubdivFlag/, UInt /uiLog2TransformBlockSize/ )
2920	{
2921	assert(0);
2922	}
2923
2924	Void TDecCavlc::parseQtCbf( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, TextType /eType/, UInt /uiTrDepth/, UInt /uiDepth/ )
2925	{
2926	assert(0);
2927	}
2928
2929	Void TDecCavlc::parseQtRootCbf( UInt /uiAbsPartIdx/, UInt& /uiQtRootCbf/ )
2930	{
2931	assert(0);
2932	}
2933
2934	Void TDecCavlc::parseTransformSkipFlags (TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /width/, UInt /height/, UInt /uiDepth/, TextType /eTType/)
2935	{
2936	assert(0);
2937	}
2938
2939	Void TDecCavlc::parseMergeFlag ( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/, UInt /uiPUIdx/ )
2940	{
2941	assert(0);
2942	}
2943
2944	Void TDecCavlc::parseMergeIndex ( TComDataCU* /pcCU/, UInt& /ruiMergeIndex/ )
2945	{
2946	assert(0);
2947	}
2948
2949	// ====================================================================================================================
2950	// Protected member functions
2951	// ====================================================================================================================
2952
2953	/** parse explicit wp tables
2954	* \param TComSlice* pcSlice
2955	* \returns Void
2956	*/
2957	Void TDecCavlc::xParsePredWeightTable( TComSlice* pcSlice )
2958	{
2959	wpScalingParam *wp;
2960	Bool bChroma = true; // color always present in HEVC ?
2961	SliceType eSliceType = pcSlice->getSliceType();
2962	Int iNbRef = (eSliceType == B_SLICE ) ? (2) : (1);
2963	#if SVC_EXTENSION
2964	UInt uiLog2WeightDenomLuma = 0, uiLog2WeightDenomChroma = 0;
2965	#else
2966	UInt uiLog2WeightDenomLuma, uiLog2WeightDenomChroma;
2967	#endif
2968	UInt uiTotalSignalledWeightFlags = 0;
2969
2970	Int iDeltaDenom;
2971	#if AUXILIARY_PICTURES
2972	if (pcSlice->getChromaFormatIdc() == CHROMA_400)
2973	{
2974	bChroma = false;
2975	}
2976	#endif
2977	// decode delta_luma_log2_weight_denom :
2978	READ_UVLC( uiLog2WeightDenomLuma, "luma_log2_weight_denom" ); // ue(v): luma_log2_weight_denom
2979	assert( uiLog2WeightDenomLuma <= 7 );
2980	if( bChroma )
2981	{
2982	READ_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" ); // se(v): delta_chroma_log2_weight_denom
2983	assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)>=0);
2984	assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)<=7);
2985	uiLog2WeightDenomChroma = (UInt)(iDeltaDenom + uiLog2WeightDenomLuma);
2986	}
2987
2988	for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ )
2989	{
2990	RefPicList eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
2991	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
2992	{
2993	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
2994
2995	wp[0].uiLog2WeightDenom = uiLog2WeightDenomLuma;
2996	#if AUXILIARY_PICTURES
2997	if (!bChroma)
2998	{
2999	wp[1].uiLog2WeightDenom = 0;
3000	wp[2].uiLog2WeightDenom = 0;
3001	}
3002	else
3003	{
3004	#endif
3005	wp[1].uiLog2WeightDenom = uiLog2WeightDenomChroma;
3006	wp[2].uiLog2WeightDenom = uiLog2WeightDenomChroma;
3007	#if AUXILIARY_PICTURES
3008	}
3009	#endif
3010
3011	UInt uiCode;
3012	READ_FLAG( uiCode, "luma_weight_lX_flag" ); // u(1): luma_weight_l0_flag
3013	wp[0].bPresentFlag = ( uiCode == 1 );
3014	uiTotalSignalledWeightFlags += wp[0].bPresentFlag;
3015	}
3016	if ( bChroma )
3017	{
3018	UInt uiCode;
3019	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
3020	{
3021	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
3022	READ_FLAG( uiCode, "chroma_weight_lX_flag" ); // u(1): chroma_weight_l0_flag
3023	wp[1].bPresentFlag = ( uiCode == 1 );
3024	wp[2].bPresentFlag = ( uiCode == 1 );
3025	uiTotalSignalledWeightFlags += 2*wp[1].bPresentFlag;
3026	}
3027	}
3028	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
3029	{
3030	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
3031	if ( wp[0].bPresentFlag )
3032	{
3033	Int iDeltaWeight;
3034	READ_SVLC( iDeltaWeight, "delta_luma_weight_lX" ); // se(v): delta_luma_weight_l0[i]
3035	assert( iDeltaWeight >= -128 );
3036	assert( iDeltaWeight <= 127 );
3037	wp[0].iWeight = (iDeltaWeight + (1<<wp[0].uiLog2WeightDenom));
3038	READ_SVLC( wp[0].iOffset, "luma_offset_lX" ); // se(v): luma_offset_l0[i]
3039	assert( wp[0].iOffset >= -128 );
3040	assert( wp[0].iOffset <= 127 );
3041	}
3042	else
3043	{
3044	wp[0].iWeight = (1 << wp[0].uiLog2WeightDenom);
3045	wp[0].iOffset = 0;
3046	}
3047	if ( bChroma )
3048	{
3049	if ( wp[1].bPresentFlag )
3050	{
3051	for ( Int j=1 ; j<3 ; j++ )
3052	{
3053	Int iDeltaWeight;
3054	READ_SVLC( iDeltaWeight, "delta_chroma_weight_lX" ); // se(v): chroma_weight_l0[i][j]
3055	assert( iDeltaWeight >= -128 );
3056	assert( iDeltaWeight <= 127 );
3057	wp[j].iWeight = (iDeltaWeight + (1<<wp[1].uiLog2WeightDenom));
3058
3059	Int iDeltaChroma;
3060	READ_SVLC( iDeltaChroma, "delta_chroma_offset_lX" ); // se(v): delta_chroma_offset_l0[i][j]
3061	assert( iDeltaChroma >= -512 );
3062	assert( iDeltaChroma <= 511 );
3063	Int pred = ( 128 - ( ( 128*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) );
3064	wp[j].iOffset = Clip3(-128, 127, (iDeltaChroma + pred) );
3065	}
3066	}
3067	else
3068	{
3069	for ( Int j=1 ; j<3 ; j++ )
3070	{
3071	wp[j].iWeight = (1 << wp[j].uiLog2WeightDenom);
3072	wp[j].iOffset = 0;
3073	}
3074	}
3075	}
3076	}
3077
3078	for ( Int iRefIdx=pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx<MAX_NUM_REF ; iRefIdx++ )
3079	{
3080	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
3081
3082	wp[0].bPresentFlag = false;
3083	wp[1].bPresentFlag = false;
3084	wp[2].bPresentFlag = false;
3085	}
3086	}
3087	assert(uiTotalSignalledWeightFlags<=24);
3088	}
3089
3090	/** decode quantization matrix
3091	* \param scalingList quantization matrix information
3092	*/
3093	Void TDecCavlc::parseScalingList(TComScalingList* scalingList)
3094	{
3095	UInt code, sizeId, listId;
3096	Bool scalingListPredModeFlag;
3097	//for each size
3098	for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3099	{
3100	for(listId = 0; listId < g_scalingListNum[sizeId]; listId++)
3101	{
3102	READ_FLAG( code, "scaling_list_pred_mode_flag");
3103	scalingListPredModeFlag = (code) ? true : false;
3104	if(!scalingListPredModeFlag) //Copy Mode
3105	{
3106	READ_UVLC( code, "scaling_list_pred_matrix_id_delta");
3107	scalingList->setRefMatrixId (sizeId,listId,(UInt)((Int)(listId)-(code)));
3108	if( sizeId > SCALING_LIST_8x8 )
3109	{
3110	scalingList->setScalingListDC(sizeId,listId,((listId == scalingList->getRefMatrixId (sizeId,listId))? 16 :scalingList->getScalingListDC(sizeId, scalingList->getRefMatrixId (sizeId,listId))));
3111	}
3112	scalingList->processRefMatrix( sizeId, listId, scalingList->getRefMatrixId (sizeId,listId));
3113
3114	}
3115	else //DPCM Mode
3116	{
3117	xDecodeScalingList(scalingList, sizeId, listId);
3118	}
3119	}
3120	}
3121
3122	return;
3123	}
3124	/** decode DPCM
3125	* \param scalingList quantization matrix information
3126	* \param sizeId size index
3127	* \param listId list index
3128	*/
3129	Void TDecCavlc::xDecodeScalingList(TComScalingList *scalingList, UInt sizeId, UInt listId)
3130	{
3131	Int i,coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
3132	Int data;
3133	Int scalingListDcCoefMinus8 = 0;
3134	Int nextCoef = SCALING_LIST_START_VALUE;
3135	UInt* scan = (sizeId == 0) ? g_auiSigLastScan [ SCAN_DIAG ] [ 1 ] : g_sigLastScanCG32x32;
3136	Int *dst = scalingList->getScalingListAddress(sizeId, listId);
3137
3138	if( sizeId > SCALING_LIST_8x8 )
3139	{
3140	READ_SVLC( scalingListDcCoefMinus8, "scaling_list_dc_coef_minus8");
3141	scalingList->setScalingListDC(sizeId,listId,scalingListDcCoefMinus8 + 8);
3142	nextCoef = scalingList->getScalingListDC(sizeId,listId);
3143	}
3144
3145	for(i = 0; i < coefNum; i++)
3146	{
3147	READ_SVLC( data, "scaling_list_delta_coef");
3148	nextCoef = (nextCoef + data + 256 ) % 256;
3149	dst[scan[i]] = nextCoef;
3150	}
3151	}
3152
3153	Bool TDecCavlc::xMoreRbspData()
3154	{
3155	Int bitsLeft = m_pcBitstream->getNumBitsLeft();
3156
3157	// if there are more than 8 bits, it cannot be rbsp_trailing_bits
3158	if (bitsLeft > 8)
3159	{
3160	return true;
3161	}
3162
3163	UChar lastByte = m_pcBitstream->peekBits(bitsLeft);
3164	Int cnt = bitsLeft;
3165
3166	// remove trailing bits equal to zero
3167	while ((cnt>0) && ((lastByte & 1) == 0))
3168	{
3169	lastByte >>= 1;
3170	cnt--;
3171	}
3172	// remove bit equal to one
3173	cnt--;
3174
3175	// we should not have a negative number of bits
3176	assert (cnt>=0);
3177
3178	// we have more data, if cnt is not zero
3179	return (cnt>0);
3180	}
3181
3182	//! \}
3183

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

Download in other formats: