Context navigation

source: 3DVCSoftware/branches/HTM-9.2-dev0/source/App/TAppEncoder/TAppEncCfg.cpp @ 764

Visit:

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

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

Download in other formats: