Context navigation

TAppEncCfg.cpp @ 1417

Visit:

Last change on this file since 1417 was 1158, checked in by sony, 10 years ago

Fix for SONY_MV_V_CONST_C0078
1) search range limit to consider sub-pel search
2) added disparity vector check module

ohji.nakagami@…

Property svn:eol-style set to native

File size: 127.1 KB

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-13.1-dev2-Sony/source/App/TAppEncoder/TAppEncCfg.cpp @ 1417

Download in other formats: