blob: 6ad1197acf64b3757371c05fd2a33e3287b7fe31 [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
Yaowu Xuf883b422016-08-30 14:01:10 -070012#ifndef AV1_ENCODER_ENCODER_H_
13#define AV1_ENCODER_ENCODER_H_
Yaowu Xuc27fc142016-08-22 16:08:15 -070014
15#include <stdio.h>
16
Yaowu Xuf883b422016-08-30 14:01:10 -070017#include "./aom_config.h"
18#include "aom/aomcx.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070019
20#include "av1/common/alloccommon.h"
21#include "av1/common/entropymode.h"
22#include "av1/common/thread_common.h"
23#include "av1/common/onyxc_int.h"
Fergus Simpsond2bcbb52017-05-22 23:15:05 -070024#include "av1/common/resize.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070025#include "av1/encoder/aq_cyclicrefresh.h"
26#if CONFIG_ANS
Alex Converseeb780e72016-12-13 12:46:41 -080027#include "aom_dsp/ans.h"
Alex Converse1ac1ae72016-09-17 15:11:16 -070028#include "aom_dsp/buf_ans.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070029#endif
Tom Finegan17ce8b12017-02-08 12:46:31 -080030#include "av1/encoder/av1_quantize.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070031#include "av1/encoder/context_tree.h"
32#include "av1/encoder/encodemb.h"
33#include "av1/encoder/firstpass.h"
34#include "av1/encoder/lookahead.h"
35#include "av1/encoder/mbgraph.h"
36#include "av1/encoder/mcomp.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070037#include "av1/encoder/ratectrl.h"
38#include "av1/encoder/rd.h"
39#include "av1/encoder/speed_features.h"
40#include "av1/encoder/tokenize.h"
Rostislav Pehlivanov002e7b72017-02-15 19:45:54 +000041#if CONFIG_XIPHRC
42#include "av1/encoder/ratectrl_xiph.h"
43#endif
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"
Yaowu Xuf883b422016-08-30 14:01:10 -070049#include "aom/internal/aom_codec_internal.h"
50#include "aom_util/aom_thread.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070051
52#ifdef __cplusplus
53extern "C" {
54#endif
55
56typedef struct {
Yaowu Xuc27fc142016-08-22 16:08:15 -070057 int nmv_vec_cost[NMV_CONTEXTS][MV_JOINTS];
58 int nmv_costs[NMV_CONTEXTS][2][MV_VALS];
59 int nmv_costs_hp[NMV_CONTEXTS][2][MV_VALS];
Yaowu Xuc27fc142016-08-22 16:08:15 -070060
Yaowu Xuc27fc142016-08-22 16:08:15 -070061 // 0 = Intra, Last, GF, ARF
62 signed char last_ref_lf_deltas[TOTAL_REFS_PER_FRAME];
63 // 0 = ZERO_MV, MV
64 signed char last_mode_lf_deltas[MAX_MODE_LF_DELTAS];
65
66 FRAME_CONTEXT fc;
67} CODING_CONTEXT;
68
69typedef enum {
70 // regular inter frame
71 REGULAR_FRAME = 0,
72 // alternate reference frame
73 ARF_FRAME = 1,
74 // overlay frame
75 OVERLAY_FRAME = 2,
76 // golden frame
77 GLD_FRAME = 3,
78#if CONFIG_EXT_REFS
79 // backward reference frame
80 BRF_FRAME = 4,
81 // extra alternate reference frame
82 EXT_ARF_FRAME = 5
83#endif
84} FRAME_CONTEXT_INDEX;
85
86typedef enum {
Yaowu Xuc27fc142016-08-22 16:08:15 -070087 NORMAL = 0,
88 FOURFIVE = 1,
89 THREEFIVE = 2,
90 ONETWO = 3
Yaowu Xuf883b422016-08-30 14:01:10 -070091} AOM_SCALING;
Yaowu Xuc27fc142016-08-22 16:08:15 -070092
93typedef enum {
94 // Good Quality Fast Encoding. The encoder balances quality with the amount of
95 // time it takes to encode the output. Speed setting controls how fast.
Thomas Daede80826142017-03-20 15:44:24 -070096 GOOD
Yaowu Xuc27fc142016-08-22 16:08:15 -070097} MODE;
98
99typedef enum {
100 FRAMEFLAGS_KEY = 1 << 0,
101 FRAMEFLAGS_GOLDEN = 1 << 1,
102#if CONFIG_EXT_REFS
103 FRAMEFLAGS_BWDREF = 1 << 2,
104 FRAMEFLAGS_ALTREF = 1 << 3,
105#else
106 FRAMEFLAGS_ALTREF = 1 << 2,
107#endif // CONFIG_EXT_REFS
108} FRAMETYPE_FLAGS;
109
110typedef enum {
111 NO_AQ = 0,
112 VARIANCE_AQ = 1,
113 COMPLEXITY_AQ = 2,
114 CYCLIC_REFRESH_AQ = 3,
Fangwen Fu6160df22017-04-24 09:45:51 -0700115#if CONFIG_DELTA_Q && !CONFIG_EXT_DELTA_Q
Arild Fuldseth07441162016-08-15 15:07:52 +0200116 DELTA_AQ = 4,
117#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -0700118 AQ_MODE_COUNT // This should always be the last member of the enum
119} AQ_MODE;
Fangwen Fu6160df22017-04-24 09:45:51 -0700120#if CONFIG_EXT_DELTA_Q
121typedef enum {
122 NO_DELTA_Q = 0,
123 DELTA_Q_ONLY = 1,
124 DELTA_Q_LF = 2,
125 DELTAQ_MODE_COUNT // This should always be the last member of the enum
126} DELTAQ_MODE;
127#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -0700128typedef enum {
129 RESIZE_NONE = 0, // No frame resizing allowed.
130 RESIZE_FIXED = 1, // All frames are coded at the specified dimension.
131 RESIZE_DYNAMIC = 2 // Coded size of each frame is determined by the codec.
Debargha Mukherjee29e40a62017-06-14 09:37:12 -0700132} RESIZE_MODE;
Fergus Simpsonc4e78942017-04-10 14:59:00 -0700133#if CONFIG_FRAME_SUPERRES
134typedef enum {
135 SUPERRES_NONE = 0,
136 SUPERRES_FIXED = 1,
137 SUPERRES_DYNAMIC = 2
138} SUPERRES_MODE;
139#endif // CONFIG_FRAME_SUPERRES
Yaowu Xuc27fc142016-08-22 16:08:15 -0700140
Yaowu Xuf883b422016-08-30 14:01:10 -0700141typedef struct AV1EncoderConfig {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700142 BITSTREAM_PROFILE profile;
Yaowu Xuf883b422016-08-30 14:01:10 -0700143 aom_bit_depth_t bit_depth; // Codec bit-depth.
Yaowu Xuc27fc142016-08-22 16:08:15 -0700144 int width; // width of data passed to the compressor
145 int height; // height of data passed to the compressor
146 unsigned int input_bit_depth; // Input bit depth.
147 double init_framerate; // set to passed in framerate
148 int64_t target_bandwidth; // bandwidth to be used in bits per second
149
150 int noise_sensitivity; // pre processing blur: recommendation 0
151 int sharpness; // sharpening output: recommendation 0:
152 int speed;
153 // maximum allowed bitrate for any intra frame in % of bitrate target.
154 unsigned int rc_max_intra_bitrate_pct;
155 // maximum allowed bitrate for any inter frame in % of bitrate target.
156 unsigned int rc_max_inter_bitrate_pct;
157 // percent of rate boost for golden frame in CBR mode.
158 unsigned int gf_cbr_boost_pct;
159
160 MODE mode;
161 int pass;
162
163 // Key Framing Operations
164 int auto_key; // autodetect cut scenes and set the keyframes
165 int key_freq; // maximum distance to key frame.
166
167 int lag_in_frames; // how many frames lag before we start encoding
168
169 // ----------------------------------------------------------------
170 // DATARATE CONTROL OPTIONS
171
172 // vbr, cbr, constrained quality or constant quality
Yaowu Xuf883b422016-08-30 14:01:10 -0700173 enum aom_rc_mode rc_mode;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700174
175 // buffer targeting aggressiveness
176 int under_shoot_pct;
177 int over_shoot_pct;
178
179 // buffering parameters
180 int64_t starting_buffer_level_ms;
181 int64_t optimal_buffer_level_ms;
182 int64_t maximum_buffer_size_ms;
183
184 // Frame drop threshold.
185 int drop_frames_water_mark;
186
187 // controlling quality
188 int fixed_q;
189 int worst_allowed_q;
190 int best_allowed_q;
191 int cq_level;
192 AQ_MODE aq_mode; // Adaptive Quantization mode
Fangwen Fu6160df22017-04-24 09:45:51 -0700193#if CONFIG_EXT_DELTA_Q
194 DELTAQ_MODE deltaq_mode;
195#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -0700196#if CONFIG_AOM_QM
197 int using_qm;
198 int qm_minlevel;
199 int qm_maxlevel;
200#endif
Thomas Daviesaf6df172016-11-09 14:04:18 +0000201#if CONFIG_TILE_GROUPS
202 unsigned int num_tile_groups;
203 unsigned int mtu;
204#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -0700205
Fangwen Fu8d164de2016-12-14 13:40:54 -0800206#if CONFIG_TEMPMV_SIGNALING
207 unsigned int disable_tempmv;
208#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -0700209 // Internal frame size scaling.
Debargha Mukherjee29e40a62017-06-14 09:37:12 -0700210 RESIZE_MODE resize_mode;
211 uint8_t resize_scale_numerator;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700212
Fergus Simpson3502d082017-04-10 12:25:07 -0700213#if CONFIG_FRAME_SUPERRES
Fergus Simpsonc4e78942017-04-10 14:59:00 -0700214 // Frame Super-Resolution size scaling.
215 SUPERRES_MODE superres_mode;
216 uint8_t superres_scale_numerator;
Fergus Simpson3502d082017-04-10 12:25:07 -0700217#endif // CONFIG_FRAME_SUPERRES
218
Yaowu Xuc27fc142016-08-22 16:08:15 -0700219 // Enable feature to reduce the frame quantization every x frames.
220 int frame_periodic_boost;
221
222 // two pass datarate control
223 int two_pass_vbrbias; // two pass datarate control tweaks
224 int two_pass_vbrmin_section;
225 int two_pass_vbrmax_section;
226 // END DATARATE CONTROL OPTIONS
227 // ----------------------------------------------------------------
228
229 int enable_auto_arf;
230#if CONFIG_EXT_REFS
231 int enable_auto_brf; // (b)ackward (r)ef (f)rame
232#endif // CONFIG_EXT_REFS
233
Yaowu Xuc27fc142016-08-22 16:08:15 -0700234 /* Bitfield defining the error resiliency features to enable.
235 * Can provide decodable frames after losses in previous
236 * frames and decodable partitions after losses in the same frame.
237 */
238 unsigned int error_resilient_mode;
239
240 /* Bitfield defining the parallel decoding mode where the
241 * decoding in successive frames may be conducted in parallel
242 * just by decoding the frame headers.
243 */
244 unsigned int frame_parallel_decoding_mode;
245
246 int arnr_max_frames;
247 int arnr_strength;
248
249 int min_gf_interval;
250 int max_gf_interval;
251
252 int tile_columns;
253 int tile_rows;
Fangwen Fu7b9f2b32017-01-17 14:01:52 -0800254#if CONFIG_DEPENDENT_HORZTILES
255 int dependent_horz_tiles;
256#endif
Ryan Lei9b02b0e2017-01-30 15:52:20 -0800257#if CONFIG_LOOPFILTERING_ACROSS_TILES
Ryan Lei7386eda2016-12-08 21:08:31 -0800258 int loop_filter_across_tiles_enabled;
Ryan Lei9b02b0e2017-01-30 15:52:20 -0800259#endif // CONFIG_LOOPFILTERING_ACROSS_TILES
Yaowu Xuc27fc142016-08-22 16:08:15 -0700260
261 int max_threads;
262
Yaowu Xuf883b422016-08-30 14:01:10 -0700263 aom_fixed_buf_t two_pass_stats_in;
264 struct aom_codec_pkt_list *output_pkt_list;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700265
266#if CONFIG_FP_MB_STATS
Yaowu Xuf883b422016-08-30 14:01:10 -0700267 aom_fixed_buf_t firstpass_mb_stats_in;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700268#endif
269
Yaowu Xuf883b422016-08-30 14:01:10 -0700270 aom_tune_metric tuning;
271 aom_tune_content content;
Sebastien Alaiwan71e87842017-04-12 16:03:28 +0200272#if CONFIG_HIGHBITDEPTH
Yaowu Xuc27fc142016-08-22 16:08:15 -0700273 int use_highbitdepth;
274#endif
Yaowu Xuf883b422016-08-30 14:01:10 -0700275 aom_color_space_t color_space;
anorkin76fb1262017-03-22 15:12:12 -0700276#if CONFIG_COLORSPACE_HEADERS
277 aom_transfer_function_t transfer_function;
278 aom_chroma_sample_position_t chroma_sample_position;
279#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -0700280 int color_range;
281 int render_width;
282 int render_height;
283
284#if CONFIG_EXT_PARTITION
Yaowu Xuf883b422016-08-30 14:01:10 -0700285 aom_superblock_size_t superblock_size;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700286#endif // CONFIG_EXT_PARTITION
Alex Converseeb780e72016-12-13 12:46:41 -0800287#if CONFIG_ANS && ANS_MAX_SYMBOLS
288 int ans_window_size_log2;
289#endif // CONFIG_ANS && ANS_MAX_SYMBOLS
Yunqing Wangd8cd55f2017-02-27 12:16:00 -0800290#if CONFIG_EXT_TILE
291 unsigned int tile_encoding_mode;
292#endif // CONFIG_EXT_TILE
Yunqing Wangff4fa062017-04-21 10:56:08 -0700293
294 unsigned int motion_vector_unit_test;
Yaowu Xuf883b422016-08-30 14:01:10 -0700295} AV1EncoderConfig;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700296
Yaowu Xuf883b422016-08-30 14:01:10 -0700297static INLINE int is_lossless_requested(const AV1EncoderConfig *cfg) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700298 return cfg->best_allowed_q == 0 && cfg->worst_allowed_q == 0;
299}
300
301// TODO(jingning) All spatially adaptive variables should go to TileDataEnc.
302typedef struct TileDataEnc {
303 TileInfo tile_info;
304 int thresh_freq_fact[BLOCK_SIZES][MAX_MODES];
305 int mode_map[BLOCK_SIZES][MAX_MODES];
Yunqing Wang8c1e57c2016-10-25 15:15:23 -0700306 int m_search_count;
307 int ex_search_count;
Yushin Cho77bba8d2016-11-04 16:36:56 -0700308#if CONFIG_PVQ
309 PVQ_QUEUE pvq_q;
310#endif
Luc Trudeauf8164152017-04-11 16:20:51 -0400311#if CONFIG_CFL
312 CFL_CTX cfl;
313#endif
Thomas Daviesf77d4ad2017-01-10 18:55:42 +0000314#if CONFIG_EC_ADAPT
Jingning Han9f07be12017-04-13 09:31:40 -0700315 DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx);
Thomas Daviesf77d4ad2017-01-10 18:55:42 +0000316#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -0700317} TileDataEnc;
318
319typedef struct RD_COUNTS {
Yaowu Xuf883b422016-08-30 14:01:10 -0700320 av1_coeff_count coef_counts[TX_SIZES][PLANE_TYPES];
Yaowu Xuc27fc142016-08-22 16:08:15 -0700321 int64_t comp_pred_diff[REFERENCE_MODES];
Debargha Mukherjeea575d232017-04-28 17:46:47 -0700322#if CONFIG_GLOBAL_MOTION
323 // Stores number of 4x4 blocks using global motion per reference frame.
324 int global_motion_used[TOTAL_REFS_PER_FRAME];
325#endif // CONFIG_GLOBAL_MOTION
Arild Fuldseth (arilfuld)6c20c782017-06-15 09:45:02 +0200326 int single_ref_used_flag;
327 int compound_ref_used_flag;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700328} RD_COUNTS;
329
330typedef struct ThreadData {
331 MACROBLOCK mb;
332 RD_COUNTS rd_counts;
333 FRAME_COUNTS *counts;
334
335 PICK_MODE_CONTEXT *leaf_tree;
336 PC_TREE *pc_tree;
337 PC_TREE *pc_root[MAX_MIB_SIZE_LOG2 - MIN_MIB_SIZE_LOG2 + 1];
Jingning Hand064cf02017-06-01 10:00:39 -0700338#if CONFIG_MOTION_VAR
339 int32_t *wsrc_buf;
340 int32_t *mask_buf;
341 uint8_t *above_pred_buf;
342 uint8_t *left_pred_buf;
343#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -0700344
hui su5d493142017-05-08 12:06:12 -0700345#if CONFIG_PALETTE
346 PALETTE_BUFFER *palette_buffer;
347#endif // CONFIG_PALETTE
Yaowu Xuc27fc142016-08-22 16:08:15 -0700348} ThreadData;
349
350struct EncWorkerData;
351
352typedef struct ActiveMap {
353 int enabled;
354 int update;
355 unsigned char *map;
356} ActiveMap;
357
Urvang Joshib5ed3502016-10-17 16:38:05 -0700358#define NUM_STAT_TYPES 4 // types of stats: Y, U, V and ALL
Yaowu Xuc27fc142016-08-22 16:08:15 -0700359
360typedef struct IMAGE_STAT {
Urvang Joshib5ed3502016-10-17 16:38:05 -0700361 double stat[NUM_STAT_TYPES];
Yaowu Xuc27fc142016-08-22 16:08:15 -0700362 double worst;
363} ImageStat;
364
Urvang Joshib5ed3502016-10-17 16:38:05 -0700365#undef NUM_STAT_TYPES
366
Yaowu Xuc27fc142016-08-22 16:08:15 -0700367typedef struct {
368 int ref_count;
369 YV12_BUFFER_CONFIG buf;
370} EncRefCntBuffer;
371
Yaowu Xuc27fc142016-08-22 16:08:15 -0700372typedef struct TileBufferEnc {
373 uint8_t *data;
374 size_t size;
375} TileBufferEnc;
376
Yaowu Xuf883b422016-08-30 14:01:10 -0700377typedef struct AV1_COMP {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700378 QUANTS quants;
379 ThreadData td;
380 MB_MODE_INFO_EXT *mbmi_ext_base;
Yi Luoc6210232017-05-25 15:09:25 -0700381 Dequants dequants;
Yaowu Xuf883b422016-08-30 14:01:10 -0700382 AV1_COMMON common;
383 AV1EncoderConfig oxcf;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700384 struct lookahead_ctx *lookahead;
385 struct lookahead_entry *alt_ref_source;
386
Alex Conversef77fd0b2017-04-20 11:00:24 -0700387 YV12_BUFFER_CONFIG *source;
388 YV12_BUFFER_CONFIG *last_source; // NULL for first frame and alt_ref frames
Fergus Simpsond2bcbb52017-05-22 23:15:05 -0700389 YV12_BUFFER_CONFIG *unscaled_source;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700390 YV12_BUFFER_CONFIG scaled_source;
391 YV12_BUFFER_CONFIG *unscaled_last_source;
392 YV12_BUFFER_CONFIG scaled_last_source;
393
394 // Up-sampled reference buffers
395 // NOTE(zoeliu): It is needed to allocate sufficient space to the up-sampled
396 // reference buffers, which should include the up-sampled version of all the
397 // possibly stored references plus the currently coded frame itself.
398 EncRefCntBuffer upsampled_ref_bufs[REF_FRAMES + 1];
399 int upsampled_ref_idx[REF_FRAMES + 1];
400
401 // For a still frame, this flag is set to 1 to skip partition search.
402 int partition_search_skippable_frame;
403
404 int scaled_ref_idx[TOTAL_REFS_PER_FRAME];
405#if CONFIG_EXT_REFS
406 int lst_fb_idxes[LAST_REF_FRAMES];
407#else
408 int lst_fb_idx;
409#endif // CONFIG_EXT_REFS
410 int gld_fb_idx;
411#if CONFIG_EXT_REFS
412 int bwd_fb_idx; // BWD_REF_FRAME
413#endif // CONFIG_EXT_REFS
414 int alt_fb_idx;
415
416 int last_show_frame_buf_idx; // last show frame buffer index
417
418 int refresh_last_frame;
419 int refresh_golden_frame;
420#if CONFIG_EXT_REFS
421 int refresh_bwd_ref_frame;
422#endif // CONFIG_EXT_REFS
423 int refresh_alt_ref_frame;
424
425 int ext_refresh_frame_flags_pending;
426 int ext_refresh_last_frame;
427 int ext_refresh_golden_frame;
428 int ext_refresh_alt_ref_frame;
429
430 int ext_refresh_frame_context_pending;
431 int ext_refresh_frame_context;
432
433 YV12_BUFFER_CONFIG last_frame_uf;
434#if CONFIG_LOOP_RESTORATION
435 YV12_BUFFER_CONFIG last_frame_db;
Debargha Mukherjee999d2f62016-12-15 13:23:21 -0800436 YV12_BUFFER_CONFIG trial_frame_rst;
Debargha Mukherjeea43a2d92017-01-03 15:14:57 -0800437 uint8_t *extra_rstbuf; // Extra buffers used in restoration search
438 RestorationInfo rst_search[MAX_MB_PLANE]; // Used for encoder side search
439#endif // CONFIG_LOOP_RESTORATION
Yaowu Xuc27fc142016-08-22 16:08:15 -0700440
441 // Ambient reconstruction err target for force key frames
442 int64_t ambient_err;
443
444 RD_OPT rd;
445
446 CODING_CONTEXT coding_context;
447
Urvang Joshibffc0b52016-07-25 13:38:49 -0700448 int nmv_costs[NMV_CONTEXTS][2][MV_VALS];
449 int nmv_costs_hp[NMV_CONTEXTS][2][MV_VALS];
Yaowu Xuc27fc142016-08-22 16:08:15 -0700450
Yaowu Xuc27fc142016-08-22 16:08:15 -0700451 int64_t last_time_stamp_seen;
452 int64_t last_end_time_stamp_seen;
453 int64_t first_time_stamp_ever;
454
455 RATE_CONTROL rc;
Rostislav Pehlivanov002e7b72017-02-15 19:45:54 +0000456#if CONFIG_XIPHRC
457 od_rc_state od_rc;
458#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -0700459 double framerate;
460
461 // NOTE(zoeliu): Any inter frame allows maximum of REF_FRAMES inter
462 // references; Plus the currently coded frame itself, it is needed to allocate
463 // sufficient space to the size of the maximum possible number of frames.
464 int interp_filter_selected[REF_FRAMES + 1][SWITCHABLE];
465
Yaowu Xuf883b422016-08-30 14:01:10 -0700466 struct aom_codec_pkt_list *output_pkt_list;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700467
468 MBGRAPH_FRAME_STATS mbgraph_stats[MAX_LAG_BUFFERS];
469 int mbgraph_n_frames; // number of frames filled in the above
470 int static_mb_pct; // % forced skip mbs by segmentation
471 int ref_frame_flags;
472
473 SPEED_FEATURES sf;
474
475 unsigned int max_mv_magnitude;
476 int mv_step_param;
477
478 int allow_comp_inter_inter;
479
Yaowu Xuc27fc142016-08-22 16:08:15 -0700480 uint8_t *segmentation_map;
481
Yaowu Xuc27fc142016-08-22 16:08:15 -0700482 CYCLIC_REFRESH *cyclic_refresh;
483 ActiveMap active_map;
484
485 fractional_mv_step_fp *find_fractional_mv_step;
Yaowu Xuf883b422016-08-30 14:01:10 -0700486 av1_full_search_fn_t full_search_sad; // It is currently unused.
487 av1_diamond_search_fn_t diamond_search_sad;
488 aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES];
Yaowu Xuc27fc142016-08-22 16:08:15 -0700489 uint64_t time_receive_data;
490 uint64_t time_compress_data;
491 uint64_t time_pick_lpf;
492 uint64_t time_encode_sb_row;
493
494#if CONFIG_FP_MB_STATS
495 int use_fp_mb_stats;
496#endif
497
498 TWO_PASS twopass;
499
500 YV12_BUFFER_CONFIG alt_ref_buffer;
501
502#if CONFIG_INTERNAL_STATS
503 unsigned int mode_chosen_counts[MAX_MODES];
504
505 int count;
506 uint64_t total_sq_error;
507 uint64_t total_samples;
508 ImageStat psnr;
509
510 double total_blockiness;
511 double worst_blockiness;
512
513 int bytes;
514 double summed_quality;
515 double summed_weights;
516 unsigned int tot_recode_hits;
517 double worst_ssim;
518
519 ImageStat fastssim;
520 ImageStat psnrhvs;
521
522 int b_calculate_blockiness;
523 int b_calculate_consistency;
524
525 double total_inconsistency;
526 double worst_consistency;
527 Ssimv *ssim_vars;
528 Metrics metrics;
529#endif
530 int b_calculate_psnr;
531
532 int droppable;
533
534 int initial_width;
535 int initial_height;
536 int initial_mbs; // Number of MBs in the full-size frame; to be used to
537 // normalize the firstpass stats. This will differ from the
538 // number of MBs in the current frame when the frame is
539 // scaled.
540
Yaowu Xuc27fc142016-08-22 16:08:15 -0700541 int frame_flags;
542
543 search_site_config ss_cfg;
544
545 int mbmode_cost[BLOCK_SIZE_GROUPS][INTRA_MODES];
Yaowu Xuc27fc142016-08-22 16:08:15 -0700546 int newmv_mode_cost[NEWMV_MODE_CONTEXTS][2];
547 int zeromv_mode_cost[ZEROMV_MODE_CONTEXTS][2];
548 int refmv_mode_cost[REFMV_MODE_CONTEXTS][2];
549 int drl_mode_cost0[DRL_MODE_CONTEXTS][2];
Yaowu Xuc27fc142016-08-22 16:08:15 -0700550
551 unsigned int inter_mode_cost[INTER_MODE_CONTEXTS][INTER_MODES];
552#if CONFIG_EXT_INTER
clang-format67948d32016-09-07 22:40:40 -0700553 unsigned int inter_compound_mode_cost[INTER_MODE_CONTEXTS]
554 [INTER_COMPOUND_MODES];
Zoe Liu85b66462017-04-20 14:28:19 -0700555#if CONFIG_COMPOUND_SINGLEREF
556 unsigned int inter_singleref_comp_mode_cost[INTER_MODE_CONTEXTS]
557 [INTER_SINGLEREF_COMP_MODES];
558#endif // CONFIG_COMPOUND_SINGLEREF
Yue Chen4d26acb2017-05-01 12:28:34 -0700559#if CONFIG_INTERINTRA
Yaowu Xuc27fc142016-08-22 16:08:15 -0700560 unsigned int interintra_mode_cost[BLOCK_SIZE_GROUPS][INTERINTRA_MODES];
Yue Chen4d26acb2017-05-01 12:28:34 -0700561#endif // CONFIG_INTERINTRA
Yaowu Xuc27fc142016-08-22 16:08:15 -0700562#endif // CONFIG_EXT_INTER
Yue Chencb60b182016-10-13 15:18:22 -0700563#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
564 int motion_mode_cost[BLOCK_SIZES][MOTION_MODES];
Yue Chen69f18e12016-09-08 14:48:15 -0700565#if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
566 int motion_mode_cost1[BLOCK_SIZES][2];
567#endif // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
Yue Chencb60b182016-10-13 15:18:22 -0700568#endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
Yaowu Xuc27fc142016-08-22 16:08:15 -0700569 int intra_uv_mode_cost[INTRA_MODES][INTRA_MODES];
570 int y_mode_costs[INTRA_MODES][INTRA_MODES][INTRA_MODES];
571 int switchable_interp_costs[SWITCHABLE_FILTER_CONTEXTS][SWITCHABLE_FILTERS];
572#if CONFIG_EXT_PARTITION_TYPES
Alex Converse55c6bde2017-01-12 15:55:31 -0800573 int partition_cost[PARTITION_CONTEXTS + CONFIG_UNPOISON_PARTITION_CTX]
574 [EXT_PARTITION_TYPES];
Yaowu Xuc27fc142016-08-22 16:08:15 -0700575#else
Alex Converse55c6bde2017-01-12 15:55:31 -0800576 int partition_cost[PARTITION_CONTEXTS + CONFIG_UNPOISON_PARTITION_CTX]
577 [PARTITION_TYPES];
Yaowu Xuc27fc142016-08-22 16:08:15 -0700578#endif
Urvang Joshib100db72016-10-12 16:28:56 -0700579#if CONFIG_PALETTE
Yaowu Xuc27fc142016-08-22 16:08:15 -0700580 int palette_y_size_cost[PALETTE_BLOCK_SIZES][PALETTE_SIZES];
581 int palette_uv_size_cost[PALETTE_BLOCK_SIZES][PALETTE_SIZES];
Alex Converse92109812017-02-22 10:21:40 -0800582 int palette_y_color_cost[PALETTE_SIZES][PALETTE_COLOR_INDEX_CONTEXTS]
clang-format67948d32016-09-07 22:40:40 -0700583 [PALETTE_COLORS];
Alex Converse92109812017-02-22 10:21:40 -0800584 int palette_uv_color_cost[PALETTE_SIZES][PALETTE_COLOR_INDEX_CONTEXTS]
clang-format67948d32016-09-07 22:40:40 -0700585 [PALETTE_COLORS];
Urvang Joshib100db72016-10-12 16:28:56 -0700586#endif // CONFIG_PALETTE
Yaowu Xuc27fc142016-08-22 16:08:15 -0700587 int tx_size_cost[TX_SIZES - 1][TX_SIZE_CONTEXTS][TX_SIZES];
588#if CONFIG_EXT_TX
589 int inter_tx_type_costs[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
590 int intra_tx_type_costs[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
591 [TX_TYPES];
592#else
593 int intra_tx_type_costs[EXT_TX_SIZES][TX_TYPES][TX_TYPES];
594 int inter_tx_type_costs[EXT_TX_SIZES][TX_TYPES];
595#endif // CONFIG_EXT_TX
596#if CONFIG_EXT_INTRA
hui sueda3d762016-12-06 16:58:23 -0800597#if CONFIG_INTRA_INTERP
Yaowu Xuc27fc142016-08-22 16:08:15 -0700598 int intra_filter_cost[INTRA_FILTERS + 1][INTRA_FILTERS];
hui sueda3d762016-12-06 16:58:23 -0800599#endif // CONFIG_INTRA_INTERP
Yaowu Xuc27fc142016-08-22 16:08:15 -0700600#endif // CONFIG_EXT_INTRA
Debargha Mukherjee5cd2ab92016-09-08 15:15:17 -0700601#if CONFIG_LOOP_RESTORATION
602 int switchable_restore_cost[RESTORE_SWITCHABLE_TYPES];
603#endif // CONFIG_LOOP_RESTORATION
Debargha Mukherjee9febfc12016-12-07 13:20:44 -0800604#if CONFIG_GLOBAL_MOTION
605 int gmtype_cost[TRANS_TYPES];
Debargha Mukherjee265db6d2017-03-28 11:15:27 -0700606 int gmparams_cost[TOTAL_REFS_PER_FRAME];
Debargha Mukherjee9febfc12016-12-07 13:20:44 -0800607#endif // CONFIG_GLOBAL_MOTION
Yaowu Xuc27fc142016-08-22 16:08:15 -0700608
609 int multi_arf_allowed;
610 int multi_arf_enabled;
611 int multi_arf_last_grp_enabled;
612
613 TileDataEnc *tile_data;
614 int allocated_tiles; // Keep track of memory allocated for tiles.
615
616 TOKENEXTRA *tile_tok[MAX_TILE_ROWS][MAX_TILE_COLS];
617 unsigned int tok_count[MAX_TILE_ROWS][MAX_TILE_COLS];
618
619 TileBufferEnc tile_buffers[MAX_TILE_ROWS][MAX_TILE_COLS];
620
Yaowu Xuc27fc142016-08-22 16:08:15 -0700621 int resize_state;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700622 int resize_avg_qp;
623 int resize_buffer_underflow;
624 int resize_count;
625
Yaowu Xuc27fc142016-08-22 16:08:15 -0700626 // VARIANCE_AQ segment map refresh
627 int vaq_refresh;
628
629 // Multi-threading
630 int num_workers;
Yaowu Xuf883b422016-08-30 14:01:10 -0700631 AVxWorker *workers;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700632 struct EncWorkerData *tile_thr_data;
Yaowu Xuf883b422016-08-30 14:01:10 -0700633 AV1LfSync lf_row_sync;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700634#if CONFIG_ANS
635 struct BufAnsCoder buf_ans;
636#endif
637#if CONFIG_EXT_REFS
638 int refresh_frame_mask;
639 int existing_fb_idx_to_show;
640 int is_arf_filter_off[MAX_EXT_ARFS + 1];
641 int num_extra_arfs;
642 int arf_map[MAX_EXT_ARFS + 1];
643#endif // CONFIG_EXT_REFS
644#if CONFIG_GLOBAL_MOTION
Debargha Mukherjeeb98a7022016-11-15 16:07:12 -0800645 int global_motion_search_done;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700646#endif
Arild Fuldseth (arilfuld)5114b7b2016-11-09 13:32:54 +0100647#if CONFIG_REFERENCE_BUFFER
648 SequenceHeader seq_params;
649#endif
Angie Chiangf0fbf9d2017-03-15 15:01:22 -0700650#if CONFIG_LV_MAP
651 tran_low_t *tcoeff_buf[MAX_MB_PLANE];
652#endif
Yaowu Xuf883b422016-08-30 14:01:10 -0700653} AV1_COMP;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700654
Yaowu Xuf883b422016-08-30 14:01:10 -0700655void av1_initialize_enc(void);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700656
Yaowu Xuf883b422016-08-30 14:01:10 -0700657struct AV1_COMP *av1_create_compressor(AV1EncoderConfig *oxcf,
658 BufferPool *const pool);
659void av1_remove_compressor(AV1_COMP *cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700660
Yaowu Xuf883b422016-08-30 14:01:10 -0700661void av1_change_config(AV1_COMP *cpi, const AV1EncoderConfig *oxcf);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700662
663// receive a frames worth of data. caller can assume that a copy of this
664// frame is made and not just a copy of the pointer..
James Zern3e2613b2017-03-30 23:14:40 -0700665int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags,
Yaowu Xuf883b422016-08-30 14:01:10 -0700666 YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
667 int64_t end_time_stamp);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700668
Yaowu Xuf883b422016-08-30 14:01:10 -0700669int av1_get_compressed_data(AV1_COMP *cpi, unsigned int *frame_flags,
670 size_t *size, uint8_t *dest, int64_t *time_stamp,
671 int64_t *time_end, int flush);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700672
Yaowu Xuf883b422016-08-30 14:01:10 -0700673int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700674
Yaowu Xuf883b422016-08-30 14:01:10 -0700675int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700676
Yaowu Xuf883b422016-08-30 14:01:10 -0700677int av1_use_as_reference(AV1_COMP *cpi, int ref_frame_flags);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700678
Yaowu Xuf883b422016-08-30 14:01:10 -0700679void av1_update_reference(AV1_COMP *cpi, int ref_frame_flags);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700680
Yaowu Xuf883b422016-08-30 14:01:10 -0700681int av1_copy_reference_enc(AV1_COMP *cpi, AOM_REFFRAME ref_frame_flag,
Yaowu Xuc27fc142016-08-22 16:08:15 -0700682 YV12_BUFFER_CONFIG *sd);
683
Yaowu Xuf883b422016-08-30 14:01:10 -0700684int av1_set_reference_enc(AV1_COMP *cpi, AOM_REFFRAME ref_frame_flag,
685 YV12_BUFFER_CONFIG *sd);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700686
Yaowu Xuf883b422016-08-30 14:01:10 -0700687int av1_update_entropy(AV1_COMP *cpi, int update);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700688
Yaowu Xuf883b422016-08-30 14:01:10 -0700689int av1_set_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700690
Yaowu Xuf883b422016-08-30 14:01:10 -0700691int av1_get_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700692
Yaowu Xuf883b422016-08-30 14:01:10 -0700693int av1_set_internal_size(AV1_COMP *cpi, AOM_SCALING horiz_mode,
694 AOM_SCALING vert_mode);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700695
Fergus Simpson0a30c882017-05-16 16:54:51 -0700696// Returns 1 if the assigned width or height was <= 0.
697int av1_set_size_literal(AV1_COMP *cpi, int width, int height);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700698
Yaowu Xuf883b422016-08-30 14:01:10 -0700699int av1_get_quantizer(struct AV1_COMP *cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700700
Yaowu Xuf883b422016-08-30 14:01:10 -0700701void av1_full_to_model_counts(av1_coeff_count_model *model_count,
702 av1_coeff_count *full_count);
703
704static INLINE int frame_is_kf_gf_arf(const AV1_COMP *cpi) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700705 return frame_is_intra_only(&cpi->common) || cpi->refresh_alt_ref_frame ||
706 (cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref);
707}
708
Yaowu Xuf883b422016-08-30 14:01:10 -0700709static INLINE int get_ref_frame_map_idx(const AV1_COMP *cpi,
Yaowu Xuc27fc142016-08-22 16:08:15 -0700710 MV_REFERENCE_FRAME ref_frame) {
711#if CONFIG_EXT_REFS
712 if (ref_frame >= LAST_FRAME && ref_frame <= LAST3_FRAME)
713 return cpi->lst_fb_idxes[ref_frame - 1];
714#else
715 if (ref_frame == LAST_FRAME) return cpi->lst_fb_idx;
716#endif // CONFIG_EXT_REFS
717 else if (ref_frame == GOLDEN_FRAME)
718 return cpi->gld_fb_idx;
719#if CONFIG_EXT_REFS
720 else if (ref_frame == BWDREF_FRAME)
721 return cpi->bwd_fb_idx;
722#endif // CONFIG_EXT_REFS
723 else
724 return cpi->alt_fb_idx;
725}
726
Urvang Joshi52648442016-10-13 17:27:51 -0700727static INLINE int get_ref_frame_buf_idx(const AV1_COMP *cpi,
Yaowu Xuc27fc142016-08-22 16:08:15 -0700728 MV_REFERENCE_FRAME ref_frame) {
Yaowu Xuf883b422016-08-30 14:01:10 -0700729 const AV1_COMMON *const cm = &cpi->common;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700730 const int map_idx = get_ref_frame_map_idx(cpi, ref_frame);
731 return (map_idx != INVALID_IDX) ? cm->ref_frame_map[map_idx] : INVALID_IDX;
732}
733
734static INLINE YV12_BUFFER_CONFIG *get_ref_frame_buffer(
Urvang Joshi52648442016-10-13 17:27:51 -0700735 const AV1_COMP *cpi, MV_REFERENCE_FRAME ref_frame) {
736 const AV1_COMMON *const cm = &cpi->common;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700737 const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
738 return buf_idx != INVALID_IDX ? &cm->buffer_pool->frame_bufs[buf_idx].buf
739 : NULL;
740}
741
742static INLINE const YV12_BUFFER_CONFIG *get_upsampled_ref(
Urvang Joshi52648442016-10-13 17:27:51 -0700743 const AV1_COMP *cpi, const MV_REFERENCE_FRAME ref_frame) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700744 // Use up-sampled reference frames.
745 const int buf_idx =
746 cpi->upsampled_ref_idx[get_ref_frame_map_idx(cpi, ref_frame)];
747 return &cpi->upsampled_ref_bufs[buf_idx].buf;
748}
749
Jingning Han3c4556c2017-05-19 11:27:17 -0700750#if CONFIG_EXT_REFS || CONFIG_TEMPMV_SIGNALING
Yaowu Xuf883b422016-08-30 14:01:10 -0700751static INLINE int enc_is_ref_frame_buf(AV1_COMP *cpi, RefCntBuffer *frame_buf) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700752 MV_REFERENCE_FRAME ref_frame;
Yaowu Xuf883b422016-08-30 14:01:10 -0700753 AV1_COMMON *const cm = &cpi->common;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700754 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
755 const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
756 if (buf_idx == INVALID_IDX) continue;
757 if (frame_buf == &cm->buffer_pool->frame_bufs[buf_idx]) break;
758 }
759 return (ref_frame <= ALTREF_FRAME);
760}
761#endif // CONFIG_EXT_REFS
762
763static INLINE unsigned int get_token_alloc(int mb_rows, int mb_cols) {
Jingning Han7f76d472016-07-29 10:48:34 -0700764 // We assume 3 planes all at full resolution. We assume up to 1 token per
765 // pixel, and then allow a head room of 1 EOSB token per 4x4 block per plane,
766 // plus EOSB_TOKEN per plane.
767 return mb_rows * mb_cols * (16 * 16 + 17) * 3;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700768}
769
770// Get the allocated token size for a tile. It does the same calculation as in
771// the frame token allocation.
772static INLINE unsigned int allocated_tokens(TileInfo tile) {
Jingning Haneafbd5f2017-03-07 11:18:17 -0800773#if CONFIG_CB4X4
774 int tile_mb_rows = (tile.mi_row_end - tile.mi_row_start + 2) >> 2;
775 int tile_mb_cols = (tile.mi_col_end - tile.mi_col_start + 2) >> 2;
776#else
Yaowu Xuc27fc142016-08-22 16:08:15 -0700777 int tile_mb_rows = (tile.mi_row_end - tile.mi_row_start + 1) >> 1;
778 int tile_mb_cols = (tile.mi_col_end - tile.mi_col_start + 1) >> 1;
Jingning Haneafbd5f2017-03-07 11:18:17 -0800779#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -0700780
781 return get_token_alloc(tile_mb_rows, tile_mb_cols);
782}
783
Yaowu Xuf883b422016-08-30 14:01:10 -0700784void av1_alloc_compressor_data(AV1_COMP *cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700785
Yaowu Xuf883b422016-08-30 14:01:10 -0700786void av1_scale_references(AV1_COMP *cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700787
Yaowu Xuf883b422016-08-30 14:01:10 -0700788void av1_update_reference_frames(AV1_COMP *cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700789
Yaowu Xuf883b422016-08-30 14:01:10 -0700790void av1_set_high_precision_mv(AV1_COMP *cpi, int allow_high_precision_mv);
Fangwen Fu8d164de2016-12-14 13:40:54 -0800791#if CONFIG_TEMPMV_SIGNALING
792void av1_set_temporal_mv_prediction(AV1_COMP *cpi, int allow_tempmv_prediction);
793#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -0700794
Yaowu Xuf883b422016-08-30 14:01:10 -0700795void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700796
Yaowu Xuf883b422016-08-30 14:01:10 -0700797static INLINE int is_altref_enabled(const AV1_COMP *const cpi) {
Thomas Daede80826142017-03-20 15:44:24 -0700798 return cpi->oxcf.lag_in_frames > 0 && cpi->oxcf.enable_auto_arf;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700799}
800
801// TODO(zoeliu): To set up cpi->oxcf.enable_auto_brf
802#if 0 && CONFIG_EXT_REFS
Yaowu Xuf883b422016-08-30 14:01:10 -0700803static INLINE int is_bwdref_enabled(const AV1_COMP *const cpi) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700804 // NOTE(zoeliu): The enabling of bi-predictive frames depends on the use of
805 // alt_ref, and now will be off when the alt_ref interval is
806 // not sufficiently large.
807 return is_altref_enabled(cpi) && cpi->oxcf.enable_auto_brf;
808}
809#endif // CONFIG_EXT_REFS
810
Urvang Joshi52648442016-10-13 17:27:51 -0700811static INLINE void set_ref_ptrs(const AV1_COMMON *cm, MACROBLOCKD *xd,
Yaowu Xuc27fc142016-08-22 16:08:15 -0700812 MV_REFERENCE_FRAME ref0,
813 MV_REFERENCE_FRAME ref1) {
814 xd->block_refs[0] =
815 &cm->frame_refs[ref0 >= LAST_FRAME ? ref0 - LAST_FRAME : 0];
816 xd->block_refs[1] =
817 &cm->frame_refs[ref1 >= LAST_FRAME ? ref1 - LAST_FRAME : 0];
818}
819
Yaowu Xu4ff59b52017-04-24 12:41:56 -0700820static INLINE int get_chessboard_index(int frame_index) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700821 return frame_index & 0x1;
822}
823
Yaowu Xuf883b422016-08-30 14:01:10 -0700824static INLINE int *cond_cost_list(const struct AV1_COMP *cpi, int *cost_list) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700825 return cpi->sf.mv.subpel_search_method != SUBPEL_TREE ? cost_list : NULL;
826}
827
Yaowu Xuf883b422016-08-30 14:01:10 -0700828void av1_new_framerate(AV1_COMP *cpi, double framerate);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700829
830#define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl))
831
832// Update up-sampled reference frame index.
833static INLINE void uref_cnt_fb(EncRefCntBuffer *ubufs, int *uidx,
834 int new_uidx) {
835 const int ref_index = *uidx;
836
837 if (ref_index >= 0 && ubufs[ref_index].ref_count > 0)
838 ubufs[ref_index].ref_count--;
839
840 *uidx = new_uidx;
841 ubufs[new_uidx].ref_count++;
842}
843
Fergus Simpsonfecb2ab2017-04-30 15:49:57 -0700844// Returns 1 if a frame is unscaled and 0 otherwise.
Fergus Simpsond2bcbb52017-05-22 23:15:05 -0700845static INLINE int av1_resize_unscaled(const AV1_COMMON *cm) {
846#if CONFIG_FRAME_SUPERRES
847 return cm->superres_upscaled_width == cm->render_width &&
848 cm->superres_upscaled_height == cm->render_height;
849#else
850 return cm->width == cm->render_width && cm->height == cm->render_height;
851#endif // CONFIG_FRAME_SUPERRES
Fergus Simpsonfecb2ab2017-04-30 15:49:57 -0700852}
853
Fergus Simpsond2bcbb52017-05-22 23:15:05 -0700854static INLINE int av1_frame_unscaled(const AV1_COMMON *cm) {
855#if CONFIG_FRAME_SUPERRES
856 return av1_superres_unscaled(cm) && av1_resize_unscaled(cm);
857#else
858 return av1_resize_unscaled(cm);
859#endif // CONFIG_FRAME_SUPERRES
Fergus Simpsonfecb2ab2017-04-30 15:49:57 -0700860}
861
Yaowu Xuc27fc142016-08-22 16:08:15 -0700862#ifdef __cplusplus
863} // extern "C"
864#endif
865
Yaowu Xuf883b422016-08-30 14:01:10 -0700866#endif // AV1_ENCODER_ENCODER_H_