Context navigation

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

Visit:

Last change on this file since 531 was 531, checked in by tech, 12 years ago
Merged HTM-DEV-0.3-dev1 Rev. 520.
Property svn:eol-style set to `native`
File size: 106.7 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2013, ITU/ISO/IEC
7	* All rights reserved.
8	*
9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions are met:
11	*
12	* * Redistributions of source code must retain the above copyright notice,
13	* this list of conditions and the following disclaimer.
14	* * Redistributions in binary form must reproduce the above copyright notice,
15	* this list of conditions and the following disclaimer in the documentation
16	* and/or other materials provided with the distribution.
17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18	* be used to endorse or promote products derived from this software without
19	* specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31	* THE POSSIBILITY OF SUCH DAMAGE.
32	*/
33
34	/** \file TAppEncCfg.cpp
35	\brief Handle encoder configuration parameters
36	*/
37
38	#include <stdlib.h>
39	#include <cassert>
40	#include <cstring>
41	#include <string>
42	#include "TLibCommon/TComRom.h"
43	#include "TAppEncCfg.h"
44
45	static istream& operator>>(istream &, Level::Name &);
46	static istream& operator>>(istream &, Level::Tier &);
47	static istream& operator>>(istream &, Profile::Name &);
48
49	#include "TAppCommon/program_options_lite.h"
50	#include "TLibEncoder/TEncRateCtrl.h"
51	#ifdef WIN32
52	#define strdup _strdup
53	#endif
54
55	using namespace std;
56	namespace po = df::program_options_lite;
57
58	//! \ingroup TAppEncoder
59	//! \{
60
61	// ====================================================================================================================
62	// Constructor / destructor / initialization / destroy
63	// ====================================================================================================================
64
65	TAppEncCfg::TAppEncCfg()
66	#if H_MV
67	: m_pchBitstreamFile()
68	#else
69	: m_pchInputFile()
70	, m_pchBitstreamFile()
71	, m_pchReconFile()
72	#endif
73	, m_pchdQPFile()
74	, m_pColumnWidth()
75	, m_pRowHeight()
76	, m_scalingListFile()
77	{
78	#if !H_MV
79	m_aidQP = NULL;
80	#endif
81	#if J0149_TONE_MAPPING_SEI
82	m_startOfCodedInterval = NULL;
83	m_codedPivotValue = NULL;
84	m_targetPivotValue = NULL;
85	#endif
86	}
87
88	TAppEncCfg::~TAppEncCfg()
89	{
90	#if H_MV
91	for( Int layer = 0; layer < m_aidQP.size(); layer++ )
92	{
93	if ( m_aidQP[layer] != NULL )
94	{
95	delete[] m_aidQP[layer];
96	m_aidQP[layer] = NULL;
97	}
98	}
99	for(Int i = 0; i< m_pchInputFileList.size(); i++ )
100	{
101	if ( m_pchInputFileList[i] != NULL )
102	free (m_pchInputFileList[i]);
103	}
104	#else
105	if ( m_aidQP )
106	{
107	delete[] m_aidQP;
108	}
109	#endif
110	#if J0149_TONE_MAPPING_SEI
111	if ( m_startOfCodedInterval )
112	{
113	delete[] m_startOfCodedInterval;
114	m_startOfCodedInterval = NULL;
115	}
116	if ( m_codedPivotValue )
117	{
118	delete[] m_codedPivotValue;
119	m_codedPivotValue = NULL;
120	}
121	if ( m_targetPivotValue )
122	{
123	delete[] m_targetPivotValue;
124	m_targetPivotValue = NULL;
125	}
126	#endif
127	#if !H_MV
128	free(m_pchInputFile);
129	#endif
130	free(m_pchBitstreamFile);
131	#if H_MV
132	for(Int i = 0; i< m_pchReconFileList.size(); i++ )
133	{
134	if ( m_pchReconFileList[i] != NULL )
135	free (m_pchReconFileList[i]);
136	}
137	#else
138	free(m_pchReconFile);
139	#endif
140	free(m_pchdQPFile);
141	free(m_pColumnWidth);
142	free(m_pRowHeight);
143	free(m_scalingListFile);
144	#if H_MV
145	for( Int i = 0; i < m_GOPListMvc.size(); i++ )
146	{
147	if( m_GOPListMvc[i] )
148	{
149	delete[] m_GOPListMvc[i];
150	m_GOPListMvc[i] = NULL;
151	}
152	}
153	#endif
154	#if H_3D
155	#if H_3D_VSO
156	if ( m_pchVSOConfig != NULL)
157	free ( m_pchVSOConfig );
158	#endif
159	if ( m_pchCameraParameterFile != NULL )
160	free ( m_pchCameraParameterFile );
161
162	if ( m_pchBaseViewCameraNumbers != NULL )
163	free ( m_pchBaseViewCameraNumbers );
164	#endif
165	}
166
167	Void TAppEncCfg::create()
168	{
169	}
170
171	Void TAppEncCfg::destroy()
172	{
173	}
174
175	std::istringstream &operator>>(std::istringstream &in, GOPEntry &entry) //input
176	{
177	in>>entry.m_sliceType;
178	in>>entry.m_POC;
179	in>>entry.m_QPOffset;
180	in>>entry.m_QPFactor;
181	in>>entry.m_tcOffsetDiv2;
182	in>>entry.m_betaOffsetDiv2;
183	in>>entry.m_temporalId;
184	in>>entry.m_numRefPicsActive;
185	in>>entry.m_numRefPics;
186	for ( Int i = 0; i < entry.m_numRefPics; i++ )
187	{
188	in>>entry.m_referencePics[i];
189	}
190	in>>entry.m_interRPSPrediction;
191	#if AUTO_INTER_RPS
192	if (entry.m_interRPSPrediction==1)
193	{
194	in>>entry.m_deltaRPS;
195	in>>entry.m_numRefIdc;
196	for ( Int i = 0; i < entry.m_numRefIdc; i++ )
197	{
198	in>>entry.m_refIdc[i];
199	}
200	}
201	else if (entry.m_interRPSPrediction==2)
202	{
203	in>>entry.m_deltaRPS;
204	}
205	#else
206	if (entry.m_interRPSPrediction)
207	{
208	in>>entry.m_deltaRPS;
209	in>>entry.m_numRefIdc;
210	for ( Int i = 0; i < entry.m_numRefIdc; i++ )
211	{
212	in>>entry.m_refIdc[i];
213	}
214	}
215	#endif
216	#if H_MV
217	in>>entry.m_numInterViewRefPics;
218	for( Int i = 0; i < entry.m_numInterViewRefPics; i++ )
219	{
220	in>>entry.m_interViewRefs[i];
221	}
222	for( Int i = 0; i < entry.m_numInterViewRefPics; i++ )
223	{
224	in>>entry.m_interViewRefPosL[0][i];
225	}
226	for( Int i = 0; i < entry.m_numInterViewRefPics; i++ )
227	{
228	in>>entry.m_interViewRefPosL[1][i];
229	}
230	#endif
231	return in;
232	}
233
234	static const struct MapStrToProfile {
235	const Char* str;
236	Profile::Name value;
237	} strToProfile[] = {
238	{"none", Profile::NONE},
239	{"main", Profile::MAIN},
240	{"main10", Profile::MAIN10},
241	{"main-still-picture", Profile::MAINSTILLPICTURE},
242	#if H_MV
243	{"main-stereo", Profile::MAINSTEREO},
244	{"main-multiview", Profile::MAINMULTIVIEW},
245	#if H_3D
246	{"main-3d" , Profile::MAIN3D},
247	#endif
248	#endif
249	};
250
251	static const struct MapStrToTier {
252	const Char* str;
253	Level::Tier value;
254	} strToTier[] = {
255	{"main", Level::MAIN},
256	{"high", Level::HIGH},
257	};
258
259	static const struct MapStrToLevel {
260	const Char* str;
261	Level::Name value;
262	} strToLevel[] = {
263	{"none",Level::NONE},
264	{"1", Level::LEVEL1},
265	{"2", Level::LEVEL2},
266	{"2.1", Level::LEVEL2_1},
267	{"3", Level::LEVEL3},
268	{"3.1", Level::LEVEL3_1},
269	{"4", Level::LEVEL4},
270	{"4.1", Level::LEVEL4_1},
271	{"5", Level::LEVEL5},
272	{"5.1", Level::LEVEL5_1},
273	{"5.2", Level::LEVEL5_2},
274	{"6", Level::LEVEL6},
275	{"6.1", Level::LEVEL6_1},
276	{"6.2", Level::LEVEL6_2},
277	};
278
279	template<typename T, typename P>
280	static istream& readStrToEnum(P map[], unsigned long mapLen, istream &in, T &val)
281	{
282	string str;
283	in >> str;
284
285	for (Int i = 0; i < mapLen; i++)
286	{
287	if (str == map[i].str)
288	{
289	val = map[i].value;
290	goto found;
291	}
292	}
293	/* not found */
294	in.setstate(ios::failbit);
295	found:
296	return in;
297	}
298
299	static istream& operator>>(istream &in, Profile::Name &profile)
300	{
301	return readStrToEnum(strToProfile, sizeof(strToProfile)/sizeof(*strToProfile), in, profile);
302	}
303
304	static istream& operator>>(istream &in, Level::Tier &tier)
305	{
306	return readStrToEnum(strToTier, sizeof(strToTier)/sizeof(*strToTier), in, tier);
307	}
308
309	static istream& operator>>(istream &in, Level::Name &level)
310	{
311	return readStrToEnum(strToLevel, sizeof(strToLevel)/sizeof(*strToLevel), in, level);
312	}
313
314	#if SIGNAL_BITRATE_PICRATE_IN_VPS
315	Void readBoolString(const string inpString, const Int numEntries, Bool* &memberArray, const char *elementName);
316	Void readIntString(const string inpString, const Int numEntries, Int* &memberArray, const char *elementName);
317	#endif
318	// ====================================================================================================================
319	// Public member functions
320	// ====================================================================================================================
321
322	/** \param argc number of arguments
323	\param argv array of arguments
324	\retval true when success
325	*/
326	Bool TAppEncCfg::parseCfg( Int argc, Char* argv[] )
327	{
328	Bool do_help = false;
329
330	#if !H_MV
331	string cfg_InputFile;
332	#endif
333	string cfg_BitstreamFile;
334	#if !H_MV
335	string cfg_ReconFile;
336	#endif
337	#if H_MV
338	vector<Int> cfg_dimensionLength;
339	#if H_3D
340	cfg_dimensionLength.push_back( 2 ); // depth
341	cfg_dimensionLength.push_back( 32 ); // texture
342	#else
343	cfg_dimensionLength.push_back( 64 );
344	#endif
345	#endif
346	string cfg_dQPFile;
347	string cfg_ColumnWidth;
348	string cfg_RowHeight;
349	string cfg_ScalingListFile;
350	#if J0149_TONE_MAPPING_SEI
351	string cfg_startOfCodedInterval;
352	string cfg_codedPivotValue;
353	string cfg_targetPivotValue;
354	#endif
355	#if SIGNAL_BITRATE_PICRATE_IN_VPS
356	string cfg_bitRateInfoPresentFlag;
357	string cfg_picRateInfoPresentFlag;
358	string cfg_avgBitRate;
359	string cfg_maxBitRate;
360	string cfg_avgPicRate;
361	string cfg_constantPicRateIdc;
362	#endif
363	po::Options opts;
364	opts.addOptions()
365	("help", do_help, false, "this help text")
366	("c", po::parseConfigFile, "configuration file name")
367
368	// File, I/O and source parameters
369	#if H_MV
370	("InputFile_%d,i_%d", m_pchInputFileList, (char *) 0 , MAX_NUM_LAYER_IDS , "original Yuv input file name %d")
371	#else
372	("InputFile,i", cfg_InputFile, string(""), "Original YUV input file name")
373	#endif
374	("BitstreamFile,b", cfg_BitstreamFile, string(""), "Bitstream output file name")
375	#if H_MV
376	("ReconFile_%d,o_%d", m_pchReconFileList, (char *) 0 , MAX_NUM_LAYER_IDS , "reconstructed Yuv output file name %d")
377	#else
378	("ReconFile,o", cfg_ReconFile, string(""), "Reconstructed YUV output file name")
379	#endif
380	#if H_MV
381	("NumberOfLayers", m_numberOfLayers , 1, "Number of layers")
382	#if !H_3D
383	("ScalabilityMask", m_scalabilityMask , 1 , "Scalability Mask")
384	#else
385	("ScalabilityMask", m_scalabilityMask , 3 , "Scalability Mask, 1: Texture 3: Texture + Depth ")
386	#endif
387	("DimensionIdLen", m_dimensionIdLen , cfg_dimensionLength , "Number of bits used to store dimensions Id")
388	("ViewId", m_viewId , std::vector<Int>(1,0), "View Id")
389	#if H_3D
390	("DepthFlag", m_depthFlag , std::vector<Int>(1,0), "Depth Flag")
391	#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, false , "inter view motion prediction " )
733	#endif
734	#if H_3D_NBDV_REF
735	("DepthRefinement", m_depthRefinementFlag, false , "depth refinement by DoNBDV" )
736	#endif
737	#if H_3D_VSP
738	("ViewSynthesisPred", m_viewSynthesisPredFlag, false , "view synthesis prediction " )
739	#endif
740	#endif //H_3D
741	;
742
743	#if H_MV
744	// parse coding structure
745	for( Int k = 0; k < MAX_NUM_LAYERS; k++ )
746	{
747	m_GOPListMvc.push_back( new GOPEntry[MAX_GOP + 1] );
748	if( k == 0 )
749	{
750	for( Int i = 1; i < MAX_GOP + 1; i++ )
751	{
752	std::ostringstream cOSS;
753	cOSS<<"Frame"<<i;
754	opts.addOptions()( cOSS.str(), m_GOPListMvc[k][i-1], GOPEntry() );
755	}
756	}
757	else
758	{
759	std::ostringstream cOSS1;
760	cOSS1<<"FrameI"<<"_l"<<k;
761	opts.addOptions()(cOSS1.str(), m_GOPListMvc[k][MAX_GOP], GOPEntry());
762
763	for( Int i = 1; i < MAX_GOP + 1; i++ )
764	{
765	std::ostringstream cOSS2;
766	cOSS2<<"Frame"<<i<<"_l"<<k;
767	opts.addOptions()(cOSS2.str(), m_GOPListMvc[k][i-1], GOPEntry());
768	}
769	}
770	}
771	#else
772	for(Int i=1; i<MAX_GOP+1; i++) {
773	std::ostringstream cOSS;
774	cOSS<<"Frame"<<i;
775	opts.addOptions()(cOSS.str(), m_GOPList[i-1], GOPEntry());
776	}
777	#endif
778	po::setDefaults(opts);
779	const list<const Char>& argv_unhandled = po::scanArgv(opts, argc, (const Char*) argv);
780
781	for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
782	{
783	fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
784	}
785
786	if (argc == 1 \|\| do_help)
787	{
788	/* argc == 1: no options have been specified */
789	po::doHelp(cout, opts);
790	return false;
791	}
792
793	/*
794	* Set any derived parameters
795	*/
796	/* convert std::string to c string for compatability */
797	#if !H_MV
798	m_pchInputFile = cfg_InputFile.empty() ? NULL : strdup(cfg_InputFile.c_str());
799	#endif
800	m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
801	#if !H_MV
802	m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str());
803	#endif
804	m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());
805
806	Char* pColumnWidth = cfg_ColumnWidth.empty() ? NULL: strdup(cfg_ColumnWidth.c_str());
807	Char* pRowHeight = cfg_RowHeight.empty() ? NULL : strdup(cfg_RowHeight.c_str());
808	if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
809	{
810	char *columnWidth;
811	int i=0;
812	m_pColumnWidth = new UInt[m_iNumColumnsMinus1];
813	columnWidth = strtok(pColumnWidth, " ,-");
814	while(columnWidth!=NULL)
815	{
816	if( i>=m_iNumColumnsMinus1 )
817	{
818	printf( "The number of columns whose width are defined is larger than the allowed number of columns.\n" );
819	exit( EXIT_FAILURE );
820	}
821	*( m_pColumnWidth + i ) = atoi( columnWidth );
822	columnWidth = strtok(NULL, " ,-");
823	i++;
824	}
825	if( i<m_iNumColumnsMinus1 )
826	{
827	printf( "The width of some columns is not defined.\n" );
828	exit( EXIT_FAILURE );
829	}
830	}
831	else
832	{
833	m_pColumnWidth = NULL;
834	}
835
836	if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
837	{
838	char *rowHeight;
839	int i=0;
840	m_pRowHeight = new UInt[m_iNumRowsMinus1];
841	rowHeight = strtok(pRowHeight, " ,-");
842	while(rowHeight!=NULL)
843	{
844	if( i>=m_iNumRowsMinus1 )
845	{
846	printf( "The number of rows whose height are defined is larger than the allowed number of rows.\n" );
847	exit( EXIT_FAILURE );
848	}
849	*( m_pRowHeight + i ) = atoi( rowHeight );
850	rowHeight = strtok(NULL, " ,-");
851	i++;
852	}
853	if( i<m_iNumRowsMinus1 )
854	{
855	printf( "The height of some rows is not defined.\n" );
856	exit( EXIT_FAILURE );
857	}
858	}
859	else
860	{
861	m_pRowHeight = NULL;
862	}
863	#if H_MV
864	free ( pColumnWidth );
865	free ( pRowHeight );
866	#endif
867	#if SIGNAL_BITRATE_PICRATE_IN_VPS
868	readBoolString(cfg_bitRateInfoPresentFlag, m_bitRatePicRateMaxTLayers, m_bitRateInfoPresentFlag, "bit rate info. present flag" );
869	readIntString (cfg_avgBitRate, m_bitRatePicRateMaxTLayers, m_avgBitRate, "avg. bit rate" );
870	readIntString (cfg_maxBitRate, m_bitRatePicRateMaxTLayers, m_maxBitRate, "max. bit rate" );
871	readBoolString(cfg_picRateInfoPresentFlag, m_bitRatePicRateMaxTLayers, m_picRateInfoPresentFlag, "bit rate info. present flag" );
872	readIntString (cfg_avgPicRate, m_bitRatePicRateMaxTLayers, m_avgPicRate, "avg. pic rate" );
873	readIntString (cfg_constantPicRateIdc, m_bitRatePicRateMaxTLayers, m_constantPicRateIdc, "constant pic rate Idc" );
874	#endif
875	m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str());
876
877	/* rules for input, output and internal bitdepths as per help text */
878	if (!m_internalBitDepthY) { m_internalBitDepthY = m_inputBitDepthY; }
879	if (!m_internalBitDepthC) { m_internalBitDepthC = m_internalBitDepthY; }
880	if (!m_inputBitDepthC) { m_inputBitDepthC = m_inputBitDepthY; }
881	if (!m_outputBitDepthY) { m_outputBitDepthY = m_internalBitDepthY; }
882	if (!m_outputBitDepthC) { m_outputBitDepthC = m_internalBitDepthC; }
883
884	// TODO:ChromaFmt assumes 4:2:0 below
885	switch (m_conformanceMode)
886	{
887	case 0:
888	{
889	// no conformance or padding
890	m_confLeft = m_confRight = m_confTop = m_confBottom = 0;
891	m_aiPad[1] = m_aiPad[0] = 0;
892	break;
893	}
894	case 1:
895	{
896	// automatic padding to minimum CU size
897	Int minCuSize = m_uiMaxCUHeight >> (m_uiMaxCUDepth - 1);
898	if (m_iSourceWidth % minCuSize)
899	{
900	m_aiPad[0] = m_confRight = ((m_iSourceWidth / minCuSize) + 1) * minCuSize - m_iSourceWidth;
901	m_iSourceWidth += m_confRight;
902	}
903	if (m_iSourceHeight % minCuSize)
904	{
905	m_aiPad[1] = m_confBottom = ((m_iSourceHeight / minCuSize) + 1) * minCuSize - m_iSourceHeight;
906	m_iSourceHeight += m_confBottom;
907	}
908	if (m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0)
909	{
910	fprintf(stderr, "Error: picture width is not an integer multiple of the specified chroma subsampling\n");
911	exit(EXIT_FAILURE);
912	}
913	if (m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0)
914	{
915	fprintf(stderr, "Error: picture height is not an integer multiple of the specified chroma subsampling\n");
916	exit(EXIT_FAILURE);
917	}
918	break;
919	}
920	case 2:
921	{
922	//padding
923	m_iSourceWidth += m_aiPad[0];
924	m_iSourceHeight += m_aiPad[1];
925	m_confRight = m_aiPad[0];
926	m_confBottom = m_aiPad[1];
927	break;
928	}
929	case 3:
930	{
931	// conformance
932	if ((m_confLeft == 0) && (m_confRight == 0) && (m_confTop == 0) && (m_confBottom == 0))
933	{
934	fprintf(stderr, "Warning: Conformance window enabled, but all conformance window parameters set to zero\n");
935	}
936	if ((m_aiPad[1] != 0) \|\| (m_aiPad[0]!=0))
937	{
938	fprintf(stderr, "Warning: Conformance window enabled, padding parameters will be ignored\n");
939	}
940	m_aiPad[1] = m_aiPad[0] = 0;
941	break;
942	}
943	}
944
945	// allocate slice-based dQP values
946	#if H_MV
947	xResizeVector( m_viewId );
948	#if H_3D
949	xResizeVector( m_depthFlag );
950
951	std::vector<Int> uniqueViewIds;
952	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
953	{
954	Bool isIn = false;
955	for ( Int i = 0 ; i < uniqueViewIds.size(); i++ )
956	{
957	isIn = isIn \|\| ( m_viewId[ layer ] == uniqueViewIds[ i ] );
958	}
959	if ( !isIn )
960	{
961	uniqueViewIds.push_back( m_viewId[ layer ] );
962	}
963	}
964	m_iNumberOfViews = (Int) uniqueViewIds.size();
965	#endif
966
967	xResizeVector( m_fQP );
968
969	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
970	{
971	m_aidQP.push_back( new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ] );
972	::memset( m_aidQP[layer], 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
973
974	// handling of floating-point QP values
975	// if QP is not integer, sequence is split into two sections having QP and QP+1
976	m_iQP.push_back((Int)( m_fQP[layer] ));
977	if ( m_iQP[layer] < m_fQP[layer] )
978	{
979	Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP[layer] - m_iQP[layer])*m_framesToBeEncoded + 0.5 );
980
981	iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
982	for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
983	{
984	m_aidQP[layer][i] = 1;
985	}
986	}
987	}
988
989	xResizeVector( m_bLoopFilterDisable );
990	xResizeVector( m_bUseSAO );
991
992	#else
993	m_aidQP = new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ];
994	::memset( m_aidQP, 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
995
996	// handling of floating-point QP values
997	// if QP is not integer, sequence is split into two sections having QP and QP+1
998	m_iQP = (Int)( m_fQP );
999	if ( m_iQP < m_fQP )
1000	{
1001	Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP - m_iQP)*m_framesToBeEncoded + 0.5 );
1002
1003	iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
1004	for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
1005	{
1006	m_aidQP[i] = 1;
1007	}
1008	}
1009	#endif
1010
1011	// reading external dQP description from file
1012	if ( m_pchdQPFile )
1013	{
1014	FILE* fpt=fopen( m_pchdQPFile, "r" );
1015	if ( fpt )
1016	{
1017	#if H_MV
1018	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1019	{
1020	#endif
1021	Int iValue;
1022	Int iPOC = 0;
1023	while ( iPOC < m_framesToBeEncoded )
1024	{
1025	if ( fscanf(fpt, "%d", &iValue ) == EOF ) break;
1026	#if H_MV
1027	m_aidQP[layer][ iPOC ] = iValue;
1028	iPOC++;
1029	}
1030	#else
1031	m_aidQP[ iPOC ] = iValue;
1032	iPOC++;
1033	#endif
1034	}
1035	fclose(fpt);
1036	}
1037	}
1038	m_iWaveFrontSubstreams = m_iWaveFrontSynchro ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1;
1039
1040	#if J0149_TONE_MAPPING_SEI
1041	if( m_toneMappingInfoSEIEnabled && !m_toneMapCancelFlag )
1042	{
1043	Char* pcStartOfCodedInterval = cfg_startOfCodedInterval.empty() ? NULL: strdup(cfg_startOfCodedInterval.c_str());
1044	Char* pcCodedPivotValue = cfg_codedPivotValue.empty() ? NULL: strdup(cfg_codedPivotValue.c_str());
1045	Char* pcTargetPivotValue = cfg_targetPivotValue.empty() ? NULL: strdup(cfg_targetPivotValue.c_str());
1046	if( m_toneMapModelId == 2 && pcStartOfCodedInterval )
1047	{
1048	char *startOfCodedInterval;
1049	UInt num = 1u<< m_toneMapTargetBitDepth;
1050	m_startOfCodedInterval = new Int[num];
1051	::memset( m_startOfCodedInterval, 0, sizeof(Int)*num );
1052	startOfCodedInterval = strtok(pcStartOfCodedInterval, " .");
1053	int i = 0;
1054	while( startOfCodedInterval && ( i < num ) )
1055	{
1056	m_startOfCodedInterval[i] = atoi( startOfCodedInterval );
1057	startOfCodedInterval = strtok(NULL, " .");
1058	i++;
1059	}
1060	}
1061	else
1062	{
1063	m_startOfCodedInterval = NULL;
1064	}
1065	if( ( m_toneMapModelId == 3 ) && ( m_numPivots > 0 ) )
1066	{
1067	if( pcCodedPivotValue && pcTargetPivotValue )
1068	{
1069	char *codedPivotValue;
1070	char *targetPivotValue;
1071	m_codedPivotValue = new Int[m_numPivots];
1072	m_targetPivotValue = new Int[m_numPivots];
1073	::memset( m_codedPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1074	::memset( m_targetPivotValue, 0, sizeof(Int)*( m_numPivots ) );
1075	codedPivotValue = strtok(pcCodedPivotValue, " .");
1076	int i=0;
1077	while(codedPivotValue&&i<m_numPivots)
1078	{
1079	m_codedPivotValue[i] = atoi( codedPivotValue );
1080	codedPivotValue = strtok(NULL, " .");
1081	i++;
1082	}
1083	i=0;
1084	targetPivotValue = strtok(pcTargetPivotValue, " .");
1085	while(targetPivotValue&&i<m_numPivots)
1086	{
1087	m_targetPivotValue[i]= atoi( targetPivotValue );
1088	targetPivotValue = strtok(NULL, " .");
1089	i++;
1090	}
1091	}
1092	}
1093	else
1094	{
1095	m_codedPivotValue = NULL;
1096	m_targetPivotValue = NULL;
1097	}
1098	}
1099	#endif
1100	#if H_3D
1101	// set global varibles
1102	xSetGlobal();
1103	#if H_3D_VSO
1104	// Table base optimization
1105	// Q&D
1106	Double adLambdaScaleTable[] =
1107	{ 0.031250, 0.031639, 0.032029, 0.032418, 0.032808, 0.033197, 0.033586, 0.033976, 0.034365, 0.034755,
1108	0.035144, 0.035533, 0.035923, 0.036312, 0.036702, 0.037091, 0.037480, 0.037870, 0.038259, 0.038648,
1109	0.039038, 0.039427, 0.039817, 0.040206, 0.040595, 0.040985, 0.041374, 0.041764, 0.042153, 0.042542,
1110	0.042932, 0.043321, 0.043711, 0.044100, 0.044194, 0.053033, 0.061872, 0.070711, 0.079550, 0.088388,
1111	0.117851, 0.147314, 0.176777, 0.235702, 0.294628, 0.353553, 0.471405, 0.589256, 0.707107, 0.707100,
1112	0.753550, 0.800000
1113	};
1114	#if H_3D_CLEANUPS
1115	if ( m_bUseVSO && m_bVSOLSTable )
1116	#else
1117	if ( m_bVSOLSTable )
1118	#endif
1119	{
1120	Int firstDepthLayer = -1;
1121	for (Int layer = 0; layer < m_numberOfLayers; layer++ )
1122	{
1123	if ( m_depthFlag[ layer ])
1124	{
1125	firstDepthLayer = layer;
1126	break;
1127	}
1128	}
1129	AOT( firstDepthLayer == -1 );
1130	AOT( (m_iQP[firstDepthLayer] < 0) \|\| (m_iQP[firstDepthLayer] > 51));
1131	m_dLambdaScaleVSO *= adLambdaScaleTable[m_iQP[firstDepthLayer]];
1132	}
1133	#endif
1134	#if H_3D_VSO
1135	if ( m_bUseVSO && m_uiVSOMode == 4)
1136	{
1137	m_cRenModStrParser.setString( m_iNumberOfViews, m_pchVSOConfig );
1138	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1139	g_bitDepthY,
1140	(UInt)m_iCodedCamParPrecision,
1141	m_FrameSkip,
1142	(UInt)m_framesToBeEncoded,
1143	m_pchCameraParameterFile,
1144	m_pchBaseViewCameraNumbers,
1145	NULL,
1146	m_cRenModStrParser.getSynthViews(),
1147	LOG2_DISP_PREC_LUT );
1148	}
1149	else if ( m_bUseVSO && m_uiVSOMode != 4 )
1150	{
1151	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1152	g_bitDepthY,
1153	(UInt)m_iCodedCamParPrecision,
1154	m_FrameSkip,
1155	(UInt)m_framesToBeEncoded,
1156	m_pchCameraParameterFile,
1157	m_pchBaseViewCameraNumbers,
1158	m_pchVSOConfig,
1159	NULL,
1160	LOG2_DISP_PREC_LUT );
1161	}
1162	else
1163	{
1164	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1165	g_bitDepthY,
1166	(UInt) m_iCodedCamParPrecision,
1167	m_FrameSkip,
1168	(UInt) m_framesToBeEncoded,
1169	m_pchCameraParameterFile,
1170	m_pchBaseViewCameraNumbers,
1171	NULL,
1172	NULL,
1173	LOG2_DISP_PREC_LUT );
1174	}
1175	#else
1176	m_cCameraData .init ( ((UInt) m_iNumberOfViews ),
1177	g_bitDepthY,
1178	(UInt) m_iCodedCamParPrecision,
1179	m_FrameSkip,
1180	(UInt) m_framesToBeEncoded,
1181	m_pchCameraParameterFile,
1182	m_pchBaseViewCameraNumbers,
1183	NULL,
1184	NULL,
1185	LOG2_DISP_PREC_LUT );
1186	#endif
1187	m_cCameraData.check( false, true );
1188	#endif
1189	// check validity of input parameters
1190	xCheckParameter();
1191
1192	#if !H_3D
1193	// set global varibles
1194	xSetGlobal();
1195	#endif
1196
1197	// print-out parameters
1198	xPrintParameter();
1199
1200	return true;
1201	}
1202	#if SIGNAL_BITRATE_PICRATE_IN_VPS
1203	Void readBoolString(const string inpString, const Int numEntries, Bool* &memberArray, const char *elementName)
1204	{
1205	Char* inpArray = inpString.empty() ? NULL : strdup(inpString.c_str());
1206	Int i = 0;
1207	if(numEntries)
1208	{
1209	Char* tempArray = strtok(inpArray, " ,-");
1210	memberArray = new Bool[numEntries];
1211	while( tempArray != NULL )
1212	{
1213	if( i >= numEntries )
1214	{
1215	printf( "The number of %s defined is larger than the allowed number\n", elementName );
1216	exit( EXIT_FAILURE );
1217	}
1218	assert( (atoi(tempArray) == 0) \|\| (atoi(tempArray) == 1) );
1219	*( memberArray + i ) = atoi(tempArray);
1220	tempArray = strtok(NULL, " ,-");
1221	i++;
1222	}
1223	if( i < numEntries )
1224	{
1225	printf( "Some %s are not defined\n", elementName );
1226	exit( EXIT_FAILURE );
1227	}
1228	}
1229	else
1230	{
1231	memberArray = NULL;
1232	}
1233	}
1234
1235	Void readIntString(const string inpString, const Int numEntries, Int* &memberArray, const char *elementName)
1236	{
1237	Char* inpArray = inpString.empty() ? NULL : strdup(inpString.c_str());
1238	Int i = 0;
1239	if(numEntries)
1240	{
1241	Char* tempArray = strtok(inpArray, " ,-");
1242	memberArray = new Int[numEntries];
1243	while( tempArray != NULL )
1244	{
1245	if( i >= numEntries )
1246	{
1247	printf( "The number of %s defined is larger than the allowed number\n", elementName );
1248	exit( EXIT_FAILURE );
1249	}
1250	*( memberArray + i ) = atoi(tempArray);
1251	tempArray = strtok(NULL, " ,-");
1252	i++;
1253	}
1254	if( i < numEntries )
1255	{
1256	printf( "Some %s are not defined\n", elementName );
1257	exit( EXIT_FAILURE );
1258	}
1259	}
1260	else
1261	{
1262	memberArray = NULL;
1263	}
1264	}
1265	#endif
1266	// ====================================================================================================================
1267	// Private member functions
1268	// ====================================================================================================================
1269
1270	Bool confirmPara(Bool bflag, const Char* message);
1271
1272	Void TAppEncCfg::xCheckParameter()
1273	{
1274	if (!m_decodedPictureHashSEIEnabled)
1275	{
1276	fprintf(stderr, "******************************************************************\n");
1277	fprintf(stderr, " WARNING: --SEIDecodedPictureHash is now disabled by default. \n");
1278	fprintf(stderr, " Automatic verification of decoded pictures by a \n");
1279	fprintf(stderr, " decoder requires this option to be enabled. \n");
1280	fprintf(stderr, "******************************************************************\n");
1281	}
1282
1283	Bool check_failed = false; /* abort if there is a fatal configuration problem */
1284	#define xConfirmPara(a,b) check_failed \|= confirmPara(a,b)
1285	// check range of parameters
1286	xConfirmPara( m_inputBitDepthY < 8, "InputBitDepth must be at least 8" );
1287	xConfirmPara( m_inputBitDepthC < 8, "InputBitDepthC must be at least 8" );
1288	xConfirmPara( m_iFrameRate <= 0, "Frame rate must be more than 1" );
1289	xConfirmPara( m_framesToBeEncoded <= 0, "Total Number Of Frames encoded must be more than 0" );
1290	#if H_MV
1291	xConfirmPara( m_numberOfLayers > MAX_NUM_LAYER_IDS , "NumberOfLayers must be less than or equal to MAX_NUM_LAYER_IDS");
1292
1293
1294	xConfirmPara( m_layerIdInNuh[0] != 0 , "LayerIdInNuh must be 0 for the first layer. ");
1295	xConfirmPara( (m_layerIdInNuh.size()!=1) && (m_layerIdInNuh.size() < m_numberOfLayers) , "LayerIdInNuh must be given for all layers. ");
1296
1297	#if H_3D
1298	xConfirmPara( m_scalabilityMask != 1 && m_scalabilityMask != 3, "Scalability Mask must be equal to 1 or 3. ");
1299	#else
1300	xConfirmPara( m_scalabilityMask != 1 , "Scalability Mask must be equal to 1. ");
1301	#endif
1302
1303	m_dimIds.push_back( m_viewId );
1304	const Int viewDimPosition = 0;
1305	#if H_3D
1306	if ( m_scalabilityMask & ( 1 << DEPTH_ID ) )
1307	m_dimIds.push_back( m_depthFlag );
1308	#endif
1309
1310	xConfirmPara( m_dimensionIdLen.size() < m_dimIds.size(), "DimensionIdLen must be given for all dimensions. " );
1311
1312	for( Int dim = 0; dim < m_dimIds.size(); dim++ )
1313	{
1314	xConfirmPara( m_dimIds[dim].size() < m_numberOfLayers, "DimensionId must be given for all layers and all dimensions. ");
1315	xConfirmPara( ( dim != viewDimPosition ) && (m_dimIds[dim][0] != 0), "DimensionId of layer 0 must be 0. " );
1316	xConfirmPara( m_dimensionIdLen[dim] < 1 \|\| m_dimensionIdLen[dim] > 8, "DimensionIdLen must be greater than 0 and less than 9 in all dimensions. " );
1317	for( Int i = 1; i < m_numberOfLayers; i++ )
1318	{
1319	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. " );
1320	}
1321	}
1322
1323	for( Int i = 0; i < m_numberOfLayers; i++ )
1324	{
1325	for( Int j = 0; j < i; j++ )
1326	{
1327	Int numDiff = 0;
1328	Int lastDiff = -1;
1329	for( Int dim = 0; dim < m_dimIds.size(); dim++ )
1330	{
1331	if ( m_dimIds[dim][i] != m_dimIds[dim][j] )
1332	{
1333	numDiff ++;
1334	lastDiff = dim;
1335	}
1336	}
1337
1338	Bool allEqual = ( numDiff == 0 );
1339
1340	if ( allEqual )
1341	{
1342	printf( "\nError: Positions of Layers %d and %d are identical in scalability space\n", i, j);
1343	}
1344
1345	xConfirmPara( allEqual , "Each layer shall have a different position in scalability space." );
1346
1347	if ( numDiff == 1 )
1348	{
1349	Bool inc = m_dimIds[ lastDiff ][ i ] > m_dimIds[ lastDiff ][ j ];
1350	Bool shallBeButIsNotIncreasing = ( !inc && ( lastDiff != viewDimPosition ) ) ;
1351	if ( shallBeButIsNotIncreasing )
1352	{
1353	printf( "\nError: Positions of Layers %d and %d is not increasing in dimension %d \n", i, j, lastDiff);
1354	}
1355	xConfirmPara( shallBeButIsNotIncreasing && ( lastDiff != viewDimPosition ), "DimensionIds shall be increasing within one dimension. " );
1356	}
1357	}
1358	}
1359
1360	#endif
1361	xConfirmPara( m_iGOPSize < 1 , "GOP Size must be greater or equal to 1" );
1362	xConfirmPara( m_iGOPSize > 1 && m_iGOPSize % 2, "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
1363	xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) \|\| m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
1364	xConfirmPara( m_iDecodingRefreshType < 0 \|\| m_iDecodingRefreshType > 2, "Decoding Refresh Type must be equal to 0, 1 or 2" );
1365	#if H_MV
1366	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1367	{
1368	xConfirmPara( m_iQP[layer] < -6 * (m_internalBitDepthY - 8) \|\| m_iQP[layer] > 51, "QP exceeds supported range (-QpBDOffsety to 51)" );
1369	}
1370	#else
1371	xConfirmPara( m_iQP < -6 * (m_internalBitDepthY - 8) \|\| m_iQP > 51, "QP exceeds supported range (-QpBDOffsety to 51)" );
1372	#endif
1373	xConfirmPara( m_loopFilterBetaOffsetDiv2 < -13 \|\| m_loopFilterBetaOffsetDiv2 > 13, "Loop Filter Beta Offset div. 2 exceeds supported range (-13 to 13)");
1374	xConfirmPara( m_loopFilterTcOffsetDiv2 < -13 \|\| m_loopFilterTcOffsetDiv2 > 13, "Loop Filter Tc Offset div. 2 exceeds supported range (-13 to 13)");
1375	xConfirmPara( m_iFastSearch < 0 \|\| m_iFastSearch > 2, "Fast Search Mode is not supported value (0:Full search 1:Diamond 2:PMVFAST)" );
1376	xConfirmPara( m_iSearchRange < 0 , "Search Range must be more than 0" );
1377	xConfirmPara( m_bipredSearchRange < 0 , "Search Range must be more than 0" );
1378	xConfirmPara( m_iMaxDeltaQP > 7, "Absolute Delta QP exceeds supported range (0 to 7)" );
1379	xConfirmPara( m_iMaxCuDQPDepth > m_uiMaxCUDepth - 1, "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
1380
1381	xConfirmPara( m_cbQpOffset < -12, "Min. Chroma Cb QP Offset is -12" );
1382	xConfirmPara( m_cbQpOffset > 12, "Max. Chroma Cb QP Offset is 12" );
1383	xConfirmPara( m_crQpOffset < -12, "Min. Chroma Cr QP Offset is -12" );
1384	xConfirmPara( m_crQpOffset > 12, "Max. Chroma Cr QP Offset is 12" );
1385
1386	xConfirmPara( m_iQPAdaptationRange <= 0, "QP Adaptation Range must be more than 0" );
1387	if (m_iDecodingRefreshType == 2)
1388	{
1389	xConfirmPara( m_iIntraPeriod > 0 && m_iIntraPeriod <= m_iGOPSize , "Intra period must be larger than GOP size for periodic IDR pictures");
1390	}
1391	xConfirmPara( (m_uiMaxCUWidth >> m_uiMaxCUDepth) < 4, "Minimum partition width size should be larger than or equal to 8");
1392	xConfirmPara( (m_uiMaxCUHeight >> m_uiMaxCUDepth) < 4, "Minimum partition height size should be larger than or equal to 8");
1393	xConfirmPara( m_uiMaxCUWidth < 16, "Maximum partition width size should be larger than or equal to 16");
1394	xConfirmPara( m_uiMaxCUHeight < 16, "Maximum partition height size should be larger than or equal to 16");
1395	xConfirmPara( (m_iSourceWidth % (m_uiMaxCUWidth >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame width must be a multiple of the minimum CU size");
1396	xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame height must be a multiple of the minimum CU size");
1397
1398	xConfirmPara( m_uiQuadtreeTULog2MinSize < 2, "QuadtreeTULog2MinSize must be 2 or greater.");
1399	xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5, "QuadtreeTULog2MaxSize must be 5 or smaller.");
1400	xConfirmPara( (1<<m_uiQuadtreeTULog2MaxSize) > m_uiMaxCUWidth, "QuadtreeTULog2MaxSize must be log2(maxCUSize) or smaller.");
1401
1402	xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize, "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize.");
1403	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1404	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUHeight>>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
1405	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUWidth >> m_uiMaxCUDepth ), "Minimum CU width must be greater than minimum transform size." );
1406	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." );
1407	xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1, "QuadtreeTUMaxDepthInter must be greater than or equal to 1" );
1408	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" );
1409	xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1, "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" );
1410	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" );
1411
1412	xConfirmPara( m_maxNumMergeCand < 1, "MaxNumMergeCand must be 1 or greater.");
1413	xConfirmPara( m_maxNumMergeCand > 5, "MaxNumMergeCand must be 5 or smaller.");
1414
1415	#if H_3D_ARP
1416	xConfirmPara( ( 0 != m_uiUseAdvResPred ) && ( 1 != m_uiUseAdvResPred ), "UseAdvResPred must be 0 or 1." );
1417	#endif
1418
1419	#if ADAPTIVE_QP_SELECTION
1420	#if H_MV
1421	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1422	{
1423	xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP[layer] < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
1424	}
1425	#else
1426	xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
1427	#endif
1428	xConfirmPara( m_bUseAdaptQpSelect == true && (m_cbQpOffset !=0 \|\| m_crQpOffset != 0 ), "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
1429	#endif
1430
1431	if( m_usePCM)
1432	{
1433	xConfirmPara( m_uiPCMLog2MinSize < 3, "PCMLog2MinSize must be 3 or greater.");
1434	xConfirmPara( m_uiPCMLog2MinSize > 5, "PCMLog2MinSize must be 5 or smaller.");
1435	xConfirmPara( m_pcmLog2MaxSize > 5, "PCMLog2MaxSize must be 5 or smaller.");
1436	xConfirmPara( m_pcmLog2MaxSize < m_uiPCMLog2MinSize, "PCMLog2MaxSize must be equal to or greater than m_uiPCMLog2MinSize.");
1437	}
1438
1439	xConfirmPara( m_sliceMode < 0 \|\| m_sliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
1440	if (m_sliceMode!=0)
1441	{
1442	xConfirmPara( m_sliceArgument < 1 , "SliceArgument should be larger than or equal to 1" );
1443	}
1444	xConfirmPara( m_sliceSegmentMode < 0 \|\| m_sliceSegmentMode > 3, "SliceSegmentMode exceeds supported range (0 to 3)" );
1445	if (m_sliceSegmentMode!=0)
1446	{
1447	xConfirmPara( m_sliceSegmentArgument < 1 , "SliceSegmentArgument should be larger than or equal to 1" );
1448	}
1449
1450	Bool tileFlag = (m_iNumColumnsMinus1 > 0 \|\| m_iNumRowsMinus1 > 0 );
1451	xConfirmPara( tileFlag && m_iWaveFrontSynchro, "Tile and Wavefront can not be applied together");
1452
1453	//TODO:ChromaFmt assumes 4:2:0 below
1454	xConfirmPara( m_iSourceWidth % TComSPS::getWinUnitX(CHROMA_420) != 0, "Picture width must be an integer multiple of the specified chroma subsampling");
1455	xConfirmPara( m_iSourceHeight % TComSPS::getWinUnitY(CHROMA_420) != 0, "Picture height must be an integer multiple of the specified chroma subsampling");
1456
1457	xConfirmPara( m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0, "Horizontal padding must be an integer multiple of the specified chroma subsampling");
1458	xConfirmPara( m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0, "Vertical padding must be an integer multiple of the specified chroma subsampling");
1459
1460	xConfirmPara( m_confLeft % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left conformance window offset must be an integer multiple of the specified chroma subsampling");
1461	xConfirmPara( m_confRight % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right conformance window offset must be an integer multiple of the specified chroma subsampling");
1462	xConfirmPara( m_confTop % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top conformance window offset must be an integer multiple of the specified chroma subsampling");
1463	xConfirmPara( m_confBottom % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom conformance window offset must be an integer multiple of the specified chroma subsampling");
1464
1465	#if H_3D
1466	xConfirmPara( m_pchCameraParameterFile == 0 , "CameraParameterFile must be given");
1467	xConfirmPara( m_pchBaseViewCameraNumbers == 0 , "BaseViewCameraNumbers must be given" );
1468	xConfirmPara( ((UInt) m_numberOfLayers >> 1 ) != m_cCameraData.getBaseViewNumbers().size(), "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
1469	xConfirmPara ( m_iCodedCamParPrecision < 0 \|\| m_iCodedCamParPrecision > 5, "CodedCamParsPrecision must be in range of 0..5" );
1470	#if H_3D_VSO
1471	if( m_bUseVSO )
1472	{
1473	xConfirmPara( m_pchVSOConfig == 0 , "VSO Setup string must be given");
1474	xConfirmPara( m_uiVSOMode > 4 , "VSO Mode must be less than 5");
1475	}
1476	#endif
1477	#endif
1478	// max CU width and height should be power of 2
1479	UInt ui = m_uiMaxCUWidth;
1480	while(ui)
1481	{
1482	ui >>= 1;
1483	if( (ui & 1) == 1)
1484	xConfirmPara( ui != 1 , "Width should be 2^n");
1485	}
1486	ui = m_uiMaxCUHeight;
1487	while(ui)
1488	{
1489	ui >>= 1;
1490	if( (ui & 1) == 1)
1491	xConfirmPara( ui != 1 , "Height should be 2^n");
1492	}
1493
1494	#if H_MV
1495	// validate that POC of same frame is identical across multiple layers
1496	Bool bErrorMvePoc = false;
1497	if( m_numberOfLayers > 1 )
1498	{
1499	for( Int k = 1; k < m_numberOfLayers; k++ )
1500	{
1501	for( Int i = 0; i < MAX_GOP; i++ )
1502	{
1503	if( m_GOPListMvc[k][i].m_POC != m_GOPListMvc[0][i].m_POC )
1504	{
1505	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 );
1506	bErrorMvePoc = true;
1507	}
1508	}
1509	}
1510	}
1511	xConfirmPara( bErrorMvePoc, "Invalid inter-layer POC structure given" );
1512
1513	// validate that baseview has no inter-view refs
1514	Bool bErrorIvpBase = false;
1515	for( Int i = 0; i < MAX_GOP; i++ )
1516	{
1517	if( m_GOPListMvc[0][i].m_numInterViewRefPics != 0 )
1518	{
1519	printf( "\nError: Frame%d inter_layer refs not available in layer 0\n", i );
1520	bErrorIvpBase = true;
1521	}
1522	}
1523	xConfirmPara( bErrorIvpBase, "Inter-layer refs not possible in base layer" );
1524
1525	// validate inter-view refs
1526	Bool bErrorIvpEnhV = false;
1527	if( m_numberOfLayers > 1 )
1528	{
1529	for( Int k = 1; k < m_numberOfLayers; k++ )
1530	{
1531	for( Int i = 0; i < MAX_GOP+1; i++ )
1532	{
1533	for( Int j = 0; j < m_GOPListMvc[k][i].m_numInterViewRefPics; j++ )
1534	{
1535	Int iAbsViewId = m_GOPListMvc[k][i].m_interViewRefs[j] + k;
1536	if( iAbsViewId < 0 \|\| iAbsViewId >= k )
1537	{
1538	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 );
1539	bErrorIvpEnhV = true;
1540	}
1541	if( m_GOPListMvc[k][i].m_interViewRefPosL[0][j] < -1 \|\| m_GOPListMvc[k][i].m_interViewRefPosL[0][j] > m_GOPListMvc[k][i].m_numRefPicsActive )
1542	{
1543	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 );
1544	bErrorIvpEnhV = true;
1545	}
1546	if( m_GOPListMvc[k][i].m_interViewRefPosL[1][j] < -1 \|\| m_GOPListMvc[k][i].m_interViewRefPosL[1][j] > m_GOPListMvc[k][i].m_numRefPicsActive )
1547	{
1548	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 );
1549	bErrorIvpEnhV = true;
1550	}
1551	}
1552	if( i == MAX_GOP ) // inter-view refs at I pic position in base view
1553	{
1554	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' )
1555	{
1556	printf( "\nError: slice type of FrameI_l%d must be equal to B or P or I\n", k );
1557	bErrorIvpEnhV = true;
1558	}
1559
1560	if( m_GOPListMvc[k][MAX_GOP].m_POC != 0 )
1561	{
1562	printf( "\nError: POC %d not possible for FrameI_l%d, must be 0\n", m_GOPListMvc[k][MAX_GOP].m_POC, k );
1563	bErrorIvpEnhV = true;
1564	}
1565
1566	if( m_GOPListMvc[k][MAX_GOP].m_temporalId != 0 )
1567	{
1568	printf( "\nWarning: Temporal id of FrameI_l%d must be 0 (cp. I-frame in base layer)\n", k );
1569	m_GOPListMvc[k][MAX_GOP].m_temporalId = 0;
1570	}
1571
1572	if( m_GOPListMvc[k][MAX_GOP].m_numRefPics != 0 )
1573	{
1574	printf( "\nWarning: temporal references not possible for FrameI_l%d\n", k );
1575	for( Int j = 0; j < m_GOPListMvc[k][MAX_GOP].m_numRefPics; j++ )
1576	{
1577	m_GOPListMvc[k][MAX_GOP].m_referencePics[j] = 0;
1578	}
1579	m_GOPListMvc[k][MAX_GOP].m_numRefPics = 0;
1580	}
1581
1582	if( m_GOPListMvc[k][MAX_GOP].m_interRPSPrediction )
1583	{
1584	printf( "\nError: inter RPS prediction not possible for FrameI_l%d, must be 0\n", k );
1585	bErrorIvpEnhV = true;
1586	}
1587
1588	if( m_GOPListMvc[k][MAX_GOP].m_sliceType == 'I' && m_GOPListMvc[k][MAX_GOP].m_numInterViewRefPics != 0 )
1589	{
1590	printf( "\nError: inter-layer prediction not possible for FrameI_l%d with slice type I, #IL_ref_pics must be 0\n", k );
1591	bErrorIvpEnhV = true;
1592	}
1593
1594	if( m_GOPListMvc[k][MAX_GOP].m_numRefPicsActive > m_GOPListMvc[k][MAX_GOP].m_numInterViewRefPics )
1595	{
1596	m_GOPListMvc[k][MAX_GOP].m_numRefPicsActive = m_GOPListMvc[k][MAX_GOP].m_numInterViewRefPics;
1597	}
1598
1599	if( m_GOPListMvc[k][MAX_GOP].m_sliceType == 'P' )
1600	{
1601	if( m_GOPListMvc[k][MAX_GOP].m_numInterViewRefPics < 1 )
1602	{
1603	printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type P\n", k );
1604	bErrorIvpEnhV = true;
1605	}
1606	else
1607	{
1608	for( Int j = 0; j < m_GOPListMvc[k][MAX_GOP].m_numInterViewRefPics; j++ )
1609	{
1610	if( m_GOPListMvc[k][MAX_GOP].m_interViewRefPosL[1][j] != -1 )
1611	{
1612	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 );
1613	bErrorIvpEnhV = true;
1614	}
1615	}
1616	}
1617	}
1618
1619	if( m_GOPListMvc[k][MAX_GOP].m_sliceType == 'B' && m_GOPListMvc[k][MAX_GOP].m_numInterViewRefPics < 1 )
1620	{
1621	printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type B\n", k );
1622	bErrorIvpEnhV = true;
1623	}
1624	}
1625	}
1626	}
1627	}
1628	xConfirmPara( bErrorIvpEnhV, "Invalid inter-layer coding structure for enhancement layers given" );
1629
1630	// validate temporal coding structure
1631	if( !bErrorMvePoc && !bErrorIvpBase && !bErrorIvpEnhV )
1632	{
1633	for( Int layer = 0; layer < m_numberOfLayers; layer++ )
1634	{
1635	GOPEntry* m_GOPList = m_GOPListMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1636	Int& m_extraRPSs = m_extraRPSsMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1637	Int& m_maxTempLayer = m_maxTempLayerMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1638	Int* m_maxDecPicBuffering = m_maxDecPicBufferingMvc[layer]; // It is not a member, but this name helps avoiding code duplication !!!
1639	Int* m_numReorderPics = m_numReorderPicsMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!!
1640	#endif
1641	/* if this is an intra-only sequence, ie IntraPeriod=1, don't verify the GOP structure
1642	* This permits the ability to omit a GOP structure specification */
1643	if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) {
1644	m_GOPList[0] = GOPEntry();
1645	m_GOPList[0].m_QPFactor = 1;
1646	m_GOPList[0].m_betaOffsetDiv2 = 0;
1647	m_GOPList[0].m_tcOffsetDiv2 = 0;
1648	m_GOPList[0].m_POC = 1;
1649	m_GOPList[0].m_numRefPicsActive = 4;
1650	}
1651
1652	Bool verifiedGOP=false;
1653	Bool errorGOP=false;
1654	Int checkGOP=1;
1655	Int numRefs = 1;
1656	Int refList[MAX_NUM_REF_PICS+1];
1657	refList[0]=0;
1658	Bool isOK[MAX_GOP];
1659	for(Int i=0; i<MAX_GOP; i++)
1660	{
1661	isOK[i]=false;
1662	}
1663	Int numOK=0;
1664	xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );
1665
1666	for(Int i=0; i<m_iGOPSize; i++)
1667	{
1668	if(m_GOPList[i].m_POC==m_iGOPSize)
1669	{
1670	xConfirmPara( m_GOPList[i].m_temporalId!=0 , "The last frame in each GOP must have temporal ID = 0 " );
1671	}
1672	}
1673
1674	#if H_MV
1675	if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable[layer]) )
1676	#else
1677	if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
1678	#endif
1679	{
1680	for(Int i=0; i<m_iGOPSize; i++)
1681	{
1682	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)" );
1683	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)" );
1684	}
1685	}
1686	m_extraRPSs=0;
1687	//start looping through frames in coding order until we can verify that the GOP structure is correct.
1688	while(!verifiedGOP&&!errorGOP)
1689	{
1690	Int curGOP = (checkGOP-1)%m_iGOPSize;
1691	Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC;
1692	if(m_GOPList[curGOP].m_POC<0)
1693	{
1694	#if H_MV
1695	printf("\nError: found fewer Reference Picture Sets than GOPSize for layer %d\n", layer );
1696	#else
1697	printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
1698	#endif
1699	errorGOP=true;
1700	}
1701	else
1702	{
1703	//check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
1704	Bool beforeI = false;
1705	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
1706	{
1707	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1708	if(absPOC < 0)
1709	{
1710	beforeI=true;
1711	}
1712	else
1713	{
1714	Bool found=false;
1715	for(Int j=0; j<numRefs; j++)
1716	{
1717	if(refList[j]==absPOC)
1718	{
1719	found=true;
1720	for(Int k=0; k<m_iGOPSize; k++)
1721	{
1722	if(absPOC%m_iGOPSize == m_GOPList[k].m_POC%m_iGOPSize)
1723	{
1724	if(m_GOPList[k].m_temporalId==m_GOPList[curGOP].m_temporalId)
1725	{
1726	m_GOPList[k].m_refPic = true;
1727	}
1728	m_GOPList[curGOP].m_usedByCurrPic[i]=m_GOPList[k].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1729	}
1730	}
1731	}
1732	}
1733	if(!found)
1734	{
1735	#if H_MV
1736	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);
1737	#else
1738	printf("\nError: ref pic %d is not available for GOP frame %d\n",m_GOPList[curGOP].m_referencePics[i],curGOP+1);
1739	#endif
1740	errorGOP=true;
1741	}
1742	}
1743	}
1744	if(!beforeI&&!errorGOP)
1745	{
1746	//all ref frames were present
1747	if(!isOK[curGOP])
1748	{
1749	numOK++;
1750	isOK[curGOP]=true;
1751	if(numOK==m_iGOPSize)
1752	{
1753	verifiedGOP=true;
1754	}
1755	}
1756	}
1757	else
1758	{
1759	//create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
1760	m_GOPList[m_iGOPSize+m_extraRPSs]=m_GOPList[curGOP];
1761	Int newRefs=0;
1762	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
1763	{
1764	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1765	if(absPOC>=0)
1766	{
1767	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[newRefs]=m_GOPList[curGOP].m_referencePics[i];
1768	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[newRefs]=m_GOPList[curGOP].m_usedByCurrPic[i];
1769	newRefs++;
1770	}
1771	}
1772	Int numPrefRefs = m_GOPList[curGOP].m_numRefPicsActive;
1773
1774	for(Int offset = -1; offset>-checkGOP; offset--)
1775	{
1776	//step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
1777	Int offGOP = (checkGOP-1+offset)%m_iGOPSize;
1778	Int offPOC = ((checkGOP-1+offset)/m_iGOPSize)*m_iGOPSize + m_GOPList[offGOP].m_POC;
1779	if(offPOC>=0&&m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId)
1780	{
1781	Bool newRef=false;
1782	for(Int i=0; i<numRefs; i++)
1783	{
1784	if(refList[i]==offPOC)
1785	{
1786	newRef=true;
1787	}
1788	}
1789	for(Int i=0; i<newRefs; i++)
1790	{
1791	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[i]==offPOC-curPOC)
1792	{
1793	newRef=false;
1794	}
1795	}
1796	if(newRef)
1797	{
1798	Int insertPoint=newRefs;
1799	//this picture can be added, find appropriate place in list and insert it.
1800	if(m_GOPList[offGOP].m_temporalId==m_GOPList[curGOP].m_temporalId)
1801	{
1802	m_GOPList[offGOP].m_refPic = true;
1803	}
1804	for(Int j=0; j<newRefs; j++)
1805	{
1806	if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]<offPOC-curPOC\|\|m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]>0)
1807	{
1808	insertPoint = j;
1809	break;
1810	}
1811	}
1812	Int prev = offPOC-curPOC;
1813	Int prevUsed = m_GOPList[offGOP].m_temporalId<=m_GOPList[curGOP].m_temporalId;
1814	for(Int j=insertPoint; j<newRefs+1; j++)
1815	{
1816	Int newPrev = m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j];
1817	Int newUsed = m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j];
1818	m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j]=prev;
1819	m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j]=prevUsed;
1820	prevUsed=newUsed;
1821	prev=newPrev;
1822	}
1823	newRefs++;
1824	}
1825	}
1826	if(newRefs>=numPrefRefs)
1827	{
1828	break;
1829	}
1830	}
1831	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics=newRefs;
1832	m_GOPList[m_iGOPSize+m_extraRPSs].m_POC = curPOC;
1833	if (m_extraRPSs == 0)
1834	{
1835	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 0;
1836	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = 0;
1837	}
1838	else
1839	{
1840	Int rIdx = m_iGOPSize + m_extraRPSs - 1;
1841	Int refPOC = m_GOPList[rIdx].m_POC;
1842	Int refPics = m_GOPList[rIdx].m_numRefPics;
1843	Int newIdc=0;
1844	for(Int i = 0; i<= refPics; i++)
1845	{
1846	Int deltaPOC = ((i != refPics)? m_GOPList[rIdx].m_referencePics[i] : 0); // check if the reference abs POC is >= 0
1847	Int absPOCref = refPOC+deltaPOC;
1848	Int refIdc = 0;
1849	for (Int j = 0; j < m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefPics; j++)
1850	{
1851	if ( (absPOCref - curPOC) == m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[j])
1852	{
1853	if (m_GOPList[m_iGOPSize+m_extraRPSs].m_usedByCurrPic[j])
1854	{
1855	refIdc = 1;
1856	}
1857	else
1858	{
1859	refIdc = 2;
1860	}
1861	}
1862	}
1863	m_GOPList[m_iGOPSize+m_extraRPSs].m_refIdc[newIdc]=refIdc;
1864	newIdc++;
1865	}
1866	m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1;
1867	m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = newIdc;
1868	m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC;
1869	}
1870	curGOP=m_iGOPSize+m_extraRPSs;
1871	m_extraRPSs++;
1872	}
1873	numRefs=0;
1874	for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++)
1875	{
1876	Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i];
1877	if(absPOC >= 0)
1878	{
1879	refList[numRefs]=absPOC;
1880	numRefs++;
1881	}
1882	}
1883	refList[numRefs]=curPOC;
1884	numRefs++;
1885	}
1886	checkGOP++;
1887	}
1888	xConfirmPara(errorGOP,"Invalid GOP structure given");
1889	m_maxTempLayer = 1;
1890	for(Int i=0; i<m_iGOPSize; i++)
1891	{
1892	if(m_GOPList[i].m_temporalId >= m_maxTempLayer)
1893	{
1894	m_maxTempLayer = m_GOPList[i].m_temporalId+1;
1895	}
1896	xConfirmPara(m_GOPList[i].m_sliceType!='B'&&m_GOPList[i].m_sliceType!='P', "Slice type must be equal to B or P");
1897	}
1898	for(Int i=0; i<MAX_TLAYER; i++)
1899	{
1900	m_numReorderPics[i] = 0;
1901	#if L0323_DPB
1902	m_maxDecPicBuffering[i] = 1;
1903	#else
1904	m_maxDecPicBuffering[i] = 0;
1905	#endif
1906	}
1907	for(Int i=0; i<m_iGOPSize; i++)
1908	{
1909	#if L0323_DPB
1910	if(m_GOPList[i].m_numRefPics+1 > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
1911	#else
1912	if(m_GOPList[i].m_numRefPics > m_maxDecPicBuffering[m_GOPList[i].m_temporalId])
1913	#endif
1914	{
1915	#if L0323_DPB
1916	m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1;
1917	#else
1918	m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics;
1919	#endif
1920	}
1921	Int highestDecodingNumberWithLowerPOC = 0;
1922	for(Int j=0; j<m_iGOPSize; j++)
1923	{
1924	if(m_GOPList[j].m_POC <= m_GOPList[i].m_POC)
1925	{
1926	highestDecodingNumberWithLowerPOC = j;
1927	}
1928	}
1929	Int numReorder = 0;
1930	for(Int j=0; j<highestDecodingNumberWithLowerPOC; j++)
1931	{
1932	if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId &&
1933	m_GOPList[j].m_POC > m_GOPList[i].m_POC)
1934	{
1935	numReorder++;
1936	}
1937	}
1938	if(numReorder > m_numReorderPics[m_GOPList[i].m_temporalId])
1939	{
1940	m_numReorderPics[m_GOPList[i].m_temporalId] = numReorder;
1941	}
1942	}
1943	for(Int i=0; i<MAX_TLAYER-1; i++)
1944	{
1945	// a lower layer can not have higher value of m_numReorderPics than a higher layer
1946	if(m_numReorderPics[i+1] < m_numReorderPics[i])
1947	{
1948	m_numReorderPics[i+1] = m_numReorderPics[i];
1949	}
1950	#if L0323_DPB
1951	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
1952	if(m_numReorderPics[i] > m_maxDecPicBuffering[i] - 1)
1953	{
1954	m_maxDecPicBuffering[i] = m_numReorderPics[i] + 1;
1955	}
1956	#else
1957	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive
1958	if(m_numReorderPics[i] > m_maxDecPicBuffering[i])
1959	{
1960	m_maxDecPicBuffering[i] = m_numReorderPics[i];
1961	}
1962	#endif
1963	// a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
1964	if(m_maxDecPicBuffering[i+1] < m_maxDecPicBuffering[i])
1965	{
1966	m_maxDecPicBuffering[i+1] = m_maxDecPicBuffering[i];
1967	}
1968	}
1969
1970
1971	#if L0323_DPB
1972	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive
1973	if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1)
1974	{
1975	m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1] + 1;
1976	}
1977	#else
1978	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive
1979	if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1])
1980	{
1981	m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1];
1982	}
1983	#endif
1984
1985	if(m_vuiParametersPresentFlag && m_bitstreamRestrictionFlag)
1986	{
1987	Int PicSizeInSamplesY = m_iSourceWidth * m_iSourceHeight;
1988	if(tileFlag)
1989	{
1990	Int maxTileWidth = 0;
1991	Int maxTileHeight = 0;
1992	Int widthInCU = (m_iSourceWidth % m_uiMaxCUWidth) ? m_iSourceWidth/m_uiMaxCUWidth + 1: m_iSourceWidth/m_uiMaxCUWidth;
1993	Int heightInCU = (m_iSourceHeight % m_uiMaxCUHeight) ? m_iSourceHeight/m_uiMaxCUHeight + 1: m_iSourceHeight/m_uiMaxCUHeight;
1994	if(m_iUniformSpacingIdr)
1995	{
1996	maxTileWidth = m_uiMaxCUWidth*((widthInCU+m_iNumColumnsMinus1)/(m_iNumColumnsMinus1+1));
1997	maxTileHeight = m_uiMaxCUHeight*((heightInCU+m_iNumRowsMinus1)/(m_iNumRowsMinus1+1));
1998	// if only the last tile-row is one treeblock higher than the others
1999	// the maxTileHeight becomes smaller if the last row of treeblocks has lower height than the others
2000	if(!((heightInCU-1)%(m_iNumRowsMinus1+1)))
2001	{
2002	maxTileHeight = maxTileHeight - m_uiMaxCUHeight + (m_iSourceHeight % m_uiMaxCUHeight);
2003	}
2004	// if only the last tile-column is one treeblock wider than the others
2005	// the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others
2006	if(!((widthInCU-1)%(m_iNumColumnsMinus1+1)))
2007	{
2008	maxTileWidth = maxTileWidth - m_uiMaxCUWidth + (m_iSourceWidth % m_uiMaxCUWidth);
2009	}
2010	}
2011	else // not uniform spacing
2012	{
2013	if(m_iNumColumnsMinus1<1)
2014	{
2015	maxTileWidth = m_iSourceWidth;
2016	}
2017	else
2018	{
2019	Int accColumnWidth = 0;
2020	for(Int col=0; col<(m_iNumColumnsMinus1); col++)
2021	{
2022	maxTileWidth = m_pColumnWidth[col]>maxTileWidth ? m_pColumnWidth[col]:maxTileWidth;
2023	accColumnWidth += m_pColumnWidth[col];
2024	}
2025	maxTileWidth = (widthInCU-accColumnWidth)>maxTileWidth ? m_uiMaxCUWidth(widthInCU-accColumnWidth):m_uiMaxCUWidthmaxTileWidth;
2026	}
2027	if(m_iNumRowsMinus1<1)
2028	{
2029	maxTileHeight = m_iSourceHeight;
2030	}
2031	else
2032	{
2033	Int accRowHeight = 0;
2034	for(Int row=0; row<(m_iNumRowsMinus1); row++)
2035	{
2036	maxTileHeight = m_pRowHeight[row]>maxTileHeight ? m_pRowHeight[row]:maxTileHeight;
2037	accRowHeight += m_pRowHeight[row];
2038	}
2039	maxTileHeight = (heightInCU-accRowHeight)>maxTileHeight ? m_uiMaxCUHeight(heightInCU-accRowHeight):m_uiMaxCUHeightmaxTileHeight;
2040	}
2041	}
2042	Int maxSizeInSamplesY = maxTileWidth*maxTileHeight;
2043	m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/maxSizeInSamplesY-4;
2044	}
2045	else if(m_iWaveFrontSynchro)
2046	{
2047	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/((2m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4;
2048	}
2049	else if(m_sliceMode == 1)
2050	{
2051	m_minSpatialSegmentationIdc = 4PicSizeInSamplesY/(m_sliceArgumentm_uiMaxCUWidth*m_uiMaxCUHeight)-4;
2052	}
2053	else
2054	{
2055	m_minSpatialSegmentationIdc = 0;
2056	}
2057	}
2058	#if !L0034_COMBINED_LIST_CLEANUP
2059	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.
2060	#endif
2061	xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
2062	xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
2063	xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
2064
2065	xConfirmPara( m_decodedPictureHashSEIEnabled<0 \|\| m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n");
2066
2067	#if J0149_TONE_MAPPING_SEI
2068	if (m_toneMappingInfoSEIEnabled)
2069	{
2070	xConfirmPara( m_toneMapCodedDataBitDepth < 8 \|\| m_toneMapCodedDataBitDepth > 14 , "SEIToneMapCodedDataBitDepth must be in rage 8 to 14");
2071	xConfirmPara( m_toneMapTargetBitDepth < 1 \|\| (m_toneMapTargetBitDepth > 16 && m_toneMapTargetBitDepth < 255) , "SEIToneMapTargetBitDepth must be in rage 1 to 16 or equal to 255");
2072	xConfirmPara( m_toneMapModelId < 0 \|\| m_toneMapModelId > 4 , "SEIToneMapModelId must be in rage 0 to 4");
2073	xConfirmPara( m_cameraIsoSpeedValue == 0, "SEIToneMapCameraIsoSpeedValue shall not be equal to 0");
2074	xConfirmPara( m_extendedRangeWhiteLevel < 100, "SEIToneMapExtendedRangeWhiteLevel should be greater than or equal to 100");
2075	xConfirmPara( m_nominalBlackLevelLumaCodeValue >= m_nominalWhiteLevelLumaCodeValue, "SEIToneMapNominalWhiteLevelLumaCodeValue shall be greater than SEIToneMapNominalBlackLevelLumaCodeValue");
2076	xConfirmPara( m_extendedWhiteLevelLumaCodeValue < m_nominalWhiteLevelLumaCodeValue, "SEIToneMapExtendedWhiteLevelLumaCodeValue shall be greater than or equal to SEIToneMapNominalWhiteLevelLumaCodeValue");
2077	}
2078	#endif
2079
2080	#if RATE_CONTROL_LAMBDA_DOMAIN
2081	if ( m_RCEnableRateControl )
2082	{
2083	if ( m_RCForceIntraQP )
2084	{
2085	if ( m_RCInitialQP == 0 )
2086	{
2087	printf( "\nInitial QP for rate control is not specified. Reset not to use force intra QP!" );
2088	m_RCForceIntraQP = false;
2089	}
2090	}
2091	xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
2092	}
2093	#else
2094	if(m_enableRateCtrl)
2095	{
2096	Int numLCUInWidth = (m_iSourceWidth / m_uiMaxCUWidth) + (( m_iSourceWidth % m_uiMaxCUWidth ) ? 1 : 0);
2097	Int numLCUInHeight = (m_iSourceHeight / m_uiMaxCUHeight)+ (( m_iSourceHeight % m_uiMaxCUHeight) ? 1 : 0);
2098	Int numLCUInPic = numLCUInWidth * numLCUInHeight;
2099
2100	xConfirmPara( (numLCUInPic % m_numLCUInUnit) != 0, "total number of LCUs in a frame should be completely divided by NumLCUInUnit" );
2101
2102	m_iMaxDeltaQP = MAX_DELTA_QP;
2103	m_iMaxCuDQPDepth = MAX_CUDQP_DEPTH;
2104	}
2105	#endif
2106
2107	xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagValue, "CUTransquantBypassFlagValue cannot be 1 when TransquantBypassEnableFlag is 0");
2108
2109	xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2");
2110	#if L0444_FPA_TYPE
2111	if (m_framePackingSEIEnabled)
2112	{
2113	xConfirmPara(m_framePackingSEIType < 3 \|\| m_framePackingSEIType > 5 , "SEIFramePackingType must be in rage 3 to 5");
2114	}
2115	#endif
2116	#if H_MV
2117	}
2118	}
2119	#endif
2120
2121	#undef xConfirmPara
2122	if (check_failed)
2123	{
2124	exit(EXIT_FAILURE);
2125	}
2126	}
2127
2128	/** \todo use of global variables should be removed later
2129	*/
2130	Void TAppEncCfg::xSetGlobal()
2131	{
2132	// set max CU width & height
2133	g_uiMaxCUWidth = m_uiMaxCUWidth;
2134	g_uiMaxCUHeight = m_uiMaxCUHeight;
2135
2136	// compute actual CU depth with respect to config depth and max transform size
2137	g_uiAddCUDepth = 0;
2138	while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth ) ) ) g_uiAddCUDepth++;
2139
2140	m_uiMaxCUDepth += g_uiAddCUDepth;
2141	g_uiAddCUDepth++;
2142	g_uiMaxCUDepth = m_uiMaxCUDepth;
2143
2144	// set internal bit-depth and constants
2145	g_bitDepthY = m_internalBitDepthY;
2146	g_bitDepthC = m_internalBitDepthC;
2147
2148	g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY;
2149	g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC;
2150	}
2151
2152	Void TAppEncCfg::xPrintParameter()
2153	{
2154	printf("\n");
2155	#if H_MV
2156	for( Int layer = 0; layer < m_numberOfLayers; layer++)
2157	{
2158	printf("Input File %i : %s\n", layer, m_pchInputFileList[layer]);
2159	}
2160	#else
2161	printf("Input File : %s\n", m_pchInputFile );
2162	#endif
2163	printf("Bitstream File : %s\n", m_pchBitstreamFile );
2164	#if H_MV
2165	for( Int layer = 0; layer < m_numberOfLayers; layer++)
2166	{
2167	printf("Reconstruction File %i : %s\n", layer, m_pchReconFileList[layer]);
2168	}
2169	#else
2170	printf("Reconstruction File : %s\n", m_pchReconFile );
2171	#endif
2172	#if H_MV
2173	xPrintParaVector( "ViewId", m_viewId );
2174	#endif
2175	#if H_3D
2176	xPrintParaVector( "DepthFlag", m_depthFlag );
2177	printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2178	#endif
2179	#if H_MV
2180	xPrintParaVector( "QP" , m_fQP );
2181	xPrintParaVector( "LoopFilterDisable", m_bLoopFilterDisable );
2182	xPrintParaVector( "SAO" , m_bUseSAO );
2183	#endif
2184	printf("Real Format : %dx%d %dHz\n", m_iSourceWidth - m_confLeft - m_confRight, m_iSourceHeight - m_confTop - m_confBottom, m_iFrameRate );
2185	printf("Internal Format : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
2186	printf("Frame index : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
2187	printf("CU size / depth : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
2188	printf("RQT trans. size (min / max) : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
2189	printf("Max RQT depth inter : %d\n", m_uiQuadtreeTUMaxDepthInter);
2190	printf("Max RQT depth intra : %d\n", m_uiQuadtreeTUMaxDepthIntra);
2191	printf("Min PCM size : %d\n", 1 << m_uiPCMLog2MinSize);
2192	printf("Motion search range : %d\n", m_iSearchRange );
2193	printf("Intra period : %d\n", m_iIntraPeriod );
2194	printf("Decoding refresh type : %d\n", m_iDecodingRefreshType );
2195	#if !H_MV
2196	printf("QP : %5.2f\n", m_fQP );
2197	#endif
2198	printf("Max dQP signaling depth : %d\n", m_iMaxCuDQPDepth);
2199
2200	printf("Cb QP Offset : %d\n", m_cbQpOffset );
2201	printf("Cr QP Offset : %d\n", m_crQpOffset);
2202
2203	printf("QP adaptation : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
2204	printf("GOP size : %d\n", m_iGOPSize );
2205	printf("Internal bit depth : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC );
2206	printf("PCM sample bit depth : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma );
2207	#if RATE_CONTROL_LAMBDA_DOMAIN
2208	printf("RateControl : %d\n", m_RCEnableRateControl );
2209	if(m_RCEnableRateControl)
2210	{
2211	printf("TargetBitrate : %d\n", m_RCTargetBitrate );
2212	printf("KeepHierarchicalBit : %d\n", m_RCKeepHierarchicalBit );
2213	printf("LCULevelRC : %d\n", m_RCLCULevelRC );
2214	printf("UseLCUSeparateModel : %d\n", m_RCUseLCUSeparateModel );
2215	printf("InitialQP : %d\n", m_RCInitialQP );
2216	printf("ForceIntraQP : %d\n", m_RCForceIntraQP );
2217	}
2218	#else
2219	printf("RateControl : %d\n", m_enableRateCtrl);
2220	if(m_enableRateCtrl)
2221	{
2222	printf("TargetBitrate : %d\n", m_targetBitrate);
2223	printf("NumLCUInUnit : %d\n", m_numLCUInUnit);
2224	}
2225	#endif
2226	printf("Max Num Merge Candidates : %d\n", m_maxNumMergeCand);
2227	#if H_3D
2228	printf("BaseViewCameraNumbers : %s\n", m_pchBaseViewCameraNumbers );
2229	printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
2230	#if H_3D_VSO
2231	printf("Force use of Lambda Scale : %d\n", m_bForceLambdaScaleVSO );
2232
2233	if ( m_bUseVSO )
2234	{
2235	printf("VSO Lambda Scale : %5.2f\n", m_dLambdaScaleVSO );
2236	printf("VSO Mode : %d\n", m_uiVSOMode );
2237	printf("VSO Config : %s\n", m_pchVSOConfig );
2238	printf("VSO Negative Distortion : %d\n", m_bAllowNegDist ? 1 : 0);
2239	printf("VSO LS Table : %d\n", m_bVSOLSTable ? 1 : 0);
2240	printf("VSO Estimated VSD : %d\n", m_bUseEstimatedVSD ? 1 : 0);
2241	printf("VSO Early Skip : %d\n", m_bVSOEarlySkip ? 1 : 0);
2242	if ( m_bUseWVSO )
2243	printf("Dist. Weights (VSO/VSD/SAD) : %d/%d/%d\n ", m_iVSOWeight, m_iVSDWeight, m_iDWeight );
2244	}
2245	#endif //HHI_VSO
2246	#endif //H_3D
2247	printf("\n");
2248	#if H_MV
2249	printf("TOOL CFG General: ");
2250	#else
2251	printf("TOOL CFG: ");
2252	#endif
2253	printf("IBD:%d ", g_bitDepthY > m_inputBitDepthY \|\| g_bitDepthC > m_inputBitDepthC);
2254	printf("HAD:%d ", m_bUseHADME );
2255	printf("SRD:%d ", m_bUseSBACRD );
2256	printf("RDQ:%d ", m_useRDOQ );
2257	printf("RDQTS:%d ", m_useRDOQTS );
2258	#if L0232_RD_PENALTY
2259	printf("RDpenalty:%d ", m_rdPenalty );
2260	#endif
2261	printf("SQP:%d ", m_uiDeltaQpRD );
2262	printf("ASR:%d ", m_bUseASR );
2263	#if !L0034_COMBINED_LIST_CLEANUP
2264	printf("LComb:%d ", m_bUseLComb );
2265	#endif
2266	printf("FEN:%d ", m_bUseFastEnc );
2267	printf("ECU:%d ", m_bUseEarlyCU );
2268	printf("FDM:%d ", m_useFastDecisionForMerge );
2269	printf("CFM:%d ", m_bUseCbfFastMode );
2270	printf("ESD:%d ", m_useEarlySkipDetection );
2271	printf("RQT:%d ", 1 );
2272	printf("TransformSkip:%d ", m_useTransformSkip );
2273	printf("TransformSkipFast:%d ", m_useTransformSkipFast );
2274	printf("Slice: M=%d ", m_sliceMode);
2275	if (m_sliceMode!=0)
2276	{
2277	printf("A=%d ", m_sliceArgument);
2278	}
2279	printf("SliceSegment: M=%d ",m_sliceSegmentMode);
2280	if (m_sliceSegmentMode!=0)
2281	{
2282	printf("A=%d ", m_sliceSegmentArgument);
2283	}
2284	printf("CIP:%d ", m_bUseConstrainedIntraPred);
2285	#if !H_MV
2286	printf("SAO:%d ", (m_bUseSAO)?(1):(0));
2287	#endif
2288	printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
2289	printf("SAOLcuBasedOptimization:%d ", (m_saoLcuBasedOptimization)?(1):(0));
2290
2291	printf("LosslessCuEnabled:%d ", (m_useLossless)? 1:0 );
2292	printf("WPP:%d ", (Int)m_useWeightedPred);
2293	printf("WPB:%d ", (Int)m_useWeightedBiPred);
2294	printf("PME:%d ", m_log2ParallelMergeLevel);
2295	printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d",
2296	m_iWaveFrontSynchro, m_iWaveFrontSubstreams);
2297	printf(" ScalingList:%d ", m_useScalingListId );
2298	printf("TMVPMode:%d ", m_TMVPModeId );
2299	#if ADAPTIVE_QP_SELECTION
2300	printf("AQpS:%d ", m_bUseAdaptQpSelect );
2301	#endif
2302
2303	printf(" SignBitHidingFlag:%d ", m_signHideFlag);
2304	printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 );
2305	#if H_3D_VSO
2306	printf("VSO:%d ", m_bUseVSO );
2307	printf("WVSO:%d ", m_bUseWVSO );
2308	#endif
2309	#if H_3D_IV_MERGE
2310	printf("IvMvPred:%d ", m_ivMvPredFlag );
2311	#endif
2312	#if H_3D_ARP
2313	printf(" ARP:%d ", m_uiUseAdvResPred );
2314	#endif
2315	#if H_3D_IC
2316	printf( "IlluCompEnable: %d %d ", m_abUseIC[0] ? 1 : 0, m_abUseIC[1] ? 1 : 0 );
2317	#endif
2318	#if H_3D_NBDV_REF
2319	printf("DepthRefinement:%d ", m_depthRefinementFlag );
2320	#endif
2321	#if H_3D_VSP
2322	printf("ViewSynthesisPred:%d ", m_viewSynthesisPredFlag );
2323	#endif
2324	#if H_3D_DIM
2325	printf("DMM:%d ", m_useDMM );
2326	printf("RBC:%d ", m_useRBC );
2327	printf("SDC:%d ", m_useSDC );
2328	printf("DLT:%d ", m_useDLT );
2329	#endif
2330	printf("\n\n");
2331
2332	fflush(stdout);
2333	}
2334
2335	Bool confirmPara(Bool bflag, const Char* message)
2336	{
2337	if (!bflag)
2338	return false;
2339
2340	printf("Error: %s\n",message);
2341	return true;
2342	}
2343
2344	//! \}

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

Download in other formats: