Context navigation

source: 3DVCSoftware/branches/HTM-13.1-dev0/source/App/TAppEncoder/TAppEncCfg.cpp @ 1164

Visit:

Last change on this file since 1164 was 1164, checked in by tech, 9 years ago
Merged 13.1-dev2-Sony
Property svn:eol-style set to `native`
File size: 127.5 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	* All rights reserved.
8	*
9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions are met:
11	*
12	* * Redistributions of source code must retain the above copyright notice,
13	* this list of conditions and the following disclaimer.
14	* * Redistributions in binary form must reproduce the above copyright notice,
15	* this list of conditions and the following disclaimer in the documentation
16	* and/or other materials provided with the distribution.
17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18	* be used to endorse or promote products derived from this software without
19	* specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31	* THE POSSIBILITY OF SUCH DAMAGE.
32	*/
33
34	/** \file TAppEncCfg.cpp
35	\brief Handle encoder configuration parameters
36	*/
37
38	#include <stdlib.h>
39	#include <cassert>
40	#include <cstring>
41	#include <string>
42	#include "TLibCommon/TComRom.h"
43	#include "TAppEncCfg.h"
44
45	static istream& operator>>(istream &, Level::Name &);
46	static istream& operator>>(istream &, Level::Tier &);
47	static istream& operator>>(istream &, Profile::Name &);
48
49	#include "TAppCommon/program_options_lite.h"
50	#include "TLibEncoder/TEncRateCtrl.h"
51	#ifdef WIN32
52	#define strdup _strdup
53	#endif
54
55	using namespace std;
56	namespace po = df::program_options_lite;
57
58	//! \ingroup TAppEncoder
59	//! \{
60
61	// ====================================================================================================================
62	// Constructor / destructor / initialization / destroy
63	// ====================================================================================================================
64
65	TAppEncCfg::TAppEncCfg()
66	#if H_MV
67	: m_pchBitstreamFile()
68	#else
69	: m_pchInputFile()
70	, m_pchBitstreamFile()
71	, m_pchReconFile()
72	#endif
73	, m_pchdQPFile()
74	, m_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	#if SEC_DEPTH_INTRA_SKIP_MODE_K0033
792	("DepthIntraSkip" , m_depthIntraSkipFlag , true , "Depth intra skip mode" )
793	#else
794	("IntraSingleFlag" , m_intraSingleFlag , true , "Intra single mode" )
795	#endif
796	#endif //H_3D
797	;
798
799	#if H_MV
800	// parse coding structure
801	for( Int k = 0; k < MAX_NUM_LAYERS; k++ )
802	{
803	m_GOPListMvc.push_back( new GOPEntry[MAX_GOP + 1] );
804	if( k == 0 )
805	{
806	m_GOPListMvc[0][0].m_sliceType = 'I';
807	for( Int i = 1; i < MAX_GOP + 1; i++ )
808	{
809	std::ostringstream cOSS;
810	cOSS<<"Frame"<<i;
811	opts.addOptions()( cOSS.str(), m_GOPListMvc[k][i-1], GOPEntry() );
812	if ( i != 1 )
813	{
814	opts.opt_list.back()->opt->opt_duplicate = true;
815	}
816	}
817	}
818	else
819	{
820	std::ostringstream cOSS1;
821	cOSS1<<"FrameI"<<"_l"<<k;
822
823	opts.addOptions()(cOSS1.str(), m_GOPListMvc[k][MAX_GOP], GOPEntry());
824	if ( k > 1 )
825	{
826	opts.opt_list.back()->opt->opt_duplicate = true;
827	}
828
829
830	for( Int i = 1; i < MAX_GOP + 1; i++ )
831	{
832	std::ostringstream cOSS2;
833	cOSS2<<"Frame"<<i<<"_l"<<k;
834	opts.addOptions()(cOSS2.str(), m_GOPListMvc[k][i-1], GOPEntry());
835	if ( i != 1 \|\| k > 0 )
836	{
837	opts.opt_list.back()->opt->opt_duplicate = true;
838	}
839	}
840	}
841	}
842	#else
843	for(Int i=1; i<MAX_GOP+1; i++) {
844	std::ostringstream cOSS;
845	cOSS<<"Frame"<<i;
846	opts.addOptions()(cOSS.str(), m_GOPList[i-1], GOPEntry());
847	}
848	#endif
849	po::setDefaults(opts);
850	const list<const Char>& argv_unhandled = po::scanArgv(opts, argc, (const Char*) argv);
851
852	if(m_isField)
853	{
854	//Frame height
855	m_iSourceHeightOrg = m_iSourceHeight;
856	//Field height
857	m_iSourceHeight = m_iSourceHeight >> 1;
858	//number of fields to encode
859	m_framesToBeEncoded *= 2;
860	}
861
862	for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
863	{
864	fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
865	}
866
867	if (argc == 1 \|\| do_help)
868	{
869	/* argc == 1: no options have been specified */
870	po::doHelp(cout, opts);
871	return false;
872	}
873
874	/*
875	* Set any derived parameters
876	*/
877	/* convert std::string to c string for compatability */
878	#if !H_MV
879	m_pchInputFile = cfg_InputFile.empty() ? NULL : strdup(cfg_InputFile.c_str());
880	#endif
881	m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
882	#if !H_MV
883	m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str());
884	#endif
885	m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());
886
887	Char* pColumnWidth = cfgColumnWidth.empty() ? NULL: strdup(cfgColumnWidth.c_str());
888	Char* pRowHeight = cfgRowHeight.empty() ? NULL : strdup(cfgRowHeight.c_str());
889
890	if( !m_tileUniformSpacingFlag && m_numTileColumnsMinus1 > 0 )
891	{
892	char *str;
893	int i=0;
894	m_tileColumnWidth.resize( m_numTileColumnsMinus1 );
895	str = strtok(pColumnWidth, " ,-");
896	while(str!=NULL)
897	{
898	if( i >= m_numTileColumnsMinus1 )
899	{
900	printf( "The number of columns whose width are defined is larger than the allowed number of columns.\n" );
901	exit( EXIT_FAILURE );
902	}
903	m_tileColumnWidth[i] = atoi( str );
904	str = strtok(NULL, " ,-");
905	i++;
906	}
907	if( i < m_numTileColumnsMinus1 )
908	{
909	printf( "The width of some columns is not defined.\n" );
910	exit( EXIT_FAILURE );
911	}
912	}
913	else
914	{
915	m_tileColumnWidth.clear();
916	}
917
918	if( !m_tileUniformSpacingFlag && m_numTileRowsMinus1 > 0 )
919	{
920	char *str;
921	int i=0;
922	m_tileRowHeight.resize(m_numTileRowsMinus1);
923	str = strtok(pRowHeight, " ,-");
924	while(str!=NULL)
925	{
926	if( i>=m_numTileRowsMinus1 )
927	{
928	printf( "The number of rows whose height are defined is larger than the allowed number of rows.\n" );
929	exit( EXIT_FAILURE );
930	}
931	m_tileRowHeight[i] = atoi( str );
932	str = strtok(NULL, " ,-");
933	i++;
934	}
935	if( i < m_numTileRowsMinus1 )
936	{
937	printf( "The height of some rows is not defined.\n" );
938	exit( EXIT_FAILURE );
939	}
940	}
941	else
942	{
943	m_tileRowHeight.clear();
944	}
945	#if H_MV
946	free ( pColumnWidth );
947	free ( pRowHeight );
948	#endif
949	m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str());
950
951	/* rules for input, output and internal bitdepths as per help text */
952	if (!m_internalBitDepthY) { m_internalBitDepthY = m_inputBitDepthY; }
953	if (!m_internalBitDepthC) { m_internalBitDepthC = m_internalBitDepthY; }
954	if (!m_inputBitDepthC) { m_inputBitDepthC = m_inputBitDepthY; }
955	if (!m_outputBitDepthY) { m_outputBitDepthY = m_internalBitDepthY; }
956	if (!m_outputBitDepthC) { m_outputBitDepthC = m_internalBitDepthC; }
957
958	// TODO:ChromaFmt assumes 4:2:0 below
959	switch (m_conformanceWindowMode)
960	{
961	case 0:
962	{
963	// no conformance or padding
964	m_confWinLeft = m_confWinRight = m_confWinTop = m_confWinBottom = 0;
965	m_aiPad[1] = m_aiPad[0] = 0;
966	break;
967	}
968	case 1:
969	{
970	// automatic padding to minimum CU size
971	Int minCuSize = m_uiMaxCUHeight >> (m_uiMaxCUDepth - 1);
972	if (m_iSourceWidth % minCuSize)
973	{
974	m_aiPad[0] = m_confWinRight = ((m_iSourceWidth / minCuSize) + 1) * minCuSize - m_iSourceWidth;
975	m_iSourceWidth += m_confWinRight;
976	}
977	if (m_iSourceHeight % minCuSize)
978	{
979	m_aiPad[1] = m_confWinBottom = ((m_iSourceHeight / minCuSize) + 1) * minCuSize - m_iSourceHeight;
980	m_iSourceHeight += m_confWinBottom;
981	if ( m_isField )
982	{
983	m_iSourceHeightOrg += m_confWinBottom << 1;
984	m_aiPad[1] = m_confWinBottom << 1;
985	}
986	}
987	if (m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0)
988	{
989	fprintf(stderr, "Error: picture width is not an integer multiple of the specified chroma subsampling\n");
990	exit(EXIT_FAILURE);
991	}
992	if (m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0)
993	{
994	fprintf(stderr, "Error: picture height is not an integer multiple of the specified chroma subsampling\n");
995	exit(EXIT_FAILURE);
996	}
997	break;
998	}
999	case 2:
1000	{
1001	//padding
1002	m_iSourceWidth += m_aiPad[0];
1003	m_iSourceHeight += m_aiPad[1];
1004	m_confWinRight = m_aiPad[0];
1005	m_confWinBottom = m_aiPad[1];
1006	break;
1007	}
1008	case 3:
1009	{
1010	// conformance
1011	if ((m_confWinLeft == 0) && (m_confWinRight == 0) && (m_confWinTop == 0) && (m_confWinBottom == 0))
1012	{
1013	fprintf(stderr, "Warning: Conformance window enabled, but all conformance window parameters set to zero\n");
1014	}
1015	if ((m_aiPad[1] != 0) \|\| (m_aiPad[0]!=0))
1016	{
1017	fprintf(stderr, "Warning: Conformance window enabled, padding parameters will be ignored\n");
1018	}
1019	m_aiPad[1] = m_aiPad[0] = 0;
1020	break;
1021	}
1022	}
1023
1024	// allocate slice-based dQP values
1025	#if H_MV
1026	xResizeVector( m_viewOrderIndex );
1027
1028	std::vector<Int> uniqueViewOrderIndices;
1029	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1030	{
1031	Bool isIn = false;
1032	for ( Int i = 0 ; i < uniqueViewOrderIndices.size(); i++ )
1033	{
1034	isIn = isIn \|\| ( m_viewOrderIndex[ layer ] == uniqueViewOrderIndices[ i ] );
1035	}
1036	if ( !isIn )
1037	{
1038	uniqueViewOrderIndices.push_back( m_viewOrderIndex[ layer ] );
1039	}
1040	}
1041	m_iNumberOfViews = (Int) uniqueViewOrderIndices.size();
1042	xResizeVector( m_auxId );
1043
1044	#if H_3D
1045	xResizeVector( m_depthFlag );
1046	#endif
1047	xResizeVector( m_fQP );
1048
1049	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1050	{
1051	m_aidQP.push_back( new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ] );
1052	::memset( m_aidQP[layer], 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
1053
1054	// handling of floating-point QP values
1055	// if QP is not integer, sequence is split into two sections having QP and QP+1
1056	m_iQP.push_back((Int)( m_fQP[layer] ));
1057	if ( m_iQP[layer] < m_fQP[layer] )
1058	{
1059	Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP[layer] - m_iQP[layer])*m_framesToBeEncoded + 0.5 );
1060
1061	iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
1062	for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
1063	{
1064	m_aidQP[layer][i] = 1;
1065	}
1066	}
1067	}
1068
1069	xResizeVector( m_bLoopFilterDisable );
1070	xResizeVector( m_bUseSAO );
1071	xResizeVector( m_iIntraPeriod );
1072	xResizeVector( m_tilesInUseFlag );
1073	xResizeVector( m_loopFilterNotAcrossTilesFlag );
1074	xResizeVector( m_wppInUseFlag );
1075
1076	for (Int olsIdx = 0; olsIdx < m_vpsNumLayerSets + m_numAddLayerSets + (Int) m_outputLayerSetIdx.size(); olsIdx++)
1077	{
1078	m_altOutputLayerFlag.push_back( false );
1079	}
1080	#else
1081	m_aidQP = new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ];
1082	::memset( m_aidQP, 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
1083
1084	// handling of floating-point QP values
1085	// if QP is not integer, sequence is split into two sections having QP and QP+1
1086	m_iQP = (Int)( m_fQP );
1087	if ( m_iQP < m_fQP )
1088	{
1089	Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP - m_iQP)*m_framesToBeEncoded + 0.5 );
1090
1091	iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
1092	for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
1093	{
1094	m_aidQP[i] = 1;
1095	}
1096	}
1097	#endif
1098
1099	// reading external dQP description from file
1100	if ( m_pchdQPFile )
1101	{
1102	FILE* fpt=fopen( m_pchdQPFile, "r" );
1103	if ( fpt )
1104	{
1105	#if H_MV
1106	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1107	{
1108	#endif
1109	Int iValue;
1110	Int iPOC = 0;
1111	while ( iPOC < m_framesToBeEncoded )
1112	{
1113	if ( fscanf(fpt, "%d", &iValue ) == EOF ) break;
1114	#if H_MV
1115	m_aidQP[layer][ iPOC ] = iValue;
1116	iPOC++;
1117	}
1118	#else
1119	m_aidQP[ iPOC ] = iValue;
1120	iPOC++;
1121	#endif
1122	}
1123	fclose(fpt);
1124	}
1125	}
1126	m_iWaveFrontSubstreams = m_iWaveFrontSynchro ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1;
1127
1128	if( m_toneMappingInfoSEIEnabled && !m_toneMapCancelFlag )
1129	{
1130	Char* pcStartOfCodedInterval = cfg_startOfCodedInterval.empty() ? NULL: strdup(cfg_startOfCodedInterval.c_str());
1131	Char* pcCodedPivotValue = cfg_codedPivotValue.empty() ? NULL: strdup(cfg_codedPivotValue.c_str());
1132	Char* pcTargetPivotValue = cfg_targetPivotValue.empty() ? NULL: strdup(cfg_targetPivotValue.c_str());
1133	if( m_toneMapModelId == 2 && pcStartOfCodedInterval )
1134	{
1135	char *startOfCodedInterval;
1136	UInt num = 1u<< m_toneMapTargetBitDepth;
1137	m_startOfCodedInterval = new Int[num];
1138	::memset( m_startOfCodedInterval, 0, sizeof(Int)*num );
1139	startOfCodedInterval = strtok(pcStartOfCodedInterval, " .");
1140	int i = 0;
1141	while( startOfCodedInterval && ( i < num ) )
1142	{
1143	m_startOfCodedInterval[i] = atoi( startOfCodedInterval );
1144	startOfCodedInterval = strtok(NULL, " .");
1145	i++;
1146	}
1147	}
1148	else
1149	{
1150	m_startOfCodedInterval = NULL;
1151	}
1152	if( ( m_toneMapModelId == 3 ) && ( m_numPivots > 0 ) )
1153	{
1154	if( pcCodedPivotValue && pcTargetPivotValue )
1155	{
1156	char *codedPivotValue;
1157	char *targetPivotValue;
1158	m_codedPivotValue = new Int[m_numPivots];
1159	m_targetPivotValue = new Int[m_numPivots];
1160	::memset( m_codedPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1161	::memset( m_targetPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1162	codedPivotValue = strtok(pcCodedPivotValue, " .");
1163	int i=0;
1164	while(codedPivotValue&&i<m_numPivots)
1165	{
1166	m_codedPivotValue[i] = atoi( codedPivotValue );
1167	codedPivotValue = strtok(NULL, " .");
1168	i++;
1169	}
1170	i=0;
1171	targetPivotValue = strtok(pcTargetPivotValue, " .");
1172	while(targetPivotValue&&i<m_numPivots)
1173	{
1174	m_targetPivotValue[i]= atoi( targetPivotValue );
1175	targetPivotValue = strtok(NULL, " .");
1176	i++;
1177	}
1178	}
1179	}
1180	else
1181	{
1182	m_codedPivotValue = NULL;
1183	m_targetPivotValue = NULL;
1184	}
1185	}
1186
1187	#if H_MV
1188	// parse PTL
1189	Bool anyEmpty = false;
1190	if( cfg_profiles.empty() )
1191	{
1192	#if H_3D
1193	cfg_profiles = string("main main 3d-main");
1194	#else
1195	cfg_profiles = string("main main multiview-main");
1196	#endif
1197	fprintf(stderr, "\nWarning: No profiles given, using defaults: %s", cfg_profiles.c_str() );
1198	anyEmpty = true;
1199	}
1200
1201	if( cfg_levels.empty() )
1202	{
1203	cfg_levels = string("none none none");
1204	fprintf(stderr, "\nWarning: No levels given, using defaults: %s", cfg_levels.c_str() );
1205	anyEmpty = true;
1206	}
1207
1208	if( cfg_tiers.empty() )
1209	{
1210	cfg_tiers = string("main main main");
1211	fprintf(stderr, "\nWarning: No tiers given, using defaults: %s", cfg_tiers.c_str());
1212	anyEmpty = true;
1213	}
1214
1215	if( m_inblFlag.empty() )
1216	{
1217	fprintf(stderr, "\nWarning: No inblFlags given, using defaults:");
1218	for( Int i = 0; i < 3; i++)
1219	{
1220	m_inblFlag.push_back( false );
1221	fprintf(stderr," %d", (Int) m_inblFlag[i]);
1222	}
1223	anyEmpty = true;
1224	}
1225
1226	if ( anyEmpty )
1227	{
1228	fprintf( stderr, "\n" );
1229	}
1230
1231	xReadStrToEnum( cfg_profiles, m_profile );
1232	xReadStrToEnum( cfg_levels, m_level );
1233	xReadStrToEnum( cfg_tiers , m_levelTier );
1234	#endif
1235	#if H_3D
1236	// set global varibles
1237	xSetGlobal();
1238	#if H_3D_VSO
1239	// Table base optimization
1240	// Q&D
1241	Double adLambdaScaleTable[] =
1242	{ 0.031250, 0.031639, 0.032029, 0.032418, 0.032808, 0.033197, 0.033586, 0.033976, 0.034365, 0.034755,
1243	0.035144, 0.035533, 0.035923, 0.036312, 0.036702, 0.037091, 0.037480, 0.037870, 0.038259, 0.038648,
1244	0.039038, 0.039427, 0.039817, 0.040206, 0.040595, 0.040985, 0.041374, 0.041764, 0.042153, 0.042542,
1245	0.042932, 0.043321, 0.043711, 0.044100, 0.044194, 0.053033, 0.061872, 0.070711, 0.079550, 0.088388,
1246	0.117851, 0.147314, 0.176777, 0.235702, 0.294628, 0.353553, 0.471405, 0.589256, 0.707107, 0.707100,
1247	0.753550, 0.800000
1248	};
1249	if ( m_bUseVSO && m_bVSOLSTable )
1250	{
1251	Int firstDepthLayer = -1;
1252	for (Int layer = 0; layer < m_numberOfLayers; layer++ )
1253	{
1254	if ( m_depthFlag[ layer ])
1255	{
1256	firstDepthLayer = layer;
1257	break;
1258	}
1259	}
1260	AOT( firstDepthLayer == -1 );
1261	AOT( (m_iQP[firstDepthLayer] < 0) \|\| (m_iQP[firstDepthLayer] > 51));
1262	m_dLambdaScaleVSO *= adLambdaScaleTable[m_iQP[firstDepthLayer]];
1263	}
1264	#endif
1265	#if H_3D_VSO
1266	if ( m_bUseVSO && m_uiVSOMode == 4)
1267	{
1268	m_cRenModStrParser.setString( m_iNumberOfViews, m_pchVSOConfig );
1269	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1270	g_bitDepthY,
1271	(UInt)m_iCodedCamParPrecision,
1272	m_FrameSkip,
1273	(UInt)m_framesToBeEncoded,
1274	m_pchCameraParameterFile,
1275	m_pchBaseViewCameraNumbers,
1276	NULL,
1277	m_cRenModStrParser.getSynthViews(),
1278	LOG2_DISP_PREC_LUT );
1279	}
1280	else if ( m_bUseVSO && m_uiVSOMode != 4 )
1281	{
1282	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1283	g_bitDepthY,
1284	(UInt)m_iCodedCamParPrecision,
1285	m_FrameSkip,
1286	(UInt)m_framesToBeEncoded,
1287	m_pchCameraParameterFile,
1288	m_pchBaseViewCameraNumbers,
1289	m_pchVSOConfig,
1290	NULL,
1291	LOG2_DISP_PREC_LUT );
1292	}
1293	else
1294	{
1295	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1296	g_bitDepthY,
1297	(UInt) m_iCodedCamParPrecision,
1298	m_FrameSkip,
1299	(UInt) m_framesToBeEncoded,
1300	m_pchCameraParameterFile,
1301	m_pchBaseViewCameraNumbers,
1302	NULL,
1303	NULL,
1304	LOG2_DISP_PREC_LUT );
1305	}
1306	#else
1307	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1308	g_bitDepthY,
1309	(UInt) m_iCodedCamParPrecision,
1310	m_FrameSkip,
1311	(UInt) m_framesToBeEncoded,
1312	m_pchCameraParameterFile,
1313	m_pchBaseViewCameraNumbers,
1314	NULL,
1315	NULL,
1316	LOG2_DISP_PREC_LUT );
1317	#endif
1318	m_cCameraData.check( false, true );
1319	#endif
1320	// check validity of input parameters
1321	xCheckParameter();
1322
1323	#if !H_3D
1324	// set global varibles
1325	xSetGlobal();
1326	#endif
1327
1328	// print-out parameters
1329	xPrintParameter();
1330
1331	return true;
1332	}
1333	// ====================================================================================================================
1334	// Private member functions
1335	// ====================================================================================================================
1336
1337	Bool confirmPara(Bool bflag, const Char* message);
1338
1339	Void TAppEncCfg::xCheckParameter()
1340	{
1341	if (!m_decodedPictureHashSEIEnabled)
1342	{
1343	fprintf(stderr, "******************************************************************\n");
1344	fprintf(stderr, " WARNING: --SEIDecodedPictureHash is now disabled by default. \n");
1345	fprintf(stderr, " Automatic verification of decoded pictures by a \n");
1346	fprintf(stderr, " decoder requires this option to be enabled. \n");
1347	fprintf(stderr, "******************************************************************\n");
1348	}
1349
1350
1351	#if !H_MV
1352	if( m_profile==Profile::NONE )
1353	{
1354	fprintf(stderr, "***************************************************************************\n");
1355	fprintf(stderr, " WARNING: For conforming bitstreams a valid Profile value must be set! \n");
1356	fprintf(stderr, "***************************************************************************\n");
1357	}
1358	if( m_level==Level::NONE )
1359	{
1360	fprintf(stderr, "***************************************************************************\n");
1361	fprintf(stderr, " WARNING: For conforming bitstreams a valid Level value must be set! \n");
1362	fprintf(stderr, "***************************************************************************\n");
1363	}
1364	#endif
1365
1366	Bool check_failed = false; /* abort if there is a fatal configuration problem */
1367	#define xConfirmPara(a,b) check_failed \|= confirmPara(a,b)
1368	// check range of parameters
1369	xConfirmPara( m_inputBitDepthY < 8, "InputBitDepth must be at least 8" );
1370	xConfirmPara( m_inputBitDepthC < 8, "InputBitDepthC must be at least 8" );
1371	xConfirmPara( m_iFrameRate <= 0, "Frame rate must be more than 1" );
1372	xConfirmPara( m_framesToBeEncoded <= 0, "Total Number Of Frames encoded must be more than 0" );
1373	#if H_MV
1374	xConfirmPara( m_numberOfLayers > MAX_NUM_LAYER_IDS , "NumberOfLayers must be less than or equal to MAX_NUM_LAYER_IDS");
1375
1376
1377	xConfirmPara( m_layerIdInNuh[0] != 0 , "LayerIdInNuh must be 0 for the first layer. ");
1378	xConfirmPara( (m_layerIdInNuh.size()!=1) && (m_layerIdInNuh.size() < m_numberOfLayers) , "LayerIdInNuh must be given for all layers. ");
1379
1380	#if H_3D
1381	xConfirmPara( m_scalabilityMask != 2 && m_scalabilityMask != 3, "Scalability Mask must be equal to 2 or 3. ");
1382	#else
1383	xConfirmPara( m_scalabilityMask != 2 && m_scalabilityMask != 8 && m_scalabilityMask != 10, "Scalability Mask must be equal to 2, 8 or 10");
1384	#endif
1385
1386	#if H_3D
1387	if ( m_scalabilityMask & ( 1 << DEPTH_ID ) )
1388	{
1389	m_dimIds.push_back( m_depthFlag );
1390	}
1391	#endif
1392
1393	m_dimIds.push_back( m_viewOrderIndex );
1394	for (Int i = 0; i < m_auxId.size(); i++)
1395	{
1396	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");
1397	}
1398	if ( m_scalabilityMask & ( 1 << AUX_ID ) )
1399	{
1400	m_dimIds.push_back ( m_auxId );
1401	}
1402	xConfirmPara( m_dimensionIdLen.size() < m_dimIds.size(), "DimensionIdLen must be given for all dimensions. " );
1403	Int dimBitOffset[MAX_NUM_SCALABILITY_TYPES+1];
1404
1405	dimBitOffset[ 0 ] = 0;
1406	for (Int j = 1; j <= ((Int) m_dimIds.size() - m_splittingFlag ? 1 : 0); j++ )
1407	{
1408	dimBitOffset[ j ] = dimBitOffset[ j - 1 ] + m_dimensionIdLen[ j - 1];
1409	}
1410
1411	if ( m_splittingFlag )
1412	{
1413	dimBitOffset[ (Int) m_dimIds.size() ] = 6;
1414	}
1415
1416	for( Int j = 0; j < m_dimIds.size(); j++ )
1417	{
1418	xConfirmPara( m_dimIds[j].size() < m_numberOfLayers, "DimensionId must be given for all layers and all dimensions. ");
1419	xConfirmPara( (m_dimIds[j][0] != 0) , "DimensionId of layer 0 must be 0. " );
1420	xConfirmPara( m_dimensionIdLen[j] < 1 \|\| m_dimensionIdLen[j] > 8, "DimensionIdLen must be greater than 0 and less than 9 in all dimensions. " );
1421
1422
1423	for( Int i = 1; i < m_numberOfLayers; i++ )
1424	{
1425	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. " );
1426	if ( m_splittingFlag )
1427	{
1428	Int layerIdInNuh = (m_layerIdInNuh.size()!=1) ? m_layerIdInNuh[i] : i;
1429	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. ");
1430	}
1431	}
1432	}
1433
1434	for( Int i = 0; i < m_numberOfLayers; i++ )
1435	{
1436	for( Int j = 0; j < i; j++ )
1437	{
1438	Int numDiff = 0;
1439	Int lastDiff = -1;
1440	for( Int dim = 0; dim < m_dimIds.size(); dim++ )
1441	{
1442	if ( m_dimIds[dim][i] != m_dimIds[dim][j] )
1443	{
1444	numDiff ++;
1445	lastDiff = dim;
1446	}
1447	}
1448
1449	Bool allEqual = ( numDiff == 0 );
1450
1451	if ( allEqual )
1452	{
1453	printf( "\nError: Positions of Layers %d and %d are identical in scalability space\n", i, j);
1454	}
1455
1456	xConfirmPara( allEqual , "Each layer shall have a different position in scalability space." );
1457
1458	#if !H_3D_FCO
1459	if ( numDiff == 1 )
1460	{
1461	Bool inc = m_dimIds[ lastDiff ][ i ] > m_dimIds[ lastDiff ][ j ];
1462	Bool shallBeButIsNotIncreasing = ( !inc ) ;
1463	if ( shallBeButIsNotIncreasing )
1464	{
1465	printf( "\nError: Positions of Layers %d and %d is not increasing in dimension %d \n", i, j, lastDiff);
1466	}
1467	xConfirmPara( shallBeButIsNotIncreasing, "DimensionIds shall be increasing within one dimension. " );
1468	}
1469	#endif
1470	}
1471	}
1472
1473	/// ViewId
1474	xConfirmPara( m_viewId.size() != m_iNumberOfViews, "The number of ViewIds must be equal to the number of views." );
1475
1476	/// Layer sets
1477	xConfirmPara( m_vpsNumLayerSets < 0 \|\| m_vpsNumLayerSets > 1024, "VpsNumLayerSets must be greater than 0 and less than 1025. ") ;
1478	for( Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++ )
1479	{
1480	if (lsIdx == 0)
1481	{
1482	xConfirmPara( m_layerIdsInSets[lsIdx].size() != 1 \|\| m_layerIdsInSets[lsIdx][0] != 0 , "0-th layer shall only include layer 0. ");
1483	}
1484	for ( Int i = 0; i < m_layerIdsInSets[lsIdx].size(); i++ )
1485	{
1486	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" );
1487	}
1488	}
1489
1490	// Output layer sets
1491	xConfirmPara( m_outputLayerSetIdx.size() > 1024, "The number of output layer set indices must be less than 1025.") ;
1492	for (Int lsIdx = 0; lsIdx < m_outputLayerSetIdx.size(); lsIdx++)
1493	{
1494	Int refLayerSetIdx = m_outputLayerSetIdx[ lsIdx ];
1495	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." );
1496	}
1497
1498	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." );
1499
1500	if( m_defaultOutputLayerIdc != 2 )
1501	{
1502	Bool anyDefaultOutputFlag = false;
1503	for (Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++)
1504	{
1505	anyDefaultOutputFlag = anyDefaultOutputFlag \|\| ( m_layerIdsInDefOutputLayerSet[lsIdx].size() != 0 );
1506	}
1507	if ( anyDefaultOutputFlag )
1508	{
1509	printf( "\nWarning: Ignoring LayerIdsInDefOutputLayerSet parameters, since defaultTargetOuputLayerIdc is not equal 2.\n" );
1510	}
1511	}
1512	else
1513	{
1514	for (Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++)
1515	{
1516	for (Int i = 0; i < m_layerIdsInDefOutputLayerSet[ lsIdx ].size(); i++)
1517	{
1518	Bool inLayerSetFlag = false;
1519	for (Int j = 0; j < m_layerIdsInSets[ lsIdx].size(); j++ )
1520	{
1521	if ( m_layerIdsInSets[ lsIdx ][ j ] == m_layerIdsInDefOutputLayerSet[ lsIdx ][ i ] )
1522	{
1523	inLayerSetFlag = true;
1524	break;
1525	}
1526	}
1527	xConfirmPara( !inLayerSetFlag, "All output layers of a output layer set must be included in corresponding layer set.");
1528	}
1529	}
1530	}
1531
1532	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" );
1533
1534	// PTL
1535	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." );
1536
1537	if ( m_numberOfLayers > 1)
1538	{
1539	xConfirmPara( m_profile.size() <= 1, "The number of profiles, tiers, levels, and inblFlags must be greater than 1.");
1540	xConfirmPara( m_inblFlag[0], "VpsProfileTierLevel[0] must have inblFlag equal to 0");
1541	if (m_profile.size() > 1 )
1542	{
1543	xConfirmPara( m_profile[0] != m_profile[1], "The profile in VpsProfileTierLevel[1] must be equal to the profile in VpsProfileTierLevel[0].");
1544	xConfirmPara( m_inblFlag[0] != m_inblFlag[1], "inblFlag in VpsProfileTierLevel[1] must be equal to the inblFlag in VpsProfileTierLevel[0].");
1545	}
1546	}
1547
1548	// Layer Dependencies
1549	for (Int i = 0; i < m_numberOfLayers; i++ )
1550	{
1551	xConfirmPara( (i == 0) && m_directRefLayers[0].size() != 0, "Layer 0 shall not have reference layers." );
1552	xConfirmPara( m_directRefLayers[i].size() != m_dependencyTypes[ i ].size(), "Each reference layer shall have a reference type." );
1553	for (Int j = 0; j < m_directRefLayers[i].size(); j++)
1554	{
1555	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");
1556	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");
1557	}
1558	}
1559	#endif
1560	xConfirmPara( m_iGOPSize < 1 , "GOP Size must be greater or equal to 1" );
1561	xConfirmPara( m_iGOPSize > 1 && m_iGOPSize % 2, "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
1562	#if H_MV
1563	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1564	{
1565	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" );
1566	}
1567	#else
1568	xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) \|\| m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
1569	#endif
1570	#if ALLOW_RECOVERY_POINT_AS_RAP
1571	xConfirmPara( m_iDecodingRefreshType < 0 \|\| m_iDecodingRefreshType > 3, "Decoding Refresh Type must be comprised between 0 and 3 included" );
1572	if(m_iDecodingRefreshType == 3)
1573	{
1574	xConfirmPara( !m_recoveryPointSEIEnabled, "When using RecoveryPointSEI messages as RA points, recoveryPointSEI must be enabled" );
1575	}
1576	#else
1577	xConfirmPara( m_iDecodingRefreshType < 0 \|\| m_iDecodingRefreshType > 2, "Decoding Refresh Type must be equal to 0, 1 or 2" );
1578	#endif
1579	#if H_MV
1580	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1581	{
1582	xConfirmPara( m_iQP[layer] < -6 * (m_internalBitDepthY - 8) \|\| m_iQP[layer] > 51, "QP exceeds supported range (-QpBDOffsety to 51)" );
1583	}
1584	#else
1585	xConfirmPara( m_iQP < -6 * (m_internalBitDepthY - 8) \|\| m_iQP > 51, "QP exceeds supported range (-QpBDOffsety to 51)" );
1586	#endif
1587	xConfirmPara( m_loopFilterBetaOffsetDiv2 < -6 \|\| m_loopFilterBetaOffsetDiv2 > 6, "Loop Filter Beta Offset div. 2 exceeds supported range (-6 to 6)");
1588	xConfirmPara( m_loopFilterTcOffsetDiv2 < -6 \|\| m_loopFilterTcOffsetDiv2 > 6, "Loop Filter Tc Offset div. 2 exceeds supported range (-6 to 6)");
1589	xConfirmPara( m_iFastSearch < 0 \|\| m_iFastSearch > 2, "Fast Search Mode is not supported value (0:Full search 1:Diamond 2:PMVFAST)" );
1590	xConfirmPara( m_iSearchRange < 0 , "Search Range must be more than 0" );
1591	xConfirmPara( m_bipredSearchRange < 0 , "Search Range must be more than 0" );
1592	#ifdef SONY_MV_V_CONST_C0078
1593	xConfirmPara( m_iVerticalDisparitySearchRange <= 0 , "Vertical Disparity Search Range must be more than 0" );
1594	#endif
1595	xConfirmPara( m_iMaxDeltaQP > 7, "Absolute Delta QP exceeds supported range (0 to 7)" );
1596	xConfirmPara( m_iMaxCuDQPDepth > m_uiMaxCUDepth - 1, "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
1597
1598	xConfirmPara( m_cbQpOffset < -12, "Min. Chroma Cb QP Offset is -12" );
1599	xConfirmPara( m_cbQpOffset > 12, "Max. Chroma Cb QP Offset is 12" );
1600	xConfirmPara( m_crQpOffset < -12, "Min. Chroma Cr QP Offset is -12" );
1601	xConfirmPara( m_crQpOffset > 12, "Max. Chroma Cr QP Offset is 12" );
1602
1603	xConfirmPara( m_iQPAdaptationRange <= 0, "QP Adaptation Range must be more than 0" );
1604	if (m_iDecodingRefreshType == 2)
1605	{
1606	#if H_MV
1607	for (Int i = 0; i < m_numberOfLayers; i++ )
1608	{
1609	xConfirmPara( m_iIntraPeriod[i] > 0 && m_iIntraPeriod[i] <= m_iGOPSize , "Intra period must be larger than GOP size for periodic IDR pictures");
1610	}
1611	#else
1612	xConfirmPara( m_iIntraPeriod > 0 && m_iIntraPeriod <= m_iGOPSize , "Intra period must be larger than GOP size for periodic IDR pictures");
1613	#endif
1614	}
1615	xConfirmPara( (m_uiMaxCUWidth >> m_uiMaxCUDepth) < 4, "Minimum partition width size should be larger than or equal to 8");
1616	xConfirmPara( (m_uiMaxCUHeight >> m_uiMaxCUDepth) < 4, "Minimum partition height size should be larger than or equal to 8");
1617	xConfirmPara( m_uiMaxCUWidth < 16, "Maximum partition width size should be larger than or equal to 16");
1618	xConfirmPara( m_uiMaxCUHeight < 16, "Maximum partition height size should be larger than or equal to 16");
1619	xConfirmPara( (m_iSourceWidth % (m_uiMaxCUWidth >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame width must be a multiple of the minimum CU size");
1620	xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame height must be a multiple of the minimum CU size");
1621
1622	xConfirmPara( m_uiQuadtreeTULog2MinSize < 2, "QuadtreeTULog2MinSize must be 2 or greater.");
1623	xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5, "QuadtreeTULog2MaxSize must be 5 or smaller.");
1624	xConfirmPara( (1<<m_uiQuadtreeTULog2MaxSize) > m_uiMaxCUWidth, "QuadtreeTULog2MaxSize must be log2(maxCUSize) or smaller.");
1625
1626	xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize, "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize.");
1627	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1628	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUHeight>>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1629	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUWidth >> m_uiMaxCUDepth ), "Minimum CU width must be greater than minimum transform size." );
1630	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." );
1631	xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1, "QuadtreeTUMaxDepthInter must be greater than or equal to 1" );
1632	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" );
1633	xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1, "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" );
1634	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" );
1635
1636	xConfirmPara( m_maxNumMergeCand < 1, "MaxNumMergeCand must be 1 or greater.");
1637	xConfirmPara( m_maxNumMergeCand > 5, "MaxNumMergeCand must be 5 or smaller.");
1638
1639	#if H_3D_ARP
1640	#endif
1641	#if H_3D_SPIVMP
1642	xConfirmPara( m_log2SubPbSizeMinus3 < 0, "Log2SubPbSizeMinus3 must be equal to 0 or greater.");
1643	xConfirmPara( m_log2SubPbSizeMinus3 > 3, "Log2SubPbSizeMinus3 must be equal to 3 or smaller.");
1644	xConfirmPara( (1<< ( m_log2SubPbSizeMinus3 + 3) ) > m_uiMaxCUWidth, "Log2SubPbSizeMinus3 must be equal to log2(maxCUSize)-3 or smaller.");
1645
1646	xConfirmPara( m_log2MpiSubPbSizeMinus3 < 0, "Log2MpiSubPbSizeMinus3 must be equal to 0 or greater.");
1647	xConfirmPara( m_log2MpiSubPbSizeMinus3 > 3, "Log2MpiSubPbSizeMinus3 must be equal to 3 or smaller.");
1648	xConfirmPara( (1<< (m_log2MpiSubPbSizeMinus3 + 3)) > m_uiMaxCUWidth, "Log2MpiSubPbSizeMinus3 must be equal to log2(maxCUSize)-3 or smaller.");
1649	#endif
1650	#if ADAPTIVE_QP_SELECTION
1651	#if H_MV
1652	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1653	{
1654	xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP[layer] < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
1655	}
1656	#else
1657	xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
1658	#endif
1659	xConfirmPara( m_bUseAdaptQpSelect == true && (m_cbQpOffset !=0 \|\| m_crQpOffset != 0 ), "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
1660	#endif
1661
1662	if( m_usePCM)
1663	{
1664	xConfirmPara( m_uiPCMLog2MinSize < 3, "PCMLog2MinSize must be 3 or greater.");
1665	xConfirmPara( m_uiPCMLog2MinSize > 5, "PCMLog2MinSize must be 5 or smaller.");
1666	xConfirmPara( m_pcmLog2MaxSize > 5, "PCMLog2MaxSize must be 5 or smaller.");
1667	xConfirmPara( m_pcmLog2MaxSize < m_uiPCMLog2MinSize, "PCMLog2MaxSize must be equal to or greater than m_uiPCMLog2MinSize.");
1668	}
1669
1670	xConfirmPara( m_sliceMode < 0 \|\| m_sliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
1671	if (m_sliceMode!=0)
1672	{
1673	xConfirmPara( m_sliceArgument < 1 , "SliceArgument should be larger than or equal to 1" );
1674	}
1675	xConfirmPara( m_sliceSegmentMode < 0 \|\| m_sliceSegmentMode > 3, "SliceSegmentMode exceeds supported range (0 to 3)" );
1676	if (m_sliceSegmentMode!=0)
1677	{
1678	xConfirmPara( m_sliceSegmentArgument < 1 , "SliceSegmentArgument should be larger than or equal to 1" );
1679	}
1680
1681	Bool tileFlag = (m_numTileColumnsMinus1 > 0 \|\| m_numTileRowsMinus1 > 0 );
1682	xConfirmPara( tileFlag && m_iWaveFrontSynchro, "Tile and Wavefront can not be applied together");
1683
1684	//TODO:ChromaFmt assumes 4:2:0 below
1685	xConfirmPara( m_iSourceWidth % TComSPS::getWinUnitX(CHROMA_420) != 0, "Picture width must be an integer multiple of the specified chroma subsampling");
1686	xConfirmPara( m_iSourceHeight % TComSPS::getWinUnitY(CHROMA_420) != 0, "Picture height must be an integer multiple of the specified chroma subsampling");
1687
1688	xConfirmPara( m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0, "Horizontal padding must be an integer multiple of the specified chroma subsampling");
1689	xConfirmPara( m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0, "Vertical padding must be an integer multiple of the specified chroma subsampling");
1690
1691	xConfirmPara( m_confWinLeft % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left conformance window offset must be an integer multiple of the specified chroma subsampling");
1692	xConfirmPara( m_confWinRight % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right conformance window offset must be an integer multiple of the specified chroma subsampling");
1693	xConfirmPara( m_confWinTop % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top conformance window offset must be an integer multiple of the specified chroma subsampling");
1694	xConfirmPara( m_confWinBottom % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom conformance window offset must be an integer multiple of the specified chroma subsampling");
1695
1696	xConfirmPara( m_defaultDisplayWindowFlag && !m_vuiParametersPresentFlag, "VUI needs to be enabled for default display window");
1697
1698	if (m_defaultDisplayWindowFlag)
1699	{
1700	xConfirmPara( m_defDispWinLeftOffset % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left default display window offset must be an integer multiple of the specified chroma subsampling");
1701	xConfirmPara( m_defDispWinRightOffset % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right default display window offset must be an integer multiple of the specified chroma subsampling");
1702	xConfirmPara( m_defDispWinTopOffset % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top default display window offset must be an integer multiple of the specified chroma subsampling");
1703	xConfirmPara( m_defDispWinBottomOffset % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom default display window offset must be an integer multiple of the specified chroma subsampling");
1704	}
1705
1706	#if H_3D
1707	xConfirmPara( m_pchCameraParameterFile == 0 , "CameraParameterFile must be given");
1708	xConfirmPara( m_pchBaseViewCameraNumbers == 0 , "BaseViewCameraNumbers must be given" );
1709	#if BUG_FIX_TK65
1710	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" );
1711	#else
1712	xConfirmPara( ((UInt) m_numberOfLayers >> 1 ) != m_cCameraData.getBaseViewNumbers().size(), "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
1713	#endif
1714	xConfirmPara ( m_iCodedCamParPrecision < 0 \|\| m_iCodedCamParPrecision > 5, "CodedCamParsPrecision must be in range of 0..5" );
1715	#if H_3D_VSO
1716	if( m_bUseVSO )
1717	{
1718	xConfirmPara( m_pchVSOConfig == 0 , "VSO Setup string must be given");
1719	xConfirmPara( m_uiVSOMode > 4 , "VSO Mode must be less than 5");
1720	}
1721	#endif
1722	#endif
1723	// max CU width and height should be power of 2
1724	UInt ui = m_uiMaxCUWidth;
1725	while(ui)
1726	{
1727	ui >>= 1;
1728	if( (ui & 1) == 1)
1729	xConfirmPara( ui != 1 , "Width should be 2^n");
1730	}
1731	ui = m_uiMaxCUHeight;
1732	while(ui)
1733	{
1734	ui >>= 1;
1735	if( (ui & 1) == 1)
1736	xConfirmPara( ui != 1 , "Height should be 2^n");
1737	}
1738
1739	#if H_MV
1740	// validate that POC of same frame is identical across multiple layers
1741	Bool bErrorMvePoc = false;
1742	if( m_numberOfLayers > 1 )
1743	{
1744	for( Int k = 1; k < m_numberOfLayers; k++ )
1745	{
1746	for( Int i = 0; i < MAX_GOP; i++ )
1747	{
1748	if( m_GOPListMvc[k][i].m_POC != m_GOPListMvc[0][i].m_POC )
1749	{
1750	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 );
1751	bErrorMvePoc = true;
1752	}
1753	}
1754	}
1755	}
1756	xConfirmPara( bErrorMvePoc, "Invalid inter-layer POC structure given" );
1757
1758	// validate that baseview has no inter-view refs
1759	Bool bErrorIvpBase = false;
1760	for( Int i = 0; i < MAX_GOP; i++ )
1761	{
1762	if( m_GOPListMvc[0][i].m_numActiveRefLayerPics != 0 )
1763	{
1764	printf( "\nError: Frame%d inter_layer refs not available in layer 0\n", i );
1765	bErrorIvpBase = true;
1766	}
1767	}
1768	xConfirmPara( bErrorIvpBase, "Inter-layer refs not possible in base layer" );
1769
1770	// validate inter-view refs
1771	Bool bErrorIvpEnhV = false;
1772	if( m_numberOfLayers > 1 )
1773	{
1774	for( Int layer = 1; layer < m_numberOfLayers; layer++ )
1775	{
1776	for( Int i = 0; i < MAX_GOP+1; i++ )
1777	{
1778	GOPEntry gopEntry = m_GOPListMvc[layer][i];
1779	for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1780	{
1781	Int ilPredLayerIdc = gopEntry.m_interLayerPredLayerIdc[j];
1782	if( ilPredLayerIdc < 0 \|\| ilPredLayerIdc >= m_directRefLayers[layer].size() )
1783	{
1784	printf( "\nError: inter-layer ref idc %d is not available for Frame%d_l%d\n", gopEntry.m_interLayerPredLayerIdc[j], i, layer );
1785	bErrorIvpEnhV = true;
1786	}
1787	if( gopEntry.m_interViewRefPosL[0][j] < -1 \|\| gopEntry.m_interViewRefPosL[0][j] > gopEntry.m_numRefPicsActive )
1788	{
1789	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 );
1790	bErrorIvpEnhV = true;
1791	}
1792	if( gopEntry.m_interViewRefPosL[1][j] < -1 \|\| gopEntry.m_interViewRefPosL[1][j] > gopEntry.m_numRefPicsActive )
1793	{
1794	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 );
1795	bErrorIvpEnhV = true;
1796	}
1797	}
1798	if( i == MAX_GOP ) // inter-view refs at I pic position in base view
1799	{
1800	if( gopEntry.m_sliceType != 'B' && gopEntry.m_sliceType != 'P' && gopEntry.m_sliceType != 'I' )
1801	{
1802	printf( "\nError: slice type of FrameI_l%d must be equal to B or P or I\n", layer );
1803	bErrorIvpEnhV = true;
1804	}
1805
1806	if( gopEntry.m_POC != 0 )
1807	{
1808	printf( "\nError: POC %d not possible for FrameI_l%d, must be 0\n", gopEntry.m_POC, layer );
1809	bErrorIvpEnhV = true;
1810	}
1811
1812	if( gopEntry.m_temporalId != 0 )
1813	{
1814	printf( "\nWarning: Temporal id of FrameI_l%d must be 0 (cp. I-frame in base layer)\n", layer );
1815	gopEntry.m_temporalId = 0;
1816	}
1817
1818	if( gopEntry.m_numRefPics != 0 )
1819	{
1820	printf( "\nWarning: temporal references not possible for FrameI_l%d\n", layer );
1821	for( Int j = 0; j < m_GOPListMvc[layer][MAX_GOP].m_numRefPics; j++ )
1822	{
1823	gopEntry.m_referencePics[j] = 0;
1824	}
1825	gopEntry.m_numRefPics = 0;
1826	}
1827
1828	if( gopEntry.m_interRPSPrediction )
1829	{
1830	printf( "\nError: inter RPS prediction not possible for FrameI_l%d, must be 0\n", layer );
1831	bErrorIvpEnhV = true;
1832	}
1833
1834	if( gopEntry.m_sliceType == 'I' && gopEntry.m_numActiveRefLayerPics != 0 )
1835	{
1836	printf( "\nError: inter-layer prediction not possible for FrameI_l%d with slice type I, #IL_ref_pics must be 0\n", layer );
1837	bErrorIvpEnhV = true;
1838	}
1839
1840	if( gopEntry.m_numRefPicsActive > gopEntry.m_numActiveRefLayerPics )
1841	{
1842	gopEntry.m_numRefPicsActive = gopEntry.m_numActiveRefLayerPics;
1843	}
1844
1845	if( gopEntry.m_sliceType == 'P' )
1846	{
1847	if( gopEntry.m_numActiveRefLayerPics < 1 )
1848	{
1849	printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type P\n", layer );
1850	bErrorIvpEnhV = true;
1851	}
1852	else
1853	{
1854	for( Int j = 0; j < gopEntry.m_numActiveRefLayerPics; j++ )
1855	{
1856	if( gopEntry.m_interViewRefPosL[1][j] != -1 )
1857	{
1858	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 );
1859	bErrorIvpEnhV = true;
1860	}
1861	}
1862	}
1863	}
1864
1865	if( gopEntry.m_sliceType == 'B' && gopEntry.m_numActiveRefLayerPics < 1 )
1866	{
1867	printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type B\n", layer );
1868	bErrorIvpEnhV = true;
1869	}
1870	}
1871	}
1872	}
1873	}
1874	xConfirmPara( bErrorIvpEnhV, "Invalid inter-layer coding structure for enhancement layers given" );
1875
1876	// validate temporal coding structure
1877	if( !bErrorMvePoc && !bErrorIvpBase && !bErrorIvpEnhV )
1878	{
1879	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1880	{
1881	GOPEntry* m_GOPList = m_GOPListMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1882	Int& m_extraRPSs = m_extraRPSsMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1883	Int& m_maxTempLayer = m_maxTempLayerMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1884	Int* m_maxDecPicBuffering = m_maxDecPicBufferingMvc[layer]; // It is not a member, but this name helps avoiding code duplication !!!
1885	Int* m_numReorderPics = m_numReorderPicsMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1886	#endif
1887	/* if this is an intra-only sequence, ie IntraPeriod=1, don't verify the GOP structure
1888	* This permits the ability to omit a GOP structure specification */
1889	#if H_MV
1890	if (m_iIntraPeriod[layer] == 1 && m_GOPList[0].m_POC == -1) {
1891	#else
1892	if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
1893	#endif
1894	m_GOPList[0] = GOPEntry();
1895	m_GOPList[0].m_QPFactor = 1;
1896	m_GOPList[0].m_betaOffsetDiv2 = 0;
1897	m_GOPList[0].m_tcOffsetDiv2 = 0;
1898	m_GOPList[0].m_POC = 1;
1899	m_GOPList[0].m_numRefPicsActive = 4;
1900	}
1901
1902	Bool verifiedGOP=false;
1903	Bool errorGOP=false;
1904	Int checkGOP=1;
1905	Int numRefs = m_isField ? 2 : 1;
1906	Int refList[MAX_NUM_REF_PICS+1];
1907	refList[0]=0;
1908	if(m_isField)
1909	{
1910	refList[1] = 1;
1911	}
1912	Bool isOK[MAX_GOP];
1913	for(Int i=0; i<MAX_GOP; i++)
1914	{
1915	isOK[i]=false;
1916	}
1917	Int numOK=0;
1918	#if H_MV
1919	xConfirmPara( m_iIntraPeriod[layer] >=0&&(m_iIntraPeriod[layer]%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
1920	#else
1921	xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
1922	#endif
1923
1924	for(Int i=0; i<m_iGOPSize; i++)
1925	{
1926	if(m_GOPList[i].m_POC==m_iGOPSize)
1927	{
1928	xConfirmPara( m_GOPList[i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
1929	}
1930	}
1931
1932	#if H_MV
1933	if ( (m_iIntraPeriod[layer] != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable[layer]) )
1934	#else
1935	if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
1936	#endif
1937	{
1938	for(Int i=0; i<m_iGOPSize; i++)
1939	{
1940	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)" );
1941	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)" );
1942	}
1943	}
1944	m_extraRPSs=0;
1945	//start looping through frames in coding order until we can verify that the GOP structure is correct.
1946	while(!verifiedGOP&&!errorGOP)
1947	{
1948	Int curGOP = (checkGOP-1)%m_iGOPSize;
1949	Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC;
1950	if(m_GOPList[curGOP].m_POC<0)
1951	{
1952	#if H_MV
1953	printf("\nError: found fewer Reference Picture Sets than GOPSize for layer %d\n", layer );
1954	#else
1955	printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
1956	#endif
1957	errorGOP=true;
1958	}
1959	else
1960	{
1961	//check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
1962	Bool beforeI = false;
1963	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
1964	{
1965	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1966	if(absPOC < 0)
1967	{
1968	beforeI=true;
1969	}
1970	else
1971	{
1972	Bool found=false;
1973	for(Int j=0; j<numRefs; j++)
1974	{
1975	if(refList[j]==absPOC)
1976	{
1977	found=true;
1978	for(Int k=0; k<m_iGOPSize; k++)
1979	{
1980	if(absPOC%m_iGOPSize == m_GOPList[k].m_POC%m_iGOPSize)
1981	{
1982	if(m_GOPList[k].m_temporalId==m_GOPList[curGOP].m_temporalId)
1983	{
1984	m_GOPList[k].m_refPic = true;
1985	}
1986	m_GOPList[curGOP].m_usedByCurrPic[i]=m_GOPList[k].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1987	}
1988	}
1989	}
1990	}
1991	if(!found)
1992	{
1993	#if H_MV
1994	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);
1995	#else
1996	printf("\nError: ref pic %d is not available for GOP frame %d\n",m_GOPList[curGOP].m_referencePics[i],curGOP+1);
1997	#endif
1998	errorGOP=true;
1999	}
2000	}
2001	}
2002	if(!beforeI&&!errorGOP)
2003	{
2004	//all ref frames were present
2005	if(!isOK[curGOP])
2006	{
2007	numOK++;
2008	isOK[curGOP]=true;
2009	if(numOK==m_iGOPSize)
2010	{
2011	verifiedGOP=true;
2012	}
2013	}
2014	}
2015	else
2016	{
2017	//create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
2018	m_GOPList[m_iGOPSize+m_extraRPSs]=m_GOPList[curGOP];
2019	Int newRefs=0;
2020	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
2021	{
2022	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
2023	if(absPOC>=0)
2024	{
2025	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
2026	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
2027	newRefs++;
2028	}
2029	}
2030	Int numPrefRefs = m_GOPList[curGOP].m_numRefPicsActive;
2031
2032	for(Int offset = -1; offset>-checkGOP; offset--)
2033	{
2034	//step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
2035	Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
2036	Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_GOPList[offGOP].m_POC;
2037	if(offPOC>=0&&m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId)
2038	{
2039	Bool newRef=false;
2040	for(Int i=0; i<numRefs; i++)
2041	{
2042	if(refList[i]==offPOC)
2043	{
2044	newRef=true;
2045	}
2046	}
2047	for(Int i=0; i<newRefs; i++)
2048	{
2049	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[i]==offPOC-curPOC)
2050	{
2051	newRef=false;
2052	}
2053	}
2054	if(newRef)
2055	{
2056	Int insertPoint=newRefs;
2057	//this picture can be added, find appropriate place in list and insert it.
2058	if(m_GOPList[offGOP].m_temporalId==m_GOPList[curGOP].m_temporalId)
2059	{
2060	m_GOPList[offGOP].m_refPic = true;
2061	}
2062	for(Int j=0; j<newRefs; j++)
2063	{
2064	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]<offPOC-curPOC\|\|m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]>0)
2065	{
2066	insertPoint = j;
2067	break;
2068	}
2069	}
2070	Int prev = offPOC-curPOC;
2071	Int prevUsed = m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId;
2072	for(Int j=insertPoint; j<newRefs+1; j++)
2073	{
2074	Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j];
2075	Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j];
2076	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]=prev;
2077	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j]=prevUsed;
2078	prevUsed=newUsed;
2079	prev=newPrev;
2080	}
2081	newRefs++;
2082	}
2083	}
2084	if(newRefs>=numPrefRefs)
2085	{
2086	break;
2087	}
2088	}
2089	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics=newRefs;
2090	m_GOPList[m_iGOPSize+m_extraRPSs].m_POC = curPOC;
2091	if (m_extraRPSs == 0)
2092	{
2093	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 0;
2094	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = 0;
2095	}
2096	else
2097	{
2098	Int rIdx = m_iGOPSize + m_extraRPSs - 1;
2099	Int refPOC = m_GOPList[rIdx].m_POC;
2100	Int refPics = m_GOPList[rIdx].m_numRefPics;
2101	Int newIdc=0;
2102	for(Int i = 0; i<= refPics; i++)
2103	{
2104	Int deltaPOC = ((i != refPics)? m_GOPList[rIdx].m_referencePics[i] : 0); // check if the reference abs POC is >= 0
2105	Int absPOCref = refPOC+deltaPOC;
2106	Int refIdc = 0;
2107	for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics; j++)
2108	{
2109	if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j])
2110	{
2111	if (m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j])
2112	{
2113	refIdc = 1;
2114	}
2115	else
2116	{
2117	refIdc = 2;
2118	}
2119	}
2120	}
2121	m_GOPList[m_iGOPSize+m_extraRPSs].m_refIdc[newIdc]=refIdc;
2122	newIdc++;
2123	}
2124	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1;
2125	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = newIdc;
2126	m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC;
2127	}
2128	curGOP=m_iGOPSize+m_extraRPSs;
2129	m_extraRPSs++;
2130	}
2131	numRefs=0;
2132	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
2133	{
2134	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
2135	if(absPOC >= 0)
2136	{
2137	refList[numRefs]=absPOC;
2138	numRefs++;
2139	}
2140	}
2141	refList[numRefs]=curPOC;
2142	numRefs++;
2143	}
2144	checkGOP++;
2145	}
2146	xConfirmPara(errorGOP,"Invalid GOP structure given");
2147	m_maxTempLayer = 1;
2148	for(Int i=0; i<m_iGOPSize; i++)
2149	{
2150	if(m_GOPList[i].m_temporalId >= m_maxTempLayer)
2151	{
2152	m_maxTempLayer = m_GOPList[i].m_temporalId+1;
2153	}
2154	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");
2155	}
2156	for(Int i=0; i<MAX_TLAYER; i++)
2157	{
2158	m_numReorderPics[i] = 0;
2159	m_maxDecPicBuffering[i] = 1;
2160	}
2161	for(Int i=0; i<m_iGOPSize; i++)
2162	{
2163	if(m_GOPList[i].m_numRefPics+1 > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
2164	{
2165	m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1;
2166	}
2167	Int highestDecodingNumberWithLowerPOC = 0;
2168	for(Int j=0; j<m_iGOPSize; j++)
2169	{
2170	if(m_GOPList[j].m_POC <= m_GOPList[i].m_POC)
2171	{
2172	highestDecodingNumberWithLowerPOC = j;
2173	}
2174	}
2175	Int numReorder = 0;
2176	for(Int j=0; j<highestDecodingNumberWithLowerPOC; j++)
2177	{
2178	if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId &&
2179	m_GOPList[j].m_POC > m_GOPList[i].m_POC)
2180	{
2181	numReorder++;
2182	}
2183	}
2184	if(numReorder > m_numReorderPics[m_GOPList[i].m_temporalId])
2185	{
2186	m_numReorderPics[m_GOPList[i].m_temporalId] = numReorder;
2187	}
2188	}
2189	for(Int i=0; i<MAX_TLAYER-1; i++)
2190	{
2191	// a lower layer can not have higher value of m_numReorderPics than a higher layer
2192	if(m_numReorderPics[i+1] < m_numReorderPics[i])
2193	{
2194	m_numReorderPics[i+1] = m_numReorderPics[i];
2195	}
2196	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
2197	if(m_numReorderPics[i] > m_maxDecPicBuffering[i] - 1)
2198	{
2199	m_maxDecPicBuffering[i] = m_numReorderPics[i] + 1;
2200	}
2201	// a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
2202	if(m_maxDecPicBuffering[i+1] < m_maxDecPicBuffering[i])
2203	{
2204	m_maxDecPicBuffering[i+1] = m_maxDecPicBuffering[i];
2205	}
2206	}
2207
2208
2209	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
2210	if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1)
2211	{
2212	m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1] + 1;
2213	}
2214
2215	if(m_vuiParametersPresentFlag && m_bitstreamRestrictionFlag)
2216	{
2217	Int PicSizeInSamplesY = m_iSourceWidth * m_iSourceHeight;
2218	if(tileFlag)
2219	{
2220	Int maxTileWidth = 0;
2221	Int maxTileHeight = 0;
2222	Int widthInCU = (m_iSourceWidth % m_uiMaxCUWidth) ? m_iSourceWidth/m_uiMaxCUWidth + 1: m_iSourceWidth/m_uiMaxCUWidth;
2223	Int heightInCU = (m_iSourceHeight % m_uiMaxCUHeight) ? m_iSourceHeight/m_uiMaxCUHeight + 1: m_iSourceHeight/m_uiMaxCUHeight;
2224	if(m_tileUniformSpacingFlag)
2225	{
2226	maxTileWidth = m_uiMaxCUWidth*((widthInCU+m_numTileColumnsMinus1)/(m_numTileColumnsMinus1+1));
2227	maxTileHeight = m_uiMaxCUHeight*((heightInCU+m_numTileRowsMinus1)/(m_numTileRowsMinus1+1));
2228	// if only the last tile-row is one treeblock higher than the others
2229	// the maxTileHeight becomes smaller if the last row of treeblocks has lower height than the others
2230	if(!((heightInCU-1)%(m_numTileRowsMinus1+1)))
2231	{
2232	maxTileHeight = maxTileHeight - m_uiMaxCUHeight + (m_iSourceHeight % m_uiMaxCUHeight);
2233	}
2234	// if only the last tile-column is one treeblock wider than the others
2235	// the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others
2236	if(!((widthInCU-1)%(m_numTileColumnsMinus1+1)))
2237	{
2238	maxTileWidth = maxTileWidth - m_uiMaxCUWidth + (m_iSourceWidth % m_uiMaxCUWidth);
2239	}
2240	}
2241	else // not uniform spacing
2242	{
2243	if(m_numTileColumnsMinus1<1)
2244	{
2245	maxTileWidth = m_iSourceWidth;
2246	}
2247	else
2248	{
2249	Int accColumnWidth = 0;
2250	for(Int col=0; col<(m_numTileColumnsMinus1); col++)
2251	{
2252	maxTileWidth = m_tileColumnWidth[col]>maxTileWidth ? m_tileColumnWidth[col]:maxTileWidth;
2253	accColumnWidth += m_tileColumnWidth[col];
2254	}
2255	maxTileWidth = (widthInCU-accColumnWidth)>maxTileWidth ? m_uiMaxCUWidth(widthInCU-accColumnWidth):m_uiMaxCUWidthmaxTileWidth;
2256	}
2257	if(m_numTileRowsMinus1<1)
2258	{
2259	maxTileHeight = m_iSourceHeight;
2260	}
2261	else
2262	{
2263	Int accRowHeight = 0;
2264	for(Int row=0; row<(m_numTileRowsMinus1); row++)
2265	{
2266	maxTileHeight = m_tileRowHeight[row]>maxTileHeight ? m_tileRowHeight[row]:maxTileHeight;
2267	accRowHeight += m_tileRowHeight[row];
2268	}
2269	maxTileHeight = (heightInCU-accRowHeight)>maxTileHeight ? m_uiMaxCUHeight(heightInCU-accRowHeight):m_uiMaxCUHeightmaxTileHeight;
2270	}
2271	}
2272	Int maxSizeInSamplesY = maxTileWidth*maxTileHeight;
2273	m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/maxSizeInSamplesY-4;
2274	}
2275	else if(m_iWaveFrontSynchro)
2276	{
2277	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/((2m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4;
2278	}
2279	else if(m_sliceMode == 1)
2280	{
2281	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/(m_sliceArgumentm_uiMaxCUWidth*m_uiMaxCUHeight)-4;
2282	}
2283	else
2284	{
2285	m_minSpatialSegmentationIdc = 0;
2286	}
2287	}
2288	xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
2289	xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
2290	xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
2291
2292	xConfirmPara( m_decodedPictureHashSEIEnabled<0 \|\| m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n");
2293
2294	if (m_toneMappingInfoSEIEnabled)
2295	{
2296	xConfirmPara( m_toneMapCodedDataBitDepth < 8 \|\| m_toneMapCodedDataBitDepth > 14 , "SEIToneMapCodedDataBitDepth must be in rage 8 to 14");
2297	xConfirmPara( m_toneMapTargetBitDepth < 1 \|\| (m_toneMapTargetBitDepth > 16 && m_toneMapTargetBitDepth < 255) , "SEIToneMapTargetBitDepth must be in rage 1 to 16 or equal to 255");
2298	xConfirmPara( m_toneMapModelId < 0 \|\| m_toneMapModelId > 4 , "SEIToneMapModelId must be in rage 0 to 4");
2299	xConfirmPara( m_cameraIsoSpeedValue == 0, "SEIToneMapCameraIsoSpeedValue shall not be equal to 0");
2300	xConfirmPara( m_exposureIndexValue == 0, "SEIToneMapExposureIndexValue shall not be equal to 0");
2301	xConfirmPara( m_extendedRangeWhiteLevel < 100, "SEIToneMapExtendedRangeWhiteLevel should be greater than or equal to 100");
2302	xConfirmPara( m_nominalBlackLevelLumaCodeValue >= m_nominalWhiteLevelLumaCodeValue, "SEIToneMapNominalWhiteLevelLumaCodeValue shall be greater than SEIToneMapNominalBlackLevelLumaCodeValue");
2303	xConfirmPara( m_extendedWhiteLevelLumaCodeValue < m_nominalWhiteLevelLumaCodeValue, "SEIToneMapExtendedWhiteLevelLumaCodeValue shall be greater than or equal to SEIToneMapNominalWhiteLevelLumaCodeValue");
2304	}
2305
2306	if ( m_RCEnableRateControl )
2307	{
2308	if ( m_RCForceIntraQP )
2309	{
2310	if ( m_RCInitialQP == 0 )
2311	{
2312	printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
2313	m_RCForceIntraQP = false;
2314	}
2315	}
2316	xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
2317	}
2318	#if H_MV
2319	// VPS VUI
2320	for(Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++ )
2321	{
2322	for (Int j = 0; j < MAX_TLAYER; j++)
2323	{
2324	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" );
2325	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" );
2326	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" );
2327	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" );
2328	}
2329	}
2330	// todo: replace value of 100 with requirement in spec
2331	for(Int i = 0; i < MAX_NUM_LAYERS; i++ )
2332	{
2333	for (Int j = 0; j < MAX_NUM_LAYERS; j++)
2334	{
2335	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" );
2336	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" );
2337	}
2338	}
2339	#endif
2340
2341	xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagForce, "CUTransquantBypassFlagForce cannot be 1 when TransquantBypassEnableFlag is 0");
2342
2343	xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2");
2344	if (m_framePackingSEIEnabled)
2345	{
2346	xConfirmPara(m_framePackingSEIType < 3 \|\| m_framePackingSEIType > 5 , "SEIFramePackingType must be in rage 3 to 5");
2347	}
2348
2349	#if H_MV
2350	}
2351	}
2352	// Check input parameters for Sub-bitstream property SEI message
2353	if( m_subBistreamPropSEIEnabled )
2354	{
2355	xConfirmPara(
2356	(this->m_sbPropNumAdditionalSubStreams != m_sbPropAvgBitRate.size() )
2357	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropHighestSublayerId.size() )
2358	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropMaxBitRate.size() )
2359	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropOutputLayerSetIdxToVps.size() )
2360	\|\| (this->m_sbPropNumAdditionalSubStreams != m_sbPropSubBitstreamMode.size()), "Some parameters of some sub-bitstream not defined");
2361
2362	for( Int i = 0; i < m_sbPropNumAdditionalSubStreams; i++ )
2363	{
2364	xConfirmPara( m_sbPropSubBitstreamMode[i] < 0 \|\| m_sbPropSubBitstreamMode[i] > 1, "Mode value should be 0 or 1" );
2365	xConfirmPara( m_sbPropHighestSublayerId[i] < 0 \|\| m_sbPropHighestSublayerId[i] > MAX_TLAYER-1, "Maximum sub-layer ID out of range" );
2366	xConfirmPara( m_sbPropOutputLayerSetIdxToVps[i] < 0 \|\| m_sbPropOutputLayerSetIdxToVps[i] >= MAX_VPS_OUTPUTLAYER_SETS, "OutputLayerSetIdxToVps should be within allowed range" );
2367	}
2368	}
2369	#endif
2370	#undef xConfirmPara
2371	if (check_failed)
2372	{
2373	exit(EXIT_FAILURE);
2374	}
2375	}
2376
2377	/** \todo use of global variables should be removed later
2378	*/
2379	Void TAppEncCfg::xSetGlobal()
2380	{
2381	// set max CU width & height
2382	g_uiMaxCUWidth = m_uiMaxCUWidth;
2383	g_uiMaxCUHeight = m_uiMaxCUHeight;
2384
2385	// compute actual CU depth with respect to config depth and max transform size
2386	g_uiAddCUDepth = 0;
2387	while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth ) ) ) g_uiAddCUDepth++;
2388
2389	m_uiMaxCUDepth += g_uiAddCUDepth;
2390	g_uiAddCUDepth++;
2391	g_uiMaxCUDepth = m_uiMaxCUDepth;
2392
2393	// set internal bit-depth and constants
2394	g_bitDepthY = m_internalBitDepthY;
2395	g_bitDepthC = m_internalBitDepthC;
2396
2397	g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
2398	g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
2399	}
2400
2401	Void TAppEncCfg::xPrintParameter()
2402	{
2403	printf("\n");
2404	#if H_MV
2405	for( Int layer = 0; layer < m_numberOfLayers; layer++)
2406	{
2407	printf("Input File %i : %s\n", layer, m_pchInputFileList[layer]);
2408	}
2409	#else
2410	printf("Input File : %s\n", m_pchInputFile );
2411	#endif
2412	printf("Bitstream File : %s\n", m_pchBitstreamFile );
2413	#if H_MV
2414	for( Int layer = 0; layer < m_numberOfLayers; layer++)
2415	{
2416	printf("Reconstruction File %i : %s\n", layer, m_pchReconFileList[layer]);
2417	}
2418	#else
2419	printf("Reconstruction File : %s\n", m_pchReconFile );
2420	#endif
2421	#if H_MV
2422	xPrintParaVector( "NuhLayerId" , m_layerIdInNuh );
2423	if ( m_targetEncLayerIdList.size() > 0)
2424	{
2425	xPrintParaVector( "TargetEncLayerIdList" , m_targetEncLayerIdList );
2426	}
2427	xPrintParaVector( "ViewIdVal" , m_viewId );
2428	xPrintParaVector( "ViewOrderIndex", m_viewOrderIndex );
2429	xPrintParaVector( "AuxId", m_auxId );
2430	#endif
2431	#if H_3D
2432	xPrintParaVector( "DepthFlag", m_depthFlag );
2433	printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2434	#endif
2435	#if H_MV
2436	xPrintParaVector( "QP" , m_fQP );
2437	xPrintParaVector( "LoopFilterDisable", m_bLoopFilterDisable );
2438	xPrintParaVector( "SAO" , m_bUseSAO );
2439	#endif
2440	printf("Real Format : %dx%d %dHz\n", m_iSourceWidth - m_confWinLeft - m_confWinRight, m_iSourceHeight - m_confWinTop - m_confWinBottom, m_iFrameRate );
2441	printf("Internal Format : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
2442	if (m_isField)
2443	{
2444	printf("Frame/Field : Field based coding\n");
2445	printf("Field index : %u - %d (%d fields)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2446	if (m_isTopFieldFirst)
2447	{
2448	printf("Field Order : Top field first\n");
2449	}
2450	else
2451	{
2452	printf("Field Order : Bottom field first\n");
2453	}
2454	}
2455	else
2456	{
2457	printf("Frame/Field : Frame based coding\n");
2458	printf("Frame index : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2459	}
2460	printf("CU size / depth : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
2461	printf("RQT trans. size (min / max) : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
2462	printf("Max RQT depth inter : %d\n", m_uiQuadtreeTUMaxDepthInter);
2463	printf("Max RQT depth intra : %d\n", m_uiQuadtreeTUMaxDepthIntra);
2464	printf("Min PCM size : %d\n", 1 << m_uiPCMLog2MinSize);
2465	printf("Motion search range : %d\n", m_iSearchRange );
2466	#ifdef SONY_MV_V_CONST_C0078
2467	printf("Disp search range restriction: %d\n", m_bUseDisparitySearchRangeRestriction );
2468	printf("Vertical disp search range : %d\n", m_iVerticalDisparitySearchRange );
2469	#endif
2470	#if H_MV
2471	xPrintParaVector( "Intra period", m_iIntraPeriod );
2472	#else
2473	printf("Intra period : %d\n", m_iIntraPeriod );
2474	#endif
2475	printf("Decoding refresh type : %d\n", m_iDecodingRefreshType );
2476	#if !H_MV
2477	printf("QP : %5.2f\n", m_fQP );
2478	#endif
2479	printf("Max dQP signaling depth : %d\n", m_iMaxCuDQPDepth);
2480
2481	printf("Cb QP Offset : %d\n", m_cbQpOffset );
2482	printf("Cr QP Offset : %d\n", m_crQpOffset);
2483
2484	printf("QP adaptation : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
2485	printf("GOP size : %d\n", m_iGOPSize );
2486	printf("Internal bit depth : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC );
2487	printf("PCM sample bit depth : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma );
2488	printf("RateControl : %d\n", m_RCEnableRateControl );
2489	if(m_RCEnableRateControl)
2490	{
2491	printf("TargetBitrate : %d\n", m_RCTargetBitrate );
2492	printf("KeepHierarchicalBit : %d\n", m_RCKeepHierarchicalBit );
2493	printf("LCULevelRC : %d\n", m_RCLCULevelRC );
2494	printf("UseLCUSeparateModel : %d\n", m_RCUseLCUSeparateModel );
2495	printf("InitialQP : %d\n", m_RCInitialQP );
2496	printf("ForceIntraQP : %d\n", m_RCForceIntraQP );
2497
2498	#if KWU_RC_MADPRED_E0227
2499	printf("Depth based MAD prediction : %d\n", m_depthMADPred);
2500	#endif
2501	#if KWU_RC_VIEWRC_E0227
2502	printf("View-wise Rate control : %d\n", m_viewWiseRateCtrl);
2503	if(m_viewWiseRateCtrl)
2504	{
2505
2506	printf("ViewWiseTargetBits : ");
2507	for (Int i = 0 ; i < m_iNumberOfViews ; i++)
2508	printf("%d ", m_viewTargetBits[i]);
2509	printf("\n");
2510	}
2511	else
2512	{
2513	printf("TargetBitrate : %d\n", m_RCTargetBitrate );
2514	}
2515	#endif
2516	}
2517	printf("Max Num Merge Candidates : %d\n", m_maxNumMergeCand);
2518	#if H_3D
2519	printf("BaseViewCameraNumbers : %s\n", m_pchBaseViewCameraNumbers );
2520	printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2521	#if H_3D_VSO
2522	printf("Force use of Lambda Scale : %d\n", m_bForceLambdaScaleVSO );
2523
2524	if ( m_bUseVSO )
2525	{
2526	printf("VSO Lambda Scale : %5.2f\n", m_dLambdaScaleVSO );
2527	printf("VSO Mode : %d\n", m_uiVSOMode );
2528	printf("VSO Config : %s\n", m_pchVSOConfig );
2529	printf("VSO Negative Distortion : %d\n", m_bAllowNegDist ? 1 : 0);
2530	printf("VSO LS Table : %d\n", m_bVSOLSTable ? 1 : 0);
2531	printf("VSO Estimated VSD : %d\n", m_bUseEstimatedVSD ? 1 : 0);
2532	printf("VSO Early Skip : %d\n", m_bVSOEarlySkip ? 1 : 0);
2533	if ( m_bUseWVSO )
2534	printf("Dist. Weights (VSO/VSD/SAD) : %d/%d/%d\n ", m_iVSOWeight, m_iVSDWeight, m_iDWeight );
2535	}
2536	#endif //HHI_VSO
2537	#endif //H_3D
2538	printf("\n");
2539	#if H_MV
2540	printf("TOOL CFG General: ");
2541	#else
2542	printf("TOOL CFG: ");
2543	#endif
2544	printf("IBD:%d ", g_bitDepthY > m_inputBitDepthY \|\| g_bitDepthC > m_inputBitDepthC);
2545	printf("HAD:%d ", m_bUseHADME );
2546	printf("RDQ:%d ", m_useRDOQ );
2547	printf("RDQTS:%d ", m_useRDOQTS );
2548	printf("RDpenalty:%d ", m_rdPenalty );
2549	printf("SQP:%d ", m_uiDeltaQpRD );
2550	printf("ASR:%d ", m_bUseASR );
2551	printf("FEN:%d ", m_bUseFastEnc );
2552	printf("ECU:%d ", m_bUseEarlyCU );
2553	printf("FDM:%d ", m_useFastDecisionForMerge );
2554	printf("CFM:%d ", m_bUseCbfFastMode );
2555	printf("ESD:%d ", m_useEarlySkipDetection );
2556	printf("RQT:%d ", 1 );
2557	printf("TransformSkip:%d ", m_useTransformSkip );
2558	printf("TransformSkipFast:%d ", m_useTransformSkipFast );
2559	printf("Slice: M=%d ", m_sliceMode);
2560	if (m_sliceMode!=0)
2561	{
2562	printf("A=%d ", m_sliceArgument);
2563	}
2564	printf("SliceSegment: M=%d ",m_sliceSegmentMode);
2565	if (m_sliceSegmentMode!=0)
2566	{
2567	printf("A=%d ", m_sliceSegmentArgument);
2568	}
2569	printf("CIP:%d ", m_bUseConstrainedIntraPred);
2570	#if !H_MV
2571	printf("SAO:%d ", (m_bUseSAO)?(1):(0));
2572	#endif
2573	printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
2574	if (m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagForce)
2575	{
2576	printf("TransQuantBypassEnabled: =1 ");
2577	}
2578	else
2579	{
2580	printf("TransQuantBypassEnabled:%d ", (m_TransquantBypassEnableFlag)? 1:0 );
2581	}
2582	printf("WPP:%d ", (Int)m_useWeightedPred);
2583	printf("WPB:%d ", (Int)m_useWeightedBiPred);
2584	printf("PME:%d ", m_log2ParallelMergeLevel);
2585	printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d",
2586	m_iWaveFrontSynchro, m_iWaveFrontSubstreams);
2587	printf(" ScalingList:%d ", m_useScalingListId );
2588	printf("TMVPMode:%d ", m_TMVPModeId );
2589	#if ADAPTIVE_QP_SELECTION
2590	printf("AQpS:%d ", m_bUseAdaptQpSelect );
2591	#endif
2592
2593	printf(" SignBitHidingFlag:%d ", m_signHideFlag);
2594	printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 );
2595	#if H_3D_VSO
2596	printf("VSO:%d ", m_bUseVSO );
2597	printf("WVSO:%d ", m_bUseWVSO );
2598	#endif
2599	#if H_3D
2600	printf( "QTL:%d " , m_bUseQTL);
2601	printf( "IlluCompEnable:%d " , m_abUseIC);
2602	printf( "IlluCompLowLatencyEnc:%d ", m_bUseLowLatencyICEnc);
2603	printf( "DLT:%d ", m_useDLT );
2604
2605
2606	printf( "IvMvPred:%d %d " , m_ivMvPredFlag[0] ? 1 : 0, m_ivMvPredFlag[1] ? 1 : 0);
2607	printf( "IvMvScaling:%d %d " , m_ivMvScalingFlag[0] ? 1 : 0 , m_ivMvScalingFlag[1] ? 1 : 0);
2608
2609	printf( "Log2SubPbSizeMinus3:%d " , m_log2SubPbSizeMinus3 );
2610	printf( "IvResPred:%d " , m_ivResPredFlag ? 1 : 0 );
2611	printf( "DepthRefinement:%d " , m_depthRefinementFlag ? 1 : 0 );
2612	printf( "ViewSynthesisPred:%d " , m_viewSynthesisPredFlag ? 1 : 0 );
2613	printf( "DepthBasedBlkPart:%d " , m_depthBasedBlkPartFlag ? 1 : 0 );
2614	printf( "Mpi:%d " , m_mpiFlag ? 1 : 0 );
2615	printf( "Log2MpiSubPbSizeMinus3:%d " , m_log2MpiSubPbSizeMinus3 );
2616	printf( "IntraContour:%d " , m_intraContourFlag ? 1 : 0 );
2617	printf( "IntraWedge:%d " , m_intraWedgeFlag ? 1 : 0 );
2618	printf( "IntraSdc:%d " , m_intraSdcFlag ? 1 : 0 );
2619	printf( "QtPred:%d " , m_qtPredFlag ? 1 : 0 );
2620	printf( "InterSdc:%d " , m_interSdcFlag ? 1 : 0 );
2621	#if SEC_DEPTH_INTRA_SKIP_MODE_K0033
2622	printf( "DepthIntraSkip:%d " , m_depthIntraSkipFlag ? 1 : 0 );
2623	#else
2624	printf( "IntraSingle:%d " , m_intraSingleFlag ? 1 : 0 );
2625	#endif
2626	#endif
2627
2628	printf("\n\n");
2629
2630	fflush(stdout);
2631	}
2632
2633	Bool confirmPara(Bool bflag, const Char* message)
2634	{
2635	if (!bflag)
2636	return false;
2637
2638	printf("Error: %s\n",message);
2639	return true;
2640	}
2641
2642	//! \}

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

Download in other formats: