Context navigation

source: 3DVCSoftware/branches/HTM-12.1-dev0/source/App/TAppEncoder/TAppEncCfg.cpp @ 1075

Visit:

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

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

Download in other formats: