Context navigation

TAppEncCfg.cpp @ 1417

Visit:

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-6.2-dev1-LG/source/App/TAppEncoder/TAppEncCfg.cpp @ 1417

Download in other formats: