Context navigation

← Previous revision
Next revision →
Blame
Revision log

TAppEncCfg.cpp

Visit:

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-DEV-2.0-dev3-Samsung/source/App/TAppEncoder/TAppEncCfg.cpp

Download in other formats: