Context navigation

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

Visit:

Last change on this file since 959 was 958, checked in by qualcomm, 10 years ago
Fix the bug in the assertion for PTL
Property svn:eol-style set to `native`
File size: 194.8 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	* All rights reserved.
8	*
9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions are met:
11	*
12	* * Redistributions of source code must retain the above copyright notice,
13	* this list of conditions and the following disclaimer.
14	* * Redistributions in binary form must reproduce the above copyright notice,
15	* this list of conditions and the following disclaimer in the documentation
16	* and/or other materials provided with the distribution.
17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18	* be used to endorse or promote products derived from this software without
19	* specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31	* THE POSSIBILITY OF SUCH DAMAGE.
32	*/
33
34	/** \file TAppEncCfg.cpp
35	\brief Handle encoder configuration parameters
36	*/
37
38	#include <stdlib.h>
39	#include <cassert>
40	#include <cstring>
41	#include <string>
42	#include "TLibCommon/TComRom.h"
43	#include "TAppEncCfg.h"
44
45	static istream& operator>>(istream &, Level::Name &);
46	static istream& operator>>(istream &, Level::Tier &);
47	static istream& operator>>(istream &, Profile::Name &);
48
49	#include "TAppCommon/program_options_lite.h"
50	#include "TLibEncoder/TEncRateCtrl.h"
51	#ifdef WIN32
52	#define strdup _strdup
53	#endif
54
55	using namespace std;
56	namespace po = df::program_options_lite;
57
58	//! \ingroup TAppEncoder
59	//! \{
60
61	// ====================================================================================================================
62	// Constructor / destructor / initialization / destroy
63	// ====================================================================================================================
64
65	#if SVC_EXTENSION
66	TAppEncCfg::TAppEncCfg()
67	: m_pBitstreamFile()
68	#if AVC_BASE
69	#if VPS_AVC_BL_FLAG_REMOVAL
70	, m_nonHEVCBaseLayerFlag(0)
71	#else
72	, m_avcBaseLayerFlag(0)
73	#endif
74	#endif
75	, m_maxTidRefPresentFlag(1)
76	#if OUTPUT_LAYER_SETS_CONFIG
77	, m_defaultTargetOutputLayerIdc (-1)
78	, m_numOutputLayerSets (-1)
79	#endif
80	, m_scalingListFile()
81	, m_elRapSliceBEnabled(0)
82	{
83	for(UInt layer=0; layer<MAX_LAYERS; layer++)
84	{
85	m_acLayerCfg[layer].setAppEncCfg(this);
86	}
87	memset( m_scalabilityMask, 0, sizeof(m_scalabilityMask) );
88	}
89	#else
90	TAppEncCfg::TAppEncCfg()
91	: m_pchInputFile()
92	, m_pchBitstreamFile()
93	, m_pchReconFile()
94	, m_pchdQPFile()
95	, m_scalingListFile()
96	{
97	m_aidQP = NULL;
98	m_startOfCodedInterval = NULL;
99	m_codedPivotValue = NULL;
100	m_targetPivotValue = NULL;
101	#if Q0074_COLOUR_REMAPPING_SEI
102	for( Int c=0 ; c<3 ; c++)
103	{
104	m_colourRemapSEIPreLutCodedValue[c] = NULL;
105	m_colourRemapSEIPreLutTargetValue[c] = NULL;
106	m_colourRemapSEIPostLutCodedValue[c] = NULL;
107	m_colourRemapSEIPostLutTargetValue[c] = NULL;
108	}
109	#endif
110	}
111	#endif
112
113	TAppEncCfg::~TAppEncCfg()
114	{
115	#if SVC_EXTENSION
116	if( m_pBitstreamFile )
117	{
118	free(m_pBitstreamFile);
119	m_pBitstreamFile = NULL;
120	}
121	#else
122	if ( m_aidQP )
123	{
124	delete[] m_aidQP;
125	}
126	if ( m_startOfCodedInterval )
127	{
128	delete[] m_startOfCodedInterval;
129	m_startOfCodedInterval = NULL;
130	}
131	if ( m_codedPivotValue )
132	{
133	delete[] m_codedPivotValue;
134	m_codedPivotValue = NULL;
135	}
136	if ( m_targetPivotValue )
137	{
138	delete[] m_targetPivotValue;
139	m_targetPivotValue = NULL;
140	}
141	free(m_pchInputFile);
142	free(m_pchBitstreamFile);
143	#endif
144	#if !SVC_EXTENSION
145	free(m_pchReconFile);
146	free(m_pchdQPFile);
147	#if Q0074_COLOUR_REMAPPING_SEI
148	for( Int c=0 ; c<3 ; c++)
149	{
150	if ( m_colourRemapSEIPreLutCodedValue[c] )
151	{
152	delete[] m_colourRemapSEIPreLutCodedValue[c];
153	}
154	if ( m_colourRemapSEIPreLutTargetValue[c] )
155	{
156	delete[] m_colourRemapSEIPreLutTargetValue[c];
157	}
158	if ( m_colourRemapSEIPostLutCodedValue[c] )
159	{
160	delete[] m_colourRemapSEIPostLutCodedValue[c];
161	}
162	if ( m_colourRemapSEIPostLutTargetValue[c] )
163	{
164	delete[] m_colourRemapSEIPostLutTargetValue[c];
165	}
166	}
167	#endif
168	#endif
169	free(m_scalingListFile);
170	}
171
172	Void TAppEncCfg::create()
173	{
174	}
175
176	Void TAppEncCfg::destroy()
177	{
178	#if VPS_EXTN_DIRECT_REF_LAYERS
179	for(Int layer = 0; layer < MAX_LAYERS; layer++)
180	{
181	if( m_acLayerCfg[layer].m_numSamplePredRefLayers > 0 )
182	{
183	delete [] m_acLayerCfg[layer].m_samplePredRefLayerIds;
184	m_acLayerCfg[layer].m_samplePredRefLayerIds = NULL;
185	}
186	if( m_acLayerCfg[layer].m_numMotionPredRefLayers > 0 )
187	{
188	delete [] m_acLayerCfg[layer].m_motionPredRefLayerIds;
189	m_acLayerCfg[layer].m_motionPredRefLayerIds = NULL;
190	}
191	if( m_acLayerCfg[layer].m_numActiveRefLayers > 0 )
192	{
193	delete [] m_acLayerCfg[layer].m_predLayerIds;
194	m_acLayerCfg[layer].m_predLayerIds = NULL;
195	}
196	}
197	#endif
198	}
199
200	std::istringstream &operator>>(std::istringstream &in, GOPEntry &entry) //input
201	{
202	in>>entry.m_sliceType;
203	in>>entry.m_POC;
204	in>>entry.m_QPOffset;
205	in>>entry.m_QPFactor;
206	in>>entry.m_tcOffsetDiv2;
207	in>>entry.m_betaOffsetDiv2;
208	in>>entry.m_temporalId;
209	in>>entry.m_numRefPicsActive;
210	in>>entry.m_numRefPics;
211	for ( Int i = 0; i < entry.m_numRefPics; i++ )
212	{
213	in>>entry.m_referencePics[i];
214	}
215	in>>entry.m_interRPSPrediction;
216	#if AUTO_INTER_RPS
217	if (entry.m_interRPSPrediction==1)
218	{
219	in>>entry.m_deltaRPS;
220	in>>entry.m_numRefIdc;
221	for ( Int i = 0; i < entry.m_numRefIdc; i++ )
222	{
223	in>>entry.m_refIdc[i];
224	}
225	}
226	else if (entry.m_interRPSPrediction==2)
227	{
228	in>>entry.m_deltaRPS;
229	}
230	#else
231	if (entry.m_interRPSPrediction)
232	{
233	in>>entry.m_deltaRPS;
234	in>>entry.m_numRefIdc;
235	for ( Int i = 0; i < entry.m_numRefIdc; i++ )
236	{
237	in>>entry.m_refIdc[i];
238	}
239	}
240	#endif
241	return in;
242	}
243
244	#if AUXILIARY_PICTURES
245	static inline ChromaFormat numberToChromaFormat(const Int val)
246	{
247	switch (val)
248	{
249	case 400: return CHROMA_400; break;
250	case 420: return CHROMA_420; break;
251	case 422: return CHROMA_422; break;
252	case 444: return CHROMA_444; break;
253	default: return NUM_CHROMA_FORMAT;
254	}
255	}
256	#endif
257
258	#if SVC_EXTENSION
259	void TAppEncCfg::getDirFilename(string& filename, string& dir, const string path)
260	{
261	size_t pos = path.find_last_of("\\");
262	if(pos != std::string::npos)
263	{
264	filename.assign(path.begin() + pos + 1, path.end());
265	dir.assign(path.begin(), path.begin() + pos + 1);
266	}
267	else
268	{
269	pos = path.find_last_of("/");
270	if(pos != std::string::npos)
271	{
272	filename.assign(path.begin() + pos + 1, path.end());
273	dir.assign(path.begin(), path.begin() + pos + 1);
274	}
275	else
276	{
277	filename = path;
278	dir.assign("");
279	}
280	}
281	}
282	#endif
283
284	static const struct MapStrToProfile {
285	const Char* str;
286	Profile::Name value;
287	} strToProfile[] = {
288	{"none", Profile::NONE},
289	{"main", Profile::MAIN},
290	{"main10", Profile::MAIN10},
291	{"main-still-picture", Profile::MAINSTILLPICTURE},
292	#if MULTIPLE_PTL_SUPPORT
293	{"range-extension", Profile::RANGEEXTENSION}, //This is not used in this software
294	{"range-extension-high", Profile::RANGEEXTENSIONHIGH}, //This is not used in this software
295	{"multiview-main", Profile::MULTIVIEWMAIN}, //This is not used in this software
296	{"scalable-main", Profile::SCALABLEMAIN},
297	{"scalable-main10", Profile::SCALABLEMAIN10},
298	#endif
299	};
300
301	static const struct MapStrToTier {
302	const Char* str;
303	Level::Tier value;
304	} strToTier[] = {
305	{"main", Level::MAIN},
306	{"high", Level::HIGH},
307	};
308
309	static const struct MapStrToLevel {
310	const Char* str;
311	Level::Name value;
312	} strToLevel[] = {
313	{"none",Level::NONE},
314	{"1", Level::LEVEL1},
315	{"2", Level::LEVEL2},
316	{"2.1", Level::LEVEL2_1},
317	{"3", Level::LEVEL3},
318	{"3.1", Level::LEVEL3_1},
319	{"4", Level::LEVEL4},
320	{"4.1", Level::LEVEL4_1},
321	{"5", Level::LEVEL5},
322	{"5.1", Level::LEVEL5_1},
323	{"5.2", Level::LEVEL5_2},
324	{"6", Level::LEVEL6},
325	{"6.1", Level::LEVEL6_1},
326	{"6.2", Level::LEVEL6_2},
327	};
328
329	template<typename T, typename P>
330	static istream& readStrToEnum(P map[], unsigned long mapLen, istream &in, T &val)
331	{
332	string str;
333	in >> str;
334
335	for (Int i = 0; i < mapLen; i++)
336	{
337	if (str == map[i].str)
338	{
339	val = map[i].value;
340	goto found;
341	}
342	}
343	/* not found */
344	in.setstate(ios::failbit);
345	found:
346	return in;
347	}
348
349	static istream& operator>>(istream &in, Profile::Name &profile)
350	{
351	return readStrToEnum(strToProfile, sizeof(strToProfile)/sizeof(*strToProfile), in, profile);
352	}
353
354	static istream& operator>>(istream &in, Level::Tier &tier)
355	{
356	return readStrToEnum(strToTier, sizeof(strToTier)/sizeof(*strToTier), in, tier);
357	}
358
359	static istream& operator>>(istream &in, Level::Name &level)
360	{
361	return readStrToEnum(strToLevel, sizeof(strToLevel)/sizeof(*strToLevel), in, level);
362	}
363
364	// ====================================================================================================================
365	// Public member functions
366	// ====================================================================================================================
367
368	/** \param argc number of arguments
369	\param argv array of arguments
370	\retval true when success
371	*/
372	Bool TAppEncCfg::parseCfg( Int argc, Char* argv[] )
373	{
374	Bool do_help = false;
375
376	#if SVC_EXTENSION
377	string cfg_LayerCfgFile [MAX_LAYERS];
378	string cfg_BitstreamFile;
379	string* cfg_InputFile [MAX_LAYERS];
380	string* cfg_ReconFile [MAX_LAYERS];
381	Double* cfg_fQP [MAX_LAYERS];
382	#if REPN_FORMAT_IN_VPS
383	Int* cfg_repFormatIdx [MAX_LAYERS];
384	#endif
385	Int* cfg_SourceWidth [MAX_LAYERS];
386	Int* cfg_SourceHeight [MAX_LAYERS];
387	Int* cfg_FrameRate [MAX_LAYERS];
388	Int* cfg_IntraPeriod [MAX_LAYERS];
389	Int* cfg_conformanceMode[MAX_LAYERS];
390	Int* cfg_confWinLeft [MAX_LAYERS];
391	Int* cfg_confWinRight [MAX_LAYERS];
392	Int* cfg_confWinTop [MAX_LAYERS];
393	Int* cfg_confWinBottom [MAX_LAYERS];
394	Int* cfg_aiPadX [MAX_LAYERS];
395	Int* cfg_aiPadY [MAX_LAYERS];
396	#if LAYER_CTB
397	// coding unit (CU) definition
398	UInt* cfg_uiMaxCUWidth[MAX_LAYERS]; ///< max. CU width in pixel
399	UInt* cfg_uiMaxCUHeight[MAX_LAYERS]; ///< max. CU height in pixel
400	UInt* cfg_uiMaxCUDepth[MAX_LAYERS]; ///< max. CU depth
401
402	// transfom unit (TU) definition
403	UInt* cfg_uiQuadtreeTULog2MaxSize[MAX_LAYERS];
404	UInt* cfg_uiQuadtreeTULog2MinSize[MAX_LAYERS];
405
406	UInt* cfg_uiQuadtreeTUMaxDepthInter[MAX_LAYERS];
407	UInt* cfg_uiQuadtreeTUMaxDepthIntra[MAX_LAYERS];
408	#endif
409	#if AUXILIARY_PICTURES
410	Int cfg_tmpChromaFormatIDC [MAX_LAYERS];
411	Int cfg_tmpInputChromaFormat[MAX_LAYERS];
412	Int* cfg_auxId [MAX_LAYERS];
413	#endif
414	#if VPS_EXTN_DIRECT_REF_LAYERS
415	Int* cfg_numSamplePredRefLayers [MAX_LAYERS];
416	string cfg_samplePredRefLayerIds [MAX_LAYERS];
417	string* cfg_samplePredRefLayerIdsPtr[MAX_LAYERS];
418	Int* cfg_numMotionPredRefLayers [MAX_LAYERS];
419	string cfg_motionPredRefLayerIds [MAX_LAYERS];
420	string* cfg_motionPredRefLayerIdsPtr[MAX_LAYERS];
421	Int* cfg_numActiveRefLayers [MAX_LAYERS];
422	string cfg_predLayerIds [MAX_LAYERS];
423	string* cfg_predLayerIdsPtr [MAX_LAYERS];
424	#endif
425	#if O0098_SCALED_REF_LAYER_ID
426	string cfg_scaledRefLayerId [MAX_LAYERS];
427	#endif
428	string cfg_scaledRefLayerLeftOffset [MAX_LAYERS];
429	string cfg_scaledRefLayerTopOffset [MAX_LAYERS];
430	string cfg_scaledRefLayerRightOffset [MAX_LAYERS];
431	string cfg_scaledRefLayerBottomOffset [MAX_LAYERS];
432	Int* cfg_numScaledRefLayerOffsets[MAX_LAYERS];
433	#if REF_REGION_OFFSET
434	string cfg_scaledRefLayerOffsetPresentFlag [MAX_LAYERS];
435	string cfg_refRegionOffsetPresentFlag [MAX_LAYERS];
436	string cfg_refRegionLeftOffset [MAX_LAYERS];
437	string cfg_refRegionTopOffset [MAX_LAYERS];
438	string cfg_refRegionRightOffset [MAX_LAYERS];
439	string cfg_refRegionBottomOffset [MAX_LAYERS];
440	#endif
441	#if R0209_GENERIC_PHASE
442	string cfg_resamplePhaseSetPresentFlag [MAX_LAYERS];
443	string cfg_phaseHorLuma [MAX_LAYERS];
444	string cfg_phaseVerLuma [MAX_LAYERS];
445	string cfg_phaseHorChroma [MAX_LAYERS];
446	string cfg_phaseVerChroma [MAX_LAYERS];
447	#else
448	#if P0312_VERT_PHASE_ADJ
449	string cfg_vertPhasePositionEnableFlag[MAX_LAYERS];
450	#endif
451	#endif
452
453	#if O0098_SCALED_REF_LAYER_ID
454	string* cfg_scaledRefLayerIdPtr [MAX_LAYERS];
455	#endif
456	string* cfg_scaledRefLayerLeftOffsetPtr [MAX_LAYERS];
457	string* cfg_scaledRefLayerTopOffsetPtr [MAX_LAYERS];
458	string* cfg_scaledRefLayerRightOffsetPtr [MAX_LAYERS];
459	string* cfg_scaledRefLayerBottomOffsetPtr [MAX_LAYERS];
460	#if REF_REGION_OFFSET
461	string* cfg_scaledRefLayerOffsetPresentFlagPtr [MAX_LAYERS];
462	string* cfg_refRegionOffsetPresentFlagPtr [MAX_LAYERS];
463	string* cfg_refRegionLeftOffsetPtr [MAX_LAYERS];
464	string* cfg_refRegionTopOffsetPtr [MAX_LAYERS];
465	string* cfg_refRegionRightOffsetPtr [MAX_LAYERS];
466	string* cfg_refRegionBottomOffsetPtr [MAX_LAYERS];
467	#endif
468	#if R0209_GENERIC_PHASE
469	string* cfg_resamplePhaseSetPresentFlagPtr [MAX_LAYERS];
470	string* cfg_phaseHorLumaPtr [MAX_LAYERS];
471	string* cfg_phaseVerLumaPtr [MAX_LAYERS];
472	string* cfg_phaseHorChromaPtr [MAX_LAYERS];
473	string* cfg_phaseVerChromaPtr [MAX_LAYERS];
474	#endif
475	#if P0312_VERT_PHASE_ADJ
476	string* cfg_vertPhasePositionEnableFlagPtr[MAX_LAYERS];
477	#endif
478
479	#if RC_SHVC_HARMONIZATION
480	Bool* cfg_RCEnableRateControl [MAX_LAYERS];
481	Int* cfg_RCTargetBitRate [MAX_LAYERS];
482	Bool* cfg_RCKeepHierarchicalBit[MAX_LAYERS];
483	Bool* cfg_RCLCULevelRC [MAX_LAYERS];
484	Bool* cfg_RCUseLCUSeparateModel[MAX_LAYERS];
485	Int* cfg_RCInitialQP [MAX_LAYERS];
486	Bool* cfg_RCForceIntraQP [MAX_LAYERS];
487	#endif
488	#if O0194_DIFFERENT_BITDEPTH_EL_BL
489	Int* cfg_InputBitDepthY [MAX_LAYERS];
490	Int* cfg_InternalBitDepthY [MAX_LAYERS];
491	Int* cfg_InputBitDepthC [MAX_LAYERS];
492	Int* cfg_InternalBitDepthC [MAX_LAYERS];
493	Int* cfg_OutputBitDepthY [MAX_LAYERS];
494	Int* cfg_OutputBitDepthC [MAX_LAYERS];
495	#endif
496	Int* cfg_maxTidIlRefPicsPlus1[MAX_LAYERS];
497	#if Q0074_COLOUR_REMAPPING_SEI
498	string* cfg_colourRemapSEIFile[MAX_LAYERS];
499	#endif
500	Int* cfg_waveFrontSynchro[MAX_LAYERS];
501
502	for(UInt layer = 0; layer < MAX_LAYERS; layer++)
503	{
504	cfg_InputFile[layer] = &m_acLayerCfg[layer].m_cInputFile;
505	cfg_ReconFile[layer] = &m_acLayerCfg[layer].m_cReconFile;
506	cfg_fQP[layer] = &m_acLayerCfg[layer].m_fQP;
507	#if Q0074_COLOUR_REMAPPING_SEI
508	cfg_colourRemapSEIFile[layer] = &m_acLayerCfg[layer].m_colourRemapSEIFile;
509	#endif
510	#if REPN_FORMAT_IN_VPS
511	cfg_repFormatIdx[layer] = &m_acLayerCfg[layer].m_repFormatIdx;
512	#endif
513	cfg_SourceWidth[layer] = &m_acLayerCfg[layer].m_iSourceWidth;
514	cfg_SourceHeight[layer] = &m_acLayerCfg[layer].m_iSourceHeight;
515	cfg_FrameRate[layer] = &m_acLayerCfg[layer].m_iFrameRate;
516	cfg_IntraPeriod[layer] = &m_acLayerCfg[layer].m_iIntraPeriod;
517	cfg_conformanceMode[layer] = &m_acLayerCfg[layer].m_conformanceMode;
518	cfg_confWinLeft[layer] = &m_acLayerCfg[layer].m_confWinLeft;
519	cfg_confWinRight[layer] = &m_acLayerCfg[layer].m_confWinRight;
520	cfg_confWinTop[layer] = &m_acLayerCfg[layer].m_confWinTop;
521	cfg_confWinBottom[layer]= &m_acLayerCfg[layer].m_confWinBottom;
522	cfg_aiPadX[layer] = &m_acLayerCfg[layer].m_aiPad[0];
523	cfg_aiPadY[layer] = &m_acLayerCfg[layer].m_aiPad[1];
524	#if LAYER_CTB
525	// coding unit (CU) definition
526	cfg_uiMaxCUWidth[layer] = &m_acLayerCfg[layer].m_uiMaxCUWidth;
527	cfg_uiMaxCUHeight[layer] = &m_acLayerCfg[layer].m_uiMaxCUHeight;
528	cfg_uiMaxCUDepth[layer] = &m_acLayerCfg[layer].m_uiMaxCUDepth;
529
530	// transfom unit (TU) definition.
531	cfg_uiQuadtreeTULog2MaxSize[layer] = &m_acLayerCfg[layer].m_uiQuadtreeTULog2MaxSize;
532	cfg_uiQuadtreeTULog2MinSize[layer] = &m_acLayerCfg[layer].m_uiQuadtreeTULog2MinSize;
533
534	cfg_uiQuadtreeTUMaxDepthInter[layer] = &m_acLayerCfg[layer].m_uiQuadtreeTUMaxDepthInter;
535	cfg_uiQuadtreeTUMaxDepthIntra[layer] = &m_acLayerCfg[layer].m_uiQuadtreeTUMaxDepthIntra;
536	#endif
537	#if VPS_EXTN_DIRECT_REF_LAYERS
538	cfg_numSamplePredRefLayers [layer] = &m_acLayerCfg[layer].m_numSamplePredRefLayers;
539	cfg_samplePredRefLayerIdsPtr[layer] = &cfg_samplePredRefLayerIds[layer];
540	cfg_numMotionPredRefLayers [layer] = &m_acLayerCfg[layer].m_numMotionPredRefLayers;
541	cfg_motionPredRefLayerIdsPtr[layer] = &cfg_motionPredRefLayerIds[layer];
542	cfg_numActiveRefLayers [layer] = &m_acLayerCfg[layer].m_numActiveRefLayers;
543	cfg_predLayerIdsPtr [layer] = &cfg_predLayerIds[layer];
544	#endif
545	cfg_numScaledRefLayerOffsets [layer] = &m_acLayerCfg[layer].m_numScaledRefLayerOffsets;
546	cfg_waveFrontSynchro[layer] = &m_acLayerCfg[layer].m_waveFrontSynchro;
547	for(Int i = 0; i < MAX_LAYERS; i++)
548	{
549	#if O0098_SCALED_REF_LAYER_ID
550	cfg_scaledRefLayerIdPtr [layer] = &cfg_scaledRefLayerId[layer];
551	#endif
552	cfg_scaledRefLayerLeftOffsetPtr [layer] = &cfg_scaledRefLayerLeftOffset[layer];
553	cfg_scaledRefLayerTopOffsetPtr [layer] = &cfg_scaledRefLayerTopOffset[layer];
554	cfg_scaledRefLayerRightOffsetPtr [layer] = &cfg_scaledRefLayerRightOffset[layer];
555	cfg_scaledRefLayerBottomOffsetPtr[layer] = &cfg_scaledRefLayerBottomOffset[layer];
556	#if P0312_VERT_PHASE_ADJ
557	cfg_vertPhasePositionEnableFlagPtr[layer] = &cfg_vertPhasePositionEnableFlag[layer];
558	#endif
559	#if REF_REGION_OFFSET
560	cfg_scaledRefLayerOffsetPresentFlagPtr [layer] = &cfg_scaledRefLayerOffsetPresentFlag [layer];
561	cfg_refRegionOffsetPresentFlagPtr [layer] = &cfg_refRegionOffsetPresentFlag [layer];
562	cfg_refRegionLeftOffsetPtr [layer] = &cfg_refRegionLeftOffset [layer];
563	cfg_refRegionTopOffsetPtr [layer] = &cfg_refRegionTopOffset [layer];
564	cfg_refRegionRightOffsetPtr [layer] = &cfg_refRegionRightOffset [layer];
565	cfg_refRegionBottomOffsetPtr[layer] = &cfg_refRegionBottomOffset[layer];
566	#endif
567	#if R0209_GENERIC_PHASE
568	cfg_resamplePhaseSetPresentFlagPtr [layer] = &cfg_resamplePhaseSetPresentFlag [layer];
569	cfg_phaseHorLumaPtr [layer] = &cfg_phaseHorLuma [layer];
570	cfg_phaseVerLumaPtr [layer] = &cfg_phaseVerLuma [layer];
571	cfg_phaseHorChromaPtr [layer] = &cfg_phaseHorChroma [layer];
572	cfg_phaseVerChromaPtr [layer] = &cfg_phaseVerChroma [layer];
573	#endif
574	}
575	#if RC_SHVC_HARMONIZATION
576	cfg_RCEnableRateControl[layer] = &m_acLayerCfg[layer].m_RCEnableRateControl;
577	cfg_RCTargetBitRate[layer] = &m_acLayerCfg[layer].m_RCTargetBitrate;
578	cfg_RCKeepHierarchicalBit[layer] = &m_acLayerCfg[layer].m_RCKeepHierarchicalBit;
579	cfg_RCLCULevelRC[layer] = &m_acLayerCfg[layer].m_RCLCULevelRC;
580	cfg_RCUseLCUSeparateModel[layer] = &m_acLayerCfg[layer].m_RCUseLCUSeparateModel;
581	cfg_RCInitialQP[layer] = &m_acLayerCfg[layer].m_RCInitialQP;
582	cfg_RCForceIntraQP[layer] = &m_acLayerCfg[layer].m_RCForceIntraQP;
583	#endif
584	#if O0194_DIFFERENT_BITDEPTH_EL_BL
585	cfg_InputBitDepthY [layer] = &m_acLayerCfg[layer].m_inputBitDepthY;
586	cfg_InternalBitDepthY[layer] = &m_acLayerCfg[layer].m_internalBitDepthY;
587	cfg_InputBitDepthC [layer] = &m_acLayerCfg[layer].m_inputBitDepthC;
588	cfg_InternalBitDepthC[layer] = &m_acLayerCfg[layer].m_internalBitDepthC;
589	cfg_OutputBitDepthY [layer] = &m_acLayerCfg[layer].m_outputBitDepthY;
590	cfg_OutputBitDepthC [layer] = &m_acLayerCfg[layer].m_outputBitDepthC;
591	#endif
592	cfg_maxTidIlRefPicsPlus1[layer] = &m_acLayerCfg[layer].m_maxTidIlRefPicsPlus1;
593	#if AUXILIARY_PICTURES
594	cfg_auxId[layer] = &m_acLayerCfg[layer].m_auxId;
595	#endif
596	}
597	#if Q0078_ADD_LAYER_SETS
598	Int* cfg_numLayerInIdList[MAX_VPS_LAYER_SETS_PLUS1];
599	string cfg_layerSetLayerIdList[MAX_VPS_LAYER_SETS_PLUS1];
600	string* cfg_layerSetLayerIdListPtr[MAX_VPS_LAYER_SETS_PLUS1];
601	Int* cfg_numHighestLayerIdx[MAX_VPS_LAYER_SETS_PLUS1];
602	string cfg_highestLayerIdx[MAX_VPS_LAYER_SETS_PLUS1];
603	string* cfg_highestLayerIdxPtr[MAX_VPS_LAYER_SETS_PLUS1];
604	for (UInt i = 0; i < MAX_VPS_LAYER_SETS_PLUS1; i++)
605	{
606	cfg_numLayerInIdList[i] = &m_numLayerInIdList[i];
607	cfg_layerSetLayerIdListPtr[i] = &cfg_layerSetLayerIdList[i];
608	cfg_highestLayerIdxPtr[i] = &cfg_highestLayerIdx[i];
609	cfg_numHighestLayerIdx[i] = &m_numHighestLayerIdx[i];
610	}
611	#endif
612	#if OUTPUT_LAYER_SETS_CONFIG
613	string* cfg_numOutputLayersInOutputLayerSet = new string;
614	string* cfg_listOfOutputLayers = new string[MAX_VPS_OUTPUT_LAYER_SETS_PLUS1];
615	string* cfg_outputLayerSetIdx = new string;
616	#endif
617	#if MULTIPLE_PTL_SUPPORT
618	string* cfg_listOfLayerPTLOfOlss = new string[MAX_VPS_OUTPUT_LAYER_SETS_PLUS1];
619	#endif
620	#if AVC_BASE
621	string cfg_BLInputFile;
622	#endif
623	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
624	string cfg_tileSets;
625	#endif
626	#else //SVC_EXTENSION
627	string cfg_InputFile;
628	string cfg_BitstreamFile;
629	string cfg_ReconFile;
630	string cfg_dQPFile;
631	#if Q0074_COLOUR_REMAPPING_SEI
632	string cfg_colourRemapSEIFile;
633	#endif
634	#endif //SVC_EXTENSION
635	string cfgColumnWidth;
636	string cfgRowHeight;
637	string cfg_ScalingListFile;
638	string cfg_startOfCodedInterval;
639	string cfg_codedPivotValue;
640	string cfg_targetPivotValue;
641	#if P0050_KNEE_FUNCTION_SEI
642	string cfg_kneeSEIInputKneePointValue;
643	string cfg_kneeSEIOutputKneePointValue;
644	#endif
645	#if Q0096_OVERLAY_SEI
646	const Int CFG_MAX_OVERLAYS = 3;
647	UInt cfg_overlaySEIIdx[CFG_MAX_OVERLAYS];
648	Bool cfg_overlaySEILanguagePresentFlag[CFG_MAX_OVERLAYS];
649	UInt cfg_overlaySEIContentLayerId[CFG_MAX_OVERLAYS];
650	Bool cfg_overlaySEILabelPresentFlag[CFG_MAX_OVERLAYS];
651	UInt cfg_overlaySEILabelLayerId[CFG_MAX_OVERLAYS];
652	Bool cfg_overlaySEIAlphaPresentFlag[CFG_MAX_OVERLAYS];
653	UInt cfg_overlaySEIAlphaLayerId[CFG_MAX_OVERLAYS];
654	UInt cfg_overlaySEINumElementsMinus1[CFG_MAX_OVERLAYS];
655	string cfg_overlaySEIElementLabelRanges[CFG_MAX_OVERLAYS];
656	string cfg_overlaySEILanguage[CFG_MAX_OVERLAYS];
657	string cfg_overlaySEIName[CFG_MAX_OVERLAYS];
658	string cfg_overlaySEIElementNames[CFG_MAX_OVERLAYS];
659	#endif
660
661	po::Options opts;
662	opts.addOptions()
663	("help", do_help, false, "this help text")
664	("c", po::parseConfigFile, "configuration file name")
665
666	// File, I/O and source parameters
667	#if SVC_EXTENSION
668	("InputFile%d,-i%d", cfg_InputFile, string(""), MAX_LAYERS, "original YUV input file name for layer %d")
669	("ReconFile%d,-o%d", cfg_ReconFile, string(""), MAX_LAYERS, "reconstruction YUV input file name for layer %d")
670	("LayerConfig%d,-lc%d", cfg_LayerCfgFile, string(""), MAX_LAYERS, "layer %d configuration file name")
671	("SourceWidth%d,-wdt%d", cfg_SourceWidth, 0, MAX_LAYERS, "Source picture width for layer %d")
672	("SourceHeight%d,-hgt%d", cfg_SourceHeight, 0, MAX_LAYERS, "Source picture height for layer %d")
673	("FrameRate%d,-fr%d", cfg_FrameRate, 0, MAX_LAYERS, "Frame rate for layer %d")
674	("LambdaModifier%d,-LM%d", m_adLambdaModifier, ( double )1.0, MAX_TLAYER, "Lambda modifier for temporal layer %d")
675	#if O0215_PHASE_ALIGNMENT
676	("PhaseAlignment", m_phaseAlignFlag, false, "indicate the sample location alignment between layers (0: zero position aligned, 1: central position aligned)")
677	#endif
678	#if REPN_FORMAT_IN_VPS
679	("RepFormatIdx%d", cfg_repFormatIdx, -1, MAX_LAYERS, "Index to the representation format structure used from the VPS")
680	#endif
681	#if VPS_EXTN_DIRECT_REF_LAYERS
682	("NumSamplePredRefLayers%d",cfg_numSamplePredRefLayers, -1, MAX_LAYERS, "Number of sample prediction reference layers")
683	("SamplePredRefLayerIds%d", cfg_samplePredRefLayerIdsPtr, string(""), MAX_LAYERS, "sample pred reference layer IDs")
684	("NumMotionPredRefLayers%d",cfg_numMotionPredRefLayers, -1, MAX_LAYERS, "Number of motion prediction reference layers")
685	("MotionPredRefLayerIds%d", cfg_motionPredRefLayerIdsPtr, string(""), MAX_LAYERS, "motion pred reference layer IDs")
686	("NumActiveRefLayers%d", cfg_numActiveRefLayers, -1, MAX_LAYERS, "Number of active reference layers")
687	("PredLayerIds%d", cfg_predLayerIdsPtr, string(""), MAX_LAYERS, "inter-layer prediction layer IDs")
688	#endif
689	("NumLayers", m_numLayers, 1, "Number of layers to code")
690	#if Q0078_ADD_LAYER_SETS
691	#if OUTPUT_LAYER_SETS_CONFIG
692	("NumLayerSets", m_numLayerSets, 1, "Number of layer sets")
693	#else
694	("NumLayerSets", m_numLayerSets, 0, "Number of layer sets")
695	#endif
696	("NumLayerInIdList%d", cfg_numLayerInIdList, 0, MAX_VPS_LAYER_ID_PLUS1, "Number of layers in the set")
697	("LayerSetLayerIdList%d", cfg_layerSetLayerIdListPtr, string(""), MAX_VPS_LAYER_ID_PLUS1, "Layer IDs for the set")
698	("NumAddLayerSets", m_numAddLayerSets, 0, "Number of additional layer sets")
699	("NumHighestLayerIdx%d", cfg_numHighestLayerIdx, 0, MAX_VPS_LAYER_ID_PLUS1, "Number of highest layer idx")
700	("HighestLayerIdx%d", cfg_highestLayerIdxPtr, string(""), MAX_VPS_LAYER_ID_PLUS1, "Highest layer idx for an additional layer set")
701	#endif
702	#if OUTPUT_LAYER_SETS_CONFIG
703	("DefaultTargetOutputLayerIdc", m_defaultTargetOutputLayerIdc, 1, "Default target output layers. 0: All layers are output layer, 1: Only highest layer is output layer, 2 or 3: No default output layers")
704	("NumOutputLayerSets", m_numOutputLayerSets, 1, "Number of output layer sets excluding the 0-th output layer set")
705	("NumOutputLayersInOutputLayerSet", cfg_numOutputLayersInOutputLayerSet, string(""), 1 , "List containing number of output layers in the output layer sets")
706	("ListOfOutputLayers%d", cfg_listOfOutputLayers, string(""), MAX_VPS_LAYER_ID_PLUS1, "Layer IDs for the set, in terms of layer ID in the output layer set Range: [0..NumLayersInOutputLayerSet-1]")
707	("OutputLayerSetIdx", cfg_outputLayerSetIdx, string(""), 1, "Corresponding layer set index, only for non-default output layer sets")
708	#endif
709	#if AUXILIARY_PICTURES
710	("InputChromaFormat%d", cfg_tmpInputChromaFormat, 420, MAX_LAYERS, "InputChromaFormatIDC for layer %d")
711	("ChromaFormatIDC%d,-cf", cfg_tmpChromaFormatIDC, 420, MAX_LAYERS, "ChromaFormatIDC (400\|420\|422\|444 or set 0 (default) for same as InputChromaFormat) for layer %d")
712	("AuxId%d", cfg_auxId, 0, MAX_LAYERS, "Auxilary picture ID for layer %d (0: Not aux pic, 1: Alpha plane, 2: Depth picture, 3: Cb enh, 4: Cr enh")
713	#endif
714	("ConformanceMode%d", cfg_conformanceMode, 0, MAX_LAYERS, "Window conformance mode (0: no cropping, 1:automatic padding, 2: padding, 3:cropping")
715	("ConfLeft%d", cfg_confWinLeft, 0, MAX_LAYERS, "Deprecated alias of ConfWinLeft")
716	("ConfRight%d", cfg_confWinRight, 0, MAX_LAYERS, "Deprecated alias of ConfWinRight")
717	("ConfTop%d", cfg_confWinTop, 0, MAX_LAYERS, "Deprecated alias of ConfWinTop")
718	("ConfBottom%d", cfg_confWinBottom, 0, MAX_LAYERS, "Deprecated alias of ConfWinBottom")
719	("ConfWinLeft%d", cfg_confWinLeft, 0, MAX_LAYERS, "Left offset for window conformance mode 3")
720	("ConfWinRight%d", cfg_confWinRight, 0, MAX_LAYERS, "Right offset for window conformance mode 3")
721	("ConfWinTop%d", cfg_confWinTop, 0, MAX_LAYERS, "Top offset for window conformance mode 3")
722	("ConfWinBottom%d", cfg_confWinBottom, 0, MAX_LAYERS, "Bottom offset for window conformance mode 3")
723	("HorizontalPadding%d,-pdx%d", cfg_aiPadX, 0, MAX_LAYERS, "Horizontal source padding for conformance window mode 2")
724	("VerticalPadding%d,-pdy%d", cfg_aiPadY, 0, MAX_LAYERS, "Vertical source padding for conformance window mode 2")
725	("ScalabilityMask1", m_scalabilityMask[1], 0, "scalability_mask[1] (multiview)")
726	("ScalabilityMask2", m_scalabilityMask[2], 1, "scalability_mask[2] (scalable)" )
727	#if AUXILIARY_PICTURES
728	("ScalabilityMask3", m_scalabilityMask[3], 0, "scalability_mask[3] (auxiliary pictures)" )
729	#endif
730	("BitstreamFile,b", cfg_BitstreamFile, string(""), "Bitstream output file name")
731	#if !O0194_DIFFERENT_BITDEPTH_EL_BL
732	("InputBitDepth", m_inputBitDepthY, 8, "Bit-depth of input file")
733	("OutputBitDepth", m_outputBitDepthY, 0, "Bit-depth of output file (default:InternalBitDepth)")
734	("InternalBitDepth", m_internalBitDepthY, 0, "Bit-depth the codec operates at. (default:InputBitDepth)"
735	"If different to InputBitDepth, source data will be converted")
736	("InputBitDepthC", m_inputBitDepthC, 0, "As per InputBitDepth but for chroma component. (default:InputBitDepth)")
737	("OutputBitDepthC", m_outputBitDepthC, 0, "As per OutputBitDepth but for chroma component. (default:InternalBitDepthC)")
738	("InternalBitDepthC", m_internalBitDepthC, 0, "As per InternalBitDepth but for chroma component. (default:IntrenalBitDepth)")
739	#endif
740	("NumScaledRefLayerOffsets%d", cfg_numScaledRefLayerOffsets, 0, MAX_LAYERS, "Number of scaled offset layer sets ")
741	#if O0098_SCALED_REF_LAYER_ID
742	("ScaledRefLayerId%d", cfg_scaledRefLayerIdPtr, string(""), MAX_LAYERS, "Layer ID of scaled base layer picture")
743	#endif
744	("ScaledRefLayerLeftOffset%d", cfg_scaledRefLayerLeftOffsetPtr, string(""), MAX_LAYERS, "Horizontal offset of top-left luma sample of scaled base layer picture with respect to"
745	" top-left luma sample of the EL picture, in units of two luma samples")
746	("ScaledRefLayerTopOffset%d", cfg_scaledRefLayerTopOffsetPtr, string(""), MAX_LAYERS, "Vertical offset of top-left luma sample of scaled base layer picture with respect to"
747	" top-left luma sample of the EL picture, in units of two luma samples")
748	("ScaledRefLayerRightOffset%d", cfg_scaledRefLayerRightOffsetPtr, string(""), MAX_LAYERS, "Horizontal offset of bottom-right luma sample of scaled base layer picture with respect to"
749	" bottom-right luma sample of the EL picture, in units of two luma samples")
750	("ScaledRefLayerBottomOffset%d", cfg_scaledRefLayerBottomOffsetPtr,string(""), MAX_LAYERS, "Vertical offset of bottom-right luma sample of scaled base layer picture with respect to"
751	" bottom-right luma sample of the EL picture, in units of two luma samples")
752	#if REF_REGION_OFFSET
753	("ScaledRefLayerOffsetPresentFlag%d", cfg_scaledRefLayerOffsetPresentFlagPtr, string(""), MAX_LAYERS, "presense flag of scaled reference layer offsets")
754	("RefRegionOffsetPresentFlag%d", cfg_refRegionOffsetPresentFlagPtr, string(""), MAX_LAYERS, "presense flag of reference region offsets")
755	("RefRegionLeftOffset%d", cfg_refRegionLeftOffsetPtr, string(""), MAX_LAYERS, "Horizontal offset of top-left luma sample of ref region with respect to"
756	" top-left luma sample of the BL picture, in units of two luma samples")
757	("RefRegionTopOffset%d", cfg_refRegionTopOffsetPtr, string(""), MAX_LAYERS, "Vertical offset of top-left luma sample of ref region with respect to"
758	" top-left luma sample of the BL picture, in units of two luma samples")
759	("RefRegionRightOffset%d", cfg_refRegionRightOffsetPtr, string(""), MAX_LAYERS, "Horizontal offset of bottom-right luma sample of ref region with respect to"
760	" bottom-right luma sample of the BL picture, in units of two luma samples")
761	("RefRegionBottomOffset%d", cfg_refRegionBottomOffsetPtr,string(""), MAX_LAYERS, "Vertical offset of bottom-right luma sample of ref region with respect to"
762	" bottom-right luma sample of the BL picture, in units of two luma samples")
763	#endif
764	#if R0209_GENERIC_PHASE
765	("ResamplePhaseSetPresentFlag%d", cfg_resamplePhaseSetPresentFlagPtr, string(""), MAX_LAYERS, "presense flag of resample phase set")
766	("PhaseHorLuma%d", cfg_phaseHorLumaPtr, string(""), MAX_LAYERS, "luma shift in the horizontal direction used in resampling proces")
767	("PhaseVerLuma%d", cfg_phaseVerLumaPtr, string(""), MAX_LAYERS, "luma shift in the vertical direction used in resampling proces")
768	("PhaseHorChroma%d", cfg_phaseHorChromaPtr, string(""), MAX_LAYERS, "chroma shift in the horizontal direction used in resampling proces")
769	("PhaseVerChroma%d", cfg_phaseVerChromaPtr, string(""), MAX_LAYERS, "chroma shift in the vertical direction used in resampling proces")
770	#endif
771	#if P0312_VERT_PHASE_ADJ
772	("VertPhasePositionEnableFlag%d", cfg_vertPhasePositionEnableFlagPtr,string(""), MAX_LAYERS, "VertPhasePositionEnableFlag for layer %d")
773	#endif
774	#if Q0074_COLOUR_REMAPPING_SEI
775	("SEIColourRemappingInfoFile%d", cfg_colourRemapSEIFile, string(""), MAX_LAYERS, "Colour Remapping Information SEI parameters file name for layer %d")
776	#endif
777	#if O0194_DIFFERENT_BITDEPTH_EL_BL
778	("InputBitDepth%d", cfg_InputBitDepthY, 8, MAX_LAYERS, "Bit-depth of input file for layer %d")
779	("InternalBitDepth%d", cfg_InternalBitDepthY, 0, MAX_LAYERS, "Bit-depth the codec operates at. (default:InputBitDepth) for layer %d ")
780	// "If different to InputBitDepth, source data will be converted")
781	("InputBitDepthC%d", cfg_InputBitDepthC, 0, MAX_LAYERS, "As per InputBitDepth but for chroma component. (default:InputBitDepth) for layer %d")
782	("InternalBitDepthC%d", cfg_InternalBitDepthC, 0, MAX_LAYERS, "As per InternalBitDepth but for chroma component. (default:IntrenalBitDepth) for layer %d")
783	("OutputBitDepth%d", cfg_OutputBitDepthY, 0, MAX_LAYERS, "Bit-depth of output file (default:InternalBitDepth)")
784	("OutputBitDepthC%d", cfg_OutputBitDepthC, 0, MAX_LAYERS, "As per OutputBitDepth but for chroma component. (default:InternalBitDepthC)")
785	#endif
786	("MaxTidRefPresentFlag", m_maxTidRefPresentFlag, true, "max_tid_ref_present_flag (0: not present, 1: present(default)) " )
787	("MaxTidIlRefPicsPlus1%d", cfg_maxTidIlRefPicsPlus1, 1, MAX_LAYERS, "allowed maximum temporal_id for inter-layer prediction")
788	#if O0223_PICTURE_TYPES_ALIGN_FLAG
789	("CrossLayerPictureTypeAlignFlag", m_crossLayerPictureTypeAlignFlag, true, "align picture type across layers" )
790	#endif
791	("CrossLayerIrapAlignFlag", m_crossLayerIrapAlignFlag, true, "align IRAP across layers" )
792	#if P0068_CROSS_LAYER_ALIGNED_IDR_ONLY_FOR_IRAP_FLAG
793	("CrossLayerAlignedIdrOnlyFlag", m_crossLayerAlignedIdrOnlyFlag, true, "only idr for IRAP across layers" )
794	#endif
795	#if O0194_WEIGHTED_PREDICTION_CGS
796	("InterLayerWeightedPred", m_useInterLayerWeightedPred, false, "enable IL WP parameters estimation at encoder" )
797	#endif
798	#if AVC_BASE
799	#if VPS_AVC_BL_FLAG_REMOVAL
800	("NonHEVCBase,-nonhevc", m_nonHEVCBaseLayerFlag, 0, "BL is available but not internal")
801	#else
802	("AvcBase,-avc", m_avcBaseLayerFlag, 0, "avc_base_layer_flag")
803	#endif
804	("InputBLFile,-ibl", cfg_BLInputFile, string(""), "Base layer rec YUV input file name")
805	#endif
806	("EnableElRapB,-use-rap-b", m_elRapSliceBEnabled, 0, "Set ILP over base-layer I picture to B picture (default is P picture)")
807	#else //SVC_EXTENSION
808	("InputFile,i", cfg_InputFile, string(""), "Original YUV input file name")
809	("BitstreamFile,b", cfg_BitstreamFile, string(""), "Bitstream output file name")
810	("ReconFile,o", cfg_ReconFile, string(""), "Reconstructed YUV output file name")
811	("SourceWidth,-wdt", m_iSourceWidth, 0, "Source picture width")
812	("SourceHeight,-hgt", m_iSourceHeight, 0, "Source picture height")
813	("InputBitDepth", m_inputBitDepthY, 8, "Bit-depth of input file")
814	("OutputBitDepth", m_outputBitDepthY, 0, "Bit-depth of output file (default:InternalBitDepth)")
815	("InternalBitDepth", m_internalBitDepthY, 0, "Bit-depth the codec operates at. (default:InputBitDepth)"
816	"If different to InputBitDepth, source data will be converted")
817	("InputBitDepthC", m_inputBitDepthC, 0, "As per InputBitDepth but for chroma component. (default:InputBitDepth)")
818	("OutputBitDepthC", m_outputBitDepthC, 0, "As per OutputBitDepth but for chroma component. (default:InternalBitDepthC)")
819	("InternalBitDepthC", m_internalBitDepthC, 0, "As per InternalBitDepth but for chroma component. (default:IntrenalBitDepth)")
820	#if AUXILIARY_PICTURES
821	("InputChromaFormat", tmpInputChromaFormat, 420, "InputChromaFormatIDC")
822	("ChromaFormatIDC,-cf", tmpChromaFormat, 0, "ChromaFormatIDC (400\|420\|422\|444 or set 0 (default) for same as InputChromaFormat)")
823	#endif
824	("ConformanceMode", m_conformanceWindowMode, 0, "Deprecated alias of ConformanceWindowMode")
825	("ConformanceWindowMode", m_conformanceWindowMode, 0, "Window conformance mode (0: no window, 1:automatic padding, 2:padding, 3:conformance")
826	("HorizontalPadding,-pdx",m_aiPad[0], 0, "Horizontal source padding for conformance window mode 2")
827	("VerticalPadding,-pdy", m_aiPad[1], 0, "Vertical source padding for conformance window mode 2")
828	("ConfLeft", m_confWinLeft, 0, "Deprecated alias of ConfWinLeft")
829	("ConfRight", m_confWinRight, 0, "Deprecated alias of ConfWinRight")
830	("ConfTop", m_confWinTop, 0, "Deprecated alias of ConfWinTop")
831	("ConfBottom", m_confWinBottom, 0, "Deprecated alias of ConfWinBottom")
832	("ConfWinLeft", m_confWinLeft, 0, "Left offset for window conformance mode 3")
833	("ConfWinRight", m_confWinRight, 0, "Right offset for window conformance mode 3")
834	("ConfWinTop", m_confWinTop, 0, "Top offset for window conformance mode 3")
835	("ConfWinBottom", m_confWinBottom, 0, "Bottom offset for window conformance mode 3")
836	("FrameRate,-fr", m_iFrameRate, 0, "Frame rate")
837	#if Q0074_COLOUR_REMAPPING_SEI
838	("SEIColourRemappingInfoFile", cfg_colourRemapSEIFile, string(""), "Colour Remapping Information SEI parameters file name")
839	#endif
840	#endif //SVC_EXTENSION
841	("FrameSkip,-fs", m_FrameSkip, 0u, "Number of frames to skip at start of input YUV")
842	("FramesToBeEncoded,f", m_framesToBeEncoded, 0, "Number of frames to be encoded (default=all)")
843
844	//Field coding parameters
845	("FieldCoding", m_isField, false, "Signals if it's a field based coding")
846	("TopFieldFirst, Tff", m_isTopFieldFirst, false, "In case of field based coding, signals whether if it's a top field first or not")
847
848	// Profile and level
849	#if SVC_EXTENSION && MULTIPLE_PTL_SUPPORT
850	("NumProfileTierLevel", m_numPTLInfo, 1, "Number of Profile, Tier and Level information")
851	("Profile%d", m_profileList, Profile::NONE, MAX_NUM_LAYER_IDS + 1, "Profile to be used when encoding (Incomplete)")
852	("Level%d", m_levelList, Level::NONE, MAX_NUM_LAYER_IDS + 1, "Level limit to be used, eg 5.1 (Incomplete)")
853	("Tier%d", m_levelTierList, Level::MAIN, MAX_NUM_LAYER_IDS + 1, "Tier to use for interpretation of --Level")
854	("ProfileCompatibility%d", m_profileCompatibility, Profile::NONE, MAX_NUM_LAYER_IDS + 1, "Compatible profile to be used when encoding")
855	("ProgressiveSource%d", m_progressiveSourceFlagList, false, MAX_NUM_LAYER_IDS + 1, "Indicate that source is progressive")
856	("InterlacedSource%d", m_interlacedSourceFlagList, false, MAX_NUM_LAYER_IDS + 1, "Indicate that source is interlaced")
857	("NonPackedSource%d", m_nonPackedConstraintFlagList, false, MAX_NUM_LAYER_IDS + 1, "Indicate that source does not contain frame packing")
858	("FrameOnly%d", m_frameOnlyConstraintFlagList, false, MAX_NUM_LAYER_IDS + 1, "Indicate that the bitstream contains only frames")
859
860	("LayerPTLIndex%d", m_layerPTLIdx, 0, MAX_VPS_LAYER_ID_PLUS1, "Index of PTL for each layer")
861	("ListOfProfileTierLevelOls%d", cfg_listOfLayerPTLOfOlss, string(""), MAX_VPS_OUTPUT_LAYER_SETS_PLUS1, "PTL Index for each layer in each OLS except the first OLS. The PTL index for layer in the first OLS is set to 1")
862	#else
863	("Profile", m_profile, Profile::NONE, "Profile to be used when encoding (Incomplete)")
864	("Level", m_level, Level::NONE, "Level limit to be used, eg 5.1 (Incomplete)")
865	("Tier", m_levelTier, Level::MAIN, "Tier to use for interpretation of --Level")
866
867	("ProgressiveSource", m_progressiveSourceFlag, false, "Indicate that source is progressive")
868	("InterlacedSource", m_interlacedSourceFlag, false, "Indicate that source is interlaced")
869	("NonPackedSource", m_nonPackedConstraintFlag, false, "Indicate that source does not contain frame packing")
870	("FrameOnly", m_frameOnlyConstraintFlag, false, "Indicate that the bitstream contains only frames")
871	#endif
872
873	#if LAYER_CTB
874	// Unit definition parameters
875	("MaxCUWidth%d", cfg_uiMaxCUWidth, 64u, MAX_LAYERS, "Maximum CU width")
876	("MaxCUHeight%d", cfg_uiMaxCUHeight, 64u, MAX_LAYERS, "Maximum CU height")
877	// todo: remove defaults from MaxCUSize
878	("MaxCUSize%d,s%d", cfg_uiMaxCUWidth, 64u, MAX_LAYERS, "Maximum CU size")
879	("MaxCUSize%d,s%d", cfg_uiMaxCUHeight, 64u, MAX_LAYERS, "Maximum CU size")
880	("MaxPartitionDepth%d,h%d", cfg_uiMaxCUDepth, 4u, MAX_LAYERS, "CU depth")
881
882	("QuadtreeTULog2MaxSize%d", cfg_uiQuadtreeTULog2MaxSize, 6u, MAX_LAYERS, "Maximum TU size in logarithm base 2")
883	("QuadtreeTULog2MinSize%d", cfg_uiQuadtreeTULog2MinSize, 2u, MAX_LAYERS, "Minimum TU size in logarithm base 2")
884
885	("QuadtreeTUMaxDepthIntra%d", cfg_uiQuadtreeTUMaxDepthIntra, 1u, MAX_LAYERS, "Depth of TU tree for intra CUs")
886	("QuadtreeTUMaxDepthInter%d", cfg_uiQuadtreeTUMaxDepthInter, 2u, MAX_LAYERS, "Depth of TU tree for inter CUs")
887
888
889	// set the same CU realted settings across all the layers if config file parameters are not layer specific
890	("MaxCUWidth", cfg_uiMaxCUWidth, 64u, MAX_LAYERS, "Maximum CU width")
891	("MaxCUHeight", cfg_uiMaxCUHeight, 64u, MAX_LAYERS, "Maximum CU height")
892	// todo: remove defaults from MaxCUSize
893	("MaxCUSize,s", cfg_uiMaxCUWidth, 64u, MAX_LAYERS, "Maximum CU size")
894	("MaxCUSize,s", cfg_uiMaxCUHeight, 64u, MAX_LAYERS, "Maximum CU size")
895	("MaxPartitionDepth,h", cfg_uiMaxCUDepth, 4u, MAX_LAYERS, "CU depth")
896
897	("QuadtreeTULog2MaxSize", cfg_uiQuadtreeTULog2MaxSize, 6u, MAX_LAYERS, "Maximum TU size in logarithm base 2")
898	("QuadtreeTULog2MinSize", cfg_uiQuadtreeTULog2MinSize, 2u, MAX_LAYERS, "Minimum TU size in logarithm base 2")
899
900	("QuadtreeTUMaxDepthIntra", cfg_uiQuadtreeTUMaxDepthIntra, 1u, MAX_LAYERS, "Depth of TU tree for intra CUs")
901	("QuadtreeTUMaxDepthInter", cfg_uiQuadtreeTUMaxDepthInter, 2u, MAX_LAYERS, "Depth of TU tree for inter CUs")
902	#else
903	// Unit definition parameters
904	("MaxCUWidth", m_uiMaxCUWidth, 64u)
905	("MaxCUHeight", m_uiMaxCUHeight, 64u)
906	// todo: remove defaults from MaxCUSize
907	("MaxCUSize,s", m_uiMaxCUWidth, 64u, "Maximum CU size")
908	("MaxCUSize,s", m_uiMaxCUHeight, 64u, "Maximum CU size")
909	("MaxPartitionDepth,h", m_uiMaxCUDepth, 4u, "CU depth")
910
911	("QuadtreeTULog2MaxSize", m_uiQuadtreeTULog2MaxSize, 6u, "Maximum TU size in logarithm base 2")
912	("QuadtreeTULog2MinSize", m_uiQuadtreeTULog2MinSize, 2u, "Minimum TU size in logarithm base 2")
913
914	("QuadtreeTUMaxDepthIntra", m_uiQuadtreeTUMaxDepthIntra, 1u, "Depth of TU tree for intra CUs")
915	("QuadtreeTUMaxDepthInter", m_uiQuadtreeTUMaxDepthInter, 2u, "Depth of TU tree for inter CUs")
916	#endif
917
918	// Coding structure paramters
919	#if SVC_EXTENSION
920	("IntraPeriod%d,-ip%d", cfg_IntraPeriod, -1, MAX_LAYERS, "intra period in frames for layer %d, (-1: only first frame)")
921	#else
922	("IntraPeriod,-ip", m_iIntraPeriod, -1, "Intra period in frames, (-1: only first frame)")
923	#endif
924	#if ALLOW_RECOVERY_POINT_AS_RAP
925	("DecodingRefreshType,-dr", m_iDecodingRefreshType, 0, "Intra refresh type (0:none 1:CRA 2:IDR 3:RecPointSEI)")
926	#else
927	("DecodingRefreshType,-dr", m_iDecodingRefreshType, 0, "Intra refresh type (0:none 1:CRA 2:IDR)")
928	#endif
929	("GOPSize,g", m_iGOPSize, 1, "GOP size of temporal structure")
930	// motion options
931	("FastSearch", m_iFastSearch, 1, "0:Full search 1:Diamond 2:PMVFAST")
932	("SearchRange,-sr", m_iSearchRange, 96, "Motion search range")
933	("BipredSearchRange", m_bipredSearchRange, 4, "Motion search range for bipred refinement")
934	("HadamardME", m_bUseHADME, true, "Hadamard ME for fractional-pel")
935	("ASR", m_bUseASR, false, "Adaptive motion search range")
936
937	#if SVC_EXTENSION
938	("LambdaModifier%d,-LM%d", m_adLambdaModifier, ( double )1.0, MAX_TLAYER, "Lambda modifier for temporal layer %d")
939	#else
940	// Mode decision parameters
941	("LambdaModifier0,-LM0", m_adLambdaModifier[ 0 ], ( Double )1.0, "Lambda modifier for temporal layer 0")
942	("LambdaModifier1,-LM1", m_adLambdaModifier[ 1 ], ( Double )1.0, "Lambda modifier for temporal layer 1")
943	("LambdaModifier2,-LM2", m_adLambdaModifier[ 2 ], ( Double )1.0, "Lambda modifier for temporal layer 2")
944	("LambdaModifier3,-LM3", m_adLambdaModifier[ 3 ], ( Double )1.0, "Lambda modifier for temporal layer 3")
945	("LambdaModifier4,-LM4", m_adLambdaModifier[ 4 ], ( Double )1.0, "Lambda modifier for temporal layer 4")
946	("LambdaModifier5,-LM5", m_adLambdaModifier[ 5 ], ( Double )1.0, "Lambda modifier for temporal layer 5")
947	("LambdaModifier6,-LM6", m_adLambdaModifier[ 6 ], ( Double )1.0, "Lambda modifier for temporal layer 6")
948	#endif
949
950	/* Quantization parameters */
951	#if SVC_EXTENSION
952	("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")
953	#else
954	("QP,q", m_fQP, 30.0, "Qp value, if value is float, QP is switched once during encoding")
955	#endif
956	("DeltaQpRD,-dqr",m_uiDeltaQpRD, 0u, "max dQp offset for slice")
957	("MaxDeltaQP,d", m_iMaxDeltaQP, 0, "max dQp offset for block")
958	("MaxCuDQPDepth,-dqd", m_iMaxCuDQPDepth, 0, "max depth for a minimum CuDQP")
959
960	("CbQpOffset,-cbqpofs", m_cbQpOffset, 0, "Chroma Cb QP Offset")
961	("CrQpOffset,-crqpofs", m_crQpOffset, 0, "Chroma Cr QP Offset")
962
963	#if ADAPTIVE_QP_SELECTION
964	("AdaptiveQpSelection,-aqps", m_bUseAdaptQpSelect, false, "AdaptiveQpSelection")
965	#endif
966
967	("AdaptiveQP,-aq", m_bUseAdaptiveQP, false, "QP adaptation based on a psycho-visual model")
968	("MaxQPAdaptationRange,-aqr", m_iQPAdaptationRange, 6, "QP adaptation range")
969	#if !SVC_EXTENSION
970	("dQPFile,m", cfg_dQPFile, string(""), "dQP file name")
971	#endif
972	("RDOQ", m_useRDOQ, true )
973	("RDOQTS", m_useRDOQTS, true )
974	("RDpenalty", m_rdPenalty, 0, "RD-penalty for 32x32 TU for intra in non-intra slices. 0:disbaled 1:RD-penalty 2:maximum RD-penalty")
975
976	// Deblocking filter parameters
977	("LoopFilterDisable", m_bLoopFilterDisable, false )
978	("LoopFilterOffsetInPPS", m_loopFilterOffsetInPPS, false )
979	("LoopFilterBetaOffset_div2", m_loopFilterBetaOffsetDiv2, 0 )
980	("LoopFilterTcOffset_div2", m_loopFilterTcOffsetDiv2, 0 )
981	("DeblockingFilterControlPresent", m_DeblockingFilterControlPresent, false )
982	("DeblockingFilterMetric", m_DeblockingFilterMetric, false )
983
984	// Coding tools
985	("AMP", m_enableAMP, true, "Enable asymmetric motion partitions")
986	("TransformSkip", m_useTransformSkip, false, "Intra transform skipping")
987	("TransformSkipFast", m_useTransformSkipFast, false, "Fast intra transform skipping")
988	("SAO", m_bUseSAO, true, "Enable Sample Adaptive Offset")
989	("MaxNumOffsetsPerPic", m_maxNumOffsetsPerPic, 2048, "Max number of SAO offset per picture (Default: 2048)")
990	("SAOLcuBoundary", m_saoLcuBoundary, false, "0: right/bottom LCU boundary areas skipped from SAO parameter estimation, 1: non-deblocked pixels are used for those areas")
991	("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")
992	("SliceArgument", m_sliceArgument, 0, "Depending on SliceMode being:"
993	"\t1: max number of CTUs per slice"
994	"\t2: max number of bytes per slice"
995	"\t3: max number of tiles per slice")
996	("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")
997	("SliceSegmentArgument", m_sliceSegmentArgument, 0, "Depending on SliceSegmentMode being:"
998	"\t1: max number of CTUs per slice segment"
999	"\t2: max number of bytes per slice segment"
1000	"\t3: max number of tiles per slice segment")
1001	("LFCrossSliceBoundaryFlag", m_bLFCrossSliceBoundaryFlag, true)
1002
1003	("ConstrainedIntraPred", m_bUseConstrainedIntraPred, false, "Constrained Intra Prediction")
1004
1005	("PCMEnabledFlag", m_usePCM, false)
1006	("PCMLog2MaxSize", m_pcmLog2MaxSize, 5u)
1007	("PCMLog2MinSize", m_uiPCMLog2MinSize, 3u)
1008	("PCMInputBitDepthFlag", m_bPCMInputBitDepthFlag, true)
1009	("PCMFilterDisableFlag", m_bPCMFilterDisableFlag, false)
1010
1011	("WeightedPredP,-wpP", m_useWeightedPred, false, "Use weighted prediction in P slices")
1012	("WeightedPredB,-wpB", m_useWeightedBiPred, false, "Use weighted (bidirectional) prediction in B slices")
1013	("Log2ParallelMergeLevel", m_log2ParallelMergeLevel, 2u, "Parallel merge estimation region")
1014
1015	//deprecated copies of renamed tile parameters
1016	("UniformSpacingIdc", m_tileUniformSpacingFlag, false, "deprecated alias of TileUniformSpacing")
1017	("ColumnWidthArray", cfgColumnWidth, string(""), "deprecated alias of TileColumnWidthArray")
1018	("RowHeightArray", cfgRowHeight, string(""), "deprecated alias of TileRowHeightArray")
1019
1020	("TileUniformSpacing", m_tileUniformSpacingFlag, false, "Indicates that tile columns and rows are distributed uniformly")
1021	("NumTileColumnsMinus1", m_numTileColumnsMinus1, 0, "Number of tile columns in a picture minus 1")
1022	("NumTileRowsMinus1", m_numTileRowsMinus1, 0, "Number of rows in a picture minus 1")
1023	("TileColumnWidthArray", cfgColumnWidth, string(""), "Array containing tile column width values in units of LCU")
1024	("TileRowHeightArray", cfgRowHeight, string(""), "Array containing tile row height values in units of LCU")
1025	("LFCrossTileBoundaryFlag", m_bLFCrossTileBoundaryFlag, true, "1: cross-tile-boundary loop filtering. 0:non-cross-tile-boundary loop filtering")
1026	#if SVC_EXTENSION
1027	("WaveFrontSynchro%d", cfg_waveFrontSynchro, 0, MAX_LAYERS, "0: no synchro; 1 synchro with TR; 2 TRR etc")
1028	#else
1029	("WaveFrontSynchro", m_iWaveFrontSynchro, 0, "0: no synchro; 1 synchro with TR; 2 TRR etc")
1030	#endif
1031	("ScalingList", m_useScalingListId, 0, "0: no scaling list, 1: default scaling lists, 2: scaling lists specified in ScalingListFile")
1032	("ScalingListFile", cfg_ScalingListFile, string(""), "Scaling list file name")
1033	("SignHideFlag,-SBH", m_signHideFlag, 1)
1034	("MaxNumMergeCand", m_maxNumMergeCand, 5u, "Maximum number of merge candidates")
1035
1036	/* Misc. */
1037	("SEIDecodedPictureHash", m_decodedPictureHashSEIEnabled, 0, "Control generation of decode picture hash SEI messages\n"
1038	"\t3: checksum\n"
1039	"\t2: CRC\n"
1040	"\t1: use MD5\n"
1041	"\t0: disable")
1042	("SEIpictureDigest", m_decodedPictureHashSEIEnabled, 0, "deprecated alias for SEIDecodedPictureHash")
1043	("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")
1044	("FEN", m_bUseFastEnc, false, "fast encoder setting")
1045	("ECU", m_bUseEarlyCU, false, "Early CU setting")
1046	("FDM", m_useFastDecisionForMerge, true, "Fast decision for Merge RD Cost")
1047	("CFM", m_bUseCbfFastMode, false, "Cbf fast mode setting")
1048	("ESD", m_useEarlySkipDetection, false, "Early SKIP detection setting")
1049	#if FAST_INTRA_SHVC
1050	("FIS", m_useFastIntraScalable, false, "Fast Intra Decision for Scalable HEVC")
1051	#endif
1052	#if RC_SHVC_HARMONIZATION
1053	("RateControl%d", cfg_RCEnableRateControl, false, MAX_LAYERS, "Rate control: enable rate control for layer %d")
1054	("TargetBitrate%d", cfg_RCTargetBitRate, 0, MAX_LAYERS, "Rate control: target bitrate for layer %d")
1055	("KeepHierarchicalBit%d", cfg_RCKeepHierarchicalBit, false, MAX_LAYERS, "Rate control: keep hierarchical bit allocation for layer %d")
1056	("LCULevelRateControl%d", cfg_RCLCULevelRC, true, MAX_LAYERS, "Rate control: LCU level RC")
1057	("RCLCUSeparateModel%d", cfg_RCUseLCUSeparateModel, true, MAX_LAYERS, "Rate control: Use LCU level separate R-lambda model")
1058	("InitialQP%d", cfg_RCInitialQP, 0, MAX_LAYERS, "Rate control: initial QP")
1059	("RCForceIntraQP%d", cfg_RCForceIntraQP, false, MAX_LAYERS, "Rate control: force intra QP to be equal to initial QP")
1060	#else
1061	( "RateControl", m_RCEnableRateControl, false, "Rate control: enable rate control" )
1062	( "TargetBitrate", m_RCTargetBitrate, 0, "Rate control: target bitrate" )
1063	( "KeepHierarchicalBit", m_RCKeepHierarchicalBit, 0, "Rate control: 0: equal bit allocation; 1: fixed ratio bit allocation; 2: adaptive ratio bit allocation" )
1064	( "LCULevelRateControl", m_RCLCULevelRC, true, "Rate control: true: LCU level RC; false: picture level RC" )
1065	( "RCLCUSeparateModel", m_RCUseLCUSeparateModel, true, "Rate control: use LCU level separate R-lambda model" )
1066	( "InitialQP", m_RCInitialQP, 0, "Rate control: initial QP" )
1067	( "RCForceIntraQP", m_RCForceIntraQP, false, "Rate control: force intra QP to be equal to initial QP" )
1068	#endif
1069
1070	("TransquantBypassEnableFlag", m_TransquantBypassEnableFlag, false, "transquant_bypass_enable_flag indicator in PPS")
1071	("CUTransquantBypassFlagForce", m_CUTransquantBypassFlagForce, false, "Force transquant bypass mode, when transquant_bypass_enable_flag is enabled")
1072	("RecalculateQPAccordingToLambda", m_recalculateQPAccordingToLambda, false, "Recalculate QP values according to lambda values. Do not suggest to be enabled in all intra case")
1073	("StrongIntraSmoothing,-sis", m_useStrongIntraSmoothing, true, "Enable strong intra smoothing for 32x32 blocks")
1074	("SEIActiveParameterSets", m_activeParameterSetsSEIEnabled, 0, "Enable generation of active parameter sets SEI messages")
1075	("VuiParametersPresent,-vui", m_vuiParametersPresentFlag, false, "Enable generation of vui_parameters()")
1076	("AspectRatioInfoPresent", m_aspectRatioInfoPresentFlag, false, "Signals whether aspect_ratio_idc is present")
1077	("AspectRatioIdc", m_aspectRatioIdc, 0, "aspect_ratio_idc")
1078	("SarWidth", m_sarWidth, 0, "horizontal size of the sample aspect ratio")
1079	("SarHeight", m_sarHeight, 0, "vertical size of the sample aspect ratio")
1080	("OverscanInfoPresent", m_overscanInfoPresentFlag, false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n")
1081	("OverscanAppropriate", m_overscanAppropriateFlag, false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n")
1082	("VideoSignalTypePresent", m_videoSignalTypePresentFlag, false, "Signals whether video_format, video_full_range_flag, and colour_description_present_flag are present")
1083	("VideoFormat", m_videoFormat, 5, "Indicates representation of pictures")
1084	("VideoFullRange", m_videoFullRangeFlag, false, "Indicates the black level and range of luma and chroma signals")
1085	("ColourDescriptionPresent", m_colourDescriptionPresentFlag, false, "Signals whether colour_primaries, transfer_characteristics and matrix_coefficients are present")
1086	("ColourPrimaries", m_colourPrimaries, 2, "Indicates chromaticity coordinates of the source primaries")
1087	("TransferCharacteristics", m_transferCharacteristics, 2, "Indicates the opto-electronic transfer characteristics of the source")
1088	("MatrixCoefficients", m_matrixCoefficients, 2, "Describes the matrix coefficients used in deriving luma and chroma from RGB primaries")
1089	("ChromaLocInfoPresent", m_chromaLocInfoPresentFlag, false, "Signals whether chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field are present")
1090	("ChromaSampleLocTypeTopField", m_chromaSampleLocTypeTopField, 0, "Specifies the location of chroma samples for top field")
1091	("ChromaSampleLocTypeBottomField", m_chromaSampleLocTypeBottomField, 0, "Specifies the location of chroma samples for bottom field")
1092	("NeutralChromaIndication", m_neutralChromaIndicationFlag, false, "Indicates that the value of all decoded chroma samples is equal to 1<<(BitDepthCr-1)")
1093	("DefaultDisplayWindowFlag", m_defaultDisplayWindowFlag, false, "Indicates the presence of the Default Window parameters")
1094	("DefDispWinLeftOffset", m_defDispWinLeftOffset, 0, "Specifies the left offset of the default display window from the conformance window")
1095	("DefDispWinRightOffset", m_defDispWinRightOffset, 0, "Specifies the right offset of the default display window from the conformance window")
1096	("DefDispWinTopOffset", m_defDispWinTopOffset, 0, "Specifies the top offset of the default display window from the conformance window")
1097	("DefDispWinBottomOffset", m_defDispWinBottomOffset, 0, "Specifies the bottom offset of the default display window from the conformance window")
1098	("FrameFieldInfoPresentFlag", m_frameFieldInfoPresentFlag, false, "Indicates that pic_struct and field coding related values are present in picture timing SEI messages")
1099	("PocProportionalToTimingFlag", m_pocProportionalToTimingFlag, false, "Indicates that the POC value is proportional to the output time w.r.t. first picture in CVS")
1100	("NumTicksPocDiffOneMinus1", m_numTicksPocDiffOneMinus1, 0, "Number of ticks minus 1 that for a POC difference of one")
1101	("BitstreamRestriction", m_bitstreamRestrictionFlag, false, "Signals whether bitstream restriction parameters are present")
1102	("TilesFixedStructure", m_tilesFixedStructureFlag, false, "Indicates that each active picture parameter set has the same values of the syntax elements related to tiles")
1103	("MotionVectorsOverPicBoundaries", m_motionVectorsOverPicBoundariesFlag, false, "Indicates that no samples outside the picture boundaries are used for inter prediction")
1104	("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")
1105	("MaxBitsPerMinCuDenom", m_maxBitsPerMinCuDenom, 1, "Indicates an upper bound for the number of bits of coding_unit() data")
1106	("Log2MaxMvLengthHorizontal", m_log2MaxMvLengthHorizontal, 15, "Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units")
1107	("Log2MaxMvLengthVertical", m_log2MaxMvLengthVertical, 15, "Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units")
1108	("SEIRecoveryPoint", m_recoveryPointSEIEnabled, 0, "Control generation of recovery point SEI messages")
1109	("SEIBufferingPeriod", m_bufferingPeriodSEIEnabled, 0, "Control generation of buffering period SEI messages")
1110	("SEIPictureTiming", m_pictureTimingSEIEnabled, 0, "Control generation of picture timing SEI messages")
1111	("SEIToneMappingInfo", m_toneMappingInfoSEIEnabled, false, "Control generation of Tone Mapping SEI messages")
1112	("SEIToneMapId", m_toneMapId, 0, "Specifies Id of Tone Mapping SEI message for a given session")
1113	("SEIToneMapCancelFlag", m_toneMapCancelFlag, false, "Indicates that Tone Mapping SEI message cancels the persistance or follows")
1114	("SEIToneMapPersistenceFlag", m_toneMapPersistenceFlag, true, "Specifies the persistence of the Tone Mapping SEI message")
1115	("SEIToneMapCodedDataBitDepth", m_toneMapCodedDataBitDepth, 8, "Specifies Coded Data BitDepth of Tone Mapping SEI messages")
1116	("SEIToneMapTargetBitDepth", m_toneMapTargetBitDepth, 8, "Specifies Output BitDepth of Tome mapping function")
1117	("SEIToneMapModelId", m_toneMapModelId, 0, "Specifies Model utilized for mapping coded data into target_bit_depth range\n"
1118	"\t0: linear mapping with clipping\n"
1119	"\t1: sigmoidal mapping\n"
1120	"\t2: user-defined table mapping\n"
1121	"\t3: piece-wise linear mapping\n"
1122	"\t4: luminance dynamic range information ")
1123	("SEIToneMapMinValue", m_toneMapMinValue, 0, "Specifies the minimum value in mode 0")
1124	("SEIToneMapMaxValue", m_toneMapMaxValue, 1023, "Specifies the maxmum value in mode 0")
1125	("SEIToneMapSigmoidMidpoint", m_sigmoidMidpoint, 512, "Specifies the centre point in mode 1")
1126	("SEIToneMapSigmoidWidth", m_sigmoidWidth, 960, "Specifies the distance between 5% and 95% values of the target_bit_depth in mode 1")
1127	("SEIToneMapStartOfCodedInterval", cfg_startOfCodedInterval, string(""), "Array of user-defined mapping table")
1128	("SEIToneMapNumPivots", m_numPivots, 0, "Specifies the number of pivot points in mode 3")
1129	("SEIToneMapCodedPivotValue", cfg_codedPivotValue, string(""), "Array of pivot point")
1130	("SEIToneMapTargetPivotValue", cfg_targetPivotValue, string(""), "Array of pivot point")
1131	("SEIToneMapCameraIsoSpeedIdc", m_cameraIsoSpeedIdc, 0, "Indicates the camera ISO speed for daylight illumination")
1132	("SEIToneMapCameraIsoSpeedValue", m_cameraIsoSpeedValue, 400, "Specifies the camera ISO speed for daylight illumination of Extended_ISO")
1133	("SEIToneMapExposureIndexIdc", m_exposureIndexIdc, 0, "Indicates the exposure index setting of the camera")
1134	("SEIToneMapExposureIndexValue", m_exposureIndexValue, 400, "Specifies the exposure index setting of the cameran of Extended_ISO")
1135	("SEIToneMapExposureCompensationValueSignFlag", m_exposureCompensationValueSignFlag, 0, "Specifies the sign of ExposureCompensationValue")
1136	("SEIToneMapExposureCompensationValueNumerator", m_exposureCompensationValueNumerator, 0, "Specifies the numerator of ExposureCompensationValue")
1137	("SEIToneMapExposureCompensationValueDenomIdc", m_exposureCompensationValueDenomIdc, 2, "Specifies the denominator of ExposureCompensationValue")
1138	("SEIToneMapRefScreenLuminanceWhite", m_refScreenLuminanceWhite, 350, "Specifies reference screen brightness setting in units of candela per square metre")
1139	("SEIToneMapExtendedRangeWhiteLevel", m_extendedRangeWhiteLevel, 800, "Indicates the luminance dynamic range")
1140	("SEIToneMapNominalBlackLevelLumaCodeValue", m_nominalBlackLevelLumaCodeValue, 16, "Specifies luma sample value of the nominal black level assigned decoded pictures")
1141	("SEIToneMapNominalWhiteLevelLumaCodeValue", m_nominalWhiteLevelLumaCodeValue, 235, "Specifies luma sample value of the nominal white level assigned decoded pictures")
1142	("SEIToneMapExtendedWhiteLevelLumaCodeValue", m_extendedWhiteLevelLumaCodeValue, 300, "Specifies luma sample value of the extended dynamic range assigned decoded pictures")
1143	("SEIFramePacking", m_framePackingSEIEnabled, 0, "Control generation of frame packing SEI messages")
1144	("SEIFramePackingType", m_framePackingSEIType, 0, "Define frame packing arrangement\n"
1145	"\t0: checkerboard - pixels alternatively represent either frames\n"
1146	"\t1: column alternation - frames are interlaced by column\n"
1147	"\t2: row alternation - frames are interlaced by row\n"
1148	"\t3: side by side - frames are displayed horizontally\n"
1149	"\t4: top bottom - frames are displayed vertically\n"
1150	"\t5: frame alternation - one frame is alternated with the other")
1151	("SEIFramePackingId", m_framePackingSEIId, 0, "Id of frame packing SEI message for a given session")
1152	("SEIFramePackingQuincunx", m_framePackingSEIQuincunx, 0, "Indicate the presence of a Quincunx type video frame")
1153	("SEIFramePackingInterpretation", m_framePackingSEIInterpretation, 0, "Indicate the interpretation of the frame pair\n"
1154	"\t0: unspecified\n"
1155	"\t1: stereo pair, frame0 represents left view\n"
1156	"\t2: stereo pair, frame0 represents right view")
1157	("SEIDisplayOrientation", m_displayOrientationSEIAngle, 0, "Control generation of display orientation SEI messages\n"
1158	"\tN: 0 < N < (2^16 - 1) enable display orientation SEI message with anticlockwise_rotation = N and display_orientation_repetition_period = 1\n"
1159	"\t0: disable")
1160	("SEITemporalLevel0Index", m_temporalLevel0IndexSEIEnabled, 0, "Control generation of temporal level 0 index SEI messages")
1161	("SEIGradualDecodingRefreshInfo", m_gradualDecodingRefreshInfoEnabled, 0, "Control generation of gradual decoding refresh information SEI message")
1162	("SEIDecodingUnitInfo", m_decodingUnitInfoSEIEnabled, 0, "Control generation of decoding unit information SEI message.")
1163	#if LAYERS_NOT_PRESENT_SEI
1164	("SEILayersNotPresent", m_layersNotPresentSEIEnabled, 0, "Control generation of layers not present SEI message")
1165	#endif
1166	("SEISOPDescription", m_SOPDescriptionSEIEnabled, 0, "Control generation of SOP description SEI messages")
1167	("SEIScalableNesting", m_scalableNestingSEIEnabled, 0, "Control generation of scalable nesting SEI messages")
1168	#if P0050_KNEE_FUNCTION_SEI
1169	("SEIKneeFunctionInfo", m_kneeSEIEnabled, false, "Control generation of Knee function SEI messages")
1170	("SEIKneeFunctionId", m_kneeSEIId, 0, "Specifies Id of Knee function SEI message for a given session")
1171	("SEIKneeFunctionCancelFlag", m_kneeSEICancelFlag, false, "Indicates that Knee function SEI message cancels the persistance or follows")
1172	("SEIKneeFunctionPersistenceFlag", m_kneeSEIPersistenceFlag, true, "Specifies the persistence of the Knee function SEI message")
1173	("SEIKneeFunctionMappingFlag", m_kneeSEIMappingFlag, false, "Specifies the mapping mode of the Knee function SEI message")
1174	("SEIKneeFunctionInputDrange", m_kneeSEIInputDrange, 1000, "Specifies the peak luminance level for the input picture of Knee function SEI messages")
1175	("SEIKneeFunctionInputDispLuminance", m_kneeSEIInputDispLuminance, 100, "Specifies the expected display brightness for the input picture of Knee function SEI messages")
1176	("SEIKneeFunctionOutputDrange", m_kneeSEIOutputDrange, 4000, "Specifies the peak luminance level for the output picture of Knee function SEI messages")
1177	("SEIKneeFunctionOutputDispLuminance", m_kneeSEIOutputDispLuminance, 800, "Specifies the expected display brightness for the output picture of Knee function SEI messages")
1178	("SEIKneeFunctionNumKneePointsMinus1", m_kneeSEINumKneePointsMinus1, 2, "Specifies the number of knee points - 1")
1179	("SEIKneeFunctionInputKneePointValue", cfg_kneeSEIInputKneePointValue, string("600 800 900"), "Array of input knee point")
1180	("SEIKneeFunctionOutputKneePointValue", cfg_kneeSEIOutputKneePointValue, string("100 250 450"), "Array of output knee point")
1181	#endif
1182	#if Q0096_OVERLAY_SEI
1183	("SEIOverlayInfo", m_overlaySEIEnabled, false, "Control generation of Selectable Overlays SEI messages")
1184	("SEIOverlayCancelFlag", m_overlayInfoCancelFlag, true, "Indicates that Selectable Overlay SEI message cancels the persistance or follows (default: 1)")
1185	("SEIOverlayContentAuxIdMinus128", m_overlayContentAuxIdMinus128, UInt(0), "Indicates the AuxId value of auxiliary pictures containing overlay content - 128")
1186	("SEIOverlayLabelAuxIdMinus128", m_overlayLabelAuxIdMinus128, UInt(1), "Indicates the AuxId value of auxiliary pictures containing label content - 128")
1187	("SEIOverlayAlphaAuxIdMinus128", m_overlayAlphaAuxIdMinus128, UInt(2), "Indicates the AuxId value of auxiliary pictures containing alpha content - 128")
1188	("SEIOverlayElementLabelValueLengthMinus8", m_overlayElementLabelValueLengthMinus8, UInt(0), "Indicates the number of bits used for coding min and max label values - 8")
1189	("SEIOverlayNumOverlaysMinus1", m_numOverlaysMinus1, UInt(0), "Specifies the number of overlays described by this SEI message - 1")
1190	("SEIOverlayIdx0", cfg_overlaySEIIdx[0], UInt(0), "Indicates the index of overlay 0")
1191	("SEIOverlayIdx1", cfg_overlaySEIIdx[1], UInt(1), "Indicates the index of overlay 1")
1192	("SEIOverlayIdx2", cfg_overlaySEIIdx[2], UInt(2), "Indicates the index of overlay 2")
1193	("SEIOverlayLanguagePresentFlag0", cfg_overlaySEILanguagePresentFlag[0], false, "Indicates if the language for overlay 0 is specified")
1194	("SEIOverlayLanguagePresentFlag1", cfg_overlaySEILanguagePresentFlag[1], false, "Indicates if the language for overlay 1 is specified")
1195	("SEIOverlayLanguagePresentFlag2", cfg_overlaySEILanguagePresentFlag[2], false, "Indicates if the language for overlay 2 is specified")
1196	("SEIOverlayContentLayerId0", cfg_overlaySEIContentLayerId[0], UInt(0), "Indicates the nuh_layer_id value of the overlay content of overlay 0")
1197	("SEIOverlayContentLayerId1", cfg_overlaySEIContentLayerId[1], UInt(0), "Indicates the nuh_layer_id value of the overlay content of overlay 1")
1198	("SEIOverlayContentLayerId2", cfg_overlaySEIContentLayerId[2], UInt(0), "Indicates the nuh_layer_id value of the overlay content of overlay 2")
1199	("SEIOverlayLabelPresentFlag0", cfg_overlaySEILabelPresentFlag[0], false, "Specifies if label content 0 is present")
1200	("SEIOverlayLabelPresentFlag1", cfg_overlaySEILabelPresentFlag[1], false, "Specifies if label content 1 is present")
1201	("SEIOverlayLabelPresentFlag2", cfg_overlaySEILabelPresentFlag[2], false, "Specifies if label content 2 is present")
1202	("SEIOverlayLabelLayerId0", cfg_overlaySEILabelLayerId[0], UInt(0), "Specifies the nuh_layer_id value of the label content of overlay 0")
1203	("SEIOverlayLabelLayerId1", cfg_overlaySEILabelLayerId[1], UInt(0), "Specifies the nuh_layer_id value of the label content of overlay 1")
1204	("SEIOverlayLabelLayerId2", cfg_overlaySEILabelLayerId[2], UInt(0), "Specifies the nuh_layer_id value of the label content of overlay 2")
1205	("SEIOverlayAlphaPresentFlag0", cfg_overlaySEIAlphaPresentFlag[0], false, "Specifies if alpha content 0 is present")
1206	("SEIOverlayAlphaPresentFlag1", cfg_overlaySEIAlphaPresentFlag[1], false, "Specifies if alpha content 1 is present")
1207	("SEIOverlayAlphaPresentFlag2", cfg_overlaySEIAlphaPresentFlag[2], false, "Specifies if alpha content 2 is present")
1208	("SEIOverlayAlphaLayerId0", cfg_overlaySEIAlphaLayerId[0], UInt(0), "Specifies the nuh_layer_id value of the alpha content of overlay 0")
1209	("SEIOverlayAlphaLayerId1", cfg_overlaySEIAlphaLayerId[1], UInt(0), "Specifies the nuh_layer_id value of the alpha content of overlay 1")
1210	("SEIOverlayAlphaLayerId2", cfg_overlaySEIAlphaLayerId[2], UInt(0), "Specifies the nuh_layer_id value of the alpha content of overlay 2")
1211	("SEIOverlayNumElementsMinus1_0", cfg_overlaySEINumElementsMinus1[0], UInt(0), "Specifies the number of overlay elements in overlay 0")
1212	("SEIOverlayNumElementsMinus1_1", cfg_overlaySEINumElementsMinus1[1], UInt(0), "Specifies the number of overlay elements in overlay 1")
1213	("SEIOverlayNumElementsMinus1_2", cfg_overlaySEINumElementsMinus1[2], UInt(0), "Specifies the number of overlay elements in overlay 2")
1214	("SEIOverlayElementLabelRange0", cfg_overlaySEIElementLabelRanges[0], string(""), "Array of minimum and maximum values in order min0, max0, min1, max1, etc.\n"""
1215	"indicating the range of sample values corresponding to overlay elements of overlay 0")
1216	("SEIOverlayElementLabelRange1", cfg_overlaySEIElementLabelRanges[1], string(""), "Array of minimum and maximum values in order min0, max0, min1, max1, etc.\n"""
1217	"indicating the range of sample values corresponding to overlay elements of overlay 1")
1218	("SEIOverlayElementLabelRange2", cfg_overlaySEIElementLabelRanges[2], string(""), "Array of minimum and maximum values in order min0, max0, min1, max1, etc.\n"""
1219	"indicating the range of sample values corresponding to overlay elements of overlay 2")
1220	("SEIOverlayLanguage0", cfg_overlaySEILanguage[0], string(""), "Indicates the language of overlay 0 by a language tag according to RFC 5646")
1221	("SEIOverlayLanguage1", cfg_overlaySEILanguage[1], string(""), "Indicates the language of overlay 1 by a language tag according to RFC 5646")
1222	("SEIOverlayLanguage2", cfg_overlaySEILanguage[2], string(""), "Indicates the language of overlay 2 by a language tag according to RFC 5646")
1223	("SEIOverlayName0", cfg_overlaySEIName[0], string("Overlay0"), "Indicates the name of overlay 0")
1224	("SEIOverlayName1", cfg_overlaySEIName[1], string("Overlay1"), "Indicates the name of overlay 1")
1225	("SEIOverlayName2", cfg_overlaySEIName[2], string("Overlay2"), "Indicates the name of overlay 2")
1226	("SEIOverlayElementNames0", cfg_overlaySEIElementNames[0], string(""), "Indicates the names of all overlay elements of overlay 0 in the format name1\|name2\|name3\|...")
1227	("SEIOverlayElementNames1", cfg_overlaySEIElementNames[1], string(""), "Indicates the names of all overlay elements of overlay 1 in the format name1\|name2\|name3\|...")
1228	("SEIOverlayElementNames2", cfg_overlaySEIElementNames[2], string(""), "Indicates the names of all overlay elements of overlay 2 in the format name1\|name2\|name3\|...")
1229	("SEIOverlayPersistenceFlag", m_overlayInfoPersistenceFlag, true, "Indicates if the SEI message applies to the current picture only (0) or also to following pictures (1)")
1230	#endif
1231	#if Q0189_TMVP_CONSTRAINTS
1232	("SEITemporalMotionVectorPredictionConstraints", m_TMVPConstraintsSEIEnabled, 0, "Control generation of TMVP constrants SEI message")
1233	#endif
1234	#if M0040_ADAPTIVE_RESOLUTION_CHANGE
1235	("AdaptiveResolutionChange", m_adaptiveResolutionChange, 0, "Adaptive resolution change frame number. Should coincide with EL RAP picture. (0: disable)")
1236	#endif
1237	#if HIGHER_LAYER_IRAP_SKIP_FLAG
1238	("SkipPictureAtArcSwitch", m_skipPictureAtArcSwitch, false, "Code the higher layer picture in ARC up-switching as a skip picture. (0: disable)")
1239	#endif
1240	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
1241	("SEIInterLayerConstrainedTileSets", m_interLayerConstrainedTileSetsSEIEnabled, false, "Control generation of inter layer constrained tile sets SEI message")
1242	("IlNumSetsInMessage", m_ilNumSetsInMessage, 0u, "Number of inter layer constrained tile sets")
1243	("TileSetsArray", cfg_tileSets, string(""), "Array containing tile sets params (TopLeftTileIndex, BottonRightTileIndex and ilcIdc for each set) ")
1244	#endif
1245	#if O0153_ALT_OUTPUT_LAYER_FLAG
1246	("AltOutputLayerFlag", m_altOutputLayerFlag, false, "Specifies the value of alt_output_layer_flag in VPS extension")
1247	#endif
1248	#if O0149_CROSS_LAYER_BLA_FLAG
1249	("CrossLayerBLAFlag", m_crossLayerBLAFlag, false, "Specifies the value of cross_layer_bla_flag in VPS")
1250	#endif
1251	#if Q0048_CGS_3D_ASYMLUT
1252	("CGS", m_nCGSFlag , 0, "whether CGS is enabled")
1253	("CGSMaxOctantDepth", m_nCGSMaxOctantDepth , 1, "max octant depth")
1254	("CGSMaxYPartNumLog", m_nCGSMaxYPartNumLog2 , 2, "max Y part number ")
1255	("CGSLUTBit", m_nCGSLUTBit , 12, "bit depth of CGS LUT")
1256	#if R0151_CGS_3D_ASYMLUT_IMPROVE
1257	("CGSAdaptC", m_nCGSAdaptiveChroma , 1, "adaptive chroma partition (only for the case of two chroma partitions)")
1258	#endif
1259	#if R0179_ENC_OPT_3DLUT_SIZE
1260	("CGSSizeRDO", m_nCGSLutSizeRDO , 0, "RDOpt selection of best table size (effective when large maximum table size such as 8x8x8 is used)")
1261	#endif
1262	#endif
1263	#if Q0108_TSA_STSA
1264	("InheritCodingStruct%d",m_inheritCodingStruct, 0, MAX_LAYERS, "Predicts the GOP structure of one layer for another layer")
1265	#endif
1266	;
1267
1268	for(Int i=1; i<MAX_GOP+1; i++) {
1269	std::ostringstream cOSS;
1270	cOSS<<"Frame"<<i;
1271	opts.addOptions()(cOSS.str(), m_GOPList[i-1], GOPEntry());
1272	}
1273
1274	#if Q0108_TSA_STSA
1275	for (Int i=1; i<MAX_LAYERS; i++)
1276	{
1277	for(Int j=1; j<MAX_GOP+1; j++)
1278	{
1279	std::ostringstream cOSS;
1280	cOSS<<"Layer"<<i<<"Frame"<<j;
1281	opts.addOptions()(cOSS.str(), m_EhGOPList[i][j-1], GOPEntry());
1282	}
1283	}
1284	#endif
1285
1286	po::setDefaults(opts);
1287	const list<const Char>& argv_unhandled = po::scanArgv(opts, argc, (const Char*) argv);
1288
1289	#if Q0108_TSA_STSA
1290	for (Int i=1; i<MAX_LAYERS; i++)
1291	{
1292	if(m_inheritCodingStruct[i] == 0)
1293	{
1294	for(Int j=1; j<MAX_GOP+1; j++)
1295	{
1296	m_EhGOPList[i][j-1] = m_GOPList[j-1];
1297	}
1298	}
1299	else if( m_inheritCodingStruct[i] > 0)
1300	{
1301	for(Int j=1; j<MAX_GOP+1; j++)
1302	{
1303	m_EhGOPList[i][j-1] = m_EhGOPList[m_inheritCodingStruct[i]][j-1];
1304	}
1305	}
1306	}
1307	#endif
1308
1309	if(m_isField)
1310	{
1311	#if SVC_EXTENSION
1312	for(Int layer = 0; layer < MAX_LAYERS; layer++)
1313	{
1314	//Frame height
1315	m_acLayerCfg[layer].m_iSourceHeightOrg = m_acLayerCfg[layer].m_iSourceHeight;
1316	//Field height
1317	m_acLayerCfg[layer].m_iSourceHeight = m_acLayerCfg[layer].m_iSourceHeight >> 1;
1318	}
1319	#else
1320	//Frame height
1321	m_iSourceHeightOrg = m_iSourceHeight;
1322	//Field height
1323	m_iSourceHeight = m_iSourceHeight >> 1;
1324	#endif
1325	//number of fields to encode
1326	m_framesToBeEncoded *= 2;
1327	}
1328
1329	for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
1330	{
1331	fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
1332	}
1333
1334	if (argc == 1 \|\| do_help)
1335	{
1336	/* argc == 1: no options have been specified */
1337	po::doHelp(cout, opts);
1338	return false;
1339	}
1340
1341	/*
1342	* Set any derived parameters
1343	*/
1344	/* convert std::string to c string for compatability */
1345	#if SVC_EXTENSION
1346	#if AVC_BASE
1347	#if VPS_AVC_BL_FLAG_REMOVAL
1348	if( m_nonHEVCBaseLayerFlag )
1349	#else
1350	if( m_avcBaseLayerFlag )
1351	#endif
1352	{
1353	*cfg_InputFile[0] = cfg_BLInputFile;
1354	}
1355	#endif
1356	m_pBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
1357	#else //SVC_EXTENSION
1358	m_pchInputFile = cfg_InputFile.empty() ? NULL : strdup(cfg_InputFile.c_str());
1359	m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
1360	m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str());
1361	m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());
1362	#if Q0074_COLOUR_REMAPPING_SEI
1363	m_colourRemapSEIFile = cfg_colourRemapSEIFile.empty() ? NULL : strdup(cfg_colourRemapSEIFile.c_str());
1364	#endif
1365	#endif //SVC_EXTENSION
1366
1367
1368	Char* pColumnWidth = cfgColumnWidth.empty() ? NULL: strdup(cfgColumnWidth.c_str());
1369	Char* pRowHeight = cfgRowHeight.empty() ? NULL : strdup(cfgRowHeight.c_str());
1370
1371	if( !m_tileUniformSpacingFlag && m_numTileColumnsMinus1 > 0 )
1372	{
1373	char *str;
1374	int i=0;
1375	m_tileColumnWidth.resize( m_numTileColumnsMinus1 );
1376	str = strtok(pColumnWidth, " ,-");
1377	while(str!=NULL)
1378	{
1379	if( i >= m_numTileColumnsMinus1 )
1380	{
1381	printf( "The number of columns whose width are defined is larger than the allowed number of columns.\n" );
1382	exit( EXIT_FAILURE );
1383	}
1384	m_tileColumnWidth[i] = atoi( str );
1385	str = strtok(NULL, " ,-");
1386	i++;
1387	}
1388	if( i < m_numTileColumnsMinus1 )
1389	{
1390	printf( "The width of some columns is not defined.\n" );
1391	exit( EXIT_FAILURE );
1392	}
1393	}
1394	else
1395	{
1396	m_tileColumnWidth.clear();
1397	}
1398
1399	if( !m_tileUniformSpacingFlag && m_numTileRowsMinus1 > 0 )
1400	{
1401	char *str;
1402	int i=0;
1403	m_tileRowHeight.resize(m_numTileRowsMinus1);
1404	str = strtok(pRowHeight, " ,-");
1405	while(str!=NULL)
1406	{
1407	if( i>=m_numTileRowsMinus1 )
1408	{
1409	printf( "The number of rows whose height are defined is larger than the allowed number of rows.\n" );
1410	exit( EXIT_FAILURE );
1411	}
1412	m_tileRowHeight[i] = atoi( str );
1413	str = strtok(NULL, " ,-");
1414	i++;
1415	}
1416	if( i < m_numTileRowsMinus1 )
1417	{
1418	printf( "The height of some rows is not defined.\n" );
1419	exit( EXIT_FAILURE );
1420	}
1421	}
1422	else
1423	{
1424	m_tileRowHeight.clear();
1425	}
1426	#if SVC_EXTENSION
1427	if( pColumnWidth )
1428	{
1429	free( pColumnWidth );
1430	pColumnWidth = NULL;
1431	}
1432
1433	if( pRowHeight )
1434	{
1435	free( pRowHeight );
1436	pRowHeight = NULL;
1437	}
1438
1439	for(Int layer = 0; layer < MAX_LAYERS; layer++)
1440	{
1441	// If number of scaled ref. layer offsets is non-zero, at least one of the offsets should be specified
1442	if(m_acLayerCfg[layer].m_numScaledRefLayerOffsets)
1443	{
1444	#if O0098_SCALED_REF_LAYER_ID
1445	assert( strcmp(cfg_scaledRefLayerId[layer].c_str(), ""));
1446	#endif
1447	#if REF_REGION_OFFSET
1448	Bool srloFlag =
1449	strcmp(cfg_scaledRefLayerLeftOffset [layer].c_str(), "") \|\|
1450	strcmp(cfg_scaledRefLayerRightOffset [layer].c_str(), "") \|\|
1451	strcmp(cfg_scaledRefLayerTopOffset [layer].c_str(), "") \|\|
1452	strcmp(cfg_scaledRefLayerBottomOffset [layer].c_str(), "");
1453	Bool rroFlag =
1454	strcmp(cfg_refRegionLeftOffset [layer].c_str(), "") \|\|
1455	strcmp(cfg_refRegionRightOffset [layer].c_str(), "") \|\|
1456	strcmp(cfg_refRegionTopOffset [layer].c_str(), "") \|\|
1457	strcmp(cfg_refRegionBottomOffset [layer].c_str(), "");
1458	#if R0209_GENERIC_PHASE
1459	Bool phaseSetFlag =
1460	strcmp(cfg_phaseHorLuma [layer].c_str(), "") \|\|
1461	strcmp(cfg_phaseVerLuma [layer].c_str(), "") \|\|
1462	strcmp(cfg_phaseHorChroma [layer].c_str(), "") \|\|
1463	strcmp(cfg_phaseVerChroma [layer].c_str(), "");
1464	assert( srloFlag \|\| rroFlag \|\| phaseSetFlag);
1465	#else
1466	assert( srloFlag \|\| rroFlag );
1467	#endif
1468	#else
1469	#if P0312_VERT_PHASE_ADJ
1470	assert( strcmp(cfg_scaledRefLayerLeftOffset[layer].c_str(), "") \|\|
1471	strcmp(cfg_scaledRefLayerRightOffset[layer].c_str(), "") \|\|
1472	strcmp(cfg_scaledRefLayerTopOffset[layer].c_str(), "") \|\|
1473	strcmp(cfg_scaledRefLayerBottomOffset[layer].c_str(),"") \|\|
1474	strcmp(cfg_vertPhasePositionEnableFlag[layer].c_str(),"") );
1475	#else
1476	assert( strcmp(cfg_scaledRefLayerLeftOffset[layer].c_str(), "") \|\|
1477	strcmp(cfg_scaledRefLayerRightOffset[layer].c_str(), "") \|\|
1478	strcmp(cfg_scaledRefLayerTopOffset[layer].c_str(), "") \|\|
1479	strcmp(cfg_scaledRefLayerBottomOffset[layer].c_str(),"") );
1480	#endif
1481	#endif
1482	}
1483
1484	Int *tempArray = NULL; // Contain the value
1485
1486	#if O0098_SCALED_REF_LAYER_ID
1487	// ID //
1488	if(strcmp(cfg_scaledRefLayerId[layer].c_str(), ""))
1489	{
1490	cfgStringToArray( &tempArray, cfg_scaledRefLayerId[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "ScaledRefLayerId");
1491	if(tempArray)
1492	{
1493	for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1494	{
1495	m_acLayerCfg[layer].m_scaledRefLayerId[i] = tempArray[i];
1496	}
1497	delete [] tempArray; tempArray = NULL;
1498	}
1499	}
1500	#endif
1501
1502	#if REF_REGION_OFFSET
1503	// Presense Flag //
1504	if(strcmp(cfg_scaledRefLayerOffsetPresentFlag[layer].c_str(), ""))
1505	{
1506	cfgStringToArray( &tempArray, cfg_scaledRefLayerOffsetPresentFlag[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "ScaledRefLayerOffsetPresentFlag");
1507	if(tempArray)
1508	{
1509	for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1510	{
1511	m_acLayerCfg[layer].m_scaledRefLayerOffsetPresentFlag[i] = tempArray[i];
1512	}
1513	delete [] tempArray; tempArray = NULL;
1514	}
1515	}
1516	#endif
1517
1518	// Left offset //
1519	if(strcmp(cfg_scaledRefLayerLeftOffset[layer].c_str(), ""))
1520	{
1521	cfgStringToArray( &tempArray, cfg_scaledRefLayerLeftOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "LeftOffset");
1522	if(tempArray)
1523	{
1524	for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1525	{
1526	m_acLayerCfg[layer].m_scaledRefLayerLeftOffset[i] = tempArray[i];
1527	}
1528	delete [] tempArray; tempArray = NULL;
1529	}
1530	}
1531
1532	// Top offset //
1533	if(strcmp(cfg_scaledRefLayerTopOffset[layer].c_str(), ""))
1534	{
1535	cfgStringToArray( &tempArray, cfg_scaledRefLayerTopOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "TopOffset");
1536	if(tempArray)
1537	{
1538	for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1539	{
1540	m_acLayerCfg[layer].m_scaledRefLayerTopOffset[i] = tempArray[i];
1541	}
1542	delete [] tempArray; tempArray = NULL;
1543	}
1544	}
1545
1546	// Right offset //
1547	if(strcmp(cfg_scaledRefLayerRightOffset[layer].c_str(), ""))
1548	{
1549	cfgStringToArray( &tempArray, cfg_scaledRefLayerRightOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RightOffset");
1550	if(tempArray)
1551	{
1552	for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1553	{
1554	m_acLayerCfg[layer].m_scaledRefLayerRightOffset[i] = tempArray[i];
1555	}
1556	delete [] tempArray; tempArray = NULL;
1557	}
1558	}
1559
1560	// Bottom offset //
1561	if(strcmp(cfg_scaledRefLayerBottomOffset[layer].c_str(), ""))
1562	{
1563	cfgStringToArray( &tempArray, cfg_scaledRefLayerBottomOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "BottomOffset");
1564	if(tempArray)
1565	{
1566	for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1567	{
1568	m_acLayerCfg[layer].m_scaledRefLayerBottomOffset[i] = tempArray[i];
1569	}
1570	delete [] tempArray; tempArray = NULL;
1571	}
1572	}
1573	#if P0312_VERT_PHASE_ADJ
1574	// VertPhasePositionEnableFlag //
1575	if(strcmp(cfg_vertPhasePositionEnableFlag[layer].c_str(), ""))
1576	{
1577	cfgStringToArray( &tempArray, cfg_vertPhasePositionEnableFlag[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "VertPhasePositionEnableFlag");
1578	if(tempArray)
1579	{
1580	for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1581	{
1582	m_acLayerCfg[layer].m_vertPhasePositionEnableFlag[i] = tempArray[i];
1583	}
1584	delete [] tempArray; tempArray = NULL;
1585	}
1586	}
1587	#endif
1588	#if REF_REGION_OFFSET
1589	// Presense Flag //
1590	if(strcmp(cfg_refRegionOffsetPresentFlag[layer].c_str(), ""))
1591	{
1592	cfgStringToArray( &tempArray, cfg_refRegionOffsetPresentFlag[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RefRegionOffsetPresentFlag");
1593	if(tempArray)
1594	{
1595	for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1596	{
1597	m_acLayerCfg[layer].m_refRegionOffsetPresentFlag[i] = tempArray[i];
1598	}
1599	delete [] tempArray; tempArray = NULL;
1600	}
1601	}
1602
1603	// Left offset //
1604	if(strcmp(cfg_refRegionLeftOffset[layer].c_str(), ""))
1605	{
1606	cfgStringToArray( &tempArray, cfg_refRegionLeftOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RefRegionLeftOffset");
1607	if(tempArray)
1608	{
1609	for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1610	{
1611	m_acLayerCfg[layer].m_refRegionLeftOffset[i] = tempArray[i];
1612	}
1613	delete [] tempArray; tempArray = NULL;
1614	}
1615	}
1616
1617	// Top offset //
1618	if(strcmp(cfg_refRegionTopOffset[layer].c_str(), ""))
1619	{
1620	cfgStringToArray( &tempArray, cfg_refRegionTopOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RefRegionTopOffset");
1621	if(tempArray)
1622	{
1623	for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1624	{
1625	m_acLayerCfg[layer].m_refRegionTopOffset[i] = tempArray[i];
1626	}
1627	delete [] tempArray; tempArray = NULL;
1628	}
1629	}
1630
1631	// Right offset //
1632	if(strcmp(cfg_refRegionRightOffset[layer].c_str(), ""))
1633	{
1634	cfgStringToArray( &tempArray, cfg_refRegionRightOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RefRegionRightOffset");
1635	if(tempArray)
1636	{
1637	for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1638	{
1639	m_acLayerCfg[layer].m_refRegionRightOffset[i] = tempArray[i];
1640	}
1641	delete [] tempArray; tempArray = NULL;
1642	}
1643	}
1644
1645	// Bottom offset //
1646	if(strcmp(cfg_refRegionBottomOffset[layer].c_str(), ""))
1647	{
1648	cfgStringToArray( &tempArray, cfg_refRegionBottomOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RefRegionBottomOffset");
1649	if(tempArray)
1650	{
1651	for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
1652	{
1653	m_acLayerCfg[layer].m_refRegionBottomOffset[i] = tempArray[i];
1654	}
1655	delete [] tempArray; tempArray = NULL;
1656	}
1657	}
1658	#endif
1659	#if R0209_GENERIC_PHASE
1660	Int numPhaseSet = m_acLayerCfg[layer].m_numScaledRefLayerOffsets;
1661
1662	// Presense Flag //
1663	if(strcmp(cfg_resamplePhaseSetPresentFlag[layer].c_str(), ""))
1664	{
1665	cfgStringToArray( &tempArray, cfg_resamplePhaseSetPresentFlag[layer], numPhaseSet, "resamplePhaseSetPresentFlag");
1666	if(tempArray)
1667	{
1668	for(Int i = 0; i < numPhaseSet; i++)
1669	{
1670	m_acLayerCfg[layer].m_resamplePhaseSetPresentFlag[i] = tempArray[i];
1671	}
1672	delete [] tempArray; tempArray = NULL;
1673	}
1674	}
1675
1676	// Luma horizontal phase //
1677	if(strcmp(cfg_phaseHorLuma[layer].c_str(), ""))
1678	{
1679	cfgStringToArray( &tempArray, cfg_phaseHorLuma[layer], numPhaseSet, "phaseHorLuma");
1680	if(tempArray)
1681	{
1682	for(Int i = 0; i < numPhaseSet; i++)
1683	{
1684	m_acLayerCfg[layer].m_phaseHorLuma[i] = tempArray[i];
1685	}
1686	delete [] tempArray; tempArray = NULL;
1687	}
1688	}
1689
1690	// Luma vertical phase //
1691	if(strcmp(cfg_phaseVerLuma[layer].c_str(), ""))
1692	{
1693	cfgStringToArray( &tempArray, cfg_phaseVerLuma[layer], numPhaseSet, "phaseVerLuma");
1694	if(tempArray)
1695	{
1696	for(Int i = 0; i < numPhaseSet; i++)
1697	{
1698	m_acLayerCfg[layer].m_phaseVerLuma[i] = tempArray[i];
1699	}
1700	delete [] tempArray; tempArray = NULL;
1701	}
1702	}
1703
1704	// Chroma horizontal phase //
1705	if(strcmp(cfg_phaseHorChroma[layer].c_str(), ""))
1706	{
1707	cfgStringToArray( &tempArray, cfg_phaseHorChroma[layer], numPhaseSet, "phaseHorChroma");
1708	if(tempArray)
1709	{
1710	for(Int i = 0; i < numPhaseSet; i++)
1711	{
1712	m_acLayerCfg[layer].m_phaseHorChroma[i] = tempArray[i];
1713	}
1714	delete [] tempArray; tempArray = NULL;
1715	}
1716	}
1717
1718	// Chroma vertical phase //
1719	if(strcmp(cfg_phaseVerChroma[layer].c_str(), ""))
1720	{
1721	cfgStringToArray( &tempArray, cfg_phaseVerChroma[layer], numPhaseSet, "phaseVerChroma");
1722	if(tempArray)
1723	{
1724	for(Int i = 0; i < numPhaseSet; i++)
1725	{
1726	m_acLayerCfg[layer].m_phaseVerChroma[i] = tempArray[i];
1727	}
1728	delete [] tempArray; tempArray = NULL;
1729	}
1730	}
1731	#endif
1732	}
1733
1734	#if VPS_EXTN_DIRECT_REF_LAYERS
1735	for(Int layer = 0; layer < MAX_LAYERS; layer++)
1736	{
1737	Char* pSamplePredRefLayerIds = cfg_samplePredRefLayerIds[layer].empty() ? NULL: strdup(cfg_samplePredRefLayerIds[layer].c_str());
1738	if( m_acLayerCfg[layer].m_numSamplePredRefLayers > 0 )
1739	{
1740	char *samplePredRefLayerId;
1741	int i=0;
1742	m_acLayerCfg[layer].m_samplePredRefLayerIds = new Int[m_acLayerCfg[layer].m_numSamplePredRefLayers];
1743	samplePredRefLayerId = strtok(pSamplePredRefLayerIds, " ,-");
1744	while(samplePredRefLayerId != NULL)
1745	{
1746	if( i >= m_acLayerCfg[layer].m_numSamplePredRefLayers )
1747	{
1748	printf( "NumSamplePredRefLayers%d: The number of columns whose width are defined is larger than the allowed number of columns.\n", layer );
1749	exit( EXIT_FAILURE );
1750	}
1751	*( m_acLayerCfg[layer].m_samplePredRefLayerIds + i ) = atoi( samplePredRefLayerId );
1752	samplePredRefLayerId = strtok(NULL, " ,-");
1753	i++;
1754	}
1755	if( i < m_acLayerCfg[layer].m_numSamplePredRefLayers )
1756	{
1757	printf( "NumSamplePredRefLayers%d: The width of some columns is not defined.\n", layer );
1758	exit( EXIT_FAILURE );
1759	}
1760	}
1761	else
1762	{
1763	m_acLayerCfg[layer].m_samplePredRefLayerIds = NULL;
1764	}
1765
1766	if( pSamplePredRefLayerIds )
1767	{
1768	free( pSamplePredRefLayerIds );
1769	pSamplePredRefLayerIds = NULL;
1770	}
1771	}
1772	for(Int layer = 0; layer < MAX_LAYERS; layer++)
1773	{
1774	Char* pMotionPredRefLayerIds = cfg_motionPredRefLayerIds[layer].empty() ? NULL: strdup(cfg_motionPredRefLayerIds[layer].c_str());
1775	if( m_acLayerCfg[layer].m_numMotionPredRefLayers > 0 )
1776	{
1777	char *motionPredRefLayerId;
1778	int i=0;
1779	m_acLayerCfg[layer].m_motionPredRefLayerIds = new Int[m_acLayerCfg[layer].m_numMotionPredRefLayers];
1780	motionPredRefLayerId = strtok(pMotionPredRefLayerIds, " ,-");
1781	while(motionPredRefLayerId != NULL)
1782	{
1783	if( i >= m_acLayerCfg[layer].m_numMotionPredRefLayers )
1784	{
1785	printf( "NumMotionPredRefLayers%d: The number of columns whose width are defined is larger than the allowed number of columns.\n", layer );
1786	exit( EXIT_FAILURE );
1787	}
1788	*( m_acLayerCfg[layer].m_motionPredRefLayerIds + i ) = atoi( motionPredRefLayerId );
1789	motionPredRefLayerId = strtok(NULL, " ,-");
1790	i++;
1791	}
1792	if( i < m_acLayerCfg[layer].m_numMotionPredRefLayers )
1793	{
1794	printf( "NumMotionPredRefLayers%d: The width of some columns is not defined.\n", layer );
1795	exit( EXIT_FAILURE );
1796	}
1797	}
1798	else
1799	{
1800	m_acLayerCfg[layer].m_motionPredRefLayerIds = NULL;
1801	}
1802
1803	if( pMotionPredRefLayerIds )
1804	{
1805	free( pMotionPredRefLayerIds );
1806	pMotionPredRefLayerIds = NULL;
1807	}
1808	}
1809
1810	#if AUXILIARY_PICTURES
1811	for(UInt layer = 0; layer < MAX_LAYERS; layer++)
1812	{
1813	m_acLayerCfg[layer].m_InputChromaFormat = numberToChromaFormat(cfg_tmpChromaFormatIDC[layer]);
1814	m_acLayerCfg[layer].m_chromaFormatIDC = ((cfg_tmpChromaFormatIDC[layer] == 0) ? (m_acLayerCfg[layer].m_InputChromaFormat ) : (numberToChromaFormat(cfg_tmpChromaFormatIDC[layer])));
1815	}
1816	#endif
1817	for(Int layer = 0; layer < MAX_LAYERS; layer++)
1818	{
1819	Char* pPredLayerIds = cfg_predLayerIds[layer].empty() ? NULL: strdup(cfg_predLayerIds[layer].c_str());
1820	if( m_acLayerCfg[layer].m_numActiveRefLayers > 0 )
1821	{
1822	char *refLayerId;
1823	int i=0;
1824	m_acLayerCfg[layer].m_predLayerIds = new Int[m_acLayerCfg[layer].m_numActiveRefLayers];
1825	refLayerId = strtok(pPredLayerIds, " ,-");
1826	while(refLayerId != NULL)
1827	{
1828	if( i >= m_acLayerCfg[layer].m_numActiveRefLayers )
1829	{
1830	printf( "NumActiveRefLayers%d: The number of columns whose width are defined is larger than the allowed number of columns.\n", layer );
1831	exit( EXIT_FAILURE );
1832	}
1833	*( m_acLayerCfg[layer].m_predLayerIds + i ) = atoi( refLayerId );
1834	refLayerId = strtok(NULL, " ,-");
1835	i++;
1836	}
1837	if( i < m_acLayerCfg[layer].m_numActiveRefLayers )
1838	{
1839	printf( "NumActiveRefLayers%d: The width of some columns is not defined.\n", layer );
1840	exit( EXIT_FAILURE );
1841	}
1842	}
1843	else
1844	{
1845	m_acLayerCfg[layer].m_predLayerIds = NULL;
1846	}
1847
1848	if( pPredLayerIds )
1849	{
1850	free( pPredLayerIds );
1851	pPredLayerIds = NULL;
1852	}
1853	}
1854	#endif
1855	#if Q0078_ADD_LAYER_SETS
1856	#if OUTPUT_LAYER_SETS_CONFIG
1857	for (Int layerSet = 1; layerSet < m_numLayerSets; layerSet++)
1858	{
1859	// Simplifying the code in the #else section, and allowing 0-th layer set t
1860	assert( scanStringToArray( cfg_layerSetLayerIdList[layerSet], m_numLayerInIdList[layerSet], "NumLayerInIdList", m_layerSetLayerIdList[layerSet] ) );
1861	#else
1862	for (Int layerSet = 0; layerSet < m_numLayerSets; layerSet++)
1863	{
1864	if (m_numLayerInIdList[layerSet] > 0)
1865	{
1866	Char* layerSetLayerIdListDup = cfg_layerSetLayerIdList[layerSet].empty() ? NULL : strdup(cfg_layerSetLayerIdList[layerSet].c_str());
1867	Int i = 0;
1868	char *layerId = strtok(layerSetLayerIdListDup, " ,-");
1869	while (layerId != NULL)
1870	{
1871	if (i >= m_numLayerInIdList[layerSet])
1872	{
1873	printf("NumLayerInIdList%d: The number of layers in the set is larger than the allowed number of layers.\n", layerSet);
1874	exit(EXIT_FAILURE);
1875	}
1876	m_layerSetLayerIdList[layerSet][i] = atoi(layerId);
1877	layerId = strtok(NULL, " ,-");
1878	i++;
1879	}
1880
1881	if( layerSetLayerIdListDup )
1882	{
1883	free( layerSetLayerIdListDup );
1884	layerSetLayerIdListDup = NULL;
1885	}
1886	}
1887	#endif
1888	}
1889	for (Int addLayerSet = 0; addLayerSet < m_numAddLayerSets; addLayerSet++)
1890	{
1891	#if OUTPUT_LAYER_SETS_CONFIG
1892	// Simplifying the code in the #else section
1893	#if FIX_LAYER_ID_INIT
1894	assert( scanStringToArray( cfg_highestLayerIdx[addLayerSet], m_numHighestLayerIdx[addLayerSet], "HighestLayerIdx", m_highestLayerIdx[addLayerSet] ) );
1895	#else
1896	assert( scanStringToArray( cfg_layerSetLayerIdList[addLayerSet], m_numLayerInIdList[addLayerSet], "NumLayerInIdList", m_highestLayerIdx[addLayerSet] ) );
1897	#endif
1898	#else
1899	if (m_numHighestLayerIdx[addLayerSet] > 0)
1900	{
1901	Char* highestLayrIdxListDup = cfg_highestLayerIdx[addLayerSet].empty() ? NULL : strdup(cfg_highestLayerIdx[addLayerSet].c_str());
1902	Int i = 0;
1903	char *layerIdx = strtok(highestLayrIdxListDup, " ,-");
1904	while (layerIdx != NULL)
1905	{
1906	if (i >= m_numLayerInIdList[addLayerSet])
1907	{
1908	printf("NumLayerInIdList%d: The number of layer idx's in the highest layer idx list is larger than the allowed number of idx's.\n", addLayerSet);
1909	exit(EXIT_FAILURE);
1910	}
1911	m_highestLayerIdx[addLayerSet][i] = atoi(layerIdx);
1912	layerIdx = strtok(NULL, " ,-");
1913	i++;
1914	}
1915
1916	if( highestLayrIdxListDup )
1917	{
1918	free( highestLayrIdxListDup );
1919	highestLayrIdxListDup = NULL;
1920	}
1921	}
1922	#endif
1923	}
1924	#endif
1925	#if OUTPUT_LAYER_SETS_CONFIG
1926	if( m_defaultTargetOutputLayerIdc != -1 )
1927	{
1928	assert( m_defaultTargetOutputLayerIdc >= 0 && m_defaultTargetOutputLayerIdc <= 3 );
1929	}
1930	assert( m_numOutputLayerSets != 0 );
1931	assert( m_numOutputLayerSets >= m_numLayerSets + m_numAddLayerSets ); // Number of output layer sets must be at least as many as layer sets.
1932
1933	// If output layer Set Idx is specified, only specify it for the non-default output layer sets
1934	Int numNonDefaultOls = m_numOutputLayerSets - (m_numLayerSets + m_numAddLayerSets);
1935	if( numNonDefaultOls )
1936	{
1937	assert( scanStringToArray( *cfg_outputLayerSetIdx, numNonDefaultOls, "OutputLayerSetIdx", m_outputLayerSetIdx ) );
1938	for(Int i = 0; i < numNonDefaultOls; i++)
1939	{
1940	assert( m_outputLayerSetIdx[i] >= 0 && m_outputLayerSetIdx[i] < (m_numLayerSets + m_numAddLayerSets) );
1941	}
1942	}
1943
1944	// Number of output layers in output layer sets
1945	scanStringToArray( *cfg_numOutputLayersInOutputLayerSet, m_numOutputLayerSets - 1, "NumOutputLayersInOutputLayerSets", m_numOutputLayersInOutputLayerSet );
1946	m_numOutputLayersInOutputLayerSet.insert(m_numOutputLayersInOutputLayerSet.begin(), 1);
1947	// Layers in the output layer set
1948	m_listOfOutputLayers.resize(m_numOutputLayerSets);
1949
1950	#if MULTIPLE_PTL_SUPPORT
1951	m_listOfLayerPTLofOlss.resize(m_numOutputLayerSets);
1952	#endif
1953
1954	Int startOlsCtr = 1;
1955	if( m_defaultTargetOutputLayerIdc == 0 \|\| m_defaultTargetOutputLayerIdc == 1 )
1956	{
1957	// Default output layer sets defined
1958	startOlsCtr = m_numLayerSets + m_numAddLayerSets;
1959	}
1960	for( Int olsCtr = 1; olsCtr < m_numOutputLayerSets; olsCtr++ )
1961	{
1962	if( olsCtr < startOlsCtr )
1963	{
1964	if(scanStringToArray( cfg_listOfOutputLayers[olsCtr], m_numOutputLayersInOutputLayerSet[olsCtr], "ListOfOutputLayers", m_listOfOutputLayers[olsCtr] ) )
1965	{
1966	std::cout << "Default OLS defined. Ignoring ListOfOutputLayers" << olsCtr << endl;
1967	}
1968	}
1969	else
1970	{
1971	assert( scanStringToArray( cfg_listOfOutputLayers[olsCtr], m_numOutputLayersInOutputLayerSet[olsCtr], "ListOfOutputLayers", m_listOfOutputLayers[olsCtr] ) );
1972	}
1973	#if MULTIPLE_PTL_SUPPORT
1974	Int olsToLsIndex = (olsCtr > startOlsCtr) ? m_outputLayerSetIdx[olsCtr - m_numLayerSets] : olsCtr;
1975	scanStringToArray( cfg_listOfLayerPTLOfOlss[olsCtr], m_numLayerInIdList[olsToLsIndex], "List of PTL for each layers in OLS", m_listOfLayerPTLofOlss[olsCtr] );
1976	//For conformance checking
1977	//Conformance of a layer in an output operation point associated with an OLS in a bitstream to the Scalable Main profile is indicated as follows:
1978	//If OpTid of the output operation point is equal to vps_max_sub_layer_minus1, the conformance is indicated by general_profile_idc being equal to 7 or general_profile_compatibility_flag[ 7 ] being equal to 1
1979	//Conformance of a layer in an output operation point associated with an OLS in a bitstream to the Scalable Main 10 profile is indicated as follows:
1980	//If OpTid of the output operation point is equal to vps_max_sub_layer_minus1, the conformance is indicated by general_profile_idc being equal to 7 or general_profile_compatibility_flag[ 7 ] being equal to 1
1981	//The following assert may be updated / upgraded to take care of general_profile_compatibility_flag.
1982	for ( Int ii = 1; ii < m_numLayerInIdList[olsToLsIndex]; ii++)
1983	{
1984	if (m_layerSetLayerIdList[olsToLsIndex][ii - 1] != 0 && m_layerSetLayerIdList[olsToLsIndex][ii] != 0) //Profile / profile compatibility of enhancement layers must indicate the same profile.
1985	{
1986	assert( (m_profileList[m_listOfLayerPTLofOlss[olsCtr][ii]] == m_profileList[m_listOfLayerPTLofOlss[olsCtr][ii - 1]]) \|\|
1987	(m_profileList[m_listOfLayerPTLofOlss[olsCtr][ii]] == m_profileCompatibility[m_listOfLayerPTLofOlss[olsCtr][ii - 1]]) \|\|
1988	(m_profileCompatibility[m_listOfLayerPTLofOlss[olsCtr][ii]] == m_profileList[m_listOfLayerPTLofOlss[olsCtr][ii - 1]]) );
1989	}
1990	}
1991	#endif
1992	}
1993	#if MULTIPLE_PTL_SUPPORT
1994	m_listOfLayerPTLofOlss[0].push_back(m_layerPTLIdx[0]);
1995	delete [] cfg_listOfLayerPTLOfOlss;
1996	#endif
1997	delete cfg_numOutputLayersInOutputLayerSet;
1998	delete [] cfg_listOfOutputLayers;
1999	delete cfg_outputLayerSetIdx;
2000	#endif
2001	#endif //SVC_EXTENSION
2002	m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str());
2003
2004	/* rules for input, output and internal bitdepths as per help text */
2005	#if O0194_DIFFERENT_BITDEPTH_EL_BL
2006	for(Int layer = 0; layer < MAX_LAYERS; layer++)
2007	{
2008	if (!m_acLayerCfg[layer].m_internalBitDepthY) { m_acLayerCfg[layer].m_internalBitDepthY = m_acLayerCfg[layer].m_inputBitDepthY; }
2009	if (!m_acLayerCfg[layer].m_internalBitDepthC) { m_acLayerCfg[layer].m_internalBitDepthC = m_acLayerCfg[layer].m_internalBitDepthY; }
2010	if (!m_acLayerCfg[layer].m_inputBitDepthC) { m_acLayerCfg[layer].m_inputBitDepthC = m_acLayerCfg[layer].m_inputBitDepthY; }
2011	if (!m_acLayerCfg[layer].m_outputBitDepthY) { m_acLayerCfg[layer].m_outputBitDepthY = m_acLayerCfg[layer].m_internalBitDepthY; }
2012	if (!m_acLayerCfg[layer].m_outputBitDepthC) { m_acLayerCfg[layer].m_outputBitDepthC = m_acLayerCfg[layer].m_internalBitDepthC; }
2013	}
2014	#else
2015	if (!m_internalBitDepthY) { m_internalBitDepthY = m_inputBitDepthY; }
2016	if (!m_internalBitDepthC) { m_internalBitDepthC = m_internalBitDepthY; }
2017	if (!m_inputBitDepthC) { m_inputBitDepthC = m_inputBitDepthY; }
2018	if (!m_outputBitDepthY) { m_outputBitDepthY = m_internalBitDepthY; }
2019	if (!m_outputBitDepthC) { m_outputBitDepthC = m_internalBitDepthC; }
2020	#endif
2021
2022	#if !SVC_EXTENSION
2023	// TODO:ChromaFmt assumes 4:2:0 below
2024	switch (m_conformanceWindowMode)
2025	{
2026	case 0:
2027	{
2028	// no conformance or padding
2029	m_confWinLeft = m_confWinRight = m_confWinTop = m_confWinBottom = 0;
2030	m_aiPad[1] = m_aiPad[0] = 0;
2031	break;
2032	}
2033	case 1:
2034	{
2035	// automatic padding to minimum CU size
2036	Int minCuSize = m_uiMaxCUHeight >> (m_uiMaxCUDepth - 1);
2037	if (m_iSourceWidth % minCuSize)
2038	{
2039	m_aiPad[0] = m_confWinRight = ((m_iSourceWidth / minCuSize) + 1) * minCuSize - m_iSourceWidth;
2040	m_iSourceWidth += m_confWinRight;
2041	}
2042	if (m_iSourceHeight % minCuSize)
2043	{
2044	m_aiPad[1] = m_confWinBottom = ((m_iSourceHeight / minCuSize) + 1) * minCuSize - m_iSourceHeight;
2045	m_iSourceHeight += m_confWinBottom;
2046	if ( m_isField )
2047	{
2048	m_iSourceHeightOrg += m_confWinBottom << 1;
2049	m_aiPad[1] = m_confWinBottom << 1;
2050	}
2051	}
2052	if (m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0)
2053	{
2054	fprintf(stderr, "Error: picture width is not an integer multiple of the specified chroma subsampling\n");
2055	exit(EXIT_FAILURE);
2056	}
2057	if (m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0)
2058	{
2059	fprintf(stderr, "Error: picture height is not an integer multiple of the specified chroma subsampling\n");
2060	exit(EXIT_FAILURE);
2061	}
2062	break;
2063	}
2064	case 2:
2065	{
2066	//padding
2067	m_iSourceWidth += m_aiPad[0];
2068	m_iSourceHeight += m_aiPad[1];
2069	m_confWinRight = m_aiPad[0];
2070	m_confWinBottom = m_aiPad[1];
2071	break;
2072	}
2073	case 3:
2074	{
2075	// conformance
2076	if ((m_confWinLeft == 0) && (m_confWinRight == 0) && (m_confWinTop == 0) && (m_confWinBottom == 0))
2077	{
2078	fprintf(stderr, "Warning: Conformance window enabled, but all conformance window parameters set to zero\n");
2079	}
2080	if ((m_aiPad[1] != 0) \|\| (m_aiPad[0]!=0))
2081	{
2082	fprintf(stderr, "Warning: Conformance window enabled, padding parameters will be ignored\n");
2083	}
2084	m_aiPad[1] = m_aiPad[0] = 0;
2085	break;
2086	}
2087	}
2088
2089	// allocate slice-based dQP values
2090	m_aidQP = new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ];
2091	::memset( m_aidQP, 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
2092
2093	// handling of floating-point QP values
2094	// if QP is not integer, sequence is split into two sections having QP and QP+1
2095	m_iQP = (Int)( m_fQP );
2096	if ( m_iQP < m_fQP )
2097	{
2098	Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP - m_iQP)*m_framesToBeEncoded + 0.5 );
2099
2100	iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
2101	for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
2102	{
2103	m_aidQP[i] = 1;
2104	}
2105	}
2106
2107	// reading external dQP description from file
2108	if ( m_pchdQPFile )
2109	{
2110	FILE* fpt=fopen( m_pchdQPFile, "r" );
2111	if ( fpt )
2112	{
2113	Int iValue;
2114	Int iPOC = 0;
2115	while ( iPOC < m_framesToBeEncoded )
2116	{
2117	if ( fscanf(fpt, "%d", &iValue ) == EOF ) break;
2118	m_aidQP[ iPOC ] = iValue;
2119	iPOC++;
2120	}
2121	fclose(fpt);
2122	}
2123	}
2124	m_iWaveFrontSubstreams = m_iWaveFrontSynchro ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1;
2125	#endif
2126	if( m_toneMappingInfoSEIEnabled && !m_toneMapCancelFlag )
2127	{
2128	Char* pcStartOfCodedInterval = cfg_startOfCodedInterval.empty() ? NULL: strdup(cfg_startOfCodedInterval.c_str());
2129	Char* pcCodedPivotValue = cfg_codedPivotValue.empty() ? NULL: strdup(cfg_codedPivotValue.c_str());
2130	Char* pcTargetPivotValue = cfg_targetPivotValue.empty() ? NULL: strdup(cfg_targetPivotValue.c_str());
2131	if( m_toneMapModelId == 2 && pcStartOfCodedInterval )
2132	{
2133	char *startOfCodedInterval;
2134	UInt num = 1u<< m_toneMapTargetBitDepth;
2135	m_startOfCodedInterval = new Int[num];
2136	::memset( m_startOfCodedInterval, 0, sizeof(Int)*num );
2137	startOfCodedInterval = strtok(pcStartOfCodedInterval, " .");
2138	int i = 0;
2139	while( startOfCodedInterval && ( i < num ) )
2140	{
2141	m_startOfCodedInterval[i] = atoi( startOfCodedInterval );
2142	startOfCodedInterval = strtok(NULL, " .");
2143	i++;
2144	}
2145	}
2146	else
2147	{
2148	m_startOfCodedInterval = NULL;
2149	}
2150	if( ( m_toneMapModelId == 3 ) && ( m_numPivots > 0 ) )
2151	{
2152	if( pcCodedPivotValue && pcTargetPivotValue )
2153	{
2154	char *codedPivotValue;
2155	char *targetPivotValue;
2156	m_codedPivotValue = new Int[m_numPivots];
2157	m_targetPivotValue = new Int[m_numPivots];
2158	::memset( m_codedPivotValue, 0, sizeof(Int)*( m_numPivots ) );
2159	::memset( m_targetPivotValue, 0, sizeof(Int)*( m_numPivots ) );
2160	codedPivotValue = strtok(pcCodedPivotValue, " .");
2161	int i=0;
2162	while(codedPivotValue&&i<m_numPivots)
2163	{
2164	m_codedPivotValue[i] = atoi( codedPivotValue );
2165	codedPivotValue = strtok(NULL, " .");
2166	i++;
2167	}
2168	i=0;
2169	targetPivotValue = strtok(pcTargetPivotValue, " .");
2170	while(targetPivotValue&&i<m_numPivots)
2171	{
2172	m_targetPivotValue[i]= atoi( targetPivotValue );
2173	targetPivotValue = strtok(NULL, " .");
2174	i++;
2175	}
2176	}
2177	}
2178	else
2179	{
2180	m_codedPivotValue = NULL;
2181	m_targetPivotValue = NULL;
2182	}
2183
2184	if( pcStartOfCodedInterval )
2185	{
2186	free( pcStartOfCodedInterval );
2187	pcStartOfCodedInterval = NULL;
2188	}
2189
2190	if( pcCodedPivotValue )
2191	{
2192	free( pcCodedPivotValue );
2193	pcCodedPivotValue = NULL;
2194	}
2195
2196	if( pcTargetPivotValue )
2197	{
2198	free( pcTargetPivotValue );
2199	pcTargetPivotValue = NULL;
2200	}
2201	}
2202	#if P0050_KNEE_FUNCTION_SEI
2203	if( m_kneeSEIEnabled && !m_kneeSEICancelFlag )
2204	{
2205	Char* pcInputKneePointValue = cfg_kneeSEIInputKneePointValue.empty() ? NULL : strdup(cfg_kneeSEIInputKneePointValue.c_str());
2206	Char* pcOutputKneePointValue = cfg_kneeSEIOutputKneePointValue.empty() ? NULL : strdup(cfg_kneeSEIOutputKneePointValue.c_str());
2207	assert ( m_kneeSEINumKneePointsMinus1 >= 0 && m_kneeSEINumKneePointsMinus1 < 999 );
2208	m_kneeSEIInputKneePoint = new Int[m_kneeSEINumKneePointsMinus1+1];
2209	m_kneeSEIOutputKneePoint = new Int[m_kneeSEINumKneePointsMinus1+1];
2210	char *InputVal = strtok(pcInputKneePointValue, " .,");
2211	Int i=0;
2212	while( InputVal && i<(m_kneeSEINumKneePointsMinus1+1) )
2213	{
2214	m_kneeSEIInputKneePoint[i] = (UInt) atoi( InputVal );
2215	InputVal = strtok(NULL, " .,");
2216	i++;
2217	}
2218	char *OutputVal = strtok(pcOutputKneePointValue, " .,");
2219	i=0;
2220	while( OutputVal && i<(m_kneeSEINumKneePointsMinus1+1) )
2221	{
2222	m_kneeSEIOutputKneePoint[i] = (UInt) atoi( OutputVal );
2223	OutputVal = strtok(NULL, " .,");
2224	i++;
2225	}
2226
2227	if( pcInputKneePointValue )
2228	{
2229	free( pcInputKneePointValue );
2230	pcInputKneePointValue = NULL;
2231	}
2232
2233	if( pcOutputKneePointValue )
2234	{
2235	free( pcOutputKneePointValue );
2236	pcOutputKneePointValue = NULL;
2237	}
2238	}
2239	#endif
2240	#if Q0096_OVERLAY_SEI
2241	if( m_overlaySEIEnabled && !m_overlayInfoCancelFlag )
2242	{
2243	m_overlayIdx.resize ( m_numOverlaysMinus1+1 );
2244	m_overlayLanguagePresentFlag.resize ( m_numOverlaysMinus1+1 );
2245	m_overlayContentLayerId.resize ( m_numOverlaysMinus1+1 );
2246	m_overlayLabelPresentFlag.resize ( m_numOverlaysMinus1+1 );
2247	m_overlayLabelLayerId.resize ( m_numOverlaysMinus1+1 );
2248	m_overlayAlphaPresentFlag.resize ( m_numOverlaysMinus1+1 );
2249	m_overlayAlphaLayerId.resize ( m_numOverlaysMinus1+1 );
2250	m_numOverlayElementsMinus1.resize ( m_numOverlaysMinus1+1 );
2251	m_overlayElementLabelMin.resize ( m_numOverlaysMinus1+1 );
2252	m_overlayElementLabelMax.resize ( m_numOverlaysMinus1+1 );
2253	m_overlayLanguage.resize ( m_numOverlaysMinus1+1 );
2254	m_overlayName.resize ( m_numOverlaysMinus1+1 );
2255	m_overlayElementName.resize ( m_numOverlaysMinus1+1 );
2256	for (Int i=0 ; i<=m_numOverlaysMinus1 ; i++)
2257	{
2258	m_overlayIdx[i] = cfg_overlaySEIIdx[i];
2259	m_overlayLanguagePresentFlag[i] = cfg_overlaySEILanguagePresentFlag[i];
2260	m_overlayContentLayerId[i] = cfg_overlaySEIContentLayerId[i];
2261	m_overlayLabelPresentFlag[i] = cfg_overlaySEILabelPresentFlag[i];
2262	m_overlayLabelLayerId[i] = cfg_overlaySEILabelLayerId[i];
2263	m_overlayAlphaPresentFlag[i] = cfg_overlaySEIAlphaPresentFlag[i];
2264	m_overlayAlphaLayerId[i] = cfg_overlaySEIAlphaLayerId[i];
2265	m_numOverlayElementsMinus1[i] = cfg_overlaySEINumElementsMinus1[i];
2266	m_overlayLanguage[i] = cfg_overlaySEILanguage[i];
2267	m_overlayName[i] = cfg_overlaySEIName[i];
2268
2269	//parse min and max values of label elements
2270	istringstream ranges(cfg_overlaySEIElementLabelRanges[i]);
2271	string range;
2272	UInt val;
2273	vector<UInt> vRanges;
2274	while ( getline(ranges, range, ' ') )
2275	{
2276	istringstream(range) >> val;
2277	vRanges.push_back(val);
2278	}
2279	assert( vRanges.size()%2==0 );
2280	assert( vRanges.size()==2*(m_numOverlayElementsMinus1[i]+1) );
2281	m_overlayElementLabelMin[i].resize( m_numOverlayElementsMinus1[i]+1 );
2282	m_overlayElementLabelMax[i].resize( m_numOverlayElementsMinus1[i]+1 );
2283	for (Int j=0 ; j<=m_numOverlayElementsMinus1[i] ; j++)
2284	{
2285	m_overlayElementLabelMin[i][j] = vRanges[2*j];
2286	m_overlayElementLabelMax[i][j] = vRanges[2*j+1];
2287	}
2288
2289	//parse overlay element names
2290	istringstream elementNames(cfg_overlaySEIElementNames[i]);
2291	string elementName;
2292	vector<string> vElementName;
2293	while ( getline(elementNames, elementName, '\|') )
2294	{
2295	vElementName.push_back(elementName);
2296	}
2297	if ( m_overlayLabelPresentFlag[i] )
2298	{
2299	m_overlayElementName[i].resize( m_numOverlayElementsMinus1[i]+1 );
2300	for (Int j=0 ; j<=m_numOverlayElementsMinus1[i] ; j++)
2301	{
2302	if (j < vElementName.size())
2303	{
2304	m_overlayElementName[i][j] = vElementName[j];
2305	}
2306	else
2307	{
2308	m_overlayElementName[i][j] = string("NoElementName");
2309	}
2310	}
2311	}
2312	}
2313	}
2314	#endif
2315	#if Q0074_COLOUR_REMAPPING_SEI
2316	#if !SVC_EXTENSION
2317	// reading external Colour Remapping Information SEI message parameters from file
2318	if( m_colourRemapSEIFile.size() > 0 )
2319	{
2320	FILE* fic;
2321	Int retval;
2322	if((fic = fopen(m_colourRemapSEIFile.c_str(),"r")) == (FILE*)NULL)
2323	{
2324	fprintf(stderr, "Can't open Colour Remapping Information SEI parameters file %s\n", m_colourRemapSEIFile.c_str());
2325	exit(EXIT_FAILURE);
2326	}
2327
2328	retval = fscanf( fic, "%d", &m_colourRemapSEIId );
2329	retval = fscanf( fic, "%d", &m_colourRemapSEICancelFlag );
2330	if( !m_colourRemapSEICancelFlag )
2331	{
2332	retval = fscanf( fic, "%d", &m_colourRemapSEIPersistenceFlag );
2333	retval = fscanf( fic, "%d", &m_colourRemapSEIVideoSignalInfoPresentFlag);
2334	if( m_colourRemapSEIVideoSignalInfoPresentFlag )
2335	{
2336	retval = fscanf( fic, "%d", &m_colourRemapSEIFullRangeFlag );
2337	retval = fscanf( fic, "%d", &m_colourRemapSEIPrimaries );
2338	retval = fscanf( fic, "%d", &m_colourRemapSEITransferFunction );
2339	retval = fscanf( fic, "%d", &m_colourRemapSEIMatrixCoefficients );
2340	}
2341
2342	retval = fscanf( fic, "%d", &m_colourRemapSEIInputBitDepth );
2343	retval = fscanf( fic, "%d", &m_colourRemapSEIBitDepth );
2344
2345	for( Int c=0 ; c<3 ; c++ )
2346	{
2347	retval = fscanf( fic, "%d", &m_colourRemapSEIPreLutNumValMinus1[c] );
2348	if( m_colourRemapSEIPreLutNumValMinus1[c]>0 )
2349	{
2350	m_colourRemapSEIPreLutCodedValue[c] = new Int[m_colourRemapSEIPreLutNumValMinus1[c]+1];
2351	m_colourRemapSEIPreLutTargetValue[c] = new Int[m_colourRemapSEIPreLutNumValMinus1[c]+1];
2352	for( Int i=0 ; i<=m_colourRemapSEIPreLutNumValMinus1[c] ; i++ )
2353	{
2354	retval = fscanf( fic, "%d", &m_colourRemapSEIPreLutCodedValue[c][i] );
2355	retval = fscanf( fic, "%d", &m_colourRemapSEIPreLutTargetValue[c][i] );
2356	}
2357	}
2358	}
2359
2360	retval = fscanf( fic, "%d", &m_colourRemapSEIMatrixPresentFlag );
2361	if( m_colourRemapSEIMatrixPresentFlag )
2362	{
2363	retval = fscanf( fic, "%d", &m_colourRemapSEILog2MatrixDenom );
2364	for( Int c=0 ; c<3 ; c++ )
2365	for( Int i=0 ; i<3 ; i++ )
2366	retval = fscanf( fic, "%d", &m_colourRemapSEICoeffs[c][i] );
2367	}
2368
2369	for( Int c=0 ; c<3 ; c++ )
2370	{
2371	retval = fscanf( fic, "%d", &m_colourRemapSEIPostLutNumValMinus1[c] );
2372	if( m_colourRemapSEIPostLutNumValMinus1[c]>0 )
2373	{
2374	m_colourRemapSEIPostLutCodedValue[c] = new Int[m_colourRemapSEIPostLutNumValMinus1[c]+1];
2375	m_colourRemapSEIPostLutTargetValue[c] = new Int[m_colourRemapSEIPostLutNumValMinus1[c]+1];
2376	for( Int i=0 ; i<=m_colourRemapSEIPostLutNumValMinus1[c] ; i++ )
2377	{
2378	retval = fscanf( fic, "%d", &m_colourRemapSEIPostLutCodedValue[c][i] );
2379	retval = fscanf( fic, "%d", &m_colourRemapSEIPostLutTargetValue[c][i] );
2380	}
2381	}
2382	}
2383	}
2384
2385	fclose( fic );
2386	if( retval != 1 )
2387	{
2388	fprintf(stderr, "Error while reading Colour Remapping Information SEI parameters file\n");
2389	exit(EXIT_FAILURE);
2390	}
2391	}
2392	#else
2393	// Reading external Colour Remapping Information SEI message parameters from file
2394	// It seems that TAppEncLayerCfg::parseCfg is not used
2395	for(UInt layer = 0; layer < m_numLayers; layer++)
2396	{
2397	if( cfg_colourRemapSEIFile[layer]->length() )
2398	{
2399	FILE* fic;
2400	Int retval;
2401	if((fic = fopen(cfg_colourRemapSEIFile[layer]->c_str(),"r")) == (FILE*)NULL)
2402	{
2403	fprintf(stderr, "Can't open Colour Remapping Information SEI parameters file %s\n", cfg_colourRemapSEIFile[layer]->c_str());
2404	exit(EXIT_FAILURE);
2405	}
2406	Int tempCode;
2407	retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIId );
2408	retval = fscanf( fic, "%d", &tempCode ); m_acLayerCfg[layer].m_colourRemapSEICancelFlag = tempCode ? 1 : 0;
2409	if( !m_acLayerCfg[layer].m_colourRemapSEICancelFlag )
2410	{
2411	retval = fscanf( fic, "%d", &tempCode ); m_acLayerCfg[layer].m_colourRemapSEIPersistenceFlag = tempCode ? 1 : 0;
2412	retval = fscanf( fic, "%d", &tempCode ); m_acLayerCfg[layer].m_colourRemapSEIVideoSignalInfoPresentFlag = tempCode ? 1 : 0;
2413	if( m_acLayerCfg[layer].m_colourRemapSEIVideoSignalInfoPresentFlag )
2414	{
2415	retval = fscanf( fic, "%d", &tempCode ); m_acLayerCfg[layer].m_colourRemapSEIFullRangeFlag = tempCode ? 1 : 0;
2416	retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIPrimaries );
2417	retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEITransferFunction );
2418	retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIMatrixCoefficients );
2419	}
2420
2421	retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIInputBitDepth );
2422	retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIBitDepth );
2423
2424	for( Int c=0 ; c<3 ; c++ )
2425	{
2426	retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIPreLutNumValMinus1[c] );
2427	if( m_acLayerCfg[layer].m_colourRemapSEIPreLutNumValMinus1[c]>0 )
2428	{
2429	m_acLayerCfg[layer].m_colourRemapSEIPreLutCodedValue[c] = new Int[m_acLayerCfg[layer].m_colourRemapSEIPreLutNumValMinus1[c]+1];
2430	m_acLayerCfg[layer].m_colourRemapSEIPreLutTargetValue[c] = new Int[m_acLayerCfg[layer].m_colourRemapSEIPreLutNumValMinus1[c]+1];
2431	for( Int i=0 ; i<=m_acLayerCfg[layer].m_colourRemapSEIPreLutNumValMinus1[c] ; i++ )
2432	{
2433	retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIPreLutCodedValue[c][i] );
2434	retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIPreLutTargetValue[c][i] );
2435	}
2436	}
2437	}
2438
2439	retval = fscanf( fic, "%d", &tempCode ); m_acLayerCfg[layer].m_colourRemapSEIMatrixPresentFlag = tempCode ? 1 : 0;
2440	if( m_acLayerCfg[layer].m_colourRemapSEIMatrixPresentFlag )
2441	{
2442	retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEILog2MatrixDenom );
2443	for( Int c=0 ; c<3 ; c++ )
2444	for( Int i=0 ; i<3 ; i++ )
2445	retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEICoeffs[c][i] );
2446	}
2447
2448	for( Int c=0 ; c<3 ; c++ )
2449	{
2450	retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIPostLutNumValMinus1[c] );
2451	if( m_acLayerCfg[layer].m_colourRemapSEIPostLutNumValMinus1[c]>0 )
2452	{
2453	m_acLayerCfg[layer].m_colourRemapSEIPostLutCodedValue[c] = new Int[m_acLayerCfg[layer].m_colourRemapSEIPostLutNumValMinus1[c]+1];
2454	m_acLayerCfg[layer].m_colourRemapSEIPostLutTargetValue[c] = new Int[m_acLayerCfg[layer].m_colourRemapSEIPostLutNumValMinus1[c]+1];
2455	for( Int i=0 ; i<=m_acLayerCfg[layer].m_colourRemapSEIPostLutNumValMinus1[c] ; i++ )
2456	{
2457	retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIPostLutCodedValue[c][i] );
2458	retval = fscanf( fic, "%d", &m_acLayerCfg[layer].m_colourRemapSEIPostLutTargetValue[c][i] );
2459	}
2460	}
2461	}
2462	}
2463
2464	fclose( fic );
2465	if( retval != 1 )
2466	{
2467	fprintf(stderr, "Error while reading Colour Remapping Information SEI parameters file\n");
2468	exit(EXIT_FAILURE);
2469	}
2470	}
2471	}
2472	#endif
2473	#endif
2474	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
2475	if (m_interLayerConstrainedTileSetsSEIEnabled)
2476	{
2477	if (m_numTileColumnsMinus1 == 0 && m_numTileRowsMinus1 == 0)
2478	{
2479	printf( "Tiles are not defined (needed for inter-layer comnstrained tile sets SEI).\n" );
2480	exit( EXIT_FAILURE );
2481	}
2482	Char* pTileSets = cfg_tileSets.empty() ? NULL : strdup(cfg_tileSets.c_str());
2483	int i = 0;
2484	char *topLeftTileIndex = strtok(pTileSets, " ,");
2485	while(topLeftTileIndex != NULL)
2486	{
2487	if( i >= m_ilNumSetsInMessage )
2488	{
2489	printf( "The number of tile sets is larger than defined by IlNumSetsInMessage.\n" );
2490	exit( EXIT_FAILURE );
2491	}
2492	*( m_topLeftTileIndex + i ) = atoi( topLeftTileIndex );
2493	char *bottonRightTileIndex = strtok(NULL, " ,");
2494	if( bottonRightTileIndex == NULL )
2495	{
2496	printf( "BottonRightTileIndex is missing in the tile sets.\n" );
2497	exit( EXIT_FAILURE );
2498	}
2499	*( m_bottomRightTileIndex + i ) = atoi( bottonRightTileIndex );
2500	char *ilcIdc = strtok(NULL, " ,");
2501	if( ilcIdc == NULL )
2502	{
2503	printf( "IlcIdc is missing in the tile sets.\n" );
2504	exit( EXIT_FAILURE );
2505	}
2506	*( m_ilcIdc + i ) = atoi( ilcIdc );
2507	topLeftTileIndex = strtok(NULL, " ,");
2508	i++;
2509	}
2510	if( i < m_ilNumSetsInMessage )
2511	{
2512	printf( "The number of tile sets is smaller than defined by IlNumSetsInMessage.\n" );
2513	exit( EXIT_FAILURE );
2514	}
2515	m_skippedTileSetPresentFlag = false;
2516
2517	if( pTileSets )
2518	{
2519	free( pTileSets );
2520	pTileSets = NULL;
2521	}
2522	}
2523	#endif
2524	// check validity of input parameters
2525	xCheckParameter();
2526
2527	// set global varibles
2528	#if LAYER_CTB
2529	for(Int layer = 0; layer < MAX_LAYERS; layer++)
2530	{
2531	xSetGlobal(layer);
2532	}
2533	#else
2534	xSetGlobal();
2535	#endif
2536
2537	// print-out parameters
2538	xPrintParameter();
2539
2540	return true;
2541	}
2542	// ====================================================================================================================
2543	// Private member functions
2544	// ====================================================================================================================
2545
2546	Bool confirmPara(Bool bflag, const Char* message);
2547
2548	Void TAppEncCfg::xCheckParameter()
2549	{
2550	if (!m_decodedPictureHashSEIEnabled)
2551	{
2552	fprintf(stderr, "******************************************************************\n");
2553	fprintf(stderr, " WARNING: --SEIDecodedPictureHash is now disabled by default. \n");
2554	fprintf(stderr, " Automatic verification of decoded pictures by a \n");
2555	fprintf(stderr, " decoder requires this option to be enabled. \n");
2556	fprintf(stderr, "******************************************************************\n");
2557	}
2558
2559	#if SVC_EXTENSION && MULTIPLE_PTL_SUPPORT
2560	Int ii = 0;
2561	while ( ii < m_numPTLInfo )
2562	{
2563	if( m_profileList[ii] == Profile::NONE )
2564	{
2565	fprintf(stderr, "***************************************************************************\n");
2566	fprintf(stderr, " WARNING: For conforming bitstreams a valid Profile value must be set! \n");
2567	fprintf(stderr, "***************************************************************************\n");
2568	}
2569	if( m_levelList[ii] == Level::NONE )
2570	{
2571	fprintf(stderr, "***************************************************************************\n");
2572	fprintf(stderr, " WARNING: For conforming bitstreams a valid Level value must be set! \n");
2573	fprintf(stderr, "***************************************************************************\n");
2574	}
2575	ii++;
2576	}
2577	#else
2578	if( m_profile==Profile::NONE )
2579	{
2580	fprintf(stderr, "***************************************************************************\n");
2581	fprintf(stderr, " WARNING: For conforming bitstreams a valid Profile value must be set! \n");
2582	fprintf(stderr, "***************************************************************************\n");
2583	}
2584	if( m_level==Level::NONE )
2585	{
2586	fprintf(stderr, "***************************************************************************\n");
2587	fprintf(stderr, " WARNING: For conforming bitstreams a valid Level value must be set! \n");
2588	fprintf(stderr, "***************************************************************************\n");
2589	}
2590	#endif
2591
2592	Bool check_failed = false; /* abort if there is a fatal configuration problem */
2593	#define xConfirmPara(a,b) check_failed \|= confirmPara(a,b)
2594	// check range of parameters
2595	#if O0194_DIFFERENT_BITDEPTH_EL_BL
2596	for(UInt layer=0; layer<m_numLayers; layer++)
2597	{
2598	xConfirmPara( m_acLayerCfg[layer].m_inputBitDepthY < 8, "InputBitDepth must be at least 8" );
2599	xConfirmPara( m_acLayerCfg[layer].m_inputBitDepthC < 8, "InputBitDepthC must be at least 8" );
2600	}
2601	#else
2602	xConfirmPara( m_inputBitDepthY < 8, "InputBitDepth must be at least 8" );
2603	xConfirmPara( m_inputBitDepthC < 8, "InputBitDepthC must be at least 8" );
2604	#endif
2605	#if !SVC_EXTENSION
2606	xConfirmPara( m_iFrameRate <= 0, "Frame rate must be more than 1" );
2607	#endif
2608	xConfirmPara( m_framesToBeEncoded <= 0, "Total Number Of Frames encoded must be more than 0" );
2609	xConfirmPara( m_iGOPSize < 1 , "GOP Size must be greater or equal to 1" );
2610	xConfirmPara( m_iGOPSize > 1 && m_iGOPSize % 2, "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
2611	#if !SVC_EXTENSION
2612	xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) \|\| m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
2613	#endif
2614	#if ALLOW_RECOVERY_POINT_AS_RAP
2615	xConfirmPara( m_iDecodingRefreshType < 0 \|\| m_iDecodingRefreshType > 3, "Decoding Refresh Type must be comprised between 0 and 3 included" );
2616	if(m_iDecodingRefreshType == 3)
2617	{
2618	xConfirmPara( !m_recoveryPointSEIEnabled, "When using RecoveryPointSEI messages as RA points, recoveryPointSEI must be enabled" );
2619	}
2620	#else
2621	xConfirmPara( m_iDecodingRefreshType < 0 \|\| m_iDecodingRefreshType > 2, "Decoding Refresh Type must be equal to 0, 1 or 2" );
2622	#endif
2623	#if !SVC_EXTENSION
2624	xConfirmPara( m_iQP < -6 * (m_internalBitDepthY - 8) \|\| m_iQP > 51, "QP exceeds supported range (-QpBDOffsety to 51)" );
2625	#endif
2626	xConfirmPara( m_loopFilterBetaOffsetDiv2 < -6 \|\| m_loopFilterBetaOffsetDiv2 > 6, "Loop Filter Beta Offset div. 2 exceeds supported range (-6 to 6)");
2627	xConfirmPara( m_loopFilterTcOffsetDiv2 < -6 \|\| m_loopFilterTcOffsetDiv2 > 6, "Loop Filter Tc Offset div. 2 exceeds supported range (-6 to 6)");
2628	xConfirmPara( m_iFastSearch < 0 \|\| m_iFastSearch > 2, "Fast Search Mode is not supported value (0:Full search 1:Diamond 2:PMVFAST)" );
2629	xConfirmPara( m_iSearchRange < 0 , "Search Range must be more than 0" );
2630	xConfirmPara( m_bipredSearchRange < 0 , "Search Range must be more than 0" );
2631	xConfirmPara( m_iMaxDeltaQP > 7, "Absolute Delta QP exceeds supported range (0 to 7)" );
2632	#if LAYER_CTB
2633	for(UInt layer = 0; layer < MAX_LAYERS; layer++)
2634	{
2635	xConfirmPara( m_iMaxCuDQPDepth > m_acLayerCfg[layer].m_uiMaxCUDepth - 1, "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
2636	}
2637	#else
2638	xConfirmPara( m_iMaxCuDQPDepth > m_uiMaxCUDepth - 1, "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
2639	#endif
2640
2641	xConfirmPara( m_cbQpOffset < -12, "Min. Chroma Cb QP Offset is -12" );
2642	xConfirmPara( m_cbQpOffset > 12, "Max. Chroma Cb QP Offset is 12" );
2643	xConfirmPara( m_crQpOffset < -12, "Min. Chroma Cr QP Offset is -12" );
2644	xConfirmPara( m_crQpOffset > 12, "Max. Chroma Cr QP Offset is 12" );
2645
2646	xConfirmPara( m_iQPAdaptationRange <= 0, "QP Adaptation Range must be more than 0" );
2647	#if !SVC_EXTENSION
2648	if (m_iDecodingRefreshType == 2)
2649	{
2650	xConfirmPara( m_iIntraPeriod > 0 && m_iIntraPeriod <= m_iGOPSize , "Intra period must be larger than GOP size for periodic IDR pictures");
2651	}
2652	#endif
2653	#if !LAYER_CTB
2654	xConfirmPara( (m_uiMaxCUWidth >> m_uiMaxCUDepth) < 4, "Minimum partition width size should be larger than or equal to 8");
2655	xConfirmPara( (m_uiMaxCUHeight >> m_uiMaxCUDepth) < 4, "Minimum partition height size should be larger than or equal to 8");
2656	xConfirmPara( m_uiMaxCUWidth < 16, "Maximum partition width size should be larger than or equal to 16");
2657	xConfirmPara( m_uiMaxCUHeight < 16, "Maximum partition height size should be larger than or equal to 16");
2658	#endif
2659	#if !SVC_EXTENSION
2660	xConfirmPara( (m_iSourceWidth % (m_uiMaxCUWidth >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame width must be a multiple of the minimum CU size");
2661	xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame height must be a multiple of the minimum CU size");
2662	#endif
2663
2664	#if !LAYER_CTB
2665	xConfirmPara( m_uiQuadtreeTULog2MinSize < 2, "QuadtreeTULog2MinSize must be 2 or greater.");
2666	xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5, "QuadtreeTULog2MaxSize must be 5 or smaller.");
2667	xConfirmPara( (1<<m_uiQuadtreeTULog2MaxSize) > m_uiMaxCUWidth, "QuadtreeTULog2MaxSize must be log2(maxCUSize) or smaller.");
2668
2669	xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize, "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize.");
2670	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
2671	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUHeight>>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
2672	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUWidth >> m_uiMaxCUDepth ), "Minimum CU width must be greater than minimum transform size." );
2673	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." );
2674	xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1, "QuadtreeTUMaxDepthInter must be greater than or equal to 1" );
2675	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" );
2676	xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1, "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" );
2677	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" );
2678	#endif
2679
2680	xConfirmPara( m_maxNumMergeCand < 1, "MaxNumMergeCand must be 1 or greater.");
2681	xConfirmPara( m_maxNumMergeCand > 5, "MaxNumMergeCand must be 5 or smaller.");
2682
2683	#if !SVC_EXTENSION
2684	#if ADAPTIVE_QP_SELECTION
2685	xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
2686	xConfirmPara( m_bUseAdaptQpSelect == true && (m_cbQpOffset !=0 \|\| m_crQpOffset != 0 ), "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
2687	#endif
2688	#endif
2689
2690	if( m_usePCM)
2691	{
2692	xConfirmPara( m_uiPCMLog2MinSize < 3, "PCMLog2MinSize must be 3 or greater.");
2693	xConfirmPara( m_uiPCMLog2MinSize > 5, "PCMLog2MinSize must be 5 or smaller.");
2694	xConfirmPara( m_pcmLog2MaxSize > 5, "PCMLog2MaxSize must be 5 or smaller.");
2695	xConfirmPara( m_pcmLog2MaxSize < m_uiPCMLog2MinSize, "PCMLog2MaxSize must be equal to or greater than m_uiPCMLog2MinSize.");
2696	}
2697
2698	xConfirmPara( m_sliceMode < 0 \|\| m_sliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
2699	if (m_sliceMode!=0)
2700	{
2701	xConfirmPara( m_sliceArgument < 1 , "SliceArgument should be larger than or equal to 1" );
2702	}
2703	xConfirmPara( m_sliceSegmentMode < 0 \|\| m_sliceSegmentMode > 3, "SliceSegmentMode exceeds supported range (0 to 3)" );
2704	if (m_sliceSegmentMode!=0)
2705	{
2706	xConfirmPara( m_sliceSegmentArgument < 1 , "SliceSegmentArgument should be larger than or equal to 1" );
2707	}
2708
2709	#if !SVC_EXTENSION
2710	Bool tileFlag = (m_numTileColumnsMinus1 > 0 \|\| m_numTileRowsMinus1 > 0 );
2711	xConfirmPara( tileFlag && m_iWaveFrontSynchro, "Tile and Wavefront can not be applied together");
2712
2713	//TODO:ChromaFmt assumes 4:2:0 below
2714	xConfirmPara( m_iSourceWidth % TComSPS::getWinUnitX(CHROMA_420) != 0, "Picture width must be an integer multiple of the specified chroma subsampling");
2715	xConfirmPara( m_iSourceHeight % TComSPS::getWinUnitY(CHROMA_420) != 0, "Picture height must be an integer multiple of the specified chroma subsampling");
2716
2717	xConfirmPara( m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0, "Horizontal padding must be an integer multiple of the specified chroma subsampling");
2718	xConfirmPara( m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0, "Vertical padding must be an integer multiple of the specified chroma subsampling");
2719
2720	xConfirmPara( m_confWinLeft % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left conformance window offset must be an integer multiple of the specified chroma subsampling");
2721	xConfirmPara( m_confWinRight % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right conformance window offset must be an integer multiple of the specified chroma subsampling");
2722	xConfirmPara( m_confWinTop % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top conformance window offset must be an integer multiple of the specified chroma subsampling");
2723	xConfirmPara( m_confWinBottom % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom conformance window offset must be an integer multiple of the specified chroma subsampling");
2724
2725	xConfirmPara( m_defaultDisplayWindowFlag && !m_vuiParametersPresentFlag, "VUI needs to be enabled for default display window");
2726
2727	if (m_defaultDisplayWindowFlag)
2728	{
2729	xConfirmPara( m_defDispWinLeftOffset % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left default display window offset must be an integer multiple of the specified chroma subsampling");
2730	xConfirmPara( m_defDispWinRightOffset % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right default display window offset must be an integer multiple of the specified chroma subsampling");
2731	xConfirmPara( m_defDispWinTopOffset % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top default display window offset must be an integer multiple of the specified chroma subsampling");
2732	xConfirmPara( m_defDispWinBottomOffset % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom default display window offset must be an integer multiple of the specified chroma subsampling");
2733	}
2734	#endif
2735
2736	#if !LAYER_CTB
2737	// max CU width and height should be power of 2
2738	UInt ui = m_uiMaxCUWidth;
2739	while(ui)
2740	{
2741	ui >>= 1;
2742	if( (ui & 1) == 1)
2743	xConfirmPara( ui != 1 , "Width should be 2^n");
2744	}
2745	ui = m_uiMaxCUHeight;
2746	while(ui)
2747	{
2748	ui >>= 1;
2749	if( (ui & 1) == 1)
2750	xConfirmPara( ui != 1 , "Height should be 2^n");
2751	}
2752	#endif
2753
2754	/* if this is an intra-only sequence, ie IntraPeriod=1, don't verify the GOP structure
2755	* This permits the ability to omit a GOP structure specification */
2756	#if SVC_EXTENSION
2757	#if Q0108_TSA_STSA
2758	if( m_acLayerCfg[0].m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1 )
2759	{
2760	m_GOPList[0] = GOPEntry();
2761	m_GOPList[0].m_QPFactor = 1;
2762	m_GOPList[0].m_betaOffsetDiv2 = 0;
2763	m_GOPList[0].m_tcOffsetDiv2 = 0;
2764	m_GOPList[0].m_POC = 1;
2765	m_GOPList[0].m_numRefPicsActive = 4;
2766	}
2767
2768	for(UInt layer = 0; layer < MAX_LAYERS; layer++)
2769	{
2770	if (m_acLayerCfg[layer].m_iIntraPeriod == 1 && m_EhGOPList[layer][0].m_POC == -1) {
2771	m_EhGOPList[layer][0] = GOPEntry();
2772	m_EhGOPList[layer][0].m_QPFactor = 1;
2773	m_EhGOPList[layer][0].m_betaOffsetDiv2 = 0;
2774	m_EhGOPList[layer][0].m_tcOffsetDiv2 = 0;
2775	m_EhGOPList[layer][0].m_POC = 1;
2776	m_EhGOPList[layer][0].m_numRefPicsActive = 4;
2777	}
2778	}
2779	#else
2780	for(UInt layer = 0; layer < MAX_LAYERS; layer++)
2781	{
2782	Int m_iIntraPeriod = m_acLayerCfg[layer].m_iIntraPeriod;
2783	if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
2784	m_GOPList[0] = GOPEntry();
2785	m_GOPList[0].m_QPFactor = 1;
2786	m_GOPList[0].m_betaOffsetDiv2 = 0;
2787	m_GOPList[0].m_tcOffsetDiv2 = 0;
2788	m_GOPList[0].m_POC = 1;
2789	m_GOPList[0].m_numRefPicsActive = 4;
2790	}
2791	}
2792	#endif
2793	#else
2794	if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
2795	m_GOPList[0] = GOPEntry();
2796	m_GOPList[0].m_QPFactor = 1;
2797	m_GOPList[0].m_betaOffsetDiv2 = 0;
2798	m_GOPList[0].m_tcOffsetDiv2 = 0;
2799	m_GOPList[0].m_POC = 1;
2800	m_GOPList[0].m_numRefPicsActive = 4;
2801	}
2802	#endif
2803
2804	Bool verifiedGOP=false;
2805	Bool errorGOP=false;
2806	Int checkGOP=1;
2807	Int numRefs = m_isField ? 2 : 1;
2808	Int refList[MAX_NUM_REF_PICS+1];
2809	refList[0]=0;
2810	if(m_isField)
2811	{
2812	refList[1] = 1;
2813	}
2814	Bool isOK[MAX_GOP];
2815	for(Int i=0; i<MAX_GOP; i++)
2816	{
2817	isOK[i]=false;
2818	}
2819	Int numOK=0;
2820	#if !SVC_EXTENSION
2821	xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
2822	#endif
2823
2824	for(Int i=0; i<m_iGOPSize; i++)
2825	{
2826	if(m_GOPList[i].m_POC==m_iGOPSize)
2827	{
2828	xConfirmPara( m_GOPList[i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
2829	}
2830	}
2831
2832	#if SVC_EXTENSION
2833	xConfirmPara( m_numLayers > MAX_LAYERS , "Number of layers in config file is greater than MAX_LAYERS" );
2834	m_numLayers = m_numLayers > MAX_LAYERS ? MAX_LAYERS : m_numLayers;
2835
2836	// it can be updated after AVC BL support will be added to the WD
2837	#if VPS_AVC_BL_FLAG_REMOVAL
2838	if( m_nonHEVCBaseLayerFlag )
2839	#else
2840	if( m_avcBaseLayerFlag )
2841	#endif
2842	{
2843	m_crossLayerIrapAlignFlag = false;
2844	m_crossLayerPictureTypeAlignFlag = false;
2845	m_crossLayerAlignedIdrOnlyFlag = false;
2846	}
2847
2848	// verify layer configuration parameters
2849	for(UInt layer=0; layer<m_numLayers; layer++)
2850	{
2851	if(m_acLayerCfg[layer].xCheckParameter(m_isField))
2852	{
2853	printf("\nError: invalid configuration parameter found in layer %d \n", layer);
2854	check_failed = true;
2855	}
2856	}
2857
2858	// verify layer configuration parameters
2859	for(UInt layer=0; layer<m_numLayers; layer++)
2860	{
2861	Int m_iIntraPeriod = m_acLayerCfg[layer].m_iIntraPeriod;
2862	#endif
2863	if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
2864	{
2865	for(Int i=0; i<m_iGOPSize; i++)
2866	{
2867	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)" );
2868	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)" );
2869	}
2870	}
2871	#if SVC_EXTENSION
2872	}
2873	#endif
2874
2875	#if !Q0108_TSA_STSA
2876	m_extraRPSs = 0;
2877	#else
2878	memset( m_extraRPSs, 0, sizeof( m_extraRPSs ) );
2879	#endif
2880	//start looping through frames in coding order until we can verify that the GOP structure is correct.
2881	while(!verifiedGOP&&!errorGOP)
2882	{
2883	Int curGOP = (checkGOP-1)%m_iGOPSize;
2884	Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC;
2885	if(m_GOPList[curGOP].m_POC<0)
2886	{
2887	printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
2888	errorGOP=true;
2889	}
2890	else
2891	{
2892	//check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
2893	Bool beforeI = false;
2894	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
2895	{
2896	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
2897	if(absPOC < 0)
2898	{
2899	beforeI=true;
2900	}
2901	else
2902	{
2903	Bool found=false;
2904	for(Int j=0; j<numRefs; j++)
2905	{
2906	if(refList[j]==absPOC)
2907	{
2908	found=true;
2909	for(Int k=0; k<m_iGOPSize; k++)
2910	{
2911	if(absPOC%m_iGOPSize == m_GOPList[k].m_POC%m_iGOPSize)
2912	{
2913	if(m_GOPList[k].m_temporalId==m_GOPList[curGOP].m_temporalId)
2914	{
2915	m_GOPList[k].m_refPic = true;
2916	}
2917	m_GOPList[curGOP].m_usedByCurrPic[i]=m_GOPList[k].m_temporalId<=m_GOPList[curGOP].m_temporalId;
2918	}
2919	}
2920	}
2921	}
2922	if(!found)
2923	{
2924	printf("\nError: ref pic %d is not available for GOP frame %d\n",m_GOPList[curGOP].m_referencePics[i],curGOP+1);
2925	errorGOP=true;
2926	}
2927	}
2928	}
2929	if(!beforeI&&!errorGOP)
2930	{
2931	//all ref frames were present
2932	if(!isOK[curGOP])
2933	{
2934	numOK++;
2935	isOK[curGOP]=true;
2936	if(numOK==m_iGOPSize)
2937	{
2938	verifiedGOP=true;
2939	}
2940	}
2941	}
2942	else
2943	{
2944	//create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
2945	#if !Q0108_TSA_STSA
2946	m_GOPList[m_iGOPSize+m_extraRPSs]=m_GOPList[curGOP];
2947	#else
2948	m_GOPList[m_iGOPSize+m_extraRPSs[0]]=m_GOPList[curGOP];
2949	#endif
2950	Int newRefs=0;
2951	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
2952	{
2953	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
2954	if(absPOC>=0)
2955	{
2956	#if !Q0108_TSA_STSA
2957	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
2958	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
2959	#else
2960	m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
2961	m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
2962	#endif
2963	newRefs++;
2964	}
2965	}
2966	Int numPrefRefs = m_GOPList[curGOP].m_numRefPicsActive;
2967
2968	for(Int offset = -1; offset>-checkGOP; offset--)
2969	{
2970	//step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
2971	Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
2972	Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_GOPList[offGOP].m_POC;
2973	if(offPOC>=0&&m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId)
2974	{
2975	Bool newRef=false;
2976	for(Int i=0; i<numRefs; i++)
2977	{
2978	if(refList[i]==offPOC)
2979	{
2980	newRef=true;
2981	}
2982	}
2983	for(Int i=0; i<newRefs; i++)
2984	{
2985	#if !Q0108_TSA_STSA
2986	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[i]==offPOC-curPOC)
2987	#else
2988	if(m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_referencePics[i]==offPOC-curPOC)
2989	#endif
2990	{
2991	newRef=false;
2992	}
2993	}
2994	if(newRef)
2995	{
2996	Int insertPoint=newRefs;
2997	//this picture can be added, find appropriate place in list and insert it.
2998	if(m_GOPList[offGOP].m_temporalId==m_GOPList[curGOP].m_temporalId)
2999	{
3000	m_GOPList[offGOP].m_refPic = true;
3001	}
3002	for(Int j=0; j<newRefs; j++)
3003	{
3004	#if !Q0108_TSA_STSA
3005	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]<offPOC-curPOC\|\|m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]>0)
3006	#else
3007	if(m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_referencePics[j]<offPOC-curPOC\|\|m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_referencePics[j]>0)
3008	#endif
3009	{
3010	insertPoint = j;
3011	break;
3012	}
3013	}
3014	Int prev = offPOC-curPOC;
3015	Int prevUsed = m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId;
3016	for(Int j=insertPoint; j<newRefs+1; j++)
3017	{
3018	#if !Q0108_TSA_STSA
3019	Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j];
3020	Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j];
3021	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]=prev;
3022	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j]=prevUsed;
3023	#else
3024	Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_referencePics[j];
3025	Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_usedByCurrPic[j];
3026	m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_referencePics[j]=prev;
3027	m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_usedByCurrPic[j]=prevUsed;
3028	#endif
3029
3030	prevUsed=newUsed;
3031	prev=newPrev;
3032	}
3033	newRefs++;
3034	}
3035	}
3036	if(newRefs>=numPrefRefs)
3037	{
3038	break;
3039	}
3040	}
3041	#if !Q0108_TSA_STSA
3042	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics=newRefs;
3043	m_GOPList[m_iGOPSize+m_extraRPSs].m_POC = curPOC;
3044	#else
3045	m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_numRefPics=newRefs;
3046	m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_POC = curPOC;
3047	#endif
3048	#if !Q0108_TSA_STSA
3049	if (m_extraRPSs == 0)
3050	#else
3051	if (m_extraRPSs[0] == 0)
3052	#endif
3053	{
3054	#if !Q0108_TSA_STSA
3055	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 0;
3056	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = 0;
3057	#else
3058	m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_interRPSPrediction = 0;
3059	m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_numRefIdc = 0;
3060	#endif
3061	}
3062	else
3063	{
3064	#if !Q0108_TSA_STSA
3065	Int rIdx = m_iGOPSize + m_extraRPSs - 1;
3066	#else
3067	Int rIdx = m_iGOPSize + m_extraRPSs[0] - 1;
3068	#endif
3069	Int refPOC = m_GOPList[rIdx].m_POC;
3070	Int refPics = m_GOPList[rIdx].m_numRefPics;
3071	Int newIdc=0;
3072	for(Int i = 0; i<= refPics; i++)
3073	{
3074	Int deltaPOC = ((i != refPics)? m_GOPList[rIdx].m_referencePics[i] : 0); // check if the reference abs POC is >= 0
3075	Int absPOCref = refPOC+deltaPOC;
3076	Int refIdc = 0;
3077	#if !Q0108_TSA_STSA
3078	for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics; j++)
3079	{
3080	if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j])
3081	{
3082	if (m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j])
3083	{
3084	refIdc = 1;
3085	}
3086	else
3087	{
3088	refIdc = 2;
3089	}
3090	}
3091	}
3092	m_GOPList[m_iGOPSize+m_extraRPSs].m_refIdc[newIdc]=refIdc;
3093	newIdc++;
3094	}
3095	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1;
3096	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = newIdc;
3097	m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC;
3098	}
3099	curGOP=m_iGOPSize+m_extraRPSs;
3100	m_extraRPSs++;
3101	}
3102	#else
3103	for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_numRefPics; j++)
3104	{
3105	if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_referencePics[j])
3106	{
3107	if (m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_usedByCurrPic[j])
3108	{
3109	refIdc = 1;
3110	}
3111	else
3112	{
3113	refIdc = 2;
3114	}
3115	}
3116	}
3117	m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_refIdc[newIdc]=refIdc;
3118	newIdc++;
3119	}
3120	m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_interRPSPrediction = 1;
3121	m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_numRefIdc = newIdc;
3122	m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs[0]].m_POC;
3123	}
3124	curGOP=m_iGOPSize+m_extraRPSs[0];
3125	m_extraRPSs[0]++;
3126	}
3127	#endif
3128
3129	numRefs=0;
3130	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
3131	{
3132	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
3133	if(absPOC >= 0)
3134	{
3135	refList[numRefs]=absPOC;
3136	numRefs++;
3137	}
3138	}
3139	refList[numRefs]=curPOC;
3140	numRefs++;
3141	}
3142	checkGOP++;
3143	}
3144	xConfirmPara(errorGOP,"Invalid GOP structure given");
3145
3146	#if SVC_EXTENSION && Q0108_TSA_STSA
3147	for ( Int layerId = 1; layerId < m_numLayers; layerId++ )
3148	{
3149	verifiedGOP=false;
3150	errorGOP=false;
3151	checkGOP=1;
3152	numRefs = m_isField ? 2 : 1;
3153	refList[0]=0;
3154
3155	if(m_isField)
3156	{
3157	refList[1] = 1;
3158	}
3159
3160	memset( isOK, 0, sizeof( isOK ) );
3161	numOK=0;
3162
3163	for(Int i=0; i<m_iGOPSize; i++)
3164	{
3165	if(m_EhGOPList[layerId][i].m_POC==m_iGOPSize)
3166	{
3167	xConfirmPara( m_EhGOPList[layerId][i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
3168	}
3169	}
3170
3171	xConfirmPara( m_numLayers > MAX_LAYERS , "Number of layers in config file is greater than MAX_LAYERS" );
3172	m_numLayers = m_numLayers > MAX_LAYERS ? MAX_LAYERS : m_numLayers;
3173
3174	// verify layer configuration parameters
3175	for(UInt layer=0; layer<m_numLayers; layer++)
3176	{
3177	Int m_iIntraPeriod = m_acLayerCfg[layer].m_iIntraPeriod;
3178	if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
3179	{
3180	for(Int i=0; i<m_iGOPSize; i++)
3181	{
3182	xConfirmPara( (m_EhGOPList[layerId][i].m_betaOffsetDiv2 + m_loopFilterBetaOffsetDiv2) < -6 \|\| (m_EhGOPList[layerId][i].m_betaOffsetDiv2 + m_loopFilterBetaOffsetDiv2) > 6, "Loop Filter Beta Offset div. 2 for one of the GOP entries exceeds supported range (-6 to 6)" );
3183	xConfirmPara( (m_EhGOPList[layerId][i].m_tcOffsetDiv2 + m_loopFilterTcOffsetDiv2) < -6 \|\| (m_EhGOPList[layerId][i].m_tcOffsetDiv2 + m_loopFilterTcOffsetDiv2) > 6, "Loop Filter Tc Offset div. 2 for one of the GOP entries exceeds supported range (-6 to 6)" );
3184	}
3185	}
3186	}
3187
3188	//start looping through frames in coding order until we can verify that the GOP structure is correct.
3189	while(!verifiedGOP&&!errorGOP)
3190	{
3191	Int curGOP = (checkGOP-1)%m_iGOPSize;
3192	Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_EhGOPList[layerId][curGOP].m_POC;
3193	if(m_EhGOPList[layerId][curGOP].m_POC<0)
3194	{
3195	printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
3196	errorGOP=true;
3197	}
3198	else
3199	{
3200	//check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
3201	Bool beforeI = false;
3202	for(Int i = 0; i< m_EhGOPList[layerId][curGOP].m_numRefPics; i++)
3203	{
3204	Int absPOC = curPOC+m_EhGOPList[layerId][curGOP].m_referencePics[i];
3205	if(absPOC < 0)
3206	{
3207	beforeI=true;
3208	}
3209	else
3210	{
3211	Bool found=false;
3212	for(Int j=0; j<numRefs; j++)
3213	{
3214	if(refList[j]==absPOC)
3215	{
3216	found=true;
3217	for(Int k=0; k<m_iGOPSize; k++)
3218	{
3219	if(absPOC%m_iGOPSize == m_EhGOPList[layerId][k].m_POC%m_iGOPSize)
3220	{
3221	if(m_EhGOPList[layerId][k].m_temporalId==m_EhGOPList[layerId][curGOP].m_temporalId)
3222	{
3223	m_EhGOPList[layerId][k].m_refPic = true;
3224	}
3225	m_EhGOPList[layerId][curGOP].m_usedByCurrPic[i]=m_EhGOPList[layerId][k].m_temporalId<=m_EhGOPList[layerId][curGOP].m_temporalId;
3226	}
3227	}
3228	}
3229	}
3230	if(!found)
3231	{
3232	printf("\nError: ref pic %d is not available for GOP frame %d\n",m_EhGOPList[layerId][curGOP].m_referencePics[i],curGOP+1);
3233	errorGOP=true;
3234	}
3235	}
3236	}
3237	if(!beforeI&&!errorGOP)
3238	{
3239	//all ref frames were present
3240	if(!isOK[curGOP])
3241	{
3242	numOK++;
3243	isOK[curGOP]=true;
3244	if(numOK==m_iGOPSize)
3245	{
3246	verifiedGOP=true;
3247	}
3248	}
3249	}
3250	else
3251	{
3252	//create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
3253
3254	m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]]=m_EhGOPList[layerId][curGOP];
3255	Int newRefs=0;
3256	for(Int i = 0; i< m_EhGOPList[layerId][curGOP].m_numRefPics; i++)
3257	{
3258	Int absPOC = curPOC+m_EhGOPList[layerId][curGOP].m_referencePics[i];
3259	if(absPOC>=0)
3260	{
3261	m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_referencePics[newRefs]=m_EhGOPList[layerId][curGOP].m_referencePics[i];
3262	m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_usedByCurrPic[newRefs]=m_EhGOPList[layerId][curGOP].m_usedByCurrPic[i];
3263	newRefs++;
3264	}
3265	}
3266	Int numPrefRefs = m_EhGOPList[layerId][curGOP].m_numRefPicsActive;
3267
3268	for(Int offset = -1; offset>-checkGOP; offset--)
3269	{
3270	//step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
3271	Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
3272	Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_EhGOPList[layerId][offGOP].m_POC;
3273	if(offPOC>=0&&m_EhGOPList[layerId][offGOP].m_temporalId<=m_EhGOPList[layerId][curGOP].m_temporalId)
3274	{
3275	Bool newRef=false;
3276	for(Int i=0; i<numRefs; i++)
3277	{
3278	if(refList[i]==offPOC)
3279	{
3280	newRef=true;
3281	}
3282	}
3283	for(Int i=0; i<newRefs; i++)
3284	{
3285	if(m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_referencePics[i]==offPOC-curPOC)
3286	{
3287	newRef=false;
3288	}
3289	}
3290	if(newRef)
3291	{
3292	Int insertPoint=newRefs;
3293	//this picture can be added, find appropriate place in list and insert it.
3294	if(m_EhGOPList[layerId][offGOP].m_temporalId==m_EhGOPList[layerId][curGOP].m_temporalId)
3295	{
3296	m_EhGOPList[layerId][offGOP].m_refPic = true;
3297	}
3298	for(Int j=0; j<newRefs; j++)
3299	{
3300	if(m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_referencePics[j]<offPOC-curPOC\|\|m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_referencePics[j]>0)
3301	{
3302	insertPoint = j;
3303	break;
3304	}
3305	}
3306	Int prev = offPOC-curPOC;
3307	Int prevUsed = m_EhGOPList[layerId][offGOP].m_temporalId<=m_EhGOPList[layerId][curGOP].m_temporalId;
3308	for(Int j=insertPoint; j<newRefs+1; j++)
3309	{
3310	Int newPrev = m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_referencePics[j];
3311	Int newUsed = m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_usedByCurrPic[j];
3312	m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_referencePics[j]=prev;
3313	m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_usedByCurrPic[j]=prevUsed;
3314	prevUsed=newUsed;
3315	prev=newPrev;
3316	}
3317	newRefs++;
3318	}
3319	}
3320	if(newRefs>=numPrefRefs)
3321	{
3322	break;
3323	}
3324	}
3325	m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_numRefPics=newRefs;
3326	m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_POC = curPOC;
3327	if (m_extraRPSs[layerId] == 0)
3328	{
3329	m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_interRPSPrediction = 0;
3330	m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_numRefIdc = 0;
3331	}
3332	else
3333	{
3334	Int rIdx = m_iGOPSize + m_extraRPSs[layerId] - 1;
3335	Int refPOC = m_EhGOPList[layerId][rIdx].m_POC;
3336	Int refPics = m_EhGOPList[layerId][rIdx].m_numRefPics;
3337	Int newIdc=0;
3338	for(Int i = 0; i<= refPics; i++)
3339	{
3340	Int deltaPOC = ((i != refPics)? m_EhGOPList[layerId][rIdx].m_referencePics[i] : 0); // check if the reference abs POC is >= 0
3341	Int absPOCref = refPOC+deltaPOC;
3342	Int refIdc = 0;
3343	for (Int j = 0; j < m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_numRefPics; j++)
3344	{
3345	if ( (absPOCref - curPOC) == m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_referencePics[j])
3346	{
3347	if (m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_usedByCurrPic[j])
3348	{
3349	refIdc = 1;
3350	}
3351	else
3352	{
3353	refIdc = 2;
3354	}
3355	}
3356	}
3357	m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_refIdc[newIdc]=refIdc;
3358	newIdc++;
3359	}
3360	m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_interRPSPrediction = 1;
3361	m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_numRefIdc = newIdc;
3362	m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_deltaRPS = refPOC - m_EhGOPList[layerId][m_iGOPSize+m_extraRPSs[layerId]].m_POC;
3363	}
3364	curGOP=m_iGOPSize+m_extraRPSs[layerId];
3365	m_extraRPSs[layerId]++;
3366	}
3367	numRefs=0;
3368	for(Int i = 0; i< m_EhGOPList[layerId][curGOP].m_numRefPics; i++)
3369	{
3370	Int absPOC = curPOC+m_EhGOPList[layerId][curGOP].m_referencePics[i];
3371	if(absPOC >= 0)
3372	{
3373	refList[numRefs]=absPOC;
3374	numRefs++;
3375	}
3376	}
3377	refList[numRefs]=curPOC;
3378	numRefs++;
3379	}
3380	checkGOP++;
3381	}
3382	xConfirmPara(errorGOP,"Invalid GOP structure given");
3383	}
3384	#endif
3385
3386	m_maxTempLayer = 1;
3387	for(Int i=0; i<m_iGOPSize; i++)
3388	{
3389	if(m_GOPList[i].m_temporalId >= m_maxTempLayer)
3390	{
3391	m_maxTempLayer = m_GOPList[i].m_temporalId+1;
3392	}
3393	xConfirmPara(m_GOPList[i].m_sliceType!='B'&&m_GOPList[i].m_sliceType!='P'&&m_GOPList[i].m_sliceType!='I', "Slice type must be equal to B or P or I");
3394	}
3395
3396	#if Q0108_TSA_STSA
3397	for ( Int layerId = 1; layerId < m_numLayers; layerId++)
3398	{
3399	m_EhMaxTempLayer[layerId] = 1;
3400	for(Int i=0; i<m_iGOPSize; i++)
3401	{
3402	if(m_EhGOPList[layerId][i].m_temporalId >= m_EhMaxTempLayer[layerId] )
3403	{
3404	m_EhMaxTempLayer[layerId] = m_EhGOPList[layerId][i].m_temporalId;
3405	}
3406	xConfirmPara(m_GOPList[i].m_sliceType!='B'&&m_GOPList[i].m_sliceType!='P'&&m_GOPList[i].m_sliceType!='I', "Slice type must be equal to B or P or I");
3407	}
3408	}
3409	#endif
3410
3411	for(Int i=0; i<MAX_TLAYER; i++)
3412	{
3413	m_numReorderPics[i] = 0;
3414	m_maxDecPicBuffering[i] = 1;
3415	}
3416	for(Int i=0; i<m_iGOPSize; i++)
3417	{
3418	if(m_GOPList[i].m_numRefPics+1 > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
3419	{
3420	m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1;
3421	}
3422	Int highestDecodingNumberWithLowerPOC = 0;
3423	for(Int j=0; j<m_iGOPSize; j++)
3424	{
3425	if(m_GOPList[j].m_POC <= m_GOPList[i].m_POC)
3426	{
3427	highestDecodingNumberWithLowerPOC = j;
3428	}
3429	}
3430	Int numReorder = 0;
3431	for(Int j=0; j<highestDecodingNumberWithLowerPOC; j++)
3432	{
3433	if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId &&
3434	m_GOPList[j].m_POC > m_GOPList[i].m_POC)
3435	{
3436	numReorder++;
3437	}
3438	}
3439	if(numReorder > m_numReorderPics[m_GOPList[i].m_temporalId])
3440	{
3441	m_numReorderPics[m_GOPList[i].m_temporalId] = numReorder;
3442	}
3443	}
3444	for(Int i=0; i<MAX_TLAYER-1; i++)
3445	{
3446	// a lower layer can not have higher value of m_numReorderPics than a higher layer
3447	if(m_numReorderPics[i+1] < m_numReorderPics[i])
3448	{
3449	m_numReorderPics[i+1] = m_numReorderPics[i];
3450	}
3451	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
3452	if(m_numReorderPics[i] > m_maxDecPicBuffering[i] - 1)
3453	{
3454	m_maxDecPicBuffering[i] = m_numReorderPics[i] + 1;
3455	}
3456	// a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
3457	if(m_maxDecPicBuffering[i+1] < m_maxDecPicBuffering[i])
3458	{
3459	m_maxDecPicBuffering[i+1] = m_maxDecPicBuffering[i];
3460	}
3461	}
3462
3463
3464	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
3465	if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1)
3466	{
3467	m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1] + 1;
3468	}
3469
3470	#if SVC_EXTENSION // ToDo: it should be checked for the case when parameters are different for the layers
3471	for(UInt layer = 0; layer < MAX_LAYERS; layer++)
3472	{
3473	Int m_iSourceWidth = m_acLayerCfg[layer].m_iSourceWidth;
3474	Int m_iSourceHeight = m_acLayerCfg[layer].m_iSourceHeight;
3475	#if LAYER_CTB
3476	Int m_uiMaxCUWidth = m_acLayerCfg[layer].m_uiMaxCUWidth;
3477	Int m_uiMaxCUHeight = m_acLayerCfg[layer].m_uiMaxCUHeight;
3478	#endif
3479
3480	Bool tileFlag = (m_numTileColumnsMinus1 > 0 \|\| m_numTileRowsMinus1 > 0 );
3481	Int m_iWaveFrontSynchro = m_acLayerCfg[layer].m_waveFrontSynchro;
3482	xConfirmPara( tileFlag && m_iWaveFrontSynchro, "Tile and Wavefront can not be applied together");
3483	#endif
3484
3485	if(m_vuiParametersPresentFlag && m_bitstreamRestrictionFlag)
3486	{
3487	Int PicSizeInSamplesY = m_iSourceWidth * m_iSourceHeight;
3488	if(tileFlag)
3489	{
3490	Int maxTileWidth = 0;
3491	Int maxTileHeight = 0;
3492	Int widthInCU = (m_iSourceWidth % m_uiMaxCUWidth) ? m_iSourceWidth/m_uiMaxCUWidth + 1: m_iSourceWidth/m_uiMaxCUWidth;
3493	Int heightInCU = (m_iSourceHeight % m_uiMaxCUHeight) ? m_iSourceHeight/m_uiMaxCUHeight + 1: m_iSourceHeight/m_uiMaxCUHeight;
3494	if(m_tileUniformSpacingFlag)
3495	{
3496	maxTileWidth = m_uiMaxCUWidth*((widthInCU+m_numTileColumnsMinus1)/(m_numTileColumnsMinus1+1));
3497	maxTileHeight = m_uiMaxCUHeight*((heightInCU+m_numTileRowsMinus1)/(m_numTileRowsMinus1+1));
3498	// if only the last tile-row is one treeblock higher than the others
3499	// the maxTileHeight becomes smaller if the last row of treeblocks has lower height than the others
3500	if(!((heightInCU-1)%(m_numTileRowsMinus1+1)))
3501	{
3502	maxTileHeight = maxTileHeight - m_uiMaxCUHeight + (m_iSourceHeight % m_uiMaxCUHeight);
3503	}
3504	// if only the last tile-column is one treeblock wider than the others
3505	// the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others
3506	if(!((widthInCU-1)%(m_numTileColumnsMinus1+1)))
3507	{
3508	maxTileWidth = maxTileWidth - m_uiMaxCUWidth + (m_iSourceWidth % m_uiMaxCUWidth);
3509	}
3510	}
3511	else // not uniform spacing
3512	{
3513	if(m_numTileColumnsMinus1<1)
3514	{
3515	maxTileWidth = m_iSourceWidth;
3516	}
3517	else
3518	{
3519	Int accColumnWidth = 0;
3520	for(Int col=0; col<(m_numTileColumnsMinus1); col++)
3521	{
3522	maxTileWidth = m_tileColumnWidth[col]>maxTileWidth ? m_tileColumnWidth[col]:maxTileWidth;
3523	accColumnWidth += m_tileColumnWidth[col];
3524	}
3525	maxTileWidth = (widthInCU-accColumnWidth)>maxTileWidth ? m_uiMaxCUWidth(widthInCU-accColumnWidth):m_uiMaxCUWidthmaxTileWidth;
3526	}
3527	if(m_numTileRowsMinus1<1)
3528	{
3529	maxTileHeight = m_iSourceHeight;
3530	}
3531	else
3532	{
3533	Int accRowHeight = 0;
3534	for(Int row=0; row<(m_numTileRowsMinus1); row++)
3535	{
3536	maxTileHeight = m_tileRowHeight[row]>maxTileHeight ? m_tileRowHeight[row]:maxTileHeight;
3537	accRowHeight += m_tileRowHeight[row];
3538	}
3539	maxTileHeight = (heightInCU-accRowHeight)>maxTileHeight ? m_uiMaxCUHeight(heightInCU-accRowHeight):m_uiMaxCUHeightmaxTileHeight;
3540	}
3541	}
3542	Int maxSizeInSamplesY = maxTileWidth*maxTileHeight;
3543	m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/maxSizeInSamplesY-4;
3544	}
3545	else if(m_iWaveFrontSynchro)
3546	{
3547	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/((2m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4;
3548	}
3549	else if(m_sliceMode == 1)
3550	{
3551	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/(m_sliceArgumentm_uiMaxCUWidth*m_uiMaxCUHeight)-4;
3552	}
3553	else
3554	{
3555	m_minSpatialSegmentationIdc = 0;
3556	}
3557	}
3558	#if SVC_EXTENSION
3559	}
3560	#endif
3561	#if !SVC_EXTENSION
3562	xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
3563	xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
3564	xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
3565	#endif
3566
3567	xConfirmPara( m_decodedPictureHashSEIEnabled<0 \|\| m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n");
3568
3569	if (m_toneMappingInfoSEIEnabled)
3570	{
3571	xConfirmPara( m_toneMapCodedDataBitDepth < 8 \|\| m_toneMapCodedDataBitDepth > 14 , "SEIToneMapCodedDataBitDepth must be in rage 8 to 14");
3572	xConfirmPara( m_toneMapTargetBitDepth < 1 \|\| (m_toneMapTargetBitDepth > 16 && m_toneMapTargetBitDepth < 255) , "SEIToneMapTargetBitDepth must be in rage 1 to 16 or equal to 255");
3573	xConfirmPara( m_toneMapModelId < 0 \|\| m_toneMapModelId > 4 , "SEIToneMapModelId must be in rage 0 to 4");
3574	xConfirmPara( m_cameraIsoSpeedValue == 0, "SEIToneMapCameraIsoSpeedValue shall not be equal to 0");
3575	xConfirmPara( m_exposureIndexValue == 0, "SEIToneMapExposureIndexValue shall not be equal to 0");
3576	xConfirmPara( m_extendedRangeWhiteLevel < 100, "SEIToneMapExtendedRangeWhiteLevel should be greater than or equal to 100");
3577	xConfirmPara( m_nominalBlackLevelLumaCodeValue >= m_nominalWhiteLevelLumaCodeValue, "SEIToneMapNominalWhiteLevelLumaCodeValue shall be greater than SEIToneMapNominalBlackLevelLumaCodeValue");
3578	xConfirmPara( m_extendedWhiteLevelLumaCodeValue < m_nominalWhiteLevelLumaCodeValue, "SEIToneMapExtendedWhiteLevelLumaCodeValue shall be greater than or equal to SEIToneMapNominalWhiteLevelLumaCodeValue");
3579	}
3580	#if P0050_KNEE_FUNCTION_SEI
3581	if (m_kneeSEIEnabled && !m_kneeSEICancelFlag)
3582	{
3583	xConfirmPara( m_kneeSEINumKneePointsMinus1 < 0 \|\| m_kneeSEINumKneePointsMinus1 > 998, "SEIKneeFunctionNumKneePointsMinus1 must be in the range of 0 to 998");
3584	for ( UInt i=0; i<=m_kneeSEINumKneePointsMinus1; i++ ){
3585	xConfirmPara( m_kneeSEIInputKneePoint[i] < 1 \|\| m_kneeSEIInputKneePoint[i] > 999, "SEIKneeFunctionInputKneePointValue must be in the range of 1 to 999");
3586	xConfirmPara( m_kneeSEIOutputKneePoint[i] < 0 \|\| m_kneeSEIOutputKneePoint[i] > 1000, "SEIKneeFunctionInputKneePointValue must be in the range of 0 to 1000");
3587	if ( i > 0 )
3588	{
3589	xConfirmPara( m_kneeSEIInputKneePoint[i-1] >= m_kneeSEIInputKneePoint[i], "The i-th SEIKneeFunctionInputKneePointValue must be greather than the (i-1)-th value");
3590	}
3591	}
3592	}
3593	#endif
3594	#if Q0096_OVERLAY_SEI
3595	if( m_overlaySEIEnabled && !m_overlayInfoCancelFlag )
3596	{
3597	xConfirmPara( m_overlayContentAuxIdMinus128 < 0 \|\| m_overlayContentAuxIdMinus128 > 31, "SEIOverlayContentAuxIdMinus128 must be in the range of 0 to 31");
3598	xConfirmPara( m_overlayLabelAuxIdMinus128 < 0 \|\| m_overlayLabelAuxIdMinus128 > 31, "SEIOverlayLabelAuxIdMinus128 must be in the range of 0 to 31");
3599	xConfirmPara( m_overlayAlphaAuxIdMinus128 < 0 \|\| m_overlayAlphaAuxIdMinus128 > 31, "SEIOverlayAlphaAuxIdMinus128 must be in the range of 0 to 31");
3600	xConfirmPara( m_numOverlaysMinus1 < 0 \|\| m_numOverlaysMinus1 > 15, "SEIOverlayNumOverlaysMinus1 must be in the range of 0 to 15");
3601	for (Int i=0 ; i<=m_numOverlaysMinus1 ; i++ )
3602	{
3603	xConfirmPara( m_overlayIdx[i] < 0 \|\| m_overlayIdx[i] > 255, "SEIOverlayIdx must be in the range of 0 to 255");
3604	xConfirmPara( m_numOverlayElementsMinus1[i] < 0 \|\| m_numOverlayElementsMinus1[i] > 255, "SEIOverlayNumElementsMinus1 must be in the range of 0 to 255");
3605	}
3606	}
3607	#endif
3608	#if Q0074_COLOUR_REMAPPING_SEI
3609	#if !SVC_EXTENSION
3610	if ( ( m_colourRemapSEIFile.size() > 0 ) && !m_colourRemapSEICancelFlag )
3611	{
3612	xConfirmPara( m_colourRemapSEIInputBitDepth < 8 \|\| m_colourRemapSEIInputBitDepth > 16 , "colour_remap_input_bit_depth shall be in the range of 8 to 16, inclusive");
3613	xConfirmPara( m_colourRemapSEIBitDepth < 8 \|\| m_colourRemapSEIBitDepth > 16, "colour_remap_bit_depth shall be in the range of 8 to 16, inclusive");
3614	for( Int c=0 ; c<3 ; c++)
3615	{
3616	xConfirmPara( m_colourRemapSEIPreLutNumValMinus1[c] < 0 \|\| m_colourRemapSEIPreLutNumValMinus1[c] > 32, "pre_lut_num_val_minus1[c] shall be in the range of 0 to 32, inclusive");
3617	if( m_colourRemapSEIPreLutNumValMinus1[c]>0 )
3618	for( Int i=0 ; i<=m_colourRemapSEIPreLutNumValMinus1[c] ; i++)
3619	{
3620	xConfirmPara( m_colourRemapSEIPreLutCodedValue[c][i] < 0 \|\| m_colourRemapSEIPreLutCodedValue[c][i] > ((1<<m_colourRemapSEIInputBitDepth)-1), "pre_lut_coded_value[c][i] shall be in the range of 0 to (1<<colour_remap_input_bit_depth)-1, inclusive");
3621	xConfirmPara( m_colourRemapSEIPreLutTargetValue[c][i] < 0 \|\| m_colourRemapSEIPreLutTargetValue[c][i] > ((1<<m_colourRemapSEIBitDepth)-1), "pre_lut_target_value[c][i] shall be in the range of 0 to (1<<colour_remap_bit_depth)-1, inclusive");
3622	}
3623	xConfirmPara( m_colourRemapSEIPostLutNumValMinus1[c] < 0 \|\| m_colourRemapSEIPostLutNumValMinus1[c] > 32, "post_lut_num_val_minus1[c] shall be in the range of 0 to 32, inclusive");
3624	if( m_colourRemapSEIPostLutNumValMinus1[c]>0 )
3625	for( Int i=0 ; i<=m_colourRemapSEIPostLutNumValMinus1[c] ; i++)
3626	{
3627	xConfirmPara( m_colourRemapSEIPostLutCodedValue[c][i] < 0 \|\| m_colourRemapSEIPostLutCodedValue[c][i] > ((1<<m_colourRemapSEIBitDepth)-1), "post_lut_coded_value[c][i] shall be in the range of 0 to (1<<colour_remap_bit_depth)-1, inclusive");
3628	xConfirmPara( m_colourRemapSEIPostLutTargetValue[c][i] < 0 \|\| m_colourRemapSEIPostLutTargetValue[c][i] > ((1<<m_colourRemapSEIBitDepth)-1), "post_lut_target_value[c][i] shall be in the range of 0 to (1<<colour_remap_bit_depth)-1, inclusive");
3629	}
3630	}
3631	if ( m_colourRemapSEIMatrixPresentFlag )
3632	{
3633	xConfirmPara( m_colourRemapSEILog2MatrixDenom < 0 \|\| m_colourRemapSEILog2MatrixDenom > 15, "log2_matrix_denom shall be in the range of 0 to 15, inclusive");
3634	for( Int c=0 ; c<3 ; c++)
3635	for( Int i=0 ; i<3 ; i++)
3636	xConfirmPara( m_colourRemapSEICoeffs[c][i] < -32768 \|\| m_colourRemapSEICoeffs[c][i] > 32767, "colour_remap_coeffs[c][i] shall be in the range of -32768 and 32767, inclusive");
3637	}
3638	}
3639	#endif
3640	#endif
3641
3642	#if RC_SHVC_HARMONIZATION
3643	for ( Int layer=0; layer<m_numLayers; layer++ )
3644	{
3645	if ( m_acLayerCfg[layer].m_RCEnableRateControl )
3646	{
3647	if ( m_acLayerCfg[layer].m_RCForceIntraQP )
3648	{
3649	if ( m_acLayerCfg[layer].m_RCInitialQP == 0 )
3650	{
3651	printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
3652	m_acLayerCfg[layer].m_RCForceIntraQP = false;
3653	}
3654	}
3655	}
3656	xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
3657	}
3658	#else
3659	if ( m_RCEnableRateControl )
3660	{
3661	if ( m_RCForceIntraQP )
3662	{
3663	if ( m_RCInitialQP == 0 )
3664	{
3665	printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
3666	m_RCForceIntraQP = false;
3667	}
3668	}
3669	xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
3670	}
3671	#endif
3672
3673	xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagForce, "CUTransquantBypassFlagForce cannot be 1 when TransquantBypassEnableFlag is 0");
3674
3675	xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2");
3676	if (m_framePackingSEIEnabled)
3677	{
3678	xConfirmPara(m_framePackingSEIType < 3 \|\| m_framePackingSEIType > 5 , "SEIFramePackingType must be in rage 3 to 5");
3679	}
3680
3681	#if SVC_EXTENSION
3682	#if VPS_EXTN_DIRECT_REF_LAYERS
3683	xConfirmPara( (m_acLayerCfg[0].m_numSamplePredRefLayers != 0) && (m_acLayerCfg[0].m_numSamplePredRefLayers != -1), "Layer 0 cannot have any reference layers" );
3684	// NOTE: m_numSamplePredRefLayers (for any layer) could be -1 (not signalled in cfg), in which case only the "previous layer" would be taken for reference
3685	for(Int layer = 1; layer < MAX_LAYERS; layer++)
3686	{
3687	xConfirmPara(m_acLayerCfg[layer].m_numSamplePredRefLayers > layer, "Cannot reference more layers than before current layer");
3688	for(Int i = 0; i < m_acLayerCfg[layer].m_numSamplePredRefLayers; i++)
3689	{
3690	xConfirmPara(m_acLayerCfg[layer].m_samplePredRefLayerIds[i] > layer, "Cannot reference higher layers");
3691	xConfirmPara(m_acLayerCfg[layer].m_samplePredRefLayerIds[i] == layer, "Cannot reference the current layer itself");
3692	}
3693	}
3694	xConfirmPara( (m_acLayerCfg[0].m_numMotionPredRefLayers != 0) && (m_acLayerCfg[0].m_numMotionPredRefLayers != -1), "Layer 0 cannot have any reference layers" );
3695	// NOTE: m_numMotionPredRefLayers (for any layer) could be -1 (not signalled in cfg), in which case only the "previous layer" would be taken for reference
3696	for(Int layer = 1; layer < MAX_LAYERS; layer++)
3697	{
3698	xConfirmPara(m_acLayerCfg[layer].m_numMotionPredRefLayers > layer, "Cannot reference more layers than before current layer");
3699	for(Int i = 0; i < m_acLayerCfg[layer].m_numMotionPredRefLayers; i++)
3700	{
3701	xConfirmPara(m_acLayerCfg[layer].m_motionPredRefLayerIds[i] > layer, "Cannot reference higher layers");
3702	xConfirmPara(m_acLayerCfg[layer].m_motionPredRefLayerIds[i] == layer, "Cannot reference the current layer itself");
3703	}
3704	}
3705
3706	xConfirmPara( (m_acLayerCfg[0].m_numActiveRefLayers != 0) && (m_acLayerCfg[0].m_numActiveRefLayers != -1), "Layer 0 cannot have any active reference layers" );
3707	// NOTE: m_numActiveRefLayers (for any layer) could be -1 (not signalled in cfg), in which case only the "previous layer" would be taken for reference
3708	for(Int layer = 1; layer < MAX_LAYERS; layer++)
3709	{
3710	Bool predEnabledFlag[MAX_LAYERS];
3711	for (Int refLayer = 0; refLayer < layer; refLayer++)
3712	{
3713	predEnabledFlag[refLayer] = false;
3714	}
3715	for(Int i = 0; i < m_acLayerCfg[layer].m_numSamplePredRefLayers; i++)
3716	{
3717	predEnabledFlag[m_acLayerCfg[layer].m_samplePredRefLayerIds[i]] = true;
3718	}
3719	for(Int i = 0; i < m_acLayerCfg[layer].m_numMotionPredRefLayers; i++)
3720	{
3721	predEnabledFlag[m_acLayerCfg[layer].m_motionPredRefLayerIds[i]] = true;
3722	}
3723	Int numDirectRefLayers = 0;
3724	for (Int refLayer = 0; refLayer < layer; refLayer++)
3725	{
3726	if (predEnabledFlag[refLayer] == true) numDirectRefLayers++;
3727	}
3728	xConfirmPara(m_acLayerCfg[layer].m_numActiveRefLayers > numDirectRefLayers, "Cannot reference more layers than NumDirectRefLayers");
3729	for(Int i = 0; i < m_acLayerCfg[layer].m_numActiveRefLayers; i++)
3730	{
3731	xConfirmPara(m_acLayerCfg[layer].m_predLayerIds[i] >= numDirectRefLayers, "Cannot reference higher layers");
3732	}
3733	}
3734	#endif //VPS_EXTN_DIRECT_REF_LAYERS
3735	#if M0040_ADAPTIVE_RESOLUTION_CHANGE
3736	if (m_adaptiveResolutionChange > 0)
3737	{
3738	xConfirmPara(m_numLayers != 2, "Adaptive resolution change works with 2 layers only");
3739	xConfirmPara(m_acLayerCfg[1].m_iIntraPeriod == 0 \|\| (m_adaptiveResolutionChange % m_acLayerCfg[1].m_iIntraPeriod) != 0, "Adaptive resolution change must happen at enhancement layer RAP picture");
3740	}
3741	#endif
3742	#if HIGHER_LAYER_IRAP_SKIP_FLAG
3743	if (m_adaptiveResolutionChange > 0)
3744	{
3745	xConfirmPara(m_crossLayerIrapAlignFlag != 0, "Cross layer IRAP alignment must be disabled when using adaptive resolution change.");
3746	}
3747	if (m_skipPictureAtArcSwitch)
3748	{
3749	xConfirmPara(m_adaptiveResolutionChange <= 0, "Skip picture at ARC switching only works when Adaptive Resolution Change is active (AdaptiveResolutionChange > 0)");
3750	}
3751	#endif
3752	for (UInt layer=0; layer < MAX_LAYERS-1; layer++)
3753	{
3754	xConfirmPara(m_acLayerCfg[layer].m_maxTidIlRefPicsPlus1 < 0 \|\| m_acLayerCfg[layer].m_maxTidIlRefPicsPlus1 > 7, "MaxTidIlRefPicsPlus1 must be in range 0 to 7");
3755	}
3756	#if AUXILIARY_PICTURES
3757	for (UInt layer=0; layer < MAX_LAYERS-1; layer++)
3758	{
3759	#if R0062_AUX_PSEUDO_MONOCHROME
3760	xConfirmPara(m_acLayerCfg[layer].m_auxId < 0 \|\| m_acLayerCfg[layer].m_auxId > 2, "AuxId must be in range 0 to 2");
3761	#else
3762	xConfirmPara(m_acLayerCfg[layer].m_auxId < 0 \|\| m_acLayerCfg[layer].m_auxId > 4, "AuxId must be in range 0 to 4");
3763	xConfirmPara(m_acLayerCfg[layer].m_auxId > 0 && m_acLayerCfg[layer].m_chromaFormatIDC != CHROMA_400, "Auxiliary picture must be monochrome picture");
3764	#endif
3765	}
3766	#endif
3767	#if Q0048_CGS_3D_ASYMLUT
3768	xConfirmPara( m_nCGSFlag < 0 \|\| m_nCGSFlag > 1 , "0<=CGS<=1" );
3769	#endif
3770	#endif //SVC_EXTENSION
3771	#undef xConfirmPara
3772	if (check_failed)
3773	{
3774	exit(EXIT_FAILURE);
3775	}
3776	}
3777
3778	/** \todo use of global variables should be removed later
3779	*/
3780	#if LAYER_CTB
3781	Void TAppEncCfg::xSetGlobal(UInt layerId)
3782	{
3783	// set max CU width & height
3784	g_auiLayerMaxCUWidth[layerId] = m_acLayerCfg[layerId].m_uiMaxCUWidth;
3785	g_auiLayerMaxCUHeight[layerId] = m_acLayerCfg[layerId].m_uiMaxCUHeight;
3786
3787	// compute actual CU depth with respect to config depth and max transform size
3788	g_auiLayerAddCUDepth[layerId] = 0;
3789	while( (m_acLayerCfg[layerId].m_uiMaxCUWidth>>m_acLayerCfg[layerId].m_uiMaxCUDepth) > ( 1 << ( m_acLayerCfg[layerId].m_uiQuadtreeTULog2MinSize + g_auiLayerAddCUDepth[layerId] ) ) ) g_auiLayerAddCUDepth[layerId]++;
3790
3791	m_acLayerCfg[layerId].m_uiMaxCUDepth += g_auiLayerAddCUDepth[layerId];
3792	g_auiLayerAddCUDepth[layerId]++;
3793	g_auiLayerMaxCUDepth[layerId] = m_acLayerCfg[layerId].m_uiMaxCUDepth;
3794
3795	#if O0194_DIFFERENT_BITDEPTH_EL_BL
3796	// set internal bit-depth to constant value to make sure to be updated later
3797	g_bitDepthY = -1;
3798	g_bitDepthC = -1;
3799
3800	g_uiPCMBitDepthLuma = -1;
3801	g_uiPCMBitDepthChroma = -1;
3802	#else
3803	// set internal bit-depth and constants
3804	g_bitDepthY = m_internalBitDepthY;
3805	g_bitDepthC = m_internalBitDepthC;
3806
3807	g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
3808	g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
3809	#endif
3810	}
3811	#else
3812	Void TAppEncCfg::xSetGlobal()
3813	{
3814	// set max CU width & height
3815	g_uiMaxCUWidth = m_uiMaxCUWidth;
3816	g_uiMaxCUHeight = m_uiMaxCUHeight;
3817
3818	// compute actual CU depth with respect to config depth and max transform size
3819	g_uiAddCUDepth = 0;
3820	while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth ) ) ) g_uiAddCUDepth++;
3821
3822	m_uiMaxCUDepth += g_uiAddCUDepth;
3823	g_uiAddCUDepth++;
3824	g_uiMaxCUDepth = m_uiMaxCUDepth;
3825
3826	#if O0194_DIFFERENT_BITDEPTH_EL_BL
3827	// set internal bit-depth to constant value to make sure to be updated later
3828	g_bitDepthY = -1;
3829	g_bitDepthC = -1;
3830
3831	g_uiPCMBitDepthLuma = -1;
3832	g_uiPCMBitDepthChroma = -1;
3833	#else
3834	g_bitDepthY = m_internalBitDepthY;
3835	g_bitDepthC = m_internalBitDepthC;
3836
3837	g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
3838	g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
3839	#endif
3840	}
3841	#endif
3842
3843	Void TAppEncCfg::xPrintParameter()
3844	{
3845	printf("\n");
3846	#if SVC_EXTENSION
3847	printf("Total number of layers : %d\n", m_numLayers );
3848	printf("Multiview : %d\n", m_scalabilityMask[VIEW_ORDER_INDEX] );
3849	printf("Scalable : %d\n", m_scalabilityMask[SCALABILITY_ID] );
3850	#if AVC_BASE
3851	#if VPS_AVC_BL_FLAG_REMOVAL
3852	printf("Base layer : %s\n", m_nonHEVCBaseLayerFlag ? "Non-HEVC" : "HEVC");
3853	#else
3854	printf("Base layer : %s\n", m_avcBaseLayerFlag ? "AVC" : "HEVC");
3855	#endif
3856	#endif
3857	#if AUXILIARY_PICTURES
3858	printf("Auxiliary pictures : %d\n", m_scalabilityMask[AUX_ID] );
3859	#endif
3860	#if M0040_ADAPTIVE_RESOLUTION_CHANGE
3861	printf("Adaptive Resolution Change : %d\n", m_adaptiveResolutionChange );
3862	#endif
3863	#if HIGHER_LAYER_IRAP_SKIP_FLAG
3864	printf("Skip picture at ARC switch : %d\n", m_skipPictureAtArcSwitch );
3865	#endif
3866	#if O0223_PICTURE_TYPES_ALIGN_FLAG
3867	printf("Align picture type : %d\n", m_crossLayerPictureTypeAlignFlag );
3868	#endif
3869	printf("Cross layer IRAP alignment : %d\n", m_crossLayerIrapAlignFlag );
3870	#if P0068_CROSS_LAYER_ALIGNED_IDR_ONLY_FOR_IRAP_FLAG
3871	printf("IDR only for IRAP : %d\n", m_crossLayerAlignedIdrOnlyFlag );
3872	#endif
3873	#if O0194_WEIGHTED_PREDICTION_CGS
3874	printf("InterLayerWeightedPred : %d\n", m_useInterLayerWeightedPred );
3875	#endif
3876	for(UInt layer=0; layer<m_numLayers; layer++)
3877	{
3878	printf("=== Layer %d settings === \n", layer);
3879	m_acLayerCfg[layer].xPrintParameter();
3880	printf("\n");
3881	}
3882	printf("=== Common configuration settings === \n");
3883	printf("Bitstream File : %s\n", m_pBitstreamFile );
3884	#else //SVC_EXTENSION
3885	printf("Input File : %s\n", m_pchInputFile );
3886	printf("Bitstream File : %s\n", m_pchBitstreamFile );
3887	printf("Reconstruction File : %s\n", m_pchReconFile );
3888	printf("Real Format : %dx%d %dHz\n", m_iSourceWidth - m_confWinLeft - m_confWinRight, m_iSourceHeight - m_confWinTop - m_confWinBottom, m_iFrameRate );
3889	printf("Internal Format : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
3890	#endif //SVC_EXTENSION
3891	if (m_isField)
3892	{
3893	printf("Frame/Field : Field based coding\n");
3894	printf("Field index : %u - %d (%d fields)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
3895	if (m_isTopFieldFirst)
3896	{
3897	printf("Field Order : Top field first\n");
3898	}
3899	else
3900	{
3901	printf("Field Order : Bottom field first\n");
3902	}
3903	}
3904	else
3905	{
3906	printf("Frame/Field : Frame based coding\n");
3907	printf("Frame index : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
3908	}
3909	#if !LAYER_CTB
3910	printf("CU size / depth : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
3911	printf("RQT trans. size (min / max) : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
3912	printf("Max RQT depth inter : %d\n", m_uiQuadtreeTUMaxDepthInter);
3913	printf("Max RQT depth intra : %d\n", m_uiQuadtreeTUMaxDepthIntra);
3914	#endif
3915	printf("Min PCM size : %d\n", 1 << m_uiPCMLog2MinSize);
3916	printf("Motion search range : %d\n", m_iSearchRange );
3917	#if !SVC_EXTENSION
3918	printf("Intra period : %d\n", m_iIntraPeriod );
3919	#endif
3920	printf("Decoding refresh type : %d\n", m_iDecodingRefreshType );
3921	#if !SVC_EXTENSION
3922	printf("QP : %5.2f\n", m_fQP );
3923	#endif
3924	printf("Max dQP signaling depth : %d\n", m_iMaxCuDQPDepth);
3925
3926	printf("Cb QP Offset : %d\n", m_cbQpOffset );
3927	printf("Cr QP Offset : %d\n", m_crQpOffset);
3928
3929	printf("QP adaptation : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
3930	printf("GOP size : %d\n", m_iGOPSize );
3931	#if !O0194_DIFFERENT_BITDEPTH_EL_BL
3932	printf("Internal bit depth : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC );
3933	printf("PCM sample bit depth : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma );
3934	#endif
3935	#if O0215_PHASE_ALIGNMENT
3936	printf("Cross-layer sample alignment : %d\n", m_phaseAlignFlag);
3937	#endif
3938	#if !RC_SHVC_HARMONIZATION
3939	printf("RateControl : %d\n", m_RCEnableRateControl );
3940	if(m_RCEnableRateControl)
3941	{
3942	printf("TargetBitrate : %d\n", m_RCTargetBitrate );
3943	printf("KeepHierarchicalBit : %d\n", m_RCKeepHierarchicalBit );
3944	printf("LCULevelRC : %d\n", m_RCLCULevelRC );
3945	printf("UseLCUSeparateModel : %d\n", m_RCUseLCUSeparateModel );
3946	printf("InitialQP : %d\n", m_RCInitialQP );
3947	printf("ForceIntraQP : %d\n", m_RCForceIntraQP );
3948	}
3949	#endif
3950
3951	printf("Max Num Merge Candidates : %d\n", m_maxNumMergeCand);
3952	printf("\n");
3953
3954	printf("TOOL CFG: ");
3955	#if !O0194_DIFFERENT_BITDEPTH_EL_BL
3956	printf("IBD:%d ", g_bitDepthY > m_inputBitDepthY \|\| g_bitDepthC > m_inputBitDepthC);
3957	#endif
3958	printf("HAD:%d ", m_bUseHADME );
3959	printf("RDQ:%d ", m_useRDOQ );
3960	printf("RDQTS:%d ", m_useRDOQTS );
3961	printf("RDpenalty:%d ", m_rdPenalty );
3962	printf("SQP:%d ", m_uiDeltaQpRD );
3963	printf("ASR:%d ", m_bUseASR );
3964	printf("FEN:%d ", m_bUseFastEnc );
3965	printf("ECU:%d ", m_bUseEarlyCU );
3966	printf("FDM:%d ", m_useFastDecisionForMerge );
3967	printf("CFM:%d ", m_bUseCbfFastMode );
3968	printf("ESD:%d ", m_useEarlySkipDetection );
3969	#if FAST_INTRA_SHVC
3970	printf("FIS:%d ", m_useFastIntraScalable );
3971	#endif
3972	printf("RQT:%d ", 1 );
3973	printf("TransformSkip:%d ", m_useTransformSkip );
3974	printf("TransformSkipFast:%d ", m_useTransformSkipFast );
3975	printf("Slice: M=%d ", m_sliceMode);
3976	if (m_sliceMode!=0)
3977	{
3978	printf("A=%d ", m_sliceArgument);
3979	}
3980	printf("SliceSegment: M=%d ",m_sliceSegmentMode);
3981	if (m_sliceSegmentMode!=0)
3982	{
3983	printf("A=%d ", m_sliceSegmentArgument);
3984	}
3985	printf("CIP:%d ", m_bUseConstrainedIntraPred);
3986	printf("SAO:%d ", (m_bUseSAO)?(1):(0));
3987	#if !LAYER_CTB
3988	printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
3989	#endif
3990	if (m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagForce)
3991	{
3992	printf("TransQuantBypassEnabled: =1 ");
3993	}
3994	else
3995	{
3996	printf("TransQuantBypassEnabled:%d ", (m_TransquantBypassEnableFlag)? 1:0 );
3997	}
3998	printf("WPP:%d ", (Int)m_useWeightedPred);
3999	printf("WPB:%d ", (Int)m_useWeightedBiPred);
4000	printf("PME:%d ", m_log2ParallelMergeLevel);
4001	#if !SVC_EXTENSION
4002	printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d",
4003	m_iWaveFrontSynchro, m_iWaveFrontSubstreams);
4004	#endif
4005	printf(" ScalingList:%d ", m_useScalingListId );
4006	printf("TMVPMode:%d ", m_TMVPModeId );
4007	#if ADAPTIVE_QP_SELECTION
4008	printf("AQpS:%d", m_bUseAdaptQpSelect );
4009	#endif
4010
4011	printf(" SignBitHidingFlag:%d ", m_signHideFlag);
4012	#if SVC_EXTENSION
4013	printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 );
4014	printf("EL_RAP_SliceType: %d ", m_elRapSliceBEnabled);
4015	printf("REF_IDX_ME_ZEROMV: %d ", REF_IDX_ME_ZEROMV);
4016	printf("ENCODER_FAST_MODE: %d ", ENCODER_FAST_MODE);
4017	printf("REF_IDX_MFM: %d ", REF_IDX_MFM);
4018	printf("O0194_DIFFERENT_BITDEPTH_EL_BL: %d ", O0194_DIFFERENT_BITDEPTH_EL_BL);
4019	printf("O0194_JOINT_US_BITSHIFT: %d ", O0194_JOINT_US_BITSHIFT);
4020	#else
4021	printf("RecalQP:%d", m_recalculateQPAccordingToLambda ? 1 : 0 );
4022	#endif
4023	#if Q0048_CGS_3D_ASYMLUT
4024	printf("CGS: %d CGSMaxOctantDepth: %d CGSMaxYPartNumLog2: %d CGSLUTBit:%d " , m_nCGSFlag , m_nCGSMaxOctantDepth , m_nCGSMaxYPartNumLog2 , m_nCGSLUTBit );
4025	#endif
4026	#if R0151_CGS_3D_ASYMLUT_IMPROVE
4027	printf("CGSAdaptC:%d " , m_nCGSAdaptiveChroma );
4028	#endif
4029	#if R0179_ENC_OPT_3DLUT_SIZE
4030	printf("CGSSizeRDO:%d " , m_nCGSLutSizeRDO );
4031	#endif
4032
4033	printf("\n\n");
4034
4035	fflush(stdout);
4036	}
4037
4038	Bool confirmPara(Bool bflag, const Char* message)
4039	{
4040	if (!bflag)
4041	return false;
4042
4043	printf("Error: %s\n",message);
4044	return true;
4045	}
4046
4047	#if SVC_EXTENSION
4048	#if OUTPUT_LAYER_SETS_CONFIG
4049	Void TAppEncCfg::cfgStringToArray(Int *arr, string const cfgString, Int const numEntries, const char logString)
4050	#else
4051	Void TAppEncCfg::cfgStringToArray(Int *arr, string cfgString, Int numEntries, const char logString)
4052	#endif
4053	{
4054	Char *tempChar = cfgString.empty() ? NULL : strdup(cfgString.c_str());
4055	if( numEntries > 0 )
4056	{
4057	Char *arrayEntry;
4058	Int i = 0;
4059	*arr = new Int[numEntries];
4060
4061	#if OUTPUT_LAYER_SETS_CONFIG
4062	if( tempChar == NULL )
4063	{
4064	arrayEntry = NULL;
4065	}
4066	else
4067	{
4068	arrayEntry = strtok( tempChar, " ,");
4069	}
4070	#else
4071	arrayEntry = strtok( tempChar, " ,");
4072	#endif
4073	while(arrayEntry != NULL)
4074	{
4075	if( i >= numEntries )
4076	{
4077	printf( "%s: The number of entries specified is larger than the allowed number.\n", logString );
4078	exit( EXIT_FAILURE );
4079	}
4080	( arr + i ) = atoi( arrayEntry );
4081	arrayEntry = strtok(NULL, " ,");
4082	i++;
4083	}
4084	if( i < numEntries )
4085	{
4086	printf( "%s: Some entries are not specified.\n", logString );
4087	exit( EXIT_FAILURE );
4088	}
4089	}
4090	else
4091	{
4092	*arr = NULL;
4093	}
4094
4095	if( tempChar )
4096	{
4097	free( tempChar );
4098	tempChar = NULL;
4099	}
4100	}
4101
4102	#if OUTPUT_LAYER_SETS_CONFIG
4103	Bool TAppEncCfg::scanStringToArray(string const cfgString, Int const numEntries, const char* logString, Int * const returnArray)
4104	{
4105	Int *tempArray = NULL;
4106	// For all layer sets
4107	cfgStringToArray( &tempArray, cfgString, numEntries, logString );
4108	if(tempArray)
4109	{
4110	for(Int i = 0; i < numEntries; i++)
4111	{
4112	returnArray[i] = tempArray[i];
4113	}
4114	delete [] tempArray; tempArray = NULL;
4115	return true;
4116	}
4117	return false;
4118	}
4119	Bool TAppEncCfg::scanStringToArray(string const cfgString, Int const numEntries, const char* logString, std::vector<Int> & returnVector)
4120	{
4121	Int *tempArray = NULL;
4122	// For all layer sets
4123	cfgStringToArray( &tempArray, cfgString, numEntries, logString );
4124	if(tempArray)
4125	{
4126	returnVector.empty();
4127	for(Int i = 0; i < numEntries; i++)
4128	{
4129	returnVector.push_back(tempArray[i]);
4130	}
4131	delete [] tempArray; tempArray = NULL;
4132	return true;
4133	}
4134	return false;
4135	}
4136	#endif
4137	#endif //SVC_EXTENSION
4138	//! \}

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

Download in other formats: