Context navigation

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

Visit:

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

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

Download in other formats: