vp9_ratectrl.c 51.1 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

// 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))
Dmitry Kovalev's avatar
Dmitry Kovalev committed
58
static int get_minq_index(double maxq, double x3, double x2, double x1) {
59
  int i;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
60
  const double minqtarget = MIN(((x3 * maxq + x2) * maxq + x1) * maxq,
61
62
63
64
65
66
67
                                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;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
68
  for (i = 0; i < QINDEX_RANGE; i++)
69
70
71
72
73
74
    if (minqtarget <= vp9_convert_qindex_to_q(i))
      return i;

  return QINDEX_RANGE - 1;
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
75
void vp9_rc_init_minq_luts() {
76
77
78
79
80
  int i;

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
81
82
83
84
85
86
87
    kf_low_motion_minq[i] = get_minq_index(maxq, 0.000001, -0.0004, 0.15);
    kf_high_motion_minq[i] = get_minq_index(maxq, 0.000002, -0.0012, 0.50);
    gf_low_motion_minq[i] = get_minq_index(maxq, 0.0000015, -0.0009, 0.32);
    gf_high_motion_minq[i] = get_minq_index(maxq, 0.0000021, -0.00125, 0.50);
    afq_low_motion_minq[i] = get_minq_index(maxq, 0.0000015, -0.0009, 0.33);
    afq_high_motion_minq[i] = get_minq_index(maxq, 0.0000021, -0.00125, 0.55);
    inter_minq[i] = get_minq_index(maxq, 0.00000271, -0.00113, 0.75);
88
89
90
  }
}

Paul Wilkins's avatar
Paul Wilkins committed
91
92
93
// 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
94
double vp9_convert_qindex_to_q(int qindex) {
John Koleszar's avatar
John Koleszar committed
95
  // Convert the index to a real Q value (scaled down to match old Q values)
96
  return vp9_ac_quant(qindex, 0) / 4.0;
Paul Wilkins's avatar
Paul Wilkins committed
97
98
}

99
100
int vp9_rc_bits_per_mb(FRAME_TYPE frame_type, int qindex,
                       double correction_factor) {
101
  const double q = vp9_convert_qindex_to_q(qindex);
102
  int enumerator = frame_type == KEY_FRAME ? 3300000 : 2250000;
Paul Wilkins's avatar
Paul Wilkins committed
103

104
  // q based adjustment to baseline enumerator
Paul Wilkins's avatar
Paul Wilkins committed
105
  enumerator += (int)(enumerator * q) >> 12;
106
107
  return (int)(0.5 + (enumerator * correction_factor / q));
}
John Koleszar's avatar
John Koleszar committed
108

109
void vp9_save_coding_context(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
110
  CODING_CONTEXT *const cc = &cpi->coding_context;
111
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
112

John Koleszar's avatar
John Koleszar committed
113
  // Stores a snapshot of key state variables which can subsequently be
114
  // restored with a call to vp9_restore_coding_context. These functions are
115
  // intended for use in a re-code loop in vp9_compress_frame where the
John Koleszar's avatar
John Koleszar committed
116
  // quantizer value is adjusted between loop iterations.
117
118
119
120
  vp9_copy(cc->nmvjointcost,  cpi->mb.nmvjointcost);
  vp9_copy(cc->nmvcosts,  cpi->mb.nmvcosts);
  vp9_copy(cc->nmvcosts_hp,  cpi->mb.nmvcosts_hp);

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

John Koleszar's avatar
John Koleszar committed
123
  vpx_memcpy(cpi->coding_context.last_frame_seg_map_copy,
124
             cm->last_frame_seg_map, (cm->mi_rows * cm->mi_cols));
John Koleszar's avatar
John Koleszar committed
125

126
127
  vp9_copy(cc->last_ref_lf_deltas, cm->lf.last_ref_deltas);
  vp9_copy(cc->last_mode_lf_deltas, cm->lf.last_mode_deltas);
128

129
  cc->fc = cm->fc;
130
}
John Koleszar's avatar
John Koleszar committed
131

132
void vp9_restore_coding_context(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
133
  CODING_CONTEXT *const cc = &cpi->coding_context;
134
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
135

John Koleszar's avatar
John Koleszar committed
136
  // Restore key state variables to the snapshot state stored in the
137
  // previous call to vp9_save_coding_context.
138
139
140
141
  vp9_copy(cpi->mb.nmvjointcost, cc->nmvjointcost);
  vp9_copy(cpi->mb.nmvcosts, cc->nmvcosts);
  vp9_copy(cpi->mb.nmvcosts_hp, cc->nmvcosts_hp);

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

John Koleszar's avatar
John Koleszar committed
144
145
  vpx_memcpy(cm->last_frame_seg_map,
             cpi->coding_context.last_frame_seg_map_copy,
146
             (cm->mi_rows * cm->mi_cols));
John Koleszar's avatar
John Koleszar committed
147

148
149
  vp9_copy(cm->lf.last_ref_deltas, cc->last_ref_lf_deltas);
  vp9_copy(cm->lf.last_mode_deltas, cc->last_mode_lf_deltas);
150

151
  cm->fc = cc->fc;
John Koleszar's avatar
John Koleszar committed
152
153
}

154
static int estimate_bits_at_q(int frame_kind, int q, int mbs,
John Koleszar's avatar
John Koleszar committed
155
                              double correction_factor) {
156
  const int bpm = (int)(vp9_rc_bits_per_mb(frame_kind, q, correction_factor));
John Koleszar's avatar
John Koleszar committed
157

158
159
160
161
162
  // 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;
163
}
164

165
166
167
168
169
170
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;
171
  if (cpi->refresh_golden_frame && rc->is_src_frame_alt_ref) {
172
173
174
175
    // 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.
176
    target = min_frame_target;
177
178
179
180
181
182
  }
  // Clip the frame target to the maximum allowed value.
  if (target > rc->max_frame_bandwidth)
    target = rc->max_frame_bandwidth;
  return target;
}
183

184
185
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
186
187
  const VP9_CONFIG *oxcf = &cpi->oxcf;
  if (oxcf->rc_max_intra_bitrate_pct) {
188
    const int max_rate = rc->av_per_frame_bandwidth *
189
        oxcf->rc_max_intra_bitrate_pct / 100;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
190
    target = MIN(target, max_rate);
John Koleszar's avatar
John Koleszar committed
191
  }
192
193
194
  if (target > rc->max_frame_bandwidth)
    target = rc->max_frame_bandwidth;
  return target;
John Koleszar's avatar
John Koleszar committed
195
196
}

197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216

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

217
// Update the buffer level: leaky bucket model.
218
static void update_buffer_level(VP9_COMP *cpi, int encoded_frame_size) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
219
220
  const VP9_COMMON *const cm = &cpi->common;
  const VP9_CONFIG *oxcf = &cpi->oxcf;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
221
  RATE_CONTROL *const rc = &cpi->rc;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
222

223
224
  // Non-viewable frames are a special case and are treated as pure overhead.
  if (!cm->show_frame) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
225
    rc->bits_off_target -= encoded_frame_size;
226
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
227
    rc->bits_off_target += rc->av_per_frame_bandwidth - encoded_frame_size;
228
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
229

230
  // Clip the buffer level to the maximum specified buffer size.
231
232
233
234
235
236
  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);
  }
237
238
}

239
int vp9_rc_drop_frame(VP9_COMP *cpi) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
240
  const VP9_CONFIG *oxcf = &cpi->oxcf;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
241
242
  RATE_CONTROL *const rc = &cpi->rc;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
243
  if (!oxcf->drop_frames_water_mark) {
244
245
    return 0;
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
246
    if (rc->buffer_level < 0) {
247
248
249
250
251
      // 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
252
      int drop_mark = (int)(oxcf->drop_frames_water_mark *
253
          oxcf->optimal_buffer_level / 100);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
254
255
256
257
258
259
      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;
260
      }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
261
262
263
      if (rc->decimation_factor > 0) {
        if (rc->decimation_count > 0) {
          --rc->decimation_count;
264
265
          return 1;
        } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
266
          rc->decimation_count = rc->decimation_factor;
267
268
269
          return 0;
        }
      } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
270
        rc->decimation_count = 0;
271
272
273
274
275
276
        return 0;
      }
    }
  }
}

277
278
279
280
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 {
281
282
    if ((cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) &&
        !(cpi->use_svc && cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
283
284
285
286
287
288
289
290
291
292
      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 {
293
294
    if ((cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) &&
        !(cpi->use_svc && cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
295
296
297
298
299
300
      cpi->rc.gf_rate_correction_factor = factor;
    else
      cpi->rc.rate_correction_factor = factor;
  }
}

301
void vp9_rc_update_rate_correction_factors(VP9_COMP *cpi, int damp_var) {
302
303
  const int q = cpi->common.base_qindex;
  int correction_factor = 100;
304
  double rate_correction_factor = get_rate_correction_factor(cpi);
John Koleszar's avatar
John Koleszar committed
305
  double adjustment_limit;
John Koleszar's avatar
John Koleszar committed
306

307
  int projected_size_based_on_q = 0;
John Koleszar's avatar
John Koleszar committed
308

John Koleszar's avatar
John Koleszar committed
309
  // Clear down mmx registers to allow floating point in what follows
310
  vp9_clear_system_state();
John Koleszar's avatar
John Koleszar committed
311

312
313
  // 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
314
  // Stay in double to avoid int overflow when values are large
315
316
317
  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
318
319
  // Work out a size correction factor.
  if (projected_size_based_on_q > 0)
320
321
    correction_factor = (100 * cpi->rc.projected_frame_size) /
                            projected_size_based_on_q;
John Koleszar's avatar
John Koleszar committed
322

323
324
  // More heavily damped adjustment used if we have been oscillating either side
  // of target.
John Koleszar's avatar
John Koleszar committed
325
  switch (damp_var) {
John Koleszar's avatar
John Koleszar committed
326
    case 0:
John Koleszar's avatar
John Koleszar committed
327
328
      adjustment_limit = 0.75;
      break;
John Koleszar's avatar
John Koleszar committed
329
    case 1:
John Koleszar's avatar
John Koleszar committed
330
331
      adjustment_limit = 0.375;
      break;
John Koleszar's avatar
John Koleszar committed
332
333
    case 2:
    default:
John Koleszar's avatar
John Koleszar committed
334
335
336
337
338
339
      adjustment_limit = 0.25;
      break;
  }

  if (correction_factor > 102) {
    // We are not already at the worst allowable quality
340
    correction_factor =
341
        (int)(100 + ((correction_factor - 100) * adjustment_limit));
342
343
    rate_correction_factor =
        ((rate_correction_factor * correction_factor) / 100);
John Koleszar's avatar
John Koleszar committed
344
345
346
347

    // Keep rate_correction_factor within limits
    if (rate_correction_factor > MAX_BPB_FACTOR)
      rate_correction_factor = MAX_BPB_FACTOR;
348
  } else if (correction_factor < 99) {
John Koleszar's avatar
John Koleszar committed
349
    // We are not already at the best allowable quality
350
    correction_factor =
351
        (int)(100 - ((100 - correction_factor) * adjustment_limit));
352
353
    rate_correction_factor =
        ((rate_correction_factor * correction_factor) / 100);
John Koleszar's avatar
John Koleszar committed
354
355
356
357
358
359

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

360
  set_rate_correction_factor(cpi, rate_correction_factor);
John Koleszar's avatar
John Koleszar committed
361
362
363
}


Deb Mukherjee's avatar
Deb Mukherjee committed
364
365
int vp9_rc_regulate_q(const VP9_COMP *cpi, int target_bits_per_frame,
                      int active_best_quality, int active_worst_quality) {
366
  const VP9_COMMON *const cm = &cpi->common;
Deb Mukherjee's avatar
Deb Mukherjee committed
367
  int q = active_worst_quality;
John Koleszar's avatar
John Koleszar committed
368
  int last_error = INT_MAX;
369
  int i, target_bits_per_mb;
370
  const double correction_factor = get_rate_correction_factor(cpi);
John Koleszar's avatar
John Koleszar committed
371

372
373
  // Calculate required scaling factor based on target frame size and size of
  // frame produced using previous Q.
John Koleszar's avatar
John Koleszar committed
374
  if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
375
376
    // 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
377
  else
378
    target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cm->MBs;
John Koleszar's avatar
John Koleszar committed
379

Deb Mukherjee's avatar
Deb Mukherjee committed
380
  i = active_best_quality;
John Koleszar's avatar
John Koleszar committed
381

John Koleszar's avatar
John Koleszar committed
382
  do {
383
384
    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
385

John Koleszar's avatar
John Koleszar committed
386
387
    if (bits_per_mb_at_this_q <= target_bits_per_mb) {
      if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
388
        q = i;
John Koleszar's avatar
John Koleszar committed
389
      else
390
        q = i - 1;
John Koleszar's avatar
John Koleszar committed
391

John Koleszar's avatar
John Koleszar committed
392
      break;
393
    } else {
John Koleszar's avatar
John Koleszar committed
394
      last_error = bits_per_mb_at_this_q - target_bits_per_mb;
395
    }
Deb Mukherjee's avatar
Deb Mukherjee committed
396
  } while (++i <= active_worst_quality);
397
398
399
400

  return q;
}

401
402
static int get_active_quality(int q, int gfu_boost, int low, int high,
                              int *low_motion_minq, int *high_motion_minq) {
403
  if (gfu_boost > high) {
404
    return low_motion_minq[q];
405
  } else if (gfu_boost < low) {
406
    return high_motion_minq[q];
407
408
409
410
411
  } 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;
412
    return low_motion_minq[q] + adjustment;
413
414
415
  }
}

416
static int calc_active_worst_quality_one_pass_vbr(const VP9_COMP *cpi) {
417
418
  const RATE_CONTROL *const rc = &cpi->rc;
  const unsigned int curr_frame = cpi->common.current_video_frame;
419
  int active_worst_quality;
420

421
  if (cpi->common.frame_type == KEY_FRAME) {
422
423
    active_worst_quality = curr_frame == 0 ? rc->worst_quality
                                           : rc->last_q[KEY_FRAME] * 2;
424
  } else {
425
426
427
428
    if (!rc->is_src_frame_alt_ref &&
        (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
      active_worst_quality =  curr_frame == 1 ? rc->last_q[KEY_FRAME] * 5 / 4
                                              : rc->last_q[INTER_FRAME];
429
    } else {
430
431
      active_worst_quality = curr_frame == 1 ? rc->last_q[KEY_FRAME] * 2
                                             : rc->last_q[INTER_FRAME] * 2;
432
433
    }
  }
434
435

  return MIN(active_worst_quality, rc->worst_quality);
436
437
438
439
440
441
442
443
444
445
446
447
}

// 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.
448
449
  int64_t critical_level = oxcf->optimal_buffer_level >> 2;
  int64_t buff_lvl_step = 0;
450
451
452
453
454
455
456
457
458
459
460
461
  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.
462
    // Maximum limit for down adjustment, ~30%.
463
464
    int max_adjustment_down = active_worst_quality / 3;
    if (max_adjustment_down) {
465
466
      buff_lvl_step = ((oxcf->maximum_buffer_size -
                        oxcf->optimal_buffer_level) / max_adjustment_down);
467
468
469
470
471
472
473
474
475
476
      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) {
477
478
479
480
        adjustment =
            (int)((rc->worst_quality - rc->avg_frame_qindex[INTER_FRAME]) *
                  (oxcf->optimal_buffer_level - rc->buffer_level) /
                  buff_lvl_step);
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
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
      }
      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 &&
534
             !cpi->use_svc &&
535
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
             (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
604
  const VP9_COMMON *const cm = &cpi->common;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
605
606
  const RATE_CONTROL *const rc = &cpi->rc;
  const VP9_CONFIG *const oxcf = &cpi->oxcf;
Deb Mukherjee's avatar
Deb Mukherjee committed
607
  int active_best_quality;
608
  int active_worst_quality = calc_active_worst_quality_one_pass_vbr(cpi);
Deb Mukherjee's avatar
Deb Mukherjee committed
609
  int q;
610
611

  if (frame_is_intra_only(cm)) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
612
    active_best_quality = rc->best_quality;
613
614
615
616
#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
617
618
    if (rc->this_key_frame_forced) {
      int qindex = rc->last_boosted_qindex;
619
      double last_boosted_q = vp9_convert_qindex_to_q(qindex);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
620
621
622
      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);
623
    } else if (cm->current_video_frame > 0) {
Alex Converse's avatar
Alex Converse committed
624
      // not first frame of one pass and kf_boost is set
625
626
627
      double q_adj_factor = 1.0;
      double q_val;

628
      active_best_quality = get_active_quality(rc->avg_frame_qindex[KEY_FRAME],
Dmitry Kovalev's avatar
Dmitry Kovalev committed
629
                                               rc->kf_boost,
Deb Mukherjee's avatar
Deb Mukherjee committed
630
631
632
                                               kf_low, kf_high,
                                               kf_low_motion_minq,
                                               kf_high_motion_minq);
633
634
635
636
637
638
639
640

      // 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
641
      q_val = vp9_convert_qindex_to_q(active_best_quality);
642
643
      active_best_quality += vp9_compute_qdelta(cpi, q_val, q_val *
                                                   q_adj_factor);
644
645
646
647
    }
#else
    double current_q;
    // Force the KF quantizer to be 30% of the active_worst_quality.
Deb Mukherjee's avatar
Deb Mukherjee committed
648
649
    current_q = vp9_convert_qindex_to_q(active_worst_quality);
    active_best_quality = active_worst_quality
650
651
        + vp9_compute_qdelta(cpi, current_q, current_q * 0.3);
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
652
  } else if (!rc->is_src_frame_alt_ref &&
653
             (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
Deb Mukherjee's avatar
Deb Mukherjee committed
654
    // Use the lower of active_worst_quality and recent
655
656
    // average Q as basis for GF/ARF best Q limit unless last frame was
    // a key frame.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
657
658
659
    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
660
    } else {
661
      q = rc->avg_frame_qindex[KEY_FRAME];
662
663
    }
    // For constrained quality dont allow Q less than the cq level
Dmitry Kovalev's avatar
Dmitry Kovalev committed
664
    if (oxcf->end_usage == USAGE_CONSTRAINED_QUALITY) {
665
666
      if (q < cpi->cq_target_quality)
        q = cpi->cq_target_quality;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
667
668
      if (rc->frames_since_key > 1) {
        active_best_quality = get_active_quality(q, rc->gfu_boost,
Deb Mukherjee's avatar
Deb Mukherjee committed
669
670
671
                                                 gf_low, gf_high,
                                                 afq_low_motion_minq,
                                                 afq_high_motion_minq);
672
      } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
673
        active_best_quality = get_active_quality(q, rc->gfu_boost,
Deb Mukherjee's avatar
Deb Mukherjee committed
674
675
676
                                                 gf_low, gf_high,
                                                 gf_low_motion_minq,
                                                 gf_high_motion_minq);
677
678
      }
      // Constrained quality use slightly lower active best.
Deb Mukherjee's avatar
Deb Mukherjee committed
679
      active_best_quality = active_best_quality * 15 / 16;
680

Dmitry Kovalev's avatar
Dmitry Kovalev committed
681
    } else if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
682
      if (!cpi->refresh_alt_ref_frame) {
Deb Mukherjee's avatar
Deb Mukherjee committed
683
        active_best_quality = cpi->cq_target_quality;
684
      } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
685
        if (rc->frames_since_key > 1) {
Deb Mukherjee's avatar
Deb Mukherjee committed
686
          active_best_quality = get_active_quality(
Dmitry Kovalev's avatar
Dmitry Kovalev committed
687
              q, rc->gfu_boost, gf_low, gf_high,
688
              afq_low_motion_minq, afq_high_motion_minq);
689
        } else {
Deb Mukherjee's avatar
Deb Mukherjee committed
690
          active_best_quality = get_active_quality(
Dmitry Kovalev's avatar
Dmitry Kovalev committed
691
              q, rc->gfu_boost, gf_low, gf_high,
692
              gf_low_motion_minq, gf_high_motion_minq);
693
694
695
        }
      }
    } else {
Deb Mukherjee's avatar
Deb Mukherjee committed
696
      active_best_quality = get_active_quality(
Dmitry Kovalev's avatar
Dmitry Kovalev committed
697
          q, rc->gfu_boost, gf_low, gf_high,
Deb Mukherjee's avatar
Deb Mukherjee committed
698
          gf_low_motion_minq, gf_high_motion_minq);
699
700
    }
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
701
    if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
Deb Mukherjee's avatar
Deb Mukherjee committed
702
      active_best_quality = cpi->cq_target_quality;
703
    } else {
704
      // Use the lower of active_worst_quality and recent/average Q.
705
706
707
708
      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]];
709
710
      // For the constrained quality mode we don't want
      // q to fall below the cq level.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
711
      if ((oxcf->end_usage == USAGE_CONSTRAINED_QUALITY) &&
Deb Mukherjee's avatar
Deb Mukherjee committed
712
          (active_best_quality < cpi->cq_target_quality)) {
713
714
715
        // 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
716
717
        if (rc->rolling_actual_bits < rc->min_frame_bandwidth)
          active_best_quality = oxcf->cq_level;
718
        else
Deb Mukherjee's avatar
Deb Mukherjee committed
719
          active_best_quality = cpi->cq_target_quality;
720
721
722
723
724
      }
    }
  }

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

Deb Mukherjee's avatar
Deb Mukherjee committed
730
731
  *top_index = active_worst_quality;
  *bottom_index = active_best_quality;
732
733

#if LIMIT_QRANGE_FOR_ALTREF_AND_KEY
734
  // Limit Q range for the adaptive loop.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
735
  if (cm->frame_type == KEY_FRAME && !rc->this_key_frame_forced) {
736
    if (!(cm->current_video_frame == 0))
737
      *top_index = (active_worst_quality + active_best_quality * 3) / 4;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
738
  } else if (!rc->is_src_frame_alt_ref &&
739
             (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
740
    *top_index = (active_worst_quality + active_best_quality) / 2;
741
  }
742
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
743
  if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
Deb Mukherjee's avatar
Deb Mukherjee committed
744
    q = active_best_quality;
745
  // Special case code to try and match quality with forced key frames
Dmitry Kovalev's avatar
Dmitry Kovalev committed
746
747
  } else if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced) {
    q = rc->last_boosted_qindex;
748
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
749
    q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
750
                          active_best_quality, active_worst_quality);
Paul Wilkins's avatar
Paul Wilkins committed
751
752
753
754
755
756
757
    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;
    }
758
  }
Deb Mukherjee's avatar
Deb Mukherjee committed
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
#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
776
777
778
779
780
  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);
781
  return q;
John Koleszar's avatar
John Koleszar committed
782
783
}

784
785
786
static int rc_pick_q_and_bounds_two_pass(const VP9_COMP *cpi,
                                         int *bottom_index,
                                         int *top_index) {
787
788
789
790
  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;
791
  int active_worst_quality = cpi->twopass.active_worst_quality;
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
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
  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.
907
908
909
910
  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);
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

  *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.
936
      if (rc->this_frame_target >= rc->max_frame_bandwidth)
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
        *top_index = q;
      else
        q = *top_index;
    }
  }
#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
  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;
}

967
968
969
int vp9_rc_pick_q_and_bounds(const VP9_COMP *cpi,
                             int *bottom_index,
                             int *top_index) {
970
  int q;
971
972
973
974
975
976
977
978
  if (cpi->pass == 0) {
    if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
      q = rc_pick_q_and_bounds_one_pass_cbr(cpi, bottom_index, top_index);
    else
      q = rc_pick_q_and_bounds_one_pass_vbr(cpi, bottom_index, top_index);
  } else {
    q = rc_pick_q_and_bounds_two_pass(cpi, bottom_index, top_index);
  }
979
980
981
982

  // JBB : This is realtime mode.  In real time mode the first frame
  // should be larger. Q of 0 is disabled because we force tx size to be
  // 16x16...
983
  if (cpi->sf.use_nonrd_pick_mode) {
984
985
986
987
988
989
990
991
992
993
    if (cpi->common.current_video_frame == 0)
      q /= 3;
    if (q == 0)
      q++;
    if (q < *bottom_index)
      *bottom_index = q;
    else if (q > *top_index)
      *top_index = q;
  }
  return q;
994
995
}

Deb Mukherjee's avatar
Deb Mukherjee committed
996
void vp9_rc_compute_frame_size_bounds(const VP9_COMP *cpi,
997
998
999
                                      int this_frame_target,
                                      int *frame_under_shoot_limit,
                                      int *frame_over_shoot_limit) {
John Koleszar's avatar
John Koleszar committed
1000
  // Set-up bounds on acceptable frame size:
1001
  if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
John Koleszar's avatar
John Koleszar committed
1002
1003
1004
1005
    *frame_under_shoot_limit = 0;
    *frame_over_shoot_limit  = INT_MAX;
  } else {
    if (cpi->common.frame_type == KEY_FRAME) {
1006
1007
      *frame_over_shoot_limit  = this_frame_target * 9 / 8;
      *frame_under_shoot_limit = this_frame_target * 7 / 8;
John Koleszar's avatar
John Koleszar committed
1008
    } else {
1009
      if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) {
1010
1011
        *frame_over_shoot_limit  = this_frame_target * 9 / 8;
        *frame_under_shoot_limit = this_frame_target * 7 / 8;
John Koleszar's avatar
John Koleszar committed
1012
      } else {
1013
        // Strong overshoot limit for constrained quality
John Koleszar's avatar
John Koleszar committed
1014
        if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
1015
1016
          *frame_over_shoot_limit  = this_frame_target * 11 / 8;
          *frame_under_shoot_limit = this_frame_target * 2 / 8;
John Koleszar's avatar
John Koleszar committed
1017
        } else {
1018
1019
          *frame_over_shoot_limit  = this_frame_target * 11 / 8;
          *frame_under_shoot_limit = this_frame_target * 5 / 8;
John Koleszar's avatar
John Koleszar committed
1020
        }
John Koleszar's avatar
John Koleszar committed
1021
      }
John Koleszar's avatar
John Koleszar committed
1022
    }
John Koleszar's avatar
John Koleszar committed
1023
1024
1025
1026
1027
1028
1029
1030

    // For very small rate targets where the fractional adjustment
    // (eg * 7/8) may be tiny make sure there is at least a minimum
    // range.
    *frame_over_shoot_limit += 200;
    *frame_under_shoot_limit -= 200;
    if (*frame_under_shoot_limit < 0)
      *frame_under_shoot_limit = 0;
Paul Wilkins's avatar
Paul Wilkins committed
1031
1032
1033
1034
1035

    // Clip to maximum allowed rate for a frame.
    if (*frame_over_shoot_limit > cpi->rc.max_frame_bandwidth) {
      *frame_over_shoot_limit = cpi->rc.max_frame_bandwidth;
    }
John Koleszar's avatar
John Koleszar committed
1036
  }
John Koleszar's avatar
John Koleszar committed
1037
}
1038

1039
void vp9_rc_set_frame_target(VP9_COMP *cpi, int target) {
1040
1041
  const VP9_COMMON *const cm = &cpi->common;
  RATE_CONTROL *const rc = &cpi->rc;
1042

1043
  rc->this_frame_target = target;
1044
  // Target rate per SB64 (including partial SB64s.
1045
1046
  rc->sb64_target_rate = ((int64_t)rc->this_frame_target * 64 * 64) /
                             (cm->width * cm->height);
1047
}
1048

Deb Mukherjee's avatar
Deb Mukherjee committed
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
static void update_alt_ref_frame_stats(VP9_COMP *cpi) {
  // this frame refreshes means next frames don't unless specified by user
  cpi->rc.frames_since_golden = 0;

#if CONFIG_MULTIPLE_ARF
  if (!cpi->multi_arf_enabled)
#endif
    // Clear the alternate reference update pending flag.
    cpi->rc.source_alt_ref_pending = 0;

  // Set the alternate reference frame active flag
  cpi->rc.source_alt_ref_active = 1;
}

static void update_golden_frame_stats(VP9_COMP *cpi) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
1064
1065
  RATE_CONTROL *const rc = &cpi->rc;

Deb Mukherjee's avatar
Deb Mukherjee committed
1066
1067
1068
  // Update the Golden frame usage counts.
  if (cpi->refresh_golden_frame) {
    // this frame refreshes means next frames don't unless specified by user
Dmitry Kovalev's avatar
Dmitry Kovalev committed
1069
    rc->frames_since_golden = 0;
Deb Mukherjee's avatar
Deb Mukherjee committed
1070

Dmitry Kovalev's avatar
Dmitry Kovalev committed
1071
1072
    if (!rc->source_alt_ref_pending)
      rc->source_alt_ref_active = 0;
Deb Mukherjee's avatar
Deb Mukherjee committed
1073
1074

    // Decrement count down till next gf
Dmitry Kovalev's avatar
Dmitry Kovalev committed
1075
1076
    if (rc->frames_till_gf_update_due > 0)
      rc->frames_till_gf_update_due--;
Deb Mukherjee's avatar
Deb Mukherjee committed
1077
1078
1079

  } else if (!cpi->refresh_alt_ref_frame) {
    // Decrement count down till next gf
Dmitry Kovalev's avatar
Dmitry Kovalev committed
1080
1081
    if (rc->frames_till_gf_update_due > 0)
      rc->frames_till_gf_update_due--;
Deb Mukherjee's avatar
Deb Mukherjee committed
1082

Dmitry Kovalev's avatar
Dmitry Kovalev committed
1083
    rc->frames_since_golden++;
Deb Mukherjee's avatar
Deb Mukherjee committed
1084
1085
1086
  }
}

1087
void vp9_rc_postencode_update(VP9_COMP *cpi, uint64_t bytes_used) {
1088
  VP9_COMMON *const cm = &cpi->common;
1089
  RATE_CONTROL *const rc = &cpi->rc;
1090
1091

  cm->last_frame_type = cm->frame_type;
1092
  // Update rate control heuristics
1093
  rc->projected_frame_size = (int)(bytes_used << 3);
1094
1095

  // Post encode loop adjustment of Q prediction.
1096
1097
  vp9_rc_update_rate_correction_factors(
      cpi, (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF ||
1098
1099
            cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) ? 2 : 0);

1100
1101
  // Keep a record of last Q and ambient average Q.
  if (cm->frame_type == KEY_FRAME) {
1102
1103
1104
1105
    rc->last_q[KEY_FRAME] = cm->base_qindex;
    rc->avg_frame_qindex[KEY_FRAME] = ROUND_POWER_OF_TWO(
        3 * rc->avg_frame_qindex[KEY_FRAME] + cm->base_qindex, 2);
  } else if (!rc->is_src_frame_alt_ref &&
1106
1107
      (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame) &&
      !(cpi->use_svc && cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)) {
1108
1109
1110
    rc->last_q[2] = cm->base_qindex;
    rc->avg_frame_qindex[2] = ROUND_POWER_OF_TWO(
        3 * rc->avg_frame_qindex[2] + cm->base_qindex, 2);
1111
  } else {
1112
1113
1114
1115
1116
1117
    rc->last_q[INTER_FRAME] = cm->base_qindex;
    rc->avg_frame_qindex[INTER_FRAME] = ROUND_POWER_OF_TWO(
        3 * rc->avg_frame_qindex[INTER_FRAME] + cm->base_qindex, 2);
    rc->ni_frames++;
    rc->tot_q += vp9_convert_qindex_to_q(cm->base_qindex);
    rc->avg_q = rc->tot_q / (double)rc->ni_frames;
1118
1119

    // Calculate the average Q for normal inter frames (not key or GFU frames).
1120
1121
    rc->ni_tot_qi += cm->base_qindex;
    rc->ni_av_qi = rc->ni_tot_qi / rc->ni_frames;
1122
  }
1123