Context navigation

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

Visit:

Last change on this file since 464 was 464, checked in by zhang, 11 years ago
Implementation of ARP from QC
Property svn:eol-style set to `native`
File size: 105.3 KB

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

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

Download in other formats: