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 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 memcpy(&cpi->lfc_a, &cpi->common.fc, sizeof(cpi->common.fc));
309 memcpy(&cpi->lfc_g, &cpi->common.fc, sizeof(cpi->common.fc));
310 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 {
712 Adjustment = (cpi->current_gf_interval - 1) * Adjustment;
713 // Limit adjustment to 10% of current target.
714 if (Adjustment > (10 * cpi->this_frame_target) / 100)
715 Adjustment = (10 * cpi->this_frame_target) / 100;
716 cpi->this_frame_target += Adjustment;
717 }
718 else
719 cpi->this_frame_target -= Adjustment;
720 }
721 }
722 }
723
724 /* Sanity check that the total sum of adjustments is not above the
725 * maximum allowed That is that having allowed for KF and GF penalties
726 * we have not pushed the current interframe target to low. If the
727 * adjustment we apply here is not capable of recovering all the extra
728 * bits we have spent in the KF or GF then the remainder will have to
729 * be recovered over a longer time span via other buffer / rate control
730 * mechanisms.
731 */
732 if (cpi->this_frame_target < min_frame_target)
733 cpi->this_frame_target = min_frame_target;
734
735 if (!cpi->common.refresh_alt_ref_frame)
736 /* Note the baseline target data rate for this inter frame. */
737 cpi->inter_frame_target = cpi->this_frame_target;
738
739 /* One Pass specific code */
740 if (cpi->pass == 0)
741 {
742 /* Adapt target frame size with respect to any buffering constraints: */
743 if (cpi->buffered_mode)
744 {
745 int one_percent_bits = (int)
746 (1 + cpi->oxcf.optimal_buffer_level / 100);
747
748 if ((cpi->buffer_level < cpi->oxcf.optimal_buffer_level) ||
749 (cpi->bits_off_target < cpi->oxcf.optimal_buffer_level))
750 {
751 int percent_low = 0;
752
753 /* Decide whether or not we need to adjust the frame data
754 * rate target.
755 *
756 * If we are are below the optimal buffer fullness level
757 * and adherence to buffering constraints is important to
758 * the end usage then adjust the per frame target.
759 */
760 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
761 (cpi->buffer_level < cpi->oxcf.optimal_buffer_level))
762 {
763 percent_low = (int)
764 ((cpi->oxcf.optimal_buffer_level - cpi->buffer_level) /
765 one_percent_bits);
766 }
767 /* Are we overshooting the long term clip data rate... */
768 else if (cpi->bits_off_target < 0)
769 {
770 /* Adjust per frame data target downwards to compensate. */
771 percent_low = (int)(100 * -cpi->bits_off_target /
772 (cpi->total_byte_count * 8));
773 }
774
775 if (percent_low > cpi->oxcf.under_shoot_pct)
776 percent_low = cpi->oxcf.under_shoot_pct;
777 else if (percent_low < 0)
778 percent_low = 0;
779
780 /* lower the target bandwidth for this frame. */
781 cpi->this_frame_target -=
782 (cpi->this_frame_target * percent_low) / 200;
783
784 /* Are we using allowing control of active_worst_allowed_q
785 * according to buffer level.
786 */
787 if (cpi->auto_worst_q && cpi->ni_frames > 150)
788 {
789 int64_t critical_buffer_level;
790
791 /* For streaming applications the most important factor is
792 * cpi->buffer_level as this takes into account the
793 * specified short term buffering constraints. However,
794 * hitting the long term clip data rate target is also
795 * important.
796 */
797 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
798 {
799 /* Take the smaller of cpi->buffer_level and
800 * cpi->bits_off_target
801 */
802 critical_buffer_level =
803 (cpi->buffer_level < cpi->bits_off_target)
804 ? cpi->buffer_level : cpi->bits_off_target;
805 }
806 /* For local file playback short term buffering constraints
807 * are less of an issue
808 */
809 else
810 {
811 /* Consider only how we are doing for the clip as a
812 * whole
813 */
814 critical_buffer_level = cpi->bits_off_target;
815 }
816
817 /* Set the active worst quality based upon the selected
818 * buffer fullness number.
819 */
820 if (critical_buffer_level < cpi->oxcf.optimal_buffer_level)
821 {
822 if ( critical_buffer_level >
823 (cpi->oxcf.optimal_buffer_level >> 2) )
824 {
825 int64_t qadjustment_range =
826 cpi->worst_quality - cpi->ni_av_qi;
827 int64_t above_base =
828 (critical_buffer_level -
829 (cpi->oxcf.optimal_buffer_level >> 2));
830
831 /* Step active worst quality down from
832 * cpi->ni_av_qi when (critical_buffer_level ==
833 * cpi->optimal_buffer_level) to
834 * cpi->worst_quality when
835 * (critical_buffer_level ==
836 * cpi->optimal_buffer_level >> 2)
837 */
838 cpi->active_worst_quality =
839 cpi->worst_quality -
840 (int)((qadjustment_range * above_base) /
841 (cpi->oxcf.optimal_buffer_level*3>>2));
842 }
843 else
844 {
845 cpi->active_worst_quality = cpi->worst_quality;
846 }
847 }
848 else
849 {
850 cpi->active_worst_quality = cpi->ni_av_qi;
851 }
852 }
853 else
854 {
855 cpi->active_worst_quality = cpi->worst_quality;
856 }
857 }
858 else
859 {
860 int percent_high = 0;
861
862 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
863 && (cpi->buffer_level > cpi->oxcf.optimal_buffer_level))
864 {
865 percent_high = (int)((cpi->buffer_level
866 - cpi->oxcf.optimal_buffer_level)
867 / one_percent_bits);
868 }
869 else if (cpi->bits_off_target > cpi->oxcf.optimal_buffer_level)
870 {
871 percent_high = (int)((100 * cpi->bits_off_target)
872 / (cpi->total_byte_count * 8));
873 }
874
875 if (percent_high > cpi->oxcf.over_shoot_pct)
876 percent_high = cpi->oxcf.over_shoot_pct;
877 else if (percent_high < 0)
878 percent_high = 0;
879
880 cpi->this_frame_target += (cpi->this_frame_target *
881 percent_high) / 200;
882
883 /* Are we allowing control of active_worst_allowed_q according
884 * to buffer level.
885 */
886 if (cpi->auto_worst_q && cpi->ni_frames > 150)
887 {
888 /* When using the relaxed buffer model stick to the
889 * user specified value
890 */
891 cpi->active_worst_quality = cpi->ni_av_qi;
892 }
893 else
894 {
895 cpi->active_worst_quality = cpi->worst_quality;
896 }
897 }
898
899 /* Set active_best_quality to prevent quality rising too high */
900 cpi->active_best_quality = cpi->best_quality;
901
902 /* Worst quality obviously must not be better than best quality */
903 if (cpi->active_worst_quality <= cpi->active_best_quality)
904 cpi->active_worst_quality = cpi->active_best_quality + 1;
905
906 if(cpi->active_worst_quality > 127)
907 cpi->active_worst_quality = 127;
908 }
909 /* Unbuffered mode (eg. video conferencing) */
910 else
911 {
912 /* Set the active worst quality */
913 cpi->active_worst_quality = cpi->worst_quality;
914 }
915
916 /* Special trap for constrained quality mode
917 * "active_worst_quality" may never drop below cq level
918 * for any frame type.
919 */
920 if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY &&
921 cpi->active_worst_quality < cpi->cq_target_quality)
922 {
923 cpi->active_worst_quality = cpi->cq_target_quality;
924 }
925 }
926
927 /* Test to see if we have to drop a frame
928 * The auto-drop frame code is only used in buffered mode.
929 * In unbufferd mode (eg vide conferencing) the descision to
930 * code or drop a frame is made outside the codec in response to real
931 * world comms or buffer considerations.
932 */
933 if (cpi->drop_frames_allowed &&
934 (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
935 ((cpi->common.frame_type != KEY_FRAME)))
936 {
937 /* Check for a buffer underun-crisis in which case we have to drop
938 * a frame
939 */
940 if ((cpi->buffer_level < 0))
941 {
942 #if 0
943 FILE *f = fopen("dec.stt", "a");
944 fprintf(f, "%10d %10d %10d %10d ***** BUFFER EMPTY\n",
945 (int) cpi->common.current_video_frame,
946 cpi->decimation_factor, cpi->common.horiz_scale,
947 (cpi->buffer_level * 100) / cpi->oxcf.optimal_buffer_level);
948 fclose(f);
949 #endif
950 cpi->drop_frame = 1;
951
952 /* Update the buffer level variable. */
953 cpi->bits_off_target += cpi->av_per_frame_bandwidth;
954 if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
955 cpi->bits_off_target = (int)cpi->oxcf.maximum_buffer_size;
956 cpi->buffer_level = cpi->bits_off_target;
957
958 if (cpi->oxcf.number_of_layers > 1) {
959 unsigned int i;
960
961 // Propagate bits saved by dropping the frame to higher layers.
962 for (i = cpi->current_layer + 1; i < cpi->oxcf.number_of_layers;
963 i++) {
964 LAYER_CONTEXT *lc = &cpi->layer_context[i];
965 lc->bits_off_target += (int)(lc->target_bandwidth /
966 lc->framerate);
967 if (lc->bits_off_target > lc->maximum_buffer_size)
968 lc->bits_off_target = lc->maximum_buffer_size;
969 lc->buffer_level = lc->bits_off_target;
970 }
971 }
972 }
973 }
974
975 /* Adjust target frame size for Golden Frames: */
976 if (cpi->oxcf.error_resilient_mode == 0 &&
977 (cpi->frames_till_gf_update_due == 0) && !cpi->drop_frame)
978 {
979 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
980
981 int gf_frame_useage = 0; /* Golden frame useage since last GF */
982 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
983 cpi->recent_ref_frame_usage[LAST_FRAME] +
984 cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
985 cpi->recent_ref_frame_usage[ALTREF_FRAME];
986
987 int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols);
988
989 if (tot_mbs)
990 gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs;
991
992 if (pct_gf_active > gf_frame_useage)
993 gf_frame_useage = pct_gf_active;
994
995 /* Is a fixed manual GF frequency being used */
996 if (cpi->auto_gold)
997 {
998 /* For one pass throw a GF if recent frame intra useage is
999 * low or the GF useage is high
1000 */
1001 if ((cpi->pass == 0) && (cpi->this_frame_percent_intra < 15 || gf_frame_useage >= 5))
1002 cpi->common.refresh_golden_frame = 1;
1003
1004 /* Two pass GF descision */
1005 else if (cpi->pass == 2)
1006 cpi->common.refresh_golden_frame = 1;
1007 }
1008
1009 #if 0
1010
1011 /* Debug stats */
1012 if (0)
1013 {
1014 FILE *f;
1015
1016 f = fopen("gf_useaget.stt", "a");
1017 fprintf(f, " %8ld %10ld %10ld %10ld %10ld\n",
1018 cpi->common.current_video_frame, cpi->gfu_boost, GFQ_ADJUSTMENT, cpi->gfu_boost, gf_frame_useage);
1019 fclose(f);
1020 }
1021
1022 #endif
1023
1024 if (cpi->common.refresh_golden_frame == 1)
1025 {
1026 #if 0
1027
1028 if (0)
1029 {
1030 FILE *f;
1031
1032 f = fopen("GFexit.stt", "a");
1033 fprintf(f, "%8ld GF coded\n", cpi->common.current_video_frame);
1034 fclose(f);
1035 }
1036
1037 #endif
1038
1039 if (cpi->auto_adjust_gold_quantizer)
1040 {
1041 calc_gf_params(cpi);
1042 }
1043
1044 /* If we are using alternate ref instead of gf then do not apply the
1045 * boost It will instead be applied to the altref update Jims
1046 * modified boost
1047 */
1048 if (!cpi->source_alt_ref_active)
1049 {
1050 if (cpi->oxcf.fixed_q < 0)
1051 {
1052 if (cpi->pass == 2)
1053 {
1054 /* The spend on the GF is defined in the two pass
1055 * code for two pass encodes
1056 */
1057 cpi->this_frame_target = cpi->per_frame_bandwidth;
1058 }
1059 else
1060 {
1061 int Boost = cpi->last_boost;
1062 int frames_in_section = cpi->frames_till_gf_update_due + 1;
1063 int allocation_chunks = (frames_in_section * 100) + (Boost - 100);
1064 int bits_in_section = cpi->inter_frame_target * frames_in_section;
1065
1066 /* Normalize Altboost and allocations chunck down to
1067 * prevent overflow
1068 */
1069 while (Boost > 1000)
1070 {
1071 Boost /= 2;
1072 allocation_chunks /= 2;
1073 }
1074
1075 /* Avoid loss of precision but avoid overflow */
1076 if ((bits_in_section >> 7) > allocation_chunks)
1077 cpi->this_frame_target = Boost * (bits_in_section / allocation_chunks);
1078 else
1079 cpi->this_frame_target = (Boost * bits_in_section) / allocation_chunks;
1080 }
1081 }
1082 else
1083 cpi->this_frame_target =
1084 (estimate_bits_at_q(1, Q, cpi->common.MBs, 1.0)
1085 * cpi->last_boost) / 100;
1086
1087 }
1088 /* If there is an active ARF at this location use the minimum
1089 * bits on this frame even if it is a contructed arf.
1090 * The active maximum quantizer insures that an appropriate
1091 * number of bits will be spent if needed for contstructed ARFs.
1092 */
1093 else
1094 {
1095 cpi->this_frame_target = 0;
1096 }
1097
1098 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
1099
1100 }
1101 }
1102
1103 cpi->per_frame_bandwidth = old_per_frame_bandwidth;
1104 }
1105
1106
vp8_update_rate_correction_factors(VP8_COMP * cpi,int damp_var)1107 void vp8_update_rate_correction_factors(VP8_COMP *cpi, int damp_var)
1108 {
1109 int Q = cpi->common.base_qindex;
1110 int correction_factor = 100;
1111 double rate_correction_factor;
1112 double adjustment_limit;
1113
1114 int projected_size_based_on_q = 0;
1115
1116 /* Clear down mmx registers to allow floating point in what follows */
1117 vp8_clear_system_state();
1118
1119 if (cpi->common.frame_type == KEY_FRAME)
1120 {
1121 rate_correction_factor = cpi->key_frame_rate_correction_factor;
1122 }
1123 else
1124 {
1125 if (cpi->oxcf.number_of_layers == 1 &&
1126 (cpi->common.refresh_alt_ref_frame ||
1127 cpi->common.refresh_golden_frame))
1128 rate_correction_factor = cpi->gf_rate_correction_factor;
1129 else
1130 rate_correction_factor = cpi->rate_correction_factor;
1131 }
1132
1133 /* Work out how big we would have expected the frame to be at this Q
1134 * given the current correction factor. Stay in double to avoid int
1135 * overflow when values are large
1136 */
1137 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));
1138
1139 /* Make some allowance for cpi->zbin_over_quant */
1140 if (cpi->mb.zbin_over_quant > 0)
1141 {
1142 int Z = cpi->mb.zbin_over_quant;
1143 double Factor = 0.99;
1144 double factor_adjustment = 0.01 / 256.0;
1145
1146 while (Z > 0)
1147 {
1148 Z --;
1149 projected_size_based_on_q =
1150 (int)(Factor * projected_size_based_on_q);
1151 Factor += factor_adjustment;
1152
1153 if (Factor >= 0.999)
1154 Factor = 0.999;
1155 }
1156 }
1157
1158 /* Work out a size correction factor. */
1159 if (projected_size_based_on_q > 0)
1160 correction_factor = (100 * cpi->projected_frame_size) / projected_size_based_on_q;
1161
1162 /* More heavily damped adjustment used if we have been oscillating
1163 * either side of target
1164 */
1165 switch (damp_var)
1166 {
1167 case 0:
1168 adjustment_limit = 0.75;
1169 break;
1170 case 1:
1171 adjustment_limit = 0.375;
1172 break;
1173 case 2:
1174 default:
1175 adjustment_limit = 0.25;
1176 break;
1177 }
1178
1179 if (correction_factor > 102)
1180 {
1181 /* We are not already at the worst allowable quality */
1182 correction_factor = (int)(100.5 + ((correction_factor - 100) * adjustment_limit));
1183 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1184
1185 /* Keep rate_correction_factor within limits */
1186 if (rate_correction_factor > MAX_BPB_FACTOR)
1187 rate_correction_factor = MAX_BPB_FACTOR;
1188 }
1189 else if (correction_factor < 99)
1190 {
1191 /* We are not already at the best allowable quality */
1192 correction_factor = (int)(100.5 - ((100 - correction_factor) * adjustment_limit));
1193 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1194
1195 /* Keep rate_correction_factor within limits */
1196 if (rate_correction_factor < MIN_BPB_FACTOR)
1197 rate_correction_factor = MIN_BPB_FACTOR;
1198 }
1199
1200 if (cpi->common.frame_type == KEY_FRAME)
1201 cpi->key_frame_rate_correction_factor = rate_correction_factor;
1202 else
1203 {
1204 if (cpi->oxcf.number_of_layers == 1 &&
1205 (cpi->common.refresh_alt_ref_frame ||
1206 cpi->common.refresh_golden_frame))
1207 cpi->gf_rate_correction_factor = rate_correction_factor;
1208 else
1209 cpi->rate_correction_factor = rate_correction_factor;
1210 }
1211 }
1212
1213
vp8_regulate_q(VP8_COMP * cpi,int target_bits_per_frame)1214 int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame)
1215 {
1216 int Q = cpi->active_worst_quality;
1217
1218 if (cpi->force_maxqp == 1) {
1219 cpi->active_worst_quality = cpi->worst_quality;
1220 return cpi->worst_quality;
1221 }
1222
1223 /* Reset Zbin OQ value */
1224 cpi->mb.zbin_over_quant = 0;
1225
1226 if (cpi->oxcf.fixed_q >= 0)
1227 {
1228 Q = cpi->oxcf.fixed_q;
1229
1230 if (cpi->common.frame_type == KEY_FRAME)
1231 {
1232 Q = cpi->oxcf.key_q;
1233 }
1234 else if (cpi->oxcf.number_of_layers == 1 &&
1235 cpi->common.refresh_alt_ref_frame)
1236 {
1237 Q = cpi->oxcf.alt_q;
1238 }
1239 else if (cpi->oxcf.number_of_layers == 1 &&
1240 cpi->common.refresh_golden_frame)
1241 {
1242 Q = cpi->oxcf.gold_q;
1243 }
1244 }
1245 else
1246 {
1247 int i;
1248 int last_error = INT_MAX;
1249 int target_bits_per_mb;
1250 int bits_per_mb_at_this_q;
1251 double correction_factor;
1252
1253 /* Select the appropriate correction factor based upon type of frame. */
1254 if (cpi->common.frame_type == KEY_FRAME)
1255 correction_factor = cpi->key_frame_rate_correction_factor;
1256 else
1257 {
1258 if (cpi->oxcf.number_of_layers == 1 &&
1259 (cpi->common.refresh_alt_ref_frame ||
1260 cpi->common.refresh_golden_frame))
1261 correction_factor = cpi->gf_rate_correction_factor;
1262 else
1263 correction_factor = cpi->rate_correction_factor;
1264 }
1265
1266 /* Calculate required scaling factor based on target frame size and
1267 * size of frame produced using previous Q
1268 */
1269 if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
1270 /* Case where we would overflow int */
1271 target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs) << BPER_MB_NORMBITS;
1272 else
1273 target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
1274
1275 i = cpi->active_best_quality;
1276
1277 do
1278 {
1279 bits_per_mb_at_this_q = (int)(.5 + correction_factor * vp8_bits_per_mb[cpi->common.frame_type][i]);
1280
1281 if (bits_per_mb_at_this_q <= target_bits_per_mb)
1282 {
1283 if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
1284 Q = i;
1285 else
1286 Q = i - 1;
1287
1288 break;
1289 }
1290 else
1291 last_error = bits_per_mb_at_this_q - target_bits_per_mb;
1292 }
1293 while (++i <= cpi->active_worst_quality);
1294
1295
1296 /* If we are at MAXQ then enable Q over-run which seeks to claw
1297 * back additional bits through things like the RD multiplier
1298 * and zero bin size.
1299 */
1300 if (Q >= MAXQ)
1301 {
1302 int zbin_oqmax;
1303
1304 double Factor = 0.99;
1305 double factor_adjustment = 0.01 / 256.0;
1306
1307 if (cpi->common.frame_type == KEY_FRAME)
1308 zbin_oqmax = 0;
1309 else if (cpi->oxcf.number_of_layers == 1 &&
1310 (cpi->common.refresh_alt_ref_frame ||
1311 (cpi->common.refresh_golden_frame &&
1312 !cpi->source_alt_ref_active)))
1313 zbin_oqmax = 16;
1314 else
1315 zbin_oqmax = ZBIN_OQ_MAX;
1316
1317 /*{
1318 double Factor = (double)target_bits_per_mb/(double)bits_per_mb_at_this_q;
1319 double Oq;
1320
1321 Factor = Factor/1.2683;
1322
1323 Oq = pow( Factor, (1.0/-0.165) );
1324
1325 if ( Oq > zbin_oqmax )
1326 Oq = zbin_oqmax;
1327
1328 cpi->zbin_over_quant = (int)Oq;
1329 }*/
1330
1331 /* Each incrment in the zbin is assumed to have a fixed effect
1332 * on bitrate. This is not of course true. The effect will be
1333 * highly clip dependent and may well have sudden steps. The
1334 * idea here is to acheive higher effective quantizers than the
1335 * normal maximum by expanding the zero bin and hence
1336 * decreasing the number of low magnitude non zero coefficients.
1337 */
1338 while (cpi->mb.zbin_over_quant < zbin_oqmax)
1339 {
1340 cpi->mb.zbin_over_quant ++;
1341
1342 if (cpi->mb.zbin_over_quant > zbin_oqmax)
1343 cpi->mb.zbin_over_quant = zbin_oqmax;
1344
1345 /* Adjust bits_per_mb_at_this_q estimate */
1346 bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q);
1347 Factor += factor_adjustment;
1348
1349 if (Factor >= 0.999)
1350 Factor = 0.999;
1351
1352 /* Break out if we get down to the target rate */
1353 if (bits_per_mb_at_this_q <= target_bits_per_mb)
1354 break;
1355 }
1356
1357 }
1358 }
1359
1360 return Q;
1361 }
1362
1363
estimate_keyframe_frequency(VP8_COMP * cpi)1364 static int estimate_keyframe_frequency(VP8_COMP *cpi)
1365 {
1366 int i;
1367
1368 /* Average key frame frequency */
1369 int av_key_frame_frequency = 0;
1370
1371 /* First key frame at start of sequence is a special case. We have no
1372 * frequency data.
1373 */
1374 if (cpi->key_frame_count == 1)
1375 {
1376 /* Assume a default of 1 kf every 2 seconds, or the max kf interval,
1377 * whichever is smaller.
1378 */
1379 int key_freq = cpi->oxcf.key_freq>0 ? cpi->oxcf.key_freq : 1;
1380 av_key_frame_frequency = 1 + (int)cpi->output_framerate * 2;
1381
1382 if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq)
1383 av_key_frame_frequency = key_freq;
1384
1385 cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1]
1386 = av_key_frame_frequency;
1387 }
1388 else
1389 {
1390 unsigned int total_weight = 0;
1391 int last_kf_interval =
1392 (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;
1393
1394 /* reset keyframe context and calculate weighted average of last
1395 * KEY_FRAME_CONTEXT keyframes
1396 */
1397 for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1398 {
1399 if (i < KEY_FRAME_CONTEXT - 1)
1400 cpi->prior_key_frame_distance[i]
1401 = cpi->prior_key_frame_distance[i+1];
1402 else
1403 cpi->prior_key_frame_distance[i] = last_kf_interval;
1404
1405 av_key_frame_frequency += prior_key_frame_weight[i]
1406 * cpi->prior_key_frame_distance[i];
1407 total_weight += prior_key_frame_weight[i];
1408 }
1409
1410 av_key_frame_frequency /= total_weight;
1411
1412 }
1413 // TODO (marpan): Given the checks above, |av_key_frame_frequency|
1414 // should always be above 0. But for now we keep the sanity check in.
1415 if (av_key_frame_frequency == 0)
1416 av_key_frame_frequency = 1;
1417 return av_key_frame_frequency;
1418 }
1419
1420
vp8_adjust_key_frame_context(VP8_COMP * cpi)1421 void vp8_adjust_key_frame_context(VP8_COMP *cpi)
1422 {
1423 /* Clear down mmx registers to allow floating point in what follows */
1424 vp8_clear_system_state();
1425
1426 /* Do we have any key frame overspend to recover? */
1427 /* Two-pass overspend handled elsewhere. */
1428 if ((cpi->pass != 2)
1429 && (cpi->projected_frame_size > cpi->per_frame_bandwidth))
1430 {
1431 int overspend;
1432
1433 /* Update the count of key frame overspend to be recovered in
1434 * subsequent frames. A portion of the KF overspend is treated as gf
1435 * overspend (and hence recovered more quickly) as the kf is also a
1436 * gf. Otherwise the few frames following each kf tend to get more
1437 * bits allocated than those following other gfs.
1438 */
1439 overspend = (cpi->projected_frame_size - cpi->per_frame_bandwidth);
1440
1441 if (cpi->oxcf.number_of_layers > 1)
1442 cpi->kf_overspend_bits += overspend;
1443 else
1444 {
1445 cpi->kf_overspend_bits += overspend * 7 / 8;
1446 cpi->gf_overspend_bits += overspend * 1 / 8;
1447 }
1448
1449 /* Work out how much to try and recover per frame. */
1450 cpi->kf_bitrate_adjustment = cpi->kf_overspend_bits
1451 / estimate_keyframe_frequency(cpi);
1452 }
1453
1454 cpi->frames_since_key = 0;
1455 cpi->key_frame_count++;
1456 }
1457
1458
vp8_compute_frame_size_bounds(VP8_COMP * cpi,int * frame_under_shoot_limit,int * frame_over_shoot_limit)1459 void vp8_compute_frame_size_bounds(VP8_COMP *cpi, int *frame_under_shoot_limit, int *frame_over_shoot_limit)
1460 {
1461 /* Set-up bounds on acceptable frame size: */
1462 if (cpi->oxcf.fixed_q >= 0)
1463 {
1464 /* Fixed Q scenario: frame size never outranges target
1465 * (there is no target!)
1466 */
1467 *frame_under_shoot_limit = 0;
1468 *frame_over_shoot_limit = INT_MAX;
1469 }
1470 else
1471 {
1472 if (cpi->common.frame_type == KEY_FRAME)
1473 {
1474 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
1475 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1476 }
1477 else
1478 {
1479 if (cpi->oxcf.number_of_layers > 1 ||
1480 cpi->common.refresh_alt_ref_frame ||
1481 cpi->common.refresh_golden_frame)
1482 {
1483 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
1484 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1485 }
1486 else
1487 {
1488 /* For CBR take buffer fullness into account */
1489 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
1490 {
1491 if (cpi->buffer_level >= ((cpi->oxcf.optimal_buffer_level + cpi->oxcf.maximum_buffer_size) >> 1))
1492 {
1493 /* Buffer is too full so relax overshoot and tighten
1494 * undershoot
1495 */
1496 *frame_over_shoot_limit = cpi->this_frame_target * 12 / 8;
1497 *frame_under_shoot_limit = cpi->this_frame_target * 6 / 8;
1498 }
1499 else if (cpi->buffer_level <= (cpi->oxcf.optimal_buffer_level >> 1))
1500 {
1501 /* Buffer is too low so relax undershoot and tighten
1502 * overshoot
1503 */
1504 *frame_over_shoot_limit = cpi->this_frame_target * 10 / 8;
1505 *frame_under_shoot_limit = cpi->this_frame_target * 4 / 8;
1506 }
1507 else
1508 {
1509 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1510 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1511 }
1512 }
1513 /* VBR and CQ mode */
1514 /* Note that tighter restrictions here can help quality
1515 * but hurt encode speed
1516 */
1517 else
1518 {
1519 /* Stron overshoot limit for constrained quality */
1520 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
1521 {
1522 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1523 *frame_under_shoot_limit = cpi->this_frame_target * 2 / 8;
1524 }
1525 else
1526 {
1527 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1528 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1529 }
1530 }
1531 }
1532 }
1533
1534 /* For very small rate targets where the fractional adjustment
1535 * (eg * 7/8) may be tiny make sure there is at least a minimum
1536 * range.
1537 */
1538 *frame_over_shoot_limit += 200;
1539 *frame_under_shoot_limit -= 200;
1540 if ( *frame_under_shoot_limit < 0 )
1541 *frame_under_shoot_limit = 0;
1542
1543 }
1544 }
1545
1546
1547 /* return of 0 means drop frame */
vp8_pick_frame_size(VP8_COMP * cpi)1548 int vp8_pick_frame_size(VP8_COMP *cpi)
1549 {
1550 VP8_COMMON *cm = &cpi->common;
1551
1552 if (cm->frame_type == KEY_FRAME)
1553 calc_iframe_target_size(cpi);
1554 else
1555 {
1556 calc_pframe_target_size(cpi);
1557
1558 /* Check if we're dropping the frame: */
1559 if (cpi->drop_frame)
1560 {
1561 cpi->drop_frame = 0;
1562 return 0;
1563 }
1564 }
1565 return 1;
1566 }
1567 // If this just encoded frame (mcomp/transform/quant, but before loopfilter and
1568 // pack_bitstream) has large overshoot, and was not being encoded close to the
1569 // max QP, then drop this frame and force next frame to be encoded at max QP.
1570 // Condition this on 1 pass CBR with screen content mode and frame dropper off.
1571 // TODO(marpan): Should do this exit condition during the encode_frame
1572 // (i.e., halfway during the encoding of the frame) to save cycles.
vp8_drop_encodedframe_overshoot(VP8_COMP * cpi,int Q)1573 int vp8_drop_encodedframe_overshoot(VP8_COMP *cpi, int Q) {
1574 if (cpi->pass == 0 &&
1575 cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER &&
1576 cpi->drop_frames_allowed == 0 &&
1577 cpi->common.frame_type != KEY_FRAME) {
1578 // Note: the "projected_frame_size" from encode_frame() only gives estimate
1579 // of mode/motion vector rate (in non-rd mode): so below we only require
1580 // that projected_frame_size is somewhat greater than per-frame-bandwidth,
1581 // but add additional condition with high threshold on prediction residual.
1582
1583 // QP threshold: only allow dropping if we are not close to qp_max.
1584 int thresh_qp = 3 * cpi->worst_quality >> 2;
1585 // Rate threshold, in bytes.
1586 int thresh_rate = 2 * (cpi->av_per_frame_bandwidth >> 3);
1587 // Threshold for the average (over all macroblocks) of the pixel-sum
1588 // residual error over 16x16 block. Should add QP dependence on threshold?
1589 int thresh_pred_err_mb = (256 << 4);
1590 int pred_err_mb = (int)(cpi->mb.prediction_error / cpi->common.MBs);
1591 if (Q < thresh_qp &&
1592 cpi->projected_frame_size > thresh_rate &&
1593 pred_err_mb > thresh_pred_err_mb) {
1594 // Drop this frame: advance frame counters, and set force_maxqp flag.
1595 cpi->common.current_video_frame++;
1596 cpi->frames_since_key++;
1597 // Flag to indicate we will force next frame to be encoded at max QP.
1598 cpi->force_maxqp = 1;
1599 return 1;
1600 } else {
1601 cpi->force_maxqp = 0;
1602 return 0;
1603 }
1604 cpi->force_maxqp = 0;
1605 return 0;
1606 }
1607 cpi->force_maxqp = 0;
1608 return 0;
1609 }
1610