vp9_ratectrl.c 18.9 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
#include "vp9/common/vp9_alloccommon.h"
20
#include "vp9/common/vp9_modecont.h"
21
#include "vp9/common/vp9_common.h"
22
#include "vp9/encoder/vp9_ratectrl.h"
23
#include "vp9/common/vp9_entropymode.h"
John Koleszar's avatar
John Koleszar committed
24
#include "vpx_mem/vpx_mem.h"
25
#include "vp9/common/vp9_systemdependent.h"
26
#include "vp9/encoder/vp9_encodemv.h"
27
#include "vp9/common/vp9_quant_common.h"
28
#include "vp9/common/vp9_seg_common.h"
John Koleszar's avatar
John Koleszar committed
29

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

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

// % adjustment to target kf size based on seperation from previous frame
John Koleszar's avatar
John Koleszar committed
37
38
39
static const int kf_boost_seperation_adjustment[16] = {
  30,   40,   50,   55,   60,   65,   70,   75,
  80,   85,   90,   95,  100,  100,  100,  100,
John Koleszar's avatar
John Koleszar committed
40
41
};

John Koleszar's avatar
John Koleszar committed
42
43
44
45
46
47
48
49
50
51
52
53
static const int gf_adjust_table[101] = {
  100,
  115, 130, 145, 160, 175, 190, 200, 210, 220, 230,
  240, 260, 270, 280, 290, 300, 310, 320, 330, 340,
  350, 360, 370, 380, 390, 400, 400, 400, 400, 400,
  400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
  400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
  400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
  400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
  400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
  400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
  400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
John Koleszar's avatar
John Koleszar committed
54
55
};

John Koleszar's avatar
John Koleszar committed
56
57
58
static const int gf_intra_usage_adjustment[20] = {
  125, 120, 115, 110, 105, 100,  95,  85,  80,  75,
  70,  65,  60,  55,  50,  50,  50,  50,  50,  50,
John Koleszar's avatar
John Koleszar committed
59
60
};

John Koleszar's avatar
John Koleszar committed
61
62
63
64
65
66
67
68
69
70
71
72
static const int gf_interval_table[101] = {
  7,
  7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
  9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
  10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
  10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
  11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
John Koleszar's avatar
John Koleszar committed
73
74
75
76
};

static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = { 1, 2, 3, 4, 5 };

Paul Wilkins's avatar
Paul Wilkins committed
77
78
79
// 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
80
double vp9_convert_qindex_to_q(int qindex) {
John Koleszar's avatar
John Koleszar committed
81
  // Convert the index to a real Q value (scaled down to match old Q values)
82
  return vp9_ac_quant(qindex, 0) / 4.0;
Paul Wilkins's avatar
Paul Wilkins committed
83
84
}

85
int vp9_gfboost_qadjust(int qindex) {
86
87
88
89
  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
90
91
}

92
static int kfboost_qadjust(int qindex) {
93
94
95
96
  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
97
98
}

99
100
101
int vp9_bits_per_mb(FRAME_TYPE frame_type, int qindex,
                    double correction_factor) {

102
103
  const double q = vp9_convert_qindex_to_q(qindex);
  int enumerator = frame_type == KEY_FRAME ? 4000000 : 2500000;
Paul Wilkins's avatar
Paul Wilkins committed
104

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

110
void vp9_save_coding_context(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
111
  CODING_CONTEXT *const cc = &cpi->coding_context;
112
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
113
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
John Koleszar's avatar
John Koleszar committed
114

John Koleszar's avatar
John Koleszar committed
115
  // Stores a snapshot of key state variables which can subsequently be
116
  // restored with a call to vp9_restore_coding_context. These functions are
117
  // intended for use in a re-code loop in vp9_compress_frame where the
John Koleszar's avatar
John Koleszar committed
118
  // quantizer value is adjusted between loop iterations.
John Koleszar's avatar
John Koleszar committed
119

120
  cc->nmvc = cm->fc.nmvc;
121
122
123
124
  vp9_copy(cc->nmvjointcost,  cpi->mb.nmvjointcost);
  vp9_copy(cc->nmvcosts,  cpi->mb.nmvcosts);
  vp9_copy(cc->nmvcosts_hp,  cpi->mb.nmvcosts_hp);

125
  vp9_copy(cc->inter_mode_probs, cm->fc.inter_mode_probs);
126

127
  vp9_copy(cc->y_mode_prob, cm->fc.y_mode_prob);
128
  vp9_copy(cc->uv_mode_prob, cm->fc.uv_mode_prob);
129
  vp9_copy(cc->partition_prob, cm->fc.partition_prob);
130

131
  vp9_copy(cc->segment_pred_probs, cm->segment_pred_probs);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
132
133
134
135
136

  vp9_copy(cc->intra_inter_prob, cm->fc.intra_inter_prob);
  vp9_copy(cc->comp_inter_prob, cm->fc.comp_inter_prob);
  vp9_copy(cc->single_ref_prob, cm->fc.single_ref_prob);
  vp9_copy(cc->comp_ref_prob, cm->fc.comp_ref_prob);
137

John Koleszar's avatar
John Koleszar committed
138
  vpx_memcpy(cpi->coding_context.last_frame_seg_map_copy,
139
             cm->last_frame_seg_map, (cm->mi_rows * cm->mi_cols));
John Koleszar's avatar
John Koleszar committed
140

141
142
  vp9_copy(cc->last_ref_lf_deltas, xd->last_ref_lf_deltas);
  vp9_copy(cc->last_mode_lf_deltas, xd->last_mode_lf_deltas);
143

144
  vp9_copy(cc->coef_probs, cm->fc.coef_probs);
145
  vp9_copy(cc->switchable_interp_prob, cm->fc.switchable_interp_prob);
146
147
148
  vp9_copy(cc->tx_probs_8x8p, cm->fc.tx_probs_8x8p);
  vp9_copy(cc->tx_probs_16x16p, cm->fc.tx_probs_16x16p);
  vp9_copy(cc->tx_probs_32x32p, cm->fc.tx_probs_32x32p);
Deb Mukherjee's avatar
Deb Mukherjee committed
149
  vp9_copy(cc->mbskip_probs, cm->fc.mbskip_probs);
150
}
John Koleszar's avatar
John Koleszar committed
151

152
void vp9_restore_coding_context(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
153
  CODING_CONTEXT *const cc = &cpi->coding_context;
154
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
155
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
John Koleszar's avatar
John Koleszar committed
156

John Koleszar's avatar
John Koleszar committed
157
  // Restore key state variables to the snapshot state stored in the
158
  // previous call to vp9_save_coding_context.
John Koleszar's avatar
John Koleszar committed
159

160
  cm->fc.nmvc = cc->nmvc;
161
162
163
164
  vp9_copy(cpi->mb.nmvjointcost, cc->nmvjointcost);
  vp9_copy(cpi->mb.nmvcosts, cc->nmvcosts);
  vp9_copy(cpi->mb.nmvcosts_hp, cc->nmvcosts_hp);

165
  vp9_copy(cm->fc.inter_mode_probs, cc->inter_mode_probs);
166

167
  vp9_copy(cm->fc.y_mode_prob, cc->y_mode_prob);
168
  vp9_copy(cm->fc.uv_mode_prob, cc->uv_mode_prob);
169
  vp9_copy(cm->fc.partition_prob, cc->partition_prob);
170

171
  vp9_copy(cm->segment_pred_probs, cc->segment_pred_probs);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
172
173
174
175
176

  vp9_copy(cm->fc.intra_inter_prob, cc->intra_inter_prob);
  vp9_copy(cm->fc.comp_inter_prob, cc->comp_inter_prob);
  vp9_copy(cm->fc.single_ref_prob, cc->single_ref_prob);
  vp9_copy(cm->fc.comp_ref_prob, cc->comp_ref_prob);
177

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

182
183
  vp9_copy(xd->last_ref_lf_deltas, cc->last_ref_lf_deltas);
  vp9_copy(xd->last_mode_lf_deltas, cc->last_mode_lf_deltas);
184

185
  vp9_copy(cm->fc.coef_probs, cc->coef_probs);
186
  vp9_copy(cm->fc.switchable_interp_prob, cc->switchable_interp_prob);
187
188
189
  vp9_copy(cm->fc.tx_probs_8x8p, cc->tx_probs_8x8p);
  vp9_copy(cm->fc.tx_probs_16x16p, cc->tx_probs_16x16p);
  vp9_copy(cm->fc.tx_probs_32x32p, cc->tx_probs_32x32p);
Deb Mukherjee's avatar
Deb Mukherjee committed
190
  vp9_copy(cm->fc.mbskip_probs, cc->mbskip_probs);
John Koleszar's avatar
John Koleszar committed
191
192
}

193
194
void vp9_setup_key_frame(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
195
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
196

197
  vp9_setup_past_independence(cm, xd);
John Koleszar's avatar
John Koleszar committed
198

John Koleszar's avatar
John Koleszar committed
199
200
  // interval before next GF
  cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
201
  /* All buffers are implicitly updated on key frames. */
202
203
  cpi->refresh_golden_frame = 1;
  cpi->refresh_alt_ref_frame = 1;
John Koleszar's avatar
John Koleszar committed
204
}
205

206
void vp9_setup_inter_frame(VP9_COMP *cpi) {
207
208
  VP9_COMMON *cm = &cpi->common;
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
Adrian Grange's avatar
Adrian Grange committed
209
  if (cm->error_resilient_mode || cm->intra_only)
210
    vp9_setup_past_independence(cm, xd);
211

212
  assert(cm->frame_context_idx < NUM_FRAME_CONTEXTS);
213
  cm->fc = cm->frame_contexts[cm->frame_context_idx];
214
}
John Koleszar's avatar
John Koleszar committed
215

216
static int estimate_bits_at_q(int frame_kind, int q, int mbs,
John Koleszar's avatar
John Koleszar committed
217
                              double correction_factor) {
218
  const int bpm = (int)(vp9_bits_per_mb(frame_kind, q, correction_factor));
John Koleszar's avatar
John Koleszar committed
219

220
221
222
223
224
  // 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;
225
}
226
227


228
static void calc_iframe_target_size(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
229
230
  // boost defaults to half second
  int target;
John Koleszar's avatar
John Koleszar committed
231

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

John Koleszar's avatar
John Koleszar committed
235
236
  // New Two pass RC
  target = cpi->per_frame_bandwidth;
John Koleszar's avatar
John Koleszar committed
237

John Koleszar's avatar
John Koleszar committed
238
  if (cpi->oxcf.rc_max_intra_bitrate_pct) {
239
240
    int max_rate = cpi->per_frame_bandwidth
                 * cpi->oxcf.rc_max_intra_bitrate_pct / 100;
John Koleszar's avatar
John Koleszar committed
241

John Koleszar's avatar
John Koleszar committed
242
243
244
    if (target > max_rate)
      target = max_rate;
  }
John Koleszar's avatar
John Koleszar committed
245

John Koleszar's avatar
John Koleszar committed
246
  cpi->this_frame_target = target;
John Koleszar's avatar
John Koleszar committed
247
248
}

249

250
//  Do the best we can to define the parameters for the next GF based
Paul Wilkins's avatar
Paul Wilkins committed
251
//  on what information we have available.
252
253
254
//
//  In this experimental code only two pass is supported
//  so we just use the interval determined in the two pass code.
255
static void calc_gf_params(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
256
257
  // Set the gf interval
  cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
John Koleszar's avatar
John Koleszar committed
258
259
260
}


261
static void calc_pframe_target_size(VP9_COMP *cpi) {
262
263
  const int min_frame_target = MAX(cpi->min_frame_bandwidth,
                                   cpi->av_per_frame_bandwidth >> 5);
264
  if (cpi->refresh_alt_ref_frame) {
265
    // Special alt reference frame case
John Koleszar's avatar
John Koleszar committed
266
267
268
    // 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;
269
270
  } else {
    // Normal frames (gf,and inter)
John Koleszar's avatar
John Koleszar committed
271
272
    cpi->this_frame_target = cpi->per_frame_bandwidth;
  }
John Koleszar's avatar
John Koleszar committed
273

John Koleszar's avatar
John Koleszar committed
274
275
276
277
278
279
280
  // 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
281

282
  if (!cpi->refresh_alt_ref_frame)
John Koleszar's avatar
John Koleszar committed
283
284
285
286
287
    // 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) {
288
289
    const int q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME]
                                          : cpi->oxcf.fixed_q;
John Koleszar's avatar
John Koleszar committed
290

291
    cpi->refresh_golden_frame = 1;
292

John Koleszar's avatar
John Koleszar committed
293
294
295
296
297
298
299
300
301
302
    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;
303
      } else {
John Koleszar's avatar
John Koleszar committed
304
        cpi->this_frame_target =
305
          (estimate_bits_at_q(1, q, cpi->common.MBs, 1.0)
John Koleszar's avatar
John Koleszar committed
306
           * cpi->last_boost) / 100;
307
308
309
      }
    } else {
      // If there is an active ARF at this location use the minimum
310
      // bits on this frame even if it is a constructed arf.
311
      // The active maximum quantizer insures that an appropriate
312
      // number of bits will be spent if needed for constructed ARFs.
John Koleszar's avatar
John Koleszar committed
313
      cpi->this_frame_target = 0;
John Koleszar's avatar
John Koleszar committed
314
    }
John Koleszar's avatar
John Koleszar committed
315
  }
John Koleszar's avatar
John Koleszar committed
316
317
318
}


319
void vp9_update_rate_correction_factors(VP9_COMP *cpi, int damp_var) {
320
321
  const int q = cpi->common.base_qindex;
  int correction_factor = 100;
John Koleszar's avatar
John Koleszar committed
322
323
  double rate_correction_factor;
  double adjustment_limit;
John Koleszar's avatar
John Koleszar committed
324

325
  int projected_size_based_on_q = 0;
John Koleszar's avatar
John Koleszar committed
326

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

John Koleszar's avatar
John Koleszar committed
330
331
332
  if (cpi->common.frame_type == KEY_FRAME) {
    rate_correction_factor = cpi->key_frame_rate_correction_factor;
  } else {
333
    if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame)
John Koleszar's avatar
John Koleszar committed
334
      rate_correction_factor = cpi->gf_rate_correction_factor;
John Koleszar's avatar
John Koleszar committed
335
    else
John Koleszar's avatar
John Koleszar committed
336
337
338
      rate_correction_factor = cpi->rate_correction_factor;
  }

339
340
  // 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
341
  // Stay in double to avoid int overflow when values are large
342
343
344
  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
345
346
347
348
349
350

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

John Koleszar's avatar
John Koleszar committed
352
353
  // More heavily damped adjustment used if we have been oscillating either side of target
  switch (damp_var) {
John Koleszar's avatar
John Koleszar committed
354
    case 0:
John Koleszar's avatar
John Koleszar committed
355
356
      adjustment_limit = 0.75;
      break;
John Koleszar's avatar
John Koleszar committed
357
    case 1:
John Koleszar's avatar
John Koleszar committed
358
359
      adjustment_limit = 0.375;
      break;
John Koleszar's avatar
John Koleszar committed
360
361
    case 2:
    default:
John Koleszar's avatar
John Koleszar committed
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
      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 {
390
    if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame)
John Koleszar's avatar
John Koleszar committed
391
      cpi->gf_rate_correction_factor = rate_correction_factor;
John Koleszar's avatar
John Koleszar committed
392
    else
John Koleszar's avatar
John Koleszar committed
393
394
      cpi->rate_correction_factor = rate_correction_factor;
  }
John Koleszar's avatar
John Koleszar committed
395
396
397
}


398
int vp9_regulate_q(VP9_COMP *cpi, int target_bits_per_frame) {
399
  int q = cpi->active_worst_quality;
John Koleszar's avatar
John Koleszar committed
400

John Koleszar's avatar
John Koleszar committed
401
402
403
404
405
  int i;
  int last_error = INT_MAX;
  int target_bits_per_mb;
  int bits_per_mb_at_this_q;
  double correction_factor;
406

John Koleszar's avatar
John Koleszar committed
407
408
409
410
  // 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 {
411
    if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame)
John Koleszar's avatar
John Koleszar committed
412
      correction_factor = cpi->gf_rate_correction_factor;
John Koleszar's avatar
John Koleszar committed
413
    else
John Koleszar's avatar
John Koleszar committed
414
415
      correction_factor = cpi->rate_correction_factor;
  }
John Koleszar's avatar
John Koleszar committed
416

John Koleszar's avatar
John Koleszar committed
417
418
419
420
421
  // 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
422

John Koleszar's avatar
John Koleszar committed
423
  i = cpi->active_best_quality;
John Koleszar's avatar
John Koleszar committed
424

John Koleszar's avatar
John Koleszar committed
425
  do {
426
427
    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
428

John Koleszar's avatar
John Koleszar committed
429
430
    if (bits_per_mb_at_this_q <= target_bits_per_mb) {
      if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
431
        q = i;
John Koleszar's avatar
John Koleszar committed
432
      else
433
        q = i - 1;
John Koleszar's avatar
John Koleszar committed
434

John Koleszar's avatar
John Koleszar committed
435
      break;
436
    } else {
John Koleszar's avatar
John Koleszar committed
437
      last_error = bits_per_mb_at_this_q - target_bits_per_mb;
438
    }
John Koleszar's avatar
John Koleszar committed
439
  } while (++i <= cpi->active_worst_quality);
John Koleszar's avatar
John Koleszar committed
440

441
  return q;
John Koleszar's avatar
John Koleszar committed
442
443
}

444

445
static int estimate_keyframe_frequency(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
446
  int i;
John Koleszar's avatar
John Koleszar committed
447

John Koleszar's avatar
John Koleszar committed
448
449
  // Average key frame frequency
  int av_key_frame_frequency = 0;
John Koleszar's avatar
John Koleszar committed
450

John Koleszar's avatar
John Koleszar committed
451
452
453
454
455
456
  /* 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.
457
     */
John Koleszar's avatar
John Koleszar committed
458
459
    int key_freq = cpi->oxcf.key_freq > 0 ? cpi->oxcf.key_freq : 1;
    av_key_frame_frequency = (int)cpi->output_frame_rate * 2;
John Koleszar's avatar
John Koleszar committed
460

John Koleszar's avatar
John Koleszar committed
461
462
    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
463

John Koleszar's avatar
John Koleszar committed
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
    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
484
    }
John Koleszar's avatar
John Koleszar committed
485

486
    av_key_frame_frequency /= total_weight;
John Koleszar's avatar
John Koleszar committed
487
488
489

  }
  return av_key_frame_frequency;
490
491
492
}


493
void vp9_adjust_key_frame_context(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
494
  // Clear down mmx registers to allow floating point in what follows
495
  vp9_clear_system_state();
John Koleszar's avatar
John Koleszar committed
496

John Koleszar's avatar
John Koleszar committed
497
498
  cpi->frames_since_key = 0;
  cpi->key_frame_count++;
John Koleszar's avatar
John Koleszar committed
499
500
}

501

502
void vp9_compute_frame_size_bounds(VP9_COMP *cpi, int *frame_under_shoot_limit,
503
                                   int *frame_over_shoot_limit) {
John Koleszar's avatar
John Koleszar committed
504
505
506
507
508
509
510
511
512
513
  // 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 {
514
      if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) {
John Koleszar's avatar
John Koleszar committed
515
516
517
518
519
520
521
522
523
524
        *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
525
        }
John Koleszar's avatar
John Koleszar committed
526
      }
John Koleszar's avatar
John Koleszar committed
527
    }
John Koleszar's avatar
John Koleszar committed
528
529
530
531
532
533
534
535
536

    // 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
537
}
538
539
540


// return of 0 means drop frame
541
542
int vp9_pick_frame_size(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
543

John Koleszar's avatar
John Koleszar committed
544
545
546
547
  if (cm->frame_type == KEY_FRAME)
    calc_iframe_target_size(cpi);
  else
    calc_pframe_target_size(cpi);
548

John Koleszar's avatar
John Koleszar committed
549
  return 1;
550
}