vp9_ratectrl.c 18.6 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
  vp9_copy(cc->tx_probs, cm->fc.tx_probs);
Deb Mukherjee's avatar
Deb Mukherjee committed
147
  vp9_copy(cc->mbskip_probs, cm->fc.mbskip_probs);
148
}
John Koleszar's avatar
John Koleszar committed
149

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

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

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

163
  vp9_copy(cm->fc.inter_mode_probs, cc->inter_mode_probs);
164

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

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

  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);
175

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

180
181
  vp9_copy(xd->last_ref_lf_deltas, cc->last_ref_lf_deltas);
  vp9_copy(xd->last_mode_lf_deltas, cc->last_mode_lf_deltas);
182

183
  vp9_copy(cm->fc.coef_probs, cc->coef_probs);
184
  vp9_copy(cm->fc.switchable_interp_prob, cc->switchable_interp_prob);
185
  vp9_copy(cm->fc.tx_probs, cc->tx_probs);
Deb Mukherjee's avatar
Deb Mukherjee committed
186
  vp9_copy(cm->fc.mbskip_probs, cc->mbskip_probs);
John Koleszar's avatar
John Koleszar committed
187
188
}

189
190
void vp9_setup_key_frame(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
191
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
192

193
  vp9_setup_past_independence(cm, xd);
John Koleszar's avatar
John Koleszar committed
194

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

202
void vp9_setup_inter_frame(VP9_COMP *cpi) {
203
204
  VP9_COMMON *cm = &cpi->common;
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
205
  if (cm->error_resilient_mode)
206
    vp9_setup_past_independence(cm, xd);
207

208
  assert(cm->frame_context_idx < NUM_FRAME_CONTEXTS);
209
  cm->fc = cm->frame_contexts[cm->frame_context_idx];
210
}
John Koleszar's avatar
John Koleszar committed
211

212
static int estimate_bits_at_q(int frame_kind, int q, int mbs,
John Koleszar's avatar
John Koleszar committed
213
                              double correction_factor) {
214
  const int bpm = (int)(vp9_bits_per_mb(frame_kind, q, correction_factor));
John Koleszar's avatar
John Koleszar committed
215

216
217
218
219
220
  // 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;
221
}
222
223


224
static void calc_iframe_target_size(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
225
226
  // boost defaults to half second
  int target;
John Koleszar's avatar
John Koleszar committed
227

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

John Koleszar's avatar
John Koleszar committed
231
232
  // New Two pass RC
  target = cpi->per_frame_bandwidth;
John Koleszar's avatar
John Koleszar committed
233

John Koleszar's avatar
John Koleszar committed
234
  if (cpi->oxcf.rc_max_intra_bitrate_pct) {
235
236
    int max_rate = cpi->per_frame_bandwidth
                 * cpi->oxcf.rc_max_intra_bitrate_pct / 100;
John Koleszar's avatar
John Koleszar committed
237

John Koleszar's avatar
John Koleszar committed
238
239
240
    if (target > max_rate)
      target = max_rate;
  }
John Koleszar's avatar
John Koleszar committed
241

John Koleszar's avatar
John Koleszar committed
242
  cpi->this_frame_target = target;
John Koleszar's avatar
John Koleszar committed
243
244
}

245

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


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

John Koleszar's avatar
John Koleszar committed
270
271
272
273
274
275
276
  // 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
277

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

287
    cpi->refresh_golden_frame = 1;
288

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


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

321
  int projected_size_based_on_q = 0;
John Koleszar's avatar
John Koleszar committed
322

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

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

335
336
  // 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
337
  // Stay in double to avoid int overflow when values are large
338
339
340
  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
341
342
343
344
345
346

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

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


394
int vp9_regulate_q(VP9_COMP *cpi, int target_bits_per_frame) {
395
  int q = cpi->active_worst_quality;
John Koleszar's avatar
John Koleszar committed
396

John Koleszar's avatar
John Koleszar committed
397
398
399
400
401
  int i;
  int last_error = INT_MAX;
  int target_bits_per_mb;
  int bits_per_mb_at_this_q;
  double correction_factor;
402

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

John Koleszar's avatar
John Koleszar committed
413
414
415
416
417
  // 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
418

John Koleszar's avatar
John Koleszar committed
419
  i = cpi->active_best_quality;
John Koleszar's avatar
John Koleszar committed
420

John Koleszar's avatar
John Koleszar committed
421
  do {
422
423
    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
424

John Koleszar's avatar
John Koleszar committed
425
426
    if (bits_per_mb_at_this_q <= target_bits_per_mb) {
      if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
427
        q = i;
John Koleszar's avatar
John Koleszar committed
428
      else
429
        q = i - 1;
John Koleszar's avatar
John Koleszar committed
430

John Koleszar's avatar
John Koleszar committed
431
      break;
432
    } else {
John Koleszar's avatar
John Koleszar committed
433
      last_error = bits_per_mb_at_this_q - target_bits_per_mb;
434
    }
John Koleszar's avatar
John Koleszar committed
435
  } while (++i <= cpi->active_worst_quality);
John Koleszar's avatar
John Koleszar committed
436

437
  return q;
John Koleszar's avatar
John Koleszar committed
438
439
}

440

441
static int estimate_keyframe_frequency(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
442
  int i;
John Koleszar's avatar
John Koleszar committed
443

John Koleszar's avatar
John Koleszar committed
444
445
  // Average key frame frequency
  int av_key_frame_frequency = 0;
John Koleszar's avatar
John Koleszar committed
446

John Koleszar's avatar
John Koleszar committed
447
448
449
450
451
452
  /* 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.
453
     */
John Koleszar's avatar
John Koleszar committed
454
455
    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
456

John Koleszar's avatar
John Koleszar committed
457
458
    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
459

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

482
    av_key_frame_frequency /= total_weight;
John Koleszar's avatar
John Koleszar committed
483
484
485

  }
  return av_key_frame_frequency;
486
487
488
}


489
void vp9_adjust_key_frame_context(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
490
  // Clear down mmx registers to allow floating point in what follows
491
  vp9_clear_system_state();
John Koleszar's avatar
John Koleszar committed
492

John Koleszar's avatar
John Koleszar committed
493
494
  cpi->frames_since_key = 0;
  cpi->key_frame_count++;
John Koleszar's avatar
John Koleszar committed
495
496
}

497

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

    // 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
533
}
534
535
536


// return of 0 means drop frame
537
538
int vp9_pick_frame_size(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
539

John Koleszar's avatar
John Koleszar committed
540
541
542
543
  if (cm->frame_type == KEY_FRAME)
    calc_iframe_target_size(cpi);
  else
    calc_pframe_target_size(cpi);
544

John Koleszar's avatar
John Koleszar committed
545
  return 1;
546
}