Newer
Older
Karsten Suehring
committed
/* The copyright in this software is being made available under the BSD
* License, included below. This software may be subject to other third party
* and contributor rights, including patent rights, and no such rights are
* granted under this license.
*
* Copyright (c) 2010-2020, ITU/ISO/IEC
Karsten Suehring
committed
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
/** \file EncAppCfg.h
\brief Handle encoder configuration parameters (header)
*/
#ifndef __ENCAPPCFG__
#define __ENCAPPCFG__
#include "CommonLib/CommonDef.h"
#include "EncoderLib/EncCfgParam.h"
#include <map>
template <class T1, class T2>
static inline std::istream& operator >> (std::istream &in, std::map<T1, T2> &map);
Rickard Sjöberg
committed
#include "Utilities/program_options_lite.h"
Karsten Suehring
committed
#include "EncoderLib/EncCfg.h"
#if EXTENSION_360_VIDEO
#include "AppEncHelper360/TExt360AppEncCfg.h"
#endif
#if JVET_O0756_CALCULATE_HDRMETRICS
#include "HDRLib/inc/DistortionMetric.H"
#endif
Rickard Sjöberg
committed
namespace po = df::program_options_lite;
Karsten Suehring
committed
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#include <sstream>
#include <vector>
//! \ingroup EncoderApp
//! \{
// ====================================================================================================================
// Class definition
// ====================================================================================================================
/// encoder configuration class
class EncAppCfg
{
#if QP_SWITCHING_FOR_PARALLEL
public:
template <class T>
struct OptionalValue
{
bool bPresent;
T value;
OptionalValue() : bPresent(false), value() { }
};
#endif
protected:
// file I/O
std::string m_inputFileName; ///< source file name
std::string m_bitstreamFileName; ///< output bitstream file
std::string m_reconFileName; ///< output reconstruction file
// Lambda modifiers
double m_adLambdaModifier[ MAX_TLAYER ]; ///< Lambda modifier array for each temporal layer
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.
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) ))
// source specification
int m_iFrameRate; ///< source frame-rates (Hz)
uint32_t m_FrameSkip; ///< number of skipped frames from the beginning
uint32_t m_temporalSubsampleRatio; ///< temporal subsample ratio, 2 means code every two frames
int m_iSourceWidth; ///< source width in pixel
int m_iSourceHeight; ///< source height in pixel (when interlaced = field height)
#if EXTENSION_360_VIDEO
int m_inputFileWidth; ///< width of image in input file (this is equivalent to sourceWidth, if sourceWidth is not subsequently altered due to padding)
int m_inputFileHeight; ///< height of image in input file (this is equivalent to sourceHeight, if sourceHeight is not subsequently altered due to padding)
#endif
int m_iSourceHeightOrg; ///< original source height in pixel (when interlaced = frame height)
bool m_isField; ///< enable field coding
bool m_isTopFieldFirst;
bool m_bEfficientFieldIRAPEnabled; ///< enable an efficient field IRAP structure.
bool m_bHarmonizeGopFirstFieldCoupleEnabled;
int m_conformanceWindowMode;
int m_confWinLeft;
int m_confWinRight;
int m_confWinTop;
int m_confWinBottom;
int m_framesToBeEncoded; ///< number of encoded frames
int m_aiPad[2]; ///< number of padded pixels for width and height
bool m_AccessUnitDelimiter; ///< add Access Unit Delimiter NAL units
bool m_enablePictureHeaderInSliceHeader; ///< Enable Picture Header in Slice Header
Karsten Suehring
committed
InputColourSpaceConversion m_inputColourSpaceConvert; ///< colour space conversion to apply to input video
bool m_snrInternalColourSpace; ///< if true, then no colour space conversion is applied for snr calculation, otherwise inverse of input is applied.
bool m_outputInternalColourSpace; ///< if true, then no colour space conversion is applied for reconstructed video, otherwise inverse of input is applied.
ChromaFormat m_InputChromaFormatIDC;
bool m_printMSEBasedSequencePSNR;
bool m_printHexPsnr;
bool m_printFrameMSE;
bool m_printSequenceMSE;
bool m_cabacZeroWordPaddingEnabled;
bool m_bClipInputVideoToRec709Range;
bool m_bClipOutputVideoToRec709Range;
bool m_packedYUVMode; ///< If true, output 10-bit and 12-bit YUV data as 5-byte and 3-byte (respectively) packed YUV data
Karsten Suehring
committed
bool m_bIntraOnlyConstraintFlag;
uint32_t m_maxBitDepthConstraintIdc;
uint32_t m_maxChromaFormatConstraintIdc;
bool m_bFrameConstraintFlag;
#if JVET_R0286_GCI_CLEANUP
bool m_singleLayerConstraintFlag;
bool m_allLayersIndependentConstraintFlag;
bool m_noMrlConstraintFlag;
bool m_noIspConstraintFlag;
bool m_noMipConstraintFlag;
bool m_noLfnstConstraintFlag;
bool m_noMmvdConstraintFlag;
bool m_noSmvdConstraintFlag;
bool m_noProfConstraintFlag;
bool m_noPaletteConstraintFlag;
bool m_noActConstraintFlag;
bool m_noLmcsConstraintFlag;
#endif
bool m_noPartitionConstraintsOverrideConstraintFlag;
bool m_bNoSaoConstraintFlag;
bool m_bNoAlfConstraintFlag;
bool m_bNoRefWraparoundConstraintFlag;
bool m_bNoTemporalMvpConstraintFlag;
bool m_bNoSbtmvpConstraintFlag;
bool m_bNoAmvrConstraintFlag;
bool m_bNoBdofConstraintFlag;
bool m_bNoCclmConstraintFlag;
bool m_bNoMtsConstraintFlag;
bool m_bNoBcwConstraintFlag;
bool m_bNoCiipConstraintFlag;
bool m_noBDPCMConstraintFlag;
bool m_noJointCbCrConstraintFlag;
bool m_bNoQpDeltaConstraintFlag;
bool m_bNoDepQuantConstraintFlag;
bool m_bNoSignDataHidingConstraintFlag;
Martin Pettersson
committed
bool m_noTrailConstraintFlag;
bool m_noStsaConstraintFlag;
bool m_noRaslConstraintFlag;
bool m_noRadlConstraintFlag;
bool m_noIdrConstraintFlag;
bool m_noCraConstraintFlag;
bool m_noGdrConstraintFlag;
bool m_noApsConstraintFlag;
Karsten Suehring
committed
// profile/level
Profile::Name m_profile;
Level::Tier m_levelTier;
Level::Name m_level;
std::vector<uint32_t> m_subProfile;
uint8_t m_numSubProfile;
Karsten Suehring
committed
uint32_t m_bitDepthConstraint;
ChromaFormat m_chromaFormatConstraint;
bool m_intraConstraintFlag;
Karsten Suehring
committed
bool m_progressiveSourceFlag;
bool m_interlacedSourceFlag;
Karsten Suehring
committed
bool m_nonPackedConstraintFlag;
bool m_nonProjectedConstraintFlag;
bool m_noResChangeInClvsConstraintFlag;
bool m_oneTilePerPicConstraintFlag;
bool m_oneSlicePerPicConstraintFlag;
bool m_oneSubpicPerPicConstraintFlag;
Karsten Suehring
committed
bool m_frameOnlyConstraintFlag;
// coding structure
int m_iIntraPeriod; ///< period of I-slice (random access period)
int m_iDecodingRefreshType; ///< random access type
int m_iGOPSize; ///< GOP size of hierarchical structure
int m_drapPeriod; ///< period of dependent RAP pictures
bool m_rewriteParamSets; ///< Flag to enable rewriting of parameter sets at random access points
RPLEntry m_RPLList0[MAX_GOP]; ///< the RPL entries from the config file
RPLEntry m_RPLList1[MAX_GOP]; ///< the RPL entries from the config file
bool m_idrRefParamList; ///< indicates if reference picture list syntax elements are present in slice headers of IDR pictures
Karsten Suehring
committed
GOPEntry m_GOPList[MAX_GOP]; ///< the coding structure entries from the config file
int m_numReorderPics[MAX_TLAYER]; ///< total number of reorder pictures
int m_maxDecPicBuffering[MAX_TLAYER]; ///< total number of pictures in the decoded picture buffer
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
bool m_useTransformSkip; ///< flag for enabling intra transform skipping
bool m_useTransformSkipFast; ///< flag for enabling fast intra transform skipping
Alican Nalci
committed
bool m_useBDPCM;
Karsten Suehring
committed
uint32_t m_log2MaxTransformSkipBlockSize; ///< transform-skip maximum size (minimum of 2)
bool m_transformSkipRotationEnabledFlag; ///< control flag for transform-skip/transquant-bypass residual rotation
bool m_transformSkipContextEnabledFlag; ///< control flag for transform-skip/transquant-bypass single significance map context
bool m_rdpcmEnabledFlag[NUMBER_OF_RDPCM_SIGNALLING_MODES];///< control flags for residual DPCM
bool m_persistentRiceAdaptationEnabledFlag; ///< control flag for Golomb-Rice parameter adaptation over each slice
bool m_cabacBypassAlignmentEnabledFlag;
Santiago de Luxán Hernández
committed
bool m_useFastISP; ///< flag for enabling fast methods for ISP
Karsten Suehring
committed
// coding quality
#if QP_SWITCHING_FOR_PARALLEL
OptionalValue<uint32_t> m_qpIncrementAtSourceFrame; ///< Optional source frame number at which all subsequent frames are to use an increased internal QP.
#else
double m_fQP; ///< QP value of key-picture (floating point)
#endif
int m_iQP; ///< QP value of key-picture (integer)
Adarsh Krishnan Ramasubramonian
committed
bool m_useIdentityTableForNon420Chroma;
ChromaQpMappingTableParams m_chromaQpMappingTableParams;
Karsten Suehring
committed
#if X0038_LAMBDA_FROM_QP_CAPABILITY
int m_intraQPOffset; ///< QP offset for intra slice (integer)
bool m_lambdaFromQPEnable; ///< enable flag for QP:lambda fix
#endif
std::string m_dQPFileName; ///< QP offset for each slice (initialized from external file)
int* m_aidQP; ///< array of slice QP values
int m_iMaxDeltaQP; ///< max. |delta QP|
uint32_t m_uiDeltaQpRD; ///< dQP range for multi-pass slice QP optimization
int m_cuQpDeltaSubdiv; ///< Maximum subdiv for CU luma Qp adjustment (0:default)
int m_cuChromaQpOffsetSubdiv; ///< If negative, then do not apply chroma qp offsets.
Karsten Suehring
committed
bool m_bFastDeltaQP; ///< Fast Delta QP (false:default)
int m_cbQpOffset; ///< Chroma Cb QP Offset (0:default)
int m_crQpOffset; ///< Chroma Cr QP Offset (0:default)
int m_cbQpOffsetDualTree; ///< Chroma Cb QP Offset for dual tree (overwrite m_cbQpOffset for dual tree)
int m_crQpOffsetDualTree; ///< Chroma Cr QP Offset for dual tree (overwrite m_crQpOffset for dual tree)
int m_cbCrQpOffset; ///< QP Offset for joint Cb-Cr mode
int m_cbCrQpOffsetDualTree; ///< QP Offset for joint Cb-Cr mode (overwrite m_cbCrQpOffset for dual tree)
Karsten Suehring
committed
#if ER_CHROMA_QP_WCG_PPS
WCGChromaQPControl m_wcgChromaQpControl; ///< Wide-colour-gamut chroma QP control.
#endif
#if W0038_CQP_ADJ
uint32_t m_sliceChromaQpOffsetPeriodicity; ///< Used in conjunction with Slice Cb/Cr QpOffsetIntraOrPeriodic. Use 0 (default) to disable periodic nature.
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.
#endif
#if SHARP_LUMA_DELTA_QP
LumaLevelToDeltaQPMapping m_lumaLevelToDeltaQPMapping; ///< mapping from luma level to Delta QP.
#endif
SEIMasteringDisplay m_masteringDisplay;
Karsten Suehring
committed
bool m_bUseAdaptiveQP; ///< Flag for enabling QP adaptation based on a psycho-visual model
int m_iQPAdaptationRange; ///< dQP range by QP adaptation
#if ENABLE_QPA
bool m_bUsePerceptQPA; ///< Flag to enable perceptually motivated input-adaptive QP modification
bool m_bUseWPSNR; ///< Flag to output perceptually weighted peak SNR (WPSNR) instead of PSNR
#endif
int m_maxTempLayer; ///< Max temporal layer
// coding unit (CU) definition
unsigned m_uiCTUSize;
Kui Fan
committed
bool m_subPicInfoPresentFlag;
unsigned m_numSubPics;
std::vector<uint32_t> m_subPicCtuTopLeftX;
std::vector<uint32_t> m_subPicCtuTopLeftY;
std::vector<uint32_t> m_subPicWidth;
std::vector<uint32_t> m_subPicHeight;
std::vector<bool> m_subPicTreatedAsPicFlag;
std::vector<bool> m_loopFilterAcrossSubpicEnabledFlag;
bool m_subPicIdMappingExplicitlySignalledFlag;
Kui Fan
committed
bool m_subPicIdMappingInSpsFlag;
std::vector<uint16_t> m_subPicId;
bool m_SplitConsOverrideEnabledFlag;
Karsten Suehring
committed
unsigned m_uiMinQT[3]; // 0: I slice luma; 1: P/B slice; 2: I slice chroma
unsigned m_uiMaxMTTHierarchyDepth;
unsigned m_uiMaxMTTHierarchyDepthI;
unsigned m_uiMaxMTTHierarchyDepthIChroma;
unsigned m_uiMaxBT[3];
unsigned m_uiMaxTT[3];
Karsten Suehring
committed
bool m_dualTree;
bool m_LFNST;
bool m_useFastLFNST;
Karsten Suehring
committed
int m_SubPuMvpMode;
bool m_Affine;
bool m_AffineType;
bool m_PROF;
Karsten Suehring
committed
int m_LMChroma;
bool m_horCollocatedChromaFlag;
bool m_verCollocatedChromaFlag;
int m_MTS; ///< XZ: Multiple Transform Set
int m_MTSIntraMaxCand; ///< XZ: Number of additional candidates to test
int m_MTSInterMaxCand; ///< XZ: Number of additional candidates to test
bool m_SBT; ///< Sub-Block Transform for inter blocks
bool m_compositeRefEnabled;
bool m_bcw;
bool m_BcwFast;
Shunsuke Iwamura
committed
#if LUMA_ADAPTIVE_DEBLOCKING_FILTER_QP_OFFSET
bool m_LadfEnabed;
int m_LadfNumIntervals;
std::vector<int> m_LadfQpOffset;
int m_LadfIntervalLowerBound[MAX_LADF_INTERVALS];
bool m_Geo;
bool m_allowDisFracMMVD;
bool m_AffineAmvr;
Hongbin Liu
committed
bool m_AffineAmvrEncOpt;
bool m_rgbFormat;
bool m_useColorTrans;
Yung-Hsuan Chao (Jessie)
committed
unsigned m_PLTMode;
unsigned m_IBCMode;
unsigned m_IBCLocalSearchRangeX;
unsigned m_IBCLocalSearchRangeY;
unsigned m_IBCHashSearch;
unsigned m_IBCHashSearchMaxCand;
unsigned m_IBCHashSearchRange4SmallBlk;
unsigned m_IBCFastMethod;
bool m_wrapAround;
unsigned m_wrapAroundOffset;
Karsten Suehring
committed
// ADD_NEW_TOOL : (encoder app) add tool enabling flags and associated parameters here
bool m_virtualBoundariesEnabledFlag;
bool m_virtualBoundariesPresentFlag;
Sheng-Yen Lin
committed
unsigned m_numVerVirtualBoundaries;
unsigned m_numHorVirtualBoundaries;
std::vector<unsigned> m_virtualBoundariesPosX;
std::vector<unsigned> m_virtualBoundariesPosY;
bool m_lmcsEnabled;
int m_updateCtrl;
int m_adpOption;
uint32_t m_initialCW;
int m_CSoffset;
Karsten Suehring
committed
unsigned m_uiMaxCUWidth; ///< max. CU width in pixel
unsigned m_uiMaxCUHeight; ///< max. CU height in pixel
unsigned m_log2MinCuSize; ///< min. CU size log2
Karsten Suehring
committed
bool m_useFastLCTU;
bool m_usePbIntraFast;
bool m_useAMaxBT;
bool m_useFastMrg;
bool m_e0023FastEnc;
bool m_contentBasedFastQtbt;
bool m_useNonLinearAlfLuma;
bool m_useNonLinearAlfChroma;
unsigned m_maxNumAlfAlternativesChroma;
Philipp Merkle
committed
bool m_useFastMIP;
int m_fastLocalDualTreeMode;
Karsten Suehring
committed
int m_numSplitThreads;
bool m_forceSplitSequential;
int m_numWppThreads;
int m_numWppExtraLines;
bool m_ensureWppBitEqual;
Karsten Suehring
committed
// coding tools (bit-depth)
int m_inputBitDepth [MAX_NUM_CHANNEL_TYPE]; ///< bit-depth of input file
int m_outputBitDepth [MAX_NUM_CHANNEL_TYPE]; ///< bit-depth of output file
int m_MSBExtendedBitDepth[MAX_NUM_CHANNEL_TYPE]; ///< bit-depth of input samples after MSB extension
int m_internalBitDepth[MAX_NUM_CHANNEL_TYPE]; ///< bit-depth codec operates at (input/output files will be converted)
bool m_extendedPrecisionProcessingFlag;
bool m_highPrecisionOffsetsEnabledFlag;
//coding tools (chroma format)
ChromaFormat m_chromaFormatIDC;
// coding tool (SAO)
bool m_bUseSAO;
bool m_bTestSAODisableAtPictureLevel;
double m_saoEncodingRate; ///< When >0 SAO early picture termination is enabled for luma and chroma
double m_saoEncodingRateChroma; ///< The SAO early picture termination rate to use for chroma (when m_SaoEncodingRate is >0). If <=0, use results for luma.
int m_maxNumOffsetsPerPic; ///< SAO maximun number of offset per picture
bool m_saoCtuBoundary; ///< SAO parameter estimation using non-deblocked pixels for CTU bottom and right boundary areas
bool m_saoGreedyMergeEnc; ///< SAO greedy merge encoding algorithm
Karsten Suehring
committed
// coding tools (loop filter)
bool m_bLoopFilterDisable; ///< flag for using deblocking filter
bool m_loopFilterOffsetInPPS; ///< offset for deblocking filter in 0 = slice header, 1 = PPS
int m_loopFilterBetaOffsetDiv2; ///< beta offset for deblocking filter
int m_loopFilterTcOffsetDiv2; ///< tc offset for deblocking filter
int m_loopFilterCbBetaOffsetDiv2; ///< beta offset for Cb deblocking filter
int m_loopFilterCbTcOffsetDiv2; ///< tc offset for Cb deblocking filter
int m_loopFilterCrBetaOffsetDiv2; ///< beta offset for Cr deblocking filter
int m_loopFilterCrTcOffsetDiv2; ///< tc offset for Cr deblocking filter
Karsten Suehring
committed
#if W0038_DB_OPT
int m_deblockingFilterMetric; ///< blockiness metric in encoder
#else
bool m_DeblockingFilterMetric; ///< blockiness metric in encoder
Karsten Suehring
committed
bool m_enableIntraReferenceSmoothing; ///< flag for enabling(default)/disabling intra reference smoothing/filtering
// coding tools (encoder-only parameters)
bool m_bUseASR; ///< flag for using adaptive motion search range
bool m_bUseHADME; ///< flag for using HAD in sub-pel ME
bool m_useRDOQ; ///< flag for using RD optimized quantization
bool m_useRDOQTS; ///< flag for using RD optimized quantization for transform skip
#if T0196_SELECTIVE_RDOQ
bool m_useSelectiveRDOQ; ///< flag for using selective RDOQ
#endif
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)
bool m_bDisableIntraPUsInInterSlices; ///< Flag for disabling intra predicted PUs in inter slices.
MESearchMethod m_motionEstimationSearchMethod;
bool m_bRestrictMESampling; ///< Restrict sampling for the Selective ME
int m_iSearchRange; ///< ME search range
int m_bipredSearchRange; ///< ME search range for bipred refinement
int m_minSearchWindow; ///< ME minimum search window size for the Adaptive Window ME
bool m_bClipForBiPredMeEnabled; ///< Enables clipping for Bi-Pred ME.
bool m_bFastMEAssumingSmootherMVEnabled; ///< Enables fast ME assuming a smoother MV.
FastInterSearchMode m_fastInterSearchMode; ///< Parameter that controls fast encoder settings
bool m_bUseEarlyCU; ///< flag for using Early CU setting
bool m_useFastDecisionForMerge; ///< flag for using Fast Decision Merge RD-Cost
bool m_bUseCbfFastMode; ///< flag for using Cbf Fast PU Mode Decision
bool m_useEarlySkipDetection; ///< flag for using Early SKIP Detection
bool m_picPartitionFlag; ///< enable picture partitioning (0: single tile, single slice, 1: multiple tiles/slices can be used)
#if JVET_R0110_MIXED_LOSSLESS
std::vector<uint32_t> m_sliceLosslessArray; ///< Slice lossless array
#endif
std::vector<uint32_t> m_tileColumnWidth; ///< tile column widths in units of CTUs (last column width will be repeated uniformly to cover any remaining picture width)
std::vector<uint32_t> m_tileRowHeight; ///< tile row heights in units of CTUs (last row height will be repeated uniformly to cover any remaining picture height)
bool m_rasterSliceFlag; ///< indicates if using raster-scan or rectangular slices (0: rectangular, 1: raster-scan)
std::vector<uint32_t> m_rectSlicePos; ///< rectangular slice positions (pairs of top-left CTU address followed by bottom-right CTU address)
int m_rectSliceFixedWidth; ///< fixed rectangular slice width in units of tiles (0: disable this feature and use RectSlicePositions instead)
int m_rectSliceFixedHeight; ///< fixed rectangular slice height in units of tiles (0: disable this feature and use RectSlicePositions instead)
std::vector<uint32_t> m_rasterSliceSize; ///< raster-scan slice sizes in units of tiles (last size will be repeated uniformly to cover any remaining tiles in the picture)
bool m_disableLFCrossTileBoundaryFlag; ///< 0: filter across tile boundaries 1: do not filter across tile boundaries
bool m_disableLFCrossSliceBoundaryFlag; ///< 0: filter across slice boundaries 1: do not filter across slice boundaries
uint32_t m_numSlicesInPic; ///< derived number of rectangular slices in the picture (raster-scan slice specified at slice level)
bool m_tileIdxDeltaPresentFlag; ///< derived tile index delta present flag
std::vector<RectSlice> m_rectSlices; ///< derived list of rectangular slice signalling parameters
uint32_t m_numTileCols; ///< derived number of tile columns
uint32_t m_numTileRows; ///< derived number of tile rows
bool m_singleSlicePerSubPicFlag;
Karsten Suehring
committed
bool m_entropyCodingSyncEnabledFlag;
#if JVET_R0165_OPTIONAL_ENTRY_POINT
bool m_entryPointPresentFlag; ///< flag for the presence of entry points
#else
bool m_entropyCodingSyncEntryPointPresentFlag; ///< flag for the presence of entry points for WPP
Karsten Suehring
committed
bool m_bFastUDIUseMPMEnabled;
bool m_bFastMEForGenBLowDelayEnabled;
bool m_bUseBLambdaForNonKeyLowDelayPictures;
HashType m_decodedPictureHashSEIType; ///< Checksum mode for decoded picture hash SEI message
bool m_bufferingPeriodSEIEnabled;
bool m_pictureTimingSEIEnabled;
Yago Sanchez de la Fuente
committed
bool m_bpDeltasGOPStructure;
bool m_decodingUnitInfoSEIEnabled;
bool m_frameFieldInfoSEIEnabled;
Karsten Suehring
committed
bool m_framePackingSEIEnabled;
int m_framePackingSEIType;
int m_framePackingSEIId;
int m_framePackingSEIQuincunx;
int m_framePackingSEIInterpretation;
#if U0033_ALTERNATIVE_TRANSFER_CHARACTERISTICS_SEI
int m_preferredTransferCharacteristics;
#endif
// film grain characterstics sei
bool m_fgcSEIEnabled;
bool m_fgcSEICancelFlag;
bool m_fgcSEIPersistenceFlag;
uint32_t m_fgcSEIBlendingModeID;
uint32_t m_fgcSEILog2ScaleFactor;
bool m_cllSEIEnabled;
uint32_t m_cllSEIMaxContentLevel;
uint32_t m_cllSEIMaxPicAvgLevel;
bool m_aveSEIEnabled;
uint32_t m_aveSEIAmbientIlluminance;
uint32_t m_aveSEIAmbientLightX;
uint32_t m_aveSEIAmbientLightY;
bool m_ccvSEIEnabled;
bool m_ccvSEICancelFlag;
bool m_ccvSEIPersistenceFlag;
bool m_ccvSEIPrimariesPresentFlag;
bool m_ccvSEIMinLuminanceValuePresentFlag;
bool m_ccvSEIMaxLuminanceValuePresentFlag;
bool m_ccvSEIAvgLuminanceValuePresentFlag;
double m_ccvSEIPrimariesX[MAX_NUM_COMPONENT];
double m_ccvSEIPrimariesY[MAX_NUM_COMPONENT];
double m_ccvSEIMinLuminanceValue;
double m_ccvSEIMaxLuminanceValue;
double m_ccvSEIAvgLuminanceValue;
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
bool m_erpSEIEnabled;
bool m_erpSEICancelFlag;
bool m_erpSEIPersistenceFlag;
bool m_erpSEIGuardBandFlag;
uint32_t m_erpSEIGuardBandType;
uint32_t m_erpSEILeftGuardBandWidth;
uint32_t m_erpSEIRightGuardBandWidth;
bool m_sphereRotationSEIEnabled;
bool m_sphereRotationSEICancelFlag;
bool m_sphereRotationSEIPersistenceFlag;
int m_sphereRotationSEIYaw;
int m_sphereRotationSEIPitch;
int m_sphereRotationSEIRoll;
bool m_omniViewportSEIEnabled;
uint32_t m_omniViewportSEIId;
bool m_omniViewportSEICancelFlag;
bool m_omniViewportSEIPersistenceFlag;
uint32_t m_omniViewportSEICntMinus1;
std::vector<int> m_omniViewportSEIAzimuthCentre;
std::vector<int> m_omniViewportSEIElevationCentre;
std::vector<int> m_omniViewportSEITiltCentre;
std::vector<uint32_t> m_omniViewportSEIHorRange;
std::vector<uint32_t> m_omniViewportSEIVerRange;
bool m_rwpSEIEnabled;
bool m_rwpSEIRwpCancelFlag;
bool m_rwpSEIRwpPersistenceFlag;
bool m_rwpSEIConstituentPictureMatchingFlag;
int m_rwpSEINumPackedRegions;
int m_rwpSEIProjPictureWidth;
int m_rwpSEIProjPictureHeight;
int m_rwpSEIPackedPictureWidth;
int m_rwpSEIPackedPictureHeight;
std::vector<uint8_t> m_rwpSEIRwpTransformType;
std::vector<bool> m_rwpSEIRwpGuardBandFlag;
std::vector<uint32_t> m_rwpSEIProjRegionWidth;
std::vector<uint32_t> m_rwpSEIProjRegionHeight;
std::vector<uint32_t> m_rwpSEIRwpSEIProjRegionTop;
std::vector<uint32_t> m_rwpSEIProjRegionLeft;
std::vector<uint16_t> m_rwpSEIPackedRegionWidth;
std::vector<uint16_t> m_rwpSEIPackedRegionHeight;
std::vector<uint16_t> m_rwpSEIPackedRegionTop;
std::vector<uint16_t> m_rwpSEIPackedRegionLeft;
std::vector<uint8_t> m_rwpSEIRwpLeftGuardBandWidth;
std::vector<uint8_t> m_rwpSEIRwpRightGuardBandWidth;
std::vector<uint8_t> m_rwpSEIRwpTopGuardBandHeight;
std::vector<uint8_t> m_rwpSEIRwpBottomGuardBandHeight;
std::vector<bool> m_rwpSEIRwpGuardBandNotUsedForPredFlag;
std::vector<uint8_t> m_rwpSEIRwpGuardBandType;
Karsten Suehring
committed
bool m_gcmpSEIEnabled;
bool m_gcmpSEICancelFlag;
bool m_gcmpSEIPersistenceFlag;
uint32_t m_gcmpSEIPackingType;
uint32_t m_gcmpSEIMappingFunctionType;
std::vector<uint8_t> m_gcmpSEIFaceIndex;
std::vector<uint8_t> m_gcmpSEIFaceRotation;
std::vector<double> m_gcmpSEIFunctionCoeffU;
std::vector<bool> m_gcmpSEIFunctionUAffectedByVFlag;
std::vector<double> m_gcmpSEIFunctionCoeffV;
std::vector<bool> m_gcmpSEIFunctionVAffectedByUFlag;
bool m_gcmpSEIGuardBandFlag;
uint32_t m_gcmpSEIGuardBandType;
bool m_gcmpSEIGuardBandBoundaryExteriorFlag;
uint32_t m_gcmpSEIGuardBandSamplesMinus1;
EncCfgParam::CfgSEISubpictureLevel m_cfgSubpictureLevelInfoSEI;
bool m_sampleAspectRatioInfoSEIEnabled;
bool m_sariCancelFlag;
bool m_sariPersistenceFlag;
int m_sariAspectRatioIdc;
int m_sariSarWidth;
int m_sariSarHeight;
Karsten Suehring
committed
// weighted prediction
bool m_useWeightedPred; ///< Use of weighted prediction in P slices
bool m_useWeightedBiPred; ///< Use of bi-directional weighted prediction in B slices
WeightedPredictionMethod m_weightedPredictionMethod;
uint32_t m_log2ParallelMergeLevel; ///< Parallel merge estimation region
Karsten Suehring
committed
uint32_t m_maxNumMergeCand; ///< Max number of merge candidates
uint32_t m_maxNumAffineMergeCand; ///< Max number of affine merge candidates
uint32_t m_maxNumIBCMergeCand; ///< Max number of IBC merge candidates
Karsten Suehring
committed
bool m_sliceLevelRpl; ///< code reference picture lists in slice headers rather than picture header
bool m_sliceLevelDblk; ///< code deblocking filter parameters in slice headers rather than picture header
bool m_sliceLevelSao; ///< code SAO parameters in slice headers rather than picture header
bool m_sliceLevelAlf; ///< code ALF parameters in slice headers rather than picture header
bool m_sliceLevelWp; ///< code weighted prediction parameters in slice headers rather than picture header
bool m_sliceLevelDeltaQp; ///< code delta in slice headers rather than picture header
Martin Pettersson
committed
int m_TMVPModeId;
Karsten Suehring
committed
bool m_depQuantEnabledFlag;
bool m_signDataHidingEnabledFlag;
bool m_RCEnableRateControl; ///< enable rate control or not
int m_RCTargetBitrate; ///< target bitrate when rate control is enabled
int m_RCKeepHierarchicalBit; ///< 0: equal bit allocation; 1: fixed ratio bit allocation; 2: adaptive ratio bit allocation
bool m_RCLCULevelRC; ///< true: LCU level rate control; false: picture level rate control NOTE: code-tidy - rename to m_RCCtuLevelRC
bool m_RCUseLCUSeparateModel; ///< use separate R-lambda model at LCU level NOTE: code-tidy - rename to m_RCUseCtuSeparateModel
int m_RCInitialQP; ///< inital QP for rate control
bool m_RCForceIntraQP; ///< force all intra picture to use initial QP or not
#if U0132_TARGET_BITS_SATURATION
bool m_RCCpbSaturationEnabled; ///< enable target bits saturation to avoid CPB overflow and underflow
uint32_t m_RCCpbSize; ///< CPB size
double m_RCInitialCpbFullness; ///< initial CPB fullness
#endif
ScalingListMode m_useScalingListId; ///< using quantization matrix
std::string m_scalingListFileName; ///< quantization matrix file name
Adarsh Krishnan Ramasubramonian
committed
bool m_disableScalingMatrixForLfnstBlks;
#if JVET_R0380_SCALING_MATRIX_DISABLE_YCC_OR_RGB
bool m_disableScalingMatrixForAlternativeColourSpace;
bool m_scalingMatrixDesignatedColourSpace;
#endif
Karsten Suehring
committed
CostMode m_costMode; ///< Cost mode to use
Christopher Hollmann
committed
#if JVET_R0143_TSRCdisableLL
bool m_TSRCdisableLL; ///< disable TSRC for lossless
#endif
Karsten Suehring
committed
bool m_recalculateQPAccordingToLambda; ///< recalculate QP value according to the lambda value
bool m_DCIEnabled; ///< enable Decoding Capability Information (DCI)
bool m_hrdParametersPresentFlag; ///< enable generation of HRD parameters
bool m_vuiParametersPresentFlag; ///< enable generation of VUI parameters
bool m_aspectRatioInfoPresentFlag; ///< Signals whether aspect_ratio_idc is present
int m_aspectRatioIdc; ///< aspect_ratio_idc
int m_sarWidth; ///< horizontal size of the sample aspect ratio
int m_sarHeight; ///< vertical size of the sample aspect ratio
bool m_colourDescriptionPresentFlag; ///< Signals whether colour_primaries, transfer_characteristics and matrix_coefficients are present
int m_colourPrimaries; ///< Indicates chromaticity coordinates of the source primaries
int m_transferCharacteristics; ///< Indicates the opto-electronic transfer characteristics of the source
int m_matrixCoefficients; ///< Describes the matrix coefficients used in deriving luma and chroma from RGB primaries
#if JVET_R0090_VUI
bool m_progressiveSourceFlag; ///< Indicates if the content is progressive
bool m_interlacedSourceFlag; ///< Indicates if the content is interlaced
#endif
bool m_chromaLocInfoPresentFlag; ///< Signals whether chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field are present
int m_chromaSampleLocTypeTopField; ///< Specifies the location of chroma samples for top field
int m_chromaSampleLocTypeBottomField; ///< Specifies the location of chroma samples for bottom field
int m_chromaSampleLocType; ///< Specifies the location of chroma samples for progressive content
bool m_overscanInfoPresentFlag; ///< Signals whether overscan_appropriate_flag is present
bool m_overscanAppropriateFlag; ///< Indicates whether conformant decoded pictures are suitable for display using overscan
bool m_videoFullRangeFlag; ///< Indicates the black level and range of luma and chroma signals
Karsten Suehring
committed
int m_ImvMode; ///< imv mode
int m_Imv4PelFast; ///< imv 4-Pel fast mode
Karsten Suehring
committed
std::string m_summaryOutFilename; ///< filename to use for producing summary output file.
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.
uint32_t m_summaryVerboseness; ///< Specifies the level of the verboseness of the text output.
int m_verbosity;
std::string m_decodeBitstreams[2]; ///< filename for decode bitstreams.
Karsten Suehring
committed
int m_switchPOC; ///< dbg poc.
int m_switchDQP; ///< switch DQP.
int m_fastForwardToPOC; ///< get to encoding the specified POC as soon as possible by skipping temporal layers irrelevant for the specified POC
bool m_stopAfterFFtoPOC;
bool m_bs2ModPOCAndType;
bool m_forceDecodeBitstream1;
bool m_alf; ///< Adaptive Loop Filter
bool m_ccalf;
int m_ccalfQpThreshold;
double m_scalingRatioHor;
double m_scalingRatioVer;
bool m_rprEnabled;
double m_fractionOfFrames; ///< encode a fraction of the frames as specified in FramesToBeEncoded
int m_switchPocPeriod;
int m_upscaledOutput; ////< Output upscaled (2), decoded cropped but in full resolution buffer (1) or decoded cropped (0, default) picture for RPR.
Karsten Suehring
committed
Rickard Sjöberg
committed
bool m_gopBasedTemporalFilterEnabled; ///< GOP-based Temporal Filter enable/disable
bool m_gopBasedTemporalFilterFutureReference; ///< Enable/disable future frame references in the GOP-based Temporal Filter
std::map<int, double> m_gopBasedTemporalFilterStrengths; ///< Filter strength per frame for the GOP-based Temporal Filter
int m_layerId[MAX_VPS_LAYERS];
int m_layerIdx;
int m_maxSublayers;
bool m_allLayersSameNumSublayersFlag;
bool m_allIndependentLayersFlag;
int m_numRefLayers[MAX_VPS_LAYERS];
std::string m_refLayerIdxStr[MAX_VPS_LAYERS];
bool m_eachLayerIsAnOlsFlag;
int m_olsModeIdc;
int m_numOutputLayerSets;
std::string m_olsOutputLayerStr[MAX_VPS_LAYERS];
int m_numPtlsInVps;
Level::Name m_levelPtl[MAX_NUM_OLSS];
int m_olsPtlIdx[MAX_NUM_OLSS];
Karsten Suehring
committed
#if EXTENSION_360_VIDEO
TExt360AppEncCfg m_ext360;
friend class TExt360AppEncCfg;
friend class TExt360AppEncTop;
#endif
#if JVET_O0756_CONFIG_HDRMETRICS || JVET_O0756_CALCULATE_HDRMETRICS
#if JVET_O0756_CALCULATE_HDRMETRICS
double m_whitePointDeltaE[hdrtoolslib::NB_REF_WHITE];
#else
double m_whitePointDeltaE[3];
#endif
double m_maxSampleValue;
int m_sampleRange;
int m_colorPrimaries;
bool m_enableTFunctionLUT;
int m_chromaLocation;
int m_chromaUPFilter;
int m_cropOffsetLeft;
int m_cropOffsetTop;
int m_cropOffsetRight;
int m_cropOffsetBottom;
bool m_calculateHdrMetrics;
#endif
Karsten Suehring
committed
// internal member functions
bool xCheckParameter (); ///< check validity of configuration values
void xPrintParameter (); ///< print configuration values
void xPrintUsage (); ///< print usage
Martin Pettersson
committed
bool xHasNonZeroTemporalID(); ///< check presence of constant temporal ID in GOP structure
bool xHasLeadingPicture(); ///< check presence of leading pictures in GOP structure
int xAutoDetermineProfile(); ///< auto determine the profile to use given the other configuration settings. Returns 1 if erred. Can select profile 'NONE'
Karsten Suehring
committed
public:
EncAppCfg();
virtual ~EncAppCfg();
public:
void create (); ///< create option handling class
void destroy (); ///< destroy option handling class
bool parseCfg ( int argc, char* argv[] ); ///< parse configuration file to fill member variables
};// END CLASS DEFINITION EncAppCfg
//! \}
#endif // __ENCAPPCFG__