source: 3DVCSoftware/branches/HTM-DEV-2.0-dev1-Fix/source/App/TAppEncoder/TAppEncCfg.h @ 713

Last change on this file since 713 was 539, checked in by orange, 11 years ago

Integrated QTLPC and added new line mark at the end of TComWedgelet.cpp for MERL

  • Property svn:eol-style set to native
File size: 29.1 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license. 
5 *
6 * Copyright (c) 2010-2013, 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#include <sstream>
45#if H_3D
46#include "TAppCommon/TAppComCamPara.h"
47#include "TLibRenderer/TRenModel.h"
48#include "TLibRenderer/TRenModSetupStrParser.h"
49#endif
50//! \ingroup TAppEncoder
51//! \{
52
53// ====================================================================================================================
54// Class definition
55// ====================================================================================================================
56
57/// encoder configuration class
58class TAppEncCfg
59{
60protected:
61  // file I/O
62#if H_MV
63  std::vector<char*>     m_pchInputFileList;                  ///< source file names
64#else
65  Char*     m_pchInputFile;                                   ///< source file name
66#endif
67  Char*     m_pchBitstreamFile;                               ///< output bitstream file
68#if H_MV
69  std::vector<char*>     m_pchReconFileList;                  ///< output reconstruction file names
70  Int                    m_numberOfLayers;                    ///< number of Layers to Encode
71#if H_3D
72  Int                    m_iNumberOfViews;                    ///< number of Layers that are views
73#endif
74#else
75  Char*     m_pchReconFile;                                   ///< output reconstruction file
76#endif
77  #if H_MV
78// VPS specification
79  std::vector< std::vector<Int> > m_dimIds;                   ///< dimension ids ( pointers to m_viewId and m_depthFlag
80  std::vector<Int>       m_viewId;                            ///< view id
81#if H_3D
82  std::vector<Int>       m_depthFlag;                         ///< depth flag
83#endif
84  std::vector<Int>       m_layerIdInNuh;                      ///< layer Id in Nuh for each layer
85  Bool                   m_splittingFlag;                     ///< Splitting Flag
86  Int                    m_scalabilityMask;                   ///< Mask indicating scalabilities, 1: texture; 3: texture + depth                                                               
87  std::vector<Int>       m_dimensionIdLen;                    ///< Length of scalability dimension s
88 
89// layer sets   
90  Int                    m_vpsNumLayerSets;                   ///< Number of layer sets
91  std::vector< std::vector<Int> > m_layerIdsInSets;           ///< LayerIds in vps of layer set
92  Bool                   m_defaultOneTargetOutputLayerFlag;   ///< Output highest layer of layer sets by default 
93  std::vector<Int>       m_outputLayerSetIdx;                 ///< Indices of layer sets used as additional output layer sets 
94  std::vector< std::vector<Int> > m_layerIdsInAddOutputLayerSet; ///< LayerIds in vps of additional output layers
95  std::vector<Int>       m_profileLevelTierIdx;               ///< Indices of of profile level tier
96 
97  // Dependencies
98  std::vector< std::vector<Int> > m_directRefLayers;          ///< LayerIds of direct reference layers
99  std::vector< std::vector<Int> > m_dependencyTypes;          ///< Dependency types of direct reference layers
100
101#if H_3D_IV_MERGE
102  Bool                   m_ivMvPredFlag;                      ///< Interview motion vector prediction
103#endif
104#if H_3D_ARP                                                  /// < flag and number of weighting factors in ARP
105  UInt                   m_uiUseAdvResPred;
106  UInt                   m_uiARPStepNum;
107#endif
108#if H_3D_IC
109  vector<Bool> m_abUseIC;                                    ///< flag for using illumination compensation for inter-view prediction
110#endif
111#if H_3D_NBDV_REF
112  Bool m_depthRefinementFlag; 
113#endif
114#if H_3D_VSP
115  Bool m_viewSynthesisPredFlag;
116#endif
117#if H_3D_TMVP
118  Bool m_ivMvScalingFlag; 
119#endif
120#endif
121  Double    m_adLambdaModifier[ MAX_TLAYER ];                 ///< Lambda modifier array for each temporal layer
122  // source specification
123  Int       m_iFrameRate;                                     ///< source frame-rates (Hz)
124  UInt      m_FrameSkip;                                      ///< number of skipped frames from the beginning
125  Int       m_iSourceWidth;                                   ///< source width in pixel
126  Int       m_iSourceHeight;                                  ///< source height in pixel
127  Int       m_conformanceMode;
128  Int       m_confLeft;
129  Int       m_confRight;
130  Int       m_confTop;
131  Int       m_confBottom;
132  Int       m_framesToBeEncoded;                              ///< number of encoded frames
133  Int       m_aiPad[2];                                       ///< number of padded pixels for width and height
134 
135  // profile/level
136  Profile::Name m_profile;
137  Level::Tier   m_levelTier;
138  Level::Name   m_level;
139  Bool m_progressiveSourceFlag;
140  Bool m_interlacedSourceFlag;
141  Bool m_nonPackedConstraintFlag;
142  Bool m_frameOnlyConstraintFlag;
143 
144  // coding structure
145  Int       m_iIntraPeriod;                                   ///< period of I-slice (random access period)
146  Int       m_iDecodingRefreshType;                           ///< random access type
147  Int       m_iGOPSize;                                       ///< GOP size of hierarchical structure
148#if H_MV
149  Int       m_extraRPSsMvc[MAX_NUM_LAYERS];                       ///< extra RPSs added to handle CRA for each layer
150  std::vector< GOPEntry* >  m_GOPListMvc;                            ///< the coding structure entries from the config file for each layer
151  Int       m_numReorderPicsMvc[MAX_NUM_LAYERS][MAX_TLAYER];      ///< total number of reorder pictures for each layer
152  Int       m_maxDecPicBufferingMvc[MAX_NUM_LAYERS][MAX_TLAYER];  ///< total number of reference pictures needed for decoding for each layer
153#else
154  Int       m_extraRPSs;                                      ///< extra RPSs added to handle CRA
155  GOPEntry  m_GOPList[MAX_GOP];                               ///< the coding structure entries from the config file
156  Int       m_numReorderPics[MAX_TLAYER];                     ///< total number of reorder pictures
157  Int       m_maxDecPicBuffering[MAX_TLAYER];                 ///< total number of pictures in the decoded picture buffer
158  #endif
159  Bool      m_useTransformSkip;                               ///< flag for enabling intra transform skipping
160  Bool      m_useTransformSkipFast;                           ///< flag for enabling fast intra transform skipping
161  Bool      m_enableAMP;
162  // coding quality
163#if H_MV
164  std::vector<Double>  m_fQP;                                 ///< QP value of key-picture (floating point) for each layer
165  std::vector<Int>     m_iQP;                                 ///< QP value of key-picture (integer) for each layer
166#else
167  Double    m_fQP;                                            ///< QP value of key-picture (floating point)
168  Int       m_iQP;                                            ///< QP value of key-picture (integer)
169#endif
170  Char*     m_pchdQPFile;                                     ///< QP offset for each slice (initialized from external file)
171#if H_MV
172  std::vector<Int*> m_aidQP;                                    ///< array of slice QP values for each layer
173#else
174  Int*      m_aidQP;                                          ///< array of slice QP values
175#endif
176  Int       m_iMaxDeltaQP;                                    ///< max. |delta QP|
177  UInt      m_uiDeltaQpRD;                                    ///< dQP range for multi-pass slice QP optimization
178  Int       m_iMaxCuDQPDepth;                                 ///< Max. depth for a minimum CuDQPSize (0:default)
179
180  Int       m_cbQpOffset;                                     ///< Chroma Cb QP Offset (0:default)
181  Int       m_crQpOffset;                                     ///< Chroma Cr QP Offset (0:default)
182
183#if ADAPTIVE_QP_SELECTION
184  Bool      m_bUseAdaptQpSelect;
185#endif
186
187  Bool      m_bUseAdaptiveQP;                                 ///< Flag for enabling QP adaptation based on a psycho-visual model
188  Int       m_iQPAdaptationRange;                             ///< dQP range by QP adaptation
189 
190#if H_MV
191  Int       m_maxTempLayerMvc[MAX_NUM_LAYER_IDS];             ///< Max temporal layer for each layer
192#else
193  Int       m_maxTempLayer;                                  ///< Max temporal layer
194#endif
195
196  // coding unit (CU) definition
197  UInt      m_uiMaxCUWidth;                                   ///< max. CU width in pixel
198  UInt      m_uiMaxCUHeight;                                  ///< max. CU height in pixel
199  UInt      m_uiMaxCUDepth;                                   ///< max. CU depth
200 
201  // transfom unit (TU) definition
202  UInt      m_uiQuadtreeTULog2MaxSize;
203  UInt      m_uiQuadtreeTULog2MinSize;
204 
205  UInt      m_uiQuadtreeTUMaxDepthInter;
206  UInt      m_uiQuadtreeTUMaxDepthIntra;
207 
208  // coding tools (bit-depth)
209  Int       m_inputBitDepthY;                               ///< bit-depth of input file (luma component)
210  Int       m_inputBitDepthC;                               ///< bit-depth of input file (chroma component)
211  Int       m_outputBitDepthY;                              ///< bit-depth of output file (luma component)
212  Int       m_outputBitDepthC;                              ///< bit-depth of output file (chroma component)
213  Int       m_internalBitDepthY;                            ///< bit-depth codec operates at in luma (input/output files will be converted)
214  Int       m_internalBitDepthC;                            ///< bit-depth codec operates at in chroma (input/output files will be converted)
215
216  // coding tools (PCM bit-depth)
217  Bool      m_bPCMInputBitDepthFlag;                          ///< 0: PCM bit-depth is internal bit-depth. 1: PCM bit-depth is input bit-depth.
218
219  // coding tool (lossless)
220  Bool      m_useLossless;                                    ///< flag for using lossless coding
221#if H_MV
222  std::vector<Bool> m_bUseSAO; 
223#else
224  Bool      m_bUseSAO; 
225#endif
226  Int       m_maxNumOffsetsPerPic;                            ///< SAO maximun number of offset per picture
227  Bool      m_saoLcuBoundary;                                 ///< SAO parameter estimation using non-deblocked pixels for LCU bottom and right boundary areas
228  Bool      m_saoLcuBasedOptimization;                        ///< SAO LCU-based optimization
229  // coding tools (loop filter)
230#if H_MV
231  std::vector<Bool> m_bLoopFilterDisable;                     ///< flag for using deblocking filter for each layer
232#else
233  Bool      m_bLoopFilterDisable;                             ///< flag for using deblocking filter
234#endif
235  Bool      m_loopFilterOffsetInPPS;                         ///< offset for deblocking filter in 0 = slice header, 1 = PPS
236  Int       m_loopFilterBetaOffsetDiv2;                     ///< beta offset for deblocking filter
237  Int       m_loopFilterTcOffsetDiv2;                       ///< tc offset for deblocking filter
238  Bool      m_DeblockingFilterControlPresent;                 ///< deblocking filter control present flag in PPS
239  Bool      m_DeblockingFilterMetric;                         ///< blockiness metric in encoder
240 
241  // coding tools (PCM)
242  Bool      m_usePCM;                                         ///< flag for using IPCM
243  UInt      m_pcmLog2MaxSize;                                 ///< log2 of maximum PCM block size
244  UInt      m_uiPCMLog2MinSize;                               ///< log2 of minimum PCM block size
245  Bool      m_bPCMFilterDisableFlag;                          ///< PCM filter disable flag
246
247  // coding tools (encoder-only parameters)
248  Bool      m_bUseSBACRD;                                     ///< flag for using RD optimization based on SBAC
249  Bool      m_bUseASR;                                        ///< flag for using adaptive motion search range
250  Bool      m_bUseHADME;                                      ///< flag for using HAD in sub-pel ME
251  Bool      m_useRDOQ;                                       ///< flag for using RD optimized quantization
252  Bool      m_useRDOQTS;                                     ///< flag for using RD optimized quantization for transform skip
253  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)
254  Int       m_iFastSearch;                                    ///< ME mode, 0 = full, 1 = diamond, 2 = PMVFAST
255  Int       m_iSearchRange;                                   ///< ME search range
256  Int       m_bipredSearchRange;                              ///< ME search range for bipred refinement
257  Bool      m_bUseFastEnc;                                    ///< flag for using fast encoder setting
258  Bool      m_bUseEarlyCU;                                    ///< flag for using Early CU setting
259  Bool      m_useFastDecisionForMerge;                        ///< flag for using Fast Decision Merge RD-Cost
260  Bool      m_bUseCbfFastMode;                              ///< flag for using Cbf Fast PU Mode Decision
261  Bool      m_useEarlySkipDetection;                         ///< flag for using Early SKIP Detection
262  Int       m_sliceMode;                                     ///< 0: no slice limits, 1 : max number of CTBs per slice, 2: max number of bytes per slice,
263                                                             ///< 3: max number of tiles per slice
264  Int       m_sliceArgument;                                 ///< argument according to selected slice mode
265  Int       m_sliceSegmentMode;                              ///< 0: no slice segment limits, 1 : max number of CTBs per slice segment, 2: max number of bytes per slice segment,
266                                                             ///< 3: max number of tiles per slice segment
267  Int       m_sliceSegmentArgument;                          ///< argument according to selected slice segment mode
268
269  Bool      m_bLFCrossSliceBoundaryFlag;  ///< 1: filter across slice boundaries 0: do not filter across slice boundaries
270  Bool      m_bLFCrossTileBoundaryFlag;   ///< 1: filter across tile boundaries  0: do not filter across tile boundaries
271  Int       m_iUniformSpacingIdr;
272  Int       m_iNumColumnsMinus1;
273  Char*     m_pchColumnWidth;
274  Int       m_iNumRowsMinus1;
275  Char*     m_pchRowHeight;
276  UInt*     m_pColumnWidth;
277  UInt*     m_pRowHeight;
278  Int       m_iWaveFrontSynchro; //< 0: no WPP. >= 1: WPP is enabled, the "Top right" from which inheritance occurs is this LCU offset in the line above the current.
279  Int       m_iWaveFrontSubstreams; //< If iWaveFrontSynchro, this is the number of substreams per frame (dependent tiles) or per tile (independent tiles).
280
281  Bool      m_bUseConstrainedIntraPred;                       ///< flag for using constrained intra prediction
282 
283  Int       m_decodedPictureHashSEIEnabled;                    ///< Checksum(3)/CRC(2)/MD5(1)/disable(0) acting on decoded picture hash SEI message
284  Int       m_recoveryPointSEIEnabled;
285  Int       m_bufferingPeriodSEIEnabled;
286  Int       m_pictureTimingSEIEnabled;
287  Bool      m_toneMappingInfoSEIEnabled;
288  Int       m_toneMapId;
289  Bool      m_toneMapCancelFlag;
290  Bool      m_toneMapPersistenceFlag;
291  Int       m_toneMapCodedDataBitDepth;
292  Int       m_toneMapTargetBitDepth;
293  Int       m_toneMapModelId; 
294  Int       m_toneMapMinValue;
295  Int       m_toneMapMaxValue;
296  Int       m_sigmoidMidpoint;
297  Int       m_sigmoidWidth;
298  Int       m_numPivots;
299  Int       m_cameraIsoSpeedIdc;
300  Int       m_cameraIsoSpeedValue;
301  Int       m_exposureCompensationValueSignFlag;
302  Int       m_exposureCompensationValueNumerator;
303  Int       m_exposureCompensationValueDenomIdc;
304  Int       m_refScreenLuminanceWhite;
305  Int       m_extendedRangeWhiteLevel;
306  Int       m_nominalBlackLevelLumaCodeValue;
307  Int       m_nominalWhiteLevelLumaCodeValue;
308  Int       m_extendedWhiteLevelLumaCodeValue;
309  Int*      m_startOfCodedInterval;
310  Int*      m_codedPivotValue;
311  Int*      m_targetPivotValue;
312  Int       m_framePackingSEIEnabled;
313  Int       m_framePackingSEIType;
314  Int       m_framePackingSEIId;
315  Int       m_framePackingSEIQuincunx;
316  Int       m_framePackingSEIInterpretation;
317  Int       m_displayOrientationSEIAngle;
318  Int       m_temporalLevel0IndexSEIEnabled;
319  Int       m_gradualDecodingRefreshInfoEnabled;
320  Int       m_decodingUnitInfoSEIEnabled;
321  Int       m_SOPDescriptionSEIEnabled;
322  Int       m_scalableNestingSEIEnabled;
323  // weighted prediction
324  Bool      m_useWeightedPred;                    ///< Use of weighted prediction in P slices
325  Bool      m_useWeightedBiPred;                  ///< Use of bi-directional weighted prediction in B slices
326 
327  UInt      m_log2ParallelMergeLevel;                         ///< Parallel merge estimation region
328  UInt      m_maxNumMergeCand;                                ///< Max number of merge candidates
329
330  Int       m_TMVPModeId;
331  Int       m_signHideFlag;
332#if RATE_CONTROL_LAMBDA_DOMAIN
333  Bool      m_RCEnableRateControl;                ///< enable rate control or not
334  Int       m_RCTargetBitrate;                    ///< target bitrate when rate control is enabled
335#if M0036_RC_IMPROVEMENT
336  Int       m_RCKeepHierarchicalBit;              ///< 0: equal bit allocation; 1: fixed ratio bit allocation; 2: adaptive ratio bit allocation
337#else
338  Bool      m_RCKeepHierarchicalBit;              ///< whether keeping hierarchical bit allocation structure or not
339#endif
340  Bool      m_RCLCULevelRC;                       ///< true: LCU level rate control; false: picture level rate control
341  Bool      m_RCUseLCUSeparateModel;              ///< use separate R-lambda model at LCU level
342  Int       m_RCInitialQP;                        ///< inital QP for rate control
343  Bool      m_RCForceIntraQP;                     ///< force all intra picture to use initial QP or not
344#else
345  Bool      m_enableRateCtrl;                                   ///< Flag for using rate control algorithm
346  Int       m_targetBitrate;                                 ///< target bitrate
347  Int       m_numLCUInUnit;                                  ///< Total number of LCUs in a frame should be completely divided by the NumLCUInUnit
348#endif
349  Int       m_useScalingListId;                               ///< using quantization matrix
350  Char*     m_scalingListFile;                                ///< quantization matrix file name
351
352  Bool      m_TransquantBypassEnableFlag;                     ///< transquant_bypass_enable_flag setting in PPS.
353  Bool      m_CUTransquantBypassFlagValue;                    ///< if transquant_bypass_enable_flag, the fixed value to use for the per-CU cu_transquant_bypass_flag.
354
355  Bool      m_recalculateQPAccordingToLambda;                 ///< recalculate QP value according to the lambda value
356  Bool      m_useStrongIntraSmoothing;                        ///< enable strong intra smoothing for 32x32 blocks where the reference samples are flat
357  Int       m_activeParameterSetsSEIEnabled;
358
359  Bool      m_vuiParametersPresentFlag;                       ///< enable generation of VUI parameters
360  Bool      m_aspectRatioInfoPresentFlag;                     ///< Signals whether aspect_ratio_idc is present
361  Int       m_aspectRatioIdc;                                 ///< aspect_ratio_idc
362  Int       m_sarWidth;                                       ///< horizontal size of the sample aspect ratio
363  Int       m_sarHeight;                                      ///< vertical size of the sample aspect ratio
364  Bool      m_overscanInfoPresentFlag;                        ///< Signals whether overscan_appropriate_flag is present
365  Bool      m_overscanAppropriateFlag;                        ///< Indicates whether conformant decoded pictures are suitable for display using overscan
366  Bool      m_videoSignalTypePresentFlag;                     ///< Signals whether video_format, video_full_range_flag, and colour_description_present_flag are present
367  Int       m_videoFormat;                                    ///< Indicates representation of pictures
368  Bool      m_videoFullRangeFlag;                             ///< Indicates the black level and range of luma and chroma signals
369  Bool      m_colourDescriptionPresentFlag;                   ///< Signals whether colour_primaries, transfer_characteristics and matrix_coefficients are present
370  Int       m_colourPrimaries;                                ///< Indicates chromaticity coordinates of the source primaries
371  Int       m_transferCharacteristics;                        ///< Indicates the opto-electronic transfer characteristics of the source
372  Int       m_matrixCoefficients;                             ///< Describes the matrix coefficients used in deriving luma and chroma from RGB primaries
373  Bool      m_chromaLocInfoPresentFlag;                       ///< Signals whether chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field are present
374  Int       m_chromaSampleLocTypeTopField;                    ///< Specifies the location of chroma samples for top field
375  Int       m_chromaSampleLocTypeBottomField;                 ///< Specifies the location of chroma samples for bottom field
376  Bool      m_neutralChromaIndicationFlag;                    ///< Indicates that the value of all decoded chroma samples is equal to 1<<(BitDepthCr-1)
377  Bool      m_defaultDisplayWindowFlag;                       ///< Indicates the presence of the default window parameters
378  Int       m_defDispWinLeftOffset;                           ///< Specifies the left offset from the conformance window of the default window
379  Int       m_defDispWinRightOffset;                          ///< Specifies the right offset from the conformance window of the default window
380  Int       m_defDispWinTopOffset;                            ///< Specifies the top offset from the conformance window of the default window
381  Int       m_defDispWinBottomOffset;                         ///< Specifies the bottom offset from the conformance window of the default window
382  Bool      m_frameFieldInfoPresentFlag;                      ///< Indicates that pic_struct values are present in picture timing SEI messages
383  Bool      m_pocProportionalToTimingFlag;                    ///< Indicates that the POC value is proportional to the output time w.r.t. first picture in CVS
384  Int       m_numTicksPocDiffOneMinus1;                       ///< Number of ticks minus 1 that for a POC difference of one
385  Bool      m_bitstreamRestrictionFlag;                       ///< Signals whether bitstream restriction parameters are present
386  Bool      m_tilesFixedStructureFlag;                        ///< Indicates that each active picture parameter set has the same values of the syntax elements related to tiles
387  Bool      m_motionVectorsOverPicBoundariesFlag;             ///< Indicates that no samples outside the picture boundaries are used for inter prediction
388  Int       m_minSpatialSegmentationIdc;                      ///< Indicates the maximum size of the spatial segments in the pictures in the coded video sequence
389  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
390  Int       m_maxBitsPerMinCuDenom;                           ///< Indicates an upper bound for the number of bits of coding_unit() data
391  Int       m_log2MaxMvLengthHorizontal;                      ///< Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units
392  Int       m_log2MaxMvLengthVertical;                        ///< Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units
393
394#if H_3D
395  // Camera parameters
396  Char*     m_pchCameraParameterFile;                         ///< camera parameter file
397  Char*     m_pchBaseViewCameraNumbers;
398  TAppComCamPara m_cCameraData;
399  Int       m_iCodedCamParPrecision;                          ///< precision for coding of camera parameters
400#if H_3D_VSO
401  Char*     m_pchVSOConfig;
402  Bool      m_bUseVSO;                                    ///< flag for using View Synthesis Optimization
403  Bool      m_bVSOLSTable;                                ///< Depth QP dependent Lagrange parameter optimization (m23714)
404  Bool      m_bVSOEarlySkip;                              ///< Early skip of VSO computation (JCT3V-A0093 modification 4)
405
406  //// Used for development by GT, might be removed later
407  Double    m_dLambdaScaleVSO;                            ///< Scaling factor for Lambda in VSO mode
408  Bool      m_bForceLambdaScaleVSO;                       ///< Use Lambda Scale for depth even if VSO is turned off
409  Bool      m_bAllowNegDist;                              ///< Allow negative distortion in VSO
410  UInt      m_uiVSOMode;                                  ///< Number of VSO Mode, 1 = , 2 = simple, org vs. ren, 3 = simple, ren vs. ren, 4 = full 
411
412  // SAIT_VSO_EST_A0033
413  Bool      m_bUseEstimatedVSD;                           ///< Flag for using model based VSD estimation instead of VSO for some encoder decisions (JCT3V-A0033 modification 3) 
414
415  // LGE_WVSO_A0119
416  Bool      m_bUseWVSO;                                    ///< flag for using View Synthesis Optimization 
417  Int       m_iVSOWeight;
418  Int       m_iVSDWeight;
419  Int       m_iDWeight;
420
421  // Ren Model String
422  TRenModSetupStrParser       m_cRenModStrParser;
423#endif
424#if H_3D_DIM
425  Bool      m_useDMM;                                        ///< flag for using DMM
426  Bool      m_useRBC;                                        ///< flag for using RBC
427  Bool      m_useSDC;                                        ///< flag for using SDC
428  Bool      m_useDLT;                                        ///< flag for using DLT
429#endif
430#if H_3D_QTLPC
431  Bool      m_bUseQTL;                                        ///< flag for using depth QuadTree Limitation
432  Bool      m_bUsePC;                                         ///< flag for using Predictive Coding with QTL
433#endif
434#endif
435  // internal member functions
436  Void  xSetGlobal      ();                                   ///< set global variables
437  Void  xCheckParameter ();                                   ///< check validity of configuration values
438  Void  xPrintParameter ();                                   ///< print configuration values
439  Void  xPrintUsage     ();                                   ///< print usage
440#if H_MV
441  template <typename T>
442  Void xResizeVector(  std::vector<T> & rpcVector )
443  {
444    for( Int layer = 0; rpcVector.size() < m_numberOfLayers; layer++ )
445    {
446      assert( rpcVector.size() > 0 );
447      rpcVector.push_back( rpcVector[layer] );     
448    }
449
450    for( ; rpcVector.size() > m_numberOfLayers; )
451    {     
452      rpcVector.pop_back( );     
453    }
454  }
455
456  template <typename T>
457  Void xPrintParaVector( std::string description, std::vector<T> & rpcVector )
458  {
459    Int iSpace = max(1, ENC_CFG_CONSOUT_SPACE - (Int) description.length() ); 
460   
461    for ( Int i = 0; i < iSpace; i++ ) 
462      description.append( " " ); 
463     
464    description.append( ":" ); 
465    printf( "%s", description.c_str() ); 
466
467    for(Int i=0;i<rpcVector.size();i++)               
468      xPrintVectorElem( rpcVector[i] );
469
470    printf("\n");
471  }
472 
473  Void xPrintVectorElem( UInt   elem ) { printf(" %d"   , elem            );};
474  Void xPrintVectorElem( Int    elem ) { printf(" %d"   , elem            );};
475 
476  Void xPrintVectorElem( Double elem ) { printf(" %5.2f", elem            );}; 
477  Void xPrintVectorElem( Bool   elem ) { printf(" %d"   , ( elem ? 1 : 0 ));};
478#endif
479#if H_MV
480  Int   getGOPSize() { return m_iGOPSize; }
481#endif
482public:
483  TAppEncCfg();
484  virtual ~TAppEncCfg();
485 
486public:
487  Void  create    ();                                         ///< create option handling class
488  Void  destroy   ();                                         ///< destroy option handling class
489  Bool  parseCfg  ( Int argc, Char* argv[] );                 ///< parse configuration file to fill member variables
490 
491};// END CLASS DEFINITION TAppEncCfg
492
493//! \}
494
495#endif // __TAPPENCCFG__
496
Note: See TracBrowser for help on using the repository browser.