blob: 1a0cbbbd35d2e9d9912cdc6e804cb29ff5ec2f18 [file] [log] [blame]
Yaowu Xuc27fc142016-08-22 16:08:15 -07001/*
Urvang Joshi8a02d762016-07-28 15:51:12 -07002 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
Yaowu Xuc27fc142016-08-22 16:08:15 -07003 *
Urvang Joshi8a02d762016-07-28 15:51:12 -07004 * 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.
Yaowu Xuc27fc142016-08-22 16:08:15 -070010 */
11
James Zerne1cbb132018-08-22 14:10:36 -070012#ifndef AOM_AV1_ENCODER_ENCODER_H_
13#define AOM_AV1_ENCODER_ENCODER_H_
Yaowu Xuc27fc142016-08-22 16:08:15 -070014
elliottkb8becb22019-03-04 01:01:30 -080015#include <stdbool.h>
Yaowu Xuc27fc142016-08-22 16:08:15 -070016#include <stdio.h>
17
Tom Finegan60e653d2018-05-22 11:34:58 -070018#include "config/aom_config.h"
19
Yaowu Xuf883b422016-08-30 14:01:10 -070020#include "aom/aomcx.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070021
22#include "av1/common/alloccommon.h"
23#include "av1/common/entropymode.h"
24#include "av1/common/thread_common.h"
25#include "av1/common/onyxc_int.h"
Fergus Simpsond2bcbb52017-05-22 23:15:05 -070026#include "av1/common/resize.h"
Andrey Norkin795ba872018-03-06 13:24:14 -080027#include "av1/common/timing.h"
kyslov7b9d0d62018-12-21 11:12:26 -080028#include "av1/common/blockd.h"
29#include "av1/common/enums.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070030#include "av1/encoder/aq_cyclicrefresh.h"
Tom Finegan17ce8b12017-02-08 12:46:31 -080031#include "av1/encoder/av1_quantize.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070032#include "av1/encoder/context_tree.h"
33#include "av1/encoder/encodemb.h"
34#include "av1/encoder/firstpass.h"
chiyotsaid16a2572019-03-05 17:48:10 -080035#include "av1/encoder/level.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070036#include "av1/encoder/lookahead.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070037#include "av1/encoder/mcomp.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070038#include "av1/encoder/ratectrl.h"
39#include "av1/encoder/rd.h"
40#include "av1/encoder/speed_features.h"
Marco Paniconi5b1e4732019-08-08 18:57:53 -070041#include "av1/encoder/svc_layercontext.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070042#include "av1/encoder/tokenize.h"
kyslov7b9d0d62018-12-21 11:12:26 -080043#include "av1/encoder/block.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070044
45#if CONFIG_INTERNAL_STATS
46#include "aom_dsp/ssim.h"
47#endif
48#include "aom_dsp/variance.h"
Neil Birkbecka2893ab2018-06-08 14:45:13 -070049#if CONFIG_DENOISE
50#include "aom_dsp/noise_model.h"
51#endif
Yaowu Xuf883b422016-08-30 14:01:10 -070052#include "aom/internal/aom_codec_internal.h"
53#include "aom_util/aom_thread.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070054
55#ifdef __cplusplus
56extern "C" {
57#endif
58
Yue Chenc79fd242019-04-05 14:49:29 -070059// Rational number with an int64 numerator
60// This structure holds a fractional value
Yue Chen1bc5be62018-08-24 13:57:32 -070061typedef struct aom_rational64 {
Yue Chenc79fd242019-04-05 14:49:29 -070062 int64_t num; // fraction numerator
63 int den; // fraction denominator
64} aom_rational64_t; // alias for struct aom_rational
Yue Chen1bc5be62018-08-24 13:57:32 -070065
Yaowu Xuc27fc142016-08-22 16:08:15 -070066typedef struct {
Urvang Joshi0e8b6ed2019-06-20 15:36:21 -070067#if CONFIG_SUPERRES_IN_RECODE
68 struct loopfilter lf;
69 CdefInfo cdef_info;
70 YV12_BUFFER_CONFIG copy_buffer;
71 RATE_CONTROL rc;
72#endif // CONFIG_SUPERRES_IN_RECODE
Yaowu Xuc27fc142016-08-22 16:08:15 -070073} CODING_CONTEXT;
74
Satish Kumar Suman4667aa12018-12-14 18:28:19 +053075enum {
Urvang Joshif70375a2019-03-22 23:30:19 -070076 REGULAR_FRAME, // regular inter frame
77 ARF_FRAME, // alternate reference frame
78 OVERLAY_FRAME, // overlay frame
79 GLD_FRAME, // golden frame
80 BRF_FRAME, // backward reference frame
81 INTERNAL_ARF_FRAME, // internal alternate reference frame
Thomas Daede51020e12017-12-14 20:12:44 -080082 FRAME_CONTEXT_INDEXES
Satish Kumar Suman4667aa12018-12-14 18:28:19 +053083} UENUM1BYTE(FRAME_CONTEXT_INDEX);
Yaowu Xuc27fc142016-08-22 16:08:15 -070084
Satish Kumar Suman4667aa12018-12-14 18:28:19 +053085enum {
Yaowu Xuc27fc142016-08-22 16:08:15 -070086 NORMAL = 0,
87 FOURFIVE = 1,
88 THREEFIVE = 2,
89 ONETWO = 3
Satish Kumar Suman4667aa12018-12-14 18:28:19 +053090} UENUM1BYTE(AOM_SCALING);
Yaowu Xuc27fc142016-08-22 16:08:15 -070091
Satish Kumar Suman4667aa12018-12-14 18:28:19 +053092enum {
Yaowu Xuc27fc142016-08-22 16:08:15 -070093 // Good Quality Fast Encoding. The encoder balances quality with the amount of
94 // time it takes to encode the output. Speed setting controls how fast.
kyslov7b9d0d62018-12-21 11:12:26 -080095 GOOD,
96 // Realtime Fast Encoding. Will force some restrictions on bitrate
97 // constraints.
98 REALTIME
Satish Kumar Suman4667aa12018-12-14 18:28:19 +053099} UENUM1BYTE(MODE);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700100
Satish Kumar Suman4667aa12018-12-14 18:28:19 +0530101enum {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700102 FRAMEFLAGS_KEY = 1 << 0,
103 FRAMEFLAGS_GOLDEN = 1 << 1,
Yaowu Xuc27fc142016-08-22 16:08:15 -0700104 FRAMEFLAGS_BWDREF = 1 << 2,
Zoe Liu3ac20932017-08-30 16:35:55 -0700105 // TODO(zoeliu): To determine whether a frame flag is needed for ALTREF2_FRAME
Yaowu Xuc27fc142016-08-22 16:08:15 -0700106 FRAMEFLAGS_ALTREF = 1 << 3,
Debargha Mukherjee57378252018-09-21 18:29:37 -0700107 FRAMEFLAGS_INTRAONLY = 1 << 4,
108 FRAMEFLAGS_SWITCH = 1 << 5,
109 FRAMEFLAGS_ERROR_RESILIENT = 1 << 6,
Satish Kumar Suman4667aa12018-12-14 18:28:19 +0530110} UENUM1BYTE(FRAMETYPE_FLAGS);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700111
Satish Kumar Suman4667aa12018-12-14 18:28:19 +0530112enum {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700113 NO_AQ = 0,
114 VARIANCE_AQ = 1,
115 COMPLEXITY_AQ = 2,
116 CYCLIC_REFRESH_AQ = 3,
117 AQ_MODE_COUNT // This should always be the last member of the enum
Satish Kumar Suman4667aa12018-12-14 18:28:19 +0530118} UENUM1BYTE(AQ_MODE);
119enum {
Fangwen Fu6160df22017-04-24 09:45:51 -0700120 NO_DELTA_Q = 0,
Debargha Mukherjee4fef7a52019-04-04 01:02:06 -0700121 DELTA_Q_OBJECTIVE = 1, // Modulation to improve objective quality
122 DELTA_Q_PERCEPTUAL = 2, // Modulation to improve perceptual quality
123 DELTA_Q_MODE_COUNT // This should always be the last member of the enum
Satish Kumar Suman4667aa12018-12-14 18:28:19 +0530124} UENUM1BYTE(DELTAQ_MODE);
Debargha Mukherjee3a4959f2018-02-26 15:34:03 -0800125
Satish Kumar Suman4667aa12018-12-14 18:28:19 +0530126enum {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700127 RESIZE_NONE = 0, // No frame resizing allowed.
Debargha Mukherjee7166f222017-09-05 21:32:42 -0700128 RESIZE_FIXED = 1, // All frames are coded at the specified scale.
129 RESIZE_RANDOM = 2, // All frames are coded at a random scale.
130 RESIZE_MODES
Satish Kumar Suman4667aa12018-12-14 18:28:19 +0530131} UENUM1BYTE(RESIZE_MODE);
Debargha Mukherjee3a4959f2018-02-26 15:34:03 -0800132
Satish Kumar Suman4667aa12018-12-14 18:28:19 +0530133enum {
Urvang Joshi36a83732019-01-31 15:31:57 -0800134 SUPERRES_NONE, // No frame superres allowed.
135 SUPERRES_FIXED, // All frames are coded at the specified scale,
136 // and super-resolved.
137 SUPERRES_RANDOM, // All frames are coded at a random scale,
138 // and super-resolved.
139 SUPERRES_QTHRESH, // Superres scale for a frame is determined based on
140 // q_index.
141 SUPERRES_AUTO, // Automatically select superres for appropriate frames.
Debargha Mukherjee7166f222017-09-05 21:32:42 -0700142 SUPERRES_MODES
Satish Kumar Suman4667aa12018-12-14 18:28:19 +0530143} UENUM1BYTE(SUPERRES_MODE);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700144
kyslov7b9d0d62018-12-21 11:12:26 -0800145typedef enum {
146 kInvalid = 0,
147 kLowSadLowSumdiff = 1,
148 kLowSadHighSumdiff = 2,
149 kHighSadLowSumdiff = 3,
150 kHighSadHighSumdiff = 4,
151 kLowVarHighSumdiff = 5,
152 kVeryHighSad = 6,
153} CONTENT_STATE_SB;
154
Satish Kumar Sumane6d0be52019-02-14 14:33:28 +0530155enum {
156 SS_CFG_SRC = 0,
157 SS_CFG_LOOKAHEAD = 1,
158 SS_CFG_TOTAL = 2
159} UENUM1BYTE(SS_CFG_OFFSET);
160
Jingning Han31a0ee92019-07-15 13:56:55 -0700161#define MAX_LENGTH_TPL_FRAME_STATS (27 + 9)
Yue Chenc9b23e02019-04-10 16:54:03 -0700162
Yue Chen7cae98f2018-08-24 10:43:16 -0700163typedef struct TplDepStats {
164 int64_t intra_cost;
165 int64_t inter_cost;
Jingning Hanfdd0ab42019-09-27 19:47:28 -0700166 int64_t srcrf_dist;
167 int64_t recrf_dist;
Jingning Han40e870f2019-10-02 16:05:39 -0700168 int64_t srcrf_rate;
169 int64_t recrf_rate;
Jingning Han40e870f2019-10-02 16:05:39 -0700170 int64_t mc_dep_rate;
171 int64_t mc_dep_dist;
Jingning Hane8baf832019-09-23 15:43:47 -0700172 int_mv mv;
173 int ref_frame_index;
Yue Chenbd934232019-08-05 14:23:39 -0700174#if !USE_TPL_CLASSIC_MODEL
Debargha Mukherjee88ff7382019-05-01 12:36:10 -0700175 int64_t mc_count;
176 int64_t mc_saved;
Yue Chenbd934232019-08-05 14:23:39 -0700177#endif // !USE_TPL_CLASSIC_MODEL
Yue Chen7cae98f2018-08-24 10:43:16 -0700178} TplDepStats;
179
180typedef struct TplDepFrame {
181 uint8_t is_valid;
182 TplDepStats *tpl_stats_ptr;
Jingning Han81d6fbb2019-07-15 10:14:13 -0700183 const YV12_BUFFER_CONFIG *gf_picture;
Jingning Han5e98d3b2019-09-23 21:59:36 -0700184 YV12_BUFFER_CONFIG rec_picture_buf;
185 YV12_BUFFER_CONFIG *rec_picture;
Jingning Han31a0ee92019-07-15 13:56:55 -0700186 int ref_map_index[REF_FRAMES];
Yue Chen7cae98f2018-08-24 10:43:16 -0700187 int stride;
188 int width;
189 int height;
190 int mi_rows;
191 int mi_cols;
Deepa K G33f1ab72019-09-23 17:59:06 +0530192 unsigned int frame_display_index;
Jingning Han40e870f2019-10-02 16:05:39 -0700193 int base_rdmult;
Yue Chen7cae98f2018-08-24 10:43:16 -0700194} TplDepFrame;
195
Debargha Mukherjee03ad12d2019-02-07 11:17:59 -0800196typedef enum {
197 COST_UPD_SB,
198 COST_UPD_SBROW,
199 COST_UPD_TILE,
Fyodor Kyslov25daf5d2019-10-23 10:33:26 -0700200 COST_UPD_OFF,
Debargha Mukherjee03ad12d2019-02-07 11:17:59 -0800201} COST_UPDATE_TYPE;
202
Yue Chen7cae98f2018-08-24 10:43:16 -0700203#define TPL_DEP_COST_SCALE_LOG2 4
204
Yaowu Xuf883b422016-08-30 14:01:10 -0700205typedef struct AV1EncoderConfig {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700206 BITSTREAM_PROFILE profile;
Tom Finegan8ab2bba2018-02-28 07:36:28 -0800207 aom_bit_depth_t bit_depth; // Codec bit-depth.
208 int width; // width of data passed to the compressor
209 int height; // height of data passed to the compressor
210 int forced_max_frame_width; // forced maximum width of frame (if != 0)
211 int forced_max_frame_height; // forced maximum height of frame (if != 0)
Yaowu Xuc27fc142016-08-22 16:08:15 -0700212 unsigned int input_bit_depth; // Input bit depth.
213 double init_framerate; // set to passed in framerate
214 int64_t target_bandwidth; // bandwidth to be used in bits per second
215
216 int noise_sensitivity; // pre processing blur: recommendation 0
217 int sharpness; // sharpening output: recommendation 0:
218 int speed;
219 // maximum allowed bitrate for any intra frame in % of bitrate target.
220 unsigned int rc_max_intra_bitrate_pct;
221 // maximum allowed bitrate for any inter frame in % of bitrate target.
222 unsigned int rc_max_inter_bitrate_pct;
223 // percent of rate boost for golden frame in CBR mode.
224 unsigned int gf_cbr_boost_pct;
225
226 MODE mode;
227 int pass;
228
229 // Key Framing Operations
230 int auto_key; // autodetect cut scenes and set the keyframes
231 int key_freq; // maximum distance to key frame.
Tarek AMARAc9813852018-03-05 18:40:18 -0500232 int sframe_dist;
233 int sframe_mode;
234 int sframe_enabled;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700235 int lag_in_frames; // how many frames lag before we start encoding
Sarah Parker93c03142018-05-22 13:35:45 -0700236 int fwd_kf_enabled;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700237
238 // ----------------------------------------------------------------
239 // DATARATE CONTROL OPTIONS
240
241 // vbr, cbr, constrained quality or constant quality
Yaowu Xuf883b422016-08-30 14:01:10 -0700242 enum aom_rc_mode rc_mode;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700243
244 // buffer targeting aggressiveness
245 int under_shoot_pct;
246 int over_shoot_pct;
247
248 // buffering parameters
249 int64_t starting_buffer_level_ms;
250 int64_t optimal_buffer_level_ms;
251 int64_t maximum_buffer_size_ms;
252
253 // Frame drop threshold.
254 int drop_frames_water_mark;
255
256 // controlling quality
257 int fixed_q;
258 int worst_allowed_q;
259 int best_allowed_q;
260 int cq_level;
Yue Chenc5806c22019-07-19 17:32:57 -0700261 int enable_chroma_deltaq;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700262 AQ_MODE aq_mode; // Adaptive Quantization mode
Fangwen Fu6160df22017-04-24 09:45:51 -0700263 DELTAQ_MODE deltaq_mode;
Debargha Mukherjee4fef7a52019-04-04 01:02:06 -0700264 int deltalf_mode;
Debargha Mukherjee98a311c2018-03-25 16:33:11 -0700265 int enable_cdef;
266 int enable_restoration;
Yaowu Xu2a9ac432019-08-06 14:21:17 -0700267 int force_video_mode;
Yue Chen5e129512018-12-10 10:48:54 -0800268 int enable_obmc;
Yue Chen4835dc02018-05-11 15:57:43 -0700269 int disable_trellis_quant;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700270 int using_qm;
Yaowu Xuf7a12422018-01-31 15:29:20 -0800271 int qm_y;
272 int qm_u;
273 int qm_v;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700274 int qm_minlevel;
275 int qm_maxlevel;
Yushin Chod808bfc2017-08-10 15:54:36 -0700276#if CONFIG_DIST_8X8
277 int using_dist_8x8;
278#endif
Thomas Daviesaf6df172016-11-09 14:04:18 +0000279 unsigned int num_tile_groups;
280 unsigned int mtu;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700281
282 // Internal frame size scaling.
Debargha Mukherjee29e40a62017-06-14 09:37:12 -0700283 RESIZE_MODE resize_mode;
Urvang Joshide71d142017-10-05 12:12:15 -0700284 uint8_t resize_scale_denominator;
285 uint8_t resize_kf_scale_denominator;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700286
Fergus Simpsonc4e78942017-04-10 14:59:00 -0700287 // Frame Super-Resolution size scaling.
288 SUPERRES_MODE superres_mode;
Urvang Joshide71d142017-10-05 12:12:15 -0700289 uint8_t superres_scale_denominator;
290 uint8_t superres_kf_scale_denominator;
Debargha Mukherjee7166f222017-09-05 21:32:42 -0700291 int superres_qthresh;
292 int superres_kf_qthresh;
Fergus Simpson3502d082017-04-10 12:25:07 -0700293
Yaowu Xuc27fc142016-08-22 16:08:15 -0700294 // Enable feature to reduce the frame quantization every x frames.
295 int frame_periodic_boost;
296
297 // two pass datarate control
298 int two_pass_vbrbias; // two pass datarate control tweaks
299 int two_pass_vbrmin_section;
300 int two_pass_vbrmax_section;
301 // END DATARATE CONTROL OPTIONS
302 // ----------------------------------------------------------------
303
304 int enable_auto_arf;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700305 int enable_auto_brf; // (b)ackward (r)ef (f)rame
Yaowu Xuc27fc142016-08-22 16:08:15 -0700306
Yaowu Xuc27fc142016-08-22 16:08:15 -0700307 /* Bitfield defining the error resiliency features to enable.
308 * Can provide decodable frames after losses in previous
309 * frames and decodable partitions after losses in the same frame.
310 */
311 unsigned int error_resilient_mode;
312
Debargha Mukherjee52fb0472018-03-29 15:48:11 -0700313 unsigned int s_frame_mode;
314
Yaowu Xuc27fc142016-08-22 16:08:15 -0700315 /* Bitfield defining the parallel decoding mode where the
316 * decoding in successive frames may be conducted in parallel
317 * just by decoding the frame headers.
318 */
319 unsigned int frame_parallel_decoding_mode;
320
Debargha Mukherjeec6f24c22018-04-07 08:43:08 -0700321 unsigned int limit;
322
Yaowu Xuc27fc142016-08-22 16:08:15 -0700323 int arnr_max_frames;
324 int arnr_strength;
325
326 int min_gf_interval;
327 int max_gf_interval;
Urvang Joshif4e775c2018-12-14 11:33:17 -0800328 int gf_max_pyr_height;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700329
Ravi Chaudhary0ec03a42018-08-17 18:53:28 +0530330 int row_mt;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700331 int tile_columns;
332 int tile_rows;
Dominic Symes26ad0b22017-10-01 16:35:13 +0200333 int tile_width_count;
334 int tile_height_count;
335 int tile_widths[MAX_TILE_COLS];
336 int tile_heights[MAX_TILE_ROWS];
Yaowu Xuc27fc142016-08-22 16:08:15 -0700337
Yue Chen7cae98f2018-08-24 10:43:16 -0700338 int enable_tpl_model;
Cheng Chen0fcf6f82019-10-11 11:41:19 -0700339 int enable_keyframe_filtering;
Yue Chen7cae98f2018-08-24 10:43:16 -0700340
Yaowu Xuc27fc142016-08-22 16:08:15 -0700341 int max_threads;
342
Yaowu Xuf883b422016-08-30 14:01:10 -0700343 aom_fixed_buf_t two_pass_stats_in;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700344
Yaowu Xuf883b422016-08-30 14:01:10 -0700345 aom_tune_metric tuning;
sdeng29c62152019-12-09 12:44:18 -0800346 const char *vmaf_model_path;
Yaowu Xuf883b422016-08-30 14:01:10 -0700347 aom_tune_content content;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700348 int use_highbitdepth;
Andrey Norkin9e694632017-12-21 18:50:57 -0800349 aom_color_primaries_t color_primaries;
350 aom_transfer_characteristics_t transfer_characteristics;
351 aom_matrix_coefficients_t matrix_coefficients;
anorkin76fb1262017-03-22 15:12:12 -0700352 aom_chroma_sample_position_t chroma_sample_position;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700353 int color_range;
354 int render_width;
355 int render_height;
Andrey Norkin28e9ce22018-01-08 10:11:21 -0800356 int timing_info_present;
Andrey Norkin795ba872018-03-06 13:24:14 -0800357 aom_timing_info_t timing_info;
358 int decoder_model_info_present_flag;
Andrey Norkin26495512018-06-20 17:13:11 -0700359 int display_model_info_present_flag;
Wan-Teh Changf64b3bc2018-07-02 09:42:39 -0700360 int buffer_removal_time_present;
Andrey Norkin795ba872018-03-06 13:24:14 -0800361 aom_dec_model_info_t buffer_model;
Andrey Norkin6f1c2f72018-01-15 20:08:52 -0800362 int film_grain_test_vector;
Neil Birkbeckeb895ef2018-03-14 17:51:03 -0700363 const char *film_grain_table_filename;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700364
Hui Su1cb1c002018-02-05 18:21:20 -0800365 uint8_t cdf_update_mode;
Yaowu Xuf883b422016-08-30 14:01:10 -0700366 aom_superblock_size_t superblock_size;
Yunqing Wangeeb08a92017-07-07 21:25:18 -0700367 unsigned int large_scale_tile;
368 unsigned int single_tile_decoding;
Yaowu Xu76537ca2019-01-03 12:41:32 -0800369 uint8_t monochrome;
Debargha Mukherjee9713ccb2018-04-08 19:09:17 -0700370 unsigned int full_still_picture_hdr;
Jingning Hana446f552018-02-22 15:42:12 -0800371 int enable_dual_filter;
Yunqing Wangff4fa062017-04-21 10:56:08 -0700372 unsigned int motion_vector_unit_test;
Debargha Mukherjee9d9cf192018-12-17 11:24:21 -0800373 int enable_rect_partitions;
Ryan Lei9543c702019-03-11 11:06:14 -0700374 int enable_ab_partitions;
375 int enable_1to4_partitions;
376 int min_partition_size;
377 int max_partition_size;
Debargha Mukherjee03c43ba2018-12-14 13:08:08 -0800378 int enable_intra_edge_filter;
Debargha Mukherjee8c917b02018-12-17 13:45:50 -0800379 int enable_tx64;
Ryan Lei9543c702019-03-11 11:06:14 -0700380 int enable_flip_idtx;
Debargha Mukherjee0d8368a2018-03-25 12:23:02 -0700381 int enable_order_hint;
Debargha Mukherjee7ac3eb12018-12-12 10:26:50 -0800382 int enable_dist_wtd_comp;
Debargha Mukherjee0187d7c2018-03-25 11:37:56 -0700383 int enable_ref_frame_mvs;
Urvang Joshi9ad9f082019-01-22 12:31:33 -0800384 unsigned int max_reference_frames;
Urvang Joshi1a9e27e2019-02-19 11:17:23 -0800385 int enable_reduced_reference_set;
Debargha Mukherjee0d8368a2018-03-25 12:23:02 -0700386 unsigned int allow_ref_frame_mvs;
Debargha Mukherjee16ea6ba2018-12-10 12:01:38 -0800387 int enable_masked_comp;
Ryan Lei9543c702019-03-11 11:06:14 -0700388 int enable_onesided_comp;
Debargha Mukherjee16ea6ba2018-12-10 12:01:38 -0800389 int enable_interintra_comp;
Yue Chen8cbee6c2018-12-14 11:54:39 -0800390 int enable_smooth_interintra;
Debargha Mukherjee78e6b2c2018-12-11 07:50:57 -0800391 int enable_diff_wtd_comp;
392 int enable_interinter_wedge;
393 int enable_interintra_wedge;
Debargha Mukherjeed2e53ca2018-12-10 11:34:59 -0800394 int enable_global_motion;
Debargha Mukherjee37df9162018-03-25 12:48:24 -0700395 int enable_warped_motion;
396 int allow_warped_motion;
Yue Chen8f9ca582018-12-12 15:11:47 -0800397 int enable_filter_intra;
Debargha Mukherjee078ae862018-12-18 11:05:43 -0800398 int enable_smooth_intra;
399 int enable_paeth_intra;
Debargha Mukherjee8e256782018-12-18 13:44:13 -0800400 int enable_cfl_intra;
Urvang Joshi2c92b072018-03-19 17:23:31 -0700401 int enable_superres;
Debargha Mukherjeea2074dd2019-09-04 10:03:44 -0700402 int enable_overlay;
Hui Sua9e3d142018-12-14 15:21:21 -0800403 int enable_palette;
Hui Su440e6d42018-12-17 11:47:07 -0800404 int enable_intrabc;
Hui Su94b38172018-12-19 10:40:29 -0800405 int enable_angle_delta;
Soo-Chul Han29c46fb2018-03-23 16:02:00 -0400406 unsigned int save_as_annexb;
Neil Birkbecka2893ab2018-06-08 14:45:13 -0700407
408#if CONFIG_DENOISE
409 float noise_level;
410 int noise_block_size;
411#endif
Tom Finegan02b2a842018-08-24 13:50:00 -0700412
413 unsigned int chroma_subsampling_x;
414 unsigned int chroma_subsampling_y;
Sarah Parker0b7e5902018-12-10 13:35:25 -0800415 int reduced_tx_type_set;
Debargha Mukherjeedb458152019-01-25 11:04:09 -0800416 int use_intra_dct_only;
417 int use_inter_dct_only;
Debargha Mukherjee042af922019-02-07 05:58:26 -0800418 int use_intra_default_tx_only;
Sarah Parker740e8392019-01-23 15:47:53 -0800419 int quant_b_adapt;
Debargha Mukherjee03ad12d2019-02-07 11:17:59 -0800420 COST_UPDATE_TYPE coeff_cost_upd_freq;
421 COST_UPDATE_TYPE mode_cost_upd_freq;
Debargha Mukherjee8d273412019-09-11 10:36:50 -0700422 COST_UPDATE_TYPE mv_cost_upd_freq;
Satish Kumar Suman29909962019-01-09 10:31:21 +0530423 int border_in_pixels;
Hui Su2aa492c2019-03-12 15:18:18 -0700424 AV1_LEVEL target_seq_level_idx[MAX_NUM_OPERATING_POINTS];
Hui Sud909c2c2019-03-08 11:51:14 -0800425 // Bit mask to specify which tier each of the 32 possible operating points
426 // conforms to.
427 unsigned int tier_mask;
Hui Suef139e12019-05-20 15:51:22 -0700428 // min_cr / 100 is the target minimum compression ratio for each frame.
429 unsigned int min_cr;
Ryan44276df2019-10-29 17:11:45 -0700430 const cfg_options_t *encoder_cfg;
Yaowu Xuf883b422016-08-30 14:01:10 -0700431} AV1EncoderConfig;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700432
Yaowu Xuf883b422016-08-30 14:01:10 -0700433static INLINE int is_lossless_requested(const AV1EncoderConfig *cfg) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700434 return cfg->best_allowed_q == 0 && cfg->worst_allowed_q == 0;
435}
436
Yue Chencc6a6ef2018-05-21 16:21:05 -0700437typedef struct FRAME_COUNTS {
438// Note: This structure should only contain 'unsigned int' fields, or
439// aggregates built solely from 'unsigned int' fields/elements
440#if CONFIG_ENTROPY_STATS
441 unsigned int kf_y_mode[KF_MODE_CONTEXTS][KF_MODE_CONTEXTS][INTRA_MODES];
442 unsigned int angle_delta[DIRECTIONAL_MODES][2 * MAX_ANGLE_DELTA + 1];
443 unsigned int y_mode[BLOCK_SIZE_GROUPS][INTRA_MODES];
444 unsigned int uv_mode[CFL_ALLOWED_TYPES][INTRA_MODES][UV_INTRA_MODES];
445 unsigned int cfl_sign[CFL_JOINT_SIGNS];
446 unsigned int cfl_alpha[CFL_ALPHA_CONTEXTS][CFL_ALPHABET_SIZE];
447 unsigned int palette_y_mode[PALATTE_BSIZE_CTXS][PALETTE_Y_MODE_CONTEXTS][2];
448 unsigned int palette_uv_mode[PALETTE_UV_MODE_CONTEXTS][2];
449 unsigned int palette_y_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
450 unsigned int palette_uv_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
451 unsigned int palette_y_color_index[PALETTE_SIZES]
452 [PALETTE_COLOR_INDEX_CONTEXTS]
453 [PALETTE_COLORS];
454 unsigned int palette_uv_color_index[PALETTE_SIZES]
455 [PALETTE_COLOR_INDEX_CONTEXTS]
456 [PALETTE_COLORS];
457 unsigned int partition[PARTITION_CONTEXTS][EXT_PARTITION_TYPES];
458 unsigned int txb_skip[TOKEN_CDF_Q_CTXS][TX_SIZES][TXB_SKIP_CONTEXTS][2];
459 unsigned int eob_extra[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
460 [EOB_COEF_CONTEXTS][2];
461 unsigned int dc_sign[PLANE_TYPES][DC_SIGN_CONTEXTS][2];
462 unsigned int coeff_lps[TX_SIZES][PLANE_TYPES][BR_CDF_SIZE - 1][LEVEL_CONTEXTS]
463 [2];
464 unsigned int eob_flag[TX_SIZES][PLANE_TYPES][EOB_COEF_CONTEXTS][2];
465 unsigned int eob_multi16[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][5];
466 unsigned int eob_multi32[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][6];
467 unsigned int eob_multi64[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][7];
468 unsigned int eob_multi128[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][8];
469 unsigned int eob_multi256[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][9];
470 unsigned int eob_multi512[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][10];
471 unsigned int eob_multi1024[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][11];
472 unsigned int coeff_lps_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
473 [LEVEL_CONTEXTS][BR_CDF_SIZE];
474 unsigned int coeff_base_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
475 [SIG_COEF_CONTEXTS][NUM_BASE_LEVELS + 2];
476 unsigned int coeff_base_eob_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
477 [SIG_COEF_CONTEXTS_EOB][NUM_BASE_LEVELS + 1];
478 unsigned int newmv_mode[NEWMV_MODE_CONTEXTS][2];
479 unsigned int zeromv_mode[GLOBALMV_MODE_CONTEXTS][2];
480 unsigned int refmv_mode[REFMV_MODE_CONTEXTS][2];
481 unsigned int drl_mode[DRL_MODE_CONTEXTS][2];
482 unsigned int inter_compound_mode[INTER_MODE_CONTEXTS][INTER_COMPOUND_MODES];
483 unsigned int wedge_idx[BLOCK_SIZES_ALL][16];
484 unsigned int interintra[BLOCK_SIZE_GROUPS][2];
485 unsigned int interintra_mode[BLOCK_SIZE_GROUPS][INTERINTRA_MODES];
486 unsigned int wedge_interintra[BLOCK_SIZES_ALL][2];
Debargha Mukherjee54eabb52019-02-01 16:54:33 -0800487 unsigned int compound_type[BLOCK_SIZES_ALL][MASKED_COMPOUND_TYPES];
Yue Chencc6a6ef2018-05-21 16:21:05 -0700488 unsigned int motion_mode[BLOCK_SIZES_ALL][MOTION_MODES];
489 unsigned int obmc[BLOCK_SIZES_ALL][2];
490 unsigned int intra_inter[INTRA_INTER_CONTEXTS][2];
491 unsigned int comp_inter[COMP_INTER_CONTEXTS][2];
492 unsigned int comp_ref_type[COMP_REF_TYPE_CONTEXTS][2];
493 unsigned int uni_comp_ref[UNI_COMP_REF_CONTEXTS][UNIDIR_COMP_REFS - 1][2];
494 unsigned int single_ref[REF_CONTEXTS][SINGLE_REFS - 1][2];
495 unsigned int comp_ref[REF_CONTEXTS][FWD_REFS - 1][2];
496 unsigned int comp_bwdref[REF_CONTEXTS][BWD_REFS - 1][2];
497 unsigned int intrabc[2];
498
499 unsigned int txfm_partition[TXFM_PARTITION_CONTEXTS][2];
500 unsigned int intra_tx_size[MAX_TX_CATS][TX_SIZE_CONTEXTS][MAX_TX_DEPTH + 1];
501 unsigned int skip_mode[SKIP_MODE_CONTEXTS][2];
502 unsigned int skip[SKIP_CONTEXTS][2];
503 unsigned int compound_index[COMP_INDEX_CONTEXTS][2];
504 unsigned int comp_group_idx[COMP_GROUP_IDX_CONTEXTS][2];
505 unsigned int delta_q[DELTA_Q_PROBS][2];
506 unsigned int delta_lf_multi[FRAME_LF_COUNT][DELTA_LF_PROBS][2];
507 unsigned int delta_lf[DELTA_LF_PROBS][2];
508
509 unsigned int inter_ext_tx[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
510 unsigned int intra_ext_tx[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
511 [TX_TYPES];
512 unsigned int filter_intra_mode[FILTER_INTRA_MODES];
513 unsigned int filter_intra[BLOCK_SIZES_ALL][2];
514 unsigned int switchable_restore[RESTORE_SWITCHABLE_TYPES];
515 unsigned int wiener_restore[2];
516 unsigned int sgrproj_restore[2];
517#endif // CONFIG_ENTROPY_STATS
518
519 unsigned int switchable_interp[SWITCHABLE_FILTER_CONTEXTS]
520 [SWITCHABLE_FILTERS];
521} FRAME_COUNTS;
522
Angie Chiang71572162018-08-06 16:20:36 -0700523#define INTER_MODE_RD_DATA_OVERALL_SIZE 6400
524
525typedef struct {
526 int ready;
527 double a;
528 double b;
529 double dist_mean;
Angie Chiang199f3d42018-08-14 18:07:02 -0700530 double ld_mean;
531 double sse_mean;
532 double sse_sse_mean;
533 double sse_ld_mean;
Angie Chiang106fa482018-08-07 18:28:40 -0700534 int num;
535 double dist_sum;
536 double ld_sum;
537 double sse_sum;
538 double sse_sse_sum;
539 double sse_ld_sum;
Angie Chiang71572162018-08-06 16:20:36 -0700540} InterModeRdModel;
541
542typedef struct {
543 int idx;
544 int64_t rd;
545} RdIdxPair;
546// TODO(angiebird): This is an estimated size. We still need to figure what is
547// the maximum number of modes.
548#define MAX_INTER_MODES 1024
549typedef struct inter_modes_info {
550 int num;
551 MB_MODE_INFO mbmi_arr[MAX_INTER_MODES];
552 int mode_rate_arr[MAX_INTER_MODES];
553 int64_t sse_arr[MAX_INTER_MODES];
554 int64_t est_rd_arr[MAX_INTER_MODES];
555 RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES];
elliottkb8becb22019-03-04 01:01:30 -0800556 RD_STATS rd_cost_arr[MAX_INTER_MODES];
557 RD_STATS rd_cost_y_arr[MAX_INTER_MODES];
558 RD_STATS rd_cost_uv_arr[MAX_INTER_MODES];
Angie Chiang71572162018-08-06 16:20:36 -0700559} InterModesInfo;
Angie Chiang71572162018-08-06 16:20:36 -0700560
Ravi Chaudhary40cdf132018-10-08 11:04:16 +0530561// Encoder row synchronization
562typedef struct AV1RowMTSyncData {
563#if CONFIG_MULTITHREAD
564 pthread_mutex_t *mutex_;
565 pthread_cond_t *cond_;
566#endif
567 // Allocate memory to store the sb/mb block index in each row.
568 int *cur_col;
569 int sync_range;
570 int rows;
571} AV1RowMTSync;
572
Ravi Chaudhary90a15f42018-10-11 18:56:35 +0530573typedef struct AV1RowMTInfo {
574 int current_mi_row;
575 int num_threads_working;
576} AV1RowMTInfo;
577
Yaowu Xuc27fc142016-08-22 16:08:15 -0700578// TODO(jingning) All spatially adaptive variables should go to TileDataEnc.
579typedef struct TileDataEnc {
580 TileInfo tile_info;
Yunqing Wang8c1e57c2016-10-25 15:15:23 -0700581 int m_search_count;
582 int ex_search_count;
Luc Trudeauf8164152017-04-11 16:20:51 -0400583 CFL_CTX cfl;
Jingning Han9f07be12017-04-13 09:31:40 -0700584 DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx);
Ravi Chaudharye5215172018-12-21 18:47:25 +0530585 FRAME_CONTEXT *row_ctx;
Yunqing Wang0e141b52017-11-02 15:08:58 -0700586 uint8_t allow_update_cdf;
Angie Chiang71572162018-08-06 16:20:36 -0700587 InterModeRdModel inter_mode_rd_models[BLOCK_SIZES_ALL];
Ravi Chaudhary40cdf132018-10-08 11:04:16 +0530588 AV1RowMTSync row_mt_sync;
Ravi Chaudhary90a15f42018-10-11 18:56:35 +0530589 AV1RowMTInfo row_mt_info;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700590} TileDataEnc;
591
Ravi Chaudhary73cf15b2018-08-30 10:52:51 +0530592typedef struct {
593 TOKENEXTRA *start;
594 TOKENEXTRA *stop;
595 unsigned int count;
596} TOKENLIST;
597
Ravi Chaudharyc5e74692018-10-08 16:05:38 +0530598typedef struct MultiThreadHandle {
599 int allocated_tile_rows;
600 int allocated_tile_cols;
601 int allocated_sb_rows;
Ravi Chaudhary90a15f42018-10-11 18:56:35 +0530602 int thread_id_to_tile_id[MAX_NUM_THREADS]; // Mapping of threads to tiles
Ravi Chaudharyc5e74692018-10-08 16:05:38 +0530603} MultiThreadHandle;
604
Yaowu Xuc27fc142016-08-22 16:08:15 -0700605typedef struct RD_COUNTS {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700606 int64_t comp_pred_diff[REFERENCE_MODES];
Debargha Mukherjeea575d232017-04-28 17:46:47 -0700607 // Stores number of 4x4 blocks using global motion per reference frame.
Zoe Liu27deb382018-03-27 15:13:56 -0700608 int global_motion_used[REF_FRAMES];
Arild Fuldseth (arilfuld)6c20c782017-06-15 09:45:02 +0200609 int compound_ref_used_flag;
Zoe Liu8a5d3432017-11-30 16:33:44 -0800610 int skip_mode_used_flag;
Yunqing Wang7ad3aca2019-11-01 13:06:23 -0700611 int tx_type_used[TX_SIZES_ALL][TX_TYPES];
Yunqing Wang5f74dc22019-10-29 10:35:20 -0700612 int obmc_used[BLOCK_SIZES_ALL][2];
Yunqing Wanga09a46b2019-12-09 13:16:24 -0800613 int warped_used[2];
Yaowu Xuc27fc142016-08-22 16:08:15 -0700614} RD_COUNTS;
615
616typedef struct ThreadData {
617 MACROBLOCK mb;
618 RD_COUNTS rd_counts;
619 FRAME_COUNTS *counts;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700620 PC_TREE *pc_tree;
621 PC_TREE *pc_root[MAX_MIB_SIZE_LOG2 - MIN_MIB_SIZE_LOG2 + 1];
wenyao.liu0c6f5fd2018-10-23 18:41:16 +0800622 tran_low_t *tree_coeff_buf[MAX_MB_PLANE];
623 tran_low_t *tree_qcoeff_buf[MAX_MB_PLANE];
624 tran_low_t *tree_dqcoeff_buf[MAX_MB_PLANE];
Ravi Chaudhary5d970f42018-09-25 11:25:32 +0530625 InterModesInfo *inter_modes_info;
Ravi Chaudhary783d6a32018-08-28 18:21:02 +0530626 uint32_t *hash_value_buffer[2][2];
Jingning Hand064cf02017-06-01 10:00:39 -0700627 int32_t *wsrc_buf;
628 int32_t *mask_buf;
629 uint8_t *above_pred_buf;
630 uint8_t *left_pred_buf;
hui su5d493142017-05-08 12:06:12 -0700631 PALETTE_BUFFER *palette_buffer;
Hui Su38711e72019-06-11 10:49:47 -0700632 CompoundTypeRdBuffers comp_rd_buffer;
Urvang Joshi0a4cfad2018-09-07 11:10:39 -0700633 CONV_BUF_TYPE *tmp_conv_dst;
634 uint8_t *tmp_obmc_bufs[2];
Ravi Chaudhary00525ef2018-10-31 19:52:42 +0530635 int intrabc_used;
Yue Chenc87d7492019-05-30 17:22:49 -0700636 int deltaq_used;
Ravi Chaudhary84a280a2018-09-24 16:09:48 +0530637 FRAME_CONTEXT *tctx;
Remya0cce44c2019-08-16 11:57:24 +0530638 MB_MODE_INFO_EXT *mbmi_ext;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700639} ThreadData;
640
641struct EncWorkerData;
642
643typedef struct ActiveMap {
644 int enabled;
645 int update;
646 unsigned char *map;
647} ActiveMap;
648
Wan-Teh Changc25c92a2018-04-23 15:04:14 -0700649#if CONFIG_INTERNAL_STATS
650// types of stats
Satish Kumar Suman4667aa12018-12-14 18:28:19 +0530651enum {
Wan-Teh Changc25c92a2018-04-23 15:04:14 -0700652 STAT_Y,
653 STAT_U,
654 STAT_V,
655 STAT_ALL,
656 NUM_STAT_TYPES // This should always be the last member of the enum
Satish Kumar Suman4667aa12018-12-14 18:28:19 +0530657} UENUM1BYTE(StatType);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700658
659typedef struct IMAGE_STAT {
Urvang Joshib5ed3502016-10-17 16:38:05 -0700660 double stat[NUM_STAT_TYPES];
Yaowu Xuc27fc142016-08-22 16:08:15 -0700661 double worst;
662} ImageStat;
Wan-Teh Changc25c92a2018-04-23 15:04:14 -0700663#endif // CONFIG_INTERNAL_STATS
Urvang Joshib5ed3502016-10-17 16:38:05 -0700664
Yaowu Xuc27fc142016-08-22 16:08:15 -0700665typedef struct {
666 int ref_count;
667 YV12_BUFFER_CONFIG buf;
668} EncRefCntBuffer;
669
chiyotsai9c484b32019-03-07 16:01:50 -0800670#if CONFIG_COLLECT_PARTITION_STATS == 2
chiyotsai92ed0dd2019-01-25 14:50:14 -0800671typedef struct PartitionStats {
672 int partition_decisions[6][EXT_PARTITION_TYPES];
673 int partition_attempts[6][EXT_PARTITION_TYPES];
chiyotsai9c484b32019-03-07 16:01:50 -0800674 int64_t partition_times[6][EXT_PARTITION_TYPES];
chiyotsai92ed0dd2019-01-25 14:50:14 -0800675
676 int partition_redo;
677} PartitionStats;
678#endif
679
Yunqing Wangba255582019-02-11 16:21:12 -0800680#if CONFIG_COLLECT_COMPONENT_TIMING
681#include "aom_ports/aom_timer.h"
682// Adjust the following to add new components.
683enum {
Yunqing Wangd1f32e62019-02-20 10:37:51 -0800684 encode_frame_to_data_rate_time,
685 encode_with_recode_loop_time,
686 loop_filter_time,
687 cdef_time,
688 loop_restoration_time,
689 av1_pack_bitstream_final_time,
690 av1_encode_frame_time,
691 av1_compute_global_motion_time,
692 av1_setup_motion_field_time,
Yunqing Wangba255582019-02-11 16:21:12 -0800693 encode_sb_time,
694 rd_pick_partition_time,
695 rd_pick_sb_modes_time,
696 av1_rd_pick_intra_mode_sb_time,
697 av1_rd_pick_inter_mode_sb_time,
Yunqing Wangd1f32e62019-02-20 10:37:51 -0800698 handle_intra_mode_time,
Yunqing Wangd1f32e62019-02-20 10:37:51 -0800699 do_tx_search_time,
700 handle_newmv_time,
701 compound_type_rd_time,
702 interpolation_filter_search_time,
Yunqing Wangba255582019-02-11 16:21:12 -0800703 motion_mode_rd_time,
704 kTimingComponents,
705} UENUM1BYTE(TIMING_COMPONENT);
706
707static INLINE char const *get_component_name(int index) {
708 switch (index) {
Yunqing Wangd1f32e62019-02-20 10:37:51 -0800709 case encode_frame_to_data_rate_time:
710 return "encode_frame_to_data_rate_time";
711 case encode_with_recode_loop_time: return "encode_with_recode_loop_time";
712 case loop_filter_time: return "loop_filter_time";
713 case cdef_time: return "cdef_time";
714 case loop_restoration_time: return "loop_restoration_time";
715 case av1_pack_bitstream_final_time: return "av1_pack_bitstream_final_time";
716 case av1_encode_frame_time: return "av1_encode_frame_time";
717 case av1_compute_global_motion_time:
718 return "av1_compute_global_motion_time";
719 case av1_setup_motion_field_time: return "av1_setup_motion_field_time";
720 case encode_sb_time: return "encode_sb_time";
Yunqing Wangd1f32e62019-02-20 10:37:51 -0800721 case rd_pick_partition_time: return "rd_pick_partition_time";
722 case rd_pick_sb_modes_time: return "rd_pick_sb_modes_time";
723 case av1_rd_pick_intra_mode_sb_time:
724 return "av1_rd_pick_intra_mode_sb_time";
725 case av1_rd_pick_inter_mode_sb_time:
726 return "av1_rd_pick_inter_mode_sb_time";
727 case handle_intra_mode_time: return "handle_intra_mode_time";
Yunqing Wangd1f32e62019-02-20 10:37:51 -0800728 case do_tx_search_time: return "do_tx_search_time";
729 case handle_newmv_time: return "handle_newmv_time";
730 case compound_type_rd_time: return "compound_type_rd_time";
731 case interpolation_filter_search_time:
732 return "interpolation_filter_search_time";
733 case motion_mode_rd_time: return "motion_mode_rd_time";
Yunqing Wangba255582019-02-11 16:21:12 -0800734 default: assert(0);
735 }
736 return "error";
737}
738#endif
739
Urvang Joshif70375a2019-03-22 23:30:19 -0700740// The maximum number of internal ARFs except ALTREF_FRAME
741#define MAX_INTERNAL_ARFS (REF_FRAMES - BWDREF_FRAME - 1)
742
Jingning Han42266ca2019-07-12 14:37:16 -0700743typedef struct {
744 int arf_stack[FRAME_BUFFERS];
745 int arf_stack_size;
746 int lst_stack[FRAME_BUFFERS];
747 int lst_stack_size;
748 int gld_stack[FRAME_BUFFERS];
749 int gld_stack_size;
750} RefBufferStack;
751
Yaowu Xuf883b422016-08-30 14:01:10 -0700752typedef struct AV1_COMP {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700753 QUANTS quants;
754 ThreadData td;
Yue Chencc6a6ef2018-05-21 16:21:05 -0700755 FRAME_COUNTS counts;
Remya0cce44c2019-08-16 11:57:24 +0530756 MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame_base;
Jingning Hanf5a4d3b2017-08-27 23:01:19 -0700757 CB_COEFF_BUFFER *coeff_buffer_base;
Yi Luoc6210232017-05-25 15:09:25 -0700758 Dequants dequants;
Yaowu Xuf883b422016-08-30 14:01:10 -0700759 AV1_COMMON common;
760 AV1EncoderConfig oxcf;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700761 struct lookahead_ctx *lookahead;
762 struct lookahead_entry *alt_ref_source;
Sarah Parkeraf32a7b2018-06-29 14:59:05 -0700763 int no_show_kf;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700764
Angie Chiange69a6822018-03-16 13:52:44 -0700765 int optimize_seg_arr[MAX_SEGMENTS];
chiyotsaia7091f12019-08-09 16:48:27 -0700766 int mi_ext_alloc_size;
Angie Chiange69a6822018-03-16 13:52:44 -0700767
Alex Conversef77fd0b2017-04-20 11:00:24 -0700768 YV12_BUFFER_CONFIG *source;
769 YV12_BUFFER_CONFIG *last_source; // NULL for first frame and alt_ref frames
Fergus Simpsond2bcbb52017-05-22 23:15:05 -0700770 YV12_BUFFER_CONFIG *unscaled_source;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700771 YV12_BUFFER_CONFIG scaled_source;
772 YV12_BUFFER_CONFIG *unscaled_last_source;
773 YV12_BUFFER_CONFIG scaled_last_source;
Cheng Chen4f666ca2019-11-18 17:05:03 -0800774 YV12_BUFFER_CONFIG *unfiltered_source;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700775
Yue Chenb4c93f02019-08-05 13:47:31 -0700776 uint8_t tpl_stats_block_mis_log2; // block granularity of tpl score storage
Jingning Han81d6fbb2019-07-15 10:14:13 -0700777 TplDepFrame tpl_stats_buffer[MAX_LENGTH_TPL_FRAME_STATS];
778 TplDepFrame *tpl_frame;
Yue Chen7cae98f2018-08-24 10:43:16 -0700779
Yaowu Xuc27fc142016-08-22 16:08:15 -0700780 // For a still frame, this flag is set to 1 to skip partition search.
781 int partition_search_skippable_frame;
Yunqing Wangc3e21ec2019-02-28 16:29:27 -0800782
RogerZhou3b635242017-09-19 10:06:46 -0700783 double csm_rate_array[32];
784 double m_rate_array[32];
785 int rate_size;
786 int rate_index;
Debargha Mukherjeee41a6672018-02-27 11:56:31 -0800787 hash_table *previous_hash_table;
chiyotsaifc1404d2019-08-08 12:09:12 -0700788 int need_to_clear_prev_hash_table;
Debargha Mukherjeee41a6672018-02-27 11:56:31 -0800789 int previous_index;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700790
Ravi Chaudhary0ec03a42018-08-17 18:53:28 +0530791 unsigned int row_mt;
David Turnere7ebf902018-12-04 14:04:55 +0000792 RefCntBuffer *scaled_ref_buf[INTER_REFS_PER_FRAME];
Urvang Joshi4d9f15f2018-11-05 15:26:22 -0800793
David Turnere7ebf902018-12-04 14:04:55 +0000794 RefCntBuffer *last_show_frame_buf; // last show frame buffer
Yaowu Xuc27fc142016-08-22 16:08:15 -0700795
Urvang Joshi06b37652018-11-06 11:17:56 -0800796 // refresh_*_frame are boolean flags. If 'refresh_xyz_frame' is true, then
797 // after the current frame is encoded, the XYZ reference frame gets refreshed
798 // (updated) to be the current frame.
799 //
800 // Special case: 'refresh_last_frame' specifies that:
801 // - LAST_FRAME reference should be updated to be the current frame (as usual)
802 // - Also, LAST2_FRAME and LAST3_FRAME references are implicitly updated to be
803 // the two past reference frames just before LAST_FRAME that are available.
804 //
805 // Note: Usually at most one of these refresh flags is true at a time.
806 // But a key-frame is special, for which all the flags are true at once.
Yaowu Xuc27fc142016-08-22 16:08:15 -0700807 int refresh_last_frame;
808 int refresh_golden_frame;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700809 int refresh_bwd_ref_frame;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700810 int refresh_alt_ref_frame;
Urvang Joshi06b37652018-11-06 11:17:56 -0800811
David Turner99e990e2018-12-10 12:54:26 +0000812 // For each type of reference frame, this contains the index of a reference
813 // frame buffer for a reference frame of the same type. We use this to
814 // choose our primary reference frame (which is the most recent reference
815 // frame of the same type as the current frame).
816 int fb_of_context_type[REF_FRAMES];
817
Yaowu Xuc27fc142016-08-22 16:08:15 -0700818 int ext_refresh_frame_flags_pending;
819 int ext_refresh_last_frame;
820 int ext_refresh_golden_frame;
Yunqing Wang9a50fec2017-11-02 17:02:00 -0700821 int ext_refresh_bwd_ref_frame;
822 int ext_refresh_alt2_ref_frame;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700823 int ext_refresh_alt_ref_frame;
824
825 int ext_refresh_frame_context_pending;
826 int ext_refresh_frame_context;
sarahparker21dbca42018-03-30 17:43:44 -0700827 int ext_use_ref_frame_mvs;
sarahparker27d686a2018-03-30 17:43:44 -0700828 int ext_use_error_resilient;
sarahparker9806fed2018-03-30 17:43:44 -0700829 int ext_use_s_frame;
Sarah Parker50b6d6e2018-04-11 19:21:54 -0700830 int ext_use_primary_ref_none;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700831
832 YV12_BUFFER_CONFIG last_frame_uf;
Debargha Mukherjee999d2f62016-12-15 13:23:21 -0800833 YV12_BUFFER_CONFIG trial_frame_rst;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700834
835 // Ambient reconstruction err target for force key frames
836 int64_t ambient_err;
837
838 RD_OPT rd;
839
840 CODING_CONTEXT coding_context;
841
Yue Chenb23d00a2017-07-28 17:01:21 -0700842 int gmtype_cost[TRANS_TYPES];
Zoe Liu27deb382018-03-27 15:13:56 -0700843 int gmparams_cost[REF_FRAMES];
Yue Chenb23d00a2017-07-28 17:01:21 -0700844
Yaowu Xuc27fc142016-08-22 16:08:15 -0700845 int64_t last_time_stamp_seen;
846 int64_t last_end_time_stamp_seen;
847 int64_t first_time_stamp_ever;
848
849 RATE_CONTROL rc;
850 double framerate;
851
Yaowu Xuf883b422016-08-30 14:01:10 -0700852 struct aom_codec_pkt_list *output_pkt_list;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700853
chiyotsaif373d362019-12-12 10:58:47 -0800854 int static_mb_pct; // % forced skip mbs by segmentation
Yaowu Xuc27fc142016-08-22 16:08:15 -0700855 int ref_frame_flags;
Yunqing Wangf2e7a392017-11-08 00:27:21 -0800856 int ext_ref_frame_flags;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700857
David Turner04b70d82019-01-24 15:39:19 +0000858 // speed is passed as a per-frame parameter into the encoder
859 int speed;
860 // sf contains fine-grained config set internally based on speed
Yaowu Xuc27fc142016-08-22 16:08:15 -0700861 SPEED_FEATURES sf;
862
863 unsigned int max_mv_magnitude;
864 int mv_step_param;
865
Zoe Liu77fb5be2017-11-02 14:36:19 -0700866 int all_one_sided_refs;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700867
Yaowu Xuc27fc142016-08-22 16:08:15 -0700868 uint8_t *segmentation_map;
869
Yaowu Xuc27fc142016-08-22 16:08:15 -0700870 CYCLIC_REFRESH *cyclic_refresh;
871 ActiveMap active_map;
872
873 fractional_mv_step_fp *find_fractional_mv_step;
Rupert Swarbrick93c39e92017-07-12 11:11:02 +0100874 aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL];
Yunqing Wangd1f32e62019-02-20 10:37:51 -0800875
876#if CONFIG_INTERNAL_STATS
Yaowu Xuc27fc142016-08-22 16:08:15 -0700877 uint64_t time_receive_data;
878 uint64_t time_compress_data;
Yunqing Wangd1f32e62019-02-20 10:37:51 -0800879#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -0700880
Debargha Mukherjeee3778392019-05-06 11:44:23 -0700881 // number of show frames encoded in current gf_group
882 int num_gf_group_show_frames;
883
884 // when two pass tpl model is used, set to 1 for the
885 // first pass, then 0 for the final pass.
886 int tpl_model_pass;
Debargha Mukherjee347c64d2019-05-08 13:53:46 -0700887 // Number of gf_group frames for tpl stats
888 int tpl_gf_group_frames;
Debargha Mukherjeee3778392019-05-06 11:44:23 -0700889
Yaowu Xuc27fc142016-08-22 16:08:15 -0700890 TWO_PASS twopass;
891
Sarah Parkere1b22012019-06-06 16:35:25 -0700892 GF_GROUP gf_group;
893
Jingning Hancf6d3252019-07-03 14:26:45 -0700894 // To control the reference frame buffer and selection.
Jingning Han42266ca2019-07-12 14:37:16 -0700895 RefBufferStack ref_buffer_stack;
Jingning Hancf6d3252019-07-03 14:26:45 -0700896
Yaowu Xuc27fc142016-08-22 16:08:15 -0700897 YV12_BUFFER_CONFIG alt_ref_buffer;
898
Yunqing Wang1973f112019-10-18 15:50:04 -0700899 // Tell if OVERLAY frame shows existing alt_ref frame.
900 int show_existing_alt_ref;
901
Yaowu Xuc27fc142016-08-22 16:08:15 -0700902#if CONFIG_INTERNAL_STATS
903 unsigned int mode_chosen_counts[MAX_MODES];
904
905 int count;
906 uint64_t total_sq_error;
907 uint64_t total_samples;
908 ImageStat psnr;
909
910 double total_blockiness;
911 double worst_blockiness;
912
913 int bytes;
914 double summed_quality;
915 double summed_weights;
916 unsigned int tot_recode_hits;
917 double worst_ssim;
918
919 ImageStat fastssim;
920 ImageStat psnrhvs;
921
922 int b_calculate_blockiness;
923 int b_calculate_consistency;
924
925 double total_inconsistency;
926 double worst_consistency;
927 Ssimv *ssim_vars;
928 Metrics metrics;
929#endif
930 int b_calculate_psnr;
Debargha Mukherjee0857e662019-01-04 16:22:09 -0800931#if CONFIG_SPEED_STATS
932 unsigned int tx_search_count;
933#endif // CONFIG_SPEED_STATS
Yaowu Xuc27fc142016-08-22 16:08:15 -0700934
935 int droppable;
936
Jingning Hanc7a52172019-09-17 15:28:46 -0700937 FRAME_INFO frame_info;
938
Yaowu Xuc27fc142016-08-22 16:08:15 -0700939 int initial_width;
940 int initial_height;
941 int initial_mbs; // Number of MBs in the full-size frame; to be used to
942 // normalize the firstpass stats. This will differ from the
943 // number of MBs in the current frame when the frame is
944 // scaled.
945
Debargha Mukherjeeccb27262017-09-25 14:19:46 -0700946 // When resize is triggered through external control, the desired width/height
947 // are stored here until use in the next frame coded. They are effective only
948 // for
949 // one frame and are reset after use.
950 int resize_pending_width;
951 int resize_pending_height;
952
Satish Kumar Suman1de46882019-02-27 17:24:18 +0530953 // ss_cfg[SS_CFG_LOOKAHEAD] : used in following cases
954 // -> temporal filtering
955 // -> intrabc
956 // ss_cfg[SS_CFG_SRC] : used everywhere except above mentioned cases
Satish Kumar Sumane6d0be52019-02-14 14:33:28 +0530957 search_site_config ss_cfg[SS_CFG_TOTAL];
Yaowu Xuc27fc142016-08-22 16:08:15 -0700958
Yaowu Xuc27fc142016-08-22 16:08:15 -0700959 TileDataEnc *tile_data;
960 int allocated_tiles; // Keep track of memory allocated for tiles.
961
962 TOKENEXTRA *tile_tok[MAX_TILE_ROWS][MAX_TILE_COLS];
Ravi Chaudhary73cf15b2018-08-30 10:52:51 +0530963 TOKENLIST *tplist[MAX_TILE_ROWS][MAX_TILE_COLS];
Yaowu Xuc27fc142016-08-22 16:08:15 -0700964
Yaowu Xuc27fc142016-08-22 16:08:15 -0700965 int resize_state;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700966 int resize_avg_qp;
967 int resize_buffer_underflow;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700968
Debargha Mukherjeef2e5bb32018-03-26 14:35:24 -0700969 // Sequence parameters have been transmitted already and locked
970 // or not. Once locked av1_change_config cannot change the seq
971 // parameters.
972 int seq_params_locked;
973
Yaowu Xuc27fc142016-08-22 16:08:15 -0700974 // VARIANCE_AQ segment map refresh
975 int vaq_refresh;
976
kyslov7b9d0d62018-12-21 11:12:26 -0800977 // VAR_BASED_PARTITION thresholds
978 // 0 - threshold_128x128; 1 - threshold_64x64;
979 // 2 - threshold_32x32; 3 - threshold_16x16;
980 // 4 - vbp_threshold_8x8;
981 int64_t vbp_thresholds[5];
982 int64_t vbp_threshold_minmax;
983 int64_t vbp_threshold_sad;
984 int64_t vbp_threshold_copy;
985 BLOCK_SIZE vbp_bsize_min;
986
Yunqing Wang5f74dc22019-10-29 10:35:20 -0700987 int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL];
Yunqing Wanga09a46b2019-12-09 13:16:24 -0800988 int warped_probs[FRAME_UPDATE_TYPES];
Yunqing Wangdb70bf42019-08-19 09:28:11 -0700989 int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES];
990 int tx_type_probs_thresh[FRAME_UPDATE_TYPES];
991
Yaowu Xuc27fc142016-08-22 16:08:15 -0700992 // Multi-threading
993 int num_workers;
Yaowu Xuf883b422016-08-30 14:01:10 -0700994 AVxWorker *workers;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700995 struct EncWorkerData *tile_thr_data;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700996 int existing_fb_idx_to_show;
Urvang Joshif70375a2019-03-22 23:30:19 -0700997 int is_arf_filter_off[MAX_INTERNAL_ARFS + 1];
Debargha Mukherjeeb98a7022016-11-15 16:07:12 -0800998 int global_motion_search_done;
Urvang Joshif70375a2019-03-22 23:30:19 -0700999 int internal_altref_allowed;
Hui Su85878782017-11-07 14:56:31 -08001000 // A flag to indicate if intrabc is ever used in current frame.
1001 int intrabc_used;
Hui Sudfcbfbd2017-11-13 12:05:30 -08001002 int dv_cost[2][MV_VALS];
1003 // TODO(huisu@google.com): we can update dv_joint_cost per SB.
1004 int dv_joint_cost[MV_JOINTS];
Hui Suad7551e2018-03-14 11:13:31 -07001005 int has_lossless_segment;
Zoe Liu1d90ceb2018-04-16 16:53:37 -07001006
Remya6924f4a2018-11-26 12:27:32 +05301007 // Factors to control gating of compound type selection based on best
1008 // approximate rd so far
1009 int max_comp_type_rd_threshold_mul;
1010 int max_comp_type_rd_threshold_div;
1011
Cherma Rajan A628efce2019-09-18 18:55:12 +05301012 // Threshold of transform domain distortion
1013 // Index 0: Default mode evaluation, Winner mode processing is not applicable
1014 // (Eg : IntraBc).
1015 // Index 1: Mode evaluation.
1016 // Index 2: Winner mode evaluation.
1017 // Index 1 and 2 are applicable when enable_winner_mode_for_use_tx_domain_dist
1018 // speed feature is ON
1019 unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES];
Venkatb62a64b2019-01-03 17:50:40 +05301020
Venkat48067652019-01-09 17:59:53 +05301021 // Factor to control R-D optimization of coeffs based on block
1022 // mse.
Cherma Rajan A628efce2019-09-18 18:55:12 +05301023 // Index 0: Default mode evaluation, Winner mode processing is not applicable
1024 // (Eg : IntraBc). Index 1: Mode evaluation.
1025 // Index 2: Winner mode evaluation
1026 // Index 1 and 2 are applicable when enable_winner_mode_for_coeff_opt speed
1027 // feature is ON
1028 unsigned int coeff_opt_dist_threshold[MODE_EVAL_TYPES];
1029
1030 // Transform size to be used in transform search
1031 // Index 0: Default mode evaluation, Winner mode processing is not applicable
1032 // (Eg : IntraBc).
1033 // Index 1: Mode evaluation. Index 2: Winner mode evaluation
1034 // Index 1 and 2 are applicable when enable_winner_mode_for_tx_size_srch speed
1035 // feature is ON
1036 TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES];
1037
1038 // Transform domain distortion levels
1039 // Index 0: Default mode evaluation, Winner mode processing is not applicable
1040 // (Eg : IntraBc).
1041 // Index 1: Mode evaluation. Index 2: Winner mode evaluation
1042 // Index 1 and 2 are applicable when enable_winner_mode_for_use_tx_domain_dist
1043 // speed feature is ON
1044 unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES];
Venkat48067652019-01-09 17:59:53 +05301045
Nithya V Sd0276ac2019-10-24 11:31:06 +05301046 // Predict transform skip levels to be used for default, mode and winner mode
1047 // evaluation. Index 0: Default mode evaluation, Winner mode processing is not
1048 // applicable. Index 1: Mode evaluation, Index 2: Winner mode evaluation
1049 unsigned int predict_skip_level[MODE_EVAL_TYPES];
1050
Deepa K G964e72e2018-05-16 16:56:01 +05301051 AV1LfSync lf_row_sync;
Ravi Chaudharye2aa4012018-06-04 14:20:00 +05301052 AV1LrSync lr_row_sync;
Ravi Chaudharyce0f5fc2018-05-30 16:19:32 +05301053 AV1LrStruct lr_ctxt;
Neil Birkbecka2893ab2018-06-08 14:45:13 -07001054
1055 aom_film_grain_table_t *film_grain_table;
1056#if CONFIG_DENOISE
1057 struct aom_denoise_and_model_t *denoise_and_model;
1058#endif
Ranjit Kumar Tulabandu8105bf42018-07-27 14:16:55 +05301059 // Stores the default value of skip flag depending on chroma format
1060 // Set as 1 for monochrome and 3 for other color formats
1061 int default_interp_skip_flags;
Yunqing Wangc3ab9272019-11-01 17:43:58 -07001062 // Filter mask to allow certain interp_filter type.
1063 uint16_t interp_filter_search_mask;
1064
Marco Paniconi67142112019-07-24 15:00:31 -07001065 int preserve_arf_as_gld;
Ravi Chaudharyc5e74692018-10-08 16:05:38 +05301066 MultiThreadHandle multi_thread_ctxt;
Ravi Chaudhary40cdf132018-10-08 11:04:16 +05301067 void (*row_mt_sync_read_ptr)(AV1RowMTSync *const, int, int);
1068 void (*row_mt_sync_write_ptr)(AV1RowMTSync *const, int, int, const int);
Ravi Chaudhary90a15f42018-10-11 18:56:35 +05301069#if CONFIG_MULTITHREAD
1070 pthread_mutex_t *row_mt_mutex_;
1071#endif
Aniket Dhokf6d7ed82019-01-04 14:05:57 +05301072 // Set if screen content is set or relevant tools are enabled
1073 int is_screen_content_type;
chiyotsai9c484b32019-03-07 16:01:50 -08001074#if CONFIG_COLLECT_PARTITION_STATS == 2
chiyotsai92ed0dd2019-01-25 14:50:14 -08001075 PartitionStats partition_stats;
1076#endif
Yunqing Wangba255582019-02-11 16:21:12 -08001077
1078#if CONFIG_COLLECT_COMPONENT_TIMING
1079 // component_time[] are initialized to zero while encoder starts.
1080 uint64_t component_time[kTimingComponents];
1081 struct aom_usec_timer component_timer[kTimingComponents];
1082 // frame_component_time[] are initialized to zero at beginning of each frame.
1083 uint64_t frame_component_time[kTimingComponents];
1084#endif
Hui Su81a59f12019-03-26 16:47:52 -07001085
1086 // The following data are for AV1 bitstream levels.
Hui Su2aa492c2019-03-12 15:18:18 -07001087 AV1_LEVEL target_seq_level_idx[MAX_NUM_OPERATING_POINTS];
Hui Su72ff0482019-05-28 14:07:37 -07001088 // Bit mask to indicate whether to keep level stats for corresponding
1089 // operating points.
1090 uint32_t keep_level_stats;
Hui Suc3a8d372019-05-28 15:52:45 -07001091 AV1LevelInfo *level_info[MAX_NUM_OPERATING_POINTS];
Hui Su4fd11762019-03-26 16:05:07 -07001092 // Count the number of OBU_FRAME and OBU_FRAME_HEADER for level calculation.
1093 int frame_header_count;
Debargha Mukherjee472df412019-04-29 15:00:02 -07001094
1095 // whether any no-zero delta_q was actually used
Yue Chenc87d7492019-05-30 17:22:49 -07001096 int deltaq_used;
sdengc23c7f12019-06-11 16:56:50 -07001097
Lokeshwar Reddy Bce8b7592019-07-09 18:19:55 +05301098 // Indicates the true relative distance of ref frame w.r.t. current frame
Lokeshwar Reddy B6c2c0f92019-07-31 10:18:58 +05301099 int ref_relative_dist[INTER_REFS_PER_FRAME];
Lokeshwar Reddy Bce8b7592019-07-09 18:19:55 +05301100
Lokeshwar Reddy B895efa72019-07-29 13:44:36 +05301101 // Indicate nearest references w.r.t. current frame in past and future
1102 int8_t nearest_past_ref;
1103 int8_t nearest_future_ref;
1104
Ravi Chaudhary267d9a42019-11-22 17:14:08 +05301105 // Indicates the number of simple translation winner modes for exhaustive
1106 // motion mode evaluation
1107 int num_winner_motion_modes;
1108
sdengf46a1062019-08-04 18:43:50 -07001109 // TODO(sdeng): consider merge the following arrays.
1110 double *tpl_rdmult_scaling_factors;
1111 double *tpl_sb_rdmult_scaling_factors;
sdengc23c7f12019-06-11 16:56:50 -07001112 double *ssim_rdmult_scaling_factors;
Marco Paniconi67142112019-07-24 15:00:31 -07001113
1114 int use_svc;
1115 SVC svc;
Mufaddal Chakeraac828682019-12-13 16:31:42 +05301116
Mufaddal Chakera5517b282019-12-13 16:39:56 +05301117 int lap_enabled;
Mufaddal Chakeraac828682019-12-13 16:31:42 +05301118 COMPRESSOR_STAGE compressor_stage;
Yaowu Xuf883b422016-08-30 14:01:10 -07001119} AV1_COMP;
Yaowu Xuc27fc142016-08-22 16:08:15 -07001120
David Turnercb5e36f2019-01-17 17:15:25 +00001121typedef struct {
1122 YV12_BUFFER_CONFIG *source;
1123 YV12_BUFFER_CONFIG *last_source;
1124 int64_t ts_duration;
1125} EncodeFrameInput;
1126
David Turner056f7cd2019-01-07 17:48:13 +00001127// EncodeFrameParams contains per-frame encoding parameters decided upon by
1128// av1_encode_strategy() and passed down to av1_encode()
David Turner475a3132019-01-18 15:17:17 +00001129struct EncodeFrameParams {
David Turner07dbd8e2019-01-08 17:16:25 +00001130 int error_resilient_mode;
David Turner475a3132019-01-18 15:17:17 +00001131 FRAME_TYPE frame_type;
David Turnera7f133c2019-01-22 14:47:16 +00001132 int primary_ref_frame;
1133 int order_offset;
David Turnerdedd8ff2019-01-23 13:59:46 +00001134 int show_frame;
David Turner6e8b4d92019-02-18 15:01:33 +00001135 int refresh_frame_flags;
David Turner07dbd8e2019-01-08 17:16:25 +00001136
David Turnere86ee0d2019-02-18 17:16:28 +00001137 int show_existing_frame;
1138 int existing_fb_idx_to_show;
1139
David Turnerfe3aecb2019-02-06 14:42:42 +00001140 // Bitmask of which reference buffers may be referenced by this frame
David Turner07dbd8e2019-01-08 17:16:25 +00001141 int ref_frame_flags;
1142
David Turner73245762019-02-11 16:42:34 +00001143 // Reference buffer assignment for this frame.
1144 int remapped_ref_idx[REF_FRAMES];
1145
David Turnerfe3aecb2019-02-06 14:42:42 +00001146 // Flags which determine which reference buffers are refreshed by this frame
1147 int refresh_last_frame;
1148 int refresh_golden_frame;
1149 int refresh_bwd_ref_frame;
David Turnerfe3aecb2019-02-06 14:42:42 +00001150 int refresh_alt_ref_frame;
1151
David Turner04b70d82019-01-24 15:39:19 +00001152 // Speed level to use for this frame: Bigger number means faster.
1153 int speed;
David Turner475a3132019-01-18 15:17:17 +00001154};
1155typedef struct EncodeFrameParams EncodeFrameParams;
David Turner056f7cd2019-01-07 17:48:13 +00001156
1157// EncodeFrameResults contains information about the result of encoding a
1158// single frame
1159typedef struct {
1160 size_t size; // Size of resulting bitstream
1161} EncodeFrameResults;
1162
Wan-Teh Chang3cac4542018-06-29 10:21:39 -07001163// Must not be called more than once.
Yaowu Xuf883b422016-08-30 14:01:10 -07001164void av1_initialize_enc(void);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001165
Yaowu Xuf883b422016-08-30 14:01:10 -07001166struct AV1_COMP *av1_create_compressor(AV1EncoderConfig *oxcf,
Aasaipriyabd659e42019-12-13 16:12:13 +05301167 BufferPool *const pool,
Mufaddal Chakera5517b282019-12-13 16:39:56 +05301168 FIRSTPASS_STATS *frame_stats_buf,
1169 COMPRESSOR_STAGE stage,
Akshata Jadhava49be172019-12-18 00:03:53 +05301170 int num_lap_buffers,
1171 STATS_BUFFER_CTX *stats_buf_context);
Yaowu Xuf883b422016-08-30 14:01:10 -07001172void av1_remove_compressor(AV1_COMP *cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001173
Yaowu Xuf883b422016-08-30 14:01:10 -07001174void av1_change_config(AV1_COMP *cpi, const AV1EncoderConfig *oxcf);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001175
Mufaddal Chakera02ac17f2019-12-09 18:09:55 +05301176void av1_check_initial_width(AV1_COMP *cpi, int use_highbitdepth,
1177 int subsampling_x, int subsampling_y);
1178
Yaowu Xuc27fc142016-08-22 16:08:15 -07001179// receive a frames worth of data. caller can assume that a copy of this
1180// frame is made and not just a copy of the pointer..
James Zern3e2613b2017-03-30 23:14:40 -07001181int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags,
Yaowu Xuf883b422016-08-30 14:01:10 -07001182 YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
1183 int64_t end_time_stamp);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001184
Andrey Norkin795ba872018-03-06 13:24:14 -08001185int av1_get_compressed_data(AV1_COMP *cpi, unsigned int *frame_flags,
1186 size_t *size, uint8_t *dest, int64_t *time_stamp,
1187 int64_t *time_end, int flush,
Yue Chen1bc5be62018-08-24 13:57:32 -07001188 const aom_rational64_t *timebase);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001189
David Turner056f7cd2019-01-07 17:48:13 +00001190int av1_encode(AV1_COMP *const cpi, uint8_t *const dest,
David Turnercb5e36f2019-01-17 17:15:25 +00001191 const EncodeFrameInput *const frame_input,
David Turner056f7cd2019-01-07 17:48:13 +00001192 const EncodeFrameParams *const frame_params,
1193 EncodeFrameResults *const frame_results);
1194
Yaowu Xuf883b422016-08-30 14:01:10 -07001195int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001196
Yaowu Xuf883b422016-08-30 14:01:10 -07001197int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001198
Yunqing Wang93b18f32018-06-08 21:08:29 -07001199aom_codec_err_t av1_copy_new_frame_enc(AV1_COMMON *cm,
1200 YV12_BUFFER_CONFIG *new_frame,
1201 YV12_BUFFER_CONFIG *sd);
Yunqing Wangff9bfca2018-06-06 11:46:08 -07001202
Yaowu Xuf883b422016-08-30 14:01:10 -07001203int av1_use_as_reference(AV1_COMP *cpi, int ref_frame_flags);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001204
Thomas Daede497d1952017-08-08 17:33:06 -07001205int av1_copy_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001206
Thomas Daede497d1952017-08-08 17:33:06 -07001207int av1_set_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001208
Marco Paniconi63971322019-08-15 21:32:05 -07001209int av1_set_size_literal(AV1_COMP *cpi, int width, int height);
1210
David Turner475a3132019-01-18 15:17:17 +00001211void av1_set_frame_size(AV1_COMP *cpi, int width, int height);
1212
Yaowu Xuf883b422016-08-30 14:01:10 -07001213int av1_update_entropy(AV1_COMP *cpi, int update);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001214
Yaowu Xuf883b422016-08-30 14:01:10 -07001215int av1_set_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001216
Yaowu Xuf883b422016-08-30 14:01:10 -07001217int av1_get_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001218
Yaowu Xuf883b422016-08-30 14:01:10 -07001219int av1_set_internal_size(AV1_COMP *cpi, AOM_SCALING horiz_mode,
1220 AOM_SCALING vert_mode);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001221
Yaowu Xuf883b422016-08-30 14:01:10 -07001222int av1_get_quantizer(struct AV1_COMP *cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001223
Soo-Chul Han29c46fb2018-03-23 16:02:00 -04001224int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t *input_size);
1225
Hui Su38711e72019-06-11 10:49:47 -07001226void av1_alloc_compound_type_rd_buffers(AV1_COMMON *const cm,
1227 CompoundTypeRdBuffers *const bufs);
1228void av1_release_compound_type_rd_buffers(CompoundTypeRdBuffers *const bufs);
1229
Jingning Hancf6d3252019-07-03 14:26:45 -07001230// TODO(jingning): Move these functions as primitive members for the new cpi
1231// class.
1232static INLINE void stack_push(int *stack, int *stack_size, int item) {
Jingning Han0a2af4e2019-07-08 19:30:03 -07001233 for (int i = *stack_size - 1; i >= 0; --i) stack[i + 1] = stack[i];
Jingning Hancf6d3252019-07-03 14:26:45 -07001234 stack[0] = item;
1235 ++*stack_size;
1236}
1237
1238static INLINE int stack_pop(int *stack, int *stack_size) {
Jingning Hanf58175c2019-07-07 15:02:00 -07001239 if (*stack_size <= 0) return -1;
1240
Jingning Hancf6d3252019-07-03 14:26:45 -07001241 int item = stack[0];
1242 for (int i = 0; i < *stack_size; ++i) stack[i] = stack[i + 1];
1243 --*stack_size;
1244
1245 return item;
1246}
1247
1248static INLINE int stack_pop_end(int *stack, int *stack_size) {
1249 int item = stack[*stack_size - 1];
1250 stack[*stack_size - 1] = -1;
1251 --*stack_size;
1252
1253 return item;
1254}
1255
1256static INLINE void stack_reset(int *stack, int *stack_size) {
1257 for (int i = 0; i < *stack_size; ++i) stack[i] = INVALID_IDX;
1258 *stack_size = 0;
1259}
1260
David Turnerdedd8ff2019-01-23 13:59:46 +00001261// av1 uses 10,000,000 ticks/second as time stamp
1262#define TICKS_PER_SEC 10000000LL
1263
Yue Chen1bc5be62018-08-24 13:57:32 -07001264static INLINE int64_t
1265timebase_units_to_ticks(const aom_rational64_t *timestamp_ratio, int64_t n) {
1266 return n * timestamp_ratio->num / timestamp_ratio->den;
David Turnerdedd8ff2019-01-23 13:59:46 +00001267}
1268
Yue Chen1bc5be62018-08-24 13:57:32 -07001269static INLINE int64_t
1270ticks_to_timebase_units(const aom_rational64_t *timestamp_ratio, int64_t n) {
1271 int64_t round = timestamp_ratio->num / 2;
1272 if (round > 0) --round;
1273 return (n * timestamp_ratio->den + round) / timestamp_ratio->num;
David Turnerdedd8ff2019-01-23 13:59:46 +00001274}
Andrey Norkin795ba872018-03-06 13:24:14 -08001275
Yaowu Xuf883b422016-08-30 14:01:10 -07001276static INLINE int frame_is_kf_gf_arf(const AV1_COMP *cpi) {
Jingning Han52af4392019-08-13 11:44:40 -07001277 const GF_GROUP *const gf_group = &cpi->gf_group;
1278 const FRAME_UPDATE_TYPE update_type = gf_group->update_type[gf_group->index];
1279
1280 return frame_is_intra_only(&cpi->common) || update_type == ARF_UPDATE ||
1281 update_type == GF_UPDATE;
Yaowu Xuc27fc142016-08-22 16:08:15 -07001282}
1283
Hui Su2d5fd742018-02-21 18:10:37 -08001284// TODO(huisu@google.com, youzhou@microsoft.com): enable hash-me for HBD.
Remyaa14a4582019-11-05 13:17:36 +05301285static INLINE int av1_use_hash_me(const AV1_COMP *const cpi) {
chiyotsai8cc054a2019-12-12 14:57:43 -08001286 return (cpi->common.allow_screen_content_tools &&
1287 !cpi->sf.mv_sf.disable_hash_me);
Hui Su2d5fd742018-02-21 18:10:37 -08001288}
1289
1290static INLINE hash_table *av1_get_ref_frame_hash_map(
David Turnera21966b2018-12-05 14:48:49 +00001291 const AV1_COMMON *cm, MV_REFERENCE_FRAME ref_frame) {
1292 const int map_idx = get_ref_frame_map_idx(cm, ref_frame);
1293 RefCntBuffer *buf =
1294 (map_idx != INVALID_IDX) ? cm->ref_frame_map[map_idx] : NULL;
1295 return buf ? &buf->hash_table : NULL;
RogerZhoucc5d35d2017-08-07 22:20:15 -07001296}
RogerZhoucc5d35d2017-08-07 22:20:15 -07001297
David Turnera21966b2018-12-05 14:48:49 +00001298static INLINE const YV12_BUFFER_CONFIG *get_ref_frame_yv12_buf(
1299 const AV1_COMMON *const cm, MV_REFERENCE_FRAME ref_frame) {
1300 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
David Turnere7ebf902018-12-04 14:04:55 +00001301 return buf != NULL ? &buf->buf : NULL;
Yaowu Xuc27fc142016-08-22 16:08:15 -07001302}
1303
David Turnera21966b2018-12-05 14:48:49 +00001304static INLINE int enc_is_ref_frame_buf(const AV1_COMMON *const cm,
1305 const RefCntBuffer *const frame_buf) {
Urvang Joshi40582172018-11-07 11:53:03 -08001306 MV_REFERENCE_FRAME ref_frame;
1307 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
David Turnera21966b2018-12-05 14:48:49 +00001308 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
David Turnere7ebf902018-12-04 14:04:55 +00001309 if (buf == NULL) continue;
1310 if (frame_buf == buf) break;
Yaowu Xuc27fc142016-08-22 16:08:15 -07001311 }
Urvang Joshi40582172018-11-07 11:53:03 -08001312 return (ref_frame <= ALTREF_FRAME);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001313}
Yaowu Xuc27fc142016-08-22 16:08:15 -07001314
David Turnere3e520d2019-01-18 14:38:08 +00001315static INLINE void alloc_frame_mvs(AV1_COMMON *const cm, RefCntBuffer *buf) {
1316 assert(buf != NULL);
1317 ensure_mv_buffer(buf, cm);
1318 buf->width = cm->width;
1319 buf->height = cm->height;
1320}
1321
Hui Su8ac0c982018-04-03 12:17:36 -07001322// Token buffer is only used for palette tokens.
Yaowu Xue39b3b82017-10-31 16:11:59 -07001323static INLINE unsigned int get_token_alloc(int mb_rows, int mb_cols,
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00001324 int sb_size_log2,
1325 const int num_planes) {
Rupert Swarbrickce63e832017-10-25 17:54:17 +01001326 // Calculate the maximum number of max superblocks in the image.
Yaowu Xue39b3b82017-10-31 16:11:59 -07001327 const int shift = sb_size_log2 - 4;
1328 const int sb_size = 1 << sb_size_log2;
1329 const int sb_size_square = sb_size * sb_size;
Rupert Swarbrickce63e832017-10-25 17:54:17 +01001330 const int sb_rows = ALIGN_POWER_OF_TWO(mb_rows, shift) >> shift;
1331 const int sb_cols = ALIGN_POWER_OF_TWO(mb_cols, shift) >> shift;
1332
Hui Su8ac0c982018-04-03 12:17:36 -07001333 // One palette token for each pixel. There can be palettes on two planes.
1334 const int sb_palette_toks = AOMMIN(2, num_planes) * sb_size_square;
Rupert Swarbrickce63e832017-10-25 17:54:17 +01001335
Hui Su8ac0c982018-04-03 12:17:36 -07001336 return sb_rows * sb_cols * sb_palette_toks;
Yaowu Xuc27fc142016-08-22 16:08:15 -07001337}
1338
1339// Get the allocated token size for a tile. It does the same calculation as in
1340// the frame token allocation.
Rupert Swarbrickdcb3cff2017-11-09 15:58:33 +00001341static INLINE unsigned int allocated_tokens(TileInfo tile, int sb_size_log2,
1342 int num_planes) {
Jingning Haneafbd5f2017-03-07 11:18:17 -08001343 int tile_mb_rows = (tile.mi_row_end - tile.mi_row_start + 2) >> 2;
1344 int tile_mb_cols = (tile.mi_col_end - tile.mi_col_start + 2) >> 2;
Yaowu Xuc27fc142016-08-22 16:08:15 -07001345
Rupert Swarbrickdcb3cff2017-11-09 15:58:33 +00001346 return get_token_alloc(tile_mb_rows, tile_mb_cols, sb_size_log2, num_planes);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001347}
1348
Ravi Chaudhary73cf15b2018-08-30 10:52:51 +05301349static INLINE void get_start_tok(AV1_COMP *cpi, int tile_row, int tile_col,
1350 int mi_row, TOKENEXTRA **tok, int sb_size_log2,
1351 int num_planes) {
1352 AV1_COMMON *const cm = &cpi->common;
1353 const int tile_cols = cm->tile_cols;
1354 TileDataEnc *this_tile = &cpi->tile_data[tile_row * tile_cols + tile_col];
1355 const TileInfo *const tile_info = &this_tile->tile_info;
1356
1357 const int tile_mb_cols =
1358 (tile_info->mi_col_end - tile_info->mi_col_start + 2) >> 2;
1359 const int tile_mb_row = (mi_row - tile_info->mi_row_start + 2) >> 2;
1360
1361 *tok = cpi->tile_tok[tile_row][tile_col] +
1362 get_token_alloc(tile_mb_row, tile_mb_cols, sb_size_log2, num_planes);
1363}
1364
Yaowu Xuf883b422016-08-30 14:01:10 -07001365void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001366
Yaowu Xu6da42302017-10-10 14:45:06 -07001367#define ALT_MIN_LAG 3
Yaowu Xuf883b422016-08-30 14:01:10 -07001368static INLINE int is_altref_enabled(const AV1_COMP *const cpi) {
Yaowu Xu6da42302017-10-10 14:45:06 -07001369 return cpi->oxcf.lag_in_frames >= ALT_MIN_LAG && cpi->oxcf.enable_auto_arf;
Yaowu Xuc27fc142016-08-22 16:08:15 -07001370}
1371
Mufaddal Chakerae7326122019-12-04 14:49:09 +05301372// Check if statistics generation stage
1373static INLINE int is_stat_generation_stage(const AV1_COMP *const cpi) {
Mufaddal Chakera5517b282019-12-13 16:39:56 +05301374 assert(IMPLIES(cpi->compressor_stage == LAP_STAGE,
1375 cpi->oxcf.pass == 0 && cpi->lap_enabled));
1376 return (cpi->oxcf.pass == 1 || (cpi->compressor_stage == LAP_STAGE));
Mufaddal Chakerae7326122019-12-04 14:49:09 +05301377}
Hamsalekha S37cc1d12019-12-12 19:27:41 +05301378// Check if statistics consumption stage
1379static INLINE int is_stat_consumption_stage_twopass(const AV1_COMP *const cpi) {
1380 return (cpi->oxcf.pass == 2);
1381}
1382
1383// Check if statistics consumption stage
1384static INLINE int is_stat_consumption_stage(const AV1_COMP *const cpi) {
1385 return (is_stat_consumption_stage_twopass(cpi));
1386}
Mufaddal Chakerae7326122019-12-04 14:49:09 +05301387
Mufaddal Chakera3bcc72c2019-12-11 14:38:37 +05301388// Check if the current stage has statistics
1389static INLINE int has_no_stats_stage(const AV1_COMP *const cpi) {
Mufaddal Chakera5517b282019-12-13 16:39:56 +05301390 assert(IMPLIES(!cpi->lap_enabled, cpi->compressor_stage == ENCODE_STAGE));
1391 return (cpi->oxcf.pass == 0 && !cpi->lap_enabled);
Mufaddal Chakera3bcc72c2019-12-11 14:38:37 +05301392}
1393
Akshata Jadhav4be65112019-12-18 00:26:25 +05301394// Function return size of frame stats buffer
1395static INLINE int get_stats_buf_size(int num_lap_buffer, int num_lag_buffer) {
1396 /* if lookahead is enabled return num_lap_buffers else num_lag_buffers */
1397 return (num_lap_buffer > 0 ? num_lap_buffer + 1 : num_lag_buffer);
1398}
1399
Yaowu Xuc27fc142016-08-22 16:08:15 -07001400// TODO(zoeliu): To set up cpi->oxcf.enable_auto_brf
Yaowu Xuc27fc142016-08-22 16:08:15 -07001401
Urvang Joshi52648442016-10-13 17:27:51 -07001402static INLINE void set_ref_ptrs(const AV1_COMMON *cm, MACROBLOCKD *xd,
Yaowu Xuc27fc142016-08-22 16:08:15 -07001403 MV_REFERENCE_FRAME ref0,
1404 MV_REFERENCE_FRAME ref1) {
David Turnera21966b2018-12-05 14:48:49 +00001405 xd->block_ref_scale_factors[0] =
1406 get_ref_scale_factors_const(cm, ref0 >= LAST_FRAME ? ref0 : 1);
1407 xd->block_ref_scale_factors[1] =
1408 get_ref_scale_factors_const(cm, ref1 >= LAST_FRAME ? ref1 : 1);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001409}
1410
Yaowu Xu4ff59b52017-04-24 12:41:56 -07001411static INLINE int get_chessboard_index(int frame_index) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07001412 return frame_index & 0x1;
1413}
1414
Yaowu Xuf883b422016-08-30 14:01:10 -07001415static INLINE int *cond_cost_list(const struct AV1_COMP *cpi, int *cost_list) {
chiyotsai8cc054a2019-12-12 14:57:43 -08001416 return cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE ? cost_list : NULL;
Yaowu Xuc27fc142016-08-22 16:08:15 -07001417}
1418
Hui Suef139e12019-05-20 15:51:22 -07001419// Compression ratio of current frame.
1420double av1_get_compression_ratio(const AV1_COMMON *const cm,
1421 size_t encoded_frame_size);
1422
Yaowu Xuf883b422016-08-30 14:01:10 -07001423void av1_new_framerate(AV1_COMP *cpi, double framerate);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001424
David Turnerdedd8ff2019-01-23 13:59:46 +00001425void av1_setup_frame_size(AV1_COMP *cpi);
1426
Yaowu Xuc27fc142016-08-22 16:08:15 -07001427#define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl))
1428
Cheng Chen09c83a52018-06-05 12:27:36 -07001429// Returns 1 if a frame is scaled and 0 otherwise.
1430static INLINE int av1_resize_scaled(const AV1_COMMON *cm) {
1431 return !(cm->superres_upscaled_width == cm->render_width &&
1432 cm->superres_upscaled_height == cm->render_height);
Fergus Simpsonfecb2ab2017-04-30 15:49:57 -07001433}
1434
Cheng Chen09c83a52018-06-05 12:27:36 -07001435static INLINE int av1_frame_scaled(const AV1_COMMON *cm) {
1436 return !av1_superres_scaled(cm) && av1_resize_scaled(cm);
Fergus Simpsonfecb2ab2017-04-30 15:49:57 -07001437}
1438
Sarah Parker33005522018-07-27 14:46:25 -07001439// Don't allow a show_existing_frame to coincide with an error resilient
1440// frame. An exception can be made for a forward keyframe since it has no
1441// previous dependencies.
1442static INLINE int encode_show_existing_frame(const AV1_COMMON *cm) {
David Turnerd2a592e2018-11-16 14:59:31 +00001443 return cm->show_existing_frame && (!cm->error_resilient_mode ||
1444 cm->current_frame.frame_type == KEY_FRAME);
Sarah Parker33005522018-07-27 14:46:25 -07001445}
1446
kyslov7b9d0d62018-12-21 11:12:26 -08001447// Lighter version of set_offsets that only sets the mode info
1448// pointers.
1449static INLINE void set_mode_info_offsets(const AV1_COMP *const cpi,
1450 MACROBLOCK *const x,
1451 MACROBLOCKD *const xd, int mi_row,
1452 int mi_col) {
1453 const AV1_COMMON *const cm = &cpi->common;
chiyotsaia7091f12019-08-09 16:48:27 -07001454 const int grid_idx = get_mi_grid_idx(cm, mi_row, mi_col);
1455 const int mi_idx = get_alloc_mi_idx(cm, mi_row, mi_col);
1456 const int ext_idx = get_mi_ext_idx(cm, mi_row, mi_col);
chiyotsai426c0662019-08-05 16:15:11 -07001457
chiyotsaia7091f12019-08-09 16:48:27 -07001458 xd->mi = cm->mi_grid_base + grid_idx;
1459 xd->mi[0] = cm->mi + mi_idx;
Hui Su52b7ddc2019-10-10 16:27:16 -07001460 xd->tx_type_map = cm->tx_type_map + grid_idx;
1461 xd->tx_type_map_stride = cm->mi_stride;
Remya0cce44c2019-08-16 11:57:24 +05301462 x->mbmi_ext_frame = cpi->mbmi_ext_frame_base + ext_idx;
kyslov7b9d0d62018-12-21 11:12:26 -08001463}
1464
1465// Check to see if the given partition size is allowed for a specified number
1466// of mi block rows and columns remaining in the image.
1467// If not then return the largest allowed partition size
1468static INLINE BLOCK_SIZE find_partition_size(BLOCK_SIZE bsize, int rows_left,
1469 int cols_left, int *bh, int *bw) {
1470 int int_size = (int)bsize;
1471 if (rows_left <= 0 || cols_left <= 0) {
1472 return AOMMIN(bsize, BLOCK_8X8);
1473 } else {
1474 for (; int_size > 0; int_size -= 3) {
1475 *bh = mi_size_high[int_size];
1476 *bw = mi_size_wide[int_size];
1477 if ((*bh <= rows_left) && (*bw <= cols_left)) {
1478 break;
1479 }
1480 }
1481 }
1482 return (BLOCK_SIZE)int_size;
1483}
1484
chiyotsaidd132d22019-03-11 14:22:49 -07001485static const uint8_t av1_ref_frame_flag_list[REF_FRAMES] = { 0,
1486 AOM_LAST_FLAG,
1487 AOM_LAST2_FLAG,
1488 AOM_LAST3_FLAG,
1489 AOM_GOLD_FLAG,
1490 AOM_BWD_FLAG,
1491 AOM_ALT2_FLAG,
1492 AOM_ALT_FLAG };
1493
Deepa K G33f1ab72019-09-23 17:59:06 +05301494// When more than 'max_allowed_refs' are available, we reduce the number of
1495// reference frames one at a time based on this order.
1496static const MV_REFERENCE_FRAME disable_order[] = {
1497 LAST3_FRAME,
1498 LAST2_FRAME,
1499 ALTREF2_FRAME,
1500 GOLDEN_FRAME,
1501};
1502
1503static INLINE int get_max_allowed_ref_frames(const AV1_COMP *cpi) {
1504 const unsigned int max_allowed_refs_for_given_speed =
chiyotsai868dc902019-12-12 15:32:52 -08001505 (cpi->sf.inter_sf.selective_ref_frame >= 3) ? INTER_REFS_PER_FRAME - 1
1506 : INTER_REFS_PER_FRAME;
Deepa K G33f1ab72019-09-23 17:59:06 +05301507 return AOMMIN(max_allowed_refs_for_given_speed,
1508 cpi->oxcf.max_reference_frames);
1509}
1510
Tom Fineganf8d6a162018-08-21 10:47:55 -07001511// Returns a Sequence Header OBU stored in an aom_fixed_buf_t, or NULL upon
1512// failure. When a non-NULL aom_fixed_buf_t pointer is returned by this
1513// function, the memory must be freed by the caller. Both the buf member of the
Tom Fineganca1e28f2018-08-28 16:55:35 -07001514// aom_fixed_buf_t, and the aom_fixed_buf_t pointer itself must be freed. Memory
1515// returned must be freed via call to free().
1516//
1517// Note: The OBU returned is in Low Overhead Bitstream Format. Specifically,
1518// the obu_has_size_field bit is set, and the buffer contains the obu_size
1519// field.
Tom Fineganf8d6a162018-08-21 10:47:55 -07001520aom_fixed_buf_t *av1_get_global_headers(AV1_COMP *cpi);
1521
Yue Chen4e585cc2019-06-03 14:47:16 -07001522#define ENABLE_KF_TPL 1
Debargha Mukherjeed0c0b772019-05-27 23:05:06 -07001523#define MAX_PYR_LEVEL_FROMTOP_DELTAQ 0
Yue Chen4e585cc2019-06-03 14:47:16 -07001524
1525static INLINE int is_frame_kf_and_tpl_eligible(AV1_COMP *const cpi) {
1526 AV1_COMMON *cm = &cpi->common;
Urvang Joshi05fc9fa2019-10-10 15:49:31 -07001527 return (cm->current_frame.frame_type == KEY_FRAME) && cm->show_frame &&
1528 (cpi->rc.frames_to_key > 1);
Debargha Mukherjeed0c0b772019-05-27 23:05:06 -07001529}
1530
Jingning Han44a573b2019-09-04 14:01:22 -07001531static INLINE int is_frame_arf_and_tpl_eligible(const GF_GROUP *gf_group) {
1532 const FRAME_UPDATE_TYPE update_type = gf_group->update_type[gf_group->index];
1533 return update_type == ARF_UPDATE || update_type == GF_UPDATE;
Debargha Mukherjeed0c0b772019-05-27 23:05:06 -07001534}
1535
Yue Chen4e585cc2019-06-03 14:47:16 -07001536static INLINE int is_frame_tpl_eligible(AV1_COMP *const cpi) {
1537#if ENABLE_KF_TPL
1538 return is_frame_kf_and_tpl_eligible(cpi) ||
Jingning Han44a573b2019-09-04 14:01:22 -07001539 is_frame_arf_and_tpl_eligible(&cpi->gf_group);
Yue Chen4e585cc2019-06-03 14:47:16 -07001540#else
Jingning Han44a573b2019-09-04 14:01:22 -07001541 return is_frame_arf_and_tpl_eligible(&cpi->gf_group);
Yue Chen4e585cc2019-06-03 14:47:16 -07001542#endif // ENABLE_KF_TPL
1543}
1544
Yunqing Wangdb70bf42019-08-19 09:28:11 -07001545// Get update type of the current frame.
Jingning Hancc914b42019-09-04 14:49:46 -07001546static INLINE FRAME_UPDATE_TYPE
1547get_frame_update_type(const GF_GROUP *gf_group) {
Yunqing Wangdb70bf42019-08-19 09:28:11 -07001548 return gf_group->update_type[gf_group->index];
1549}
1550
Hui Su30573182019-10-08 16:24:34 -07001551static INLINE int av1_pixels_to_mi(int pixels) {
1552 return ALIGN_POWER_OF_TWO(pixels, 3) >> MI_SIZE_LOG2;
1553}
1554
chiyotsai9c484b32019-03-07 16:01:50 -08001555#if CONFIG_COLLECT_PARTITION_STATS == 2
chiyotsai92ed0dd2019-01-25 14:50:14 -08001556static INLINE void av1_print_partition_stats(PartitionStats *part_stats) {
1557 FILE *f = fopen("partition_stats.csv", "w");
1558 if (!f) {
1559 return;
1560 }
1561
1562 fprintf(f, "bsize,redo,");
1563 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
1564 fprintf(f, "decision_%d,", part);
1565 }
1566 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
1567 fprintf(f, "attempt_%d,", part);
1568 }
chiyotsai9c484b32019-03-07 16:01:50 -08001569 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
1570 fprintf(f, "time_%d,", part);
1571 }
chiyotsai92ed0dd2019-01-25 14:50:14 -08001572 fprintf(f, "\n");
1573
1574 const int bsizes[6] = { 128, 64, 32, 16, 8, 4 };
1575
1576 for (int bsize_idx = 0; bsize_idx < 6; bsize_idx++) {
1577 fprintf(f, "%d,%d,", bsizes[bsize_idx], part_stats->partition_redo);
1578 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
1579 fprintf(f, "%d,", part_stats->partition_decisions[bsize_idx][part]);
1580 }
1581 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
1582 fprintf(f, "%d,", part_stats->partition_attempts[bsize_idx][part]);
1583 }
chiyotsai9c484b32019-03-07 16:01:50 -08001584 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
1585 fprintf(f, "%ld,", part_stats->partition_times[bsize_idx][part]);
1586 }
chiyotsai92ed0dd2019-01-25 14:50:14 -08001587 fprintf(f, "\n");
1588 }
1589 fclose(f);
1590}
1591
1592static INLINE int av1_get_bsize_idx_for_part_stats(BLOCK_SIZE bsize) {
1593 assert(bsize == BLOCK_128X128 || bsize == BLOCK_64X64 ||
chiyotsai9c484b32019-03-07 16:01:50 -08001594 bsize == BLOCK_32X32 || bsize == BLOCK_16X16 || bsize == BLOCK_8X8 ||
1595 bsize == BLOCK_4X4);
chiyotsai92ed0dd2019-01-25 14:50:14 -08001596 switch (bsize) {
1597 case BLOCK_128X128: return 0;
1598 case BLOCK_64X64: return 1;
1599 case BLOCK_32X32: return 2;
1600 case BLOCK_16X16: return 3;
1601 case BLOCK_8X8: return 4;
1602 case BLOCK_4X4: return 5;
1603 default: assert(0 && "Invalid bsize for partition_stats."); return -1;
1604 }
1605}
1606#endif
1607
Yunqing Wangba255582019-02-11 16:21:12 -08001608#if CONFIG_COLLECT_COMPONENT_TIMING
1609static INLINE void start_timing(AV1_COMP *cpi, int component) {
1610 aom_usec_timer_start(&cpi->component_timer[component]);
1611}
1612static INLINE void end_timing(AV1_COMP *cpi, int component) {
1613 aom_usec_timer_mark(&cpi->component_timer[component]);
1614 cpi->frame_component_time[component] +=
1615 aom_usec_timer_elapsed(&cpi->component_timer[component]);
1616}
1617static INLINE char const *get_frame_type_enum(int type) {
1618 switch (type) {
1619 case 0: return "KEY_FRAME";
1620 case 1: return "INTER_FRAME";
1621 case 2: return "INTRA_ONLY_FRAME";
1622 case 3: return "S_FRAME";
1623 default: assert(0);
1624 }
1625 return "error";
1626}
1627#endif
1628
Yaowu Xuc27fc142016-08-22 16:08:15 -07001629#ifdef __cplusplus
1630} // extern "C"
1631#endif
1632
James Zerne1cbb132018-08-22 14:10:36 -07001633#endif // AOM_AV1_ENCODER_ENCODER_H_