Context navigation

TAppEncCfg.cpp @ 613

Visit:

Last change on this file since 613 was 508, checked in by tech, 12 years ago
Fixed compiler warning.
Property svn:eol-style set to `native`
File size: 109.5 KB

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

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

JCT-3V 3D-HEVC

Context navigation

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

Download in other formats: