Context navigation

TAppEncCfg.cpp @ 854

Visit:

Last change on this file since 854 was 854, checked in by tech, 10 years ago

Integrated following MV-HEVC HLS 7 items:

H_MV_HLS7_GEN Stub for further integrations (not tested)
H_MV_HLS_7_OUTPUT_LAYERS_5_10_22_27 Output layer sets, various

(VPS/P0300/alt output layer flag) #27 Change alt output layer flag to be signalled within the loop of output layer sets, from JCTVC-P0300-v2. Decision: Adopt.
(VPS/P0156/Num of output_layer_flag) #10 Proposal 3: The output_layer_flag[ i ][ j ] is signalled for j equal to 0 to NumLayersInIdList[ lsIdx ] inclusive. It was remarked that we might be able to just assume that the top layer is always output; however, this was not entirely clear , so the safe thing to do may be to also send the flag for this layer.
(VPS/P0295/Default output layer sets) #5 Discussion from (P0110). Decision: Three-state approach (text in P0295, decoder shall allow 3 to be present and shall treat 3 the same as the value 2).

H_MV_HLS_7_HRD_P0156_7 (HRD/P0156/MaxSubLayersInLayerSetMinus1) #7 Proposal 1: signal, in the VPS extension, the DPB parameters for an output layer set for sub-DPBs only up to the maximum temporal sub-layers in the corresponding layer set
H_MV_HLS_7_VPS_P0048_14 (VPS/P0048/profile_ref_minus1 rem) #14 Remove profile_ref_minus1 from the VPS extension, from JCTVC-P0048
H_MV_HLS_7_VPS_P0076_15 (VPS/P0076/video signal info move) #15 Move video signal information syntax structure earlier in the VPS VUI.
H_MV_HLS_7_SPS_P0155_16_32 (SPS/P0155/sps_sub_layer_ordering_info) #16, #32 Not signal the sps_max_num_reorder_pics[], sps_max_latency_increase_plus1[], and sps_max_dec_pic_buffering_minus1[] syntax elements in the SPS when nuh_layer_id > 0.
H_MV_HLS_7_GEN_P0166_PPS_EXTENSION (GEN/P0166/pps_extension) #17 Add PPS extension type flags for conditional presence of syntax extensions per extension type, aligned with the SPS extension type flags, from JCTVC-P0166. Further align the SPS extension type flags syntax between RExt and MV-HEVC/SHVC
H_MV_HLS_7_FIX_SET_DPB_SIZE Fix derivation dpb size parameters
H_MV_HLS_7_RESERVED_FLAGS Added flags

(SPS/P0312/SHVC reserved flag) The flag will be used for the syntax vert_phase_position_enable_flag in SHVC draft
(VPS/O0215/SHVC reserved flag): this flag will be used for the syntax cross_layer_phase_alignment_flag in SHVC draft.
(VPS VUI/O0199,P0312/SHVC reserved flags) the 3 reserved bits will be used for the syntaxes single_layer_for_non_irap_flag, higher_layer_irap_skip_flag and vert_phase_position_not_in_use_flag in SHVC draft.

H_MV_FIX_VPS_LAYER_ID_NOT_EQUAL_ZERO Discard VPS with nuh_layer_Id > 0
H_MV_HLS_7_MISC_P0130_EOS (MISC/P0130/EOS NAL layer id) #19 Require that end of bitstream NAL unit shall have nuh_layer_id equal to 0, from JCTVC-P0130. Decoders shall allow an end of bitstream NAL unit with nuh_layer_id > 0 to be present, and shall ignore the NAL unit.
H_MV_HLS_7_MISC_P0182_13 (MISC/P0182/BL PS Compatibility flag) #13 Define the flag (in VPS VUI) with the proposed semantics, without specifying an associated extraction process. Editors to select the position in the VPS VUI.
H_MV_HLS_7_MISC_P0068_21 (MISC/P0068/all irap idr flag) #21 Add flag in VUI to indicate that all IRAP pictures are IDRs and that all layer pictures in an AU are IDR aligned, from JCTVC-P0068 proposal 1.
H_MV_HLS_7_FIX_INFER_CROSS_LAYER_IRAP_ALIGNED_FLAG Fix inference of cross_layer_irap_aligned_flag
H_MV_HLS_7_MISC_P0079_18 (MISC/P0079/NumActiveRefLayerPics) #18 Modification of derivation of variable NumActiveRefLayerPics.

Property svn:eol-style set to native

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-10.0-dev0/source/App/TAppEncoder/TAppEncCfg.cpp @ 854

Download in other formats: