Context navigation

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

Visit:

Last change on this file since 499 was 499, checked in by zhang, 11 years ago
Changes include: DV-MVP(H_3D_IDV), TMVP merging candidate(H_3D_TMVP, target reference index changes, scaling based on view order index) and cleanups (H_3D_CLEANUPS)
Property svn:eol-style set to `native`
File size: 105.7 KB

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

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

Download in other formats: