1 /*
2 * Copyright (c) 2020, Alliance for Open Media. All rights reserved.
3 *
4 * This source code is subject to the terms of the BSD 2 Clause License and
5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6 * was not distributed with this source code in the LICENSE file, you can
7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8 * Media Patent License 1.0 was not distributed with this source code in the
9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10 */
11
12 #ifndef AOM_AV1_ENCODER_RC_UTILS_H_
13 #define AOM_AV1_ENCODER_RC_UTILS_H_
14
15 #include "av1/encoder/encoder.h"
16 #include "aom_dsp/psnr.h"
17
18 #ifdef __cplusplus
19 extern "C" {
20 #endif
21
check_reset_rc_flag(AV1_COMP * cpi)22 static inline void check_reset_rc_flag(AV1_COMP *cpi) {
23 RATE_CONTROL *rc = &cpi->rc;
24 PRIMARY_RATE_CONTROL *const p_rc = &cpi->ppi->p_rc;
25 if (cpi->common.current_frame.frame_number >
26 (unsigned int)cpi->svc.number_spatial_layers) {
27 if (cpi->ppi->use_svc) {
28 av1_svc_check_reset_layer_rc_flag(cpi);
29 } else {
30 if (rc->avg_frame_bandwidth / 3 > (rc->prev_avg_frame_bandwidth >> 1) ||
31 rc->avg_frame_bandwidth < (rc->prev_avg_frame_bandwidth >> 1)) {
32 rc->rc_1_frame = 0;
33 rc->rc_2_frame = 0;
34 p_rc->bits_off_target = p_rc->optimal_buffer_level;
35 p_rc->buffer_level = p_rc->optimal_buffer_level;
36 }
37 }
38 }
39 }
40
set_primary_rc_buffer_sizes(const AV1EncoderConfig * oxcf,AV1_PRIMARY * ppi)41 static inline void set_primary_rc_buffer_sizes(const AV1EncoderConfig *oxcf,
42 AV1_PRIMARY *ppi) {
43 PRIMARY_RATE_CONTROL *p_rc = &ppi->p_rc;
44 const RateControlCfg *const rc_cfg = &oxcf->rc_cfg;
45
46 const int64_t bandwidth = rc_cfg->target_bandwidth;
47 const int64_t starting = rc_cfg->starting_buffer_level_ms;
48 const int64_t optimal = rc_cfg->optimal_buffer_level_ms;
49 const int64_t maximum = rc_cfg->maximum_buffer_size_ms;
50
51 p_rc->starting_buffer_level = starting * bandwidth / 1000;
52 p_rc->optimal_buffer_level =
53 (optimal == 0) ? bandwidth / 8 : optimal * bandwidth / 1000;
54 p_rc->maximum_buffer_size =
55 (maximum == 0) ? bandwidth / 8 : maximum * bandwidth / 1000;
56
57 // Under a configuration change, where maximum_buffer_size may change,
58 // keep buffer level clipped to the maximum allowed buffer size.
59 p_rc->bits_off_target =
60 AOMMIN(p_rc->bits_off_target, p_rc->maximum_buffer_size);
61 p_rc->buffer_level = AOMMIN(p_rc->buffer_level, p_rc->maximum_buffer_size);
62 }
63
config_target_level(AV1_COMP * const cpi,AV1_LEVEL target_level,int tier)64 static inline void config_target_level(AV1_COMP *const cpi,
65 AV1_LEVEL target_level, int tier) {
66 AV1EncoderConfig *const oxcf = &cpi->oxcf;
67 SequenceHeader *const seq_params = cpi->common.seq_params;
68 TileConfig *const tile_cfg = &oxcf->tile_cfg;
69 RateControlCfg *const rc_cfg = &oxcf->rc_cfg;
70
71 // Adjust target bitrate to be no larger than 70% of level limit.
72 const BITSTREAM_PROFILE profile = seq_params->profile;
73 const double level_bitrate_limit =
74 av1_get_max_bitrate_for_level(target_level, tier, profile);
75 const int64_t max_bitrate = (int64_t)(level_bitrate_limit * 0.70);
76 rc_cfg->target_bandwidth = AOMMIN(rc_cfg->target_bandwidth, max_bitrate);
77 // Also need to update cpi->ppi->twopass.bits_left.
78 TWO_PASS *const twopass = &cpi->ppi->twopass;
79 FIRSTPASS_STATS *stats = twopass->stats_buf_ctx->total_stats;
80 if (stats != NULL)
81 cpi->ppi->twopass.bits_left =
82 (int64_t)(stats->duration * rc_cfg->target_bandwidth / 10000000.0);
83
84 // Adjust max over-shoot percentage.
85 rc_cfg->over_shoot_pct = 0;
86
87 // Adjust max quantizer.
88 rc_cfg->worst_allowed_q = 255;
89
90 // Adjust number of tiles and tile columns to be under level limit.
91 int max_tiles, max_tile_cols;
92 av1_get_max_tiles_for_level(target_level, &max_tiles, &max_tile_cols);
93 while (tile_cfg->tile_columns > 0 &&
94 (1 << tile_cfg->tile_columns) > max_tile_cols) {
95 --tile_cfg->tile_columns;
96 }
97 const int tile_cols = (1 << tile_cfg->tile_columns);
98 while (tile_cfg->tile_rows > 0 &&
99 tile_cols * (1 << tile_cfg->tile_rows) > max_tiles) {
100 --tile_cfg->tile_rows;
101 }
102
103 // Adjust min compression ratio.
104 const int still_picture = seq_params->still_picture;
105 const double min_cr =
106 av1_get_min_cr_for_level(target_level, tier, still_picture);
107 rc_cfg->min_cr = AOMMAX(rc_cfg->min_cr, (unsigned int)(min_cr * 100));
108 }
109
110 #if !CONFIG_REALTIME_ONLY
111
112 /*!\brief Function to test for conditions that indicate we should loop
113 * back and recode a frame.
114 *
115 * \ingroup rate_control
116 *
117 * \param[in] cpi Top-level encoder structure
118 * \param[in] high_limit Upper rate threshold
119 * \param[in] low_limit Lower rate threshold
120 * \param[in] q Current q index
121 * \param[in] maxq Maximum allowed q index
122 * \param[in] minq Minimum allowed q index
123 *
124 * \return Indicates if a recode is required.
125 * \retval 1 Recode Required
126 * \retval 0 No Recode required
127 */
recode_loop_test(AV1_COMP * cpi,int high_limit,int low_limit,int q,int maxq,int minq)128 static inline int recode_loop_test(AV1_COMP *cpi, int high_limit, int low_limit,
129 int q, int maxq, int minq) {
130 const RATE_CONTROL *const rc = &cpi->rc;
131 const AV1EncoderConfig *const oxcf = &cpi->oxcf;
132 const int frame_is_kfgfarf = frame_is_kf_gf_arf(cpi);
133 int force_recode = 0;
134
135 if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
136 (cpi->sf.hl_sf.recode_loop == ALLOW_RECODE) ||
137 (frame_is_kfgfarf &&
138 (cpi->sf.hl_sf.recode_loop == ALLOW_RECODE_KFARFGF))) {
139 // TODO(agrange) high_limit could be greater than the scale-down threshold.
140 if ((rc->projected_frame_size > high_limit && q < maxq) ||
141 (rc->projected_frame_size < low_limit && q > minq)) {
142 force_recode = 1;
143 } else if (cpi->oxcf.rc_cfg.mode == AOM_CQ) {
144 // Deal with frame undershoot and whether or not we are
145 // below the automatically set cq level.
146 if (q > oxcf->rc_cfg.cq_level &&
147 rc->projected_frame_size <
148 (((int64_t)rc->this_frame_target * 7) >> 3)) {
149 force_recode = 1;
150 }
151 }
152 }
153 return force_recode;
154 }
155
av1_get_gfu_boost_projection_factor(double min_factor,double max_factor,int frame_count)156 static inline double av1_get_gfu_boost_projection_factor(double min_factor,
157 double max_factor,
158 int frame_count) {
159 double factor = sqrt((double)frame_count);
160 factor = AOMMIN(factor, max_factor);
161 factor = AOMMAX(factor, min_factor);
162 factor = (200.0 + 10.0 * factor);
163 return factor;
164 }
165
get_gfu_boost_from_r0_lap(double min_factor,double max_factor,double r0,int frames_to_key)166 static inline int get_gfu_boost_from_r0_lap(double min_factor,
167 double max_factor, double r0,
168 int frames_to_key) {
169 double factor = av1_get_gfu_boost_projection_factor(min_factor, max_factor,
170 frames_to_key);
171 const int boost = (int)rint(factor / r0);
172 return boost;
173 }
174
av1_get_kf_boost_projection_factor(int frame_count)175 static inline double av1_get_kf_boost_projection_factor(int frame_count) {
176 double factor = sqrt((double)frame_count);
177 factor = AOMMIN(factor, 10.0);
178 factor = AOMMAX(factor, 4.0);
179 factor = (75.0 + 14.0 * factor);
180 return factor;
181 }
182
get_regulated_q_overshoot(AV1_COMP * const cpi,int is_encode_stage,int q_low,int q_high,int top_index,int bottom_index)183 static inline int get_regulated_q_overshoot(AV1_COMP *const cpi,
184 int is_encode_stage, int q_low,
185 int q_high, int top_index,
186 int bottom_index) {
187 const AV1_COMMON *const cm = &cpi->common;
188 const RATE_CONTROL *const rc = &cpi->rc;
189
190 av1_rc_update_rate_correction_factors(cpi, is_encode_stage, cm->width,
191 cm->height);
192
193 int q_regulated =
194 av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
195 AOMMAX(q_high, top_index), cm->width, cm->height);
196
197 int retries = 0;
198 while (q_regulated < q_low && retries < 10) {
199 av1_rc_update_rate_correction_factors(cpi, is_encode_stage, cm->width,
200 cm->height);
201 q_regulated =
202 av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
203 AOMMAX(q_high, top_index), cm->width, cm->height);
204 retries++;
205 }
206 return q_regulated;
207 }
208
get_regulated_q_undershoot(AV1_COMP * const cpi,int is_encode_stage,int q_high,int top_index,int bottom_index)209 static inline int get_regulated_q_undershoot(AV1_COMP *const cpi,
210 int is_encode_stage, int q_high,
211 int top_index, int bottom_index) {
212 const AV1_COMMON *const cm = &cpi->common;
213 const RATE_CONTROL *const rc = &cpi->rc;
214
215 av1_rc_update_rate_correction_factors(cpi, is_encode_stage, cm->width,
216 cm->height);
217 int q_regulated = av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
218 top_index, cm->width, cm->height);
219
220 int retries = 0;
221 while (q_regulated > q_high && retries < 10) {
222 av1_rc_update_rate_correction_factors(cpi, is_encode_stage, cm->width,
223 cm->height);
224 q_regulated = av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
225 top_index, cm->width, cm->height);
226 retries++;
227 }
228 return q_regulated;
229 }
230
231 /*!\brief Called after encode_with_recode_loop() has just encoded a frame.
232 * This function works out whether we undershot or overshot our bitrate
233 * target and adjusts q as appropriate. It also decides whether or not
234 * we need to recode the frame to get closer to the target rate.
235 *
236 * \ingroup rate_control
237 *
238 * \param[in] cpi Top-level encoder structure
239 * \param[out] loop Should we go around the recode loop again
240 * \param[in,out] q New q index value
241 * \param[in,out] q_low Low q index limit for this loop itteration
242 * \param[in,out] q_high High q index limit for this loop itteration
243 * \param[in] top_index Max permited new value for q index
244 * \param[in] bottom_index Min permited new value for q index
245 * \param[in,out] undershoot_seen Have we seen undershoot on this frame
246 * \param[in,out] overshoot_seen Have we seen overshoot on this frame
247 * \param[in,out] low_cr_seen Have we previously trriggered recode
248 * because the compression ration was less
249 * than a given minimum threshold.
250 * \param[in] loop_count Loop itterations so far.
251 *
252 */
recode_loop_update_q(AV1_COMP * const cpi,int * const loop,int * const q,int * const q_low,int * const q_high,const int top_index,const int bottom_index,int * const undershoot_seen,int * const overshoot_seen,int * const low_cr_seen,const int loop_count)253 static inline void recode_loop_update_q(
254 AV1_COMP *const cpi, int *const loop, int *const q, int *const q_low,
255 int *const q_high, const int top_index, const int bottom_index,
256 int *const undershoot_seen, int *const overshoot_seen,
257 int *const low_cr_seen, const int loop_count) {
258 AV1_COMMON *const cm = &cpi->common;
259 RATE_CONTROL *const rc = &cpi->rc;
260 PRIMARY_RATE_CONTROL *const p_rc = &cpi->ppi->p_rc;
261 const RateControlCfg *const rc_cfg = &cpi->oxcf.rc_cfg;
262 *loop = 0;
263
264 // Special case for overlay frame.
265 if (rc->is_src_frame_alt_ref &&
266 rc->projected_frame_size < rc->max_frame_bandwidth)
267 return;
268
269 const int min_cr = rc_cfg->min_cr;
270 if (min_cr > 0) {
271 const double compression_ratio =
272 av1_get_compression_ratio(cm, rc->projected_frame_size >> 3);
273 const double target_cr = min_cr / 100.0;
274 if (compression_ratio < target_cr) {
275 *low_cr_seen = 1;
276 if (*q < rc->worst_quality) {
277 const double cr_ratio = target_cr / compression_ratio;
278 const int projected_q = AOMMAX(*q + 1, (int)(*q * cr_ratio * cr_ratio));
279 *q = AOMMIN(AOMMIN(projected_q, *q + 32), rc->worst_quality);
280 *q_low = AOMMAX(*q, *q_low);
281 *q_high = AOMMAX(*q, *q_high);
282 *loop = 1;
283 }
284 }
285 if (*low_cr_seen) return;
286 }
287
288 if (cpi->ppi->level_params.keep_level_stats &&
289 !is_stat_generation_stage(cpi)) {
290 // Initialize level info. at the beginning of each sequence.
291 if (cm->current_frame.frame_type == KEY_FRAME &&
292 cpi->ppi->gf_group.refbuf_state[cpi->gf_frame_index] == REFBUF_RESET) {
293 av1_init_level_info(cpi);
294 }
295 const AV1LevelParams *const level_params = &cpi->ppi->level_params;
296 // TODO(any): currently only checking operating point 0
297 const AV1LevelInfo *const level_info = level_params->level_info[0];
298 const DECODER_MODEL *const decoder_models = level_info->decoder_models;
299 const AV1_LEVEL target_level = level_params->target_seq_level_idx[0];
300
301 if (target_level < SEQ_LEVELS &&
302 decoder_models[target_level].status == DECODER_MODEL_OK) {
303 DECODER_MODEL_STATUS status = av1_decoder_model_try_smooth_buf(
304 cpi, rc->projected_frame_size, &decoder_models[target_level]);
305
306 if ((status == SMOOTHING_BUFFER_UNDERFLOW ||
307 status == SMOOTHING_BUFFER_OVERFLOW) &&
308 *q < rc->worst_quality) {
309 *q = AOMMIN(*q + 10, rc->worst_quality);
310 *q_low = AOMMAX(*q, *q_low);
311 *q_high = AOMMAX(*q, *q_high);
312 *loop = 1;
313 return;
314 }
315 }
316 }
317
318 if (rc_cfg->mode == AOM_Q) return;
319
320 const int last_q = *q;
321 int frame_over_shoot_limit = 0, frame_under_shoot_limit = 0;
322 av1_rc_compute_frame_size_bounds(cpi, rc->this_frame_target,
323 &frame_under_shoot_limit,
324 &frame_over_shoot_limit);
325 if (frame_over_shoot_limit == 0) frame_over_shoot_limit = 1;
326
327 if (cm->current_frame.frame_type == KEY_FRAME &&
328 p_rc->this_key_frame_forced &&
329 rc->projected_frame_size < rc->max_frame_bandwidth) {
330 int64_t kf_err;
331 const int64_t high_err_target = cpi->ambient_err;
332 const int64_t low_err_target = cpi->ambient_err >> 1;
333
334 #if CONFIG_AV1_HIGHBITDEPTH
335 if (cm->seq_params->use_highbitdepth) {
336 kf_err = aom_highbd_get_y_sse(cpi->source, &cm->cur_frame->buf);
337 } else {
338 kf_err = aom_get_y_sse(cpi->source, &cm->cur_frame->buf);
339 }
340 #else
341 kf_err = aom_get_y_sse(cpi->source, &cm->cur_frame->buf);
342 #endif
343 // Prevent possible divide by zero error below for perfect KF
344 kf_err += !kf_err;
345
346 // The key frame is not good enough or we can afford
347 // to make it better without undue risk of popping.
348 if ((kf_err > high_err_target &&
349 rc->projected_frame_size <= frame_over_shoot_limit) ||
350 (kf_err > low_err_target &&
351 rc->projected_frame_size <= frame_under_shoot_limit)) {
352 // Lower q_high
353 *q_high = AOMMAX(*q - 1, *q_low);
354
355 // Adjust Q
356 *q = (int)((*q * high_err_target) / kf_err);
357 *q = AOMMIN(*q, (*q_high + *q_low) >> 1);
358 } else if (kf_err < low_err_target &&
359 rc->projected_frame_size >= frame_under_shoot_limit) {
360 // The key frame is much better than the previous frame
361 // Raise q_low
362 *q_low = AOMMIN(*q + 1, *q_high);
363
364 // Adjust Q
365 *q = (int)((*q * low_err_target) / kf_err);
366 *q = AOMMIN(*q, (*q_high + *q_low + 1) >> 1);
367 }
368
369 // Clamp Q to upper and lower limits:
370 *q = clamp(*q, *q_low, *q_high);
371 *loop = (*q != last_q);
372 return;
373 }
374
375 if (recode_loop_test(cpi, frame_over_shoot_limit, frame_under_shoot_limit, *q,
376 AOMMAX(*q_high, top_index), bottom_index)) {
377 // Is the projected frame size out of range and are we allowed
378 // to attempt to recode.
379
380 // Frame size out of permitted range:
381 // Update correction factor & compute new Q to try...
382 // Frame is too large
383 if (rc->projected_frame_size > rc->this_frame_target) {
384 // Special case if the projected size is > the max allowed.
385 if (*q == *q_high &&
386 rc->projected_frame_size >= rc->max_frame_bandwidth) {
387 const double q_val_high_current =
388 av1_convert_qindex_to_q(*q_high, cm->seq_params->bit_depth);
389 const double q_val_high_new =
390 q_val_high_current *
391 ((double)rc->projected_frame_size / rc->max_frame_bandwidth);
392 *q_high = av1_find_qindex(q_val_high_new, cm->seq_params->bit_depth,
393 rc->best_quality, rc->worst_quality);
394 }
395
396 // Raise Qlow as to at least the current value
397 *q_low = AOMMIN(*q + 1, *q_high);
398
399 if (*undershoot_seen || loop_count > 2 ||
400 (loop_count == 2 && !frame_is_intra_only(cm))) {
401 av1_rc_update_rate_correction_factors(cpi, 1, cm->width, cm->height);
402
403 *q = (*q_high + *q_low + 1) / 2;
404 } else if (loop_count == 2 && frame_is_intra_only(cm)) {
405 const int q_mid = (*q_high + *q_low + 1) / 2;
406 const int q_regulated = get_regulated_q_overshoot(
407 cpi, 1, *q_low, *q_high, top_index, bottom_index);
408 // Get 'q' in-between 'q_mid' and 'q_regulated' for a smooth
409 // transition between loop_count < 2 and loop_count > 2.
410 *q = (q_mid + q_regulated + 1) / 2;
411 } else {
412 *q = get_regulated_q_overshoot(cpi, 1, *q_low, *q_high, top_index,
413 bottom_index);
414 }
415
416 *overshoot_seen = 1;
417 } else {
418 // Frame is too small
419 *q_high = AOMMAX(*q - 1, *q_low);
420
421 if (*overshoot_seen || loop_count > 2 ||
422 (loop_count == 2 && !frame_is_intra_only(cm))) {
423 av1_rc_update_rate_correction_factors(cpi, 1, cm->width, cm->height);
424 *q = (*q_high + *q_low) / 2;
425 } else if (loop_count == 2 && frame_is_intra_only(cm)) {
426 const int q_mid = (*q_high + *q_low) / 2;
427 const int q_regulated = get_regulated_q_undershoot(
428 cpi, 1, *q_high, top_index, bottom_index);
429 // Get 'q' in-between 'q_mid' and 'q_regulated' for a smooth
430 // transition between loop_count < 2 and loop_count > 2.
431 *q = (q_mid + q_regulated) / 2;
432
433 // Special case reset for qlow for constrained quality.
434 // This should only trigger where there is very substantial
435 // undershoot on a frame and the auto cq level is above
436 // the user passsed in value.
437 if (rc_cfg->mode == AOM_CQ && q_regulated < *q_low) {
438 *q_low = *q;
439 }
440 } else {
441 *q = get_regulated_q_undershoot(cpi, 1, *q_high, top_index,
442 bottom_index);
443
444 // Special case reset for qlow for constrained quality.
445 // This should only trigger where there is very substantial
446 // undershoot on a frame and the auto cq level is above
447 // the user passsed in value.
448 if (rc_cfg->mode == AOM_CQ && *q < *q_low) {
449 *q_low = *q;
450 }
451 }
452
453 *undershoot_seen = 1;
454 }
455
456 // Clamp Q to upper and lower limits:
457 *q = clamp(*q, *q_low, *q_high);
458 }
459
460 *loop = (*q != last_q);
461 }
462 #endif
463
464 #ifdef __cplusplus
465 } // extern "C"
466 #endif
467
468 #endif // AOM_AV1_ENCODER_RC_UTILS_H_
469