Context navigation

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

Visit:

Last change on this file since 830 was 829, checked in by seregin, 10 years ago
memory release
Property svn:eol-style set to `native`
File size: 147.1 KB

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

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

Download in other formats: