Context navigation

TDecCAVLC.cpp @ 468

Visit:

Last change on this file since 468 was 468, checked in by lg, 11 years ago
1.IC and full pel depth coding are integrated and is guarded by Macro H_3D_IC.
Property svn:eol-style set to `native`
File size: 79.2 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-2013, 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	#if H_3D
71	m_aaiTempScale = new Int* [ MAX_NUM_LAYERS ];
72	m_aaiTempOffset = new Int* [ MAX_NUM_LAYERS ];
73	for( UInt uiVId = 0; uiVId < MAX_NUM_LAYERS; uiVId++ )
74	{
75	m_aaiTempScale [ uiVId ] = new Int [ MAX_NUM_LAYERS ];
76	m_aaiTempOffset [ uiVId ] = new Int [ MAX_NUM_LAYERS ];
77	}
78	#endif
79	}
80
81	TDecCavlc::~TDecCavlc()
82	{
83	#if H_3D
84	for( UInt uiVId = 0; uiVId < MAX_NUM_LAYERS; uiVId++ )
85	{
86	delete [] m_aaiTempScale [ uiVId ];
87	delete [] m_aaiTempOffset [ uiVId ];
88	}
89	delete [] m_aaiTempScale;
90	delete [] m_aaiTempOffset;
91	#endif
92	}
93
94	// ====================================================================================================================
95	// Public member functions
96	// ====================================================================================================================
97
98	void TDecCavlc::parseShortTermRefPicSet( TComSPS* sps, TComReferencePictureSet* rps, Int idx )
99	{
100	UInt code;
101	UInt interRPSPred;
102	if (idx > 0)
103	{
104	READ_FLAG(interRPSPred, "inter_ref_pic_set_prediction_flag"); rps->setInterRPSPrediction(interRPSPred);
105	}
106	else
107	{
108	interRPSPred = false;
109	rps->setInterRPSPrediction(false);
110	}
111
112	if (interRPSPred)
113	{
114	UInt bit;
115	if(idx == sps->getRPSList()->getNumberOfReferencePictureSets())
116	{
117	READ_UVLC(code, "delta_idx_minus1" ); // delta index of the Reference Picture Set used for prediction minus 1
118	}
119	else
120	{
121	code = 0;
122	}
123	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
124	Int rIdx = idx - 1 - code;
125	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
126	TComReferencePictureSet* rpsRef = sps->getRPSList()->getReferencePictureSet(rIdx);
127	Int k = 0, k0 = 0, k1 = 0;
128	READ_CODE(1, bit, "delta_rps_sign"); // delta_RPS_sign
129	READ_UVLC(code, "abs_delta_rps_minus1"); // absolute delta RPS minus 1
130	Int deltaRPS = (1 - 2 * bit) * (code + 1); // delta_RPS
131	for(Int j=0 ; j <= rpsRef->getNumberOfPictures(); j++)
132	{
133	READ_CODE(1, bit, "used_by_curr_pic_flag" ); //first bit is "1" if Idc is 1
134	Int refIdc = bit;
135	if (refIdc == 0)
136	{
137	READ_CODE(1, bit, "use_delta_flag" ); //second bit is "1" if Idc is 2, "0" otherwise.
138	refIdc = bit<<1; //second bit is "1" if refIdc is 2, "0" if refIdc = 0.
139	}
140	if (refIdc == 1 \|\| refIdc == 2)
141	{
142	Int deltaPOC = deltaRPS + ((j < rpsRef->getNumberOfPictures())? rpsRef->getDeltaPOC(j) : 0);
143	rps->setDeltaPOC(k, deltaPOC);
144	rps->setUsed(k, (refIdc == 1));
145
146	if (deltaPOC < 0)
147	{
148	k0++;
149	}
150	else
151	{
152	k1++;
153	}
154	k++;
155	}
156	rps->setRefIdc(j,refIdc);
157	}
158	rps->setNumRefIdc(rpsRef->getNumberOfPictures()+1);
159	rps->setNumberOfPictures(k);
160	rps->setNumberOfNegativePictures(k0);
161	rps->setNumberOfPositivePictures(k1);
162	rps->sortDeltaPOC();
163	}
164	else
165	{
166	READ_UVLC(code, "num_negative_pics"); rps->setNumberOfNegativePictures(code);
167	READ_UVLC(code, "num_positive_pics"); rps->setNumberOfPositivePictures(code);
168	Int prev = 0;
169	Int poc;
170	for(Int j=0 ; j < rps->getNumberOfNegativePictures(); j++)
171	{
172	READ_UVLC(code, "delta_poc_s0_minus1");
173	poc = prev-code-1;
174	prev = poc;
175	rps->setDeltaPOC(j,poc);
176	READ_FLAG(code, "used_by_curr_pic_s0_flag"); rps->setUsed(j,code);
177	}
178	prev = 0;
179	for(Int j=rps->getNumberOfNegativePictures(); j < rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures(); j++)
180	{
181	READ_UVLC(code, "delta_poc_s1_minus1");
182	poc = prev+code+1;
183	prev = poc;
184	rps->setDeltaPOC(j,poc);
185	READ_FLAG(code, "used_by_curr_pic_s1_flag"); rps->setUsed(j,code);
186	}
187	rps->setNumberOfPictures(rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures());
188	}
189	#if PRINT_RPS_INFO
190	rps->printDeltaPOC();
191	#endif
192	}
193
194	Void TDecCavlc::parsePPS(TComPPS* pcPPS)
195	{
196	#if ENC_DEC_TRACE
197	xTracePPSHeader (pcPPS);
198	#endif
199	UInt uiCode;
200
201	Int iCode;
202
203	READ_UVLC( uiCode, "pps_pic_parameter_set_id"); pcPPS->setPPSId (uiCode);
204	READ_UVLC( uiCode, "pps_seq_parameter_set_id"); pcPPS->setSPSId (uiCode);
205	READ_FLAG( uiCode, "dependent_slice_segments_enabled_flag" ); pcPPS->setDependentSliceSegmentsEnabledFlag ( uiCode == 1 );
206	#if L0255_MOVE_PPS_FLAGS
207	READ_FLAG( uiCode, "output_flag_present_flag" ); pcPPS->setOutputFlagPresentFlag( uiCode==1 );
208
209	READ_CODE(3, uiCode, "num_extra_slice_header_bits"); pcPPS->setNumExtraSliceHeaderBits(uiCode);
210	#endif
211	READ_FLAG ( uiCode, "sign_data_hiding_flag" ); pcPPS->setSignHideFlag( uiCode );
212
213	READ_FLAG( uiCode, "cabac_init_present_flag" ); pcPPS->setCabacInitPresentFlag( uiCode ? true : false );
214
215	#if L0323_LIMIT_DEFAULT_LIST_SIZE
216	READ_UVLC(uiCode, "num_ref_idx_l0_default_active_minus1");
217	assert(uiCode <= 14);
218	pcPPS->setNumRefIdxL0DefaultActive(uiCode+1);
219
220	READ_UVLC(uiCode, "num_ref_idx_l1_default_active_minus1");
221	assert(uiCode <= 14);
222	pcPPS->setNumRefIdxL1DefaultActive(uiCode+1);
223	#else
224	READ_UVLC(uiCode, "num_ref_idx_l0_default_active_minus1"); pcPPS->setNumRefIdxL0DefaultActive(uiCode+1);
225	READ_UVLC(uiCode, "num_ref_idx_l1_default_active_minus1"); pcPPS->setNumRefIdxL1DefaultActive(uiCode+1);
226	#endif
227
228	READ_SVLC(iCode, "init_qp_minus26" ); pcPPS->setPicInitQPMinus26(iCode);
229	READ_FLAG( uiCode, "constrained_intra_pred_flag" ); pcPPS->setConstrainedIntraPred( uiCode ? true : false );
230	READ_FLAG( uiCode, "transform_skip_enabled_flag" );
231	pcPPS->setUseTransformSkip ( uiCode ? true : false );
232
233	READ_FLAG( uiCode, "cu_qp_delta_enabled_flag" ); pcPPS->setUseDQP( uiCode ? true : false );
234	if( pcPPS->getUseDQP() )
235	{
236	READ_UVLC( uiCode, "diff_cu_qp_delta_depth" );
237	pcPPS->setMaxCuDQPDepth( uiCode );
238	}
239	else
240	{
241	pcPPS->setMaxCuDQPDepth( 0 );
242	}
243	READ_SVLC( iCode, "pps_cb_qp_offset");
244	pcPPS->setChromaCbQpOffset(iCode);
245	assert( pcPPS->getChromaCbQpOffset() >= -12 );
246	assert( pcPPS->getChromaCbQpOffset() <= 12 );
247
248	READ_SVLC( iCode, "pps_cr_qp_offset");
249	pcPPS->setChromaCrQpOffset(iCode);
250	assert( pcPPS->getChromaCrQpOffset() >= -12 );
251	assert( pcPPS->getChromaCrQpOffset() <= 12 );
252
253	READ_FLAG( uiCode, "pps_slice_chroma_qp_offsets_present_flag" );
254	pcPPS->setSliceChromaQpFlag( uiCode ? true : false );
255
256	READ_FLAG( uiCode, "weighted_pred_flag" ); // Use of Weighting Prediction (P_SLICE)
257	pcPPS->setUseWP( uiCode==1 );
258	READ_FLAG( uiCode, "weighted_bipred_flag" ); // Use of Bi-Directional Weighting Prediction (B_SLICE)
259	pcPPS->setWPBiPred( uiCode==1 );
260
261	#if !L0255_MOVE_PPS_FLAGS
262	READ_FLAG( uiCode, "output_flag_present_flag" );
263	pcPPS->setOutputFlagPresentFlag( uiCode==1 );
264	#endif
265	READ_FLAG( uiCode, "transquant_bypass_enable_flag");
266	pcPPS->setTransquantBypassEnableFlag(uiCode ? true : false);
267	READ_FLAG( uiCode, "tiles_enabled_flag" ); pcPPS->setTilesEnabledFlag ( uiCode == 1 );
268	READ_FLAG( uiCode, "entropy_coding_sync_enabled_flag" ); pcPPS->setEntropyCodingSyncEnabledFlag( uiCode == 1 );
269
270	if( pcPPS->getTilesEnabledFlag() )
271	{
272	READ_UVLC ( uiCode, "num_tile_columns_minus1" ); pcPPS->setNumColumnsMinus1( uiCode );
273	READ_UVLC ( uiCode, "num_tile_rows_minus1" ); pcPPS->setNumRowsMinus1( uiCode );
274	READ_FLAG ( uiCode, "uniform_spacing_flag" ); pcPPS->setUniformSpacingFlag( uiCode );
275
276	if( !pcPPS->getUniformSpacingFlag())
277	{
278	UInt* columnWidth = (UInt)malloc(pcPPS->getNumColumnsMinus1()sizeof(UInt));
279	for(UInt i=0; i<pcPPS->getNumColumnsMinus1(); i++)
280	{
281	READ_UVLC( uiCode, "column_width_minus1" );
282	columnWidth[i] = uiCode+1;
283	}
284	pcPPS->setColumnWidth(columnWidth);
285	free(columnWidth);
286
287	UInt* rowHeight = (UInt)malloc(pcPPS->getNumRowsMinus1()sizeof(UInt));
288	for(UInt i=0; i<pcPPS->getNumRowsMinus1(); i++)
289	{
290	READ_UVLC( uiCode, "row_height_minus1" );
291	rowHeight[i] = uiCode + 1;
292	}
293	pcPPS->setRowHeight(rowHeight);
294	free(rowHeight);
295	}
296
297	if(pcPPS->getNumColumnsMinus1() !=0 \|\| pcPPS->getNumRowsMinus1() !=0)
298	{
299	READ_FLAG ( uiCode, "loop_filter_across_tiles_enabled_flag" ); pcPPS->setLoopFilterAcrossTilesEnabledFlag( uiCode ? true : false );
300	}
301	}
302	READ_FLAG( uiCode, "loop_filter_across_slices_enabled_flag" ); pcPPS->setLoopFilterAcrossSlicesEnabledFlag( uiCode ? true : false );
303	READ_FLAG( uiCode, "deblocking_filter_control_present_flag" ); pcPPS->setDeblockingFilterControlPresentFlag( uiCode ? true : false );
304	if(pcPPS->getDeblockingFilterControlPresentFlag())
305	{
306	READ_FLAG( uiCode, "deblocking_filter_override_enabled_flag" ); pcPPS->setDeblockingFilterOverrideEnabledFlag( uiCode ? true : false );
307	READ_FLAG( uiCode, "pps_disable_deblocking_filter_flag" ); pcPPS->setPicDisableDeblockingFilterFlag(uiCode ? true : false );
308	if(!pcPPS->getPicDisableDeblockingFilterFlag())
309	{
310	READ_SVLC ( iCode, "pps_beta_offset_div2" ); pcPPS->setDeblockingFilterBetaOffsetDiv2( iCode );
311	READ_SVLC ( iCode, "pps_tc_offset_div2" ); pcPPS->setDeblockingFilterTcOffsetDiv2( iCode );
312	}
313	}
314	READ_FLAG( uiCode, "pps_scaling_list_data_present_flag" ); pcPPS->setScalingListPresentFlag( uiCode ? true : false );
315	if(pcPPS->getScalingListPresentFlag ())
316	{
317	parseScalingList( pcPPS->getScalingList() );
318	}
319
320	READ_FLAG( uiCode, "lists_modification_present_flag");
321	pcPPS->setListsModificationPresentFlag(uiCode);
322
323	READ_UVLC( uiCode, "log2_parallel_merge_level_minus2");
324	pcPPS->setLog2ParallelMergeLevelMinus2 (uiCode);
325
326	#if !L0255_MOVE_PPS_FLAGS
327	READ_CODE(3, uiCode, "num_extra_slice_header_bits");
328	pcPPS->setNumExtraSliceHeaderBits(uiCode);
329	#endif
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	#if L0043_TIMING_INFO
404	TimingInfo *timingInfo = pcVUI->getTimingInfo();
405	READ_FLAG( uiCode, "vui_timing_info_present_flag"); timingInfo->setTimingInfoPresentFlag (uiCode ? true : false);
406	if(timingInfo->getTimingInfoPresentFlag())
407	{
408	READ_CODE( 32, uiCode, "vui_num_units_in_tick"); timingInfo->setNumUnitsInTick (uiCode);
409	READ_CODE( 32, uiCode, "vui_time_scale"); timingInfo->setTimeScale (uiCode);
410	READ_FLAG( uiCode, "vui_poc_proportional_to_timing_flag"); timingInfo->setPocProportionalToTimingFlag(uiCode ? true : false);
411	if(timingInfo->getPocProportionalToTimingFlag())
412	{
413	READ_UVLC( uiCode, "vui_num_ticks_poc_diff_one_minus1"); timingInfo->setNumTicksPocDiffOneMinus1 (uiCode);
414	}
415	#endif
416	READ_FLAG( uiCode, "hrd_parameters_present_flag"); pcVUI->setHrdParametersPresentFlag(uiCode);
417	if( pcVUI->getHrdParametersPresentFlag() )
418	{
419	parseHrdParameters( pcVUI->getHrdParameters(), 1, pcSPS->getMaxTLayers() - 1 );
420	}
421	#if L0043_TIMING_INFO
422	}
423	#endif
424	#if !L0043_TIMING_INFO
425	READ_FLAG( uiCode, "poc_proportional_to_timing_flag" ); pcVUI->setPocProportionalToTimingFlag(uiCode ? true : false);
426	if( pcVUI->getPocProportionalToTimingFlag() && pcVUI->getHrdParameters()->getTimingInfoPresentFlag() )
427	{
428	READ_UVLC( uiCode, "num_ticks_poc_diff_one_minus1" ); pcVUI->setNumTicksPocDiffOneMinus1(uiCode);
429	}
430	#endif
431	READ_FLAG( uiCode, "bitstream_restriction_flag"); pcVUI->setBitstreamRestrictionFlag(uiCode);
432	if (pcVUI->getBitstreamRestrictionFlag())
433	{
434	READ_FLAG( uiCode, "tiles_fixed_structure_flag"); pcVUI->setTilesFixedStructureFlag(uiCode);
435	READ_FLAG( uiCode, "motion_vectors_over_pic_boundaries_flag"); pcVUI->setMotionVectorsOverPicBoundariesFlag(uiCode);
436	READ_FLAG( uiCode, "restricted_ref_pic_lists_flag"); pcVUI->setRestrictedRefPicListsFlag(uiCode);
437	#if L0043_MSS_IDC
438	READ_UVLC( uiCode, "min_spatial_segmentation_idc"); pcVUI->setMinSpatialSegmentationIdc(uiCode);
439	assert(uiCode < 4096);
440	#else
441	READ_CODE( 8, uiCode, "min_spatial_segmentation_idc"); pcVUI->setMinSpatialSegmentationIdc(uiCode);
442	#endif
443	READ_UVLC( uiCode, "max_bytes_per_pic_denom" ); pcVUI->setMaxBytesPerPicDenom(uiCode);
444	READ_UVLC( uiCode, "max_bits_per_mincu_denom" ); pcVUI->setMaxBitsPerMinCuDenom(uiCode);
445	READ_UVLC( uiCode, "log2_max_mv_length_horizontal" ); pcVUI->setLog2MaxMvLengthHorizontal(uiCode);
446	READ_UVLC( uiCode, "log2_max_mv_length_vertical" ); pcVUI->setLog2MaxMvLengthVertical(uiCode);
447	}
448	}
449
450	Void TDecCavlc::parseHrdParameters(TComHRD *hrd, Bool commonInfPresentFlag, UInt maxNumSubLayersMinus1)
451	{
452	UInt uiCode;
453	if( commonInfPresentFlag )
454	{
455	#if !L0043_TIMING_INFO
456	READ_FLAG( uiCode, "timing_info_present_flag" ); hrd->setTimingInfoPresentFlag( uiCode == 1 ? true : false );
457	if( hrd->getTimingInfoPresentFlag() )
458	{
459	READ_CODE( 32, uiCode, "num_units_in_tick" ); hrd->setNumUnitsInTick( uiCode );
460	READ_CODE( 32, uiCode, "time_scale" ); hrd->setTimeScale( uiCode );
461	}
462	#endif
463	READ_FLAG( uiCode, "nal_hrd_parameters_present_flag" ); hrd->setNalHrdParametersPresentFlag( uiCode == 1 ? true : false );
464	READ_FLAG( uiCode, "vcl_hrd_parameters_present_flag" ); hrd->setVclHrdParametersPresentFlag( uiCode == 1 ? true : false );
465	if( hrd->getNalHrdParametersPresentFlag() \|\| hrd->getVclHrdParametersPresentFlag() )
466	{
467	READ_FLAG( uiCode, "sub_pic_cpb_params_present_flag" ); hrd->setSubPicCpbParamsPresentFlag( uiCode == 1 ? true : false );
468	if( hrd->getSubPicCpbParamsPresentFlag() )
469	{
470	READ_CODE( 8, uiCode, "tick_divisor_minus2" ); hrd->setTickDivisorMinus2( uiCode );
471	READ_CODE( 5, uiCode, "du_cpb_removal_delay_length_minus1" ); hrd->setDuCpbRemovalDelayLengthMinus1( uiCode );
472	READ_FLAG( uiCode, "sub_pic_cpb_params_in_pic_timing_sei_flag" ); hrd->setSubPicCpbParamsInPicTimingSEIFlag( uiCode == 1 ? true : false );
473	#if L0044_DU_DPB_OUTPUT_DELAY_HRD
474	READ_CODE( 5, uiCode, "dpb_output_delay_du_length_minus1" ); hrd->setDpbOutputDelayDuLengthMinus1( uiCode );
475	#endif
476	}
477	READ_CODE( 4, uiCode, "bit_rate_scale" ); hrd->setBitRateScale( uiCode );
478	READ_CODE( 4, uiCode, "cpb_size_scale" ); hrd->setCpbSizeScale( uiCode );
479	if( hrd->getSubPicCpbParamsPresentFlag() )
480	{
481	READ_CODE( 4, uiCode, "cpb_size_du_scale" ); hrd->setDuCpbSizeScale( uiCode );
482	}
483	READ_CODE( 5, uiCode, "initial_cpb_removal_delay_length_minus1" ); hrd->setInitialCpbRemovalDelayLengthMinus1( uiCode );
484	READ_CODE( 5, uiCode, "au_cpb_removal_delay_length_minus1" ); hrd->setCpbRemovalDelayLengthMinus1( uiCode );
485	READ_CODE( 5, uiCode, "dpb_output_delay_length_minus1" ); hrd->setDpbOutputDelayLengthMinus1( uiCode );
486	}
487	}
488	Int i, j, nalOrVcl;
489	for( i = 0; i <= maxNumSubLayersMinus1; i ++ )
490	{
491	READ_FLAG( uiCode, "fixed_pic_rate_general_flag" ); hrd->setFixedPicRateFlag( i, uiCode == 1 ? true : false );
492	if( !hrd->getFixedPicRateFlag( i ) )
493	{
494	READ_FLAG( uiCode, "fixed_pic_rate_within_cvs_flag" ); hrd->setFixedPicRateWithinCvsFlag( i, uiCode == 1 ? true : false );
495	}
496	else
497	{
498	hrd->setFixedPicRateWithinCvsFlag( i, true );
499	}
500	#if L0372
501	hrd->setLowDelayHrdFlag( i, 0 ); // Infered to be 0 when not present
502	hrd->setCpbCntMinus1 ( i, 0 ); // Infered to be 0 when not present
503	#endif
504	if( hrd->getFixedPicRateWithinCvsFlag( i ) )
505	{
506	READ_UVLC( uiCode, "elemental_duration_in_tc_minus1" ); hrd->setPicDurationInTcMinus1( i, uiCode );
507	}
508	#if L0372
509	else
510	{
511	READ_FLAG( uiCode, "low_delay_hrd_flag" ); hrd->setLowDelayHrdFlag( i, uiCode == 1 ? true : false );
512	}
513	if (!hrd->getLowDelayHrdFlag( i ))
514	{
515	READ_UVLC( uiCode, "cpb_cnt_minus1" ); hrd->setCpbCntMinus1( i, uiCode );
516	}
517	#else
518	READ_FLAG( uiCode, "low_delay_hrd_flag" ); hrd->setLowDelayHrdFlag( i, uiCode == 1 ? true : false );
519	READ_UVLC( uiCode, "cpb_cnt_minus1" ); hrd->setCpbCntMinus1( i, uiCode );
520	#endif
521	for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
522	{
523	if( ( ( nalOrVcl == 0 ) && ( hrd->getNalHrdParametersPresentFlag() ) ) \|\|
524	( ( nalOrVcl == 1 ) && ( hrd->getVclHrdParametersPresentFlag() ) ) )
525	{
526	for( j = 0; j <= ( hrd->getCpbCntMinus1( i ) ); j ++ )
527	{
528	READ_UVLC( uiCode, "bit_rate_value_minus1" ); hrd->setBitRateValueMinus1( i, j, nalOrVcl, uiCode );
529	READ_UVLC( uiCode, "cpb_size_value_minus1" ); hrd->setCpbSizeValueMinus1( i, j, nalOrVcl, uiCode );
530	if( hrd->getSubPicCpbParamsPresentFlag() )
531	{
532	#if L0363_DU_BIT_RATE
533	READ_UVLC( uiCode, "bit_rate_du_value_minus1" ); hrd->setDuBitRateValueMinus1( i, j, nalOrVcl, uiCode );
534	#endif
535	READ_UVLC( uiCode, "cpb_size_du_value_minus1" ); hrd->setDuCpbSizeValueMinus1( i, j, nalOrVcl, uiCode );
536	}
537	READ_FLAG( uiCode, "cbr_flag" ); hrd->setCbrFlag( i, j, nalOrVcl, uiCode == 1 ? true : false );
538	}
539	}
540	}
541	}
542	}
543
544	#if H_3D
545	Void TDecCavlc::parseSPS(TComSPS* pcSPS, Int viewIndex, Bool depthFlag )
546	#else
547	Void TDecCavlc::parseSPS(TComSPS* pcSPS)
548	#endif
549	{
550	#if ENC_DEC_TRACE
551	xTraceSPSHeader (pcSPS);
552	#endif
553
554	UInt uiCode;
555	READ_CODE( 4, uiCode, "sps_video_parameter_set_id"); pcSPS->setVPSId ( uiCode );
556	READ_CODE( 3, uiCode, "sps_max_sub_layers_minus1" ); pcSPS->setMaxTLayers ( uiCode+1 );
557	READ_FLAG( uiCode, "sps_temporal_id_nesting_flag" ); pcSPS->setTemporalIdNestingFlag ( uiCode > 0 ? true : false );
558	if ( pcSPS->getMaxTLayers() == 1 )
559	{
560	// sps_temporal_id_nesting_flag must be 1 when sps_max_sub_layers_minus1 is 0
561	assert( uiCode == 1 );
562	}
563
564	parsePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
565	READ_UVLC( uiCode, "sps_seq_parameter_set_id" ); pcSPS->setSPSId( uiCode );
566	READ_UVLC( uiCode, "chroma_format_idc" ); pcSPS->setChromaFormatIdc( uiCode );
567	// 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
568	assert (uiCode == 1);
569	if( uiCode == 3 )
570	{
571	READ_FLAG( uiCode, "separate_colour_plane_flag"); assert(uiCode == 0);
572	}
573
574	READ_UVLC ( uiCode, "pic_width_in_luma_samples" ); pcSPS->setPicWidthInLumaSamples ( uiCode );
575	READ_UVLC ( uiCode, "pic_height_in_luma_samples" ); pcSPS->setPicHeightInLumaSamples( uiCode );
576	READ_FLAG( uiCode, "conformance_window_flag");
577	if (uiCode != 0)
578	{
579	Window &conf = pcSPS->getConformanceWindow();
580	READ_UVLC( uiCode, "conf_win_left_offset" ); conf.setWindowLeftOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc() ) );
581	READ_UVLC( uiCode, "conf_win_right_offset" ); conf.setWindowRightOffset ( uiCode * TComSPS::getWinUnitX( pcSPS->getChromaFormatIdc() ) );
582	READ_UVLC( uiCode, "conf_win_top_offset" ); conf.setWindowTopOffset ( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc() ) );
583	READ_UVLC( uiCode, "conf_win_bottom_offset" ); conf.setWindowBottomOffset( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc() ) );
584	}
585
586	READ_UVLC( uiCode, "bit_depth_luma_minus8" );
587	pcSPS->setBitDepthY( uiCode + 8 );
588	pcSPS->setQpBDOffsetY( (Int) (6*uiCode) );
589
590	READ_UVLC( uiCode, "bit_depth_chroma_minus8" );
591	pcSPS->setBitDepthC( uiCode + 8 );
592	pcSPS->setQpBDOffsetC( (Int) (6*uiCode) );
593
594	READ_UVLC( uiCode, "log2_max_pic_order_cnt_lsb_minus4" ); pcSPS->setBitsForPOC( 4 + uiCode );
595
596	UInt subLayerOrderingInfoPresentFlag;
597	READ_FLAG(subLayerOrderingInfoPresentFlag, "sps_sub_layer_ordering_info_present_flag");
598	for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
599	{
600	#if L0323_DPB
601	#if H_MV
602	READ_UVLC ( uiCode, "sps_max_dec_pic_buffering_minus1[i]");
603	#else
604	READ_UVLC ( uiCode, "sps_max_dec_pic_buffering_minus1");
605	#endif
606	pcSPS->setMaxDecPicBuffering( uiCode + 1, i);
607	#else
608	READ_UVLC ( uiCode, "sps_max_dec_pic_buffering");
609	pcSPS->setMaxDecPicBuffering( uiCode, i);
610	#endif
611	#if H_MV
612	READ_UVLC ( uiCode, "sps_num_reorder_pics[i]" );
613	#else
614	READ_UVLC ( uiCode, "sps_num_reorder_pics" );
615	#endif
616	pcSPS->setNumReorderPics(uiCode, i);
617	#if H_MV
618	READ_UVLC ( uiCode, "sps_max_latency_increase[i]");
619	#else
620	READ_UVLC ( uiCode, "sps_max_latency_increase");
621	#endif
622	pcSPS->setMaxLatencyIncrease( uiCode, i );
623
624	if (!subLayerOrderingInfoPresentFlag)
625	{
626	for (i++; i <= pcSPS->getMaxTLayers()-1; i++)
627	{
628	pcSPS->setMaxDecPicBuffering(pcSPS->getMaxDecPicBuffering(0), i);
629	pcSPS->setNumReorderPics(pcSPS->getNumReorderPics(0), i);
630	pcSPS->setMaxLatencyIncrease(pcSPS->getMaxLatencyIncrease(0), i);
631	}
632	break;
633	}
634	}
635
636	READ_UVLC( uiCode, "log2_min_coding_block_size_minus3" );
637	Int log2MinCUSize = uiCode + 3;
638	pcSPS->setLog2MinCodingBlockSize(log2MinCUSize);
639	READ_UVLC( uiCode, "log2_diff_max_min_coding_block_size" );
640	pcSPS->setLog2DiffMaxMinCodingBlockSize(uiCode);
641	Int maxCUDepthDelta = uiCode;
642	pcSPS->setMaxCUWidth ( 1<<(log2MinCUSize + maxCUDepthDelta) );
643	pcSPS->setMaxCUHeight ( 1<<(log2MinCUSize + maxCUDepthDelta) );
644	READ_UVLC( uiCode, "log2_min_transform_block_size_minus2" ); pcSPS->setQuadtreeTULog2MinSize( uiCode + 2 );
645
646	READ_UVLC( uiCode, "log2_diff_max_min_transform_block_size" ); pcSPS->setQuadtreeTULog2MaxSize( uiCode + pcSPS->getQuadtreeTULog2MinSize() );
647	pcSPS->setMaxTrSize( 1<<(uiCode + pcSPS->getQuadtreeTULog2MinSize()) );
648
649	READ_UVLC( uiCode, "max_transform_hierarchy_depth_inter" ); pcSPS->setQuadtreeTUMaxDepthInter( uiCode+1 );
650	READ_UVLC( uiCode, "max_transform_hierarchy_depth_intra" ); pcSPS->setQuadtreeTUMaxDepthIntra( uiCode+1 );
651
652	Int addCuDepth = max (0, log2MinCUSize - (Int)pcSPS->getQuadtreeTULog2MinSize() );
653	pcSPS->setMaxCUDepth( maxCUDepthDelta + addCuDepth );
654
655	READ_FLAG( uiCode, "scaling_list_enabled_flag" ); pcSPS->setScalingListFlag ( uiCode );
656	if(pcSPS->getScalingListFlag())
657	{
658	READ_FLAG( uiCode, "sps_scaling_list_data_present_flag" ); pcSPS->setScalingListPresentFlag ( uiCode );
659	if(pcSPS->getScalingListPresentFlag ())
660	{
661	parseScalingList( pcSPS->getScalingList() );
662	}
663	}
664	READ_FLAG( uiCode, "amp_enabled_flag" ); pcSPS->setUseAMP( uiCode );
665	READ_FLAG( uiCode, "sample_adaptive_offset_enabled_flag" ); pcSPS->setUseSAO ( uiCode ? true : false );
666
667	READ_FLAG( uiCode, "pcm_enabled_flag" ); pcSPS->setUsePCM( uiCode ? true : false );
668	if( pcSPS->getUsePCM() )
669	{
670	READ_CODE( 4, uiCode, "pcm_sample_bit_depth_luma_minus1" ); pcSPS->setPCMBitDepthLuma ( 1 + uiCode );
671	READ_CODE( 4, uiCode, "pcm_sample_bit_depth_chroma_minus1" ); pcSPS->setPCMBitDepthChroma ( 1 + uiCode );
672	READ_UVLC( uiCode, "log2_min_pcm_luma_coding_block_size_minus3" ); pcSPS->setPCMLog2MinSize (uiCode+3);
673	READ_UVLC( uiCode, "log2_diff_max_min_pcm_luma_coding_block_size" ); pcSPS->setPCMLog2MaxSize ( uiCode+pcSPS->getPCMLog2MinSize() );
674	READ_FLAG( uiCode, "pcm_loop_filter_disable_flag" ); pcSPS->setPCMFilterDisableFlag ( uiCode ? true : false );
675	}
676
677	READ_UVLC( uiCode, "num_short_term_ref_pic_sets" );
678	pcSPS->createRPSList(uiCode);
679
680	TComRPSList* rpsList = pcSPS->getRPSList();
681	TComReferencePictureSet* rps;
682
683	for(UInt i=0; i< rpsList->getNumberOfReferencePictureSets(); i++)
684	{
685	rps = rpsList->getReferencePictureSet(i);
686	parseShortTermRefPicSet(pcSPS,rps,i);
687	}
688	READ_FLAG( uiCode, "long_term_ref_pics_present_flag" ); pcSPS->setLongTermRefsPresent(uiCode);
689	if (pcSPS->getLongTermRefsPresent())
690	{
691	READ_UVLC( uiCode, "num_long_term_ref_pic_sps" );
692	pcSPS->setNumLongTermRefPicSPS(uiCode);
693	for (UInt k = 0; k < pcSPS->getNumLongTermRefPicSPS(); k++)
694	{
695	READ_CODE( pcSPS->getBitsForPOC(), uiCode, "lt_ref_pic_poc_lsb_sps" );
696	pcSPS->setLtRefPicPocLsbSps(k, uiCode);
697	READ_FLAG( uiCode, "used_by_curr_pic_lt_sps_flag[i]");
698	pcSPS->setUsedByCurrPicLtSPSFlag(k, uiCode?1:0);
699	}
700	}
701	READ_FLAG( uiCode, "sps_temporal_mvp_enable_flag" ); pcSPS->setTMVPFlagsPresent(uiCode);
702
703	READ_FLAG( uiCode, "sps_strong_intra_smoothing_enable_flag" ); pcSPS->setUseStrongIntraSmoothing(uiCode);
704
705	READ_FLAG( uiCode, "vui_parameters_present_flag" ); pcSPS->setVuiParametersPresentFlag(uiCode);
706
707	if (pcSPS->getVuiParametersPresentFlag())
708	{
709	parseVUI(pcSPS->getVuiParameters(), pcSPS);
710	}
711
712	READ_FLAG( uiCode, "sps_extension_flag");
713	if (uiCode)
714	{
715	#if !H_MV
716	while ( xMoreRbspData() )
717	{
718	READ_FLAG( uiCode, "sps_extension_data_flag");
719	}
720	#else
721	READ_FLAG( uiCode, "inter_view_mv_vert_constraint_flag" ); pcSPS->setInterViewMvVertConstraintFlag(uiCode == 1 ? true : false);
722	READ_FLAG( uiCode, "sps_extension2_flag");
723	if ( uiCode )
724	{
725	#if !H_3D
726	while ( xMoreRbspData() )
727	{
728	READ_FLAG( uiCode, "sps_extension_data_flag");
729	}
730	#else
731	UInt uiCamParPrecision = 0;
732	Bool bCamParSlice = false;
733	if ( !depthFlag )
734	{
735	READ_UVLC( uiCamParPrecision, "cp_precision" );
736	READ_FLAG( uiCode, "cp_in_slice_header_flag" ); bCamParSlice = ( uiCode == 1 );
737	if( !bCamParSlice )
738	{
739	for( UInt uiBaseIndex = 0; uiBaseIndex < viewIndex; uiBaseIndex++ )
740	{
741	Int iCode;
742	READ_SVLC( iCode, "cp_scale" ); m_aaiTempScale [ uiBaseIndex ][ viewIndex ] = iCode;
743	READ_SVLC( iCode, "cp_off" ); m_aaiTempOffset [ uiBaseIndex ][ viewIndex ] = iCode;
744	READ_SVLC( iCode, "cp_inv_scale_plus_scale" ); m_aaiTempScale [ viewIndex ][ uiBaseIndex ] = iCode - m_aaiTempScale [ uiBaseIndex ][ viewIndex ];
745	READ_SVLC( iCode, "cp_inv_off_plus_off" ); m_aaiTempOffset [ viewIndex ][ uiBaseIndex ] = iCode - m_aaiTempOffset[ uiBaseIndex ][ viewIndex ];
746	}
747	}
748	}
749	pcSPS->initCamParaSPS( viewIndex, uiCamParPrecision, bCamParSlice, m_aaiTempScale, m_aaiTempOffset );
750	READ_FLAG( uiCode, "sps_extension3_flag");
751	if ( uiCode )
752	{
753	while ( xMoreRbspData() )
754	{
755	READ_FLAG( uiCode, "sps_extension_data_flag");
756	}
757	}
758	#endif // !H_3D
759	}
760	#endif // !H_MV
761	}
762	}
763
764	Void TDecCavlc::parseVPS(TComVPS* pcVPS)
765	{
766	UInt uiCode;
767
768	READ_CODE( 4, uiCode, "vps_video_parameter_set_id" ); pcVPS->setVPSId( uiCode );
769	READ_CODE( 2, uiCode, "vps_reserved_three_2bits" ); assert(uiCode == 3);
770	#if H_MV
771	READ_CODE( 6, uiCode, "vps_max_layers_minus1" ); pcVPS->setMaxLayers( uiCode + 1 );
772	#else
773	READ_CODE( 6, uiCode, "vps_reserved_zero_6bits" ); assert(uiCode == 0);
774	#endif
775	READ_CODE( 3, uiCode, "vps_max_sub_layers_minus1" ); pcVPS->setMaxTLayers( uiCode + 1 );
776	READ_FLAG( uiCode, "vps_temporal_id_nesting_flag" ); pcVPS->setTemporalNestingFlag( uiCode ? true:false );
777	assert (pcVPS->getMaxTLayers()>1\|\|pcVPS->getTemporalNestingFlag());
778	#if H_MV
779	READ_CODE( 16, uiCode, "vps_extension_offset" );
780	#else
781	READ_CODE( 16, uiCode, "vps_reserved_ffff_16bits" ); assert(uiCode == 0xffff);
782	#endif
783	parsePTL ( pcVPS->getPTL(), true, pcVPS->getMaxTLayers()-1);
784	#if SIGNAL_BITRATE_PICRATE_IN_VPS
785	parseBitratePicRateInfo( pcVPS->getBitratePicrateInfo(), 0, pcVPS->getMaxTLayers() - 1);
786	#endif
787	UInt subLayerOrderingInfoPresentFlag;
788	READ_FLAG(subLayerOrderingInfoPresentFlag, "vps_sub_layer_ordering_info_present_flag");
789	for(UInt i = 0; i <= pcVPS->getMaxTLayers()-1; i++)
790	{
791	#if L0323_DPB
792	READ_UVLC( uiCode, "vps_max_dec_pic_buffering_minus1[i]" ); pcVPS->setMaxDecPicBuffering( uiCode + 1, i );
793	#else
794	READ_UVLC( uiCode, "vps_max_dec_pic_buffering[i]" ); pcVPS->setMaxDecPicBuffering( uiCode, i );
795	#endif
796	READ_UVLC( uiCode, "vps_num_reorder_pics[i]" ); pcVPS->setNumReorderPics( uiCode, i );
797	READ_UVLC( uiCode, "vps_max_latency_increase[i]" ); pcVPS->setMaxLatencyIncrease( uiCode, i );
798
799	if (!subLayerOrderingInfoPresentFlag)
800	{
801	for (i++; i <= pcVPS->getMaxTLayers()-1; i++)
802	{
803	pcVPS->setMaxDecPicBuffering(pcVPS->getMaxDecPicBuffering(0), i);
804	pcVPS->setNumReorderPics(pcVPS->getNumReorderPics(0), i);
805	pcVPS->setMaxLatencyIncrease(pcVPS->getMaxLatencyIncrease(0), i);
806	}
807	break;
808	}
809	}
810
811	assert( pcVPS->getNumHrdParameters() < MAX_VPS_OP_SETS_PLUS1 );
812	#if H_MV
813	assert( pcVPS->getMaxNuhLayerId() < MAX_VPS_NUH_LAYER_ID_PLUS1 );
814	READ_CODE( 6, uiCode, "vps_max_nuh_layer_id" ); pcVPS->setMaxNuhLayerId( uiCode );
815	#else
816	assert( pcVPS->getMaxNuhReservedZeroLayerId() < MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1 );
817	READ_CODE( 6, uiCode, "vps_max_nuh_reserved_zero_layer_id" ); pcVPS->setMaxNuhReservedZeroLayerId( uiCode );
818	#endif
819	READ_UVLC( uiCode, "vps_max_op_sets_minus1" ); pcVPS->setMaxOpSets( uiCode + 1 );
820	for( UInt opsIdx = 1; opsIdx <= ( pcVPS->getMaxOpSets() - 1 ); opsIdx ++ )
821	{
822	// Operation point set
823	#if H_MV
824	for( UInt i = 0; i <= pcVPS->getMaxNuhLayerId(); i ++ )
825	#else
826	for( UInt i = 0; i <= pcVPS->getMaxNuhReservedZeroLayerId(); i ++ )
827	#endif
828	{
829	READ_FLAG( uiCode, "layer_id_included_flag[opsIdx][i]" ); pcVPS->setLayerIdIncludedFlag( uiCode == 1 ? true : false, opsIdx, i );
830	}
831	}
832	#if L0043_TIMING_INFO
833	TimingInfo *timingInfo = pcVPS->getTimingInfo();
834	READ_FLAG( uiCode, "vps_timing_info_present_flag"); timingInfo->setTimingInfoPresentFlag (uiCode ? true : false);
835	if(timingInfo->getTimingInfoPresentFlag())
836	{
837	READ_CODE( 32, uiCode, "vps_num_units_in_tick"); timingInfo->setNumUnitsInTick (uiCode);
838	READ_CODE( 32, uiCode, "vps_time_scale"); timingInfo->setTimeScale (uiCode);
839	READ_FLAG( uiCode, "vps_poc_proportional_to_timing_flag"); timingInfo->setPocProportionalToTimingFlag(uiCode ? true : false);
840	if(timingInfo->getPocProportionalToTimingFlag())
841	{
842	READ_UVLC( uiCode, "vps_num_ticks_poc_diff_one_minus1"); timingInfo->setNumTicksPocDiffOneMinus1 (uiCode);
843	}
844	#endif
845	READ_UVLC( uiCode, "vps_num_hrd_parameters" ); pcVPS->setNumHrdParameters( uiCode );
846
847	if( pcVPS->getNumHrdParameters() > 0 )
848	{
849	pcVPS->createHrdParamBuffer();
850	}
851	for( UInt i = 0; i < pcVPS->getNumHrdParameters(); i ++ )
852	{
853	READ_UVLC( uiCode, "hrd_op_set_idx" ); pcVPS->setHrdOpSetIdx( uiCode, i );
854	if( i > 0 )
855	{
856	READ_FLAG( uiCode, "cprms_present_flag[i]" ); pcVPS->setCprmsPresentFlag( uiCode == 1 ? true : false, i );
857	}
858	parseHrdParameters(pcVPS->getHrdParameters(i), pcVPS->getCprmsPresentFlag( i ), pcVPS->getMaxTLayers() - 1);
859	}
860	#if L0043_TIMING_INFO
861	}
862	#endif
863	READ_FLAG( uiCode, "vps_extension_flag" );
864	if (uiCode)
865	{
866	#if H_MV
867	m_pcBitstream->readOutTrailingBits();
868
869	READ_FLAG( uiCode, "avc_base_layer_flag" ); pcVPS->setAvcBaseLayerFlag( uiCode == 1 ? true : false );
870	READ_FLAG( uiCode, "splitting_flag" ); pcVPS->setSplittingFlag( uiCode == 1 ? true : false );
871
872	// Parse scalability_mask[i]
873	for( Int sIdx = 0; sIdx < MAX_NUM_SCALABILITY_TYPES; sIdx++ )
874	{
875	READ_FLAG( uiCode, "scalability_mask[i]" ); pcVPS->setScalabilityMask( sIdx, uiCode == 1 ? true : false );
876	}
877
878	Int numScalabilityTypes = pcVPS->getNumScalabilityTypes();
879
880	// Parse dimension_id_len_minus1[j]
881	for( Int sIdx = 0; sIdx < numScalabilityTypes; sIdx++ )
882	{
883	READ_CODE( 3, uiCode, "dimension_id_len_minus1[j]" ); pcVPS->setDimensionIdLen( sIdx, uiCode + 1 );
884	}
885
886	// vps_nuh_layer_id_present_flag
887	READ_FLAG( uiCode, "vps_nuh_layer_id_present_flag" ); pcVPS->setVpsNuhLayerIdPresentFlag( uiCode == 1 ? true : false );
888
889	// parse layer_id_in_nuh[i] and derive LayerIdInVps
890	// already updated to JCT3V-D0220
891	for( Int layer = 0; layer <= pcVPS->getMaxLayers() - 1; layer++ )
892	{
893	UInt layerIdInNuh;
894	if ( pcVPS->getVpsNuhLayerIdPresentFlag() && ( layer != 0 ) )
895	{
896	READ_CODE( 6, uiCode, "layer_id_in_nuh[i]" ); layerIdInNuh = uiCode;
897	}
898	else
899	{
900	layerIdInNuh = layer;
901	}
902
903	pcVPS->setLayerIdInNuh( layer, layerIdInNuh );
904	pcVPS->setLayerIdInVps( layerIdInNuh, layer );
905
906	// parse dimension_id[i][j]
907	for( Int sIdx = 0; sIdx < numScalabilityTypes; sIdx++ )
908	{
909	READ_CODE( pcVPS->getDimensionIdLen( sIdx ), uiCode, "dimension_id[i][j]" ); pcVPS->setDimensionId( layer, sIdx, uiCode );
910	}
911	}
912
913	for( Int layerSet = 1; layerSet <= pcVPS->getMaxOpSets() - 1; layerSet++ )
914	{
915	READ_FLAG( uiCode, "vps_profile_present_flag[lsIdx]" ); pcVPS->setVpsProfilePresentFlag( layerSet, uiCode == 1 ? true : false );
916	if( pcVPS->getVpsProfilePresentFlag( layerSet ) == false )
917	{
918	READ_UVLC( uiCode, "profile_layer_set_ref_minus1[lsIdx]" ); pcVPS->setProfileLayerSetRefMinus1( layerSet, uiCode );
919	}
920
921	parsePTL ( pcVPS->getPTL( layerSet ), pcVPS->getVpsProfilePresentFlag( layerSet ), pcVPS->getMaxTLayers()-1);
922	if( pcVPS->getVpsProfilePresentFlag( layerSet ) == false )
923	{
924	TComPTL temp = *pcVPS->getPTL( layerSet );
925	pcVPS->getPTL( layerSet ) = pcVPS->getPTL( pcVPS->getProfileLayerSetRefMinus1( layerSet ) + 1 );
926	pcVPS->getPTL( layerSet )->copyLevelFrom( &temp );
927	}
928	}
929
930	READ_UVLC( uiCode, "num_output_layer_sets" ); pcVPS->setNumOutputLayerSets( uiCode );
931
932	for( Int layerSet = 0; layerSet < pcVPS->getNumOutputLayerSets(); layerSet++ )
933	{
934	READ_UVLC( uiCode, "output_layer_set_idx[i]" ); pcVPS->setOutputLayerSetIdx( layerSet, uiCode );
935	for( Int layer = 0; layer <= pcVPS->getMaxNuhLayerId(); layer++ )
936	{
937	if( pcVPS->getLayerIdIncludedFlag( pcVPS->getOutputLayerSetIdx( layerSet ), layer ) == true )
938	{
939	READ_FLAG( uiCode, "output_layer_flag" ); pcVPS->setOutputLayerFlag( layerSet, layer, uiCode == 1 ? true : false );
940	}
941	}
942	}
943
944	for( Int i = 1; i <= pcVPS->getMaxLayers() - 1; i++ )
945	{
946	for( Int j = 0; j < i; j++ )
947	{
948	READ_FLAG( uiCode, "direct_dependency_flag[i][j]" ); pcVPS->setDirectDependencyFlag( i, j, uiCode );
949	}
950	}
951
952	#if H_3D_ARP
953	for( Int layer = 0; layer <= pcVPS->getMaxLayers() - 1; layer++ )
954	{
955	if( ( layer!=0 ) && ( pcVPS->getDepthId(layer)!=1 ) )
956	{
957	READ_FLAG( uiCode, "advanced_residual_pred_flag" );
958	pcVPS->setUseAdvRP ( layer, uiCode );
959	pcVPS->setARPStepNum( layer, uiCode ? H_3D_ARP_WFNR : 1 );
960	}
961	else
962	{
963	pcVPS->setUseAdvRP ( layer, 0 );
964	pcVPS->setARPStepNum( layer, 1 );
965	}
966	}
967	#endif
968
969	READ_FLAG( uiCode, "vps_extension2_flag" );
970	if (uiCode)
971	{
972	while ( xMoreRbspData() )
973	{
974	READ_FLAG( uiCode, "vps_extension2_data_flag");
975	}
976	}
977
978	pcVPS->checkVPSExtensionSyntax();
979
980	pcVPS->calcIvRefLayers();
981
982	#else
983	while ( xMoreRbspData() )
984	{
985	READ_FLAG( uiCode, "vps_extension_data_flag");
986	}
987	#endif
988	}
989
990	#if H_3D
991	pcVPS->initViewIndex();
992	#endif
993
994	return;
995	}
996
997	Void TDecCavlc::parseSliceHeader (TComSlice& rpcSlice, ParameterSetManagerDecoder parameterSetManager)
998	{
999	UInt uiCode;
1000	Int iCode;
1001
1002	#if ENC_DEC_TRACE
1003	xTraceSliceHeader(rpcSlice);
1004	#endif
1005	TComPPS* pps = NULL;
1006	TComSPS* sps = NULL;
1007	#if H_MV
1008	TComVPS* vps = NULL;
1009	#endif
1010
1011	UInt firstSliceSegmentInPic;
1012	READ_FLAG( firstSliceSegmentInPic, "first_slice_segment_in_pic_flag" );
1013	if( rpcSlice->getRapPicFlag())
1014	{
1015	READ_FLAG( uiCode, "no_output_of_prior_pics_flag" ); //ignored
1016	}
1017	READ_UVLC ( uiCode, "slice_pic_parameter_set_id" ); rpcSlice->setPPSId(uiCode);
1018	pps = parameterSetManager->getPrefetchedPPS(uiCode);
1019	//!KS: need to add error handling code here, if PPS is not available
1020	assert(pps!=0);
1021	sps = parameterSetManager->getPrefetchedSPS(pps->getSPSId());
1022	//!KS: need to add error handling code here, if SPS is not available
1023	assert(sps!=0);
1024	#if H_MV
1025	vps = parameterSetManager->getPrefetchedVPS(sps->getVPSId());
1026	assert(vps!=0);
1027	rpcSlice->setVPS(vps);
1028	rpcSlice->setViewId ( vps->getViewId ( rpcSlice->getLayerIdInVps() ) );
1029	#if H_3D
1030	rpcSlice->setViewIndex( vps->getViewIndex( rpcSlice->getLayerIdInVps() ) );
1031	rpcSlice->setIsDepth ( vps->getDepthId ( rpcSlice->getLayerIdInVps() ) == 1 );
1032	#endif
1033	#endif
1034	rpcSlice->setSPS(sps);
1035	rpcSlice->setPPS(pps);
1036	if( pps->getDependentSliceSegmentsEnabledFlag() && ( !firstSliceSegmentInPic ))
1037	{
1038	READ_FLAG( uiCode, "dependent_slice_segment_flag" ); rpcSlice->setDependentSliceSegmentFlag(uiCode ? true : false);
1039	}
1040	else
1041	{
1042	rpcSlice->setDependentSliceSegmentFlag(false);
1043	}
1044	Int numCTUs = ((sps->getPicWidthInLumaSamples()+sps->getMaxCUWidth()-1)/sps->getMaxCUWidth())*((sps->getPicHeightInLumaSamples()+sps->getMaxCUHeight()-1)/sps->getMaxCUHeight());
1045	Int maxParts = (1<<(sps->getMaxCUDepth()<<1));
1046	UInt sliceSegmentAddress = 0;
1047	Int bitsSliceSegmentAddress = 0;
1048	while(numCTUs>(1<<bitsSliceSegmentAddress))
1049	{
1050	bitsSliceSegmentAddress++;
1051	}
1052
1053	if(!firstSliceSegmentInPic)
1054	{
1055	READ_CODE( bitsSliceSegmentAddress, sliceSegmentAddress, "slice_segment_address" );
1056	}
1057	//set uiCode to equal slice start address (or dependent slice start address)
1058	Int startCuAddress = maxParts*sliceSegmentAddress;
1059	rpcSlice->setSliceSegmentCurStartCUAddr( startCuAddress );
1060	rpcSlice->setSliceSegmentCurEndCUAddr(numCTUs*maxParts);
1061
1062	if (rpcSlice->getDependentSliceSegmentFlag())
1063	{
1064	rpcSlice->setNextSlice ( false );
1065	rpcSlice->setNextSliceSegment ( true );
1066	}
1067	else
1068	{
1069	rpcSlice->setNextSlice ( true );
1070	rpcSlice->setNextSliceSegment ( false );
1071
1072	rpcSlice->setSliceCurStartCUAddr(startCuAddress);
1073	rpcSlice->setSliceCurEndCUAddr(numCTUs*maxParts);
1074	}
1075
1076	if(!rpcSlice->getDependentSliceSegmentFlag())
1077	{
1078	for (Int i = 0; i < rpcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
1079	{
1080	READ_FLAG(uiCode, "slice_reserved_undetermined_flag[]"); // ignored
1081	}
1082
1083	READ_UVLC ( uiCode, "slice_type" ); rpcSlice->setSliceType((SliceType)uiCode);
1084	if( pps->getOutputFlagPresentFlag() )
1085	{
1086	READ_FLAG( uiCode, "pic_output_flag" ); rpcSlice->setPicOutputFlag( uiCode ? true : false );
1087	}
1088	else
1089	{
1090	rpcSlice->setPicOutputFlag( true );
1091	}
1092	// in the first version chroma_format_idc is equal to one, thus colour_plane_id will not be present
1093	assert (sps->getChromaFormatIdc() == 1 );
1094	// if( separate_colour_plane_flag == 1 )
1095	// colour_plane_id u(2)
1096
1097	if( rpcSlice->getIdrPicFlag() )
1098	{
1099	rpcSlice->setPOC(0);
1100	TComReferencePictureSet* rps = rpcSlice->getLocalRPS();
1101	rps->setNumberOfNegativePictures(0);
1102	rps->setNumberOfPositivePictures(0);
1103	rps->setNumberOfLongtermPictures(0);
1104	rps->setNumberOfPictures(0);
1105	rpcSlice->setRPS(rps);
1106	}
1107	else
1108	{
1109	READ_CODE(sps->getBitsForPOC(), uiCode, "pic_order_cnt_lsb");
1110	Int iPOClsb = uiCode;
1111	Int iPrevPOC = rpcSlice->getPrevPOC();
1112	Int iMaxPOClsb = 1<< sps->getBitsForPOC();
1113	Int iPrevPOClsb = iPrevPOC%iMaxPOClsb;
1114	Int iPrevPOCmsb = iPrevPOC-iPrevPOClsb;
1115	Int iPOCmsb;
1116	if( ( iPOClsb < iPrevPOClsb ) && ( ( iPrevPOClsb - iPOClsb ) >= ( iMaxPOClsb / 2 ) ) )
1117	{
1118	iPOCmsb = iPrevPOCmsb + iMaxPOClsb;
1119	}
1120	else if( (iPOClsb > iPrevPOClsb ) && ( (iPOClsb - iPrevPOClsb ) > ( iMaxPOClsb / 2 ) ) )
1121	{
1122	iPOCmsb = iPrevPOCmsb - iMaxPOClsb;
1123	}
1124	else
1125	{
1126	iPOCmsb = iPrevPOCmsb;
1127	}
1128	if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
1129	\|\| rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
1130	\|\| rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
1131	{
1132	// For BLA picture types, POCmsb is set to 0.
1133	iPOCmsb = 0;
1134	}
1135	rpcSlice->setPOC (iPOCmsb+iPOClsb);
1136
1137	TComReferencePictureSet* rps;
1138	rps = rpcSlice->getLocalRPS();
1139	rpcSlice->setRPS(rps);
1140	READ_FLAG( uiCode, "short_term_ref_pic_set_sps_flag" );
1141	if(uiCode == 0) // use short-term reference picture set explicitly signalled in slice header
1142	{
1143	parseShortTermRefPicSet(sps,rps, sps->getRPSList()->getNumberOfReferencePictureSets());
1144	}
1145	else // use reference to short-term reference picture set in PPS
1146	{
1147	Int numBits = 0;
1148	while ((1 << numBits) < rpcSlice->getSPS()->getRPSList()->getNumberOfReferencePictureSets())
1149	{
1150	numBits++;
1151	}
1152	if (numBits > 0)
1153	{
1154	READ_CODE( numBits, uiCode, "short_term_ref_pic_set_idx");
1155	}
1156	else
1157	{
1158	uiCode = 0;
1159	}
1160	memcpy(rps,sps->getRPSList()->getReferencePictureSet(uiCode),sizeof(TComReferencePictureSet));
1161	}
1162	if(sps->getLongTermRefsPresent())
1163	{
1164	Int offset = rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures();
1165	UInt numOfLtrp = 0;
1166	UInt numLtrpInSPS = 0;
1167	if (rpcSlice->getSPS()->getNumLongTermRefPicSPS() > 0)
1168	{
1169	READ_UVLC( uiCode, "num_long_term_sps");
1170	numLtrpInSPS = uiCode;
1171	numOfLtrp += numLtrpInSPS;
1172	rps->setNumberOfLongtermPictures(numOfLtrp);
1173	}
1174	Int bitsForLtrpInSPS = 0;
1175	while (rpcSlice->getSPS()->getNumLongTermRefPicSPS() > (1 << bitsForLtrpInSPS))
1176	{
1177	bitsForLtrpInSPS++;
1178	}
1179	READ_UVLC( uiCode, "num_long_term_pics"); rps->setNumberOfLongtermPictures(uiCode);
1180	numOfLtrp += uiCode;
1181	rps->setNumberOfLongtermPictures(numOfLtrp);
1182	Int maxPicOrderCntLSB = 1 << rpcSlice->getSPS()->getBitsForPOC();
1183	Int prevDeltaMSB = 0, deltaPocMSBCycleLT = 0;;
1184	for(Int j=offset+rps->getNumberOfLongtermPictures()-1, k = 0; k < numOfLtrp; j--, k++)
1185	{
1186	Int pocLsbLt;
1187	if (k < numLtrpInSPS)
1188	{
1189	uiCode = 0;
1190	if (bitsForLtrpInSPS > 0)
1191	{
1192	READ_CODE(bitsForLtrpInSPS, uiCode, "lt_idx_sps[i]");
1193	}
1194	Int usedByCurrFromSPS=rpcSlice->getSPS()->getUsedByCurrPicLtSPSFlag(uiCode);
1195
1196	pocLsbLt = rpcSlice->getSPS()->getLtRefPicPocLsbSps(uiCode);
1197	rps->setUsed(j,usedByCurrFromSPS);
1198	}
1199	else
1200	{
1201	READ_CODE(rpcSlice->getSPS()->getBitsForPOC(), uiCode, "poc_lsb_lt"); pocLsbLt= uiCode;
1202	READ_FLAG( uiCode, "used_by_curr_pic_lt_flag"); rps->setUsed(j,uiCode);
1203	}
1204	READ_FLAG(uiCode,"delta_poc_msb_present_flag");
1205	Bool mSBPresentFlag = uiCode ? true : false;
1206	if(mSBPresentFlag)
1207	{
1208	READ_UVLC( uiCode, "delta_poc_msb_cycle_lt[i]" );
1209	Bool deltaFlag = false;
1210	// First LTRP \|\| First LTRP from SH
1211	if( (j == offset+rps->getNumberOfLongtermPictures()-1) \|\| (j == offset+(numOfLtrp-numLtrpInSPS)-1) )
1212	{
1213	deltaFlag = true;
1214	}
1215	if(deltaFlag)
1216	{
1217	deltaPocMSBCycleLT = uiCode;
1218	}
1219	else
1220	{
1221	deltaPocMSBCycleLT = uiCode + prevDeltaMSB;
1222	}
1223
1224	Int pocLTCurr = rpcSlice->getPOC() - deltaPocMSBCycleLT * maxPicOrderCntLSB
1225	- iPOClsb + pocLsbLt;
1226	rps->setPOC (j, pocLTCurr);
1227	rps->setDeltaPOC(j, - rpcSlice->getPOC() + pocLTCurr);
1228	rps->setCheckLTMSBPresent(j,true);
1229	}
1230	else
1231	{
1232	rps->setPOC (j, pocLsbLt);
1233	rps->setDeltaPOC(j, - rpcSlice->getPOC() + pocLsbLt);
1234	rps->setCheckLTMSBPresent(j,false);
1235	}
1236	prevDeltaMSB = deltaPocMSBCycleLT;
1237	}
1238	offset += rps->getNumberOfLongtermPictures();
1239	rps->setNumberOfPictures(offset);
1240	}
1241	if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
1242	\|\| rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
1243	\|\| rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
1244	{
1245	// In the case of BLA picture types, rps data is read from slice header but ignored
1246	rps = rpcSlice->getLocalRPS();
1247	rps->setNumberOfNegativePictures(0);
1248	rps->setNumberOfPositivePictures(0);
1249	rps->setNumberOfLongtermPictures(0);
1250	rps->setNumberOfPictures(0);
1251	rpcSlice->setRPS(rps);
1252	}
1253	if (rpcSlice->getSPS()->getTMVPFlagsPresent())
1254	{
1255	READ_FLAG( uiCode, "slice_temporal_mvp_enable_flag" );
1256	rpcSlice->setEnableTMVPFlag( uiCode == 1 ? true : false );
1257	}
1258	else
1259	{
1260	rpcSlice->setEnableTMVPFlag(false);
1261	}
1262	}
1263	if(sps->getUseSAO())
1264	{
1265	READ_FLAG(uiCode, "slice_sao_luma_flag"); rpcSlice->setSaoEnabledFlag((Bool)uiCode);
1266	READ_FLAG(uiCode, "slice_sao_chroma_flag"); rpcSlice->setSaoEnabledFlagChroma((Bool)uiCode);
1267	}
1268
1269	if (rpcSlice->getIdrPicFlag())
1270	{
1271	rpcSlice->setEnableTMVPFlag(false);
1272	}
1273	if (!rpcSlice->isIntra())
1274	{
1275
1276	READ_FLAG( uiCode, "num_ref_idx_active_override_flag");
1277	if (uiCode)
1278	{
1279	READ_UVLC (uiCode, "num_ref_idx_l0_active_minus1" ); rpcSlice->setNumRefIdx( REF_PIC_LIST_0, uiCode + 1 );
1280	if (rpcSlice->isInterB())
1281	{
1282	READ_UVLC (uiCode, "num_ref_idx_l1_active_minus1" ); rpcSlice->setNumRefIdx( REF_PIC_LIST_1, uiCode + 1 );
1283	}
1284	else
1285	{
1286	rpcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
1287	}
1288	}
1289	else
1290	{
1291	rpcSlice->setNumRefIdx(REF_PIC_LIST_0, rpcSlice->getPPS()->getNumRefIdxL0DefaultActive());
1292	if (rpcSlice->isInterB())
1293	{
1294	rpcSlice->setNumRefIdx(REF_PIC_LIST_1, rpcSlice->getPPS()->getNumRefIdxL1DefaultActive());
1295	}
1296	else
1297	{
1298	rpcSlice->setNumRefIdx(REF_PIC_LIST_1,0);
1299	}
1300	}
1301	}
1302	// }
1303	TComRefPicListModification* refPicListModification = rpcSlice->getRefPicListModification();
1304	if(!rpcSlice->isIntra())
1305	{
1306	if( !rpcSlice->getPPS()->getListsModificationPresentFlag() \|\| rpcSlice->getNumRpsCurrTempList() <= 1 )
1307	{
1308	refPicListModification->setRefPicListModificationFlagL0( 0 );
1309	}
1310	else
1311	{
1312	READ_FLAG( uiCode, "ref_pic_list_modification_flag_l0" ); refPicListModification->setRefPicListModificationFlagL0( uiCode ? 1 : 0 );
1313	}
1314
1315	if(refPicListModification->getRefPicListModificationFlagL0())
1316	{
1317	uiCode = 0;
1318	Int i = 0;
1319	Int numRpsCurrTempList0 = rpcSlice->getNumRpsCurrTempList();
1320	if ( numRpsCurrTempList0 > 1 )
1321	{
1322	Int length = 1;
1323	numRpsCurrTempList0 --;
1324	while ( numRpsCurrTempList0 >>= 1)
1325	{
1326	length ++;
1327	}
1328	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
1329	{
1330	READ_CODE( length, uiCode, "list_entry_l0" );
1331	refPicListModification->setRefPicSetIdxL0(i, uiCode );
1332	}
1333	}
1334	else
1335	{
1336	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_0); i ++)
1337	{
1338	refPicListModification->setRefPicSetIdxL0(i, 0 );
1339	}
1340	}
1341	}
1342	}
1343	else
1344	{
1345	refPicListModification->setRefPicListModificationFlagL0(0);
1346	}
1347	if(rpcSlice->isInterB())
1348	{
1349	if( !rpcSlice->getPPS()->getListsModificationPresentFlag() \|\| rpcSlice->getNumRpsCurrTempList() <= 1 )
1350	{
1351	refPicListModification->setRefPicListModificationFlagL1( 0 );
1352	}
1353	else
1354	{
1355	READ_FLAG( uiCode, "ref_pic_list_modification_flag_l1" ); refPicListModification->setRefPicListModificationFlagL1( uiCode ? 1 : 0 );
1356	}
1357	if(refPicListModification->getRefPicListModificationFlagL1())
1358	{
1359	uiCode = 0;
1360	Int i = 0;
1361	Int numRpsCurrTempList1 = rpcSlice->getNumRpsCurrTempList();
1362	if ( numRpsCurrTempList1 > 1 )
1363	{
1364	Int length = 1;
1365	numRpsCurrTempList1 --;
1366	while ( numRpsCurrTempList1 >>= 1)
1367	{
1368	length ++;
1369	}
1370	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
1371	{
1372	READ_CODE( length, uiCode, "list_entry_l1" );
1373	refPicListModification->setRefPicSetIdxL1(i, uiCode );
1374	}
1375	}
1376	else
1377	{
1378	for (i = 0; i < rpcSlice->getNumRefIdx(REF_PIC_LIST_1); i ++)
1379	{
1380	refPicListModification->setRefPicSetIdxL1(i, 0 );
1381	}
1382	}
1383	}
1384	}
1385	else
1386	{
1387	refPicListModification->setRefPicListModificationFlagL1(0);
1388	}
1389	if (rpcSlice->isInterB())
1390	{
1391	READ_FLAG( uiCode, "mvd_l1_zero_flag" ); rpcSlice->setMvdL1ZeroFlag( (uiCode ? true : false) );
1392	}
1393
1394	rpcSlice->setCabacInitFlag( false ); // default
1395	if(pps->getCabacInitPresentFlag() && !rpcSlice->isIntra())
1396	{
1397	READ_FLAG(uiCode, "cabac_init_flag");
1398	rpcSlice->setCabacInitFlag( uiCode ? true : false );
1399	}
1400
1401	if ( rpcSlice->getEnableTMVPFlag() )
1402	{
1403	if ( rpcSlice->getSliceType() == B_SLICE )
1404	{
1405	READ_FLAG( uiCode, "collocated_from_l0_flag" );
1406	rpcSlice->setColFromL0Flag(uiCode);
1407	}
1408	else
1409	{
1410	rpcSlice->setColFromL0Flag( 1 );
1411	}
1412
1413	if ( rpcSlice->getSliceType() != I_SLICE &&
1414	((rpcSlice->getColFromL0Flag() == 1 && rpcSlice->getNumRefIdx(REF_PIC_LIST_0) > 1)\|\|
1415	(rpcSlice->getColFromL0Flag() == 0 && rpcSlice->getNumRefIdx(REF_PIC_LIST_1) > 1)))
1416	{
1417	READ_UVLC( uiCode, "collocated_ref_idx" );
1418	rpcSlice->setColRefIdx(uiCode);
1419	}
1420	else
1421	{
1422	rpcSlice->setColRefIdx(0);
1423	}
1424	}
1425	if ( (pps->getUseWP() && rpcSlice->getSliceType()==P_SLICE) \|\| (pps->getWPBiPred() && rpcSlice->getSliceType()==B_SLICE) )
1426	{
1427	xParsePredWeightTable(rpcSlice);
1428	rpcSlice->initWpScaling();
1429	}
1430	#if H_3D_IC
1431	else if( rpcSlice->getViewIndex() && ( rpcSlice->getSliceType() == P_SLICE \|\| rpcSlice->getSliceType() == B_SLICE ) )
1432	{
1433	UInt uiCodeTmp = 0;
1434
1435	READ_FLAG ( uiCodeTmp, "slice_ic_enable_flag" );
1436	rpcSlice->setApplyIC( uiCodeTmp );
1437
1438	if ( uiCodeTmp )
1439	{
1440	READ_FLAG ( uiCodeTmp, "ic_skip_mergeidx0" );
1441	rpcSlice->setIcSkipParseFlag( uiCodeTmp );
1442	}
1443	}
1444	#endif
1445	if (!rpcSlice->isIntra())
1446	{
1447	READ_UVLC( uiCode, "five_minus_max_num_merge_cand");
1448	rpcSlice->setMaxNumMergeCand(MRG_MAX_NUM_CANDS - uiCode);
1449	}
1450
1451	READ_SVLC( iCode, "slice_qp_delta" );
1452	rpcSlice->setSliceQp (26 + pps->getPicInitQPMinus26() + iCode);
1453
1454	assert( rpcSlice->getSliceQp() >= -sps->getQpBDOffsetY() );
1455	assert( rpcSlice->getSliceQp() <= 51 );
1456
1457	if (rpcSlice->getPPS()->getSliceChromaQpFlag())
1458	{
1459	READ_SVLC( iCode, "slice_qp_delta_cb" );
1460	rpcSlice->setSliceQpDeltaCb( iCode );
1461	assert( rpcSlice->getSliceQpDeltaCb() >= -12 );
1462	assert( rpcSlice->getSliceQpDeltaCb() <= 12 );
1463	assert( (rpcSlice->getPPS()->getChromaCbQpOffset() + rpcSlice->getSliceQpDeltaCb()) >= -12 );
1464	assert( (rpcSlice->getPPS()->getChromaCbQpOffset() + rpcSlice->getSliceQpDeltaCb()) <= 12 );
1465
1466	READ_SVLC( iCode, "slice_qp_delta_cr" );
1467	rpcSlice->setSliceQpDeltaCr( iCode );
1468	assert( rpcSlice->getSliceQpDeltaCr() >= -12 );
1469	assert( rpcSlice->getSliceQpDeltaCr() <= 12 );
1470	assert( (rpcSlice->getPPS()->getChromaCrQpOffset() + rpcSlice->getSliceQpDeltaCr()) >= -12 );
1471	assert( (rpcSlice->getPPS()->getChromaCrQpOffset() + rpcSlice->getSliceQpDeltaCr()) <= 12 );
1472	}
1473
1474	if (rpcSlice->getPPS()->getDeblockingFilterControlPresentFlag())
1475	{
1476	if(rpcSlice->getPPS()->getDeblockingFilterOverrideEnabledFlag())
1477	{
1478	READ_FLAG ( uiCode, "deblocking_filter_override_flag" ); rpcSlice->setDeblockingFilterOverrideFlag(uiCode ? true : false);
1479	}
1480	else
1481	{
1482	rpcSlice->setDeblockingFilterOverrideFlag(0);
1483	}
1484	if(rpcSlice->getDeblockingFilterOverrideFlag())
1485	{
1486	READ_FLAG ( uiCode, "slice_disable_deblocking_filter_flag" ); rpcSlice->setDeblockingFilterDisable(uiCode ? 1 : 0);
1487	if(!rpcSlice->getDeblockingFilterDisable())
1488	{
1489	READ_SVLC( iCode, "slice_beta_offset_div2" ); rpcSlice->setDeblockingFilterBetaOffsetDiv2(iCode);
1490	assert(rpcSlice->getDeblockingFilterBetaOffsetDiv2() >= -6 &&
1491	rpcSlice->getDeblockingFilterBetaOffsetDiv2() <= 6);
1492	READ_SVLC( iCode, "slice_tc_offset_div2" ); rpcSlice->setDeblockingFilterTcOffsetDiv2(iCode);
1493	assert(rpcSlice->getDeblockingFilterTcOffsetDiv2() >= -6 &&
1494	rpcSlice->getDeblockingFilterTcOffsetDiv2() <= 6);
1495	}
1496	}
1497	else
1498	{
1499	rpcSlice->setDeblockingFilterDisable ( rpcSlice->getPPS()->getPicDisableDeblockingFilterFlag() );
1500	rpcSlice->setDeblockingFilterBetaOffsetDiv2( rpcSlice->getPPS()->getDeblockingFilterBetaOffsetDiv2() );
1501	rpcSlice->setDeblockingFilterTcOffsetDiv2 ( rpcSlice->getPPS()->getDeblockingFilterTcOffsetDiv2() );
1502	}
1503	}
1504	else
1505	{
1506	rpcSlice->setDeblockingFilterDisable ( false );
1507	rpcSlice->setDeblockingFilterBetaOffsetDiv2( 0 );
1508	rpcSlice->setDeblockingFilterTcOffsetDiv2 ( 0 );
1509	}
1510
1511	Bool isSAOEnabled = (!rpcSlice->getSPS()->getUseSAO())?(false):(rpcSlice->getSaoEnabledFlag()\|\|rpcSlice->getSaoEnabledFlagChroma());
1512	Bool isDBFEnabled = (!rpcSlice->getDeblockingFilterDisable());
1513
1514	if(rpcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag() && ( isSAOEnabled \|\| isDBFEnabled ))
1515	{
1516	READ_FLAG( uiCode, "slice_loop_filter_across_slices_enabled_flag");
1517	}
1518	else
1519	{
1520	uiCode = rpcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag()?1:0;
1521	}
1522	rpcSlice->setLFCrossSliceBoundaryFlag( (uiCode==1)?true:false);
1523
1524	}
1525
1526	UInt *entryPointOffset = NULL;
1527	UInt numEntryPointOffsets, offsetLenMinus1;
1528	if( pps->getTilesEnabledFlag() \|\| pps->getEntropyCodingSyncEnabledFlag() )
1529	{
1530	READ_UVLC(numEntryPointOffsets, "num_entry_point_offsets"); rpcSlice->setNumEntryPointOffsets ( numEntryPointOffsets );
1531	if (numEntryPointOffsets>0)
1532	{
1533	READ_UVLC(offsetLenMinus1, "offset_len_minus1");
1534	}
1535	entryPointOffset = new UInt[numEntryPointOffsets];
1536	for (UInt idx=0; idx<numEntryPointOffsets; idx++)
1537	{
1538	#if L0116_ENTRY_POINT
1539	READ_CODE(offsetLenMinus1+1, uiCode, "entry_point_offset_minus1");
1540	entryPointOffset[ idx ] = uiCode + 1;
1541	#else
1542	READ_CODE(offsetLenMinus1+1, uiCode, "entry_point_offset");
1543	entryPointOffset[ idx ] = uiCode;
1544	#endif
1545	}
1546	}
1547	else
1548	{
1549	rpcSlice->setNumEntryPointOffsets ( 0 );
1550	}
1551
1552	if(pps->getSliceHeaderExtensionPresentFlag())
1553	{
1554	READ_UVLC(uiCode,"slice_header_extension_length");
1555	#if H_3D
1556	if( rpcSlice->getSPS()->hasCamParInSliceHeader() )
1557	{
1558	UInt uiViewIndex = rpcSlice->getViewIndex();
1559	for( UInt uiBaseIndex = 0; uiBaseIndex < uiViewIndex; uiBaseIndex++ )
1560	{
1561	READ_SVLC( iCode, "cp_scale" ); m_aaiTempScale [ uiBaseIndex ][ uiViewIndex ] = iCode;
1562	READ_SVLC( iCode, "cp_off" ); m_aaiTempOffset[ uiBaseIndex ][ uiViewIndex ] = iCode;
1563	READ_SVLC( iCode, "cp_inv_scale_plus_scale" ); m_aaiTempScale [ uiViewIndex ][ uiBaseIndex ] = iCode - m_aaiTempScale [ uiBaseIndex ][ uiViewIndex ];
1564	READ_SVLC( iCode, "cp_inv_off_plus_off" ); m_aaiTempOffset[ uiViewIndex ][ uiBaseIndex ] = iCode - m_aaiTempOffset[ uiBaseIndex ][ uiViewIndex ];
1565	}
1566	rpcSlice->setCamparaSlice( m_aaiTempScale, m_aaiTempOffset );
1567	}
1568
1569	READ_FLAG(uiCode,"slice_segment_header_extension2_flag");
1570	if ( uiCode )
1571	{
1572	READ_UVLC(uiCode,"slice_header_extension2_length");
1573	for(Int i=0; i<uiCode; i++)
1574	{
1575	UInt ignore;
1576	READ_CODE(8,ignore,"slice_header_extension2_data_byte");
1577	}
1578	}
1579	}
1580	#else
1581	for(Int i=0; i<uiCode; i++)
1582	{
1583	UInt ignore;
1584	READ_CODE(8,ignore,"slice_header_extension_data_byte");
1585	}
1586	}
1587	#endif
1588	m_pcBitstream->readByteAlignment();
1589
1590	if( pps->getTilesEnabledFlag() \|\| pps->getEntropyCodingSyncEnabledFlag() )
1591	{
1592	Int endOfSliceHeaderLocation = m_pcBitstream->getByteLocation();
1593	Int curEntryPointOffset = 0;
1594	Int prevEntryPointOffset = 0;
1595	for (UInt idx=0; idx<numEntryPointOffsets; idx++)
1596	{
1597	curEntryPointOffset += entryPointOffset[ idx ];
1598
1599	Int emulationPreventionByteCount = 0;
1600	for ( UInt curByteIdx = 0; curByteIdx<m_pcBitstream->numEmulationPreventionBytesRead(); curByteIdx++ )
1601	{
1602	if ( m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) >= ( prevEntryPointOffset + endOfSliceHeaderLocation ) &&
1603	m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) < ( curEntryPointOffset + endOfSliceHeaderLocation ) )
1604	{
1605	emulationPreventionByteCount++;
1606	}
1607	}
1608
1609	entryPointOffset[ idx ] -= emulationPreventionByteCount;
1610	prevEntryPointOffset = curEntryPointOffset;
1611	}
1612
1613	if ( pps->getTilesEnabledFlag() )
1614	{
1615	rpcSlice->setTileLocationCount( numEntryPointOffsets );
1616
1617	UInt prevPos = 0;
1618	for (Int idx=0; idx<rpcSlice->getTileLocationCount(); idx++)
1619	{
1620	rpcSlice->setTileLocation( idx, prevPos + entryPointOffset [ idx ] );
1621	prevPos += entryPointOffset[ idx ];
1622	}
1623	}
1624	else if ( pps->getEntropyCodingSyncEnabledFlag() )
1625	{
1626	Int numSubstreams = rpcSlice->getNumEntryPointOffsets()+1;
1627	rpcSlice->allocSubstreamSizes(numSubstreams);
1628	UInt *pSubstreamSizes = rpcSlice->getSubstreamSizes();
1629	for (Int idx=0; idx<numSubstreams-1; idx++)
1630	{
1631	if ( idx < numEntryPointOffsets )
1632	{
1633	pSubstreamSizes[ idx ] = ( entryPointOffset[ idx ] << 3 ) ;
1634	}
1635	else
1636	{
1637	pSubstreamSizes[ idx ] = 0;
1638	}
1639	}
1640	}
1641
1642	if (entryPointOffset)
1643	{
1644	delete [] entryPointOffset;
1645	}
1646	}
1647
1648	return;
1649	}
1650
1651	Void TDecCavlc::parsePTL( TComPTL *rpcPTL, Bool profilePresentFlag, Int maxNumSubLayersMinus1 )
1652	{
1653	UInt uiCode;
1654	if(profilePresentFlag)
1655	{
1656	parseProfileTier(rpcPTL->getGeneralPTL());
1657	}
1658	READ_CODE( 8, uiCode, "general_level_idc" ); rpcPTL->getGeneralPTL()->setLevelIdc(uiCode);
1659
1660	#if L0363_BYTE_ALIGN
1661	for (Int i = 0; i < maxNumSubLayersMinus1; i++)
1662	{
1663	#if !H_MV
1664	if(profilePresentFlag)
1665	{
1666	#endif
1667	READ_FLAG( uiCode, "sub_layer_profile_present_flag[i]" ); rpcPTL->setSubLayerProfilePresentFlag(i, uiCode);
1668	#if H_MV
1669	rpcPTL->setSubLayerProfilePresentFlag( i, profilePresentFlag && rpcPTL->getSubLayerProfilePresentFlag(i) );
1670	#else
1671	}
1672	#endif
1673	READ_FLAG( uiCode, "sub_layer_level_present_flag[i]" ); rpcPTL->setSubLayerLevelPresentFlag (i, uiCode);
1674	}
1675
1676	if (maxNumSubLayersMinus1 > 0)
1677	{
1678	for (Int i = maxNumSubLayersMinus1; i < 8; i++)
1679	{
1680	READ_CODE(2, uiCode, "reserved_zero_2bits");
1681	assert(uiCode == 0);
1682	}
1683	}
1684	#endif
1685
1686	for(Int i = 0; i < maxNumSubLayersMinus1; i++)
1687	{
1688	#if !L0363_BYTE_ALIGN
1689	if(profilePresentFlag)
1690	{
1691	READ_FLAG( uiCode, "sub_layer_profile_present_flag[i]" ); rpcPTL->setSubLayerProfilePresentFlag(i, uiCode);
1692	}
1693	READ_FLAG( uiCode, "sub_layer_level_present_flag[i]" ); rpcPTL->setSubLayerLevelPresentFlag (i, uiCode);
1694	#endif
1695	if( profilePresentFlag && rpcPTL->getSubLayerProfilePresentFlag(i) )
1696	{
1697	parseProfileTier(rpcPTL->getSubLayerPTL(i));
1698	}
1699	if(rpcPTL->getSubLayerLevelPresentFlag(i))
1700	{
1701	READ_CODE( 8, uiCode, "sub_layer_level_idc[i]" ); rpcPTL->getSubLayerPTL(i)->setLevelIdc(uiCode);
1702	}
1703	}
1704	}
1705
1706	Void TDecCavlc::parseProfileTier(ProfileTierLevel *ptl)
1707	{
1708	UInt uiCode;
1709	READ_CODE(2 , uiCode, "XXX_profile_space[]"); ptl->setProfileSpace(uiCode);
1710	READ_FLAG( uiCode, "XXX_tier_flag[]" ); ptl->setTierFlag (uiCode ? 1 : 0);
1711	READ_CODE(5 , uiCode, "XXX_profile_idc[]" ); ptl->setProfileIdc (uiCode);
1712	for(Int j = 0; j < 32; j++)
1713	{
1714	READ_FLAG( uiCode, "XXX_profile_compatibility_flag[][j]"); ptl->setProfileCompatibilityFlag(j, uiCode ? 1 : 0);
1715	}
1716	#if L0046_CONSTRAINT_FLAGS
1717	READ_FLAG(uiCode, "general_progressive_source_flag");
1718	ptl->setProgressiveSourceFlag(uiCode ? true : false);
1719
1720	READ_FLAG(uiCode, "general_interlaced_source_flag");
1721	ptl->setInterlacedSourceFlag(uiCode ? true : false);
1722
1723	READ_FLAG(uiCode, "general_non_packed_constraint_flag");
1724	ptl->setNonPackedConstraintFlag(uiCode ? true : false);
1725
1726	READ_FLAG(uiCode, "general_frame_only_constraint_flag");
1727	ptl->setFrameOnlyConstraintFlag(uiCode ? true : false);
1728
1729	READ_CODE(16, uiCode, "XXX_reserved_zero_44bits[0..15]");
1730	READ_CODE(16, uiCode, "XXX_reserved_zero_44bits[16..31]");
1731	READ_CODE(12, uiCode, "XXX_reserved_zero_44bits[32..43]");
1732	#elif L0363_MORE_BITS
1733	READ_CODE(16, uiCode, "XXX_reserved_zero_48bits[0..15]");
1734	READ_CODE(16, uiCode, "XXX_reserved_zero_48bits[16..31]");
1735	READ_CODE(16, uiCode, "XXX_reserved_zero_48bits[32..47]");
1736	#else
1737	READ_CODE(16, uiCode, "XXX_reserved_zero_16bits[]"); assert( uiCode == 0 );
1738	#endif
1739	}
1740	#if SIGNAL_BITRATE_PICRATE_IN_VPS
1741	Void TDecCavlc::parseBitratePicRateInfo(TComBitRatePicRateInfo *info, Int tempLevelLow, Int tempLevelHigh)
1742	{
1743	UInt uiCode;
1744	for(Int i = tempLevelLow; i <= tempLevelHigh; i++)
1745	{
1746	READ_FLAG( uiCode, "bit_rate_info_present_flag[i]" ); info->setBitRateInfoPresentFlag(i, uiCode ? true : false);
1747	READ_FLAG( uiCode, "pic_rate_info_present_flag[i]" ); info->setPicRateInfoPresentFlag(i, uiCode ? true : false);
1748	if(info->getBitRateInfoPresentFlag(i))
1749	{
1750	READ_CODE( 16, uiCode, "avg_bit_rate[i]" ); info->setAvgBitRate(i, uiCode);
1751	READ_CODE( 16, uiCode, "max_bit_rate[i]" ); info->setMaxBitRate(i, uiCode);
1752	}
1753	if(info->getPicRateInfoPresentFlag(i))
1754	{
1755	READ_CODE( 2, uiCode, "constant_pic_rate_idc[i]" ); info->setConstantPicRateIdc(i, uiCode);
1756	READ_CODE( 16, uiCode, "avg_pic_rate[i]" ); info->setAvgPicRate(i, uiCode);
1757	}
1758	}
1759	}
1760	#endif
1761	Void TDecCavlc::parseTerminatingBit( UInt& ruiBit )
1762	{
1763	ruiBit = false;
1764	Int iBitsLeft = m_pcBitstream->getNumBitsLeft();
1765	if(iBitsLeft <= 8)
1766	{
1767	UInt uiPeekValue = m_pcBitstream->peekBits(iBitsLeft);
1768	if (uiPeekValue == (1<<(iBitsLeft-1)))
1769	{
1770	ruiBit = true;
1771	}
1772	}
1773	}
1774
1775	Void TDecCavlc::parseSkipFlag( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
1776	{
1777	assert(0);
1778	}
1779
1780	Void TDecCavlc::parseCUTransquantBypassFlag( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
1781	{
1782	assert(0);
1783	}
1784
1785	Void TDecCavlc::parseMVPIdx( Int& /riMVPIdx/ )
1786	{
1787	assert(0);
1788	}
1789
1790	Void TDecCavlc::parseSplitFlag ( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
1791	{
1792	assert(0);
1793	}
1794
1795	Void TDecCavlc::parsePartSize( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
1796	{
1797	assert(0);
1798	}
1799
1800	Void TDecCavlc::parsePredMode( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
1801	{
1802	assert(0);
1803	}
1804
1805	/** Parse I_PCM information.
1806	* \param pcCU pointer to CU
1807	* \param uiAbsPartIdx CU index
1808	* \param uiDepth CU depth
1809	* \returns Void
1810	*
1811	* If I_PCM flag indicates that the CU is I_PCM, parse its PCM alignment bits and codes.
1812	*/
1813	Void TDecCavlc::parseIPCMInfo( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
1814	{
1815	assert(0);
1816	}
1817
1818	Void TDecCavlc::parseIntraDirLumaAng ( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
1819	{
1820	assert(0);
1821	}
1822
1823	Void TDecCavlc::parseIntraDirChroma( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
1824	{
1825	assert(0);
1826	}
1827
1828	Void TDecCavlc::parseInterDir( TComDataCU* /pcCU/, UInt& /ruiInterDir/, UInt /uiAbsPartIdx/ )
1829	{
1830	assert(0);
1831	}
1832
1833	Void TDecCavlc::parseRefFrmIdx( TComDataCU* /pcCU/, Int& /riRefFrmIdx/, RefPicList /eRefList/ )
1834	{
1835	assert(0);
1836	}
1837
1838	Void TDecCavlc::parseMvd( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiPartIdx/, UInt /uiDepth/, RefPicList /eRefList/ )
1839	{
1840	assert(0);
1841	}
1842
1843	Void TDecCavlc::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1844	{
1845	Int qp;
1846	Int iDQp;
1847
1848	xReadSvlc( iDQp );
1849
1850	Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
1851	qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+ qpBdOffsetY)) - qpBdOffsetY;
1852
1853	UInt uiAbsQpCUPartIdx = (uiAbsPartIdx>>((g_uiMaxCUDepth - pcCU->getSlice()->getPPS()->getMaxCuDQPDepth())<<1))<<((g_uiMaxCUDepth - pcCU->getSlice()->getPPS()->getMaxCuDQPDepth())<<1) ;
1854	UInt uiQpCUDepth = min(uiDepth,pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()) ;
1855
1856	pcCU->setQPSubParts( qp, uiAbsQpCUPartIdx, uiQpCUDepth );
1857	}
1858
1859	Void TDecCavlc::parseCoeffNxN( TComDataCU* /pcCU/, TCoeff* /pcCoef/, UInt /uiAbsPartIdx/, UInt /uiWidth/, UInt /uiHeight/, UInt /uiDepth/, TextType /eTType/ )
1860	{
1861	assert(0);
1862	}
1863
1864	Void TDecCavlc::parseTransformSubdivFlag( UInt& /ruiSubdivFlag/, UInt /uiLog2TransformBlockSize/ )
1865	{
1866	assert(0);
1867	}
1868
1869	Void TDecCavlc::parseQtCbf( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, TextType /eType/, UInt /uiTrDepth/, UInt /uiDepth/ )
1870	{
1871	assert(0);
1872	}
1873
1874	Void TDecCavlc::parseQtRootCbf( UInt /uiAbsPartIdx/, UInt& /uiQtRootCbf/ )
1875	{
1876	assert(0);
1877	}
1878
1879	Void TDecCavlc::parseTransformSkipFlags (TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /width/, UInt /height/, UInt /uiDepth/, TextType /eTType/)
1880	{
1881	assert(0);
1882	}
1883
1884	Void TDecCavlc::parseMergeFlag ( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/, UInt /uiPUIdx/ )
1885	{
1886	assert(0);
1887	}
1888
1889	Void TDecCavlc::parseMergeIndex ( TComDataCU* /pcCU/, UInt& /ruiMergeIndex/ )
1890	{
1891	assert(0);
1892	}
1893
1894	#if H_3D_ARP
1895	Void TDecCavlc::parseARPW( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1896	{
1897	assert(0);
1898	}
1899	#endif
1900
1901	#if H_3D_IC
1902	Void TDecCavlc::parseICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1903	{
1904	assert(0);
1905	}
1906	#endif
1907
1908	// ====================================================================================================================
1909	// Protected member functions
1910	// ====================================================================================================================
1911
1912	/** parse explicit wp tables
1913	* \param TComSlice* pcSlice
1914	* \returns Void
1915	*/
1916	Void TDecCavlc::xParsePredWeightTable( TComSlice* pcSlice )
1917	{
1918	wpScalingParam *wp;
1919	Bool bChroma = true; // color always present in HEVC ?
1920	SliceType eSliceType = pcSlice->getSliceType();
1921	Int iNbRef = (eSliceType == B_SLICE ) ? (2) : (1);
1922	UInt uiLog2WeightDenomLuma, uiLog2WeightDenomChroma;
1923	UInt uiTotalSignalledWeightFlags = 0;
1924
1925	Int iDeltaDenom;
1926	// decode delta_luma_log2_weight_denom :
1927	READ_UVLC( uiLog2WeightDenomLuma, "luma_log2_weight_denom" ); // ue(v): luma_log2_weight_denom
1928	assert( uiLog2WeightDenomLuma <= 7 );
1929	if( bChroma )
1930	{
1931	READ_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" ); // se(v): delta_chroma_log2_weight_denom
1932	assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)>=0);
1933	assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)<=7);
1934	uiLog2WeightDenomChroma = (UInt)(iDeltaDenom + uiLog2WeightDenomLuma);
1935	}
1936
1937	for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ )
1938	{
1939	RefPicList eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
1940	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
1941	{
1942	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
1943
1944	wp[0].uiLog2WeightDenom = uiLog2WeightDenomLuma;
1945	wp[1].uiLog2WeightDenom = uiLog2WeightDenomChroma;
1946	wp[2].uiLog2WeightDenom = uiLog2WeightDenomChroma;
1947
1948	UInt uiCode;
1949	READ_FLAG( uiCode, "luma_weight_lX_flag" ); // u(1): luma_weight_l0_flag
1950	wp[0].bPresentFlag = ( uiCode == 1 );
1951	uiTotalSignalledWeightFlags += wp[0].bPresentFlag;
1952	}
1953	if ( bChroma )
1954	{
1955	UInt uiCode;
1956	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
1957	{
1958	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
1959	READ_FLAG( uiCode, "chroma_weight_lX_flag" ); // u(1): chroma_weight_l0_flag
1960	wp[1].bPresentFlag = ( uiCode == 1 );
1961	wp[2].bPresentFlag = ( uiCode == 1 );
1962	uiTotalSignalledWeightFlags += 2*wp[1].bPresentFlag;
1963	}
1964	}
1965	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
1966	{
1967	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
1968	if ( wp[0].bPresentFlag )
1969	{
1970	Int iDeltaWeight;
1971	READ_SVLC( iDeltaWeight, "delta_luma_weight_lX" ); // se(v): delta_luma_weight_l0[i]
1972	assert( iDeltaWeight >= -128 );
1973	assert( iDeltaWeight <= 127 );
1974	wp[0].iWeight = (iDeltaWeight + (1<<wp[0].uiLog2WeightDenom));
1975	READ_SVLC( wp[0].iOffset, "luma_offset_lX" ); // se(v): luma_offset_l0[i]
1976	assert( wp[0].iOffset >= -128 );
1977	assert( wp[0].iOffset <= 127 );
1978	}
1979	else
1980	{
1981	wp[0].iWeight = (1 << wp[0].uiLog2WeightDenom);
1982	wp[0].iOffset = 0;
1983	}
1984	if ( bChroma )
1985	{
1986	if ( wp[1].bPresentFlag )
1987	{
1988	for ( Int j=1 ; j<3 ; j++ )
1989	{
1990	Int iDeltaWeight;
1991	READ_SVLC( iDeltaWeight, "delta_chroma_weight_lX" ); // se(v): chroma_weight_l0[i][j]
1992	assert( iDeltaWeight >= -128 );
1993	assert( iDeltaWeight <= 127 );
1994	wp[j].iWeight = (iDeltaWeight + (1<<wp[1].uiLog2WeightDenom));
1995
1996	Int iDeltaChroma;
1997	READ_SVLC( iDeltaChroma, "delta_chroma_offset_lX" ); // se(v): delta_chroma_offset_l0[i][j]
1998	assert( iDeltaChroma >= -512 );
1999	assert( iDeltaChroma <= 511 );
2000	Int pred = ( 128 - ( ( 128*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) );
2001	wp[j].iOffset = Clip3(-128, 127, (iDeltaChroma + pred) );
2002	}
2003	}
2004	else
2005	{
2006	for ( Int j=1 ; j<3 ; j++ )
2007	{
2008	wp[j].iWeight = (1 << wp[j].uiLog2WeightDenom);
2009	wp[j].iOffset = 0;
2010	}
2011	}
2012	}
2013	}
2014
2015	for ( Int iRefIdx=pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx<MAX_NUM_REF ; iRefIdx++ )
2016	{
2017	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
2018
2019	wp[0].bPresentFlag = false;
2020	wp[1].bPresentFlag = false;
2021	wp[2].bPresentFlag = false;
2022	}
2023	}
2024	assert(uiTotalSignalledWeightFlags<=24);
2025	}
2026
2027	/** decode quantization matrix
2028	* \param scalingList quantization matrix information
2029	*/
2030	Void TDecCavlc::parseScalingList(TComScalingList* scalingList)
2031	{
2032	UInt code, sizeId, listId;
2033	Bool scalingListPredModeFlag;
2034	//for each size
2035	for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2036	{
2037	for(listId = 0; listId < g_scalingListNum[sizeId]; listId++)
2038	{
2039	READ_FLAG( code, "scaling_list_pred_mode_flag");
2040	scalingListPredModeFlag = (code) ? true : false;
2041	if(!scalingListPredModeFlag) //Copy Mode
2042	{
2043	READ_UVLC( code, "scaling_list_pred_matrix_id_delta");
2044	scalingList->setRefMatrixId (sizeId,listId,(UInt)((Int)(listId)-(code)));
2045	if( sizeId > SCALING_LIST_8x8 )
2046	{
2047	scalingList->setScalingListDC(sizeId,listId,((listId == scalingList->getRefMatrixId (sizeId,listId))? 16 :scalingList->getScalingListDC(sizeId, scalingList->getRefMatrixId (sizeId,listId))));
2048	}
2049	scalingList->processRefMatrix( sizeId, listId, scalingList->getRefMatrixId (sizeId,listId));
2050
2051	}
2052	else //DPCM Mode
2053	{
2054	xDecodeScalingList(scalingList, sizeId, listId);
2055	}
2056	}
2057	}
2058
2059	return;
2060	}
2061	/** decode DPCM
2062	* \param scalingList quantization matrix information
2063	* \param sizeId size index
2064	* \param listId list index
2065	*/
2066	Void TDecCavlc::xDecodeScalingList(TComScalingList *scalingList, UInt sizeId, UInt listId)
2067	{
2068	Int i,coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
2069	Int data;
2070	Int scalingListDcCoefMinus8 = 0;
2071	Int nextCoef = SCALING_LIST_START_VALUE;
2072	UInt* scan = (sizeId == 0) ? g_auiSigLastScan [ SCAN_DIAG ] [ 1 ] : g_sigLastScanCG32x32;
2073	Int *dst = scalingList->getScalingListAddress(sizeId, listId);
2074
2075	if( sizeId > SCALING_LIST_8x8 )
2076	{
2077	READ_SVLC( scalingListDcCoefMinus8, "scaling_list_dc_coef_minus8");
2078	scalingList->setScalingListDC(sizeId,listId,scalingListDcCoefMinus8 + 8);
2079	nextCoef = scalingList->getScalingListDC(sizeId,listId);
2080	}
2081
2082	for(i = 0; i < coefNum; i++)
2083	{
2084	READ_SVLC( data, "scaling_list_delta_coef");
2085	nextCoef = (nextCoef + data + 256 ) % 256;
2086	dst[scan[i]] = nextCoef;
2087	}
2088	}
2089
2090	Bool TDecCavlc::xMoreRbspData()
2091	{
2092	Int bitsLeft = m_pcBitstream->getNumBitsLeft();
2093
2094	// if there are more than 8 bits, it cannot be rbsp_trailing_bits
2095	if (bitsLeft > 8)
2096	{
2097	return true;
2098	}
2099
2100	UChar lastByte = m_pcBitstream->peekBits(bitsLeft);
2101	Int cnt = bitsLeft;
2102
2103	// remove trailing bits equal to zero
2104	while ((cnt>0) && ((lastByte & 1) == 0))
2105	{
2106	lastByte >>= 1;
2107	cnt--;
2108	}
2109	// remove bit equal to one
2110	cnt--;
2111
2112	// we should not have a negative number of bits
2113	assert (cnt>=0);
2114
2115	// we have more data, if cnt is not zero
2116	return (cnt>0);
2117	}
2118
2119	//! \}
2120

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-DEV-0.3-dev2a/source/Lib/TLibDecoder/TDecCAVLC.cpp @ 468

Download in other formats: