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

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

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

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

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

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

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

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

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

John Koleszar's avatar
John Koleszar committed
151
  vpx_memcpy(cpi->coding_context.last_frame_seg_map_copy,
152
             cm->last_frame_seg_map, (cm->mi_rows * cm->mi_cols));
John Koleszar's avatar
John Koleszar committed
153

154
155
  vp9_copy(cc->last_ref_lf_deltas, cm->lf.last_ref_deltas);
  vp9_copy(cc->last_mode_lf_deltas, cm->lf.last_mode_deltas);
156

157
  cc->fc = cm->fc;
158
}
John Koleszar's avatar
John Koleszar committed
159

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

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

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

John Koleszar's avatar
John Koleszar committed
172
173
  vpx_memcpy(cm->last_frame_seg_map,
             cpi->coding_context.last_frame_seg_map_copy,
174
             (cm->mi_rows * cm->mi_cols));
John Koleszar's avatar
John Koleszar committed
175

176
177
  vp9_copy(cm->lf.last_ref_deltas, cc->last_ref_lf_deltas);
  vp9_copy(cm->lf.last_mode_deltas, cc->last_mode_lf_deltas);
178

179
  cm->fc = cc->fc;
John Koleszar's avatar
John Koleszar committed
180
181
}

182
183
void vp9_setup_key_frame(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
184

185
  vp9_setup_past_independence(cm);
John Koleszar's avatar
John Koleszar committed
186

187
  /* All buffers are implicitly updated on key frames. */
188
189
  cpi->refresh_golden_frame = 1;
  cpi->refresh_alt_ref_frame = 1;
John Koleszar's avatar
John Koleszar committed
190
}
191

192
void vp9_setup_inter_frame(VP9_COMP *cpi) {
193
  VP9_COMMON *cm = &cpi->common;
Adrian Grange's avatar
Adrian Grange committed
194
  if (cm->error_resilient_mode || cm->intra_only)
195
    vp9_setup_past_independence(cm);
196

Dmitry Kovalev's avatar
Dmitry Kovalev committed
197
  assert(cm->frame_context_idx < FRAME_CONTEXTS);
198
  cm->fc = cm->frame_contexts[cm->frame_context_idx];
199
}
John Koleszar's avatar
John Koleszar committed
200

201
static int estimate_bits_at_q(int frame_kind, int q, int mbs,
John Koleszar's avatar
John Koleszar committed
202
                              double correction_factor) {
203
  const int bpm = (int)(vp9_rc_bits_per_mb(frame_kind, q, correction_factor));
John Koleszar's avatar
John Koleszar committed
204

205
206
207
208
209
  // 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;
210
}
211

212
213
214
215
216
217
218
219
220
221
222
int vp9_rc_clamp_pframe_target_size(const VP9_COMP *const cpi, int target) {
  const RATE_CONTROL *rc = &cpi->rc;
  const int min_frame_target = MAX(rc->min_frame_bandwidth,
                                   rc->av_per_frame_bandwidth >> 5);
  if (target < min_frame_target)
    target = min_frame_target;
  if (cpi->refresh_golden_frame && rc->source_alt_ref_active) {
    // If there is an active ARF at this location use the minimum
    // bits on this frame even if it is a constructed arf.
    // The active maximum quantizer insures that an appropriate
    // number of bits will be spent if needed for constructed ARFs.
223
    target = min_frame_target;
224
225
226
227
228
229
  }
  // Clip the frame target to the maximum allowed value.
  if (target > rc->max_frame_bandwidth)
    target = rc->max_frame_bandwidth;
  return target;
}
230

231
232
int vp9_rc_clamp_iframe_target_size(const VP9_COMP *const cpi, int target) {
  const RATE_CONTROL *rc = &cpi->rc;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
233
234
  const VP9_CONFIG *oxcf = &cpi->oxcf;
  if (oxcf->rc_max_intra_bitrate_pct) {
235
    const int max_rate = rc->av_per_frame_bandwidth *
236
        oxcf->rc_max_intra_bitrate_pct / 100;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
237
    target = MIN(target, max_rate);
John Koleszar's avatar
John Koleszar committed
238
  }
239
240
241
  if (target > rc->max_frame_bandwidth)
    target = rc->max_frame_bandwidth;
  return target;
John Koleszar's avatar
John Koleszar committed
242
243
}

244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263

// Update the buffer level for higher layers, given the encoded current layer.
static void update_layer_buffer_level(VP9_COMP *const cpi,
                                      int encoded_frame_size) {
  int temporal_layer = 0;
  int current_temporal_layer = cpi->svc.temporal_layer_id;
  for (temporal_layer = current_temporal_layer + 1;
      temporal_layer < cpi->svc.number_temporal_layers; ++temporal_layer) {
    LAYER_CONTEXT *lc = &cpi->svc.layer_context[temporal_layer];
    RATE_CONTROL *lrc = &lc->rc;
    int bits_off_for_this_layer = (int)(lc->target_bandwidth / lc->framerate -
        encoded_frame_size);
    lrc->bits_off_target += bits_off_for_this_layer;

    // Clip buffer level to maximum buffer size for the layer.
    lrc->bits_off_target = MIN(lrc->bits_off_target, lc->maximum_buffer_size);
    lrc->buffer_level = lrc->bits_off_target;
  }
}

264
// Update the buffer level: leaky bucket model.
265
static void update_buffer_level(VP9_COMP *cpi, int encoded_frame_size) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
266
267
  const VP9_COMMON *const cm = &cpi->common;
  const VP9_CONFIG *oxcf = &cpi->oxcf;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
268
  RATE_CONTROL *const rc = &cpi->rc;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
269

270
271
  // Non-viewable frames are a special case and are treated as pure overhead.
  if (!cm->show_frame) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
272
    rc->bits_off_target -= encoded_frame_size;
273
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
274
    rc->bits_off_target += rc->av_per_frame_bandwidth - encoded_frame_size;
275
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
276

277
  // Clip the buffer level to the maximum specified buffer size.
278
279
280
281
282
283
  rc->bits_off_target = MIN(rc->bits_off_target, oxcf->maximum_buffer_size);
  rc->buffer_level = rc->bits_off_target;

  if (cpi->use_svc && cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
    update_layer_buffer_level(cpi, encoded_frame_size);
  }
284
285
}

286
int vp9_rc_drop_frame(VP9_COMP *cpi) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
287
  const VP9_CONFIG *oxcf = &cpi->oxcf;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
288
289
  RATE_CONTROL *const rc = &cpi->rc;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
290
  if (!oxcf->drop_frames_water_mark) {
291
292
    return 0;
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
293
    if (rc->buffer_level < 0) {
294
295
296
297
298
      // Always drop if buffer is below 0.
      return 1;
    } else {
      // If buffer is below drop_mark, for now just drop every other frame
      // (starting with the next frame) until it increases back over drop_mark.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
299
      int drop_mark = (int)(oxcf->drop_frames_water_mark *
300
          oxcf->optimal_buffer_level / 100);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
301
302
303
304
305
306
      if ((rc->buffer_level > drop_mark) &&
          (rc->decimation_factor > 0)) {
        --rc->decimation_factor;
      } else if (rc->buffer_level <= drop_mark &&
          rc->decimation_factor == 0) {
        rc->decimation_factor = 1;
307
      }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
308
309
310
      if (rc->decimation_factor > 0) {
        if (rc->decimation_count > 0) {
          --rc->decimation_count;
311
312
          return 1;
        } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
313
          rc->decimation_count = rc->decimation_factor;
314
315
316
          return 0;
        }
      } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
317
        rc->decimation_count = 0;
318
319
320
321
322
323
        return 0;
      }
    }
  }
}

324
325
326
327
static double get_rate_correction_factor(const VP9_COMP *cpi) {
  if (cpi->common.frame_type == KEY_FRAME) {
    return cpi->rc.key_frame_rate_correction_factor;
  } else {
328
329
    if ((cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) &&
        !(cpi->use_svc && cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
330
331
332
333
334
335
336
337
338
339
      return cpi->rc.gf_rate_correction_factor;
    else
      return cpi->rc.rate_correction_factor;
  }
}

static void set_rate_correction_factor(VP9_COMP *cpi, double factor) {
  if (cpi->common.frame_type == KEY_FRAME) {
    cpi->rc.key_frame_rate_correction_factor = factor;
  } else {
340
341
    if ((cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) &&
        !(cpi->use_svc && cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
342
343
344
345
346
347
      cpi->rc.gf_rate_correction_factor = factor;
    else
      cpi->rc.rate_correction_factor = factor;
  }
}

348
void vp9_rc_update_rate_correction_factors(VP9_COMP *cpi, int damp_var) {
349
350
  const int q = cpi->common.base_qindex;
  int correction_factor = 100;
351
  double rate_correction_factor = get_rate_correction_factor(cpi);
John Koleszar's avatar
John Koleszar committed
352
  double adjustment_limit;
John Koleszar's avatar
John Koleszar committed
353

354
  int projected_size_based_on_q = 0;
John Koleszar's avatar
John Koleszar committed
355

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

359
360
  // 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
361
  // Stay in double to avoid int overflow when values are large
362
363
364
  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
365
366
  // Work out a size correction factor.
  if (projected_size_based_on_q > 0)
367
368
    correction_factor = (100 * cpi->rc.projected_frame_size) /
                            projected_size_based_on_q;
John Koleszar's avatar
John Koleszar committed
369

370
371
  // More heavily damped adjustment used if we have been oscillating either side
  // of target.
John Koleszar's avatar
John Koleszar committed
372
  switch (damp_var) {
John Koleszar's avatar
John Koleszar committed
373
    case 0:
John Koleszar's avatar
John Koleszar committed
374
375
      adjustment_limit = 0.75;
      break;
John Koleszar's avatar
John Koleszar committed
376
    case 1:
John Koleszar's avatar
John Koleszar committed
377
378
      adjustment_limit = 0.375;
      break;
John Koleszar's avatar
John Koleszar committed
379
380
    case 2:
    default:
John Koleszar's avatar
John Koleszar committed
381
382
383
384
385
386
      adjustment_limit = 0.25;
      break;
  }

  if (correction_factor > 102) {
    // We are not already at the worst allowable quality
387
    correction_factor =
388
        (int)(100 + ((correction_factor - 100) * adjustment_limit));
389
390
    rate_correction_factor =
        ((rate_correction_factor * correction_factor) / 100);
John Koleszar's avatar
John Koleszar committed
391
392
393
394

    // Keep rate_correction_factor within limits
    if (rate_correction_factor > MAX_BPB_FACTOR)
      rate_correction_factor = MAX_BPB_FACTOR;
395
  } else if (correction_factor < 99) {
John Koleszar's avatar
John Koleszar committed
396
    // We are not already at the best allowable quality
397
    correction_factor =
398
        (int)(100 - ((100 - correction_factor) * adjustment_limit));
399
400
    rate_correction_factor =
        ((rate_correction_factor * correction_factor) / 100);
John Koleszar's avatar
John Koleszar committed
401
402
403
404
405
406

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

407
  set_rate_correction_factor(cpi, rate_correction_factor);
John Koleszar's avatar
John Koleszar committed
408
409
410
}


Deb Mukherjee's avatar
Deb Mukherjee committed
411
412
int vp9_rc_regulate_q(const VP9_COMP *cpi, int target_bits_per_frame,
                      int active_best_quality, int active_worst_quality) {
413
  const VP9_COMMON *const cm = &cpi->common;
Deb Mukherjee's avatar
Deb Mukherjee committed
414
  int q = active_worst_quality;
John Koleszar's avatar
John Koleszar committed
415
  int last_error = INT_MAX;
416
  int i, target_bits_per_mb;
417
  const double correction_factor = get_rate_correction_factor(cpi);
John Koleszar's avatar
John Koleszar committed
418

419
420
  // Calculate required scaling factor based on target frame size and size of
  // frame produced using previous Q.
John Koleszar's avatar
John Koleszar committed
421
  if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
422
423
    // Case where we would overflow int
    target_bits_per_mb = (target_bits_per_frame / cm->MBs) << BPER_MB_NORMBITS;
John Koleszar's avatar
John Koleszar committed
424
  else
425
    target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cm->MBs;
John Koleszar's avatar
John Koleszar committed
426

Deb Mukherjee's avatar
Deb Mukherjee committed
427
  i = active_best_quality;
John Koleszar's avatar
John Koleszar committed
428

John Koleszar's avatar
John Koleszar committed
429
  do {
430
431
    const int bits_per_mb_at_this_q = (int)vp9_rc_bits_per_mb(cm->frame_type, i,
                                                             correction_factor);
John Koleszar's avatar
John Koleszar committed
432

John Koleszar's avatar
John Koleszar committed
433
434
    if (bits_per_mb_at_this_q <= target_bits_per_mb) {
      if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
435
        q = i;
John Koleszar's avatar
John Koleszar committed
436
      else
437
        q = i - 1;
John Koleszar's avatar
John Koleszar committed
438

John Koleszar's avatar
John Koleszar committed
439
      break;
440
    } else {
John Koleszar's avatar
John Koleszar committed
441
      last_error = bits_per_mb_at_this_q - target_bits_per_mb;
442
    }
Deb Mukherjee's avatar
Deb Mukherjee committed
443
  } while (++i <= active_worst_quality);
444
445
446
447

  return q;
}

448
449
static int get_active_quality(int q, int gfu_boost, int low, int high,
                              int *low_motion_minq, int *high_motion_minq) {
450
  if (gfu_boost > high) {
451
    return low_motion_minq[q];
452
  } else if (gfu_boost < low) {
453
    return high_motion_minq[q];
454
455
456
457
458
  } 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;
459
    return low_motion_minq[q] + adjustment;
460
461
462
  }
}

463
464
465
static int rc_pick_q_and_adjust_q_bounds_one_pass(const VP9_COMP *cpi,
                                                  int *bottom_index,
                                                  int *top_index) {
Deb Mukherjee's avatar
Deb Mukherjee committed
466
  const VP9_COMMON *const cm = &cpi->common;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
467
468
  const RATE_CONTROL *const rc = &cpi->rc;
  const VP9_CONFIG *const oxcf = &cpi->oxcf;
Deb Mukherjee's avatar
Deb Mukherjee committed
469
  int active_best_quality;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
470
  int active_worst_quality = rc->active_worst_quality;
Deb Mukherjee's avatar
Deb Mukherjee committed
471
  int q;
472
473

  if (frame_is_intra_only(cm)) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
474
    active_best_quality = rc->best_quality;
475
476
477
478
#if !CONFIG_MULTIPLE_ARF
    // Handle the special case for key frames forced when we have75 reached
    // the maximum key frame interval. Here force the Q to a range
    // based on the ambient Q to reduce the risk of popping.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
479
480
    if (rc->this_key_frame_forced) {
      int qindex = rc->last_boosted_qindex;
481
      double last_boosted_q = vp9_convert_qindex_to_q(qindex);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
482
483
484
      int delta_qindex = vp9_compute_qdelta(cpi, last_boosted_q,
                                            (last_boosted_q * 0.75));
      active_best_quality = MAX(qindex + delta_qindex, rc->best_quality);
485
    } else if (cm->current_video_frame > 0) {
Alex Converse's avatar
Alex Converse committed
486
      // not first frame of one pass and kf_boost is set
487
488
489
490
      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
491
      active_best_quality = get_active_quality(active_worst_quality,
Dmitry Kovalev's avatar
Dmitry Kovalev committed
492
                                               rc->kf_boost,
Deb Mukherjee's avatar
Deb Mukherjee committed
493
494
495
                                               kf_low, kf_high,
                                               kf_low_motion_minq,
                                               kf_high_motion_minq);
496
497
498
499
500
501
502
503

      // Allow somewhat lower kf minq with small image formats.
      if ((cm->width * cm->height) <= (352 * 288)) {
        q_adj_factor -= 0.25;
      }

      // Convert the adjustment factor to a qindex delta
      // on active_best_quality.
Deb Mukherjee's avatar
Deb Mukherjee committed
504
      q_val = vp9_convert_qindex_to_q(active_best_quality);
505
506
      active_best_quality += vp9_compute_qdelta(cpi, q_val, q_val *
                                                   q_adj_factor);
507
508
509
510
    }
#else
    double current_q;
    // Force the KF quantizer to be 30% of the active_worst_quality.
Deb Mukherjee's avatar
Deb Mukherjee committed
511
512
    current_q = vp9_convert_qindex_to_q(active_worst_quality);
    active_best_quality = active_worst_quality
513
514
        + vp9_compute_qdelta(cpi, current_q, current_q * 0.3);
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
515
  } else if (!rc->is_src_frame_alt_ref &&
516
             (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
Deb Mukherjee's avatar
Deb Mukherjee committed
517
    // Use the lower of active_worst_quality and recent
518
519
    // average Q as basis for GF/ARF best Q limit unless last frame was
    // a key frame.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
520
521
522
    if (rc->frames_since_key > 1 &&
        rc->avg_frame_qindex[INTER_FRAME] < active_worst_quality) {
      q = rc->avg_frame_qindex[INTER_FRAME];
Deb Mukherjee's avatar
Deb Mukherjee committed
523
524
    } else {
      q = active_worst_quality;
525
526
    }
    // For constrained quality dont allow Q less than the cq level
Dmitry Kovalev's avatar
Dmitry Kovalev committed
527
    if (oxcf->end_usage == USAGE_CONSTRAINED_QUALITY) {
528
529
      if (q < cpi->cq_target_quality)
        q = cpi->cq_target_quality;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
530
531
      if (rc->frames_since_key > 1) {
        active_best_quality = get_active_quality(q, rc->gfu_boost,
Deb Mukherjee's avatar
Deb Mukherjee committed
532
533
534
                                                 gf_low, gf_high,
                                                 afq_low_motion_minq,
                                                 afq_high_motion_minq);
535
      } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
536
        active_best_quality = get_active_quality(q, rc->gfu_boost,
Deb Mukherjee's avatar
Deb Mukherjee committed
537
538
539
                                                 gf_low, gf_high,
                                                 gf_low_motion_minq,
                                                 gf_high_motion_minq);
540
541
      }
      // Constrained quality use slightly lower active best.
Deb Mukherjee's avatar
Deb Mukherjee committed
542
      active_best_quality = active_best_quality * 15 / 16;
543

Dmitry Kovalev's avatar
Dmitry Kovalev committed
544
    } else if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
545
      if (!cpi->refresh_alt_ref_frame) {
Deb Mukherjee's avatar
Deb Mukherjee committed
546
        active_best_quality = cpi->cq_target_quality;
547
      } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
548
        if (rc->frames_since_key > 1) {
Deb Mukherjee's avatar
Deb Mukherjee committed
549
          active_best_quality = get_active_quality(
Dmitry Kovalev's avatar
Dmitry Kovalev committed
550
              q, rc->gfu_boost, gf_low, gf_high,
551
              afq_low_motion_minq, afq_high_motion_minq);
552
        } else {
Deb Mukherjee's avatar
Deb Mukherjee committed
553
          active_best_quality = get_active_quality(
Dmitry Kovalev's avatar
Dmitry Kovalev committed
554
              q, rc->gfu_boost, gf_low, gf_high,
555
              gf_low_motion_minq, gf_high_motion_minq);
556
557
558
        }
      }
    } else {
Deb Mukherjee's avatar
Deb Mukherjee committed
559
      active_best_quality = get_active_quality(
Dmitry Kovalev's avatar
Dmitry Kovalev committed
560
          q, rc->gfu_boost, gf_low, gf_high,
Deb Mukherjee's avatar
Deb Mukherjee committed
561
          gf_low_motion_minq, gf_high_motion_minq);
562
563
    }
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
564
    if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
Deb Mukherjee's avatar
Deb Mukherjee committed
565
      active_best_quality = cpi->cq_target_quality;
566
    } else {
567
568
569
570
571
      // Use the lower of active_worst_quality and recent/average Q.
      if (rc->avg_frame_qindex[INTER_FRAME] < active_worst_quality)
       active_best_quality = inter_minq[rc->avg_frame_qindex[INTER_FRAME]];
      else
        active_best_quality = inter_minq[active_worst_quality];
572
573
      // For the constrained quality mode we don't want
      // q to fall below the cq level.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
574
      if ((oxcf->end_usage == USAGE_CONSTRAINED_QUALITY) &&
Deb Mukherjee's avatar
Deb Mukherjee committed
575
          (active_best_quality < cpi->cq_target_quality)) {
576
577
578
        // If we are strongly undershooting the target rate in the last
        // frames then use the user passed in cq value not the auto
        // cq value.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
579
580
        if (rc->rolling_actual_bits < rc->min_frame_bandwidth)
          active_best_quality = oxcf->cq_level;
581
        else
Deb Mukherjee's avatar
Deb Mukherjee committed
582
          active_best_quality = cpi->cq_target_quality;
583
584
585
586
587
      }
    }
  }

  // Clip the active best and worst quality values to limits
588
589
590
591
  active_best_quality = clamp(active_best_quality,
                              rc->best_quality, rc->worst_quality);
  active_worst_quality = clamp(active_worst_quality,
                               active_best_quality, rc->worst_quality);
592

Deb Mukherjee's avatar
Deb Mukherjee committed
593
594
  *top_index = active_worst_quality;
  *bottom_index = active_best_quality;
595
596

#if LIMIT_QRANGE_FOR_ALTREF_AND_KEY
597
  // Limit Q range for the adaptive loop.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
598
  if (cm->frame_type == KEY_FRAME && !rc->this_key_frame_forced) {
599
    if (!(cm->current_video_frame == 0))
600
      *top_index = (active_worst_quality + active_best_quality * 3) / 4;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
601
602
  } else if (!rc->is_src_frame_alt_ref &&
             (oxcf->end_usage != USAGE_STREAM_FROM_SERVER) &&
603
             (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
604
    *top_index = (active_worst_quality + active_best_quality) / 2;
605
  }
606
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
607
  if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
Deb Mukherjee's avatar
Deb Mukherjee committed
608
    q = active_best_quality;
609
  // Special case code to try and match quality with forced key frames
Dmitry Kovalev's avatar
Dmitry Kovalev committed
610
611
  } else if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced) {
    q = rc->last_boosted_qindex;
612
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
613
    q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
614
                          active_best_quality, active_worst_quality);
Paul Wilkins's avatar
Paul Wilkins committed
615
616
617
618
619
620
621
    if (q > *top_index) {
      // Special case when we are targeting the max allowed rate
      if (cpi->rc.this_frame_target >= cpi->rc.max_frame_bandwidth)
        *top_index = q;
      else
        q = *top_index;
    }
622
  }
Deb Mukherjee's avatar
Deb Mukherjee committed
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
#if CONFIG_MULTIPLE_ARF
  // Force the quantizer determined by the coding order pattern.
  if (cpi->multi_arf_enabled && (cm->frame_type != KEY_FRAME) &&
      cpi->oxcf.end_usage != USAGE_CONSTANT_QUALITY) {
    double new_q;
    double current_q = vp9_convert_qindex_to_q(active_worst_quality);
    int level = cpi->this_frame_weight;
    assert(level >= 0);
    new_q = current_q * (1.0 - (0.2 * (cpi->max_arf_level - level)));
    q = active_worst_quality +
        vp9_compute_qdelta(cpi, current_q, new_q);

    *bottom_index = q;
    *top_index    = q;
    printf("frame:%d q:%d\n", cm->current_video_frame, q);
  }
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
640
641
642
643
644
  assert(*top_index <= rc->worst_quality &&
         *top_index >= rc->best_quality);
  assert(*bottom_index <= rc->worst_quality &&
         *bottom_index >= rc->best_quality);
  assert(q <= rc->worst_quality && q >= rc->best_quality);
645
  return q;
John Koleszar's avatar
John Koleszar committed
646
647
}

648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
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
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
static int rc_pick_q_and_adjust_q_bounds_two_pass(const VP9_COMP *cpi,
                                                  int *bottom_index,
                                                  int *top_index) {
  const VP9_COMMON *const cm = &cpi->common;
  const RATE_CONTROL *const rc = &cpi->rc;
  const VP9_CONFIG *const oxcf = &cpi->oxcf;
  int active_best_quality;
  int active_worst_quality = rc->active_worst_quality;
  int q;

  if (frame_is_intra_only(cm)) {
    active_best_quality = rc->best_quality;
#if !CONFIG_MULTIPLE_ARF
    // Handle the special case for key frames forced when we have75 reached
    // the maximum key frame interval. Here force the Q to a range
    // based on the ambient Q to reduce the risk of popping.
    if (rc->this_key_frame_forced) {
      int qindex = rc->last_boosted_qindex;
      double last_boosted_q = vp9_convert_qindex_to_q(qindex);
      int delta_qindex = vp9_compute_qdelta(cpi, last_boosted_q,
                                            (last_boosted_q * 0.75));
      active_best_quality = MAX(qindex + delta_qindex, rc->best_quality);
    } else {
      // Not forced keyframe.
      double q_adj_factor = 1.0;
      double q_val;
      // Baseline value derived from cpi->active_worst_quality and kf boost.
      active_best_quality = get_active_quality(active_worst_quality,
                                               rc->kf_boost,
                                               kf_low, kf_high,
                                               kf_low_motion_minq,
                                               kf_high_motion_minq);

      // Allow somewhat lower kf minq with small image formats.
      if ((cm->width * cm->height) <= (352 * 288)) {
        q_adj_factor -= 0.25;
      }

      // Make a further adjustment based on the kf zero motion measure.
      q_adj_factor += 0.05 - (0.001 * (double)cpi->twopass.kf_zeromotion_pct);

      // Convert the adjustment factor to a qindex delta
      // on active_best_quality.
      q_val = vp9_convert_qindex_to_q(active_best_quality);
      active_best_quality += vp9_compute_qdelta(cpi, q_val, q_val *
                                                   q_adj_factor);
    }
#else
    double current_q;
    // Force the KF quantizer to be 30% of the active_worst_quality.
    current_q = vp9_convert_qindex_to_q(active_worst_quality);
    active_best_quality = active_worst_quality
        + vp9_compute_qdelta(cpi, current_q, current_q * 0.3);
#endif
  } else if (!rc->is_src_frame_alt_ref &&
             (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
    // Use the lower of active_worst_quality and recent
    // average Q as basis for GF/ARF best Q limit unless last frame was
    // a key frame.
    if (rc->frames_since_key > 1 &&
        rc->avg_frame_qindex[INTER_FRAME] < active_worst_quality) {
      q = rc->avg_frame_qindex[INTER_FRAME];
    } else {
      q = active_worst_quality;
    }
    // For constrained quality dont allow Q less than the cq level
    if (oxcf->end_usage == USAGE_CONSTRAINED_QUALITY) {
      if (q < cpi->cq_target_quality)
        q = cpi->cq_target_quality;
      if (rc->frames_since_key > 1) {
        active_best_quality = get_active_quality(q, rc->gfu_boost,
                                                 gf_low, gf_high,
                                                 afq_low_motion_minq,
                                                 afq_high_motion_minq);
      } else {
        active_best_quality = get_active_quality(q, rc->gfu_boost,
                                                 gf_low, gf_high,
                                                 gf_low_motion_minq,
                                                 gf_high_motion_minq);
      }
      // Constrained quality use slightly lower active best.
      active_best_quality = active_best_quality * 15 / 16;

    } else if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
      if (!cpi->refresh_alt_ref_frame) {
        active_best_quality = cpi->cq_target_quality;
      } else {
        if (rc->frames_since_key > 1) {
          active_best_quality = get_active_quality(
              q, rc->gfu_boost, gf_low, gf_high,
              afq_low_motion_minq, afq_high_motion_minq);
        } else {
          active_best_quality = get_active_quality(
              q, rc->gfu_boost, gf_low, gf_high,
              gf_low_motion_minq, gf_high_motion_minq);
        }
      }
    } else {
      active_best_quality = get_active_quality(
          q, rc->gfu_boost, gf_low, gf_high,
          gf_low_motion_minq, gf_high_motion_minq);
    }
  } else {
    if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
      active_best_quality = cpi->cq_target_quality;
    } else {
      active_best_quality = inter_minq[active_worst_quality];

      // For the constrained quality mode we don't want
      // q to fall below the cq level.
      if ((oxcf->end_usage == USAGE_CONSTRAINED_QUALITY) &&
          (active_best_quality < cpi->cq_target_quality)) {
        // If we are strongly undershooting the target rate in the last
        // frames then use the user passed in cq value not the auto
        // cq value.
        if (rc->rolling_actual_bits < rc->min_frame_bandwidth)
          active_best_quality = oxcf->cq_level;
        else
          active_best_quality = cpi->cq_target_quality;
      }
    }
  }

  // Clip the active best and worst quality values to limits.
  if (active_worst_quality > rc->worst_quality)
    active_worst_quality = rc->worst_quality;

  if (active_best_quality < rc->best_quality)
    active_best_quality = rc->best_quality;

  if (active_best_quality > rc->worst_quality)
    active_best_quality = rc->worst_quality;

  if (active_worst_quality < active_best_quality)
    active_worst_quality = active_best_quality;

  *top_index = active_worst_quality;
  *bottom_index = active_best_quality;

#if LIMIT_QRANGE_FOR_ALTREF_AND_KEY
  // Limit Q range for the adaptive loop.
  if (cm->frame_type == KEY_FRAME && !rc->this_key_frame_forced) {
    *top_index = (active_worst_quality + active_best_quality * 3) / 4;
  } else if (!rc->is_src_frame_alt_ref &&
             (oxcf->end_usage != USAGE_STREAM_FROM_SERVER) &&
             (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
    *top_index = (active_worst_quality + active_best_quality) / 2;
  }
#endif

  if (oxcf->end_usage == USAGE_CONSTANT_QUALITY) {
    q = active_best_quality;
  // Special case code to try and match quality with forced key frames.
  } else if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced) {
    q = rc->last_boosted_qindex;
  } else {
    q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
                          active_best_quality, active_worst_quality);
    if (q > *top_index) {
      // Special case when we are targeting the max allowed rate.
      if (cpi->rc.this_frame_target >= cpi->rc.max_frame_bandwidth)
        *top_index = q;
      else
        q = *top_index;
    }
  }
#if CONFIG_MULTIPLE_ARF
  // Force the quantizer determined by the coding order pattern.
  if (cpi->multi_arf_enabled && (cm->frame_type != KEY_FRAME) &&
      cpi->oxcf.end_usage != USAGE_CONSTANT_QUALITY) {
    double new_q;
    double current_q = vp9_convert_qindex_to_q(active_worst_quality);
    int level = cpi->this_frame_weight;
    assert(level >= 0);
    new_q = current_q * (1.0 - (0.2 * (cpi->max_arf_level - level)));
    q = active_worst_quality +
        vp9_compute_qdelta(cpi, current_q, new_q);

    *bottom_index = q;
    *top_index    = q;
    printf("frame:%d q:%d\n", cm->current_video_frame, q);
  }
#endif
  assert(*top_index <= rc->worst_quality &&
         *top_index >= rc->best_quality);
  assert(*bottom_index <= rc->worst_quality &&
         *bottom_index >= rc->best_quality);
  assert(q <= rc->worst_quality && q >= rc->best_quality);
  return q;
}

int vp9_rc_pick_q_and_adjust_q_bounds(const VP9_COMP *cpi,
                                      int *bottom_index,
                                      int *top_index) {
842
  int q;
843
  if (cpi->pass == 0)
844
    q = rc_pick_q_and_adjust_q_bounds_one_pass(
845
846
        cpi, bottom_index, top_index);
  else
847
    q = rc_pick_q_and_adjust_q_bounds_two_pass(
848
        cpi, bottom_index, top_index);
849
850
851
852

  // JBB : This is realtime mode.  In real time mode the first frame
  // should be larger. Q of 0 is disabled because we force tx size to be
  // 16x16...
853
  if (cpi->sf.use_pick_mode) {
854
855
856
857
858
859
860
861
862
863
    if (cpi->common.current_video_frame == 0)
      q /= 3;
    if (q == 0)
      q++;
    if (q < *bottom_index)
      *bottom_index = q;
    else if (q > *top_index)
      *top_index = q;
  }
  return q;
864
865
}

Deb Mukherjee's avatar
Deb Mukherjee committed
866
void vp9_rc_compute_frame_size_bounds(const VP9_COMP *cpi,
867
868
869
                                      int this_frame_target,
                                      int *frame_under_shoot_limit,
                                      int *frame_over_shoot_limit) {
John Koleszar's avatar
John Koleszar committed
870
  // Set-up bounds on acceptable frame size:
871
  if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
John Koleszar's avatar
John Koleszar committed
872
873
874
875
    *frame_under_shoot_limit = 0;
    *frame_over_shoot_limit  = INT_MAX;
  } else {
    if (cpi->common.frame_type == KEY_FRAME) {
876
877
      *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
878
    } else {
879
      if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) {
880
881
        *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
882
883
884
      } else {
        // Stron overshoot limit for constrained quality
        if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
885
886
          *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
887
        } else {
888
889
          *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
890
        }
John Koleszar's avatar
John Koleszar committed
891
      }
John Koleszar's avatar
John Koleszar committed
892
    }
John Koleszar's avatar
John Koleszar committed
893
894
895
896
897
898
899
900

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

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

909
void vp9_rc_set_frame_target(VP9_COMP *cpi, int target) {
910
911
  const VP9_COMMON *const cm = &cpi->common;
  RATE_CONTROL *const rc = &cpi->rc;
912

913
  rc->this_frame_target = target;
914
  // Target rate per SB64 (including partial SB64s.
915
916
  rc->sb64_target_rate = ((int64_t)rc->this_frame_target * 64 * 64) /
                             (cm->width * cm->height);
917
}
918

Deb Mukherjee's avatar
Deb Mukherjee committed
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
static void update_alt_ref_frame_stats(VP9_COMP *cpi) {
  // this frame refreshes means next frames don't unless specified by user
  cpi->rc.frames_since_golden = 0;

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

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

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

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
941
942
    if (!rc->source_alt_ref_pending)
      rc->source_alt_ref_active = 0;
Deb Mukherjee's avatar
Deb Mukherjee committed
943
944

    // Decrement count down till next gf
Dmitry Kovalev's avatar
Dmitry Kovalev committed
945
946
    if (rc->frames_till_gf_update_due > 0)
      rc->frames_till_gf_update_due--;
Deb Mukherjee's avatar
Deb Mukherjee committed
947
948
949

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
953
    rc->frames_since_golden++;
Deb Mukherjee's avatar
Deb Mukherjee committed
954
955
956
  }
}

957
void vp9_rc_postencode_update(VP9_COMP *cpi, uint64_t bytes_used) {
958
  VP9_COMMON *const cm = &cpi->common;
959
  RATE_CONTROL *const rc = &cpi->rc;
960
961

  cm->last_frame_type = cm->frame_type;
962
  // Update rate control heuristics
963
  rc->projected_frame_size = (bytes_used << 3);
964
965

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

970
971
  // Keep a record of last Q and ambient average Q.
  if (cm->frame_type == KEY_FRAME) {
972
973
974
975
    rc->last_q[KEY_FRAME] = cm->base_qindex;
    rc->avg_frame_qindex[KEY_FRAME] = ROUND_POWER_OF_TWO(
        3 * rc->avg_frame_qindex[KEY_FRAME] + cm->base_qindex, 2);
  } else if (!rc->is_src_frame_alt_ref &&
976
977
      (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame) &&
      !(cpi->use_svc && cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)) {
978
979
980
    rc->last_q[2] = cm->base_qindex;
    rc->avg_frame_qindex[2] = ROUND_POWER_OF_TWO(
        3 * rc->avg_frame_qindex[2] + cm->base_qindex, 2);
981
  } else {
982
983
984
985
986
987
    rc->last_q[INTER_FRAME] = cm->base_qindex;
    rc->avg_frame_qindex[INTER_FRAME] = ROUND_POWER_OF_TWO(
        3 * rc->avg_frame_qindex[INTER_FRAME] + cm->base_qindex, 2);
    rc->ni_frames++;
    rc->tot_q += vp9_convert_qindex_to_q(cm->base_qindex);
    rc->avg_q = rc->tot_q / (double)rc->ni_frames;
988
989

    // Calculate the average Q for normal inter frames (not key or GFU frames).
990
991
    rc->ni_tot_qi += cm->base_qindex;
    rc->ni_av_qi = rc->ni_tot_qi / rc->ni_frames;
992
  }
993
994
995
996
997
998

  // 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
999
  if ((cm->base_qindex < rc->last_boosted_qindex) ||
1000
      ((cpi->static_mb_pct < 100) &&
For faster browsing, not all history is shown. View entire blame