vp9_ratectrl.c 53.4 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5
6
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
7
 *  in the file PATENTS.  All contributing project authors may
8
 *  be found in the AUTHORS file in the root of the source tree.
John Koleszar's avatar
John Koleszar committed
9
10
11
12
13
14
15
16
 */


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <assert.h>
Dmitry Kovalev's avatar
Dmitry Kovalev committed
17
#include <math.h>
John Koleszar's avatar
John Koleszar committed
18

19
20
#include "vp9/common/vp9_alloccommon.h"
#include "vp9/common/vp9_common.h"
21
#include "vp9/encoder/vp9_ratectrl.h"
22
#include "vp9/common/vp9_entropymode.h"
John Koleszar's avatar
John Koleszar committed
23
#include "vpx_mem/vpx_mem.h"
24
#include "vp9/common/vp9_systemdependent.h"
25
#include "vp9/encoder/vp9_encodemv.h"
26
#include "vp9/common/vp9_quant_common.h"
27
#include "vp9/common/vp9_seg_common.h"
John Koleszar's avatar
John Koleszar committed
28

Deb Mukherjee's avatar
Deb Mukherjee committed
29
#define LIMIT_QRANGE_FOR_ALTREF_AND_KEY 1
30

Dmitry Kovalev's avatar
Dmitry Kovalev committed
31
32
#define MIN_BPB_FACTOR 0.005
#define MAX_BPB_FACTOR 50
John Koleszar's avatar
John Koleszar committed
33
34
35
36

// Bits Per MB at different Q (Multiplied by 512)
#define BPER_MB_NORMBITS    9

37
38
39
40
41
42
43
44
// Tables relating active max Q to active min Q
static int kf_low_motion_minq[QINDEX_RANGE];
static int kf_high_motion_minq[QINDEX_RANGE];
static int gf_low_motion_minq[QINDEX_RANGE];
static int gf_high_motion_minq[QINDEX_RANGE];
static int inter_minq[QINDEX_RANGE];
static int afq_low_motion_minq[QINDEX_RANGE];
static int afq_high_motion_minq[QINDEX_RANGE];
Deb Mukherjee's avatar
Deb Mukherjee committed
45
46
47
48
static int gf_high = 2000;
static int gf_low = 400;
static int kf_high = 5000;
static int kf_low = 400;
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

// 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 calculate_minq_index(double maxq,
                                double x3, double x2, double x1, double c) {
  int i;
  const double minqtarget = MIN(((x3 * maxq + x2) * maxq + x1) * maxq + c,
                                maxq);

  // Special case handling to deal with the step from q2.0
  // down to lossless mode represented by q 1.0.
  if (minqtarget <= 2.0)
    return 0;

  for (i = 0; i < QINDEX_RANGE; i++) {
    if (minqtarget <= vp9_convert_qindex_to_q(i))
      return i;
  }

  return QINDEX_RANGE - 1;
}

73
void vp9_rc_init_minq_luts(void) {
74
75
76
77
78
79
80
81
82
83
84
85
86
87
  int i;

  for (i = 0; i < QINDEX_RANGE; i++) {
    const double maxq = vp9_convert_qindex_to_q(i);


    kf_low_motion_minq[i] = calculate_minq_index(maxq,
                                                 0.000001,
                                                 -0.0004,
                                                 0.15,
                                                 0.0);
    kf_high_motion_minq[i] = calculate_minq_index(maxq,
                                                  0.000002,
                                                  -0.0012,
Deb Mukherjee's avatar
Deb Mukherjee committed
88
                                                  0.50,
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
                                                  0.0);

    gf_low_motion_minq[i] = calculate_minq_index(maxq,
                                                 0.0000015,
                                                 -0.0009,
                                                 0.32,
                                                 0.0);
    gf_high_motion_minq[i] = calculate_minq_index(maxq,
                                                  0.0000021,
                                                  -0.00125,
                                                  0.50,
                                                  0.0);
    afq_low_motion_minq[i] = calculate_minq_index(maxq,
                                                  0.0000015,
                                                  -0.0009,
                                                  0.33,
                                                  0.0);
    afq_high_motion_minq[i] = calculate_minq_index(maxq,
                                                   0.0000021,
                                                   -0.00125,
                                                   0.55,
                                                   0.0);
Deb Mukherjee's avatar
Deb Mukherjee committed
111
112
113
114
115
    inter_minq[i] = calculate_minq_index(maxq,
                                         0.00000271,
                                         -0.00113,
                                         0.75,
                                         0.0);
116
117
118
  }
}

Paul Wilkins's avatar
Paul Wilkins committed
119
120
121
// 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
122
double vp9_convert_qindex_to_q(int qindex) {
John Koleszar's avatar
John Koleszar committed
123
  // Convert the index to a real Q value (scaled down to match old Q values)
124
  return vp9_ac_quant(qindex, 0) / 4.0;
Paul Wilkins's avatar
Paul Wilkins committed
125
126
}

127
128
int vp9_rc_bits_per_mb(FRAME_TYPE frame_type, int qindex,
                       double correction_factor) {
129
  const double q = vp9_convert_qindex_to_q(qindex);
130
  int enumerator = frame_type == KEY_FRAME ? 3300000 : 2250000;
Paul Wilkins's avatar
Paul Wilkins committed
131

132
  // q based adjustment to baseline enumerator
Paul Wilkins's avatar
Paul Wilkins committed
133
  enumerator += (int)(enumerator * q) >> 12;
134
135
  return (int)(0.5 + (enumerator * correction_factor / q));
}
John Koleszar's avatar
John Koleszar committed
136

137
void vp9_save_coding_context(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
138
  CODING_CONTEXT *const cc = &cpi->coding_context;
139
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
140

John Koleszar's avatar
John Koleszar committed
141
  // Stores a snapshot of key state variables which can subsequently be
142
  // restored with a call to vp9_restore_coding_context. These functions are
143
  // intended for use in a re-code loop in vp9_compress_frame where the
John Koleszar's avatar
John Koleszar committed
144
  // quantizer value is adjusted between loop iterations.
145
146
147
148
  vp9_copy(cc->nmvjointcost,  cpi->mb.nmvjointcost);
  vp9_copy(cc->nmvcosts,  cpi->mb.nmvcosts);
  vp9_copy(cc->nmvcosts_hp,  cpi->mb.nmvcosts_hp);

149
  vp9_copy(cc->segment_pred_probs, cm->seg.pred_probs);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
150

John Koleszar's avatar
John Koleszar committed
151
  vpx_memcpy(cpi->coding_context.last_frame_seg_map_copy,
152
             cm->last_frame_seg_map, (cm->mi_rows * cm->mi_cols));
John Koleszar's avatar
John Koleszar committed
153

154
155
  vp9_copy(cc->last_ref_lf_deltas, cm->lf.last_ref_deltas);
  vp9_copy(cc->last_mode_lf_deltas, cm->lf.last_mode_deltas);
156

157
  cc->fc = cm->fc;
158
}
John Koleszar's avatar
John Koleszar committed
159

160
void vp9_restore_coding_context(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
161
  CODING_CONTEXT *const cc = &cpi->coding_context;
162
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
163

John Koleszar's avatar
John Koleszar committed
164
  // Restore key state variables to the snapshot state stored in the
165
  // previous call to vp9_save_coding_context.
166
167
168
169
  vp9_copy(cpi->mb.nmvjointcost, cc->nmvjointcost);
  vp9_copy(cpi->mb.nmvcosts, cc->nmvcosts);
  vp9_copy(cpi->mb.nmvcosts_hp, cc->nmvcosts_hp);

170
  vp9_copy(cm->seg.pred_probs, cc->segment_pred_probs);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
171

John Koleszar's avatar
John Koleszar committed
172
173
  vpx_memcpy(cm->last_frame_seg_map,
             cpi->coding_context.last_frame_seg_map_copy,
174
             (cm->mi_rows * cm->mi_cols));
John Koleszar's avatar
John Koleszar committed
175

176
177
  vp9_copy(cm->lf.last_ref_deltas, cc->last_ref_lf_deltas);
  vp9_copy(cm->lf.last_mode_deltas, cc->last_mode_lf_deltas);
178

179
  cm->fc = cc->fc;
John Koleszar's avatar
John Koleszar committed
180
181
}

182
183
void vp9_setup_key_frame(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
184

185
  vp9_setup_past_independence(cm);
John Koleszar's avatar
John Koleszar committed
186

187
  /* All buffers are implicitly updated on key frames. */
188
189
  cpi->refresh_golden_frame = 1;
  cpi->refresh_alt_ref_frame = 1;
John Koleszar's avatar
John Koleszar committed
190
}
191

192
void vp9_setup_inter_frame(VP9_COMP *cpi) {
193
  VP9_COMMON *cm = &cpi->common;
Adrian Grange's avatar
Adrian Grange committed
194
  if (cm->error_resilient_mode || cm->intra_only)
195
    vp9_setup_past_independence(cm);
196

Dmitry Kovalev's avatar
Dmitry Kovalev committed
197
  assert(cm->frame_context_idx < FRAME_CONTEXTS);
198
  cm->fc = cm->frame_contexts[cm->frame_context_idx];
199
}
John Koleszar's avatar
John Koleszar committed
200

201
static int estimate_bits_at_q(int frame_kind, int q, int mbs,
John Koleszar's avatar
John Koleszar committed
202
                              double correction_factor) {
203
  const int bpm = (int)(vp9_rc_bits_per_mb(frame_kind, q, correction_factor));
John Koleszar's avatar
John Koleszar committed
204

205
206
207
208
209
  // Attempt to retain reasonable accuracy without overflow. The cutoff is
  // chosen such that the maximum product of Bpm and MBs fits 31 bits. The
  // largest Bpm takes 20 bits.
  return (mbs > (1 << 11)) ? (bpm >> BPER_MB_NORMBITS) * mbs
                           : (bpm * mbs) >> BPER_MB_NORMBITS;
210
}
211

212
213
214
215
216
217
int vp9_rc_clamp_pframe_target_size(const VP9_COMP *const cpi, int target) {
  const RATE_CONTROL *rc = &cpi->rc;
  const int min_frame_target = MAX(rc->min_frame_bandwidth,
                                   rc->av_per_frame_bandwidth >> 5);
  if (target < min_frame_target)
    target = min_frame_target;
218
  if (cpi->refresh_golden_frame && rc->is_src_frame_alt_ref) {
219
220
221
222
    // 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.
223
    target = min_frame_target;
224
225
226
227
228
229
  }
  // Clip the frame target to the maximum allowed value.
  if (target > rc->max_frame_bandwidth)
    target = rc->max_frame_bandwidth;
  return target;
}
230

231
232
int vp9_rc_clamp_iframe_target_size(const VP9_COMP *const cpi, int target) {
  const RATE_CONTROL *rc = &cpi->rc;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
233
234
  const VP9_CONFIG *oxcf = &cpi->oxcf;
  if (oxcf->rc_max_intra_bitrate_pct) {
235
    const int max_rate = rc->av_per_frame_bandwidth *
236
        oxcf->rc_max_intra_bitrate_pct / 100;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
237
    target = MIN(target, max_rate);
John Koleszar's avatar
John Koleszar committed
238
  }
239
240
241
  if (target > rc->max_frame_bandwidth)
    target = rc->max_frame_bandwidth;
  return target;
John Koleszar's avatar
John Koleszar committed
242
243
}

244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263

// Update the buffer level for higher layers, given the encoded current layer.
static void update_layer_buffer_level(VP9_COMP *const cpi,
                                      int encoded_frame_size) {
  int temporal_layer = 0;
  int current_temporal_layer = cpi->svc.temporal_layer_id;
  for (temporal_layer = current_temporal_layer + 1;
      temporal_layer < cpi->svc.number_temporal_layers; ++temporal_layer) {
    LAYER_CONTEXT *lc = &cpi->svc.layer_context[temporal_layer];
    RATE_CONTROL *lrc = &lc->rc;
    int bits_off_for_this_layer = (int)(lc->target_bandwidth / lc->framerate -
        encoded_frame_size);
    lrc->bits_off_target += bits_off_for_this_layer;

    // Clip buffer level to maximum buffer size for the layer.
    lrc->bits_off_target = MIN(lrc->bits_off_target, lc->maximum_buffer_size);
    lrc->buffer_level = lrc->bits_off_target;
  }
}

264
// Update the buffer level: leaky bucket model.
265
static void update_buffer_level(VP9_COMP *cpi, int encoded_frame_size) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
266
267
  const VP9_COMMON *const cm = &cpi->common;
  const VP9_CONFIG *oxcf = &cpi->oxcf;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
268
  RATE_CONTROL *const rc = &cpi->rc;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
269

270
271
  // Non-viewable frames are a special case and are treated as pure overhead.
  if (!cm->show_frame) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
272
    rc->bits_off_target -= encoded_frame_size;
273
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
274
    rc->bits_off_target += rc->av_per_frame_bandwidth - encoded_frame_size;
275
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
276

277
  // Clip the buffer level to the maximum specified buffer size.
278
279
280
281
282
283
  rc->bits_off_target = MIN(rc->bits_off_target, oxcf->maximum_buffer_size);
  rc->buffer_level = rc->bits_off_target;

  if (cpi->use_svc && cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
    update_layer_buffer_level(cpi, encoded_frame_size);
  }
284
285
}

286
int vp9_rc_drop_frame(VP9_COMP *cpi) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
287
  const VP9_CONFIG *oxcf = &cpi->oxcf;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
288
289
  RATE_CONTROL *const rc = &cpi->rc;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
290
  if (!oxcf->drop_frames_water_mark) {
291
292
    return 0;
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
293
    if (rc->buffer_level < 0) {
294
295
296
297
298
      // 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.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
299
      int drop_mark = (int)(oxcf->drop_frames_water_mark *
300
          oxcf->optimal_buffer_level / 100);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
301
302
303
304
305
306
      if ((rc->buffer_level > drop_mark) &&
          (rc->decimation_factor > 0)) {
        --rc->decimation_factor;
      } else if (rc->buffer_level <= drop_mark &&
          rc->decimation_factor == 0) {
        rc->decimation_factor = 1;
307
      }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
308
309
310
      if (rc->decimation_factor > 0) {
        if (rc->decimation_count > 0) {
          --rc->decimation_count;
311
312
          return 1;
        } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
313
          rc->decimation_count = rc->decimation_factor;
314
315
316
          return 0;
        }
      } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
317
        rc->decimation_count = 0;
318
319
320
321
322
323
        return 0;
      }
    }
  }
}

324
325
326
327
static double get_rate_correction_factor(const VP9_COMP *cpi) {
  if (cpi->common.frame_type == KEY_FRAME) {
    return cpi->rc.key_frame_rate_correction_factor;
  } else {
328
329
    if ((cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) &&
        !(cpi->use_svc && cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
330
331
332
333
334
335
336
337
338
339
      return cpi->rc.gf_rate_correction_factor;
    else
      return cpi->rc.rate_correction_factor;
  }
}

static void set_rate_correction_factor(VP9_COMP *cpi, double factor) {
  if (cpi->common.frame_type == KEY_FRAME) {
    cpi->rc.key_frame_rate_correction_factor = factor;
  } else {
340
341
    if ((cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) &&
        !(cpi->use_svc && cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
342
343
344
345
346
347
      cpi->rc.gf_rate_correction_factor = factor;
    else
      cpi->rc.rate_correction_factor = factor;
  }
}

348
void vp9_rc_update_rate_correction_factors(VP9_COMP *cpi, int damp_var) {
349
350
  const int q = cpi->common.base_qindex;
  int correction_factor = 100;
351
  double rate_correction_factor = get_rate_correction_factor(cpi);
John Koleszar's avatar
John Koleszar committed
352
  double adjustment_limit;
John Koleszar's avatar
John Koleszar committed
353

354
  int projected_size_based_on_q = 0;
John Koleszar's avatar
John Koleszar committed
355

John Koleszar's avatar
John Koleszar committed
356
  // Clear down mmx registers to allow floating point in what follows
357
  vp9_clear_system_state();
John Koleszar's avatar
John Koleszar committed
358

359
360
  // Work out how big we would have expected the frame to be at this Q given
  // the current correction factor.
John Koleszar's avatar
John Koleszar committed
361
  // Stay in double to avoid int overflow when values are large
362
363
364
  projected_size_based_on_q = estimate_bits_at_q(cpi->common.frame_type, q,
                                                 cpi->common.MBs,
                                                 rate_correction_factor);
John Koleszar's avatar
John Koleszar committed
365
366
  // Work out a size correction factor.
  if (projected_size_based_on_q > 0)
367
368
    correction_factor = (100 * cpi->rc.projected_frame_size) /
                            projected_size_based_on_q;
John Koleszar's avatar
John Koleszar committed
369

370
371
  // More heavily damped adjustment used if we have been oscillating either side
  // of target.
John Koleszar's avatar
John Koleszar committed
372
  switch (damp_var) {
John Koleszar's avatar
John Koleszar committed
373
    case 0:
John Koleszar's avatar
John Koleszar committed
374
375
      adjustment_limit = 0.75;
      break;
John Koleszar's avatar
John Koleszar committed
376
    case 1:
John Koleszar's avatar
John Koleszar committed
377
378
      adjustment_limit = 0.375;
      break;
John Koleszar's avatar
John Koleszar committed
379
380
    case 2:
    default:
John Koleszar's avatar
John Koleszar committed
381
382
383
384
385
386
      adjustment_limit = 0.25;
      break;
  }

  if (correction_factor > 102) {
    // We are not already at the worst allowable quality
387
    correction_factor =
388
        (int)(100 + ((correction_factor - 100) * adjustment_limit));
389
390
    rate_correction_factor =
        ((rate_correction_factor * correction_factor) / 100);
John Koleszar's avatar
John Koleszar committed
391
392
393
394

    // Keep rate_correction_factor within limits
    if (rate_correction_factor > MAX_BPB_FACTOR)
      rate_correction_factor = MAX_BPB_FACTOR;
395
  } else if (correction_factor < 99) {
John Koleszar's avatar
John Koleszar committed
396
    // We are not already at the best allowable quality
397
    correction_factor =
398
        (int)(100 - ((100 - correction_factor) * adjustment_limit));
399
400
    rate_correction_factor =
        ((rate_correction_factor * correction_factor) / 100);
John Koleszar's avatar
John Koleszar committed
401
402
403
404
405
406

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

407
  set_rate_correction_factor(cpi, rate_correction_factor);
John Koleszar's avatar
John Koleszar committed
408
409
410
}


Deb Mukherjee's avatar
Deb Mukherjee committed
411
412
int vp9_rc_regulate_q(const VP9_COMP *cpi, int target_bits_per_frame,
                      int active_best_quality, int active_worst_quality) {
413
  const VP9_COMMON *const cm = &cpi->common;
Deb Mukherjee's avatar
Deb Mukherjee committed
414
  int q = active_worst_quality;
John Koleszar's avatar
John Koleszar committed
415
  int last_error = INT_MAX;
416
  int i, target_bits_per_mb;
417
  const double correction_factor = get_rate_correction_factor(cpi);
John Koleszar's avatar
John Koleszar committed
418

419
420
  // Calculate required scaling factor based on target frame size and size of
  // frame produced using previous Q.
John Koleszar's avatar
John Koleszar committed
421
  if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
422
423
    // Case where we would overflow int
    target_bits_per_mb = (target_bits_per_frame / cm->MBs) << BPER_MB_NORMBITS;
John Koleszar's avatar
John Koleszar committed
424
  else
425
    target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cm->MBs;
John Koleszar's avatar
John Koleszar committed
426

Deb Mukherjee's avatar
Deb Mukherjee committed
427
  i = active_best_quality;
John Koleszar's avatar
John Koleszar committed
428

John Koleszar's avatar
John Koleszar committed
429
  do {
430
431
    const int bits_per_mb_at_this_q = (int)vp9_rc_bits_per_mb(cm->frame_type, i,
                                                             correction_factor);
John Koleszar's avatar
John Koleszar committed
432

John Koleszar's avatar
John Koleszar committed
433
434
    if (bits_per_mb_at_this_q <= target_bits_per_mb) {
      if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
435
        q = i;
John Koleszar's avatar
John Koleszar committed
436
      else
437
        q = i - 1;
John Koleszar's avatar
John Koleszar committed
438

John Koleszar's avatar
John Koleszar committed
439
      break;
440
    } else {
John Koleszar's avatar
John Koleszar committed
441
      last_error = bits_per_mb_at_this_q - target_bits_per_mb;
442
    }
Deb Mukherjee's avatar
Deb Mukherjee committed
443
  } while (++i <= active_worst_quality);
444
445
446
447

  return q;
}

448
449
static int get_active_quality(int q, int gfu_boost, int low, int high,
                              int *low_motion_minq, int *high_motion_minq) {
450
  if (gfu_boost > high) {
451
    return low_motion_minq[q];
452
  } else if (gfu_boost < low) {
453
    return high_motion_minq[q];
454
455
456
457
458
  } 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;
459
    return low_motion_minq[q] + adjustment;
460
461
462
  }
}

463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
static int calc_active_worst_quality_one_pass_vbr(const VP9_COMP *cpi) {
  int active_worst_quality;
  if (cpi->common.frame_type == KEY_FRAME) {
    if (cpi->common.current_video_frame == 0) {
      active_worst_quality = cpi->rc.worst_quality;
    } else {
      // Choose active worst quality twice as large as the last q.
      active_worst_quality = cpi->rc.last_q[KEY_FRAME] * 2;
    }
  } else if (!cpi->rc.is_src_frame_alt_ref &&
             (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
    if (cpi->common.current_video_frame == 1) {
      active_worst_quality = cpi->rc.last_q[KEY_FRAME] * 5 / 4;
    } else {
      // Choose active worst quality twice as large as the last q.
      active_worst_quality = cpi->rc.last_q[INTER_FRAME];
    }
  } else {
    if (cpi->common.current_video_frame == 1) {
      active_worst_quality = cpi->rc.last_q[KEY_FRAME] * 2;
    } else {
      // Choose active worst quality twice as large as the last q.
      active_worst_quality = cpi->rc.last_q[INTER_FRAME] * 2;
    }
  }
  if (active_worst_quality > cpi->rc.worst_quality)
    active_worst_quality = cpi->rc.worst_quality;
  return active_worst_quality;
}

// Adjust active_worst_quality level based on buffer level.
static int calc_active_worst_quality_one_pass_cbr(const VP9_COMP *cpi) {
  // 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).
  const VP9_CONFIG *oxcf = &cpi->oxcf;
  const RATE_CONTROL *rc = &cpi->rc;
  // Buffer level below which we push active_worst to worst_quality.
503
504
  int64_t critical_level = oxcf->optimal_buffer_level >> 2;
  int64_t buff_lvl_step = 0;
505
506
507
508
509
510
511
512
513
514
515
516
  int adjustment = 0;
  int active_worst_quality;
  if (cpi->common.frame_type == KEY_FRAME)
    return rc->worst_quality;
  if (cpi->common.current_video_frame > 1)
    active_worst_quality = MIN(rc->worst_quality,
                               rc->avg_frame_qindex[INTER_FRAME] * 5 / 4);
  else
    active_worst_quality = MIN(rc->worst_quality,
                               rc->avg_frame_qindex[KEY_FRAME] * 3 / 2);
  if (rc->buffer_level > oxcf->optimal_buffer_level) {
    // Adjust down.
517
    // Maximum limit for down adjustment, ~30%.
518
519
    int max_adjustment_down = active_worst_quality / 3;
    if (max_adjustment_down) {
520
521
      buff_lvl_step = ((oxcf->maximum_buffer_size -
                        oxcf->optimal_buffer_level) / max_adjustment_down);
522
523
524
525
526
527
528
529
530
531
      if (buff_lvl_step)
        adjustment = (int)((rc->buffer_level - oxcf->optimal_buffer_level) /
                            buff_lvl_step);
      active_worst_quality -= adjustment;
    }
  } else if (rc->buffer_level > critical_level) {
    // Adjust up from ambient Q.
    if (critical_level) {
      buff_lvl_step = (oxcf->optimal_buffer_level - critical_level);
      if (buff_lvl_step) {
532
533
534
535
        adjustment =
            (int)((rc->worst_quality - rc->avg_frame_qindex[INTER_FRAME]) *
                  (oxcf->optimal_buffer_level - rc->buffer_level) /
                  buff_lvl_step);
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
      }
      active_worst_quality = rc->avg_frame_qindex[INTER_FRAME] + adjustment;
    }
  } else {
    // Set to worst_quality if buffer is below critical level.
    active_worst_quality = rc->worst_quality;
  }
  return active_worst_quality;
}

static int rc_pick_q_and_bounds_one_pass_cbr(const VP9_COMP *cpi,
                                             int *bottom_index,
                                             int *top_index) {
  const VP9_COMMON *const cm = &cpi->common;
  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;

  if (frame_is_intra_only(cm)) {
    active_best_quality = rc->best_quality;
    // Handle the special case for key frames forced when we have75 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;
      double last_boosted_q = vp9_convert_qindex_to_q(qindex);
      int delta_qindex = vp9_compute_qdelta(cpi, last_boosted_q,
                                            (last_boosted_q * 0.75));
      active_best_quality = MAX(qindex + delta_qindex, rc->best_quality);
    } 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;

      active_best_quality = get_active_quality(rc->avg_frame_qindex[KEY_FRAME],
                                               rc->kf_boost,
                                               kf_low, kf_high,
                                               kf_low_motion_minq,
                                               kf_high_motion_minq);

      // Allow somewhat lower kf minq with small image formats.
      if ((cm->width * cm->height) <= (352 * 288)) {
        q_adj_factor -= 0.25;
      }

      // Convert the adjustment factor to a qindex delta
      // on active_best_quality.
      q_val = vp9_convert_qindex_to_q(active_best_quality);
      active_best_quality += vp9_compute_qdelta(cpi, q_val, q_val *
                                                   q_adj_factor);
    }
  } 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_active_quality(
        q, rc->gfu_boost, gf_low, gf_high,
        gf_low_motion_minq, gf_high_motion_minq);
  } 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 = inter_minq[rc->avg_frame_qindex[INTER_FRAME]];
      else
        active_best_quality = inter_minq[active_worst_quality];
    } else {
      if (rc->avg_frame_qindex[KEY_FRAME] < active_worst_quality)
        active_best_quality = inter_minq[rc->avg_frame_qindex[KEY_FRAME]];
      else
        active_best_quality = inter_minq[active_worst_quality];
    }
  }

  // Clip the active best and worst quality values to limits
  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);

  *top_index = active_worst_quality;
  *bottom_index = active_best_quality;

#if LIMIT_QRANGE_FOR_ALTREF_AND_KEY
  // Limit Q range for the adaptive loop.
  if (cm->frame_type == KEY_FRAME && !rc->this_key_frame_forced) {
    if (!(cm->current_video_frame == 0))
      *top_index = (active_worst_quality + active_best_quality * 3) / 4;
  }
#endif
  // 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 {
    q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
                          active_best_quality, active_worst_quality);
    if (q > *top_index) {
      // Special case when we are targeting the max allowed rate
      if (cpi->rc.this_frame_target >= cpi->rc.max_frame_bandwidth)
        *top_index = q;
      else
        q = *top_index;
    }
  }
  assert(*top_index <= rc->worst_quality &&
         *top_index >= rc->best_quality);
  assert(*bottom_index <= rc->worst_quality &&
         *bottom_index >= rc->best_quality);
  assert(q <= rc->worst_quality && q >= rc->best_quality);
  return q;
}

static int rc_pick_q_and_bounds_one_pass_vbr(const VP9_COMP *cpi,
                                             int *bottom_index,
                                             int *top_index) {
Deb Mukherjee's avatar
Deb Mukherjee committed
658
  const VP9_COMMON *const cm = &cpi->common;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
659
660
  const RATE_CONTROL *const rc = &cpi->rc;
  const VP9_CONFIG *const oxcf = &cpi->oxcf;
Deb Mukherjee's avatar
Deb Mukherjee committed
661
  int active_best_quality;
662
  int active_worst_quality = calc_active_worst_quality_one_pass_vbr(cpi);
Deb Mukherjee's avatar
Deb Mukherjee committed
663
  int q;
664
665

  if (frame_is_intra_only(cm)) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
666
    active_best_quality = rc->best_quality;
667
668
669
670
#if !CONFIG_MULTIPLE_ARF
    // Handle the special case for key frames forced when we have75 reached
    // the maximum key frame interval. Here force the Q to a range
    // based on the ambient Q to reduce the risk of popping.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
671
672
    if (rc->this_key_frame_forced) {
      int qindex = rc->last_boosted_qindex;
673
      double last_boosted_q = vp9_convert_qindex_to_q(qindex);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
674
675
676
      int delta_qindex = vp9_compute_qdelta(cpi, last_boosted_q,
                                            (last_boosted_q * 0.75));
      active_best_quality = MAX(qindex + delta_qindex, rc->best_quality);
677
    } else if (cm->current_video_frame > 0) {
Alex Converse's avatar
Alex Converse committed
678
      // not first frame of one pass and kf_boost is set
679
680
681
      double q_adj_factor = 1.0;
      double q_val;

682
      active_best_quality = get_active_quality(rc->avg_frame_qindex[KEY_FRAME],
Dmitry Kovalev's avatar
Dmitry Kovalev committed
683
                                               rc->kf_boost,
Deb Mukherjee's avatar
Deb Mukherjee committed
684
685
686
                                               kf_low, kf_high,
                                               kf_low_motion_minq,
                                               kf_high_motion_minq);
687
688
689
690
691
692
693
694

      // Allow somewhat lower kf minq with small image formats.
      if ((cm->width * cm->height) <= (352 * 288)) {
        q_adj_factor -= 0.25;
      }

      // Convert the adjustment factor to a qindex delta
      // on active_best_quality.
Deb Mukherjee's avatar
Deb Mukherjee committed
695
      q_val = vp9_convert_qindex_to_q(active_best_quality);
696
697
      active_best_quality += vp9_compute_qdelta(cpi, q_val, q_val *
                                                   q_adj_factor);
698
699
700
701
    }
#else
    double current_q;
    // Force the KF quantizer to be 30% of the active_worst_quality.
Deb Mukherjee's avatar
Deb Mukherjee committed
702
703
    current_q = vp9_convert_qindex_to_q(active_worst_quality);
    active_best_quality = active_worst_quality
704
705
        + vp9_compute_qdelta(cpi, current_q, current_q * 0.3);
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
706
  } else if (!rc->is_src_frame_alt_ref &&
707
             (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
Deb Mukherjee's avatar
Deb Mukherjee committed
708
    // Use the lower of active_worst_quality and recent
709
710
    // average Q as basis for GF/ARF best Q limit unless last frame was
    // a key frame.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
711
712
713
    if (rc->frames_since_key > 1 &&
        rc->avg_frame_qindex[INTER_FRAME] < active_worst_quality) {
      q = rc->avg_frame_qindex[INTER_FRAME];
Deb Mukherjee's avatar
Deb Mukherjee committed
714
    } else {
715
      q = rc->avg_frame_qindex[KEY_FRAME];
716
717
    }
    // For constrained quality dont allow Q less than the cq level
Dmitry Kovalev's avatar
Dmitry Kovalev committed
718
    if (oxcf->end_usage == USAGE_CONSTRAINED_QUALITY) {
719
720
      if (q < cpi->cq_target_quality)
        q = cpi->cq_target_quality;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
721
722
      if (rc->frames_since_key > 1) {
        active_best_quality = get_active_quality(q, rc->gfu_boost,
Deb Mukherjee's avatar
Deb Mukherjee committed
723
724
725
                                                 gf_low, gf_high,
                                                 afq_low_motion_minq,
                                                 afq_high_motion_minq);
726
      } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
727
        active_best_quality = get_active_quality(q, rc->gfu_boost,
Deb Mukherjee's avatar
Deb Mukherjee committed
728
729
730
                                                 gf_low, gf_high,
                                                 gf_low_motion_minq,
                                                 gf_high_motion_minq);
731
732
      }
      // Constrained quality use slightly lower active best.
Deb Mukherjee's avatar
Deb Mukherjee committed
733
      active_best_quality = active_best_quality * 15 / 16;
734

Dmitry Kovalev's avatar
Dmitry Kovalev committed
735
    } else if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
736
      if (!cpi->refresh_alt_ref_frame) {
Deb Mukherjee's avatar
Deb Mukherjee committed
737
        active_best_quality = cpi->cq_target_quality;
738
      } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
739
        if (rc->frames_since_key > 1) {
Deb Mukherjee's avatar
Deb Mukherjee committed
740
          active_best_quality = get_active_quality(
Dmitry Kovalev's avatar
Dmitry Kovalev committed
741
              q, rc->gfu_boost, gf_low, gf_high,
742
              afq_low_motion_minq, afq_high_motion_minq);
743
        } else {
Deb Mukherjee's avatar
Deb Mukherjee committed
744
          active_best_quality = get_active_quality(
Dmitry Kovalev's avatar
Dmitry Kovalev committed
745
              q, rc->gfu_boost, gf_low, gf_high,
746
              gf_low_motion_minq, gf_high_motion_minq);
747
748
749
        }
      }
    } else {
Deb Mukherjee's avatar
Deb Mukherjee committed
750
      active_best_quality = get_active_quality(
Dmitry Kovalev's avatar
Dmitry Kovalev committed
751
          q, rc->gfu_boost, gf_low, gf_high,
Deb Mukherjee's avatar
Deb Mukherjee committed
752
          gf_low_motion_minq, gf_high_motion_minq);
753
754
    }
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
755
    if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
Deb Mukherjee's avatar
Deb Mukherjee committed
756
      active_best_quality = cpi->cq_target_quality;
757
    } else {
758
      // Use the lower of active_worst_quality and recent/average Q.
759
760
761
762
      if (cm->current_video_frame > 1)
        active_best_quality = inter_minq[rc->avg_frame_qindex[INTER_FRAME]];
      else
        active_best_quality = inter_minq[rc->avg_frame_qindex[KEY_FRAME]];
763
764
      // For the constrained quality mode we don't want
      // q to fall below the cq level.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
765
      if ((oxcf->end_usage == USAGE_CONSTRAINED_QUALITY) &&
Deb Mukherjee's avatar
Deb Mukherjee committed
766
          (active_best_quality < cpi->cq_target_quality)) {
767
768
769
        // If we are strongly undershooting the target rate in the last
        // frames then use the user passed in cq value not the auto
        // cq value.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
770
771
        if (rc->rolling_actual_bits < rc->min_frame_bandwidth)
          active_best_quality = oxcf->cq_level;
772
        else
Deb Mukherjee's avatar
Deb Mukherjee committed
773
          active_best_quality = cpi->cq_target_quality;
774
775
776
777
778
      }
    }
  }

  // Clip the active best and worst quality values to limits
779
780
781
782
  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);
783

Deb Mukherjee's avatar
Deb Mukherjee committed
784
785
  *top_index = active_worst_quality;
  *bottom_index = active_best_quality;
786
787

#if LIMIT_QRANGE_FOR_ALTREF_AND_KEY
788
  // Limit Q range for the adaptive loop.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
789
  if (cm->frame_type == KEY_FRAME && !rc->this_key_frame_forced) {
790
    if (!(cm->current_video_frame == 0))
791
      *top_index = (active_worst_quality + active_best_quality * 3) / 4;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
792
  } else if (!rc->is_src_frame_alt_ref &&
793
             (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
794
    *top_index = (active_worst_quality + active_best_quality) / 2;
795
  }
796
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
797
  if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
Deb Mukherjee's avatar
Deb Mukherjee committed
798
    q = active_best_quality;
799
  // Special case code to try and match quality with forced key frames
Dmitry Kovalev's avatar
Dmitry Kovalev committed
800
801
  } else if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced) {
    q = rc->last_boosted_qindex;
802
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
803
    q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
804
                          active_best_quality, active_worst_quality);
Paul Wilkins's avatar
Paul Wilkins committed
805
806
807
808
809
810
811
    if (q > *top_index) {
      // Special case when we are targeting the max allowed rate
      if (cpi->rc.this_frame_target >= cpi->rc.max_frame_bandwidth)
        *top_index = q;
      else
        q = *top_index;
    }
812
  }
Deb Mukherjee's avatar
Deb Mukherjee committed
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
#if CONFIG_MULTIPLE_ARF
  // Force the quantizer determined by the coding order pattern.
  if (cpi->multi_arf_enabled && (cm->frame_type != KEY_FRAME) &&
      cpi->oxcf.end_usage != USAGE_CONSTANT_QUALITY) {
    double new_q;
    double current_q = vp9_convert_qindex_to_q(active_worst_quality);
    int level = cpi->this_frame_weight;
    assert(level >= 0);
    new_q = current_q * (1.0 - (0.2 * (cpi->max_arf_level - level)));
    q = active_worst_quality +
        vp9_compute_qdelta(cpi, current_q, new_q);

    *bottom_index = q;
    *top_index    = q;
    printf("frame:%d q:%d\n", cm->current_video_frame, q);
  }
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
830
831
832
833
834
  assert(*top_index <= rc->worst_quality &&
         *top_index >= rc->best_quality);
  assert(*bottom_index <= rc->worst_quality &&
         *bottom_index >= rc->best_quality);
  assert(q <= rc->worst_quality && q >= rc->best_quality);
835
  return q;
John Koleszar's avatar
John Koleszar committed
836
837
}

838
839
840
static int rc_pick_q_and_bounds_two_pass(const VP9_COMP *cpi,
                                         int *bottom_index,
                                         int *top_index) {
841
842
843
844
  const VP9_COMMON *const cm = &cpi->common;
  const RATE_CONTROL *const rc = &cpi->rc;
  const VP9_CONFIG *const oxcf = &cpi->oxcf;
  int active_best_quality;
845
  int active_worst_quality = cpi->twopass.active_worst_quality;
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
  int q;

  if (frame_is_intra_only(cm)) {
#if !CONFIG_MULTIPLE_ARF
    // Handle the special case for key frames forced when we have75 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;
      double last_boosted_q = vp9_convert_qindex_to_q(qindex);
      int delta_qindex = vp9_compute_qdelta(cpi, last_boosted_q,
                                            (last_boosted_q * 0.75));
      active_best_quality = MAX(qindex + delta_qindex, rc->best_quality);
    } else {
      // Not forced keyframe.
      double q_adj_factor = 1.0;
      double q_val;
      // Baseline value derived from cpi->active_worst_quality and kf boost.
      active_best_quality = get_active_quality(active_worst_quality,
                                               rc->kf_boost,
                                               kf_low, kf_high,
                                               kf_low_motion_minq,
                                               kf_high_motion_minq);

      // Allow somewhat lower kf minq with small image formats.
      if ((cm->width * cm->height) <= (352 * 288)) {
        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.
      q_val = vp9_convert_qindex_to_q(active_best_quality);
      active_best_quality += vp9_compute_qdelta(cpi, q_val, q_val *
                                                   q_adj_factor);
    }
#else
    double current_q;
    // Force the KF quantizer to be 30% of the active_worst_quality.
    current_q = vp9_convert_qindex_to_q(active_worst_quality);
    active_best_quality = active_worst_quality
        + vp9_compute_qdelta(cpi, current_q, current_q * 0.3);
#endif
  } 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;
    }
    // For constrained quality dont allow Q less than the cq level
    if (oxcf->end_usage == USAGE_CONSTRAINED_QUALITY) {
      if (q < cpi->cq_target_quality)
        q = cpi->cq_target_quality;
      if (rc->frames_since_key > 1) {
        active_best_quality = get_active_quality(q, rc->gfu_boost,
                                                 gf_low, gf_high,
                                                 afq_low_motion_minq,
                                                 afq_high_motion_minq);
      } else {
        active_best_quality = get_active_quality(q, rc->gfu_boost,
                                                 gf_low, gf_high,
                                                 gf_low_motion_minq,
                                                 gf_high_motion_minq);
      }
      // Constrained quality use slightly lower active best.
      active_best_quality = active_best_quality * 15 / 16;

    } else if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
      if (!cpi->refresh_alt_ref_frame) {
        active_best_quality = cpi->cq_target_quality;
      } else {
        if (rc->frames_since_key > 1) {
          active_best_quality = get_active_quality(
              q, rc->gfu_boost, gf_low, gf_high,
              afq_low_motion_minq, afq_high_motion_minq);
        } else {
          active_best_quality = get_active_quality(
              q, rc->gfu_boost, gf_low, gf_high,
              gf_low_motion_minq, gf_high_motion_minq);
        }
      }
    } else {
      active_best_quality = get_active_quality(
          q, rc->gfu_boost, gf_low, gf_high,
          gf_low_motion_minq, gf_high_motion_minq);
    }
  } else {
    if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
      active_best_quality = cpi->cq_target_quality;
    } 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.
      if ((oxcf->end_usage == USAGE_CONSTRAINED_QUALITY) &&
          (active_best_quality < cpi->cq_target_quality)) {
        // If we are strongly undershooting the target rate in the last
        // frames then use the user passed in cq value not the auto
        // cq value.
        if (rc->rolling_actual_bits < rc->min_frame_bandwidth)
          active_best_quality = oxcf->cq_level;
        else
          active_best_quality = cpi->cq_target_quality;
      }
    }
  }

  // Clip the active best and worst quality values to limits.
  if (active_worst_quality > rc->worst_quality)
    active_worst_quality = rc->worst_quality;

  if (active_best_quality < rc->best_quality)
    active_best_quality = rc->best_quality;

  if (active_best_quality > rc->worst_quality)
    active_best_quality = rc->worst_quality;

  if (active_worst_quality < active_best_quality)
    active_worst_quality = active_best_quality;

  *top_index = active_worst_quality;
  *bottom_index = active_best_quality;

#if LIMIT_QRANGE_FOR_ALTREF_AND_KEY
  // Limit Q range for the adaptive loop.
  if (cm->frame_type == KEY_FRAME && !rc->this_key_frame_forced) {
    *top_index = (active_worst_quality + active_best_quality * 3) / 4;
  } else if (!rc->is_src_frame_alt_ref &&
             (oxcf->end_usage != USAGE_STREAM_FROM_SERVER) &&
             (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
    *top_index = (active_worst_quality + active_best_quality) / 2;
  }
#endif

  if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
    q = active_best_quality;
  // Special case code to try and match quality with forced key frames.
  } else if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced) {
    q = rc->last_boosted_qindex;
  } else {
    q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
                          active_best_quality, active_worst_quality);
    if (q > *top_index) {
      // Special case when we are targeting the max allowed rate.
      if (cpi->rc.this_frame_target >= cpi->rc.max_frame_bandwidth)
        *top_index = q;
      else
        q = *top_index;