Context navigation

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

Visit:

Last change on this file since 611 was 608, checked in by tech, 11 years ago
Merged DEV-2.0-dev0@604.
Property svn:eol-style set to `native`
File size: 106.0 KB

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

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

Download in other formats: