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 static const int gf_adjust_table[101] =
178 {
179 100,
180 115, 130, 145, 160, 175, 190, 200, 210, 220, 230,
181 240, 260, 270, 280, 290, 300, 310, 320, 330, 340,
182 350, 360, 370, 380, 390, 400, 400, 400, 400, 400,
183 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
184 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
185 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
186 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
187 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
188 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
189 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
190 };
191
192 static const int gf_intra_usage_adjustment[20] =
193 {
194 125, 120, 115, 110, 105, 100, 95, 85, 80, 75,
195 70, 65, 60, 55, 50, 50, 50, 50, 50, 50,
196 };
197
198 static const int gf_interval_table[101] =
199 {
200 7,
201 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
202 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
203 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
204 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
205 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
206 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
207 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
208 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
209 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
210 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
211 };
212
213 static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = { 1, 2, 3, 4, 5 };
214
215
vp8_save_coding_context(VP8_COMP * cpi)216 void vp8_save_coding_context(VP8_COMP *cpi)
217 {
218 CODING_CONTEXT *const cc = & cpi->coding_context;
219
220 /* Stores a snapshot of key state variables which can subsequently be
221 * restored with a call to vp8_restore_coding_context. These functions are
222 * intended for use in a re-code loop in vp8_compress_frame where the
223 * quantizer value is adjusted between loop iterations.
224 */
225
226 cc->frames_since_key = cpi->frames_since_key;
227 cc->filter_level = cpi->common.filter_level;
228 cc->frames_till_gf_update_due = cpi->frames_till_gf_update_due;
229 cc->frames_since_golden = cpi->frames_since_golden;
230
231 vp8_copy(cc->mvc, cpi->common.fc.mvc);
232 vp8_copy(cc->mvcosts, cpi->rd_costs.mvcosts);
233
234 vp8_copy(cc->ymode_prob, cpi->common.fc.ymode_prob);
235 vp8_copy(cc->uv_mode_prob, cpi->common.fc.uv_mode_prob);
236
237 vp8_copy(cc->ymode_count, cpi->mb.ymode_count);
238 vp8_copy(cc->uv_mode_count, cpi->mb.uv_mode_count);
239
240
241 /* Stats */
242 #ifdef MODE_STATS
243 vp8_copy(cc->y_modes, y_modes);
244 vp8_copy(cc->uv_modes, uv_modes);
245 vp8_copy(cc->b_modes, b_modes);
246 vp8_copy(cc->inter_y_modes, inter_y_modes);
247 vp8_copy(cc->inter_uv_modes, inter_uv_modes);
248 vp8_copy(cc->inter_b_modes, inter_b_modes);
249 #endif
250
251 cc->this_frame_percent_intra = cpi->this_frame_percent_intra;
252 }
253
254
vp8_restore_coding_context(VP8_COMP * cpi)255 void vp8_restore_coding_context(VP8_COMP *cpi)
256 {
257 CODING_CONTEXT *const cc = & cpi->coding_context;
258
259 /* Restore key state variables to the snapshot state stored in the
260 * previous call to vp8_save_coding_context.
261 */
262
263 cpi->frames_since_key = cc->frames_since_key;
264 cpi->common.filter_level = cc->filter_level;
265 cpi->frames_till_gf_update_due = cc->frames_till_gf_update_due;
266 cpi->frames_since_golden = cc->frames_since_golden;
267
268 vp8_copy(cpi->common.fc.mvc, cc->mvc);
269
270 vp8_copy(cpi->rd_costs.mvcosts, cc->mvcosts);
271
272 vp8_copy(cpi->common.fc.ymode_prob, cc->ymode_prob);
273 vp8_copy(cpi->common.fc.uv_mode_prob, cc->uv_mode_prob);
274
275 vp8_copy(cpi->mb.ymode_count, cc->ymode_count);
276 vp8_copy(cpi->mb.uv_mode_count, cc->uv_mode_count);
277
278 /* Stats */
279 #ifdef MODE_STATS
280 vp8_copy(y_modes, cc->y_modes);
281 vp8_copy(uv_modes, cc->uv_modes);
282 vp8_copy(b_modes, cc->b_modes);
283 vp8_copy(inter_y_modes, cc->inter_y_modes);
284 vp8_copy(inter_uv_modes, cc->inter_uv_modes);
285 vp8_copy(inter_b_modes, cc->inter_b_modes);
286 #endif
287
288
289 cpi->this_frame_percent_intra = cc->this_frame_percent_intra;
290 }
291
292
vp8_setup_key_frame(VP8_COMP * cpi)293 void vp8_setup_key_frame(VP8_COMP *cpi)
294 {
295 /* Setup for Key frame: */
296
297 vp8_default_coef_probs(& cpi->common);
298
299 vpx_memcpy(cpi->common.fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));
300 {
301 int flag[2] = {1, 1};
302 vp8_build_component_cost_table(cpi->mb.mvcost, (const MV_CONTEXT *) cpi->common.fc.mvc, flag);
303 }
304
305 /* Make sure we initialize separate contexts for altref,gold, and normal.
306 * TODO shouldn't need 3 different copies of structure to do this!
307 */
308 vpx_memcpy(&cpi->lfc_a, &cpi->common.fc, sizeof(cpi->common.fc));
309 vpx_memcpy(&cpi->lfc_g, &cpi->common.fc, sizeof(cpi->common.fc));
310 vpx_memcpy(&cpi->lfc_n, &cpi->common.fc, sizeof(cpi->common.fc));
311
312 cpi->common.filter_level = cpi->common.base_qindex * 3 / 8 ;
313
314 /* Provisional interval before next GF */
315 if (cpi->auto_gold)
316 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
317 else
318 cpi->frames_till_gf_update_due = DEFAULT_GF_INTERVAL;
319
320 cpi->common.refresh_golden_frame = 1;
321 cpi->common.refresh_alt_ref_frame = 1;
322 }
323
324
estimate_bits_at_q(int frame_kind,int Q,int MBs,double correction_factor)325 static int estimate_bits_at_q(int frame_kind, int Q, int MBs,
326 double correction_factor)
327 {
328 int Bpm = (int)(.5 + correction_factor * vp8_bits_per_mb[frame_kind][Q]);
329
330 /* Attempt to retain reasonable accuracy without overflow. The cutoff is
331 * chosen such that the maximum product of Bpm and MBs fits 31 bits. The
332 * largest Bpm takes 20 bits.
333 */
334 if (MBs > (1 << 11))
335 return (Bpm >> BPER_MB_NORMBITS) * MBs;
336 else
337 return (Bpm * MBs) >> BPER_MB_NORMBITS;
338 }
339
340
calc_iframe_target_size(VP8_COMP * cpi)341 static void calc_iframe_target_size(VP8_COMP *cpi)
342 {
343 /* boost defaults to half second */
344 int kf_boost;
345 uint64_t target;
346
347 /* Clear down mmx registers to allow floating point in what follows */
348 vp8_clear_system_state();
349
350 if (cpi->oxcf.fixed_q >= 0)
351 {
352 int Q = cpi->oxcf.key_q;
353
354 target = estimate_bits_at_q(INTRA_FRAME, Q, cpi->common.MBs,
355 cpi->key_frame_rate_correction_factor);
356 }
357 else if (cpi->pass == 2)
358 {
359 /* New Two pass RC */
360 target = cpi->per_frame_bandwidth;
361 }
362 /* First Frame is a special case */
363 else if (cpi->common.current_video_frame == 0)
364 {
365 /* 1 Pass there is no information on which to base size so use
366 * bandwidth per second * fraction of the initial buffer
367 * level
368 */
369 target = cpi->oxcf.starting_buffer_level / 2;
370
371 if(target > cpi->oxcf.target_bandwidth * 3 / 2)
372 target = cpi->oxcf.target_bandwidth * 3 / 2;
373 }
374 else
375 {
376 /* if this keyframe was forced, use a more recent Q estimate */
377 int Q = (cpi->common.frame_flags & FRAMEFLAGS_KEY)
378 ? cpi->avg_frame_qindex : cpi->ni_av_qi;
379
380 int initial_boost = 32; /* |3.0 * per_frame_bandwidth| */
381 /* Boost depends somewhat on frame rate: only used for 1 layer case. */
382 if (cpi->oxcf.number_of_layers == 1) {
383 kf_boost = MAX(initial_boost, (int)(2 * cpi->output_framerate - 16));
384 }
385 else {
386 /* Initial factor: set target size to: |3.0 * per_frame_bandwidth|. */
387 kf_boost = initial_boost;
388 }
389
390 /* adjustment up based on q: this factor ranges from ~1.2 to 2.2. */
391 kf_boost = kf_boost * kf_boost_qadjustment[Q] / 100;
392
393 /* frame separation adjustment ( down) */
394 if (cpi->frames_since_key < cpi->output_framerate / 2)
395 kf_boost = (int)(kf_boost
396 * cpi->frames_since_key / (cpi->output_framerate / 2));
397
398 /* Minimal target size is |2* per_frame_bandwidth|. */
399 if (kf_boost < 16)
400 kf_boost = 16;
401
402 target = ((16 + kf_boost) * cpi->per_frame_bandwidth) >> 4;
403 }
404
405
406 if (cpi->oxcf.rc_max_intra_bitrate_pct)
407 {
408 unsigned int max_rate = cpi->per_frame_bandwidth
409 * cpi->oxcf.rc_max_intra_bitrate_pct / 100;
410
411 if (target > max_rate)
412 target = max_rate;
413 }
414
415 cpi->this_frame_target = (int)target;
416
417 /* TODO: if we separate rate targeting from Q targetting, move this.
418 * Reset the active worst quality to the baseline value for key frames.
419 */
420 if (cpi->pass != 2)
421 cpi->active_worst_quality = cpi->worst_quality;
422
423 #if 0
424 {
425 FILE *f;
426
427 f = fopen("kf_boost.stt", "a");
428 fprintf(f, " %8u %10d %10d %10d\n",
429 cpi->common.current_video_frame, cpi->gfu_boost, cpi->baseline_gf_interval, cpi->source_alt_ref_pending);
430
431 fclose(f);
432 }
433 #endif
434 }
435
436
437 /* Do the best we can to define the parameters for the next GF based on what
438 * information we have available.
439 */
calc_gf_params(VP8_COMP * cpi)440 static void calc_gf_params(VP8_COMP *cpi)
441 {
442 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
443 int Boost = 0;
444
445 int gf_frame_useage = 0; /* Golden frame useage since last GF */
446 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
447 cpi->recent_ref_frame_usage[LAST_FRAME] +
448 cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
449 cpi->recent_ref_frame_usage[ALTREF_FRAME];
450
451 int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols);
452
453 if (tot_mbs)
454 gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs;
455
456 if (pct_gf_active > gf_frame_useage)
457 gf_frame_useage = pct_gf_active;
458
459 /* Not two pass */
460 if (cpi->pass != 2)
461 {
462 /* Single Pass lagged mode: TBD */
463 if (0)
464 {
465 }
466
467 /* Single Pass compression: Has to use current and historical data */
468 else
469 {
470 #if 0
471 /* Experimental code */
472 int index = cpi->one_pass_frame_index;
473 int frames_to_scan = (cpi->max_gf_interval <= MAX_LAG_BUFFERS) ? cpi->max_gf_interval : MAX_LAG_BUFFERS;
474
475 /* ************** Experimental code - incomplete */
476 /*
477 double decay_val = 1.0;
478 double IIAccumulator = 0.0;
479 double last_iiaccumulator = 0.0;
480 double IIRatio;
481
482 cpi->one_pass_frame_index = cpi->common.current_video_frame%MAX_LAG_BUFFERS;
483
484 for ( i = 0; i < (frames_to_scan - 1); i++ )
485 {
486 if ( index < 0 )
487 index = MAX_LAG_BUFFERS;
488 index --;
489
490 if ( cpi->one_pass_frame_stats[index].frame_coded_error > 0.0 )
491 {
492 IIRatio = cpi->one_pass_frame_stats[index].frame_intra_error / cpi->one_pass_frame_stats[index].frame_coded_error;
493
494 if ( IIRatio > 30.0 )
495 IIRatio = 30.0;
496 }
497 else
498 IIRatio = 30.0;
499
500 IIAccumulator += IIRatio * decay_val;
501
502 decay_val = decay_val * cpi->one_pass_frame_stats[index].frame_pcnt_inter;
503
504 if ( (i > MIN_GF_INTERVAL) &&
505 ((IIAccumulator - last_iiaccumulator) < 2.0) )
506 {
507 break;
508 }
509 last_iiaccumulator = IIAccumulator;
510 }
511
512 Boost = IIAccumulator*100.0/16.0;
513 cpi->baseline_gf_interval = i;
514
515 */
516 #else
517
518 /*************************************************************/
519 /* OLD code */
520
521 /* Adjust boost based upon ambient Q */
522 Boost = GFQ_ADJUSTMENT;
523
524 /* Adjust based upon most recently measure intra useage */
525 Boost = Boost * gf_intra_usage_adjustment[(cpi->this_frame_percent_intra < 15) ? cpi->this_frame_percent_intra : 14] / 100;
526
527 /* Adjust gf boost based upon GF usage since last GF */
528 Boost = Boost * gf_adjust_table[gf_frame_useage] / 100;
529 #endif
530 }
531
532 /* golden frame boost without recode loop often goes awry. be
533 * safe by keeping numbers down.
534 */
535 if (!cpi->sf.recode_loop)
536 {
537 if (cpi->compressor_speed == 2)
538 Boost = Boost / 2;
539 }
540
541 /* Apply an upper limit based on Q for 1 pass encodes */
542 if (Boost > kf_gf_boost_qlimits[Q] && (cpi->pass == 0))
543 Boost = kf_gf_boost_qlimits[Q];
544
545 /* Apply lower limits to boost. */
546 else if (Boost < 110)
547 Boost = 110;
548
549 /* Note the boost used */
550 cpi->last_boost = Boost;
551
552 }
553
554 /* Estimate next interval
555 * This is updated once the real frame size/boost is known.
556 */
557 if (cpi->oxcf.fixed_q == -1)
558 {
559 if (cpi->pass == 2) /* 2 Pass */
560 {
561 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
562 }
563 else /* 1 Pass */
564 {
565 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
566
567 if (cpi->last_boost > 750)
568 cpi->frames_till_gf_update_due++;
569
570 if (cpi->last_boost > 1000)
571 cpi->frames_till_gf_update_due++;
572
573 if (cpi->last_boost > 1250)
574 cpi->frames_till_gf_update_due++;
575
576 if (cpi->last_boost >= 1500)
577 cpi->frames_till_gf_update_due ++;
578
579 if (gf_interval_table[gf_frame_useage] > cpi->frames_till_gf_update_due)
580 cpi->frames_till_gf_update_due = gf_interval_table[gf_frame_useage];
581
582 if (cpi->frames_till_gf_update_due > cpi->max_gf_interval)
583 cpi->frames_till_gf_update_due = cpi->max_gf_interval;
584 }
585 }
586 else
587 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
588
589 /* ARF on or off */
590 if (cpi->pass != 2)
591 {
592 /* For now Alt ref is not allowed except in 2 pass modes. */
593 cpi->source_alt_ref_pending = 0;
594
595 /*if ( cpi->oxcf.fixed_q == -1)
596 {
597 if ( cpi->oxcf.play_alternate && (cpi->last_boost > (100 + (AF_THRESH*cpi->frames_till_gf_update_due)) ) )
598 cpi->source_alt_ref_pending = 1;
599 else
600 cpi->source_alt_ref_pending = 0;
601 }*/
602 }
603 }
604
605
calc_pframe_target_size(VP8_COMP * cpi)606 static void calc_pframe_target_size(VP8_COMP *cpi)
607 {
608 int min_frame_target;
609 int old_per_frame_bandwidth = cpi->per_frame_bandwidth;
610
611 if ( cpi->current_layer > 0)
612 cpi->per_frame_bandwidth =
613 cpi->layer_context[cpi->current_layer].avg_frame_size_for_layer;
614
615 min_frame_target = 0;
616
617 if (cpi->pass == 2)
618 {
619 min_frame_target = cpi->min_frame_bandwidth;
620
621 if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5))
622 min_frame_target = cpi->av_per_frame_bandwidth >> 5;
623 }
624 else if (min_frame_target < cpi->per_frame_bandwidth / 4)
625 min_frame_target = cpi->per_frame_bandwidth / 4;
626
627
628 /* Special alt reference frame case */
629 if((cpi->common.refresh_alt_ref_frame) && (cpi->oxcf.number_of_layers == 1))
630 {
631 if (cpi->pass == 2)
632 {
633 /* Per frame bit target for the alt ref frame */
634 cpi->per_frame_bandwidth = cpi->twopass.gf_bits;
635 cpi->this_frame_target = cpi->per_frame_bandwidth;
636 }
637
638 /* One Pass ??? TBD */
639 }
640
641 /* Normal frames (gf,and inter) */
642 else
643 {
644 /* 2 pass */
645 if (cpi->pass == 2)
646 {
647 cpi->this_frame_target = cpi->per_frame_bandwidth;
648 }
649 /* 1 pass */
650 else
651 {
652 int Adjustment;
653 /* Make rate adjustment to recover bits spent in key frame
654 * Test to see if the key frame inter data rate correction
655 * should still be in force
656 */
657 if (cpi->kf_overspend_bits > 0)
658 {
659 Adjustment = (cpi->kf_bitrate_adjustment <= cpi->kf_overspend_bits) ? cpi->kf_bitrate_adjustment : cpi->kf_overspend_bits;
660
661 if (Adjustment > (cpi->per_frame_bandwidth - min_frame_target))
662 Adjustment = (cpi->per_frame_bandwidth - min_frame_target);
663
664 cpi->kf_overspend_bits -= Adjustment;
665
666 /* Calculate an inter frame bandwidth target for the next
667 * few frames designed to recover any extra bits spent on
668 * the key frame.
669 */
670 cpi->this_frame_target = cpi->per_frame_bandwidth - Adjustment;
671
672 if (cpi->this_frame_target < min_frame_target)
673 cpi->this_frame_target = min_frame_target;
674 }
675 else
676 cpi->this_frame_target = cpi->per_frame_bandwidth;
677
678 /* If appropriate make an adjustment to recover bits spent on a
679 * recent GF
680 */
681 if ((cpi->gf_overspend_bits > 0) && (cpi->this_frame_target > min_frame_target))
682 {
683 Adjustment = (cpi->non_gf_bitrate_adjustment <= cpi->gf_overspend_bits) ? cpi->non_gf_bitrate_adjustment : cpi->gf_overspend_bits;
684
685 if (Adjustment > (cpi->this_frame_target - min_frame_target))
686 Adjustment = (cpi->this_frame_target - min_frame_target);
687
688 cpi->gf_overspend_bits -= Adjustment;
689 cpi->this_frame_target -= Adjustment;
690 }
691
692 /* Apply small + and - boosts for non gf frames */
693 if ((cpi->last_boost > 150) && (cpi->frames_till_gf_update_due > 0) &&
694 (cpi->current_gf_interval >= (MIN_GF_INTERVAL << 1)))
695 {
696 /* % Adjustment limited to the range 1% to 10% */
697 Adjustment = (cpi->last_boost - 100) >> 5;
698
699 if (Adjustment < 1)
700 Adjustment = 1;
701 else if (Adjustment > 10)
702 Adjustment = 10;
703
704 /* Convert to bits */
705 Adjustment = (cpi->this_frame_target * Adjustment) / 100;
706
707 if (Adjustment > (cpi->this_frame_target - min_frame_target))
708 Adjustment = (cpi->this_frame_target - min_frame_target);
709
710 if (cpi->frames_since_golden == (cpi->current_gf_interval >> 1))
711 cpi->this_frame_target += ((cpi->current_gf_interval - 1) * Adjustment);
712 else
713 cpi->this_frame_target -= Adjustment;
714 }
715 }
716 }
717
718 /* Sanity check that the total sum of adjustments is not above the
719 * maximum allowed That is that having allowed for KF and GF penalties
720 * we have not pushed the current interframe target to low. If the
721 * adjustment we apply here is not capable of recovering all the extra
722 * bits we have spent in the KF or GF then the remainder will have to
723 * be recovered over a longer time span via other buffer / rate control
724 * mechanisms.
725 */
726 if (cpi->this_frame_target < min_frame_target)
727 cpi->this_frame_target = min_frame_target;
728
729 if (!cpi->common.refresh_alt_ref_frame)
730 /* Note the baseline target data rate for this inter frame. */
731 cpi->inter_frame_target = cpi->this_frame_target;
732
733 /* One Pass specific code */
734 if (cpi->pass == 0)
735 {
736 /* Adapt target frame size with respect to any buffering constraints: */
737 if (cpi->buffered_mode)
738 {
739 int one_percent_bits = (int)
740 (1 + cpi->oxcf.optimal_buffer_level / 100);
741
742 if ((cpi->buffer_level < cpi->oxcf.optimal_buffer_level) ||
743 (cpi->bits_off_target < cpi->oxcf.optimal_buffer_level))
744 {
745 int percent_low = 0;
746
747 /* Decide whether or not we need to adjust the frame data
748 * rate target.
749 *
750 * If we are are below the optimal buffer fullness level
751 * and adherence to buffering constraints is important to
752 * the end usage then adjust the per frame target.
753 */
754 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
755 (cpi->buffer_level < cpi->oxcf.optimal_buffer_level))
756 {
757 percent_low = (int)
758 ((cpi->oxcf.optimal_buffer_level - cpi->buffer_level) /
759 one_percent_bits);
760 }
761 /* Are we overshooting the long term clip data rate... */
762 else if (cpi->bits_off_target < 0)
763 {
764 /* Adjust per frame data target downwards to compensate. */
765 percent_low = (int)(100 * -cpi->bits_off_target /
766 (cpi->total_byte_count * 8));
767 }
768
769 if (percent_low > cpi->oxcf.under_shoot_pct)
770 percent_low = cpi->oxcf.under_shoot_pct;
771 else if (percent_low < 0)
772 percent_low = 0;
773
774 /* lower the target bandwidth for this frame. */
775 cpi->this_frame_target -=
776 (cpi->this_frame_target * percent_low) / 200;
777
778 /* Are we using allowing control of active_worst_allowed_q
779 * according to buffer level.
780 */
781 if (cpi->auto_worst_q && cpi->ni_frames > 150)
782 {
783 int64_t critical_buffer_level;
784
785 /* For streaming applications the most important factor is
786 * cpi->buffer_level as this takes into account the
787 * specified short term buffering constraints. However,
788 * hitting the long term clip data rate target is also
789 * important.
790 */
791 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
792 {
793 /* Take the smaller of cpi->buffer_level and
794 * cpi->bits_off_target
795 */
796 critical_buffer_level =
797 (cpi->buffer_level < cpi->bits_off_target)
798 ? cpi->buffer_level : cpi->bits_off_target;
799 }
800 /* For local file playback short term buffering constraints
801 * are less of an issue
802 */
803 else
804 {
805 /* Consider only how we are doing for the clip as a
806 * whole
807 */
808 critical_buffer_level = cpi->bits_off_target;
809 }
810
811 /* Set the active worst quality based upon the selected
812 * buffer fullness number.
813 */
814 if (critical_buffer_level < cpi->oxcf.optimal_buffer_level)
815 {
816 if ( critical_buffer_level >
817 (cpi->oxcf.optimal_buffer_level >> 2) )
818 {
819 int64_t qadjustment_range =
820 cpi->worst_quality - cpi->ni_av_qi;
821 int64_t above_base =
822 (critical_buffer_level -
823 (cpi->oxcf.optimal_buffer_level >> 2));
824
825 /* Step active worst quality down from
826 * cpi->ni_av_qi when (critical_buffer_level ==
827 * cpi->optimal_buffer_level) to
828 * cpi->worst_quality when
829 * (critical_buffer_level ==
830 * cpi->optimal_buffer_level >> 2)
831 */
832 cpi->active_worst_quality =
833 cpi->worst_quality -
834 (int)((qadjustment_range * above_base) /
835 (cpi->oxcf.optimal_buffer_level*3>>2));
836 }
837 else
838 {
839 cpi->active_worst_quality = cpi->worst_quality;
840 }
841 }
842 else
843 {
844 cpi->active_worst_quality = cpi->ni_av_qi;
845 }
846 }
847 else
848 {
849 cpi->active_worst_quality = cpi->worst_quality;
850 }
851 }
852 else
853 {
854 int percent_high = 0;
855
856 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
857 && (cpi->buffer_level > cpi->oxcf.optimal_buffer_level))
858 {
859 percent_high = (int)((cpi->buffer_level
860 - cpi->oxcf.optimal_buffer_level)
861 / one_percent_bits);
862 }
863 else if (cpi->bits_off_target > cpi->oxcf.optimal_buffer_level)
864 {
865 percent_high = (int)((100 * cpi->bits_off_target)
866 / (cpi->total_byte_count * 8));
867 }
868
869 if (percent_high > cpi->oxcf.over_shoot_pct)
870 percent_high = cpi->oxcf.over_shoot_pct;
871 else if (percent_high < 0)
872 percent_high = 0;
873
874 cpi->this_frame_target += (cpi->this_frame_target *
875 percent_high) / 200;
876
877 /* Are we allowing control of active_worst_allowed_q according
878 * to buffer level.
879 */
880 if (cpi->auto_worst_q && cpi->ni_frames > 150)
881 {
882 /* When using the relaxed buffer model stick to the
883 * user specified value
884 */
885 cpi->active_worst_quality = cpi->ni_av_qi;
886 }
887 else
888 {
889 cpi->active_worst_quality = cpi->worst_quality;
890 }
891 }
892
893 /* Set active_best_quality to prevent quality rising too high */
894 cpi->active_best_quality = cpi->best_quality;
895
896 /* Worst quality obviously must not be better than best quality */
897 if (cpi->active_worst_quality <= cpi->active_best_quality)
898 cpi->active_worst_quality = cpi->active_best_quality + 1;
899
900 if(cpi->active_worst_quality > 127)
901 cpi->active_worst_quality = 127;
902 }
903 /* Unbuffered mode (eg. video conferencing) */
904 else
905 {
906 /* Set the active worst quality */
907 cpi->active_worst_quality = cpi->worst_quality;
908 }
909
910 /* Special trap for constrained quality mode
911 * "active_worst_quality" may never drop below cq level
912 * for any frame type.
913 */
914 if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY &&
915 cpi->active_worst_quality < cpi->cq_target_quality)
916 {
917 cpi->active_worst_quality = cpi->cq_target_quality;
918 }
919 }
920
921 /* Test to see if we have to drop a frame
922 * The auto-drop frame code is only used in buffered mode.
923 * In unbufferd mode (eg vide conferencing) the descision to
924 * code or drop a frame is made outside the codec in response to real
925 * world comms or buffer considerations.
926 */
927 if (cpi->drop_frames_allowed &&
928 (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
929 ((cpi->common.frame_type != KEY_FRAME)))
930 {
931 /* Check for a buffer underun-crisis in which case we have to drop
932 * a frame
933 */
934 if ((cpi->buffer_level < 0))
935 {
936 #if 0
937 FILE *f = fopen("dec.stt", "a");
938 fprintf(f, "%10d %10d %10d %10d ***** BUFFER EMPTY\n",
939 (int) cpi->common.current_video_frame,
940 cpi->decimation_factor, cpi->common.horiz_scale,
941 (cpi->buffer_level * 100) / cpi->oxcf.optimal_buffer_level);
942 fclose(f);
943 #endif
944 cpi->drop_frame = 1;
945
946 /* Update the buffer level variable. */
947 cpi->bits_off_target += cpi->av_per_frame_bandwidth;
948 if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
949 cpi->bits_off_target = (int)cpi->oxcf.maximum_buffer_size;
950 cpi->buffer_level = cpi->bits_off_target;
951
952 if (cpi->oxcf.number_of_layers > 1) {
953 unsigned int i;
954
955 // Propagate bits saved by dropping the frame to higher layers.
956 for (i = cpi->current_layer + 1; i < cpi->oxcf.number_of_layers;
957 i++) {
958 LAYER_CONTEXT *lc = &cpi->layer_context[i];
959 lc->bits_off_target += (int)(lc->target_bandwidth /
960 lc->framerate);
961 if (lc->bits_off_target > lc->maximum_buffer_size)
962 lc->bits_off_target = lc->maximum_buffer_size;
963 lc->buffer_level = lc->bits_off_target;
964 }
965 }
966 }
967 }
968
969 /* Adjust target frame size for Golden Frames: */
970 if (cpi->oxcf.error_resilient_mode == 0 &&
971 (cpi->frames_till_gf_update_due == 0) && !cpi->drop_frame)
972 {
973 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
974
975 int gf_frame_useage = 0; /* Golden frame useage since last GF */
976 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
977 cpi->recent_ref_frame_usage[LAST_FRAME] +
978 cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
979 cpi->recent_ref_frame_usage[ALTREF_FRAME];
980
981 int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols);
982
983 if (tot_mbs)
984 gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs;
985
986 if (pct_gf_active > gf_frame_useage)
987 gf_frame_useage = pct_gf_active;
988
989 /* Is a fixed manual GF frequency being used */
990 if (cpi->auto_gold)
991 {
992 /* For one pass throw a GF if recent frame intra useage is
993 * low or the GF useage is high
994 */
995 if ((cpi->pass == 0) && (cpi->this_frame_percent_intra < 15 || gf_frame_useage >= 5))
996 cpi->common.refresh_golden_frame = 1;
997
998 /* Two pass GF descision */
999 else if (cpi->pass == 2)
1000 cpi->common.refresh_golden_frame = 1;
1001 }
1002
1003 #if 0
1004
1005 /* Debug stats */
1006 if (0)
1007 {
1008 FILE *f;
1009
1010 f = fopen("gf_useaget.stt", "a");
1011 fprintf(f, " %8ld %10ld %10ld %10ld %10ld\n",
1012 cpi->common.current_video_frame, cpi->gfu_boost, GFQ_ADJUSTMENT, cpi->gfu_boost, gf_frame_useage);
1013 fclose(f);
1014 }
1015
1016 #endif
1017
1018 if (cpi->common.refresh_golden_frame == 1)
1019 {
1020 #if 0
1021
1022 if (0)
1023 {
1024 FILE *f;
1025
1026 f = fopen("GFexit.stt", "a");
1027 fprintf(f, "%8ld GF coded\n", cpi->common.current_video_frame);
1028 fclose(f);
1029 }
1030
1031 #endif
1032
1033 if (cpi->auto_adjust_gold_quantizer)
1034 {
1035 calc_gf_params(cpi);
1036 }
1037
1038 /* If we are using alternate ref instead of gf then do not apply the
1039 * boost It will instead be applied to the altref update Jims
1040 * modified boost
1041 */
1042 if (!cpi->source_alt_ref_active)
1043 {
1044 if (cpi->oxcf.fixed_q < 0)
1045 {
1046 if (cpi->pass == 2)
1047 {
1048 /* The spend on the GF is defined in the two pass
1049 * code for two pass encodes
1050 */
1051 cpi->this_frame_target = cpi->per_frame_bandwidth;
1052 }
1053 else
1054 {
1055 int Boost = cpi->last_boost;
1056 int frames_in_section = cpi->frames_till_gf_update_due + 1;
1057 int allocation_chunks = (frames_in_section * 100) + (Boost - 100);
1058 int bits_in_section = cpi->inter_frame_target * frames_in_section;
1059
1060 /* Normalize Altboost and allocations chunck down to
1061 * prevent overflow
1062 */
1063 while (Boost > 1000)
1064 {
1065 Boost /= 2;
1066 allocation_chunks /= 2;
1067 }
1068
1069 /* Avoid loss of precision but avoid overflow */
1070 if ((bits_in_section >> 7) > allocation_chunks)
1071 cpi->this_frame_target = Boost * (bits_in_section / allocation_chunks);
1072 else
1073 cpi->this_frame_target = (Boost * bits_in_section) / allocation_chunks;
1074 }
1075 }
1076 else
1077 cpi->this_frame_target =
1078 (estimate_bits_at_q(1, Q, cpi->common.MBs, 1.0)
1079 * cpi->last_boost) / 100;
1080
1081 }
1082 /* If there is an active ARF at this location use the minimum
1083 * bits on this frame even if it is a contructed arf.
1084 * The active maximum quantizer insures that an appropriate
1085 * number of bits will be spent if needed for contstructed ARFs.
1086 */
1087 else
1088 {
1089 cpi->this_frame_target = 0;
1090 }
1091
1092 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
1093
1094 }
1095 }
1096
1097 cpi->per_frame_bandwidth = old_per_frame_bandwidth;
1098 }
1099
1100
vp8_update_rate_correction_factors(VP8_COMP * cpi,int damp_var)1101 void vp8_update_rate_correction_factors(VP8_COMP *cpi, int damp_var)
1102 {
1103 int Q = cpi->common.base_qindex;
1104 int correction_factor = 100;
1105 double rate_correction_factor;
1106 double adjustment_limit;
1107
1108 int projected_size_based_on_q = 0;
1109
1110 /* Clear down mmx registers to allow floating point in what follows */
1111 vp8_clear_system_state();
1112
1113 if (cpi->common.frame_type == KEY_FRAME)
1114 {
1115 rate_correction_factor = cpi->key_frame_rate_correction_factor;
1116 }
1117 else
1118 {
1119 if (cpi->oxcf.number_of_layers == 1 &&
1120 (cpi->common.refresh_alt_ref_frame ||
1121 cpi->common.refresh_golden_frame))
1122 rate_correction_factor = cpi->gf_rate_correction_factor;
1123 else
1124 rate_correction_factor = cpi->rate_correction_factor;
1125 }
1126
1127 /* Work out how big we would have expected the frame to be at this Q
1128 * given the current correction factor. Stay in double to avoid int
1129 * overflow when values are large
1130 */
1131 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));
1132
1133 /* Make some allowance for cpi->zbin_over_quant */
1134 if (cpi->mb.zbin_over_quant > 0)
1135 {
1136 int Z = cpi->mb.zbin_over_quant;
1137 double Factor = 0.99;
1138 double factor_adjustment = 0.01 / 256.0;
1139
1140 while (Z > 0)
1141 {
1142 Z --;
1143 projected_size_based_on_q =
1144 (int)(Factor * projected_size_based_on_q);
1145 Factor += factor_adjustment;
1146
1147 if (Factor >= 0.999)
1148 Factor = 0.999;
1149 }
1150 }
1151
1152 /* Work out a size correction factor. */
1153 if (projected_size_based_on_q > 0)
1154 correction_factor = (100 * cpi->projected_frame_size) / projected_size_based_on_q;
1155
1156 /* More heavily damped adjustment used if we have been oscillating
1157 * either side of target
1158 */
1159 switch (damp_var)
1160 {
1161 case 0:
1162 adjustment_limit = 0.75;
1163 break;
1164 case 1:
1165 adjustment_limit = 0.375;
1166 break;
1167 case 2:
1168 default:
1169 adjustment_limit = 0.25;
1170 break;
1171 }
1172
1173 if (correction_factor > 102)
1174 {
1175 /* We are not already at the worst allowable quality */
1176 correction_factor = (int)(100.5 + ((correction_factor - 100) * adjustment_limit));
1177 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1178
1179 /* Keep rate_correction_factor within limits */
1180 if (rate_correction_factor > MAX_BPB_FACTOR)
1181 rate_correction_factor = MAX_BPB_FACTOR;
1182 }
1183 else if (correction_factor < 99)
1184 {
1185 /* We are not already at the best allowable quality */
1186 correction_factor = (int)(100.5 - ((100 - correction_factor) * adjustment_limit));
1187 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1188
1189 /* Keep rate_correction_factor within limits */
1190 if (rate_correction_factor < MIN_BPB_FACTOR)
1191 rate_correction_factor = MIN_BPB_FACTOR;
1192 }
1193
1194 if (cpi->common.frame_type == KEY_FRAME)
1195 cpi->key_frame_rate_correction_factor = rate_correction_factor;
1196 else
1197 {
1198 if (cpi->oxcf.number_of_layers == 1 &&
1199 (cpi->common.refresh_alt_ref_frame ||
1200 cpi->common.refresh_golden_frame))
1201 cpi->gf_rate_correction_factor = rate_correction_factor;
1202 else
1203 cpi->rate_correction_factor = rate_correction_factor;
1204 }
1205 }
1206
1207
vp8_regulate_q(VP8_COMP * cpi,int target_bits_per_frame)1208 int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame)
1209 {
1210 int Q = cpi->active_worst_quality;
1211
1212 /* Reset Zbin OQ value */
1213 cpi->mb.zbin_over_quant = 0;
1214
1215 if (cpi->oxcf.fixed_q >= 0)
1216 {
1217 Q = cpi->oxcf.fixed_q;
1218
1219 if (cpi->common.frame_type == KEY_FRAME)
1220 {
1221 Q = cpi->oxcf.key_q;
1222 }
1223 else if (cpi->oxcf.number_of_layers == 1 &&
1224 cpi->common.refresh_alt_ref_frame)
1225 {
1226 Q = cpi->oxcf.alt_q;
1227 }
1228 else if (cpi->oxcf.number_of_layers == 1 &&
1229 cpi->common.refresh_golden_frame)
1230 {
1231 Q = cpi->oxcf.gold_q;
1232 }
1233 }
1234 else
1235 {
1236 int i;
1237 int last_error = INT_MAX;
1238 int target_bits_per_mb;
1239 int bits_per_mb_at_this_q;
1240 double correction_factor;
1241
1242 /* Select the appropriate correction factor based upon type of frame. */
1243 if (cpi->common.frame_type == KEY_FRAME)
1244 correction_factor = cpi->key_frame_rate_correction_factor;
1245 else
1246 {
1247 if (cpi->oxcf.number_of_layers == 1 &&
1248 (cpi->common.refresh_alt_ref_frame ||
1249 cpi->common.refresh_golden_frame))
1250 correction_factor = cpi->gf_rate_correction_factor;
1251 else
1252 correction_factor = cpi->rate_correction_factor;
1253 }
1254
1255 /* Calculate required scaling factor based on target frame size and
1256 * size of frame produced using previous Q
1257 */
1258 if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
1259 /* Case where we would overflow int */
1260 target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs) << BPER_MB_NORMBITS;
1261 else
1262 target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
1263
1264 i = cpi->active_best_quality;
1265
1266 do
1267 {
1268 bits_per_mb_at_this_q = (int)(.5 + correction_factor * vp8_bits_per_mb[cpi->common.frame_type][i]);
1269
1270 if (bits_per_mb_at_this_q <= target_bits_per_mb)
1271 {
1272 if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
1273 Q = i;
1274 else
1275 Q = i - 1;
1276
1277 break;
1278 }
1279 else
1280 last_error = bits_per_mb_at_this_q - target_bits_per_mb;
1281 }
1282 while (++i <= cpi->active_worst_quality);
1283
1284
1285 /* If we are at MAXQ then enable Q over-run which seeks to claw
1286 * back additional bits through things like the RD multiplier
1287 * and zero bin size.
1288 */
1289 if (Q >= MAXQ)
1290 {
1291 int zbin_oqmax;
1292
1293 double Factor = 0.99;
1294 double factor_adjustment = 0.01 / 256.0;
1295
1296 if (cpi->common.frame_type == KEY_FRAME)
1297 zbin_oqmax = 0;
1298 else if (cpi->oxcf.number_of_layers == 1 &&
1299 (cpi->common.refresh_alt_ref_frame ||
1300 (cpi->common.refresh_golden_frame &&
1301 !cpi->source_alt_ref_active)))
1302 zbin_oqmax = 16;
1303 else
1304 zbin_oqmax = ZBIN_OQ_MAX;
1305
1306 /*{
1307 double Factor = (double)target_bits_per_mb/(double)bits_per_mb_at_this_q;
1308 double Oq;
1309
1310 Factor = Factor/1.2683;
1311
1312 Oq = pow( Factor, (1.0/-0.165) );
1313
1314 if ( Oq > zbin_oqmax )
1315 Oq = zbin_oqmax;
1316
1317 cpi->zbin_over_quant = (int)Oq;
1318 }*/
1319
1320 /* Each incrment in the zbin is assumed to have a fixed effect
1321 * on bitrate. This is not of course true. The effect will be
1322 * highly clip dependent and may well have sudden steps. The
1323 * idea here is to acheive higher effective quantizers than the
1324 * normal maximum by expanding the zero bin and hence
1325 * decreasing the number of low magnitude non zero coefficients.
1326 */
1327 while (cpi->mb.zbin_over_quant < zbin_oqmax)
1328 {
1329 cpi->mb.zbin_over_quant ++;
1330
1331 if (cpi->mb.zbin_over_quant > zbin_oqmax)
1332 cpi->mb.zbin_over_quant = zbin_oqmax;
1333
1334 /* Adjust bits_per_mb_at_this_q estimate */
1335 bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q);
1336 Factor += factor_adjustment;
1337
1338 if (Factor >= 0.999)
1339 Factor = 0.999;
1340
1341 /* Break out if we get down to the target rate */
1342 if (bits_per_mb_at_this_q <= target_bits_per_mb)
1343 break;
1344 }
1345
1346 }
1347 }
1348
1349 return Q;
1350 }
1351
1352
estimate_keyframe_frequency(VP8_COMP * cpi)1353 static int estimate_keyframe_frequency(VP8_COMP *cpi)
1354 {
1355 int i;
1356
1357 /* Average key frame frequency */
1358 int av_key_frame_frequency = 0;
1359
1360 /* First key frame at start of sequence is a special case. We have no
1361 * frequency data.
1362 */
1363 if (cpi->key_frame_count == 1)
1364 {
1365 /* Assume a default of 1 kf every 2 seconds, or the max kf interval,
1366 * whichever is smaller.
1367 */
1368 int key_freq = cpi->oxcf.key_freq>0 ? cpi->oxcf.key_freq : 1;
1369 av_key_frame_frequency = 1 + (int)cpi->output_framerate * 2;
1370
1371 if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq)
1372 av_key_frame_frequency = key_freq;
1373
1374 cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1]
1375 = av_key_frame_frequency;
1376 }
1377 else
1378 {
1379 unsigned int total_weight = 0;
1380 int last_kf_interval =
1381 (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;
1382
1383 /* reset keyframe context and calculate weighted average of last
1384 * KEY_FRAME_CONTEXT keyframes
1385 */
1386 for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1387 {
1388 if (i < KEY_FRAME_CONTEXT - 1)
1389 cpi->prior_key_frame_distance[i]
1390 = cpi->prior_key_frame_distance[i+1];
1391 else
1392 cpi->prior_key_frame_distance[i] = last_kf_interval;
1393
1394 av_key_frame_frequency += prior_key_frame_weight[i]
1395 * cpi->prior_key_frame_distance[i];
1396 total_weight += prior_key_frame_weight[i];
1397 }
1398
1399 av_key_frame_frequency /= total_weight;
1400
1401 }
1402 // TODO (marpan): Given the checks above, |av_key_frame_frequency|
1403 // should always be above 0. But for now we keep the sanity check in.
1404 if (av_key_frame_frequency == 0)
1405 av_key_frame_frequency = 1;
1406 return av_key_frame_frequency;
1407 }
1408
1409
vp8_adjust_key_frame_context(VP8_COMP * cpi)1410 void vp8_adjust_key_frame_context(VP8_COMP *cpi)
1411 {
1412 /* Clear down mmx registers to allow floating point in what follows */
1413 vp8_clear_system_state();
1414
1415 /* Do we have any key frame overspend to recover? */
1416 /* Two-pass overspend handled elsewhere. */
1417 if ((cpi->pass != 2)
1418 && (cpi->projected_frame_size > cpi->per_frame_bandwidth))
1419 {
1420 int overspend;
1421
1422 /* Update the count of key frame overspend to be recovered in
1423 * subsequent frames. A portion of the KF overspend is treated as gf
1424 * overspend (and hence recovered more quickly) as the kf is also a
1425 * gf. Otherwise the few frames following each kf tend to get more
1426 * bits allocated than those following other gfs.
1427 */
1428 overspend = (cpi->projected_frame_size - cpi->per_frame_bandwidth);
1429
1430 if (cpi->oxcf.number_of_layers > 1)
1431 cpi->kf_overspend_bits += overspend;
1432 else
1433 {
1434 cpi->kf_overspend_bits += overspend * 7 / 8;
1435 cpi->gf_overspend_bits += overspend * 1 / 8;
1436 }
1437
1438 /* Work out how much to try and recover per frame. */
1439 cpi->kf_bitrate_adjustment = cpi->kf_overspend_bits
1440 / estimate_keyframe_frequency(cpi);
1441 }
1442
1443 cpi->frames_since_key = 0;
1444 cpi->key_frame_count++;
1445 }
1446
1447
vp8_compute_frame_size_bounds(VP8_COMP * cpi,int * frame_under_shoot_limit,int * frame_over_shoot_limit)1448 void vp8_compute_frame_size_bounds(VP8_COMP *cpi, int *frame_under_shoot_limit, int *frame_over_shoot_limit)
1449 {
1450 /* Set-up bounds on acceptable frame size: */
1451 if (cpi->oxcf.fixed_q >= 0)
1452 {
1453 /* Fixed Q scenario: frame size never outranges target
1454 * (there is no target!)
1455 */
1456 *frame_under_shoot_limit = 0;
1457 *frame_over_shoot_limit = INT_MAX;
1458 }
1459 else
1460 {
1461 if (cpi->common.frame_type == KEY_FRAME)
1462 {
1463 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
1464 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1465 }
1466 else
1467 {
1468 if (cpi->oxcf.number_of_layers > 1 ||
1469 cpi->common.refresh_alt_ref_frame ||
1470 cpi->common.refresh_golden_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 /* For CBR take buffer fullness into account */
1478 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
1479 {
1480 if (cpi->buffer_level >= ((cpi->oxcf.optimal_buffer_level + cpi->oxcf.maximum_buffer_size) >> 1))
1481 {
1482 /* Buffer is too full so relax overshoot and tighten
1483 * undershoot
1484 */
1485 *frame_over_shoot_limit = cpi->this_frame_target * 12 / 8;
1486 *frame_under_shoot_limit = cpi->this_frame_target * 6 / 8;
1487 }
1488 else if (cpi->buffer_level <= (cpi->oxcf.optimal_buffer_level >> 1))
1489 {
1490 /* Buffer is too low so relax undershoot and tighten
1491 * overshoot
1492 */
1493 *frame_over_shoot_limit = cpi->this_frame_target * 10 / 8;
1494 *frame_under_shoot_limit = cpi->this_frame_target * 4 / 8;
1495 }
1496 else
1497 {
1498 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1499 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1500 }
1501 }
1502 /* VBR and CQ mode */
1503 /* Note that tighter restrictions here can help quality
1504 * but hurt encode speed
1505 */
1506 else
1507 {
1508 /* Stron overshoot limit for constrained quality */
1509 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
1510 {
1511 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1512 *frame_under_shoot_limit = cpi->this_frame_target * 2 / 8;
1513 }
1514 else
1515 {
1516 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1517 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1518 }
1519 }
1520 }
1521 }
1522
1523 /* For very small rate targets where the fractional adjustment
1524 * (eg * 7/8) may be tiny make sure there is at least a minimum
1525 * range.
1526 */
1527 *frame_over_shoot_limit += 200;
1528 *frame_under_shoot_limit -= 200;
1529 if ( *frame_under_shoot_limit < 0 )
1530 *frame_under_shoot_limit = 0;
1531
1532 }
1533 }
1534
1535
1536 /* return of 0 means drop frame */
vp8_pick_frame_size(VP8_COMP * cpi)1537 int vp8_pick_frame_size(VP8_COMP *cpi)
1538 {
1539 VP8_COMMON *cm = &cpi->common;
1540
1541 if (cm->frame_type == KEY_FRAME)
1542 calc_iframe_target_size(cpi);
1543 else
1544 {
1545 calc_pframe_target_size(cpi);
1546
1547 /* Check if we're dropping the frame: */
1548 if (cpi->drop_frame)
1549 {
1550 cpi->drop_frame = 0;
1551 return 0;
1552 }
1553 }
1554 return 1;
1555 }
1556