Context navigation

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

Visit:

Last change on this file since 664 was 655, checked in by tech, 11 years ago
Merged 8.1-Cleanup@654
Property svn:eol-style set to `native`
File size: 113.2 KB

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

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

Download in other formats: