Context navigation

source: 3DVCSoftware/branches/HTM-10.0-dev0/source/App/TAppEncoder/TAppEncCfg.cpp @ 852

Visit:

Last change on this file since 852 was 852, checked in by tech, 10 years ago
Update HM-12.0 -> HM-13.0.
Property svn:eol-style set to `native`
File size: 114.9 KB

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

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

Download in other formats: