Context navigation

source: 3DVCSoftware/trunk/source/App/TAppEncoder/TAppEncCfg.cpp @ 1097

Visit:

Last change on this file since 1097 was 1084, checked in by tech, 10 years ago
Merged branches/HTM-12.1-dev0@1083.
Property svn:eol-style set to `native`
File size: 125.7 KB

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

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

Download in other formats: