Context navigation

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

Visit:

Last change on this file since 454 was 443, checked in by tech, 12 years ago
Reintegrated branch 6.2-dev0 rev. 442. Changed version number. Added coding results.
Property svn:eol-style set to `native`
File size: 79.4 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	*
[56]	6	* Copyright (c) 2010-2012, 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"
[56]	44	#include "TAppCommon/program_options_lite.h"
[2]	45
[56]	46	#ifdef WIN32
	47	#define strdup _strdup
	48	#endif
[2]	49
	50	using namespace std;
	51	namespace po = df::program_options_lite;
	52
[56]	53	//! \ingroup TAppEncoder
	54	//! \{
	55
[2]	56	/* configuration helper funcs */
	57	void doOldStyleCmdlineOn(po::Options& opts, const std::string& arg);
	58	void doOldStyleCmdlineOff(po::Options& opts, const std::string& arg);
	59
	60	// ====================================================================================================================
	61	// Local constants
	62	// ====================================================================================================================
	63
	64	/// max value of source padding size
	65	/** \todo replace it by command line option
	66	*/
	67	#define MAX_PAD_SIZE 16
	68
	69	// ====================================================================================================================
	70	// Constructor / destructor / initialization / destroy
	71	// ====================================================================================================================
	72
	73	TAppEncCfg::TAppEncCfg()
	74	{
	75	m_aidQP = NULL;
[100]	76	m_aidQPdepth = NULL;
[2]	77	}
	78
	79	TAppEncCfg::~TAppEncCfg()
	80	{
	81	if ( m_aidQP )
	82	{
	83	delete[] m_aidQP; m_aidQP = NULL;
	84	}
[100]	85
	86	if ( m_aidQPdepth )
	87	{
	88	delete[] m_aidQPdepth; m_aidQPdepth = NULL;
	89	}
	90
[2]	91	for(Int i = 0; i< m_pchInputFileList.size(); i++ )
	92	{
	93	if ( m_pchInputFileList[i] != NULL )
	94	free (m_pchInputFileList[i]);
	95	}
	96	for(Int i = 0; i< m_pchDepthInputFileList.size(); i++ )
	97	{
	98	if ( m_pchDepthInputFileList[i] != NULL )
	99	free (m_pchDepthInputFileList[i]);
	100	}
	101	for(Int i = 0; i< m_pchReconFileList.size(); i++ )
	102	{
	103	if ( m_pchReconFileList[i] != NULL )
	104	free (m_pchReconFileList[i]);
	105	}
	106	for(Int i = 0; i< m_pchDepthReconFileList.size(); i++ )
	107	{
	108	if ( m_pchDepthReconFileList[i] != NULL )
	109	free (m_pchDepthReconFileList[i]);
	110	}
[56]	111	if (m_pchBitstreamFile != NULL)
	112	free (m_pchBitstreamFile) ;
[210]	113	#if FLEX_CODING_ORDER_M23723
	114	if (m_pchMVCJointCodingOrder != NULL)
	115	{
	116	free(m_pchMVCJointCodingOrder) ;
	117	}
	118	#endif
[5]	119	#if HHI_VSO
[2]	120	if ( m_pchVSOConfig != NULL)
	121	free ( m_pchVSOConfig );
[5]	122	#endif
[2]	123
[121]	124	if ( m_pchCameraParameterFile != NULL )
	125	free ( m_pchCameraParameterFile );
	126
	127	if ( m_pchBaseViewCameraNumbers != NULL )
	128	free ( m_pchBaseViewCameraNumbers );
	129
	130	if ( m_pchdQPFile != NULL )
	131	free ( m_pchdQPFile );
	132
	133	if ( m_pchColumnWidth != NULL )
	134	free ( m_pchColumnWidth );
	135
	136	if ( m_pchRowHeight != NULL )
	137	free ( m_pchRowHeight );
	138
	139	if ( m_scalingListFile != NULL )
	140	free ( m_scalingListFile );
	141
	142
[2]	143	}
	144
	145	Void TAppEncCfg::create()
	146	{
	147	}
	148
	149	Void TAppEncCfg::destroy()
	150	{
	151	}
	152
[56]	153	std::istringstream &operator>>( std::istringstream &in, GOPEntryMvc &entry ) //input
	154	{
	155	in>>entry.m_sliceType;
	156	in>>entry.m_POC;
	157	in>>entry.m_QPOffset;
	158	in>>entry.m_QPFactor;
	159	in>>entry.m_temporalId;
	160	in>>entry.m_numRefPicsActive;
	161	in>>entry.m_refPic;
	162	in>>entry.m_numRefPics;
	163	for ( Int i = 0; i < entry.m_numRefPics; i++ )
	164	{
	165	in>>entry.m_referencePics[i];
	166	}
	167	in>>entry.m_interRPSPrediction;
	168	if (entry.m_interRPSPrediction)
	169	{
	170	in>>entry.m_deltaRIdxMinus1;
	171	in>>entry.m_deltaRPS;
	172	in>>entry.m_numRefIdc;
	173	for ( Int i = 0; i < entry.m_numRefIdc; i++ )
	174	{
	175	in>>entry.m_refIdc[i];
	176	}
	177	}
	178	in>>entry.m_numInterViewRefPics;
	179	for( Int i = 0; i < entry.m_numInterViewRefPics; i++ )
	180	{
	181	in>>entry.m_interViewRefs[i];
	182	}
	183	for( Int i = 0; i < entry.m_numInterViewRefPics; i++ )
	184	{
	185	in>>entry.m_interViewRefPosL0[i];
	186	}
	187	for( Int i = 0; i < entry.m_numInterViewRefPics; i++ )
	188	{
	189	in>>entry.m_interViewRefPosL1[i];
	190	}
	191	return in;
	192	}
	193
[2]	194	// ====================================================================================================================
	195	// Public member functions
	196	// ====================================================================================================================
	197
	198	/** \param argc number of arguments
	199	\param argv array of arguments
	200	\retval true when success
	201	*/
	202	Bool TAppEncCfg::parseCfg( Int argc, Char* argv[] )
	203	{
	204	bool do_help = false;
[56]	205
[2]	206	string cfg_BitstreamFile;
	207	string cfg_dQPFile;
[56]	208	string cfg_ColumnWidth;
	209	string cfg_RowHeight;
	210	string cfg_ScalingListFile;
[210]	211
	212	#if FLEX_CODING_ORDER_M23723
	213	string cfg_JointCodingOrdering;
	214	#endif
	215
[2]	216	po::Options opts;
	217	opts.addOptions()
	218	("help", do_help, false, "this help text")
	219	("c", po::parseConfigFile, "configuration file name")
[56]	220
[2]	221	/* File, I/O and source parameters */
[296]	222	("InputFile_%d,i_%d", m_pchInputFileList, (char *) 0 , MAX_VIEW_NUM , "original Yuv input file name %d")
	223	("DepthInputFile_%d,di_%d", m_pchDepthInputFileList, (char *) 0 , MAX_VIEW_NUM , "original Yuv depth input file name %d")
	224	("ReconFile_%d,o_%d", m_pchReconFileList, (char *) 0 , MAX_VIEW_NUM , "reconstructed Yuv output file name %d")
	225	("DepthReconFile_%d,do_%d", m_pchDepthReconFileList, (char *) 0 , MAX_VIEW_NUM , "reconstructed Yuv depth output file name %d")
	226	("BitstreamFile,b", cfg_BitstreamFile, string(""), "bitstream output file name")
	227	("CodeDepthMaps", m_bUsingDepthMaps, false, "Encode depth maps" )
	228	("CodedCamParsPrecision", m_iCodedCamParPrecision, STD_CAM_PARAMETERS_PRECISION, "precision for coding of camera parameters (in units of 2^(-x) luma samples)" )
	229	("LambdaModifier0,-LM0", m_adLambdaModifier[ 0 ], ( double )1.0, "Lambda modifier for temporal layer 0")
	230	("LambdaModifier1,-LM1", m_adLambdaModifier[ 1 ], ( double )1.0, "Lambda modifier for temporal layer 1")
	231	("LambdaModifier2,-LM2", m_adLambdaModifier[ 2 ], ( double )1.0, "Lambda modifier for temporal layer 2")
	232	("LambdaModifier3,-LM3", m_adLambdaModifier[ 3 ], ( double )1.0, "Lambda modifier for temporal layer 3")
	233	("SourceWidth,-wdt", m_iSourceWidth, 0, "Source picture width")
	234	("SourceHeight,-hgt", m_iSourceHeight, 0, "Source picture height")
	235	("CroppingMode", m_croppingMode, 0, "Cropping mode (0: no cropping, 1:automatic padding, 2: padding, 3:cropping")
	236	("CropLeft", m_cropLeft, 0, "Left cropping/padding for cropping mode 3")
	237	("CropRight", m_cropRight, 0, "Right cropping/padding for cropping mode 3")
	238	("CropTop", m_cropTop, 0, "Top cropping/padding for cropping mode 3")
	239	("CropBottom", m_cropBottom, 0, "Bottom cropping/padding for cropping mode 3")
	240	("HorizontalPadding,-pdx", m_aiPad[0], 0, "horizontal source padding for cropping mode 2")
	241	("VerticalPadding,-pdy", m_aiPad[1], 0, "vertical source padding for cropping mode 2")
[2]	242	("InputBitDepth", m_uiInputBitDepth, 8u, "bit-depth of input file")
	243	("BitDepth", m_uiInputBitDepth, 8u, "deprecated alias of InputBitDepth")
	244	("OutputBitDepth", m_uiOutputBitDepth, 0u, "bit-depth of output file")
	245	("InternalBitDepth", m_uiInternalBitDepth, 0u, "Internal bit-depth (BitDepth+BitIncrement)")
	246	("FrameRate,-fr", m_iFrameRate, 0, "Frame rate")
	247	("FrameSkip,-fs", m_FrameSkip, 0u, "Number of frames to skip at start of input YUV")
	248	("FramesToBeEncoded,f", m_iFrameToBeEncoded, 0, "number of frames to be encoded (default=all)")
[296]	249	("FrameToBeEncoded", m_iFrameToBeEncoded, 0, "deprecated alias of FramesToBeEncoded")
[56]	250
[2]	251	("NumberOfViews", m_iNumberOfViews, 0, "Number of views")
[210]	252	#if FLEX_CODING_ORDER_M23723
	253	("FCO", m_b3DVFlexOrder, false, "flexible coding order flag" )
	254	("FCOCodingOrder", cfg_JointCodingOrdering, string(""), "The coding order for joint texture-depth coding")
	255	#endif
[2]	256	/* Unit definition parameters */
	257	("MaxCUWidth", m_uiMaxCUWidth, 64u)
	258	("MaxCUHeight", m_uiMaxCUHeight, 64u)
	259	/* todo: remove defaults from MaxCUSize */
	260	("MaxCUSize,s", m_uiMaxCUWidth, 64u, "max CU size")
	261	("MaxCUSize,s", m_uiMaxCUHeight, 64u, "max CU size")
	262	("MaxPartitionDepth,h", m_uiMaxCUDepth, 4u, "CU depth")
[56]	263
[2]	264	("QuadtreeTULog2MaxSize", m_uiQuadtreeTULog2MaxSize, 6u)
	265	("QuadtreeTULog2MinSize", m_uiQuadtreeTULog2MinSize, 2u)
[56]	266
[2]	267	("QuadtreeTUMaxDepthIntra", m_uiQuadtreeTUMaxDepthIntra, 1u)
	268	("QuadtreeTUMaxDepthInter", m_uiQuadtreeTUMaxDepthInter, 2u)
[56]	269
[2]	270	/* Coding structure paramters */
[56]	271	("IntraPeriod,-ip",m_iIntraPeriod, -1, "intra period in frames, (-1: only first frame)")
	272	("DecodingRefreshType,-dr",m_iDecodingRefreshType, 0, "intra refresh, (0:none 1:CRA 2:IDR)")
[2]	273	("GOPSize,g", m_iGOPSize, 1, "GOP size of temporal structure")
[56]	274	("ListCombination,-lc", m_bUseLComb, true, "combined reference list flag for uni-prediction in B-slices")
[2]	275	("LCModification", m_bLCMod, false, "enables signalling of combined reference list derivation")
[56]	276	("DisableInter4x4", m_bDisInter4x4, true, "Disable Inter 4x4")
	277	("NSQT", m_enableNSQT, true, "Enable non-square transforms")
	278	("AMP", m_enableAMP, true, "Enable asymmetric motion partitions")
[2]	279	/* motion options */
	280	("FastSearch", m_iFastSearch, 1, "0:Full search 1:Diamond 2:PMVFAST")
	281	("SearchRange,-sr",m_iSearchRange, 96, "motion search range")
[210]	282	#if DV_V_RESTRICTION_B0037
	283	("DisparitySearchRangeRestriction",m_bUseDisparitySearchRangeRestriction, false, "restrict disparity search range")
	284	("VerticalDisparitySearchRange",m_iVerticalDisparitySearchRange, 56, "vertical disparity search range")
	285	#endif
[2]	286	("BipredSearchRange", m_bipredSearchRange, 4, "motion search range for bipred refinement")
	287	("HadamardME", m_bUseHADME, true, "hadamard ME for fractional-pel")
	288	("ASR", m_bUseASR, false, "adaptive motion search range")
[56]	289
[2]	290	/* Quantization parameters */
	291	("QP,q", m_adQP, std::vector<double>(1,32), "Qp value, if value is float, QP is switched once during encoding, if two values are given the second is used for depth")
	292	("DeltaQpRD,-dqr",m_uiDeltaQpRD, 0u, "max dQp offset for slice")
	293	("MaxDeltaQP,d", m_iMaxDeltaQP, 0, "max dQp offset for block")
[56]	294	("MaxCuDQPDepth,-dqd", m_iMaxCuDQPDepth, 0, "max depth for a minimum CuDQP")
	295
	296	("ChromaQpOffset, -cqo", m_iChromaQpOffset, 0, "ChromaQpOffset")
	297	("ChromaQpOffset2nd,-cqo2", m_iChromaQpOffset2nd, 0, "ChromaQpOffset2nd")
	298
	299	#if ADAPTIVE_QP_SELECTION
	300	("AdaptiveQpSelection,-aqps", m_bUseAdaptQpSelect, false, "AdaptiveQpSelection")
	301	#endif
	302
	303	("AdaptiveQP,-aq", m_bUseAdaptiveQP, false, "QP adaptation based on a psycho-visual model")
	304	("MaxQPAdaptationRange,-aqr", m_iQPAdaptationRange, 6, "QP adaptation range")
	305	("dQPFile,m", cfg_dQPFile, string(""), "dQP file name")
[2]	306	("RDOQ", m_abUseRDOQ, std::vector<Bool>(1,true), "Enable RDOQ")
[56]	307	("TemporalLayerQPOffset_L0,-tq0", m_aiTLayerQPOffset[0], MAX_QP + 1, "QP offset of temporal layer 0")
	308	("TemporalLayerQPOffset_L1,-tq1", m_aiTLayerQPOffset[1], MAX_QP + 1, "QP offset of temporal layer 1")
	309	("TemporalLayerQPOffset_L2,-tq2", m_aiTLayerQPOffset[2], MAX_QP + 1, "QP offset of temporal layer 2")
	310	("TemporalLayerQPOffset_L3,-tq3", m_aiTLayerQPOffset[3], MAX_QP + 1, "QP offset of temporal layer 3")
	311
[2]	312
	313	/* Entropy coding parameters */
	314	("SBACRD", m_bUseSBACRD, true, "SBAC based RD estimation")
[56]	315
[2]	316	/* Deblocking filter parameters */
	317	("LoopFilterDisable", m_abLoopFilterDisable, std::vector<Bool>(1,false), "Disables LoopFilter")
	318
[56]	319	("LoopFilterOffsetInAPS", m_loopFilterOffsetInAPS, false)
	320	("LoopFilterBetaOffset_div2", m_loopFilterBetaOffsetDiv2, 0 )
	321	("LoopFilterTcOffset_div2", m_loopFilterTcOffsetDiv2, 0 )
[189]	322	#if LGE_ILLUCOMP_B0045
[296]	323	#if LGE_ILLUCOMP_DEPTH_C0046
	324	("IlluCompEnable", m_abUseIC, std::vector<Bool>(2, true), "Enable illumination compensation for inter-view prediction")
	325	#else
[189]	326	("IlluCompEnable", m_bUseIC , true , "Use illumination compensation for inter-view prediction" )
	327	#endif
[296]	328	#endif
	329	#if INTER_VIEW_VECTOR_SCALING_C0115
	330	("IVSEnable", m_bUseIVS , true , "Use inter-view vector scaling" )
	331	#endif
[128]	332	("DeblockingFilterControlPresent", m_DeblockingFilterControlPresent, true)
[56]	333
[5]	334	/* Camera Paremetes */
[2]	335	("CameraParameterFile,cpf", m_pchCameraParameterFile, (Char *) 0, "Camera Parameter File Name")
[210]	336	#if QC_MVHEVC_B0046
	337	("BaseViewCameraNumbers" , m_aiVId, std::vector<Int>(1, MAX_VIEW_NUM), "Numbers of base views")
	338	#endif
[2]	339	("BaseViewCameraNumbers" , m_pchBaseViewCameraNumbers, (Char *) 0, "Numbers of base views")
	340
[56]	341	/* View Synthesis Optimization */
[5]	342
	343	#if HHI_VSO
[2]	344	("VSOConfig", m_pchVSOConfig , (Char *) 0 , "VSO configuration")
[100]	345	("VSO", m_bUseVSO , false , "Use VSO" )
[2]	346	("VSOMode", m_uiVSOMode , (UInt) 4 , "VSO Mode")
[100]	347	("LambdaScaleVSO", m_dLambdaScaleVSO , (Double) 1 , "Lambda Scaling for VSO")
	348
[189]	349	#if HHI_VSO_LS_TABLE_M23714
[100]	350	("VSOLSTable", m_bVSOLSTable , true , "Depth QP dependent video/depth rate allocation by Lagrange multiplier" )
[21]	351	#endif
[100]	352
	353	#if SAIT_VSO_EST_A0033
	354	("UseEstimatedVSD", m_bUseEstimatedVSD , true , "Model based VSD estimation instead of rendering based for some encoder decisions" )
	355	#endif
	356	#if LGE_VSO_EARLY_SKIP_A0093
	357	("VSOEarlySkip", m_bVSOEarlySkip , true , "Early skip of VSO computation if synthesis error assumed to be zero" )
	358	#endif
	359	("ForceLambdaScaleVSO", m_bForceLambdaScaleVSO , false , "Force using Lambda Scale VSO also in non-VSO-Mode")
[5]	360	#if HHI_VSO_DIST_INT
[100]	361	("AllowNegDist", m_bAllowNegDist , true , "Allow negative Distortion in VSO")
[2]	362	#endif
[115]	363	#if LGE_WVSO_A0119
[189]	364	("WVSO", m_bUseWVSO , true , "Use depth fidelity term for VSO" )
[120]	365	("VSOWeight", m_iVSOWeight , 10 , "Synthesized View Distortion Change weight" )
	366	("VSDWeight", m_iVSDWeight , 1 , "View Synthesis Distortion estimate weight" )
	367	("DWeight", m_iDWeight , 1 , "Depth Distortion weight" )
[115]	368	#endif
[2]	369
[332]	370	#if H3D_QTL
[189]	371	("QTLPC", m_bUseQTLPC , true , "Use depth Quadtree Limitation + Predictive Coding" )
[5]	372	#endif
[2]	373
[115]	374	#endif
	375
[56]	376	#if DEPTH_MAP_GENERATION
	377	("PredDepthMapGen", m_uiPredDepthMapGeneration, (UInt)0, "generation of prediction depth maps for motion data prediction" )
	378	#endif
[296]	379	#if H3D_IVMP
[56]	380	("MultiviewMvPred", m_uiMultiviewMvPredMode, (UInt)0, "usage of predicted depth maps" )
	381	("MultiviewMvRegMode", m_uiMultiviewMvRegMode, (UInt)0, "regularization mode for multiview motion vectors" )
	382	("MultiviewMvRegLambdaScale", m_dMultiviewMvRegLambdaScale, (Double)0, "lambda scale for multiview motion vector regularization" )
	383	#endif
[296]	384	#if H3D_IVRP
[443]	385	#if QC_ARP_D0177
	386	("MultiviewResPred", m_nUseAdvResPred, (UInt)0, "usage of Advanced residual prediction" )
	387	#else
[56]	388	("MultiviewResPred", m_uiMultiviewResPredMode, (UInt)0, "usage of inter-view residual prediction" )
	389	#endif
[443]	390	#endif
	391	#if MTK_D0156
	392	("UseVSPCompensation", m_bUseVSPCompensation, true, "Depth dependent tools: BVSP" )
	393	("UseDVPRefine", m_bUseDVPRefine, true, "Depth dependent tools: DoNBDV" )
	394	#endif
[56]	395
[2]	396	/* Coding tools */
	397	("LMChroma", m_bUseLMChroma, true, "intra chroma prediction based on recontructed luma")
	398
	399	("ALF", m_abUseALF, std::vector<Bool>(1,true), "Enables ALF")
	400	("SAO", m_abUseSAO, std::vector<Bool>(1, true), "SAO")
[56]	401	("MaxNumOffsetsPerPic", m_maxNumOffsetsPerPic, 2048, "2048: default")
[443]	402	#if LGE_SAO_MIGRATION_D0091
	403	("SAOLcuBoundary", m_saoLcuBoundary, false, "0: right/bottom LCU boundary areas skipped from SAO parameter estimation, 1: non-deblocked pixels are used for those areas")
	404	("SAOLcuBasedOptimization", m_saoLcuBasedOptimization, true, "0: SAO picture-based optimization, 1: SAO LCU-based optimization ")
	405	#else
[56]	406	("SAOInterleaving", m_saoInterleavingFlag, false, "0: SAO Picture Mode, 1: SAO Interleaving ")
[443]	407	#endif
[2]	408
	409	("ALFEncodePassReduction", m_iALFEncodePassReduction, 0, "0:Original 16-pass, 1: 1-pass, 2: 2-pass encoding")
[56]	410
	411	("ALFMaxNumFilter,-ALFMNF", m_iALFMaxNumberFilters, 16, "16: No Constrained, 1-15: Constrained max number of filter")
	412	("ALFParamInSlice", m_bALFParamInSlice, false, "ALF parameters in 0: APS, 1: slice header")
	413	("ALFPicBasedEncode", m_bALFPicBasedEncode, true, "ALF picture-based encoding 0: false, 1: true")
	414
[2]	415	("SliceMode", m_iSliceMode, 0, "0: Disable all Recon slice limits, 1: Enforce max # of LCUs, 2: Enforce max # of bytes")
	416	("SliceArgument", m_iSliceArgument, 0, "if SliceMode==1 SliceArgument represents max # of LCUs. if SliceMode==2 SliceArgument represents max # of bytes.")
	417	("EntropySliceMode", m_iEntropySliceMode, 0, "0: Disable all entropy slice limits, 1: Enforce max # of LCUs, 2: Enforce constraint based entropy slices")
	418	("EntropySliceArgument", m_iEntropySliceArgument,0, "if EntropySliceMode==1 SliceArgument represents max # of LCUs. if EntropySliceMode==2 EntropySliceArgument represents max # of bins.")
[56]	419	("SliceGranularity", m_iSliceGranularity, 0, "0: Slices always end at LCU borders. 1-3: slices may end at a depth of 1-3 below LCU level.")
[2]	420	("LFCrossSliceBoundaryFlag", m_bLFCrossSliceBoundaryFlag, true)
[56]	421
	422	("ConstrainedIntraPred", m_bUseConstrainedIntraPred, false, "Constrained Intra Prediction")
	423	("PCMEnabledFlag", m_usePCM , false)
	424	("PCMLog2MaxSize", m_pcmLog2MaxSize, 5u)
	425	("PCMLog2MinSize", m_uiPCMLog2MinSize, 3u)
	426
	427	("PCMInputBitDepthFlag", m_bPCMInputBitDepthFlag, true)
	428	("PCMFilterDisableFlag", m_bPCMFilterDisableFlag, false)
	429	#if LOSSLESS_CODING
	430	("LosslessCuEnabled", m_useLossless, false)
[2]	431	#endif
[56]	432	("weighted_pred_flag,-wpP", m_bUseWeightPred, false, "weighted prediction flag (P-Slices)")
	433	("weighted_bipred_idc,-wpBidc", m_uiBiPredIdc, 0u, "weighted bipred idc (B-Slices)")
	434	("TileInfoPresentFlag", m_iColumnRowInfoPresent, 1, "0: tiles parameters are NOT present in the PPS. 1: tiles parameters are present in the PPS")
	435	("UniformSpacingIdc", m_iUniformSpacingIdr, 0, "Indicates if the column and row boundaries are distributed uniformly")
	436	("NumTileColumnsMinus1", m_iNumColumnsMinus1, 0, "Number of columns in a picture minus 1")
	437	("ColumnWidthArray", cfg_ColumnWidth, string(""), "Array containing ColumnWidth values in units of LCU")
	438	("NumTileRowsMinus1", m_iNumRowsMinus1, 0, "Number of rows in a picture minus 1")
	439	("RowHeightArray", cfg_RowHeight, string(""), "Array containing RowHeight values in units of LCU")
	440	("TileLocationInSliceHeaderFlag", m_iTileLocationInSliceHeaderFlag, 0, "0: Disable transmission of tile location in slice header. 1: Transmit tile locations in slice header.")
	441	("TileMarkerFlag", m_iTileMarkerFlag, 0, "0: Disable transmission of lightweight tile marker. 1: Transmit light weight tile marker.")
	442	("MaxTileMarkerEntryPoints", m_iMaxTileMarkerEntryPoints, 4, "Maximum number of uniformly-spaced tile entry points (using light weigh tile markers). Default=4. If number of tiles < MaxTileMarkerEntryPoints then all tiles have entry points.")
	443	("TileControlPresentFlag", m_iTileBehaviorControlPresentFlag, 1, "0: tiles behavior control parameters are NOT present in the PPS. 1: tiles behavior control parameters are present in the PPS")
	444	("LFCrossTileBoundaryFlag", m_bLFCrossTileBoundaryFlag, true, "1: cross-tile-boundary loop filtering. 0:non-cross-tile-boundary loop filtering")
	445	("WaveFrontSynchro", m_iWaveFrontSynchro, 0, "0: no synchro; 1 synchro with TR; 2 TRR etc")
	446	("WaveFrontFlush", m_iWaveFrontFlush, 0, "Flush and terminate CABAC coding for each LCU line")
	447	("WaveFrontSubstreams", m_iWaveFrontSubstreams, 1, "# coded substreams wanted; per tile if TileBoundaryIndependenceIdc is 1, otherwise per frame")
	448	("ScalingList", m_useScalingListId, 0, "0: no scaling list, 1: default scaling lists, 2: scaling lists specified in ScalingListFile")
	449	("ScalingListFile", cfg_ScalingListFile, string(""), "Scaling list file name")
	450	("SignHideFlag,-SBH", m_signHideFlag, 1)
	451	("SignHideThreshold,-TSIG", m_signHidingThreshold, 4)
	452	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
	453	("DMM", m_bUseDMM, false, "depth model modes flag")
	454	#endif
	455
[2]	456	/* Misc. */
[56]	457	("SEIpictureDigest", m_pictureDigestEnabled, true, "Control generation of picture_digest SEI messages\n"
[2]	458	"\t1: use MD5\n"
	459	"\t0: disable")
	460
[189]	461	#if TMVP_DEPTH_SWITCH
	462	("TMVP", m_enableTMVP, std::vector<Bool>(1,true), "Enable TMVP" )
	463	#else
[56]	464	("TMVP", m_enableTMVP, true, "Enable TMVP" )
[189]	465	#endif
[2]	466
[56]	467	("FEN", m_bUseFastEnc, false, "fast encoder setting")
	468	("ECU", m_bUseEarlyCU, false, "Early CU setting")
	469	("FDM", m_useFastDecisionForMerge, true, "Fast decision for Merge RD Cost")
	470	("CFM", m_bUseCbfFastMode, false, "Cbf fast mode setting")
[5]	471	#if HHI_INTERVIEW_SKIP
[56]	472	("InterViewSkip", m_bInterViewSkip, false, "usage of interview skip" )
[5]	473	#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
[2]	474	("InterViewSkipLambdaScale", m_dInterViewSkipLambdaScale, (Double)8, "lambda scale for interview skip" )
	475	#endif
	476	#endif
	477	/* Compatability with old style -1 FOO or -0 FOO options. */
	478	("1", doOldStyleCmdlineOn, "turn option <name> on")
	479	("0", doOldStyleCmdlineOff, "turn option <name> off")
[56]	480	#if HHI_MPI
	481	("MVI", m_bUseMVI, false, "use motion vector inheritance for depth map coding")
	482	#endif
[189]	483	#if RWTH_SDC_DLT_B0036
	484	("DLT", m_bUseDLT, true, "use depth lookup table for depth map coding")
	485	("SDC", m_bUseSDC, true, "use simplified depth coding tree")
	486	#endif
[2]	487	;
[56]	488
	489	// parse coding structure
	490	for( Int k = 0; k < MAX_VIEW_NUM; k++ )
	491	{
	492	if( k == 0 )
	493	{
	494	for( Int i = 1; i < MAX_GOP + 1; i++ )
	495	{
	496	std::ostringstream cOSS;
	497	cOSS<<"Frame"<<i;
	498	opts.addOptions()( cOSS.str(), m_GOPListsMvc[k][i-1], GOPEntryMvc() );
	499	}
	500	}
	501	else
	502	{
	503	std::ostringstream cOSS1;
	504	cOSS1<<"FrameI"<<"_v"<<k;
	505	opts.addOptions()(cOSS1.str(), m_GOPListsMvc[k][MAX_GOP], GOPEntryMvc());
[2]	506
[56]	507	for( Int i = 1; i < MAX_GOP + 1; i++ )
	508	{
	509	std::ostringstream cOSS2;
	510	cOSS2<<"Frame"<<i<<"_v"<<k;
	511	opts.addOptions()(cOSS2.str(), m_GOPListsMvc[k][i-1], GOPEntryMvc());
	512	}
	513	}
	514	}
	515
[2]	516	po::setDefaults(opts);
	517	const list<const char>& argv_unhandled = po::scanArgv(opts, argc, (const char*) argv);
	518
	519	for (list<const char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
	520	{
	521	fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
	522	}
[56]	523
[2]	524	if (argc == 1 \|\| do_help)
	525	{
	526	/* argc == 1: no options have been specified */
	527	po::doHelp(cout, opts);
	528	xPrintUsage();
	529	return false;
	530	}
[56]	531
[2]	532	/*
	533	* Set any derived parameters
	534	*/
	535	/* convert std::string to c string for compatability */
	536	m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
	537	m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());
[210]	538	#if FLEX_CODING_ORDER_M23723
	539	m_pchMVCJointCodingOrder= cfg_JointCodingOrdering.empty()?NULL:strdup(cfg_JointCodingOrdering.c_str());
	540	// If flexible order is enabled and if depth comes before the texture for a view, disable VSO
	541	#if HHI_VSO && DISABLE_FCO_FOR_VSO
	542	Bool depthComesFirst = false;
	543	int iter = 0;
	544	if ( m_b3DVFlexOrder )
	545	{
	546	for(Int iViewIdx=0; iViewIdx<m_iNumberOfViews; iViewIdx++)
	547	{
	548	iter = 0;
	549	for ( Int ii=1; ii<12; ii+=2 )
	550	{
	551	Int iViewIdxCfg = (Int)(m_pchMVCJointCodingOrder[ii]-'0');
	552	if ( iViewIdxCfg == iViewIdx )
	553	{
	554	iter ++;
	555	if ( m_pchMVCJointCodingOrder[ii-1]=='D' ) // depth comes first for this view
	556	{
	557	if(iter == 1)
	558	{
	559	depthComesFirst = true;
	560	break;
	561	}
	562	}
	563	else
	564	{
	565	assert(m_pchMVCJointCodingOrder[ii-1]=='T');
	566	}
	567	}
	568	}
	569	}
	570	}
	571	if (depthComesFirst)
	572	{
	573	m_bUseVSO = false;
	574	}
	575	#endif
	576	#endif
[56]	577	m_pchColumnWidth = cfg_ColumnWidth.empty() ? NULL: strdup(cfg_ColumnWidth.c_str());
	578	m_pchRowHeight = cfg_RowHeight.empty() ? NULL : strdup(cfg_RowHeight.c_str());
	579	m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str());
	580
[2]	581	if ( m_bUsingDepthMaps )
	582	{
	583	for(Int i = 0; i < m_pchDepthReconFileList.size() ; i++)
	584	{
	585	if ((m_pchDepthInputFileList[i] != NULL) && (m_pchReconFileList[i] != NULL) && (i < m_iNumberOfViews) )
	586	{
	587	if (m_pchDepthReconFileList[i] == NULL )
	588	{
	589	xAppendToFileNameEnd( m_pchReconFileList[i], "_depth", m_pchDepthReconFileList[i] );
	590	}
	591	}
	592	else
	593	{
	594	m_pchDepthReconFileList[i] = NULL;
	595	}
	596	};
	597	}
[56]	598	if ( m_adQP.size() < 2 )
	599	{
	600	m_adQP.push_back( m_adQP[0] );
	601	};
	602	for (UInt uiK = 0; uiK < m_adQP.size(); uiK++)
	603	{
	604	m_aiQP.push_back( (Int)( m_adQP[uiK] ) );
	605	}
[2]	606
[56]	607	switch (m_croppingMode)
[2]	608	{
[56]	609	case 0:
	610	{
	611	// no cropping or padding
	612	m_cropLeft = m_cropRight = m_cropTop = m_cropBottom = 0;
	613	m_aiPad[1] = m_aiPad[0] = 0;
	614	break;
	615	}
	616	case 1:
	617	{
	618	// automatic padding to minimum CU size
	619	Int minCuSize = m_uiMaxCUHeight >> (m_uiMaxCUDepth - 1);
	620	if (m_iSourceWidth % minCuSize)
	621	{
	622	m_aiPad[0] = m_cropRight = ((m_iSourceWidth / minCuSize) + 1) * minCuSize - m_iSourceWidth;
	623	m_iSourceWidth += m_cropRight;
	624	}
	625	if (m_iSourceHeight % minCuSize)
	626	{
	627	m_aiPad[1] = m_cropBottom = ((m_iSourceHeight / minCuSize) + 1) * minCuSize - m_iSourceHeight;
	628	m_iSourceHeight += m_cropBottom;
	629	}
	630	break;
	631	}
	632	case 2:
	633	{
	634	//padding
	635	m_iSourceWidth += m_aiPad[0];
	636	m_iSourceHeight += m_aiPad[1];
	637	m_cropRight = m_aiPad[0];
	638	m_cropBottom = m_aiPad[1];
	639	break;
	640	}
	641	case 3:
	642	{
	643	// cropping
	644	if ((m_cropLeft == 0) && (m_cropRight == 0) && (m_cropTop == 0) && (m_cropBottom == 0))
	645	{
	646	fprintf(stderr, "Warning: Cropping enabled, but all cropping parameters set to zero\n");
	647	}
	648	if ((m_aiPad[1] != 0) \|\| (m_aiPad[0]!=0))
	649	{
	650	fprintf(stderr, "Warning: Cropping enabled, padding parameters will be ignored\n");
	651	}
	652	m_aiPad[1] = m_aiPad[0] = 0;
	653	break;
	654	}
[2]	655	}
[56]	656
	657	// allocate slice-based dQP values
	658	m_aidQP = new Int[ m_iFrameToBeEncoded + m_iGOPSize + 1 ];
	659	m_aidQPdepth = new Int[ m_iFrameToBeEncoded + m_iGOPSize + 1 ];
	660	::memset( m_aidQP, 0, sizeof(Int)*( m_iFrameToBeEncoded + m_iGOPSize + 1 ) );
	661	::memset( m_aidQPdepth, 0, sizeof(Int)*( m_iFrameToBeEncoded + m_iGOPSize + 1 ) );
	662
	663	// handling of floating-point QP values
	664	// if QP is not integer, sequence is split into two sections having QP and QP+1
	665	m_aiQP[0] = (Int)( m_adQP[0] );
	666	if ( m_aiQP[0] < m_adQP[0] )
	667	{
	668	Int iSwitchPOC = (Int)( m_iFrameToBeEncoded - (m_adQP[0] - m_aiQP[0])*m_iFrameToBeEncoded + 0.5 );
	669
	670	iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
	671	for ( Int i=iSwitchPOC; i<m_iFrameToBeEncoded + m_iGOPSize + 1; i++ )
	672	{
	673	m_aidQP[i] = 1;
	674	}
	675	}
[2]	676
[56]	677	m_aiQP[1] = (Int)( m_adQP[1] );
	678	if ( m_aiQP[1] < m_adQP[1] )
[2]	679	{
[56]	680	Int iSwitchPOC = (Int)( m_iFrameToBeEncoded - (m_adQP[1] - m_aiQP[1])*m_iFrameToBeEncoded + 0.5 );
	681
	682	iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
	683	for ( Int i=iSwitchPOC; i<m_iFrameToBeEncoded + m_iGOPSize + 1; i++ )
	684	{
	685	m_aidQPdepth[i] = 1;
	686	}
	687	}
	688
	689	// reading external dQP description from file
	690	if ( m_pchdQPFile )
[2]	691	{
[56]	692	FILE* fpt=fopen( m_pchdQPFile, "r" );
	693	if ( fpt )
	694	{
	695	Int iValue;
	696	Int iPOC = 0;
	697	while ( iPOC < m_iFrameToBeEncoded )
	698	{
	699	if ( fscanf(fpt, "%d", &iValue ) == EOF ) break;
	700	m_aidQP[ iPOC ] = iValue;
	701	iPOC++;
	702	}
	703	fclose(fpt);
	704	}
[2]	705	}
	706
[5]	707	#if HHI_VSO
[2]	708	m_bUseVSO = m_bUseVSO && m_bUsingDepthMaps && (m_uiVSOMode != 0);
[5]	709	#endif
[2]	710
[115]	711	#if LGE_WVSO_A0119
[120]	712	m_bUseWVSO = m_bUseVSO && m_bUseWVSO && m_bUsingDepthMaps;
[115]	713	#endif
[2]	714	xCleanUpVectors();
	715
[189]	716
	717	#if TMVP_DEPTH_SWITCH
	718	if ( m_enableTMVP.size() < 2)
	719	{
	720	m_enableTMVP.push_back( m_enableTMVP[0] );
	721	}
	722	#endif
	723
	724
[5]	725	#if HHI_VSO
[2]	726	if ( m_abUseALF .size() < 2)
	727	m_abUseALF .push_back( m_bUseVSO ? false : m_abUseALF[0] );
	728
	729	if ( m_abUseRDOQ.size() < 2)
[5]	730	m_abUseRDOQ.push_back( m_bUseVSO ? true : m_abUseRDOQ[0] );
[2]	731
	732	if ( m_abLoopFilterDisable.size() < 2)
	733	m_abLoopFilterDisable.push_back( m_bUseVSO ? true : m_abLoopFilterDisable[0] );
	734
	735	if (m_abUseSAO.size() < 2)
	736	m_abUseSAO.push_back ( m_bUseVSO ? false : m_abUseSAO[0] );
[5]	737	#else
	738	if ( m_abUseALF .size() < 2)
	739	m_abUseALF .push_back( m_abUseALF[0] );
[2]	740
[5]	741	if ( m_abUseRDOQ.size() < 2)
	742	m_abUseRDOQ.push_back( m_abUseRDOQ[0] );
	743
	744	if ( m_abLoopFilterDisable.size() < 2)
	745	m_abLoopFilterDisable.push_back( m_abLoopFilterDisable[0] );
	746
	747	if (m_abUseSAO.size() < 2)
	748	m_abUseSAO.push_back ( m_abUseSAO[0] );
	749	#endif
	750
	751	#if HHI_VSO
[21]	752
[189]	753	#if HHI_VSO_LS_TABLE_M23714
[21]	754	// Q&D
	755	Double adLambdaScaleTable[] =
	756	{ 0.031250, 0.031639, 0.032029, 0.032418, 0.032808, 0.033197, 0.033586, 0.033976, 0.034365, 0.034755,
	757	0.035144, 0.035533, 0.035923, 0.036312, 0.036702, 0.037091, 0.037480, 0.037870, 0.038259, 0.038648,
	758	0.039038, 0.039427, 0.039817, 0.040206, 0.040595, 0.040985, 0.041374, 0.041764, 0.042153, 0.042542,
	759	0.042932, 0.043321, 0.043711, 0.044100, 0.044194, 0.053033, 0.061872, 0.070711, 0.079550, 0.088388,
	760	0.117851, 0.147314, 0.176777, 0.235702, 0.294628, 0.353553, 0.471405, 0.589256, 0.707107, 0.707100,
	761	0.753550, 0.800000
	762	};
[100]	763	if ( m_bVSOLSTable )
	764	{
	765	AOT( (m_aiQP[1] < 0) \|\| (m_aiQP[1] > 51));
	766	m_dLambdaScaleVSO *= adLambdaScaleTable[m_aiQP[1]];
	767	}
[5]	768	#endif
[21]	769	#endif
[2]	770
[56]	771	// set global variables
[2]	772	xSetGlobal();
	773
	774	// read and check camera parameters
[5]	775	#if HHI_VSO
[2]	776	if ( m_bUseVSO && m_uiVSOMode == 4)
	777	{
	778	m_cRenModStrParser.setString( m_iNumberOfViews, m_pchVSOConfig );
	779	m_cCameraData .init ( (UInt)m_iNumberOfViews,
	780	m_uiInputBitDepth,
	781	(UInt)m_iCodedCamParPrecision,
	782	m_FrameSkip,
	783	(UInt)m_iFrameToBeEncoded,
	784	m_pchCameraParameterFile,
	785	m_pchBaseViewCameraNumbers,
	786	NULL,
	787	m_cRenModStrParser.getSynthViews(),
	788	LOG2_DISP_PREC_LUT );
	789	}
	790	else if ( m_bUseVSO && m_uiVSOMode != 4 )
	791	{
	792	m_cCameraData .init ( (UInt)m_iNumberOfViews,
	793	m_uiInputBitDepth,
	794	(UInt)m_iCodedCamParPrecision,
	795	m_FrameSkip,
	796	(UInt)m_iFrameToBeEncoded,
	797	m_pchCameraParameterFile,
	798	m_pchBaseViewCameraNumbers,
	799	m_pchVSOConfig,
	800	NULL,
	801	LOG2_DISP_PREC_LUT );
	802	}
	803	else
	804	{
	805	m_cCameraData .init ( (UInt)m_iNumberOfViews,
	806	m_uiInputBitDepth,
	807	(UInt)m_iCodedCamParPrecision,
	808	m_FrameSkip,
	809	(UInt)m_iFrameToBeEncoded,
	810	m_pchCameraParameterFile,
	811	m_pchBaseViewCameraNumbers,
	812	NULL,
	813	NULL,
	814	LOG2_DISP_PREC_LUT );
[5]	815	}
	816	#else
[210]	817	#if !QC_MVHEVC_B0046
[5]	818	m_cCameraData .init ( (UInt)m_iNumberOfViews,
	819	m_uiInputBitDepth,
	820	(UInt)m_iCodedCamParPrecision,
	821	m_FrameSkip,
	822	(UInt)m_iFrameToBeEncoded,
	823	m_pchCameraParameterFile,
	824	m_pchBaseViewCameraNumbers,
	825	NULL,
	826	NULL,
	827	LOG2_DISP_PREC_LUT );
	828	#endif
[210]	829	#endif
[2]	830
[5]	831
[2]	832	// check validity of input parameters
	833	xCheckParameter();
[210]	834	#if !QC_MVHEVC_B0046
[2]	835	m_cCameraData.check( false, true );
[210]	836	#endif
[2]	837	// print-out parameters
	838	xPrintParameter();
[56]	839
[2]	840	return true;
	841	}
	842
	843	// ====================================================================================================================
	844	// Private member functions
	845	// ====================================================================================================================
	846
	847	Bool confirmPara(Bool bflag, const char* message);
	848
	849	Void TAppEncCfg::xCheckParameter()
	850	{
	851	bool check_failed = false; /* abort if there is a fatal configuration problem */
	852	#define xConfirmPara(a,b) check_failed \|= confirmPara(a,b)
	853	// check range of parameters
	854	xConfirmPara( m_uiInputBitDepth < 8, "InputBitDepth must be at least 8" );
	855	xConfirmPara( m_iFrameRate <= 0, "Frame rate must be more than 1" );
[56]	856	xConfirmPara( m_iFrameToBeEncoded <= 0, "Total Number Of Frames encoded must be more than 0" );
	857	xConfirmPara( m_iGOPSize < 1 , "GOP Size must be greater or equal to 1" );
	858	xConfirmPara( m_iGOPSize > 1 && m_iGOPSize % 2, "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
	859	xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) \|\| m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
[2]	860	xConfirmPara( m_iDecodingRefreshType < 0 \|\| m_iDecodingRefreshType > 2, "Decoding Refresh Type must be equal to 0, 1 or 2" );
[56]	861	xConfirmPara( m_aiQP[0] < -6 * ((Int)m_uiInternalBitDepth - 8) \|\| m_aiQP[0] > 51, "QP exceeds supported range (-QpBDOffsety to 51)" );
	862	if ( m_aiQP.size() >= 2 )
	863	{
	864	xConfirmPara( m_aiQP[1] < -6 * ((Int)m_uiInternalBitDepth - 8) \|\| m_aiQP[1] > 51, "QP depth exceeds supported range (-QpBDOffsety to 51)" );
	865	}
[2]	866	xConfirmPara( m_iALFEncodePassReduction < 0 \|\| m_iALFEncodePassReduction > 2, "ALFEncodePassReduction must be equal to 0, 1 or 2");
[56]	867	xConfirmPara( m_iALFMaxNumberFilters < 1, "ALFMaxNumFilter should be larger than 1");
	868	xConfirmPara( m_loopFilterBetaOffsetDiv2 < -13 \|\| m_loopFilterBetaOffsetDiv2 > 13, "Loop Filter Beta Offset div. 2 exceeds supported range (-13 to 13)");
	869	xConfirmPara( m_loopFilterTcOffsetDiv2 < -13 \|\| m_loopFilterTcOffsetDiv2 > 13, "Loop Filter Tc Offset div. 2 exceeds supported range (-13 to 13)");
[2]	870	xConfirmPara( m_iFastSearch < 0 \|\| m_iFastSearch > 2, "Fast Search Mode is not supported value (0:Full search 1:Diamond 2:PMVFAST)" );
	871	xConfirmPara( m_iSearchRange < 0 , "Search Range must be more than 0" );
[210]	872	#if DV_V_RESTRICTION_B0037
	873	xConfirmPara( m_iVerticalDisparitySearchRange <= 0 , "Vertical Disparity Search Range must be more than 0" );
	874	#endif
[2]	875	xConfirmPara( m_bipredSearchRange < 0 , "Search Range must be more than 0" );
	876	xConfirmPara( m_iMaxDeltaQP > 7, "Absolute Delta QP exceeds supported range (0 to 7)" );
[56]	877	xConfirmPara( m_iMaxCuDQPDepth > m_uiMaxCUDepth - 1, "Absolute depth for a minimum CuDQP exceeds maximum coding unit depth" );
	878
	879	xConfirmPara( m_iChromaQpOffset < -12, "Min. Chroma Qp Offset is -12" );
	880	xConfirmPara( m_iChromaQpOffset > 12, "Max. Chroma Qp Offset is 12" );
	881	xConfirmPara( m_iChromaQpOffset2nd < -12, "Min. Chroma Qp Offset 2nd is -12" );
	882	xConfirmPara( m_iChromaQpOffset2nd > 12, "Max. Chroma Qp Offset 2nd is 12" );
	883
	884	xConfirmPara( m_iQPAdaptationRange <= 0, "QP Adaptation Range must be more than 0" );
	885	if (m_iDecodingRefreshType == 2)
	886	{
	887	xConfirmPara( m_iIntraPeriod > 0 && m_iIntraPeriod <= m_iGOPSize , "Intra period must be larger than GOP size for periodic IDR pictures");
	888	}
[2]	889	xConfirmPara( (m_uiMaxCUWidth >> m_uiMaxCUDepth) < 4, "Minimum partition width size should be larger than or equal to 8");
	890	xConfirmPara( (m_uiMaxCUHeight >> m_uiMaxCUDepth) < 4, "Minimum partition height size should be larger than or equal to 8");
	891	xConfirmPara( m_uiMaxCUWidth < 16, "Maximum partition width size should be larger than or equal to 16");
	892	xConfirmPara( m_uiMaxCUHeight < 16, "Maximum partition height size should be larger than or equal to 16");
[56]	893	xConfirmPara( (m_iSourceWidth % (m_uiMaxCUWidth >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame width must be a multiple of the minimum CU size");
	894	xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame height must be a multiple of the minimum CU size");
	895
[2]	896	xConfirmPara( m_uiQuadtreeTULog2MinSize < 2, "QuadtreeTULog2MinSize must be 2 or greater.");
	897	xConfirmPara( m_uiQuadtreeTULog2MinSize > 5, "QuadtreeTULog2MinSize must be 5 or smaller.");
	898	xConfirmPara( m_uiQuadtreeTULog2MaxSize < 2, "QuadtreeTULog2MaxSize must be 2 or greater.");
	899	xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5, "QuadtreeTULog2MaxSize must be 5 or smaller.");
	900	xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize, "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize.");
	901	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
	902	xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUHeight>>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS
	903	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUWidth >> m_uiMaxCUDepth ), "Minimum CU width must be greater than minimum transform size." );
	904	xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." );
	905	xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1, "QuadtreeTUMaxDepthInter must be greater than or equal to 1" );
	906	xConfirmPara( m_uiQuadtreeTUMaxDepthInter > m_uiQuadtreeTULog2MaxSize - m_uiQuadtreeTULog2MinSize + 1, "QuadtreeTUMaxDepthInter must be less than or equal to the difference between QuadtreeTULog2MaxSize and QuadtreeTULog2MinSize plus 1" );
	907	xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1, "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" );
	908	xConfirmPara( m_uiQuadtreeTUMaxDepthIntra > m_uiQuadtreeTULog2MaxSize - m_uiQuadtreeTULog2MinSize + 1, "QuadtreeTUMaxDepthIntra must be less than or equal to the difference between QuadtreeTULog2MaxSize and QuadtreeTULog2MinSize plus 1" );
	909
[56]	910	xConfirmPara( m_iNumberOfViews > MAX_VIEW_NUM , "NumberOfViews must be less than or equal to MAX_VIEW_NUM");
[2]	911	xConfirmPara ( Int( m_pchInputFileList.size() ) < m_iNumberOfViews, "Number of InputFiles must be greater than or equal to NumberOfViews" );
	912	xConfirmPara ( Int( m_pchReconFileList.size() ) < m_iNumberOfViews, "Number of ReconFiles must be greater than or equal to NumberOfViews" );
	913	xConfirmPara ( m_iCodedCamParPrecision < 0 \|\| m_iCodedCamParPrecision > 5, "CodedCamParsPrecision must be in range of 0..5" );
[56]	914	#if HHI_INTERVIEW_SKIP
	915	xConfirmPara ( m_bInterViewSkip && !m_bUsingDepthMaps, "RenderingSkipMode requires CodeDepthMaps = 1" );
	916	#endif
[5]	917	#if DEPTH_MAP_GENERATION
[21]	918	xConfirmPara ( m_uiPredDepthMapGeneration > 2, "PredDepthMapGen must be less than or equal to 2" );
[2]	919	xConfirmPara ( m_uiPredDepthMapGeneration >= 2 && !m_bUsingDepthMaps, "PredDepthMapGen >= 2 requires CodeDepthMaps = 1" );
[5]	920	#endif
[296]	921	#if H3D_IVMP
[2]	922	xConfirmPara ( m_uiMultiviewMvPredMode > 7, "MultiviewMvPred must be less than or equal to 7" );
	923	xConfirmPara ( m_uiMultiviewMvPredMode > 0 && m_uiPredDepthMapGeneration == 0 , "MultiviewMvPred > 0 requires PredDepthMapGen > 0" );
	924	xConfirmPara ( m_uiMultiviewMvRegMode > 1, "MultiviewMvRegMode must be less than or equal to 1" );
	925	xConfirmPara ( m_dMultiviewMvRegLambdaScale < 0.0, "MultiviewMvRegLambdaScale must not be negative" );
	926	if( m_uiMultiviewMvRegMode )
	927	{
	928	xConfirmPara ( Int( m_pchDepthInputFileList.size() ) < m_iNumberOfViews, "MultiviewMvRegMode > 0 requires the presence of input depth maps" );
	929	}
[5]	930	#endif
[296]	931	#if H3D_IVRP
[443]	932	#if QC_ARP_D0177
	933	#if QC_ARP_WARNING_FIX
	934	xConfirmPara ( m_nUseAdvResPred > 1 , "0<=ARP<=1" );
	935	#else
	936	xConfirmPara ( m_nUseAdvResPred < 0 \|\| m_nUseAdvResPred > 1 , "0<=ARP<=1" );
	937	#endif
	938	#else
[2]	939	xConfirmPara ( m_uiMultiviewResPredMode > 1, "MultiviewResPred must be less than or equal to 1" );
	940	xConfirmPara ( m_uiMultiviewResPredMode > 0 && m_uiPredDepthMapGeneration == 0 , "MultiviewResPred > 0 requires PredDepthMapGen > 0" );
