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
 */

#include <assert.h>
12
#include <limits.h>
Dmitry Kovalev's avatar
Dmitry Kovalev committed
13
#include <math.h>
14
15
16
17
18
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "vpx_mem/vpx_mem.h"
John Koleszar's avatar
John Koleszar committed
19

20
21
22
23
#include "vp9/common/vp9_alloccommon.h"
#include "vp9/common/vp9_common.h"
#include "vp9/common/vp9_entropymode.h"
#include "vp9/common/vp9_quant_common.h"
24
#include "vp9/common/vp9_seg_common.h"
25
26
27
28
#include "vp9/common/vp9_systemdependent.h"

#include "vp9/encoder/vp9_encodemv.h"
#include "vp9/encoder/vp9_ratectrl.h"
John Koleszar's avatar
John Koleszar committed
29

30
31
32
#define DEFAULT_KF_BOOST 2000
#define DEFAULT_GF_BOOST 2000

Deb Mukherjee's avatar
Deb Mukherjee committed
33
#define LIMIT_QRANGE_FOR_ALTREF_AND_KEY 1
34

Dmitry Kovalev's avatar
Dmitry Kovalev committed
35
36
#define MIN_BPB_FACTOR 0.005
#define MAX_BPB_FACTOR 50
John Koleszar's avatar
John Koleszar committed
37
38
39
40

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

41
42
43
44
45
46
47
48
// 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
49
50
51
52
static int gf_high = 2000;
static int gf_low = 400;
static int kf_high = 5000;
static int kf_low = 400;
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

// 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;
}

77
void vp9_rc_init_minq_luts(void) {
78
79
80
81
82
83
84
85
86
87
88
89
90
91
  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
92
                                                  0.50,
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
                                                  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
115
116
117
118
119
    inter_minq[i] = calculate_minq_index(maxq,
                                         0.00000271,
                                         -0.00113,
                                         0.75,
                                         0.0);
120
121
122
  }
}

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

131
132
int vp9_rc_bits_per_mb(FRAME_TYPE frame_type, int qindex,
                       double correction_factor) {
133
  const double q = vp9_convert_qindex_to_q(qindex);
134
  int enumerator = frame_type == KEY_FRAME ? 3300000 : 2250000;
Paul Wilkins's avatar
Paul Wilkins committed
135

136
  // q based adjustment to baseline enumerator
Paul Wilkins's avatar
Paul Wilkins committed
137
  enumerator += (int)(enumerator * q) >> 12;
138
139
  return (int)(0.5 + (enumerator * correction_factor / q));
}
John Koleszar's avatar
John Koleszar committed
140

141
void vp9_save_coding_context(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
142
  CODING_CONTEXT *const cc = &cpi->coding_context;
143
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
144

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

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

John Koleszar's avatar
John Koleszar committed
155
  vpx_memcpy(cpi->coding_context.last_frame_seg_map_copy,
156
             cm->last_frame_seg_map, (cm->mi_rows * cm->mi_cols));
John Koleszar's avatar
John Koleszar committed
157

158
159
  vp9_copy(cc->last_ref_lf_deltas, cm->lf.last_ref_deltas);
  vp9_copy(cc->last_mode_lf_deltas, cm->lf.last_mode_deltas);
160

161
  cc->fc = cm->fc;
162
}
John Koleszar's avatar
John Koleszar committed
163

164
void vp9_restore_coding_context(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
165
  CODING_CONTEXT *const cc = &cpi->coding_context;
166
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
167

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

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

John Koleszar's avatar
John Koleszar committed
176
177
  vpx_memcpy(cm->last_frame_seg_map,
             cpi->coding_context.last_frame_seg_map_copy,
178
             (cm->mi_rows * cm->mi_cols));
John Koleszar's avatar
John Koleszar committed
179

180
181
  vp9_copy(cm->lf.last_ref_deltas, cc->last_ref_lf_deltas);
  vp9_copy(cm->lf.last_mode_deltas, cc->last_mode_lf_deltas);
182

183
  cm->fc = cc->fc;
John Koleszar's avatar
John Koleszar committed
184
185
}

186
187
void vp9_setup_key_frame(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
188

189
  vp9_setup_past_independence(cm);
John Koleszar's avatar
John Koleszar committed
190

191
  /* All buffers are implicitly updated on key frames. */
192
193
  cpi->refresh_golden_frame = 1;
  cpi->refresh_alt_ref_frame = 1;
John Koleszar's avatar
John Koleszar committed
194
}
195

196
void vp9_setup_inter_frame(VP9_COMP *cpi) {
197
  VP9_COMMON *cm = &cpi->common;
Adrian Grange's avatar
Adrian Grange committed
198
  if (cm->error_resilient_mode || cm->intra_only)
199
    vp9_setup_past_independence(cm);
200

Dmitry Kovalev's avatar
Dmitry Kovalev committed
201
  assert(cm->frame_context_idx < FRAME_CONTEXTS);
202
  cm->fc = cm->frame_contexts[cm->frame_context_idx];
203
}
John Koleszar's avatar
John Koleszar committed
204

205
static int estimate_bits_at_q(int frame_kind, int q, int mbs,
John Koleszar's avatar
John Koleszar committed
206
                              double correction_factor) {
207
  const int bpm = (int)(vp9_rc_bits_per_mb(frame_kind, q, correction_factor));
John Koleszar's avatar
John Koleszar committed
208

209
210
211
212
213
  // 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;
214
}
215

216
217
218
219
220
221
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;
222
  if (cpi->refresh_golden_frame && rc->is_src_frame_alt_ref) {
223
224
225
226
    // 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.
227
    target = min_frame_target;
228
229
230
231
232
233
  }
  // Clip the frame target to the maximum allowed value.
  if (target > rc->max_frame_bandwidth)
    target = rc->max_frame_bandwidth;
  return target;
}
234

235
236
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
237
238
  const VP9_CONFIG *oxcf = &cpi->oxcf;
  if (oxcf->rc_max_intra_bitrate_pct) {
239
    const int max_rate = rc->av_per_frame_bandwidth *
240
        oxcf->rc_max_intra_bitrate_pct / 100;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
241
    target = MIN(target, max_rate);
John Koleszar's avatar
John Koleszar committed
242
  }
243
244
245
  if (target > rc->max_frame_bandwidth)
    target = rc->max_frame_bandwidth;
  return target;
John Koleszar's avatar
John Koleszar committed
246
247
}

248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267

// 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;
  }
}

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

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

281
  // Clip the buffer level to the maximum specified buffer size.
282
283
284
285
286
287
  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);
  }
288
289
}

290
int vp9_rc_drop_frame(VP9_COMP *cpi) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
291
  const VP9_CONFIG *oxcf = &cpi->oxcf;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
292
293
  RATE_CONTROL *const rc = &cpi->rc;

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

328
329
330
331
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 {
332
333
    if ((cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) &&
        !(cpi->use_svc && cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
334
335
336
337
338
339
340
341
342
343
      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 {
344
345
    if ((cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) &&
        !(cpi->use_svc && cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
346
347
348
349
350
351
      cpi->rc.gf_rate_correction_factor = factor;
    else
      cpi->rc.rate_correction_factor = factor;
  }
}

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

358
  int projected_size_based_on_q = 0;
John Koleszar's avatar
John Koleszar committed
359

John Koleszar's avatar
John Koleszar committed
360
  // Clear down mmx registers to allow floating point in what follows
361
  vp9_clear_system_state();
John Koleszar's avatar
John Koleszar committed
362

363
364
  // 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
365
  // Stay in double to avoid int overflow when values are large
366
367
368
  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
369
370
  // Work out a size correction factor.
  if (projected_size_based_on_q > 0)
371
372
    correction_factor = (100 * cpi->rc.projected_frame_size) /
                            projected_size_based_on_q;
John Koleszar's avatar
John Koleszar committed
373

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

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

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

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

411
  set_rate_correction_factor(cpi, rate_correction_factor);
John Koleszar's avatar
John Koleszar committed
412
413
414
}


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

423
424
  // Calculate required scaling factor based on target frame size and size of
  // frame produced using previous Q.
John Koleszar's avatar
John Koleszar committed
425
  if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
426
427
    // 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
428
  else
429
    target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cm->MBs;
John Koleszar's avatar
John Koleszar committed
430

Deb Mukherjee's avatar
Deb Mukherjee committed
431
  i = active_best_quality;
John Koleszar's avatar
John Koleszar committed
432

John Koleszar's avatar
John Koleszar committed
433
  do {
434
435
    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
436

John Koleszar's avatar
John Koleszar committed
437
438
    if (bits_per_mb_at_this_q <= target_bits_per_mb) {
      if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
439
        q = i;
John Koleszar's avatar
John Koleszar committed
440
      else
441
        q = i - 1;
John Koleszar's avatar
John Koleszar committed
442

John Koleszar's avatar
John Koleszar committed
443
      break;
444
    } else {
John Koleszar's avatar
John Koleszar committed
445
      last_error = bits_per_mb_at_this_q - target_bits_per_mb;
446
    }
Deb Mukherjee's avatar
Deb Mukherjee committed
447
  } while (++i <= active_worst_quality);
448
449
450
451

  return q;
}

452
453
static int get_active_quality(int q, int gfu_boost, int low, int high,
                              int *low_motion_minq, int *high_motion_minq) {
454
  if (gfu_boost > high) {
455
    return low_motion_minq[q];
456
  } else if (gfu_boost < low) {
457
    return high_motion_minq[q];
458
459
460
461
462
  } 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;
463
    return low_motion_minq[q] + adjustment;
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
503
504
505
506
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.
507
508
  int64_t critical_level = oxcf->optimal_buffer_level >> 2;
  int64_t buff_lvl_step = 0;
509
510
511
512
513
514
515
516
517
518
519
520
  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.
521
    // Maximum limit for down adjustment, ~30%.
522
523
    int max_adjustment_down = active_worst_quality / 3;
    if (max_adjustment_down) {
524
525
      buff_lvl_step = ((oxcf->maximum_buffer_size -
                        oxcf->optimal_buffer_level) / max_adjustment_down);
526
527
528
529
530
531
532
533
534
535
      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) {
536
537
538
539
        adjustment =
            (int)((rc->worst_quality - rc->avg_frame_qindex[INTER_FRAME]) *
                  (oxcf->optimal_buffer_level - rc->buffer_level) /
                  buff_lvl_step);
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
      }
      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 &&
593
             !cpi->use_svc &&
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
658
659
660
661
662
             (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
663
  const VP9_COMMON *const cm = &cpi->common;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
664
665
  const RATE_CONTROL *const rc = &cpi->rc;
  const VP9_CONFIG *const oxcf = &cpi->oxcf;
Deb Mukherjee's avatar
Deb Mukherjee committed
666
  int active_best_quality;
667
  int active_worst_quality = calc_active_worst_quality_one_pass_vbr(cpi);
Deb Mukherjee's avatar
Deb Mukherjee committed
668
  int q;
669
670

  if (frame_is_intra_only(cm)) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
671
    active_best_quality = rc->best_quality;
672
673
674
675
#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
676
677
    if (rc->this_key_frame_forced) {
      int qindex = rc->last_boosted_qindex;
678
      double last_boosted_q = vp9_convert_qindex_to_q(qindex);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
679
680
681
      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);
682
    } else if (cm->current_video_frame > 0) {
Alex Converse's avatar
Alex Converse committed
683
      // not first frame of one pass and kf_boost is set
684
685
686
      double q_adj_factor = 1.0;
      double q_val;

687
      active_best_quality = get_active_quality(rc->avg_frame_qindex[KEY_FRAME],
Dmitry Kovalev's avatar
Dmitry Kovalev committed
688
                                               rc->kf_boost,
Deb Mukherjee's avatar
Deb Mukherjee committed
689
690
691
                                               kf_low, kf_high,
                                               kf_low_motion_minq,
                                               kf_high_motion_minq);
692
693
694
695
696
697
698
699

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
740
    } else if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
741
      if (!cpi->refresh_alt_ref_frame) {
Deb Mukherjee's avatar
Deb Mukherjee committed
742
        active_best_quality = cpi->cq_target_quality;
743
      } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
744
        if (rc->frames_since_key > 1) {
Deb Mukherjee's avatar
Deb Mukherjee committed
745
          active_best_quality = get_active_quality(
Dmitry Kovalev's avatar
Dmitry Kovalev committed
746
              q, rc->gfu_boost, gf_low, gf_high,
747
              afq_low_motion_minq, afq_high_motion_minq);
748
        } else {
Deb Mukherjee's avatar
Deb Mukherjee committed
749
          active_best_quality = get_active_quality(
Dmitry Kovalev's avatar
Dmitry Kovalev committed
750
              q, rc->gfu_boost, gf_low, gf_high,
751
              gf_low_motion_minq, gf_high_motion_minq);
752
753
754
        }
      }
    } else {
Deb Mukherjee's avatar
Deb Mukherjee committed
755
      active_best_quality = get_active_quality(
Dmitry Kovalev's avatar
Dmitry Kovalev committed
756
          q, rc->gfu_boost, gf_low, gf_high,
Deb Mukherjee's avatar
Deb Mukherjee committed
757
          gf_low_motion_minq, gf_high_motion_minq);
758
759
    }
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
760
    if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
Deb Mukherjee's avatar
Deb Mukherjee committed
761
      active_best_quality = cpi->cq_target_quality;
762
    } else {
763
      // Use the lower of active_worst_quality and recent/average Q.
764
765
766
767
      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]];
768
769
      // For the constrained quality mode we don't want
      // q to fall below the cq level.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
770
      if ((oxcf->end_usage == USAGE_CONSTRAINED_QUALITY) &&
Deb Mukherjee's avatar
Deb Mukherjee committed
771
          (active_best_quality < cpi->cq_target_quality)) {
772
773
774
        // 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
775
776
        if (rc->rolling_actual_bits < rc->min_frame_bandwidth)
          active_best_quality = oxcf->cq_level;
777
        else
Deb Mukherjee's avatar
Deb Mukherjee committed
778
          active_best_quality = cpi->cq_target_quality;
779
780
781
782
783
      }
    }
  }

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

Deb Mukherjee's avatar
Deb Mukherjee committed
789
790
  *top_index = active_worst_quality;
  *bottom_index = active_best_quality;
791
792

#if LIMIT_QRANGE_FOR_ALTREF_AND_KEY
793
  // Limit Q range for the adaptive loop.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
794
  if (cm->frame_type == KEY_FRAME && !rc->this_key_frame_forced) {
795
    if (!(cm->current_video_frame == 0))
796
      *top_index = (active_worst_quality + active_best_quality * 3) / 4;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
797
  } else if (!rc->is_src_frame_alt_ref &&
798
             (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
799
    *top_index = (active_worst_quality + active_best_quality) / 2;
800
  }
801
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
802
  if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
Deb Mukherjee's avatar
Deb Mukherjee committed
803
    q = active_best_quality;
804
  // Special case code to try and match quality with forced key frames
Dmitry Kovalev's avatar
Dmitry Kovalev committed
805
806
  } else if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced) {
    q = rc->last_boosted_qindex;
807
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
808
    q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
809
                          active_best_quality, active_worst_quality);
Paul Wilkins's avatar
Paul Wilkins committed
810
811
812
813
814
815
816
    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;
    }
817
  }
Deb Mukherjee's avatar
Deb Mukherjee committed
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
#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
835
836
837
838
839
  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);
840
  return q;
John Koleszar's avatar
John Koleszar committed
841
842
}

843
844
845
static int rc_pick_q_and_bounds_two_pass(const VP9_COMP *cpi,
                                         int *bottom_index,
                                         int *top_index) {
846
847
848
849
  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;
850
  int active_worst_quality = cpi->twopass.active_worst_quality;
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
  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.
966
967
968
969
  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);
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

  *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;
    }
  }