Context navigation

TAppEncCfg.cpp @ 715

Visit:

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

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

JCT-3V 3D-HEVC

Context navigation

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

Download in other formats: