Context navigation

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

Visit:

Last change on this file since 479 was 479, checked in by tech, 11 years ago
changed IV-MERGE HLS to match Test Model 4 spec incorporated iv-refpic list to TComSlice removed TComDepthMapGenerator
Property svn:eol-style set to `native`
File size: 105.2 KB

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

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

Download in other formats: