Context navigation

source: 3DVCSoftware/branches/HTM-10.1-dev0/source/App/TAppEncoder/TAppEncCfg.cpp @ 876

Visit:

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

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

Download in other formats: