AOMedia AV1 Codec: av1/encoder/encoder.h Source File

| AOMedia AV1 Codec

encoder.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2016, Alliance for Open Media. All rights reserved.
3 *
4 * This source code is subject to the terms of the BSD 2 Clause License and
5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6 * was not distributed with this source code in the LICENSE file, you can
7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8 * Media Patent License 1.0 was not distributed with this source code in the
9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10 */
11
15#ifndef AOM_AV1_ENCODER_ENCODER_H_
16#define AOM_AV1_ENCODER_ENCODER_H_
17
18#include <stdbool.h>
19#include <stdio.h>
20
21#include "config/aom_config.h"
22
23#include "aom/aomcx.h"
24#include "aom_util/aom_pthread.h"
25
26#include "av1/common/alloccommon.h"
27#include "av1/common/av1_common_int.h"
28#include "av1/common/blockd.h"
29#include "av1/common/entropymode.h"
30#include "av1/common/enums.h"
31#include "av1/common/reconintra.h"
32#include "av1/common/resize.h"
33#include "av1/common/thread_common.h"
34#include "av1/common/timing.h"
35
36#include "av1/encoder/aq_cyclicrefresh.h"
37#include "av1/encoder/av1_quantize.h"
38#include "av1/encoder/block.h"
39#include "av1/encoder/context_tree.h"
40#include "av1/encoder/enc_enums.h"
41#include "av1/encoder/encodemb.h"
42#include "av1/encoder/external_partition.h"
43#include "av1/encoder/firstpass.h"
44#include "av1/encoder/global_motion.h"
45#include "av1/encoder/level.h"
46#include "av1/encoder/lookahead.h"
47#include "av1/encoder/mcomp.h"
48#include "av1/encoder/pickcdef.h"
49#include "av1/encoder/ratectrl.h"
50#include "av1/encoder/rd.h"
51#include "av1/encoder/speed_features.h"
52#include "av1/encoder/svc_layercontext.h"
53#include "av1/encoder/temporal_filter.h"
54#if CONFIG_THREE_PASS
55#include "av1/encoder/thirdpass.h"
56#endif
57#include "av1/encoder/tokenize.h"
58#include "av1/encoder/tpl_model.h"
59#include "av1/encoder/av1_noise_estimate.h"
60#include "av1/encoder/bitstream.h"
61
62#if CONFIG_INTERNAL_STATS
63#include "aom_dsp/ssim.h"
64#endif
65#include "aom_dsp/variance.h"
66#if CONFIG_DENOISE
67#include "aom_dsp/noise_model.h"
68#endif
69#if CONFIG_TUNE_VMAF
70#include "av1/encoder/tune_vmaf.h"
71#endif
72#if CONFIG_AV1_TEMPORAL_DENOISING
73#include "av1/encoder/av1_temporal_denoiser.h"
74#endif
75#if CONFIG_TUNE_BUTTERAUGLI
76#include "av1/encoder/tune_butteraugli.h"
77#endif
78
79#include "aom/internal/aom_codec_internal.h"
80
81#ifdef __cplusplus
82extern "C" {
83#endif
84
85// TODO(yunqing, any): Added suppression tag to quiet Doxygen warnings. Need to
86// adjust it while we work on documentation.
88// Number of frames required to test for scene cut detection
89#define SCENE_CUT_KEY_TEST_INTERVAL 16
90
91// Lookahead index threshold to enable temporal filtering for second arf.
92#define TF_LOOKAHEAD_IDX_THR 7
93
94#define HDR_QP_LEVELS 10
95#define CHROMA_CB_QP_SCALE 1.04
96#define CHROMA_CR_QP_SCALE 1.04
97#define CHROMA_QP_SCALE -0.46
98#define CHROMA_QP_OFFSET 9.26
99#define QP_SCALE_FACTOR 2.0
100#define DISABLE_HDR_LUMA_DELTAQ 1
101
102// Rational number with an int64 numerator
103// This structure holds a fractional value
104typedef struct aom_rational64 {
105 int64_t num; // fraction numerator
106 int den; // fraction denominator
107} aom_rational64_t; // alias for struct aom_rational
108
109enum {
110 // Good Quality Fast Encoding. The encoder balances quality with the amount of
111 // time it takes to encode the output. Speed setting controls how fast.
112 GOOD,
113 // Realtime Fast Encoding. Will force some restrictions on bitrate
114 // constraints.
115 REALTIME,
116 // All intra mode. All the frames are coded as intra frames.
117 ALLINTRA
118} UENUM1BYTE(MODE);
119
120enum {
121 FRAMEFLAGS_KEY = 1 << 0,
122 FRAMEFLAGS_GOLDEN = 1 << 1,
123 FRAMEFLAGS_BWDREF = 1 << 2,
124 // TODO(zoeliu): To determine whether a frame flag is needed for ALTREF2_FRAME
125 FRAMEFLAGS_ALTREF = 1 << 3,
126 FRAMEFLAGS_INTRAONLY = 1 << 4,
127 FRAMEFLAGS_SWITCH = 1 << 5,
128 FRAMEFLAGS_ERROR_RESILIENT = 1 << 6,
129} UENUM1BYTE(FRAMETYPE_FLAGS);
130
131#if CONFIG_FPMT_TEST
132enum {
133 PARALLEL_ENCODE = 0,
134 PARALLEL_SIMULATION_ENCODE,
135 NUM_FPMT_TEST_ENCODES
136} UENUM1BYTE(FPMT_TEST_ENC_CFG);
137#endif // CONFIG_FPMT_TEST
138// 0 level frames are sometimes used for rate control purposes, but for
139// reference mapping purposes, the minimum level should be 1.
140#define MIN_PYR_LEVEL 1
141static inline int get_true_pyr_level(int frame_level, int frame_order,
142 int max_layer_depth) {
143 if (frame_order == 0) {
144 // Keyframe case
145 return MIN_PYR_LEVEL;
146 } else if (frame_level == MAX_ARF_LAYERS) {
147 // Leaves
148 return max_layer_depth;
149 } else if (frame_level == (MAX_ARF_LAYERS + 1)) {
150 // Altrefs
151 return MIN_PYR_LEVEL;
152 }
153 return AOMMAX(MIN_PYR_LEVEL, frame_level);
154}
155
156enum {
157 NO_AQ = 0,
158 VARIANCE_AQ = 1,
159 COMPLEXITY_AQ = 2,
160 CYCLIC_REFRESH_AQ = 3,
161 AQ_MODE_COUNT // This should always be the last member of the enum
162} UENUM1BYTE(AQ_MODE);
163enum {
164 NO_DELTA_Q = 0,
165 DELTA_Q_OBJECTIVE = 1, // Modulation to improve objective quality
166 DELTA_Q_PERCEPTUAL = 2, // Modulation to improve video perceptual quality
167 DELTA_Q_PERCEPTUAL_AI = 3, // Perceptual quality opt for all intra mode
168 DELTA_Q_USER_RATING_BASED = 4, // User rating based delta q mode
169 DELTA_Q_HDR = 5, // QP adjustment based on HDR block pixel average
170 DELTA_Q_VARIANCE_BOOST =
171 6, // Variance Boost style modulation for all intra mode
172 DELTA_Q_MODE_COUNT // This should always be the last member of the enum
173} UENUM1BYTE(DELTAQ_MODE);
174
175enum {
176 RESIZE_NONE = 0, // No frame resizing allowed.
177 RESIZE_FIXED = 1, // All frames are coded at the specified scale.
178 RESIZE_RANDOM = 2, // All frames are coded at a random scale.
179 RESIZE_DYNAMIC = 3, // Frames coded at lower scale based on rate control.
180 RESIZE_MODES
181} UENUM1BYTE(RESIZE_MODE);
182
183enum {
184 SS_CFG_SRC = 0,
185 SS_CFG_LOOKAHEAD = 1,
186 SS_CFG_FPF = 2,
187 SS_CFG_TOTAL = 3
188} UENUM1BYTE(SS_CFG_OFFSET);
189
190enum {
191 DISABLE_SCENECUT, // For LAP, lag_in_frames < 19
192 ENABLE_SCENECUT_MODE_1, // For LAP, lag_in_frames >=19 and < 33
193 ENABLE_SCENECUT_MODE_2 // For twopass and LAP - lag_in_frames >=33
194} UENUM1BYTE(SCENECUT_MODE);
195
196#define MAX_VBR_CORPUS_COMPLEXITY 10000
197
198typedef enum {
199 MOD_FP, // First pass
200 MOD_TF, // Temporal filtering
201 MOD_TPL, // TPL
202 MOD_GME, // Global motion estimation
203 MOD_ENC, // Encode stage
204 MOD_LPF, // Deblocking loop filter
205 MOD_CDEF_SEARCH, // CDEF search
206 MOD_CDEF, // CDEF frame
207 MOD_LR, // Loop restoration filtering
208 MOD_PACK_BS, // Pack bitstream
209 MOD_FRAME_ENC, // Frame Parallel encode
210 MOD_AI, // All intra
211 NUM_MT_MODULES
212} MULTI_THREADED_MODULES;
213
215
222 typedef enum {
223 COST_UPD_SB,
224 COST_UPD_SBROW,
225 COST_UPD_TILE,
226 COST_UPD_OFF,
227 NUM_COST_UPDATE_TYPES,
228} COST_UPDATE_TYPE;
229
233 typedef enum {
234 LOOPFILTER_NONE = 0,
235 LOOPFILTER_ALL = 1,
236 LOOPFILTER_REFERENCE = 2,
237 LOOPFILTER_SELECTIVELY =
238 3,
239} LOOPFILTER_CONTROL;
240
245 typedef enum {
246 SKIP_APPLY_RESTORATION = 1 << 0,
247 SKIP_APPLY_SUPERRES = 1 << 1,
248 SKIP_APPLY_CDEF = 1 << 2,
249 SKIP_APPLY_LOOPFILTER = 1 << 3,
250} SKIP_APPLY_POSTPROC_FILTER;
251
255 typedef struct {
259 RESIZE_MODE resize_mode;
264 uint8_t resize_scale_denominator;
269 uint8_t resize_kf_scale_denominator;
270} ResizeCfg;
271
275 typedef struct {
279 bool enable_rect_partitions;
283 bool enable_ab_partitions;
287 bool enable_1to4_partitions;
292 BLOCK_SIZE min_partition_size;
297 BLOCK_SIZE max_partition_size;
298} PartitionCfg;
299
303 typedef struct {
307 bool enable_intra_edge_filter;
312 bool enable_filter_intra;
316 bool enable_smooth_intra;
320 bool enable_paeth_intra;
324 bool enable_cfl_intra;
328 bool enable_directional_intra;
333 bool enable_diagonal_intra;
338 bool enable_angle_delta;
352 bool auto_intra_tools_off;
353} IntraModeCfg;
354
358 typedef struct {
362 bool enable_tx64;
366 bool enable_flip_idtx;
370 bool enable_rect_tx;
375 bool reduced_tx_type_set;
380 bool use_intra_dct_only;
385 bool use_inter_dct_only;
390 bool use_intra_default_tx_only;
394 bool enable_tx_size_search;
395} TxfmSizeTypeCfg;
396
400 typedef struct {
404 bool enable_dist_wtd_comp;
409 bool enable_masked_comp;
413 bool enable_smooth_interintra;
417 bool enable_diff_wtd_comp;
421 bool enable_interinter_wedge;
425 bool enable_interintra_wedge;
426} CompoundTypeCfg;
427
431 typedef struct {
436 int superres_qthresh;
441 int superres_kf_qthresh;
447 uint8_t superres_scale_denominator;
453 uint8_t superres_kf_scale_denominator;
457 aom_superres_mode superres_mode;
461 bool enable_superres;
462} SuperResCfg;
463
467 typedef struct {
471 int key_freq_min;
472
476 int key_freq_max;
477
481 int enable_keyframe_filtering;
482
487 int sframe_dist;
488
494 int sframe_mode;
495
499 bool auto_key;
500
504 int fwd_kf_dist;
505
509 bool fwd_kf_enabled;
510
514 bool enable_sframe;
515
519 bool enable_intrabc;
520} KeyFrameCfg;
521
525 typedef struct {
527 // BUFFERING PARAMETERS
534 int64_t starting_buffer_level_ms;
539 int64_t optimal_buffer_level_ms;
544 int64_t maximum_buffer_size_ms;
545
549 int64_t target_bandwidth;
550
555 unsigned int vbr_corpus_complexity_lap;
560 unsigned int max_intra_bitrate_pct;
565 unsigned int max_inter_bitrate_pct;
569 unsigned int gf_cbr_boost_pct;
574 unsigned int min_cr;
578 int drop_frames_water_mark;
584 int under_shoot_pct;
590 int over_shoot_pct;
595 int worst_allowed_q;
600 int best_allowed_q;
604 int cq_level;
609 enum aom_rc_mode mode;
616 int vbrbias;
621 int vbrmin_section;
626 int vbrmax_section;
627
633 int max_consec_drop_ms;
634} RateControlCfg;
635
637typedef struct {
638 // Indicates the number of frames lag before encoding is started.
639 int lag_in_frames;
640 // Indicates the minimum gf/arf interval to be used.
641 int min_gf_interval;
642 // Indicates the maximum gf/arf interval to be used.
643 int max_gf_interval;
644 // Indicates the minimum height for GF group pyramid structure to be used.
645 int gf_min_pyr_height;
646 // Indicates the maximum height for GF group pyramid structure to be used.
647 int gf_max_pyr_height;
648 // Indicates if automatic set and use of altref frames should be enabled.
649 bool enable_auto_arf;
650 // Indicates if automatic set and use of (b)ackward (r)ef (f)rames should be
651 // enabled.
652 bool enable_auto_brf;
653} GFConfig;
654
655typedef struct {
656 // Indicates the number of tile groups.
657 unsigned int num_tile_groups;
658 // Indicates the MTU size for a tile group. If mtu is non-zero,
659 // num_tile_groups is set to DEFAULT_MAX_NUM_TG.
660 unsigned int mtu;
661 // Indicates the number of tile columns in log2.
662 int tile_columns;
663 // Indicates the number of tile rows in log2.
664 int tile_rows;
665 // Indicates the number of widths in the tile_widths[] array.
666 int tile_width_count;
667 // Indicates the number of heights in the tile_heights[] array.
668 int tile_height_count;
669 // Indicates the tile widths, and may be empty.
670 int tile_widths[MAX_TILE_COLS];
671 // Indicates the tile heights, and may be empty.
672 int tile_heights[MAX_TILE_ROWS];
673 // Indicates if large scale tile coding should be used.
674 bool enable_large_scale_tile;
675 // Indicates if single tile decoding mode should be enabled.
676 bool enable_single_tile_decoding;
677 // Indicates if EXT_TILE_DEBUG should be enabled.
678 bool enable_ext_tile_debug;
679} TileConfig;
680
681typedef struct {
682 // Indicates the width of the input frame.
683 int width;
684 // Indicates the height of the input frame.
685 int height;
686 // If forced_max_frame_width is non-zero then it is used to force the maximum
687 // frame width written in write_sequence_header().
688 int forced_max_frame_width;
689 // If forced_max_frame_width is non-zero then it is used to force the maximum
690 // frame height written in write_sequence_header().
691 int forced_max_frame_height;
692 // Indicates the frame width after applying both super-resolution and resize
693 // to the coded frame.
694 int render_width;
695 // Indicates the frame height after applying both super-resolution and resize
696 // to the coded frame.
697 int render_height;
698} FrameDimensionCfg;
699
700typedef struct {
701 // Indicates if warped motion should be enabled.
702 bool enable_warped_motion;
703 // Indicates if warped motion should be evaluated or not.
704 bool allow_warped_motion;
705 // Indicates if OBMC motion should be enabled.
706 bool enable_obmc;
707} MotionModeCfg;
708
709typedef struct {
710 // Timing info for each frame.
711 aom_timing_info_t timing_info;
712 // Indicates the number of time units of a decoding clock.
713 uint32_t num_units_in_decoding_tick;
714 // Indicates if decoder model information is present in the coded sequence
715 // header.
716 bool decoder_model_info_present_flag;
717 // Indicates if display model information is present in the coded sequence
718 // header.
719 bool display_model_info_present_flag;
720 // Indicates if timing info for each frame is present.
721 bool timing_info_present;
722} DecoderModelCfg;
723
724typedef struct {
725 // Indicates the update frequency for coeff costs.
726 COST_UPDATE_TYPE coeff;
727 // Indicates the update frequency for mode costs.
728 COST_UPDATE_TYPE mode;
729 // Indicates the update frequency for mv costs.
730 COST_UPDATE_TYPE mv;
731 // Indicates the update frequency for dv costs.
732 COST_UPDATE_TYPE dv;
733} CostUpdateFreq;
734
735typedef struct {
736 // Indicates the maximum number of reference frames allowed per frame.
737 unsigned int max_reference_frames;
738 // Indicates if the reduced set of references should be enabled.
739 bool enable_reduced_reference_set;
740 // Indicates if one-sided compound should be enabled.
741 bool enable_onesided_comp;
742} RefFrameCfg;
743
744typedef struct {
745 // Indicates the color space that should be used.
746 aom_color_primaries_t color_primaries;
747 // Indicates the characteristics of transfer function to be used.
748 aom_transfer_characteristics_t transfer_characteristics;
749 // Indicates the matrix coefficients to be used for the transfer function.
750 aom_matrix_coefficients_t matrix_coefficients;
751 // Indicates the chroma 4:2:0 sample position info.
752 aom_chroma_sample_position_t chroma_sample_position;
753 // Indicates if a limited color range or full color range should be used.
754 aom_color_range_t color_range;
755} ColorCfg;
756
757typedef struct {
758 // Indicates if extreme motion vector unit test should be enabled or not.
759 unsigned int motion_vector_unit_test;
760 // Indicates if superblock multipass unit test should be enabled or not.
761 unsigned int sb_multipass_unit_test;
762} UnitTestCfg;
763
764typedef struct {
765 // Indicates the file path to the VMAF model.
766 const char *vmaf_model_path;
767 // Indicates the path to the film grain parameters.
768 const char *film_grain_table_filename;
769 // Indicates the visual tuning metric.
770 aom_tune_metric tuning;
771 // Indicates if the current content is screen or default type.
772 aom_tune_content content;
773 // Indicates the film grain parameters.
774 int film_grain_test_vector;
775 // Indicates the in-block distortion metric to use.
776 aom_dist_metric dist_metric;
777} TuneCfg;
778
779typedef struct {
780 // Indicates the framerate of the input video.
781 double init_framerate;
782 // Indicates the bit-depth of the input video.
783 unsigned int input_bit_depth;
784 // Indicates the maximum number of frames to be encoded.
785 unsigned int limit;
786 // Indicates the chrome subsampling x value.
787 unsigned int chroma_subsampling_x;
788 // Indicates the chrome subsampling y value.
789 unsigned int chroma_subsampling_y;
790} InputCfg;
791
792typedef struct {
793 // If true, encoder will use fixed QP offsets, that are either:
794 // - Given by the user, and stored in 'fixed_qp_offsets' array, OR
795 // - Picked automatically from cq_level.
796 int use_fixed_qp_offsets;
797 // Indicates the minimum flatness of the quantization matrix.
798 int qm_minlevel;
799 // Indicates the maximum flatness of the quantization matrix.
800 int qm_maxlevel;
801 // Indicates if adaptive quantize_b should be enabled.
802 int quant_b_adapt;
803 // Indicates the Adaptive Quantization mode to be used.
804 AQ_MODE aq_mode;
805 // Indicates the delta q mode to be used.
806 DELTAQ_MODE deltaq_mode;
807 // Indicates the delta q mode strength.
808 unsigned int deltaq_strength;
809 // Indicates if delta quantization should be enabled in chroma planes.
810 bool enable_chroma_deltaq;
811 // Indicates if delta quantization should be enabled for hdr video
812 bool enable_hdr_deltaq;
813 // Indicates if encoding with quantization matrices should be enabled.
814 bool using_qm;
815} QuantizationCfg;
816
821 typedef struct {
834 int sharpness;
835
839 bool enable_adaptive_sharpness;
840
848 int disable_trellis_quant;
849
853 int arnr_max_frames;
854
858 int arnr_strength;
859
866 uint8_t cdf_update_mode;
867
871 bool enable_tpl_model;
872
877 bool enable_overlay;
878
886 LOOPFILTER_CONTROL loopfilter_control;
887
892 bool skip_postproc_filtering;
893
897 aom_screen_detection_mode screen_detection_mode;
898} AlgoCfg;
899
900
901typedef struct {
902 // Indicates the codec bit-depth.
903 aom_bit_depth_t bit_depth;
904 // Indicates the superblock size that should be used by the encoder.
905 aom_superblock_size_t superblock_size;
906 // Indicates if loopfilter modulation should be enabled.
907 bool enable_deltalf_mode;
908 // Indicates how CDEF should be applied.
909 CDEF_CONTROL cdef_control;
910 // Indicates if loop restoration filter should be enabled.
911 bool enable_restoration;
912 // When enabled, video mode should be used even for single frame input.
913 bool force_video_mode;
914 // Indicates if the error resiliency features should be enabled.
915 bool error_resilient_mode;
916 // Indicates if frame parallel decoding feature should be enabled.
917 bool frame_parallel_decoding_mode;
918 // Indicates if the input should be encoded as monochrome.
919 bool enable_monochrome;
920 // When enabled, the encoder will use a full header even for still pictures.
921 // When disabled, a reduced header is used for still pictures.
922 bool full_still_picture_hdr;
923 // Indicates if dual interpolation filters should be enabled.
924 bool enable_dual_filter;
925 // Indicates if frame order hint should be enabled or not.
926 bool enable_order_hint;
927 // Indicates if ref_frame_mvs should be enabled at the sequence level.
928 bool ref_frame_mvs_present;
929 // Indicates if ref_frame_mvs should be enabled at the frame level.
930 bool enable_ref_frame_mvs;
931 // Indicates if interintra compound mode is enabled.
932 bool enable_interintra_comp;
933 // Indicates if global motion should be enabled.
934 bool enable_global_motion;
935 // Indicates if palette should be enabled.
936 bool enable_palette;
937} ToolCfg;
938
943 typedef struct AV1EncoderConfig {
945 // Configuration related to the input video.
946 InputCfg input_cfg;
947
948 // Configuration related to frame-dimensions.
949 FrameDimensionCfg frm_dim_cfg;
950
955 AlgoCfg algo_cfg;
956
960 KeyFrameCfg kf_cfg;
961
965 RateControlCfg rc_cfg;
967
968 // Configuration related to Quantization.
969 QuantizationCfg q_cfg;
970
971 // Internal frame size scaling.
972 ResizeCfg resize_cfg;
973
974 // Frame Super-Resolution size scaling.
975 SuperResCfg superres_cfg;
976
982 aom_fixed_buf_t twopass_stats_in;
984
985 // Configuration related to encoder toolsets.
986 ToolCfg tool_cfg;
987
988 // Configuration related to Group of frames.
989 GFConfig gf_cfg;
990
991 // Tile related configuration parameters.
992 TileConfig tile_cfg;
993
994 // Configuration related to Tune.
995 TuneCfg tune_cfg;
996
997 // Configuration related to color.
998 ColorCfg color_cfg;
999
1000 // Configuration related to decoder model.
1001 DecoderModelCfg dec_model_cfg;
1002
1003 // Configuration related to reference frames.
1004 RefFrameCfg ref_frm_cfg;
1005
1006 // Configuration related to unit tests.
1007 UnitTestCfg unit_test_cfg;
1008
1009 // Flags related to motion mode.
1010 MotionModeCfg motion_mode_cfg;
1011
1012 // Flags related to intra mode search.
1013 IntraModeCfg intra_mode_cfg;
1014
1015 // Flags related to transform size/type.
1016 TxfmSizeTypeCfg txfm_cfg;
1017
1018 // Flags related to compound type.
1019 CompoundTypeCfg comp_type_cfg;
1020
1021 // Partition related information.
1022 PartitionCfg part_cfg;
1023
1024 // Configuration related to frequency of cost update.
1025 CostUpdateFreq cost_upd_freq;
1026
1027#if CONFIG_DENOISE
1028 // Indicates the noise level.
1029 float noise_level;
1030 // Indicates the the denoisers block size.
1031 int noise_block_size;
1032 // Indicates whether to apply denoising to the frame to be encoded
1033 int enable_dnl_denoising;
1034#endif
1035
1036#if CONFIG_AV1_TEMPORAL_DENOISING
1037 // Noise sensitivity.
1038 int noise_sensitivity;
1039#endif
1040 // Bit mask to specify which tier each of the 32 possible operating points
1041 // conforms to.
1042 unsigned int tier_mask;
1043
1044 // Indicates the number of pixels off the edge of a reference frame we're
1045 // allowed to go when forming an inter prediction.
1046 int border_in_pixels;
1047
1048 // Indicates the maximum number of threads that may be used by the encoder.
1049 int max_threads;
1050
1051 // Indicates the speed preset to be used.
1052 int speed;
1053
1054 // Enable the low complexity decode mode.
1055 unsigned int enable_low_complexity_decode;
1056
1057 // Indicates the target sequence level index for each operating point(OP).
1058 AV1_LEVEL target_seq_level_idx[MAX_NUM_OPERATING_POINTS];
1059
1060 // Indicates the bitstream profile to be used.
1061 BITSTREAM_PROFILE profile;
1062
1071 enum aom_enc_pass pass;
1073
1074 // Total number of encoding passes.
1075 int passes;
1076
1077 // the name of the second pass output file when passes > 2
1078 const char *two_pass_output;
1079
1080 // the name of the second pass log file when passes > 2
1081 const char *second_pass_log;
1082
1083 // Indicates if the encoding is GOOD or REALTIME.
1084 MODE mode;
1085
1086 // Indicates if row-based multi-threading should be enabled or not.
1087 bool row_mt;
1088
1089 // Indicates if frame parallel multi-threading should be enabled or not.
1090 bool fp_mt;
1091
1092 // Indicates if 16bit frame buffers are to be used i.e., the content is >
1093 // 8-bit.
1094 bool use_highbitdepth;
1095
1096 // Indicates the bitstream syntax mode. 0 indicates bitstream is saved as
1097 // Section 5 bitstream, while 1 indicates the bitstream is saved in Annex - B
1098 // format.
1099 bool save_as_annexb;
1100
1101 // The path for partition stats reading and writing, used in the experiment
1102 // CONFIG_PARTITION_SEARCH_ORDER.
1103 const char *partition_info_path;
1104
1105 // The flag that indicates whether we use an external rate distribution to
1106 // guide adaptive quantization. It requires --deltaq-mode=3. The rate
1107 // distribution map file name is stored in |rate_distribution_info|.
1108 unsigned int enable_rate_guide_deltaq;
1109
1110 // The input file of rate distribution information used in all intra mode
1111 // to determine delta quantization.
1112 const char *rate_distribution_info;
1113
1114 // Exit the encoder when it fails to encode to a given level.
1115 int strict_level_conformance;
1116
1117 // Max depth for the GOP after a key frame
1118 int kf_max_pyr_height;
1119
1120 // A flag to control if we enable the superblock qp sweep for a given lambda
1121 int sb_qp_sweep;
1123} AV1EncoderConfig;
1124
1126static inline int is_lossless_requested(const RateControlCfg *const rc_cfg) {
1127 return rc_cfg->best_allowed_q == 0 && rc_cfg->worst_allowed_q == 0;
1128}
1130
1134 typedef struct {
1140 int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL];
1141
1147 int warped_probs[FRAME_UPDATE_TYPES];
1148
1155 int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES];
1156
1163 int switchable_interp_probs[FRAME_UPDATE_TYPES][SWITCHABLE_FILTER_CONTEXTS]
1164 [SWITCHABLE_FILTERS];
1165} FrameProbInfo;
1166
1168
1169typedef struct FRAME_COUNTS {
1170// Note: This structure should only contain 'unsigned int' fields, or
1171// aggregates built solely from 'unsigned int' fields/elements
1172#if CONFIG_ENTROPY_STATS
1173 unsigned int kf_y_mode[KF_MODE_CONTEXTS][KF_MODE_CONTEXTS][INTRA_MODES];
1174 unsigned int angle_delta[DIRECTIONAL_MODES][2 * MAX_ANGLE_DELTA + 1];
1175 unsigned int y_mode[BLOCK_SIZE_GROUPS][INTRA_MODES];
1176 unsigned int uv_mode[CFL_ALLOWED_TYPES][INTRA_MODES][UV_INTRA_MODES];
1177 unsigned int cfl_sign[CFL_JOINT_SIGNS];
1178 unsigned int cfl_alpha[CFL_ALPHA_CONTEXTS][CFL_ALPHABET_SIZE];
1179 unsigned int palette_y_mode[PALATTE_BSIZE_CTXS][PALETTE_Y_MODE_CONTEXTS][2];
1180 unsigned int palette_uv_mode[PALETTE_UV_MODE_CONTEXTS][2];
1181 unsigned int palette_y_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
1182 unsigned int palette_uv_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
1183 unsigned int palette_y_color_index[PALETTE_SIZES]
1184 [PALETTE_COLOR_INDEX_CONTEXTS]
1185 [PALETTE_COLORS];
1186 unsigned int palette_uv_color_index[PALETTE_SIZES]
1187 [PALETTE_COLOR_INDEX_CONTEXTS]
1188 [PALETTE_COLORS];
1189 unsigned int partition[PARTITION_CONTEXTS][EXT_PARTITION_TYPES];
1190 unsigned int txb_skip[TOKEN_CDF_Q_CTXS][TX_SIZES][TXB_SKIP_CONTEXTS][2];
1191 unsigned int eob_extra[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1192 [EOB_COEF_CONTEXTS][2];
1193 unsigned int dc_sign[PLANE_TYPES][DC_SIGN_CONTEXTS][2];
1194 unsigned int coeff_lps[TX_SIZES][PLANE_TYPES][BR_CDF_SIZE - 1][LEVEL_CONTEXTS]
1195 [2];
1196 unsigned int eob_flag[TX_SIZES][PLANE_TYPES][EOB_COEF_CONTEXTS][2];
1197 unsigned int eob_multi16[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][5];
1198 unsigned int eob_multi32[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][6];
1199 unsigned int eob_multi64[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][7];
1200 unsigned int eob_multi128[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][8];
1201 unsigned int eob_multi256[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][9];
1202 unsigned int eob_multi512[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][10];
1203 unsigned int eob_multi1024[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][11];
1204 unsigned int coeff_lps_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1205 [LEVEL_CONTEXTS][BR_CDF_SIZE];
1206 unsigned int coeff_base_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1207 [SIG_COEF_CONTEXTS][NUM_BASE_LEVELS + 2];
1208 unsigned int coeff_base_eob_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1209 [SIG_COEF_CONTEXTS_EOB][NUM_BASE_LEVELS + 1];
1210 unsigned int newmv_mode[NEWMV_MODE_CONTEXTS][2];
1211 unsigned int zeromv_mode[GLOBALMV_MODE_CONTEXTS][2];
1212 unsigned int refmv_mode[REFMV_MODE_CONTEXTS][2];
1213 unsigned int drl_mode[DRL_MODE_CONTEXTS][2];
1214 unsigned int inter_compound_mode[INTER_MODE_CONTEXTS][INTER_COMPOUND_MODES];
1215 unsigned int wedge_idx[BLOCK_SIZES_ALL][16];
1216 unsigned int interintra[BLOCK_SIZE_GROUPS][2];
1217 unsigned int interintra_mode[BLOCK_SIZE_GROUPS][INTERINTRA_MODES];
1218 unsigned int wedge_interintra[BLOCK_SIZES_ALL][2];
1219 unsigned int compound_type[BLOCK_SIZES_ALL][MASKED_COMPOUND_TYPES];
1220 unsigned int motion_mode[BLOCK_SIZES_ALL][MOTION_MODES];
1221 unsigned int obmc[BLOCK_SIZES_ALL][2];
1222 unsigned int intra_inter[INTRA_INTER_CONTEXTS][2];
1223 unsigned int comp_inter[COMP_INTER_CONTEXTS][2];
1224 unsigned int comp_ref_type[COMP_REF_TYPE_CONTEXTS][2];
1225 unsigned int uni_comp_ref[UNI_COMP_REF_CONTEXTS][UNIDIR_COMP_REFS - 1][2];
1226 unsigned int single_ref[REF_CONTEXTS][SINGLE_REFS - 1][2];
1227 unsigned int comp_ref[REF_CONTEXTS][FWD_REFS - 1][2];
1228 unsigned int comp_bwdref[REF_CONTEXTS][BWD_REFS - 1][2];
1229 unsigned int intrabc[2];
1230
1231 unsigned int txfm_partition[TXFM_PARTITION_CONTEXTS][2];
1232 unsigned int intra_tx_size[MAX_TX_CATS][TX_SIZE_CONTEXTS][MAX_TX_DEPTH + 1];
1233 unsigned int skip_mode[SKIP_MODE_CONTEXTS][2];
1234 unsigned int skip_txfm[SKIP_CONTEXTS][2];
1235 unsigned int compound_index[COMP_INDEX_CONTEXTS][2];
1236 unsigned int comp_group_idx[COMP_GROUP_IDX_CONTEXTS][2];
1237 unsigned int delta_q[DELTA_Q_PROBS][2];
1238 unsigned int delta_lf_multi[FRAME_LF_COUNT][DELTA_LF_PROBS][2];
1239 unsigned int delta_lf[DELTA_LF_PROBS][2];
1240
1241 unsigned int inter_ext_tx[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
1242 unsigned int intra_ext_tx[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
1243 [TX_TYPES];
1244 unsigned int filter_intra_mode[FILTER_INTRA_MODES];
1245 unsigned int filter_intra[BLOCK_SIZES_ALL][2];
1246 unsigned int switchable_restore[RESTORE_SWITCHABLE_TYPES];
1247 unsigned int wiener_restore[2];
1248 unsigned int sgrproj_restore[2];
1249#endif // CONFIG_ENTROPY_STATS
1250
1251 unsigned int switchable_interp[SWITCHABLE_FILTER_CONTEXTS]
1252 [SWITCHABLE_FILTERS];
1253} FRAME_COUNTS;
1254
1255#define INTER_MODE_RD_DATA_OVERALL_SIZE 6400
1256
1257typedef struct {
1258 int ready;
1259 double a;
1260 double b;
1261 double dist_mean;
1262 double ld_mean;
1263 double sse_mean;
1264 double sse_sse_mean;
1265 double sse_ld_mean;
1266 int num;
1267 double dist_sum;
1268 double ld_sum;
1269 double sse_sum;
1270 double sse_sse_sum;
1271 double sse_ld_sum;
1272} InterModeRdModel;
1273
1274typedef struct {
1275 int idx;
1276 int64_t rd;
1277} RdIdxPair;
1278// TODO(angiebird): This is an estimated size. We still need to figure what is
1279// the maximum number of modes.
1280#define MAX_INTER_MODES 1024
1281// TODO(any): rename this struct to something else. There is already another
1282// struct called inter_mode_info, which makes this terribly confusing.
1290 typedef struct inter_modes_info {
1295 int num;
1299 MB_MODE_INFO mbmi_arr[MAX_INTER_MODES];
1303 int mode_rate_arr[MAX_INTER_MODES];
1307 int64_t sse_arr[MAX_INTER_MODES];
1311 int64_t est_rd_arr[MAX_INTER_MODES];
1315 RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES];
1319 RD_STATS rd_cost_arr[MAX_INTER_MODES];
1323 RD_STATS rd_cost_y_arr[MAX_INTER_MODES];
1327 RD_STATS rd_cost_uv_arr[MAX_INTER_MODES];
1328} InterModesInfo;
1329
1331typedef struct {
1332 // TODO(kyslov): consider changing to 64bit
1333
1334 // This struct is used for computing variance in choose_partitioning(), where
1335 // the max number of samples within a superblock is 32x32 (with 4x4 avg).
1336 // With 8bit bitdepth, uint32_t is enough for sum_square_error (2^8 * 2^8 * 32
1337 // * 32 = 2^26). For high bitdepth we need to consider changing this to 64 bit
1338 uint32_t sum_square_error;
1339 int32_t sum_error;
1340 int log2_count;
1341 int variance;
1342} VPartVar;
1343
1344typedef struct {
1345 VPartVar none;
1346 VPartVar horz[2];
1347 VPartVar vert[2];
1348} VPVariance;
1349
1350typedef struct {
1351 VPVariance part_variances;
1352 VPartVar split[4];
1353} VP4x4;
1354
1355typedef struct {
1356 VPVariance part_variances;
1357 VP4x4 split[4];
1358} VP8x8;
1359
1360typedef struct {
1361 VPVariance part_variances;
1362 VP8x8 split[4];
1363} VP16x16;
1364
1365typedef struct {
1366 VPVariance part_variances;
1367 VP16x16 split[4];
1368} VP32x32;
1369
1370typedef struct {
1371 VPVariance part_variances;
1372 VP32x32 split[4];
1373} VP64x64;
1374
1375typedef struct {
1376 VPVariance part_variances;
1377 VP64x64 *split;
1378} VP128x128;
1379
1381
1385 typedef struct {
1394 int64_t thresholds[5];
1395
1400 int64_t threshold_minmax;
1401} VarBasedPartitionInfo;
1402
1406 typedef struct {
1407#if CONFIG_MULTITHREAD
1412 pthread_mutex_t *mutex_;
1413 pthread_cond_t *cond_;
1415#endif // CONFIG_MULTITHREAD
1421 int *num_finished_cols;
1428 int sync_range;
1435 int intrabc_extra_top_right_sb_delay;
1439 int rows;
1443 int next_mi_row;
1447 int num_threads_working;
1448} AV1EncRowMultiThreadSync;
1449
1451
1452// TODO(jingning) All spatially adaptive variables should go to TileDataEnc.
1453typedef struct TileDataEnc {
1454 TileInfo tile_info;
1455 DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx);
1456 FRAME_CONTEXT *row_ctx;
1457 uint64_t abs_sum_level;
1458 uint8_t allow_update_cdf;
1459 InterModeRdModel inter_mode_rd_models[BLOCK_SIZES_ALL];
1460 AV1EncRowMultiThreadSync row_mt_sync;
1461 MV firstpass_top_mv;
1462} TileDataEnc;
1463
1464typedef struct RD_COUNTS {
1465 int compound_ref_used_flag;
1466 int skip_mode_used_flag;
1467 int tx_type_used[TX_SIZES_ALL][TX_TYPES];
1468 int obmc_used[BLOCK_SIZES_ALL][2];
1469 int warped_used[2];
1470 int newmv_or_intra_blocks;
1471 uint64_t seg_tmp_pred_cost[2];
1472} RD_COUNTS;
1473
1474typedef struct ThreadData {
1475 MACROBLOCK mb;
1476 MvCosts *mv_costs_alloc;
1477 IntraBCMVCosts *dv_costs_alloc;
1478 RD_COUNTS rd_counts;
1479 FRAME_COUNTS *counts;
1480 PC_TREE_SHARED_BUFFERS shared_coeff_buf;
1481 SIMPLE_MOTION_DATA_TREE *sms_tree;
1482 SIMPLE_MOTION_DATA_TREE *sms_root;
1483 // buffers are AOM_BUFFER_SIZE_FOR_BLOCK_HASH elements long
1484 uint32_t *hash_value_buffer[2];
1485 OBMCBuffer obmc_buffer;
1486 PALETTE_BUFFER *palette_buffer;
1487 CompoundTypeRdBuffers comp_rd_buffer;
1488 CONV_BUF_TYPE *tmp_conv_dst;
1489 uint64_t abs_sum_level;
1490 uint8_t *tmp_pred_bufs[2];
1491 uint8_t *wiener_tmp_pred_buf;
1492 int intrabc_used;
1493 int deltaq_used;
1494 int coefficient_size;
1495 int max_mv_magnitude;
1496 int interp_filter_selected[SWITCHABLE];
1497 FRAME_CONTEXT *tctx;
1498 VP64x64 *vt64x64;
1499 int32_t num_64x64_blocks;
1500 PICK_MODE_CONTEXT *firstpass_ctx;
1501 TemporalFilterData tf_data;
1502 TplBuffers tpl_tmp_buffers;
1503 TplTxfmStats tpl_txfm_stats;
1504 GlobalMotionData gm_data;
1505 // Pointer to the array of structures to store gradient information of each
1506 // pixel in a superblock. The buffer constitutes of MAX_SB_SQUARE pixel level
1507 // structures for each of the plane types (PLANE_TYPE_Y and PLANE_TYPE_UV).
1508 PixelLevelGradientInfo *pixel_gradient_info;
1509 // Pointer to the array of structures to store source variance information of
1510 // each 4x4 sub-block in a superblock. Block4x4VarInfo structure is used to
1511 // store source variance and log of source variance of each 4x4 sub-block
1512 // for subsequent retrieval.
1513 Block4x4VarInfo *src_var_info_of_4x4_sub_blocks;
1514 // Pointer to pc tree root.
1515 PC_TREE *pc_root;
1516} ThreadData;
1517
1518struct EncWorkerData;
1519
1521
1525 typedef struct {
1529 int allocated_tile_rows;
1533 int allocated_tile_cols;
1540 int allocated_rows;
1547 int allocated_cols;
1548
1552 int thread_id_to_tile_id[MAX_NUM_THREADS];
1553
1558 int *num_tile_cols_done;
1559
1564 int allocated_sb_rows;
1565
1570 bool row_mt_exit;
1571
1577 bool firstpass_mt_exit;
1578
1584 bool mb_wiener_mt_exit;
1585
1586#if CONFIG_MULTITHREAD
1590 pthread_mutex_t *mutex_;
1594 pthread_cond_t *cond_;
1595#endif
1596
1604 void (*sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int);
1608 void (*sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
1610} AV1EncRowMultiThreadInfo;
1611
1615 typedef struct {
1616#if CONFIG_MULTITHREAD
1620 pthread_mutex_t *mutex_;
1624 pthread_cond_t *cond_;
1625#endif
1626
1634 void (*intra_sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int);
1638 void (*intra_sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
1640} AV1EncAllIntraMultiThreadInfo;
1641
1645#define NUM_RECODES_PER_FRAME 10
1646
1650#define MAX_PARALLEL_FRAMES 4
1651
1656 typedef struct RestoreStateBuffers {
1660 uint16_t *cdef_srcbuf;
1661
1665 uint16_t *cdef_colbuf[MAX_MB_PLANE];
1666
1670 int32_t *rst_tmpbuf;
1671
1675 RestorationLineBuffers *rlbs;
1676} RestoreStateBuffers;
1677
1681 typedef struct {
1685 WienerInfo wiener;
1686
1690 SgrprojInfo sgrproj;
1691
1696 RestorationType best_rtype[RESTORE_TYPES - 1];
1697} RestUnitSearchInfo;
1698
1704 typedef struct {
1709 RestUnitSearchInfo *rusi[MAX_MB_PLANE];
1710
1714 int16_t *dgd_avg;
1715} AV1LrPickStruct;
1716
1720 typedef struct PrimaryMultiThreadInfo {
1724 int num_workers;
1725
1729 int num_mod_workers[NUM_MT_MODULES];
1730
1734 AVxWorker *workers;
1735
1740 struct EncWorkerData *tile_thr_data;
1741
1745 AV1CdefWorkerData *cdef_worker;
1746
1751 AVxWorker *p_workers[MAX_PARALLEL_FRAMES];
1752
1756 int p_num_workers;
1757
1761 int prev_num_enc_workers;
1762} PrimaryMultiThreadInfo;
1763
1767 typedef struct MultiThreadInfo {
1771 int num_workers;
1772
1776 int num_mod_workers[NUM_MT_MODULES];
1777
1781 AVxWorker *workers;
1782
1787 struct EncWorkerData *tile_thr_data;
1788
1793 bool row_mt_enabled;
1794
1798 bool pack_bs_mt_enabled;
1799
1803 AV1EncRowMultiThreadInfo enc_row_mt;
1804
1809 AV1EncAllIntraMultiThreadInfo intra_mt;
1810
1814 AV1TplRowMultiThreadInfo tpl_row_mt;
1815
1819 AV1LfSync lf_row_sync;
1820
1824 AV1LrSync lr_row_sync;
1825
1829 AV1EncPackBSSync pack_bs_sync;
1830
1834 AV1GlobalMotionSync gm_sync;
1835
1839 AV1TemporalFilterSync tf_sync;
1840
1844 AV1CdefSync cdef_sync;
1845
1849 AV1CdefWorkerData *cdef_worker;
1850
1854 RestoreStateBuffers restore_state_buf;
1855
1860 int pipeline_lpf_mt_with_enc;
1861} MultiThreadInfo;
1862
1864
1865typedef struct ActiveMap {
1866 int enabled;
1867 int update;
1868 unsigned char *map;
1869} ActiveMap;
1870
1872
1876 typedef struct {
1881 double cs_rate_array[32];
1885 int rate_index;
1889 int rate_size;
1890} ForceIntegerMVInfo;
1891
1893
1894#if CONFIG_INTERNAL_STATS
1895// types of stats
1896enum {
1897 STAT_Y,
1898 STAT_U,
1899 STAT_V,
1900 STAT_ALL,
1901 NUM_STAT_TYPES // This should always be the last member of the enum
1902} UENUM1BYTE(StatType);
1903
1904typedef struct IMAGE_STAT {
1905 double stat[NUM_STAT_TYPES];
1906 double worst;
1907} ImageStat;
1908#endif // CONFIG_INTERNAL_STATS
1909
1910typedef struct {
1911 int ref_count;
1912 YV12_BUFFER_CONFIG buf;
1913} EncRefCntBuffer;
1914
1916
1922 typedef struct {
1927 MB_MODE_INFO_EXT_FRAME *frame_base;
1931 int alloc_size;
1935 int stride;
1936} MBMIExtFrameBufferInfo;
1937
1939
1940#if CONFIG_COLLECT_PARTITION_STATS
1941typedef struct FramePartitionTimingStats {
1942 int partition_decisions[6][EXT_PARTITION_TYPES];
1943 int partition_attempts[6][EXT_PARTITION_TYPES];
1944 int64_t partition_times[6][EXT_PARTITION_TYPES];
1945
1946 int partition_redo;
1947} FramePartitionTimingStats;
1948#endif // CONFIG_COLLECT_PARTITION_STATS
1949
1950#if CONFIG_COLLECT_COMPONENT_TIMING
1951#include "aom_ports/aom_timer.h"
1952// Adjust the following to add new components.
1953enum {
1954 av1_encode_strategy_time,
1955 av1_get_one_pass_rt_params_time,
1956 av1_get_second_pass_params_time,
1957 denoise_and_encode_time,
1958 apply_filtering_time,
1959 av1_tpl_setup_stats_time,
1960 encode_frame_to_data_rate_time,
1961 encode_with_or_without_recode_time,
1962 loop_filter_time,
1963 cdef_time,
1964 loop_restoration_time,
1965 av1_pack_bitstream_final_time,
1966 av1_encode_frame_time,
1967 av1_compute_global_motion_time,
1968 av1_setup_motion_field_time,
1969 encode_sb_row_time,
1970
1971 rd_pick_partition_time,
1972 rd_use_partition_time,
1973 choose_var_based_partitioning_time,
1974 av1_prune_partitions_time,
1975 none_partition_search_time,
1976 split_partition_search_time,
1977 rectangular_partition_search_time,
1978 ab_partitions_search_time,
1979 rd_pick_4partition_time,
1980 encode_sb_time,
1981
1982 rd_pick_sb_modes_time,
1983 av1_rd_pick_intra_mode_sb_time,
1984 av1_rd_pick_inter_mode_sb_time,
1985 set_params_rd_pick_inter_mode_time,
1986 skip_inter_mode_time,
1987 handle_inter_mode_time,
1988 evaluate_motion_mode_for_winner_candidates_time,
1989 do_tx_search_time,
1990 handle_intra_mode_time,
1991 refine_winner_mode_tx_time,
1992 av1_search_palette_mode_time,
1993 handle_newmv_time,
1994 compound_type_rd_time,
1995 interpolation_filter_search_time,
1996 motion_mode_rd_time,
1997
1998 nonrd_use_partition_time,
1999 pick_sb_modes_nonrd_time,
2000 hybrid_intra_mode_search_time,
2001 nonrd_pick_inter_mode_sb_time,
2002 encode_b_nonrd_time,
2003
2004 kTimingComponents,
2005} UENUM1BYTE(TIMING_COMPONENT);
2006
2007static inline char const *get_component_name(int index) {
2008 switch (index) {
2009 case av1_encode_strategy_time: return "av1_encode_strategy_time";
2010 case av1_get_one_pass_rt_params_time:
2011 return "av1_get_one_pass_rt_params_time";
2012 case av1_get_second_pass_params_time:
2013 return "av1_get_second_pass_params_time";
2014 case denoise_and_encode_time: return "denoise_and_encode_time";
2015 case apply_filtering_time: return "apply_filtering_time";
2016 case av1_tpl_setup_stats_time: return "av1_tpl_setup_stats_time";
2017 case encode_frame_to_data_rate_time:
2018 return "encode_frame_to_data_rate_time";
2019 case encode_with_or_without_recode_time:
2020 return "encode_with_or_without_recode_time";
2021 case loop_filter_time: return "loop_filter_time";
2022 case cdef_time: return "cdef_time";
2023 case loop_restoration_time: return "loop_restoration_time";
2024 case av1_pack_bitstream_final_time: return "av1_pack_bitstream_final_time";
2025 case av1_encode_frame_time: return "av1_encode_frame_time";
2026 case av1_compute_global_motion_time:
2027 return "av1_compute_global_motion_time";
2028 case av1_setup_motion_field_time: return "av1_setup_motion_field_time";
2029 case encode_sb_row_time: return "encode_sb_row_time";
2030
2031 case rd_pick_partition_time: return "rd_pick_partition_time";
2032 case rd_use_partition_time: return "rd_use_partition_time";
2033 case choose_var_based_partitioning_time:
2034 return "choose_var_based_partitioning_time";
2035 case av1_prune_partitions_time: return "av1_prune_partitions_time";
2036 case none_partition_search_time: return "none_partition_search_time";
2037 case split_partition_search_time: return "split_partition_search_time";
2038 case rectangular_partition_search_time:
2039 return "rectangular_partition_search_time";
2040 case ab_partitions_search_time: return "ab_partitions_search_time";
2041 case rd_pick_4partition_time: return "rd_pick_4partition_time";
2042 case encode_sb_time: return "encode_sb_time";
2043
2044 case rd_pick_sb_modes_time: return "rd_pick_sb_modes_time";
2045 case av1_rd_pick_intra_mode_sb_time:
2046 return "av1_rd_pick_intra_mode_sb_time";
2047 case av1_rd_pick_inter_mode_sb_time:
2048 return "av1_rd_pick_inter_mode_sb_time";
2049 case set_params_rd_pick_inter_mode_time:
2050 return "set_params_rd_pick_inter_mode_time";
2051 case skip_inter_mode_time: return "skip_inter_mode_time";
2052 case handle_inter_mode_time: return "handle_inter_mode_time";
2053 case evaluate_motion_mode_for_winner_candidates_time:
2054 return "evaluate_motion_mode_for_winner_candidates_time";
2055 case do_tx_search_time: return "do_tx_search_time";
2056 case handle_intra_mode_time: return "handle_intra_mode_time";
2057 case refine_winner_mode_tx_time: return "refine_winner_mode_tx_time";
2058 case av1_search_palette_mode_time: return "av1_search_palette_mode_time";
2059 case handle_newmv_time: return "handle_newmv_time";
2060 case compound_type_rd_time: return "compound_type_rd_time";
2061 case interpolation_filter_search_time:
2062 return "interpolation_filter_search_time";
2063 case motion_mode_rd_time: return "motion_mode_rd_time";
2064
2065 case nonrd_use_partition_time: return "nonrd_use_partition_time";
2066 case pick_sb_modes_nonrd_time: return "pick_sb_modes_nonrd_time";
2067 case hybrid_intra_mode_search_time: return "hybrid_intra_mode_search_time";
2068 case nonrd_pick_inter_mode_sb_time: return "nonrd_pick_inter_mode_sb_time";
2069 case encode_b_nonrd_time: return "encode_b_nonrd_time";
2070
2071 default: assert(0);
2072 }
2073 return "error";
2074}
2075#endif
2076
2077// The maximum number of internal ARFs except ALTREF_FRAME
2078#define MAX_INTERNAL_ARFS (REF_FRAMES - BWDREF_FRAME - 1)
2079
2081
2085 typedef struct {
2089 bool search_done;
2090
2096 YV12_BUFFER_CONFIG *ref_buf[REF_FRAMES];
2097
2103 int num_ref_frames[MAX_DIRECTIONS];
2104
2111 FrameDistPair reference_frames[MAX_DIRECTIONS][REF_FRAMES - 1];
2112
2117 int segment_map_w;
2118 int segment_map_h;
2120} GlobalMotionInfo;
2121
2125 typedef struct {
2130 int default_interp_skip_flags;
2134 uint16_t interp_filter_search_mask;
2135} InterpSearchFlags;
2136
2140 typedef struct {
2146 int max_mv_magnitude;
2151 int mv_step_param;
2160 fractional_mv_step_fp *find_fractional_mv_step;
2167 search_site_config search_site_cfg[SS_CFG_TOTAL][NUM_DISTINCT_SEARCH_METHODS];
2168} MotionVectorSearchParams;
2169
2178 typedef struct {
2179 bool golden_frame;
2180 bool bwd_ref_frame;
2181 bool alt_ref_frame;
2182} RefreshFrameInfo;
2183
2191 typedef struct {
2192 int width;
2193 int height;
2194} ResizePendingParams;
2195
2199 typedef struct {
2203 int ref_relative_dist[INTER_REFS_PER_FRAME];
2207 int8_t nearest_past_ref;
2211 int8_t nearest_future_ref;
2212} RefFrameDistanceInfo;
2213
2229 typedef struct {
2237 unsigned int coeff_opt_thresholds[MODE_EVAL_TYPES][2];
2238
2243 TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES];
2244
2251 unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES];
2252
2258 unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES];
2259
2265 unsigned int skip_txfm_level[MODE_EVAL_TYPES];
2266
2272 unsigned int predict_dc_level[MODE_EVAL_TYPES];
2273} WinnerModeParams;
2274
2282 typedef struct {
2283 bool last_frame;
2284 bool golden_frame;
2285 bool bwd_ref_frame;
2286 bool alt2_ref_frame;
2287 bool alt_ref_frame;
2291 bool update_pending;
2292} ExtRefreshFrameFlagsInfo;
2293
2297 typedef struct {
2301 int ref_frame_flags;
2302
2306 ExtRefreshFrameFlagsInfo refresh_frame;
2307
2311 bool refresh_frame_context;
2312
2317 bool refresh_frame_context_pending;
2318
2322 bool use_ref_frame_mvs;
2323
2327 bool use_error_resilient;
2328
2332 bool use_s_frame;
2333
2338 bool use_primary_ref_none;
2339} ExternalFlags;
2340
2342
2343typedef struct {
2344 // Some misc info
2345 int high_prec;
2346 int q;
2347 int order;
2348
2349 // MV counters
2350 int inter_count;
2351 int intra_count;
2352 int default_mvs;
2353 int mv_joint_count[4];
2354 int last_bit_zero;
2355 int last_bit_nonzero;
2356
2357 // Keep track of the rates
2358 int total_mv_rate;
2359 int hp_total_mv_rate;
2360 int lp_total_mv_rate;
2361
2362 // Texture info
2363 int horz_text;
2364 int vert_text;
2365 int diag_text;
2366
2367 // Whether the current struct contains valid data
2368 int valid;
2369} MV_STATS;
2370
2371typedef struct WeberStats {
2372 int64_t mb_wiener_variance;
2373 int64_t src_variance;
2374 int64_t rec_variance;
2375 int16_t src_pix_max;
2376 int16_t rec_pix_max;
2377 int64_t distortion;
2378 int64_t satd;
2379 double max_scale;
2380} WeberStats;
2381
2382typedef struct {
2383 struct loopfilter lf;
2384 CdefInfo cdef_info;
2385 YV12_BUFFER_CONFIG copy_buffer;
2386 RATE_CONTROL rc;
2387 MV_STATS mv_stats;
2388} CODING_CONTEXT;
2389
2390typedef struct {
2391 int frame_width;
2392 int frame_height;
2393 int mi_rows;
2394 int mi_cols;
2395 int mb_rows;
2396 int mb_cols;
2397 int num_mbs;
2398 aom_bit_depth_t bit_depth;
2399 int subsampling_x;
2400 int subsampling_y;
2401} FRAME_INFO;
2402
2406typedef struct {
2407 int show_frame_count;
2408} FRAME_INDEX_SET;
2409
2411
2415 typedef struct {
2421 uint8_t *map;
2427 bool has_lossless_segment;
2428} EncSegmentationInfo;
2429
2433 typedef struct {
2437 int64_t prev_ts_start;
2441 int64_t prev_ts_end;
2445 int64_t first_ts_start;
2446} TimeStamps;
2447
2452 typedef struct {
2456 tran_low_t *tcoeff;
2460 uint16_t *eobs;
2464 uint8_t *entropy_ctx;
2465} CoeffBufferPool;
2466
2467#if !CONFIG_REALTIME_ONLY
2469// DUCKY_ENCODE_FRAME_MODE is c version of EncodeFrameMode
2470enum {
2471 DUCKY_ENCODE_FRAME_MODE_NONE, // Let native AV1 determine q index and rdmult
2472 DUCKY_ENCODE_FRAME_MODE_QINDEX, // DuckyEncode determines q index and AV1
2473 // determines rdmult
2474 DUCKY_ENCODE_FRAME_MODE_QINDEX_RDMULT, // DuckyEncode determines q index and
2475 // rdmult
2476} UENUM1BYTE(DUCKY_ENCODE_FRAME_MODE);
2477
2478enum {
2479 DUCKY_ENCODE_GOP_MODE_NONE, // native AV1 decides GOP
2480 DUCKY_ENCODE_GOP_MODE_RCL, // rate control lib decides GOP
2481} UENUM1BYTE(DUCKY_ENCODE_GOP_MODE);
2482
2483typedef struct DuckyEncodeFrameInfo {
2484 DUCKY_ENCODE_FRAME_MODE qp_mode;
2485 DUCKY_ENCODE_GOP_MODE gop_mode;
2486 int q_index;
2487 int rdmult;
2488 // These two arrays are equivalent to std::vector<SuperblockEncodeParameters>
2489 int *superblock_encode_qindex;
2490 int *superblock_encode_rdmult;
2491 int delta_q_enabled;
2492} DuckyEncodeFrameInfo;
2493
2494typedef struct DuckyEncodeFrameResult {
2495 int global_order_idx;
2496 int q_index;
2497 int rdmult;
2498 int rate;
2499 int64_t dist;
2500 double psnr;
2501} DuckyEncodeFrameResult;
2502
2503typedef struct DuckyEncodeInfo {
2504 DuckyEncodeFrameInfo frame_info;
2505 DuckyEncodeFrameResult frame_result;
2506} DuckyEncodeInfo;
2508#endif
2509
2511typedef struct RTC_REF {
2516 int reference[INTER_REFS_PER_FRAME];
2517 int ref_idx[INTER_REFS_PER_FRAME];
2518 int refresh[REF_FRAMES];
2519 int set_ref_frame_config;
2520 int non_reference_frame;
2521 int ref_frame_comp[3];
2522 int gld_idx_1layer;
2526 unsigned int buffer_time_index[REF_FRAMES];
2530 unsigned char buffer_spatial_layer[REF_FRAMES];
2534 bool reference_was_previous_frame;
2539 bool bias_recovery_frame;
2540} RTC_REF;
2542
2546 typedef struct AV1_COMP_DATA {
2550 unsigned char *cx_data;
2551
2555 size_t cx_data_sz;
2556
2560 size_t frame_size;
2561
2565 unsigned int lib_flags;
2566
2570 int64_t ts_frame_start;
2571
2575 int64_t ts_frame_end;
2576
2580 int flush;
2581
2585 const aom_rational64_t *timestamp_ratio;
2586
2590 int pop_lookahead;
2591} AV1_COMP_DATA;
2592
2596 typedef struct AV1_PRIMARY {
2600 struct AV1_COMP *parallel_cpi[MAX_PARALLEL_FRAMES];
2601
2606 struct AV1_COMP_DATA parallel_frames_data[MAX_PARALLEL_FRAMES - 1];
2607#if CONFIG_FPMT_TEST
2613 FPMT_TEST_ENC_CFG fpmt_unit_test_cfg;
2614
2618 FrameProbInfo temp_frame_probs;
2619
2625 FrameProbInfo temp_frame_probs_simulation;
2626
2631 int temp_valid_gm_model_found[FRAME_UPDATE_TYPES];
2632#endif // CONFIG_FPMT_TEST
2638 RefCntBuffer *ref_frame_map_copy[REF_FRAMES];
2639
2643 int64_t ts_start_last_show_frame;
2644
2648 int64_t ts_end_last_show_frame;
2649
2653 int num_fp_contexts;
2654
2658 int filter_level[2];
2659
2663 int filter_level_u;
2664
2668 int filter_level_v;
2669
2674 struct AV1_COMP *cpi;
2675
2679 struct AV1_COMP *cpi_lap;
2680
2684 struct lookahead_ctx *lookahead;
2685
2695 int seq_params_locked;
2696
2701 struct aom_codec_pkt_list *output_pkt_list;
2702
2706 int internal_altref_allowed;
2707
2711 int show_existing_alt_ref;
2712
2716 GF_GROUP gf_group;
2717
2721 GF_STATE gf_state;
2722
2726 int lap_enabled;
2727
2731 AV1LevelParams level_params;
2732
2736 int b_calculate_psnr;
2737
2741 int frames_left;
2742
2746 TWO_PASS twopass;
2747
2751 PRIMARY_RATE_CONTROL p_rc;
2752
2756 TEMPORAL_FILTER_INFO tf_info;
2761 SequenceHeader seq_params;
2762
2766 int use_svc;
2767
2771 bool buffer_removal_time_present;
2772
2776 unsigned int number_temporal_layers;
2777
2781 unsigned int number_spatial_layers;
2782
2786 struct aom_internal_error_info error;
2787
2793 aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL];
2794
2799 double *tpl_sb_rdmult_scaling_factors;
2800
2804 TplParams tpl_data;
2805
2809 MV_STATS mv_stats;
2810
2811#if CONFIG_INTERNAL_STATS
2813 uint64_t total_time_receive_data;
2814 uint64_t total_time_compress_data;
2815
2816 unsigned int total_mode_chosen_counts[MAX_MODES];
2817
2818 int count[2];
2819 uint64_t total_sq_error[2];
2820 uint64_t total_samples[2];
2821 ImageStat psnr[2];
2822
2823 double total_blockiness;
2824 double worst_blockiness;
2825
2826 uint64_t total_bytes;
2827 double summed_quality;
2828 double summed_weights;
2829 double summed_quality_hbd;
2830 double summed_weights_hbd;
2831 unsigned int total_recode_hits;
2832 double worst_ssim;
2833 double worst_ssim_hbd;
2834
2835 ImageStat fastssim;
2836 ImageStat psnrhvs;
2837
2838 int b_calculate_blockiness;
2839 int b_calculate_consistency;
2840
2841 double total_inconsistency;
2842 double worst_consistency;
2843 Ssimv *ssim_vars;
2844 Metrics metrics;
2846#endif
2847
2848#if CONFIG_ENTROPY_STATS
2852 FRAME_COUNTS aggregate_fc;
2853#endif // CONFIG_ENTROPY_STATS
2854
2861 int fb_of_context_type[REF_FRAMES];
2862
2866 PrimaryMultiThreadInfo p_mt_info;
2867
2871 FrameProbInfo frame_probs;
2872
2879 int valid_gm_model_found[FRAME_UPDATE_TYPES];
2880
2884 RTC_REF rtc_ref;
2885
2890 AV1EncRowMultiThreadSync intra_row_mt_sync;
2891} AV1_PRIMARY;
2892
2896 typedef struct AV1_COMP {
2900 AV1_PRIMARY *ppi;
2901
2906 EncQuantDequantParams enc_quant_dequant_params;
2907
2911 ThreadData td;
2912
2916 FRAME_COUNTS counts;
2917
2921 MBMIExtFrameBufferInfo mbmi_ext_info;
2922
2928 CB_COEFF_BUFFER *coeff_buffer_base;
2929
2934 CoeffBufferPool coeff_buffer_pool;
2935
2939 AV1_COMMON common;
2940
2944 AV1EncoderConfig oxcf;
2945
2950 TRELLIS_OPT_TYPE optimize_seg_arr[MAX_SEGMENTS];
2951
2957 YV12_BUFFER_CONFIG *source;
2958
2966 YV12_BUFFER_CONFIG *last_source;
2967
2972 YV12_BUFFER_CONFIG *unscaled_source;
2973
2977 YV12_BUFFER_CONFIG scaled_source;
2978
2982 YV12_BUFFER_CONFIG *unscaled_last_source;
2983
2987 YV12_BUFFER_CONFIG scaled_last_source;
2988
2993 YV12_BUFFER_CONFIG *unfiltered_source;
2994
2999 YV12_BUFFER_CONFIG orig_source;
3000
3004 int skip_tpl_setup_stats;
3005
3014 double *tpl_rdmult_scaling_factors;
3015
3019 TemporalFilterCtx tf_ctx;
3020
3024 CdefSearchCtx *cdef_search_ctx;
3025
3029 ForceIntegerMVInfo force_intpel_info;
3030
3035 RefCntBuffer *scaled_ref_buf[INTER_REFS_PER_FRAME];
3036
3040 RefCntBuffer *last_show_frame_buf;
3041
3045 RefreshFrameInfo refresh_frame;
3046
3050 int rt_reduce_num_ref_buffers;
3051
3055 ExternalFlags ext_flags;
3056
3061 YV12_BUFFER_CONFIG last_frame_uf;
3062
3067 YV12_BUFFER_CONFIG trial_frame_rst;
3068
3072 int64_t ambient_err;
3073
3077 RD_OPT rd;
3078
3083 CODING_CONTEXT coding_context;
3084
3088 GlobalMotionInfo gm_info;
3089
3093 WinnerModeParams winner_mode_params;
3094
3098 TimeStamps time_stamps;
3099
3103 RATE_CONTROL rc;
3104
3108 double framerate;
3109
3113 int ref_frame_flags;
3114
3118 int speed;
3119
3123 SPEED_FEATURES sf;
3124
3128 MotionVectorSearchParams mv_search_params;
3129
3134 int all_one_sided_refs;
3135
3139 EncSegmentationInfo enc_seg;
3140
3144 CYCLIC_REFRESH *cyclic_refresh;
3149 ActiveMap active_map;
3150
3154 unsigned char gf_frame_index;
3155
3156#if CONFIG_INTERNAL_STATS
3158 uint64_t time_compress_data;
3159
3160 unsigned int mode_chosen_counts[MAX_MODES];
3161 int bytes;
3162 unsigned int frame_recode_hits;
3164#endif
3165
3166#if CONFIG_SPEED_STATS
3170 unsigned int tx_search_count;
3171#endif // CONFIG_SPEED_STATS
3172
3177 int droppable;
3178
3182 FRAME_INFO frame_info;
3183
3187 FRAME_INDEX_SET frame_index_set;
3188
3194 int data_alloc_width;
3195
3201 int data_alloc_height;
3202
3209 int initial_mbs;
3210
3215 bool frame_size_related_setup_done;
3216
3221 int last_coded_width;
3222
3227 int last_coded_height;
3228
3232 ResizePendingParams resize_pending_params;
3233
3238 TileDataEnc *tile_data;
3242 int allocated_tiles;
3243
3247 TokenInfo token_info;
3248
3252 int vaq_refresh;
3253
3257 VarBasedPartitionInfo vbp_info;
3258
3262 int num_frame_recode;
3263
3267 FrameProbInfo frame_new_probs[NUM_RECODES_PER_FRAME];
3268
3272 int do_update_frame_probs_txtype[NUM_RECODES_PER_FRAME];
3273
3277 int do_update_frame_probs_obmc[NUM_RECODES_PER_FRAME];
3278
3282 int do_update_frame_probs_warp[NUM_RECODES_PER_FRAME];
3283
3287 int do_update_frame_probs_interpfilter[NUM_RECODES_PER_FRAME];
3288
3289#if CONFIG_FPMT_TEST
3294 double temp_framerate;
3295#endif
3301 double new_framerate;
3302
3306 int do_update_vbr_bits_off_target_fast;
3307
3311 MultiThreadInfo mt_info;
3312
3318 int existing_fb_idx_to_show;
3319
3323 int intrabc_used;
3324
3328 int prune_ref_frame_mask;
3329
3333 AV1LrStruct lr_ctxt;
3334
3338 AV1LrPickStruct pick_lr_ctxt;
3339
3343 aom_film_grain_table_t *film_grain_table;
3344
3345#if CONFIG_DENOISE
3350 struct aom_denoise_and_model_t *denoise_and_model;
3351#endif
3352
3356 InterpSearchFlags interp_search_flags;
3357
3365 int use_screen_content_tools;
3366
3373 int is_screen_content_type;
3374
3375#if CONFIG_COLLECT_PARTITION_STATS
3379 FramePartitionTimingStats partition_stats;
3380#endif // CONFIG_COLLECT_PARTITION_STATS
3381
3382#if CONFIG_COLLECT_COMPONENT_TIMING
3386 uint64_t component_time[kTimingComponents];
3391 struct aom_usec_timer component_timer[kTimingComponents];
3395 uint64_t frame_component_time[kTimingComponents];
3396#endif
3397
3401 int frame_header_count;
3402
3406 int deltaq_used;
3407
3411 RefFrameDistanceInfo ref_frame_dist_info;
3412
3418 double *ssim_rdmult_scaling_factors;
3419
3420#if CONFIG_TUNE_VMAF
3424 TuneVMAFInfo vmaf_info;
3425#endif
3426
3427#if CONFIG_TUNE_BUTTERAUGLI
3431 TuneButteraugliInfo butteraugli_info;
3432#endif
3433
3437 SVC svc;
3438
3442 COMPRESSOR_STAGE compressor_stage;
3443
3448 FRAME_TYPE last_frame_type;
3449
3453 int num_tg;
3454
3460 aom_superres_mode superres_mode;
3461
3465 FirstPassData firstpass_data;
3466
3470 NOISE_ESTIMATE noise_estimate;
3471
3472#if CONFIG_AV1_TEMPORAL_DENOISING
3476 AV1_DENOISER denoiser;
3477#endif
3478
3483 uint8_t *consec_zero_mv;
3484
3488 int consec_zero_mv_alloc_size;
3489
3493 BLOCK_SIZE fp_block_size;
3494
3499 int sb_counter;
3500
3504 size_t available_bs_size;
3505
3510 ExtPartController ext_part_controller;
3511
3516 MV_STATS mv_stats;
3520 int ref_refresh_index;
3521
3526 bool refresh_idx_available;
3527
3533 int ref_idx_to_skip;
3534#if CONFIG_FPMT_TEST
3540
3541 int wanted_fb;
3542#endif // CONFIG_FPMT_TEST
3543
3549 bool do_frame_data_update;
3550
3551#if CONFIG_RD_COMMAND
3555 RD_COMMAND rd_command;
3556#endif // CONFIG_RD_COMMAND
3557
3561 WeberStats *mb_weber_stats;
3562
3567 int *prep_rate_estimates;
3568
3573 double *ext_rate_distribution;
3574
3578 double ext_rate_scale;
3579
3583 BLOCK_SIZE weber_bsize;
3584
3588 int64_t norm_wiener_variance;
3589
3593 int *mb_delta_q;
3594
3598 bool is_dropped_frame;
3599
3600#if CONFIG_BITRATE_ACCURACY
3604 VBR_RATECTRL_INFO vbr_rc_info;
3605#endif
3606
3607#if CONFIG_RATECTRL_LOG
3611 RATECTRL_LOG rc_log;
3612#endif // CONFIG_RATECTRL_LOG
3613
3617 TWO_PASS_FRAME twopass_frame;
3618
3619#if CONFIG_THREE_PASS
3623 THIRD_PASS_DEC_CTX *third_pass_ctx;
3624#endif
3625
3629 FILE *second_pass_log_stream;
3630
3634 uint64_t *src_sad_blk_64x64;
3635
3641 uint64_t rec_sse;
3642
3647 int use_ducky_encode;
3648
3649#if !CONFIG_REALTIME_ONLY
3653 DuckyEncodeInfo ducky_encode_info;
3654#endif // CONFIG_REALTIME_ONLY
3655 //
3659 int frames_since_last_update;
3660
3664 unsigned int zeromv_skip_thresh_exit_part[BLOCK_SIZES_ALL];
3665
3670 bool alloc_pyramid;
3671
3672#if CONFIG_SALIENCY_MAP
3676 uint8_t *saliency_map;
3677
3681 double *sm_scaling_factor;
3682#endif
3683
3688 int palette_pixel_num;
3689
3694 int scaled_last_source_available;
3695
3699 aom_roi_map_t roi;
3700} AV1_COMP;
3701
3705 typedef struct EncodeFrameInput {
3707 YV12_BUFFER_CONFIG *source;
3708 YV12_BUFFER_CONFIG *last_source;
3709 int64_t ts_duration;
3711} EncodeFrameInput;
3712
3717 typedef struct EncodeFrameParams {
3721 int error_resilient_mode;
3725 FRAME_TYPE frame_type;
3726
3728 int primary_ref_frame;
3729 int order_offset;
3730
3735 int show_frame;
3736
3738 int refresh_frame_flags;
3739
3740 int show_existing_frame;
3741 int existing_fb_idx_to_show;
3742
3747 int ref_frame_flags;
3748
3752 int remapped_ref_idx[REF_FRAMES];
3753
3758 RefreshFrameInfo refresh_frame;
3759
3763 int speed;
3764} EncodeFrameParams;
3765
3767
3768void av1_initialize_enc(unsigned int usage, enum aom_rc_mode end_usage);
3769
3770struct AV1_COMP *av1_create_compressor(AV1_PRIMARY *ppi,
3771 const AV1EncoderConfig *oxcf,
3772 BufferPool *const pool,
3773 COMPRESSOR_STAGE stage,
3774 int lap_lag_in_frames);
3775
3776struct AV1_PRIMARY *av1_create_primary_compressor(
3777 struct aom_codec_pkt_list *pkt_list_head, int num_lap_buffers,
3778 const AV1EncoderConfig *oxcf);
3779
3780void av1_remove_compressor(AV1_COMP *cpi);
3781
3782void av1_remove_primary_compressor(AV1_PRIMARY *ppi);
3783
3784#if CONFIG_ENTROPY_STATS
3785void print_entropy_stats(AV1_PRIMARY *const ppi);
3786#endif
3787#if CONFIG_INTERNAL_STATS
3788void print_internal_stats(AV1_PRIMARY *ppi);
3789#endif
3790
3791void av1_change_config_seq(AV1_PRIMARY *ppi, const AV1EncoderConfig *oxcf,
3792 bool *sb_size_changed);
3793
3794void av1_change_config(AV1_COMP *cpi, const AV1EncoderConfig *oxcf,
3795 bool sb_size_changed);
3796
3797 aom_codec_err_t av1_check_initial_width(AV1_COMP *cpi, int use_highbitdepth,
3798 int subsampling_x, int subsampling_y);
3799
3800void av1_post_encode_updates(AV1_COMP *const cpi,
3801 const AV1_COMP_DATA *const cpi_data);
3802
3803void av1_release_scaled_references_fpmt(AV1_COMP *cpi);
3804
3805void av1_decrement_ref_counts_fpmt(BufferPool *buffer_pool,
3806 int ref_buffers_used_map);
3807
3808void av1_init_sc_decisions(AV1_PRIMARY *const ppi);
3809
3810 AV1_COMP *av1_get_parallel_frame_enc_data(AV1_PRIMARY *const ppi,
3811 AV1_COMP_DATA *const first_cpi_data);
3812
3813int av1_init_parallel_frame_context(const AV1_COMP_DATA *const first_cpi_data,
3814 AV1_PRIMARY *const ppi,
3815 int *ref_buffers_used_map);
3816
3818
3835int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags,
3836 const YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
3837 int64_t end_time_stamp);
3838
3860int av1_get_compressed_data(AV1_COMP *cpi, AV1_COMP_DATA *const cpi_data);
3861
3868int av1_encode(AV1_COMP *const cpi, uint8_t *const dest, size_t dest_size,
3869 const EncodeFrameInput *const frame_input,
3870 const EncodeFrameParams *const frame_params,
3871 size_t *const frame_size);
3872
3874int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest);
3875
3876int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame);
3877
3878 aom_codec_err_t av1_copy_new_frame_enc(AV1_COMMON *cm,
3879 YV12_BUFFER_CONFIG *new_frame,
3880 YV12_BUFFER_CONFIG *sd);
3881
3882int av1_use_as_reference(int *ext_ref_frame_flags, int ref_frame_flags);
3883
3884int av1_copy_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
3885
3886int av1_set_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
3887
3888void av1_set_frame_size(AV1_COMP *cpi, int width, int height);
3889
3890void av1_set_mv_search_params(AV1_COMP *cpi);
3891
3892int av1_set_roi_map(AV1_COMP *cpi, unsigned char *map, unsigned int rows,
3893 unsigned int cols, int delta_q[8], int delta_lf[8],
3894 int skip[8], int ref_frame[8]);
3895
3896int av1_set_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
3897
3898int av1_get_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
3899
3900int av1_set_internal_size(AV1EncoderConfig *const oxcf,
3901 ResizePendingParams *resize_pending_params,
3902 AOM_SCALING_MODE horiz_mode,
3903 AOM_SCALING_MODE vert_mode);
3904
3905int av1_get_quantizer(struct AV1_COMP *cpi);
3906
3907// This function assumes that the input buffer contains valid OBUs. It should
3908// not be called on untrusted input.
3909int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t buffer_size,
3910 size_t *input_size);
3911
3912void av1_alloc_mb_wiener_var_pred_buf(AV1_COMMON *cm, ThreadData *td);
3913
3914void av1_dealloc_mb_wiener_var_pred_buf(ThreadData *td);
3915
3916uint8_t av1_find_dominant_value(const uint8_t *src, int stride, int rows,
3917 int cols);
3918
3919void av1_dilate_block(const uint8_t *src, int src_stride, uint8_t *dilated,
3920 int dilated_stride, int rows, int cols);
3921
3922// Set screen content options.
3923// This function estimates whether to use screen content tools, by counting
3924// the portion of blocks that have few luma colors.
3925// Modifies:
3926// cpi->commom.features.allow_screen_content_tools
3927// cpi->common.features.allow_intrabc
3928// cpi->use_screen_content_tools
3929// cpi->is_screen_content_type
3930// However, the estimation is not accurate and may misclassify videos.
3931// A slower but more accurate approach that determines whether to use screen
3932// content tools is employed later. See av1_determine_sc_tools_with_encoding().
3933void av1_set_screen_content_options(struct AV1_COMP *cpi,
3934 FeatureFlags *features);
3935
3936void av1_update_frame_size(AV1_COMP *cpi);
3937
3938void av1_set_svc_seq_params(AV1_PRIMARY *const ppi);
3939
3940typedef struct {
3941 int pyr_level;
3942 int disp_order;
3943} RefFrameMapPair;
3944
3945static inline void init_ref_map_pair(
3946 AV1_COMP *cpi, RefFrameMapPair ref_frame_map_pairs[REF_FRAMES]) {
3947 if (cpi->ppi->gf_group.update_type[cpi->gf_frame_index] == KF_UPDATE) {
3948 memset(ref_frame_map_pairs, -1, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
3949 return;
3950 }
3951 memset(ref_frame_map_pairs, 0, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
3952 for (int map_idx = 0; map_idx < REF_FRAMES; map_idx++) {
3953 // Get reference frame buffer.
3954 const RefCntBuffer *const buf = cpi->common.ref_frame_map[map_idx];
3955 if (ref_frame_map_pairs[map_idx].disp_order == -1) continue;
3956 if (buf == NULL) {
3957 ref_frame_map_pairs[map_idx].disp_order = -1;
3958 ref_frame_map_pairs[map_idx].pyr_level = -1;
3959 continue;
3960 } else if (buf->ref_count > 1) {
3961 // Once the keyframe is coded, the slots in ref_frame_map will all
3962 // point to the same frame. In that case, all subsequent pointers
3963 // matching the current are considered "free" slots. This will find
3964 // the next occurrence of the current pointer if ref_count indicates
3965 // there are multiple instances of it and mark it as free.
3966 for (int idx2 = map_idx + 1; idx2 < REF_FRAMES; ++idx2) {
3967 const RefCntBuffer *const buf2 = cpi->common.ref_frame_map[idx2];
3968 if (buf2 == buf) {
3969 ref_frame_map_pairs[idx2].disp_order = -1;
3970 ref_frame_map_pairs[idx2].pyr_level = -1;
3971 }
3972 }
3973 }
3974 ref_frame_map_pairs[map_idx].disp_order = (int)buf->display_order_hint;
3975 ref_frame_map_pairs[map_idx].pyr_level = buf->pyramid_level;
3976 }
3977}
3978
3979#if CONFIG_FPMT_TEST
3980static inline void calc_frame_data_update_flag(
3981 GF_GROUP *const gf_group, int gf_frame_index,
3982 bool *const do_frame_data_update) {
3983 *do_frame_data_update = true;
3984 // Set the flag to false for all frames in a given parallel encode set except
3985 // the last frame in the set with frame_parallel_level = 2.
3986 if (gf_group->frame_parallel_level[gf_frame_index] == 1) {
3987 *do_frame_data_update = false;
3988 } else if (gf_group->frame_parallel_level[gf_frame_index] == 2) {
3989 // Check if this is the last frame in the set with frame_parallel_level = 2.
3990 for (int i = gf_frame_index + 1; i < gf_group->size; i++) {
3991 if ((gf_group->frame_parallel_level[i] == 0 &&
3992 (gf_group->update_type[i] == ARF_UPDATE ||
3993 gf_group->update_type[i] == INTNL_ARF_UPDATE)) ||
3994 gf_group->frame_parallel_level[i] == 1) {
3995 break;
3996 } else if (gf_group->frame_parallel_level[i] == 2) {
3997 *do_frame_data_update = false;
3998 break;
3999 }
4000 }
4001 }
4002}
4003#endif
4004
4005// av1 uses 10,000,000 ticks/second as time stamp
4006#define TICKS_PER_SEC 10000000LL
4007
4008static inline int64_t timebase_units_to_ticks(
4009 const aom_rational64_t *timestamp_ratio, int64_t n) {
4010 return n * timestamp_ratio->num / timestamp_ratio->den;
4011}
4012
4013static inline int64_t ticks_to_timebase_units(
4014 const aom_rational64_t *timestamp_ratio, int64_t n) {
4015 int64_t round = timestamp_ratio->num / 2;
4016 if (round > 0) --round;
4017 return (n * timestamp_ratio->den + round) / timestamp_ratio->num;
4018}
4019
4020static inline int frame_is_kf_gf_arf(const AV1_COMP *cpi) {
4021 const GF_GROUP *const gf_group = &cpi->ppi->gf_group;
4022 const FRAME_UPDATE_TYPE update_type =
4023 gf_group->update_type[cpi->gf_frame_index];
4024
4025 return frame_is_intra_only(&cpi->common) || update_type == ARF_UPDATE ||
4026 update_type == GF_UPDATE;
4027}
4028
4029// TODO(huisu@google.com, youzhou@microsoft.com): enable hash-me for HBD.
4030static inline int av1_use_hash_me(const AV1_COMP *const cpi) {
4031 return (cpi->common.features.allow_screen_content_tools &&
4032 cpi->common.features.allow_intrabc &&
4033 frame_is_intra_only(&cpi->common));
4034}
4035
4036static inline const YV12_BUFFER_CONFIG *get_ref_frame_yv12_buf(
4037 const AV1_COMMON *const cm, MV_REFERENCE_FRAME ref_frame) {
4038 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
4039 return buf != NULL ? &buf->buf : NULL;
4040}
4041
4042static inline void alloc_frame_mvs(AV1_COMMON *const cm, RefCntBuffer *buf) {
4043 assert(buf != NULL);
4044 ensure_mv_buffer(buf, cm);
4045 buf->width = cm->width;
4046 buf->height = cm->height;
4047}
4048
4049// Get the allocated token size for a tile. It does the same calculation as in
4050// the frame token allocation.
4051static inline unsigned int allocated_tokens(const TileInfo *tile,
4052 int sb_size_log2, int num_planes) {
4053 int tile_mb_rows =
4054 ROUND_POWER_OF_TWO(tile->mi_row_end - tile->mi_row_start, 2);
4055 int tile_mb_cols =
4056 ROUND_POWER_OF_TWO(tile->mi_col_end - tile->mi_col_start, 2);
4057
4058 return get_token_alloc(tile_mb_rows, tile_mb_cols, sb_size_log2, num_planes);
4059}
4060
4061static inline void get_start_tok(AV1_COMP *cpi, int tile_row, int tile_col,
4062 int mi_row, TokenExtra **tok, int sb_size_log2,
4063 int num_planes) {
4064 AV1_COMMON *const cm = &cpi->common;
4065 const int tile_cols = cm->tiles.cols;
4066 TileDataEnc *this_tile = &cpi->tile_data[tile_row * tile_cols + tile_col];
4067 const TileInfo *const tile_info = &this_tile->tile_info;
4068
4069 const int tile_mb_cols =
4070 (tile_info->mi_col_end - tile_info->mi_col_start + 2) >> 2;
4071 const int tile_mb_row = (mi_row - tile_info->mi_row_start + 2) >> 2;
4072
4073 *tok = cpi->token_info.tile_tok[tile_row][tile_col] +
4074 get_token_alloc(tile_mb_row, tile_mb_cols, sb_size_log2, num_planes);
4075}
4076
4077void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags);
4078
4079#define ALT_MIN_LAG 3
4080static inline int is_altref_enabled(int lag_in_frames, bool enable_auto_arf) {
4081 return lag_in_frames >= ALT_MIN_LAG && enable_auto_arf;
4082}
4083
4084static inline int can_disable_altref(const GFConfig *gf_cfg) {
4085 return is_altref_enabled(gf_cfg->lag_in_frames, gf_cfg->enable_auto_arf) &&
4086 (gf_cfg->gf_min_pyr_height == 0);
4087}
4088
4089// Helper function to compute number of blocks on either side of the frame.
4090static inline int get_num_blocks(const int frame_length, const int mb_length) {
4091 return (frame_length + mb_length - 1) / mb_length;
4092}
4093
4094// Check if statistics generation stage
4095static inline int is_stat_generation_stage(const AV1_COMP *const cpi) {
4096 assert(IMPLIES(cpi->compressor_stage == LAP_STAGE,
4097 cpi->oxcf.pass == AOM_RC_ONE_PASS && cpi->ppi->lap_enabled));
4098 return (cpi->oxcf.pass == AOM_RC_FIRST_PASS ||
4099 (cpi->compressor_stage == LAP_STAGE));
4100}
4101// Check if statistics consumption stage
4102static inline int is_stat_consumption_stage_twopass(const AV1_COMP *const cpi) {
4103 return (cpi->oxcf.pass >= AOM_RC_SECOND_PASS);
4104}
4105
4106// Check if statistics consumption stage
4107static inline int is_stat_consumption_stage(const AV1_COMP *const cpi) {
4108 return (is_stat_consumption_stage_twopass(cpi) ||
4109 (cpi->oxcf.pass == AOM_RC_ONE_PASS &&
4110 (cpi->compressor_stage == ENCODE_STAGE) && cpi->ppi->lap_enabled));
4111}
4112
4113// Decide whether 'dv_costs' need to be allocated/stored during the encoding.
4114static inline bool av1_need_dv_costs(const AV1_COMP *const cpi) {
4115 return !cpi->sf.rt_sf.use_nonrd_pick_mode &&
4116 av1_allow_intrabc(&cpi->common) && !is_stat_generation_stage(cpi);
4117}
4118
4128 static inline int has_no_stats_stage(const AV1_COMP *const cpi) {
4129 assert(
4130 IMPLIES(!cpi->ppi->lap_enabled, cpi->compressor_stage == ENCODE_STAGE));
4131 return (cpi->oxcf.pass == AOM_RC_ONE_PASS && !cpi->ppi->lap_enabled);
4132}
4133
4135
4136static inline int is_one_pass_rt_params(const AV1_COMP *cpi) {
4137 return has_no_stats_stage(cpi) && cpi->oxcf.gf_cfg.lag_in_frames == 0 &&
4138 (cpi->oxcf.mode == REALTIME || cpi->svc.number_spatial_layers > 1);
4139}
4140
4141// Use default/internal reference structure for single-layer RTC.
4142static inline int use_rtc_reference_structure_one_layer(const AV1_COMP *cpi) {
4143 return is_one_pass_rt_params(cpi) && cpi->ppi->number_spatial_layers == 1 &&
4144 cpi->ppi->number_temporal_layers == 1 &&
4145 !cpi->ppi->rtc_ref.set_ref_frame_config;
4146}
4147
4148// Check if postencode drop is allowed.
4149static inline int allow_postencode_drop_rtc(const AV1_COMP *cpi) {
4150 const AV1_COMMON *const cm = &cpi->common;
4151 return is_one_pass_rt_params(cpi) && cpi->oxcf.rc_cfg.mode == AOM_CBR &&
4152 cpi->oxcf.rc_cfg.drop_frames_water_mark > 0 &&
4153 !cpi->rc.rtc_external_ratectrl && !frame_is_intra_only(cm) &&
4154 cpi->svc.spatial_layer_id == 0;
4155}
4156
4157// Function return size of frame stats buffer
4158static inline int get_stats_buf_size(int num_lap_buffer, int num_lag_buffer) {
4159 /* if lookahead is enabled return num_lap_buffers else num_lag_buffers */
4160 return (num_lap_buffer > 0 ? num_lap_buffer + 1 : num_lag_buffer);
4161}
4162
4163// TODO(zoeliu): To set up cpi->oxcf.gf_cfg.enable_auto_brf
4164
4165static inline void set_ref_ptrs(const AV1_COMMON *cm, MACROBLOCKD *xd,
4166 MV_REFERENCE_FRAME ref0,
4167 MV_REFERENCE_FRAME ref1) {
4168 xd->block_ref_scale_factors[0] =
4169 get_ref_scale_factors_const(cm, ref0 >= LAST_FRAME ? ref0 : 1);
4170 xd->block_ref_scale_factors[1] =
4171 get_ref_scale_factors_const(cm, ref1 >= LAST_FRAME ? ref1 : 1);
4172}
4173
4174static inline int get_chessboard_index(int frame_index) {
4175 return frame_index & 0x1;
4176}
4177
4178static inline const int *cond_cost_list_const(const struct AV1_COMP *cpi,
4179 const int *cost_list) {
4180 const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
4181 cpi->sf.mv_sf.use_fullpel_costlist;
4182 return use_cost_list ? cost_list : NULL;
4183}
4184
4185static inline int *cond_cost_list(const struct AV1_COMP *cpi, int *cost_list) {
4186 const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
4187 cpi->sf.mv_sf.use_fullpel_costlist;
4188 return use_cost_list ? cost_list : NULL;
4189}
4190
4191// Compression ratio of current frame.
4192double av1_get_compression_ratio(const AV1_COMMON *const cm,
4193 size_t encoded_frame_size);
4194
4195void av1_new_framerate(AV1_COMP *cpi, double framerate);
4196
4197void av1_setup_frame_size(AV1_COMP *cpi);
4198
4199#define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl))
4200
4201// Returns 1 if a frame is scaled and 0 otherwise.
4202static inline int av1_resize_scaled(const AV1_COMMON *cm) {
4203 return cm->superres_upscaled_width != cm->render_width ||
4204 cm->superres_upscaled_height != cm->render_height;
4205}
4206
4207static inline int av1_frame_scaled(const AV1_COMMON *cm) {
4208 return av1_superres_scaled(cm) || av1_resize_scaled(cm);
4209}
4210
4211// Don't allow a show_existing_frame to coincide with an error resilient
4212// frame. An exception can be made for a forward keyframe since it has no
4213// previous dependencies.
4214static inline int encode_show_existing_frame(const AV1_COMMON *cm) {
4215 return cm->show_existing_frame && (!cm->features.error_resilient_mode ||
4216 cm->current_frame.frame_type == KEY_FRAME);
4217}
4218
4219// Get index into the 'cpi->mbmi_ext_info.frame_base' array for the given
4220// 'mi_row' and 'mi_col'.
4221static inline int get_mi_ext_idx(const int mi_row, const int mi_col,
4222 const BLOCK_SIZE mi_alloc_bsize,
4223 const int mbmi_ext_stride) {
4224 const int mi_ext_size_1d = mi_size_wide[mi_alloc_bsize];
4225 const int mi_ext_row = mi_row / mi_ext_size_1d;
4226 const int mi_ext_col = mi_col / mi_ext_size_1d;
4227 return mi_ext_row * mbmi_ext_stride + mi_ext_col;
4228}
4229
4230// Lighter version of set_offsets that only sets the mode info
4231// pointers.
4232static inline void set_mode_info_offsets(
4233 const CommonModeInfoParams *const mi_params,
4234 const MBMIExtFrameBufferInfo *const mbmi_ext_info, MACROBLOCK *const x,
4235 MACROBLOCKD *const xd, int mi_row, int mi_col) {
4236 set_mi_offsets(mi_params, xd, mi_row, mi_col);
4237 const int ext_idx = get_mi_ext_idx(mi_row, mi_col, mi_params->mi_alloc_bsize,
4238 mbmi_ext_info->stride);
4239 x->mbmi_ext_frame = mbmi_ext_info->frame_base + ext_idx;
4240}
4241
4242// Check to see if the given partition size is allowed for a specified number
4243// of mi block rows and columns remaining in the image.
4244// If not then return the largest allowed partition size
4245static inline BLOCK_SIZE find_partition_size(BLOCK_SIZE bsize, int rows_left,
4246 int cols_left, int *bh, int *bw) {
4247 int int_size = (int)bsize;
4248 if (rows_left <= 0 || cols_left <= 0) {
4249 return AOMMIN(bsize, BLOCK_8X8);
4250 } else {
4251 for (; int_size > 0; int_size -= 3) {
4252 *bh = mi_size_high[int_size];
4253 *bw = mi_size_wide[int_size];
4254 if ((*bh <= rows_left) && (*bw <= cols_left)) {
4255 break;
4256 }
4257 }
4258 }
4259 return (BLOCK_SIZE)int_size;
4260}
4261
4262static const uint8_t av1_ref_frame_flag_list[REF_FRAMES] = { 0,
4263 AOM_LAST_FLAG,
4264 AOM_LAST2_FLAG,
4265 AOM_LAST3_FLAG,
4266 AOM_GOLD_FLAG,
4267 AOM_BWD_FLAG,
4268 AOM_ALT2_FLAG,
4269 AOM_ALT_FLAG };
4270
4271// When more than 'max_allowed_refs' are available, we reduce the number of
4272// reference frames one at a time based on this order.
4273static const MV_REFERENCE_FRAME disable_order[] = {
4274 LAST3_FRAME,
4275 LAST2_FRAME,
4276 ALTREF2_FRAME,
4277 BWDREF_FRAME,
4278};
4279
4280static const MV_REFERENCE_FRAME
4281 ref_frame_priority_order[INTER_REFS_PER_FRAME] = {
4282 LAST_FRAME, ALTREF_FRAME, BWDREF_FRAME, GOLDEN_FRAME,
4283 ALTREF2_FRAME, LAST2_FRAME, LAST3_FRAME,
4284 };
4285
4286static inline int get_ref_frame_flags(const SPEED_FEATURES *const sf,
4287 const int use_one_pass_rt_params,
4288 const YV12_BUFFER_CONFIG **ref_frames,
4289 const int ext_ref_frame_flags) {
4290 // cpi->ext_flags.ref_frame_flags allows certain reference types to be
4291 // disabled by the external interface. These are set by
4292 // av1_apply_encoding_flags(). Start with what the external interface allows,
4293 // then suppress any reference types which we have found to be duplicates.
4294 int flags = ext_ref_frame_flags;
4295
4296 for (int i = 1; i < INTER_REFS_PER_FRAME; ++i) {
4297 const YV12_BUFFER_CONFIG *const this_ref = ref_frames[i];
4298 // If this_ref has appeared before, mark the corresponding ref frame as
4299 // invalid. For one_pass_rt mode, only disable GOLDEN_FRAME if it's the
4300 // same as LAST_FRAME or ALTREF_FRAME (if ALTREF is being used in nonrd).
4301 int index =
4302 (use_one_pass_rt_params && ref_frame_priority_order[i] == GOLDEN_FRAME)
4303 ? (1 + sf->rt_sf.use_nonrd_altref_frame)
4304 : i;
4305 for (int j = 0; j < index; ++j) {
4306 // If this_ref has appeared before (same as the reference corresponding
4307 // to lower index j), remove it as a reference only if that reference
4308 // (for index j) is actually used as a reference.
4309 if (this_ref == ref_frames[j] &&
4310 (flags & (1 << (ref_frame_priority_order[j] - 1)))) {
4311 flags &= ~(1 << (ref_frame_priority_order[i] - 1));
4312 break;
4313 }
4314 }
4315 }
4316 return flags;
4317}
4318
4319// Returns a Sequence Header OBU stored in an aom_fixed_buf_t, or NULL upon
4320// failure. When a non-NULL aom_fixed_buf_t pointer is returned by this
4321// function, the memory must be freed by the caller. Both the buf member of the
4322// aom_fixed_buf_t, and the aom_fixed_buf_t pointer itself must be freed. Memory
4323// returned must be freed via call to free().
4324//
4325// Note: The OBU returned is in Low Overhead Bitstream Format. Specifically,
4326// the obu_has_size_field bit is set, and the buffer contains the obu_size
4327// field.
4328 aom_fixed_buf_t *av1_get_global_headers(AV1_PRIMARY *ppi);
4329
4330#define MAX_GFUBOOST_FACTOR 10.0
4331#define MIN_GFUBOOST_FACTOR 4.0
4332
4333static inline int is_frame_tpl_eligible(const GF_GROUP *const gf_group,
4334 uint8_t index) {
4335 const FRAME_UPDATE_TYPE update_type = gf_group->update_type[index];
4336 return update_type == ARF_UPDATE || update_type == GF_UPDATE ||
4337 update_type == KF_UPDATE;
4338}
4339
4340static inline int is_frame_eligible_for_ref_pruning(const GF_GROUP *gf_group,
4341 int selective_ref_frame,
4342 int prune_ref_frames,
4343 int gf_index) {
4344 return (selective_ref_frame > 0) && (prune_ref_frames > 0) &&
4345 !is_frame_tpl_eligible(gf_group, gf_index);
4346}
4347
4348// Get update type of the current frame.
4349static inline FRAME_UPDATE_TYPE get_frame_update_type(const GF_GROUP *gf_group,
4350 int gf_frame_index) {
4351 return gf_group->update_type[gf_frame_index];
4352}
4353
4354static inline int av1_pixels_to_mi(int pixels) {
4355 return ALIGN_POWER_OF_TWO(pixels, 3) >> MI_SIZE_LOG2;
4356}
4357
4358static inline int is_psnr_calc_enabled(const AV1_COMP *cpi) {
4359 const AV1_COMMON *const cm = &cpi->common;
4360
4361 return cpi->ppi->b_calculate_psnr && !is_stat_generation_stage(cpi) &&
4362 cm->show_frame && !cpi->is_dropped_frame;
4363}
4364
4365static inline int is_frame_resize_pending(const AV1_COMP *const cpi) {
4366 const ResizePendingParams *const resize_pending_params =
4367 &cpi->resize_pending_params;
4368 return (resize_pending_params->width && resize_pending_params->height &&
4369 (cpi->common.width != resize_pending_params->width ||
4370 cpi->common.height != resize_pending_params->height));
4371}
4372
4373// Check if loop filter is used.
4374static inline int is_loopfilter_used(const AV1_COMMON *const cm) {
4375 return !cm->features.coded_lossless && !cm->tiles.large_scale;
4376}
4377
4378// Check if CDEF is used.
4379static inline int is_cdef_used(const AV1_COMMON *const cm) {
4380 return cm->seq_params->enable_cdef && !cm->features.coded_lossless &&
4381 !cm->tiles.large_scale;
4382}
4383
4384// Check if loop restoration filter is used.
4385static inline int is_restoration_used(const AV1_COMMON *const cm) {
4386 return cm->seq_params->enable_restoration && !cm->features.all_lossless &&
4387 !cm->tiles.large_scale;
4388}
4389
4390// Checks if post-processing filters need to be applied.
4391// NOTE: This function decides if the application of different post-processing
4392// filters on the reconstructed frame can be skipped at the encoder side.
4393// However the computation of different filter parameters that are signaled in
4394// the bitstream is still required.
4395static inline unsigned int derive_skip_apply_postproc_filters(
4396 const AV1_COMP *cpi, int use_loopfilter, int use_cdef, int use_superres,
4397 int use_restoration) {
4398 // Though CDEF parameter selection should be dependent on
4399 // deblocked/loop-filtered pixels for cdef_pick_method <=
4400 // CDEF_FAST_SEARCH_LVL5, CDEF strength values are calculated based on the
4401 // pixel values that are not loop-filtered in svc real-time encoding mode.
4402 // Hence this case is handled separately using the condition below.
4403 if (cpi->ppi->rtc_ref.non_reference_frame)
4404 return (SKIP_APPLY_LOOPFILTER | SKIP_APPLY_CDEF);
4405
4406 if (!cpi->oxcf.algo_cfg.skip_postproc_filtering || cpi->ppi->b_calculate_psnr)
4407 return 0;
4408 assert(cpi->oxcf.mode == ALLINTRA);
4409
4410 // The post-processing filters are applied one after the other in the
4411 // following order: deblocking->cdef->superres->restoration. In case of
4412 // ALLINTRA encoding, the reconstructed frame is not used as a reference
4413 // frame. Hence, the application of these filters can be skipped when
4414 // 1. filter parameters of the subsequent stages are not dependent on the
4415 // filtered output of the current stage or
4416 // 2. subsequent filtering stages are disabled
4417 if (use_restoration) return SKIP_APPLY_RESTORATION;
4418 if (use_superres) return SKIP_APPLY_SUPERRES;
4419 if (use_cdef) {
4420 // CDEF parameter selection is not dependent on the deblocked frame if
4421 // cdef_pick_method is CDEF_PICK_FROM_Q. Hence the application of deblocking
4422 // filters and cdef filters can be skipped in this case.
4423 return (cpi->sf.lpf_sf.cdef_pick_method == CDEF_PICK_FROM_Q &&
4424 use_loopfilter)
4425 ? (SKIP_APPLY_LOOPFILTER | SKIP_APPLY_CDEF)
4426 : SKIP_APPLY_CDEF;
4427 }
4428 if (use_loopfilter) return SKIP_APPLY_LOOPFILTER;
4429
4430 // If we reach here, all post-processing stages are disabled, so none need to
4431 // be skipped.
4432 return 0;
4433}
4434
4435static inline void set_postproc_filter_default_params(AV1_COMMON *cm) {
4436 struct loopfilter *const lf = &cm->lf;
4437 CdefInfo *const cdef_info = &cm->cdef_info;
4438 RestorationInfo *const rst_info = cm->rst_info;
4439
4440 lf->filter_level[0] = 0;
4441 lf->filter_level[1] = 0;
4442 lf->backup_filter_level[0] = 0;
4443 lf->backup_filter_level[1] = 0;
4444 cdef_info->cdef_bits = 0;
4445 cdef_info->cdef_strengths[0] = 0;
4446 cdef_info->nb_cdef_strengths = 1;
4447 cdef_info->cdef_uv_strengths[0] = 0;
4448 rst_info[0].frame_restoration_type = RESTORE_NONE;
4449 rst_info[1].frame_restoration_type = RESTORE_NONE;
4450 rst_info[2].frame_restoration_type = RESTORE_NONE;
4451}
4452
4453static inline int is_inter_tx_size_search_level_one(
4454 const TX_SPEED_FEATURES *tx_sf) {
4455 return (tx_sf->inter_tx_size_search_init_depth_rect >= 1 &&
4456 tx_sf->inter_tx_size_search_init_depth_sqr >= 1);
4457}
4458
4459static inline int get_lpf_opt_level(const SPEED_FEATURES *sf) {
4460 int lpf_opt_level = 0;
4461 if (is_inter_tx_size_search_level_one(&sf->tx_sf))
4462 lpf_opt_level = (sf->lpf_sf.lpf_pick == LPF_PICK_FROM_Q) ? 2 : 1;
4463 return lpf_opt_level;
4464}
4465
4466// Enable switchable motion mode only if warp and OBMC tools are allowed
4467static inline bool is_switchable_motion_mode_allowed(bool allow_warped_motion,
4468 bool enable_obmc) {
4469 return (allow_warped_motion || enable_obmc);
4470}
4471
4472#if CONFIG_AV1_TEMPORAL_DENOISING
4473static inline int denoise_svc(const struct AV1_COMP *const cpi) {
4474 return (!cpi->ppi->use_svc ||
4475 (cpi->ppi->use_svc &&
4476 cpi->svc.spatial_layer_id >= cpi->svc.first_layer_denoise));
4477}
4478#endif
4479
4480#if CONFIG_COLLECT_PARTITION_STATS == 2
4481static inline void av1_print_fr_partition_timing_stats(
4482 const FramePartitionTimingStats *part_stats, const char *filename) {
4483 FILE *f = fopen(filename, "w");
4484 if (!f) {
4485 return;
4486 }
4487
4488 fprintf(f, "bsize,redo,");
4489 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4490 fprintf(f, "decision_%d,", part);
4491 }
4492 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4493 fprintf(f, "attempt_%d,", part);
4494 }
4495 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4496 fprintf(f, "time_%d,", part);
4497 }
4498 fprintf(f, "\n");
4499
4500 static const int bsizes[6] = { 128, 64, 32, 16, 8, 4 };
4501
4502 for (int bsize_idx = 0; bsize_idx < 6; bsize_idx++) {
4503 fprintf(f, "%d,%d,", bsizes[bsize_idx], part_stats->partition_redo);
4504 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4505 fprintf(f, "%d,", part_stats->partition_decisions[bsize_idx][part]);
4506 }
4507 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4508 fprintf(f, "%d,", part_stats->partition_attempts[bsize_idx][part]);
4509 }
4510 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4511 fprintf(f, "%ld,", part_stats->partition_times[bsize_idx][part]);
4512 }
4513 fprintf(f, "\n");
4514 }
4515 fclose(f);
4516}
4517#endif // CONFIG_COLLECT_PARTITION_STATS == 2
4518
4519#if CONFIG_COLLECT_PARTITION_STATS
4520static inline int av1_get_bsize_idx_for_part_stats(BLOCK_SIZE bsize) {
4521 assert(bsize == BLOCK_128X128 || bsize == BLOCK_64X64 ||
4522 bsize == BLOCK_32X32 || bsize == BLOCK_16X16 || bsize == BLOCK_8X8 ||
4523 bsize == BLOCK_4X4);
4524 switch (bsize) {
4525 case BLOCK_128X128: return 0;
4526 case BLOCK_64X64: return 1;
4527 case BLOCK_32X32: return 2;
4528 case BLOCK_16X16: return 3;
4529 case BLOCK_8X8: return 4;
4530 case BLOCK_4X4: return 5;
4531 default: assert(0 && "Invalid bsize for partition_stats."); return -1;
4532 }
4533}
4534#endif // CONFIG_COLLECT_PARTITION_STATS
4535
4536#if CONFIG_COLLECT_COMPONENT_TIMING
4537static inline void start_timing(AV1_COMP *cpi, int component) {
4538 aom_usec_timer_start(&cpi->component_timer[component]);
4539}
4540static inline void end_timing(AV1_COMP *cpi, int component) {
4541 aom_usec_timer_mark(&cpi->component_timer[component]);
4542 cpi->frame_component_time[component] +=
4543 aom_usec_timer_elapsed(&cpi->component_timer[component]);
4544}
4545static inline char const *get_frame_type_enum(int type) {
4546 switch (type) {
4547 case 0: return "KEY_FRAME";
4548 case 1: return "INTER_FRAME";
4549 case 2: return "INTRA_ONLY_FRAME";
4550 case 3: return "S_FRAME";
4551 default: assert(0);
4552 }
4553 return "error";
4554}
4555#endif
4556
4558
4559#ifdef __cplusplus
4560} // extern "C"
4561#endif
4562
4563#endif // AOM_AV1_ENCODER_ENCODER_H_
aom_chroma_sample_position_t
enum aom_chroma_sample_position aom_chroma_sample_position_t
List of chroma sample positions.
aom_transfer_characteristics_t
enum aom_transfer_characteristics aom_transfer_characteristics_t
List of supported transfer functions.
aom_color_range_t
enum aom_color_range aom_color_range_t
List of supported color range.
aom_color_primaries_t
enum aom_color_primaries aom_color_primaries_t
List of supported color primaries.
aom_matrix_coefficients_t
enum aom_matrix_coefficients aom_matrix_coefficients_t
List of supported matrix coefficients.
aomcx.h
Provides definitions for using AOM or AV1 encoder algorithm within the aom Codec Interface.
block.h
MACROBLOCK
struct macroblock MACROBLOCK
Encoder's parameters related to the current coding block.
COST_UPDATE_TYPE
COST_UPDATE_TYPE
This enum controls how often the entropy costs should be updated.
Definition encoder.h:222
COST_UPD_SBROW
@ COST_UPD_SBROW
Definition encoder.h:224
COST_UPD_TILE
@ COST_UPD_TILE
Definition encoder.h:225
COST_UPD_OFF
@ COST_UPD_OFF
Definition encoder.h:226
NUM_COST_UPDATE_TYPES
@ NUM_COST_UPDATE_TYPES
Definition encoder.h:227
COST_UPD_SB
@ COST_UPD_SB
Definition encoder.h:223
LOOPFILTER_CONTROL
LOOPFILTER_CONTROL
This enum controls to which frames loopfilter is applied.
Definition encoder.h:233
LOOPFILTER_ALL
@ LOOPFILTER_ALL
Definition encoder.h:235
LOOPFILTER_SELECTIVELY
@ LOOPFILTER_SELECTIVELY
Definition encoder.h:237
LOOPFILTER_REFERENCE
@ LOOPFILTER_REFERENCE
Definition encoder.h:236
LOOPFILTER_NONE
@ LOOPFILTER_NONE
Definition encoder.h:234
NUM_RECODES_PER_FRAME
#define NUM_RECODES_PER_FRAME
Max number of recodes used to track the frame probabilities.
Definition encoder.h:1645
InterModesInfo
struct inter_modes_info InterModesInfo
Struct used to hold inter mode data for fast tx search.
SKIP_APPLY_POSTPROC_FILTER
SKIP_APPLY_POSTPROC_FILTER
This enum controls the application of post-processing filters on a reconstructed frame.
Definition encoder.h:245
MAX_PARALLEL_FRAMES
#define MAX_PARALLEL_FRAMES
Max number of frames that can be encoded in a parallel encode set.
Definition encoder.h:1650
enums.h
RestorationType
RestorationType
This enumeration defines various restoration types supported.
Definition enums.h:609
RESTORE_NONE
@ RESTORE_NONE
Definition enums.h:610
RESTORE_SWITCHABLE_TYPES
@ RESTORE_SWITCHABLE_TYPES
Definition enums.h:614
RESTORE_TYPES
@ RESTORE_TYPES
Definition enums.h:615
aom_dist_metric
aom_dist_metric
Distortion metric to use for RD optimization.
Definition aomcx.h:1770
aom_tune_content
aom_tune_content
AV1 encoder content type.
Definition aomcx.h:1694
AOM_SCALING_MODE
enum aom_scaling_mode_1d AOM_SCALING_MODE
aom 1-D scaling mode
aom_tune_metric
aom_tune_metric
Model tuning parameters.
Definition aomcx.h:1737
aom_roi_map_t
struct aom_roi_map aom_roi_map_t
aom region of interest map
aom_screen_detection_mode
aom_screen_detection_mode
Screen content detection mode.
Definition aomcx.h:1702
aom_bit_depth_t
enum aom_bit_depth aom_bit_depth_t
Bit depth for codecThis enumeration determines the bit depth of the codec.
aom_superblock_size_t
enum aom_superblock_size aom_superblock_size_t
Superblock size selection.
aom_codec_err_t
aom_codec_err_t
Algorithm return codes.
Definition aom_codec.h:155
aom_superres_mode
aom_superres_mode
Frame super-resolution mode.
Definition aom_encoder.h:207
aom_rc_mode
aom_rc_mode
Rate control mode.
Definition aom_encoder.h:185
aom_enc_pass
aom_enc_pass
Multi-pass Encoding Pass.
Definition aom_encoder.h:176
aom_fixed_buf_t
struct aom_fixed_buf aom_fixed_buf_t
Generic fixed size buffer structure.
aom_enc_frame_flags_t
long aom_enc_frame_flags_t
Encoded Frame Flags.
Definition aom_encoder.h:377
AOM_CBR
@ AOM_CBR
Definition aom_encoder.h:187
AOM_RC_ONE_PASS
@ AOM_RC_ONE_PASS
Definition aom_encoder.h:177
AOM_RC_SECOND_PASS
@ AOM_RC_SECOND_PASS
Definition aom_encoder.h:179
AOM_RC_FIRST_PASS
@ AOM_RC_FIRST_PASS
Definition aom_encoder.h:178
av1_get_compressed_data
int av1_get_compressed_data(AV1_COMP *cpi, AV1_COMP_DATA *const cpi_data)
Encode a frame.
Definition encoder.c:5180
av1_encode
int av1_encode(AV1_COMP *const cpi, uint8_t *const dest, size_t dest_size, const EncodeFrameInput *const frame_input, const EncodeFrameParams *const frame_params, size_t *const frame_size)
Run 1-pass/2-pass encoding.
Definition encoder.c:4472
av1_receive_raw_frame
int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags, const YV12_BUFFER_CONFIG *sd, int64_t time_stamp, int64_t end_time_stamp)
Obtain the raw frame data.
Definition encoder.c:4570
has_no_stats_stage
static int has_no_stats_stage(const AV1_COMP *const cpi)
Check if the current stage has statistics.
Definition encoder.h:4128
lookahead.h
Describes look ahead buffer operations.
speed_features.h
CDEF_PICK_FROM_Q
@ CDEF_PICK_FROM_Q
Definition speed_features.h:172
AV1Common::rst_info
RestorationInfo rst_info[3]
Definition av1_common_int.h:960
AV1Common::superres_upscaled_width
int superres_upscaled_width
Definition av1_common_int.h:813
AV1Common::superres_upscaled_height
int superres_upscaled_height
Definition av1_common_int.h:814
AV1Common::seq_params
SequenceHeader * seq_params
Definition av1_common_int.h:990
AV1Common::width
int width
Definition av1_common_int.h:789
AV1Common::cdef_info
CdefInfo cdef_info
Definition av1_common_int.h:969
AV1Common::current_frame
CurrentFrame current_frame
Definition av1_common_int.h:768
AV1Common::show_existing_frame
int show_existing_frame
Definition av1_common_int.h:914
AV1Common::lf
struct loopfilter lf
Definition av1_common_int.h:953
AV1Common::features
FeatureFlags features
Definition av1_common_int.h:919
AV1Common::show_frame
int show_frame
Definition av1_common_int.h:899
AV1Common::ref_frame_map
RefCntBuffer * ref_frame_map[REF_FRAMES]
Definition av1_common_int.h:892
AV1Common::tiles
CommonTileParams tiles
Definition av1_common_int.h:1006
AV1Common::height
int height
Definition av1_common_int.h:790
AV1Common::render_width
int render_width
Definition av1_common_int.h:800
AV1Common::render_height
int render_height
Definition av1_common_int.h:801
AV1EncAllIntraMultiThreadInfo
Encoder data related to multi-threading for allintra deltaq-mode=3.
Definition encoder.h:1615
AV1EncAllIntraMultiThreadInfo::mutex_
pthread_mutex_t * mutex_
Definition encoder.h:1620
AV1EncAllIntraMultiThreadInfo::intra_sync_read_ptr
void(* intra_sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int)
Definition encoder.h:1634
AV1EncAllIntraMultiThreadInfo::cond_
pthread_cond_t * cond_
Definition encoder.h:1624
AV1EncAllIntraMultiThreadInfo::intra_sync_write_ptr
void(* intra_sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int)
Definition encoder.h:1638
AV1EncRowMultiThreadInfo
Encoder data related to row-based multi-threading.
Definition encoder.h:1525
AV1EncRowMultiThreadInfo::allocated_sb_rows
int allocated_sb_rows
Definition encoder.h:1564
AV1EncRowMultiThreadInfo::mutex_
pthread_mutex_t * mutex_
Definition encoder.h:1590
AV1EncRowMultiThreadInfo::allocated_tile_cols
int allocated_tile_cols
Definition encoder.h:1533
AV1EncRowMultiThreadInfo::firstpass_mt_exit
bool firstpass_mt_exit
Definition encoder.h:1577
AV1EncRowMultiThreadInfo::allocated_cols
int allocated_cols
Definition encoder.h:1547
AV1EncRowMultiThreadInfo::thread_id_to_tile_id
int thread_id_to_tile_id[64]
Definition encoder.h:1552
AV1EncRowMultiThreadInfo::mb_wiener_mt_exit
bool mb_wiener_mt_exit
Definition encoder.h:1584
AV1EncRowMultiThreadInfo::sync_write_ptr
void(* sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int)
Definition encoder.h:1608
AV1EncRowMultiThreadInfo::cond_
pthread_cond_t * cond_
Definition encoder.h:1594
AV1EncRowMultiThreadInfo::row_mt_exit
bool row_mt_exit
Definition encoder.h:1570
AV1EncRowMultiThreadInfo::allocated_tile_rows
int allocated_tile_rows
Definition encoder.h:1529
AV1EncRowMultiThreadInfo::allocated_rows
int allocated_rows
Definition encoder.h:1540
AV1EncRowMultiThreadInfo::num_tile_cols_done
int * num_tile_cols_done
Definition encoder.h:1558
AV1EncRowMultiThreadInfo::sync_read_ptr
void(* sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int)
Definition encoder.h:1604
AV1EncRowMultiThreadSync
Encoder parameters for synchronization of row based multi-threading.
Definition encoder.h:1406
AV1EncRowMultiThreadSync::rows
int rows
Definition encoder.h:1439
AV1EncRowMultiThreadSync::sync_range
int sync_range
Definition encoder.h:1428
AV1EncRowMultiThreadSync::intrabc_extra_top_right_sb_delay
int intrabc_extra_top_right_sb_delay
Definition encoder.h:1435
AV1EncRowMultiThreadSync::next_mi_row
int next_mi_row
Definition encoder.h:1443
AV1EncRowMultiThreadSync::num_finished_cols
int * num_finished_cols
Definition encoder.h:1421
AV1EncRowMultiThreadSync::mutex_
pthread_mutex_t * mutex_
Definition encoder.h:1412
AV1EncRowMultiThreadSync::cond_
pthread_cond_t * cond_
Definition encoder.h:1413
AV1EncRowMultiThreadSync::num_threads_working
int num_threads_working
Definition encoder.h:1447
AV1EncoderConfig
Main encoder configuration data structure.
Definition encoder.h:943
AV1EncoderConfig::rc_cfg
RateControlCfg rc_cfg
Definition encoder.h:965
AV1EncoderConfig::kf_cfg
KeyFrameCfg kf_cfg
Definition encoder.h:960
AV1EncoderConfig::pass
enum aom_enc_pass pass
Definition encoder.h:1071
AV1EncoderConfig::algo_cfg
AlgoCfg algo_cfg
Definition encoder.h:955
AV1EncoderConfig::twopass_stats_in
aom_fixed_buf_t twopass_stats_in
Definition encoder.h:982
AV1LrPickStruct
Structure to hold search parameter per restoration unit and intermediate buffer of Wiener filter used...
Definition encoder.h:1704
AV1LrPickStruct::rusi
RestUnitSearchInfo * rusi[3]
Definition encoder.h:1709
AV1LrPickStruct::dgd_avg
int16_t * dgd_avg
Definition encoder.h:1714
AV1_COMP_DATA
Structure to hold data corresponding to an encoded frame.
Definition encoder.h:2546
AV1_COMP_DATA::ts_frame_end
int64_t ts_frame_end
Definition encoder.h:2575
AV1_COMP_DATA::pop_lookahead
int pop_lookahead
Definition encoder.h:2590
AV1_COMP_DATA::ts_frame_start
int64_t ts_frame_start
Definition encoder.h:2570
AV1_COMP_DATA::cx_data
unsigned char * cx_data
Definition encoder.h:2550
AV1_COMP_DATA::cx_data_sz
size_t cx_data_sz
Definition encoder.h:2555
AV1_COMP_DATA::flush
int flush
Definition encoder.h:2580
AV1_COMP_DATA::lib_flags
unsigned int lib_flags
Definition encoder.h:2565
AV1_COMP_DATA::frame_size
size_t frame_size
Definition encoder.h:2560
AV1_COMP_DATA::timestamp_ratio
const aom_rational64_t * timestamp_ratio
Definition encoder.h:2585
AV1_COMP
Top level encoder structure.
Definition encoder.h:2896
AV1_COMP::ext_rate_distribution
double * ext_rate_distribution
Definition encoder.h:3573
AV1_COMP::do_update_frame_probs_warp
int do_update_frame_probs_warp[10]
Definition encoder.h:3282
AV1_COMP::consec_zero_mv
uint8_t * consec_zero_mv
Definition encoder.h:3483
AV1_COMP::do_update_frame_probs_obmc
int do_update_frame_probs_obmc[10]
Definition encoder.h:3277
AV1_COMP::denoise_and_model
struct aom_denoise_and_model_t * denoise_and_model
Definition encoder.h:3350
AV1_COMP::skip_tpl_setup_stats
int skip_tpl_setup_stats
Definition encoder.h:3004
AV1_COMP::frames_since_last_update
int frames_since_last_update
Definition encoder.h:3659
AV1_COMP::mb_delta_q
int * mb_delta_q
Definition encoder.h:3593
AV1_COMP::vaq_refresh
int vaq_refresh
Definition encoder.h:3252
AV1_COMP::last_frame_type
FRAME_TYPE last_frame_type
Definition encoder.h:3448
AV1_COMP::unscaled_source
YV12_BUFFER_CONFIG * unscaled_source
Definition encoder.h:2972
AV1_COMP::palette_pixel_num
int palette_pixel_num
Definition encoder.h:3688
AV1_COMP::cyclic_refresh
CYCLIC_REFRESH * cyclic_refresh
Definition encoder.h:3144
AV1_COMP::rc
RATE_CONTROL rc
Definition encoder.h:3103
AV1_COMP::deltaq_used
int deltaq_used
Definition encoder.h:3406
AV1_COMP::active_map
ActiveMap active_map
Definition encoder.h:3149
AV1_COMP::frame_size_related_setup_done
bool frame_size_related_setup_done
Definition encoder.h:3215
AV1_COMP::mb_weber_stats
WeberStats * mb_weber_stats
Definition encoder.h:3561
AV1_COMP::refresh_idx_available
bool refresh_idx_available
Definition encoder.h:3526
AV1_COMP::token_info
TokenInfo token_info
Definition encoder.h:3247
AV1_COMP::ambient_err
int64_t ambient_err
Definition encoder.h:3072
AV1_COMP::film_grain_table
aom_film_grain_table_t * film_grain_table
Definition encoder.h:3343
AV1_COMP::ref_refresh_index
int ref_refresh_index
Definition encoder.h:3520
AV1_COMP::available_bs_size
size_t available_bs_size
Definition encoder.h:3504
AV1_COMP::sf
SPEED_FEATURES sf
Definition encoder.h:3123
AV1_COMP::optimize_seg_arr
TRELLIS_OPT_TYPE optimize_seg_arr[8]
Definition encoder.h:2950
AV1_COMP::ext_part_controller
ExtPartController ext_part_controller
Definition encoder.h:3510
AV1_COMP::second_pass_log_stream
FILE * second_pass_log_stream
Definition encoder.h:3629
AV1_COMP::ssim_rdmult_scaling_factors
double * ssim_rdmult_scaling_factors
Definition encoder.h:3418
AV1_COMP::rd
RD_OPT rd
Definition encoder.h:3077
AV1_COMP::data_alloc_height
int data_alloc_height
Definition encoder.h:3201
AV1_COMP::num_tg
int num_tg
Definition encoder.h:3453
AV1_COMP::winner_mode_params
WinnerModeParams winner_mode_params
Definition encoder.h:3093
AV1_COMP::ext_flags
ExternalFlags ext_flags
Definition encoder.h:3055
AV1_COMP::alloc_pyramid
bool alloc_pyramid
Definition encoder.h:3670
AV1_COMP::enc_seg
EncSegmentationInfo enc_seg
Definition encoder.h:3139
AV1_COMP::mv_search_params
MotionVectorSearchParams mv_search_params
Definition encoder.h:3128
AV1_COMP::use_screen_content_tools
int use_screen_content_tools
Definition encoder.h:3365
AV1_COMP::do_update_frame_probs_interpfilter
int do_update_frame_probs_interpfilter[10]
Definition encoder.h:3287
AV1_COMP::coding_context
CODING_CONTEXT coding_context
Definition encoder.h:3083
AV1_COMP::tf_ctx
TemporalFilterCtx tf_ctx
Definition encoder.h:3019
AV1_COMP::force_intpel_info
ForceIntegerMVInfo force_intpel_info
Definition encoder.h:3029
AV1_COMP::gm_info
GlobalMotionInfo gm_info
Definition encoder.h:3088
AV1_COMP::consec_zero_mv_alloc_size
int consec_zero_mv_alloc_size
Definition encoder.h:3488
AV1_COMP::coeff_buffer_pool
CoeffBufferPool coeff_buffer_pool
Definition encoder.h:2934
AV1_COMP::frame_index_set
FRAME_INDEX_SET frame_index_set
Definition encoder.h:3187
AV1_COMP::ref_frame_flags
int ref_frame_flags
Definition encoder.h:3113
AV1_COMP::scaled_ref_buf
RefCntBuffer * scaled_ref_buf[INTER_REFS_PER_FRAME]
Definition encoder.h:3035
AV1_COMP::gf_frame_index
unsigned char gf_frame_index
Definition encoder.h:3154
AV1_COMP::oxcf
AV1EncoderConfig oxcf
Definition encoder.h:2944
AV1_COMP::common
AV1_COMMON common
Definition encoder.h:2939
AV1_COMP::lr_ctxt
AV1LrStruct lr_ctxt
Definition encoder.h:3333
AV1_COMP::do_frame_data_update
bool do_frame_data_update
Definition encoder.h:3549
AV1_COMP::cdef_search_ctx
CdefSearchCtx * cdef_search_ctx
Definition encoder.h:3024
AV1_COMP::data_alloc_width
int data_alloc_width
Definition encoder.h:3194
AV1_COMP::do_update_frame_probs_txtype
int do_update_frame_probs_txtype[10]
Definition encoder.h:3272
AV1_COMP::counts
FRAME_COUNTS counts
Definition encoder.h:2916
AV1_COMP::compressor_stage
COMPRESSOR_STAGE compressor_stage
Definition encoder.h:3442
AV1_COMP::intrabc_used
int intrabc_used
Definition encoder.h:3323
AV1_COMP::num_frame_recode
int num_frame_recode
Definition encoder.h:3262
AV1_COMP::rt_reduce_num_ref_buffers
int rt_reduce_num_ref_buffers
Definition encoder.h:3050
AV1_COMP::refresh_frame
RefreshFrameInfo refresh_frame
Definition encoder.h:3045
AV1_COMP::prune_ref_frame_mask
int prune_ref_frame_mask
Definition encoder.h:3328
AV1_COMP::unscaled_last_source
YV12_BUFFER_CONFIG * unscaled_last_source
Definition encoder.h:2982
AV1_COMP::all_one_sided_refs
int all_one_sided_refs
Definition encoder.h:3134
AV1_COMP::mt_info
MultiThreadInfo mt_info
Definition encoder.h:3311
AV1_COMP::vbp_info
VarBasedPartitionInfo vbp_info
Definition encoder.h:3257
AV1_COMP::scaled_last_source_available
int scaled_last_source_available
Definition encoder.h:3694
AV1_COMP::last_source
YV12_BUFFER_CONFIG * last_source
Definition encoder.h:2966
AV1_COMP::existing_fb_idx_to_show
int existing_fb_idx_to_show
Definition encoder.h:3318
AV1_COMP::unfiltered_source
YV12_BUFFER_CONFIG * unfiltered_source
Definition encoder.h:2993
AV1_COMP::zeromv_skip_thresh_exit_part
unsigned int zeromv_skip_thresh_exit_part[BLOCK_SIZES_ALL]
Definition encoder.h:3664
AV1_COMP::frame_info
FRAME_INFO frame_info
Definition encoder.h:3182
AV1_COMP::last_coded_height
int last_coded_height
Definition encoder.h:3227
AV1_COMP::frame_header_count
int frame_header_count
Definition encoder.h:3401
AV1_COMP::droppable
int droppable
Definition encoder.h:3177
AV1_COMP::last_show_frame_buf
RefCntBuffer * last_show_frame_buf
Definition encoder.h:3040
AV1_COMP::superres_mode
aom_superres_mode superres_mode
Definition encoder.h:3460
AV1_COMP::mbmi_ext_info
MBMIExtFrameBufferInfo mbmi_ext_info
Definition encoder.h:2921
AV1_COMP::pick_lr_ctxt
AV1LrPickStruct pick_lr_ctxt
Definition encoder.h:3338
AV1_COMP::new_framerate
double new_framerate
Definition encoder.h:3301
AV1_COMP::ppi
AV1_PRIMARY * ppi
Definition encoder.h:2900
AV1_COMP::src_sad_blk_64x64
uint64_t * src_sad_blk_64x64
Definition encoder.h:3634
AV1_COMP::norm_wiener_variance
int64_t norm_wiener_variance
Definition encoder.h:3588
AV1_COMP::tpl_rdmult_scaling_factors
double * tpl_rdmult_scaling_factors
Definition encoder.h:3014
AV1_COMP::sb_counter
int sb_counter
Definition encoder.h:3499
AV1_COMP::last_coded_width
int last_coded_width
Definition encoder.h:3221
AV1_COMP::tile_data
TileDataEnc * tile_data
Definition encoder.h:3238
AV1_COMP::is_screen_content_type
int is_screen_content_type
Definition encoder.h:3373
AV1_COMP::weber_bsize
BLOCK_SIZE weber_bsize
Definition encoder.h:3583
AV1_COMP::interp_search_flags
InterpSearchFlags interp_search_flags
Definition encoder.h:3356
AV1_COMP::time_stamps
TimeStamps time_stamps
Definition encoder.h:3098
AV1_COMP::roi
aom_roi_map_t roi
Definition encoder.h:3699
AV1_COMP::ref_idx_to_skip
int ref_idx_to_skip
Definition encoder.h:3533
AV1_COMP::orig_source
YV12_BUFFER_CONFIG orig_source
Definition encoder.h:2999
AV1_COMP::firstpass_data
FirstPassData firstpass_data
Definition encoder.h:3465
AV1_COMP::framerate
double framerate
Definition encoder.h:3108
AV1_COMP::speed
int speed
Definition encoder.h:3118
AV1_COMP::fp_block_size
BLOCK_SIZE fp_block_size
Definition encoder.h:3493
AV1_COMP::use_ducky_encode
int use_ducky_encode
Definition encoder.h:3647
AV1_COMP::trial_frame_rst
YV12_BUFFER_CONFIG trial_frame_rst
Definition encoder.h:3067
AV1_COMP::is_dropped_frame
bool is_dropped_frame
Definition encoder.h:3598
AV1_COMP::td
ThreadData td
Definition encoder.h:2911
AV1_COMP::resize_pending_params
ResizePendingParams resize_pending_params
Definition encoder.h:3232
AV1_COMP::scaled_source
YV12_BUFFER_CONFIG scaled_source
Definition encoder.h:2977
AV1_COMP::do_update_vbr_bits_off_target_fast
int do_update_vbr_bits_off_target_fast
Definition encoder.h:3306
AV1_COMP::last_frame_uf
YV12_BUFFER_CONFIG last_frame_uf
Definition encoder.h:3061
AV1_COMP::enc_quant_dequant_params
EncQuantDequantParams enc_quant_dequant_params
Definition encoder.h:2906
AV1_COMP::ref_frame_dist_info
RefFrameDistanceInfo ref_frame_dist_info
Definition encoder.h:3411
AV1_COMP::prep_rate_estimates
int * prep_rate_estimates
Definition encoder.h:3567
AV1_COMP::ducky_encode_info
DuckyEncodeInfo ducky_encode_info
Definition encoder.h:3653
AV1_COMP::ext_rate_scale
double ext_rate_scale
Definition encoder.h:3578
AV1_COMP::initial_mbs
int initial_mbs
Definition encoder.h:3209
AV1_COMP::rec_sse
uint64_t rec_sse
Definition encoder.h:3641
AV1_COMP::scaled_last_source
YV12_BUFFER_CONFIG scaled_last_source
Definition encoder.h:2987
AV1_COMP::mv_stats
MV_STATS mv_stats
Definition encoder.h:3516
AV1_COMP::frame_new_probs
FrameProbInfo frame_new_probs[10]
Definition encoder.h:3267
AV1_COMP::source
YV12_BUFFER_CONFIG * source
Definition encoder.h:2957
AV1_COMP::allocated_tiles
int allocated_tiles
Definition encoder.h:3242
AV1_COMP::svc
SVC svc
Definition encoder.h:3437
AV1_COMP::coeff_buffer_base
CB_COEFF_BUFFER * coeff_buffer_base
Definition encoder.h:2928
AV1_COMP::noise_estimate
NOISE_ESTIMATE noise_estimate
Definition encoder.h:3470
AV1_COMP::twopass_frame
TWO_PASS_FRAME twopass_frame
Definition encoder.h:3617
AV1_PRIMARY
Top level primary encoder structure.
Definition encoder.h:2596
AV1_PRIMARY::num_fp_contexts
int num_fp_contexts
Definition encoder.h:2653
AV1_PRIMARY::intra_row_mt_sync
AV1EncRowMultiThreadSync intra_row_mt_sync
Definition encoder.h:2890
AV1_PRIMARY::buffer_removal_time_present
bool buffer_removal_time_present
Definition encoder.h:2771
AV1_PRIMARY::valid_gm_model_found
int valid_gm_model_found[FRAME_UPDATE_TYPES]
Definition encoder.h:2879
AV1_PRIMARY::output_pkt_list
struct aom_codec_pkt_list * output_pkt_list
Definition encoder.h:2701
AV1_PRIMARY::filter_level
int filter_level[2]
Definition encoder.h:2658
AV1_PRIMARY::seq_params
SequenceHeader seq_params
Definition encoder.h:2761
AV1_PRIMARY::mv_stats
MV_STATS mv_stats
Definition encoder.h:2809
AV1_PRIMARY::cpi
struct AV1_COMP * cpi
Definition encoder.h:2674
AV1_PRIMARY::level_params
AV1LevelParams level_params
Definition encoder.h:2731
AV1_PRIMARY::internal_altref_allowed
int internal_altref_allowed
Definition encoder.h:2706
AV1_PRIMARY::rtc_ref
RTC_REF rtc_ref
Definition encoder.h:2884
AV1_PRIMARY::b_calculate_psnr
int b_calculate_psnr
Definition encoder.h:2736
AV1_PRIMARY::p_mt_info
PrimaryMultiThreadInfo p_mt_info
Definition encoder.h:2866
AV1_PRIMARY::tf_info
TEMPORAL_FILTER_INFO tf_info
Definition encoder.h:2756
AV1_PRIMARY::twopass
TWO_PASS twopass
Definition encoder.h:2746
AV1_PRIMARY::frames_left
int frames_left
Definition encoder.h:2741
AV1_PRIMARY::ts_start_last_show_frame
int64_t ts_start_last_show_frame
Definition encoder.h:2643
AV1_PRIMARY::p_rc
PRIMARY_RATE_CONTROL p_rc
Definition encoder.h:2751
AV1_PRIMARY::lap_enabled
int lap_enabled
Definition encoder.h:2726
AV1_PRIMARY::frame_probs
FrameProbInfo frame_probs
Definition encoder.h:2871
AV1_PRIMARY::show_existing_alt_ref
int show_existing_alt_ref
Definition encoder.h:2711
AV1_PRIMARY::fb_of_context_type
int fb_of_context_type[REF_FRAMES]
Definition encoder.h:2861
AV1_PRIMARY::use_svc
int use_svc
Definition encoder.h:2766
AV1_PRIMARY::tpl_sb_rdmult_scaling_factors
double * tpl_sb_rdmult_scaling_factors
Definition encoder.h:2799
AV1_PRIMARY::filter_level_v
int filter_level_v
Definition encoder.h:2668
AV1_PRIMARY::filter_level_u
int filter_level_u
Definition encoder.h:2663
AV1_PRIMARY::cpi_lap
struct AV1_COMP * cpi_lap
Definition encoder.h:2679
AV1_PRIMARY::parallel_cpi
struct AV1_COMP * parallel_cpi[4]
Definition encoder.h:2600
AV1_PRIMARY::ts_end_last_show_frame
int64_t ts_end_last_show_frame
Definition encoder.h:2648
AV1_PRIMARY::lookahead
struct lookahead_ctx * lookahead
Definition encoder.h:2684
AV1_PRIMARY::ref_frame_map_copy
RefCntBuffer * ref_frame_map_copy[REF_FRAMES]
Definition encoder.h:2638
AV1_PRIMARY::gf_state
GF_STATE gf_state
Definition encoder.h:2721
AV1_PRIMARY::fn_ptr
aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL]
Definition encoder.h:2793
AV1_PRIMARY::gf_group
GF_GROUP gf_group
Definition encoder.h:2716
AV1_PRIMARY::parallel_frames_data
struct AV1_COMP_DATA parallel_frames_data[4 - 1]
Definition encoder.h:2606
AV1_PRIMARY::tpl_data
TplParams tpl_data
Definition encoder.h:2804
AV1_PRIMARY::number_temporal_layers
unsigned int number_temporal_layers
Definition encoder.h:2776
AV1_PRIMARY::number_spatial_layers
unsigned int number_spatial_layers
Definition encoder.h:2781
AV1_PRIMARY::seq_params_locked
int seq_params_locked
Definition encoder.h:2695
AV1_PRIMARY::error
struct aom_internal_error_info error
Definition encoder.h:2786
AlgoCfg
Algorithm configuration parameters.
Definition encoder.h:821
AlgoCfg::disable_trellis_quant
int disable_trellis_quant
Definition encoder.h:848
AlgoCfg::sharpness
int sharpness
Definition encoder.h:834
AlgoCfg::skip_postproc_filtering
bool skip_postproc_filtering
Definition encoder.h:892
AlgoCfg::enable_adaptive_sharpness
bool enable_adaptive_sharpness
Definition encoder.h:839
AlgoCfg::arnr_max_frames
int arnr_max_frames
Definition encoder.h:853
AlgoCfg::screen_detection_mode
aom_screen_detection_mode screen_detection_mode
Definition encoder.h:897
AlgoCfg::enable_tpl_model
bool enable_tpl_model
Definition encoder.h:871
AlgoCfg::loopfilter_control
LOOPFILTER_CONTROL loopfilter_control
Definition encoder.h:886
AlgoCfg::cdf_update_mode
uint8_t cdf_update_mode
Definition encoder.h:866
AlgoCfg::enable_overlay
bool enable_overlay
Definition encoder.h:877
AlgoCfg::arnr_strength
int arnr_strength
Definition encoder.h:858
CB_COEFF_BUFFER
Stores the transforms coefficients for the whole superblock.
Definition block.h:206
CYCLIC_REFRESH
The stucture of CYCLIC_REFRESH.
Definition aq_cyclicrefresh.h:36
CdefInfo
Parameters related to CDEF.
Definition av1_common_int.h:202
CdefInfo::cdef_bits
int cdef_bits
Number of CDEF strength values in bits.
Definition av1_common_int.h:224
CdefInfo::cdef_uv_strengths
int cdef_uv_strengths[16]
CDEF strength values for chroma.
Definition av1_common_int.h:222
CdefInfo::cdef_strengths
int cdef_strengths[16]
CDEF strength values for luma.
Definition av1_common_int.h:220
CdefInfo::nb_cdef_strengths
int nb_cdef_strengths
Number of CDEF strength values.
Definition av1_common_int.h:218
CoeffBufferPool
Definition encoder.h:2452
CoeffBufferPool::entropy_ctx
uint8_t * entropy_ctx
Definition encoder.h:2464
CoeffBufferPool::tcoeff
tran_low_t * tcoeff
Definition encoder.h:2456
CoeffBufferPool::eobs
uint16_t * eobs
Definition encoder.h:2460
CommonModeInfoParams
Params related to MB_MODE_INFO arrays and related info.
Definition av1_common_int.h:510
CommonModeInfoParams::mi_alloc_bsize
BLOCK_SIZE mi_alloc_bsize
Definition av1_common_int.h:559
CommonTileParams::cols
int cols
Definition av1_common_int.h:437
CommonTileParams::large_scale
unsigned int large_scale
Definition av1_common_int.h:497
CompoundTypeCfg
Encoder flags for compound prediction modes.
Definition encoder.h:400
CompoundTypeCfg::enable_masked_comp
bool enable_masked_comp
Definition encoder.h:409
CompoundTypeCfg::enable_diff_wtd_comp
bool enable_diff_wtd_comp
Definition encoder.h:417
CompoundTypeCfg::enable_smooth_interintra
bool enable_smooth_interintra
Definition encoder.h:413
CompoundTypeCfg::enable_interintra_wedge
bool enable_interintra_wedge
Definition encoder.h:425
CompoundTypeCfg::enable_interinter_wedge
bool enable_interinter_wedge
Definition encoder.h:421
CompoundTypeCfg::enable_dist_wtd_comp
bool enable_dist_wtd_comp
Definition encoder.h:404
EncSegmentationInfo
Segmentation related information for the current frame.
Definition encoder.h:2415
EncSegmentationInfo::map
uint8_t * map
Definition encoder.h:2421
EncSegmentationInfo::has_lossless_segment
bool has_lossless_segment
Definition encoder.h:2427
EncodeFrameInput
Input frames and last input frame.
Definition encoder.h:3705
EncodeFrameParams
contains per-frame encoding parameters decided upon by av1_encode_strategy() and passed down to av1_e...
Definition encoder.h:3717
EncodeFrameParams::error_resilient_mode
int error_resilient_mode
Definition encoder.h:3721
EncodeFrameParams::remapped_ref_idx
int remapped_ref_idx[REF_FRAMES]
Definition encoder.h:3752
EncodeFrameParams::ref_frame_flags
int ref_frame_flags
Definition encoder.h:3747
EncodeFrameParams::speed
int speed
Definition encoder.h:3763
EncodeFrameParams::frame_type
FRAME_TYPE frame_type
Definition encoder.h:3725
EncodeFrameParams::show_frame
int show_frame
Definition encoder.h:3735
EncodeFrameParams::refresh_frame
RefreshFrameInfo refresh_frame
Definition encoder.h:3758
ExtRefreshFrameFlagsInfo
Frame refresh flags set by the external interface.
Definition encoder.h:2282
ExtRefreshFrameFlagsInfo::golden_frame
bool golden_frame
Definition encoder.h:2284
ExtRefreshFrameFlagsInfo::bwd_ref_frame
bool bwd_ref_frame
Definition encoder.h:2285
ExtRefreshFrameFlagsInfo::update_pending
bool update_pending
Definition encoder.h:2291
ExtRefreshFrameFlagsInfo::last_frame
bool last_frame
Definition encoder.h:2283
ExtRefreshFrameFlagsInfo::alt_ref_frame
bool alt_ref_frame
Definition encoder.h:2287
ExtRefreshFrameFlagsInfo::alt2_ref_frame
bool alt2_ref_frame
Definition encoder.h:2286
ExternalFlags
Flags signalled by the external interface at frame level.
Definition encoder.h:2297
ExternalFlags::use_primary_ref_none
bool use_primary_ref_none
Definition encoder.h:2338
ExternalFlags::use_ref_frame_mvs
bool use_ref_frame_mvs
Definition encoder.h:2322
ExternalFlags::refresh_frame
ExtRefreshFrameFlagsInfo refresh_frame
Definition encoder.h:2306
ExternalFlags::ref_frame_flags
int ref_frame_flags
Definition encoder.h:2301
ExternalFlags::use_error_resilient
bool use_error_resilient
Definition encoder.h:2327
ExternalFlags::use_s_frame
bool use_s_frame
Definition encoder.h:2332
ExternalFlags::refresh_frame_context
bool refresh_frame_context
Definition encoder.h:2311
ExternalFlags::refresh_frame_context_pending
bool refresh_frame_context_pending
Definition encoder.h:2317
FeatureFlags
Frame level features.
Definition av1_common_int.h:367
FeatureFlags::allow_screen_content_tools
bool allow_screen_content_tools
Definition av1_common_int.h:384
FeatureFlags::allow_intrabc
bool allow_intrabc
Definition av1_common_int.h:385
FeatureFlags::coded_lossless
bool coded_lossless
Definition av1_common_int.h:394
FeatureFlags::error_resilient_mode
bool error_resilient_mode
Definition av1_common_int.h:409
FeatureFlags::all_lossless
bool all_lossless
Definition av1_common_int.h:398
ForceIntegerMVInfo
Encoder info used for decision on forcing integer motion vectors.
Definition encoder.h:1876
ForceIntegerMVInfo::cs_rate_array
double cs_rate_array[32]
Definition encoder.h:1881
ForceIntegerMVInfo::rate_size
int rate_size
Definition encoder.h:1889
ForceIntegerMVInfo::rate_index
int rate_index
Definition encoder.h:1885
FrameProbInfo
Encoder-side probabilities for pruning of various AV1 tools.
Definition encoder.h:1134
FrameProbInfo::switchable_interp_probs
int switchable_interp_probs[FRAME_UPDATE_TYPES][((SWITCHABLE_FILTERS+1) *4)][SWITCHABLE_FILTERS]
Definition encoder.h:1164
FrameProbInfo::obmc_probs
int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL]
Definition encoder.h:1140
FrameProbInfo::warped_probs
int warped_probs[FRAME_UPDATE_TYPES]
Definition encoder.h:1147
FrameProbInfo::tx_type_probs
int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES]
Definition encoder.h:1155
GF_GROUP
Data related to the current GF/ARF group and the individual frames within the group.
Definition firstpass.h:339
GlobalMotionInfo
Parameters related to global motion search.
Definition encoder.h:2085
GlobalMotionInfo::reference_frames
FrameDistPair reference_frames[2][REF_FRAMES - 1]
Definition encoder.h:2111
GlobalMotionInfo::search_done
bool search_done
Definition encoder.h:2089
GlobalMotionInfo::segment_map_h
int segment_map_h
Definition encoder.h:2118
GlobalMotionInfo::num_ref_frames
int num_ref_frames[2]
Definition encoder.h:2103
GlobalMotionInfo::ref_buf
YV12_BUFFER_CONFIG * ref_buf[REF_FRAMES]
Definition encoder.h:2096
GlobalMotionInfo::segment_map_w
int segment_map_w
Definition encoder.h:2117
InterpSearchFlags
Flags related to interpolation filter search.
Definition encoder.h:2125
InterpSearchFlags::default_interp_skip_flags
int default_interp_skip_flags
Definition encoder.h:2130
InterpSearchFlags::interp_filter_search_mask
uint16_t interp_filter_search_mask
Definition encoder.h:2134
IntraModeCfg
Encoder flags for intra prediction.
Definition encoder.h:303
IntraModeCfg::enable_diagonal_intra
bool enable_diagonal_intra
Definition encoder.h:333
IntraModeCfg::enable_smooth_intra
bool enable_smooth_intra
Definition encoder.h:316
IntraModeCfg::auto_intra_tools_off
bool auto_intra_tools_off
Definition encoder.h:352
IntraModeCfg::enable_filter_intra
bool enable_filter_intra
Definition encoder.h:312
IntraModeCfg::enable_directional_intra
bool enable_directional_intra
Definition encoder.h:328
IntraModeCfg::enable_paeth_intra
bool enable_paeth_intra
Definition encoder.h:320
IntraModeCfg::enable_intra_edge_filter
bool enable_intra_edge_filter
Definition encoder.h:307
IntraModeCfg::enable_cfl_intra
bool enable_cfl_intra
Definition encoder.h:324
IntraModeCfg::enable_angle_delta
bool enable_angle_delta
Definition encoder.h:338
KeyFrameCfg
Encoder config related to the coding of key frames.
Definition encoder.h:467
KeyFrameCfg::key_freq_max
int key_freq_max
Definition encoder.h:476
KeyFrameCfg::sframe_mode
int sframe_mode
Definition encoder.h:494
KeyFrameCfg::auto_key
bool auto_key
Definition encoder.h:499
KeyFrameCfg::enable_intrabc
bool enable_intrabc
Definition encoder.h:519
KeyFrameCfg::sframe_dist
int sframe_dist
Definition encoder.h:487
KeyFrameCfg::enable_sframe
bool enable_sframe
Definition encoder.h:514
KeyFrameCfg::enable_keyframe_filtering
int enable_keyframe_filtering
Definition encoder.h:481
KeyFrameCfg::fwd_kf_dist
int fwd_kf_dist
Definition encoder.h:504
KeyFrameCfg::key_freq_min
int key_freq_min
Definition encoder.h:471
KeyFrameCfg::fwd_kf_enabled
bool fwd_kf_enabled
Definition encoder.h:509
MBMIExtFrameBufferInfo
Buffer to store mode information at mi_alloc_bsize (4x4 or 8x8) level.
Definition encoder.h:1922
MBMIExtFrameBufferInfo::alloc_size
int alloc_size
Definition encoder.h:1931
MBMIExtFrameBufferInfo::stride
int stride
Definition encoder.h:1935
MBMIExtFrameBufferInfo::frame_base
MB_MODE_INFO_EXT_FRAME * frame_base
Definition encoder.h:1927
MB_MODE_INFO_EXT_FRAME
Stores best extended mode information at frame level.
Definition block.h:242
MB_MODE_INFO
Stores the prediction/txfm mode of the current coding block.
Definition blockd.h:222
MotionVectorSearchParams
Parameters for motion vector search process.
Definition encoder.h:2140
MotionVectorSearchParams::max_mv_magnitude
int max_mv_magnitude
Definition encoder.h:2146
MotionVectorSearchParams::find_fractional_mv_step
fractional_mv_step_fp * find_fractional_mv_step
Definition encoder.h:2160
MotionVectorSearchParams::mv_step_param
int mv_step_param
Definition encoder.h:2151
MotionVectorSearchParams::search_site_cfg
search_site_config search_site_cfg[SS_CFG_TOTAL][NUM_DISTINCT_SEARCH_METHODS]
Definition encoder.h:2167
MultiThreadInfo
Encoder parameters related to multi-threading.
Definition encoder.h:1767
MultiThreadInfo::restore_state_buf
RestoreStateBuffers restore_state_buf
Definition encoder.h:1854
MultiThreadInfo::cdef_worker
AV1CdefWorkerData * cdef_worker
Definition encoder.h:1849
MultiThreadInfo::lr_row_sync
AV1LrSync lr_row_sync
Definition encoder.h:1824
MultiThreadInfo::tile_thr_data
struct EncWorkerData * tile_thr_data
Definition encoder.h:1787
MultiThreadInfo::tpl_row_mt
AV1TplRowMultiThreadInfo tpl_row_mt
Definition encoder.h:1814
MultiThreadInfo::pack_bs_sync
AV1EncPackBSSync pack_bs_sync
Definition encoder.h:1829
MultiThreadInfo::enc_row_mt
AV1EncRowMultiThreadInfo enc_row_mt
Definition encoder.h:1803
MultiThreadInfo::lf_row_sync
AV1LfSync lf_row_sync
Definition encoder.h:1819
MultiThreadInfo::cdef_sync
AV1CdefSync cdef_sync
Definition encoder.h:1844
MultiThreadInfo::num_mod_workers
int num_mod_workers[NUM_MT_MODULES]
Definition encoder.h:1776
MultiThreadInfo::intra_mt
AV1EncAllIntraMultiThreadInfo intra_mt
Definition encoder.h:1809
MultiThreadInfo::num_workers
int num_workers
Definition encoder.h:1771
MultiThreadInfo::pipeline_lpf_mt_with_enc
int pipeline_lpf_mt_with_enc
Definition encoder.h:1860
MultiThreadInfo::workers
AVxWorker * workers
Definition encoder.h:1781
MultiThreadInfo::pack_bs_mt_enabled
bool pack_bs_mt_enabled
Definition encoder.h:1798
MultiThreadInfo::row_mt_enabled
bool row_mt_enabled
Definition encoder.h:1793
MultiThreadInfo::tf_sync
AV1TemporalFilterSync tf_sync
Definition encoder.h:1839
MultiThreadInfo::gm_sync
AV1GlobalMotionSync gm_sync
Definition encoder.h:1834
PRIMARY_RATE_CONTROL
Primary Rate Control parameters and status.
Definition ratectrl.h:302
PartitionCfg
Encoder config for coding block partitioning.
Definition encoder.h:275
PartitionCfg::enable_rect_partitions
bool enable_rect_partitions
Definition encoder.h:279
PartitionCfg::enable_1to4_partitions
bool enable_1to4_partitions
Definition encoder.h:287
PartitionCfg::max_partition_size
BLOCK_SIZE max_partition_size
Definition encoder.h:297
PartitionCfg::enable_ab_partitions
bool enable_ab_partitions
Definition encoder.h:283
PartitionCfg::min_partition_size
BLOCK_SIZE min_partition_size
Definition encoder.h:292
PrimaryMultiThreadInfo
Primary Encoder parameters related to multi-threading.
Definition encoder.h:1720
PrimaryMultiThreadInfo::tile_thr_data
struct EncWorkerData * tile_thr_data
Definition encoder.h:1740
PrimaryMultiThreadInfo::cdef_worker
AV1CdefWorkerData * cdef_worker
Definition encoder.h:1745
PrimaryMultiThreadInfo::num_workers
int num_workers
Definition encoder.h:1724
PrimaryMultiThreadInfo::prev_num_enc_workers
int prev_num_enc_workers
Definition encoder.h:1761
PrimaryMultiThreadInfo::workers
AVxWorker * workers
Definition encoder.h:1734
PrimaryMultiThreadInfo::p_workers
AVxWorker * p_workers[4]
Definition encoder.h:1751
PrimaryMultiThreadInfo::p_num_workers
int p_num_workers
Definition encoder.h:1756
PrimaryMultiThreadInfo::num_mod_workers
int num_mod_workers[NUM_MT_MODULES]
Definition encoder.h:1729
RATE_CONTROL
Rate Control parameters and status.
Definition ratectrl.h:134
RateControlCfg
Encoder rate control configuration parameters.
Definition encoder.h:525
RateControlCfg::worst_allowed_q
int worst_allowed_q
Definition encoder.h:595
RateControlCfg::over_shoot_pct
int over_shoot_pct
Definition encoder.h:590
RateControlCfg::max_intra_bitrate_pct
unsigned int max_intra_bitrate_pct
Definition encoder.h:560
RateControlCfg::drop_frames_water_mark
int drop_frames_water_mark
Definition encoder.h:578
RateControlCfg::max_consec_drop_ms
int max_consec_drop_ms
Definition encoder.h:633
RateControlCfg::vbrmax_section
int vbrmax_section
Definition encoder.h:626
RateControlCfg::maximum_buffer_size_ms
int64_t maximum_buffer_size_ms
Definition encoder.h:544
RateControlCfg::vbr_corpus_complexity_lap
unsigned int vbr_corpus_complexity_lap
Definition encoder.h:555
RateControlCfg::min_cr
unsigned int min_cr
Definition encoder.h:574
RateControlCfg::vbrbias
int vbrbias
Definition encoder.h:616
RateControlCfg::gf_cbr_boost_pct
unsigned int gf_cbr_boost_pct
Definition encoder.h:569
RateControlCfg::vbrmin_section
int vbrmin_section
Definition encoder.h:621
RateControlCfg::mode
enum aom_rc_mode mode
Definition encoder.h:609
RateControlCfg::max_inter_bitrate_pct
unsigned int max_inter_bitrate_pct
Definition encoder.h:565
RateControlCfg::starting_buffer_level_ms
int64_t starting_buffer_level_ms
Definition encoder.h:534
RateControlCfg::best_allowed_q
int best_allowed_q
Definition encoder.h:600
RateControlCfg::under_shoot_pct
int under_shoot_pct
Definition encoder.h:584
RateControlCfg::target_bandwidth
int64_t target_bandwidth
Definition encoder.h:549
RateControlCfg::optimal_buffer_level_ms
int64_t optimal_buffer_level_ms
Definition encoder.h:539
RateControlCfg::cq_level
int cq_level
Definition encoder.h:604
RefFrameDistanceInfo
Refrence frame distance related variables.
Definition encoder.h:2199
RefFrameDistanceInfo::nearest_past_ref
int8_t nearest_past_ref
Definition encoder.h:2207
RefFrameDistanceInfo::ref_relative_dist
int ref_relative_dist[INTER_REFS_PER_FRAME]
Definition encoder.h:2203
RefFrameDistanceInfo::nearest_future_ref
int8_t nearest_future_ref
Definition encoder.h:2211
RefreshFrameInfo
Refresh frame flags for different type of frames.
Definition encoder.h:2178
RefreshFrameInfo::bwd_ref_frame
bool bwd_ref_frame
Definition encoder.h:2180
RefreshFrameInfo::golden_frame
bool golden_frame
Definition encoder.h:2179
RefreshFrameInfo::alt_ref_frame
bool alt_ref_frame
Definition encoder.h:2181
ResizeCfg
Encoder config related to resize.
Definition encoder.h:255
ResizeCfg::resize_scale_denominator
uint8_t resize_scale_denominator
Definition encoder.h:264
ResizeCfg::resize_kf_scale_denominator
uint8_t resize_kf_scale_denominator
Definition encoder.h:269
ResizeCfg::resize_mode
RESIZE_MODE resize_mode
Definition encoder.h:259
ResizePendingParams
Desired dimensions for an externally triggered resize.
Definition encoder.h:2191
ResizePendingParams::width
int width
Definition encoder.h:2192
ResizePendingParams::height
int height
Definition encoder.h:2193
RestUnitSearchInfo
Parameters related to restoration types.
Definition encoder.h:1681
RestUnitSearchInfo::best_rtype
RestorationType best_rtype[RESTORE_TYPES - 1]
Definition encoder.h:1696
RestUnitSearchInfo::wiener
WienerInfo wiener
Definition encoder.h:1685
RestUnitSearchInfo::sgrproj
SgrprojInfo sgrproj
Definition encoder.h:1690
RestorationInfo
Parameters related to Restoration Info.
Definition restoration.h:246
RestorationInfo::frame_restoration_type
RestorationType frame_restoration_type
Definition restoration.h:250
RestoreStateBuffers
Buffers to be backed up during parallel encode set to be restored later.
Definition encoder.h:1656
RestoreStateBuffers::rst_tmpbuf
int32_t * rst_tmpbuf
Definition encoder.h:1670
RestoreStateBuffers::rlbs
RestorationLineBuffers * rlbs
Definition encoder.h:1675
RestoreStateBuffers::cdef_colbuf
uint16_t * cdef_colbuf[3]
Definition encoder.h:1665
RestoreStateBuffers::cdef_srcbuf
uint16_t * cdef_srcbuf
Definition encoder.h:1660
SPEED_FEATURES
Top level speed vs quality trade off data struture.
Definition speed_features.h:2015
SPEED_FEATURES::mv_sf
MV_SPEED_FEATURES mv_sf
Definition speed_features.h:2044
SPEED_FEATURES::lpf_sf
LOOP_FILTER_SPEED_FEATURES lpf_sf
Definition speed_features.h:2079
SPEED_FEATURES::tx_sf
TX_SPEED_FEATURES tx_sf
Definition speed_features.h:2064
SPEED_FEATURES::rt_sf
REAL_TIME_SPEED_FEATURES rt_sf
Definition speed_features.h:2084
SVC
The stucture of SVC.
Definition svc_layercontext.h:89
SgrprojInfo
Parameters related to Sgrproj Filter.
Definition blockd.h:507
SuperResCfg
Encoder config related to frame super-resolution.
Definition encoder.h:431
SuperResCfg::superres_kf_scale_denominator
uint8_t superres_kf_scale_denominator
Definition encoder.h:453
SuperResCfg::superres_mode
aom_superres_mode superres_mode
Definition encoder.h:457
SuperResCfg::superres_kf_qthresh
int superres_kf_qthresh
Definition encoder.h:441
SuperResCfg::enable_superres
bool enable_superres
Definition encoder.h:461
SuperResCfg::superres_scale_denominator
uint8_t superres_scale_denominator
Definition encoder.h:447
SuperResCfg::superres_qthresh
int superres_qthresh
Definition encoder.h:436
TEMPORAL_FILTER_INFO
Temporal filter info for a gop.
Definition temporal_filter.h:161
TWO_PASS_FRAME
Frame level Two pass status and control data.
Definition firstpass.h:460
TWO_PASS
Two pass status and control data.
Definition firstpass.h:418
TemporalFilterCtx
Parameters related to temporal filtering.
Definition temporal_filter.h:98
TimeStamps
Frame time stamps.
Definition encoder.h:2433
TimeStamps::prev_ts_start
int64_t prev_ts_start
Definition encoder.h:2437
TimeStamps::first_ts_start
int64_t first_ts_start
Definition encoder.h:2445
TimeStamps::prev_ts_end
int64_t prev_ts_end
Definition encoder.h:2441
TplParams
Params related to temporal dependency model.
Definition tpl_model.h:165
TxfmSizeTypeCfg
Encoder flags for transform sizes and types.
Definition encoder.h:358
TxfmSizeTypeCfg::enable_tx64
bool enable_tx64
Definition encoder.h:362
TxfmSizeTypeCfg::use_inter_dct_only
bool use_inter_dct_only
Definition encoder.h:385
TxfmSizeTypeCfg::enable_flip_idtx
bool enable_flip_idtx
Definition encoder.h:366
TxfmSizeTypeCfg::use_intra_default_tx_only
bool use_intra_default_tx_only
Definition encoder.h:390
TxfmSizeTypeCfg::use_intra_dct_only
bool use_intra_dct_only
Definition encoder.h:380
TxfmSizeTypeCfg::enable_rect_tx
bool enable_rect_tx
Definition encoder.h:370
TxfmSizeTypeCfg::reduced_tx_type_set
bool reduced_tx_type_set
Definition encoder.h:375
TxfmSizeTypeCfg::enable_tx_size_search
bool enable_tx_size_search
Definition encoder.h:394
VarBasedPartitionInfo
Thresholds for variance based partitioning.
Definition encoder.h:1385
VarBasedPartitionInfo::thresholds
int64_t thresholds[5]
Definition encoder.h:1394
VarBasedPartitionInfo::threshold_minmax
int64_t threshold_minmax
Definition encoder.h:1400
WienerInfo
Parameters related to Wiener Filter.
Definition blockd.h:494
WinnerModeParams
Parameters used for winner mode processing.
Definition encoder.h:2229
WinnerModeParams::use_transform_domain_distortion
unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES]
Definition encoder.h:2251
WinnerModeParams::tx_size_search_methods
TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES]
Definition encoder.h:2243
WinnerModeParams::skip_txfm_level
unsigned int skip_txfm_level[MODE_EVAL_TYPES]
Definition encoder.h:2265
WinnerModeParams::coeff_opt_thresholds
unsigned int coeff_opt_thresholds[MODE_EVAL_TYPES][2]
Definition encoder.h:2237
WinnerModeParams::tx_domain_dist_threshold
unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES]
Definition encoder.h:2258
WinnerModeParams::predict_dc_level
unsigned int predict_dc_level[MODE_EVAL_TYPES]
Definition encoder.h:2272
inter_modes_info
Struct used to hold inter mode data for fast tx search.
Definition encoder.h:1290
inter_modes_info::rd_cost_arr
RD_STATS rd_cost_arr[MAX_INTER_MODES]
Definition encoder.h:1319
inter_modes_info::est_rd_arr
int64_t est_rd_arr[MAX_INTER_MODES]
Definition encoder.h:1311
inter_modes_info::sse_arr
int64_t sse_arr[MAX_INTER_MODES]
Definition encoder.h:1307
inter_modes_info::rd_cost_y_arr
RD_STATS rd_cost_y_arr[MAX_INTER_MODES]
Definition encoder.h:1323
inter_modes_info::rd_cost_uv_arr
RD_STATS rd_cost_uv_arr[MAX_INTER_MODES]
Definition encoder.h:1327
inter_modes_info::mbmi_arr
MB_MODE_INFO mbmi_arr[MAX_INTER_MODES]
Definition encoder.h:1299
inter_modes_info::rd_idx_pair_arr
RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES]
Definition encoder.h:1315
inter_modes_info::mode_rate_arr
int mode_rate_arr[MAX_INTER_MODES]
Definition encoder.h:1303
inter_modes_info::num
int num
Definition encoder.h:1295
macroblock::mbmi_ext_frame
MB_MODE_INFO_EXT_FRAME * mbmi_ext_frame
Finalized mbmi_ext for the whole frame.
Definition block.h:910
macroblockd::block_ref_scale_factors
const struct scale_factors * block_ref_scale_factors[2]
Definition blockd.h:687