Context navigation

TAppEncCfg.cpp @ 1015

Visit:

Last change on this file since 1015 was 1015, checked in by samsung-htm, 10 years ago
Integration of JCT3V-I0085: Separate enabling flag for intra-view prediction mode (DMM4)
Property svn:eol-style set to `native`
File size: 120.4 KB

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

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

JCT-3V 3D-HEVC

Context navigation

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

Download in other formats: