Context navigation

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

Visit:

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

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

Download in other formats: