Context navigation

source: 3DVCSoftware/branches/HTM-14.0-dev0/source/App/TAppEncoder/TAppEncCfg.cpp @ 1184

Visit:

Last change on this file since 1184 was 1179, checked in by tech, 10 years ago
Merged branch 13.1-dev0@1178.
Property svn:eol-style set to `native`
File size: 127.9 KB

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

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

Download in other formats: