blob: 0832494ee14f98bc34ff93cae2d20ac3da64fc28 [file] [log] [blame]
Yaowu Xuc27fc142016-08-22 16:08:15 -07001/*
James Zernb7c05bd2024-06-11 19:15:10 -07002 * Copyright (c) 2016, Alliance for Open Media. All rights reserved.
Yaowu Xuc27fc142016-08-22 16:08:15 -07003 *
Yaowu Xu2ab7ff02016-09-02 12:04:54 -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_FIRSTPASS_H_
13#define AOM_AV1_ENCODER_FIRSTPASS_H_
Yaowu Xuc27fc142016-08-22 16:08:15 -070014
Remya Prakasan54e4b8f2023-03-07 18:20:21 +053015#include <stdbool.h>
16
Wan-Teh Changf2d15ee2020-03-10 09:24:43 -070017#include "av1/common/av1_common_int.h"
Zoe Liu43486e72017-09-04 03:44:27 -070018#include "av1/common/enums.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070019#include "av1/encoder/lookahead.h"
20#include "av1/encoder/ratectrl.h"
21
22#ifdef __cplusplus
23extern "C" {
24#endif
25
David Turner0fa8c492019-02-06 16:38:13 +000026#define DOUBLE_DIVIDE_CHECK(x) ((x) < 0 ? (x)-0.000001 : (x) + 0.000001)
27
Di Chen53a04f62017-06-23 13:47:56 -070028#define MIN_ZERO_MOTION 0.95
29#define MAX_SR_CODED_ERROR 40
30#define MAX_RAW_ERR_VAR 2000
31#define MIN_MV_IN_OUT 0.4
Di Chen53a04f62017-06-23 13:47:56 -070032
Yaowu Xuc27fc142016-08-22 16:08:15 -070033#define VLOW_MOTION_THRESHOLD 950
Bohan Li15b3c6d2021-07-27 17:27:20 -070034struct ThreadData;
Yaowu Xuc27fc142016-08-22 16:08:15 -070035
Cheng Chena7fd6f12020-06-08 10:46:30 -070036/*!
37 * \brief The stucture of acummulated frame stats in the first pass.
Bohan Li063e4e52021-06-18 13:59:38 -070038 *
39 * Errors (coded_error, intra_error, etc.) and counters (new_mv_count) are
40 * normalized to each MB. MV related stats (MVc, MVr, etc.) are normalized to
41 * the frame width and height. See function normalize_firstpass_stats.
Cheng Chena7fd6f12020-06-08 10:46:30 -070042 */
Mark Wachsler7ace1182022-06-29 15:45:48 +000043typedef struct FIRSTPASS_STATS {
Cheng Chena7fd6f12020-06-08 10:46:30 -070044 /*!
45 * Frame number in display order, if stats are for a single frame.
46 * No real meaning for a collection of frames.
47 */
Yaowu Xuc27fc142016-08-22 16:08:15 -070048 double frame;
Cheng Chena7fd6f12020-06-08 10:46:30 -070049 /*!
50 * Weight assigned to this frame (or total weight for the collection of
51 * frames) currently based on intra factor and brightness factor. This is used
52 * to distribute bits betweeen easier and harder frames.
53 */
Yaowu Xuc27fc142016-08-22 16:08:15 -070054 double weight;
Cheng Chena7fd6f12020-06-08 10:46:30 -070055 /*!
56 * Intra prediction error.
57 */
Yaowu Xuc27fc142016-08-22 16:08:15 -070058 double intra_error;
Cheng Chena7fd6f12020-06-08 10:46:30 -070059 /*!
60 * Average wavelet energy computed using Discrete Wavelet Transform (DWT).
61 */
Yue Chen2dbdbc92018-05-24 09:54:01 -070062 double frame_avg_wavelet_energy;
Cheng Chena7fd6f12020-06-08 10:46:30 -070063 /*!
64 * Best of intra pred error and inter pred error using last frame as ref.
65 */
Yaowu Xuc27fc142016-08-22 16:08:15 -070066 double coded_error;
Cheng Chena7fd6f12020-06-08 10:46:30 -070067 /*!
68 * Best of intra pred error and inter pred error using golden frame as ref.
69 */
Yaowu Xuc27fc142016-08-22 16:08:15 -070070 double sr_coded_error;
Cheng Chena7fd6f12020-06-08 10:46:30 -070071 /*!
Cheng Chena7fd6f12020-06-08 10:46:30 -070072 * Percentage of blocks with inter pred error < intra pred error.
73 */
Yaowu Xuc27fc142016-08-22 16:08:15 -070074 double pcnt_inter;
Cheng Chena7fd6f12020-06-08 10:46:30 -070075 /*!
76 * Percentage of blocks using (inter prediction and) non-zero motion vectors.
77 */
Yaowu Xuc27fc142016-08-22 16:08:15 -070078 double pcnt_motion;
Cheng Chena7fd6f12020-06-08 10:46:30 -070079 /*!
80 * Percentage of blocks where golden frame was better than last or intra:
81 * inter pred error using golden frame < inter pred error using last frame and
82 * inter pred error using golden frame < intra pred error
83 */
Yaowu Xuc27fc142016-08-22 16:08:15 -070084 double pcnt_second_ref;
Cheng Chena7fd6f12020-06-08 10:46:30 -070085 /*!
Cheng Chena7fd6f12020-06-08 10:46:30 -070086 * Percentage of blocks where intra and inter prediction errors were very
87 * close. Note that this is a 'weighted count', that is, the so blocks may be
88 * weighted by how close the two errors were.
89 */
Yaowu Xuc27fc142016-08-22 16:08:15 -070090 double pcnt_neutral;
Cheng Chena7fd6f12020-06-08 10:46:30 -070091 /*!
92 * Percentage of blocks that have almost no intra error residual
93 * (i.e. are in effect completely flat and untextured in the intra
94 * domain). In natural videos this is uncommon, but it is much more
95 * common in animations, graphics and screen content, so may be used
96 * as a signal to detect these types of content.
97 */
Yaowu Xuc27fc142016-08-22 16:08:15 -070098 double intra_skip_pct;
Cheng Chena7fd6f12020-06-08 10:46:30 -070099 /*!
100 * Image mask rows top and bottom.
101 */
Urvang Joshi87a83942019-03-28 12:35:25 -0700102 double inactive_zone_rows;
Cheng Chena7fd6f12020-06-08 10:46:30 -0700103 /*!
104 * Image mask columns at left and right edges.
105 */
Urvang Joshi87a83942019-03-28 12:35:25 -0700106 double inactive_zone_cols;
Cheng Chena7fd6f12020-06-08 10:46:30 -0700107 /*!
108 * Average of row motion vectors.
109 */
Yaowu Xuc27fc142016-08-22 16:08:15 -0700110 double MVr;
Cheng Chena7fd6f12020-06-08 10:46:30 -0700111 /*!
112 * Mean of absolute value of row motion vectors.
113 */
Yaowu Xuc27fc142016-08-22 16:08:15 -0700114 double mvr_abs;
Cheng Chena7fd6f12020-06-08 10:46:30 -0700115 /*!
116 * Mean of column motion vectors.
117 */
Yaowu Xuc27fc142016-08-22 16:08:15 -0700118 double MVc;
Cheng Chena7fd6f12020-06-08 10:46:30 -0700119 /*!
120 * Mean of absolute value of column motion vectors.
121 */
Yaowu Xuc27fc142016-08-22 16:08:15 -0700122 double mvc_abs;
Cheng Chena7fd6f12020-06-08 10:46:30 -0700123 /*!
124 * Variance of row motion vectors.
125 */
Yaowu Xuc27fc142016-08-22 16:08:15 -0700126 double MVrv;
Cheng Chena7fd6f12020-06-08 10:46:30 -0700127 /*!
128 * Variance of column motion vectors.
129 */
Yaowu Xuc27fc142016-08-22 16:08:15 -0700130 double MVcv;
Cheng Chena7fd6f12020-06-08 10:46:30 -0700131 /*!
132 * Value in range [-1,1] indicating fraction of row and column motion vectors
133 * that point inwards (negative MV value) or outwards (positive MV value).
134 * For example, value of 1 indicates, all row/column MVs are inwards.
135 */
Yaowu Xuc27fc142016-08-22 16:08:15 -0700136 double mv_in_out_count;
Cheng Chena7fd6f12020-06-08 10:46:30 -0700137 /*!
138 * Count of unique non-zero motion vectors.
139 */
Yaowu Xuc27fc142016-08-22 16:08:15 -0700140 double new_mv_count;
Cheng Chena7fd6f12020-06-08 10:46:30 -0700141 /*!
142 * Duration of the frame / collection of frames.
143 */
Yaowu Xuc27fc142016-08-22 16:08:15 -0700144 double duration;
Cheng Chena7fd6f12020-06-08 10:46:30 -0700145 /*!
146 * 1.0 if stats are for a single frame, OR
147 * Number of frames in this collection for which the stats are accumulated.
148 */
Yaowu Xuc27fc142016-08-22 16:08:15 -0700149 double count;
Cheng Chena7fd6f12020-06-08 10:46:30 -0700150 /*!
151 * standard deviation for (0, 0) motion prediction error
152 */
Di Chen53a04f62017-06-23 13:47:56 -0700153 double raw_error_stdev;
Bohan Lidc1c16c2021-04-07 13:29:00 -0700154 /*!
155 * Whether the frame contains a flash
156 */
157 int64_t is_flash;
158 /*!
159 * Estimated noise variance
160 */
161 double noise_var;
162 /*!
163 * Correlation coefficient with the previous frame
164 */
165 double cor_coeff;
Lin Zheng2060c142023-02-18 00:32:23 +0000166 /*!
167 * log of intra_error
168 */
169 double log_intra_error;
170 /*!
171 * log of coded_error
172 */
173 double log_coded_error;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700174} FIRSTPASS_STATS;
175
Angie Chiangd8cfe162021-07-30 17:48:54 -0700176// We want to keep one past stats for key frame detection
177// in test_candidate_kf()
178#define FIRSTPASS_INFO_STATS_PAST_MIN 1
179
180// The size of static buffer used in FIRSTPASS_INFO.
181#define FIRSTPASS_INFO_STATIC_BUF_SIZE \
182 (MAX_LAP_BUFFERS + FIRSTPASS_INFO_STATS_PAST_MIN)
183
184/*!
185 * \brief Data structure used for managing first pass stats
186 */
Angie Chiangc798da52021-07-22 18:07:06 -0700187typedef struct {
188 /*!
Bohan Li3adb660d2021-08-24 17:59:14 -0700189 * A static buffer that will be used when no ext_stats_buf is assigned. The
190 * ext_stats_buf is assigned through av1_firstpass_info_init() when the user
191 * already has a pre-existing firstpass stats that is stored in an external
192 * buffer. The ext_stats_buf is usually used in two pass mode. When using one
193 * pass mode, we generate "firstpass" stats and encode the video in the same
194 * pass. In this scenario, the stats will be pushed and popped from
195 * static_stats_buf.
Angie Chiangc798da52021-07-22 18:07:06 -0700196 */
Angie Chiangd8cfe162021-07-30 17:48:54 -0700197 FIRSTPASS_STATS static_stats_buf[FIRSTPASS_INFO_STATIC_BUF_SIZE];
Angie Chiangc798da52021-07-22 18:07:06 -0700198 /*!
Bohan Li3adb660d2021-08-24 17:59:14 -0700199 * A pointer to first pass stats.
Angie Chiangc798da52021-07-22 18:07:06 -0700200 * Note that this buffer will be used as ring buffer.
201 */
202 FIRSTPASS_STATS *stats_buf;
203 /*!
204 * size of stats_buf
205 */
206 int stats_buf_size;
207 /*!
Angie Chiangd8cfe162021-07-30 17:48:54 -0700208 * start index of the available frame stats
209 * Note that start_index doesn't always point to
210 * current frame's stats because we need to
211 * keep past stats as well. To access current
212 * frame's stats, please use cur_index.
Angie Chiangc798da52021-07-22 18:07:06 -0700213 */
214 int start_index;
Angie Chiangd8cfe162021-07-30 17:48:54 -0700215
Angie Chiangc798da52021-07-22 18:07:06 -0700216 /*!
217 * count available stats stored in stats_buf
Angie Chiangd8cfe162021-07-30 17:48:54 -0700218 * the following condition should stay true
219 * stats_count = future_stats_count + past_stats_count
Angie Chiangc798da52021-07-22 18:07:06 -0700220 */
221 int stats_count;
Angie Chiangd1b83012021-07-25 17:53:26 -0700222
223 /*!
Angie Chiangd8cfe162021-07-30 17:48:54 -0700224 * index of the current frame's stats
225 */
226 int cur_index;
227
228 /*!
229 * count available future stats including current stats
230 */
231 int future_stats_count;
232
233 /*!
234 * count available past stats EXCLUDING current stats
235 */
236 int past_stats_count;
237
238 /*!
Angie Chiangd1b83012021-07-25 17:53:26 -0700239 * Accumulation of the stats being pushed into firstpass_info
240 */
241 FIRSTPASS_STATS total_stats;
Angie Chiangc798da52021-07-22 18:07:06 -0700242} FIRSTPASS_INFO;
243
244/*!\brief Init firstpass_info
245 *
246 * If using ext_stats_buf, the buffer needs to stay available during encoding
247 * process.
248 *
249 * \ingroup rate_control
250 * \param[out] firstpass_info struct of firstpass_info.
251 * \param[in] ext_stats_buf external stats buffer. Pass in NULL if
252 * choose to use internal static_stats_buf.
253 * \param[in] ext_stats_buf_size external stats buffer size. Pass in 0 if
254 * choose to use internal static_stats_buf. \return status
255 */
256aom_codec_err_t av1_firstpass_info_init(FIRSTPASS_INFO *firstpass_info,
257 FIRSTPASS_STATS *ext_stats_buf,
258 int ext_stats_buf_size);
259
Angie Chiangd8cfe162021-07-30 17:48:54 -0700260/*!\brief Move cur_index by 1
261 *
262 * \ingroup rate_control
263 * \param[out] firstpass_info struct of firstpass_info.
264 * \return status
265 */
266aom_codec_err_t av1_firstpass_info_move_cur_index(
267 FIRSTPASS_INFO *firstpass_info);
268
Angie Chiangc798da52021-07-22 18:07:06 -0700269/*!\brief Pop a stats from firstpass_info
270 *
271 * \ingroup rate_control
272 * \param[out] firstpass_info struct of firstpass_info.
Angie Chiangc798da52021-07-22 18:07:06 -0700273 * \return status
274 */
Angie Chiangd8cfe162021-07-30 17:48:54 -0700275aom_codec_err_t av1_firstpass_info_pop(FIRSTPASS_INFO *firstpass_info);
276
277/*!\brief Move cur_index by 1 and pop a stats from firstpass_info
278 *
279 * \ingroup rate_control
280 * \param[out] firstpass_info struct of firstpass_info.
281 * \return status
282 */
283aom_codec_err_t av1_firstpass_info_move_cur_index_and_pop(
284 FIRSTPASS_INFO *firstpass_info);
Angie Chiangc798da52021-07-22 18:07:06 -0700285
Angie Chiangd1b83012021-07-25 17:53:26 -0700286/*!\brief Push a stats into firstpass_info
Angie Chiangc798da52021-07-22 18:07:06 -0700287 *
Angie Chiangd1b83012021-07-25 17:53:26 -0700288 * Note that the input stats will be copied into firstpass_info.
Angie Chiangc798da52021-07-22 18:07:06 -0700289 * \ingroup rate_control
Angie Chiangd1b83012021-07-25 17:53:26 -0700290 * \param[out] firstpass_info struct of firstpass_info.
291 * \param[in] input_stats input stats
Angie Chiangc798da52021-07-22 18:07:06 -0700292 * \return status
293 */
294aom_codec_err_t av1_firstpass_info_push(FIRSTPASS_INFO *firstpass_info,
295 const FIRSTPASS_STATS *input_stats);
296
Angie Chiangd1b83012021-07-25 17:53:26 -0700297/*!\brief Peek at a stats from firstpass_info
Angie Chiangc798da52021-07-22 18:07:06 -0700298 *
Angie Chiangd8cfe162021-07-30 17:48:54 -0700299 * The target index is as follows.
300 * (cur_index + offset_from_cur) % firstpass_info->stats_buf_size
301 *
Angie Chiangc798da52021-07-22 18:07:06 -0700302 * \ingroup rate_control
303 * \param[in] firstpass_info struct of firstpass_info.
Angie Chiangd8cfe162021-07-30 17:48:54 -0700304 * \param[in] offset_from_cur index offset from cur_index.
Angie Chiangd1b83012021-07-25 17:53:26 -0700305 * \return pointer to the stats. The pointer will be NULL if
306 * stats_index_offset is invalid.
Angie Chiangc798da52021-07-22 18:07:06 -0700307 */
Angie Chiangd1b83012021-07-25 17:53:26 -0700308const FIRSTPASS_STATS *av1_firstpass_info_peek(
Angie Chiangd8cfe162021-07-30 17:48:54 -0700309 const FIRSTPASS_INFO *firstpass_info, int offset_from_cur);
Cheng Chena7fd6f12020-06-08 10:46:30 -0700310
Angie Chiangd8cfe162021-07-30 17:48:54 -0700311/*!\brief Count the future stats from the target in firstpass_info
312 * Note that the target stats will be counted as well.
313 * The target index is as follows.
Angie Chiangb3cb8952021-08-05 12:00:41 -0700314 * (cur_index + offset_from_cur) % firstpass_info->stats_buf_size
Angie Chiangd8cfe162021-07-30 17:48:54 -0700315 *
316 * \ingroup rate_control
317 * \param[in] firstpass_info struct of firstpass_info.
318 * \param[in] offset_from_cur target stats's inffset
319 * from cur_index.
320 * \return Number of stats in the future after the target stats
321 * including itself.
322 */
323int av1_firstpass_info_future_count(const FIRSTPASS_INFO *firstpass_info,
324 int offset_from_cur);
325
326/*!\brief Count the past stats before the target in firstpass_info
327 * Note that the target stats will NOT be counted.
328 * The target index is as follows.
329 * (cur_index + offset_from_cur) % firstpass_info->stats_buf_size
330 *
331 * \ingroup rate_control
332 * \param[in] firstpass_info struct of firstpass_info.
333 * \param[in] offset_from_cur target stats's index offset
334 * from cur_index.
335 * \return Number of stats in the past before the target stats
336 * excluding itself.
337 */
338int av1_firstpass_info_past_count(const FIRSTPASS_INFO *firstpass_info,
339 int offset_from_cur);
340
341/*!\cond */
Yaowu Xuc27fc142016-08-22 16:08:15 -0700342#define FC_ANIMATION_THRESH 0.15
Satish Kumar Suman4667aa12018-12-14 18:28:19 +0530343enum {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700344 FC_NORMAL = 0,
345 FC_GRAPHICS_ANIMATION = 1,
346 FRAME_CONTENT_TYPES = 2
Satish Kumar Suman4667aa12018-12-14 18:28:19 +0530347} UENUM1BYTE(FRAME_CONTENT_TYPE);
Paul Wilkinse8c76eb2020-06-30 17:24:11 +0100348/*!\endcond */
Angie Chiangd8cfe162021-07-30 17:48:54 -0700349
Paul Wilkinse8c76eb2020-06-30 17:24:11 +0100350/*!
Wan-Teh Chang247dd542020-10-08 12:37:47 -0700351 * \brief Data related to the current GF/ARF group and the
Paul Wilkinse8c76eb2020-06-30 17:24:11 +0100352 * individual frames within the group
353 */
Kavi Ramamurthy291ef252021-06-09 17:07:30 +0000354typedef struct GF_GROUP {
Paul Wilkinse8c76eb2020-06-30 17:24:11 +0100355 /*!\cond */
Wan-Teh Chang1287d352020-10-08 09:40:17 -0700356 // Frame update type, e.g. ARF/GF/LF/Overlay
Urvang Joshi2e4aaf22019-05-08 11:38:00 -0700357 FRAME_UPDATE_TYPE update_type[MAX_STATIC_GF_GROUP_LENGTH];
358 unsigned char arf_src_offset[MAX_STATIC_GF_GROUP_LENGTH];
Jingning Han9b8051e2020-02-24 22:06:52 -0800359 // The number of frames displayed so far within the GOP at a given coding
360 // frame.
361 unsigned char cur_frame_idx[MAX_STATIC_GF_GROUP_LENGTH];
Jingning Han7a202352019-07-02 14:40:53 -0700362 int layer_depth[MAX_STATIC_GF_GROUP_LENGTH];
Jingning Han3f9c45d2019-07-26 10:38:38 -0700363 int arf_boost[MAX_STATIC_GF_GROUP_LENGTH];
Jingning Han237d46f2019-08-16 13:22:09 -0700364 int max_layer_depth;
365 int max_layer_depth_allowed;
Sarah Parkerfce50142019-06-03 16:52:07 -0700366 // This is currently only populated for AOM_Q mode
Angie Chiangbb201602021-07-13 18:50:15 -0700367 int q_val[MAX_STATIC_GF_GROUP_LENGTH];
Jingning Hanad725382022-11-29 09:50:35 -0800368 int rdmult_val[MAX_STATIC_GF_GROUP_LENGTH];
Urvang Joshi2e4aaf22019-05-08 11:38:00 -0700369 int bit_allocation[MAX_STATIC_GF_GROUP_LENGTH];
Wan-Teh Chang1287d352020-10-08 09:40:17 -0700370 // The frame coding type - inter/intra frame
Jingning Hanf8420392020-08-20 14:42:08 -0700371 FRAME_TYPE frame_type[MAX_STATIC_GF_GROUP_LENGTH];
Wan-Teh Chang1287d352020-10-08 09:40:17 -0700372 // The reference frame buffer control - update or reset
Jingning Hanf8420392020-08-20 14:42:08 -0700373 REFBUF_STATE refbuf_state[MAX_STATIC_GF_GROUP_LENGTH];
bohanli1629a4b2020-06-11 16:15:14 -0700374 int arf_index; // the index in the gf group of ARF, if no arf, then -1
Wan-Teh Chang1287d352020-10-08 09:40:17 -0700375 int size; // The total length of a GOP
Jingning Han4c9d3dd2022-08-05 22:11:57 -0700376
377 // The offset into lookahead_ctx for choosing
378 // source of frame parallel encodes.
379 int src_offset[MAX_STATIC_GF_GROUP_LENGTH];
380 // Stores the display order hint of each frame in the current GF_GROUP.
381 int display_idx[MAX_STATIC_GF_GROUP_LENGTH];
382
Jingning Han154ee2c2022-08-07 17:22:47 -0700383 // The reference frame list maps the reference frame indexes to its
384 // buffer index in the decoded buffer. A value of -1 means the
385 // corresponding reference frame index doesn't point towards any
386 // previously decoded frame.
Jingning Han4c9d3dd2022-08-05 22:11:57 -0700387 int8_t ref_frame_list[MAX_STATIC_GF_GROUP_LENGTH][REF_FRAMES];
Jingning Han154ee2c2022-08-07 17:22:47 -0700388 // Update frame index
389 int update_ref_idx[MAX_STATIC_GF_GROUP_LENGTH];
Jingning Han77890092022-08-09 12:07:14 -0700390 // The map_idx of primary reference
391 int primary_ref_idx[MAX_STATIC_GF_GROUP_LENGTH];
Jingning Han4c9d3dd2022-08-05 22:11:57 -0700392
Remya Prakasan9f54e5c2021-04-21 15:27:34 +0530393 // Indicates the level of parallelism in frame parallel encodes.
394 // 0 : frame is independently encoded (not part of parallel encodes).
395 // 1 : frame is the first in encode order in a given parallel encode set.
396 // 2 : frame occurs later in encode order in a given parallel encode set.
397 int frame_parallel_level[MAX_STATIC_GF_GROUP_LENGTH];
398 // Indicates whether a frame should act as non-reference frame.
Remya Prakasan16f38c02023-03-14 16:06:50 +0530399 bool is_frame_non_ref[MAX_STATIC_GF_GROUP_LENGTH];
Remya Prakasan54e4b8f2023-03-07 18:20:21 +0530400 // Indicates whether a frame is dropped.
401 bool is_frame_dropped[MAX_STATIC_GF_GROUP_LENGTH];
Mufaddal Chakera97f92712021-05-21 15:10:33 +0530402
Remya Prakasana05ccde2021-06-07 21:24:11 +0530403 // Stores the display order hint of the frames not to be
404 // refreshed by the current frame.
405 int skip_frame_refresh[MAX_STATIC_GF_GROUP_LENGTH][REF_FRAMES];
Remya Prakasanfa7262a2021-05-29 16:00:30 +0530406 // Stores the display order hint of the frame to be excluded during reference
407 // assignment.
408 int skip_frame_as_ref[MAX_STATIC_GF_GROUP_LENGTH];
Paul Wilkinse8c76eb2020-06-30 17:24:11 +0100409 /*!\endcond */
Yaowu Xuc27fc142016-08-22 16:08:15 -0700410} GF_GROUP;
Paul Wilkinse8c76eb2020-06-30 17:24:11 +0100411/*!\cond */
Yaowu Xuc27fc142016-08-22 16:08:15 -0700412
413typedef struct {
Jingning Han9af02fa2020-08-20 23:01:01 -0700414 // Track if the last frame in a GOP has higher quality.
415 int arf_gf_boost_lst;
416} GF_STATE;
417
418typedef struct {
Akshata Jadhava49be172019-12-18 00:03:53 +0530419 FIRSTPASS_STATS *stats_in_start;
420 FIRSTPASS_STATS *stats_in_end;
421 FIRSTPASS_STATS *stats_in_buf_end;
Aasaipriyaeb417c12020-04-07 12:08:24 +0530422 FIRSTPASS_STATS *total_stats;
423 FIRSTPASS_STATS *total_left_stats;
Akshata Jadhava49be172019-12-18 00:03:53 +0530424} STATS_BUFFER_CTX;
425
Paul Wilkins83cfad42020-06-26 12:38:07 +0100426/*!\endcond */
427
428/*!
429 * \brief Two pass status and control data.
430 */
Akshata Jadhava49be172019-12-18 00:03:53 +0530431typedef struct {
Paul Wilkins83cfad42020-06-26 12:38:07 +0100432 /*!\cond */
Yaowu Xuc27fc142016-08-22 16:08:15 -0700433 unsigned int section_intra_rating;
Urvang Joshi38b7e842019-05-01 11:27:47 -0700434 // Circular queue of first pass stats stored for most recent frames.
435 // cpi->output_pkt_list[i].data.twopass_stats.buf points to actual data stored
436 // here.
Akshata Jadhav4be65112019-12-18 00:26:25 +0530437 FIRSTPASS_STATS *frame_stats_arr[MAX_LAP_BUFFERS + 1];
Urvang Joshi38b7e842019-05-01 11:27:47 -0700438 int frame_stats_next_idx; // Index to next unused element in frame_stats_arr.
Akshata Jadhava49be172019-12-18 00:03:53 +0530439 STATS_BUFFER_CTX *stats_buf_ctx;
Angie Chiangd1b83012021-07-25 17:53:26 -0700440 FIRSTPASS_INFO firstpass_info; // This is the first pass data structure
441 // intended to replace stats_in
Yaowu Xuc27fc142016-08-22 16:08:15 -0700442 int first_pass_done;
443 int64_t bits_left;
Debargha Mukherjeed0b9bf72018-05-14 17:45:27 +0000444 double modified_error_min;
445 double modified_error_max;
446 double modified_error_left;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700447
448 // Projected total bits available for a key frame group of frames
449 int64_t kf_group_bits;
450
451 // Error score of frames still to be coded in kf group
Bohan Li063e4e52021-06-18 13:59:38 -0700452 double kf_group_error_left;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700453
Paul Wilkins88fdf642019-07-31 12:29:48 +0100454 // Over time correction for bits per macro block estimation
455 double bpm_factor;
456
457 // Record of target and actual bits spent in current ARF group
458 int rolling_arf_group_target_bits;
459 int rolling_arf_group_actual_bits;
460
Yaowu Xuc27fc142016-08-22 16:08:15 -0700461 int sr_update_lag;
462
463 int kf_zeromotion_pct;
464 int last_kfgroup_zeromotion_pct;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700465 int extend_minq;
466 int extend_maxq;
Paul Wilkins83cfad42020-06-26 12:38:07 +0100467 /*!\endcond */
Yaowu Xuc27fc142016-08-22 16:08:15 -0700468} TWO_PASS;
469
Mufaddal Chakera55ea39b2021-07-07 15:25:37 +0530470/*!
471 * \brief Frame level Two pass status and control data.
472 */
473typedef struct {
474 /*!\cond */
475 const FIRSTPASS_STATS *stats_in;
Remya Prakasanf54c2b92021-07-21 15:40:07 +0530476 // Pointer to the stats of the current frame.
477 const FIRSTPASS_STATS *this_frame;
Mufaddal Chakera55ea39b2021-07-07 15:25:37 +0530478 double mb_av_energy;
479 // An indication of the content type of the current frame
480 FRAME_CONTENT_TYPE fr_content_type;
481 double frame_avg_haar_energy;
482 /*!\endcond */
483} TWO_PASS_FRAME;
484
Paul Wilkins83cfad42020-06-26 12:38:07 +0100485/*!\cond */
486
Mufaddal Chakera6c3b6de2020-04-29 12:27:42 +0530487// This structure contains several key parameters to be accumulated for this
488// frame.
489typedef struct {
490 // Intra prediction error.
491 int64_t intra_error;
492 // Average wavelet energy computed using Discrete Wavelet Transform (DWT).
493 int64_t frame_avg_wavelet_energy;
494 // Best of intra pred error and inter pred error using last frame as ref.
495 int64_t coded_error;
496 // Best of intra pred error and inter pred error using golden frame as ref.
497 int64_t sr_coded_error;
Mufaddal Chakera6c3b6de2020-04-29 12:27:42 +0530498 // Count of motion vector.
499 int mv_count;
500 // Count of blocks that pick inter prediction (inter pred error is smaller
501 // than intra pred error).
502 int inter_count;
503 // Count of blocks that pick second ref (golden frame).
504 int second_ref_count;
Mufaddal Chakera6c3b6de2020-04-29 12:27:42 +0530505 // Count of blocks where the inter and intra are very close and very low.
506 double neutral_count;
507 // Count of blocks where intra error is very small.
508 int intra_skip_count;
509 // Start row.
510 int image_data_start_row;
511 // Count of unique non-zero motion vectors.
512 int new_mv_count;
513 // Sum of inward motion vectors.
514 int sum_in_vectors;
515 // Sum of motion vector row.
516 int sum_mvr;
517 // Sum of motion vector column.
518 int sum_mvc;
519 // Sum of absolute value of motion vector row.
520 int sum_mvr_abs;
521 // Sum of absolute value of motion vector column.
522 int sum_mvc_abs;
523 // Sum of the square of motion vector row.
524 int64_t sum_mvrs;
525 // Sum of the square of motion vector column.
526 int64_t sum_mvcs;
527 // A factor calculated using intra pred error.
528 double intra_factor;
529 // A factor that measures brightness.
530 double brightness_factor;
531} FRAME_STATS;
532
533// This structure contains first pass data.
534typedef struct {
535 // Buffer holding frame stats for all MACROBLOCKs.
536 // mb_stats[i] stores the FRAME_STATS of the ith
537 // MB in raster scan order.
538 FRAME_STATS *mb_stats;
539 // Buffer to store the prediction error of the (0,0) motion
540 // vector using the last source frame as the reference.
541 // raw_motion_err_list[i] stores the raw_motion_err of
542 // the ith MB in raster scan order.
543 int *raw_motion_err_list;
544} FirstPassData;
545
Yaowu Xuf883b422016-08-30 14:01:10 -0700546struct AV1_COMP;
David Turner475a3132019-01-18 15:17:17 +0000547struct EncodeFrameParams;
David Turner0fa8c492019-02-06 16:38:13 +0000548struct AV1EncoderConfig;
Mufaddal Chakeraa7ff4332020-04-28 15:10:49 +0530549struct TileDataEnc;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700550
Wan-Teh Chang12c64e82024-08-08 16:02:19 -0700551static inline int is_fp_wavelet_energy_invalid(
Mudassir Galagnath32e54162021-07-09 10:32:33 +0530552 const FIRSTPASS_STATS *fp_stats) {
Mufaddal Chakera55ea39b2021-07-07 15:25:37 +0530553 assert(fp_stats != NULL);
Mudassir Galagnath32e54162021-07-09 10:32:33 +0530554 return (fp_stats->frame_avg_wavelet_energy < 0);
555}
556
Wan-Teh Chang12c64e82024-08-08 16:02:19 -0700557static inline BLOCK_SIZE get_fp_block_size(int is_screen_content_type) {
Deepa K Gc29630a2021-05-31 13:19:41 +0530558 return (is_screen_content_type ? BLOCK_8X8 : BLOCK_16X16);
559}
560
Wan-Teh Chang5350a5e2022-01-29 11:50:17 -0800561int av1_get_unit_rows_in_tile(const TileInfo *tile,
562 const BLOCK_SIZE fp_block_size);
563int av1_get_unit_cols_in_tile(const TileInfo *tile,
564 const BLOCK_SIZE fp_block_size);
Mufaddal Chakera65b69102020-05-01 04:07:13 +0530565
Mufaddal Chakeraa7ff4332020-04-28 15:10:49 +0530566void av1_first_pass_row(struct AV1_COMP *cpi, struct ThreadData *td,
Cheng Chenfd2c0cf2020-11-30 16:28:37 -0800567 struct TileDataEnc *tile_data, const int mb_row,
568 const BLOCK_SIZE fp_block_size);
Yaowu Xuf883b422016-08-30 14:01:10 -0700569void av1_end_first_pass(struct AV1_COMP *cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700570
Remya Prakasan0badba32023-08-17 16:44:52 +0530571void av1_free_firstpass_data(FirstPassData *firstpass_data);
572
David Turner0fa8c492019-02-06 16:38:13 +0000573void av1_twopass_zero_stats(FIRSTPASS_STATS *section);
Aasaipriya240671e2020-04-16 16:50:21 +0530574void av1_accumulate_stats(FIRSTPASS_STATS *section,
575 const FIRSTPASS_STATS *frame);
Cheng Chen7c26f2e2020-05-20 16:25:21 -0700576/*!\endcond */
577
578/*!\brief AV1 first pass encoding.
579 *
580 * \ingroup rate_control
581 * This function is the first encoding pass for the two pass encoding mode.
582 * It encodes the whole video and collect essential information.
583 * Two pass encoding is an encoding mode in the reference software (libaom)
584 * of AV1 for high performance encoding. The first pass is a fast encoding
585 * process to collect essential information to help the second pass make
586 * encoding decisions and improve coding quality. The collected stats is used
587 * in rate control, for example, to determine frame cut, the position of
588 * alternative reference frame (ARF), etc.
589 *
590 * \param[in] cpi Top-level encoder structure
591 * \param[in] ts_duration Duration of the frame / collection of frames
592 *
Wan-Teh Chang0defff82022-08-23 14:17:01 -0700593 * \remark Nothing is returned. Instead, the "TWO_PASS" structure inside "cpi"
Cheng Chen7c26f2e2020-05-20 16:25:21 -0700594 * is modified to store information computed in this function.
595 */
596void av1_first_pass(struct AV1_COMP *cpi, const int64_t ts_duration);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700597
Jingning Han7697d282022-01-19 11:42:38 -0800598void av1_noop_first_pass_frame(struct AV1_COMP *cpi, const int64_t ts_duration);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700599#ifdef __cplusplus
600} // extern "C"
601#endif
602
James Zerne1cbb132018-08-22 14:10:36 -0700603#endif // AOM_AV1_ENCODER_FIRSTPASS_H_