Context navigation

TAppEncCfg.cpp @ 1271

Visit:

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-13.1-dev1-Qualcomm/source/App/TAppEncoder/TAppEncCfg.cpp @ 1271

Download in other formats: