Context navigation

TAppEncCfg.cpp @ 983

Visit:

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

Integration of Single Depth Mode proposed in JCT3V-I0095.
The MACRO is "MTK_SINGLE_DEPTH_MODE_I0095".

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

Property svn:eol-style set to native

File size: 120.3 KB

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

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

JCT-3V 3D-HEVC

Context navigation

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

Download in other formats: