Context navigation

TAppEncCfg.cpp @ 645

Visit:

Last change on this file since 645 was 638, checked in by kwu-htm, 11 years ago
Macro enclosed and cleaned-up
Property svn:eol-style set to `native`
File size: 114.0 KB

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-8.2-dev0-KWU/source/App/TAppEncoder/TAppEncCfg.cpp @ 645

Download in other formats: