Context navigation

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

Visit:

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

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

Download in other formats: