Context navigation

TComSlice.h @ 213

Visit:

Last change on this file since 213 was 213, checked in by mitsubishi-htm, 12 years ago

A final release, as planned

Migrate to HTM 5.1
For VC project files, only VC9 file is updated
To be used as an additional anchor for CE1.h for 3rd JCTVC meeting at Geneva

Property svn:eol-style set to native

File size: 82.4 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2012, ITU/ISO/IEC
7	* All rights reserved.
8	*
9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions are met:
11	*
12	* * Redistributions of source code must retain the above copyright notice,
13	* this list of conditions and the following disclaimer.
14	* * Redistributions in binary form must reproduce the above copyright notice,
15	* this list of conditions and the following disclaimer in the documentation
16	* and/or other materials provided with the distribution.
17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18	* be used to endorse or promote products derived from this software without
19	* specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31	* THE POSSIBILITY OF SUCH DAMAGE.
32	*/
33
34	/** \file TComSlice.h
35	\brief slice header and SPS class (header)
36	*/
37
38	#ifndef __TCOMSLICE__
39	#define __TCOMSLICE__
40
41	#include <cstring>
42	#include <map>
43	#include <vector>
44	#include "CommonDef.h"
45	#include "TComRom.h"
46	#include "TComList.h"
47
48	//! \ingroup TLibCommon
49	//! \{
50
51	class TComPic;
52	class TComTrQuant;
53	#if DEPTH_MAP_GENERATION
54	class TComDepthMapGenerator;
55	#endif
56	#if HHI_INTER_VIEW_RESIDUAL_PRED
57	class TComResidualGenerator;
58	#endif
59	// ====================================================================================================================
60	// Constants
61	// ====================================================================================================================
62
63	/// max number of supported APS in software
64	#define MAX_NUM_SUPPORTED_APS 1
65
66	// ====================================================================================================================
67	// Class definition
68	// ====================================================================================================================
69
70	#if RPS_IN_SPS
71	/// Reference Picture Set class
72	class TComReferencePictureSet
73	{
74	private:
75	Int m_numberOfPictures;
76	Int m_numberOfNegativePictures;
77	Int m_numberOfPositivePictures;
78	Int m_numberOfLongtermPictures;
79	Int m_deltaPOC[MAX_NUM_REF_PICS];
80	Int m_POC[MAX_NUM_REF_PICS];
81	Bool m_used[MAX_NUM_REF_PICS];
82	Bool m_interRPSPrediction;
83	Int m_deltaRIdxMinus1;
84	Int m_deltaRPS;
85	Int m_numRefIdc;
86	Int m_refIdc[MAX_NUM_REF_PICS+1];
87
88	public:
89	TComReferencePictureSet();
90	virtual ~TComReferencePictureSet();
91
92	Void setNumberOfPictures(Int numberOfPictures);
93	Int getNumberOfPictures();
94	Void setNumberOfNegativePictures(Int number) { m_numberOfNegativePictures = number; }
95	Int getNumberOfNegativePictures() { return m_numberOfNegativePictures; }
96	Void setNumberOfPositivePictures(Int number) { m_numberOfPositivePictures = number; }
97	Int getNumberOfPositivePictures() { return m_numberOfPositivePictures; }
98	Void setNumberOfLongtermPictures(Int number) { m_numberOfLongtermPictures = number; }
99	Int getNumberOfLongtermPictures() { return m_numberOfLongtermPictures; }
100
101	Void setDeltaPOC(Int bufferNum, Int deltaPOC);
102	Int getDeltaPOC(Int bufferNum);
103	Void setPOC(Int bufferNum, Int deltaPOC);
104	Int getPOC(Int bufferNum);
105
106	Void setUsed(Int bufferNum, Bool used);
107	Int getUsed(Int bufferNum);
108
109	Void setInterRPSPrediction(Bool flag) { m_interRPSPrediction = flag; }
110	Bool getInterRPSPrediction() { return m_interRPSPrediction; }
111	Void setDeltaRIdxMinus1(Int x) { m_deltaRIdxMinus1 = x; }
112	Int getDeltaRIdxMinus1() { return m_deltaRIdxMinus1; }
113	Void setDeltaRPS(Int x) { m_deltaRPS = x; }
114	Int getDeltaRPS() { return m_deltaRPS; }
115	Void setNumRefIdc(Int x) { m_numRefIdc = x; }
116	Int getNumRefIdc() { return m_numRefIdc; }
117
118	Void setRefIdc(Int bufferNum, Int refIdc);
119	Int getRefIdc(Int bufferNum);
120
121	Void sortDeltaPOC();
122	Void printDeltaPOC();
123	};
124
125	/// Reference Picture Set set class
126	class TComRPSList
127	{
128	private:
129	Int m_numberOfReferencePictureSets;
130	TComReferencePictureSet* m_referencePictureSets;
131
132	public:
133	TComRPSList();
134	virtual ~TComRPSList();
135
136	Void create (Int numberOfEntries);
137	Void destroy ();
138
139
140	TComReferencePictureSet* getReferencePictureSet(Int referencePictureSetNum);
141	Int getNumberOfReferencePictureSets();
142	Void setNumberOfReferencePictureSets(Int numberOfReferencePictureSets);
143	};
144	#endif
145
146	#if VIDYO_VPS_INTEGRATION\|QC_MVHEVC_B0046
147	/// VPS class
148
149	class TComVPS
150	{
151	private:
152	Int m_VPSId;
153	UInt m_uiMaxTLayers;
154	UInt m_uiMaxLayers;
155	Bool m_bTemporalIdNestingFlag;
156
157	UInt m_uiExtensionType;
158	#if !QC_MVHEVC_B0046
159	Bool m_bDependentFlag[MAX_LAYER_NUM];
160	#else
161	UInt m_uiNumHRDParameter;
162	UInt m_numAddiLayerOperationPoints;
163	UInt m_numAddiProLevelSets;
164	UInt m_numDirectRefLayer[MAX_LAYER_NUM];
165	UInt m_numDirectRefID[MAX_LAYER_NUM][MAX_LAYER_NUM];
166	UInt m_numOpLayerIdMinus1[MAX_LAYER_NUM];
167	UInt m_numOpLayerId[MAX_LAYER_NUM][MAX_LAYER_NUM];
168	#endif
169	UInt m_uiViewId[MAX_LAYER_NUM];
170	#if !QC_MVHEVC_B0046
171	Bool m_bDepthFlag[MAX_LAYER_NUM];
172	#endif
173	Int m_iViewOrderIdx[MAX_LAYER_NUM];
174	#if !QC_MVHEVC_B0046
175	UInt m_uiDependentLayer[MAX_LAYER_NUM];
176	#endif
177
178	UInt m_numReorderPics[MAX_TLAYER];
179	UInt m_uiMaxDecPicBuffering[MAX_TLAYER];
180	UInt m_uiMaxLatencyIncrease[MAX_TLAYER];
181
182	public:
183	TComVPS();
184	virtual ~TComVPS();
185
186	Int getVPSId () { return m_VPSId; }
187	Void setVPSId (Int i) { m_VPSId = i; }
188
189	UInt getMaxTLayers () { return m_uiMaxTLayers; }
190	Void setMaxTLayers (UInt t) { m_uiMaxTLayers = t; }
191
192	UInt getMaxLayers () { return m_uiMaxLayers; }
193	Void setMaxLayers (UInt l) { m_uiMaxLayers = l; }
194
195	Bool getTemporalNestingFlag () { return m_uiMaxLayers; }
196	Void setTemporalNestingFlag (UInt t) { m_bTemporalIdNestingFlag = t; }
197	#if !QC_MVHEVC_B0046
198	Void setExtensionType(UInt v) { m_uiExtensionType = v; }
199	UInt getExtensionType() { return m_uiExtensionType; }
200
201	Void setDependentFlag(Bool d, UInt layer) { m_bDependentFlag[layer] = d; }
202	Bool getDependentFlag(UInt layer) { return m_bDependentFlag[layer]; }
203	#endif
204	Void setViewId(UInt v, UInt layer) { m_uiViewId[layer] = v; }
205	UInt getViewId(UInt layer) { return m_uiViewId[layer]; }
206	#if !QC_MVHEVC_B0046
207	Void setDepthFlag(Bool d, UInt layer) { m_bDepthFlag[layer] = d; }
208	Bool getDepthFlag(UInt layer) { return m_bDepthFlag[layer]; }
209	#endif
210	Void setViewOrderIdx(Int v, UInt layer) { m_iViewOrderIdx[layer] = v; }
211	Int getViewOrderIdx(UInt layer) { return m_iViewOrderIdx[layer]; }
212	#if !QC_MVHEVC_B0046
213	Void setDependentLayer(UInt v, UInt layer) { m_uiDependentLayer[layer] = v; }
214	UInt getDependentLayer(UInt layer) { return m_uiDependentLayer[layer]; }
215	#endif
216	Void setNumReorderPics(UInt v, UInt tLayer) { m_numReorderPics[tLayer] = v; }
217	UInt getNumReorderPics(UInt tLayer) { return m_numReorderPics[tLayer]; }
218
219	Void setMaxDecPicBuffering(UInt v, UInt tLayer) { m_uiMaxDecPicBuffering[tLayer] = v; }
220	UInt getMaxDecPicBuffering(UInt tLayer) { return m_uiMaxDecPicBuffering[tLayer]; }
221
222	Void setMaxLatencyIncrease(UInt v, UInt tLayer) { m_uiMaxLatencyIncrease[tLayer] = v; }
223	UInt getMaxLatencyIncrease(UInt tLayer) { return m_uiMaxLatencyIncrease[tLayer]; }
224	#if QC_MVHEVC_B0046
225	Void setNumHRDParameters(UInt n) { m_uiNumHRDParameter = n; }
226	UInt getNumHRDParameters() { return m_uiNumHRDParameter; }
227	Void setNumDirectRefLayer(UInt n, UInt layer) { m_numDirectRefLayer[layer] = n; };
228	UInt getNumDirectRefLayer(UInt layer) { return m_numDirectRefLayer[layer]; };
229	Void setDirectRefLayerId (UInt n, UInt layer, UInt refId) { m_numDirectRefID[layer][refId] = n; assert(refId < MAX_NUM_REF ); };
230	UInt getDirectRefLayerId ( UInt layer, UInt refId) { return m_numDirectRefID[layer][refId]; };
231	UInt getNumAddiLayerOperationPoints( ) { return m_numAddiLayerOperationPoints; };
232	Void setNumAddiLayerOperationPoints(UInt n) { m_numAddiLayerOperationPoints = n; };
233	Void setNumAddiProLevelSets (UInt n) { m_numAddiProLevelSets = n;}
234	UInt getNumAddiProLevelSets ( ) { return m_numAddiProLevelSets;}
235
236	Void setNumOpLayerIdMinus1 (UInt n, UInt layer) { m_numOpLayerIdMinus1[layer] = n;}
237	UInt getNumOpLayerIdMinus1 (UInt layer ) { return m_numOpLayerIdMinus1[layer];}
238
239	Void setNumOpLayerId (UInt n, UInt layer, UInt OpId) { m_numOpLayerId[layer][OpId] = n;}
240	UInt getNumOpLayerId (UInt layer, UInt OpId ) { return m_numOpLayerId[layer][OpId];}
241
242	#endif
243	};
244
245	#endif
246
247	/// SPS class
248	class TComSPS
249	{
250	private:
251	#if VIDYO_VPS_INTEGRATION\|QC_MVHEVC_B0046
252	Int m_VPSId;
253	#endif
254	Int m_SPSId;
255	Int m_ProfileIdc;
256	Int m_LevelIdc;
257	Int m_chromaFormatIdc;
258
259	UInt m_uiMaxTLayers; // maximum number of temporal layers
260
261	UInt m_uiViewId;
262	Int m_iViewOrderIdx;
263	Bool m_bDepth;
264	UInt m_uiCamParPrecision;
265	Bool m_bCamParInSliceHeader;
266	Int m_aaiCodedScale [2][MAX_VIEW_NUM];
267	Int m_aaiCodedOffset[2][MAX_VIEW_NUM];
268
269	// Structure
270	UInt m_picWidthInLumaSamples;
271	UInt m_picHeightInLumaSamples;
272	#if PIC_CROPPING
273	Bool m_picCroppingFlag;
274	Int m_picCropLeftOffset;
275	Int m_picCropRightOffset;
276	Int m_picCropTopOffset;
277	Int m_picCropBottomOffset;
278	#else
279	Int m_aiPad[2];
280	#endif
281	UInt m_uiMaxCUWidth;
282	UInt m_uiMaxCUHeight;
283	UInt m_uiMaxCUDepth;
284	UInt m_uiMinTrDepth;
285	UInt m_uiMaxTrDepth;
286	#if RPS_IN_SPS
287	TComRPSList* m_RPSList;
288	Bool m_bLongTermRefsPresent;
289	#endif
290	#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
291	Int m_numReorderPics[MAX_TLAYER];
292	#else
293	Int m_maxNumberOfReferencePictures;
294	Int m_numReorderFrames;
295	#endif
296
297	Int m_iNumberOfUsableInterViewRefs;
298	Int m_aiUsableInterViewRefs[MAX_VIEW_NUM];
299
300	// Tool list
301	UInt m_uiQuadtreeTULog2MaxSize;
302	UInt m_uiQuadtreeTULog2MinSize;
303	UInt m_uiQuadtreeTUMaxDepthInter;
304	UInt m_uiQuadtreeTUMaxDepthIntra;
305	Bool m_usePCM;
306	UInt m_pcmLog2MaxSize;
307	UInt m_uiPCMLog2MinSize;
308	Bool m_bDisInter4x4;
309	Bool m_useAMP;
310	Bool m_bUseALF;
311	#if LCU_SYNTAX_ALF
312	Bool m_bALFCoefInSlice;
313	#endif
314	#if !PIC_CROPPING
315	Bool m_bUsePAD;
316	#endif
317	Bool m_bUseLMChroma; // JL:
318
319	Bool m_bUseLComb;
320	Bool m_bLCMod;
321	Bool m_useNSQT;
322
323	#if H0412_REF_PIC_LIST_RESTRICTION
324	Bool m_restrictedRefPicListsFlag;
325	Bool m_listsModificationPresentFlag;
326	#endif
327
328	// Parameter
329	AMVP_MODE m_aeAMVPMode[MAX_CU_DEPTH];
330	UInt m_uiBitDepth;
331	UInt m_uiBitIncrement;
332	#if H0736_AVC_STYLE_QP_RANGE
333	Int m_qpBDOffsetY;
334	Int m_qpBDOffsetC;
335	#endif
336
337	#if LOSSLESS_CODING
338	Bool m_useLossless;
339	#endif
340
341	UInt m_uiPCMBitDepthLuma;
342	UInt m_uiPCMBitDepthChroma;
343	Bool m_bPCMFilterDisableFlag;
344
345	UInt m_uiBitsForPOC;
346	// Max physical transform size
347	UInt m_uiMaxTrSize;
348
349	Int m_iAMPAcc[MAX_CU_DEPTH];
350
351	Bool m_bLFCrossSliceBoundaryFlag;
352	Bool m_bUseSAO;
353	#if HHI_MPI
354	Bool m_bUseMVI;
355	#endif
356
357	#if RWTH_SDC_DLT_B0036
358	Bool m_bUseDLT;
359
360	UInt m_uiBitsPerDepthValue;
361	UInt m_uiNumDepthmapValues;
362	UInt* m_uiDepthValue2Idx;
363	UInt* m_uiIdx2DepthValue;
364	#endif
365
366	Bool m_bLFCrossTileBoundaryFlag;
367	Int m_iUniformSpacingIdr;
368	Int m_iTileBoundaryIndependenceIdr;
369	Int m_iNumColumnsMinus1;
370	UInt* m_puiColumnWidth;
371	Int m_iNumRowsMinus1;
372	UInt* m_puiRowHeight;
373
374	Bool m_bTemporalIdNestingFlag; // temporal_id_nesting_flag
375
376	Bool m_scalingListEnabledFlag;
377	#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
378	UInt m_uiMaxDecPicBuffering[MAX_TLAYER];
379	UInt m_uiMaxLatencyIncrease[MAX_TLAYER];
380	#else
381	UInt m_uiMaxDecFrameBuffering;
382	UInt m_uiMaxLatencyIncrease;
383	#endif
384
385	Bool m_useDF;
386
387	#if TILES_WPP_ENTRY_POINT_SIGNALLING
388	UInt m_tilesOrEntropyCodingSyncIdc;
389	Int m_numSubstreams;
390	#endif
391
392	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
393	Bool m_bUseDMM;
394	#endif
395
396	#if HHI_DMM_PRED_TEX && FLEX_CODING_ORDER_M23723
397	Bool m_bUseDMM34;
398	#endif
399
400	#if OL_QTLIMIT_PREDCODING_B0068
401	Bool m_bUseQTLPC;
402	#endif
403
404	#if DEPTH_MAP_GENERATION
405	UInt m_uiPredDepthMapGeneration;
406	UInt m_uiPdmPrecision;
407	Int m_aiPdmScaleNomDelta[MAX_VIEW_NUM];
408	Int m_aiPdmOffset [MAX_VIEW_NUM];
409	#endif
410
411	#if HHI_INTER_VIEW_MOTION_PRED
412	UInt m_uiMultiviewMvPredMode;
413	#endif
414	#if HHI_INTER_VIEW_RESIDUAL_PRED
415	UInt m_uiMultiviewResPredMode;
416	#endif
417
418	#if DEPTH_MAP_GENERATION
419	TComDepthMapGenerator* m_pcDepthMapGenerator;
420	#endif
421	#if HHI_INTER_VIEW_RESIDUAL_PRED
422	TComResidualGenerator* m_pcResidualGenerator;
423	#endif
424
425	#if VSP_N
426	Bool m_bVspPresentFlag;
427	#if VSP_CFG
428	Bool m_bVspDepthPresentFlag;
429	#endif
430	Bool m_bIsFirstInView;
431	#endif
432
433	public:
434	TComSPS();
435	virtual ~TComSPS();
436	#if VIDYO_VPS_INTEGRATION\|QC_MVHEVC_B0046
437	Int getVPSId () { return m_VPSId; }
438	Void setVPSId (Int i) { m_VPSId = i; }
439	#endif
440	Int getSPSId () { return m_SPSId; }
441	Void setSPSId (Int i) { m_SPSId = i; }
442	Int getProfileIdc () { return m_ProfileIdc; }
443	Void setProfileIdc (Int i) { m_ProfileIdc = i; }
444	Int getLevelIdc () { return m_LevelIdc; }
445	Void setLevelIdc (Int i) { m_LevelIdc = i; }
446
447	Int getChromaFormatIdc () { return m_chromaFormatIdc; }
448	Void setChromaFormatIdc (Int i) { m_chromaFormatIdc = i; }
449
450	// structure
451	Void setPicWidthInLumaSamples ( UInt u ) { m_picWidthInLumaSamples = u; }
452	UInt getPicWidthInLumaSamples () { return m_picWidthInLumaSamples; }
453	Void setPicHeightInLumaSamples ( UInt u ) { m_picHeightInLumaSamples = u; }
454	UInt getPicHeightInLumaSamples () { return m_picHeightInLumaSamples; }
455
456	#if PIC_CROPPING
457	Bool getPicCroppingFlag() const { return m_picCroppingFlag; }
458	Void setPicCroppingFlag(Bool val) { m_picCroppingFlag = val; }
459	Int getPicCropLeftOffset() const { return m_picCropLeftOffset; }
460	Void setPicCropLeftOffset(Int val) { m_picCropLeftOffset = val; }
461	Int getPicCropRightOffset() const { return m_picCropRightOffset; }
462	Void setPicCropRightOffset(Int val) { m_picCropRightOffset = val; }
463	Int getPicCropTopOffset() const { return m_picCropTopOffset; }
464	Void setPicCropTopOffset(Int val) { m_picCropTopOffset = val; }
465	Int getPicCropBottomOffset() const { return m_picCropBottomOffset; }
466	Void setPicCropBottomOffset(Int val) { m_picCropBottomOffset = val; }
467	#endif
468
469	Void setMaxCUWidth ( UInt u ) { m_uiMaxCUWidth = u; }
470	UInt getMaxCUWidth () { return m_uiMaxCUWidth; }
471	Void setMaxCUHeight ( UInt u ) { m_uiMaxCUHeight = u; }
472	UInt getMaxCUHeight () { return m_uiMaxCUHeight; }
473	Void setMaxCUDepth ( UInt u ) { m_uiMaxCUDepth = u; }
474	UInt getMaxCUDepth () { return m_uiMaxCUDepth; }
475	Void setUsePCM ( Bool b ) { m_usePCM = b; }
476	Bool getUsePCM () { return m_usePCM; }
477	Void setPCMLog2MaxSize ( UInt u ) { m_pcmLog2MaxSize = u; }
478	UInt getPCMLog2MaxSize () { return m_pcmLog2MaxSize; }
479	Void setPCMLog2MinSize ( UInt u ) { m_uiPCMLog2MinSize = u; }
480	UInt getPCMLog2MinSize () { return m_uiPCMLog2MinSize; }
481	Void setBitsForPOC ( UInt u ) { m_uiBitsForPOC = u; }
482	UInt getBitsForPOC () { return m_uiBitsForPOC; }
483	Bool getDisInter4x4() { return m_bDisInter4x4; }
484	Void setDisInter4x4 ( Bool b ) { m_bDisInter4x4 = b; }
485	Bool getUseAMP() { return m_useAMP; }
486	Void setUseAMP( Bool b ) { m_useAMP = b; }
487	Void setMinTrDepth ( UInt u ) { m_uiMinTrDepth = u; }
488	UInt getMinTrDepth () { return m_uiMinTrDepth; }
489	Void setMaxTrDepth ( UInt u ) { m_uiMaxTrDepth = u; }
490	UInt getMaxTrDepth () { return m_uiMaxTrDepth; }
491	Void setQuadtreeTULog2MaxSize( UInt u ) { m_uiQuadtreeTULog2MaxSize = u; }
492	UInt getQuadtreeTULog2MaxSize() { return m_uiQuadtreeTULog2MaxSize; }
493	Void setQuadtreeTULog2MinSize( UInt u ) { m_uiQuadtreeTULog2MinSize = u; }
494	UInt getQuadtreeTULog2MinSize() { return m_uiQuadtreeTULog2MinSize; }
495	Void setQuadtreeTUMaxDepthInter( UInt u ) { m_uiQuadtreeTUMaxDepthInter = u; }
496	Void setQuadtreeTUMaxDepthIntra( UInt u ) { m_uiQuadtreeTUMaxDepthIntra = u; }
497	UInt getQuadtreeTUMaxDepthInter() { return m_uiQuadtreeTUMaxDepthInter; }
498	UInt getQuadtreeTUMaxDepthIntra() { return m_uiQuadtreeTUMaxDepthIntra; }
499	#if !PIC_CROPPING
500	Void setPad (Int iPad[2]) { m_aiPad[0] = iPad[0]; m_aiPad[1] = iPad[1]; }
501	#endif
502	#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
503	Void setNumReorderPics(Int i, UInt tlayer) { m_numReorderPics[tlayer] = i; }
504	Int getNumReorderPics(UInt tlayer) { return m_numReorderPics[tlayer]; }
505	#else
506	Void setMaxNumberOfReferencePictures( Int u ) { m_maxNumberOfReferencePictures = u; }
507	Int getMaxNumberOfReferencePictures() { return m_maxNumberOfReferencePictures; }
508	Void setNumReorderFrames( Int i ) { m_numReorderFrames = i; }
509	Int getNumReorderFrames() { return m_numReorderFrames; }
510	#endif
511	#if RPS_IN_SPS
512	Void setRPSList( TComRPSList* RPSList ) { m_RPSList = RPSList; }
513	TComRPSList* getRPSList() { return m_RPSList; }
514	Bool getLongTermRefsPresent() { return m_bLongTermRefsPresent; }
515	Void setLongTermRefsPresent(Bool b) { m_bLongTermRefsPresent=b; }
516	#endif
517
518	Void setNumberOfUsableInterViewRefs( Int number ) { m_iNumberOfUsableInterViewRefs = number; }
519	Int getNumberOfUsableInterViewRefs() { return m_iNumberOfUsableInterViewRefs; }
520	Void setUsableInterViewRef( Int pos, Int deltaViewId ) { m_aiUsableInterViewRefs[pos] = deltaViewId; }
521	Int getUsableInterViewRef( Int pos ) { return m_aiUsableInterViewRefs[pos]; }
522
523	#if !PIC_CROPPING
524	Void setPadX ( Int u ) { m_aiPad[0] = u; }
525	Void setPadY ( Int u ) { m_aiPad[1] = u; }
526	Int getPad ( Int u ) { assert(u < 2); return m_aiPad[u];}
527	Int* getPad ( ) { return m_aiPad; }
528	#endif
529
530	// physical transform
531	Void setMaxTrSize ( UInt u ) { m_uiMaxTrSize = u; }
532	UInt getMaxTrSize () { return m_uiMaxTrSize; }
533
534	// Tool list
535	Bool getUseALF () { return m_bUseALF; }
536	#if LCU_SYNTAX_ALF
537	Void setUseALFCoefInSlice(Bool b) {m_bALFCoefInSlice = b;}
538	Bool getUseALFCoefInSlice() {return m_bALFCoefInSlice;}
539	#endif
540
541	#if !PIC_CROPPING
542	Bool getUsePAD () { return m_bUsePAD; }
543	Void setUsePAD ( Bool b ) { m_bUsePAD = b; }
544	#endif
545	Void setUseALF ( Bool b ) { m_bUseALF = b; }
546	Void setUseLComb (Bool b) { m_bUseLComb = b; }
547	Bool getUseLComb () { return m_bUseLComb; }
548	Void setLCMod (Bool b) { m_bLCMod = b; }
549	Bool getLCMod () { return m_bLCMod; }
550
551	Bool getUseLMChroma () { return m_bUseLMChroma; }
552	Void setUseLMChroma ( Bool b ) { m_bUseLMChroma = b; }
553
554	#if LOSSLESS_CODING
555	Bool getUseLossless () { return m_useLossless; }
556	Void setUseLossless ( Bool b ) { m_useLossless = b; }
557	#endif
558	Bool getUseNSQT() { return m_useNSQT; }
559	Void setUseNSQT( Bool b ) { m_useNSQT = b; }
560
561	#if H0412_REF_PIC_LIST_RESTRICTION
562	Bool getRestrictedRefPicListsFlag () { return m_restrictedRefPicListsFlag; }
563	Void setRestrictedRefPicListsFlag ( Bool b ) { m_restrictedRefPicListsFlag = b; }
564	Bool getListsModificationPresentFlag () { return m_listsModificationPresentFlag; }
565	Void setListsModificationPresentFlag ( Bool b ) { m_listsModificationPresentFlag = b; }
566	#endif
567
568	// AMVP mode (for each depth)
569	AMVP_MODE getAMVPMode ( UInt uiDepth ) { assert(uiDepth < g_uiMaxCUDepth); return m_aeAMVPMode[uiDepth]; }
570	Void setAMVPMode ( UInt uiDepth, AMVP_MODE eMode) { assert(uiDepth < g_uiMaxCUDepth); m_aeAMVPMode[uiDepth] = eMode; }
571
572	// AMP accuracy
573	Int getAMPAcc ( UInt uiDepth ) { return m_iAMPAcc[uiDepth]; }
574	Void setAMPAcc ( UInt uiDepth, Int iAccu ) { assert( uiDepth < g_uiMaxCUDepth); m_iAMPAcc[uiDepth] = iAccu; }
575
576	// Bit-depth
577	UInt getBitDepth () { return m_uiBitDepth; }
578	Void setBitDepth ( UInt u ) { m_uiBitDepth = u; }
579	UInt getBitIncrement () { return m_uiBitIncrement; }
580	Void setBitIncrement ( UInt u ) { m_uiBitIncrement = u; }
581	#if H0736_AVC_STYLE_QP_RANGE
582	Int getQpBDOffsetY () { return m_qpBDOffsetY; }
583	Void setQpBDOffsetY ( Int value ) { m_qpBDOffsetY = value; }
584	Int getQpBDOffsetC () { return m_qpBDOffsetC; }
585	Void setQpBDOffsetC ( Int value ) { m_qpBDOffsetC = value; }
586	#endif
587
588	Void setLFCrossSliceBoundaryFlag ( Bool bValue ) { m_bLFCrossSliceBoundaryFlag = bValue; }
589	Bool getLFCrossSliceBoundaryFlag () { return m_bLFCrossSliceBoundaryFlag; }
590
591	Void setUseDF ( Bool b ) { m_useDF = b; }
592	Bool getUseDF () { return m_useDF; }
593
594	Void setUseSAO (Bool bVal) {m_bUseSAO = bVal;}
595	Bool getUseSAO () {return m_bUseSAO;}
596
597	#if HHI_MPI
598	Void setUseMVI (Bool bVal) {m_bUseMVI = bVal;}
599	Bool getUseMVI () {return m_bUseMVI;}
600	#endif
601
602	#if RWTH_SDC_DLT_B0036
603	Bool getUseDLT () { return m_bUseDLT; }
604	Void setUseDLT ( Bool b ) { m_bUseDLT = b; }
605
606	UInt getBitsPerDepthValue() { return m_bUseDLT?m_uiBitsPerDepthValue:g_uiBitDepth; }
607	UInt getNumDepthValues() { return m_bUseDLT?m_uiNumDepthmapValues:g_uiIBDI_MAX; }
608	UInt depthValue2idx(Pel uiValue) { return m_bUseDLT?m_uiDepthValue2Idx[uiValue]:uiValue; }
609	Pel idx2DepthValue(UInt uiIdx) { return m_bUseDLT?m_uiIdx2DepthValue[uiIdx]:uiIdx; }
610	Void setDepthLUTs (UInt* uidx2DepthValue = NULL, UInt uiNumDepthValues = 0);
611	#endif
612
613	UInt getMaxTLayers() { return m_uiMaxTLayers; }
614	Void setMaxTLayers( UInt uiMaxTLayers ) { assert( uiMaxTLayers <= MAX_TLAYER ); m_uiMaxTLayers = uiMaxTLayers; }
615
616	Bool getTemporalIdNestingFlag() { return m_bTemporalIdNestingFlag; }
617	Void setTemporalIdNestingFlag( Bool bValue ) { m_bTemporalIdNestingFlag = bValue; }
618	UInt getPCMBitDepthLuma () { return m_uiPCMBitDepthLuma; }
619	Void setPCMBitDepthLuma ( UInt u ) { m_uiPCMBitDepthLuma = u; }
620	UInt getPCMBitDepthChroma () { return m_uiPCMBitDepthChroma; }
621	Void setPCMBitDepthChroma ( UInt u ) { m_uiPCMBitDepthChroma = u; }
622	Void setPCMFilterDisableFlag ( Bool bValue ) { m_bPCMFilterDisableFlag = bValue; }
623	Bool getPCMFilterDisableFlag () { return m_bPCMFilterDisableFlag; }
624
625	Void setLFCrossTileBoundaryFlag ( Bool bValue ) { m_bLFCrossTileBoundaryFlag = bValue; }
626	Bool getLFCrossTileBoundaryFlag () { return m_bLFCrossTileBoundaryFlag; }
627	Void setUniformSpacingIdr ( Int i ) { m_iUniformSpacingIdr = i; }
628	Int getUniformSpacingIdr () { return m_iUniformSpacingIdr; }
629	#if !REMOVE_TILE_DEPENDENCE
630	Void setTileBoundaryIndependenceIdr ( Int i ) { m_iTileBoundaryIndependenceIdr = i; }
631	Int getTileBoundaryIndependenceIdr () { return m_iTileBoundaryIndependenceIdr; }
632	#endif
633	Void setNumColumnsMinus1 ( Int i ) { m_iNumColumnsMinus1 = i; }
634	Int getNumColumnsMinus1 () { return m_iNumColumnsMinus1; }
635	Void setColumnWidth ( UInt* columnWidth )
636	{
637	if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
638	{
639	m_puiColumnWidth = new UInt[ m_iNumColumnsMinus1 ];
640
641	for(Int i=0; i<m_iNumColumnsMinus1; i++)
642	{
643	m_puiColumnWidth[i] = columnWidth[i];
644	}
645	}
646	}
647	UInt getColumnWidth (UInt columnIdx) { return *( m_puiColumnWidth + columnIdx ); }
648	Void setNumRowsMinus1( Int i ) { m_iNumRowsMinus1 = i; }
649	Int getNumRowsMinus1() { return m_iNumRowsMinus1; }
650	Void setRowHeight ( UInt* rowHeight )
651	{
652	if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
653	{
654	m_puiRowHeight = new UInt[ m_iNumRowsMinus1 ];
655
656	for(Int i=0; i<m_iNumRowsMinus1; i++)
657	{
658	m_puiRowHeight[i] = rowHeight[i];
659	}
660	}
661	}
662	UInt getRowHeight (UInt rowIdx) { return *( m_puiRowHeight + rowIdx ); }
663	Bool getScalingListFlag () { return m_scalingListEnabledFlag; }
664	Void setScalingListFlag ( Bool b ) { m_scalingListEnabledFlag = b; }
665	#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
666	UInt getMaxDecPicBuffering (UInt tlayer) { return m_uiMaxDecPicBuffering[tlayer]; }
667	Void setMaxDecPicBuffering ( UInt ui, UInt tlayer ) { m_uiMaxDecPicBuffering[tlayer] = ui; }
668	UInt getMaxLatencyIncrease (UInt tlayer) { return m_uiMaxLatencyIncrease[tlayer]; }
669	Void setMaxLatencyIncrease ( UInt ui , UInt tlayer) { m_uiMaxLatencyIncrease[tlayer] = ui; }
670	#else
671	UInt getMaxDecFrameBuffering () { return m_uiMaxDecFrameBuffering; }
672	Void setMaxDecFrameBuffering ( UInt ui ) { m_uiMaxDecFrameBuffering = ui; }
673	UInt getMaxLatencyIncrease () { return m_uiMaxLatencyIncrease; }
674	Void setMaxLatencyIncrease ( UInt ui ) { m_uiMaxLatencyIncrease= ui; }
675	#endif
676	#if TILES_WPP_ENTRY_POINT_SIGNALLING
677	UInt getTilesOrEntropyCodingSyncIdc () { return m_tilesOrEntropyCodingSyncIdc; }
678	Void setTilesOrEntropyCodingSyncIdc ( UInt val ) { m_tilesOrEntropyCodingSyncIdc = val; }
679	Int getNumSubstreams () { return m_numSubstreams; }
680	Void setNumSubstreams ( Int numSubstreams ) { m_numSubstreams = numSubstreams; }
681	#endif
682
683	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
684	Bool getUseDMM() { return m_bUseDMM; }
685	Void setUseDMM( Bool b ) { m_bUseDMM = b; }
686	#endif
687
688	#if HHI_DMM_PRED_TEX && FLEX_CODING_ORDER_M23723
689	Bool getUseDMM34() { return m_bUseDMM34; }
690	Void setUseDMM34( Bool b ) { m_bUseDMM34 = b; }
691	#endif
692
693	#if OL_QTLIMIT_PREDCODING_B0068
694	Void setUseQTLPC( Bool b ) { m_bUseQTLPC = b; }
695	Bool getUseQTLPC() { return m_bUseQTLPC; }
696	#endif
697
698	Void initMultiviewSPS ( UInt uiViewId, Int iViewOrderIdx = 0, UInt uiCamParPrecision = 0, Bool bCamParSlice = false, Int aaiScale = 0, Int aaiOffset = 0 );
699	Void initMultiviewSPSDepth ( UInt uiViewId, Int iViewOrderIdx );
700	#if VSP_N
701	Void initMultiviewSPSFlex ( UInt uiViewId, Int iViewOrderIdx, Bool bDepth, Bool bPresent = 0, UInt uiCamParPrecision = 0, Bool bCamParSlice = false, Int aaiScale = 0, Int aaiOffset = 0 );
702	#endif
703
704	UInt getViewId () { return m_uiViewId; }
705	Int getViewOrderIdx () { return m_iViewOrderIdx; }
706	Bool isDepth () { return m_bDepth; }
707	UInt getCamParPrecision () { return m_uiCamParPrecision; }
708	Bool hasCamParInSliceHeader() { return m_bCamParInSliceHeader; }
709	Int* getCodedScale () { return m_aaiCodedScale [0]; }
710	Int* getCodedOffset () { return m_aaiCodedOffset[0]; }
711	Int* getInvCodedScale () { return m_aaiCodedScale [1]; }
712	Int* getInvCodedOffset () { return m_aaiCodedOffset[1]; }
713
714
715	#if DEPTH_MAP_GENERATION
716	Void setPredDepthMapGeneration( UInt uiViewId, Bool bIsDepth, UInt uiPdmGenMode = 0, UInt uiPdmMvPredMode = 0, UInt uiPdmPrec = 0, Int aaiPdmScaleNomDelta = 0, Int aaiPdmOffset = 0 );
717	#endif
718	#if HHI_INTER_VIEW_RESIDUAL_PRED
719	Void setMultiviewResPredMode ( UInt uiResPrdMode ) { m_uiMultiviewResPredMode = uiResPrdMode; }
720	#endif
721
722	#if DEPTH_MAP_GENERATION
723	UInt getPredDepthMapGeneration() { return m_uiPredDepthMapGeneration; }
724	UInt getPdmPrecision () { return m_uiPdmPrecision; }
725	Int* getPdmScaleNomDelta () { return m_aiPdmScaleNomDelta; }
726	Int* getPdmOffset () { return m_aiPdmOffset; }
727	#endif
728
729	#if HHI_INTER_VIEW_MOTION_PRED
730	UInt getMultiviewMvPredMode () { return m_uiMultiviewMvPredMode; }
731	#endif
732	#if HHI_INTER_VIEW_RESIDUAL_PRED
733	UInt getMultiviewResPredMode () { return m_uiMultiviewResPredMode; }
734	#endif
735
736	#if DEPTH_MAP_GENERATION
737	Void setDepthMapGenerator( TComDepthMapGenerator* pcDepthMapGenerator ) { m_pcDepthMapGenerator = pcDepthMapGenerator; }
738	TComDepthMapGenerator* getDepthMapGenerator() { return m_pcDepthMapGenerator; }
739	#endif
740	#if HHI_INTER_VIEW_RESIDUAL_PRED
741	Void setResidualGenerator( TComResidualGenerator* pcResidualGenerator ) { m_pcResidualGenerator = pcResidualGenerator; }
742	TComResidualGenerator* getResidualGenerator() { return m_pcResidualGenerator; }
743	#endif
744
745	#if VSP_N
746	Void setVspPresentFlag( Bool b ) { m_bVspPresentFlag = b; }
747	Bool getVspPresentFlag() { return m_bVspPresentFlag; }
748	#if VSP_CFG
749	Void setVspDepthPresentFlag( Bool b ) { m_bVspDepthPresentFlag = b; }
750	Bool getVspDepthPresentFlag() { return m_bVspDepthPresentFlag; }
751	#endif
752	Void setIsFirstInView( Bool b ) { m_bIsFirstInView = b; }
753	Bool getIsFirstInView() { return m_bIsFirstInView; }
754	Void copyCameraParameterPre( UInt uiCamParPrecision, Bool bCamParSlice );
755	Void copyCameraParameterPost( Int* aiScale0, Int* aiScale1, Int* aiOffset0, Int* aiOffset1 );
756	#endif
757	};
758
759	#if !RPS_IN_SPS
760	/// Reference Picture Set class
761	class TComReferencePictureSet
762	{
763	private:
764	Int m_numberOfPictures;
765	Int m_numberOfNegativePictures;
766	Int m_numberOfPositivePictures;
767	Int m_numberOfLongtermPictures;
768	Int m_deltaPOC[MAX_NUM_REF_PICS];
769	Int m_POC[MAX_NUM_REF_PICS];
770	Bool m_used[MAX_NUM_REF_PICS];
771	Bool m_interRPSPrediction;
772	Int m_deltaRIdxMinus1;
773	Int m_deltaRPS;
774	Int m_numRefIdc;
775	Int m_refIdc[MAX_NUM_REF_PICS+1];
776
777	public:
778	TComReferencePictureSet();
779	virtual ~TComReferencePictureSet();
780
781	Void setUsed(Int bufferNum, Bool used);
782	Void setDeltaPOC(Int bufferNum, Int deltaPOC);
783	Void setPOC(Int bufferNum, Int deltaPOC);
784	Void setNumberOfPictures(Int numberOfPictures);
785
786	Int getUsed(Int bufferNum);
787	Int getDeltaPOC(Int bufferNum);
788	Int getPOC(Int bufferNum);
789	Int getNumberOfPictures();
790
791	Void setNumberOfNegativePictures(Int number) { m_numberOfNegativePictures = number; }
792	Int getNumberOfNegativePictures() { return m_numberOfNegativePictures; }
793	Void setNumberOfPositivePictures(Int number) { m_numberOfPositivePictures = number; }
794	Int getNumberOfPositivePictures() { return m_numberOfPositivePictures; }
795	Void setNumberOfLongtermPictures(Int number) { m_numberOfLongtermPictures = number; }
796	Int getNumberOfLongtermPictures() { return m_numberOfLongtermPictures; }
797
798	Void setInterRPSPrediction(Bool flag) { m_interRPSPrediction = flag; }
799	Bool getInterRPSPrediction() { return m_interRPSPrediction; }
800	Void setDeltaRIdxMinus1(Int x) { m_deltaRIdxMinus1 = x; }
801	Int getDeltaRIdxMinus1() { return m_deltaRIdxMinus1; }
802	Void setDeltaRPS(Int x) { m_deltaRPS = x; }
803	Int getDeltaRPS() { return m_deltaRPS; }
804	Void setNumRefIdc(Int x) { m_numRefIdc = x; }
805	Int getNumRefIdc() { return m_numRefIdc; }
806
807	Void setRefIdc(Int bufferNum, Int refIdc);
808	Int getRefIdc(Int bufferNum);
809
810	Void sortDeltaPOC();
811	Void printDeltaPOC();
812	};
813
814	/// Reference Picture Set set class
815	class TComRPSList
816	{
817	private:
818	Int m_numberOfReferencePictureSets;
819	TComReferencePictureSet* m_referencePictureSets;
820
821	public:
822	TComRPSList();
823	virtual ~TComRPSList();
824
825	Void create (Int numberOfEntries);
826	Void destroy ();
827
828
829	TComReferencePictureSet* getReferencePictureSet(Int referencePictureSetNum);
830	Int getNumberOfReferencePictureSets();
831	Void setNumberOfReferencePictureSets(Int numberOfReferencePictureSets);
832	};
833	#endif
834
835	/// Reference Picture Lists class
836	class TComRefPicListModification
837	{
838	private:
839	UInt m_bRefPicListModificationFlagL0;
840	UInt m_bRefPicListModificationFlagL1;
841	#if !H0137_0138_LIST_MODIFICATION
842	UInt m_uiNumberOfRefPicListModificationsL0;
843	UInt m_uiNumberOfRefPicListModificationsL1;
844	UInt m_ListIdcL0[32];
845	#endif
846	UInt m_RefPicSetIdxL0[32];
847	#if !H0137_0138_LIST_MODIFICATION
848	UInt m_ListIdcL1[32];
849	#endif
850	UInt m_RefPicSetIdxL1[32];
851
852	public:
853	TComRefPicListModification();
854	virtual ~TComRefPicListModification();
855
856	Void create ();
857	Void destroy ();
858
859	Bool getRefPicListModificationFlagL0() { return m_bRefPicListModificationFlagL0; }
860	Void setRefPicListModificationFlagL0(Bool flag) { m_bRefPicListModificationFlagL0 = flag; }
861	Bool getRefPicListModificationFlagL1() { return m_bRefPicListModificationFlagL1; }
862	Void setRefPicListModificationFlagL1(Bool flag) { m_bRefPicListModificationFlagL1 = flag; }
863	#if !H0137_0138_LIST_MODIFICATION
864	UInt getNumberOfRefPicListModificationsL0() { return m_uiNumberOfRefPicListModificationsL0; }
865	Void setNumberOfRefPicListModificationsL0(UInt nr) { m_uiNumberOfRefPicListModificationsL0 = nr; }
866	UInt getNumberOfRefPicListModificationsL1() { return m_uiNumberOfRefPicListModificationsL1; }
867	Void setNumberOfRefPicListModificationsL1(UInt nr) { m_uiNumberOfRefPicListModificationsL1 = nr; }
868	Void setListIdcL0(UInt idx, UInt idc) { m_ListIdcL0[idx] = idc; }
869	UInt getListIdcL0(UInt idx) { return m_ListIdcL0[idx]; }
870	#endif
871	Void setRefPicSetIdxL0(UInt idx, UInt refPicSetIdx) { m_RefPicSetIdxL0[idx] = refPicSetIdx; }
872	UInt getRefPicSetIdxL0(UInt idx) { return m_RefPicSetIdxL0[idx]; }
873	#if !H0137_0138_LIST_MODIFICATION
874	Void setListIdcL1(UInt idx, UInt idc) { m_ListIdcL1[idx] = idc; }
875	UInt getListIdcL1(UInt idx) { return m_ListIdcL1[idx]; }
876	#endif
877	Void setRefPicSetIdxL1(UInt idx, UInt refPicSetIdx) { m_RefPicSetIdxL1[idx] = refPicSetIdx; }
878	UInt getRefPicSetIdxL1(UInt idx) { return m_RefPicSetIdxL1[idx]; }
879	};
880
881	/// PPS class
882	class TComPPS
883	{
884	private:
885	Int m_PPSId; // pic_parameter_set_id
886	Int m_SPSId; // seq_parameter_set_id
887	Int m_picInitQPMinus26;
888	Bool m_useDQP;
889	Bool m_bConstrainedIntraPred; // constrained_intra_pred_flag
890
891	// access channel
892	TComSPS* m_pcSPS;
893	#if !RPS_IN_SPS
894	TComRPSList* m_RPSList;
895	#endif
896	UInt m_uiMaxCuDQPDepth;
897	UInt m_uiMinCuDQPSize;
898
899	Int m_iChromaQpOffset;
900	Int m_iChromaQpOffset2nd;
901
902	#if !RPS_IN_SPS
903	Bool m_bLongTermRefsPresent;
904	#endif
905
906	#if !H0566_TLA
907	UInt m_uiNumTlayerSwitchingFlags; // num_temporal_layer_switching_point_flags
908	Bool m_abTLayerSwitchingFlag[ MAX_TLAYER ]; // temporal_layer_switching_point_flag
909	#endif
910
911	Int m_iSliceGranularity;
912
913	Bool m_bUseWeightPred; // Use of Weighting Prediction (P_SLICE)
914	UInt m_uiBiPredIdc; // Use of Weighting Bi-Prediction (B_SLICE)
915
916	#if H0388
917	Bool m_OutputFlagPresentFlag; // Indicates the presence of output_flag in slice header
918	#endif
919
920	Int m_iTileBehaviorControlPresentFlag;
921	Bool m_bLFCrossTileBoundaryFlag;
922	Int m_iColumnRowInfoPresent;
923	Int m_iUniformSpacingIdr;
924	#if !REMOVE_TILE_DEPENDENCE
925	Int m_iTileBoundaryIndependenceIdr;
926	#endif
927	Int m_iNumColumnsMinus1;
928	UInt* m_puiColumnWidth;
929	Int m_iNumRowsMinus1;
930	UInt* m_puiRowHeight;
931
932	Int m_iEntropyCodingMode; // !!! in PPS now, but also remains in slice header!
933	#if !WPP_SIMPLIFICATION
934	Int m_iEntropyCodingSynchro;
935	Bool m_bCabacIstateReset;
936	#endif
937	Int m_iNumSubstreams;
938
939	Bool m_enableTMVPFlag;
940
941	#if MULTIBITS_DATA_HIDING
942	Int m_signHideFlag;
943	Int m_signHidingThreshold;
944	#endif
945
946	#if CABAC_INIT_FLAG
947	Bool m_cabacInitPresentFlag;
948	UInt m_encCABACTableIdx; // Used to transmit table selection across slices
949	#if FIX_POZNAN_CABAC_INIT_FLAG
950	UInt m_encPrevPOC;
951	#endif
952	#endif
953	#if DBL_CONTROL
954	Bool m_DeblockingFilterControlPresent;
955	#endif
956	#if PARALLEL_MERGE
957	UInt m_log2ParallelMergeLevelMinus2;
958	#endif
959	public:
960	TComPPS();
961	virtual ~TComPPS();
962
963	Int getPPSId () { return m_PPSId; }
964	Void setPPSId (Int i) { m_PPSId = i; }
965	Int getSPSId () { return m_SPSId; }
966	Void setSPSId (Int i) { m_SPSId = i; }
967
968	Int getSliceGranularity() { return m_iSliceGranularity; }
969	Void setSliceGranularity( Int i ) { m_iSliceGranularity = i; }
970	Int getPicInitQPMinus26 () { return m_picInitQPMinus26; }
971	Void setPicInitQPMinus26 ( Int i ) { m_picInitQPMinus26 = i; }
972	Bool getUseDQP () { return m_useDQP; }
973	Void setUseDQP ( Bool b ) { m_useDQP = b; }
974	Bool getConstrainedIntraPred () { return m_bConstrainedIntraPred; }
975	Void setConstrainedIntraPred ( Bool b ) { m_bConstrainedIntraPred = b; }
976
977	#if !H0566_TLA
978	UInt getNumTLayerSwitchingFlags() { return m_uiNumTlayerSwitchingFlags; }
979	Void setNumTLayerSwitchingFlags( UInt uiNumTlayerSwitchingFlags ) { assert( uiNumTlayerSwitchingFlags < MAX_TLAYER ); m_uiNumTlayerSwitchingFlags = uiNumTlayerSwitchingFlags; }
980
981	Bool getTLayerSwitchingFlag( UInt uiTLayer ) { assert( uiTLayer < MAX_TLAYER ); return m_abTLayerSwitchingFlag[ uiTLayer ]; }
982	Void setTLayerSwitchingFlag( UInt uiTLayer, Bool bValue ) { m_abTLayerSwitchingFlag[ uiTLayer ] = bValue; }
983	#endif
984
985	#if !RPS_IN_SPS
986	Bool getLongTermRefsPresent() { return m_bLongTermRefsPresent; }
987	Void setLongTermRefsPresent(Bool b) { m_bLongTermRefsPresent=b; }
988	#endif
989	Void setSPS ( TComSPS* pcSPS ) { m_pcSPS = pcSPS; }
990	TComSPS* getSPS () { return m_pcSPS; }
991	#if !RPS_IN_SPS
992	Void setRPSList ( TComRPSList* RPSList ) { m_RPSList = RPSList; }
993	TComRPSList* getRPSList () { return m_RPSList; }
994	#endif
995	Void setMaxCuDQPDepth ( UInt u ) { m_uiMaxCuDQPDepth = u; }
996	UInt getMaxCuDQPDepth () { return m_uiMaxCuDQPDepth;}
997	Void setMinCuDQPSize ( UInt u ) { m_uiMinCuDQPSize = u; }
998	UInt getMinCuDQPSize () { return m_uiMinCuDQPSize; }
999
1000	Void setChromaQpOffset ( Int i ) { m_iChromaQpOffset = i; }
1001	Int getChromaQpOffset () { return m_iChromaQpOffset;}
1002	Void setChromaQpOffset2nd( Int i ) { m_iChromaQpOffset2nd = i; }
1003	Int getChromaQpOffset2nd() { return m_iChromaQpOffset2nd;}
1004
1005	Bool getUseWP () { return m_bUseWeightPred; }
1006	UInt getWPBiPredIdc () { return m_uiBiPredIdc; }
1007
1008	Void setUseWP ( Bool b ) { m_bUseWeightPred = b; }
1009	Void setWPBiPredIdc ( UInt u ) { m_uiBiPredIdc = u; }
1010
1011	#if H0388
1012	Void setOutputFlagPresentFlag( Bool b ) { m_OutputFlagPresentFlag = b; }
1013	Bool getOutputFlagPresentFlag() { return m_OutputFlagPresentFlag; }
1014	#endif
1015
1016	Void setTileBehaviorControlPresentFlag ( Int i ) { m_iTileBehaviorControlPresentFlag = i; }
1017	Int getTileBehaviorControlPresentFlag () { return m_iTileBehaviorControlPresentFlag; }
1018	Void setLFCrossTileBoundaryFlag ( Bool bValue ) { m_bLFCrossTileBoundaryFlag = bValue; }
1019	Bool getLFCrossTileBoundaryFlag () { return m_bLFCrossTileBoundaryFlag; }
1020	Void setColumnRowInfoPresent ( Int i ) { m_iColumnRowInfoPresent = i; }
1021	Int getColumnRowInfoPresent () { return m_iColumnRowInfoPresent; }
1022	Void setUniformSpacingIdr ( Int i ) { m_iUniformSpacingIdr = i; }
1023	Int getUniformSpacingIdr () { return m_iUniformSpacingIdr; }
1024	#if !REMOVE_TILE_DEPENDENCE
1025	Void setTileBoundaryIndependenceIdr ( Int i ) { m_iTileBoundaryIndependenceIdr = i; }
1026	Int getTileBoundaryIndependenceIdr () { return m_iTileBoundaryIndependenceIdr; }
1027	#endif
1028	Void setNumColumnsMinus1 ( Int i ) { m_iNumColumnsMinus1 = i; }
1029	Int getNumColumnsMinus1 () { return m_iNumColumnsMinus1; }
1030	Void setColumnWidth ( UInt* columnWidth )
1031	{
1032	if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
1033	{
1034	m_puiColumnWidth = new UInt[ m_iNumColumnsMinus1 ];
1035
1036	for(Int i=0; i<m_iNumColumnsMinus1; i++)
1037	{
1038	m_puiColumnWidth[i] = columnWidth[i];
1039	}
1040	}
1041	}
1042	UInt getColumnWidth (UInt columnIdx) { return *( m_puiColumnWidth + columnIdx ); }
1043	Void setNumRowsMinus1( Int i ) { m_iNumRowsMinus1 = i; }
1044	Int getNumRowsMinus1() { return m_iNumRowsMinus1; }
1045	Void setRowHeight ( UInt* rowHeight )
1046	{
1047	if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
1048	{
1049	m_puiRowHeight = new UInt[ m_iNumRowsMinus1 ];
1050
1051	for(Int i=0; i<m_iNumRowsMinus1; i++)
1052	{
1053	m_puiRowHeight[i] = rowHeight[i];
1054	}
1055	}
1056	}
1057	UInt getRowHeight (UInt rowIdx) { return *( m_puiRowHeight + rowIdx ); }
1058	Void setEntropyCodingMode(Int iEntropyCodingMode) { m_iEntropyCodingMode = iEntropyCodingMode; }
1059	Int getEntropyCodingMode() { return m_iEntropyCodingMode; }
1060	#if !WPP_SIMPLIFICATION
1061	Void setEntropyCodingSynchro(Int iEntropyCodingSynchro) { m_iEntropyCodingSynchro = iEntropyCodingSynchro; }
1062	Int getEntropyCodingSynchro() { return m_iEntropyCodingSynchro; }
1063	Void setCabacIstateReset(Bool bCabacIstateReset) { m_bCabacIstateReset = bCabacIstateReset; }
1064	Bool getCabacIstateReset() { return m_bCabacIstateReset; }
1065	#endif
1066	Void setNumSubstreams(Int iNumSubstreams) { m_iNumSubstreams = iNumSubstreams; }
1067	Int getNumSubstreams() { return m_iNumSubstreams; }
1068
1069	#if MULTIBITS_DATA_HIDING
1070	Void setSignHideFlag( Int signHideFlag ) { m_signHideFlag = signHideFlag; }
1071	Void setTSIG( Int tsig ) { m_signHidingThreshold = tsig; }
1072	Int getSignHideFlag() { return m_signHideFlag; }
1073	Int getTSIG() { return m_signHidingThreshold; }
1074	#endif
1075
1076	Void setEnableTMVPFlag( Bool b ) { m_enableTMVPFlag = b; }
1077	Bool getEnableTMVPFlag() { return m_enableTMVPFlag; }
1078
1079	#if CABAC_INIT_FLAG
1080	Void setCabacInitPresentFlag( Bool flag ) { m_cabacInitPresentFlag = flag; }
1081	Void setEncCABACTableIdx( Int idx ) { m_encCABACTableIdx = idx; }
1082	Bool getCabacInitPresentFlag() { return m_cabacInitPresentFlag; }
1083	UInt getEncCABACTableIdx() { return m_encCABACTableIdx; }
1084	#if FIX_POZNAN_CABAC_INIT_FLAG
1085	Void setEncPrevPOC(UInt uiPOC) { m_encPrevPOC = uiPOC; }
1086	UInt getEncPrevPOC() { return m_encPrevPOC; }
1087	#endif
1088	#endif
1089	#if DBL_CONTROL
1090	Void setDeblockingFilterControlPresent ( Bool bValue ) { m_DeblockingFilterControlPresent = bValue; }
1091	Bool getDeblockingFilterControlPresent () { return m_DeblockingFilterControlPresent; }
1092	#endif
1093	#if PARALLEL_MERGE
1094	UInt getLog2ParallelMergeLevelMinus2 () { return m_log2ParallelMergeLevelMinus2; }
1095	Void setLog2ParallelMergeLevelMinus2 (UInt mrgLevel) { m_log2ParallelMergeLevelMinus2 = mrgLevel; }
1096	#endif
1097	};
1098
1099	/// SCALING_LIST class
1100	class TComScalingList
1101	{
1102	public:
1103	TComScalingList();
1104	virtual ~TComScalingList();
1105	Void setScalingListPresentFlag (Bool b) { m_scalingListPresentFlag = b; }
1106	Bool getScalingListPresentFlag () { return m_scalingListPresentFlag; }
1107	Int* getScalingListAddress (UInt sizeId, UInt listId) { return m_scalingListCoef[sizeId][listId]; } //!< get matrix coefficient
1108	Bool checkPredMode (UInt sizeId, UInt listId);
1109	Void setRefMatrixId (UInt sizeId, UInt listId, UInt u) { m_refMatrixId[sizeId][listId] = u; } //!< set reference matrix ID
1110	UInt getRefMatrixId (UInt sizeId, UInt listId) { return m_refMatrixId[sizeId][listId]; } //!< get reference matrix ID
1111	Int* getScalingListDefaultAddress (UInt sizeId, UInt listId); //!< get default matrix coefficient
1112	Void processDefaultMarix (UInt sizeId, UInt listId);
1113	#if SCALING_LIST
1114	Void setScalingListDC (UInt sizeId, UInt listId, UInt u) { m_scalingListDC[sizeId][listId] = u; } //!< set DC value
1115	Int getScalingListDC (UInt sizeId, UInt listId) { return m_scalingListDC[sizeId][listId]; } //!< get DC value
1116	Void checkDcOfMatrix ();
1117	Void setUseDefaultScalingMatrixFlag (UInt sizeId, UInt listId, Bool b) { m_useDefaultScalingMatrixFlag[sizeId][listId] = b; } //!< set default matrix enabled/disabled in each matrix
1118	Bool getUseDefaultScalingMatrixFlag (UInt sizeId, UInt listId) { return m_useDefaultScalingMatrixFlag[sizeId][listId]; } //!< get default matrix enabled/disabled in each matrix
1119	#endif
1120	Void processRefMatrix (UInt sizeId, UInt listId , UInt refListId );
1121	Bool xParseScalingList (char* pchFile);
1122
1123	private:
1124	Void init ();
1125	Void destroy ();
1126	#if SCALING_LIST
1127	Int m_scalingListDC [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< the DC value of the matrix coefficient for 16x16
1128	Bool m_useDefaultScalingMatrixFlag [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< UseDefaultScalingMatrixFlag
1129	#endif
1130	UInt m_refMatrixId [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< RefMatrixID
1131	Bool m_scalingListPresentFlag; //!< flag for using default matrix
1132	UInt m_predMatrixId [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< reference list index
1133	Int *m_scalingListCoef [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< quantization matrix
1134	};
1135
1136	/// APS class
1137	class TComAPS
1138	{
1139	public:
1140	TComAPS();
1141	virtual ~TComAPS();
1142
1143	Void setAPSID (Int iID) {m_apsID = iID; } //!< set APS ID
1144	Int getAPSID () {return m_apsID; } //!< get APS ID
1145	Void setSaoEnabled (Bool bVal) {m_bSaoEnabled = bVal; } //!< set SAO enabled/disabled in APS
1146	Bool getSaoEnabled () {return m_bSaoEnabled; } //!< get SAO enabled/disabled in APS
1147	Void setAlfEnabled (Bool bVal) {m_bAlfEnabled = bVal; } //!< set ALF enabled/disabled in APS
1148	Bool getAlfEnabled () {return m_bAlfEnabled; } //!< get ALF enabled/disabled in APS
1149
1150	#if LCU_SYNTAX_ALF
1151	AlfParamSet* getAlfParam () {return m_alfParamSet;}
1152	#else
1153	ALFParam* getAlfParam () {return m_pAlfParam; } //!< get ALF parameters in APS
1154	#endif
1155	SAOParam* getSaoParam () {return m_pSaoParam; } //!< get SAO parameters in APS
1156
1157	Void createSaoParam(); //!< create SAO parameter object
1158	Void destroySaoParam(); //!< destroy SAO parameter object
1159
1160	Void createAlfParam(); //!< create ALF parameter object
1161	Void destroyAlfParam(); //!< destroy ALF parameter object
1162
1163	Void setLoopFilterOffsetInAPS(Bool val) {m_loopFilterOffsetInAPS = val; } //!< set offset for deblocking filter enabled/disabled in APS
1164	Bool getLoopFilterOffsetInAPS() {return m_loopFilterOffsetInAPS; } //!< get offset for deblocking filter enabled/disabled in APS
1165	Void setLoopFilterDisable(Bool val) {m_loopFilterDisable = val; } //!< set offset for deblocking filter disabled
1166	Bool getLoopFilterDisable() {return m_loopFilterDisable; } //!< get offset for deblocking filter disabled
1167	Void setLoopFilterBetaOffset(Int val) {m_loopFilterBetaOffsetDiv2 = val; } //!< set beta offset for deblocking filter
1168	Int getLoopFilterBetaOffset() {return m_loopFilterBetaOffsetDiv2; } //!< get beta offset for deblocking filter
1169	Void setLoopFilterTcOffset(Int val) {m_loopFilterTcOffsetDiv2 = val; } //!< set tc offset for deblocking filter
1170	Int getLoopFilterTcOffset() {return m_loopFilterTcOffsetDiv2; } //!< get tc offset for deblocking filter
1171
1172	Void createScalingList();
1173	Void destroyScalingList();
1174	Void setScalingListEnabled (Bool bVal) { m_scalingListEnabled = bVal; } //!< set ScalingList enabled/disabled in APS
1175	Bool getScalingListEnabled () { return m_scalingListEnabled; } //!< get ScalingList enabled/disabled in APS
1176	TComScalingList* getScalingList () { return m_scalingList; } //!< get ScalingList class pointer in APS
1177	#if SAO_UNIT_INTERLEAVING
1178	Bool getSaoInterleavingFlag() {return m_saoInterleavingFlag;} //!< get SAO interleaving flag in APS
1179	Void setSaoInterleavingFlag(Bool bVal) {m_saoInterleavingFlag = bVal;} //!< set SAO interleaving flag in APS
1180	#endif
1181
1182	private:
1183	Int m_apsID; //!< APS ID
1184	Bool m_bSaoEnabled; //!< SAO enabled/disabled in APS (true for enabled)
1185	Bool m_bAlfEnabled; //!< ALF enabled/disabled in APS (true for enabled)
1186	SAOParam* m_pSaoParam; //!< SAO parameter object pointer
1187	#if LCU_SYNTAX_ALF
1188	AlfParamSet* m_alfParamSet;
1189	#else
1190	ALFParam* m_pAlfParam; //!< ALF parameter object pointer
1191	#endif
1192	Bool m_loopFilterOffsetInAPS; //< offset for deblocking filter in 0 = slice header, 1 = APS
1193	Bool m_loopFilterDisable; //< Deblocking filter enabled/disabled in APS
1194	Int m_loopFilterBetaOffsetDiv2; //< beta offset for deblocking filter
1195	Int m_loopFilterTcOffsetDiv2; //< tc offset for deblocking filter
1196	Bool m_scalingListEnabled; //!< ScalingList enabled/disabled in APS (true for enabled)
1197	TComScalingList* m_scalingList; //!< ScalingList class pointer
1198	#if SAO_UNIT_INTERLEAVING
1199	Bool m_saoInterleavingFlag; //!< SAO interleaving flag
1200	#endif
1201
1202	public:
1203	TComAPS& operator= (const TComAPS& src); //!< "=" operator for APS object
1204	};
1205
1206	typedef struct {
1207	// Explicit weighted prediction parameters parsed in slice header,
1208	// or Implicit weighted prediction parameters (8 bits depth values).
1209	Bool bPresentFlag;
1210	UInt uiLog2WeightDenom;
1211	Int iWeight;
1212	Int iOffset;
1213
1214	// Weighted prediction scaling values built from above parameters (bitdepth scaled):
1215	Int w, o, offset, shift, round;
1216	} wpScalingParam;
1217
1218	typedef struct {
1219	Int64 iAC;
1220	Int64 iDC;
1221	} wpACDCParam;
1222
1223	/// slice header class
1224	class TComSlice
1225	{
1226
1227	private:
1228	// Bitstream writing
1229	Int m_iAPSId; //!< APS ID in slice header
1230	bool m_alfEnabledFlag;
1231	bool m_saoEnabledFlag;
1232	#if SAO_UNIT_INTERLEAVING
1233	bool m_saoInterleavingFlag; ///< SAO interleaving flag
1234	bool m_saoEnabledFlagCb; ///< SAO Cb enabled flag
1235	bool m_saoEnabledFlagCr; ///< SAO Cr enabled flag
1236	#endif
1237	Int m_iPPSId; ///< picture parameter set ID
1238	#if H0388
1239	Bool m_PicOutputFlag; ///< pic_output_flag
1240	#endif
1241	Int m_iPOC;
1242	Int m_iLastIDR;
1243	static Int m_prevPOC;
1244	TComReferencePictureSet *m_pcRPS;
1245	TComReferencePictureSet m_LocalRPS;
1246	Int m_iBDidx;
1247	Int m_iCombinationBDidx;
1248	Bool m_bCombineWithReferenceFlag;
1249	TComRefPicListModification m_RefPicListModification;
1250	NalUnitType m_eNalUnitType; ///< Nal unit type for the slice
1251	NalUnitType m_eNalUnitTypeBaseViewMvc; ///< Nal unit type of the base view slice for multiview coding
1252	SliceType m_eSliceType;
1253	Int m_iSliceQp;
1254	#if ADAPTIVE_QP_SELECTION
1255	Int m_iSliceQpBase;
1256	#endif
1257	Bool m_bLoopFilterDisable;
1258	Bool m_loopFilterOffsetInAPS;
1259	Bool m_inheritDblParamFromAPS; //< offsets for deblocking filter inherit from APS
1260	Int m_loopFilterBetaOffsetDiv2; //< beta offset for deblocking filter
1261	Int m_loopFilterTcOffsetDiv2; //< tc offset for deblocking filter
1262
1263	Int m_aiNumRefIdx [3]; // for multiple reference of current slice
1264
1265	Int m_iRefIdxOfLC[2][MAX_NUM_REF_LC];
1266	Int m_eListIdFromIdxOfLC[MAX_NUM_REF_LC];
1267	Int m_iRefIdxFromIdxOfLC[MAX_NUM_REF_LC];
1268	Int m_iRefIdxOfL1FromRefIdxOfL0[MAX_NUM_REF_LC];
1269	Int m_iRefIdxOfL0FromRefIdxOfL1[MAX_NUM_REF_LC];
1270	Bool m_bRefPicListModificationFlagLC;
1271	Bool m_bRefPicListCombinationFlag;
1272
1273	Bool m_bCheckLDC;
1274
1275	// Data
1276	Int m_iSliceQpDelta;
1277	TComPic* m_apcRefPicList [2][MAX_NUM_REF+1];
1278	Int m_aiRefPOCList [2][MAX_NUM_REF+1];
1279	Int m_aiRefViewIdList[2][MAX_NUM_REF+1];
1280	TComPic* m_pcTexturePic;
1281	Int m_iDepth;
1282
1283	// referenced slice?
1284	Bool m_bRefenced;
1285
1286	// access channel
1287	#if VIDYO_VPS_INTEGRATION\|QC_MVHEVC_B0046
1288	TComVPS* m_pcVPS;
1289	#endif
1290	#if QC_IV_AS_LT_B0046
1291	Bool m_bWasLongTerm[2][MAX_NUM_REF+1]; //was long-term picture
1292	#endif
1293	TComSPS* m_pcSPS;
1294	TComPPS* m_pcPPS;
1295	TComPic* m_pcPic;
1296	#if ADAPTIVE_QP_SELECTION
1297	TComTrQuant* m_pcTrQuant;
1298	#endif
1299	TComAPS* m_pcAPS; //!< pointer to APS parameter object
1300
1301	UInt m_uiColDir; // direction to get colocated CUs
1302
1303	#if COLLOCATED_REF_IDX
1304	UInt m_colRefIdx;
1305	#endif
1306
1307	#if ALF_CHROMA_LAMBDA \|\| SAO_CHROMA_LAMBDA
1308	Double m_dLambdaLuma;
1309	Double m_dLambdaChroma;
1310	#else
1311	Double m_dLambda;
1312	#endif
1313
1314	Bool m_abEqualRef [2][MAX_NUM_REF][MAX_NUM_REF];
1315
1316	Bool m_bNoBackPredFlag;
1317	Bool m_bRefIdxCombineCoding;
1318
1319	UInt m_uiTLayer;
1320	Bool m_bTLayerSwitchingFlag;
1321
1322	UInt m_uiSliceMode;
1323	UInt m_uiSliceArgument;
1324	UInt m_uiSliceCurStartCUAddr;
1325	UInt m_uiSliceCurEndCUAddr;
1326	UInt m_uiSliceIdx;
1327	UInt m_uiEntropySliceMode;
1328	UInt m_uiEntropySliceArgument;
1329	UInt m_uiEntropySliceCurStartCUAddr;
1330	UInt m_uiEntropySliceCurEndCUAddr;
1331	Bool m_bNextSlice;
1332	Bool m_bNextEntropySlice;
1333	UInt m_uiSliceBits;
1334	UInt m_uiEntropySliceCounter;
1335	Bool m_bFinalized;
1336
1337	wpScalingParam m_weightPredTable[2][MAX_NUM_REF][3]; // [REF_PIC_LIST_0 or REF_PIC_LIST_1][refIdx][0:Y, 1:U, 2:V]
1338	wpACDCParam m_weightACDCParam[3]; // [0:Y, 1:U, 2:V]
1339	wpScalingParam m_weightPredTableLC[2*MAX_NUM_REF][3]; // [refIdxLC][0:Y, 1:U, 2:V]
1340
1341	UInt *m_uiTileByteLocation;
1342	UInt m_uiTileCount;
1343	Int m_iTileMarkerFlag;
1344	UInt m_uiTileOffstForMultES;
1345
1346	UInt* m_puiSubstreamSizes;
1347	TComScalingList* m_scalingList; //!< pointer of quantization matrix
1348	#if CABAC_INIT_FLAG
1349	Bool m_cabacInitFlag;
1350	#else
1351	Int m_cabacInitIdc;
1352	#endif
1353
1354	#if H0111_MVD_L1_ZERO
1355	Bool m_bLMvdL1Zero;
1356	#endif
1357	#if TILES_WPP_ENTRY_POINT_SIGNALLING
1358	Int m_numEntryPointOffsets;
1359	#endif
1360
1361	Int m_viewId;
1362	Bool m_isDepth;
1363	Int m_aaiCodedScale [2][MAX_VIEW_NUM];
1364	Int m_aaiCodedOffset[2][MAX_VIEW_NUM];
1365
1366	#if SONY_COLPIC_AVAILABILITY\|QC_MVHEVC_B0046\|VSP_N
1367	Int m_iViewOrderIdx;
1368	#endif
1369	#if LGE_ILLUCOMP_B0045
1370	Bool m_bApplyIC;
1371	#endif
1372
1373	#if FORCE_REF_VSP
1374	Int m_iRefIdxVsp[2]; // L0/L1
1375	#endif
1376
1377	#if VSP_SLICE_HEADER
1378	Bool m_bVspFlag;
1379	#if VSP_CFG
1380	UInt m_uiNumVspRefPics;
1381	UInt m_uiVspRefPos[2][MAX_NUM_REF_PICS];
1382	#else
1383	Bool m_bVspDepthDisableFlag;
1384	#endif
1385	#endif
1386
1387	public:
1388	TComSlice();
1389	virtual ~TComSlice();
1390
1391	Void initSlice ();
1392	Void initTiles();
1393
1394	#if VIDYO_VPS_INTEGRATION\|QC_MVHEVC_B0046
1395	Void setVPS ( TComVPS* pcVPS ) { m_pcVPS = pcVPS; }
1396	TComVPS* getVPS () { return m_pcVPS; }
1397	#endif
1398	#if QC_IV_AS_LT_B0046
1399	Void setWasLongTerm( Bool lt, RefPicList e, Int iRefIdx ) { m_bWasLongTerm[e][iRefIdx] = lt; }
1400	Bool getWasLongTerm( RefPicList e, Int iRefIdx ) { return m_bWasLongTerm[e][iRefIdx] ; }
1401	#endif
1402
1403	Void setSPS ( TComSPS* pcSPS ) { m_pcSPS = pcSPS; }
1404	TComSPS* getSPS () { return m_pcSPS; }
1405
1406	Void setPPS ( TComPPS* pcPPS ) { assert(pcPPS!=NULL); m_pcPPS = pcPPS; m_iPPSId = pcPPS->getPPSId(); }
1407	TComPPS* getPPS () { return m_pcPPS; }
1408
1409	#if ADAPTIVE_QP_SELECTION
1410	Void setTrQuant ( TComTrQuant* pcTrQuant ) { m_pcTrQuant = pcTrQuant; }
1411	TComTrQuant* getTrQuant () { return m_pcTrQuant; }
1412	#endif
1413
1414	Void setPPSId ( Int PPSId ) { m_iPPSId = PPSId; }
1415	Int getPPSId () { return m_iPPSId; }
1416	Void setAPS ( TComAPS* pcAPS ) { m_pcAPS = pcAPS; } //!< set APS pointer
1417	TComAPS* getAPS () { return m_pcAPS; } //!< get APS pointer
1418	Void setAPSId ( Int Id) { m_iAPSId =Id; } //!< set APS ID
1419	Int getAPSId () { return m_iAPSId; } //!< get APS ID
1420	#if H0388
1421	Void setPicOutputFlag( Bool b ) { m_PicOutputFlag = b; }
1422	Bool getPicOutputFlag() { return m_PicOutputFlag; }
1423	#endif
1424	Void setAlfEnabledFlag(Bool s) {m_alfEnabledFlag =s; }
1425	Bool getAlfEnabledFlag() { return m_alfEnabledFlag; }
1426	Void setSaoEnabledFlag(Bool s) {m_saoEnabledFlag =s; }
1427	Bool getSaoEnabledFlag() { return m_saoEnabledFlag; }
1428	#if SAO_UNIT_INTERLEAVING
1429	Void setSaoInterleavingFlag(Bool s) {m_saoInterleavingFlag =s; } //!< set SAO interleaving flag
1430	Bool getSaoInterleavingFlag() { return m_saoInterleavingFlag; } //!< get SAO interleaving flag
1431	Void setSaoEnabledFlagCb(Bool s) {m_saoEnabledFlagCb =s; } //!< set SAO Cb enabled flag
1432	Bool getSaoEnabledFlagCb() { return m_saoEnabledFlagCb; } //!< get SAO Cb enabled flag
1433	Void setSaoEnabledFlagCr(Bool s) {m_saoEnabledFlagCr =s; } //!< set SAO Cr enabled flag
1434	Bool getSaoEnabledFlagCr() { return m_saoEnabledFlagCr; } //!< get SAO Cr enabled flag
1435	#endif
1436	Void setRPS ( TComReferencePictureSet *pcRPS ) { m_pcRPS = pcRPS; }
1437	TComReferencePictureSet* getRPS () { return m_pcRPS; }
1438	TComReferencePictureSet* getLocalRPS () { return &m_LocalRPS; }
1439
1440	Void setRPSidx ( Int iBDidx ) { m_iBDidx = iBDidx; }
1441	Int getRPSidx () { return m_iBDidx; }
1442	Void setCombinationBDidx ( Int iCombinationBDidx ) { m_iCombinationBDidx = iCombinationBDidx; }
1443	Int getCombinationBDidx () { return m_iCombinationBDidx; }
1444	Void setCombineWithReferenceFlag ( Bool bCombineWithReferenceFlag ) { m_bCombineWithReferenceFlag = bCombineWithReferenceFlag; }
1445	Bool getCombineWithReferenceFlag () { return m_bCombineWithReferenceFlag; }
1446	Int getPrevPOC () { return m_prevPOC; }
1447
1448	TComRefPicListModification* getRefPicListModification() { return &m_RefPicListModification; }
1449	Void setLastIDR(Int iIDRPOC) { m_iLastIDR = iIDRPOC; }
1450	Int getLastIDR() { return m_iLastIDR; }
1451	SliceType getSliceType () { return m_eSliceType; }
1452	Int getPOC () { return m_iPOC; }
1453	Int getSliceQp () { return m_iSliceQp; }
1454	#if ADAPTIVE_QP_SELECTION
1455	Int getSliceQpBase () { return m_iSliceQpBase; }
1456	#endif
1457	Int getSliceQpDelta () { return m_iSliceQpDelta; }
1458	Bool getLoopFilterDisable() { return m_bLoopFilterDisable; }
1459	Bool getLoopFilterOffsetInAPS() { return m_loopFilterOffsetInAPS;}
1460	Bool getInheritDblParamFromAPS() { return m_inheritDblParamFromAPS; }
1461	Int getLoopFilterBetaOffset() { return m_loopFilterBetaOffsetDiv2; }
1462	Int getLoopFilterTcOffset() { return m_loopFilterTcOffsetDiv2; }
1463
1464	Int getNumRefIdx ( RefPicList e ) { return m_aiNumRefIdx[e]; }
1465	TComPic* getPic () { return m_pcPic; }
1466	TComPic* getRefPic ( RefPicList e, Int iRefIdx) { return m_apcRefPicList[e][iRefIdx]; }
1467	Int getRefPOC ( RefPicList e, Int iRefIdx) { return m_aiRefPOCList[e][iRefIdx]; }
1468	Int getRefViewId ( RefPicList e, Int iRefIdx) { return m_aiRefViewIdList[e][iRefIdx]; }
1469	TComPic* getTexturePic () const { return m_pcTexturePic; }
1470	#if SONY_COLPIC_AVAILABILITY \|\| VSP_N
1471	Int getViewOrderIdx () { return m_iViewOrderIdx; }
1472	#endif
1473	Int getDepth () { return m_iDepth; }
1474	UInt getColDir () { return m_uiColDir; }
1475	#if COLLOCATED_REF_IDX
1476	Bool getColRefIdx () { return m_colRefIdx; }
1477	Void checkColRefIdx (UInt curSliceIdx, TComPic* pic);
1478	#endif
1479	Bool getCheckLDC () { return m_bCheckLDC; }
1480	#if H0111_MVD_L1_ZERO
1481	Bool getMvdL1ZeroFlag () { return m_bLMvdL1Zero; }
1482	#endif
1483	Int getRefIdxOfLC (RefPicList e, Int iRefIdx) { return m_iRefIdxOfLC[e][iRefIdx]; }
1484	Int getListIdFromIdxOfLC(Int iRefIdx) { return m_eListIdFromIdxOfLC[iRefIdx]; }
1485	Int getRefIdxFromIdxOfLC(Int iRefIdx) { return m_iRefIdxFromIdxOfLC[iRefIdx]; }
1486	Int getRefIdxOfL0FromRefIdxOfL1(Int iRefIdx) { return m_iRefIdxOfL0FromRefIdxOfL1[iRefIdx];}
1487	Int getRefIdxOfL1FromRefIdxOfL0(Int iRefIdx) { return m_iRefIdxOfL1FromRefIdxOfL0[iRefIdx];}
1488	Bool getRefPicListModificationFlagLC() {return m_bRefPicListModificationFlagLC;}
1489	Void setRefPicListModificationFlagLC(Bool bflag) {m_bRefPicListModificationFlagLC=bflag;}
1490	Bool getRefPicListCombinationFlag() {return m_bRefPicListCombinationFlag;}
1491	Void setRefPicListCombinationFlag(Bool bflag) {m_bRefPicListCombinationFlag=bflag;}
1492	Void setListIdFromIdxOfLC(Int iRefIdx, UInt uiVal) { m_eListIdFromIdxOfLC[iRefIdx]=uiVal; }
1493	Void setRefIdxFromIdxOfLC(Int iRefIdx, UInt uiVal) { m_iRefIdxFromIdxOfLC[iRefIdx]=uiVal; }
1494	Void setRefIdxOfLC (RefPicList e, Int iRefIdx, Int RefIdxLC) { m_iRefIdxOfLC[e][iRefIdx]=RefIdxLC;}
1495
1496	Void setReferenced(Bool b) { m_bRefenced = b; }
1497	Bool isReferenced() { return m_bRefenced; }
1498
1499	Void setPOC ( Int i ) { m_iPOC = i; if(getTLayer()==0) m_prevPOC=i; }
1500	Void setNalUnitType ( NalUnitType e ) { m_eNalUnitType = e; }
1501	NalUnitType getNalUnitType () { return m_eNalUnitType; }
1502	Void setNalUnitTypeBaseViewMvc ( NalUnitType e ) { m_eNalUnitTypeBaseViewMvc = e; }
1503	NalUnitType getNalUnitTypeBaseViewMvc() { return m_eNalUnitTypeBaseViewMvc; }
1504	Void checkCRA(TComReferencePictureSet pReferencePictureSet, Int& pocCRA, TComList<TComPic>& rcListPic);
1505	Void decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic);
1506	Void setSliceType ( SliceType e ) { m_eSliceType = e; }
1507	Void setSliceQp ( Int i ) { m_iSliceQp = i; }
1508	#if ADAPTIVE_QP_SELECTION
1509	Void setSliceQpBase ( Int i ) { m_iSliceQpBase = i; }
1510	#endif
1511	Void setSliceQpDelta ( Int i ) { m_iSliceQpDelta = i; }
1512	Void setLoopFilterDisable( Bool b ) { m_bLoopFilterDisable= b; }
1513	Void setLoopFilterOffsetInAPS( Bool b ) { m_loopFilterOffsetInAPS = b;}
1514	Void setInheritDblParamFromAPS( Bool b ) { m_inheritDblParamFromAPS = b; }
1515	Void setLoopFilterBetaOffset( Int i ) { m_loopFilterBetaOffsetDiv2 = i; }
1516	Void setLoopFilterTcOffset( Int i ) { m_loopFilterTcOffsetDiv2 = i; }
1517
1518	Void setRefPic ( TComPic* p, RefPicList e, Int iRefIdx ) { m_apcRefPicList[e][iRefIdx] = p; }
1519	Void setRefPOC ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefPOCList[e][iRefIdx] = i; }
1520	Void setRefViewId ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefViewIdList[e][iRefIdx] = i; }
1521	Void setTexturePic ( TComPic *pcTexturePic ) { m_pcTexturePic = pcTexturePic; }
1522	#if SONY_COLPIC_AVAILABILITY \|\| VSP_N
1523	Void setViewOrderIdx ( Int i ) { m_iViewOrderIdx = i; }
1524	#endif
1525	Void setNumRefIdx ( RefPicList e, Int i ) { m_aiNumRefIdx[e] = i; }
1526	Void setPic ( TComPic* p ) { m_pcPic = p; }
1527	Void setDepth ( Int iDepth ) { m_iDepth = iDepth; }
1528
1529	Int getNumPocTotalCurr();
1530	Int getNumPocTotalCurrMvc();
1531	#if VSP_N
1532	Void setRefPicListMvc ( TComList<TComPic>& rcListPic, std::vector<TComPic>& rapcInterViewRefPics, TComPic* pcVspPic );
1533	#else
1534	Void setRefPicListMvc ( TComList<TComPic>& rcListPic, std::vector<TComPic>& rapcInterViewRefPics );
1535	#endif
1536	Void setRefPOCnViewListsMvc();
1537
1538	Void setColDir ( UInt uiDir ) { m_uiColDir = uiDir; }
1539	#if COLLOCATED_REF_IDX
1540	Void setColRefIdx ( UInt refIdx) { m_colRefIdx = refIdx; }
1541	#endif
1542	Void setCheckLDC ( Bool b ) { m_bCheckLDC = b; }
1543	#if H0111_MVD_L1_ZERO
1544	Void setMvdL1ZeroFlag ( Bool b) { m_bLMvdL1Zero = b; }
1545	#endif
1546
1547	Bool isIntra () { return m_eSliceType == I_SLICE; }
1548	Bool isInterB () { return m_eSliceType == B_SLICE; }
1549	Bool isInterP () { return m_eSliceType == P_SLICE; }
1550
1551	#if ALF_CHROMA_LAMBDA \|\| SAO_CHROMA_LAMBDA
1552	Void setLambda( Double d, Double e ) { m_dLambdaLuma = d; m_dLambdaChroma = e;}
1553	Double getLambdaLuma() { return m_dLambdaLuma; }
1554	Double getLambdaChroma() { return m_dLambdaChroma; }
1555	#else
1556	Void setLambda( Double d ) { m_dLambda = d; }
1557	Double getLambda() { return m_dLambda; }
1558	#endif
1559
1560	Void initEqualRef();
1561	Bool isEqualRef ( RefPicList e, Int iRefIdx1, Int iRefIdx2 )
1562	{
1563	if (iRefIdx1 < 0 \|\| iRefIdx2 < 0) return false;
1564	return m_abEqualRef[e][iRefIdx1][iRefIdx2];
1565	}
1566
1567	Void setEqualRef( RefPicList e, Int iRefIdx1, Int iRefIdx2, Bool b)
1568	{
1569	m_abEqualRef[e][iRefIdx1][iRefIdx2] = m_abEqualRef[e][iRefIdx2][iRefIdx1] = b;
1570	}
1571
1572	static Void sortPicList ( TComList<TComPic*>& rcListPic );
1573
1574	Bool getNoBackPredFlag() { return m_bNoBackPredFlag; }
1575	Void setNoBackPredFlag( Bool b ) { m_bNoBackPredFlag = b; }
1576	Bool getRefIdxCombineCoding() { return m_bRefIdxCombineCoding; }
1577	Void setRefIdxCombineCoding( Bool b ) { m_bRefIdxCombineCoding = b; }
1578	Void generateCombinedList ();
1579
1580	UInt getTLayer () { return m_uiTLayer; }
1581	Void setTLayer ( UInt uiTLayer ) { m_uiTLayer = uiTLayer; }
1582
1583	#if !H0566_TLA
1584	Bool getTLayerSwitchingFlag() { return m_bTLayerSwitchingFlag; }
1585	Void setTLayerSwitchingFlag( Bool bValue ) { m_bTLayerSwitchingFlag = bValue; }
1586	#endif
1587
1588	Void setTLayerInfo( UInt uiTLayer );
1589	Void decodingMarking( TComList<TComPic*>& rcListPic, Int iGOPSIze, Int& iMaxRefPicNum );
1590	Void applyReferencePictureSet( TComList<TComPic>& rcListPic, TComReferencePictureSet RPSList);
1591	#if H0566_TLA && H0566_TLA_SET_FOR_SWITCHING_POINTS
1592	Bool isTemporalLayerSwitchingPoint( TComList<TComPic>& rcListPic, TComReferencePictureSet RPSList);
1593	#endif
1594	#if START_DECODING_AT_CRA
1595	Int checkThatAllRefPicsAreAvailable( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet, Bool outputFlag, Int pocRandomAccess = 0);
1596	#else
1597	Int checkThatAllRefPicsAreAvailable( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet, Bool outputFlag);
1598	#endif
1599	Void createExplicitReferencePictureSetFromReference( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet);
1600
1601	Void decodingMarkingForNoTMVP( TComList<TComPic*>& rcListPic, Int currentPOC );
1602
1603	UInt m_uiMaxNumMergeCand;
1604	Void setMaxNumMergeCand (UInt maxNumMergeCand ) { m_uiMaxNumMergeCand = maxNumMergeCand; }
1605	UInt getMaxNumMergeCand () {return m_uiMaxNumMergeCand; }
1606
1607	Void setSliceMode ( UInt uiMode ) { m_uiSliceMode = uiMode; }
1608	UInt getSliceMode () { return m_uiSliceMode; }
1609	Void setSliceArgument ( UInt uiArgument ) { m_uiSliceArgument = uiArgument; }
1610	UInt getSliceArgument () { return m_uiSliceArgument; }
1611	Void setSliceCurStartCUAddr ( UInt uiAddr ) { m_uiSliceCurStartCUAddr = uiAddr; }
1612	UInt getSliceCurStartCUAddr () { return m_uiSliceCurStartCUAddr; }
1613	Void setSliceCurEndCUAddr ( UInt uiAddr ) { m_uiSliceCurEndCUAddr = uiAddr; }
1614	UInt getSliceCurEndCUAddr () { return m_uiSliceCurEndCUAddr; }
1615	Void setSliceIdx ( UInt i) { m_uiSliceIdx = i; }
1616	UInt getSliceIdx () { return m_uiSliceIdx; }
1617	Void copySliceInfo (TComSlice *pcSliceSrc);
1618	Void setEntropySliceMode ( UInt uiMode ) { m_uiEntropySliceMode = uiMode; }
1619	UInt getEntropySliceMode () { return m_uiEntropySliceMode; }
1620	Void setEntropySliceArgument ( UInt uiArgument ) { m_uiEntropySliceArgument = uiArgument; }
1621	UInt getEntropySliceArgument () { return m_uiEntropySliceArgument; }
1622	Void setEntropySliceCurStartCUAddr ( UInt uiAddr ) { m_uiEntropySliceCurStartCUAddr = uiAddr; }
1623	UInt getEntropySliceCurStartCUAddr () { return m_uiEntropySliceCurStartCUAddr; }
1624	Void setEntropySliceCurEndCUAddr ( UInt uiAddr ) { m_uiEntropySliceCurEndCUAddr = uiAddr; }
1625	UInt getEntropySliceCurEndCUAddr () { return m_uiEntropySliceCurEndCUAddr; }
1626	Void setNextSlice ( Bool b ) { m_bNextSlice = b; }
1627	Bool isNextSlice () { return m_bNextSlice; }
1628	Void setNextEntropySlice ( Bool b ) { m_bNextEntropySlice = b; }
1629	Bool isNextEntropySlice () { return m_bNextEntropySlice; }
1630	Void setSliceBits ( UInt uiVal ) { m_uiSliceBits = uiVal; }
1631	UInt getSliceBits () { return m_uiSliceBits; }
1632	Void setEntropySliceCounter ( UInt uiVal ) { m_uiEntropySliceCounter = uiVal; }
1633	UInt getEntropySliceCounter () { return m_uiEntropySliceCounter; }
1634	Void setFinalized ( Bool uiVal ) { m_bFinalized = uiVal; }
1635	Bool getFinalized () { return m_bFinalized; }
1636	Void setWpScaling ( wpScalingParam wp[2][MAX_NUM_REF][3] ) { memcpy(m_weightPredTable, wp, sizeof(wpScalingParam)2MAX_NUM_REF*3); }
1637	Void getWpScaling ( RefPicList e, Int iRefIdx, wpScalingParam *&wp);
1638
1639	Void resetWpScaling (wpScalingParam wp[2][MAX_NUM_REF][3]);
1640	Void initWpScaling (wpScalingParam wp[2][MAX_NUM_REF][3]);
1641	Void initWpScaling ();
1642	inline Bool applyWP () { return( (m_eSliceType==P_SLICE && m_pcPPS->getUseWP()) \|\| (m_eSliceType==B_SLICE && m_pcPPS->getWPBiPredIdc()) ); }
1643
1644	Void setWpAcDcParam ( wpACDCParam wp[3] ) { memcpy(m_weightACDCParam, wp, sizeof(wpACDCParam)*3); }
1645	Void getWpAcDcParam ( wpACDCParam *&wp );
1646	Void initWpAcDcParam ();
1647	Void copyWPtable (wpScalingParam &wp_src, wpScalingParam &wp_dst);
1648	Void getWpScalingLC ( Int iRefIdx, wpScalingParam *&wp);
1649	Void resetWpScalingLC(wpScalingParam wp[2*MAX_NUM_REF][3]);
1650	Void setWpParamforLC();
1651	Void setTileLocationCount ( UInt uiCount ) { m_uiTileCount = uiCount; }
1652	UInt getTileLocationCount () { return m_uiTileCount; }
1653	Void setTileLocation ( Int i, UInt uiLOC ) { m_uiTileByteLocation[i] = uiLOC; }
1654	UInt getTileLocation ( Int i ) { return m_uiTileByteLocation[i]; }
1655	Void setTileMarkerFlag ( Int iFlag ) { m_iTileMarkerFlag = iFlag; }
1656	Int getTileMarkerFlag () { return m_iTileMarkerFlag; }
1657	Void setTileOffstForMultES (UInt uiOffset ) { m_uiTileOffstForMultES = uiOffset; }
1658	UInt getTileOffstForMultES () { return m_uiTileOffstForMultES; }
1659	Void allocSubstreamSizes ( UInt uiNumSubstreams );
1660	UInt* getSubstreamSizes () { return m_puiSubstreamSizes; }
1661	Void setScalingList ( TComScalingList* scalingList ) { m_scalingList = scalingList; }
1662	TComScalingList* getScalingList () { return m_scalingList; }
1663	Void setDefaultScalingList ();
1664	Bool checkDefaultScalingList ();
1665	#if CABAC_INIT_FLAG
1666	Void setCabacInitFlag ( Bool val ) { m_cabacInitFlag = val; } //!< set CABAC initial flag
1667	Bool getCabacInitFlag () { return m_cabacInitFlag; } //!< get CABAC initial flag
1668	#else
1669	Void setCABACinitIDC(Int iVal) {m_cabacInitIdc = iVal; } //!< set CABAC initial IDC number
1670	Int getCABACinitIDC() {return m_cabacInitIdc; } //!< get CABAC initial IDC number
1671	#endif
1672	#if TILES_WPP_ENTRY_POINT_SIGNALLING
1673	Void setNumEntryPointOffsets(Int val) { m_numEntryPointOffsets = val; }
1674	Int getNumEntryPointOffsets() { return m_numEntryPointOffsets; }
1675	#endif
1676
1677	Void setViewId( Int viewId ) { m_viewId = viewId; }
1678	Int getViewId() { return m_viewId; }
1679	#if QC_MVHEVC_B0046
1680	Void setViewOrderIdx(Int v, UInt layer) { m_iViewOrderIdx = v; }
1681	Int getViewOrderIdx() { return m_iViewOrderIdx; }
1682	#endif
1683	Void setIsDepth( Bool isDepth ) { m_isDepth = isDepth; }
1684	Bool getIsDepth() { return m_isDepth; }
1685
1686	Void initMultiviewSlice ( Int aaiScale = 0, Int aaiOffset = 0 );
1687
1688	Int* getCodedScale () { return m_aaiCodedScale [0]; }
1689	Int* getCodedOffset () { return m_aaiCodedOffset[0]; }
1690	Int* getInvCodedScale () { return m_aaiCodedScale [1]; }
1691	Int* getInvCodedOffset () { return m_aaiCodedOffset[1]; }
1692
1693	#if LGE_ILLUCOMP_B0045
1694	Void setApplyIC ( Bool b ) { m_bApplyIC = b; }
1695	Bool getApplyIC () { return m_bApplyIC; }
1696	Void xSetApplyIC ();
1697	#endif
1698
1699	#if FORCE_REF_VSP
1700	Void setRefIdxVsp ( Int idx, Int refList ) { m_iRefIdxVsp[refList] = idx; }
1701	Int getRefIdxVsp ( Int refList ) { return m_iRefIdxVsp[refList]; }
1702	#endif
1703
1704	#if VSP_SLICE_HEADER
1705	Void setVspFlag ( Bool val ) { m_bVspFlag = val; }
1706	Bool getVspFlag () { return m_bVspFlag; }
1707	#if VSP_CFG
1708	Void setNumVspRefPics( UInt val ) { m_uiNumVspRefPics = val; }
1709	UInt getNumVspRefPics() { return m_uiNumVspRefPics; }
1710	Void setVspRefPos( UInt dir, UInt idx, UInt val ) { m_uiVspRefPos[dir][idx] = val; }
1711	UInt getVspRefPos( UInt dir, UInt idx ) { return m_uiVspRefPos[dir][idx]; }
1712	#else
1713	Void setVspDepthDisableFlag( Bool val ) { m_bVspDepthDisableFlag = val; }
1714	Bool getVspDepthDisableFlag() { return m_bVspDepthDisableFlag; }
1715	#endif
1716	#endif
1717
1718	protected:
1719	TComPic* xGetRefPic (TComList<TComPic*>& rcListPic, UInt uiPOC);
1720	TComPic* xGetLongTermRefPic(TComList<TComPic*>& rcListPic, UInt uiPOC);
1721	TComPic* xGetInterViewRefPic( std::vector<TComPic*>& rcListIvPic, UInt uiViewId );
1722	};// END CLASS DEFINITION TComSlice
1723
1724
1725	template <class T> class ParameterSetMap
1726	{
1727	public:
1728	ParameterSetMap(Int maxId)
1729	:m_maxId (maxId)
1730	{}
1731
1732	~ParameterSetMap()
1733	{
1734	for (typename std::map<Int,T *>::iterator i = m_paramsetMap.begin(); i!= m_paramsetMap.end(); i++)
1735	{
1736	delete (*i).second;
1737	}
1738	}
1739
1740	Void storePS(Int psId, T *ps)
1741	{
1742	assert ( psId < m_maxId );
1743	if ( m_paramsetMap.find(psId) != m_paramsetMap.end() )
1744	{
1745	delete m_paramsetMap[psId];
1746	}
1747	m_paramsetMap[psId] = ps;
1748	}
1749
1750	Void mergePSList(ParameterSetMap<T> &rPsList)
1751	{
1752	for (typename std::map<Int,T *>::iterator i = rPsList.m_paramsetMap.begin(); i!= rPsList.m_paramsetMap.end(); i++)
1753	{
1754	storePS(i->first, i->second);
1755	}
1756	rPsList.m_paramsetMap.clear();
1757	}
1758
1759
1760	T* getPS(Int psId)
1761	{
1762	return ( m_paramsetMap.find(psId) == m_paramsetMap.end() ) ? NULL : m_paramsetMap[psId];
1763	}
1764
1765	T* getFirstPS()
1766	{
1767	return (m_paramsetMap.begin() == m_paramsetMap.end() ) ? NULL : m_paramsetMap.begin()->second;
1768	}
1769
1770	#if QC_MVHEVC_B0046
1771	Void clearPSList()
1772	{
1773	m_paramsetMap.clear();
1774	}
1775	#endif
1776	private:
1777	std::map<Int,T *> m_paramsetMap;
1778	Int m_maxId;
1779	};
1780
1781	class ParameterSetManager
1782	{
1783	public:
1784	ParameterSetManager();
1785	virtual ~ParameterSetManager();
1786	#if VIDYO_VPS_INTEGRATION\|QC_MVHEVC_B0046
1787	//! store video parameter set and take ownership of it
1788	Void storeVPS(TComVPS *vps) { m_vpsMap.storePS( vps->getVPSId(), vps); };
1789	//! get pointer to existing video parameter set
1790	TComVPS* getVPS(Int vpsId) { return m_vpsMap.getPS(vpsId); };
1791	TComVPS* getFirstVPS() { return m_vpsMap.getFirstPS(); };
1792	#if QC_MVHEVC_B0046
1793	Void clearVPS() { m_vpsMap.clearPSList(); };
1794	Void clearSPS() { m_spsMap.clearPSList(); };
1795	Void clearPPS() { m_ppsMap.clearPSList(); };
1796	#endif
1797	#endif
1798	//! store sequence parameter set and take ownership of it
1799	Void storeSPS(TComSPS *sps) { m_spsMap.storePS( sps->getSPSId(), sps); };
1800	//! get pointer to existing sequence parameter set
1801	TComSPS* getSPS(Int spsId) { return m_spsMap.getPS(spsId); };
1802	TComSPS* getFirstSPS() { return m_spsMap.getFirstPS(); };
1803
1804	//! store picture parameter set and take ownership of it
1805	Void storePPS(TComPPS *pps) { m_ppsMap.storePS( pps->getPPSId(), pps); };
1806	//! get pointer to existing picture parameter set
1807	TComPPS* getPPS(Int ppsId) { return m_ppsMap.getPS(ppsId); };
1808	TComPPS* getFirstPPS() { return m_ppsMap.getFirstPS(); };
1809
1810	//! store adaptation parameter set and take ownership of it
1811	Void storeAPS(TComAPS *aps) { m_apsMap.storePS( aps->getAPSID(), aps); };
1812	//! getPointer to existing adaptation parameter set
1813	TComAPS* getAPS(Int apsId) { return m_apsMap.getPS(apsId); };
1814
1815	protected:
1816	ParameterSetMap<TComSPS> m_spsMap;
1817	ParameterSetMap<TComPPS> m_ppsMap;
1818	ParameterSetMap<TComAPS> m_apsMap;
1819	#if VIDYO_VPS_INTEGRATION\|QC_MVHEVC_B0046
1820	ParameterSetMap<TComVPS> m_vpsMap;
1821	#endif
1822	};
1823
1824	//! \}
1825
1826	#endif // __TCOMSLICE__

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComSlice.h @ 213

Download in other formats: