Context navigation

source: 3DVCSoftware/branches/HTM-11.2-dev2-MediaTek/source/App/TAppEncoder/TAppEncCfg.cpp @ 1007

Visit:

Last change on this file since 1007 was 1007, checked in by mediatek-htm, 10 years ago
JCT3V-I0099. Changes of sub-PU size signaling and lim_qt_pred_flag signaling in VPS extension 2. Remove use_qtl_flag and use_pc_flag.
Property svn:eol-style set to `native`
File size: 120.3 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-2014, ITU/ISO/IEC
7	* All rights reserved.
8	*
9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions are met:
11	*
12	* * Redistributions of source code must retain the above copyright notice,
13	* this list of conditions and the following disclaimer.
14	* * Redistributions in binary form must reproduce the above copyright notice,
15	* this list of conditions and the following disclaimer in the documentation
16	* and/or other materials provided with the distribution.
17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18	* be used to endorse or promote products derived from this software without
19	* specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31	* THE POSSIBILITY OF SUCH DAMAGE.
32	*/
33
34	/** \file TAppEncCfg.cpp
35	\brief Handle encoder configuration parameters
36	*/
37
38	#include <stdlib.h>
39	#include <cassert>
40	#include <cstring>
41	#include <string>
42	#include "TLibCommon/TComRom.h"
43	#include "TAppEncCfg.h"
44
45	static istream& operator>>(istream &, Level::Name &);
46	static istream& operator>>(istream &, Level::Tier &);
47	static istream& operator>>(istream &, Profile::Name &);
48
49	#include "TAppCommon/program_options_lite.h"
50	#include "TLibEncoder/TEncRateCtrl.h"
51	#ifdef WIN32
52	#define strdup _strdup
53	#endif
54
55	using namespace std;
56	namespace po = df::program_options_lite;
57
58	//! \ingroup TAppEncoder
59	//! \{
60
61	// ====================================================================================================================
62	// Constructor / destructor / initialization / destroy
63	// ====================================================================================================================
64
65	TAppEncCfg::TAppEncCfg()
66	#if H_MV
67	: m_pchBitstreamFile()
68	#else
69	: m_pchInputFile()
70	, m_pchBitstreamFile()
71	, m_pchReconFile()
72	#endif
73	, m_pchdQPFile()
74	, m_pColumnWidth()
75	, m_pRowHeight()
76	, m_scalingListFile()
77	{
78	#if !H_MV
79	m_aidQP = NULL;
80	#endif
81	m_startOfCodedInterval = NULL;
82	m_codedPivotValue = NULL;
83	m_targetPivotValue = NULL;
84
85	#if KWU_RC_MADPRED_E0227
86	m_depthMADPred = 0;
87	#endif
88	}
89
90	TAppEncCfg::~TAppEncCfg()
91	{
92	#if H_MV
93	for( Int layer = 0; layer < m_aidQP.size(); layer++ )
94	{
95	if ( m_aidQP[layer] != NULL )
96	{
97	delete[] m_aidQP[layer];
98	m_aidQP[layer] = NULL;
99	}
100	}
101	for(Int i = 0; i< m_pchInputFileList.size(); i++ )
102	{
103	if ( m_pchInputFileList[i] != NULL )
104	free (m_pchInputFileList[i]);
105	}
106	#else
107	if ( m_aidQP )
108	{
109	delete[] m_aidQP;
110	}
111	#endif
112	if ( m_startOfCodedInterval )
113	{
114	delete[] m_startOfCodedInterval;
115	m_startOfCodedInterval = NULL;
116	}
117	if ( m_codedPivotValue )
118	{
119	delete[] m_codedPivotValue;
120	m_codedPivotValue = NULL;
121	}
122	if ( m_targetPivotValue )
123	{
124	delete[] m_targetPivotValue;
125	m_targetPivotValue = NULL;
126	}
127	#if !H_MV
128	free(m_pchInputFile);
129	#endif
130	free(m_pchBitstreamFile);
131	#if H_MV
132	for(Int i = 0; i< m_pchReconFileList.size(); i++ )
133	{
134	if ( m_pchReconFileList[i] != NULL )
135	free (m_pchReconFileList[i]);
136	}
137	#else
138	free(m_pchReconFile);
139	#endif
140	free(m_pchdQPFile);
141	free(m_pColumnWidth);
142	free(m_pRowHeight);
143	free(m_scalingListFile);
144	#if H_MV
145	for( Int i = 0; i < m_GOPListMvc.size(); i++ )
146	{
147	if( m_GOPListMvc[i] )
148	{
149	delete[] m_GOPListMvc[i];
150	m_GOPListMvc[i] = NULL;
151	}
152	}
153	#endif
154	#if H_3D
155	#if H_3D_VSO
156	if ( m_pchVSOConfig != NULL)
157	free ( m_pchVSOConfig );
158	#endif
159	if ( m_pchCameraParameterFile != NULL )
160	free ( m_pchCameraParameterFile );
161
162	if ( m_pchBaseViewCameraNumbers != NULL )
163	free ( m_pchBaseViewCameraNumbers );
164	#endif
165	}
166
167	Void TAppEncCfg::create()
168	{
169	}
170
171	Void TAppEncCfg::destroy()
172	{
173	}
174
175	std::istringstream &operator>>(std::istringstream &in, GOPEntry &entry) //input
176	{
177	in>>entry.m_sliceType;
178	in>>entry.m_POC;
179	in>>entry.m_QPOffset;
180	in>>entry.m_QPFactor;
181	in>>entry.m_tcOffsetDiv2;
182	in>>entry.m_betaOffsetDiv2;
183	in>>entry.m_temporalId;
184	in>>entry.m_numRefPicsActive;
185	in>>entry.m_numRefPics;
186	for ( Int i = 0; i < entry.m_numRefPics; i++ )
187	{
188	in>>entry.m_referencePics[i];
189	}
190	in>>entry.m_interRPSPrediction;
191	#if AUTO_INTER_RPS
192	if (entry.m_interRPSPrediction==1)
193	{
194	in>>entry.m_deltaRPS;
195	in>>entry.m_numRefIdc;
196	for ( Int i = 0; i < entry.m_numRefIdc; i++ )
197	{
198	in>>entry.m_refIdc[i];
199	}
200	}
201	else if (entry.m_interRPSPrediction==2)
202	{
203	in>>entry.m_deltaRPS;
204	}
205	#else
206	if (entry.m_interRPSPrediction)
207	{
208	in>>entry.m_deltaRPS;
209	in>>entry.m_numRefIdc;
210	for ( Int i = 0; i < entry.m_numRefIdc; i++ )
211	{
212	in>>entry.m_refIdc[i];
213	}
214	}
215	#endif
216	#if H_MV
217	in>>entry.m_numActiveRefLayerPics;
218	for( Int i = 0; i < entry.m_numActiveRefLayerPics; i++ )
219	{
220	in>>entry.m_interLayerPredLayerIdc[i];
221	}
222	for( Int i = 0; i < entry.m_numActiveRefLayerPics; i++ )
223	{
224	in>>entry.m_interViewRefPosL[0][i];
225	}
226	for( Int i = 0; i < entry.m_numActiveRefLayerPics; i++ )
227	{
228	in>>entry.m_interViewRefPosL[1][i];
229	}
230	#endif
231	return in;
232	}
233
234	static const struct MapStrToProfile {
235	const Char* str;
236	Profile::Name value;
237	} strToProfile[] = {
238	{"none", Profile::NONE},
239	{"main", Profile::MAIN},
240	{"main10", Profile::MAIN10},
241	{"main-still-picture", Profile::MAINSTILLPICTURE},
242	#if H_MV
243	{"main-stereo", Profile::MAINSTEREO},
244	{"main-multiview", Profile::MAINMULTIVIEW},
245	#if H_3D
246	{"main-3d" , Profile::MAIN3D},
247	#endif
248	#endif
249	};
250
251	static const struct MapStrToTier {
252	const Char* str;
253	Level::Tier value;
254	} strToTier[] = {
255	{"main", Level::MAIN},
256	{"high", Level::HIGH},
257	};
258
259	static const struct MapStrToLevel {
260	const Char* str;
261	Level::Name value;
262	} strToLevel[] = {
263	{"none",Level::NONE},
264	{"1", Level::LEVEL1},
265	{"2", Level::LEVEL2},
266	{"2.1", Level::LEVEL2_1},
267	{"3", Level::LEVEL3},
268	{"3.1", Level::LEVEL3_1},
269	{"4", Level::LEVEL4},
270	{"4.1", Level::LEVEL4_1},
271	{"5", Level::LEVEL5},
272	{"5.1", Level::LEVEL5_1},
273	{"5.2", Level::LEVEL5_2},
274	{"6", Level::LEVEL6},
275	{"6.1", Level::LEVEL6_1},
276	{"6.2", Level::LEVEL6_2},
277	};
278
279	template<typename T, typename P>
280	static istream& readStrToEnum(P map[], unsigned long mapLen, istream &in, T &val)
281	{
282	string str;
283	in >> str;
284
285	for (Int i = 0; i < mapLen; i++)
286	{
287	if (str == map[i].str)
288	{
289	val = map[i].value;
290	goto found;
291	}
292	}
293	/* not found */
294	in.setstate(ios::failbit);
295	found:
296	return in;
297	}
298
299	static istream& operator>>(istream &in, Profile::Name &profile)
300	{
301	return readStrToEnum(strToProfile, sizeof(strToProfile)/sizeof(*strToProfile), in, profile);
302	}
303
304	static istream& operator>>(istream &in, Level::Tier &tier)
305	{
306	return readStrToEnum(strToTier, sizeof(strToTier)/sizeof(*strToTier), in, tier);
307	}
308
309	static istream& operator>>(istream &in, Level::Name &level)
310	{
311	return readStrToEnum(strToLevel, sizeof(strToLevel)/sizeof(*strToLevel), in, level);
312	}
313
314	// ====================================================================================================================
315	// Public member functions
316	// ====================================================================================================================
317
318	/** \param argc number of arguments
319	\param argv array of arguments
320	\retval true when success
321	*/
322	Bool TAppEncCfg::parseCfg( Int argc, Char* argv[] )
323	{
324	Bool do_help = false;
325
326	#if !H_MV
327	string cfg_InputFile;
328	#endif
329	string cfg_BitstreamFile;
330	#if !H_MV
331	string cfg_ReconFile;
332	#endif
333	#if H_MV
334	vector<Int> cfg_dimensionLength;
335	#if H_3D
336	cfg_dimensionLength.push_back( 2 ); // depth
337	cfg_dimensionLength.push_back( 32 ); // texture
338	#else
339	cfg_dimensionLength.push_back( 64 );
340	#endif
341	#endif
342	string cfg_dQPFile;
343	string cfg_ColumnWidth;
344	string cfg_RowHeight;
345	string cfg_ScalingListFile;
346	string cfg_startOfCodedInterval;
347	string cfg_codedPivotValue;
348	string cfg_targetPivotValue;
349	po::Options opts;
350	opts.addOptions()
351	("help", do_help, false, "this help text")
352	("c", po::parseConfigFile, "configuration file name")
353
354	// File, I/O and source parameters
355	#if H_MV
356	("InputFile_%d,i_%d", m_pchInputFileList, (char *) 0 , MAX_NUM_LAYER_IDS , "original Yuv input file name %d")
357	#else
358	("InputFile,i", cfg_InputFile, string(""), "Original YUV input file name")
359	#endif
360	("BitstreamFile,b", cfg_BitstreamFile, string(""), "Bitstream output file name")
361	#if H_MV
362	("ReconFile_%d,o_%d", m_pchReconFileList, (char *) 0 , MAX_NUM_LAYER_IDS , "reconstructed Yuv output file name %d")
363	#else
364	("ReconFile,o", cfg_ReconFile, string(""), "Reconstructed YUV output file name")
365	#endif
366	#if H_MV
367	("NumberOfLayers", m_numberOfLayers , 1, "Number of layers")
368	#if !H_3D
369	("ScalabilityMask", m_scalabilityMask , 2 , "Scalability Mask")
370	#else
371	("ScalabilityMask", m_scalabilityMask , 3 , "Scalability Mask, 1: Texture 3: Texture + Depth ")
372	#endif
373	("DimensionIdLen", m_dimensionIdLen , cfg_dimensionLength , "Number of bits used to store dimensions Id")
374	("ViewOrderIndex", m_viewOrderIndex , std::vector<Int>(1,0), "View Order Index per layer")
375	("ViewId", m_viewId , std::vector<Int>(1,0), "View Id per View Order Index")
376	#if H_3D
377	("DepthFlag", m_depthFlag , std::vector<Int>(1,0), "Depth Flag")
378	#if H_3D_DIM
379	("DMM", m_useDMM, true, "Depth intra model modes")
380	("SDC", m_useSDC, true, "Simplified depth coding")
381	("DLT", m_useDLT, true, "Depth lookup table")
382	#endif
383	#endif
384	("LayerIdInNuh", m_layerIdInNuh , std::vector<Int>(1,0), "LayerId in Nuh")
385	("SplittingFlag", m_splittingFlag , false , "Splitting Flag")
386
387	// Layer Sets + Output Layer Sets + Profile Tier Level
388	("VpsNumLayerSets", m_vpsNumLayerSets , 1 , "Number of layer sets")
389	("LayerIdsInSet_%d", m_layerIdsInSets , std::vector<Int>(1,0), MAX_VPS_OP_SETS_PLUS1 ,"LayerIds of Layer set")
390	("DefaultTargetOutputLayerIdc" , m_defaultOutputLayerIdc , 0, "Specifies output layers of layer sets, 0: output all layers, 1: output highest layer, 2: specified by LayerIdsInDefOutputLayerSet")
391	("OutputLayerSetIdx", m_outputLayerSetIdx , std::vector<Int>(0,0), "Indices of layer sets used as additional output layer sets")
392
393	("LayerIdsInAddOutputLayerSet_%d", m_layerIdsInAddOutputLayerSet , std::vector<Int>(0,0), MAX_VPS_ADD_OUTPUT_LAYER_SETS, "Indices in VPS of output layers in additional output layer set")
394	("LayerIdsInDefOutputLayerSet_%d", m_layerIdsInDefOutputLayerSet , std::vector<Int>(0,0), MAX_VPS_OP_SETS_PLUS1, "Indices in VPS of output layers in layer set")
395	("AltOutputLayerFlag", m_altOutputLayerFlag , std::vector<Bool>(1,0), "Alt output layer flag")
396	("ProfileLevelTierIdx", m_profileLevelTierIdx, std::vector<Int>(1,0), "Indices to profile level tier")
397
398	// Layer dependencies
399	("DirectRefLayers_%d", m_directRefLayers , std::vector<Int>(0,0), MAX_NUM_LAYERS, "LayerIds of direct reference layers")
400	("DependencyTypes_%d", m_dependencyTypes , std::vector<Int>(0,0), MAX_NUM_LAYERS, "Dependency types of direct reference layers, 0: Sample 1: Motion 2: Sample+Motion")
401	#endif
402	("SourceWidth,-wdt", m_iSourceWidth, 0, "Source picture width")
403	("SourceHeight,-hgt", m_iSourceHeight, 0, "Source picture height")
404	("InputBitDepth", m_inputBitDepthY, 8, "Bit-depth of input file")
405	("OutputBitDepth", m_outputBitDepthY, 0, "Bit-depth of output file (default:InternalBitDepth)")
406	("InternalBitDepth", m_internalBitDepthY, 0, "Bit-depth the codec operates at. (default:InputBitDepth)"
407	"If different to InputBitDepth, source data will be converted")
408	("InputBitDepthC", m_inputBitDepthC, 0, "As per InputBitDepth but for chroma component. (default:InputBitDepth)")
409	("OutputBitDepthC", m_outputBitDepthC, 0, "As per OutputBitDepth but for chroma component. (default:InternalBitDepthC)")
410	("InternalBitDepthC", m_internalBitDepthC, 0, "As per InternalBitDepth but for chroma component. (default:IntrenalBitDepth)")
411	("ConformanceMode", m_conformanceMode, 0, "Window conformance mode (0: no window, 1:automatic padding, 2:padding, 3:conformance")
412	("HorizontalPadding,-pdx",m_aiPad[0], 0, "Horizontal source padding for conformance window mode 2")
413	("VerticalPadding,-pdy", m_aiPad[1], 0, "Vertical source padding for conformance window mode 2")
414	("ConfLeft", m_confLeft, 0, "Left offset for window conformance mode 3")
415	("ConfRight", m_confRight, 0, "Right offset for window conformance mode 3")
416	("ConfTop", m_confTop, 0, "Top offset for window conformance mode 3")
417	("ConfBottom", m_confBottom, 0, "Bottom offset for window conformance mode 3")
418	("FrameRate,-fr", m_iFrameRate, 0, "Frame rate")
419	("FrameSkip,-fs", m_FrameSkip, 0u, "Number of frames to skip at start of input YUV")
420	("FramesToBeEncoded,f", m_framesToBeEncoded, 0, "Number of frames to be encoded (default=all)")
421
422	//Field coding parameters
423	("FieldCoding", m_isField, false, "Signals if it's a field based coding")
424	("TopFieldFirst, Tff", m_isTopFieldFirst, false, "In case of field based coding, signals whether if it's a top field first or not")
425
426	// Profile and level
427	("Profile", m_profile, Profile::NONE, "Profile to be used when encoding (Incomplete)")
428	("Level", m_level, Level::NONE, "Level limit to be used, eg 5.1 (Incomplete)")
429	("Tier", m_levelTier, Level::MAIN, "Tier to use for interpretation of --Level")
430
431	("ProgressiveSource", m_progressiveSourceFlag, false, "Indicate that source is progressive")
432	("InterlacedSource", m_interlacedSourceFlag, false, "Indicate that source is interlaced")
433	("NonPackedSource", m_nonPackedConstraintFlag, false, "Indicate that source does not contain frame packing")
434	("FrameOnly", m_frameOnlyConstraintFlag, false, "Indicate that the bitstream contains only frames")
435
436	// Unit definition parameters
437	("MaxCUWidth", m_uiMaxCUWidth, 64u)
438	("MaxCUHeight", m_uiMaxCUHeight, 64u)
439	// todo: remove defaults from MaxCUSize
440	("MaxCUSize,s", m_uiMaxCUWidth, 64u, "Maximum CU size")
441	("MaxCUSize,s", m_uiMaxCUHeight, 64u, "Maximum CU size")
442	("MaxPartitionDepth,h", m_uiMaxCUDepth, 4u, "CU depth")
443
444	("QuadtreeTULog2MaxSize", m_uiQuadtreeTULog2MaxSize, 6u, "Maximum TU size in logarithm base 2")
445	("QuadtreeTULog2MinSize", m_uiQuadtreeTULog2MinSize, 2u, "Minimum TU size in logarithm base 2")
446
447	("QuadtreeTUMaxDepthIntra", m_uiQuadtreeTUMaxDepthIntra, 1u, "Depth of TU tree for intra CUs")
448	("QuadtreeTUMaxDepthInter", m_uiQuadtreeTUMaxDepthInter, 2u, "Depth of TU tree for inter CUs")
449	#if H_MV
450	// Coding structure parameters
451	("IntraPeriod,-ip", m_iIntraPeriod,std::vector<Int>(1,-1), "Intra period in frames, (-1: only first frame), per layer")
452	#else
453	// Coding structure paramters
454	("IntraPeriod,-ip", m_iIntraPeriod, -1, "Intra period in frames, (-1: only first frame)")
455	#endif
456	#if ALLOW_RECOVERY_POINT_AS_RAP
457	("DecodingRefreshType,-dr", m_iDecodingRefreshType, 0, "Intra refresh type (0:none 1:CRA 2:IDR 3:RecPointSEI)")
458	#else
459	("DecodingRefreshType,-dr", m_iDecodingRefreshType, 0, "Intra refresh type (0:none 1:CRA 2:IDR)")
460	#endif
461	("GOPSize,g", m_iGOPSize, 1, "GOP size of temporal structure")
462	// motion options
463	("FastSearch", m_iFastSearch, 1, "0:Full search 1:Diamond 2:PMVFAST")
464	("SearchRange,-sr", m_iSearchRange, 96, "Motion search range")
465	("BipredSearchRange", m_bipredSearchRange, 4, "Motion search range for bipred refinement")
466	("HadamardME", m_bUseHADME, true, "Hadamard ME for fractional-pel")
467	("ASR", m_bUseASR, false, "Adaptive motion search range")
468
469	// Mode decision parameters
470	("LambdaModifier0,-LM0", m_adLambdaModifier[ 0 ], ( Double )1.0, "Lambda modifier for temporal layer 0")
471	("LambdaModifier1,-LM1", m_adLambdaModifier[ 1 ], ( Double )1.0, "Lambda modifier for temporal layer 1")
472	("LambdaModifier2,-LM2", m_adLambdaModifier[ 2 ], ( Double )1.0, "Lambda modifier for temporal layer 2")
473	("LambdaModifier3,-LM3", m_adLambdaModifier[ 3 ], ( Double )1.0, "Lambda modifier for temporal layer 3")
474	("LambdaModifier4,-LM4", m_adLambdaModifier[ 4 ], ( Double )1.0, "Lambda modifier for temporal layer 4")
475	("LambdaModifier5,-LM5", m_adLambdaModifier[ 5 ], ( Double )1.0, "Lambda modifier for temporal layer 5")
476	("LambdaModifier6,-LM6", m_adLambdaModifier[ 6 ], ( Double )1.0, "Lambda modifier for temporal layer 6")
477
478	/* Quantization parameters */
479	#if H_MV
480	("QP,q", m_fQP, std::vector<double>(1,30.0), "Qp values for each layer, if value is float, QP is switched once during encoding")
481	#else
482	("QP,q", m_fQP, 30.0, "Qp value, if value is float, QP is switched once during encoding")
483	#endif
484	("DeltaQpRD,-dqr",m_uiDeltaQpRD, 0u, "max dQp offset for slice")
485	("MaxDeltaQP,d", m_iMaxDeltaQP, 0, "max dQp offset for block")
486	("MaxCuDQPDepth,-dqd", m_iMaxCuDQPDepth, 0, "max depth for a minimum CuDQP")
487
488	("CbQpOffset,-cbqpofs", m_cbQpOffset, 0, "Chroma Cb QP Offset")
489	("CrQpOffset,-crqpofs", m_crQpOffset, 0, "Chroma Cr QP Offset")
490
491	#if ADAPTIVE_QP_SELECTION
492	("AdaptiveQpSelection,-aqps", m_bUseAdaptQpSelect, false, "AdaptiveQpSelection")
493	#endif
494
495	("AdaptiveQP,-aq", m_bUseAdaptiveQP, false, "QP adaptation based on a psycho-visual model")
496	("MaxQPAdaptationRange,-aqr", m_iQPAdaptationRange, 6, "QP adaptation range")
497	("dQPFile,m", cfg_dQPFile, string(""), "dQP file name")
498	("RDOQ", m_useRDOQ, true )
499	("RDOQTS", m_useRDOQTS, true )
500	("RDpenalty", m_rdPenalty, 0, "RD-penalty for 32x32 TU for intra in non-intra slices. 0:disbaled 1:RD-penalty 2:maximum RD-penalty")
501
502	// Deblocking filter parameters
503	#if H_MV
504	("LoopFilterDisable", m_bLoopFilterDisable, std::vector<Bool>(1,false), "Disable Loop Filter per Layer" )
505	#else
506	("LoopFilterDisable", m_bLoopFilterDisable, false )
507	#endif
508	("LoopFilterOffsetInPPS", m_loopFilterOffsetInPPS, false )
509	("LoopFilterBetaOffset_div2", m_loopFilterBetaOffsetDiv2, 0 )
510	("LoopFilterTcOffset_div2", m_loopFilterTcOffsetDiv2, 0 )
511	("DeblockingFilterControlPresent", m_DeblockingFilterControlPresent, false )
512	("DeblockingFilterMetric", m_DeblockingFilterMetric, false )
513
514	#if H_3D_ARP
515	("AdvMultiviewResPred", m_uiUseAdvResPred, (UInt)1, "Usage of Advanced Residual Prediction" )
516	#endif
517	#if H_3D_SPIVMP
518	("SubPULog2Size", m_iSubPULog2Size, (Int)3, "Sub-PU size index: 2^n")
519	("SubPUMPILog2Size", m_iSubPUMPILog2Size, (Int)3, "Sub-PU MPI size index: 2^n")
520	#endif
521	#if H_3D_IC
522	("IlluCompEnable", m_abUseIC, true, "Enable illumination compensation")
523	("IlluCompLowLatencyEnc", m_bUseLowLatencyICEnc, false, "Enable low-latency illumination compensation encoding")
524	#endif
525	#if H_3D_INTER_SDC
526	("InterSDC", m_bDepthInterSDCFlag, true, "Enable depth inter SDC")
527	#endif
528	#if H_3D_DBBP
529	("DBBP", m_bUseDBBP, true, "Enable depth-based block partitioning" )
530	#endif
531	#if H_3D_IV_MERGE
532	("MPI", m_bMPIFlag, true, "Enable MPI")
533	#endif
534	// Coding tools
535	("AMP", m_enableAMP, true, "Enable asymmetric motion partitions")
536	("TransformSkip", m_useTransformSkip, false, "Intra transform skipping")
537	("TransformSkipFast", m_useTransformSkipFast, false, "Fast intra transform skipping")
538	#if H_MV
539	("SAO", m_bUseSAO, std::vector<Bool>(1,true), "Enable Sample Adaptive Offset per Layer")
540	#else
541	("SAO", m_bUseSAO, true, "Enable Sample Adaptive Offset")
542	#endif
543	("MaxNumOffsetsPerPic", m_maxNumOffsetsPerPic, 2048, "Max number of SAO offset per picture (Default: 2048)")
544	("SAOLcuBoundary", m_saoLcuBoundary, false, "0: right/bottom LCU boundary areas skipped from SAO parameter estimation, 1: non-deblocked pixels are used for those areas")
545	("SliceMode", m_sliceMode, 0, "0: Disable all Recon slice limits, 1: Enforce max # of LCUs, 2: Enforce max # of bytes, 3:specify tiles per dependent slice")
546	("SliceArgument", m_sliceArgument, 0, "Depending on SliceMode being:"
547	"\t1: max number of CTUs per slice"
548	"\t2: max number of bytes per slice"
549	"\t3: max number of tiles per slice")
550	("SliceSegmentMode", m_sliceSegmentMode, 0, "0: Disable all slice segment limits, 1: Enforce max # of LCUs, 2: Enforce max # of bytes, 3:specify tiles per dependent slice")
551	("SliceSegmentArgument", m_sliceSegmentArgument, 0, "Depending on SliceSegmentMode being:"
552	"\t1: max number of CTUs per slice segment"
553	"\t2: max number of bytes per slice segment"
554	"\t3: max number of tiles per slice segment")
555	("LFCrossSliceBoundaryFlag", m_bLFCrossSliceBoundaryFlag, true)
556
557	("ConstrainedIntraPred", m_bUseConstrainedIntraPred, false, "Constrained Intra Prediction")
558
559	("PCMEnabledFlag", m_usePCM, false)
560	("PCMLog2MaxSize", m_pcmLog2MaxSize, 5u)
561	("PCMLog2MinSize", m_uiPCMLog2MinSize, 3u)
562	("PCMInputBitDepthFlag", m_bPCMInputBitDepthFlag, true)
563	("PCMFilterDisableFlag", m_bPCMFilterDisableFlag, false)
564
565	("WeightedPredP,-wpP", m_useWeightedPred, false, "Use weighted prediction in P slices")
566	("WeightedPredB,-wpB", m_useWeightedBiPred, false, "Use weighted (bidirectional) prediction in B slices")
567	("Log2ParallelMergeLevel", m_log2ParallelMergeLevel, 2u, "Parallel merge estimation region")
568	("UniformSpacingIdc", m_iUniformSpacingIdr, 0, "Indicates if the column and row boundaries are distributed uniformly")
569	("NumTileColumnsMinus1", m_iNumColumnsMinus1, 0, "Number of columns in a picture minus 1")
570	("ColumnWidthArray", cfg_ColumnWidth, string(""), "Array containing ColumnWidth values in units of LCU")
571	("NumTileRowsMinus1", m_iNumRowsMinus1, 0, "Number of rows in a picture minus 1")
572	("RowHeightArray", cfg_RowHeight, string(""), "Array containing RowHeight values in units of LCU")
573	("LFCrossTileBoundaryFlag", m_bLFCrossTileBoundaryFlag, true, "1: cross-tile-boundary loop filtering. 0:non-cross-tile-boundary loop filtering")
574	("WaveFrontSynchro", m_iWaveFrontSynchro, 0, "0: no synchro; 1 synchro with TR; 2 TRR etc")
575	("ScalingList", m_useScalingListId, 0, "0: no scaling list, 1: default scaling lists, 2: scaling lists specified in ScalingListFile")
576	("ScalingListFile", cfg_ScalingListFile, string(""), "Scaling list file name")
577	("SignHideFlag,-SBH", m_signHideFlag, 1)
578	("MaxNumMergeCand", m_maxNumMergeCand, 5u, "Maximum number of merge candidates")
579
580	/* Misc. */
581	("SEIDecodedPictureHash", m_decodedPictureHashSEIEnabled, 0, "Control generation of decode picture hash SEI messages\n"
582	"\t3: checksum\n"
583	"\t2: CRC\n"
584	"\t1: use MD5\n"
585	"\t0: disable")
586	("SEIpictureDigest", m_decodedPictureHashSEIEnabled, 0, "deprecated alias for SEIDecodedPictureHash")
587	("TMVPMode", m_TMVPModeId, 1, "TMVP mode 0: TMVP disable for all slices. 1: TMVP enable for all slices (default) 2: TMVP enable for certain slices only")
588	("FEN", m_bUseFastEnc, false, "fast encoder setting")
589	("ECU", m_bUseEarlyCU, false, "Early CU setting")
590	("FDM", m_useFastDecisionForMerge, true, "Fast decision for Merge RD Cost")
591	("CFM", m_bUseCbfFastMode, false, "Cbf fast mode setting")
592	("ESD", m_useEarlySkipDetection, false, "Early SKIP detection setting")
593	( "RateControl", m_RCEnableRateControl, false, "Rate control: enable rate control" )
594	( "TargetBitrate", m_RCTargetBitrate, 0, "Rate control: target bitrate" )
595	( "KeepHierarchicalBit", m_RCKeepHierarchicalBit, 0, "Rate control: 0: equal bit allocation; 1: fixed ratio bit allocation; 2: adaptive ratio bit allocation" )
596	( "LCULevelRateControl", m_RCLCULevelRC, true, "Rate control: true: LCU level RC; false: picture level RC" )
597	( "RCLCUSeparateModel", m_RCUseLCUSeparateModel, true, "Rate control: use LCU level separate R-lambda model" )
598	( "InitialQP", m_RCInitialQP, 0, "Rate control: initial QP" )
599	( "RCForceIntraQP", m_RCForceIntraQP, false, "Rate control: force intra QP to be equal to initial QP" )
600
601	#if KWU_RC_VIEWRC_E0227
602	("ViewWiseTargetBits, -vtbr" , m_viewTargetBits, std::vector<Int>(1, 32), "View-wise target bit-rate setting")
603	("TargetBitAssign, -ta", m_viewWiseRateCtrl, false, "View-wise rate control on/off")
604	#endif
605	#if KWU_RC_MADPRED_E0227
606	("DepthMADPred, -dm", m_depthMADPred, (UInt)0, "Depth based MAD prediction on/off")
607	#endif
608	#if H_MV
609
610	// VPS VUI
611	("VpsVuiPresentFlag" , m_vpsVuiPresentFlag , false , "VpsVuiPresentFlag ")
612	("CrossLayerPicTypeAlignedFlag", m_crossLayerPicTypeAlignedFlag, false , "CrossLayerPicTypeAlignedFlag") // Could actually be derived by the encoder
613	("CrossLayerIrapAlignedFlag" , m_crossLayerIrapAlignedFlag , false , "CrossLayerIrapAlignedFlag ") // Could actually be derived by the encoder
614	("AllLayersIdrAlignedFlag" , m_allLayersIdrAlignedFlag , false , "CrossLayerIrapAlignedFlag ") // Could actually be derived by the encoder
615	("BitRatePresentVpsFlag" , m_bitRatePresentVpsFlag , false , "BitRatePresentVpsFlag ")
616	("PicRatePresentVpsFlag" , m_picRatePresentVpsFlag , false , "PicRatePresentVpsFlag ")
617	("BitRatePresentFlag" , m_bitRatePresentFlag , std::vector< Bool >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "BitRatePresentFlag per sub layer for the N-th layer set")
618	("PicRatePresentFlag" , m_picRatePresentFlag , std::vector< Bool >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "PicRatePresentFlag per sub layer for the N-th layer set")
619	("AvgBitRate" , m_avgBitRate , std::vector< Int >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "AvgBitRate per sub layer for the N-th layer set")
620	("MaxBitRate" , m_maxBitRate , std::vector< Int >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "MaxBitRate per sub layer for the N-th layer set")
621	("ConstantPicRateIdc" , m_constantPicRateIdc , std::vector< Int >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "ConstantPicRateIdc per sub layer for the N-th layer set")
622	("AvgPicRate" , m_avgPicRate , std::vector< Int >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "AvgPicRate per sub layer for the N-th layer set")
623	("TilesNotInUseFlag" , m_tilesNotInUseFlag , true , "TilesNotInUseFlag ")
624	("TilesInUseFlag" , m_tilesInUseFlag , std::vector< Bool >(1,false) , "TilesInUseFlag ")
625	("LoopFilterNotAcrossTilesFlag" , m_loopFilterNotAcrossTilesFlag , std::vector< Bool >(1,false) , "LoopFilterNotAcrossTilesFlag ")
626	("WppNotInUseFlag" , m_wppNotInUseFlag , true , "WppNotInUseFlag ")
627	("WppInUseFlag" , m_wppInUseFlag , std::vector< Bool >(1,0) , "WppInUseFlag ")
628	("TileBoundariesAlignedFlag" , m_tileBoundariesAlignedFlag , std::vector< Bool >(1,0) ,MAX_NUM_LAYERS , "TileBoundariesAlignedFlag per direct reference for the N-th layer")
629	("IlpRestrictedRefLayersFlag" , m_ilpRestrictedRefLayersFlag , false , "IlpRestrictedRefLayersFlag")
630	("MinSpatialSegmentOffsetPlus1", m_minSpatialSegmentOffsetPlus1, std::vector< Int >(1,0) ,MAX_NUM_LAYERS , "MinSpatialSegmentOffsetPlus1 per direct reference for the N-th layer")
631	("CtuBasedOffsetEnabledFlag" , m_ctuBasedOffsetEnabledFlag , std::vector< Bool >(1,0) ,MAX_NUM_LAYERS , "CtuBasedOffsetEnabledFlag per direct reference for the N-th layer")
632	("MinHorizontalCtuOffsetPlus1" , m_minHorizontalCtuOffsetPlus1 , std::vector< Int >(1,0) ,MAX_NUM_LAYERS , "MinHorizontalCtuOffsetPlus1 per direct reference for the N-th layer")
633	#endif
634
635	("TransquantBypassEnableFlag", m_TransquantBypassEnableFlag, false, "transquant_bypass_enable_flag indicator in PPS")
636	("CUTransquantBypassFlagForce", m_CUTransquantBypassFlagForce, false, "Force transquant bypass mode, when transquant_bypass_enable_flag is enabled")
637	("RecalculateQPAccordingToLambda", m_recalculateQPAccordingToLambda, false, "Recalculate QP values according to lambda values. Do not suggest to be enabled in all intra case")
638	("StrongIntraSmoothing,-sis", m_useStrongIntraSmoothing, true, "Enable strong intra smoothing for 32x32 blocks")
639	("SEIActiveParameterSets", m_activeParameterSetsSEIEnabled, 0, "Enable generation of active parameter sets SEI messages")
640	("VuiParametersPresent,-vui", m_vuiParametersPresentFlag, false, "Enable generation of vui_parameters()")
641	("AspectRatioInfoPresent", m_aspectRatioInfoPresentFlag, false, "Signals whether aspect_ratio_idc is present")
642	("AspectRatioIdc", m_aspectRatioIdc, 0, "aspect_ratio_idc")
643	("SarWidth", m_sarWidth, 0, "horizontal size of the sample aspect ratio")
644	("SarHeight", m_sarHeight, 0, "vertical size of the sample aspect ratio")
645	("OverscanInfoPresent", m_overscanInfoPresentFlag, false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n")
646	("OverscanAppropriate", m_overscanAppropriateFlag, false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n")
647	("VideoSignalTypePresent", m_videoSignalTypePresentFlag, false, "Signals whether video_format, video_full_range_flag, and colour_description_present_flag are present")
648	("VideoFormat", m_videoFormat, 5, "Indicates representation of pictures")
649	("VideoFullRange", m_videoFullRangeFlag, false, "Indicates the black level and range of luma and chroma signals")
650	("ColourDescriptionPresent", m_colourDescriptionPresentFlag, false, "Signals whether colour_primaries, transfer_characteristics and matrix_coefficients are present")
651	("ColourPrimaries", m_colourPrimaries, 2, "Indicates chromaticity coordinates of the source primaries")
652	("TransferCharateristics", m_transferCharacteristics, 2, "Indicates the opto-electronic transfer characteristics of the source")
653	("MatrixCoefficients", m_matrixCoefficients, 2, "Describes the matrix coefficients used in deriving luma and chroma from RGB primaries")
654	("ChromaLocInfoPresent", m_chromaLocInfoPresentFlag, false, "Signals whether chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field are present")
655	("ChromaSampleLocTypeTopField", m_chromaSampleLocTypeTopField, 0, "Specifies the location of chroma samples for top field")
656	("ChromaSampleLocTypeBottomField", m_chromaSampleLocTypeBottomField, 0, "Specifies the location of chroma samples for bottom field")
657	("NeutralChromaIndication", m_neutralChromaIndicationFlag, false, "Indicates that the value of all decoded chroma samples is equal to 1<<(BitDepthCr-1)")
658	("DefaultDisplayWindowFlag", m_defaultDisplayWindowFlag, false, "Indicates the presence of the Default Window parameters")
659	("DefDispWinLeftOffset", m_defDispWinLeftOffset, 0, "Specifies the left offset of the default display window from the conformance window")
660	("DefDispWinRightOffset", m_defDispWinRightOffset, 0, "Specifies the right offset of the default display window from the conformance window")
661	("DefDispWinTopOffset", m_defDispWinTopOffset, 0, "Specifies the top offset of the default display window from the conformance window")
662	("DefDispWinBottomOffset", m_defDispWinBottomOffset, 0, "Specifies the bottom offset of the default display window from the conformance window")
663	("FrameFieldInfoPresentFlag", m_frameFieldInfoPresentFlag, false, "Indicates that pic_struct and field coding related values are present in picture timing SEI messages")
664	("PocProportionalToTimingFlag", m_pocProportionalToTimingFlag, false, "Indicates that the POC value is proportional to the output time w.r.t. first picture in CVS")
665	("NumTicksPocDiffOneMinus1", m_numTicksPocDiffOneMinus1, 0, "Number of ticks minus 1 that for a POC difference of one")
666	("BitstreamRestriction", m_bitstreamRestrictionFlag, false, "Signals whether bitstream restriction parameters are present")
667	("TilesFixedStructure", m_tilesFixedStructureFlag, false, "Indicates that each active picture parameter set has the same values of the syntax elements related to tiles")
668	("MotionVectorsOverPicBoundaries", m_motionVectorsOverPicBoundariesFlag, false, "Indicates that no samples outside the picture boundaries are used for inter prediction")
669	("MaxBytesPerPicDenom", m_maxBytesPerPicDenom, 2, "Indicates a number of bytes not exceeded by the sum of the sizes of the VCL NAL units associated with any coded picture")
670	("MaxBitsPerMinCuDenom", m_maxBitsPerMinCuDenom, 1, "Indicates an upper bound for the number of bits of coding_unit() data")
671	("Log2MaxMvLengthHorizontal", m_log2MaxMvLengthHorizontal, 15, "Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units")
672	("Log2MaxMvLengthVertical", m_log2MaxMvLengthVertical, 15, "Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units")
673	("SEIRecoveryPoint", m_recoveryPointSEIEnabled, 0, "Control generation of recovery point SEI messages")
674	("SEIBufferingPeriod", m_bufferingPeriodSEIEnabled, 0, "Control generation of buffering period SEI messages")
675	("SEIPictureTiming", m_pictureTimingSEIEnabled, 0, "Control generation of picture timing SEI messages")
676	("SEIToneMappingInfo", m_toneMappingInfoSEIEnabled, false, "Control generation of Tone Mapping SEI messages")
677	("SEIToneMapId", m_toneMapId, 0, "Specifies Id of Tone Mapping SEI message for a given session")
678	("SEIToneMapCancelFlag", m_toneMapCancelFlag, false, "Indicates that Tone Mapping SEI message cancels the persistance or follows")
679	("SEIToneMapPersistenceFlag", m_toneMapPersistenceFlag, true, "Specifies the persistence of the Tone Mapping SEI message")
680	("SEIToneMapCodedDataBitDepth", m_toneMapCodedDataBitDepth, 8, "Specifies Coded Data BitDepth of Tone Mapping SEI messages")
681	("SEIToneMapTargetBitDepth", m_toneMapTargetBitDepth, 8, "Specifies Output BitDepth of Tome mapping function")
682	("SEIToneMapModelId", m_toneMapModelId, 0, "Specifies Model utilized for mapping coded data into target_bit_depth range\n"
683	"\t0: linear mapping with clipping\n"
684	"\t1: sigmoidal mapping\n"
685	"\t2: user-defined table mapping\n"
686	"\t3: piece-wise linear mapping\n"
687	"\t4: luminance dynamic range information ")
688	("SEIToneMapMinValue", m_toneMapMinValue, 0, "Specifies the minimum value in mode 0")
689	("SEIToneMapMaxValue", m_toneMapMaxValue, 1023, "Specifies the maxmum value in mode 0")
690	("SEIToneMapSigmoidMidpoint", m_sigmoidMidpoint, 512, "Specifies the centre point in mode 1")
691	("SEIToneMapSigmoidWidth", m_sigmoidWidth, 960, "Specifies the distance between 5% and 95% values of the target_bit_depth in mode 1")
692	("SEIToneMapStartOfCodedInterval", cfg_startOfCodedInterval, string(""), "Array of user-defined mapping table")
693	("SEIToneMapNumPivots", m_numPivots, 0, "Specifies the number of pivot points in mode 3")
694	("SEIToneMapCodedPivotValue", cfg_codedPivotValue, string(""), "Array of pivot point")
695	("SEIToneMapTargetPivotValue", cfg_targetPivotValue, string(""), "Array of pivot point")
696	("SEIToneMapCameraIsoSpeedIdc", m_cameraIsoSpeedIdc, 0, "Indicates the camera ISO speed for daylight illumination")
697	("SEIToneMapCameraIsoSpeedValue", m_cameraIsoSpeedValue, 400, "Specifies the camera ISO speed for daylight illumination of Extended_ISO")
698	("SEIToneMapExposureIndexIdc", m_exposureIndexIdc, 0, "Indicates the exposure index setting of the camera")
699	("SEIToneMapExposureIndexValue", m_exposureIndexValue, 400, "Specifies the exposure index setting of the cameran of Extended_ISO")
700	("SEIToneMapExposureCompensationValueSignFlag", m_exposureCompensationValueSignFlag, 0, "Specifies the sign of ExposureCompensationValue")
701	("SEIToneMapExposureCompensationValueNumerator", m_exposureCompensationValueNumerator, 0, "Specifies the numerator of ExposureCompensationValue")
702	("SEIToneMapExposureCompensationValueDenomIdc", m_exposureCompensationValueDenomIdc, 2, "Specifies the denominator of ExposureCompensationValue")
703	("SEIToneMapRefScreenLuminanceWhite", m_refScreenLuminanceWhite, 350, "Specifies reference screen brightness setting in units of candela per square metre")
704	("SEIToneMapExtendedRangeWhiteLevel", m_extendedRangeWhiteLevel, 800, "Indicates the luminance dynamic range")
705	("SEIToneMapNominalBlackLevelLumaCodeValue", m_nominalBlackLevelLumaCodeValue, 16, "Specifies luma sample value of the nominal black level assigned decoded pictures")
706	("SEIToneMapNominalWhiteLevelLumaCodeValue", m_nominalWhiteLevelLumaCodeValue, 235, "Specifies luma sample value of the nominal white level assigned decoded pictures")
707	("SEIToneMapExtendedWhiteLevelLumaCodeValue", m_extendedWhiteLevelLumaCodeValue, 300, "Specifies luma sample value of the extended dynamic range assigned decoded pictures")
708	("SEIFramePacking", m_framePackingSEIEnabled, 0, "Control generation of frame packing SEI messages")
709	("SEIFramePackingType", m_framePackingSEIType, 0, "Define frame packing arrangement\n"
710	"\t0: checkerboard - pixels alternatively represent either frames\n"
711	"\t1: column alternation - frames are interlaced by column\n"
712	"\t2: row alternation - frames are interlaced by row\n"
713	"\t3: side by side - frames are displayed horizontally\n"
714	"\t4: top bottom - frames are displayed vertically\n"
715	"\t5: frame alternation - one frame is alternated with the other")
716	("SEIFramePackingId", m_framePackingSEIId, 0, "Id of frame packing SEI message for a given session")
717	("SEIFramePackingQuincunx", m_framePackingSEIQuincunx, 0, "Indicate the presence of a Quincunx type video frame")
718	("SEIFramePackingInterpretation", m_framePackingSEIInterpretation, 0, "Indicate the interpretation of the frame pair\n"
719	"\t0: unspecified\n"
720	"\t1: stereo pair, frame0 represents left view\n"
721	"\t2: stereo pair, frame0 represents right view")
722	("SEIDisplayOrientation", m_displayOrientationSEIAngle, 0, "Control generation of display orientation SEI messages\n"
723	"\tN: 0 < N < (2^16 - 1) enable display orientation SEI message with anticlockwise_rotation = N and display_orientation_repetition_period = 1\n"
724	"\t0: disable")
725	("SEITemporalLevel0Index", m_temporalLevel0IndexSEIEnabled, 0, "Control generation of temporal level 0 index SEI messages")
726	("SEIGradualDecodingRefreshInfo", m_gradualDecodingRefreshInfoEnabled, 0, "Control generation of gradual decoding refresh information SEI message")
727	("SEIDecodingUnitInfo", m_decodingUnitInfoSEIEnabled, 0, "Control generation of decoding unit information SEI message.")
728	("SEISOPDescription", m_SOPDescriptionSEIEnabled, 0, "Control generation of SOP description SEI messages")
729	("SEIScalableNesting", m_scalableNestingSEIEnabled, 0, "Control generation of scalable nesting SEI messages")
730	#if H_MV
731	("SubBitstreamPropSEIEnabled", m_subBistreamPropSEIEnabled, false ,"Enable signaling of sub-bitstream property SEI message")
732	("SEISubBitstreamNumAdditionalSubStreams", m_sbPropNumAdditionalSubStreams,0, "Number of substreams for which additional information is signalled")
733	("SEISubBitstreamSubBitstreamMode", m_sbPropSubBitstreamMode, std::vector< Int >(1,0) ,"Specifies mode of generation of the i-th sub-bitstream (0 or 1)")
734	("SEISubBitstreamOutputLayerSetIdxToVps", m_sbPropOutputLayerSetIdxToVps, std::vector< Int >(1,0) ,"Specifies output layer set index of the i-th sub-bitstream ")
735	("SEISubBitstreamHighestSublayerId", m_sbPropHighestSublayerId, std::vector< Int >(1,0) ,"Specifies highest TemporalId of the i-th sub-bitstream")
736	("SEISubBitstreamAvgBitRate", m_sbPropAvgBitRate, std::vector< Int >(1,0) ,"Specifies average bit rate of the i-th sub-bitstream")
737	("SEISubBitstreamMaxBitRate", m_sbPropMaxBitRate, std::vector< Int >(1,0) ,"Specifies maximum bit rate of the i-th sub-bitstream")
738	#endif
739	#if H_3D
740	("CameraParameterFile,cpf", m_pchCameraParameterFile, (Char *) 0, "Camera Parameter File Name")
741	("BaseViewCameraNumbers" , m_pchBaseViewCameraNumbers, (Char *) 0, "Numbers of base views")
742	("CodedCamParsPrecision", m_iCodedCamParPrecision, STD_CAM_PARAMETERS_PRECISION, "precision for coding of camera parameters (in units of 2^(-x) luma samples)" )
743	/* View Synthesis Optimization */
744
745	#if H_3D_VSO
746	("VSOConfig", m_pchVSOConfig , (Char *) 0 , "VSO configuration")
747	("VSO", m_bUseVSO , false , "Use VSO" )
748	("VSOMode", m_uiVSOMode , (UInt) 4 , "VSO Mode")
749	("LambdaScaleVSO", m_dLambdaScaleVSO , (Double) 1 , "Lambda Scaling for VSO")
750	("VSOLSTable", m_bVSOLSTable , true , "Depth QP dependent video/depth rate allocation by Lagrange multiplier" )
751	("ForceLambdaScaleVSO", m_bForceLambdaScaleVSO , false , "Force using Lambda Scale VSO also in non-VSO-Mode")
752	("AllowNegDist", m_bAllowNegDist , true , "Allow negative Distortion in VSO")
753
754	("UseEstimatedVSD", m_bUseEstimatedVSD , true , "Model based VSD estimation instead of rendering based for some encoder decisions" )
755	("VSOEarlySkip", m_bVSOEarlySkip , true , "Early skip of VSO computation if synthesis error assumed to be zero" )
756
757	("WVSO", m_bUseWVSO , true , "Use depth fidelity term for VSO" )
758	("VSOWeight", m_iVSOWeight , 10 , "Synthesized View Distortion Change weight" )
759	("VSDWeight", m_iVSDWeight , 1 , "View Synthesis Distortion estimate weight" )
760	("DWeight", m_iDWeight , 1 , "Depth Distortion weight" )
761
762	#endif //HHI_VSO
763	#if MTK_I0099_VPS_EX2
764	("LimQtPredFlag", m_bLimQtPredFlag , true , "Use Predictive Coding with QTL" )
765	#endif
766	#if !MTK_I0099_VPS_EX2
767	#if H_3D_QTLPC
768	("QTL", m_bUseQTL , true , "Use depth Quadtree Limitation" )
769	("PC", m_bUsePC , true , "Use Predictive Coding with QTL" )
770	#endif
771	#endif
772	#if H_3D_IV_MERGE
773	("IvMvPred", m_ivMvPredFlag , std::vector<Bool>(2, true) , "inter view motion prediction " )
774	#endif
775	#if H_3D_NBDV_REF
776	("DepthRefinement", m_depthRefinementFlag, true , "depth refinement by DoNBDV" )
777	#endif
778	#if H_3D_VSP
779	("ViewSynthesisPred", m_viewSynthesisPredFlag, true , "view synthesis prediction " )
780	#endif
781	#if H_3D
782	("IvMvScaling", m_ivMvScalingFlag , true , "inter view motion vector scaling" )
783	#endif
784	#endif //H_3D
785	;
786	#if H_MV
787	// parse coding structure
788	for( Int k = 0; k < MAX_NUM_LAYERS; k++ )
789	{
790	m_GOPListMvc.push_back( new GOPEntry[MAX_GOP + 1] );
791	if( k == 0 )
792	{
793	m_GOPListMvc[0][0].m_sliceType = 'I';
794	for( Int i = 1; i < MAX_GOP + 1; i++ )
795	{
796	std::ostringstream cOSS;
797	cOSS<<"Frame"<<i;
798	opts.addOptions()( cOSS.str(), m_GOPListMvc[k][i-1], GOPEntry() );
799	if ( i != 1 )
800	{
801	opts.opt_list.back()->opt->opt_duplicate = true;
802	}
803	}
804	}
805	else
806	{
807	std::ostringstream cOSS1;
808	cOSS1<<"FrameI"<<"_l"<<k;
809
810	opts.addOptions()(cOSS1.str(), m_GOPListMvc[k][MAX_GOP], GOPEntry());
811	if ( k > 1 )
812	{
813	opts.opt_list.back()->opt->opt_duplicate = true;
814	}
815
816
817	for( Int i = 1; i < MAX_GOP + 1; i++ )
818	{
819	std::ostringstream cOSS2;
820	cOSS2<<"Frame"<<i<<"_l"<<k;
821	opts.addOptions()(cOSS2.str(), m_GOPListMvc[k][i-1], GOPEntry());
822	if ( i != 1 \|\| k > 0 )
823	{
824	opts.opt_list.back()->opt->opt_duplicate = true;
825	}
826	}
827	}
828	}
829	#else
830	for(Int i=1; i<MAX_GOP+1; i++) {
831	std::ostringstream cOSS;
832	cOSS<<"Frame"<<i;
833	opts.addOptions()(cOSS.str(), m_GOPList[i-1], GOPEntry());
834	}
835	#endif
836	po::setDefaults(opts);
837	const list<const Char>& argv_unhandled = po::scanArgv(opts, argc, (const Char*) argv);
838
839	if(m_isField)
840	{
841	//Frame height
842	m_iSourceHeightOrg = m_iSourceHeight;
843	//Field height
844	m_iSourceHeight = m_iSourceHeight >> 1;
845	//number of fields to encode
846	m_framesToBeEncoded *= 2;
847	}
848
849	for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
850	{
851	fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
852	}
853
854	if (argc == 1 \|\| do_help)
855	{
856	/* argc == 1: no options have been specified */
857	po::doHelp(cout, opts);
858	return false;
859	}
860
861	/*
862	* Set any derived parameters
863	*/
864	/* convert std::string to c string for compatability */
865	#if !H_MV
866	m_pchInputFile = cfg_InputFile.empty() ? NULL : strdup(cfg_InputFile.c_str());
867	#endif
868	m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
869	#if !H_MV
870	m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str());
871	#endif
872	m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());
873
874	Char* pColumnWidth = cfg_ColumnWidth.empty() ? NULL: strdup(cfg_ColumnWidth.c_str());
875	Char* pRowHeight = cfg_RowHeight.empty() ? NULL : strdup(cfg_RowHeight.c_str());
876	if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
877	{
878	char *columnWidth;
879	int i=0;
880	m_pColumnWidth = new UInt[m_iNumColumnsMinus1];
881	columnWidth = strtok(pColumnWidth, " ,-");
882	while(columnWidth!=NULL)
883	{
884	if( i>=m_iNumColumnsMinus1 )
885	{
886	printf( "The number of columns whose width are defined is larger than the allowed number of columns.\n" );
887	exit( EXIT_FAILURE );
888	}
889	*( m_pColumnWidth + i ) = atoi( columnWidth );
890	columnWidth = strtok(NULL, " ,-");
891	i++;
892	}
893	if( i<m_iNumColumnsMinus1 )
894	{
895	printf( "The width of some columns is not defined.\n" );
896	exit( EXIT_FAILURE );
897	}
898	}
899	else
900	{
901	m_pColumnWidth = NULL;
902	}
903
904	if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
905	{
906	char *rowHeight;
907	int i=0;
908	m_pRowHeight = new UInt[m_iNumRowsMinus1];
909	rowHeight = strtok(pRowHeight, " ,-");
910	while(rowHeight!=NULL)
911	{
912	if( i>=m_iNumRowsMinus1 )
913	{
914	printf( "The number of rows whose height are defined is larger than the allowed number of rows.\n" );
915	exit( EXIT_FAILURE );
916	}
917	*( m_pRowHeight + i ) = atoi( rowHeight );
918	rowHeight = strtok(NULL, " ,-");
919	i++;
920	}
921	if( i<m_iNumRowsMinus1 )
922	{
923	printf( "The height of some rows is not defined.\n" );
924	exit( EXIT_FAILURE );
925	}
926	}
927	else
928	{
929	m_pRowHeight = NULL;
930	}
931	#if H_MV
932	free ( pColumnWidth );
933	free ( pRowHeight );
934	#endif
935	m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str());
936
937	/* rules for input, output and internal bitdepths as per help text */
938	if (!m_internalBitDepthY) { m_internalBitDepthY = m_inputBitDepthY; }
939	if (!m_internalBitDepthC) { m_internalBitDepthC = m_internalBitDepthY; }
940	if (!m_inputBitDepthC) { m_inputBitDepthC = m_inputBitDepthY; }
941	if (!m_outputBitDepthY) { m_outputBitDepthY = m_internalBitDepthY; }
942	if (!m_outputBitDepthC) { m_outputBitDepthC = m_internalBitDepthC; }
943
944	// TODO:ChromaFmt assumes 4:2:0 below
945	switch (m_conformanceMode)
946	{
947	case 0:
948	{
949	// no conformance or padding
950	m_confLeft = m_confRight = m_confTop = m_confBottom = 0;
951	m_aiPad[1] = m_aiPad[0] = 0;
952	break;
953	}
954	case 1:
955	{
956	// automatic padding to minimum CU size
957	Int minCuSize = m_uiMaxCUHeight >> (m_uiMaxCUDepth - 1);
958	if (m_iSourceWidth % minCuSize)
959	{
960	m_aiPad[0] = m_confRight = ((m_iSourceWidth / minCuSize) + 1) * minCuSize - m_iSourceWidth;
961	m_iSourceWidth += m_confRight;
962	}
963	if (m_iSourceHeight % minCuSize)
964	{
965	m_aiPad[1] = m_confBottom = ((m_iSourceHeight / minCuSize) + 1) * minCuSize - m_iSourceHeight;
966	m_iSourceHeight += m_confBottom;
967	if ( m_isField )
968	{
969	m_iSourceHeightOrg += m_confBottom << 1;
970	m_aiPad[1] = m_confBottom << 1;
971	}
972	}
973	if (m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0)
974	{
975	fprintf(stderr, "Error: picture width is not an integer multiple of the specified chroma subsampling\n");
976	exit(EXIT_FAILURE);
977	}
978	if (m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0)
979	{
980	fprintf(stderr, "Error: picture height is not an integer multiple of the specified chroma subsampling\n");
981	exit(EXIT_FAILURE);
982	}
983	break;
984	}
985	case 2:
986	{
987	//padding
988	m_iSourceWidth += m_aiPad[0];
989	m_iSourceHeight += m_aiPad[1];
990	m_confRight = m_aiPad[0];
991	m_confBottom = m_aiPad[1];
992	break;
993	}
994	case 3:
995	{
996	// conformance
997	if ((m_confLeft == 0) && (m_confRight == 0) && (m_confTop == 0) && (m_confBottom == 0))
998	{
999	fprintf(stderr, "Warning: Conformance window enabled, but all conformance window parameters set to zero\n");
1000	}
1001	if ((m_aiPad[1] != 0) \|\| (m_aiPad[0]!=0))
1002	{
1003	fprintf(stderr, "Warning: Conformance window enabled, padding parameters will be ignored\n");
1004	}
1005	m_aiPad[1] = m_aiPad[0] = 0;
1006	break;
1007	}
1008	}
1009
1010	// allocate slice-based dQP values
1011	#if H_MV
1012	xResizeVector( m_viewOrderIndex );
1013
1014	std::vector<Int> uniqueViewOrderIndices;
1015	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1016	{
1017	Bool isIn = false;
1018	for ( Int i = 0 ; i < uniqueViewOrderIndices.size(); i++ )
1019	{
1020	isIn = isIn \|\| ( m_viewOrderIndex[ layer ] == uniqueViewOrderIndices[ i ] );
1021	}
1022	if ( !isIn )
1023	{
1024	uniqueViewOrderIndices.push_back( m_viewOrderIndex[ layer ] );
1025	}
1026	}
1027	m_iNumberOfViews = (Int) uniqueViewOrderIndices.size();
1028
1029	#if H_3D
1030	xResizeVector( m_depthFlag );
1031	#endif
1032	xResizeVector( m_fQP );
1033
1034	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1035	{
1036	m_aidQP.push_back( new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ] );
1037	::memset( m_aidQP[layer], 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
1038
1039	// handling of floating-point QP values
1040	// if QP is not integer, sequence is split into two sections having QP and QP+1
1041	m_iQP.push_back((Int)( m_fQP[layer] ));
1042	if ( m_iQP[layer] < m_fQP[layer] )
1043	{
1044	Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP[layer] - m_iQP[layer])*m_framesToBeEncoded + 0.5 );
1045
1046	iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
1047	for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
1048	{
1049	m_aidQP[layer][i] = 1;
1050	}
1051	}
1052	}
1053
1054	xResizeVector( m_bLoopFilterDisable );
1055	xResizeVector( m_bUseSAO );
1056	xResizeVector( m_iIntraPeriod );
1057	xResizeVector( m_tilesInUseFlag );
1058	xResizeVector( m_loopFilterNotAcrossTilesFlag );
1059	xResizeVector( m_wppInUseFlag );
1060
1061	for (Int olsIdx = 0; olsIdx < m_vpsNumLayerSets + (Int) m_outputLayerSetIdx.size(); olsIdx++)
1062	{
1063	m_altOutputLayerFlag.push_back( false );
1064	}
1065	#else
1066	m_aidQP = new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ];
1067	::memset( m_aidQP, 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
1068
1069	// handling of floating-point QP values
1070	// if QP is not integer, sequence is split into two sections having QP and QP+1
1071	m_iQP = (Int)( m_fQP );
1072	if ( m_iQP < m_fQP )
1073	{
1074	Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP - m_iQP)*m_framesToBeEncoded + 0.5 );
1075
1076	iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
1077	for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
1078	{
1079	m_aidQP[i] = 1;
1080	}
1081	}
1082	#endif
1083
1084	// reading external dQP description from file
1085	if ( m_pchdQPFile )
1086	{
1087	FILE* fpt=fopen( m_pchdQPFile, "r" );
1088	if ( fpt )
1089	{
1090	#if H_MV
1091	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1092	{
1093	#endif
1094	Int iValue;
1095	Int iPOC = 0;
1096	while ( iPOC < m_framesToBeEncoded )
1097	{
1098	if ( fscanf(fpt, "%d", &iValue ) == EOF ) break;
1099	#if H_MV
1100	m_aidQP[layer][ iPOC ] = iValue;
1101	iPOC++;
1102	}
1103	#else
1104	m_aidQP[ iPOC ] = iValue;
1105	iPOC++;
1106	#endif
1107	}
1108	fclose(fpt);
1109	}
1110	}
1111	m_iWaveFrontSubstreams = m_iWaveFrontSynchro ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1;
1112
1113	if( m_toneMappingInfoSEIEnabled && !m_toneMapCancelFlag )
1114	{
1115	Char* pcStartOfCodedInterval = cfg_startOfCodedInterval.empty() ? NULL: strdup(cfg_startOfCodedInterval.c_str());
1116	Char* pcCodedPivotValue = cfg_codedPivotValue.empty() ? NULL: strdup(cfg_codedPivotValue.c_str());
1117	Char* pcTargetPivotValue = cfg_targetPivotValue.empty() ? NULL: strdup(cfg_targetPivotValue.c_str());
1118	if( m_toneMapModelId == 2 && pcStartOfCodedInterval )
1119	{
1120	char *startOfCodedInterval;
1121	UInt num = 1u<< m_toneMapTargetBitDepth;
1122	m_startOfCodedInterval = new Int[num];
1123	::memset( m_startOfCodedInterval, 0, sizeof(Int)*num );
1124	startOfCodedInterval = strtok(pcStartOfCodedInterval, " .");
1125	int i = 0;
1126	while( startOfCodedInterval && ( i < num ) )
1127	{
1128	m_startOfCodedInterval[i] = atoi( startOfCodedInterval );
1129	startOfCodedInterval = strtok(NULL, " .");
1130	i++;
1131	}
1132	}
1133	else
1134	{
1135	m_startOfCodedInterval = NULL;
1136	}
1137	if( ( m_toneMapModelId == 3 ) && ( m_numPivots > 0 ) )
1138	{
1139	if( pcCodedPivotValue && pcTargetPivotValue )
1140	{
1141	char *codedPivotValue;
1142	char *targetPivotValue;
1143	m_codedPivotValue = new Int[m_numPivots];
1144	m_targetPivotValue = new Int[m_numPivots];
1145	::memset( m_codedPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1146	::memset( m_targetPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1147	codedPivotValue = strtok(pcCodedPivotValue, " .");
1148	int i=0;
1149	while(codedPivotValue&&i<m_numPivots)
1150	{
1151	m_codedPivotValue[i] = atoi( codedPivotValue );
1152	codedPivotValue = strtok(NULL, " .");
1153	i++;
1154	}
1155	i=0;
1156	targetPivotValue = strtok(pcTargetPivotValue, " .");
1157	while(targetPivotValue&&i<m_numPivots)
1158	{
1159	m_targetPivotValue[i]= atoi( targetPivotValue );
1160	targetPivotValue = strtok(NULL, " .");
1161	i++;
1162	}
1163	}
1164	}
1165	else
1166	{
1167	m_codedPivotValue = NULL;
1168	m_targetPivotValue = NULL;
1169	}
1170	}
1171	#if H_3D
1172	// set global varibles
1173	xSetGlobal();
1174	#if H_3D_VSO
1175	// Table base optimization
1176	// Q&D
1177	Double adLambdaScaleTable[] =
1178	{ 0.031250, 0.031639, 0.032029, 0.032418, 0.032808, 0.033197, 0.033586, 0.033976, 0.034365, 0.034755,
1179	0.035144, 0.035533, 0.035923, 0.036312, 0.036702, 0.037091, 0.037480, 0.037870, 0.038259, 0.038648,
1180	0.039038, 0.039427, 0.039817, 0.040206, 0.040595, 0.040985, 0.041374, 0.041764, 0.042153, 0.042542,
1181	0.042932, 0.043321, 0.043711, 0.044100, 0.044194, 0.053033, 0.061872, 0.070711, 0.079550, 0.088388,
1182	0.117851, 0.147314, 0.176777, 0.235702, 0.294628, 0.353553, 0.471405, 0.589256, 0.707107, 0.707100,
1183	0.753550, 0.800000
1184	};
1185	if ( m_bUseVSO && m_bVSOLSTable )
1186	{
1187	Int firstDepthLayer = -1;
1188	for (Int layer = 0; layer < m_numberOfLayers; layer++ )
1189	{
1190	if ( m_depthFlag[ layer ])
1191	{
1192	firstDepthLayer = layer;
1193	break;
1194	}
1195	}
1196	AOT( firstDepthLayer == -1 );
1197	AOT( (m_iQP[firstDepthLayer] < 0) \|\| (m_iQP[firstDepthLayer] > 51));
1198	m_dLambdaScaleVSO *= adLambdaScaleTable[m_iQP[firstDepthLayer]];
1199	}
1200	#endif
1201	#if H_3D_VSO
1202	if ( m_bUseVSO && m_uiVSOMode == 4)
1203	{
1204	m_cRenModStrParser.setString( m_iNumberOfViews, m_pchVSOConfig );
1205	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1206	g_bitDepthY,
1207	(UInt)m_iCodedCamParPrecision,
1208	m_FrameSkip,
1209	(UInt)m_framesToBeEncoded,
1210	m_pchCameraParameterFile,
1211	m_pchBaseViewCameraNumbers,
1212	NULL,
1213	m_cRenModStrParser.getSynthViews(),
1214	LOG2_DISP_PREC_LUT );
1215	}
1216	else if ( m_bUseVSO && m_uiVSOMode != 4 )
1217	{
1218	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1219	g_bitDepthY,
1220	(UInt)m_iCodedCamParPrecision,
1221	m_FrameSkip,
1222	(UInt)m_framesToBeEncoded,
1223	m_pchCameraParameterFile,
1224	m_pchBaseViewCameraNumbers,
1225	m_pchVSOConfig,
1226	NULL,
1227	LOG2_DISP_PREC_LUT );
1228	}
1229	else
1230	{
1231	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1232	g_bitDepthY,
1233	(UInt) m_iCodedCamParPrecision,
1234	m_FrameSkip,
1235	(UInt) m_framesToBeEncoded,
1236	m_pchCameraParameterFile,
1237	m_pchBaseViewCameraNumbers,
1238	NULL,
1239	NULL,
1240	LOG2_DISP_PREC_LUT );
1241	}
1242	#else
1243	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1244	g_bitDepthY,
1245	(UInt) m_iCodedCamParPrecision,
1246	m_FrameSkip,
1247	(UInt) m_framesToBeEncoded,
1248	m_pchCameraParameterFile,
1249	m_pchBaseViewCameraNumbers,
1250	NULL,
1251	NULL,
1252	LOG2_DISP_PREC_LUT );
1253	#endif
1254	m_cCameraData.check( false, true );
1255	#endif
1256	// check validity of input parameters
1257	xCheckParameter();
1258
1259	#if !H_3D
1260	// set global varibles
1261	xSetGlobal();
1262	#endif
1263
1264	// print-out parameters
1265	xPrintParameter();
1266
1267	return true;
1268	}
1269	// ====================================================================================================================
1270	// Private member functions
1271	// ====================================================================================================================
1272
1273	Bool confirmPara(Bool bflag, const Char* message);
1274
1275	Void TAppEncCfg::xCheckParameter()
1276	{
1277	if (!m_decodedPictureHashSEIEnabled)
1278	{
1279	fprintf(stderr, "******************************************************************\n");
1280	fprintf(stderr, " WARNING: --SEIDecodedPictureHash is now disabled by default. \n");
1281	fprintf(stderr, " Automatic verification of decoded pictures by a \n");
1282	fprintf(stderr, " decoder requires this option to be enabled. \n");
1283	fprintf(stderr, "******************************************************************\n");
1284	}
1285	if( m_profile==Profile::NONE )
1286	{
1287	fprintf(stderr, "***************************************************************************\n");
1288	fprintf(stderr, " WARNING: For conforming bitstreams a valid Profile value must be set! \n");
1289	fprintf(stderr, "***************************************************************************\n");
1290	}
1291	if( m_level==Level::NONE )
1292	{
1293	fprintf(stderr, "***************************************************************************\n");
1294	fprintf(stderr, " WARNING: For conforming bitstreams a valid Level value must be set! \n");
1295	fprintf(stderr, "***************************************************************************\n");
1296	}
1297
1298	Bool check_failed = false; /* abort if there is a fatal configuration problem */
1299	#define xConfirmPara(a,b) check_failed \|= confirmPara(a,b)
1300	// check range of parameters
1301	xConfirmPara( m_inputBitDepthY < 8, "InputBitDepth must be at least 8" );
1302	xConfirmPara( m_inputBitDepthC < 8, "InputBitDepthC must be at least 8" );
1303	xConfirmPara( m_iFrameRate <= 0, "Frame rate must be more than 1" );
1304	xConfirmPara( m_framesToBeEncoded <= 0, "Total Number Of Frames encoded must be more than 0" );
1305	#if H_MV
1306	xConfirmPara( m_numberOfLayers > MAX_NUM_LAYER_IDS , "NumberOfLayers must be less than or equal to MAX_NUM_LAYER_IDS");
1307
1308
1309	xConfirmPara( m_layerIdInNuh[0] != 0 , "LayerIdInNuh must be 0 for the first layer. ");
1310	xConfirmPara( (m_layerIdInNuh.size()!=1) && (m_layerIdInNuh.size() < m_numberOfLayers) , "LayerIdInNuh must be given for all layers. ");
1311
1312	#if H_3D
1313	xConfirmPara( m_scalabilityMask != 2 && m_scalabilityMask != 3, "Scalability Mask must be equal to 2 or 3. ");
1314	#else
1315	xConfirmPara( m_scalabilityMask != 2 , "Scalability Mask must be equal to 2. ");
1316	#endif
1317
1318	#if H_3D
1319	if ( m_scalabilityMask & ( 1 << DEPTH_ID ) )
1320	{
1321	m_dimIds.push_back( m_depthFlag );
1322	}
1323	#endif
1324
1325	m_dimIds.push_back( m_viewOrderIndex );
1326	xConfirmPara( m_dimensionIdLen.size() < m_dimIds.size(), "DimensionIdLen must be given for all dimensions. " ); Int dimBitOffset[MAX_NUM_SCALABILITY_TYPES+1];
1327
1328	dimBitOffset[ 0 ] = 0;
1329	for (Int j = 1; j <= ((Int) m_dimIds.size() - m_splittingFlag ? 1 : 0); j++ )
1330	{
1331	dimBitOffset[ j ] = dimBitOffset[ j - 1 ] + m_dimensionIdLen[ j - 1];
1332	}
1333
1334	if ( m_splittingFlag )
1335	{
1336	dimBitOffset[ (Int) m_dimIds.size() ] = 6;
1337	}
1338
1339	for( Int j = 0; j < m_dimIds.size(); j++ )
1340	{
1341	xConfirmPara( m_dimIds[j].size() < m_numberOfLayers, "DimensionId must be given for all layers and all dimensions. ");
1342	xConfirmPara( (m_dimIds[j][0] != 0) , "DimensionId of layer 0 must be 0. " );
1343	xConfirmPara( m_dimensionIdLen[j] < 1 \|\| m_dimensionIdLen[j] > 8, "DimensionIdLen must be greater than 0 and less than 9 in all dimensions. " );
1344
1345
1346	for( Int i = 1; i < m_numberOfLayers; i++ )
1347	{
1348	xConfirmPara( ( m_dimIds[j][i] < 0 ) \|\| ( m_dimIds[j][i] > ( ( 1 << m_dimensionIdLen[j] ) - 1 ) ) , "DimensionId shall be in the range of 0 to 2^DimensionIdLen - 1. " );
1349	if ( m_splittingFlag )
1350	{
1351	Int layerIdInNuh = (m_layerIdInNuh.size()!=1) ? m_layerIdInNuh[i] : i;
1352	xConfirmPara( ( ( layerIdInNuh & ( (1 << dimBitOffset[ j + 1 ] ) - 1) ) >> dimBitOffset[ j ] ) != m_dimIds[j][ i ] , "When Splitting Flag is equal to 1 dimension ids shall match values derived from layer ids. ");
1353	}
1354	}
1355	}
1356
1357	for( Int i = 0; i < m_numberOfLayers; i++ )
1358	{
1359	for( Int j = 0; j < i; j++ )
1360	{
1361	Int numDiff = 0;
1362	Int lastDiff = -1;
1363	for( Int dim = 0; dim < m_dimIds.size(); dim++ )
1364	{
1365	if ( m_dimIds[dim][i] != m_dimIds[dim][j] )
1366	{
1367	numDiff ++;
1368	lastDiff = dim;
1369	}
1370	}
1371
1372	Bool allEqual = ( numDiff == 0 );
1373
1374	if ( allEqual )
1375	{
1376	printf( "\nError: Positions of Layers %d and %d are identical in scalability space\n", i, j);
1377	}
1378
1379	xConfirmPara( allEqual , "Each layer shall have a different position in scalability space." );
1380
1381	#if !H_3D_FCO
1382	if ( numDiff == 1 )
1383	{
1384	Bool inc = m_dimIds[ lastDiff ][ i ] > m_dimIds[ lastDiff ][ j ];
1385	Bool shallBeButIsNotIncreasing = ( !inc ) ;
1386	if ( shallBeButIsNotIncreasing )
1387	{
1388	printf( "\nError: Positions of Layers %d and %d is not increasing in dimension %d \n", i, j, lastDiff);
1389	}
1390	xConfirmPara( shallBeButIsNotIncreasing, "DimensionIds shall be increasing within one dimension. " );
1391	}
1392	#endif
1393	}
1394	}
1395
1396	/// ViewId
1397	xConfirmPara( m_viewId.size() != m_iNumberOfViews, "The number of ViewIds must be equal to the number of views." );
1398
1399	/// Layer sets
1400	xConfirmPara( m_vpsNumLayerSets < 0 \|\| m_vpsNumLayerSets > 1024, "VpsNumLayerSets must be greater than 0 and less than 1025. ") ;
1401	for( Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++ )
1402	{
1403	if (lsIdx == 0)
1404	{
1405	xConfirmPara( m_layerIdsInSets[lsIdx].size() != 1 \|\| m_layerIdsInSets[lsIdx][0] != 0 , "0-th layer shall only include layer 0. ");
1406	}
1407	for ( Int i = 0; i < m_layerIdsInSets[lsIdx].size(); i++ )
1408	{
1409	xConfirmPara( m_layerIdsInSets[lsIdx][i] < 0 \|\| m_layerIdsInSets[lsIdx].size() >= MAX_NUM_LAYER_IDS, "LayerIdsInSet must be greater than and less than MAX_NUM_LAYER_IDS" );
1410	}
1411	}
1412
1413	// Output layer sets
1414	xConfirmPara( m_outputLayerSetIdx.size() > 1024, "The number of output layer set indices must be less than 1025.") ;
1415	for (Int lsIdx = 0; lsIdx < m_outputLayerSetIdx.size(); lsIdx++)
1416	{
1417	Int refLayerSetIdx = m_outputLayerSetIdx[ lsIdx ];
1418	xConfirmPara( refLayerSetIdx < 0 \|\| refLayerSetIdx >= m_vpsNumLayerSets, "Output layer set idx must be greater or equal to 0 and less than the VpsNumLayerSets." );
1419
1420	for (Int i = 0; i < m_layerIdsInAddOutputLayerSet[ lsIdx ].size(); i++)
1421	{
1422	Bool isAlsoInLayerSet = false;
1423	for (Int j = 0; j < m_layerIdsInSets[ refLayerSetIdx ].size(); j++ )
1424	{
1425	if ( m_layerIdsInSets[ refLayerSetIdx ][ j ] == m_layerIdsInAddOutputLayerSet[ lsIdx ][ i ] )
1426	{
1427	isAlsoInLayerSet = true;
1428	break;
1429	}
1430	}
1431	xConfirmPara( !isAlsoInLayerSet, "All output layers of a output layer set be included in corresponding layer set.");
1432	}
1433	}
1434
1435	xConfirmPara( m_defaultOutputLayerIdc < 0 \|\| m_defaultOutputLayerIdc > 2, "Default target output layer idc must greater than or equal to 0 and less than or equal to 2." );
1436
1437	if( m_defaultOutputLayerIdc != 2 )
1438	{
1439	Bool anyDefaultOutputFlag = false;
1440	for (Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++)
1441	{
1442	anyDefaultOutputFlag = anyDefaultOutputFlag \|\| ( m_layerIdsInDefOutputLayerSet[lsIdx].size() != 0 );
1443	}
1444	printf( "\nWarning: Ignoring LayerIdsInDefOutputLayerSet parameters, since defaultTargetOuputLayerIdc is not equal 2.\n" );
1445	}
1446	else
1447	{
1448	for (Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++)
1449	{
1450	for (Int i = 0; i < m_layerIdsInDefOutputLayerSet[ lsIdx ].size(); i++)
1451	{
1452	Bool inLayerSetFlag = false;
1453	for (Int j = 0; j < m_layerIdsInSets[ lsIdx].size(); j++ )
1454	{
1455	if ( m_layerIdsInSets[ lsIdx ][ j ] == m_layerIdsInDefOutputLayerSet[ lsIdx ][ i ] )
1456	{
1457	inLayerSetFlag = true;
1458	break;
1459	}
1460	}
1461	xConfirmPara( !inLayerSetFlag, "All output layers of a output layer set must be included in corresponding layer set.");
1462	}
1463	}
1464	}
1465
1466	xConfirmPara( m_altOutputLayerFlag.size() < m_vpsNumLayerSets + m_outputLayerSetIdx.size(), "The number of Profile Level Tier indices must be equal to the number of layer set plus the number of output layer set indices" );
1467	xConfirmPara( m_profileLevelTierIdx.size() < m_vpsNumLayerSets + m_outputLayerSetIdx.size(), "The number of Profile Level Tier indices must be equal to the number of layer set plus the number of output layer set indices" );
1468
1469	// Layer Dependencies
1470	for (Int i = 0; i < m_numberOfLayers; i++ )
1471	{
1472	xConfirmPara( (i == 0) && m_directRefLayers[0].size() != 0, "Layer 0 shall not have reference layers." );
1473	xConfirmPara( m_directRefLayers[i].size() != m_dependencyTypes[ i ].size(), "Each reference layer shall have a reference type." );
1474	for (Int j = 0; j < m_directRefLayers[i].size(); j++)
1475	{
1476	xConfirmPara( m_directRefLayers[i][j] < 0 \|\| m_directRefLayers[i][j] >= i , "Reference layer id shall be greater than or equal to 0 and less than dependent layer id");
1477	xConfirmPara( m_dependencyTypes[i][j] < 0 \|\| m_dependencyTypes[i][j] > 2 , "Dependency type shall be greater than or equal to 0 and less than 3");
1478	}
1479	}
1480	#endif
1481	xConfirmPara( m_iGOPSize < 1 , "GOP Size must be greater or equal to 1" );
1482	xConfirmPara( m_iGOPSize > 1 && m_iGOPSize % 2, "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
1483	#if H_MV
1484	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1485	{
1486	xConfirmPara( (m_iIntraPeriod[layer] > 0 && m_iIntraPeriod[layer] < m_iGOPSize) \|\| m_iIntraPeriod[layer] == 0, "Intra period must be more than GOP size, or -1 , not 0" );
1487	}
1488	#else
1489	xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) \|\| m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
1490	#endif
1491	#if ALLOW_RECOVERY_POINT_AS_RAP
1492	xConfirmPara( m_iDecodingRefreshType < 0 \|\| m_iDecodingRefreshType > 3, "Decoding Refresh Type must be comprised between 0 and 3 included" );
1493	if(m_iDecodingRefreshType == 3)
1494	{
1495	xConfirmPara( !m_recoveryPointSEIEnabled, "When using RecoveryPointSEI messages as RA points, recoveryPointSEI must be enabled" );
1496	}
1497	#else
1498	xConfirmPara( m_iDecodingRefreshType < 0 \|\| m_iDecodingRefreshType > 2, "Decoding Refresh Type must be equal to 0, 1 or 2" );
1499	#endif
1500	#if H_MV
1501	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1502	{
1503	xConfirmPara( m_iQP[layer] < -6 * (m_internalBitDepthY - 8) \|\| m_iQP[layer] > 51, "QP exceeds supported range (-QpBDOffsety to 51)" );
1504	}
1505	#else
1506	xConfirmPara( m_iQP < -6 * (m_internalBitDepthY - 8) \|\| m_iQP > 51, "QP exceeds supported range (-QpBDOffsety to 51)" );
1507	#endif
1508	xConfirmPara( m_loopFilterBetaOffsetDiv2 < -6 \|\| m_loopFilterBetaOffsetDiv2 > 6, "Loop Filter Beta Offset div. 2 exceeds supported range (-6 to 6)");
1509	xConfirmPara( m_loopFilterTcOffsetDiv2 < -6 \|\| m_loopFilterTcOffsetDiv2 > 6, "Loop Filter Tc Offset div. 2 exceeds supported range (-6 to 6)");
1510	xConfirmPara( m_iFastSearch < 0 \|\| m_iFastSearch > 2, "Fast Search Mode is not supported value (0:Full search 1:Diamond 2:PMVFAST)" );
1511	xConfirmPara( m_iSearchRange < 0 , "Search Range must be more than 0" );
1512	xConfirmPara( m_bipredSearchRange < 0 , "Search Range must be more than 0" );
1513	xConfirmPara( m_iMaxDeltaQP > 7, "Absolute Delta QP exceeds supported range (0 to 7)" );
1514	xConfirmPara( m_iMaxCuDQPDepth > m_uiMaxCUDepth - 1, "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
1515
1516	xConfirmPara( m_cbQpOffset < -12, "Min. Chroma Cb QP Offset is -12" );
1517	xConfirmPara( m_cbQpOffset > 12, "Max. Chroma Cb QP Offset is 12" );
1518	xConfirmPara( m_crQpOffset < -12, "Min. Chroma Cr QP Offset is -12" );
1519	xConfirmPara( m_crQpOffset > 12, "Max. Chroma Cr QP Offset is 12" );
1520
1521	xConfirmPara( m_iQPAdaptationRange <= 0, "QP Adaptation Range must be more than 0" );
1522	if (m_iDecodingRefreshType == 2)
1523	{
1524	#if H_MV
1525	for (Int i = 0; i < m_numberOfLayers; i++ )
1526	{
1527	xConfirmPara( m_iIntraPeriod[i] > 0 && m_iIntraPeriod[i] <= m_iGOPSize , "Intra period must be larger than GOP size for periodic IDR pictures");
1528	}
1529	#else
1530	xConfirmPara( m_iIntraPeriod > 0 && m_iIntraPeriod <= m_iGOPSize , "Intra period must be larger than GOP size for periodic IDR pictures");
1531	#endif
1532	}
1533	xConfirmPara( (m_uiMaxCUWidth >> m_uiMaxCUDepth) < 4, "Minimum partition width size should be larger than or equal to 8");
1534	xConfirmPara( (m_uiMaxCUHeight >> m_uiMaxCUDepth) < 4, "Minimum partition height size should be larger than or equal to 8");
1535	xConfirmPara( m_uiMaxCUWidth < 16, "Maximum partition width size should be larger than or equal to 16");
1536	xConfirmPara( m_uiMaxCUHeight < 16, "Maximum partition height size should be larger than or equal to 16");
1537	xConfirmPara( (m_iSourceWidth % (m_uiMaxCUWidth >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame width must be a multiple of the minimum CU size");
1538	xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame height must be a multiple of the minimum CU size");
1539
1540	xConfirmPara( m_uiQuadtreeTULog2MinSize < 2, "QuadtreeTULog2MinSize must be 2 or greater.");
1541	xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5, "QuadtreeTULog2MaxSize must be 5 or smaller.");
1542	xConfirmPara( (1<<m_uiQuadtreeTULog2MaxSize) > m_uiMaxCUWidth, "QuadtreeTULog2MaxSize must be log2(maxCUSize) or smaller.");
1543
1544	xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize, "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize.");
1545	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1546	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUHeight>>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1547	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUWidth >> m_uiMaxCUDepth ), "Minimum CU width must be greater than minimum transform size." );
1548	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." );
1549	xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1, "QuadtreeTUMaxDepthInter must be greater than or equal to 1" );
1550	xConfirmPara( m_uiMaxCUWidth < ( 1 << (m_uiQuadtreeTULog2MinSize + m_uiQuadtreeTUMaxDepthInter - 1) ), "QuadtreeTUMaxDepthInter must be less than or equal to the difference between log2(maxCUSize) and QuadtreeTULog2MinSize plus 1" );
1551	xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1, "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" );
1552	xConfirmPara( m_uiMaxCUWidth < ( 1 << (m_uiQuadtreeTULog2MinSize + m_uiQuadtreeTUMaxDepthIntra - 1) ), "QuadtreeTUMaxDepthInter must be less than or equal to the difference between log2(maxCUSize) and QuadtreeTULog2MinSize plus 1" );
1553
1554	xConfirmPara( m_maxNumMergeCand < 1, "MaxNumMergeCand must be 1 or greater.");
1555	xConfirmPara( m_maxNumMergeCand > 5, "MaxNumMergeCand must be 5 or smaller.");
1556
1557	#if H_3D_ARP
1558	xConfirmPara( ( 0 != m_uiUseAdvResPred ) && ( 1 != m_uiUseAdvResPred ), "UseAdvResPred must be 0 or 1." );
1559	#endif
1560	#if H_3D_SPIVMP
1561	xConfirmPara( m_iSubPULog2Size < 3, "SubPULog2Size must be 3 or greater.");
1562	xConfirmPara( m_iSubPULog2Size > 6, "SubPULog2Size must be 6 or smaller.");
1563	xConfirmPara( (1<<m_iSubPULog2Size) > m_uiMaxCUWidth, "SubPULog2Size must be log2(maxCUSize) or smaller.");
1564
1565	xConfirmPara( m_iSubPUMPILog2Size < 3, "SubPUMPILog2Size must be 3 or greater.");
1566	xConfirmPara( m_iSubPUMPILog2Size > 6, "SubPUMPILog2Size must be 6 or smaller.");
1567	xConfirmPara( ( 1 << m_iSubPUMPILog2Size ) > m_uiMaxCUWidth, "SubPUMPILog2Size must be log2(maxCUSize) or smaller.");
1568	#endif
1569	#if ADAPTIVE_QP_SELECTION
1570	#if H_MV
1571	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1572	{
1573	xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP[layer] < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
1574	}
1575	#else
1576	xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
1577	#endif
1578	xConfirmPara( m_bUseAdaptQpSelect == true && (m_cbQpOffset !=0 \|\| m_crQpOffset != 0 ), "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
1579	#endif
1580
1581	if( m_usePCM)
1582	{
1583	xConfirmPara( m_uiPCMLog2MinSize < 3, "PCMLog2MinSize must be 3 or greater.");
1584	xConfirmPara( m_uiPCMLog2MinSize > 5, "PCMLog2MinSize must be 5 or smaller.");
1585	xConfirmPara( m_pcmLog2MaxSize > 5, "PCMLog2MaxSize must be 5 or smaller.");
1586	xConfirmPara( m_pcmLog2MaxSize < m_uiPCMLog2MinSize, "PCMLog2MaxSize must be equal to or greater than m_uiPCMLog2MinSize.");
1587	}
1588
1589	xConfirmPara( m_sliceMode < 0 \|\| m_sliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
1590	if (m_sliceMode!=0)
1591	{
1592	xConfirmPara( m_sliceArgument < 1 , "SliceArgument should be larger than or equal to 1" );
1593	}
1594	xConfirmPara( m_sliceSegmentMode < 0 \|\| m_sliceSegmentMode > 3, "SliceSegmentMode exceeds supported range (0 to 3)" );
1595	if (m_sliceSegmentMode!=0)
1596	{
1597	xConfirmPara( m_sliceSegmentArgument < 1 , "SliceSegmentArgument should be larger than or equal to 1" );
1598	}
1599
1600	Bool tileFlag = (m_iNumColumnsMinus1 > 0 \|\| m_iNumRowsMinus1 > 0 );
1601	xConfirmPara( tileFlag && m_iWaveFrontSynchro, "Tile and Wavefront can not be applied together");
1602
1603	//TODO:ChromaFmt assumes 4:2:0 below
1604	xConfirmPara( m_iSourceWidth % TComSPS::getWinUnitX(CHROMA_420) != 0, "Picture width must be an integer multiple of the specified chroma subsampling");
1605	xConfirmPara( m_iSourceHeight % TComSPS::getWinUnitY(CHROMA_420) != 0, "Picture height must be an integer multiple of the specified chroma subsampling");
1606
1607	xConfirmPara( m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0, "Horizontal padding must be an integer multiple of the specified chroma subsampling");
1608	xConfirmPara( m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0, "Vertical padding must be an integer multiple of the specified chroma subsampling");
1609
1610	xConfirmPara( m_confLeft % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left conformance window offset must be an integer multiple of the specified chroma subsampling");
1611	xConfirmPara( m_confRight % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right conformance window offset must be an integer multiple of the specified chroma subsampling");
1612	xConfirmPara( m_confTop % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top conformance window offset must be an integer multiple of the specified chroma subsampling");
1613	xConfirmPara( m_confBottom % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom conformance window offset must be an integer multiple of the specified chroma subsampling");
1614
1615	#if H_3D
1616	xConfirmPara( m_pchCameraParameterFile == 0 , "CameraParameterFile must be given");
1617	xConfirmPara( m_pchBaseViewCameraNumbers == 0 , "BaseViewCameraNumbers must be given" );
1618	#if BUG_FIX_TK65
1619	xConfirmPara( ( ((UInt) m_numberOfLayers >> 1 ) != m_cCameraData.getBaseViewNumbers().size() ) && ( m_numberOfLayers != m_cCameraData.getBaseViewNumbers().size() ), "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
1620	#else
1621	xConfirmPara( ((UInt) m_numberOfLayers >> 1 ) != m_cCameraData.getBaseViewNumbers().size(), "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
1622	#endif
1623	xConfirmPara ( m_iCodedCamParPrecision < 0 \|\| m_iCodedCamParPrecision > 5, "CodedCamParsPrecision must be in range of 0..5" );
1624	#if H_3D_VSO
1625	if( m_bUseVSO )
1626	{
1627	xConfirmPara( m_pchVSOConfig == 0 , "VSO Setup string must be given");
1628	xConfirmPara( m_uiVSOMode > 4 , "VSO Mode must be less than 5");
1629	}
1630	#endif
1631	#endif
1632	// max CU width and height should be power of 2
1633	UInt ui = m_uiMaxCUWidth;
1634	while(ui)
1635	{
1636	ui >>= 1;
1637	if( (ui & 1) == 1)
1638	xConfirmPara( ui != 1 , "Width should be 2^n");
1639	}
1640	ui = m_uiMaxCUHeight;
1641	while(ui)
1642	{
1643	ui >>= 1;
1644	if( (ui & 1) == 1)
1645	xConfirmPara( ui != 1 , "Height should be 2^n");
1646	}
1647
1648	#if H_MV
1649	// validate that POC of same frame is identical across multiple layers
1650	Bool bErrorMvePoc = false;
1651	if( m_numberOfLayers > 1 )
1652	{
1653	for( Int k = 1; k < m_numberOfLayers; k++ )
1654	{
1655	for( Int i = 0; i < MAX_GOP; i++ )
1656	{
1657	if( m_GOPListMvc[k][i].m_POC != m_GOPListMvc[0][i].m_POC )
1658	{
1659	printf( "\nError: Frame%d_l%d POC %d is not identical to Frame%d POC\n", i, k, m_GOPListMvc[k][i].m_POC, i );
1660	bErrorMvePoc = true;
1661	}
1662	}
1663	}
1664	}
1665	xConfirmPara( bErrorMvePoc, "Invalid inter-layer POC structure given" );
1666
1667	// validate that baseview has no inter-view refs
1668	Bool bErrorIvpBase = false;
1669	for( Int i = 0; i < MAX_GOP; i++ )
1670	{
1671	if( m_GOPListMvc[0][i].m_numActiveRefLayerPics != 0 )
1672	{
1673	printf( "\nError: Frame%d inter_layer refs not available in layer 0\n", i );
1674	bErrorIvpBase = true;
1675	}
1676	}
1677	xConfirmPara( bErrorIvpBase, "Inter-layer refs not possible in base layer" );
1678
1679	// validate inter-view refs
1680	Bool bErrorIvpEnhV = false;
1681	if( m_numberOfLayers > 1 )
1682	{
1683	for( Int layer = 1; layer < m_numberOfLayers; layer++ )
1684	{
1685	for( Int i = 0; i < MAX_GOP+1; i++ )
1686	{
1687	GOPEntry gopEntry = m_GOPListMvc[layer][i];
1688	for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1689	{
1690	Int ilPredLayerIdc = gopEntry.m_interLayerPredLayerIdc[j];
1691	if( ilPredLayerIdc < 0 \|\| ilPredLayerIdc >= m_directRefLayers[layer].size() )
1692	{
1693	printf( "\nError: inter-layer ref idc %d is not available for Frame%d_l%d\n", gopEntry.m_interLayerPredLayerIdc[j], i, layer );
1694	bErrorIvpEnhV = true;
1695	}
1696	if( gopEntry.m_interViewRefPosL[0][j] < -1 \|\| gopEntry.m_interViewRefPosL[0][j] > gopEntry.m_numRefPicsActive )
1697	{
1698	printf( "\nError: inter-layer ref pos %d on L0 is not available for Frame%d_l%d\n", gopEntry.m_interViewRefPosL[0][j], i, layer );
1699	bErrorIvpEnhV = true;
1700	}
1701	if( gopEntry.m_interViewRefPosL[1][j] < -1 \|\| gopEntry.m_interViewRefPosL[1][j] > gopEntry.m_numRefPicsActive )
1702	{
1703	printf( "\nError: inter-layer ref pos %d on L1 is not available for Frame%d_l%d\n", gopEntry.m_interViewRefPosL[1][j], i, layer );
1704	bErrorIvpEnhV = true;
1705	}
1706	}
1707	if( i == MAX_GOP ) // inter-view refs at I pic position in base view
1708	{
1709	if( gopEntry.m_sliceType != 'B' && gopEntry.m_sliceType != 'P' && gopEntry.m_sliceType != 'I' )
1710	{
1711	printf( "\nError: slice type of FrameI_l%d must be equal to B or P or I\n", layer );
1712	bErrorIvpEnhV = true;
1713	}
1714
1715	if( gopEntry.m_POC != 0 )
1716	{
1717	printf( "\nError: POC %d not possible for FrameI_l%d, must be 0\n", gopEntry.m_POC, layer );
1718	bErrorIvpEnhV = true;
1719	}
1720
1721	if( gopEntry.m_temporalId != 0 )
1722	{
1723	printf( "\nWarning: Temporal id of FrameI_l%d must be 0 (cp. I-frame in base layer)\n", layer );
1724	gopEntry.m_temporalId = 0;
1725	}
1726
1727	if( gopEntry.m_numRefPics != 0 )
1728	{
1729	printf( "\nWarning: temporal references not possible for FrameI_l%d\n", layer );
1730	for( Int j = 0; j < m_GOPListMvc[layer][MAX_GOP].m_numRefPics; j++ )
1731	{
1732	gopEntry.m_referencePics[j] = 0;
1733	}
1734	gopEntry.m_numRefPics = 0;
1735	}
1736
1737	if( gopEntry.m_interRPSPrediction )
1738	{
1739	printf( "\nError: inter RPS prediction not possible for FrameI_l%d, must be 0\n", layer );
1740	bErrorIvpEnhV = true;
1741	}
1742
1743	if( gopEntry.m_sliceType == 'I' && gopEntry.m_numActiveRefLayerPics != 0 )
1744	{
1745	printf( "\nError: inter-layer prediction not possible for FrameI_l%d with slice type I, #IL_ref_pics must be 0\n", layer );
1746	bErrorIvpEnhV = true;
1747	}
1748
1749	if( gopEntry.m_numRefPicsActive > gopEntry.m_numActiveRefLayerPics )
1750	{
1751	gopEntry.m_numRefPicsActive = gopEntry.m_numActiveRefLayerPics;
1752	}
1753
1754	if( gopEntry.m_sliceType == 'P' )
1755	{
1756	if( gopEntry.m_numActiveRefLayerPics < 1 )
1757	{
1758	printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type P\n", layer );
1759	bErrorIvpEnhV = true;
1760	}
1761	else
1762	{
1763	for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1764	{
1765	if( gopEntry.m_interViewRefPosL[1][j] != -1 )
1766	{
1767	printf( "\nError: inter-layer ref pos %d on L1 not possible for FrameI_l%d with slice type P\n", gopEntry.m_interViewRefPosL[1][j], layer );
1768	bErrorIvpEnhV = true;
1769	}
1770	}
1771	}
1772	}
1773
1774	if( gopEntry.m_sliceType == 'B' && gopEntry.m_numActiveRefLayerPics < 1 )
1775	{
1776	printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type B\n", layer );
1777	bErrorIvpEnhV = true;
1778	}
1779	}
1780	}
1781	}
1782	}
1783	xConfirmPara( bErrorIvpEnhV, "Invalid inter-layer coding structure for enhancement layers given" );
1784
1785	// validate temporal coding structure
1786	if( !bErrorMvePoc && !bErrorIvpBase && !bErrorIvpEnhV )
1787	{
1788	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1789	{
1790	GOPEntry* m_GOPList = m_GOPListMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1791	Int& m_extraRPSs = m_extraRPSsMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1792	Int& m_maxTempLayer = m_maxTempLayerMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1793	Int* m_maxDecPicBuffering = m_maxDecPicBufferingMvc[layer]; // It is not a member, but this name helps avoiding code duplication !!!
1794	Int* m_numReorderPics = m_numReorderPicsMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1795	#endif
1796	/* if this is an intra-only sequence, ie IntraPeriod=1, don't verify the GOP structure
1797	* This permits the ability to omit a GOP structure specification */
1798	#if H_MV
1799	if (m_iIntraPeriod[layer] == 1 && m_GOPList[0].m_POC == -1) {
1800	#else
1801	if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
1802	#endif
1803	m_GOPList[0] = GOPEntry();
1804	m_GOPList[0].m_QPFactor = 1;
1805	m_GOPList[0].m_betaOffsetDiv2 = 0;
1806	m_GOPList[0].m_tcOffsetDiv2 = 0;
1807	m_GOPList[0].m_POC = 1;
1808	m_GOPList[0].m_numRefPicsActive = 4;
1809	}
1810
1811	Bool verifiedGOP=false;
1812	Bool errorGOP=false;
1813	Int checkGOP=1;
1814	Int numRefs = m_isField ? 2 : 1;
1815	Int refList[MAX_NUM_REF_PICS+1];
1816	refList[0]=0;
1817	if(m_isField)
1818	{
1819	refList[1] = 1;
1820	}
1821	Bool isOK[MAX_GOP];
1822	for(Int i=0; i<MAX_GOP; i++)
1823	{
1824	isOK[i]=false;
1825	}
1826	Int numOK=0;
1827	#if H_MV
1828	xConfirmPara( m_iIntraPeriod[layer] >=0&&(m_iIntraPeriod[layer]%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
1829	#else
1830	xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
1831	#endif
1832
1833	for(Int i=0; i<m_iGOPSize; i++)
1834	{
1835	if(m_GOPList[i].m_POC==m_iGOPSize)
1836	{
1837	xConfirmPara( m_GOPList[i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
1838	}
1839	}
1840
1841	#if H_MV
1842	if ( (m_iIntraPeriod[layer] != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable[layer]) )
1843	#else
1844	if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
1845	#endif
1846	{
1847	for(Int i=0; i<m_iGOPSize; i++)
1848	{
1849	xConfirmPara( (m_GOPList[i].m_betaOffsetDiv2 + m_loopFilterBetaOffsetDiv2) < -6 \|\| (m_GOPList[i].m_betaOffsetDiv2 + m_loopFilterBetaOffsetDiv2) > 6, "Loop Filter Beta Offset div. 2 for one of the GOP entries exceeds supported range (-6 to 6)" );
1850	xConfirmPara( (m_GOPList[i].m_tcOffsetDiv2 + m_loopFilterTcOffsetDiv2) < -6 \|\| (m_GOPList[i].m_tcOffsetDiv2 + m_loopFilterTcOffsetDiv2) > 6, "Loop Filter Tc Offset div. 2 for one of the GOP entries exceeds supported range (-6 to 6)" );
1851	}
1852	}
1853	m_extraRPSs=0;
1854	//start looping through frames in coding order until we can verify that the GOP structure is correct.
1855	while(!verifiedGOP&&!errorGOP)
1856	{
1857	Int curGOP = (checkGOP-1)%m_iGOPSize;
1858	Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC;
1859	if(m_GOPList[curGOP].m_POC<0)
1860	{
1861	#if H_MV
1862	printf("\nError: found fewer Reference Picture Sets than GOPSize for layer %d\n", layer );
1863	#else
1864	printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
1865	#endif
1866	errorGOP=true;
1867	}
1868	else
1869	{
1870	//check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
1871	Bool beforeI = false;
1872	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
1873	{
1874	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1875	if(absPOC < 0)
1876	{
1877	beforeI=true;
1878	}
1879	else
1880	{
1881	Bool found=false;
1882	for(Int j=0; j<numRefs; j++)
1883	{
1884	if(refList[j]==absPOC)
1885	{
1886	found=true;
1887	for(Int k=0; k<m_iGOPSize; k++)
1888	{
1889	if(absPOC%m_iGOPSize == m_GOPList[k].m_POC%m_iGOPSize)
1890	{
1891	if(m_GOPList[k].m_temporalId==m_GOPList[curGOP].m_temporalId)
1892	{
1893	m_GOPList[k].m_refPic = true;
1894	}
1895	m_GOPList[curGOP].m_usedByCurrPic[i]=m_GOPList[k].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1896	}
1897	}
1898	}
1899	}
1900	if(!found)
1901	{
1902	#if H_MV
1903	printf("\nError: ref pic %d is not available for GOP frame %d of layer %d\n", m_GOPList[curGOP].m_referencePics[i], curGOP+1, layer);
1904	#else
1905	printf("\nError: ref pic %d is not available for GOP frame %d\n",m_GOPList[curGOP].m_referencePics[i],curGOP+1);
1906	#endif
1907	errorGOP=true;
1908	}
1909	}
1910	}
1911	if(!beforeI&&!errorGOP)
1912	{
1913	//all ref frames were present
1914	if(!isOK[curGOP])
1915	{
1916	numOK++;
1917	isOK[curGOP]=true;
1918	if(numOK==m_iGOPSize)
1919	{
1920	verifiedGOP=true;
1921	}
1922	}
1923	}
1924	else
1925	{
1926	//create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
1927	m_GOPList[m_iGOPSize+m_extraRPSs]=m_GOPList[curGOP];
1928	Int newRefs=0;
1929	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
1930	{
1931	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1932	if(absPOC>=0)
1933	{
1934	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
1935	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
1936	newRefs++;
1937	}
1938	}
1939	Int numPrefRefs = m_GOPList[curGOP].m_numRefPicsActive;
1940
1941	for(Int offset = -1; offset>-checkGOP; offset--)
1942	{
1943	//step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
1944	Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
1945	Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_GOPList[offGOP].m_POC;
1946	if(offPOC>=0&&m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId)
1947	{
1948	Bool newRef=false;
1949	for(Int i=0; i<numRefs; i++)
1950	{
1951	if(refList[i]==offPOC)
1952	{
1953	newRef=true;
1954	}
1955	}
1956	for(Int i=0; i<newRefs; i++)
1957	{
1958	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[i]==offPOC-curPOC)
1959	{
1960	newRef=false;
1961	}
1962	}
1963	if(newRef)
1964	{
1965	Int insertPoint=newRefs;
1966	//this picture can be added, find appropriate place in list and insert it.
1967	if(m_GOPList[offGOP].m_temporalId==m_GOPList[curGOP].m_temporalId)
1968	{
1969	m_GOPList[offGOP].m_refPic = true;
1970	}
1971	for(Int j=0; j<newRefs; j++)
1972	{
1973	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]<offPOC-curPOC\|\|m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]>0)
1974	{
1975	insertPoint = j;
1976	break;
1977	}
1978	}
1979	Int prev = offPOC-curPOC;
1980	Int prevUsed = m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1981	for(Int j=insertPoint; j<newRefs+1; j++)
1982	{
1983	Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j];
1984	Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j];
1985	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]=prev;
1986	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j]=prevUsed;
1987	prevUsed=newUsed;
1988	prev=newPrev;
1989	}
1990	newRefs++;
1991	}
1992	}
1993	if(newRefs>=numPrefRefs)
1994	{
1995	break;
1996	}
1997	}
1998	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics=newRefs;
1999	m_GOPList[m_iGOPSize+m_extraRPSs].m_POC = curPOC;
2000	if (m_extraRPSs == 0)
2001	{
2002	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 0;
2003	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = 0;
2004	}
2005	else
2006	{
2007	Int rIdx = m_iGOPSize + m_extraRPSs - 1;
2008	Int refPOC = m_GOPList[rIdx].m_POC;
2009	Int refPics = m_GOPList[rIdx].m_numRefPics;
2010	Int newIdc=0;
2011	for(Int i = 0; i<= refPics; i++)
2012	{
2013	Int deltaPOC = ((i != refPics)? m_GOPList[rIdx].m_referencePics[i] : 0); // check if the reference abs POC is >= 0
2014	Int absPOCref = refPOC+deltaPOC;
2015	Int refIdc = 0;
2016	for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics; j++)
2017	{
2018	if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j])
2019	{
2020	if (m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j])
2021	{
2022	refIdc = 1;
2023	}
2024	else
2025	{
2026	refIdc = 2;
2027	}
2028	}
2029	}
2030	m_GOPList[m_iGOPSize+m_extraRPSs].m_refIdc[newIdc]=refIdc;
2031	newIdc++;
2032	}
2033	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1;
2034	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = newIdc;
2035	m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC;
2036	}
2037	curGOP=m_iGOPSize+m_extraRPSs;
2038	m_extraRPSs++;
2039	}
2040	numRefs=0;
2041	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
2042	{
2043	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
2044	if(absPOC >= 0)
2045	{
2046	refList[numRefs]=absPOC;
2047	numRefs++;
2048	}
2049	}
2050	refList[numRefs]=curPOC;
2051	numRefs++;
2052	}
2053	checkGOP++;
2054	}
2055	xConfirmPara(errorGOP,"Invalid GOP structure given");
2056	m_maxTempLayer = 1;
2057	for(Int i=0; i<m_iGOPSize; i++)
2058	{
2059	if(m_GOPList[i].m_temporalId >= m_maxTempLayer)
2060	{
2061	m_maxTempLayer = m_GOPList[i].m_temporalId+1;
2062	}
2063	xConfirmPara(m_GOPList[i].m_sliceType!='B'&&m_GOPList[i].m_sliceType!='P'&&m_GOPList[i].m_sliceType!='I', "Slice type must be equal to B or P or I");
2064	}
2065	for(Int i=0; i<MAX_TLAYER; i++)
2066	{
2067	m_numReorderPics[i] = 0;
2068	m_maxDecPicBuffering[i] = 1;
2069	}
2070	for(Int i=0; i<m_iGOPSize; i++)
2071	{
2072	if(m_GOPList[i].m_numRefPics+1 > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
2073	{
2074	m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1;
2075	}
2076	Int highestDecodingNumberWithLowerPOC = 0;
2077	for(Int j=0; j<m_iGOPSize; j++)
2078	{
2079	if(m_GOPList[j].m_POC <= m_GOPList[i].m_POC)
2080	{
2081	highestDecodingNumberWithLowerPOC = j;
2082	}
2083	}
2084	Int numReorder = 0;
2085	for(Int j=0; j<highestDecodingNumberWithLowerPOC; j++)
2086	{
2087	if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId &&
2088	m_GOPList[j].m_POC > m_GOPList[i].m_POC)
2089	{
2090	numReorder++;
2091	}
2092	}
2093	if(numReorder > m_numReorderPics[m_GOPList[i].m_temporalId])
2094	{
2095	m_numReorderPics[m_GOPList[i].m_temporalId] = numReorder;
2096	}
2097	}
2098	for(Int i=0; i<MAX_TLAYER-1; i++)
2099	{
2100	// a lower layer can not have higher value of m_numReorderPics than a higher layer
2101	if(m_numReorderPics[i+1] < m_numReorderPics[i])
2102	{
2103	m_numReorderPics[i+1] = m_numReorderPics[i];
2104	}
2105	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
2106	if(m_numReorderPics[i] > m_maxDecPicBuffering[i] - 1)
2107	{
2108	m_maxDecPicBuffering[i] = m_numReorderPics[i] + 1;
2109	}
2110	// a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
2111	if(m_maxDecPicBuffering[i+1] < m_maxDecPicBuffering[i])
2112	{
2113	m_maxDecPicBuffering[i+1] = m_maxDecPicBuffering[i];
2114	}
2115	}
2116
2117
2118	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
2119	if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1)
2120	{
2121	m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1] + 1;
2122	}
2123
2124	if(m_vuiParametersPresentFlag && m_bitstreamRestrictionFlag)
2125	{
2126	Int PicSizeInSamplesY = m_iSourceWidth * m_iSourceHeight;
2127	if(tileFlag)
2128	{
2129	Int maxTileWidth = 0;
2130	Int maxTileHeight = 0;
2131	Int widthInCU = (m_iSourceWidth % m_uiMaxCUWidth) ? m_iSourceWidth/m_uiMaxCUWidth + 1: m_iSourceWidth/m_uiMaxCUWidth;
2132	Int heightInCU = (m_iSourceHeight % m_uiMaxCUHeight) ? m_iSourceHeight/m_uiMaxCUHeight + 1: m_iSourceHeight/m_uiMaxCUHeight;
2133	if(m_iUniformSpacingIdr)
2134	{
2135	maxTileWidth = m_uiMaxCUWidth*((widthInCU+m_iNumColumnsMinus1)/(m_iNumColumnsMinus1+1));
2136	maxTileHeight = m_uiMaxCUHeight*((heightInCU+m_iNumRowsMinus1)/(m_iNumRowsMinus1+1));
2137	// if only the last tile-row is one treeblock higher than the others
2138	// the maxTileHeight becomes smaller if the last row of treeblocks has lower height than the others
2139	if(!((heightInCU-1)%(m_iNumRowsMinus1+1)))
2140	{
2141	maxTileHeight = maxTileHeight - m_uiMaxCUHeight + (m_iSourceHeight % m_uiMaxCUHeight);
2142	}
2143	// if only the last tile-column is one treeblock wider than the others
2144	// the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others
2145	if(!((widthInCU-1)%(m_iNumColumnsMinus1+1)))
2146	{
2147	maxTileWidth = maxTileWidth - m_uiMaxCUWidth + (m_iSourceWidth % m_uiMaxCUWidth);
2148	}
2149	}
2150	else // not uniform spacing
2151	{
2152	if(m_iNumColumnsMinus1<1)
2153	{
2154	maxTileWidth = m_iSourceWidth;
2155	}
2156	else
2157	{
2158	Int accColumnWidth = 0;
2159	for(Int col=0; col<(m_iNumColumnsMinus1); col++)
2160	{
2161	maxTileWidth = m_pColumnWidth[col]>maxTileWidth ? m_pColumnWidth[col]:maxTileWidth;
2162	accColumnWidth += m_pColumnWidth[col];
2163	}
2164	maxTileWidth = (widthInCU-accColumnWidth)>maxTileWidth ? m_uiMaxCUWidth(widthInCU-accColumnWidth):m_uiMaxCUWidthmaxTileWidth;
2165	}
2166	if(m_iNumRowsMinus1<1)
2167	{
2168	maxTileHeight = m_iSourceHeight;
2169	}
2170	else
2171	{
2172	Int accRowHeight = 0;
2173	for(Int row=0; row<(m_iNumRowsMinus1); row++)
2174	{
2175	maxTileHeight = m_pRowHeight[row]>maxTileHeight ? m_pRowHeight[row]:maxTileHeight;
2176	accRowHeight += m_pRowHeight[row];
2177	}
2178	maxTileHeight = (heightInCU-accRowHeight)>maxTileHeight ? m_uiMaxCUHeight(heightInCU-accRowHeight):m_uiMaxCUHeightmaxTileHeight;
2179	}
2180	}
2181	Int maxSizeInSamplesY = maxTileWidth*maxTileHeight;
2182	m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/maxSizeInSamplesY-4;
2183	}
2184	else if(m_iWaveFrontSynchro)
2185	{
2186	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/((2m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4;
2187	}
2188	else if(m_sliceMode == 1)
2189	{
2190	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/(m_sliceArgumentm_uiMaxCUWidth*m_uiMaxCUHeight)-4;
2191	}
2192	else
2193	{
2194	m_minSpatialSegmentationIdc = 0;
2195	}
2196	}
2197	xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
2198	xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
2199	xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
2200
2201	xConfirmPara( m_decodedPictureHashSEIEnabled<0 \|\| m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n");
2202
2203	if (m_toneMappingInfoSEIEnabled)
2204	{
2205	xConfirmPara( m_toneMapCodedDataBitDepth < 8 \|\| m_toneMapCodedDataBitDepth > 14 , "SEIToneMapCodedDataBitDepth must be in rage 8 to 14");
2206	xConfirmPara( m_toneMapTargetBitDepth < 1 \|\| (m_toneMapTargetBitDepth > 16 && m_toneMapTargetBitDepth < 255) , "SEIToneMapTargetBitDepth must be in rage 1 to 16 or equal to 255");
2207	xConfirmPara( m_toneMapModelId < 0 \|\| m_toneMapModelId > 4 , "SEIToneMapModelId must be in rage 0 to 4");
2208	xConfirmPara( m_cameraIsoSpeedValue == 0, "SEIToneMapCameraIsoSpeedValue shall not be equal to 0");
2209	xConfirmPara( m_exposureIndexValue == 0, "SEIToneMapExposureIndexValue shall not be equal to 0");
2210	xConfirmPara( m_extendedRangeWhiteLevel < 100, "SEIToneMapExtendedRangeWhiteLevel should be greater than or equal to 100");
2211	xConfirmPara( m_nominalBlackLevelLumaCodeValue >= m_nominalWhiteLevelLumaCodeValue, "SEIToneMapNominalWhiteLevelLumaCodeValue shall be greater than SEIToneMapNominalBlackLevelLumaCodeValue");
2212	xConfirmPara( m_extendedWhiteLevelLumaCodeValue < m_nominalWhiteLevelLumaCodeValue, "SEIToneMapExtendedWhiteLevelLumaCodeValue shall be greater than or equal to SEIToneMapNominalWhiteLevelLumaCodeValue");
2213	}
2214
2215	if ( m_RCEnableRateControl )
2216	{
2217	if ( m_RCForceIntraQP )
2218	{
2219	if ( m_RCInitialQP == 0 )
2220	{
2221	printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
2222	m_RCForceIntraQP = false;
2223	}
2224	}
2225	xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
2226	}
2227	#if H_MV
2228	// VPS VUI
2229	for(Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++ )
2230	{
2231	for (Int j = 0; j < MAX_TLAYER; j++)
2232	{
2233	if ( j < m_avgBitRate [i].size() ) xConfirmPara( m_avgBitRate[i][j] < 0 \|\| m_avgBitRate[i][j] > 65535, "avg_bit_rate must be more than or equal to 0 and less than 65536" );
2234	if ( j < m_maxBitRate [i].size() ) xConfirmPara( m_maxBitRate[i][j] < 0 \|\| m_maxBitRate[i][j] > 65535, "max_bit_rate must be more than or equal to 0 and less than 65536" );
2235	if ( j < m_constantPicRateIdc[i].size() ) xConfirmPara( m_constantPicRateIdc[i][j] < 0 \|\| m_constantPicRateIdc[i][j] > 3, "constant_pic_rate_idc must be more than or equal to 0 and less than 4" );
2236	if ( j < m_avgPicRate [i].size() ) xConfirmPara( m_avgPicRate[i][j] < 0 \|\| m_avgPicRate[i][j] > 65535, "avg_pic_rate must be more than or equal to 0 and less than 65536" );
2237	}
2238	}
2239	// todo: replace value of 100 with requirement in spec
2240	for(Int i = 0; i < MAX_NUM_LAYERS; i++ )
2241	{
2242	for (Int j = 0; j < MAX_NUM_LAYERS; j++)
2243	{
2244	if ( j < m_minSpatialSegmentOffsetPlus1[i].size() ) xConfirmPara( m_minSpatialSegmentOffsetPlus1[i][j] < 0 \|\| m_minSpatialSegmentOffsetPlus1[i][j] > 100, "min_spatial_segment_offset_plus1 must be more than or equal to 0 and less than 101" );
2245	if ( j < m_minHorizontalCtuOffsetPlus1[i] .size() ) xConfirmPara( m_minHorizontalCtuOffsetPlus1[i][j] < 0 \|\| m_minHorizontalCtuOffsetPlus1[i][j] > 100, "min_horizontal_ctu_offset_plus1 must be more than or equal to 0 and less than 101" );
2246	}
2247	}
2248	#endif
2249
2250	xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagForce, "CUTransquantBypassFlagForce cannot be 1 when TransquantBypassEnableFlag is 0");
2251
2252	xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2");
2253	if (m_framePackingSEIEnabled)
2254	{
2255	xConfirmPara(m_framePackingSEIType < 3 \|\| m_framePackingSEIType > 5 , "SEIFramePackingType must be in rage 3 to 5");
2256	}
2257
2258	#if H_MV
2259	}
2260	}
2261	// Check input parameters for Sub-bitstream property SEI message
2262	if( m_subBistreamPropSEIEnabled )
2263	{
2264	xConfirmPara(
2265	(this->m_sbPropNumAdditionalSubStreams != m_sbPropAvgBitRate.size() )
2266	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropHighestSublayerId.size() )
2267	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropMaxBitRate.size() )
2268	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropOutputLayerSetIdxToVps.size() )
2269	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropSubBitstreamMode.size()), "Some parameters of some sub-bitstream not defined");
2270
2271	for( Int i = 0; i < m_sbPropNumAdditionalSubStreams; i++ )
2272	{
2273	xConfirmPara( m_sbPropSubBitstreamMode[i] < 0 \|\| m_sbPropSubBitstreamMode[i] > 1, "Mode value should be 0 or 1" );
2274	xConfirmPara( m_sbPropHighestSublayerId[i] < 0 \|\| m_sbPropHighestSublayerId[i] > MAX_TLAYER-1, "Maximum sub-layer ID out of range" );
2275	xConfirmPara( m_sbPropOutputLayerSetIdxToVps[i] < 0 \|\| m_sbPropOutputLayerSetIdxToVps[i] >= MAX_VPS_OUTPUTLAYER_SETS, "OutputLayerSetIdxToVps should be within allowed range" );
2276	}
2277	}
2278	#endif
2279	#undef xConfirmPara
2280	if (check_failed)
2281	{
2282	exit(EXIT_FAILURE);
2283	}
2284	}
2285
2286	/** \todo use of global variables should be removed later
2287	*/
2288	Void TAppEncCfg::xSetGlobal()
2289	{
2290	// set max CU width & height
2291	g_uiMaxCUWidth = m_uiMaxCUWidth;
2292	g_uiMaxCUHeight = m_uiMaxCUHeight;
2293
2294	// compute actual CU depth with respect to config depth and max transform size
2295	g_uiAddCUDepth = 0;
2296	while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth ) ) ) g_uiAddCUDepth++;
2297
2298	m_uiMaxCUDepth += g_uiAddCUDepth;
2299	g_uiAddCUDepth++;
2300	g_uiMaxCUDepth = m_uiMaxCUDepth;
2301
2302	// set internal bit-depth and constants
2303	g_bitDepthY = m_internalBitDepthY;
2304	g_bitDepthC = m_internalBitDepthC;
2305
2306	g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
2307	g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
2308	}
2309
2310	Void TAppEncCfg::xPrintParameter()
2311	{
2312	printf("\n");
2313	#if H_MV
2314	for( Int layer = 0; layer < m_numberOfLayers; layer++)
2315	{
2316	printf("Input File %i : %s\n", layer, m_pchInputFileList[layer]);
2317	}
2318	#else
2319	printf("Input File : %s\n", m_pchInputFile );
2320	#endif
2321	printf("Bitstream File : %s\n", m_pchBitstreamFile );
2322	#if H_MV
2323	for( Int layer = 0; layer < m_numberOfLayers; layer++)
2324	{
2325	printf("Reconstruction File %i : %s\n", layer, m_pchReconFileList[layer]);
2326	}
2327	#else
2328	printf("Reconstruction File : %s\n", m_pchReconFile );
2329	#endif
2330	#if H_MV
2331	xPrintParaVector( "ViewIdVal" , m_viewId );
2332	xPrintParaVector( "ViewOrderIndex", m_viewOrderIndex );
2333	#endif
2334	#if H_3D
2335	xPrintParaVector( "DepthFlag", m_depthFlag );
2336	printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2337	#endif
2338	#if H_MV
2339	xPrintParaVector( "QP" , m_fQP );
2340	xPrintParaVector( "LoopFilterDisable", m_bLoopFilterDisable );
2341	xPrintParaVector( "SAO" , m_bUseSAO );
2342	#endif
2343	printf("Real Format : %dx%d %dHz\n", m_iSourceWidth - m_confLeft - m_confRight, m_iSourceHeight - m_confTop - m_confBottom, m_iFrameRate );
2344	printf("Internal Format : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
2345	if (m_isField)
2346	{
2347	printf("Frame/Field : Field based coding\n");
2348	printf("Field index : %u - %d (%d fields)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2349	if (m_isTopFieldFirst)
2350	{
2351	printf("Field Order : Top field first\n");
2352	}
2353	else
2354	{
2355	printf("Field Order : Bottom field first\n");
2356	}
2357	}
2358	else
2359	{
2360	printf("Frame/Field : Frame based coding\n");
2361	printf("Frame index : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2362	}
2363	printf("CU size / depth : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
2364	printf("RQT trans. size (min / max) : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
2365	printf("Max RQT depth inter : %d\n", m_uiQuadtreeTUMaxDepthInter);
2366	printf("Max RQT depth intra : %d\n", m_uiQuadtreeTUMaxDepthIntra);
2367	printf("Min PCM size : %d\n", 1 << m_uiPCMLog2MinSize);
2368	printf("Motion search range : %d\n", m_iSearchRange );
2369	#if H_MV
2370	xPrintParaVector( "Intra period", m_iIntraPeriod );
2371	#else
2372	printf("Intra period : %d\n", m_iIntraPeriod );
2373	#endif
2374	printf("Decoding refresh type : %d\n", m_iDecodingRefreshType );
2375	#if !H_MV
2376	printf("QP : %5.2f\n", m_fQP );
2377	#endif
2378	printf("Max dQP signaling depth : %d\n", m_iMaxCuDQPDepth);
2379
2380	printf("Cb QP Offset : %d\n", m_cbQpOffset );
2381	printf("Cr QP Offset : %d\n", m_crQpOffset);
2382
2383	printf("QP adaptation : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
2384	printf("GOP size : %d\n", m_iGOPSize );
2385	printf("Internal bit depth : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC );
2386	printf("PCM sample bit depth : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma );
2387	printf("RateControl : %d\n", m_RCEnableRateControl );
2388	if(m_RCEnableRateControl)
2389	{
2390	printf("TargetBitrate : %d\n", m_RCTargetBitrate );
2391	printf("KeepHierarchicalBit : %d\n", m_RCKeepHierarchicalBit );
2392	printf("LCULevelRC : %d\n", m_RCLCULevelRC );
2393	printf("UseLCUSeparateModel : %d\n", m_RCUseLCUSeparateModel );
2394	printf("InitialQP : %d\n", m_RCInitialQP );
2395	printf("ForceIntraQP : %d\n", m_RCForceIntraQP );
2396
2397	#if KWU_RC_MADPRED_E0227
2398	printf("Depth based MAD prediction : %d\n", m_depthMADPred);
2399	#endif
2400	#if KWU_RC_VIEWRC_E0227
2401	printf("View-wise Rate control : %d\n", m_viewWiseRateCtrl);
2402	if(m_viewWiseRateCtrl)
2403	{
2404
2405	printf("ViewWiseTargetBits : ");
2406	for (Int i = 0 ; i < m_iNumberOfViews ; i++)
2407	printf("%d ", m_viewTargetBits[i]);
2408	printf("\n");
2409	}
2410	else
2411	{
2412	printf("TargetBitrate : %d\n", m_RCTargetBitrate );
2413	}
2414	#endif
2415	}
2416	printf("Max Num Merge Candidates : %d\n", m_maxNumMergeCand);
2417	#if H_3D
2418	printf("BaseViewCameraNumbers : %s\n", m_pchBaseViewCameraNumbers );
2419	printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2420	#if H_3D_VSO
2421	printf("Force use of Lambda Scale : %d\n", m_bForceLambdaScaleVSO );
2422
2423	if ( m_bUseVSO )
2424	{
2425	printf("VSO Lambda Scale : %5.2f\n", m_dLambdaScaleVSO );
2426	printf("VSO Mode : %d\n", m_uiVSOMode );
2427	printf("VSO Config : %s\n", m_pchVSOConfig );
2428	printf("VSO Negative Distortion : %d\n", m_bAllowNegDist ? 1 : 0);
2429	printf("VSO LS Table : %d\n", m_bVSOLSTable ? 1 : 0);
2430	printf("VSO Estimated VSD : %d\n", m_bUseEstimatedVSD ? 1 : 0);
2431	printf("VSO Early Skip : %d\n", m_bVSOEarlySkip ? 1 : 0);
2432	if ( m_bUseWVSO )
2433	printf("Dist. Weights (VSO/VSD/SAD) : %d/%d/%d\n ", m_iVSOWeight, m_iVSDWeight, m_iDWeight );
2434	}
2435	#endif //HHI_VSO
2436	#endif //H_3D
2437	printf("\n");
2438	#if H_MV
2439	printf("TOOL CFG General: ");
2440	#else
2441	printf("TOOL CFG: ");
2442	#endif
2443	printf("IBD:%d ", g_bitDepthY > m_inputBitDepthY \|\| g_bitDepthC > m_inputBitDepthC);
2444	printf("HAD:%d ", m_bUseHADME );
2445	printf("RDQ:%d ", m_useRDOQ );
2446	printf("RDQTS:%d ", m_useRDOQTS );
2447	printf("RDpenalty:%d ", m_rdPenalty );
2448	printf("SQP:%d ", m_uiDeltaQpRD );
2449	printf("ASR:%d ", m_bUseASR );
2450	printf("FEN:%d ", m_bUseFastEnc );
2451	printf("ECU:%d ", m_bUseEarlyCU );
2452	printf("FDM:%d ", m_useFastDecisionForMerge );
2453	printf("CFM:%d ", m_bUseCbfFastMode );
2454	printf("ESD:%d ", m_useEarlySkipDetection );
2455	printf("RQT:%d ", 1 );
2456	printf("TransformSkip:%d ", m_useTransformSkip );
2457	printf("TransformSkipFast:%d ", m_useTransformSkipFast );
2458	printf("Slice: M=%d ", m_sliceMode);
2459	if (m_sliceMode!=0)
2460	{
2461	printf("A=%d ", m_sliceArgument);
2462	}
2463	printf("SliceSegment: M=%d ",m_sliceSegmentMode);
2464	if (m_sliceSegmentMode!=0)
2465	{
2466	printf("A=%d ", m_sliceSegmentArgument);
2467	}
2468	printf("CIP:%d ", m_bUseConstrainedIntraPred);
2469	#if !H_MV
2470	printf("SAO:%d ", (m_bUseSAO)?(1):(0));
2471	#endif
2472	printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
2473	if (m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagForce)
2474	{
2475	printf("TransQuantBypassEnabled: =1 ");
2476	}
2477	else
2478	{
2479	printf("TransQuantBypassEnabled:%d ", (m_TransquantBypassEnableFlag)? 1:0 );
2480	}
2481	printf("WPP:%d ", (Int)m_useWeightedPred);
2482	printf("WPB:%d ", (Int)m_useWeightedBiPred);
2483	printf("PME:%d ", m_log2ParallelMergeLevel);
2484	printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d",
2485	m_iWaveFrontSynchro, m_iWaveFrontSubstreams);
2486	printf(" ScalingList:%d ", m_useScalingListId );
2487	printf("TMVPMode:%d ", m_TMVPModeId );
2488	#if ADAPTIVE_QP_SELECTION
2489	printf("AQpS:%d ", m_bUseAdaptQpSelect );
2490	#endif
2491
2492	printf(" SignBitHidingFlag:%d ", m_signHideFlag);
2493	printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 );
2494	#if H_3D_VSO
2495	printf("VSO:%d ", m_bUseVSO );
2496	printf("WVSO:%d ", m_bUseWVSO );
2497	#endif
2498	#if MTK_I0099_VPS_EX2
2499	printf("LimQtPredFlag:%d", m_bLimQtPredFlag ? 1 : 0);
2500	#endif
2501	#if !MTK_I0099_VPS_EX2
2502	#if H_3D_QTLPC
2503	printf("QTL:%d ", m_bUseQTL);
2504	printf("PC:%d " , m_bUsePC );
2505	#endif
2506	#endif
2507	#if H_3D_IV_MERGE
2508	printf("IvMvPred:%d %d", m_ivMvPredFlag[0] ? 1 : 0, m_ivMvPredFlag[1] ? 1 : 0);
2509	#if H_3D_SPIVMP
2510	printf(" SubPULog2Size:%d " , m_iSubPULog2Size );
2511	printf(" SubPUMPILog2Size:%d " , m_iSubPUMPILog2Size );
2512	#endif
2513	#endif
2514	#if H_3D_ARP
2515	printf(" ARP:%d ", m_uiUseAdvResPred );
2516	#endif
2517	#if H_3D_IC
2518	printf( "IlluCompEnable:%d ", m_abUseIC);
2519	printf ("IlluCompLowLatencyEnc:%d ", m_bUseLowLatencyICEnc);
2520	#endif
2521	#if H_3D_NBDV_REF
2522	printf("DepthRefinement:%d ", m_depthRefinementFlag );
2523	#endif
2524	#if H_3D_VSP
2525	printf("ViewSynthesisPred:%d ", m_viewSynthesisPredFlag );
2526	#endif
2527	#if H_3D
2528	printf("IvMvScaling:%d ", m_ivMvScalingFlag ? 1 : 0 );
2529	#endif
2530	#if H_3D_DIM
2531	printf("DMM:%d ", m_useDMM );
2532	printf("SDC:%d ", m_useSDC );
2533	printf("DLT:%d ", m_useDLT );
2534	#endif
2535	#if H_3D_INTER_SDC
2536	printf( "interSDC:%d ", m_bDepthInterSDCFlag ? 1 : 0 );
2537	#endif
2538	#if H_3D_DBBP
2539	printf("DBBP:%d ", m_bUseDBBP ? 1 : 0);
2540	#endif
2541	#if H_3D_IV_MERGE
2542	printf( "MPI:%d ", m_bMPIFlag ? 1 : 0 );
2543	#endif
2544	printf("\n\n");
2545
2546	fflush(stdout);
2547	}
2548
2549	Bool confirmPara(Bool bflag, const Char* message)
2550	{
2551	if (!bflag)
2552	return false;
2553
2554	printf("Error: %s\n",message);
2555	return true;
2556	}
2557
2558	//! \}

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

Download in other formats: