Context navigation

← Previous revision
Next revision →
Normal
Revision log

TEncCfg.h

Visit:

Last change on this file 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: 40.3 KB

Rev	Line
[5]	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
[56]	4	* granted under this license.
[5]	5	*
[56]	6	* Copyright (c) 2010-2012, ITU/ISO/IEC
[5]	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.
[56]	17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
[5]	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	*/
[2]	33
	34	/** \file TEncCfg.h
	35	\brief encoder configuration class (header)
	36	*/
	37
	38	#ifndef __TENCCFG__
	39	#define __TENCCFG__
	40
	41	#if _MSC_VER > 1000
	42	#pragma once
	43	#endif // _MSC_VER > 1000
	44
[56]	45	#include "TLibCommon/CommonDef.h"
[2]	46	#include <assert.h>
	47
[56]	48	struct GOPEntryMvc
	49	{
	50	Int m_POC;
	51	Int m_QPOffset;
	52	Double m_QPFactor;
	53	Int m_temporalId;
	54	Bool m_refPic;
	55	Int m_numRefPicsActive;
	56	Char m_sliceType;
	57	Int m_numRefPics;
	58	Int m_referencePics[MAX_NUM_REF_PICS];
	59	Int m_usedByCurrPic[MAX_NUM_REF_PICS];
	60	Bool m_interRPSPrediction;
	61	Int m_deltaRIdxMinus1;
	62	Int m_deltaRPS;
	63	Int m_numRefIdc;
	64	Int m_refIdc[MAX_NUM_REF_PICS+1];
	65	Int m_numInterViewRefPics;
	66	Int m_interViewRefs[MAX_NUM_REF_PICS];
	67	Int m_interViewRefPosL0[MAX_NUM_REF_PICS];
	68	Int m_interViewRefPosL1[MAX_NUM_REF_PICS];
[193]	69	#if VSP_CFG
	70	Int m_numVSPRefPics;
	71	Int m_VSPRefPics[MAX_NUM_REF_PICS];
	72	Int m_VSPRefPosL0[MAX_NUM_REF_PICS];
	73	Int m_VSPRefPosL1[MAX_NUM_REF_PICS];
	74	#endif
[56]	75	GOPEntryMvc()
	76	: m_POC(-1)
	77	, m_QPOffset()
	78	, m_QPFactor()
	79	, m_temporalId()
	80	, m_refPic()
	81	, m_numRefPicsActive()
	82	, m_sliceType()
	83	, m_numRefPics()
	84	, m_interRPSPrediction()
	85	, m_deltaRIdxMinus1()
	86	, m_deltaRPS()
	87	, m_numRefIdc()
	88	, m_numInterViewRefPics()
[193]	89	#if VSP_CFG
	90	, m_numVSPRefPics()
	91	#endif
[56]	92	{
	93	::memset( m_referencePics, 0, sizeof(m_referencePics) );
	94	::memset( m_usedByCurrPic, 0, sizeof(m_usedByCurrPic) );
	95	::memset( m_refIdc, 0, sizeof(m_refIdc) );
	96	::memset( m_interViewRefs, 0, sizeof(m_interViewRefs) );
	97	::memset( m_interViewRefPosL0, 0, sizeof(m_interViewRefPosL0) );
	98	::memset( m_interViewRefPosL1, 0, sizeof(m_interViewRefPosL1) );
[193]	99	#if VSP_CFG
	100	::memset( m_VSPRefPics, 0, sizeof(m_VSPRefPics) );
	101	::memset( m_VSPRefPosL0, 0, sizeof(m_VSPRefPosL0) );
	102	::memset( m_VSPRefPosL1, 0, sizeof(m_VSPRefPosL1) );
	103	#endif
[56]	104	}
	105	};
[2]	106
[56]	107	std::istringstream &operator>>(std::istringstream &in, GOPEntryMvc &entry);
	108
	109	//! \ingroup TLibEncoder
	110	//! \{
	111
[2]	112	// ====================================================================================================================
	113	// Class definition
	114	// ====================================================================================================================
	115
	116	/// encoder configuration class
	117	class TEncCfg
	118	{
	119	protected:
	120	//==== File I/O ========
	121	Int m_iFrameRate;
	122	Int m_FrameSkip;
	123	Int m_iSourceWidth;
	124	Int m_iSourceHeight;
[56]	125	#if PIC_CROPPING
	126	Int m_croppingMode;
	127	Int m_cropLeft;
	128	Int m_cropRight;
	129	Int m_cropTop;
	130	Int m_cropBottom;
	131	#endif
[2]	132	Int m_iFrameToBeEncoded;
[56]	133	Double m_adLambdaModifier[ MAX_TLAYER ];
[2]	134
	135	//====== Coding Structure ========
[56]	136	UInt m_uiIntraPeriod;
[2]	137	UInt m_uiDecodingRefreshType; ///< the type of decoding refresh employed for the random access.
[56]	138	Int m_iGOPSize;
	139	GOPEntryMvc m_GOPList[MAX_GOP+1];
	140	Int m_extraRPSs;
	141	#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
	142	Int m_maxDecPicBuffering[MAX_TLAYER];
	143	Int m_numReorderPics[MAX_TLAYER];
	144	#else
	145	Int m_maxNumberOfReferencePictures;
	146	Int m_numReorderFrames;
[2]	147	#endif
[56]	148
[2]	149	Int m_iQP; // if (AdaptiveQP == OFF)
[56]	150
[2]	151	Int m_aiTLayerQPOffset[MAX_TLAYER];
	152	Int m_aiPad[2];
[56]	153
[2]	154
[56]	155	Int m_iMaxRefPicNum; ///< this is used to mimic the sliding mechanism used by the decoder
	156	// TODO: We need to have a common sliding mechanism used by both the encoder and decoder
	157
	158	#if H0566_TLA
	159	Int m_maxTempLayer; ///< Max temporal layer
	160	#else
	161	Bool m_bTLayering; ///< indicates whether temporal IDs are set based on the hierarchical coding structure
	162	Bool m_abTLayerSwitchingFlag[MAX_TLAYER]; ///< temporal layer switching flags corresponding to temporal layer
	163	#endif
	164	Bool m_bDisInter4x4;
	165	Bool m_useAMP;
[2]	166	//======= Transform =============
	167	UInt m_uiQuadtreeTULog2MaxSize;
	168	UInt m_uiQuadtreeTULog2MinSize;
	169	UInt m_uiQuadtreeTUMaxDepthInter;
	170	UInt m_uiQuadtreeTUMaxDepthIntra;
[56]	171
	172	Bool m_useNSQT;
	173
[2]	174	//====== Loop/Deblock Filter ========
	175	Bool m_bLoopFilterDisable;
[56]	176	Bool m_loopFilterOffsetInAPS;
	177	Int m_loopFilterBetaOffsetDiv2;
	178	Int m_loopFilterTcOffsetDiv2;
	179	#if DBL_CONTROL
	180	Bool m_DeblockingFilterControlPresent;
	181	#endif
[2]	182	Bool m_bUseSAO;
[213]	183	#if LGE_ILLUCOMP_B0045
	184	Bool m_bUseIC;
	185	#endif
[56]	186	#if SAO_UNIT_INTERLEAVING
	187	Int m_maxNumOffsetsPerPic;
	188	Bool m_saoInterleavingFlag;
[2]	189	#endif
	190
[56]	191	//====== Lossless ========
	192	#if LOSSLESS_CODING
	193	Bool m_useLossless;
	194	#endif
[2]	195	//====== Motion search ========
	196	Int m_iFastSearch; // 0:Full search 1:Diamond 2:PMVFAST
	197	Int m_iSearchRange; // 0:Full frame
	198	Int m_bipredSearchRange;
[213]	199	#if DV_V_RESTRICTION_B0037
	200	Bool m_bUseDisparitySearchRangeRestriction;
	201	Int m_iVerticalDisparitySearchRange;
	202	#endif
[56]	203	//====== Quality control ========
[2]	204	Int m_iMaxDeltaQP; // Max. absolute delta QP (1:default)
[56]	205	Int m_iMaxCuDQPDepth; // Max. depth for a minimum CuDQP (0:default)
[2]	206
[56]	207	Int m_iChromaQpOffset ; // ChromaQpOffset (0:default)
	208	Int m_iChromaQpOffset2nd; // ChromaQpOffset2nd (0:default)
	209
	210	#if ADAPTIVE_QP_SELECTION
	211	Bool m_bUseAdaptQpSelect;
	212	#endif
	213
	214	Bool m_bUseAdaptiveQP;
	215	Int m_iQPAdaptationRange;
	216
[5]	217	#if HHI_VSO
[2]	218	//====== View Synthesis Optimization ======
[56]	219	Bool m_bUseVSO;
[2]	220	Bool m_bForceLambdaScale;
[5]	221	#if HHI_VSO_DIST_INT
[2]	222	Bool m_bAllowNegDist;
	223	#endif
	224	Double m_dLambdaScaleVSO;
	225	UInt m_uiVSOMode;
[193]	226	#if LGE_WVSO_A0119
	227	Bool m_bUseWVSO;
	228	Int m_iVSOWeight;
	229	Int m_iVSDWeight;
	230	Int m_iDWeight;
[5]	231	#endif
[193]	232	#endif
[100]	233	#if SAIT_VSO_EST_A0033
	234	Bool m_bUseEstimatedVSD;
	235	Double m_dDispCoeff;
	236	#endif
[2]	237
[193]	238	#if VSP_SLICE_HEADER
	239	Bool m_bUseVSP;
	240	Bool m_bVSPDepthDisable;
	241	#endif
[100]	242
[2]	243	//====== Tool list ========
	244	Bool m_bUseSBACRD;
	245	Bool m_bUseALF;
	246	Int m_iALFEncodePassReduction;
[56]	247
	248	Int m_iALFMaxNumberFilters;
	249	#if LCU_SYNTAX_ALF
	250	Bool m_bALFParamInSlice;
	251	Bool m_bALFPicBasedEncode;
[2]	252	#endif
[56]	253
[2]	254	Bool m_bUseASR;
	255	Bool m_bUseHADME;
	256	Bool m_bUseLComb;
	257	Bool m_bLCMod;
	258	Bool m_bUseRDOQ;
[56]	259	#if !PIC_CROPPING
	260	Bool m_bUsePAD;
[2]	261	#endif
	262	Bool m_bUseFastEnc;
[56]	263	Bool m_bUseEarlyCU;
[2]	264
[56]	265	#if FAST_DECISION_FOR_MRG_RD_COST
	266	Bool m_useFastDecisionForMerge;
[2]	267	#endif
[56]	268	Bool m_bUseCbfFastMode;
	269	Bool m_bUseLMChroma;
	270	#if HHI_MPI
	271	Bool m_bUseMVI;
	272	#endif
[213]	273	#if RWTH_SDC_DLT_B0036
	274	Bool m_bUseDLT;
	275	Bool m_bUseSDC;
	276	#endif
[2]	277
	278	Int* m_aidQP;
	279	UInt m_uiDeltaQpRD;
[56]	280
[2]	281	Bool m_bUseConstrainedIntraPred;
[56]	282	Bool m_usePCM;
	283	UInt m_pcmLog2MaxSize;
	284	UInt m_uiPCMLog2MinSize;
[2]	285	//====== Slice ========
	286	Int m_iSliceMode;
[56]	287	Int m_iSliceArgument;
[2]	288	//====== Entropy Slice ========
	289	Int m_iEntropySliceMode;
	290	Int m_iEntropySliceArgument;
[56]	291	Int m_iSliceGranularity;
[2]	292	Bool m_bLFCrossSliceBoundaryFlag;
	293
[56]	294	Bool m_bPCMInputBitDepthFlag;
	295	UInt m_uiPCMBitDepthLuma;
	296	UInt m_uiPCMBitDepthChroma;
	297	Bool m_bPCMFilterDisableFlag;
	298	Int m_iTileBehaviorControlPresentFlag;
	299	Bool m_bLFCrossTileBoundaryFlag;
	300	Int m_iColumnRowInfoPresent;
	301	Int m_iUniformSpacingIdr;
	302	Int m_iNumColumnsMinus1;
	303	UInt* m_puiColumnWidth;
	304	Int m_iNumRowsMinus1;
	305	UInt* m_puiRowHeight;
	306	Int m_iTileLocationInSliceHeaderFlag; //< enable(1)/disable(0) transmitssion of tile location in slice header
	307
	308	Int m_iTileMarkerFlag; //< enable(1)/disable(0) transmitssion of light weight tile marker
	309	Int m_iMaxTileMarkerEntryPoints; //< maximum number of tile markers allowed in a slice (controls degree of parallelism)
	310	Double m_dMaxTileMarkerOffset; //< Calculated offset. Light weight tile markers will be transmitted for TileIdx= Offset, 2Offset, 3Offset ...
	311
	312	Int m_iWaveFrontSynchro;
	313	Int m_iWaveFrontFlush;
	314	Int m_iWaveFrontSubstreams;
	315
[193]	316	Bool m_pictureDigestEnabled; ///< enable(1)/disable(0) md5 computation and SEI signalling
[2]	317
	318	//====== Weighted Prediction ========
[56]	319	Bool m_bUseWeightPred; //< Use of Weighting Prediction (P_SLICE)
	320	UInt m_uiBiPredIdc; //< Use of Bi-Directional Weighting Prediction (B_SLICE)
	321	Int m_useScalingListId; ///< Using quantization matrix i.e. 0=off, 1=default, 2=file.
	322	char* m_scalingListFile; ///< quantization matrix file name
	323
	324	Bool m_bEnableTMVP;
	325	#if MULTIBITS_DATA_HIDING
	326	Int m_signHideFlag;
	327	Int m_signHidingThreshold;
[2]	328	#endif
	329
[213]	330	#if VIDYO_VPS_INTEGRATION\|QC_MVHEVC_B0046
[77]	331	UInt m_layerId;
	332	#endif
	333
[56]	334	Int m_viewId;
	335	Bool m_isDepth;
[2]	336
[56]	337	#if HHI_INTERVIEW_SKIP
	338	Bool m_bInterViewSkip;
	339	#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
	340	Double m_dInterViewSkipLambdaScale;
[42]	341	#endif
[56]	342	#endif
	343	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
[193]	344	Bool m_bUseDMM;
[56]	345	#endif
[2]	346
[213]	347	#if HHI_DMM_PRED_TEX && FLEX_CODING_ORDER_M23723
	348	Bool m_bUseDMM34;
[193]	349	#endif
	350
[213]	351	#if OL_QTLIMIT_PREDCODING_B0068
	352	Bool m_bUseQTLPC;
	353	#endif
	354
[56]	355	Int m_iViewOrderIdx;
	356
	357	UInt m_uiCamParPrecision;
	358	Bool m_bCamParInSliceHeader;
	359	Int** m_aaiCodedScale;
	360	Int** m_aaiCodedOffset;
	361
[5]	362	#if DEPTH_MAP_GENERATION
[56]	363	UInt m_uiPredDepthMapGeneration;
	364	UInt m_uiPdmPrecision;
	365	Int** m_aaiPdmScaleNomDelta;
	366	Int** m_aaiPdmOffset;
[5]	367	#endif
[56]	368
[5]	369	#if HHI_INTER_VIEW_MOTION_PRED
	370	UInt m_uiMultiviewMvPredMode;
[2]	371	UInt m_uiMultiviewMvRegMode;
	372	Double m_dMultiviewMvRegLambdaScale;
[5]	373	#endif
	374	#if HHI_INTER_VIEW_RESIDUAL_PRED
[2]	375	UInt m_uiMultiviewResPredMode;
[5]	376	#endif
[2]	377
	378	public:
	379	TEncCfg() {}
[56]	380	virtual ~TEncCfg()
	381	{
	382	if( m_iUniformSpacingIdr == 0 )
	383	{
	384	if( m_iNumColumnsMinus1 )
	385	{
	386	delete[] m_puiColumnWidth;
	387	m_puiColumnWidth = NULL;
	388	}
	389	if( m_iNumRowsMinus1 )
	390	{
	391	delete[] m_puiRowHeight;
	392	m_puiRowHeight = NULL;
	393	}
	394	}
	395	m_iTileLocationInSliceHeaderFlag = 0;
	396	m_iTileMarkerFlag = 0;
	397	}
	398
[2]	399	Void setFrameRate ( Int i ) { m_iFrameRate = i; }
	400	Void setFrameSkip ( unsigned int i ) { m_FrameSkip = i; }
	401	Void setSourceWidth ( Int i ) { m_iSourceWidth = i; }
	402	Void setSourceHeight ( Int i ) { m_iSourceHeight = i; }
[56]	403	#if PIC_CROPPING
	404	Void setCroppingMode ( Int i ) { m_croppingMode = i; }
	405	Void setCropLeft ( Int i ) { m_cropLeft = i; }
	406	Void setCropRight ( Int i ) { m_cropRight = i; }
	407	Void setCropTop ( Int i ) { m_cropTop = i; }
	408	Void setCropBottom ( Int i ) { m_cropBottom = i; }
	409	#endif
[2]	410	Void setFrameToBeEncoded ( Int i ) { m_iFrameToBeEncoded = i; }
[56]	411
[2]	412	//====== Coding Structure ========
[56]	413	Void setIntraPeriod ( Int i ) { m_uiIntraPeriod = (UInt)i; }
[2]	414	Void setDecodingRefreshType ( Int i ) { m_uiDecodingRefreshType = (UInt)i; }
[56]	415	Void setGOPSize ( Int i ) { m_iGOPSize = i; }
	416	Void setGopList ( GOPEntryMvc* GOPList ) { for( Int i = 0; i < MAX_GOP+1; i++ ) m_GOPList[i] = GOPList[i]; }
	417	Void setExtraRPSs ( Int i ) { m_extraRPSs = i; }
	418	GOPEntryMvc getGOPEntry ( Int i ) { return m_GOPList[i]; }
	419	#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
	420	Void setMaxDecPicBuffering ( UInt u, UInt tlayer ) { m_maxDecPicBuffering[tlayer] = u; }
	421	Void setNumReorderPics ( Int i, UInt tlayer ) { m_numReorderPics[tlayer] = i; }
	422	#else
	423	Void setMaxNumberOfReferencePictures ( Int u ) { m_maxNumberOfReferencePictures = u; }
	424	Void setNumReorderFrames ( Int i ) { m_numReorderFrames = i; }
[2]	425	#endif
[56]	426
	427	#if HHI_INTERVIEW_SKIP
	428	Void setInterViewSkip ( UInt u ) { m_bInterViewSkip = u; }
	429	Bool getInterViewSkip ( ) { return m_bInterViewSkip ;}
	430	#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
	431	Void setInterViewSkipLambdaScale ( UInt u ) { m_dInterViewSkipLambdaScale = u; }
	432	Double getInterViewSkipLambdaScale () { return m_dInterViewSkipLambdaScale; }
	433	#endif
	434	#endif
	435	Void setQP ( Int i ) { m_iQP = i; }
	436
	437	Void setTemporalLayerQPOffset ( Int* piTemporalLayerQPOffset ) { for ( Int i = 0; i < MAX_TLAYER; i++ ) m_aiTLayerQPOffset[i] = piTemporalLayerQPOffset[i]; }
	438	Void setPad ( Int* iPad ) { for ( Int i = 0; i < 2; i++ ) m_aiPad[i] = iPad[i]; }
	439
	440	Int getMaxRefPicNum () { return m_iMaxRefPicNum; }
	441	Void setMaxRefPicNum ( Int iMaxRefPicNum ) { m_iMaxRefPicNum = iMaxRefPicNum; }
[2]	442
[56]	443	#if H0566_TLA
	444	Bool getMaxTempLayer () { return m_maxTempLayer; }
	445	Void setMaxTempLayer ( Int maxTempLayer ) { m_maxTempLayer = maxTempLayer; }
	446	#else
	447	Bool getTLayering () { return m_bTLayering; }
	448	Void setTLayering ( Bool bTLayering ) { m_bTLayering = bTLayering; }
	449	Bool getTLayerSwitchingFlag ( UInt uiTLayer ) { assert (uiTLayer < MAX_TLAYER ); return m_abTLayerSwitchingFlag[uiTLayer]; }
	450	Void setTLayerSwitchingFlag ( Bool* pbTLayerSwitchingFlag ) { for ( Int i = 0; i < MAX_TLAYER; i++ ) m_abTLayerSwitchingFlag[i] = pbTLayerSwitchingFlag[i]; }
[42]	451	#endif
[2]	452
[56]	453	Bool getDisInter4x4 () { return m_bDisInter4x4; }
	454	Void setDisInter4x4 ( Bool b ) { m_bDisInter4x4 = b; }
	455	Bool isDepthCoder () { return m_isDepth; }
	456
[5]	457	#if DEPTH_MAP_GENERATION
[2]	458	Void setPredDepthMapGeneration ( UInt u ) { m_uiPredDepthMapGeneration = u; }
	459	Void setPdmPrecision ( UInt u ) { m_uiPdmPrecision = u; }
	460	Void setPdmScaleNomDelta ( Int** p ) { m_aaiPdmScaleNomDelta = p; }
	461	Void setPdmOffset ( Int** p ) { m_aaiPdmOffset = p; }
[5]	462	#endif
[56]	463
[5]	464	#if HHI_INTER_VIEW_MOTION_PRED
	465	Void setMultiviewMvPredMode ( UInt u ) { m_uiMultiviewMvPredMode = u; }
[2]	466	Void setMultiviewMvRegMode ( UInt u ) { m_uiMultiviewMvRegMode = u; }
	467	Void setMultiviewMvRegLambdaScale ( Double d) { m_dMultiviewMvRegLambdaScale = d; }
[5]	468	#endif
	469	#if HHI_INTER_VIEW_RESIDUAL_PRED
[2]	470	Void setMultiviewResPredMode ( UInt u ) { m_uiMultiviewResPredMode = u; }
[5]	471	#endif
[56]	472
[2]	473	//======== Transform =============
	474	Void setQuadtreeTULog2MaxSize ( UInt u ) { m_uiQuadtreeTULog2MaxSize = u; }
	475	Void setQuadtreeTULog2MinSize ( UInt u ) { m_uiQuadtreeTULog2MinSize = u; }
	476	Void setQuadtreeTUMaxDepthInter ( UInt u ) { m_uiQuadtreeTUMaxDepthInter = u; }
	477	Void setQuadtreeTUMaxDepthIntra ( UInt u ) { m_uiQuadtreeTUMaxDepthIntra = u; }
[56]	478
	479	Void setUseNSQT( Bool b ) { m_useNSQT = b; }
	480	Void setUseAMP( Bool b ) { m_useAMP = b; }
	481
[2]	482	//====== Loop/Deblock Filter ========
	483	Void setLoopFilterDisable ( Bool b ) { m_bLoopFilterDisable = b; }
[56]	484	Void setLoopFilterOffsetInAPS ( Bool b ) { m_loopFilterOffsetInAPS = b; }
	485	Void setLoopFilterBetaOffset ( Int i ) { m_loopFilterBetaOffsetDiv2 = i; }
	486	Void setLoopFilterTcOffset ( Int i ) { m_loopFilterTcOffsetDiv2 = i; }
	487	#if DBL_CONTROL
	488	Void setDeblockingFilterControlPresent ( Bool b ) { m_DeblockingFilterControlPresent = b; }
	489	#endif
[2]	490
	491	//====== Motion search ========
	492	Void setFastSearch ( Int i ) { m_iFastSearch = i; }
	493	Void setSearchRange ( Int i ) { m_iSearchRange = i; }
	494	Void setBipredSearchRange ( Int i ) { m_bipredSearchRange = i; }
[213]	495	#if DV_V_RESTRICTION_B0037
	496	Void setUseDisparitySearchRangeRestriction ( Bool b ) { m_bUseDisparitySearchRangeRestriction = b; }
	497	Void setVerticalDisparitySearchRange ( Int i ) { m_iVerticalDisparitySearchRange = i; }
	498	#endif
[56]	499	#if HHI_INTER_VIEW_MOTION_PRED
	500	UInt getMultiviewMvRegMode () { return m_uiMultiviewMvRegMode; }
	501	Double getMultiviewMvRegLambdaScale () { return m_dMultiviewMvRegLambdaScale; }
	502	#endif
	503
[5]	504	#if HHI_VSO
[2]	505	//==== VSO ==========
	506	Void setVSOMode ( UInt ui ) { m_uiVSOMode = ui; }
	507	Void setForceLambdaScaleVSO ( Bool b ) { m_bForceLambdaScale = b; };
	508	Void setLambdaScaleVSO ( Double d ) { m_dLambdaScaleVSO = d; };
[5]	509	#if HHI_VSO_DIST_INT
[2]	510	Void setAllowNegDist ( Bool b ) { m_bAllowNegDist = b; };
	511	#endif
[193]	512	#if LGE_WVSO_A0119
	513	Void setUseWVSO ( Bool b ) { m_bUseWVSO = b; }
	514	Void setVSOWeight ( Int i ) { m_iVSOWeight = i; }
	515	Void setVSDWeight ( Int i ) { m_iVSDWeight = i; }
	516	Void setDWeight ( Int i ) { m_iDWeight = i; }
[5]	517	#endif
[193]	518	#endif
[2]	519
[56]	520	//====== Quality control ========
	521	Void setMaxDeltaQP ( Int i ) { m_iMaxDeltaQP = i; }
	522	Void setMaxCuDQPDepth ( Int i ) { m_iMaxCuDQPDepth = i; }
	523
	524	Void setChromaQpOffset ( Int i ) { m_iChromaQpOffset = i; }
	525	Void setChromaQpOffset2nd ( Int i ) { m_iChromaQpOffset2nd = i; }
	526
	527	#if ADAPTIVE_QP_SELECTION
	528	Void setUseAdaptQpSelect ( Bool i ) { m_bUseAdaptQpSelect = i; }
	529	Bool getUseAdaptQpSelect () { return m_bUseAdaptQpSelect; }
	530	#endif
	531
	532	Void setUseAdaptiveQP ( Bool b ) { m_bUseAdaptiveQP = b; }
	533	Void setQPAdaptationRange ( Int i ) { m_iQPAdaptationRange = i; }
	534
	535	//====== Lossless ========
	536	#if LOSSLESS_CODING
	537	Void setUseLossless (Bool b ) { m_useLossless = b; }
	538	#endif
[2]	539	//====== Sequence ========
	540	Int getFrameRate () { return m_iFrameRate; }
	541	unsigned int getFrameSkip () { return m_FrameSkip; }
	542	Int getSourceWidth () { return m_iSourceWidth; }
	543	Int getSourceHeight () { return m_iSourceHeight; }
[56]	544	#if PIC_CROPPING
	545	Int getCroppingMode () { return m_croppingMode; }
	546	Int getCropLeft () { return m_cropLeft; }
	547	Int getCropRight () { return m_cropRight; }
	548	Int getCropTop () { return m_cropTop; }
	549	Int getCropBottom () { return m_cropBottom; }
	550	#endif
[2]	551	Int getFrameToBeEncoded () { return m_iFrameToBeEncoded; }
[56]	552	void setLambdaModifier ( UInt uiIndex, Double dValue ) { m_adLambdaModifier[ uiIndex ] = dValue; }
	553	Double getLambdaModifier ( UInt uiIndex ) const { return m_adLambdaModifier[ uiIndex ]; }
[2]	554
	555	//==== Coding Structure ========
[56]	556	UInt getIntraPeriod () { return m_uiIntraPeriod; }
[2]	557	UInt getDecodingRefreshType () { return m_uiDecodingRefreshType; }
[56]	558	Int getGOPSize () { return m_iGOPSize; }
	559	#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
	560	Int getMaxDecPicBuffering (UInt tlayer) { return m_maxDecPicBuffering[tlayer]; }
	561	Int getNumReorderPics (UInt tlayer) { return m_numReorderPics[tlayer]; }
	562	#else
	563	Int getMaxNumberOfReferencePictures () { return m_maxNumberOfReferencePictures; }
	564	Int geNumReorderFrames () { return m_numReorderFrames; }
[2]	565	#endif
	566	Int getQP () { return m_iQP; }
[56]	567
[2]	568	Int getTemporalLayerQPOffset ( Int i ) { assert (i < MAX_TLAYER ); return m_aiTLayerQPOffset[i]; }
	569	Int getPad ( Int i ) { assert (i < 2 ); return m_aiPad[i]; }
[56]	570
[2]	571	//======== Transform =============
	572	UInt getQuadtreeTULog2MaxSize () const { return m_uiQuadtreeTULog2MaxSize; }
	573	UInt getQuadtreeTULog2MinSize () const { return m_uiQuadtreeTULog2MinSize; }
	574	UInt getQuadtreeTUMaxDepthInter () const { return m_uiQuadtreeTUMaxDepthInter; }
	575	UInt getQuadtreeTUMaxDepthIntra () const { return m_uiQuadtreeTUMaxDepthIntra; }
[56]	576
[2]	577	//==== Loop/Deblock Filter ========
	578	Bool getLoopFilterDisable () { return m_bLoopFilterDisable; }
[56]	579	Bool getLoopFilterOffsetInAPS () { return m_loopFilterOffsetInAPS; }
	580	Int getLoopFilterBetaOffset () { return m_loopFilterBetaOffsetDiv2; }
	581	Int getLoopFilterTcOffset () { return m_loopFilterTcOffsetDiv2; }
	582	#if DBL_CONTROL
	583	Bool getDeblockingFilterControlPresent() { return m_DeblockingFilterControlPresent; }
	584	#endif
[2]	585
	586	//==== Motion search ========
	587	Int getFastSearch () { return m_iFastSearch; }
	588	Int getSearchRange () { return m_iSearchRange; }
[213]	589	#if DV_V_RESTRICTION_B0037
	590	Bool getUseDisparitySearchRangeRestriction () { return m_bUseDisparitySearchRangeRestriction; }
	591	Int getVerticalDisparitySearchRange () { return m_iVerticalDisparitySearchRange; }
	592	#endif
[5]	593	#if HHI_VSO
[2]	594	//==== VSO ==========
	595	UInt getVSOMode () { return m_uiVSOMode; }
	596	Bool getForceLambdaScaleVSO () { return m_bForceLambdaScale; }
	597	Double getLambdaScaleVSO () { return m_dLambdaScaleVSO; }
[5]	598	#if HHI_VSO_DIST_INT
[2]	599	Bool getAllowNegDist () { return m_bAllowNegDist; }
	600	#endif
[193]	601	#if LGE_WVSO_A0119
	602	Bool getUseWVSO () { return m_bUseWVSO; }
	603	Int getVSOWeight () { return m_iVSOWeight; }
	604	Int getVSDWeight () { return m_iVSDWeight; }
	605	Int getDWeight () { return m_iDWeight; }
[5]	606	#endif
[193]	607	#endif
[2]	608
[56]	609	//==== Quality control ========
	610	Int getMaxDeltaQP () { return m_iMaxDeltaQP; }
	611	Int getMaxCuDQPDepth () { return m_iMaxCuDQPDepth; }
	612	Bool getUseAdaptiveQP () { return m_bUseAdaptiveQP; }
	613	Int getQPAdaptationRange () { return m_iQPAdaptationRange; }
	614	//====== Lossless ========
	615	#if LOSSLESS_CODING
	616	Bool getUseLossless () { return m_useLossless; }
	617	#endif
	618
[2]	619	//==== Tool list ========
	620	Void setUseSBACRD ( Bool b ) { m_bUseSBACRD = b; }
	621	Void setUseASR ( Bool b ) { m_bUseASR = b; }
	622	Void setUseHADME ( Bool b ) { m_bUseHADME = b; }
	623	Void setUseALF ( Bool b ) { m_bUseALF = b; }
	624	Void setUseLComb ( Bool b ) { m_bUseLComb = b; }
	625	Void setLCMod ( Bool b ) { m_bLCMod = b; }
	626	Void setUseRDOQ ( Bool b ) { m_bUseRDOQ = b; }
[56]	627	#if !PIC_CROPPING
	628	Void setUsePAD ( Bool b ) { m_bUsePAD = b; }
[2]	629	#endif
[5]	630	#if HHI_VSO
[2]	631	Void setUseVSO ( Bool b ) { m_bUseVSO = b; }
[5]	632	#endif
[56]	633
[193]	634	#if VSP_SLICE_HEADER
	635	Void setUseVSP ( Bool b ) { m_bUseVSP = b; }
	636	Void setVSPDepthDisable ( Bool b ) { m_bVSPDepthDisable = b; }
	637	#endif
	638
[100]	639	#if SAIT_VSO_EST_A0033
	640	Void setUseEstimatedVSD ( Bool b ) { m_bUseEstimatedVSD = b; }
	641	Void setDispCoeff ( Double d ) { m_dDispCoeff = d; }
	642	#endif
	643
[56]	644	Void setUseFastEnc ( Bool b ) { m_bUseFastEnc = b; }
	645	Void setUseEarlyCU ( Bool b ) { m_bUseEarlyCU = b; }
	646	#if FAST_DECISION_FOR_MRG_RD_COST
	647	Void setUseFastDecisionForMerge ( Bool b ) { m_useFastDecisionForMerge = b; }
	648	#endif
	649	Void setUseCbfFastMode ( Bool b ) { m_bUseCbfFastMode = b; }
[2]	650	Void setUseConstrainedIntraPred ( Bool b ) { m_bUseConstrainedIntraPred = b; }
[56]	651	Void setPCMInputBitDepthFlag ( Bool b ) { m_bPCMInputBitDepthFlag = b; }
	652	Void setPCMFilterDisableFlag ( Bool b ) { m_bPCMFilterDisableFlag = b; }
	653	Void setUsePCM ( Bool b ) { m_usePCM = b; }
	654	Void setPCMLog2MaxSize ( UInt u ) { m_pcmLog2MaxSize = u; }
	655	Void setPCMLog2MinSize ( UInt u ) { m_uiPCMLog2MinSize = u; }
[2]	656	Void setdQPs ( Int* p ) { m_aidQP = p; }
	657	Void setDeltaQpRD ( UInt u ) {m_uiDeltaQpRD = u; }
	658	Bool getUseSBACRD () { return m_bUseSBACRD; }
	659	Bool getUseASR () { return m_bUseASR; }
	660	Bool getUseHADME () { return m_bUseHADME; }
	661	Bool getUseALF () { return m_bUseALF; }
	662	Void setALFEncodePassReduction (Int i) { m_iALFEncodePassReduction = i; }
	663	Int getALFEncodePassReduction () { return m_iALFEncodePassReduction; }
[56]	664
	665	Void setALFMaxNumberFilters (Int i) { m_iALFMaxNumberFilters = i; }
	666	Int getALFMaxNumberFilters () { return m_iALFMaxNumberFilters; }
	667	#if LCU_SYNTAX_ALF
	668	Void setALFParamInSlice (Bool b) {m_bALFParamInSlice = b;}
	669	Bool getALFParamInSlice () {return m_bALFParamInSlice;}
	670	Void setALFPicBasedEncode (Bool b) {m_bALFPicBasedEncode = b;}
	671	Bool getALFPicBasedEncode () {return m_bALFPicBasedEncode;}
[2]	672	#endif
[56]	673
[2]	674	Bool getUseLComb () { return m_bUseLComb; }
	675	Bool getLCMod () { return m_bLCMod; }
	676	Bool getUseRDOQ () { return m_bUseRDOQ; }
[56]	677	#if !PIC_CROPPING
	678	Bool getUsePAD () { return m_bUsePAD; }
[2]	679	#endif
	680
[5]	681	#if HHI_VSO
[2]	682	Bool getUseVSO () { return m_bUseVSO; }
[5]	683	#endif
[100]	684	#if SAIT_VSO_EST_A0033
	685	Bool getUseEstimatedVSD () { return m_bUseEstimatedVSD; }
	686	Double getDispCoeff () { return m_dDispCoeff; }
	687	#endif
	688
[193]	689	#if VSP_SLICE_HEADER
	690	Bool getUseVSP () { return m_bUseVSP; }
	691	Bool getVSPDepthDisable () { return m_bVSPDepthDisable; }
	692	#endif
	693
[56]	694	Bool getUseFastEnc () { return m_bUseFastEnc; }
	695	Bool getUseEarlyCU () { return m_bUseEarlyCU; }
	696	#if FAST_DECISION_FOR_MRG_RD_COST
	697	Bool getUseFastDecisionForMerge () { return m_useFastDecisionForMerge; }
	698	#endif
	699	Bool getUseCbfFastMode () { return m_bUseCbfFastMode; }
[2]	700	Bool getUseConstrainedIntraPred () { return m_bUseConstrainedIntraPred; }
[56]	701	#if NS_HAD
	702	Bool getUseNSQT () { return m_useNSQT; }
[2]	703	#endif
[56]	704	Bool getPCMInputBitDepthFlag () { return m_bPCMInputBitDepthFlag; }
	705	Bool getPCMFilterDisableFlag () { return m_bPCMFilterDisableFlag; }
	706	Bool getUsePCM () { return m_usePCM; }
	707	UInt getPCMLog2MaxSize () { return m_pcmLog2MaxSize; }
	708	UInt getPCMLog2MinSize () { return m_uiPCMLog2MinSize; }
	709
[2]	710	Bool getUseLMChroma () { return m_bUseLMChroma; }
	711	Void setUseLMChroma ( Bool b ) { m_bUseLMChroma = b; }
	712
	713	Int* getdQPs () { return m_aidQP; }
	714	UInt getDeltaQpRD () { return m_uiDeltaQpRD; }
[56]	715
[2]	716	//====== Slice ========
	717	Void setSliceMode ( Int i ) { m_iSliceMode = i; }
	718	Void setSliceArgument ( Int i ) { m_iSliceArgument = i; }
	719	Int getSliceMode () { return m_iSliceMode; }
	720	Int getSliceArgument () { return m_iSliceArgument; }
	721	//====== Entropy Slice ========
	722	Void setEntropySliceMode ( Int i ) { m_iEntropySliceMode = i; }
	723	Void setEntropySliceArgument ( Int i ) { m_iEntropySliceArgument = i; }
	724	Int getEntropySliceMode () { return m_iEntropySliceMode; }
	725	Int getEntropySliceArgument () { return m_iEntropySliceArgument;}
[56]	726	Void setSliceGranularity ( Int i ) { m_iSliceGranularity = i; }
	727	Int getSliceGranularity () { return m_iSliceGranularity; }
[193]	728	Void setLFCrossSliceBoundaryFlag ( Bool bValue ) { m_bLFCrossSliceBoundaryFlag = bValue; }
	729	Bool getLFCrossSliceBoundaryFlag () { return m_bLFCrossSliceBoundaryFlag; }
[56]	730
	731	#if HHI_MPI
[193]	732	Void setUseMVI ( Bool bVal ) {m_bUseMVI = bVal;}
[2]	733	#endif
[213]	734	#if RWTH_SDC_DLT_B0036
	735	Void setUseDLT ( Bool b ) { m_bUseDLT = b; }
	736	Void setUseSDC ( Bool b ) { m_bUseSDC = b; }
	737	#endif
[193]	738	Void setUseSAO ( Bool bVal ) {m_bUseSAO = bVal;}
	739	Bool getUseSAO () {return m_bUseSAO;}
[213]	740	#if LGE_ILLUCOMP_B0045
	741	Void setUseIC ( Bool bVal ) {m_bUseIC = bVal;}
	742	Bool getUseIC () {return m_bUseIC;}
	743	#endif
[56]	744	#if SAO_UNIT_INTERLEAVING
	745	Void setMaxNumOffsetsPerPic (Int iVal) { m_maxNumOffsetsPerPic = iVal; }
	746	Int getMaxNumOffsetsPerPic () { return m_maxNumOffsetsPerPic; }
	747	Void setSaoInterleavingFlag (bool bVal) { m_saoInterleavingFlag = bVal; }
	748	Bool getSaoInterleavingFlag () { return m_saoInterleavingFlag; }
[2]	749	#endif
[56]	750	Void setTileBehaviorControlPresentFlag ( Int i ) { m_iTileBehaviorControlPresentFlag = i; }
	751	Int getTileBehaviorControlPresentFlag () { return m_iTileBehaviorControlPresentFlag; }
	752	Void setLFCrossTileBoundaryFlag ( Bool bValue ) { m_bLFCrossTileBoundaryFlag = bValue; }
	753	Bool getLFCrossTileBoundaryFlag () { return m_bLFCrossTileBoundaryFlag; }
	754	Void setColumnRowInfoPresent ( Int i ) { m_iColumnRowInfoPresent = i; }
	755	Int getColumnRowInfoPresent () { return m_iColumnRowInfoPresent; }
	756	Void setUniformSpacingIdr ( Int i ) { m_iUniformSpacingIdr = i; }
	757	Int getUniformSpacingIdr () { return m_iUniformSpacingIdr; }
	758	#if !REMOVE_TILE_DEPENDENCE
	759	Void setTileBoundaryIndependenceIdr ( Int i ) { m_iTileBoundaryIndependenceIdr = i; }
	760	Int getTileBoundaryIndependenceIdr () { return m_iTileBoundaryIndependenceIdr; }
[5]	761	#endif
[56]	762	Void setNumColumnsMinus1 ( Int i ) { m_iNumColumnsMinus1 = i; }
	763	Int getNumColumnsMinus1 () { return m_iNumColumnsMinus1; }
	764	Void setColumnWidth ( char* str )
	765	{
	766	char *columnWidth;
	767	int i=0;
	768	Int m_iWidthInCU = ( m_iSourceWidth%g_uiMaxCUWidth ) ? m_iSourceWidth/g_uiMaxCUWidth + 1 : m_iSourceWidth/g_uiMaxCUWidth;
[2]	769
[56]	770	if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
	771	{
	772	m_puiColumnWidth = new UInt[m_iNumColumnsMinus1];
	773
	774	columnWidth = strtok(str, " ,-");
	775	while(columnWidth!=NULL)
	776	{
	777	if( i>=m_iNumColumnsMinus1 )
	778	{
	779	printf( "The number of columns whose width are defined is larger than the allowed number of columns.\n" );
	780	exit( EXIT_FAILURE );
	781	}
	782	*( m_puiColumnWidth + i ) = atoi( columnWidth );
	783	printf("col: m_iWidthInCU= %4d i=%4d width= %4d\n",m_iWidthInCU,i,m_puiColumnWidth[i]); //AFU
	784	columnWidth = strtok(NULL, " ,-");
	785	i++;
	786	}
	787	if( i<m_iNumColumnsMinus1 )
	788	{
	789	printf( "The width of some columns is not defined.\n" );
	790	exit( EXIT_FAILURE );
	791	}
	792	}
	793	}
	794	UInt getColumnWidth ( UInt columnidx ) { return *( m_puiColumnWidth + columnidx ); }
	795	Void setNumRowsMinus1 ( Int i ) { m_iNumRowsMinus1 = i; }
	796	Int getNumRowsMinus1 () { return m_iNumRowsMinus1; }
	797	Void setRowHeight (char* str)
	798	{
	799	char *rowHeight;
	800	int i=0;
	801	Int m_iHeightInCU = ( m_iSourceHeight%g_uiMaxCUHeight ) ? m_iSourceHeight/g_uiMaxCUHeight + 1 : m_iSourceHeight/g_uiMaxCUHeight;
	802
	803	if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
	804	{
	805	m_puiRowHeight = new UInt[m_iNumRowsMinus1];
	806
	807	rowHeight = strtok(str, " ,-");
	808	while(rowHeight!=NULL)
	809	{
	810	if( i>=m_iNumRowsMinus1 )
	811	{
	812	printf( "The number of rows whose height are defined is larger than the allowed number of rows.\n" );
	813	exit( EXIT_FAILURE );
	814	}
	815	*( m_puiRowHeight + i ) = atoi( rowHeight );
	816	printf("row: m_iHeightInCU=%4d i=%4d height=%4d\n",m_iHeightInCU,i,m_puiRowHeight[i]); //AFU
	817	rowHeight = strtok(NULL, " ,-");
	818	i++;
	819	}
	820	if( i<m_iNumRowsMinus1 )
	821	{
	822	printf( "The height of some rows is not defined.\n" );
	823	exit( EXIT_FAILURE );
	824	}
	825	}
	826	}
	827	UInt getRowHeight ( UInt rowIdx ) { return *( m_puiRowHeight + rowIdx ); }
	828	Void xCheckGSParameters();
	829	Int getTileLocationInSliceHeaderFlag () { return m_iTileLocationInSliceHeaderFlag; }
	830	Void setTileLocationInSliceHeaderFlag ( Int iFlag ) { m_iTileLocationInSliceHeaderFlag = iFlag;}
	831	Int getTileMarkerFlag () { return m_iTileMarkerFlag; }
	832	Void setTileMarkerFlag ( Int iFlag ) { m_iTileMarkerFlag = iFlag; }
	833	Int getMaxTileMarkerEntryPoints () { return m_iMaxTileMarkerEntryPoints; }
	834	Void setMaxTileMarkerEntryPoints ( Int iCount ) { m_iMaxTileMarkerEntryPoints = iCount; }
	835	Double getMaxTileMarkerOffset () { return m_dMaxTileMarkerOffset; }
	836	Void setMaxTileMarkerOffset ( Double dCount ) { m_dMaxTileMarkerOffset = dCount; }
	837	Void setWaveFrontSynchro(Int iWaveFrontSynchro) { m_iWaveFrontSynchro = iWaveFrontSynchro; }
	838	Int getWaveFrontsynchro() { return m_iWaveFrontSynchro; }
	839	Void setWaveFrontFlush(Int iWaveFrontFlush) { m_iWaveFrontFlush = iWaveFrontFlush; }
	840	Int getWaveFrontFlush() { return m_iWaveFrontFlush; }
	841	Void setWaveFrontSubstreams(Int iWaveFrontSubstreams) { m_iWaveFrontSubstreams = iWaveFrontSubstreams; }
	842	Int getWaveFrontSubstreams() { return m_iWaveFrontSubstreams; }
[2]	843	void setPictureDigestEnabled(bool b) { m_pictureDigestEnabled = b; }
	844	bool getPictureDigestEnabled() { return m_pictureDigestEnabled; }
	845
[56]	846	Void setUseWP ( Bool b ) { m_bUseWeightPred = b; }
	847	Void setWPBiPredIdc ( UInt u ) { m_uiBiPredIdc = u; }
	848	Bool getUseWP () { return m_bUseWeightPred; }
	849	UInt getWPBiPredIdc () { return m_uiBiPredIdc; }
	850	Void setUseScalingListId ( Int u ) { m_useScalingListId = u; }
	851	Int getUseScalingListId () { return m_useScalingListId; }
	852	Void setScalingListFile ( char* pch ){ m_scalingListFile = pch; }
	853	char* getScalingListFile () { return m_scalingListFile; }
	854
	855	Void setEnableTMVP ( Bool b ) { m_bEnableTMVP = b; }
	856	Bool getEnableTMVP () { return m_bEnableTMVP; }
	857	#if MULTIBITS_DATA_HIDING
	858	Void setSignHideFlag( Int signHideFlag ) { m_signHideFlag = signHideFlag; }
	859	Void setTSIG( Int tsig ) { m_signHidingThreshold = tsig; }
	860	Int getSignHideFlag() { return m_signHideFlag; }
	861	Int getTSIG() { return m_signHidingThreshold; }
[2]	862	#endif
[213]	863	#if VIDYO_VPS_INTEGRATION \|QC_MVHEVC_B0046
[77]	864	Void setLayerId ( UInt layerId ) { m_layerId = layerId; }
	865	UInt getLayerId () { return m_layerId; }
	866	#endif
[2]	867
[56]	868	Void setViewId ( Int viewId ) { m_viewId = viewId; }
	869	Int getViewId () { return m_viewId; }
	870	Void setIsDepth ( Bool isDepth ) { m_isDepth = isDepth; }
	871	Bool getIsDepth () { return m_isDepth; }
	872
	873	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
[193]	874	Void setUseDMM( Bool b) { m_bUseDMM = b; }
	875	Bool getUseDMM() { return m_bUseDMM; }
[56]	876	#endif
	877
[213]	878	#if HHI_DMM_PRED_TEX && FLEX_CODING_ORDER_M23723
	879	Void setUseDMM34( Bool b) { m_bUseDMM34 = b; }
	880	Bool getUseDMM34() { return m_bUseDMM34; }
[193]	881	#endif
	882
[213]	883	#if OL_QTLIMIT_PREDCODING_B0068
	884	Void setUseQTLPC( Bool b ) { m_bUseQTLPC = b; }
	885	Bool getUseQTLPC() { return m_bUseQTLPC; }
	886	#endif
	887
	888	#if RWTH_SDC_DLT_B0036
	889	Bool getUseDLT() { return m_bUseDLT; }
	890	Bool getUseSDC() { return m_bUseSDC; }
	891	#endif
	892
[56]	893	Void setViewOrderIdx ( Int i ) { m_iViewOrderIdx = i; }
	894	Void setCamParPrecision ( UInt u ) { m_uiCamParPrecision = u; }
	895	Void setCamParInSliceHeader ( Bool b ) { m_bCamParInSliceHeader = b; }
	896	Void setCodedScale ( Int** p ) { m_aaiCodedScale = p; }
	897	Void setCodedOffset ( Int** p ) { m_aaiCodedOffset = p; }
	898
[213]	899	#if SONY_COLPIC_AVAILABILITY \|\| VSP_N
[56]	900	Int getViewOrderIdx () { return m_iViewOrderIdx; }
	901	#endif
[2]	902	};
	903
[56]	904	//! \}
	905
[2]	906	#endif // !defined(AFX_TENCCFG_H__6B99B797_F4DA_4E46_8E78_7656339A6C41__INCLUDED_)

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/TLibEncoder/TEncCfg.h

Download in other formats: