Context navigation

source: 3DVCSoftware/trunk/source/App/TAppEncoder/TAppEncCfg.cpp @ 1069

Visit:

Last change on this file since 1069 was 1066, checked in by tech, 10 years ago
Merged 12.0-dev1@1065.
Property svn:eol-style set to `native`
File size: 127.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	TAppEncCfg::TAppEncCfg()
66	#if H_MV
67	: m_pchBitstreamFile()
68	#else
69	: m_pchInputFile()
70	, m_pchBitstreamFile()
71	, m_pchReconFile()
72	#endif
73	, m_pchdQPFile()
74	, m_pColumnWidth()
75	, m_pRowHeight()
76	, m_scalingListFile()
77	{
78	#if !H_MV
79	m_aidQP = NULL;
80	#endif
81	m_startOfCodedInterval = NULL;
82	m_codedPivotValue = NULL;
83	m_targetPivotValue = NULL;
84
85	#if KWU_RC_MADPRED_E0227
86	m_depthMADPred = 0;
87	#endif
88	}
89
90	TAppEncCfg::~TAppEncCfg()
91	{
92	#if H_MV
93	for( Int layer = 0; layer < m_aidQP.size(); layer++ )
94	{
95	if ( m_aidQP[layer] != NULL )
96	{
97	delete[] m_aidQP[layer];
98	m_aidQP[layer] = NULL;
99	}
100	}
101	for(Int i = 0; i< m_pchInputFileList.size(); i++ )
102	{
103	if ( m_pchInputFileList[i] != NULL )
104	free (m_pchInputFileList[i]);
105	}
106	#else
107	if ( m_aidQP )
108	{
109	delete[] m_aidQP;
110	}
111	#endif
112	if ( m_startOfCodedInterval )
113	{
114	delete[] m_startOfCodedInterval;
115	m_startOfCodedInterval = NULL;
116	}
117	if ( m_codedPivotValue )
118	{
119	delete[] m_codedPivotValue;
120	m_codedPivotValue = NULL;
121	}
122	if ( m_targetPivotValue )
123	{
124	delete[] m_targetPivotValue;
125	m_targetPivotValue = NULL;
126	}
127	#if !H_MV
128	free(m_pchInputFile);
129	#endif
130	free(m_pchBitstreamFile);
131	#if H_MV
132	for(Int i = 0; i< m_pchReconFileList.size(); i++ )
133	{
134	if ( m_pchReconFileList[i] != NULL )
135	free (m_pchReconFileList[i]);
136	}
137	#else
138	free(m_pchReconFile);
139	#endif
140	free(m_pchdQPFile);
141	free(m_pColumnWidth);
142	free(m_pRowHeight);
143	free(m_scalingListFile);
144	#if H_MV
145	for( Int i = 0; i < m_GOPListMvc.size(); i++ )
146	{
147	if( m_GOPListMvc[i] )
148	{
149	delete[] m_GOPListMvc[i];
150	m_GOPListMvc[i] = NULL;
151	}
152	}
153	#endif
154	#if H_3D
155	#if H_3D_VSO
156	if ( m_pchVSOConfig != NULL)
157	free ( m_pchVSOConfig );
158	#endif
159	if ( m_pchCameraParameterFile != NULL )
160	free ( m_pchCameraParameterFile );
161
162	if ( m_pchBaseViewCameraNumbers != NULL )
163	free ( m_pchBaseViewCameraNumbers );
164	#endif
165	}
166
167	Void TAppEncCfg::create()
168	{
169	}
170
171	Void TAppEncCfg::destroy()
172	{
173	}
174
175	std::istringstream &operator>>(std::istringstream &in, GOPEntry &entry) //input
176	{
177	in>>entry.m_sliceType;
178	in>>entry.m_POC;
179	in>>entry.m_QPOffset;
180	in>>entry.m_QPFactor;
181	in>>entry.m_tcOffsetDiv2;
182	in>>entry.m_betaOffsetDiv2;
183	in>>entry.m_temporalId;
184	in>>entry.m_numRefPicsActive;
185	in>>entry.m_numRefPics;
186	for ( Int i = 0; i < entry.m_numRefPics; i++ )
187	{
188	in>>entry.m_referencePics[i];
189	}
190	in>>entry.m_interRPSPrediction;
191	#if AUTO_INTER_RPS
192	if (entry.m_interRPSPrediction==1)
193	{
194	in>>entry.m_deltaRPS;
195	in>>entry.m_numRefIdc;
196	for ( Int i = 0; i < entry.m_numRefIdc; i++ )
197	{
198	in>>entry.m_refIdc[i];
199	}
200	}
201	else if (entry.m_interRPSPrediction==2)
202	{
203	in>>entry.m_deltaRPS;
204	}
205	#else
206	if (entry.m_interRPSPrediction)
207	{
208	in>>entry.m_deltaRPS;
209	in>>entry.m_numRefIdc;
210	for ( Int i = 0; i < entry.m_numRefIdc; i++ )
211	{
212	in>>entry.m_refIdc[i];
213	}
214	}
215	#endif
216	#if H_MV
217	in>>entry.m_numActiveRefLayerPics;
218	for( Int i = 0; i < entry.m_numActiveRefLayerPics; i++ )
219	{
220	in>>entry.m_interLayerPredLayerIdc[i];
221	}
222	for( Int i = 0; i < entry.m_numActiveRefLayerPics; i++ )
223	{
224	in>>entry.m_interViewRefPosL[0][i];
225	}
226	for( Int i = 0; i < entry.m_numActiveRefLayerPics; i++ )
227	{
228	in>>entry.m_interViewRefPosL[1][i];
229	}
230	#endif
231	return in;
232	}
233
234	static const struct MapStrToProfile {
235	const Char* str;
236	Profile::Name value;
237	} strToProfile[] = {
238	{"none", Profile::NONE},
239	{"main", Profile::MAIN},
240	{"main10", Profile::MAIN10},
241	{"main-still-picture", Profile::MAINSTILLPICTURE},
242	#if H_MV
243	#if H_MV_HLS10_PTL
244	{"multiview-main", Profile::MULTIVIEWMAIN},
245	#if H_3D
246	{"3d-main" , Profile::MAIN3D},
247	#endif
248
249	#else
250	{"main-stereo", Profile::MAINSTEREO},
251	{"main-multiview", Profile::MAINMULTIVIEW},
252	#if H_3D
253	{"main-3d" , Profile::MAIN3D},
254	#endif
255	#endif
256	#endif
257	};
258
259	static const struct MapStrToTier {
260	const Char* str;
261	Level::Tier value;
262	} strToTier[] = {
263	{"main", Level::MAIN},
264	{"high", Level::HIGH},
265	};
266
267	static const struct MapStrToLevel {
268	const Char* str;
269	Level::Name value;
270	} strToLevel[] = {
271	{"none",Level::NONE},
272	{"1", Level::LEVEL1},
273	{"2", Level::LEVEL2},
274	{"2.1", Level::LEVEL2_1},
275	{"3", Level::LEVEL3},
276	{"3.1", Level::LEVEL3_1},
277	{"4", Level::LEVEL4},
278	{"4.1", Level::LEVEL4_1},
279	{"5", Level::LEVEL5},
280	{"5.1", Level::LEVEL5_1},
281	{"5.2", Level::LEVEL5_2},
282	{"6", Level::LEVEL6},
283	{"6.1", Level::LEVEL6_1},
284	{"6.2", Level::LEVEL6_2},
285	};
286
287	template<typename T, typename P>
288	static istream& readStrToEnum(P map[], unsigned long mapLen, istream &in, T &val)
289	{
290	string str;
291	in >> str;
292
293	for (Int i = 0; i < mapLen; i++)
294	{
295	if (str == map[i].str)
296	{
297	val = map[i].value;
298	goto found;
299	}
300	}
301	/* not found */
302	in.setstate(ios::failbit);
303	found:
304	return in;
305	}
306
307	static istream& operator>>(istream &in, Profile::Name &profile)
308	{
309	return readStrToEnum(strToProfile, sizeof(strToProfile)/sizeof(*strToProfile), in, profile);
310	}
311
312	static istream& operator>>(istream &in, Level::Tier &tier)
313	{
314	return readStrToEnum(strToTier, sizeof(strToTier)/sizeof(*strToTier), in, tier);
315	}
316
317	static istream& operator>>(istream &in, Level::Name &level)
318	{
319	return readStrToEnum(strToLevel, sizeof(strToLevel)/sizeof(*strToLevel), in, level);
320	}
321
322	// ====================================================================================================================
323	// Public member functions
324	// ====================================================================================================================
325
326	/** \param argc number of arguments
327	\param argv array of arguments
328	\retval true when success
329	*/
330	Bool TAppEncCfg::parseCfg( Int argc, Char* argv[] )
331	{
332	Bool do_help = false;
333
334	#if !H_MV
335	string cfg_InputFile;
336	#endif
337	string cfg_BitstreamFile;
338	#if !H_MV
339	string cfg_ReconFile;
340	#endif
341	#if H_MV
342	vector<Int> cfg_dimensionLength;
343	#if H_MV_HLS10_PTL
344	string cfg_profiles;
345	string cfg_levels;
346	string cfg_tiers;
347	#endif
348	#if H_3D
349	cfg_dimensionLength.push_back( 2 ); // depth
350	cfg_dimensionLength.push_back( 32 ); // texture
351	#else
352	cfg_dimensionLength.push_back( 64 );
353	#endif
354	#endif
355	string cfg_dQPFile;
356	string cfg_ColumnWidth;
357	string cfg_RowHeight;
358	string cfg_ScalingListFile;
359	string cfg_startOfCodedInterval;
360	string cfg_codedPivotValue;
361	string cfg_targetPivotValue;
362	po::Options opts;
363	opts.addOptions()
364	("help", do_help, false, "this help text")
365	("c", po::parseConfigFile, "configuration file name")
366
367	// File, I/O and source parameters
368	#if H_MV
369	("InputFile_%d,i_%d", m_pchInputFileList, (char *) 0 , MAX_NUM_LAYER_IDS , "original Yuv input file name %d")
370	#else
371	("InputFile,i", cfg_InputFile, string(""), "Original YUV input file name")
372	#endif
373	("BitstreamFile,b", cfg_BitstreamFile, string(""), "Bitstream output file name")
374	#if H_MV
375	("ReconFile_%d,o_%d", m_pchReconFileList, (char *) 0 , MAX_NUM_LAYER_IDS , "reconstructed Yuv output file name %d")
376	#else
377	("ReconFile,o", cfg_ReconFile, string(""), "Reconstructed YUV output file name")
378	#endif
379	#if H_MV
380	("NumberOfLayers", m_numberOfLayers , 1, "Number of layers")
381	#if !H_3D
382	#if H_MV_HLS10_AUX
383	("ScalabilityMask", m_scalabilityMask , 2 , "Scalability Mask: 2: Multiview, 8: Auxiliary, 10: Multiview + Auxiliary")
384	#else
385	("ScalabilityMask", m_scalabilityMask , 2 , "Scalability Mask")
386	#endif
387	#else
388	("ScalabilityMask", m_scalabilityMask , 3 , "Scalability Mask, 1: Texture 3: Texture + Depth ")
389	#endif
390	("DimensionIdLen", m_dimensionIdLen , cfg_dimensionLength , "Number of bits used to store dimensions Id")
391	("ViewOrderIndex", m_viewOrderIndex , std::vector<Int>(1,0), "View Order Index per layer")
392	("ViewId", m_viewId , std::vector<Int>(1,0), "View Id per View Order Index")
393	#if H_MV_HLS10_AUX
394	("AuxId", m_auxId , std::vector<Int>(1,0), "AuxId per layer")
395	#endif
396	#if H_3D
397	("DepthFlag", m_depthFlag , std::vector<Int>(1,0), "Depth Flag")
398	#if H_3D_DIM
399	("DMM", m_useDMM, true, "Depth intra model modes")
400	#if SEPARATE_FLAG_I0085
401	("IVP", m_useIVP, true, "intra-view prediction")
402	#endif
403	("SDC", m_useSDC, true, "Simplified depth coding")
404	("DLT", m_useDLT, true, "Depth lookup table")
405	#endif
406	#if MTK_SINGLE_DEPTH_MODE_I0095
407	("SingleDepthMode", m_useSingleDepthMode, true, "Single depth mode")
408	#endif
409	#endif
410	#if H_MV_HLS10_GEN_FIX
411	("TargetEncLayerIdList", m_targetEncLayerIdList, std::vector<Int>(0,0), "LayerIds in Nuh to be encoded")
412	#endif
413	("LayerIdInNuh", m_layerIdInNuh , std::vector<Int>(1,0), "LayerId in Nuh")
414	("SplittingFlag", m_splittingFlag , false , "Splitting Flag")
415
416	// Layer Sets + Output Layer Sets + Profile Tier Level
417	("VpsNumLayerSets", m_vpsNumLayerSets , 1 , "Number of layer sets")
418	("LayerIdsInSet_%d", m_layerIdsInSets , std::vector<Int>(1,0), MAX_VPS_OP_SETS_PLUS1 ,"LayerIds of Layer set")
419	#if H_MV_HLS10_ADD_LAYERSETS
420	("NumAddLayerSets" , m_numAddLayerSets , 0 , "NumAddLayerSets ")
421	("HighestLayerIdxPlus1_%d", m_highestLayerIdxPlus1, std::vector< Int >(0,0) ,MAX_VPS_NUM_ADD_LAYER_SETS, "HighestLayerIdxPlus1")
422	#endif
423	("DefaultTargetOutputLayerIdc" , m_defaultOutputLayerIdc , 0, "Specifies output layers of layer sets, 0: output all layers, 1: output highest layer, 2: specified by LayerIdsInDefOutputLayerSet")
424	("OutputLayerSetIdx", m_outputLayerSetIdx , std::vector<Int>(0,0), "Indices of layer sets used as additional output layer sets")
425
426	("LayerIdsInAddOutputLayerSet_%d", m_layerIdsInAddOutputLayerSet , std::vector<Int>(0,0), MAX_VPS_ADD_OUTPUT_LAYER_SETS, "Indices in VPS of output layers in additional output layer set")
427	("LayerIdsInDefOutputLayerSet_%d", m_layerIdsInDefOutputLayerSet , std::vector<Int>(0,0), MAX_VPS_OP_SETS_PLUS1, "Indices in VPS of output layers in layer set")
428	("AltOutputLayerFlag", m_altOutputLayerFlag , std::vector<Bool>(1,0), "Alt output layer flag")
429
430	#if H_MV_HLS10_PTL
431	("ProfileTierLevelIdx_%d", m_profileTierLevelIdx, std::vector<Int>(0), MAX_NUM_LAYERS, "Indices to profile level tier for ols")
432	#else
433	("ProfileLevelTierIdx", m_profileLevelTierIdx, std::vector<Int>(1,0), "Indices to profile level tier")
434	#endif
435	// Layer dependencies
436	("DirectRefLayers_%d", m_directRefLayers , std::vector<Int>(0,0), MAX_NUM_LAYERS, "LayerIds of direct reference layers")
437	("DependencyTypes_%d", m_dependencyTypes , std::vector<Int>(0,0), MAX_NUM_LAYERS, "Dependency types of direct reference layers, 0: Sample 1: Motion 2: Sample+Motion")
438	#endif
439	("SourceWidth,-wdt", m_iSourceWidth, 0, "Source picture width")
440	("SourceHeight,-hgt", m_iSourceHeight, 0, "Source picture height")
441	("InputBitDepth", m_inputBitDepthY, 8, "Bit-depth of input file")
442	("OutputBitDepth", m_outputBitDepthY, 0, "Bit-depth of output file (default:InternalBitDepth)")
443	("InternalBitDepth", m_internalBitDepthY, 0, "Bit-depth the codec operates at. (default:InputBitDepth)"
444	"If different to InputBitDepth, source data will be converted")
445	("InputBitDepthC", m_inputBitDepthC, 0, "As per InputBitDepth but for chroma component. (default:InputBitDepth)")
446	("OutputBitDepthC", m_outputBitDepthC, 0, "As per OutputBitDepth but for chroma component. (default:InternalBitDepthC)")
447	("InternalBitDepthC", m_internalBitDepthC, 0, "As per InternalBitDepth but for chroma component. (default:IntrenalBitDepth)")
448	("ConformanceMode", m_conformanceMode, 0, "Window conformance mode (0: no window, 1:automatic padding, 2:padding, 3:conformance")
449	("HorizontalPadding,-pdx",m_aiPad[0], 0, "Horizontal source padding for conformance window mode 2")
450	("VerticalPadding,-pdy", m_aiPad[1], 0, "Vertical source padding for conformance window mode 2")
451	("ConfLeft", m_confLeft, 0, "Left offset for window conformance mode 3")
452	("ConfRight", m_confRight, 0, "Right offset for window conformance mode 3")
453	("ConfTop", m_confTop, 0, "Top offset for window conformance mode 3")
454	("ConfBottom", m_confBottom, 0, "Bottom offset for window conformance mode 3")
455	("FrameRate,-fr", m_iFrameRate, 0, "Frame rate")
456	("FrameSkip,-fs", m_FrameSkip, 0u, "Number of frames to skip at start of input YUV")
457	("FramesToBeEncoded,f", m_framesToBeEncoded, 0, "Number of frames to be encoded (default=all)")
458
459	//Field coding parameters
460	("FieldCoding", m_isField, false, "Signals if it's a field based coding")
461	("TopFieldFirst, Tff", m_isTopFieldFirst, false, "In case of field based coding, signals whether if it's a top field first or not")
462
463	// Profile and level
464	#if H_MV_HLS10_PTL
465	("Profile", cfg_profiles, string(""), "Profile in VpsProfileTierLevel (Indication only)")
466	("Level", cfg_levels , string(""), "Level indication in VpsProfileTierLevel (Indication only)")
467	("Tier", cfg_tiers , string(""), "Tier indication in VpsProfileTierLevel (Indication only)")
468	("InblFlag",m_inblFlag , std::vector<Bool>(0), "InblFlags in VpsProfileTierLevel (Indication only)" )
469	#else
470	("Profile", m_profile, Profile::NONE, "Profile to be used when encoding (Incomplete)")
471	("Level", m_level, Level::NONE, "Level limit to be used, eg 5.1 (Incomplete)")
472	("Tier", m_levelTier, Level::MAIN, "Tier to use for interpretation of --Level")
473	#endif
474	("ProgressiveSource", m_progressiveSourceFlag, false, "Indicate that source is progressive")
475	("InterlacedSource", m_interlacedSourceFlag, false, "Indicate that source is interlaced")
476	("NonPackedSource", m_nonPackedConstraintFlag, false, "Indicate that source does not contain frame packing")
477	("FrameOnly", m_frameOnlyConstraintFlag, false, "Indicate that the bitstream contains only frames")
478
479	// Unit definition parameters
480	("MaxCUWidth", m_uiMaxCUWidth, 64u)
481	("MaxCUHeight", m_uiMaxCUHeight, 64u)
482	// todo: remove defaults from MaxCUSize
483	("MaxCUSize,s", m_uiMaxCUWidth, 64u, "Maximum CU size")
484	("MaxCUSize,s", m_uiMaxCUHeight, 64u, "Maximum CU size")
485	("MaxPartitionDepth,h", m_uiMaxCUDepth, 4u, "CU depth")
486
487	("QuadtreeTULog2MaxSize", m_uiQuadtreeTULog2MaxSize, 6u, "Maximum TU size in logarithm base 2")
488	("QuadtreeTULog2MinSize", m_uiQuadtreeTULog2MinSize, 2u, "Minimum TU size in logarithm base 2")
489
490	("QuadtreeTUMaxDepthIntra", m_uiQuadtreeTUMaxDepthIntra, 1u, "Depth of TU tree for intra CUs")
491	("QuadtreeTUMaxDepthInter", m_uiQuadtreeTUMaxDepthInter, 2u, "Depth of TU tree for inter CUs")
492	#if H_MV
493	// Coding structure parameters
494	("IntraPeriod,-ip", m_iIntraPeriod,std::vector<Int>(1,-1), "Intra period in frames, (-1: only first frame), per layer")
495	#else
496	// Coding structure paramters
497	("IntraPeriod,-ip", m_iIntraPeriod, -1, "Intra period in frames, (-1: only first frame)")
498	#endif
499	#if ALLOW_RECOVERY_POINT_AS_RAP
500	("DecodingRefreshType,-dr", m_iDecodingRefreshType, 0, "Intra refresh type (0:none 1:CRA 2:IDR 3:RecPointSEI)")
501	#else
502	("DecodingRefreshType,-dr", m_iDecodingRefreshType, 0, "Intra refresh type (0:none 1:CRA 2:IDR)")
503	#endif
504	("GOPSize,g", m_iGOPSize, 1, "GOP size of temporal structure")
505	// motion options
506	("FastSearch", m_iFastSearch, 1, "0:Full search 1:Diamond 2:PMVFAST")
507	("SearchRange,-sr", m_iSearchRange, 96, "Motion search range")
508	("BipredSearchRange", m_bipredSearchRange, 4, "Motion search range for bipred refinement")
509	("HadamardME", m_bUseHADME, true, "Hadamard ME for fractional-pel")
510	("ASR", m_bUseASR, false, "Adaptive motion search range")
511
512	// Mode decision parameters
513	("LambdaModifier0,-LM0", m_adLambdaModifier[ 0 ], ( Double )1.0, "Lambda modifier for temporal layer 0")
514	("LambdaModifier1,-LM1", m_adLambdaModifier[ 1 ], ( Double )1.0, "Lambda modifier for temporal layer 1")
515	("LambdaModifier2,-LM2", m_adLambdaModifier[ 2 ], ( Double )1.0, "Lambda modifier for temporal layer 2")
516	("LambdaModifier3,-LM3", m_adLambdaModifier[ 3 ], ( Double )1.0, "Lambda modifier for temporal layer 3")
517	("LambdaModifier4,-LM4", m_adLambdaModifier[ 4 ], ( Double )1.0, "Lambda modifier for temporal layer 4")
518	("LambdaModifier5,-LM5", m_adLambdaModifier[ 5 ], ( Double )1.0, "Lambda modifier for temporal layer 5")
519	("LambdaModifier6,-LM6", m_adLambdaModifier[ 6 ], ( Double )1.0, "Lambda modifier for temporal layer 6")
520
521	/* Quantization parameters */
522	#if H_MV
523	("QP,q", m_fQP, std::vector<double>(1,30.0), "Qp values for each layer, if value is float, QP is switched once during encoding")
524	#else
525	("QP,q", m_fQP, 30.0, "Qp value, if value is float, QP is switched once during encoding")
526	#endif
527	("DeltaQpRD,-dqr",m_uiDeltaQpRD, 0u, "max dQp offset for slice")
528	("MaxDeltaQP,d", m_iMaxDeltaQP, 0, "max dQp offset for block")
529	("MaxCuDQPDepth,-dqd", m_iMaxCuDQPDepth, 0, "max depth for a minimum CuDQP")
530
531	("CbQpOffset,-cbqpofs", m_cbQpOffset, 0, "Chroma Cb QP Offset")
532	("CrQpOffset,-crqpofs", m_crQpOffset, 0, "Chroma Cr QP Offset")
533
534	#if ADAPTIVE_QP_SELECTION
535	("AdaptiveQpSelection,-aqps", m_bUseAdaptQpSelect, false, "AdaptiveQpSelection")
536	#endif
537
538	("AdaptiveQP,-aq", m_bUseAdaptiveQP, false, "QP adaptation based on a psycho-visual model")
539	("MaxQPAdaptationRange,-aqr", m_iQPAdaptationRange, 6, "QP adaptation range")
540	("dQPFile,m", cfg_dQPFile, string(""), "dQP file name")
541	("RDOQ", m_useRDOQ, true )
542	("RDOQTS", m_useRDOQTS, true )
543	("RDpenalty", m_rdPenalty, 0, "RD-penalty for 32x32 TU for intra in non-intra slices. 0:disbaled 1:RD-penalty 2:maximum RD-penalty")
544
545	// Deblocking filter parameters
546	#if H_MV
547	("LoopFilterDisable", m_bLoopFilterDisable, std::vector<Bool>(1,false), "Disable Loop Filter per Layer" )
548	#else
549	("LoopFilterDisable", m_bLoopFilterDisable, false )
550	#endif
551	("LoopFilterOffsetInPPS", m_loopFilterOffsetInPPS, false )
552	("LoopFilterBetaOffset_div2", m_loopFilterBetaOffsetDiv2, 0 )
553	("LoopFilterTcOffset_div2", m_loopFilterTcOffsetDiv2, 0 )
554	("DeblockingFilterControlPresent", m_DeblockingFilterControlPresent, false )
555	("DeblockingFilterMetric", m_DeblockingFilterMetric, false )
556
557	#if H_3D_ARP
558	("AdvMultiviewResPred", m_uiUseAdvResPred, (UInt)1, "Usage of Advanced Residual Prediction" )
559	#endif
560	#if H_3D_SPIVMP
561	("SubPULog2Size", m_iSubPULog2Size, (Int)3, "Sub-PU size index: 2^n")
562	("SubPUMPILog2Size", m_iSubPUMPILog2Size, (Int)3, "Sub-PU MPI size index: 2^n")
563	#endif
564	#if H_3D_IC
565	("IlluCompEnable", m_abUseIC, true, "Enable illumination compensation")
566	("IlluCompLowLatencyEnc", m_bUseLowLatencyICEnc, false, "Enable low-latency illumination compensation encoding")
567	#endif
568	#if H_3D_INTER_SDC
569	("InterSDC", m_bDepthInterSDCFlag, true, "Enable depth inter SDC")
570	#endif
571	#if H_3D_DBBP
572	("DBBP", m_bUseDBBP, true, "Enable depth-based block partitioning" )
573	#endif
574	#if H_3D_IV_MERGE
575	("MPI", m_bMPIFlag, true, "Enable MPI")
576	#endif
577	// Coding tools
578	("AMP", m_enableAMP, true, "Enable asymmetric motion partitions")
579	("TransformSkip", m_useTransformSkip, false, "Intra transform skipping")
580	("TransformSkipFast", m_useTransformSkipFast, false, "Fast intra transform skipping")
581	#if H_MV
582	("SAO", m_bUseSAO, std::vector<Bool>(1,true), "Enable Sample Adaptive Offset per Layer")
583	#else
584	("SAO", m_bUseSAO, true, "Enable Sample Adaptive Offset")
585	#endif
586	("MaxNumOffsetsPerPic", m_maxNumOffsetsPerPic, 2048, "Max number of SAO offset per picture (Default: 2048)")
587	("SAOLcuBoundary", m_saoLcuBoundary, false, "0: right/bottom LCU boundary areas skipped from SAO parameter estimation, 1: non-deblocked pixels are used for those areas")
588	("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")
589	("SliceArgument", m_sliceArgument, 0, "Depending on SliceMode being:"
590	"\t1: max number of CTUs per slice"
591	"\t2: max number of bytes per slice"
592	"\t3: max number of tiles per slice")
593	("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")
594	("SliceSegmentArgument", m_sliceSegmentArgument, 0, "Depending on SliceSegmentMode being:"
595	"\t1: max number of CTUs per slice segment"
596	"\t2: max number of bytes per slice segment"
597	"\t3: max number of tiles per slice segment")
598	("LFCrossSliceBoundaryFlag", m_bLFCrossSliceBoundaryFlag, true)
599
600	("ConstrainedIntraPred", m_bUseConstrainedIntraPred, false, "Constrained Intra Prediction")
601
602	("PCMEnabledFlag", m_usePCM, false)
603	("PCMLog2MaxSize", m_pcmLog2MaxSize, 5u)
604	("PCMLog2MinSize", m_uiPCMLog2MinSize, 3u)
605	("PCMInputBitDepthFlag", m_bPCMInputBitDepthFlag, true)
606	("PCMFilterDisableFlag", m_bPCMFilterDisableFlag, false)
607
608	("WeightedPredP,-wpP", m_useWeightedPred, false, "Use weighted prediction in P slices")
609	("WeightedPredB,-wpB", m_useWeightedBiPred, false, "Use weighted (bidirectional) prediction in B slices")
610	("Log2ParallelMergeLevel", m_log2ParallelMergeLevel, 2u, "Parallel merge estimation region")
611	("UniformSpacingIdc", m_iUniformSpacingIdr, 0, "Indicates if the column and row boundaries are distributed uniformly")
612	("NumTileColumnsMinus1", m_iNumColumnsMinus1, 0, "Number of columns in a picture minus 1")
613	("ColumnWidthArray", cfg_ColumnWidth, string(""), "Array containing ColumnWidth values in units of LCU")
614	("NumTileRowsMinus1", m_iNumRowsMinus1, 0, "Number of rows in a picture minus 1")
615	("RowHeightArray", cfg_RowHeight, string(""), "Array containing RowHeight values in units of LCU")
616	("LFCrossTileBoundaryFlag", m_bLFCrossTileBoundaryFlag, true, "1: cross-tile-boundary loop filtering. 0:non-cross-tile-boundary loop filtering")
617	("WaveFrontSynchro", m_iWaveFrontSynchro, 0, "0: no synchro; 1 synchro with TR; 2 TRR etc")
618	("ScalingList", m_useScalingListId, 0, "0: no scaling list, 1: default scaling lists, 2: scaling lists specified in ScalingListFile")
619	("ScalingListFile", cfg_ScalingListFile, string(""), "Scaling list file name")
620	("SignHideFlag,-SBH", m_signHideFlag, 1)
621	("MaxNumMergeCand", m_maxNumMergeCand, 5u, "Maximum number of merge candidates")
622
623	/* Misc. */
624	("SEIDecodedPictureHash", m_decodedPictureHashSEIEnabled, 0, "Control generation of decode picture hash SEI messages\n"
625	"\t3: checksum\n"
626	"\t2: CRC\n"
627	"\t1: use MD5\n"
628	"\t0: disable")
629	("SEIpictureDigest", m_decodedPictureHashSEIEnabled, 0, "deprecated alias for SEIDecodedPictureHash")
630	("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")
631	("FEN", m_bUseFastEnc, false, "fast encoder setting")
632	("ECU", m_bUseEarlyCU, false, "Early CU setting")
633	("FDM", m_useFastDecisionForMerge, true, "Fast decision for Merge RD Cost")
634	("CFM", m_bUseCbfFastMode, false, "Cbf fast mode setting")
635	("ESD", m_useEarlySkipDetection, false, "Early SKIP detection setting")
636	( "RateControl", m_RCEnableRateControl, false, "Rate control: enable rate control" )
637	( "TargetBitrate", m_RCTargetBitrate, 0, "Rate control: target bitrate" )
638	( "KeepHierarchicalBit", m_RCKeepHierarchicalBit, 0, "Rate control: 0: equal bit allocation; 1: fixed ratio bit allocation; 2: adaptive ratio bit allocation" )
639	( "LCULevelRateControl", m_RCLCULevelRC, true, "Rate control: true: LCU level RC; false: picture level RC" )
640	( "RCLCUSeparateModel", m_RCUseLCUSeparateModel, true, "Rate control: use LCU level separate R-lambda model" )
641	( "InitialQP", m_RCInitialQP, 0, "Rate control: initial QP" )
642	( "RCForceIntraQP", m_RCForceIntraQP, false, "Rate control: force intra QP to be equal to initial QP" )
643
644	#if KWU_RC_VIEWRC_E0227
645	("ViewWiseTargetBits, -vtbr" , m_viewTargetBits, std::vector<Int>(1, 32), "View-wise target bit-rate setting")
646	("TargetBitAssign, -ta", m_viewWiseRateCtrl, false, "View-wise rate control on/off")
647	#endif
648	#if KWU_RC_MADPRED_E0227
649	("DepthMADPred, -dm", m_depthMADPred, (UInt)0, "Depth based MAD prediction on/off")
650	#endif
651	#if H_MV
652	#if H_MV_HLS10_GEN_FIX
653	// A lot of this stuff could should actually be derived by the encoder.
654	#endif // H_MV_HLS10_GEN
655	// VPS VUI
656	("VpsVuiPresentFlag" , m_vpsVuiPresentFlag , false , "VpsVuiPresentFlag ")
657	("CrossLayerPicTypeAlignedFlag", m_crossLayerPicTypeAlignedFlag, false , "CrossLayerPicTypeAlignedFlag") // Could actually be derived by the encoder
658	("CrossLayerIrapAlignedFlag" , m_crossLayerIrapAlignedFlag , false , "CrossLayerIrapAlignedFlag ") // Could actually be derived by the encoder
659	("AllLayersIdrAlignedFlag" , m_allLayersIdrAlignedFlag , false , "CrossLayerIrapAlignedFlag ") // Could actually be derived by the encoder
660	("BitRatePresentVpsFlag" , m_bitRatePresentVpsFlag , false , "BitRatePresentVpsFlag ")
661	("PicRatePresentVpsFlag" , m_picRatePresentVpsFlag , false , "PicRatePresentVpsFlag ")
662	("BitRatePresentFlag" , m_bitRatePresentFlag , std::vector< Bool >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "BitRatePresentFlag per sub layer for the N-th layer set")
663	("PicRatePresentFlag" , m_picRatePresentFlag , std::vector< Bool >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "PicRatePresentFlag per sub layer for the N-th layer set")
664	("AvgBitRate" , m_avgBitRate , std::vector< Int >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "AvgBitRate per sub layer for the N-th layer set")
665	("MaxBitRate" , m_maxBitRate , std::vector< Int >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "MaxBitRate per sub layer for the N-th layer set")
666	("ConstantPicRateIdc" , m_constantPicRateIdc , std::vector< Int >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "ConstantPicRateIdc per sub layer for the N-th layer set")
667	("AvgPicRate" , m_avgPicRate , std::vector< Int >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "AvgPicRate per sub layer for the N-th layer set")
668	("TilesNotInUseFlag" , m_tilesNotInUseFlag , true , "TilesNotInUseFlag ")
669	("TilesInUseFlag" , m_tilesInUseFlag , std::vector< Bool >(1,false) , "TilesInUseFlag ")
670	("LoopFilterNotAcrossTilesFlag" , m_loopFilterNotAcrossTilesFlag , std::vector< Bool >(1,false) , "LoopFilterNotAcrossTilesFlag ")
671	("WppNotInUseFlag" , m_wppNotInUseFlag , true , "WppNotInUseFlag ")
672	("WppInUseFlag" , m_wppInUseFlag , std::vector< Bool >(1,0) , "WppInUseFlag ")
673	("TileBoundariesAlignedFlag" , m_tileBoundariesAlignedFlag , std::vector< Bool >(1,0) ,MAX_NUM_LAYERS , "TileBoundariesAlignedFlag per direct reference for the N-th layer")
674	("IlpRestrictedRefLayersFlag" , m_ilpRestrictedRefLayersFlag , false , "IlpRestrictedRefLayersFlag")
675	("MinSpatialSegmentOffsetPlus1", m_minSpatialSegmentOffsetPlus1, std::vector< Int >(1,0) ,MAX_NUM_LAYERS , "MinSpatialSegmentOffsetPlus1 per direct reference for the N-th layer")
676	("CtuBasedOffsetEnabledFlag" , m_ctuBasedOffsetEnabledFlag , std::vector< Bool >(1,0) ,MAX_NUM_LAYERS , "CtuBasedOffsetEnabledFlag per direct reference for the N-th layer")
677	("MinHorizontalCtuOffsetPlus1" , m_minHorizontalCtuOffsetPlus1 , std::vector< Int >(1,0) ,MAX_NUM_LAYERS , "MinHorizontalCtuOffsetPlus1 per direct reference for the N-th layer")
678	#if H_MV_HLS10_VPS_VUI
679	("SingleLayerForNonIrapFlag", m_singleLayerForNonIrapFlag, false , "SingleLayerForNonIrapFlag")
680	("HigherLayerIrapSkipFlag" , m_higherLayerIrapSkipFlag , false , "HigherLayerIrapSkipFlag ")
681	#endif
682	#endif
683
684	("TransquantBypassEnableFlag", m_TransquantBypassEnableFlag, false, "transquant_bypass_enable_flag indicator in PPS")
685	("CUTransquantBypassFlagForce", m_CUTransquantBypassFlagForce, false, "Force transquant bypass mode, when transquant_bypass_enable_flag is enabled")
686	("RecalculateQPAccordingToLambda", m_recalculateQPAccordingToLambda, false, "Recalculate QP values according to lambda values. Do not suggest to be enabled in all intra case")
687	("StrongIntraSmoothing,-sis", m_useStrongIntraSmoothing, true, "Enable strong intra smoothing for 32x32 blocks")
688	("SEIActiveParameterSets", m_activeParameterSetsSEIEnabled, 0, "Enable generation of active parameter sets SEI messages")
689	("VuiParametersPresent,-vui", m_vuiParametersPresentFlag, false, "Enable generation of vui_parameters()")
690	("AspectRatioInfoPresent", m_aspectRatioInfoPresentFlag, false, "Signals whether aspect_ratio_idc is present")
691	("AspectRatioIdc", m_aspectRatioIdc, 0, "aspect_ratio_idc")
692	("SarWidth", m_sarWidth, 0, "horizontal size of the sample aspect ratio")
693	("SarHeight", m_sarHeight, 0, "vertical size of the sample aspect ratio")
694	("OverscanInfoPresent", m_overscanInfoPresentFlag, false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n")
695	("OverscanAppropriate", m_overscanAppropriateFlag, false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n")
696	("VideoSignalTypePresent", m_videoSignalTypePresentFlag, false, "Signals whether video_format, video_full_range_flag, and colour_description_present_flag are present")
697	("VideoFormat", m_videoFormat, 5, "Indicates representation of pictures")
698	("VideoFullRange", m_videoFullRangeFlag, false, "Indicates the black level and range of luma and chroma signals")
699	("ColourDescriptionPresent", m_colourDescriptionPresentFlag, false, "Signals whether colour_primaries, transfer_characteristics and matrix_coefficients are present")
700	("ColourPrimaries", m_colourPrimaries, 2, "Indicates chromaticity coordinates of the source primaries")
701	("TransferCharateristics", m_transferCharacteristics, 2, "Indicates the opto-electronic transfer characteristics of the source")
702	("MatrixCoefficients", m_matrixCoefficients, 2, "Describes the matrix coefficients used in deriving luma and chroma from RGB primaries")
703	("ChromaLocInfoPresent", m_chromaLocInfoPresentFlag, false, "Signals whether chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field are present")
704	("ChromaSampleLocTypeTopField", m_chromaSampleLocTypeTopField, 0, "Specifies the location of chroma samples for top field")
705	("ChromaSampleLocTypeBottomField", m_chromaSampleLocTypeBottomField, 0, "Specifies the location of chroma samples for bottom field")
706	("NeutralChromaIndication", m_neutralChromaIndicationFlag, false, "Indicates that the value of all decoded chroma samples is equal to 1<<(BitDepthCr-1)")
707	("DefaultDisplayWindowFlag", m_defaultDisplayWindowFlag, false, "Indicates the presence of the Default Window parameters")
708	("DefDispWinLeftOffset", m_defDispWinLeftOffset, 0, "Specifies the left offset of the default display window from the conformance window")
709	("DefDispWinRightOffset", m_defDispWinRightOffset, 0, "Specifies the right offset of the default display window from the conformance window")
710	("DefDispWinTopOffset", m_defDispWinTopOffset, 0, "Specifies the top offset of the default display window from the conformance window")
711	("DefDispWinBottomOffset", m_defDispWinBottomOffset, 0, "Specifies the bottom offset of the default display window from the conformance window")
712	("FrameFieldInfoPresentFlag", m_frameFieldInfoPresentFlag, false, "Indicates that pic_struct and field coding related values are present in picture timing SEI messages")
713	("PocProportionalToTimingFlag", m_pocProportionalToTimingFlag, false, "Indicates that the POC value is proportional to the output time w.r.t. first picture in CVS")
714	("NumTicksPocDiffOneMinus1", m_numTicksPocDiffOneMinus1, 0, "Number of ticks minus 1 that for a POC difference of one")
715	("BitstreamRestriction", m_bitstreamRestrictionFlag, false, "Signals whether bitstream restriction parameters are present")
716	("TilesFixedStructure", m_tilesFixedStructureFlag, false, "Indicates that each active picture parameter set has the same values of the syntax elements related to tiles")
717	("MotionVectorsOverPicBoundaries", m_motionVectorsOverPicBoundariesFlag, false, "Indicates that no samples outside the picture boundaries are used for inter prediction")
718	("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")
719	("MaxBitsPerMinCuDenom", m_maxBitsPerMinCuDenom, 1, "Indicates an upper bound for the number of bits of coding_unit() data")
720	("Log2MaxMvLengthHorizontal", m_log2MaxMvLengthHorizontal, 15, "Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units")
721	("Log2MaxMvLengthVertical", m_log2MaxMvLengthVertical, 15, "Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units")
722	("SEIRecoveryPoint", m_recoveryPointSEIEnabled, 0, "Control generation of recovery point SEI messages")
723	("SEIBufferingPeriod", m_bufferingPeriodSEIEnabled, 0, "Control generation of buffering period SEI messages")
724	("SEIPictureTiming", m_pictureTimingSEIEnabled, 0, "Control generation of picture timing SEI messages")
725	("SEIToneMappingInfo", m_toneMappingInfoSEIEnabled, false, "Control generation of Tone Mapping SEI messages")
726	("SEIToneMapId", m_toneMapId, 0, "Specifies Id of Tone Mapping SEI message for a given session")
727	("SEIToneMapCancelFlag", m_toneMapCancelFlag, false, "Indicates that Tone Mapping SEI message cancels the persistance or follows")
728	("SEIToneMapPersistenceFlag", m_toneMapPersistenceFlag, true, "Specifies the persistence of the Tone Mapping SEI message")
729	("SEIToneMapCodedDataBitDepth", m_toneMapCodedDataBitDepth, 8, "Specifies Coded Data BitDepth of Tone Mapping SEI messages")
730	("SEIToneMapTargetBitDepth", m_toneMapTargetBitDepth, 8, "Specifies Output BitDepth of Tome mapping function")
731	("SEIToneMapModelId", m_toneMapModelId, 0, "Specifies Model utilized for mapping coded data into target_bit_depth range\n"
732	"\t0: linear mapping with clipping\n"
733	"\t1: sigmoidal mapping\n"
734	"\t2: user-defined table mapping\n"
735	"\t3: piece-wise linear mapping\n"
736	"\t4: luminance dynamic range information ")
737	("SEIToneMapMinValue", m_toneMapMinValue, 0, "Specifies the minimum value in mode 0")
738	("SEIToneMapMaxValue", m_toneMapMaxValue, 1023, "Specifies the maxmum value in mode 0")
739	("SEIToneMapSigmoidMidpoint", m_sigmoidMidpoint, 512, "Specifies the centre point in mode 1")
740	("SEIToneMapSigmoidWidth", m_sigmoidWidth, 960, "Specifies the distance between 5% and 95% values of the target_bit_depth in mode 1")
741	("SEIToneMapStartOfCodedInterval", cfg_startOfCodedInterval, string(""), "Array of user-defined mapping table")
742	("SEIToneMapNumPivots", m_numPivots, 0, "Specifies the number of pivot points in mode 3")
743	("SEIToneMapCodedPivotValue", cfg_codedPivotValue, string(""), "Array of pivot point")
744	("SEIToneMapTargetPivotValue", cfg_targetPivotValue, string(""), "Array of pivot point")
745	("SEIToneMapCameraIsoSpeedIdc", m_cameraIsoSpeedIdc, 0, "Indicates the camera ISO speed for daylight illumination")
746	("SEIToneMapCameraIsoSpeedValue", m_cameraIsoSpeedValue, 400, "Specifies the camera ISO speed for daylight illumination of Extended_ISO")
747	("SEIToneMapExposureIndexIdc", m_exposureIndexIdc, 0, "Indicates the exposure index setting of the camera")
748	("SEIToneMapExposureIndexValue", m_exposureIndexValue, 400, "Specifies the exposure index setting of the cameran of Extended_ISO")
749	("SEIToneMapExposureCompensationValueSignFlag", m_exposureCompensationValueSignFlag, 0, "Specifies the sign of ExposureCompensationValue")
750	("SEIToneMapExposureCompensationValueNumerator", m_exposureCompensationValueNumerator, 0, "Specifies the numerator of ExposureCompensationValue")
751	("SEIToneMapExposureCompensationValueDenomIdc", m_exposureCompensationValueDenomIdc, 2, "Specifies the denominator of ExposureCompensationValue")
752	("SEIToneMapRefScreenLuminanceWhite", m_refScreenLuminanceWhite, 350, "Specifies reference screen brightness setting in units of candela per square metre")
753	("SEIToneMapExtendedRangeWhiteLevel", m_extendedRangeWhiteLevel, 800, "Indicates the luminance dynamic range")
754	("SEIToneMapNominalBlackLevelLumaCodeValue", m_nominalBlackLevelLumaCodeValue, 16, "Specifies luma sample value of the nominal black level assigned decoded pictures")
755	("SEIToneMapNominalWhiteLevelLumaCodeValue", m_nominalWhiteLevelLumaCodeValue, 235, "Specifies luma sample value of the nominal white level assigned decoded pictures")
756	("SEIToneMapExtendedWhiteLevelLumaCodeValue", m_extendedWhiteLevelLumaCodeValue, 300, "Specifies luma sample value of the extended dynamic range assigned decoded pictures")
757	("SEIFramePacking", m_framePackingSEIEnabled, 0, "Control generation of frame packing SEI messages")
758	("SEIFramePackingType", m_framePackingSEIType, 0, "Define frame packing arrangement\n"
759	"\t0: checkerboard - pixels alternatively represent either frames\n"
760	"\t1: column alternation - frames are interlaced by column\n"
761	"\t2: row alternation - frames are interlaced by row\n"
762	"\t3: side by side - frames are displayed horizontally\n"
763	"\t4: top bottom - frames are displayed vertically\n"
764	"\t5: frame alternation - one frame is alternated with the other")
765	("SEIFramePackingId", m_framePackingSEIId, 0, "Id of frame packing SEI message for a given session")
766	("SEIFramePackingQuincunx", m_framePackingSEIQuincunx, 0, "Indicate the presence of a Quincunx type video frame")
767	("SEIFramePackingInterpretation", m_framePackingSEIInterpretation, 0, "Indicate the interpretation of the frame pair\n"
768	"\t0: unspecified\n"
769	"\t1: stereo pair, frame0 represents left view\n"
770	"\t2: stereo pair, frame0 represents right view")
771	("SEIDisplayOrientation", m_displayOrientationSEIAngle, 0, "Control generation of display orientation SEI messages\n"
772	"\tN: 0 < N < (2^16 - 1) enable display orientation SEI message with anticlockwise_rotation = N and display_orientation_repetition_period = 1\n"
773	"\t0: disable")
774	("SEITemporalLevel0Index", m_temporalLevel0IndexSEIEnabled, 0, "Control generation of temporal level 0 index SEI messages")
775	("SEIGradualDecodingRefreshInfo", m_gradualDecodingRefreshInfoEnabled, 0, "Control generation of gradual decoding refresh information SEI message")
776	("SEIDecodingUnitInfo", m_decodingUnitInfoSEIEnabled, 0, "Control generation of decoding unit information SEI message.")
777	("SEISOPDescription", m_SOPDescriptionSEIEnabled, 0, "Control generation of SOP description SEI messages")
778	("SEIScalableNesting", m_scalableNestingSEIEnabled, 0, "Control generation of scalable nesting SEI messages")
779	#if H_MV
780	("SubBitstreamPropSEIEnabled", m_subBistreamPropSEIEnabled, false ,"Enable signaling of sub-bitstream property SEI message")
781	("SEISubBitstreamNumAdditionalSubStreams", m_sbPropNumAdditionalSubStreams,0, "Number of substreams for which additional information is signalled")
782	("SEISubBitstreamSubBitstreamMode", m_sbPropSubBitstreamMode, std::vector< Int >(1,0) ,"Specifies mode of generation of the i-th sub-bitstream (0 or 1)")
783	("SEISubBitstreamOutputLayerSetIdxToVps", m_sbPropOutputLayerSetIdxToVps, std::vector< Int >(1,0) ,"Specifies output layer set index of the i-th sub-bitstream ")
784	("SEISubBitstreamHighestSublayerId", m_sbPropHighestSublayerId, std::vector< Int >(1,0) ,"Specifies highest TemporalId of the i-th sub-bitstream")
785	("SEISubBitstreamAvgBitRate", m_sbPropAvgBitRate, std::vector< Int >(1,0) ,"Specifies average bit rate of the i-th sub-bitstream")
786	("SEISubBitstreamMaxBitRate", m_sbPropMaxBitRate, std::vector< Int >(1,0) ,"Specifies maximum bit rate of the i-th sub-bitstream")
787
788	#if H_MV_HLS10_GEN_FIX
789	("OutputVpsInfo", m_outputVpsInfo, false ,"Output information about the layer dependencies and layer sets")
790	#endif
791	#endif
792	#if H_3D
793	("CameraParameterFile,cpf", m_pchCameraParameterFile, (Char *) 0, "Camera Parameter File Name")
794	("BaseViewCameraNumbers" , m_pchBaseViewCameraNumbers, (Char *) 0, "Numbers of base views")
795	("CodedCamParsPrecision", m_iCodedCamParPrecision, STD_CAM_PARAMETERS_PRECISION, "precision for coding of camera parameters (in units of 2^(-x) luma samples)" )
796	/* View Synthesis Optimization */
797
798	#if H_3D_VSO
799	("VSOConfig", m_pchVSOConfig , (Char *) 0 , "VSO configuration")
800	("VSO", m_bUseVSO , false , "Use VSO" )
801	("VSOMode", m_uiVSOMode , (UInt) 4 , "VSO Mode")
802	("LambdaScaleVSO", m_dLambdaScaleVSO , (Double) 1 , "Lambda Scaling for VSO")
803	("VSOLSTable", m_bVSOLSTable , true , "Depth QP dependent video/depth rate allocation by Lagrange multiplier" )
804	("ForceLambdaScaleVSO", m_bForceLambdaScaleVSO , false , "Force using Lambda Scale VSO also in non-VSO-Mode")
805	("AllowNegDist", m_bAllowNegDist , true , "Allow negative Distortion in VSO")
806
807	("UseEstimatedVSD", m_bUseEstimatedVSD , true , "Model based VSD estimation instead of rendering based for some encoder decisions" )
808	("VSOEarlySkip", m_bVSOEarlySkip , true , "Early skip of VSO computation if synthesis error assumed to be zero" )
809
810	("WVSO", m_bUseWVSO , true , "Use depth fidelity term for VSO" )
811	("VSOWeight", m_iVSOWeight , 10 , "Synthesized View Distortion Change weight" )
812	("VSDWeight", m_iVSDWeight , 1 , "View Synthesis Distortion estimate weight" )
813	("DWeight", m_iDWeight , 1 , "Depth Distortion weight" )
814
815	#endif //HHI_VSO
816	#if MTK_I0099_VPS_EX2
817	("LimQtPredFlag", m_bLimQtPredFlag , true , "Use Predictive Coding with QTL" )
818	#endif
819	#if !MTK_I0099_VPS_EX2 \|\| MTK_I0099_FIX
820	#if H_3D_QTLPC
821	("QTL", m_bUseQTL , true , "Use depth Quadtree Limitation" )
822	#if !MTK_I0099_VPS_EX2
823	("PC", m_bUsePC , true , "Use Predictive Coding with QTL" )
824	#endif
825	#endif
826	#endif
827	#if H_3D_IV_MERGE
828	("IvMvPred", m_ivMvPredFlag , std::vector<Bool>(2, true) , "inter view motion prediction " )
829	#endif
830	#if H_3D_NBDV_REF
831	("DepthRefinement", m_depthRefinementFlag, true , "depth refinement by DoNBDV" )
832	#endif
833	#if H_3D_VSP
834	("ViewSynthesisPred", m_viewSynthesisPredFlag, true , "view synthesis prediction " )
835	#endif
836	#if H_3D
837	("IvMvScaling", m_ivMvScalingFlag , true , "inter view motion vector scaling" )
838	#endif
839	#endif //H_3D
840	;
841
842	#if H_MV
843	// parse coding structure
844	for( Int k = 0; k < MAX_NUM_LAYERS; k++ )
845	{
846	m_GOPListMvc.push_back( new GOPEntry[MAX_GOP + 1] );
847	if( k == 0 )
848	{
849	m_GOPListMvc[0][0].m_sliceType = 'I';
850	for( Int i = 1; i < MAX_GOP + 1; i++ )
851	{
852	std::ostringstream cOSS;
853	cOSS<<"Frame"<<i;
854	opts.addOptions()( cOSS.str(), m_GOPListMvc[k][i-1], GOPEntry() );
855	if ( i != 1 )
856	{
857	opts.opt_list.back()->opt->opt_duplicate = true;
858	}
859	}
860	}
861	else
862	{
863	std::ostringstream cOSS1;
864	cOSS1<<"FrameI"<<"_l"<<k;
865
866	opts.addOptions()(cOSS1.str(), m_GOPListMvc[k][MAX_GOP], GOPEntry());
867	if ( k > 1 )
868	{
869	opts.opt_list.back()->opt->opt_duplicate = true;
870	}
871
872
873	for( Int i = 1; i < MAX_GOP + 1; i++ )
874	{
875	std::ostringstream cOSS2;
876	cOSS2<<"Frame"<<i<<"_l"<<k;
877	opts.addOptions()(cOSS2.str(), m_GOPListMvc[k][i-1], GOPEntry());
878	if ( i != 1 \|\| k > 0 )
879	{
880	opts.opt_list.back()->opt->opt_duplicate = true;
881	}
882	}
883	}
884	}
885	#else
886	for(Int i=1; i<MAX_GOP+1; i++) {
887	std::ostringstream cOSS;
888	cOSS<<"Frame"<<i;
889	opts.addOptions()(cOSS.str(), m_GOPList[i-1], GOPEntry());
890	}
891	#endif
892	po::setDefaults(opts);
893	const list<const Char>& argv_unhandled = po::scanArgv(opts, argc, (const Char*) argv);
894
895	if(m_isField)
896	{
897	//Frame height
898	m_iSourceHeightOrg = m_iSourceHeight;
899	//Field height
900	m_iSourceHeight = m_iSourceHeight >> 1;
901	//number of fields to encode
902	m_framesToBeEncoded *= 2;
903	}
904
905	for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
906	{
907	fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
908	}
909
910	if (argc == 1 \|\| do_help)
911	{
912	/* argc == 1: no options have been specified */
913	po::doHelp(cout, opts);
914	return false;
915	}
916
917	/*
918	* Set any derived parameters
919	*/
920	/* convert std::string to c string for compatability */
921	#if !H_MV
922	m_pchInputFile = cfg_InputFile.empty() ? NULL : strdup(cfg_InputFile.c_str());
923	#endif
924	m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
925	#if !H_MV
926	m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str());
927	#endif
928	m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());
929
930	Char* pColumnWidth = cfg_ColumnWidth.empty() ? NULL: strdup(cfg_ColumnWidth.c_str());
931	Char* pRowHeight = cfg_RowHeight.empty() ? NULL : strdup(cfg_RowHeight.c_str());
932	if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
933	{
934	char *columnWidth;
935	int i=0;
936	m_pColumnWidth = new UInt[m_iNumColumnsMinus1];
937	columnWidth = strtok(pColumnWidth, " ,-");
938	while(columnWidth!=NULL)
939	{
940	if( i>=m_iNumColumnsMinus1 )
941	{
942	printf( "The number of columns whose width are defined is larger than the allowed number of columns.\n" );
943	exit( EXIT_FAILURE );
944	}
945	*( m_pColumnWidth + i ) = atoi( columnWidth );
946	columnWidth = strtok(NULL, " ,-");
947	i++;
948	}
949	if( i<m_iNumColumnsMinus1 )
950	{
951	printf( "The width of some columns is not defined.\n" );
952	exit( EXIT_FAILURE );
953	}
954	}
955	else
956	{
957	m_pColumnWidth = NULL;
958	}
959
960	if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
961	{
962	char *rowHeight;
963	int i=0;
964	m_pRowHeight = new UInt[m_iNumRowsMinus1];
965	rowHeight = strtok(pRowHeight, " ,-");
966	while(rowHeight!=NULL)
967	{
968	if( i>=m_iNumRowsMinus1 )
969	{
970	printf( "The number of rows whose height are defined is larger than the allowed number of rows.\n" );
971	exit( EXIT_FAILURE );
972	}
973	*( m_pRowHeight + i ) = atoi( rowHeight );
974	rowHeight = strtok(NULL, " ,-");
975	i++;
976	}
977	if( i<m_iNumRowsMinus1 )
978	{
979	printf( "The height of some rows is not defined.\n" );
980	exit( EXIT_FAILURE );
981	}
982	}
983	else
984	{
985	m_pRowHeight = NULL;
986	}
987	#if H_MV
988	free ( pColumnWidth );
989	free ( pRowHeight );
990	#endif
991	m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str());
992
993	/* rules for input, output and internal bitdepths as per help text */
994	if (!m_internalBitDepthY) { m_internalBitDepthY = m_inputBitDepthY; }
995	if (!m_internalBitDepthC) { m_internalBitDepthC = m_internalBitDepthY; }
996	if (!m_inputBitDepthC) { m_inputBitDepthC = m_inputBitDepthY; }
997	if (!m_outputBitDepthY) { m_outputBitDepthY = m_internalBitDepthY; }
998	if (!m_outputBitDepthC) { m_outputBitDepthC = m_internalBitDepthC; }
999
1000	// TODO:ChromaFmt assumes 4:2:0 below
1001	switch (m_conformanceMode)
1002	{
1003	case 0:
1004	{
1005	// no conformance or padding
1006	m_confLeft = m_confRight = m_confTop = m_confBottom = 0;
1007	m_aiPad[1] = m_aiPad[0] = 0;
1008	break;
1009	}
1010	case 1:
1011	{
1012	// automatic padding to minimum CU size
1013	Int minCuSize = m_uiMaxCUHeight >> (m_uiMaxCUDepth - 1);
1014	if (m_iSourceWidth % minCuSize)
1015	{
1016	m_aiPad[0] = m_confRight = ((m_iSourceWidth / minCuSize) + 1) * minCuSize - m_iSourceWidth;
1017	m_iSourceWidth += m_confRight;
1018	}
1019	if (m_iSourceHeight % minCuSize)
1020	{
1021	m_aiPad[1] = m_confBottom = ((m_iSourceHeight / minCuSize) + 1) * minCuSize - m_iSourceHeight;
1022	m_iSourceHeight += m_confBottom;
1023	if ( m_isField )
1024	{
1025	m_iSourceHeightOrg += m_confBottom << 1;
1026	m_aiPad[1] = m_confBottom << 1;
1027	}
1028	}
1029	if (m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0)
1030	{
1031	fprintf(stderr, "Error: picture width is not an integer multiple of the specified chroma subsampling\n");
1032	exit(EXIT_FAILURE);
1033	}
1034	if (m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0)
1035	{
1036	fprintf(stderr, "Error: picture height is not an integer multiple of the specified chroma subsampling\n");
1037	exit(EXIT_FAILURE);
1038	}
1039	break;
1040	}
1041	case 2:
1042	{
1043	//padding
1044	m_iSourceWidth += m_aiPad[0];
1045	m_iSourceHeight += m_aiPad[1];
1046	m_confRight = m_aiPad[0];
1047	m_confBottom = m_aiPad[1];
1048	break;
1049	}
1050	case 3:
1051	{
1052	// conformance
1053	if ((m_confLeft == 0) && (m_confRight == 0) && (m_confTop == 0) && (m_confBottom == 0))
1054	{
1055	fprintf(stderr, "Warning: Conformance window enabled, but all conformance window parameters set to zero\n");
1056	}
1057	if ((m_aiPad[1] != 0) \|\| (m_aiPad[0]!=0))
1058	{
1059	fprintf(stderr, "Warning: Conformance window enabled, padding parameters will be ignored\n");
1060	}
1061	m_aiPad[1] = m_aiPad[0] = 0;
1062	break;
1063	}
1064	}
1065
1066	// allocate slice-based dQP values
1067	#if H_MV
1068	xResizeVector( m_viewOrderIndex );
1069
1070	std::vector<Int> uniqueViewOrderIndices;
1071	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1072	{
1073	Bool isIn = false;
1074	for ( Int i = 0 ; i < uniqueViewOrderIndices.size(); i++ )
1075	{
1076	isIn = isIn \|\| ( m_viewOrderIndex[ layer ] == uniqueViewOrderIndices[ i ] );
1077	}
1078	if ( !isIn )
1079	{
1080	uniqueViewOrderIndices.push_back( m_viewOrderIndex[ layer ] );
1081	}
1082	}
1083	m_iNumberOfViews = (Int) uniqueViewOrderIndices.size();
1084	#if H_MV_HLS10_AUX
1085	xResizeVector( m_auxId );
1086	#endif
1087
1088	#if H_3D
1089	xResizeVector( m_depthFlag );
1090	#endif
1091	xResizeVector( m_fQP );
1092
1093	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1094	{
1095	m_aidQP.push_back( new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ] );
1096	::memset( m_aidQP[layer], 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
1097
1098	// handling of floating-point QP values
1099	// if QP is not integer, sequence is split into two sections having QP and QP+1
1100	m_iQP.push_back((Int)( m_fQP[layer] ));
1101	if ( m_iQP[layer] < m_fQP[layer] )
1102	{
1103	Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP[layer] - m_iQP[layer])*m_framesToBeEncoded + 0.5 );
1104
1105	iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
1106	for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
1107	{
1108	m_aidQP[layer][i] = 1;
1109	}
1110	}
1111	}
1112
1113	xResizeVector( m_bLoopFilterDisable );
1114	xResizeVector( m_bUseSAO );
1115	xResizeVector( m_iIntraPeriod );
1116	xResizeVector( m_tilesInUseFlag );
1117	xResizeVector( m_loopFilterNotAcrossTilesFlag );
1118	xResizeVector( m_wppInUseFlag );
1119
1120	#if H_MV_HLS10_ADD_LAYERSETS
1121	for (Int olsIdx = 0; olsIdx < m_vpsNumLayerSets + m_numAddLayerSets + (Int) m_outputLayerSetIdx.size(); olsIdx++)
1122	#else
1123	for (Int olsIdx = 0; olsIdx < m_vpsNumLayerSets + (Int) m_outputLayerSetIdx.size(); olsIdx++)
1124	#endif
1125	{
1126	m_altOutputLayerFlag.push_back( false );
1127	}
1128	#else
1129	m_aidQP = new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ];
1130	::memset( m_aidQP, 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
1131
1132	// handling of floating-point QP values
1133	// if QP is not integer, sequence is split into two sections having QP and QP+1
1134	m_iQP = (Int)( m_fQP );
1135	if ( m_iQP < m_fQP )
1136	{
1137	Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP - m_iQP)*m_framesToBeEncoded + 0.5 );
1138
1139	iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
1140	for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
1141	{
1142	m_aidQP[i] = 1;
1143	}
1144	}
1145	#endif
1146
1147	// reading external dQP description from file
1148	if ( m_pchdQPFile )
1149	{
1150	FILE* fpt=fopen( m_pchdQPFile, "r" );
1151	if ( fpt )
1152	{
1153	#if H_MV
1154	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1155	{
1156	#endif
1157	Int iValue;
1158	Int iPOC = 0;
1159	while ( iPOC < m_framesToBeEncoded )
1160	{
1161	if ( fscanf(fpt, "%d", &iValue ) == EOF ) break;
1162	#if H_MV
1163	m_aidQP[layer][ iPOC ] = iValue;
1164	iPOC++;
1165	}
1166	#else
1167	m_aidQP[ iPOC ] = iValue;
1168	iPOC++;
1169	#endif
1170	}
1171	fclose(fpt);
1172	}
1173	}
1174	m_iWaveFrontSubstreams = m_iWaveFrontSynchro ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1;
1175
1176	if( m_toneMappingInfoSEIEnabled && !m_toneMapCancelFlag )
1177	{
1178	Char* pcStartOfCodedInterval = cfg_startOfCodedInterval.empty() ? NULL: strdup(cfg_startOfCodedInterval.c_str());
1179	Char* pcCodedPivotValue = cfg_codedPivotValue.empty() ? NULL: strdup(cfg_codedPivotValue.c_str());
1180	Char* pcTargetPivotValue = cfg_targetPivotValue.empty() ? NULL: strdup(cfg_targetPivotValue.c_str());
1181	if( m_toneMapModelId == 2 && pcStartOfCodedInterval )
1182	{
1183	char *startOfCodedInterval;
1184	UInt num = 1u<< m_toneMapTargetBitDepth;
1185	m_startOfCodedInterval = new Int[num];
1186	::memset( m_startOfCodedInterval, 0, sizeof(Int)*num );
1187	startOfCodedInterval = strtok(pcStartOfCodedInterval, " .");
1188	int i = 0;
1189	while( startOfCodedInterval && ( i < num ) )
1190	{
1191	m_startOfCodedInterval[i] = atoi( startOfCodedInterval );
1192	startOfCodedInterval = strtok(NULL, " .");
1193	i++;
1194	}
1195	}
1196	else
1197	{
1198	m_startOfCodedInterval = NULL;
1199	}
1200	if( ( m_toneMapModelId == 3 ) && ( m_numPivots > 0 ) )
1201	{
1202	if( pcCodedPivotValue && pcTargetPivotValue )
1203	{
1204	char *codedPivotValue;
1205	char *targetPivotValue;
1206	m_codedPivotValue = new Int[m_numPivots];
1207	m_targetPivotValue = new Int[m_numPivots];
1208	::memset( m_codedPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1209	::memset( m_targetPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1210	codedPivotValue = strtok(pcCodedPivotValue, " .");
1211	int i=0;
1212	while(codedPivotValue&&i<m_numPivots)
1213	{
1214	m_codedPivotValue[i] = atoi( codedPivotValue );
1215	codedPivotValue = strtok(NULL, " .");
1216	i++;
1217	}
1218	i=0;
1219	targetPivotValue = strtok(pcTargetPivotValue, " .");
1220	while(targetPivotValue&&i<m_numPivots)
1221	{
1222	m_targetPivotValue[i]= atoi( targetPivotValue );
1223	targetPivotValue = strtok(NULL, " .");
1224	i++;
1225	}
1226	}
1227	}
1228	else
1229	{
1230	m_codedPivotValue = NULL;
1231	m_targetPivotValue = NULL;
1232	}
1233	}
1234
1235	#if H_MV
1236	#if H_MV_HLS10_PTL
1237	// parse PTL
1238	Bool anyEmpty = false;
1239	if( cfg_profiles.empty() )
1240	{
1241	#if H_3D
1242	cfg_profiles = string("main main 3d-main");
1243	#else
1244	cfg_profiles = string("main main multiview-main");
1245	#endif
1246	fprintf(stderr, "\nWarning: No profiles given, using defaults: %s", cfg_profiles.c_str() );
1247	anyEmpty = true;
1248	}
1249
1250	if( cfg_levels.empty() )
1251	{
1252	cfg_levels = string("none none none");
1253	fprintf(stderr, "\nWarning: No levels given, using defaults: %s", cfg_levels.c_str() );
1254	anyEmpty = true;
1255	}
1256
1257	if( cfg_tiers.empty() )
1258	{
1259	cfg_tiers = string("main main main");
1260	fprintf(stderr, "\nWarning: No tiers given, using defaults: %s", cfg_tiers.c_str());
1261	anyEmpty = true;
1262	}
1263
1264	if( m_inblFlag.empty() )
1265	{
1266	fprintf(stderr, "\nWarning: No inblFlags given, using defaults:");
1267	for( Int i = 0; i < 3; i++)
1268	{
1269	m_inblFlag.push_back( false );
1270	fprintf(stderr," %d", (Int) m_inblFlag[i]);
1271	}
1272	anyEmpty = true;
1273	}
1274
1275	if ( anyEmpty )
1276	{
1277	fprintf( stderr, "\n" );
1278	}
1279
1280	xReadStrToEnum( cfg_profiles, m_profile );
1281	xReadStrToEnum( cfg_levels, m_level );
1282	xReadStrToEnum( cfg_tiers , m_levelTier );
1283	#endif
1284	#endif
1285	#if H_3D
1286	// set global varibles
1287	xSetGlobal();
1288	#if H_3D_VSO
1289	// Table base optimization
1290	// Q&D
1291	Double adLambdaScaleTable[] =
1292	{ 0.031250, 0.031639, 0.032029, 0.032418, 0.032808, 0.033197, 0.033586, 0.033976, 0.034365, 0.034755,
1293	0.035144, 0.035533, 0.035923, 0.036312, 0.036702, 0.037091, 0.037480, 0.037870, 0.038259, 0.038648,
1294	0.039038, 0.039427, 0.039817, 0.040206, 0.040595, 0.040985, 0.041374, 0.041764, 0.042153, 0.042542,
1295	0.042932, 0.043321, 0.043711, 0.044100, 0.044194, 0.053033, 0.061872, 0.070711, 0.079550, 0.088388,
1296	0.117851, 0.147314, 0.176777, 0.235702, 0.294628, 0.353553, 0.471405, 0.589256, 0.707107, 0.707100,
1297	0.753550, 0.800000
1298	};
1299	if ( m_bUseVSO && m_bVSOLSTable )
1300	{
1301	Int firstDepthLayer = -1;
1302	for (Int layer = 0; layer < m_numberOfLayers; layer++ )
1303	{
1304	if ( m_depthFlag[ layer ])
1305	{
1306	firstDepthLayer = layer;
1307	break;
1308	}
1309	}
1310	AOT( firstDepthLayer == -1 );
1311	AOT( (m_iQP[firstDepthLayer] < 0) \|\| (m_iQP[firstDepthLayer] > 51));
1312	m_dLambdaScaleVSO *= adLambdaScaleTable[m_iQP[firstDepthLayer]];
1313	}
1314	#endif
1315	#if H_3D_VSO
1316	if ( m_bUseVSO && m_uiVSOMode == 4)
1317	{
1318	m_cRenModStrParser.setString( m_iNumberOfViews, m_pchVSOConfig );
1319	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1320	g_bitDepthY,
1321	(UInt)m_iCodedCamParPrecision,
1322	m_FrameSkip,
1323	(UInt)m_framesToBeEncoded,
1324	m_pchCameraParameterFile,
1325	m_pchBaseViewCameraNumbers,
1326	NULL,
1327	m_cRenModStrParser.getSynthViews(),
1328	LOG2_DISP_PREC_LUT );
1329	}
1330	else if ( m_bUseVSO && m_uiVSOMode != 4 )
1331	{
1332	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1333	g_bitDepthY,
1334	(UInt)m_iCodedCamParPrecision,
1335	m_FrameSkip,
1336	(UInt)m_framesToBeEncoded,
1337	m_pchCameraParameterFile,
1338	m_pchBaseViewCameraNumbers,
1339	m_pchVSOConfig,
1340	NULL,
1341	LOG2_DISP_PREC_LUT );
1342	}
1343	else
1344	{
1345	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1346	g_bitDepthY,
1347	(UInt) m_iCodedCamParPrecision,
1348	m_FrameSkip,
1349	(UInt) m_framesToBeEncoded,
1350	m_pchCameraParameterFile,
1351	m_pchBaseViewCameraNumbers,
1352	NULL,
1353	NULL,
1354	LOG2_DISP_PREC_LUT );
1355	}
1356	#else
1357	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1358	g_bitDepthY,
1359	(UInt) m_iCodedCamParPrecision,
1360	m_FrameSkip,
1361	(UInt) m_framesToBeEncoded,
1362	m_pchCameraParameterFile,
1363	m_pchBaseViewCameraNumbers,
1364	NULL,
1365	NULL,
1366	LOG2_DISP_PREC_LUT );
1367	#endif
1368	m_cCameraData.check( false, true );
1369	#endif
1370	// check validity of input parameters
1371	xCheckParameter();
1372
1373	#if !H_3D
1374	// set global varibles
1375	xSetGlobal();
1376	#endif
1377
1378	// print-out parameters
1379	xPrintParameter();
1380
1381	return true;
1382	}
1383	// ====================================================================================================================
1384	// Private member functions
1385	// ====================================================================================================================
1386
1387	Bool confirmPara(Bool bflag, const Char* message);
1388
1389	Void TAppEncCfg::xCheckParameter()
1390	{
1391	if (!m_decodedPictureHashSEIEnabled)
1392	{
1393	fprintf(stderr, "******************************************************************\n");
1394	fprintf(stderr, " WARNING: --SEIDecodedPictureHash is now disabled by default. \n");
1395	fprintf(stderr, " Automatic verification of decoded pictures by a \n");
1396	fprintf(stderr, " decoder requires this option to be enabled. \n");
1397	fprintf(stderr, "******************************************************************\n");
1398	}
1399
1400
1401	#if !H_MV_HLS10_PTL
1402	if( m_profile==Profile::NONE )
1403	{
1404	fprintf(stderr, "***************************************************************************\n");
1405	fprintf(stderr, " WARNING: For conforming bitstreams a valid Profile value must be set! \n");
1406	fprintf(stderr, "***************************************************************************\n");
1407	}
1408	if( m_level==Level::NONE )
1409	{
1410	fprintf(stderr, "***************************************************************************\n");
1411	fprintf(stderr, " WARNING: For conforming bitstreams a valid Level value must be set! \n");
1412	fprintf(stderr, "***************************************************************************\n");
1413	}
1414	#endif
1415
1416	Bool check_failed = false; /* abort if there is a fatal configuration problem */
1417	#define xConfirmPara(a,b) check_failed \|= confirmPara(a,b)
1418	// check range of parameters
1419	xConfirmPara( m_inputBitDepthY < 8, "InputBitDepth must be at least 8" );
1420	xConfirmPara( m_inputBitDepthC < 8, "InputBitDepthC must be at least 8" );
1421	xConfirmPara( m_iFrameRate <= 0, "Frame rate must be more than 1" );
1422	xConfirmPara( m_framesToBeEncoded <= 0, "Total Number Of Frames encoded must be more than 0" );
1423	#if H_MV
1424	xConfirmPara( m_numberOfLayers > MAX_NUM_LAYER_IDS , "NumberOfLayers must be less than or equal to MAX_NUM_LAYER_IDS");
1425
1426
1427	xConfirmPara( m_layerIdInNuh[0] != 0 , "LayerIdInNuh must be 0 for the first layer. ");
1428	xConfirmPara( (m_layerIdInNuh.size()!=1) && (m_layerIdInNuh.size() < m_numberOfLayers) , "LayerIdInNuh must be given for all layers. ");
1429
1430	#if H_3D
1431	xConfirmPara( m_scalabilityMask != 2 && m_scalabilityMask != 3, "Scalability Mask must be equal to 2 or 3. ");
1432	#else
1433	#if H_MV_HLS10_AUX
1434	xConfirmPara( m_scalabilityMask != 2 && m_scalabilityMask != 8 && m_scalabilityMask != 10, "Scalability Mask must be equal to 2, 8 or 10");
1435	#else
1436	xConfirmPara( m_scalabilityMask != 2 , "Scalability Mask must be equal to 2. ");
1437	#endif
1438	#endif
1439
1440	#if H_3D
1441	if ( m_scalabilityMask & ( 1 << DEPTH_ID ) )
1442	{
1443	m_dimIds.push_back( m_depthFlag );
1444	}
1445	#endif
1446
1447	m_dimIds.push_back( m_viewOrderIndex );
1448	#if H_MV_HLS10_AUX
1449	for (Int i = 0; i < m_auxId.size(); i++)
1450	{
1451	xConfirmPara( !( ( m_auxId[i] >= 0 && m_auxId[i] <= 2 ) \|\| ( m_auxId[i] >= 128 && m_auxId[i] <= 159 ) ) , "AuxId shall be in the range of 0 to 2, inclusive, or 128 to 159, inclusive");
1452	}
1453	if ( m_scalabilityMask & ( 1 << AUX_ID ) )
1454	{
1455	m_dimIds.push_back ( m_auxId );
1456	}
1457	#endif
1458	xConfirmPara( m_dimensionIdLen.size() < m_dimIds.size(), "DimensionIdLen must be given for all dimensions. " );
1459	Int dimBitOffset[MAX_NUM_SCALABILITY_TYPES+1];
1460
1461	dimBitOffset[ 0 ] = 0;
1462	for (Int j = 1; j <= ((Int) m_dimIds.size() - m_splittingFlag ? 1 : 0); j++ )
1463	{
1464	dimBitOffset[ j ] = dimBitOffset[ j - 1 ] + m_dimensionIdLen[ j - 1];
1465	}
1466
1467	if ( m_splittingFlag )
1468	{
1469	dimBitOffset[ (Int) m_dimIds.size() ] = 6;
1470	}
1471
1472	for( Int j = 0; j < m_dimIds.size(); j++ )
1473	{
1474	xConfirmPara( m_dimIds[j].size() < m_numberOfLayers, "DimensionId must be given for all layers and all dimensions. ");
1475	xConfirmPara( (m_dimIds[j][0] != 0) , "DimensionId of layer 0 must be 0. " );
1476	xConfirmPara( m_dimensionIdLen[j] < 1 \|\| m_dimensionIdLen[j] > 8, "DimensionIdLen must be greater than 0 and less than 9 in all dimensions. " );
1477
1478
1479	for( Int i = 1; i < m_numberOfLayers; i++ )
1480	{
1481	xConfirmPara( ( m_dimIds[j][i] < 0 ) \|\| ( m_dimIds[j][i] > ( ( 1 << m_dimensionIdLen[j] ) - 1 ) ) , "DimensionId shall be in the range of 0 to 2^DimensionIdLen - 1. " );
1482	if ( m_splittingFlag )
1483	{
1484	Int layerIdInNuh = (m_layerIdInNuh.size()!=1) ? m_layerIdInNuh[i] : i;
1485	xConfirmPara( ( ( layerIdInNuh & ( (1 << dimBitOffset[ j + 1 ] ) - 1) ) >> dimBitOffset[ j ] ) != m_dimIds[j][ i ] , "When Splitting Flag is equal to 1 dimension ids shall match values derived from layer ids. ");
1486	}
1487	}
1488	}
1489
1490	for( Int i = 0; i < m_numberOfLayers; i++ )
1491	{
1492	for( Int j = 0; j < i; j++ )
1493	{
1494	Int numDiff = 0;
1495	Int lastDiff = -1;
1496	for( Int dim = 0; dim < m_dimIds.size(); dim++ )
1497	{
1498	if ( m_dimIds[dim][i] != m_dimIds[dim][j] )
1499	{
1500	numDiff ++;
1501	lastDiff = dim;
1502	}
1503	}
1504
1505	Bool allEqual = ( numDiff == 0 );
1506
1507	if ( allEqual )
1508	{
1509	printf( "\nError: Positions of Layers %d and %d are identical in scalability space\n", i, j);
1510	}
1511
1512	xConfirmPara( allEqual , "Each layer shall have a different position in scalability space." );
1513
1514	#if !H_3D_FCO
1515	if ( numDiff == 1 )
1516	{
1517	Bool inc = m_dimIds[ lastDiff ][ i ] > m_dimIds[ lastDiff ][ j ];
1518	Bool shallBeButIsNotIncreasing = ( !inc ) ;
1519	if ( shallBeButIsNotIncreasing )
1520	{
1521	printf( "\nError: Positions of Layers %d and %d is not increasing in dimension %d \n", i, j, lastDiff);
1522	}
1523	xConfirmPara( shallBeButIsNotIncreasing, "DimensionIds shall be increasing within one dimension. " );
1524	}
1525	#endif
1526	}
1527	}
1528
1529	/// ViewId
1530	xConfirmPara( m_viewId.size() != m_iNumberOfViews, "The number of ViewIds must be equal to the number of views." );
1531
1532	/// Layer sets
1533	xConfirmPara( m_vpsNumLayerSets < 0 \|\| m_vpsNumLayerSets > 1024, "VpsNumLayerSets must be greater than 0 and less than 1025. ") ;
1534	for( Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++ )
1535	{
1536	if (lsIdx == 0)
1537	{
1538	xConfirmPara( m_layerIdsInSets[lsIdx].size() != 1 \|\| m_layerIdsInSets[lsIdx][0] != 0 , "0-th layer shall only include layer 0. ");
1539	}
1540	for ( Int i = 0; i < m_layerIdsInSets[lsIdx].size(); i++ )
1541	{
1542	#if FIX_TICKET_61
1543	xConfirmPara( m_layerIdsInSets[lsIdx][i] < 0 \|\| m_layerIdsInSets[lsIdx][i] >= MAX_NUM_LAYER_IDS, "LayerIdsInSet must be greater than 0 and less than MAX_NUM_LAYER_IDS" );
1544	#else
1545	xConfirmPara( m_layerIdsInSets[lsIdx][i] < 0 \|\| m_layerIdsInSets[lsIdx].size() >= MAX_NUM_LAYER_IDS, "LayerIdsInSet must be greater than and less than MAX_NUM_LAYER_IDS" );
1546	#endif
1547	}
1548	}
1549
1550	// Output layer sets
1551	xConfirmPara( m_outputLayerSetIdx.size() > 1024, "The number of output layer set indices must be less than 1025.") ;
1552	for (Int lsIdx = 0; lsIdx < m_outputLayerSetIdx.size(); lsIdx++)
1553	{
1554	Int refLayerSetIdx = m_outputLayerSetIdx[ lsIdx ];
1555	#if H_MV_HLS10_ADD_LAYERSETS
1556	xConfirmPara( refLayerSetIdx < 0 \|\| refLayerSetIdx >= m_vpsNumLayerSets + m_numAddLayerSets, "Output layer set idx must be greater or equal to 0 and less than the VpsNumLayerSets plus NumAddLayerSets." );
1557	#else
1558	xConfirmPara( refLayerSetIdx < 0 \|\| refLayerSetIdx >= m_vpsNumLayerSets, "Output layer set idx must be greater or equal to 0 and less than the VpsNumLayerSets." );
1559	#endif
1560	#if !H_MV_HLS10_ADD_LAYERSETS
1561	for (Int i = 0; i < m_layerIdsInAddOutputLayerSet[ lsIdx ].size(); i++)
1562	{
1563	Bool isAlsoInLayerSet = false;
1564	for (Int j = 0; j < m_layerIdsInSets[ refLayerSetIdx ].size(); j++ )
1565	{
1566	if ( m_layerIdsInSets[ refLayerSetIdx ][ j ] == m_layerIdsInAddOutputLayerSet[ lsIdx ][ i ] )
1567	{
1568	isAlsoInLayerSet = true;
1569	break;
1570	}
1571	}
1572	xConfirmPara( !isAlsoInLayerSet, "All output layers of a output layer set be included in corresponding layer set.");
1573	}
1574	#endif
1575	}
1576
1577	xConfirmPara( m_defaultOutputLayerIdc < 0 \|\| m_defaultOutputLayerIdc > 2, "Default target output layer idc must greater than or equal to 0 and less than or equal to 2." );
1578
1579	if( m_defaultOutputLayerIdc != 2 )
1580	{
1581	Bool anyDefaultOutputFlag = false;
1582	for (Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++)
1583	{
1584	anyDefaultOutputFlag = anyDefaultOutputFlag \|\| ( m_layerIdsInDefOutputLayerSet[lsIdx].size() != 0 );
1585	}
1586	#if H_MV_HLS10_ADD_LAYERSETS
1587	if ( anyDefaultOutputFlag )
1588	{
1589	printf( "\nWarning: Ignoring LayerIdsInDefOutputLayerSet parameters, since defaultTargetOuputLayerIdc is not equal 2.\n" );
1590	}
1591	#else
1592	printf( "\nWarning: Ignoring LayerIdsInDefOutputLayerSet parameters, since defaultTargetOuputLayerIdc is not equal 2.\n" );
1593	#endif
1594	}
1595	else
1596	{
1597	for (Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++)
1598	{
1599	for (Int i = 0; i < m_layerIdsInDefOutputLayerSet[ lsIdx ].size(); i++)
1600	{
1601	Bool inLayerSetFlag = false;
1602	for (Int j = 0; j < m_layerIdsInSets[ lsIdx].size(); j++ )
1603	{
1604	if ( m_layerIdsInSets[ lsIdx ][ j ] == m_layerIdsInDefOutputLayerSet[ lsIdx ][ i ] )
1605	{
1606	inLayerSetFlag = true;
1607	break;
1608	}
1609	}
1610	xConfirmPara( !inLayerSetFlag, "All output layers of a output layer set must be included in corresponding layer set.");
1611	}
1612	}
1613	}
1614
1615	#if H_MV_HLS10_ADD_LAYERSETS
1616	xConfirmPara( m_altOutputLayerFlag.size() < m_vpsNumLayerSets + m_numAddLayerSets + m_outputLayerSetIdx.size(), "The number of alt output layer flags must be equal to the number of layer set additional output layer sets plus the number of output layer set indices" );
1617	#else
1618	xConfirmPara( m_altOutputLayerFlag.size() < m_vpsNumLayerSets + m_outputLayerSetIdx.size(), "The number of Profile Level Tier indices must be equal to the number of layer set plus the number of output layer set indices" );
1619	#endif
1620
1621	// PTL
1622	#if H_MV_HLS10_PTL
1623	xConfirmPara( ( m_profile.size() != m_inblFlag.size() \|\| m_profile.size() != m_level.size() \|\| m_profile.size() != m_levelTier.size() ), "The number of Profiles, Levels, Tiers and InblFlags must be equal." );
1624
1625	if ( m_numberOfLayers > 1)
1626	{
1627	xConfirmPara( m_profile.size() <= 1, "The number of profiles, tiers, levels, and inblFlags must be greater than 1.");
1628	xConfirmPara( m_inblFlag[0], "VpsProfileTierLevel[0] must have inblFlag equal to 0");
1629	if (m_profile.size() > 1 )
1630	{
1631	xConfirmPara( m_profile[0] != m_profile[1], "The profile in VpsProfileTierLevel[1] must be equal to the profile in VpsProfileTierLevel[0].");
1632	xConfirmPara( m_inblFlag[0] != m_inblFlag[1], "inblFlag in VpsProfileTierLevel[1] must be equal to the inblFlag in VpsProfileTierLevel[0].");
1633	}
1634	}
1635	#else
1636	xConfirmPara( m_profileLevelTierIdx.size() < m_vpsNumLayerSets + m_outputLayerSetIdx.size(), "The number of Profile Level Tier indices must be equal to the number of layer set plus the number of output layer set indices" );
1637	#endif
1638
1639	// Layer Dependencies
1640	for (Int i = 0; i < m_numberOfLayers; i++ )
1641	{
1642	xConfirmPara( (i == 0) && m_directRefLayers[0].size() != 0, "Layer 0 shall not have reference layers." );
1643	xConfirmPara( m_directRefLayers[i].size() != m_dependencyTypes[ i ].size(), "Each reference layer shall have a reference type." );
1644	for (Int j = 0; j < m_directRefLayers[i].size(); j++)
1645	{
1646	xConfirmPara( m_directRefLayers[i][j] < 0 \|\| m_directRefLayers[i][j] >= i , "Reference layer id shall be greater than or equal to 0 and less than dependent layer id");
1647	xConfirmPara( m_dependencyTypes[i][j] < 0 \|\| m_dependencyTypes[i][j] > 2 , "Dependency type shall be greater than or equal to 0 and less than 3");
1648	}
1649	}
1650	#endif
1651	xConfirmPara( m_iGOPSize < 1 , "GOP Size must be greater or equal to 1" );
1652	xConfirmPara( m_iGOPSize > 1 && m_iGOPSize % 2, "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
1653	#if H_MV
1654	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1655	{
1656	xConfirmPara( (m_iIntraPeriod[layer] > 0 && m_iIntraPeriod[layer] < m_iGOPSize) \|\| m_iIntraPeriod[layer] == 0, "Intra period must be more than GOP size, or -1 , not 0" );
1657	}
1658	#else
1659	xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) \|\| m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
1660	#endif
1661	#if ALLOW_RECOVERY_POINT_AS_RAP
1662	xConfirmPara( m_iDecodingRefreshType < 0 \|\| m_iDecodingRefreshType > 3, "Decoding Refresh Type must be comprised between 0 and 3 included" );
1663	if(m_iDecodingRefreshType == 3)
1664	{
1665	xConfirmPara( !m_recoveryPointSEIEnabled, "When using RecoveryPointSEI messages as RA points, recoveryPointSEI must be enabled" );
1666	}
1667	#else
1668	xConfirmPara( m_iDecodingRefreshType < 0 \|\| m_iDecodingRefreshType > 2, "Decoding Refresh Type must be equal to 0, 1 or 2" );
1669	#endif
1670	#if H_MV
1671	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1672	{
1673	xConfirmPara( m_iQP[layer] < -6 * (m_internalBitDepthY - 8) \|\| m_iQP[layer] > 51, "QP exceeds supported range (-QpBDOffsety to 51)" );
1674	}
1675	#else
1676	xConfirmPara( m_iQP < -6 * (m_internalBitDepthY - 8) \|\| m_iQP > 51, "QP exceeds supported range (-QpBDOffsety to 51)" );
1677	#endif
1678	xConfirmPara( m_loopFilterBetaOffsetDiv2 < -6 \|\| m_loopFilterBetaOffsetDiv2 > 6, "Loop Filter Beta Offset div. 2 exceeds supported range (-6 to 6)");
1679	xConfirmPara( m_loopFilterTcOffsetDiv2 < -6 \|\| m_loopFilterTcOffsetDiv2 > 6, "Loop Filter Tc Offset div. 2 exceeds supported range (-6 to 6)");
1680	xConfirmPara( m_iFastSearch < 0 \|\| m_iFastSearch > 2, "Fast Search Mode is not supported value (0:Full search 1:Diamond 2:PMVFAST)" );
1681	xConfirmPara( m_iSearchRange < 0 , "Search Range must be more than 0" );
1682	xConfirmPara( m_bipredSearchRange < 0 , "Search Range must be more than 0" );
1683	xConfirmPara( m_iMaxDeltaQP > 7, "Absolute Delta QP exceeds supported range (0 to 7)" );
1684	xConfirmPara( m_iMaxCuDQPDepth > m_uiMaxCUDepth - 1, "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
1685
1686	xConfirmPara( m_cbQpOffset < -12, "Min. Chroma Cb QP Offset is -12" );
1687	xConfirmPara( m_cbQpOffset > 12, "Max. Chroma Cb QP Offset is 12" );
1688	xConfirmPara( m_crQpOffset < -12, "Min. Chroma Cr QP Offset is -12" );
1689	xConfirmPara( m_crQpOffset > 12, "Max. Chroma Cr QP Offset is 12" );
1690
1691	xConfirmPara( m_iQPAdaptationRange <= 0, "QP Adaptation Range must be more than 0" );
1692	if (m_iDecodingRefreshType == 2)
1693	{
1694	#if H_MV
1695	for (Int i = 0; i < m_numberOfLayers; i++ )
1696	{
1697	xConfirmPara( m_iIntraPeriod[i] > 0 && m_iIntraPeriod[i] <= m_iGOPSize , "Intra period must be larger than GOP size for periodic IDR pictures");
1698	}
1699	#else
1700	xConfirmPara( m_iIntraPeriod > 0 && m_iIntraPeriod <= m_iGOPSize , "Intra period must be larger than GOP size for periodic IDR pictures");
1701	#endif
1702	}
1703	xConfirmPara( (m_uiMaxCUWidth >> m_uiMaxCUDepth) < 4, "Minimum partition width size should be larger than or equal to 8");
1704	xConfirmPara( (m_uiMaxCUHeight >> m_uiMaxCUDepth) < 4, "Minimum partition height size should be larger than or equal to 8");
1705	xConfirmPara( m_uiMaxCUWidth < 16, "Maximum partition width size should be larger than or equal to 16");
1706	xConfirmPara( m_uiMaxCUHeight < 16, "Maximum partition height size should be larger than or equal to 16");
1707	xConfirmPara( (m_iSourceWidth % (m_uiMaxCUWidth >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame width must be a multiple of the minimum CU size");
1708	xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame height must be a multiple of the minimum CU size");
1709
1710	xConfirmPara( m_uiQuadtreeTULog2MinSize < 2, "QuadtreeTULog2MinSize must be 2 or greater.");
1711	xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5, "QuadtreeTULog2MaxSize must be 5 or smaller.");
1712	xConfirmPara( (1<<m_uiQuadtreeTULog2MaxSize) > m_uiMaxCUWidth, "QuadtreeTULog2MaxSize must be log2(maxCUSize) or smaller.");
1713
1714	xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize, "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize.");
1715	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1716	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUHeight>>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1717	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUWidth >> m_uiMaxCUDepth ), "Minimum CU width must be greater than minimum transform size." );
1718	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." );
1719	xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1, "QuadtreeTUMaxDepthInter must be greater than or equal to 1" );
1720	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" );
1721	xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1, "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" );
1722	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" );
1723
1724	xConfirmPara( m_maxNumMergeCand < 1, "MaxNumMergeCand must be 1 or greater.");
1725	xConfirmPara( m_maxNumMergeCand > 5, "MaxNumMergeCand must be 5 or smaller.");
1726
1727	#if H_3D_ARP
1728	xConfirmPara( ( 0 != m_uiUseAdvResPred ) && ( 1 != m_uiUseAdvResPred ), "UseAdvResPred must be 0 or 1." );
1729	#endif
1730	#if H_3D_SPIVMP
1731	xConfirmPara( m_iSubPULog2Size < 3, "SubPULog2Size must be 3 or greater.");
1732	xConfirmPara( m_iSubPULog2Size > 6, "SubPULog2Size must be 6 or smaller.");
1733	xConfirmPara( (1<<m_iSubPULog2Size) > m_uiMaxCUWidth, "SubPULog2Size must be log2(maxCUSize) or smaller.");
1734
1735	xConfirmPara( m_iSubPUMPILog2Size < 3, "SubPUMPILog2Size must be 3 or greater.");
1736	xConfirmPara( m_iSubPUMPILog2Size > 6, "SubPUMPILog2Size must be 6 or smaller.");
1737	xConfirmPara( ( 1 << m_iSubPUMPILog2Size ) > m_uiMaxCUWidth, "SubPUMPILog2Size must be log2(maxCUSize) or smaller.");
1738	#endif
1739	#if ADAPTIVE_QP_SELECTION
1740	#if H_MV
1741	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1742	{
1743	xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP[layer] < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
1744	}
1745	#else
1746	xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
1747	#endif
1748	xConfirmPara( m_bUseAdaptQpSelect == true && (m_cbQpOffset !=0 \|\| m_crQpOffset != 0 ), "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
1749	#endif
1750
1751	if( m_usePCM)
1752	{
1753	xConfirmPara( m_uiPCMLog2MinSize < 3, "PCMLog2MinSize must be 3 or greater.");
1754	xConfirmPara( m_uiPCMLog2MinSize > 5, "PCMLog2MinSize must be 5 or smaller.");
1755	xConfirmPara( m_pcmLog2MaxSize > 5, "PCMLog2MaxSize must be 5 or smaller.");
1756	xConfirmPara( m_pcmLog2MaxSize < m_uiPCMLog2MinSize, "PCMLog2MaxSize must be equal to or greater than m_uiPCMLog2MinSize.");
1757	}
1758
1759	xConfirmPara( m_sliceMode < 0 \|\| m_sliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
1760	if (m_sliceMode!=0)
1761	{
1762	xConfirmPara( m_sliceArgument < 1 , "SliceArgument should be larger than or equal to 1" );
1763	}
1764	xConfirmPara( m_sliceSegmentMode < 0 \|\| m_sliceSegmentMode > 3, "SliceSegmentMode exceeds supported range (0 to 3)" );
1765	if (m_sliceSegmentMode!=0)
1766	{
1767	xConfirmPara( m_sliceSegmentArgument < 1 , "SliceSegmentArgument should be larger than or equal to 1" );
1768	}
1769
1770	Bool tileFlag = (m_iNumColumnsMinus1 > 0 \|\| m_iNumRowsMinus1 > 0 );
1771	xConfirmPara( tileFlag && m_iWaveFrontSynchro, "Tile and Wavefront can not be applied together");
1772
1773	//TODO:ChromaFmt assumes 4:2:0 below
1774	xConfirmPara( m_iSourceWidth % TComSPS::getWinUnitX(CHROMA_420) != 0, "Picture width must be an integer multiple of the specified chroma subsampling");
1775	xConfirmPara( m_iSourceHeight % TComSPS::getWinUnitY(CHROMA_420) != 0, "Picture height must be an integer multiple of the specified chroma subsampling");
1776
1777	xConfirmPara( m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0, "Horizontal padding must be an integer multiple of the specified chroma subsampling");
1778	xConfirmPara( m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0, "Vertical padding must be an integer multiple of the specified chroma subsampling");
1779
1780	xConfirmPara( m_confLeft % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left conformance window offset must be an integer multiple of the specified chroma subsampling");
1781	xConfirmPara( m_confRight % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right conformance window offset must be an integer multiple of the specified chroma subsampling");
1782	xConfirmPara( m_confTop % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top conformance window offset must be an integer multiple of the specified chroma subsampling");
1783	xConfirmPara( m_confBottom % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom conformance window offset must be an integer multiple of the specified chroma subsampling");
1784
1785	#if H_3D
1786	xConfirmPara( m_pchCameraParameterFile == 0 , "CameraParameterFile must be given");
1787	xConfirmPara( m_pchBaseViewCameraNumbers == 0 , "BaseViewCameraNumbers must be given" );
1788	#if BUG_FIX_TK65
1789	xConfirmPara( ( ((UInt) m_numberOfLayers >> 1 ) != m_cCameraData.getBaseViewNumbers().size() ) && ( m_numberOfLayers != m_cCameraData.getBaseViewNumbers().size() ), "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
1790	#else
1791	xConfirmPara( ((UInt) m_numberOfLayers >> 1 ) != m_cCameraData.getBaseViewNumbers().size(), "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
1792	#endif
1793	xConfirmPara ( m_iCodedCamParPrecision < 0 \|\| m_iCodedCamParPrecision > 5, "CodedCamParsPrecision must be in range of 0..5" );
1794	#if H_3D_VSO
1795	if( m_bUseVSO )
1796	{
1797	xConfirmPara( m_pchVSOConfig == 0 , "VSO Setup string must be given");
1798	xConfirmPara( m_uiVSOMode > 4 , "VSO Mode must be less than 5");
1799	}
1800	#endif
1801	#endif
1802	// max CU width and height should be power of 2
1803	UInt ui = m_uiMaxCUWidth;
1804	while(ui)
1805	{
1806	ui >>= 1;
1807	if( (ui & 1) == 1)
1808	xConfirmPara( ui != 1 , "Width should be 2^n");
1809	}
1810	ui = m_uiMaxCUHeight;
1811	while(ui)
1812	{
1813	ui >>= 1;
1814	if( (ui & 1) == 1)
1815	xConfirmPara( ui != 1 , "Height should be 2^n");
1816	}
1817
1818	#if H_MV
1819	// validate that POC of same frame is identical across multiple layers
1820	Bool bErrorMvePoc = false;
1821	if( m_numberOfLayers > 1 )
1822	{
1823	for( Int k = 1; k < m_numberOfLayers; k++ )
1824	{
1825	for( Int i = 0; i < MAX_GOP; i++ )
1826	{
1827	if( m_GOPListMvc[k][i].m_POC != m_GOPListMvc[0][i].m_POC )
1828	{
1829	printf( "\nError: Frame%d_l%d POC %d is not identical to Frame%d POC\n", i, k, m_GOPListMvc[k][i].m_POC, i );
1830	bErrorMvePoc = true;
1831	}
1832	}
1833	}
1834	}
1835	xConfirmPara( bErrorMvePoc, "Invalid inter-layer POC structure given" );
1836
1837	// validate that baseview has no inter-view refs
1838	Bool bErrorIvpBase = false;
1839	for( Int i = 0; i < MAX_GOP; i++ )
1840	{
1841	if( m_GOPListMvc[0][i].m_numActiveRefLayerPics != 0 )
1842	{
1843	printf( "\nError: Frame%d inter_layer refs not available in layer 0\n", i );
1844	bErrorIvpBase = true;
1845	}
1846	}
1847	xConfirmPara( bErrorIvpBase, "Inter-layer refs not possible in base layer" );
1848
1849	// validate inter-view refs
1850	Bool bErrorIvpEnhV = false;
1851	if( m_numberOfLayers > 1 )
1852	{
1853	for( Int layer = 1; layer < m_numberOfLayers; layer++ )
1854	{
1855	for( Int i = 0; i < MAX_GOP+1; i++ )
1856	{
1857	GOPEntry gopEntry = m_GOPListMvc[layer][i];
1858	for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1859	{
1860	Int ilPredLayerIdc = gopEntry.m_interLayerPredLayerIdc[j];
1861	if( ilPredLayerIdc < 0 \|\| ilPredLayerIdc >= m_directRefLayers[layer].size() )
1862	{
1863	printf( "\nError: inter-layer ref idc %d is not available for Frame%d_l%d\n", gopEntry.m_interLayerPredLayerIdc[j], i, layer );
1864	bErrorIvpEnhV = true;
1865	}
1866	if( gopEntry.m_interViewRefPosL[0][j] < -1 \|\| gopEntry.m_interViewRefPosL[0][j] > gopEntry.m_numRefPicsActive )
1867	{
1868	printf( "\nError: inter-layer ref pos %d on L0 is not available for Frame%d_l%d\n", gopEntry.m_interViewRefPosL[0][j], i, layer );
1869	bErrorIvpEnhV = true;
1870	}
1871	if( gopEntry.m_interViewRefPosL[1][j] < -1 \|\| gopEntry.m_interViewRefPosL[1][j] > gopEntry.m_numRefPicsActive )
1872	{
1873	printf( "\nError: inter-layer ref pos %d on L1 is not available for Frame%d_l%d\n", gopEntry.m_interViewRefPosL[1][j], i, layer );
1874	bErrorIvpEnhV = true;
1875	}
1876	}
1877	if( i == MAX_GOP ) // inter-view refs at I pic position in base view
1878	{
1879	if( gopEntry.m_sliceType != 'B' && gopEntry.m_sliceType != 'P' && gopEntry.m_sliceType != 'I' )
1880	{
1881	printf( "\nError: slice type of FrameI_l%d must be equal to B or P or I\n", layer );
1882	bErrorIvpEnhV = true;
1883	}
1884
1885	if( gopEntry.m_POC != 0 )
1886	{
1887	printf( "\nError: POC %d not possible for FrameI_l%d, must be 0\n", gopEntry.m_POC, layer );
1888	bErrorIvpEnhV = true;
1889	}
1890
1891	if( gopEntry.m_temporalId != 0 )
1892	{
1893	printf( "\nWarning: Temporal id of FrameI_l%d must be 0 (cp. I-frame in base layer)\n", layer );
1894	gopEntry.m_temporalId = 0;
1895	}
1896
1897	if( gopEntry.m_numRefPics != 0 )
1898	{
1899	printf( "\nWarning: temporal references not possible for FrameI_l%d\n", layer );
1900	for( Int j = 0; j < m_GOPListMvc[layer][MAX_GOP].m_numRefPics; j++ )
1901	{
1902	gopEntry.m_referencePics[j] = 0;
1903	}
1904	gopEntry.m_numRefPics = 0;
1905	}
1906
1907	if( gopEntry.m_interRPSPrediction )
1908	{
1909	printf( "\nError: inter RPS prediction not possible for FrameI_l%d, must be 0\n", layer );
1910	bErrorIvpEnhV = true;
1911	}
1912
1913	if( gopEntry.m_sliceType == 'I' && gopEntry.m_numActiveRefLayerPics != 0 )
1914	{
1915	printf( "\nError: inter-layer prediction not possible for FrameI_l%d with slice type I, #IL_ref_pics must be 0\n", layer );
1916	bErrorIvpEnhV = true;
1917	}
1918
1919	if( gopEntry.m_numRefPicsActive > gopEntry.m_numActiveRefLayerPics )
1920	{
1921	gopEntry.m_numRefPicsActive = gopEntry.m_numActiveRefLayerPics;
1922	}
1923
1924	if( gopEntry.m_sliceType == 'P' )
1925	{
1926	if( gopEntry.m_numActiveRefLayerPics < 1 )
1927	{
1928	printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type P\n", layer );
1929	bErrorIvpEnhV = true;
1930	}
1931	else
1932	{
1933	for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1934	{
1935	if( gopEntry.m_interViewRefPosL[1][j] != -1 )
1936	{
1937	printf( "\nError: inter-layer ref pos %d on L1 not possible for FrameI_l%d with slice type P\n", gopEntry.m_interViewRefPosL[1][j], layer );
1938	bErrorIvpEnhV = true;
1939	}
1940	}
1941	}
1942	}
1943
1944	if( gopEntry.m_sliceType == 'B' && gopEntry.m_numActiveRefLayerPics < 1 )
1945	{
1946	printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type B\n", layer );
1947	bErrorIvpEnhV = true;
1948	}
1949	}
1950	}
1951	}
1952	}
1953	xConfirmPara( bErrorIvpEnhV, "Invalid inter-layer coding structure for enhancement layers given" );
1954
1955	// validate temporal coding structure
1956	if( !bErrorMvePoc && !bErrorIvpBase && !bErrorIvpEnhV )
1957	{
1958	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1959	{
1960	GOPEntry* m_GOPList = m_GOPListMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1961	Int& m_extraRPSs = m_extraRPSsMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1962	Int& m_maxTempLayer = m_maxTempLayerMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1963	Int* m_maxDecPicBuffering = m_maxDecPicBufferingMvc[layer]; // It is not a member, but this name helps avoiding code duplication !!!
1964	Int* m_numReorderPics = m_numReorderPicsMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1965	#endif
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 H_MV
1969	if (m_iIntraPeriod[layer] == 1 && m_GOPList[0].m_POC == -1) {
1970	#else
1971	if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
1972	#endif
1973	m_GOPList[0] = GOPEntry();
1974	m_GOPList[0].m_QPFactor = 1;
1975	m_GOPList[0].m_betaOffsetDiv2 = 0;
1976	m_GOPList[0].m_tcOffsetDiv2 = 0;
1977	m_GOPList[0].m_POC = 1;
1978	m_GOPList[0].m_numRefPicsActive = 4;
1979	}
1980
1981	Bool verifiedGOP=false;
1982	Bool errorGOP=false;
1983	Int checkGOP=1;
1984	Int numRefs = m_isField ? 2 : 1;
1985	Int refList[MAX_NUM_REF_PICS+1];
1986	refList[0]=0;
1987	if(m_isField)
1988	{
1989	refList[1] = 1;
1990	}
1991	Bool isOK[MAX_GOP];
1992	for(Int i=0; i<MAX_GOP; i++)
1993	{
1994	isOK[i]=false;
1995	}
1996	Int numOK=0;
1997	#if H_MV
1998	xConfirmPara( m_iIntraPeriod[layer] >=0&&(m_iIntraPeriod[layer]%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
1999	#else
2000	xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
2001	#endif
2002
2003	for(Int i=0; i<m_iGOPSize; i++)
2004	{
2005	if(m_GOPList[i].m_POC==m_iGOPSize)
2006	{
2007	xConfirmPara( m_GOPList[i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
2008	}
2009	}
2010
2011	#if H_MV
2012	if ( (m_iIntraPeriod[layer] != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable[layer]) )
2013	#else
2014	if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
2015	#endif
2016	{
2017	for(Int i=0; i<m_iGOPSize; i++)
2018	{
2019	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)" );
2020	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)" );
2021	}
2022	}
2023	m_extraRPSs=0;
2024	//start looping through frames in coding order until we can verify that the GOP structure is correct.
2025	while(!verifiedGOP&&!errorGOP)
2026	{
2027	Int curGOP = (checkGOP-1)%m_iGOPSize;
2028	Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC;
2029	if(m_GOPList[curGOP].m_POC<0)
2030	{
2031	#if H_MV
2032	printf("\nError: found fewer Reference Picture Sets than GOPSize for layer %d\n", layer );
2033	#else
2034	printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
2035	#endif
2036	errorGOP=true;
2037	}
2038	else
2039	{
2040	//check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
2041	Bool beforeI = false;
2042	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
2043	{
2044	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
2045	if(absPOC < 0)
2046	{
2047	beforeI=true;
2048	}
2049	else
2050	{
2051	Bool found=false;
2052	for(Int j=0; j<numRefs; j++)
2053	{
2054	if(refList[j]==absPOC)
2055	{
2056	found=true;
2057	for(Int k=0; k<m_iGOPSize; k++)
2058	{
2059	if(absPOC%m_iGOPSize == m_GOPList[k].m_POC%m_iGOPSize)
2060	{
2061	if(m_GOPList[k].m_temporalId==m_GOPList[curGOP].m_temporalId)
2062	{
2063	m_GOPList[k].m_refPic = true;
2064	}
2065	m_GOPList[curGOP].m_usedByCurrPic[i]=m_GOPList[k].m_temporalId<=m_GOPList[curGOP].m_temporalId;
2066	}
2067	}
2068	}
2069	}
2070	if(!found)
2071	{
2072	#if H_MV
2073	printf("\nError: ref pic %d is not available for GOP frame %d of layer %d\n", m_GOPList[curGOP].m_referencePics[i], curGOP+1, layer);
2074	#else
2075	printf("\nError: ref pic %d is not available for GOP frame %d\n",m_GOPList[curGOP].m_referencePics[i],curGOP+1);
2076	#endif
2077	errorGOP=true;
2078	}
2079	}
2080	}
2081	if(!beforeI&&!errorGOP)
2082	{
2083	//all ref frames were present
2084	if(!isOK[curGOP])
2085	{
2086	numOK++;
2087	isOK[curGOP]=true;
2088	if(numOK==m_iGOPSize)
2089	{
2090	verifiedGOP=true;
2091	}
2092	}
2093	}
2094	else
2095	{
2096	//create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
2097	m_GOPList[m_iGOPSize+m_extraRPSs]=m_GOPList[curGOP];
2098	Int newRefs=0;
2099	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
2100	{
2101	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
2102	if(absPOC>=0)
2103	{
2104	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
2105	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
2106	newRefs++;
2107	}
2108	}
2109	Int numPrefRefs = m_GOPList[curGOP].m_numRefPicsActive;
2110
2111	for(Int offset = -1; offset>-checkGOP; offset--)
2112	{
2113	//step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
2114	Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
2115	Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_GOPList[offGOP].m_POC;
2116	if(offPOC>=0&&m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId)
2117	{
2118	Bool newRef=false;
2119	for(Int i=0; i<numRefs; i++)
2120	{
2121	if(refList[i]==offPOC)
2122	{
2123	newRef=true;
2124	}
2125	}
2126	for(Int i=0; i<newRefs; i++)
2127	{
2128	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[i]==offPOC-curPOC)
2129	{
2130	newRef=false;
2131	}
2132	}
2133	if(newRef)
2134	{
2135	Int insertPoint=newRefs;
2136	//this picture can be added, find appropriate place in list and insert it.
2137	if(m_GOPList[offGOP].m_temporalId==m_GOPList[curGOP].m_temporalId)
2138	{
2139	m_GOPList[offGOP].m_refPic = true;
2140	}
2141	for(Int j=0; j<newRefs; j++)
2142	{
2143	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]<offPOC-curPOC\|\|m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]>0)
2144	{
2145	insertPoint = j;
2146	break;
2147	}
2148	}
2149	Int prev = offPOC-curPOC;
2150	Int prevUsed = m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId;
2151	for(Int j=insertPoint; j<newRefs+1; j++)
2152	{
2153	Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j];
2154	Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j];
2155	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]=prev;
2156	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j]=prevUsed;
2157	prevUsed=newUsed;
2158	prev=newPrev;
2159	}
2160	newRefs++;
2161	}
2162	}
2163	if(newRefs>=numPrefRefs)
2164	{
2165	break;
2166	}
2167	}
2168	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics=newRefs;
2169	m_GOPList[m_iGOPSize+m_extraRPSs].m_POC = curPOC;
2170	if (m_extraRPSs == 0)
2171	{
2172	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 0;
2173	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = 0;
2174	}
2175	else
2176	{
2177	Int rIdx = m_iGOPSize + m_extraRPSs - 1;
2178	Int refPOC = m_GOPList[rIdx].m_POC;
2179	Int refPics = m_GOPList[rIdx].m_numRefPics;
2180	Int newIdc=0;
2181	for(Int i = 0; i<= refPics; i++)
2182	{
2183	Int deltaPOC = ((i != refPics)? m_GOPList[rIdx].m_referencePics[i] : 0); // check if the reference abs POC is >= 0
2184	Int absPOCref = refPOC+deltaPOC;
2185	Int refIdc = 0;
2186	for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics; j++)
2187	{
2188	if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j])
2189	{
2190	if (m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j])
2191	{
2192	refIdc = 1;
2193	}
2194	else
2195	{
2196	refIdc = 2;
2197	}
2198	}
2199	}
2200	m_GOPList[m_iGOPSize+m_extraRPSs].m_refIdc[newIdc]=refIdc;
2201	newIdc++;
2202	}
2203	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1;
2204	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = newIdc;
2205	m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC;
2206	}
2207	curGOP=m_iGOPSize+m_extraRPSs;
2208	m_extraRPSs++;
2209	}
2210	numRefs=0;
2211	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
2212	{
2213	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
2214	if(absPOC >= 0)
2215	{
2216	refList[numRefs]=absPOC;
2217	numRefs++;
2218	}
2219	}
2220	refList[numRefs]=curPOC;
2221	numRefs++;
2222	}
2223	checkGOP++;
2224	}
2225	xConfirmPara(errorGOP,"Invalid GOP structure given");
2226	m_maxTempLayer = 1;
2227	for(Int i=0; i<m_iGOPSize; i++)
2228	{
2229	if(m_GOPList[i].m_temporalId >= m_maxTempLayer)
2230	{
2231	m_maxTempLayer = m_GOPList[i].m_temporalId+1;
2232	}
2233	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");
2234	}
2235	for(Int i=0; i<MAX_TLAYER; i++)
2236	{
2237	m_numReorderPics[i] = 0;
2238	m_maxDecPicBuffering[i] = 1;
2239	}
2240	for(Int i=0; i<m_iGOPSize; i++)
2241	{
2242	if(m_GOPList[i].m_numRefPics+1 > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
2243	{
2244	m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1;
2245	}
2246	Int highestDecodingNumberWithLowerPOC = 0;
2247	for(Int j=0; j<m_iGOPSize; j++)
2248	{
2249	if(m_GOPList[j].m_POC <= m_GOPList[i].m_POC)
2250	{
2251	highestDecodingNumberWithLowerPOC = j;
2252	}
2253	}
2254	Int numReorder = 0;
2255	for(Int j=0; j<highestDecodingNumberWithLowerPOC; j++)
2256	{
2257	if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId &&
2258	m_GOPList[j].m_POC > m_GOPList[i].m_POC)
2259	{
2260	numReorder++;
2261	}
2262	}
2263	if(numReorder > m_numReorderPics[m_GOPList[i].m_temporalId])
2264	{
2265	m_numReorderPics[m_GOPList[i].m_temporalId] = numReorder;
2266	}
2267	}
2268	for(Int i=0; i<MAX_TLAYER-1; i++)
2269	{
2270	// a lower layer can not have higher value of m_numReorderPics than a higher layer
2271	if(m_numReorderPics[i+1] < m_numReorderPics[i])
2272	{
2273	m_numReorderPics[i+1] = m_numReorderPics[i];
2274	}
2275	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
2276	if(m_numReorderPics[i] > m_maxDecPicBuffering[i] - 1)
2277	{
2278	m_maxDecPicBuffering[i] = m_numReorderPics[i] + 1;
2279	}
2280	// a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
2281	if(m_maxDecPicBuffering[i+1] < m_maxDecPicBuffering[i])
2282	{
2283	m_maxDecPicBuffering[i+1] = m_maxDecPicBuffering[i];
2284	}
2285	}
2286
2287
2288	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
2289	if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1)
2290	{
2291	m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1] + 1;
2292	}
2293
2294	if(m_vuiParametersPresentFlag && m_bitstreamRestrictionFlag)
2295	{
2296	Int PicSizeInSamplesY = m_iSourceWidth * m_iSourceHeight;
2297	if(tileFlag)
2298	{
2299	Int maxTileWidth = 0;
2300	Int maxTileHeight = 0;
2301	Int widthInCU = (m_iSourceWidth % m_uiMaxCUWidth) ? m_iSourceWidth/m_uiMaxCUWidth + 1: m_iSourceWidth/m_uiMaxCUWidth;
2302	Int heightInCU = (m_iSourceHeight % m_uiMaxCUHeight) ? m_iSourceHeight/m_uiMaxCUHeight + 1: m_iSourceHeight/m_uiMaxCUHeight;
2303	if(m_iUniformSpacingIdr)
2304	{
2305	maxTileWidth = m_uiMaxCUWidth*((widthInCU+m_iNumColumnsMinus1)/(m_iNumColumnsMinus1+1));
2306	maxTileHeight = m_uiMaxCUHeight*((heightInCU+m_iNumRowsMinus1)/(m_iNumRowsMinus1+1));
2307	// if only the last tile-row is one treeblock higher than the others
2308	// the maxTileHeight becomes smaller if the last row of treeblocks has lower height than the others
2309	if(!((heightInCU-1)%(m_iNumRowsMinus1+1)))
2310	{
2311	maxTileHeight = maxTileHeight - m_uiMaxCUHeight + (m_iSourceHeight % m_uiMaxCUHeight);
2312	}
2313	// if only the last tile-column is one treeblock wider than the others
2314	// the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others
2315	if(!((widthInCU-1)%(m_iNumColumnsMinus1+1)))
2316	{
2317	maxTileWidth = maxTileWidth - m_uiMaxCUWidth + (m_iSourceWidth % m_uiMaxCUWidth);
2318	}
2319	}
2320	else // not uniform spacing
2321	{
2322	if(m_iNumColumnsMinus1<1)
2323	{
2324	maxTileWidth = m_iSourceWidth;
2325	}
2326	else
2327	{
2328	Int accColumnWidth = 0;
2329	for(Int col=0; col<(m_iNumColumnsMinus1); col++)
2330	{
2331	maxTileWidth = m_pColumnWidth[col]>maxTileWidth ? m_pColumnWidth[col]:maxTileWidth;
2332	accColumnWidth += m_pColumnWidth[col];
2333	}
2334	maxTileWidth = (widthInCU-accColumnWidth)>maxTileWidth ? m_uiMaxCUWidth(widthInCU-accColumnWidth):m_uiMaxCUWidthmaxTileWidth;
2335	}
2336	if(m_iNumRowsMinus1<1)
2337	{
2338	maxTileHeight = m_iSourceHeight;
2339	}
2340	else
2341	{
2342	Int accRowHeight = 0;
2343	for(Int row=0; row<(m_iNumRowsMinus1); row++)
2344	{
2345	maxTileHeight = m_pRowHeight[row]>maxTileHeight ? m_pRowHeight[row]:maxTileHeight;
2346	accRowHeight += m_pRowHeight[row];
2347	}
2348	maxTileHeight = (heightInCU-accRowHeight)>maxTileHeight ? m_uiMaxCUHeight(heightInCU-accRowHeight):m_uiMaxCUHeightmaxTileHeight;
2349	}
2350	}
2351	Int maxSizeInSamplesY = maxTileWidth*maxTileHeight;
2352	m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/maxSizeInSamplesY-4;
2353	}
2354	else if(m_iWaveFrontSynchro)
2355	{
2356	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/((2m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4;
2357	}
2358	else if(m_sliceMode == 1)
2359	{
2360	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/(m_sliceArgumentm_uiMaxCUWidth*m_uiMaxCUHeight)-4;
2361	}
2362	else
2363	{
2364	m_minSpatialSegmentationIdc = 0;
2365	}
2366	}
2367	xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
2368	xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
2369	xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
2370
2371	xConfirmPara( m_decodedPictureHashSEIEnabled<0 \|\| m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n");
2372
2373	if (m_toneMappingInfoSEIEnabled)
2374	{
2375	xConfirmPara( m_toneMapCodedDataBitDepth < 8 \|\| m_toneMapCodedDataBitDepth > 14 , "SEIToneMapCodedDataBitDepth must be in rage 8 to 14");
2376	xConfirmPara( m_toneMapTargetBitDepth < 1 \|\| (m_toneMapTargetBitDepth > 16 && m_toneMapTargetBitDepth < 255) , "SEIToneMapTargetBitDepth must be in rage 1 to 16 or equal to 255");
2377	xConfirmPara( m_toneMapModelId < 0 \|\| m_toneMapModelId > 4 , "SEIToneMapModelId must be in rage 0 to 4");
2378	xConfirmPara( m_cameraIsoSpeedValue == 0, "SEIToneMapCameraIsoSpeedValue shall not be equal to 0");
2379	xConfirmPara( m_exposureIndexValue == 0, "SEIToneMapExposureIndexValue shall not be equal to 0");
2380	xConfirmPara( m_extendedRangeWhiteLevel < 100, "SEIToneMapExtendedRangeWhiteLevel should be greater than or equal to 100");
2381	xConfirmPara( m_nominalBlackLevelLumaCodeValue >= m_nominalWhiteLevelLumaCodeValue, "SEIToneMapNominalWhiteLevelLumaCodeValue shall be greater than SEIToneMapNominalBlackLevelLumaCodeValue");
2382	xConfirmPara( m_extendedWhiteLevelLumaCodeValue < m_nominalWhiteLevelLumaCodeValue, "SEIToneMapExtendedWhiteLevelLumaCodeValue shall be greater than or equal to SEIToneMapNominalWhiteLevelLumaCodeValue");
2383	}
2384
2385	if ( m_RCEnableRateControl )
2386	{
2387	if ( m_RCForceIntraQP )
2388	{
2389	if ( m_RCInitialQP == 0 )
2390	{
2391	printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
2392	m_RCForceIntraQP = false;
2393	}
2394	}
2395	xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
2396	}
2397	#if H_MV
2398	// VPS VUI
2399	for(Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++ )
2400	{
2401	for (Int j = 0; j < MAX_TLAYER; j++)
2402	{
2403	if ( j < m_avgBitRate [i].size() ) xConfirmPara( m_avgBitRate[i][j] < 0 \|\| m_avgBitRate[i][j] > 65535, "avg_bit_rate must be more than or equal to 0 and less than 65536" );
2404	if ( j < m_maxBitRate [i].size() ) xConfirmPara( m_maxBitRate[i][j] < 0 \|\| m_maxBitRate[i][j] > 65535, "max_bit_rate must be more than or equal to 0 and less than 65536" );
2405	if ( j < m_constantPicRateIdc[i].size() ) xConfirmPara( m_constantPicRateIdc[i][j] < 0 \|\| m_constantPicRateIdc[i][j] > 3, "constant_pic_rate_idc must be more than or equal to 0 and less than 4" );
2406	if ( j < m_avgPicRate [i].size() ) xConfirmPara( m_avgPicRate[i][j] < 0 \|\| m_avgPicRate[i][j] > 65535, "avg_pic_rate must be more than or equal to 0 and less than 65536" );
2407	}
2408	}
2409	// todo: replace value of 100 with requirement in spec
2410	for(Int i = 0; i < MAX_NUM_LAYERS; i++ )
2411	{
2412	for (Int j = 0; j < MAX_NUM_LAYERS; j++)
2413	{
2414	if ( j < m_minSpatialSegmentOffsetPlus1[i].size() ) xConfirmPara( m_minSpatialSegmentOffsetPlus1[i][j] < 0 \|\| m_minSpatialSegmentOffsetPlus1[i][j] > 100, "min_spatial_segment_offset_plus1 must be more than or equal to 0 and less than 101" );
2415	if ( j < m_minHorizontalCtuOffsetPlus1[i] .size() ) xConfirmPara( m_minHorizontalCtuOffsetPlus1[i][j] < 0 \|\| m_minHorizontalCtuOffsetPlus1[i][j] > 100, "min_horizontal_ctu_offset_plus1 must be more than or equal to 0 and less than 101" );
2416	}
2417	}
2418	#endif
2419
2420	xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagForce, "CUTransquantBypassFlagForce cannot be 1 when TransquantBypassEnableFlag is 0");
2421
2422	xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2");
2423	if (m_framePackingSEIEnabled)
2424	{
2425	xConfirmPara(m_framePackingSEIType < 3 \|\| m_framePackingSEIType > 5 , "SEIFramePackingType must be in rage 3 to 5");
2426	}
2427
2428	#if H_MV
2429	}
2430	}
2431	// Check input parameters for Sub-bitstream property SEI message
2432	if( m_subBistreamPropSEIEnabled )
2433	{
2434	xConfirmPara(
2435	(this->m_sbPropNumAdditionalSubStreams != m_sbPropAvgBitRate.size() )
2436	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropHighestSublayerId.size() )
2437	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropMaxBitRate.size() )
2438	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropOutputLayerSetIdxToVps.size() )
2439	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropSubBitstreamMode.size()), "Some parameters of some sub-bitstream not defined");
2440
2441	for( Int i = 0; i < m_sbPropNumAdditionalSubStreams; i++ )
2442	{
2443	xConfirmPara( m_sbPropSubBitstreamMode[i] < 0 \|\| m_sbPropSubBitstreamMode[i] > 1, "Mode value should be 0 or 1" );
2444	xConfirmPara( m_sbPropHighestSublayerId[i] < 0 \|\| m_sbPropHighestSublayerId[i] > MAX_TLAYER-1, "Maximum sub-layer ID out of range" );
2445	xConfirmPara( m_sbPropOutputLayerSetIdxToVps[i] < 0 \|\| m_sbPropOutputLayerSetIdxToVps[i] >= MAX_VPS_OUTPUTLAYER_SETS, "OutputLayerSetIdxToVps should be within allowed range" );
2446	}
2447	}
2448	#endif
2449	#undef xConfirmPara
2450	if (check_failed)
2451	{
2452	exit(EXIT_FAILURE);
2453	}
2454	}
2455
2456	/** \todo use of global variables should be removed later
2457	*/
2458	Void TAppEncCfg::xSetGlobal()
2459	{
2460	// set max CU width & height
2461	g_uiMaxCUWidth = m_uiMaxCUWidth;
2462	g_uiMaxCUHeight = m_uiMaxCUHeight;
2463
2464	// compute actual CU depth with respect to config depth and max transform size
2465	g_uiAddCUDepth = 0;
2466	while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth ) ) ) g_uiAddCUDepth++;
2467
2468	m_uiMaxCUDepth += g_uiAddCUDepth;
2469	g_uiAddCUDepth++;
2470	g_uiMaxCUDepth = m_uiMaxCUDepth;
2471
2472	// set internal bit-depth and constants
2473	g_bitDepthY = m_internalBitDepthY;
2474	g_bitDepthC = m_internalBitDepthC;
2475
2476	g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
2477	g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
2478	}
2479
2480	Void TAppEncCfg::xPrintParameter()
2481	{
2482	printf("\n");
2483	#if H_MV
2484	for( Int layer = 0; layer < m_numberOfLayers; layer++)
2485	{
2486	printf("Input File %i : %s\n", layer, m_pchInputFileList[layer]);
2487	}
2488	#else
2489	printf("Input File : %s\n", m_pchInputFile );
2490	#endif
2491	printf("Bitstream File : %s\n", m_pchBitstreamFile );
2492	#if H_MV
2493	for( Int layer = 0; layer < m_numberOfLayers; layer++)
2494	{
2495	printf("Reconstruction File %i : %s\n", layer, m_pchReconFileList[layer]);
2496	}
2497	#else
2498	printf("Reconstruction File : %s\n", m_pchReconFile );
2499	#endif
2500	#if H_MV
2501	#if H_MV_HLS10_GEN_FIX
2502	xPrintParaVector( "NuhLayerId" , m_layerIdInNuh );
2503	if ( m_targetEncLayerIdList.size() > 0)
2504	{
2505	xPrintParaVector( "TargetEncLayerIdList" , m_targetEncLayerIdList );
2506	}
2507	#endif
2508	xPrintParaVector( "ViewIdVal" , m_viewId );
2509	xPrintParaVector( "ViewOrderIndex", m_viewOrderIndex );
2510	#if H_MV_HLS10_AUX
2511	xPrintParaVector( "AuxId", m_auxId );
2512	#endif
2513	#endif
2514	#if H_3D
2515	xPrintParaVector( "DepthFlag", m_depthFlag );
2516	printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2517	#endif
2518	#if H_MV
2519	xPrintParaVector( "QP" , m_fQP );
2520	xPrintParaVector( "LoopFilterDisable", m_bLoopFilterDisable );
2521	xPrintParaVector( "SAO" , m_bUseSAO );
2522	#endif
2523	printf("Real Format : %dx%d %dHz\n", m_iSourceWidth - m_confLeft - m_confRight, m_iSourceHeight - m_confTop - m_confBottom, m_iFrameRate );
2524	printf("Internal Format : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
2525	if (m_isField)
2526	{
2527	printf("Frame/Field : Field based coding\n");
2528	printf("Field index : %u - %d (%d fields)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2529	if (m_isTopFieldFirst)
2530	{
2531	printf("Field Order : Top field first\n");
2532	}
2533	else
2534	{
2535	printf("Field Order : Bottom field first\n");
2536	}
2537	}
2538	else
2539	{
2540	printf("Frame/Field : Frame based coding\n");
2541	printf("Frame index : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2542	}
2543	printf("CU size / depth : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
2544	printf("RQT trans. size (min / max) : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
2545	printf("Max RQT depth inter : %d\n", m_uiQuadtreeTUMaxDepthInter);
2546	printf("Max RQT depth intra : %d\n", m_uiQuadtreeTUMaxDepthIntra);
2547	printf("Min PCM size : %d\n", 1 << m_uiPCMLog2MinSize);
2548	printf("Motion search range : %d\n", m_iSearchRange );
2549	#if H_MV
2550	xPrintParaVector( "Intra period", m_iIntraPeriod );
2551	#else
2552	printf("Intra period : %d\n", m_iIntraPeriod );
2553	#endif
2554	printf("Decoding refresh type : %d\n", m_iDecodingRefreshType );
2555	#if !H_MV
2556	printf("QP : %5.2f\n", m_fQP );
2557	#endif
2558	printf("Max dQP signaling depth : %d\n", m_iMaxCuDQPDepth);
2559
2560	printf("Cb QP Offset : %d\n", m_cbQpOffset );
2561	printf("Cr QP Offset : %d\n", m_crQpOffset);
2562
2563	printf("QP adaptation : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
2564	printf("GOP size : %d\n", m_iGOPSize );
2565	printf("Internal bit depth : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC );
2566	printf("PCM sample bit depth : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma );
2567	printf("RateControl : %d\n", m_RCEnableRateControl );
2568	if(m_RCEnableRateControl)
2569	{
2570	printf("TargetBitrate : %d\n", m_RCTargetBitrate );
2571	printf("KeepHierarchicalBit : %d\n", m_RCKeepHierarchicalBit );
2572	printf("LCULevelRC : %d\n", m_RCLCULevelRC );
2573	printf("UseLCUSeparateModel : %d\n", m_RCUseLCUSeparateModel );
2574	printf("InitialQP : %d\n", m_RCInitialQP );
2575	printf("ForceIntraQP : %d\n", m_RCForceIntraQP );
2576
2577	#if KWU_RC_MADPRED_E0227
2578	printf("Depth based MAD prediction : %d\n", m_depthMADPred);
2579	#endif
2580	#if KWU_RC_VIEWRC_E0227
2581	printf("View-wise Rate control : %d\n", m_viewWiseRateCtrl);
2582	if(m_viewWiseRateCtrl)
2583	{
2584
2585	printf("ViewWiseTargetBits : ");
2586	for (Int i = 0 ; i < m_iNumberOfViews ; i++)
2587	printf("%d ", m_viewTargetBits[i]);
2588	printf("\n");
2589	}
2590	else
2591	{
2592	printf("TargetBitrate : %d\n", m_RCTargetBitrate );
2593	}
2594	#endif
2595	}
2596	printf("Max Num Merge Candidates : %d\n", m_maxNumMergeCand);
2597	#if H_3D
2598	printf("BaseViewCameraNumbers : %s\n", m_pchBaseViewCameraNumbers );
2599	printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2600	#if H_3D_VSO
2601	printf("Force use of Lambda Scale : %d\n", m_bForceLambdaScaleVSO );
2602
2603	if ( m_bUseVSO )
2604	{
2605	printf("VSO Lambda Scale : %5.2f\n", m_dLambdaScaleVSO );
2606	printf("VSO Mode : %d\n", m_uiVSOMode );
2607	printf("VSO Config : %s\n", m_pchVSOConfig );
2608	printf("VSO Negative Distortion : %d\n", m_bAllowNegDist ? 1 : 0);
2609	printf("VSO LS Table : %d\n", m_bVSOLSTable ? 1 : 0);
2610	printf("VSO Estimated VSD : %d\n", m_bUseEstimatedVSD ? 1 : 0);
2611	printf("VSO Early Skip : %d\n", m_bVSOEarlySkip ? 1 : 0);
2612	if ( m_bUseWVSO )
2613	printf("Dist. Weights (VSO/VSD/SAD) : %d/%d/%d\n ", m_iVSOWeight, m_iVSDWeight, m_iDWeight );
2614	}
2615	#endif //HHI_VSO
2616	#endif //H_3D
2617	printf("\n");
2618	#if H_MV
2619	printf("TOOL CFG General: ");
2620	#else
2621	printf("TOOL CFG: ");
2622	#endif
2623	printf("IBD:%d ", g_bitDepthY > m_inputBitDepthY \|\| g_bitDepthC > m_inputBitDepthC);
2624	printf("HAD:%d ", m_bUseHADME );
2625	printf("RDQ:%d ", m_useRDOQ );
2626	printf("RDQTS:%d ", m_useRDOQTS );
2627	printf("RDpenalty:%d ", m_rdPenalty );
2628	printf("SQP:%d ", m_uiDeltaQpRD );
2629	printf("ASR:%d ", m_bUseASR );
2630	printf("FEN:%d ", m_bUseFastEnc );
2631	printf("ECU:%d ", m_bUseEarlyCU );
2632	printf("FDM:%d ", m_useFastDecisionForMerge );
2633	printf("CFM:%d ", m_bUseCbfFastMode );
2634	printf("ESD:%d ", m_useEarlySkipDetection );
2635	printf("RQT:%d ", 1 );
2636	printf("TransformSkip:%d ", m_useTransformSkip );
2637	printf("TransformSkipFast:%d ", m_useTransformSkipFast );
2638	printf("Slice: M=%d ", m_sliceMode);
2639	if (m_sliceMode!=0)
2640	{
2641	printf("A=%d ", m_sliceArgument);
2642	}
2643	printf("SliceSegment: M=%d ",m_sliceSegmentMode);
2644	if (m_sliceSegmentMode!=0)
2645	{
2646	printf("A=%d ", m_sliceSegmentArgument);
2647	}
2648	printf("CIP:%d ", m_bUseConstrainedIntraPred);
2649	#if !H_MV
2650	printf("SAO:%d ", (m_bUseSAO)?(1):(0));
2651	#endif
2652	printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
2653	if (m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagForce)
2654	{
2655	printf("TransQuantBypassEnabled: =1 ");
2656	}
2657	else
2658	{
2659	printf("TransQuantBypassEnabled:%d ", (m_TransquantBypassEnableFlag)? 1:0 );
2660	}
2661	printf("WPP:%d ", (Int)m_useWeightedPred);
2662	printf("WPB:%d ", (Int)m_useWeightedBiPred);
2663	printf("PME:%d ", m_log2ParallelMergeLevel);
2664	printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d",
2665	m_iWaveFrontSynchro, m_iWaveFrontSubstreams);
2666	printf(" ScalingList:%d ", m_useScalingListId );
2667	printf("TMVPMode:%d ", m_TMVPModeId );
2668	#if ADAPTIVE_QP_SELECTION
2669	printf("AQpS:%d ", m_bUseAdaptQpSelect );
2670	#endif
2671
2672	printf(" SignBitHidingFlag:%d ", m_signHideFlag);
2673	printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 );
2674	#if H_3D_VSO
2675	printf("VSO:%d ", m_bUseVSO );
2676	printf("WVSO:%d ", m_bUseWVSO );
2677	#endif
2678	#if MTK_I0099_VPS_EX2
2679	printf("LimQtPredFlag:%d ", m_bLimQtPredFlag ? 1 : 0);
2680	#endif
2681	#if !MTK_I0099_VPS_EX2 \|\| MTK_I0099_FIX
2682	#if H_3D_QTLPC
2683	printf("QTL:%d ", m_bUseQTL);
2684	#if !MTK_I0099_VPS_EX2
2685	printf("PC:%d " , m_bUsePC );
2686	#endif
2687	#endif
2688	#endif
2689	#if H_3D_IV_MERGE
2690	printf("IvMvPred:%d %d", m_ivMvPredFlag[0] ? 1 : 0, m_ivMvPredFlag[1] ? 1 : 0);
2691	#if H_3D_SPIVMP
2692	printf(" SubPULog2Size:%d " , m_iSubPULog2Size );
2693	printf(" SubPUMPILog2Size:%d " , m_iSubPUMPILog2Size );
2694	#endif
2695	#endif
2696	#if H_3D_ARP
2697	printf(" ARP:%d ", m_uiUseAdvResPred );
2698	#endif
2699	#if H_3D_IC
2700	printf( "IlluCompEnable:%d ", m_abUseIC);
2701	printf ("IlluCompLowLatencyEnc:%d ", m_bUseLowLatencyICEnc);
2702	#endif
2703	#if H_3D_NBDV_REF
2704	printf("DepthRefinement:%d ", m_depthRefinementFlag );
2705	#endif
2706	#if H_3D_VSP
2707	printf("ViewSynthesisPred:%d ", m_viewSynthesisPredFlag );
2708	#endif
2709	#if H_3D
2710	printf("IvMvScaling:%d ", m_ivMvScalingFlag ? 1 : 0 );
2711	#endif
2712	#if H_3D_DIM
2713	printf("DMM:%d ", m_useDMM );
2714	#if SEPARATE_FLAG_I0085
2715	printf("IVP:%d ", m_useIVP );
2716	#endif
2717	printf("SDC:%d ", m_useSDC );
2718	printf("DLT:%d ", m_useDLT );
2719	#endif
2720	#if MTK_SINGLE_DEPTH_MODE_I0095
2721	printf("SingleDepthMode:%d ", m_useSingleDepthMode);
2722	#endif
2723	#if H_3D_INTER_SDC
2724	printf( "interSDC:%d ", m_bDepthInterSDCFlag ? 1 : 0 );
2725	#endif
2726	#if H_3D_DBBP
2727	printf("DBBP:%d ", m_bUseDBBP ? 1 : 0);
2728	#endif
2729	#if H_3D_IV_MERGE
2730	printf( "MPI:%d ", m_bMPIFlag ? 1 : 0 );
2731	#endif
2732	printf("\n\n");
2733
2734	fflush(stdout);
2735	}
2736
2737	Bool confirmPara(Bool bflag, const Char* message)
2738	{
2739	if (!bflag)
2740	return false;
2741
2742	printf("Error: %s\n",message);
2743	return true;
2744	}
2745
2746	//! \}

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

Download in other formats: