Context navigation

TAppEncCfg.cpp @ 902

Visit:

Last change on this file since 902 was 902, checked in by mediatek-htm, 10 years ago

Integration of low-latency IC encoding as proposed in JCT3V-H0086.
The MACRO is "MTK_LOW_LATENCY_IC_ENCODING_H0086"
The configuration files are modified by adding one additional control parameter "IlluCompLowLatencyEnc" which is set to 0 for CTC.

By Yi-Wen Chen (yiwen.chen@…)

Property svn:eol-style set to native

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-10.2-dev3-MediaTek/source/App/TAppEncoder/TAppEncCfg.cpp @ 902

Download in other formats: