Context navigation

source: 3DVCSoftware/branches/HTM-DEV-0.3-dev2/source/App/TAppEncoder/TAppEncCfg.cpp @ 534

Visit:

Last change on this file since 534 was 534, checked in by tech, 11 years ago
MergeMerged tags/HTM-DEV-1.0.
Property svn:eol-style set to `native`
File size: 111.4 KB

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

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

Download in other formats: