Context navigation

source: 3DVCSoftware/branches/HTM-10.0-Fix/source/App/TAppEncoder/TAppEncCfg.cpp @ 1417

Visit:

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

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

Download in other formats: