Context navigation

TAppEncCfg.cpp @ 1013

Visit:

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-5.0-Qualcomm/source/App/TAppEncoder/TAppEncCfg.cpp @ 1013

Download in other formats: