Context navigation

source: 3DVCSoftware/branches/HTM-DEV-0.3-dev2/source/App/TAppEncoder/TAppEncCfg.cpp @ 504

Visit:

Last change on this file since 504 was 504, checked in by zhang, 12 years ago
Merge Dev2.a to Dev2 and simulation results updated
Property svn:eol-style set to `native`
File size: 106.3 KB

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

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

Download in other formats: