Context navigation

source: 3DVCSoftware/trunk/source/App/TAppEncoder/TAppEncCfg.cpp @ 884

Visit:

Last change on this file since 884 was 884, checked in by tech, 10 years ago
Merged HTM-10.1-dev0@883. (MV-HEVC 7 HLS)
Property svn:eol-style set to `native`
File size: 118.2 KB

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

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

Download in other formats: