Context navigation

source: 3DVCSoftware/branches/HTM-8.2-dev3-Samsung/source/App/TAppEncoder/TAppEncCfg.cpp @ 697

Visit:

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

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

Download in other formats: