Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1 | /* |
Yaowu Xu | 2ab7ff0 | 2016-09-02 12:04:54 -0700 | [diff] [blame] | 2 | * Copyright (c) 2016, Alliance for Open Media. All rights reserved |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3 | * |
Yaowu Xu | 2ab7ff0 | 2016-09-02 12:04:54 -0700 | [diff] [blame] | 4 | * This source code is subject to the terms of the BSD 2 Clause License and |
| 5 | * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License |
| 6 | * was not distributed with this source code in the LICENSE file, you can |
| 7 | * obtain it at www.aomedia.org/license/software. If the Alliance for Open |
| 8 | * Media Patent License 1.0 was not distributed with this source code in the |
| 9 | * PATENTS file, you can obtain it at www.aomedia.org/license/patent. |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 10 | */ |
| 11 | |
James Zern | e1cbb13 | 2018-08-22 14:10:36 -0700 | [diff] [blame] | 12 | #ifndef AOM_AV1_ENCODER_RATECTRL_H_ |
| 13 | #define AOM_AV1_ENCODER_RATECTRL_H_ |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 14 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 15 | #include "aom/aom_codec.h" |
| 16 | #include "aom/aom_integer.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 17 | |
David Turner | 4f1f181 | 2019-01-24 17:00:24 +0000 | [diff] [blame] | 18 | #include "aom_ports/mem.h" |
| 19 | |
Wan-Teh Chang | f2d15ee | 2020-03-10 09:24:43 -0700 | [diff] [blame] | 20 | #include "av1/common/av1_common_int.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 21 | #include "av1/common/blockd.h" |
| 22 | |
| 23 | #ifdef __cplusplus |
| 24 | extern "C" { |
| 25 | #endif |
| 26 | |
Urvang Joshi | fee52c6 | 2020-06-17 13:45:55 -0700 | [diff] [blame] | 27 | /*!\cond */ |
| 28 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 29 | // Bits Per MB at different Q (Multiplied by 512) |
| 30 | #define BPER_MB_NORMBITS 9 |
| 31 | |
Sarah Parker | 97803fc | 2019-05-17 14:15:37 -0700 | [diff] [blame] | 32 | // Use this macro to turn on/off use of alt-refs in one-pass mode. |
| 33 | #define USE_ALTREF_FOR_ONE_PASS 1 |
| 34 | |
Urvang Joshi | c6d7e2d | 2018-11-06 15:52:42 -0800 | [diff] [blame] | 35 | // Threshold used to define if a KF group is static (e.g. a slide show). |
| 36 | // Essentially, this means that no frame in the group has more than 1% of MBs |
| 37 | // that are not marked as coded with 0,0 motion in the first pass. |
| 38 | #define STATIC_KF_GROUP_THRESH 99 |
| 39 | #define STATIC_KF_GROUP_FLOAT_THRESH 0.99 |
| 40 | |
| 41 | // The maximum duration of a GF group that is static (e.g. a slide show). |
| 42 | #define MAX_STATIC_GF_GROUP_LENGTH 250 |
| 43 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 44 | #define MIN_GF_INTERVAL 4 |
Jingning Han | b5c134c | 2020-02-07 09:27:21 -0800 | [diff] [blame] | 45 | #define MAX_GF_INTERVAL 32 |
Jingning Han | aa1d8fc | 2020-10-01 14:41:12 -0700 | [diff] [blame] | 46 | #define FIXED_GF_INTERVAL 16 |
Aasaipriya | d1ef460 | 2020-03-16 20:13:35 +0530 | [diff] [blame] | 47 | #define MAX_GF_LENGTH_LAP 16 |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 48 | |
Yunqing Wang | 415abbd | 2021-10-06 20:17:26 -0700 | [diff] [blame] | 49 | #define FIXED_GF_INTERVAL_RT 80 |
| 50 | #define MAX_GF_INTERVAL_RT 160 |
| 51 | |
bohanli | e151534 | 2020-02-25 11:58:11 -0800 | [diff] [blame] | 52 | #define MAX_NUM_GF_INTERVALS 15 |
bohanli | a964eea | 2020-02-13 11:48:00 -0800 | [diff] [blame] | 53 | |
Paul Wilkins | 4742616 | 2020-03-02 17:46:07 +0000 | [diff] [blame] | 54 | #define MAX_ARF_LAYERS 6 |
| 55 | // #define STRICT_RC |
| 56 | |
Jerome Jiang | da133ca | 2021-11-15 07:50:10 -0800 | [diff] [blame] | 57 | #define DEFAULT_KF_BOOST_RT 2300 |
| 58 | #define DEFAULT_GF_BOOST_RT 2000 |
| 59 | |
Cheng Chen | 3e35375 | 2022-04-01 16:36:37 -0700 | [diff] [blame] | 60 | // A passive rate control strategy for screen content type in real-time mode. |
| 61 | // When it is turned on, the compression performance is improved by |
| 62 | // 7.8% (overall_psnr), 5.0% (VMAF) on average. Some clips see gains |
| 63 | // over 20% on metric. |
| 64 | // The downside is that it does not guarantee frame size. |
| 65 | // Since RT mode has a tight restriction on buffer overflow control, we |
| 66 | // turn it off by default. |
| 67 | #define RT_PASSIVE_STRATEGY 0 |
| 68 | #define MAX_Q_HISTORY 1000 |
| 69 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 70 | typedef struct { |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 71 | int resize_width; |
| 72 | int resize_height; |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 73 | uint8_t superres_denom; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 74 | } size_params_type; |
| 75 | |
Urvang Joshi | 7a89023 | 2019-03-22 17:00:31 -0700 | [diff] [blame] | 76 | enum { |
Jingning Han | bf23719 | 2019-12-15 15:21:31 +0000 | [diff] [blame] | 77 | INTER_NORMAL, |
| 78 | GF_ARF_LOW, |
| 79 | GF_ARF_STD, |
| 80 | KF_STD, |
Urvang Joshi | 7a89023 | 2019-03-22 17:00:31 -0700 | [diff] [blame] | 81 | RATE_FACTOR_LEVELS |
| 82 | } UENUM1BYTE(RATE_FACTOR_LEVEL); |
| 83 | |
Marco Paniconi | cea99e2 | 2019-07-16 18:36:31 -0700 | [diff] [blame] | 84 | enum { |
| 85 | KF_UPDATE, |
| 86 | LF_UPDATE, |
| 87 | GF_UPDATE, |
| 88 | ARF_UPDATE, |
| 89 | OVERLAY_UPDATE, |
| 90 | INTNL_OVERLAY_UPDATE, // Internal Overlay Frame |
| 91 | INTNL_ARF_UPDATE, // Internal Altref Frame |
| 92 | FRAME_UPDATE_TYPES |
| 93 | } UENUM1BYTE(FRAME_UPDATE_TYPE); |
| 94 | |
Jingning Han | f842039 | 2020-08-20 14:42:08 -0700 | [diff] [blame] | 95 | enum { |
| 96 | REFBUF_RESET, // Clear reference frame buffer |
| 97 | REFBUF_UPDATE, // Refresh reference frame buffer |
| 98 | REFBUF_STATES |
| 99 | } UENUM1BYTE(REFBUF_STATE); |
Jingning Han | a77319b | 2020-08-09 23:10:44 -0700 | [diff] [blame] | 100 | |
Marco Paniconi | 69e6dcc | 2020-07-20 14:19:20 -0700 | [diff] [blame] | 101 | typedef enum { |
| 102 | NO_RESIZE = 0, |
| 103 | DOWN_THREEFOUR = 1, // From orig to 3/4. |
| 104 | DOWN_ONEHALF = 2, // From orig or 3/4 to 1/2. |
| 105 | UP_THREEFOUR = -1, // From 1/2 to 3/4. |
| 106 | UP_ORIG = -2, // From 1/2 or 3/4 to orig. |
| 107 | } RESIZE_ACTION; |
| 108 | |
| 109 | typedef enum { ORIG = 0, THREE_QUARTER = 1, ONE_HALF = 2 } RESIZE_STATE; |
| 110 | |
bohanli | 5c2c97d | 2020-09-24 11:59:32 -0700 | [diff] [blame] | 111 | #define MAX_FIRSTPASS_ANALYSIS_FRAMES 150 |
| 112 | typedef enum region_types { |
| 113 | STABLE_REGION = 0, |
| 114 | HIGH_VAR_REGION = 1, |
| 115 | SCENECUT_REGION = 2, |
| 116 | BLENDING_REGION = 3, |
| 117 | } REGION_TYPES; |
| 118 | |
| 119 | typedef struct regions { |
| 120 | int start; |
| 121 | int last; |
| 122 | double avg_noise_var; |
| 123 | double avg_cor_coeff; |
| 124 | double avg_sr_fr_ratio; |
| 125 | double avg_intra_err; |
| 126 | double avg_coded_err; |
| 127 | REGION_TYPES type; |
| 128 | } REGIONS; |
| 129 | |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 130 | /*!\endcond */ |
| 131 | /*! |
| 132 | * \brief Rate Control parameters and status |
| 133 | */ |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 134 | typedef struct { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 135 | // Rate targetting variables |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 136 | |
| 137 | /*! |
| 138 | * Baseline target rate for frame before adjustment for previous under or |
| 139 | * over shoot. |
| 140 | */ |
| 141 | int base_frame_target; |
| 142 | /*! |
| 143 | * Target rate for frame after adjustment for previous under or over shoot. |
| 144 | */ |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 145 | int this_frame_target; // Actual frame target after rc adjustment. |
Jingning Han | 2eedec5 | 2020-02-05 10:33:43 -0800 | [diff] [blame] | 146 | |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 147 | /*! |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 148 | * Projected size for current frame |
| 149 | */ |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 150 | int projected_frame_size; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 151 | |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 152 | /*! |
Cheng Chen | 8e74aaf | 2020-08-24 21:07:12 -0700 | [diff] [blame] | 153 | * Bit size of transform coefficient for current frame. |
| 154 | */ |
| 155 | int coefficient_size; |
| 156 | |
| 157 | /*! |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 158 | * Super block rate target used with some adaptive quantization strategies. |
| 159 | */ |
| 160 | int sb64_target_rate; |
| 161 | |
| 162 | /*! |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 163 | * Number of frames since the last ARF / GF. |
| 164 | */ |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 165 | int frames_since_golden; |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 166 | |
| 167 | /*! |
| 168 | * Number of frames till the next ARF / GF is due. |
| 169 | */ |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 170 | int frames_till_gf_update_due; |
bohanli | a964eea | 2020-02-13 11:48:00 -0800 | [diff] [blame] | 171 | |
Paul Wilkins | 1fb0172 | 2020-07-07 17:45:46 +0100 | [diff] [blame] | 172 | /*! |
| 173 | * Number of determined gf groups left |
| 174 | */ |
bohanli | a964eea | 2020-02-13 11:48:00 -0800 | [diff] [blame] | 175 | int intervals_till_gf_calculate_due; |
Paul Wilkins | 1fb0172 | 2020-07-07 17:45:46 +0100 | [diff] [blame] | 176 | |
Paul Wilkins | 1fb0172 | 2020-07-07 17:45:46 +0100 | [diff] [blame] | 177 | /*!\cond */ |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 178 | int min_gf_interval; |
| 179 | int max_gf_interval; |
| 180 | int static_scene_max_gf_interval; |
Paul Wilkins | 1fb0172 | 2020-07-07 17:45:46 +0100 | [diff] [blame] | 181 | /*!\endcond */ |
| 182 | /*! |
| 183 | * Frames before the next key frame |
| 184 | */ |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 185 | int frames_to_key; |
Paul Wilkins | 1fb0172 | 2020-07-07 17:45:46 +0100 | [diff] [blame] | 186 | /*!\cond */ |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 187 | int frames_since_key; |
Jingning Han | c7c31d1 | 2021-06-23 09:56:22 -0700 | [diff] [blame] | 188 | int frames_to_fwd_kf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 189 | int is_src_frame_alt_ref; |
Urvang Joshi | 6ce7fbc | 2019-03-22 15:24:21 -0700 | [diff] [blame] | 190 | int sframe_due; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 191 | |
Jerome Jiang | 854f968 | 2020-04-03 15:15:33 -0700 | [diff] [blame] | 192 | int high_source_sad; |
| 193 | uint64_t avg_source_sad; |
Marco Paniconi | 482293b | 2020-05-01 10:56:13 -0700 | [diff] [blame] | 194 | uint64_t prev_avg_source_sad; |
Marco Paniconi | e591c6b | 2022-01-19 12:31:32 -0800 | [diff] [blame] | 195 | uint64_t frame_source_sad; |
Jerome Jiang | 854f968 | 2020-04-03 15:15:33 -0700 | [diff] [blame] | 196 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 197 | int avg_frame_bandwidth; // Average frame size target for clip |
| 198 | int min_frame_bandwidth; // Minimum allocation used for any frame |
| 199 | int max_frame_bandwidth; // Maximum burst rate allowed for a frame. |
Marco Paniconi | fb4e6e5 | 2019-11-22 11:44:42 -0800 | [diff] [blame] | 200 | int prev_avg_frame_bandwidth; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 201 | |
| 202 | int ni_av_qi; |
| 203 | int ni_tot_qi; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 204 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 205 | int decimation_factor; |
| 206 | int decimation_count; |
Marco Paniconi | 6154a1e | 2023-06-14 14:42:41 -0700 | [diff] [blame] | 207 | int prev_frame_is_dropped; |
Marco Paniconi | 5c46a34 | 2023-10-23 14:40:00 -0700 | [diff] [blame] | 208 | int drop_count_consec; |
| 209 | int max_consec_drop; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 210 | |
Marco Paniconi | 233000f | 2023-06-12 15:10:54 -0700 | [diff] [blame] | 211 | /*! |
| 212 | * Frame number for encoded frames (non-dropped). |
| 213 | * Use for setting the rtc reference structure. |
| 214 | */ |
| 215 | unsigned int frame_number_encoded; |
| 216 | |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 217 | /*!\endcond */ |
| 218 | /*! |
| 219 | * User specified maximum Q allowed for current frame |
| 220 | */ |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 221 | int worst_quality; |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 222 | /*! |
| 223 | * User specified minimum Q allowed for current frame |
| 224 | */ |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 225 | int best_quality; |
| 226 | |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 227 | /*!\cond */ |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 228 | |
| 229 | // rate control history for last frame(1) and the frame before(2). |
Yunqing Wang | 89de3d5 | 2022-01-12 15:48:29 -0800 | [diff] [blame] | 230 | // -1: overshoot |
| 231 | // 1: undershoot |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 232 | // 0: not initialized. |
| 233 | int rc_1_frame; |
| 234 | int rc_2_frame; |
| 235 | int q_1_frame; |
| 236 | int q_2_frame; |
| 237 | |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 238 | /*!\endcond */ |
| 239 | /*! |
Paul Wilkins | ff3923f | 2022-08-22 17:16:03 +0100 | [diff] [blame] | 240 | * Proposed maximum allowed Q for current frame |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 241 | */ |
Sarah Parker | e1b2201 | 2019-06-06 16:35:25 -0700 | [diff] [blame] | 242 | int active_worst_quality; |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 243 | |
| 244 | /*!\cond */ |
Fyodor Kyslov | 34b591f | 2020-06-24 20:13:58 -0700 | [diff] [blame] | 245 | // Track amount of low motion in scene |
| 246 | int avg_frame_low_motion; |
Marco Paniconi | 60e4e24 | 2022-07-24 23:32:02 -0700 | [diff] [blame] | 247 | int cnt_zeromv; |
Marco Paniconi | 69e6dcc | 2020-07-20 14:19:20 -0700 | [diff] [blame] | 248 | |
Fyodor Kyslov | e76a05b | 2022-01-31 13:46:38 -0800 | [diff] [blame] | 249 | // signals if number of blocks with motion is high |
Marco Paniconi | 03b2ff9 | 2022-09-21 23:24:15 -0700 | [diff] [blame] | 250 | int percent_blocks_with_motion; |
| 251 | |
| 252 | // Maximum value of source sad across all blocks of frame. |
| 253 | uint64_t max_block_source_sad; |
Fyodor Kyslov | e76a05b | 2022-01-31 13:46:38 -0800 | [diff] [blame] | 254 | |
Marco Paniconi | 69e6dcc | 2020-07-20 14:19:20 -0700 | [diff] [blame] | 255 | // For dynamic resize, 1 pass cbr. |
| 256 | RESIZE_STATE resize_state; |
| 257 | int resize_avg_qp; |
| 258 | int resize_buffer_underflow; |
| 259 | int resize_count; |
Jerome Jiang | 089794f | 2021-11-18 12:30:37 -0800 | [diff] [blame] | 260 | |
| 261 | // Flag to disable content related qp adjustment. |
| 262 | int rtc_external_ratectrl; |
Remya Prakasan | fcfd50e | 2022-03-09 20:57:28 +0530 | [diff] [blame] | 263 | |
| 264 | // Stores fast_extra_bits of the current frame. |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 265 | int frame_level_fast_extra_bits; |
Nithya V S | 56a2362 | 2022-05-10 11:32:43 +0530 | [diff] [blame] | 266 | |
Aasaipriya | 87e4abc | 2021-06-07 19:20:00 +0530 | [diff] [blame] | 267 | double frame_level_rate_correction_factors[RATE_FACTOR_LEVELS]; |
Marco Paniconi | 503c5e3 | 2022-10-13 13:47:32 -0700 | [diff] [blame] | 268 | |
| 269 | int frame_num_last_gf_refresh; |
Marco Paniconi | bee1cad | 2022-11-28 14:25:08 -0800 | [diff] [blame] | 270 | |
| 271 | int prev_coded_width; |
| 272 | int prev_coded_height; |
Yunqing Wang | c964a81 | 2022-12-01 20:08:16 -0800 | [diff] [blame] | 273 | |
| 274 | // The ratio used for inter frames in bit estimation. |
| 275 | // TODO(yunqing): if golden frame is treated differently (e.g. gf_cbr_boost_ |
| 276 | // pct > THR), consider to add bit_est_ratio_g for golden frames. |
| 277 | int bit_est_ratio; |
Jerome Jiang | 706ee36 | 2023-01-25 13:37:57 -0500 | [diff] [blame] | 278 | |
Wan-Teh Chang | 323fa02 | 2023-03-01 15:28:58 -0800 | [diff] [blame] | 279 | // Whether to use a fixed qp for the frame, bypassing internal rate control. |
Jerome Jiang | 706ee36 | 2023-01-25 13:37:57 -0500 | [diff] [blame] | 280 | // This flag will reset to 0 after every frame. |
| 281 | int use_external_qp_one_pass; |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 282 | /*!\endcond */ |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 283 | } RATE_CONTROL; |
| 284 | |
Mufaddal Chakera | 94ee9bf | 2021-04-12 01:02:22 +0530 | [diff] [blame] | 285 | /*! |
| 286 | * \brief Primary Rate Control parameters and status |
| 287 | */ |
| 288 | typedef struct { |
| 289 | // Sub-gop level Rate targetting variables |
| 290 | |
| 291 | /*! |
| 292 | * Target bit budget for the current GF / ARF group of frame. |
| 293 | */ |
| 294 | int64_t gf_group_bits; |
| 295 | |
| 296 | /*! |
| 297 | * Boost factor used to calculate the extra bits allocated to the key frame |
| 298 | */ |
| 299 | int kf_boost; |
| 300 | |
| 301 | /*! |
| 302 | * Boost factor used to calculate the extra bits allocated to ARFs and GFs |
| 303 | */ |
| 304 | int gfu_boost; |
| 305 | |
| 306 | /*! |
| 307 | * Stores the determined gf group lengths for a set of gf groups |
| 308 | */ |
| 309 | int gf_intervals[MAX_NUM_GF_INTERVALS]; |
| 310 | |
| 311 | /*! |
| 312 | * The current group's index into gf_intervals[] |
| 313 | */ |
| 314 | int cur_gf_index; |
| 315 | |
| 316 | /*!\cond */ |
| 317 | int num_regions; |
| 318 | |
| 319 | REGIONS regions[MAX_FIRSTPASS_ANALYSIS_FRAMES]; |
| 320 | int regions_offset; // offset of regions from the last keyframe |
| 321 | int frames_till_regions_update; |
| 322 | |
| 323 | int baseline_gf_interval; |
| 324 | |
| 325 | int constrained_gf_group; |
| 326 | |
| 327 | int this_key_frame_forced; |
| 328 | |
| 329 | int next_key_frame_forced; |
| 330 | /*!\endcond */ |
| 331 | |
| 332 | /*! |
| 333 | * Initial buffuer level in ms for CBR / low delay encoding |
| 334 | */ |
| 335 | int64_t starting_buffer_level; |
| 336 | |
| 337 | /*! |
| 338 | * Optimum / target buffuer level in ms for CBR / low delay encoding |
| 339 | */ |
| 340 | int64_t optimal_buffer_level; |
| 341 | |
| 342 | /*! |
| 343 | * Maximum target buffuer level in ms for CBR / low delay encoding |
| 344 | */ |
| 345 | int64_t maximum_buffer_size; |
| 346 | |
| 347 | /*! |
| 348 | * Q index used for ALT frame |
| 349 | */ |
| 350 | int arf_q; |
| 351 | |
| 352 | /*!\cond */ |
| 353 | float_t arf_boost_factor; |
| 354 | |
| 355 | int base_layer_qp; |
| 356 | |
| 357 | // Total number of stats used only for kf_boost calculation. |
| 358 | int num_stats_used_for_kf_boost; |
| 359 | |
| 360 | // Total number of stats used only for gfu_boost calculation. |
| 361 | int num_stats_used_for_gfu_boost; |
| 362 | |
| 363 | // Total number of stats required by gfu_boost calculation. |
| 364 | int num_stats_required_for_gfu_boost; |
| 365 | |
Mufaddal Chakera | 94ee9bf | 2021-04-12 01:02:22 +0530 | [diff] [blame] | 366 | int enable_scenecut_detection; |
| 367 | |
| 368 | int use_arf_in_this_kf_group; |
Remya Prakasan | 2c35528 | 2021-07-08 13:27:48 +0530 | [diff] [blame] | 369 | |
| 370 | int ni_frames; |
| 371 | |
| 372 | double tot_q; |
Mufaddal Chakera | 94ee9bf | 2021-04-12 01:02:22 +0530 | [diff] [blame] | 373 | /*!\endcond */ |
| 374 | |
| 375 | /*! |
| 376 | * Q used for last boosted (non leaf) frame |
| 377 | */ |
| 378 | int last_kf_qindex; |
Aasaipriya | cdfcf17 | 2021-06-05 16:40:57 +0530 | [diff] [blame] | 379 | |
Tarundeep Singh | 5d03ed3 | 2021-06-23 19:23:19 +0530 | [diff] [blame] | 380 | /*! |
| 381 | * Average of q index of previous encoded frames in a sequence. |
| 382 | */ |
| 383 | int avg_frame_qindex[FRAME_TYPES]; |
| 384 | |
Remya Prakasan | ffeb497 | 2022-06-21 20:00:28 +0530 | [diff] [blame] | 385 | #if CONFIG_FPMT_TEST |
Remya Prakasan | 6566bc8 | 2021-11-05 23:21:12 +0530 | [diff] [blame] | 386 | /*! |
| 387 | * Temporary variable used in simulating the delayed update of |
| 388 | * active_best_quality. |
| 389 | */ |
| 390 | int temp_active_best_quality[MAX_ARF_LAYERS + 1]; |
| 391 | |
| 392 | /*! |
| 393 | * Temporary variable used in simulating the delayed update of |
| 394 | * last_boosted_qindex. |
| 395 | */ |
| 396 | int temp_last_boosted_qindex; |
| 397 | |
| 398 | /*! |
| 399 | * Temporary variable used in simulating the delayed update of |
| 400 | * avg_q. |
| 401 | */ |
| 402 | double temp_avg_q; |
| 403 | |
| 404 | /*! |
| 405 | * Temporary variable used in simulating the delayed update of |
| 406 | * last_q. |
| 407 | */ |
| 408 | int temp_last_q[FRAME_TYPES]; |
| 409 | |
| 410 | /*! |
| 411 | * Temporary variable used in simulating the delayed update of |
| 412 | * projected_frame_size. |
| 413 | */ |
| 414 | int temp_projected_frame_size; |
| 415 | |
| 416 | /*! |
| 417 | * Temporary variable used in simulating the delayed update of |
| 418 | * total_actual_bits. |
| 419 | */ |
| 420 | int64_t temp_total_actual_bits; |
| 421 | |
| 422 | /*! |
| 423 | * Temporary variable used in simulating the delayed update of |
| 424 | * buffer_level. |
| 425 | */ |
| 426 | int64_t temp_buffer_level; |
| 427 | |
| 428 | /*! |
| 429 | * Temporary variable used in simulating the delayed update of |
| 430 | * vbr_bits_off_target. |
| 431 | */ |
| 432 | int64_t temp_vbr_bits_off_target; |
| 433 | |
| 434 | /*! |
| 435 | * Temporary variable used in simulating the delayed update of |
| 436 | * vbr_bits_off_target_fast. |
| 437 | */ |
| 438 | int64_t temp_vbr_bits_off_target_fast; |
| 439 | |
| 440 | /*! |
| 441 | * Temporary variable used in simulating the delayed update of |
| 442 | * rate_correction_factors. |
| 443 | */ |
| 444 | double temp_rate_correction_factors[RATE_FACTOR_LEVELS]; |
| 445 | |
| 446 | /*! |
| 447 | * Temporary variable used in simulating the delayed update of |
| 448 | * rate_error_estimate. |
| 449 | */ |
| 450 | int temp_rate_error_estimate; |
| 451 | |
| 452 | /*! |
| 453 | * Temporary variable used in simulating the delayed update of |
| 454 | * rolling_arf_group_target_bits. |
| 455 | */ |
| 456 | int temp_rolling_arf_group_target_bits; |
| 457 | |
| 458 | /*! |
| 459 | * Temporary variable used in simulating the delayed update of |
| 460 | * rolling_arf_group_actual_bits;. |
| 461 | */ |
| 462 | int temp_rolling_arf_group_actual_bits; |
| 463 | |
| 464 | /*! |
| 465 | * Temporary variable used in simulating the delayed update of |
| 466 | * bits_left;. |
| 467 | */ |
| 468 | int64_t temp_bits_left; |
| 469 | |
| 470 | /*! |
| 471 | * Temporary variable used in simulating the delayed update of |
| 472 | * extend_minq. |
| 473 | */ |
| 474 | int temp_extend_minq; |
| 475 | |
| 476 | /*! |
| 477 | * Temporary variable used in simulating the delayed update of |
| 478 | * extend_maxq. |
| 479 | */ |
| 480 | int temp_extend_maxq; |
| 481 | |
Remya Prakasan | 6566bc8 | 2021-11-05 23:21:12 +0530 | [diff] [blame] | 482 | #endif |
Aasaipriya | c6f0a0b | 2021-08-12 11:27:03 +0530 | [diff] [blame] | 483 | /*! |
| 484 | * Proposed minimum allowed Q different layers in a coding pyramid |
| 485 | */ |
| 486 | int active_best_quality[MAX_ARF_LAYERS + 1]; |
| 487 | |
| 488 | /*! |
| 489 | * Q used for last boosted (non leaf) frame (GF/KF/ARF) |
| 490 | */ |
| 491 | int last_boosted_qindex; |
| 492 | |
| 493 | /*! |
| 494 | * Average Q value of previous inter frames |
| 495 | */ |
| 496 | double avg_q; |
| 497 | |
| 498 | /*! |
| 499 | * Q used on last encoded frame of the given type. |
| 500 | */ |
| 501 | int last_q[FRAME_TYPES]; |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 502 | |
| 503 | /*! |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 504 | * Correction factors used to adjust the q estimate for a given target rate |
| 505 | * in the encode loop. |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 506 | */ |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 507 | double rate_correction_factors[RATE_FACTOR_LEVELS]; |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 508 | |
| 509 | /*! |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 510 | * Current total consumed bits. |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 511 | */ |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 512 | int64_t total_actual_bits; |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 513 | |
| 514 | /*! |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 515 | * Current total target bits. |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 516 | */ |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 517 | int64_t total_target_bits; |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 518 | |
| 519 | /*! |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 520 | * Current buffer level. |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 521 | */ |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 522 | int64_t buffer_level; |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 523 | |
| 524 | /*! |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 525 | * PCT rc error. |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 526 | */ |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 527 | int rate_error_estimate; |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 528 | |
| 529 | /*! |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 530 | * Error bits available from previously encoded frames. |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 531 | */ |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 532 | int64_t vbr_bits_off_target; |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 533 | |
| 534 | /*! |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 535 | * Error bits available from previously encoded frames undershoot. |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 536 | */ |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 537 | int64_t vbr_bits_off_target_fast; |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 538 | |
| 539 | /*! |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 540 | * Total bits deviated from the average frame target, from previously |
| 541 | * encoded frames. |
Aasaipriya | e0da085 | 2021-05-31 18:37:37 +0530 | [diff] [blame] | 542 | */ |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 543 | int64_t bits_off_target; |
Aasaipriya | bf0417d | 2021-08-12 11:34:14 +0530 | [diff] [blame] | 544 | |
| 545 | /*! |
| 546 | * Rolling monitor target bits updated based on current frame target size. |
| 547 | */ |
| 548 | int rolling_target_bits; |
| 549 | |
| 550 | /*! |
| 551 | * Rolling monitor actual bits updated based on current frame final projected |
| 552 | * size. |
| 553 | */ |
| 554 | int rolling_actual_bits; |
Cheng Chen | 3e35375 | 2022-04-01 16:36:37 -0700 | [diff] [blame] | 555 | |
| 556 | /*! |
| 557 | * The history of qindex for each frame. |
| 558 | * Only used when RT_PASSIVE_STRATEGY = 1. |
| 559 | */ |
| 560 | int q_history[MAX_Q_HISTORY]; |
Mufaddal Chakera | 94ee9bf | 2021-04-12 01:02:22 +0530 | [diff] [blame] | 561 | } PRIMARY_RATE_CONTROL; |
Paul Wilkins | e8c76eb | 2020-06-30 17:24:11 +0100 | [diff] [blame] | 562 | |
Wan-Teh Chang | 4d42274 | 2022-08-22 13:37:11 -0700 | [diff] [blame] | 563 | /*!\cond */ |
| 564 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 565 | struct AV1_COMP; |
| 566 | struct AV1EncoderConfig; |
Kavi Ramamurthy | 291ef25 | 2021-06-09 17:07:30 +0000 | [diff] [blame] | 567 | struct GF_GROUP; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 568 | |
Mufaddal Chakera | 94ee9bf | 2021-04-12 01:02:22 +0530 | [diff] [blame] | 569 | void av1_primary_rc_init(const struct AV1EncoderConfig *oxcf, |
| 570 | PRIMARY_RATE_CONTROL *p_rc); |
| 571 | |
Aasaipriya | 65e5e9e | 2021-08-12 11:31:27 +0530 | [diff] [blame] | 572 | void av1_rc_init(const struct AV1EncoderConfig *oxcf, RATE_CONTROL *rc); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 573 | |
Yunqing Wang | 1ff889c | 2022-11-07 15:24:29 -0800 | [diff] [blame] | 574 | int av1_estimate_bits_at_q(const struct AV1_COMP *cpi, int q, |
| 575 | double correction_factor); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 576 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 577 | double av1_convert_qindex_to_q(int qindex, aom_bit_depth_t bit_depth); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 578 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 579 | void av1_rc_init_minq_luts(void); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 580 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 581 | int av1_rc_get_default_min_gf_interval(int width, int height, double framerate); |
| 582 | // Note av1_rc_get_default_max_gf_interval() requires the min_gf_interval to |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 583 | // be passed in to ensure that the max_gf_interval returned is at least as bis |
| 584 | // as that. |
Urvang Joshi | 2abb772 | 2019-03-19 14:28:37 -0700 | [diff] [blame] | 585 | int av1_rc_get_default_max_gf_interval(double framerate, int min_gf_interval); |
Urvang Joshi | f4e775c | 2018-12-14 11:33:17 -0800 | [diff] [blame] | 586 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 587 | // Generally at the high level, the following flow is expected |
| 588 | // to be enforced for rate control: |
| 589 | // First call per frame, one of: |
Mark Wachsler | 389f267 | 2022-02-02 07:26:12 -0800 | [diff] [blame] | 590 | // av1_get_one_pass_rt_params() |
| 591 | // av1_get_second_pass_params() |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 592 | // depending on the usage to set the rate control encode parameters desired. |
| 593 | // |
| 594 | // Then, call encode_frame_to_data_rate() to perform the |
| 595 | // actual encode. This function will in turn call encode_frame() |
Tarundeep Singh | 249a867 | 2021-06-10 15:40:43 +0530 | [diff] [blame] | 596 | // one or more times, followed by: |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 597 | // av1_rc_postencode_update_drop_frame() |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 598 | // |
| 599 | // The majority of rate control parameters are only expected |
Mark Wachsler | 389f267 | 2022-02-02 07:26:12 -0800 | [diff] [blame] | 600 | // to be set in the av1_get_..._params() functions and |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 601 | // updated during the av1_rc_postencode_update...() functions. |
| 602 | // The only exceptions are av1_rc_drop_frame() and |
| 603 | // av1_rc_update_rate_correction_factors() functions. |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 604 | |
| 605 | // Functions to set parameters for encoding before the actual |
| 606 | // encode_frame_to_data_rate() function. |
Ranjit Kumar Tulabandu | d10be50 | 2022-08-08 16:45:06 +0530 | [diff] [blame] | 607 | struct EncodeFrameInput; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 608 | |
| 609 | // Post encode update of the rate control parameters based |
| 610 | // on bytes used |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 611 | void av1_rc_postencode_update(struct AV1_COMP *cpi, uint64_t bytes_used); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 612 | // Post encode update of the rate control parameters for dropped frames |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 613 | void av1_rc_postencode_update_drop_frame(struct AV1_COMP *cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 614 | |
Paul Wilkins | 5ce9d50 | 2020-07-16 17:58:40 +0100 | [diff] [blame] | 615 | /*!\endcond */ |
| 616 | /*!\brief Updates the rate correction factor linking Q to output bits |
| 617 | * |
| 618 | * This function updates the Q rate correction factor after an encode |
| 619 | * cycle depending on whether we overshot or undershot the target rate. |
| 620 | * |
| 621 | * \ingroup rate_control |
| 622 | * \param[in] cpi Top level encoder instance structure |
Nithya V S | 3ce203a | 2022-01-20 17:46:09 +0530 | [diff] [blame] | 623 | * \param[in] is_encode_stage Indicates if recode loop or post-encode |
Paul Wilkins | 5ce9d50 | 2020-07-16 17:58:40 +0100 | [diff] [blame] | 624 | * \param[in] width Frame width |
| 625 | * \param[in] height Frame height |
| 626 | * |
Wan-Teh Chang | 0defff8 | 2022-08-23 14:17:01 -0700 | [diff] [blame] | 627 | * \remark Updates the relevant rate correction factor in cpi->rc |
Paul Wilkins | 5ce9d50 | 2020-07-16 17:58:40 +0100 | [diff] [blame] | 628 | */ |
Aasaipriya | 87e4abc | 2021-06-07 19:20:00 +0530 | [diff] [blame] | 629 | void av1_rc_update_rate_correction_factors(struct AV1_COMP *cpi, |
Nithya V S | 3ce203a | 2022-01-20 17:46:09 +0530 | [diff] [blame] | 630 | int is_encode_stage, int width, |
| 631 | int height); |
Paul Wilkins | 5ce9d50 | 2020-07-16 17:58:40 +0100 | [diff] [blame] | 632 | /*!\cond */ |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 633 | |
| 634 | // Decide if we should drop this frame: For 1-pass CBR. |
| 635 | // Changes only the decimation count in the rate control structure |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 636 | int av1_rc_drop_frame(struct AV1_COMP *cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 637 | |
| 638 | // Computes frame size bounds. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 639 | void av1_rc_compute_frame_size_bounds(const struct AV1_COMP *cpi, |
| 640 | int this_frame_target, |
| 641 | int *frame_under_shoot_limit, |
| 642 | int *frame_over_shoot_limit); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 643 | |
Urvang Joshi | fee52c6 | 2020-06-17 13:45:55 -0700 | [diff] [blame] | 644 | /*!\endcond */ |
| 645 | |
| 646 | /*!\brief Picks q and q bounds given the rate control parameters in \c cpi->rc. |
| 647 | * |
| 648 | * \ingroup rate_control |
| 649 | * \param[in] cpi Top level encoder structure |
Urvang Joshi | fee52c6 | 2020-06-17 13:45:55 -0700 | [diff] [blame] | 650 | * \param[in] width Coded frame width |
| 651 | * \param[in] height Coded frame height |
| 652 | * \param[in] gf_index Index of this frame in the golden frame group |
| 653 | * \param[out] bottom_index Bottom bound for q index (best quality) |
| 654 | * \param[out] top_index Top bound for q index (worst quality) |
| 655 | * \return Returns selected q index to be used for encoding this frame. |
| 656 | * Also, updates \c rc->arf_q. |
| 657 | */ |
Paul Wilkins | ff3923f | 2022-08-22 17:16:03 +0100 | [diff] [blame] | 658 | int av1_rc_pick_q_and_bounds(struct AV1_COMP *cpi, int width, int height, |
Mufaddal Chakera | 94ee9bf | 2021-04-12 01:02:22 +0530 | [diff] [blame] | 659 | int gf_index, int *bottom_index, int *top_index); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 660 | |
Paul Wilkins | 5ce9d50 | 2020-07-16 17:58:40 +0100 | [diff] [blame] | 661 | /*!\brief Estimates q to achieve a target bits per frame |
| 662 | * |
| 663 | * \ingroup rate_control |
| 664 | * \param[in] cpi Top level encoder instance structure |
| 665 | * \param[in] target_bits_per_frame Frame rate target |
| 666 | * \param[in] active_worst_quality Max Q allowed |
| 667 | * \param[in] active_best_quality Min Q allowed |
| 668 | * \param[in] width Frame width |
| 669 | * \param[in] height Frame height |
| 670 | * |
| 671 | * \return Returns a q index value |
| 672 | */ |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 673 | int av1_rc_regulate_q(const struct AV1_COMP *cpi, int target_bits_per_frame, |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 674 | int active_best_quality, int active_worst_quality, |
| 675 | int width, int height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 676 | |
Paul Wilkins | 5ce9d50 | 2020-07-16 17:58:40 +0100 | [diff] [blame] | 677 | /*!\cond */ |
Paul Wilkins | 418ba43 | 2022-11-14 13:07:45 +0000 | [diff] [blame] | 678 | // Gets the appropriate bpmb ennumerator based on the frame and content type |
| 679 | int av1_get_bpmb_enumerator(FRAME_TYPE frame_type, |
| 680 | const int is_screen_content_type); |
| 681 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 682 | // Estimates bits per mb for a given qindex and correction factor. |
Yunqing Wang | 6d9cd9c | 2022-11-07 16:18:16 -0800 | [diff] [blame] | 683 | int av1_rc_bits_per_mb(const struct AV1_COMP *cpi, FRAME_TYPE frame_type, |
| 684 | int qindex, double correction_factor, |
| 685 | int accurate_estimate); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 686 | |
| 687 | // Clamping utilities for bitrate targets for iframes and pframes. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 688 | int av1_rc_clamp_iframe_target_size(const struct AV1_COMP *const cpi, |
Jerome Jiang | ee1ed1c | 2022-03-08 08:22:50 -0800 | [diff] [blame] | 689 | int64_t target); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 690 | int av1_rc_clamp_pframe_target_size(const struct AV1_COMP *const cpi, |
David Turner | 4f1f181 | 2019-01-24 17:00:24 +0000 | [diff] [blame] | 691 | int target, uint8_t frame_update_type); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 692 | |
Urvang Joshi | 1765dd0 | 2019-02-08 10:26:00 -0800 | [diff] [blame] | 693 | // Find q_index corresponding to desired_q, within [best_qindex, worst_qindex]. |
| 694 | // To be precise, 'q_index' is the smallest integer, for which the corresponding |
| 695 | // q >= desired_q. |
| 696 | // If no such q index is found, returns 'worst_qindex'. |
| 697 | int av1_find_qindex(double desired_q, aom_bit_depth_t bit_depth, |
| 698 | int best_qindex, int worst_qindex); |
| 699 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 700 | // Computes a q delta (in "q index" terms) to get from a starting q value |
| 701 | // to a target q value |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 702 | int av1_compute_qdelta(const RATE_CONTROL *rc, double qstart, double qtarget, |
| 703 | aom_bit_depth_t bit_depth); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 704 | |
| 705 | // Computes a q delta (in "q index" terms) to get from a starting q value |
| 706 | // to a value that should equate to the given rate ratio. |
Yunqing Wang | 9723779 | 2022-11-07 15:55:30 -0800 | [diff] [blame] | 707 | int av1_compute_qdelta_by_rate(const struct AV1_COMP *cpi, |
| 708 | FRAME_TYPE frame_type, int qindex, |
| 709 | double rate_target_ratio); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 710 | |
Urvang Joshi | 7a89023 | 2019-03-22 17:00:31 -0700 | [diff] [blame] | 711 | int av1_frame_type_qdelta(const struct AV1_COMP *cpi, int q); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 712 | |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 713 | void av1_rc_update_framerate(struct AV1_COMP *cpi, int width, int height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 714 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 715 | void av1_rc_set_gf_interval_range(const struct AV1_COMP *const cpi, |
| 716 | RATE_CONTROL *const rc); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 717 | |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 718 | void av1_set_target_rate(struct AV1_COMP *cpi, int width, int height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 719 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 720 | int av1_resize_one_pass_cbr(struct AV1_COMP *cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 721 | |
Sarah Parker | 97803fc | 2019-05-17 14:15:37 -0700 | [diff] [blame] | 722 | void av1_rc_set_frame_target(struct AV1_COMP *cpi, int target, int width, |
| 723 | int height); |
| 724 | |
Marco Paniconi | 6868fb4 | 2021-09-08 22:47:26 -0700 | [diff] [blame] | 725 | void av1_adjust_gf_refresh_qp_one_pass_rt(struct AV1_COMP *cpi); |
| 726 | |
Marco Paniconi | 1a3a74a | 2022-08-28 22:26:48 -0700 | [diff] [blame] | 727 | void av1_set_rtc_reference_structure_one_layer(struct AV1_COMP *cpi, |
| 728 | int gf_update); |
Jingning Han | 3f3318f | 2020-08-16 16:12:10 -0700 | [diff] [blame] | 729 | |
Paul Wilkins | 83cfad4 | 2020-06-26 12:38:07 +0100 | [diff] [blame] | 730 | /*!\endcond */ |
| 731 | /*!\brief Calculates how many bits to use for a P frame in one pass vbr |
| 732 | * |
| 733 | * \ingroup rate_control |
| 734 | * \callgraph |
| 735 | * \callergraph |
| 736 | * |
| 737 | * \param[in] cpi Top level encoder structure |
| 738 | * \param[in] frame_update_type Type of frame |
| 739 | * |
| 740 | * \return Returns the target number of bits for this frame. |
| 741 | */ |
Marco Paniconi | cea99e2 | 2019-07-16 18:36:31 -0700 | [diff] [blame] | 742 | int av1_calc_pframe_target_size_one_pass_vbr( |
| 743 | const struct AV1_COMP *const cpi, FRAME_UPDATE_TYPE frame_update_type); |
| 744 | |
Paul Wilkins | 83cfad4 | 2020-06-26 12:38:07 +0100 | [diff] [blame] | 745 | /*!\brief Calculates how many bits to use for an i frame in one pass vbr |
| 746 | * |
| 747 | * \ingroup rate_control |
| 748 | * \callgraph |
| 749 | * \callergraph |
| 750 | * |
| 751 | * \param[in] cpi Top level encoder structure |
| 752 | * |
| 753 | * \return Returns the target number of bits for this frame. |
| 754 | */ |
Marco Paniconi | cea99e2 | 2019-07-16 18:36:31 -0700 | [diff] [blame] | 755 | int av1_calc_iframe_target_size_one_pass_vbr(const struct AV1_COMP *const cpi); |
| 756 | |
Marco Paniconi | dd0fa45 | 2020-07-07 12:04:32 -0700 | [diff] [blame] | 757 | /*!\brief Calculates how many bits to use for a P frame in one pass cbr |
| 758 | * |
| 759 | * \ingroup rate_control |
| 760 | * \callgraph |
| 761 | * \callergraph |
| 762 | * |
| 763 | * \param[in] cpi Top level encoder structure |
| 764 | * \param[in] frame_update_type Type of frame |
| 765 | * |
| 766 | * \return Returns the target number of bits for this frame. |
| 767 | */ |
Marco Paniconi | cea99e2 | 2019-07-16 18:36:31 -0700 | [diff] [blame] | 768 | int av1_calc_pframe_target_size_one_pass_cbr( |
| 769 | const struct AV1_COMP *cpi, FRAME_UPDATE_TYPE frame_update_type); |
| 770 | |
Marco Paniconi | dd0fa45 | 2020-07-07 12:04:32 -0700 | [diff] [blame] | 771 | /*!\brief Calculates how many bits to use for an i frame in one pass cbr |
| 772 | * |
| 773 | * \ingroup rate_control |
| 774 | * \callgraph |
| 775 | * \callergraph |
| 776 | * |
| 777 | * \param[in] cpi Top level encoder structure |
| 778 | * |
| 779 | * \return Returns the target number of bits for this frame. |
| 780 | */ |
Marco Paniconi | cea99e2 | 2019-07-16 18:36:31 -0700 | [diff] [blame] | 781 | int av1_calc_iframe_target_size_one_pass_cbr(const struct AV1_COMP *cpi); |
| 782 | |
Marco Paniconi | dd0fa45 | 2020-07-07 12:04:32 -0700 | [diff] [blame] | 783 | /*!\brief Setup the rate control parameters for 1 pass real-time mode. |
| 784 | * |
| 785 | * - Sets the frame type and target frame size. |
| 786 | * - Sets the GF update. |
| 787 | * - Checks for scene change. |
| 788 | * - Sets the reference prediction structure for 1 layers (non-SVC). |
| 789 | * - Resets and updates are done for SVC. |
| 790 | * |
| 791 | * \ingroup rate_control |
| 792 | * \param[in] cpi Top level encoder structure |
Wan-Teh Chang | 5529fda | 2022-09-02 11:31:17 -0700 | [diff] [blame] | 793 | * \param[in] frame_type Encoder frame type |
Ranjit Kumar Tulabandu | d10be50 | 2022-08-08 16:45:06 +0530 | [diff] [blame] | 794 | * \param[in] frame_input Current and last input source frames |
Wan-Teh Chang | 5529fda | 2022-09-02 11:31:17 -0700 | [diff] [blame] | 795 | * \param[in] frame_flags Encoder frame flags |
Marco Paniconi | dd0fa45 | 2020-07-07 12:04:32 -0700 | [diff] [blame] | 796 | * |
Wan-Teh Chang | 0defff8 | 2022-08-23 14:17:01 -0700 | [diff] [blame] | 797 | * \remark Nothing is returned. Instead the settings computed in this |
Wan-Teh Chang | c781258 | 2022-08-23 20:17:34 -0700 | [diff] [blame] | 798 | * function are set in: \c frame_params, \c cpi->common, \c cpi->rc, |
| 799 | * \c cpi->svc. |
Marco Paniconi | dd0fa45 | 2020-07-07 12:04:32 -0700 | [diff] [blame] | 800 | */ |
Marco Paniconi | cea99e2 | 2019-07-16 18:36:31 -0700 | [diff] [blame] | 801 | void av1_get_one_pass_rt_params(struct AV1_COMP *cpi, |
Wan-Teh Chang | 5529fda | 2022-09-02 11:31:17 -0700 | [diff] [blame] | 802 | FRAME_TYPE *const frame_type, |
Ranjit Kumar Tulabandu | d10be50 | 2022-08-08 16:45:06 +0530 | [diff] [blame] | 803 | const struct EncodeFrameInput *frame_input, |
Marco Paniconi | cea99e2 | 2019-07-16 18:36:31 -0700 | [diff] [blame] | 804 | unsigned int frame_flags); |
| 805 | |
Marco Paniconi | dd0fa45 | 2020-07-07 12:04:32 -0700 | [diff] [blame] | 806 | /*!\brief Increase q on expected encoder overshoot, for CBR mode. |
| 807 | * |
| 808 | * Handles the case when encoder is expected to create a large frame: |
| 809 | * - q is increased to value closer to \c cpi->rc.worst_quality |
| 810 | * - avg_frame_qindex is reset |
| 811 | * - buffer levels are reset |
| 812 | * - rate correction factor is adjusted |
| 813 | * |
| 814 | * \ingroup rate_control |
| 815 | * \param[in] cpi Top level encoder structure |
| 816 | * \param[in] q Current q index |
| 817 | * |
| 818 | * \return q is returned, and updates are done to \c cpi->rc. |
| 819 | */ |
| 820 | int av1_encodedframe_overshoot_cbr(struct AV1_COMP *cpi, int *q); |
Urvang Joshi | fee52c6 | 2020-06-17 13:45:55 -0700 | [diff] [blame] | 821 | |
Kavi Ramamurthy | 7904673 | 2021-06-11 20:25:00 +0000 | [diff] [blame] | 822 | /*!\brief Compute the q_indices for a single frame. |
| 823 | * |
| 824 | * Intended to be used with AOM_Q mode. |
| 825 | * |
| 826 | * \param[in] base_q_index Base q index |
| 827 | * \param[in] gf_update_type GOP update type |
| 828 | * \param[in] gf_pyramid_level GOP level of the current frame |
| 829 | * \param[in] arf_q ARF q_index |
| 830 | * |
| 831 | * \return Returns the q_index for the current frame. |
| 832 | */ |
| 833 | int av1_q_mode_get_q_index(int base_q_index, int gf_update_type, |
| 834 | int gf_pyramid_level, int arf_q); |
| 835 | |
| 836 | /*!\brief Compute the q_indices for the ARF of a GOP. |
| 837 | * |
| 838 | * \param[in] base_q_index Base q index |
| 839 | * \param[in] gfu_boost GFU boost |
| 840 | * \param[in] bit_depth Bit depth |
| 841 | * \param[in] arf_boost_factor ARF boost factor |
| 842 | * |
| 843 | * \return Returns the q_index for the ARF frame. |
| 844 | */ |
| 845 | int av1_get_arf_q_index(int base_q_index, int gfu_boost, int bit_depth, |
| 846 | double arf_boost_factor); |
| 847 | |
Jingning Han | 1657934 | 2021-05-12 00:02:01 -0700 | [diff] [blame] | 848 | #if !CONFIG_REALTIME_ONLY |
Kavi Ramamurthy | 99bc51c | 2021-09-01 21:29:18 +0000 | [diff] [blame] | 849 | struct TplDepFrame; |
Jingning Han | 1657934 | 2021-05-12 00:02:01 -0700 | [diff] [blame] | 850 | /*!\brief Compute the q_indices for the ARF of a GOP in Q mode. |
| 851 | * |
| 852 | * \param[in] cpi Top level encoder structure |
| 853 | * \param[in] tpl_frame Tpl Frame stats |
| 854 | * |
| 855 | * \return Returns the q_index for the ARF frame. |
| 856 | */ |
| 857 | int av1_get_arf_q_index_q_mode(struct AV1_COMP *cpi, |
| 858 | struct TplDepFrame *tpl_frame); |
| 859 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 860 | #ifdef __cplusplus |
| 861 | } // extern "C" |
| 862 | #endif |
| 863 | |
James Zern | e1cbb13 | 2018-08-22 14:10:36 -0700 | [diff] [blame] | 864 | #endif // AOM_AV1_ENCODER_RATECTRL_H_ |