Context navigation

TAppEncCfg.cpp @ 175

Visit:

Last change on this file since 175 was 175, checked in by qualcomm, 12 years ago

Scaled reference layer offsets in SPS (MACRO: SCALED_REF_LAYER_OFFSETS)

M0309: Signal scaled reference layer offsets in the SPS and use it for upsampling and MV prediction.

From: Adarsh K. Ramasubramonian <aramasub@…>

File size: 93.3 KB

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

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

JCT-VC SHVC

Context navigation

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

Download in other formats: