Context navigation

TAppEncCfg.cpp @ 892

Visit:

Last change on this file since 892 was 696, checked in by samsung-htm, 11 years ago
Integration of F0150: MPI candidate in depth merge mode list construction
Property svn:eol-style set to `native`
File size: 113.7 KB

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-8.2-dev2-Samsung/source/App/TAppEncoder/TAppEncCfg.cpp @ 892

Download in other formats: