Context navigation

source: 3DVCSoftware/trunk/source/App/TAppEncoder/TAppEncCfg.cpp @ 622

Visit:

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

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

Download in other formats: