Context navigation

TAppEncCfg.cpp @ 446

Visit:

Last change on this file since 446 was 446, checked in by tech, 11 years ago
Added missing parts.
Property svn:eol-style set to `native`
File size: 105.0 KB

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-DEV-0.2-dev/source/App/TAppEncoder/TAppEncCfg.cpp @ 446

Download in other formats: