Context navigation

TAppEncCfg.cpp @ 1368

Visit:

Last change on this file since 1368 was 786, checked in by samsung-htm, 11 years ago
Integration of JCT3V-G0077: MCP Size (Only enabling SPIVMP with 2Nx2N PU & Change name of syntax element "log2_sub_pb_size_minus2" to "log2_sub_pb_size_minus3")
Property svn:eol-style set to `native`
File size: 117.1 KB

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-9.3-dev1-KHU/source/App/TAppEncoder/TAppEncCfg.cpp @ 1368

Download in other formats: