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


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

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

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

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

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

37
38
static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] =
    { 1, 2, 3, 4, 5 };
John Koleszar's avatar
John Koleszar committed
39

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

John Koleszar's avatar
John Koleszar committed
190
  // interval before next GF
191
  cpi->rc.frames_till_gf_update_due = cpi->rc.baseline_gf_interval;
192
  /* All buffers are implicitly updated on key frames. */
193
194
  cpi->refresh_golden_frame = 1;
  cpi->refresh_alt_ref_frame = 1;
John Koleszar's avatar
John Koleszar committed
195
}
196

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

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

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

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


218
static void calc_iframe_target_size(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
219
220
  // boost defaults to half second
  int target;
John Koleszar's avatar
John Koleszar committed
221

John Koleszar's avatar
John Koleszar committed
222
  // Clear down mmx registers to allow floating point in what follows
223
  vp9_clear_system_state();  // __asm emms;
John Koleszar's avatar
John Koleszar committed
224

John Koleszar's avatar
John Koleszar committed
225
  // New Two pass RC
226
  target = cpi->rc.per_frame_bandwidth;
John Koleszar's avatar
John Koleszar committed
227

John Koleszar's avatar
John Koleszar committed
228
  if (cpi->oxcf.rc_max_intra_bitrate_pct) {
229
    int max_rate = cpi->rc.per_frame_bandwidth
230
                 * cpi->oxcf.rc_max_intra_bitrate_pct / 100;
John Koleszar's avatar
John Koleszar committed
231

John Koleszar's avatar
John Koleszar committed
232
233
234
    if (target > max_rate)
      target = max_rate;
  }
235
  cpi->rc.this_frame_target = target;
John Koleszar's avatar
John Koleszar committed
236
237
}

238
//  Do the best we can to define the parameters for the next GF based
Paul Wilkins's avatar
Paul Wilkins committed
239
//  on what information we have available.
240
241
242
//
//  In this experimental code only two pass is supported
//  so we just use the interval determined in the two pass code.
243
static void calc_gf_params(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
244
  // Set the gf interval
245
  cpi->rc.frames_till_gf_update_due = cpi->rc.baseline_gf_interval;
John Koleszar's avatar
John Koleszar committed
246
247
248
}


249
static void calc_pframe_target_size(VP9_COMP *cpi) {
250
251
  const int min_frame_target = MAX(cpi->rc.min_frame_bandwidth,
                                   cpi->rc.av_per_frame_bandwidth >> 5);
252
  if (cpi->refresh_alt_ref_frame) {
253
    // Special alt reference frame case
John Koleszar's avatar
John Koleszar committed
254
    // Per frame bit target for the alt ref frame
255
256
    cpi->rc.per_frame_bandwidth = cpi->twopass.gf_bits;
    cpi->rc.this_frame_target = cpi->rc.per_frame_bandwidth;
257
258
  } else {
    // Normal frames (gf,and inter)
259
    cpi->rc.this_frame_target = cpi->rc.per_frame_bandwidth;
John Koleszar's avatar
John Koleszar committed
260
  }
John Koleszar's avatar
John Koleszar committed
261

262
263
264
265
266
267
  // Check that the total sum of adjustments is not above the maximum allowed.
  // That is, having allowed for the KF and GF penalties, we have not pushed
  // the current inter-frame target too low. If the adjustment we apply here is
  // not capable of recovering all the extra bits we have spent in the KF or GF,
  // then the remainder will have to be recovered over a longer time span via
  // other buffer / rate control mechanisms.
268
269
  if (cpi->rc.this_frame_target < min_frame_target)
    cpi->rc.this_frame_target = min_frame_target;
John Koleszar's avatar
John Koleszar committed
270
271

  // Adjust target frame size for Golden Frames:
272
  if (cpi->rc.frames_till_gf_update_due == 0) {
273
    cpi->refresh_golden_frame = 1;
John Koleszar's avatar
John Koleszar committed
274
275
276
277
278
    calc_gf_params(cpi);
    // If we are using alternate ref instead of gf then do not apply the boost
    // It will instead be applied to the altref update
    // Jims modified boost
    if (!cpi->source_alt_ref_active) {
279
280
281
      // The spend on the GF is defined in the two pass code
      // for two pass encodes
      cpi->rc.this_frame_target = cpi->rc.per_frame_bandwidth;
282
283
    } else {
      // If there is an active ARF at this location use the minimum
284
      // bits on this frame even if it is a constructed arf.
285
      // The active maximum quantizer insures that an appropriate
286
      // number of bits will be spent if needed for constructed ARFs.
287
      cpi->rc.this_frame_target = 0;
John Koleszar's avatar
John Koleszar committed
288
    }
John Koleszar's avatar
John Koleszar committed
289
  }
John Koleszar's avatar
John Koleszar committed
290
291
}

292
void vp9_rc_update_rate_correction_factors(VP9_COMP *cpi, int damp_var) {
293
294
  const int q = cpi->common.base_qindex;
  int correction_factor = 100;
John Koleszar's avatar
John Koleszar committed
295
296
  double rate_correction_factor;
  double adjustment_limit;
John Koleszar's avatar
John Koleszar committed
297

298
  int projected_size_based_on_q = 0;
John Koleszar's avatar
John Koleszar committed
299

John Koleszar's avatar
John Koleszar committed
300
  // Clear down mmx registers to allow floating point in what follows
301
  vp9_clear_system_state();  // __asm emms;
John Koleszar's avatar
John Koleszar committed
302

John Koleszar's avatar
John Koleszar committed
303
  if (cpi->common.frame_type == KEY_FRAME) {
304
    rate_correction_factor = cpi->rc.key_frame_rate_correction_factor;
John Koleszar's avatar
John Koleszar committed
305
  } else {
306
    if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame)
307
      rate_correction_factor = cpi->rc.gf_rate_correction_factor;
John Koleszar's avatar
John Koleszar committed
308
    else
309
      rate_correction_factor = cpi->rc.rate_correction_factor;
John Koleszar's avatar
John Koleszar committed
310
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
320

  // Work out a size correction factor.
  if (projected_size_based_on_q > 0)
321
    correction_factor =
322
        (100 * cpi->rc.projected_frame_size) / projected_size_based_on_q;
John Koleszar's avatar
John Koleszar committed
323

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

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

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

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

361
  if (cpi->common.frame_type == KEY_FRAME) {
362
    cpi->rc.key_frame_rate_correction_factor = rate_correction_factor;
363
  } else {
364
    if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame)
365
      cpi->rc.gf_rate_correction_factor = rate_correction_factor;
John Koleszar's avatar
John Koleszar committed
366
    else
367
      cpi->rc.rate_correction_factor = rate_correction_factor;
John Koleszar's avatar
John Koleszar committed
368
  }
John Koleszar's avatar
John Koleszar committed
369
370
371
}


Deb Mukherjee's avatar
Deb Mukherjee committed
372
373
374
int vp9_rc_regulate_q(const VP9_COMP *cpi, int target_bits_per_frame,
                      int active_best_quality, int active_worst_quality) {
  int q = active_worst_quality;
John Koleszar's avatar
John Koleszar committed
375

John Koleszar's avatar
John Koleszar committed
376
377
378
379
380
  int i;
  int last_error = INT_MAX;
  int target_bits_per_mb;
  int bits_per_mb_at_this_q;
  double correction_factor;
381

John Koleszar's avatar
John Koleszar committed
382
  // Select the appropriate correction factor based upon type of frame.
383
  if (cpi->common.frame_type == KEY_FRAME) {
384
    correction_factor = cpi->rc.key_frame_rate_correction_factor;
385
  } else {
386
    if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame)
387
      correction_factor = cpi->rc.gf_rate_correction_factor;
John Koleszar's avatar
John Koleszar committed
388
    else
389
      correction_factor = cpi->rc.rate_correction_factor;
John Koleszar's avatar
John Koleszar committed
390
  }
John Koleszar's avatar
John Koleszar committed
391

392
393
  // Calculate required scaling factor based on target frame size and size of
  // frame produced using previous Q.
John Koleszar's avatar
John Koleszar committed
394
  if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
395
396
397
    target_bits_per_mb =
        (target_bits_per_frame / cpi->common.MBs)
        << BPER_MB_NORMBITS;  // Case where we would overflow int
John Koleszar's avatar
John Koleszar committed
398
  else
399
400
    target_bits_per_mb =
        (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
John Koleszar's avatar
John Koleszar committed
401

Deb Mukherjee's avatar
Deb Mukherjee committed
402
  i = active_best_quality;
John Koleszar's avatar
John Koleszar committed
403

John Koleszar's avatar
John Koleszar committed
404
  do {
405
406
    bits_per_mb_at_this_q = (int)vp9_rc_bits_per_mb(cpi->common.frame_type, i,
                                                    correction_factor);
John Koleszar's avatar
John Koleszar committed
407

John Koleszar's avatar
John Koleszar committed
408
409
    if (bits_per_mb_at_this_q <= target_bits_per_mb) {
      if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
410
        q = i;
John Koleszar's avatar
John Koleszar committed
411
      else
412
        q = i - 1;
John Koleszar's avatar
John Koleszar committed
413

John Koleszar's avatar
John Koleszar committed
414
      break;
415
    } else {
John Koleszar's avatar
John Koleszar committed
416
      last_error = bits_per_mb_at_this_q - target_bits_per_mb;
417
    }
Deb Mukherjee's avatar
Deb Mukherjee committed
418
  } while (++i <= active_worst_quality);
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443

  return q;
}

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

Deb Mukherjee's avatar
Deb Mukherjee committed
444
int vp9_rc_pick_q_and_adjust_q_bounds(const VP9_COMP *cpi,
445
                                      int *bottom_index,
Deb Mukherjee's avatar
Deb Mukherjee committed
446
447
448
449
450
451
                                      int *top_index,
                                      int *top_index_prop) {
  const VP9_COMMON *const cm = &cpi->common;
  int active_best_quality;
  int active_worst_quality = cpi->rc.active_worst_quality;
  int q;
452
453

  if (frame_is_intra_only(cm)) {
Deb Mukherjee's avatar
Deb Mukherjee committed
454
    active_best_quality = cpi->rc.best_quality;
455
456
457
458
459
460
461
462
463
464
465
#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 (cpi->this_key_frame_forced) {
      int delta_qindex;
      int qindex = cpi->rc.last_boosted_qindex;
      double last_boosted_q = vp9_convert_qindex_to_q(qindex);

      delta_qindex = vp9_compute_qdelta(cpi, last_boosted_q,
                                        (last_boosted_q * 0.75));
Deb Mukherjee's avatar
Deb Mukherjee committed
466
467
468
469
      active_best_quality = MAX(qindex + delta_qindex,
                                cpi->rc.best_quality);
    } else if (!(cpi->pass == 0 && cpi->common.current_video_frame == 0)) {
      // not first frame of one pass
470
471
472
473
      double q_adj_factor = 1.0;
      double q_val;

      // Baseline value derived from cpi->active_worst_quality and kf boost
Deb Mukherjee's avatar
Deb Mukherjee committed
474
475
476
477
478
      active_best_quality = get_active_quality(active_worst_quality,
                                               cpi->rc.kf_boost,
                                               kf_low, kf_high,
                                               kf_low_motion_minq,
                                               kf_high_motion_minq);
479
480
481
482
483
484
485
486
487
488
489

      // 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->kf_zeromotion_pct);

      // Convert the adjustment factor to a qindex delta
      // on active_best_quality.
Deb Mukherjee's avatar
Deb Mukherjee committed
490
491
      q_val = vp9_convert_qindex_to_q(active_best_quality);
      active_best_quality +=
492
493
494
495
496
          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.
Deb Mukherjee's avatar
Deb Mukherjee committed
497
498
    current_q = vp9_convert_qindex_to_q(active_worst_quality);
    active_best_quality = active_worst_quality
499
500
501
502
503
        + vp9_compute_qdelta(cpi, current_q, current_q * 0.3);
#endif
  } else if (!cpi->is_src_frame_alt_ref &&
             (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {

Deb Mukherjee's avatar
Deb Mukherjee committed
504
    // Use the lower of active_worst_quality and recent
505
506
507
    // average Q as basis for GF/ARF best Q limit unless last frame was
    // a key frame.
    if (cpi->frames_since_key > 1 &&
Deb Mukherjee's avatar
Deb Mukherjee committed
508
        cpi->rc.avg_frame_qindex < active_worst_quality) {
509
      q = cpi->rc.avg_frame_qindex;
Deb Mukherjee's avatar
Deb Mukherjee committed
510
511
    } else {
      q = active_worst_quality;
512
513
514
515
516
517
    }
    // For constrained quality dont allow Q less than the cq level
    if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
      if (q < cpi->cq_target_quality)
        q = cpi->cq_target_quality;
      if (cpi->frames_since_key > 1) {
Deb Mukherjee's avatar
Deb Mukherjee committed
518
519
520
521
        active_best_quality = get_active_quality(q, cpi->rc.gfu_boost,
                                                 gf_low, gf_high,
                                                 afq_low_motion_minq,
                                                 afq_high_motion_minq);
522
      } else {
Deb Mukherjee's avatar
Deb Mukherjee committed
523
524
525
526
        active_best_quality = get_active_quality(q, cpi->rc.gfu_boost,
                                                 gf_low, gf_high,
                                                 gf_low_motion_minq,
                                                 gf_high_motion_minq);
527
528
      }
      // Constrained quality use slightly lower active best.
Deb Mukherjee's avatar
Deb Mukherjee committed
529
      active_best_quality = active_best_quality * 15 / 16;
530
531
532

    } else if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
      if (!cpi->refresh_alt_ref_frame) {
Deb Mukherjee's avatar
Deb Mukherjee committed
533
        active_best_quality = cpi->cq_target_quality;
534
535
      } else {
        if (cpi->frames_since_key > 1) {
Deb Mukherjee's avatar
Deb Mukherjee committed
536
537
          active_best_quality = get_active_quality(
              q, cpi->rc.gfu_boost, gf_low, gf_high,
538
              afq_low_motion_minq, afq_high_motion_minq);
539
        } else {
Deb Mukherjee's avatar
Deb Mukherjee committed
540
541
          active_best_quality = get_active_quality(
              q, cpi->rc.gfu_boost, gf_low, gf_high,
542
              gf_low_motion_minq, gf_high_motion_minq);
543
544
545
        }
      }
    } else {
Deb Mukherjee's avatar
Deb Mukherjee committed
546
547
548
      active_best_quality = get_active_quality(
          q, cpi->rc.gfu_boost, gf_low, gf_high,
          gf_low_motion_minq, gf_high_motion_minq);
549
550
551
    }
  } else {
    if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
Deb Mukherjee's avatar
Deb Mukherjee committed
552
      active_best_quality = cpi->cq_target_quality;
553
    } else {
Deb Mukherjee's avatar
Deb Mukherjee committed
554
555
556
557
558
559
560
      if (cpi->pass == 0 &&
          cpi->rc.avg_frame_qindex < active_worst_quality)
        // 1-pass: for now, use the average Q for the active_best, if its lower
        // than active_worst.
        active_best_quality = inter_minq[cpi->rc.avg_frame_qindex];
      else
        active_best_quality = inter_minq[active_worst_quality];
561
562
563
564

      // For the constrained quality mode we don't want
      // q to fall below the cq level.
      if ((cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
Deb Mukherjee's avatar
Deb Mukherjee committed
565
          (active_best_quality < cpi->cq_target_quality)) {
566
567
568
569
        // 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 (cpi->rc.rolling_actual_bits < cpi->rc.min_frame_bandwidth)
Deb Mukherjee's avatar
Deb Mukherjee committed
570
          active_best_quality = cpi->oxcf.cq_level;
571
        else
Deb Mukherjee's avatar
Deb Mukherjee committed
572
          active_best_quality = cpi->cq_target_quality;
573
574
575
576
577
      }
    }
  }

  // Clip the active best and worst quality values to limits
Deb Mukherjee's avatar
Deb Mukherjee committed
578
579
  if (active_worst_quality > cpi->rc.worst_quality)
    active_worst_quality = cpi->rc.worst_quality;
580

Deb Mukherjee's avatar
Deb Mukherjee committed
581
582
  if (active_best_quality < cpi->rc.best_quality)
    active_best_quality = cpi->rc.best_quality;
583

Deb Mukherjee's avatar
Deb Mukherjee committed
584
585
  if (active_best_quality > cpi->rc.worst_quality)
    active_best_quality = cpi->rc.worst_quality;
586

Deb Mukherjee's avatar
Deb Mukherjee committed
587
588
  if (active_worst_quality < active_best_quality)
    active_worst_quality = active_best_quality;
589

Deb Mukherjee's avatar
Deb Mukherjee committed
590
591
592
  *top_index_prop = active_worst_quality;
  *top_index = active_worst_quality;
  *bottom_index = active_best_quality;
593
594

#if LIMIT_QRANGE_FOR_ALTREF_AND_KEY
595
596
  // Limit Q range for the adaptive loop.
  if (cm->frame_type == KEY_FRAME && !cpi->this_key_frame_forced) {
597
    if (!(cpi->pass == 0 && cpi->common.current_video_frame == 0)) {
Deb Mukherjee's avatar
Deb Mukherjee committed
598
      *top_index = active_worst_quality;
599
      *top_index =
Deb Mukherjee's avatar
Deb Mukherjee committed
600
          (active_worst_quality + active_best_quality * 3) / 4;
601
602
603
604
605
    }
  } else if (!cpi->is_src_frame_alt_ref &&
             (cpi->oxcf.end_usage != USAGE_STREAM_FROM_SERVER) &&
             (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
    *top_index =
Deb Mukherjee's avatar
Deb Mukherjee committed
606
      (active_worst_quality + active_best_quality) / 2;
607
  }
608
#endif
609
610

  if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
Deb Mukherjee's avatar
Deb Mukherjee committed
611
    q = active_best_quality;
612
613
614
615
616
617
618
619
620
  // Special case code to try and match quality with forced key frames
  } else if ((cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced) {
    q = cpi->rc.last_boosted_qindex;
  } else {
    // Determine initial Q to try.
    if (cpi->pass == 0) {
      // 1-pass: for now, use per-frame-bw for target size of frame, scaled
      // by |x| for key frame.
      int scale = (cm->frame_type == KEY_FRAME) ? 5 : 1;
Deb Mukherjee's avatar
Deb Mukherjee committed
621
622
      q = vp9_rc_regulate_q(cpi, scale * cpi->rc.av_per_frame_bandwidth,
                            active_best_quality, active_worst_quality);
623
    } else {
Deb Mukherjee's avatar
Deb Mukherjee committed
624
625
      q = vp9_rc_regulate_q(cpi, cpi->rc.this_frame_target,
                            active_best_quality, active_worst_quality);
626
627
628
629
    }
    if (q > *top_index)
      q = *top_index;
  }
Deb Mukherjee's avatar
Deb Mukherjee committed
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
#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
647
  return q;
John Koleszar's avatar
John Koleszar committed
648
649
}

650
static int estimate_keyframe_frequency(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
651
  int i;
John Koleszar's avatar
John Koleszar committed
652

John Koleszar's avatar
John Koleszar committed
653
654
  // Average key frame frequency
  int av_key_frame_frequency = 0;
John Koleszar's avatar
John Koleszar committed
655

John Koleszar's avatar
John Koleszar committed
656
657
658
  /* First key frame at start of sequence is a special case. We have no
   * frequency data.
   */
659
  if (cpi->rc.key_frame_count == 1) {
John Koleszar's avatar
John Koleszar committed
660
661
    /* Assume a default of 1 kf every 2 seconds, or the max kf interval,
     * whichever is smaller.
662
     */
John Koleszar's avatar
John Koleszar committed
663
    int key_freq = cpi->oxcf.key_freq > 0 ? cpi->oxcf.key_freq : 1;
James Zern's avatar
James Zern committed
664
    av_key_frame_frequency = (int)cpi->output_framerate * 2;
John Koleszar's avatar
John Koleszar committed
665

John Koleszar's avatar
John Koleszar committed
666
667
    if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq)
      av_key_frame_frequency = cpi->oxcf.key_freq;
John Koleszar's avatar
John Koleszar committed
668

669
    cpi->rc.prior_key_frame_distance[KEY_FRAME_CONTEXT - 1]
John Koleszar's avatar
John Koleszar committed
670
671
672
673
674
675
676
677
678
679
680
      = av_key_frame_frequency;
  } else {
    unsigned int total_weight = 0;
    int last_kf_interval =
      (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;

    /* reset keyframe context and calculate weighted average of last
     * KEY_FRAME_CONTEXT keyframes
     */
    for (i = 0; i < KEY_FRAME_CONTEXT; i++) {
      if (i < KEY_FRAME_CONTEXT - 1)
681
682
        cpi->rc.prior_key_frame_distance[i]
          = cpi->rc.prior_key_frame_distance[i + 1];
John Koleszar's avatar
John Koleszar committed
683
      else
684
        cpi->rc.prior_key_frame_distance[i] = last_kf_interval;
John Koleszar's avatar
John Koleszar committed
685
686

      av_key_frame_frequency += prior_key_frame_weight[i]
687
                                * cpi->rc.prior_key_frame_distance[i];
John Koleszar's avatar
John Koleszar committed
688
      total_weight += prior_key_frame_weight[i];
John Koleszar's avatar
John Koleszar committed
689
    }
John Koleszar's avatar
John Koleszar committed
690

691
    av_key_frame_frequency /= total_weight;
John Koleszar's avatar
John Koleszar committed
692
693
  }
  return av_key_frame_frequency;
694
695
696
}


697
static void adjust_key_frame_context(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
698
  // Clear down mmx registers to allow floating point in what follows
699
  vp9_clear_system_state();
John Koleszar's avatar
John Koleszar committed
700

John Koleszar's avatar
John Koleszar committed
701
  cpi->frames_since_key = 0;
702
  cpi->rc.key_frame_count++;
John Koleszar's avatar
John Koleszar committed
703
704
}

Deb Mukherjee's avatar
Deb Mukherjee committed
705
void vp9_rc_compute_frame_size_bounds(const VP9_COMP *cpi,
706
707
708
                                      int this_frame_target,
                                      int *frame_under_shoot_limit,
                                      int *frame_over_shoot_limit) {
John Koleszar's avatar
John Koleszar committed
709
  // Set-up bounds on acceptable frame size:
710
  if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
John Koleszar's avatar
John Koleszar committed
711
712
713
714
    *frame_under_shoot_limit = 0;
    *frame_over_shoot_limit  = INT_MAX;
  } else {
    if (cpi->common.frame_type == KEY_FRAME) {
715
716
      *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
717
    } else {
718
      if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) {
719
720
        *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
721
722
723
      } else {
        // Stron overshoot limit for constrained quality
        if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
724
725
          *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
726
        } else {
727
728
          *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
729
        }
John Koleszar's avatar
John Koleszar committed
730
      }
John Koleszar's avatar
John Koleszar committed
731
    }
John Koleszar's avatar
John Koleszar committed
732
733
734
735
736
737
738
739
740

    // 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;
  }
John Koleszar's avatar
John Koleszar committed
741
}
742
743

// return of 0 means drop frame
Deb Mukherjee's avatar
Deb Mukherjee committed
744
int vp9_rc_pick_frame_size_target(VP9_COMP *cpi) {
745
  VP9_COMMON *cm = &cpi->common;
746

John Koleszar's avatar
John Koleszar committed
747
748
749
750
  if (cm->frame_type == KEY_FRAME)
    calc_iframe_target_size(cpi);
  else
    calc_pframe_target_size(cpi);
751

752
753
754
  // Target rate per SB64 (including partial SB64s.
  cpi->rc.sb64_target_rate = ((int64_t)cpi->rc.this_frame_target * 64 * 64) /
                             (cpi->common.width * cpi->common.height);
John Koleszar's avatar
John Koleszar committed
755
  return 1;
756
}
757

Deb Mukherjee's avatar
Deb Mukherjee committed
758
759
void vp9_rc_postencode_update(VP9_COMP *cpi, uint64_t bytes_used,
                              int worst_q) {
760
761
762
763
764
765
766
767
768
769
  VP9_COMMON *const cm = &cpi->common;
  // Update rate control heuristics
  cpi->rc.projected_frame_size = (bytes_used << 3);

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

  cpi->rc.last_q[cm->frame_type] = cm->base_qindex;
Deb Mukherjee's avatar
Deb Mukherjee committed
770
  cpi->rc.active_worst_quality = worst_q;
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797

  // Keep record of last boosted (KF/KF/ARF) Q value.
  // If the current frame is coded at a lower Q then we also update it.
  // If all mbs in this group are skipped only update if the Q value is
  // better than that already stored.
  // This is used to help set quality in forced key frames to reduce popping
  if ((cm->base_qindex < cpi->rc.last_boosted_qindex) ||
      ((cpi->static_mb_pct < 100) &&
       ((cm->frame_type == KEY_FRAME) || cpi->refresh_alt_ref_frame ||
        (cpi->refresh_golden_frame && !cpi->is_src_frame_alt_ref)))) {
    cpi->rc.last_boosted_qindex = cm->base_qindex;
  }

  if (cm->frame_type == KEY_FRAME) {
    adjust_key_frame_context(cpi);
  }

  // Keep a record of ambient average Q.
  if (cm->frame_type != KEY_FRAME)
    cpi->rc.avg_frame_qindex = (2 + 3 * cpi->rc.avg_frame_qindex +
                            cm->base_qindex) >> 2;

  // Keep a record from which we can calculate the average Q excluding GF
  // updates and key frames.
  if (cm->frame_type != KEY_FRAME &&
      !cpi->refresh_golden_frame && !cpi->refresh_alt_ref_frame) {
    cpi->rc.ni_frames++;
Deb Mukherjee's avatar
Deb Mukherjee committed
798
    cpi->rc.tot_q += vp9_convert_qindex_to_q(cm->base_qindex);
799
800
801
    cpi->rc.avg_q = cpi->rc.tot_q / (double)cpi->rc.ni_frames;

    // Calculate the average Q for normal inter frames (not key or GFU frames).
Deb Mukherjee's avatar
Deb Mukherjee committed
802
    cpi->rc.ni_tot_qi += cm->base_qindex;
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
    cpi->rc.ni_av_qi = cpi->rc.ni_tot_qi / cpi->rc.ni_frames;
  }

  // Update the buffer level variable.
  // Non-viewable frames are a special case and are treated as pure overhead.
  if (!cm->show_frame)
    cpi->rc.bits_off_target -= cpi->rc.projected_frame_size;
  else
    cpi->rc.bits_off_target += cpi->rc.av_per_frame_bandwidth -
                               cpi->rc.projected_frame_size;

  // Clip the buffer level at the maximum buffer size
  if (cpi->rc.bits_off_target > cpi->oxcf.maximum_buffer_size)
    cpi->rc.bits_off_target = cpi->oxcf.maximum_buffer_size;

  // Rolling monitors of whether we are over or underspending used to help
  // regulate min and Max Q in two pass.
  if (cm->frame_type != KEY_FRAME) {
    cpi->rc.rolling_target_bits =
        ((cpi->rc.rolling_target_bits * 3) +
         cpi->rc.this_frame_target + 2) / 4;
    cpi->rc.rolling_actual_bits =
        ((cpi->rc.rolling_actual_bits * 3) +
         cpi->rc.projected_frame_size + 2) / 4;
    cpi->rc.long_rolling_target_bits =
        ((cpi->rc.long_rolling_target_bits * 31) +
         cpi->rc.this_frame_target + 16) / 32;
    cpi->rc.long_rolling_actual_bits =
        ((cpi->rc.long_rolling_actual_bits * 31) +
         cpi->rc.projected_frame_size + 16) / 32;
  }

  // Actual bits spent
  cpi->rc.total_actual_bits += cpi->rc.projected_frame_size;

  // Debug stats
  cpi->rc.total_target_vs_actual += (cpi->rc.this_frame_target -
                                     cpi->rc.projected_frame_size);

  cpi->rc.buffer_level = cpi->rc.bits_off_target;

#ifndef DISABLE_RC_LONG_TERM_MEM
  // Update bits left to the kf and gf groups to account for overshoot or
  // undershoot on these frames
  if (cm->frame_type == KEY_FRAME) {
    cpi->twopass.kf_group_bits += cpi->rc.this_frame_target -
                                  cpi->rc.projected_frame_size;

    cpi->twopass.kf_group_bits = MAX(cpi->twopass.kf_group_bits, 0);
  } else if (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame) {
    cpi->twopass.gf_group_bits += cpi->rc.this_frame_target -
                                  cpi->rc.projected_frame_size;

    cpi->twopass.gf_group_bits = MAX(cpi->twopass.gf_group_bits, 0);
  }
#endif
}