Context navigation

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

Visit:

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

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

Download in other formats: