Context navigation

source: 3DVCSoftware/branches/HTM-12.0-dev1/source/App/TAppEncoder/TAppEncCfg.cpp @ 1054

Visit:

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

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

Download in other formats: