ratectrl.c 63.9 KB
Newer Older
Jingning Han's avatar
Jingning Han committed
1
/*
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
Jingning Han's avatar
Jingning Han committed
3
 *
4 5 6 7 8 9
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
Jingning Han's avatar
Jingning Han committed
10 11 12 13 14 15 16 17 18
 */

#include <assert.h>
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

19 20
#include "aom_dsp/aom_dsp_common.h"
#include "aom_mem/aom_mem.h"
21 22
#include "aom_ports/mem.h"
#include "aom_ports/system_state.h"
Jingning Han's avatar
Jingning Han committed
23

24 25 26 27 28 29
#include "av1/common/alloccommon.h"
#include "av1/encoder/aq_cyclicrefresh.h"
#include "av1/common/common.h"
#include "av1/common/entropymode.h"
#include "av1/common/quant_common.h"
#include "av1/common/seg_common.h"
Jingning Han's avatar
Jingning Han committed
30

31
#include "av1/encoder/encodemv.h"
32
#include "av1/encoder/random.h"
33
#include "av1/encoder/ratectrl.h"
Jingning Han's avatar
Jingning Han committed
34 35 36 37 38 39 40 41 42 43 44 45 46

// Max rate target for 1080P and below encodes under normal circumstances
// (1920 * 1080 / (16 * 16)) * MAX_MB_RATE bits per MB
#define MAX_MB_RATE 250
#define MAXRATE_1080P 2025000

#define DEFAULT_KF_BOOST 2000
#define DEFAULT_GF_BOOST 2000

#define MIN_BPB_FACTOR 0.005
#define MAX_BPB_FACTOR 50

#define FRAME_OVERHEAD_BITS 200
47
#if CONFIG_HIGHBITDEPTH
48 49 50
#define ASSIGN_MINQ_TABLE(bit_depth, name)                   \
  do {                                                       \
    switch (bit_depth) {                                     \
51 52 53
      case AOM_BITS_8: name = name##_8; break;               \
      case AOM_BITS_10: name = name##_10; break;             \
      case AOM_BITS_12: name = name##_12; break;             \
54 55
      default:                                               \
        assert(0 &&                                          \
56 57
               "bit_depth should be AOM_BITS_8, AOM_BITS_10" \
               " or AOM_BITS_12");                           \
58 59
        name = NULL;                                         \
    }                                                        \
Jingning Han's avatar
Jingning Han committed
60 61 62
  } while (0)
#else
#define ASSIGN_MINQ_TABLE(bit_depth, name) \
63
  do {                                     \
clang-format's avatar
clang-format committed
64
    (void)bit_depth;                       \
65
    name = name##_8;                       \
Jingning Han's avatar
Jingning Han committed
66 67 68 69 70 71 72 73 74 75 76
  } while (0)
#endif

// Tables relating active max Q to active min Q
static int kf_low_motion_minq_8[QINDEX_RANGE];
static int kf_high_motion_minq_8[QINDEX_RANGE];
static int arfgf_low_motion_minq_8[QINDEX_RANGE];
static int arfgf_high_motion_minq_8[QINDEX_RANGE];
static int inter_minq_8[QINDEX_RANGE];
static int rtc_minq_8[QINDEX_RANGE];

77
#if CONFIG_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
static int kf_low_motion_minq_10[QINDEX_RANGE];
static int kf_high_motion_minq_10[QINDEX_RANGE];
static int arfgf_low_motion_minq_10[QINDEX_RANGE];
static int arfgf_high_motion_minq_10[QINDEX_RANGE];
static int inter_minq_10[QINDEX_RANGE];
static int rtc_minq_10[QINDEX_RANGE];
static int kf_low_motion_minq_12[QINDEX_RANGE];
static int kf_high_motion_minq_12[QINDEX_RANGE];
static int arfgf_low_motion_minq_12[QINDEX_RANGE];
static int arfgf_high_motion_minq_12[QINDEX_RANGE];
static int inter_minq_12[QINDEX_RANGE];
static int rtc_minq_12[QINDEX_RANGE];
#endif

static int gf_high = 2000;
static int gf_low = 400;
static int kf_high = 5000;
static int kf_low = 400;

97 98 99 100 101
// How many times less pixels there are to encode given the current scaling.
// Temporary replacement for rcf_mult and rate_thresh_mult.
static double resize_rate_factor(const AV1_COMP *cpi, int width, int height) {
  (void)cpi;
  return (double)(cpi->oxcf.width * cpi->oxcf.height) / (width * height);
102 103
}

Jingning Han's avatar
Jingning Han committed
104 105 106 107 108
// Functions to compute the active minq lookup table entries based on a
// formulaic approach to facilitate easier adjustment of the Q tables.
// The formulae were derived from computing a 3rd order polynomial best
// fit to the original data (after plotting real maxq vs minq (not q index))
static int get_minq_index(double maxq, double x3, double x2, double x1,
109
                          aom_bit_depth_t bit_depth) {
Jingning Han's avatar
Jingning Han committed
110
  int i;
111
  const double minqtarget = AOMMIN(((x3 * maxq + x2) * maxq + x1) * maxq, maxq);
Jingning Han's avatar
Jingning Han committed
112 113 114

  // Special case handling to deal with the step from q2.0
  // down to lossless mode represented by q 1.0.
115
  if (minqtarget <= 2.0) return 0;
Jingning Han's avatar
Jingning Han committed
116 117

  for (i = 0; i < QINDEX_RANGE; i++) {
118
    if (minqtarget <= av1_convert_qindex_to_q(i, bit_depth)) return i;
Jingning Han's avatar
Jingning Han committed
119 120 121 122 123
  }

  return QINDEX_RANGE - 1;
}

124 125
static void init_minq_luts(int *kf_low_m, int *kf_high_m, int *arfgf_low,
                           int *arfgf_high, int *inter, int *rtc,
126
                           aom_bit_depth_t bit_depth) {
Jingning Han's avatar
Jingning Han committed
127 128
  int i;
  for (i = 0; i < QINDEX_RANGE; i++) {
129
    const double maxq = av1_convert_qindex_to_q(i, bit_depth);
Jingning Han's avatar
Jingning Han committed
130 131 132 133 134 135 136 137 138
    kf_low_m[i] = get_minq_index(maxq, 0.000001, -0.0004, 0.150, bit_depth);
    kf_high_m[i] = get_minq_index(maxq, 0.0000021, -0.00125, 0.55, bit_depth);
    arfgf_low[i] = get_minq_index(maxq, 0.0000015, -0.0009, 0.30, bit_depth);
    arfgf_high[i] = get_minq_index(maxq, 0.0000021, -0.00125, 0.55, bit_depth);
    inter[i] = get_minq_index(maxq, 0.00000271, -0.00113, 0.90, bit_depth);
    rtc[i] = get_minq_index(maxq, 0.00000271, -0.00113, 0.70, bit_depth);
  }
}

139
void av1_rc_init_minq_luts(void) {
Jingning Han's avatar
Jingning Han committed
140 141
  init_minq_luts(kf_low_motion_minq_8, kf_high_motion_minq_8,
                 arfgf_low_motion_minq_8, arfgf_high_motion_minq_8,
142
                 inter_minq_8, rtc_minq_8, AOM_BITS_8);
143
#if CONFIG_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
144 145
  init_minq_luts(kf_low_motion_minq_10, kf_high_motion_minq_10,
                 arfgf_low_motion_minq_10, arfgf_high_motion_minq_10,
146
                 inter_minq_10, rtc_minq_10, AOM_BITS_10);
Jingning Han's avatar
Jingning Han committed
147 148
  init_minq_luts(kf_low_motion_minq_12, kf_high_motion_minq_12,
                 arfgf_low_motion_minq_12, arfgf_high_motion_minq_12,
149
                 inter_minq_12, rtc_minq_12, AOM_BITS_12);
Jingning Han's avatar
Jingning Han committed
150 151 152 153 154 155
#endif
}

// These functions use formulaic calculations to make playing with the
// quantizer tables easier. If necessary they can be replaced by lookup
// tables if and when things settle down in the experimental bitstream
156
double av1_convert_qindex_to_q(int qindex, aom_bit_depth_t bit_depth) {
157
// Convert the index to a real Q value (scaled down to match old Q values)
158
#if CONFIG_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
159
  switch (bit_depth) {
160 161 162
    case AOM_BITS_8: return av1_ac_quant_Q3(qindex, 0, bit_depth) / 4.0;
    case AOM_BITS_10: return av1_ac_quant_Q3(qindex, 0, bit_depth) / 16.0;
    case AOM_BITS_12: return av1_ac_quant_Q3(qindex, 0, bit_depth) / 64.0;
Jingning Han's avatar
Jingning Han committed
163
    default:
164
      assert(0 && "bit_depth should be AOM_BITS_8, AOM_BITS_10 or AOM_BITS_12");
Jingning Han's avatar
Jingning Han committed
165 166 167
      return -1.0;
  }
#else
168
  return av1_ac_quant_Q3(qindex, 0, bit_depth) / 4.0;
Jingning Han's avatar
Jingning Han committed
169 170 171
#endif
}

172 173 174
int av1_rc_bits_per_mb(FRAME_TYPE frame_type, int qindex,
                       double correction_factor, aom_bit_depth_t bit_depth) {
  const double q = av1_convert_qindex_to_q(qindex, bit_depth);
Jingning Han's avatar
Jingning Han committed
175 176 177 178 179 180 181 182 183 184
  int enumerator = frame_type == KEY_FRAME ? 2700000 : 1800000;

  assert(correction_factor <= MAX_BPB_FACTOR &&
         correction_factor >= MIN_BPB_FACTOR);

  // q based adjustment to baseline enumerator
  enumerator += (int)(enumerator * q) >> 12;
  return (int)(enumerator * correction_factor / q);
}

185 186 187
int av1_estimate_bits_at_q(FRAME_TYPE frame_type, int q, int mbs,
                           double correction_factor,
                           aom_bit_depth_t bit_depth) {
188
  const int bpm =
189 190
      (int)(av1_rc_bits_per_mb(frame_type, q, correction_factor, bit_depth));
  return AOMMAX(FRAME_OVERHEAD_BITS,
191
                (int)((uint64_t)bpm * mbs) >> BPER_MB_NORMBITS);
Jingning Han's avatar
Jingning Han committed
192 193
}

194
int av1_rc_clamp_pframe_target_size(const AV1_COMP *const cpi, int target) {
Jingning Han's avatar
Jingning Han committed
195
  const RATE_CONTROL *rc = &cpi->rc;
196
  const AV1EncoderConfig *oxcf = &cpi->oxcf;
197
  const int min_frame_target =
198
      AOMMAX(rc->min_frame_bandwidth, rc->avg_frame_bandwidth >> 5);
199
  // Clip the frame target to the minimum setup value.
200
  if (cpi->rc.is_src_frame_alt_ref) {
Jingning Han's avatar
Jingning Han committed
201 202 203 204 205
    // If there is an active ARF at this location use the minimum
    // bits on this frame even if it is a constructed arf.
    // The active maximum quantizer insures that an appropriate
    // number of bits will be spent if needed for constructed ARFs.
    target = min_frame_target;
206 207
  } else if (target < min_frame_target) {
    target = min_frame_target;
Jingning Han's avatar
Jingning Han committed
208
  }
209

Jingning Han's avatar
Jingning Han committed
210
  // Clip the frame target to the maximum allowed value.
211
  if (target > rc->max_frame_bandwidth) target = rc->max_frame_bandwidth;
Jingning Han's avatar
Jingning Han committed
212
  if (oxcf->rc_max_inter_bitrate_pct) {
213 214
    const int max_rate =
        rc->avg_frame_bandwidth * oxcf->rc_max_inter_bitrate_pct / 100;
215
    target = AOMMIN(target, max_rate);
Jingning Han's avatar
Jingning Han committed
216
  }
217

Jingning Han's avatar
Jingning Han committed
218 219 220
  return target;
}

221
int av1_rc_clamp_iframe_target_size(const AV1_COMP *const cpi, int target) {
Jingning Han's avatar
Jingning Han committed
222
  const RATE_CONTROL *rc = &cpi->rc;
223
  const AV1EncoderConfig *oxcf = &cpi->oxcf;
Jingning Han's avatar
Jingning Han committed
224
  if (oxcf->rc_max_intra_bitrate_pct) {
225 226
    const int max_rate =
        rc->avg_frame_bandwidth * oxcf->rc_max_intra_bitrate_pct / 100;
227
    target = AOMMIN(target, max_rate);
Jingning Han's avatar
Jingning Han committed
228
  }
229
  if (target > rc->max_frame_bandwidth) target = rc->max_frame_bandwidth;
Jingning Han's avatar
Jingning Han committed
230 231 232 233
  return target;
}

// Update the buffer level: leaky bucket model.
234 235
static void update_buffer_level(AV1_COMP *cpi, int encoded_frame_size) {
  const AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
236 237
  RATE_CONTROL *const rc = &cpi->rc;

238
  // Non-viewable frames are a special case and are treated as pure overhead.
239 240
  // TODO(zoeliu): To further explore whether we should treat BWDREF_FRAME
  //               differently, since it is a no-show frame.
241
  if (!cm->show_frame && !rc->is_bwd_ref_frame)
Jingning Han's avatar
Jingning Han committed
242
    rc->bits_off_target -= encoded_frame_size;
243
  else
Jingning Han's avatar
Jingning Han committed
244 245 246
    rc->bits_off_target += rc->avg_frame_bandwidth - encoded_frame_size;

  // Clip the buffer level to the maximum specified buffer size.
247
  rc->bits_off_target = AOMMIN(rc->bits_off_target, rc->maximum_buffer_size);
Jingning Han's avatar
Jingning Han committed
248 249 250
  rc->buffer_level = rc->bits_off_target;
}

251 252
int av1_rc_get_default_min_gf_interval(int width, int height,
                                       double framerate) {
Jingning Han's avatar
Jingning Han committed
253 254 255 256 257 258 259 260 261
  // Assume we do not need any constraint lower than 4K 20 fps
  static const double factor_safe = 3840 * 2160 * 20.0;
  const double factor = width * height * framerate;
  const int default_interval =
      clamp((int)(framerate * 0.125), MIN_GF_INTERVAL, MAX_GF_INTERVAL);

  if (factor <= factor_safe)
    return default_interval;
  else
262
    return AOMMAX(default_interval,
263
                  (int)(MIN_GF_INTERVAL * factor / factor_safe + 0.5));
Jingning Han's avatar
Jingning Han committed
264 265 266 267 268 269
  // Note this logic makes:
  // 4K24: 5
  // 4K30: 6
  // 4K60: 12
}

270 271
int av1_rc_get_default_max_gf_interval(double framerate, int min_gf_interval) {
  int interval = AOMMIN(MAX_GF_INTERVAL, (int)(framerate * 0.75));
Jingning Han's avatar
Jingning Han committed
272
  interval += (interval & 0x01);  // Round to even value
273
  return AOMMAX(interval, min_gf_interval);
Jingning Han's avatar
Jingning Han committed
274 275
}

276
void av1_rc_init(const AV1EncoderConfig *oxcf, int pass, RATE_CONTROL *rc) {
Jingning Han's avatar
Jingning Han committed
277 278
  int i;

279
  if (pass == 0 && oxcf->rc_mode == AOM_CBR) {
Jingning Han's avatar
Jingning Han committed
280 281 282
    rc->avg_frame_qindex[KEY_FRAME] = oxcf->worst_allowed_q;
    rc->avg_frame_qindex[INTER_FRAME] = oxcf->worst_allowed_q;
  } else {
283 284 285 286
    rc->avg_frame_qindex[KEY_FRAME] =
        (oxcf->worst_allowed_q + oxcf->best_allowed_q) / 2;
    rc->avg_frame_qindex[INTER_FRAME] =
        (oxcf->worst_allowed_q + oxcf->best_allowed_q) / 2;
Jingning Han's avatar
Jingning Han committed
287 288 289 290 291
  }

  rc->last_q[KEY_FRAME] = oxcf->best_allowed_q;
  rc->last_q[INTER_FRAME] = oxcf->worst_allowed_q;

292
  rc->buffer_level = rc->starting_buffer_level;
Jingning Han's avatar
Jingning Han committed
293 294
  rc->bits_off_target = rc->starting_buffer_level;

295 296
  rc->rolling_target_bits = rc->avg_frame_bandwidth;
  rc->rolling_actual_bits = rc->avg_frame_bandwidth;
Jingning Han's avatar
Jingning Han committed
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
  rc->long_rolling_target_bits = rc->avg_frame_bandwidth;
  rc->long_rolling_actual_bits = rc->avg_frame_bandwidth;

  rc->total_actual_bits = 0;
  rc->total_target_bits = 0;
  rc->total_target_vs_actual = 0;

  rc->frames_since_key = 8;  // Sensible default for first frame.
  rc->this_key_frame_forced = 0;
  rc->next_key_frame_forced = 0;
  rc->source_alt_ref_pending = 0;
  rc->source_alt_ref_active = 0;

  rc->frames_till_gf_update_due = 0;
  rc->ni_av_qi = oxcf->worst_allowed_q;
  rc->ni_tot_qi = 0;
  rc->ni_frames = 0;

  rc->tot_q = 0.0;
316
  rc->avg_q = av1_convert_qindex_to_q(oxcf->worst_allowed_q, oxcf->bit_depth);
Jingning Han's avatar
Jingning Han committed
317 318 319 320 321 322 323 324

  for (i = 0; i < RATE_FACTOR_LEVELS; ++i) {
    rc->rate_correction_factors[i] = 1.0;
  }

  rc->min_gf_interval = oxcf->min_gf_interval;
  rc->max_gf_interval = oxcf->max_gf_interval;
  if (rc->min_gf_interval == 0)
325
    rc->min_gf_interval = av1_rc_get_default_min_gf_interval(
Jingning Han's avatar
Jingning Han committed
326 327
        oxcf->width, oxcf->height, oxcf->init_framerate);
  if (rc->max_gf_interval == 0)
328
    rc->max_gf_interval = av1_rc_get_default_max_gf_interval(
Jingning Han's avatar
Jingning Han committed
329 330 331 332
        oxcf->init_framerate, rc->min_gf_interval);
  rc->baseline_gf_interval = (rc->min_gf_interval + rc->max_gf_interval) / 2;
}

333 334
int av1_rc_drop_frame(AV1_COMP *cpi) {
  const AV1EncoderConfig *oxcf = &cpi->oxcf;
Jingning Han's avatar
Jingning Han committed
335 336 337 338 339 340 341 342 343 344 345
  RATE_CONTROL *const rc = &cpi->rc;

  if (!oxcf->drop_frames_water_mark) {
    return 0;
  } else {
    if (rc->buffer_level < 0) {
      // Always drop if buffer is below 0.
      return 1;
    } else {
      // If buffer is below drop_mark, for now just drop every other frame
      // (starting with the next frame) until it increases back over drop_mark.
346 347 348
      int drop_mark =
          (int)(oxcf->drop_frames_water_mark * rc->optimal_buffer_level / 100);
      if ((rc->buffer_level > drop_mark) && (rc->decimation_factor > 0)) {
Jingning Han's avatar
Jingning Han committed
349
        --rc->decimation_factor;
350
      } else if (rc->buffer_level <= drop_mark && rc->decimation_factor == 0) {
Jingning Han's avatar
Jingning Han committed
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
        rc->decimation_factor = 1;
      }
      if (rc->decimation_factor > 0) {
        if (rc->decimation_count > 0) {
          --rc->decimation_count;
          return 1;
        } else {
          rc->decimation_count = rc->decimation_factor;
          return 0;
        }
      } else {
        rc->decimation_count = 0;
        return 0;
      }
    }
  }
}

369 370
static double get_rate_correction_factor(const AV1_COMP *cpi, int width,
                                         int height) {
Jingning Han's avatar
Jingning Han committed
371 372 373 374 375 376 377
  const RATE_CONTROL *const rc = &cpi->rc;
  double rcf;

  if (cpi->common.frame_type == KEY_FRAME) {
    rcf = rc->rate_correction_factors[KF_STD];
  } else if (cpi->oxcf.pass == 2) {
    RATE_FACTOR_LEVEL rf_lvl =
378
        cpi->twopass.gf_group.rf_level[cpi->twopass.gf_group.index];
Jingning Han's avatar
Jingning Han committed
379 380 381
    rcf = rc->rate_correction_factors[rf_lvl];
  } else {
    if ((cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) &&
Yunqing Wang's avatar
Yunqing Wang committed
382
        !rc->is_src_frame_alt_ref &&
383
        (cpi->oxcf.rc_mode != AOM_CBR || cpi->oxcf.gf_cbr_boost_pct > 20))
Jingning Han's avatar
Jingning Han committed
384 385 386 387
      rcf = rc->rate_correction_factors[GF_ARF_STD];
    else
      rcf = rc->rate_correction_factors[INTER_NORMAL];
  }
388
  rcf *= resize_rate_factor(cpi, width, height);
Jingning Han's avatar
Jingning Han committed
389 390 391
  return fclamp(rcf, MIN_BPB_FACTOR, MAX_BPB_FACTOR);
}

392 393
static void set_rate_correction_factor(AV1_COMP *cpi, double factor, int width,
                                       int height) {
Jingning Han's avatar
Jingning Han committed
394 395 396
  RATE_CONTROL *const rc = &cpi->rc;

  // Normalize RCF to account for the size-dependent scaling factor.
397
  factor /= resize_rate_factor(cpi, width, height);
Jingning Han's avatar
Jingning Han committed
398 399 400 401 402 403 404

  factor = fclamp(factor, MIN_BPB_FACTOR, MAX_BPB_FACTOR);

  if (cpi->common.frame_type == KEY_FRAME) {
    rc->rate_correction_factors[KF_STD] = factor;
  } else if (cpi->oxcf.pass == 2) {
    RATE_FACTOR_LEVEL rf_lvl =
405
        cpi->twopass.gf_group.rf_level[cpi->twopass.gf_group.index];
Jingning Han's avatar
Jingning Han committed
406 407 408
    rc->rate_correction_factors[rf_lvl] = factor;
  } else {
    if ((cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) &&
Yunqing Wang's avatar
Yunqing Wang committed
409
        !rc->is_src_frame_alt_ref &&
410
        (cpi->oxcf.rc_mode != AOM_CBR || cpi->oxcf.gf_cbr_boost_pct > 20))
Jingning Han's avatar
Jingning Han committed
411 412 413 414 415 416
      rc->rate_correction_factors[GF_ARF_STD] = factor;
    else
      rc->rate_correction_factors[INTER_NORMAL] = factor;
  }
}

417 418
void av1_rc_update_rate_correction_factors(AV1_COMP *cpi, int width,
                                           int height) {
419
  const AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
420
  int correction_factor = 100;
421 422
  double rate_correction_factor =
      get_rate_correction_factor(cpi, width, height);
Jingning Han's avatar
Jingning Han committed
423
  double adjustment_limit;
424
  const int MBs = av1_get_MBs(width, height);
Jingning Han's avatar
Jingning Han committed
425 426 427 428

  int projected_size_based_on_q = 0;

  // Do not update the rate factors for arf overlay frames.
429
  if (cpi->rc.is_src_frame_alt_ref) return;
Jingning Han's avatar
Jingning Han committed
430 431

  // Clear down mmx registers to allow floating point in what follows
432
  aom_clear_system_state();
Jingning Han's avatar
Jingning Han committed
433 434 435 436 437 438

  // Work out how big we would have expected the frame to be at this Q given
  // the current correction factor.
  // Stay in double to avoid int overflow when values are large
  if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && cpi->common.seg.enabled) {
    projected_size_based_on_q =
439
        av1_cyclic_refresh_estimate_bits_at_q(cpi, rate_correction_factor);
Jingning Han's avatar
Jingning Han committed
440
  } else {
441
    projected_size_based_on_q =
442
        av1_estimate_bits_at_q(cpi->common.frame_type, cm->base_qindex, MBs,
443
                               rate_correction_factor, cm->bit_depth);
Jingning Han's avatar
Jingning Han committed
444 445 446 447
  }
  // Work out a size correction factor.
  if (projected_size_based_on_q > FRAME_OVERHEAD_BITS)
    correction_factor = (int)((100 * (int64_t)cpi->rc.projected_frame_size) /
448
                              projected_size_based_on_q);
Jingning Han's avatar
Jingning Han committed
449 450 451

  // More heavily damped adjustment used if we have been oscillating either side
  // of target.
452 453 454 455 456 457
  if (correction_factor > 0) {
    adjustment_limit =
        0.25 + 0.5 * AOMMIN(1, fabs(log10(0.01 * correction_factor)));
  } else {
    adjustment_limit = 0.75;
  }
Jingning Han's avatar
Jingning Han committed
458 459 460 461 462 463 464 465 466 467 468 469 470

  cpi->rc.q_2_frame = cpi->rc.q_1_frame;
  cpi->rc.q_1_frame = cm->base_qindex;
  cpi->rc.rc_2_frame = cpi->rc.rc_1_frame;
  if (correction_factor > 110)
    cpi->rc.rc_1_frame = -1;
  else if (correction_factor < 90)
    cpi->rc.rc_1_frame = 1;
  else
    cpi->rc.rc_1_frame = 0;

  if (correction_factor > 102) {
    // We are not already at the worst allowable quality
471 472
    correction_factor =
        (int)(100 + ((correction_factor - 100) * adjustment_limit));
Jingning Han's avatar
Jingning Han committed
473 474 475 476 477 478
    rate_correction_factor = (rate_correction_factor * correction_factor) / 100;
    // Keep rate_correction_factor within limits
    if (rate_correction_factor > MAX_BPB_FACTOR)
      rate_correction_factor = MAX_BPB_FACTOR;
  } else if (correction_factor < 99) {
    // We are not already at the best allowable quality
479 480
    correction_factor =
        (int)(100 - ((100 - correction_factor) * adjustment_limit));
Jingning Han's avatar
Jingning Han committed
481 482 483 484 485 486 487
    rate_correction_factor = (rate_correction_factor * correction_factor) / 100;

    // Keep rate_correction_factor within limits
    if (rate_correction_factor < MIN_BPB_FACTOR)
      rate_correction_factor = MIN_BPB_FACTOR;
  }

488
  set_rate_correction_factor(cpi, rate_correction_factor, width, height);
Jingning Han's avatar
Jingning Han committed
489 490
}

491
int av1_rc_regulate_q(const AV1_COMP *cpi, int target_bits_per_frame,
492 493
                      int active_best_quality, int active_worst_quality,
                      int width, int height) {
494
  const AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
495 496 497
  int q = active_worst_quality;
  int last_error = INT_MAX;
  int i, target_bits_per_mb, bits_per_mb_at_this_q;
498 499 500
  const int MBs = av1_get_MBs(width, height);
  const double correction_factor =
      get_rate_correction_factor(cpi, width, height);
Jingning Han's avatar
Jingning Han committed
501 502 503 504

  // Calculate required scaling factor based on target frame size and size of
  // frame produced using previous Q.
  target_bits_per_mb =
505
      (int)((uint64_t)(target_bits_per_frame) << BPER_MB_NORMBITS) / MBs;
Jingning Han's avatar
Jingning Han committed
506 507 508 509

  i = active_best_quality;

  do {
Yunqing Wang's avatar
Yunqing Wang committed
510
    if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && cm->seg.enabled) {
Jingning Han's avatar
Jingning Han committed
511
      bits_per_mb_at_this_q =
512
          (int)av1_cyclic_refresh_rc_bits_per_mb(cpi, i, correction_factor);
Jingning Han's avatar
Jingning Han committed
513
    } else {
514
      bits_per_mb_at_this_q = (int)av1_rc_bits_per_mb(
515
          cm->frame_type, i, correction_factor, cm->bit_depth);
Jingning Han's avatar
Jingning Han committed
516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
    }

    if (bits_per_mb_at_this_q <= target_bits_per_mb) {
      if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
        q = i;
      else
        q = i - 1;

      break;
    } else {
      last_error = bits_per_mb_at_this_q - target_bits_per_mb;
    }
  } while (++i <= active_worst_quality);

  // In CBR mode, this makes sure q is between oscillating Qs to prevent
  // resonance.
532
  if (cpi->oxcf.rc_mode == AOM_CBR &&
Jingning Han's avatar
Jingning Han committed
533 534
      (cpi->rc.rc_1_frame * cpi->rc.rc_2_frame == -1) &&
      cpi->rc.q_1_frame != cpi->rc.q_2_frame) {
535 536
    q = clamp(q, AOMMIN(cpi->rc.q_1_frame, cpi->rc.q_2_frame),
              AOMMAX(cpi->rc.q_1_frame, cpi->rc.q_2_frame));
Jingning Han's avatar
Jingning Han committed
537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
  }
  return q;
}

static int get_active_quality(int q, int gfu_boost, int low, int high,
                              int *low_motion_minq, int *high_motion_minq) {
  if (gfu_boost > high) {
    return low_motion_minq[q];
  } else if (gfu_boost < low) {
    return high_motion_minq[q];
  } else {
    const int gap = high - low;
    const int offset = high - gfu_boost;
    const int qdiff = high_motion_minq[q] - low_motion_minq[q];
    const int adjustment = ((offset * qdiff) + (gap >> 1)) / gap;
    return low_motion_minq[q] + adjustment;
  }
}

static int get_kf_active_quality(const RATE_CONTROL *const rc, int q,
557
                                 aom_bit_depth_t bit_depth) {
Jingning Han's avatar
Jingning Han committed
558 559 560 561 562 563 564 565 566
  int *kf_low_motion_minq;
  int *kf_high_motion_minq;
  ASSIGN_MINQ_TABLE(bit_depth, kf_low_motion_minq);
  ASSIGN_MINQ_TABLE(bit_depth, kf_high_motion_minq);
  return get_active_quality(q, rc->kf_boost, kf_low, kf_high,
                            kf_low_motion_minq, kf_high_motion_minq);
}

static int get_gf_active_quality(const RATE_CONTROL *const rc, int q,
567
                                 aom_bit_depth_t bit_depth) {
Jingning Han's avatar
Jingning Han committed
568 569 570 571 572 573 574 575
  int *arfgf_low_motion_minq;
  int *arfgf_high_motion_minq;
  ASSIGN_MINQ_TABLE(bit_depth, arfgf_low_motion_minq);
  ASSIGN_MINQ_TABLE(bit_depth, arfgf_high_motion_minq);
  return get_active_quality(q, rc->gfu_boost, gf_low, gf_high,
                            arfgf_low_motion_minq, arfgf_high_motion_minq);
}

576
static int calc_active_worst_quality_one_pass_vbr(const AV1_COMP *cpi) {
Jingning Han's avatar
Jingning Han committed
577 578 579 580 581
  const RATE_CONTROL *const rc = &cpi->rc;
  const unsigned int curr_frame = cpi->common.current_video_frame;
  int active_worst_quality;

  if (cpi->common.frame_type == KEY_FRAME) {
582 583
    active_worst_quality =
        curr_frame == 0 ? rc->worst_quality : rc->last_q[KEY_FRAME] * 2;
Jingning Han's avatar
Jingning Han committed
584
  } else {
585 586 587
    if (!rc->is_src_frame_alt_ref &&
        (cpi->refresh_golden_frame || cpi->refresh_alt2_ref_frame ||
         cpi->refresh_alt_ref_frame)) {
588 589
      active_worst_quality = curr_frame == 1 ? rc->last_q[KEY_FRAME] * 5 / 4
                                             : rc->last_q[INTER_FRAME];
Jingning Han's avatar
Jingning Han committed
590 591 592 593 594
    } else {
      active_worst_quality = curr_frame == 1 ? rc->last_q[KEY_FRAME] * 2
                                             : rc->last_q[INTER_FRAME] * 2;
    }
  }
595
  return AOMMIN(active_worst_quality, rc->worst_quality);
Jingning Han's avatar
Jingning Han committed
596 597 598
}

// Adjust active_worst_quality level based on buffer level.
599
static int calc_active_worst_quality_one_pass_cbr(const AV1_COMP *cpi) {
Jingning Han's avatar
Jingning Han committed
600 601 602 603 604
  // Adjust active_worst_quality: If buffer is above the optimal/target level,
  // bring active_worst_quality down depending on fullness of buffer.
  // If buffer is below the optimal level, let the active_worst_quality go from
  // ambient Q (at buffer = optimal level) to worst_quality level
  // (at buffer = critical level).
605
  const AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
606 607 608 609 610 611 612
  const RATE_CONTROL *rc = &cpi->rc;
  // Buffer level below which we push active_worst to worst_quality.
  int64_t critical_level = rc->optimal_buffer_level >> 3;
  int64_t buff_lvl_step = 0;
  int adjustment = 0;
  int active_worst_quality;
  int ambient_qp;
613
  if (cm->frame_type == KEY_FRAME) return rc->worst_quality;
Jingning Han's avatar
Jingning Han committed
614 615 616 617 618
  // For ambient_qp we use minimum of avg_frame_qindex[KEY_FRAME/INTER_FRAME]
  // for the first few frames following key frame. These are both initialized
  // to worst_quality and updated with (3/4, 1/4) average in postencode_update.
  // So for first few frames following key, the qp of that key frame is weighted
  // into the active_worst_quality setting.
619
  ambient_qp = (cm->current_video_frame < 5)
620
                   ? AOMMIN(rc->avg_frame_qindex[INTER_FRAME],
621 622
                            rc->avg_frame_qindex[KEY_FRAME])
                   : rc->avg_frame_qindex[INTER_FRAME];
623
  active_worst_quality = AOMMIN(rc->worst_quality, ambient_qp * 5 / 4);
Jingning Han's avatar
Jingning Han committed
624 625 626 627 628
  if (rc->buffer_level > rc->optimal_buffer_level) {
    // Adjust down.
    // Maximum limit for down adjustment, ~30%.
    int max_adjustment_down = active_worst_quality / 3;
    if (max_adjustment_down) {
629 630
      buff_lvl_step = ((rc->maximum_buffer_size - rc->optimal_buffer_level) /
                       max_adjustment_down);
Jingning Han's avatar
Jingning Han committed
631 632
      if (buff_lvl_step)
        adjustment = (int)((rc->buffer_level - rc->optimal_buffer_level) /
633
                           buff_lvl_step);
Jingning Han's avatar
Jingning Han committed
634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653
      active_worst_quality -= adjustment;
    }
  } else if (rc->buffer_level > critical_level) {
    // Adjust up from ambient Q.
    if (critical_level) {
      buff_lvl_step = (rc->optimal_buffer_level - critical_level);
      if (buff_lvl_step) {
        adjustment = (int)((rc->worst_quality - ambient_qp) *
                           (rc->optimal_buffer_level - rc->buffer_level) /
                           buff_lvl_step);
      }
      active_worst_quality = ambient_qp + adjustment;
    }
  } else {
    // Set to worst_quality if buffer is below critical level.
    active_worst_quality = rc->worst_quality;
  }
  return active_worst_quality;
}

654 655
static int rc_pick_q_and_bounds_one_pass_cbr(const AV1_COMP *cpi, int width,
                                             int height, int *bottom_index,
Jingning Han's avatar
Jingning Han committed
656
                                             int *top_index) {
657
  const AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
658 659 660 661 662 663 664 665 666 667 668 669 670 671
  const RATE_CONTROL *const rc = &cpi->rc;
  int active_best_quality;
  int active_worst_quality = calc_active_worst_quality_one_pass_cbr(cpi);
  int q;
  int *rtc_minq;
  ASSIGN_MINQ_TABLE(cm->bit_depth, rtc_minq);

  if (frame_is_intra_only(cm)) {
    active_best_quality = rc->best_quality;
    // Handle the special case for key frames forced when we have reached
    // the maximum key frame interval. Here force the Q to a range
    // based on the ambient Q to reduce the risk of popping.
    if (rc->this_key_frame_forced) {
      int qindex = rc->last_boosted_qindex;
672 673
      double last_boosted_q = av1_convert_qindex_to_q(qindex, cm->bit_depth);
      int delta_qindex = av1_compute_qdelta(
674
          rc, last_boosted_q, (last_boosted_q * 0.75), cm->bit_depth);
675
      active_best_quality = AOMMAX(qindex + delta_qindex, rc->best_quality);
Jingning Han's avatar
Jingning Han committed
676 677 678 679 680
    } else if (cm->current_video_frame > 0) {
      // not first frame of one pass and kf_boost is set
      double q_adj_factor = 1.0;
      double q_val;

681 682
      active_best_quality = get_kf_active_quality(
          rc, rc->avg_frame_qindex[KEY_FRAME], cm->bit_depth);
Jingning Han's avatar
Jingning Han committed
683 684

      // Allow somewhat lower kf minq with small image formats.
685
      if ((width * height) <= (352 * 288)) {
Jingning Han's avatar
Jingning Han committed
686 687 688 689 690
        q_adj_factor -= 0.25;
      }

      // Convert the adjustment factor to a qindex delta
      // on active_best_quality.
691
      q_val = av1_convert_qindex_to_q(active_best_quality, cm->bit_depth);
692
      active_best_quality +=
693
          av1_compute_qdelta(rc, q_val, q_val * q_adj_factor, cm->bit_depth);
Jingning Han's avatar
Jingning Han committed
694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722
    }
  } else if (!rc->is_src_frame_alt_ref &&
             (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
    // Use the lower of active_worst_quality and recent
    // average Q as basis for GF/ARF best Q limit unless last frame was
    // a key frame.
    if (rc->frames_since_key > 1 &&
        rc->avg_frame_qindex[INTER_FRAME] < active_worst_quality) {
      q = rc->avg_frame_qindex[INTER_FRAME];
    } else {
      q = active_worst_quality;
    }
    active_best_quality = get_gf_active_quality(rc, q, cm->bit_depth);
  } else {
    // Use the lower of active_worst_quality and recent/average Q.
    if (cm->current_video_frame > 1) {
      if (rc->avg_frame_qindex[INTER_FRAME] < active_worst_quality)
        active_best_quality = rtc_minq[rc->avg_frame_qindex[INTER_FRAME]];
      else
        active_best_quality = rtc_minq[active_worst_quality];
    } else {
      if (rc->avg_frame_qindex[KEY_FRAME] < active_worst_quality)
        active_best_quality = rtc_minq[rc->avg_frame_qindex[KEY_FRAME]];
      else
        active_best_quality = rtc_minq[active_worst_quality];
    }
  }

  // Clip the active best and worst quality values to limits
723 724 725 726
  active_best_quality =
      clamp(active_best_quality, rc->best_quality, rc->worst_quality);
  active_worst_quality =
      clamp(active_worst_quality, active_best_quality, rc->worst_quality);
Jingning Han's avatar
Jingning Han committed
727 728 729 730 731

  *top_index = active_worst_quality;
  *bottom_index = active_best_quality;

  // Limit Q range for the adaptive loop.
732
  if (cm->frame_type == KEY_FRAME && !rc->this_key_frame_forced &&
Jingning Han's avatar
Jingning Han committed
733 734
      !(cm->current_video_frame == 0)) {
    int qdelta = 0;
735 736
    aom_clear_system_state();
    qdelta = av1_compute_qdelta_by_rate(
737
        &cpi->rc, cm->frame_type, active_worst_quality, 2.0, cm->bit_depth);
Jingning Han's avatar
Jingning Han committed
738
    *top_index = active_worst_quality + qdelta;
739
    *top_index = AOMMAX(*top_index, *bottom_index);
Jingning Han's avatar
Jingning Han committed
740 741 742 743 744 745
  }

  // Special case code to try and match quality with forced key frames
  if (cm->frame_type == KEY_FRAME && rc->this_key_frame_forced) {
    q = rc->last_boosted_qindex;
  } else {
746
    q = av1_rc_regulate_q(cpi, rc->this_frame_target, active_best_quality,
747
                          active_worst_quality, width, height);
Jingning Han's avatar
Jingning Han committed
748 749 750 751 752 753 754 755
    if (q > *top_index) {
      // Special case when we are targeting the max allowed rate
      if (rc->this_frame_target >= rc->max_frame_bandwidth)
        *top_index = q;
      else
        q = *top_index;
    }
  }
756

757
  assert(*top_index <= rc->worst_quality && *top_index >= rc->best_quality);
Jingning Han's avatar
Jingning Han committed
758 759 760 761 762 763 764
  assert(*bottom_index <= rc->worst_quality &&
         *bottom_index >= rc->best_quality);
  assert(q <= rc->worst_quality && q >= rc->best_quality);
  return q;
}

static int get_active_cq_level(const RATE_CONTROL *rc,
765
                               const AV1EncoderConfig *const oxcf) {
Jingning Han's avatar
Jingning Han committed
766 767
  static const double cq_adjust_threshold = 0.1;
  int active_cq_level = oxcf->cq_level;
768
  if (oxcf->rc_mode == AOM_CQ && rc->total_target_bits > 0) {
Jingning Han's avatar
Jingning Han committed
769 770 771 772 773 774 775 776
    const double x = (double)rc->total_actual_bits / rc->total_target_bits;
    if (x < cq_adjust_threshold) {
      active_cq_level = (int)(active_cq_level * x / cq_adjust_threshold);
    }
  }
  return active_cq_level;
}

777 778
static int rc_pick_q_and_bounds_one_pass_vbr(const AV1_COMP *cpi, int width,
                                             int height, int *bottom_index,
Jingning Han's avatar
Jingning Han committed
779
                                             int *top_index) {
780
  const AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
781
  const RATE_CONTROL *const rc = &cpi->rc;
782
  const AV1EncoderConfig *const oxcf = &cpi->oxcf;
Jingning Han's avatar
Jingning Han committed
783 784 785 786 787 788 789 790
  const int cq_level = get_active_cq_level(rc, oxcf);
  int active_best_quality;
  int active_worst_quality = calc_active_worst_quality_one_pass_vbr(cpi);
  int q;
  int *inter_minq;
  ASSIGN_MINQ_TABLE(cm->bit_depth, inter_minq);

  if (frame_is_intra_only(cm)) {
791
    if (oxcf->rc_mode == AOM_Q) {
792 793 794 795
      const int qindex = cq_level;
      const double q_val = av1_convert_qindex_to_q(qindex, cm->bit_depth);
      const int delta_qindex =
          av1_compute_qdelta(rc, q_val, q_val * 0.25, cm->bit_depth);
796
      active_best_quality = AOMMAX(qindex + delta_qindex, rc->best_quality);
797
    } else if (rc->this_key_frame_forced) {
798 799 800 801
      const int qindex = rc->last_boosted_qindex;
      const double last_boosted_q =
          av1_convert_qindex_to_q(qindex, cm->bit_depth);
      const int delta_qindex = av1_compute_qdelta(
802
          rc, last_boosted_q, last_boosted_q * 0.75, cm->bit_depth);
803
      active_best_quality = AOMMAX(qindex + delta_qindex, rc->best_quality);
804
    } else {  // not first frame of one pass and kf_boost is set
Jingning Han's avatar
Jingning Han committed
805 806
      double q_adj_factor = 1.0;

807 808
      active_best_quality = get_kf_active_quality(
          rc, rc->avg_frame_qindex[KEY_FRAME], cm->bit_depth);
Jingning Han's avatar
Jingning Han committed
809 810

      // Allow somewhat lower kf minq with small image formats.
811
      if ((width * height) <= (352 * 288)) {
Jingning Han's avatar
Jingning Han committed
812 813 814
        q_adj_factor -= 0.25;
      }

815 816 817 818 819 820 821
      // Convert the adjustment factor to a qindex delta on active_best_quality.
      {
        const double q_val =
            av1_convert_qindex_to_q(active_best_quality, cm->bit_depth);
        active_best_quality +=
            av1_compute_qdelta(rc, q_val, q_val * q_adj_factor, cm->bit_depth);
      }
Jingning Han's avatar
Jingning Han committed
822 823 824 825 826 827
    }
  } else if (!rc->is_src_frame_alt_ref &&
             (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
    // Use the lower of active_worst_quality and recent
    // average Q as basis for GF/ARF best Q limit unless last frame was
    // a key frame.
828 829 830 831
    q = (rc->frames_since_key > 1 &&
         rc->avg_frame_qindex[INTER_FRAME] < active_worst_quality)
            ? rc->avg_frame_qindex[INTER_FRAME]
            : rc->avg_frame_qindex[KEY_FRAME];
Jingning Han's avatar
Jingning Han committed
832
    // For constrained quality dont allow Q less than the cq level
833
    if (oxcf->rc_mode == AOM_CQ) {
834
      if (q < cq_level) q = cq_level;
Jingning Han's avatar
Jingning Han committed
835 836 837
      active_best_quality = get_gf_active_quality(rc, q, cm->bit_depth);
      // Constrained quality use slightly lower active best.
      active_best_quality = active_best_quality * 15 / 16;
838
    } else if (oxcf->rc_mode == AOM_Q) {
839 840 841 842 843 844
      const int qindex = cq_level;
      const double q_val = av1_convert_qindex_to_q(qindex, cm->bit_depth);
      const int delta_qindex =
          (cpi->refresh_alt_ref_frame)
              ? av1_compute_qdelta(rc, q_val, q_val * 0.40, cm->bit_depth)
              : av1_compute_qdelta(rc, q_val, q_val * 0.50, cm->bit_depth);
845
      active_best_quality = AOMMAX(qindex + delta_qindex, rc->best_quality);
Jingning Han's avatar
Jingning Han committed
846 847 848 849
    } else {
      active_best_quality = get_gf_active_quality(rc, q, cm->bit_depth);
    }
  } else {
850
    if (oxcf->rc_mode == AOM_Q) {
851 852 853 854 855 856 857
      const int qindex = cq_level;
      const double q_val = av1_convert_qindex_to_q(qindex, cm->bit_depth);
      const double delta_rate[FIXED_GF_INTERVAL] = { 0.50, 1.0, 0.85, 1.0,
                                                     0.70, 1.0, 0.85, 1.0 };
      const int delta_qindex = av1_compute_qdelta(
          rc, q_val,
          q_val * delta_rate[cm->current_video_frame % FIXED_GF_INTERVAL],
858
          cm->bit_depth);
859
      active_best_quality = AOMMAX(qindex + delta_qindex, rc->best_quality);
Jingning Han's avatar
Jingning Han committed
860 861
    } else {
      // Use the lower of active_worst_quality and recent/average Q.
862 863 864
      active_best_quality = (cm->current_video_frame > 1)
                                ? inter_minq[rc->avg_frame_qindex[INTER_FRAME]]
                                : inter_minq[rc->avg_frame_qindex[KEY_FRAME]];
Jingning Han's avatar
Jingning Han committed
865 866
      // For the constrained quality mode we don't want
      // q to fall below the cq level.
867
      if ((oxcf->rc_mode == AOM_CQ) && (active_best_quality < cq_level)) {
Jingning Han's avatar
Jingning Han committed
868 869 870 871 872 873
        active_best_quality = cq_level;
      }
    }
  }

  // Clip the active best and worst quality values to limits
874 875 876 877
  active_best_quality =
      clamp(active_best_quality, rc->best_quality, rc->worst_quality);
  active_worst_quality =
      clamp(active_worst_quality, active_best_quality, rc->worst_quality);
Jingning Han's avatar
Jingning Han committed
878 879 880 881

  *top_index = active_worst_quality;
  *bottom_index = active_best_quality;

882
  // Limit Q range for the adaptive loop.
Jingning Han's avatar
Jingning Han committed
883 884
  {
    int qdelta = 0;
885
    aom_clear_system_state();
886
    if (cm->frame_type == KEY_FRAME && !rc->this_key_frame_forced &&
Jingning Han's avatar
Jingning Han committed
887
        !(cm->current_video_frame == 0)) {
888
      qdelta = av1_compute_qdelta_by_rate(
889
          &cpi->rc, cm->frame_type, active_worst_quality, 2.0, cm->bit_depth);
Jingning Han's avatar
Jingning Han committed
890 891
    } else if (!rc->is_src_frame_alt_ref &&
               (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
892
      qdelta = av1_compute_qdelta_by_rate(
893
          &cpi->rc, cm->frame_type, active_worst_quality, 1.75, cm->bit_depth);
Jingning Han's avatar
Jingning Han committed
894 895
    }
    *top_index = active_worst_quality + qdelta;
896
    *top_index = AOMMAX(*top_index, *bottom_index);
Jingning Han's avatar
Jingning Han committed
897 898
  }

899
  if (oxcf->rc_mode == AOM_Q) {
Jingning Han's avatar
Jingning Han committed
900
    q = active_best_quality;
901
    // Special case code to try and match quality with forced key frames
Jingning Han's avatar
Jingning Han committed
902 903 904
  } else if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced) {
    q = rc->last_boosted_qindex;
  } else {
905
    q = av1_rc_regulate_q(cpi, rc->this_frame_target, active_best_quality,
906
                          active_worst_quality, width, height);
Jingning Han's avatar
Jingning Han committed
907 908 909 910 911 912 913 914 915
    if (q > *top_index) {
      // Special case when we are targeting the max allowed rate
      if (rc->this_frame_target >= rc->max_frame_bandwidth)
        *top_index = q;
      else
        q = *top_index;
    }
  }

916
  assert(*top_index <= rc->worst_quality && *top_index >= rc->best_quality);
Jingning Han's avatar
Jingning Han committed
917 918 919 920 921 922
  assert(*bottom_index <= rc->worst_quality &&
         *bottom_index >= rc->best_quality);
  assert(q <= rc->worst_quality && q >= rc->best_quality);
  return q;
}

923
int av1_frame_type_qdelta(const AV1_COMP *cpi, int rf_level, int q) {
924 925 926
  static const FRAME_TYPE frame_type[RATE_FACTOR_LEVELS] = {
    INTER_FRAME, INTER_FRAME, INTER_FRAME, INTER_FRAME, INTER_FRAME, KEY_FRAME
  };
927
  const AV1_COMMON *const cm = &cpi->common;
928
  int qdelta =
929 930
      av1_compute_qdelta_by_rate(&cpi->rc, frame_type[rf_level], q,
                                 rate_factor_deltas[rf_level], cm->bit_depth);
Jingning Han's avatar
Jingning Han committed
931 932 933 934
  return qdelta;
}

#define STATIC_MOTION_THRESH 95
935 936
static int rc_pick_q_and_bounds_two_pass(const AV1_COMP *cpi, int width,
                                         int height, int *bottom_index,
937 938
                                         int *top_index) {
  const AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
939
  const RATE_CONTROL *const rc = &cpi->rc;
940
  const AV1EncoderConfig *const oxcf = &cpi->oxcf;
Jingning Han's avatar
Jingning Han committed
941 942 943 944 945 946 947 948
  const GF_GROUP *gf_group = &cpi->twopass.gf_group;
  const int cq_level = get_active_cq_level(rc, oxcf);
  int active_best_quality;
  int active_worst_quality = cpi->twopass.active_worst_quality;
  int q;
  int *inter_minq;
  ASSIGN_MINQ_TABLE(cm->bit_depth, inter_minq);

Yunqing Wang's avatar
Yunqing Wang committed
949
  if (frame_is_intra_only(cm)) {
Jingning Han's avatar
Jingning Han committed
950 951 952 953 954 955 956 957 958
    // Handle the special case for key frames forced when we have reached
    // the maximum key frame interval. Here force the Q to a range
    // based on the ambient Q to reduce the risk of popping.
    if (rc->this_key_frame_forced) {
      double last_boosted_q;
      int delta_qindex;
      int qindex;

      if (cpi->twopass.last_kfgroup_zeromotion_pct >= STATIC_MOTION_THRESH) {
959
        qindex = AOMMIN(rc->last_kf_qindex, rc->last_boosted_qindex);
Jingning Han's avatar
Jingning Han committed
960
        active_best_quality = qindex;
961 962 963
        last_boosted_q = av1_convert_qindex_to_q(qindex, cm->bit_depth);
        delta_qindex = av1_compute_qdelta(rc, last_boosted_q,
                                          last_boosted_q * 1.25, cm->bit_depth);
964
        active_worst_quality =
965
            AOMMIN(qindex + delta_qindex, active_worst_quality);
Jingning Han's avatar
Jingning Han committed
966 967
      } else {
        qindex = rc->last_boosted_qindex;
968 969 970 971
        last_boosted_q = av1_convert_qindex_to_q(qindex, cm->bit_depth);
        delta_qindex = av1_compute_qdelta(rc, last_boosted_q,
                                          last_boosted_q * 0.75, cm->bit_depth);
        active_best_quality = AOMMAX(qindex + delta_qindex, rc->best_quality);
Jingning Han's avatar
Jingning Han committed
972 973 974 975 976
      }
    } else {
      // Not forced keyframe.
      double q_adj_factor = 1.0;
      double q_val;
977

Jingning Han's avatar
Jingning Han committed
978
      // Baseline value derived from cpi->active_worst_quality and kf boost.
979 980
      active_best_quality =
          get_kf_active_quality(rc, active_worst_quality, cm->bit_depth);
Jingning Han's avatar
Jingning Han committed
981 982

      // Allow somewhat lower kf minq with small image formats.
983
      if ((width * height) <= (352 * 288)) {
Jingning Han's avatar
Jingning Han committed
984 985 986 987 988 989 990 991
        q_adj_factor -= 0.25;
      }

      // Make a further adjustment based on the kf zero motion measure.
      q_adj_factor += 0.05 - (0.001 * (double)cpi->twopass.kf_zeromotion_pct);

      // Convert the adjustment factor to a qindex delta
      // on active_best_quality.
992
      q_val = av1_convert_qindex_to_q(active_best_quality, cm->bit_depth);
993
      active_best_quality +=
994
          av1_compute_qdelta(rc, q_val, q_val * q_adj_factor, cm->bit_depth);
Jingning Han's avatar
Jingning Han committed
995
    }
996 997 998
  } else if (!rc->is_src_frame_alt_ref &&
             (cpi->refresh_golden_frame || cpi->refresh_alt2_ref_frame ||
              cpi->refresh_alt_ref_frame)) {
Jingning Han's avatar
Jingning Han committed
999 1000 1001 1002 1003 1004 1005 1006 1007 1008
    // Use the lower of active_worst_quality and recent
    // average Q as basis for GF/ARF best Q limit unless last frame was
    // a key frame.
    if (rc->frames_since_key > 1 &&
        rc->avg_frame_qindex[INTER_FRAME] < active_worst_quality) {
      q = rc->avg_frame_qindex[INTER_FRAME];
    } else {
      q = active_worst_quality;
    }
    // For constrained quality dont allow Q less than the cq level
1009
    if (oxcf->rc_mode == AOM_CQ) {
1010
      if (q < cq_level) q = cq_level;
Jingning Han's avatar
Jingning Han committed
1011 1012 1013 1014 1015 1016

      active_best_quality = get_gf_active_quality(rc, q, cm->bit_depth);

      // Constrained quality use slightly lower active best.
      active_best_quality = active_best_quality * 15 / 16;

1017
    } else if (oxcf->rc_mode == AOM_Q) {
Zoe Liu's avatar
Zoe Liu committed
1018
      if (!cpi->refresh_alt_ref_frame && !cpi->refresh_alt2_ref_frame) {
Jingning Han's avatar
Jingning Han committed
1019 1020
        active_best_quality = cq_level;
      } else {
1021
        active_best_quality = get_gf_active_quality(rc, q, cm->bit_depth);
Jingning Han's avatar
Jingning Han committed
1022

1023
        // Modify best quality for second level arfs. For mode AOM_Q this
Jingning Han's avatar
Jingning Han committed
1024 1025 1026 1027 1028 1029 1030 1031
        // becomes the baseline frame q.
        if (gf_group->rf_level[gf_group->index] == GF_ARF_LOW)
          active_best_quality = (active_best_quality + cq_level + 1) / 2;
      }
    } else {
      active_best_quality = get_gf_active_quality(rc, q, cm->bit_depth);
    }
  } else {
1032
    if (oxcf->rc_mode == AOM_Q) {
Jingning Han's avatar
Jingning Han committed
1033 1034 1035 1036 1037 1038
      active_best_quality = cq_level;
    } else {
      active_best_quality = inter_minq[active_worst_quality];

      // For the constrained quality mode we don't want
      // q to fall below the cq level.
1039
      if ((oxcf->rc_mode == AOM_CQ) && (active_best_quality < cq_level)) {
Jingning Han's avatar
Jingning Han committed
1040 1041 1042 1043 1044 1045 1046
        active_best_quality = cq_level;
      }
    }
  }

  // Extension to max or min Q if undershoot or overshoot is outside
  // the permitted range.
1047
  if ((cpi->oxcf.rc_mode != AOM_Q) &&
Jingning Han's avatar
Jingning Han committed
1048 1049
      (cpi->twopass.gf_zeromotion_pct < VLOW_MOTION_THRESHOLD)) {
    if (frame_is_intra_only(cm) ||
1050 1051 1052
        (!rc->is_src_frame_alt_ref &&
         (cpi->refresh_golden_frame || cpi->refresh_alt2_ref_frame ||
          cpi->refresh_alt_ref_frame))) {
Jingning Han's avatar
Jingning Han committed
1053
      active_best_quality -=
1054
          (cpi->twopass.extend_minq + cpi->twopass.extend_minq_fast);
Jingning Han's avatar
Jingning Han committed
1055 1056 1057
      active_worst_quality += (cpi->twopass.extend_maxq / 2);
    } else {
      active_best_quality -=
1058
          (cpi->twopass.extend_minq + cpi->twopass.extend_minq_fast) / 2;
Jingning Han's avatar
Jingning Han committed
1059 1060 1061 1062
      active_worst_quality += cpi->twopass.extend_maxq;
    }
  }

1063
  aom_clear_system_state();
Jingning Han's avatar
Jingning Han committed
1064
  // Static forced key frames Q restrictions dealt with elsewhere.
1065
  if (!(frame_is_intra_only(cm)) || !rc->this_key_frame_forced ||
Jingning Han's avatar
Jingning Han committed
1066
      (cpi->twopass.last_kfgroup_zeromotion_pct < STATIC_MOTION_THRESH)) {
1067 1068
    int qdelta = av1_frame_type_qdelta(cpi, gf_group->rf_level[gf_group->index],
                                       active_worst_quality);
1069
    active_worst_quality =
1070
        AOMMAX(active_worst_quality + qdelta, active_best_quality);
Jingning Han's avatar
Jingning Han committed
1071 1072 1073
  }

  // Modify active_best_quality for downscaled normal frames.
1074
  if (!av1_frame_unscaled(cm) && !frame_is_kf_gf_arf(cpi)) {
1075
    int qdelta = av1_compute_qdelta_by_rate(
1076
        rc, cm->frame_type, active_best_quality, 2.0, cm->bit_depth);
1077
    active_best_quality =
1078
        AOMMAX(active_best_quality + qdelta, rc->best_quality);
Jingning Han's avatar
Jingning Han committed
1079 1080
  }

1081 1082 1083 1084
  active_best_quality =
      clamp(active_best_quality, rc->best_quality, rc->worst_quality);
  active_worst_quality =
      clamp(active_worst_quality, active_best_quality, rc->worst_quality);
Jingning Han's avatar
Jingning Han committed
1085

1086
  if (oxcf->rc_mode == AOM_Q) {
Jingning Han's avatar
Jingning Han committed
1087
    q = active_best_quality;
1088
    // Special case code to try and match quality with forced key frames.
Yunqing Wang's avatar
Yunqing Wang committed
1089
  } else if (frame_is_intra_only(cm) && rc->this_key_frame_forced) {
Jingning Han's avatar
Jingning Han committed
1090 1091
    // If static since last kf use better of last boosted and last kf q.
    if (cpi->twopass.last_kfgroup_zeromotion_pct >= STATIC_MOTION_THRESH) {
1092
      q = AOMMIN(rc->last_kf_qindex, rc->last_boosted_qindex);
Jingning Han's avatar
Jingning Han committed
1093 1094 1095 1096
    } else {
      q = rc->last_boosted_qindex;
    }
  } else {
1097
    q = av1_rc_regulate_q(cpi, rc->this_frame_target, active_best_quality,
1098
                          active_worst_quality, width, height);
Jingning Han's avatar
Jingning Han committed
1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111
    if (q > active_worst_quality) {
      // Special case when we are targeting the max allowed rate.
      if (rc->this_frame_target >= rc->max_frame_bandwidth)
        active_worst_quality = q;
      else
        q = active_worst_quality;
    }
  }
  clamp(q, active_best_quality, active_worst_quality);

  *top_index = active_worst_quality;
  *bottom_index = active_best_quality;

1112
  assert(*top_index <= rc->worst_quality && *top_index >= rc->best_quality);
Jingning Han's avatar
Jingning Han committed
1113 1114 1115 1116 1117 1118
  assert(*bottom_index <= rc->worst_quality &&
         *bottom_index >= rc->best_quality);
  assert(q <= rc->worst_quality && q >= rc->best_quality);
  return q;
}

1119 1120
int av1_rc_pick_q_and_bounds(const AV1_COMP *cpi, int width, int height,
                             int *bottom_index, int *top_index) {
Jingning Han's avatar
Jingning Han committed
1121 1122
  int q;
  if (cpi->oxcf.pass == 0) {
1123
    if (cpi->oxcf.rc_mode == AOM_CBR)
1124 1125
      q = rc_pick_q_and_bounds_one_pass_cbr(cpi, width, height, bottom_index,
                                            top_index);
Jingning Han's avatar
Jingning Han committed
1126
    else
1127 1128
      q = rc_pick_q_and_bounds_one_pass_vbr(cpi, width, height, bottom_index,
                                            top_index);
Jingning Han's avatar
Jingning Han committed
1129
  } else {
1130 1131
    q = rc_pick_q_and_bounds_two_pass(cpi, width, height, bottom_index,
                                      top_index);
Jingning Han's avatar
Jingning Han committed
1132
  }
1133

Jingning Han's avatar
Jingning Han committed
1134 1135 1136
  return q;
}

1137 1138 1139 1140
void av1_rc_compute_frame_size_bounds(const AV1_COMP *cpi, int frame_target,
                                      int *frame_under_shoot_limit,
                                      int *frame_over_shoot_limit) {
  if (cpi->oxcf.rc_mode == AOM_Q) {
Jingning Han's avatar
Jingning Han committed
1141
    *frame_under_shoot_limit = 0;