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 */
10
11
12 #include <stdlib.h>
13 #include <stdio.h>
14 #include <string.h>
15 #include <limits.h>
16 #include <assert.h>
17
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"
25
26
27 #define MIN_BPB_FACTOR 0.01
28 #define MAX_BPB_FACTOR 50
29
30 extern const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES];
31
32
33
34 #ifdef MODE_STATS
35 extern int y_modes[5];
36 extern int uv_modes[4];
37 extern int b_modes[10];
38
39 extern int inter_y_modes[10];
40 extern int inter_uv_modes[4];
41 extern int inter_b_modes[10];
42 #endif
43
44 /* Bits Per MB at different Q (Multiplied by 512) */
45 #define BPER_MB_NORMBITS 9
46
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 };
92
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 };
112
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 };
134
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 */
156
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 };
176
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 };
183
184
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 };
199
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 };
205
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 };
220
221 static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = { 1, 2, 3, 4, 5 };
222
223
vp8_save_coding_context(VP8_COMP * cpi)224 void vp8_save_coding_context(VP8_COMP *cpi)
225 {
226 CODING_CONTEXT *const cc = & cpi->coding_context;
227
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 */
233
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->common.frames_since_golden;
238
239 vp8_copy(cc->mvc, cpi->common.fc.mvc);
240 vp8_copy(cc->mvcosts, cpi->rd_costs.mvcosts);
241
242 vp8_copy(cc->ymode_prob, cpi->common.fc.ymode_prob);
243 vp8_copy(cc->uv_mode_prob, cpi->common.fc.uv_mode_prob);
244
245 vp8_copy(cc->ymode_count, cpi->mb.ymode_count);
246 vp8_copy(cc->uv_mode_count, cpi->mb.uv_mode_count);
247
248
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
258
259 cc->this_frame_percent_intra = cpi->this_frame_percent_intra;
260 }
261
262
vp8_restore_coding_context(VP8_COMP * cpi)263 void vp8_restore_coding_context(VP8_COMP *cpi)
264 {
265 CODING_CONTEXT *const cc = & cpi->coding_context;
266
267 /* Restore key state variables to the snapshot state stored in the
268 * previous call to vp8_save_coding_context.
269 */
270
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->common.frames_since_golden = cc->frames_since_golden;
275
276 vp8_copy(cpi->common.fc.mvc, cc->mvc);
277
278 vp8_copy(cpi->rd_costs.mvcosts, cc->mvcosts);
279
280 vp8_copy(cpi->common.fc.ymode_prob, cc->ymode_prob);
281 vp8_copy(cpi->common.fc.uv_mode_prob, cc->uv_mode_prob);
282
283 vp8_copy(cpi->mb.ymode_count, cc->ymode_count);
284 vp8_copy(cpi->mb.uv_mode_count, cc->uv_mode_count);
285
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
295
296
297 cpi->this_frame_percent_intra = cc->this_frame_percent_intra;
298 }
299
300
vp8_setup_key_frame(VP8_COMP * cpi)301 void vp8_setup_key_frame(VP8_COMP *cpi)
302 {
303 /* Setup for Key frame: */
304
305 vp8_default_coef_probs(& cpi->common);
306
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 }
312
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));
319
320 cpi->common.filter_level = cpi->common.base_qindex * 3 / 8 ;
321
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;
327
328 cpi->common.refresh_golden_frame = 1;
329 cpi->common.refresh_alt_ref_frame = 1;
330 }
331
332
estimate_bits_at_q(int frame_kind,int Q,int MBs,double correction_factor)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]);
337
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 }
347
348
calc_iframe_target_size(VP8_COMP * cpi)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;
354
355 /* Clear down mmx registers to allow floating point in what follows */
356 vp8_clear_system_state();
357
358 if (cpi->oxcf.fixed_q >= 0)
359 {
360 int Q = cpi->oxcf.key_q;
361
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;
378
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;
387
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_frame_rate - 16));
392 }
393 else {
394 /* Initial factor: set target size to: |3.0 * per_frame_bandwidth|. */
395 kf_boost = initial_boost;
396 }
397
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;
400
401 /* frame separation adjustment ( down) */
402 if (cpi->frames_since_key < cpi->output_frame_rate / 2)
403 kf_boost = (int)(kf_boost
404 * cpi->frames_since_key / (cpi->output_frame_rate / 2));
405
406 /* Minimal target size is |2* per_frame_bandwidth|. */
407 if (kf_boost < 16)
408 kf_boost = 16;
409
410 target = ((16 + kf_boost) * cpi->per_frame_bandwidth) >> 4;
411 }
412
413
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;
418
419 if (target > max_rate)
420 target = max_rate;
421 }
422
423 cpi->this_frame_target = (int)target;
424
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;
430
431 #if 0
432 {
433 FILE *f;
434
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);
438
439 fclose(f);
440 }
441 #endif
442 }
443
444
445 /* Do the best we can to define the parameters for the next GF based on what
446 * information we have available.
447 */
calc_gf_params(VP8_COMP * cpi)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;
452
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];
458
459 int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols);
460
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;
463
464 if (pct_gf_active > gf_frame_useage)
465 gf_frame_useage = pct_gf_active;
466
467 /* Not two pass */
468 if (cpi->pass != 2)
469 {
470 /* Single Pass lagged mode: TBD */
471 if (0)
472 {
473 }
474
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;
482
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;
489
490 cpi->one_pass_frame_index = cpi->common.current_video_frame%MAX_LAG_BUFFERS;
491
492 for ( i = 0; i < (frames_to_scan - 1); i++ )
493 {
494 if ( index < 0 )
495 index = MAX_LAG_BUFFERS;
496 index --;
497
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;
501
502 if ( IIRatio > 30.0 )
503 IIRatio = 30.0;
504 }
505 else
506 IIRatio = 30.0;
507
508 IIAccumulator += IIRatio * decay_val;
509
510 decay_val = decay_val * cpi->one_pass_frame_stats[index].frame_pcnt_inter;
511
512 if ( (i > MIN_GF_INTERVAL) &&
513 ((IIAccumulator - last_iiaccumulator) < 2.0) )
514 {
515 break;
516 }
517 last_iiaccumulator = IIAccumulator;
518 }
519
520 Boost = IIAccumulator*100.0/16.0;
521 cpi->baseline_gf_interval = i;
522
523 */
524 #else
525
526 /*************************************************************/
527 /* OLD code */
528
529 /* Adjust boost based upon ambient Q */
530 Boost = GFQ_ADJUSTMENT;
531
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;
534
535 /* Adjust gf boost based upon GF usage since last GF */
536 Boost = Boost * gf_adjust_table[gf_frame_useage] / 100;
537 #endif
538 }
539
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 }
548
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];
552
553 /* Apply lower limits to boost. */
554 else if (Boost < 110)
555 Boost = 110;
556
557 /* Note the boost used */
558 cpi->last_boost = Boost;
559
560 }
561
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;
574
575 if (cpi->last_boost > 750)
576 cpi->frames_till_gf_update_due++;
577
578 if (cpi->last_boost > 1000)
579 cpi->frames_till_gf_update_due++;
580
581 if (cpi->last_boost > 1250)
582 cpi->frames_till_gf_update_due++;
583
584 if (cpi->last_boost >= 1500)
585 cpi->frames_till_gf_update_due ++;
586
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];
589
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;
596
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;
602
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 }
612
613
calc_pframe_target_size(VP8_COMP * cpi)614 static void calc_pframe_target_size(VP8_COMP *cpi)
615 {
616 int min_frame_target;
617 int Adjustment;
618 int old_per_frame_bandwidth = cpi->per_frame_bandwidth;
619
620 if ( cpi->current_layer > 0)
621 cpi->per_frame_bandwidth =
622 cpi->layer_context[cpi->current_layer].avg_frame_size_for_layer;
623
624 min_frame_target = 0;
625
626 if (cpi->pass == 2)
627 {
628 min_frame_target = cpi->min_frame_bandwidth;
629
630 if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5))
631 min_frame_target = cpi->av_per_frame_bandwidth >> 5;
632 }
633 else if (min_frame_target < cpi->per_frame_bandwidth / 4)
634 min_frame_target = cpi->per_frame_bandwidth / 4;
635
636
637 /* Special alt reference frame case */
638 if((cpi->common.refresh_alt_ref_frame) && (cpi->oxcf.number_of_layers == 1))
639 {
640 if (cpi->pass == 2)
641 {
642 /* Per frame bit target for the alt ref frame */
643 cpi->per_frame_bandwidth = cpi->twopass.gf_bits;
644 cpi->this_frame_target = cpi->per_frame_bandwidth;
645 }
646
647 /* One Pass ??? TBD */
648 }
649
650 /* Normal frames (gf,and inter) */
651 else
652 {
653 /* 2 pass */
654 if (cpi->pass == 2)
655 {
656 cpi->this_frame_target = cpi->per_frame_bandwidth;
657 }
658 /* 1 pass */
659 else
660 {
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;
668
669 if (Adjustment > (cpi->per_frame_bandwidth - min_frame_target))
670 Adjustment = (cpi->per_frame_bandwidth - min_frame_target);
671
672 cpi->kf_overspend_bits -= Adjustment;
673
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;
679
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;
685
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 int Adjustment = (cpi->non_gf_bitrate_adjustment <= cpi->gf_overspend_bits) ? cpi->non_gf_bitrate_adjustment : cpi->gf_overspend_bits;
692
693 if (Adjustment > (cpi->this_frame_target - min_frame_target))
694 Adjustment = (cpi->this_frame_target - min_frame_target);
695
696 cpi->gf_overspend_bits -= Adjustment;
697 cpi->this_frame_target -= Adjustment;
698 }
699
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;
706
707 if (Adjustment < 1)
708 Adjustment = 1;
709 else if (Adjustment > 10)
710 Adjustment = 10;
711
712 /* Convert to bits */
713 Adjustment = (cpi->this_frame_target * Adjustment) / 100;
714
715 if (Adjustment > (cpi->this_frame_target - min_frame_target))
716 Adjustment = (cpi->this_frame_target - min_frame_target);
717
718 if (cpi->common.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 }
725
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;
736
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;
740
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);
749
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;
754
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 }
776
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;
781
782 /* lower the target bandwidth for this frame. */
783 cpi->this_frame_target -=
784 (cpi->this_frame_target * percent_low) / 200;
785
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;
792
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 }
818
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));
832
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;
863
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 }
876
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;
881
882 cpi->this_frame_target += (cpi->this_frame_target *
883 percent_high) / 200;
884
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 }
900
901 /* Set active_best_quality to prevent quality rising too high */
902 cpi->active_best_quality = cpi->best_quality;
903
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;
907
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 }
917
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 }
928
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;
953
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;
959 }
960 }
961
962 /* Adjust target frame size for Golden Frames: */
963 if (cpi->oxcf.error_resilient_mode == 0 &&
964 (cpi->frames_till_gf_update_due == 0) && !cpi->drop_frame)
965 {
966 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
967
968 int gf_frame_useage = 0; /* Golden frame useage since last GF */
969 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
970 cpi->recent_ref_frame_usage[LAST_FRAME] +
971 cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
972 cpi->recent_ref_frame_usage[ALTREF_FRAME];
973
974 int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols);
975
976 if (tot_mbs)
977 gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs;
978
979 if (pct_gf_active > gf_frame_useage)
980 gf_frame_useage = pct_gf_active;
981
982 /* Is a fixed manual GF frequency being used */
983 if (cpi->auto_gold)
984 {
985 /* For one pass throw a GF if recent frame intra useage is
986 * low or the GF useage is high
987 */
988 if ((cpi->pass == 0) && (cpi->this_frame_percent_intra < 15 || gf_frame_useage >= 5))
989 cpi->common.refresh_golden_frame = 1;
990
991 /* Two pass GF descision */
992 else if (cpi->pass == 2)
993 cpi->common.refresh_golden_frame = 1;
994 }
995
996 #if 0
997
998 /* Debug stats */
999 if (0)
1000 {
1001 FILE *f;
1002
1003 f = fopen("gf_useaget.stt", "a");
1004 fprintf(f, " %8ld %10ld %10ld %10ld %10ld\n",
1005 cpi->common.current_video_frame, cpi->gfu_boost, GFQ_ADJUSTMENT, cpi->gfu_boost, gf_frame_useage);
1006 fclose(f);
1007 }
1008
1009 #endif
1010
1011 if (cpi->common.refresh_golden_frame == 1)
1012 {
1013 #if 0
1014
1015 if (0)
1016 {
1017 FILE *f;
1018
1019 f = fopen("GFexit.stt", "a");
1020 fprintf(f, "%8ld GF coded\n", cpi->common.current_video_frame);
1021 fclose(f);
1022 }
1023
1024 #endif
1025
1026 if (cpi->auto_adjust_gold_quantizer)
1027 {
1028 calc_gf_params(cpi);
1029 }
1030
1031 /* If we are using alternate ref instead of gf then do not apply the
1032 * boost It will instead be applied to the altref update Jims
1033 * modified boost
1034 */
1035 if (!cpi->source_alt_ref_active)
1036 {
1037 if (cpi->oxcf.fixed_q < 0)
1038 {
1039 if (cpi->pass == 2)
1040 {
1041 /* The spend on the GF is defined in the two pass
1042 * code for two pass encodes
1043 */
1044 cpi->this_frame_target = cpi->per_frame_bandwidth;
1045 }
1046 else
1047 {
1048 int Boost = cpi->last_boost;
1049 int frames_in_section = cpi->frames_till_gf_update_due + 1;
1050 int allocation_chunks = (frames_in_section * 100) + (Boost - 100);
1051 int bits_in_section = cpi->inter_frame_target * frames_in_section;
1052
1053 /* Normalize Altboost and allocations chunck down to
1054 * prevent overflow
1055 */
1056 while (Boost > 1000)
1057 {
1058 Boost /= 2;
1059 allocation_chunks /= 2;
1060 }
1061
1062 /* Avoid loss of precision but avoid overflow */
1063 if ((bits_in_section >> 7) > allocation_chunks)
1064 cpi->this_frame_target = Boost * (bits_in_section / allocation_chunks);
1065 else
1066 cpi->this_frame_target = (Boost * bits_in_section) / allocation_chunks;
1067 }
1068 }
1069 else
1070 cpi->this_frame_target =
1071 (estimate_bits_at_q(1, Q, cpi->common.MBs, 1.0)
1072 * cpi->last_boost) / 100;
1073
1074 }
1075 /* If there is an active ARF at this location use the minimum
1076 * bits on this frame even if it is a contructed arf.
1077 * The active maximum quantizer insures that an appropriate
1078 * number of bits will be spent if needed for contstructed ARFs.
1079 */
1080 else
1081 {
1082 cpi->this_frame_target = 0;
1083 }
1084
1085 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
1086
1087 }
1088 }
1089
1090 cpi->per_frame_bandwidth = old_per_frame_bandwidth;
1091 }
1092
1093
vp8_update_rate_correction_factors(VP8_COMP * cpi,int damp_var)1094 void vp8_update_rate_correction_factors(VP8_COMP *cpi, int damp_var)
1095 {
1096 int Q = cpi->common.base_qindex;
1097 int correction_factor = 100;
1098 double rate_correction_factor;
1099 double adjustment_limit;
1100
1101 int projected_size_based_on_q = 0;
1102
1103 /* Clear down mmx registers to allow floating point in what follows */
1104 vp8_clear_system_state();
1105
1106 if (cpi->common.frame_type == KEY_FRAME)
1107 {
1108 rate_correction_factor = cpi->key_frame_rate_correction_factor;
1109 }
1110 else
1111 {
1112 if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1113 rate_correction_factor = cpi->gf_rate_correction_factor;
1114 else
1115 rate_correction_factor = cpi->rate_correction_factor;
1116 }
1117
1118 /* Work out how big we would have expected the frame to be at this Q
1119 * given the current correction factor. Stay in double to avoid int
1120 * overflow when values are large
1121 */
1122 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));
1123
1124 /* Make some allowance for cpi->zbin_over_quant */
1125 if (cpi->zbin_over_quant > 0)
1126 {
1127 int Z = cpi->zbin_over_quant;
1128 double Factor = 0.99;
1129 double factor_adjustment = 0.01 / 256.0;
1130
1131 while (Z > 0)
1132 {
1133 Z --;
1134 projected_size_based_on_q =
1135 (int)(Factor * projected_size_based_on_q);
1136 Factor += factor_adjustment;
1137
1138 if (Factor >= 0.999)
1139 Factor = 0.999;
1140 }
1141 }
1142
1143 /* Work out a size correction factor. */
1144 if (projected_size_based_on_q > 0)
1145 correction_factor = (100 * cpi->projected_frame_size) / projected_size_based_on_q;
1146
1147 /* More heavily damped adjustment used if we have been oscillating
1148 * either side of target
1149 */
1150 switch (damp_var)
1151 {
1152 case 0:
1153 adjustment_limit = 0.75;
1154 break;
1155 case 1:
1156 adjustment_limit = 0.375;
1157 break;
1158 case 2:
1159 default:
1160 adjustment_limit = 0.25;
1161 break;
1162 }
1163
1164 if (correction_factor > 102)
1165 {
1166 /* We are not already at the worst allowable quality */
1167 correction_factor = (int)(100.5 + ((correction_factor - 100) * adjustment_limit));
1168 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1169
1170 /* Keep rate_correction_factor within limits */
1171 if (rate_correction_factor > MAX_BPB_FACTOR)
1172 rate_correction_factor = MAX_BPB_FACTOR;
1173 }
1174 else if (correction_factor < 99)
1175 {
1176 /* We are not already at the best allowable quality */
1177 correction_factor = (int)(100.5 - ((100 - correction_factor) * adjustment_limit));
1178 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1179
1180 /* Keep rate_correction_factor within limits */
1181 if (rate_correction_factor < MIN_BPB_FACTOR)
1182 rate_correction_factor = MIN_BPB_FACTOR;
1183 }
1184
1185 if (cpi->common.frame_type == KEY_FRAME)
1186 cpi->key_frame_rate_correction_factor = rate_correction_factor;
1187 else
1188 {
1189 if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1190 cpi->gf_rate_correction_factor = rate_correction_factor;
1191 else
1192 cpi->rate_correction_factor = rate_correction_factor;
1193 }
1194 }
1195
1196
vp8_regulate_q(VP8_COMP * cpi,int target_bits_per_frame)1197 int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame)
1198 {
1199 int Q = cpi->active_worst_quality;
1200
1201 /* Reset Zbin OQ value */
1202 cpi->zbin_over_quant = 0;
1203
1204 if (cpi->oxcf.fixed_q >= 0)
1205 {
1206 Q = cpi->oxcf.fixed_q;
1207
1208 if (cpi->common.frame_type == KEY_FRAME)
1209 {
1210 Q = cpi->oxcf.key_q;
1211 }
1212 else if (cpi->common.refresh_alt_ref_frame)
1213 {
1214 Q = cpi->oxcf.alt_q;
1215 }
1216 else if (cpi->common.refresh_golden_frame)
1217 {
1218 Q = cpi->oxcf.gold_q;
1219 }
1220
1221 }
1222 else
1223 {
1224 int i;
1225 int last_error = INT_MAX;
1226 int target_bits_per_mb;
1227 int bits_per_mb_at_this_q;
1228 double correction_factor;
1229
1230 /* Select the appropriate correction factor based upon type of frame. */
1231 if (cpi->common.frame_type == KEY_FRAME)
1232 correction_factor = cpi->key_frame_rate_correction_factor;
1233 else
1234 {
1235 if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1236 correction_factor = cpi->gf_rate_correction_factor;
1237 else
1238 correction_factor = cpi->rate_correction_factor;
1239 }
1240
1241 /* Calculate required scaling factor based on target frame size and
1242 * size of frame produced using previous Q
1243 */
1244 if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
1245 /* Case where we would overflow int */
1246 target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs) << BPER_MB_NORMBITS;
1247 else
1248 target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
1249
1250 i = cpi->active_best_quality;
1251
1252 do
1253 {
1254 bits_per_mb_at_this_q = (int)(.5 + correction_factor * vp8_bits_per_mb[cpi->common.frame_type][i]);
1255
1256 if (bits_per_mb_at_this_q <= target_bits_per_mb)
1257 {
1258 if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
1259 Q = i;
1260 else
1261 Q = i - 1;
1262
1263 break;
1264 }
1265 else
1266 last_error = bits_per_mb_at_this_q - target_bits_per_mb;
1267 }
1268 while (++i <= cpi->active_worst_quality);
1269
1270
1271 /* If we are at MAXQ then enable Q over-run which seeks to claw
1272 * back additional bits through things like the RD multiplier
1273 * and zero bin size.
1274 */
1275 if (Q >= MAXQ)
1276 {
1277 int zbin_oqmax;
1278
1279 double Factor = 0.99;
1280 double factor_adjustment = 0.01 / 256.0;
1281
1282 if (cpi->common.frame_type == KEY_FRAME)
1283 zbin_oqmax = 0;
1284 else if (cpi->common.refresh_alt_ref_frame || (cpi->common.refresh_golden_frame && !cpi->source_alt_ref_active))
1285 zbin_oqmax = 16;
1286 else
1287 zbin_oqmax = ZBIN_OQ_MAX;
1288
1289 /*{
1290 double Factor = (double)target_bits_per_mb/(double)bits_per_mb_at_this_q;
1291 double Oq;
1292
1293 Factor = Factor/1.2683;
1294
1295 Oq = pow( Factor, (1.0/-0.165) );
1296
1297 if ( Oq > zbin_oqmax )
1298 Oq = zbin_oqmax;
1299
1300 cpi->zbin_over_quant = (int)Oq;
1301 }*/
1302
1303 /* Each incrment in the zbin is assumed to have a fixed effect
1304 * on bitrate. This is not of course true. The effect will be
1305 * highly clip dependent and may well have sudden steps. The
1306 * idea here is to acheive higher effective quantizers than the
1307 * normal maximum by expanding the zero bin and hence
1308 * decreasing the number of low magnitude non zero coefficients.
1309 */
1310 while (cpi->zbin_over_quant < zbin_oqmax)
1311 {
1312 cpi->zbin_over_quant ++;
1313
1314 if (cpi->zbin_over_quant > zbin_oqmax)
1315 cpi->zbin_over_quant = zbin_oqmax;
1316
1317 /* Adjust bits_per_mb_at_this_q estimate */
1318 bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q);
1319 Factor += factor_adjustment;
1320
1321 if (Factor >= 0.999)
1322 Factor = 0.999;
1323
1324 /* Break out if we get down to the target rate */
1325 if (bits_per_mb_at_this_q <= target_bits_per_mb)
1326 break;
1327 }
1328
1329 }
1330 }
1331
1332 return Q;
1333 }
1334
1335
estimate_keyframe_frequency(VP8_COMP * cpi)1336 static int estimate_keyframe_frequency(VP8_COMP *cpi)
1337 {
1338 int i;
1339
1340 /* Average key frame frequency */
1341 int av_key_frame_frequency = 0;
1342
1343 /* First key frame at start of sequence is a special case. We have no
1344 * frequency data.
1345 */
1346 if (cpi->key_frame_count == 1)
1347 {
1348 /* Assume a default of 1 kf every 2 seconds, or the max kf interval,
1349 * whichever is smaller.
1350 */
1351 int key_freq = cpi->oxcf.key_freq>0 ? cpi->oxcf.key_freq : 1;
1352 av_key_frame_frequency = (int)cpi->output_frame_rate * 2;
1353
1354 if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq)
1355 av_key_frame_frequency = cpi->oxcf.key_freq;
1356
1357 cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1]
1358 = av_key_frame_frequency;
1359 }
1360 else
1361 {
1362 unsigned int total_weight = 0;
1363 int last_kf_interval =
1364 (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;
1365
1366 /* reset keyframe context and calculate weighted average of last
1367 * KEY_FRAME_CONTEXT keyframes
1368 */
1369 for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1370 {
1371 if (i < KEY_FRAME_CONTEXT - 1)
1372 cpi->prior_key_frame_distance[i]
1373 = cpi->prior_key_frame_distance[i+1];
1374 else
1375 cpi->prior_key_frame_distance[i] = last_kf_interval;
1376
1377 av_key_frame_frequency += prior_key_frame_weight[i]
1378 * cpi->prior_key_frame_distance[i];
1379 total_weight += prior_key_frame_weight[i];
1380 }
1381
1382 av_key_frame_frequency /= total_weight;
1383
1384 }
1385 return av_key_frame_frequency;
1386 }
1387
1388
vp8_adjust_key_frame_context(VP8_COMP * cpi)1389 void vp8_adjust_key_frame_context(VP8_COMP *cpi)
1390 {
1391 /* Clear down mmx registers to allow floating point in what follows */
1392 vp8_clear_system_state();
1393
1394 /* Do we have any key frame overspend to recover? */
1395 /* Two-pass overspend handled elsewhere. */
1396 if ((cpi->pass != 2)
1397 && (cpi->projected_frame_size > cpi->per_frame_bandwidth))
1398 {
1399 int overspend;
1400
1401 /* Update the count of key frame overspend to be recovered in
1402 * subsequent frames. A portion of the KF overspend is treated as gf
1403 * overspend (and hence recovered more quickly) as the kf is also a
1404 * gf. Otherwise the few frames following each kf tend to get more
1405 * bits allocated than those following other gfs.
1406 */
1407 overspend = (cpi->projected_frame_size - cpi->per_frame_bandwidth);
1408
1409 if (cpi->oxcf.number_of_layers > 1)
1410 cpi->kf_overspend_bits += overspend;
1411 else
1412 {
1413 cpi->kf_overspend_bits += overspend * 7 / 8;
1414 cpi->gf_overspend_bits += overspend * 1 / 8;
1415 }
1416
1417 /* Work out how much to try and recover per frame. */
1418 cpi->kf_bitrate_adjustment = cpi->kf_overspend_bits
1419 / estimate_keyframe_frequency(cpi);
1420 }
1421
1422 cpi->frames_since_key = 0;
1423 cpi->key_frame_count++;
1424 }
1425
1426
vp8_compute_frame_size_bounds(VP8_COMP * cpi,int * frame_under_shoot_limit,int * frame_over_shoot_limit)1427 void vp8_compute_frame_size_bounds(VP8_COMP *cpi, int *frame_under_shoot_limit, int *frame_over_shoot_limit)
1428 {
1429 /* Set-up bounds on acceptable frame size: */
1430 if (cpi->oxcf.fixed_q >= 0)
1431 {
1432 /* Fixed Q scenario: frame size never outranges target
1433 * (there is no target!)
1434 */
1435 *frame_under_shoot_limit = 0;
1436 *frame_over_shoot_limit = INT_MAX;
1437 }
1438 else
1439 {
1440 if (cpi->common.frame_type == KEY_FRAME)
1441 {
1442 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
1443 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1444 }
1445 else
1446 {
1447 if (cpi->oxcf.number_of_layers > 1 ||
1448 cpi->common.refresh_alt_ref_frame ||
1449 cpi->common.refresh_golden_frame)
1450 {
1451 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
1452 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1453 }
1454 else
1455 {
1456 /* For CBR take buffer fullness into account */
1457 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
1458 {
1459 if (cpi->buffer_level >= ((cpi->oxcf.optimal_buffer_level + cpi->oxcf.maximum_buffer_size) >> 1))
1460 {
1461 /* Buffer is too full so relax overshoot and tighten
1462 * undershoot
1463 */
1464 *frame_over_shoot_limit = cpi->this_frame_target * 12 / 8;
1465 *frame_under_shoot_limit = cpi->this_frame_target * 6 / 8;
1466 }
1467 else if (cpi->buffer_level <= (cpi->oxcf.optimal_buffer_level >> 1))
1468 {
1469 /* Buffer is too low so relax undershoot and tighten
1470 * overshoot
1471 */
1472 *frame_over_shoot_limit = cpi->this_frame_target * 10 / 8;
1473 *frame_under_shoot_limit = cpi->this_frame_target * 4 / 8;
1474 }
1475 else
1476 {
1477 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1478 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1479 }
1480 }
1481 /* VBR and CQ mode */
1482 /* Note that tighter restrictions here can help quality
1483 * but hurt encode speed
1484 */
1485 else
1486 {
1487 /* Stron overshoot limit for constrained quality */
1488 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
1489 {
1490 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1491 *frame_under_shoot_limit = cpi->this_frame_target * 2 / 8;
1492 }
1493 else
1494 {
1495 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1496 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1497 }
1498 }
1499 }
1500 }
1501
1502 /* For very small rate targets where the fractional adjustment
1503 * (eg * 7/8) may be tiny make sure there is at least a minimum
1504 * range.
1505 */
1506 *frame_over_shoot_limit += 200;
1507 *frame_under_shoot_limit -= 200;
1508 if ( *frame_under_shoot_limit < 0 )
1509 *frame_under_shoot_limit = 0;
1510
1511 }
1512 }
1513
1514
1515 /* return of 0 means drop frame */
vp8_pick_frame_size(VP8_COMP * cpi)1516 int vp8_pick_frame_size(VP8_COMP *cpi)
1517 {
1518 VP8_COMMON *cm = &cpi->common;
1519
1520 if (cm->frame_type == KEY_FRAME)
1521 calc_iframe_target_size(cpi);
1522 else
1523 {
1524 calc_pframe_target_size(cpi);
1525
1526 /* Check if we're dropping the frame: */
1527 if (cpi->drop_frame)
1528 {
1529 cpi->drop_frame = 0;
1530 return 0;
1531 }
1532 }
1533 return 1;
1534 }
1535