Context navigation

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

Visit:

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

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

Download in other formats: