Context navigation

TAppEncCfg.cpp @ 1071

Visit:

Last change on this file since 1071 was 669, checked in by zhang, 11 years ago
JCT3V-F0125
Property svn:eol-style set to `native`
File size: 113.5 KB

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-8.2-dev2-Qualcomm/source/App/TAppEncoder/TAppEncCfg.cpp @ 1071

Download in other formats: