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
25#include "av1/common/alloccommon.h"
26#include "av1/common/av1_common_int.h"
27#include "av1/common/blockd.h"
28#include "av1/common/entropymode.h"
29#include "av1/common/enums.h"
30#include "av1/common/reconintra.h"
31#include "av1/common/resize.h"
32#include "av1/common/thread_common.h"
33#include "av1/common/timing.h"
34
35#include "av1/encoder/aq_cyclicrefresh.h"
36#include "av1/encoder/av1_quantize.h"
37#include "av1/encoder/block.h"
38#include "av1/encoder/context_tree.h"
39#include "av1/encoder/encodemb.h"
40#include "av1/encoder/external_partition.h"
41#include "av1/encoder/firstpass.h"
42#include "av1/encoder/global_motion.h"
43#include "av1/encoder/level.h"
45#include "av1/encoder/mcomp.h"
46#include "av1/encoder/pickcdef.h"
47#include "av1/encoder/ratectrl.h"
48#include "av1/encoder/rd.h"
50#include "av1/encoder/svc_layercontext.h"
51#include "av1/encoder/temporal_filter.h"
52#include "av1/encoder/thirdpass.h"
53#include "av1/encoder/tokenize.h"
54#include "av1/encoder/tpl_model.h"
55#include "av1/encoder/av1_noise_estimate.h"
56#include "av1/encoder/bitstream.h"
57
58#if CONFIG_INTERNAL_STATS
59#include "aom_dsp/ssim.h"
60#endif
61#include "aom_dsp/variance.h"
62#if CONFIG_DENOISE
63#include "aom_dsp/noise_model.h"
64#endif
65#if CONFIG_TUNE_VMAF
66#include "av1/encoder/tune_vmaf.h"
67#endif
68#if CONFIG_AV1_TEMPORAL_DENOISING
69#include "av1/encoder/av1_temporal_denoiser.h"
70#endif
71#if CONFIG_TUNE_BUTTERAUGLI
72#include "av1/encoder/tune_butteraugli.h"
73#endif
74
75#include "aom/internal/aom_codec_internal.h"
76#include "aom_util/aom_thread.h"
77
78#ifdef __cplusplus
79extern "C" {
80#endif
81
82// TODO(yunqing, any): Added suppression tag to quiet Doxygen warnings. Need to
83// adjust it while we work on documentation.
85// Number of frames required to test for scene cut detection
86#define SCENE_CUT_KEY_TEST_INTERVAL 16
87
88// Lookahead index threshold to enable temporal filtering for second arf.
89#define TF_LOOKAHEAD_IDX_THR 7
90
91#define HDR_QP_LEVELS 10
92#define CHROMA_CB_QP_SCALE 1.04
93#define CHROMA_CR_QP_SCALE 1.04
94#define CHROMA_QP_SCALE -0.46
95#define CHROMA_QP_OFFSET 9.26
96#define QP_SCALE_FACTOR 2.0
97#define DISABLE_HDR_LUMA_DELTAQ 1
98
99// Rational number with an int64 numerator
100// This structure holds a fractional value
101typedef struct aom_rational64 {
102 int64_t num; // fraction numerator
103 int den; // fraction denominator
104} aom_rational64_t; // alias for struct aom_rational
105
106enum {
107 // Good Quality Fast Encoding. The encoder balances quality with the amount of
108 // time it takes to encode the output. Speed setting controls how fast.
109 GOOD,
110 // Realtime Fast Encoding. Will force some restrictions on bitrate
111 // constraints.
112 REALTIME,
113 // All intra mode. All the frames are coded as intra frames.
114 ALLINTRA
115} UENUM1BYTE(MODE);
116
117enum {
118 FRAMEFLAGS_KEY = 1 << 0,
119 FRAMEFLAGS_GOLDEN = 1 << 1,
120 FRAMEFLAGS_BWDREF = 1 << 2,
121 // TODO(zoeliu): To determine whether a frame flag is needed for ALTREF2_FRAME
122 FRAMEFLAGS_ALTREF = 1 << 3,
123 FRAMEFLAGS_INTRAONLY = 1 << 4,
124 FRAMEFLAGS_SWITCH = 1 << 5,
125 FRAMEFLAGS_ERROR_RESILIENT = 1 << 6,
126} UENUM1BYTE(FRAMETYPE_FLAGS);
127
128#if CONFIG_FPMT_TEST
129enum {
130 PARALLEL_ENCODE = 0,
131 PARALLEL_SIMULATION_ENCODE,
132 NUM_FPMT_TEST_ENCODES
133} UENUM1BYTE(FPMT_TEST_ENC_CFG);
134#endif // CONFIG_FPMT_TEST
135// 0 level frames are sometimes used for rate control purposes, but for
136// reference mapping purposes, the minimum level should be 1.
137#define MIN_PYR_LEVEL 1
138static INLINE int get_true_pyr_level(int frame_level, int frame_order,
139 int max_layer_depth) {
140 if (frame_order == 0) {
141 // Keyframe case
142 return MIN_PYR_LEVEL;
143 } else if (frame_level == MAX_ARF_LAYERS) {
144 // Leaves
145 return max_layer_depth;
146 } else if (frame_level == (MAX_ARF_LAYERS + 1)) {
147 // Altrefs
148 return MIN_PYR_LEVEL;
149 }
150 return AOMMAX(MIN_PYR_LEVEL, frame_level);
151}
152
153enum {
154 NO_AQ = 0,
155 VARIANCE_AQ = 1,
156 COMPLEXITY_AQ = 2,
157 CYCLIC_REFRESH_AQ = 3,
158 AQ_MODE_COUNT // This should always be the last member of the enum
159} UENUM1BYTE(AQ_MODE);
160enum {
161 NO_DELTA_Q = 0,
162 DELTA_Q_OBJECTIVE = 1, // Modulation to improve objective quality
163 DELTA_Q_PERCEPTUAL = 2, // Modulation to improve video perceptual quality
164 DELTA_Q_PERCEPTUAL_AI = 3, // Perceptual quality opt for all intra mode
165 DELTA_Q_USER_RATING_BASED = 4, // User rating based delta q mode
166 DELTA_Q_HDR = 5, // QP adjustment based on HDR block pixel average
167 DELTA_Q_MODE_COUNT // This should always be the last member of the enum
168} UENUM1BYTE(DELTAQ_MODE);
169
170enum {
171 RESIZE_NONE = 0, // No frame resizing allowed.
172 RESIZE_FIXED = 1, // All frames are coded at the specified scale.
173 RESIZE_RANDOM = 2, // All frames are coded at a random scale.
174 RESIZE_DYNAMIC = 3, // Frames coded at lower scale based on rate control.
175 RESIZE_MODES
176} UENUM1BYTE(RESIZE_MODE);
177
178enum {
179 SS_CFG_SRC = 0,
180 SS_CFG_LOOKAHEAD = 1,
181 SS_CFG_FPF = 2,
182 SS_CFG_TOTAL = 3
183} UENUM1BYTE(SS_CFG_OFFSET);
184
185enum {
186 DISABLE_SCENECUT, // For LAP, lag_in_frames < 19
187 ENABLE_SCENECUT_MODE_1, // For LAP, lag_in_frames >=19 and < 33
188 ENABLE_SCENECUT_MODE_2 // For twopass and LAP - lag_in_frames >=33
189} UENUM1BYTE(SCENECUT_MODE);
190
191#define MAX_VBR_CORPUS_COMPLEXITY 10000
192
193typedef enum {
194 MOD_FP, // First pass
195 MOD_TF, // Temporal filtering
196 MOD_TPL, // TPL
197 MOD_GME, // Global motion estimation
198 MOD_ENC, // Encode stage
199 MOD_LPF, // Deblocking loop filter
200 MOD_CDEF_SEARCH, // CDEF search
201 MOD_CDEF, // CDEF frame
202 MOD_LR, // Loop restoration filtering
203 MOD_PACK_BS, // Pack bitstream
204 MOD_FRAME_ENC, // Frame Parallel encode
205 MOD_AI, // All intra
206 NUM_MT_MODULES
207} MULTI_THREADED_MODULES;
208
210
224
235
240typedef enum {
241 SKIP_APPLY_RESTORATION = 1 << 0,
242 SKIP_APPLY_SUPERRES = 1 << 1,
243 SKIP_APPLY_CDEF = 1 << 2,
244 SKIP_APPLY_LOOPFILTER = 1 << 3,
246
250typedef struct {
254 RESIZE_MODE resize_mode;
265} ResizeCfg;
266
294
349
391
422
458
462typedef struct {
467
472
477
483
490
495
500
505
510
516
623
625typedef struct {
626 // Indicates the number of frames lag before encoding is started.
627 int lag_in_frames;
628 // Indicates the minimum gf/arf interval to be used.
629 int min_gf_interval;
630 // Indicates the maximum gf/arf interval to be used.
631 int max_gf_interval;
632 // Indicates the minimum height for GF group pyramid structure to be used.
633 int gf_min_pyr_height;
634 // Indicates the maximum height for GF group pyramid structure to be used.
635 int gf_max_pyr_height;
636 // Indicates if automatic set and use of altref frames should be enabled.
637 bool enable_auto_arf;
638 // Indicates if automatic set and use of (b)ackward (r)ef (f)rames should be
639 // enabled.
640 bool enable_auto_brf;
641} GFConfig;
642
643typedef struct {
644 // Indicates the number of tile groups.
645 unsigned int num_tile_groups;
646 // Indicates the MTU size for a tile group. If mtu is non-zero,
647 // num_tile_groups is set to DEFAULT_MAX_NUM_TG.
648 unsigned int mtu;
649 // Indicates the number of tile columns in log2.
650 int tile_columns;
651 // Indicates the number of tile rows in log2.
652 int tile_rows;
653 // Indicates the number of widths in the tile_widths[] array.
654 int tile_width_count;
655 // Indicates the number of heights in the tile_heights[] array.
656 int tile_height_count;
657 // Indicates the tile widths, and may be empty.
658 int tile_widths[MAX_TILE_COLS];
659 // Indicates the tile heights, and may be empty.
660 int tile_heights[MAX_TILE_ROWS];
661 // Indicates if large scale tile coding should be used.
662 bool enable_large_scale_tile;
663 // Indicates if single tile decoding mode should be enabled.
664 bool enable_single_tile_decoding;
665 // Indicates if EXT_TILE_DEBUG should be enabled.
666 bool enable_ext_tile_debug;
667} TileConfig;
668
669typedef struct {
670 // Indicates the width of the input frame.
671 int width;
672 // Indicates the height of the input frame.
673 int height;
674 // If forced_max_frame_width is non-zero then it is used to force the maximum
675 // frame width written in write_sequence_header().
676 int forced_max_frame_width;
677 // If forced_max_frame_width is non-zero then it is used to force the maximum
678 // frame height written in write_sequence_header().
679 int forced_max_frame_height;
680 // Indicates the frame width after applying both super-resolution and resize
681 // to the coded frame.
682 int render_width;
683 // Indicates the frame height after applying both super-resolution and resize
684 // to the coded frame.
685 int render_height;
686} FrameDimensionCfg;
687
688typedef struct {
689 // Indicates if warped motion should be enabled.
690 bool enable_warped_motion;
691 // Indicates if warped motion should be evaluated or not.
692 bool allow_warped_motion;
693 // Indicates if OBMC motion should be enabled.
694 bool enable_obmc;
695} MotionModeCfg;
696
697typedef struct {
698 // Timing info for each frame.
699 aom_timing_info_t timing_info;
700 // Indicates the number of time units of a decoding clock.
701 uint32_t num_units_in_decoding_tick;
702 // Indicates if decoder model information is present in the coded sequence
703 // header.
704 bool decoder_model_info_present_flag;
705 // Indicates if display model information is present in the coded sequence
706 // header.
707 bool display_model_info_present_flag;
708 // Indicates if timing info for each frame is present.
709 bool timing_info_present;
710} DecoderModelCfg;
711
712typedef struct {
713 // Indicates the update frequency for coeff costs.
714 COST_UPDATE_TYPE coeff;
715 // Indicates the update frequency for mode costs.
716 COST_UPDATE_TYPE mode;
717 // Indicates the update frequency for mv costs.
719 // Indicates the update frequency for dv costs.
721} CostUpdateFreq;
722
723typedef struct {
724 // Indicates the maximum number of reference frames allowed per frame.
725 unsigned int max_reference_frames;
726 // Indicates if the reduced set of references should be enabled.
727 bool enable_reduced_reference_set;
728 // Indicates if one-sided compound should be enabled.
729 bool enable_onesided_comp;
730} RefFrameCfg;
731
732typedef struct {
733 // Indicates the color space that should be used.
734 aom_color_primaries_t color_primaries;
735 // Indicates the characteristics of transfer function to be used.
736 aom_transfer_characteristics_t transfer_characteristics;
737 // Indicates the matrix coefficients to be used for the transfer function.
738 aom_matrix_coefficients_t matrix_coefficients;
739 // Indicates the chroma 4:2:0 sample position info.
740 aom_chroma_sample_position_t chroma_sample_position;
741 // Indicates if a limited color range or full color range should be used.
742 aom_color_range_t color_range;
743} ColorCfg;
744
745typedef struct {
746 // Indicates if extreme motion vector unit test should be enabled or not.
747 unsigned int motion_vector_unit_test;
748 // Indicates if superblock multipass unit test should be enabled or not.
749 unsigned int sb_multipass_unit_test;
750} UnitTestCfg;
751
752typedef struct {
753 // Indicates the file path to the VMAF model.
754 const char *vmaf_model_path;
755 // Indicates the path to the film grain parameters.
756 const char *film_grain_table_filename;
757 // Indicates the visual tuning metric.
758 aom_tune_metric tuning;
759 // Indicates if the current content is screen or default type.
760 aom_tune_content content;
761 // Indicates the film grain parameters.
762 int film_grain_test_vector;
763 // Indicates the in-block distortion metric to use.
764 aom_dist_metric dist_metric;
765} TuneCfg;
766
767typedef struct {
768 // Indicates the framerate of the input video.
769 double init_framerate;
770 // Indicates the bit-depth of the input video.
771 unsigned int input_bit_depth;
772 // Indicates the maximum number of frames to be encoded.
773 unsigned int limit;
774 // Indicates the chrome subsampling x value.
775 unsigned int chroma_subsampling_x;
776 // Indicates the chrome subsampling y value.
777 unsigned int chroma_subsampling_y;
778} InputCfg;
779
780typedef struct {
781 // If true, encoder will use fixed QP offsets, that are either:
782 // - Given by the user, and stored in 'fixed_qp_offsets' array, OR
783 // - Picked automatically from cq_level.
784 int use_fixed_qp_offsets;
785 // Indicates the minimum flatness of the quantization matrix.
786 int qm_minlevel;
787 // Indicates the maximum flatness of the quantization matrix.
788 int qm_maxlevel;
789 // Indicates if adaptive quantize_b should be enabled.
790 int quant_b_adapt;
791 // Indicates the Adaptive Quantization mode to be used.
792 AQ_MODE aq_mode;
793 // Indicates the delta q mode to be used.
794 DELTAQ_MODE deltaq_mode;
795 // Indicates the delta q mode strength.
796 DELTAQ_MODE deltaq_strength;
797 // Indicates if delta quantization should be enabled in chroma planes.
798 bool enable_chroma_deltaq;
799 // Indicates if delta quantization should be enabled for hdr video
800 bool enable_hdr_deltaq;
801 // Indicates if encoding with quantization matrices should be enabled.
802 bool using_qm;
803} QuantizationCfg;
804
871
872
873typedef struct {
874 // Indicates the codec bit-depth.
875 aom_bit_depth_t bit_depth;
876 // Indicates the superblock size that should be used by the encoder.
877 aom_superblock_size_t superblock_size;
878 // Indicates if loopfilter modulation should be enabled.
879 bool enable_deltalf_mode;
880 // Indicates how CDEF should be applied.
881 CDEF_CONTROL cdef_control;
882 // Indicates if loop restoration filter should be enabled.
883 bool enable_restoration;
884 // When enabled, video mode should be used even for single frame input.
885 bool force_video_mode;
886 // Indicates if the error resiliency features should be enabled.
887 bool error_resilient_mode;
888 // Indicates if frame parallel decoding feature should be enabled.
889 bool frame_parallel_decoding_mode;
890 // Indicates if the input should be encoded as monochrome.
891 bool enable_monochrome;
892 // When enabled, the encoder will use a full header even for still pictures.
893 // When disabled, a reduced header is used for still pictures.
894 bool full_still_picture_hdr;
895 // Indicates if dual interpolation filters should be enabled.
896 bool enable_dual_filter;
897 // Indicates if frame order hint should be enabled or not.
898 bool enable_order_hint;
899 // Indicates if ref_frame_mvs should be enabled at the sequence level.
900 bool ref_frame_mvs_present;
901 // Indicates if ref_frame_mvs should be enabled at the frame level.
902 bool enable_ref_frame_mvs;
903 // Indicates if interintra compound mode is enabled.
904 bool enable_interintra_comp;
905 // Indicates if global motion should be enabled.
906 bool enable_global_motion;
907 // Indicates if palette should be enabled.
908 bool enable_palette;
909} ToolCfg;
910
915typedef struct AV1EncoderConfig {
917 // Configuration related to the input video.
918 InputCfg input_cfg;
919
920 // Configuration related to frame-dimensions.
921 FrameDimensionCfg frm_dim_cfg;
922
928
933
939
940 // Configuration related to Quantization.
941 QuantizationCfg q_cfg;
942
943 // Internal frame size scaling.
944 ResizeCfg resize_cfg;
945
946 // Frame Super-Resolution size scaling.
947 SuperResCfg superres_cfg;
948
956
957 // Configuration related to encoder toolsets.
958 ToolCfg tool_cfg;
959
960 // Configuration related to Group of frames.
961 GFConfig gf_cfg;
962
963 // Tile related configuration parameters.
964 TileConfig tile_cfg;
965
966 // Configuration related to Tune.
967 TuneCfg tune_cfg;
968
969 // Configuration related to color.
970 ColorCfg color_cfg;
971
972 // Configuration related to decoder model.
973 DecoderModelCfg dec_model_cfg;
974
975 // Configuration related to reference frames.
976 RefFrameCfg ref_frm_cfg;
977
978 // Configuration related to unit tests.
979 UnitTestCfg unit_test_cfg;
980
981 // Flags related to motion mode.
982 MotionModeCfg motion_mode_cfg;
983
984 // Flags related to intra mode search.
985 IntraModeCfg intra_mode_cfg;
986
987 // Flags related to transform size/type.
988 TxfmSizeTypeCfg txfm_cfg;
989
990 // Flags related to compound type.
991 CompoundTypeCfg comp_type_cfg;
992
993 // Partition related information.
994 PartitionCfg part_cfg;
995
996 // Configuration related to frequency of cost update.
997 CostUpdateFreq cost_upd_freq;
998
999#if CONFIG_DENOISE
1000 // Indicates the noise level.
1001 float noise_level;
1002 // Indicates the the denoisers block size.
1003 int noise_block_size;
1004 // Indicates whether to apply denoising to the frame to be encoded
1005 int enable_dnl_denoising;
1006#endif
1007
1008#if CONFIG_AV1_TEMPORAL_DENOISING
1009 // Noise sensitivity.
1010 int noise_sensitivity;
1011#endif
1012 // Bit mask to specify which tier each of the 32 possible operating points
1013 // conforms to.
1014 unsigned int tier_mask;
1015
1016 // Indicates the number of pixels off the edge of a reference frame we're
1017 // allowed to go when forming an inter prediction.
1018 int border_in_pixels;
1019
1020 // Indicates the maximum number of threads that may be used by the encoder.
1021 int max_threads;
1022
1023 // Indicates the speed preset to be used.
1024 int speed;
1025
1026 // Indicates the target sequence level index for each operating point(OP).
1027 AV1_LEVEL target_seq_level_idx[MAX_NUM_OPERATING_POINTS];
1028
1029 // Indicates the bitstream profile to be used.
1030 BITSTREAM_PROFILE profile;
1031
1042
1043 // Total number of encoding passes.
1044 int passes;
1045
1046 // the name of the second pass output file when passes > 2
1047 const char *two_pass_output;
1048
1049 // the name of the second pass log file when passes > 2
1050 const char *second_pass_log;
1051
1052 // Indicates if the encoding is GOOD or REALTIME.
1053 MODE mode;
1054
1055 // Indicates if row-based multi-threading should be enabled or not.
1056 bool row_mt;
1057
1058 // Indicates if frame parallel multi-threading should be enabled or not.
1059 bool fp_mt;
1060
1061 // Indicates if 16bit frame buffers are to be used i.e., the content is >
1062 // 8-bit.
1063 bool use_highbitdepth;
1064
1065 // Indicates the bitstream syntax mode. 0 indicates bitstream is saved as
1066 // Section 5 bitstream, while 1 indicates the bitstream is saved in Annex - B
1067 // format.
1068 bool save_as_annexb;
1069
1070 // The path for partition stats reading and writing, used in the experiment
1071 // CONFIG_PARTITION_SEARCH_ORDER.
1072 const char *partition_info_path;
1073
1074 // The flag that indicates whether we use an external rate distribution to
1075 // guide adaptive quantization. It requires --deltaq-mode=3. The rate
1076 // distribution map file name is stored in |rate_distribution_info|.
1077 unsigned int enable_rate_guide_deltaq;
1078
1079 // The input file of rate distribution information used in all intra mode
1080 // to determine delta quantization.
1081 const char *rate_distribution_info;
1082
1083 // Exit the encoder when it fails to encode to a given level.
1084 int strict_level_conformance;
1085
1086 // Max depth for the GOP after a key frame
1087 int kf_max_pyr_height;
1088
1089 // A flag to control if we enable the superblock qp sweep for a given lambda
1090 int sb_qp_sweep;
1093
1095static INLINE int is_lossless_requested(const RateControlCfg *const rc_cfg) {
1096 return rc_cfg->best_allowed_q == 0 && rc_cfg->worst_allowed_q == 0;
1097}
1099
1103typedef struct {
1109 int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL];
1110
1116 int warped_probs[FRAME_UPDATE_TYPES];
1117
1124 int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES];
1125
1132 int switchable_interp_probs[FRAME_UPDATE_TYPES][SWITCHABLE_FILTER_CONTEXTS]
1133 [SWITCHABLE_FILTERS];
1135
1137
1138typedef struct FRAME_COUNTS {
1139// Note: This structure should only contain 'unsigned int' fields, or
1140// aggregates built solely from 'unsigned int' fields/elements
1141#if CONFIG_ENTROPY_STATS
1142 unsigned int kf_y_mode[KF_MODE_CONTEXTS][KF_MODE_CONTEXTS][INTRA_MODES];
1143 unsigned int angle_delta[DIRECTIONAL_MODES][2 * MAX_ANGLE_DELTA + 1];
1144 unsigned int y_mode[BLOCK_SIZE_GROUPS][INTRA_MODES];
1145 unsigned int uv_mode[CFL_ALLOWED_TYPES][INTRA_MODES][UV_INTRA_MODES];
1146 unsigned int cfl_sign[CFL_JOINT_SIGNS];
1147 unsigned int cfl_alpha[CFL_ALPHA_CONTEXTS][CFL_ALPHABET_SIZE];
1148 unsigned int palette_y_mode[PALATTE_BSIZE_CTXS][PALETTE_Y_MODE_CONTEXTS][2];
1149 unsigned int palette_uv_mode[PALETTE_UV_MODE_CONTEXTS][2];
1150 unsigned int palette_y_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
1151 unsigned int palette_uv_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
1152 unsigned int palette_y_color_index[PALETTE_SIZES]
1153 [PALETTE_COLOR_INDEX_CONTEXTS]
1154 [PALETTE_COLORS];
1155 unsigned int palette_uv_color_index[PALETTE_SIZES]
1156 [PALETTE_COLOR_INDEX_CONTEXTS]
1157 [PALETTE_COLORS];
1158 unsigned int partition[PARTITION_CONTEXTS][EXT_PARTITION_TYPES];
1159 unsigned int txb_skip[TOKEN_CDF_Q_CTXS][TX_SIZES][TXB_SKIP_CONTEXTS][2];
1160 unsigned int eob_extra[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1161 [EOB_COEF_CONTEXTS][2];
1162 unsigned int dc_sign[PLANE_TYPES][DC_SIGN_CONTEXTS][2];
1163 unsigned int coeff_lps[TX_SIZES][PLANE_TYPES][BR_CDF_SIZE - 1][LEVEL_CONTEXTS]
1164 [2];
1165 unsigned int eob_flag[TX_SIZES][PLANE_TYPES][EOB_COEF_CONTEXTS][2];
1166 unsigned int eob_multi16[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][5];
1167 unsigned int eob_multi32[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][6];
1168 unsigned int eob_multi64[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][7];
1169 unsigned int eob_multi128[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][8];
1170 unsigned int eob_multi256[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][9];
1171 unsigned int eob_multi512[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][10];
1172 unsigned int eob_multi1024[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][11];
1173 unsigned int coeff_lps_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1174 [LEVEL_CONTEXTS][BR_CDF_SIZE];
1175 unsigned int coeff_base_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1176 [SIG_COEF_CONTEXTS][NUM_BASE_LEVELS + 2];
1177 unsigned int coeff_base_eob_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1178 [SIG_COEF_CONTEXTS_EOB][NUM_BASE_LEVELS + 1];
1179 unsigned int newmv_mode[NEWMV_MODE_CONTEXTS][2];
1180 unsigned int zeromv_mode[GLOBALMV_MODE_CONTEXTS][2];
1181 unsigned int refmv_mode[REFMV_MODE_CONTEXTS][2];
1182 unsigned int drl_mode[DRL_MODE_CONTEXTS][2];
1183 unsigned int inter_compound_mode[INTER_MODE_CONTEXTS][INTER_COMPOUND_MODES];
1184 unsigned int wedge_idx[BLOCK_SIZES_ALL][16];
1185 unsigned int interintra[BLOCK_SIZE_GROUPS][2];
1186 unsigned int interintra_mode[BLOCK_SIZE_GROUPS][INTERINTRA_MODES];
1187 unsigned int wedge_interintra[BLOCK_SIZES_ALL][2];
1188 unsigned int compound_type[BLOCK_SIZES_ALL][MASKED_COMPOUND_TYPES];
1189 unsigned int motion_mode[BLOCK_SIZES_ALL][MOTION_MODES];
1190 unsigned int obmc[BLOCK_SIZES_ALL][2];
1191 unsigned int intra_inter[INTRA_INTER_CONTEXTS][2];
1192 unsigned int comp_inter[COMP_INTER_CONTEXTS][2];
1193 unsigned int comp_ref_type[COMP_REF_TYPE_CONTEXTS][2];
1194 unsigned int uni_comp_ref[UNI_COMP_REF_CONTEXTS][UNIDIR_COMP_REFS - 1][2];
1195 unsigned int single_ref[REF_CONTEXTS][SINGLE_REFS - 1][2];
1196 unsigned int comp_ref[REF_CONTEXTS][FWD_REFS - 1][2];
1197 unsigned int comp_bwdref[REF_CONTEXTS][BWD_REFS - 1][2];
1198 unsigned int intrabc[2];
1199
1200 unsigned int txfm_partition[TXFM_PARTITION_CONTEXTS][2];
1201 unsigned int intra_tx_size[MAX_TX_CATS][TX_SIZE_CONTEXTS][MAX_TX_DEPTH + 1];
1202 unsigned int skip_mode[SKIP_MODE_CONTEXTS][2];
1203 unsigned int skip_txfm[SKIP_CONTEXTS][2];
1204 unsigned int compound_index[COMP_INDEX_CONTEXTS][2];
1205 unsigned int comp_group_idx[COMP_GROUP_IDX_CONTEXTS][2];
1206 unsigned int delta_q[DELTA_Q_PROBS][2];
1207 unsigned int delta_lf_multi[FRAME_LF_COUNT][DELTA_LF_PROBS][2];
1208 unsigned int delta_lf[DELTA_LF_PROBS][2];
1209
1210 unsigned int inter_ext_tx[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
1211 unsigned int intra_ext_tx[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
1212 [TX_TYPES];
1213 unsigned int filter_intra_mode[FILTER_INTRA_MODES];
1214 unsigned int filter_intra[BLOCK_SIZES_ALL][2];
1215 unsigned int switchable_restore[RESTORE_SWITCHABLE_TYPES];
1216 unsigned int wiener_restore[2];
1217 unsigned int sgrproj_restore[2];
1218#endif // CONFIG_ENTROPY_STATS
1219
1220 unsigned int switchable_interp[SWITCHABLE_FILTER_CONTEXTS]
1221 [SWITCHABLE_FILTERS];
1222} FRAME_COUNTS;
1223
1224#define INTER_MODE_RD_DATA_OVERALL_SIZE 6400
1225
1226typedef struct {
1227 int ready;
1228 double a;
1229 double b;
1230 double dist_mean;
1231 double ld_mean;
1232 double sse_mean;
1233 double sse_sse_mean;
1234 double sse_ld_mean;
1235 int num;
1236 double dist_sum;
1237 double ld_sum;
1238 double sse_sum;
1239 double sse_sse_sum;
1240 double sse_ld_sum;
1241} InterModeRdModel;
1242
1243typedef struct {
1244 int idx;
1245 int64_t rd;
1246} RdIdxPair;
1247// TODO(angiebird): This is an estimated size. We still need to figure what is
1248// the maximum number of modes.
1249#define MAX_INTER_MODES 1024
1250// TODO(any): rename this struct to something else. There is already another
1251// struct called inter_mode_info, which makes this terribly confusing.
1259typedef struct inter_modes_info {
1264 int num;
1268 MB_MODE_INFO mbmi_arr[MAX_INTER_MODES];
1272 int mode_rate_arr[MAX_INTER_MODES];
1276 int64_t sse_arr[MAX_INTER_MODES];
1280 int64_t est_rd_arr[MAX_INTER_MODES];
1284 RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES];
1288 RD_STATS rd_cost_arr[MAX_INTER_MODES];
1292 RD_STATS rd_cost_y_arr[MAX_INTER_MODES];
1296 RD_STATS rd_cost_uv_arr[MAX_INTER_MODES];
1298
1300typedef struct {
1301 // TODO(kyslov): consider changing to 64bit
1302
1303 // This struct is used for computing variance in choose_partitioning(), where
1304 // the max number of samples within a superblock is 32x32 (with 4x4 avg).
1305 // With 8bit bitdepth, uint32_t is enough for sum_square_error (2^8 * 2^8 * 32
1306 // * 32 = 2^26). For high bitdepth we need to consider changing this to 64 bit
1307 uint32_t sum_square_error;
1308 int32_t sum_error;
1309 int log2_count;
1310 int variance;
1311} VPartVar;
1312
1313typedef struct {
1314 VPartVar none;
1315 VPartVar horz[2];
1316 VPartVar vert[2];
1317} VPVariance;
1318
1319typedef struct {
1320 VPVariance part_variances;
1321 VPartVar split[4];
1322} VP4x4;
1323
1324typedef struct {
1325 VPVariance part_variances;
1326 VP4x4 split[4];
1327} VP8x8;
1328
1329typedef struct {
1330 VPVariance part_variances;
1331 VP8x8 split[4];
1332} VP16x16;
1333
1334typedef struct {
1335 VPVariance part_variances;
1336 VP16x16 split[4];
1337} VP32x32;
1338
1339typedef struct {
1340 VPVariance part_variances;
1341 VP32x32 split[4];
1342} VP64x64;
1343
1344typedef struct {
1345 VPVariance part_variances;
1346 VP64x64 *split;
1347} VP128x128;
1348
1350
1354typedef struct {
1363 int64_t thresholds[5];
1364
1371
1375typedef struct {
1376#if CONFIG_MULTITHREAD
1381 pthread_mutex_t *mutex_;
1382 pthread_cond_t *cond_;
1384#endif // CONFIG_MULTITHREAD
1408 int rows;
1418
1420
1421// TODO(jingning) All spatially adaptive variables should go to TileDataEnc.
1422typedef struct TileDataEnc {
1423 TileInfo tile_info;
1424 DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx);
1425 FRAME_CONTEXT *row_ctx;
1426 uint64_t abs_sum_level;
1427 uint8_t allow_update_cdf;
1428 InterModeRdModel inter_mode_rd_models[BLOCK_SIZES_ALL];
1429 AV1EncRowMultiThreadSync row_mt_sync;
1430 MV firstpass_top_mv;
1431} TileDataEnc;
1432
1433typedef struct RD_COUNTS {
1434 int compound_ref_used_flag;
1435 int skip_mode_used_flag;
1436 int tx_type_used[TX_SIZES_ALL][TX_TYPES];
1437 int obmc_used[BLOCK_SIZES_ALL][2];
1438 int warped_used[2];
1439 int newmv_or_intra_blocks;
1440 uint64_t seg_tmp_pred_cost[2];
1441} RD_COUNTS;
1442
1443typedef struct ThreadData {
1444 MACROBLOCK mb;
1445 RD_COUNTS rd_counts;
1446 FRAME_COUNTS *counts;
1447 PC_TREE_SHARED_BUFFERS shared_coeff_buf;
1448 SIMPLE_MOTION_DATA_TREE *sms_tree;
1449 SIMPLE_MOTION_DATA_TREE *sms_root;
1450 uint32_t *hash_value_buffer[2][2];
1451 OBMCBuffer obmc_buffer;
1452 PALETTE_BUFFER *palette_buffer;
1453 CompoundTypeRdBuffers comp_rd_buffer;
1454 CONV_BUF_TYPE *tmp_conv_dst;
1455 uint64_t abs_sum_level;
1456 uint8_t *tmp_pred_bufs[2];
1457 int intrabc_used;
1458 int deltaq_used;
1459 int coefficient_size;
1460 int max_mv_magnitude;
1461 int interp_filter_selected[SWITCHABLE];
1462 FRAME_CONTEXT *tctx;
1463 VP64x64 *vt64x64;
1464 int32_t num_64x64_blocks;
1465 PICK_MODE_CONTEXT *firstpass_ctx;
1466 TemporalFilterData tf_data;
1467 TplTxfmStats tpl_txfm_stats;
1468 // Pointer to the array of structures to store gradient information of each
1469 // pixel in a superblock. The buffer constitutes of MAX_SB_SQUARE pixel level
1470 // structures for each of the plane types (PLANE_TYPE_Y and PLANE_TYPE_UV).
1471 PixelLevelGradientInfo *pixel_gradient_info;
1472 // Pointer to the array of structures to store source variance information of
1473 // each 4x4 sub-block in a superblock. Block4x4VarInfo structure is used to
1474 // store source variance and log of source variance of each 4x4 sub-block
1475 // for subsequent retrieval.
1476 Block4x4VarInfo *src_var_info_of_4x4_sub_blocks;
1477 // The pc tree root for RTC non-rd case.
1478 PC_TREE *rt_pc_root;
1479} ThreadData;
1480
1481struct EncWorkerData;
1482
1484
1488typedef struct {
1511
1515 int thread_id_to_tile_id[MAX_NUM_THREADS];
1516
1522
1528
1529#if CONFIG_MULTITHREAD
1533 pthread_mutex_t *mutex_;
1537 pthread_cond_t *cond_;
1538#endif
1539
1547 void (*sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int);
1551 void (*sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
1554
1558typedef struct {
1559#if CONFIG_MULTITHREAD
1563 pthread_mutex_t *mutex_;
1567 pthread_cond_t *cond_;
1568#endif
1569
1581 void (*intra_sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
1584
1588#define NUM_RECODES_PER_FRAME 10
1589
1593#define MAX_PARALLEL_FRAMES 4
1594
1599typedef struct RestoreStateBuffers {
1603 uint16_t *cdef_srcbuf;
1604
1608 uint16_t *cdef_colbuf[MAX_MB_PLANE];
1609
1613 int32_t *rst_tmpbuf;
1614
1618 RestorationLineBuffers *rlbs;
1620
1629
1633 int num_mod_workers[NUM_MT_MODULES];
1634
1638 AVxWorker *workers;
1639
1644 struct EncWorkerData *tile_thr_data;
1645
1649 AV1CdefWorkerData *cdef_worker;
1650
1656
1661
1667
1671typedef struct MultiThreadInfo {
1676
1680 int num_mod_workers[NUM_MT_MODULES];
1681
1685 AVxWorker *workers;
1686
1691 struct EncWorkerData *tile_thr_data;
1692
1698
1703
1708
1714
1718 AV1TplRowMultiThreadInfo tpl_row_mt;
1719
1723 AV1LfSync lf_row_sync;
1724
1728 AV1LrSync lr_row_sync;
1729
1733 AV1EncPackBSSync pack_bs_sync;
1734
1738 AV1GlobalMotionSync gm_sync;
1739
1743 AV1TemporalFilterSync tf_sync;
1744
1748 AV1CdefSync cdef_sync;
1749
1753 AV1CdefWorkerData *cdef_worker;
1754
1759
1766
1768
1769typedef struct ActiveMap {
1770 int enabled;
1771 int update;
1772 unsigned char *map;
1773} ActiveMap;
1774
1776
1780typedef struct {
1785 double cs_rate_array[32];
1795
1797
1798#if CONFIG_INTERNAL_STATS
1799// types of stats
1800enum {
1801 STAT_Y,
1802 STAT_U,
1803 STAT_V,
1804 STAT_ALL,
1805 NUM_STAT_TYPES // This should always be the last member of the enum
1806} UENUM1BYTE(StatType);
1807
1808typedef struct IMAGE_STAT {
1809 double stat[NUM_STAT_TYPES];
1810 double worst;
1811} ImageStat;
1812#endif // CONFIG_INTERNAL_STATS
1813
1814typedef struct {
1815 int ref_count;
1816 YV12_BUFFER_CONFIG buf;
1817} EncRefCntBuffer;
1818
1820
1841
1843
1844#if CONFIG_COLLECT_PARTITION_STATS
1845typedef struct FramePartitionTimingStats {
1846 int partition_decisions[6][EXT_PARTITION_TYPES];
1847 int partition_attempts[6][EXT_PARTITION_TYPES];
1848 int64_t partition_times[6][EXT_PARTITION_TYPES];
1849
1850 int partition_redo;
1851} FramePartitionTimingStats;
1852#endif // CONFIG_COLLECT_PARTITION_STATS
1853
1854#if CONFIG_COLLECT_COMPONENT_TIMING
1855#include "aom_ports/aom_timer.h"
1856// Adjust the following to add new components.
1857enum {
1858 av1_encode_strategy_time,
1859 av1_get_one_pass_rt_params_time,
1860 av1_get_second_pass_params_time,
1861 denoise_and_encode_time,
1862 apply_filtering_time,
1863 av1_tpl_setup_stats_time,
1864 encode_frame_to_data_rate_time,
1865 encode_with_or_without_recode_time,
1866 loop_filter_time,
1867 cdef_time,
1868 loop_restoration_time,
1869 av1_pack_bitstream_final_time,
1870 av1_encode_frame_time,
1871 av1_compute_global_motion_time,
1872 av1_setup_motion_field_time,
1873 encode_sb_row_time,
1874
1875 rd_pick_partition_time,
1876 rd_use_partition_time,
1877 choose_var_based_partitioning_time,
1878 av1_prune_partitions_time,
1879 none_partition_search_time,
1880 split_partition_search_time,
1881 rectangular_partition_search_time,
1882 ab_partitions_search_time,
1883 rd_pick_4partition_time,
1884 encode_sb_time,
1885
1886 rd_pick_sb_modes_time,
1887 av1_rd_pick_intra_mode_sb_time,
1888 av1_rd_pick_inter_mode_sb_time,
1889 set_params_rd_pick_inter_mode_time,
1890 skip_inter_mode_time,
1891 handle_inter_mode_time,
1892 evaluate_motion_mode_for_winner_candidates_time,
1893 do_tx_search_time,
1894 handle_intra_mode_time,
1895 refine_winner_mode_tx_time,
1896 av1_search_palette_mode_time,
1897 handle_newmv_time,
1898 compound_type_rd_time,
1899 interpolation_filter_search_time,
1900 motion_mode_rd_time,
1901
1902 nonrd_use_partition_time,
1903 pick_sb_modes_nonrd_time,
1904 hybrid_intra_mode_search_time,
1905 nonrd_pick_inter_mode_sb_time,
1906 encode_b_nonrd_time,
1907
1908 kTimingComponents,
1909} UENUM1BYTE(TIMING_COMPONENT);
1910
1911static INLINE char const *get_component_name(int index) {
1912 switch (index) {
1913 case av1_encode_strategy_time: return "av1_encode_strategy_time";
1914 case av1_get_one_pass_rt_params_time:
1915 return "av1_get_one_pass_rt_params_time";
1916 case av1_get_second_pass_params_time:
1917 return "av1_get_second_pass_params_time";
1918 case denoise_and_encode_time: return "denoise_and_encode_time";
1919 case apply_filtering_time: return "apply_filtering_time";
1920 case av1_tpl_setup_stats_time: return "av1_tpl_setup_stats_time";
1921 case encode_frame_to_data_rate_time:
1922 return "encode_frame_to_data_rate_time";
1923 case encode_with_or_without_recode_time:
1924 return "encode_with_or_without_recode_time";
1925 case loop_filter_time: return "loop_filter_time";
1926 case cdef_time: return "cdef_time";
1927 case loop_restoration_time: return "loop_restoration_time";
1928 case av1_pack_bitstream_final_time: return "av1_pack_bitstream_final_time";
1929 case av1_encode_frame_time: return "av1_encode_frame_time";
1930 case av1_compute_global_motion_time:
1931 return "av1_compute_global_motion_time";
1932 case av1_setup_motion_field_time: return "av1_setup_motion_field_time";
1933 case encode_sb_row_time: return "encode_sb_row_time";
1934
1935 case rd_pick_partition_time: return "rd_pick_partition_time";
1936 case rd_use_partition_time: return "rd_use_partition_time";
1937 case choose_var_based_partitioning_time:
1938 return "choose_var_based_partitioning_time";
1939 case av1_prune_partitions_time: return "av1_prune_partitions_time";
1940 case none_partition_search_time: return "none_partition_search_time";
1941 case split_partition_search_time: return "split_partition_search_time";
1942 case rectangular_partition_search_time:
1943 return "rectangular_partition_search_time";
1944 case ab_partitions_search_time: return "ab_partitions_search_time";
1945 case rd_pick_4partition_time: return "rd_pick_4partition_time";
1946 case encode_sb_time: return "encode_sb_time";
1947
1948 case rd_pick_sb_modes_time: return "rd_pick_sb_modes_time";
1949 case av1_rd_pick_intra_mode_sb_time:
1950 return "av1_rd_pick_intra_mode_sb_time";
1951 case av1_rd_pick_inter_mode_sb_time:
1952 return "av1_rd_pick_inter_mode_sb_time";
1953 case set_params_rd_pick_inter_mode_time:
1954 return "set_params_rd_pick_inter_mode_time";
1955 case skip_inter_mode_time: return "skip_inter_mode_time";
1956 case handle_inter_mode_time: return "handle_inter_mode_time";
1957 case evaluate_motion_mode_for_winner_candidates_time:
1958 return "evaluate_motion_mode_for_winner_candidates_time";
1959 case do_tx_search_time: return "do_tx_search_time";
1960 case handle_intra_mode_time: return "handle_intra_mode_time";
1961 case refine_winner_mode_tx_time: return "refine_winner_mode_tx_time";
1962 case av1_search_palette_mode_time: return "av1_search_palette_mode_time";
1963 case handle_newmv_time: return "handle_newmv_time";
1964 case compound_type_rd_time: return "compound_type_rd_time";
1965 case interpolation_filter_search_time:
1966 return "interpolation_filter_search_time";
1967 case motion_mode_rd_time: return "motion_mode_rd_time";
1968
1969 case nonrd_use_partition_time: return "nonrd_use_partition_time";
1970 case pick_sb_modes_nonrd_time: return "pick_sb_modes_nonrd_time";
1971 case hybrid_intra_mode_search_time: return "hybrid_intra_mode_search_time";
1972 case nonrd_pick_inter_mode_sb_time: return "nonrd_pick_inter_mode_sb_time";
1973 case encode_b_nonrd_time: return "encode_b_nonrd_time";
1974
1975 default: assert(0);
1976 }
1977 return "error";
1978}
1979#endif
1980
1981// The maximum number of internal ARFs except ALTREF_FRAME
1982#define MAX_INTERNAL_ARFS (REF_FRAMES - BWDREF_FRAME - 1)
1983
1985
1989typedef struct {
1994
2000 YV12_BUFFER_CONFIG *ref_buf[REF_FRAMES];
2001
2007 int num_ref_frames[MAX_DIRECTIONS];
2008
2015 FrameDistPair reference_frames[MAX_DIRECTIONS][REF_FRAMES - 1];
2016
2025
2035typedef struct {
2036 int width;
2039
2054
2058typedef struct {
2078 fractional_mv_step_fp *find_fractional_mv_step;
2085 search_site_config search_site_cfg[SS_CFG_TOTAL][NUM_DISTINCT_SEARCH_METHODS];
2087
2101
2109typedef struct {
2110 int width;
2113
2117typedef struct {
2121 int ref_relative_dist[INTER_REFS_PER_FRAME];
2131
2147typedef struct {
2155 unsigned int coeff_opt_thresholds[MODE_EVAL_TYPES][2];
2156
2161 TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES];
2162
2169 unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES];
2170
2176 unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES];
2177
2183 unsigned int skip_txfm_level[MODE_EVAL_TYPES];
2184
2190 unsigned int predict_dc_level[MODE_EVAL_TYPES];
2192
2211
2258
2260
2261typedef struct {
2262 // Some misc info
2263 int high_prec;
2264 int q;
2265 int order;
2266
2267 // MV counters
2268 int inter_count;
2269 int intra_count;
2270 int default_mvs;
2271 int mv_joint_count[4];
2272 int last_bit_zero;
2273 int last_bit_nonzero;
2274
2275 // Keep track of the rates
2276 int total_mv_rate;
2277 int hp_total_mv_rate;
2278 int lp_total_mv_rate;
2279
2280 // Texture info
2281 int horz_text;
2282 int vert_text;
2283 int diag_text;
2284
2285 // Whether the current struct contains valid data
2286 int valid;
2287} MV_STATS;
2288
2289typedef struct WeberStats {
2290 int64_t mb_wiener_variance;
2291 int64_t src_variance;
2292 int64_t rec_variance;
2293 int16_t src_pix_max;
2294 int16_t rec_pix_max;
2295 int64_t distortion;
2296 int64_t satd;
2297 double max_scale;
2298} WeberStats;
2299
2300typedef struct {
2301 struct loopfilter lf;
2302 CdefInfo cdef_info;
2303 YV12_BUFFER_CONFIG copy_buffer;
2304 RATE_CONTROL rc;
2305 MV_STATS mv_stats;
2306} CODING_CONTEXT;
2307
2308typedef struct {
2309 int frame_width;
2310 int frame_height;
2311 int mi_rows;
2312 int mi_cols;
2313 int mb_rows;
2314 int mb_cols;
2315 int num_mbs;
2316 aom_bit_depth_t bit_depth;
2317 int subsampling_x;
2318 int subsampling_y;
2319} FRAME_INFO;
2320
2324typedef struct {
2325 int show_frame_count;
2326} FRAME_INDEX_SET;
2327
2329
2333typedef struct {
2339 uint8_t *map;
2347
2351typedef struct {
2364} TimeStamps;
2365
2370typedef struct {
2374 tran_low_t *tcoeff;
2378 uint16_t *eobs;
2382 uint8_t *entropy_ctx;
2384
2385#if !CONFIG_REALTIME_ONLY
2387// DUCKY_ENCODE_FRAME_MODE is c version of EncodeFrameMode
2388enum {
2389 DUCKY_ENCODE_FRAME_MODE_NONE, // Let native AV1 determine q index and rdmult
2390 DUCKY_ENCODE_FRAME_MODE_QINDEX, // DuckyEncode determines q index and AV1
2391 // determines rdmult
2392 DUCKY_ENCODE_FRAME_MODE_QINDEX_RDMULT, // DuckyEncode determines q index and
2393 // rdmult
2394} UENUM1BYTE(DUCKY_ENCODE_FRAME_MODE);
2395
2396enum {
2397 DUCKY_ENCODE_GOP_MODE_NONE, // native AV1 decides GOP
2398 DUCKY_ENCODE_GOP_MODE_RCL, // rate control lib decides GOP
2399} UENUM1BYTE(DUCKY_ENCODE_GOP_MODE);
2400
2401typedef struct DuckyEncodeFrameInfo {
2402 DUCKY_ENCODE_FRAME_MODE qp_mode;
2403 DUCKY_ENCODE_GOP_MODE gop_mode;
2404 int q_index;
2405 int rdmult;
2406 // These two arrays are equivalent to std::vector<SuperblockEncodeParameters>
2407 int *superblock_encode_qindex;
2408 int *superblock_encode_rdmult;
2409 int delta_q_enabled;
2410} DuckyEncodeFrameInfo;
2411
2412typedef struct DuckyEncodeFrameResult {
2413 int global_order_idx;
2414 int q_index;
2415 int rdmult;
2416 int rate;
2417 int64_t dist;
2418 double psnr;
2419} DuckyEncodeFrameResult;
2420
2421typedef struct DuckyEncodeInfo {
2422 DuckyEncodeFrameInfo frame_info;
2423 DuckyEncodeFrameResult frame_result;
2424} DuckyEncodeInfo;
2426#endif
2427
2429typedef struct RTC_REF {
2434 int reference[INTER_REFS_PER_FRAME];
2435 int ref_idx[INTER_REFS_PER_FRAME];
2436 int refresh[REF_FRAMES];
2437 int set_ref_frame_config;
2438 int non_reference_frame;
2439 int ref_frame_comp[3];
2440 int gld_idx_1layer;
2444 unsigned int buffer_time_index[REF_FRAMES];
2448 unsigned char buffer_spatial_layer[REF_FRAMES];
2452 bool reference_was_previous_frame;
2457 bool bias_recovery_frame;
2458} RTC_REF;
2460
2464typedef struct AV1_COMP_DATA {
2468 unsigned char *cx_data;
2469
2474
2479
2483 unsigned int lib_flags;
2484
2489
2494
2499
2503 const aom_rational64_t *timestamp_ratio;
2504
2509
2515
2519typedef struct AV1_PRIMARY {
2524
2530#if CONFIG_FPMT_TEST
2536 FPMT_TEST_ENC_CFG fpmt_unit_test_cfg;
2537
2541 FrameProbInfo temp_frame_probs;
2542
2548 FrameProbInfo temp_frame_probs_simulation;
2549
2554 int temp_valid_gm_model_found[FRAME_UPDATE_TYPES];
2555#endif // CONFIG_FPMT_TEST
2561 RefCntBuffer *ref_frame_map_copy[REF_FRAMES];
2562
2567
2572
2577
2582
2587
2592
2597 struct AV1_COMP *cpi;
2598
2603
2607 struct lookahead_ctx *lookahead;
2608
2615
2620 struct aom_codec_pkt_list *output_pkt_list;
2621
2626
2631
2636
2640 GF_STATE gf_state;
2641
2646
2650 AV1LevelParams level_params;
2651
2656
2661
2666
2671
2680 SequenceHeader seq_params;
2681
2686
2691
2696
2701
2705 struct aom_internal_error_info error;
2706
2712 aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL];
2713
2719
2724
2728 MV_STATS mv_stats;
2729
2730#if CONFIG_INTERNAL_STATS
2732 uint64_t total_time_receive_data;
2733 uint64_t total_time_compress_data;
2734
2735 unsigned int total_mode_chosen_counts[MAX_MODES];
2736
2737 int count[2];
2738 uint64_t total_sq_error[2];
2739 uint64_t total_samples[2];
2740 ImageStat psnr[2];
2741
2742 double total_blockiness;
2743 double worst_blockiness;
2744
2745 int total_bytes;
2746 double summed_quality;
2747 double summed_weights;
2748 double summed_quality_hbd;
2749 double summed_weights_hbd;
2750 unsigned int total_recode_hits;
2751 double worst_ssim;
2752 double worst_ssim_hbd;
2753
2754 ImageStat fastssim;
2755 ImageStat psnrhvs;
2756
2757 int b_calculate_blockiness;
2758 int b_calculate_consistency;
2759
2760 double total_inconsistency;
2761 double worst_consistency;
2762 Ssimv *ssim_vars;
2763 Metrics metrics;
2765#endif
2766
2767#if CONFIG_ENTROPY_STATS
2771 FRAME_COUNTS aggregate_fc;
2772#endif // CONFIG_ENTROPY_STATS
2773
2780 int fb_of_context_type[REF_FRAMES];
2781
2786
2791
2798 int valid_gm_model_found[FRAME_UPDATE_TYPES];
2799
2803 RTC_REF rtc_ref;
2804
2811
2815typedef struct AV1_COMP {
2820
2825 EncQuantDequantParams enc_quant_dequant_params;
2826
2830 ThreadData td;
2831
2835 FRAME_COUNTS counts;
2836
2841
2848
2854
2858 AV1_COMMON common;
2859
2864
2869 TRELLIS_OPT_TYPE optimize_seg_arr[MAX_SEGMENTS];
2870
2876 YV12_BUFFER_CONFIG *source;
2877
2885 YV12_BUFFER_CONFIG *last_source;
2886
2891 YV12_BUFFER_CONFIG *unscaled_source;
2892
2896 YV12_BUFFER_CONFIG scaled_source;
2897
2901 YV12_BUFFER_CONFIG *unscaled_last_source;
2902
2906 YV12_BUFFER_CONFIG scaled_last_source;
2907
2912 YV12_BUFFER_CONFIG *unfiltered_source;
2913
2918 YV12_BUFFER_CONFIG orig_source;
2919
2924
2934
2939
2944
2949 RefCntBuffer *scaled_ref_buf[INTER_REFS_PER_FRAME];
2950
2954 RefCntBuffer *last_show_frame_buf;
2955
2960
2965
2970
2975 YV12_BUFFER_CONFIG last_frame_uf;
2976
2981 YV12_BUFFER_CONFIG trial_frame_rst;
2982
2987
2991 RD_OPT rd;
2992
2997 CODING_CONTEXT coding_context;
2998
3003
3008
3013
3018
3023
3028
3033
3038
3043
3049
3054
3063 ActiveMap active_map;
3064
3068 unsigned char gf_frame_index;
3069
3070#if CONFIG_INTERNAL_STATS
3072 uint64_t time_compress_data;
3073
3074 unsigned int mode_chosen_counts[MAX_MODES];
3075 int bytes;
3076 unsigned int frame_recode_hits;
3078#endif
3079
3080#if CONFIG_SPEED_STATS
3084 unsigned int tx_search_count;
3085#endif // CONFIG_SPEED_STATS
3086
3092
3096 FRAME_INFO frame_info;
3097
3101 FRAME_INDEX_SET frame_index_set;
3102
3107
3115
3120
3125 TileDataEnc *tile_data;
3130
3134 TokenInfo token_info;
3135
3140
3145
3150
3155
3160
3165
3170
3175
3176#if CONFIG_FPMT_TEST
3181 double temp_framerate;
3182#endif
3189
3194
3199
3206
3211
3216
3220 AV1LrStruct lr_ctxt;
3221
3225 aom_film_grain_table_t *film_grain_table;
3226
3227#if CONFIG_DENOISE
3232 struct aom_denoise_and_model_t *denoise_and_model;
3233#endif
3234
3239
3248
3256
3257#if CONFIG_COLLECT_PARTITION_STATS
3261 FramePartitionTimingStats partition_stats;
3262#endif // CONFIG_COLLECT_PARTITION_STATS
3263
3264#if CONFIG_COLLECT_COMPONENT_TIMING
3268 uint64_t component_time[kTimingComponents];
3273 struct aom_usec_timer component_timer[kTimingComponents];
3277 uint64_t frame_component_time[kTimingComponents];
3278#endif
3279
3284
3289
3294
3301
3302#if CONFIG_TUNE_VMAF
3306 TuneVMAFInfo vmaf_info;
3307#endif
3308
3309#if CONFIG_TUNE_BUTTERAUGLI
3313 TuneButteraugliInfo butteraugli_info;
3314#endif
3315
3320
3324 COMPRESSOR_STAGE compressor_stage;
3325
3331
3336
3343
3347 FirstPassData firstpass_data;
3348
3352 NOISE_ESTIMATE noise_estimate;
3353
3354#if CONFIG_AV1_TEMPORAL_DENOISING
3358 AV1_DENOISER denoiser;
3359#endif
3360
3366
3371
3375 BLOCK_SIZE fp_block_size;
3376
3382
3387
3392 ExtPartController ext_part_controller;
3393
3398 MV_STATS mv_stats;
3403
3409
3416#if CONFIG_FPMT_TEST
3422
3423 int wanted_fb;
3424#endif // CONFIG_FPMT_TEST
3425
3432
3433#if CONFIG_RD_COMMAND
3437 RD_COMMAND rd_command;
3438#endif // CONFIG_RD_COMMAND
3439
3443 WeberStats *mb_weber_stats;
3444
3450
3456
3461
3465 BLOCK_SIZE weber_bsize;
3466
3471
3476
3481
3482#if CONFIG_BITRATE_ACCURACY
3486 VBR_RATECTRL_INFO vbr_rc_info;
3487#endif
3488
3489#if CONFIG_RATECTRL_LOG
3493 RATECTRL_LOG rc_log;
3494#endif // CONFIG_RATECTRL_LOG
3495
3500
3504 THIRD_PASS_DEC_CTX *third_pass_ctx;
3505
3510
3515
3519 uint64_t rec_sse;
3520
3526
3527#if !CONFIG_REALTIME_ONLY
3531 DuckyEncodeInfo ducky_encode_info;
3532#endif // CONFIG_REALTIME_ONLY
3533 //
3538
3542 unsigned int zeromv_skip_thresh_exit_part[BLOCK_SIZES_ALL];
3543
3549
3550#if CONFIG_SALIENCY_MAP
3554 uint8_t *saliency_map;
3555
3559 double *sm_scaling_factor;
3560#endif
3561
3568
3572typedef struct EncodeFrameInput {
3574 YV12_BUFFER_CONFIG *source;
3575 YV12_BUFFER_CONFIG *last_source;
3576 int64_t ts_duration;
3579
3584typedef struct EncodeFrameParams {
3592 FRAME_TYPE frame_type;
3593
3595 int primary_ref_frame;
3596 int order_offset;
3597
3603
3605 int refresh_frame_flags;
3606
3607 int show_existing_frame;
3608 int existing_fb_idx_to_show;
3609
3615
3619 int remapped_ref_idx[REF_FRAMES];
3620
3626
3632
3634
3635// EncodeFrameResults contains information about the result of encoding a
3636// single frame
3637typedef struct {
3638 size_t size; // Size of resulting bitstream
3639} EncodeFrameResults;
3640
3641void av1_initialize_enc(unsigned int usage, enum aom_rc_mode end_usage);
3642
3643struct AV1_COMP *av1_create_compressor(AV1_PRIMARY *ppi,
3644 const AV1EncoderConfig *oxcf,
3645 BufferPool *const pool,
3646 COMPRESSOR_STAGE stage,
3647 int lap_lag_in_frames);
3648
3649struct AV1_PRIMARY *av1_create_primary_compressor(
3650 struct aom_codec_pkt_list *pkt_list_head, int num_lap_buffers,
3651 const AV1EncoderConfig *oxcf);
3652
3653void av1_remove_compressor(AV1_COMP *cpi);
3654
3655void av1_remove_primary_compressor(AV1_PRIMARY *ppi);
3656
3657#if CONFIG_ENTROPY_STATS
3658void print_entropy_stats(AV1_PRIMARY *const ppi);
3659#endif
3660#if CONFIG_INTERNAL_STATS
3661void print_internal_stats(AV1_PRIMARY *ppi);
3662#endif
3663
3664void av1_change_config_seq(AV1_PRIMARY *ppi, const AV1EncoderConfig *oxcf,
3665 bool *sb_size_changed);
3666
3667void av1_change_config(AV1_COMP *cpi, const AV1EncoderConfig *oxcf,
3668 bool sb_size_changed);
3669
3670void av1_check_initial_width(AV1_COMP *cpi, int use_highbitdepth,
3671 int subsampling_x, int subsampling_y);
3672
3673void av1_init_seq_coding_tools(AV1_PRIMARY *const ppi,
3674 const AV1EncoderConfig *oxcf, int use_svc);
3675
3676void av1_post_encode_updates(AV1_COMP *const cpi,
3677 const AV1_COMP_DATA *const cpi_data);
3678
3679void av1_scale_references_fpmt(AV1_COMP *cpi, int *ref_buffers_used_map);
3680
3681void av1_increment_scaled_ref_counts_fpmt(BufferPool *buffer_pool,
3682 int ref_buffers_used_map);
3683
3684void av1_release_scaled_references_fpmt(AV1_COMP *cpi);
3685
3686void av1_decrement_ref_counts_fpmt(BufferPool *buffer_pool,
3687 int ref_buffers_used_map);
3688
3689void av1_init_sc_decisions(AV1_PRIMARY *const ppi);
3690
3691AV1_COMP *av1_get_parallel_frame_enc_data(AV1_PRIMARY *const ppi,
3692 AV1_COMP_DATA *const first_cpi_data);
3693
3694int av1_init_parallel_frame_context(const AV1_COMP_DATA *const first_cpi_data,
3695 AV1_PRIMARY *const ppi,
3696 int *ref_buffers_used_map);
3698
3716 YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
3717 int64_t end_time_stamp);
3718
3738int av1_get_compressed_data(AV1_COMP *cpi, AV1_COMP_DATA *const cpi_data);
3739
3746int av1_encode(AV1_COMP *const cpi, uint8_t *const dest,
3747 const EncodeFrameInput *const frame_input,
3748 const EncodeFrameParams *const frame_params,
3749 EncodeFrameResults *const frame_results);
3750
3752int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest);
3753
3754int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame);
3755
3756aom_codec_err_t av1_copy_new_frame_enc(AV1_COMMON *cm,
3757 YV12_BUFFER_CONFIG *new_frame,
3758 YV12_BUFFER_CONFIG *sd);
3759
3760int av1_use_as_reference(int *ext_ref_frame_flags, int ref_frame_flags);
3761
3762int av1_copy_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
3763
3764int av1_set_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
3765
3766int av1_set_size_literal(AV1_COMP *cpi, int width, int height);
3767
3768void av1_set_frame_size(AV1_COMP *cpi, int width, int height);
3769
3770void av1_set_mv_search_params(AV1_COMP *cpi);
3771
3772int av1_set_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
3773
3774int av1_get_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
3775
3776int av1_set_internal_size(AV1EncoderConfig *const oxcf,
3777 ResizePendingParams *resize_pending_params,
3778 AOM_SCALING_MODE horiz_mode,
3779 AOM_SCALING_MODE vert_mode);
3780
3781int av1_get_quantizer(struct AV1_COMP *cpi);
3782
3783int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t *input_size);
3784
3785// Set screen content options.
3786// This function estimates whether to use screen content tools, by counting
3787// the portion of blocks that have few luma colors.
3788// Modifies:
3789// cpi->commom.features.allow_screen_content_tools
3790// cpi->common.features.allow_intrabc
3791// cpi->use_screen_content_tools
3792// cpi->is_screen_content_type
3793// However, the estimation is not accurate and may misclassify videos.
3794// A slower but more accurate approach that determines whether to use screen
3795// content tools is employed later. See av1_determine_sc_tools_with_encoding().
3796void av1_set_screen_content_options(struct AV1_COMP *cpi,
3797 FeatureFlags *features);
3798
3799void av1_update_frame_size(AV1_COMP *cpi);
3800
3801typedef struct {
3802 int pyr_level;
3803 int disp_order;
3804} RefFrameMapPair;
3805
3806static INLINE void init_ref_map_pair(
3807 AV1_COMP *cpi, RefFrameMapPair ref_frame_map_pairs[REF_FRAMES]) {
3808 if (cpi->ppi->gf_group.update_type[cpi->gf_frame_index] == KF_UPDATE) {
3809 memset(ref_frame_map_pairs, -1, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
3810 return;
3811 }
3812 memset(ref_frame_map_pairs, 0, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
3813 for (int map_idx = 0; map_idx < REF_FRAMES; map_idx++) {
3814 // Get reference frame buffer.
3815 const RefCntBuffer *const buf = cpi->common.ref_frame_map[map_idx];
3816 if (ref_frame_map_pairs[map_idx].disp_order == -1) continue;
3817 if (buf == NULL) {
3818 ref_frame_map_pairs[map_idx].disp_order = -1;
3819 ref_frame_map_pairs[map_idx].pyr_level = -1;
3820 continue;
3821 } else if (buf->ref_count > 1) {
3822 // Once the keyframe is coded, the slots in ref_frame_map will all
3823 // point to the same frame. In that case, all subsequent pointers
3824 // matching the current are considered "free" slots. This will find
3825 // the next occurrence of the current pointer if ref_count indicates
3826 // there are multiple instances of it and mark it as free.
3827 for (int idx2 = map_idx + 1; idx2 < REF_FRAMES; ++idx2) {
3828 const RefCntBuffer *const buf2 = cpi->common.ref_frame_map[idx2];
3829 if (buf2 == buf) {
3830 ref_frame_map_pairs[idx2].disp_order = -1;
3831 ref_frame_map_pairs[idx2].pyr_level = -1;
3832 }
3833 }
3834 }
3835 ref_frame_map_pairs[map_idx].disp_order = (int)buf->display_order_hint;
3836 ref_frame_map_pairs[map_idx].pyr_level = buf->pyramid_level;
3837 }
3838}
3839
3840#if CONFIG_FPMT_TEST
3841static AOM_INLINE void calc_frame_data_update_flag(
3842 GF_GROUP *const gf_group, int gf_frame_index,
3843 bool *const do_frame_data_update) {
3844 *do_frame_data_update = true;
3845 // Set the flag to false for all frames in a given parallel encode set except
3846 // the last frame in the set with frame_parallel_level = 2.
3847 if (gf_group->frame_parallel_level[gf_frame_index] == 1) {
3848 *do_frame_data_update = false;
3849 } else if (gf_group->frame_parallel_level[gf_frame_index] == 2) {
3850 // Check if this is the last frame in the set with frame_parallel_level = 2.
3851 for (int i = gf_frame_index + 1; i < gf_group->size; i++) {
3852 if ((gf_group->frame_parallel_level[i] == 0 &&
3853 (gf_group->update_type[i] == ARF_UPDATE ||
3854 gf_group->update_type[i] == INTNL_ARF_UPDATE)) ||
3855 gf_group->frame_parallel_level[i] == 1) {
3856 break;
3857 } else if (gf_group->frame_parallel_level[i] == 2) {
3858 *do_frame_data_update = false;
3859 break;
3860 }
3861 }
3862 }
3863}
3864#endif
3865
3866// av1 uses 10,000,000 ticks/second as time stamp
3867#define TICKS_PER_SEC 10000000LL
3868
3869static INLINE int64_t
3870timebase_units_to_ticks(const aom_rational64_t *timestamp_ratio, int64_t n) {
3871 return n * timestamp_ratio->num / timestamp_ratio->den;
3872}
3873
3874static INLINE int64_t
3875ticks_to_timebase_units(const aom_rational64_t *timestamp_ratio, int64_t n) {
3876 int64_t round = timestamp_ratio->num / 2;
3877 if (round > 0) --round;
3878 return (n * timestamp_ratio->den + round) / timestamp_ratio->num;
3879}
3880
3881static INLINE int frame_is_kf_gf_arf(const AV1_COMP *cpi) {
3882 const GF_GROUP *const gf_group = &cpi->ppi->gf_group;
3883 const FRAME_UPDATE_TYPE update_type =
3884 gf_group->update_type[cpi->gf_frame_index];
3885
3886 return frame_is_intra_only(&cpi->common) || update_type == ARF_UPDATE ||
3887 update_type == GF_UPDATE;
3888}
3889
3890// TODO(huisu@google.com, youzhou@microsoft.com): enable hash-me for HBD.
3891static INLINE int av1_use_hash_me(const AV1_COMP *const cpi) {
3894 frame_is_intra_only(&cpi->common));
3895}
3896
3897static INLINE const YV12_BUFFER_CONFIG *get_ref_frame_yv12_buf(
3898 const AV1_COMMON *const cm, MV_REFERENCE_FRAME ref_frame) {
3899 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
3900 return buf != NULL ? &buf->buf : NULL;
3901}
3902
3903static INLINE void alloc_frame_mvs(AV1_COMMON *const cm, RefCntBuffer *buf) {
3904 assert(buf != NULL);
3905 ensure_mv_buffer(buf, cm);
3906 buf->width = cm->width;
3907 buf->height = cm->height;
3908}
3909
3910// Get the allocated token size for a tile. It does the same calculation as in
3911// the frame token allocation.
3912static INLINE unsigned int allocated_tokens(const TileInfo *tile,
3913 int sb_size_log2, int num_planes) {
3914 int tile_mb_rows =
3915 ROUND_POWER_OF_TWO(tile->mi_row_end - tile->mi_row_start, 2);
3916 int tile_mb_cols =
3917 ROUND_POWER_OF_TWO(tile->mi_col_end - tile->mi_col_start, 2);
3918
3919 return get_token_alloc(tile_mb_rows, tile_mb_cols, sb_size_log2, num_planes);
3920}
3921
3922static INLINE void get_start_tok(AV1_COMP *cpi, int tile_row, int tile_col,
3923 int mi_row, TokenExtra **tok, int sb_size_log2,
3924 int num_planes) {
3925 AV1_COMMON *const cm = &cpi->common;
3926 const int tile_cols = cm->tiles.cols;
3927 TileDataEnc *this_tile = &cpi->tile_data[tile_row * tile_cols + tile_col];
3928 const TileInfo *const tile_info = &this_tile->tile_info;
3929
3930 const int tile_mb_cols =
3931 (tile_info->mi_col_end - tile_info->mi_col_start + 2) >> 2;
3932 const int tile_mb_row = (mi_row - tile_info->mi_row_start + 2) >> 2;
3933
3934 *tok = cpi->token_info.tile_tok[tile_row][tile_col] +
3935 get_token_alloc(tile_mb_row, tile_mb_cols, sb_size_log2, num_planes);
3936}
3937
3938void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags);
3939
3940#define ALT_MIN_LAG 3
3941static INLINE int is_altref_enabled(int lag_in_frames, bool enable_auto_arf) {
3942 return lag_in_frames >= ALT_MIN_LAG && enable_auto_arf;
3943}
3944
3945static AOM_INLINE int can_disable_altref(const GFConfig *gf_cfg) {
3946 return is_altref_enabled(gf_cfg->lag_in_frames, gf_cfg->enable_auto_arf) &&
3947 (gf_cfg->gf_min_pyr_height == 0);
3948}
3949
3950// Helper function to compute number of blocks on either side of the frame.
3951static INLINE int get_num_blocks(const int frame_length, const int mb_length) {
3952 return (frame_length + mb_length - 1) / mb_length;
3953}
3954
3955// Check if statistics generation stage
3956static INLINE int is_stat_generation_stage(const AV1_COMP *const cpi) {
3957 assert(IMPLIES(cpi->compressor_stage == LAP_STAGE,
3958 cpi->oxcf.pass == AOM_RC_ONE_PASS && cpi->ppi->lap_enabled));
3959 return (cpi->oxcf.pass == AOM_RC_FIRST_PASS ||
3960 (cpi->compressor_stage == LAP_STAGE));
3961}
3962// Check if statistics consumption stage
3963static INLINE int is_stat_consumption_stage_twopass(const AV1_COMP *const cpi) {
3964 return (cpi->oxcf.pass >= AOM_RC_SECOND_PASS);
3965}
3966
3967// Check if statistics consumption stage
3968static INLINE int is_stat_consumption_stage(const AV1_COMP *const cpi) {
3969 return (is_stat_consumption_stage_twopass(cpi) ||
3970 (cpi->oxcf.pass == AOM_RC_ONE_PASS &&
3971 (cpi->compressor_stage == ENCODE_STAGE) && cpi->ppi->lap_enabled));
3972}
3973
3974// Decide whether 'dv_costs' need to be allocated/stored during the encoding.
3975static AOM_INLINE bool av1_need_dv_costs(const AV1_COMP *const cpi) {
3976 return !cpi->sf.rt_sf.use_nonrd_pick_mode &&
3977 av1_allow_intrabc(&cpi->common) && !is_stat_generation_stage(cpi);
3978}
3979
3989static INLINE int has_no_stats_stage(const AV1_COMP *const cpi) {
3990 assert(
3991 IMPLIES(!cpi->ppi->lap_enabled, cpi->compressor_stage == ENCODE_STAGE));
3992 return (cpi->oxcf.pass == AOM_RC_ONE_PASS && !cpi->ppi->lap_enabled);
3993}
3994
3996
3997static INLINE int is_one_pass_rt_params(const AV1_COMP *cpi) {
3998 return has_no_stats_stage(cpi) && cpi->oxcf.mode == REALTIME &&
3999 cpi->oxcf.gf_cfg.lag_in_frames == 0;
4000}
4001
4002// Use default/internal reference structure for single-layer RTC.
4003static INLINE int use_rtc_reference_structure_one_layer(const AV1_COMP *cpi) {
4004 return is_one_pass_rt_params(cpi) && cpi->ppi->number_spatial_layers == 1 &&
4005 cpi->ppi->number_temporal_layers == 1 &&
4006 !cpi->ppi->rtc_ref.set_ref_frame_config;
4007}
4008
4009// Function return size of frame stats buffer
4010static INLINE int get_stats_buf_size(int num_lap_buffer, int num_lag_buffer) {
4011 /* if lookahead is enabled return num_lap_buffers else num_lag_buffers */
4012 return (num_lap_buffer > 0 ? num_lap_buffer + 1 : num_lag_buffer);
4013}
4014
4015// TODO(zoeliu): To set up cpi->oxcf.gf_cfg.enable_auto_brf
4016
4017static INLINE void set_ref_ptrs(const AV1_COMMON *cm, MACROBLOCKD *xd,
4018 MV_REFERENCE_FRAME ref0,
4019 MV_REFERENCE_FRAME ref1) {
4021 get_ref_scale_factors_const(cm, ref0 >= LAST_FRAME ? ref0 : 1);
4023 get_ref_scale_factors_const(cm, ref1 >= LAST_FRAME ? ref1 : 1);
4024}
4025
4026static INLINE int get_chessboard_index(int frame_index) {
4027 return frame_index & 0x1;
4028}
4029
4030static INLINE const int *cond_cost_list_const(const struct AV1_COMP *cpi,
4031 const int *cost_list) {
4032 const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
4033 cpi->sf.mv_sf.use_fullpel_costlist;
4034 return use_cost_list ? cost_list : NULL;
4035}
4036
4037static INLINE int *cond_cost_list(const struct AV1_COMP *cpi, int *cost_list) {
4038 const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
4039 cpi->sf.mv_sf.use_fullpel_costlist;
4040 return use_cost_list ? cost_list : NULL;
4041}
4042
4043// Compression ratio of current frame.
4044double av1_get_compression_ratio(const AV1_COMMON *const cm,
4045 size_t encoded_frame_size);
4046
4047void av1_new_framerate(AV1_COMP *cpi, double framerate);
4048
4049void av1_setup_frame_size(AV1_COMP *cpi);
4050
4051#define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl))
4052
4053// Returns 1 if a frame is scaled and 0 otherwise.
4054static INLINE int av1_resize_scaled(const AV1_COMMON *cm) {
4055 return cm->superres_upscaled_width != cm->render_width ||
4057}
4058
4059static INLINE int av1_frame_scaled(const AV1_COMMON *cm) {
4060 return av1_superres_scaled(cm) || av1_resize_scaled(cm);
4061}
4062
4063// Don't allow a show_existing_frame to coincide with an error resilient
4064// frame. An exception can be made for a forward keyframe since it has no
4065// previous dependencies.
4066static INLINE int encode_show_existing_frame(const AV1_COMMON *cm) {
4068 cm->current_frame.frame_type == KEY_FRAME);
4069}
4070
4071// Get index into the 'cpi->mbmi_ext_info.frame_base' array for the given
4072// 'mi_row' and 'mi_col'.
4073static INLINE int get_mi_ext_idx(const int mi_row, const int mi_col,
4074 const BLOCK_SIZE mi_alloc_bsize,
4075 const int mbmi_ext_stride) {
4076 const int mi_ext_size_1d = mi_size_wide[mi_alloc_bsize];
4077 const int mi_ext_row = mi_row / mi_ext_size_1d;
4078 const int mi_ext_col = mi_col / mi_ext_size_1d;
4079 return mi_ext_row * mbmi_ext_stride + mi_ext_col;
4080}
4081
4082// Lighter version of set_offsets that only sets the mode info
4083// pointers.
4084static INLINE void set_mode_info_offsets(
4085 const CommonModeInfoParams *const mi_params,
4086 const MBMIExtFrameBufferInfo *const mbmi_ext_info, MACROBLOCK *const x,
4087 MACROBLOCKD *const xd, int mi_row, int mi_col) {
4088 set_mi_offsets(mi_params, xd, mi_row, mi_col);
4089 const int ext_idx = get_mi_ext_idx(mi_row, mi_col, mi_params->mi_alloc_bsize,
4090 mbmi_ext_info->stride);
4091 x->mbmi_ext_frame = mbmi_ext_info->frame_base + ext_idx;
4092}
4093
4094// Check to see if the given partition size is allowed for a specified number
4095// of mi block rows and columns remaining in the image.
4096// If not then return the largest allowed partition size
4097static INLINE BLOCK_SIZE find_partition_size(BLOCK_SIZE bsize, int rows_left,
4098 int cols_left, int *bh, int *bw) {
4099 int int_size = (int)bsize;
4100 if (rows_left <= 0 || cols_left <= 0) {
4101 return AOMMIN(bsize, BLOCK_8X8);
4102 } else {
4103 for (; int_size > 0; int_size -= 3) {
4104 *bh = mi_size_high[int_size];
4105 *bw = mi_size_wide[int_size];
4106 if ((*bh <= rows_left) && (*bw <= cols_left)) {
4107 break;
4108 }
4109 }
4110 }
4111 return (BLOCK_SIZE)int_size;
4112}
4113
4114static const uint8_t av1_ref_frame_flag_list[REF_FRAMES] = { 0,
4115 AOM_LAST_FLAG,
4116 AOM_LAST2_FLAG,
4117 AOM_LAST3_FLAG,
4118 AOM_GOLD_FLAG,
4119 AOM_BWD_FLAG,
4120 AOM_ALT2_FLAG,
4121 AOM_ALT_FLAG };
4122
4123// When more than 'max_allowed_refs' are available, we reduce the number of
4124// reference frames one at a time based on this order.
4125static const MV_REFERENCE_FRAME disable_order[] = {
4126 LAST3_FRAME,
4127 LAST2_FRAME,
4128 ALTREF2_FRAME,
4129 BWDREF_FRAME,
4130};
4131
4132static const MV_REFERENCE_FRAME
4133 ref_frame_priority_order[INTER_REFS_PER_FRAME] = {
4134 LAST_FRAME, ALTREF_FRAME, BWDREF_FRAME, GOLDEN_FRAME,
4135 ALTREF2_FRAME, LAST2_FRAME, LAST3_FRAME,
4136 };
4137
4138static INLINE int get_ref_frame_flags(const SPEED_FEATURES *const sf,
4139 const int use_one_pass_rt_params,
4140 const YV12_BUFFER_CONFIG **ref_frames,
4141 const int ext_ref_frame_flags) {
4142 // cpi->ext_flags.ref_frame_flags allows certain reference types to be
4143 // disabled by the external interface. These are set by
4144 // av1_apply_encoding_flags(). Start with what the external interface allows,
4145 // then suppress any reference types which we have found to be duplicates.
4146 int flags = ext_ref_frame_flags;
4147
4148 for (int i = 1; i < INTER_REFS_PER_FRAME; ++i) {
4149 const YV12_BUFFER_CONFIG *const this_ref = ref_frames[i];
4150 // If this_ref has appeared before, mark the corresponding ref frame as
4151 // invalid. For one_pass_rt mode, only disable GOLDEN_FRAME if it's the
4152 // same as LAST_FRAME or ALTREF_FRAME (if ALTREF is being used in nonrd).
4153 int index =
4154 (use_one_pass_rt_params && ref_frame_priority_order[i] == GOLDEN_FRAME)
4155 ? (1 + sf->rt_sf.use_nonrd_altref_frame)
4156 : i;
4157 for (int j = 0; j < index; ++j) {
4158 // If this_ref has appeared before (same as the reference corresponding
4159 // to lower index j), remove it as a reference only if that reference
4160 // (for index j) is actually used as a reference.
4161 if (this_ref == ref_frames[j] &&
4162 (flags & (1 << (ref_frame_priority_order[j] - 1)))) {
4163 flags &= ~(1 << (ref_frame_priority_order[i] - 1));
4164 break;
4165 }
4166 }
4167 }
4168 return flags;
4169}
4170
4171// Returns a Sequence Header OBU stored in an aom_fixed_buf_t, or NULL upon
4172// failure. When a non-NULL aom_fixed_buf_t pointer is returned by this
4173// function, the memory must be freed by the caller. Both the buf member of the
4174// aom_fixed_buf_t, and the aom_fixed_buf_t pointer itself must be freed. Memory
4175// returned must be freed via call to free().
4176//
4177// Note: The OBU returned is in Low Overhead Bitstream Format. Specifically,
4178// the obu_has_size_field bit is set, and the buffer contains the obu_size
4179// field.
4180aom_fixed_buf_t *av1_get_global_headers(AV1_PRIMARY *ppi);
4181
4182#define MAX_GFUBOOST_FACTOR 10.0
4183#define MIN_GFUBOOST_FACTOR 4.0
4184
4185static INLINE int is_frame_tpl_eligible(const GF_GROUP *const gf_group,
4186 uint8_t index) {
4187 const FRAME_UPDATE_TYPE update_type = gf_group->update_type[index];
4188 return update_type == ARF_UPDATE || update_type == GF_UPDATE ||
4189 update_type == KF_UPDATE;
4190}
4191
4192static INLINE int is_frame_eligible_for_ref_pruning(const GF_GROUP *gf_group,
4193 int selective_ref_frame,
4194 int prune_ref_frames,
4195 int gf_index) {
4196 return (selective_ref_frame > 0) && (prune_ref_frames > 0) &&
4197 !is_frame_tpl_eligible(gf_group, gf_index);
4198}
4199
4200// Get update type of the current frame.
4201static INLINE FRAME_UPDATE_TYPE get_frame_update_type(const GF_GROUP *gf_group,
4202 int gf_frame_index) {
4203 return gf_group->update_type[gf_frame_index];
4204}
4205
4206static INLINE int av1_pixels_to_mi(int pixels) {
4207 return ALIGN_POWER_OF_TWO(pixels, 3) >> MI_SIZE_LOG2;
4208}
4209
4210static AOM_INLINE int is_psnr_calc_enabled(const AV1_COMP *cpi) {
4211 const AV1_COMMON *const cm = &cpi->common;
4212
4213 return cpi->ppi->b_calculate_psnr && !is_stat_generation_stage(cpi) &&
4214 cm->show_frame;
4215}
4216
4217static INLINE int is_frame_resize_pending(const AV1_COMP *const cpi) {
4218 const ResizePendingParams *const resize_pending_params =
4220 return (resize_pending_params->width && resize_pending_params->height &&
4221 (cpi->common.width != resize_pending_params->width ||
4222 cpi->common.height != resize_pending_params->height));
4223}
4224
4225// Check if loop filter is used.
4226static INLINE int is_loopfilter_used(const AV1_COMMON *const cm) {
4227 return !cm->features.coded_lossless && !cm->tiles.large_scale;
4228}
4229
4230// Check if CDEF is used.
4231static INLINE int is_cdef_used(const AV1_COMMON *const cm) {
4232 return cm->seq_params->enable_cdef && !cm->features.coded_lossless &&
4233 !cm->tiles.large_scale;
4234}
4235
4236// Check if loop restoration filter is used.
4237static INLINE int is_restoration_used(const AV1_COMMON *const cm) {
4238 return cm->seq_params->enable_restoration && !cm->features.all_lossless &&
4239 !cm->tiles.large_scale;
4240}
4241
4242// Checks if post-processing filters need to be applied.
4243// NOTE: This function decides if the application of different post-processing
4244// filters on the reconstructed frame can be skipped at the encoder side.
4245// However the computation of different filter parameters that are signaled in
4246// the bitstream is still required.
4247static INLINE unsigned int derive_skip_apply_postproc_filters(
4248 const AV1_COMP *cpi, int use_loopfilter, int use_cdef, int use_superres,
4249 int use_restoration) {
4250 // Though CDEF parameter selection should be dependent on
4251 // deblocked/loop-filtered pixels for cdef_pick_method <=
4252 // CDEF_FAST_SEARCH_LVL5, CDEF strength values are calculated based on the
4253 // pixel values that are not loop-filtered in svc real-time encoding mode.
4254 // Hence this case is handled separately using the condition below.
4255 if (cpi->ppi->rtc_ref.non_reference_frame)
4256 return (SKIP_APPLY_LOOPFILTER | SKIP_APPLY_CDEF);
4257
4259 return 0;
4260 assert(cpi->oxcf.mode == ALLINTRA);
4261
4262 // The post-processing filters are applied one after the other in the
4263 // following order: deblocking->cdef->superres->restoration. In case of
4264 // ALLINTRA encoding, the reconstructed frame is not used as a reference
4265 // frame. Hence, the application of these filters can be skipped when
4266 // 1. filter parameters of the subsequent stages are not dependent on the
4267 // filtered output of the current stage or
4268 // 2. subsequent filtering stages are disabled
4269 if (use_restoration) return SKIP_APPLY_RESTORATION;
4270 if (use_superres) return SKIP_APPLY_SUPERRES;
4271 if (use_cdef) {
4272 // CDEF parameter selection is not dependent on the deblocked frame if
4273 // cdef_pick_method is CDEF_PICK_FROM_Q. Hence the application of deblocking
4274 // filters and cdef filters can be skipped in this case.
4275 return (cpi->sf.lpf_sf.cdef_pick_method == CDEF_PICK_FROM_Q &&
4276 use_loopfilter)
4277 ? (SKIP_APPLY_LOOPFILTER | SKIP_APPLY_CDEF)
4278 : SKIP_APPLY_CDEF;
4279 }
4280 if (use_loopfilter) return SKIP_APPLY_LOOPFILTER;
4281
4282 // If we reach here, all post-processing stages are disabled, so none need to
4283 // be skipped.
4284 return 0;
4285}
4286
4287static INLINE void set_postproc_filter_default_params(AV1_COMMON *cm) {
4288 struct loopfilter *const lf = &cm->lf;
4289 CdefInfo *const cdef_info = &cm->cdef_info;
4290 RestorationInfo *const rst_info = cm->rst_info;
4291
4292 lf->filter_level[0] = 0;
4293 lf->filter_level[1] = 0;
4294 cdef_info->cdef_bits = 0;
4295 cdef_info->cdef_strengths[0] = 0;
4296 cdef_info->nb_cdef_strengths = 1;
4297 cdef_info->cdef_uv_strengths[0] = 0;
4301}
4302
4303static INLINE int is_inter_tx_size_search_level_one(
4304 const TX_SPEED_FEATURES *tx_sf) {
4305 return (tx_sf->inter_tx_size_search_init_depth_rect >= 1 &&
4306 tx_sf->inter_tx_size_search_init_depth_sqr >= 1);
4307}
4308
4309static INLINE int get_lpf_opt_level(const SPEED_FEATURES *sf) {
4310 int lpf_opt_level = 0;
4311 if (is_inter_tx_size_search_level_one(&sf->tx_sf))
4312 lpf_opt_level = (sf->lpf_sf.lpf_pick == LPF_PICK_FROM_Q) ? 2 : 1;
4313 return lpf_opt_level;
4314}
4315
4316// Enable switchable motion mode only if warp and OBMC tools are allowed
4317static INLINE bool is_switchable_motion_mode_allowed(bool allow_warped_motion,
4318 bool enable_obmc) {
4319 return (allow_warped_motion || enable_obmc);
4320}
4321
4322#if CONFIG_AV1_TEMPORAL_DENOISING
4323static INLINE int denoise_svc(const struct AV1_COMP *const cpi) {
4324 return (!cpi->ppi->use_svc ||
4325 (cpi->ppi->use_svc &&
4326 cpi->svc.spatial_layer_id >= cpi->svc.first_layer_denoise));
4327}
4328#endif
4329
4330#if CONFIG_COLLECT_PARTITION_STATS == 2
4331static INLINE void av1_print_fr_partition_timing_stats(
4332 const FramePartitionTimingStats *part_stats, const char *filename) {
4333 FILE *f = fopen(filename, "w");
4334 if (!f) {
4335 return;
4336 }
4337
4338 fprintf(f, "bsize,redo,");
4339 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4340 fprintf(f, "decision_%d,", part);
4341 }
4342 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4343 fprintf(f, "attempt_%d,", part);
4344 }
4345 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4346 fprintf(f, "time_%d,", part);
4347 }
4348 fprintf(f, "\n");
4349
4350 static const int bsizes[6] = { 128, 64, 32, 16, 8, 4 };
4351
4352 for (int bsize_idx = 0; bsize_idx < 6; bsize_idx++) {
4353 fprintf(f, "%d,%d,", bsizes[bsize_idx], part_stats->partition_redo);
4354 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4355 fprintf(f, "%d,", part_stats->partition_decisions[bsize_idx][part]);
4356 }
4357 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4358 fprintf(f, "%d,", part_stats->partition_attempts[bsize_idx][part]);
4359 }
4360 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4361 fprintf(f, "%ld,", part_stats->partition_times[bsize_idx][part]);
4362 }
4363 fprintf(f, "\n");
4364 }
4365 fclose(f);
4366}
4367#endif // CONFIG_COLLECT_PARTITION_STATS == 2
4368
4369#if CONFIG_COLLECT_PARTITION_STATS
4370static INLINE int av1_get_bsize_idx_for_part_stats(BLOCK_SIZE bsize) {
4371 assert(bsize == BLOCK_128X128 || bsize == BLOCK_64X64 ||
4372 bsize == BLOCK_32X32 || bsize == BLOCK_16X16 || bsize == BLOCK_8X8 ||
4373 bsize == BLOCK_4X4);
4374 switch (bsize) {
4375 case BLOCK_128X128: return 0;
4376 case BLOCK_64X64: return 1;
4377 case BLOCK_32X32: return 2;
4378 case BLOCK_16X16: return 3;
4379 case BLOCK_8X8: return 4;
4380 case BLOCK_4X4: return 5;
4381 default: assert(0 && "Invalid bsize for partition_stats."); return -1;
4382 }
4383}
4384#endif // CONFIG_COLLECT_PARTITION_STATS
4385
4386#if CONFIG_COLLECT_COMPONENT_TIMING
4387static INLINE void start_timing(AV1_COMP *cpi, int component) {
4388 aom_usec_timer_start(&cpi->component_timer[component]);
4389}
4390static INLINE void end_timing(AV1_COMP *cpi, int component) {
4391 aom_usec_timer_mark(&cpi->component_timer[component]);
4392 cpi->frame_component_time[component] +=
4393 aom_usec_timer_elapsed(&cpi->component_timer[component]);
4394}
4395static INLINE char const *get_frame_type_enum(int type) {
4396 switch (type) {
4397 case 0: return "KEY_FRAME";
4398 case 1: return "INTER_FRAME";
4399 case 2: return "INTRA_ONLY_FRAME";
4400 case 3: return "S_FRAME";
4401 default: assert(0);
4402 }
4403 return "error";
4404}
4405#endif
4406
4408
4409#ifdef __cplusplus
4410} // extern "C"
4411#endif
4412
4413#endif // AOM_AV1_ENCODER_ENCODER_H_
enum aom_chroma_sample_position aom_chroma_sample_position_t
List of chroma sample positions.
enum aom_transfer_characteristics aom_transfer_characteristics_t
List of supported transfer functions.
enum aom_color_range aom_color_range_t
List of supported color range.
enum aom_color_primaries aom_color_primaries_t
List of supported color primaries.
enum aom_matrix_coefficients aom_matrix_coefficients_t
List of supported matrix coefficients.
Provides definitions for using AOM or AV1 encoder algorithm within the aom Codec Interface.
struct macroblock MACROBLOCK
Encoder's parameters related to the current coding block.
COST_UPDATE_TYPE
This enum controls how often the entropy costs should be updated.
Definition encoder.h:217
@ COST_UPD_SBROW
Definition encoder.h:219
@ COST_UPD_TILE
Definition encoder.h:220
@ COST_UPD_OFF
Definition encoder.h:221
@ NUM_COST_UPDATE_TYPES
Definition encoder.h:222
@ COST_UPD_SB
Definition encoder.h:218
LOOPFILTER_CONTROL
This enum controls to which frames loopfilter is applied.
Definition encoder.h:228
@ LOOPFILTER_ALL
Definition encoder.h:230
@ LOOPFILTER_SELECTIVELY
Definition encoder.h:232
@ LOOPFILTER_REFERENCE
Definition encoder.h:231
@ LOOPFILTER_NONE
Definition encoder.h:229
#define NUM_RECODES_PER_FRAME
Max number of recodes used to track the frame probabilities.
Definition encoder.h:1588
struct inter_modes_info InterModesInfo
Struct used to hold inter mode data for fast tx search.
SKIP_APPLY_POSTPROC_FILTER
This enum controls the application of post-processing filters on a reconstructed frame.
Definition encoder.h:240
#define MAX_PARALLEL_FRAMES
Max number of frames that can be encoded in a parallel encode set.
Definition encoder.h:1593
@ RESTORE_NONE
Definition enums.h:612
@ RESTORE_SWITCHABLE_TYPES
Definition enums.h:616
aom_dist_metric
Distortion metric to use for RD optimization.
Definition aomcx.h:1641
aom_tune_content
Definition aomcx.h:1602
enum aom_scaling_mode_1d AOM_SCALING_MODE
aom 1-D scaling mode
aom_tune_metric
Model tuning parameters.
Definition aomcx.h:1621
enum aom_bit_depth aom_bit_depth_t
Bit depth for codecThis enumeration determines the bit depth of the codec.
enum aom_superblock_size aom_superblock_size_t
Superblock size selection.
aom_codec_err_t
Algorithm return codes.
Definition aom_codec.h:155
aom_superres_mode
Frame super-resolution mode.
Definition aom_encoder.h:205
aom_rc_mode
Rate control mode.
Definition aom_encoder.h:183
aom_enc_pass
Multi-pass Encoding Pass.
Definition aom_encoder.h:174
struct aom_fixed_buf aom_fixed_buf_t
Generic fixed size buffer structure.
long aom_enc_frame_flags_t
Encoded Frame Flags.
Definition aom_encoder.h:375
@ AOM_RC_ONE_PASS
Definition aom_encoder.h:175
@ AOM_RC_SECOND_PASS
Definition aom_encoder.h:177
@ AOM_RC_FIRST_PASS
Definition aom_encoder.h:176
int av1_get_compressed_data(AV1_COMP *cpi, AV1_COMP_DATA *const cpi_data)
Encode a frame.
Definition encoder.c:4693
int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags, YV12_BUFFER_CONFIG *sd, int64_t time_stamp, int64_t end_time_stamp)
Obtain the raw frame data.
Definition encoder.c:4089
int av1_encode(AV1_COMP *const cpi, uint8_t *const dest, const EncodeFrameInput *const frame_input, const EncodeFrameParams *const frame_params, EncodeFrameResults *const frame_results)
Run 1-pass/2-pass encoding.
Definition encoder.c:3991
static int has_no_stats_stage(const AV1_COMP *const cpi)
Check if the current stage has statistics.
Definition encoder.h:3989
Describes look ahead buffer operations.
@ CDEF_PICK_FROM_Q
Definition speed_features.h:170
RestorationInfo rst_info[3]
Definition av1_common_int.h:948
int superres_upscaled_width
Definition av1_common_int.h:801
int superres_upscaled_height
Definition av1_common_int.h:802
SequenceHeader * seq_params
Definition av1_common_int.h:978
int width
Definition av1_common_int.h:777
CdefInfo cdef_info
Definition av1_common_int.h:957
CurrentFrame current_frame
Definition av1_common_int.h:756
int show_existing_frame
Definition av1_common_int.h:902
struct loopfilter lf
Definition av1_common_int.h:941
FeatureFlags features
Definition av1_common_int.h:907
int show_frame
Definition av1_common_int.h:887
RefCntBuffer * ref_frame_map[REF_FRAMES]
Definition av1_common_int.h:880
CommonTileParams tiles
Definition av1_common_int.h:994
int height
Definition av1_common_int.h:778
int render_width
Definition av1_common_int.h:788
int render_height
Definition av1_common_int.h:789
Encoder data related to multi-threading for allintra deltaq-mode=3.
Definition encoder.h:1558
pthread_mutex_t * mutex_
Definition encoder.h:1563
void(* intra_sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int)
Definition encoder.h:1577
pthread_cond_t * cond_
Definition encoder.h:1567
void(* intra_sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int)
Definition encoder.h:1581
Encoder data related to row-based multi-threading.
Definition encoder.h:1488
int allocated_sb_rows
Definition encoder.h:1527
pthread_mutex_t * mutex_
Definition encoder.h:1533
int allocated_tile_cols
Definition encoder.h:1496
int allocated_cols
Definition encoder.h:1510
int thread_id_to_tile_id[64]
Definition encoder.h:1515
void(* sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int)
Definition encoder.h:1551
pthread_cond_t * cond_
Definition encoder.h:1537
int allocated_tile_rows
Definition encoder.h:1492
int allocated_rows
Definition encoder.h:1503
int * num_tile_cols_done
Definition encoder.h:1521
void(* sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int)
Definition encoder.h:1547
Encoder parameters for synchronization of row based multi-threading.
Definition encoder.h:1375
int rows
Definition encoder.h:1408
int sync_range
Definition encoder.h:1397
int intrabc_extra_top_right_sb_delay
Definition encoder.h:1404
int next_mi_row
Definition encoder.h:1412
int * num_finished_cols
Definition encoder.h:1390
pthread_mutex_t * mutex_
Definition encoder.h:1381
pthread_cond_t * cond_
Definition encoder.h:1382
int num_threads_working
Definition encoder.h:1416
Main encoder configuration data structure.
Definition encoder.h:915
RateControlCfg rc_cfg
Definition encoder.h:937
KeyFrameCfg kf_cfg
Definition encoder.h:932
enum aom_enc_pass pass
Definition encoder.h:1040
AlgoCfg algo_cfg
Definition encoder.h:927
aom_fixed_buf_t twopass_stats_in
Definition encoder.h:954
Structure to hold data corresponding to an encoded frame.
Definition encoder.h:2464
int64_t ts_frame_end
Definition encoder.h:2493
int pop_lookahead
Definition encoder.h:2508
int64_t ts_frame_start
Definition encoder.h:2488
unsigned char * cx_data
Definition encoder.h:2468
size_t cx_data_sz
Definition encoder.h:2473
int flush
Definition encoder.h:2498
int frame_display_order_hint
Definition encoder.h:2513
unsigned int lib_flags
Definition encoder.h:2483
size_t frame_size
Definition encoder.h:2478
const aom_rational64_t * timestamp_ratio
Definition encoder.h:2503
Top level encoder structure.
Definition encoder.h:2815
double * ext_rate_distribution
Definition encoder.h:3455
int do_update_frame_probs_warp[10]
Definition encoder.h:3169
uint8_t * consec_zero_mv
Definition encoder.h:3365
int do_update_frame_probs_obmc[10]
Definition encoder.h:3164
struct aom_denoise_and_model_t * denoise_and_model
Definition encoder.h:3232
int skip_tpl_setup_stats
Definition encoder.h:2923
int frames_since_last_update
Definition encoder.h:3537
int * mb_delta_q
Definition encoder.h:3475
int vaq_refresh
Definition encoder.h:3139
FRAME_TYPE last_frame_type
Definition encoder.h:3330
YV12_BUFFER_CONFIG * unscaled_source
Definition encoder.h:2891
int palette_pixel_num
Definition encoder.h:3566
CYCLIC_REFRESH * cyclic_refresh
Definition encoder.h:3058
InitialDimensions initial_dimensions
Definition encoder.h:3106
RATE_CONTROL rc
Definition encoder.h:3017
int deltaq_used
Definition encoder.h:3288
ActiveMap active_map
Definition encoder.h:3063
WeberStats * mb_weber_stats
Definition encoder.h:3443
bool refresh_idx_available
Definition encoder.h:3408
TokenInfo token_info
Definition encoder.h:3134
int64_t ambient_err
Definition encoder.h:2986
aom_film_grain_table_t * film_grain_table
Definition encoder.h:3225
int ref_refresh_index
Definition encoder.h:3402
size_t available_bs_size
Definition encoder.h:3386
SPEED_FEATURES sf
Definition encoder.h:3037
TRELLIS_OPT_TYPE optimize_seg_arr[8]
Definition encoder.h:2869
ExtPartController ext_part_controller
Definition encoder.h:3392
FILE * second_pass_log_stream
Definition encoder.h:3509
double * ssim_rdmult_scaling_factors
Definition encoder.h:3300
RD_OPT rd
Definition encoder.h:2991
int num_tg
Definition encoder.h:3335
WinnerModeParams winner_mode_params
Definition encoder.h:3007
ExternalFlags ext_flags
Definition encoder.h:2969
EncSegmentationInfo enc_seg
Definition encoder.h:3053
MotionVectorSearchParams mv_search_params
Definition encoder.h:3042
int use_screen_content_tools
Definition encoder.h:3247
int do_update_frame_probs_interpfilter[10]
Definition encoder.h:3174
CODING_CONTEXT coding_context
Definition encoder.h:2997
TemporalFilterCtx tf_ctx
Definition encoder.h:2938
int image_pyramid_levels
Definition encoder.h:3548
ForceIntegerMVInfo force_intpel_info
Definition encoder.h:2943
GlobalMotionInfo gm_info
Definition encoder.h:3002
int consec_zero_mv_alloc_size
Definition encoder.h:3370
CoeffBufferPool coeff_buffer_pool
Definition encoder.h:2853
FRAME_INDEX_SET frame_index_set
Definition encoder.h:3101
int ref_frame_flags
Definition encoder.h:3027
RefCntBuffer * scaled_ref_buf[INTER_REFS_PER_FRAME]
Definition encoder.h:2949
unsigned char gf_frame_index
Definition encoder.h:3068
AV1EncoderConfig oxcf
Definition encoder.h:2863
AV1_COMMON common
Definition encoder.h:2858
AV1LrStruct lr_ctxt
Definition encoder.h:3220
bool do_frame_data_update
Definition encoder.h:3431
int do_update_frame_probs_txtype[10]
Definition encoder.h:3159
FRAME_COUNTS counts
Definition encoder.h:2835
COMPRESSOR_STAGE compressor_stage
Definition encoder.h:3324
int intrabc_used
Definition encoder.h:3210
int num_frame_recode
Definition encoder.h:3149
int rt_reduce_num_ref_buffers
Definition encoder.h:2964
RefreshFrameInfo refresh_frame
Definition encoder.h:2959
int prune_ref_frame_mask
Definition encoder.h:3215
YV12_BUFFER_CONFIG * unscaled_last_source
Definition encoder.h:2901
THIRD_PASS_DEC_CTX * third_pass_ctx
Definition encoder.h:3504
int all_one_sided_refs
Definition encoder.h:3048
MultiThreadInfo mt_info
Definition encoder.h:3198
VarBasedPartitionInfo vbp_info
Definition encoder.h:3144
YV12_BUFFER_CONFIG * last_source
Definition encoder.h:2885
int existing_fb_idx_to_show
Definition encoder.h:3205
YV12_BUFFER_CONFIG * unfiltered_source
Definition encoder.h:2912
unsigned int zeromv_skip_thresh_exit_part[BLOCK_SIZES_ALL]
Definition encoder.h:3542
FRAME_INFO frame_info
Definition encoder.h:3096
int frame_header_count
Definition encoder.h:3283
int droppable
Definition encoder.h:3091
RefCntBuffer * last_show_frame_buf
Definition encoder.h:2954
aom_superres_mode superres_mode
Definition encoder.h:3342
MBMIExtFrameBufferInfo mbmi_ext_info
Definition encoder.h:2840
double new_framerate
Definition encoder.h:3188
AV1_PRIMARY * ppi
Definition encoder.h:2819
uint64_t * src_sad_blk_64x64
Definition encoder.h:3514
int64_t norm_wiener_variance
Definition encoder.h:3470
double * tpl_rdmult_scaling_factors
Definition encoder.h:2933
int sb_counter
Definition encoder.h:3381
TileDataEnc * tile_data
Definition encoder.h:3125
int is_screen_content_type
Definition encoder.h:3255
BLOCK_SIZE weber_bsize
Definition encoder.h:3465
InterpSearchFlags interp_search_flags
Definition encoder.h:3238
TimeStamps time_stamps
Definition encoder.h:3012
int ref_idx_to_skip
Definition encoder.h:3415
YV12_BUFFER_CONFIG orig_source
Definition encoder.h:2918
FirstPassData firstpass_data
Definition encoder.h:3347
double framerate
Definition encoder.h:3022
int speed
Definition encoder.h:3032
BLOCK_SIZE fp_block_size
Definition encoder.h:3375
int use_ducky_encode
Definition encoder.h:3525
YV12_BUFFER_CONFIG trial_frame_rst
Definition encoder.h:2981
bool is_dropped_frame
Definition encoder.h:3480
ThreadData td
Definition encoder.h:2830
ResizePendingParams resize_pending_params
Definition encoder.h:3119
YV12_BUFFER_CONFIG scaled_source
Definition encoder.h:2896
int do_update_vbr_bits_off_target_fast
Definition encoder.h:3193
YV12_BUFFER_CONFIG last_frame_uf
Definition encoder.h:2975
EncQuantDequantParams enc_quant_dequant_params
Definition encoder.h:2825
RefFrameDistanceInfo ref_frame_dist_info
Definition encoder.h:3293
int * prep_rate_estimates
Definition encoder.h:3449
DuckyEncodeInfo ducky_encode_info
Definition encoder.h:3531
double ext_rate_scale
Definition encoder.h:3460
int initial_mbs
Definition encoder.h:3114
uint64_t rec_sse
Definition encoder.h:3519
YV12_BUFFER_CONFIG scaled_last_source
Definition encoder.h:2906
MV_STATS mv_stats
Definition encoder.h:3398
FrameProbInfo frame_new_probs[10]
Definition encoder.h:3154
YV12_BUFFER_CONFIG * source
Definition encoder.h:2876
int allocated_tiles
Definition encoder.h:3129
SVC svc
Definition encoder.h:3319
CB_COEFF_BUFFER * coeff_buffer_base
Definition encoder.h:2847
NOISE_ESTIMATE noise_estimate
Definition encoder.h:3352
TWO_PASS_FRAME twopass_frame
Definition encoder.h:3499
Top level primary encoder structure.
Definition encoder.h:2519
int num_fp_contexts
Definition encoder.h:2576
AV1EncRowMultiThreadSync intra_row_mt_sync
Definition encoder.h:2809
bool buffer_removal_time_present
Definition encoder.h:2690
int valid_gm_model_found[FRAME_UPDATE_TYPES]
Definition encoder.h:2798
struct aom_codec_pkt_list * output_pkt_list
Definition encoder.h:2620
int filter_level[2]
Definition encoder.h:2581
SequenceHeader seq_params
Definition encoder.h:2680
MV_STATS mv_stats
Definition encoder.h:2728
struct AV1_COMP * cpi
Definition encoder.h:2597
AV1LevelParams level_params
Definition encoder.h:2650
int internal_altref_allowed
Definition encoder.h:2625
RTC_REF rtc_ref
Definition encoder.h:2803
int b_calculate_psnr
Definition encoder.h:2655
PrimaryMultiThreadInfo p_mt_info
Definition encoder.h:2785
TEMPORAL_FILTER_INFO tf_info
Definition encoder.h:2675
TWO_PASS twopass
Definition encoder.h:2665
int frames_left
Definition encoder.h:2660
int64_t ts_start_last_show_frame
Definition encoder.h:2566
PRIMARY_RATE_CONTROL p_rc
Definition encoder.h:2670
int lap_enabled
Definition encoder.h:2645
FrameProbInfo frame_probs
Definition encoder.h:2790
int show_existing_alt_ref
Definition encoder.h:2630
int fb_of_context_type[REF_FRAMES]
Definition encoder.h:2780
int use_svc
Definition encoder.h:2685
double * tpl_sb_rdmult_scaling_factors
Definition encoder.h:2718
int filter_level_v
Definition encoder.h:2591
int filter_level_u
Definition encoder.h:2586
struct AV1_COMP * cpi_lap
Definition encoder.h:2602
struct AV1_COMP * parallel_cpi[4]
Definition encoder.h:2523
int64_t ts_end_last_show_frame
Definition encoder.h:2571
struct lookahead_ctx * lookahead
Definition encoder.h:2607
RefCntBuffer * ref_frame_map_copy[REF_FRAMES]
Definition encoder.h:2561
GF_STATE gf_state
Definition encoder.h:2640
aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL]
Definition encoder.h:2712
GF_GROUP gf_group
Definition encoder.h:2635
struct AV1_COMP_DATA parallel_frames_data[4 - 1]
Definition encoder.h:2529
TplParams tpl_data
Definition encoder.h:2723
unsigned int number_temporal_layers
Definition encoder.h:2695
unsigned int number_spatial_layers
Definition encoder.h:2700
int seq_params_locked
Definition encoder.h:2614
struct aom_internal_error_info error
Definition encoder.h:2705
Algorithm configuration parameters.
Definition encoder.h:809
int disable_trellis_quant
Definition encoder.h:825
int sharpness
Definition encoder.h:816
bool skip_postproc_filtering
Definition encoder.h:869
int arnr_max_frames
Definition encoder.h:830
bool enable_tpl_model
Definition encoder.h:848
LOOPFILTER_CONTROL loopfilter_control
Definition encoder.h:863
uint8_t cdf_update_mode
Definition encoder.h:843
bool enable_overlay
Definition encoder.h:854
int arnr_strength
Definition encoder.h:835
Stores the transforms coefficients for the whole superblock.
Definition block.h:206
The stucture of CYCLIC_REFRESH.
Definition aq_cyclicrefresh.h:36
Parameters related to CDEF.
Definition av1_common_int.h:198
int cdef_bits
Number of CDEF strength values in bits.
Definition av1_common_int.h:220
int cdef_uv_strengths[16]
CDEF strength values for chroma.
Definition av1_common_int.h:218
int cdef_strengths[16]
CDEF strength values for luma.
Definition av1_common_int.h:216
int nb_cdef_strengths
Number of CDEF strength values.
Definition av1_common_int.h:214
Definition encoder.h:2370
uint8_t * entropy_ctx
Definition encoder.h:2382
tran_low_t * tcoeff
Definition encoder.h:2374
uint16_t * eobs
Definition encoder.h:2378
Params related to MB_MODE_INFO arrays and related info.
Definition av1_common_int.h:503
BLOCK_SIZE mi_alloc_bsize
Definition av1_common_int.h:552
int cols
Definition av1_common_int.h:430
unsigned int large_scale
Definition av1_common_int.h:490
Encoder flags for compound prediction modes.
Definition encoder.h:395
bool enable_masked_comp
Definition encoder.h:404
bool enable_diff_wtd_comp
Definition encoder.h:412
bool enable_smooth_interintra
Definition encoder.h:408
bool enable_interintra_wedge
Definition encoder.h:420
bool enable_interinter_wedge
Definition encoder.h:416
bool enable_dist_wtd_comp
Definition encoder.h:399
Segmentation related information for the current frame.
Definition encoder.h:2333
uint8_t * map
Definition encoder.h:2339
bool has_lossless_segment
Definition encoder.h:2345
Input frames and last input frame.
Definition encoder.h:3572
contains per-frame encoding parameters decided upon by av1_encode_strategy() and passed down to av1_e...
Definition encoder.h:3584
int error_resilient_mode
Definition encoder.h:3588
int remapped_ref_idx[REF_FRAMES]
Definition encoder.h:3619
int ref_frame_flags
Definition encoder.h:3614
int speed
Definition encoder.h:3630
FRAME_TYPE frame_type
Definition encoder.h:3592
int show_frame
Definition encoder.h:3602
RefreshFrameInfo refresh_frame
Definition encoder.h:3625
Frame refresh flags set by the external interface.
Definition encoder.h:2200
bool golden_frame
Definition encoder.h:2202
bool bwd_ref_frame
Definition encoder.h:2203
bool update_pending
Definition encoder.h:2209
bool last_frame
Definition encoder.h:2201
bool alt_ref_frame
Definition encoder.h:2205
bool alt2_ref_frame
Definition encoder.h:2204
Flags signalled by the external interface at frame level.
Definition encoder.h:2215
bool use_primary_ref_none
Definition encoder.h:2256
bool use_ref_frame_mvs
Definition encoder.h:2240
ExtRefreshFrameFlagsInfo refresh_frame
Definition encoder.h:2224
int ref_frame_flags
Definition encoder.h:2219
bool use_error_resilient
Definition encoder.h:2245
bool use_s_frame
Definition encoder.h:2250
bool refresh_frame_context
Definition encoder.h:2229
bool refresh_frame_context_pending
Definition encoder.h:2235
Frame level features.
Definition av1_common_int.h:360
bool allow_screen_content_tools
Definition av1_common_int.h:377
bool allow_intrabc
Definition av1_common_int.h:378
bool coded_lossless
Definition av1_common_int.h:387
bool error_resilient_mode
Definition av1_common_int.h:402
bool all_lossless
Definition av1_common_int.h:391
Encoder info used for decision on forcing integer motion vectors.
Definition encoder.h:1780
double cs_rate_array[32]
Definition encoder.h:1785
int rate_size
Definition encoder.h:1793
int rate_index
Definition encoder.h:1789
Encoder-side probabilities for pruning of various AV1 tools.
Definition encoder.h:1103
int switchable_interp_probs[FRAME_UPDATE_TYPES][((SWITCHABLE_FILTERS+1) *4)][SWITCHABLE_FILTERS]
Definition encoder.h:1133
int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL]
Definition encoder.h:1109
int warped_probs[FRAME_UPDATE_TYPES]
Definition encoder.h:1116
int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES]
Definition encoder.h:1124
Data related to the current GF/ARF group and the individual frames within the group.
Definition firstpass.h:354
Parameters related to global motion search.
Definition encoder.h:1989
FrameDistPair reference_frames[2][REF_FRAMES - 1]
Definition encoder.h:2015
bool search_done
Definition encoder.h:1993
int segment_map_h
Definition encoder.h:2022
int num_ref_frames[2]
Definition encoder.h:2007
YV12_BUFFER_CONFIG * ref_buf[REF_FRAMES]
Definition encoder.h:2000
int segment_map_w
Definition encoder.h:2021
Initial frame dimensions.
Definition encoder.h:2035
int height
Definition encoder.h:2037
int width
Definition encoder.h:2036
Flags related to interpolation filter search.
Definition encoder.h:2043
int default_interp_skip_flags
Definition encoder.h:2048
uint16_t interp_filter_search_mask
Definition encoder.h:2052
Encoder flags for intra prediction.
Definition encoder.h:298
bool enable_diagonal_intra
Definition encoder.h:328
bool enable_smooth_intra
Definition encoder.h:311
bool auto_intra_tools_off
Definition encoder.h:347
bool enable_filter_intra
Definition encoder.h:307
bool enable_directional_intra
Definition encoder.h:323
bool enable_paeth_intra
Definition encoder.h:315
bool enable_intra_edge_filter
Definition encoder.h:302
bool enable_cfl_intra
Definition encoder.h:319
bool enable_angle_delta
Definition encoder.h:333
Encoder config related to the coding of key frames.
Definition encoder.h:462
int key_freq_max
Definition encoder.h:471
int sframe_mode
Definition encoder.h:489
bool auto_key
Definition encoder.h:494
bool enable_intrabc
Definition encoder.h:514
int sframe_dist
Definition encoder.h:482
bool enable_sframe
Definition encoder.h:509
int enable_keyframe_filtering
Definition encoder.h:476
int fwd_kf_dist
Definition encoder.h:499
int key_freq_min
Definition encoder.h:466
bool fwd_kf_enabled
Definition encoder.h:504
Buffer to store mode information at mi_alloc_bsize (4x4 or 8x8) level.
Definition encoder.h:1826
int alloc_size
Definition encoder.h:1835
int stride
Definition encoder.h:1839
MB_MODE_INFO_EXT_FRAME * frame_base
Definition encoder.h:1831
Stores best extended mode information at frame level.
Definition block.h:242
Stores the prediction/txfm mode of the current coding block.
Definition blockd.h:222
Parameters for motion vector search process.
Definition encoder.h:2058
int max_mv_magnitude
Definition encoder.h:2064
fractional_mv_step_fp * find_fractional_mv_step
Definition encoder.h:2078
int mv_step_param
Definition encoder.h:2069
search_site_config search_site_cfg[SS_CFG_TOTAL][NUM_DISTINCT_SEARCH_METHODS]
Definition encoder.h:2085
Encoder parameters related to multi-threading.
Definition encoder.h:1671
RestoreStateBuffers restore_state_buf
Definition encoder.h:1758
AV1CdefWorkerData * cdef_worker
Definition encoder.h:1753
AV1LrSync lr_row_sync
Definition encoder.h:1728
struct EncWorkerData * tile_thr_data
Definition encoder.h:1691
AV1TplRowMultiThreadInfo tpl_row_mt
Definition encoder.h:1718
AV1EncPackBSSync pack_bs_sync
Definition encoder.h:1733
AV1EncRowMultiThreadInfo enc_row_mt
Definition encoder.h:1707
AV1LfSync lf_row_sync
Definition encoder.h:1723
AV1CdefSync cdef_sync
Definition encoder.h:1748
int num_mod_workers[NUM_MT_MODULES]
Definition encoder.h:1680
AV1EncAllIntraMultiThreadInfo intra_mt
Definition encoder.h:1713
int num_workers
Definition encoder.h:1675
int pipeline_lpf_mt_with_enc
Definition encoder.h:1764
AVxWorker * workers
Definition encoder.h:1685
bool pack_bs_mt_enabled
Definition encoder.h:1702
bool row_mt_enabled
Definition encoder.h:1697
AV1TemporalFilterSync tf_sync
Definition encoder.h:1743
AV1GlobalMotionSync gm_sync
Definition encoder.h:1738
Primary Rate Control parameters and status.
Definition ratectrl.h:286
Encoder config for coding block partitioning.
Definition encoder.h:270
bool enable_rect_partitions
Definition encoder.h:274
bool enable_1to4_partitions
Definition encoder.h:282
BLOCK_SIZE max_partition_size
Definition encoder.h:292
bool enable_ab_partitions
Definition encoder.h:278
BLOCK_SIZE min_partition_size
Definition encoder.h:287
Primary Encoder parameters related to multi-threading.
Definition encoder.h:1624
struct EncWorkerData * tile_thr_data
Definition encoder.h:1644
AV1CdefWorkerData * cdef_worker
Definition encoder.h:1649
int num_workers
Definition encoder.h:1628
int prev_num_enc_workers
Definition encoder.h:1665
AVxWorker * workers
Definition encoder.h:1638
AVxWorker * p_workers[4]
Definition encoder.h:1655
int p_num_workers
Definition encoder.h:1660
int num_mod_workers[NUM_MT_MODULES]
Definition encoder.h:1633
Rate Control parameters and status.
Definition ratectrl.h:134
Encoder rate control configuration parameters.
Definition encoder.h:520
int worst_allowed_q
Definition encoder.h:590
int over_shoot_pct
Definition encoder.h:585
unsigned int max_intra_bitrate_pct
Definition encoder.h:555
int drop_frames_water_mark
Definition encoder.h:573
int vbrmax_section
Definition encoder.h:621
int64_t maximum_buffer_size_ms
Definition encoder.h:539
unsigned int vbr_corpus_complexity_lap
Definition encoder.h:550
unsigned int min_cr
Definition encoder.h:569
int vbrbias
Definition encoder.h:611
unsigned int gf_cbr_boost_pct
Definition encoder.h:564
int vbrmin_section
Definition encoder.h:616
enum aom_rc_mode mode
Definition encoder.h:604
unsigned int max_inter_bitrate_pct
Definition encoder.h:560
int64_t starting_buffer_level_ms
Definition encoder.h:529
int best_allowed_q
Definition encoder.h:595
int under_shoot_pct
Definition encoder.h:579
int64_t target_bandwidth
Definition encoder.h:544
int64_t optimal_buffer_level_ms
Definition encoder.h:534
int cq_level
Definition encoder.h:599
Refrence frame distance related variables.
Definition encoder.h:2117
int8_t nearest_past_ref
Definition encoder.h:2125
int ref_relative_dist[INTER_REFS_PER_FRAME]
Definition encoder.h:2121
int8_t nearest_future_ref
Definition encoder.h:2129
Refresh frame flags for different type of frames.
Definition encoder.h:2096
bool bwd_ref_frame
Definition encoder.h:2098
bool golden_frame
Definition encoder.h:2097
bool alt_ref_frame
Definition encoder.h:2099
Encoder config related to resize.
Definition encoder.h:250
uint8_t resize_scale_denominator
Definition encoder.h:259
uint8_t resize_kf_scale_denominator
Definition encoder.h:264
RESIZE_MODE resize_mode
Definition encoder.h:254
Desired dimensions for an externally triggered resize.
Definition encoder.h:2109
int width
Definition encoder.h:2110
int height
Definition encoder.h:2111
Parameters related to Restoration Info.
Definition restoration.h:256
RestorationType frame_restoration_type
Definition restoration.h:260
Buffers to be backed up during parallel encode set to be restored later.
Definition encoder.h:1599
int32_t * rst_tmpbuf
Definition encoder.h:1613
RestorationLineBuffers * rlbs
Definition encoder.h:1618
uint16_t * cdef_colbuf[3]
Definition encoder.h:1608
uint16_t * cdef_srcbuf
Definition encoder.h:1603
Top level speed vs quality trade off data struture.
Definition speed_features.h:1808
MV_SPEED_FEATURES mv_sf
Definition speed_features.h:1837
LOOP_FILTER_SPEED_FEATURES lpf_sf
Definition speed_features.h:1872
TX_SPEED_FEATURES tx_sf
Definition speed_features.h:1857
REAL_TIME_SPEED_FEATURES rt_sf
Definition speed_features.h:1877
The stucture of SVC.
Definition svc_layercontext.h:88
Encoder config related to frame super-resolution.
Definition encoder.h:426
uint8_t superres_kf_scale_denominator
Definition encoder.h:448
aom_superres_mode superres_mode
Definition encoder.h:452
int superres_kf_qthresh
Definition encoder.h:436
bool enable_superres
Definition encoder.h:456
uint8_t superres_scale_denominator
Definition encoder.h:442
int superres_qthresh
Definition encoder.h:431
Temporal filter info for a gop.
Definition temporal_filter.h:159
Frame level Two pass status and control data.
Definition firstpass.h:473
Two pass status and control data.
Definition firstpass.h:431
Parameters related to temporal filtering.
Definition temporal_filter.h:96
Frame time stamps.
Definition encoder.h:2351
int64_t prev_ts_start
Definition encoder.h:2355
int64_t first_ts_start
Definition encoder.h:2363
int64_t prev_ts_end
Definition encoder.h:2359
Params related to temporal dependency model.
Definition tpl_model.h:146
Encoder flags for transform sizes and types.
Definition encoder.h:353
bool enable_tx64
Definition encoder.h:357
bool use_inter_dct_only
Definition encoder.h:380
bool enable_flip_idtx
Definition encoder.h:361
bool use_intra_default_tx_only
Definition encoder.h:385
bool use_intra_dct_only
Definition encoder.h:375
bool enable_rect_tx
Definition encoder.h:365
bool reduced_tx_type_set
Definition encoder.h:370
bool enable_tx_size_search
Definition encoder.h:389
Thresholds for variance based partitioning.
Definition encoder.h:1354
int64_t thresholds[5]
Definition encoder.h:1363
int64_t threshold_minmax
Definition encoder.h:1369
Parameters used for winner mode processing.
Definition encoder.h:2147
unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES]
Definition encoder.h:2169
TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES]
Definition encoder.h:2161
unsigned int skip_txfm_level[MODE_EVAL_TYPES]
Definition encoder.h:2183
unsigned int coeff_opt_thresholds[MODE_EVAL_TYPES][2]
Definition encoder.h:2155
unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES]
Definition encoder.h:2176
unsigned int predict_dc_level[MODE_EVAL_TYPES]
Definition encoder.h:2190
Struct used to hold inter mode data for fast tx search.
Definition encoder.h:1259
RD_STATS rd_cost_arr[MAX_INTER_MODES]
Definition encoder.h:1288
int64_t est_rd_arr[MAX_INTER_MODES]
Definition encoder.h:1280
int64_t sse_arr[MAX_INTER_MODES]
Definition encoder.h:1276
RD_STATS rd_cost_y_arr[MAX_INTER_MODES]
Definition encoder.h:1292
RD_STATS rd_cost_uv_arr[MAX_INTER_MODES]
Definition encoder.h:1296
MB_MODE_INFO mbmi_arr[MAX_INTER_MODES]
Definition encoder.h:1268
RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES]
Definition encoder.h:1284
int mode_rate_arr[MAX_INTER_MODES]
Definition encoder.h:1272
int num
Definition encoder.h:1264
MB_MODE_INFO_EXT_FRAME * mbmi_ext_frame
Finalized mbmi_ext for the whole frame.
Definition block.h:910
const struct scale_factors * block_ref_scale_factors[2]
Definition blockd.h:687