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-2019, 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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
* 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 EncCfg.h
\brief encoder configuration class (header)
*/
#ifndef __ENCCFG__
#define __ENCCFG__
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "CommonLib/CommonDef.h"
#include "CommonLib/Slice.h"
#include "CommonLib/Unit.h"
struct GOPEntry
{
int m_POC;
int m_QPOffset;
#if X0038_LAMBDA_FROM_QP_CAPABILITY
double m_QPOffsetModelOffset;
double m_QPOffsetModelScale;
#endif
#if W0038_CQP_ADJ
int m_CbQPoffset;
int m_CrQPoffset;
#endif
double m_QPFactor;
int m_tcOffsetDiv2;
int m_betaOffsetDiv2;
int m_temporalId;
bool m_refPic;
int m_numRefPicsActive;
int8_t m_sliceType;
int m_numRefPics;
int m_referencePics[MAX_NUM_REF_PICS];
int m_usedByCurrPic[MAX_NUM_REF_PICS];
int m_interRPSPrediction;
int m_deltaRPS;
int m_numRefIdc;
int m_refIdc[MAX_NUM_REF_PICS+1];
bool m_isEncoded;
GOPEntry()
: m_POC(-1)
, m_QPOffset(0)
#if X0038_LAMBDA_FROM_QP_CAPABILITY
, m_QPOffsetModelOffset(0)
, m_QPOffsetModelScale(0)
#endif
#if W0038_CQP_ADJ
, m_CbQPoffset(0)
, m_CrQPoffset(0)
#endif
, m_QPFactor(0)
, m_tcOffsetDiv2(0)
, m_betaOffsetDiv2(0)
, m_temporalId(0)
, m_refPic(false)
, m_numRefPicsActive(0)
, m_sliceType('P')
, m_numRefPics(0)
, m_interRPSPrediction(false)
, m_deltaRPS(0)
, m_numRefIdc(0)
, m_isEncoded(false)
{
::memset( m_referencePics, 0, sizeof(m_referencePics) );
::memset( m_usedByCurrPic, 0, sizeof(m_usedByCurrPic) );
::memset( m_refIdc, 0, sizeof(m_refIdc) );
}
};
std::istringstream &operator>>(std::istringstream &in, GOPEntry &entry); //input
//! \ingroup EncoderLib
//! \{
// ====================================================================================================================
// Class definition
// ====================================================================================================================
/// encoder configuration class
class EncCfg
{
protected:
//==== File I/O ========
int m_iFrameRate;
int m_FrameSkip;
uint32_t m_temporalSubsampleRatio;
int m_iSourceWidth;
int m_iSourceHeight;
Window m_conformanceWindow;
int m_framesToBeEncoded;
double m_adLambdaModifier[ MAX_TLAYER ];
std::vector<double> m_adIntraLambdaModifier;
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) ))
bool m_printMSEBasedSequencePSNR;
bool m_printHexPsnr;
bool m_printFrameMSE;
bool m_printSequenceMSE;
bool m_cabacZeroWordPaddingEnabled;
Zhipin Deng
committed
bool m_bIntraOnlyConstraintFlag;
uint32_t m_maxBitDepthConstraintIdc;
uint32_t m_maxChromaFormatConstraintIdc;
bool m_bFrameConstraintFlag;
bool m_bNoQtbttDualTreeIntraConstraintFlag;
bool m_bNoSaoConstraintFlag;
bool m_bNoAlfConstraintFlag;
bool m_bNoPcmConstraintFlag;
bool m_bNoRefWraparoundConstraintFlag;
Zhipin Deng
committed
bool m_bNoTemporalMvpConstraintFlag;
bool m_bNoSbtmvpConstraintFlag;
bool m_bNoAmvrConstraintFlag;
bool m_bNoBdofConstraintFlag;
bool m_bNoCclmConstraintFlag;
Zhipin Deng
committed
bool m_bNoMtsConstraintFlag;
bool m_bNoAffineMotionConstraintFlag;
bool m_bNoGbiConstraintFlag;
bool m_bNoMhIntraConstraintFlag;
bool m_bNoTriangleConstraintFlag;
Zhipin Deng
committed
bool m_bNoLadfConstraintFlag;
bool m_bNoCurrPicRefConstraintFlag;
bool m_bNoQpDeltaConstraintFlag;
Zhipin Deng
committed
bool m_bNoDepQuantConstraintFlag;
bool m_bNoSignDataHidingConstraintFlag;
Karsten Suehring
committed
/* profile & level */
Profile::Name m_profile;
Level::Tier m_levelTier;
Level::Name m_level;
bool m_progressiveSourceFlag;
bool m_interlacedSourceFlag;
bool m_nonPackedConstraintFlag;
bool m_frameOnlyConstraintFlag;
uint32_t m_bitDepthConstraintValue;
ChromaFormat m_chromaFormatConstraintValue;
bool m_intraConstraintFlag;
bool m_onePictureOnlyConstraintFlag;
bool m_lowerBitRateConstraintFlag;
//====== Coding Structure ========
uint32_t m_uiIntraPeriod; // TODO: make this an int - it can be -1!
uint32_t m_uiDecodingRefreshType; ///< the type of decoding refresh employed for the random access.
#if JCTVC_Y0038_PARAMS
bool m_rewriteParamSets;
#endif
Karsten Suehring
committed
int m_iGOPSize;
GOPEntry m_GOPList[MAX_GOP];
int m_extraRPSs;
int m_maxDecPicBuffering[MAX_TLAYER];
int m_numReorderPics[MAX_TLAYER];
int m_iQP; // if (AdaptiveQP == OFF)
#if X0038_LAMBDA_FROM_QP_CAPABILITY
int m_intraQPOffset; ///< QP offset for intra slice (integer)
int m_lambdaFromQPEnable; ///< enable lambda derivation from QP
#endif
int m_aiPad[2];
bool m_AccessUnitDelimiter; ///< add Access Unit Delimiter NAL units
int m_iMaxRefPicNum; ///< this is used to mimic the sliding mechanism used by the decoder
// TODO: We need to have a common sliding mechanism used by both the encoder and decoder
int m_maxTempLayer; ///< Max temporal layer
unsigned m_CTUSize;
bool m_useSplitConsOverride;
Karsten Suehring
committed
unsigned m_uiMinQT[3]; //0: I slice; 1: P/B slice, 2: I slice chroma
unsigned m_uiMaxBTDepth;
unsigned m_uiMaxBTDepthI;
unsigned m_uiMaxBTDepthIChroma;
bool m_dualITree;
unsigned m_maxCUWidth;
unsigned m_maxCUHeight;
unsigned m_maxTotalCUDepth;
unsigned m_log2DiffMaxMinCodingBlockSize;
int m_LMChroma;
int m_IntraMTS;
int m_InterMTS;
int m_IntraMTSMaxCand;
int m_InterMTSMaxCand;
bool m_SBT; ///< Sub-Block Transform for inter blocks
Karsten Suehring
committed
int m_SubPuMvpMode;
bool m_Affine;
bool m_AffineType;
Karsten Suehring
committed
#if JVET_N0235_SMVD_SPS
bool m_SMVD;
#endif
bool m_compositeRefEnabled; //composite reference
Shunsuke Iwamura
committed
#if LUMA_ADAPTIVE_DEBLOCKING_FILTER_QP_OFFSET
bool m_LadfEnabled;
int m_LadfNumIntervals;
int m_LadfQpOffset[MAX_LADF_INTERVALS];
int m_LadfIntervalLowerBound[MAX_LADF_INTERVALS];
bool m_MHIntra;
bool m_Triangle;
bool m_allowDisFracMMVD;
bool m_AffineAmvr;
Hongbin Liu
committed
bool m_AffineAmvrEncOpt;
#if JVET_N0127_MMVD_SPS_FLAG
bool m_MMVD;
#endif
#if JVET_N0449_MMVD_SIMP
int m_MmvdDisNum;
#endif
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 lib) add tool enabling flags and associated parameters here
bool m_lumaReshapeEnable;
unsigned m_reshapeSignalType;
unsigned m_intraCMD;
Karsten Suehring
committed
bool m_useFastLCTU;
bool m_useFastMrg;
bool m_usePbIntraFast;
bool m_useAMaxBT;
bool m_e0023FastEnc;
bool m_contentBasedFastQtbt;
#if JVET_N0242_NON_LINEAR_ALF
bool m_useNonLinearAlfLuma;
bool m_useNonLinearAlfChroma;
#endif
Karsten Suehring
committed
#if MAX_TB_SIZE_SIGNALLING
uint32_t m_log2MaxTbSize;
#endif
Karsten Suehring
committed
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
//====== Loop/Deblock Filter ========
bool m_bLoopFilterDisable;
bool m_loopFilterOffsetInPPS;
int m_loopFilterBetaOffsetDiv2;
int m_loopFilterTcOffsetDiv2;
#if W0038_DB_OPT
int m_deblockingFilterMetric;
#else
bool m_DeblockingFilterMetric;
#endif
bool m_bUseSAO;
bool m_bTestSAODisableAtPictureLevel;
double m_saoEncodingRate; // When non-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;
bool m_saoCtuBoundary;
#if K0238_SAO_GREEDY_MERGE_ENCODING
bool m_saoGreedyMergeEnc;
#endif
//====== Motion search ========
bool m_bDisableIntraPUsInInterSlices;
MESearchMethod m_motionEstimationSearchMethod;
int m_iSearchRange; // 0:Full frame
int m_bipredSearchRange;
bool m_bClipForBiPredMeEnabled;
bool m_bFastMEAssumingSmootherMVEnabled;
int m_minSearchWindow;
bool m_bRestrictMESampling;
//====== Quality control ========
int m_iMaxDeltaQP; // Max. absolute delta QP (1:default)
int m_cuQpDeltaSubdiv; // Max. subdivision level for a CuDQP (0:default)
int m_cuChromaQpOffsetSubdiv; ///< If negative, then do not apply chroma qp offsets.
Karsten Suehring
committed
int m_chromaCbQpOffset; // Chroma Cb QP Offset (0:default)
int m_chromaCrQpOffset; // Chroma Cr Qp Offset (0:default)
int m_chromaCbQpOffsetDualTree; // Chroma Cb QP Offset for dual tree
int m_chromaCrQpOffsetDualTree; // Chroma Cr Qp Offset for dual tree
#if JVET_N0054_JOINT_CHROMA
int m_chromaCbCrQpOffset; // QP Offset for the joint Cb-Cr mode
int m_chromaCbCrQpOffsetDualTree; // QP Offset for the joint Cb-Cr mode in dual tree
#endif
Karsten Suehring
committed
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
#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
ChromaFormat m_chromaFormatIDC;
bool m_extendedPrecisionProcessingFlag;
bool m_highPrecisionOffsetsEnabledFlag;
bool m_bUseAdaptiveQP;
int m_iQPAdaptationRange;
#if ENABLE_QPA
bool m_bUsePerceptQPA;
bool m_bUseWPSNR;
#endif
//====== Tool list ========
int m_inputBitDepth[MAX_NUM_CHANNEL_TYPE]; ///< bit-depth of input file
int m_bitDepth[MAX_NUM_CHANNEL_TYPE];
bool m_bUseASR;
bool m_bUseHADME;
bool m_useRDOQ;
bool m_useRDOQTS;
#if T0196_SELECTIVE_RDOQ
bool m_useSelectiveRDOQ;
#endif
uint32_t m_rdPenalty;
FastInterSearchMode m_fastInterSearchMode;
bool m_bUseEarlyCU;
bool m_useFastDecisionForMerge;
bool m_bUseCbfFastMode;
bool m_useEarlySkipDetection;
bool m_crossComponentPredictionEnabledFlag;
bool m_reconBasedCrossCPredictionEstimate;
uint32_t m_log2SaoOffsetScale[MAX_NUM_CHANNEL_TYPE];
bool m_useTransformSkip;
bool m_useTransformSkipFast;
uint32_t m_log2MaxTransformSkipBlockSize;
bool m_transformSkipRotationEnabledFlag;
bool m_transformSkipContextEnabledFlag;
bool m_persistentRiceAdaptationEnabledFlag;
bool m_cabacBypassAlignmentEnabledFlag;
bool m_rdpcmEnabledFlag[NUMBER_OF_RDPCM_SIGNALLING_MODES];
#if SHARP_LUMA_DELTA_QP
LumaLevelToDeltaQPMapping m_lumaLevelToDeltaQPMapping; ///< mapping from luma level to delta QP.
#endif
int* m_aidQP;
uint32_t m_uiDeltaQpRD;
bool m_bFastDeltaQP;
#if INCLUDE_ISP_CFG_FLAG
bool m_ISP;
#endif
Santiago de Luxán Hernández
committed
bool m_useFastISP;
Karsten Suehring
committed
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
bool m_bUseConstrainedIntraPred;
bool m_bFastUDIUseMPMEnabled;
bool m_bFastMEForGenBLowDelayEnabled;
bool m_bUseBLambdaForNonKeyLowDelayPictures;
bool m_usePCM;
int m_PCMBitDepth[MAX_NUM_CHANNEL_TYPE];
uint32_t m_pcmLog2MaxSize;
uint32_t m_uiPCMLog2MinSize;
//====== Slice ========
SliceConstraint m_sliceMode;
int m_sliceArgument;
//====== Dependent Slice ========
SliceConstraint m_sliceSegmentMode;
int m_sliceSegmentArgument;
bool m_bLFCrossSliceBoundaryFlag;
bool m_bPCMInputBitDepthFlag;
bool m_bPCMFilterDisableFlag;
bool m_intraSmoothingDisabledFlag;
bool m_loopFilterAcrossTilesEnabledFlag;
bool m_tileUniformSpacingFlag;
int m_iNumColumnsMinus1;
int m_iNumRowsMinus1;
std::vector<int> m_tileColumnWidth;
std::vector<int> m_tileRowHeight;
bool m_entropyCodingSyncEnabledFlag;
HashType m_decodedPictureHashSEIType;
bool m_bufferingPeriodSEIEnabled;
bool m_pictureTimingSEIEnabled;
bool m_recoveryPointSEIEnabled;
bool m_toneMappingInfoSEIEnabled;
int m_toneMapId;
bool m_toneMapCancelFlag;
bool m_toneMapPersistenceFlag;
int m_codedDataBitDepth;
int m_targetBitDepth;
int m_modelId;
int m_minValue;
int m_maxValue;
int m_sigmoidMidpoint;
int m_sigmoidWidth;
int m_numPivots;
int m_cameraIsoSpeedIdc;
int m_cameraIsoSpeedValue;
int m_exposureIndexIdc;
int m_exposureIndexValue;
bool m_exposureCompensationValueSignFlag;
int m_exposureCompensationValueNumerator;
int m_exposureCompensationValueDenomIdc;
int m_refScreenLuminanceWhite;
int m_extendedRangeWhiteLevel;
int m_nominalBlackLevelLumaCodeValue;
int m_nominalWhiteLevelLumaCodeValue;
int m_extendedWhiteLevelLumaCodeValue;
int* m_startOfCodedInterval;
int* m_codedPivotValue;
int* m_targetPivotValue;
bool m_framePackingSEIEnabled;
int m_framePackingSEIType;
int m_framePackingSEIId;
int m_framePackingSEIQuincunx;
int m_framePackingSEIInterpretation;
bool m_segmentedRectFramePackingSEIEnabled;
bool m_segmentedRectFramePackingSEICancel;
int m_segmentedRectFramePackingSEIType;
bool m_segmentedRectFramePackingSEIPersistence;
int m_displayOrientationSEIAngle;
bool m_temporalLevel0IndexSEIEnabled;
bool m_gradualDecodingRefreshInfoEnabled;
int m_noDisplaySEITLayer;
bool m_decodingUnitInfoSEIEnabled;
bool m_SOPDescriptionSEIEnabled;
bool m_scalableNestingSEIEnabled;
bool m_tmctsSEIEnabled;
Karsten Suehring
committed
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
bool m_timeCodeSEIEnabled;
int m_timeCodeSEINumTs;
SEITimeSet m_timeSetArray[MAX_TIMECODE_SEI_SETS];
bool m_kneeSEIEnabled;
int m_kneeSEIId;
bool m_kneeSEICancelFlag;
bool m_kneeSEIPersistenceFlag;
int m_kneeSEIInputDrange;
int m_kneeSEIInputDispLuminance;
int m_kneeSEIOutputDrange;
int m_kneeSEIOutputDispLuminance;
int m_kneeSEINumKneePointsMinus1;
int* m_kneeSEIInputKneePoint;
int* m_kneeSEIOutputKneePoint;
std::string m_colourRemapSEIFileRoot; ///< SEI Colour Remapping File (initialized from external file)
SEIMasteringDisplay m_masteringDisplay;
#if U0033_ALTERNATIVE_TRANSFER_CHARACTERISTICS_SEI
bool m_alternativeTransferCharacteristicsSEIEnabled;
uint8_t m_preferredTransferCharacteristics;
#endif
bool m_greenMetadataInfoSEIEnabled;
uint8_t m_greenMetadataType;
uint8_t m_xsdMetricType;
//====== Weighted Prediction ========
bool m_useWeightedPred; //< Use of Weighting Prediction (P_SLICE)
bool m_useWeightedBiPred; //< Use of Bi-directional Weighting Prediction (B_SLICE)
WeightedPredictionMethod m_weightedPredictionMethod;
uint32_t m_log2ParallelMergeLevelMinus2; ///< Parallel merge estimation region
uint32_t m_maxNumMergeCand; ///< Maximum number of merge candidates
uint32_t m_maxNumAffineMergeCand; ///< Maximum number of affine merge candidates
Karsten Suehring
committed
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
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
#if HEVC_USE_SCALING_LISTS
ScalingListMode m_useScalingListId; ///< Using quantization matrix i.e. 0=off, 1=default, 2=file.
std::string m_scalingListFileName; ///< quantization matrix file name
#endif
int m_TMVPModeId;
bool m_DepQuantEnabledFlag;
bool m_SignDataHidingEnabledFlag;
bool m_RCEnableRateControl;
int m_RCTargetBitrate;
int m_RCKeepHierarchicalBit;
bool m_RCLCULevelRC;
bool m_RCUseLCUSeparateModel;
int m_RCInitialQP;
bool m_RCForceIntraQP;
#if U0132_TARGET_BITS_SATURATION
bool m_RCCpbSaturationEnabled;
uint32_t m_RCCpbSize;
double m_RCInitialCpbFullness;
#endif
bool m_TransquantBypassEnabledFlag; ///< transquant_bypass_enabled_flag setting in PPS.
bool m_CUTransquantBypassFlagForce; ///< if transquant_bypass_enabled_flag, then, if true, all CU transquant bypass flags will be set to true.
CostMode m_costMode; ///< The cost function to use, primarily when considering lossless coding.
#if HEVC_VPS
VPS m_cVPS;
#endif
bool m_recalculateQPAccordingToLambda; ///< recalculate QP value according to the lambda value
int m_activeParameterSetsSEIEnabled; ///< enable active parameter set SEI message
bool m_vuiParametersPresentFlag; ///< enable generation of VUI parameters
bool m_aspectRatioInfoPresentFlag; ///< Signals whether aspect_ratio_idc is present
bool m_chromaResamplingFilterHintEnabled; ///< Signals whether chroma sampling filter hint data is present
int m_chromaResamplingHorFilterIdc; ///< Specifies the Index of filter to use
int m_chromaResamplingVerFilterIdc; ///< Specifies the Index of filter to use
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_overscanInfoPresentFlag; ///< Signals whether overscan_appropriate_flag is present
bool m_overscanAppropriateFlag; ///< Indicates whether conformant decoded pictures are suitable for display using overscan
bool m_videoSignalTypePresentFlag; ///< Signals whether video_format, video_full_range_flag, and colour_description_present_flag are present
int m_videoFormat; ///< Indicates representation of pictures
bool m_videoFullRangeFlag; ///< Indicates the black level and range of luma and chroma signals
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
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
bool m_neutralChromaIndicationFlag; ///< Indicates that the value of all decoded chroma samples is equal to 1<<(BitDepthCr-1)
Window m_defaultDisplayWindow; ///< Represents the default display window parameters
bool m_frameFieldInfoPresentFlag; ///< Indicates that pic_struct and other field coding related values are present in picture timing SEI messages
bool m_pocProportionalToTimingFlag; ///< Indicates that the POC value is proportional to the output time w.r.t. first picture in CVS
int m_numTicksPocDiffOneMinus1; ///< Number of ticks minus 1 that for a POC difference of one
bool m_bitstreamRestrictionFlag; ///< Signals whether bitstream restriction parameters are present
bool m_tilesFixedStructureFlag; ///< Indicates that each active picture parameter set has the same values of the syntax elements related to tiles
bool m_motionVectorsOverPicBoundariesFlag; ///< Indicates that no samples outside the picture boundaries are used for inter prediction
int m_minSpatialSegmentationIdc; ///< Indicates the maximum size of the spatial segments in the pictures in the coded video sequence
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
int m_maxBitsPerMinCuDenom; ///< Indicates an upper bound for the number of bits of coding_unit() data
int m_log2MaxMvLengthHorizontal; ///< Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units
int m_log2MaxMvLengthVertical; ///< Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units
#if HEVC_USE_INTRA_SMOOTHING_T32 || HEVC_USE_INTRA_SMOOTHING_T64
bool m_useStrongIntraSmoothing; ///< enable the use of strong intra smoothing (bi_linear interpolation) for 32x32 blocks when reference samples are flat.
#endif
bool m_bEfficientFieldIRAPEnabled; ///< enable to code fields in a specific, potentially more efficient, order.
bool m_bHarmonizeGopFirstFieldCoupleEnabled;
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_ImvMode;
int m_Imv4PelFast;
std::string m_decodeBitstreams[2]; ///< filename for decode bitstreams.
bool m_forceDecodeBitstream1; ///< guess what it means
int m_switchPOC; ///< dbg poc.
int m_switchDQP; ///< dqp applied to switchPOC and subsequent pictures.
int m_fastForwardToPOC; ///<
bool m_stopAfterFFtoPOC; ///<
Karsten Suehring
committed
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
bool m_bs2ModPOCAndType;
#if ENABLE_SPLIT_PARALLELISM
int m_numSplitThreads;
bool m_forceSingleSplitThread;
#endif
#if ENABLE_WPP_PARALLELISM
int m_numWppThreads;
int m_numWppExtraLines;
bool m_ensureWppBitEqual;
#endif
bool m_alf; ///< Adaptive Loop Filter
public:
EncCfg()
: m_tileColumnWidth()
, m_tileRowHeight()
{
m_PCMBitDepth[CHANNEL_TYPE_LUMA]=8;
m_PCMBitDepth[CHANNEL_TYPE_CHROMA]=8;
}
virtual ~EncCfg()
{}
void setProfile(Profile::Name profile) { m_profile = profile; }
void setLevel(Level::Tier tier, Level::Name level) { m_levelTier = tier; m_level = level; }
Zhipin Deng
committed
bool getIntraOnlyConstraintFlag() const { return m_bIntraOnlyConstraintFlag; }
void setIntraOnlyConstraintFlag(bool bVal) { m_bIntraOnlyConstraintFlag = bVal; }
uint32_t getMaxBitDepthConstraintIdc() const { return m_maxBitDepthConstraintIdc; }
void setMaxBitDepthConstraintIdc(uint32_t u) { m_maxBitDepthConstraintIdc = u; }
uint32_t getMaxChromaFormatConstraintIdc() const { return m_maxChromaFormatConstraintIdc; }
void setMaxChromaFormatConstraintIdc(uint32_t u) { m_maxChromaFormatConstraintIdc = u; }
bool getFrameConstraintFlag() const { return m_bFrameConstraintFlag; }
void setFrameConstraintFlag(bool bVal) { m_bFrameConstraintFlag = bVal; }
bool getNoQtbttDualTreeIntraConstraintFlag() const { return m_bNoQtbttDualTreeIntraConstraintFlag; }
void setNoQtbttDualTreeIntraConstraintFlag(bool bVal) { m_bNoQtbttDualTreeIntraConstraintFlag = bVal; }
bool getNoSaoConstraintFlag() const { return m_bNoSaoConstraintFlag; }
void setNoSaoConstraintFlag(bool bVal) { m_bNoSaoConstraintFlag = bVal; }
bool getNoAlfConstraintFlag() const { return m_bNoAlfConstraintFlag; }
void setNoAlfConstraintFlag(bool bVal) { m_bNoAlfConstraintFlag = bVal; }
bool getNoPcmConstraintFlag() const { return m_bNoPcmConstraintFlag; }
void setNoPcmConstraintFlag(bool bVal) { m_bNoPcmConstraintFlag = bVal; }
bool getNoRefWraparoundConstraintFlag() const { return m_bNoRefWraparoundConstraintFlag; }
void setNoRefWraparoundConstraintFlag(bool bVal) { m_bNoRefWraparoundConstraintFlag = bVal; }
Zhipin Deng
committed
bool getNoTemporalMvpConstraintFlag() const { return m_bNoTemporalMvpConstraintFlag; }
void setNoTemporalMvpConstraintFlag(bool bVal) { m_bNoTemporalMvpConstraintFlag = bVal; }
bool getNoSbtmvpConstraintFlag() const { return m_bNoSbtmvpConstraintFlag; }
void setNoSbtmvpConstraintFlag(bool bVal) { m_bNoSbtmvpConstraintFlag = bVal; }
bool getNoAmvrConstraintFlag() const { return m_bNoAmvrConstraintFlag; }
void setNoAmvrConstraintFlag(bool bVal) { m_bNoAmvrConstraintFlag = bVal; }
bool getNoBdofConstraintFlag() const { return m_bNoBdofConstraintFlag; }
void setNoBdofConstraintFlag(bool bVal) { m_bNoBdofConstraintFlag = bVal; }
bool getNoCclmConstraintFlag() const { return m_bNoCclmConstraintFlag; }
void setNoCclmConstraintFlag(bool bVal) { m_bNoCclmConstraintFlag = bVal; }
Zhipin Deng
committed
bool getNoMtsConstraintFlag() const { return m_bNoMtsConstraintFlag; }
void setNoMtsConstraintFlag(bool bVal) { m_bNoMtsConstraintFlag = bVal; }
bool getNoAffineMotionConstraintFlag() const { return m_bNoAffineMotionConstraintFlag; }
void setNoAffineMotionConstraintFlag(bool bVal) { m_bNoAffineMotionConstraintFlag = bVal; }
bool getNoGbiConstraintFlag() const { return m_bNoGbiConstraintFlag; }
void setNoGbiConstraintFlag(bool bVal) { m_bNoGbiConstraintFlag = bVal; }
bool getNoMhIntraConstraintFlag() const { return m_bNoMhIntraConstraintFlag; }
void setNoMhIntraConstraintFlag(bool bVal) { m_bNoMhIntraConstraintFlag = bVal; }
bool getNoTriangleConstraintFlag() const { return m_bNoTriangleConstraintFlag; }
void setNoTriangleConstraintFlag(bool bVal) { m_bNoTriangleConstraintFlag = bVal; }
Zhipin Deng
committed
bool getNoLadfConstraintFlag() const { return m_bNoLadfConstraintFlag; }
void setNoLadfConstraintFlag(bool bVal) { m_bNoLadfConstraintFlag = bVal; }
bool getNoCurrPicRefConstraintFlag() const { return m_bNoCurrPicRefConstraintFlag; }
void setNoCurrPicRefConstraintFlag(bool bVal) { m_bNoCurrPicRefConstraintFlag = bVal; }
bool getNoQpDeltaConstraintFlag() const { return m_bNoQpDeltaConstraintFlag; }
void setNoQpDeltaConstraintFlag(bool bVal) { m_bNoQpDeltaConstraintFlag = bVal; }
Zhipin Deng
committed
bool getNoDepQuantConstraintFlag() const { return m_bNoDepQuantConstraintFlag; }
void setNoDepQuantConstraintFlag(bool bVal) { m_bNoDepQuantConstraintFlag = bVal; }
bool getNoSignDataHidingConstraintFlag() const { return m_bNoSignDataHidingConstraintFlag; }
void setNoSignDataHidingConstraintFlag(bool bVal) { m_bNoSignDataHidingConstraintFlag = bVal; }
Karsten Suehring
committed
void setFrameRate ( int i ) { m_iFrameRate = i; }
void setFrameSkip ( uint32_t i ) { m_FrameSkip = i; }
void setTemporalSubsampleRatio ( uint32_t i ) { m_temporalSubsampleRatio = i; }
void setSourceWidth ( int i ) { m_iSourceWidth = i; }
void setSourceHeight ( int i ) { m_iSourceHeight = i; }
Window &getConformanceWindow() { return m_conformanceWindow; }
void setConformanceWindow (int confLeft, int confRight, int confTop, int confBottom ) { m_conformanceWindow.setWindow (confLeft, confRight, confTop, confBottom); }
void setFramesToBeEncoded ( int i ) { m_framesToBeEncoded = i; }
bool getPrintMSEBasedSequencePSNR () const { return m_printMSEBasedSequencePSNR; }
void setPrintMSEBasedSequencePSNR (bool value) { m_printMSEBasedSequencePSNR = value; }
bool getPrintHexPsnr () const { return m_printHexPsnr; }
void setPrintHexPsnr (bool value) { m_printHexPsnr = value; }
Karsten Suehring
committed
bool getPrintFrameMSE () const { return m_printFrameMSE; }
void setPrintFrameMSE (bool value) { m_printFrameMSE = value; }
bool getPrintSequenceMSE () const { return m_printSequenceMSE; }
void setPrintSequenceMSE (bool value) { m_printSequenceMSE = value; }
bool getCabacZeroWordPaddingEnabled() const { return m_cabacZeroWordPaddingEnabled; }
void setCabacZeroWordPaddingEnabled(bool value) { m_cabacZeroWordPaddingEnabled = value; }
//====== Coding Structure ========
void setIntraPeriod ( int i ) { m_uiIntraPeriod = (uint32_t)i; }
void setDecodingRefreshType ( int i ) { m_uiDecodingRefreshType = (uint32_t)i; }
#if JCTVC_Y0038_PARAMS
void setReWriteParamSets ( bool b ) { m_rewriteParamSets = b; }
#endif
Karsten Suehring
committed
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
void setGOPSize ( int i ) { m_iGOPSize = i; }
void setGopList ( const GOPEntry GOPList[MAX_GOP] ) { for ( int i = 0; i < MAX_GOP; i++ ) m_GOPList[i] = GOPList[i]; }
void setExtraRPSs ( int i ) { m_extraRPSs = i; }
const GOPEntry &getGOPEntry ( int i ) const { return m_GOPList[i]; }
void setEncodedFlag ( int i, bool value ) { m_GOPList[i].m_isEncoded = value; }
void setMaxDecPicBuffering ( uint32_t u, uint32_t tlayer ) { m_maxDecPicBuffering[tlayer] = u; }
void setNumReorderPics ( int i, uint32_t tlayer ) { m_numReorderPics[tlayer] = i; }
void setBaseQP ( int i ) { m_iQP = i; }
#if X0038_LAMBDA_FROM_QP_CAPABILITY
void setIntraQPOffset ( int i ) { m_intraQPOffset = i; }
void setLambdaFromQPEnable ( bool b ) { m_lambdaFromQPEnable = b; }
#endif
void setPad ( int* iPad ) { for ( int i = 0; i < 2; i++ ) m_aiPad[i] = iPad[i]; }
int getMaxRefPicNum () { return m_iMaxRefPicNum; }
void setMaxRefPicNum ( int iMaxRefPicNum ) { m_iMaxRefPicNum = iMaxRefPicNum; }
int getMaxTempLayer () { return m_maxTempLayer; }
void setMaxTempLayer ( int maxTempLayer ) { m_maxTempLayer = maxTempLayer; }
void setCTUSize ( unsigned u ) { m_CTUSize = u; }
void setMinQTSizes ( unsigned* minQT) { m_uiMinQT[0] = minQT[0]; m_uiMinQT[1] = minQT[1]; m_uiMinQT[2] = minQT[2]; }
void setMaxBTDepth ( unsigned uiMaxBTDepth, unsigned uiMaxBTDepthI, unsigned uiMaxBTDepthIChroma )
{ m_uiMaxBTDepth = uiMaxBTDepth; m_uiMaxBTDepthI = uiMaxBTDepthI; m_uiMaxBTDepthIChroma = uiMaxBTDepthIChroma; }
unsigned getMaxBTDepth () const { return m_uiMaxBTDepth; }
unsigned getMaxBTDepthI () const { return m_uiMaxBTDepthI; }
unsigned getMaxBTDepthIChroma () const { return m_uiMaxBTDepthIChroma; }
int getCTUSize () const { return m_CTUSize; }
void setUseSplitConsOverride (bool n) { m_useSplitConsOverride = n; }
bool getUseSplitConsOverride () const { return m_useSplitConsOverride; }
Karsten Suehring
committed
void setDualITree ( bool b ) { m_dualITree = b; }
bool getDualITree () const { return m_dualITree; }
void setUseLMChroma ( int n ) { m_LMChroma = n; }
int getUseLMChroma() const { return m_LMChroma; }
void setCclmCollocatedChromaFlag ( bool b ) { m_cclmCollocatedChromaFlag = b; }
bool getCclmCollocatedChromaFlag () const { return m_cclmCollocatedChromaFlag; }
Karsten Suehring
committed
void setSubPuMvpMode(int n) { m_SubPuMvpMode = n; }
bool getSubPuMvpMode() const { return m_SubPuMvpMode; }
void setAffine ( bool b ) { m_Affine = b; }
bool getAffine () const { return m_Affine; }
void setAffineType( bool b ) { m_AffineType = b; }
bool getAffineType() const { return m_AffineType; }
void setBIO(bool b) { m_BIO = b; }
bool getBIO() const { return m_BIO; }
Karsten Suehring
committed
void setIntraMTSMaxCand ( unsigned u ) { m_IntraMTSMaxCand = u; }
unsigned getIntraMTSMaxCand () const { return m_IntraMTSMaxCand; }
void setInterMTSMaxCand ( unsigned u ) { m_InterMTSMaxCand = u; }
unsigned getInterMTSMaxCand () const { return m_InterMTSMaxCand; }
void setIntraMTS ( bool b ) { m_IntraMTS = b; }
bool getIntraMTS () const { return m_IntraMTS; }
void setInterMTS ( bool b ) { m_InterMTS = b; }
bool getInterMTS () const { return m_InterMTS; }
void setImplicitMTS ( bool b ) { m_ImplicitMTS = b; }
bool getImplicitMTS () const { return m_ImplicitMTS; }
void setUseSBT ( bool b ) { m_SBT = b; }
bool getUseSBT () const { return m_SBT; }
Karsten Suehring
committed
void setUseCompositeRef (bool b) { m_compositeRefEnabled = b; }
bool getUseCompositeRef () const { return m_compositeRefEnabled; }
#if JVET_N0235_SMVD_SPS
void setUseSMVD ( bool b ) { m_SMVD = b; }
bool getUseSMVD () const { return m_SMVD; }
#endif
void setUseGBi ( bool b ) { m_GBi = b; }
bool getUseGBi () const { return m_GBi; }
void setUseGBiFast ( uint32_t b ) { m_GBiFast = b; }
bool getUseGBiFast () const { return m_GBiFast; }
Shunsuke Iwamura
committed
#if LUMA_ADAPTIVE_DEBLOCKING_FILTER_QP_OFFSET
void setUseLadf ( bool b ) { m_LadfEnabled = b; }
bool getUseLadf () const { return m_LadfEnabled; }
void setLadfNumIntervals ( int i ) { m_LadfNumIntervals = i; }
int getLadfNumIntervals () const { return m_LadfNumIntervals; }
void setLadfQpOffset ( int value, int idx ){ m_LadfQpOffset[ idx ] = value; }
int getLadfQpOffset ( int idx ) const { return m_LadfQpOffset[ idx ]; }
void setLadfIntervalLowerBound ( int value, int idx ){ m_LadfIntervalLowerBound[ idx ] = value; }
int getLadfIntervalLowerBound ( int idx ) const { return m_LadfIntervalLowerBound[ idx ]; }
void setUseMHIntra ( bool b ) { m_MHIntra = b; }
bool getUseMHIntra () const { return m_MHIntra; }
void setUseTriangle ( bool b ) { m_Triangle = b; }
bool getUseTriangle () const { return m_Triangle; }
void setAllowDisFracMMVD ( bool b ) { m_allowDisFracMMVD = b; }
bool getAllowDisFracMMVD () const { return m_allowDisFracMMVD; }
void setUseHashME ( bool b ) { m_HashME = b; }
bool getUseHashME () const { return m_HashME; }
void setUseAffineAmvr ( bool b ) { m_AffineAmvr = b; }
bool getUseAffineAmvr () const { return m_AffineAmvr; }
Hongbin Liu
committed
void setUseAffineAmvrEncOpt ( bool b ) { m_AffineAmvrEncOpt = b; }
bool getUseAffineAmvrEncOpt () const { return m_AffineAmvrEncOpt; }
void setDMVR ( bool b ) { m_DMVR = b; }
bool getDMVR () const { return m_DMVR; }
#if JVET_N0127_MMVD_SPS_FLAG
void setMMVD (bool b) { m_MMVD = b; }
bool getMMVD () const { return m_MMVD; }
#endif
#if JVET_N0449_MMVD_SIMP
void setMmvdDisNum ( int b ) { m_MmvdDisNum = b; }
int getMmvdDisNum () const { return m_MmvdDisNum; }
#endif
void setIBCMode (unsigned n) { m_IBCMode = n; }
unsigned getIBCMode () const { return m_IBCMode; }
void setIBCLocalSearchRangeX (unsigned n) { m_IBCLocalSearchRangeX = n; }
unsigned getIBCLocalSearchRangeX () const { return m_IBCLocalSearchRangeX; }
void setIBCLocalSearchRangeY (unsigned n) { m_IBCLocalSearchRangeY = n; }
unsigned getIBCLocalSearchRangeY () const { return m_IBCLocalSearchRangeY; }
void setIBCHashSearch (unsigned n) { m_IBCHashSearch = n; }
unsigned getIBCHashSearch () const { return m_IBCHashSearch; }
void setIBCHashSearchMaxCand (unsigned n) { m_IBCHashSearchMaxCand = n; }
unsigned getIBCHashSearchMaxCand () const { return m_IBCHashSearchMaxCand; }
void setIBCHashSearchRange4SmallBlk (unsigned n) { m_IBCHashSearchRange4SmallBlk = n; }
unsigned getIBCHashSearchRange4SmallBlk () const { return m_IBCHashSearchRange4SmallBlk; }
void setIBCFastMethod (unsigned n) { m_IBCFastMethod = n; }
unsigned getIBCFastMethod () const { return m_IBCFastMethod; }
void setUseWrapAround ( bool b ) { m_wrapAround = b; }
bool getUseWrapAround () const { return m_wrapAround; }
void setWrapAroundOffset ( unsigned u ) { m_wrapAroundOffset = u; }
unsigned getWrapAroundOffset () const { return m_wrapAroundOffset; }
Karsten Suehring
committed
// ADD_NEW_TOOL : (encoder lib) add access functions here
#if INCLUDE_ISP_CFG_FLAG
void setUseISP ( bool b ) { m_ISP = b; }
bool getUseISP () const { return m_ISP; }
#endif
void setReshaper ( bool b ) { m_lumaReshapeEnable = b; }
bool getReshaper () const { return m_lumaReshapeEnable; }
void setReshapeSignalType ( uint32_t signalType ) { m_reshapeSignalType = signalType; }
uint32_t getReshapeSignalType () const { return m_reshapeSignalType; }
void setReshapeIntraCMD (uint32_t intraCMD) { m_intraCMD = intraCMD; }
uint32_t getReshapeIntraCMD () { return m_intraCMD; }
void setReshapeCW (const ReshapeCW &reshapeCW) { m_reshapeCW = reshapeCW; }
const ReshapeCW& getReshapeCW () { return m_reshapeCW; }
Karsten Suehring
committed
void setMaxCUWidth ( uint32_t u ) { m_maxCUWidth = u; }
uint32_t getMaxCUWidth () const { return m_maxCUWidth; }
void setMaxCUHeight ( uint32_t u ) { m_maxCUHeight = u; }
uint32_t getMaxCUHeight () const { return m_maxCUHeight; }
void setMaxCodingDepth ( uint32_t u ) { m_maxTotalCUDepth = u; }
uint32_t getMaxCodingDepth () const { return m_maxTotalCUDepth; }
void setLog2DiffMaxMinCodingBlockSize( uint32_t u ) { m_log2DiffMaxMinCodingBlockSize = u; }
void setUseEncDbOpt ( bool n ) { m_encDbOpt = n; }
bool getUseEncDbOpt () const { return m_encDbOpt; }
Karsten Suehring
committed
void setUseFastLCTU ( bool n ) { m_useFastLCTU = n; }
bool getUseFastLCTU () const { return m_useFastLCTU; }
void setUseFastMerge ( bool n ) { m_useFastMrg = n; }
bool getUseFastMerge () const { return m_useFastMrg; }
void setUsePbIntraFast ( bool n ) { m_usePbIntraFast = n; }
bool getUsePbIntraFast () const { return m_usePbIntraFast; }
void setUseAMaxBT ( bool n ) { m_useAMaxBT = n; }
bool getUseAMaxBT () const { return m_useAMaxBT; }
void setUseE0023FastEnc ( bool b ) { m_e0023FastEnc = b; }
bool getUseE0023FastEnc () const { return m_e0023FastEnc; }
void setUseContentBasedFastQtbt ( bool b ) { m_contentBasedFastQtbt = b; }
bool getUseContentBasedFastQtbt () const { return m_contentBasedFastQtbt; }
#if JVET_N0242_NON_LINEAR_ALF
void setUseNonLinearAlfLuma ( bool b ) { m_useNonLinearAlfLuma = b; }
bool getUseNonLinearAlfLuma () const { return m_useNonLinearAlfLuma; }
void setUseNonLinearAlfChroma ( bool b ) { m_useNonLinearAlfChroma = b; }
bool getUseNonLinearAlfChroma () const { return m_useNonLinearAlfChroma; }
#endif
Karsten Suehring
committed
#if MAX_TB_SIZE_SIGNALLING
void setLog2MaxTbSize ( uint32_t u ) { m_log2MaxTbSize = u; }
#endif
Karsten Suehring
committed
//====== Loop/Deblock Filter ========
void setLoopFilterDisable ( bool b ) { m_bLoopFilterDisable = b; }
void setLoopFilterOffsetInPPS ( bool b ) { m_loopFilterOffsetInPPS = b; }
void setLoopFilterBetaOffset ( int i ) { m_loopFilterBetaOffsetDiv2 = i; }
void setLoopFilterTcOffset ( int i ) { m_loopFilterTcOffsetDiv2 = i; }
#if W0038_DB_OPT
void setDeblockingFilterMetric ( int i ) { m_deblockingFilterMetric = i; }
#else
void setDeblockingFilterMetric ( bool b ) { m_DeblockingFilterMetric = b; }
#endif
//====== Motion search ========
void setDisableIntraPUsInInterSlices ( bool b ) { m_bDisableIntraPUsInInterSlices = b; }
void setMotionEstimationSearchMethod ( MESearchMethod e ) { m_motionEstimationSearchMethod = e; }
void setSearchRange ( int i ) { m_iSearchRange = i; }
void setBipredSearchRange ( int i ) { m_bipredSearchRange = i; }
void setClipForBiPredMeEnabled ( bool b ) { m_bClipForBiPredMeEnabled = b; }
void setFastMEAssumingSmootherMVEnabled ( bool b ) { m_bFastMEAssumingSmootherMVEnabled = b; }
void setMinSearchWindow ( int i ) { m_minSearchWindow = i; }
void setRestrictMESampling ( bool b ) { m_bRestrictMESampling = b; }
//====== Quality control ========
void setMaxDeltaQP ( int i ) { m_iMaxDeltaQP = i; }
void setCuQpDeltaSubdiv ( int i ) { m_cuQpDeltaSubdiv = i; }
int getCuChromaQpOffsetSubdiv () const { return m_cuChromaQpOffsetSubdiv; }
void setCuChromaQpOffsetSubdiv (int value) { m_cuChromaQpOffsetSubdiv = value; }
Karsten Suehring
committed
void setChromaCbQpOffset ( int i ) { m_chromaCbQpOffset = i; }
void setChromaCrQpOffset ( int i ) { m_chromaCrQpOffset = i; }
void setChromaCbQpOffsetDualTree ( int i ) { m_chromaCbQpOffsetDualTree = i; }
void setChromaCrQpOffsetDualTree ( int i ) { m_chromaCrQpOffsetDualTree = i; }
int getChromaCbQpOffsetDualTree () const { return m_chromaCbQpOffsetDualTree; }
int getChromaCrQpOffsetDualTree () const { return m_chromaCrQpOffsetDualTree; }
#if JVET_N0054_JOINT_CHROMA
void setChromaCbCrQpOffset ( int i ) { m_chromaCbCrQpOffset = i; }
void setChromaCbCrQpOffsetDualTree ( int i ) { m_chromaCbCrQpOffsetDualTree = i; }
int getChromaCbCrQpOffsetDualTree () const { return m_chromaCbCrQpOffsetDualTree; }
#endif
Karsten Suehring
committed
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
#if ER_CHROMA_QP_WCG_PPS
void setWCGChromaQpControl ( const WCGChromaQPControl &ctrl ) { m_wcgChromaQpControl = ctrl; }
const WCGChromaQPControl &getWCGChromaQPControl () const { return m_wcgChromaQpControl; }
#endif
#if W0038_CQP_ADJ
void setSliceChromaOffsetQpIntraOrPeriodic( uint32_t periodicity, int sliceChromaQpOffsetIntraOrPeriodic[2]) { m_sliceChromaQpOffsetPeriodicity = periodicity; memcpy(m_sliceChromaQpOffsetIntraOrPeriodic, sliceChromaQpOffsetIntraOrPeriodic, sizeof(m_sliceChromaQpOffsetIntraOrPeriodic)); }
int getSliceChromaOffsetQpIntraOrPeriodic( bool bIsCr) const { return m_sliceChromaQpOffsetIntraOrPeriodic[bIsCr?1:0]; }
uint32_t getSliceChromaOffsetQpPeriodicity() const { return m_sliceChromaQpOffsetPeriodicity; }
#endif
void setChromaFormatIdc ( ChromaFormat cf ) { m_chromaFormatIDC = cf; }
#if REUSE_CU_RESULTS
ChromaFormat getChromaFormatIdc ( ) const { return m_chromaFormatIDC; }
#else
ChromaFormat getChromaFormatIdc ( ) { return m_chromaFormatIDC; }
#endif
#if SHARP_LUMA_DELTA_QP
void setLumaLevelToDeltaQPControls( const LumaLevelToDeltaQPMapping &lumaLevelToDeltaQPMapping ) { m_lumaLevelToDeltaQPMapping=lumaLevelToDeltaQPMapping; }
const LumaLevelToDeltaQPMapping& getLumaLevelToDeltaQPMapping() const { return m_lumaLevelToDeltaQPMapping; }
#endif
bool getExtendedPrecisionProcessingFlag () const { return m_extendedPrecisionProcessingFlag; }
void setExtendedPrecisionProcessingFlag (bool value) { m_extendedPrecisionProcessingFlag = value; }
bool getHighPrecisionOffsetsEnabledFlag() const { return m_highPrecisionOffsetsEnabledFlag; }
void setHighPrecisionOffsetsEnabledFlag(bool value) { m_highPrecisionOffsetsEnabledFlag = value; }
void setUseAdaptiveQP ( bool b ) { m_bUseAdaptiveQP = b; }
void setQPAdaptationRange ( int i ) { m_iQPAdaptationRange = i; }
#if ENABLE_QPA
void setUsePerceptQPA ( const bool b ) { m_bUsePerceptQPA = b; }
void setUseWPSNR ( const bool b ) { m_bUseWPSNR = b; }
#endif
//====== Sequence ========
int getFrameRate () const { return m_iFrameRate; }
uint32_t getFrameSkip () const { return m_FrameSkip; }
uint32_t getTemporalSubsampleRatio () const { return m_temporalSubsampleRatio; }
int getSourceWidth () const { return m_iSourceWidth; }
int getSourceHeight () const { return m_iSourceHeight; }
int getFramesToBeEncoded () const { return m_framesToBeEncoded; }
//====== Lambda Modifiers ========
void setLambdaModifier ( uint32_t uiIndex, double dValue ) { m_adLambdaModifier[ uiIndex ] = dValue; }
double getLambdaModifier ( uint32_t uiIndex ) const { return m_adLambdaModifier[ uiIndex ]; }
void setIntraLambdaModifier ( const std::vector<double> &dValue ) { m_adIntraLambdaModifier = dValue; }
const std::vector<double>& getIntraLambdaModifier() const { return m_adIntraLambdaModifier; }
void setIntraQpFactor ( double dValue ) { m_dIntraQpFactor = dValue; }
double getIntraQpFactor () const { return m_dIntraQpFactor; }
//==== Coding Structure ========
uint32_t getIntraPeriod () const { return m_uiIntraPeriod; }
uint32_t getDecodingRefreshType () const { return m_uiDecodingRefreshType; }
#if JCTVC_Y0038_PARAMS
bool getReWriteParamSets () const { return m_rewriteParamSets; }
#endif
Karsten Suehring
committed
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
int getGOPSize () const { return m_iGOPSize; }
int getMaxDecPicBuffering (uint32_t tlayer) { return m_maxDecPicBuffering[tlayer]; }
int getNumReorderPics (uint32_t tlayer) { return m_numReorderPics[tlayer]; }
#if X0038_LAMBDA_FROM_QP_CAPABILITY
int getIntraQPOffset () const { return m_intraQPOffset; }
int getLambdaFromQPEnable () const { return m_lambdaFromQPEnable; }
public:
int getBaseQP () const { return m_iQP; } // public should use getQPForPicture.
int getQPForPicture (const uint32_t gopIndex, const Slice *pSlice) const; // Function actually defined in EncLib.cpp
#else
int getBaseQP () { return m_iQP; }
#endif
int getPad ( int i ) { CHECK(i >= 2, "Invalid index"); return m_aiPad[i]; }
bool getAccessUnitDelimiter() const { return m_AccessUnitDelimiter; }
void setAccessUnitDelimiter(bool val){ m_AccessUnitDelimiter = val; }
//==== Loop/Deblock Filter ========
bool getLoopFilterDisable () { return m_bLoopFilterDisable; }
bool getLoopFilterOffsetInPPS () { return m_loopFilterOffsetInPPS; }
int getLoopFilterBetaOffset () { return m_loopFilterBetaOffsetDiv2; }
int getLoopFilterTcOffset () { return m_loopFilterTcOffsetDiv2; }
#if W0038_DB_OPT
int getDeblockingFilterMetric () { return m_deblockingFilterMetric; }
#else
bool getDeblockingFilterMetric () { return m_DeblockingFilterMetric; }
#endif
//==== Motion search ========
bool getDisableIntraPUsInInterSlices () const { return m_bDisableIntraPUsInInterSlices; }
MESearchMethod getMotionEstimationSearchMethod ( ) const { return m_motionEstimationSearchMethod; }
int getSearchRange () const { return m_iSearchRange; }
bool getClipForBiPredMeEnabled () const { return m_bClipForBiPredMeEnabled; }
bool getFastMEAssumingSmootherMVEnabled () const { return m_bFastMEAssumingSmootherMVEnabled; }
int getMinSearchWindow () const { return m_minSearchWindow; }
bool getRestrictMESampling () const { return m_bRestrictMESampling; }
//==== Quality control ========
int getMaxDeltaQP () const { return m_iMaxDeltaQP; }
int getCuQpDeltaSubdiv () const { return m_cuQpDeltaSubdiv; }
Karsten Suehring
committed
bool getUseAdaptiveQP () const { return m_bUseAdaptiveQP; }
int getQPAdaptationRange () const { return m_iQPAdaptationRange; }
#if ENABLE_QPA
bool getUsePerceptQPA () const { return m_bUsePerceptQPA; }
bool getUseWPSNR () const { return m_bUseWPSNR; }
#endif
//==== Tool list ========
void setBitDepth( const ChannelType chType, int internalBitDepthForChannel ) { m_bitDepth[chType] = internalBitDepthForChannel; }