Context navigation

source: 3DVCSoftware/branches/HTM-9.1-dev0-MediaTek/source/App/TAppEncoder/TAppEncCfg.cpp

Visit:

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

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

Download in other formats: