Context navigation

source: 3DVCSoftware/tags/HTM-14.1/source/App/TAppEncoder/TAppEncCfg.cpp

Visit:

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

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

Download in other formats: