source: 3DVCSoftware/trunk/source/App/TAppEncoder/TAppEncCfg.h

Last change on this file was 1413, checked in by tech, 6 years ago

Merged HTM-16.2-dev@1412

  • Property svn:eol-style set to native
File size: 46.4 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-2017, 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.h
35    \brief    Handle encoder configuration parameters (header)
36*/
37
38#ifndef __TAPPENCCFG__
39#define __TAPPENCCFG__
40
41#include "TLibCommon/CommonDef.h"
42
43#include "TLibEncoder/TEncCfg.h"
44#if EXTENSION_360_VIDEO
45#include "TAppEncHelper360/TExt360AppEncCfg.h"
46#endif
47#include <sstream>
48#include <vector>
49#if NH_3D
50#include "TAppCommon/TAppComCamPara.h"
51#include "TLibRenderer/TRenModel.h"
52#include "TLibRenderer/TRenModSetupStrParser.h"
53#endif
54//! \ingroup TAppEncoder
55//! \{
56
57// ====================================================================================================================
58// Class definition
59// ====================================================================================================================
60
61#if NH_MV
62enum UIProfileName // this is used for determining profile strings, where multiple profiles map to a single profile idc with various constraint flag combinations
63{
64  UI_NONE = 0,
65  UI_MAIN = 1,
66  UI_MAIN10 = 2,
67  UI_MAIN10_STILL_PICTURE=10002,
68  UI_MAINSTILLPICTURE = 3,
69  UI_MAINREXT = 4,
70  UI_HIGHTHROUGHPUTREXT = 5,
71  // The following are RExt profiles, which would map to the MAINREXT profile idc.
72  // The enumeration indicates the bit-depth constraint in the bottom 2 digits
73  //                           the chroma format in the next digit
74  //                           the intra constraint in the next digit (1 for no intra constraint, 2 for intra constraint)
75  //                           If it is a RExt still picture, there is a '1' for the top digit.
76#if NH_MV
77  UI_MULTIVIEWMAIN     = 6,
78#if NH_3D
79  UI_MAIN3D            = 8, 
80#endif
81#endif
82  UI_MONOCHROME_8      = 1008,
83  UI_MONOCHROME_12     = 1012,
84  UI_MONOCHROME_16     = 1016,
85  UI_MAIN_12           = 1112,
86  UI_MAIN_422_10       = 1210,
87  UI_MAIN_422_12       = 1212,
88  UI_MAIN_444          = 1308,
89  UI_MAIN_444_10       = 1310,
90  UI_MAIN_444_12       = 1312,
91  UI_MAIN_444_16       = 1316, // non-standard profile definition, used for development purposes
92  UI_MAIN_INTRA        = 2108,
93  UI_MAIN_10_INTRA     = 2110,
94  UI_MAIN_12_INTRA     = 2112,
95  UI_MAIN_422_10_INTRA = 2210,
96  UI_MAIN_422_12_INTRA = 2212,
97  UI_MAIN_444_INTRA    = 2308,
98  UI_MAIN_444_10_INTRA = 2310,
99  UI_MAIN_444_12_INTRA = 2312,
100  UI_MAIN_444_16_INTRA = 2316,
101  UI_MAIN_444_STILL_PICTURE = 11308,
102  UI_MAIN_444_16_STILL_PICTURE = 12316,
103  // The following are high throughput profiles, which would map to the HIGHTHROUGHPUTREXT profile idc.
104  // The enumeration indicates the bit-depth constraint in the bottom 2 digits
105  //                           the chroma format in the next digit
106  //                           the intra constraint in the next digit
107  //                           There is a '2' for the top digit to indicate it is high throughput profile
108
109  UI_HIGHTHROUGHPUT_444     = 21308,
110  UI_HIGHTHROUGHPUT_444_10  = 21310,
111  UI_HIGHTHROUGHPUT_444_14  = 21314,
112  UI_HIGHTHROUGHPUT_444_16_INTRA  = 22316
113#if NH_MV_ALLOW_NON_CONFORMING
114  , 
115  UI_MULTIVIEWMAIN_NONCONF     = 10000006,
116#if NH_3D
117  UI_MAIN3D_NONCONF            = 10000008, 
118#endif
119#endif
120};
121#endif
122
123/// encoder configuration class
124class TAppEncCfg
125{
126#if JVET_E0059_FLOATING_POINT_QP_FIX
127public:
128  template <class T>
129  struct OptionalValue
130  {
131    Bool bPresent;
132    T    value;
133    OptionalValue() : bPresent(false), value() { }
134  };
135#endif
136
137protected:
138  // file I/O
139#if NH_MV
140  std::vector<TChar*>     m_pchInputFileList;                  ///< source file names
141#else
142  std::string m_inputFileName;                                ///< source file name
143#endif
144  std::string m_bitstreamFileName;                            ///< output bitstream file
145#if NH_MV
146  std::vector<char*>     m_pchReconFileList;                  ///< output reconstruction file names
147  Int                    m_numberOfLayers;                    ///< number of Layers to Encode
148  Int                    m_iNumberOfViews;                    ///< number of Layers that are views
149#if NH_MV
150  Bool                   m_shareParameterSets;
151  IntAry1d               m_layerIdxInVpsToGopDefIdx;
152  IntAry1d               m_layerIdxInVpsToRepFormatIdx; 
153  Int                    m_numRepFormats;
154  Int                    m_numInputOutputRepFormats;
155#endif
156#else
157  std::string m_reconFileName;                                ///< output reconstruction file
158#endif
159  #if NH_MV
160// VPS specification
161  IntAry2d m_dimIds;                   ///< dimension ids ( pointers to m_viewId and m_depthFlag
162  IntAry1d               m_viewId;                            ///< view id
163  IntAry1d               m_viewOrderIndex;                    ///< view order index 
164  IntAry1d               m_auxId;                             ///< auxiliary id
165#if NH_3D_VSO || NH_3D
166  IntAry1d               m_depthFlag;                         ///< depth flag
167#endif
168  IntAry1d               m_targetEncLayerIdList;              ///< layer Ids in Nuh to be encoded
169  IntAry1d               m_layerIdInNuh;                      ///< layer Id in Nuh for each layer
170  Bool                   m_splittingFlag;                     ///< Splitting Flag
171  Int                    m_scalabilityMask;                   ///< Mask indicating scalabilities, 1: texture; 3: texture + depth                                                               
172  IntAry1d               m_dimensionIdLen;                    ///< Length of scalability dimension s
173 
174// layer sets   
175  Int                    m_vpsNumLayerSets;                   ///< Number of layer sets
176  IntAry2d               m_layerIdxInVpsInSets;               ///< LayerIds in vps of layer set
177  Int                    m_numAddLayerSets;                   ///< Number of additional layer sets
178  IntAry2d               m_highestLayerIdxPlus1;              ///< HighestLayerIdxPlus1 for each additional layer set and each independent layer (value with index 0 will be ignored)
179  Int                    m_defaultOutputLayerIdc;             ///< Specifies output layers of layer sets, 0: output all layers, 1: output highest layers, 2: specified by LayerIdsInDefOuputLayerSet
180  IntAry1d               m_outputLayerSetIdx;                 ///< Indices of layer sets used as additional output layer sets 
181  IntAry2d               m_layerIdsInAddOutputLayerSet;       ///< LayerIds in vps of additional output layers
182  IntAry2d               m_layerIdsInDefOutputLayerSet;       ///< Indices in vps of output layers in layer sets
183  IntAry2d               m_profileTierLevelIdx;               ///< Indices of of profile, per layer in layer set
184  BoolAry1d              m_altOutputLayerFlag;                ///< Alt output layer flag
185
186  // Dependencies
187  IntAry2d m_directRefLayers;          ///< LayerIds of direct reference layers
188  IntAry2d m_dependencyTypes;          ///< Dependency types of direct reference layers
189
190  // VPS VUI
191  Bool m_vpsVuiPresentFlag;
192  Bool m_crossLayerPicTypeAlignedFlag;
193  Bool m_crossLayerIrapAlignedFlag;
194  Bool m_allLayersIdrAlignedFlag;
195  Bool m_bitRatePresentVpsFlag;
196  Bool m_picRatePresentVpsFlag;
197  BoolAry2d m_bitRatePresentFlag;
198  BoolAry2d m_picRatePresentFlag;
199  IntAry2d  m_avgBitRate;
200  IntAry2d  m_maxBitRate;
201  IntAry2d  m_constantPicRateIdc;
202  IntAry2d  m_avgPicRate;
203  Bool      m_tilesNotInUseFlag; 
204  BoolAry1d m_tilesInUseFlag;
205  BoolAry1d m_loopFilterNotAcrossTilesFlag; 
206  Bool      m_wppNotInUseFlag;
207  BoolAry1d m_wppInUseFlag;
208
209  BoolAry2d m_tileBoundariesAlignedFlag; 
210  Bool      m_ilpRestrictedRefLayersFlag;
211  IntAry2d  m_minSpatialSegmentOffsetPlus1;
212  BoolAry2d m_ctuBasedOffsetEnabledFlag;
213  IntAry2d  m_minHorizontalCtuOffsetPlus1;
214  Bool      m_singleLayerForNonIrapFlag;
215  Bool      m_higherLayerIrapSkipFlag;
216#if NH_3D
217  Bool      m_abUseIC;
218  Bool      m_bUseLowLatencyICEnc;
219#endif
220#endif
221  // Lambda modifiers
222  Double    m_adLambdaModifier[ MAX_TLAYER ];                 ///< Lambda modifier array for each temporal layer
223  std::vector<Double> m_adIntraLambdaModifier;                ///< Lambda modifier for Intra pictures, one for each temporal layer. If size>temporalLayer, then use [temporalLayer], else if size>0, use [size()-1], else use m_adLambdaModifier.
224  Double    m_dIntraQpFactor;                                 ///< Intra Q Factor. If negative, use a default equation: 0.57*(1.0 - Clip3( 0.0, 0.5, 0.05*(Double)(isField ? (GopSize-1)/2 : GopSize-1) ))
225
226  // source specification
227  Int       m_iFrameRate;                                     ///< source frame-rates (Hz)
228  UInt      m_FrameSkip;                                   ///< number of skipped frames from the beginning
229  UInt      m_temporalSubsampleRatio;                         ///< temporal subsample ratio, 2 means code every two frames
230 
231#if NH_MV
232  IntAry1d       m_iSourceWidths   ;                                   ///< source width in pixel
233  IntAry1d       m_iSourceHeights  ;                                  ///< source height in pixel (when interlaced = field height)
234  IntAry1d       m_inputFileWidths ;                                 ///< width of image in input file  (this is equivalent to sourceWidth,  if sourceWidth  is not subsequently altered due to padding)
235  IntAry1d       m_inputFileHeights;                                ///< height of image in input file (this is equivalent to sourceHeight, if sourceHeight is not subsequently altered due to padding)
236
237  IntAry1d       m_iSourceHeightOrgs;                               ///< original source height in pixel (when interlaced = frame height)
238#else
239  Int       m_iSourceWidth   ;                                   ///< source width in pixel
240  Int       m_iSourceHeight  ;                                  ///< source height in pixel (when interlaced = field height)
241  Int       m_inputFileWidth ;                                 ///< width of image in input file  (this is equivalent to sourceWidth,  if sourceWidth  is not subsequently altered due to padding)
242  Int       m_inputFileHeight;                                ///< height of image in input file (this is equivalent to sourceHeight, if sourceHeight is not subsequently altered due to padding)
243
244  Int       m_iSourceHeightOrg;                               ///< original source height in pixel (when interlaced = frame height)
245#endif
246
247  Bool      m_isField;                                        ///< enable field coding
248  Bool      m_isTopFieldFirst;
249  Bool      m_bEfficientFieldIRAPEnabled;                     ///< enable an efficient field IRAP structure.
250  Bool      m_bHarmonizeGopFirstFieldCoupleEnabled;
251
252  Int       m_conformanceWindowMode;
253#if NH_MV
254  IntAry1d  m_confWinLefts  ;
255  IntAry1d  m_confWinRights ;
256  IntAry1d  m_confWinTops   ;
257  IntAry1d  m_confWinBottoms;
258#else
259  Int       m_confWinLeft;
260  Int       m_confWinRight;
261  Int       m_confWinTop;
262  Int       m_confWinBottom;
263#endif
264  Int       m_framesToBeEncoded;                              ///< number of encoded frames
265#if NH_MV
266  IntAry2d  m_aiPads;                              ///< number of padded pixels for width and height
267#else
268  Int       m_aiPad[2];                                       ///< number of padded pixels for width and height
269#endif
270  Bool      m_AccessUnitDelimiter;                            ///< add Access Unit Delimiter NAL units
271  InputColourSpaceConversion m_inputColourSpaceConvert;       ///< colour space conversion to apply to input video
272  Bool      m_snrInternalColourSpace;                       ///< if true, then no colour space conversion is applied for snr calculation, otherwise inverse of input is applied.
273  Bool      m_outputInternalColourSpace;                    ///< if true, then no colour space conversion is applied for reconstructed video, otherwise inverse of input is applied.
274#if NH_MV
275  std::vector<ChromaFormat> m_InputChromaFormatIDC;
276#else
277  ChromaFormat m_InputChromaFormatIDC;
278#endif
279
280  Bool      m_printMSEBasedSequencePSNR;
281  Bool      m_printFrameMSE;
282  Bool      m_printSequenceMSE;
283#if JVET_F0064_MSSSIM
284  Bool      m_printMSSSIM;
285#endif
286  Bool      m_cabacZeroWordPaddingEnabled;
287  Bool      m_bClipInputVideoToRec709Range;
288  Bool      m_bClipOutputVideoToRec709Range;
289
290  // profile/level
291#if NH_MV
292  std::vector< Profile::Name > m_profiles;
293 
294  std::vector<UIProfileName>   m_uiProfiles;
295
296  std::vector< Level::Tier   > m_levelTier;
297  std::vector< Level::Name   > m_level;
298  std::vector< Bool          > m_inblFlag; 
299
300  IntAry1d                    m_bitDepthConstraints          ;
301  IntAry1d                    m_tmpConstraintChromaFormats   ;
302  std::vector< ChromaFormat > m_chromaFormatConstraints      ;
303  BoolAry1d                   m_intraConstraintFlags         ;
304  BoolAry1d                   m_onePictureOnlyConstraintFlags;
305  BoolAry1d                   m_lowerBitRateConstraintFlags  ;
306  BoolAry1d                   m_progressiveSourceFlags       ;
307  BoolAry1d                   m_interlacedSourceFlags        ;
308  BoolAry1d                   m_nonPackedConstraintFlags     ;
309  BoolAry1d                   m_frameOnlyConstraintFlags     ;
310
311#else
312  Profile::Name m_profile;
313  Level::Tier   m_levelTier;
314  Level::Name   m_level;
315  UInt          m_bitDepthConstraint;
316  ChromaFormat  m_chromaFormatConstraint;
317  Bool          m_intraConstraintFlag;
318  Bool          m_onePictureOnlyConstraintFlag;
319  Bool          m_lowerBitRateConstraintFlag;
320  Bool          m_progressiveSourceFlag;
321  Bool          m_interlacedSourceFlag;
322  Bool          m_nonPackedConstraintFlag;
323  Bool          m_frameOnlyConstraintFlag;
324#endif
325
326  // coding structure
327#if NH_MV
328  IntAry1d  m_iIntraPeriod;                            ///< period of I-slice (random access period)
329#else
330  Int       m_iIntraPeriod;                                   ///< period of I-slice (random access period)
331#endif
332  Int       m_iDecodingRefreshType;                           ///< random access type
333  Int       m_iGOPSize;                                       ///< GOP size of hierarchical structure
334#if JCTVC_Y0038_PARAMS
335  Bool      m_bReWriteParamSetsFlag;                          ///< Flag to enable rewriting of parameter sets at random access points
336#endif 
337#if NH_MV
338  Int       m_extraRPSsMvc[MAX_NUM_LAYERS];                       ///< extra RPSs added to handle CRA for each layer
339  std::vector< GOPEntry* >  m_GOPListMvc;                            ///< the coding structure entries from the config file for each layer
340  Int       m_numReorderPicsMvc[MAX_NUM_LAYERS][MAX_TLAYER];      ///< total number of reorder pictures for each layer
341  Int       m_maxDecPicBufferingMvc[MAX_NUM_LAYERS][MAX_TLAYER];  ///< total number of reference pictures needed for decoding for each layer
342#else
343  Int       m_extraRPSs;                                      ///< extra RPSs added to handle CRA
344  GOPEntry  m_GOPList[MAX_GOP];                               ///< the coding structure entries from the config file
345  Int       m_numReorderPics[MAX_TLAYER];                     ///< total number of reorder pictures
346  Int       m_maxDecPicBuffering[MAX_TLAYER];                 ///< total number of pictures in the decoded picture buffer
347  #endif
348  Bool      m_crossComponentPredictionEnabledFlag;                          ///< flag enabling the use of cross-component prediction
349  Bool      m_reconBasedCrossCPredictionEstimate;             ///< causes the alpha calculation in encoder search to be based on the decoded residual rather than the pre-transform encoder-side residual
350#if NH_MV
351  UInt      m_log2SaoOffsetScale[MAX_NUM_LAYERS][MAX_NUM_CHANNEL_TYPE];        ///< number of bits for the upward bit shift operation on the decoded SAO offsets
352#else
353  UInt      m_log2SaoOffsetScale[MAX_NUM_CHANNEL_TYPE];       ///< number of bits for the upward bit shift operation on the decoded SAO offsets
354#endif
355  Bool      m_useTransformSkip;                               ///< flag for enabling intra transform skipping
356  Bool      m_useTransformSkipFast;                           ///< flag for enabling fast intra transform skipping
357  UInt      m_log2MaxTransformSkipBlockSize;                  ///< transform-skip maximum size (minimum of 2)
358  Bool      m_transformSkipRotationEnabledFlag;               ///< control flag for transform-skip/transquant-bypass residual rotation
359  Bool      m_transformSkipContextEnabledFlag;                ///< control flag for transform-skip/transquant-bypass single significance map context
360  Bool      m_rdpcmEnabledFlag[NUMBER_OF_RDPCM_SIGNALLING_MODES];///< control flags for residual DPCM
361  Bool      m_enableAMP;
362  Bool      m_persistentRiceAdaptationEnabledFlag;            ///< control flag for Golomb-Rice parameter adaptation over each slice
363  Bool      m_cabacBypassAlignmentEnabledFlag;
364
365  // coding quality
366#if NH_MV
367#if JVET_E0059_FLOATING_POINT_QP_FIX
368  std::vector<Int>   m_qpIncrementAtSourceFrame;             ///< Optional source frame number at which all subsequent frames are to use an increased internal QP.
369#else
370  std::vector<Double>  m_fQP;                                 ///< QP value of key-picture (floating point) for each layer
371#endif
372  std::vector<Int>     m_iQP;                                 ///< QP value of key-picture (integer) for each layer
373#else
374#if JVET_E0059_FLOATING_POINT_QP_FIX
375  OptionalValue<UInt> m_qpIncrementAtSourceFrame;             ///< Optional source frame number at which all subsequent frames are to use an increased internal QP.
376#else
377  Double    m_fQP;                                            ///< QP value of key-picture (floating point)
378#endif
379  Int       m_iQP;                                            ///< QP value of key-picture (integer)
380#endif
381#if X0038_LAMBDA_FROM_QP_CAPABILITY
382  Int       m_intraQPOffset;                                  ///< QP offset for intra slice (integer)
383  Bool      m_lambdaFromQPEnable;                             ///< enable flag for QP:lambda fix
384#endif
385  std::string m_dQPFileName;                                  ///< QP offset for each slice (initialized from external file)
386#if NH_MV
387  std::vector<Int*> m_aidQP;                                    ///< array of slice QP values for each layer
388#else
389  Int*      m_aidQP;                                          ///< array of slice QP values
390#endif
391  Int       m_iMaxDeltaQP;                                    ///< max. |delta QP|
392  UInt      m_uiDeltaQpRD;                                    ///< dQP range for multi-pass slice QP optimization
393  Int       m_iMaxCuDQPDepth;                                 ///< Max. depth for a minimum CuDQPSize (0:default)
394  Int       m_diffCuChromaQpOffsetDepth;                      ///< If negative, then do not apply chroma qp offsets.
395  Bool      m_bFastDeltaQP;                                   ///< Fast Delta QP (false:default)
396
397  Int       m_cbQpOffset;                                     ///< Chroma Cb QP Offset (0:default)
398  Int       m_crQpOffset;                                     ///< Chroma Cr QP Offset (0:default)
399  WCGChromaQPControl m_wcgChromaQpControl;                    ///< Wide-colour-gamut chroma QP control.
400  UInt      m_sliceChromaQpOffsetPeriodicity;                 ///< Used in conjunction with Slice Cb/Cr QpOffsetIntraOrPeriodic. Use 0 (default) to disable periodic nature.
401  Int       m_sliceChromaQpOffsetIntraOrPeriodic[2/*Cb,Cr*/]; ///< Chroma Cb QP Offset at slice level for I slice or for periodic inter slices as defined by SliceChromaQPOffsetPeriodicity. Replaces offset in the GOP table.
402  LumaLevelToDeltaQPMapping m_lumaLevelToDeltaQPMapping;      ///< mapping from luma level to Delta QP.
403#if ADAPTIVE_QP_SELECTION
404  Bool      m_bUseAdaptQpSelect;
405#endif
406  TComSEIMasteringDisplay m_masteringDisplay;
407#if NH_MV
408  std::vector<char*>     m_seiCfgFileNames;               ///< SEI message files.
409  SEIMessages            m_seiMessages;                       ///< Buffer for SEI messages.
410#endif
411
412  Bool      m_bUseAdaptiveQP;                                 ///< Flag for enabling QP adaptation based on a psycho-visual model
413  Int       m_iQPAdaptationRange;                             ///< dQP range by QP adaptation
414
415#if NH_MV
416  Int       m_maxTempLayerMvc[MAX_NUM_LAYER_IDS];             ///< Max temporal layer for each layer
417#else
418  Int       m_maxTempLayer;                                  ///< Max temporal layer
419#endif
420
421  // coding unit (CU) definition
422  // TODO: Remove MaxCUWidth/MaxCUHeight and replace with MaxCUSize.
423  UInt      m_uiMaxCUWidth;                                   ///< max. CU width in pixel
424  UInt      m_uiMaxCUHeight;                                  ///< max. CU height in pixel
425  UInt      m_uiMaxCUDepth;                                   ///< max. CU depth (as specified by command line)
426#if NH_MV
427  IntAry1d  m_uiMaxTotalCUDepth;                              ///< max. total CU depth - includes depth of transform-block structure 
428#else
429  UInt      m_uiMaxTotalCUDepth;                              ///< max. total CU depth - includes depth of transform-block structure 
430#endif
431  UInt      m_uiLog2DiffMaxMinCodingBlockSize;                ///< difference between largest and smallest CU depth
432
433  // transfom unit (TU) definition
434  UInt      m_uiQuadtreeTULog2MaxSize;
435  UInt      m_uiQuadtreeTULog2MinSize;
436
437  UInt      m_uiQuadtreeTUMaxDepthInter;
438  UInt      m_uiQuadtreeTUMaxDepthIntra;
439
440  // coding tools (bit-depth)
441#if NH_MV
442  IntAry2d  m_inputBitDepths      ;         ///< bit-depth of input file
443  IntAry2d  m_outputBitDepths     ;         ///< bit-depth of output file
444  IntAry2d  m_MSBExtendedBitDepths;         ///< bit-depth of input samples after MSB extension
445  IntAry2d  m_internalBitDepths   ;         ///< bit-depth codec operates at (input/output files will be converted)
446#else
447  Int       m_inputBitDepth   [MAX_NUM_CHANNEL_TYPE];         ///< bit-depth of input file
448  Int       m_outputBitDepth  [MAX_NUM_CHANNEL_TYPE];         ///< bit-depth of output file
449  Int       m_MSBExtendedBitDepth[MAX_NUM_CHANNEL_TYPE];      ///< bit-depth of input samples after MSB extension
450  Int       m_internalBitDepth[MAX_NUM_CHANNEL_TYPE];         ///< bit-depth codec operates at (input/output files will be converted)
451#endif
452
453  Bool      m_extendedPrecisionProcessingFlag;
454  Bool      m_highPrecisionOffsetsEnabledFlag;
455
456  //coding tools (chroma format)
457#if NH_MV
458  std::vector<ChromaFormat> m_chromaFormatIDCs;
459#else
460  ChromaFormat m_chromaFormatIDC;
461#endif
462
463  // coding tools (PCM bit-depth)
464  Bool      m_bPCMInputBitDepthFlag;                          ///< 0: PCM bit-depth is internal bit-depth. 1: PCM bit-depth is input bit-depth.
465
466  // coding tool (SAO)
467#if NH_MV
468  std::vector<Bool> m_bUseSAO; 
469#else
470  Bool      m_bUseSAO;
471#endif
472  Bool      m_bTestSAODisableAtPictureLevel;
473  Double    m_saoEncodingRate;                                ///< When >0 SAO early picture termination is enabled for luma and chroma
474  Double    m_saoEncodingRateChroma;                          ///< The SAO early picture termination rate to use for chroma (when m_SaoEncodingRate is >0). If <=0, use results for luma.
475  Int       m_maxNumOffsetsPerPic;                            ///< SAO maximun number of offset per picture
476  Bool      m_saoCtuBoundary;                                 ///< SAO parameter estimation using non-deblocked pixels for CTU bottom and right boundary areas
477  Bool      m_saoResetEncoderStateAfterIRAP;                  ///< When true, SAO encoder state will be reset following an IRAP.
478  // coding tools (loop filter)
479#if NH_MV
480  std::vector<Bool> m_bLoopFilterDisable;                     ///< flag for using deblocking filter for each layer
481#else
482  Bool      m_bLoopFilterDisable;                             ///< flag for using deblocking filter
483#endif
484  Bool      m_loopFilterOffsetInPPS;                         ///< offset for deblocking filter in 0 = slice header, 1 = PPS
485  Int       m_loopFilterBetaOffsetDiv2;                     ///< beta offset for deblocking filter
486  Int       m_loopFilterTcOffsetDiv2;                       ///< tc offset for deblocking filter
487  Int       m_deblockingFilterMetric;                         ///< blockiness metric in encoder
488  // coding tools (PCM)
489  Bool      m_usePCM;                                         ///< flag for using IPCM
490  UInt      m_pcmLog2MaxSize;                                 ///< log2 of maximum PCM block size
491  UInt      m_uiPCMLog2MinSize;                               ///< log2 of minimum PCM block size
492  Bool      m_bPCMFilterDisableFlag;                          ///< PCM filter disable flag
493  Bool      m_enableIntraReferenceSmoothing;                  ///< flag for enabling(default)/disabling intra reference smoothing/filtering
494
495  // coding tools (encoder-only parameters)
496  Bool      m_bUseASR;                                        ///< flag for using adaptive motion search range
497  Bool      m_bUseHADME;                                      ///< flag for using HAD in sub-pel ME
498  Bool      m_useRDOQ;                                       ///< flag for using RD optimized quantization
499  Bool      m_useRDOQTS;                                     ///< flag for using RD optimized quantization for transform skip
500  Bool      m_useSelectiveRDOQ;                               ///< flag for using selective RDOQ
501  Int       m_rdPenalty;                                      ///< RD-penalty for 32x32 TU for intra in non-intra slices (0: no RD-penalty, 1: RD-penalty, 2: maximum RD-penalty)
502  Bool      m_bDisableIntraPUsInInterSlices;                  ///< Flag for disabling intra predicted PUs in inter slices.
503  MESearchMethod m_motionEstimationSearchMethod;
504  Bool      m_bRestrictMESampling;                            ///< Restrict sampling for the Selective ME
505  Int       m_iSearchRange;                                   ///< ME search range
506  Int       m_bipredSearchRange;                              ///< ME search range for bipred refinement
507  Int       m_minSearchWindow;                                ///< ME minimum search window size for the Adaptive Window ME
508  Bool      m_bClipForBiPredMeEnabled;                        ///< Enables clipping for Bi-Pred ME.
509  Bool      m_bFastMEAssumingSmootherMVEnabled;               ///< Enables fast ME assuming a smoother MV.
510#if NH_MV
511  Bool      m_bUseDisparitySearchRangeRestriction;            ///< restrict vertical search range for inter-view prediction
512  Int       m_iVerticalDisparitySearchRange;                  ///< ME vertical search range for inter-view prediction
513#endif
514  FastInterSearchMode m_fastInterSearchMode;                  ///< Parameter that controls fast encoder settings
515  Bool      m_bUseEarlyCU;                                    ///< flag for using Early CU setting
516  Bool      m_useFastDecisionForMerge;                        ///< flag for using Fast Decision Merge RD-Cost
517  Bool      m_bUseCbfFastMode;                              ///< flag for using Cbf Fast PU Mode Decision
518  Bool      m_useEarlySkipDetection;                         ///< flag for using Early SKIP Detection
519  SliceConstraint m_sliceMode;
520  Int       m_sliceArgument;                                 ///< argument according to selected slice mode
521  SliceConstraint m_sliceSegmentMode;
522  Int       m_sliceSegmentArgument;                          ///< argument according to selected slice segment mode
523
524  Bool      m_bLFCrossSliceBoundaryFlag;  ///< 1: filter across slice boundaries 0: do not filter across slice boundaries
525  Bool      m_bLFCrossTileBoundaryFlag;   ///< 1: filter across tile boundaries  0: do not filter across tile boundaries
526  Bool      m_tileUniformSpacingFlag;
527  Int       m_numTileColumnsMinus1;
528  Int       m_numTileRowsMinus1;
529  std::vector<Int> m_tileColumnWidth;
530  std::vector<Int> m_tileRowHeight;
531  Bool      m_entropyCodingSyncEnabledFlag;
532
533  Bool      m_bUseConstrainedIntraPred;                       ///< flag for using constrained intra prediction
534  Bool      m_bFastUDIUseMPMEnabled;
535  Bool      m_bFastMEForGenBLowDelayEnabled;
536  Bool      m_bUseBLambdaForNonKeyLowDelayPictures;
537
538  HashType  m_decodedPictureHashSEIType;                      ///< Checksum mode for decoded picture hash SEI message
539  Bool      m_recoveryPointSEIEnabled;
540  Bool      m_bufferingPeriodSEIEnabled;
541  Bool      m_pictureTimingSEIEnabled;
542  Bool      m_toneMappingInfoSEIEnabled;
543  Bool      m_chromaResamplingFilterSEIenabled;
544  Int       m_chromaResamplingHorFilterIdc;
545  Int       m_chromaResamplingVerFilterIdc;
546  Int       m_toneMapId;
547  Bool      m_toneMapCancelFlag;
548  Bool      m_toneMapPersistenceFlag;
549  Int       m_toneMapCodedDataBitDepth;
550  Int       m_toneMapTargetBitDepth;
551  Int       m_toneMapModelId;
552  Int       m_toneMapMinValue;
553  Int       m_toneMapMaxValue;
554  Int       m_sigmoidMidpoint;
555  Int       m_sigmoidWidth;
556  Int       m_numPivots;
557  Int       m_cameraIsoSpeedIdc;
558  Int       m_cameraIsoSpeedValue;
559  Int       m_exposureIndexIdc;
560  Int       m_exposureIndexValue;
561  Bool      m_exposureCompensationValueSignFlag;
562  Int       m_exposureCompensationValueNumerator;
563  Int       m_exposureCompensationValueDenomIdc;
564  Int       m_refScreenLuminanceWhite;
565  Int       m_extendedRangeWhiteLevel;
566  Int       m_nominalBlackLevelLumaCodeValue;
567  Int       m_nominalWhiteLevelLumaCodeValue;
568  Int       m_extendedWhiteLevelLumaCodeValue;
569  Int*      m_startOfCodedInterval;
570  Int*      m_codedPivotValue;
571  Int*      m_targetPivotValue;
572  Bool      m_framePackingSEIEnabled;
573  Int       m_framePackingSEIType;
574  Int       m_framePackingSEIId;
575  Int       m_framePackingSEIQuincunx;
576  Int       m_framePackingSEIInterpretation;
577  Bool      m_segmentedRectFramePackingSEIEnabled;
578  Bool      m_segmentedRectFramePackingSEICancel;
579  Int       m_segmentedRectFramePackingSEIType;
580  Bool      m_segmentedRectFramePackingSEIPersistence;
581  Int       m_displayOrientationSEIAngle;
582  Bool      m_temporalLevel0IndexSEIEnabled;
583  Bool      m_gradualDecodingRefreshInfoEnabled;
584  Int       m_noDisplaySEITLayer;
585  Bool      m_decodingUnitInfoSEIEnabled;
586  Bool      m_SOPDescriptionSEIEnabled;
587  Bool      m_scalableNestingSEIEnabled;
588  Bool      m_tmctsSEIEnabled;
589#if MCTS_ENC_CHECK
590  Bool      m_tmctsSEITileConstraint;
591#endif
592  Bool      m_timeCodeSEIEnabled;
593  Int       m_timeCodeSEINumTs;
594  TComSEITimeSet m_timeSetArray[MAX_TIMECODE_SEI_SETS];
595  Bool      m_kneeSEIEnabled;
596  Int       m_kneeSEIId;
597  Bool      m_kneeSEICancelFlag;
598  Bool      m_kneeSEIPersistenceFlag;
599  Int       m_kneeSEIInputDrange;
600  Int       m_kneeSEIInputDispLuminance;
601  Int       m_kneeSEIOutputDrange;
602  Int       m_kneeSEIOutputDispLuminance;
603  Int       m_kneeSEINumKneePointsMinus1;
604  Int*      m_kneeSEIInputKneePoint;
605  Int*      m_kneeSEIOutputKneePoint;
606  Int       m_preferredTransferCharacteristics;
607  UInt      m_greenMetadataType;
608  UInt      m_xsdMetricType;
609
610  // weighted prediction
611  Bool      m_useWeightedPred;                    ///< Use of weighted prediction in P slices
612  Bool      m_useWeightedBiPred;                  ///< Use of bi-directional weighted prediction in B slices
613  WeightedPredictionMethod m_weightedPredictionMethod;
614
615  UInt      m_log2ParallelMergeLevel;                         ///< Parallel merge estimation region
616  UInt      m_maxNumMergeCand;                                ///< Max number of merge candidates
617
618  Int       m_TMVPModeId;
619  Bool      m_signDataHidingEnabledFlag;
620  Bool      m_RCEnableRateControl;                ///< enable rate control or not
621  Int       m_RCTargetBitrate;                    ///< target bitrate when rate control is enabled
622  Int       m_RCKeepHierarchicalBit;              ///< 0: equal bit allocation; 1: fixed ratio bit allocation; 2: adaptive ratio bit allocation
623  Bool      m_RCLCULevelRC;                       ///< true: LCU level rate control; false: picture level rate control NOTE: code-tidy - rename to m_RCCtuLevelRC
624  Bool      m_RCUseLCUSeparateModel;              ///< use separate R-lambda model at LCU level                        NOTE: code-tidy - rename to m_RCUseCtuSeparateModel
625  Int       m_RCInitialQP;                        ///< inital QP for rate control
626  Bool      m_RCForceIntraQP;                     ///< force all intra picture to use initial QP or not
627  Bool      m_RCCpbSaturationEnabled;             ///< enable target bits saturation to avoid CPB overflow and underflow
628  UInt      m_RCCpbSize;                          ///< CPB size
629  Double    m_RCInitialCpbFullness;               ///< initial CPB fullness
630
631#if KWU_RC_VIEWRC_E0227
632  vector<Int>     m_viewTargetBits;
633  Bool      m_viewWiseRateCtrl;                              ///< Flag for using view-wise rate control
634#endif
635#if KWU_RC_MADPRED_E0227
636  UInt       m_depthMADPred;
637#endif
638
639  ScalingListMode m_useScalingListId;                         ///< using quantization matrix
640  std::string m_scalingListFileName;                          ///< quantization matrix file name
641
642  Bool      m_TransquantBypassEnabledFlag;                    ///< transquant_bypass_enabled_flag setting in PPS.
643  Bool      m_CUTransquantBypassFlagForce;                    ///< if transquant_bypass_enabled_flag, then, if true, all CU transquant bypass flags will be set to true.
644  CostMode  m_costMode;                                       ///< Cost mode to use
645
646  Bool      m_recalculateQPAccordingToLambda;                 ///< recalculate QP value according to the lambda value
647  Bool      m_useStrongIntraSmoothing;                        ///< enable strong intra smoothing for 32x32 blocks where the reference samples are flat
648  Int       m_activeParameterSetsSEIEnabled;
649
650  Bool      m_vuiParametersPresentFlag;                       ///< enable generation of VUI parameters
651  Bool      m_aspectRatioInfoPresentFlag;                     ///< Signals whether aspect_ratio_idc is present
652  Int       m_aspectRatioIdc;                                 ///< aspect_ratio_idc
653  Int       m_sarWidth;                                       ///< horizontal size of the sample aspect ratio
654  Int       m_sarHeight;                                      ///< vertical size of the sample aspect ratio
655  Bool      m_overscanInfoPresentFlag;                        ///< Signals whether overscan_appropriate_flag is present
656  Bool      m_overscanAppropriateFlag;                        ///< Indicates whether conformant decoded pictures are suitable for display using overscan
657  Bool      m_videoSignalTypePresentFlag;                     ///< Signals whether video_format, video_full_range_flag, and colour_description_present_flag are present
658  Int       m_videoFormat;                                    ///< Indicates representation of pictures
659  Bool      m_videoFullRangeFlag;                             ///< Indicates the black level and range of luma and chroma signals
660  Bool      m_colourDescriptionPresentFlag;                   ///< Signals whether colour_primaries, transfer_characteristics and matrix_coefficients are present
661  Int       m_colourPrimaries;                                ///< Indicates chromaticity coordinates of the source primaries
662  Int       m_transferCharacteristics;                        ///< Indicates the opto-electronic transfer characteristics of the source
663  Int       m_matrixCoefficients;                             ///< Describes the matrix coefficients used in deriving luma and chroma from RGB primaries
664  Bool      m_chromaLocInfoPresentFlag;                       ///< Signals whether chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field are present
665  Int       m_chromaSampleLocTypeTopField;                    ///< Specifies the location of chroma samples for top field
666  Int       m_chromaSampleLocTypeBottomField;                 ///< Specifies the location of chroma samples for bottom field
667  Bool      m_neutralChromaIndicationFlag;                    ///< Indicates that the value of all decoded chroma samples is equal to 1<<(BitDepthCr-1)
668  Bool      m_defaultDisplayWindowFlag;                       ///< Indicates the presence of the default window parameters
669  Int       m_defDispWinLeftOffset;                           ///< Specifies the left offset from the conformance window of the default window
670  Int       m_defDispWinRightOffset;                          ///< Specifies the right offset from the conformance window of the default window
671  Int       m_defDispWinTopOffset;                            ///< Specifies the top offset from the conformance window of the default window
672  Int       m_defDispWinBottomOffset;                         ///< Specifies the bottom offset from the conformance window of the default window
673  Bool      m_frameFieldInfoPresentFlag;                      ///< Indicates that pic_struct values are present in picture timing SEI messages
674  Bool      m_pocProportionalToTimingFlag;                    ///< Indicates that the POC value is proportional to the output time w.r.t. first picture in CVS
675  Int       m_numTicksPocDiffOneMinus1;                       ///< Number of ticks minus 1 that for a POC difference of one
676  Bool      m_bitstreamRestrictionFlag;                       ///< Signals whether bitstream restriction parameters are present
677  Bool      m_tilesFixedStructureFlag;                        ///< Indicates that each active picture parameter set has the same values of the syntax elements related to tiles
678  Bool      m_motionVectorsOverPicBoundariesFlag;             ///< Indicates that no samples outside the picture boundaries are used for inter prediction
679  Int       m_minSpatialSegmentationIdc;                      ///< Indicates the maximum size of the spatial segments in the pictures in the coded video sequence
680  Int       m_maxBytesPerPicDenom;                            ///< Indicates a number of bytes not exceeded by the sum of the sizes of the VCL NAL units associated with any coded picture
681  Int       m_maxBitsPerMinCuDenom;                           ///< Indicates an upper bound for the number of bits of coding_unit() data
682  Int       m_log2MaxMvLengthHorizontal;                      ///< Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units
683  Int       m_log2MaxMvLengthVertical;                        ///< Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units
684  std::string m_colourRemapSEIFileRoot;
685
686  std::string m_summaryOutFilename;                           ///< filename to use for producing summary output file.
687  std::string m_summaryPicFilenameBase;                       ///< Base filename to use for producing summary picture output files. The actual filenames used will have I.txt, P.txt and B.txt appended.
688  UInt        m_summaryVerboseness;                           ///< Specifies the level of the verboseness of the text output.
689
690#if EXTENSION_360_VIDEO
691  TExt360AppEncCfg m_ext360;
692  friend class TExt360AppEncCfg;
693  friend class TExt360AppEncTop;
694#endif
695
696#if NH_MV
697  Bool              m_outputVpsInfo;
698  TChar*            m_pchBaseViewCameraNumbers;
699#endif
700
701#if NH_3D
702  // Output Format
703  Bool      m_depth420OutputFlag;                             ///< Output depth layers in 4:2:0 format
704#endif
705
706#if NH_3D || NH_3D_VSO
707    // Camera parameters
708  TChar*    m_pchCameraParameterFile;                         ///< camera parameter file
709  TAppComCamPara m_cCameraData;
710  Int       m_iCodedCamParPrecision;                          ///< precision for coding of camera parameters
711#endif
712#if NH_3D_VSO
713  TChar*    m_pchVSOConfig;
714  Bool      m_bUseVSO;                                        ///< flag for using View Synthesis Optimization
715  Bool      m_bVSOLSTable;                                    ///< Depth QP dependent Lagrange parameter optimization (m23714)
716  Bool      m_bVSOEarlySkip;                                  ///< Early skip of VSO computation (JCT3V-A0093 modification 4)
717                                                             
718  //// Used for development by GT, might be removed later     
719  Double    m_dLambdaScaleVSO;                                ///< Scaling factor for Lambda in VSO mode
720  Bool      m_bForceLambdaScaleVSO;                           ///< Use Lambda Scale for depth even if VSO is turned off
721  Bool      m_bAllowNegDist;                                  ///< Allow negative distortion in VSO
722  UInt      m_uiVSOMode;                                      ///< Number of VSO Mode, 1 = , 2 = simple, org vs. ren, 3 = simple, ren vs. ren, 4 = full 
723                                                             
724  // SAIT_VSO_EST_A0033                                       
725  Bool      m_bUseEstimatedVSD;                               ///< Flag for using model based VSD estimation instead of VSO for some encoder decisions (JCT3V-A0033 modification 3) 
726                                                             
727  // LGE_WVSO_A0119                                           
728  Bool      m_bUseWVSO;                                       ///< flag for using View Synthesis Optimization 
729  Int       m_iVSOWeight;
730  Int       m_iVSDWeight;
731  Int       m_iDWeight;
732
733  // Ren Model String
734  TRenModSetupStrParser       m_cRenModStrParser;
735#endif
736#if NH_3D
737  Bool       m_useDLT;                                        ///< flag for using DLT
738  Bool       m_bUseQTL;                                        ///< flag for using depth QuadTree Limitation
739
740  BoolAry1d  m_ivMvPredFlag;
741  BoolAry1d  m_ivMvScalingFlag;
742  Int        m_log2SubPbSizeMinus3;
743  Bool       m_ivResPredFlag;
744  Bool       m_depthRefinementFlag;
745  Bool       m_viewSynthesisPredFlag;
746  Bool       m_depthBasedBlkPartFlag;
747  Bool       m_mpiFlag;
748  Int        m_log2MpiSubPbSizeMinus3;
749  Bool       m_intraContourFlag;
750  Bool       m_intraWedgeFlag;
751  Bool       m_intraSdcFlag;
752  Bool       m_qtPredFlag;
753  Bool       m_interSdcFlag;
754  Bool       m_depthIntraSkipFlag; 
755#endif
756  // internal member functions
757  Void  xCheckParameter ();                                   ///< check validity of configuration values
758  Void  xPrintParameter ();                                   ///< print configuration values 
759 
760  Void  xPrintUsage     ();                                   ///< print usage
761#if NH_MV
762  Void xConfirmRepFormat( const TComVPS& vps);
763  Void xDeriveProfAndConstrFlags( const TComVPS& vps ); 
764  Void xCheckProfiles           ( const TComVPS& vps ); 
765
766  Void xPrintProfiles();
767
768  template< typename T >
769  Void xConfirmSingleRepFormat(Bool& checkFailed, std::string name, Int curLayer, Int refLayer, T valCur, T valRef )
770  {
771    if ( valCur != valRef )
772    {
773      printf("Error: %s of layer %d and its reference layer %d must be equal. \n", name.c_str(), curLayer, refLayer ); 
774      checkFailed = true; 
775    }
776  }
777
778  GOPEntry*  xGetGopEntries( Int layerIdInVps );
779  GOPEntry*  xGetGopEntry( Int layerIdInVps, Int poc );
780
781  template<typename T>
782  Void xReadStrToEnum(string in, std::vector<T> &val)
783  {
784    val.clear(); 
785
786    char* cElement = NULL;
787    char* cString = new char[in.size()+1];
788    strcpy(cString, in.c_str());
789
790    cElement = strtok( cString, " " );
791    while ( cElement != NULL )
792    {
793      T profile;       
794      std::istringstream ss( cElement ); 
795      ss >> profile; 
796      val.push_back( profile ); 
797      cElement = strtok( NULL, " " );
798    }
799    delete[] cString;
800  }
801
802
803  template <typename T>
804  Void xResizeVector(  std::vector<T> & rpcVector )
805  {
806    for( Int layer = 0; rpcVector.size() < m_numberOfLayers; layer++ )
807    {
808      assert( rpcVector.size() > 0 );
809      rpcVector.push_back( rpcVector[layer] );     
810    }
811
812    for( ; rpcVector.size() > m_numberOfLayers; )
813    {     
814      rpcVector.pop_back( );     
815    }
816  }
817
818  template <typename T>
819  Void xResizeVector(  std::vector<T> & rpcVector, UInt n )
820  {
821    for( Int layer = 0; rpcVector.size() < n; layer++ )
822    {
823      assert( rpcVector.size() > 0 );
824      rpcVector.push_back( rpcVector[layer] );     
825    }
826
827    for( ; rpcVector.size() > n; )
828    {     
829      rpcVector.pop_back( );     
830    }
831  }
832
833
834  template <typename T>
835  Void xPrintParaVector( std::string description, std::vector<T> & rpcVector )
836  {
837    Int iSpace = max(1, ENC_CFG_CONSOUT_SPACE - (Int) description.length() ); 
838   
839    for ( Int i = 0; i < iSpace; i++ )
840    {
841      description.append( " " ); 
842    }
843     
844    description.append( ":" ); 
845    printf( "%s", description.c_str() ); 
846
847    for(Int i=0;i<rpcVector.size();i++)
848    {
849      xPrintVectorElem( rpcVector[i] );
850    }
851
852    printf("\n");
853  }
854 
855  Void xPrintVectorElem( UInt   elem ) { printf(" %d"   , elem            );};
856  Void xPrintVectorElem( Int    elem ) { printf(" %d"   , elem            );};
857 
858  Void xPrintVectorElem( Double elem ) { printf(" %5.2f", elem            );}; 
859  Void xPrintVectorElem( Bool   elem ) { printf(" %d"   , ( elem ? 1 : 0 ));};
860  Void xParseSeiCfg();
861
862  Int   getGOPSize() { return m_iGOPSize; }
863#endif
864public:
865  TAppEncCfg();
866  virtual ~TAppEncCfg();
867
868public:
869  Void  create    ();                                         ///< create option handling class
870  Void  destroy   ();                                         ///< destroy option handling class
871  Bool  parseCfg  ( Int argc, TChar* argv[] );                ///< parse configuration file to fill member variables
872
873private:
874  Void   xConvertRepFormatParameters(
875    IntAry2d& tmpPad                       ,             
876    IntAry2d& tmpInputBitDepth             ,
877    IntAry2d& tmpOutputBitDepth            ,
878    IntAry2d& tmpMSBExtendedBitDepth       ,
879    IntAry2d& tmpInternalBitDepth          ,
880    IntAry1d& tmpInputChromaFormat         ,
881    IntAry1d& tmpChromaFormat
882    );
883
884  Void xGetMaxValuesOfApplicableLayers(const TComVPS& vps, Int vpsPtlIdx, Int& maxBitDepthLuma, Int& maxBitDepthChroma, ChromaFormat& maxChromaFormatIdc, Int& maxNumRefLayers);
885};// END CLASS DEFINITION TAppEncCfg
886
887//! \}
888
889#endif // __TAPPENCCFG__
890
Note: See TracBrowser for help on using the repository browser.