Context navigation

source: 3DVCSoftware/trunk/source/App/TAppEncoder/TAppEncCfg.cpp @ 875

Visit:

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

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

Download in other formats: