Context navigation

source: 3DVCSoftware/branches/HTM-4.1-dev0/source/App/TAppEncoder/TAppEncCfg.cpp @ 187

Visit:

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

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

Download in other formats: