Context navigation

TAppEncCfg.cpp @ 769

Visit:

Last change on this file since 769 was 716, checked in by mediatek-htm, 11 years ago

Bug fix for F0093, addded macro is

#define BUGFIX_F0093 1 bug fix for F0093 for depth IvMC pruning

Property svn:eol-style set to native

File size: 114.5 KB

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

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

JCT-3V 3D-HEVC

Context navigation

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

Download in other formats: