Context navigation

TEncCfg.h @ 193

Visit:

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

A second release, as planned

Migrate to HTM 4.1
Move VSP related switches to cfg file instead of #define in the source code
A few bug fixes
For VC project files, only VC9 file is updated

TODO

Migrate to HTM 5.0, to be used as anchor for CE1 toward Geneva meeting

Property svn:eol-style set to native

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

Download in other formats: