Context navigation

source: SHVCSoftware/branches/SHM-2.0-dev/source/App/TAppEncoder/TAppEncCfg.cpp @ 170

Visit:

Last change on this file since 170 was 161, checked in by interdigital, 13 years ago
add ENCODER_FAST_MODE and REF_IDX_MFM to TOOL CFG log
File size: 92.1 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2013, 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	#if SVC_EXTENSION
66	TAppEncCfg::TAppEncCfg()
67	: m_pBitstreamFile()
68	, m_pColumnWidth()
69	, m_pRowHeight()
70	, m_scalingListFile()
71	#if REF_IDX_FRAMEWORK
72	, m_elRapSliceBEnabled(0)
73	#endif
74	{
75	for(UInt layer=0; layer<MAX_LAYERS; layer++)
76	{
77	m_acLayerCfg[layer].setAppEncCfg(this);
78	}
79	}
80	#else
81	TAppEncCfg::TAppEncCfg()
82	: m_pchInputFile()
83	, m_pchBitstreamFile()
84	, m_pchReconFile()
85	, m_pchdQPFile()
86	, m_pColumnWidth()
87	, m_pRowHeight()
88	, m_scalingListFile()
89	{
90	m_aidQP = NULL;
91	#if J0149_TONE_MAPPING_SEI
92	m_startOfCodedInterval = NULL;
93	m_codedPivotValue = NULL;
94	m_targetPivotValue = NULL;
95	#endif
96	}
97	#endif
98
99	TAppEncCfg::~TAppEncCfg()
100	{
101	#if SVC_EXTENSION
102	free(m_pBitstreamFile);
103	#else
104	free(m_pchBitstreamFile);
105	if ( m_aidQP )
106	{
107	delete[] m_aidQP;
108	}
109	#if J0149_TONE_MAPPING_SEI
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	#endif
126	free(m_pchInputFile);
127	#endif
128	#if !SVC_EXTENSION
129	free(m_pchReconFile);
130	free(m_pchdQPFile);
131	#endif
132	free(m_pColumnWidth);
133	free(m_pRowHeight);
134	free(m_scalingListFile);
135	}
136
137	Void TAppEncCfg::create()
138	{
139	}
140
141	Void TAppEncCfg::destroy()
142	{
143	#if VPS_EXTN_DIRECT_REF_LAYERS
144	for(Int layer = 0; layer < MAX_LAYERS; layer++)
145	{
146	if( m_acLayerCfg[layer].m_numDirectRefLayers > 0 )
147	{
148	delete [] m_acLayerCfg[layer].m_refLayerIds;
149	}
150	}
151	#endif
152	}
153
154	std::istringstream &operator>>(std::istringstream &in, GOPEntry &entry) //input
155	{
156	in>>entry.m_sliceType;
157	in>>entry.m_POC;
158	in>>entry.m_QPOffset;
159	in>>entry.m_QPFactor;
160	in>>entry.m_tcOffsetDiv2;
161	in>>entry.m_betaOffsetDiv2;
162	in>>entry.m_temporalId;
163	in>>entry.m_numRefPicsActive;
164	in>>entry.m_numRefPics;
165	for ( Int i = 0; i < entry.m_numRefPics; i++ )
166	{
167	in>>entry.m_referencePics[i];
168	}
169	in>>entry.m_interRPSPrediction;
170	#if AUTO_INTER_RPS
171	if (entry.m_interRPSPrediction==1)
172	{
173	in>>entry.m_deltaRPS;
174	in>>entry.m_numRefIdc;
175	for ( Int i = 0; i < entry.m_numRefIdc; i++ )
176	{
177	in>>entry.m_refIdc[i];
178	}
179	}
180	else if (entry.m_interRPSPrediction==2)
181	{
182	in>>entry.m_deltaRPS;
183	}
184	#else
185	if (entry.m_interRPSPrediction)
186	{
187	in>>entry.m_deltaRPS;
188	in>>entry.m_numRefIdc;
189	for ( Int i = 0; i < entry.m_numRefIdc; i++ )
190	{
191	in>>entry.m_refIdc[i];
192	}
193	}
194	#endif
195	return in;
196	}
197
198	#if SVC_EXTENSION
199	void TAppEncCfg::getDirFilename(string& filename, string& dir, const string path)
200	{
201	size_t pos = path.find_last_of("\\");
202	if(pos != std::string::npos)
203	{
204	filename.assign(path.begin() + pos + 1, path.end());
205	dir.assign(path.begin(), path.begin() + pos + 1);
206	}
207	else
208	{
209	pos = path.find_last_of("/");
210	if(pos != std::string::npos)
211	{
212	filename.assign(path.begin() + pos + 1, path.end());
213	dir.assign(path.begin(), path.begin() + pos + 1);
214	}
215	else
216	{
217	filename = path;
218	dir.assign("");
219	}
220	}
221	}
222	#endif
223
224	static const struct MapStrToProfile {
225	const Char* str;
226	Profile::Name value;
227	} strToProfile[] = {
228	{"none", Profile::NONE},
229	{"main", Profile::MAIN},
230	{"main10", Profile::MAIN10},
231	{"main-still-picture", Profile::MAINSTILLPICTURE},
232	};
233
234	static const struct MapStrToTier {
235	const Char* str;
236	Level::Tier value;
237	} strToTier[] = {
238	{"main", Level::MAIN},
239	{"high", Level::HIGH},
240	};
241
242	static const struct MapStrToLevel {
243	const Char* str;
244	Level::Name value;
245	} strToLevel[] = {
246	{"none",Level::NONE},
247	{"1", Level::LEVEL1},
248	{"2", Level::LEVEL2},
249	{"2.1", Level::LEVEL2_1},
250	{"3", Level::LEVEL3},
251	{"3.1", Level::LEVEL3_1},
252	{"4", Level::LEVEL4},
253	{"4.1", Level::LEVEL4_1},
254	{"5", Level::LEVEL5},
255	{"5.1", Level::LEVEL5_1},
256	{"5.2", Level::LEVEL5_2},
257	{"6", Level::LEVEL6},
258	{"6.1", Level::LEVEL6_1},
259	{"6.2", Level::LEVEL6_2},
260	};
261
262	template<typename T, typename P>
263	static istream& readStrToEnum(P map[], unsigned long mapLen, istream &in, T &val)
264	{
265	string str;
266	in >> str;
267
268	for (Int i = 0; i < mapLen; i++)
269	{
270	if (str == map[i].str)
271	{
272	val = map[i].value;
273	goto found;
274	}
275	}
276	/* not found */
277	in.setstate(ios::failbit);
278	found:
279	return in;
280	}
281
282	static istream& operator>>(istream &in, Profile::Name &profile)
283	{
284	return readStrToEnum(strToProfile, sizeof(strToProfile)/sizeof(*strToProfile), in, profile);
285	}
286
287	static istream& operator>>(istream &in, Level::Tier &tier)
288	{
289	return readStrToEnum(strToTier, sizeof(strToTier)/sizeof(*strToTier), in, tier);
290	}
291
292	static istream& operator>>(istream &in, Level::Name &level)
293	{
294	return readStrToEnum(strToLevel, sizeof(strToLevel)/sizeof(*strToLevel), in, level);
295	}
296
297	#if SIGNAL_BITRATE_PICRATE_IN_VPS
298	Void readBoolString(const string inpString, const Int numEntries, Bool* &memberArray, const char *elementName);
299	Void readIntString(const string inpString, const Int numEntries, Int* &memberArray, const char *elementName);
300	#endif
301	// ====================================================================================================================
302	// Public member functions
303	// ====================================================================================================================
304
305	/** \param argc number of arguments
306	\param argv array of arguments
307	\retval true when success
308	*/
309	Bool TAppEncCfg::parseCfg( Int argc, Char* argv[] )
310	{
311	Bool do_help = false;
312
313	#if SVC_EXTENSION
314	string cfg_LayerCfgFile [MAX_LAYERS];
315	string cfg_BitstreamFile;
316	string* cfg_InputFile [MAX_LAYERS];
317	string* cfg_ReconFile [MAX_LAYERS];
318	Double* cfg_fQP [MAX_LAYERS];
319
320	Int* cfg_SourceWidth [MAX_LAYERS];
321	Int* cfg_SourceHeight [MAX_LAYERS];
322	Int* cfg_FrameRate [MAX_LAYERS];
323	Int* cfg_IntraPeriod [MAX_LAYERS];
324	Int* cfg_conformanceMode [MAX_LAYERS];
325	#if VPS_EXTN_DIRECT_REF_LAYERS
326	Int* cfg_numDirectRefLayers [MAX_LAYERS];
327	string cfg_refLayerIds [MAX_LAYERS];
328	string* cfg_refLayerIdsPtr [MAX_LAYERS];
329	#endif
330	for(UInt layer = 0; layer < MAX_LAYERS; layer++)
331	{
332	cfg_InputFile[layer] = &m_acLayerCfg[layer].m_cInputFile;
333	cfg_ReconFile[layer] = &m_acLayerCfg[layer].m_cReconFile;
334	cfg_fQP[layer] = &m_acLayerCfg[layer].m_fQP;
335	cfg_SourceWidth[layer] = &m_acLayerCfg[layer].m_iSourceWidth;
336	cfg_SourceHeight[layer] = &m_acLayerCfg[layer].m_iSourceHeight;
337	cfg_FrameRate[layer] = &m_acLayerCfg[layer].m_iFrameRate;
338	cfg_IntraPeriod[layer] = &m_acLayerCfg[layer].m_iIntraPeriod;
339	cfg_conformanceMode[layer] = &m_acLayerCfg[layer].m_conformanceMode;
340	#if VPS_EXTN_DIRECT_REF_LAYERS
341	cfg_numDirectRefLayers [layer] = &m_acLayerCfg[layer].m_numDirectRefLayers;
342	cfg_refLayerIdsPtr [layer] = &cfg_refLayerIds[layer];
343	#endif
344	}
345	#if AVC_BASE
346	string cfg_BLInputFile;
347	#endif
348	#if AVC_SYNTAX
349	string cfg_BLSyntaxFile;
350	#endif
351	#else
352	string cfg_InputFile;
353	string cfg_BitstreamFile;
354	string cfg_ReconFile;
355	string cfg_dQPFile;
356	#endif
357	string cfg_ColumnWidth;
358	string cfg_RowHeight;
359	string cfg_ScalingListFile;
360	#if J0149_TONE_MAPPING_SEI
361	string cfg_startOfCodedInterval;
362	string cfg_codedPivotValue;
363	string cfg_targetPivotValue;
364	#endif
365	#if SIGNAL_BITRATE_PICRATE_IN_VPS
366	string cfg_bitRateInfoPresentFlag;
367	string cfg_picRateInfoPresentFlag;
368	string cfg_avgBitRate;
369	string cfg_maxBitRate;
370	string cfg_avgPicRate;
371	string cfg_constantPicRateIdc;
372	#endif
373	po::Options opts;
374	opts.addOptions()
375	("help", do_help, false, "this help text")
376	("c", po::parseConfigFile, "configuration file name")
377
378	// File, I/O and source parameters
379	#if SVC_EXTENSION
380	("InputFile%d,-i%d", cfg_InputFile, string(""), MAX_LAYERS, "original YUV input file name for layer %d")
381	("ReconFile%d,-o%d", cfg_ReconFile, string(""), MAX_LAYERS, "reconstruction YUV input file name for layer %d")
382	("LayerConfig%d,-lc%d", cfg_LayerCfgFile, string(""), MAX_LAYERS, "layer %d configuration file name")
383	("SourceWidth%d,-wdt%d", cfg_SourceWidth, 0, MAX_LAYERS, "Source picture width for layer %d")
384	("SourceHeight%d,-hgt%d", cfg_SourceHeight, 0, MAX_LAYERS, "Source picture height for layer %d")
385	("FrameRate%d,-fr%d", cfg_FrameRate, 0, MAX_LAYERS, "Frame rate for layer %d")
386	("LambdaModifier%d,-LM%d", m_adLambdaModifier, ( double )1.0, MAX_TLAYER, "Lambda modifier for temporal layer %d")
387	#if VPS_EXTN_DIRECT_REF_LAYERS
388	("NumDirectRefLayers%d", cfg_numDirectRefLayers, -1, MAX_LAYERS, "Number of direct reference layers")
389	("RefLayerIds%d", cfg_refLayerIdsPtr, string(""), MAX_LAYERS, "direct reference layer IDs")
390	#endif
391	("NumLayers", m_numLayers, 1, "Number of layers to code")
392	("ConformanceMode%d", cfg_conformanceMode,0, MAX_LAYERS, "Window conformance mode (0: no cropping, 1:automatic padding, 2: padding, 3:cropping")
393
394	("BitstreamFile,b", cfg_BitstreamFile, string(""), "Bitstream output file name")
395	("InputBitDepth", m_inputBitDepthY, 8, "Bit-depth of input file")
396	("OutputBitDepth", m_outputBitDepthY, 0, "Bit-depth of output file (default:InternalBitDepth)")
397	("InternalBitDepth", m_internalBitDepthY, 0, "Bit-depth the codec operates at. (default:InputBitDepth)"
398	"If different to InputBitDepth, source data will be converted")
399	("InputBitDepthC", m_inputBitDepthC, 0, "As per InputBitDepth but for chroma component. (default:InputBitDepth)")
400	("OutputBitDepthC", m_outputBitDepthC, 0, "As per OutputBitDepth but for chroma component. (default:InternalBitDepthC)")
401	("InternalBitDepthC", m_internalBitDepthC, 0, "As per InternalBitDepth but for chroma component. (default:IntrenalBitDepth)")
402
403	#if AVC_BASE
404	("AvcBase", m_avcBaseLayerFlag, 0, "AVC_BASElayer_flag")
405	("InputBLFile,-ibl", cfg_BLInputFile, string(""), "Base layer rec YUV input file name")
406	#if AVC_SYNTAX
407	("InputBLSyntaxFile,-ibs", cfg_BLSyntaxFile, string(""), "Base layer syntax input file name")
408	#endif
409	#endif
410	#if REF_IDX_FRAMEWORK
411	("EnableElRapB,-use-rap-b", m_elRapSliceBEnabled, 0, "Set ILP over base-layer I picture to B picture (default is P picture_")
412	#endif
413	#else
414	("InputFile,i", cfg_InputFile, string(""), "Original YUV input file name")
415	("BitstreamFile,b", cfg_BitstreamFile, string(""), "Bitstream output file name")
416	("ReconFile,o", cfg_ReconFile, string(""), "Reconstructed YUV output file name")
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_conformanceMode, 0, "Window conformance mode (0: no window, 1:automatic padding, 2:padding, 3:conformance")
427	("HorizontalPadding,-pdx",m_aiPad[0], 0, "Horizontal source padding for conformance window mode 2")
428	("VerticalPadding,-pdy", m_aiPad[1], 0, "Vertical source padding for conformance window mode 2")
429	("ConfLeft", m_confLeft, 0, "Left offset for window conformance mode 3")
430	("ConfRight", m_confRight, 0, "Right offset for window conformance mode 3")
431	("ConfTop", m_confTop, 0, "Top offset for window conformance mode 3")
432	("ConfBottom", m_confBottom, 0, "Bottom offset for window conformance mode 3")
433	("FrameRate,-fr", m_iFrameRate, 0, "Frame rate")
434	#endif
435	("FrameSkip,-fs", m_FrameSkip, 0u, "Number of frames to skip at start of input YUV")
436	("FramesToBeEncoded,f", m_framesToBeEncoded, 0, "Number of frames to be encoded (default=all)")
437
438	// Profile and level
439	("Profile", m_profile, Profile::NONE, "Profile to be used when encoding (Incomplete)")
440	("Level", m_level, Level::NONE, "Level limit to be used, eg 5.1 (Incomplete)")
441	("Tier", m_levelTier, Level::MAIN, "Tier to use for interpretation of --Level")
442
443	#if L0046_CONSTRAINT_FLAGS
444	("ProgressiveSource", m_progressiveSourceFlag, false, "Indicate that source is progressive")
445	("InterlacedSource", m_interlacedSourceFlag, false, "Indicate that source is interlaced")
446	("NonPackedSource", m_nonPackedConstraintFlag, false, "Indicate that source does not contain frame packing")
447	("FrameOnly", m_frameOnlyConstraintFlag, false, "Indicate that the bitstream contains only frames")
448	#endif
449
450	// Unit definition parameters
451	("MaxCUWidth", m_uiMaxCUWidth, 64u)
452	("MaxCUHeight", m_uiMaxCUHeight, 64u)
453	// todo: remove defaults from MaxCUSize
454	("MaxCUSize,s", m_uiMaxCUWidth, 64u, "Maximum CU size")
455	("MaxCUSize,s", m_uiMaxCUHeight, 64u, "Maximum CU size")
456	("MaxPartitionDepth,h", m_uiMaxCUDepth, 4u, "CU depth")
457
458	("QuadtreeTULog2MaxSize", m_uiQuadtreeTULog2MaxSize, 6u, "Maximum TU size in logarithm base 2")
459	("QuadtreeTULog2MinSize", m_uiQuadtreeTULog2MinSize, 2u, "Minimum TU size in logarithm base 2")
460
461	("QuadtreeTUMaxDepthIntra", m_uiQuadtreeTUMaxDepthIntra, 1u, "Depth of TU tree for intra CUs")
462	("QuadtreeTUMaxDepthInter", m_uiQuadtreeTUMaxDepthInter, 2u, "Depth of TU tree for inter CUs")
463
464	// Coding structure paramters
465	#if SVC_EXTENSION
466	("IntraPeriod%d,-ip%d", cfg_IntraPeriod, -1, MAX_LAYERS, "intra period in frames for layer %d, (-1: only first frame)")
467	#else
468	("IntraPeriod,-ip", m_iIntraPeriod, -1, "Intra period in frames, (-1: only first frame)")
469	#endif
470	("DecodingRefreshType,-dr", m_iDecodingRefreshType, 0, "Intra refresh type (0:none 1:CRA 2:IDR)")
471	("GOPSize,g", m_iGOPSize, 1, "GOP size of temporal structure")
472	#if !L0034_COMBINED_LIST_CLEANUP
473	("ListCombination,-lc", m_bUseLComb, true, "Combined reference list for uni-prediction estimation in B-slices")
474	#endif
475	// motion options
476	("FastSearch", m_iFastSearch, 1, "0:Full search 1:Diamond 2:PMVFAST")
477	("SearchRange,-sr", m_iSearchRange, 96, "Motion search range")
478	("BipredSearchRange", m_bipredSearchRange, 4, "Motion search range for bipred refinement")
479	("HadamardME", m_bUseHADME, true, "Hadamard ME for fractional-pel")
480	("ASR", m_bUseASR, false, "Adaptive motion search range")
481
482	#if SVC_EXTENSION
483	("LambdaModifier%d,-LM%d", m_adLambdaModifier, ( double )1.0, MAX_TLAYER, "Lambda modifier for temporal layer %d")
484	#else
485	// Mode decision parameters
486	("LambdaModifier0,-LM0", m_adLambdaModifier[ 0 ], ( Double )1.0, "Lambda modifier for temporal layer 0")
487	("LambdaModifier1,-LM1", m_adLambdaModifier[ 1 ], ( Double )1.0, "Lambda modifier for temporal layer 1")
488	("LambdaModifier2,-LM2", m_adLambdaModifier[ 2 ], ( Double )1.0, "Lambda modifier for temporal layer 2")
489	("LambdaModifier3,-LM3", m_adLambdaModifier[ 3 ], ( Double )1.0, "Lambda modifier for temporal layer 3")
490	("LambdaModifier4,-LM4", m_adLambdaModifier[ 4 ], ( Double )1.0, "Lambda modifier for temporal layer 4")
491	("LambdaModifier5,-LM5", m_adLambdaModifier[ 5 ], ( Double )1.0, "Lambda modifier for temporal layer 5")
492	("LambdaModifier6,-LM6", m_adLambdaModifier[ 6 ], ( Double )1.0, "Lambda modifier for temporal layer 6")
493	("LambdaModifier7,-LM7", m_adLambdaModifier[ 7 ], ( Double )1.0, "Lambda modifier for temporal layer 7")
494	#endif
495
496	/* Quantization parameters */
497	#if SVC_EXTENSION
498	("QP%d,-q%d", cfg_fQP, 30.0, MAX_LAYERS, "Qp value for layer %d, if value is float, QP is switched once during encoding")
499	#else
500	("QP,q", m_fQP, 30.0, "Qp value, if value is float, QP is switched once during encoding")
501	#endif
502	("DeltaQpRD,-dqr",m_uiDeltaQpRD, 0u, "max dQp offset for slice")
503	("MaxDeltaQP,d", m_iMaxDeltaQP, 0, "max dQp offset for block")
504	("MaxCuDQPDepth,-dqd", m_iMaxCuDQPDepth, 0, "max depth for a minimum CuDQP")
505
506	("CbQpOffset,-cbqpofs", m_cbQpOffset, 0, "Chroma Cb QP Offset")
507	("CrQpOffset,-crqpofs", m_crQpOffset, 0, "Chroma Cr QP Offset")
508
509	#if ADAPTIVE_QP_SELECTION
510	("AdaptiveQpSelection,-aqps", m_bUseAdaptQpSelect, false, "AdaptiveQpSelection")
511	#endif
512
513	("AdaptiveQP,-aq", m_bUseAdaptiveQP, false, "QP adaptation based on a psycho-visual model")
514	("MaxQPAdaptationRange,-aqr", m_iQPAdaptationRange, 6, "QP adaptation range")
515	#if !SVC_EXTENSION
516	("dQPFile,m", cfg_dQPFile, string(""), "dQP file name")
517	#endif
518	("RDOQ", m_useRDOQ, true )
519	("RDOQTS", m_useRDOQTS, true )
520	#if L0232_RD_PENALTY
521	("RDpenalty", m_rdPenalty, 0, "RD-penalty for 32x32 TU for intra in non-intra slices. 0:disbaled 1:RD-penalty 2:maximum RD-penalty")
522	#endif
523	// Entropy coding parameters
524	("SBACRD", m_bUseSBACRD, true, "SBAC based RD estimation")
525
526	// Deblocking filter parameters
527	("LoopFilterDisable", m_bLoopFilterDisable, false )
528	("LoopFilterOffsetInPPS", m_loopFilterOffsetInPPS, false )
529	("LoopFilterBetaOffset_div2", m_loopFilterBetaOffsetDiv2, 0 )
530	("LoopFilterTcOffset_div2", m_loopFilterTcOffsetDiv2, 0 )
531	("DeblockingFilterControlPresent", m_DeblockingFilterControlPresent, false )
532	#if L0386_DB_METRIC
533	("DeblockingFilterMetric", m_DeblockingFilterMetric, false )
534	#endif
535
536	// Coding tools
537	("AMP", m_enableAMP, true, "Enable asymmetric motion partitions")
538	("TransformSkip", m_useTransformSkip, false, "Intra transform skipping")
539	("TransformSkipFast", m_useTransformSkipFast, false, "Fast intra transform skipping")
540	("SAO", m_bUseSAO, true, "Enable Sample Adaptive Offset")
541	("MaxNumOffsetsPerPic", m_maxNumOffsetsPerPic, 2048, "Max number of SAO offset per picture (Default: 2048)")
542	("SAOLcuBoundary", m_saoLcuBoundary, false, "0: right/bottom LCU boundary areas skipped from SAO parameter estimation, 1: non-deblocked pixels are used for those areas")
543	("SAOLcuBasedOptimization", m_saoLcuBasedOptimization, true, "0: SAO picture-based optimization, 1: SAO LCU-based optimization ")
544	("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")
545	("SliceArgument", m_sliceArgument, 0, "Depending on SliceMode being:"
546	"\t1: max number of CTUs per slice"
547	"\t2: max number of bytes per slice"
548	"\t3: max number of tiles per slice")
549	("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")
550	("SliceSegmentArgument", m_sliceSegmentArgument, 0, "Depending on SliceSegmentMode being:"
551	"\t1: max number of CTUs per slice segment"
552	"\t2: max number of bytes per slice segment"
553	"\t3: max number of tiles per slice segment")
554	("LFCrossSliceBoundaryFlag", m_bLFCrossSliceBoundaryFlag, true)
555
556	("ConstrainedIntraPred", m_bUseConstrainedIntraPred, false, "Constrained Intra Prediction")
557
558	("PCMEnabledFlag", m_usePCM, false)
559	("PCMLog2MaxSize", m_pcmLog2MaxSize, 5u)
560	("PCMLog2MinSize", m_uiPCMLog2MinSize, 3u)
561	("PCMInputBitDepthFlag", m_bPCMInputBitDepthFlag, true)
562	("PCMFilterDisableFlag", m_bPCMFilterDisableFlag, false)
563
564	("LosslessCuEnabled", m_useLossless, false)
565
566	("WeightedPredP,-wpP", m_useWeightedPred, false, "Use weighted prediction in P slices")
567	("WeightedPredB,-wpB", m_useWeightedBiPred, false, "Use weighted (bidirectional) prediction in B slices")
568	("Log2ParallelMergeLevel", m_log2ParallelMergeLevel, 2u, "Parallel merge estimation region")
569	("UniformSpacingIdc", m_iUniformSpacingIdr, 0, "Indicates if the column and row boundaries are distributed uniformly")
570	("NumTileColumnsMinus1", m_iNumColumnsMinus1, 0, "Number of columns in a picture minus 1")
571	("ColumnWidthArray", cfg_ColumnWidth, string(""), "Array containing ColumnWidth values in units of LCU")
572	("NumTileRowsMinus1", m_iNumRowsMinus1, 0, "Number of rows in a picture minus 1")
573	("RowHeightArray", cfg_RowHeight, string(""), "Array containing RowHeight values in units of LCU")
574	("LFCrossTileBoundaryFlag", m_bLFCrossTileBoundaryFlag, true, "1: cross-tile-boundary loop filtering. 0:non-cross-tile-boundary loop filtering")
575	("WaveFrontSynchro", m_iWaveFrontSynchro, 0, "0: no synchro; 1 synchro with TR; 2 TRR etc")
576	("ScalingList", m_useScalingListId, 0, "0: no scaling list, 1: default scaling lists, 2: scaling lists specified in ScalingListFile")
577	("ScalingListFile", cfg_ScalingListFile, string(""), "Scaling list file name")
578	("SignHideFlag,-SBH", m_signHideFlag, 1)
579	("MaxNumMergeCand", m_maxNumMergeCand, 5u, "Maximum number of merge candidates")
580
581	/* Misc. */
582	("SEIDecodedPictureHash", m_decodedPictureHashSEIEnabled, 0, "Control generation of decode picture hash SEI messages\n"
583	"\t3: checksum\n"
584	"\t2: CRC\n"
585	"\t1: use MD5\n"
586	"\t0: disable")
587	("SEIpictureDigest", m_decodedPictureHashSEIEnabled, 0, "deprecated alias for SEIDecodedPictureHash")
588	("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")
589	("FEN", m_bUseFastEnc, false, "fast encoder setting")
590	("ECU", m_bUseEarlyCU, false, "Early CU setting")
591	("FDM", m_useFastDecisionForMerge, true, "Fast decision for Merge RD Cost")
592	("CFM", m_bUseCbfFastMode, false, "Cbf fast mode setting")
593	("ESD", m_useEarlySkipDetection, false, "Early SKIP detection setting")
594	#if RATE_CONTROL_LAMBDA_DOMAIN
595	( "RateControl", m_RCEnableRateControl, false, "Rate control: enable rate control" )
596	( "TargetBitrate", m_RCTargetBitrate, 0, "Rate control: target bitrate" )
597	( "KeepHierarchicalBit", m_RCKeepHierarchicalBit, false, "Rate control: keep hierarchical bit allocation in rate control algorithm" )
598	( "LCULevelRateControl", m_RCLCULevelRC, true, "Rate control: true: LCU level RC; false: picture level RC" )
599	( "RCLCUSeparateModel", m_RCUseLCUSeparateModel, true, "Rate control: use LCU level separate R-lambda model" )
600	( "InitialQP", m_RCInitialQP, 0, "Rate control: initial QP" )
601	( "RCForceIntraQP", m_RCForceIntraQP, false, "Rate control: force intra QP to be equal to initial QP" )
602	#else
603	("RateCtrl,-rc", m_enableRateCtrl, false, "Rate control on/off")
604	("TargetBitrate,-tbr", m_targetBitrate, 0, "Input target bitrate")
605	("NumLCUInUnit,-nu", m_numLCUInUnit, 0, "Number of LCUs in an Unit")
606	#endif
607
608	("TransquantBypassEnableFlag", m_TransquantBypassEnableFlag, false, "transquant_bypass_enable_flag indicator in PPS")
609	("CUTransquantBypassFlagValue", m_CUTransquantBypassFlagValue, false, "Fixed cu_transquant_bypass_flag value, when transquant_bypass_enable_flag is enabled")
610	("RecalculateQPAccordingToLambda", m_recalculateQPAccordingToLambda, false, "Recalculate QP values according to lambda values. Do not suggest to be enabled in all intra case")
611	("StrongIntraSmoothing,-sis", m_useStrongIntraSmoothing, true, "Enable strong intra smoothing for 32x32 blocks")
612	("SEIActiveParameterSets", m_activeParameterSetsSEIEnabled, 0, "Enable generation of active parameter sets SEI messages")
613	("VuiParametersPresent,-vui", m_vuiParametersPresentFlag, false, "Enable generation of vui_parameters()")
614	("AspectRatioInfoPresent", m_aspectRatioInfoPresentFlag, false, "Signals whether aspect_ratio_idc is present")
615	("AspectRatioIdc", m_aspectRatioIdc, 0, "aspect_ratio_idc")
616	("SarWidth", m_sarWidth, 0, "horizontal size of the sample aspect ratio")
617	("SarHeight", m_sarHeight, 0, "vertical size of the sample aspect ratio")
618	("OverscanInfoPresent", m_overscanInfoPresentFlag, false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n")
619	("OverscanAppropriate", m_overscanAppropriateFlag, false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n")
620	("VideoSignalTypePresent", m_videoSignalTypePresentFlag, false, "Signals whether video_format, video_full_range_flag, and colour_description_present_flag are present")
621	("VideoFormat", m_videoFormat, 5, "Indicates representation of pictures")
622	("VideoFullRange", m_videoFullRangeFlag, false, "Indicates the black level and range of luma and chroma signals")
623	("ColourDescriptionPresent", m_colourDescriptionPresentFlag, false, "Signals whether colour_primaries, transfer_characteristics and matrix_coefficients are present")
624	("ColourPrimaries", m_colourPrimaries, 2, "Indicates chromaticity coordinates of the source primaries")
625	("TransferCharateristics", m_transferCharacteristics, 2, "Indicates the opto-electronic transfer characteristics of the source")
626	("MatrixCoefficients", m_matrixCoefficients, 2, "Describes the matrix coefficients used in deriving luma and chroma from RGB primaries")
627	("ChromaLocInfoPresent", m_chromaLocInfoPresentFlag, false, "Signals whether chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field are present")
628	("ChromaSampleLocTypeTopField", m_chromaSampleLocTypeTopField, 0, "Specifies the location of chroma samples for top field")
629	("ChromaSampleLocTypeBottomField", m_chromaSampleLocTypeBottomField, 0, "Specifies the location of chroma samples for bottom field")
630	("NeutralChromaIndication", m_neutralChromaIndicationFlag, false, "Indicates that the value of all decoded chroma samples is equal to 1<<(BitDepthCr-1)")
631	("DefaultDisplayWindowFlag", m_defaultDisplayWindowFlag, false, "Indicates the presence of the Default Window parameters")
632	("DefDispWinLeftOffset", m_defDispWinLeftOffset, 0, "Specifies the left offset of the default display window from the conformance window")
633	("DefDispWinRightOffset", m_defDispWinRightOffset, 0, "Specifies the right offset of the default display window from the conformance window")
634	("DefDispWinTopOffset", m_defDispWinTopOffset, 0, "Specifies the top offset of the default display window from the conformance window")
635	("DefDispWinBottomOffset", m_defDispWinBottomOffset, 0, "Specifies the bottom offset of the default display window from the conformance window")
636	("FrameFieldInfoPresentFlag", m_frameFieldInfoPresentFlag, false, "Indicates that pic_struct and field coding related values are present in picture timing SEI messages")
637	("PocProportionalToTimingFlag", m_pocProportionalToTimingFlag, false, "Indicates that the POC value is proportional to the output time w.r.t. first picture in CVS")
638	("NumTicksPocDiffOneMinus1", m_numTicksPocDiffOneMinus1, 0, "Number of ticks minus 1 that for a POC difference of one")
639	("BitstreamRestriction", m_bitstreamRestrictionFlag, false, "Signals whether bitstream restriction parameters are present")
640	("TilesFixedStructure", m_tilesFixedStructureFlag, false, "Indicates that each active picture parameter set has the same values of the syntax elements related to tiles")
641	("MotionVectorsOverPicBoundaries", m_motionVectorsOverPicBoundariesFlag, false, "Indicates that no samples outside the picture boundaries are used for inter prediction")
642	("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")
643	("MaxBitsPerMinCuDenom", m_maxBitsPerMinCuDenom, 1, "Indicates an upper bound for the number of bits of coding_unit() data")
644	("Log2MaxMvLengthHorizontal", m_log2MaxMvLengthHorizontal, 15, "Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units")
645	("Log2MaxMvLengthVertical", m_log2MaxMvLengthVertical, 15, "Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units")
646	("SEIRecoveryPoint", m_recoveryPointSEIEnabled, 0, "Control generation of recovery point SEI messages")
647	("SEIBufferingPeriod", m_bufferingPeriodSEIEnabled, 0, "Control generation of buffering period SEI messages")
648	("SEIPictureTiming", m_pictureTimingSEIEnabled, 0, "Control generation of picture timing SEI messages")
649	#if J0149_TONE_MAPPING_SEI
650	("SEIToneMappingInfo", m_toneMappingInfoSEIEnabled, false, "Control generation of Tone Mapping SEI messages")
651	("SEIToneMapId", m_toneMapId, 0, "Specifies Id of Tone Mapping SEI message for a given session")
652	("SEIToneMapCancelFlag", m_toneMapCancelFlag, false, "Indicates that Tone Mapping SEI message cancels the persistance or follows")
653	("SEIToneMapPersistenceFlag", m_toneMapPersistenceFlag, true, "Specifies the persistence of the Tone Mapping SEI message")
654	("SEIToneMapCodedDataBitDepth", m_toneMapCodedDataBitDepth, 8, "Specifies Coded Data BitDepth of Tone Mapping SEI messages")
655	("SEIToneMapTargetBitDepth", m_toneMapTargetBitDepth, 8, "Specifies Output BitDepth of Tome mapping function")
656	("SEIToneMapModelId", m_toneMapModelId, 0, "Specifies Model utilized for mapping coded data into target_bit_depth range\n"
657	"\t0: linear mapping with clipping\n"
658	"\t1: sigmoidal mapping\n"
659	"\t2: user-defined table mapping\n"
660	"\t3: piece-wise linear mapping\n"
661	"\t4: luminance dynamic range information ")
662	("SEIToneMapMinValue", m_toneMapMinValue, 0, "Specifies the minimum value in mode 0")
663	("SEIToneMapMaxValue", m_toneMapMaxValue, 1023, "Specifies the maxmum value in mode 0")
664	("SEIToneMapSigmoidMidpoint", m_sigmoidMidpoint, 512, "Specifies the centre point in mode 1")
665	("SEIToneMapSigmoidWidth", m_sigmoidWidth, 960, "Specifies the distance between 5% and 95% values of the target_bit_depth in mode 1")
666	("SEIToneMapStartOfCodedInterval", cfg_startOfCodedInterval, string(""), "Array of user-defined mapping table")
667	("SEIToneMapNumPivots", m_numPivots, 0, "Specifies the number of pivot points in mode 3")
668	("SEIToneMapCodedPivotValue", cfg_codedPivotValue, string(""), "Array of pivot point")
669	("SEIToneMapTargetPivotValue", cfg_targetPivotValue, string(""), "Array of pivot point")
670	("SEIToneMapCameraIsoSpeedIdc", m_cameraIsoSpeedIdc, 0, "Indicates the camera ISO speed for daylight illumination")
671	("SEIToneMapCameraIsoSpeedValue", m_cameraIsoSpeedValue, 400, "Specifies the camera ISO speed for daylight illumination of Extended_ISO")
672	("SEIToneMapExposureCompensationValueSignFlag", m_exposureCompensationValueSignFlag, 0, "Specifies the sign of ExposureCompensationValue")
673	("SEIToneMapExposureCompensationValueNumerator", m_exposureCompensationValueNumerator, 0, "Specifies the numerator of ExposureCompensationValue")
674	("SEIToneMapExposureCompensationValueDenomIdc", m_exposureCompensationValueDenomIdc, 2, "Specifies the denominator of ExposureCompensationValue")
675	("SEIToneMapRefScreenLuminanceWhite", m_refScreenLuminanceWhite, 350, "Specifies reference screen brightness setting in units of candela per square metre")
676	("SEIToneMapExtendedRangeWhiteLevel", m_extendedRangeWhiteLevel, 800, "Indicates the luminance dynamic range")
677	("SEIToneMapNominalBlackLevelLumaCodeValue", m_nominalBlackLevelLumaCodeValue, 16, "Specifies luma sample value of the nominal black level assigned decoded pictures")
678	("SEIToneMapNominalWhiteLevelLumaCodeValue", m_nominalWhiteLevelLumaCodeValue, 235, "Specifies luma sample value of the nominal white level assigned decoded pictures")
679	("SEIToneMapExtendedWhiteLevelLumaCodeValue", m_extendedWhiteLevelLumaCodeValue, 300, "Specifies luma sample value of the extended dynamic range assigned decoded pictures")
680	#endif
681	("SEIFramePacking", m_framePackingSEIEnabled, 0, "Control generation of frame packing SEI messages")
682	("SEIFramePackingType", m_framePackingSEIType, 0, "Define frame packing arrangement\n"
683	"\t0: checkerboard - pixels alternatively represent either frames\n"
684	"\t1: column alternation - frames are interlaced by column\n"
685	"\t2: row alternation - frames are interlaced by row\n"
686	"\t3: side by side - frames are displayed horizontally\n"
687	"\t4: top bottom - frames are displayed vertically\n"
688	"\t5: frame alternation - one frame is alternated with the other")
689	("SEIFramePackingId", m_framePackingSEIId, 0, "Id of frame packing SEI message for a given session")
690	("SEIFramePackingQuincunx", m_framePackingSEIQuincunx, 0, "Indicate the presence of a Quincunx type video frame")
691	("SEIFramePackingInterpretation", m_framePackingSEIInterpretation, 0, "Indicate the interpretation of the frame pair\n"
692	"\t0: unspecified\n"
693	"\t1: stereo pair, frame0 represents left view\n"
694	"\t2: stereo pair, frame0 represents right view")
695	("SEIDisplayOrientation", m_displayOrientationSEIAngle, 0, "Control generation of display orientation SEI messages\n"
696	"\tN: 0 < N < (2^16 - 1) enable display orientation SEI message with anticlockwise_rotation = N and display_orientation_repetition_period = 1\n"
697	"\t0: disable")
698	("SEITemporalLevel0Index", m_temporalLevel0IndexSEIEnabled, 0, "Control generation of temporal level 0 index SEI messages")
699	("SEIGradualDecodingRefreshInfo", m_gradualDecodingRefreshInfoEnabled, 0, "Control generation of gradual decoding refresh information SEI message")
700	("SEIDecodingUnitInfo", m_decodingUnitInfoSEIEnabled, 0, "Control generation of decoding unit information SEI message.")
701	#if L0208_SOP_DESCRIPTION_SEI
702	("SEISOPDescription", m_SOPDescriptionSEIEnabled, 0, "Control generation of SOP description SEI messages")
703	#endif
704	#if K0180_SCALABLE_NESTING_SEI
705	("SEIScalableNesting", m_scalableNestingSEIEnabled, 0, "Control generation of scalable nesting SEI messages")
706	#endif
707	#if SIGNAL_BITRATE_PICRATE_IN_VPS
708	("BitRatePicRateMaxTLayers", m_bitRatePicRateMaxTLayers, 0, "Maximum number of sub-layers signalled; can be inferred otherwise; here for easy parsing of config. file")
709	("BitRateInfoPresent", cfg_bitRateInfoPresentFlag, string(""), "Control signalling of bit rate information of avg. bit rate and max. bit rate in VPS\n"
710	"\t0: Do not sent bit rate info\n"
711	"\tN (N > 0): Send bit rate info for N sub-layers. N should equal maxTempLayers.")
712	("PicRateInfoPresent", cfg_picRateInfoPresentFlag, string(""), "Control signalling of picture rate information of avg. bit rate and max. bit rate in VPS\n"
713	"\t0: Do not sent picture rate info\n"
714	"\tN (N > 0): Send picture rate info for N sub-layers. N should equal maxTempLayers.")
715	("AvgBitRate", cfg_avgBitRate, string(""), "List of avg. bit rates for the different sub-layers; include non-negative number even if corresponding flag is 0")
716	("MaxBitRate", cfg_maxBitRate, string(""), "List of max. bit rates for the different sub-layers; include non-negative number even if corresponding flag is 0")
717	("AvgPicRate", cfg_avgPicRate, string(""), "List of avg. picture rates for the different sub-layers; include non-negative number even if corresponding flag is 0")
718	("ConstantPicRateIdc", cfg_constantPicRateIdc, string(""), "List of constant picture rate IDCs; include non-negative number even if corresponding flag is 0")
719	#endif
720	;
721
722	#if AVC_BASE
723	if( m_avcBaseLayerFlag )
724	{
725	*cfg_InputFile[0] = cfg_BLInputFile;
726	}
727	#endif
728
729	for(Int i=1; i<MAX_GOP+1; i++) {
730	std::ostringstream cOSS;
731	cOSS<<"Frame"<<i;
732	opts.addOptions()(cOSS.str(), m_GOPList[i-1], GOPEntry());
733	}
734	po::setDefaults(opts);
735	const list<const Char>& argv_unhandled = po::scanArgv(opts, argc, (const Char*) argv);
736
737	for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
738	{
739	fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
740	}
741
742	if (argc == 1 \|\| do_help)
743	{
744	/* argc == 1: no options have been specified */
745	po::doHelp(cout, opts);
746	return false;
747	}
748
749	/*
750	* Set any derived parameters
751	*/
752	/* convert std::string to c string for compatability */
753	#if SVC_EXTENSION
754	m_pBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
755	#if AVC_SYNTAX
756	m_BLSyntaxFile = cfg_BLSyntaxFile.empty() ? NULL : strdup(cfg_BLSyntaxFile.c_str());
757	#endif
758	#else
759	m_pchInputFile = cfg_InputFile.empty() ? NULL : strdup(cfg_InputFile.c_str());
760	m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
761	m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str());
762	m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());
763	#endif
764
765	Char* pColumnWidth = cfg_ColumnWidth.empty() ? NULL: strdup(cfg_ColumnWidth.c_str());
766	Char* pRowHeight = cfg_RowHeight.empty() ? NULL : strdup(cfg_RowHeight.c_str());
767	if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
768	{
769	char *columnWidth;
770	int i=0;
771	m_pColumnWidth = new UInt[m_iNumColumnsMinus1];
772	columnWidth = strtok(pColumnWidth, " ,-");
773	while(columnWidth!=NULL)
774	{
775	if( i>=m_iNumColumnsMinus1 )
776	{
777	printf( "The number of columns whose width are defined is larger than the allowed number of columns.\n" );
778	exit( EXIT_FAILURE );
779	}
780	*( m_pColumnWidth + i ) = atoi( columnWidth );
781	columnWidth = strtok(NULL, " ,-");
782	i++;
783	}
784	if( i<m_iNumColumnsMinus1 )
785	{
786	printf( "The width of some columns is not defined.\n" );
787	exit( EXIT_FAILURE );
788	}
789	}
790	else
791	{
792	m_pColumnWidth = NULL;
793	}
794
795	if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
796	{
797	char *rowHeight;
798	int i=0;
799	m_pRowHeight = new UInt[m_iNumRowsMinus1];
800	rowHeight = strtok(pRowHeight, " ,-");
801	while(rowHeight!=NULL)
802	{
803	if( i>=m_iNumRowsMinus1 )
804	{
805	printf( "The number of rows whose height are defined is larger than the allowed number of rows.\n" );
806	exit( EXIT_FAILURE );
807	}
808	*( m_pRowHeight + i ) = atoi( rowHeight );
809	rowHeight = strtok(NULL, " ,-");
810	i++;
811	}
812	if( i<m_iNumRowsMinus1 )
813	{
814	printf( "The height of some rows is not defined.\n" );
815	exit( EXIT_FAILURE );
816	}
817	}
818	else
819	{
820	m_pRowHeight = NULL;
821	}
822	#if VPS_EXTN_DIRECT_REF_LAYERS
823	for(Int layer = 0; layer < MAX_LAYERS; layer++)
824	{
825	Char* pRefLayerIds = cfg_refLayerIds[layer].empty() ? NULL: strdup(cfg_refLayerIds[layer].c_str());
826	if( m_acLayerCfg[layer].m_numDirectRefLayers > 0 )
827	{
828	char *refLayerId;
829	int i=0;
830	m_acLayerCfg[layer].m_refLayerIds = new Int[m_acLayerCfg[layer].m_numDirectRefLayers];
831	refLayerId = strtok(pRefLayerIds, " ,-");
832	while(refLayerId != NULL)
833	{
834	if( i >= m_acLayerCfg[layer].m_numDirectRefLayers )
835	{
836	printf( "The number of columns whose width are defined is larger than the allowed number of columns.\n" );
837	exit( EXIT_FAILURE );
838	}
839	*( m_acLayerCfg[layer].m_refLayerIds + i ) = atoi( refLayerId );
840	refLayerId = strtok(NULL, " ,-");
841	i++;
842	}
843	if( i < m_acLayerCfg[layer].m_numDirectRefLayers )
844	{
845	printf( "The width of some columns is not defined.\n" );
846	exit( EXIT_FAILURE );
847	}
848	}
849	else
850	{
851	m_acLayerCfg[layer].m_refLayerIds = NULL;
852	}
853	}
854	#endif
855	#if SIGNAL_BITRATE_PICRATE_IN_VPS
856	readBoolString(cfg_bitRateInfoPresentFlag, m_bitRatePicRateMaxTLayers, m_bitRateInfoPresentFlag, "bit rate info. present flag" );
857	readIntString (cfg_avgBitRate, m_bitRatePicRateMaxTLayers, m_avgBitRate, "avg. bit rate" );
858	readIntString (cfg_maxBitRate, m_bitRatePicRateMaxTLayers, m_maxBitRate, "max. bit rate" );
859	readBoolString(cfg_picRateInfoPresentFlag, m_bitRatePicRateMaxTLayers, m_picRateInfoPresentFlag, "bit rate info. present flag" );
860	readIntString (cfg_avgPicRate, m_bitRatePicRateMaxTLayers, m_avgPicRate, "avg. pic rate" );
861	readIntString (cfg_constantPicRateIdc, m_bitRatePicRateMaxTLayers, m_constantPicRateIdc, "constant pic rate Idc" );
862	#endif
863	m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str());
864
865	/* rules for input, output and internal bitdepths as per help text */
866	if (!m_internalBitDepthY) { m_internalBitDepthY = m_inputBitDepthY; }
867	if (!m_internalBitDepthC) { m_internalBitDepthC = m_internalBitDepthY; }
868	if (!m_inputBitDepthC) { m_inputBitDepthC = m_inputBitDepthY; }
869	if (!m_outputBitDepthY) { m_outputBitDepthY = m_internalBitDepthY; }
870	if (!m_outputBitDepthC) { m_outputBitDepthC = m_internalBitDepthC; }
871
872	#if !SVC_EXTENSION
873	// TODO:ChromaFmt assumes 4:2:0 below
874	switch (m_conformanceMode)
875	{
876	case 0:
877	{
878	// no conformance or padding
879	m_confLeft = m_confRight = m_confTop = m_confBottom = 0;
880	m_aiPad[1] = m_aiPad[0] = 0;
881	break;
882	}
883	case 1:
884	{
885	// automatic padding to minimum CU size
886	Int minCuSize = m_uiMaxCUHeight >> (m_uiMaxCUDepth - 1);
887	if (m_iSourceWidth % minCuSize)
888	{
889	m_aiPad[0] = m_confRight = ((m_iSourceWidth / minCuSize) + 1) * minCuSize - m_iSourceWidth;
890	m_iSourceWidth += m_confRight;
891	}
892	if (m_iSourceHeight % minCuSize)
893	{
894	m_aiPad[1] = m_confBottom = ((m_iSourceHeight / minCuSize) + 1) * minCuSize - m_iSourceHeight;
895	m_iSourceHeight += m_confBottom;
896	}
897	if (m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0)
898	{
899	fprintf(stderr, "Error: picture width is not an integer multiple of the specified chroma subsampling\n");
900	exit(EXIT_FAILURE);
901	}
902	if (m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0)
903	{
904	fprintf(stderr, "Error: picture height is not an integer multiple of the specified chroma subsampling\n");
905	exit(EXIT_FAILURE);
906	}
907	break;
908	}
909	case 2:
910	{
911	//padding
912	m_iSourceWidth += m_aiPad[0];
913	m_iSourceHeight += m_aiPad[1];
914	m_confRight = m_aiPad[0];
915	m_confBottom = m_aiPad[1];
916	break;
917	}
918	case 3:
919	{
920	// conformance
921	if ((m_confLeft == 0) && (m_confRight == 0) && (m_confTop == 0) && (m_confBottom == 0))
922	{
923	fprintf(stderr, "Warning: Conformance window enabled, but all conformance window parameters set to zero\n");
924	}
925	if ((m_aiPad[1] != 0) \|\| (m_aiPad[0]!=0))
926	{
927	fprintf(stderr, "Warning: Conformance window enabled, padding parameters will be ignored\n");
928	}
929	m_aiPad[1] = m_aiPad[0] = 0;
930	break;
931	}
932	}
933
934	// allocate slice-based dQP values
935	m_aidQP = new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ];
936	::memset( m_aidQP, 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
937
938	// handling of floating-point QP values
939	// if QP is not integer, sequence is split into two sections having QP and QP+1
940	m_iQP = (Int)( m_fQP );
941	if ( m_iQP < m_fQP )
942	{
943	Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP - m_iQP)*m_framesToBeEncoded + 0.5 );
944
945	iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
946	for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
947	{
948	m_aidQP[i] = 1;
949	}
950	}
951
952	// reading external dQP description from file
953	if ( m_pchdQPFile )
954	{
955	FILE* fpt=fopen( m_pchdQPFile, "r" );
956	if ( fpt )
957	{
958	Int iValue;
959	Int iPOC = 0;
960	while ( iPOC < m_framesToBeEncoded )
961	{
962	if ( fscanf(fpt, "%d", &iValue ) == EOF ) break;
963	m_aidQP[ iPOC ] = iValue;
964	iPOC++;
965	}
966	fclose(fpt);
967	}
968	}
969	m_iWaveFrontSubstreams = m_iWaveFrontSynchro ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1;
970	#endif
971	#if J0149_TONE_MAPPING_SEI
972	if( m_toneMappingInfoSEIEnabled && !m_toneMapCancelFlag )
973	{
974	Char* pcStartOfCodedInterval = cfg_startOfCodedInterval.empty() ? NULL: strdup(cfg_startOfCodedInterval.c_str());
975	Char* pcCodedPivotValue = cfg_codedPivotValue.empty() ? NULL: strdup(cfg_codedPivotValue.c_str());
976	Char* pcTargetPivotValue = cfg_targetPivotValue.empty() ? NULL: strdup(cfg_targetPivotValue.c_str());
977	if( m_toneMapModelId == 2 && pcStartOfCodedInterval )
978	{
979	char *startOfCodedInterval;
980	UInt num = 1u<< m_toneMapTargetBitDepth;
981	m_startOfCodedInterval = new Int[num];
982	::memset( m_startOfCodedInterval, 0, sizeof(Int)*num );
983	startOfCodedInterval = strtok(pcStartOfCodedInterval, " .");
984	int i = 0;
985	while( startOfCodedInterval && ( i < num ) )
986	{
987	m_startOfCodedInterval[i] = atoi( startOfCodedInterval );
988	startOfCodedInterval = strtok(NULL, " .");
989	i++;
990	}
991	}
992	else
993	{
994	m_startOfCodedInterval = NULL;
995	}
996	if( ( m_toneMapModelId == 3 ) && ( m_numPivots > 0 ) )
997	{
998	if( pcCodedPivotValue && pcTargetPivotValue )
999	{
1000	char *codedPivotValue;
1001	char *targetPivotValue;
1002	m_codedPivotValue = new Int[m_numPivots];
1003	m_targetPivotValue = new Int[m_numPivots];
1004	::memset( m_codedPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1005	::memset( m_targetPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1006	codedPivotValue = strtok(pcCodedPivotValue, " .");
1007	int i=0;
1008	while(codedPivotValue&&i<m_numPivots)
1009	{
1010	m_codedPivotValue[i] = atoi( codedPivotValue );
1011	codedPivotValue = strtok(NULL, " .");
1012	i++;
1013	}
1014	i=0;
1015	targetPivotValue = strtok(pcTargetPivotValue, " .");
1016	while(targetPivotValue&&i<m_numPivots)
1017	{
1018	m_targetPivotValue[i]= atoi( targetPivotValue );
1019	targetPivotValue = strtok(NULL, " .");
1020	i++;
1021	}
1022	}
1023	}
1024	else
1025	{
1026	m_codedPivotValue = NULL;
1027	m_targetPivotValue = NULL;
1028	}
1029	}
1030	#endif
1031	// check validity of input parameters
1032	xCheckParameter();
1033
1034	// set global varibles
1035	xSetGlobal();
1036
1037	// print-out parameters
1038	xPrintParameter();
1039
1040	return true;
1041	}
1042	#if SIGNAL_BITRATE_PICRATE_IN_VPS
1043	Void readBoolString(const string inpString, const Int numEntries, Bool* &memberArray, const char *elementName)
1044	{
1045	Char* inpArray = inpString.empty() ? NULL : strdup(inpString.c_str());
1046	Int i = 0;
1047	if(numEntries)
1048	{
1049	Char* tempArray = strtok(inpArray, " ,-");
1050	memberArray = new Bool[numEntries];
1051	while( tempArray != NULL )
1052	{
1053	if( i >= numEntries )
1054	{
1055	printf( "The number of %s defined is larger than the allowed number\n", elementName );
1056	exit( EXIT_FAILURE );
1057	}
1058	assert( (atoi(tempArray) == 0) \|\| (atoi(tempArray) == 1) );
1059	*( memberArray + i ) = atoi(tempArray);
1060	tempArray = strtok(NULL, " ,-");
1061	i++;
1062	}
1063	if( i < numEntries )
1064	{
1065	printf( "Some %s are not defined\n", elementName );
1066	exit( EXIT_FAILURE );
1067	}
1068	}
1069	else
1070	{
1071	memberArray = NULL;
1072	}
1073	}
1074
1075	Void readIntString(const string inpString, const Int numEntries, Int* &memberArray, const char *elementName)
1076	{
1077	Char* inpArray = inpString.empty() ? NULL : strdup(inpString.c_str());
1078	Int i = 0;
1079	if(numEntries)
1080	{
1081	Char* tempArray = strtok(inpArray, " ,-");
1082	memberArray = new Int[numEntries];
1083	while( tempArray != NULL )
1084	{
1085	if( i >= numEntries )
1086	{
1087	printf( "The number of %s defined is larger than the allowed number\n", elementName );
1088	exit( EXIT_FAILURE );
1089	}
1090	*( memberArray + i ) = atoi(tempArray);
1091	tempArray = strtok(NULL, " ,-");
1092	i++;
1093	}
1094	if( i < numEntries )
1095	{
1096	printf( "Some %s are not defined\n", elementName );
1097	exit( EXIT_FAILURE );
1098	}
1099	}
1100	else
1101	{
1102	memberArray = NULL;
1103	}
1104	}
1105	#endif
1106	// ====================================================================================================================
1107	// Private member functions
1108	// ====================================================================================================================
1109
1110	Bool confirmPara(Bool bflag, const Char* message);
1111
1112	Void TAppEncCfg::xCheckParameter()
1113	{
1114	if (!m_decodedPictureHashSEIEnabled)
1115	{
1116	fprintf(stderr, "******************************************************************\n");
1117	fprintf(stderr, " WARNING: --SEIDecodedPictureHash is now disabled by default. \n");
1118	fprintf(stderr, " Automatic verification of decoded pictures by a \n");
1119	fprintf(stderr, " decoder requires this option to be enabled. \n");
1120	fprintf(stderr, "******************************************************************\n");
1121	}
1122
1123	Bool check_failed = false; /* abort if there is a fatal configuration problem */
1124	#define xConfirmPara(a,b) check_failed \|= confirmPara(a,b)
1125	// check range of parameters
1126	xConfirmPara( m_inputBitDepthY < 8, "InputBitDepth must be at least 8" );
1127	xConfirmPara( m_inputBitDepthC < 8, "InputBitDepthC must be at least 8" );
1128	#if !SVC_EXTENSION
1129	xConfirmPara( m_iFrameRate <= 0, "Frame rate must be more than 1" );
1130	#endif
1131	xConfirmPara( m_framesToBeEncoded <= 0, "Total Number Of Frames encoded must be more than 0" );
1132	xConfirmPara( m_iGOPSize < 1 , "GOP Size must be greater or equal to 1" );
1133	xConfirmPara( m_iGOPSize > 1 && m_iGOPSize % 2, "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
1134	#if !SVC_EXTENSION
1135	xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) \|\| m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
1136	#endif
1137	xConfirmPara( m_iDecodingRefreshType < 0 \|\| m_iDecodingRefreshType > 2, "Decoding Refresh Type must be equal to 0, 1 or 2" );
1138	#if !SVC_EXTENSION
1139	xConfirmPara( m_iQP < -6 * (m_internalBitDepthY - 8) \|\| m_iQP > 51, "QP exceeds supported range (-QpBDOffsety to 51)" );
1140	#endif
1141	xConfirmPara( m_loopFilterBetaOffsetDiv2 < -13 \|\| m_loopFilterBetaOffsetDiv2 > 13, "Loop Filter Beta Offset div. 2 exceeds supported range (-13 to 13)");
1142	xConfirmPara( m_loopFilterTcOffsetDiv2 < -13 \|\| m_loopFilterTcOffsetDiv2 > 13, "Loop Filter Tc Offset div. 2 exceeds supported range (-13 to 13)");
1143	xConfirmPara( m_iFastSearch < 0 \|\| m_iFastSearch > 2, "Fast Search Mode is not supported value (0:Full search 1:Diamond 2:PMVFAST)" );
1144	xConfirmPara( m_iSearchRange < 0 , "Search Range must be more than 0" );
1145	xConfirmPara( m_bipredSearchRange < 0 , "Search Range must be more than 0" );
1146	xConfirmPara( m_iMaxDeltaQP > 7, "Absolute Delta QP exceeds supported range (0 to 7)" );
1147	xConfirmPara( m_iMaxCuDQPDepth > m_uiMaxCUDepth - 1, "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
1148
1149	xConfirmPara( m_cbQpOffset < -12, "Min. Chroma Cb QP Offset is -12" );
1150	xConfirmPara( m_cbQpOffset > 12, "Max. Chroma Cb QP Offset is 12" );
1151	xConfirmPara( m_crQpOffset < -12, "Min. Chroma Cr QP Offset is -12" );
1152	xConfirmPara( m_crQpOffset > 12, "Max. Chroma Cr QP Offset is 12" );
1153
1154	xConfirmPara( m_iQPAdaptationRange <= 0, "QP Adaptation Range must be more than 0" );
1155	#if !SVC_EXTENSION
1156	if (m_iDecodingRefreshType == 2)
1157	{
1158	xConfirmPara( m_iIntraPeriod > 0 && m_iIntraPeriod <= m_iGOPSize , "Intra period must be larger than GOP size for periodic IDR pictures");
1159	}
1160	#endif
1161	xConfirmPara( (m_uiMaxCUWidth >> m_uiMaxCUDepth) < 4, "Minimum partition width size should be larger than or equal to 8");
1162	xConfirmPara( (m_uiMaxCUHeight >> m_uiMaxCUDepth) < 4, "Minimum partition height size should be larger than or equal to 8");
1163	xConfirmPara( m_uiMaxCUWidth < 16, "Maximum partition width size should be larger than or equal to 16");
1164	xConfirmPara( m_uiMaxCUHeight < 16, "Maximum partition height size should be larger than or equal to 16");
1165	#if !SVC_EXTENSION
1166	xConfirmPara( (m_iSourceWidth % (m_uiMaxCUWidth >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame width must be a multiple of the minimum CU size");
1167	xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame height must be a multiple of the minimum CU size");
1168	#endif
1169
1170	xConfirmPara( m_uiQuadtreeTULog2MinSize < 2, "QuadtreeTULog2MinSize must be 2 or greater.");
1171	xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5, "QuadtreeTULog2MaxSize must be 5 or smaller.");
1172	xConfirmPara( (1<<m_uiQuadtreeTULog2MaxSize) > m_uiMaxCUWidth, "QuadtreeTULog2MaxSize must be log2(maxCUSize) or smaller.");
1173
1174	xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize, "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize.");
1175	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1176	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUHeight>>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1177	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUWidth >> m_uiMaxCUDepth ), "Minimum CU width must be greater than minimum transform size." );
1178	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." );
1179	xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1, "QuadtreeTUMaxDepthInter must be greater than or equal to 1" );
1180	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" );
1181	xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1, "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" );
1182	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" );
1183
1184	xConfirmPara( m_maxNumMergeCand < 1, "MaxNumMergeCand must be 1 or greater.");
1185	xConfirmPara( m_maxNumMergeCand > 5, "MaxNumMergeCand must be 5 or smaller.");
1186
1187	#if !SVC_EXTENSION
1188	#if ADAPTIVE_QP_SELECTION
1189	xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
1190	xConfirmPara( m_bUseAdaptQpSelect == true && (m_cbQpOffset !=0 \|\| m_crQpOffset != 0 ), "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
1191	#endif
1192	#endif
1193
1194	if( m_usePCM)
1195	{
1196	xConfirmPara( m_uiPCMLog2MinSize < 3, "PCMLog2MinSize must be 3 or greater.");
1197	xConfirmPara( m_uiPCMLog2MinSize > 5, "PCMLog2MinSize must be 5 or smaller.");
1198	xConfirmPara( m_pcmLog2MaxSize > 5, "PCMLog2MaxSize must be 5 or smaller.");
1199	xConfirmPara( m_pcmLog2MaxSize < m_uiPCMLog2MinSize, "PCMLog2MaxSize must be equal to or greater than m_uiPCMLog2MinSize.");
1200	}
1201
1202	xConfirmPara( m_sliceMode < 0 \|\| m_sliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
1203	if (m_sliceMode!=0)
1204	{
1205	xConfirmPara( m_sliceArgument < 1 , "SliceArgument should be larger than or equal to 1" );
1206	}
1207	xConfirmPara( m_sliceSegmentMode < 0 \|\| m_sliceSegmentMode > 3, "SliceSegmentMode exceeds supported range (0 to 3)" );
1208	if (m_sliceSegmentMode!=0)
1209	{
1210	xConfirmPara( m_sliceSegmentArgument < 1 , "SliceSegmentArgument should be larger than or equal to 1" );
1211	}
1212
1213	Bool tileFlag = (m_iNumColumnsMinus1 > 0 \|\| m_iNumRowsMinus1 > 0 );
1214	xConfirmPara( tileFlag && m_iWaveFrontSynchro, "Tile and Wavefront can not be applied together");
1215
1216	//TODO:ChromaFmt assumes 4:2:0 below
1217	#if !SVC_EXTENSION
1218	xConfirmPara( m_iSourceWidth % TComSPS::getWinUnitX(CHROMA_420) != 0, "Picture width must be an integer multiple of the specified chroma subsampling");
1219	xConfirmPara( m_iSourceHeight % TComSPS::getWinUnitY(CHROMA_420) != 0, "Picture height must be an integer multiple of the specified chroma subsampling");
1220
1221	xConfirmPara( m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0, "Horizontal padding must be an integer multiple of the specified chroma subsampling");
1222	xConfirmPara( m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0, "Vertical padding must be an integer multiple of the specified chroma subsampling");
1223
1224	xConfirmPara( m_confLeft % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left conformance window offset must be an integer multiple of the specified chroma subsampling");
1225	xConfirmPara( m_confRight % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right conformance window offset must be an integer multiple of the specified chroma subsampling");
1226	xConfirmPara( m_confTop % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top conformance window offset must be an integer multiple of the specified chroma subsampling");
1227	xConfirmPara( m_confBottom % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom conformance window offset must be an integer multiple of the specified chroma subsampling");
1228	#endif
1229
1230	// max CU width and height should be power of 2
1231	UInt ui = m_uiMaxCUWidth;
1232	while(ui)
1233	{
1234	ui >>= 1;
1235	if( (ui & 1) == 1)
1236	xConfirmPara( ui != 1 , "Width should be 2^n");
1237	}
1238	ui = m_uiMaxCUHeight;
1239	while(ui)
1240	{
1241	ui >>= 1;
1242	if( (ui & 1) == 1)
1243	xConfirmPara( ui != 1 , "Height should be 2^n");
1244	}
1245
1246
1247	/* if this is an intra-only sequence, ie IntraPeriod=1, don't verify the GOP structure
1248	* This permits the ability to omit a GOP structure specification */
1249	#if SVC_EXTENSION
1250	for(UInt layer = 0; layer < MAX_LAYERS; layer++)
1251	{
1252	Int m_iIntraPeriod = m_acLayerCfg[layer].m_iIntraPeriod;
1253	#endif
1254	if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
1255	m_GOPList[0] = GOPEntry();
1256	m_GOPList[0].m_QPFactor = 1;
1257	m_GOPList[0].m_betaOffsetDiv2 = 0;
1258	m_GOPList[0].m_tcOffsetDiv2 = 0;
1259	m_GOPList[0].m_POC = 1;
1260	m_GOPList[0].m_numRefPicsActive = 4;
1261	}
1262	#if SVC_EXTENSION
1263	}
1264	#endif
1265
1266	Bool verifiedGOP=false;
1267	Bool errorGOP=false;
1268	Int checkGOP=1;
1269	Int numRefs = 1;
1270	Int refList[MAX_NUM_REF_PICS+1];
1271	refList[0]=0;
1272	Bool isOK[MAX_GOP];
1273	for(Int i=0; i<MAX_GOP; i++)
1274	{
1275	isOK[i]=false;
1276	}
1277	Int numOK=0;
1278	#if !SVC_EXTENSION
1279	xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
1280	#endif
1281
1282	for(Int i=0; i<m_iGOPSize; i++)
1283	{
1284	if(m_GOPList[i].m_POC==m_iGOPSize)
1285	{
1286	xConfirmPara( m_GOPList[i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
1287	}
1288	}
1289
1290	#if SVC_EXTENSION
1291	xConfirmPara( m_numLayers > MAX_LAYERS , "Number of layers in config file is greater than MAX_LAYERS" );
1292	m_numLayers = m_numLayers > MAX_LAYERS ? MAX_LAYERS : m_numLayers;
1293
1294	// verify layer configuration parameters
1295	for(UInt layer=0; layer<m_numLayers; layer++)
1296	{
1297	if(m_acLayerCfg[layer].xCheckParameter())
1298	{
1299	printf("\nError: invalid configuration parameter found in layer %d \n", layer);
1300	check_failed = true;
1301	}
1302	}
1303	#endif
1304
1305	#if SVC_EXTENSION
1306	// verify layer configuration parameters
1307	for(UInt layer=0; layer<m_numLayers; layer++)
1308	{
1309	Int m_iIntraPeriod = m_acLayerCfg[layer].m_iIntraPeriod;
1310	#endif
1311	if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
1312	{
1313	for(Int i=0; i<m_iGOPSize; i++)
1314	{
1315	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)" );
1316	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)" );
1317	}
1318	}
1319	#if SVC_EXTENSION
1320	}
1321	#endif
1322
1323	m_extraRPSs=0;
1324	//start looping through frames in coding order until we can verify that the GOP structure is correct.
1325	while(!verifiedGOP&&!errorGOP)
1326	{
1327	Int curGOP = (checkGOP-1)%m_iGOPSize;
1328	Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC;
1329	if(m_GOPList[curGOP].m_POC<0)
1330	{
1331	printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
1332	errorGOP=true;
1333	}
1334	else
1335	{
1336	//check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
1337	Bool beforeI = false;
1338	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
1339	{
1340	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1341	if(absPOC < 0)
1342	{
1343	beforeI=true;
1344	}
1345	else
1346	{
1347	Bool found=false;
1348	for(Int j=0; j<numRefs; j++)
1349	{
1350	if(refList[j]==absPOC)
1351	{
1352	found=true;
1353	for(Int k=0; k<m_iGOPSize; k++)
1354	{
1355	if(absPOC%m_iGOPSize == m_GOPList[k].m_POC%m_iGOPSize)
1356	{
1357	if(m_GOPList[k].m_temporalId==m_GOPList[curGOP].m_temporalId)
1358	{
1359	m_GOPList[k].m_refPic = true;
1360	}
1361	m_GOPList[curGOP].m_usedByCurrPic[i]=m_GOPList[k].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1362	}
1363	}
1364	}
1365	}
1366	if(!found)
1367	{
1368	printf("\nError: ref pic %d is not available for GOP frame %d\n",m_GOPList[curGOP].m_referencePics[i],curGOP+1);
1369	errorGOP=true;
1370	}
1371	}
1372	}
1373	if(!beforeI&&!errorGOP)
1374	{
1375	//all ref frames were present
1376	if(!isOK[curGOP])
1377	{
1378	numOK++;
1379	isOK[curGOP]=true;
1380	if(numOK==m_iGOPSize)
1381	{
1382	verifiedGOP=true;
1383	}
1384	}
1385	}
1386	else
1387	{
1388	//create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
1389	m_GOPList[m_iGOPSize+m_extraRPSs]=m_GOPList[curGOP];
1390	Int newRefs=0;
1391	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
1392	{
1393	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1394	if(absPOC>=0)
1395	{
1396	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
1397	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
1398	newRefs++;
1399	}
1400	}
1401	Int numPrefRefs = m_GOPList[curGOP].m_numRefPicsActive;
1402
1403	for(Int offset = -1; offset>-checkGOP; offset--)
1404	{
1405	//step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
1406	Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
1407	Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_GOPList[offGOP].m_POC;
1408	if(offPOC>=0&&m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId)
1409	{
1410	Bool newRef=false;
1411	for(Int i=0; i<numRefs; i++)
1412	{
1413	if(refList[i]==offPOC)
1414	{
1415	newRef=true;
1416	}
1417	}
1418	for(Int i=0; i<newRefs; i++)
1419	{
1420	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[i]==offPOC-curPOC)
1421	{
1422	newRef=false;
1423	}
1424	}
1425	if(newRef)
1426	{
1427	Int insertPoint=newRefs;
1428	//this picture can be added, find appropriate place in list and insert it.
1429	if(m_GOPList[offGOP].m_temporalId==m_GOPList[curGOP].m_temporalId)
1430	{
1431	m_GOPList[offGOP].m_refPic = true;
1432	}
1433	for(Int j=0; j<newRefs; j++)
1434	{
1435	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]<offPOC-curPOC\|\|m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]>0)
1436	{
1437	insertPoint = j;
1438	break;
1439	}
1440	}
1441	Int prev = offPOC-curPOC;
1442	Int prevUsed = m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1443	for(Int j=insertPoint; j<newRefs+1; j++)
1444	{
1445	Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j];
1446	Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j];
1447	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]=prev;
1448	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j]=prevUsed;
1449	prevUsed=newUsed;
1450	prev=newPrev;
1451	}
1452	newRefs++;
1453	}
1454	}
1455	if(newRefs>=numPrefRefs)
1456	{
1457	break;
1458	}
1459	}
1460	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics=newRefs;
1461	m_GOPList[m_iGOPSize+m_extraRPSs].m_POC = curPOC;
1462	if (m_extraRPSs == 0)
1463	{
1464	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 0;
1465	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = 0;
1466	}
1467	else
1468	{
1469	Int rIdx = m_iGOPSize + m_extraRPSs - 1;
1470	Int refPOC = m_GOPList[rIdx].m_POC;
1471	Int refPics = m_GOPList[rIdx].m_numRefPics;
1472	Int newIdc=0;
1473	for(Int i = 0; i<= refPics; i++)
1474	{
1475	Int deltaPOC = ((i != refPics)? m_GOPList[rIdx].m_referencePics[i] : 0); // check if the reference abs POC is >= 0
1476	Int absPOCref = refPOC+deltaPOC;
1477	Int refIdc = 0;
1478	for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics; j++)
1479	{
1480	if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j])
1481	{
1482	if (m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j])
1483	{
1484	refIdc = 1;
1485	}
1486	else
1487	{
1488	refIdc = 2;
1489	}
1490	}
1491	}
1492	m_GOPList[m_iGOPSize+m_extraRPSs].m_refIdc[newIdc]=refIdc;
1493	newIdc++;
1494	}
1495	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1;
1496	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = newIdc;
1497	m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC;
1498	}
1499	curGOP=m_iGOPSize+m_extraRPSs;
1500	m_extraRPSs++;
1501	}
1502	numRefs=0;
1503	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
1504	{
1505	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1506	if(absPOC >= 0)
1507	{
1508	refList[numRefs]=absPOC;
1509	numRefs++;
1510	}
1511	}
1512	refList[numRefs]=curPOC;
1513	numRefs++;
1514	}
1515	checkGOP++;
1516	}
1517	xConfirmPara(errorGOP,"Invalid GOP structure given");
1518	m_maxTempLayer = 1;
1519	for(Int i=0; i<m_iGOPSize; i++)
1520	{
1521	if(m_GOPList[i].m_temporalId >= m_maxTempLayer)
1522	{
1523	m_maxTempLayer = m_GOPList[i].m_temporalId+1;
1524	}
1525	xConfirmPara(m_GOPList[i].m_sliceType!='B'&&m_GOPList[i].m_sliceType!='P', "Slice type must be equal to B or P");
1526	}
1527	for(Int i=0; i<MAX_TLAYER; i++)
1528	{
1529	m_numReorderPics[i] = 0;
1530	#if L0323_DPB
1531	m_maxDecPicBuffering[i] = 1;
1532	#else
1533	m_maxDecPicBuffering[i] = 0;
1534	#endif
1535	}
1536	for(Int i=0; i<m_iGOPSize; i++)
1537	{
1538	#if L0323_DPB
1539	if(m_GOPList[i].m_numRefPics+1 > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
1540	#else
1541	if(m_GOPList[i].m_numRefPics > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
1542	#endif
1543	{
1544	#if L0323_DPB
1545	m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1;
1546	#else
1547	m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics;
1548	#endif
1549	}
1550	Int highestDecodingNumberWithLowerPOC = 0;
1551	for(Int j=0; j<m_iGOPSize; j++)
1552	{
1553	if(m_GOPList[j].m_POC <= m_GOPList[i].m_POC)
1554	{
1555	highestDecodingNumberWithLowerPOC = j;
1556	}
1557	}
1558	Int numReorder = 0;
1559	for(Int j=0; j<highestDecodingNumberWithLowerPOC; j++)
1560	{
1561	if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId &&
1562	m_GOPList[j].m_POC > m_GOPList[i].m_POC)
1563	{
1564	numReorder++;
1565	}
1566	}
1567	if(numReorder > m_numReorderPics[m_GOPList[i].m_temporalId])
1568	{
1569	m_numReorderPics[m_GOPList[i].m_temporalId] = numReorder;
1570	}
1571	}
1572	for(Int i=0; i<MAX_TLAYER-1; i++)
1573	{
1574	// a lower layer can not have higher value of m_numReorderPics than a higher layer
1575	if(m_numReorderPics[i+1] < m_numReorderPics[i])
1576	{
1577	m_numReorderPics[i+1] = m_numReorderPics[i];
1578	}
1579	#if L0323_DPB
1580	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
1581	if(m_numReorderPics[i] > m_maxDecPicBuffering[i] - 1)
1582	{
1583	m_maxDecPicBuffering[i] = m_numReorderPics[i] + 1;
1584	}
1585	#else
1586	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive
1587	if(m_numReorderPics[i] > m_maxDecPicBuffering[i])
1588	{
1589	m_maxDecPicBuffering[i] = m_numReorderPics[i];
1590	}
1591	#endif
1592	// a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
1593	if(m_maxDecPicBuffering[i+1] < m_maxDecPicBuffering[i])
1594	{
1595	m_maxDecPicBuffering[i+1] = m_maxDecPicBuffering[i];
1596	}
1597	}
1598
1599
1600	#if L0323_DPB
1601	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
1602	if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1)
1603	{
1604	m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1] + 1;
1605	}
1606	#else
1607	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive
1608	if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1])
1609	{
1610	m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1];
1611	}
1612	#endif
1613
1614	#if SVC_EXTENSION // ToDo: it should be checked for the case when parameters are different for the layers
1615	for(UInt layer = 0; layer < MAX_LAYERS; layer++)
1616	{
1617	Int m_iSourceWidth = m_acLayerCfg[layer].m_iSourceWidth;
1618	Int m_iSourceHeight = m_acLayerCfg[layer].m_iSourceHeight;
1619	#endif
1620	if(m_vuiParametersPresentFlag && m_bitstreamRestrictionFlag)
1621	{
1622	Int PicSizeInSamplesY = m_iSourceWidth * m_iSourceHeight;
1623	if(tileFlag)
1624	{
1625	Int maxTileWidth = 0;
1626	Int maxTileHeight = 0;
1627	Int widthInCU = (m_iSourceWidth % m_uiMaxCUWidth) ? m_iSourceWidth/m_uiMaxCUWidth + 1: m_iSourceWidth/m_uiMaxCUWidth;
1628	Int heightInCU = (m_iSourceHeight % m_uiMaxCUHeight) ? m_iSourceHeight/m_uiMaxCUHeight + 1: m_iSourceHeight/m_uiMaxCUHeight;
1629	if(m_iUniformSpacingIdr)
1630	{
1631	maxTileWidth = m_uiMaxCUWidth*((widthInCU+m_iNumColumnsMinus1)/(m_iNumColumnsMinus1+1));
1632	maxTileHeight = m_uiMaxCUHeight*((heightInCU+m_iNumRowsMinus1)/(m_iNumRowsMinus1+1));
1633	// if only the last tile-row is one treeblock higher than the others
1634	// the maxTileHeight becomes smaller if the last row of treeblocks has lower height than the others
1635	if(!((heightInCU-1)%(m_iNumRowsMinus1+1)))
1636	{
1637	maxTileHeight = maxTileHeight - m_uiMaxCUHeight + (m_iSourceHeight % m_uiMaxCUHeight);
1638	}
1639	// if only the last tile-column is one treeblock wider than the others
1640	// the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others
1641	if(!((widthInCU-1)%(m_iNumColumnsMinus1+1)))
1642	{
1643	maxTileWidth = maxTileWidth - m_uiMaxCUWidth + (m_iSourceWidth % m_uiMaxCUWidth);
1644	}
1645	}
1646	else // not uniform spacing
1647	{
1648	if(m_iNumColumnsMinus1<1)
1649	{
1650	maxTileWidth = m_iSourceWidth;
1651	}
1652	else
1653	{
1654	Int accColumnWidth = 0;
1655	for(Int col=0; col<(m_iNumColumnsMinus1); col++)
1656	{
1657	maxTileWidth = m_pColumnWidth[col]>maxTileWidth ? m_pColumnWidth[col]:maxTileWidth;
1658	accColumnWidth += m_pColumnWidth[col];
1659	}
1660	maxTileWidth = (widthInCU-accColumnWidth)>maxTileWidth ? m_uiMaxCUWidth(widthInCU-accColumnWidth):m_uiMaxCUWidthmaxTileWidth;
1661	}
1662	if(m_iNumRowsMinus1<1)
1663	{
1664	maxTileHeight = m_iSourceHeight;
1665	}
1666	else
1667	{
1668	Int accRowHeight = 0;
1669	for(Int row=0; row<(m_iNumRowsMinus1); row++)
1670	{
1671	maxTileHeight = m_pRowHeight[row]>maxTileHeight ? m_pRowHeight[row]:maxTileHeight;
1672	accRowHeight += m_pRowHeight[row];
1673	}
1674	maxTileHeight = (heightInCU-accRowHeight)>maxTileHeight ? m_uiMaxCUHeight(heightInCU-accRowHeight):m_uiMaxCUHeightmaxTileHeight;
1675	}
1676	}
1677	Int maxSizeInSamplesY = maxTileWidth*maxTileHeight;
1678	m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/maxSizeInSamplesY-4;
1679	}
1680	else if(m_iWaveFrontSynchro)
1681	{
1682	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/((2m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4;
1683	}
1684	else if(m_sliceMode == 1)
1685	{
1686	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/(m_sliceArgumentm_uiMaxCUWidth*m_uiMaxCUHeight)-4;
1687	}
1688	else
1689	{
1690	m_minSpatialSegmentationIdc = 0;
1691	}
1692	}
1693	#if SVC_EXTENSION
1694	}
1695	#endif
1696	#if !L0034_COMBINED_LIST_CLEANUP
1697	xConfirmPara( m_bUseLComb==false && m_numReorderPics[MAX_TLAYER-1]!=0, "ListCombination can only be 0 in low delay coding (more precisely when L0 and L1 are identical)" ); // Note however this is not the full necessary condition as ref_pic_list_combination_flag can only be 0 if L0 == L1.
1698	#endif
1699	xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
1700	#if !SVC_EXTENSION
1701	xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
1702	xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
1703	#endif
1704
1705	xConfirmPara( m_decodedPictureHashSEIEnabled<0 \|\| m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n");
1706
1707	#if J0149_TONE_MAPPING_SEI
1708	if (m_toneMappingInfoSEIEnabled)
1709	{
1710	xConfirmPara( m_toneMapCodedDataBitDepth < 8 \|\| m_toneMapCodedDataBitDepth > 14 , "SEIToneMapCodedDataBitDepth must be in rage 8 to 14");
1711	xConfirmPara( m_toneMapTargetBitDepth < 1 \|\| (m_toneMapTargetBitDepth > 16 && m_toneMapTargetBitDepth < 255) , "SEIToneMapTargetBitDepth must be in rage 1 to 16 or equal to 255");
1712	xConfirmPara( m_toneMapModelId < 0 \|\| m_toneMapModelId > 4 , "SEIToneMapModelId must be in rage 0 to 4");
1713	xConfirmPara( m_cameraIsoSpeedValue == 0, "SEIToneMapCameraIsoSpeedValue shall not be equal to 0");
1714	xConfirmPara( m_extendedRangeWhiteLevel < 100, "SEIToneMapExtendedRangeWhiteLevel should be greater than or equal to 100");
1715	xConfirmPara( m_nominalBlackLevelLumaCodeValue >= m_nominalWhiteLevelLumaCodeValue, "SEIToneMapNominalWhiteLevelLumaCodeValue shall be greater than SEIToneMapNominalBlackLevelLumaCodeValue");
1716	xConfirmPara( m_extendedWhiteLevelLumaCodeValue < m_nominalWhiteLevelLumaCodeValue, "SEIToneMapExtendedWhiteLevelLumaCodeValue shall be greater than or equal to SEIToneMapNominalWhiteLevelLumaCodeValue");
1717	}
1718	#endif
1719
1720	#if RATE_CONTROL_LAMBDA_DOMAIN
1721	if ( m_RCEnableRateControl )
1722	{
1723	if ( m_RCForceIntraQP )
1724	{
1725	if ( m_RCInitialQP == 0 )
1726	{
1727	printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
1728	m_RCForceIntraQP = false;
1729	}
1730	}
1731	xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
1732	}
1733	#else
1734	if(m_enableRateCtrl)
1735	{
1736	Int numLCUInWidth = (m_iSourceWidth / m_uiMaxCUWidth) + (( m_iSourceWidth % m_uiMaxCUWidth ) ? 1 : 0);
1737	Int numLCUInHeight = (m_iSourceHeight / m_uiMaxCUHeight)+ (( m_iSourceHeight % m_uiMaxCUHeight) ? 1 : 0);
1738	Int numLCUInPic = numLCUInWidth * numLCUInHeight;
1739
1740	xConfirmPara( (numLCUInPic % m_numLCUInUnit) != 0, "total number of LCUs in a frame should be completely divided by NumLCUInUnit" );
1741
1742	m_iMaxDeltaQP = MAX_DELTA_QP;
1743	m_iMaxCuDQPDepth = MAX_CUDQP_DEPTH;
1744	}
1745	#endif
1746
1747	xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagValue, "CUTransquantBypassFlagValue cannot be 1 when TransquantBypassEnableFlag is 0");
1748
1749	xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2");
1750	#if L0444_FPA_TYPE
1751	if (m_framePackingSEIEnabled)
1752	{
1753	xConfirmPara(m_framePackingSEIType < 3 \|\| m_framePackingSEIType > 5 , "SEIFramePackingType must be in rage 3 to 5");
1754	}
1755	#endif
1756	#if VPS_EXTN_DIRECT_REF_LAYERS
1757	xConfirmPara( (m_acLayerCfg[0].m_numDirectRefLayers != 0) && (m_acLayerCfg[0].m_numDirectRefLayers != -1), "Layer 0 cannot have any reference layers" );
1758	// NOTE: m_numDirectRefLayers (for any layer) could be -1 (not signalled in cfg), in which case only the "previous layer" would be taken for reference
1759	for(Int layer = 1; layer < MAX_LAYERS; layer++)
1760	{
1761	xConfirmPara(m_acLayerCfg[layer].m_numDirectRefLayers > layer, "Cannot reference more layers than before current layer");
1762	for(Int i = 0; i < m_acLayerCfg[layer].m_numDirectRefLayers; i++)
1763	{
1764	xConfirmPara(m_acLayerCfg[layer].m_refLayerIds[i] > layer, "Cannot reference higher layers");
1765	xConfirmPara(m_acLayerCfg[layer].m_refLayerIds[i] == layer, "Cannot reference the current layer itself");
1766	}
1767	}
1768	#endif
1769	#undef xConfirmPara
1770	if (check_failed)
1771	{
1772	exit(EXIT_FAILURE);
1773	}
1774	}
1775
1776	/** \todo use of global variables should be removed later
1777	*/
1778	Void TAppEncCfg::xSetGlobal()
1779	{
1780	// set max CU width & height
1781	g_uiMaxCUWidth = m_uiMaxCUWidth;
1782	g_uiMaxCUHeight = m_uiMaxCUHeight;
1783
1784	// compute actual CU depth with respect to config depth and max transform size
1785	g_uiAddCUDepth = 0;
1786	while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth ) ) ) g_uiAddCUDepth++;
1787
1788	m_uiMaxCUDepth += g_uiAddCUDepth;
1789	g_uiAddCUDepth++;
1790	g_uiMaxCUDepth = m_uiMaxCUDepth;
1791
1792	// set internal bit-depth and constants
1793	g_bitDepthY = m_internalBitDepthY;
1794	g_bitDepthC = m_internalBitDepthC;
1795
1796	g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
1797	g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
1798	}
1799
1800	Void TAppEncCfg::xPrintParameter()
1801	{
1802	printf("\n");
1803	#if SVC_EXTENSION
1804	printf("Total number of layers : %d\n", m_numLayers );
1805	for(UInt layer=0; layer<m_numLayers; layer++)
1806	{
1807	printf("=== Layer %d settings === \n", layer);
1808	m_acLayerCfg[layer].xPrintParameter();
1809	printf("\n");
1810	}
1811	printf("=== Common configuration settings === \n");
1812	printf("Bitstream File : %s\n", m_pBitstreamFile );
1813	#else
1814	printf("Input File : %s\n", m_pchInputFile );
1815	printf("Bitstream File : %s\n", m_pchBitstreamFile );
1816	printf("Reconstruction File : %s\n", m_pchReconFile );
1817	printf("Real Format : %dx%d %dHz\n", m_iSourceWidth - m_confLeft - m_confRight, m_iSourceHeight - m_confTop - m_confBottom, m_iFrameRate );
1818	printf("Internal Format : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
1819	#endif
1820	printf("Frame index : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
1821	printf("CU size / depth : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
1822	printf("RQT trans. size (min / max) : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
1823	printf("Max RQT depth inter : %d\n", m_uiQuadtreeTUMaxDepthInter);
1824	printf("Max RQT depth intra : %d\n", m_uiQuadtreeTUMaxDepthIntra);
1825	printf("Min PCM size : %d\n", 1 << m_uiPCMLog2MinSize);
1826	printf("Motion search range : %d\n", m_iSearchRange );
1827	#if !SVC_EXTENSION
1828	printf("Intra period : %d\n", m_iIntraPeriod );
1829	#endif
1830	printf("Decoding refresh type : %d\n", m_iDecodingRefreshType );
1831	#if !SVC_EXTENSION
1832	printf("QP : %5.2f\n", m_fQP );
1833	#endif
1834	printf("Max dQP signaling depth : %d\n", m_iMaxCuDQPDepth);
1835
1836	printf("Cb QP Offset : %d\n", m_cbQpOffset );
1837	printf("Cr QP Offset : %d\n", m_crQpOffset);
1838
1839	printf("QP adaptation : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
1840	printf("GOP size : %d\n", m_iGOPSize );
1841	printf("Internal bit depth : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC );
1842	printf("PCM sample bit depth : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma );
1843	#if RATE_CONTROL_LAMBDA_DOMAIN
1844	printf("RateControl : %d\n", m_RCEnableRateControl );
1845	if(m_RCEnableRateControl)
1846	{
1847	printf("TargetBitrate : %d\n", m_RCTargetBitrate );
1848	printf("KeepHierarchicalBit : %d\n", m_RCKeepHierarchicalBit );
1849	printf("LCULevelRC : %d\n", m_RCLCULevelRC );
1850	printf("UseLCUSeparateModel : %d\n", m_RCUseLCUSeparateModel );
1851	printf("InitialQP : %d\n", m_RCInitialQP );
1852	printf("ForceIntraQP : %d\n", m_RCForceIntraQP );
1853	}
1854	#else
1855	printf("RateControl : %d\n", m_enableRateCtrl);
1856	if(m_enableRateCtrl)
1857	{
1858	printf("TargetBitrate : %d\n", m_targetBitrate);
1859	printf("NumLCUInUnit : %d\n", m_numLCUInUnit);
1860	}
1861	#endif
1862	printf("Max Num Merge Candidates : %d\n", m_maxNumMergeCand);
1863	printf("\n");
1864
1865	printf("TOOL CFG: ");
1866	printf("IBD:%d ", g_bitDepthY > m_inputBitDepthY \|\| g_bitDepthC > m_inputBitDepthC);
1867	printf("HAD:%d ", m_bUseHADME );
1868	printf("SRD:%d ", m_bUseSBACRD );
1869	printf("RDQ:%d ", m_useRDOQ );
1870	printf("RDQTS:%d ", m_useRDOQTS );
1871	#if L0232_RD_PENALTY
1872	printf("RDpenalty:%d ", m_rdPenalty );
1873	#endif
1874	printf("SQP:%d ", m_uiDeltaQpRD );
1875	printf("ASR:%d ", m_bUseASR );
1876	#if !L0034_COMBINED_LIST_CLEANUP
1877	printf("LComb:%d ", m_bUseLComb );
1878	#endif
1879	printf("FEN:%d ", m_bUseFastEnc );
1880	printf("ECU:%d ", m_bUseEarlyCU );
1881	printf("FDM:%d ", m_useFastDecisionForMerge );
1882	printf("CFM:%d ", m_bUseCbfFastMode );
1883	printf("ESD:%d ", m_useEarlySkipDetection );
1884	printf("RQT:%d ", 1 );
1885	printf("TransformSkip:%d ", m_useTransformSkip );
1886	printf("TransformSkipFast:%d ", m_useTransformSkipFast );
1887	printf("Slice: M=%d ", m_sliceMode);
1888	if (m_sliceMode!=0)
1889	{
1890	printf("A=%d ", m_sliceArgument);
1891	}
1892	printf("SliceSegment: M=%d ",m_sliceSegmentMode);
1893	if (m_sliceSegmentMode!=0)
1894	{
1895	printf("A=%d ", m_sliceSegmentArgument);
1896	}
1897	printf("CIP:%d ", m_bUseConstrainedIntraPred);
1898	printf("SAO:%d ", (m_bUseSAO)?(1):(0));
1899	printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
1900	printf("SAOLcuBasedOptimization:%d ", (m_saoLcuBasedOptimization)?(1):(0));
1901
1902	printf("LosslessCuEnabled:%d ", (m_useLossless)? 1:0 );
1903	printf("WPP:%d ", (Int)m_useWeightedPred);
1904	printf("WPB:%d ", (Int)m_useWeightedBiPred);
1905	printf("PME:%d ", m_log2ParallelMergeLevel);
1906	#if !SVC_EXTENSION
1907	printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d",
1908	m_iWaveFrontSynchro, m_iWaveFrontSubstreams);
1909	#endif
1910	printf(" ScalingList:%d ", m_useScalingListId );
1911	printf("TMVPMode:%d ", m_TMVPModeId );
1912	#if ADAPTIVE_QP_SELECTION
1913	printf("AQpS:%d", m_bUseAdaptQpSelect );
1914	#endif
1915
1916	printf(" SignBitHidingFlag:%d ", m_signHideFlag);
1917	#if SVC_EXTENSION
1918	printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 );
1919	#if AVC_BASE
1920	printf("AvcBase:%d ", m_avcBaseLayerFlag ? 1 : 0);
1921	#else
1922	printf("AvcBase:%d ", 0);
1923	#endif
1924	#if REF_IDX_FRAMEWORK
1925	printf("REF_IDX_FRAMEWORK:%d ", REF_IDX_FRAMEWORK);
1926	printf("EL_RAP_SliceType: %d ", m_elRapSliceBEnabled);
1927	printf("REF_IDX_ME_ZEROMV: %d ", REF_IDX_ME_ZEROMV);
1928	printf("ENCODER_FAST_MODE: %d ", ENCODER_FAST_MODE);
1929	printf("REF_IDX_MFM: %d ", REF_IDX_MFM);
1930	#elif INTRA_BL
1931	printf("INTRA_BL:%d ", INTRA_BL);
1932	#if !AVC_BASE
1933	printf("SVC_MVP:%d ", SVC_MVP );
1934	printf("SVC_BL_CAND_INTRA:%d", SVC_BL_CAND_INTRA );
1935	#endif
1936	#endif
1937	#else
1938	printf("RecalQP:%d", m_recalculateQPAccordingToLambda ? 1 : 0 );
1939	#endif
1940	printf("\n\n");
1941
1942	fflush(stdout);
1943	}
1944
1945	Bool confirmPara(Bool bflag, const Char* message)
1946	{
1947	if (!bflag)
1948	return false;
1949
1950	printf("Error: %s\n",message);
1951	return true;
1952	}
1953
1954	//! \}

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

Download in other formats: