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

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

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

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

Paul Wilkins's avatar
Paul Wilkins committed
38
39
40
// 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
41
double vp9_convert_qindex_to_q(int qindex) {
John Koleszar's avatar
John Koleszar committed
42
  // Convert the index to a real Q value (scaled down to match old Q values)
43
  return vp9_ac_quant(qindex, 0) / 4.0;
Paul Wilkins's avatar
Paul Wilkins committed
44
45
}

46
int vp9_gfboost_qadjust(int qindex) {
47
48
49
50
  const double q = vp9_convert_qindex_to_q(qindex);
  return (int)((0.00000828 * q * q * q) +
               (-0.0055 * q * q) +
               (1.32 * q) + 79.3);
Paul Wilkins's avatar
Paul Wilkins committed
51
52
}

53
static int kfboost_qadjust(int qindex) {
54
55
56
57
  const double q = vp9_convert_qindex_to_q(qindex);
  return (int)((0.00000973 * q * q * q) +
               (-0.00613 * q * q) +
               (1.316 * q) + 121.2);
Paul Wilkins's avatar
Paul Wilkins committed
58
59
}

60
61
62
int vp9_bits_per_mb(FRAME_TYPE frame_type, int qindex,
                    double correction_factor) {

63
  const double q = vp9_convert_qindex_to_q(qindex);
64
  int enumerator = frame_type == KEY_FRAME ? 3300000 : 2250000;
Paul Wilkins's avatar
Paul Wilkins committed
65

66
  // q based adjustment to baseline enumerator
Paul Wilkins's avatar
Paul Wilkins committed
67
  enumerator += (int)(enumerator * q) >> 12;
68
69
  return (int)(0.5 + (enumerator * correction_factor / q));
}
John Koleszar's avatar
John Koleszar committed
70

71
void vp9_save_coding_context(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
72
  CODING_CONTEXT *const cc = &cpi->coding_context;
73
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
74

John Koleszar's avatar
John Koleszar committed
75
  // Stores a snapshot of key state variables which can subsequently be
76
  // restored with a call to vp9_restore_coding_context. These functions are
77
  // intended for use in a re-code loop in vp9_compress_frame where the
John Koleszar's avatar
John Koleszar committed
78
  // quantizer value is adjusted between loop iterations.
79
80
81
82
  vp9_copy(cc->nmvjointcost,  cpi->mb.nmvjointcost);
  vp9_copy(cc->nmvcosts,  cpi->mb.nmvcosts);
  vp9_copy(cc->nmvcosts_hp,  cpi->mb.nmvcosts_hp);

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

John Koleszar's avatar
John Koleszar committed
85
  vpx_memcpy(cpi->coding_context.last_frame_seg_map_copy,
86
             cm->last_frame_seg_map, (cm->mi_rows * cm->mi_cols));
John Koleszar's avatar
John Koleszar committed
87

88
89
  vp9_copy(cc->last_ref_lf_deltas, cm->lf.last_ref_deltas);
  vp9_copy(cc->last_mode_lf_deltas, cm->lf.last_mode_deltas);
90

91
  cc->fc = cm->fc;
92
}
John Koleszar's avatar
John Koleszar committed
93

94
void vp9_restore_coding_context(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
95
  CODING_CONTEXT *const cc = &cpi->coding_context;
96
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
97

John Koleszar's avatar
John Koleszar committed
98
  // Restore key state variables to the snapshot state stored in the
99
  // previous call to vp9_save_coding_context.
100
101
102
103
  vp9_copy(cpi->mb.nmvjointcost, cc->nmvjointcost);
  vp9_copy(cpi->mb.nmvcosts, cc->nmvcosts);
  vp9_copy(cpi->mb.nmvcosts_hp, cc->nmvcosts_hp);

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

John Koleszar's avatar
John Koleszar committed
106
107
  vpx_memcpy(cm->last_frame_seg_map,
             cpi->coding_context.last_frame_seg_map_copy,
108
             (cm->mi_rows * cm->mi_cols));
John Koleszar's avatar
John Koleszar committed
109

110
111
  vp9_copy(cm->lf.last_ref_deltas, cc->last_ref_lf_deltas);
  vp9_copy(cm->lf.last_mode_deltas, cc->last_mode_lf_deltas);
112

113
  cm->fc = cc->fc;
John Koleszar's avatar
John Koleszar committed
114
115
}

116
117
void vp9_setup_key_frame(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
118

119
  vp9_setup_past_independence(cm);
John Koleszar's avatar
John Koleszar committed
120

John Koleszar's avatar
John Koleszar committed
121
122
  // interval before next GF
  cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
123
  /* All buffers are implicitly updated on key frames. */
124
125
  cpi->refresh_golden_frame = 1;
  cpi->refresh_alt_ref_frame = 1;
John Koleszar's avatar
John Koleszar committed
126
}
127

128
void vp9_setup_inter_frame(VP9_COMP *cpi) {
129
  VP9_COMMON *cm = &cpi->common;
Adrian Grange's avatar
Adrian Grange committed
130
  if (cm->error_resilient_mode || cm->intra_only)
131
    vp9_setup_past_independence(cm);
132

133
  assert(cm->frame_context_idx < NUM_FRAME_CONTEXTS);
134
  cm->fc = cm->frame_contexts[cm->frame_context_idx];
135
}
John Koleszar's avatar
John Koleszar committed
136

137
static int estimate_bits_at_q(int frame_kind, int q, int mbs,
John Koleszar's avatar
John Koleszar committed
138
                              double correction_factor) {
139
  const int bpm = (int)(vp9_bits_per_mb(frame_kind, q, correction_factor));
John Koleszar's avatar
John Koleszar committed
140

141
142
143
144
145
  // 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;
146
}
147
148


149
static void calc_iframe_target_size(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
150
151
  // boost defaults to half second
  int target;
John Koleszar's avatar
John Koleszar committed
152

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

John Koleszar's avatar
John Koleszar committed
156
157
  // New Two pass RC
  target = cpi->per_frame_bandwidth;
John Koleszar's avatar
John Koleszar committed
158

John Koleszar's avatar
John Koleszar committed
159
  if (cpi->oxcf.rc_max_intra_bitrate_pct) {
160
161
    int max_rate = cpi->per_frame_bandwidth
                 * cpi->oxcf.rc_max_intra_bitrate_pct / 100;
John Koleszar's avatar
John Koleszar committed
162

John Koleszar's avatar
John Koleszar committed
163
164
165
    if (target > max_rate)
      target = max_rate;
  }
John Koleszar's avatar
John Koleszar committed
166

John Koleszar's avatar
John Koleszar committed
167
  cpi->this_frame_target = target;
John Koleszar's avatar
John Koleszar committed
168
169
}

170

171
//  Do the best we can to define the parameters for the next GF based
Paul Wilkins's avatar
Paul Wilkins committed
172
//  on what information we have available.
173
174
175
//
//  In this experimental code only two pass is supported
//  so we just use the interval determined in the two pass code.
176
static void calc_gf_params(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
177
178
  // Set the gf interval
  cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
John Koleszar's avatar
John Koleszar committed
179
180
181
}


182
static void calc_pframe_target_size(VP9_COMP *cpi) {
183
184
  const int min_frame_target = MAX(cpi->min_frame_bandwidth,
                                   cpi->av_per_frame_bandwidth >> 5);
185
  if (cpi->refresh_alt_ref_frame) {
186
    // Special alt reference frame case
John Koleszar's avatar
John Koleszar committed
187
188
189
    // Per frame bit target for the alt ref frame
    cpi->per_frame_bandwidth = cpi->twopass.gf_bits;
    cpi->this_frame_target = cpi->per_frame_bandwidth;
190
191
  } else {
    // Normal frames (gf,and inter)
John Koleszar's avatar
John Koleszar committed
192
193
    cpi->this_frame_target = cpi->per_frame_bandwidth;
  }
John Koleszar's avatar
John Koleszar committed
194

John Koleszar's avatar
John Koleszar committed
195
196
197
198
199
200
201
  // Sanity check that the total sum of adjustments is not above the maximum allowed
  // That is that having allowed for KF and GF penalties we have not pushed the
  // current interframe target to 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.
  if (cpi->this_frame_target < min_frame_target)
    cpi->this_frame_target = min_frame_target;
John Koleszar's avatar
John Koleszar committed
202

203
  if (!cpi->refresh_alt_ref_frame)
John Koleszar's avatar
John Koleszar committed
204
205
206
207
208
    // Note the baseline target data rate for this inter frame.
    cpi->inter_frame_target = cpi->this_frame_target;

  // Adjust target frame size for Golden Frames:
  if (cpi->frames_till_gf_update_due == 0) {
209
210
    const int q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME]
                                          : cpi->oxcf.fixed_q;
John Koleszar's avatar
John Koleszar committed
211

212
    cpi->refresh_golden_frame = 1;
213

John Koleszar's avatar
John Koleszar committed
214
215
216
217
218
219
220
221
222
223
    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) {
      if (cpi->oxcf.fixed_q < 0) {
        // The spend on the GF is defined in the two pass code
        // for two pass encodes
        cpi->this_frame_target = cpi->per_frame_bandwidth;
224
      } else {
John Koleszar's avatar
John Koleszar committed
225
        cpi->this_frame_target =
226
          (estimate_bits_at_q(1, q, cpi->common.MBs, 1.0)
John Koleszar's avatar
John Koleszar committed
227
           * cpi->last_boost) / 100;
228
229
230
      }
    } else {
      // If there is an active ARF at this location use the minimum
231
      // bits on this frame even if it is a constructed arf.
232
      // The active maximum quantizer insures that an appropriate
233
      // number of bits will be spent if needed for constructed ARFs.
John Koleszar's avatar
John Koleszar committed
234
      cpi->this_frame_target = 0;
John Koleszar's avatar
John Koleszar committed
235
    }
John Koleszar's avatar
John Koleszar committed
236
  }
John Koleszar's avatar
John Koleszar committed
237
238
239
}


240
void vp9_update_rate_correction_factors(VP9_COMP *cpi, int damp_var) {
241
242
  const int q = cpi->common.base_qindex;
  int correction_factor = 100;
John Koleszar's avatar
John Koleszar committed
243
244
  double rate_correction_factor;
  double adjustment_limit;
John Koleszar's avatar
John Koleszar committed
245

246
  int projected_size_based_on_q = 0;
John Koleszar's avatar
John Koleszar committed
247

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

John Koleszar's avatar
John Koleszar committed
251
252
253
  if (cpi->common.frame_type == KEY_FRAME) {
    rate_correction_factor = cpi->key_frame_rate_correction_factor;
  } else {
254
    if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame)
John Koleszar's avatar
John Koleszar committed
255
      rate_correction_factor = cpi->gf_rate_correction_factor;
John Koleszar's avatar
John Koleszar committed
256
    else
John Koleszar's avatar
John Koleszar committed
257
258
259
      rate_correction_factor = cpi->rate_correction_factor;
  }

260
261
  // 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
262
  // Stay in double to avoid int overflow when values are large
263
264
265
  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
266
267
268
269
270
271

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

John Koleszar's avatar
John Koleszar committed
273
274
  // More heavily damped adjustment used if we have been oscillating either side of target
  switch (damp_var) {
John Koleszar's avatar
John Koleszar committed
275
    case 0:
John Koleszar's avatar
John Koleszar committed
276
277
      adjustment_limit = 0.75;
      break;
John Koleszar's avatar
John Koleszar committed
278
    case 1:
John Koleszar's avatar
John Koleszar committed
279
280
      adjustment_limit = 0.375;
      break;
John Koleszar's avatar
John Koleszar committed
281
282
    case 2:
    default:
John Koleszar's avatar
John Koleszar committed
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
      adjustment_limit = 0.25;
      break;
  }

  // if ( (correction_factor > 102) && (Q < cpi->active_worst_quality) )
  if (correction_factor > 102) {
    // We are not already at the worst allowable quality
    correction_factor = (int)(100.5 + ((correction_factor - 100) * adjustment_limit));
    rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);

    // Keep rate_correction_factor within limits
    if (rate_correction_factor > MAX_BPB_FACTOR)
      rate_correction_factor = MAX_BPB_FACTOR;
  }
  // else if ( (correction_factor < 99) && (Q > cpi->active_best_quality) )
  else if (correction_factor < 99) {
    // We are not already at the best allowable quality
    correction_factor = (int)(100.5 - ((100 - correction_factor) * adjustment_limit));
    rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);

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

  if (cpi->common.frame_type == KEY_FRAME)
    cpi->key_frame_rate_correction_factor = rate_correction_factor;
  else {
311
    if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame)
John Koleszar's avatar
John Koleszar committed
312
      cpi->gf_rate_correction_factor = rate_correction_factor;
John Koleszar's avatar
John Koleszar committed
313
    else
John Koleszar's avatar
John Koleszar committed
314
315
      cpi->rate_correction_factor = rate_correction_factor;
  }
John Koleszar's avatar
John Koleszar committed
316
317
318
}


319
int vp9_regulate_q(VP9_COMP *cpi, int target_bits_per_frame) {
320
  int q = cpi->active_worst_quality;
John Koleszar's avatar
John Koleszar committed
321

John Koleszar's avatar
John Koleszar committed
322
323
324
325
326
  int i;
  int last_error = INT_MAX;
  int target_bits_per_mb;
  int bits_per_mb_at_this_q;
  double correction_factor;
327

John Koleszar's avatar
John Koleszar committed
328
329
330
331
  // Select the appropriate correction factor based upon type of frame.
  if (cpi->common.frame_type == KEY_FRAME)
    correction_factor = cpi->key_frame_rate_correction_factor;
  else {
332
    if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame)
John Koleszar's avatar
John Koleszar committed
333
      correction_factor = cpi->gf_rate_correction_factor;
John Koleszar's avatar
John Koleszar committed
334
    else
John Koleszar's avatar
John Koleszar committed
335
336
      correction_factor = cpi->rate_correction_factor;
  }
John Koleszar's avatar
John Koleszar committed
337

John Koleszar's avatar
John Koleszar committed
338
339
340
341
342
  // Calculate required scaling factor based on target frame size and size of frame produced using previous Q
  if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
    target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs) << BPER_MB_NORMBITS;       // Case where we would overflow int
  else
    target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
John Koleszar's avatar
John Koleszar committed
343

John Koleszar's avatar
John Koleszar committed
344
  i = cpi->active_best_quality;
John Koleszar's avatar
John Koleszar committed
345

John Koleszar's avatar
John Koleszar committed
346
  do {
347
348
    bits_per_mb_at_this_q = (int)vp9_bits_per_mb(cpi->common.frame_type, i,
                                                 correction_factor);
John Koleszar's avatar
John Koleszar committed
349

John Koleszar's avatar
John Koleszar committed
350
351
    if (bits_per_mb_at_this_q <= target_bits_per_mb) {
      if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
352
        q = i;
John Koleszar's avatar
John Koleszar committed
353
      else
354
        q = i - 1;
John Koleszar's avatar
John Koleszar committed
355

John Koleszar's avatar
John Koleszar committed
356
      break;
357
    } else {
John Koleszar's avatar
John Koleszar committed
358
      last_error = bits_per_mb_at_this_q - target_bits_per_mb;
359
    }
John Koleszar's avatar
John Koleszar committed
360
  } while (++i <= cpi->active_worst_quality);
John Koleszar's avatar
John Koleszar committed
361

362
  return q;
John Koleszar's avatar
John Koleszar committed
363
364
}

365

366
static int estimate_keyframe_frequency(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
367
  int i;
John Koleszar's avatar
John Koleszar committed
368

John Koleszar's avatar
John Koleszar committed
369
370
  // Average key frame frequency
  int av_key_frame_frequency = 0;
John Koleszar's avatar
John Koleszar committed
371

John Koleszar's avatar
John Koleszar committed
372
373
374
375
376
377
  /* First key frame at start of sequence is a special case. We have no
   * frequency data.
   */
  if (cpi->key_frame_count == 1) {
    /* Assume a default of 1 kf every 2 seconds, or the max kf interval,
     * whichever is smaller.
378
     */
John Koleszar's avatar
John Koleszar committed
379
    int key_freq = cpi->oxcf.key_freq > 0 ? cpi->oxcf.key_freq : 1;
James Zern's avatar
James Zern committed
380
    av_key_frame_frequency = (int)cpi->output_framerate * 2;
John Koleszar's avatar
John Koleszar committed
381

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

John Koleszar's avatar
John Koleszar committed
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
    cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1]
      = 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)
        cpi->prior_key_frame_distance[i]
          = cpi->prior_key_frame_distance[i + 1];
      else
        cpi->prior_key_frame_distance[i] = last_kf_interval;

      av_key_frame_frequency += prior_key_frame_weight[i]
                                * cpi->prior_key_frame_distance[i];
      total_weight += prior_key_frame_weight[i];
John Koleszar's avatar
John Koleszar committed
405
    }
John Koleszar's avatar
John Koleszar committed
406

407
    av_key_frame_frequency /= total_weight;
John Koleszar's avatar
John Koleszar committed
408
409
410

  }
  return av_key_frame_frequency;
411
412
413
}


414
void vp9_adjust_key_frame_context(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
415
  // Clear down mmx registers to allow floating point in what follows
416
  vp9_clear_system_state();
John Koleszar's avatar
John Koleszar committed
417

John Koleszar's avatar
John Koleszar committed
418
419
  cpi->frames_since_key = 0;
  cpi->key_frame_count++;
John Koleszar's avatar
John Koleszar committed
420
421
}

422

423
void vp9_compute_frame_size_bounds(VP9_COMP *cpi, int *frame_under_shoot_limit,
424
                                   int *frame_over_shoot_limit) {
John Koleszar's avatar
John Koleszar committed
425
426
427
428
429
430
431
432
433
434
  // Set-up bounds on acceptable frame size:
  if (cpi->oxcf.fixed_q >= 0) {
    // Fixed Q scenario: frame size never outranges target (there is no target!)
    *frame_under_shoot_limit = 0;
    *frame_over_shoot_limit  = INT_MAX;
  } else {
    if (cpi->common.frame_type == KEY_FRAME) {
      *frame_over_shoot_limit  = cpi->this_frame_target * 9 / 8;
      *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
    } else {
435
      if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) {
John Koleszar's avatar
John Koleszar committed
436
437
438
439
440
441
442
443
444
445
        *frame_over_shoot_limit  = cpi->this_frame_target * 9 / 8;
        *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
      } else {
        // Stron overshoot limit for constrained quality
        if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
          *frame_over_shoot_limit  = cpi->this_frame_target * 11 / 8;
          *frame_under_shoot_limit = cpi->this_frame_target * 2 / 8;
        } else {
          *frame_over_shoot_limit  = cpi->this_frame_target * 11 / 8;
          *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
John Koleszar's avatar
John Koleszar committed
446
        }
John Koleszar's avatar
John Koleszar committed
447
      }
John Koleszar's avatar
John Koleszar committed
448
    }
John Koleszar's avatar
John Koleszar committed
449
450
451
452
453
454
455
456
457

    // 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
458
}
459
460
461


// return of 0 means drop frame
462
463
int vp9_pick_frame_size(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
464

John Koleszar's avatar
John Koleszar committed
465
466
467
468
  if (cm->frame_type == KEY_FRAME)
    calc_iframe_target_size(cpi);
  else
    calc_pframe_target_size(cpi);
469

John Koleszar's avatar
John Koleszar committed
470
  return 1;
471
}