Context navigation

TAppEncCfg.cpp @ 508

Visit:

Last change on this file since 508 was 508, checked in by tech, 11 years ago
Fixed compiler warning.
Property svn:eol-style set to `native`
File size: 109.5 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. " ); Int dimBitOffset[MAX_NUM_SCALABILITY_TYPES+1];
1316
1317	dimBitOffset[ 0 ] = 0;
1318	for (Int j = 1; j <= ((Int) m_dimIds.size() - m_splittingFlag ? 1 : 0); j++ )
1319	{
1320	dimBitOffset[ j ] = dimBitOffset[ j - 1 ] + m_dimensionIdLen[ j - 1];
1321	}
1322
1323	if ( m_splittingFlag )
1324	{
1325	dimBitOffset[ (Int) m_dimIds.size() ] = 6;
1326	}
1327
1328	for( Int j = 0; j < m_dimIds.size(); j++ )
1329	{
1330	xConfirmPara( m_dimIds[j].size() < m_numberOfLayers, "DimensionId must be given for all layers and all dimensions. ");
1331	xConfirmPara( ( j != viewDimPosition ) && (m_dimIds[j][0] != 0), "DimensionId of layer 0 must be 0. " );
1332	xConfirmPara( m_dimensionIdLen[j] < 1 \|\| m_dimensionIdLen[j] > 8, "DimensionIdLen must be greater than 0 and less than 9 in all dimensions. " );
1333
1334
1335	for( Int i = 1; i < m_numberOfLayers; i++ )
1336	{
1337	xConfirmPara( ( m_dimIds[j][i] < 0 ) \|\| ( m_dimIds[j][i] > ( ( 1 << m_dimensionIdLen[j] ) - 1 ) ) , "DimensionId shall be in the range of 0 to 2^DimensionIdLen - 1. " );
1338	if ( m_splittingFlag )
1339	{
1340	Int layerIdInNuh = (m_layerIdInNuh.size()!=1) ? m_layerIdInNuh[i] : i;
1341	xConfirmPara( ( ( layerIdInNuh & ( (1 << dimBitOffset[ j + 1 ] ) - 1) ) >> dimBitOffset[ j ] ) != m_dimIds[j][ i ] , "When Splitting Flag is equal to 1 dimension ids shall match values derived from layer ids. ");
1342	}
1343	}
1344	}
1345
1346	for( Int i = 0; i < m_numberOfLayers; i++ )
1347	{
1348	for( Int j = 0; j < i; j++ )
1349	{
1350	Int numDiff = 0;
1351	Int lastDiff = -1;
1352	for( Int dim = 0; dim < m_dimIds.size(); dim++ )
1353	{
1354	if ( m_dimIds[dim][i] != m_dimIds[dim][j] )
1355	{
1356	numDiff ++;
1357	lastDiff = dim;
1358	}
1359	}
1360
1361	Bool allEqual = ( numDiff == 0 );
1362
1363	if ( allEqual )
1364	{
1365	printf( "\nError: Positions of Layers %d and %d are identical in scalability space\n", i, j);
1366	}
1367
1368	xConfirmPara( allEqual , "Each layer shall have a different position in scalability space." );
1369
1370	if ( numDiff == 1 )
1371	{
1372	Bool inc = m_dimIds[ lastDiff ][ i ] > m_dimIds[ lastDiff ][ j ];
1373	Bool shallBeButIsNotIncreasing = ( !inc && ( lastDiff != viewDimPosition ) ) ;
1374	if ( shallBeButIsNotIncreasing )
1375	{
1376	printf( "\nError: Positions of Layers %d and %d is not increasing in dimension %d \n", i, j, lastDiff);
1377	}
1378	xConfirmPara( shallBeButIsNotIncreasing && ( lastDiff != viewDimPosition ), "DimensionIds shall be increasing within one dimension. " );
1379	}
1380	}
1381	}
1382
1383	/// Layer sets
1384	xConfirmPara( m_vpsNumLayerSets < 0 \|\| m_vpsNumLayerSets > 1024, "VpsNumLayerSets must be greater than 0 and less than 1025") ;
1385	for( Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++ )
1386	{
1387	if (lsIdx == 0)
1388	{
1389	xConfirmPara( m_layerIdsInSets[lsIdx].size() != 1 \|\| m_layerIdsInSets[lsIdx][0] != 0 , "0-th layer shall only include layer 0. ");
1390	}
1391	for ( Int i = 0; i < m_layerIdsInSets[lsIdx].size(); i++ )
1392	{
1393	xConfirmPara( m_layerIdsInSets[lsIdx][i] < 0 \|\| m_layerIdsInSets[lsIdx].size() >= MAX_NUM_LAYER_IDS, "LayerIdsInSet must be greater than and less than 64" );
1394	}
1395	}
1396
1397	// Output layer sets
1398	xConfirmPara( m_outputLayerSetIdx.size() > 1024, "The number of output layer set indices must be less than 1025.") ;
1399	for (Int lsIdx = 0; lsIdx < m_outputLayerSetIdx.size(); lsIdx++)
1400	{
1401	Int refLayerSetIdx = m_outputLayerSetIdx[ lsIdx ];
1402	xConfirmPara( refLayerSetIdx < 0 \|\| refLayerSetIdx >= m_vpsNumLayerSets, "Output layer set idx must be greater or equal to 0 and less than the VpsNumLayerSets." );
1403
1404	for (Int i = 0; i < m_layerIdsInAddOutputLayerSet[ lsIdx ].size(); i++)
1405	{
1406	Bool isAlsoInLayerSet = false;
1407	for (Int j = 0; j < m_layerIdsInSets[ refLayerSetIdx ].size(); j++ )
1408	{
1409	if ( m_layerIdsInSets[ refLayerSetIdx ][ j ] == m_layerIdsInAddOutputLayerSet[ lsIdx ][ i ] )
1410	{
1411	isAlsoInLayerSet = true;
1412	break;
1413	}
1414	}
1415	xConfirmPara( !isAlsoInLayerSet, "All output layers of a output layer set be included in corresponding layer set.");
1416	}
1417	}
1418	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" );
1419
1420	// Layer Dependencies
1421	for (Int i = 0; i < m_numberOfLayers; i++ )
1422	{
1423	xConfirmPara( (i == 0) && m_directRefLayers[0].size() != 0, "Layer 0 shall not have reference layers." );
1424	xConfirmPara( m_directRefLayers[i].size() != m_dependencyTypes[ i ].size(), "Each reference layer shall have a reference type." );
1425	for (Int j = 0; j < m_directRefLayers[i].size(); j++)
1426	{
1427	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");
1428	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");
1429	}
1430	}
1431	#endif
1432	xConfirmPara( m_iGOPSize < 1 , "GOP Size must be greater or equal to 1" );
1433	xConfirmPara( m_iGOPSize > 1 && m_iGOPSize % 2, "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
1434	xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) \|\| m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
1435	xConfirmPara( m_iDecodingRefreshType < 0 \|\| m_iDecodingRefreshType > 2, "Decoding Refresh Type must be equal to 0, 1 or 2" );
1436	#if H_MV
1437	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1438	{
1439	xConfirmPara( m_iQP[layer] < -6 * (m_internalBitDepthY - 8) \|\| m_iQP[layer] > 51, "QP exceeds supported range (-QpBDOffsety to 51)" );
1440	}
1441	#else
1442	xConfirmPara( m_iQP < -6 * (m_internalBitDepthY - 8) \|\| m_iQP > 51, "QP exceeds supported range (-QpBDOffsety to 51)" );
1443	#endif
1444	xConfirmPara( m_loopFilterBetaOffsetDiv2 < -13 \|\| m_loopFilterBetaOffsetDiv2 > 13, "Loop Filter Beta Offset div. 2 exceeds supported range (-13 to 13)");
1445	xConfirmPara( m_loopFilterTcOffsetDiv2 < -13 \|\| m_loopFilterTcOffsetDiv2 > 13, "Loop Filter Tc Offset div. 2 exceeds supported range (-13 to 13)");
1446	xConfirmPara( m_iFastSearch < 0 \|\| m_iFastSearch > 2, "Fast Search Mode is not supported value (0:Full search 1:Diamond 2:PMVFAST)" );
1447	xConfirmPara( m_iSearchRange < 0 , "Search Range must be more than 0" );
1448	xConfirmPara( m_bipredSearchRange < 0 , "Search Range must be more than 0" );
1449	xConfirmPara( m_iMaxDeltaQP > 7, "Absolute Delta QP exceeds supported range (0 to 7)" );
1450	xConfirmPara( m_iMaxCuDQPDepth > m_uiMaxCUDepth - 1, "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
1451
1452	xConfirmPara( m_cbQpOffset < -12, "Min. Chroma Cb QP Offset is -12" );
1453	xConfirmPara( m_cbQpOffset > 12, "Max. Chroma Cb QP Offset is 12" );
1454	xConfirmPara( m_crQpOffset < -12, "Min. Chroma Cr QP Offset is -12" );
1455	xConfirmPara( m_crQpOffset > 12, "Max. Chroma Cr QP Offset is 12" );
1456
1457	xConfirmPara( m_iQPAdaptationRange <= 0, "QP Adaptation Range must be more than 0" );
1458	if (m_iDecodingRefreshType == 2)
1459	{
1460	xConfirmPara( m_iIntraPeriod > 0 && m_iIntraPeriod <= m_iGOPSize , "Intra period must be larger than GOP size for periodic IDR pictures");
1461	}
1462	xConfirmPara( (m_uiMaxCUWidth >> m_uiMaxCUDepth) < 4, "Minimum partition width size should be larger than or equal to 8");
1463	xConfirmPara( (m_uiMaxCUHeight >> m_uiMaxCUDepth) < 4, "Minimum partition height size should be larger than or equal to 8");
1464	xConfirmPara( m_uiMaxCUWidth < 16, "Maximum partition width size should be larger than or equal to 16");
1465	xConfirmPara( m_uiMaxCUHeight < 16, "Maximum partition height size should be larger than or equal to 16");
1466	xConfirmPara( (m_iSourceWidth % (m_uiMaxCUWidth >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame width must be a multiple of the minimum CU size");
1467	xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame height must be a multiple of the minimum CU size");
1468
1469	xConfirmPara( m_uiQuadtreeTULog2MinSize < 2, "QuadtreeTULog2MinSize must be 2 or greater.");
1470	xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5, "QuadtreeTULog2MaxSize must be 5 or smaller.");
1471	xConfirmPara( (1<<m_uiQuadtreeTULog2MaxSize) > m_uiMaxCUWidth, "QuadtreeTULog2MaxSize must be log2(maxCUSize) or smaller.");
1472
1473	xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize, "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize.");
1474	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1475	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUHeight>>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1476	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUWidth >> m_uiMaxCUDepth ), "Minimum CU width must be greater than minimum transform size." );
1477	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." );
1478	xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1, "QuadtreeTUMaxDepthInter must be greater than or equal to 1" );
1479	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" );
1480	xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1, "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" );
1481	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" );
1482
1483	xConfirmPara( m_maxNumMergeCand < 1, "MaxNumMergeCand must be 1 or greater.");
1484	xConfirmPara( m_maxNumMergeCand > 5, "MaxNumMergeCand must be 5 or smaller.");
1485
1486	#if ADAPTIVE_QP_SELECTION
1487	#if H_MV
1488	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1489	{
1490	xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP[layer] < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
1491	}
1492	#else
1493	xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
1494	#endif
1495	xConfirmPara( m_bUseAdaptQpSelect == true && (m_cbQpOffset !=0 \|\| m_crQpOffset != 0 ), "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
1496	#endif
1497
1498	if( m_usePCM)
1499	{
1500	xConfirmPara( m_uiPCMLog2MinSize < 3, "PCMLog2MinSize must be 3 or greater.");
1501	xConfirmPara( m_uiPCMLog2MinSize > 5, "PCMLog2MinSize must be 5 or smaller.");
1502	xConfirmPara( m_pcmLog2MaxSize > 5, "PCMLog2MaxSize must be 5 or smaller.");
1503	xConfirmPara( m_pcmLog2MaxSize < m_uiPCMLog2MinSize, "PCMLog2MaxSize must be equal to or greater than m_uiPCMLog2MinSize.");
1504	}
1505
1506	xConfirmPara( m_sliceMode < 0 \|\| m_sliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
1507	if (m_sliceMode!=0)
1508	{
1509	xConfirmPara( m_sliceArgument < 1 , "SliceArgument should be larger than or equal to 1" );
1510	}
1511	xConfirmPara( m_sliceSegmentMode < 0 \|\| m_sliceSegmentMode > 3, "SliceSegmentMode exceeds supported range (0 to 3)" );
1512	if (m_sliceSegmentMode!=0)
1513	{
1514	xConfirmPara( m_sliceSegmentArgument < 1 , "SliceSegmentArgument should be larger than or equal to 1" );
1515	}
1516
1517	Bool tileFlag = (m_iNumColumnsMinus1 > 0 \|\| m_iNumRowsMinus1 > 0 );
1518	xConfirmPara( tileFlag && m_iWaveFrontSynchro, "Tile and Wavefront can not be applied together");
1519
1520	//TODO:ChromaFmt assumes 4:2:0 below
1521	xConfirmPara( m_iSourceWidth % TComSPS::getWinUnitX(CHROMA_420) != 0, "Picture width must be an integer multiple of the specified chroma subsampling");
1522	xConfirmPara( m_iSourceHeight % TComSPS::getWinUnitY(CHROMA_420) != 0, "Picture height must be an integer multiple of the specified chroma subsampling");
1523
1524	xConfirmPara( m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0, "Horizontal padding must be an integer multiple of the specified chroma subsampling");
1525	xConfirmPara( m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0, "Vertical padding must be an integer multiple of the specified chroma subsampling");
1526
1527	xConfirmPara( m_confLeft % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left conformance window offset must be an integer multiple of the specified chroma subsampling");
1528	xConfirmPara( m_confRight % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right conformance window offset must be an integer multiple of the specified chroma subsampling");
1529	xConfirmPara( m_confTop % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top conformance window offset must be an integer multiple of the specified chroma subsampling");
1530	xConfirmPara( m_confBottom % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom conformance window offset must be an integer multiple of the specified chroma subsampling");
1531
1532	#if H_3D
1533	xConfirmPara( m_pchCameraParameterFile == 0 , "CameraParameterFile must be given");
1534	xConfirmPara( m_pchBaseViewCameraNumbers == 0 , "BaseViewCameraNumbers must be given" );
1535	xConfirmPara( ((UInt) m_numberOfLayers >> 1 ) != m_cCameraData.getBaseViewNumbers().size(), "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
1536	xConfirmPara ( m_iCodedCamParPrecision < 0 \|\| m_iCodedCamParPrecision > 5, "CodedCamParsPrecision must be in range of 0..5" );
1537	#if H_3D_VSO
1538	if( m_bUseVSO )
1539	{
1540	xConfirmPara( m_pchVSOConfig == 0 , "VSO Setup string must be given");
1541	xConfirmPara( m_uiVSOMode > 4 , "VSO Mode must be less than 5");
1542	}
1543	#endif
1544	#endif
1545	// max CU width and height should be power of 2
1546	UInt ui = m_uiMaxCUWidth;
1547	while(ui)
1548	{
1549	ui >>= 1;
1550	if( (ui & 1) == 1)
1551	xConfirmPara( ui != 1 , "Width should be 2^n");
1552	}
1553	ui = m_uiMaxCUHeight;
1554	while(ui)
1555	{
1556	ui >>= 1;
1557	if( (ui & 1) == 1)
1558	xConfirmPara( ui != 1 , "Height should be 2^n");
1559	}
1560
1561	#if H_MV
1562	// validate that POC of same frame is identical across multiple layers
1563	Bool bErrorMvePoc = false;
1564	if( m_numberOfLayers > 1 )
1565	{
1566	for( Int k = 1; k < m_numberOfLayers; k++ )
1567	{
1568	for( Int i = 0; i < MAX_GOP; i++ )
1569	{
1570	if( m_GOPListMvc[k][i].m_POC != m_GOPListMvc[0][i].m_POC )
1571	{
1572	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 );
1573	bErrorMvePoc = true;
1574	}
1575	}
1576	}
1577	}
1578	xConfirmPara( bErrorMvePoc, "Invalid inter-layer POC structure given" );
1579
1580	// validate that baseview has no inter-view refs
1581	Bool bErrorIvpBase = false;
1582	for( Int i = 0; i < MAX_GOP; i++ )
1583	{
1584	if( m_GOPListMvc[0][i].m_numActiveRefLayerPics != 0 )
1585	{
1586	printf( "\nError: Frame%d inter_layer refs not available in layer 0\n", i );
1587	bErrorIvpBase = true;
1588	}
1589	}
1590	xConfirmPara( bErrorIvpBase, "Inter-layer refs not possible in base layer" );
1591
1592	// validate inter-view refs
1593	Bool bErrorIvpEnhV = false;
1594	if( m_numberOfLayers > 1 )
1595	{
1596	for( Int layer = 1; layer < m_numberOfLayers; layer++ )
1597	{
1598	for( Int i = 0; i < MAX_GOP+1; i++ )
1599	{
1600	GOPEntry gopEntry = m_GOPListMvc[layer][i];
1601	for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1602	{
1603	Int ilPredLayerIdc = gopEntry.m_interLayerPredLayerIdc[j];
1604	if( ilPredLayerIdc < 0 \|\| ilPredLayerIdc >= m_directRefLayers[layer].size() )
1605	{
1606	printf( "\nError: inter-layer ref idc %d is not available for Frame%d_l%d\n", gopEntry.m_interLayerPredLayerIdc[j], i, layer );
1607	bErrorIvpEnhV = true;
1608	}
1609	if( gopEntry.m_interViewRefPosL[0][j] < -1 \|\| gopEntry.m_interViewRefPosL[0][j] > gopEntry.m_numRefPicsActive )
1610	{
1611	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 );
1612	bErrorIvpEnhV = true;
1613	}
1614	if( gopEntry.m_interViewRefPosL[1][j] < -1 \|\| gopEntry.m_interViewRefPosL[1][j] > gopEntry.m_numRefPicsActive )
1615	{
1616	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 );
1617	bErrorIvpEnhV = true;
1618	}
1619	}
1620	if( i == MAX_GOP ) // inter-view refs at I pic position in base view
1621	{
1622	if( gopEntry.m_sliceType != 'B' && gopEntry.m_sliceType != 'P' && gopEntry.m_sliceType != 'I' )
1623	{
1624	printf( "\nError: slice type of FrameI_l%d must be equal to B or P or I\n", layer );
1625	bErrorIvpEnhV = true;
1626	}
1627
1628	if( gopEntry.m_POC != 0 )
1629	{
1630	printf( "\nError: POC %d not possible for FrameI_l%d, must be 0\n", gopEntry.m_POC, layer );
1631	bErrorIvpEnhV = true;
1632	}
1633
1634	if( gopEntry.m_temporalId != 0 )
1635	{
1636	printf( "\nWarning: Temporal id of FrameI_l%d must be 0 (cp. I-frame in base layer)\n", layer );
1637	gopEntry.m_temporalId = 0;
1638	}
1639
1640	if( gopEntry.m_numRefPics != 0 )
1641	{
1642	printf( "\nWarning: temporal references not possible for FrameI_l%d\n", layer );
1643	for( Int j = 0; j < m_GOPListMvc[layer][MAX_GOP].m_numRefPics; j++ )
1644	{
1645	gopEntry.m_referencePics[j] = 0;
1646	}
1647	gopEntry.m_numRefPics = 0;
1648	}
1649
1650	if( gopEntry.m_interRPSPrediction )
1651	{
1652	printf( "\nError: inter RPS prediction not possible for FrameI_l%d, must be 0\n", layer );
1653	bErrorIvpEnhV = true;
1654	}
1655
1656	if( gopEntry.m_sliceType == 'I' && gopEntry.m_numActiveRefLayerPics != 0 )
1657	{
1658	printf( "\nError: inter-layer prediction not possible for FrameI_l%d with slice type I, #IL_ref_pics must be 0\n", layer );
1659	bErrorIvpEnhV = true;
1660	}
1661
1662	if( gopEntry.m_numRefPicsActive > gopEntry.m_numActiveRefLayerPics )
1663	{
1664	gopEntry.m_numRefPicsActive = gopEntry.m_numActiveRefLayerPics;
1665	}
1666
1667	if( gopEntry.m_sliceType == 'P' )
1668	{
1669	if( gopEntry.m_numActiveRefLayerPics < 1 )
1670	{
1671	printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type P\n", layer );
1672	bErrorIvpEnhV = true;
1673	}
1674	else
1675	{
1676	for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1677	{
1678	if( gopEntry.m_interViewRefPosL[1][j] != -1 )
1679	{
1680	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 );
1681	bErrorIvpEnhV = true;
1682	}
1683	}
1684	}
1685	}
1686
1687	if( gopEntry.m_sliceType == 'B' && gopEntry.m_numActiveRefLayerPics < 1 )
1688	{
1689	printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type B\n", layer );
1690	bErrorIvpEnhV = true;
1691	}
1692	}
1693	}
1694	}
1695	}
1696	xConfirmPara( bErrorIvpEnhV, "Invalid inter-layer coding structure for enhancement layers given" );
1697
1698	// validate temporal coding structure
1699	if( !bErrorMvePoc && !bErrorIvpBase && !bErrorIvpEnhV )
1700	{
1701	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1702	{
1703	GOPEntry* m_GOPList = m_GOPListMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1704	Int& m_extraRPSs = m_extraRPSsMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1705	Int& m_maxTempLayer = m_maxTempLayerMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1706	Int* m_maxDecPicBuffering = m_maxDecPicBufferingMvc[layer]; // It is not a member, but this name helps avoiding code duplication !!!
1707	Int* m_numReorderPics = m_numReorderPicsMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1708	#endif
1709	/* if this is an intra-only sequence, ie IntraPeriod=1, don't verify the GOP structure
1710	* This permits the ability to omit a GOP structure specification */
1711	if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
1712	m_GOPList[0] = GOPEntry();
1713	m_GOPList[0].m_QPFactor = 1;
1714	m_GOPList[0].m_betaOffsetDiv2 = 0;
1715	m_GOPList[0].m_tcOffsetDiv2 = 0;
1716	m_GOPList[0].m_POC = 1;
1717	m_GOPList[0].m_numRefPicsActive = 4;
1718	}
1719
1720	Bool verifiedGOP=false;
1721	Bool errorGOP=false;
1722	Int checkGOP=1;
1723	Int numRefs = 1;
1724	Int refList[MAX_NUM_REF_PICS+1];
1725	refList[0]=0;
1726	Bool isOK[MAX_GOP];
1727	for(Int i=0; i<MAX_GOP; i++)
1728	{
1729	isOK[i]=false;
1730	}
1731	Int numOK=0;
1732	xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
1733
1734	for(Int i=0; i<m_iGOPSize; i++)
1735	{
1736	if(m_GOPList[i].m_POC==m_iGOPSize)
1737	{
1738	xConfirmPara( m_GOPList[i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
1739	}
1740	}
1741
1742	#if H_MV
1743	if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable[layer]) )
1744	#else
1745	if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
1746	#endif
1747	{
1748	for(Int i=0; i<m_iGOPSize; i++)
1749	{
1750	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)" );
1751	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)" );
1752	}
1753	}
1754	m_extraRPSs=0;
1755	//start looping through frames in coding order until we can verify that the GOP structure is correct.
1756	while(!verifiedGOP&&!errorGOP)
1757	{
1758	Int curGOP = (checkGOP-1)%m_iGOPSize;
1759	Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC;
1760	if(m_GOPList[curGOP].m_POC<0)
1761	{
1762	#if H_MV
1763	printf("\nError: found fewer Reference Picture Sets than GOPSize for layer %d\n", layer );
1764	#else
1765	printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
1766	#endif
1767	errorGOP=true;
1768	}
1769	else
1770	{
1771	//check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
1772	Bool beforeI = false;
1773	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
1774	{
1775	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1776	if(absPOC < 0)
1777	{
1778	beforeI=true;
1779	}
1780	else
1781	{
1782	Bool found=false;
1783	for(Int j=0; j<numRefs; j++)
1784	{
1785	if(refList[j]==absPOC)
1786	{
1787	found=true;
1788	for(Int k=0; k<m_iGOPSize; k++)
1789	{
1790	if(absPOC%m_iGOPSize == m_GOPList[k].m_POC%m_iGOPSize)
1791	{
1792	if(m_GOPList[k].m_temporalId==m_GOPList[curGOP].m_temporalId)
1793	{
1794	m_GOPList[k].m_refPic = true;
1795	}
1796	m_GOPList[curGOP].m_usedByCurrPic[i]=m_GOPList[k].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1797	}
1798	}
1799	}
1800	}
1801	if(!found)
1802	{
1803	#if H_MV
1804	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);
1805	#else
1806	printf("\nError: ref pic %d is not available for GOP frame %d\n",m_GOPList[curGOP].m_referencePics[i],curGOP+1);
1807	#endif
1808	errorGOP=true;
1809	}
1810	}
1811	}
1812	if(!beforeI&&!errorGOP)
1813	{
1814	//all ref frames were present
1815	if(!isOK[curGOP])
1816	{
1817	numOK++;
1818	isOK[curGOP]=true;
1819	if(numOK==m_iGOPSize)
1820	{
1821	verifiedGOP=true;
1822	}
1823	}
1824	}
1825	else
1826	{
1827	//create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
1828	m_GOPList[m_iGOPSize+m_extraRPSs]=m_GOPList[curGOP];
1829	Int newRefs=0;
1830	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
1831	{
1832	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1833	if(absPOC>=0)
1834	{
1835	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
1836	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
1837	newRefs++;
1838	}
1839	}
1840	Int numPrefRefs = m_GOPList[curGOP].m_numRefPicsActive;
1841
1842	for(Int offset = -1; offset>-checkGOP; offset--)
1843	{
1844	//step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
1845	Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
1846	Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_GOPList[offGOP].m_POC;
1847	if(offPOC>=0&&m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId)
1848	{
1849	Bool newRef=false;
1850	for(Int i=0; i<numRefs; i++)
1851	{
1852	if(refList[i]==offPOC)
1853	{
1854	newRef=true;
1855	}
1856	}
1857	for(Int i=0; i<newRefs; i++)
1858	{
1859	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[i]==offPOC-curPOC)
1860	{
1861	newRef=false;
1862	}
1863	}
1864	if(newRef)
1865	{
1866	Int insertPoint=newRefs;
1867	//this picture can be added, find appropriate place in list and insert it.
1868	if(m_GOPList[offGOP].m_temporalId==m_GOPList[curGOP].m_temporalId)
1869	{
1870	m_GOPList[offGOP].m_refPic = true;
1871	}
1872	for(Int j=0; j<newRefs; j++)
1873	{
1874	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]<offPOC-curPOC\|\|m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]>0)
1875	{
1876	insertPoint = j;
1877	break;
1878	}
1879	}
1880	Int prev = offPOC-curPOC;
1881	Int prevUsed = m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1882	for(Int j=insertPoint; j<newRefs+1; j++)
1883	{
1884	Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j];
1885	Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j];
1886	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]=prev;
1887	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j]=prevUsed;
1888	prevUsed=newUsed;
1889	prev=newPrev;
1890	}
1891	newRefs++;
1892	}
1893	}
1894	if(newRefs>=numPrefRefs)
1895	{
1896	break;
1897	}
1898	}
1899	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics=newRefs;
1900	m_GOPList[m_iGOPSize+m_extraRPSs].m_POC = curPOC;
1901	if (m_extraRPSs == 0)
1902	{
1903	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 0;
1904	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = 0;
1905	}
1906	else
1907	{
1908	Int rIdx = m_iGOPSize + m_extraRPSs - 1;
1909	Int refPOC = m_GOPList[rIdx].m_POC;
1910	Int refPics = m_GOPList[rIdx].m_numRefPics;
1911	Int newIdc=0;
1912	for(Int i = 0; i<= refPics; i++)
1913	{
1914	Int deltaPOC = ((i != refPics)? m_GOPList[rIdx].m_referencePics[i] : 0); // check if the reference abs POC is >= 0
1915	Int absPOCref = refPOC+deltaPOC;
1916	Int refIdc = 0;
1917	for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics; j++)
1918	{
1919	if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j])
1920	{
1921	if (m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j])
1922	{
1923	refIdc = 1;
1924	}
1925	else
1926	{
1927	refIdc = 2;
1928	}
1929	}
1930	}
1931	m_GOPList[m_iGOPSize+m_extraRPSs].m_refIdc[newIdc]=refIdc;
1932	newIdc++;
1933	}
1934	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1;
1935	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = newIdc;
1936	m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC;
1937	}
1938	curGOP=m_iGOPSize+m_extraRPSs;
1939	m_extraRPSs++;
1940	}
1941	numRefs=0;
1942	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
1943	{
1944	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1945	if(absPOC >= 0)
1946	{
1947	refList[numRefs]=absPOC;
1948	numRefs++;
1949	}
1950	}
1951	refList[numRefs]=curPOC;
1952	numRefs++;
1953	}
1954	checkGOP++;
1955	}
1956	xConfirmPara(errorGOP,"Invalid GOP structure given");
1957	m_maxTempLayer = 1;
1958	for(Int i=0; i<m_iGOPSize; i++)
1959	{
1960	if(m_GOPList[i].m_temporalId >= m_maxTempLayer)
1961	{
1962	m_maxTempLayer = m_GOPList[i].m_temporalId+1;
1963	}
1964	xConfirmPara(m_GOPList[i].m_sliceType!='B'&&m_GOPList[i].m_sliceType!='P', "Slice type must be equal to B or P");
1965	}
1966	for(Int i=0; i<MAX_TLAYER; i++)
1967	{
1968	m_numReorderPics[i] = 0;
1969	#if L0323_DPB
1970	m_maxDecPicBuffering[i] = 1;
1971	#else
1972	m_maxDecPicBuffering[i] = 0;
1973	#endif
1974	}
1975	for(Int i=0; i<m_iGOPSize; i++)
1976	{
1977	#if L0323_DPB
1978	if(m_GOPList[i].m_numRefPics+1 > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
1979	#else
1980	if(m_GOPList[i].m_numRefPics > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
1981	#endif
1982	{
1983	#if L0323_DPB
1984	m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1;
1985	#else
1986	m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics;
1987	#endif
1988	}
1989	Int highestDecodingNumberWithLowerPOC = 0;
1990	for(Int j=0; j<m_iGOPSize; j++)
1991	{
1992	if(m_GOPList[j].m_POC <= m_GOPList[i].m_POC)
1993	{
1994	highestDecodingNumberWithLowerPOC = j;
1995	}
1996	}
1997	Int numReorder = 0;
1998	for(Int j=0; j<highestDecodingNumberWithLowerPOC; j++)
1999	{
2000	if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId &&
2001	m_GOPList[j].m_POC > m_GOPList[i].m_POC)
2002	{
2003	numReorder++;
2004	}
2005	}
2006	if(numReorder > m_numReorderPics[m_GOPList[i].m_temporalId])
2007	{
2008	m_numReorderPics[m_GOPList[i].m_temporalId] = numReorder;
2009	}
2010	}
2011	for(Int i=0; i<MAX_TLAYER-1; i++)
2012	{
2013	// a lower layer can not have higher value of m_numReorderPics than a higher layer
2014	if(m_numReorderPics[i+1] < m_numReorderPics[i])
2015	{
2016	m_numReorderPics[i+1] = m_numReorderPics[i];
2017	}
2018	#if L0323_DPB
2019	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
2020	if(m_numReorderPics[i] > m_maxDecPicBuffering[i] - 1)
2021	{
2022	m_maxDecPicBuffering[i] = m_numReorderPics[i] + 1;
2023	}
2024	#else
2025	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive
2026	if(m_numReorderPics[i] > m_maxDecPicBuffering[i])
2027	{
2028	m_maxDecPicBuffering[i] = m_numReorderPics[i];
2029	}
2030	#endif
2031	// a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
2032	if(m_maxDecPicBuffering[i+1] < m_maxDecPicBuffering[i])
2033	{
2034	m_maxDecPicBuffering[i+1] = m_maxDecPicBuffering[i];
2035	}
2036	}
2037
2038
2039	#if L0323_DPB
2040	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
2041	if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1)
2042	{
2043	m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1] + 1;
2044	}
2045	#else
2046	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive
2047	if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1])
2048	{
2049	m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1];
2050	}
2051	#endif
2052
2053	if(m_vuiParametersPresentFlag && m_bitstreamRestrictionFlag)
2054	{
2055	Int PicSizeInSamplesY = m_iSourceWidth * m_iSourceHeight;
2056	if(tileFlag)
2057	{
2058	Int maxTileWidth = 0;
2059	Int maxTileHeight = 0;
2060	Int widthInCU = (m_iSourceWidth % m_uiMaxCUWidth) ? m_iSourceWidth/m_uiMaxCUWidth + 1: m_iSourceWidth/m_uiMaxCUWidth;
2061	Int heightInCU = (m_iSourceHeight % m_uiMaxCUHeight) ? m_iSourceHeight/m_uiMaxCUHeight + 1: m_iSourceHeight/m_uiMaxCUHeight;
2062	if(m_iUniformSpacingIdr)
2063	{
2064	maxTileWidth = m_uiMaxCUWidth*((widthInCU+m_iNumColumnsMinus1)/(m_iNumColumnsMinus1+1));
2065	maxTileHeight = m_uiMaxCUHeight*((heightInCU+m_iNumRowsMinus1)/(m_iNumRowsMinus1+1));
2066	// if only the last tile-row is one treeblock higher than the others
2067	// the maxTileHeight becomes smaller if the last row of treeblocks has lower height than the others
2068	if(!((heightInCU-1)%(m_iNumRowsMinus1+1)))
2069	{
2070	maxTileHeight = maxTileHeight - m_uiMaxCUHeight + (m_iSourceHeight % m_uiMaxCUHeight);
2071	}
2072	// if only the last tile-column is one treeblock wider than the others
2073	// the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others
2074	if(!((widthInCU-1)%(m_iNumColumnsMinus1+1)))
2075	{
2076	maxTileWidth = maxTileWidth - m_uiMaxCUWidth + (m_iSourceWidth % m_uiMaxCUWidth);
2077	}
2078	}
2079	else // not uniform spacing
2080	{
2081	if(m_iNumColumnsMinus1<1)
2082	{
2083	maxTileWidth = m_iSourceWidth;
2084	}
2085	else
2086	{
2087	Int accColumnWidth = 0;
2088	for(Int col=0; col<(m_iNumColumnsMinus1); col++)
2089	{
2090	maxTileWidth = m_pColumnWidth[col]>maxTileWidth ? m_pColumnWidth[col]:maxTileWidth;
2091	accColumnWidth += m_pColumnWidth[col];
2092	}
2093	maxTileWidth = (widthInCU-accColumnWidth)>maxTileWidth ? m_uiMaxCUWidth(widthInCU-accColumnWidth):m_uiMaxCUWidthmaxTileWidth;
2094	}
2095	if(m_iNumRowsMinus1<1)
2096	{
2097	maxTileHeight = m_iSourceHeight;
2098	}
2099	else
2100	{
2101	Int accRowHeight = 0;
2102	for(Int row=0; row<(m_iNumRowsMinus1); row++)
2103	{
2104	maxTileHeight = m_pRowHeight[row]>maxTileHeight ? m_pRowHeight[row]:maxTileHeight;
2105	accRowHeight += m_pRowHeight[row];
2106	}
2107	maxTileHeight = (heightInCU-accRowHeight)>maxTileHeight ? m_uiMaxCUHeight(heightInCU-accRowHeight):m_uiMaxCUHeightmaxTileHeight;
2108	}
2109	}
2110	Int maxSizeInSamplesY = maxTileWidth*maxTileHeight;
2111	m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/maxSizeInSamplesY-4;
2112	}
2113	else if(m_iWaveFrontSynchro)
2114	{
2115	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/((2m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4;
2116	}
2117	else if(m_sliceMode == 1)
2118	{
2119	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/(m_sliceArgumentm_uiMaxCUWidth*m_uiMaxCUHeight)-4;
2120	}
2121	else
2122	{
2123	m_minSpatialSegmentationIdc = 0;
2124	}
2125	}
2126	#if !L0034_COMBINED_LIST_CLEANUP
2127	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.
2128	#endif
2129	xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
2130	xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
2131	xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
2132
2133	xConfirmPara( m_decodedPictureHashSEIEnabled<0 \|\| m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n");
2134
2135	#if J0149_TONE_MAPPING_SEI
2136	if (m_toneMappingInfoSEIEnabled)
2137	{
2138	xConfirmPara( m_toneMapCodedDataBitDepth < 8 \|\| m_toneMapCodedDataBitDepth > 14 , "SEIToneMapCodedDataBitDepth must be in rage 8 to 14");
2139	xConfirmPara( m_toneMapTargetBitDepth < 1 \|\| (m_toneMapTargetBitDepth > 16 && m_toneMapTargetBitDepth < 255) , "SEIToneMapTargetBitDepth must be in rage 1 to 16 or equal to 255");
2140	xConfirmPara( m_toneMapModelId < 0 \|\| m_toneMapModelId > 4 , "SEIToneMapModelId must be in rage 0 to 4");
2141	xConfirmPara( m_cameraIsoSpeedValue == 0, "SEIToneMapCameraIsoSpeedValue shall not be equal to 0");
2142	xConfirmPara( m_extendedRangeWhiteLevel < 100, "SEIToneMapExtendedRangeWhiteLevel should be greater than or equal to 100");
2143	xConfirmPara( m_nominalBlackLevelLumaCodeValue >= m_nominalWhiteLevelLumaCodeValue, "SEIToneMapNominalWhiteLevelLumaCodeValue shall be greater than SEIToneMapNominalBlackLevelLumaCodeValue");
2144	xConfirmPara( m_extendedWhiteLevelLumaCodeValue < m_nominalWhiteLevelLumaCodeValue, "SEIToneMapExtendedWhiteLevelLumaCodeValue shall be greater than or equal to SEIToneMapNominalWhiteLevelLumaCodeValue");
2145	}
2146	#endif
2147
2148	#if RATE_CONTROL_LAMBDA_DOMAIN
2149	if ( m_RCEnableRateControl )
2150	{
2151	if ( m_RCForceIntraQP )
2152	{
2153	if ( m_RCInitialQP == 0 )
2154	{
2155	printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
2156	m_RCForceIntraQP = false;
2157	}
2158	}
2159	xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
2160	}
2161	#else
2162	if(m_enableRateCtrl)
2163	{
2164	Int numLCUInWidth = (m_iSourceWidth / m_uiMaxCUWidth) + (( m_iSourceWidth % m_uiMaxCUWidth ) ? 1 : 0);
2165	Int numLCUInHeight = (m_iSourceHeight / m_uiMaxCUHeight)+ (( m_iSourceHeight % m_uiMaxCUHeight) ? 1 : 0);
2166	Int numLCUInPic = numLCUInWidth * numLCUInHeight;
2167
2168	xConfirmPara( (numLCUInPic % m_numLCUInUnit) != 0, "total number of LCUs in a frame should be completely divided by NumLCUInUnit" );
2169
2170	m_iMaxDeltaQP = MAX_DELTA_QP;
2171	m_iMaxCuDQPDepth = MAX_CUDQP_DEPTH;
2172	}
2173	#endif
2174
2175	xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagValue, "CUTransquantBypassFlagValue cannot be 1 when TransquantBypassEnableFlag is 0");
2176
2177	xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2");
2178	#if L0444_FPA_TYPE
2179	if (m_framePackingSEIEnabled)
2180	{
2181	xConfirmPara(m_framePackingSEIType < 3 \|\| m_framePackingSEIType > 5 , "SEIFramePackingType must be in rage 3 to 5");
2182	}
2183	#endif
2184	#if H_MV
2185	}
2186	}
2187	#endif
2188
2189	#undef xConfirmPara
2190	if (check_failed)
2191	{
2192	exit(EXIT_FAILURE);
2193	}
2194	}
2195
2196	/** \todo use of global variables should be removed later
2197	*/
2198	Void TAppEncCfg::xSetGlobal()
2199	{
2200	// set max CU width & height
2201	g_uiMaxCUWidth = m_uiMaxCUWidth;
2202	g_uiMaxCUHeight = m_uiMaxCUHeight;
2203
2204	// compute actual CU depth with respect to config depth and max transform size
2205	g_uiAddCUDepth = 0;
2206	while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth ) ) ) g_uiAddCUDepth++;
2207
2208	m_uiMaxCUDepth += g_uiAddCUDepth;
2209	g_uiAddCUDepth++;
2210	g_uiMaxCUDepth = m_uiMaxCUDepth;
2211
2212	// set internal bit-depth and constants
2213	g_bitDepthY = m_internalBitDepthY;
2214	g_bitDepthC = m_internalBitDepthC;
2215
2216	g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
2217	g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
2218	}
2219
2220	Void TAppEncCfg::xPrintParameter()
2221	{
2222	printf("\n");
2223	#if H_MV
2224	for( Int layer = 0; layer < m_numberOfLayers; layer++)
2225	{
2226	printf("Input File %i : %s\n", layer, m_pchInputFileList[layer]);
2227	}
2228	#else
2229	printf("Input File : %s\n", m_pchInputFile );
2230	#endif
2231	printf("Bitstream File : %s\n", m_pchBitstreamFile );
2232	#if H_MV
2233	for( Int layer = 0; layer < m_numberOfLayers; layer++)
2234	{
2235	printf("Reconstruction File %i : %s\n", layer, m_pchReconFileList[layer]);
2236	}
2237	#else
2238	printf("Reconstruction File : %s\n", m_pchReconFile );
2239	#endif
2240	#if H_MV
2241	xPrintParaVector( "ViewId", m_viewId );
2242	#endif
2243	#if H_3D
2244	xPrintParaVector( "DepthFlag", m_depthFlag );
2245	printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2246	#endif
2247	#if H_MV
2248	xPrintParaVector( "QP" , m_fQP );
2249	xPrintParaVector( "LoopFilterDisable", m_bLoopFilterDisable );
2250	xPrintParaVector( "SAO" , m_bUseSAO );
2251	#endif
2252	printf("Real Format : %dx%d %dHz\n", m_iSourceWidth - m_confLeft - m_confRight, m_iSourceHeight - m_confTop - m_confBottom, m_iFrameRate );
2253	printf("Internal Format : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
2254	printf("Frame index : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2255	printf("CU size / depth : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
2256	printf("RQT trans. size (min / max) : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
2257	printf("Max RQT depth inter : %d\n", m_uiQuadtreeTUMaxDepthInter);
2258	printf("Max RQT depth intra : %d\n", m_uiQuadtreeTUMaxDepthIntra);
2259	printf("Min PCM size : %d\n", 1 << m_uiPCMLog2MinSize);
2260	printf("Motion search range : %d\n", m_iSearchRange );
2261	printf("Intra period : %d\n", m_iIntraPeriod );
2262	printf("Decoding refresh type : %d\n", m_iDecodingRefreshType );
2263	#if !H_MV
2264	printf("QP : %5.2f\n", m_fQP );
2265	#endif
2266	printf("Max dQP signaling depth : %d\n", m_iMaxCuDQPDepth);
2267
2268	printf("Cb QP Offset : %d\n", m_cbQpOffset );
2269	printf("Cr QP Offset : %d\n", m_crQpOffset);
2270
2271	printf("QP adaptation : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
2272	printf("GOP size : %d\n", m_iGOPSize );
2273	printf("Internal bit depth : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC );
2274	printf("PCM sample bit depth : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma );
2275	#if RATE_CONTROL_LAMBDA_DOMAIN
2276	printf("RateControl : %d\n", m_RCEnableRateControl );
2277	if(m_RCEnableRateControl)
2278	{
2279	printf("TargetBitrate : %d\n", m_RCTargetBitrate );
2280	printf("KeepHierarchicalBit : %d\n", m_RCKeepHierarchicalBit );
2281	printf("LCULevelRC : %d\n", m_RCLCULevelRC );
2282	printf("UseLCUSeparateModel : %d\n", m_RCUseLCUSeparateModel );
2283	printf("InitialQP : %d\n", m_RCInitialQP );
2284	printf("ForceIntraQP : %d\n", m_RCForceIntraQP );
2285	}
2286	#else
2287	printf("RateControl : %d\n", m_enableRateCtrl);
2288	if(m_enableRateCtrl)
2289	{
2290	printf("TargetBitrate : %d\n", m_targetBitrate);
2291	printf("NumLCUInUnit : %d\n", m_numLCUInUnit);
2292	}
2293	#endif
2294	printf("Max Num Merge Candidates : %d\n", m_maxNumMergeCand);
2295	#if H_3D
2296	printf("BaseViewCameraNumbers : %s\n", m_pchBaseViewCameraNumbers );
2297	printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2298	#if H_3D_VSO
2299	printf("Force use of Lambda Scale : %d\n", m_bForceLambdaScaleVSO );
2300
2301	if ( m_bUseVSO )
2302	{
2303	printf("VSO Lambda Scale : %5.2f\n", m_dLambdaScaleVSO );
2304	printf("VSO Mode : %d\n", m_uiVSOMode );
2305	printf("VSO Config : %s\n", m_pchVSOConfig );
2306	printf("VSO Negative Distortion : %d\n", m_bAllowNegDist ? 1 : 0);
2307	printf("VSO LS Table : %d\n", m_bVSOLSTable ? 1 : 0);
2308	printf("VSO Estimated VSD : %d\n", m_bUseEstimatedVSD ? 1 : 0);
2309	printf("VSO Early Skip : %d\n", m_bVSOEarlySkip ? 1 : 0);
2310	if ( m_bUseWVSO )
2311	printf("Dist. Weights (VSO/VSD/SAD) : %d/%d/%d\n ", m_iVSOWeight, m_iVSDWeight, m_iDWeight );
2312	}
2313	#endif //HHI_VSO
2314	#endif //H_3D
2315	printf("\n");
2316	#if H_MV
2317	printf("TOOL CFG General: ");
2318	#else
2319	printf("TOOL CFG: ");
2320	#endif
2321	printf("IBD:%d ", g_bitDepthY > m_inputBitDepthY \|\| g_bitDepthC > m_inputBitDepthC);
2322	printf("HAD:%d ", m_bUseHADME );
2323	printf("SRD:%d ", m_bUseSBACRD );
2324	printf("RDQ:%d ", m_useRDOQ );
2325	printf("RDQTS:%d ", m_useRDOQTS );
2326	#if L0232_RD_PENALTY
2327	printf("RDpenalty:%d ", m_rdPenalty );
2328	#endif
2329	printf("SQP:%d ", m_uiDeltaQpRD );
2330	printf("ASR:%d ", m_bUseASR );
2331	#if !L0034_COMBINED_LIST_CLEANUP
2332	printf("LComb:%d ", m_bUseLComb );
2333	#endif
2334	printf("FEN:%d ", m_bUseFastEnc );
2335	printf("ECU:%d ", m_bUseEarlyCU );
2336	printf("FDM:%d ", m_useFastDecisionForMerge );
2337	printf("CFM:%d ", m_bUseCbfFastMode );
2338	printf("ESD:%d ", m_useEarlySkipDetection );
2339	printf("RQT:%d ", 1 );
2340	printf("TransformSkip:%d ", m_useTransformSkip );
2341	printf("TransformSkipFast:%d ", m_useTransformSkipFast );
2342	printf("Slice: M=%d ", m_sliceMode);
2343	if (m_sliceMode!=0)
2344	{
2345	printf("A=%d ", m_sliceArgument);
2346	}
2347	printf("SliceSegment: M=%d ",m_sliceSegmentMode);
2348	if (m_sliceSegmentMode!=0)
2349	{
2350	printf("A=%d ", m_sliceSegmentArgument);
2351	}
2352	printf("CIP:%d ", m_bUseConstrainedIntraPred);
2353	#if !H_MV
2354	printf("SAO:%d ", (m_bUseSAO)?(1):(0));
2355	#endif
2356	printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
2357	printf("SAOLcuBasedOptimization:%d ", (m_saoLcuBasedOptimization)?(1):(0));
2358
2359	printf("LosslessCuEnabled:%d ", (m_useLossless)? 1:0 );
2360	printf("WPP:%d ", (Int)m_useWeightedPred);
2361	printf("WPB:%d ", (Int)m_useWeightedBiPred);
2362	printf("PME:%d ", m_log2ParallelMergeLevel);
2363	printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d",
2364	m_iWaveFrontSynchro, m_iWaveFrontSubstreams);
2365	printf(" ScalingList:%d ", m_useScalingListId );
2366	printf("TMVPMode:%d ", m_TMVPModeId );
2367	#if ADAPTIVE_QP_SELECTION
2368	printf("AQpS:%d ", m_bUseAdaptQpSelect );
2369	#endif
2370
2371	printf(" SignBitHidingFlag:%d ", m_signHideFlag);
2372	printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 );
2373	#if H_3D_VSO
2374	printf("VSO:%d ", m_bUseVSO );
2375	printf("WVSO:%d ", m_bUseWVSO );
2376	#endif
2377	printf("\n\n");
2378
2379	fflush(stdout);
2380	}
2381
2382	Bool confirmPara(Bool bflag, const Char* message)
2383	{
2384	if (!bflag)
2385	return false;
2386
2387	printf("Error: %s\n",message);
2388	return true;
2389	}
2390
2391	//! \}

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

JCT-3V 3D-HEVC

Context navigation

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

Download in other formats: