Context navigation

source: 3DVCSoftware/branches/0.3-poznan-univ/source/Lib/TLibCommon/TComSlice.h @ 29

Visit:

Last change on this file since 29 was 28, checked in by poznan-univ, 15 years ago

Poznan Tools

Encoding only disoccluded CUs in depended views
Depth based motion prediction
Texture QP adjustment based on depth data
Nonlinear depth representation

Property svn:eol-style set to native

File size: 28.7 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-2011, 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 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
35
36	/** \file TComSlice.h
37	\brief slice header and SPS class (header)
38	*/
39
40	#ifndef __TCOMSLICE__
41	#define __TCOMSLICE__
42
43
44	#include "CommonDef.h"
45	#ifdef WEIGHT_PRED
46	#include <string.h> // To avoid compilation failure with some g++ linux compilators...
47	#endif
48	#include "TComList.h"
49	#include <math.h>
50
51	class TComPic;
52	#if DEPTH_MAP_GENERATION
53	class TComDepthMapGenerator;
54	#endif
55	#if HHI_INTER_VIEW_RESIDUAL_PRED
56	class TComResidualGenerator;
57	#endif
58
59	#if POZNAN_MP
60	//#include "../TLibCommon/TComMP.h"
61	class TComMP;
62	#endif
63
64	// ====================================================================================================================
65	// Class definition
66	// ====================================================================================================================
67
68	/// SPS class
69	class TComSPS
70	{
71	private:
72	// Structure
73	UInt m_uiSPSId;
74	UInt m_uiWidth;
75	UInt m_uiHeight;
76	Int m_aiPad[2];
77	UInt m_uiMaxCUWidth;
78	UInt m_uiMaxCUHeight;
79	UInt m_uiMaxCUDepth;
80	UInt m_uiMinTrDepth;
81	UInt m_uiMaxTrDepth;
82
83	UInt m_uiViewId;
84	Int m_iViewOrderIdx;
85	Bool m_bDepth;
86	UInt m_uiCamParPrecision;
87	Bool m_bCamParInSliceHeader;
88	Int m_aaiCodedScale [2][MAX_NUMBER_VIEWS];
89	Int m_aaiCodedOffset[2][MAX_NUMBER_VIEWS];
90
91	// Tool list
92	UInt m_uiQuadtreeTULog2MaxSize;
93	UInt m_uiQuadtreeTULog2MinSize;
94	UInt m_uiQuadtreeTUMaxDepthInter;
95	UInt m_uiQuadtreeTUMaxDepthIntra;
96	Bool m_bUseALF;
97	Bool m_bUseDQP;
98	#if !HHI_NO_LowDelayCoding
99	Bool m_bUseLDC;
100	#endif
101	Bool m_bUsePAD;
102	Bool m_bUseMRG; // SOPH:
103
104	#if LM_CHROMA
105	Bool m_bUseLMChroma; // JL:
106	#endif
107
108	#if DCM_COMB_LIST
109	Bool m_bUseLComb;
110	Bool m_bLCMod;
111	#endif
112
113	#if HHI_RMP_SWITCH
114	Bool m_bUseRMP;
115	#endif
116	// Parameter
117	AMVP_MODE m_aeAMVPMode[MAX_CU_DEPTH];
118	UInt m_uiBitDepth;
119	UInt m_uiBitIncrement;
120
121	// Max physical transform size
122	UInt m_uiMaxTrSize;
123
124	Int m_iAMPAcc[MAX_CU_DEPTH];
125
126	#if MTK_NONCROSS_INLOOP_FILTER
127	Bool m_bLFCrossSliceBoundaryFlag;
128	#endif
129	#if MTK_SAO
130	Bool m_bUseSAO;
131	#endif
132	#if HHI_MPI
133	Bool m_bUseMVI;
134	#endif
135
136	UInt m_uiCodedPictureBufferSize ;
137
138	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
139	Bool m_bUseDMM;
140	#endif
141
142	#if DEPTH_MAP_GENERATION
143	UInt m_uiPredDepthMapGeneration;
144	UInt m_uiPdmPrecision;
145	Int m_aiPdmScaleNomDelta[MAX_NUMBER_VIEWS];
146	Int m_aiPdmOffset [MAX_NUMBER_VIEWS];
147	#endif
148	#if HHI_INTER_VIEW_MOTION_PRED
149	UInt m_uiMultiviewMvPredMode;
150	#endif
151	#if HHI_INTER_VIEW_RESIDUAL_PRED
152	UInt m_uiMultiviewResPredMode;
153	#endif
154
155	#if POZNAN_DBMP
156	UInt m_uiDBMP;
157	#endif
158
159	#if POZNAN_ENCODE_ONLY_DISOCCLUDED_CU
160	UInt m_uiUseCUSkip;
161	#endif
162
163	#if DEPTH_MAP_GENERATION
164	TComDepthMapGenerator* m_pcDepthMapGenerator;
165	#endif
166	#if HHI_INTER_VIEW_RESIDUAL_PRED
167	TComResidualGenerator* m_pcResidualGenerator;
168	#endif
169
170	#if POZNAN_NONLINEAR_DEPTH
171	Float m_fDepthPower;
172	#endif
173
174	#if POZNAN_MP
175	TComMP* m_pcMP;
176	#endif
177	#if POZNAN_TEXTURE_TU_DELTA_QP_ACCORDING_TO_DEPTH
178	Bool m_bUseTexDqpAccordingToDepth;
179	#endif
180
181	public:
182	TComSPS();
183	virtual ~TComSPS();
184
185	// structure
186	Void setSPSId ( UInt u ) { m_uiSPSId = u; }
187	UInt getSPSId () { return m_uiSPSId; }
188	Void setWidth ( UInt u ) { m_uiWidth = u; }
189	UInt getWidth () { return m_uiWidth; }
190	Void setHeight ( UInt u ) { m_uiHeight = u; }
191	UInt getHeight () { return m_uiHeight; }
192	Void setMaxCUWidth ( UInt u ) { m_uiMaxCUWidth = u; }
193	UInt getMaxCUWidth () { return m_uiMaxCUWidth; }
194	Void setMaxCUHeight ( UInt u ) { m_uiMaxCUHeight = u; }
195	UInt getMaxCUHeight () { return m_uiMaxCUHeight; }
196	Void setMaxCUDepth ( UInt u ) { m_uiMaxCUDepth = u; }
197	UInt getMaxCUDepth () { return m_uiMaxCUDepth; }
198	Void setMinTrDepth ( UInt u ) { m_uiMinTrDepth = u; }
199	UInt getMinTrDepth () { return m_uiMinTrDepth; }
200	Void setMaxTrDepth ( UInt u ) { m_uiMaxTrDepth = u; }
201	UInt getMaxTrDepth () { return m_uiMaxTrDepth; }
202	Void setQuadtreeTULog2MaxSize( UInt u ) { m_uiQuadtreeTULog2MaxSize = u; }
203	UInt getQuadtreeTULog2MaxSize() { return m_uiQuadtreeTULog2MaxSize; }
204	Void setQuadtreeTULog2MinSize( UInt u ) { m_uiQuadtreeTULog2MinSize = u; }
205	UInt getQuadtreeTULog2MinSize() { return m_uiQuadtreeTULog2MinSize; }
206	Void setQuadtreeTUMaxDepthInter( UInt u ) { m_uiQuadtreeTUMaxDepthInter = u; }
207	Void setQuadtreeTUMaxDepthIntra( UInt u ) { m_uiQuadtreeTUMaxDepthIntra = u; }
208	UInt getQuadtreeTUMaxDepthInter() { return m_uiQuadtreeTUMaxDepthInter; }
209	UInt getQuadtreeTUMaxDepthIntra() { return m_uiQuadtreeTUMaxDepthIntra; }
210	Void setPad (Int iPad[2]) { m_aiPad[0] = iPad[0]; m_aiPad[1] = iPad[1]; }
211	Void setPadX ( Int u ) { m_aiPad[0] = u; }
212	Void setPadY ( Int u ) { m_aiPad[1] = u; }
213	Int getPad ( Int u ) { assert(u < 2); return m_aiPad[u];}
214	Int* getPad ( ) { return m_aiPad; }
215
216	Void initMultiviewSPS ( UInt uiViewId, Int iViewOrderIdx = 0, UInt uiCamParPrecision = 0, Bool bCamParSlice = false, Int aaiScale = 0, Int aaiOffset = 0 );
217	Void initMultiviewSPSDepth ( UInt uiViewId, Int iViewOrderIdx );
218
219	UInt getViewId () { return m_uiViewId; }
220	Int getViewOrderIdx () { return m_iViewOrderIdx; }
221	Bool isDepth () { return m_bDepth; }
222	UInt getCamParPrecision () { return m_uiCamParPrecision; }
223	Bool hasCamParInSliceHeader() { return m_bCamParInSliceHeader; }
224	Int* getCodedScale () { return m_aaiCodedScale [0]; }
225	Int* getCodedOffset () { return m_aaiCodedOffset[0]; }
226	Int* getInvCodedScale () { return m_aaiCodedScale [1]; }
227	Int* getInvCodedOffset () { return m_aaiCodedOffset[1]; }
228
229	// physical transform
230	Void setMaxTrSize ( UInt u ) { m_uiMaxTrSize = u; }
231	UInt getMaxTrSize () { return m_uiMaxTrSize; }
232
233	// Tool list
234	#if POZNAN_ENCODE_ONLY_DISOCCLUDED_CU
235	Bool getUseALF () { return (getViewId()>0)?false:m_bUseALF;} //todo fix ALF
236	#else
237	Bool getUseALF () { return m_bUseALF; }
238	#endif
239	Bool getUseDQP () { return m_bUseDQP; }
240
241	#if !HHI_NO_LowDelayCoding
242	Bool getUseLDC () { return m_bUseLDC; }
243	#endif
244	Bool getUsePAD () { return m_bUsePAD; }
245	Bool getUseMRG () { return m_bUseMRG; } // SOPH:
246
247	Void setUseALF ( Bool b ) { m_bUseALF = b; }
248	Void setUseDQP ( Bool b ) { m_bUseDQP = b; }
249
250	#if !HHI_NO_LowDelayCoding
251	Void setUseLDC ( Bool b ) { m_bUseLDC = b; }
252	#endif
253	Void setUsePAD ( Bool b ) { m_bUsePAD = b; }
254	Void setUseMRG ( Bool b ) { m_bUseMRG = b; } // SOPH:
255
256	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
257	Bool getUseDMM() { return m_bUseDMM; }
258	Void setUseDMM( Bool b ) { m_bUseDMM = b; }
259	#endif
260
261
262	#if DCM_COMB_LIST
263	Void setUseLComb (Bool b) { m_bUseLComb = b; }
264	Bool getUseLComb () { return m_bUseLComb; }
265	Void setLCMod (Bool b) { m_bLCMod = b; }
266	Bool getLCMod () { return m_bLCMod; }
267	#endif
268
269	#if HHI_RMP_SWITCH
270	Bool getUseRMP () { return m_bUseRMP; }
271	Void setUseRMP ( Bool b ) { m_bUseRMP = b; }
272	#endif
273
274	#if LM_CHROMA
275	Bool getUseLMChroma () { return m_bUseLMChroma; }
276	Void setUseLMChroma ( Bool b ) { m_bUseLMChroma = b; }
277	#endif
278
279	// AMVP mode (for each depth)
280	AMVP_MODE getAMVPMode ( UInt uiDepth ) { assert(uiDepth < g_uiMaxCUDepth); return m_aeAMVPMode[uiDepth]; }
281	Void setAMVPMode ( UInt uiDepth, AMVP_MODE eMode) { assert(uiDepth < g_uiMaxCUDepth); m_aeAMVPMode[uiDepth] = eMode; }
282
283	// Bit-depth
284	UInt getBitDepth () { return m_uiBitDepth; }
285	Void setBitDepth ( UInt u ) { m_uiBitDepth = u; }
286	UInt getBitIncrement () { return m_uiBitIncrement; }
287	Void setBitIncrement ( UInt u ) { m_uiBitIncrement = u; }
288
289	#if MTK_NONCROSS_INLOOP_FILTER
290	Void setLFCrossSliceBoundaryFlag ( Bool bValue ) { m_bLFCrossSliceBoundaryFlag = bValue; }
291	Bool getLFCrossSliceBoundaryFlag () { return m_bLFCrossSliceBoundaryFlag; }
292	#endif
293
294	#if MTK_SAO
295	Void setUseSAO (Bool bVal) {m_bUseSAO = bVal;}
296	#if POZNAN_ENCODE_ONLY_DISOCCLUDED_CU //todo fix SAO
297	Bool getUseSAO () { return (getViewId()>0)?false:m_bUseSAO;}
298	#else
299	Bool getUseSAO () {return m_bUseSAO;}
300	#endif
301	#endif
302
303	#if HHI_MPI
304	Void setUseMVI (Bool bVal) {m_bUseMVI = bVal;}
305	Bool getUseMVI () {return m_bUseMVI;}
306	#endif
307
308	Void setCodedPictureBufferSize( UInt u ) { m_uiCodedPictureBufferSize = u ;}
309	UInt getCodedPictureBufferSize( ) { return m_uiCodedPictureBufferSize ;}
310
311	#if DEPTH_MAP_GENERATION
312	Void setPredDepthMapGeneration( UInt uiViewId, Bool bIsDepth, UInt uiPdmGenMode = 0, UInt uiPdmMvPredMode = 0, UInt uiPdmPrec = 0, Int aaiPdmScaleNomDelta = 0, Int aaiPdmOffset = 0 );
313	#endif
314	#if HHI_INTER_VIEW_RESIDUAL_PRED
315	Void setMultiviewResPredMode ( UInt uiResPrdMode ) { m_uiMultiviewResPredMode = uiResPrdMode; }
316	#endif
317
318	#if POZNAN_DBMP
319	Void setDBMP ( UInt uiDBMP ) { m_uiDBMP = uiDBMP; }
320	#endif
321
322	#if POZNAN_ENCODE_ONLY_DISOCCLUDED_CU
323	Void setUseCUSkip ( UInt uiUseCUSkip ) { m_uiUseCUSkip = uiUseCUSkip; }
324	#endif
325
326	#if DEPTH_MAP_GENERATION
327	UInt getPredDepthMapGeneration() { return m_uiPredDepthMapGeneration; }
328	UInt getPdmPrecision () { return m_uiPdmPrecision; }
329	Int* getPdmScaleNomDelta () { return m_aiPdmScaleNomDelta; }
330	Int* getPdmOffset () { return m_aiPdmOffset; }
331	#endif
332	#if HHI_INTER_VIEW_MOTION_PRED
333	UInt getMultiviewMvPredMode () { return m_uiMultiviewMvPredMode; }
334	#endif
335	#if HHI_INTER_VIEW_RESIDUAL_PRED
336	UInt getMultiviewResPredMode () { return m_uiMultiviewResPredMode; }
337	#endif
338
339	#if POZNAN_DBMP
340	UInt getDBMP () { return m_uiDBMP; }
341	#endif
342
343	#if POZNAN_ENCODE_ONLY_DISOCCLUDED_CU
344	UInt getUseCUSkip () { return m_uiUseCUSkip; }
345	#endif
346
347	#if DEPTH_MAP_GENERATION
348	Void setDepthMapGenerator( TComDepthMapGenerator* pcDepthMapGenerator ) { m_pcDepthMapGenerator = pcDepthMapGenerator; }
349	TComDepthMapGenerator* getDepthMapGenerator() { return m_pcDepthMapGenerator; }
350	#endif
351	#if HHI_INTER_VIEW_RESIDUAL_PRED
352	Void setResidualGenerator( TComResidualGenerator* pcResidualGenerator ) { m_pcResidualGenerator = pcResidualGenerator; }
353	TComResidualGenerator* getResidualGenerator() { return m_pcResidualGenerator; }
354	#endif
355	#if POZNAN_NONLINEAR_DEPTH
356	inline Void setDepthPower(Float p) {m_fDepthPower = p;}
357	inline Float getDepthPower() {return m_fDepthPower;}
358	#else
359	inline Float getDepthPower() {return 1.0f;}
360	#endif
361	#if POZNAN_TEXTURE_TU_DELTA_QP_ACCORDING_TO_DEPTH
362	Void setUseTexDqpAccordingToDepth (Bool bVal) {m_bUseTexDqpAccordingToDepth = bVal;}
363	Bool getUseTexDqpAccordingToDepth () {return m_bUseTexDqpAccordingToDepth;}
364	#endif
365	};
366
367	/// PPS class
368	class TComPPS
369	{
370	private:
371	#if CONSTRAINED_INTRA_PRED
372	Bool m_bConstrainedIntraPred; // constrained_intra_pred_flag
373	#endif
374	#ifdef WEIGHT_PRED
375	Bool m_bUseWeightPred; // Use of Weighting Prediction (P_SLICE)
376	UInt m_uiBiPredIdc; // Use of Weighting Bi-Prediction (B_SLICE)
377	#endif
378	UInt m_uiPPSId;
379	UInt m_uiSPSId;
380
381	public:
382	TComPPS();
383	virtual ~TComPPS();
384
385	Void setPPSId ( UInt u ) { m_uiPPSId = u; }
386	UInt getPPSId () { return m_uiPPSId; }
387	Void setSPSId ( UInt u ) { m_uiSPSId = u; }
388	UInt getSPSId () { return m_uiSPSId; }
389	#if CONSTRAINED_INTRA_PRED
390	Bool getConstrainedIntraPred () { return m_bConstrainedIntraPred; }
391	Void setConstrainedIntraPred ( Bool b ) { m_bConstrainedIntraPred = b; }
392	#endif
393
394	#ifdef WEIGHT_PRED
395	Bool getUseWP () { return m_bUseWeightPred; }
396	UInt getWPBiPredIdc () { return m_uiBiPredIdc; }
397
398	Void setUseWP ( Bool b ) { m_bUseWeightPred = b; }
399	Void setWPBiPredIdc ( UInt u ) { m_uiBiPredIdc = u; }
400	#endif
401	};
402
403	#ifdef WEIGHT_PRED
404	typedef struct {
405	// Explicit weighted prediction parameters parsed in slice header,
406	// or Implicit weighted prediction parameters (8 bits depth values).
407	Bool bPresentFlag;
408	UInt uiLog2WeightDenom;
409	Int iWeight;
410	Int iOffset;
411
412	// Weighted prediction scaling values built from above parameters (bitdepth scaled):
413	Int w, o, offset, shift, round;
414	} wpScalingParam;
415
416	typedef struct {
417	Int64 iAC;
418	Int64 iDC;
419	} wpACDCParam;
420	#endif
421
422	/// slice header class
423	class TComSlice
424	{
425
426	private:
427	// Bitstream writing
428	UInt m_uiPPSId;
429	Int m_iPOC;
430	#if SONY_COLPIC_AVAILABILITY
431	Int m_iViewOrderIdx;
432	#endif
433	#if DCM_DECODING_REFRESH
434	NalUnitType m_eNalUnitType; ///< Nal unit type for the slice
435	#endif
436	SliceType m_eSliceType;
437	Int m_iSliceQp;
438	Int m_iSymbolMode;
439	Bool m_bLoopFilterDisable;
440
441	#if DCM_COMB_LIST
442	Int m_aiNumRefIdx [3]; // for multiple reference of current slice
443
444	Int m_iRefIdxOfLC[2][MAX_NUM_REF_LC];
445	Int m_eListIdFromIdxOfLC[MAX_NUM_REF_LC];
446	Int m_iRefIdxFromIdxOfLC[MAX_NUM_REF_LC];
447	Int m_iRefIdxOfL1FromRefIdxOfL0[MAX_NUM_REF_LC];
448	Int m_iRefIdxOfL0FromRefIdxOfL1[MAX_NUM_REF_LC];
449	Bool m_bRefPicListModificationFlagLC;
450	Bool m_bRefPicListCombinationFlag;
451	#else
452	Int m_aiNumRefIdx [2]; // for multiple reference of current slice
453	#endif
454
455	// Data
456	Int m_iSliceQpDelta;
457	TComPic* m_apcRefPicList [2][MAX_NUM_REF];
458	Int m_aiRefPOCList [2][MAX_NUM_REF];
459	Int m_iDepth;
460	TComPic* m_pcTexturePic;
461
462	// referenced slice?
463	Bool m_bRefenced;
464	#ifdef ROUNDING_CONTROL_BIPRED
465	Bool m_bRounding;
466	#endif
467
468	// access channel
469	TComSPS* m_pcSPS;
470	TComPPS* m_pcPPS;
471	TComPic* m_pcPic;
472
473	UInt m_uiColDir; // direction to get colocated CUs
474
475	Double m_dLambda;
476
477	Bool m_abEqualRef [2][MAX_NUM_REF][MAX_NUM_REF];
478
479	Int m_iViewIdx;
480	Int m_aiRefViewList[2][MAX_INPUT_VIEW_NUM];
481
482	Bool m_bNoBackPredFlag;
483	#if MS_LCEC_LOOKUP_TABLE_EXCEPTION
484	Bool m_bRefIdxCombineCoding;
485	#endif
486
487	Int m_aaiCodedScale [2][MAX_NUMBER_VIEWS];
488	Int m_aaiCodedOffset[2][MAX_NUMBER_VIEWS];
489
490	UInt m_uiSliceMode;
491	UInt m_uiSliceArgument;
492	UInt m_uiSliceCurStartCUAddr;
493	UInt m_uiSliceCurEndCUAddr;
494	UInt m_uiSliceIdx;
495	UInt m_uiEntropySliceMode;
496	UInt m_uiEntropySliceArgument;
497	UInt m_uiEntropySliceCurStartCUAddr;
498	UInt m_uiEntropySliceCurEndCUAddr;
499	Bool m_bNextSlice;
500	Bool m_bNextEntropySlice;
501	UInt m_uiSliceBits;
502
503	#ifdef WEIGHT_PRED
504	wpScalingParam m_weightPredTable[2][MAX_NUM_REF][3]; // [REF_PIC_LIST_0 or REF_PIC_LIST_1][refIdx][0:Y, 1:U, 2:V]
505	wpACDCParam m_weightACDCParam[3]; // [0:Y, 1:U, 2:V]
506	#endif
507
508	#if POZNAN_MP
509	TComMP* m_pcMP;
510	#endif
511
512	public:
513	TComSlice();
514	#if POZNAN_MP
515	~TComSlice();
516	#else
517	virtual ~TComSlice();
518	#endif
519
520	Void initSlice ();
521
522	Void setSPS ( TComSPS* pcSPS ) { m_pcSPS = pcSPS; }
523	TComSPS* getSPS () { return m_pcSPS; }
524
525	Void setPPS ( TComPPS* pcPPS ) { m_pcPPS = pcPPS; }
526	TComPPS* getPPS () { return m_pcPPS; }
527
528	UInt getPPSId () { return m_uiPPSId; }
529	SliceType getSliceType () { return m_eSliceType; }
530	Int getPOC () { return m_iPOC; }
531	#if SONY_COLPIC_AVAILABILITY
532	Int getViewOrderIdx () { return m_iViewOrderIdx; }
533	#endif
534	Int getSliceQp () { return m_iSliceQp; }
535	Int getSliceQpDelta () { return m_iSliceQpDelta; }
536	Int getSymbolMode () { return m_iSymbolMode; }
537	Bool getLoopFilterDisable() { return m_bLoopFilterDisable; }
538	Int getNumRefIdx ( RefPicList e ) { return m_aiNumRefIdx[e]; }
539	TComPic* getPic () { return m_pcPic; }
540	TComPic* getRefPic ( RefPicList e, Int iRefIdx) { return m_apcRefPicList[e][iRefIdx]; }
541	Int getRefPOC ( RefPicList e, Int iRefIdx) { return m_aiRefPOCList[e][iRefIdx]; }
542	Int getDepth () { return m_iDepth; }
543	UInt getColDir () { return m_uiColDir; }
544
545	#if DCM_COMB_LIST
546	Int getRefIdxOfLC (RefPicList e, Int iRefIdx) { return m_iRefIdxOfLC[e][iRefIdx]; }
547	Int getListIdFromIdxOfLC(Int iRefIdx) { return m_eListIdFromIdxOfLC[iRefIdx]; }
548	Int getRefIdxFromIdxOfLC(Int iRefIdx) { return m_iRefIdxFromIdxOfLC[iRefIdx]; }
549	Int getRefIdxOfL0FromRefIdxOfL1(Int iRefIdx) { return m_iRefIdxOfL0FromRefIdxOfL1[iRefIdx];}
550	Int getRefIdxOfL1FromRefIdxOfL0(Int iRefIdx) { return m_iRefIdxOfL1FromRefIdxOfL0[iRefIdx];}
551	Bool getRefPicListModificationFlagLC() {return m_bRefPicListModificationFlagLC;}
552	Void setRefPicListModificationFlagLC(Bool bflag) {m_bRefPicListModificationFlagLC=bflag;}
553	Bool getRefPicListCombinationFlag() {return m_bRefPicListCombinationFlag;}
554	Void setRefPicListCombinationFlag(Bool bflag) {m_bRefPicListCombinationFlag=bflag;}
555	Void setListIdFromIdxOfLC(Int iRefIdx, UInt uiVal) { m_eListIdFromIdxOfLC[iRefIdx]=uiVal; }
556	Void setRefIdxFromIdxOfLC(Int iRefIdx, UInt uiVal) { m_iRefIdxFromIdxOfLC[iRefIdx]=uiVal; }
557	Void setRefIdxOfLC (RefPicList e, Int iRefIdx, Int RefIdxLC) { m_iRefIdxOfLC[e][iRefIdx]=RefIdxLC;}
558	#endif
559
560	Void setReferenced(Bool b) { m_bRefenced = b; }
561	Bool isReferenced() { return m_bRefenced; }
562	#ifdef ROUNDING_CONTROL_BIPRED
563	Void setRounding(Bool bRound) { m_bRounding = bRound; }
564	Bool isRounding() { return m_bRounding; }
565	#endif
566
567	Void setPPSId ( UInt u ) { m_uiPPSId = u; }
568	Void setPOC ( Int i ) { m_iPOC = i; }
569	#if SONY_COLPIC_AVAILABILITY
570	Void setViewOrderIdx ( Int i ) { m_iViewOrderIdx = i; }
571	#endif
572	#if DCM_DECODING_REFRESH
573	Void setNalUnitType ( NalUnitType e ) { m_eNalUnitType = e; }
574	NalUnitType getNalUnitType () { return m_eNalUnitType; }
575	Void decodingRefreshMarking(UInt& uiPOCCDR, Bool& bRefreshPending, TComList<TComPic*>& rcListPic);
576	#endif
577	Void setSliceType ( SliceType e ) { m_eSliceType = e; }
578	Void setSliceQp ( Int i ) { m_iSliceQp = i; }
579	Void setSliceQpDelta ( Int i ) { m_iSliceQpDelta = i; }
580	Void setSymbolMode ( Int b ) { m_iSymbolMode = b; }
581	Void setLoopFilterDisable( Bool b ) { m_bLoopFilterDisable= b; }
582
583	Void setRefPic ( TComPic* p, RefPicList e, Int iRefIdx ) { m_apcRefPicList[e][iRefIdx] = p; }
584	Void setRefPOC ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefPOCList[e][iRefIdx] = i; }
585	Void setNumRefIdx ( RefPicList e, Int i ) { m_aiNumRefIdx[e] = i; }
586	Void setPic ( TComPic* p ) { m_pcPic = p; }
587	Void setDepth ( Int iDepth ) { m_iDepth = iDepth; }
588
589	Void setRefPicList ( TComList<TComPic*>& rcListPic );
590	Void setRefPOCList ();
591	Void setColDir ( UInt uiDir ) { m_uiColDir = uiDir; }
592
593	Void setRefPicListFromGOPSTring( TComList<TComPic>& rcListPic, std::vector<TComPic>& rapcSpatRefPics );
594	Void setRefPicListExplicitlyDecoderSided( TComList<TComPic>& rcListPic, std::vector<TComPic>& rapcSpatRefPics );
595
596	Bool isIntra () { return m_eSliceType == I_SLICE; }
597	Bool isInterB () { return m_eSliceType == B_SLICE; }
598	Bool isInterP () { return m_eSliceType == P_SLICE; }
599
600	Void setLambda( Double d ) { m_dLambda = d; }
601	Double getLambda() { return m_dLambda; }
602
603	Void setViewIdx(Int i) { m_iViewIdx = i; }
604	Int getViewIdx() { return m_iViewIdx; }
605
606	Void setRefViewIdx ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefViewList[e][iRefIdx] = i; }
607	Int getRefViewIdx ( RefPicList e, Int iRefIdx) { return m_aiRefViewList[e][iRefIdx]; }
608
609	Void initEqualRef();
610	Bool isEqualRef ( RefPicList e, Int iRefIdx1, Int iRefIdx2 )
611	{
612	if (iRefIdx1 < 0 \|\| iRefIdx2 < 0) return false;
613	return m_abEqualRef[e][iRefIdx1][iRefIdx2];
614	}
615
616	Void setEqualRef( RefPicList e, Int iRefIdx1, Int iRefIdx2, Bool b)
617	{
618	m_abEqualRef[e][iRefIdx1][iRefIdx2] = m_abEqualRef[e][iRefIdx2][iRefIdx1] = b;
619	}
620
621	static Void sortPicList ( TComList<TComPic*>& rcListPic );
622
623	Bool getNoBackPredFlag() { return m_bNoBackPredFlag; }
624	Void setNoBackPredFlag( Bool b ) { m_bNoBackPredFlag = b; }
625	#if MS_LCEC_LOOKUP_TABLE_EXCEPTION
626	Bool getRefIdxCombineCoding() { return m_bRefIdxCombineCoding; }
627	Void setRefIdxCombineCoding( Bool b ) { m_bRefIdxCombineCoding = b; }
628	#endif
629	#if DCM_COMB_LIST
630	Void generateCombinedList ();
631	#endif
632	Void setSliceMode ( UInt uiMode ) { m_uiSliceMode = uiMode; }
633	UInt getSliceMode () { return m_uiSliceMode; }
634	Void setSliceArgument ( UInt uiArgument ) { m_uiSliceArgument = uiArgument; }
635	UInt getSliceArgument () { return m_uiSliceArgument; }
636	Void setSliceCurStartCUAddr ( UInt uiAddr ) { m_uiSliceCurStartCUAddr = uiAddr; }
637	UInt getSliceCurStartCUAddr () { return m_uiSliceCurStartCUAddr; }
638	Void setSliceCurEndCUAddr ( UInt uiAddr ) { m_uiSliceCurEndCUAddr = uiAddr; }
639	UInt getSliceCurEndCUAddr () { return m_uiSliceCurEndCUAddr; }
640	Void setSliceIdx ( UInt i) { m_uiSliceIdx = i; }
641	UInt getSliceIdx () { return m_uiSliceIdx; }
642	Void copySliceInfo (TComSlice *pcSliceSrc);
643	Void setEntropySliceMode ( UInt uiMode ) { m_uiEntropySliceMode = uiMode; }
644	UInt getEntropySliceMode () { return m_uiEntropySliceMode; }
645	Void setEntropySliceArgument ( UInt uiArgument ) { m_uiEntropySliceArgument = uiArgument; }
646	UInt getEntropySliceArgument () { return m_uiEntropySliceArgument; }
647	Void setEntropySliceCurStartCUAddr ( UInt uiAddr ) { m_uiEntropySliceCurStartCUAddr = uiAddr; }
648	UInt getEntropySliceCurStartCUAddr () { return m_uiEntropySliceCurStartCUAddr; }
649	Void setEntropySliceCurEndCUAddr ( UInt uiAddr ) { m_uiEntropySliceCurEndCUAddr = uiAddr; }
650	UInt getEntropySliceCurEndCUAddr () { return m_uiEntropySliceCurEndCUAddr; }
651	Void setNextSlice ( Bool b ) { m_bNextSlice = b; }
652	Bool isNextSlice () { return m_bNextSlice; }
653	Void setNextEntropySlice ( Bool b ) { m_bNextEntropySlice = b; }
654	Bool isNextEntropySlice () { return m_bNextEntropySlice; }
655	Void setSliceBits ( UInt uiVal ) { m_uiSliceBits = uiVal; }
656	UInt getSliceBits () { return m_uiSliceBits; }
657
658	Void initMultiviewSlice ( Int aaiScale = 0, Int aaiOffset = 0 );
659
660	Int* getCodedScale () { return m_aaiCodedScale [0]; }
661	Int* getCodedOffset () { return m_aaiCodedOffset[0]; }
662	Int* getInvCodedScale () { return m_aaiCodedScale [1]; }
663	Int* getInvCodedOffset () { return m_aaiCodedOffset[1]; }
664
665	Void setTexturePic( TComPic *pcTexturePic ) { m_pcTexturePic = pcTexturePic; }
666	TComPic *getTexturePic() const { return m_pcTexturePic; }
667
668	#ifdef WEIGHT_PRED
669	Void setWpScaling( wpScalingParam wp[2][MAX_NUM_REF][3] ) { memcpy(m_weightPredTable, wp, sizeof(wpScalingParam)2MAX_NUM_REF*3); }
670	Void getWpScaling( RefPicList e, Int iRefIdx, wpScalingParam *&wp);
671	Void displayWpScaling();
672	Void resetWpScaling(wpScalingParam wp[2][MAX_NUM_REF][3]);
673	Void initWpScaling(wpScalingParam wp[2][MAX_NUM_REF][3]);
674	Void initWpScaling();
675	inline Bool applyWP() { return( (m_eSliceType==P_SLICE && m_pcPPS->getUseWP()) \|\| (m_eSliceType==B_SLICE && m_pcPPS->getWPBiPredIdc()) ); }
676
677	Void setWpAcDcParam ( wpACDCParam wp[3] ) { memcpy(m_weightACDCParam, wp, sizeof(wpACDCParam)*3); }
678	Void getWpAcDcParam ( wpACDCParam *&wp );
679	Void initWpAcDcParam();
680	#endif
681
682	#if POZNAN_MP
683	Void setMP(TComMP* pcMP) { m_pcMP = pcMP; }
684	TComMP* getMP() { return m_pcMP; }
685	#endif
686
687	protected:
688	#if 0
689	TComPic* xGetRefPic (TComList<TComPic*>& rcListPic,
690	Bool bDRBFlag,
691	ERBIndex eERBIndex,
692	UInt uiPOCCurr,
693	RefPicList eRefPicList,
694	UInt uiNthRefPic );
695	#endif
696
697	};// END CLASS DEFINITION TComSlice
698
699
700	#endif // __TCOMSLICE__
701

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

Download in other formats: