Context navigation

TAppEncCfg.cpp @ 1033

Visit:

Last change on this file since 1033 was 1033, checked in by tech, 10 years ago
Fix tickets #61 + #62.
Property svn:eol-style set to `native`
File size: 121.0 KB

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-11.2-dev0/source/App/TAppEncoder/TAppEncCfg.cpp @ 1033

Download in other formats: