Context navigation

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

Visit:

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

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

Download in other formats: