Context navigation

← Previous revision
Next revision →
Blame
Revision log

TComSlice.h

Visit:

Last change on this file was 1413, checked in by tech, 6 years ago
Merged HTM-16.2-dev@1412
Property svn:eol-style set to `native`
File size: 241.0 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-2017, 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	#include "TComChromaFormat.h"
48
49	//! \ingroup TLibCommon
50	//! \{
51
52	class TComPic;
53	class TComTrQuant;
54	#if NH_MV
55	class TComDecodedRps;
56	class TComPicLists;
57	class TComVPS;
58	class TComSPS;
59	#endif
60	// ====================================================================================================================
61	// Constants
62	// ====================================================================================================================
63
64	static const UInt REF_PIC_LIST_NUM_IDX=32;
65
66	// ====================================================================================================================
67	// Class definition
68	// ====================================================================================================================
69
70	/// Reference Picture Set class
71
72	#if NH_MV
73	class TComStRefPicSet
74	{
75	// This class is currently only used by the decoder.
76	// TBD: Modify encoder to use also it.
77
78	private:
79
80	// Syntax elements:
81
82	Bool m_interRefPicSetPredictionFlag;
83	Int m_deltaIdxMinus1;
84	Bool m_deltaRpsSign;
85	Int m_absDeltaRpsMinus1;
86	Bool m_usedByCurrPicFlag [ MAX_NUM_PICS_RPS ];
87	Bool m_useDeltaFlag [ MAX_NUM_PICS_RPS ];
88	Int m_numNegativePics;
89	Int m_numPositivePics;
90	Int m_deltaPocS0Minus1 [ MAX_NUM_PICS_RPS ];
91	Bool m_usedByCurrPicS0Flag[ MAX_NUM_PICS_RPS ];
92	Int m_deltaPocS1Minus1 [ MAX_NUM_PICS_RPS ];
93	Bool m_usedByCurrPicS1Flag[ MAX_NUM_PICS_RPS ];
94
95	// Semantic variables:
96	Int m_deltaPocS0Var [ MAX_NUM_PICS_RPS ];
97	Int m_deltaPocS1Var [ MAX_NUM_PICS_RPS ];
98	Int m_usedByCurrPicS0Var [ MAX_NUM_PICS_RPS ];
99	Int m_usedByCurrPicS1Var [ MAX_NUM_PICS_RPS ];
100	Int m_numNegativePicsVar ;
101	Int m_numPositivePicsVar ;
102
103	public:
104
105	TComStRefPicSet( )
106	{
107	// Set default inheritance values:
108	setInterRefPicSetPredictionFlag( false );
109	setDeltaIdxMinus1( 0 );
110	for (Int j = 0; j < MAX_NUM_PICS_RPS; j++)
111	{
112	setUseDeltaFlag( j, true );
113	}
114	}
115
116	// Syntax elements:
117	Void setInterRefPicSetPredictionFlag( Bool flag ) { m_interRefPicSetPredictionFlag = flag; }
118	Bool getInterRefPicSetPredictionFlag( ) const { return m_interRefPicSetPredictionFlag; }
119
120	Void setDeltaIdxMinus1( Int val ) { m_deltaIdxMinus1 = val; }
121	Int getDeltaIdxMinus1( ) const { return m_deltaIdxMinus1; }
122
123	Void setDeltaRpsSign( Bool flag ) { m_deltaRpsSign = flag; }
124	Bool getDeltaRpsSign( ) const { return m_deltaRpsSign; }
125
126	Void setAbsDeltaRpsMinus1( Int val ) { m_absDeltaRpsMinus1 = val; }
127	Int getAbsDeltaRpsMinus1( ) const { return m_absDeltaRpsMinus1; }
128
129	Void setUsedByCurrPicFlag( Int j, Bool flag ) { m_usedByCurrPicFlag[j] = flag; }
130	Bool getUsedByCurrPicFlag( Int j ) const { return m_usedByCurrPicFlag[j]; }
131
132	Void setUseDeltaFlag( Int j, Bool flag ) { m_useDeltaFlag[j] = flag; }
133	Bool getUseDeltaFlag( Int j ) const { return m_useDeltaFlag[j]; }
134
135	Void setNumNegativePics( Int val ) { m_numNegativePics = val; }
136	Int getNumNegativePics( ) const { return m_numNegativePics; }
137
138	Void setNumPositivePics( Int val ) { m_numPositivePics = val; }
139	Int getNumPositivePics( ) const { return m_numPositivePics; }
140
141	Void setDeltaPocS0Minus1( Int i, Int val ) { m_deltaPocS0Minus1[i] = val; }
142	Int getDeltaPocS0Minus1( Int i ) const { return m_deltaPocS0Minus1[i]; }
143
144	Void setUsedByCurrPicS0Flag( Int i, Bool flag ) { m_usedByCurrPicS0Flag[i] = flag; }
145	Bool getUsedByCurrPicS0Flag( Int i ) const { return m_usedByCurrPicS0Flag[i]; }
146
147	Void setDeltaPocS1Minus1( Int i, Int val ) { m_deltaPocS1Minus1[i] = val; }
148	Int getDeltaPocS1Minus1( Int i ) const { return m_deltaPocS1Minus1[i]; }
149
150	Void setUsedByCurrPicS1Flag( Int i, Bool flag ) { m_usedByCurrPicS1Flag[i] = flag; }
151	Bool getUsedByCurrPicS1Flag( Int i ) const { return m_usedByCurrPicS1Flag[i]; }
152
153	// Semantics variables:
154	Int getRefRpsIdx(Int stRpsIdx ) const { return ( stRpsIdx - (getDeltaIdxMinus1() + 1) ); }
155	Int getDeltaRps() const { return ( ( 1 - 2 * getDeltaRpsSign() ) * ( getAbsDeltaRpsMinus1() + 1 ) ); }
156	Int getNumDeltaPocs() const { return ( getNumNegativePicsVar() + getNumPositivePicsVar()); }
157
158	Void setNumNegativePicsVar( Int val ) { m_numNegativePicsVar = val; }
159	Int getNumNegativePicsVar( ) const { return m_numNegativePicsVar; }
160
161	Void setNumPositivePicsVar( Int val ) { m_numPositivePicsVar = val; }
162	Int getNumPositivePicsVar( ) const { return m_numPositivePicsVar; }
163
164	Void setDeltaPocS0Var( Int i, Int val ) { m_deltaPocS0Var[i] = val; }
165	Int getDeltaPocS0Var( Int i ) const { return m_deltaPocS0Var[i]; }
166
167	Void setUsedByCurrPicS0Var( Int i, Bool flag ) { m_usedByCurrPicS0Var[i] = flag; }
168	Bool getUsedByCurrPicS0Var( Int i ) const { return m_usedByCurrPicS0Var[i]; }
169
170	Void setDeltaPocS1Var( Int i, Int val ) { m_deltaPocS1Var[i] = val; }
171	Int getDeltaPocS1Var( Int i ) const { return m_deltaPocS1Var[i]; }
172
173	Void setUsedByCurrPicS1Var( Int i, Bool flag ) { m_usedByCurrPicS1Var[i] = flag; }
174	Bool getUsedByCurrPicS1Var( Int i ) const { return m_usedByCurrPicS1Var[i]; }
175
176	Void inferRps( Int stRpsIdx, TComSPS* sps, Bool encoder );
177	};
178
179	#endif
180
181	class TComReferencePictureSet
182	{
183	private:
184	Int m_numberOfPictures;
185	Int m_numberOfNegativePictures;
186	Int m_numberOfPositivePictures;
187	Int m_numberOfLongtermPictures;
188	Int m_deltaPOC[MAX_NUM_REF_PICS];
189	Int m_POC[MAX_NUM_REF_PICS];
190	Bool m_used[MAX_NUM_REF_PICS];
191	Bool m_interRPSPrediction;
192	Int m_deltaRIdxMinus1;
193	Int m_deltaRPS;
194	Int m_numRefIdc;
195	Int m_refIdc[MAX_NUM_REF_PICS+1];
196	Bool m_bCheckLTMSB[MAX_NUM_REF_PICS];
197	Int m_pocLSBLT[MAX_NUM_REF_PICS];
198	Int m_deltaPOCMSBCycleLT[MAX_NUM_REF_PICS];
199	Bool m_deltaPocMSBPresentFlag[MAX_NUM_REF_PICS];
200
201	public:
202	TComReferencePictureSet();
203	virtual ~TComReferencePictureSet();
204	Int getPocLSBLT(Int i) const { return m_pocLSBLT[i]; }
205	Void setPocLSBLT(Int i, Int x) { m_pocLSBLT[i] = x; }
206	Int getDeltaPocMSBCycleLT(Int i) const { return m_deltaPOCMSBCycleLT[i]; }
207	Void setDeltaPocMSBCycleLT(Int i, Int x) { m_deltaPOCMSBCycleLT[i] = x; }
208	Bool getDeltaPocMSBPresentFlag(Int i) const { return m_deltaPocMSBPresentFlag[i]; }
209	Void setDeltaPocMSBPresentFlag(Int i, Bool x) { m_deltaPocMSBPresentFlag[i] = x; }
210	Void setUsed(Int bufferNum, Bool used);
211	Void setDeltaPOC(Int bufferNum, Int deltaPOC);
212	Void setPOC(Int bufferNum, Int deltaPOC);
213	Void setNumberOfPictures(Int numberOfPictures);
214	Void setCheckLTMSBPresent(Int bufferNum, Bool b );
215	Bool getCheckLTMSBPresent(Int bufferNum) const;
216
217	Int getUsed(Int bufferNum) const;
218	Int getDeltaPOC(Int bufferNum) const;
219	Int getPOC(Int bufferNum) const;
220	Int getNumberOfPictures() const;
221
222	Void setNumberOfNegativePictures(Int number) { m_numberOfNegativePictures = number; }
223	Int getNumberOfNegativePictures() const { return m_numberOfNegativePictures; }
224	Void setNumberOfPositivePictures(Int number) { m_numberOfPositivePictures = number; }
225	Int getNumberOfPositivePictures() const { return m_numberOfPositivePictures; }
226	Void setNumberOfLongtermPictures(Int number) { m_numberOfLongtermPictures = number; }
227	Int getNumberOfLongtermPictures() const { return m_numberOfLongtermPictures; }
228
229	Void setInterRPSPrediction(Bool flag) { m_interRPSPrediction = flag; }
230	Bool getInterRPSPrediction() const { return m_interRPSPrediction; }
231	Void setDeltaRIdxMinus1(Int x) { m_deltaRIdxMinus1 = x; }
232	Int getDeltaRIdxMinus1() const { return m_deltaRIdxMinus1; }
233	Void setDeltaRPS(Int x) { m_deltaRPS = x; }
234	Int getDeltaRPS() const { return m_deltaRPS; }
235	Void setNumRefIdc(Int x) { m_numRefIdc = x; }
236	Int getNumRefIdc() const { return m_numRefIdc; }
237
238	Void setRefIdc(Int bufferNum, Int refIdc);
239	Int getRefIdc(Int bufferNum) const ;
240
241	Void sortDeltaPOC();
242	Void printDeltaPOC() const;
243
244	#if NH_MV
245	Void checkMaxNumPics( Bool vpsExtensionFlag, Int maxNumPics, Int nuhLayerId, Int spsMaxDecPicBufferingMinus1 ) const;
246	#endif
247
248	};
249
250	/// Reference Picture Set set class
251	class TComRPSList
252	{
253	private:
254	std::vector<TComReferencePictureSet> m_referencePictureSets;
255
256	public:
257	TComRPSList() { }
258	virtual ~TComRPSList() { }
259
260	Void create (Int numberOfEntries) { m_referencePictureSets.resize(numberOfEntries); }
261	Void destroy () { }
262
263
264	TComReferencePictureSet* getReferencePictureSet(Int referencePictureSetNum) { return &m_referencePictureSets[referencePictureSetNum]; }
265	const TComReferencePictureSet* getReferencePictureSet(Int referencePictureSetNum) const { return &m_referencePictureSets[referencePictureSetNum]; }
266
267	Int getNumberOfReferencePictureSets() const { return Int(m_referencePictureSets.size()); }
268	};
269
270	/// SCALING_LIST class
271	class TComScalingList
272	{
273	public:
274	TComScalingList();
275	virtual ~TComScalingList() { }
276	Int* getScalingListAddress(UInt sizeId, UInt listId) { return &(m_scalingListCoef[sizeId][listId][0]); } //!< get matrix coefficient
277	const Int* getScalingListAddress(UInt sizeId, UInt listId) const { return &(m_scalingListCoef[sizeId][listId][0]); } //!< get matrix coefficient
278	Void checkPredMode(UInt sizeId, UInt listId);
279
280	Void setRefMatrixId(UInt sizeId, UInt listId, UInt u) { m_refMatrixId[sizeId][listId] = u; } //!< set reference matrix ID
281	UInt getRefMatrixId(UInt sizeId, UInt listId) const { return m_refMatrixId[sizeId][listId]; } //!< get reference matrix ID
282
283	const Int* getScalingListDefaultAddress(UInt sizeId, UInt listId); //!< get default matrix coefficient
284	Void processDefaultMatrix(UInt sizeId, UInt listId);
285
286	Void setScalingListDC(UInt sizeId, UInt listId, UInt u) { m_scalingListDC[sizeId][listId] = u; } //!< set DC value
287	Int getScalingListDC(UInt sizeId, UInt listId) const { return m_scalingListDC[sizeId][listId]; } //!< get DC value
288
289	Void setScalingListPredModeFlag(UInt sizeId, UInt listId, Bool bIsDPCM) { m_scalingListPredModeFlagIsDPCM[sizeId][listId] = bIsDPCM; }
290	Bool getScalingListPredModeFlag(UInt sizeId, UInt listId) const { return m_scalingListPredModeFlagIsDPCM[sizeId][listId]; }
291
292	Void checkDcOfMatrix();
293	Void processRefMatrix(UInt sizeId, UInt listId , UInt refListId );
294	Bool xParseScalingList(const std::string &fileName);
295	#if NH_MV
296	Void inferFrom ( const TComScalingList& srcScLi );
297	#endif
298	Void setDefaultScalingList();
299	Bool checkDefaultScalingList();
300
301	private:
302	Void outputScalingLists(std::ostream &os) const;
303	Bool m_scalingListPredModeFlagIsDPCM [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< reference list index
304	Int m_scalingListDC [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< the DC value of the matrix coefficient for 16x16
305	UInt m_refMatrixId [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< RefMatrixID
306	std::vector<Int> m_scalingListCoef [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< quantization matrix
307	};
308
309	class ProfileTierLevel
310	{
311	Int m_profileSpace;
312	Level::Tier m_tierFlag;
313	Profile::Name m_profileIdc;
314	Bool m_profileCompatibilityFlag[32];
315	Level::Name m_levelIdc;
316
317	Bool m_progressiveSourceFlag;
318	Bool m_interlacedSourceFlag;
319	Bool m_nonPackedConstraintFlag;
320	Bool m_frameOnlyConstraintFlag;
321	UInt m_bitDepthConstraintValue;
322	ChromaFormat m_chromaFormatConstraintValue;
323	Bool m_intraConstraintFlag;
324	Bool m_onePictureOnlyConstraintFlag;
325	Bool m_lowerBitRateConstraintFlag;
326	#if NH_MV
327	Bool m_max12bitConstraintFlag;
328	Bool m_max10bitConstraintFlag;
329	Bool m_max8bitConstraintFlag;
330	Bool m_max422chromaConstraintFlag;
331	Bool m_max420chromaConstraintFlag;
332	Bool m_maxMonochromeConstraintFlag;
333	Bool m_inbldFlag;
334	#endif
335	public:
336	ProfileTierLevel();
337
338	Int getProfileSpace() const { return m_profileSpace; }
339	Void setProfileSpace(Int x) { m_profileSpace = x; }
340
341	Level::Tier getTierFlag() const { return m_tierFlag; }
342	Void setTierFlag(Level::Tier x) { m_tierFlag = x; }
343
344	Profile::Name getProfileIdc() const { return m_profileIdc; }
345	Void setProfileIdc(Profile::Name x) { m_profileIdc = x; }
346
347	Bool getProfileCompatibilityFlag(Int i) const { return m_profileCompatibilityFlag[i]; }
348	Void setProfileCompatibilityFlag(Int i, Bool x) { m_profileCompatibilityFlag[i] = x; }
349
350	Level::Name getLevelIdc() const { return m_levelIdc; }
351	Void setLevelIdc(Level::Name x) { m_levelIdc = x; }
352
353	Bool getProgressiveSourceFlag() const { return m_progressiveSourceFlag; }
354	Void setProgressiveSourceFlag(Bool b) { m_progressiveSourceFlag = b; }
355
356	Bool getInterlacedSourceFlag() const { return m_interlacedSourceFlag; }
357	Void setInterlacedSourceFlag(Bool b) { m_interlacedSourceFlag = b; }
358
359	Bool getNonPackedConstraintFlag() const { return m_nonPackedConstraintFlag; }
360	Void setNonPackedConstraintFlag(Bool b) { m_nonPackedConstraintFlag = b; }
361
362	Bool getFrameOnlyConstraintFlag() const { return m_frameOnlyConstraintFlag; }
363	Void setFrameOnlyConstraintFlag(Bool b) { m_frameOnlyConstraintFlag = b; }
364
365	UInt getBitDepthConstraint() const { return m_bitDepthConstraintValue; }
366	Void setBitDepthConstraint(UInt bitDepth) { m_bitDepthConstraintValue=bitDepth; }
367
368	ChromaFormat getChromaFormatConstraint() const { return m_chromaFormatConstraintValue; }
369	Void setChromaFormatConstraint(ChromaFormat fmt) { m_chromaFormatConstraintValue=fmt; }
370
371	Bool getIntraConstraintFlag() const { return m_intraConstraintFlag; }
372	Void setIntraConstraintFlag(Bool b) { m_intraConstraintFlag = b; }
373
374	Bool getOnePictureOnlyConstraintFlag() const { return m_onePictureOnlyConstraintFlag;}
375	Void setOnePictureOnlyConstraintFlag(Bool b) { m_onePictureOnlyConstraintFlag = b; }
376
377	Bool getLowerBitRateConstraintFlag() const { return m_lowerBitRateConstraintFlag; }
378	Void setLowerBitRateConstraintFlag(Bool b) { m_lowerBitRateConstraintFlag = b; }
379
380	#if NH_MV
381	Void setMax12bitConstraintFlag( Bool flag ) { m_max12bitConstraintFlag = flag; }
382	Bool getMax12bitConstraintFlag( ) const { return m_max12bitConstraintFlag; }
383
384	Void setMax10bitConstraintFlag( Bool flag ) { m_max10bitConstraintFlag = flag; }
385	Bool getMax10bitConstraintFlag( ) const { return m_max10bitConstraintFlag; }
386
387	Void setMax8bitConstraintFlag( Bool flag ) { m_max8bitConstraintFlag = flag; }
388	Bool getMax8bitConstraintFlag( ) const { return m_max8bitConstraintFlag; }
389
390	Void setMax422chromaConstraintFlag( Bool flag ) { m_max422chromaConstraintFlag = flag; }
391	Bool getMax422chromaConstraintFlag( ) const { return m_max422chromaConstraintFlag; }
392
393	Void setMax420chromaConstraintFlag( Bool flag ) { m_max420chromaConstraintFlag = flag; }
394	Bool getMax420chromaConstraintFlag( ) const { return m_max420chromaConstraintFlag; }
395
396	Void setMaxMonochromeConstraintFlag( Bool flag ) { m_maxMonochromeConstraintFlag = flag; }
397	Bool getMaxMonochromeConstraintFlag( ) const { return m_maxMonochromeConstraintFlag; }
398
399	Void setInbldFlag( Bool flag ) { m_inbldFlag = flag; }
400	Bool getInbldFlag( ) const { return m_inbldFlag; }
401
402	Bool getV2ConstraintsPresentFlag() const;
403	Bool getInbldPresentFlag() const;
404
405	Void copyV2ConstraintFlags( ProfileTierLevel* ptlRef );
406	Void copyProfile( ProfileTierLevel* ptlRef );
407	#endif
408
409	};
410
411
412	class TComPTL
413	{
414	ProfileTierLevel m_generalPTL;
415	#if !NH_MV
416	ProfileTierLevel m_subLayerPTL [MAX_TLAYER-1]; // max. value of max_sub_layers_minus1 is MAX_TLAYER-1 (= 6)
417	Bool m_subLayerProfilePresentFlag [MAX_TLAYER-1];
418	Bool m_subLayerLevelPresentFlag [MAX_TLAYER-1];
419	#else
420	ProfileTierLevel m_subLayerPTL [MAX_TLAYER]; // However, highest index is 6, so we need one more.
421	Bool m_subLayerProfilePresentFlag [MAX_TLAYER];
422	Bool m_subLayerLevelPresentFlag [MAX_TLAYER];
423	#endif
424
425	public:
426	TComPTL();
427	Bool getSubLayerProfilePresentFlag(Int i) const { return m_subLayerProfilePresentFlag[i]; }
428	Void setSubLayerProfilePresentFlag(Int i, Bool x) { m_subLayerProfilePresentFlag[i] = x; }
429
430	Bool getSubLayerLevelPresentFlag(Int i) const { return m_subLayerLevelPresentFlag[i]; }
431	Void setSubLayerLevelPresentFlag(Int i, Bool x) { m_subLayerLevelPresentFlag[i] = x; }
432
433	ProfileTierLevel* getGeneralPTL() { return &m_generalPTL; }
434	const ProfileTierLevel* getGeneralPTL() const { return &m_generalPTL; }
435	ProfileTierLevel* getSubLayerPTL(Int i) { return &m_subLayerPTL[i]; }
436	const ProfileTierLevel* getSubLayerPTL(Int i) const { return &m_subLayerPTL[i]; }
437
438	#if NH_MV
439	Void inferGeneralValues ( Bool profilePresentFlag , Int k, TComPTL* refPTL );;
440	Void inferSubLayerValues( Int maxNumSubLayersMinus1, Int k, TComPTL* refPTL );;
441	#endif
442
443	};
444
445	/// VPS class
446
447	struct HrdSubLayerInfo
448	{
449	Bool fixedPicRateFlag;
450	Bool fixedPicRateWithinCvsFlag;
451	UInt picDurationInTcMinus1;
452	Bool lowDelayHrdFlag;
453	UInt cpbCntMinus1;
454	UInt bitRateValueMinus1[MAX_CPB_CNT][2];
455	UInt cpbSizeValue [MAX_CPB_CNT][2];
456	UInt ducpbSizeValue [MAX_CPB_CNT][2];
457	Bool cbrFlag [MAX_CPB_CNT][2];
458	UInt duBitRateValue [MAX_CPB_CNT][2];
459	};
460
461	class TComHRD
462	{
463	private:
464	Bool m_nalHrdParametersPresentFlag;
465	Bool m_vclHrdParametersPresentFlag;
466	Bool m_subPicCpbParamsPresentFlag;
467	UInt m_tickDivisorMinus2;
468	UInt m_duCpbRemovalDelayLengthMinus1;
469	Bool m_subPicCpbParamsInPicTimingSEIFlag;
470	UInt m_dpbOutputDelayDuLengthMinus1;
471	UInt m_bitRateScale;
472	UInt m_cpbSizeScale;
473	UInt m_ducpbSizeScale;
474	UInt m_initialCpbRemovalDelayLengthMinus1;
475	UInt m_cpbRemovalDelayLengthMinus1;
476	UInt m_dpbOutputDelayLengthMinus1;
477	HrdSubLayerInfo m_HRD[MAX_TLAYER];
478
479	public:
480	TComHRD()
481	:m_nalHrdParametersPresentFlag (0)
482	,m_vclHrdParametersPresentFlag (0)
483	,m_subPicCpbParamsPresentFlag (false)
484	,m_tickDivisorMinus2 (0)
485	,m_duCpbRemovalDelayLengthMinus1 (0)
486	,m_subPicCpbParamsInPicTimingSEIFlag (false)
487	,m_dpbOutputDelayDuLengthMinus1 (0)
488	,m_bitRateScale (0)
489	,m_cpbSizeScale (0)
490	,m_initialCpbRemovalDelayLengthMinus1(23)
491	,m_cpbRemovalDelayLengthMinus1 (23)
492	,m_dpbOutputDelayLengthMinus1 (23)
493	{}
494
495	virtual ~TComHRD() {}
496
497	Void setNalHrdParametersPresentFlag( Bool flag ) { m_nalHrdParametersPresentFlag = flag; }
498	Bool getNalHrdParametersPresentFlag( ) const { return m_nalHrdParametersPresentFlag; }
499
500	Void setVclHrdParametersPresentFlag( Bool flag ) { m_vclHrdParametersPresentFlag = flag; }
501	Bool getVclHrdParametersPresentFlag( ) const { return m_vclHrdParametersPresentFlag; }
502
503	Void setSubPicCpbParamsPresentFlag( Bool flag ) { m_subPicCpbParamsPresentFlag = flag; }
504	Bool getSubPicCpbParamsPresentFlag( ) const { return m_subPicCpbParamsPresentFlag; }
505
506	Void setTickDivisorMinus2( UInt value ) { m_tickDivisorMinus2 = value; }
507	UInt getTickDivisorMinus2( ) const { return m_tickDivisorMinus2; }
508
509	Void setDuCpbRemovalDelayLengthMinus1( UInt value ) { m_duCpbRemovalDelayLengthMinus1 = value; }
510	UInt getDuCpbRemovalDelayLengthMinus1( ) const { return m_duCpbRemovalDelayLengthMinus1; }
511
512	Void setSubPicCpbParamsInPicTimingSEIFlag( Bool flag) { m_subPicCpbParamsInPicTimingSEIFlag = flag; }
513	Bool getSubPicCpbParamsInPicTimingSEIFlag( ) const { return m_subPicCpbParamsInPicTimingSEIFlag; }
514
515	Void setDpbOutputDelayDuLengthMinus1(UInt value ) { m_dpbOutputDelayDuLengthMinus1 = value; }
516	UInt getDpbOutputDelayDuLengthMinus1( ) const { return m_dpbOutputDelayDuLengthMinus1; }
517
518	Void setBitRateScale( UInt value ) { m_bitRateScale = value; }
519	UInt getBitRateScale( ) const { return m_bitRateScale; }
520
521	Void setCpbSizeScale( UInt value ) { m_cpbSizeScale = value; }
522	UInt getCpbSizeScale( ) const { return m_cpbSizeScale; }
523	Void setDuCpbSizeScale( UInt value ) { m_ducpbSizeScale = value; }
524	UInt getDuCpbSizeScale( ) const { return m_ducpbSizeScale; }
525
526	Void setInitialCpbRemovalDelayLengthMinus1( UInt value ) { m_initialCpbRemovalDelayLengthMinus1 = value; }
527	UInt getInitialCpbRemovalDelayLengthMinus1( ) const { return m_initialCpbRemovalDelayLengthMinus1; }
528
529	Void setCpbRemovalDelayLengthMinus1( UInt value ) { m_cpbRemovalDelayLengthMinus1 = value; }
530	UInt getCpbRemovalDelayLengthMinus1( ) const { return m_cpbRemovalDelayLengthMinus1; }
531
532	Void setDpbOutputDelayLengthMinus1( UInt value ) { m_dpbOutputDelayLengthMinus1 = value; }
533	UInt getDpbOutputDelayLengthMinus1( ) const { return m_dpbOutputDelayLengthMinus1; }
534
535	Void setFixedPicRateFlag( Int layer, Bool flag ) { m_HRD[layer].fixedPicRateFlag = flag; }
536	Bool getFixedPicRateFlag( Int layer ) const { return m_HRD[layer].fixedPicRateFlag; }
537
538	Void setFixedPicRateWithinCvsFlag( Int layer, Bool flag ) { m_HRD[layer].fixedPicRateWithinCvsFlag = flag; }
539	Bool getFixedPicRateWithinCvsFlag( Int layer ) const { return m_HRD[layer].fixedPicRateWithinCvsFlag; }
540
541	Void setPicDurationInTcMinus1( Int layer, UInt value ) { m_HRD[layer].picDurationInTcMinus1 = value; }
542	UInt getPicDurationInTcMinus1( Int layer ) const { return m_HRD[layer].picDurationInTcMinus1; }
543
544	Void setLowDelayHrdFlag( Int layer, Bool flag ) { m_HRD[layer].lowDelayHrdFlag = flag; }
545	Bool getLowDelayHrdFlag( Int layer ) const { return m_HRD[layer].lowDelayHrdFlag; }
546
547	Void setCpbCntMinus1( Int layer, UInt value ) { m_HRD[layer].cpbCntMinus1 = value; }
548	UInt getCpbCntMinus1( Int layer ) const { return m_HRD[layer].cpbCntMinus1; }
549
550	Void setBitRateValueMinus1( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].bitRateValueMinus1[cpbcnt][nalOrVcl] = value; }
551	UInt getBitRateValueMinus1( Int layer, Int cpbcnt, Int nalOrVcl ) const { return m_HRD[layer].bitRateValueMinus1[cpbcnt][nalOrVcl]; }
552
553	Void setCpbSizeValueMinus1( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].cpbSizeValue[cpbcnt][nalOrVcl] = value; }
554	UInt getCpbSizeValueMinus1( Int layer, Int cpbcnt, Int nalOrVcl ) const { return m_HRD[layer].cpbSizeValue[cpbcnt][nalOrVcl]; }
555	Void setDuCpbSizeValueMinus1( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].ducpbSizeValue[cpbcnt][nalOrVcl] = value; }
556	UInt getDuCpbSizeValueMinus1( Int layer, Int cpbcnt, Int nalOrVcl ) const { return m_HRD[layer].ducpbSizeValue[cpbcnt][nalOrVcl]; }
557	Void setDuBitRateValueMinus1( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].duBitRateValue[cpbcnt][nalOrVcl] = value; }
558	UInt getDuBitRateValueMinus1(Int layer, Int cpbcnt, Int nalOrVcl ) const { return m_HRD[layer].duBitRateValue[cpbcnt][nalOrVcl]; }
559	Void setCbrFlag( Int layer, Int cpbcnt, Int nalOrVcl, Bool value ) { m_HRD[layer].cbrFlag[cpbcnt][nalOrVcl] = value; }
560	Bool getCbrFlag( Int layer, Int cpbcnt, Int nalOrVcl ) const { return m_HRD[layer].cbrFlag[cpbcnt][nalOrVcl]; }
561
562	Bool getCpbDpbDelaysPresentFlag( ) const { return getNalHrdParametersPresentFlag() \|\| getVclHrdParametersPresentFlag(); }
563	};
564
565	class TimingInfo
566	{
567	Bool m_timingInfoPresentFlag;
568	UInt m_numUnitsInTick;
569	UInt m_timeScale;
570	Bool m_pocProportionalToTimingFlag;
571	Int m_numTicksPocDiffOneMinus1;
572	public:
573	TimingInfo()
574	: m_timingInfoPresentFlag (false)
575	, m_numUnitsInTick (1001)
576	, m_timeScale (60000)
577	, m_pocProportionalToTimingFlag(false)
578	, m_numTicksPocDiffOneMinus1 (0)
579	{}
580
581	Void setTimingInfoPresentFlag( Bool flag ) { m_timingInfoPresentFlag = flag; }
582	Bool getTimingInfoPresentFlag( ) const { return m_timingInfoPresentFlag; }
583
584	Void setNumUnitsInTick( UInt value ) { m_numUnitsInTick = value; }
585	UInt getNumUnitsInTick( ) const { return m_numUnitsInTick; }
586
587	Void setTimeScale( UInt value ) { m_timeScale = value; }
588	UInt getTimeScale( ) const { return m_timeScale; }
589
590	Void setPocProportionalToTimingFlag(Bool x) { m_pocProportionalToTimingFlag = x; }
591	Bool getPocProportionalToTimingFlag( ) const { return m_pocProportionalToTimingFlag; }
592
593	Void setNumTicksPocDiffOneMinus1(Int x) { m_numTicksPocDiffOneMinus1 = x; }
594	Int getNumTicksPocDiffOneMinus1( ) const { return m_numTicksPocDiffOneMinus1; }
595	};
596
597	struct ChromaQpAdj
598	{
599	union
600	{
601	struct {
602	Int CbOffset;
603	Int CrOffset;
604	} comp;
605	Int offset[2]; /* two chroma components */
606	} u;
607	};
608
609	#if NH_MV
610
611	class TComVideoSignalInfo
612	{
613	private:
614	Int m_videoVpsFormat;
615	Bool m_videoFullRangeVpsFlag;
616	Int m_colourPrimariesVps;
617	Int m_transferCharacteristicsVps;
618	Int m_matrixCoeffsVps;
619	public:
620	Void setVideoVpsFormat( Int val ) { m_videoVpsFormat = val; }
621	Int getVideoVpsFormat( ) const { return m_videoVpsFormat; }
622
623	Void setVideoFullRangeVpsFlag( Bool flag ) { m_videoFullRangeVpsFlag = flag; }
624	Bool getVideoFullRangeVpsFlag( ) const { return m_videoFullRangeVpsFlag; }
625
626	Void setColourPrimariesVps( Int val ) { m_colourPrimariesVps = val; }
627	Int getColourPrimariesVps( ) const { return m_colourPrimariesVps; }
628
629	Void setTransferCharacteristicsVps( Int val ) { m_transferCharacteristicsVps = val; }
630	Int getTransferCharacteristicsVps( ) const { return m_transferCharacteristicsVps; }
631
632	Void setMatrixCoeffsVps( Int val ) { m_matrixCoeffsVps = val; }
633	Int getMatrixCoeffsVps( ) const { return m_matrixCoeffsVps; }
634	};
635
636	class TComVpsVuiBspHrdParameters
637	{
638	/* Not yet tested */
639	private:
640
641	Int m_vpsNumAddHrdParams;
642	BoolAry1d m_cprmsAddPresentFlag;
643	std::vector<TComHRD> m_hrdParameters;
644	IntAry1d m_numSubLayerHrdMinus1;
645	IntAry1d m_numSignalledPartitioningSchemes;
646	IntAry2d m_numPartitionsInSchemeMinus1;
647
648	BoolAry4d m_layerIncludedInPartitionFlag;
649	IntAry3d m_numBspSchedulesMinus1;
650	IntAry5d m_bspHrdIdx;
651	IntAry5d m_bspSchedIdx;
652
653	// Array sizes
654	Int m_offsetHrdParamIdx;
655	Int m_numHrdParam;
656	Int m_numOls;
657	TComVPS* m_vps;
658	public:
659
660	Void createAfterVpsNumAddHrdParams( const TComVPS* vps );
661	Void createAfterNumSignalledPartitioningSchemes(const TComVPS* vps, Int h );
662	Void createAfterNumPartitionsInSchemeMinus1(const TComVPS* vps, Int h, Int j);
663	Void createAfterNumBspSchedulesMinus1(const TComVPS* vps, Int h, Int i, Int t);
664
665	Void setVpsNumAddHrdParams( Int val ) { m_vpsNumAddHrdParams = val; }
666	Int getVpsNumAddHrdParams( ) const { return m_vpsNumAddHrdParams; }
667
668	Void setCprmsAddPresentFlag( Int i, Bool flag ) { m_cprmsAddPresentFlag[i - m_offsetHrdParamIdx] = flag; }
669	Bool getCprmsAddPresentFlag( Int i ) const { return m_cprmsAddPresentFlag[i - m_offsetHrdParamIdx]; }
670
671	Void setNumSubLayerHrdMinus1( Int i, Int val ) { m_numSubLayerHrdMinus1[i - m_offsetHrdParamIdx] = val; }
672	Int getNumSubLayerHrdMinus1( Int i ) const { return m_numSubLayerHrdMinus1[i - m_offsetHrdParamIdx]; }
673
674	Void setNumSignalledPartitioningSchemes( Int h, Int val ) { m_numSignalledPartitioningSchemes[h] = val; }
675	Int getNumSignalledPartitioningSchemes( Int h ) const { return m_numSignalledPartitioningSchemes[h]; }
676
677	Void setNumPartitionsInSchemeMinus1( Int h, Int j, Int val ) { m_numPartitionsInSchemeMinus1[h][j] = val; }
678	Int getNumPartitionsInSchemeMinus1( Int h, Int j ) const { return m_numPartitionsInSchemeMinus1[h][j]; }
679
680	Void setLayerIncludedInPartitionFlag( Int h, Int j, Int k, Int r, Bool flag ) { m_layerIncludedInPartitionFlag[h][j][k][r] = flag; }
681	Bool getLayerIncludedInPartitionFlag( Int h, Int j, Int k, Int r ) const { return m_layerIncludedInPartitionFlag[h][j][k][r]; }
682
683	Void setNumBspSchedulesMinus1( Int h, Int i, Int t, Int val ) { m_numBspSchedulesMinus1[h][i][t] = val; }
684	Int getNumBspSchedulesMinus1( Int h, Int i, Int t ) const { return m_numBspSchedulesMinus1[h][i][t]; }
685
686	Void setBspHrdIdx( Int h, Int i, Int t, Int j, Int k, Int val ) { m_bspHrdIdx[h][i - m_offsetHrdParamIdx][t][j][k] = val; }
687	Int getBspHrdIdx( Int h, Int i, Int t, Int j, Int k ) const { return m_bspHrdIdx[h][i - m_offsetHrdParamIdx][t][j][k]; }
688
689	Int getBspHrdIdxLen ( const TComVPS* vps ) const ;
690
691	Void setBspSchedIdx( Int h, Int i, Int t, Int j, Int k, Int val ) { m_bspSchedIdx[h][i - m_offsetHrdParamIdx][t][j][k] = val; }
692	Int getBspSchedIdx( Int h, Int i, Int t, Int j, Int k ) const { return m_bspSchedIdx[h][i - m_offsetHrdParamIdx][t][j][k]; }
693
694	Void setHrdParametermeters( Int k, TComHRD val ) { m_hrdParameters[k] = val; }
695	const TComHRD* getHrdParametermeters( Int k ) const { return &m_hrdParameters[k]; }
696	};
697
698	class TComVPSVUI
699	{
700	private:
701	Bool m_crossLayerPicTypeAlignedFlag ;
702	Bool m_crossLayerIrapAlignedFlag ;
703	Bool m_allLayersIdrAlignedFlag ;
704	Bool m_bitRatePresentVpsFlag ;
705	Bool m_picRatePresentVpsFlag ;
706	BoolAry2d m_bitRatePresentFlag ;
707	BoolAry2d m_picRatePresentFlag ;
708	IntAry2d m_avgBitRate ;
709	IntAry2d m_maxBitRate ;
710	IntAry2d m_constantPicRateIdc ;
711	IntAry2d m_avgPicRate ;
712	Bool m_videoSignalInfoIdxPresentFlag ;
713	Int m_vpsNumVideoSignalInfoMinus1 ;
714	std::vector< TComVideoSignalInfo > m_videoSignalInfo ;
715	IntAry1d m_vpsVideoSignalInfoIdx ;
716	Bool m_tilesNotInUseFlag; ;
717	BoolAry1d m_tilesInUseFlag ;
718	BoolAry1d m_loopFilterNotAcrossTilesFlag ;
719	BoolAry2d m_tileBoundariesAlignedFlag ;
720	Bool m_wppNotInUseFlag ;
721	BoolAry1d m_wppInUseFlag ;
722	Bool m_singleLayerForNonIrapFlag ;
723	Bool m_higherLayerIrapSkipFlag ;
724	Bool m_ilpRestrictedRefLayersFlag ;
725	IntAry2d m_minSpatialSegmentOffsetPlus1 ;
726	BoolAry2d m_ctuBasedOffsetEnabledFlag ;
727	IntAry2d m_minHorizontalCtuOffsetPlus1 ;
728	Bool m_vpsVuiBspHrdPresentFlag ;
729	TComVpsVuiBspHrdParameters m_vpsVuiBspHrdParameters ;
730	BoolAry1d m_baseLayerParameterSetCompatibilityFlag;
731
732	public:
733
734	Void init( Int numLayerSets, Int maxNumSubLayers, Int maxNumLayers );
735
736	Void setCrossLayerPicTypeAlignedFlag( Bool flag ) { m_crossLayerPicTypeAlignedFlag = flag; }
737	Bool getCrossLayerPicTypeAlignedFlag( ) const { return m_crossLayerPicTypeAlignedFlag; }
738
739	Void setCrossLayerIrapAlignedFlag( Bool flag ) { m_crossLayerIrapAlignedFlag = flag; }
740	Bool getCrossLayerIrapAlignedFlag( ) const { return m_crossLayerIrapAlignedFlag; }
741
742	Void setAllLayersIdrAlignedFlag( Bool flag ) { m_allLayersIdrAlignedFlag = flag; }
743	Bool getAllLayersIdrAlignedFlag( ) const { return m_allLayersIdrAlignedFlag; }
744
745	Void setBitRatePresentVpsFlag( Bool flag ) { m_bitRatePresentVpsFlag = flag; }
746	Bool getBitRatePresentVpsFlag( ) const { return m_bitRatePresentVpsFlag; }
747
748	Void setPicRatePresentVpsFlag( Bool flag ) { m_picRatePresentVpsFlag = flag; }
749	Bool getPicRatePresentVpsFlag( ) const { return m_picRatePresentVpsFlag; }
750
751	Void setBitRatePresentFlag( Int i, Int j, Bool flag ) { m_bitRatePresentFlag[i][j] = flag; }
752	Bool getBitRatePresentFlag( Int i, Int j ) const { return m_bitRatePresentFlag[i][j]; }
753
754	Void setPicRatePresentFlag( Int i, Int j, Bool flag ) { m_picRatePresentFlag[i][j] = flag; }
755	Bool getPicRatePresentFlag( Int i, Int j ) const { return m_picRatePresentFlag[i][j]; }
756
757	Void setAvgBitRate( Int i, Int j, Int val ) { m_avgBitRate[i][j] = val; }
758	Int getAvgBitRate( Int i, Int j ) const { return m_avgBitRate[i][j]; }
759
760	Void setMaxBitRate( Int i, Int j, Int val ) { m_maxBitRate[i][j] = val; }
761	Int getMaxBitRate( Int i, Int j ) const { return m_maxBitRate[i][j]; }
762
763	Void setConstantPicRateIdc( Int i, Int j, Int val ) { m_constantPicRateIdc[i][j] = val; }
764	Int getConstantPicRateIdc( Int i, Int j ) const { return m_constantPicRateIdc[i][j]; }
765
766	Void setAvgPicRate( Int i, Int j, Int val ) { m_avgPicRate[i][j] = val; }
767	Int getAvgPicRate( Int i, Int j ) const { return m_avgPicRate[i][j]; }
768
769	Void setVideoSignalInfoIdxPresentFlag( Bool flag ) { m_videoSignalInfoIdxPresentFlag = flag; }
770	Bool getVideoSignalInfoIdxPresentFlag( ) const { return m_videoSignalInfoIdxPresentFlag; }
771
772	Void setVideoSignalInfo( std::vector<TComVideoSignalInfo> val ) { m_videoSignalInfo = val; }
773	const TComVideoSignalInfo* getVideoSignalInfo( Int i ) const { return &m_videoSignalInfo[i]; }
774
775	Void setVpsNumVideoSignalInfoMinus1( Int val ) { m_vpsNumVideoSignalInfoMinus1 = val; }
776	Int getVpsNumVideoSignalInfoMinus1( ) const { return m_vpsNumVideoSignalInfoMinus1; }
777
778	Void setVpsVideoSignalInfoIdx( Int i, Int val ) { m_vpsVideoSignalInfoIdx[i] = val; }
779	Int getVpsVideoSignalInfoIdx( Int i ) const { return m_vpsVideoSignalInfoIdx[i]; }
780
781	Void setTilesNotInUseFlag( Bool flag ) { m_tilesNotInUseFlag = flag; }
782	Bool getTilesNotInUseFlag( ) const { return m_tilesNotInUseFlag; }
783
784	Void setTilesInUseFlag( Int i, Bool flag ) { m_tilesInUseFlag[i] = flag; }
785	Bool getTilesInUseFlag( Int i ) const { return m_tilesInUseFlag[i]; }
786
787	Void setLoopFilterNotAcrossTilesFlag( Int i, Int val ) { m_loopFilterNotAcrossTilesFlag[i] = val; }
788	Bool getLoopFilterNotAcrossTilesFlag( Int i ) const { return m_loopFilterNotAcrossTilesFlag[i]; }
789
790	Void setTileBoundariesAlignedFlag( Int i, Int j, Bool flag ) { m_tileBoundariesAlignedFlag[i][j] = flag; }
791	Bool getTileBoundariesAlignedFlag( Int i, Int j ) const { return m_tileBoundariesAlignedFlag[i][j]; }
792
793	Void setWppNotInUseFlag( Bool flag ) { m_wppNotInUseFlag = flag; }
794	Bool getWppNotInUseFlag( ) const { return m_wppNotInUseFlag; }
795
796	Void setWppInUseFlag( Int i, Bool flag ) { m_wppInUseFlag[i] = flag; }
797	Bool getWppInUseFlag( Int i ) const { return m_wppInUseFlag[i]; }
798
799	Void setSingleLayerForNonIrapFlag( Bool flag ) { m_singleLayerForNonIrapFlag = flag; }
800	Bool getSingleLayerForNonIrapFlag( ) const { return m_singleLayerForNonIrapFlag; }
801
802	Void setHigherLayerIrapSkipFlag( Bool flag ) { m_higherLayerIrapSkipFlag = flag; }
803	Bool getHigherLayerIrapSkipFlag( ) const { return m_higherLayerIrapSkipFlag; }
804
805	Void setIlpRestrictedRefLayersFlag( Bool flag ) { m_ilpRestrictedRefLayersFlag = flag; }
806	Bool getIlpRestrictedRefLayersFlag( ) const { return m_ilpRestrictedRefLayersFlag; }
807
808	Void setMinSpatialSegmentOffsetPlus1( Int i, Int j, Int val ) { m_minSpatialSegmentOffsetPlus1[i][j] = val; }
809	Int getMinSpatialSegmentOffsetPlus1( Int i, Int j ) const { return m_minSpatialSegmentOffsetPlus1[i][j]; }
810
811	Void setCtuBasedOffsetEnabledFlag( Int i, Int j, Bool flag ) { m_ctuBasedOffsetEnabledFlag[i][j] = flag; }
812	Bool getCtuBasedOffsetEnabledFlag( Int i, Int j ) const { return m_ctuBasedOffsetEnabledFlag[i][j]; }
813
814	Void setMinHorizontalCtuOffsetPlus1( Int i, Int j, Int val ) { m_minHorizontalCtuOffsetPlus1[i][j] = val; }
815	Int getMinHorizontalCtuOffsetPlus1( Int i, Int j ) const { return m_minHorizontalCtuOffsetPlus1[i][j]; }
816
817	Void setVpsVuiBspHrdPresentFlag( Bool flag ) { m_vpsVuiBspHrdPresentFlag = flag; }
818	Bool getVpsVuiBspHrdPresentFlag( ) const { return m_vpsVuiBspHrdPresentFlag; }
819
820	Void setVpsVuiBspHrdParameters( TComVpsVuiBspHrdParameters val) { m_vpsVuiBspHrdParameters = val; }
821	const TComVpsVuiBspHrdParameters* getVpsVuiBspHrdParameters( ) const { return &m_vpsVuiBspHrdParameters; }
822
823	Void setBaseLayerParameterSetCompatibilityFlag( Int i, Bool flag ) { m_baseLayerParameterSetCompatibilityFlag[i] = flag; }
824	Bool getBaseLayerParameterSetCompatibilityFlag( Int i ) const { return m_baseLayerParameterSetCompatibilityFlag[i]; }
825	};
826
827	class TComRepFormat
828	{
829	private:
830	Bool m_chromaAndBitDepthVpsPresentFlag;
831	Int m_chromaFormatVpsIdc;
832	Bool m_separateColourPlaneVpsFlag;
833	Int m_picWidthVpsInLumaSamples;
834	Int m_picHeightVpsInLumaSamples;
835	Int m_bitDepthVpsLumaMinus8;
836	Int m_bitDepthVpsChromaMinus8;
837	Bool m_conformanceWindowVpsFlag;
838	Int m_confWinVpsLeftOffset;
839	Int m_confWinVpsRightOffset;
840	Int m_confWinVpsTopOffset;
841	Int m_confWinVpsBottomOffset;
842
843	public:
844
845	TComRepFormat()
846	{
847	m_conformanceWindowVpsFlag = 0;
848	m_confWinVpsLeftOffset = 0;
849	m_confWinVpsRightOffset = 0;
850	m_confWinVpsTopOffset = 0;
851	m_confWinVpsBottomOffset = 0;
852	};
853
854	Void setChromaAndBitDepthVpsPresentFlag( Bool flag ) { m_chromaAndBitDepthVpsPresentFlag = flag; }
855	Bool getChromaAndBitDepthVpsPresentFlag( ) const { return m_chromaAndBitDepthVpsPresentFlag; }
856	Void checkChromaAndBitDepthVpsPresentFlag( Int i ) const { assert( i != 0 \|\| m_chromaAndBitDepthVpsPresentFlag ); } // The value of chroma_and_bit_depth_vps_present_flag of the first rep_format( ) syntax structure in the VPS shall be equal to 1.
857
858	Void inferChromaAndBitDepth ( const TComRepFormat* prevRepFormat );
859	Void checkInferChromaAndBitDepth( const TComRepFormat* prevRepFormat ) const;
860
861	Void setChromaFormatVpsIdc( Int val ) { m_chromaFormatVpsIdc = val; }
862	Int getChromaFormatVpsIdc( ) const { return m_chromaFormatVpsIdc; }
863
864	Void setSeparateColourPlaneVpsFlag( Bool flag ) { m_separateColourPlaneVpsFlag = flag; }
865	Bool getSeparateColourPlaneVpsFlag( ) const { return m_separateColourPlaneVpsFlag; }
866
867	Void setPicWidthVpsInLumaSamples( Int val ) { m_picWidthVpsInLumaSamples = val; }
868	Int getPicWidthVpsInLumaSamples( ) const { return m_picWidthVpsInLumaSamples; }
869
870	Void setPicHeightVpsInLumaSamples( Int val ) { m_picHeightVpsInLumaSamples = val; }
871	Int getPicHeightVpsInLumaSamples( ) const { return m_picHeightVpsInLumaSamples; }
872
873	Void setBitDepthVpsLumaMinus8( Int val ) { m_bitDepthVpsLumaMinus8 = val; }
874	Int getBitDepthVpsLumaMinus8( ) const { return m_bitDepthVpsLumaMinus8; }
875
876	Void setBitDepthVpsChromaMinus8( Int val ) { m_bitDepthVpsChromaMinus8 = val; }
877	Int getBitDepthVpsChromaMinus8( ) const { return m_bitDepthVpsChromaMinus8; }
878
879	Void setConformanceWindowVpsFlag( Bool flag ) { m_conformanceWindowVpsFlag = flag; }
880	Bool getConformanceWindowVpsFlag( ) const { return m_conformanceWindowVpsFlag; }
881
882	Void setConfWinVpsLeftOffset( Int val ) { m_confWinVpsLeftOffset = val; }
883	Int getConfWinVpsLeftOffset( ) const { return m_confWinVpsLeftOffset; }
884
885	Void setConfWinVpsRightOffset( Int val ) { m_confWinVpsRightOffset = val; }
886	Int getConfWinVpsRightOffset( ) const { return m_confWinVpsRightOffset; }
887
888	Void setConfWinVpsTopOffset( Int val ) { m_confWinVpsTopOffset = val; }
889	Int getConfWinVpsTopOffset( ) const { return m_confWinVpsTopOffset; }
890
891	Void setConfWinVpsBottomOffset( Int val ) { m_confWinVpsBottomOffset = val; }
892	Int getConfWinVpsBottomOffset( ) const { return m_confWinVpsBottomOffset; }
893	};
894
895
896	class TComDpbSize
897	{
898	private:
899	BoolAry1d m_subLayerFlagInfoPresentFlag;
900	BoolAry2d m_subLayerDpbInfoPresentFlag ;
901	IntAry3d m_maxVpsDecPicBufferingMinus1;
902	IntAry2d m_maxVpsNumReorderPics ;
903	IntAry2d m_maxVpsLatencyIncreasePlus1 ;
904
905	public:
906	TComDpbSize() {};
907
908	Void init( Int numOutputLayerSets, Int maxNumLayerIds, Int maxNumSubLayers );
909
910	Void setSubLayerFlagInfoPresentFlag( Int i, Bool flag ) { m_subLayerFlagInfoPresentFlag[i] = flag; }
911	Bool getSubLayerFlagInfoPresentFlag( Int i ) const { return m_subLayerFlagInfoPresentFlag[i]; }
912
913	Void setSubLayerDpbInfoPresentFlag( Int i, Int j, Bool flag ) { m_subLayerDpbInfoPresentFlag[i][j] = flag; }
914	Bool getSubLayerDpbInfoPresentFlag( Int i, Int j ) const { return m_subLayerDpbInfoPresentFlag[i][j]; }
915
916	Void setMaxVpsDecPicBufferingMinus1( Int i, Int k, Int j, Int val ) { m_maxVpsDecPicBufferingMinus1[i][k][j] = val; }
917	Int getMaxVpsDecPicBufferingMinus1( Int i, Int k, Int j ) const { assert( m_maxVpsDecPicBufferingMinus1[i][k][j] >= 0 ); return m_maxVpsDecPicBufferingMinus1[i][k][j]; }
918
919	Void setMaxVpsNumReorderPics( Int i, Int j, Int val ) { m_maxVpsNumReorderPics[i][j] = val; }
920	Int getMaxVpsNumReorderPics( Int i, Int j ) const { return m_maxVpsNumReorderPics[i][j]; }
921
922	Void setMaxVpsLatencyIncreasePlus1( Int i, Int j, Int val ) { m_maxVpsLatencyIncreasePlus1[i][j] = val; }
923	Int getMaxVpsLatencyIncreasePlus1( Int i, Int j ) const { return m_maxVpsLatencyIncreasePlus1[i][j]; }
924	Int getVpsMaxLatencyPictures ( Int i, Int j ) const;
925	};
926	#endif
927
928	class TComVPS
929	{
930	private:
931	Int m_VPSId;
932	#if NH_MV
933	Bool m_vpsBaseLayerInternalFlag;
934	Bool m_vpsBaseLayerAvailableFlag;
935	#endif
936
937	UInt m_uiMaxTLayers;
938
939	#if NH_MV
940	UInt m_uiMaxLayersMinus1;
941	#else
942	UInt m_uiMaxLayers;
943	#endif
944	Bool m_bTemporalIdNestingFlag;
945
946	UInt m_numReorderPics[MAX_TLAYER];
947	UInt m_uiMaxDecPicBuffering[MAX_TLAYER];
948	UInt m_uiMaxLatencyIncrease[MAX_TLAYER]; // Really max latency increase plus 1 (value 0 expresses no limit)
949
950	UInt m_numHrdParameters;
951	#if NH_MV
952	UInt m_maxLayerId;
953	#else
954	UInt m_maxNuhReservedZeroLayerId;
955	#endif
956	std::vector<TComHRD> m_hrdParameters;
957	std::vector<UInt> m_hrdOpSetIdx;
958	std::vector<Bool> m_cprmsPresentFlag;
959	#if NH_MV
960	UInt m_vpsNumLayerSetsMinus1;
961	Bool m_layerIdIncludedFlag[MAX_VPS_OP_SETS_PLUS1][MAX_VPS_NUH_LAYER_ID_PLUS1];
962	#else
963	UInt m_numOpSets;
964	Bool m_layerIdIncludedFlag[MAX_VPS_OP_SETS_PLUS1][MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1];
965	#endif
966
967	#if NH_MV
968	TComPTL m_pcPTL[MAX_VPS_OP_SETS_PLUS1];
969	#else
970	TComPTL m_pcPTL;
971	#endif
972	TimingInfo m_timingInfo;
973	#if NH_MV
974	Bool m_vpsExtensionFlag;
975
976	/// VPS EXTENSION SYNTAX ELEMENTS
977	Int m_vpsNonVuiExtensionLength;
978	Bool m_splittingFlag;
979	Bool m_scalabilityMaskFlag [MAX_NUM_SCALABILITY_TYPES];
980	Int m_dimensionIdLen [MAX_NUM_SCALABILITY_TYPES];
981	Bool m_vpsNuhLayerIdPresentFlag;
982	Int m_layerIdInNuh [MAX_NUM_LAYER_IDS];
983	Int m_dimensionId [MAX_NUM_LAYER_IDS][MAX_NUM_SCALABILITY_TYPES];
984
985	Int m_viewIdLen;
986	Int m_viewIdVal [MAX_NUM_LAYERS];
987	Bool m_directDependencyFlag [MAX_NUM_LAYER_IDS][MAX_NUM_LAYER_IDS];
988	Bool m_vpsSubLayersMaxMinus1PresentFlag;
989	Int m_subLayersVpsMaxMinus1 [MAX_NUM_LAYERS];
990	Bool m_maxTidRefPresentFlag;
991	Int m_maxTidIlRefPicsPlus1 [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
992	Bool m_allRefLayersActiveFlag;
993	Int m_vpsNumProfileTierLevelMinus1;
994	Bool m_vpsProfilePresentFlag [MAX_VPS_OP_SETS_PLUS1];
995
996	Int m_numAddLayerSets;
997	Int m_highestLayerIdxPlus1 [MAX_VPS_ADD_OUTPUT_LAYER_SETS][MAX_NUM_LAYERS];
998	Int m_numAddOlss;
999
1000	Int m_defaultOutputLayerIdc;
1001
1002	Int m_layerSetIdxForOlsMinus1 [MAX_VPS_OUTPUTLAYER_SETS];
1003	Bool m_outputLayerFlag [MAX_VPS_OUTPUTLAYER_SETS][MAX_VPS_NUH_LAYER_ID_PLUS1];
1004	Int m_profileTierLevelIdx [MAX_VPS_OUTPUTLAYER_SETS ][MAX_NUM_LAYERS];
1005	Bool m_altOutputLayerFlag [MAX_VPS_OUTPUTLAYER_SETS];
1006	Bool m_repFormatIdxPresentFlag;
1007
1008	Int m_vpsNumRepFormatsMinus1;
1009	Int m_vpsRepFormatIdx [MAX_NUM_LAYERS];
1010
1011	std::vector<TComRepFormat> m_repFormat;
1012	Bool m_maxOneActiveRefLayerFlag;
1013	Bool m_vpsPocLsbAlignedFlag;
1014	Bool m_pocLsbNotPresentFlag [MAX_NUM_LAYERS];
1015
1016	TComDpbSize m_dpbSize;
1017	Int m_directDepTypeLenMinus2;
1018	Bool m_defaultDirectDependencyFlag;
1019	Int m_defaultDirectDependencyType;
1020
1021	Bool m_vpsVuiPresentFlag;
1022	TComVPSVUI m_vpsVUI;
1023	Int m_directDependencyType [MAX_NUM_LAYERS] [MAX_NUM_LAYERS];
1024
1025	// VPS EXTENSION SEMANTICS VARIABLES
1026	Int m_layerIdInVps [MAX_NUM_LAYERS ];
1027	Int m_dependencyFlag [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
1028
1029	Int m_numViews;
1030	Int m_numDirectRefLayers [MAX_NUM_LAYERS];
1031	Int m_idDirectRefLayer [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
1032	#if NH_3D
1033	Int m_numRefListLayers [MAX_NUM_LAYERS];
1034	Int m_idRefListLayer [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
1035	#endif
1036
1037
1038	Int m_numRefLayers [MAX_NUM_LAYER_IDS];
1039	Int m_idRefLayer [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
1040
1041
1042	Int m_numPredictedLayers [MAX_NUM_LAYERS ];
1043	Int m_idPredictedLayer [MAX_NUM_LAYERS][MAX_NUM_LAYER_IDS];
1044	Int m_numIndependentLayers;
1045	Int m_numLayersInTreePartition [MAX_NUM_LAYER_IDS];
1046	Int m_treePartitionLayerIdList [MAX_NUM_LAYERS][MAX_NUM_LAYER_IDS];
1047	Bool m_recursiveRefLayerFlag [MAX_NUM_LAYER_IDS][MAX_NUM_LAYER_IDS];
1048	Int m_viewIndex [MAX_NUM_LAYERS ];
1049
1050	IntAry2d m_targetDecLayerIdLists; //[TargetOptLayerSetIdx][i]
1051	IntAry2d m_targetOptLayerIdLists;
1052	IntAry2d m_layerSetLayerIdList;
1053
1054	Int m_numNecessaryLayers [MAX_VPS_OUTPUTLAYER_SETS];
1055	Bool m_necessaryLayerFlag [MAX_VPS_OUTPUTLAYER_SETS][MAX_NUM_LAYERS];
1056
1057	Int xGetDimBitOffset( Int j ) const;
1058	Void xSetRefLayerFlags( Int currLayerId );
1059
1060	// VPS EXTENSION 2 SYNTAX ELEMENTS
1061	#if NH_3D
1062	IntAry1d m_numCp;
1063	IntAry2d m_cpRefVoi;
1064	BoolAry2d m_cpPresentFlag;
1065	Int m_cpPrecision;
1066	BoolAry1d m_cpInSliceSegmentHeaderFlag;
1067	IntAry3d m_aaaiCodedScale ;
1068	IntAry3d m_aaaiCodedOffset;
1069
1070	IntAry1d m_viewOIdxList;
1071	BoolAry2d m_viewCompLayerPresentFlag;
1072	IntAry2d m_viewCompLayerId;
1073	#endif
1074
1075	#endif
1076
1077	public:
1078	TComVPS();
1079
1080	virtual ~TComVPS();
1081
1082	Void createHrdParamBuffer()
1083	{
1084	m_hrdParameters.resize(getNumHrdParameters());
1085	m_hrdOpSetIdx.resize(getNumHrdParameters());
1086	m_cprmsPresentFlag.resize(getNumHrdParameters());
1087	}
1088
1089	TComHRD* getHrdParameters( UInt i ) { return &m_hrdParameters[ i ]; }
1090	const TComHRD* getHrdParameters( UInt i ) const { return &m_hrdParameters[ i ]; }
1091	UInt getHrdOpSetIdx( UInt i ) const { return m_hrdOpSetIdx[ i ]; }
1092	Void setHrdOpSetIdx( UInt val, UInt i ) { m_hrdOpSetIdx[ i ] = val; }
1093	Bool getCprmsPresentFlag( UInt i ) const { return m_cprmsPresentFlag[ i ]; }
1094	Void setCprmsPresentFlag( Bool val, UInt i ) { m_cprmsPresentFlag[ i ] = val; }
1095
1096	Int getVPSId() const { return m_VPSId; }
1097	Void setVPSId(Int i) { m_VPSId = i; }
1098	#if NH_MV
1099	Void setVpsBaseLayerInternalFlag( Bool flag ) { m_vpsBaseLayerInternalFlag = flag; }
1100	Bool getVpsBaseLayerInternalFlag( ) const { return m_vpsBaseLayerInternalFlag; }
1101	Void setVpsBaseLayerAvailableFlag( Bool flag ) { m_vpsBaseLayerAvailableFlag = flag; }
1102	Bool getVpsBaseLayerAvailableFlag( ) const { return m_vpsBaseLayerAvailableFlag; }
1103	#endif
1104
1105	UInt getMaxTLayers() const { return m_uiMaxTLayers; }
1106	Void setMaxTLayers(UInt t) { m_uiMaxTLayers = t; }
1107	#if NH_MV
1108	UInt getMaxSubLayersMinus1() const { return m_uiMaxTLayers - 1; } // For consistency with draft spec
1109	Void setMaxSubLayersMinus1(UInt val) { m_uiMaxTLayers = (val + 1); }
1110	UInt getMaxLayersMinus1() const { return m_uiMaxLayersMinus1; }
1111	Void setMaxLayersMinus1(UInt l) { m_uiMaxLayersMinus1 = l; }
1112	#else
1113
1114	UInt getMaxLayers() const { return m_uiMaxLayers; }
1115	Void setMaxLayers(UInt l) { m_uiMaxLayers = l; }
1116	#endif
1117
1118	Bool getTemporalNestingFlag() const { return m_bTemporalIdNestingFlag; }
1119	Void setTemporalNestingFlag(Bool t) { m_bTemporalIdNestingFlag = t; }
1120
1121	Void setNumReorderPics(UInt v, UInt tLayer) { m_numReorderPics[tLayer] = v; }
1122	UInt getNumReorderPics(UInt tLayer) const { return m_numReorderPics[tLayer]; }
1123
1124	Void setMaxDecPicBuffering(UInt v, UInt tLayer) { assert(tLayer < MAX_TLAYER); m_uiMaxDecPicBuffering[tLayer] = v; }
1125	UInt getMaxDecPicBuffering(UInt tLayer) const { return m_uiMaxDecPicBuffering[tLayer]; }
1126
1127	Void setMaxLatencyIncrease(UInt v, UInt tLayer) { m_uiMaxLatencyIncrease[tLayer] = v; }
1128	UInt getMaxLatencyIncrease(UInt tLayer) const { return m_uiMaxLatencyIncrease[tLayer]; }
1129
1130	UInt getNumHrdParameters() const { return m_numHrdParameters; }
1131	Void setNumHrdParameters(UInt v) { m_numHrdParameters = v; }
1132	#if NH_MV
1133	UInt getVpsMaxLayerId() const { return m_maxLayerId; }
1134	Void setVpsMaxLayerId(UInt v) { m_maxLayerId = v; }
1135
1136	UInt getVpsNumLayerSetsMinus1() const { return m_vpsNumLayerSetsMinus1; }
1137	Void setVpsNumLayerSetsMinus1(UInt v) { m_vpsNumLayerSetsMinus1 = v; }
1138	#else
1139	UInt getMaxNuhReservedZeroLayerId() const { return m_maxNuhReservedZeroLayerId; }
1140	Void setMaxNuhReservedZeroLayerId(UInt v) { m_maxNuhReservedZeroLayerId = v; }
1141
1142	UInt getMaxOpSets() const { return m_numOpSets; }
1143	Void setMaxOpSets(UInt v) { m_numOpSets = v; }
1144	#endif
1145	Bool getLayerIdIncludedFlag(UInt opsIdx, UInt id) const { return m_layerIdIncludedFlag[opsIdx][id]; }
1146	Void setLayerIdIncludedFlag(Bool v, UInt opsIdx, UInt id) { m_layerIdIncludedFlag[opsIdx][id] = v; }
1147
1148	#if NH_MV
1149	TComPTL* getPTL( Int idx = 0 ) { return &m_pcPTL[idx]; }
1150	const TComPTL* getPTL( Int idx = 0 ) const { return &m_pcPTL[idx]; }
1151	#else
1152	TComPTL* getPTL() { return &m_pcPTL; }
1153	const TComPTL* getPTL() const { return &m_pcPTL; }
1154	#endif
1155	TimingInfo* getTimingInfo() { return &m_timingInfo; }
1156	const TimingInfo* getTimingInfo() const { return &m_timingInfo; }
1157
1158	#if NH_MV
1159	Void setVpsExtensionFlag( Bool flag ) { m_vpsExtensionFlag = flag; }
1160	Bool getVpsExtensionFlag( ) const { return m_vpsExtensionFlag; }
1161
1162	Void setVpsNonVuiExtensionLength( Int val ) { m_vpsNonVuiExtensionLength = val; }
1163	Int getVpsNonVuiExtensionLength( ) const { return m_vpsNonVuiExtensionLength; }
1164
1165	// VPS Extension
1166	Void setSplittingFlag( Bool val ) { m_splittingFlag = val; }
1167	Bool getSplittingFlag() const { return m_splittingFlag; }
1168
1169	Void setScalabilityMaskFlag( UInt val );
1170	Void setScalabilityMaskFlag( Int scalType, Bool val ) { m_scalabilityMaskFlag[scalType] = val; }
1171	Bool getScalabilityMaskFlag( Int scalType ) const { return m_scalabilityMaskFlag[scalType]; }
1172
1173	Int getNumScalabilityTypes( ) const;
1174
1175	Void setDimensionIdLen( Int sIdx, Int val ) { m_dimensionIdLen[sIdx] = val; }
1176	Int getDimensionIdLen( Int sIdx ) const { assert( m_dimensionIdLen[sIdx] > 0) ; return m_dimensionIdLen[sIdx]; }
1177
1178	Void setVpsNuhLayerIdPresentFlag( Bool val ) { m_vpsNuhLayerIdPresentFlag = val; }
1179	Bool getVpsNuhLayerIdPresentFlag() const { return m_vpsNuhLayerIdPresentFlag; }
1180
1181	Void setLayerIdInNuh( Int layerIdInVps, Int val ) { m_layerIdInNuh[layerIdInVps] = val; }
1182	Int getLayerIdInNuh( Int layerIdInVps ) const { assert( m_layerIdInNuh[layerIdInVps] >= 0 ); return m_layerIdInNuh[layerIdInVps]; }
1183
1184	Bool nuhLayerIdIncluded( Int layerIdinNuh ) const { return ( m_layerIdInVps[ layerIdinNuh ] > 0 ); }
1185
1186	Void setDimensionId( Int layerIdInVps, Int scalIdx, Int val ) { m_dimensionId[layerIdInVps][scalIdx] = val; }
1187	Int getDimensionId( Int layerIdInVps, Int scalIdx ) const { return m_dimensionId[layerIdInVps][scalIdx]; }
1188
1189	Void setViewIdLen( Int val ) { m_viewIdLen = val; }
1190	Int getViewIdLen( ) const { return m_viewIdLen; }
1191
1192	Void setViewIdVal( Int viewOrderIndex, Int val ) { m_viewIdVal[viewOrderIndex] = val; }
1193	Int getViewIdVal( Int viewOrderIndex ) const { return m_viewIdVal[viewOrderIndex]; }
1194
1195	Void setDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Bool val ) { m_directDependencyFlag[depLayeridInVps][refLayeridInVps] = val; }
1196	Bool getDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps ) const { return m_directDependencyFlag[depLayeridInVps][refLayeridInVps]; }
1197
1198	Void setVpsSubLayersMaxMinus1PresentFlag( Bool flag ) { m_vpsSubLayersMaxMinus1PresentFlag = flag; }
1199	Bool getVpsSubLayersMaxMinus1PresentFlag( ) const { return m_vpsSubLayersMaxMinus1PresentFlag; }
1200
1201	Void setSubLayersVpsMaxMinus1( Int i, Int val ) { m_subLayersVpsMaxMinus1[i] = val; }
1202	Int getSubLayersVpsMaxMinus1( Int i ) const { return m_subLayersVpsMaxMinus1[i]; }
1203	Void checkSubLayersVpsMaxMinus1( Int i ) const { assert( m_subLayersVpsMaxMinus1[i] >= 0 && m_subLayersVpsMaxMinus1[i] <= m_uiMaxTLayers - 1 ); }
1204
1205	Void setMaxTidRefPresentFlag( Bool flag ) { m_maxTidRefPresentFlag = flag; }
1206	Bool getMaxTidRefPresentFlag( ) const { return m_maxTidRefPresentFlag; }
1207
1208	Void setMaxTidIlRefPicsPlus1( Int i, Int j, Int val ) { m_maxTidIlRefPicsPlus1[i][j] = val; }
1209	Int getMaxTidIlRefPicsPlus1( Int i, Int j ) const { return m_maxTidIlRefPicsPlus1[i][j]; }
1210
1211	Void setAllRefLayersActiveFlag( Bool flag ) { m_allRefLayersActiveFlag = flag; }
1212	Bool getAllRefLayersActiveFlag( ) const { return m_allRefLayersActiveFlag; }
1213
1214	Void setVpsNumProfileTierLevelMinus1( Int val ) { m_vpsNumProfileTierLevelMinus1 = val; }
1215	Int getVpsNumProfileTierLevelMinus1( ) const { return m_vpsNumProfileTierLevelMinus1; }
1216
1217	Void setVpsProfilePresentFlag( Int idx, Bool val ) { m_vpsProfilePresentFlag[idx] = val; }
1218	Bool getVpsProfilePresentFlag( Int idx ) const { return m_vpsProfilePresentFlag[idx]; }
1219
1220	Void setNumAddLayerSets( Int val ) { m_numAddLayerSets = val; }
1221	Int getNumAddLayerSets( ) const { return m_numAddLayerSets; }
1222
1223	Void setHighestLayerIdxPlus1( Int i, Int j, Int val ) { m_highestLayerIdxPlus1[i][j] = val; }
1224	Int getHighestLayerIdxPlus1( Int i, Int j ) const { return m_highestLayerIdxPlus1[i][j]; }
1225
1226	Void setNumAddOlss( Int val ) { m_numAddOlss = val; }
1227	Int getNumAddOlss( ) const { return m_numAddOlss; }
1228
1229	Void setDefaultOutputLayerIdc( Int val ) { m_defaultOutputLayerIdc = val; }
1230	Int getDefaultOutputLayerIdc( ) const { return m_defaultOutputLayerIdc; }
1231
1232	Void setLayerSetIdxForOlsMinus1( Int outLayerSetIdx, Int val ) { m_layerSetIdxForOlsMinus1[ outLayerSetIdx ] = val; }
1233	Int getLayerSetIdxForOlsMinus1( Int outLayerSetIdx ) const { return m_layerSetIdxForOlsMinus1[ outLayerSetIdx ]; }
1234	Int getLayerSetIdxForOlsMinus1Len( Int outLayerSetIdx ) const { return gCeilLog2( getNumLayerSets() - 1 ); }
1235
1236	Void setOutputLayerFlag( Int outLayerSetIdx, Int i, Bool flag ) { m_outputLayerFlag[ outLayerSetIdx ][ i ] = flag; }
1237	Bool getOutputLayerFlag( Int outLayerSetIdx, Int i ) const { return m_outputLayerFlag[ outLayerSetIdx ][ i ]; }
1238
1239	Bool inferOutputLayerFlag( Int i, Int j ) const;
1240
1241	Void setProfileTierLevelIdx( Int i, Int j, Int val ) { m_profileTierLevelIdx[ i ][ j ] = val; }
1242	Int getProfileTierLevelIdx( Int i, Int j ) const { return m_profileTierLevelIdx[ i ][ j ]; }
1243	Int inferProfileTierLevelIdx( Int i, Int j ) const;
1244
1245	Void setAltOutputLayerFlag( Int i, Bool flag ) { m_altOutputLayerFlag[i] = flag; }
1246	Bool getAltOutputLayerFlag( Int i ) const { return m_altOutputLayerFlag[i]; }
1247
1248	Void setRepFormatIdxPresentFlag( Bool flag ) { m_repFormatIdxPresentFlag = flag; }
1249	Bool getRepFormatIdxPresentFlag( ) const { return m_repFormatIdxPresentFlag; }
1250
1251	Void setVpsNumRepFormatsMinus1( Int val ) { m_vpsNumRepFormatsMinus1 = val; }
1252	Int getVpsNumRepFormatsMinus1( ) const { return m_vpsNumRepFormatsMinus1; }
1253
1254	Void setVpsRepFormatIdx( Int i, Int val ) { m_vpsRepFormatIdx[i] = val; }
1255	Int getVpsRepFormatIdx( Int i ) const { return m_vpsRepFormatIdx[i]; }
1256
1257	Int inferVpsRepFormatIdx( Int i ) const { return std::min( i, getVpsNumRepFormatsMinus1() ); }
1258
1259	Void setRepFormat( Int i, TComRepFormat val ) { m_repFormat[i] = val; }
1260	Void setRepFormat( std::vector<TComRepFormat> val ) { m_repFormat = val; }
1261	const TComRepFormat* getRepFormat( Int i ) const { return &m_repFormat[i]; }
1262
1263	Void setMaxOneActiveRefLayerFlag( Bool flag) { m_maxOneActiveRefLayerFlag = flag; }
1264	Bool getMaxOneActiveRefLayerFlag( ) const { return m_maxOneActiveRefLayerFlag; }
1265
1266	Void setVpsPocLsbAlignedFlag( Bool flag ) { m_vpsPocLsbAlignedFlag = flag; }
1267	Bool getVpsPocLsbAlignedFlag( ) const { return m_vpsPocLsbAlignedFlag; }
1268
1269	Void setDpbSize( TComDpbSize val ) { m_dpbSize = val; }
1270	const TComDpbSize * getDpbSize( ) const { return &m_dpbSize; }
1271
1272
1273	Void setPocLsbNotPresentFlag( Int i, Bool flag ) { m_pocLsbNotPresentFlag[i] = flag; }
1274	Bool getPocLsbNotPresentFlag( Int i ) const { return m_pocLsbNotPresentFlag[i]; }
1275
1276	Void setDirectDepTypeLenMinus2( Int val) { m_directDepTypeLenMinus2 = val; }
1277	Int getDirectDepTypeLenMinus2( ) const { return m_directDepTypeLenMinus2; }
1278
1279	Void setDefaultDirectDependencyFlag( Bool flag ) { m_defaultDirectDependencyFlag = flag; }
1280	Bool getDefaultDirectDependencyFlag( ) const { return m_defaultDirectDependencyFlag; }
1281
1282	Void setDefaultDirectDependencyType( Int val ) { m_defaultDirectDependencyType = val; }
1283	Int getDefaultDirectDependencyType( ) const { return m_defaultDirectDependencyType; }
1284
1285	Void setDirectDependencyType( Int depLayeridInVps, Int refLayeridInVps, Int val) { m_directDependencyType[ depLayeridInVps ][ refLayeridInVps ] = val; }
1286	Int getDirectDependencyType( Int depLayeridInVps, Int refLayeridInVps) const { return m_directDependencyType[ depLayeridInVps ][ refLayeridInVps ]; }
1287
1288	Void setVpsVuiPresentFlag( Bool flag ) { m_vpsVuiPresentFlag = flag; }
1289	Bool getVpsVuiPresentFlag( ) const { return m_vpsVuiPresentFlag; }
1290
1291	const TComVPSVUI* getVPSVUI( ) const { return &m_vpsVUI; }
1292	Void setVPSVUI( TComVPSVUI val ) { m_vpsVUI = val; }
1293
1294	// VPS EXTENSION SEMANTICS VARIABLES
1295	Void setLayerIdInVps( Int layerIdInNuh, Int val ) { m_layerIdInVps[layerIdInNuh] = val; }
1296	Int getLayerIdInVps( Int layerIdInNuh ) const { assert( m_layerIdInVps[layerIdInNuh] >= 0 ); return m_layerIdInVps[layerIdInNuh]; }
1297
1298	Int getScalabilityId ( Int layerIdInVps, ScalabilityType scalType ) const ;
1299	Int getViewId ( Int layerIdInNuh ) const { return m_viewIdVal[ getViewIndex( layerIdInNuh )]; }
1300	Void setRefLayers();
1301
1302	// To be aligned with spec naming, getViewIndex will be removed in future versions
1303	Int getViewOrderIdx ( Int layerIdInNuh ) const { return getScalabilityId( getLayerIdInVps(layerIdInNuh), VIEW_ORDER_INDEX ); }
1304	Int getViewIndex ( Int layerIdInNuh ) const { return getViewOrderIdx( layerIdInNuh ); }
1305	Int getAuxId ( Int layerIdInNuh ) const { return getScalabilityId( getLayerIdInVps(layerIdInNuh), AUX_ID ); }
1306	Int getDependencyId ( Int layerIdInNuh ) const { return getScalabilityId( getLayerIdInVps(layerIdInNuh), DEPENDENCY_ID ); }
1307	Int getNumViews() const { return m_numViews; }
1308	Void initNumViews();
1309	#if NH_3D
1310	Void initViewCompLayer( );
1311	Int getViewOIdxList( Int i ) const { return m_viewOIdxList[i]; }
1312	std::vector<Int> getViewOIdxList( ) const { return m_viewOIdxList; }
1313
1314	Int getVoiInVps( Int viewOIdx ) const;
1315
1316	Bool getViewCompLayerPresentFlag (Int i, Bool d ) const { return m_viewCompLayerPresentFlag[ getVoiInVps(i) ][d]; }
1317	Int getViewCompLayerId (Int i, Bool d ) const { return m_viewCompLayerId [ getVoiInVps(i) ][d]; }
1318	#endif
1319	Bool getDependencyFlag( Int i, Int j ) const { return m_dependencyFlag[i][j]; }
1320	Int getNumDirectRefLayers( Int layerIdInNuh ) const { return m_numDirectRefLayers[ layerIdInNuh ]; };
1321	#if NH_3D
1322	Int getNumRefListLayers( Int layerIdInNuh ) const { return m_numRefListLayers[ layerIdInNuh ]; };
1323	#endif
1324
1325	Int getNumRefLayers ( Int i ) const { return m_numRefLayers[i]; }
1326	Int getNumPredictedLayers ( Int i ) const { return m_numPredictedLayers[i]; }
1327
1328	Int getIdRefLayer ( Int i, Int j ) const { assert( j >= 0 && j < getNumRefLayers ( i )); return m_idRefLayer [i][j]; }
1329	Int getIdPredictedLayer ( Int i, Int j ) const { assert( j >= 0 && j < getNumPredictedLayers( i )); return m_idPredictedLayer[i][j]; }
1330	Int getIdDirectRefLayer ( Int i, Int j ) const { assert( j >= 0 && j < getNumDirectRefLayers( i )); return m_idDirectRefLayer[i][j]; }
1331	#if NH_3D
1332	Int getIdRefListLayer ( Int i, Int j ) const { assert( j >= 0 && j < getNumRefListLayers ( i )); return m_idRefListLayer[i][j]; }
1333	#endif
1334	Int getNumIndependentLayers ( ) const { return m_numIndependentLayers; }
1335	Int getNumLayersInTreePartition( Int i ) const { return m_numLayersInTreePartition[i]; }
1336	Int getTreePartitionLayerIdList( Int i, Int j ) const { return m_treePartitionLayerIdList[i][j]; }
1337	Bool getRecursiveRefLayerFlag ( Int i, Int j ) const { return m_recursiveRefLayerFlag[i][j]; }
1338	Int getNumLayerSets( ) const { return getVpsNumLayerSetsMinus1() + 1 + getNumAddLayerSets(); };
1339
1340	Int getFirstAddLayerSetIdx() const { return getVpsNumLayerSetsMinus1() + 1; }
1341	Int getLastAddLayerSetIdx() const { return getFirstAddLayerSetIdx() + getNumAddLayerSets() - 1; }
1342	Bool checkVPSExtensionSyntax();
1343	Int scalTypeToScalIdx ( ScalabilityType scalType ) const ;
1344
1345	Int getProfileTierLevelIdxLen() const { return gCeilLog2( getVpsNumProfileTierLevelMinus1() + 1 ); };
1346	Int getVpsRepFormatIdxLen() const { return gCeilLog2( getVpsNumRepFormatsMinus1() + 1 ); };
1347
1348	Int getNumLayersInIdList ( Int lsIdx ) const;
1349	Int getLayerSetLayerIdList(Int lsIdx, Int j ) const { return m_layerSetLayerIdList[ lsIdx ][ j ]; };
1350
1351	Int getNumOutputLayerSets() const;
1352
1353	Bool isOutputLayer( Int outLayerSetIdx, Int layerIdInNuh ) const;
1354	Bool isIndependendNonBaseLayer ( Int layerIdInNuh ) const { return (layerIdInNuh > 0) && getNumRefLayers( layerIdInNuh ) == 0 ; };
1355	#if NH_3D
1356	Bool isFirstDepthLayer ( Int layerIdInNuh ) const;
1357	#endif
1358
1359	Void deriveLayerSetLayerIdList();
1360
1361	Int olsIdxToLsIdx( Int i ) const { return ( i < getNumLayerSets() ) ? i : getLayerSetIdxForOlsMinus1( i ) + 1 ; };
1362
1363	Void initTargetLayerIdLists ( );
1364	Void deriveTargetLayerIdList ( Int i );
1365
1366	std::vector<Int> getTargetDecLayerIdList( Int targetDecLayerSetIdx ) const { return m_targetDecLayerIdLists[targetDecLayerSetIdx]; };
1367	std::vector<Int> getTargetOptLayerIdList( Int targetOptLayerSetIdx ) const { return m_targetOptLayerIdLists[targetOptLayerSetIdx]; };
1368
1369	Int getNumOutputLayersInOutputLayerSet( Int i ) const { return (Int) getTargetOptLayerIdList( i ).size(); };
1370	Int getOlsHighestOutputLayerId( Int i ) const { return getTargetOptLayerIdList( i ).back(); };
1371
1372	Void deriveAddLayerSetLayerIdList( Int i );
1373	Void deriveNecessaryLayerFlags( Int olsIdx );
1374	Int getNecessaryLayerFlag( Int i, Int j ) const { AOF( i >= 0 && i < getNumOutputLayerSets() ); AOF( j >= 0 && j < getNumLayersInIdList( olsIdxToLsIdx( i ) ) ); return m_necessaryLayerFlag[i][j]; };
1375
1376	Int getMaxSubLayersInLayerSetMinus1( Int i ) const;
1377	Int getHighestLayerIdxPlus1Len( Int j ) const { return gCeilLog2( getNumLayersInTreePartition( j ) + 1 ); };
1378	Bool getAltOutputLayerFlagVar( Int i ) const;
1379
1380	// inference
1381	Int inferDimensionId ( Int i, Int j ) const;
1382	Int inferLastDimsionIdLenMinus1() const;
1383
1384	// helpers
1385	Void printPTL() const;
1386	Void printRepFormat() const;
1387	Void printLayerDependencies() const;
1388	Void printScalabilityId() const;
1389	Void printLayerSets() const;
1390
1391	IntAry1d getLayersOfVpsPtl( Int idxOfVpsPtl ) const;
1392
1393	/// VPS EXTENSION 2 SYNTAX ELEMENTS
1394	Int getDepthId ( Int layerIdInNuh) const { return getScalabilityId( getLayerIdInVps(layerIdInNuh), DEPTH_ID ); }
1395	#if NH_3D_VSO \|\| NH_3D
1396	Bool getVpsDepthFlag ( Int layerIdInNuh) const { return (getDepthId( layerIdInNuh ) > 0); }
1397	Int getLayerIdInNuh ( Int viewIndex, Bool depthFlag, Int auxId ) const;
1398	#endif
1399	#if NH_3D
1400	Void createCamPars ( Int iNumViews );
1401	Void initCamParaVPS ( Int vOIdxInVps, Int numCp, Bool cpInSliceSegmentHeaderFlag, Int* cpRefVoi, Int aaiScale, Int aaiOffset );
1402
1403	Void setCpPrecision ( Int val ) { m_cpPrecision = val; }
1404	Int getCpPrecision ( ) const { return m_cpPrecision; }
1405
1406	Void setNumCp ( Int i, Int val ) { m_numCp[i] = val; }
1407	Int getNumCp ( Int i ) const { return m_numCp[i]; }
1408
1409	Void setCpRefVoi ( Int i, Int m, Int val ) { m_cpRefVoi[i][m] = val; }
1410	Int getCpRefVoi ( Int i, Int m ) const { return m_cpRefVoi[i][m]; }
1411
1412	Void setCpInSliceSegmentHeaderFlag( Int i, Bool flag ) { m_cpInSliceSegmentHeaderFlag[i] = flag; }
1413	Bool getCpInSliceSegmentHeaderFlag( Int i ) const { return m_cpInSliceSegmentHeaderFlag[i]; }
1414
1415	Void setVpsCpScale ( Int i, Int j, Int val ) { m_aaaiCodedScale [i][0][j] = val; }
1416	Int getVpsCpScale ( Int i, Int j ) const { return m_aaaiCodedScale[i][0][j]; }
1417
1418	Void setVpsCpOff ( Int i, Int j, Int val ) { m_aaaiCodedOffset[i][0][j] = val; }
1419	Int getVpsCpOff ( Int i, Int j ) const { return m_aaaiCodedOffset[i][0][j]; }
1420
1421	Void setVpsCpInvScale ( Int i, Int j, Int val ) { m_aaaiCodedScale[i][1][j] = val; }
1422	Int getVpsCpInvScale ( Int i, Int j ) const { return m_aaaiCodedScale[i][1][j]; }
1423
1424	Void setVpsCpInvOff ( Int i, Int j, Int val ) { m_aaaiCodedOffset[i][1][j] = val; }
1425	Int getVpsCpInvOff ( Int i, Int j ) const { return m_aaaiCodedOffset[i][1][j]; }
1426
1427	// Derived
1428	Void deriveCpPresentFlag ( );
1429	Void setCpPresentFlag ( Int i, Int m, Bool flag ) { m_cpPresentFlag[i][m] = flag; }
1430	Bool getCpPresentFlag ( Int i, Int m ) const { return m_cpPresentFlag[i][m]; }
1431
1432	const IntAry1d& getCodedScale ( Int viewIndex ) const { return m_aaaiCodedScale [viewIndex][0]; }
1433	const IntAry1d& getCodedOffset ( Int viewIndex ) const { return m_aaaiCodedOffset[viewIndex][0]; }
1434	const IntAry1d& getInvCodedScale ( Int viewIndex ) const { return m_aaaiCodedScale [viewIndex][1]; }
1435	const IntAry1d& getInvCodedOffset ( Int viewIndex ) const { return m_aaaiCodedOffset[viewIndex][1]; }
1436	#endif
1437
1438	template <typename T, typename S, typename U> Void xPrintArray( const TChar* name, Int numElemDim1, U idx, S numElemDim2, T vec, Bool printNumber, Bool printIdx = true, Int elemDist = 3 ) const
1439	{
1440	std::cout << std::endl;
1441	for (Int j = 0; j < numElemDim1; j++ )
1442	{
1443	std::cout << std::right << std::setw(40) << name;
1444	if (printIdx)
1445	{
1446	std::cout << "[" << std::right << std::setw(3) << idx[ j ] << "]" ;
1447	}
1448	else
1449	{
1450	std::cout << std::right << std::setw(5) << " ";
1451	}
1452
1453	if ( printNumber )
1454	{
1455	std::cout << " (" << std::right << std::setw(3) << numElemDim2[j] << ")";
1456	}
1457	else
1458	{
1459	std::cout << std::right << std::setw(6) << " ";
1460	}
1461
1462	std::cout << ":";
1463	for (Int i = 0; i < numElemDim2[j]; i++)
1464	{
1465	std::cout << std::right << std::setw(elemDist) << vec[j][i];
1466	}
1467	std::cout << std::endl;
1468	}
1469	}
1470
1471	template <typename T> Void xPrintArray( const char* name, Int numElem, T vec, Bool printNumber, Int elemDist = 3 ) const
1472	{
1473	std::vector<Int> numElemDim2(1, numElem);
1474	std::vector<T> vec2 (1, vec );
1475	std::vector<Int> idx2 (0);
1476	xPrintArray( name, 1, idx2, numElemDim2, vec2, printNumber, false, elemDist );
1477	}
1478
1479	#endif
1480
1481	};
1482
1483	#if NH_3D
1484	class TComDLT
1485	{
1486	private:
1487	Bool m_bDltPresentFlag;
1488	Bool m_bUseDLTFlag [ MAX_NUM_LAYERS ];
1489	Bool m_bInterViewDltPredEnableFlag [ MAX_NUM_LAYERS ];
1490	Bool m_bDltBitMapRepFlag [ MAX_NUM_LAYERS ];
1491
1492	Int m_iNumDepthmapValues [ MAX_NUM_LAYERS ];
1493	std::vector<Int> m_iDepthValue2Idx [ MAX_NUM_LAYERS ];
1494	std::vector<Int> m_iIdx2DepthValue [ MAX_NUM_LAYERS ];
1495
1496	Int m_iNumDepthViews;
1497	UInt m_uiDepthViewBitDepth;
1498
1499	// mapping
1500	Int m_iDepthIdxToLayerId [ MAX_NUM_LAYERS ];
1501
1502	public:
1503	TComDLT( );
1504	~TComDLT();
1505
1506	Int getDepthIdxToLayerId(Int depthIdx) const { return m_iDepthIdxToLayerId[depthIdx]; }
1507	Void setDepthIdxToLayerId(Int depthIdx, Int layerId) { m_iDepthIdxToLayerId[depthIdx] = layerId; }
1508
1509	Bool getDltPresentFlag () const { return m_bDltPresentFlag; }
1510	Void setDltPresentFlag ( Bool b ) { m_bDltPresentFlag = b; }
1511
1512	Bool getUseDLTFlag ( Int layerIdInVps ) const { return m_bUseDLTFlag[ layerIdInVps ]; }
1513	Void setUseDLTFlag ( Int layerIdInVps, Bool b ) { m_bUseDLTFlag[ layerIdInVps ] = b; }
1514
1515	Bool getInterViewDltPredEnableFlag( Int layerIdInVps ) const { return m_bInterViewDltPredEnableFlag[ layerIdInVps ]; }
1516	Void setInterViewDltPredEnableFlag( Int layerIdInVps, Bool b ) { m_bInterViewDltPredEnableFlag[ layerIdInVps ] = b; }
1517
1518	Bool getUseBitmapRep ( Int layerIdInVps ) const { return m_bDltBitMapRepFlag[ layerIdInVps ]; }
1519	Void setUseBitmapRep ( Int layerIdInVps, Bool b ) { m_bDltBitMapRepFlag[ layerIdInVps ] = b; }
1520
1521	Void setNumDepthViews ( Int n ) { m_iNumDepthViews = n; }
1522	Int getNumDepthViews () const { return m_iNumDepthViews; }
1523
1524	Void setDepthViewBitDepth( UInt n ) { m_uiDepthViewBitDepth = n; }
1525	UInt getDepthViewBitDepth() const { return m_uiDepthViewBitDepth; }
1526
1527	Int getNumDepthValues( Int layerIdInVps ) const { return getUseDLTFlag(layerIdInVps)?m_iNumDepthmapValues[layerIdInVps]:(1 << m_uiDepthViewBitDepth); }
1528	Int depthValue2idx( Int layerIdInVps, Pel value ) const { return getUseDLTFlag(layerIdInVps)?m_iDepthValue2Idx[layerIdInVps][value]:value; }
1529	Pel idx2DepthValue( Int layerIdInVps, UInt uiIdx ) const { return getUseDLTFlag(layerIdInVps)?m_iIdx2DepthValue[layerIdInVps][ClipBD(uiIdx,m_uiDepthViewBitDepth)]:uiIdx; }
1530	Void setDepthLUTs( Int layerIdInVps, std::vector<Int> idx2DepthValue, Int iNumDepthValues = 0 );
1531	std::vector<Int> idx2DepthValue( Int layerIdInVps ) const { return m_iIdx2DepthValue[layerIdInVps]; }
1532	Void getDeltaDLT( Int layerIdInVps, std::vector<Int> piDLTInRef, UInt uiDLTInRefNum, std::vector<Int>& riDeltaDLTOut, UInt& ruiDeltaDLTOutNum ) const;
1533	Void setDeltaDLT( Int layerIdInVps, std::vector<Int> piDLTInRef, UInt uiDLTInRefNum, std::vector<Int> piDeltaDLTIn, UInt uiDeltaDLTInNum );
1534	};
1535	#endif
1536
1537
1538	class Window
1539	{
1540	private:
1541	Bool m_enabledFlag;
1542	Int m_winLeftOffset;
1543	Int m_winRightOffset;
1544	Int m_winTopOffset;
1545	Int m_winBottomOffset;
1546	#if NH_MV
1547	Bool m_scaledFlag;
1548	#endif
1549	public:
1550	Window()
1551	: m_enabledFlag (false)
1552	, m_winLeftOffset (0)
1553	, m_winRightOffset (0)
1554	, m_winTopOffset (0)
1555	, m_winBottomOffset(0)
1556	#if NH_MV
1557	, m_scaledFlag(true)
1558	#endif
1559	{ }
1560
1561	Bool getWindowEnabledFlag() const { return m_enabledFlag; }
1562	Int getWindowLeftOffset() const { return m_enabledFlag ? m_winLeftOffset : 0; }
1563	Void setWindowLeftOffset(Int val) { m_winLeftOffset = val; m_enabledFlag = true; }
1564	Int getWindowRightOffset() const { return m_enabledFlag ? m_winRightOffset : 0; }
1565	Void setWindowRightOffset(Int val) { m_winRightOffset = val; m_enabledFlag = true; }
1566	Int getWindowTopOffset() const { return m_enabledFlag ? m_winTopOffset : 0; }
1567	Void setWindowTopOffset(Int val) { m_winTopOffset = val; m_enabledFlag = true; }
1568	Int getWindowBottomOffset() const { return m_enabledFlag ? m_winBottomOffset: 0; }
1569	Void setWindowBottomOffset(Int val) { m_winBottomOffset = val; m_enabledFlag = true; }
1570
1571	#if NH_MV
1572	Void setScaledFlag(Bool flag) { m_scaledFlag = flag; }
1573	Bool getScaledFlag() const { return m_scaledFlag; }
1574	Void scaleOffsets( Int scal );
1575	#endif
1576	Void setWindow(Int offsetLeft, Int offsetLRight, Int offsetLTop, Int offsetLBottom)
1577	{
1578	m_enabledFlag = true;
1579	m_winLeftOffset = offsetLeft;
1580	m_winRightOffset = offsetLRight;
1581	m_winTopOffset = offsetLTop;
1582	m_winBottomOffset = offsetLBottom;
1583	}
1584	};
1585
1586
1587	class TComVUI
1588	{
1589	private:
1590	Bool m_aspectRatioInfoPresentFlag;
1591	Int m_aspectRatioIdc;
1592	Int m_sarWidth;
1593	Int m_sarHeight;
1594	Bool m_overscanInfoPresentFlag;
1595	Bool m_overscanAppropriateFlag;
1596	Bool m_videoSignalTypePresentFlag;
1597	Int m_videoFormat;
1598	Bool m_videoFullRangeFlag;
1599	Bool m_colourDescriptionPresentFlag;
1600	Int m_colourPrimaries;
1601	Int m_transferCharacteristics;
1602	Int m_matrixCoefficients;
1603	Bool m_chromaLocInfoPresentFlag;
1604	Int m_chromaSampleLocTypeTopField;
1605	Int m_chromaSampleLocTypeBottomField;
1606	Bool m_neutralChromaIndicationFlag;
1607	Bool m_fieldSeqFlag;
1608	Window m_defaultDisplayWindow;
1609	Bool m_frameFieldInfoPresentFlag;
1610	Bool m_hrdParametersPresentFlag;
1611	Bool m_bitstreamRestrictionFlag;
1612	Bool m_tilesFixedStructureFlag;
1613	Bool m_motionVectorsOverPicBoundariesFlag;
1614	Bool m_restrictedRefPicListsFlag;
1615	Int m_minSpatialSegmentationIdc;
1616	Int m_maxBytesPerPicDenom;
1617	Int m_maxBitsPerMinCuDenom;
1618	Int m_log2MaxMvLengthHorizontal;
1619	Int m_log2MaxMvLengthVertical;
1620	TComHRD m_hrdParameters;
1621	TimingInfo m_timingInfo;
1622
1623	public:
1624	TComVUI()
1625	: m_aspectRatioInfoPresentFlag (false) //TODO: This initialiser list contains magic numbers
1626	, m_aspectRatioIdc (0)
1627	, m_sarWidth (0)
1628	, m_sarHeight (0)
1629	, m_overscanInfoPresentFlag (false)
1630	, m_overscanAppropriateFlag (false)
1631	, m_videoSignalTypePresentFlag (false)
1632	, m_videoFormat (5)
1633	, m_videoFullRangeFlag (false)
1634	, m_colourDescriptionPresentFlag (false)
1635	, m_colourPrimaries (2)
1636	, m_transferCharacteristics (2)
1637	, m_matrixCoefficients (2)
1638	, m_chromaLocInfoPresentFlag (false)
1639	, m_chromaSampleLocTypeTopField (0)
1640	, m_chromaSampleLocTypeBottomField (0)
1641	, m_neutralChromaIndicationFlag (false)
1642	, m_fieldSeqFlag (false)
1643	, m_frameFieldInfoPresentFlag (false)
1644	, m_hrdParametersPresentFlag (false)
1645	, m_bitstreamRestrictionFlag (false)
1646	, m_tilesFixedStructureFlag (false)
1647	, m_motionVectorsOverPicBoundariesFlag(true)
1648	, m_restrictedRefPicListsFlag (1)
1649	, m_minSpatialSegmentationIdc (0)
1650	, m_maxBytesPerPicDenom (2)
1651	, m_maxBitsPerMinCuDenom (1)
1652	, m_log2MaxMvLengthHorizontal (15)
1653	, m_log2MaxMvLengthVertical (15)
1654	{}
1655
1656	virtual ~TComVUI() {}
1657
1658	Bool getAspectRatioInfoPresentFlag() const { return m_aspectRatioInfoPresentFlag; }
1659	Void setAspectRatioInfoPresentFlag(Bool i) { m_aspectRatioInfoPresentFlag = i; }
1660
1661	Int getAspectRatioIdc() const { return m_aspectRatioIdc; }
1662	Void setAspectRatioIdc(Int i) { m_aspectRatioIdc = i; }
1663
1664	Int getSarWidth() const { return m_sarWidth; }
1665	Void setSarWidth(Int i) { m_sarWidth = i; }
1666
1667	Int getSarHeight() const { return m_sarHeight; }
1668	Void setSarHeight(Int i) { m_sarHeight = i; }
1669
1670	Bool getOverscanInfoPresentFlag() const { return m_overscanInfoPresentFlag; }
1671	Void setOverscanInfoPresentFlag(Bool i) { m_overscanInfoPresentFlag = i; }
1672
1673	Bool getOverscanAppropriateFlag() const { return m_overscanAppropriateFlag; }
1674	Void setOverscanAppropriateFlag(Bool i) { m_overscanAppropriateFlag = i; }
1675
1676	Bool getVideoSignalTypePresentFlag() const { return m_videoSignalTypePresentFlag; }
1677	Void setVideoSignalTypePresentFlag(Bool i) { m_videoSignalTypePresentFlag = i; }
1678
1679	Int getVideoFormat() const { return m_videoFormat; }
1680	Void setVideoFormat(Int i) { m_videoFormat = i; }
1681
1682	Bool getVideoFullRangeFlag() const { return m_videoFullRangeFlag; }
1683	Void setVideoFullRangeFlag(Bool i) { m_videoFullRangeFlag = i; }
1684
1685	Bool getColourDescriptionPresentFlag() const { return m_colourDescriptionPresentFlag; }
1686	Void setColourDescriptionPresentFlag(Bool i) { m_colourDescriptionPresentFlag = i; }
1687
1688	Int getColourPrimaries() const { return m_colourPrimaries; }
1689	Void setColourPrimaries(Int i) { m_colourPrimaries = i; }
1690
1691	Int getTransferCharacteristics() const { return m_transferCharacteristics; }
1692	Void setTransferCharacteristics(Int i) { m_transferCharacteristics = i; }
1693
1694	Int getMatrixCoefficients() const { return m_matrixCoefficients; }
1695	Void setMatrixCoefficients(Int i) { m_matrixCoefficients = i; }
1696
1697	Bool getChromaLocInfoPresentFlag() const { return m_chromaLocInfoPresentFlag; }
1698	Void setChromaLocInfoPresentFlag(Bool i) { m_chromaLocInfoPresentFlag = i; }
1699
1700	Int getChromaSampleLocTypeTopField() const { return m_chromaSampleLocTypeTopField; }
1701	Void setChromaSampleLocTypeTopField(Int i) { m_chromaSampleLocTypeTopField = i; }
1702
1703	Int getChromaSampleLocTypeBottomField() const { return m_chromaSampleLocTypeBottomField; }
1704	Void setChromaSampleLocTypeBottomField(Int i) { m_chromaSampleLocTypeBottomField = i; }
1705
1706	Bool getNeutralChromaIndicationFlag() const { return m_neutralChromaIndicationFlag; }
1707	Void setNeutralChromaIndicationFlag(Bool i) { m_neutralChromaIndicationFlag = i; }
1708
1709	Bool getFieldSeqFlag() const { return m_fieldSeqFlag; }
1710	Void setFieldSeqFlag(Bool i) { m_fieldSeqFlag = i; }
1711
1712	Bool getFrameFieldInfoPresentFlag() const { return m_frameFieldInfoPresentFlag; }
1713	Void setFrameFieldInfoPresentFlag(Bool i) { m_frameFieldInfoPresentFlag = i; }
1714
1715	Window& getDefaultDisplayWindow() { return m_defaultDisplayWindow; }
1716	const Window& getDefaultDisplayWindow() const { return m_defaultDisplayWindow; }
1717	Void setDefaultDisplayWindow(Window& defaultDisplayWindow ) { m_defaultDisplayWindow = defaultDisplayWindow; }
1718
1719	Bool getHrdParametersPresentFlag() const { return m_hrdParametersPresentFlag; }
1720	Void setHrdParametersPresentFlag(Bool i) { m_hrdParametersPresentFlag = i; }
1721
1722	Bool getBitstreamRestrictionFlag() const { return m_bitstreamRestrictionFlag; }
1723	Void setBitstreamRestrictionFlag(Bool i) { m_bitstreamRestrictionFlag = i; }
1724
1725	Bool getTilesFixedStructureFlag() const { return m_tilesFixedStructureFlag; }
1726	Void setTilesFixedStructureFlag(Bool i) { m_tilesFixedStructureFlag = i; }
1727
1728	Bool getMotionVectorsOverPicBoundariesFlag() const { return m_motionVectorsOverPicBoundariesFlag; }
1729	Void setMotionVectorsOverPicBoundariesFlag(Bool i) { m_motionVectorsOverPicBoundariesFlag = i; }
1730
1731	Bool getRestrictedRefPicListsFlag() const { return m_restrictedRefPicListsFlag; }
1732	Void setRestrictedRefPicListsFlag(Bool b) { m_restrictedRefPicListsFlag = b; }
1733
1734	Int getMinSpatialSegmentationIdc() const { return m_minSpatialSegmentationIdc; }
1735	Void setMinSpatialSegmentationIdc(Int i) { m_minSpatialSegmentationIdc = i; }
1736
1737	Int getMaxBytesPerPicDenom() const { return m_maxBytesPerPicDenom; }
1738	Void setMaxBytesPerPicDenom(Int i) { m_maxBytesPerPicDenom = i; }
1739
1740	Int getMaxBitsPerMinCuDenom() const { return m_maxBitsPerMinCuDenom; }
1741	Void setMaxBitsPerMinCuDenom(Int i) { m_maxBitsPerMinCuDenom = i; }
1742
1743	Int getLog2MaxMvLengthHorizontal() const { return m_log2MaxMvLengthHorizontal; }
1744	Void setLog2MaxMvLengthHorizontal(Int i) { m_log2MaxMvLengthHorizontal = i; }
1745
1746	Int getLog2MaxMvLengthVertical() const { return m_log2MaxMvLengthVertical; }
1747	Void setLog2MaxMvLengthVertical(Int i) { m_log2MaxMvLengthVertical = i; }
1748
1749	TComHRD* getHrdParameters() { return &m_hrdParameters; }
1750	const TComHRD* getHrdParameters() const { return &m_hrdParameters; }
1751
1752	TimingInfo* getTimingInfo() { return &m_timingInfo; }
1753	const TimingInfo* getTimingInfo() const { return &m_timingInfo; }
1754	#if NH_MV
1755	Void inferVideoSignalInfo( const TComVPS* vps, Int layerIdCurr );
1756	#endif
1757	};
1758
1759	/// SPS RExt class
1760	class TComSPSRExt // Names aligned to text specification
1761	{
1762	private:
1763	Bool m_transformSkipRotationEnabledFlag;
1764	Bool m_transformSkipContextEnabledFlag;
1765	Bool m_rdpcmEnabledFlag[NUMBER_OF_RDPCM_SIGNALLING_MODES];
1766	Bool m_extendedPrecisionProcessingFlag;
1767	Bool m_intraSmoothingDisabledFlag;
1768	Bool m_highPrecisionOffsetsEnabledFlag;
1769	Bool m_persistentRiceAdaptationEnabledFlag;
1770	Bool m_cabacBypassAlignmentEnabledFlag;
1771
1772	public:
1773	TComSPSRExt();
1774
1775	Bool settingsDifferFromDefaults() const
1776	{
1777	return getTransformSkipRotationEnabledFlag()
1778	\|\| getTransformSkipContextEnabledFlag()
1779	\|\| getRdpcmEnabledFlag(RDPCM_SIGNAL_IMPLICIT)
1780	\|\| getRdpcmEnabledFlag(RDPCM_SIGNAL_EXPLICIT)
1781	\|\| getExtendedPrecisionProcessingFlag()
1782	\|\| getIntraSmoothingDisabledFlag()
1783	\|\| getHighPrecisionOffsetsEnabledFlag()
1784	\|\| getPersistentRiceAdaptationEnabledFlag()
1785	\|\| getCabacBypassAlignmentEnabledFlag();
1786	}
1787
1788
1789	Bool getTransformSkipRotationEnabledFlag() const { return m_transformSkipRotationEnabledFlag; }
1790	Void setTransformSkipRotationEnabledFlag(const Bool value) { m_transformSkipRotationEnabledFlag = value; }
1791
1792	Bool getTransformSkipContextEnabledFlag() const { return m_transformSkipContextEnabledFlag; }
1793	Void setTransformSkipContextEnabledFlag(const Bool value) { m_transformSkipContextEnabledFlag = value; }
1794
1795	Bool getRdpcmEnabledFlag(const RDPCMSignallingMode signallingMode) const { return m_rdpcmEnabledFlag[signallingMode]; }
1796	Void setRdpcmEnabledFlag(const RDPCMSignallingMode signallingMode, const Bool value) { m_rdpcmEnabledFlag[signallingMode] = value; }
1797
1798	Bool getExtendedPrecisionProcessingFlag() const { return m_extendedPrecisionProcessingFlag; }
1799	Void setExtendedPrecisionProcessingFlag(Bool value) { m_extendedPrecisionProcessingFlag = value; }
1800
1801	Bool getIntraSmoothingDisabledFlag() const { return m_intraSmoothingDisabledFlag; }
1802	Void setIntraSmoothingDisabledFlag(Bool bValue) { m_intraSmoothingDisabledFlag=bValue; }
1803
1804	Bool getHighPrecisionOffsetsEnabledFlag() const { return m_highPrecisionOffsetsEnabledFlag; }
1805	Void setHighPrecisionOffsetsEnabledFlag(Bool value) { m_highPrecisionOffsetsEnabledFlag = value; }
1806
1807	Bool getPersistentRiceAdaptationEnabledFlag() const { return m_persistentRiceAdaptationEnabledFlag; }
1808	Void setPersistentRiceAdaptationEnabledFlag(const Bool value) { m_persistentRiceAdaptationEnabledFlag = value; }
1809
1810	Bool getCabacBypassAlignmentEnabledFlag() const { return m_cabacBypassAlignmentEnabledFlag; }
1811	Void setCabacBypassAlignmentEnabledFlag(const Bool value) { m_cabacBypassAlignmentEnabledFlag = value; }
1812	};
1813
1814
1815	#if NH_3D
1816	class TComSps3dExtension
1817	{
1818	public:
1819	TComSps3dExtension()
1820	{
1821	for (Int d = 0; d < 2; d++)
1822	{
1823	m_ivDiMcEnabledFlag [d] = false;
1824	m_ivMvScalEnabledFlag [d] = false;
1825	m_log2IvmcSubPbSizeMinus3 [d] = 3;
1826	m_ivResPredEnabledFlag [d] = false;
1827	m_depthRefEnabledFlag [d] = false;
1828	m_vspMcEnabledFlag [d] = false;
1829	m_dbbpEnabledFlag [d] = false;
1830	m_texMcEnabledFlag [d] = false;
1831	m_log2TexmcSubPbSizeMinus3 [d] = 3;
1832	m_intraContourEnabledFlag [d] = false;
1833	m_intraDcOnlyWedgeEnabledFlag [d] = false;
1834	m_cqtCuPartPredEnabledFlag [d] = false;
1835	m_interDcOnlyEnabledFlag [d] = false;
1836	m_skipIntraEnabledFlag [d] = false;
1837	}
1838	}
1839
1840	Void setIvDiMcEnabledFlag( Int d, Bool flag ) { m_ivDiMcEnabledFlag[d] = flag; }
1841	Bool getIvDiMcEnabledFlag( Int d ) const { return m_ivDiMcEnabledFlag[d]; }
1842
1843	Void setIvMvScalEnabledFlag( Int d, Bool flag ) { m_ivMvScalEnabledFlag[d] = flag; }
1844	Bool getIvMvScalEnabledFlag( Int d ) const { return m_ivMvScalEnabledFlag[d]; }
1845
1846	Void setLog2IvmcSubPbSizeMinus3( Int d, Int val ) { m_log2IvmcSubPbSizeMinus3[d] = val; }
1847	Int getLog2IvmcSubPbSizeMinus3( Int d ) const { return m_log2IvmcSubPbSizeMinus3[d]; }
1848
1849	Void setIvResPredEnabledFlag( Int d, Bool flag ) { m_ivResPredEnabledFlag[d] = flag; }
1850	Bool getIvResPredEnabledFlag( Int d ) const { return m_ivResPredEnabledFlag[d]; }
1851
1852	Void setDepthRefEnabledFlag( Int d, Bool flag ) { m_depthRefEnabledFlag[d] = flag; }
1853	Bool getDepthRefEnabledFlag( Int d ) const { return m_depthRefEnabledFlag[d]; }
1854
1855	Void setVspMcEnabledFlag( Int d, Bool flag ) { m_vspMcEnabledFlag[d] = flag; }
1856	Bool getVspMcEnabledFlag( Int d ) const { return m_vspMcEnabledFlag[d]; }
1857
1858	Void setDbbpEnabledFlag( Int d, Bool flag ) { m_dbbpEnabledFlag[d] = flag; }
1859	Bool getDbbpEnabledFlag( Int d ) const { return m_dbbpEnabledFlag[d]; }
1860
1861	Void setTexMcEnabledFlag( Int d, Bool flag ) { m_texMcEnabledFlag[d] = flag; }
1862	Bool getTexMcEnabledFlag( Int d ) const { return m_texMcEnabledFlag[d]; }
1863
1864	Void setLog2TexmcSubPbSizeMinus3( Int d, Int val ) { m_log2TexmcSubPbSizeMinus3[d] = val; }
1865	Int getLog2TexmcSubPbSizeMinus3( Int d ) const { return m_log2TexmcSubPbSizeMinus3[d]; }
1866
1867	Void setIntraContourEnabledFlag( Int d, Bool flag ) { m_intraContourEnabledFlag[d] = flag; }
1868	Bool getIntraContourEnabledFlag( Int d ) const { return m_intraContourEnabledFlag[d]; }
1869
1870	Void setIntraDcOnlyWedgeEnabledFlag( Int d, Bool flag ) { m_intraDcOnlyWedgeEnabledFlag[d] = flag; }
1871	Bool getIntraDcOnlyWedgeEnabledFlag( Int d ) const { return m_intraDcOnlyWedgeEnabledFlag[d]; }
1872
1873	Void setCqtCuPartPredEnabledFlag( Int d, Bool flag ) { m_cqtCuPartPredEnabledFlag[d] = flag; }
1874	Bool getCqtCuPartPredEnabledFlag( Int d ) const { return m_cqtCuPartPredEnabledFlag[d]; }
1875
1876	Void setInterDcOnlyEnabledFlag( Int d, Bool flag ) { m_interDcOnlyEnabledFlag[d] = flag; }
1877	Bool getInterDcOnlyEnabledFlag( Int d ) const { return m_interDcOnlyEnabledFlag[d]; }
1878
1879	Void setSkipIntraEnabledFlag( Int d, Bool flag ) { m_skipIntraEnabledFlag[d] = flag; }
1880	Bool getSkipIntraEnabledFlag( Int d ) const { return m_skipIntraEnabledFlag[d]; }
1881	private:
1882
1883	Bool m_ivDiMcEnabledFlag [2];
1884	Bool m_ivMvScalEnabledFlag [2];
1885	Int m_log2IvmcSubPbSizeMinus3 [2];
1886	Bool m_ivResPredEnabledFlag [2];
1887	Bool m_depthRefEnabledFlag [2];
1888	Bool m_vspMcEnabledFlag [2];
1889	Bool m_dbbpEnabledFlag [2];
1890	Bool m_texMcEnabledFlag [2];
1891	Int m_log2TexmcSubPbSizeMinus3 [2];
1892	Bool m_intraContourEnabledFlag [2];
1893	Bool m_intraDcOnlyWedgeEnabledFlag[2];
1894	Bool m_cqtCuPartPredEnabledFlag [2];
1895	Bool m_interDcOnlyEnabledFlag [2];
1896	Bool m_skipIntraEnabledFlag [2];
1897	};
1898
1899	#endif
1900
1901
1902	/// SPS class
1903	class TComSPS
1904	{
1905	private:
1906	Int m_SPSId;
1907	Int m_VPSId;
1908	ChromaFormat m_chromaFormatIdc;
1909
1910	UInt m_uiMaxTLayers; // maximum number of temporal layers
1911
1912	// Structure
1913	UInt m_picWidthInLumaSamples;
1914	UInt m_picHeightInLumaSamples;
1915
1916	Int m_log2MinCodingBlockSize;
1917	Int m_log2DiffMaxMinCodingBlockSize;
1918	UInt m_uiMaxCUWidth;
1919	UInt m_uiMaxCUHeight;
1920	UInt m_uiMaxTotalCUDepth; ///< Total CU depth, relative to the smallest possible transform block size.
1921
1922	Window m_conformanceWindow;
1923
1924	TComRPSList m_RPSList;
1925	#if NH_MV
1926	std::vector<TComStRefPicSet> m_stRefPicSets;
1927	#endif
1928	Bool m_bLongTermRefsPresent;
1929	Bool m_SPSTemporalMVPEnabledFlag;
1930	Int m_numReorderPics[MAX_TLAYER];
1931
1932	// Tool list
1933	UInt m_uiQuadtreeTULog2MaxSize;
1934	UInt m_uiQuadtreeTULog2MinSize;
1935	UInt m_uiQuadtreeTUMaxDepthInter;
1936	UInt m_uiQuadtreeTUMaxDepthIntra;
1937	Bool m_usePCM;
1938	UInt m_pcmLog2MaxSize;
1939	UInt m_uiPCMLog2MinSize;
1940	Bool m_useAMP;
1941
1942	// Parameter
1943	BitDepths m_bitDepths;
1944	Int m_qpBDOffset[MAX_NUM_CHANNEL_TYPE];
1945	Int m_pcmBitDepths[MAX_NUM_CHANNEL_TYPE];
1946	Bool m_bPCMFilterDisableFlag;
1947
1948	UInt m_uiBitsForPOC;
1949	UInt m_numLongTermRefPicSPS;
1950	#if NH_MV
1951	Int m_numShortTermRefPicSets;
1952	#endif
1953	UInt m_ltRefPicPocLsbSps[MAX_NUM_LONG_TERM_REF_PICS];
1954	Bool m_usedByCurrPicLtSPSFlag[MAX_NUM_LONG_TERM_REF_PICS];
1955	// Max physical transform size
1956	UInt m_uiMaxTrSize;
1957
1958	Bool m_bUseSAO;
1959
1960	Bool m_bTemporalIdNestingFlag; // temporal_id_nesting_flag
1961
1962	Bool m_scalingListEnabledFlag;
1963	Bool m_scalingListPresentFlag;
1964	TComScalingList m_scalingList;
1965	UInt m_uiMaxDecPicBuffering[MAX_TLAYER];
1966	#if NH_MV
1967	UInt m_uiSpsMaxLatencyIncreasePlus1[MAX_TLAYER];
1968	#else
1969	UInt m_uiMaxLatencyIncreasePlus1[MAX_TLAYER];
1970	#endif
1971
1972	Bool m_useStrongIntraSmoothing;
1973
1974	Bool m_vuiParametersPresentFlag;
1975	TComVUI m_vuiParameters;
1976
1977	TComSPSRExt m_spsRangeExtension;
1978
1979	static const Int m_winUnitX[NUM_CHROMA_FORMAT];
1980	static const Int m_winUnitY[NUM_CHROMA_FORMAT];
1981	TComPTL m_pcPTL;
1982
1983	#if O0043_BEST_EFFORT_DECODING
1984	UInt m_forceDecodeBitDepth; // 0 = do not force the decoder's bit depth, other = force the decoder's bit depth to this value (best effort decoding)
1985	#endif
1986	#if NH_MV
1987	TComVPS* m_pcVPS;
1988	// SPS
1989	Int m_spsMaxSubLayersMinus1;
1990	Int m_spsExtOrMaxSubLayersMinus1;
1991	Bool m_spsExtensionPresentFlag;
1992
1993	Bool m_spsRangeExtensionsFlag;
1994	Bool m_spsMultilayerExtensionFlag;
1995
1996	Bool m_sps3dExtensionFlag;
1997	Int m_spsExtension5bits;
1998
1999	Bool m_spsInferScalingListFlag;
2000	Int m_spsScalingListRefLayerId;
2001	Bool m_updateRepFormatFlag;
2002	Int m_spsRepFormatIdx;
2003	// SPS Extension
2004	Bool m_interViewMvVertConstraintFlag;
2005	#endif
2006	#if NH_3D
2007	TComSps3dExtension m_sps3dExtension;
2008	Int m_aaiCodedScale [2][MAX_NUM_LAYERS];
2009	Int m_aaiCodedOffset[2][MAX_NUM_LAYERS];
2010	#endif
2011	#if NH_MV
2012	Int m_layerId;
2013	TComRepFormat* m_inferredRepFormat;
2014	#endif
2015
2016	public:
2017	TComSPS();
2018	virtual ~TComSPS();
2019	#if O0043_BEST_EFFORT_DECODING
2020	Void setForceDecodeBitDepth(UInt bitDepth) { m_forceDecodeBitDepth = bitDepth; }
2021	UInt getForceDecodeBitDepth() const { return m_forceDecodeBitDepth; }
2022	#endif
2023
2024	Int getVPSId() const { return m_VPSId; }
2025	Void setVPSId(Int i) { m_VPSId = i; }
2026	Int getSPSId() const { return m_SPSId; }
2027	Void setSPSId(Int i) { m_SPSId = i; }
2028	ChromaFormat getChromaFormatIdc () const { return m_chromaFormatIdc; }
2029	Void setChromaFormatIdc (ChromaFormat i) { m_chromaFormatIdc = i; }
2030
2031	static Int getWinUnitX (Int chromaFormatIdc) { assert (chromaFormatIdc >= 0 && chromaFormatIdc < NUM_CHROMA_FORMAT); return m_winUnitX[chromaFormatIdc]; }
2032	static Int getWinUnitY (Int chromaFormatIdc) { assert (chromaFormatIdc >= 0 && chromaFormatIdc < NUM_CHROMA_FORMAT); return m_winUnitY[chromaFormatIdc]; }
2033
2034	// structure
2035	Void setPicWidthInLumaSamples( UInt u ) { m_picWidthInLumaSamples = u; }
2036	UInt getPicWidthInLumaSamples() const { return m_picWidthInLumaSamples; }
2037	Void setPicHeightInLumaSamples( UInt u ) { m_picHeightInLumaSamples = u; }
2038
2039	UInt getPicHeightInLumaSamples() const { return m_picHeightInLumaSamples; }
2040
2041	Window& getConformanceWindow() { return m_conformanceWindow; }
2042	const Window& getConformanceWindow() const { return m_conformanceWindow; }
2043	Void setConformanceWindow(Window& conformanceWindow ) { m_conformanceWindow = conformanceWindow; }
2044
2045	#if NH_MV
2046	UInt getNumLongTermRefPicsSps() const { return m_numLongTermRefPicSPS; }
2047	#endif
2048
2049	UInt getNumLongTermRefPicSPS() const { return m_numLongTermRefPicSPS; }
2050	Void setNumLongTermRefPicSPS(UInt val) { m_numLongTermRefPicSPS = val; }
2051
2052	UInt getLtRefPicPocLsbSps(UInt index) const { assert( index < MAX_NUM_LONG_TERM_REF_PICS ); return m_ltRefPicPocLsbSps[index]; }
2053	Void setLtRefPicPocLsbSps(UInt index, UInt val) { assert( index < MAX_NUM_LONG_TERM_REF_PICS ); m_ltRefPicPocLsbSps[index] = val; }
2054
2055	Bool getUsedByCurrPicLtSPSFlag(Int i) const { assert( i < MAX_NUM_LONG_TERM_REF_PICS ); return m_usedByCurrPicLtSPSFlag[i]; }
2056	Void setUsedByCurrPicLtSPSFlag(Int i, Bool x) { assert( i < MAX_NUM_LONG_TERM_REF_PICS ); m_usedByCurrPicLtSPSFlag[i] = x; }
2057
2058	Int getLog2MinCodingBlockSize() const { return m_log2MinCodingBlockSize; }
2059	Void setLog2MinCodingBlockSize(Int val) { m_log2MinCodingBlockSize = val; }
2060	Int getLog2DiffMaxMinCodingBlockSize() const { return m_log2DiffMaxMinCodingBlockSize; }
2061	Void setLog2DiffMaxMinCodingBlockSize(Int val) { m_log2DiffMaxMinCodingBlockSize = val; }
2062
2063	Void setMaxCUWidth( UInt u ) { m_uiMaxCUWidth = u; }
2064	UInt getMaxCUWidth() const { return m_uiMaxCUWidth; }
2065	Void setMaxCUHeight( UInt u ) { m_uiMaxCUHeight = u; }
2066	UInt getMaxCUHeight() const { return m_uiMaxCUHeight; }
2067	Void setMaxTotalCUDepth( UInt u ) { m_uiMaxTotalCUDepth = u; }
2068	UInt getMaxTotalCUDepth() const { return m_uiMaxTotalCUDepth; }
2069	Void setUsePCM( Bool b ) { m_usePCM = b; }
2070	Bool getUsePCM() const { return m_usePCM; }
2071	Void setPCMLog2MaxSize( UInt u ) { m_pcmLog2MaxSize = u; }
2072	UInt getPCMLog2MaxSize() const { return m_pcmLog2MaxSize; }
2073	Void setPCMLog2MinSize( UInt u ) { m_uiPCMLog2MinSize = u; }
2074	UInt getPCMLog2MinSize() const { return m_uiPCMLog2MinSize; }
2075	Void setBitsForPOC( UInt u ) { m_uiBitsForPOC = u; }
2076	UInt getBitsForPOC() const { return m_uiBitsForPOC; }
2077	#if NH_MV
2078	UInt getMaxPicOrderCntLsb() const { return (1 << ( getLog2MaxPicOrderCntLsbMinus4() + 4) ); }
2079	Int getLog2MaxPicOrderCntLsbMinus4() const { return (getBitsForPOC() - 4); }
2080	#endif
2081	Bool getUseAMP() const { return m_useAMP; }
2082	Void setUseAMP( Bool b ) { m_useAMP = b; }
2083	Void setQuadtreeTULog2MaxSize( UInt u ) { m_uiQuadtreeTULog2MaxSize = u; }
2084	UInt getQuadtreeTULog2MaxSize() const { return m_uiQuadtreeTULog2MaxSize; }
2085	Void setQuadtreeTULog2MinSize( UInt u ) { m_uiQuadtreeTULog2MinSize = u; }
2086	UInt getQuadtreeTULog2MinSize() const { return m_uiQuadtreeTULog2MinSize; }
2087	Void setQuadtreeTUMaxDepthInter( UInt u ) { m_uiQuadtreeTUMaxDepthInter = u; }
2088	Void setQuadtreeTUMaxDepthIntra( UInt u ) { m_uiQuadtreeTUMaxDepthIntra = u; }
2089	UInt getQuadtreeTUMaxDepthInter() const { return m_uiQuadtreeTUMaxDepthInter; }
2090	UInt getQuadtreeTUMaxDepthIntra() const { return m_uiQuadtreeTUMaxDepthIntra; }
2091	Void setNumReorderPics(Int i, UInt tlayer) { m_numReorderPics[tlayer] = i; }
2092	Int getNumReorderPics(UInt tlayer) const { return m_numReorderPics[tlayer]; }
2093	Void createRPSList( Int numRPS );
2094	const TComRPSList* getRPSList() const { return &m_RPSList; }
2095	TComRPSList* getRPSList() { return &m_RPSList; }
2096	#if NH_MV
2097	Void initStRefPicSets( ) { m_stRefPicSets.resize( getNumShortTermRefPicSets() ); }
2098	TComStRefPicSet* getStRefPicSet( Int i ) { return &(m_stRefPicSets[i]); }
2099	const TComStRefPicSet* getStRefPicSet( Int i ) const { return &(m_stRefPicSets[i]); }
2100	Bool getLongTermRefPicsPresentFlag() const { return m_bLongTermRefsPresent; }
2101	Void setLongTermRefPicsPresentFlag(Bool b) { m_bLongTermRefsPresent=b; }
2102	#else
2103	Bool getLongTermRefsPresent() const { return m_bLongTermRefsPresent; }
2104	Void setLongTermRefsPresent(Bool b) { m_bLongTermRefsPresent=b; }
2105	#endif
2106	Bool getSPSTemporalMVPEnabledFlag() const { return m_SPSTemporalMVPEnabledFlag; }
2107	Void setSPSTemporalMVPEnabledFlag(Bool b) { m_SPSTemporalMVPEnabledFlag=b; }
2108	#if NH_MV
2109	Bool getSpsTemporalMvpEnabledFlag() const { return m_SPSTemporalMVPEnabledFlag; }
2110	#endif
2111	// physical transform
2112	Void setMaxTrSize( UInt u ) { m_uiMaxTrSize = u; }
2113	UInt getMaxTrSize() const { return m_uiMaxTrSize; }
2114
2115	// Bit-depth
2116	Int getBitDepth(ChannelType type) const { return m_bitDepths.recon[type]; }
2117
2118	Void setBitDepth(ChannelType type, Int u ) { m_bitDepths.recon[type] = u; }
2119	#if O0043_BEST_EFFORT_DECODING
2120	Int getStreamBitDepth(ChannelType type) const { return m_bitDepths.stream[type]; }
2121	Void setStreamBitDepth(ChannelType type, Int u ) { m_bitDepths.stream[type] = u; }
2122	#endif
2123	const BitDepths& getBitDepths() const { return m_bitDepths; }
2124	Int getMaxLog2TrDynamicRange(ChannelType channelType) const { return getSpsRangeExtension().getExtendedPrecisionProcessingFlag() ? std::max<Int>(15, Int(m_bitDepths.recon[channelType] + 6)) : 15; }
2125
2126	Int getDifferentialLumaChromaBitDepth() const { return Int(m_bitDepths.recon[CHANNEL_TYPE_LUMA]) - Int(m_bitDepths.recon[CHANNEL_TYPE_CHROMA]); }
2127	Int getQpBDOffset(ChannelType type) const { return m_qpBDOffset[type]; }
2128	Void setQpBDOffset(ChannelType type, Int i) { m_qpBDOffset[type] = i; }
2129
2130	Void setUseSAO(Bool bVal) { m_bUseSAO = bVal; }
2131	Bool getUseSAO() const { return m_bUseSAO; }
2132
2133	UInt getMaxTLayers() const { return m_uiMaxTLayers; }
2134	Void setMaxTLayers( UInt uiMaxTLayers ) { assert( uiMaxTLayers <= MAX_TLAYER ); m_uiMaxTLayers = uiMaxTLayers; }
2135
2136	Bool getTemporalIdNestingFlag() const { return m_bTemporalIdNestingFlag; }
2137	Void setTemporalIdNestingFlag( Bool bValue ) { m_bTemporalIdNestingFlag = bValue; }
2138	UInt getPCMBitDepth(ChannelType type) const { return m_pcmBitDepths[type]; }
2139	Void setPCMBitDepth(ChannelType type, UInt u) { m_pcmBitDepths[type] = u; }
2140	Void setPCMFilterDisableFlag( Bool bValue ) { m_bPCMFilterDisableFlag = bValue; }
2141	Bool getPCMFilterDisableFlag() const { return m_bPCMFilterDisableFlag; }
2142	#if NH_MV
2143	Void setNumShortTermRefPicSets( Int val ) { m_numShortTermRefPicSets = val; }
2144	Int getNumShortTermRefPicSets( )const { return m_numShortTermRefPicSets; }
2145	#endif
2146	Bool getScalingListFlag() const { return m_scalingListEnabledFlag; }
2147	Void setScalingListFlag( Bool b ) { m_scalingListEnabledFlag = b; }
2148	Bool getScalingListPresentFlag() const { return m_scalingListPresentFlag; }
2149	Void setScalingListPresentFlag( Bool b ) { m_scalingListPresentFlag = b; }
2150	TComScalingList& getScalingList() { return m_scalingList; }
2151	const TComScalingList& getScalingList() const { return m_scalingList; }
2152	UInt getMaxDecPicBuffering(UInt tlayer) const { return m_uiMaxDecPicBuffering[tlayer]; }
2153	Void setMaxDecPicBuffering( UInt ui, UInt tlayer ) { assert(tlayer < MAX_TLAYER); m_uiMaxDecPicBuffering[tlayer] = ui; }
2154	#if NH_MV
2155	UInt getSpsMaxDecPicBufferingMinus1(UInt tlayer) const { return m_uiMaxDecPicBuffering[tlayer] -1 ; }
2156	UInt getSpsMaxLatencyIncreasePlus1(UInt tlayer) const { return m_uiSpsMaxLatencyIncreasePlus1[tlayer]; }
2157	Void setSpsMaxLatencyIncreasePlus1( UInt ui , UInt tlayer) { m_uiSpsMaxLatencyIncreasePlus1[tlayer] = ui; }
2158	Int getSpsMaxLatencyPictures( Int i ) const { return ( getSpsMaxNumReorderPics(i) + getSpsMaxLatencyIncreasePlus1(i)-1); }
2159	#else
2160	UInt getMaxLatencyIncreasePlus1(UInt tlayer) const { return m_uiMaxLatencyIncreasePlus1[tlayer]; }
2161	Void setMaxLatencyIncreasePlus1( UInt ui , UInt tlayer) { m_uiMaxLatencyIncreasePlus1[tlayer] = ui; }
2162	#endif
2163
2164	#if NH_MV
2165	Int getSpsMaxNumReorderPics(Int i ) const { return getNumReorderPics( i ); }
2166	#endif
2167
2168	Void setUseStrongIntraSmoothing(Bool bVal) { m_useStrongIntraSmoothing = bVal; }
2169	Bool getUseStrongIntraSmoothing() const { return m_useStrongIntraSmoothing; }
2170
2171	Bool getVuiParametersPresentFlag() const { return m_vuiParametersPresentFlag; }
2172	Void setVuiParametersPresentFlag(Bool b) { m_vuiParametersPresentFlag = b; }
2173	TComVUI* getVuiParameters() { return &m_vuiParameters; }
2174	const TComVUI* getVuiParameters() const { return &m_vuiParameters; }
2175	const TComPTL* getPTL() const { return &m_pcPTL; }
2176	TComPTL* getPTL() { return &m_pcPTL; }
2177
2178	const TComSPSRExt& getSpsRangeExtension() const { return m_spsRangeExtension; }
2179	TComSPSRExt& getSpsRangeExtension() { return m_spsRangeExtension; }
2180
2181	#if NH_MV
2182
2183	UInt getSpsMaxSubLayersMinus1() const { return ( m_uiMaxTLayers - 1); }
2184	Void setSpsMaxSubLayersMinus1( UInt val ) { setMaxTLayers( val + 1 ); }
2185
2186	Void setSpsExtOrMaxSubLayersMinus1( Int val ) { m_spsExtOrMaxSubLayersMinus1 = val; }
2187	Int getSpsExtOrMaxSubLayersMinus1( ) const { return m_spsExtOrMaxSubLayersMinus1; }
2188	Void inferSpsMaxSubLayersMinus1( Bool atPsActivation, TComVPS* vps );
2189
2190	Bool getMultiLayerExtSpsFlag() const { return ( getLayerId() != 0 && getSpsExtOrMaxSubLayersMinus1() == 7 ); }
2191	Void inferSpsMaxDecPicBufferingMinus1( TComVPS* vps, Int targetOptLayerSetIdx, Int currLayerId, Bool encoder );
2192
2193	Void setSpsExtensionPresentFlag( Bool flag ) { m_spsExtensionPresentFlag = flag; }
2194	Bool getSpsExtensionPresentFlag( ) const { return m_spsExtensionPresentFlag; }
2195
2196	Void setSpsRangeExtensionsFlag( Bool flag ) { m_spsRangeExtensionsFlag = flag; }
2197	Bool getSpsRangeExtensionsFlag( ) const { return m_spsRangeExtensionsFlag; }
2198
2199	Void setSpsMultilayerExtensionFlag( Bool flag ) { m_spsMultilayerExtensionFlag = flag; }
2200	Bool getSpsMultilayerExtensionFlag( ) const { return m_spsMultilayerExtensionFlag; }
2201
2202	Void setSps3dExtensionFlag( Bool flag ) { m_sps3dExtensionFlag = flag; }
2203	Bool getSps3dExtensionFlag( ) const { return m_sps3dExtensionFlag; }
2204
2205	Void setSpsExtension5bits( Int val ) { m_spsExtension5bits = val; }
2206	Int getSpsExtension5bits( ) const { return m_spsExtension5bits; }
2207
2208	Void setVPS ( TComVPS* pcVPS ) { m_pcVPS = pcVPS; }
2209	TComVPS* getVPS () const { return m_pcVPS; }
2210
2211	Void setSpsInferScalingListFlag( Bool flag ) { m_spsInferScalingListFlag = flag; }
2212	Bool getSpsInferScalingListFlag( ) const { return m_spsInferScalingListFlag; }
2213
2214	Void setSpsScalingListRefLayerId( Int val ) { m_spsScalingListRefLayerId = val; }
2215	Int getSpsScalingListRefLayerId( ) const { return m_spsScalingListRefLayerId; }
2216
2217	Void setUpdateRepFormatFlag( Bool flag ) { m_updateRepFormatFlag = flag; }
2218	Bool getUpdateRepFormatFlag( ) const { return m_updateRepFormatFlag; }
2219
2220	Void setSpsRepFormatIdx( Int val ) { m_spsRepFormatIdx = val; }
2221	Int getSpsRepFormatIdx( ) const { return m_spsRepFormatIdx; }
2222
2223	// SPS Extension
2224	Void setInterViewMvVertConstraintFlag(Bool val) { m_interViewMvVertConstraintFlag = val; }
2225	Bool getInterViewMvVertConstraintFlag() const { return m_interViewMvVertConstraintFlag; }
2226
2227	#if NH_3D
2228	Void setSps3dExtension ( TComSps3dExtension& sps3dExtension ) { m_sps3dExtension = sps3dExtension; }
2229	const TComSps3dExtension* getSps3dExtension ( ) const { return &m_sps3dExtension; }
2230	#endif
2231
2232	// Inference
2233
2234	Void inferRepFormat ( TComVPS* vps, Int layerIdCurr, Bool alreadySet );
2235	Void inferScalingList( const TComSPS* spsSrc );
2236
2237	// others
2238	Void checkRpsMaxNumPics( const TComVPS* vps, Int currLayerId ) const;
2239
2240	Int getLayerId () const { return m_layerId; }
2241	Void setLayerId ( Int val ) { m_layerId = val; }
2242
2243	#endif
2244
2245	};
2246
2247
2248	/// Reference Picture Lists class
2249
2250	class TComRefPicListModification
2251	{
2252	private:
2253	Bool m_refPicListModificationFlagL0;
2254	Bool m_refPicListModificationFlagL1;
2255	UInt m_RefPicSetIdxL0[REF_PIC_LIST_NUM_IDX];
2256	UInt m_RefPicSetIdxL1[REF_PIC_LIST_NUM_IDX];
2257
2258	public:
2259	TComRefPicListModification();
2260	virtual ~TComRefPicListModification();
2261
2262
2263	Bool getRefPicListModificationFlagL0() const { return m_refPicListModificationFlagL0; }
2264	Void setRefPicListModificationFlagL0(Bool flag) { m_refPicListModificationFlagL0 = flag; }
2265	Bool getRefPicListModificationFlagL1() const { return m_refPicListModificationFlagL1; }
2266	Void setRefPicListModificationFlagL1(Bool flag) { m_refPicListModificationFlagL1 = flag; }
2267	UInt getRefPicSetIdxL0(UInt idx) const { assert(idx<REF_PIC_LIST_NUM_IDX); return m_RefPicSetIdxL0[idx]; }
2268	Void setRefPicSetIdxL0(UInt idx, UInt refPicSetIdx) { assert(idx<REF_PIC_LIST_NUM_IDX); m_RefPicSetIdxL0[idx] = refPicSetIdx; }
2269	UInt getRefPicSetIdxL1(UInt idx) const { assert(idx<REF_PIC_LIST_NUM_IDX); return m_RefPicSetIdxL1[idx]; }
2270	Void setRefPicSetIdxL1(UInt idx, UInt refPicSetIdx) { assert(idx<REF_PIC_LIST_NUM_IDX); m_RefPicSetIdxL1[idx] = refPicSetIdx; }
2271	#if NH_MV
2272
2273	Void setRefPicSetIdxL(UInt li, UInt idx, UInt refPicSetIdx) {( li==0 ? m_RefPicSetIdxL0[idx] : m_RefPicSetIdxL1[idx] ) = refPicSetIdx; }
2274	UInt getRefPicSetIdxL(UInt li, UInt idx ) { return ( li == 0 ) ? m_RefPicSetIdxL0[idx] : m_RefPicSetIdxL1[idx] ; }
2275	Void setRefPicListModificationFlagL(UInt li, Bool flag) { ( li==0 ? m_refPicListModificationFlagL0 : m_refPicListModificationFlagL1 ) = flag; }
2276	Bool getRefPicListModificationFlagL(UInt li ) { return ( li== 0) ? m_refPicListModificationFlagL0 : m_refPicListModificationFlagL1; }
2277
2278	Int getListEntryL0( Int i) const { assert(i<REF_PIC_LIST_NUM_IDX); return m_RefPicSetIdxL0[i]; }
2279	Int getListEntryL1( Int i) const { assert(i<REF_PIC_LIST_NUM_IDX); return m_RefPicSetIdxL1[i]; }
2280
2281	Int getListEntryLXLen( Int numPicTotalCur ) const { return gCeilLog2( numPicTotalCur ); }
2282
2283	Void setListEntryL0( Int i, Int val ) { m_RefPicSetIdxL0[i] = val; }
2284	Void setListEntryL1( Int i, Int val ) { m_RefPicSetIdxL1[i] = val; }
2285	#endif
2286	};
2287
2288
2289	/// PPS RExt class
2290	class TComPPSRExt // Names aligned to text specification
2291	{
2292	private:
2293	Int m_log2MaxTransformSkipBlockSize;
2294	Bool m_crossComponentPredictionEnabledFlag;
2295
2296	// Chroma QP Adjustments
2297	Int m_diffCuChromaQpOffsetDepth;
2298	Int m_chromaQpOffsetListLen; // size (excludes the null entry used in the following array).
2299	ChromaQpAdj m_ChromaQpAdjTableIncludingNullEntry[1+MAX_QP_OFFSET_LIST_SIZE]; //!< Array includes entry [0] for the null offset used when cu_chroma_qp_offset_flag=0, and entries [cu_chroma_qp_offset_idx+1...] otherwise
2300
2301	UInt m_log2SaoOffsetScale[MAX_NUM_CHANNEL_TYPE];
2302
2303	public:
2304	TComPPSRExt();
2305
2306	Bool settingsDifferFromDefaults(const bool bTransformSkipEnabledFlag) const
2307	{
2308	return (bTransformSkipEnabledFlag && (getLog2MaxTransformSkipBlockSize() !=2))
2309	\|\| (getCrossComponentPredictionEnabledFlag() )
2310	\|\| (getChromaQpOffsetListEnabledFlag() )
2311	\|\| (getLog2SaoOffsetScale(CHANNEL_TYPE_LUMA) !=0 )
2312	\|\| (getLog2SaoOffsetScale(CHANNEL_TYPE_CHROMA) !=0 );
2313	}
2314
2315	UInt getLog2MaxTransformSkipBlockSize() const { return m_log2MaxTransformSkipBlockSize; }
2316	Void setLog2MaxTransformSkipBlockSize( UInt u ) { m_log2MaxTransformSkipBlockSize = u; }
2317
2318	Bool getCrossComponentPredictionEnabledFlag() const { return m_crossComponentPredictionEnabledFlag; }
2319	Void setCrossComponentPredictionEnabledFlag(Bool value) { m_crossComponentPredictionEnabledFlag = value; }
2320
2321	Void clearChromaQpOffsetList() { m_chromaQpOffsetListLen = 0; }
2322
2323	UInt getDiffCuChromaQpOffsetDepth () const { return m_diffCuChromaQpOffsetDepth; }
2324	Void setDiffCuChromaQpOffsetDepth ( UInt u ) { m_diffCuChromaQpOffsetDepth = u; }
2325
2326	Bool getChromaQpOffsetListEnabledFlag() const { return getChromaQpOffsetListLen()>0; }
2327	Int getChromaQpOffsetListLen() const { return m_chromaQpOffsetListLen; }
2328
2329	const ChromaQpAdj& getChromaQpOffsetListEntry( Int cuChromaQpOffsetIdxPlus1 ) const
2330	{
2331	assert(cuChromaQpOffsetIdxPlus1 < m_chromaQpOffsetListLen+1);
2332	return m_ChromaQpAdjTableIncludingNullEntry[cuChromaQpOffsetIdxPlus1]; // Array includes entry [0] for the null offset used when cu_chroma_qp_offset_flag=0, and entries [cu_chroma_qp_offset_idx+1...] otherwise
2333	}
2334
2335	Void setChromaQpOffsetListEntry( Int cuChromaQpOffsetIdxPlus1, Int cbOffset, Int crOffset )
2336	{
2337	assert (cuChromaQpOffsetIdxPlus1 != 0 && cuChromaQpOffsetIdxPlus1 <= MAX_QP_OFFSET_LIST_SIZE);
2338	m_ChromaQpAdjTableIncludingNullEntry[cuChromaQpOffsetIdxPlus1].u.comp.CbOffset = cbOffset; // Array includes entry [0] for the null offset used when cu_chroma_qp_offset_flag=0, and entries [cu_chroma_qp_offset_idx+1...] otherwise
2339	m_ChromaQpAdjTableIncludingNullEntry[cuChromaQpOffsetIdxPlus1].u.comp.CrOffset = crOffset;
2340	m_chromaQpOffsetListLen = max(m_chromaQpOffsetListLen, cuChromaQpOffsetIdxPlus1);
2341	}
2342
2343	// Now: getPpsRangeExtension().getLog2SaoOffsetScale and getPpsRangeExtension().setLog2SaoOffsetScale
2344	UInt getLog2SaoOffsetScale(ChannelType type) const { return m_log2SaoOffsetScale[type]; }
2345	Void setLog2SaoOffsetScale(ChannelType type, UInt uiBitShift) { m_log2SaoOffsetScale[type] = uiBitShift; }
2346
2347	};
2348
2349
2350	/// PPS class
2351	class TComPPS
2352	{
2353	private:
2354	Int m_PPSId; // pic_parameter_set_id
2355	Int m_SPSId; // seq_parameter_set_id
2356	Int m_picInitQPMinus26;
2357	Bool m_useDQP;
2358	Bool m_bConstrainedIntraPred; // constrained_intra_pred_flag
2359	Bool m_bSliceChromaQpFlag; // slicelevel_chroma_qp_flag
2360
2361	// access channel
2362	UInt m_uiMaxCuDQPDepth;
2363
2364	Int m_chromaCbQpOffset;
2365	Int m_chromaCrQpOffset;
2366
2367	UInt m_numRefIdxL0DefaultActive;
2368	UInt m_numRefIdxL1DefaultActive;
2369
2370	Bool m_bUseWeightPred; //!< Use of Weighting Prediction (P_SLICE)
2371	Bool m_useWeightedBiPred; //!< Use of Weighting Bi-Prediction (B_SLICE)
2372	Bool m_OutputFlagPresentFlag; //!< Indicates the presence of output_flag in slice header
2373	Bool m_TransquantBypassEnabledFlag; //!< Indicates presence of cu_transquant_bypass_flag in CUs.
2374	Bool m_useTransformSkip;
2375	Bool m_dependentSliceSegmentsEnabledFlag; //!< Indicates the presence of dependent slices
2376	Bool m_tilesEnabledFlag; //!< Indicates the presence of tiles
2377	Bool m_entropyCodingSyncEnabledFlag; //!< Indicates the presence of wavefronts
2378
2379	Bool m_loopFilterAcrossTilesEnabledFlag;
2380	Bool m_uniformSpacingFlag;
2381	Int m_numTileColumnsMinus1;
2382	Int m_numTileRowsMinus1;
2383	std::vector<Int> m_tileColumnWidth;
2384	std::vector<Int> m_tileRowHeight;
2385
2386	Bool m_signDataHidingEnabledFlag;
2387
2388	Bool m_cabacInitPresentFlag;
2389
2390	Bool m_sliceHeaderExtensionPresentFlag;
2391	Bool m_loopFilterAcrossSlicesEnabledFlag;
2392	Bool m_deblockingFilterControlPresentFlag;
2393	Bool m_deblockingFilterOverrideEnabledFlag;
2394	Bool m_ppsDeblockingFilterDisabledFlag;
2395	Int m_deblockingFilterBetaOffsetDiv2; //< beta offset for deblocking filter
2396	Int m_deblockingFilterTcOffsetDiv2; //< tc offset for deblocking filter
2397	Bool m_scalingListPresentFlag;
2398	TComScalingList m_scalingList; //!< ScalingList class
2399	Bool m_listsModificationPresentFlag;
2400	UInt m_log2ParallelMergeLevelMinus2;
2401	Int m_numExtraSliceHeaderBits;
2402
2403	TComPPSRExt m_ppsRangeExtension;
2404
2405	#if NH_MV
2406	Int m_layerId;
2407	Bool m_ppsInferScalingListFlag;
2408	Int m_ppsScalingListRefLayerId;
2409
2410	Bool m_ppsRangeExtensionsFlag;
2411	Bool m_ppsMultilayerExtensionFlag;
2412	Bool m_pps3dExtensionFlag;
2413	Int m_ppsExtension5bits;
2414
2415	Bool m_pocResetInfoPresentFlag;
2416	#endif
2417
2418	#if NH_3D
2419	TComDLT m_cDLT;
2420	#endif
2421
2422	public:
2423	TComPPS();
2424	virtual ~TComPPS();
2425
2426	Int getPPSId() const { return m_PPSId; }
2427	Void setPPSId(Int i) { m_PPSId = i; }
2428	Int getSPSId() const { return m_SPSId; }
2429	Void setSPSId(Int i) { m_SPSId = i; }
2430
2431	Int getPicInitQPMinus26() const { return m_picInitQPMinus26; }
2432	Void setPicInitQPMinus26( Int i ) { m_picInitQPMinus26 = i; }
2433	Bool getUseDQP() const { return m_useDQP; }
2434	Void setUseDQP( Bool b ) { m_useDQP = b; }
2435	Bool getConstrainedIntraPred() const { return m_bConstrainedIntraPred; }
2436	Void setConstrainedIntraPred( Bool b ) { m_bConstrainedIntraPred = b; }
2437	Bool getSliceChromaQpFlag() const { return m_bSliceChromaQpFlag; }
2438	Void setSliceChromaQpFlag( Bool b ) { m_bSliceChromaQpFlag = b; }
2439
2440	Void setMaxCuDQPDepth( UInt u ) { m_uiMaxCuDQPDepth = u; }
2441	UInt getMaxCuDQPDepth() const { return m_uiMaxCuDQPDepth; }
2442
2443	#if NH_3D
2444	Void setDLT( TComDLT cDLT ) { m_cDLT = cDLT; }
2445	const TComDLT* getDLT() const { return &m_cDLT; }
2446	TComDLT* getDLT() { return &m_cDLT; }
2447	#endif
2448
2449
2450	Void setQpOffset(ComponentID compID, Int i )
2451	{
2452	if (compID==COMPONENT_Cb)
2453	{
2454	m_chromaCbQpOffset = i;
2455	}
2456	else if (compID==COMPONENT_Cr)
2457	{
2458	m_chromaCrQpOffset = i;
2459	}
2460	else
2461	{
2462	assert(0);
2463	}
2464	}
2465	Int getQpOffset(ComponentID compID) const
2466	{
2467	return (compID==COMPONENT_Y) ? 0 : (compID==COMPONENT_Cb ? m_chromaCbQpOffset : m_chromaCrQpOffset );
2468	}
2469
2470	Void setNumRefIdxL0DefaultActive(UInt ui) { m_numRefIdxL0DefaultActive=ui; }
2471	UInt getNumRefIdxL0DefaultActive() const { return m_numRefIdxL0DefaultActive; }
2472	Void setNumRefIdxL1DefaultActive(UInt ui) { m_numRefIdxL1DefaultActive=ui; }
2473	UInt getNumRefIdxL1DefaultActive() const { return m_numRefIdxL1DefaultActive; }
2474
2475	Bool getUseWP() const { return m_bUseWeightPred; }
2476	Bool getWPBiPred() const { return m_useWeightedBiPred; }
2477	Void setUseWP( Bool b ) { m_bUseWeightPred = b; }
2478	Void setWPBiPred( Bool b ) { m_useWeightedBiPred = b; }
2479
2480	Void setOutputFlagPresentFlag( Bool b ) { m_OutputFlagPresentFlag = b; }
2481	Bool getOutputFlagPresentFlag() const { return m_OutputFlagPresentFlag; }
2482	Void setTransquantBypassEnabledFlag( Bool b ) { m_TransquantBypassEnabledFlag = b; }
2483	Bool getTransquantBypassEnabledFlag() const { return m_TransquantBypassEnabledFlag; }
2484
2485	Bool getUseTransformSkip() const { return m_useTransformSkip; }
2486	Void setUseTransformSkip( Bool b ) { m_useTransformSkip = b; }
2487
2488	Void setLoopFilterAcrossTilesEnabledFlag(Bool b) { m_loopFilterAcrossTilesEnabledFlag = b; }
2489	Bool getLoopFilterAcrossTilesEnabledFlag() const { return m_loopFilterAcrossTilesEnabledFlag; }
2490	Bool getDependentSliceSegmentsEnabledFlag() const { return m_dependentSliceSegmentsEnabledFlag; }
2491	Void setDependentSliceSegmentsEnabledFlag(Bool val) { m_dependentSliceSegmentsEnabledFlag = val; }
2492	Bool getEntropyCodingSyncEnabledFlag() const { return m_entropyCodingSyncEnabledFlag; }
2493	Void setEntropyCodingSyncEnabledFlag(Bool val) { m_entropyCodingSyncEnabledFlag = val; }
2494
2495	Void setTilesEnabledFlag(Bool val) { m_tilesEnabledFlag = val; }
2496	Bool getTilesEnabledFlag() const { return m_tilesEnabledFlag; }
2497	Void setTileUniformSpacingFlag(Bool b) { m_uniformSpacingFlag = b; }
2498	Bool getTileUniformSpacingFlag() const { return m_uniformSpacingFlag; }
2499	Void setNumTileColumnsMinus1(Int i) { m_numTileColumnsMinus1 = i; }
2500	Int getNumTileColumnsMinus1() const { return m_numTileColumnsMinus1; }
2501	Void setTileColumnWidth(const std::vector<Int>& columnWidth ) { m_tileColumnWidth = columnWidth; }
2502	UInt getTileColumnWidth(UInt columnIdx) const { return m_tileColumnWidth[columnIdx]; }
2503	Void setNumTileRowsMinus1(Int i) { m_numTileRowsMinus1 = i; }
2504	Int getNumTileRowsMinus1() const { return m_numTileRowsMinus1; }
2505	Void setTileRowHeight(const std::vector<Int>& rowHeight) { m_tileRowHeight = rowHeight; }
2506	UInt getTileRowHeight(UInt rowIdx) const { return m_tileRowHeight[rowIdx]; }
2507
2508	Void setSignDataHidingEnabledFlag( Bool b ) { m_signDataHidingEnabledFlag = b; }
2509	Bool getSignDataHidingEnabledFlag() const { return m_signDataHidingEnabledFlag; }
2510
2511	Void setCabacInitPresentFlag( Bool flag ) { m_cabacInitPresentFlag = flag; }
2512	Bool getCabacInitPresentFlag() const { return m_cabacInitPresentFlag; }
2513	Void setDeblockingFilterControlPresentFlag( Bool val ) { m_deblockingFilterControlPresentFlag = val; }
2514	Bool getDeblockingFilterControlPresentFlag() const { return m_deblockingFilterControlPresentFlag; }
2515	Void setDeblockingFilterOverrideEnabledFlag( Bool val ) { m_deblockingFilterOverrideEnabledFlag = val; }
2516	Bool getDeblockingFilterOverrideEnabledFlag() const { return m_deblockingFilterOverrideEnabledFlag; }
2517	Void setPPSDeblockingFilterDisabledFlag(Bool val) { m_ppsDeblockingFilterDisabledFlag = val; } //!< set offset for deblocking filter disabled
2518	Bool getPPSDeblockingFilterDisabledFlag() const { return m_ppsDeblockingFilterDisabledFlag; } //!< get offset for deblocking filter disabled
2519	Void setDeblockingFilterBetaOffsetDiv2(Int val) { m_deblockingFilterBetaOffsetDiv2 = val; } //!< set beta offset for deblocking filter
2520	Int getDeblockingFilterBetaOffsetDiv2() const { return m_deblockingFilterBetaOffsetDiv2; } //!< get beta offset for deblocking filter
2521	Void setDeblockingFilterTcOffsetDiv2(Int val) { m_deblockingFilterTcOffsetDiv2 = val; } //!< set tc offset for deblocking filter
2522	Int getDeblockingFilterTcOffsetDiv2() const { return m_deblockingFilterTcOffsetDiv2; } //!< get tc offset for deblocking filter
2523	Bool getScalingListPresentFlag() const { return m_scalingListPresentFlag; }
2524	Void setScalingListPresentFlag( Bool b ) { m_scalingListPresentFlag = b; }
2525	TComScalingList& getScalingList() { return m_scalingList; }
2526	const TComScalingList& getScalingList() const { return m_scalingList; }
2527	Bool getListsModificationPresentFlag() const { return m_listsModificationPresentFlag; }
2528	Void setListsModificationPresentFlag( Bool b ) { m_listsModificationPresentFlag = b; }
2529	UInt getLog2ParallelMergeLevelMinus2() const { return m_log2ParallelMergeLevelMinus2; }
2530	Void setLog2ParallelMergeLevelMinus2(UInt mrgLevel) { m_log2ParallelMergeLevelMinus2 = mrgLevel; }
2531	Int getNumExtraSliceHeaderBits() const { return m_numExtraSliceHeaderBits; }
2532	Void setNumExtraSliceHeaderBits(Int i) { m_numExtraSliceHeaderBits = i; }
2533	Void setLoopFilterAcrossSlicesEnabledFlag( Bool bValue ) { m_loopFilterAcrossSlicesEnabledFlag = bValue; }
2534	Bool getLoopFilterAcrossSlicesEnabledFlag() const { return m_loopFilterAcrossSlicesEnabledFlag; }
2535	Bool getSliceHeaderExtensionPresentFlag() const { return m_sliceHeaderExtensionPresentFlag; }
2536	Void setSliceHeaderExtensionPresentFlag(Bool val) { m_sliceHeaderExtensionPresentFlag = val; }
2537
2538
2539	const TComPPSRExt& getPpsRangeExtension() const { return m_ppsRangeExtension; }
2540	TComPPSRExt& getPpsRangeExtension() { return m_ppsRangeExtension; }
2541	#if NH_MV
2542	Void setLayerId( Int val ) { m_layerId = val; }
2543	Int getLayerId( ) const { return m_layerId; }
2544
2545	Void setPpsInferScalingListFlag( Bool flag ) { m_ppsInferScalingListFlag = flag; }
2546	Bool getPpsInferScalingListFlag( ) const { return m_ppsInferScalingListFlag; }
2547
2548	Void setPpsScalingListRefLayerId( Int val ) { m_ppsScalingListRefLayerId = val; }
2549	Int getPpsScalingListRefLayerId( ) const { return m_ppsScalingListRefLayerId; }
2550
2551	Void setPpsRangeExtensionsFlag( Bool flag ) { m_ppsRangeExtensionsFlag = flag; }
2552	Bool getPpsRangeExtensionsFlag( ) const { return m_ppsRangeExtensionsFlag; }
2553
2554	Void setPpsMultilayerExtensionFlag( Bool flag ) { m_ppsMultilayerExtensionFlag = flag; }
2555	Bool getPpsMultilayerExtensionFlag( ) const { return m_ppsMultilayerExtensionFlag; }
2556
2557	Void setPps3dExtensionFlag( Bool flag ) { m_pps3dExtensionFlag = flag; }
2558	Bool getPps3dExtensionFlag( ) const { return m_pps3dExtensionFlag; }
2559
2560	Void setPpsExtension5bits( Int val ) { m_ppsExtension5bits = val; }
2561	Int getPpsExtension5bits( ) const { return m_ppsExtension5bits; }
2562
2563	Void setPocResetInfoPresentFlag( Bool flag ) { m_pocResetInfoPresentFlag = flag; }
2564	Bool getPocResetInfoPresentFlag( ) const { return m_pocResetInfoPresentFlag; }
2565	#endif
2566	};
2567	struct WPScalingParam
2568	{
2569	// Explicit weighted prediction parameters parsed in slice header,
2570	// or Implicit weighted prediction parameters (8 bits depth values).
2571	Bool bPresentFlag;
2572	UInt uiLog2WeightDenom;
2573	Int iWeight;
2574	Int iOffset;
2575
2576	// Weighted prediction scaling values built from above parameters (bitdepth scaled):
2577	Int w;
2578	Int o;
2579	Int offset;
2580	Int shift;
2581	Int round;
2582	};
2583
2584	struct WPACDCParam
2585	{
2586	Int64 iAC;
2587	Int64 iDC;
2588	};
2589
2590	/// slice header class
2591	class TComSlice
2592	{
2593
2594	private:
2595	// Bitstream writing
2596	#if NH_MV
2597	Bool m_firstSliceSegmentInPicFlag;
2598	#endif
2599	Bool m_saoEnabledFlag[MAX_NUM_CHANNEL_TYPE];
2600	Int m_iPPSId; ///< picture parameter set ID
2601	Bool m_PicOutputFlag; ///< pic_output_flag
2602	#if NH_MV
2603	Int m_slicePicOrderCntLsb;
2604	Bool m_shortTermRefPicSetSpsFlag;
2605	Int m_shortTermRefPicSetIdx;
2606	Int m_numLongTermSps;
2607	Int m_numLongTermPics;
2608	Int m_ltIdxSps [MAX_NUM_PICS_RPS];
2609	Int m_pocLsbLt [MAX_NUM_PICS_RPS];
2610	Bool m_usedByCurrPicLtFlag [MAX_NUM_PICS_RPS];
2611	Bool m_deltaPocMsbPresentFlag [MAX_NUM_PICS_RPS];
2612	Int m_deltaPocMsbCycleLt [MAX_NUM_PICS_RPS];
2613	Bool m_sliceTemporalMvpEnabledFlag;
2614	TComStRefPicSet m_stRefPicSet;
2615	#endif
2616	Int m_iPOC;
2617	#if NH_MV
2618	Int m_iPOCBeforeReset;
2619	#endif
2620	Int m_iLastIDR;
2621	Int m_iAssociatedIRAP;
2622	NalUnitType m_iAssociatedIRAPType;
2623	const TComReferencePictureSet* m_pRPS; //< pointer to RPS, either in the SPS or the local RPS in the same slice header
2624	TComReferencePictureSet m_localRPS; //< RPS when present in slice header
2625	Int m_rpsIdx; //< index of used RPS in the SPS or -1 for local RPS in the slice header
2626	TComRefPicListModification m_RefPicListModification;
2627	NalUnitType m_eNalUnitType; ///< Nal unit type for the slice
2628	SliceType m_eSliceType;
2629	Int m_iSliceQp;
2630	Bool m_dependentSliceSegmentFlag;
2631	#if ADAPTIVE_QP_SELECTION
2632	Int m_iSliceQpBase;
2633	#endif
2634	Bool m_ChromaQpAdjEnabled;
2635	Bool m_deblockingFilterDisable;
2636	Bool m_deblockingFilterOverrideFlag; //< offsets for deblocking filter inherit from PPS
2637	Int m_deblockingFilterBetaOffsetDiv2; //< beta offset for deblocking filter
2638	Int m_deblockingFilterTcOffsetDiv2; //< tc offset for deblocking filter
2639	Int m_list1IdxToList0Idx[MAX_NUM_REF];
2640	Int m_aiNumRefIdx [NUM_REF_PIC_LIST_01]; // for multiple reference of current slice
2641
2642	Bool m_bCheckLDC;
2643
2644	// Data
2645	Int m_iSliceQpDelta;
2646	Int m_iSliceChromaQpDelta[MAX_NUM_COMPONENT];
2647	TComPic* m_apcRefPicList [NUM_REF_PIC_LIST_01][MAX_NUM_REF+1];
2648	Int m_aiRefPOCList [NUM_REF_PIC_LIST_01][MAX_NUM_REF+1];
2649	#if NH_MV
2650	Int m_aiRefLayerIdList[2][MAX_NUM_REF+1];
2651	#endif
2652	Bool m_bIsUsedAsLongTerm[NUM_REF_PIC_LIST_01][MAX_NUM_REF+1];
2653	Int m_iDepth;
2654
2655	// referenced slice?
2656	Bool m_bRefenced;
2657
2658	// access channel
2659	const TComVPS* m_pcVPS;
2660	const TComSPS* m_pcSPS;
2661	const TComPPS* m_pcPPS;
2662	TComPic* m_pcPic;
2663	Bool m_colFromL0Flag; // collocated picture from List0 flag
2664
2665	Bool m_noOutputPriorPicsFlag;
2666	Bool m_noRaslOutputFlag;
2667	Bool m_handleCraAsBlaFlag;
2668
2669	UInt m_colRefIdx;
2670	UInt m_maxNumMergeCand;
2671
2672	Double m_lambdas[MAX_NUM_COMPONENT];
2673
2674	Bool m_abEqualRef [NUM_REF_PIC_LIST_01][MAX_NUM_REF][MAX_NUM_REF];
2675	UInt m_uiTLayer;
2676	Bool m_bTLayerSwitchingFlag;
2677
2678	SliceConstraint m_sliceMode;
2679	UInt m_sliceArgument;
2680	UInt m_sliceCurStartCtuTsAddr;
2681	UInt m_sliceCurEndCtuTsAddr;
2682	UInt m_sliceIdx;
2683	SliceConstraint m_sliceSegmentMode;
2684	UInt m_sliceSegmentArgument;
2685	UInt m_sliceSegmentCurStartCtuTsAddr;
2686	UInt m_sliceSegmentCurEndCtuTsAddr;
2687	Bool m_nextSlice;
2688	Bool m_nextSliceSegment;
2689	UInt m_sliceBits;
2690	UInt m_sliceSegmentBits;
2691	Bool m_bFinalized;
2692
2693	Bool m_bTestWeightPred;
2694	Bool m_bTestWeightBiPred;
2695	WPScalingParam m_weightPredTable[NUM_REF_PIC_LIST_01][MAX_NUM_REF][MAX_NUM_COMPONENT]; // [REF_PIC_LIST_0 or REF_PIC_LIST_1][refIdx][0:Y, 1:U, 2:V]
2696	WPACDCParam m_weightACDCParam[MAX_NUM_COMPONENT];
2697
2698	std::vector<UInt> m_substreamSizes;
2699
2700	Bool m_cabacInitFlag;
2701
2702	Bool m_bLMvdL1Zero;
2703	Bool m_temporalLayerNonReferenceFlag;
2704	Bool m_LFCrossSliceBoundaryFlag;
2705
2706	Bool m_enableTMVPFlag;
2707
2708	SliceType m_encCABACTableIdx; // Used to transmit table selection across slices.
2709	#if NH_MV
2710
2711	std::vector<TComPic> m_refPicSetInterLayer0;
2712	std::vector<TComPic> m_refPicSetInterLayer1;
2713	Int m_layerId;
2714	Int m_viewId;
2715	Int m_viewIndex;
2716	#if NH_3D_VSO \|\| NH_3D
2717	Bool m_isDepth;
2718	#endif
2719
2720	// Additional slice header syntax elements
2721	Bool m_pocResetFlag;
2722
2723	Bool m_crossLayerBlaFlag;
2724	Bool m_discardableFlag;
2725	Bool m_interLayerPredEnabledFlag;
2726	Int m_numInterLayerRefPicsMinus1;
2727	Int m_interLayerPredLayerIdc [MAX_NUM_LAYERS];
2728
2729	Int m_sliceSegmentHeaderExtensionLength;
2730	Int m_pocResetIdc;
2731	Int m_pocResetPeriodId;
2732
2733	Bool m_hasPocResetPeriodIdPresent;
2734	DecodingProcess m_decodingProcess;
2735	DecodingProcess m_decProcPocAndRps;
2736	Bool m_fullPocResetFlag;
2737	Int m_pocLsbVal;
2738	Bool m_pocMsbCycleValPresentFlag;
2739	Int m_pocMsbCycleVal;
2740	Bool m_pocMsbValRequiredFlag;
2741	#endif
2742
2743	#if NH_3D
2744	IntAry2d m_aaiCodedScale ;
2745	IntAry2d m_aaiCodedOffset;
2746
2747	Int m_aiAlterRefIdx [2];
2748	Bool m_arpRefPicAvailable[2][MAX_NUM_LAYERS];
2749	TComList<TComPic> m_pBaseViewRefPicList[MAX_NUM_LAYERS];
2750	UInt m_nARPStepNum;
2751	Int m_aiFirstTRefIdx [2];
2752	std::vector<Int> m_pocsInCurrRPSs;
2753	Bool m_bApplyIC;
2754	Bool m_icSkipParseFlag;
2755	std::vector<Int> m_inCmpRefViewIdcs;
2756	Bool m_inCmpPredAvailFlag;
2757	Bool m_inCmpPredFlag;
2758	Bool m_cpAvailableFlag;
2759	Int m_numViews;
2760	TComPic* m_ivPicsCurrPoc [2][MAX_NUM_LAYERS];
2761	Int** m_depthToDisparityB;
2762	Int** m_depthToDisparityF;
2763	Bool m_bApplyDIS;
2764	Int* m_aICEnableCandidate;
2765	Int* m_aICEnableNum;
2766
2767	Int m_iDefaultRefViewIdx;
2768	Bool m_bDefaultRefViewIdxAvailableFlag;
2769
2770	Bool m_ivMvPredFlag ;
2771	Bool m_ivMvScalingFlag ;
2772	Bool m_ivResPredFlag ;
2773	Bool m_depthRefinementFlag ;
2774	Bool m_viewSynthesisPredFlag;
2775	Bool m_depthBasedBlkPartFlag;
2776	Bool m_mpiFlag ;
2777	Bool m_intraContourFlag ;
2778	Bool m_intraSdcWedgeFlag ;
2779	Bool m_qtPredFlag ;
2780	Bool m_interSdcFlag ;
2781	Bool m_depthIntraSkipFlag ;
2782	Int m_mpiSubPbSize ;
2783	Int m_subPbSize ;
2784	#endif
2785	public:
2786	TComSlice();
2787	virtual ~TComSlice();
2788	Void initSlice();
2789
2790	Void setVPS( TComVPS* pcVPS ) { m_pcVPS = pcVPS; }
2791	const TComVPS* getVPS() const { return m_pcVPS; }
2792	Void setSPS( const TComSPS* pcSPS ) { m_pcSPS = pcSPS; }
2793	const TComSPS* getSPS() const { return m_pcSPS; }
2794
2795	Void setPPS( const TComPPS* pcPPS ) { m_pcPPS = pcPPS; m_iPPSId = (pcPPS) ? pcPPS->getPPSId() : -1; }
2796	const TComPPS* getPPS() const { return m_pcPPS; }
2797
2798	Void setPPSId( Int PPSId ) { m_iPPSId = PPSId; }
2799	Int getPPSId() const { return m_iPPSId; }
2800	Void setPicOutputFlag( Bool b ) { m_PicOutputFlag = b; }
2801	#if NH_MV
2802	Void setSlicePicOrderCntLsb( Int i ) { m_slicePicOrderCntLsb = i; }
2803	Int getSlicePicOrderCntLsb( ) const { return m_slicePicOrderCntLsb; }
2804
2805	Bool getFirstSliceSegementInPicFlag() const { return m_firstSliceSegmentInPicFlag; }
2806	Void setFirstSliceSegementInPicFlag(Bool val) { m_firstSliceSegmentInPicFlag = val; }
2807	#endif
2808	Bool getPicOutputFlag() const { return m_PicOutputFlag; }
2809	Void setSaoEnabledFlag(ChannelType chType, Bool s) {m_saoEnabledFlag[chType] =s; }
2810	Bool getSaoEnabledFlag(ChannelType chType) const { return m_saoEnabledFlag[chType]; }
2811	Void setRPS( const TComReferencePictureSet *pcRPS ) { m_pRPS = pcRPS; }
2812	const TComReferencePictureSet* getRPS() { return m_pRPS; }
2813	TComReferencePictureSet* getLocalRPS() { return &m_localRPS; }
2814
2815	Void setRPSidx( Int rpsIdx ) { m_rpsIdx = rpsIdx; }
2816	Int getRPSidx() const { return m_rpsIdx; }
2817	TComRefPicListModification* getRefPicListModification() { return &m_RefPicListModification; }
2818	Void setLastIDR(Int iIDRPOC) { m_iLastIDR = iIDRPOC; }
2819	Int getLastIDR() const { return m_iLastIDR; }
2820	Void setAssociatedIRAPPOC(Int iAssociatedIRAPPOC) { m_iAssociatedIRAP = iAssociatedIRAPPOC; }
2821	Int getAssociatedIRAPPOC() const { return m_iAssociatedIRAP; }
2822	Void setAssociatedIRAPType(NalUnitType associatedIRAPType) { m_iAssociatedIRAPType = associatedIRAPType; }
2823	NalUnitType getAssociatedIRAPType() const { return m_iAssociatedIRAPType; }
2824	SliceType getSliceType() const { return m_eSliceType; }
2825	Int getPOC() const { return m_iPOC; }
2826	Int getSliceQp() const { return m_iSliceQp; }
2827	Bool getUseWeightedPrediction() const { return( (m_eSliceType==P_SLICE && testWeightPred()) \|\| (m_eSliceType==B_SLICE && testWeightBiPred()) ); }
2828	Bool getDependentSliceSegmentFlag() const { return m_dependentSliceSegmentFlag; }
2829	Void setDependentSliceSegmentFlag(Bool val) { m_dependentSliceSegmentFlag = val; }
2830	#if ADAPTIVE_QP_SELECTION
2831	Int getSliceQpBase() const { return m_iSliceQpBase; }
2832	#endif
2833	Int getSliceQpDelta() const { return m_iSliceQpDelta; }
2834	Int getSliceChromaQpDelta(ComponentID compID) const { return isLuma(compID) ? 0 : m_iSliceChromaQpDelta[compID]; }
2835	Bool getUseChromaQpAdj() const { return m_ChromaQpAdjEnabled; }
2836	Bool getDeblockingFilterDisable() const { return m_deblockingFilterDisable; }
2837	Bool getDeblockingFilterOverrideFlag() const { return m_deblockingFilterOverrideFlag; }
2838	Int getDeblockingFilterBetaOffsetDiv2()const { return m_deblockingFilterBetaOffsetDiv2; }
2839	Int getDeblockingFilterTcOffsetDiv2() const { return m_deblockingFilterTcOffsetDiv2; }
2840
2841	Int getNumRefIdx( RefPicList e ) const { return m_aiNumRefIdx[e]; }
2842	TComPic* getPic() { return m_pcPic; }
2843	const TComPic* getPic() const { return m_pcPic; }
2844	TComPic* getRefPic( RefPicList e, Int iRefIdx) { return m_apcRefPicList[e][iRefIdx]; }
2845	const TComPic* getRefPic( RefPicList e, Int iRefIdx) const { return m_apcRefPicList[e][iRefIdx]; }
2846	Int getRefPOC( RefPicList e, Int iRefIdx) const { return m_aiRefPOCList[e][iRefIdx]; }
2847	#if NH_3D
2848	Bool getInCmpPredAvailFlag( ) const { return m_inCmpPredAvailFlag; }
2849	Bool getCpAvailableFlag( ) const { return m_cpAvailableFlag; }
2850	Bool getInCompPredFlag( ) const { return m_inCmpPredFlag; }
2851	Void setInCompPredFlag( Bool b ) { m_inCmpPredFlag = b; }
2852	Int getInCmpRefViewIdcs( Int i ) const { return m_inCmpRefViewIdcs [i]; }
2853	Int getNumCurCmpLIds( ) const { return (Int) m_inCmpRefViewIdcs.size(); }
2854	TComPic* getIvPic( Bool depthFlag, Int viewIndex) const { return m_ivPicsCurrPoc[ depthFlag ? 1 : 0 ][ viewIndex ]; }
2855	TComPic* getTexturePic () { return m_ivPicsCurrPoc[0][ m_viewIndex ]; }
2856
2857	Void setApplyIC( Bool b ) { m_bApplyIC = b; }
2858	Bool getApplyIC() { return m_bApplyIC; }
2859	Void xSetApplyIC();
2860	Void xSetApplyIC(Bool bUseLowLatencyICEnc);
2861	Void setIcSkipParseFlag( Bool b ) { m_icSkipParseFlag = b; }
2862	Bool getIcSkipParseFlag() { return m_icSkipParseFlag; }
2863
2864	Void setBaseViewRefPicList( TComList<TComPic> pListPic, Int iViewIdx ) { m_pBaseViewRefPicList[iViewIdx] = pListPic; }
2865	Void setARPStepNum( TComPicLists*ivPicLists );
2866	Void setPocsInCurrRPSs( );
2867
2868	TComPic* getBaseViewRefPic ( UInt uiPOC , Int iViewIdx ) { return xGetRefPic( *m_pBaseViewRefPicList[iViewIdx], uiPOC ); }
2869	UInt getARPStepNum( ) { return m_nARPStepNum; }
2870	#endif
2871	Int getDepth() const { return m_iDepth; }
2872	Bool getColFromL0Flag() const { return m_colFromL0Flag; }
2873	UInt getColRefIdx() const { return m_colRefIdx; }
2874	Void checkColRefIdx(UInt curSliceIdx, TComPic* pic);
2875	Bool getIsUsedAsLongTerm(Int i, Int j) const { return m_bIsUsedAsLongTerm[i][j]; }
2876	Void setIsUsedAsLongTerm(Int i, Int j, Bool value) { m_bIsUsedAsLongTerm[i][j] = value; }
2877	Bool getCheckLDC() const { return m_bCheckLDC; }
2878	Bool getMvdL1ZeroFlag() const { return m_bLMvdL1Zero; }
2879	Int getNumRpsCurrTempList() const;
2880	#if NH_MV
2881	Int getNumPicTotalCurr() const;
2882	#endif
2883	Int getList1IdxToList0Idx( Int list1Idx ) const { return m_list1IdxToList0Idx[list1Idx]; }
2884	Void setReferenced(Bool b) { m_bRefenced = b; }
2885	Bool isReferenced() const { return m_bRefenced; }
2886	Bool isReferenceNalu() const { return ((getNalUnitType() <= NAL_UNIT_RESERVED_VCL_R15) && (getNalUnitType()%2 != 0)) \|\| ((getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP) && (getNalUnitType() <= NAL_UNIT_RESERVED_IRAP_VCL23) ); }
2887	Void setPOC( Int i ) { m_iPOC = i; }
2888	Void setNalUnitType( NalUnitType e ) { m_eNalUnitType = e; }
2889	NalUnitType getNalUnitType() const { return m_eNalUnitType; }
2890	#if NH_MV
2891	std::string getNalUnitTypeString( ) { return NALU_TYPE_STR[ getNalUnitType() ]; };
2892	#endif
2893	Bool getRapPicFlag() const;
2894	Bool getIdrPicFlag() const { return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL \|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP; }
2895	Bool isIRAP() const { return (getNalUnitType() >= 16) && (getNalUnitType() <= 23); }
2896	#if NH_MV
2897	Bool isBla() const { return ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP ) \|\| ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ) \|\| ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL ); }
2898	Bool isIdr() const { return ( getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL ) \|\| ( getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ); }
2899	Bool isCra() const { return ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ); }
2900
2901	Bool isSlnr() const { return ( getNalUnitType() == NAL_UNIT_CODED_SLICE_TRAIL_N \|\|
2902	getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N \|\|
2903	getNalUnitType() == NAL_UNIT_CODED_SLICE_STSA_N \|\|
2904	getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N \|\|
2905	getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N \|\|
2906	getNalUnitType() == NAL_UNIT_RESERVED_VCL_N10 \|\|
2907	getNalUnitType() == NAL_UNIT_RESERVED_VCL_N12 \|\|
2908	getNalUnitType() == NAL_UNIT_RESERVED_VCL_N14 ); }
2909
2910	Bool isRasl() const { return ( getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_R ) \|\| ( getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N ); }
2911	Bool isRadl() const { return ( getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_R ) \|\| ( getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N ); }
2912	Bool isStsa() const { return ( getNalUnitType() == NAL_UNIT_CODED_SLICE_STSA_R ) \|\| ( getNalUnitType() == NAL_UNIT_CODED_SLICE_STSA_N ); }
2913	Bool isTsa() const { return ( getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_R ) \|\| ( getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N ); }
2914
2915	Bool decProcClause8() const { return ( m_decodingProcess == CLAUSE_8 ); }
2916	Bool decProcAnnexF() const { return ( decProcAnnexG() \|\| decProcAnnexH() \|\| decProcAnnexI() ) ; }
2917	Bool decProcAnnexG() const { return ( m_decodingProcess == ANNEX_G \|\| decProcAnnexI() ); }
2918	Bool decProcAnnexH() const { return ( m_decodingProcess == ANNEX_H ); }
2919	Bool decProcAnnexI() const { return ( m_decodingProcess == ANNEX_I ); }
2920	Int getCurrRpsIdx() const { return ( getShortTermRefPicSetSpsFlag() ? getShortTermRefPicSetIdx() : getSPS()->getNumShortTermRefPicSets() ) ;}
2921
2922	#endif
2923
2924
2925	Void checkCRA(const TComReferencePictureSet pReferencePictureSet, Int& pocCRA, NalUnitType& associatedIRAPType, TComList<TComPic >& rcListPic);
2926	Void decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic, const bool bEfficientFieldIRAPEnabled);
2927	Void setSliceType( SliceType e ) { m_eSliceType = e; }
2928	Void setSliceQp( Int i ) { m_iSliceQp = i; }
2929	#if ADAPTIVE_QP_SELECTION
2930	Void setSliceQpBase( Int i ) { m_iSliceQpBase = i; }
2931	#endif
2932	Void setSliceQpDelta( Int i ) { m_iSliceQpDelta = i; }
2933	Void setSliceChromaQpDelta( ComponentID compID, Int i ) { m_iSliceChromaQpDelta[compID] = isLuma(compID) ? 0 : i; }
2934	Void setUseChromaQpAdj( Bool b ) { m_ChromaQpAdjEnabled = b; }
2935	Void setDeblockingFilterDisable( Bool b ) { m_deblockingFilterDisable= b; }
2936	Void setDeblockingFilterOverrideFlag( Bool b ) { m_deblockingFilterOverrideFlag = b; }
2937	Void setDeblockingFilterBetaOffsetDiv2( Int i ) { m_deblockingFilterBetaOffsetDiv2 = i; }
2938	Void setDeblockingFilterTcOffsetDiv2( Int i ) { m_deblockingFilterTcOffsetDiv2 = i; }
2939
2940	Void setRefPic( TComPic* p, RefPicList e, Int iRefIdx ) { m_apcRefPicList[e][iRefIdx] = p; }
2941	Void setRefPOC( Int i, RefPicList e, Int iRefIdx ) { m_aiRefPOCList[e][iRefIdx] = i; }
2942	Void setNumRefIdx( RefPicList e, Int i ) { m_aiNumRefIdx[e] = i; }
2943	#if NH_MV
2944	Int getNumRefIdxL0ActiveMinus1() const { return ( getNumRefIdx(REF_PIC_LIST_0) -1); }
2945	Int getNumRefIdxL1ActiveMinus1() const { return ( getNumRefIdx(REF_PIC_LIST_1) -1); }
2946	#endif
2947	Void setPic( TComPic* p ) { m_pcPic = p; }
2948	Void setDepth( Int iDepth ) { m_iDepth = iDepth; }
2949	#if NH_MV
2950	Void setPocBeforeReset( Int i ) { m_iPOCBeforeReset = i; }
2951	Int getPocBeforeReset( ) { return m_iPOCBeforeReset; }
2952	Int getRefLayerId( RefPicList e, Int iRefIdx) { return m_aiRefLayerIdList[e][iRefIdx]; }
2953	Void setRefLayerId( Int i, RefPicList e, Int iRefIdx ) { m_aiRefLayerIdList[e][iRefIdx] = i; }
2954	Void getTempRefPicLists ( TComList<TComPic>& rcListPic, std::vector<TComPic>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1,
2955	std::vector<TComPic*> rpsCurrList[2], BoolAry1d usedAsLongTerm[2], Int& numPocTotalCurr, Bool checkNumPocTotalCurr = false );
2956
2957	Void setRefPicList ( std::vector<TComPic*> rpsCurrList[2], BoolAry1d usedAsLongTerm[2], Int numPocTotalCurr, Bool checkNumPocTotalCurr = false );
2958	#else
2959	Void setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr = false );
2960	#endif
2961	Void setRefPOCList();
2962	Void setColFromL0Flag( Bool colFromL0 ) { m_colFromL0Flag = colFromL0; }
2963	Void setColRefIdx( UInt refIdx) { m_colRefIdx = refIdx; }
2964	Void setCheckLDC( Bool b ) { m_bCheckLDC = b; }
2965	Void setMvdL1ZeroFlag( Bool b) { m_bLMvdL1Zero = b; }
2966
2967	Bool isIntra() const { return m_eSliceType == I_SLICE; }
2968	Bool isInterB() const { return m_eSliceType == B_SLICE; }
2969	Bool isInterP() const { return m_eSliceType == P_SLICE; }
2970
2971	Void setLambdas( const Double lambdas[MAX_NUM_COMPONENT] ) { for (Int component = 0; component < MAX_NUM_COMPONENT; component++) m_lambdas[component] = lambdas[component]; }
2972	const Double* getLambdas() const { return m_lambdas; }
2973
2974	Void initEqualRef();
2975	Bool isEqualRef( RefPicList e, Int iRefIdx1, Int iRefIdx2 )
2976	{
2977	assert(e<NUM_REF_PIC_LIST_01);
2978	if (iRefIdx1 < 0 \|\| iRefIdx2 < 0)
2979	{
2980	return false;
2981	}
2982	else
2983	{
2984	return m_abEqualRef[e][iRefIdx1][iRefIdx2];
2985	}
2986	}
2987
2988	Void setEqualRef( RefPicList e, Int iRefIdx1, Int iRefIdx2, Bool b)
2989	{
2990	assert(e<NUM_REF_PIC_LIST_01);
2991	m_abEqualRef[e][iRefIdx1][iRefIdx2] = m_abEqualRef[e][iRefIdx2][iRefIdx1] = b;
2992	}
2993
2994	static Void sortPicList( TComList<TComPic*>& rcListPic );
2995	Void setList1IdxToList0Idx();
2996
2997	UInt getTLayer() const { return m_uiTLayer; }
2998	Void setTLayer( UInt uiTLayer ) { m_uiTLayer = uiTLayer; }
2999	#if NH_MV
3000	Int getTemporalId( ) const { return (Int) m_uiTLayer; }
3001	#endif
3002
3003	Void setTLayerInfo( UInt uiTLayer );
3004	Void decodingMarking( TComList<TComPic*>& rcListPic, Int iGOPSIze, Int& iMaxRefPicNum );
3005	Void checkLeadingPictureRestrictions( TComList<TComPic*>& rcListPic );
3006	Void applyReferencePictureSet( TComList<TComPic>& rcListPic, const TComReferencePictureSet RPSList);
3007	#if NH_MV
3008	Void createInterLayerReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic>& refPicSetInterLayer0, std::vector<TComPic>& refPicSetInterLayer1 );
3009	Void f834decProcForRefPicListConst();
3010	Void cl834DecProcForRefPicListConst();
3011
3012	static Void markIvRefPicsAsShortTerm ( std::vector<TComPic> refPicSetInterLayer0, std::vector<TComPic> refPicSetInterLayer1 );
3013	static Void markCurrPic ( TComPic* currPic );
3014	Void printRefPicList();
3015	#endif
3016	Bool isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic );
3017	Bool isStepwiseTemporalLayerSwitchingPointCandidate( TComList<TComPic*>& rcListPic );
3018	Int checkThatAllRefPicsAreAvailable( TComList<TComPic>& rcListPic, const TComReferencePictureSet pReferencePictureSet, Bool printErrors, Int pocRandomAccess = 0, Bool bUseRecoveryPoint = false);
3019	Void createExplicitReferencePictureSetFromReference( TComList<TComPic>& rcListPic, const TComReferencePictureSet pReferencePictureSet, Bool isRAP, Int pocRandomAccess, Bool bUseRecoveryPoint, const Bool bEfficientFieldIRAPEnabled);
3020	Void setMaxNumMergeCand(UInt val ) { m_maxNumMergeCand = val; }
3021	UInt getMaxNumMergeCand() const { return m_maxNumMergeCand; }
3022
3023	Void setNoOutputPriorPicsFlag( Bool val ) { m_noOutputPriorPicsFlag = val; }
3024	Bool getNoOutputPriorPicsFlag() const { return m_noOutputPriorPicsFlag; }
3025
3026	Void setNoRaslOutputFlag( Bool val ) { m_noRaslOutputFlag = val; }
3027	Bool getNoRaslOutputFlag() const { return m_noRaslOutputFlag; }
3028
3029
3030	Void setHandleCraAsBlaFlag( Bool val ) { m_handleCraAsBlaFlag = val; }
3031	Bool getHandleCraAsBlaFlag() const { return m_handleCraAsBlaFlag; }
3032
3033	Void setSliceMode( SliceConstraint mode ) { m_sliceMode = mode; }
3034	SliceConstraint getSliceMode() const { return m_sliceMode; }
3035	Void setSliceArgument( UInt uiArgument ) { m_sliceArgument = uiArgument; }
3036	UInt getSliceArgument() const { return m_sliceArgument; }
3037	Void setSliceCurStartCtuTsAddr( UInt ctuTsAddr ) { m_sliceCurStartCtuTsAddr = ctuTsAddr; } // CTU Tile-scan address (as opposed to raster-scan)
3038	UInt getSliceCurStartCtuTsAddr() const { return m_sliceCurStartCtuTsAddr; } // CTU Tile-scan address (as opposed to raster-scan)
3039	Void setSliceCurEndCtuTsAddr( UInt ctuTsAddr ) { m_sliceCurEndCtuTsAddr = ctuTsAddr; } // CTU Tile-scan address (as opposed to raster-scan)
3040	UInt getSliceCurEndCtuTsAddr() const { return m_sliceCurEndCtuTsAddr; } // CTU Tile-scan address (as opposed to raster-scan)
3041	Void setSliceIdx( UInt i) { m_sliceIdx = i; }
3042	UInt getSliceIdx() const { return m_sliceIdx; }
3043	Void copySliceInfo(TComSlice *pcSliceSrc);
3044	Void setSliceSegmentMode( SliceConstraint mode ) { m_sliceSegmentMode = mode; }
3045	SliceConstraint getSliceSegmentMode() const { return m_sliceSegmentMode; }
3046	Void setSliceSegmentArgument( UInt uiArgument ) { m_sliceSegmentArgument = uiArgument; }
3047	UInt getSliceSegmentArgument() const { return m_sliceSegmentArgument; }
3048	Void setSliceSegmentCurStartCtuTsAddr( UInt ctuTsAddr ) { m_sliceSegmentCurStartCtuTsAddr = ctuTsAddr; } // CTU Tile-scan address (as opposed to raster-scan)
3049	UInt getSliceSegmentCurStartCtuTsAddr() const { return m_sliceSegmentCurStartCtuTsAddr; } // CTU Tile-scan address (as opposed to raster-scan)
3050	Void setSliceSegmentCurEndCtuTsAddr( UInt ctuTsAddr ) { m_sliceSegmentCurEndCtuTsAddr = ctuTsAddr; } // CTU Tile-scan address (as opposed to raster-scan)
3051	UInt getSliceSegmentCurEndCtuTsAddr() const { return m_sliceSegmentCurEndCtuTsAddr; } // CTU Tile-scan address (as opposed to raster-scan)
3052	Void setSliceBits( UInt uiVal ) { m_sliceBits = uiVal; }
3053	UInt getSliceBits() const { return m_sliceBits; }
3054	Void setSliceSegmentBits( UInt uiVal ) { m_sliceSegmentBits = uiVal; }
3055	UInt getSliceSegmentBits() const { return m_sliceSegmentBits; }
3056	Void setFinalized( Bool uiVal ) { m_bFinalized = uiVal; }
3057	Bool getFinalized() const { return m_bFinalized; }
3058	Bool testWeightPred( ) const { return m_bTestWeightPred; }
3059	Void setTestWeightPred( Bool bValue ) { m_bTestWeightPred = bValue; }
3060	Bool testWeightBiPred( ) const { return m_bTestWeightBiPred; }
3061	Void setTestWeightBiPred( Bool bValue ) { m_bTestWeightBiPred = bValue; }
3062	Void setWpScaling( WPScalingParam wp[NUM_REF_PIC_LIST_01][MAX_NUM_REF][MAX_NUM_COMPONENT] )
3063	{
3064	memcpy(m_weightPredTable, wp, sizeof(WPScalingParam)NUM_REF_PIC_LIST_01MAX_NUM_REF*MAX_NUM_COMPONENT);
3065	}
3066
3067	Void getWpScaling( RefPicList e, Int iRefIdx, WPScalingParam *&wp);
3068
3069	Void resetWpScaling();
3070	Void initWpScaling(const TComSPS *sps);
3071
3072	Void setWpAcDcParam( WPACDCParam wp[MAX_NUM_COMPONENT] )
3073	{
3074	memcpy(m_weightACDCParam, wp, sizeof(WPACDCParam)*MAX_NUM_COMPONENT);
3075	}
3076
3077	Void getWpAcDcParam( WPACDCParam *&wp );
3078	Void initWpAcDcParam();
3079
3080	Void clearSubstreamSizes( ) { return m_substreamSizes.clear(); }
3081	UInt getNumberOfSubstreamSizes( ) { return (UInt) m_substreamSizes.size(); }
3082	Void addSubstreamSize( UInt size ) { m_substreamSizes.push_back(size); }
3083	UInt getSubstreamSize( Int idx ) { assert(idx<getNumberOfSubstreamSizes()); return m_substreamSizes[idx]; }
3084
3085	Void setCabacInitFlag( Bool val ) { m_cabacInitFlag = val; } //!< set CABAC initial flag
3086	Bool getCabacInitFlag() { return m_cabacInitFlag; } //!< get CABAC initial flag
3087	Bool getTemporalLayerNonReferenceFlag() { return m_temporalLayerNonReferenceFlag; }
3088	Void setTemporalLayerNonReferenceFlag(Bool x) { m_temporalLayerNonReferenceFlag = x; }
3089	Void setLFCrossSliceBoundaryFlag( Bool val ) { m_LFCrossSliceBoundaryFlag = val; }
3090	Bool getLFCrossSliceBoundaryFlag() { return m_LFCrossSliceBoundaryFlag; }
3091
3092	#if NH_MV
3093	Void setShortTermRefPicSetSpsFlag( Bool flag ) { m_shortTermRefPicSetSpsFlag = flag; }
3094	Bool getShortTermRefPicSetSpsFlag( ) const { return m_shortTermRefPicSetSpsFlag; }
3095
3096	Int getShortTermRefPicSetIdxLen() const { return gCeilLog2( getSPS()->getNumShortTermRefPicSets() ); }
3097	Void setShortTermRefPicSetIdx( Int val ) { m_shortTermRefPicSetIdx = val; }
3098	Int getShortTermRefPicSetIdx( ) const { return m_shortTermRefPicSetIdx; }
3099
3100	Void setNumLongTermSps( Int val ) { m_numLongTermSps = val; }
3101	Int getNumLongTermSps( ) const { return m_numLongTermSps; }
3102
3103	Void setNumLongTermPics( Int val ) { m_numLongTermPics = val; }
3104	Int getNumLongTermPics( ) const { return m_numLongTermPics; }
3105
3106	Int getLtIdxSpsLen() const { return gCeilLog2( getSPS()->getNumLongTermRefPicsSps() ); }
3107	Void setLtIdxSps( Int i, Int val ) { m_ltIdxSps[i] = val; }
3108	Int getLtIdxSps( Int i ) const { return m_ltIdxSps[i]; }
3109
3110	Int getPocLsbLtLen() const { return (getSPS()->getLog2MaxPicOrderCntLsbMinus4()+ 4); }
3111	Void setPocLsbLt( Int i, Int val ) { m_pocLsbLt[i] = val; }
3112	Int getPocLsbLt( Int i ) const { return m_pocLsbLt[i]; }
3113
3114	Void setUsedByCurrPicLtFlag( Int i, Bool flag ) { m_usedByCurrPicLtFlag[i] = flag; }
3115	Bool getUsedByCurrPicLtFlag( Int i ) const { return m_usedByCurrPicLtFlag[i]; }
3116
3117	Void setDeltaPocMsbPresentFlag( Int i, Bool flag ) { m_deltaPocMsbPresentFlag[i] = flag; }
3118	Bool getDeltaPocMsbPresentFlag( Int i ) const { return m_deltaPocMsbPresentFlag[i]; }
3119
3120	Void setDeltaPocMsbCycleLt( Int i, Int val ) { m_deltaPocMsbCycleLt[i] = val; }
3121	Int getDeltaPocMsbCycleLt( Int i ) const { return m_deltaPocMsbCycleLt[i]; }
3122
3123	Void setSliceTemporalMvpEnabledFlag( Bool flag ) { m_enableTMVPFlag = flag; }
3124	Bool getSliceTemporalMvpEnabledFlag( ) const { return m_enableTMVPFlag; }
3125
3126	TComStRefPicSet* getLocalStRps( ) { return &m_stRefPicSet; };
3127	const TComStRefPicSet* getStRps( Int stRpsIdx ) const { return ( (stRpsIdx == getSPS()->getNumShortTermRefPicSets()) ? &m_stRefPicSet : getSPS()->getStRefPicSet( stRpsIdx ) ); };
3128
3129	#endif
3130
3131	Void setEnableTMVPFlag( Bool b ) { m_enableTMVPFlag = b; }
3132	Bool getEnableTMVPFlag() const { return m_enableTMVPFlag; }
3133
3134	Void setEncCABACTableIdx( SliceType idx ) { m_encCABACTableIdx = idx; }
3135	SliceType getEncCABACTableIdx() const { return m_encCABACTableIdx; }
3136
3137	#if NH_MV
3138	Void setLayerId ( Int layerId ) { m_layerId = layerId; }
3139	Int getLayerId () const { return m_layerId; }
3140	Int getLayerIdInVps() const { return getVPS()->getLayerIdInVps( m_layerId ); }
3141	Void setViewId ( Int viewId ) { m_viewId = viewId; }
3142	Int getViewId () const { return m_viewId; }
3143	Void setViewIndex ( Int viewIndex ) { m_viewIndex = viewIndex; }
3144	Int getViewIndex () const { return m_viewIndex; }
3145
3146	Void setDecodingProcess ( DecodingProcess decProc ) { m_decodingProcess = decProc; }
3147
3148
3149	#if NH_3D
3150	Void generateAlterRefforTMVP ();
3151	Void setAlterRefIdx ( RefPicList e, Int i ) { m_aiAlterRefIdx[e] = i; }
3152	Int getAlterRefIdx ( RefPicList e ) { return m_aiAlterRefIdx[e]; }
3153	Int getFirstTRefIdx ( RefPicList e ) { return m_aiFirstTRefIdx[e]; }
3154	Void setFirstTRefIdx ( RefPicList e, Int i ) { m_aiFirstTRefIdx[e] = i; }
3155
3156	Bool getArpRefPicAvailable ( RefPicList e, Int viewIdx) { return m_arpRefPicAvailable[e][getVPS()->getLayerIdInNuh(viewIdx, false, 0 )]; }
3157	IntAry1d getPocsInCurrRPSs() { return m_pocsInCurrRPSs; }
3158	#endif
3159	#if NH_3D_VSO \|\| NH_3D
3160	Void setIsDepth ( Bool isDepth ) { m_isDepth = isDepth; }
3161	Bool getIsDepth () const { return m_isDepth; }
3162	#endif
3163	#if NH_3D
3164	Void setCamparaSlice ( Int aaiScale = 0, Int aaiOffset = 0 );
3165
3166	IntAry1d getCodedScale () const { return m_aaiCodedScale [0]; }
3167	IntAry1d getCodedOffset () const { return m_aaiCodedOffset[0]; }
3168	IntAry1d getInvCodedScale () const { return m_aaiCodedScale [1]; }
3169	IntAry1d getInvCodedOffset () const { return m_aaiCodedOffset[1]; }
3170
3171	Void setCpScale( Int j, Int val ) { m_aaiCodedScale[0][j] = val; }
3172	Int getCpScale( Int j ) { return m_aaiCodedScale[0][j]; }
3173
3174	Void setCpOff( Int j, Int val ) { m_aaiCodedOffset[0][j] = val; }
3175	Int getCpOff( Int j ) { return m_aaiCodedOffset[0][j]; }
3176
3177	Void setCpInvScale( Int j, Int val ) { m_aaiCodedScale[1][j] = val; }
3178	Int getCpInvScale( Int j ) { return m_aaiCodedScale[1][j]; }
3179
3180	Void setCpInvOff( Int j, Int val ) { m_aaiCodedOffset[1][j] = val; }
3181	Int getCpInvOff( Int j ) { return m_aaiCodedOffset[1][j]; }
3182
3183	Void setIvPicLists( TComPicLists* m_ivPicLists );
3184
3185	Void setDepthToDisparityLUTs();
3186
3187	Int* getDepthToDisparityB( Int refViewIdx ) { return m_depthToDisparityB[ getVPS()->getVoiInVps( refViewIdx) ];}
3188	Int* getDepthToDisparityF( Int refViewIdx ) { return m_depthToDisparityF[ getVPS()->getVoiInVps( refViewIdx) ];}
3189
3190	Void setICEnableCandidate( Int* icEnableCandidate) { m_aICEnableCandidate = icEnableCandidate; }
3191	Void setICEnableNum( Int* icEnableNum) { m_aICEnableNum = icEnableNum; }
3192	Void setICEnableCandidate( UInt layer, Int value) { m_aICEnableCandidate[ layer ] = value; }
3193	Void setICEnableNum( UInt layer, Int value) { m_aICEnableNum[ layer ] = value; ; }
3194
3195	Int getICEnableCandidate( Int layer) { return m_aICEnableCandidate[ layer ]; }
3196	Int getICEnableNum( Int layer) { return m_aICEnableNum[ layer ]; }
3197	#endif
3198	// Additional slice header syntax elements
3199
3200	Void setCrossLayerBlaFlag( Bool flag ) { m_crossLayerBlaFlag = flag; }
3201	Bool getCrossLayerBlaFlag( ) const { return m_crossLayerBlaFlag; }
3202	Void checkCrossLayerBlaFlag ( ) const ;
3203
3204	#if NH_MV
3205	Void setPocResetFlag( Bool flag ) { m_pocResetFlag = flag; }
3206	Bool getPocResetFlag( ) const { return m_pocResetFlag; }
3207	#endif
3208
3209	Void setDiscardableFlag( Bool flag ) { m_discardableFlag = flag; }
3210	Bool getDiscardableFlag( ) const { return m_discardableFlag; }
3211
3212	Void setInterLayerPredEnabledFlag( Bool flag ) { m_interLayerPredEnabledFlag = flag; }
3213	Bool getInterLayerPredEnabledFlag( ) const { return m_interLayerPredEnabledFlag; }
3214
3215	Void setNumInterLayerRefPicsMinus1( Int val ) { m_numInterLayerRefPicsMinus1 = val; }
3216	Int getNumInterLayerRefPicsMinus1( ) const { return m_numInterLayerRefPicsMinus1; }
3217
3218	Void setInterLayerPredLayerIdc( Int i, Int val ) { m_interLayerPredLayerIdc[i] = val; }
3219	Int getInterLayerPredLayerIdc( Int i ) const { return m_interLayerPredLayerIdc[i]; }
3220
3221	Void setSliceSegmentHeaderExtensionLength( Int val ) { m_sliceSegmentHeaderExtensionLength = val; }
3222	Int getSliceSegmentHeaderExtensionLength( ) const { return m_sliceSegmentHeaderExtensionLength; }
3223
3224	Void setPocResetIdc( Int val ) { m_pocResetIdc = val; }
3225	Int getPocResetIdc( ) const { return m_pocResetIdc; }
3226	Void checkPocResetIdc( ) const { assert( !(getVPS()->getPocLsbNotPresentFlag( getLayerIdInVps() ) ) \|\| !(getSlicePicOrderCntLsb() > 0 ) \|\| !( getPocResetIdc() == 2) ); }
3227
3228
3229	Void setPocResetPeriodId( Int val ) { m_pocResetPeriodId = val; }
3230	Int getPocResetPeriodId( ) const { return m_pocResetPeriodId; }
3231
3232	Void setFullPocResetFlag( Bool flag ) { m_fullPocResetFlag = flag; }
3233	Bool getFullPocResetFlag( ) const { return m_fullPocResetFlag; }
3234
3235	Void setPocLsbVal( Int val ) { m_pocLsbVal = val; }
3236	Int getPocLsbVal( ) const { return m_pocLsbVal; }
3237	Void checkPocLsbVal( ) const { assert( !(getVPS()->getPocLsbNotPresentFlag( getLayerIdInVps() ) ) \|\| !getFullPocResetFlag() \|\| ( getPocLsbVal() == 0 ) ); }
3238
3239	#if NH_MV
3240	Void setHasPocResetPeriodIdPresent( Bool val ) { m_hasPocResetPeriodIdPresent = val; }
3241	Bool getHasPocResetPeriodIdPresent( ) const { return m_hasPocResetPeriodIdPresent; }
3242
3243	Void setPocMsbCycleValPresentFlag( Bool flag ) { m_pocMsbCycleValPresentFlag = flag; }
3244	Bool getPocMsbCycleValPresentFlag( ) const { return m_pocMsbCycleValPresentFlag; }
3245
3246	Void setPocMsbCycleVal( Int val ) { m_pocMsbCycleVal = val; }
3247	Int getPocMsbCycleVal( ) const { return m_pocMsbCycleVal; }
3248
3249	Int getPocLsbLtVar(Int i);
3250	Bool getUsedByCurrPicLtVar(Int i) const;
3251	Int getDeltaPocMsbCycleLtVar( Int i ) const;
3252
3253	#else
3254	Void setPocMsbValPresentFlag( Bool flag ) { m_pocMsbValPresentFlag = flag; }
3255	Bool getPocMsbValPresentFlag( ) const { return m_pocMsbValPresentFlag; }
3256
3257	Void setPocMsbVal( Int val ) { m_pocMsbVal = val; }
3258	Int getPocMsbVal( ) const { return m_pocMsbVal; }
3259	#endif
3260
3261
3262	Bool getCraOrBlaPicFlag() const { return ( getCraPicFlag() \|\| getBlaPicFlag() ); }
3263	Bool getPocMsbValRequiredFlag() const { return ( getCraOrBlaPicFlag() && ( getVPS()->getVpsPocLsbAlignedFlag() \|\| getVPS()->getNumDirectRefLayers( getLayerIdInVps() ) == 0 ) ); }
3264
3265	UInt getPocLsbValLen() const { return getSPS()->getBitsForPOC(); }; //log2_max_pic_order_cnt_lsb_minus4 + 4
3266
3267	Bool getBlaPicFlag() const
3268	{
3269	return getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
3270	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
3271	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP;
3272	}
3273	Bool getCraPicFlag () const
3274	{
3275	return getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA;
3276	}
3277
3278	// Additional variables derived in slice header semantics
3279	#if NH_3D
3280	Int getNumInterLayerRefPicsMinus1Len( ) const { return gCeilLog2( getVPS()->getNumRefListLayers( getLayerId() )); }
3281	Int getInterLayerPredLayerIdcLen ( ) const { return gCeilLog2( getVPS()->getNumRefListLayers( getLayerId() )); }
3282	#else
3283	Int getNumInterLayerRefPicsMinus1Len( ) const { return gCeilLog2( getVPS()->getNumDirectRefLayers( getLayerId() )); }
3284	Int getInterLayerPredLayerIdcLen ( ) const { return gCeilLog2( getVPS()->getNumDirectRefLayers( getLayerId() )); }
3285	#endif
3286
3287	Int getRefLayerPicFlag( Int i ) const;
3288	Int getRefLayerPicIdc ( Int j ) const;
3289	Int getNumRefLayerPics( ) const;
3290
3291	Int getNumActiveRefLayerPics( ) const;
3292
3293	Int getNumActiveRefLayerPics0( ) const { return (Int) m_refPicSetInterLayer0->size(); };
3294	Int getNumActiveRefLayerPics1( ) const { return (Int) m_refPicSetInterLayer1->size(); };
3295
3296	Int getRefPicLayerId ( Int i ) const;
3297
3298	Void setRefPicSetInterLayer ( std::vector<TComPic> refPicSetInterLayer0, std::vector<TComPic> refPicSetInterLayer1);
3299	TComPic* getPicFromRefPicSetInterLayer ( Int setIdc, Int layerId ) const ;
3300
3301	#if NH_3D
3302	// 3D-HEVC tool parameters
3303	Void deriveInCmpPredAndCpAvailFlag( );
3304	Void init3dToolParameters();
3305	Void checkInCompPredRefLayers();
3306
3307	Bool getIvMvPredFlag ( ) { return m_ivMvPredFlag ; };
3308	Bool getIvMvScalingFlag ( ) { return m_ivMvScalingFlag ; };
3309	Bool getIvResPredFlag ( ) { return m_ivResPredFlag ; };
3310	Bool getDepthRefinementFlag ( ) { return m_depthRefinementFlag ; };
3311	Bool getViewSynthesisPredFlag ( ) { return m_viewSynthesisPredFlag ; };
3312	Bool getDepthBasedBlkPartFlag ( ) { return m_depthBasedBlkPartFlag ; };
3313	Bool getMpiFlag ( ) { return m_mpiFlag ; };
3314	Bool getIntraContourFlag ( ) { return m_intraContourFlag ; };
3315	Bool getIntraSdcWedgeFlag ( ) { return m_intraSdcWedgeFlag ; };
3316	Bool getQtPredFlag ( ) { return m_qtPredFlag ; };
3317	Bool getInterSdcFlag ( ) { return m_interSdcFlag ; };
3318	Bool getDepthIntraSkipFlag ( ) { return m_depthIntraSkipFlag ; };
3319
3320	Int getMpiSubPbSize ( ) { return m_mpiSubPbSize ; };
3321	Int getSubPbSize ( ) { return m_subPbSize ; };
3322
3323	Int getDefaultRefViewIdx() { return m_iDefaultRefViewIdx; }
3324	Void setDefaultRefViewIdx(Int iViewIdx) { m_iDefaultRefViewIdx = iViewIdx; }
3325
3326	Bool getDefaultRefViewIdxAvailableFlag() { return m_bDefaultRefViewIdxAvailableFlag; }
3327	Void setDefaultRefViewIdxAvailableFlag(Bool bViewIdx) { m_bDefaultRefViewIdxAvailableFlag = bViewIdx; }
3328	Void setDefaultRefView( );
3329	#endif
3330	#if NH_MV
3331	TComPic* getRefPicSetInterLayer( Int setIdc, Int i ) const;
3332	#endif
3333
3334	// Inference
3335	#if NH_MV
3336	Bool inferPocMsbCycleValPresentFlag();
3337	#else
3338	Bool inferPocMsbValPresentFlag();
3339	#endif
3340	#endif
3341	protected:
3342	TComPic* xGetRefPic (TComList<TComPic*>& rcListPic, Int poc);
3343	TComPic* xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb);
3344	#if NH_MV
3345	TComPic* xGetInterLayerRefPic( std::vector<TComPic*>& rcListIlPic, Int layerId );
3346	#endif
3347	};// END CLASS DEFINITION TComSlice
3348
3349
3350	Void calculateParameterSetChangedFlag(Bool &bChanged, const std::vector<UChar> pOldData, const std::vector<UChar> pNewData);
3351
3352	template <class T> class ParameterSetMap
3353	{
3354	public:
3355	template <class Tm>
3356	struct MapData
3357	{
3358	Bool bChanged;
3359	std::vector<UChar> *pNaluData; // Can be null
3360	Tm* parameterSet;
3361	};
3362
3363	ParameterSetMap(Int maxId)
3364	:m_maxId (maxId)
3365	{}
3366
3367	~ParameterSetMap()
3368	{
3369	for (typename std::map<Int,MapData<T> >::iterator i = m_paramsetMap.begin(); i!= m_paramsetMap.end(); i++)
3370	{
3371	delete (*i).second.pNaluData;
3372	delete (*i).second.parameterSet;
3373	}
3374	}
3375
3376	T *allocatePS(const Int psId)
3377	{
3378	assert ( psId < m_maxId );
3379	if ( m_paramsetMap.find(psId) == m_paramsetMap.end() )
3380	{
3381	m_paramsetMap[psId].bChanged = true;
3382	m_paramsetMap[psId].pNaluData=0;
3383	m_paramsetMap[psId].parameterSet = new T;
3384	setID(m_paramsetMap[psId].parameterSet, psId);
3385	}
3386	return m_paramsetMap[psId].parameterSet;
3387	}
3388
3389	Void storePS(Int psId, T ps, const std::vector<UChar> pNaluData)
3390	{
3391	assert ( psId < m_maxId );
3392	if ( m_paramsetMap.find(psId) != m_paramsetMap.end() )
3393	{
3394	MapData<T> &mapData=m_paramsetMap[psId];
3395
3396	// work out changed flag
3397	calculateParameterSetChangedFlag(mapData.bChanged, mapData.pNaluData, pNaluData);
3398	delete m_paramsetMap[psId].pNaluData;
3399	delete m_paramsetMap[psId].parameterSet;
3400
3401	m_paramsetMap[psId].parameterSet = ps;
3402	}
3403	else
3404	{
3405	m_paramsetMap[psId].parameterSet = ps;
3406	m_paramsetMap[psId].bChanged = false;
3407	}
3408	if (pNaluData != 0)
3409	{
3410	m_paramsetMap[psId].pNaluData=new std::vector<UChar>;
3411	(m_paramsetMap[psId].pNaluData) = pNaluData;
3412	}
3413	else
3414	{
3415	m_paramsetMap[psId].pNaluData=0;
3416	}
3417	}
3418
3419	Void setChangedFlag(Int psId, Bool bChanged=true)
3420	{
3421	if ( m_paramsetMap.find(psId) != m_paramsetMap.end() )
3422	{
3423	m_paramsetMap[psId].bChanged=bChanged;
3424	}
3425	}
3426
3427	Void clearChangedFlag(Int psId)
3428	{
3429	if ( m_paramsetMap.find(psId) != m_paramsetMap.end() )
3430	{
3431	m_paramsetMap[psId].bChanged=false;
3432	}
3433	}
3434
3435	Bool getChangedFlag(Int psId) const
3436	{
3437	const typename std::map<Int,MapData<T> >::const_iterator constit=m_paramsetMap.find(psId);
3438	if ( constit != m_paramsetMap.end() )
3439	{
3440	return constit->second.bChanged;
3441	}
3442	return false;
3443	}
3444
3445	T* getPS(Int psId)
3446	{
3447	typename std::map<Int,MapData<T> >::iterator it=m_paramsetMap.find(psId);
3448	return ( it == m_paramsetMap.end() ) ? NULL : (it)->second.parameterSet;
3449	}
3450
3451	const T* getPS(Int psId) const
3452	{
3453	typename std::map<Int,MapData<T> >::const_iterator it=m_paramsetMap.find(psId);
3454	return ( it == m_paramsetMap.end() ) ? NULL : (it)->second.parameterSet;
3455	}
3456
3457	T* getFirstPS()
3458	{
3459	return (m_paramsetMap.begin() == m_paramsetMap.end() ) ? NULL : m_paramsetMap.begin()->second.parameterSet;
3460	}
3461
3462	private:
3463	std::map<Int,MapData<T> > m_paramsetMap;
3464	Int m_maxId;
3465
3466	static Void setID(T* parameterSet, const Int psId);
3467	};
3468
3469	class ParameterSetManager
3470	{
3471	public:
3472	ParameterSetManager();
3473	virtual ~ParameterSetManager();
3474
3475	//! store sequence parameter set and take ownership of it
3476	Void storeVPS(TComVPS *vps, const std::vector<UChar> &naluData) { m_vpsMap.storePS( vps->getVPSId(), vps, &naluData); };
3477	//! get pointer to existing video parameter set
3478	TComVPS* getVPS(Int vpsId) { return m_vpsMap.getPS(vpsId); };
3479	Bool getVPSChangedFlag(Int vpsId) const { return m_vpsMap.getChangedFlag(vpsId); }
3480	Void clearVPSChangedFlag(Int vpsId) { m_vpsMap.clearChangedFlag(vpsId); }
3481	TComVPS* getFirstVPS() { return m_vpsMap.getFirstPS(); };
3482
3483	//! store sequence parameter set and take ownership of it
3484	Void storeSPS(TComSPS *sps, const std::vector<UChar> &naluData) { m_spsMap.storePS( sps->getSPSId(), sps, &naluData); };
3485	//! get pointer to existing sequence parameter set
3486	TComSPS* getSPS(Int spsId) { return m_spsMap.getPS(spsId); };
3487	Bool getSPSChangedFlag(Int spsId) const { return m_spsMap.getChangedFlag(spsId); }
3488	Void clearSPSChangedFlag(Int spsId) { m_spsMap.clearChangedFlag(spsId); }
3489	TComSPS* getFirstSPS() { return m_spsMap.getFirstPS(); };
3490
3491	//! store picture parameter set and take ownership of it
3492	Void storePPS(TComPPS *pps, const std::vector<UChar> &naluData) { m_ppsMap.storePS( pps->getPPSId(), pps, &naluData); };
3493	//! get pointer to existing picture parameter set
3494	TComPPS* getPPS(Int ppsId) { return m_ppsMap.getPS(ppsId); };
3495	Bool getPPSChangedFlag(Int ppsId) const { return m_ppsMap.getChangedFlag(ppsId); }
3496	Void clearPPSChangedFlag(Int ppsId) { m_ppsMap.clearChangedFlag(ppsId); }
3497	TComPPS* getFirstPPS() { return m_ppsMap.getFirstPS(); };
3498
3499	//! activate a SPS from a active parameter sets SEI message
3500	//! \returns true, if activation is successful
3501	#if NH_MV
3502	// Bool activateSPSWithSEI(Int SPSId, Int layerId );
3503	#else
3504	// Bool activateSPSWithSEI(Int SPSId);
3505	#endif
3506
3507	//! activate a PPS and depending on isIDR parameter also SPS and VPS
3508	//! \returns true, if activation is successful
3509	#if NH_MV
3510	Bool activatePPS(Int ppsId, Bool isIRAP, Int layerId );
3511	#else
3512	Bool activatePPS(Int ppsId, Bool isIRAP);
3513	#endif
3514
3515	const TComVPS* getActiveVPS()const { return m_vpsMap.getPS(m_activeVPSId); };
3516
3517	#if NH_MV
3518	const TComSPS* getActiveSPS( Int layer )const { return m_spsActiveForLayer.getPS(layer); };
3519	#else
3520	const TComSPS* getActiveSPS()const { return m_spsMap.getPS(m_activeSPSId); };
3521	#endif
3522
3523	#if NH_MV
3524	Void setSpsActiveForLayer( Int layer, TComSPS*& ps )
3525	{
3526	TComSPS* psCopy = m_spsActiveForLayer.allocatePS( layer );
3527	(psCopy) = (ps);
3528	ps = psCopy;
3529	}
3530	#endif
3531	protected:
3532	ParameterSetMap<TComVPS> m_vpsMap;
3533	ParameterSetMap<TComSPS> m_spsMap;
3534	ParameterSetMap<TComPPS> m_ppsMap;
3535
3536	#if NH_MV
3537	// As several SPS syntax elements be might inferred depending for the current layer, copies are stored for each layer
3538	ParameterSetMap<TComSPS> m_spsActiveForLayer;
3539	#endif
3540
3541	Int m_activeVPSId; // -1 for nothing active
3542	#if NH_MV
3543	Int m_activeSPSId[ MAX_NUM_LAYERS ]; // -1 for nothing active
3544	#else
3545	Int m_activeSPSId; // -1 for nothing active
3546	#endif
3547	};
3548
3549	//! \}
3550
3551	#endif // __TCOMSLICE__

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/trunk/source/Lib/TLibCommon/TComSlice.h

Download in other formats: