Newer
Older
Karsten Suehring
committed
1
2
3
4
5
6
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
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
316
317
318
319
320
321
322
323
324
325
326
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
379
380
381
382
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
460
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
490
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
571
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
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
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
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
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
949
950
951
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
991
992
993
994
995
996
997
998
999
1000
/* 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-2018, ITU/ISO/IEC
* 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;
/* 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.
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
bool m_useAMP;
bool m_QTBT;
unsigned m_CTUSize;
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;
#if JVET_K0190
int m_LMChroma;
#endif
#if JVET_K1000_SIMPLIFIED_EMT
int m_IntraEMT;
int m_InterEMT;
int m_FastIntraEMT;
int m_FastInterEMT;
#endif
bool m_LargeCTU;
#if JVET_K0346
int m_SubPuMvpMode;
unsigned m_SubPuMvpLog2Size;
#endif
#if JVET_K_AFFINE
bool m_Affine;
#if JVET_K0337_AFFINE_6PARA
bool m_AffineType;
#endif
#endif
#if JVET_K0346 || JVET_K_AFFINE
bool m_highPrecMv;
#endif
bool m_DisableMotionCompression;
unsigned m_MTTMode;
#if ENABLE_WPP_PARALLELISM
bool m_AltDQPCoding;
#endif
// ADD_NEW_TOOL : (encoder lib) add tool enabling flags and associated parameters here
bool m_useFastLCTU;
bool m_useFastMrg;
bool m_usePbIntraFast;
bool m_useAMaxBT;
#if !JVET_K0220_ENC_CTRL
bool m_useSaveLoadEncInfo;
bool m_useSaveLoadSplitDecision;
#endif
bool m_e0023FastEnc;
bool m_contentBasedFastQtbt;
//======= Transform =============
uint32_t m_uiQuadtreeTULog2MaxSize;
uint32_t m_uiQuadtreeTULog2MinSize;
uint32_t m_uiQuadtreeTUMaxDepthInter;
uint32_t m_uiQuadtreeTUMaxDepthIntra;
//====== 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_iMaxCuDQPDepth; // Max. depth for a minimum CuDQP (0:default)
int m_diffCuChromaQpOffsetDepth; ///< If negative, then do not apply chroma qp offsets.
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 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;
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;
#if HEVC_TILES_WPP
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;
#endif
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;
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
#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;
#if JVET_K0072
bool m_DepQuantEnabledFlag;
#endif
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
#if HEVC_TILES_WPP
bool m_tilesFixedStructureFlag; ///< Indicates that each active picture parameter set has the same values of the syntax elements related to tiles
#endif
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.
#if JVET_K0357_AMVR
int m_ImvMode;
int m_Imv4PelFast;
int m_ImvMaxCand;
#endif
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; ///<
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
#if JVET_K0371_ALF
bool m_alf; ///< Adaptive Loop Filter
#endif
public:
EncCfg()
#if HEVC_TILES_WPP
: m_tileColumnWidth()
, m_tileRowHeight()
#endif
{
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; }
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; }
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; }
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 setQTBT ( bool b ) { m_QTBT = b; }
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; }
bool getQTBT () const { return m_QTBT; }
int getCTUSize () const { return m_CTUSize; }
void setDualITree ( bool b ) { m_dualITree = b; }
bool getDualITree () const { return m_dualITree; }
void setLargeCTU ( bool b ) { m_LargeCTU = b; }
bool getLargeCTU () const { return m_LargeCTU; }
#if JVET_K0190
void setUseLMChroma ( int n ) { m_LMChroma = n; }
int getUseLMChroma() const { return m_LMChroma; }
#endif
#if JVET_K0346
void setSubPuMvpMode(int n) { m_SubPuMvpMode = n; }
bool getSubPuMvpMode() const { return m_SubPuMvpMode; }
void setSubPuMvpLog2Size(unsigned n) { m_SubPuMvpLog2Size = n; }
unsigned getSubPuMvpLog2Size() const { return m_SubPuMvpLog2Size; }
#endif
#if JVET_K_AFFINE
void setAffine ( bool b ) { m_Affine = b; }
bool getAffine () const { return m_Affine; }
#if JVET_K0337_AFFINE_6PARA
void setAffineType( bool b ) { m_AffineType = b; }
bool getAffineType() const { return m_AffineType; }
#endif
#endif
#if JVET_K0346 || JVET_K_AFFINE
void setHighPrecisionMv(bool b) { m_highPrecMv = b; }
bool getHighPrecisionMv() { return m_highPrecMv; }
#endif
void setDisableMotionCompression ( bool b ) { m_DisableMotionCompression = b; }
bool getDisableMotionCompression () const { return m_DisableMotionCompression; }
void setMTTMode ( unsigned u ) { m_MTTMode = u; }
unsigned getMTTMode () const { return m_MTTMode; }
#if ENABLE_WPP_PARALLELISM
void setUseAltDQPCoding ( bool b ) { m_AltDQPCoding = b; }
bool getUseAltDQPCoding () const { return m_AltDQPCoding; }
#endif
#if JVET_K1000_SIMPLIFIED_EMT
void setFastIntraEMT ( bool b ) { m_FastIntraEMT = b; }
bool getFastIntraEMT () const { return m_FastIntraEMT; }
void setFastInterEMT ( bool b ) { m_FastInterEMT = b; }
bool getFastInterEMT () const { return m_FastInterEMT; }
void setIntraEMT ( bool b ) { m_IntraEMT = b; }
bool getIntraEMT () const { return m_IntraEMT; }
void setInterEMT ( bool b ) { m_InterEMT = b; }
bool getInterEMT () const { return m_InterEMT; }
#endif
// ADD_NEW_TOOL : (encoder lib) add access functions here
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 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; }
#if !JVET_K0220_ENC_CTRL
void setUseSaveLoadEncInfo ( bool b ) { m_useSaveLoadEncInfo = b; }
void setUseSaveLoadSplitDecision ( bool b ) { m_useSaveLoadSplitDecision = b; }
bool getUseSaveLoadEncInfo () const { return m_useSaveLoadEncInfo; }
bool getUseSaveLoadSplitDecision () const { return m_useSaveLoadSplitDecision; }
#endif
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; }
//======== Transform =============
void setQuadtreeTULog2MaxSize ( uint32_t u ) { m_uiQuadtreeTULog2MaxSize = u; }
void setQuadtreeTULog2MinSize ( uint32_t u ) { m_uiQuadtreeTULog2MinSize = u; }
void setQuadtreeTUMaxDepthInter ( uint32_t u ) { m_uiQuadtreeTUMaxDepthInter = u; }
void setQuadtreeTUMaxDepthIntra ( uint32_t u ) { m_uiQuadtreeTUMaxDepthIntra = u; }
void setUseAMP( bool b ) { m_useAMP = b; }
//====== 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 setMaxCuDQPDepth ( int i ) { m_iMaxCuDQPDepth = i; }
int getDiffCuChromaQpOffsetDepth () const { return m_diffCuChromaQpOffsetDepth; }
void setDiffCuChromaQpOffsetDepth (int value) { m_diffCuChromaQpOffsetDepth = value; }
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 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; }
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; }
#if ENABLE_QPA
public:
#else
protected:
#endif
int getBaseQP () const { return m_iQP; } // public should use getQPForPicture.
public:
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; }
//======== Transform =============
uint32_t getQuadtreeTULog2MaxSize () const { return m_uiQuadtreeTULog2MaxSize; }
uint32_t getQuadtreeTULog2MinSize () const { return m_uiQuadtreeTULog2MinSize; }
uint32_t getQuadtreeTUMaxDepthInter () const { return m_uiQuadtreeTUMaxDepthInter; }
uint32_t getQuadtreeTUMaxDepthIntra () const { return m_uiQuadtreeTUMaxDepthIntra; }
//==== 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 getMaxCuDQPDepth () const { return m_iMaxCuDQPDepth; }
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; }
void setInputBitDepth( const ChannelType chType, int internalBitDepthForChannel ) { m_inputBitDepth[chType] = internalBitDepthForChannel; }
void setUseASR ( bool b ) { m_bUseASR = b; }
void setUseHADME ( bool b ) { m_bUseHADME = b; }
void setUseRDOQ ( bool b ) { m_useRDOQ = b; }
void setUseRDOQTS ( bool b ) { m_useRDOQTS = b; }
#if T0196_SELECTIVE_RDOQ
void setUseSelectiveRDOQ ( bool b ) { m_useSelectiveRDOQ = b; }
#endif
void setRDpenalty ( uint32_t u ) { m_rdPenalty = u; }
void setFastInterSearchMode ( FastInterSearchMode m ) { m_fastInterSearchMode = m; }
void setUseEarlyCU ( bool b ) { m_bUseEarlyCU = b; }
void setUseFastDecisionForMerge ( bool b ) { m_useFastDecisionForMerge = b; }
void setUseCbfFastMode ( bool b ) { m_bUseCbfFastMode = b; }
void setUseEarlySkipDetection ( bool b ) { m_useEarlySkipDetection = b; }
void setUseConstrainedIntraPred ( bool b ) { m_bUseConstrainedIntraPred = b; }
void setFastUDIUseMPMEnabled ( bool b ) { m_bFastUDIUseMPMEnabled = b; }
void setFastMEForGenBLowDelayEnabled ( bool b ) { m_bFastMEForGenBLowDelayEnabled = b; }
void setUseBLambdaForNonKeyLowDelayPictures ( bool b ) { m_bUseBLambdaForNonKeyLowDelayPictures = b; }
void setPCMInputBitDepthFlag ( bool b ) { m_bPCMInputBitDepthFlag = b; }
void setPCMFilterDisableFlag ( bool b ) { m_bPCMFilterDisableFlag = b; }
void setUsePCM ( bool b ) { m_usePCM = b; }
void setPCMBitDepth( const ChannelType chType, int pcmBitDepthForChannel ) { m_PCMBitDepth[chType] = pcmBitDepthForChannel; }
void setPCMLog2MaxSize ( uint32_t u ) { m_pcmLog2MaxSize = u; }
void setPCMLog2MinSize ( uint32_t u ) { m_uiPCMLog2MinSize = u; }
void setdQPs ( int* p ) { m_aidQP = p; }
void setDeltaQpRD ( uint32_t u ) {m_uiDeltaQpRD = u; }
void setFastDeltaQp ( bool b ) {m_bFastDeltaQP = b; }
int getBitDepth (const ChannelType chType) const { return m_bitDepth[chType]; }
bool getUseASR () { return m_bUseASR; }
bool getUseHADME () { return m_bUseHADME; }
bool getUseRDOQ () { return m_useRDOQ; }
bool getUseRDOQTS () { return m_useRDOQTS; }
#if T0196_SELECTIVE_RDOQ
bool getUseSelectiveRDOQ () { return m_useSelectiveRDOQ; }
#endif
int getRDpenalty () { return m_rdPenalty; }
FastInterSearchMode getFastInterSearchMode() const{ return m_fastInterSearchMode; }
bool getUseEarlyCU () const{ return m_bUseEarlyCU; }
bool getUseFastDecisionForMerge () const{ return m_useFastDecisionForMerge; }
bool getUseCbfFastMode () const{ return m_bUseCbfFastMode; }
bool getUseEarlySkipDetection () const{ return m_useEarlySkipDetection; }
bool getUseConstrainedIntraPred () { return m_bUseConstrainedIntraPred; }
bool getFastUDIUseMPMEnabled () { return m_bFastUDIUseMPMEnabled; }
bool getFastMEForGenBLowDelayEnabled () { return m_bFastMEForGenBLowDelayEnabled; }
bool getUseBLambdaForNonKeyLowDelayPictures () { return m_bUseBLambdaForNonKeyLowDelayPictures; }
bool getPCMInputBitDepthFlag () { return m_bPCMInputBitDepthFlag; }
bool getPCMFilterDisableFlag () { return m_bPCMFilterDisableFlag; }
bool getUsePCM () { return m_usePCM; }
uint32_t getPCMLog2MaxSize () { return m_pcmLog2MaxSize; }
uint32_t getPCMLog2MinSize () { return m_uiPCMLog2MinSize; }
bool getCrossComponentPredictionEnabledFlag () const { return m_crossComponentPredictionEnabledFlag; }
void setCrossComponentPredictionEnabledFlag (const bool value) { m_crossComponentPredictionEnabledFlag = value; }
bool getUseReconBasedCrossCPredictionEstimate () const { return m_reconBasedCrossCPredictionEstimate; }
void setUseReconBasedCrossCPredictionEstimate (const bool value) { m_reconBasedCrossCPredictionEstimate = value; }
void setLog2SaoOffsetScale(ChannelType type, uint32_t uiBitShift) { m_log2SaoOffsetScale[type] = uiBitShift; }
bool getUseTransformSkip () { return m_useTransformSkip; }
void setUseTransformSkip ( bool b ) { m_useTransformSkip = b; }
bool getTransformSkipRotationEnabledFlag () const { return m_transformSkipRotationEnabledFlag; }
void setTransformSkipRotationEnabledFlag (const bool value) { m_transformSkipRotationEnabledFlag = value; }
bool getTransformSkipContextEnabledFlag () const { return m_transformSkipContextEnabledFlag; }
void setTransformSkipContextEnabledFlag (const bool value) { m_transformSkipContextEnabledFlag = value; }
bool getPersistentRiceAdaptationEnabledFlag () const { return m_persistentRiceAdaptationEnabledFlag; }
void setPersistentRiceAdaptationEnabledFlag (const bool value) { m_persistentRiceAdaptationEnabledFlag = value; }
bool getCabacBypassAlignmentEnabledFlag () const { return m_cabacBypassAlignmentEnabledFlag; }
void setCabacBypassAlignmentEnabledFlag (const bool value) { m_cabacBypassAlignmentEnabledFlag = value; }
bool getRdpcmEnabledFlag (const RDPCMSignallingMode signallingMode) const { return m_rdpcmEnabledFlag[signallingMode]; }
void setRdpcmEnabledFlag (const RDPCMSignallingMode signallingMode, const bool value) { m_rdpcmEnabledFlag[signallingMode] = value; }
bool getUseTransformSkipFast () { return m_useTransformSkipFast; }
void setUseTransformSkipFast ( bool b ) { m_useTransformSkipFast = b; }
uint32_t getLog2MaxTransformSkipBlockSize () const { return m_log2MaxTransformSkipBlockSize; }
void setLog2MaxTransformSkipBlockSize ( uint32_t u ) { m_log2MaxTransformSkipBlockSize = u; }
bool getIntraSmoothingDisabledFlag () const { return m_intraSmoothingDisabledFlag; }
void setIntraSmoothingDisabledFlag (bool bValue) { m_intraSmoothingDisabledFlag=bValue; }
const int* getdQPs () const { return m_aidQP; }
uint32_t getDeltaQpRD () const { return m_uiDeltaQpRD; }
bool getFastDeltaQp () const { return m_bFastDeltaQP; }
//====== Slice ========
void setSliceMode ( SliceConstraint i ) { m_sliceMode = i; }
void setSliceArgument ( int i ) { m_sliceArgument = i; }
SliceConstraint getSliceMode () const { return m_sliceMode; }
int getSliceArgument () { return m_sliceArgument; }
//====== Dependent Slice ========
void setSliceSegmentMode ( SliceConstraint i ) { m_sliceSegmentMode = i; }
void setSliceSegmentArgument ( int i ) { m_sliceSegmentArgument = i; }
SliceConstraint getSliceSegmentMode () const { return m_sliceSegmentMode; }
int getSliceSegmentArgument () { return m_sliceSegmentArgument;}
void setLFCrossSliceBoundaryFlag ( bool bValue ) { m_bLFCrossSliceBoundaryFlag = bValue; }
bool getLFCrossSliceBoundaryFlag () { return m_bLFCrossSliceBoundaryFlag; }
void setUseSAO (bool bVal) { m_bUseSAO = bVal; }
bool getUseSAO () { return m_bUseSAO; }
void setTestSAODisableAtPictureLevel (bool bVal) { m_bTestSAODisableAtPictureLevel = bVal; }
bool getTestSAODisableAtPictureLevel ( ) const { return m_bTestSAODisableAtPictureLevel; }
void setSaoEncodingRate(double v) { m_saoEncodingRate = v; }
double getSaoEncodingRate() const { return m_saoEncodingRate; }
void setSaoEncodingRateChroma(double v) { m_saoEncodingRateChroma = v; }
double getSaoEncodingRateChroma() const { return m_saoEncodingRateChroma; }
void setMaxNumOffsetsPerPic (int iVal) { m_maxNumOffsetsPerPic = iVal; }
int getMaxNumOffsetsPerPic () { return m_maxNumOffsetsPerPic; }
void setSaoCtuBoundary (bool val) { m_saoCtuBoundary = val; }
bool getSaoCtuBoundary () { return m_saoCtuBoundary; }
#if K0238_SAO_GREEDY_MERGE_ENCODING
void setSaoGreedyMergeEnc (bool val) { m_saoGreedyMergeEnc = val; }
bool getSaoGreedyMergeEnc () { return m_saoGreedyMergeEnc; }
#endif
#if HEVC_TILES_WPP
void setLFCrossTileBoundaryFlag ( bool val ) { m_loopFilterAcrossTilesEnabledFlag = val; }
bool getLFCrossTileBoundaryFlag () { return m_loopFilterAcrossTilesEnabledFlag; }
void setTileUniformSpacingFlag ( bool b ) { m_tileUniformSpacingFlag = b; }
bool getTileUniformSpacingFlag () { return m_tileUniformSpacingFlag; }
void setNumColumnsMinus1 ( int i ) { m_iNumColumnsMinus1 = i; }
int getNumColumnsMinus1 () { return m_iNumColumnsMinus1; }
void setColumnWidth ( const std::vector<int>& columnWidth ) { m_tileColumnWidth = columnWidth; }
uint32_t getColumnWidth ( uint32_t columnIdx ) { return m_tileColumnWidth[columnIdx]; }
void setNumRowsMinus1 ( int i ) { m_iNumRowsMinus1 = i; }
int getNumRowsMinus1 () { return m_iNumRowsMinus1; }
void setRowHeight ( const std::vector<int>& rowHeight) { m_tileRowHeight = rowHeight; }
uint32_t getRowHeight ( uint32_t rowIdx ) { return m_tileRowHeight[rowIdx]; }
#endif
void xCheckGSParameters();
#if HEVC_TILES_WPP
void setEntropyCodingSyncEnabledFlag(bool b) { m_entropyCodingSyncEnabledFlag = b; }
bool getEntropyCodingSyncEnabledFlag() const { return m_entropyCodingSyncEnabledFlag; }
#endif
void setDecodedPictureHashSEIType(HashType m) { m_decodedPictureHashSEIType = m; }
HashType getDecodedPictureHashSEIType() const { return m_decodedPictureHashSEIType; }
void setBufferingPeriodSEIEnabled(bool b) { m_bufferingPeriodSEIEnabled = b; }
bool getBufferingPeriodSEIEnabled() const { return m_bufferingPeriodSEIEnabled; }
void setPictureTimingSEIEnabled(bool b) { m_pictureTimingSEIEnabled = b; }
bool getPictureTimingSEIEnabled() const { return m_pictureTimingSEIEnabled; }
void setRecoveryPointSEIEnabled(bool b) { m_recoveryPointSEIEnabled = b; }
bool getRecoveryPointSEIEnabled() const { return m_recoveryPointSEIEnabled; }
void setToneMappingInfoSEIEnabled(bool b) { m_toneMappingInfoSEIEnabled = b; }
bool getToneMappingInfoSEIEnabled() { return m_toneMappingInfoSEIEnabled; }
void setTMISEIToneMapId(int b) { m_toneMapId = b; }
int getTMISEIToneMapId() { return m_toneMapId; }
void setTMISEIToneMapCancelFlag(bool b) { m_toneMapCancelFlag=b; }