Context navigation

source: 3DVCSoftware/branches/HTM-12.1-dev0/source/App/TAppEncoder/TAppEncCfg.cpp @ 1079

Visit:

Last change on this file since 1079 was 1079, checked in by tech, 10 years ago
Removed MV-HEVC related macros part 5 .
Property svn:eol-style set to `native`
File size: 123.9 KB

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

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

Download in other formats: