Context navigation

TAppEncCfg.cpp @ 468

Visit:

Last change on this file since 468 was 468, checked in by lg, 11 years ago
1.IC and full pel depth coding are integrated and is guarded by Macro H_3D_IC.
Property svn:eol-style set to `native`
File size: 105.6 KB

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

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

JCT-3V 3D-HEVC

Context navigation

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

Download in other formats: