Context navigation

TAppEncCfg.cpp @ 100

Visit:

Last change on this file since 100 was 100, checked in by tech, 13 years ago

Adopted modifications:

disparity vector generation (A0097)
inter-view motion prediction modification (A0049)
simplification of disparity vector derivation (A0126)
region boundary chain coding (A0070)
residual skip intra (A0087)
VSO modification (A0033/A0093)

+ Clean ups + Bug fixes

Update of cfg files (A0033 modification 2)

Property svn:eol-style set to native

File size: 77.7 KB

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

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

JCT-3V 3D-HEVC

Context navigation

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

Download in other formats: