vp9_ratectrl.h 7.28 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
#ifndef VP9_ENCODER_VP9_RATECTRL_H_
#define VP9_ENCODER_VP9_RATECTRL_H_
John Koleszar's avatar
John Koleszar committed
14

15
#include "vpx/vpx_codec.h"
16
17
18
19
#include "vpx/vpx_integer.h"

#include "vp9/common/vp9_blockd.h"

20
21
22
23
#ifdef __cplusplus
extern "C" {
#endif

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

27
28
29
30
31
32
33
34
35
typedef enum {
  INTER_NORMAL = 0,
  INTER_HIGH = 1,
  GF_ARF_LOW = 2,
  GF_ARF_STD = 3,
  KF_STD = 4,
  RATE_FACTOR_LEVELS = 5
} RATE_FACTOR_LEVEL;

36
37
typedef struct {
  // Rate targetting variables
38
39
40
  int base_frame_target;           // A baseline frame target before adjustment
                                   // for previous under or over shoot.
  int this_frame_target;           // Actual frame target after rc adjustment.
41
42
  int projected_frame_size;
  int sb64_target_rate;
43
  int last_q[FRAME_TYPES];         // Separate values for Intra/Inter
44
  int last_boosted_qindex;         // Last boosted GF/KF/ARF q
45
  int last_kf_qindex;              // Q index of the last key frame coded.
46
47
48
49
50

  int gfu_boost;
  int last_boost;
  int kf_boost;

51
  double rate_correction_factors[RATE_FACTOR_LEVELS];
52

53
54
55
  int frames_since_golden;
  int frames_till_gf_update_due;
  int max_gf_interval;
56
  int static_scene_max_gf_interval;
57
  int baseline_gf_interval;
58
  int constrained_gf_group;
59
60
61
62
63
64
65
  int frames_to_key;
  int frames_since_key;
  int this_key_frame_forced;
  int next_key_frame_forced;
  int source_alt_ref_pending;
  int source_alt_ref_active;
  int is_src_frame_alt_ref;
66

67
68
69
  int avg_frame_bandwidth;  // Average frame size target for clip
  int min_frame_bandwidth;  // Minimum allocation used for any frame
  int max_frame_bandwidth;  // Maximum burst rate allowed for a frame.
70
71
72
73

  int ni_av_qi;
  int ni_tot_qi;
  int ni_frames;
74
  int avg_frame_qindex[FRAME_TYPES];
75
76
77
  double tot_q;
  double avg_q;

78
79
  int64_t buffer_level;
  int64_t bits_off_target;
80
  int64_t vbr_bits_off_target;
81
82
83
84
85
86
87
88
89
90

  int decimation_factor;
  int decimation_count;

  int rolling_target_bits;
  int rolling_actual_bits;

  int long_rolling_target_bits;
  int long_rolling_actual_bits;

Paul Wilkins's avatar
Paul Wilkins committed
91
92
  int rate_error_estimate;

93
  int64_t total_actual_bits;
94
95
  int64_t total_target_bits;
  int64_t total_target_vs_actual;
96
97
98

  int worst_quality;
  int best_quality;
99
100
101
102

  int64_t starting_buffer_level;
  int64_t optimal_buffer_level;
  int64_t maximum_buffer_size;
103
104
105
106
107
108
109
110
  // rate control history for last frame(1) and the frame before(2).
  // -1: undershot
  //  1: overshoot
  //  0: not initialized.
  int rc_1_frame;
  int rc_2_frame;
  int q_1_frame;
  int q_2_frame;
111
112
113
} RATE_CONTROL;

struct VP9_COMP;
114
struct VP9EncoderConfig;
115

116
117
void vp9_rc_init(const struct VP9EncoderConfig *oxcf, int pass,
                 RATE_CONTROL *rc);
118

119
120
121
122
int vp9_estimate_bits_at_q(FRAME_TYPE frame_kind, int q, int mbs,
                           double correction_factor,
                           vpx_bit_depth_t bit_depth);

123
double vp9_convert_qindex_to_q(int qindex, vpx_bit_depth_t bit_depth);
124

Dmitry Kovalev's avatar
Dmitry Kovalev committed
125
void vp9_rc_init_minq_luts();
126

127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
// Generally at the high level, the following flow is expected
// to be enforced for rate control:
// First call per frame, one of:
//   vp9_rc_get_one_pass_vbr_params()
//   vp9_rc_get_one_pass_cbr_params()
//   vp9_rc_get_svc_params()
//   vp9_rc_get_first_pass_params()
//   vp9_rc_get_second_pass_params()
// depending on the usage to set the rate control encode parameters desired.
//
// Then, call encode_frame_to_data_rate() to perform the
// actual encode. This function will in turn call encode_frame()
// one or more times, followed by one of:
//   vp9_rc_postencode_update()
//   vp9_rc_postencode_update_drop_frame()
//
// The majority of rate control parameters are only expected
// to be set in the vp9_rc_get_..._params() functions and
// updated during the vp9_rc_postencode_update...() functions.
// The only exceptions are vp9_rc_drop_frame() and
// vp9_rc_update_rate_correction_factors() functions.

// Functions to set parameters for encoding before the actual
// encode_frame_to_data_rate() function.
void vp9_rc_get_one_pass_vbr_params(struct VP9_COMP *cpi);
void vp9_rc_get_one_pass_cbr_params(struct VP9_COMP *cpi);
void vp9_rc_get_svc_params(struct VP9_COMP *cpi);

// Post encode update of the rate control parameters based
// on bytes used
157
void vp9_rc_postencode_update(struct VP9_COMP *cpi, uint64_t bytes_used);
158
159
160
161
162
// Post encode update of the rate control parameters for dropped frames
void vp9_rc_postencode_update_drop_frame(struct VP9_COMP *cpi);

// Updates rate correction factors
// Changes only the rate correction factors in the rate control structure.
163
void vp9_rc_update_rate_correction_factors(struct VP9_COMP *cpi);
Deb Mukherjee's avatar
Deb Mukherjee committed
164

165
166
167
168
169
// Decide if we should drop this frame: For 1-pass CBR.
// Changes only the decimation count in the rate control structure
int vp9_rc_drop_frame(struct VP9_COMP *cpi);

// Computes frame size bounds.
170
void vp9_rc_compute_frame_size_bounds(const struct VP9_COMP *cpi,
Deb Mukherjee's avatar
Deb Mukherjee committed
171
                                      int this_frame_target,
172
173
                                      int *frame_under_shoot_limit,
                                      int *frame_over_shoot_limit);
Deb Mukherjee's avatar
Deb Mukherjee committed
174

175
// Picks q and q bounds given the target for bits
176
177
178
int vp9_rc_pick_q_and_bounds(const struct VP9_COMP *cpi,
                             int *bottom_index,
                             int *top_index);
179
180

// Estimates q to achieve a target bits per frame
181
int vp9_rc_regulate_q(const struct VP9_COMP *cpi, int target_bits_per_frame,
Deb Mukherjee's avatar
Deb Mukherjee committed
182
                      int active_best_quality, int active_worst_quality);
183

184
// Estimates bits per mb for a given qindex and correction factor.
185
int vp9_rc_bits_per_mb(FRAME_TYPE frame_type, int qindex,
186
                       double correction_factor, vpx_bit_depth_t bit_depth);
187

188
189
190
191
192
193
194
195
// Clamping utilities for bitrate targets for iframes and pframes.
int vp9_rc_clamp_iframe_target_size(const struct VP9_COMP *const cpi,
                                    int target);
int vp9_rc_clamp_pframe_target_size(const struct VP9_COMP *const cpi,
                                    int target);
// Utility to set frame_target into the RATE_CONTROL structure
// This function is called only from the vp9_rc_get_..._params() functions.
void vp9_rc_set_frame_target(struct VP9_COMP *cpi, int target);
196

197
198
// Computes a q delta (in "q index" terms) to get from a starting q value
// to a target q value
199
200
int vp9_compute_qdelta(const RATE_CONTROL *rc, double qstart, double qtarget,
                       vpx_bit_depth_t bit_depth);
201
202
203
204

// Computes a q delta (in "q index" terms) to get from a starting q value
// to a value that should equate to the given rate ratio.
int vp9_compute_qdelta_by_rate(const RATE_CONTROL *rc, FRAME_TYPE frame_type,
205
206
                               int qindex, double rate_target_ratio,
                               vpx_bit_depth_t bit_depth);
207

208
209
void vp9_rc_update_framerate(struct VP9_COMP *cpi);

210
void vp9_rc_set_gf_max_interval(const struct VP9_COMP *const cpi,
Paul Wilkins's avatar
Paul Wilkins committed
211
212
                                RATE_CONTROL *const rc);

213
214
void vp9_set_target_rate(struct VP9_COMP *cpi);

215
216
217
218
#ifdef __cplusplus
}  // extern "C"
#endif

219
#endif  // VP9_ENCODER_VP9_RATECTRL_H_