Context navigation

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

Visit:

Last change on this file since 145 was 128, checked in by tech, 12 years ago
Changed default value of DeblockingFilterControlPresent to 1
Property svn:eol-style set to `native`
File size: 79.2 KB

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

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

Download in other formats: