Context navigation

TAppEncCfg.cpp @ 1017

Visit:

Last change on this file since 1017 was 1017, checked in by mediatek-htm, 10 years ago
JCT3V-I0099 FIX allow encoder only QTL
Property svn:eol-style set to `native`
File size: 120.4 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 MTK_I0099_VPS_EX2
764	("LimQtPredFlag", m_bLimQtPredFlag , true , "Use Predictive Coding with QTL" )
765	#endif
766	#if !MTK_I0099_VPS_EX2 \|\| MTK_I0099_FIX
767	#if H_3D_QTLPC
768	("QTL", m_bUseQTL , true , "Use depth Quadtree Limitation" )
769	#if !MTK_I0099_VPS_EX2
770	("PC", m_bUsePC , true , "Use Predictive Coding with QTL" )
771	#endif
772	#endif
773	#endif
774	#if H_3D_IV_MERGE
775	("IvMvPred", m_ivMvPredFlag , std::vector<Bool>(2, true) , "inter view motion prediction " )
776	#endif
777	#if H_3D_NBDV_REF
778	("DepthRefinement", m_depthRefinementFlag, true , "depth refinement by DoNBDV" )
779	#endif
780	#if H_3D_VSP
781	("ViewSynthesisPred", m_viewSynthesisPredFlag, true , "view synthesis prediction " )
782	#endif
783	#if H_3D
784	("IvMvScaling", m_ivMvScalingFlag , true , "inter view motion vector scaling" )
785	#endif
786	#endif //H_3D
787	;
788	#if H_MV
789	// parse coding structure
790	for( Int k = 0; k < MAX_NUM_LAYERS; k++ )
791	{
792	m_GOPListMvc.push_back( new GOPEntry[MAX_GOP + 1] );
793	if( k == 0 )
794	{
795	m_GOPListMvc[0][0].m_sliceType = 'I';
796	for( Int i = 1; i < MAX_GOP + 1; i++ )
797	{
798	std::ostringstream cOSS;
799	cOSS<<"Frame"<<i;
800	opts.addOptions()( cOSS.str(), m_GOPListMvc[k][i-1], GOPEntry() );
801	if ( i != 1 )
802	{
803	opts.opt_list.back()->opt->opt_duplicate = true;
804	}
805	}
806	}
807	else
808	{
809	std::ostringstream cOSS1;
810	cOSS1<<"FrameI"<<"_l"<<k;
811
812	opts.addOptions()(cOSS1.str(), m_GOPListMvc[k][MAX_GOP], GOPEntry());
813	if ( k > 1 )
814	{
815	opts.opt_list.back()->opt->opt_duplicate = true;
816	}
817
818
819	for( Int i = 1; i < MAX_GOP + 1; i++ )
820	{
821	std::ostringstream cOSS2;
822	cOSS2<<"Frame"<<i<<"_l"<<k;
823	opts.addOptions()(cOSS2.str(), m_GOPListMvc[k][i-1], GOPEntry());
824	if ( i != 1 \|\| k > 0 )
825	{
826	opts.opt_list.back()->opt->opt_duplicate = true;
827	}
828	}
829	}
830	}
831	#else
832	for(Int i=1; i<MAX_GOP+1; i++) {
833	std::ostringstream cOSS;
834	cOSS<<"Frame"<<i;
835	opts.addOptions()(cOSS.str(), m_GOPList[i-1], GOPEntry());
836	}
837	#endif
838	po::setDefaults(opts);
839	const list<const Char>& argv_unhandled = po::scanArgv(opts, argc, (const Char*) argv);
840
841	if(m_isField)
842	{
843	//Frame height
844	m_iSourceHeightOrg = m_iSourceHeight;
845	//Field height
846	m_iSourceHeight = m_iSourceHeight >> 1;
847	//number of fields to encode
848	m_framesToBeEncoded *= 2;
849	}
850
851	for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
852	{
853	fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
854	}
855
856	if (argc == 1 \|\| do_help)
857	{
858	/* argc == 1: no options have been specified */
859	po::doHelp(cout, opts);
860	return false;
861	}
862
863	/*
864	* Set any derived parameters
865	*/
866	/* convert std::string to c string for compatability */
867	#if !H_MV
868	m_pchInputFile = cfg_InputFile.empty() ? NULL : strdup(cfg_InputFile.c_str());
869	#endif
870	m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
871	#if !H_MV
872	m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str());
873	#endif
874	m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());
875
876	Char* pColumnWidth = cfg_ColumnWidth.empty() ? NULL: strdup(cfg_ColumnWidth.c_str());
877	Char* pRowHeight = cfg_RowHeight.empty() ? NULL : strdup(cfg_RowHeight.c_str());
878	if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
879	{
880	char *columnWidth;
881	int i=0;
882	m_pColumnWidth = new UInt[m_iNumColumnsMinus1];
883	columnWidth = strtok(pColumnWidth, " ,-");
884	while(columnWidth!=NULL)
885	{
886	if( i>=m_iNumColumnsMinus1 )
887	{
888	printf( "The number of columns whose width are defined is larger than the allowed number of columns.\n" );
889	exit( EXIT_FAILURE );
890	}
891	*( m_pColumnWidth + i ) = atoi( columnWidth );
892	columnWidth = strtok(NULL, " ,-");
893	i++;
894	}
895	if( i<m_iNumColumnsMinus1 )
896	{
897	printf( "The width of some columns is not defined.\n" );
898	exit( EXIT_FAILURE );
899	}
900	}
901	else
902	{
903	m_pColumnWidth = NULL;
904	}
905
906	if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
907	{
908	char *rowHeight;
909	int i=0;
910	m_pRowHeight = new UInt[m_iNumRowsMinus1];
911	rowHeight = strtok(pRowHeight, " ,-");
912	while(rowHeight!=NULL)
913	{
914	if( i>=m_iNumRowsMinus1 )
915	{
916	printf( "The number of rows whose height are defined is larger than the allowed number of rows.\n" );
917	exit( EXIT_FAILURE );
918	}
919	*( m_pRowHeight + i ) = atoi( rowHeight );
920	rowHeight = strtok(NULL, " ,-");
921	i++;
922	}
923	if( i<m_iNumRowsMinus1 )
924	{
925	printf( "The height of some rows is not defined.\n" );
926	exit( EXIT_FAILURE );
927	}
928	}
929	else
930	{
931	m_pRowHeight = NULL;
932	}
933	#if H_MV
934	free ( pColumnWidth );
935	free ( pRowHeight );
936	#endif
937	m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str());
938
939	/* rules for input, output and internal bitdepths as per help text */
940	if (!m_internalBitDepthY) { m_internalBitDepthY = m_inputBitDepthY; }
941	if (!m_internalBitDepthC) { m_internalBitDepthC = m_internalBitDepthY; }
942	if (!m_inputBitDepthC) { m_inputBitDepthC = m_inputBitDepthY; }
943	if (!m_outputBitDepthY) { m_outputBitDepthY = m_internalBitDepthY; }
944	if (!m_outputBitDepthC) { m_outputBitDepthC = m_internalBitDepthC; }
945
946	// TODO:ChromaFmt assumes 4:2:0 below
947	switch (m_conformanceMode)
948	{
949	case 0:
950	{
951	// no conformance or padding
952	m_confLeft = m_confRight = m_confTop = m_confBottom = 0;
953	m_aiPad[1] = m_aiPad[0] = 0;
954	break;
955	}
956	case 1:
957	{
958	// automatic padding to minimum CU size
959	Int minCuSize = m_uiMaxCUHeight >> (m_uiMaxCUDepth - 1);
960	if (m_iSourceWidth % minCuSize)
961	{
962	m_aiPad[0] = m_confRight = ((m_iSourceWidth / minCuSize) + 1) * minCuSize - m_iSourceWidth;
963	m_iSourceWidth += m_confRight;
964	}
965	if (m_iSourceHeight % minCuSize)
966	{
967	m_aiPad[1] = m_confBottom = ((m_iSourceHeight / minCuSize) + 1) * minCuSize - m_iSourceHeight;
968	m_iSourceHeight += m_confBottom;
969	if ( m_isField )
970	{
971	m_iSourceHeightOrg += m_confBottom << 1;
972	m_aiPad[1] = m_confBottom << 1;
973	}
974	}
975	if (m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0)
976	{
977	fprintf(stderr, "Error: picture width is not an integer multiple of the specified chroma subsampling\n");
978	exit(EXIT_FAILURE);
979	}
980	if (m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0)
981	{
982	fprintf(stderr, "Error: picture height is not an integer multiple of the specified chroma subsampling\n");
983	exit(EXIT_FAILURE);
984	}
985	break;
986	}
987	case 2:
988	{
989	//padding
990	m_iSourceWidth += m_aiPad[0];
991	m_iSourceHeight += m_aiPad[1];
992	m_confRight = m_aiPad[0];
993	m_confBottom = m_aiPad[1];
994	break;
995	}
996	case 3:
997	{
998	// conformance
999	if ((m_confLeft == 0) && (m_confRight == 0) && (m_confTop == 0) && (m_confBottom == 0))
1000	{
1001	fprintf(stderr, "Warning: Conformance window enabled, but all conformance window parameters set to zero\n");
1002	}
1003	if ((m_aiPad[1] != 0) \|\| (m_aiPad[0]!=0))
1004	{
1005	fprintf(stderr, "Warning: Conformance window enabled, padding parameters will be ignored\n");
1006	}
1007	m_aiPad[1] = m_aiPad[0] = 0;
1008	break;
1009	}
1010	}
1011
1012	// allocate slice-based dQP values
1013	#if H_MV
1014	xResizeVector( m_viewOrderIndex );
1015
1016	std::vector<Int> uniqueViewOrderIndices;
1017	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1018	{
1019	Bool isIn = false;
1020	for ( Int i = 0 ; i < uniqueViewOrderIndices.size(); i++ )
1021	{
1022	isIn = isIn \|\| ( m_viewOrderIndex[ layer ] == uniqueViewOrderIndices[ i ] );
1023	}
1024	if ( !isIn )
1025	{
1026	uniqueViewOrderIndices.push_back( m_viewOrderIndex[ layer ] );
1027	}
1028	}
1029	m_iNumberOfViews = (Int) uniqueViewOrderIndices.size();
1030
1031	#if H_3D
1032	xResizeVector( m_depthFlag );
1033	#endif
1034	xResizeVector( m_fQP );
1035
1036	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1037	{
1038	m_aidQP.push_back( new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ] );
1039	::memset( m_aidQP[layer], 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
1040
1041	// handling of floating-point QP values
1042	// if QP is not integer, sequence is split into two sections having QP and QP+1
1043	m_iQP.push_back((Int)( m_fQP[layer] ));
1044	if ( m_iQP[layer] < m_fQP[layer] )
1045	{
1046	Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP[layer] - m_iQP[layer])*m_framesToBeEncoded + 0.5 );
1047
1048	iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
1049	for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
1050	{
1051	m_aidQP[layer][i] = 1;
1052	}
1053	}
1054	}
1055
1056	xResizeVector( m_bLoopFilterDisable );
1057	xResizeVector( m_bUseSAO );
1058	xResizeVector( m_iIntraPeriod );
1059	xResizeVector( m_tilesInUseFlag );
1060	xResizeVector( m_loopFilterNotAcrossTilesFlag );
1061	xResizeVector( m_wppInUseFlag );
1062
1063	for (Int olsIdx = 0; olsIdx < m_vpsNumLayerSets + (Int) m_outputLayerSetIdx.size(); olsIdx++)
1064	{
1065	m_altOutputLayerFlag.push_back( false );
1066	}
1067	#else
1068	m_aidQP = new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ];
1069	::memset( m_aidQP, 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
1070
1071	// handling of floating-point QP values
1072	// if QP is not integer, sequence is split into two sections having QP and QP+1
1073	m_iQP = (Int)( m_fQP );
1074	if ( m_iQP < m_fQP )
1075	{
1076	Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP - m_iQP)*m_framesToBeEncoded + 0.5 );
1077
1078	iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
1079	for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
1080	{
1081	m_aidQP[i] = 1;
1082	}
1083	}
1084	#endif
1085
1086	// reading external dQP description from file
1087	if ( m_pchdQPFile )
1088	{
1089	FILE* fpt=fopen( m_pchdQPFile, "r" );
1090	if ( fpt )
1091	{
1092	#if H_MV
1093	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1094	{
1095	#endif
1096	Int iValue;
1097	Int iPOC = 0;
1098	while ( iPOC < m_framesToBeEncoded )
1099	{
1100	if ( fscanf(fpt, "%d", &iValue ) == EOF ) break;
1101	#if H_MV
1102	m_aidQP[layer][ iPOC ] = iValue;
1103	iPOC++;
1104	}
1105	#else
1106	m_aidQP[ iPOC ] = iValue;
1107	iPOC++;
1108	#endif
1109	}
1110	fclose(fpt);
1111	}
1112	}
1113	m_iWaveFrontSubstreams = m_iWaveFrontSynchro ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1;
1114
1115	if( m_toneMappingInfoSEIEnabled && !m_toneMapCancelFlag )
1116	{
1117	Char* pcStartOfCodedInterval = cfg_startOfCodedInterval.empty() ? NULL: strdup(cfg_startOfCodedInterval.c_str());
1118	Char* pcCodedPivotValue = cfg_codedPivotValue.empty() ? NULL: strdup(cfg_codedPivotValue.c_str());
1119	Char* pcTargetPivotValue = cfg_targetPivotValue.empty() ? NULL: strdup(cfg_targetPivotValue.c_str());
1120	if( m_toneMapModelId == 2 && pcStartOfCodedInterval )
1121	{
1122	char *startOfCodedInterval;
1123	UInt num = 1u<< m_toneMapTargetBitDepth;
1124	m_startOfCodedInterval = new Int[num];
1125	::memset( m_startOfCodedInterval, 0, sizeof(Int)*num );
1126	startOfCodedInterval = strtok(pcStartOfCodedInterval, " .");
1127	int i = 0;
1128	while( startOfCodedInterval && ( i < num ) )
1129	{
1130	m_startOfCodedInterval[i] = atoi( startOfCodedInterval );
1131	startOfCodedInterval = strtok(NULL, " .");
1132	i++;
1133	}
1134	}
1135	else
1136	{
1137	m_startOfCodedInterval = NULL;
1138	}
1139	if( ( m_toneMapModelId == 3 ) && ( m_numPivots > 0 ) )
1140	{
1141	if( pcCodedPivotValue && pcTargetPivotValue )
1142	{
1143	char *codedPivotValue;
1144	char *targetPivotValue;
1145	m_codedPivotValue = new Int[m_numPivots];
1146	m_targetPivotValue = new Int[m_numPivots];
1147	::memset( m_codedPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1148	::memset( m_targetPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1149	codedPivotValue = strtok(pcCodedPivotValue, " .");
1150	int i=0;
1151	while(codedPivotValue&&i<m_numPivots)
1152	{
1153	m_codedPivotValue[i] = atoi( codedPivotValue );
1154	codedPivotValue = strtok(NULL, " .");
1155	i++;
1156	}
1157	i=0;
1158	targetPivotValue = strtok(pcTargetPivotValue, " .");
1159	while(targetPivotValue&&i<m_numPivots)
1160	{
1161	m_targetPivotValue[i]= atoi( targetPivotValue );
1162	targetPivotValue = strtok(NULL, " .");
1163	i++;
1164	}
1165	}
1166	}
1167	else
1168	{
1169	m_codedPivotValue = NULL;
1170	m_targetPivotValue = NULL;
1171	}
1172	}
1173	#if H_3D
1174	// set global varibles
1175	xSetGlobal();
1176	#if H_3D_VSO
1177	// Table base optimization
1178	// Q&D
1179	Double adLambdaScaleTable[] =
1180	{ 0.031250, 0.031639, 0.032029, 0.032418, 0.032808, 0.033197, 0.033586, 0.033976, 0.034365, 0.034755,
1181	0.035144, 0.035533, 0.035923, 0.036312, 0.036702, 0.037091, 0.037480, 0.037870, 0.038259, 0.038648,
1182	0.039038, 0.039427, 0.039817, 0.040206, 0.040595, 0.040985, 0.041374, 0.041764, 0.042153, 0.042542,
1183	0.042932, 0.043321, 0.043711, 0.044100, 0.044194, 0.053033, 0.061872, 0.070711, 0.079550, 0.088388,
1184	0.117851, 0.147314, 0.176777, 0.235702, 0.294628, 0.353553, 0.471405, 0.589256, 0.707107, 0.707100,
1185	0.753550, 0.800000
1186	};
1187	if ( m_bUseVSO && m_bVSOLSTable )
1188	{
1189	Int firstDepthLayer = -1;
1190	for (Int layer = 0; layer < m_numberOfLayers; layer++ )
1191	{
1192	if ( m_depthFlag[ layer ])
1193	{
1194	firstDepthLayer = layer;
1195	break;
1196	}
1197	}
1198	AOT( firstDepthLayer == -1 );
1199	AOT( (m_iQP[firstDepthLayer] < 0) \|\| (m_iQP[firstDepthLayer] > 51));
1200	m_dLambdaScaleVSO *= adLambdaScaleTable[m_iQP[firstDepthLayer]];
1201	}
1202	#endif
1203	#if H_3D_VSO
1204	if ( m_bUseVSO && m_uiVSOMode == 4)
1205	{
1206	m_cRenModStrParser.setString( m_iNumberOfViews, m_pchVSOConfig );
1207	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1208	g_bitDepthY,
1209	(UInt)m_iCodedCamParPrecision,
1210	m_FrameSkip,
1211	(UInt)m_framesToBeEncoded,
1212	m_pchCameraParameterFile,
1213	m_pchBaseViewCameraNumbers,
1214	NULL,
1215	m_cRenModStrParser.getSynthViews(),
1216	LOG2_DISP_PREC_LUT );
1217	}
1218	else if ( m_bUseVSO && m_uiVSOMode != 4 )
1219	{
1220	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1221	g_bitDepthY,
1222	(UInt)m_iCodedCamParPrecision,
1223	m_FrameSkip,
1224	(UInt)m_framesToBeEncoded,
1225	m_pchCameraParameterFile,
1226	m_pchBaseViewCameraNumbers,
1227	m_pchVSOConfig,
1228	NULL,
1229	LOG2_DISP_PREC_LUT );
1230	}
1231	else
1232	{
1233	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1234	g_bitDepthY,
1235	(UInt) m_iCodedCamParPrecision,
1236	m_FrameSkip,
1237	(UInt) m_framesToBeEncoded,
1238	m_pchCameraParameterFile,
1239	m_pchBaseViewCameraNumbers,
1240	NULL,
1241	NULL,
1242	LOG2_DISP_PREC_LUT );
1243	}
1244	#else
1245	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1246	g_bitDepthY,
1247	(UInt) m_iCodedCamParPrecision,
1248	m_FrameSkip,
1249	(UInt) m_framesToBeEncoded,
1250	m_pchCameraParameterFile,
1251	m_pchBaseViewCameraNumbers,
1252	NULL,
1253	NULL,
1254	LOG2_DISP_PREC_LUT );
1255	#endif
1256	m_cCameraData.check( false, true );
1257	#endif
1258	// check validity of input parameters
1259	xCheckParameter();
1260
1261	#if !H_3D
1262	// set global varibles
1263	xSetGlobal();
1264	#endif
1265
1266	// print-out parameters
1267	xPrintParameter();
1268
1269	return true;
1270	}
1271	// ====================================================================================================================
1272	// Private member functions
1273	// ====================================================================================================================
1274
1275	Bool confirmPara(Bool bflag, const Char* message);
1276
1277	Void TAppEncCfg::xCheckParameter()
1278	{
1279	if (!m_decodedPictureHashSEIEnabled)
1280	{
1281	fprintf(stderr, "******************************************************************\n");
1282	fprintf(stderr, " WARNING: --SEIDecodedPictureHash is now disabled by default. \n");
1283	fprintf(stderr, " Automatic verification of decoded pictures by a \n");
1284	fprintf(stderr, " decoder requires this option to be enabled. \n");
1285	fprintf(stderr, "******************************************************************\n");
1286	}
1287	if( m_profile==Profile::NONE )
1288	{
1289	fprintf(stderr, "***************************************************************************\n");
1290	fprintf(stderr, " WARNING: For conforming bitstreams a valid Profile value must be set! \n");
1291	fprintf(stderr, "***************************************************************************\n");
1292	}
1293	if( m_level==Level::NONE )
1294	{
1295	fprintf(stderr, "***************************************************************************\n");
1296	fprintf(stderr, " WARNING: For conforming bitstreams a valid Level value must be set! \n");
1297	fprintf(stderr, "***************************************************************************\n");
1298	}
1299
1300	Bool check_failed = false; /* abort if there is a fatal configuration problem */
1301	#define xConfirmPara(a,b) check_failed \|= confirmPara(a,b)
1302	// check range of parameters
1303	xConfirmPara( m_inputBitDepthY < 8, "InputBitDepth must be at least 8" );
1304	xConfirmPara( m_inputBitDepthC < 8, "InputBitDepthC must be at least 8" );
1305	xConfirmPara( m_iFrameRate <= 0, "Frame rate must be more than 1" );
1306	xConfirmPara( m_framesToBeEncoded <= 0, "Total Number Of Frames encoded must be more than 0" );
1307	#if H_MV
1308	xConfirmPara( m_numberOfLayers > MAX_NUM_LAYER_IDS , "NumberOfLayers must be less than or equal to MAX_NUM_LAYER_IDS");
1309
1310
1311	xConfirmPara( m_layerIdInNuh[0] != 0 , "LayerIdInNuh must be 0 for the first layer. ");
1312	xConfirmPara( (m_layerIdInNuh.size()!=1) && (m_layerIdInNuh.size() < m_numberOfLayers) , "LayerIdInNuh must be given for all layers. ");
1313
1314	#if H_3D
1315	xConfirmPara( m_scalabilityMask != 2 && m_scalabilityMask != 3, "Scalability Mask must be equal to 2 or 3. ");
1316	#else
1317	xConfirmPara( m_scalabilityMask != 2 , "Scalability Mask must be equal to 2. ");
1318	#endif
1319
1320	#if H_3D
1321	if ( m_scalabilityMask & ( 1 << DEPTH_ID ) )
1322	{
1323	m_dimIds.push_back( m_depthFlag );
1324	}
1325	#endif
1326
1327	m_dimIds.push_back( m_viewOrderIndex );
1328	xConfirmPara( m_dimensionIdLen.size() < m_dimIds.size(), "DimensionIdLen must be given for all dimensions. " ); Int dimBitOffset[MAX_NUM_SCALABILITY_TYPES+1];
1329
1330	dimBitOffset[ 0 ] = 0;
1331	for (Int j = 1; j <= ((Int) m_dimIds.size() - m_splittingFlag ? 1 : 0); j++ )
1332	{
1333	dimBitOffset[ j ] = dimBitOffset[ j - 1 ] + m_dimensionIdLen[ j - 1];
1334	}
1335
1336	if ( m_splittingFlag )
1337	{
1338	dimBitOffset[ (Int) m_dimIds.size() ] = 6;
1339	}
1340
1341	for( Int j = 0; j < m_dimIds.size(); j++ )
1342	{
1343	xConfirmPara( m_dimIds[j].size() < m_numberOfLayers, "DimensionId must be given for all layers and all dimensions. ");
1344	xConfirmPara( (m_dimIds[j][0] != 0) , "DimensionId of layer 0 must be 0. " );
1345	xConfirmPara( m_dimensionIdLen[j] < 1 \|\| m_dimensionIdLen[j] > 8, "DimensionIdLen must be greater than 0 and less than 9 in all dimensions. " );
1346
1347
1348	for( Int i = 1; i < m_numberOfLayers; i++ )
1349	{
1350	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. " );
1351	if ( m_splittingFlag )
1352	{
1353	Int layerIdInNuh = (m_layerIdInNuh.size()!=1) ? m_layerIdInNuh[i] : i;
1354	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. ");
1355	}
1356	}
1357	}
1358
1359	for( Int i = 0; i < m_numberOfLayers; i++ )
1360	{
1361	for( Int j = 0; j < i; j++ )
1362	{
1363	Int numDiff = 0;
1364	Int lastDiff = -1;
1365	for( Int dim = 0; dim < m_dimIds.size(); dim++ )
1366	{
1367	if ( m_dimIds[dim][i] != m_dimIds[dim][j] )
1368	{
1369	numDiff ++;
1370	lastDiff = dim;
1371	}
1372	}
1373
1374	Bool allEqual = ( numDiff == 0 );
1375
1376	if ( allEqual )
1377	{
1378	printf( "\nError: Positions of Layers %d and %d are identical in scalability space\n", i, j);
1379	}
1380
1381	xConfirmPara( allEqual , "Each layer shall have a different position in scalability space." );
1382
1383	#if !H_3D_FCO
1384	if ( numDiff == 1 )
1385	{
1386	Bool inc = m_dimIds[ lastDiff ][ i ] > m_dimIds[ lastDiff ][ j ];
1387	Bool shallBeButIsNotIncreasing = ( !inc ) ;
1388	if ( shallBeButIsNotIncreasing )
1389	{
1390	printf( "\nError: Positions of Layers %d and %d is not increasing in dimension %d \n", i, j, lastDiff);
1391	}
1392	xConfirmPara( shallBeButIsNotIncreasing, "DimensionIds shall be increasing within one dimension. " );
1393	}
1394	#endif
1395	}
1396	}
1397
1398	/// ViewId
1399	xConfirmPara( m_viewId.size() != m_iNumberOfViews, "The number of ViewIds must be equal to the number of views." );
1400
1401	/// Layer sets
1402	xConfirmPara( m_vpsNumLayerSets < 0 \|\| m_vpsNumLayerSets > 1024, "VpsNumLayerSets must be greater than 0 and less than 1025. ") ;
1403	for( Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++ )
1404	{
1405	if (lsIdx == 0)
1406	{
1407	xConfirmPara( m_layerIdsInSets[lsIdx].size() != 1 \|\| m_layerIdsInSets[lsIdx][0] != 0 , "0-th layer shall only include layer 0. ");
1408	}
1409	for ( Int i = 0; i < m_layerIdsInSets[lsIdx].size(); i++ )
1410	{
1411	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" );
1412	}
1413	}
1414
1415	// Output layer sets
1416	xConfirmPara( m_outputLayerSetIdx.size() > 1024, "The number of output layer set indices must be less than 1025.") ;
1417	for (Int lsIdx = 0; lsIdx < m_outputLayerSetIdx.size(); lsIdx++)
1418	{
1419	Int refLayerSetIdx = m_outputLayerSetIdx[ lsIdx ];
1420	xConfirmPara( refLayerSetIdx < 0 \|\| refLayerSetIdx >= m_vpsNumLayerSets, "Output layer set idx must be greater or equal to 0 and less than the VpsNumLayerSets." );
1421
1422	for (Int i = 0; i < m_layerIdsInAddOutputLayerSet[ lsIdx ].size(); i++)
1423	{
1424	Bool isAlsoInLayerSet = false;
1425	for (Int j = 0; j < m_layerIdsInSets[ refLayerSetIdx ].size(); j++ )
1426	{
1427	if ( m_layerIdsInSets[ refLayerSetIdx ][ j ] == m_layerIdsInAddOutputLayerSet[ lsIdx ][ i ] )
1428	{
1429	isAlsoInLayerSet = true;
1430	break;
1431	}
1432	}
1433	xConfirmPara( !isAlsoInLayerSet, "All output layers of a output layer set be included in corresponding layer set.");
1434	}
1435	}
1436
1437	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." );
1438
1439	if( m_defaultOutputLayerIdc != 2 )
1440	{
1441	Bool anyDefaultOutputFlag = false;
1442	for (Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++)
1443	{
1444	anyDefaultOutputFlag = anyDefaultOutputFlag \|\| ( m_layerIdsInDefOutputLayerSet[lsIdx].size() != 0 );
1445	}
1446	printf( "\nWarning: Ignoring LayerIdsInDefOutputLayerSet parameters, since defaultTargetOuputLayerIdc is not equal 2.\n" );
1447	}
1448	else
1449	{
1450	for (Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++)
1451	{
1452	for (Int i = 0; i < m_layerIdsInDefOutputLayerSet[ lsIdx ].size(); i++)
1453	{
1454	Bool inLayerSetFlag = false;
1455	for (Int j = 0; j < m_layerIdsInSets[ lsIdx].size(); j++ )
1456	{
1457	if ( m_layerIdsInSets[ lsIdx ][ j ] == m_layerIdsInDefOutputLayerSet[ lsIdx ][ i ] )
1458	{
1459	inLayerSetFlag = true;
1460	break;
1461	}
1462	}
1463	xConfirmPara( !inLayerSetFlag, "All output layers of a output layer set must be included in corresponding layer set.");
1464	}
1465	}
1466	}
1467
1468	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" );
1469	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" );
1470
1471	// Layer Dependencies
1472	for (Int i = 0; i < m_numberOfLayers; i++ )
1473	{
1474	xConfirmPara( (i == 0) && m_directRefLayers[0].size() != 0, "Layer 0 shall not have reference layers." );
1475	xConfirmPara( m_directRefLayers[i].size() != m_dependencyTypes[ i ].size(), "Each reference layer shall have a reference type." );
1476	for (Int j = 0; j < m_directRefLayers[i].size(); j++)
1477	{
1478	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");
1479	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");
1480	}
1481	}
1482	#endif
1483	xConfirmPara( m_iGOPSize < 1 , "GOP Size must be greater or equal to 1" );
1484	xConfirmPara( m_iGOPSize > 1 && m_iGOPSize % 2, "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
1485	#if H_MV
1486	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1487	{
1488	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" );
1489	}
1490	#else
1491	xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) \|\| m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
1492	#endif
1493	#if ALLOW_RECOVERY_POINT_AS_RAP
1494	xConfirmPara( m_iDecodingRefreshType < 0 \|\| m_iDecodingRefreshType > 3, "Decoding Refresh Type must be comprised between 0 and 3 included" );
1495	if(m_iDecodingRefreshType == 3)
1496	{
1497	xConfirmPara( !m_recoveryPointSEIEnabled, "When using RecoveryPointSEI messages as RA points, recoveryPointSEI must be enabled" );
1498	}
1499	#else
1500	xConfirmPara( m_iDecodingRefreshType < 0 \|\| m_iDecodingRefreshType > 2, "Decoding Refresh Type must be equal to 0, 1 or 2" );
1501	#endif
1502	#if H_MV
1503	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1504	{
1505	xConfirmPara( m_iQP[layer] < -6 * (m_internalBitDepthY - 8) \|\| m_iQP[layer] > 51, "QP exceeds supported range (-QpBDOffsety to 51)" );
1506	}
1507	#else
1508	xConfirmPara( m_iQP < -6 * (m_internalBitDepthY - 8) \|\| m_iQP > 51, "QP exceeds supported range (-QpBDOffsety to 51)" );
1509	#endif
1510	xConfirmPara( m_loopFilterBetaOffsetDiv2 < -6 \|\| m_loopFilterBetaOffsetDiv2 > 6, "Loop Filter Beta Offset div. 2 exceeds supported range (-6 to 6)");
1511	xConfirmPara( m_loopFilterTcOffsetDiv2 < -6 \|\| m_loopFilterTcOffsetDiv2 > 6, "Loop Filter Tc Offset div. 2 exceeds supported range (-6 to 6)");
1512	xConfirmPara( m_iFastSearch < 0 \|\| m_iFastSearch > 2, "Fast Search Mode is not supported value (0:Full search 1:Diamond 2:PMVFAST)" );
1513	xConfirmPara( m_iSearchRange < 0 , "Search Range must be more than 0" );
1514	xConfirmPara( m_bipredSearchRange < 0 , "Search Range must be more than 0" );
1515	xConfirmPara( m_iMaxDeltaQP > 7, "Absolute Delta QP exceeds supported range (0 to 7)" );
1516	xConfirmPara( m_iMaxCuDQPDepth > m_uiMaxCUDepth - 1, "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
1517
1518	xConfirmPara( m_cbQpOffset < -12, "Min. Chroma Cb QP Offset is -12" );
1519	xConfirmPara( m_cbQpOffset > 12, "Max. Chroma Cb QP Offset is 12" );
1520	xConfirmPara( m_crQpOffset < -12, "Min. Chroma Cr QP Offset is -12" );
1521	xConfirmPara( m_crQpOffset > 12, "Max. Chroma Cr QP Offset is 12" );
1522
1523	xConfirmPara( m_iQPAdaptationRange <= 0, "QP Adaptation Range must be more than 0" );
1524	if (m_iDecodingRefreshType == 2)
1525	{
1526	#if H_MV
1527	for (Int i = 0; i < m_numberOfLayers; i++ )
1528	{
1529	xConfirmPara( m_iIntraPeriod[i] > 0 && m_iIntraPeriod[i] <= m_iGOPSize , "Intra period must be larger than GOP size for periodic IDR pictures");
1530	}
1531	#else
1532	xConfirmPara( m_iIntraPeriod > 0 && m_iIntraPeriod <= m_iGOPSize , "Intra period must be larger than GOP size for periodic IDR pictures");
1533	#endif
1534	}
1535	xConfirmPara( (m_uiMaxCUWidth >> m_uiMaxCUDepth) < 4, "Minimum partition width size should be larger than or equal to 8");
1536	xConfirmPara( (m_uiMaxCUHeight >> m_uiMaxCUDepth) < 4, "Minimum partition height size should be larger than or equal to 8");
1537	xConfirmPara( m_uiMaxCUWidth < 16, "Maximum partition width size should be larger than or equal to 16");
1538	xConfirmPara( m_uiMaxCUHeight < 16, "Maximum partition height size should be larger than or equal to 16");
1539	xConfirmPara( (m_iSourceWidth % (m_uiMaxCUWidth >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame width must be a multiple of the minimum CU size");
1540	xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame height must be a multiple of the minimum CU size");
1541
1542	xConfirmPara( m_uiQuadtreeTULog2MinSize < 2, "QuadtreeTULog2MinSize must be 2 or greater.");
1543	xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5, "QuadtreeTULog2MaxSize must be 5 or smaller.");
1544	xConfirmPara( (1<<m_uiQuadtreeTULog2MaxSize) > m_uiMaxCUWidth, "QuadtreeTULog2MaxSize must be log2(maxCUSize) or smaller.");
1545
1546	xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize, "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize.");
1547	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1548	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUHeight>>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1549	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUWidth >> m_uiMaxCUDepth ), "Minimum CU width must be greater than minimum transform size." );
1550	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." );
1551	xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1, "QuadtreeTUMaxDepthInter must be greater than or equal to 1" );
1552	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" );
1553	xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1, "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" );
1554	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" );
1555
1556	xConfirmPara( m_maxNumMergeCand < 1, "MaxNumMergeCand must be 1 or greater.");
1557	xConfirmPara( m_maxNumMergeCand > 5, "MaxNumMergeCand must be 5 or smaller.");
1558
1559	#if H_3D_ARP
1560	xConfirmPara( ( 0 != m_uiUseAdvResPred ) && ( 1 != m_uiUseAdvResPred ), "UseAdvResPred must be 0 or 1." );
1561	#endif
1562	#if H_3D_SPIVMP
1563	xConfirmPara( m_iSubPULog2Size < 3, "SubPULog2Size must be 3 or greater.");
1564	xConfirmPara( m_iSubPULog2Size > 6, "SubPULog2Size must be 6 or smaller.");
1565	xConfirmPara( (1<<m_iSubPULog2Size) > m_uiMaxCUWidth, "SubPULog2Size must be log2(maxCUSize) or smaller.");
1566
1567	xConfirmPara( m_iSubPUMPILog2Size < 3, "SubPUMPILog2Size must be 3 or greater.");
1568	xConfirmPara( m_iSubPUMPILog2Size > 6, "SubPUMPILog2Size must be 6 or smaller.");
1569	xConfirmPara( ( 1 << m_iSubPUMPILog2Size ) > m_uiMaxCUWidth, "SubPUMPILog2Size must be log2(maxCUSize) or smaller.");
1570	#endif
1571	#if ADAPTIVE_QP_SELECTION
1572	#if H_MV
1573	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1574	{
1575	xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP[layer] < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
1576	}
1577	#else
1578	xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
1579	#endif
1580	xConfirmPara( m_bUseAdaptQpSelect == true && (m_cbQpOffset !=0 \|\| m_crQpOffset != 0 ), "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
1581	#endif
1582
1583	if( m_usePCM)
1584	{
1585	xConfirmPara( m_uiPCMLog2MinSize < 3, "PCMLog2MinSize must be 3 or greater.");
1586	xConfirmPara( m_uiPCMLog2MinSize > 5, "PCMLog2MinSize must be 5 or smaller.");
1587	xConfirmPara( m_pcmLog2MaxSize > 5, "PCMLog2MaxSize must be 5 or smaller.");
1588	xConfirmPara( m_pcmLog2MaxSize < m_uiPCMLog2MinSize, "PCMLog2MaxSize must be equal to or greater than m_uiPCMLog2MinSize.");
1589	}
1590
1591	xConfirmPara( m_sliceMode < 0 \|\| m_sliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
1592	if (m_sliceMode!=0)
1593	{
1594	xConfirmPara( m_sliceArgument < 1 , "SliceArgument should be larger than or equal to 1" );
1595	}
1596	xConfirmPara( m_sliceSegmentMode < 0 \|\| m_sliceSegmentMode > 3, "SliceSegmentMode exceeds supported range (0 to 3)" );
1597	if (m_sliceSegmentMode!=0)
1598	{
1599	xConfirmPara( m_sliceSegmentArgument < 1 , "SliceSegmentArgument should be larger than or equal to 1" );
1600	}
1601
1602	Bool tileFlag = (m_iNumColumnsMinus1 > 0 \|\| m_iNumRowsMinus1 > 0 );
1603	xConfirmPara( tileFlag && m_iWaveFrontSynchro, "Tile and Wavefront can not be applied together");
1604
1605	//TODO:ChromaFmt assumes 4:2:0 below
1606	xConfirmPara( m_iSourceWidth % TComSPS::getWinUnitX(CHROMA_420) != 0, "Picture width must be an integer multiple of the specified chroma subsampling");
1607	xConfirmPara( m_iSourceHeight % TComSPS::getWinUnitY(CHROMA_420) != 0, "Picture height must be an integer multiple of the specified chroma subsampling");
1608
1609	xConfirmPara( m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0, "Horizontal padding must be an integer multiple of the specified chroma subsampling");
1610	xConfirmPara( m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0, "Vertical padding must be an integer multiple of the specified chroma subsampling");
1611
1612	xConfirmPara( m_confLeft % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left conformance window offset must be an integer multiple of the specified chroma subsampling");
1613	xConfirmPara( m_confRight % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right conformance window offset must be an integer multiple of the specified chroma subsampling");
1614	xConfirmPara( m_confTop % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top conformance window offset must be an integer multiple of the specified chroma subsampling");
1615	xConfirmPara( m_confBottom % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom conformance window offset must be an integer multiple of the specified chroma subsampling");
1616
1617	#if H_3D
1618	xConfirmPara( m_pchCameraParameterFile == 0 , "CameraParameterFile must be given");
1619	xConfirmPara( m_pchBaseViewCameraNumbers == 0 , "BaseViewCameraNumbers must be given" );
1620	#if BUG_FIX_TK65
1621	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" );
1622	#else
1623	xConfirmPara( ((UInt) m_numberOfLayers >> 1 ) != m_cCameraData.getBaseViewNumbers().size(), "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
1624	#endif
1625	xConfirmPara ( m_iCodedCamParPrecision < 0 \|\| m_iCodedCamParPrecision > 5, "CodedCamParsPrecision must be in range of 0..5" );
1626	#if H_3D_VSO
1627	if( m_bUseVSO )
1628	{
1629	xConfirmPara( m_pchVSOConfig == 0 , "VSO Setup string must be given");
1630	xConfirmPara( m_uiVSOMode > 4 , "VSO Mode must be less than 5");
1631	}
1632	#endif
1633	#endif
1634	// max CU width and height should be power of 2
1635	UInt ui = m_uiMaxCUWidth;
1636	while(ui)
1637	{
1638	ui >>= 1;
1639	if( (ui & 1) == 1)
1640	xConfirmPara( ui != 1 , "Width should be 2^n");
1641	}
1642	ui = m_uiMaxCUHeight;
1643	while(ui)
1644	{
1645	ui >>= 1;
1646	if( (ui & 1) == 1)
1647	xConfirmPara( ui != 1 , "Height should be 2^n");
1648	}
1649
1650	#if H_MV
1651	// validate that POC of same frame is identical across multiple layers
1652	Bool bErrorMvePoc = false;
1653	if( m_numberOfLayers > 1 )
1654	{
1655	for( Int k = 1; k < m_numberOfLayers; k++ )
1656	{
1657	for( Int i = 0; i < MAX_GOP; i++ )
1658	{
1659	if( m_GOPListMvc[k][i].m_POC != m_GOPListMvc[0][i].m_POC )
1660	{
1661	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 );
1662	bErrorMvePoc = true;
1663	}
1664	}
1665	}
1666	}
1667	xConfirmPara( bErrorMvePoc, "Invalid inter-layer POC structure given" );
1668
1669	// validate that baseview has no inter-view refs
1670	Bool bErrorIvpBase = false;
1671	for( Int i = 0; i < MAX_GOP; i++ )
1672	{
1673	if( m_GOPListMvc[0][i].m_numActiveRefLayerPics != 0 )
1674	{
1675	printf( "\nError: Frame%d inter_layer refs not available in layer 0\n", i );
1676	bErrorIvpBase = true;
1677	}
1678	}
1679	xConfirmPara( bErrorIvpBase, "Inter-layer refs not possible in base layer" );
1680
1681	// validate inter-view refs
1682	Bool bErrorIvpEnhV = false;
1683	if( m_numberOfLayers > 1 )
1684	{
1685	for( Int layer = 1; layer < m_numberOfLayers; layer++ )
1686	{
1687	for( Int i = 0; i < MAX_GOP+1; i++ )
1688	{
1689	GOPEntry gopEntry = m_GOPListMvc[layer][i];
1690	for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1691	{
1692	Int ilPredLayerIdc = gopEntry.m_interLayerPredLayerIdc[j];
1693	if( ilPredLayerIdc < 0 \|\| ilPredLayerIdc >= m_directRefLayers[layer].size() )
1694	{
1695	printf( "\nError: inter-layer ref idc %d is not available for Frame%d_l%d\n", gopEntry.m_interLayerPredLayerIdc[j], i, layer );
1696	bErrorIvpEnhV = true;
1697	}
1698	if( gopEntry.m_interViewRefPosL[0][j] < -1 \|\| gopEntry.m_interViewRefPosL[0][j] > gopEntry.m_numRefPicsActive )
1699	{
1700	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 );
1701	bErrorIvpEnhV = true;
1702	}
1703	if( gopEntry.m_interViewRefPosL[1][j] < -1 \|\| gopEntry.m_interViewRefPosL[1][j] > gopEntry.m_numRefPicsActive )
1704	{
1705	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 );
1706	bErrorIvpEnhV = true;
1707	}
1708	}
1709	if( i == MAX_GOP ) // inter-view refs at I pic position in base view
1710	{
1711	if( gopEntry.m_sliceType != 'B' && gopEntry.m_sliceType != 'P' && gopEntry.m_sliceType != 'I' )
1712	{
1713	printf( "\nError: slice type of FrameI_l%d must be equal to B or P or I\n", layer );
1714	bErrorIvpEnhV = true;
1715	}
1716
1717	if( gopEntry.m_POC != 0 )
1718	{
1719	printf( "\nError: POC %d not possible for FrameI_l%d, must be 0\n", gopEntry.m_POC, layer );
1720	bErrorIvpEnhV = true;
1721	}
1722
1723	if( gopEntry.m_temporalId != 0 )
1724	{
1725	printf( "\nWarning: Temporal id of FrameI_l%d must be 0 (cp. I-frame in base layer)\n", layer );
1726	gopEntry.m_temporalId = 0;
1727	}
1728
1729	if( gopEntry.m_numRefPics != 0 )
1730	{
1731	printf( "\nWarning: temporal references not possible for FrameI_l%d\n", layer );
1732	for( Int j = 0; j < m_GOPListMvc[layer][MAX_GOP].m_numRefPics; j++ )
1733	{
1734	gopEntry.m_referencePics[j] = 0;
1735	}
1736	gopEntry.m_numRefPics = 0;
1737	}
1738
1739	if( gopEntry.m_interRPSPrediction )
1740	{
1741	printf( "\nError: inter RPS prediction not possible for FrameI_l%d, must be 0\n", layer );
1742	bErrorIvpEnhV = true;
1743	}
1744
1745	if( gopEntry.m_sliceType == 'I' && gopEntry.m_numActiveRefLayerPics != 0 )
1746	{
1747	printf( "\nError: inter-layer prediction not possible for FrameI_l%d with slice type I, #IL_ref_pics must be 0\n", layer );
1748	bErrorIvpEnhV = true;
1749	}
1750
1751	if( gopEntry.m_numRefPicsActive > gopEntry.m_numActiveRefLayerPics )
1752	{
1753	gopEntry.m_numRefPicsActive = gopEntry.m_numActiveRefLayerPics;
1754	}
1755
1756	if( gopEntry.m_sliceType == 'P' )
1757	{
1758	if( gopEntry.m_numActiveRefLayerPics < 1 )
1759	{
1760	printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type P\n", layer );
1761	bErrorIvpEnhV = true;
1762	}
1763	else
1764	{
1765	for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1766	{
1767	if( gopEntry.m_interViewRefPosL[1][j] != -1 )
1768	{
1769	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 );
1770	bErrorIvpEnhV = true;
1771	}
1772	}
1773	}
1774	}
1775
1776	if( gopEntry.m_sliceType == 'B' && gopEntry.m_numActiveRefLayerPics < 1 )
1777	{
1778	printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type B\n", layer );
1779	bErrorIvpEnhV = true;
1780	}
1781	}
1782	}
1783	}
1784	}
1785	xConfirmPara( bErrorIvpEnhV, "Invalid inter-layer coding structure for enhancement layers given" );
1786
1787	// validate temporal coding structure
1788	if( !bErrorMvePoc && !bErrorIvpBase && !bErrorIvpEnhV )
1789	{
1790	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1791	{
1792	GOPEntry* m_GOPList = m_GOPListMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1793	Int& m_extraRPSs = m_extraRPSsMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1794	Int& m_maxTempLayer = m_maxTempLayerMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1795	Int* m_maxDecPicBuffering = m_maxDecPicBufferingMvc[layer]; // It is not a member, but this name helps avoiding code duplication !!!
1796	Int* m_numReorderPics = m_numReorderPicsMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1797	#endif
1798	/* if this is an intra-only sequence, ie IntraPeriod=1, don't verify the GOP structure
1799	* This permits the ability to omit a GOP structure specification */
1800	#if H_MV
1801	if (m_iIntraPeriod[layer] == 1 && m_GOPList[0].m_POC == -1) {
1802	#else
1803	if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
1804	#endif
1805	m_GOPList[0] = GOPEntry();
1806	m_GOPList[0].m_QPFactor = 1;
1807	m_GOPList[0].m_betaOffsetDiv2 = 0;
1808	m_GOPList[0].m_tcOffsetDiv2 = 0;
1809	m_GOPList[0].m_POC = 1;
1810	m_GOPList[0].m_numRefPicsActive = 4;
1811	}
1812
1813	Bool verifiedGOP=false;
1814	Bool errorGOP=false;
1815	Int checkGOP=1;
1816	Int numRefs = m_isField ? 2 : 1;
1817	Int refList[MAX_NUM_REF_PICS+1];
1818	refList[0]=0;
1819	if(m_isField)
1820	{
1821	refList[1] = 1;
1822	}
1823	Bool isOK[MAX_GOP];
1824	for(Int i=0; i<MAX_GOP; i++)
1825	{
1826	isOK[i]=false;
1827	}
1828	Int numOK=0;
1829	#if H_MV
1830	xConfirmPara( m_iIntraPeriod[layer] >=0&&(m_iIntraPeriod[layer]%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
1831	#else
1832	xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
1833	#endif
1834
1835	for(Int i=0; i<m_iGOPSize; i++)
1836	{
1837	if(m_GOPList[i].m_POC==m_iGOPSize)
1838	{
1839	xConfirmPara( m_GOPList[i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
1840	}
1841	}
1842
1843	#if H_MV
1844	if ( (m_iIntraPeriod[layer] != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable[layer]) )
1845	#else
1846	if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
1847	#endif
1848	{
1849	for(Int i=0; i<m_iGOPSize; i++)
1850	{
1851	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)" );
1852	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)" );
1853	}
1854	}
1855	m_extraRPSs=0;
1856	//start looping through frames in coding order until we can verify that the GOP structure is correct.
1857	while(!verifiedGOP&&!errorGOP)
1858	{
1859	Int curGOP = (checkGOP-1)%m_iGOPSize;
1860	Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC;
1861	if(m_GOPList[curGOP].m_POC<0)
1862	{
1863	#if H_MV
1864	printf("\nError: found fewer Reference Picture Sets than GOPSize for layer %d\n", layer );
1865	#else
1866	printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
1867	#endif
1868	errorGOP=true;
1869	}
1870	else
1871	{
1872	//check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
1873	Bool beforeI = false;
1874	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
1875	{
1876	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1877	if(absPOC < 0)
1878	{
1879	beforeI=true;
1880	}
1881	else
1882	{
1883	Bool found=false;
1884	for(Int j=0; j<numRefs; j++)
1885	{
1886	if(refList[j]==absPOC)
1887	{
1888	found=true;
1889	for(Int k=0; k<m_iGOPSize; k++)
1890	{
1891	if(absPOC%m_iGOPSize == m_GOPList[k].m_POC%m_iGOPSize)
1892	{
1893	if(m_GOPList[k].m_temporalId==m_GOPList[curGOP].m_temporalId)
1894	{
1895	m_GOPList[k].m_refPic = true;
1896	}
1897	m_GOPList[curGOP].m_usedByCurrPic[i]=m_GOPList[k].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1898	}
1899	}
1900	}
1901	}
1902	if(!found)
1903	{
1904	#if H_MV
1905	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);
1906	#else
1907	printf("\nError: ref pic %d is not available for GOP frame %d\n",m_GOPList[curGOP].m_referencePics[i],curGOP+1);
1908	#endif
1909	errorGOP=true;
1910	}
1911	}
1912	}
1913	if(!beforeI&&!errorGOP)
1914	{
1915	//all ref frames were present
1916	if(!isOK[curGOP])
1917	{
1918	numOK++;
1919	isOK[curGOP]=true;
1920	if(numOK==m_iGOPSize)
1921	{
1922	verifiedGOP=true;
1923	}
1924	}
1925	}
1926	else
1927	{
1928	//create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
1929	m_GOPList[m_iGOPSize+m_extraRPSs]=m_GOPList[curGOP];
1930	Int newRefs=0;
1931	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
1932	{
1933	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1934	if(absPOC>=0)
1935	{
1936	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
1937	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
1938	newRefs++;
1939	}
1940	}
1941	Int numPrefRefs = m_GOPList[curGOP].m_numRefPicsActive;
1942
1943	for(Int offset = -1; offset>-checkGOP; offset--)
1944	{
1945	//step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
1946	Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
1947	Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_GOPList[offGOP].m_POC;
1948	if(offPOC>=0&&m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId)
1949	{
1950	Bool newRef=false;
1951	for(Int i=0; i<numRefs; i++)
1952	{
1953	if(refList[i]==offPOC)
1954	{
1955	newRef=true;
1956	}
1957	}
1958	for(Int i=0; i<newRefs; i++)
1959	{
1960	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[i]==offPOC-curPOC)
1961	{
1962	newRef=false;
1963	}
1964	}
1965	if(newRef)
1966	{
1967	Int insertPoint=newRefs;
1968	//this picture can be added, find appropriate place in list and insert it.
1969	if(m_GOPList[offGOP].m_temporalId==m_GOPList[curGOP].m_temporalId)
1970	{
1971	m_GOPList[offGOP].m_refPic = true;
1972	}
1973	for(Int j=0; j<newRefs; j++)
1974	{
1975	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]<offPOC-curPOC\|\|m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]>0)
1976	{
1977	insertPoint = j;
1978	break;
1979	}
1980	}
1981	Int prev = offPOC-curPOC;
1982	Int prevUsed = m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1983	for(Int j=insertPoint; j<newRefs+1; j++)
1984	{
1985	Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j];
1986	Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j];
1987	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]=prev;
1988	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j]=prevUsed;
1989	prevUsed=newUsed;
1990	prev=newPrev;
1991	}
1992	newRefs++;
1993	}
1994	}
1995	if(newRefs>=numPrefRefs)
1996	{
1997	break;
1998	}
1999	}
2000	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics=newRefs;
2001	m_GOPList[m_iGOPSize+m_extraRPSs].m_POC = curPOC;
2002	if (m_extraRPSs == 0)
2003	{
2004	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 0;
2005	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = 0;
2006	}
2007	else
2008	{
2009	Int rIdx = m_iGOPSize + m_extraRPSs - 1;
2010	Int refPOC = m_GOPList[rIdx].m_POC;
2011	Int refPics = m_GOPList[rIdx].m_numRefPics;
2012	Int newIdc=0;
2013	for(Int i = 0; i<= refPics; i++)
2014	{
2015	Int deltaPOC = ((i != refPics)? m_GOPList[rIdx].m_referencePics[i] : 0); // check if the reference abs POC is >= 0
2016	Int absPOCref = refPOC+deltaPOC;
2017	Int refIdc = 0;
2018	for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics; j++)
2019	{
2020	if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j])
2021	{
2022	if (m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j])
2023	{
2024	refIdc = 1;
2025	}
2026	else
2027	{
2028	refIdc = 2;
2029	}
2030	}
2031	}
2032	m_GOPList[m_iGOPSize+m_extraRPSs].m_refIdc[newIdc]=refIdc;
2033	newIdc++;
2034	}
2035	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1;
2036	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = newIdc;
2037	m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC;
2038	}
2039	curGOP=m_iGOPSize+m_extraRPSs;
2040	m_extraRPSs++;
2041	}
2042	numRefs=0;
2043	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
2044	{
2045	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
2046	if(absPOC >= 0)
2047	{
2048	refList[numRefs]=absPOC;
2049	numRefs++;
2050	}
2051	}
2052	refList[numRefs]=curPOC;
2053	numRefs++;
2054	}
2055	checkGOP++;
2056	}
2057	xConfirmPara(errorGOP,"Invalid GOP structure given");
2058	m_maxTempLayer = 1;
2059	for(Int i=0; i<m_iGOPSize; i++)
2060	{
2061	if(m_GOPList[i].m_temporalId >= m_maxTempLayer)
2062	{
2063	m_maxTempLayer = m_GOPList[i].m_temporalId+1;
2064	}
2065	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");
2066	}
2067	for(Int i=0; i<MAX_TLAYER; i++)
2068	{
2069	m_numReorderPics[i] = 0;
2070	m_maxDecPicBuffering[i] = 1;
2071	}
2072	for(Int i=0; i<m_iGOPSize; i++)
2073	{
2074	if(m_GOPList[i].m_numRefPics+1 > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
2075	{
2076	m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1;
2077	}
2078	Int highestDecodingNumberWithLowerPOC = 0;
2079	for(Int j=0; j<m_iGOPSize; j++)
2080	{
2081	if(m_GOPList[j].m_POC <= m_GOPList[i].m_POC)
2082	{
2083	highestDecodingNumberWithLowerPOC = j;
2084	}
2085	}
2086	Int numReorder = 0;
2087	for(Int j=0; j<highestDecodingNumberWithLowerPOC; j++)
2088	{
2089	if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId &&
2090	m_GOPList[j].m_POC > m_GOPList[i].m_POC)
2091	{
2092	numReorder++;
2093	}
2094	}
2095	if(numReorder > m_numReorderPics[m_GOPList[i].m_temporalId])
2096	{
2097	m_numReorderPics[m_GOPList[i].m_temporalId] = numReorder;
2098	}
2099	}
2100	for(Int i=0; i<MAX_TLAYER-1; i++)
2101	{
2102	// a lower layer can not have higher value of m_numReorderPics than a higher layer
2103	if(m_numReorderPics[i+1] < m_numReorderPics[i])
2104	{
2105	m_numReorderPics[i+1] = m_numReorderPics[i];
2106	}
2107	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
2108	if(m_numReorderPics[i] > m_maxDecPicBuffering[i] - 1)
2109	{
2110	m_maxDecPicBuffering[i] = m_numReorderPics[i] + 1;
2111	}
2112	// a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
2113	if(m_maxDecPicBuffering[i+1] < m_maxDecPicBuffering[i])
2114	{
2115	m_maxDecPicBuffering[i+1] = m_maxDecPicBuffering[i];
2116	}
2117	}
2118
2119
2120	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
2121	if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1)
2122	{
2123	m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1] + 1;
2124	}
2125
2126	if(m_vuiParametersPresentFlag && m_bitstreamRestrictionFlag)
2127	{
2128	Int PicSizeInSamplesY = m_iSourceWidth * m_iSourceHeight;
2129	if(tileFlag)
2130	{
2131	Int maxTileWidth = 0;
2132	Int maxTileHeight = 0;
2133	Int widthInCU = (m_iSourceWidth % m_uiMaxCUWidth) ? m_iSourceWidth/m_uiMaxCUWidth + 1: m_iSourceWidth/m_uiMaxCUWidth;
2134	Int heightInCU = (m_iSourceHeight % m_uiMaxCUHeight) ? m_iSourceHeight/m_uiMaxCUHeight + 1: m_iSourceHeight/m_uiMaxCUHeight;
2135	if(m_iUniformSpacingIdr)
2136	{
2137	maxTileWidth = m_uiMaxCUWidth*((widthInCU+m_iNumColumnsMinus1)/(m_iNumColumnsMinus1+1));
2138	maxTileHeight = m_uiMaxCUHeight*((heightInCU+m_iNumRowsMinus1)/(m_iNumRowsMinus1+1));
2139	// if only the last tile-row is one treeblock higher than the others
2140	// the maxTileHeight becomes smaller if the last row of treeblocks has lower height than the others
2141	if(!((heightInCU-1)%(m_iNumRowsMinus1+1)))
2142	{
2143	maxTileHeight = maxTileHeight - m_uiMaxCUHeight + (m_iSourceHeight % m_uiMaxCUHeight);
2144	}
2145	// if only the last tile-column is one treeblock wider than the others
2146	// the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others
2147	if(!((widthInCU-1)%(m_iNumColumnsMinus1+1)))
2148	{
2149	maxTileWidth = maxTileWidth - m_uiMaxCUWidth + (m_iSourceWidth % m_uiMaxCUWidth);
2150	}
2151	}
2152	else // not uniform spacing
2153	{
2154	if(m_iNumColumnsMinus1<1)
2155	{
2156	maxTileWidth = m_iSourceWidth;
2157	}
2158	else
2159	{
2160	Int accColumnWidth = 0;
2161	for(Int col=0; col<(m_iNumColumnsMinus1); col++)
2162	{
2163	maxTileWidth = m_pColumnWidth[col]>maxTileWidth ? m_pColumnWidth[col]:maxTileWidth;
2164	accColumnWidth += m_pColumnWidth[col];
2165	}
2166	maxTileWidth = (widthInCU-accColumnWidth)>maxTileWidth ? m_uiMaxCUWidth(widthInCU-accColumnWidth):m_uiMaxCUWidthmaxTileWidth;
2167	}
2168	if(m_iNumRowsMinus1<1)
2169	{
2170	maxTileHeight = m_iSourceHeight;
2171	}
2172	else
2173	{
2174	Int accRowHeight = 0;
2175	for(Int row=0; row<(m_iNumRowsMinus1); row++)
2176	{
2177	maxTileHeight = m_pRowHeight[row]>maxTileHeight ? m_pRowHeight[row]:maxTileHeight;
2178	accRowHeight += m_pRowHeight[row];
2179	}
2180	maxTileHeight = (heightInCU-accRowHeight)>maxTileHeight ? m_uiMaxCUHeight(heightInCU-accRowHeight):m_uiMaxCUHeightmaxTileHeight;
2181	}
2182	}
2183	Int maxSizeInSamplesY = maxTileWidth*maxTileHeight;
2184	m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/maxSizeInSamplesY-4;
2185	}
2186	else if(m_iWaveFrontSynchro)
2187	{
2188	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/((2m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4;
2189	}
2190	else if(m_sliceMode == 1)
2191	{
2192	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/(m_sliceArgumentm_uiMaxCUWidth*m_uiMaxCUHeight)-4;
2193	}
2194	else
2195	{
2196	m_minSpatialSegmentationIdc = 0;
2197	}
2198	}
2199	xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
2200	xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
2201	xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
2202
2203	xConfirmPara( m_decodedPictureHashSEIEnabled<0 \|\| m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n");
2204
2205	if (m_toneMappingInfoSEIEnabled)
2206	{
2207	xConfirmPara( m_toneMapCodedDataBitDepth < 8 \|\| m_toneMapCodedDataBitDepth > 14 , "SEIToneMapCodedDataBitDepth must be in rage 8 to 14");
2208	xConfirmPara( m_toneMapTargetBitDepth < 1 \|\| (m_toneMapTargetBitDepth > 16 && m_toneMapTargetBitDepth < 255) , "SEIToneMapTargetBitDepth must be in rage 1 to 16 or equal to 255");
2209	xConfirmPara( m_toneMapModelId < 0 \|\| m_toneMapModelId > 4 , "SEIToneMapModelId must be in rage 0 to 4");
2210	xConfirmPara( m_cameraIsoSpeedValue == 0, "SEIToneMapCameraIsoSpeedValue shall not be equal to 0");
2211	xConfirmPara( m_exposureIndexValue == 0, "SEIToneMapExposureIndexValue shall not be equal to 0");
2212	xConfirmPara( m_extendedRangeWhiteLevel < 100, "SEIToneMapExtendedRangeWhiteLevel should be greater than or equal to 100");
2213	xConfirmPara( m_nominalBlackLevelLumaCodeValue >= m_nominalWhiteLevelLumaCodeValue, "SEIToneMapNominalWhiteLevelLumaCodeValue shall be greater than SEIToneMapNominalBlackLevelLumaCodeValue");
2214	xConfirmPara( m_extendedWhiteLevelLumaCodeValue < m_nominalWhiteLevelLumaCodeValue, "SEIToneMapExtendedWhiteLevelLumaCodeValue shall be greater than or equal to SEIToneMapNominalWhiteLevelLumaCodeValue");
2215	}
2216
2217	if ( m_RCEnableRateControl )
2218	{
2219	if ( m_RCForceIntraQP )
2220	{
2221	if ( m_RCInitialQP == 0 )
2222	{
2223	printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
2224	m_RCForceIntraQP = false;
2225	}
2226	}
2227	xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
2228	}
2229	#if H_MV
2230	// VPS VUI
2231	for(Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++ )
2232	{
2233	for (Int j = 0; j < MAX_TLAYER; j++)
2234	{
2235	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" );
2236	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" );
2237	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" );
2238	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" );
2239	}
2240	}
2241	// todo: replace value of 100 with requirement in spec
2242	for(Int i = 0; i < MAX_NUM_LAYERS; i++ )
2243	{
2244	for (Int j = 0; j < MAX_NUM_LAYERS; j++)
2245	{
2246	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" );
2247	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" );
2248	}
2249	}
2250	#endif
2251
2252	xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagForce, "CUTransquantBypassFlagForce cannot be 1 when TransquantBypassEnableFlag is 0");
2253
2254	xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2");
2255	if (m_framePackingSEIEnabled)
2256	{
2257	xConfirmPara(m_framePackingSEIType < 3 \|\| m_framePackingSEIType > 5 , "SEIFramePackingType must be in rage 3 to 5");
2258	}
2259
2260	#if H_MV
2261	}
2262	}
2263	// Check input parameters for Sub-bitstream property SEI message
2264	if( m_subBistreamPropSEIEnabled )
2265	{
2266	xConfirmPara(
2267	(this->m_sbPropNumAdditionalSubStreams != m_sbPropAvgBitRate.size() )
2268	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropHighestSublayerId.size() )
2269	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropMaxBitRate.size() )
2270	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropOutputLayerSetIdxToVps.size() )
2271	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropSubBitstreamMode.size()), "Some parameters of some sub-bitstream not defined");
2272
2273	for( Int i = 0; i < m_sbPropNumAdditionalSubStreams; i++ )
2274	{
2275	xConfirmPara( m_sbPropSubBitstreamMode[i] < 0 \|\| m_sbPropSubBitstreamMode[i] > 1, "Mode value should be 0 or 1" );
2276	xConfirmPara( m_sbPropHighestSublayerId[i] < 0 \|\| m_sbPropHighestSublayerId[i] > MAX_TLAYER-1, "Maximum sub-layer ID out of range" );
2277	xConfirmPara( m_sbPropOutputLayerSetIdxToVps[i] < 0 \|\| m_sbPropOutputLayerSetIdxToVps[i] >= MAX_VPS_OUTPUTLAYER_SETS, "OutputLayerSetIdxToVps should be within allowed range" );
2278	}
2279	}
2280	#endif
2281	#undef xConfirmPara
2282	if (check_failed)
2283	{
2284	exit(EXIT_FAILURE);
2285	}
2286	}
2287
2288	/** \todo use of global variables should be removed later
2289	*/
2290	Void TAppEncCfg::xSetGlobal()
2291	{
2292	// set max CU width & height
2293	g_uiMaxCUWidth = m_uiMaxCUWidth;
2294	g_uiMaxCUHeight = m_uiMaxCUHeight;
2295
2296	// compute actual CU depth with respect to config depth and max transform size
2297	g_uiAddCUDepth = 0;
2298	while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth ) ) ) g_uiAddCUDepth++;
2299
2300	m_uiMaxCUDepth += g_uiAddCUDepth;
2301	g_uiAddCUDepth++;
2302	g_uiMaxCUDepth = m_uiMaxCUDepth;
2303
2304	// set internal bit-depth and constants
2305	g_bitDepthY = m_internalBitDepthY;
2306	g_bitDepthC = m_internalBitDepthC;
2307
2308	g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
2309	g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
2310	}
2311
2312	Void TAppEncCfg::xPrintParameter()
2313	{
2314	printf("\n");
2315	#if H_MV
2316	for( Int layer = 0; layer < m_numberOfLayers; layer++)
2317	{
2318	printf("Input File %i : %s\n", layer, m_pchInputFileList[layer]);
2319	}
2320	#else
2321	printf("Input File : %s\n", m_pchInputFile );
2322	#endif
2323	printf("Bitstream File : %s\n", m_pchBitstreamFile );
2324	#if H_MV
2325	for( Int layer = 0; layer < m_numberOfLayers; layer++)
2326	{
2327	printf("Reconstruction File %i : %s\n", layer, m_pchReconFileList[layer]);
2328	}
2329	#else
2330	printf("Reconstruction File : %s\n", m_pchReconFile );
2331	#endif
2332	#if H_MV
2333	xPrintParaVector( "ViewIdVal" , m_viewId );
2334	xPrintParaVector( "ViewOrderIndex", m_viewOrderIndex );
2335	#endif
2336	#if H_3D
2337	xPrintParaVector( "DepthFlag", m_depthFlag );
2338	printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2339	#endif
2340	#if H_MV
2341	xPrintParaVector( "QP" , m_fQP );
2342	xPrintParaVector( "LoopFilterDisable", m_bLoopFilterDisable );
2343	xPrintParaVector( "SAO" , m_bUseSAO );
2344	#endif
2345	printf("Real Format : %dx%d %dHz\n", m_iSourceWidth - m_confLeft - m_confRight, m_iSourceHeight - m_confTop - m_confBottom, m_iFrameRate );
2346	printf("Internal Format : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
2347	if (m_isField)
2348	{
2349	printf("Frame/Field : Field based coding\n");
2350	printf("Field index : %u - %d (%d fields)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2351	if (m_isTopFieldFirst)
2352	{
2353	printf("Field Order : Top field first\n");
2354	}
2355	else
2356	{
2357	printf("Field Order : Bottom field first\n");
2358	}
2359	}
2360	else
2361	{
2362	printf("Frame/Field : Frame based coding\n");
2363	printf("Frame index : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2364	}
2365	printf("CU size / depth : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
2366	printf("RQT trans. size (min / max) : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
2367	printf("Max RQT depth inter : %d\n", m_uiQuadtreeTUMaxDepthInter);
2368	printf("Max RQT depth intra : %d\n", m_uiQuadtreeTUMaxDepthIntra);
2369	printf("Min PCM size : %d\n", 1 << m_uiPCMLog2MinSize);
2370	printf("Motion search range : %d\n", m_iSearchRange );
2371	#if H_MV
2372	xPrintParaVector( "Intra period", m_iIntraPeriod );
2373	#else
2374	printf("Intra period : %d\n", m_iIntraPeriod );
2375	#endif
2376	printf("Decoding refresh type : %d\n", m_iDecodingRefreshType );
2377	#if !H_MV
2378	printf("QP : %5.2f\n", m_fQP );
2379	#endif
2380	printf("Max dQP signaling depth : %d\n", m_iMaxCuDQPDepth);
2381
2382	printf("Cb QP Offset : %d\n", m_cbQpOffset );
2383	printf("Cr QP Offset : %d\n", m_crQpOffset);
2384
2385	printf("QP adaptation : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
2386	printf("GOP size : %d\n", m_iGOPSize );
2387	printf("Internal bit depth : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC );
2388	printf("PCM sample bit depth : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma );
2389	printf("RateControl : %d\n", m_RCEnableRateControl );
2390	if(m_RCEnableRateControl)
2391	{
2392	printf("TargetBitrate : %d\n", m_RCTargetBitrate );
2393	printf("KeepHierarchicalBit : %d\n", m_RCKeepHierarchicalBit );
2394	printf("LCULevelRC : %d\n", m_RCLCULevelRC );
2395	printf("UseLCUSeparateModel : %d\n", m_RCUseLCUSeparateModel );
2396	printf("InitialQP : %d\n", m_RCInitialQP );
2397	printf("ForceIntraQP : %d\n", m_RCForceIntraQP );
2398
2399	#if KWU_RC_MADPRED_E0227
2400	printf("Depth based MAD prediction : %d\n", m_depthMADPred);
2401	#endif
2402	#if KWU_RC_VIEWRC_E0227
2403	printf("View-wise Rate control : %d\n", m_viewWiseRateCtrl);
2404	if(m_viewWiseRateCtrl)
2405	{
2406
2407	printf("ViewWiseTargetBits : ");
2408	for (Int i = 0 ; i < m_iNumberOfViews ; i++)
2409	printf("%d ", m_viewTargetBits[i]);
2410	printf("\n");
2411	}
2412	else
2413	{
2414	printf("TargetBitrate : %d\n", m_RCTargetBitrate );
2415	}
2416	#endif
2417	}
2418	printf("Max Num Merge Candidates : %d\n", m_maxNumMergeCand);
2419	#if H_3D
2420	printf("BaseViewCameraNumbers : %s\n", m_pchBaseViewCameraNumbers );
2421	printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2422	#if H_3D_VSO
2423	printf("Force use of Lambda Scale : %d\n", m_bForceLambdaScaleVSO );
2424
2425	if ( m_bUseVSO )
2426	{
2427	printf("VSO Lambda Scale : %5.2f\n", m_dLambdaScaleVSO );
2428	printf("VSO Mode : %d\n", m_uiVSOMode );
2429	printf("VSO Config : %s\n", m_pchVSOConfig );
2430	printf("VSO Negative Distortion : %d\n", m_bAllowNegDist ? 1 : 0);
2431	printf("VSO LS Table : %d\n", m_bVSOLSTable ? 1 : 0);
2432	printf("VSO Estimated VSD : %d\n", m_bUseEstimatedVSD ? 1 : 0);
2433	printf("VSO Early Skip : %d\n", m_bVSOEarlySkip ? 1 : 0);
2434	if ( m_bUseWVSO )
2435	printf("Dist. Weights (VSO/VSD/SAD) : %d/%d/%d\n ", m_iVSOWeight, m_iVSDWeight, m_iDWeight );
2436	}
2437	#endif //HHI_VSO
2438	#endif //H_3D
2439	printf("\n");
2440	#if H_MV
2441	printf("TOOL CFG General: ");
2442	#else
2443	printf("TOOL CFG: ");
2444	#endif
2445	printf("IBD:%d ", g_bitDepthY > m_inputBitDepthY \|\| g_bitDepthC > m_inputBitDepthC);
2446	printf("HAD:%d ", m_bUseHADME );
2447	printf("RDQ:%d ", m_useRDOQ );
2448	printf("RDQTS:%d ", m_useRDOQTS );
2449	printf("RDpenalty:%d ", m_rdPenalty );
2450	printf("SQP:%d ", m_uiDeltaQpRD );
2451	printf("ASR:%d ", m_bUseASR );
2452	printf("FEN:%d ", m_bUseFastEnc );
2453	printf("ECU:%d ", m_bUseEarlyCU );
2454	printf("FDM:%d ", m_useFastDecisionForMerge );
2455	printf("CFM:%d ", m_bUseCbfFastMode );
2456	printf("ESD:%d ", m_useEarlySkipDetection );
2457	printf("RQT:%d ", 1 );
2458	printf("TransformSkip:%d ", m_useTransformSkip );
2459	printf("TransformSkipFast:%d ", m_useTransformSkipFast );
2460	printf("Slice: M=%d ", m_sliceMode);
2461	if (m_sliceMode!=0)
2462	{
2463	printf("A=%d ", m_sliceArgument);
2464	}
2465	printf("SliceSegment: M=%d ",m_sliceSegmentMode);
2466	if (m_sliceSegmentMode!=0)
2467	{
2468	printf("A=%d ", m_sliceSegmentArgument);
2469	}
2470	printf("CIP:%d ", m_bUseConstrainedIntraPred);
2471	#if !H_MV
2472	printf("SAO:%d ", (m_bUseSAO)?(1):(0));
2473	#endif
2474	printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
2475	if (m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagForce)
2476	{
2477	printf("TransQuantBypassEnabled: =1 ");
2478	}
2479	else
2480	{
2481	printf("TransQuantBypassEnabled:%d ", (m_TransquantBypassEnableFlag)? 1:0 );
2482	}
2483	printf("WPP:%d ", (Int)m_useWeightedPred);
2484	printf("WPB:%d ", (Int)m_useWeightedBiPred);
2485	printf("PME:%d ", m_log2ParallelMergeLevel);
2486	printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d",
2487	m_iWaveFrontSynchro, m_iWaveFrontSubstreams);
2488	printf(" ScalingList:%d ", m_useScalingListId );
2489	printf("TMVPMode:%d ", m_TMVPModeId );
2490	#if ADAPTIVE_QP_SELECTION
2491	printf("AQpS:%d ", m_bUseAdaptQpSelect );
2492	#endif
2493
2494	printf(" SignBitHidingFlag:%d ", m_signHideFlag);
2495	printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 );
2496	#if H_3D_VSO
2497	printf("VSO:%d ", m_bUseVSO );
2498	printf("WVSO:%d ", m_bUseWVSO );
2499	#endif
2500	#if MTK_I0099_VPS_EX2
2501	printf("LimQtPredFlag:%d ", m_bLimQtPredFlag ? 1 : 0);
2502	#endif
2503	#if !MTK_I0099_VPS_EX2 \|\| MTK_I0099_FIX
2504	#if H_3D_QTLPC
2505	printf("QTL:%d ", m_bUseQTL);
2506	#if !MTK_I0099_VPS_EX2
2507	printf("PC:%d " , m_bUsePC );
2508	#endif
2509	#endif
2510	#endif
2511	#if H_3D_IV_MERGE
2512	printf("IvMvPred:%d %d", m_ivMvPredFlag[0] ? 1 : 0, m_ivMvPredFlag[1] ? 1 : 0);
2513	#if H_3D_SPIVMP
2514	printf(" SubPULog2Size:%d " , m_iSubPULog2Size );
2515	printf(" SubPUMPILog2Size:%d " , m_iSubPUMPILog2Size );
2516	#endif
2517	#endif
2518	#if H_3D_ARP
2519	printf(" ARP:%d ", m_uiUseAdvResPred );
2520	#endif
2521	#if H_3D_IC
2522	printf( "IlluCompEnable:%d ", m_abUseIC);
2523	printf ("IlluCompLowLatencyEnc:%d ", m_bUseLowLatencyICEnc);
2524	#endif
2525	#if H_3D_NBDV_REF
2526	printf("DepthRefinement:%d ", m_depthRefinementFlag );
2527	#endif
2528	#if H_3D_VSP
2529	printf("ViewSynthesisPred:%d ", m_viewSynthesisPredFlag );
2530	#endif
2531	#if H_3D
2532	printf("IvMvScaling:%d ", m_ivMvScalingFlag ? 1 : 0 );
2533	#endif
2534	#if H_3D_DIM
2535	printf("DMM:%d ", m_useDMM );
2536	printf("SDC:%d ", m_useSDC );
2537	printf("DLT:%d ", m_useDLT );
2538	#endif
2539	#if H_3D_INTER_SDC
2540	printf( "interSDC:%d ", m_bDepthInterSDCFlag ? 1 : 0 );
2541	#endif
2542	#if H_3D_DBBP
2543	printf("DBBP:%d ", m_bUseDBBP ? 1 : 0);
2544	#endif
2545	#if H_3D_IV_MERGE
2546	printf( "MPI:%d ", m_bMPIFlag ? 1 : 0 );
2547	#endif
2548	printf("\n\n");
2549
2550	fflush(stdout);
2551	}
2552
2553	Bool confirmPara(Bool bflag, const Char* message)
2554	{
2555	if (!bflag)
2556	return false;
2557
2558	printf("Error: %s\n",message);
2559	return true;
2560	}
2561
2562	//! \}

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-11.2-dev2-MediaTek/source/App/TAppEncoder/TAppEncCfg.cpp @ 1017

Download in other formats: