Context navigation

source: 3DVCSoftware/branches/HTM-8.2-dev0-Cleanup/source/App/TAppEncoder/TAppEncCfg.cpp @ 650

Visit:

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

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

Download in other formats: