Context navigation

source: 3DVCSoftware/branches/HTM-8.2-dev0-MediaTek/source/App/TAppEncoder/TAppEncCfg.cpp @ 629

Visit:

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

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

Download in other formats: