AOMedia AV1 Codec
encoder.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016, Alliance for Open Media. All rights reserved
3  *
4  * This source code is subject to the terms of the BSD 2 Clause License and
5  * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6  * was not distributed with this source code in the LICENSE file, you can
7  * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8  * Media Patent License 1.0 was not distributed with this source code in the
9  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10  */
11 
15 #ifndef AOM_AV1_ENCODER_ENCODER_H_
16 #define AOM_AV1_ENCODER_ENCODER_H_
17 
18 #include <stdbool.h>
19 #include <stdio.h>
20 
21 #include "config/aom_config.h"
22 
23 #include "aom/aomcx.h"
24 #include "aom_util/aom_pthread.h"
25 
26 #include "av1/common/alloccommon.h"
27 #include "av1/common/av1_common_int.h"
28 #include "av1/common/blockd.h"
29 #include "av1/common/entropymode.h"
30 #include "av1/common/enums.h"
31 #include "av1/common/reconintra.h"
32 #include "av1/common/resize.h"
33 #include "av1/common/thread_common.h"
34 #include "av1/common/timing.h"
35 
36 #include "av1/encoder/aq_cyclicrefresh.h"
37 #include "av1/encoder/av1_quantize.h"
38 #include "av1/encoder/block.h"
39 #include "av1/encoder/context_tree.h"
40 #include "av1/encoder/encodemb.h"
41 #include "av1/encoder/external_partition.h"
42 #include "av1/encoder/firstpass.h"
43 #include "av1/encoder/global_motion.h"
44 #include "av1/encoder/level.h"
45 #include "av1/encoder/lookahead.h"
46 #include "av1/encoder/mcomp.h"
47 #include "av1/encoder/pickcdef.h"
48 #include "av1/encoder/ratectrl.h"
49 #include "av1/encoder/rd.h"
51 #include "av1/encoder/svc_layercontext.h"
52 #include "av1/encoder/temporal_filter.h"
53 #include "av1/encoder/thirdpass.h"
54 #include "av1/encoder/tokenize.h"
55 #include "av1/encoder/tpl_model.h"
56 #include "av1/encoder/av1_noise_estimate.h"
57 #include "av1/encoder/bitstream.h"
58 
59 #if CONFIG_INTERNAL_STATS
60 #include "aom_dsp/ssim.h"
61 #endif
62 #include "aom_dsp/variance.h"
63 #if CONFIG_DENOISE
64 #include "aom_dsp/noise_model.h"
65 #endif
66 #if CONFIG_TUNE_VMAF
67 #include "av1/encoder/tune_vmaf.h"
68 #endif
69 #if CONFIG_AV1_TEMPORAL_DENOISING
70 #include "av1/encoder/av1_temporal_denoiser.h"
71 #endif
72 #if CONFIG_TUNE_BUTTERAUGLI
73 #include "av1/encoder/tune_butteraugli.h"
74 #endif
75 
76 #include "aom/internal/aom_codec_internal.h"
77 #include "aom_util/aom_thread.h"
78 
79 #ifdef __cplusplus
80 extern "C" {
81 #endif
82 
83 // TODO(yunqing, any): Added suppression tag to quiet Doxygen warnings. Need to
84 // adjust it while we work on documentation.
86 // Number of frames required to test for scene cut detection
87 #define SCENE_CUT_KEY_TEST_INTERVAL 16
88 
89 // Lookahead index threshold to enable temporal filtering for second arf.
90 #define TF_LOOKAHEAD_IDX_THR 7
91 
92 #define HDR_QP_LEVELS 10
93 #define CHROMA_CB_QP_SCALE 1.04
94 #define CHROMA_CR_QP_SCALE 1.04
95 #define CHROMA_QP_SCALE -0.46
96 #define CHROMA_QP_OFFSET 9.26
97 #define QP_SCALE_FACTOR 2.0
98 #define DISABLE_HDR_LUMA_DELTAQ 1
99 
100 // Rational number with an int64 numerator
101 // This structure holds a fractional value
102 typedef struct aom_rational64 {
103  int64_t num; // fraction numerator
104  int den; // fraction denominator
105 } aom_rational64_t; // alias for struct aom_rational
106 
107 enum {
108  // Good Quality Fast Encoding. The encoder balances quality with the amount of
109  // time it takes to encode the output. Speed setting controls how fast.
110  GOOD,
111  // Realtime Fast Encoding. Will force some restrictions on bitrate
112  // constraints.
113  REALTIME,
114  // All intra mode. All the frames are coded as intra frames.
115  ALLINTRA
116 } UENUM1BYTE(MODE);
117 
118 enum {
119  FRAMEFLAGS_KEY = 1 << 0,
120  FRAMEFLAGS_GOLDEN = 1 << 1,
121  FRAMEFLAGS_BWDREF = 1 << 2,
122  // TODO(zoeliu): To determine whether a frame flag is needed for ALTREF2_FRAME
123  FRAMEFLAGS_ALTREF = 1 << 3,
124  FRAMEFLAGS_INTRAONLY = 1 << 4,
125  FRAMEFLAGS_SWITCH = 1 << 5,
126  FRAMEFLAGS_ERROR_RESILIENT = 1 << 6,
127 } UENUM1BYTE(FRAMETYPE_FLAGS);
128 
129 #if CONFIG_FPMT_TEST
130 enum {
131  PARALLEL_ENCODE = 0,
132  PARALLEL_SIMULATION_ENCODE,
133  NUM_FPMT_TEST_ENCODES
134 } UENUM1BYTE(FPMT_TEST_ENC_CFG);
135 #endif // CONFIG_FPMT_TEST
136 // 0 level frames are sometimes used for rate control purposes, but for
137 // reference mapping purposes, the minimum level should be 1.
138 #define MIN_PYR_LEVEL 1
139 static INLINE int get_true_pyr_level(int frame_level, int frame_order,
140  int max_layer_depth) {
141  if (frame_order == 0) {
142  // Keyframe case
143  return MIN_PYR_LEVEL;
144  } else if (frame_level == MAX_ARF_LAYERS) {
145  // Leaves
146  return max_layer_depth;
147  } else if (frame_level == (MAX_ARF_LAYERS + 1)) {
148  // Altrefs
149  return MIN_PYR_LEVEL;
150  }
151  return AOMMAX(MIN_PYR_LEVEL, frame_level);
152 }
153 
154 enum {
155  NO_AQ = 0,
156  VARIANCE_AQ = 1,
157  COMPLEXITY_AQ = 2,
158  CYCLIC_REFRESH_AQ = 3,
159  AQ_MODE_COUNT // This should always be the last member of the enum
160 } UENUM1BYTE(AQ_MODE);
161 enum {
162  NO_DELTA_Q = 0,
163  DELTA_Q_OBJECTIVE = 1, // Modulation to improve objective quality
164  DELTA_Q_PERCEPTUAL = 2, // Modulation to improve video perceptual quality
165  DELTA_Q_PERCEPTUAL_AI = 3, // Perceptual quality opt for all intra mode
166  DELTA_Q_USER_RATING_BASED = 4, // User rating based delta q mode
167  DELTA_Q_HDR = 5, // QP adjustment based on HDR block pixel average
168  DELTA_Q_MODE_COUNT // This should always be the last member of the enum
169 } UENUM1BYTE(DELTAQ_MODE);
170 
171 enum {
172  RESIZE_NONE = 0, // No frame resizing allowed.
173  RESIZE_FIXED = 1, // All frames are coded at the specified scale.
174  RESIZE_RANDOM = 2, // All frames are coded at a random scale.
175  RESIZE_DYNAMIC = 3, // Frames coded at lower scale based on rate control.
176  RESIZE_MODES
177 } UENUM1BYTE(RESIZE_MODE);
178 
179 enum {
180  SS_CFG_SRC = 0,
181  SS_CFG_LOOKAHEAD = 1,
182  SS_CFG_FPF = 2,
183  SS_CFG_TOTAL = 3
184 } UENUM1BYTE(SS_CFG_OFFSET);
185 
186 enum {
187  DISABLE_SCENECUT, // For LAP, lag_in_frames < 19
188  ENABLE_SCENECUT_MODE_1, // For LAP, lag_in_frames >=19 and < 33
189  ENABLE_SCENECUT_MODE_2 // For twopass and LAP - lag_in_frames >=33
190 } UENUM1BYTE(SCENECUT_MODE);
191 
192 #define MAX_VBR_CORPUS_COMPLEXITY 10000
193 
194 typedef enum {
195  MOD_FP, // First pass
196  MOD_TF, // Temporal filtering
197  MOD_TPL, // TPL
198  MOD_GME, // Global motion estimation
199  MOD_ENC, // Encode stage
200  MOD_LPF, // Deblocking loop filter
201  MOD_CDEF_SEARCH, // CDEF search
202  MOD_CDEF, // CDEF frame
203  MOD_LR, // Loop restoration filtering
204  MOD_PACK_BS, // Pack bitstream
205  MOD_FRAME_ENC, // Frame Parallel encode
206  MOD_AI, // All intra
207  NUM_MT_MODULES
208 } MULTI_THREADED_MODULES;
209 
218 typedef enum {
225 
229 typedef enum {
234  3,
236 
241 typedef enum {
242  SKIP_APPLY_RESTORATION = 1 << 0,
243  SKIP_APPLY_SUPERRES = 1 << 1,
244  SKIP_APPLY_CDEF = 1 << 2,
245  SKIP_APPLY_LOOPFILTER = 1 << 3,
247 
251 typedef struct {
255  RESIZE_MODE resize_mode;
266 } ResizeCfg;
267 
271 typedef struct {
288  BLOCK_SIZE min_partition_size;
293  BLOCK_SIZE max_partition_size;
294 } PartitionCfg;
295 
299 typedef struct {
349 } IntraModeCfg;
350 
354 typedef struct {
392 
396 typedef struct {
423 
427 typedef struct {
458 } SuperResCfg;
459 
463 typedef struct {
468 
473 
478 
484 
491 
495  bool auto_key;
496 
501 
506 
511 
516 } KeyFrameCfg;
517 
521 typedef struct {
523  // BUFFERING PARAMETERS
541 
546 
556  unsigned int max_intra_bitrate_pct;
561  unsigned int max_inter_bitrate_pct;
565  unsigned int gf_cbr_boost_pct;
570  unsigned int min_cr;
600  int cq_level;
605  enum aom_rc_mode mode;
612  int vbrbias;
624 
626 typedef struct {
627  // Indicates the number of frames lag before encoding is started.
628  int lag_in_frames;
629  // Indicates the minimum gf/arf interval to be used.
630  int min_gf_interval;
631  // Indicates the maximum gf/arf interval to be used.
632  int max_gf_interval;
633  // Indicates the minimum height for GF group pyramid structure to be used.
634  int gf_min_pyr_height;
635  // Indicates the maximum height for GF group pyramid structure to be used.
636  int gf_max_pyr_height;
637  // Indicates if automatic set and use of altref frames should be enabled.
638  bool enable_auto_arf;
639  // Indicates if automatic set and use of (b)ackward (r)ef (f)rames should be
640  // enabled.
641  bool enable_auto_brf;
642 } GFConfig;
643 
644 typedef struct {
645  // Indicates the number of tile groups.
646  unsigned int num_tile_groups;
647  // Indicates the MTU size for a tile group. If mtu is non-zero,
648  // num_tile_groups is set to DEFAULT_MAX_NUM_TG.
649  unsigned int mtu;
650  // Indicates the number of tile columns in log2.
651  int tile_columns;
652  // Indicates the number of tile rows in log2.
653  int tile_rows;
654  // Indicates the number of widths in the tile_widths[] array.
655  int tile_width_count;
656  // Indicates the number of heights in the tile_heights[] array.
657  int tile_height_count;
658  // Indicates the tile widths, and may be empty.
659  int tile_widths[MAX_TILE_COLS];
660  // Indicates the tile heights, and may be empty.
661  int tile_heights[MAX_TILE_ROWS];
662  // Indicates if large scale tile coding should be used.
663  bool enable_large_scale_tile;
664  // Indicates if single tile decoding mode should be enabled.
665  bool enable_single_tile_decoding;
666  // Indicates if EXT_TILE_DEBUG should be enabled.
667  bool enable_ext_tile_debug;
668 } TileConfig;
669 
670 typedef struct {
671  // Indicates the width of the input frame.
672  int width;
673  // Indicates the height of the input frame.
674  int height;
675  // If forced_max_frame_width is non-zero then it is used to force the maximum
676  // frame width written in write_sequence_header().
677  int forced_max_frame_width;
678  // If forced_max_frame_width is non-zero then it is used to force the maximum
679  // frame height written in write_sequence_header().
680  int forced_max_frame_height;
681  // Indicates the frame width after applying both super-resolution and resize
682  // to the coded frame.
683  int render_width;
684  // Indicates the frame height after applying both super-resolution and resize
685  // to the coded frame.
686  int render_height;
687 } FrameDimensionCfg;
688 
689 typedef struct {
690  // Indicates if warped motion should be enabled.
691  bool enable_warped_motion;
692  // Indicates if warped motion should be evaluated or not.
693  bool allow_warped_motion;
694  // Indicates if OBMC motion should be enabled.
695  bool enable_obmc;
696 } MotionModeCfg;
697 
698 typedef struct {
699  // Timing info for each frame.
700  aom_timing_info_t timing_info;
701  // Indicates the number of time units of a decoding clock.
702  uint32_t num_units_in_decoding_tick;
703  // Indicates if decoder model information is present in the coded sequence
704  // header.
705  bool decoder_model_info_present_flag;
706  // Indicates if display model information is present in the coded sequence
707  // header.
708  bool display_model_info_present_flag;
709  // Indicates if timing info for each frame is present.
710  bool timing_info_present;
711 } DecoderModelCfg;
712 
713 typedef struct {
714  // Indicates the update frequency for coeff costs.
715  COST_UPDATE_TYPE coeff;
716  // Indicates the update frequency for mode costs.
717  COST_UPDATE_TYPE mode;
718  // Indicates the update frequency for mv costs.
719  COST_UPDATE_TYPE mv;
720  // Indicates the update frequency for dv costs.
721  COST_UPDATE_TYPE dv;
722 } CostUpdateFreq;
723 
724 typedef struct {
725  // Indicates the maximum number of reference frames allowed per frame.
726  unsigned int max_reference_frames;
727  // Indicates if the reduced set of references should be enabled.
728  bool enable_reduced_reference_set;
729  // Indicates if one-sided compound should be enabled.
730  bool enable_onesided_comp;
731 } RefFrameCfg;
732 
733 typedef struct {
734  // Indicates the color space that should be used.
735  aom_color_primaries_t color_primaries;
736  // Indicates the characteristics of transfer function to be used.
737  aom_transfer_characteristics_t transfer_characteristics;
738  // Indicates the matrix coefficients to be used for the transfer function.
739  aom_matrix_coefficients_t matrix_coefficients;
740  // Indicates the chroma 4:2:0 sample position info.
741  aom_chroma_sample_position_t chroma_sample_position;
742  // Indicates if a limited color range or full color range should be used.
743  aom_color_range_t color_range;
744 } ColorCfg;
745 
746 typedef struct {
747  // Indicates if extreme motion vector unit test should be enabled or not.
748  unsigned int motion_vector_unit_test;
749  // Indicates if superblock multipass unit test should be enabled or not.
750  unsigned int sb_multipass_unit_test;
751 } UnitTestCfg;
752 
753 typedef struct {
754  // Indicates the file path to the VMAF model.
755  const char *vmaf_model_path;
756  // Indicates the path to the film grain parameters.
757  const char *film_grain_table_filename;
758  // Indicates the visual tuning metric.
759  aom_tune_metric tuning;
760  // Indicates if the current content is screen or default type.
761  aom_tune_content content;
762  // Indicates the film grain parameters.
763  int film_grain_test_vector;
764  // Indicates the in-block distortion metric to use.
765  aom_dist_metric dist_metric;
766 } TuneCfg;
767 
768 typedef struct {
769  // Indicates the framerate of the input video.
770  double init_framerate;
771  // Indicates the bit-depth of the input video.
772  unsigned int input_bit_depth;
773  // Indicates the maximum number of frames to be encoded.
774  unsigned int limit;
775  // Indicates the chrome subsampling x value.
776  unsigned int chroma_subsampling_x;
777  // Indicates the chrome subsampling y value.
778  unsigned int chroma_subsampling_y;
779 } InputCfg;
780 
781 typedef struct {
782  // If true, encoder will use fixed QP offsets, that are either:
783  // - Given by the user, and stored in 'fixed_qp_offsets' array, OR
784  // - Picked automatically from cq_level.
785  int use_fixed_qp_offsets;
786  // Indicates the minimum flatness of the quantization matrix.
787  int qm_minlevel;
788  // Indicates the maximum flatness of the quantization matrix.
789  int qm_maxlevel;
790  // Indicates if adaptive quantize_b should be enabled.
791  int quant_b_adapt;
792  // Indicates the Adaptive Quantization mode to be used.
793  AQ_MODE aq_mode;
794  // Indicates the delta q mode to be used.
795  DELTAQ_MODE deltaq_mode;
796  // Indicates the delta q mode strength.
797  DELTAQ_MODE deltaq_strength;
798  // Indicates if delta quantization should be enabled in chroma planes.
799  bool enable_chroma_deltaq;
800  // Indicates if delta quantization should be enabled for hdr video
801  bool enable_hdr_deltaq;
802  // Indicates if encoding with quantization matrices should be enabled.
803  bool using_qm;
804 } QuantizationCfg;
805 
810 typedef struct {
818 
827 
832 
837 
845 
850 
856 
865 
871 } AlgoCfg;
874 typedef struct {
875  // Indicates the codec bit-depth.
876  aom_bit_depth_t bit_depth;
877  // Indicates the superblock size that should be used by the encoder.
878  aom_superblock_size_t superblock_size;
879  // Indicates if loopfilter modulation should be enabled.
880  bool enable_deltalf_mode;
881  // Indicates how CDEF should be applied.
882  CDEF_CONTROL cdef_control;
883  // Indicates if loop restoration filter should be enabled.
884  bool enable_restoration;
885  // When enabled, video mode should be used even for single frame input.
886  bool force_video_mode;
887  // Indicates if the error resiliency features should be enabled.
888  bool error_resilient_mode;
889  // Indicates if frame parallel decoding feature should be enabled.
890  bool frame_parallel_decoding_mode;
891  // Indicates if the input should be encoded as monochrome.
892  bool enable_monochrome;
893  // When enabled, the encoder will use a full header even for still pictures.
894  // When disabled, a reduced header is used for still pictures.
895  bool full_still_picture_hdr;
896  // Indicates if dual interpolation filters should be enabled.
897  bool enable_dual_filter;
898  // Indicates if frame order hint should be enabled or not.
899  bool enable_order_hint;
900  // Indicates if ref_frame_mvs should be enabled at the sequence level.
901  bool ref_frame_mvs_present;
902  // Indicates if ref_frame_mvs should be enabled at the frame level.
903  bool enable_ref_frame_mvs;
904  // Indicates if interintra compound mode is enabled.
905  bool enable_interintra_comp;
906  // Indicates if global motion should be enabled.
907  bool enable_global_motion;
908  // Indicates if palette should be enabled.
909  bool enable_palette;
910 } ToolCfg;
911 
916 typedef struct AV1EncoderConfig {
918  // Configuration related to the input video.
919  InputCfg input_cfg;
920 
921  // Configuration related to frame-dimensions.
922  FrameDimensionCfg frm_dim_cfg;
923 
929 
934 
941  // Configuration related to Quantization.
942  QuantizationCfg q_cfg;
943 
944  // Internal frame size scaling.
945  ResizeCfg resize_cfg;
946 
947  // Frame Super-Resolution size scaling.
948  SuperResCfg superres_cfg;
949 
958  // Configuration related to encoder toolsets.
959  ToolCfg tool_cfg;
960 
961  // Configuration related to Group of frames.
962  GFConfig gf_cfg;
963 
964  // Tile related configuration parameters.
965  TileConfig tile_cfg;
966 
967  // Configuration related to Tune.
968  TuneCfg tune_cfg;
969 
970  // Configuration related to color.
971  ColorCfg color_cfg;
972 
973  // Configuration related to decoder model.
974  DecoderModelCfg dec_model_cfg;
975 
976  // Configuration related to reference frames.
977  RefFrameCfg ref_frm_cfg;
978 
979  // Configuration related to unit tests.
980  UnitTestCfg unit_test_cfg;
981 
982  // Flags related to motion mode.
983  MotionModeCfg motion_mode_cfg;
984 
985  // Flags related to intra mode search.
986  IntraModeCfg intra_mode_cfg;
987 
988  // Flags related to transform size/type.
989  TxfmSizeTypeCfg txfm_cfg;
990 
991  // Flags related to compound type.
992  CompoundTypeCfg comp_type_cfg;
993 
994  // Partition related information.
995  PartitionCfg part_cfg;
996 
997  // Configuration related to frequency of cost update.
998  CostUpdateFreq cost_upd_freq;
999 
1000 #if CONFIG_DENOISE
1001  // Indicates the noise level.
1002  float noise_level;
1003  // Indicates the the denoisers block size.
1004  int noise_block_size;
1005  // Indicates whether to apply denoising to the frame to be encoded
1006  int enable_dnl_denoising;
1007 #endif
1008 
1009 #if CONFIG_AV1_TEMPORAL_DENOISING
1010  // Noise sensitivity.
1011  int noise_sensitivity;
1012 #endif
1013  // Bit mask to specify which tier each of the 32 possible operating points
1014  // conforms to.
1015  unsigned int tier_mask;
1016 
1017  // Indicates the number of pixels off the edge of a reference frame we're
1018  // allowed to go when forming an inter prediction.
1019  int border_in_pixels;
1020 
1021  // Indicates the maximum number of threads that may be used by the encoder.
1022  int max_threads;
1023 
1024  // Indicates the speed preset to be used.
1025  int speed;
1026 
1027  // Indicates the target sequence level index for each operating point(OP).
1028  AV1_LEVEL target_seq_level_idx[MAX_NUM_OPERATING_POINTS];
1029 
1030  // Indicates the bitstream profile to be used.
1031  BITSTREAM_PROFILE profile;
1032 
1041  enum aom_enc_pass pass;
1044  // Total number of encoding passes.
1045  int passes;
1046 
1047  // the name of the second pass output file when passes > 2
1048  const char *two_pass_output;
1049 
1050  // the name of the second pass log file when passes > 2
1051  const char *second_pass_log;
1052 
1053  // Indicates if the encoding is GOOD or REALTIME.
1054  MODE mode;
1055 
1056  // Indicates if row-based multi-threading should be enabled or not.
1057  bool row_mt;
1058 
1059  // Indicates if frame parallel multi-threading should be enabled or not.
1060  bool fp_mt;
1061 
1062  // Indicates if 16bit frame buffers are to be used i.e., the content is >
1063  // 8-bit.
1064  bool use_highbitdepth;
1065 
1066  // Indicates the bitstream syntax mode. 0 indicates bitstream is saved as
1067  // Section 5 bitstream, while 1 indicates the bitstream is saved in Annex - B
1068  // format.
1069  bool save_as_annexb;
1070 
1071  // The path for partition stats reading and writing, used in the experiment
1072  // CONFIG_PARTITION_SEARCH_ORDER.
1073  const char *partition_info_path;
1074 
1075  // The flag that indicates whether we use an external rate distribution to
1076  // guide adaptive quantization. It requires --deltaq-mode=3. The rate
1077  // distribution map file name is stored in |rate_distribution_info|.
1078  unsigned int enable_rate_guide_deltaq;
1079 
1080  // The input file of rate distribution information used in all intra mode
1081  // to determine delta quantization.
1082  const char *rate_distribution_info;
1083 
1084  // Exit the encoder when it fails to encode to a given level.
1085  int strict_level_conformance;
1086 
1087  // Max depth for the GOP after a key frame
1088  int kf_max_pyr_height;
1089 
1090  // A flag to control if we enable the superblock qp sweep for a given lambda
1091  int sb_qp_sweep;
1094 
1096 static INLINE int is_lossless_requested(const RateControlCfg *const rc_cfg) {
1097  return rc_cfg->best_allowed_q == 0 && rc_cfg->worst_allowed_q == 0;
1098 }
1104 typedef struct {
1110  int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL];
1111 
1117  int warped_probs[FRAME_UPDATE_TYPES];
1118 
1125  int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES];
1126 
1133  int switchable_interp_probs[FRAME_UPDATE_TYPES][SWITCHABLE_FILTER_CONTEXTS]
1134  [SWITCHABLE_FILTERS];
1135 } FrameProbInfo;
1136 
1139 typedef struct FRAME_COUNTS {
1140 // Note: This structure should only contain 'unsigned int' fields, or
1141 // aggregates built solely from 'unsigned int' fields/elements
1142 #if CONFIG_ENTROPY_STATS
1143  unsigned int kf_y_mode[KF_MODE_CONTEXTS][KF_MODE_CONTEXTS][INTRA_MODES];
1144  unsigned int angle_delta[DIRECTIONAL_MODES][2 * MAX_ANGLE_DELTA + 1];
1145  unsigned int y_mode[BLOCK_SIZE_GROUPS][INTRA_MODES];
1146  unsigned int uv_mode[CFL_ALLOWED_TYPES][INTRA_MODES][UV_INTRA_MODES];
1147  unsigned int cfl_sign[CFL_JOINT_SIGNS];
1148  unsigned int cfl_alpha[CFL_ALPHA_CONTEXTS][CFL_ALPHABET_SIZE];
1149  unsigned int palette_y_mode[PALATTE_BSIZE_CTXS][PALETTE_Y_MODE_CONTEXTS][2];
1150  unsigned int palette_uv_mode[PALETTE_UV_MODE_CONTEXTS][2];
1151  unsigned int palette_y_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
1152  unsigned int palette_uv_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
1153  unsigned int palette_y_color_index[PALETTE_SIZES]
1154  [PALETTE_COLOR_INDEX_CONTEXTS]
1155  [PALETTE_COLORS];
1156  unsigned int palette_uv_color_index[PALETTE_SIZES]
1157  [PALETTE_COLOR_INDEX_CONTEXTS]
1158  [PALETTE_COLORS];
1159  unsigned int partition[PARTITION_CONTEXTS][EXT_PARTITION_TYPES];
1160  unsigned int txb_skip[TOKEN_CDF_Q_CTXS][TX_SIZES][TXB_SKIP_CONTEXTS][2];
1161  unsigned int eob_extra[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1162  [EOB_COEF_CONTEXTS][2];
1163  unsigned int dc_sign[PLANE_TYPES][DC_SIGN_CONTEXTS][2];
1164  unsigned int coeff_lps[TX_SIZES][PLANE_TYPES][BR_CDF_SIZE - 1][LEVEL_CONTEXTS]
1165  [2];
1166  unsigned int eob_flag[TX_SIZES][PLANE_TYPES][EOB_COEF_CONTEXTS][2];
1167  unsigned int eob_multi16[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][5];
1168  unsigned int eob_multi32[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][6];
1169  unsigned int eob_multi64[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][7];
1170  unsigned int eob_multi128[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][8];
1171  unsigned int eob_multi256[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][9];
1172  unsigned int eob_multi512[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][10];
1173  unsigned int eob_multi1024[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][11];
1174  unsigned int coeff_lps_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1175  [LEVEL_CONTEXTS][BR_CDF_SIZE];
1176  unsigned int coeff_base_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1177  [SIG_COEF_CONTEXTS][NUM_BASE_LEVELS + 2];
1178  unsigned int coeff_base_eob_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1179  [SIG_COEF_CONTEXTS_EOB][NUM_BASE_LEVELS + 1];
1180  unsigned int newmv_mode[NEWMV_MODE_CONTEXTS][2];
1181  unsigned int zeromv_mode[GLOBALMV_MODE_CONTEXTS][2];
1182  unsigned int refmv_mode[REFMV_MODE_CONTEXTS][2];
1183  unsigned int drl_mode[DRL_MODE_CONTEXTS][2];
1184  unsigned int inter_compound_mode[INTER_MODE_CONTEXTS][INTER_COMPOUND_MODES];
1185  unsigned int wedge_idx[BLOCK_SIZES_ALL][16];
1186  unsigned int interintra[BLOCK_SIZE_GROUPS][2];
1187  unsigned int interintra_mode[BLOCK_SIZE_GROUPS][INTERINTRA_MODES];
1188  unsigned int wedge_interintra[BLOCK_SIZES_ALL][2];
1189  unsigned int compound_type[BLOCK_SIZES_ALL][MASKED_COMPOUND_TYPES];
1190  unsigned int motion_mode[BLOCK_SIZES_ALL][MOTION_MODES];
1191  unsigned int obmc[BLOCK_SIZES_ALL][2];
1192  unsigned int intra_inter[INTRA_INTER_CONTEXTS][2];
1193  unsigned int comp_inter[COMP_INTER_CONTEXTS][2];
1194  unsigned int comp_ref_type[COMP_REF_TYPE_CONTEXTS][2];
1195  unsigned int uni_comp_ref[UNI_COMP_REF_CONTEXTS][UNIDIR_COMP_REFS - 1][2];
1196  unsigned int single_ref[REF_CONTEXTS][SINGLE_REFS - 1][2];
1197  unsigned int comp_ref[REF_CONTEXTS][FWD_REFS - 1][2];
1198  unsigned int comp_bwdref[REF_CONTEXTS][BWD_REFS - 1][2];
1199  unsigned int intrabc[2];
1200 
1201  unsigned int txfm_partition[TXFM_PARTITION_CONTEXTS][2];
1202  unsigned int intra_tx_size[MAX_TX_CATS][TX_SIZE_CONTEXTS][MAX_TX_DEPTH + 1];
1203  unsigned int skip_mode[SKIP_MODE_CONTEXTS][2];
1204  unsigned int skip_txfm[SKIP_CONTEXTS][2];
1205  unsigned int compound_index[COMP_INDEX_CONTEXTS][2];
1206  unsigned int comp_group_idx[COMP_GROUP_IDX_CONTEXTS][2];
1207  unsigned int delta_q[DELTA_Q_PROBS][2];
1208  unsigned int delta_lf_multi[FRAME_LF_COUNT][DELTA_LF_PROBS][2];
1209  unsigned int delta_lf[DELTA_LF_PROBS][2];
1210 
1211  unsigned int inter_ext_tx[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
1212  unsigned int intra_ext_tx[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
1213  [TX_TYPES];
1214  unsigned int filter_intra_mode[FILTER_INTRA_MODES];
1215  unsigned int filter_intra[BLOCK_SIZES_ALL][2];
1216  unsigned int switchable_restore[RESTORE_SWITCHABLE_TYPES];
1217  unsigned int wiener_restore[2];
1218  unsigned int sgrproj_restore[2];
1219 #endif // CONFIG_ENTROPY_STATS
1220 
1221  unsigned int switchable_interp[SWITCHABLE_FILTER_CONTEXTS]
1222  [SWITCHABLE_FILTERS];
1223 } FRAME_COUNTS;
1224 
1225 #define INTER_MODE_RD_DATA_OVERALL_SIZE 6400
1226 
1227 typedef struct {
1228  int ready;
1229  double a;
1230  double b;
1231  double dist_mean;
1232  double ld_mean;
1233  double sse_mean;
1234  double sse_sse_mean;
1235  double sse_ld_mean;
1236  int num;
1237  double dist_sum;
1238  double ld_sum;
1239  double sse_sum;
1240  double sse_sse_sum;
1241  double sse_ld_sum;
1242 } InterModeRdModel;
1243 
1244 typedef struct {
1245  int idx;
1246  int64_t rd;
1247 } RdIdxPair;
1248 // TODO(angiebird): This is an estimated size. We still need to figure what is
1249 // the maximum number of modes.
1250 #define MAX_INTER_MODES 1024
1251 // TODO(any): rename this struct to something else. There is already another
1252 // struct called inter_mode_info, which makes this terribly confusing.
1260 typedef struct inter_modes_info {
1265  int num;
1269  MB_MODE_INFO mbmi_arr[MAX_INTER_MODES];
1273  int mode_rate_arr[MAX_INTER_MODES];
1277  int64_t sse_arr[MAX_INTER_MODES];
1281  int64_t est_rd_arr[MAX_INTER_MODES];
1285  RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES];
1289  RD_STATS rd_cost_arr[MAX_INTER_MODES];
1293  RD_STATS rd_cost_y_arr[MAX_INTER_MODES];
1297  RD_STATS rd_cost_uv_arr[MAX_INTER_MODES];
1299 
1301 typedef struct {
1302  // TODO(kyslov): consider changing to 64bit
1303 
1304  // This struct is used for computing variance in choose_partitioning(), where
1305  // the max number of samples within a superblock is 32x32 (with 4x4 avg).
1306  // With 8bit bitdepth, uint32_t is enough for sum_square_error (2^8 * 2^8 * 32
1307  // * 32 = 2^26). For high bitdepth we need to consider changing this to 64 bit
1308  uint32_t sum_square_error;
1309  int32_t sum_error;
1310  int log2_count;
1311  int variance;
1312 } VPartVar;
1313 
1314 typedef struct {
1315  VPartVar none;
1316  VPartVar horz[2];
1317  VPartVar vert[2];
1318 } VPVariance;
1319 
1320 typedef struct {
1321  VPVariance part_variances;
1322  VPartVar split[4];
1323 } VP4x4;
1324 
1325 typedef struct {
1326  VPVariance part_variances;
1327  VP4x4 split[4];
1328 } VP8x8;
1329 
1330 typedef struct {
1331  VPVariance part_variances;
1332  VP8x8 split[4];
1333 } VP16x16;
1334 
1335 typedef struct {
1336  VPVariance part_variances;
1337  VP16x16 split[4];
1338 } VP32x32;
1339 
1340 typedef struct {
1341  VPVariance part_variances;
1342  VP32x32 split[4];
1343 } VP64x64;
1344 
1345 typedef struct {
1346  VPVariance part_variances;
1347  VP64x64 *split;
1348 } VP128x128;
1349 
1355 typedef struct {
1364  int64_t thresholds[5];
1365 
1372 
1376 typedef struct {
1377 #if CONFIG_MULTITHREAD
1382  pthread_mutex_t *mutex_;
1383  pthread_cond_t *cond_;
1385 #endif // CONFIG_MULTITHREAD
1391  int *num_finished_cols;
1409  int rows;
1419 
1422 // TODO(jingning) All spatially adaptive variables should go to TileDataEnc.
1423 typedef struct TileDataEnc {
1424  TileInfo tile_info;
1425  DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx);
1426  FRAME_CONTEXT *row_ctx;
1427  uint64_t abs_sum_level;
1428  uint8_t allow_update_cdf;
1429  InterModeRdModel inter_mode_rd_models[BLOCK_SIZES_ALL];
1430  AV1EncRowMultiThreadSync row_mt_sync;
1431  MV firstpass_top_mv;
1432 } TileDataEnc;
1433 
1434 typedef struct RD_COUNTS {
1435  int compound_ref_used_flag;
1436  int skip_mode_used_flag;
1437  int tx_type_used[TX_SIZES_ALL][TX_TYPES];
1438  int obmc_used[BLOCK_SIZES_ALL][2];
1439  int warped_used[2];
1440  int newmv_or_intra_blocks;
1441  uint64_t seg_tmp_pred_cost[2];
1442 } RD_COUNTS;
1443 
1444 typedef struct ThreadData {
1445  MACROBLOCK mb;
1446  MvCosts *mv_costs_alloc;
1447  IntraBCMVCosts *dv_costs_alloc;
1448  RD_COUNTS rd_counts;
1449  FRAME_COUNTS *counts;
1450  PC_TREE_SHARED_BUFFERS shared_coeff_buf;
1451  SIMPLE_MOTION_DATA_TREE *sms_tree;
1452  SIMPLE_MOTION_DATA_TREE *sms_root;
1453  uint32_t *hash_value_buffer[2][2];
1454  OBMCBuffer obmc_buffer;
1455  PALETTE_BUFFER *palette_buffer;
1456  CompoundTypeRdBuffers comp_rd_buffer;
1457  CONV_BUF_TYPE *tmp_conv_dst;
1458  uint64_t abs_sum_level;
1459  uint8_t *tmp_pred_bufs[2];
1460  uint8_t *wiener_tmp_pred_buf;
1461  int intrabc_used;
1462  int deltaq_used;
1463  int coefficient_size;
1464  int max_mv_magnitude;
1465  int interp_filter_selected[SWITCHABLE];
1466  FRAME_CONTEXT *tctx;
1467  VP64x64 *vt64x64;
1468  int32_t num_64x64_blocks;
1469  PICK_MODE_CONTEXT *firstpass_ctx;
1470  TemporalFilterData tf_data;
1471  TplBuffers tpl_tmp_buffers;
1472  TplTxfmStats tpl_txfm_stats;
1473  GlobalMotionData gm_data;
1474  // Pointer to the array of structures to store gradient information of each
1475  // pixel in a superblock. The buffer constitutes of MAX_SB_SQUARE pixel level
1476  // structures for each of the plane types (PLANE_TYPE_Y and PLANE_TYPE_UV).
1477  PixelLevelGradientInfo *pixel_gradient_info;
1478  // Pointer to the array of structures to store source variance information of
1479  // each 4x4 sub-block in a superblock. Block4x4VarInfo structure is used to
1480  // store source variance and log of source variance of each 4x4 sub-block
1481  // for subsequent retrieval.
1482  Block4x4VarInfo *src_var_info_of_4x4_sub_blocks;
1483  // Pointer to pc tree root.
1484  PC_TREE *pc_root;
1485 } ThreadData;
1486 
1487 struct EncWorkerData;
1488 
1494 typedef struct {
1517 
1521  int thread_id_to_tile_id[MAX_NUM_THREADS];
1522 
1528 
1534 
1540 
1547 
1554 
1555 #if CONFIG_MULTITHREAD
1559  pthread_mutex_t *mutex_;
1563  pthread_cond_t *cond_;
1564 #endif
1565 
1573  void (*sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int);
1577  void (*sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
1580 
1584 typedef struct {
1585 #if CONFIG_MULTITHREAD
1589  pthread_mutex_t *mutex_;
1593  pthread_cond_t *cond_;
1594 #endif
1595 
1603  void (*intra_sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int);
1607  void (*intra_sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
1610 
1614 #define NUM_RECODES_PER_FRAME 10
1615 
1619 #define MAX_PARALLEL_FRAMES 4
1620 
1625 typedef struct RestoreStateBuffers {
1629  uint16_t *cdef_srcbuf;
1630 
1634  uint16_t *cdef_colbuf[MAX_MB_PLANE];
1635 
1639  int32_t *rst_tmpbuf;
1640 
1644  RestorationLineBuffers *rlbs;
1646 
1650 typedef struct {
1655 
1660 
1667 
1673 typedef struct {
1678  RestUnitSearchInfo *rusi[MAX_MB_PLANE];
1679 
1683  int16_t *dgd_avg;
1684 } AV1LrPickStruct;
1685 
1689 typedef struct PrimaryMultiThreadInfo {
1694 
1698  int num_mod_workers[NUM_MT_MODULES];
1699 
1703  AVxWorker *workers;
1704 
1709  struct EncWorkerData *tile_thr_data;
1710 
1714  AV1CdefWorkerData *cdef_worker;
1715 
1721 
1726 
1732 
1736 typedef struct MultiThreadInfo {
1741 
1745  int num_mod_workers[NUM_MT_MODULES];
1746 
1750  AVxWorker *workers;
1751 
1756  struct EncWorkerData *tile_thr_data;
1757 
1763 
1768 
1773 
1779 
1783  AV1TplRowMultiThreadInfo tpl_row_mt;
1784 
1788  AV1LfSync lf_row_sync;
1789 
1793  AV1LrSync lr_row_sync;
1794 
1798  AV1EncPackBSSync pack_bs_sync;
1799 
1803  AV1GlobalMotionSync gm_sync;
1804 
1808  AV1TemporalFilterSync tf_sync;
1809 
1813  AV1CdefSync cdef_sync;
1814 
1818  AV1CdefWorkerData *cdef_worker;
1819 
1824 
1831 
1834 typedef struct ActiveMap {
1835  int enabled;
1836  int update;
1837  unsigned char *map;
1838 } ActiveMap;
1839 
1845 typedef struct {
1850  double cs_rate_array[32];
1860 
1863 #if CONFIG_INTERNAL_STATS
1864 // types of stats
1865 enum {
1866  STAT_Y,
1867  STAT_U,
1868  STAT_V,
1869  STAT_ALL,
1870  NUM_STAT_TYPES // This should always be the last member of the enum
1871 } UENUM1BYTE(StatType);
1872 
1873 typedef struct IMAGE_STAT {
1874  double stat[NUM_STAT_TYPES];
1875  double worst;
1876 } ImageStat;
1877 #endif // CONFIG_INTERNAL_STATS
1878 
1879 typedef struct {
1880  int ref_count;
1881  YV12_BUFFER_CONFIG buf;
1882 } EncRefCntBuffer;
1883 
1891 typedef struct {
1904  int stride;
1906 
1909 #if CONFIG_COLLECT_PARTITION_STATS
1910 typedef struct FramePartitionTimingStats {
1911  int partition_decisions[6][EXT_PARTITION_TYPES];
1912  int partition_attempts[6][EXT_PARTITION_TYPES];
1913  int64_t partition_times[6][EXT_PARTITION_TYPES];
1914 
1915  int partition_redo;
1916 } FramePartitionTimingStats;
1917 #endif // CONFIG_COLLECT_PARTITION_STATS
1918 
1919 #if CONFIG_COLLECT_COMPONENT_TIMING
1920 #include "aom_ports/aom_timer.h"
1921 // Adjust the following to add new components.
1922 enum {
1923  av1_encode_strategy_time,
1924  av1_get_one_pass_rt_params_time,
1925  av1_get_second_pass_params_time,
1926  denoise_and_encode_time,
1927  apply_filtering_time,
1928  av1_tpl_setup_stats_time,
1929  encode_frame_to_data_rate_time,
1930  encode_with_or_without_recode_time,
1931  loop_filter_time,
1932  cdef_time,
1933  loop_restoration_time,
1934  av1_pack_bitstream_final_time,
1935  av1_encode_frame_time,
1936  av1_compute_global_motion_time,
1937  av1_setup_motion_field_time,
1938  encode_sb_row_time,
1939 
1940  rd_pick_partition_time,
1941  rd_use_partition_time,
1942  choose_var_based_partitioning_time,
1943  av1_prune_partitions_time,
1944  none_partition_search_time,
1945  split_partition_search_time,
1946  rectangular_partition_search_time,
1947  ab_partitions_search_time,
1948  rd_pick_4partition_time,
1949  encode_sb_time,
1950 
1951  rd_pick_sb_modes_time,
1952  av1_rd_pick_intra_mode_sb_time,
1953  av1_rd_pick_inter_mode_sb_time,
1954  set_params_rd_pick_inter_mode_time,
1955  skip_inter_mode_time,
1956  handle_inter_mode_time,
1957  evaluate_motion_mode_for_winner_candidates_time,
1958  do_tx_search_time,
1959  handle_intra_mode_time,
1960  refine_winner_mode_tx_time,
1961  av1_search_palette_mode_time,
1962  handle_newmv_time,
1963  compound_type_rd_time,
1964  interpolation_filter_search_time,
1965  motion_mode_rd_time,
1966 
1967  nonrd_use_partition_time,
1968  pick_sb_modes_nonrd_time,
1969  hybrid_intra_mode_search_time,
1970  nonrd_pick_inter_mode_sb_time,
1971  encode_b_nonrd_time,
1972 
1973  kTimingComponents,
1974 } UENUM1BYTE(TIMING_COMPONENT);
1975 
1976 static INLINE char const *get_component_name(int index) {
1977  switch (index) {
1978  case av1_encode_strategy_time: return "av1_encode_strategy_time";
1979  case av1_get_one_pass_rt_params_time:
1980  return "av1_get_one_pass_rt_params_time";
1981  case av1_get_second_pass_params_time:
1982  return "av1_get_second_pass_params_time";
1983  case denoise_and_encode_time: return "denoise_and_encode_time";
1984  case apply_filtering_time: return "apply_filtering_time";
1985  case av1_tpl_setup_stats_time: return "av1_tpl_setup_stats_time";
1986  case encode_frame_to_data_rate_time:
1987  return "encode_frame_to_data_rate_time";
1988  case encode_with_or_without_recode_time:
1989  return "encode_with_or_without_recode_time";
1990  case loop_filter_time: return "loop_filter_time";
1991  case cdef_time: return "cdef_time";
1992  case loop_restoration_time: return "loop_restoration_time";
1993  case av1_pack_bitstream_final_time: return "av1_pack_bitstream_final_time";
1994  case av1_encode_frame_time: return "av1_encode_frame_time";
1995  case av1_compute_global_motion_time:
1996  return "av1_compute_global_motion_time";
1997  case av1_setup_motion_field_time: return "av1_setup_motion_field_time";
1998  case encode_sb_row_time: return "encode_sb_row_time";
1999 
2000  case rd_pick_partition_time: return "rd_pick_partition_time";
2001  case rd_use_partition_time: return "rd_use_partition_time";
2002  case choose_var_based_partitioning_time:
2003  return "choose_var_based_partitioning_time";
2004  case av1_prune_partitions_time: return "av1_prune_partitions_time";
2005  case none_partition_search_time: return "none_partition_search_time";
2006  case split_partition_search_time: return "split_partition_search_time";
2007  case rectangular_partition_search_time:
2008  return "rectangular_partition_search_time";
2009  case ab_partitions_search_time: return "ab_partitions_search_time";
2010  case rd_pick_4partition_time: return "rd_pick_4partition_time";
2011  case encode_sb_time: return "encode_sb_time";
2012 
2013  case rd_pick_sb_modes_time: return "rd_pick_sb_modes_time";
2014  case av1_rd_pick_intra_mode_sb_time:
2015  return "av1_rd_pick_intra_mode_sb_time";
2016  case av1_rd_pick_inter_mode_sb_time:
2017  return "av1_rd_pick_inter_mode_sb_time";
2018  case set_params_rd_pick_inter_mode_time:
2019  return "set_params_rd_pick_inter_mode_time";
2020  case skip_inter_mode_time: return "skip_inter_mode_time";
2021  case handle_inter_mode_time: return "handle_inter_mode_time";
2022  case evaluate_motion_mode_for_winner_candidates_time:
2023  return "evaluate_motion_mode_for_winner_candidates_time";
2024  case do_tx_search_time: return "do_tx_search_time";
2025  case handle_intra_mode_time: return "handle_intra_mode_time";
2026  case refine_winner_mode_tx_time: return "refine_winner_mode_tx_time";
2027  case av1_search_palette_mode_time: return "av1_search_palette_mode_time";
2028  case handle_newmv_time: return "handle_newmv_time";
2029  case compound_type_rd_time: return "compound_type_rd_time";
2030  case interpolation_filter_search_time:
2031  return "interpolation_filter_search_time";
2032  case motion_mode_rd_time: return "motion_mode_rd_time";
2033 
2034  case nonrd_use_partition_time: return "nonrd_use_partition_time";
2035  case pick_sb_modes_nonrd_time: return "pick_sb_modes_nonrd_time";
2036  case hybrid_intra_mode_search_time: return "hybrid_intra_mode_search_time";
2037  case nonrd_pick_inter_mode_sb_time: return "nonrd_pick_inter_mode_sb_time";
2038  case encode_b_nonrd_time: return "encode_b_nonrd_time";
2039 
2040  default: assert(0);
2041  }
2042  return "error";
2043 }
2044 #endif
2045 
2046 // The maximum number of internal ARFs except ALTREF_FRAME
2047 #define MAX_INTERNAL_ARFS (REF_FRAMES - BWDREF_FRAME - 1)
2048 
2054 typedef struct {
2059 
2065  YV12_BUFFER_CONFIG *ref_buf[REF_FRAMES];
2066 
2072  int num_ref_frames[MAX_DIRECTIONS];
2073 
2080  FrameDistPair reference_frames[MAX_DIRECTIONS][REF_FRAMES - 1];
2081 
2090 
2094 typedef struct {
2105 
2109 typedef struct {
2129  fractional_mv_step_fp *find_fractional_mv_step;
2136  search_site_config search_site_cfg[SS_CFG_TOTAL][NUM_DISTINCT_SEARCH_METHODS];
2138 
2147 typedef struct {
2152 
2160 typedef struct {
2161  int width;
2162  int height;
2164 
2168 typedef struct {
2172  int ref_relative_dist[INTER_REFS_PER_FRAME];
2182 
2198 typedef struct {
2206  unsigned int coeff_opt_thresholds[MODE_EVAL_TYPES][2];
2207 
2212  TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES];
2213 
2220  unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES];
2221 
2227  unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES];
2228 
2234  unsigned int skip_txfm_level[MODE_EVAL_TYPES];
2235 
2241  unsigned int predict_dc_level[MODE_EVAL_TYPES];
2243 
2251 typedef struct {
2252  bool last_frame;
2262 
2266 typedef struct {
2271 
2276 
2281 
2287 
2292 
2297 
2302 
2308 } ExternalFlags;
2309 
2312 typedef struct {
2313  // Some misc info
2314  int high_prec;
2315  int q;
2316  int order;
2317 
2318  // MV counters
2319  int inter_count;
2320  int intra_count;
2321  int default_mvs;
2322  int mv_joint_count[4];
2323  int last_bit_zero;
2324  int last_bit_nonzero;
2325 
2326  // Keep track of the rates
2327  int total_mv_rate;
2328  int hp_total_mv_rate;
2329  int lp_total_mv_rate;
2330 
2331  // Texture info
2332  int horz_text;
2333  int vert_text;
2334  int diag_text;
2335 
2336  // Whether the current struct contains valid data
2337  int valid;
2338 } MV_STATS;
2339 
2340 typedef struct WeberStats {
2341  int64_t mb_wiener_variance;
2342  int64_t src_variance;
2343  int64_t rec_variance;
2344  int16_t src_pix_max;
2345  int16_t rec_pix_max;
2346  int64_t distortion;
2347  int64_t satd;
2348  double max_scale;
2349 } WeberStats;
2350 
2351 typedef struct {
2352  struct loopfilter lf;
2353  CdefInfo cdef_info;
2354  YV12_BUFFER_CONFIG copy_buffer;
2355  RATE_CONTROL rc;
2356  MV_STATS mv_stats;
2357 } CODING_CONTEXT;
2358 
2359 typedef struct {
2360  int frame_width;
2361  int frame_height;
2362  int mi_rows;
2363  int mi_cols;
2364  int mb_rows;
2365  int mb_cols;
2366  int num_mbs;
2367  aom_bit_depth_t bit_depth;
2368  int subsampling_x;
2369  int subsampling_y;
2370 } FRAME_INFO;
2371 
2375 typedef struct {
2376  int show_frame_count;
2377 } FRAME_INDEX_SET;
2378 
2384 typedef struct {
2390  uint8_t *map;
2398 
2402 typedef struct {
2406  int64_t prev_ts_start;
2410  int64_t prev_ts_end;
2415 } TimeStamps;
2416 
2421 typedef struct {
2425  tran_low_t *tcoeff;
2429  uint16_t *eobs;
2433  uint8_t *entropy_ctx;
2434 } CoeffBufferPool;
2435 
2436 #if !CONFIG_REALTIME_ONLY
2438 // DUCKY_ENCODE_FRAME_MODE is c version of EncodeFrameMode
2439 enum {
2440  DUCKY_ENCODE_FRAME_MODE_NONE, // Let native AV1 determine q index and rdmult
2441  DUCKY_ENCODE_FRAME_MODE_QINDEX, // DuckyEncode determines q index and AV1
2442  // determines rdmult
2443  DUCKY_ENCODE_FRAME_MODE_QINDEX_RDMULT, // DuckyEncode determines q index and
2444  // rdmult
2445 } UENUM1BYTE(DUCKY_ENCODE_FRAME_MODE);
2446 
2447 enum {
2448  DUCKY_ENCODE_GOP_MODE_NONE, // native AV1 decides GOP
2449  DUCKY_ENCODE_GOP_MODE_RCL, // rate control lib decides GOP
2450 } UENUM1BYTE(DUCKY_ENCODE_GOP_MODE);
2451 
2452 typedef struct DuckyEncodeFrameInfo {
2453  DUCKY_ENCODE_FRAME_MODE qp_mode;
2454  DUCKY_ENCODE_GOP_MODE gop_mode;
2455  int q_index;
2456  int rdmult;
2457  // These two arrays are equivalent to std::vector<SuperblockEncodeParameters>
2458  int *superblock_encode_qindex;
2459  int *superblock_encode_rdmult;
2460  int delta_q_enabled;
2461 } DuckyEncodeFrameInfo;
2462 
2463 typedef struct DuckyEncodeFrameResult {
2464  int global_order_idx;
2465  int q_index;
2466  int rdmult;
2467  int rate;
2468  int64_t dist;
2469  double psnr;
2470 } DuckyEncodeFrameResult;
2471 
2472 typedef struct DuckyEncodeInfo {
2473  DuckyEncodeFrameInfo frame_info;
2474  DuckyEncodeFrameResult frame_result;
2475 } DuckyEncodeInfo;
2477 #endif
2478 
2480 typedef struct RTC_REF {
2485  int reference[INTER_REFS_PER_FRAME];
2486  int ref_idx[INTER_REFS_PER_FRAME];
2487  int refresh[REF_FRAMES];
2488  int set_ref_frame_config;
2489  int non_reference_frame;
2490  int ref_frame_comp[3];
2491  int gld_idx_1layer;
2495  unsigned int buffer_time_index[REF_FRAMES];
2499  unsigned char buffer_spatial_layer[REF_FRAMES];
2503  bool reference_was_previous_frame;
2508  bool bias_recovery_frame;
2509 } RTC_REF;
2515 typedef struct AV1_COMP_DATA {
2519  unsigned char *cx_data;
2520 
2524  size_t cx_data_sz;
2525 
2529  size_t frame_size;
2530 
2534  unsigned int lib_flags;
2535 
2540 
2544  int64_t ts_frame_end;
2545 
2549  int flush;
2550 
2554  const aom_rational64_t *timestamp_ratio;
2555 
2560 
2566 
2570 typedef struct AV1_PRIMARY {
2575 
2581 #if CONFIG_FPMT_TEST
2587  FPMT_TEST_ENC_CFG fpmt_unit_test_cfg;
2588 
2592  FrameProbInfo temp_frame_probs;
2593 
2599  FrameProbInfo temp_frame_probs_simulation;
2600 
2605  int temp_valid_gm_model_found[FRAME_UPDATE_TYPES];
2606 #endif // CONFIG_FPMT_TEST
2612  RefCntBuffer *ref_frame_map_copy[REF_FRAMES];
2613 
2618 
2623 
2628 
2633 
2638 
2643 
2648  struct AV1_COMP *cpi;
2649 
2654 
2658  struct lookahead_ctx *lookahead;
2659 
2666 
2671  struct aom_codec_pkt_list *output_pkt_list;
2672 
2677 
2682 
2687 
2691  GF_STATE gf_state;
2692 
2697 
2701  AV1LevelParams level_params;
2702 
2707 
2712 
2717 
2722 
2731  SequenceHeader seq_params;
2732 
2736  int use_svc;
2737 
2742 
2747 
2752 
2756  struct aom_internal_error_info error;
2757 
2763  aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL];
2764 
2770 
2775 
2779  MV_STATS mv_stats;
2780 
2781 #if CONFIG_INTERNAL_STATS
2783  uint64_t total_time_receive_data;
2784  uint64_t total_time_compress_data;
2785 
2786  unsigned int total_mode_chosen_counts[MAX_MODES];
2787 
2788  int count[2];
2789  uint64_t total_sq_error[2];
2790  uint64_t total_samples[2];
2791  ImageStat psnr[2];
2792 
2793  double total_blockiness;
2794  double worst_blockiness;
2795 
2796  uint64_t total_bytes;
2797  double summed_quality;
2798  double summed_weights;
2799  double summed_quality_hbd;
2800  double summed_weights_hbd;
2801  unsigned int total_recode_hits;
2802  double worst_ssim;
2803  double worst_ssim_hbd;
2804 
2805  ImageStat fastssim;
2806  ImageStat psnrhvs;
2807 
2808  int b_calculate_blockiness;
2809  int b_calculate_consistency;
2810 
2811  double total_inconsistency;
2812  double worst_consistency;
2813  Ssimv *ssim_vars;
2814  Metrics metrics;
2816 #endif
2817 
2818 #if CONFIG_ENTROPY_STATS
2822  FRAME_COUNTS aggregate_fc;
2823 #endif // CONFIG_ENTROPY_STATS
2824 
2831  int fb_of_context_type[REF_FRAMES];
2832 
2837 
2842 
2849  int valid_gm_model_found[FRAME_UPDATE_TYPES];
2850 
2854  RTC_REF rtc_ref;
2855 
2862 
2866 typedef struct AV1_COMP {
2871 
2876  EncQuantDequantParams enc_quant_dequant_params;
2877 
2881  ThreadData td;
2882 
2886  FRAME_COUNTS counts;
2887 
2892 
2899 
2905 
2910 
2915 
2920  TRELLIS_OPT_TYPE optimize_seg_arr[MAX_SEGMENTS];
2921 
2928 
2937 
2943 
2948 
2953 
2958 
2964 
2970 
2975 
2985 
2990 
2994  CdefSearchCtx *cdef_search_ctx;
2995 
3000 
3005  RefCntBuffer *scaled_ref_buf[INTER_REFS_PER_FRAME];
3006 
3010  RefCntBuffer *last_show_frame_buf;
3011 
3016 
3021 
3026 
3032 
3038 
3042  int64_t ambient_err;
3043 
3047  RD_OPT rd;
3048 
3053  CODING_CONTEXT coding_context;
3054 
3059 
3064 
3069 
3074 
3078  double framerate;
3079 
3084 
3088  int speed;
3089 
3094 
3099 
3105 
3110 
3119  ActiveMap active_map;
3120 
3124  unsigned char gf_frame_index;
3125 
3126 #if CONFIG_INTERNAL_STATS
3128  uint64_t time_compress_data;
3129 
3130  unsigned int mode_chosen_counts[MAX_MODES];
3131  int bytes;
3132  unsigned int frame_recode_hits;
3134 #endif
3135 
3136 #if CONFIG_SPEED_STATS
3140  unsigned int tx_search_count;
3141 #endif // CONFIG_SPEED_STATS
3142 
3148 
3152  FRAME_INFO frame_info;
3153 
3157  FRAME_INDEX_SET frame_index_set;
3158 
3165 
3172 
3180 
3186 
3192 
3198 
3203 
3208  TileDataEnc *tile_data;
3213 
3217  TokenInfo token_info;
3218 
3223 
3228 
3233 
3238 
3243 
3248 
3253 
3258 
3259 #if CONFIG_FPMT_TEST
3264  double temp_framerate;
3265 #endif
3272 
3277 
3282 
3289 
3294 
3299 
3303  AV1LrStruct lr_ctxt;
3304 
3309 
3313  aom_film_grain_table_t *film_grain_table;
3314 
3315 #if CONFIG_DENOISE
3320  struct aom_denoise_and_model_t *denoise_and_model;
3321 #endif
3322 
3327 
3336 
3344 
3345 #if CONFIG_COLLECT_PARTITION_STATS
3349  FramePartitionTimingStats partition_stats;
3350 #endif // CONFIG_COLLECT_PARTITION_STATS
3351 
3352 #if CONFIG_COLLECT_COMPONENT_TIMING
3356  uint64_t component_time[kTimingComponents];
3361  struct aom_usec_timer component_timer[kTimingComponents];
3365  uint64_t frame_component_time[kTimingComponents];
3366 #endif
3367 
3372 
3377 
3382 
3389 
3390 #if CONFIG_TUNE_VMAF
3394  TuneVMAFInfo vmaf_info;
3395 #endif
3396 
3397 #if CONFIG_TUNE_BUTTERAUGLI
3401  TuneButteraugliInfo butteraugli_info;
3402 #endif
3403 
3408 
3412  COMPRESSOR_STAGE compressor_stage;
3413 
3418  FRAME_TYPE last_frame_type;
3419 
3423  int num_tg;
3424 
3431 
3435  FirstPassData firstpass_data;
3436 
3440  NOISE_ESTIMATE noise_estimate;
3441 
3442 #if CONFIG_AV1_TEMPORAL_DENOISING
3446  AV1_DENOISER denoiser;
3447 #endif
3448 
3453  uint8_t *consec_zero_mv;
3454 
3459 
3463  BLOCK_SIZE fp_block_size;
3464 
3470 
3475 
3480  ExtPartController ext_part_controller;
3481 
3486  MV_STATS mv_stats;
3491 
3497 
3504 #if CONFIG_FPMT_TEST
3511  int wanted_fb;
3512 #endif // CONFIG_FPMT_TEST
3513 
3520 
3521 #if CONFIG_RD_COMMAND
3525  RD_COMMAND rd_command;
3526 #endif // CONFIG_RD_COMMAND
3527 
3531  WeberStats *mb_weber_stats;
3532 
3538 
3544 
3549 
3553  BLOCK_SIZE weber_bsize;
3554 
3559 
3564 
3569 
3570 #if CONFIG_BITRATE_ACCURACY
3574  VBR_RATECTRL_INFO vbr_rc_info;
3575 #endif
3576 
3577 #if CONFIG_RATECTRL_LOG
3581  RATECTRL_LOG rc_log;
3582 #endif // CONFIG_RATECTRL_LOG
3583 
3588 
3592  THIRD_PASS_DEC_CTX *third_pass_ctx;
3593 
3598 
3603 
3609  uint64_t rec_sse;
3610 
3616 
3617 #if !CONFIG_REALTIME_ONLY
3621  DuckyEncodeInfo ducky_encode_info;
3622 #endif // CONFIG_REALTIME_ONLY
3623  //
3628 
3632  unsigned int zeromv_skip_thresh_exit_part[BLOCK_SIZES_ALL];
3633 
3639 
3640 #if CONFIG_SALIENCY_MAP
3644  uint8_t *saliency_map;
3645 
3649  double *sm_scaling_factor;
3650 #endif
3651 
3657 
3664 
3668 typedef struct EncodeFrameInput {
3670  YV12_BUFFER_CONFIG *source;
3671  YV12_BUFFER_CONFIG *last_source;
3672  int64_t ts_duration;
3675 
3680 typedef struct EncodeFrameParams {
3688  FRAME_TYPE frame_type;
3689 
3691  int primary_ref_frame;
3692  int order_offset;
3693 
3699 
3701  int refresh_frame_flags;
3702 
3703  int show_existing_frame;
3704  int existing_fb_idx_to_show;
3705 
3711 
3715  int remapped_ref_idx[REF_FRAMES];
3716 
3722 
3726  int speed;
3728 
3731 // EncodeFrameResults contains information about the result of encoding a
3732 // single frame
3733 typedef struct {
3734  size_t size; // Size of resulting bitstream
3735 } EncodeFrameResults;
3736 
3737 void av1_initialize_enc(unsigned int usage, enum aom_rc_mode end_usage);
3738 
3739 struct AV1_COMP *av1_create_compressor(AV1_PRIMARY *ppi,
3740  const AV1EncoderConfig *oxcf,
3741  BufferPool *const pool,
3742  COMPRESSOR_STAGE stage,
3743  int lap_lag_in_frames);
3744 
3745 struct AV1_PRIMARY *av1_create_primary_compressor(
3746  struct aom_codec_pkt_list *pkt_list_head, int num_lap_buffers,
3747  const AV1EncoderConfig *oxcf);
3748 
3749 void av1_remove_compressor(AV1_COMP *cpi);
3750 
3751 void av1_remove_primary_compressor(AV1_PRIMARY *ppi);
3752 
3753 #if CONFIG_ENTROPY_STATS
3754 void print_entropy_stats(AV1_PRIMARY *const ppi);
3755 #endif
3756 #if CONFIG_INTERNAL_STATS
3757 void print_internal_stats(AV1_PRIMARY *ppi);
3758 #endif
3759 
3760 void av1_change_config_seq(AV1_PRIMARY *ppi, const AV1EncoderConfig *oxcf,
3761  bool *sb_size_changed);
3762 
3763 void av1_change_config(AV1_COMP *cpi, const AV1EncoderConfig *oxcf,
3764  bool sb_size_changed);
3765 
3766 aom_codec_err_t av1_check_initial_width(AV1_COMP *cpi, int use_highbitdepth,
3767  int subsampling_x, int subsampling_y);
3768 
3769 void av1_init_seq_coding_tools(AV1_PRIMARY *const ppi,
3770  const AV1EncoderConfig *oxcf, int use_svc);
3771 
3772 void av1_post_encode_updates(AV1_COMP *const cpi,
3773  const AV1_COMP_DATA *const cpi_data);
3774 
3775 void av1_scale_references_fpmt(AV1_COMP *cpi, int *ref_buffers_used_map);
3776 
3777 void av1_increment_scaled_ref_counts_fpmt(BufferPool *buffer_pool,
3778  int ref_buffers_used_map);
3779 
3780 void av1_release_scaled_references_fpmt(AV1_COMP *cpi);
3781 
3782 void av1_decrement_ref_counts_fpmt(BufferPool *buffer_pool,
3783  int ref_buffers_used_map);
3784 
3785 void av1_init_sc_decisions(AV1_PRIMARY *const ppi);
3786 
3787 AV1_COMP *av1_get_parallel_frame_enc_data(AV1_PRIMARY *const ppi,
3788  AV1_COMP_DATA *const first_cpi_data);
3789 
3790 int av1_init_parallel_frame_context(const AV1_COMP_DATA *const first_cpi_data,
3791  AV1_PRIMARY *const ppi,
3792  int *ref_buffers_used_map);
3812  const YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
3813  int64_t end_time_stamp);
3814 
3836 int av1_get_compressed_data(AV1_COMP *cpi, AV1_COMP_DATA *const cpi_data);
3837 
3844 int av1_encode(AV1_COMP *const cpi, uint8_t *const dest,
3845  const EncodeFrameInput *const frame_input,
3846  const EncodeFrameParams *const frame_params,
3847  EncodeFrameResults *const frame_results);
3848 
3850 int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest);
3851 
3852 int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame);
3853 
3854 aom_codec_err_t av1_copy_new_frame_enc(AV1_COMMON *cm,
3855  YV12_BUFFER_CONFIG *new_frame,
3856  YV12_BUFFER_CONFIG *sd);
3857 
3858 int av1_use_as_reference(int *ext_ref_frame_flags, int ref_frame_flags);
3859 
3860 int av1_copy_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
3861 
3862 int av1_set_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
3863 
3864 void av1_set_frame_size(AV1_COMP *cpi, int width, int height);
3865 
3866 void av1_set_mv_search_params(AV1_COMP *cpi);
3867 
3868 int av1_set_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
3869 
3870 int av1_get_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
3871 
3872 int av1_set_internal_size(AV1EncoderConfig *const oxcf,
3873  ResizePendingParams *resize_pending_params,
3874  AOM_SCALING_MODE horiz_mode,
3875  AOM_SCALING_MODE vert_mode);
3876 
3877 int av1_get_quantizer(struct AV1_COMP *cpi);
3878 
3879 int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t *input_size);
3880 
3881 void av1_alloc_mb_wiener_var_pred_buf(AV1_COMMON *cm, ThreadData *td);
3882 
3883 void av1_dealloc_mb_wiener_var_pred_buf(ThreadData *td);
3884 
3885 // Set screen content options.
3886 // This function estimates whether to use screen content tools, by counting
3887 // the portion of blocks that have few luma colors.
3888 // Modifies:
3889 // cpi->commom.features.allow_screen_content_tools
3890 // cpi->common.features.allow_intrabc
3891 // cpi->use_screen_content_tools
3892 // cpi->is_screen_content_type
3893 // However, the estimation is not accurate and may misclassify videos.
3894 // A slower but more accurate approach that determines whether to use screen
3895 // content tools is employed later. See av1_determine_sc_tools_with_encoding().
3896 void av1_set_screen_content_options(struct AV1_COMP *cpi,
3897  FeatureFlags *features);
3898 
3899 void av1_update_frame_size(AV1_COMP *cpi);
3900 
3901 typedef struct {
3902  int pyr_level;
3903  int disp_order;
3904 } RefFrameMapPair;
3905 
3906 static INLINE void init_ref_map_pair(
3907  AV1_COMP *cpi, RefFrameMapPair ref_frame_map_pairs[REF_FRAMES]) {
3908  if (cpi->ppi->gf_group.update_type[cpi->gf_frame_index] == KF_UPDATE) {
3909  memset(ref_frame_map_pairs, -1, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
3910  return;
3911  }
3912  memset(ref_frame_map_pairs, 0, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
3913  for (int map_idx = 0; map_idx < REF_FRAMES; map_idx++) {
3914  // Get reference frame buffer.
3915  const RefCntBuffer *const buf = cpi->common.ref_frame_map[map_idx];
3916  if (ref_frame_map_pairs[map_idx].disp_order == -1) continue;
3917  if (buf == NULL) {
3918  ref_frame_map_pairs[map_idx].disp_order = -1;
3919  ref_frame_map_pairs[map_idx].pyr_level = -1;
3920  continue;
3921  } else if (buf->ref_count > 1) {
3922  // Once the keyframe is coded, the slots in ref_frame_map will all
3923  // point to the same frame. In that case, all subsequent pointers
3924  // matching the current are considered "free" slots. This will find
3925  // the next occurrence of the current pointer if ref_count indicates
3926  // there are multiple instances of it and mark it as free.
3927  for (int idx2 = map_idx + 1; idx2 < REF_FRAMES; ++idx2) {
3928  const RefCntBuffer *const buf2 = cpi->common.ref_frame_map[idx2];
3929  if (buf2 == buf) {
3930  ref_frame_map_pairs[idx2].disp_order = -1;
3931  ref_frame_map_pairs[idx2].pyr_level = -1;
3932  }
3933  }
3934  }
3935  ref_frame_map_pairs[map_idx].disp_order = (int)buf->display_order_hint;
3936  ref_frame_map_pairs[map_idx].pyr_level = buf->pyramid_level;
3937  }
3938 }
3939 
3940 #if CONFIG_FPMT_TEST
3941 static AOM_INLINE void calc_frame_data_update_flag(
3942  GF_GROUP *const gf_group, int gf_frame_index,
3943  bool *const do_frame_data_update) {
3944  *do_frame_data_update = true;
3945  // Set the flag to false for all frames in a given parallel encode set except
3946  // the last frame in the set with frame_parallel_level = 2.
3947  if (gf_group->frame_parallel_level[gf_frame_index] == 1) {
3948  *do_frame_data_update = false;
3949  } else if (gf_group->frame_parallel_level[gf_frame_index] == 2) {
3950  // Check if this is the last frame in the set with frame_parallel_level = 2.
3951  for (int i = gf_frame_index + 1; i < gf_group->size; i++) {
3952  if ((gf_group->frame_parallel_level[i] == 0 &&
3953  (gf_group->update_type[i] == ARF_UPDATE ||
3954  gf_group->update_type[i] == INTNL_ARF_UPDATE)) ||
3955  gf_group->frame_parallel_level[i] == 1) {
3956  break;
3957  } else if (gf_group->frame_parallel_level[i] == 2) {
3958  *do_frame_data_update = false;
3959  break;
3960  }
3961  }
3962  }
3963 }
3964 #endif
3965 
3966 // av1 uses 10,000,000 ticks/second as time stamp
3967 #define TICKS_PER_SEC 10000000LL
3968 
3969 static INLINE int64_t
3970 timebase_units_to_ticks(const aom_rational64_t *timestamp_ratio, int64_t n) {
3971  return n * timestamp_ratio->num / timestamp_ratio->den;
3972 }
3973 
3974 static INLINE int64_t
3975 ticks_to_timebase_units(const aom_rational64_t *timestamp_ratio, int64_t n) {
3976  int64_t round = timestamp_ratio->num / 2;
3977  if (round > 0) --round;
3978  return (n * timestamp_ratio->den + round) / timestamp_ratio->num;
3979 }
3980 
3981 static INLINE int frame_is_kf_gf_arf(const AV1_COMP *cpi) {
3982  const GF_GROUP *const gf_group = &cpi->ppi->gf_group;
3983  const FRAME_UPDATE_TYPE update_type =
3984  gf_group->update_type[cpi->gf_frame_index];
3985 
3986  return frame_is_intra_only(&cpi->common) || update_type == ARF_UPDATE ||
3987  update_type == GF_UPDATE;
3988 }
3989 
3990 // TODO(huisu@google.com, youzhou@microsoft.com): enable hash-me for HBD.
3991 static INLINE int av1_use_hash_me(const AV1_COMP *const cpi) {
3993  cpi->common.features.allow_intrabc &&
3994  frame_is_intra_only(&cpi->common));
3995 }
3996 
3997 static INLINE const YV12_BUFFER_CONFIG *get_ref_frame_yv12_buf(
3998  const AV1_COMMON *const cm, MV_REFERENCE_FRAME ref_frame) {
3999  const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
4000  return buf != NULL ? &buf->buf : NULL;
4001 }
4002 
4003 static INLINE void alloc_frame_mvs(AV1_COMMON *const cm, RefCntBuffer *buf) {
4004  assert(buf != NULL);
4005  ensure_mv_buffer(buf, cm);
4006  buf->width = cm->width;
4007  buf->height = cm->height;
4008 }
4009 
4010 // Get the allocated token size for a tile. It does the same calculation as in
4011 // the frame token allocation.
4012 static INLINE unsigned int allocated_tokens(const TileInfo *tile,
4013  int sb_size_log2, int num_planes) {
4014  int tile_mb_rows =
4015  ROUND_POWER_OF_TWO(tile->mi_row_end - tile->mi_row_start, 2);
4016  int tile_mb_cols =
4017  ROUND_POWER_OF_TWO(tile->mi_col_end - tile->mi_col_start, 2);
4018 
4019  return get_token_alloc(tile_mb_rows, tile_mb_cols, sb_size_log2, num_planes);
4020 }
4021 
4022 static INLINE void get_start_tok(AV1_COMP *cpi, int tile_row, int tile_col,
4023  int mi_row, TokenExtra **tok, int sb_size_log2,
4024  int num_planes) {
4025  AV1_COMMON *const cm = &cpi->common;
4026  const int tile_cols = cm->tiles.cols;
4027  TileDataEnc *this_tile = &cpi->tile_data[tile_row * tile_cols + tile_col];
4028  const TileInfo *const tile_info = &this_tile->tile_info;
4029 
4030  const int tile_mb_cols =
4031  (tile_info->mi_col_end - tile_info->mi_col_start + 2) >> 2;
4032  const int tile_mb_row = (mi_row - tile_info->mi_row_start + 2) >> 2;
4033 
4034  *tok = cpi->token_info.tile_tok[tile_row][tile_col] +
4035  get_token_alloc(tile_mb_row, tile_mb_cols, sb_size_log2, num_planes);
4036 }
4037 
4038 void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags);
4039 
4040 #define ALT_MIN_LAG 3
4041 static INLINE int is_altref_enabled(int lag_in_frames, bool enable_auto_arf) {
4042  return lag_in_frames >= ALT_MIN_LAG && enable_auto_arf;
4043 }
4044 
4045 static AOM_INLINE int can_disable_altref(const GFConfig *gf_cfg) {
4046  return is_altref_enabled(gf_cfg->lag_in_frames, gf_cfg->enable_auto_arf) &&
4047  (gf_cfg->gf_min_pyr_height == 0);
4048 }
4049 
4050 // Helper function to compute number of blocks on either side of the frame.
4051 static INLINE int get_num_blocks(const int frame_length, const int mb_length) {
4052  return (frame_length + mb_length - 1) / mb_length;
4053 }
4054 
4055 // Check if statistics generation stage
4056 static INLINE int is_stat_generation_stage(const AV1_COMP *const cpi) {
4057  assert(IMPLIES(cpi->compressor_stage == LAP_STAGE,
4058  cpi->oxcf.pass == AOM_RC_ONE_PASS && cpi->ppi->lap_enabled));
4059  return (cpi->oxcf.pass == AOM_RC_FIRST_PASS ||
4060  (cpi->compressor_stage == LAP_STAGE));
4061 }
4062 // Check if statistics consumption stage
4063 static INLINE int is_stat_consumption_stage_twopass(const AV1_COMP *const cpi) {
4064  return (cpi->oxcf.pass >= AOM_RC_SECOND_PASS);
4065 }
4066 
4067 // Check if statistics consumption stage
4068 static INLINE int is_stat_consumption_stage(const AV1_COMP *const cpi) {
4069  return (is_stat_consumption_stage_twopass(cpi) ||
4070  (cpi->oxcf.pass == AOM_RC_ONE_PASS &&
4071  (cpi->compressor_stage == ENCODE_STAGE) && cpi->ppi->lap_enabled));
4072 }
4073 
4074 // Decide whether 'dv_costs' need to be allocated/stored during the encoding.
4075 static AOM_INLINE bool av1_need_dv_costs(const AV1_COMP *const cpi) {
4076  return !cpi->sf.rt_sf.use_nonrd_pick_mode &&
4077  av1_allow_intrabc(&cpi->common) && !is_stat_generation_stage(cpi);
4078 }
4079 
4089 static INLINE int has_no_stats_stage(const AV1_COMP *const cpi) {
4090  assert(
4091  IMPLIES(!cpi->ppi->lap_enabled, cpi->compressor_stage == ENCODE_STAGE));
4092  return (cpi->oxcf.pass == AOM_RC_ONE_PASS && !cpi->ppi->lap_enabled);
4093 }
4094 
4097 static INLINE int is_one_pass_rt_params(const AV1_COMP *cpi) {
4098  return has_no_stats_stage(cpi) && cpi->oxcf.mode == REALTIME &&
4099  cpi->oxcf.gf_cfg.lag_in_frames == 0;
4100 }
4101 
4102 // Use default/internal reference structure for single-layer RTC.
4103 static INLINE int use_rtc_reference_structure_one_layer(const AV1_COMP *cpi) {
4104  return is_one_pass_rt_params(cpi) && cpi->ppi->number_spatial_layers == 1 &&
4105  cpi->ppi->number_temporal_layers == 1 &&
4106  !cpi->ppi->rtc_ref.set_ref_frame_config;
4107 }
4108 
4109 // Function return size of frame stats buffer
4110 static INLINE int get_stats_buf_size(int num_lap_buffer, int num_lag_buffer) {
4111  /* if lookahead is enabled return num_lap_buffers else num_lag_buffers */
4112  return (num_lap_buffer > 0 ? num_lap_buffer + 1 : num_lag_buffer);
4113 }
4114 
4115 // TODO(zoeliu): To set up cpi->oxcf.gf_cfg.enable_auto_brf
4116 
4117 static INLINE void set_ref_ptrs(const AV1_COMMON *cm, MACROBLOCKD *xd,
4118  MV_REFERENCE_FRAME ref0,
4119  MV_REFERENCE_FRAME ref1) {
4120  xd->block_ref_scale_factors[0] =
4121  get_ref_scale_factors_const(cm, ref0 >= LAST_FRAME ? ref0 : 1);
4122  xd->block_ref_scale_factors[1] =
4123  get_ref_scale_factors_const(cm, ref1 >= LAST_FRAME ? ref1 : 1);
4124 }
4125 
4126 static INLINE int get_chessboard_index(int frame_index) {
4127  return frame_index & 0x1;
4128 }
4129 
4130 static INLINE const int *cond_cost_list_const(const struct AV1_COMP *cpi,
4131  const int *cost_list) {
4132  const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
4133  cpi->sf.mv_sf.use_fullpel_costlist;
4134  return use_cost_list ? cost_list : NULL;
4135 }
4136 
4137 static INLINE int *cond_cost_list(const struct AV1_COMP *cpi, int *cost_list) {
4138  const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
4139  cpi->sf.mv_sf.use_fullpel_costlist;
4140  return use_cost_list ? cost_list : NULL;
4141 }
4142 
4143 // Compression ratio of current frame.
4144 double av1_get_compression_ratio(const AV1_COMMON *const cm,
4145  size_t encoded_frame_size);
4146 
4147 void av1_new_framerate(AV1_COMP *cpi, double framerate);
4148 
4149 void av1_setup_frame_size(AV1_COMP *cpi);
4150 
4151 #define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl))
4152 
4153 // Returns 1 if a frame is scaled and 0 otherwise.
4154 static INLINE int av1_resize_scaled(const AV1_COMMON *cm) {
4155  return cm->superres_upscaled_width != cm->render_width ||
4157 }
4158 
4159 static INLINE int av1_frame_scaled(const AV1_COMMON *cm) {
4160  return av1_superres_scaled(cm) || av1_resize_scaled(cm);
4161 }
4162 
4163 // Don't allow a show_existing_frame to coincide with an error resilient
4164 // frame. An exception can be made for a forward keyframe since it has no
4165 // previous dependencies.
4166 static INLINE int encode_show_existing_frame(const AV1_COMMON *cm) {
4167  return cm->show_existing_frame && (!cm->features.error_resilient_mode ||
4168  cm->current_frame.frame_type == KEY_FRAME);
4169 }
4170 
4171 // Get index into the 'cpi->mbmi_ext_info.frame_base' array for the given
4172 // 'mi_row' and 'mi_col'.
4173 static INLINE int get_mi_ext_idx(const int mi_row, const int mi_col,
4174  const BLOCK_SIZE mi_alloc_bsize,
4175  const int mbmi_ext_stride) {
4176  const int mi_ext_size_1d = mi_size_wide[mi_alloc_bsize];
4177  const int mi_ext_row = mi_row / mi_ext_size_1d;
4178  const int mi_ext_col = mi_col / mi_ext_size_1d;
4179  return mi_ext_row * mbmi_ext_stride + mi_ext_col;
4180 }
4181 
4182 // Lighter version of set_offsets that only sets the mode info
4183 // pointers.
4184 static INLINE void set_mode_info_offsets(
4185  const CommonModeInfoParams *const mi_params,
4186  const MBMIExtFrameBufferInfo *const mbmi_ext_info, MACROBLOCK *const x,
4187  MACROBLOCKD *const xd, int mi_row, int mi_col) {
4188  set_mi_offsets(mi_params, xd, mi_row, mi_col);
4189  const int ext_idx = get_mi_ext_idx(mi_row, mi_col, mi_params->mi_alloc_bsize,
4190  mbmi_ext_info->stride);
4191  x->mbmi_ext_frame = mbmi_ext_info->frame_base + ext_idx;
4192 }
4193 
4194 // Check to see if the given partition size is allowed for a specified number
4195 // of mi block rows and columns remaining in the image.
4196 // If not then return the largest allowed partition size
4197 static INLINE BLOCK_SIZE find_partition_size(BLOCK_SIZE bsize, int rows_left,
4198  int cols_left, int *bh, int *bw) {
4199  int int_size = (int)bsize;
4200  if (rows_left <= 0 || cols_left <= 0) {
4201  return AOMMIN(bsize, BLOCK_8X8);
4202  } else {
4203  for (; int_size > 0; int_size -= 3) {
4204  *bh = mi_size_high[int_size];
4205  *bw = mi_size_wide[int_size];
4206  if ((*bh <= rows_left) && (*bw <= cols_left)) {
4207  break;
4208  }
4209  }
4210  }
4211  return (BLOCK_SIZE)int_size;
4212 }
4213 
4214 static const uint8_t av1_ref_frame_flag_list[REF_FRAMES] = { 0,
4215  AOM_LAST_FLAG,
4216  AOM_LAST2_FLAG,
4217  AOM_LAST3_FLAG,
4218  AOM_GOLD_FLAG,
4219  AOM_BWD_FLAG,
4220  AOM_ALT2_FLAG,
4221  AOM_ALT_FLAG };
4222 
4223 // When more than 'max_allowed_refs' are available, we reduce the number of
4224 // reference frames one at a time based on this order.
4225 static const MV_REFERENCE_FRAME disable_order[] = {
4226  LAST3_FRAME,
4227  LAST2_FRAME,
4228  ALTREF2_FRAME,
4229  BWDREF_FRAME,
4230 };
4231 
4232 static const MV_REFERENCE_FRAME
4233  ref_frame_priority_order[INTER_REFS_PER_FRAME] = {
4234  LAST_FRAME, ALTREF_FRAME, BWDREF_FRAME, GOLDEN_FRAME,
4235  ALTREF2_FRAME, LAST2_FRAME, LAST3_FRAME,
4236  };
4237 
4238 static INLINE int get_ref_frame_flags(const SPEED_FEATURES *const sf,
4239  const int use_one_pass_rt_params,
4240  const YV12_BUFFER_CONFIG **ref_frames,
4241  const int ext_ref_frame_flags) {
4242  // cpi->ext_flags.ref_frame_flags allows certain reference types to be
4243  // disabled by the external interface. These are set by
4244  // av1_apply_encoding_flags(). Start with what the external interface allows,
4245  // then suppress any reference types which we have found to be duplicates.
4246  int flags = ext_ref_frame_flags;
4247 
4248  for (int i = 1; i < INTER_REFS_PER_FRAME; ++i) {
4249  const YV12_BUFFER_CONFIG *const this_ref = ref_frames[i];
4250  // If this_ref has appeared before, mark the corresponding ref frame as
4251  // invalid. For one_pass_rt mode, only disable GOLDEN_FRAME if it's the
4252  // same as LAST_FRAME or ALTREF_FRAME (if ALTREF is being used in nonrd).
4253  int index =
4254  (use_one_pass_rt_params && ref_frame_priority_order[i] == GOLDEN_FRAME)
4255  ? (1 + sf->rt_sf.use_nonrd_altref_frame)
4256  : i;
4257  for (int j = 0; j < index; ++j) {
4258  // If this_ref has appeared before (same as the reference corresponding
4259  // to lower index j), remove it as a reference only if that reference
4260  // (for index j) is actually used as a reference.
4261  if (this_ref == ref_frames[j] &&
4262  (flags & (1 << (ref_frame_priority_order[j] - 1)))) {
4263  flags &= ~(1 << (ref_frame_priority_order[i] - 1));
4264  break;
4265  }
4266  }
4267  }
4268  return flags;
4269 }
4270 
4271 // Returns a Sequence Header OBU stored in an aom_fixed_buf_t, or NULL upon
4272 // failure. When a non-NULL aom_fixed_buf_t pointer is returned by this
4273 // function, the memory must be freed by the caller. Both the buf member of the
4274 // aom_fixed_buf_t, and the aom_fixed_buf_t pointer itself must be freed. Memory
4275 // returned must be freed via call to free().
4276 //
4277 // Note: The OBU returned is in Low Overhead Bitstream Format. Specifically,
4278 // the obu_has_size_field bit is set, and the buffer contains the obu_size
4279 // field.
4280 aom_fixed_buf_t *av1_get_global_headers(AV1_PRIMARY *ppi);
4281 
4282 #define MAX_GFUBOOST_FACTOR 10.0
4283 #define MIN_GFUBOOST_FACTOR 4.0
4284 
4285 static INLINE int is_frame_tpl_eligible(const GF_GROUP *const gf_group,
4286  uint8_t index) {
4287  const FRAME_UPDATE_TYPE update_type = gf_group->update_type[index];
4288  return update_type == ARF_UPDATE || update_type == GF_UPDATE ||
4289  update_type == KF_UPDATE;
4290 }
4291 
4292 static INLINE int is_frame_eligible_for_ref_pruning(const GF_GROUP *gf_group,
4293  int selective_ref_frame,
4294  int prune_ref_frames,
4295  int gf_index) {
4296  return (selective_ref_frame > 0) && (prune_ref_frames > 0) &&
4297  !is_frame_tpl_eligible(gf_group, gf_index);
4298 }
4299 
4300 // Get update type of the current frame.
4301 static INLINE FRAME_UPDATE_TYPE get_frame_update_type(const GF_GROUP *gf_group,
4302  int gf_frame_index) {
4303  return gf_group->update_type[gf_frame_index];
4304 }
4305 
4306 static INLINE int av1_pixels_to_mi(int pixels) {
4307  return ALIGN_POWER_OF_TWO(pixels, 3) >> MI_SIZE_LOG2;
4308 }
4309 
4310 static AOM_INLINE int is_psnr_calc_enabled(const AV1_COMP *cpi) {
4311  const AV1_COMMON *const cm = &cpi->common;
4312 
4313  return cpi->ppi->b_calculate_psnr && !is_stat_generation_stage(cpi) &&
4314  cm->show_frame && !cpi->is_dropped_frame;
4315 }
4316 
4317 static INLINE int is_frame_resize_pending(const AV1_COMP *const cpi) {
4318  const ResizePendingParams *const resize_pending_params =
4319  &cpi->resize_pending_params;
4320  return (resize_pending_params->width && resize_pending_params->height &&
4321  (cpi->common.width != resize_pending_params->width ||
4322  cpi->common.height != resize_pending_params->height));
4323 }
4324 
4325 // Check if loop filter is used.
4326 static INLINE int is_loopfilter_used(const AV1_COMMON *const cm) {
4327  return !cm->features.coded_lossless && !cm->tiles.large_scale;
4328 }
4329 
4330 // Check if CDEF is used.
4331 static INLINE int is_cdef_used(const AV1_COMMON *const cm) {
4332  return cm->seq_params->enable_cdef && !cm->features.coded_lossless &&
4333  !cm->tiles.large_scale;
4334 }
4335 
4336 // Check if loop restoration filter is used.
4337 static INLINE int is_restoration_used(const AV1_COMMON *const cm) {
4338  return cm->seq_params->enable_restoration && !cm->features.all_lossless &&
4339  !cm->tiles.large_scale;
4340 }
4341 
4342 // Checks if post-processing filters need to be applied.
4343 // NOTE: This function decides if the application of different post-processing
4344 // filters on the reconstructed frame can be skipped at the encoder side.
4345 // However the computation of different filter parameters that are signaled in
4346 // the bitstream is still required.
4347 static INLINE unsigned int derive_skip_apply_postproc_filters(
4348  const AV1_COMP *cpi, int use_loopfilter, int use_cdef, int use_superres,
4349  int use_restoration) {
4350  // Though CDEF parameter selection should be dependent on
4351  // deblocked/loop-filtered pixels for cdef_pick_method <=
4352  // CDEF_FAST_SEARCH_LVL5, CDEF strength values are calculated based on the
4353  // pixel values that are not loop-filtered in svc real-time encoding mode.
4354  // Hence this case is handled separately using the condition below.
4355  if (cpi->ppi->rtc_ref.non_reference_frame)
4356  return (SKIP_APPLY_LOOPFILTER | SKIP_APPLY_CDEF);
4357 
4359  return 0;
4360  assert(cpi->oxcf.mode == ALLINTRA);
4361 
4362  // The post-processing filters are applied one after the other in the
4363  // following order: deblocking->cdef->superres->restoration. In case of
4364  // ALLINTRA encoding, the reconstructed frame is not used as a reference
4365  // frame. Hence, the application of these filters can be skipped when
4366  // 1. filter parameters of the subsequent stages are not dependent on the
4367  // filtered output of the current stage or
4368  // 2. subsequent filtering stages are disabled
4369  if (use_restoration) return SKIP_APPLY_RESTORATION;
4370  if (use_superres) return SKIP_APPLY_SUPERRES;
4371  if (use_cdef) {
4372  // CDEF parameter selection is not dependent on the deblocked frame if
4373  // cdef_pick_method is CDEF_PICK_FROM_Q. Hence the application of deblocking
4374  // filters and cdef filters can be skipped in this case.
4375  return (cpi->sf.lpf_sf.cdef_pick_method == CDEF_PICK_FROM_Q &&
4376  use_loopfilter)
4377  ? (SKIP_APPLY_LOOPFILTER | SKIP_APPLY_CDEF)
4378  : SKIP_APPLY_CDEF;
4379  }
4380  if (use_loopfilter) return SKIP_APPLY_LOOPFILTER;
4381 
4382  // If we reach here, all post-processing stages are disabled, so none need to
4383  // be skipped.
4384  return 0;
4385 }
4386 
4387 static INLINE void set_postproc_filter_default_params(AV1_COMMON *cm) {
4388  struct loopfilter *const lf = &cm->lf;
4389  CdefInfo *const cdef_info = &cm->cdef_info;
4390  RestorationInfo *const rst_info = cm->rst_info;
4391 
4392  lf->filter_level[0] = 0;
4393  lf->filter_level[1] = 0;
4394  cdef_info->cdef_bits = 0;
4395  cdef_info->cdef_strengths[0] = 0;
4396  cdef_info->nb_cdef_strengths = 1;
4397  cdef_info->cdef_uv_strengths[0] = 0;
4398  rst_info[0].frame_restoration_type = RESTORE_NONE;
4399  rst_info[1].frame_restoration_type = RESTORE_NONE;
4400  rst_info[2].frame_restoration_type = RESTORE_NONE;
4401 }
4402 
4403 static INLINE int is_inter_tx_size_search_level_one(
4404  const TX_SPEED_FEATURES *tx_sf) {
4405  return (tx_sf->inter_tx_size_search_init_depth_rect >= 1 &&
4406  tx_sf->inter_tx_size_search_init_depth_sqr >= 1);
4407 }
4408 
4409 static INLINE int get_lpf_opt_level(const SPEED_FEATURES *sf) {
4410  int lpf_opt_level = 0;
4411  if (is_inter_tx_size_search_level_one(&sf->tx_sf))
4412  lpf_opt_level = (sf->lpf_sf.lpf_pick == LPF_PICK_FROM_Q) ? 2 : 1;
4413  return lpf_opt_level;
4414 }
4415 
4416 // Enable switchable motion mode only if warp and OBMC tools are allowed
4417 static INLINE bool is_switchable_motion_mode_allowed(bool allow_warped_motion,
4418  bool enable_obmc) {
4419  return (allow_warped_motion || enable_obmc);
4420 }
4421 
4422 #if CONFIG_AV1_TEMPORAL_DENOISING
4423 static INLINE int denoise_svc(const struct AV1_COMP *const cpi) {
4424  return (!cpi->ppi->use_svc ||
4425  (cpi->ppi->use_svc &&
4426  cpi->svc.spatial_layer_id >= cpi->svc.first_layer_denoise));
4427 }
4428 #endif
4429 
4430 #if CONFIG_COLLECT_PARTITION_STATS == 2
4431 static INLINE void av1_print_fr_partition_timing_stats(
4432  const FramePartitionTimingStats *part_stats, const char *filename) {
4433  FILE *f = fopen(filename, "w");
4434  if (!f) {
4435  return;
4436  }
4437 
4438  fprintf(f, "bsize,redo,");
4439  for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4440  fprintf(f, "decision_%d,", part);
4441  }
4442  for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4443  fprintf(f, "attempt_%d,", part);
4444  }
4445  for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4446  fprintf(f, "time_%d,", part);
4447  }
4448  fprintf(f, "\n");
4449 
4450  static const int bsizes[6] = { 128, 64, 32, 16, 8, 4 };
4451 
4452  for (int bsize_idx = 0; bsize_idx < 6; bsize_idx++) {
4453  fprintf(f, "%d,%d,", bsizes[bsize_idx], part_stats->partition_redo);
4454  for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4455  fprintf(f, "%d,", part_stats->partition_decisions[bsize_idx][part]);
4456  }
4457  for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4458  fprintf(f, "%d,", part_stats->partition_attempts[bsize_idx][part]);
4459  }
4460  for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4461  fprintf(f, "%ld,", part_stats->partition_times[bsize_idx][part]);
4462  }
4463  fprintf(f, "\n");
4464  }
4465  fclose(f);
4466 }
4467 #endif // CONFIG_COLLECT_PARTITION_STATS == 2
4468 
4469 #if CONFIG_COLLECT_PARTITION_STATS
4470 static INLINE int av1_get_bsize_idx_for_part_stats(BLOCK_SIZE bsize) {
4471  assert(bsize == BLOCK_128X128 || bsize == BLOCK_64X64 ||
4472  bsize == BLOCK_32X32 || bsize == BLOCK_16X16 || bsize == BLOCK_8X8 ||
4473  bsize == BLOCK_4X4);
4474  switch (bsize) {
4475  case BLOCK_128X128: return 0;
4476  case BLOCK_64X64: return 1;
4477  case BLOCK_32X32: return 2;
4478  case BLOCK_16X16: return 3;
4479  case BLOCK_8X8: return 4;
4480  case BLOCK_4X4: return 5;
4481  default: assert(0 && "Invalid bsize for partition_stats."); return -1;
4482  }
4483 }
4484 #endif // CONFIG_COLLECT_PARTITION_STATS
4485 
4486 #if CONFIG_COLLECT_COMPONENT_TIMING
4487 static INLINE void start_timing(AV1_COMP *cpi, int component) {
4488  aom_usec_timer_start(&cpi->component_timer[component]);
4489 }
4490 static INLINE void end_timing(AV1_COMP *cpi, int component) {
4491  aom_usec_timer_mark(&cpi->component_timer[component]);
4492  cpi->frame_component_time[component] +=
4493  aom_usec_timer_elapsed(&cpi->component_timer[component]);
4494 }
4495 static INLINE char const *get_frame_type_enum(int type) {
4496  switch (type) {
4497  case 0: return "KEY_FRAME";
4498  case 1: return "INTER_FRAME";
4499  case 2: return "INTRA_ONLY_FRAME";
4500  case 3: return "S_FRAME";
4501  default: assert(0);
4502  }
4503  return "error";
4504 }
4505 #endif
4506 
4509 #ifdef __cplusplus
4510 } // extern "C"
4511 #endif
4512 
4513 #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 AV1_COMP AV1_COMP
Top level encoder structure.
COST_UPDATE_TYPE
This enum controls how often the entropy costs should be updated.
Definition: encoder.h:218
@ COST_UPD_SBROW
Definition: encoder.h:220
@ COST_UPD_TILE
Definition: encoder.h:221
@ COST_UPD_OFF
Definition: encoder.h:222
@ NUM_COST_UPDATE_TYPES
Definition: encoder.h:223
@ COST_UPD_SB
Definition: encoder.h:219
struct EncodeFrameParams EncodeFrameParams
contains per-frame encoding parameters decided upon by av1_encode_strategy() and passed down to av1_e...
struct PrimaryMultiThreadInfo PrimaryMultiThreadInfo
Primary Encoder parameters related to multi-threading.
struct EncodeFrameInput EncodeFrameInput
Input frames and last input frame.
struct MultiThreadInfo MultiThreadInfo
Encoder parameters related to multi-threading.
struct AV1_COMP_DATA AV1_COMP_DATA
Structure to hold data corresponding to an encoded frame.
LOOPFILTER_CONTROL
This enum controls to which frames loopfilter is applied.
Definition: encoder.h:229
@ LOOPFILTER_ALL
Definition: encoder.h:231
@ LOOPFILTER_SELECTIVELY
Definition: encoder.h:233
@ LOOPFILTER_REFERENCE
Definition: encoder.h:232
@ LOOPFILTER_NONE
Definition: encoder.h:230
#define NUM_RECODES_PER_FRAME
Max number of recodes used to track the frame probabilities.
Definition: encoder.h:1614
struct AV1_PRIMARY AV1_PRIMARY
Top level primary encoder structure.
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:241
struct RestoreStateBuffers RestoreStateBuffers
Buffers to be backed up during parallel encode set to be restored later.
struct AV1EncoderConfig AV1EncoderConfig
Main encoder configuration data structure.
#define MAX_PARALLEL_FRAMES
Max number of frames that can be encoded in a parallel encode set.
Definition: encoder.h:1619
RestorationType
This enumeration defines various restoration types supported.
Definition: enums.h:609
@ RESTORE_NONE
Definition: enums.h:610
@ RESTORE_SWITCHABLE_TYPES
Definition: enums.h:614
@ RESTORE_TYPES
Definition: enums.h:615
aom_dist_metric
Distortion metric to use for RD optimization.
Definition: aomcx.h:1653
aom_tune_content
Definition: aomcx.h:1614
enum aom_scaling_mode_1d AOM_SCALING_MODE
aom 1-D scaling mode
aom_tune_metric
Model tuning parameters.
Definition: aomcx.h:1633
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
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:4694
int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags, const YV12_BUFFER_CONFIG *sd, int64_t time_stamp, int64_t end_time_stamp)
Obtain the raw frame data.
Definition: encoder.c:4085
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:3987
static int has_no_stats_stage(const AV1_COMP *const cpi)
Check if the current stage has statistics.
Definition: encoder.h:4089
Describes look ahead buffer operations.
@ CDEF_PICK_FROM_Q
Definition: speed_features.h:172
Top level common structure used by both encoder and decoder.
Definition: av1_common_int.h:752
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:1584
pthread_mutex_t * mutex_
Definition: encoder.h:1589
pthread_cond_t * cond_
Definition: encoder.h:1593
Encoder data related to row-based multi-threading.
Definition: encoder.h:1494
int allocated_sb_rows
Definition: encoder.h:1533
pthread_mutex_t * mutex_
Definition: encoder.h:1559
int allocated_tile_cols
Definition: encoder.h:1502
bool firstpass_mt_exit
Definition: encoder.h:1546
int allocated_cols
Definition: encoder.h:1516
bool mb_wiener_mt_exit
Definition: encoder.h:1553
pthread_cond_t * cond_
Definition: encoder.h:1563
bool row_mt_exit
Definition: encoder.h:1539
int allocated_tile_rows
Definition: encoder.h:1498
int allocated_rows
Definition: encoder.h:1509
int * num_tile_cols_done
Definition: encoder.h:1527
Encoder parameters for synchronization of row based multi-threading.
Definition: encoder.h:1376
int rows
Definition: encoder.h:1409
int sync_range
Definition: encoder.h:1398
int intrabc_extra_top_right_sb_delay
Definition: encoder.h:1405
int next_mi_row
Definition: encoder.h:1413
pthread_mutex_t * mutex_
Definition: encoder.h:1382
pthread_cond_t * cond_
Definition: encoder.h:1383
int num_threads_working
Definition: encoder.h:1417
Main encoder configuration data structure.
Definition: encoder.h:916
RateControlCfg rc_cfg
Definition: encoder.h:938
KeyFrameCfg kf_cfg
Definition: encoder.h:933
enum aom_enc_pass pass
Definition: encoder.h:1041
AlgoCfg algo_cfg
Definition: encoder.h:928
aom_fixed_buf_t twopass_stats_in
Definition: encoder.h:955
Structure to hold search parameter per restoration unit and intermediate buffer of Wiener filter used...
Definition: encoder.h:1673
int16_t * dgd_avg
Definition: encoder.h:1683
Structure to hold data corresponding to an encoded frame.
Definition: encoder.h:2515
int64_t ts_frame_end
Definition: encoder.h:2544
int pop_lookahead
Definition: encoder.h:2559
int64_t ts_frame_start
Definition: encoder.h:2539
unsigned char * cx_data
Definition: encoder.h:2519
size_t cx_data_sz
Definition: encoder.h:2524
int flush
Definition: encoder.h:2549
int frame_display_order_hint
Definition: encoder.h:2564
unsigned int lib_flags
Definition: encoder.h:2534
size_t frame_size
Definition: encoder.h:2529
const aom_rational64_t * timestamp_ratio
Definition: encoder.h:2554
Top level encoder structure.
Definition: encoder.h:2866
double * ext_rate_distribution
Definition: encoder.h:3543
int do_update_frame_probs_warp[10]
Definition: encoder.h:3252
uint8_t * consec_zero_mv
Definition: encoder.h:3453
int do_update_frame_probs_obmc[10]
Definition: encoder.h:3247
struct aom_denoise_and_model_t * denoise_and_model
Definition: encoder.h:3320
int skip_tpl_setup_stats
Definition: encoder.h:2974
int frames_since_last_update
Definition: encoder.h:3627
int * mb_delta_q
Definition: encoder.h:3563
int vaq_refresh
Definition: encoder.h:3222
FRAME_TYPE last_frame_type
Definition: encoder.h:3418
YV12_BUFFER_CONFIG * unscaled_source
Definition: encoder.h:2942
int palette_pixel_num
Definition: encoder.h:3656
CYCLIC_REFRESH * cyclic_refresh
Definition: encoder.h:3114
RATE_CONTROL rc
Definition: encoder.h:3073
int deltaq_used
Definition: encoder.h:3376
ActiveMap active_map
Definition: encoder.h:3119
bool frame_size_related_setup_done
Definition: encoder.h:3185
WeberStats * mb_weber_stats
Definition: encoder.h:3531
bool refresh_idx_available
Definition: encoder.h:3496
TokenInfo token_info
Definition: encoder.h:3217
int64_t ambient_err
Definition: encoder.h:3042
aom_film_grain_table_t * film_grain_table
Definition: encoder.h:3313
int ref_refresh_index
Definition: encoder.h:3490
size_t available_bs_size
Definition: encoder.h:3474
SPEED_FEATURES sf
Definition: encoder.h:3093
TRELLIS_OPT_TYPE optimize_seg_arr[8]
Definition: encoder.h:2920
ExtPartController ext_part_controller
Definition: encoder.h:3480
FILE * second_pass_log_stream
Definition: encoder.h:3597
double * ssim_rdmult_scaling_factors
Definition: encoder.h:3388
RD_OPT rd
Definition: encoder.h:3047
int data_alloc_height
Definition: encoder.h:3171
int num_tg
Definition: encoder.h:3423
WinnerModeParams winner_mode_params
Definition: encoder.h:3063
ExternalFlags ext_flags
Definition: encoder.h:3025
bool alloc_pyramid
Definition: encoder.h:3638
EncSegmentationInfo enc_seg
Definition: encoder.h:3109
MotionVectorSearchParams mv_search_params
Definition: encoder.h:3098
int use_screen_content_tools
Definition: encoder.h:3335
int do_update_frame_probs_interpfilter[10]
Definition: encoder.h:3257
CODING_CONTEXT coding_context
Definition: encoder.h:3053
TemporalFilterCtx tf_ctx
Definition: encoder.h:2989
ForceIntegerMVInfo force_intpel_info
Definition: encoder.h:2999
GlobalMotionInfo gm_info
Definition: encoder.h:3058
int consec_zero_mv_alloc_size
Definition: encoder.h:3458
CoeffBufferPool coeff_buffer_pool
Definition: encoder.h:2904
FRAME_INDEX_SET frame_index_set
Definition: encoder.h:3157
int ref_frame_flags
Definition: encoder.h:3083
RefCntBuffer * scaled_ref_buf[INTER_REFS_PER_FRAME]
Definition: encoder.h:3005
unsigned char gf_frame_index
Definition: encoder.h:3124
AV1EncoderConfig oxcf
Definition: encoder.h:2914
AV1_COMMON common
Definition: encoder.h:2909
AV1LrStruct lr_ctxt
Definition: encoder.h:3303
bool do_frame_data_update
Definition: encoder.h:3519
CdefSearchCtx * cdef_search_ctx
Definition: encoder.h:2994
int data_alloc_width
Definition: encoder.h:3164
int do_update_frame_probs_txtype[10]
Definition: encoder.h:3242
FRAME_COUNTS counts
Definition: encoder.h:2886
COMPRESSOR_STAGE compressor_stage
Definition: encoder.h:3412
int intrabc_used
Definition: encoder.h:3293
int num_frame_recode
Definition: encoder.h:3232
int rt_reduce_num_ref_buffers
Definition: encoder.h:3020
RefreshFrameInfo refresh_frame
Definition: encoder.h:3015
int prune_ref_frame_mask
Definition: encoder.h:3298
YV12_BUFFER_CONFIG * unscaled_last_source
Definition: encoder.h:2952
THIRD_PASS_DEC_CTX * third_pass_ctx
Definition: encoder.h:3592
int all_one_sided_refs
Definition: encoder.h:3104
MultiThreadInfo mt_info
Definition: encoder.h:3281
VarBasedPartitionInfo vbp_info
Definition: encoder.h:3227
int scaled_last_source_available
Definition: encoder.h:3662
YV12_BUFFER_CONFIG * last_source
Definition: encoder.h:2936
int existing_fb_idx_to_show
Definition: encoder.h:3288
YV12_BUFFER_CONFIG * unfiltered_source
Definition: encoder.h:2963
unsigned int zeromv_skip_thresh_exit_part[BLOCK_SIZES_ALL]
Definition: encoder.h:3632
FRAME_INFO frame_info
Definition: encoder.h:3152
int last_coded_height
Definition: encoder.h:3197
int frame_header_count
Definition: encoder.h:3371
int droppable
Definition: encoder.h:3147
RefCntBuffer * last_show_frame_buf
Definition: encoder.h:3010
aom_superres_mode superres_mode
Definition: encoder.h:3430
MBMIExtFrameBufferInfo mbmi_ext_info
Definition: encoder.h:2891
AV1LrPickStruct pick_lr_ctxt
Definition: encoder.h:3308
double new_framerate
Definition: encoder.h:3271
AV1_PRIMARY * ppi
Definition: encoder.h:2870
uint64_t * src_sad_blk_64x64
Definition: encoder.h:3602
int64_t norm_wiener_variance
Definition: encoder.h:3558
double * tpl_rdmult_scaling_factors
Definition: encoder.h:2984
int sb_counter
Definition: encoder.h:3469
int last_coded_width
Definition: encoder.h:3191
TileDataEnc * tile_data
Definition: encoder.h:3208
int is_screen_content_type
Definition: encoder.h:3343
BLOCK_SIZE weber_bsize
Definition: encoder.h:3553
InterpSearchFlags interp_search_flags
Definition: encoder.h:3326
TimeStamps time_stamps
Definition: encoder.h:3068
int ref_idx_to_skip
Definition: encoder.h:3503
YV12_BUFFER_CONFIG orig_source
Definition: encoder.h:2969
FirstPassData firstpass_data
Definition: encoder.h:3435
double framerate
Definition: encoder.h:3078
int speed
Definition: encoder.h:3088
BLOCK_SIZE fp_block_size
Definition: encoder.h:3463
int use_ducky_encode
Definition: encoder.h:3615
YV12_BUFFER_CONFIG trial_frame_rst
Definition: encoder.h:3037
bool is_dropped_frame
Definition: encoder.h:3568
ThreadData td
Definition: encoder.h:2881
ResizePendingParams resize_pending_params
Definition: encoder.h:3202
YV12_BUFFER_CONFIG scaled_source
Definition: encoder.h:2947
int do_update_vbr_bits_off_target_fast
Definition: encoder.h:3276
YV12_BUFFER_CONFIG last_frame_uf
Definition: encoder.h:3031
EncQuantDequantParams enc_quant_dequant_params
Definition: encoder.h:2876
RefFrameDistanceInfo ref_frame_dist_info
Definition: encoder.h:3381
int * prep_rate_estimates
Definition: encoder.h:3537
DuckyEncodeInfo ducky_encode_info
Definition: encoder.h:3621
double ext_rate_scale
Definition: encoder.h:3548
int initial_mbs
Definition: encoder.h:3179
uint64_t rec_sse
Definition: encoder.h:3609
YV12_BUFFER_CONFIG scaled_last_source
Definition: encoder.h:2957
MV_STATS mv_stats
Definition: encoder.h:3486
FrameProbInfo frame_new_probs[10]
Definition: encoder.h:3237
YV12_BUFFER_CONFIG * source
Definition: encoder.h:2927
int allocated_tiles
Definition: encoder.h:3212
SVC svc
Definition: encoder.h:3407
CB_COEFF_BUFFER * coeff_buffer_base
Definition: encoder.h:2898
NOISE_ESTIMATE noise_estimate
Definition: encoder.h:3440
TWO_PASS_FRAME twopass_frame
Definition: encoder.h:3587
Top level primary encoder structure.
Definition: encoder.h:2570
int num_fp_contexts
Definition: encoder.h:2627
AV1EncRowMultiThreadSync intra_row_mt_sync
Definition: encoder.h:2860
bool buffer_removal_time_present
Definition: encoder.h:2741
int valid_gm_model_found[FRAME_UPDATE_TYPES]
Definition: encoder.h:2849
struct aom_codec_pkt_list * output_pkt_list
Definition: encoder.h:2671
int filter_level[2]
Definition: encoder.h:2632
SequenceHeader seq_params
Definition: encoder.h:2731
MV_STATS mv_stats
Definition: encoder.h:2779
struct AV1_COMP * cpi
Definition: encoder.h:2648
AV1LevelParams level_params
Definition: encoder.h:2701
int internal_altref_allowed
Definition: encoder.h:2676
RTC_REF rtc_ref
Definition: encoder.h:2854
int b_calculate_psnr
Definition: encoder.h:2706
PrimaryMultiThreadInfo p_mt_info
Definition: encoder.h:2836
TEMPORAL_FILTER_INFO tf_info
Definition: encoder.h:2726
TWO_PASS twopass
Definition: encoder.h:2716
int frames_left
Definition: encoder.h:2711
int64_t ts_start_last_show_frame
Definition: encoder.h:2617
PRIMARY_RATE_CONTROL p_rc
Definition: encoder.h:2721
int lap_enabled
Definition: encoder.h:2696
FrameProbInfo frame_probs
Definition: encoder.h:2841
int show_existing_alt_ref
Definition: encoder.h:2681
int fb_of_context_type[REF_FRAMES]
Definition: encoder.h:2831
int use_svc
Definition: encoder.h:2736
double * tpl_sb_rdmult_scaling_factors
Definition: encoder.h:2769
int filter_level_v
Definition: encoder.h:2642
int filter_level_u
Definition: encoder.h:2637
struct AV1_COMP * cpi_lap
Definition: encoder.h:2653
struct AV1_COMP * parallel_cpi[4]
Definition: encoder.h:2574
int64_t ts_end_last_show_frame
Definition: encoder.h:2622
struct lookahead_ctx * lookahead
Definition: encoder.h:2658
GF_STATE gf_state
Definition: encoder.h:2691
aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL]
Definition: encoder.h:2763
GF_GROUP gf_group
Definition: encoder.h:2686
struct AV1_COMP_DATA parallel_frames_data[4 - 1]
Definition: encoder.h:2580
TplParams tpl_data
Definition: encoder.h:2774
unsigned int number_temporal_layers
Definition: encoder.h:2746
unsigned int number_spatial_layers
Definition: encoder.h:2751
int seq_params_locked
Definition: encoder.h:2665
struct aom_internal_error_info error
Definition: encoder.h:2756
Algorithm configuration parameters.
Definition: encoder.h:810
int disable_trellis_quant
Definition: encoder.h:826
int sharpness
Definition: encoder.h:817
bool skip_postproc_filtering
Definition: encoder.h:870
int arnr_max_frames
Definition: encoder.h:831
bool enable_tpl_model
Definition: encoder.h:849
LOOPFILTER_CONTROL loopfilter_control
Definition: encoder.h:864
uint8_t cdf_update_mode
Definition: encoder.h:844
bool enable_overlay
Definition: encoder.h:855
int arnr_strength
Definition: encoder.h:836
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:2421
uint8_t * entropy_ctx
Definition: encoder.h:2433
tran_low_t * tcoeff
Definition: encoder.h:2425
uint16_t * eobs
Definition: encoder.h:2429
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:396
bool enable_masked_comp
Definition: encoder.h:405
bool enable_diff_wtd_comp
Definition: encoder.h:413
bool enable_smooth_interintra
Definition: encoder.h:409
bool enable_interintra_wedge
Definition: encoder.h:421
bool enable_interinter_wedge
Definition: encoder.h:417
bool enable_dist_wtd_comp
Definition: encoder.h:400
Contains buffers used by av1_compound_type_rd()
Definition: block.h:366
Segmentation related information for the current frame.
Definition: encoder.h:2384
uint8_t * map
Definition: encoder.h:2390
bool has_lossless_segment
Definition: encoder.h:2396
Input frames and last input frame.
Definition: encoder.h:3668
contains per-frame encoding parameters decided upon by av1_encode_strategy() and passed down to av1_e...
Definition: encoder.h:3680
int error_resilient_mode
Definition: encoder.h:3684
int remapped_ref_idx[REF_FRAMES]
Definition: encoder.h:3715
int ref_frame_flags
Definition: encoder.h:3710
int speed
Definition: encoder.h:3726
FRAME_TYPE frame_type
Definition: encoder.h:3688
int show_frame
Definition: encoder.h:3698
RefreshFrameInfo refresh_frame
Definition: encoder.h:3721
Frame refresh flags set by the external interface.
Definition: encoder.h:2251
bool golden_frame
Definition: encoder.h:2253
bool bwd_ref_frame
Definition: encoder.h:2254
bool update_pending
Definition: encoder.h:2260
bool last_frame
Definition: encoder.h:2252
bool alt_ref_frame
Definition: encoder.h:2256
bool alt2_ref_frame
Definition: encoder.h:2255
Flags signalled by the external interface at frame level.
Definition: encoder.h:2266
bool use_primary_ref_none
Definition: encoder.h:2307
bool use_ref_frame_mvs
Definition: encoder.h:2291
ExtRefreshFrameFlagsInfo refresh_frame
Definition: encoder.h:2275
int ref_frame_flags
Definition: encoder.h:2270
bool use_error_resilient
Definition: encoder.h:2296
bool use_s_frame
Definition: encoder.h:2301
bool refresh_frame_context
Definition: encoder.h:2280
bool refresh_frame_context_pending
Definition: encoder.h:2286
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:1845
int rate_size
Definition: encoder.h:1858
int rate_index
Definition: encoder.h:1854
Encoder-side probabilities for pruning of various AV1 tools.
Definition: encoder.h:1104
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:2054
bool search_done
Definition: encoder.h:2058
int segment_map_h
Definition: encoder.h:2087
int segment_map_w
Definition: encoder.h:2086
Flags related to interpolation filter search.
Definition: encoder.h:2094
int default_interp_skip_flags
Definition: encoder.h:2099
uint16_t interp_filter_search_mask
Definition: encoder.h:2103
Holds mv costs for intrabc.
Definition: block.h:789
Encoder flags for intra prediction.
Definition: encoder.h:299
bool enable_diagonal_intra
Definition: encoder.h:329
bool enable_smooth_intra
Definition: encoder.h:312
bool auto_intra_tools_off
Definition: encoder.h:348
bool enable_filter_intra
Definition: encoder.h:308
bool enable_directional_intra
Definition: encoder.h:324
bool enable_paeth_intra
Definition: encoder.h:316
bool enable_intra_edge_filter
Definition: encoder.h:303
bool enable_cfl_intra
Definition: encoder.h:320
bool enable_angle_delta
Definition: encoder.h:334
Encoder config related to the coding of key frames.
Definition: encoder.h:463
int key_freq_max
Definition: encoder.h:472
int sframe_mode
Definition: encoder.h:490
bool auto_key
Definition: encoder.h:495
bool enable_intrabc
Definition: encoder.h:515
int sframe_dist
Definition: encoder.h:483
bool enable_sframe
Definition: encoder.h:510
int enable_keyframe_filtering
Definition: encoder.h:477
int fwd_kf_dist
Definition: encoder.h:500
int key_freq_min
Definition: encoder.h:467
bool fwd_kf_enabled
Definition: encoder.h:505
Buffer to store mode information at mi_alloc_bsize (4x4 or 8x8) level.
Definition: encoder.h:1891
int alloc_size
Definition: encoder.h:1900
int stride
Definition: encoder.h:1904
MB_MODE_INFO_EXT_FRAME * frame_base
Definition: encoder.h:1896
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:2109
int max_mv_magnitude
Definition: encoder.h:2115
fractional_mv_step_fp * find_fractional_mv_step
Definition: encoder.h:2129
int mv_step_param
Definition: encoder.h:2120
Encoder parameters related to multi-threading.
Definition: encoder.h:1736
RestoreStateBuffers restore_state_buf
Definition: encoder.h:1823
AV1CdefWorkerData * cdef_worker
Definition: encoder.h:1818
AV1LrSync lr_row_sync
Definition: encoder.h:1793
struct EncWorkerData * tile_thr_data
Definition: encoder.h:1756
AV1TplRowMultiThreadInfo tpl_row_mt
Definition: encoder.h:1783
AV1EncPackBSSync pack_bs_sync
Definition: encoder.h:1798
AV1EncRowMultiThreadInfo enc_row_mt
Definition: encoder.h:1772
AV1LfSync lf_row_sync
Definition: encoder.h:1788
AV1CdefSync cdef_sync
Definition: encoder.h:1813
int num_mod_workers[NUM_MT_MODULES]
Definition: encoder.h:1745
AV1EncAllIntraMultiThreadInfo intra_mt
Definition: encoder.h:1778
int num_workers
Definition: encoder.h:1740
int pipeline_lpf_mt_with_enc
Definition: encoder.h:1829
AVxWorker * workers
Definition: encoder.h:1750
bool pack_bs_mt_enabled
Definition: encoder.h:1767
bool row_mt_enabled
Definition: encoder.h:1762
AV1TemporalFilterSync tf_sync
Definition: encoder.h:1808
AV1GlobalMotionSync gm_sync
Definition: encoder.h:1803
Holds mv costs for encoding and motion search.
Definition: block.h:758
Contains buffers used to speed up rdopt for obmc.
Definition: block.h:329
Contains color maps used in palette mode.
Definition: block.h:354
Primary Rate Control parameters and status.
Definition: ratectrl.h:291
Encoder config for coding block partitioning.
Definition: encoder.h:271
bool enable_rect_partitions
Definition: encoder.h:275
bool enable_1to4_partitions
Definition: encoder.h:283
BLOCK_SIZE max_partition_size
Definition: encoder.h:293
bool enable_ab_partitions
Definition: encoder.h:279
BLOCK_SIZE min_partition_size
Definition: encoder.h:288
Primary Encoder parameters related to multi-threading.
Definition: encoder.h:1689
struct EncWorkerData * tile_thr_data
Definition: encoder.h:1709
AV1CdefWorkerData * cdef_worker
Definition: encoder.h:1714
int num_workers
Definition: encoder.h:1693
int prev_num_enc_workers
Definition: encoder.h:1730
AVxWorker * workers
Definition: encoder.h:1703
AVxWorker * p_workers[4]
Definition: encoder.h:1720
int p_num_workers
Definition: encoder.h:1725
int num_mod_workers[NUM_MT_MODULES]
Definition: encoder.h:1698
Rate Control parameters and status.
Definition: ratectrl.h:134
Encoder rate control configuration parameters.
Definition: encoder.h:521
int worst_allowed_q
Definition: encoder.h:591
int over_shoot_pct
Definition: encoder.h:586
unsigned int max_intra_bitrate_pct
Definition: encoder.h:556
int drop_frames_water_mark
Definition: encoder.h:574
int vbrmax_section
Definition: encoder.h:622
int64_t maximum_buffer_size_ms
Definition: encoder.h:540
unsigned int vbr_corpus_complexity_lap
Definition: encoder.h:551
unsigned int min_cr
Definition: encoder.h:570
int vbrbias
Definition: encoder.h:612
unsigned int gf_cbr_boost_pct
Definition: encoder.h:565
int vbrmin_section
Definition: encoder.h:617
unsigned int max_inter_bitrate_pct
Definition: encoder.h:561
int64_t starting_buffer_level_ms
Definition: encoder.h:530
int best_allowed_q
Definition: encoder.h:596
int under_shoot_pct
Definition: encoder.h:580
int64_t target_bandwidth
Definition: encoder.h:545
int64_t optimal_buffer_level_ms
Definition: encoder.h:535
int cq_level
Definition: encoder.h:600
Refrence frame distance related variables.
Definition: encoder.h:2168
int8_t nearest_past_ref
Definition: encoder.h:2176
int8_t nearest_future_ref
Definition: encoder.h:2180
Refresh frame flags for different type of frames.
Definition: encoder.h:2147
bool bwd_ref_frame
Definition: encoder.h:2149
bool golden_frame
Definition: encoder.h:2148
bool alt_ref_frame
Definition: encoder.h:2150
Encoder config related to resize.
Definition: encoder.h:251
uint8_t resize_scale_denominator
Definition: encoder.h:260
uint8_t resize_kf_scale_denominator
Definition: encoder.h:265
RESIZE_MODE resize_mode
Definition: encoder.h:255
Desired dimensions for an externally triggered resize.
Definition: encoder.h:2160
int width
Definition: encoder.h:2161
int height
Definition: encoder.h:2162
Parameters related to restoration types.
Definition: encoder.h:1650
WienerInfo wiener
Definition: encoder.h:1654
SgrprojInfo sgrproj
Definition: encoder.h:1659
Parameters related to Restoration Info.
Definition: restoration.h:246
RestorationType frame_restoration_type
Definition: restoration.h:250
Buffers to be backed up during parallel encode set to be restored later.
Definition: encoder.h:1625
int32_t * rst_tmpbuf
Definition: encoder.h:1639
RestorationLineBuffers * rlbs
Definition: encoder.h:1644
uint16_t * cdef_colbuf[3]
Definition: encoder.h:1634
uint16_t * cdef_srcbuf
Definition: encoder.h:1629
Top level speed vs quality trade off data struture.
Definition: speed_features.h:1912
MV_SPEED_FEATURES mv_sf
Definition: speed_features.h:1941
LOOP_FILTER_SPEED_FEATURES lpf_sf
Definition: speed_features.h:1976
TX_SPEED_FEATURES tx_sf
Definition: speed_features.h:1961
REAL_TIME_SPEED_FEATURES rt_sf
Definition: speed_features.h:1981
The stucture of SVC.
Definition: svc_layercontext.h:88
Parameters related to Sgrproj Filter.
Definition: blockd.h:507
Encoder config related to frame super-resolution.
Definition: encoder.h:427
uint8_t superres_kf_scale_denominator
Definition: encoder.h:449
aom_superres_mode superres_mode
Definition: encoder.h:453
int superres_kf_qthresh
Definition: encoder.h:437
bool enable_superres
Definition: encoder.h:457
uint8_t superres_scale_denominator
Definition: encoder.h:443
int superres_qthresh
Definition: encoder.h:432
Temporal filter info for a gop.
Definition: temporal_filter.h:161
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:98
Frame time stamps.
Definition: encoder.h:2402
int64_t prev_ts_start
Definition: encoder.h:2406
int64_t first_ts_start
Definition: encoder.h:2414
int64_t prev_ts_end
Definition: encoder.h:2410
Params related to temporal dependency model.
Definition: tpl_model.h:165
Encoder flags for transform sizes and types.
Definition: encoder.h:354
bool enable_tx64
Definition: encoder.h:358
bool use_inter_dct_only
Definition: encoder.h:381
bool enable_flip_idtx
Definition: encoder.h:362
bool use_intra_default_tx_only
Definition: encoder.h:386
bool use_intra_dct_only
Definition: encoder.h:376
bool enable_rect_tx
Definition: encoder.h:366
bool reduced_tx_type_set
Definition: encoder.h:371
bool enable_tx_size_search
Definition: encoder.h:390
Thresholds for variance based partitioning.
Definition: encoder.h:1355
int64_t threshold_minmax
Definition: encoder.h:1370
Parameters related to Wiener Filter.
Definition: blockd.h:494
Parameters used for winner mode processing.
Definition: encoder.h:2198
Generic fixed size buffer structure.
Definition: aom_encoder.h:86
Struct used to hold inter mode data for fast tx search.
Definition: encoder.h:1260
RD_STATS rd_cost_arr[MAX_INTER_MODES]
Definition: encoder.h:1289
int64_t est_rd_arr[MAX_INTER_MODES]
Definition: encoder.h:1281
int64_t sse_arr[MAX_INTER_MODES]
Definition: encoder.h:1277
RD_STATS rd_cost_y_arr[MAX_INTER_MODES]
Definition: encoder.h:1293
RD_STATS rd_cost_uv_arr[MAX_INTER_MODES]
Definition: encoder.h:1297
MB_MODE_INFO mbmi_arr[MAX_INTER_MODES]
Definition: encoder.h:1269
RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES]
Definition: encoder.h:1285
int mode_rate_arr[MAX_INTER_MODES]
Definition: encoder.h:1273
int num
Definition: encoder.h:1265
Encoder's parameters related to the current coding block.
Definition: block.h:878
MB_MODE_INFO_EXT_FRAME * mbmi_ext_frame
Finalized mbmi_ext for the whole frame.
Definition: block.h:910
Variables related to current coding block.
Definition: blockd.h:570
const struct scale_factors * block_ref_scale_factors[2]
Definition: blockd.h:687
YV12 frame buffer data structure.
Definition: yv12config.h:46