Context navigation

source: 3DVCSoftware/branches/HTM-5.1-dev0-MERL-Mediatek-Fix/source/App/TAppEncoder/TAppEncCfg.cpp @ 286

Visit:

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

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

Download in other formats: