2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * 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.
18 #include "vp8/common/common.h"
20 #include "vp8/common/entropymode.h"
21 #include "vpx_mem/vpx_mem.h"
22 #include "vp8/common/systemdependent.h"
24 #include "vpx_dsp/vpx_dsp_common.h"
25 #include "vpx_ports/system_state.h"
27 #define MIN_BPB_FACTOR 0.01
28 #define MAX_BPB_FACTOR 50
30 extern const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES];
33 extern int y_modes[5];
34 extern int uv_modes[4];
35 extern int b_modes[10];
37 extern int inter_y_modes[10];
38 extern int inter_uv_modes[4];
39 extern int inter_b_modes[10];
42 /* Bits Per MB at different Q (Multiplied by 512) */
43 #define BPER_MB_NORMBITS 9
45 /* Work in progress recalibration of baseline rate tables based on
46 * the assumption that bits per mb is inversely proportional to the
49 const int vp8_bits_per_mb[2][QINDEX_RANGE] = {
50 /* Intra case 450000/Qintra */
52 1125000, 900000, 750000, 642857, 562500, 500000, 450000, 450000, 409090,
53 375000, 346153, 321428, 300000, 281250, 264705, 264705, 250000, 236842,
54 225000, 225000, 214285, 214285, 204545, 204545, 195652, 195652, 187500,
55 180000, 180000, 173076, 166666, 160714, 155172, 150000, 145161, 140625,
56 136363, 132352, 128571, 125000, 121621, 121621, 118421, 115384, 112500,
57 109756, 107142, 104651, 102272, 100000, 97826, 97826, 95744, 93750,
58 91836, 90000, 88235, 86538, 84905, 83333, 81818, 80357, 78947,
59 77586, 76271, 75000, 73770, 72580, 71428, 70312, 69230, 68181,
60 67164, 66176, 65217, 64285, 63380, 62500, 61643, 60810, 60000,
61 59210, 59210, 58441, 57692, 56962, 56250, 55555, 54878, 54216,
62 53571, 52941, 52325, 51724, 51136, 50561, 49450, 48387, 47368,
63 46875, 45918, 45000, 44554, 44117, 43269, 42452, 41666, 40909,
64 40178, 39473, 38793, 38135, 36885, 36290, 35714, 35156, 34615,
65 34090, 33582, 33088, 32608, 32142, 31468, 31034, 30405, 29801,
68 /* Inter case 285000/Qinter */
70 712500, 570000, 475000, 407142, 356250, 316666, 285000, 259090, 237500,
71 219230, 203571, 190000, 178125, 167647, 158333, 150000, 142500, 135714,
72 129545, 123913, 118750, 114000, 109615, 105555, 101785, 98275, 95000,
73 91935, 89062, 86363, 83823, 81428, 79166, 77027, 75000, 73076,
74 71250, 69512, 67857, 66279, 64772, 63333, 61956, 60638, 59375,
75 58163, 57000, 55882, 54807, 53773, 52777, 51818, 50892, 50000,
76 49137, 47500, 45967, 44531, 43181, 41911, 40714, 39583, 38513,
77 37500, 36538, 35625, 34756, 33928, 33139, 32386, 31666, 30978,
78 30319, 29687, 29081, 28500, 27941, 27403, 26886, 26388, 25909,
79 25446, 25000, 24568, 23949, 23360, 22800, 22265, 21755, 21268,
80 20802, 20357, 19930, 19520, 19127, 18750, 18387, 18037, 17701,
81 17378, 17065, 16764, 16473, 16101, 15745, 15405, 15079, 14766,
82 14467, 14179, 13902, 13636, 13380, 13133, 12895, 12666, 12445,
83 12179, 11924, 11632, 11445, 11220, 11003, 10795, 10594, 10401,
88 static const int kf_boost_qadjustment[QINDEX_RANGE] = {
89 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
90 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
91 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172,
92 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,
93 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 200, 201,
94 201, 202, 203, 203, 203, 204, 204, 205, 205, 206, 206, 207, 207, 208, 208,
95 209, 209, 210, 210, 211, 211, 212, 212, 213, 213, 214, 214, 215, 215, 216,
96 216, 217, 217, 218, 218, 219, 219, 220, 220, 220, 220, 220, 220, 220, 220,
97 220, 220, 220, 220, 220, 220, 220, 220,
100 /* #define GFQ_ADJUSTMENT (Q+100) */
101 #define GFQ_ADJUSTMENT vp8_gf_boost_qadjustment[Q]
102 const int vp8_gf_boost_qadjustment[QINDEX_RANGE] = {
103 80, 82, 84, 86, 88, 90, 92, 94, 96, 97, 98, 99, 100, 101, 102,
104 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
105 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
106 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
107 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162,
108 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
109 178, 179, 180, 181, 182, 183, 184, 184, 185, 185, 186, 186, 187, 187, 188,
110 188, 189, 189, 190, 190, 191, 191, 192, 192, 193, 193, 194, 194, 194, 194,
111 195, 195, 196, 196, 197, 197, 198, 198
115 const int vp8_gf_boost_qadjustment[QINDEX_RANGE] =
117 100,101,102,103,104,105,105,106,
118 106,107,107,108,109,109,110,111,
119 112,113,114,115,116,117,118,119,
120 120,121,122,123,124,125,126,127,
121 128,129,130,131,132,133,134,135,
122 136,137,138,139,140,141,142,143,
123 144,145,146,147,148,149,150,151,
124 152,153,154,155,156,157,158,159,
125 160,161,162,163,164,165,166,167,
126 168,169,170,170,171,171,172,172,
127 173,173,173,174,174,174,175,175,
128 175,176,176,176,177,177,177,177,
129 178,178,179,179,180,180,181,181,
130 182,182,183,183,184,184,185,185,
131 186,186,187,187,188,188,189,189,
132 190,190,191,191,192,192,193,193,
136 static const int kf_gf_boost_qlimits[QINDEX_RANGE] = {
137 150, 155, 160, 165, 170, 175, 180, 185, 190, 195, 200, 205, 210, 215, 220,
138 225, 230, 235, 240, 245, 250, 255, 260, 265, 270, 275, 280, 285, 290, 295,
139 300, 305, 310, 320, 330, 340, 350, 360, 370, 380, 390, 400, 410, 420, 430,
140 440, 450, 460, 470, 480, 490, 500, 510, 520, 530, 540, 550, 560, 570, 580,
141 590, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600,
142 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600,
143 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600,
144 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600,
145 600, 600, 600, 600, 600, 600, 600, 600,
148 static const int gf_adjust_table[101] = {
149 100, 115, 130, 145, 160, 175, 190, 200, 210, 220, 230, 240, 260, 270, 280,
150 290, 300, 310, 320, 330, 340, 350, 360, 370, 380, 390, 400, 400, 400, 400,
151 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
152 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
153 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
154 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
155 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
158 static const int gf_intra_usage_adjustment[20] = {
159 125, 120, 115, 110, 105, 100, 95, 85, 80, 75,
160 70, 65, 60, 55, 50, 50, 50, 50, 50, 50,
163 static const int gf_interval_table[101] = {
164 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
165 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8,
166 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
167 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
168 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
169 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
172 static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = { 1, 2, 3,
175 void vp8_save_coding_context(VP8_COMP *cpi) {
176 CODING_CONTEXT *const cc = &cpi->coding_context;
178 /* Stores a snapshot of key state variables which can subsequently be
179 * restored with a call to vp8_restore_coding_context. These functions are
180 * intended for use in a re-code loop in vp8_compress_frame where the
181 * quantizer value is adjusted between loop iterations.
184 cc->frames_since_key = cpi->frames_since_key;
185 cc->filter_level = cpi->common.filter_level;
186 cc->frames_till_gf_update_due = cpi->frames_till_gf_update_due;
187 cc->frames_since_golden = cpi->frames_since_golden;
189 vp8_copy(cc->mvc, cpi->common.fc.mvc);
190 vp8_copy(cc->mvcosts, cpi->rd_costs.mvcosts);
192 vp8_copy(cc->ymode_prob, cpi->common.fc.ymode_prob);
193 vp8_copy(cc->uv_mode_prob, cpi->common.fc.uv_mode_prob);
195 vp8_copy(cc->ymode_count, cpi->mb.ymode_count);
196 vp8_copy(cc->uv_mode_count, cpi->mb.uv_mode_count);
200 vp8_copy(cc->y_modes, y_modes);
201 vp8_copy(cc->uv_modes, uv_modes);
202 vp8_copy(cc->b_modes, b_modes);
203 vp8_copy(cc->inter_y_modes, inter_y_modes);
204 vp8_copy(cc->inter_uv_modes, inter_uv_modes);
205 vp8_copy(cc->inter_b_modes, inter_b_modes);
208 cc->this_frame_percent_intra = cpi->this_frame_percent_intra;
211 void vp8_restore_coding_context(VP8_COMP *cpi) {
212 CODING_CONTEXT *const cc = &cpi->coding_context;
214 /* Restore key state variables to the snapshot state stored in the
215 * previous call to vp8_save_coding_context.
218 cpi->frames_since_key = cc->frames_since_key;
219 cpi->common.filter_level = cc->filter_level;
220 cpi->frames_till_gf_update_due = cc->frames_till_gf_update_due;
221 cpi->frames_since_golden = cc->frames_since_golden;
223 vp8_copy(cpi->common.fc.mvc, cc->mvc);
225 vp8_copy(cpi->rd_costs.mvcosts, cc->mvcosts);
227 vp8_copy(cpi->common.fc.ymode_prob, cc->ymode_prob);
228 vp8_copy(cpi->common.fc.uv_mode_prob, cc->uv_mode_prob);
230 vp8_copy(cpi->mb.ymode_count, cc->ymode_count);
231 vp8_copy(cpi->mb.uv_mode_count, cc->uv_mode_count);
235 vp8_copy(y_modes, cc->y_modes);
236 vp8_copy(uv_modes, cc->uv_modes);
237 vp8_copy(b_modes, cc->b_modes);
238 vp8_copy(inter_y_modes, cc->inter_y_modes);
239 vp8_copy(inter_uv_modes, cc->inter_uv_modes);
240 vp8_copy(inter_b_modes, cc->inter_b_modes);
243 cpi->this_frame_percent_intra = cc->this_frame_percent_intra;
246 void vp8_setup_key_frame(VP8_COMP *cpi) {
247 /* Setup for Key frame: */
249 vp8_default_coef_probs(&cpi->common);
251 memcpy(cpi->common.fc.mvc, vp8_default_mv_context,
252 sizeof(vp8_default_mv_context));
254 int flag[2] = { 1, 1 };
255 vp8_build_component_cost_table(
256 cpi->mb.mvcost, (const MV_CONTEXT *)cpi->common.fc.mvc, flag);
259 /* Make sure we initialize separate contexts for altref,gold, and normal.
260 * TODO shouldn't need 3 different copies of structure to do this!
262 memcpy(&cpi->lfc_a, &cpi->common.fc, sizeof(cpi->common.fc));
263 memcpy(&cpi->lfc_g, &cpi->common.fc, sizeof(cpi->common.fc));
264 memcpy(&cpi->lfc_n, &cpi->common.fc, sizeof(cpi->common.fc));
266 cpi->common.filter_level = cpi->common.base_qindex * 3 / 8;
268 /* Provisional interval before next GF */
269 if (cpi->auto_gold) {
270 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
272 cpi->frames_till_gf_update_due = DEFAULT_GF_INTERVAL;
275 cpi->common.refresh_golden_frame = 1;
276 cpi->common.refresh_alt_ref_frame = 1;
279 static int estimate_bits_at_q(int frame_kind, int Q, int MBs,
280 double correction_factor) {
281 int Bpm = (int)(.5 + correction_factor * vp8_bits_per_mb[frame_kind][Q]);
283 /* Attempt to retain reasonable accuracy without overflow. The cutoff is
284 * chosen such that the maximum product of Bpm and MBs fits 31 bits. The
285 * largest Bpm takes 20 bits.
287 if (MBs > (1 << 11)) {
288 return (Bpm >> BPER_MB_NORMBITS) * MBs;
290 return (Bpm * MBs) >> BPER_MB_NORMBITS;
294 static void calc_iframe_target_size(VP8_COMP *cpi) {
295 /* boost defaults to half second */
299 /* Clear down mmx registers to allow floating point in what follows */
300 vpx_clear_system_state();
302 if (cpi->oxcf.fixed_q >= 0) {
303 int Q = cpi->oxcf.key_q;
305 target = estimate_bits_at_q(INTRA_FRAME, Q, cpi->common.MBs,
306 cpi->key_frame_rate_correction_factor);
307 } else if (cpi->pass == 2) {
308 /* New Two pass RC */
309 target = cpi->per_frame_bandwidth;
311 /* First Frame is a special case */
312 else if (cpi->common.current_video_frame == 0) {
313 /* 1 Pass there is no information on which to base size so use
314 * bandwidth per second * fraction of the initial buffer
317 target = cpi->oxcf.starting_buffer_level / 2;
319 if (target > cpi->oxcf.target_bandwidth * 3 / 2) {
320 target = cpi->oxcf.target_bandwidth * 3 / 2;
323 /* if this keyframe was forced, use a more recent Q estimate */
324 int Q = (cpi->common.frame_flags & FRAMEFLAGS_KEY) ? cpi->avg_frame_qindex
327 int initial_boost = 32; /* |3.0 * per_frame_bandwidth| */
328 /* Boost depends somewhat on frame rate: only used for 1 layer case. */
329 if (cpi->oxcf.number_of_layers == 1) {
331 VPXMAX(initial_boost, (int)round(2 * cpi->output_framerate - 16));
333 /* Initial factor: set target size to: |3.0 * per_frame_bandwidth|. */
334 kf_boost = initial_boost;
337 /* adjustment up based on q: this factor ranges from ~1.2 to 2.2. */
338 kf_boost = kf_boost * kf_boost_qadjustment[Q] / 100;
340 /* frame separation adjustment ( down) */
341 if (cpi->frames_since_key < cpi->output_framerate / 2) {
343 (int)(kf_boost * cpi->frames_since_key / (cpi->output_framerate / 2));
346 /* Minimal target size is |2* per_frame_bandwidth|. */
347 if (kf_boost < 16) kf_boost = 16;
349 target = ((16 + kf_boost) * cpi->per_frame_bandwidth) >> 4;
352 if (cpi->oxcf.rc_max_intra_bitrate_pct) {
353 unsigned int max_rate;
354 // This product may overflow unsigned int
355 uint64_t product = cpi->per_frame_bandwidth;
356 product *= cpi->oxcf.rc_max_intra_bitrate_pct;
358 max_rate = (unsigned int)VPXMIN(INT_MAX, product);
360 if (target > max_rate) target = max_rate;
363 cpi->this_frame_target = (int)target;
365 /* TODO: if we separate rate targeting from Q targeting, move this.
366 * Reset the active worst quality to the baseline value for key frames.
368 if (cpi->pass != 2) cpi->active_worst_quality = cpi->worst_quality;
374 f = fopen("kf_boost.stt", "a");
375 fprintf(f, " %8u %10d %10d %10d\n",
376 cpi->common.current_video_frame, cpi->gfu_boost, cpi->baseline_gf_interval, cpi->source_alt_ref_pending);
383 /* Do the best we can to define the parameters for the next GF based on what
384 * information we have available.
386 static void calc_gf_params(VP8_COMP *cpi) {
388 (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
391 int gf_frame_useage = 0; /* Golden frame useage since last GF */
392 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
393 cpi->recent_ref_frame_usage[LAST_FRAME] +
394 cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
395 cpi->recent_ref_frame_usage[ALTREF_FRAME];
397 int pct_gf_active = (100 * cpi->gf_active_count) /
398 (cpi->common.mb_rows * cpi->common.mb_cols);
401 gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
402 cpi->recent_ref_frame_usage[ALTREF_FRAME]) *
406 if (pct_gf_active > gf_frame_useage) gf_frame_useage = pct_gf_active;
409 if (cpi->pass != 2) {
410 /* Single Pass lagged mode: TBD */
414 /* Single Pass compression: Has to use current and historical data */
417 /* Experimental code */
418 int index = cpi->one_pass_frame_index;
419 int frames_to_scan = (cpi->max_gf_interval <= MAX_LAG_BUFFERS) ? cpi->max_gf_interval : MAX_LAG_BUFFERS;
421 /* ************** Experimental code - incomplete */
423 double decay_val = 1.0;
424 double IIAccumulator = 0.0;
425 double last_iiaccumulator = 0.0;
428 cpi->one_pass_frame_index = cpi->common.current_video_frame%MAX_LAG_BUFFERS;
430 for ( i = 0; i < (frames_to_scan - 1); i++ )
433 index = MAX_LAG_BUFFERS;
436 if ( cpi->one_pass_frame_stats[index].frame_coded_error > 0.0 )
438 IIRatio = cpi->one_pass_frame_stats[index].frame_intra_error / cpi->one_pass_frame_stats[index].frame_coded_error;
440 if ( IIRatio > 30.0 )
446 IIAccumulator += IIRatio * decay_val;
448 decay_val = decay_val * cpi->one_pass_frame_stats[index].frame_pcnt_inter;
450 if ( (i > MIN_GF_INTERVAL) &&
451 ((IIAccumulator - last_iiaccumulator) < 2.0) )
455 last_iiaccumulator = IIAccumulator;
458 Boost = IIAccumulator*100.0/16.0;
459 cpi->baseline_gf_interval = i;
464 /*************************************************************/
467 /* Adjust boost based upon ambient Q */
468 Boost = GFQ_ADJUSTMENT;
470 /* Adjust based upon most recently measure intra useage */
472 gf_intra_usage_adjustment[(cpi->this_frame_percent_intra < 15)
473 ? cpi->this_frame_percent_intra
477 /* Adjust gf boost based upon GF usage since last GF */
478 Boost = Boost * gf_adjust_table[gf_frame_useage] / 100;
482 /* golden frame boost without recode loop often goes awry. be
483 * safe by keeping numbers down.
485 if (!cpi->sf.recode_loop) {
486 if (cpi->compressor_speed == 2) Boost = Boost / 2;
489 /* Apply an upper limit based on Q for 1 pass encodes */
490 if (Boost > kf_gf_boost_qlimits[Q] && (cpi->pass == 0)) {
491 Boost = kf_gf_boost_qlimits[Q];
493 /* Apply lower limits to boost. */
494 } else if (Boost < 110) {
498 /* Note the boost used */
499 cpi->last_boost = Boost;
502 /* Estimate next interval
503 * This is updated once the real frame size/boost is known.
505 if (cpi->oxcf.fixed_q == -1) {
506 if (cpi->pass == 2) { /* 2 Pass */
507 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
508 } else { /* 1 Pass */
509 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
511 if (cpi->last_boost > 750) cpi->frames_till_gf_update_due++;
513 if (cpi->last_boost > 1000) cpi->frames_till_gf_update_due++;
515 if (cpi->last_boost > 1250) cpi->frames_till_gf_update_due++;
517 if (cpi->last_boost >= 1500) cpi->frames_till_gf_update_due++;
519 if (gf_interval_table[gf_frame_useage] > cpi->frames_till_gf_update_due) {
520 cpi->frames_till_gf_update_due = gf_interval_table[gf_frame_useage];
523 if (cpi->frames_till_gf_update_due > cpi->max_gf_interval) {
524 cpi->frames_till_gf_update_due = cpi->max_gf_interval;
528 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
532 if (cpi->pass != 2) {
533 /* For now Alt ref is not allowed except in 2 pass modes. */
534 cpi->source_alt_ref_pending = 0;
536 /*if ( cpi->oxcf.fixed_q == -1)
538 if ( cpi->oxcf.play_alternate && (cpi->last_boost > (100 +
539 (AF_THRESH*cpi->frames_till_gf_update_due)) ) )
540 cpi->source_alt_ref_pending = 1;
542 cpi->source_alt_ref_pending = 0;
547 static void calc_pframe_target_size(VP8_COMP *cpi) {
548 int min_frame_target;
549 int old_per_frame_bandwidth = cpi->per_frame_bandwidth;
551 if (cpi->current_layer > 0) {
552 cpi->per_frame_bandwidth =
553 cpi->layer_context[cpi->current_layer].avg_frame_size_for_layer;
556 min_frame_target = 0;
558 if (cpi->pass == 2) {
559 min_frame_target = cpi->min_frame_bandwidth;
561 if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5)) {
562 min_frame_target = cpi->av_per_frame_bandwidth >> 5;
564 } else if (min_frame_target < cpi->per_frame_bandwidth / 4) {
565 min_frame_target = cpi->per_frame_bandwidth / 4;
568 /* Special alt reference frame case */
569 if ((cpi->common.refresh_alt_ref_frame) &&
570 (cpi->oxcf.number_of_layers == 1)) {
571 if (cpi->pass == 2) {
572 /* Per frame bit target for the alt ref frame */
573 cpi->per_frame_bandwidth = cpi->twopass.gf_bits;
574 cpi->this_frame_target = cpi->per_frame_bandwidth;
577 /* One Pass ??? TBD */
580 /* Normal frames (gf,and inter) */
583 if (cpi->pass == 2) {
584 cpi->this_frame_target = cpi->per_frame_bandwidth;
589 /* Make rate adjustment to recover bits spent in key frame
590 * Test to see if the key frame inter data rate correction
591 * should still be in force
593 if (cpi->kf_overspend_bits > 0) {
594 Adjustment = (cpi->kf_bitrate_adjustment <= cpi->kf_overspend_bits)
595 ? cpi->kf_bitrate_adjustment
596 : cpi->kf_overspend_bits;
598 if (Adjustment > (cpi->per_frame_bandwidth - min_frame_target)) {
599 Adjustment = (cpi->per_frame_bandwidth - min_frame_target);
602 cpi->kf_overspend_bits -= Adjustment;
604 /* Calculate an inter frame bandwidth target for the next
605 * few frames designed to recover any extra bits spent on
608 cpi->this_frame_target = cpi->per_frame_bandwidth - Adjustment;
610 if (cpi->this_frame_target < min_frame_target) {
611 cpi->this_frame_target = min_frame_target;
614 cpi->this_frame_target = cpi->per_frame_bandwidth;
617 /* If appropriate make an adjustment to recover bits spent on a
620 if ((cpi->gf_overspend_bits > 0) &&
621 (cpi->this_frame_target > min_frame_target)) {
622 Adjustment = (cpi->non_gf_bitrate_adjustment <= cpi->gf_overspend_bits)
623 ? cpi->non_gf_bitrate_adjustment
624 : cpi->gf_overspend_bits;
626 if (Adjustment > (cpi->this_frame_target - min_frame_target)) {
627 Adjustment = (cpi->this_frame_target - min_frame_target);
630 cpi->gf_overspend_bits -= Adjustment;
631 cpi->this_frame_target -= Adjustment;
634 /* Apply small + and - boosts for non gf frames */
635 if ((cpi->last_boost > 150) && (cpi->frames_till_gf_update_due > 0) &&
636 (cpi->current_gf_interval >= (MIN_GF_INTERVAL << 1))) {
637 /* % Adjustment limited to the range 1% to 10% */
638 Adjustment = (cpi->last_boost - 100) >> 5;
640 if (Adjustment < 1) {
642 } else if (Adjustment > 10) {
646 /* Convert to bits */
647 Adjustment = (cpi->this_frame_target * Adjustment) / 100;
649 if (Adjustment > (cpi->this_frame_target - min_frame_target)) {
650 Adjustment = (cpi->this_frame_target - min_frame_target);
653 if (cpi->frames_since_golden == (cpi->current_gf_interval >> 1)) {
654 Adjustment = (cpi->current_gf_interval - 1) * Adjustment;
655 // Limit adjustment to 10% of current target.
656 if (Adjustment > (10 * cpi->this_frame_target) / 100) {
657 Adjustment = (10 * cpi->this_frame_target) / 100;
659 cpi->this_frame_target += Adjustment;
661 cpi->this_frame_target -= Adjustment;
667 /* Sanity check that the total sum of adjustments is not above the
668 * maximum allowed That is that having allowed for KF and GF penalties
669 * we have not pushed the current interframe target to low. If the
670 * adjustment we apply here is not capable of recovering all the extra
671 * bits we have spent in the KF or GF then the remainder will have to
672 * be recovered over a longer time span via other buffer / rate control
675 if (cpi->this_frame_target < min_frame_target) {
676 cpi->this_frame_target = min_frame_target;
679 if (!cpi->common.refresh_alt_ref_frame) {
680 /* Note the baseline target data rate for this inter frame. */
681 cpi->inter_frame_target = cpi->this_frame_target;
684 /* One Pass specific code */
685 if (cpi->pass == 0) {
686 /* Adapt target frame size with respect to any buffering constraints: */
687 if (cpi->buffered_mode) {
688 int one_percent_bits = (int)(1 + cpi->oxcf.optimal_buffer_level / 100);
690 if ((cpi->buffer_level < cpi->oxcf.optimal_buffer_level) ||
691 (cpi->bits_off_target < cpi->oxcf.optimal_buffer_level)) {
694 /* Decide whether or not we need to adjust the frame data
697 * If we are are below the optimal buffer fullness level
698 * and adherence to buffering constraints is important to
699 * the end usage then adjust the per frame target.
701 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
702 (cpi->buffer_level < cpi->oxcf.optimal_buffer_level)) {
704 (int)((cpi->oxcf.optimal_buffer_level - cpi->buffer_level) /
707 /* Are we overshooting the long term clip data rate... */
708 else if (cpi->bits_off_target < 0) {
709 /* Adjust per frame data target downwards to compensate. */
711 (int)(100 * -cpi->bits_off_target / (cpi->total_byte_count * 8));
714 if (percent_low > cpi->oxcf.under_shoot_pct) {
715 percent_low = cpi->oxcf.under_shoot_pct;
716 } else if (percent_low < 0) {
720 /* lower the target bandwidth for this frame. */
721 cpi->this_frame_target -= (cpi->this_frame_target * percent_low) / 200;
723 /* Are we using allowing control of active_worst_allowed_q
724 * according to buffer level.
726 if (cpi->auto_worst_q && cpi->ni_frames > 150) {
727 int64_t critical_buffer_level;
729 /* For streaming applications the most important factor is
730 * cpi->buffer_level as this takes into account the
731 * specified short term buffering constraints. However,
732 * hitting the long term clip data rate target is also
735 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
736 /* Take the smaller of cpi->buffer_level and
737 * cpi->bits_off_target
739 critical_buffer_level = (cpi->buffer_level < cpi->bits_off_target)
741 : cpi->bits_off_target;
743 /* For local file playback short term buffering constraints
744 * are less of an issue
747 /* Consider only how we are doing for the clip as a
750 critical_buffer_level = cpi->bits_off_target;
753 /* Set the active worst quality based upon the selected
754 * buffer fullness number.
756 if (critical_buffer_level < cpi->oxcf.optimal_buffer_level) {
757 if (critical_buffer_level > (cpi->oxcf.optimal_buffer_level >> 2)) {
758 int64_t qadjustment_range = cpi->worst_quality - cpi->ni_av_qi;
759 int64_t above_base = (critical_buffer_level -
760 (cpi->oxcf.optimal_buffer_level >> 2));
762 /* Step active worst quality down from
763 * cpi->ni_av_qi when (critical_buffer_level ==
764 * cpi->optimal_buffer_level) to
765 * cpi->worst_quality when
766 * (critical_buffer_level ==
767 * cpi->optimal_buffer_level >> 2)
769 cpi->active_worst_quality =
771 (int)((qadjustment_range * above_base) /
772 (cpi->oxcf.optimal_buffer_level * 3 >> 2));
774 cpi->active_worst_quality = cpi->worst_quality;
777 cpi->active_worst_quality = cpi->ni_av_qi;
780 cpi->active_worst_quality = cpi->worst_quality;
783 int percent_high = 0;
785 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
786 (cpi->buffer_level > cpi->oxcf.optimal_buffer_level)) {
788 (int)((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) /
790 } else if (cpi->bits_off_target > cpi->oxcf.optimal_buffer_level) {
792 (int)((100 * cpi->bits_off_target) / (cpi->total_byte_count * 8));
795 if (percent_high > cpi->oxcf.over_shoot_pct) {
796 percent_high = cpi->oxcf.over_shoot_pct;
797 } else if (percent_high < 0) {
801 cpi->this_frame_target += (cpi->this_frame_target * percent_high) / 200;
803 /* Are we allowing control of active_worst_allowed_q according
806 if (cpi->auto_worst_q && cpi->ni_frames > 150) {
807 /* When using the relaxed buffer model stick to the
808 * user specified value
810 cpi->active_worst_quality = cpi->ni_av_qi;
812 cpi->active_worst_quality = cpi->worst_quality;
816 /* Set active_best_quality to prevent quality rising too high */
817 cpi->active_best_quality = cpi->best_quality;
819 /* Worst quality obviously must not be better than best quality */
820 if (cpi->active_worst_quality <= cpi->active_best_quality) {
821 cpi->active_worst_quality = cpi->active_best_quality + 1;
824 if (cpi->active_worst_quality > 127) cpi->active_worst_quality = 127;
826 /* Unbuffered mode (eg. video conferencing) */
828 /* Set the active worst quality */
829 cpi->active_worst_quality = cpi->worst_quality;
832 /* Special trap for constrained quality mode
833 * "active_worst_quality" may never drop below cq level
834 * for any frame type.
836 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY &&
837 cpi->active_worst_quality < cpi->cq_target_quality) {
838 cpi->active_worst_quality = cpi->cq_target_quality;
842 /* Test to see if we have to drop a frame
843 * The auto-drop frame code is only used in buffered mode.
844 * In unbufferd mode (eg vide conferencing) the descision to
845 * code or drop a frame is made outside the codec in response to real
846 * world comms or buffer considerations.
848 if (cpi->drop_frames_allowed &&
849 (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
850 ((cpi->common.frame_type != KEY_FRAME))) {
851 /* Check for a buffer underun-crisis in which case we have to drop
854 if ((cpi->buffer_level < 0)) {
856 FILE *f = fopen("dec.stt", "a");
857 fprintf(f, "%10d %10d %10d %10d ***** BUFFER EMPTY\n",
858 (int) cpi->common.current_video_frame,
859 cpi->decimation_factor, cpi->common.horiz_scale,
860 (cpi->buffer_level * 100) / cpi->oxcf.optimal_buffer_level);
865 /* Update the buffer level variable. */
866 cpi->bits_off_target += cpi->av_per_frame_bandwidth;
867 if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size) {
868 cpi->bits_off_target = (int)cpi->oxcf.maximum_buffer_size;
870 cpi->buffer_level = cpi->bits_off_target;
872 if (cpi->oxcf.number_of_layers > 1) {
875 // Propagate bits saved by dropping the frame to higher layers.
876 for (i = cpi->current_layer + 1; i < cpi->oxcf.number_of_layers; ++i) {
877 LAYER_CONTEXT *lc = &cpi->layer_context[i];
878 lc->bits_off_target += (int)(lc->target_bandwidth / lc->framerate);
879 if (lc->bits_off_target > lc->maximum_buffer_size) {
880 lc->bits_off_target = lc->maximum_buffer_size;
882 lc->buffer_level = lc->bits_off_target;
888 /* Adjust target frame size for Golden Frames: */
889 if (cpi->oxcf.error_resilient_mode == 0 &&
890 (cpi->frames_till_gf_update_due == 0) && !cpi->drop_frame) {
891 if (!cpi->gf_update_onepass_cbr) {
892 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME]
895 int gf_frame_useage = 0; /* Golden frame useage since last GF */
896 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
897 cpi->recent_ref_frame_usage[LAST_FRAME] +
898 cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
899 cpi->recent_ref_frame_usage[ALTREF_FRAME];
901 int pct_gf_active = (100 * cpi->gf_active_count) /
902 (cpi->common.mb_rows * cpi->common.mb_cols);
905 gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
906 cpi->recent_ref_frame_usage[ALTREF_FRAME]) *
910 if (pct_gf_active > gf_frame_useage) gf_frame_useage = pct_gf_active;
912 /* Is a fixed manual GF frequency being used */
913 if (cpi->auto_gold) {
914 /* For one pass throw a GF if recent frame intra useage is
915 * low or the GF useage is high
917 if ((cpi->pass == 0) &&
918 (cpi->this_frame_percent_intra < 15 || gf_frame_useage >= 5)) {
919 cpi->common.refresh_golden_frame = 1;
921 /* Two pass GF descision */
922 } else if (cpi->pass == 2) {
923 cpi->common.refresh_golden_frame = 1;
933 f = fopen("gf_useaget.stt", "a");
934 fprintf(f, " %8ld %10ld %10ld %10ld %10ld\n",
935 cpi->common.current_video_frame, cpi->gfu_boost,
936 GFQ_ADJUSTMENT, cpi->gfu_boost, gf_frame_useage);
942 if (cpi->common.refresh_golden_frame == 1) {
948 f = fopen("GFexit.stt", "a");
949 fprintf(f, "%8ld GF coded\n", cpi->common.current_video_frame);
955 if (cpi->auto_adjust_gold_quantizer) {
959 /* If we are using alternate ref instead of gf then do not apply the
960 * boost It will instead be applied to the altref update Jims
963 if (!cpi->source_alt_ref_active) {
964 if (cpi->oxcf.fixed_q < 0) {
965 if (cpi->pass == 2) {
966 /* The spend on the GF is defined in the two pass
967 * code for two pass encodes
969 cpi->this_frame_target = cpi->per_frame_bandwidth;
971 int Boost = cpi->last_boost;
972 int frames_in_section = cpi->frames_till_gf_update_due + 1;
973 int allocation_chunks = (frames_in_section * 100) + (Boost - 100);
974 int bits_in_section = cpi->inter_frame_target * frames_in_section;
976 /* Normalize Altboost and allocations chunck down to
979 while (Boost > 1000) {
981 allocation_chunks /= 2;
984 /* Avoid loss of precision but avoid overflow */
985 if ((bits_in_section >> 7) > allocation_chunks) {
986 cpi->this_frame_target =
987 Boost * (bits_in_section / allocation_chunks);
989 cpi->this_frame_target =
990 (Boost * bits_in_section) / allocation_chunks;
994 cpi->this_frame_target =
995 (estimate_bits_at_q(1, Q, cpi->common.MBs, 1.0) *
1000 /* If there is an active ARF at this location use the minimum
1001 * bits on this frame even if it is a contructed arf.
1002 * The active maximum quantizer insures that an appropriate
1003 * number of bits will be spent if needed for contstructed ARFs.
1005 cpi->this_frame_target = 0;
1008 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
1011 // Special case for 1 pass CBR: fixed gf period.
1012 // TODO(marpan): Adjust this boost/interval logic.
1013 // If gf_cbr_boost_pct is small (below threshold) set the flag
1014 // gf_noboost_onepass_cbr = 1, which forces the gf to use the same
1015 // rate correction factor as last.
1016 cpi->gf_noboost_onepass_cbr = (cpi->oxcf.gf_cbr_boost_pct <= 100);
1017 cpi->baseline_gf_interval = cpi->gf_interval_onepass_cbr;
1018 // Skip this update if the zero_mvcount is low.
1019 if (cpi->zeromv_count > (cpi->common.MBs >> 1)) {
1020 cpi->common.refresh_golden_frame = 1;
1021 cpi->this_frame_target =
1022 (cpi->this_frame_target * (100 + cpi->oxcf.gf_cbr_boost_pct)) / 100;
1024 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
1025 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
1029 cpi->per_frame_bandwidth = old_per_frame_bandwidth;
1032 void vp8_update_rate_correction_factors(VP8_COMP *cpi, int damp_var) {
1033 int Q = cpi->common.base_qindex;
1034 int correction_factor = 100;
1035 double rate_correction_factor;
1036 double adjustment_limit;
1038 int projected_size_based_on_q = 0;
1040 /* Clear down mmx registers to allow floating point in what follows */
1041 vpx_clear_system_state();
1043 if (cpi->common.frame_type == KEY_FRAME) {
1044 rate_correction_factor = cpi->key_frame_rate_correction_factor;
1046 if (cpi->oxcf.number_of_layers == 1 && !cpi->gf_noboost_onepass_cbr &&
1047 (cpi->common.refresh_alt_ref_frame ||
1048 cpi->common.refresh_golden_frame)) {
1049 rate_correction_factor = cpi->gf_rate_correction_factor;
1051 rate_correction_factor = cpi->rate_correction_factor;
1055 /* Work out how big we would have expected the frame to be at this Q
1056 * given the current correction factor. Stay in double to avoid int
1057 * overflow when values are large
1059 projected_size_based_on_q =
1060 (int)(((.5 + rate_correction_factor *
1061 vp8_bits_per_mb[cpi->common.frame_type][Q]) *
1063 (1 << BPER_MB_NORMBITS));
1065 /* Make some allowance for cpi->zbin_over_quant */
1066 if (cpi->mb.zbin_over_quant > 0) {
1067 int Z = cpi->mb.zbin_over_quant;
1068 double Factor = 0.99;
1069 double factor_adjustment = 0.01 / 256.0;
1073 projected_size_based_on_q = (int)(Factor * projected_size_based_on_q);
1074 Factor += factor_adjustment;
1076 if (Factor >= 0.999) Factor = 0.999;
1080 /* Work out a size correction factor. */
1081 if (projected_size_based_on_q > 0) {
1082 correction_factor = (int)((100 * (int64_t)cpi->projected_frame_size) /
1083 projected_size_based_on_q);
1086 /* More heavily damped adjustment used if we have been oscillating
1087 * either side of target
1090 case 0: adjustment_limit = 0.75; break;
1091 case 1: adjustment_limit = 0.375; break;
1093 default: adjustment_limit = 0.25; break;
1096 if (correction_factor > 102) {
1097 /* We are not already at the worst allowable quality */
1099 (int)(100.5 + ((correction_factor - 100) * adjustment_limit));
1100 rate_correction_factor =
1101 ((rate_correction_factor * correction_factor) / 100);
1103 /* Keep rate_correction_factor within limits */
1104 if (rate_correction_factor > MAX_BPB_FACTOR) {
1105 rate_correction_factor = MAX_BPB_FACTOR;
1107 } else if (correction_factor < 99) {
1108 /* We are not already at the best allowable quality */
1110 (int)(100.5 - ((100 - correction_factor) * adjustment_limit));
1111 rate_correction_factor =
1112 ((rate_correction_factor * correction_factor) / 100);
1114 /* Keep rate_correction_factor within limits */
1115 if (rate_correction_factor < MIN_BPB_FACTOR) {
1116 rate_correction_factor = MIN_BPB_FACTOR;
1120 if (cpi->common.frame_type == KEY_FRAME) {
1121 cpi->key_frame_rate_correction_factor = rate_correction_factor;
1123 if (cpi->oxcf.number_of_layers == 1 && !cpi->gf_noboost_onepass_cbr &&
1124 (cpi->common.refresh_alt_ref_frame ||
1125 cpi->common.refresh_golden_frame)) {
1126 cpi->gf_rate_correction_factor = rate_correction_factor;
1128 cpi->rate_correction_factor = rate_correction_factor;
1133 static int limit_q_cbr_inter(int last_q, int current_q) {
1134 int limit_down = 12;
1135 if (last_q - current_q > limit_down)
1136 return (last_q - limit_down);
1141 int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame) {
1142 int Q = cpi->active_worst_quality;
1144 if (cpi->force_maxqp == 1) {
1145 cpi->active_worst_quality = cpi->worst_quality;
1146 return cpi->worst_quality;
1148 /* Reset Zbin OQ value */
1149 cpi->mb.zbin_over_quant = 0;
1151 if (cpi->oxcf.fixed_q >= 0) {
1152 Q = cpi->oxcf.fixed_q;
1154 if (cpi->common.frame_type == KEY_FRAME) {
1155 Q = cpi->oxcf.key_q;
1156 } else if (cpi->oxcf.number_of_layers == 1 &&
1157 cpi->common.refresh_alt_ref_frame &&
1158 !cpi->gf_noboost_onepass_cbr) {
1159 Q = cpi->oxcf.alt_q;
1160 } else if (cpi->oxcf.number_of_layers == 1 &&
1161 cpi->common.refresh_golden_frame &&
1162 !cpi->gf_noboost_onepass_cbr) {
1163 Q = cpi->oxcf.gold_q;
1167 int last_error = INT_MAX;
1168 int target_bits_per_mb;
1169 int bits_per_mb_at_this_q;
1170 double correction_factor;
1172 /* Select the appropriate correction factor based upon type of frame. */
1173 if (cpi->common.frame_type == KEY_FRAME) {
1174 correction_factor = cpi->key_frame_rate_correction_factor;
1176 if (cpi->oxcf.number_of_layers == 1 && !cpi->gf_noboost_onepass_cbr &&
1177 (cpi->common.refresh_alt_ref_frame ||
1178 cpi->common.refresh_golden_frame)) {
1179 correction_factor = cpi->gf_rate_correction_factor;
1181 correction_factor = cpi->rate_correction_factor;
1185 /* Calculate required scaling factor based on target frame size and
1186 * size of frame produced using previous Q
1188 if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS)) {
1189 /* Case where we would overflow int */
1190 target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs)
1191 << BPER_MB_NORMBITS;
1193 target_bits_per_mb =
1194 (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
1197 i = cpi->active_best_quality;
1200 bits_per_mb_at_this_q =
1202 correction_factor * vp8_bits_per_mb[cpi->common.frame_type][i]);
1204 if (bits_per_mb_at_this_q <= target_bits_per_mb) {
1205 if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error) {
1213 last_error = bits_per_mb_at_this_q - target_bits_per_mb;
1215 } while (++i <= cpi->active_worst_quality);
1217 /* If we are at MAXQ then enable Q over-run which seeks to claw
1218 * back additional bits through things like the RD multiplier
1219 * and zero bin size.
1224 double Factor = 0.99;
1225 double factor_adjustment = 0.01 / 256.0;
1227 if (cpi->common.frame_type == KEY_FRAME) {
1229 } else if (cpi->oxcf.number_of_layers == 1 &&
1230 !cpi->gf_noboost_onepass_cbr &&
1231 (cpi->common.refresh_alt_ref_frame ||
1232 (cpi->common.refresh_golden_frame &&
1233 !cpi->source_alt_ref_active))) {
1236 zbin_oqmax = ZBIN_OQ_MAX;
1241 (double)target_bits_per_mb/(double)bits_per_mb_at_this_q;
1244 Factor = Factor/1.2683;
1246 Oq = pow( Factor, (1.0/-0.165) );
1248 if ( Oq > zbin_oqmax )
1251 cpi->zbin_over_quant = (int)Oq;
1254 /* Each incrment in the zbin is assumed to have a fixed effect
1255 * on bitrate. This is not of course true. The effect will be
1256 * highly clip dependent and may well have sudden steps. The
1257 * idea here is to acheive higher effective quantizers than the
1258 * normal maximum by expanding the zero bin and hence
1259 * decreasing the number of low magnitude non zero coefficients.
1261 while (cpi->mb.zbin_over_quant < zbin_oqmax) {
1262 cpi->mb.zbin_over_quant++;
1264 if (cpi->mb.zbin_over_quant > zbin_oqmax) {
1265 cpi->mb.zbin_over_quant = zbin_oqmax;
1268 /* Adjust bits_per_mb_at_this_q estimate */
1269 bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q);
1270 Factor += factor_adjustment;
1272 if (Factor >= 0.999) Factor = 0.999;
1274 /* Break out if we get down to the target rate */
1275 if (bits_per_mb_at_this_q <= target_bits_per_mb) break;
1280 // Limit decrease in Q for 1 pass CBR screen content mode.
1281 if (cpi->common.frame_type != KEY_FRAME && cpi->pass == 0 &&
1282 cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER &&
1283 cpi->oxcf.screen_content_mode)
1284 Q = limit_q_cbr_inter(cpi->last_q[1], Q);
1289 static int estimate_keyframe_frequency(VP8_COMP *cpi) {
1292 /* Average key frame frequency */
1293 int av_key_frame_frequency = 0;
1295 /* First key frame at start of sequence is a special case. We have no
1298 if (cpi->key_frame_count == 1) {
1299 /* Assume a default of 1 kf every 2 seconds, or the max kf interval,
1300 * whichever is smaller.
1302 int key_freq = cpi->oxcf.key_freq > 0 ? cpi->oxcf.key_freq : 1;
1303 av_key_frame_frequency = 1 + (int)cpi->output_framerate * 2;
1305 if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq) {
1306 av_key_frame_frequency = key_freq;
1309 cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1] =
1310 av_key_frame_frequency;
1312 unsigned int total_weight = 0;
1313 int last_kf_interval =
1314 (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;
1316 /* reset keyframe context and calculate weighted average of last
1317 * KEY_FRAME_CONTEXT keyframes
1319 for (i = 0; i < KEY_FRAME_CONTEXT; ++i) {
1320 if (i < KEY_FRAME_CONTEXT - 1) {
1321 cpi->prior_key_frame_distance[i] = cpi->prior_key_frame_distance[i + 1];
1323 cpi->prior_key_frame_distance[i] = last_kf_interval;
1326 av_key_frame_frequency +=
1327 prior_key_frame_weight[i] * cpi->prior_key_frame_distance[i];
1328 total_weight += prior_key_frame_weight[i];
1331 av_key_frame_frequency /= total_weight;
1333 // TODO (marpan): Given the checks above, |av_key_frame_frequency|
1334 // should always be above 0. But for now we keep the sanity check in.
1335 if (av_key_frame_frequency == 0) av_key_frame_frequency = 1;
1336 return av_key_frame_frequency;
1339 void vp8_adjust_key_frame_context(VP8_COMP *cpi) {
1340 /* Clear down mmx registers to allow floating point in what follows */
1341 vpx_clear_system_state();
1343 /* Do we have any key frame overspend to recover? */
1344 /* Two-pass overspend handled elsewhere. */
1345 if ((cpi->pass != 2) &&
1346 (cpi->projected_frame_size > cpi->per_frame_bandwidth)) {
1349 /* Update the count of key frame overspend to be recovered in
1350 * subsequent frames. A portion of the KF overspend is treated as gf
1351 * overspend (and hence recovered more quickly) as the kf is also a
1352 * gf. Otherwise the few frames following each kf tend to get more
1353 * bits allocated than those following other gfs.
1355 overspend = (cpi->projected_frame_size - cpi->per_frame_bandwidth);
1357 if (cpi->oxcf.number_of_layers > 1) {
1358 cpi->kf_overspend_bits += overspend;
1360 cpi->kf_overspend_bits += overspend * 7 / 8;
1361 cpi->gf_overspend_bits += overspend * 1 / 8;
1364 /* Work out how much to try and recover per frame. */
1365 cpi->kf_bitrate_adjustment =
1366 cpi->kf_overspend_bits / estimate_keyframe_frequency(cpi);
1369 cpi->frames_since_key = 0;
1370 cpi->key_frame_count++;
1373 void vp8_compute_frame_size_bounds(VP8_COMP *cpi, int *frame_under_shoot_limit,
1374 int *frame_over_shoot_limit) {
1375 /* Set-up bounds on acceptable frame size: */
1376 if (cpi->oxcf.fixed_q >= 0) {
1377 /* Fixed Q scenario: frame size never outranges target
1378 * (there is no target!)
1380 *frame_under_shoot_limit = 0;
1381 *frame_over_shoot_limit = INT_MAX;
1383 const int64_t this_frame_target = cpi->this_frame_target;
1384 int64_t over_shoot_limit, under_shoot_limit;
1386 if (cpi->common.frame_type == KEY_FRAME) {
1387 over_shoot_limit = this_frame_target * 9 / 8;
1388 under_shoot_limit = this_frame_target * 7 / 8;
1390 if (cpi->oxcf.number_of_layers > 1 || cpi->common.refresh_alt_ref_frame ||
1391 cpi->common.refresh_golden_frame) {
1392 over_shoot_limit = this_frame_target * 9 / 8;
1393 under_shoot_limit = this_frame_target * 7 / 8;
1395 /* For CBR take buffer fullness into account */
1396 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
1397 if (cpi->buffer_level >= ((cpi->oxcf.optimal_buffer_level +
1398 cpi->oxcf.maximum_buffer_size) >>
1400 /* Buffer is too full so relax overshoot and tighten
1403 over_shoot_limit = this_frame_target * 12 / 8;
1404 under_shoot_limit = this_frame_target * 6 / 8;
1405 } else if (cpi->buffer_level <=
1406 (cpi->oxcf.optimal_buffer_level >> 1)) {
1407 /* Buffer is too low so relax undershoot and tighten
1410 over_shoot_limit = this_frame_target * 10 / 8;
1411 under_shoot_limit = this_frame_target * 4 / 8;
1413 over_shoot_limit = this_frame_target * 11 / 8;
1414 under_shoot_limit = this_frame_target * 5 / 8;
1417 /* VBR and CQ mode */
1418 /* Note that tighter restrictions here can help quality
1419 * but hurt encode speed
1422 /* Stron overshoot limit for constrained quality */
1423 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
1424 over_shoot_limit = this_frame_target * 11 / 8;
1425 under_shoot_limit = this_frame_target * 2 / 8;
1427 over_shoot_limit = this_frame_target * 11 / 8;
1428 under_shoot_limit = this_frame_target * 5 / 8;
1434 /* For very small rate targets where the fractional adjustment
1435 * (eg * 7/8) may be tiny make sure there is at least a minimum
1438 over_shoot_limit += 200;
1439 under_shoot_limit -= 200;
1440 if (under_shoot_limit < 0) under_shoot_limit = 0;
1441 if (under_shoot_limit > INT_MAX) under_shoot_limit = INT_MAX;
1442 if (over_shoot_limit > INT_MAX) over_shoot_limit = INT_MAX;
1443 *frame_under_shoot_limit = (int)under_shoot_limit;
1444 *frame_over_shoot_limit = (int)over_shoot_limit;
1448 /* return of 0 means drop frame */
1449 int vp8_pick_frame_size(VP8_COMP *cpi) {
1450 VP8_COMMON *cm = &cpi->common;
1452 if (cm->frame_type == KEY_FRAME) {
1453 calc_iframe_target_size(cpi);
1455 calc_pframe_target_size(cpi);
1457 /* Check if we're dropping the frame: */
1458 if (cpi->drop_frame) {
1459 cpi->drop_frame = 0;
1465 // If this just encoded frame (mcomp/transform/quant, but before loopfilter and
1466 // pack_bitstream) has large overshoot, and was not being encoded close to the
1467 // max QP, then drop this frame and force next frame to be encoded at max QP.
1468 // Allow this for screen_content_mode = 2, or if drop frames is allowed.
1469 // TODO(marpan): Should do this exit condition during the encode_frame
1470 // (i.e., halfway during the encoding of the frame) to save cycles.
1471 int vp8_drop_encodedframe_overshoot(VP8_COMP *cpi, int Q) {
1472 int force_drop_overshoot = 0;
1473 #if CONFIG_MULTI_RES_ENCODING
1474 // Only check for dropping due to overshoot on the lowest stream.
1475 // If the lowest stream of the multi-res encoding was dropped due to
1476 // overshoot, then force dropping on all upper layer streams
1477 // (mr_encoder_id > 0).
1478 LOWER_RES_FRAME_INFO *low_res_frame_info =
1479 (LOWER_RES_FRAME_INFO *)cpi->oxcf.mr_low_res_mode_info;
1480 if (cpi->oxcf.mr_total_resolutions > 1 && cpi->oxcf.mr_encoder_id > 0) {
1481 force_drop_overshoot = low_res_frame_info->is_frame_dropped_overshoot_maxqp;
1482 if (!force_drop_overshoot) {
1483 cpi->force_maxqp = 0;
1484 cpi->frames_since_last_drop_overshoot++;
1489 if (cpi->common.frame_type != KEY_FRAME &&
1490 (cpi->oxcf.screen_content_mode == 2 ||
1491 (cpi->drop_frames_allowed &&
1492 (force_drop_overshoot ||
1493 (cpi->rate_correction_factor < (8.0f * MIN_BPB_FACTOR) &&
1494 cpi->frames_since_last_drop_overshoot > (int)cpi->framerate))))) {
1495 // Note: the "projected_frame_size" from encode_frame() only gives estimate
1496 // of mode/motion vector rate (in non-rd mode): so below we only require
1497 // that projected_frame_size is somewhat greater than per-frame-bandwidth,
1498 // but add additional condition with high threshold on prediction residual.
1500 // QP threshold: only allow dropping if we are not close to qp_max.
1501 int thresh_qp = 3 * cpi->worst_quality >> 2;
1502 // Rate threshold, in bytes.
1503 int thresh_rate = 2 * (cpi->av_per_frame_bandwidth >> 3);
1504 // Threshold for the average (over all macroblocks) of the pixel-sum
1505 // residual error over 16x16 block.
1506 int thresh_pred_err_mb = (200 << 4);
1507 int pred_err_mb = (int)(cpi->mb.prediction_error / cpi->common.MBs);
1508 // Reduce/ignore thresh_rate if pred_err_mb much larger than its threshold,
1509 // give more weight to pred_err metric for overshoot detection.
1510 if (cpi->drop_frames_allowed && pred_err_mb > (thresh_pred_err_mb << 4))
1511 thresh_rate = thresh_rate >> 3;
1512 if ((Q < thresh_qp && cpi->projected_frame_size > thresh_rate &&
1513 pred_err_mb > thresh_pred_err_mb &&
1514 pred_err_mb > 2 * cpi->last_pred_err_mb) ||
1515 force_drop_overshoot) {
1517 double new_correction_factor;
1518 int target_bits_per_mb;
1519 const int target_size = cpi->av_per_frame_bandwidth;
1520 // Flag to indicate we will force next frame to be encoded at max QP.
1521 cpi->force_maxqp = 1;
1522 // Reset the buffer levels.
1523 cpi->buffer_level = cpi->oxcf.optimal_buffer_level;
1524 cpi->bits_off_target = cpi->oxcf.optimal_buffer_level;
1525 // Compute a new rate correction factor, corresponding to the current
1526 // target frame size and max_QP, and adjust the rate correction factor
1527 // upwards, if needed.
1528 // This is to prevent a bad state where the re-encoded frame at max_QP
1529 // undershoots significantly, and then we end up dropping every other
1530 // frame because the QP/rate_correction_factor may have been too low
1531 // before the drop and then takes too long to come up.
1532 if (target_size >= (INT_MAX >> BPER_MB_NORMBITS)) {
1533 target_bits_per_mb = (target_size / cpi->common.MBs)
1534 << BPER_MB_NORMBITS;
1536 target_bits_per_mb =
1537 (target_size << BPER_MB_NORMBITS) / cpi->common.MBs;
1539 // Rate correction factor based on target_size_per_mb and max_QP.
1540 new_correction_factor =
1541 (double)target_bits_per_mb /
1542 (double)vp8_bits_per_mb[INTER_FRAME][cpi->worst_quality];
1543 if (new_correction_factor > cpi->rate_correction_factor) {
1544 cpi->rate_correction_factor =
1545 VPXMIN(2.0 * cpi->rate_correction_factor, new_correction_factor);
1547 if (cpi->rate_correction_factor > MAX_BPB_FACTOR) {
1548 cpi->rate_correction_factor = MAX_BPB_FACTOR;
1550 // Drop this frame: update frame counters.
1551 cpi->common.current_video_frame++;
1552 cpi->frames_since_key++;
1553 cpi->temporal_pattern_counter++;
1554 cpi->frames_since_last_drop_overshoot = 0;
1555 if (cpi->oxcf.number_of_layers > 1) {
1556 // Set max_qp and rate correction for all temporal layers if overshoot
1558 for (i = 0; i < cpi->oxcf.number_of_layers; ++i) {
1559 LAYER_CONTEXT *lc = &cpi->layer_context[i];
1560 lc->force_maxqp = 1;
1561 lc->frames_since_last_drop_overshoot = 0;
1562 lc->rate_correction_factor = cpi->rate_correction_factor;
1565 #if CONFIG_MULTI_RES_ENCODING
1566 if (cpi->oxcf.mr_total_resolutions > 1)
1567 low_res_frame_info->is_frame_dropped_overshoot_maxqp = 1;
1571 cpi->force_maxqp = 0;
1572 cpi->frames_since_last_drop_overshoot++;
1573 #if CONFIG_MULTI_RES_ENCODING
1574 if (cpi->oxcf.mr_total_resolutions > 1)
1575 low_res_frame_info->is_frame_dropped_overshoot_maxqp = 0;
1579 cpi->force_maxqp = 0;
1580 cpi->frames_since_last_drop_overshoot++;
1581 #if CONFIG_MULTI_RES_ENCODING
1582 if (cpi->oxcf.mr_total_resolutions > 1)
1583 low_res_frame_info->is_frame_dropped_overshoot_maxqp = 0;