[5]	941	#endif
[443]	942	#endif
[2]	943	if( m_bUsingDepthMaps )
	944	{
	945	xConfirmPara ( Int( m_pchDepthInputFileList.size() ) < m_iNumberOfViews, "Number of DepthInputFiles must be greater than or equal to NumberOfViews" );
	946	xConfirmPara ( Int( m_pchDepthReconFileList.size() ) < m_iNumberOfViews, "Number of DepthReconFiles must be greater than or equal to NumberOfViews" );
	947
[5]	948	#if HHI_VSO
[2]	949	if( m_bUseVSO )
	950	{
	951	xConfirmPara( m_pchCameraParameterFile == 0 , "CameraParameterFile must be given");
	952	xConfirmPara( m_pchVSOConfig == 0 , "VSO Setup string must be given");
	953	xConfirmPara( m_pchBaseViewCameraNumbers == 0 , "BaseViewCameraNumbers must be given" );
	954	xConfirmPara( m_iNumberOfViews != m_cCameraData.getBaseViewNumbers().size(), "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" );
[58]	955	xConfirmPara( m_uiVSOMode > 4 , "VSO Mode must be less than 5");
[2]	956	}
[5]	957	#endif
[2]	958	}
[56]	959	#if ADAPTIVE_QP_SELECTION
	960	xConfirmPara( m_bUseAdaptQpSelect == true && m_aiQP[0] < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
	961	xConfirmPara( m_bUseAdaptQpSelect == true && m_aiQP[1] < 0, "AdaptiveQpSelection must be disabled when QP < 0.");
	962	xConfirmPara( m_bUseAdaptQpSelect == true && (m_iChromaQpOffset !=0 \|\| m_iChromaQpOffset2nd != 0 ), "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
	963	#endif
[2]	964
[56]	965	if( m_usePCM)
	966	{
	967	xConfirmPara( m_uiPCMLog2MinSize < 3, "PCMLog2MinSize must be 3 or greater.");
	968	xConfirmPara( m_uiPCMLog2MinSize > 5, "PCMLog2MinSize must be 5 or smaller.");
	969	xConfirmPara( m_pcmLog2MaxSize > 5, "PCMLog2MaxSize must be 5 or smaller.");
	970	xConfirmPara( m_pcmLog2MaxSize < m_uiPCMLog2MinSize, "PCMLog2MaxSize must be equal to or greater than m_uiPCMLog2MinSize.");
	971	}
	972
	973	xConfirmPara( m_iSliceMode < 0 \|\| m_iSliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
	974	if (m_iSliceMode!=0)
	975	{
	976	xConfirmPara( m_iSliceArgument < 1 , "SliceArgument should be larger than or equal to 1" );
	977	}
	978	if (m_iSliceMode==3)
	979	{
	980	xConfirmPara( m_iSliceGranularity > 0 , "When SliceMode == 3 is chosen, the SliceGranularity must be 0" );
	981	}
	982	xConfirmPara( m_iEntropySliceMode < 0 \|\| m_iEntropySliceMode > 2, "EntropySliceMode exceeds supported range (0 to 2)" );
	983	if (m_iEntropySliceMode!=0)
	984	{
	985	xConfirmPara( m_iEntropySliceArgument < 1 , "EntropySliceArgument should be larger than or equal to 1" );
	986	}
	987	xConfirmPara( m_iSliceGranularity >= m_uiMaxCUDepth, "SliceGranularity must be smaller than maximum cu depth");
	988	xConfirmPara( m_iSliceGranularity <0 \|\| m_iSliceGranularity > 3, "SliceGranularity exceeds supported range (0 to 3)" );
	989	xConfirmPara( m_iSliceGranularity > m_iMaxCuDQPDepth, "SliceGranularity must be smaller smaller than or equal to maximum dqp depth" );
[2]	990
[56]	991	bool tileFlag = (m_iNumColumnsMinus1 > 0 \|\| m_iNumRowsMinus1 > 0 );
	992	xConfirmPara( tileFlag && m_iEntropySliceMode, "Tile and Entropy Slice can not be applied together");
	993	xConfirmPara( tileFlag && m_iWaveFrontSynchro, "Tile and Wavefront can not be applied together");
	994	xConfirmPara( m_iWaveFrontSynchro && m_iEntropySliceMode, "Wavefront and Entropy Slice can not be applied together");
	995
[2]	996	// max CU width and height should be power of 2
	997	UInt ui = m_uiMaxCUWidth;
	998	while(ui)
	999	{
	1000	ui >>= 1;
	1001	if( (ui & 1) == 1)
	1002	xConfirmPara( ui != 1 , "Width should be 2^n");
	1003	}
	1004	ui = m_uiMaxCUHeight;
	1005	while(ui)
	1006	{
	1007	ui >>= 1;
	1008	if( (ui & 1) == 1)
	1009	xConfirmPara( ui != 1 , "Height should be 2^n");
	1010	}
[56]	1011
	1012	xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
	1013	xConfirmPara( m_iWaveFrontFlush < 0, "WaveFrontFlush cannot be negative" );
	1014	xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );
	1015	xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );
[2]	1016
[56]	1017	#undef xConfirmPara
	1018	if (check_failed)
[2]	1019	{
[56]	1020	exit(EXIT_FAILURE);
[2]	1021	}
	1022
[56]	1023	xCheckCodingStructureMvc();
	1024	}
	1025
	1026	Void TAppEncCfg::xCheckCodingStructureMvc()
	1027	{
	1028	bool check_failed = false; /* abort if there is a fatal configuration problem */
	1029	#define xConfirmPara(a,b) check_failed \|= confirmPara(a,b)
	1030
	1031	// validate that POC of same frame is identical across multiple views
	1032	Bool bErrorMvePoc = false;
	1033	if( m_iNumberOfViews > 1 )
	1034	{
	1035	for( Int k = 1; k < m_iNumberOfViews; k++ )
	1036	{
	1037	for( Int i = 0; i < MAX_GOP; i++ )
	1038	{
	1039	if( m_GOPListsMvc[k][i].m_POC != m_GOPListsMvc[0][i].m_POC )
	1040	{
	1041	printf( "\nError: Frame%d_v%d POC %d is not identical to Frame%d POC\n", i, k, m_GOPListsMvc[k][i].m_POC, i );
	1042	bErrorMvePoc = true;
	1043	}
	1044	}
	1045	}
	1046	}
	1047	xConfirmPara( bErrorMvePoc, "Invalid inter-view POC structure given" );
	1048
	1049	// validate that baseview has no inter-view refs
	1050	Bool bErrorIvpBase = false;
	1051	for( Int i = 0; i < MAX_GOP; i++ )
	1052	{
	1053	if( m_GOPListsMvc[0][i].m_numInterViewRefPics != 0 )
	1054	{
	1055	printf( "\nError: Frame%d inter_view refs not available in view 0\n", i );
	1056	bErrorIvpBase = true;
	1057	}
	1058	}
	1059	xConfirmPara( bErrorIvpBase, "Inter-view refs not possible in base view" );
	1060
	1061	// validate inter-view refs
	1062	Bool bErrorIvpEnhV = false;
	1063	if( m_iNumberOfViews > 1 )
	1064	{
	1065	for( Int k = 1; k < m_iNumberOfViews; k++ )
	1066	{
	1067	for( Int i = 0; i < MAX_GOP+1; i++ )
	1068	{
	1069	for( Int j = 0; j < m_GOPListsMvc[k][i].m_numInterViewRefPics; j++ )
	1070	{
	1071	Int iAbsViewId = m_GOPListsMvc[k][i].m_interViewRefs[j] + k;
	1072	if( iAbsViewId < 0 \|\| iAbsViewId >= k )
	1073	{
	1074	printf( "\nError: inter-view ref pic %d is not available for Frame%d_v%d\n", m_GOPListsMvc[k][i].m_interViewRefs[j], i, k );
	1075	bErrorIvpEnhV = true;
	1076	}
	1077	if( m_GOPListsMvc[k][i].m_interViewRefPosL0[j] < 0 \|\| m_GOPListsMvc[k][i].m_interViewRefPosL0[j] > m_GOPListsMvc[k][i].m_numRefPicsActive )
	1078	{
	1079	printf( "\nError: inter-view ref pos %d on L0 is not available for Frame%d_v%d\n", m_GOPListsMvc[k][i].m_interViewRefPosL0[j], i, k );
	1080	bErrorIvpEnhV = true;
	1081	}
	1082	if( m_GOPListsMvc[k][i].m_interViewRefPosL1[j] < 0 \|\| m_GOPListsMvc[k][i].m_interViewRefPosL1[j] > m_GOPListsMvc[k][i].m_numRefPicsActive )
	1083	{
	1084	printf( "\nError: inter-view ref pos %d on L1 is not available for Frame%d_v%d\n", m_GOPListsMvc[k][i].m_interViewRefPosL1[j], i, k );
	1085	bErrorIvpEnhV = true;
	1086	}
	1087	}
	1088	if( i == MAX_GOP ) // inter-view refs at I pic position in base view
	1089	{
	1090	if( m_GOPListsMvc[k][MAX_GOP].m_sliceType != 'B' && m_GOPListsMvc[k][MAX_GOP].m_sliceType != 'P' && m_GOPListsMvc[k][MAX_GOP].m_sliceType != 'I' )
	1091	{
	1092	printf( "\nError: slice type of FrameI_v%d must be equal to B or P or I\n", k );
	1093	bErrorIvpEnhV = true;
	1094	}
	1095
	1096	if( m_GOPListsMvc[k][MAX_GOP].m_POC != 0 )
	1097	{
	1098	printf( "\nError: POC %d not possible for FrameI_v%d, must be 0\n", m_GOPListsMvc[k][MAX_GOP].m_POC, k );
	1099	bErrorIvpEnhV = true;
	1100	}
	1101
	1102	if( m_GOPListsMvc[k][MAX_GOP].m_temporalId != 0 )
	1103	{
	1104	printf( "\nWarning: Temporal id of FrameI_v%d must be 0 (cp. I-frame in base view)\n", k );
	1105	m_GOPListsMvc[k][MAX_GOP].m_temporalId = 0;
	1106	}
	1107
	1108	if( !(m_GOPListsMvc[k][MAX_GOP].m_refPic) )
	1109	{
	1110	printf( "\nWarning: FrameI_v%d must be ref pic (cp. I-frame in base view)\n", k );
	1111	m_GOPListsMvc[k][MAX_GOP].m_refPic = true;
	1112	}
	1113
	1114	if( m_GOPListsMvc[k][MAX_GOP].m_numRefPics != 0 )
	1115	{
	1116	printf( "\nWarning: temporal references not possible for FrameI_v%d\n", k );
	1117	for( Int j = 0; j < m_GOPListsMvc[k][MAX_GOP].m_numRefPics; j++ )
	1118	{
	1119	m_GOPListsMvc[k][MAX_GOP].m_referencePics[j] = 0;
	1120	}
	1121	m_GOPListsMvc[k][MAX_GOP].m_numRefPics = 0;
	1122	}
	1123
	1124	if( m_GOPListsMvc[k][MAX_GOP].m_interRPSPrediction )
	1125	{
	1126	printf( "\nError: inter RPS prediction not possible for FrameI_v%d, must be 0\n", k );
	1127	bErrorIvpEnhV = true;
	1128	}
	1129
	1130	if( m_GOPListsMvc[k][MAX_GOP].m_sliceType == 'I' && m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics != 0 )
	1131	{
	1132	printf( "\nError: inter-view prediction not possible for FrameI_v%d with slice type I, #IV_ref_pics must be 0\n", k );
	1133	bErrorIvpEnhV = true;
	1134	}
	1135
	1136	if( m_GOPListsMvc[k][MAX_GOP].m_numRefPicsActive > m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics )
	1137	{
	1138	m_GOPListsMvc[k][MAX_GOP].m_numRefPicsActive = m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics;
	1139	}
	1140
	1141	if( m_GOPListsMvc[k][MAX_GOP].m_sliceType == 'P' )
	1142	{
	1143	if( m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics < 1 )
	1144	{
	1145	printf( "\nError: #IV_ref_pics must be at least one for FrameI_v%d with slice type P\n", k );
	1146	bErrorIvpEnhV = true;
	1147	}
	1148	else
	1149	{
	1150	for( Int j = 0; j < m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics; j++ )
	1151	{
	1152	if( m_GOPListsMvc[k][MAX_GOP].m_interViewRefPosL1[j] != 0 )
	1153	{
	1154	printf( "\nError: inter-view ref pos %d on L1 not possible for FrameI_v%d with slice type P\n", m_GOPListsMvc[k][MAX_GOP].m_interViewRefPosL1[j], k );
	1155	bErrorIvpEnhV = true;
	1156	}
	1157	}
	1158	}
	1159	}
	1160
	1161	if( m_GOPListsMvc[k][MAX_GOP].m_sliceType == 'B' && m_GOPListsMvc[k][MAX_GOP].m_numInterViewRefPics < 1 )
	1162	{
	1163	printf( "\nError: #IV_ref_pics must be at least one for FrameI_v%d with slice type B\n", k );
	1164	bErrorIvpEnhV = true;
	1165	}
	1166	}
	1167	}
	1168	}
	1169	}
	1170	xConfirmPara( bErrorIvpEnhV, "Invalid inter-view coding structure for enhancement views given" );
	1171
	1172	// validate temporal coding structure
	1173	if( !bErrorMvePoc && !bErrorIvpBase && !bErrorIvpEnhV )
	1174	{
	1175	for( Int viewId = 0; viewId < m_iNumberOfViews; viewId++ )
	1176	{
	1177	Bool verifiedGOP = false;
	1178	Bool errorGOP = false;
	1179	Int checkGOP = 1;
	1180	Int numRefs = 1;
	1181	Int refList[MAX_NUM_REF_PICS+1];
	1182	refList[0] = 0;
	1183	Bool isOK[MAX_GOP];
	1184	for( Int i = 0; i < MAX_GOP; i++ ) { isOK[i] = false; }
	1185	Int numOK = 0;
	1186	m_extraRPSs[viewId] = 0;
	1187	//start looping through frames in coding order until we can verify that the GOP structure is correct.
	1188	while( !verifiedGOP && !errorGOP )
	1189	{
	1190	Int curGOP = (checkGOP-1)%m_iGOPSize;
	1191	Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPListsMvc[viewId][curGOP].m_POC;
	1192	if( m_GOPListsMvc[viewId][curGOP].m_POC < 0 )
	1193	{
	1194	printf( "\nError: found fewer Reference Picture Sets than GOPSize for view %d\n", viewId );
	1195	errorGOP = true;
	1196	}
	1197	else
	1198	{
	1199	//check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP.
	1200	Bool beforeI = false;
	1201	for( Int i = 0; i < m_GOPListsMvc[viewId][curGOP].m_numRefPics; i++ )
	1202	{
	1203	Int absPOC = curPOC + m_GOPListsMvc[viewId][curGOP].m_referencePics[i];
	1204	if( absPOC < 0 )
	1205	{
	1206	beforeI = true;
	1207	}
	1208	else
	1209	{
	1210	Bool found = false;
	1211	for( Int j = 0; j < numRefs; j++ )
	1212	{
	1213	if( refList[j] == absPOC )
	1214	{
	1215	found = true;
	1216	for( Int k = 0; k < m_iGOPSize; k++ )
	1217	{
	1218	if( absPOC%m_iGOPSize == m_GOPListsMvc[viewId][k].m_POC%m_iGOPSize )
	1219	{
	1220	m_GOPListsMvc[viewId][curGOP].m_usedByCurrPic[i] = (m_GOPListsMvc[viewId][k].m_temporalId <= m_GOPListsMvc[viewId][curGOP].m_temporalId);
	1221	}
	1222	}
	1223	}
	1224	}
	1225	if( !found )
	1226	{
	1227	printf("\nError: ref pic %d is not available for GOP frame %d of view %d\n", m_GOPListsMvc[viewId][curGOP].m_referencePics[i], curGOP+1, viewId );
	1228	errorGOP = true;
	1229	}
	1230	}
	1231	}
	1232	if( !beforeI && !errorGOP )
	1233	{
	1234	//all ref frames were present
	1235	if( !isOK[curGOP] )
	1236	{
	1237	numOK++;
	1238	isOK[curGOP] = true;
	1239	if( numOK == m_iGOPSize )
	1240	{
	1241	verifiedGOP = true;
	1242	}
	1243	}
	1244	}
	1245	else
	1246	{
	1247	//create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0)
	1248	m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]] = m_GOPListsMvc[viewId][curGOP];
	1249	Int newRefs = 0;
	1250	for( Int i = 0; i < m_GOPListsMvc[viewId][curGOP].m_numRefPics; i++ )
	1251	{
	1252	Int absPOC = curPOC + m_GOPListsMvc[viewId][curGOP].m_referencePics[i];
	1253	if( absPOC >= 0 )
	1254	{
	1255	m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[newRefs] = m_GOPListsMvc[viewId][curGOP].m_referencePics[i];
	1256	m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_usedByCurrPic[newRefs] = m_GOPListsMvc[viewId][curGOP].m_usedByCurrPic[i];
	1257	newRefs++;
	1258	}
	1259	}
	1260	Int numPrefRefs = m_GOPListsMvc[viewId][curGOP].m_numRefPicsActive;
	1261
	1262	for( Int offset = -1; offset > -checkGOP; offset-- )
	1263	{
	1264	//step backwards in coding order and include any extra available pictures we might find useful to replace the ones with POC < 0.
	1265	Int offGOP = (checkGOP - 1 + offset)%m_iGOPSize;
	1266	Int offPOC = ((checkGOP - 1 + offset)/m_iGOPSize) * m_iGOPSize + m_GOPListsMvc[viewId][offGOP].m_POC;
	1267	if( offPOC >= 0 && m_GOPListsMvc[viewId][offGOP].m_refPic && m_GOPListsMvc[viewId][offGOP].m_temporalId <= m_GOPListsMvc[viewId][curGOP].m_temporalId )
	1268	{
	1269	Bool newRef = false;
	1270	for( Int i = 0; i < numRefs; i++ )
	1271	{
	1272	if( refList[i] == offPOC )
	1273	{
	1274	newRef = true;
	1275	}
	1276	}
	1277	for( Int i = 0; i < newRefs; i++ )
	1278	{
	1279	if( m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[i] == (offPOC - curPOC) )
	1280	{
	1281	newRef = false;
	1282	}
	1283	}
	1284	if( newRef )
	1285	{
	1286	Int insertPoint = newRefs;
	1287	//this picture can be added, find appropriate place in list and insert it.
	1288	for( Int j = 0; j < newRefs; j++ )
	1289	{
	1290	if( m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[j] < (offPOC - curPOC) \|\|
	1291	m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[j] > 0 )
	1292	{
	1293	insertPoint = j;
	1294	break;
	1295	}
	1296	}
	1297	Int prev = offPOC - curPOC;
	1298	Int prevUsed = (m_GOPListsMvc[viewId][offGOP].m_temporalId <= m_GOPListsMvc[viewId][curGOP].m_temporalId);
	1299	for( Int j = insertPoint; j < newRefs+1; j++ )
	1300	{
	1301	Int newPrev = m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[j];
	1302	Int newUsed = m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_usedByCurrPic[j];
	1303	m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[j] = prev;
	1304	m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_usedByCurrPic[j] = prevUsed;
	1305	prevUsed = newUsed;
	1306	prev = newPrev;
	1307	}
	1308	newRefs++;
	1309	}
	1310	}
	1311	if( newRefs >= numPrefRefs )
	1312	{
	1313	break;
	1314	}
	1315	}
	1316	m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_numRefPics = newRefs;
	1317	m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_POC = curPOC;
	1318	if( m_extraRPSs[viewId] == 0 )
	1319	{
	1320	m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_interRPSPrediction = 0;
	1321	m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_numRefIdc = 0;
	1322	}
	1323	else
	1324	{
	1325	Int rIdx = m_iGOPSize + m_extraRPSs[viewId] - 1;
	1326	Int refPOC = m_GOPListsMvc[viewId][rIdx].m_POC;
	1327	Int refPics = m_GOPListsMvc[viewId][rIdx].m_numRefPics;
	1328	Int newIdc = 0;
	1329	for( Int i = 0; i <= refPics; i++ )
	1330	{
	1331	Int deltaPOC = ((i != refPics)? m_GOPListsMvc[viewId][rIdx].m_referencePics[i] : 0); // check if the reference abs POC is >= 0
	1332	Int absPOCref = refPOC + deltaPOC;
	1333	Int refIdc = 0;
	1334	for( Int j = 0; j < m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_numRefPics; j++ )
	1335	{
	1336	if( (absPOCref - curPOC) == m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_referencePics[j] )
	1337	{
	1338	if( m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_usedByCurrPic[j] )
	1339	{
	1340	refIdc = 1;
	1341	}
	1342	else
	1343	{
	1344	refIdc = 2;
	1345	}
	1346	}
	1347	}
	1348	m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_refIdc[newIdc] = refIdc;
	1349	newIdc++;
	1350	}
	1351	m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_interRPSPrediction = 1;
	1352	m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_numRefIdc = newIdc;
	1353	m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_deltaRPS = refPOC - m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_POC;
	1354	m_GOPListsMvc[viewId][m_iGOPSize+m_extraRPSs[viewId]].m_deltaRIdxMinus1 = 0;
	1355	}
	1356	curGOP = m_iGOPSize + m_extraRPSs[viewId];
	1357	m_extraRPSs[viewId]++;
	1358	}
	1359	numRefs = 0;
	1360	for( Int i = 0; i < m_GOPListsMvc[viewId][curGOP].m_numRefPics; i++ )
	1361	{
	1362	Int absPOC = curPOC + m_GOPListsMvc[viewId][curGOP].m_referencePics[i];
	1363	if( absPOC >= 0 )
	1364	{
	1365	refList[numRefs] = absPOC;
	1366	numRefs++;
	1367	}
	1368	}
	1369	refList[numRefs] = curPOC;
	1370	numRefs++;
	1371	}
	1372	checkGOP++;
	1373	}
	1374	xConfirmPara( errorGOP, "Invalid GOP structure given" );
	1375	m_maxTempLayer[viewId] = 1;
	1376	for( Int i = 0; i < m_iGOPSize; i++ )
	1377	{
	1378	if( m_GOPListsMvc[viewId][i].m_temporalId >= m_maxTempLayer[viewId] )
	1379	{
	1380	m_maxTempLayer[viewId] = m_GOPListsMvc[viewId][i].m_temporalId + 1;
	1381	}
	1382	xConfirmPara( m_GOPListsMvc[viewId][i].m_sliceType != 'B' && m_GOPListsMvc[viewId][i].m_sliceType != 'P', "Slice type must be equal to B or P" );
	1383	}
	1384
	1385	for( Int i = 0; i < MAX_TLAYER; i++ )
	1386	{
	1387	m_numReorderPics[viewId][i] = 0;
	1388	m_maxDecPicBuffering[viewId][i] = 0;
	1389	}
	1390	for( Int i = 0; i < m_iGOPSize; i++ )
	1391	{
	1392	if( m_GOPListsMvc[viewId][i].m_numRefPics > m_maxDecPicBuffering[viewId][m_GOPListsMvc[viewId][i].m_temporalId] )
	1393	{
	1394	m_maxDecPicBuffering[viewId][m_GOPListsMvc[viewId][i].m_temporalId] = m_GOPListsMvc[viewId][i].m_numRefPics;
	1395	}
	1396	Int highestDecodingNumberWithLowerPOC = 0;
	1397	for( Int j = 0; j < m_iGOPSize; j++ )
	1398	{
	1399	if( m_GOPListsMvc[viewId][j].m_POC <= m_GOPListsMvc[viewId][i].m_POC )
	1400	{
	1401	highestDecodingNumberWithLowerPOC = j;
	1402	}
	1403	}
	1404	Int numReorder = 0;
	1405	for( Int j = 0; j < highestDecodingNumberWithLowerPOC; j++ )
	1406	{
	1407	if( m_GOPListsMvc[viewId][j].m_temporalId <= m_GOPListsMvc[viewId][i].m_temporalId &&
	1408	m_GOPListsMvc[viewId][j].m_POC > m_GOPListsMvc[viewId][i].m_POC )
	1409	{
	1410	numReorder++;
	1411	}
	1412	}
	1413	if( numReorder > m_numReorderPics[viewId][m_GOPListsMvc[viewId][i].m_temporalId] )
	1414	{
	1415	m_numReorderPics[viewId][m_GOPListsMvc[viewId][i].m_temporalId] = numReorder;
	1416	}
	1417	}
	1418	for( Int i = 0; i < MAX_TLAYER-1; i++ )
	1419	{
	1420	// a lower layer can not have higher value of m_numReorderPics than a higher layer
	1421	if( m_numReorderPics[viewId][i+1] < m_numReorderPics[viewId][i] )
	1422	{
	1423	m_numReorderPics[viewId][i+1] = m_numReorderPics[viewId][i];
	1424	}
	1425	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive
	1426	if( m_numReorderPics[viewId][i] > m_maxDecPicBuffering[viewId][i] )
	1427	{
	1428	m_maxDecPicBuffering[viewId][i] = m_numReorderPics[viewId][i];
	1429	}
	1430	// a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer
	1431	if( m_maxDecPicBuffering[viewId][i+1] < m_maxDecPicBuffering[viewId][i] )
	1432	{
	1433	m_maxDecPicBuffering[viewId][i+1] = m_maxDecPicBuffering[viewId][i];
	1434	}
	1435	}
	1436	// the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive
	1437	if( m_numReorderPics[viewId][MAX_TLAYER-1] > m_maxDecPicBuffering[viewId][MAX_TLAYER-1] )
	1438	{
	1439	m_maxDecPicBuffering[viewId][MAX_TLAYER-1] = m_numReorderPics[viewId][MAX_TLAYER-1];
	1440	}
	1441
	1442	xConfirmPara( m_bUseLComb == false && m_numReorderPics[viewId][MAX_TLAYER-1] != 0, "ListCombination can only be 0 in low delay coding (more precisely when L0 and L1 are identical)" ); // Note however this is not the full necessary condition as ref_pic_list_combination_flag can only be 0 if L0 == L1.
	1443	}
	1444	}
[2]	1445	#undef xConfirmPara
[56]	1446	if( check_failed )
[2]	1447	{
	1448	exit(EXIT_FAILURE);
	1449	}
	1450	}
	1451
	1452	template <class T>
	1453	Void
	1454	TAppEncCfg::xCleanUpVector( std::vector<T>& rcVec, const T& rcInvalid )
	1455	{
	1456	Int iFirstInv = (Int)rcVec.size();
	1457	for( Int iIdx = 0; iIdx < (Int)rcVec.size(); iIdx++ )
	1458	{
	1459	if( rcVec[ iIdx ] == rcInvalid )
	1460	{
	1461	iFirstInv = iIdx;
	1462	break;
	1463	}
	1464	}
	1465	while( (Int)rcVec.size() > iFirstInv )
	1466	{
	1467	rcVec.pop_back();
	1468	}
	1469	}
	1470
	1471	Void
	1472	TAppEncCfg::xCleanUpVectors()
	1473	{
	1474	xCleanUpVector( m_pchInputFileList, (char*)0 );
	1475	xCleanUpVector( m_pchDepthInputFileList, (char*)0 );
	1476	xCleanUpVector( m_pchReconFileList, (char*)0 );
	1477	xCleanUpVector( m_pchDepthReconFileList, (char*)0 );
	1478	}
	1479
	1480	/** \todo use of global variables should be removed later
	1481	*/
	1482	Void TAppEncCfg::xSetGlobal()
	1483	{
	1484	// set max CU width & height
	1485	g_uiMaxCUWidth = m_uiMaxCUWidth;
	1486	g_uiMaxCUHeight = m_uiMaxCUHeight;
[56]	1487
[2]	1488	// compute actual CU depth with respect to config depth and max transform size
	1489	g_uiAddCUDepth = 0;
	1490	while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth ) ) ) g_uiAddCUDepth++;
[56]	1491
[2]	1492	m_uiMaxCUDepth += g_uiAddCUDepth;
	1493	g_uiAddCUDepth++;
	1494	g_uiMaxCUDepth = m_uiMaxCUDepth;
[56]	1495
[2]	1496	// set internal bit-depth and constants
	1497	#if FULL_NBIT
	1498	g_uiBitDepth = m_uiInternalBitDepth;
	1499	g_uiBitIncrement = 0;
	1500	#else
	1501	g_uiBitDepth = 8;
	1502	g_uiBitIncrement = m_uiInternalBitDepth - g_uiBitDepth;
	1503	#endif
[56]	1504
[17]	1505	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
[56]	1506	g_iDeltaDCsQuantOffset = g_uiBitIncrement - 2;
[17]	1507	#endif
[2]	1508
	1509	g_uiBASE_MAX = ((1<<(g_uiBitDepth))-1);
[56]	1510
[2]	1511	#if IBDI_NOCLIP_RANGE
	1512	g_uiIBDI_MAX = g_uiBASE_MAX << g_uiBitIncrement;
	1513	#else
	1514	g_uiIBDI_MAX = ((1<<(g_uiBitDepth+g_uiBitIncrement))-1);
	1515	#endif
[56]	1516
[2]	1517	if (m_uiOutputBitDepth == 0)
	1518	{
	1519	m_uiOutputBitDepth = m_uiInternalBitDepth;
	1520	}
[56]	1521
	1522	g_uiPCMBitDepthLuma = m_uiPCMBitDepthLuma = ((m_bPCMInputBitDepthFlag)? m_uiInputBitDepth : m_uiInternalBitDepth);
	1523	g_uiPCMBitDepthChroma = ((m_bPCMInputBitDepthFlag)? m_uiInputBitDepth : m_uiInternalBitDepth);
[2]	1524	}
	1525
	1526	Void TAppEncCfg::xPrintParameter()
	1527	{
	1528	printf("\n");
[56]	1529	for( Int iCounter = 0; iCounter< m_iNumberOfViews; iCounter++)
[2]	1530	{
[56]	1531	printf("Texture Input File %i : %s\n", iCounter, m_pchInputFileList[iCounter]);
[2]	1532	}
[56]	1533	if( m_bUsingDepthMaps )
[2]	1534	{
[56]	1535	for( Int iCounter = 0; iCounter < m_iNumberOfViews; iCounter++)
	1536	{
	1537	printf("Depth Input File %i : %s\n", iCounter, m_pchDepthInputFileList[iCounter]);
	1538	}
[2]	1539	}
[56]	1540	printf("Bitstream File : %s\n", m_pchBitstreamFile );
	1541	for( Int iCounter = 0; iCounter< m_iNumberOfViews; iCounter++)
[2]	1542	{
[56]	1543	printf("Texture Reconstruction File %i : %s\n", iCounter, m_pchReconFileList[iCounter]);
[2]	1544	}
[56]	1545	if( m_bUsingDepthMaps )
[2]	1546	{
[56]	1547	for( Int iCounter = 0; iCounter< m_iNumberOfViews; iCounter++)
	1548	{
	1549	printf("Depth Reconstruction File %i : %s\n", iCounter, m_pchDepthReconFileList[iCounter]);
	1550	}
[2]	1551	}
[56]	1552	printf("Real Format : %dx%d %dHz\n", m_iSourceWidth - m_cropLeft - m_cropRight, m_iSourceHeight - m_cropTop - m_cropBottom, m_iFrameRate );
[2]	1553	printf("Internal Format : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
	1554	printf("Frame index : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_iFrameToBeEncoded-1, m_iFrameToBeEncoded );
	1555	printf("CU size / depth : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
	1556	printf("RQT trans. size (min / max) : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
	1557	printf("Max RQT depth inter : %d\n", m_uiQuadtreeTUMaxDepthInter);
	1558	printf("Max RQT depth intra : %d\n", m_uiQuadtreeTUMaxDepthIntra);
[56]	1559	printf("Min PCM size : %d\n", 1 << m_uiPCMLog2MinSize);
[2]	1560	printf("Motion search range : %d\n", m_iSearchRange );
[210]	1561	#if DV_V_RESTRICTION_B0037
	1562	printf("Disp search range restriction: %d\n", m_bUseDisparitySearchRangeRestriction );
	1563	printf("Vertical disp search range : %d\n", m_iVerticalDisparitySearchRange );
	1564	#endif
[56]	1565	printf("Intra period : %d\n", m_iIntraPeriod );
[2]	1566	printf("Decoding refresh type : %d\n", m_iDecodingRefreshType );
[56]	1567	printf("QP Texture : %5.2f\n", m_adQP[0] );
	1568	if( m_bUsingDepthMaps )
	1569	{
	1570	printf("QP Depth : %5.2f\n", m_adQP[ m_adQP.size() < 2 ? 0 : 1] );
	1571	}
	1572	printf("Max dQP signaling depth : %d\n", m_iMaxCuDQPDepth);
	1573
	1574	printf("Chroma Qp Offset : %d\n", m_iChromaQpOffset );
	1575	printf("Chroma Qp Offset 2nd : %d\n", m_iChromaQpOffset2nd);
	1576
	1577	printf("QP adaptation : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) );
[2]	1578	printf("GOP size : %d\n", m_iGOPSize );
	1579	printf("Internal bit depth : %d\n", m_uiInternalBitDepth );
[56]	1580	printf("PCM sample bit depth : %d\n", m_uiPCMBitDepthLuma );
	1581	if((m_uiMaxCUWidth >> m_uiMaxCUDepth) == 4)
[2]	1582	{
[56]	1583	printf("DisableInter4x4 : %d\n", m_bDisInter4x4);
[2]	1584	}
	1585
[56]	1586	printf("Loop Filter Disabled : %d %d\n", m_abLoopFilterDisable[0] ? 1 : 0, m_abLoopFilterDisable[1] ? 1 : 0 );
[2]	1587	printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision);
	1588
[5]	1589	#if HHI_VSO
[2]	1590	printf("Force use of Lambda Scale : %d\n", m_bForceLambdaScaleVSO );
	1591
	1592	if ( m_bUseVSO )
	1593	{
	1594	printf("VSO Lambda Scale : %5.2f\n", m_dLambdaScaleVSO );
	1595	printf("VSO Mode : %d\n", m_uiVSOMode );
	1596	printf("VSO Config : %s\n", m_pchVSOConfig );
[5]	1597	#if HHI_VSO_DIST_INT
[2]	1598	printf("VSO Negative Distortion : %d\n", m_bAllowNegDist ? 1 : 0);
	1599	#endif
[189]	1600	#if HHI_VSO_LS_TABLE_M23714
[100]	1601	printf("VSO LS Table : %d\n", m_bVSOLSTable ? 1 : 0);
	1602	#endif
	1603	#if SAIT_VSO_EST_A0033
	1604	printf("VSO Estimated VSD : %d\n", m_bUseEstimatedVSD ? 1 : 0);
	1605	#endif
	1606	#if LGE_VSO_EARLY_SKIP_A0093
	1607	printf("VSO Early Skip : %d\n", m_bVSOEarlySkip ? 1 : 0);
	1608	#endif
	1609
[2]	1610	}
[5]	1611	#endif
[56]	1612	#if HHI_INTERVIEW_SKIP
	1613	printf("InterView Skip: : %d\n", m_bInterViewSkip ? 1:0 );
	1614	printf("InterView Skip Lambda Scale : %f\n", m_dInterViewSkipLambdaScale );
	1615	#endif
[2]	1616
	1617	printf("\n");
[56]	1618
	1619	printf("TOOL CFG General: ");
	1620	printf("ALFMNF:%d ", m_iALFMaxNumberFilters);
	1621	printf("ALFInSlice:%d ", m_bALFParamInSlice);
	1622	printf("ALFPicEnc:%d ", m_bALFPicBasedEncode);
[2]	1623	printf("IBD:%d ", !!g_uiBitIncrement);
	1624	printf("HAD:%d ", m_bUseHADME );
	1625	printf("SRD:%d ", m_bUseSBACRD );
	1626	printf("SQP:%d ", m_uiDeltaQpRD );
	1627	printf("ASR:%d ", m_bUseASR );
	1628	printf("LComb:%d ", m_bUseLComb );
	1629	printf("LCMod:%d ", m_bLCMod );
[56]	1630	printf("FEN:%d ", m_bUseFastEnc );
	1631	printf("ECU:%d ", m_bUseEarlyCU );
	1632	printf("FDM:%d ", m_useFastDecisionForMerge );
	1633	printf("CFM:%d ", m_bUseCbfFastMode );
[2]	1634	printf("RQT:%d ", 1 );
[56]	1635	printf("LMC:%d ", m_bUseLMChroma );
	1636	printf("Slice: G=%d M=%d ", m_iSliceGranularity, m_iSliceMode);
[2]	1637	if (m_iSliceMode!=0)
	1638	{
[56]	1639	printf("A=%d ", m_iSliceArgument);
[2]	1640	}
[56]	1641	printf("EntropySlice: M=%d ",m_iEntropySliceMode);
[2]	1642	if (m_iEntropySliceMode!=0)
	1643	{
[56]	1644	printf("A=%d ", m_iEntropySliceArgument);
[2]	1645	}
	1646	printf("CIP:%d ", m_bUseConstrainedIntraPred);
[56]	1647	printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
[443]	1648	#if LGE_SAO_MIGRATION_D0091
	1649	printf("SAOLcuBasedOptimization:%d ", (m_saoLcuBasedOptimization)?(1):(0));
	1650	#else
[56]	1651	printf("SAOInterleaving:%d ", (m_saoInterleavingFlag)?(1):(0));
[443]	1652	#endif
[56]	1653	#if LOSSLESS_CODING
	1654	printf("LosslessCuEnabled:%d ", (m_useLossless)? 1:0 );
	1655	#endif
	1656	printf("WPP:%d ", (Int)m_bUseWeightPred);
	1657	printf("WPB:%d ", m_uiBiPredIdc);
	1658	printf("TileLocationInSliceHdr:%d ", m_iTileLocationInSliceHeaderFlag);
	1659	printf("TileMarker:%d", m_iTileMarkerFlag);
	1660	if (m_iTileMarkerFlag)
	1661	{
	1662	printf("[%d] ", m_iMaxTileMarkerEntryPoints);
	1663	}
	1664	else
	1665	{
	1666	printf(" ");
	1667	}
	1668	printf(" WaveFrontSynchro:%d WaveFrontFlush:%d WaveFrontSubstreams:%d",
	1669	m_iWaveFrontSynchro, m_iWaveFrontFlush, m_iWaveFrontSubstreams);
	1670	printf(" ScalingList:%d ", m_useScalingListId );
	1671
[189]	1672	#if !TMVP_DEPTH_SWITCH
[56]	1673	printf("TMVP:%d ", m_enableTMVP );
[189]	1674	#endif
[56]	1675
	1676	#if ADAPTIVE_QP_SELECTION
	1677	printf("AQpS:%d", m_bUseAdaptQpSelect );
	1678	#endif
	1679
	1680	printf(" SignBitHidingFlag:%d SignBitHidingThreshold:%d", m_signHideFlag, m_signHidingThreshold);
[2]	1681	printf("\n");
	1682	printf("TOOL CFG VIDEO : ");
	1683	printf("ALF:%d ", (m_abUseALF [0] ? 1 : 0) );
	1684	printf("SAO:%d ", (m_abUseSAO [0] ? 1 : 0));
	1685	printf("RDQ:%d ", (m_abUseRDOQ[0] ? 1 : 0) );
[189]	1686	#if TMVP_DEPTH_SWITCH
	1687	printf("TMVP:%d ", (m_enableTMVP[0] ? 1 : 0) );
	1688	#endif
	1689	#if LGE_ILLUCOMP_B0045
[296]	1690	#if LGE_ILLUCOMP_DEPTH_C0046
	1691	printf("IlluCompEnable: %d %d", m_abUseIC[0] ? 1 : 0, m_abUseIC[1] ? 1 : 0);
	1692	#else
[189]	1693	printf("IlluCompEnable: %d ", m_bUseIC);
	1694	#endif
[296]	1695	#endif
	1696	#if INTER_VIEW_VECTOR_SCALING_C0115
	1697	printf("IVSEnable: %d ", m_bUseIVS);
	1698	#endif
[443]	1699	#if QC_ARP_D0177
	1700	printf(" ARP:%d " , m_nUseAdvResPred );
	1701	#endif
[2]	1702	printf("\n");
	1703
	1704	printf("TOOL CFG DEPTH : ");
	1705	printf("ALF:%d ", (m_abUseALF [1] ? 1 : 0));
	1706	printf("SAO:%d ", (m_abUseSAO [1] ? 1 : 0));
	1707	printf("RDQ:%d ", (m_abUseRDOQ[1] ? 1 : 0));
[189]	1708	#if TMVP_DEPTH_SWITCH
	1709	printf("TMVP:%d ", (m_enableTMVP[1] ? 1 : 0) );
	1710	#endif
[210]	1711	#if FLEX_CODING_ORDER_M23723
	1712	printf("FCO:%d ", (m_b3DVFlexOrder ? 1: 0));
	1713
	1714	if(m_b3DVFlexOrder)
	1715	{
	1716	printf("CodingOrder: %s ", m_pchMVCJointCodingOrder);
	1717	}
	1718	#endif
[5]	1719	#if HHI_VSO
[2]	1720	printf("VSO:%d ", m_bUseVSO );
[115]	1721	#endif
	1722	#if LGE_WVSO_A0119
[120]	1723	printf("WVSO:%d ", m_bUseWVSO );
[115]	1724	#endif
[332]	1725	#if H3D_QTL
[189]	1726	printf("QTLPC:%d ", m_bUseQTLPC);
[115]	1727	#endif
[5]	1728	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
	1729	printf("DMM:%d ", m_bUseDMM );
	1730	#endif
	1731	#if HHI_MPI
[2]	1732	printf("MVI:%d ", m_bUseMVI ? 1 : 0 );
[5]	1733	#endif
[189]	1734	#if RWTH_SDC_DLT_B0036
	1735	printf("SDC:%d ", m_bUseSDC ? 1 : 0 );
	1736	printf("DLT:%d ", m_bUseDLT ? 1 : 0 );
	1737	#endif
[443]	1738
	1739	#if MTK_D0156
	1740	printf("BVSP:%d ", m_bUseVSPCompensation ? 1 : 0 );
	1741	printf("DoNBDV:%d ", m_bUseDVPRefine ? 1 : 0 );
	1742	#endif
	1743
[115]	1744	#if LGE_WVSO_A0119
[189]	1745	if ( m_bUseWVSO )
	1746	printf("\nVSO : VSD : SAD weight = %d : %d : %d ", m_iVSOWeight, m_iVSDWeight, m_iDWeight );
[115]	1747	#endif
[56]	1748	printf("\n\n");
	1749
[2]	1750	fflush(stdout);
	1751	}
	1752
	1753	Void TAppEncCfg::xPrintUsage()
	1754	{
	1755	printf( " <name> = ALF - adaptive loop filter\n");
	1756	printf( " IBD - bit-depth increasement\n");
	1757	printf( " GPB - generalized B instead of P in low-delay mode\n");
	1758	printf( " HAD - hadamard ME for fractional-pel\n");
	1759	printf( " SRD - SBAC based RD estimation\n");
	1760	printf( " RDQ - RDOQ\n");
	1761	printf( " LDC - low-delay mode\n");
	1762	printf( " NRF - non-reference frame marking in last layer\n");
	1763	printf( " BQP - hier-P style QP assignment in low-delay mode\n");
	1764	printf( " PAD - automatic source padding of multiple of 16\n");
	1765	printf( " ASR - adaptive motion search range\n");
[56]	1766	printf( " FEN - fast encoder setting\n");
	1767	printf( " ECU - Early CU setting\n");
	1768	printf( " CFM - Cbf fast mode setting\n");
[2]	1769	printf( " LMC - intra chroma prediction based on luma\n");
	1770	printf( "\n" );
	1771	printf( " Example 1) TAppEncoder.exe -c test.cfg -q 32 -g 8 -f 9 -s 64 -h 4\n");
	1772	printf(" -> QP 32, hierarchical-B GOP 8, 9 frames, 64x64-8x8 CU (~4x4 PU)\n\n");
	1773	printf( " Example 2) TAppEncoder.exe -c test.cfg -q 32 -g 4 -f 9 -s 64 -h 4 -1 LDC\n");
	1774	printf(" -> QP 32, hierarchical-P GOP 4, 9 frames, 64x64-8x8 CU (~4x4 PU)\n\n");
	1775	}
	1776
	1777	Bool confirmPara(Bool bflag, const char* message)
	1778	{
	1779	if (!bflag)
	1780	return false;
[56]	1781
[2]	1782	printf("Error: %s\n",message);
	1783	return true;
	1784	}
	1785
	1786	/* helper function */
	1787	/* for handling "-1/-0 FOO" */
	1788	void translateOldStyleCmdline(const char* value, po::Options& opts, const std::string& arg)
	1789	{
	1790	const char* argv[] = {arg.c_str(), value};
	1791	/* replace some short names with their long name varients */
	1792	if (arg == "LDC")
	1793	{
	1794	argv[0] = "LowDelayCoding";
	1795	}
	1796	else if (arg == "RDQ")
	1797	{
	1798	argv[0] = "RDOQ";
	1799	}
	1800	else if (arg == "HAD")
	1801	{
	1802	argv[0] = "HadamardME";
	1803	}
	1804	else if (arg == "SRD")
	1805	{
	1806	argv[0] = "SBACRD";
	1807	}
	1808	else if (arg == "IBD")
	1809	{
	1810	argv[0] = "BitIncrement";
	1811	}
	1812	/* issue a warning for change in FEN behaviour */
	1813	if (arg == "FEN")
	1814	{
	1815	/* xxx todo */
	1816	}
	1817	po::storePair(opts, argv[0], argv[1]);
	1818	}
	1819
	1820	void doOldStyleCmdlineOn(po::Options& opts, const std::string& arg)
	1821	{
	1822	if (arg == "IBD")
	1823	{
	1824	translateOldStyleCmdline("4", opts, arg);
	1825	return;
	1826	}
	1827	translateOldStyleCmdline("1", opts, arg);
	1828	}
	1829
	1830	void doOldStyleCmdlineOff(po::Options& opts, const std::string& arg)
	1831	{
	1832	translateOldStyleCmdline("0", opts, arg);
	1833	}
	1834
	1835	Void TAppEncCfg::xAppendToFileNameEnd( Char* pchInputFileName, const Char* pchStringToAppend, Char*& rpchOutputFileName)
	1836	{
	1837	size_t iInLength = strlen(pchInputFileName);
	1838	size_t iAppendLength = strlen(pchStringToAppend);
	1839
	1840	rpchOutputFileName = (Char*) malloc(iInLength+iAppendLength+1);
	1841	Char* pCDot = strrchr(pchInputFileName,'.');
	1842	pCDot = pCDot ? pCDot : pchInputFileName + iInLength;
	1843	size_t iCharsToDot = pCDot - pchInputFileName ;
	1844	size_t iCharsToEnd = iInLength - iCharsToDot;
	1845	strncpy(rpchOutputFileName , pchInputFileName , iCharsToDot );
	1846	strncpy(rpchOutputFileName+ iCharsToDot , pchStringToAppend , iAppendLength);
	1847	strncpy(rpchOutputFileName+ iCharsToDot+iAppendLength , pchInputFileName+iCharsToDot, iCharsToEnd );
	1848	rpchOutputFileName[iInLength+iAppendLength] = '\0';
	1849	}
[56]	1850
	1851	//! \}

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

Download in other formats: