Context navigation

source: 3DVCSoftware/branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComSlice.h @ 539

Visit:

Last change on this file since 539 was 539, checked in by orange, 11 years ago
Integrated QTLPC and added new line mark at the end of TComWedgelet.cpp for MERL
Property svn:eol-style set to `native`
File size: 99.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-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 TComSlice.h
35	\brief slice header and SPS class (header)
36	*/
37
38	#ifndef __TCOMSLICE__
39	#define __TCOMSLICE__
40
41	#include <cstring>
42	#include <map>
43	#include <vector>
44	#include "CommonDef.h"
45	#include "TComRom.h"
46	#include "TComList.h"
47
48	//! \ingroup TLibCommon
49	//! \{
50
51	class TComPic;
52	class TComTrQuant;
53	#if H_MV
54	class TComPicLists;
55	#endif
56	// ====================================================================================================================
57	// Constants
58	// ====================================================================================================================
59
60	// ====================================================================================================================
61	// Class definition
62	// ====================================================================================================================
63
64	/// Reference Picture Set class
65	class TComReferencePictureSet
66	{
67	private:
68	Int m_numberOfPictures;
69	Int m_numberOfNegativePictures;
70	Int m_numberOfPositivePictures;
71	Int m_numberOfLongtermPictures;
72	Int m_deltaPOC[MAX_NUM_REF_PICS];
73	Int m_POC[MAX_NUM_REF_PICS];
74	Bool m_used[MAX_NUM_REF_PICS];
75	Bool m_interRPSPrediction;
76	Int m_deltaRIdxMinus1;
77	Int m_deltaRPS;
78	Int m_numRefIdc;
79	Int m_refIdc[MAX_NUM_REF_PICS+1];
80	Bool m_bCheckLTMSB[MAX_NUM_REF_PICS];
81	Int m_pocLSBLT[MAX_NUM_REF_PICS];
82	Int m_deltaPOCMSBCycleLT[MAX_NUM_REF_PICS];
83	Bool m_deltaPocMSBPresentFlag[MAX_NUM_REF_PICS];
84
85	public:
86	TComReferencePictureSet();
87	virtual ~TComReferencePictureSet();
88	Int getPocLSBLT(Int i) { return m_pocLSBLT[i]; }
89	Void setPocLSBLT(Int i, Int x) { m_pocLSBLT[i] = x; }
90	Int getDeltaPocMSBCycleLT(Int i) { return m_deltaPOCMSBCycleLT[i]; }
91	Void setDeltaPocMSBCycleLT(Int i, Int x) { m_deltaPOCMSBCycleLT[i] = x; }
92	Bool getDeltaPocMSBPresentFlag(Int i) { return m_deltaPocMSBPresentFlag[i]; }
93	Void setDeltaPocMSBPresentFlag(Int i, Bool x) { m_deltaPocMSBPresentFlag[i] = x; }
94	Void setUsed(Int bufferNum, Bool used);
95	Void setDeltaPOC(Int bufferNum, Int deltaPOC);
96	Void setPOC(Int bufferNum, Int deltaPOC);
97	Void setNumberOfPictures(Int numberOfPictures);
98	Void setCheckLTMSBPresent(Int bufferNum, Bool b );
99	Bool getCheckLTMSBPresent(Int bufferNum);
100
101	Int getUsed(Int bufferNum);
102	Int getDeltaPOC(Int bufferNum);
103	Int getPOC(Int bufferNum);
104	Int getNumberOfPictures();
105
106	Void setNumberOfNegativePictures(Int number) { m_numberOfNegativePictures = number; }
107	Int getNumberOfNegativePictures() { return m_numberOfNegativePictures; }
108	Void setNumberOfPositivePictures(Int number) { m_numberOfPositivePictures = number; }
109	Int getNumberOfPositivePictures() { return m_numberOfPositivePictures; }
110	Void setNumberOfLongtermPictures(Int number) { m_numberOfLongtermPictures = number; }
111	Int getNumberOfLongtermPictures() { return m_numberOfLongtermPictures; }
112
113	Void setInterRPSPrediction(Bool flag) { m_interRPSPrediction = flag; }
114	Bool getInterRPSPrediction() { return m_interRPSPrediction; }
115	Void setDeltaRIdxMinus1(Int x) { m_deltaRIdxMinus1 = x; }
116	Int getDeltaRIdxMinus1() { return m_deltaRIdxMinus1; }
117	Void setDeltaRPS(Int x) { m_deltaRPS = x; }
118	Int getDeltaRPS() { return m_deltaRPS; }
119	Void setNumRefIdc(Int x) { m_numRefIdc = x; }
120	Int getNumRefIdc() { return m_numRefIdc; }
121
122	Void setRefIdc(Int bufferNum, Int refIdc);
123	Int getRefIdc(Int bufferNum);
124
125	Void sortDeltaPOC();
126	Void printDeltaPOC();
127	};
128
129	/// Reference Picture Set set class
130	class TComRPSList
131	{
132	private:
133	Int m_numberOfReferencePictureSets;
134	TComReferencePictureSet* m_referencePictureSets;
135
136	public:
137	TComRPSList();
138	virtual ~TComRPSList();
139
140	Void create (Int numberOfEntries);
141	Void destroy ();
142
143
144	TComReferencePictureSet* getReferencePictureSet(Int referencePictureSetNum);
145	Int getNumberOfReferencePictureSets();
146	Void setNumberOfReferencePictureSets(Int numberOfReferencePictureSets);
147	};
148
149	/// SCALING_LIST class
150	class TComScalingList
151	{
152	public:
153	TComScalingList();
154	virtual ~TComScalingList();
155	Void setScalingListPresentFlag (Bool b) { m_scalingListPresentFlag = b; }
156	Bool getScalingListPresentFlag () { return m_scalingListPresentFlag; }
157	Bool getUseTransformSkip () { return m_useTransformSkip; }
158	Void setUseTransformSkip (Bool b) { m_useTransformSkip = b; }
159	Int* getScalingListAddress (UInt sizeId, UInt listId) { return m_scalingListCoef[sizeId][listId]; } //!< get matrix coefficient
160	Bool checkPredMode (UInt sizeId, UInt listId);
161	Void setRefMatrixId (UInt sizeId, UInt listId, UInt u) { m_refMatrixId[sizeId][listId] = u; } //!< set reference matrix ID
162	UInt getRefMatrixId (UInt sizeId, UInt listId) { return m_refMatrixId[sizeId][listId]; } //!< get reference matrix ID
163	Int* getScalingListDefaultAddress (UInt sizeId, UInt listId); //!< get default matrix coefficient
164	Void processDefaultMarix (UInt sizeId, UInt listId);
165	Void setScalingListDC (UInt sizeId, UInt listId, UInt u) { m_scalingListDC[sizeId][listId] = u; } //!< set DC value
166
167	Int getScalingListDC (UInt sizeId, UInt listId) { return m_scalingListDC[sizeId][listId]; } //!< get DC value
168	Void checkDcOfMatrix ();
169	Void processRefMatrix (UInt sizeId, UInt listId , UInt refListId );
170	Bool xParseScalingList (Char* pchFile);
171
172	private:
173	Void init ();
174	Void destroy ();
175	Int m_scalingListDC [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< the DC value of the matrix coefficient for 16x16
176	Bool m_useDefaultScalingMatrixFlag [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< UseDefaultScalingMatrixFlag
177	UInt m_refMatrixId [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< RefMatrixID
178	Bool m_scalingListPresentFlag; //!< flag for using default matrix
179	UInt m_predMatrixId [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< reference list index
180	Int *m_scalingListCoef [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< quantization matrix
181	Bool m_useTransformSkip; //!< transform skipping flag for setting default scaling matrix for 4x4
182	};
183
184	class ProfileTierLevel
185	{
186	Int m_profileSpace;
187	Bool m_tierFlag;
188	Int m_profileIdc;
189	Bool m_profileCompatibilityFlag[32];
190	Int m_levelIdc;
191
192	Bool m_progressiveSourceFlag;
193	Bool m_interlacedSourceFlag;
194	Bool m_nonPackedConstraintFlag;
195	Bool m_frameOnlyConstraintFlag;
196
197	public:
198	ProfileTierLevel();
199
200	Int getProfileSpace() const { return m_profileSpace; }
201	Void setProfileSpace(Int x) { m_profileSpace = x; }
202
203	Bool getTierFlag() const { return m_tierFlag; }
204	Void setTierFlag(Bool x) { m_tierFlag = x; }
205
206	Int getProfileIdc() const { return m_profileIdc; }
207	Void setProfileIdc(Int x) { m_profileIdc = x; }
208
209	Bool getProfileCompatibilityFlag(Int i) const { return m_profileCompatibilityFlag[i]; }
210	Void setProfileCompatibilityFlag(Int i, Bool x) { m_profileCompatibilityFlag[i] = x; }
211
212	Int getLevelIdc() const { return m_levelIdc; }
213	Void setLevelIdc(Int x) { m_levelIdc = x; }
214
215	Bool getProgressiveSourceFlag() const { return m_progressiveSourceFlag; }
216	Void setProgressiveSourceFlag(Bool b) { m_progressiveSourceFlag = b; }
217
218	Bool getInterlacedSourceFlag() const { return m_interlacedSourceFlag; }
219	Void setInterlacedSourceFlag(Bool b) { m_interlacedSourceFlag = b; }
220
221	Bool getNonPackedConstraintFlag() const { return m_nonPackedConstraintFlag; }
222	Void setNonPackedConstraintFlag(Bool b) { m_nonPackedConstraintFlag = b; }
223
224	Bool getFrameOnlyConstraintFlag() const { return m_frameOnlyConstraintFlag; }
225	Void setFrameOnlyConstraintFlag(Bool b) { m_frameOnlyConstraintFlag = b; }
226	};
227
228
229	class TComPTL
230	{
231	ProfileTierLevel m_generalPTL;
232	ProfileTierLevel m_subLayerPTL[6]; // max. value of max_sub_layers_minus1 is 6
233	Bool m_subLayerProfilePresentFlag[6];
234	Bool m_subLayerLevelPresentFlag[6];
235
236	public:
237	TComPTL();
238	Bool getSubLayerProfilePresentFlag(Int i) const { return m_subLayerProfilePresentFlag[i]; }
239	Void setSubLayerProfilePresentFlag(Int i, Bool x) { m_subLayerProfilePresentFlag[i] = x; }
240
241	Bool getSubLayerLevelPresentFlag(Int i) const { return m_subLayerLevelPresentFlag[i]; }
242	Void setSubLayerLevelPresentFlag(Int i, Bool x) { m_subLayerLevelPresentFlag[i] = x; }
243
244	ProfileTierLevel* getGeneralPTL() { return &m_generalPTL; }
245	ProfileTierLevel* getSubLayerPTL(Int i) { return &m_subLayerPTL[i]; }
246	#if H_MV
247	Void copyLevelFrom( TComPTL* source );
248	#endif
249	};
250	/// VPS class
251
252	struct HrdSubLayerInfo
253	{
254	Bool fixedPicRateFlag;
255	Bool fixedPicRateWithinCvsFlag;
256	UInt picDurationInTcMinus1;
257	Bool lowDelayHrdFlag;
258	UInt cpbCntMinus1;
259	UInt bitRateValueMinus1[MAX_CPB_CNT][2];
260	UInt cpbSizeValue [MAX_CPB_CNT][2];
261	UInt ducpbSizeValue [MAX_CPB_CNT][2];
262	UInt cbrFlag [MAX_CPB_CNT][2];
263	UInt duBitRateValue [MAX_CPB_CNT][2];
264	};
265
266	class TComHRD
267	{
268	private:
269	Bool m_nalHrdParametersPresentFlag;
270	Bool m_vclHrdParametersPresentFlag;
271	Bool m_subPicCpbParamsPresentFlag;
272	UInt m_tickDivisorMinus2;
273	UInt m_duCpbRemovalDelayLengthMinus1;
274	Bool m_subPicCpbParamsInPicTimingSEIFlag;
275	UInt m_dpbOutputDelayDuLengthMinus1;
276	UInt m_bitRateScale;
277	UInt m_cpbSizeScale;
278	UInt m_ducpbSizeScale;
279	UInt m_initialCpbRemovalDelayLengthMinus1;
280	UInt m_cpbRemovalDelayLengthMinus1;
281	UInt m_dpbOutputDelayLengthMinus1;
282	UInt m_numDU;
283	HrdSubLayerInfo m_HRD[MAX_TLAYER];
284
285	public:
286	TComHRD()
287	:m_nalHrdParametersPresentFlag(0)
288	,m_vclHrdParametersPresentFlag(0)
289	,m_subPicCpbParamsPresentFlag(false)
290	,m_tickDivisorMinus2(0)
291	,m_duCpbRemovalDelayLengthMinus1(0)
292	,m_subPicCpbParamsInPicTimingSEIFlag(false)
293	,m_dpbOutputDelayDuLengthMinus1(0)
294	,m_bitRateScale(0)
295	,m_cpbSizeScale(0)
296	,m_initialCpbRemovalDelayLengthMinus1(0)
297	,m_cpbRemovalDelayLengthMinus1(0)
298	,m_dpbOutputDelayLengthMinus1(0)
299	{}
300
301	virtual ~TComHRD() {}
302
303	Void setNalHrdParametersPresentFlag ( Bool flag ) { m_nalHrdParametersPresentFlag = flag; }
304	Bool getNalHrdParametersPresentFlag ( ) { return m_nalHrdParametersPresentFlag; }
305
306	Void setVclHrdParametersPresentFlag ( Bool flag ) { m_vclHrdParametersPresentFlag = flag; }
307	Bool getVclHrdParametersPresentFlag ( ) { return m_vclHrdParametersPresentFlag; }
308
309	Void setSubPicCpbParamsPresentFlag ( Bool flag ) { m_subPicCpbParamsPresentFlag = flag; }
310	Bool getSubPicCpbParamsPresentFlag ( ) { return m_subPicCpbParamsPresentFlag; }
311
312	Void setTickDivisorMinus2 ( UInt value ) { m_tickDivisorMinus2 = value; }
313	UInt getTickDivisorMinus2 ( ) { return m_tickDivisorMinus2; }
314
315	Void setDuCpbRemovalDelayLengthMinus1 ( UInt value ) { m_duCpbRemovalDelayLengthMinus1 = value; }
316	UInt getDuCpbRemovalDelayLengthMinus1 ( ) { return m_duCpbRemovalDelayLengthMinus1; }
317
318	Void setSubPicCpbParamsInPicTimingSEIFlag ( Bool flag) { m_subPicCpbParamsInPicTimingSEIFlag = flag; }
319	Bool getSubPicCpbParamsInPicTimingSEIFlag () { return m_subPicCpbParamsInPicTimingSEIFlag; }
320
321	Void setDpbOutputDelayDuLengthMinus1 (UInt value ) { m_dpbOutputDelayDuLengthMinus1 = value; }
322	UInt getDpbOutputDelayDuLengthMinus1 () { return m_dpbOutputDelayDuLengthMinus1; }
323
324	Void setBitRateScale ( UInt value ) { m_bitRateScale = value; }
325	UInt getBitRateScale ( ) { return m_bitRateScale; }
326
327	Void setCpbSizeScale ( UInt value ) { m_cpbSizeScale = value; }
328	UInt getCpbSizeScale ( ) { return m_cpbSizeScale; }
329	Void setDuCpbSizeScale ( UInt value ) { m_ducpbSizeScale = value; }
330	UInt getDuCpbSizeScale ( ) { return m_ducpbSizeScale; }
331
332	Void setInitialCpbRemovalDelayLengthMinus1( UInt value ) { m_initialCpbRemovalDelayLengthMinus1 = value; }
333	UInt getInitialCpbRemovalDelayLengthMinus1( ) { return m_initialCpbRemovalDelayLengthMinus1; }
334
335	Void setCpbRemovalDelayLengthMinus1 ( UInt value ) { m_cpbRemovalDelayLengthMinus1 = value; }
336	UInt getCpbRemovalDelayLengthMinus1 ( ) { return m_cpbRemovalDelayLengthMinus1; }
337
338	Void setDpbOutputDelayLengthMinus1 ( UInt value ) { m_dpbOutputDelayLengthMinus1 = value; }
339	UInt getDpbOutputDelayLengthMinus1 ( ) { return m_dpbOutputDelayLengthMinus1; }
340
341	Void setFixedPicRateFlag ( Int layer, Bool flag ) { m_HRD[layer].fixedPicRateFlag = flag; }
342	Bool getFixedPicRateFlag ( Int layer ) { return m_HRD[layer].fixedPicRateFlag; }
343
344	Void setFixedPicRateWithinCvsFlag ( Int layer, Bool flag ) { m_HRD[layer].fixedPicRateWithinCvsFlag = flag; }
345	Bool getFixedPicRateWithinCvsFlag ( Int layer ) { return m_HRD[layer].fixedPicRateWithinCvsFlag; }
346
347	Void setPicDurationInTcMinus1 ( Int layer, UInt value ) { m_HRD[layer].picDurationInTcMinus1 = value; }
348	UInt getPicDurationInTcMinus1 ( Int layer ) { return m_HRD[layer].picDurationInTcMinus1; }
349
350	Void setLowDelayHrdFlag ( Int layer, Bool flag ) { m_HRD[layer].lowDelayHrdFlag = flag; }
351	Bool getLowDelayHrdFlag ( Int layer ) { return m_HRD[layer].lowDelayHrdFlag; }
352
353	Void setCpbCntMinus1 ( Int layer, UInt value ) { m_HRD[layer].cpbCntMinus1 = value; }
354	UInt getCpbCntMinus1 ( Int layer ) { return m_HRD[layer].cpbCntMinus1; }
355
356	Void setBitRateValueMinus1 ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].bitRateValueMinus1[cpbcnt][nalOrVcl] = value; }
357	UInt getBitRateValueMinus1 ( Int layer, Int cpbcnt, Int nalOrVcl ) { return m_HRD[layer].bitRateValueMinus1[cpbcnt][nalOrVcl]; }
358
359	Void setCpbSizeValueMinus1 ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].cpbSizeValue[cpbcnt][nalOrVcl] = value; }
360	UInt getCpbSizeValueMinus1 ( Int layer, Int cpbcnt, Int nalOrVcl ) { return m_HRD[layer].cpbSizeValue[cpbcnt][nalOrVcl]; }
361	Void setDuCpbSizeValueMinus1 ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].ducpbSizeValue[cpbcnt][nalOrVcl] = value; }
362	UInt getDuCpbSizeValueMinus1 ( Int layer, Int cpbcnt, Int nalOrVcl ) { return m_HRD[layer].ducpbSizeValue[cpbcnt][nalOrVcl]; }
363	Void setDuBitRateValueMinus1 ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].duBitRateValue[cpbcnt][nalOrVcl] = value; }
364	UInt getDuBitRateValueMinus1 (Int layer, Int cpbcnt, Int nalOrVcl ) { return m_HRD[layer].duBitRateValue[cpbcnt][nalOrVcl]; }
365	Void setCbrFlag ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].cbrFlag[cpbcnt][nalOrVcl] = value; }
366	Bool getCbrFlag ( Int layer, Int cpbcnt, Int nalOrVcl ) { return m_HRD[layer].cbrFlag[cpbcnt][nalOrVcl]; }
367
368	Void setNumDU ( UInt value ) { m_numDU = value; }
369	UInt getNumDU ( ) { return m_numDU; }
370	Bool getCpbDpbDelaysPresentFlag() { return getNalHrdParametersPresentFlag() \|\| getVclHrdParametersPresentFlag(); }
371	};
372
373	class TimingInfo
374	{
375	Bool m_timingInfoPresentFlag;
376	UInt m_numUnitsInTick;
377	UInt m_timeScale;
378	Bool m_pocProportionalToTimingFlag;
379	Int m_numTicksPocDiffOneMinus1;
380	public:
381	TimingInfo()
382	: m_timingInfoPresentFlag(false)
383	, m_numUnitsInTick(1001)
384	, m_timeScale(60000)
385	, m_pocProportionalToTimingFlag(false)
386	, m_numTicksPocDiffOneMinus1(0) {}
387
388	Void setTimingInfoPresentFlag ( Bool flag ) { m_timingInfoPresentFlag = flag; }
389	Bool getTimingInfoPresentFlag ( ) { return m_timingInfoPresentFlag; }
390
391	Void setNumUnitsInTick ( UInt value ) { m_numUnitsInTick = value; }
392	UInt getNumUnitsInTick ( ) { return m_numUnitsInTick; }
393
394	Void setTimeScale ( UInt value ) { m_timeScale = value; }
395	UInt getTimeScale ( ) { return m_timeScale; }
396
397	Bool getPocProportionalToTimingFlag ( ) { return m_pocProportionalToTimingFlag; }
398	Void setPocProportionalToTimingFlag (Bool x ) { m_pocProportionalToTimingFlag = x; }
399
400	Int getNumTicksPocDiffOneMinus1 ( ) { return m_numTicksPocDiffOneMinus1; }
401	Void setNumTicksPocDiffOneMinus1 (Int x ) { m_numTicksPocDiffOneMinus1 = x; }
402	};
403
404	class TComVPS
405	{
406	private:
407	Int m_VPSId;
408	UInt m_uiMaxTLayers;
409	UInt m_uiMaxLayers;
410	Bool m_bTemporalIdNestingFlag;
411
412	UInt m_numReorderPics[MAX_TLAYER];
413	UInt m_uiMaxDecPicBuffering[MAX_TLAYER];
414	UInt m_uiMaxLatencyIncrease[MAX_TLAYER]; // Really max latency increase plus 1 (value 0 expresses no limit)
415
416	UInt m_numHrdParameters;
417	#if H_MV
418	UInt m_maxLayerId;
419	#else
420	UInt m_maxNuhReservedZeroLayerId;
421	#endif
422	TComHRD* m_hrdParameters;
423	UInt* m_hrdOpSetIdx;
424	Bool* m_cprmsPresentFlag;
425	#if H_MV
426	UInt m_vpsNumLayerSetsMinus1;
427	Bool m_layerIdIncludedFlag[MAX_VPS_OP_SETS_PLUS1][MAX_VPS_NUH_LAYER_ID_PLUS1];
428	#else
429	UInt m_numOpSets;
430	Bool m_layerIdIncludedFlag[MAX_VPS_OP_SETS_PLUS1][MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1];
431	#endif
432
433	#if H_MV
434	TComPTL m_pcPTL[MAX_VPS_OP_SETS_PLUS1];
435	#else
436	TComPTL m_pcPTL;
437	#endif
438	TimingInfo m_timingInfo;
439	#if H_MV
440	/// VPS EXTENSION SYNTAX ELEMENTS
441	Bool m_avcBaseLayerFlag;
442	Bool m_splittingFlag;
443	Bool m_scalabilityMask [MAX_NUM_SCALABILITY_TYPES];
444	Int m_dimensionIdLen [MAX_NUM_SCALABILITY_TYPES];
445	Bool m_vpsNuhLayerIdPresentFlag;
446	Int m_layerIdInNuh [MAX_NUM_LAYER_IDS];
447	Int m_dimensionId [MAX_NUM_LAYER_IDS][MAX_NUM_SCALABILITY_TYPES];
448	Bool m_directDependencyFlag [MAX_NUM_LAYER_IDS][MAX_NUM_LAYER_IDS];
449	Int m_maxTidIlRefPicPlus1 [MAX_NUM_LAYERS];
450	Int m_vpsNumberLayerSetsMinus1;
451	Int m_vpsNumProfileTierLevelMinus1;
452	Bool m_vpsProfilePresentFlag [MAX_VPS_OP_SETS_PLUS1];
453	Int m_profileRefMinus1 [MAX_VPS_PROFILE_TIER_LEVEL];
454	Bool m_moreOutputLayerSetsThanDefaultFlag;
455	Int m_numAddOutputLayerSetsMinus1;
456	Bool m_defaultOneTargetOutputLayerFlag;
457	Int m_outputLayerSetIdxMinus1 [MAX_VPS_OUTPUTLAYER_SETS];
458	Bool m_outputLayerFlag [MAX_VPS_OUTPUTLAYER_SETS][MAX_VPS_NUH_LAYER_ID_PLUS1];
459	Int m_profileLevelTierIdx [MAX_VPS_OUTPUTLAYER_SETS ];
460	Bool m_maxOneActiveRefLayerFlag;
461	Int m_directDepTypeLenMinus2;
462	Int m_directDependencyType [MAX_NUM_LAYERS] [MAX_NUM_LAYERS];
463
464	// VPS EXTENSION SEMANTICS VARIABLES
465	Int m_layerIdInVps [MAX_NUM_LAYERS ];
466
467	Int m_numDirectRefLayers [MAX_NUM_LAYERS];
468	Int m_refLayerId [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
469
470	Int m_numSamplePredRefLayers [MAX_NUM_LAYERS];
471	Bool m_samplePredEnabledFlag [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
472	Int m_samplePredRefLayerId [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
473
474	Int m_numMotionPredRefLayers [MAX_NUM_LAYERS];
475	Bool m_motionPredEnabledFlag [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
476	Int m_motionPredRefLayerId [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
477	#if H_3D
478	Int m_viewIndex [MAX_NUM_LAYERS ];
479	#endif
480
481	Int xCeilLog2 ( Int val );
482	Int xGetDimBitOffset( Int j );
483
484	#if H_3D_ARP
485	UInt m_uiUseAdvResPred [MAX_NUM_LAYERS ];
486	UInt m_uiARPStepNum [MAX_NUM_LAYERS ];
487	#endif
488	#if H_3D_IV_MERGE
489	Bool m_ivMvPredFlag [ MAX_NUM_LAYERS ];
490	#endif
491	#if H_3D_VSP
492	Bool m_viewSynthesisPredFlag [ MAX_NUM_LAYERS ];
493	#endif
494	#if H_3D_NBDV_REF
495	Bool m_depthRefinementFlag [ MAX_NUM_LAYERS ];
496	#endif
497	Bool m_vpsDepthModesFlag [MAX_NUM_LAYERS ];
498	#if H_3D_DIM_DLT
499	Bool m_bUseDLTFlag [MAX_NUM_LAYERS ];
500
501	Int m_iBitsPerDepthValue [MAX_NUM_LAYERS ];
502	Int m_iNumDepthmapValues [MAX_NUM_LAYERS ];
503	Int* m_iDepthValue2Idx [MAX_NUM_LAYERS ];
504	Int* m_iIdx2DepthValue [MAX_NUM_LAYERS ];
505	#endif
506	#if H_3D_TMVP
507	Bool m_ivMvScalingFlag;
508	#endif
509
510	#endif
511	public:
512	TComVPS();
513	virtual ~TComVPS();
514
515	Void createHrdParamBuffer()
516	{
517	m_hrdParameters = new TComHRD[ getNumHrdParameters() ];
518	m_hrdOpSetIdx = new UInt [ getNumHrdParameters() ];
519	m_cprmsPresentFlag = new Bool [ getNumHrdParameters() ];
520	}
521
522	TComHRD* getHrdParameters ( UInt i ) { return &m_hrdParameters[ i ]; }
523	UInt getHrdOpSetIdx ( UInt i ) { return m_hrdOpSetIdx[ i ]; }
524	Void setHrdOpSetIdx ( UInt val, UInt i ) { m_hrdOpSetIdx[ i ] = val; }
525	Bool getCprmsPresentFlag ( UInt i ) { return m_cprmsPresentFlag[ i ]; }
526	Void setCprmsPresentFlag ( Bool val, UInt i ) { m_cprmsPresentFlag[ i ] = val; }
527
528	Int getVPSId () { return m_VPSId; }
529	Void setVPSId (Int i) { m_VPSId = i; }
530
531	UInt getMaxTLayers () { return m_uiMaxTLayers; }
532	Void setMaxTLayers (UInt t) { m_uiMaxTLayers = t; }
533
534	UInt getMaxLayers () { return m_uiMaxLayers; }
535	Void setMaxLayers (UInt l) { m_uiMaxLayers = l; }
536
537	Bool getTemporalNestingFlag () { return m_bTemporalIdNestingFlag; }
538	Void setTemporalNestingFlag (Bool t) { m_bTemporalIdNestingFlag = t; }
539
540	Void setNumReorderPics(UInt v, UInt tLayer) { m_numReorderPics[tLayer] = v; }
541	UInt getNumReorderPics(UInt tLayer) { return m_numReorderPics[tLayer]; }
542
543	Void setMaxDecPicBuffering(UInt v, UInt tLayer) { m_uiMaxDecPicBuffering[tLayer] = v; }
544	UInt getMaxDecPicBuffering(UInt tLayer) { return m_uiMaxDecPicBuffering[tLayer]; }
545
546	Void setMaxLatencyIncrease(UInt v, UInt tLayer) { m_uiMaxLatencyIncrease[tLayer] = v; }
547	UInt getMaxLatencyIncrease(UInt tLayer) { return m_uiMaxLatencyIncrease[tLayer]; }
548
549	UInt getNumHrdParameters() { return m_numHrdParameters; }
550	Void setNumHrdParameters(UInt v) { m_numHrdParameters = v; }
551
552	#if H_MV
553	UInt getVpsMaxLayerId() { return m_maxLayerId; }
554	Void setVpsMaxLayerId(UInt v) { m_maxLayerId = v; }
555
556	UInt getVpsNumLayerSetsMinus1() { return m_vpsNumLayerSetsMinus1; }
557	Void setVpsNumLayerSetsMinus1(UInt v) { m_vpsNumLayerSetsMinus1 = v; }
558	#else
559	UInt getMaxNuhReservedZeroLayerId() { return m_maxNuhReservedZeroLayerId; }
560	Void setMaxNuhReservedZeroLayerId(UInt v) { m_maxNuhReservedZeroLayerId = v; }
561
562	UInt getMaxOpSets() { return m_numOpSets; }
563	Void setMaxOpSets(UInt v) { m_numOpSets = v; }
564	#endif
565	Bool getLayerIdIncludedFlag(UInt opsIdx, UInt id) { return m_layerIdIncludedFlag[opsIdx][id]; }
566	Void setLayerIdIncludedFlag(Bool v, UInt opsIdx, UInt id) { m_layerIdIncludedFlag[opsIdx][id] = v; }
567
568	#if H_MV
569	TComPTL* getPTL( Int layerSet = 0 ) { return &m_pcPTL[layerSet]; }
570	#else
571	TComPTL* getPTL() { return &m_pcPTL; }
572	#endif
573	TimingInfo* getTimingInfo() { return &m_timingInfo; }
574	#if H_MV
575	Void setAvcBaseLayerFlag( Bool val ) { m_avcBaseLayerFlag = val; }
576	Bool getAvcBaseLayerFlag() { return m_avcBaseLayerFlag; }
577
578	Void setSplittingFlag( Bool val ) { m_splittingFlag = val; }
579	Bool getSplittingFlag() { return m_splittingFlag; }
580
581	Void setScalabilityMask( UInt val );
582
583	Void setScalabilityMask( Int scalType, Bool val ) { m_scalabilityMask[scalType] = val; }
584	Bool getScalabilityMask( Int scalType ) { return m_scalabilityMask[scalType]; }
585
586	Int getNumScalabilityTypes( );
587
588	Void setDimensionIdLen( Int sIdx, Int val ) { m_dimensionIdLen[sIdx] = val; }
589	Int getDimensionIdLen( Int sIdx ) { assert( m_dimensionIdLen[sIdx] > 0) ; return m_dimensionIdLen[sIdx]; }
590
591	Void setVpsNuhLayerIdPresentFlag( Bool val ) { m_vpsNuhLayerIdPresentFlag = val; }
592	Bool getVpsNuhLayerIdPresentFlag() { return m_vpsNuhLayerIdPresentFlag; }
593
594	Void setLayerIdInNuh( Int layerIdInVps, Int val ) { m_layerIdInNuh[layerIdInVps] = val; }
595	Int getLayerIdInNuh( Int layerIdInVps ) { assert( m_layerIdInNuh[layerIdInVps] >= 0 ); return m_layerIdInNuh[layerIdInVps]; }
596
597	Bool nuhLayerIdIncluded( Int layerIdinNuh ) { return ( m_layerIdInVps[ layerIdinNuh ] > 0 ); }
598
599	Void setDimensionId( Int layerIdInVps, Int scalIdx, Int val ) { m_dimensionId[layerIdInVps][scalIdx] = val; }
600	Int getDimensionId( Int layerIdInVps, Int scalIdx ) { return m_dimensionId[layerIdInVps][scalIdx]; }
601
602	Void setDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Bool val ) { m_directDependencyFlag[depLayeridInVps][refLayeridInVps] = val; }
603	Bool getDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps ) { return m_directDependencyFlag[depLayeridInVps][refLayeridInVps]; }
604
605	Void setMaxTidIlRefPicPlus1( Int layerIdInVps, Int val ) { m_maxTidIlRefPicPlus1[ layerIdInVps ] = val; }
606	Int getMaxTidIlRefPicPlus1( Int layerIdInVps ) { return m_maxTidIlRefPicPlus1[ layerIdInVps ]; }
607
608	Void setVpsNumberLayerSetsMinus1( Int val ) { m_vpsNumberLayerSetsMinus1 = val; }
609	Int getVpsNumberLayerSetsMinus1( ) { return m_vpsNumberLayerSetsMinus1; }
610
611	Void setVpsNumProfileTierLevelMinus1( Int val ) { m_vpsNumProfileTierLevelMinus1 = val; }
612	Int getVpsNumProfileTierLevelMinus1( ) { return m_vpsNumProfileTierLevelMinus1; }
613
614	Void setVpsProfilePresentFlag( Int idx, Bool val ) { m_vpsProfilePresentFlag[idx] = val; }
615	Bool getVpsProfilePresentFlag( Int idx ) { return m_vpsProfilePresentFlag[idx]; }
616
617	Void setProfileRefMinus1( Int profileTierLevelIdx, Int val ) { m_profileRefMinus1[ profileTierLevelIdx ] = val; }
618	Int getProfileRefMinus1( Int profileTierLevelIdx ) { return m_profileRefMinus1[ profileTierLevelIdx ]; }
619
620	Void setMoreOutputLayerSetsThanDefaultFlag( Bool flag ) { m_moreOutputLayerSetsThanDefaultFlag = flag; }
621	Bool getMoreOutputLayerSetsThanDefaultFlag() { return m_moreOutputLayerSetsThanDefaultFlag; }
622
623	Void setNumAddOutputLayerSetsMinus1( Int val ) { m_numAddOutputLayerSetsMinus1 = val; }
624	Int getNumAddOutputLayerSetsMinus1( ) { return m_numAddOutputLayerSetsMinus1; }
625
626	Void setDefaultOneTargetOutputLayerFlag( Bool flag ) { m_defaultOneTargetOutputLayerFlag = flag; }
627	Bool getDefaultOneTargetOutputLayerFlag( ) { return m_defaultOneTargetOutputLayerFlag; }
628
629	Void setOutputLayerSetIdxMinus1( Int outLayerSetIdx, Int val ) { m_outputLayerSetIdxMinus1[ outLayerSetIdx ] = val; }
630	Int getOutputLayerSetIdxMinus1( Int outLayerSetIdx ) { return m_outputLayerSetIdxMinus1[ outLayerSetIdx ]; }
631
632	Void setOutputLayerFlag( Int outLayerSetIdx, Int i, Bool flag ) { m_outputLayerFlag[ outLayerSetIdx ][ i ] = flag; }
633	Bool getOutputLayerFlag( Int outLayerSetIdx, Int i ) { return m_outputLayerFlag[ outLayerSetIdx ][ i ]; }
634
635	Void setProfileLevelTierIdx( Int outLayerSetIdx, Int val ) { m_profileLevelTierIdx[ outLayerSetIdx = val ]; }
636	Int getProfileLevelTierIdx( Int outLayerSetIdx ) { return m_profileLevelTierIdx[ outLayerSetIdx ]; }
637
638	Void setMaxOneActiveRefLayerFlag( Bool flag) { m_maxOneActiveRefLayerFlag = flag; }
639	Bool getMaxOneActiveRefLayerFlag( ) { return m_maxOneActiveRefLayerFlag; }
640
641	Void setDirectDepTypeLenMinus2( Int val) { m_directDepTypeLenMinus2 = val; }
642	Int getDirectDepTypeLenMinus2( ) { return m_directDepTypeLenMinus2; }
643
644	Void setDirectDependencyType( Int depLayeridInVps, Int refLayeridInVps, Int val) { m_directDependencyType[ depLayeridInVps ][ refLayeridInVps ] = val; }
645	Int getDirectDependencyType( Int depLayeridInVps, Int refLayeridInVps) { return m_directDependencyType[ depLayeridInVps ][ refLayeridInVps ]; }
646
647
648	// VPS EXTENSION SEMANTICS VARIABLES
649	Void setLayerIdInVps( Int layerIdInNuh, Int val ) { m_layerIdInVps[layerIdInNuh] = val; }
650	Int getLayerIdInVps( Int layerIdInNuh ) { assert( m_layerIdInVps[layerIdInNuh] >= 0 ); return m_layerIdInVps[layerIdInNuh]; }
651
652	Int getScalabilityId ( Int layerIdInVps, ScalabilityType scalType );
653	Int getViewId ( Int layerIdInVps ) { return getScalabilityId( layerIdInVps, VIEW_ID ); }
654
655	Void setRefLayers();
656
657	Int getNumDirectRefLayers( Int layerIdInVps ) { return m_numDirectRefLayers[ layerIdInVps ]; };
658	Int getRefLayerId ( Int layerIdInVps, Int idx );;
659
660	Int getNumSamplePredRefLayers( Int layerIdInVps ) { return m_numSamplePredRefLayers[layerIdInVps]; }
661	Bool getSamplePredEnabledFlag ( Int layerIdInVps, Int idx ) { return m_samplePredEnabledFlag [layerIdInVps][idx]; }
662	Int getSamplePredRefLayerId ( Int layerIdInVps, Int idx ) { return m_samplePredRefLayerId [layerIdInVps][idx]; }
663
664	Int getNumMotionPredRefLayers( Int layerIdInVps ) { return m_numMotionPredRefLayers[layerIdInVps]; }
665	Bool getMotionPredEnabledFlag ( Int layerIdInVps, Int idx ) { return m_motionPredEnabledFlag [layerIdInVps][idx]; }
666	Int getMotionPredRefLayerId ( Int layerIdInVps, Int idx ) { return m_motionPredRefLayerId [layerIdInVps][idx]; }
667
668	Bool checkVPSExtensionSyntax();
669	Int scalTypeToScalIdx ( ScalabilityType scalType );
670
671	Int getProfileLevelTierIdxLen() { return xCeilLog2( getVpsNumProfileTierLevelMinus1() + 1 ); };
672	Int getNumLayersInIdList ( Int lsIdx );;
673
674	// inference
675	Int inferDimensionId ( Int i, Int j );
676	Int inferLastDimsionIdLenMinus1();
677
678	#if H_3D
679	Void initViewIndex();
680	Int getViewIndex ( Int layerIdInVps ) { return m_viewIndex[ layerIdInVps ]; }
681	Int getDepthId ( Int layerIdInVps ) { return getScalabilityId( layerIdInVps, DEPTH_ID ); }
682	Int getLayerIdInNuh( Int viewIndex, Bool depthFlag );
683
684	#if H_3D_ARP
685	UInt getUseAdvRP ( Int layerIdInVps ) { return m_uiUseAdvResPred[layerIdInVps]; }
686	UInt getARPStepNum( Int layerIdInVps ) { return m_uiARPStepNum[layerIdInVps]; }
687	Void setUseAdvRP ( Int layerIdInVps, UInt val ) { m_uiUseAdvResPred[layerIdInVps] = val; }
688	Void setARPStepNum( Int layerIdInVps, UInt val ) { m_uiARPStepNum[layerIdInVps] = val; }
689	#endif
690	#if H_3D_IV_MERGE
691	Void setIvMvPredFlag ( Int layerIdInVps, Bool val ) { m_ivMvPredFlag[ layerIdInVps ] = val; }
692	Bool getIvMvPredFlag ( Int layerIdInVps ) { return m_ivMvPredFlag[ layerIdInVps ]; };
693	#endif
694	#if H_3D_VSP
695	Void setViewSynthesisPredFlag ( Int layerIdInVps, Bool val ) { m_viewSynthesisPredFlag[ layerIdInVps ] = val; }
696	Bool getViewSynthesisPredFlag ( Int layerIdInVps ) { return m_viewSynthesisPredFlag[ layerIdInVps ]; };
697	#endif
698	#if H_3D_NBDV_REF
699	Void setDepthRefinementFlag ( Int layerIdInVps, Bool val ) { m_depthRefinementFlag[ layerIdInVps ] = val; }
700	Bool getDepthRefinementFlag ( Int layerIdInVps ) { return m_depthRefinementFlag[ layerIdInVps ]; };
701	#endif
702	Void setVpsDepthModesFlag( Int layerIdInVps, Bool val ) { m_vpsDepthModesFlag[ layerIdInVps ] = val; }
703	Bool getVpsDepthModesFlag( Int layerIdInVps ) { return m_vpsDepthModesFlag[ layerIdInVps ]; }
704	#if H_3D_DIM_DLT
705	Bool getUseDLTFlag ( Int layerIdInVps ) { return m_bUseDLTFlag[ layerIdInVps ]; }
706	Void setUseDLTFlag ( Int layerIdInVps, Bool b ) { m_bUseDLTFlag[ layerIdInVps ] = b; }
707
708	Int getBitsPerDepthValue( Int layerIdInVps ) { return getUseDLTFlag(layerIdInVps)?m_iBitsPerDepthValue[layerIdInVps]:g_bitDepthY; }
709	Int getNumDepthValues( Int layerIdInVps ) { return getUseDLTFlag(layerIdInVps)?m_iNumDepthmapValues[layerIdInVps]:((1 << g_bitDepthY)-1); }
710	Int depthValue2idx( Int layerIdInVps, Pel value ) { return getUseDLTFlag(layerIdInVps)?m_iDepthValue2Idx[layerIdInVps][value]:value; }
711	Pel idx2DepthValue( Int layerIdInVps, UInt uiIdx ) { return getUseDLTFlag(layerIdInVps)?m_iIdx2DepthValue[layerIdInVps][uiIdx]:uiIdx; }
712	Void setDepthLUTs( Int layerIdInVps, Int* idx2DepthValue = NULL, Int iNumDepthValues = 0 );
713	#endif
714
715	#if H_3D_TMVP
716	Bool getIvMvScalingFlag ( ) { return m_ivMvScalingFlag; }
717	Void setIvMvScalingFlag ( Bool b ) { m_ivMvScalingFlag = b; }
718	#endif
719
720	#endif
721	#endif
722	};
723
724	class Window
725	{
726	private:
727	Bool m_enabledFlag;
728	Int m_winLeftOffset;
729	Int m_winRightOffset;
730	Int m_winTopOffset;
731	Int m_winBottomOffset;
732	public:
733	Window()
734	: m_enabledFlag (false)
735	, m_winLeftOffset (0)
736	, m_winRightOffset (0)
737	, m_winTopOffset (0)
738	, m_winBottomOffset (0)
739	{ }
740
741	Bool getWindowEnabledFlag() const { return m_enabledFlag; }
742	Void resetWindow() { m_enabledFlag = false; m_winLeftOffset = m_winRightOffset = m_winTopOffset = m_winBottomOffset = 0; }
743	Int getWindowLeftOffset() const { return m_enabledFlag ? m_winLeftOffset : 0; }
744	Void setWindowLeftOffset(Int val) { m_winLeftOffset = val; m_enabledFlag = true; }
745	Int getWindowRightOffset() const { return m_enabledFlag ? m_winRightOffset : 0; }
746	Void setWindowRightOffset(Int val) { m_winRightOffset = val; m_enabledFlag = true; }
747	Int getWindowTopOffset() const { return m_enabledFlag ? m_winTopOffset : 0; }
748	Void setWindowTopOffset(Int val) { m_winTopOffset = val; m_enabledFlag = true; }
749	Int getWindowBottomOffset() const { return m_enabledFlag ? m_winBottomOffset: 0; }
750	Void setWindowBottomOffset(Int val) { m_winBottomOffset = val; m_enabledFlag = true; }
751
752	Void setWindow(Int offsetLeft, Int offsetLRight, Int offsetLTop, Int offsetLBottom)
753	{
754	m_enabledFlag = true;
755	m_winLeftOffset = offsetLeft;
756	m_winRightOffset = offsetLRight;
757	m_winTopOffset = offsetLTop;
758	m_winBottomOffset = offsetLBottom;
759	}
760	};
761
762
763	class TComVUI
764	{
765	private:
766	Bool m_aspectRatioInfoPresentFlag;
767	Int m_aspectRatioIdc;
768	Int m_sarWidth;
769	Int m_sarHeight;
770	Bool m_overscanInfoPresentFlag;
771	Bool m_overscanAppropriateFlag;
772	Bool m_videoSignalTypePresentFlag;
773	Int m_videoFormat;
774	Bool m_videoFullRangeFlag;
775	Bool m_colourDescriptionPresentFlag;
776	Int m_colourPrimaries;
777	Int m_transferCharacteristics;
778	Int m_matrixCoefficients;
779	Bool m_chromaLocInfoPresentFlag;
780	Int m_chromaSampleLocTypeTopField;
781	Int m_chromaSampleLocTypeBottomField;
782	Bool m_neutralChromaIndicationFlag;
783	Bool m_fieldSeqFlag;
784
785	Window m_defaultDisplayWindow;
786	Bool m_frameFieldInfoPresentFlag;
787	Bool m_hrdParametersPresentFlag;
788	Bool m_bitstreamRestrictionFlag;
789	Bool m_tilesFixedStructureFlag;
790	Bool m_motionVectorsOverPicBoundariesFlag;
791	Bool m_restrictedRefPicListsFlag;
792	Int m_minSpatialSegmentationIdc;
793	Int m_maxBytesPerPicDenom;
794	Int m_maxBitsPerMinCuDenom;
795	Int m_log2MaxMvLengthHorizontal;
796	Int m_log2MaxMvLengthVertical;
797	TComHRD m_hrdParameters;
798	TimingInfo m_timingInfo;
799	#if H_MV
800	Bool m_tileBoundariesAlignedFlag;
801	#endif
802
803	public:
804	TComVUI()
805	:m_aspectRatioInfoPresentFlag(false)
806	,m_aspectRatioIdc(0)
807	,m_sarWidth(0)
808	,m_sarHeight(0)
809	,m_overscanInfoPresentFlag(false)
810	,m_overscanAppropriateFlag(false)
811	,m_videoSignalTypePresentFlag(false)
812	,m_videoFormat(5)
813	,m_videoFullRangeFlag(false)
814	,m_colourDescriptionPresentFlag(false)
815	,m_colourPrimaries(2)
816	,m_transferCharacteristics(2)
817	,m_matrixCoefficients(2)
818	,m_chromaLocInfoPresentFlag(false)
819	,m_chromaSampleLocTypeTopField(0)
820	,m_chromaSampleLocTypeBottomField(0)
821	,m_neutralChromaIndicationFlag(false)
822	,m_fieldSeqFlag(false)
823	,m_frameFieldInfoPresentFlag(false)
824	,m_hrdParametersPresentFlag(false)
825	,m_bitstreamRestrictionFlag(false)
826	,m_tilesFixedStructureFlag(false)
827	,m_motionVectorsOverPicBoundariesFlag(true)
828	,m_restrictedRefPicListsFlag(1)
829	,m_minSpatialSegmentationIdc(0)
830	,m_maxBytesPerPicDenom(2)
831	,m_maxBitsPerMinCuDenom(1)
832	,m_log2MaxMvLengthHorizontal(15)
833	,m_log2MaxMvLengthVertical(15)
834	#if H_MV
835	,m_tileBoundariesAlignedFlag(true)
836	#endif
837	{}
838
839	virtual ~TComVUI() {}
840
841	Bool getAspectRatioInfoPresentFlag() { return m_aspectRatioInfoPresentFlag; }
842	Void setAspectRatioInfoPresentFlag(Bool i) { m_aspectRatioInfoPresentFlag = i; }
843
844	Int getAspectRatioIdc() { return m_aspectRatioIdc; }
845	Void setAspectRatioIdc(Int i) { m_aspectRatioIdc = i; }
846
847	Int getSarWidth() { return m_sarWidth; }
848	Void setSarWidth(Int i) { m_sarWidth = i; }
849
850	Int getSarHeight() { return m_sarHeight; }
851	Void setSarHeight(Int i) { m_sarHeight = i; }
852
853	Bool getOverscanInfoPresentFlag() { return m_overscanInfoPresentFlag; }
854	Void setOverscanInfoPresentFlag(Bool i) { m_overscanInfoPresentFlag = i; }
855
856	Bool getOverscanAppropriateFlag() { return m_overscanAppropriateFlag; }
857	Void setOverscanAppropriateFlag(Bool i) { m_overscanAppropriateFlag = i; }
858
859	Bool getVideoSignalTypePresentFlag() { return m_videoSignalTypePresentFlag; }
860	Void setVideoSignalTypePresentFlag(Bool i) { m_videoSignalTypePresentFlag = i; }
861
862	Int getVideoFormat() { return m_videoFormat; }
863	Void setVideoFormat(Int i) { m_videoFormat = i; }
864
865	Bool getVideoFullRangeFlag() { return m_videoFullRangeFlag; }
866	Void setVideoFullRangeFlag(Bool i) { m_videoFullRangeFlag = i; }
867
868	Bool getColourDescriptionPresentFlag() { return m_colourDescriptionPresentFlag; }
869	Void setColourDescriptionPresentFlag(Bool i) { m_colourDescriptionPresentFlag = i; }
870
871	Int getColourPrimaries() { return m_colourPrimaries; }
872	Void setColourPrimaries(Int i) { m_colourPrimaries = i; }
873
874	Int getTransferCharacteristics() { return m_transferCharacteristics; }
875	Void setTransferCharacteristics(Int i) { m_transferCharacteristics = i; }
876
877	Int getMatrixCoefficients() { return m_matrixCoefficients; }
878	Void setMatrixCoefficients(Int i) { m_matrixCoefficients = i; }
879
880	Bool getChromaLocInfoPresentFlag() { return m_chromaLocInfoPresentFlag; }
881	Void setChromaLocInfoPresentFlag(Bool i) { m_chromaLocInfoPresentFlag = i; }
882
883	Int getChromaSampleLocTypeTopField() { return m_chromaSampleLocTypeTopField; }
884	Void setChromaSampleLocTypeTopField(Int i) { m_chromaSampleLocTypeTopField = i; }
885
886	Int getChromaSampleLocTypeBottomField() { return m_chromaSampleLocTypeBottomField; }
887	Void setChromaSampleLocTypeBottomField(Int i) { m_chromaSampleLocTypeBottomField = i; }
888
889	Bool getNeutralChromaIndicationFlag() { return m_neutralChromaIndicationFlag; }
890	Void setNeutralChromaIndicationFlag(Bool i) { m_neutralChromaIndicationFlag = i; }
891
892	Bool getFieldSeqFlag() { return m_fieldSeqFlag; }
893	Void setFieldSeqFlag(Bool i) { m_fieldSeqFlag = i; }
894
895	Bool getFrameFieldInfoPresentFlag() { return m_frameFieldInfoPresentFlag; }
896	Void setFrameFieldInfoPresentFlag(Bool i) { m_frameFieldInfoPresentFlag = i; }
897
898	Window& getDefaultDisplayWindow() { return m_defaultDisplayWindow; }
899	Void setDefaultDisplayWindow(Window& defaultDisplayWindow ) { m_defaultDisplayWindow = defaultDisplayWindow; }
900
901	Bool getHrdParametersPresentFlag() { return m_hrdParametersPresentFlag; }
902	Void setHrdParametersPresentFlag(Bool i) { m_hrdParametersPresentFlag = i; }
903
904	Bool getBitstreamRestrictionFlag() { return m_bitstreamRestrictionFlag; }
905	Void setBitstreamRestrictionFlag(Bool i) { m_bitstreamRestrictionFlag = i; }
906
907	Bool getTilesFixedStructureFlag() { return m_tilesFixedStructureFlag; }
908	Void setTilesFixedStructureFlag(Bool i) { m_tilesFixedStructureFlag = i; }
909
910	Bool getMotionVectorsOverPicBoundariesFlag() { return m_motionVectorsOverPicBoundariesFlag; }
911	Void setMotionVectorsOverPicBoundariesFlag(Bool i) { m_motionVectorsOverPicBoundariesFlag = i; }
912
913	Bool getRestrictedRefPicListsFlag() { return m_restrictedRefPicListsFlag; }
914	Void setRestrictedRefPicListsFlag(Bool b) { m_restrictedRefPicListsFlag = b; }
915
916	Int getMinSpatialSegmentationIdc() { return m_minSpatialSegmentationIdc; }
917	Void setMinSpatialSegmentationIdc(Int i) { m_minSpatialSegmentationIdc = i; }
918	Int getMaxBytesPerPicDenom() { return m_maxBytesPerPicDenom; }
919	Void setMaxBytesPerPicDenom(Int i) { m_maxBytesPerPicDenom = i; }
920
921	Int getMaxBitsPerMinCuDenom() { return m_maxBitsPerMinCuDenom; }
922	Void setMaxBitsPerMinCuDenom(Int i) { m_maxBitsPerMinCuDenom = i; }
923
924	Int getLog2MaxMvLengthHorizontal() { return m_log2MaxMvLengthHorizontal; }
925	Void setLog2MaxMvLengthHorizontal(Int i) { m_log2MaxMvLengthHorizontal = i; }
926
927	Int getLog2MaxMvLengthVertical() { return m_log2MaxMvLengthVertical; }
928	Void setLog2MaxMvLengthVertical(Int i) { m_log2MaxMvLengthVertical = i; }
929
930	TComHRD* getHrdParameters () { return &m_hrdParameters; }
931	TimingInfo* getTimingInfo() { return &m_timingInfo; }
932	#if H_MV
933	Bool getTileBoundariesAlignedFlag( ) { return m_tileBoundariesAlignedFlag; }
934	Void setTileBoundariesAlignedFlag( Bool flag ) { m_tileBoundariesAlignedFlag = flag; }
935	#endif
936	};
937
938	/// SPS class
939	class TComSPS
940	{
941	private:
942	Int m_SPSId;
943	Int m_VPSId;
944	Int m_chromaFormatIdc;
945
946	UInt m_uiMaxTLayers; // maximum number of temporal layers
947
948	// Structure
949	UInt m_picWidthInLumaSamples;
950	UInt m_picHeightInLumaSamples;
951
952	Int m_log2MinCodingBlockSize;
953	Int m_log2DiffMaxMinCodingBlockSize;
954	UInt m_uiMaxCUWidth;
955	UInt m_uiMaxCUHeight;
956	UInt m_uiMaxCUDepth;
957
958	Window m_conformanceWindow;
959
960	TComRPSList m_RPSList;
961	Bool m_bLongTermRefsPresent;
962	Bool m_TMVPFlagsPresent;
963	Int m_numReorderPics[MAX_TLAYER];
964
965	// Tool list
966	UInt m_uiQuadtreeTULog2MaxSize;
967	UInt m_uiQuadtreeTULog2MinSize;
968	UInt m_uiQuadtreeTUMaxDepthInter;
969	UInt m_uiQuadtreeTUMaxDepthIntra;
970	Bool m_usePCM;
971	UInt m_pcmLog2MaxSize;
972	UInt m_uiPCMLog2MinSize;
973	Bool m_useAMP;
974
975	#if H_3D_QTLPC
976	Bool m_bUseQTL;
977	Bool m_bUsePC;
978	#endif
979
980	// Parameter
981	Int m_bitDepthY;
982	Int m_bitDepthC;
983	Int m_qpBDOffsetY;
984	Int m_qpBDOffsetC;
985
986	Bool m_useLossless;
987
988	UInt m_uiPCMBitDepthLuma;
989	UInt m_uiPCMBitDepthChroma;
990	Bool m_bPCMFilterDisableFlag;
991
992	UInt m_uiBitsForPOC;
993	UInt m_numLongTermRefPicSPS;
994	UInt m_ltRefPicPocLsbSps[33];
995	Bool m_usedByCurrPicLtSPSFlag[33];
996	// Max physical transform size
997	UInt m_uiMaxTrSize;
998
999	Int m_iAMPAcc[MAX_CU_DEPTH];
1000	Bool m_bUseSAO;
1001
1002	Bool m_bTemporalIdNestingFlag; // temporal_id_nesting_flag
1003
1004	Bool m_scalingListEnabledFlag;
1005	Bool m_scalingListPresentFlag;
1006	TComScalingList* m_scalingList; //!< ScalingList class pointer
1007	UInt m_uiMaxDecPicBuffering[MAX_TLAYER];
1008	UInt m_uiMaxLatencyIncrease[MAX_TLAYER]; // Really max latency increase plus 1 (value 0 expresses no limit)
1009
1010	Bool m_useDF;
1011	Bool m_useStrongIntraSmoothing;
1012
1013	Bool m_vuiParametersPresentFlag;
1014	TComVUI m_vuiParameters;
1015
1016	static const Int m_winUnitX[MAX_CHROMA_FORMAT_IDC+1];
1017	static const Int m_winUnitY[MAX_CHROMA_FORMAT_IDC+1];
1018	TComPTL m_pcPTL;
1019	#if H_MV
1020	Bool m_interViewMvVertConstraintFlag;
1021	Int m_numIlpRestrictedRefLayers ;
1022	Int m_minSpatialSegmentOffsetPlus1[MAX_NUM_LAYERS];
1023	Bool m_ctuBasedOffsetEnabledFlag [MAX_NUM_LAYERS];
1024	Int m_minHorizontalCtuOffsetPlus1 [MAX_NUM_LAYERS];
1025	#endif
1026	#if H_3D
1027	UInt m_uiCamParPrecision;
1028	Bool m_bCamParInSliceHeader;
1029	Int m_aaiCodedScale [2][MAX_NUM_LAYERS];
1030	Int m_aaiCodedOffset[2][MAX_NUM_LAYERS];
1031	#endif
1032	#if H_MV
1033	Int m_layerId;
1034	#endif
1035	public:
1036	TComSPS();
1037	virtual ~TComSPS();
1038
1039	Int getVPSId () { return m_VPSId; }
1040	Void setVPSId (Int i) { m_VPSId = i; }
1041	Int getSPSId () { return m_SPSId; }
1042	Void setSPSId (Int i) { m_SPSId = i; }
1043	Int getChromaFormatIdc () { return m_chromaFormatIdc; }
1044	Void setChromaFormatIdc (Int i) { m_chromaFormatIdc = i; }
1045
1046	static Int getWinUnitX (Int chromaFormatIdc) { assert (chromaFormatIdc > 0 && chromaFormatIdc <= MAX_CHROMA_FORMAT_IDC); return m_winUnitX[chromaFormatIdc]; }
1047	static Int getWinUnitY (Int chromaFormatIdc) { assert (chromaFormatIdc > 0 && chromaFormatIdc <= MAX_CHROMA_FORMAT_IDC); return m_winUnitY[chromaFormatIdc]; }
1048
1049	// structure
1050	Void setPicWidthInLumaSamples ( UInt u ) { m_picWidthInLumaSamples = u; }
1051	UInt getPicWidthInLumaSamples () { return m_picWidthInLumaSamples; }
1052	Void setPicHeightInLumaSamples ( UInt u ) { m_picHeightInLumaSamples = u; }
1053	UInt getPicHeightInLumaSamples () { return m_picHeightInLumaSamples; }
1054
1055	Window& getConformanceWindow() { return m_conformanceWindow; }
1056	Void setConformanceWindow(Window& conformanceWindow ) { m_conformanceWindow = conformanceWindow; }
1057
1058	UInt getNumLongTermRefPicSPS() { return m_numLongTermRefPicSPS; }
1059	Void setNumLongTermRefPicSPS(UInt val) { m_numLongTermRefPicSPS = val; }
1060
1061	UInt getLtRefPicPocLsbSps(UInt index) { return m_ltRefPicPocLsbSps[index]; }
1062	Void setLtRefPicPocLsbSps(UInt index, UInt val) { m_ltRefPicPocLsbSps[index] = val; }
1063
1064	Bool getUsedByCurrPicLtSPSFlag(Int i) {return m_usedByCurrPicLtSPSFlag[i];}
1065	Void setUsedByCurrPicLtSPSFlag(Int i, Bool x) { m_usedByCurrPicLtSPSFlag[i] = x;}
1066
1067	Int getLog2MinCodingBlockSize() const { return m_log2MinCodingBlockSize; }
1068	Void setLog2MinCodingBlockSize(Int val) { m_log2MinCodingBlockSize = val; }
1069	Int getLog2DiffMaxMinCodingBlockSize() const { return m_log2DiffMaxMinCodingBlockSize; }
1070	Void setLog2DiffMaxMinCodingBlockSize(Int val) { m_log2DiffMaxMinCodingBlockSize = val; }
1071
1072	Void setMaxCUWidth ( UInt u ) { m_uiMaxCUWidth = u; }
1073	UInt getMaxCUWidth () { return m_uiMaxCUWidth; }
1074	Void setMaxCUHeight ( UInt u ) { m_uiMaxCUHeight = u; }
1075	UInt getMaxCUHeight () { return m_uiMaxCUHeight; }
1076	Void setMaxCUDepth ( UInt u ) { m_uiMaxCUDepth = u; }
1077	UInt getMaxCUDepth () { return m_uiMaxCUDepth; }
1078	Void setUsePCM ( Bool b ) { m_usePCM = b; }
1079	Bool getUsePCM () { return m_usePCM; }
1080	Void setPCMLog2MaxSize ( UInt u ) { m_pcmLog2MaxSize = u; }
1081	UInt getPCMLog2MaxSize () { return m_pcmLog2MaxSize; }
1082	Void setPCMLog2MinSize ( UInt u ) { m_uiPCMLog2MinSize = u; }
1083	UInt getPCMLog2MinSize () { return m_uiPCMLog2MinSize; }
1084	Void setBitsForPOC ( UInt u ) { m_uiBitsForPOC = u; }
1085	UInt getBitsForPOC () { return m_uiBitsForPOC; }
1086	Bool getUseAMP() { return m_useAMP; }
1087	Void setUseAMP( Bool b ) { m_useAMP = b; }
1088	Void setQuadtreeTULog2MaxSize( UInt u ) { m_uiQuadtreeTULog2MaxSize = u; }
1089	UInt getQuadtreeTULog2MaxSize() { return m_uiQuadtreeTULog2MaxSize; }
1090	Void setQuadtreeTULog2MinSize( UInt u ) { m_uiQuadtreeTULog2MinSize = u; }
1091	UInt getQuadtreeTULog2MinSize() { return m_uiQuadtreeTULog2MinSize; }
1092	Void setQuadtreeTUMaxDepthInter( UInt u ) { m_uiQuadtreeTUMaxDepthInter = u; }
1093	Void setQuadtreeTUMaxDepthIntra( UInt u ) { m_uiQuadtreeTUMaxDepthIntra = u; }
1094	UInt getQuadtreeTUMaxDepthInter() { return m_uiQuadtreeTUMaxDepthInter; }
1095	UInt getQuadtreeTUMaxDepthIntra() { return m_uiQuadtreeTUMaxDepthIntra; }
1096	Void setNumReorderPics(Int i, UInt tlayer) { m_numReorderPics[tlayer] = i; }
1097	Int getNumReorderPics(UInt tlayer) { return m_numReorderPics[tlayer]; }
1098	Void createRPSList( Int numRPS );
1099	TComRPSList* getRPSList() { return &m_RPSList; }
1100	Bool getLongTermRefsPresent() { return m_bLongTermRefsPresent; }
1101	Void setLongTermRefsPresent(Bool b) { m_bLongTermRefsPresent=b; }
1102	Bool getTMVPFlagsPresent() { return m_TMVPFlagsPresent; }
1103	Void setTMVPFlagsPresent(Bool b) { m_TMVPFlagsPresent=b; }
1104	// physical transform
1105	Void setMaxTrSize ( UInt u ) { m_uiMaxTrSize = u; }
1106	UInt getMaxTrSize () { return m_uiMaxTrSize; }
1107
1108	// Tool list
1109	Bool getUseLossless () { return m_useLossless; }
1110	Void setUseLossless ( Bool b ) { m_useLossless = b; }
1111
1112	// AMP accuracy
1113	Int getAMPAcc ( UInt uiDepth ) { return m_iAMPAcc[uiDepth]; }
1114	Void setAMPAcc ( UInt uiDepth, Int iAccu ) { assert( uiDepth < g_uiMaxCUDepth); m_iAMPAcc[uiDepth] = iAccu; }
1115
1116	// Bit-depth
1117	Int getBitDepthY() { return m_bitDepthY; }
1118	Void setBitDepthY(Int u) { m_bitDepthY = u; }
1119	Int getBitDepthC() { return m_bitDepthC; }
1120	Void setBitDepthC(Int u) { m_bitDepthC = u; }
1121	Int getQpBDOffsetY () { return m_qpBDOffsetY; }
1122	Void setQpBDOffsetY ( Int value ) { m_qpBDOffsetY = value; }
1123	Int getQpBDOffsetC () { return m_qpBDOffsetC; }
1124	Void setQpBDOffsetC ( Int value ) { m_qpBDOffsetC = value; }
1125	Void setUseSAO (Bool bVal) {m_bUseSAO = bVal;}
1126	Bool getUseSAO () {return m_bUseSAO;}
1127
1128	UInt getMaxTLayers() { return m_uiMaxTLayers; }
1129	Void setMaxTLayers( UInt uiMaxTLayers ) { assert( uiMaxTLayers <= MAX_TLAYER ); m_uiMaxTLayers = uiMaxTLayers; }
1130
1131	Bool getTemporalIdNestingFlag() { return m_bTemporalIdNestingFlag; }
1132	Void setTemporalIdNestingFlag( Bool bValue ) { m_bTemporalIdNestingFlag = bValue; }
1133	UInt getPCMBitDepthLuma () { return m_uiPCMBitDepthLuma; }
1134	Void setPCMBitDepthLuma ( UInt u ) { m_uiPCMBitDepthLuma = u; }
1135	UInt getPCMBitDepthChroma () { return m_uiPCMBitDepthChroma; }
1136	Void setPCMBitDepthChroma ( UInt u ) { m_uiPCMBitDepthChroma = u; }
1137	Void setPCMFilterDisableFlag ( Bool bValue ) { m_bPCMFilterDisableFlag = bValue; }
1138	Bool getPCMFilterDisableFlag () { return m_bPCMFilterDisableFlag; }
1139
1140	Bool getScalingListFlag () { return m_scalingListEnabledFlag; }
1141	Void setScalingListFlag ( Bool b ) { m_scalingListEnabledFlag = b; }
1142	Bool getScalingListPresentFlag() { return m_scalingListPresentFlag; }
1143	Void setScalingListPresentFlag( Bool b ) { m_scalingListPresentFlag = b; }
1144	Void setScalingList ( TComScalingList *scalingList);
1145	TComScalingList* getScalingList () { return m_scalingList; } //!< get ScalingList class pointer in SPS
1146	UInt getMaxDecPicBuffering (UInt tlayer) { return m_uiMaxDecPicBuffering[tlayer]; }
1147	Void setMaxDecPicBuffering ( UInt ui, UInt tlayer ) { m_uiMaxDecPicBuffering[tlayer] = ui; }
1148	UInt getMaxLatencyIncrease (UInt tlayer) { return m_uiMaxLatencyIncrease[tlayer]; }
1149	Void setMaxLatencyIncrease ( UInt ui , UInt tlayer) { m_uiMaxLatencyIncrease[tlayer] = ui; }
1150
1151	Void setUseStrongIntraSmoothing (Bool bVal) {m_useStrongIntraSmoothing = bVal;}
1152	Bool getUseStrongIntraSmoothing () {return m_useStrongIntraSmoothing;}
1153
1154	Bool getVuiParametersPresentFlag() { return m_vuiParametersPresentFlag; }
1155	Void setVuiParametersPresentFlag(Bool b) { m_vuiParametersPresentFlag = b; }
1156	TComVUI* getVuiParameters() { return &m_vuiParameters; }
1157	Void setHrdParameters( UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess );
1158
1159	TComPTL* getPTL() { return &m_pcPTL; }
1160	#if H_MV
1161	Void setInterViewMvVertConstraintFlag(Bool val) { m_interViewMvVertConstraintFlag = val; }
1162	Bool getInterViewMvVertConstraintFlag() { return m_interViewMvVertConstraintFlag;}
1163
1164	//// sps_extension_vui_parameters( )
1165	Void setNumIlpRestrictedRefLayers ( Int val ) { m_numIlpRestrictedRefLayers = val;}
1166	Int getNumIlpRestrictedRefLayers ( ) { return m_numIlpRestrictedRefLayers ;}
1167
1168	Void setMinSpatialSegmentOffsetPlus1( Int i, Int val ) { m_minSpatialSegmentOffsetPlus1[ i ] = val;}
1169	Int getMinSpatialSegmentOffsetPlus1( Int i ) { return m_minSpatialSegmentOffsetPlus1[ i ];}
1170
1171	Void setCtuBasedOffsetEnabledFlag ( Int i, Bool flag ) { m_ctuBasedOffsetEnabledFlag [ i ] = flag;}
1172	Bool getCtuBasedOffsetEnabledFlag ( Int i ) { return m_ctuBasedOffsetEnabledFlag [ i ];}
1173
1174	Void setMinHorizontalCtuOffsetPlus1 ( Int i, Int val ) { m_minHorizontalCtuOffsetPlus1 [ i ] = val;}
1175	Int getMinHorizontalCtuOffsetPlus1 ( Int i ) { return m_minHorizontalCtuOffsetPlus1 [ i ];}
1176	#endif
1177
1178	#if H_3D_QTLPC
1179	Void setUseQTL( Bool b ) { m_bUseQTL = b; }
1180	Bool getUseQTL() { return m_bUseQTL; }
1181	Void setUsePC ( Bool b ) { m_bUsePC = b; }
1182	Bool getUsePC () { return m_bUsePC; }
1183	#endif
1184
1185	#if H_3D
1186	Void initCamParaSPS ( UInt uiViewIndex, UInt uiCamParPrecision = 0, Bool bCamParSlice = false, Int aaiScale = 0, Int aaiOffset = 0 );
1187	UInt getCamParPrecision () { return m_uiCamParPrecision; }
1188	Bool hasCamParInSliceHeader() { return m_bCamParInSliceHeader; }
1189	Int* getCodedScale () { return m_aaiCodedScale [0]; }
1190	Int* getCodedOffset () { return m_aaiCodedOffset[0]; }
1191	Int* getInvCodedScale () { return m_aaiCodedScale [1]; }
1192	Int* getInvCodedOffset () { return m_aaiCodedOffset[1]; }
1193	#endif
1194	#if H_MV
1195	Int getLayerId () { return m_layerId; }
1196	Void setLayerId ( Int val ) { m_layerId = val; }
1197	#endif
1198
1199	};
1200
1201	/// Reference Picture Lists class
1202	class TComRefPicListModification
1203	{
1204	private:
1205	UInt m_bRefPicListModificationFlagL0;
1206	UInt m_bRefPicListModificationFlagL1;
1207	UInt m_RefPicSetIdxL0[32];
1208	UInt m_RefPicSetIdxL1[32];
1209
1210	public:
1211	TComRefPicListModification();
1212	virtual ~TComRefPicListModification();
1213
1214	Void create ();
1215	Void destroy ();
1216
1217	Bool getRefPicListModificationFlagL0() { return m_bRefPicListModificationFlagL0; }
1218	Void setRefPicListModificationFlagL0(Bool flag) { m_bRefPicListModificationFlagL0 = flag; }
1219	Bool getRefPicListModificationFlagL1() { return m_bRefPicListModificationFlagL1; }
1220	Void setRefPicListModificationFlagL1(Bool flag) { m_bRefPicListModificationFlagL1 = flag; }
1221	Void setRefPicSetIdxL0(UInt idx, UInt refPicSetIdx) { m_RefPicSetIdxL0[idx] = refPicSetIdx; }
1222	UInt getRefPicSetIdxL0(UInt idx) { return m_RefPicSetIdxL0[idx]; }
1223	Void setRefPicSetIdxL1(UInt idx, UInt refPicSetIdx) { m_RefPicSetIdxL1[idx] = refPicSetIdx; }
1224	UInt getRefPicSetIdxL1(UInt idx) { return m_RefPicSetIdxL1[idx]; }
1225	#if H_MV
1226	// Why not an listIdx for all members, would avoid code duplication??
1227	Void setRefPicSetIdxL(UInt li, UInt idx, UInt refPicSetIdx) {( li==0 ? m_RefPicSetIdxL0[idx] : m_RefPicSetIdxL1[idx] ) = refPicSetIdx; }
1228	UInt getRefPicSetIdxL(UInt li, UInt idx ) { return ( li == 0 ) ? m_RefPicSetIdxL0[idx] : m_RefPicSetIdxL1[idx] ; }
1229	Void setRefPicListModificationFlagL(UInt li, Bool flag) { ( li==0 ? m_bRefPicListModificationFlagL0 : m_bRefPicListModificationFlagL1 ) = flag; }
1230	Bool getRefPicListModificationFlagL(UInt li ) { return ( li== 0) ? m_bRefPicListModificationFlagL0 : m_bRefPicListModificationFlagL1; }
1231	#endif
1232	};
1233
1234	/// PPS class
1235	class TComPPS
1236	{
1237	private:
1238	Int m_PPSId; // pic_parameter_set_id
1239	Int m_SPSId; // seq_parameter_set_id
1240	Int m_picInitQPMinus26;
1241	Bool m_useDQP;
1242	Bool m_bConstrainedIntraPred; // constrained_intra_pred_flag
1243	Bool m_bSliceChromaQpFlag; // slicelevel_chroma_qp_flag
1244
1245	// access channel
1246	TComSPS* m_pcSPS;
1247	UInt m_uiMaxCuDQPDepth;
1248	UInt m_uiMinCuDQPSize;
1249
1250	Int m_chromaCbQpOffset;
1251	Int m_chromaCrQpOffset;
1252
1253	UInt m_numRefIdxL0DefaultActive;
1254	UInt m_numRefIdxL1DefaultActive;
1255
1256	Bool m_bUseWeightPred; // Use of Weighting Prediction (P_SLICE)
1257	Bool m_useWeightedBiPred; // Use of Weighting Bi-Prediction (B_SLICE)
1258	Bool m_OutputFlagPresentFlag; // Indicates the presence of output_flag in slice header
1259
1260	Bool m_TransquantBypassEnableFlag; // Indicates presence of cu_transquant_bypass_flag in CUs.
1261	Bool m_useTransformSkip;
1262	Bool m_dependentSliceSegmentsEnabledFlag; //!< Indicates the presence of dependent slices
1263	Bool m_tilesEnabledFlag; //!< Indicates the presence of tiles
1264	Bool m_entropyCodingSyncEnabledFlag; //!< Indicates the presence of wavefronts
1265
1266	Bool m_loopFilterAcrossTilesEnabledFlag;
1267	Int m_uniformSpacingFlag;
1268	Int m_iNumColumnsMinus1;
1269	UInt* m_puiColumnWidth;
1270	Int m_iNumRowsMinus1;
1271	UInt* m_puiRowHeight;
1272
1273	Int m_iNumSubstreams;
1274
1275	Int m_signHideFlag;
1276
1277	Bool m_cabacInitPresentFlag;
1278	UInt m_encCABACTableIdx; // Used to transmit table selection across slices
1279
1280	Bool m_sliceHeaderExtensionPresentFlag;
1281	Bool m_loopFilterAcrossSlicesEnabledFlag;
1282	Bool m_deblockingFilterControlPresentFlag;
1283	Bool m_deblockingFilterOverrideEnabledFlag;
1284	Bool m_picDisableDeblockingFilterFlag;
1285	Int m_deblockingFilterBetaOffsetDiv2; //< beta offset for deblocking filter
1286	Int m_deblockingFilterTcOffsetDiv2; //< tc offset for deblocking filter
1287	Bool m_scalingListPresentFlag;
1288	TComScalingList* m_scalingList; //!< ScalingList class pointer
1289	Bool m_listsModificationPresentFlag;
1290	UInt m_log2ParallelMergeLevelMinus2;
1291	Int m_numExtraSliceHeaderBits;
1292
1293	public:
1294	TComPPS();
1295	virtual ~TComPPS();
1296
1297	Int getPPSId () { return m_PPSId; }
1298	Void setPPSId (Int i) { m_PPSId = i; }
1299	Int getSPSId () { return m_SPSId; }
1300	Void setSPSId (Int i) { m_SPSId = i; }
1301
1302	Int getPicInitQPMinus26 () { return m_picInitQPMinus26; }
1303	Void setPicInitQPMinus26 ( Int i ) { m_picInitQPMinus26 = i; }
1304	Bool getUseDQP () { return m_useDQP; }
1305	Void setUseDQP ( Bool b ) { m_useDQP = b; }
1306	Bool getConstrainedIntraPred () { return m_bConstrainedIntraPred; }
1307	Void setConstrainedIntraPred ( Bool b ) { m_bConstrainedIntraPred = b; }
1308	Bool getSliceChromaQpFlag () { return m_bSliceChromaQpFlag; }
1309	Void setSliceChromaQpFlag ( Bool b ) { m_bSliceChromaQpFlag = b; }
1310
1311	Void setSPS ( TComSPS* pcSPS ) { m_pcSPS = pcSPS; }
1312	TComSPS* getSPS () { return m_pcSPS; }
1313	Void setMaxCuDQPDepth ( UInt u ) { m_uiMaxCuDQPDepth = u; }
1314	UInt getMaxCuDQPDepth () { return m_uiMaxCuDQPDepth;}
1315	Void setMinCuDQPSize ( UInt u ) { m_uiMinCuDQPSize = u; }
1316	UInt getMinCuDQPSize () { return m_uiMinCuDQPSize; }
1317
1318	Void setChromaCbQpOffset( Int i ) { m_chromaCbQpOffset = i; }
1319	Int getChromaCbQpOffset() { return m_chromaCbQpOffset; }
1320	Void setChromaCrQpOffset( Int i ) { m_chromaCrQpOffset = i; }
1321	Int getChromaCrQpOffset() { return m_chromaCrQpOffset; }
1322
1323	Void setNumRefIdxL0DefaultActive(UInt ui) { m_numRefIdxL0DefaultActive=ui; }
1324	UInt getNumRefIdxL0DefaultActive() { return m_numRefIdxL0DefaultActive; }
1325	Void setNumRefIdxL1DefaultActive(UInt ui) { m_numRefIdxL1DefaultActive=ui; }
1326	UInt getNumRefIdxL1DefaultActive() { return m_numRefIdxL1DefaultActive; }
1327
1328	Bool getUseWP () { return m_bUseWeightPred; }
1329	Bool getWPBiPred () { return m_useWeightedBiPred; }
1330	Void setUseWP ( Bool b ) { m_bUseWeightPred = b; }
1331	Void setWPBiPred ( Bool b ) { m_useWeightedBiPred = b; }
1332	Void setOutputFlagPresentFlag( Bool b ) { m_OutputFlagPresentFlag = b; }
1333	Bool getOutputFlagPresentFlag() { return m_OutputFlagPresentFlag; }
1334	Void setTransquantBypassEnableFlag( Bool b ) { m_TransquantBypassEnableFlag = b; }
1335	Bool getTransquantBypassEnableFlag() { return m_TransquantBypassEnableFlag; }
1336
1337	Bool getUseTransformSkip () { return m_useTransformSkip; }
1338	Void setUseTransformSkip ( Bool b ) { m_useTransformSkip = b; }
1339
1340	Void setLoopFilterAcrossTilesEnabledFlag (Bool b) { m_loopFilterAcrossTilesEnabledFlag = b; }
1341	Bool getLoopFilterAcrossTilesEnabledFlag () { return m_loopFilterAcrossTilesEnabledFlag; }
1342	Bool getDependentSliceSegmentsEnabledFlag() const { return m_dependentSliceSegmentsEnabledFlag; }
1343	Void setDependentSliceSegmentsEnabledFlag(Bool val) { m_dependentSliceSegmentsEnabledFlag = val; }
1344	Bool getTilesEnabledFlag() const { return m_tilesEnabledFlag; }
1345	Void setTilesEnabledFlag(Bool val) { m_tilesEnabledFlag = val; }
1346	Bool getEntropyCodingSyncEnabledFlag() const { return m_entropyCodingSyncEnabledFlag; }
1347	Void setEntropyCodingSyncEnabledFlag(Bool val) { m_entropyCodingSyncEnabledFlag = val; }
1348	Void setUniformSpacingFlag ( Bool b ) { m_uniformSpacingFlag = b; }
1349	Bool getUniformSpacingFlag () { return m_uniformSpacingFlag; }
1350	Void setNumColumnsMinus1 ( Int i ) { m_iNumColumnsMinus1 = i; }
1351	Int getNumColumnsMinus1 () { return m_iNumColumnsMinus1; }
1352	Void setColumnWidth ( UInt* columnWidth )
1353	{
1354	if( m_uniformSpacingFlag == 0 && m_iNumColumnsMinus1 > 0 )
1355	{
1356	m_puiColumnWidth = new UInt[ m_iNumColumnsMinus1 ];
1357
1358	for(Int i=0; i<m_iNumColumnsMinus1; i++)
1359	{
1360	m_puiColumnWidth[i] = columnWidth[i];
1361	}
1362	}
1363	}
1364	UInt getColumnWidth (UInt columnIdx) { return *( m_puiColumnWidth + columnIdx ); }
1365	Void setNumRowsMinus1( Int i ) { m_iNumRowsMinus1 = i; }
1366	Int getNumRowsMinus1() { return m_iNumRowsMinus1; }
1367	Void setRowHeight ( UInt* rowHeight )
1368	{
1369	if( m_uniformSpacingFlag == 0 && m_iNumRowsMinus1 > 0 )
1370	{
1371	m_puiRowHeight = new UInt[ m_iNumRowsMinus1 ];
1372
1373	for(Int i=0; i<m_iNumRowsMinus1; i++)
1374	{
1375	m_puiRowHeight[i] = rowHeight[i];
1376	}
1377	}
1378	}
1379	UInt getRowHeight (UInt rowIdx) { return *( m_puiRowHeight + rowIdx ); }
1380	Void setNumSubstreams(Int iNumSubstreams) { m_iNumSubstreams = iNumSubstreams; }
1381	Int getNumSubstreams() { return m_iNumSubstreams; }
1382
1383	Void setSignHideFlag( Int signHideFlag ) { m_signHideFlag = signHideFlag; }
1384	Int getSignHideFlag() { return m_signHideFlag; }
1385
1386	Void setCabacInitPresentFlag( Bool flag ) { m_cabacInitPresentFlag = flag; }
1387	Void setEncCABACTableIdx( Int idx ) { m_encCABACTableIdx = idx; }
1388	Bool getCabacInitPresentFlag() { return m_cabacInitPresentFlag; }
1389	UInt getEncCABACTableIdx() { return m_encCABACTableIdx; }
1390	Void setDeblockingFilterControlPresentFlag( Bool val ) { m_deblockingFilterControlPresentFlag = val; }
1391	Bool getDeblockingFilterControlPresentFlag() { return m_deblockingFilterControlPresentFlag; }
1392	Void setDeblockingFilterOverrideEnabledFlag( Bool val ) { m_deblockingFilterOverrideEnabledFlag = val; }
1393	Bool getDeblockingFilterOverrideEnabledFlag() { return m_deblockingFilterOverrideEnabledFlag; }
1394	Void setPicDisableDeblockingFilterFlag(Bool val) { m_picDisableDeblockingFilterFlag = val; } //!< set offset for deblocking filter disabled
1395	Bool getPicDisableDeblockingFilterFlag() { return m_picDisableDeblockingFilterFlag; } //!< get offset for deblocking filter disabled
1396	Void setDeblockingFilterBetaOffsetDiv2(Int val) { m_deblockingFilterBetaOffsetDiv2 = val; } //!< set beta offset for deblocking filter
1397	Int getDeblockingFilterBetaOffsetDiv2() { return m_deblockingFilterBetaOffsetDiv2; } //!< get beta offset for deblocking filter
1398	Void setDeblockingFilterTcOffsetDiv2(Int val) { m_deblockingFilterTcOffsetDiv2 = val; } //!< set tc offset for deblocking filter
1399	Int getDeblockingFilterTcOffsetDiv2() { return m_deblockingFilterTcOffsetDiv2; } //!< get tc offset for deblocking filter
1400	Bool getScalingListPresentFlag() { return m_scalingListPresentFlag; }
1401	Void setScalingListPresentFlag( Bool b ) { m_scalingListPresentFlag = b; }
1402	Void setScalingList ( TComScalingList *scalingList);
1403	TComScalingList* getScalingList () { return m_scalingList; } //!< get ScalingList class pointer in PPS
1404	Bool getListsModificationPresentFlag () { return m_listsModificationPresentFlag; }
1405	Void setListsModificationPresentFlag ( Bool b ) { m_listsModificationPresentFlag = b; }
1406	UInt getLog2ParallelMergeLevelMinus2 () { return m_log2ParallelMergeLevelMinus2; }
1407	Void setLog2ParallelMergeLevelMinus2 (UInt mrgLevel) { m_log2ParallelMergeLevelMinus2 = mrgLevel; }
1408	Int getNumExtraSliceHeaderBits() { return m_numExtraSliceHeaderBits; }
1409	Void setNumExtraSliceHeaderBits(Int i) { m_numExtraSliceHeaderBits = i; }
1410	Void setLoopFilterAcrossSlicesEnabledFlag ( Bool bValue ) { m_loopFilterAcrossSlicesEnabledFlag = bValue; }
1411	Bool getLoopFilterAcrossSlicesEnabledFlag () { return m_loopFilterAcrossSlicesEnabledFlag; }
1412	Bool getSliceHeaderExtensionPresentFlag () { return m_sliceHeaderExtensionPresentFlag; }
1413	Void setSliceHeaderExtensionPresentFlag (Bool val) { m_sliceHeaderExtensionPresentFlag = val; }
1414	};
1415
1416	typedef struct
1417	{
1418	// Explicit weighted prediction parameters parsed in slice header,
1419	// or Implicit weighted prediction parameters (8 bits depth values).
1420	Bool bPresentFlag;
1421	UInt uiLog2WeightDenom;
1422	Int iWeight;
1423	Int iOffset;
1424
1425	// Weighted prediction scaling values built from above parameters (bitdepth scaled):
1426	Int w, o, offset, shift, round;
1427	} wpScalingParam;
1428
1429	typedef struct
1430	{
1431	Int64 iAC;
1432	Int64 iDC;
1433	} wpACDCParam;
1434
1435	/// slice header class
1436	class TComSlice
1437	{
1438
1439	private:
1440	// Bitstream writing
1441	Bool m_saoEnabledFlag;
1442	Bool m_saoEnabledFlagChroma; ///< SAO Cb&Cr enabled flag
1443	Int m_iPPSId; ///< picture parameter set ID
1444	Bool m_PicOutputFlag; ///< pic_output_flag
1445	Int m_iPOC;
1446	Int m_iLastIDR;
1447	static Int m_prevPOC;
1448	TComReferencePictureSet *m_pcRPS;
1449	TComReferencePictureSet m_LocalRPS;
1450	Int m_iBDidx;
1451	TComRefPicListModification m_RefPicListModification;
1452	NalUnitType m_eNalUnitType; ///< Nal unit type for the slice
1453	SliceType m_eSliceType;
1454	Int m_iSliceQp;
1455	Bool m_dependentSliceSegmentFlag;
1456	#if ADAPTIVE_QP_SELECTION
1457	Int m_iSliceQpBase;
1458	#endif
1459	Bool m_deblockingFilterDisable;
1460	Bool m_deblockingFilterOverrideFlag; //< offsets for deblocking filter inherit from PPS
1461	Int m_deblockingFilterBetaOffsetDiv2; //< beta offset for deblocking filter
1462	Int m_deblockingFilterTcOffsetDiv2; //< tc offset for deblocking filter
1463	Int m_list1IdxToList0Idx[MAX_NUM_REF];
1464	Int m_aiNumRefIdx [2]; // for multiple reference of current slice
1465
1466	Bool m_bCheckLDC;
1467
1468	// Data
1469	Int m_iSliceQpDelta;
1470	Int m_iSliceQpDeltaCb;
1471	Int m_iSliceQpDeltaCr;
1472	TComPic* m_apcRefPicList [2][MAX_NUM_REF+1];
1473	Int m_aiRefPOCList [2][MAX_NUM_REF+1];
1474	#if H_MV
1475	Int m_aiRefLayerIdList[2][MAX_NUM_REF+1];
1476	#endif
1477	Bool m_bIsUsedAsLongTerm[2][MAX_NUM_REF+1];
1478	Int m_iDepth;
1479
1480	// referenced slice?
1481	Bool m_bRefenced;
1482
1483	// access channel
1484	TComVPS* m_pcVPS;
1485	TComSPS* m_pcSPS;
1486	TComPPS* m_pcPPS;
1487	TComPic* m_pcPic;
1488	#if ADAPTIVE_QP_SELECTION
1489	TComTrQuant* m_pcTrQuant;
1490	#endif
1491	UInt m_colFromL0Flag; // collocated picture from List0 flag
1492
1493	UInt m_colRefIdx;
1494	UInt m_maxNumMergeCand;
1495
1496
1497	#if SAO_CHROMA_LAMBDA
1498	Double m_dLambdaLuma;
1499	Double m_dLambdaChroma;
1500	#else
1501	Double m_dLambda;
1502	#endif
1503
1504	Bool m_abEqualRef [2][MAX_NUM_REF][MAX_NUM_REF];
1505	UInt m_uiTLayer;
1506	Bool m_bTLayerSwitchingFlag;
1507
1508	UInt m_sliceMode;
1509	UInt m_sliceArgument;
1510	UInt m_sliceCurStartCUAddr;
1511	UInt m_sliceCurEndCUAddr;
1512	UInt m_sliceIdx;
1513	UInt m_sliceSegmentMode;
1514	UInt m_sliceSegmentArgument;
1515	UInt m_sliceSegmentCurStartCUAddr;
1516	UInt m_sliceSegmentCurEndCUAddr;
1517	Bool m_nextSlice;
1518	Bool m_nextSliceSegment;
1519	UInt m_sliceBits;
1520	UInt m_sliceSegmentBits;
1521	Bool m_bFinalized;
1522
1523	wpScalingParam m_weightPredTable[2][MAX_NUM_REF][3]; // [REF_PIC_LIST_0 or REF_PIC_LIST_1][refIdx][0:Y, 1:U, 2:V]
1524	wpACDCParam m_weightACDCParam[3]; // [0:Y, 1:U, 2:V]
1525
1526	std::vector<UInt> m_tileByteLocation;
1527	UInt m_uiTileOffstForMultES;
1528
1529	UInt* m_puiSubstreamSizes;
1530	TComScalingList* m_scalingList; //!< pointer of quantization matrix
1531	Bool m_cabacInitFlag;
1532
1533	Bool m_bLMvdL1Zero;
1534	Int m_numEntryPointOffsets;
1535	Bool m_temporalLayerNonReferenceFlag;
1536	Bool m_LFCrossSliceBoundaryFlag;
1537
1538	Bool m_enableTMVPFlag;
1539	#if H_MV
1540	std::vector<TComPic> m_refPicSetInterLayer;
1541	Int m_layerId;
1542	Int m_viewId;
1543	#if H_3D
1544	Int m_viewIndex;
1545	Bool m_isDepth;
1546	#endif
1547
1548	// Additional slice header syntax elements
1549	Bool m_discardableFlag;
1550	Bool m_interLayerPredEnabledFlag;
1551	Int m_numInterLayerRefPicsMinus1;
1552	Int m_interLayerPredLayerIdc [MAX_NUM_LAYERS];
1553	Bool m_interLayerSamplePredOnlyFlag;
1554	Bool m_altCollocatedIndicationFlag;
1555	Int m_collocatedRefLayerIdx;
1556	// Additional slice header semantics variables
1557	Int m_numActiveMotionPredRefLayers;
1558	Int m_activeMotionPredRefLayerId [ MAX_NUM_LAYER_IDS ];
1559
1560	Int m_aaiCodedScale [2][MAX_NUM_LAYERS];
1561	Int m_aaiCodedOffset[2][MAX_NUM_LAYERS];
1562	#if H_3D_TMVP
1563	Int m_aiAlterRefIdx [2];
1564	#endif
1565	#if H_3D_ARP
1566	TComList<TComPic> m_pBaseViewRefPicList[MAX_NUM_LAYERS];
1567	UInt m_nARPStepNum;
1568	#endif
1569	#if H_3D_IC
1570	Bool m_bApplyIC;
1571	Bool m_icSkipParseFlag;
1572	#endif
1573	#if H_3D_GEN
1574	TComPic* m_ivPicsCurrPoc [2][MAX_NUM_LAYERS];
1575	Int** m_depthToDisparityB;
1576	Int** m_depthToDisparityF;
1577	#endif
1578	#endif
1579	public:
1580	TComSlice();
1581	virtual ~TComSlice();
1582	Void initSlice ();
1583
1584	Void setVPS ( TComVPS* pcVPS ) { m_pcVPS = pcVPS; }
1585	TComVPS* getVPS () { return m_pcVPS; }
1586	Void setSPS ( TComSPS* pcSPS ) { m_pcSPS = pcSPS; }
1587	TComSPS* getSPS () { return m_pcSPS; }
1588
1589	Void setPPS ( TComPPS* pcPPS ) { assert(pcPPS!=NULL); m_pcPPS = pcPPS; m_iPPSId = pcPPS->getPPSId(); }
1590	TComPPS* getPPS () { return m_pcPPS; }
1591
1592	#if ADAPTIVE_QP_SELECTION
1593	Void setTrQuant ( TComTrQuant* pcTrQuant ) { m_pcTrQuant = pcTrQuant; }
1594	TComTrQuant* getTrQuant () { return m_pcTrQuant; }
1595	#endif
1596
1597	Void setPPSId ( Int PPSId ) { m_iPPSId = PPSId; }
1598	Int getPPSId () { return m_iPPSId; }
1599	Void setPicOutputFlag( Bool b ) { m_PicOutputFlag = b; }
1600	Bool getPicOutputFlag() { return m_PicOutputFlag; }
1601	Void setSaoEnabledFlag(Bool s) {m_saoEnabledFlag =s; }
1602	Bool getSaoEnabledFlag() { return m_saoEnabledFlag; }
1603	Void setSaoEnabledFlagChroma(Bool s) {m_saoEnabledFlagChroma =s; } //!< set SAO Cb&Cr enabled flag
1604	Bool getSaoEnabledFlagChroma() { return m_saoEnabledFlagChroma; } //!< get SAO Cb&Cr enabled flag
1605	Void setRPS ( TComReferencePictureSet *pcRPS ) { m_pcRPS = pcRPS; }
1606	TComReferencePictureSet* getRPS () { return m_pcRPS; }
1607	TComReferencePictureSet* getLocalRPS () { return &m_LocalRPS; }
1608
1609	Void setRPSidx ( Int iBDidx ) { m_iBDidx = iBDidx; }
1610	Int getRPSidx () { return m_iBDidx; }
1611	Int getPrevPOC () { return m_prevPOC; }
1612	TComRefPicListModification* getRefPicListModification() { return &m_RefPicListModification; }
1613	Void setLastIDR(Int iIDRPOC) { m_iLastIDR = iIDRPOC; }
1614	Int getLastIDR() { return m_iLastIDR; }
1615	SliceType getSliceType () { return m_eSliceType; }
1616	Int getPOC () { return m_iPOC; }
1617	Int getSliceQp () { return m_iSliceQp; }
1618	Bool getDependentSliceSegmentFlag() const { return m_dependentSliceSegmentFlag; }
1619	void setDependentSliceSegmentFlag(Bool val) { m_dependentSliceSegmentFlag = val; }
1620	#if ADAPTIVE_QP_SELECTION
1621	Int getSliceQpBase () { return m_iSliceQpBase; }
1622	#endif
1623	Int getSliceQpDelta () { return m_iSliceQpDelta; }
1624	Int getSliceQpDeltaCb () { return m_iSliceQpDeltaCb; }
1625	Int getSliceQpDeltaCr () { return m_iSliceQpDeltaCr; }
1626	Bool getDeblockingFilterDisable() { return m_deblockingFilterDisable; }
1627	Bool getDeblockingFilterOverrideFlag() { return m_deblockingFilterOverrideFlag; }
1628	Int getDeblockingFilterBetaOffsetDiv2() { return m_deblockingFilterBetaOffsetDiv2; }
1629	Int getDeblockingFilterTcOffsetDiv2() { return m_deblockingFilterTcOffsetDiv2; }
1630
1631	Int getNumRefIdx ( RefPicList e ) { return m_aiNumRefIdx[e]; }
1632	TComPic* getPic () { return m_pcPic; }
1633	TComPic* getRefPic ( RefPicList e, Int iRefIdx) { return m_apcRefPicList[e][iRefIdx]; }
1634	Int getRefPOC ( RefPicList e, Int iRefIdx) { return m_aiRefPOCList[e][iRefIdx]; }
1635	#if H_3D_GEN
1636	TComPic* getIvPic ( Bool depthFlag, Int viewIndex){ return m_ivPicsCurrPoc[ depthFlag ? 1 : 0 ][ viewIndex ]; }
1637	#endif
1638	#if H_3D_IV_MERGE
1639	TComPic* getTexturePic () { return m_ivPicsCurrPoc[0][ m_viewIndex ]; }
1640	#endif
1641	#if H_3D_IC
1642	Void setApplyIC( Bool b ) { m_bApplyIC = b; }
1643	Bool getApplyIC() { return m_bApplyIC; }
1644	Void xSetApplyIC();
1645	Void setIcSkipParseFlag( Bool b ) { m_icSkipParseFlag = b; }
1646	Bool getIcSkipParseFlag() { return m_icSkipParseFlag; }
1647	#endif
1648	#if H_3D_ARP
1649	Void setBaseViewRefPicList( TComList<TComPic> pListPic, Int iViewIdx ) { m_pBaseViewRefPicList[iViewIdx] = pListPic; }
1650	Void setARPStepNum();
1651	TComPic* getBaseViewRefPic ( UInt uiPOC , Int iViewIdx ) { return xGetRefPic( *m_pBaseViewRefPicList[iViewIdx], uiPOC ); }
1652	UInt getARPStepNum( ) { return m_nARPStepNum; }
1653	#endif
1654	Int getDepth () { return m_iDepth; }
1655	UInt getColFromL0Flag () { return m_colFromL0Flag; }
1656	UInt getColRefIdx () { return m_colRefIdx; }
1657	Void checkColRefIdx (UInt curSliceIdx, TComPic* pic);
1658	Bool getIsUsedAsLongTerm (Int i, Int j) { return m_bIsUsedAsLongTerm[i][j]; }
1659	Bool getCheckLDC () { return m_bCheckLDC; }
1660	Bool getMvdL1ZeroFlag () { return m_bLMvdL1Zero; }
1661	Int getNumRpsCurrTempList();
1662	Int getList1IdxToList0Idx ( Int list1Idx ) { return m_list1IdxToList0Idx[list1Idx]; }
1663	Void setReferenced(Bool b) { m_bRefenced = b; }
1664	Bool isReferenced() { return m_bRefenced; }
1665	Void setPOC ( Int i ) { m_iPOC = i; if(getTLayer()==0) m_prevPOC=i; }
1666	Void setNalUnitType ( NalUnitType e ) { m_eNalUnitType = e; }
1667	NalUnitType getNalUnitType () const { return m_eNalUnitType; }
1668	Bool getRapPicFlag ();
1669	Bool getIdrPicFlag () { return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL \|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP; }
1670	Bool isIRAP () const { return (getNalUnitType() >= 16) && (getNalUnitType() <= 23); }
1671	Void checkCRA(TComReferencePictureSet pReferencePictureSet, Int& pocCRA, Bool& prevRAPisBLA, TComList<TComPic >& rcListPic);
1672	Void decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic);
1673	Void setSliceType ( SliceType e ) { m_eSliceType = e; }
1674	Void setSliceQp ( Int i ) { m_iSliceQp = i; }
1675	#if ADAPTIVE_QP_SELECTION
1676	Void setSliceQpBase ( Int i ) { m_iSliceQpBase = i; }
1677	#endif
1678	Void setSliceQpDelta ( Int i ) { m_iSliceQpDelta = i; }
1679	Void setSliceQpDeltaCb ( Int i ) { m_iSliceQpDeltaCb = i; }
1680	Void setSliceQpDeltaCr ( Int i ) { m_iSliceQpDeltaCr = i; }
1681	Void setDeblockingFilterDisable( Bool b ) { m_deblockingFilterDisable= b; }
1682	Void setDeblockingFilterOverrideFlag( Bool b ) { m_deblockingFilterOverrideFlag = b; }
1683	Void setDeblockingFilterBetaOffsetDiv2( Int i ) { m_deblockingFilterBetaOffsetDiv2 = i; }
1684	Void setDeblockingFilterTcOffsetDiv2( Int i ) { m_deblockingFilterTcOffsetDiv2 = i; }
1685
1686	Void setRefPic ( TComPic* p, RefPicList e, Int iRefIdx ) { m_apcRefPicList[e][iRefIdx] = p; }
1687	Void setRefPOC ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefPOCList[e][iRefIdx] = i; }
1688	Void setNumRefIdx ( RefPicList e, Int i ) { m_aiNumRefIdx[e] = i; }
1689	Void setPic ( TComPic* p ) { m_pcPic = p; }
1690	Void setDepth ( Int iDepth ) { m_iDepth = iDepth; }
1691
1692	#if H_MV
1693	Int getRefLayerId ( RefPicList e, Int iRefIdx) { return m_aiRefLayerIdList[e][iRefIdx]; }
1694	Void setRefLayerId ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefLayerIdList[e][iRefIdx] = i; }
1695	#endif
1696	#if H_MV
1697	Void setRefPicList ( TComList<TComPic>& rcListPic, std::vector<TComPic>& interLayerRefPicSet , Bool checkNumPocTotalCurr = false );
1698	#else
1699	#if FIX1071
1700	Void setRefPicList ( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr = false );
1701	#else
1702	Void setRefPicList ( TComList<TComPic*>& rcListPic );
1703	#endif
1704	#endif
1705	Void setRefPOCList ();
1706	Void setColFromL0Flag ( UInt colFromL0 ) { m_colFromL0Flag = colFromL0; }
1707	Void setColRefIdx ( UInt refIdx) { m_colRefIdx = refIdx; }
1708	Void setCheckLDC ( Bool b ) { m_bCheckLDC = b; }
1709	Void setMvdL1ZeroFlag ( Bool b) { m_bLMvdL1Zero = b; }
1710
1711	Bool isIntra () { return m_eSliceType == I_SLICE; }
1712	Bool isInterB () { return m_eSliceType == B_SLICE; }
1713	Bool isInterP () { return m_eSliceType == P_SLICE; }
1714
1715	#if SAO_CHROMA_LAMBDA
1716	Void setLambda( Double d, Double e ) { m_dLambdaLuma = d; m_dLambdaChroma = e;}
1717	Double getLambdaLuma() { return m_dLambdaLuma; }
1718	Double getLambdaChroma() { return m_dLambdaChroma; }
1719	#else
1720	Void setLambda( Double d ) { m_dLambda = d; }
1721	Double getLambda() { return m_dLambda; }
1722	#endif
1723
1724	Void initEqualRef();
1725	Bool isEqualRef ( RefPicList e, Int iRefIdx1, Int iRefIdx2 )
1726	{
1727	if (iRefIdx1 < 0 \|\| iRefIdx2 < 0) return false;
1728	return m_abEqualRef[e][iRefIdx1][iRefIdx2];
1729	}
1730
1731	Void setEqualRef( RefPicList e, Int iRefIdx1, Int iRefIdx2, Bool b)
1732	{
1733	m_abEqualRef[e][iRefIdx1][iRefIdx2] = m_abEqualRef[e][iRefIdx2][iRefIdx1] = b;
1734	}
1735
1736	static Void sortPicList ( TComList<TComPic*>& rcListPic );
1737	Void setList1IdxToList0Idx();
1738
1739	UInt getTLayer () { return m_uiTLayer; }
1740	Void setTLayer ( UInt uiTLayer ) { m_uiTLayer = uiTLayer; }
1741
1742	Void setTLayerInfo( UInt uiTLayer );
1743	Void decodingMarking( TComList<TComPic*>& rcListPic, Int iGOPSIze, Int& iMaxRefPicNum );
1744	Void applyReferencePictureSet( TComList<TComPic>& rcListPic, TComReferencePictureSet RPSList);
1745	#if H_MV
1746	Void createAndApplyIvReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer );
1747	static Void markIvRefPicsAsShortTerm ( std::vector<TComPic*> refPicSetInterLayer );
1748	static Void markCurrPic ( TComPic* currPic );;
1749	static Void markIvRefPicsAsUnused ( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc );
1750	Void xPrintRefPicList();
1751	#endif
1752	Bool isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic );
1753	Bool isStepwiseTemporalLayerSwitchingPointCandidate( TComList<TComPic*>& rcListPic );
1754	Int checkThatAllRefPicsAreAvailable( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet, Bool printErrors, Int pocRandomAccess = 0);
1755	#if FIX1071
1756	Void createExplicitReferencePictureSetFromReference( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet, Bool isRAP);
1757	#else
1758	Void createExplicitReferencePictureSetFromReference( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet);
1759	#endif
1760
1761	Void setMaxNumMergeCand (UInt val ) { m_maxNumMergeCand = val; }
1762	UInt getMaxNumMergeCand () { return m_maxNumMergeCand; }
1763
1764	Void setSliceMode ( UInt uiMode ) { m_sliceMode = uiMode; }
1765	UInt getSliceMode () { return m_sliceMode; }
1766	Void setSliceArgument ( UInt uiArgument ) { m_sliceArgument = uiArgument; }
1767	UInt getSliceArgument () { return m_sliceArgument; }
1768	Void setSliceCurStartCUAddr ( UInt uiAddr ) { m_sliceCurStartCUAddr = uiAddr; }
1769	UInt getSliceCurStartCUAddr () { return m_sliceCurStartCUAddr; }
1770	Void setSliceCurEndCUAddr ( UInt uiAddr ) { m_sliceCurEndCUAddr = uiAddr; }
1771	UInt getSliceCurEndCUAddr () { return m_sliceCurEndCUAddr; }
1772	Void setSliceIdx ( UInt i) { m_sliceIdx = i; }
1773	UInt getSliceIdx () { return m_sliceIdx; }
1774	Void copySliceInfo (TComSlice *pcSliceSrc);
1775	Void setSliceSegmentMode ( UInt uiMode ) { m_sliceSegmentMode = uiMode; }
1776	UInt getSliceSegmentMode () { return m_sliceSegmentMode; }
1777	Void setSliceSegmentArgument ( UInt uiArgument ) { m_sliceSegmentArgument = uiArgument; }
1778	UInt getSliceSegmentArgument () { return m_sliceSegmentArgument; }
1779	Void setSliceSegmentCurStartCUAddr ( UInt uiAddr ) { m_sliceSegmentCurStartCUAddr = uiAddr; }
1780	UInt getSliceSegmentCurStartCUAddr () { return m_sliceSegmentCurStartCUAddr; }
1781	Void setSliceSegmentCurEndCUAddr ( UInt uiAddr ) { m_sliceSegmentCurEndCUAddr = uiAddr; }
1782	UInt getSliceSegmentCurEndCUAddr () { return m_sliceSegmentCurEndCUAddr; }
1783	Void setNextSlice ( Bool b ) { m_nextSlice = b; }
1784	Bool isNextSlice () { return m_nextSlice; }
1785	Void setNextSliceSegment ( Bool b ) { m_nextSliceSegment = b; }
1786	Bool isNextSliceSegment () { return m_nextSliceSegment; }
1787	Void setSliceBits ( UInt uiVal ) { m_sliceBits = uiVal; }
1788	UInt getSliceBits () { return m_sliceBits; }
1789	Void setSliceSegmentBits ( UInt uiVal ) { m_sliceSegmentBits = uiVal; }
1790	UInt getSliceSegmentBits () { return m_sliceSegmentBits; }
1791	Void setFinalized ( Bool uiVal ) { m_bFinalized = uiVal; }
1792	Bool getFinalized () { return m_bFinalized; }
1793	Void setWpScaling ( wpScalingParam wp[2][MAX_NUM_REF][3] ) { memcpy(m_weightPredTable, wp, sizeof(wpScalingParam)2MAX_NUM_REF*3); }
1794	Void getWpScaling ( RefPicList e, Int iRefIdx, wpScalingParam *&wp);
1795
1796	Void resetWpScaling ();
1797	Void initWpScaling ();
1798	inline Bool applyWP () { return( (m_eSliceType==P_SLICE && m_pcPPS->getUseWP()) \|\| (m_eSliceType==B_SLICE && m_pcPPS->getWPBiPred()) ); }
1799
1800	Void setWpAcDcParam ( wpACDCParam wp[3] ) { memcpy(m_weightACDCParam, wp, sizeof(wpACDCParam)*3); }
1801	Void getWpAcDcParam ( wpACDCParam *&wp );
1802	Void initWpAcDcParam ();
1803
1804	Void setTileLocationCount ( UInt cnt ) { return m_tileByteLocation.resize(cnt); }
1805	UInt getTileLocationCount () { return (UInt) m_tileByteLocation.size(); }
1806	Void setTileLocation ( Int idx, UInt location ) { assert (idx<m_tileByteLocation.size());
1807	m_tileByteLocation[idx] = location; }
1808	Void addTileLocation ( UInt location ) { m_tileByteLocation.push_back(location); }
1809	UInt getTileLocation ( Int idx ) { return m_tileByteLocation[idx]; }
1810
1811	Void setTileOffstForMultES (UInt uiOffset ) { m_uiTileOffstForMultES = uiOffset; }
1812	UInt getTileOffstForMultES () { return m_uiTileOffstForMultES; }
1813	Void allocSubstreamSizes ( UInt uiNumSubstreams );
1814	UInt* getSubstreamSizes () { return m_puiSubstreamSizes; }
1815	Void setScalingList ( TComScalingList* scalingList ) { m_scalingList = scalingList; }
1816	TComScalingList* getScalingList () { return m_scalingList; }
1817	Void setDefaultScalingList ();
1818	Bool checkDefaultScalingList ();
1819	Void setCabacInitFlag ( Bool val ) { m_cabacInitFlag = val; } //!< set CABAC initial flag
1820	Bool getCabacInitFlag () { return m_cabacInitFlag; } //!< get CABAC initial flag
1821	Void setNumEntryPointOffsets(Int val) { m_numEntryPointOffsets = val; }
1822	Int getNumEntryPointOffsets() { return m_numEntryPointOffsets; }
1823	Bool getTemporalLayerNonReferenceFlag() { return m_temporalLayerNonReferenceFlag;}
1824	Void setTemporalLayerNonReferenceFlag(Bool x) { m_temporalLayerNonReferenceFlag = x;}
1825	Void setLFCrossSliceBoundaryFlag ( Bool val ) { m_LFCrossSliceBoundaryFlag = val; }
1826	Bool getLFCrossSliceBoundaryFlag () { return m_LFCrossSliceBoundaryFlag;}
1827
1828	Void setEnableTMVPFlag ( Bool b ) { m_enableTMVPFlag = b; }
1829	Bool getEnableTMVPFlag () { return m_enableTMVPFlag;}
1830
1831	#if H_MV
1832	Void setLayerId ( Int layerId ) { m_layerId = layerId; }
1833	Int getLayerId () { return m_layerId; }
1834	Int getLayerIdInVps () { return getVPS()->getLayerIdInVps( m_layerId ); };
1835	Void setViewId ( Int viewId ) { m_viewId = viewId; }
1836	Int getViewId () { return m_viewId; }
1837	#if H_3D
1838	#if H_3D_TMVP
1839	Void generateAlterRefforTMVP ();
1840	Void setAlterRefIdx ( RefPicList e, Int i ) { m_aiAlterRefIdx[e] = i; }
1841	Int getAlterRefIdx ( RefPicList e ) { return m_aiAlterRefIdx[e]; }
1842	#endif
1843	Void setViewIndex ( Int viewIndex ) { m_viewIndex = viewIndex; }
1844	Int getViewIndex () { return m_viewIndex; }
1845	Void setIsDepth ( Bool isDepth ) { m_isDepth = isDepth; }
1846	Bool getIsDepth () { return m_isDepth; }
1847	Void setCamparaSlice ( Int aaiScale = 0, Int aaiOffset = 0 );
1848	Int* getCodedScale () { return m_aaiCodedScale [0]; }
1849	Int* getCodedOffset () { return m_aaiCodedOffset[0]; }
1850	Int* getInvCodedScale () { return m_aaiCodedScale [1]; }
1851	Int* getInvCodedOffset () { return m_aaiCodedOffset[1]; }
1852	#endif
1853	#endif
1854	#if H_3D_GEN
1855	Void setIvPicLists( TComPicLists* m_ivPicLists );
1856	Void setDepthToDisparityLUTs();
1857
1858	Int* getDepthToDisparityB( Int refViewIdx ) { return m_depthToDisparityB[ refViewIdx ]; };
1859	Int* getDepthToDisparityF( Int refViewIdx ) { return m_depthToDisparityF[ refViewIdx ]; };
1860	Bool getVpsDepthModesFlag () { return getVPS()->getVpsDepthModesFlag( getVPS()->getLayerIdInVps( m_layerId ) ); }
1861
1862	#endif
1863	#if H_MV
1864	// Additional slice header syntax elements
1865	Void setDiscardableFlag( Bool flag ) { m_discardableFlag = flag; }
1866	Bool getDiscardableFlag( ) { return m_discardableFlag; }
1867
1868	Void setInterLayerPredEnabledFlag( Bool flag ) { m_interLayerPredEnabledFlag = flag; }
1869	Bool getInterLayerPredEnabledFlag( ) { return m_interLayerPredEnabledFlag; }
1870
1871	Void setNumInterLayerRefPicsMinus1( Int val ) { m_numInterLayerRefPicsMinus1 = val; }
1872	Int getNumInterLayerRefPicsMinus1( ) { return m_numInterLayerRefPicsMinus1; }
1873
1874	Void setInterLayerPredLayerIdc( Int i, Int val ) { m_interLayerPredLayerIdc[i] = val; }
1875	Int getInterLayerPredLayerIdc( Int i ) { return m_interLayerPredLayerIdc[i]; }
1876
1877	Void setInterLayerSamplePredOnlyFlag( Bool flag ) { m_interLayerSamplePredOnlyFlag = flag; }
1878	Bool getInterLayerSamplePredOnlyFlag( ) { return m_interLayerSamplePredOnlyFlag; }
1879
1880	Void setAltCollocatedIndicationFlag( Bool flag ) { m_altCollocatedIndicationFlag = flag; }
1881	Bool getAltCollocatedIndicationFlag( ) { return m_altCollocatedIndicationFlag; }
1882
1883	Void setCollocatedRefLayerIdx( Int val ) { m_collocatedRefLayerIdx = val; }
1884	Int getCollocatedRefLayerIdx( ) { return m_collocatedRefLayerIdx; }
1885
1886	// Additional variables derived in slice header semantics
1887	Int getNumInterLayerRefPicsMinus1Len( ) { return xCeilLog2( getVPS()->getNumDirectRefLayers( getLayerIdInVps() )); }
1888	Int getInterLayerPredLayerIdcLen ( ) { return xCeilLog2( getVPS()->getNumDirectRefLayers( getLayerIdInVps() )); }
1889
1890	Int getNumActiveRefLayerPics( );
1891	Int getRefPicLayerId ( Int i );
1892
1893	Void setActiveMotionPredRefLayers ( );
1894
1895	Int getNumActiveMotionPredRefLayers( ) { return m_numActiveMotionPredRefLayers; }
1896	Int getActiveMotionPredRefLayerId ( Int i ) { return m_activeMotionPredRefLayerId[i]; }
1897
1898	Bool getInterRefEnabledInRPLFlag( );
1899
1900	Void setRefPicSetInterLayer ( std::vector<TComPic> m_refPicSetInterLayer );
1901	TComPic* getPicFromRefPicSetInterLayer( Int layerId );
1902
1903	#endif
1904	protected:
1905	TComPic* xGetRefPic (TComList<TComPic*>& rcListPic,
1906	Int poc);
1907	TComPic* xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb);
1908	#if H_MV
1909	Int xCeilLog2( Int val );
1910	TComPic* xGetInterLayerRefPic( std::vector<TComPic*>& rcListIlPic, Int layerId );
1911	#endif
1912	};// END CLASS DEFINITION TComSlice
1913
1914
1915	template <class T> class ParameterSetMap
1916	{
1917	public:
1918	ParameterSetMap(Int maxId)
1919	:m_maxId (maxId)
1920	{}
1921
1922	~ParameterSetMap()
1923	{
1924	for (typename std::map<Int,T *>::iterator i = m_paramsetMap.begin(); i!= m_paramsetMap.end(); i++)
1925	{
1926	delete (*i).second;
1927	}
1928	}
1929
1930	Void storePS(Int psId, T *ps)
1931	{
1932	assert ( psId < m_maxId );
1933	if ( m_paramsetMap.find(psId) != m_paramsetMap.end() )
1934	{
1935	delete m_paramsetMap[psId];
1936	}
1937	m_paramsetMap[psId] = ps;
1938	}
1939
1940	Void mergePSList(ParameterSetMap<T> &rPsList)
1941	{
1942	for (typename std::map<Int,T *>::iterator i = rPsList.m_paramsetMap.begin(); i!= rPsList.m_paramsetMap.end(); i++)
1943	{
1944	storePS(i->first, i->second);
1945	}
1946	rPsList.m_paramsetMap.clear();
1947	}
1948
1949
1950	T* getPS(Int psId)
1951	{
1952	return ( m_paramsetMap.find(psId) == m_paramsetMap.end() ) ? NULL : m_paramsetMap[psId];
1953	}
1954
1955	T* getFirstPS()
1956	{
1957	return (m_paramsetMap.begin() == m_paramsetMap.end() ) ? NULL : m_paramsetMap.begin()->second;
1958	}
1959
1960	private:
1961	std::map<Int,T *> m_paramsetMap;
1962	Int m_maxId;
1963	};
1964
1965	class ParameterSetManager
1966	{
1967	public:
1968	ParameterSetManager();
1969	virtual ~ParameterSetManager();
1970
1971	//! store sequence parameter set and take ownership of it
1972	Void storeVPS(TComVPS *vps) { m_vpsMap.storePS( vps->getVPSId(), vps); };
1973	//! get pointer to existing video parameter set
1974	TComVPS* getVPS(Int vpsId) { return m_vpsMap.getPS(vpsId); };
1975	TComVPS* getFirstVPS() { return m_vpsMap.getFirstPS(); };
1976
1977	//! store sequence parameter set and take ownership of it
1978	Void storeSPS(TComSPS *sps) { m_spsMap.storePS( sps->getSPSId(), sps); };
1979	//! get pointer to existing sequence parameter set
1980	TComSPS* getSPS(Int spsId) { return m_spsMap.getPS(spsId); };
1981	TComSPS* getFirstSPS() { return m_spsMap.getFirstPS(); };
1982
1983	//! store picture parameter set and take ownership of it
1984	Void storePPS(TComPPS *pps) { m_ppsMap.storePS( pps->getPPSId(), pps); };
1985	//! get pointer to existing picture parameter set
1986	TComPPS* getPPS(Int ppsId) { return m_ppsMap.getPS(ppsId); };
1987	TComPPS* getFirstPPS() { return m_ppsMap.getFirstPS(); };
1988
1989	//! activate a SPS from a active parameter sets SEI message
1990	//! \returns true, if activation is successful
1991	Bool activateSPSWithSEI(Int SPSId);
1992
1993	//! activate a PPS and depending on isIDR parameter also SPS and VPS
1994	//! \returns true, if activation is successful
1995	Bool activatePPS(Int ppsId, Bool isIRAP);
1996
1997	TComVPS* getActiveVPS(){ return m_vpsMap.getPS(m_activeVPSId); };
1998	TComSPS* getActiveSPS(){ return m_spsMap.getPS(m_activeSPSId); };
1999	TComPPS* getActivePPS(){ return m_ppsMap.getPS(m_activePPSId); };
2000
2001	protected:
2002
2003	ParameterSetMap<TComVPS> m_vpsMap;
2004	ParameterSetMap<TComSPS> m_spsMap;
2005	ParameterSetMap<TComPPS> m_ppsMap;
2006
2007	Int m_activeVPSId;
2008	Int m_activeSPSId;
2009	Int m_activePPSId;
2010	};
2011
2012	//! \}
2013
2014	#endif // __TCOMSLICE__

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

Download in other formats: