Context navigation

source: 3DVCSoftware/branches/HTM-9.3-dev2-RWTH/source/App/TAppEncoder/TAppEncCfg.cpp

Visit:

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

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

Download in other formats: