media/libvpx/vp8/encoder/ratectrl.c@b8a032363ba2
media/libvpx/vp8/encoder/ratectrl.c
Thu, 22 Jan 2015 13:21:57 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Thu, 22 Jan 2015 13:21:57 +0100
- branch
- TOR_BUG_9701
- changeset 15
- b8a032363ba2
- permissions
- -rw-r--r--
Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6
1 /*
2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
3 *
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.
9 */
12 #include <stdlib.h>
13 #include <stdio.h>
14 #include <string.h>
15 #include <limits.h>
16 #include <assert.h>
18 #include "math.h"
19 #include "vp8/common/common.h"
20 #include "ratectrl.h"
21 #include "vp8/common/entropymode.h"
22 #include "vpx_mem/vpx_mem.h"
23 #include "vp8/common/systemdependent.h"
24 #include "encodemv.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];
34 #ifdef MODE_STATS
35 extern int y_modes[5];
36 extern int uv_modes[4];
37 extern int b_modes[10];
39 extern int inter_y_modes[10];
40 extern int inter_uv_modes[4];
41 extern int inter_b_modes[10];
42 #endif
44 /* Bits Per MB at different Q (Multiplied by 512) */
45 #define BPER_MB_NORMBITS 9
47 /* Work in progress recalibration of baseline rate tables based on
48 * the assumption that bits per mb is inversely proportional to the
49 * quantizer value.
50 */
51 const int vp8_bits_per_mb[2][QINDEX_RANGE] =
52 {
53 /* Intra case 450000/Qintra */
54 {
55 1125000,900000, 750000, 642857, 562500, 500000, 450000, 450000,
56 409090, 375000, 346153, 321428, 300000, 281250, 264705, 264705,
57 250000, 236842, 225000, 225000, 214285, 214285, 204545, 204545,
58 195652, 195652, 187500, 180000, 180000, 173076, 166666, 160714,
59 155172, 150000, 145161, 140625, 136363, 132352, 128571, 125000,
60 121621, 121621, 118421, 115384, 112500, 109756, 107142, 104651,
61 102272, 100000, 97826, 97826, 95744, 93750, 91836, 90000,
62 88235, 86538, 84905, 83333, 81818, 80357, 78947, 77586,
63 76271, 75000, 73770, 72580, 71428, 70312, 69230, 68181,
64 67164, 66176, 65217, 64285, 63380, 62500, 61643, 60810,
65 60000, 59210, 59210, 58441, 57692, 56962, 56250, 55555,
66 54878, 54216, 53571, 52941, 52325, 51724, 51136, 50561,
67 49450, 48387, 47368, 46875, 45918, 45000, 44554, 44117,
68 43269, 42452, 41666, 40909, 40178, 39473, 38793, 38135,
69 36885, 36290, 35714, 35156, 34615, 34090, 33582, 33088,
70 32608, 32142, 31468, 31034, 30405, 29801, 29220, 28662,
71 },
72 /* Inter case 285000/Qinter */
73 {
74 712500, 570000, 475000, 407142, 356250, 316666, 285000, 259090,
75 237500, 219230, 203571, 190000, 178125, 167647, 158333, 150000,
76 142500, 135714, 129545, 123913, 118750, 114000, 109615, 105555,
77 101785, 98275, 95000, 91935, 89062, 86363, 83823, 81428,
78 79166, 77027, 75000, 73076, 71250, 69512, 67857, 66279,
79 64772, 63333, 61956, 60638, 59375, 58163, 57000, 55882,
80 54807, 53773, 52777, 51818, 50892, 50000, 49137, 47500,
81 45967, 44531, 43181, 41911, 40714, 39583, 38513, 37500,
82 36538, 35625, 34756, 33928, 33139, 32386, 31666, 30978,
83 30319, 29687, 29081, 28500, 27941, 27403, 26886, 26388,
84 25909, 25446, 25000, 24568, 23949, 23360, 22800, 22265,
85 21755, 21268, 20802, 20357, 19930, 19520, 19127, 18750,
86 18387, 18037, 17701, 17378, 17065, 16764, 16473, 16101,
87 15745, 15405, 15079, 14766, 14467, 14179, 13902, 13636,
88 13380, 13133, 12895, 12666, 12445, 12179, 11924, 11632,
89 11445, 11220, 11003, 10795, 10594, 10401, 10215, 10035,
90 }
91 };
93 static const int kf_boost_qadjustment[QINDEX_RANGE] =
94 {
95 128, 129, 130, 131, 132, 133, 134, 135,
96 136, 137, 138, 139, 140, 141, 142, 143,
97 144, 145, 146, 147, 148, 149, 150, 151,
98 152, 153, 154, 155, 156, 157, 158, 159,
99 160, 161, 162, 163, 164, 165, 166, 167,
100 168, 169, 170, 171, 172, 173, 174, 175,
101 176, 177, 178, 179, 180, 181, 182, 183,
102 184, 185, 186, 187, 188, 189, 190, 191,
103 192, 193, 194, 195, 196, 197, 198, 199,
104 200, 200, 201, 201, 202, 203, 203, 203,
105 204, 204, 205, 205, 206, 206, 207, 207,
106 208, 208, 209, 209, 210, 210, 211, 211,
107 212, 212, 213, 213, 214, 214, 215, 215,
108 216, 216, 217, 217, 218, 218, 219, 219,
109 220, 220, 220, 220, 220, 220, 220, 220,
110 220, 220, 220, 220, 220, 220, 220, 220,
111 };
113 /* #define GFQ_ADJUSTMENT (Q+100) */
114 #define GFQ_ADJUSTMENT vp8_gf_boost_qadjustment[Q]
115 const int vp8_gf_boost_qadjustment[QINDEX_RANGE] =
116 {
117 80, 82, 84, 86, 88, 90, 92, 94,
118 96, 97, 98, 99, 100, 101, 102, 103,
119 104, 105, 106, 107, 108, 109, 110, 111,
120 112, 113, 114, 115, 116, 117, 118, 119,
121 120, 121, 122, 123, 124, 125, 126, 127,
122 128, 129, 130, 131, 132, 133, 134, 135,
123 136, 137, 138, 139, 140, 141, 142, 143,
124 144, 145, 146, 147, 148, 149, 150, 151,
125 152, 153, 154, 155, 156, 157, 158, 159,
126 160, 161, 162, 163, 164, 165, 166, 167,
127 168, 169, 170, 171, 172, 173, 174, 175,
128 176, 177, 178, 179, 180, 181, 182, 183,
129 184, 184, 185, 185, 186, 186, 187, 187,
130 188, 188, 189, 189, 190, 190, 191, 191,
131 192, 192, 193, 193, 194, 194, 194, 194,
132 195, 195, 196, 196, 197, 197, 198, 198
133 };
135 /*
136 const int vp8_gf_boost_qadjustment[QINDEX_RANGE] =
137 {
138 100,101,102,103,104,105,105,106,
139 106,107,107,108,109,109,110,111,
140 112,113,114,115,116,117,118,119,
141 120,121,122,123,124,125,126,127,
142 128,129,130,131,132,133,134,135,
143 136,137,138,139,140,141,142,143,
144 144,145,146,147,148,149,150,151,
145 152,153,154,155,156,157,158,159,
146 160,161,162,163,164,165,166,167,
147 168,169,170,170,171,171,172,172,
148 173,173,173,174,174,174,175,175,
149 175,176,176,176,177,177,177,177,
150 178,178,179,179,180,180,181,181,
151 182,182,183,183,184,184,185,185,
152 186,186,187,187,188,188,189,189,
153 190,190,191,191,192,192,193,193,
154 };
155 */
157 static const int kf_gf_boost_qlimits[QINDEX_RANGE] =
158 {
159 150, 155, 160, 165, 170, 175, 180, 185,
160 190, 195, 200, 205, 210, 215, 220, 225,
161 230, 235, 240, 245, 250, 255, 260, 265,
162 270, 275, 280, 285, 290, 295, 300, 305,
163 310, 320, 330, 340, 350, 360, 370, 380,
164 390, 400, 410, 420, 430, 440, 450, 460,
165 470, 480, 490, 500, 510, 520, 530, 540,
166 550, 560, 570, 580, 590, 600, 600, 600,
167 600, 600, 600, 600, 600, 600, 600, 600,
168 600, 600, 600, 600, 600, 600, 600, 600,
169 600, 600, 600, 600, 600, 600, 600, 600,
170 600, 600, 600, 600, 600, 600, 600, 600,
171 600, 600, 600, 600, 600, 600, 600, 600,
172 600, 600, 600, 600, 600, 600, 600, 600,
173 600, 600, 600, 600, 600, 600, 600, 600,
174 600, 600, 600, 600, 600, 600, 600, 600,
175 };
177 /* % adjustment to target kf size based on seperation from previous frame */
178 static const int kf_boost_seperation_adjustment[16] =
179 {
180 30, 40, 50, 55, 60, 65, 70, 75,
181 80, 85, 90, 95, 100, 100, 100, 100,
182 };
185 static const int gf_adjust_table[101] =
186 {
187 100,
188 115, 130, 145, 160, 175, 190, 200, 210, 220, 230,
189 240, 260, 270, 280, 290, 300, 310, 320, 330, 340,
190 350, 360, 370, 380, 390, 400, 400, 400, 400, 400,
191 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
192 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
193 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
194 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
195 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
196 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
197 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
198 };
200 static const int gf_intra_usage_adjustment[20] =
201 {
202 125, 120, 115, 110, 105, 100, 95, 85, 80, 75,
203 70, 65, 60, 55, 50, 50, 50, 50, 50, 50,
204 };
206 static const int gf_interval_table[101] =
207 {
208 7,
209 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
210 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
211 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
212 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
213 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
214 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
215 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
216 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
217 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
218 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
219 };
221 static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = { 1, 2, 3, 4, 5 };
224 void vp8_save_coding_context(VP8_COMP *cpi)
225 {
226 CODING_CONTEXT *const cc = & cpi->coding_context;
228 /* Stores a snapshot of key state variables which can subsequently be
229 * restored with a call to vp8_restore_coding_context. These functions are
230 * intended for use in a re-code loop in vp8_compress_frame where the
231 * quantizer value is adjusted between loop iterations.
232 */
234 cc->frames_since_key = cpi->frames_since_key;
235 cc->filter_level = cpi->common.filter_level;
236 cc->frames_till_gf_update_due = cpi->frames_till_gf_update_due;
237 cc->frames_since_golden = cpi->frames_since_golden;
239 vp8_copy(cc->mvc, cpi->common.fc.mvc);
240 vp8_copy(cc->mvcosts, cpi->rd_costs.mvcosts);
242 vp8_copy(cc->ymode_prob, cpi->common.fc.ymode_prob);
243 vp8_copy(cc->uv_mode_prob, cpi->common.fc.uv_mode_prob);
245 vp8_copy(cc->ymode_count, cpi->mb.ymode_count);
246 vp8_copy(cc->uv_mode_count, cpi->mb.uv_mode_count);
249 /* Stats */
250 #ifdef MODE_STATS
251 vp8_copy(cc->y_modes, y_modes);
252 vp8_copy(cc->uv_modes, uv_modes);
253 vp8_copy(cc->b_modes, b_modes);
254 vp8_copy(cc->inter_y_modes, inter_y_modes);
255 vp8_copy(cc->inter_uv_modes, inter_uv_modes);
256 vp8_copy(cc->inter_b_modes, inter_b_modes);
257 #endif
259 cc->this_frame_percent_intra = cpi->this_frame_percent_intra;
260 }
263 void vp8_restore_coding_context(VP8_COMP *cpi)
264 {
265 CODING_CONTEXT *const cc = & cpi->coding_context;
267 /* Restore key state variables to the snapshot state stored in the
268 * previous call to vp8_save_coding_context.
269 */
271 cpi->frames_since_key = cc->frames_since_key;
272 cpi->common.filter_level = cc->filter_level;
273 cpi->frames_till_gf_update_due = cc->frames_till_gf_update_due;
274 cpi->frames_since_golden = cc->frames_since_golden;
276 vp8_copy(cpi->common.fc.mvc, cc->mvc);
278 vp8_copy(cpi->rd_costs.mvcosts, cc->mvcosts);
280 vp8_copy(cpi->common.fc.ymode_prob, cc->ymode_prob);
281 vp8_copy(cpi->common.fc.uv_mode_prob, cc->uv_mode_prob);
283 vp8_copy(cpi->mb.ymode_count, cc->ymode_count);
284 vp8_copy(cpi->mb.uv_mode_count, cc->uv_mode_count);
286 /* Stats */
287 #ifdef MODE_STATS
288 vp8_copy(y_modes, cc->y_modes);
289 vp8_copy(uv_modes, cc->uv_modes);
290 vp8_copy(b_modes, cc->b_modes);
291 vp8_copy(inter_y_modes, cc->inter_y_modes);
292 vp8_copy(inter_uv_modes, cc->inter_uv_modes);
293 vp8_copy(inter_b_modes, cc->inter_b_modes);
294 #endif
297 cpi->this_frame_percent_intra = cc->this_frame_percent_intra;
298 }
301 void vp8_setup_key_frame(VP8_COMP *cpi)
302 {
303 /* Setup for Key frame: */
305 vp8_default_coef_probs(& cpi->common);
307 vpx_memcpy(cpi->common.fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));
308 {
309 int flag[2] = {1, 1};
310 vp8_build_component_cost_table(cpi->mb.mvcost, (const MV_CONTEXT *) cpi->common.fc.mvc, flag);
311 }
313 /* Make sure we initialize separate contexts for altref,gold, and normal.
314 * TODO shouldn't need 3 different copies of structure to do this!
315 */
316 vpx_memcpy(&cpi->lfc_a, &cpi->common.fc, sizeof(cpi->common.fc));
317 vpx_memcpy(&cpi->lfc_g, &cpi->common.fc, sizeof(cpi->common.fc));
318 vpx_memcpy(&cpi->lfc_n, &cpi->common.fc, sizeof(cpi->common.fc));
320 cpi->common.filter_level = cpi->common.base_qindex * 3 / 8 ;
322 /* Provisional interval before next GF */
323 if (cpi->auto_gold)
324 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
325 else
326 cpi->frames_till_gf_update_due = DEFAULT_GF_INTERVAL;
328 cpi->common.refresh_golden_frame = 1;
329 cpi->common.refresh_alt_ref_frame = 1;
330 }
333 static int estimate_bits_at_q(int frame_kind, int Q, int MBs,
334 double correction_factor)
335 {
336 int Bpm = (int)(.5 + correction_factor * vp8_bits_per_mb[frame_kind][Q]);
338 /* Attempt to retain reasonable accuracy without overflow. The cutoff is
339 * chosen such that the maximum product of Bpm and MBs fits 31 bits. The
340 * largest Bpm takes 20 bits.
341 */
342 if (MBs > (1 << 11))
343 return (Bpm >> BPER_MB_NORMBITS) * MBs;
344 else
345 return (Bpm * MBs) >> BPER_MB_NORMBITS;
346 }
349 static void calc_iframe_target_size(VP8_COMP *cpi)
350 {
351 /* boost defaults to half second */
352 int kf_boost;
353 uint64_t target;
355 /* Clear down mmx registers to allow floating point in what follows */
356 vp8_clear_system_state();
358 if (cpi->oxcf.fixed_q >= 0)
359 {
360 int Q = cpi->oxcf.key_q;
362 target = estimate_bits_at_q(INTRA_FRAME, Q, cpi->common.MBs,
363 cpi->key_frame_rate_correction_factor);
364 }
365 else if (cpi->pass == 2)
366 {
367 /* New Two pass RC */
368 target = cpi->per_frame_bandwidth;
369 }
370 /* First Frame is a special case */
371 else if (cpi->common.current_video_frame == 0)
372 {
373 /* 1 Pass there is no information on which to base size so use
374 * bandwidth per second * fraction of the initial buffer
375 * level
376 */
377 target = cpi->oxcf.starting_buffer_level / 2;
379 if(target > cpi->oxcf.target_bandwidth * 3 / 2)
380 target = cpi->oxcf.target_bandwidth * 3 / 2;
381 }
382 else
383 {
384 /* if this keyframe was forced, use a more recent Q estimate */
385 int Q = (cpi->common.frame_flags & FRAMEFLAGS_KEY)
386 ? cpi->avg_frame_qindex : cpi->ni_av_qi;
388 int initial_boost = 32; /* |3.0 * per_frame_bandwidth| */
389 /* Boost depends somewhat on frame rate: only used for 1 layer case. */
390 if (cpi->oxcf.number_of_layers == 1) {
391 kf_boost = MAX(initial_boost, (int)(2 * cpi->output_framerate - 16));
392 }
393 else {
394 /* Initial factor: set target size to: |3.0 * per_frame_bandwidth|. */
395 kf_boost = initial_boost;
396 }
398 /* adjustment up based on q: this factor ranges from ~1.2 to 2.2. */
399 kf_boost = kf_boost * kf_boost_qadjustment[Q] / 100;
401 /* frame separation adjustment ( down) */
402 if (cpi->frames_since_key < cpi->output_framerate / 2)
403 kf_boost = (int)(kf_boost
404 * cpi->frames_since_key / (cpi->output_framerate / 2));
406 /* Minimal target size is |2* per_frame_bandwidth|. */
407 if (kf_boost < 16)
408 kf_boost = 16;
410 target = ((16 + kf_boost) * cpi->per_frame_bandwidth) >> 4;
411 }
414 if (cpi->oxcf.rc_max_intra_bitrate_pct)
415 {
416 unsigned int max_rate = cpi->per_frame_bandwidth
417 * cpi->oxcf.rc_max_intra_bitrate_pct / 100;
419 if (target > max_rate)
420 target = max_rate;
421 }
423 cpi->this_frame_target = (int)target;
425 /* TODO: if we separate rate targeting from Q targetting, move this.
426 * Reset the active worst quality to the baseline value for key frames.
427 */
428 if (cpi->pass != 2)
429 cpi->active_worst_quality = cpi->worst_quality;
431 #if 0
432 {
433 FILE *f;
435 f = fopen("kf_boost.stt", "a");
436 fprintf(f, " %8u %10d %10d %10d\n",
437 cpi->common.current_video_frame, cpi->gfu_boost, cpi->baseline_gf_interval, cpi->source_alt_ref_pending);
439 fclose(f);
440 }
441 #endif
442 }
445 /* Do the best we can to define the parameters for the next GF based on what
446 * information we have available.
447 */
448 static void calc_gf_params(VP8_COMP *cpi)
449 {
450 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
451 int Boost = 0;
453 int gf_frame_useage = 0; /* Golden frame useage since last GF */
454 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
455 cpi->recent_ref_frame_usage[LAST_FRAME] +
456 cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
457 cpi->recent_ref_frame_usage[ALTREF_FRAME];
459 int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols);
461 if (tot_mbs)
462 gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs;
464 if (pct_gf_active > gf_frame_useage)
465 gf_frame_useage = pct_gf_active;
467 /* Not two pass */
468 if (cpi->pass != 2)
469 {
470 /* Single Pass lagged mode: TBD */
471 if (0)
472 {
473 }
475 /* Single Pass compression: Has to use current and historical data */
476 else
477 {
478 #if 0
479 /* Experimental code */
480 int index = cpi->one_pass_frame_index;
481 int frames_to_scan = (cpi->max_gf_interval <= MAX_LAG_BUFFERS) ? cpi->max_gf_interval : MAX_LAG_BUFFERS;
483 /* ************** Experimental code - incomplete */
484 /*
485 double decay_val = 1.0;
486 double IIAccumulator = 0.0;
487 double last_iiaccumulator = 0.0;
488 double IIRatio;
490 cpi->one_pass_frame_index = cpi->common.current_video_frame%MAX_LAG_BUFFERS;
492 for ( i = 0; i < (frames_to_scan - 1); i++ )
493 {
494 if ( index < 0 )
495 index = MAX_LAG_BUFFERS;
496 index --;
498 if ( cpi->one_pass_frame_stats[index].frame_coded_error > 0.0 )
499 {
500 IIRatio = cpi->one_pass_frame_stats[index].frame_intra_error / cpi->one_pass_frame_stats[index].frame_coded_error;
502 if ( IIRatio > 30.0 )
503 IIRatio = 30.0;
504 }
505 else
506 IIRatio = 30.0;
508 IIAccumulator += IIRatio * decay_val;
510 decay_val = decay_val * cpi->one_pass_frame_stats[index].frame_pcnt_inter;
512 if ( (i > MIN_GF_INTERVAL) &&
513 ((IIAccumulator - last_iiaccumulator) < 2.0) )
514 {
515 break;
516 }
517 last_iiaccumulator = IIAccumulator;
518 }
520 Boost = IIAccumulator*100.0/16.0;
521 cpi->baseline_gf_interval = i;
523 */
524 #else
526 /*************************************************************/
527 /* OLD code */
529 /* Adjust boost based upon ambient Q */
530 Boost = GFQ_ADJUSTMENT;
532 /* Adjust based upon most recently measure intra useage */
533 Boost = Boost * gf_intra_usage_adjustment[(cpi->this_frame_percent_intra < 15) ? cpi->this_frame_percent_intra : 14] / 100;
535 /* Adjust gf boost based upon GF usage since last GF */
536 Boost = Boost * gf_adjust_table[gf_frame_useage] / 100;
537 #endif
538 }
540 /* golden frame boost without recode loop often goes awry. be
541 * safe by keeping numbers down.
542 */
543 if (!cpi->sf.recode_loop)
544 {
545 if (cpi->compressor_speed == 2)
546 Boost = Boost / 2;
547 }
549 /* Apply an upper limit based on Q for 1 pass encodes */
550 if (Boost > kf_gf_boost_qlimits[Q] && (cpi->pass == 0))
551 Boost = kf_gf_boost_qlimits[Q];
553 /* Apply lower limits to boost. */
554 else if (Boost < 110)
555 Boost = 110;
557 /* Note the boost used */
558 cpi->last_boost = Boost;
560 }
562 /* Estimate next interval
563 * This is updated once the real frame size/boost is known.
564 */
565 if (cpi->oxcf.fixed_q == -1)
566 {
567 if (cpi->pass == 2) /* 2 Pass */
568 {
569 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
570 }
571 else /* 1 Pass */
572 {
573 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
575 if (cpi->last_boost > 750)
576 cpi->frames_till_gf_update_due++;
578 if (cpi->last_boost > 1000)
579 cpi->frames_till_gf_update_due++;
581 if (cpi->last_boost > 1250)
582 cpi->frames_till_gf_update_due++;
584 if (cpi->last_boost >= 1500)
585 cpi->frames_till_gf_update_due ++;
587 if (gf_interval_table[gf_frame_useage] > cpi->frames_till_gf_update_due)
588 cpi->frames_till_gf_update_due = gf_interval_table[gf_frame_useage];
590 if (cpi->frames_till_gf_update_due > cpi->max_gf_interval)
591 cpi->frames_till_gf_update_due = cpi->max_gf_interval;
592 }
593 }
594 else
595 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
597 /* ARF on or off */
598 if (cpi->pass != 2)
599 {
600 /* For now Alt ref is not allowed except in 2 pass modes. */
601 cpi->source_alt_ref_pending = 0;
603 /*if ( cpi->oxcf.fixed_q == -1)
604 {
605 if ( cpi->oxcf.play_alternate && (cpi->last_boost > (100 + (AF_THRESH*cpi->frames_till_gf_update_due)) ) )
606 cpi->source_alt_ref_pending = 1;
607 else
608 cpi->source_alt_ref_pending = 0;
609 }*/
610 }
611 }
614 static void calc_pframe_target_size(VP8_COMP *cpi)
615 {
616 int min_frame_target;
617 int old_per_frame_bandwidth = cpi->per_frame_bandwidth;
619 if ( cpi->current_layer > 0)
620 cpi->per_frame_bandwidth =
621 cpi->layer_context[cpi->current_layer].avg_frame_size_for_layer;
623 min_frame_target = 0;
625 if (cpi->pass == 2)
626 {
627 min_frame_target = cpi->min_frame_bandwidth;
629 if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5))
630 min_frame_target = cpi->av_per_frame_bandwidth >> 5;
631 }
632 else if (min_frame_target < cpi->per_frame_bandwidth / 4)
633 min_frame_target = cpi->per_frame_bandwidth / 4;
636 /* Special alt reference frame case */
637 if((cpi->common.refresh_alt_ref_frame) && (cpi->oxcf.number_of_layers == 1))
638 {
639 if (cpi->pass == 2)
640 {
641 /* Per frame bit target for the alt ref frame */
642 cpi->per_frame_bandwidth = cpi->twopass.gf_bits;
643 cpi->this_frame_target = cpi->per_frame_bandwidth;
644 }
646 /* One Pass ??? TBD */
647 }
649 /* Normal frames (gf,and inter) */
650 else
651 {
652 /* 2 pass */
653 if (cpi->pass == 2)
654 {
655 cpi->this_frame_target = cpi->per_frame_bandwidth;
656 }
657 /* 1 pass */
658 else
659 {
660 int Adjustment;
661 /* Make rate adjustment to recover bits spent in key frame
662 * Test to see if the key frame inter data rate correction
663 * should still be in force
664 */
665 if (cpi->kf_overspend_bits > 0)
666 {
667 Adjustment = (cpi->kf_bitrate_adjustment <= cpi->kf_overspend_bits) ? cpi->kf_bitrate_adjustment : cpi->kf_overspend_bits;
669 if (Adjustment > (cpi->per_frame_bandwidth - min_frame_target))
670 Adjustment = (cpi->per_frame_bandwidth - min_frame_target);
672 cpi->kf_overspend_bits -= Adjustment;
674 /* Calculate an inter frame bandwidth target for the next
675 * few frames designed to recover any extra bits spent on
676 * the key frame.
677 */
678 cpi->this_frame_target = cpi->per_frame_bandwidth - Adjustment;
680 if (cpi->this_frame_target < min_frame_target)
681 cpi->this_frame_target = min_frame_target;
682 }
683 else
684 cpi->this_frame_target = cpi->per_frame_bandwidth;
686 /* If appropriate make an adjustment to recover bits spent on a
687 * recent GF
688 */
689 if ((cpi->gf_overspend_bits > 0) && (cpi->this_frame_target > min_frame_target))
690 {
691 Adjustment = (cpi->non_gf_bitrate_adjustment <= cpi->gf_overspend_bits) ? cpi->non_gf_bitrate_adjustment : cpi->gf_overspend_bits;
693 if (Adjustment > (cpi->this_frame_target - min_frame_target))
694 Adjustment = (cpi->this_frame_target - min_frame_target);
696 cpi->gf_overspend_bits -= Adjustment;
697 cpi->this_frame_target -= Adjustment;
698 }
700 /* Apply small + and - boosts for non gf frames */
701 if ((cpi->last_boost > 150) && (cpi->frames_till_gf_update_due > 0) &&
702 (cpi->current_gf_interval >= (MIN_GF_INTERVAL << 1)))
703 {
704 /* % Adjustment limited to the range 1% to 10% */
705 Adjustment = (cpi->last_boost - 100) >> 5;
707 if (Adjustment < 1)
708 Adjustment = 1;
709 else if (Adjustment > 10)
710 Adjustment = 10;
712 /* Convert to bits */
713 Adjustment = (cpi->this_frame_target * Adjustment) / 100;
715 if (Adjustment > (cpi->this_frame_target - min_frame_target))
716 Adjustment = (cpi->this_frame_target - min_frame_target);
718 if (cpi->frames_since_golden == (cpi->current_gf_interval >> 1))
719 cpi->this_frame_target += ((cpi->current_gf_interval - 1) * Adjustment);
720 else
721 cpi->this_frame_target -= Adjustment;
722 }
723 }
724 }
726 /* Sanity check that the total sum of adjustments is not above the
727 * maximum allowed That is that having allowed for KF and GF penalties
728 * we have not pushed the current interframe target to low. If the
729 * adjustment we apply here is not capable of recovering all the extra
730 * bits we have spent in the KF or GF then the remainder will have to
731 * be recovered over a longer time span via other buffer / rate control
732 * mechanisms.
733 */
734 if (cpi->this_frame_target < min_frame_target)
735 cpi->this_frame_target = min_frame_target;
737 if (!cpi->common.refresh_alt_ref_frame)
738 /* Note the baseline target data rate for this inter frame. */
739 cpi->inter_frame_target = cpi->this_frame_target;
741 /* One Pass specific code */
742 if (cpi->pass == 0)
743 {
744 /* Adapt target frame size with respect to any buffering constraints: */
745 if (cpi->buffered_mode)
746 {
747 int one_percent_bits = (int)
748 (1 + cpi->oxcf.optimal_buffer_level / 100);
750 if ((cpi->buffer_level < cpi->oxcf.optimal_buffer_level) ||
751 (cpi->bits_off_target < cpi->oxcf.optimal_buffer_level))
752 {
753 int percent_low = 0;
755 /* Decide whether or not we need to adjust the frame data
756 * rate target.
757 *
758 * If we are are below the optimal buffer fullness level
759 * and adherence to buffering constraints is important to
760 * the end usage then adjust the per frame target.
761 */
762 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
763 (cpi->buffer_level < cpi->oxcf.optimal_buffer_level))
764 {
765 percent_low = (int)
766 ((cpi->oxcf.optimal_buffer_level - cpi->buffer_level) /
767 one_percent_bits);
768 }
769 /* Are we overshooting the long term clip data rate... */
770 else if (cpi->bits_off_target < 0)
771 {
772 /* Adjust per frame data target downwards to compensate. */
773 percent_low = (int)(100 * -cpi->bits_off_target /
774 (cpi->total_byte_count * 8));
775 }
777 if (percent_low > cpi->oxcf.under_shoot_pct)
778 percent_low = cpi->oxcf.under_shoot_pct;
779 else if (percent_low < 0)
780 percent_low = 0;
782 /* lower the target bandwidth for this frame. */
783 cpi->this_frame_target -=
784 (cpi->this_frame_target * percent_low) / 200;
786 /* Are we using allowing control of active_worst_allowed_q
787 * according to buffer level.
788 */
789 if (cpi->auto_worst_q && cpi->ni_frames > 150)
790 {
791 int64_t critical_buffer_level;
793 /* For streaming applications the most important factor is
794 * cpi->buffer_level as this takes into account the
795 * specified short term buffering constraints. However,
796 * hitting the long term clip data rate target is also
797 * important.
798 */
799 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
800 {
801 /* Take the smaller of cpi->buffer_level and
802 * cpi->bits_off_target
803 */
804 critical_buffer_level =
805 (cpi->buffer_level < cpi->bits_off_target)
806 ? cpi->buffer_level : cpi->bits_off_target;
807 }
808 /* For local file playback short term buffering constraints
809 * are less of an issue
810 */
811 else
812 {
813 /* Consider only how we are doing for the clip as a
814 * whole
815 */
816 critical_buffer_level = cpi->bits_off_target;
817 }
819 /* Set the active worst quality based upon the selected
820 * buffer fullness number.
821 */
822 if (critical_buffer_level < cpi->oxcf.optimal_buffer_level)
823 {
824 if ( critical_buffer_level >
825 (cpi->oxcf.optimal_buffer_level >> 2) )
826 {
827 int64_t qadjustment_range =
828 cpi->worst_quality - cpi->ni_av_qi;
829 int64_t above_base =
830 (critical_buffer_level -
831 (cpi->oxcf.optimal_buffer_level >> 2));
833 /* Step active worst quality down from
834 * cpi->ni_av_qi when (critical_buffer_level ==
835 * cpi->optimal_buffer_level) to
836 * cpi->worst_quality when
837 * (critical_buffer_level ==
838 * cpi->optimal_buffer_level >> 2)
839 */
840 cpi->active_worst_quality =
841 cpi->worst_quality -
842 (int)((qadjustment_range * above_base) /
843 (cpi->oxcf.optimal_buffer_level*3>>2));
844 }
845 else
846 {
847 cpi->active_worst_quality = cpi->worst_quality;
848 }
849 }
850 else
851 {
852 cpi->active_worst_quality = cpi->ni_av_qi;
853 }
854 }
855 else
856 {
857 cpi->active_worst_quality = cpi->worst_quality;
858 }
859 }
860 else
861 {
862 int percent_high = 0;
864 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
865 && (cpi->buffer_level > cpi->oxcf.optimal_buffer_level))
866 {
867 percent_high = (int)((cpi->buffer_level
868 - cpi->oxcf.optimal_buffer_level)
869 / one_percent_bits);
870 }
871 else if (cpi->bits_off_target > cpi->oxcf.optimal_buffer_level)
872 {
873 percent_high = (int)((100 * cpi->bits_off_target)
874 / (cpi->total_byte_count * 8));
875 }
877 if (percent_high > cpi->oxcf.over_shoot_pct)
878 percent_high = cpi->oxcf.over_shoot_pct;
879 else if (percent_high < 0)
880 percent_high = 0;
882 cpi->this_frame_target += (cpi->this_frame_target *
883 percent_high) / 200;
885 /* Are we allowing control of active_worst_allowed_q according
886 * to buffer level.
887 */
888 if (cpi->auto_worst_q && cpi->ni_frames > 150)
889 {
890 /* When using the relaxed buffer model stick to the
891 * user specified value
892 */
893 cpi->active_worst_quality = cpi->ni_av_qi;
894 }
895 else
896 {
897 cpi->active_worst_quality = cpi->worst_quality;
898 }
899 }
901 /* Set active_best_quality to prevent quality rising too high */
902 cpi->active_best_quality = cpi->best_quality;
904 /* Worst quality obviously must not be better than best quality */
905 if (cpi->active_worst_quality <= cpi->active_best_quality)
906 cpi->active_worst_quality = cpi->active_best_quality + 1;
908 if(cpi->active_worst_quality > 127)
909 cpi->active_worst_quality = 127;
910 }
911 /* Unbuffered mode (eg. video conferencing) */
912 else
913 {
914 /* Set the active worst quality */
915 cpi->active_worst_quality = cpi->worst_quality;
916 }
918 /* Special trap for constrained quality mode
919 * "active_worst_quality" may never drop below cq level
920 * for any frame type.
921 */
922 if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY &&
923 cpi->active_worst_quality < cpi->cq_target_quality)
924 {
925 cpi->active_worst_quality = cpi->cq_target_quality;
926 }
927 }
929 /* Test to see if we have to drop a frame
930 * The auto-drop frame code is only used in buffered mode.
931 * In unbufferd mode (eg vide conferencing) the descision to
932 * code or drop a frame is made outside the codec in response to real
933 * world comms or buffer considerations.
934 */
935 if (cpi->drop_frames_allowed &&
936 (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
937 ((cpi->common.frame_type != KEY_FRAME)))
938 {
939 /* Check for a buffer underun-crisis in which case we have to drop
940 * a frame
941 */
942 if ((cpi->buffer_level < 0))
943 {
944 #if 0
945 FILE *f = fopen("dec.stt", "a");
946 fprintf(f, "%10d %10d %10d %10d ***** BUFFER EMPTY\n",
947 (int) cpi->common.current_video_frame,
948 cpi->decimation_factor, cpi->common.horiz_scale,
949 (cpi->buffer_level * 100) / cpi->oxcf.optimal_buffer_level);
950 fclose(f);
951 #endif
952 cpi->drop_frame = 1;
954 /* Update the buffer level variable. */
955 cpi->bits_off_target += cpi->av_per_frame_bandwidth;
956 if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
957 cpi->bits_off_target = (int)cpi->oxcf.maximum_buffer_size;
958 cpi->buffer_level = cpi->bits_off_target;
960 if (cpi->oxcf.number_of_layers > 1) {
961 unsigned int i;
963 // Propagate bits saved by dropping the frame to higher layers.
964 for (i = cpi->current_layer + 1; i < cpi->oxcf.number_of_layers;
965 i++) {
966 LAYER_CONTEXT *lc = &cpi->layer_context[i];
967 lc->bits_off_target += (int)(lc->target_bandwidth /
968 lc->framerate);
969 if (lc->bits_off_target > lc->maximum_buffer_size)
970 lc->bits_off_target = lc->maximum_buffer_size;
971 lc->buffer_level = lc->bits_off_target;
972 }
973 }
974 }
975 }
977 /* Adjust target frame size for Golden Frames: */
978 if (cpi->oxcf.error_resilient_mode == 0 &&
979 (cpi->frames_till_gf_update_due == 0) && !cpi->drop_frame)
980 {
981 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
983 int gf_frame_useage = 0; /* Golden frame useage since last GF */
984 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
985 cpi->recent_ref_frame_usage[LAST_FRAME] +
986 cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
987 cpi->recent_ref_frame_usage[ALTREF_FRAME];
989 int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols);
991 if (tot_mbs)
992 gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs;
994 if (pct_gf_active > gf_frame_useage)
995 gf_frame_useage = pct_gf_active;
997 /* Is a fixed manual GF frequency being used */
998 if (cpi->auto_gold)
999 {
1000 /* For one pass throw a GF if recent frame intra useage is
1001 * low or the GF useage is high
1002 */
1003 if ((cpi->pass == 0) && (cpi->this_frame_percent_intra < 15 || gf_frame_useage >= 5))
1004 cpi->common.refresh_golden_frame = 1;
1006 /* Two pass GF descision */
1007 else if (cpi->pass == 2)
1008 cpi->common.refresh_golden_frame = 1;
1009 }
1011 #if 0
1013 /* Debug stats */
1014 if (0)
1015 {
1016 FILE *f;
1018 f = fopen("gf_useaget.stt", "a");
1019 fprintf(f, " %8ld %10ld %10ld %10ld %10ld\n",
1020 cpi->common.current_video_frame, cpi->gfu_boost, GFQ_ADJUSTMENT, cpi->gfu_boost, gf_frame_useage);
1021 fclose(f);
1022 }
1024 #endif
1026 if (cpi->common.refresh_golden_frame == 1)
1027 {
1028 #if 0
1030 if (0)
1031 {
1032 FILE *f;
1034 f = fopen("GFexit.stt", "a");
1035 fprintf(f, "%8ld GF coded\n", cpi->common.current_video_frame);
1036 fclose(f);
1037 }
1039 #endif
1041 if (cpi->auto_adjust_gold_quantizer)
1042 {
1043 calc_gf_params(cpi);
1044 }
1046 /* If we are using alternate ref instead of gf then do not apply the
1047 * boost It will instead be applied to the altref update Jims
1048 * modified boost
1049 */
1050 if (!cpi->source_alt_ref_active)
1051 {
1052 if (cpi->oxcf.fixed_q < 0)
1053 {
1054 if (cpi->pass == 2)
1055 {
1056 /* The spend on the GF is defined in the two pass
1057 * code for two pass encodes
1058 */
1059 cpi->this_frame_target = cpi->per_frame_bandwidth;
1060 }
1061 else
1062 {
1063 int Boost = cpi->last_boost;
1064 int frames_in_section = cpi->frames_till_gf_update_due + 1;
1065 int allocation_chunks = (frames_in_section * 100) + (Boost - 100);
1066 int bits_in_section = cpi->inter_frame_target * frames_in_section;
1068 /* Normalize Altboost and allocations chunck down to
1069 * prevent overflow
1070 */
1071 while (Boost > 1000)
1072 {
1073 Boost /= 2;
1074 allocation_chunks /= 2;
1075 }
1077 /* Avoid loss of precision but avoid overflow */
1078 if ((bits_in_section >> 7) > allocation_chunks)
1079 cpi->this_frame_target = Boost * (bits_in_section / allocation_chunks);
1080 else
1081 cpi->this_frame_target = (Boost * bits_in_section) / allocation_chunks;
1082 }
1083 }
1084 else
1085 cpi->this_frame_target =
1086 (estimate_bits_at_q(1, Q, cpi->common.MBs, 1.0)
1087 * cpi->last_boost) / 100;
1089 }
1090 /* If there is an active ARF at this location use the minimum
1091 * bits on this frame even if it is a contructed arf.
1092 * The active maximum quantizer insures that an appropriate
1093 * number of bits will be spent if needed for contstructed ARFs.
1094 */
1095 else
1096 {
1097 cpi->this_frame_target = 0;
1098 }
1100 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
1102 }
1103 }
1105 cpi->per_frame_bandwidth = old_per_frame_bandwidth;
1106 }
1109 void vp8_update_rate_correction_factors(VP8_COMP *cpi, int damp_var)
1110 {
1111 int Q = cpi->common.base_qindex;
1112 int correction_factor = 100;
1113 double rate_correction_factor;
1114 double adjustment_limit;
1116 int projected_size_based_on_q = 0;
1118 /* Clear down mmx registers to allow floating point in what follows */
1119 vp8_clear_system_state();
1121 if (cpi->common.frame_type == KEY_FRAME)
1122 {
1123 rate_correction_factor = cpi->key_frame_rate_correction_factor;
1124 }
1125 else
1126 {
1127 if (cpi->oxcf.number_of_layers == 1 &&
1128 (cpi->common.refresh_alt_ref_frame ||
1129 cpi->common.refresh_golden_frame))
1130 rate_correction_factor = cpi->gf_rate_correction_factor;
1131 else
1132 rate_correction_factor = cpi->rate_correction_factor;
1133 }
1135 /* Work out how big we would have expected the frame to be at this Q
1136 * given the current correction factor. Stay in double to avoid int
1137 * overflow when values are large
1138 */
1139 projected_size_based_on_q = (int)(((.5 + rate_correction_factor * vp8_bits_per_mb[cpi->common.frame_type][Q]) * cpi->common.MBs) / (1 << BPER_MB_NORMBITS));
1141 /* Make some allowance for cpi->zbin_over_quant */
1142 if (cpi->mb.zbin_over_quant > 0)
1143 {
1144 int Z = cpi->mb.zbin_over_quant;
1145 double Factor = 0.99;
1146 double factor_adjustment = 0.01 / 256.0;
1148 while (Z > 0)
1149 {
1150 Z --;
1151 projected_size_based_on_q =
1152 (int)(Factor * projected_size_based_on_q);
1153 Factor += factor_adjustment;
1155 if (Factor >= 0.999)
1156 Factor = 0.999;
1157 }
1158 }
1160 /* Work out a size correction factor. */
1161 if (projected_size_based_on_q > 0)
1162 correction_factor = (100 * cpi->projected_frame_size) / projected_size_based_on_q;
1164 /* More heavily damped adjustment used if we have been oscillating
1165 * either side of target
1166 */
1167 switch (damp_var)
1168 {
1169 case 0:
1170 adjustment_limit = 0.75;
1171 break;
1172 case 1:
1173 adjustment_limit = 0.375;
1174 break;
1175 case 2:
1176 default:
1177 adjustment_limit = 0.25;
1178 break;
1179 }
1181 if (correction_factor > 102)
1182 {
1183 /* We are not already at the worst allowable quality */
1184 correction_factor = (int)(100.5 + ((correction_factor - 100) * adjustment_limit));
1185 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1187 /* Keep rate_correction_factor within limits */
1188 if (rate_correction_factor > MAX_BPB_FACTOR)
1189 rate_correction_factor = MAX_BPB_FACTOR;
1190 }
1191 else if (correction_factor < 99)
1192 {
1193 /* We are not already at the best allowable quality */
1194 correction_factor = (int)(100.5 - ((100 - correction_factor) * adjustment_limit));
1195 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1197 /* Keep rate_correction_factor within limits */
1198 if (rate_correction_factor < MIN_BPB_FACTOR)
1199 rate_correction_factor = MIN_BPB_FACTOR;
1200 }
1202 if (cpi->common.frame_type == KEY_FRAME)
1203 cpi->key_frame_rate_correction_factor = rate_correction_factor;
1204 else
1205 {
1206 if (cpi->oxcf.number_of_layers == 1 &&
1207 (cpi->common.refresh_alt_ref_frame ||
1208 cpi->common.refresh_golden_frame))
1209 cpi->gf_rate_correction_factor = rate_correction_factor;
1210 else
1211 cpi->rate_correction_factor = rate_correction_factor;
1212 }
1213 }
1216 int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame)
1217 {
1218 int Q = cpi->active_worst_quality;
1220 /* Reset Zbin OQ value */
1221 cpi->mb.zbin_over_quant = 0;
1223 if (cpi->oxcf.fixed_q >= 0)
1224 {
1225 Q = cpi->oxcf.fixed_q;
1227 if (cpi->common.frame_type == KEY_FRAME)
1228 {
1229 Q = cpi->oxcf.key_q;
1230 }
1231 else if (cpi->oxcf.number_of_layers == 1 &&
1232 cpi->common.refresh_alt_ref_frame)
1233 {
1234 Q = cpi->oxcf.alt_q;
1235 }
1236 else if (cpi->oxcf.number_of_layers == 1 &&
1237 cpi->common.refresh_golden_frame)
1238 {
1239 Q = cpi->oxcf.gold_q;
1240 }
1242 }
1243 else
1244 {
1245 int i;
1246 int last_error = INT_MAX;
1247 int target_bits_per_mb;
1248 int bits_per_mb_at_this_q;
1249 double correction_factor;
1251 /* Select the appropriate correction factor based upon type of frame. */
1252 if (cpi->common.frame_type == KEY_FRAME)
1253 correction_factor = cpi->key_frame_rate_correction_factor;
1254 else
1255 {
1256 if (cpi->oxcf.number_of_layers == 1 &&
1257 (cpi->common.refresh_alt_ref_frame ||
1258 cpi->common.refresh_golden_frame))
1259 correction_factor = cpi->gf_rate_correction_factor;
1260 else
1261 correction_factor = cpi->rate_correction_factor;
1262 }
1264 /* Calculate required scaling factor based on target frame size and
1265 * size of frame produced using previous Q
1266 */
1267 if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
1268 /* Case where we would overflow int */
1269 target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs) << BPER_MB_NORMBITS;
1270 else
1271 target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
1273 i = cpi->active_best_quality;
1275 do
1276 {
1277 bits_per_mb_at_this_q = (int)(.5 + correction_factor * vp8_bits_per_mb[cpi->common.frame_type][i]);
1279 if (bits_per_mb_at_this_q <= target_bits_per_mb)
1280 {
1281 if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
1282 Q = i;
1283 else
1284 Q = i - 1;
1286 break;
1287 }
1288 else
1289 last_error = bits_per_mb_at_this_q - target_bits_per_mb;
1290 }
1291 while (++i <= cpi->active_worst_quality);
1294 /* If we are at MAXQ then enable Q over-run which seeks to claw
1295 * back additional bits through things like the RD multiplier
1296 * and zero bin size.
1297 */
1298 if (Q >= MAXQ)
1299 {
1300 int zbin_oqmax;
1302 double Factor = 0.99;
1303 double factor_adjustment = 0.01 / 256.0;
1305 if (cpi->common.frame_type == KEY_FRAME)
1306 zbin_oqmax = 0;
1307 else if (cpi->oxcf.number_of_layers == 1 &&
1308 (cpi->common.refresh_alt_ref_frame ||
1309 (cpi->common.refresh_golden_frame &&
1310 !cpi->source_alt_ref_active)))
1311 zbin_oqmax = 16;
1312 else
1313 zbin_oqmax = ZBIN_OQ_MAX;
1315 /*{
1316 double Factor = (double)target_bits_per_mb/(double)bits_per_mb_at_this_q;
1317 double Oq;
1319 Factor = Factor/1.2683;
1321 Oq = pow( Factor, (1.0/-0.165) );
1323 if ( Oq > zbin_oqmax )
1324 Oq = zbin_oqmax;
1326 cpi->zbin_over_quant = (int)Oq;
1327 }*/
1329 /* Each incrment in the zbin is assumed to have a fixed effect
1330 * on bitrate. This is not of course true. The effect will be
1331 * highly clip dependent and may well have sudden steps. The
1332 * idea here is to acheive higher effective quantizers than the
1333 * normal maximum by expanding the zero bin and hence
1334 * decreasing the number of low magnitude non zero coefficients.
1335 */
1336 while (cpi->mb.zbin_over_quant < zbin_oqmax)
1337 {
1338 cpi->mb.zbin_over_quant ++;
1340 if (cpi->mb.zbin_over_quant > zbin_oqmax)
1341 cpi->mb.zbin_over_quant = zbin_oqmax;
1343 /* Adjust bits_per_mb_at_this_q estimate */
1344 bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q);
1345 Factor += factor_adjustment;
1347 if (Factor >= 0.999)
1348 Factor = 0.999;
1350 /* Break out if we get down to the target rate */
1351 if (bits_per_mb_at_this_q <= target_bits_per_mb)
1352 break;
1353 }
1355 }
1356 }
1358 return Q;
1359 }
1362 static int estimate_keyframe_frequency(VP8_COMP *cpi)
1363 {
1364 int i;
1366 /* Average key frame frequency */
1367 int av_key_frame_frequency = 0;
1369 /* First key frame at start of sequence is a special case. We have no
1370 * frequency data.
1371 */
1372 if (cpi->key_frame_count == 1)
1373 {
1374 /* Assume a default of 1 kf every 2 seconds, or the max kf interval,
1375 * whichever is smaller.
1376 */
1377 int key_freq = cpi->oxcf.key_freq>0 ? cpi->oxcf.key_freq : 1;
1378 av_key_frame_frequency = 1 + (int)cpi->output_framerate * 2;
1380 if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq)
1381 av_key_frame_frequency = key_freq;
1383 cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1]
1384 = av_key_frame_frequency;
1385 }
1386 else
1387 {
1388 unsigned int total_weight = 0;
1389 int last_kf_interval =
1390 (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;
1392 /* reset keyframe context and calculate weighted average of last
1393 * KEY_FRAME_CONTEXT keyframes
1394 */
1395 for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1396 {
1397 if (i < KEY_FRAME_CONTEXT - 1)
1398 cpi->prior_key_frame_distance[i]
1399 = cpi->prior_key_frame_distance[i+1];
1400 else
1401 cpi->prior_key_frame_distance[i] = last_kf_interval;
1403 av_key_frame_frequency += prior_key_frame_weight[i]
1404 * cpi->prior_key_frame_distance[i];
1405 total_weight += prior_key_frame_weight[i];
1406 }
1408 av_key_frame_frequency /= total_weight;
1410 }
1411 // TODO (marpan): Given the checks above, |av_key_frame_frequency|
1412 // should always be above 0. But for now we keep the sanity check in.
1413 if (av_key_frame_frequency == 0)
1414 av_key_frame_frequency = 1;
1415 return av_key_frame_frequency;
1416 }
1419 void vp8_adjust_key_frame_context(VP8_COMP *cpi)
1420 {
1421 /* Clear down mmx registers to allow floating point in what follows */
1422 vp8_clear_system_state();
1424 /* Do we have any key frame overspend to recover? */
1425 /* Two-pass overspend handled elsewhere. */
1426 if ((cpi->pass != 2)
1427 && (cpi->projected_frame_size > cpi->per_frame_bandwidth))
1428 {
1429 int overspend;
1431 /* Update the count of key frame overspend to be recovered in
1432 * subsequent frames. A portion of the KF overspend is treated as gf
1433 * overspend (and hence recovered more quickly) as the kf is also a
1434 * gf. Otherwise the few frames following each kf tend to get more
1435 * bits allocated than those following other gfs.
1436 */
1437 overspend = (cpi->projected_frame_size - cpi->per_frame_bandwidth);
1439 if (cpi->oxcf.number_of_layers > 1)
1440 cpi->kf_overspend_bits += overspend;
1441 else
1442 {
1443 cpi->kf_overspend_bits += overspend * 7 / 8;
1444 cpi->gf_overspend_bits += overspend * 1 / 8;
1445 }
1447 /* Work out how much to try and recover per frame. */
1448 cpi->kf_bitrate_adjustment = cpi->kf_overspend_bits
1449 / estimate_keyframe_frequency(cpi);
1450 }
1452 cpi->frames_since_key = 0;
1453 cpi->key_frame_count++;
1454 }
1457 void vp8_compute_frame_size_bounds(VP8_COMP *cpi, int *frame_under_shoot_limit, int *frame_over_shoot_limit)
1458 {
1459 /* Set-up bounds on acceptable frame size: */
1460 if (cpi->oxcf.fixed_q >= 0)
1461 {
1462 /* Fixed Q scenario: frame size never outranges target
1463 * (there is no target!)
1464 */
1465 *frame_under_shoot_limit = 0;
1466 *frame_over_shoot_limit = INT_MAX;
1467 }
1468 else
1469 {
1470 if (cpi->common.frame_type == KEY_FRAME)
1471 {
1472 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
1473 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1474 }
1475 else
1476 {
1477 if (cpi->oxcf.number_of_layers > 1 ||
1478 cpi->common.refresh_alt_ref_frame ||
1479 cpi->common.refresh_golden_frame)
1480 {
1481 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
1482 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1483 }
1484 else
1485 {
1486 /* For CBR take buffer fullness into account */
1487 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
1488 {
1489 if (cpi->buffer_level >= ((cpi->oxcf.optimal_buffer_level + cpi->oxcf.maximum_buffer_size) >> 1))
1490 {
1491 /* Buffer is too full so relax overshoot and tighten
1492 * undershoot
1493 */
1494 *frame_over_shoot_limit = cpi->this_frame_target * 12 / 8;
1495 *frame_under_shoot_limit = cpi->this_frame_target * 6 / 8;
1496 }
1497 else if (cpi->buffer_level <= (cpi->oxcf.optimal_buffer_level >> 1))
1498 {
1499 /* Buffer is too low so relax undershoot and tighten
1500 * overshoot
1501 */
1502 *frame_over_shoot_limit = cpi->this_frame_target * 10 / 8;
1503 *frame_under_shoot_limit = cpi->this_frame_target * 4 / 8;
1504 }
1505 else
1506 {
1507 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1508 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1509 }
1510 }
1511 /* VBR and CQ mode */
1512 /* Note that tighter restrictions here can help quality
1513 * but hurt encode speed
1514 */
1515 else
1516 {
1517 /* Stron overshoot limit for constrained quality */
1518 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
1519 {
1520 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1521 *frame_under_shoot_limit = cpi->this_frame_target * 2 / 8;
1522 }
1523 else
1524 {
1525 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1526 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1527 }
1528 }
1529 }
1530 }
1532 /* For very small rate targets where the fractional adjustment
1533 * (eg * 7/8) may be tiny make sure there is at least a minimum
1534 * range.
1535 */
1536 *frame_over_shoot_limit += 200;
1537 *frame_under_shoot_limit -= 200;
1538 if ( *frame_under_shoot_limit < 0 )
1539 *frame_under_shoot_limit = 0;
1541 }
1542 }
1545 /* return of 0 means drop frame */
1546 int vp8_pick_frame_size(VP8_COMP *cpi)
1547 {
1548 VP8_COMMON *cm = &cpi->common;
1550 if (cm->frame_type == KEY_FRAME)
1551 calc_iframe_target_size(cpi);
1552 else
1553 {
1554 calc_pframe_target_size(cpi);
1556 /* Check if we're dropping the frame: */
1557 if (cpi->drop_frame)
1558 {
1559 cpi->drop_frame = 0;
1560 return 0;
1561 }
1562 }
1563 return 1;
1564 }
