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 "common.h"
20 #include "ratectrl.h"
21 #include "entropymode.h"
22 #include "vpx_mem/vpx_mem.h"
23 #include "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 extern const MV_REFERENCE_FRAME vp8_ref_frame_order[MAX_MODES];
32
33
34
35 #ifdef MODE_STATS
36 extern int y_modes[5];
37 extern int uv_modes[4];
38 extern int b_modes[10];
39
40 extern int inter_y_modes[10];
41 extern int inter_uv_modes[4];
42 extern int inter_b_modes[10];
43 #endif
44
45 // Bits Per MB at different Q (Multiplied by 512)
46 #define BPER_MB_NORMBITS 9
47
48 const int vp8_bits_per_mb[2][QINDEX_RANGE] =
49 {
50 // (Updated 19 March 08) Baseline estimate of INTRA-frame Bits Per MB at each Q:
51 {
52 674781, 606845, 553905, 524293, 500428, 452540, 435379, 414719,
53 390970, 371082, 359416, 341807, 336957, 317263, 303724, 298402,
54 285688, 275237, 268455, 262560, 256038, 248734, 241087, 237615,
55 229247, 225211, 219112, 213920, 211559, 202714, 198482, 193401,
56 187866, 183453, 179212, 175965, 171852, 167235, 163972, 160560,
57 156032, 154349, 151390, 148725, 145708, 142311, 139981, 137700,
58 134084, 131863, 129746, 128498, 126077, 123461, 121290, 117782,
59 114883, 112332, 108410, 105685, 103434, 101192, 98587, 95959,
60 94059, 92017, 89970, 87936, 86142, 84801, 82736, 81106,
61 79668, 78135, 76641, 75103, 73943, 72693, 71401, 70098,
62 69165, 67901, 67170, 65987, 64923, 63534, 62378, 61302,
63 59921, 58941, 57844, 56782, 55960, 54973, 54257, 53454,
64 52230, 50938, 49962, 49190, 48288, 47270, 46738, 46037,
65 45020, 44027, 43216, 42287, 41594, 40702, 40081, 39414,
66 38282, 37627, 36987, 36375, 35808, 35236, 34710, 34162,
67 33659, 33327, 32751, 32384, 31936, 31461, 30982, 30582,
68 },
69
70 // (Updated 19 March 08) Baseline estimate of INTER-frame Bits Per MB at each Q:
71 {
72 497401, 426316, 372064, 352732, 335763, 283921, 273848, 253321,
73 233181, 217727, 210030, 196685, 194836, 178396, 167753, 164116,
74 154119, 146929, 142254, 138488, 133591, 127741, 123166, 120226,
75 114188, 111756, 107882, 104749, 102522, 96451, 94424, 90905,
76 87286, 84931, 82111, 80534, 77610, 74700, 73037, 70715,
77 68006, 67235, 65374, 64009, 62134, 60180, 59105, 57691,
78 55509, 54512, 53318, 52693, 51194, 49840, 48944, 46980,
79 45668, 44177, 42348, 40994, 39859, 38889, 37717, 36391,
80 35482, 34622, 33795, 32756, 32002, 31492, 30573, 29737,
81 29152, 28514, 27941, 27356, 26859, 26329, 25874, 25364,
82 24957, 24510, 24290, 23689, 23380, 22845, 22481, 22066,
83 21587, 21219, 20880, 20452, 20260, 19926, 19661, 19334,
84 18915, 18391, 18046, 17833, 17441, 17105, 16888, 16729,
85 16383, 16023, 15706, 15442, 15222, 14938, 14673, 14452,
86 14005, 13807, 13611, 13447, 13223, 13102, 12963, 12801,
87 12627, 12534, 12356, 12228, 12056, 11907, 11746, 11643,
88 }
89 };
90
91 const int vp8_kf_boost_qadjustment[QINDEX_RANGE] =
92 {
93 128, 129, 130, 131, 132, 133, 134, 135,
94 136, 137, 138, 139, 140, 141, 142, 143,
95 144, 145, 146, 147, 148, 149, 150, 151,
96 152, 153, 154, 155, 156, 157, 158, 159,
97 160, 161, 162, 163, 164, 165, 166, 167,
98 168, 169, 170, 171, 172, 173, 174, 175,
99 176, 177, 178, 179, 180, 181, 182, 183,
100 184, 185, 186, 187, 188, 189, 190, 191,
101 192, 193, 194, 195, 196, 197, 198, 199,
102 200, 200, 201, 201, 202, 203, 203, 203,
103 204, 204, 205, 205, 206, 206, 207, 207,
104 208, 208, 209, 209, 210, 210, 211, 211,
105 212, 212, 213, 213, 214, 214, 215, 215,
106 216, 216, 217, 217, 218, 218, 219, 219,
107 220, 220, 220, 220, 220, 220, 220, 220,
108 220, 220, 220, 220, 220, 220, 220, 220,
109 };
110
111 //#define GFQ_ADJUSTMENT (Q+100)
112 #define GFQ_ADJUSTMENT vp8_gf_boost_qadjustment[Q]
113 const int vp8_gf_boost_qadjustment[QINDEX_RANGE] =
114 {
115 80, 82, 84, 86, 88, 90, 92, 94,
116 96, 97, 98, 99, 100, 101, 102, 103,
117 104, 105, 106, 107, 108, 109, 110, 111,
118 112, 113, 114, 115, 116, 117, 118, 119,
119 120, 121, 122, 123, 124, 125, 126, 127,
120 128, 129, 130, 131, 132, 133, 134, 135,
121 136, 137, 138, 139, 140, 141, 142, 143,
122 144, 145, 146, 147, 148, 149, 150, 151,
123 152, 153, 154, 155, 156, 157, 158, 159,
124 160, 161, 162, 163, 164, 165, 166, 167,
125 168, 169, 170, 171, 172, 173, 174, 175,
126 176, 177, 178, 179, 180, 181, 182, 183,
127 184, 184, 185, 185, 186, 186, 187, 187,
128 188, 188, 189, 189, 190, 190, 191, 191,
129 192, 192, 193, 193, 194, 194, 194, 194,
130 195, 195, 196, 196, 197, 197, 198, 198
131 };
132
133 /*
134 const int vp8_gf_boost_qadjustment[QINDEX_RANGE] =
135 {
136 100,101,102,103,104,105,105,106,
137 106,107,107,108,109,109,110,111,
138 112,113,114,115,116,117,118,119,
139 120,121,122,123,124,125,126,127,
140 128,129,130,131,132,133,134,135,
141 136,137,138,139,140,141,142,143,
142 144,145,146,147,148,149,150,151,
143 152,153,154,155,156,157,158,159,
144 160,161,162,163,164,165,166,167,
145 168,169,170,170,171,171,172,172,
146 173,173,173,174,174,174,175,175,
147 175,176,176,176,177,177,177,177,
148 178,178,179,179,180,180,181,181,
149 182,182,183,183,184,184,185,185,
150 186,186,187,187,188,188,189,189,
151 190,190,191,191,192,192,193,193,
152 };
153 */
154
155 const int vp8_kf_gf_boost_qlimits[QINDEX_RANGE] =
156 {
157 150, 155, 160, 165, 170, 175, 180, 185,
158 190, 195, 200, 205, 210, 215, 220, 225,
159 230, 235, 240, 245, 250, 255, 260, 265,
160 270, 275, 280, 285, 290, 295, 300, 305,
161 310, 320, 330, 340, 350, 360, 370, 380,
162 390, 400, 410, 420, 430, 440, 450, 460,
163 470, 480, 490, 500, 510, 520, 530, 540,
164 550, 560, 570, 580, 590, 600, 600, 600,
165 600, 600, 600, 600, 600, 600, 600, 600,
166 600, 600, 600, 600, 600, 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 };
174
175 // % adjustment to target kf size based on seperation from previous frame
176 const int vp8_kf_boost_seperationt_adjustment[16] =
177 {
178 30, 40, 50, 55, 60, 65, 70, 75,
179 80, 85, 90, 95, 100, 100, 100, 100,
180 };
181
182
183 const int vp8_gf_adjust_table[101] =
184 {
185 100,
186 115, 130, 145, 160, 175, 190, 200, 210, 220, 230,
187 240, 260, 270, 280, 290, 300, 310, 320, 330, 340,
188 350, 360, 370, 380, 390, 400, 400, 400, 400, 400,
189 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
190 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
191 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
192 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
193 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
194 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
195 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
196 };
197
198 const int vp8_gf_intra_useage_adjustment[20] =
199 {
200 125, 120, 115, 110, 105, 100, 95, 85, 80, 75,
201 70, 65, 60, 55, 50, 50, 50, 50, 50, 50,
202 };
203
204 const int vp8_gf_interval_table[101] =
205 {
206 7,
207 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
208 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
209 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
210 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
211 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
212 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
213 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
214 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
215 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
216 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
217 };
218
219 static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = { 1, 2, 3, 4, 5 };
220
221
vp8_save_coding_context(VP8_COMP * cpi)222 void vp8_save_coding_context(VP8_COMP *cpi)
223 {
224 CODING_CONTEXT *const cc = & cpi->coding_context;
225
226 // Stores a snapshot of key state variables which can subsequently be
227 // restored with a call to vp8_restore_coding_context. These functions are
228 // intended for use in a re-code loop in vp8_compress_frame where the
229 // quantizer value is adjusted between loop iterations.
230
231 cc->frames_since_key = cpi->frames_since_key;
232 cc->filter_level = cpi->common.filter_level;
233 cc->frames_till_gf_update_due = cpi->frames_till_gf_update_due;
234 cc->frames_since_golden = cpi->common.frames_since_golden;
235
236 vp8_copy(cc->mvc, cpi->common.fc.mvc);
237 vp8_copy(cc->mvcosts, cpi->mb.mvcosts);
238
239 vp8_copy(cc->kf_ymode_prob, cpi->common.kf_ymode_prob);
240 vp8_copy(cc->ymode_prob, cpi->common.fc.ymode_prob);
241 vp8_copy(cc->kf_uv_mode_prob, cpi->common.kf_uv_mode_prob);
242 vp8_copy(cc->uv_mode_prob, cpi->common.fc.uv_mode_prob);
243
244 vp8_copy(cc->ymode_count, cpi->ymode_count);
245 vp8_copy(cc->uv_mode_count, cpi->uv_mode_count);
246
247
248 // Stats
249 #ifdef MODE_STATS
250 vp8_copy(cc->y_modes, y_modes);
251 vp8_copy(cc->uv_modes, uv_modes);
252 vp8_copy(cc->b_modes, b_modes);
253 vp8_copy(cc->inter_y_modes, inter_y_modes);
254 vp8_copy(cc->inter_uv_modes, inter_uv_modes);
255 vp8_copy(cc->inter_b_modes, inter_b_modes);
256 #endif
257
258 cc->this_frame_percent_intra = cpi->this_frame_percent_intra;
259 }
260
261
vp8_restore_coding_context(VP8_COMP * cpi)262 void vp8_restore_coding_context(VP8_COMP *cpi)
263 {
264 CODING_CONTEXT *const cc = & cpi->coding_context;
265
266 // Restore key state variables to the snapshot state stored in the
267 // previous call to vp8_save_coding_context.
268
269 cpi->frames_since_key = cc->frames_since_key;
270 cpi->common.filter_level = cc->filter_level;
271 cpi->frames_till_gf_update_due = cc->frames_till_gf_update_due;
272 cpi->common.frames_since_golden = cc->frames_since_golden;
273
274 vp8_copy(cpi->common.fc.mvc, cc->mvc);
275
276 vp8_copy(cpi->mb.mvcosts, cc->mvcosts);
277
278 vp8_copy(cpi->common.kf_ymode_prob, cc->kf_ymode_prob);
279 vp8_copy(cpi->common.fc.ymode_prob, cc->ymode_prob);
280 vp8_copy(cpi->common.kf_uv_mode_prob, cc->kf_uv_mode_prob);
281 vp8_copy(cpi->common.fc.uv_mode_prob, cc->uv_mode_prob);
282
283 vp8_copy(cpi->ymode_count, cc->ymode_count);
284 vp8_copy(cpi->uv_mode_count, cc->uv_mode_count);
285
286 // Stats
287 #ifdef MODE_STATS
288 vp8_copy(y_modes, cc->y_modes);
289 vp8_copy(uv_modes, cc->uv_modes);
290 vp8_copy(b_modes, cc->b_modes);
291 vp8_copy(inter_y_modes, cc->inter_y_modes);
292 vp8_copy(inter_uv_modes, cc->inter_uv_modes);
293 vp8_copy(inter_b_modes, cc->inter_b_modes);
294 #endif
295
296
297 cpi->this_frame_percent_intra = cc->this_frame_percent_intra;
298 }
299
300
vp8_setup_key_frame(VP8_COMP * cpi)301 void vp8_setup_key_frame(VP8_COMP *cpi)
302 {
303 // Setup for Key frame:
304
305 vp8_default_coef_probs(& cpi->common);
306 vp8_kf_default_bmode_probs(cpi->common.kf_bmode_prob);
307
308 vpx_memcpy(cpi->common.fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));
309 {
310 int flag[2] = {1, 1};
311 vp8_build_component_cost_table(cpi->mb.mvcost, cpi->mb.mvsadcost, (const MV_CONTEXT *) cpi->common.fc.mvc, flag);
312 }
313
314 vpx_memset(cpi->common.fc.pre_mvc, 0, sizeof(cpi->common.fc.pre_mvc)); //initialize pre_mvc to all zero.
315
316 //cpi->common.filter_level = 0; // Reset every key frame.
317 cpi->common.filter_level = cpi->common.base_qindex * 3 / 8 ;
318
319 // Provisional interval before next GF
320 if (cpi->auto_gold)
321 //cpi->frames_till_gf_update_due = DEFAULT_GF_INTERVAL;
322 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
323 else
324 cpi->frames_till_gf_update_due = cpi->goldfreq;
325
326 cpi->common.refresh_golden_frame = TRUE;
327 }
328
vp8_calc_auto_iframe_target_size(VP8_COMP * cpi)329 void vp8_calc_auto_iframe_target_size(VP8_COMP *cpi)
330 {
331 // boost defaults to half second
332 int kf_boost;
333
334 // Clear down mmx registers to allow floating point in what follows
335 vp8_clear_system_state(); //__asm emms;
336
337 if (cpi->oxcf.fixed_q >= 0)
338 {
339 vp8_calc_iframe_target_size(cpi);
340 return;
341 }
342
343 if (cpi->pass == 2)
344 {
345 cpi->this_frame_target = cpi->per_frame_bandwidth; // New Two pass RC
346 }
347 else
348 {
349 // Boost depends somewhat on frame rate
350 kf_boost = (int)(2 * cpi->output_frame_rate - 16);
351
352 // adjustment up based on q
353 kf_boost = kf_boost * vp8_kf_boost_qadjustment[cpi->ni_av_qi] / 100;
354
355 // frame separation adjustment ( down)
356 if (cpi->frames_since_key < cpi->output_frame_rate / 2)
357 kf_boost = (int)(kf_boost * cpi->frames_since_key / (cpi->output_frame_rate / 2));
358
359 if (kf_boost < 16)
360 kf_boost = 16;
361
362 // Reset the active worst quality to the baseline value for key frames.
363 cpi->active_worst_quality = cpi->worst_quality;
364
365 cpi->this_frame_target = ((16 + kf_boost) * cpi->per_frame_bandwidth) >> 4;
366 }
367
368
369 // Should the next frame be an altref frame
370 if (cpi->pass != 2)
371 {
372 // For now Alt ref is not allowed except in 2 pass modes.
373 cpi->source_alt_ref_pending = FALSE;
374
375 /*if ( cpi->oxcf.fixed_q == -1)
376 {
377 if ( cpi->oxcf.play_alternate && ( (cpi->last_boost/2) > (100+(AF_THRESH*cpi->frames_till_gf_update_due)) ) )
378 cpi->source_alt_ref_pending = TRUE;
379 else
380 cpi->source_alt_ref_pending = FALSE;
381 }*/
382 }
383
384 if (0)
385 {
386 FILE *f;
387
388 f = fopen("kf_boost.stt", "a");
389 //fprintf(f, " %8d %10d %10d %10d %10d %10d %10d\n",
390 // cpi->common.current_video_frame, cpi->target_bandwidth, cpi->frames_to_key, kf_boost_qadjustment[cpi->ni_av_qi], cpi->kf_boost, (cpi->this_frame_target *100 / cpi->per_frame_bandwidth), cpi->this_frame_target );
391
392 fprintf(f, " %8u %10d %10d %10d\n",
393 cpi->common.current_video_frame, cpi->gfu_boost, cpi->baseline_gf_interval, cpi->source_alt_ref_pending);
394
395 fclose(f);
396 }
397 }
398
399 // Do the best we can to define the parameteres for the next GF based on what information we have available.
calc_gf_params(VP8_COMP * cpi)400 static void calc_gf_params(VP8_COMP *cpi)
401 {
402 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
403 int Boost = 0;
404
405 int gf_frame_useage = 0; // Golden frame useage since last GF
406 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
407 cpi->recent_ref_frame_usage[LAST_FRAME] +
408 cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
409 cpi->recent_ref_frame_usage[ALTREF_FRAME];
410
411 int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols);
412
413 // Reset the last boost indicator
414 //cpi->last_boost = 100;
415
416 if (tot_mbs)
417 gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs;
418
419 if (pct_gf_active > gf_frame_useage)
420 gf_frame_useage = pct_gf_active;
421
422 // Not two pass
423 if (cpi->pass != 2)
424 {
425 // Single Pass lagged mode: TBD
426 if (FALSE)
427 {
428 }
429
430 // Single Pass compression: Has to use current and historical data
431 else
432 {
433 #if 0
434 // Experimental code
435 int index = cpi->one_pass_frame_index;
436 int frames_to_scan = (cpi->max_gf_interval <= MAX_LAG_BUFFERS) ? cpi->max_gf_interval : MAX_LAG_BUFFERS;
437
438 /*
439 // *************** Experimental code - incomplete
440 double decay_val = 1.0;
441 double IIAccumulator = 0.0;
442 double last_iiaccumulator = 0.0;
443 double IIRatio;
444
445 cpi->one_pass_frame_index = cpi->common.current_video_frame%MAX_LAG_BUFFERS;
446
447 for ( i = 0; i < (frames_to_scan - 1); i++ )
448 {
449 if ( index < 0 )
450 index = MAX_LAG_BUFFERS;
451 index --;
452
453 if ( cpi->one_pass_frame_stats[index].frame_coded_error > 0.0 )
454 {
455 IIRatio = cpi->one_pass_frame_stats[index].frame_intra_error / cpi->one_pass_frame_stats[index].frame_coded_error;
456
457 if ( IIRatio > 30.0 )
458 IIRatio = 30.0;
459 }
460 else
461 IIRatio = 30.0;
462
463 IIAccumulator += IIRatio * decay_val;
464
465 decay_val = decay_val * cpi->one_pass_frame_stats[index].frame_pcnt_inter;
466
467 if ( (i > MIN_GF_INTERVAL) &&
468 ((IIAccumulator - last_iiaccumulator) < 2.0) )
469 {
470 break;
471 }
472 last_iiaccumulator = IIAccumulator;
473 }
474
475 Boost = IIAccumulator*100.0/16.0;
476 cpi->baseline_gf_interval = i;
477
478 */
479 #else
480
481 /*************************************************************/
482 // OLD code
483
484 // Adjust boost based upon ambient Q
485 Boost = GFQ_ADJUSTMENT;
486
487 // Adjust based upon most recently measure intra useage
488 Boost = Boost * vp8_gf_intra_useage_adjustment[(cpi->this_frame_percent_intra < 15) ? cpi->this_frame_percent_intra : 14] / 100;
489
490 // Adjust gf boost based upon GF usage since last GF
491 Boost = Boost * vp8_gf_adjust_table[gf_frame_useage] / 100;
492 #endif
493 }
494
495 // golden frame boost without recode loop often goes awry. be safe by keeping numbers down.
496 if (!cpi->sf.recode_loop)
497 {
498 if (cpi->compressor_speed == 2)
499 Boost = Boost / 2;
500 }
501
502 // Apply an upper limit based on Q for 1 pass encodes
503 if (Boost > vp8_kf_gf_boost_qlimits[Q] && (cpi->pass == 0))
504 Boost = vp8_kf_gf_boost_qlimits[Q];
505
506 // Apply lower limits to boost.
507 else if (Boost < 110)
508 Boost = 110;
509
510 // Note the boost used
511 cpi->last_boost = Boost;
512
513 }
514
515 // Estimate next interval
516 // This is updated once the real frame size/boost is known.
517 if (cpi->oxcf.fixed_q == -1)
518 {
519 if (cpi->pass == 2) // 2 Pass
520 {
521 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
522 }
523 else // 1 Pass
524 {
525 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
526
527 if (cpi->last_boost > 750)
528 cpi->frames_till_gf_update_due++;
529
530 if (cpi->last_boost > 1000)
531 cpi->frames_till_gf_update_due++;
532
533 if (cpi->last_boost > 1250)
534 cpi->frames_till_gf_update_due++;
535
536 if (cpi->last_boost >= 1500)
537 cpi->frames_till_gf_update_due ++;
538
539 if (vp8_gf_interval_table[gf_frame_useage] > cpi->frames_till_gf_update_due)
540 cpi->frames_till_gf_update_due = vp8_gf_interval_table[gf_frame_useage];
541
542 if (cpi->frames_till_gf_update_due > cpi->max_gf_interval)
543 cpi->frames_till_gf_update_due = cpi->max_gf_interval;
544 }
545 }
546 else
547 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
548
549 // ARF on or off
550 if (cpi->pass != 2)
551 {
552 // For now Alt ref is not allowed except in 2 pass modes.
553 cpi->source_alt_ref_pending = FALSE;
554
555 /*if ( cpi->oxcf.fixed_q == -1)
556 {
557 if ( cpi->oxcf.play_alternate && (cpi->last_boost > (100 + (AF_THRESH*cpi->frames_till_gf_update_due)) ) )
558 cpi->source_alt_ref_pending = TRUE;
559 else
560 cpi->source_alt_ref_pending = FALSE;
561 }*/
562 }
563 }
564 /* This is equvialent to estimate_bits_at_q without the rate_correction_factor. */
baseline_bits_at_q(int frame_kind,int Q,int MBs)565 static int baseline_bits_at_q(int frame_kind, int Q, int MBs)
566 {
567 int Bpm = vp8_bits_per_mb[frame_kind][Q];
568
569 /* Attempt to retain reasonable accuracy without overflow. The cutoff is
570 * chosen such that the maximum product of Bpm and MBs fits 31 bits. The
571 * largest Bpm takes 20 bits.
572 */
573 if (MBs > (1 << 11))
574 return (Bpm >> BPER_MB_NORMBITS) * MBs;
575 else
576 return (Bpm * MBs) >> BPER_MB_NORMBITS;
577 }
578
vp8_calc_iframe_target_size(VP8_COMP * cpi)579 void vp8_calc_iframe_target_size(VP8_COMP *cpi)
580 {
581 int Q;
582 int Boost = 100;
583
584 Q = (cpi->oxcf.fixed_q >= 0) ? cpi->oxcf.fixed_q : cpi->avg_frame_qindex;
585
586 if (cpi->auto_adjust_key_quantizer == 1)
587 {
588 // If (auto_adjust_key_quantizer==1) then a lower Q is selected for key-frames.
589 // The enhanced Q is calculated so as to boost the key frame size by a factor
590 // specified in kf_boost_qadjustment. Also, can adjust based on distance
591 // between key frames.
592
593 // Adjust boost based upon ambient Q
594 Boost = vp8_kf_boost_qadjustment[Q];
595
596 // Make the Key frame boost less if the seperation from the previous key frame is small
597 if (cpi->frames_since_key < 16)
598 Boost = Boost * vp8_kf_boost_seperationt_adjustment[cpi->frames_since_key] / 100;
599 else
600 Boost = Boost * vp8_kf_boost_seperationt_adjustment[15] / 100;
601
602 // Apply limits on boost
603 if (Boost > vp8_kf_gf_boost_qlimits[Q])
604 Boost = vp8_kf_gf_boost_qlimits[Q];
605 else if (Boost < 120)
606 Boost = 120;
607 }
608
609 // Keep a record of the boost that was used
610 cpi->last_boost = Boost;
611
612 // Should the next frame be an altref frame
613 if (cpi->pass != 2)
614 {
615 // For now Alt ref is not allowed except in 2 pass modes.
616 cpi->source_alt_ref_pending = FALSE;
617
618 /*if ( cpi->oxcf.fixed_q == -1)
619 {
620 if ( cpi->oxcf.play_alternate && ( (cpi->last_boost/2) > (100+(AF_THRESH*cpi->frames_till_gf_update_due)) ) )
621 cpi->source_alt_ref_pending = TRUE;
622 else
623 cpi->source_alt_ref_pending = FALSE;
624 }*/
625 }
626
627 if (cpi->oxcf.fixed_q >= 0)
628 {
629 cpi->this_frame_target = (baseline_bits_at_q(0, Q, cpi->common.MBs) * Boost) / 100;
630 }
631 else
632 {
633
634 int bits_per_mb_at_this_q ;
635
636 if (cpi->oxcf.error_resilient_mode == 1)
637 {
638 cpi->this_frame_target = 2 * cpi->av_per_frame_bandwidth;
639 return;
640 }
641
642 // Rate targetted scenario:
643 // Be careful of 32-bit OVERFLOW if restructuring the caluclation of cpi->this_frame_target
644 bits_per_mb_at_this_q = (int)(.5 +
645 cpi->key_frame_rate_correction_factor * vp8_bits_per_mb[0][Q]);
646
647 cpi->this_frame_target = (((bits_per_mb_at_this_q * cpi->common.MBs) >> BPER_MB_NORMBITS) * Boost) / 100;
648
649 // Reset the active worst quality to the baseline value for key frames.
650 if (cpi->pass < 2)
651 cpi->active_worst_quality = cpi->worst_quality;
652 }
653 }
654
655
656
vp8_calc_pframe_target_size(VP8_COMP * cpi)657 void vp8_calc_pframe_target_size(VP8_COMP *cpi)
658 {
659 int min_frame_target;
660 int Adjustment;
661
662 // Set the min frame bandwidth.
663 //min_frame_target = estimate_min_frame_size( cpi );
664 min_frame_target = 0;
665
666 if (cpi->pass == 2)
667 {
668 min_frame_target = cpi->min_frame_bandwidth;
669
670 if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5))
671 min_frame_target = cpi->av_per_frame_bandwidth >> 5;
672 }
673 else if (min_frame_target < cpi->per_frame_bandwidth / 4)
674 min_frame_target = cpi->per_frame_bandwidth / 4;
675
676
677 // Special alt reference frame case
678 if (cpi->common.refresh_alt_ref_frame)
679 {
680 if (cpi->pass == 2)
681 {
682 cpi->per_frame_bandwidth = cpi->gf_bits; // Per frame bit target for the alt ref frame
683 cpi->this_frame_target = cpi->per_frame_bandwidth;
684 }
685
686 /* One Pass ??? TBD */
687 /*else
688 {
689 int frames_in_section;
690 int allocation_chunks;
691 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
692 int alt_boost;
693 int max_arf_rate;
694
695 alt_boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100);
696 alt_boost += (cpi->frames_till_gf_update_due * 50);
697
698 // If alt ref is not currently active then we have a pottential double hit with GF and ARF so reduce the boost a bit.
699 // A similar thing is done on GFs that preceed a arf update.
700 if ( !cpi->source_alt_ref_active )
701 alt_boost = alt_boost * 3 / 4;
702
703 frames_in_section = cpi->frames_till_gf_update_due+1; // Standard frames + GF
704 allocation_chunks = (frames_in_section * 100) + alt_boost;
705
706 // Normalize Altboost and allocations chunck down to prevent overflow
707 while ( alt_boost > 1000 )
708 {
709 alt_boost /= 2;
710 allocation_chunks /= 2;
711 }
712
713 else
714 {
715 int bits_in_section;
716
717 if ( cpi->kf_overspend_bits > 0 )
718 {
719 Adjustment = (cpi->kf_bitrate_adjustment <= cpi->kf_overspend_bits) ? cpi->kf_bitrate_adjustment : cpi->kf_overspend_bits;
720
721 if ( Adjustment > (cpi->per_frame_bandwidth - min_frame_target) )
722 Adjustment = (cpi->per_frame_bandwidth - min_frame_target);
723
724 cpi->kf_overspend_bits -= Adjustment;
725
726 // Calculate an inter frame bandwidth target for the next few frames designed to recover
727 // any extra bits spent on the key frame.
728 cpi->inter_frame_target = cpi->per_frame_bandwidth - Adjustment;
729 if ( cpi->inter_frame_target < min_frame_target )
730 cpi->inter_frame_target = min_frame_target;
731 }
732 else
733 cpi->inter_frame_target = cpi->per_frame_bandwidth;
734
735 bits_in_section = cpi->inter_frame_target * frames_in_section;
736
737 // Avoid loss of precision but avoid overflow
738 if ( (bits_in_section>>7) > allocation_chunks )
739 cpi->this_frame_target = alt_boost * (bits_in_section / allocation_chunks);
740 else
741 cpi->this_frame_target = (alt_boost * bits_in_section) / allocation_chunks;
742 }
743 }
744 */
745 }
746
747 // Normal frames (gf,and inter)
748 else
749 {
750 // 2 pass
751 if (cpi->pass == 2)
752 {
753 cpi->this_frame_target = cpi->per_frame_bandwidth;
754 }
755 // 1 pass
756 else
757 {
758 // Make rate adjustment to recover bits spent in key frame
759 // Test to see if the key frame inter data rate correction should still be in force
760 if (cpi->kf_overspend_bits > 0)
761 {
762 Adjustment = (cpi->kf_bitrate_adjustment <= cpi->kf_overspend_bits) ? cpi->kf_bitrate_adjustment : cpi->kf_overspend_bits;
763
764 if (Adjustment > (cpi->per_frame_bandwidth - min_frame_target))
765 Adjustment = (cpi->per_frame_bandwidth - min_frame_target);
766
767 cpi->kf_overspend_bits -= Adjustment;
768
769 // Calculate an inter frame bandwidth target for the next few frames designed to recover
770 // any extra bits spent on the key frame.
771 cpi->this_frame_target = cpi->per_frame_bandwidth - Adjustment;
772
773 if (cpi->this_frame_target < min_frame_target)
774 cpi->this_frame_target = min_frame_target;
775 }
776 else
777 cpi->this_frame_target = cpi->per_frame_bandwidth;
778
779 // If appropriate make an adjustment to recover bits spent on a recent GF
780 if ((cpi->gf_overspend_bits > 0) && (cpi->this_frame_target > min_frame_target))
781 {
782 int Adjustment = (cpi->non_gf_bitrate_adjustment <= cpi->gf_overspend_bits) ? cpi->non_gf_bitrate_adjustment : cpi->gf_overspend_bits;
783
784 if (Adjustment > (cpi->this_frame_target - min_frame_target))
785 Adjustment = (cpi->this_frame_target - min_frame_target);
786
787 cpi->gf_overspend_bits -= Adjustment;
788 cpi->this_frame_target -= Adjustment;
789 }
790
791 // Apply small + and - boosts for non gf frames
792 if ((cpi->last_boost > 150) && (cpi->frames_till_gf_update_due > 0) &&
793 (cpi->current_gf_interval >= (MIN_GF_INTERVAL << 1)))
794 {
795 // % Adjustment limited to the range 1% to 10%
796 Adjustment = (cpi->last_boost - 100) >> 5;
797
798 if (Adjustment < 1)
799 Adjustment = 1;
800 else if (Adjustment > 10)
801 Adjustment = 10;
802
803 // Convert to bits
804 Adjustment = (cpi->this_frame_target * Adjustment) / 100;
805
806 if (Adjustment > (cpi->this_frame_target - min_frame_target))
807 Adjustment = (cpi->this_frame_target - min_frame_target);
808
809 if (cpi->common.frames_since_golden == (cpi->current_gf_interval >> 1))
810 cpi->this_frame_target += ((cpi->current_gf_interval - 1) * Adjustment);
811 else
812 cpi->this_frame_target -= Adjustment;
813 }
814 }
815 }
816
817 // Set a reduced data rate target for our initial Q calculation.
818 // This should help to save bits during earier sections.
819 if ((cpi->oxcf.under_shoot_pct > 0) && (cpi->oxcf.under_shoot_pct <= 100))
820 cpi->this_frame_target = (cpi->this_frame_target * cpi->oxcf.under_shoot_pct) / 100;
821
822 // Sanity check that the total sum of adjustments is not above the maximum allowed
823 // That is that having allowed for KF and GF penalties we have not pushed the
824 // current interframe target to low. If the adjustment we apply here is not capable of recovering
825 // all the extra bits we have spent in the KF or GF then the remainder will have to be recovered over
826 // a longer time span via other buffer / rate control mechanisms.
827 if (cpi->this_frame_target < min_frame_target)
828 cpi->this_frame_target = min_frame_target;
829
830 if (!cpi->common.refresh_alt_ref_frame)
831 // Note the baseline target data rate for this inter frame.
832 cpi->inter_frame_target = cpi->this_frame_target;
833
834 // One Pass specific code
835 if (cpi->pass == 0)
836 {
837 // Adapt target frame size with respect to any buffering constraints:
838 if (cpi->buffered_mode)
839 {
840 int one_percent_bits = 1 + cpi->oxcf.optimal_buffer_level / 100;
841
842 if ((cpi->buffer_level < cpi->oxcf.optimal_buffer_level) || (cpi->bits_off_target < cpi->oxcf.optimal_buffer_level))
843 {
844 int percent_low = 0;
845
846 // Decide whether or not we need to adjust the frame data rate target.
847 //
848 // If we are are below the optimal buffer fullness level and adherence
849 // to buffering contraints is important to the end useage then adjust
850 // the per frame target.
851 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) && (cpi->buffer_level < cpi->oxcf.optimal_buffer_level))
852 {
853 percent_low = (cpi->oxcf.optimal_buffer_level - cpi->buffer_level) / one_percent_bits;
854
855 if (percent_low > 100)
856 percent_low = 100;
857 else if (percent_low < 0)
858 percent_low = 0;
859 }
860 // Are we overshooting the long term clip data rate...
861 else if (cpi->bits_off_target < 0)
862 {
863 // Adjust per frame data target downwards to compensate.
864 percent_low = (int)(100 * -cpi->bits_off_target / (cpi->total_byte_count * 8));
865
866 if (percent_low > 100)
867 percent_low = 100;
868 else if (percent_low < 0)
869 percent_low = 0;
870 }
871
872 // lower the target bandwidth for this frame.
873 cpi->this_frame_target = (cpi->this_frame_target * (100 - (percent_low / 2))) / 100;
874
875 // Are we using allowing control of active_worst_allowed_q according to buffer level.
876 if (cpi->auto_worst_q)
877 {
878 int critical_buffer_level;
879
880 // For streaming applications the most important factor is cpi->buffer_level as this takes
881 // into account the specified short term buffering constraints. However, hitting the long
882 // term clip data rate target is also important.
883 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
884 {
885 // Take the smaller of cpi->buffer_level and cpi->bits_off_target
886 critical_buffer_level = (cpi->buffer_level < cpi->bits_off_target) ? cpi->buffer_level : cpi->bits_off_target;
887 }
888 // For local file playback short term buffering contraints are less of an issue
889 else
890 {
891 // Consider only how we are doing for the clip as a whole
892 critical_buffer_level = cpi->bits_off_target;
893 }
894
895 // Set the active worst quality based upon the selected buffer fullness number.
896 if (critical_buffer_level < cpi->oxcf.optimal_buffer_level)
897 {
898 if (critical_buffer_level > (cpi->oxcf.optimal_buffer_level / 4))
899 {
900 int qadjustment_range = cpi->worst_quality - cpi->ni_av_qi;
901 int above_base = (critical_buffer_level - (cpi->oxcf.optimal_buffer_level / 4));
902
903 // Step active worst quality down from cpi->ni_av_qi when (critical_buffer_level == cpi->optimal_buffer_level)
904 // to cpi->oxcf.worst_allowed_q when (critical_buffer_level == cpi->optimal_buffer_level/4)
905 cpi->active_worst_quality = cpi->worst_quality - ((qadjustment_range * above_base) / (cpi->oxcf.optimal_buffer_level * 3 / 4));
906 }
907 else
908 {
909 cpi->active_worst_quality = cpi->worst_quality;
910 }
911 }
912 else
913 {
914 cpi->active_worst_quality = cpi->ni_av_qi;
915 }
916 }
917 else
918 {
919 cpi->active_worst_quality = cpi->worst_quality;
920 }
921 }
922 else
923 {
924 int percent_high;
925
926 if (cpi->bits_off_target > cpi->oxcf.optimal_buffer_level)
927 {
928 percent_high = (int)(100 * (cpi->bits_off_target - cpi->oxcf.optimal_buffer_level) / (cpi->total_byte_count * 8));
929
930 if (percent_high > 100)
931 percent_high = 100;
932 else if (percent_high < 0)
933 percent_high = 0;
934
935 cpi->this_frame_target = (cpi->this_frame_target * (100 + (percent_high / 2))) / 100;
936
937 }
938
939 // Are we allowing control of active_worst_allowed_q according to bufferl level.
940 if (cpi->auto_worst_q)
941 {
942 // When using the relaxed buffer model stick to the user specified value
943 cpi->active_worst_quality = cpi->ni_av_qi;
944 }
945 else
946 {
947 cpi->active_worst_quality = cpi->worst_quality;
948 }
949 }
950
951 // Set active_best_quality to prevent quality rising too high
952 cpi->active_best_quality = cpi->best_quality;
953
954 // Worst quality obviously must not be better than best quality
955 if (cpi->active_worst_quality <= cpi->active_best_quality)
956 cpi->active_worst_quality = cpi->active_best_quality + 1;
957
958 }
959 // Unbuffered mode (eg. video conferencing)
960 else
961 {
962 // Set the active worst quality
963 cpi->active_worst_quality = cpi->worst_quality;
964 }
965 }
966
967 // Test to see if we have to drop a frame
968 // The auto-drop frame code is only used in buffered mode.
969 // In unbufferd mode (eg vide conferencing) the descision to
970 // code or drop a frame is made outside the codec in response to real
971 // world comms or buffer considerations.
972 if (cpi->drop_frames_allowed && cpi->buffered_mode &&
973 (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
974 ((cpi->common.frame_type != KEY_FRAME))) //|| !cpi->oxcf.allow_spatial_resampling) )
975 {
976 // Check for a buffer underun-crisis in which case we have to drop a frame
977 if ((cpi->buffer_level < 0))
978 {
979 #if 0
980 FILE *f = fopen("dec.stt", "a");
981 fprintf(f, "%10d %10d %10d %10d ***** BUFFER EMPTY\n",
982 (int) cpi->common.current_video_frame,
983 cpi->decimation_factor, cpi->common.horiz_scale,
984 (cpi->buffer_level * 100) / cpi->oxcf.optimal_buffer_level);
985 fclose(f);
986 #endif
987 //vpx_log("Decoder: Drop frame due to bandwidth: %d \n",cpi->buffer_level, cpi->av_per_frame_bandwidth);
988
989 cpi->drop_frame = TRUE;
990 }
991
992 #if 0
993 // Check for other drop frame crtieria (Note 2 pass cbr uses decimation on whole KF sections)
994 else if ((cpi->buffer_level < cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100) &&
995 (cpi->drop_count < cpi->max_drop_count) && (cpi->pass == 0))
996 {
997 cpi->drop_frame = TRUE;
998 }
999
1000 #endif
1001
1002 if (cpi->drop_frame)
1003 {
1004 // Update the buffer level variable.
1005 cpi->bits_off_target += cpi->av_per_frame_bandwidth;
1006 cpi->buffer_level = cpi->bits_off_target;
1007 }
1008 else
1009 cpi->drop_count = 0;
1010 }
1011
1012 // Adjust target frame size for Golden Frames:
1013 if (cpi->oxcf.error_resilient_mode == 0 &&
1014 (cpi->frames_till_gf_update_due == 0) && !cpi->drop_frame)
1015 {
1016 //int Boost = 0;
1017 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
1018
1019 int gf_frame_useage = 0; // Golden frame useage since last GF
1020 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
1021 cpi->recent_ref_frame_usage[LAST_FRAME] +
1022 cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
1023 cpi->recent_ref_frame_usage[ALTREF_FRAME];
1024
1025 int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols);
1026
1027 // Reset the last boost indicator
1028 //cpi->last_boost = 100;
1029
1030 if (tot_mbs)
1031 gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs;
1032
1033 if (pct_gf_active > gf_frame_useage)
1034 gf_frame_useage = pct_gf_active;
1035
1036 // Is a fixed manual GF frequency being used
1037 if (!cpi->auto_gold)
1038 cpi->common.refresh_golden_frame = TRUE;
1039 else
1040 {
1041 // For one pass throw a GF if recent frame intra useage is low or the GF useage is high
1042 if ((cpi->pass == 0) && (cpi->this_frame_percent_intra < 15 || gf_frame_useage >= 5))
1043 cpi->common.refresh_golden_frame = TRUE;
1044
1045 // Two pass GF descision
1046 else if (cpi->pass == 2)
1047 cpi->common.refresh_golden_frame = TRUE;
1048 }
1049
1050 #if 0
1051
1052 // Debug stats
1053 if (0)
1054 {
1055 FILE *f;
1056
1057 f = fopen("gf_useaget.stt", "a");
1058 fprintf(f, " %8ld %10ld %10ld %10ld %10ld\n",
1059 cpi->common.current_video_frame, cpi->gfu_boost, GFQ_ADJUSTMENT, cpi->gfu_boost, gf_frame_useage);
1060 fclose(f);
1061 }
1062
1063 #endif
1064
1065 if (cpi->common.refresh_golden_frame == TRUE)
1066 {
1067 #if 0
1068
1069 if (0) // p_gw
1070 {
1071 FILE *f;
1072
1073 f = fopen("GFexit.stt", "a");
1074 fprintf(f, "%8ld GF coded\n", cpi->common.current_video_frame);
1075 fclose(f);
1076 }
1077
1078 #endif
1079 cpi->initial_gf_use = 0;
1080
1081 if (cpi->auto_adjust_gold_quantizer)
1082 {
1083 calc_gf_params(cpi);
1084 }
1085
1086 // If we are using alternate ref instead of gf then do not apply the boost
1087 // It will instead be applied to the altref update
1088 // Jims modified boost
1089 if (!cpi->source_alt_ref_active)
1090 {
1091 if (cpi->oxcf.fixed_q < 0)
1092 {
1093 if (cpi->pass == 2)
1094 {
1095 cpi->this_frame_target = cpi->per_frame_bandwidth; // The spend on the GF is defined in the two pass code for two pass encodes
1096 }
1097 else
1098 {
1099 int Boost = cpi->last_boost;
1100 int frames_in_section = cpi->frames_till_gf_update_due + 1;
1101 int allocation_chunks = (frames_in_section * 100) + (Boost - 100);
1102 int bits_in_section = cpi->inter_frame_target * frames_in_section;
1103
1104 // Normalize Altboost and allocations chunck down to prevent overflow
1105 while (Boost > 1000)
1106 {
1107 Boost /= 2;
1108 allocation_chunks /= 2;
1109 }
1110
1111 // Avoid loss of precision but avoid overflow
1112 if ((bits_in_section >> 7) > allocation_chunks)
1113 cpi->this_frame_target = Boost * (bits_in_section / allocation_chunks);
1114 else
1115 cpi->this_frame_target = (Boost * bits_in_section) / allocation_chunks;
1116 }
1117 }
1118 else
1119 cpi->this_frame_target = (baseline_bits_at_q(1, Q, cpi->common.MBs) * cpi->last_boost) / 100;
1120
1121 }
1122 // If there is an active ARF at this location use the minimum
1123 // bits on this frame even if it is a contructed arf.
1124 // The active maximum quantizer insures that an appropriate
1125 // number of bits will be spent if needed for contstructed ARFs.
1126 else
1127 {
1128 cpi->this_frame_target = 0;
1129 }
1130
1131 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
1132
1133 }
1134 }
1135 }
1136
1137
vp8_update_rate_correction_factors(VP8_COMP * cpi,int damp_var)1138 void vp8_update_rate_correction_factors(VP8_COMP *cpi, int damp_var)
1139 {
1140 int Q = cpi->common.base_qindex;
1141 int correction_factor = 100;
1142 double rate_correction_factor;
1143 double adjustment_limit;
1144
1145 int projected_size_based_on_q = 0;
1146
1147 // Clear down mmx registers to allow floating point in what follows
1148 vp8_clear_system_state(); //__asm emms;
1149
1150 if (cpi->common.frame_type == KEY_FRAME)
1151 {
1152 rate_correction_factor = cpi->key_frame_rate_correction_factor;
1153 }
1154 else
1155 {
1156 if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1157 rate_correction_factor = cpi->gf_rate_correction_factor;
1158 else
1159 rate_correction_factor = cpi->rate_correction_factor;
1160 }
1161
1162 // Work out how big we would have expected the frame to be at this Q given the current correction factor.
1163 // Stay in double to avoid int overflow when values are large
1164 //projected_size_based_on_q = ((int)(.5 + rate_correction_factor * vp8_bits_per_mb[cpi->common.frame_type][Q]) * cpi->common.MBs) >> BPER_MB_NORMBITS;
1165 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));
1166
1167 // Make some allowance for cpi->zbin_over_quant
1168 if (cpi->zbin_over_quant > 0)
1169 {
1170 int Z = cpi->zbin_over_quant;
1171 double Factor = 0.99;
1172 double factor_adjustment = 0.01 / 256.0; //(double)ZBIN_OQ_MAX;
1173
1174 while (Z > 0)
1175 {
1176 Z --;
1177 projected_size_based_on_q =
1178 (int)(Factor * projected_size_based_on_q);
1179 Factor += factor_adjustment;
1180
1181 if (Factor >= 0.999)
1182 Factor = 0.999;
1183 }
1184 }
1185
1186 // Work out a size correction factor.
1187 //if ( cpi->this_frame_target > 0 )
1188 // correction_factor = (100 * cpi->projected_frame_size) / cpi->this_frame_target;
1189 if (projected_size_based_on_q > 0)
1190 correction_factor = (100 * cpi->projected_frame_size) / projected_size_based_on_q;
1191
1192 // More heavily damped adjustment used if we have been oscillating either side of target
1193 switch (damp_var)
1194 {
1195 case 0:
1196 adjustment_limit = 0.75;
1197 break;
1198 case 1:
1199 adjustment_limit = 0.375;
1200 break;
1201 case 2:
1202 default:
1203 adjustment_limit = 0.25;
1204 break;
1205 }
1206
1207 //if ( (correction_factor > 102) && (Q < cpi->active_worst_quality) )
1208 if (correction_factor > 102)
1209 {
1210 // We are not already at the worst allowable quality
1211 correction_factor = (int)(100.5 + ((correction_factor - 100) * adjustment_limit));
1212 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1213
1214 // Keep rate_correction_factor within limits
1215 if (rate_correction_factor > MAX_BPB_FACTOR)
1216 rate_correction_factor = MAX_BPB_FACTOR;
1217 }
1218 //else if ( (correction_factor < 99) && (Q > cpi->active_best_quality) )
1219 else if (correction_factor < 99)
1220 {
1221 // We are not already at the best allowable quality
1222 correction_factor = (int)(100.5 - ((100 - correction_factor) * adjustment_limit));
1223 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1224
1225 // Keep rate_correction_factor within limits
1226 if (rate_correction_factor < MIN_BPB_FACTOR)
1227 rate_correction_factor = MIN_BPB_FACTOR;
1228 }
1229
1230 if (cpi->common.frame_type == KEY_FRAME)
1231 cpi->key_frame_rate_correction_factor = rate_correction_factor;
1232 else
1233 {
1234 if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1235 cpi->gf_rate_correction_factor = rate_correction_factor;
1236 else
1237 cpi->rate_correction_factor = rate_correction_factor;
1238 }
1239 }
1240
estimate_bits_at_q(VP8_COMP * cpi,int Q)1241 static int estimate_bits_at_q(VP8_COMP *cpi, int Q)
1242 {
1243 int Bpm = (int)(.5 + cpi->rate_correction_factor * vp8_bits_per_mb[INTER_FRAME][Q]);
1244
1245 /* Attempt to retain reasonable accuracy without overflow. The cutoff is
1246 * chosen such that the maximum product of Bpm and MBs fits 31 bits. The
1247 * largest Bpm takes 20 bits.
1248 */
1249 if (cpi->common.MBs > (1 << 11))
1250 return (Bpm >> BPER_MB_NORMBITS) * cpi->common.MBs;
1251 else
1252 return (Bpm * cpi->common.MBs) >> BPER_MB_NORMBITS;
1253
1254 }
1255
1256
vp8_regulate_q(VP8_COMP * cpi,int target_bits_per_frame)1257 int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame)
1258 {
1259 int Q = cpi->active_worst_quality;
1260
1261 // Reset Zbin OQ value
1262 cpi->zbin_over_quant = 0;
1263
1264 if (cpi->oxcf.fixed_q >= 0)
1265 {
1266 Q = cpi->oxcf.fixed_q;
1267
1268 if (cpi->common.frame_type == KEY_FRAME)
1269 {
1270 Q = cpi->oxcf.key_q;
1271 }
1272 else if (cpi->common.refresh_alt_ref_frame)
1273 {
1274 Q = cpi->oxcf.alt_q;
1275 }
1276 else if (cpi->common.refresh_golden_frame)
1277 {
1278 Q = cpi->oxcf.gold_q;
1279 }
1280
1281 }
1282 else
1283 {
1284 int i;
1285 int last_error = INT_MAX;
1286 int target_bits_per_mb;
1287 int bits_per_mb_at_this_q;
1288 double correction_factor;
1289
1290 // Select the appropriate correction factor based upon type of frame.
1291 if (cpi->common.frame_type == KEY_FRAME)
1292 correction_factor = cpi->key_frame_rate_correction_factor;
1293 else
1294 {
1295 if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1296 correction_factor = cpi->gf_rate_correction_factor;
1297 else
1298 correction_factor = cpi->rate_correction_factor;
1299 }
1300
1301 // Calculate required scaling factor based on target frame size and size of frame produced using previous Q
1302 if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
1303 target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs) << BPER_MB_NORMBITS; // Case where we would overflow int
1304 else
1305 target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
1306
1307 i = cpi->active_best_quality;
1308
1309 do
1310 {
1311 bits_per_mb_at_this_q = (int)(.5 + correction_factor * vp8_bits_per_mb[cpi->common.frame_type][i]);
1312
1313 if (bits_per_mb_at_this_q <= target_bits_per_mb)
1314 {
1315 if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
1316 Q = i;
1317 else
1318 Q = i - 1;
1319
1320 break;
1321 }
1322 else
1323 last_error = bits_per_mb_at_this_q - target_bits_per_mb;
1324 }
1325 while (++i <= cpi->active_worst_quality);
1326
1327
1328 // If we are at MAXQ then enable Q over-run which seeks to claw back additional bits through things like
1329 // the RD multiplier and zero bin size.
1330 if (Q >= MAXQ)
1331 {
1332 int zbin_oqmax;
1333
1334 double Factor = 0.99;
1335 double factor_adjustment = 0.01 / 256.0; //(double)ZBIN_OQ_MAX;
1336
1337 if (cpi->common.frame_type == KEY_FRAME)
1338 zbin_oqmax = 0; //ZBIN_OQ_MAX/16
1339 else if (cpi->common.refresh_alt_ref_frame || (cpi->common.refresh_golden_frame && !cpi->source_alt_ref_active))
1340 zbin_oqmax = 16;
1341 else
1342 zbin_oqmax = ZBIN_OQ_MAX;
1343
1344 /*{
1345 double Factor = (double)target_bits_per_mb/(double)bits_per_mb_at_this_q;
1346 double Oq;
1347
1348 Factor = Factor/1.2683;
1349
1350 Oq = pow( Factor, (1.0/-0.165) );
1351
1352 if ( Oq > zbin_oqmax )
1353 Oq = zbin_oqmax;
1354
1355 cpi->zbin_over_quant = (int)Oq;
1356 }*/
1357
1358 // Each incrment in the zbin is assumed to have a fixed effect on bitrate. This is not of course true.
1359 // The effect will be highly clip dependent and may well have sudden steps.
1360 // The idea here is to acheive higher effective quantizers than the normal maximum by expanding the zero
1361 // bin and hence decreasing the number of low magnitude non zero coefficients.
1362 while (cpi->zbin_over_quant < zbin_oqmax)
1363 {
1364 cpi->zbin_over_quant ++;
1365
1366 if (cpi->zbin_over_quant > zbin_oqmax)
1367 cpi->zbin_over_quant = zbin_oqmax;
1368
1369 // Adjust bits_per_mb_at_this_q estimate
1370 bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q);
1371 Factor += factor_adjustment;
1372
1373 if (Factor >= 0.999)
1374 Factor = 0.999;
1375
1376 if (bits_per_mb_at_this_q <= target_bits_per_mb) // Break out if we get down to the target rate
1377 break;
1378 }
1379
1380 }
1381 }
1382
1383 return Q;
1384 }
1385
estimate_min_frame_size(VP8_COMP * cpi)1386 static int estimate_min_frame_size(VP8_COMP *cpi)
1387 {
1388 double correction_factor;
1389 int bits_per_mb_at_max_q;
1390
1391 // This funtion returns a default value for the first few frames untill the correction factor has had time to adapt.
1392 if (cpi->common.current_video_frame < 10)
1393 {
1394 if (cpi->pass == 2)
1395 return (cpi->min_frame_bandwidth);
1396 else
1397 return cpi->per_frame_bandwidth / 3;
1398 }
1399
1400 /* // Select the appropriate correction factor based upon type of frame.
1401 if ( cpi->common.frame_type == KEY_FRAME )
1402 correction_factor = cpi->key_frame_rate_correction_factor;
1403 else
1404 {
1405 if ( cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame )
1406 correction_factor = cpi->gf_rate_correction_factor;
1407 else
1408 correction_factor = cpi->rate_correction_factor;
1409 }*/
1410
1411 // We estimate at half the value we get from vp8_bits_per_mb
1412 correction_factor = cpi->rate_correction_factor / 2.0;
1413
1414 bits_per_mb_at_max_q = (int)(.5 + correction_factor * vp8_bits_per_mb[cpi->common.frame_type][MAXQ]);
1415
1416 return (bits_per_mb_at_max_q * cpi->common.MBs) >> BPER_MB_NORMBITS;
1417 }
1418
vp8_adjust_key_frame_context(VP8_COMP * cpi)1419 void vp8_adjust_key_frame_context(VP8_COMP *cpi)
1420 {
1421 int i;
1422 int av_key_frames_per_second;
1423
1424 // Average key frame frequency and size
1425 unsigned int total_weight = 0;
1426 unsigned int av_key_frame_frequency = 0;
1427 unsigned int av_key_frame_bits = 0;
1428
1429 unsigned int output_frame_rate = (unsigned int)(100 * cpi->output_frame_rate);
1430 unsigned int target_bandwidth = (unsigned int)(100 * cpi->target_bandwidth);
1431
1432 // Clear down mmx registers to allow floating point in what follows
1433 vp8_clear_system_state(); //__asm emms;
1434
1435 // Update the count of total key frame bits
1436 cpi->tot_key_frame_bits += cpi->projected_frame_size;
1437
1438 // First key frame at start of sequence is a special case. We have no frequency data.
1439 if (cpi->key_frame_count == 1)
1440 {
1441 av_key_frame_frequency = (int)cpi->output_frame_rate * 2; // Assume a default of 1 kf every 2 seconds
1442 av_key_frame_bits = cpi->projected_frame_size;
1443 av_key_frames_per_second = output_frame_rate / av_key_frame_frequency; // Note output_frame_rate not cpi->output_frame_rate
1444 }
1445 else
1446 {
1447 int last_kf_interval =
1448 (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;
1449
1450 // reset keyframe context and calculate weighted average of last KEY_FRAME_CONTEXT keyframes
1451 for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1452 {
1453 if (i < KEY_FRAME_CONTEXT - 1)
1454 {
1455 cpi->prior_key_frame_size[i] = cpi->prior_key_frame_size[i+1];
1456 cpi->prior_key_frame_distance[i] = cpi->prior_key_frame_distance[i+1];
1457 }
1458 else
1459 {
1460 cpi->prior_key_frame_size[i] = cpi->projected_frame_size;
1461 cpi->prior_key_frame_distance[i] = last_kf_interval;
1462 }
1463
1464 av_key_frame_bits += prior_key_frame_weight[i] * cpi->prior_key_frame_size[i];
1465 av_key_frame_frequency += prior_key_frame_weight[i] * cpi->prior_key_frame_distance[i];
1466 total_weight += prior_key_frame_weight[i];
1467 }
1468
1469 av_key_frame_bits /= total_weight;
1470 av_key_frame_frequency /= total_weight;
1471 av_key_frames_per_second = output_frame_rate / av_key_frame_frequency;
1472
1473 }
1474
1475 // Do we have any key frame overspend to recover?
1476 if ((cpi->pass != 2) && (cpi->projected_frame_size > cpi->per_frame_bandwidth))
1477 {
1478 // Update the count of key frame overspend to be recovered in subsequent frames
1479 // A portion of the KF overspend is treated as gf overspend (and hence recovered more quickly)
1480 // as the kf is also a gf. Otherwise the few frames following each kf tend to get more bits
1481 // allocated than those following other gfs.
1482 cpi->kf_overspend_bits += (cpi->projected_frame_size - cpi->per_frame_bandwidth) * 7 / 8;
1483 cpi->gf_overspend_bits += (cpi->projected_frame_size - cpi->per_frame_bandwidth) * 1 / 8;
1484 if(!av_key_frame_frequency)
1485 av_key_frame_frequency = 60;
1486
1487 // Work out how much to try and recover per frame.
1488 // For one pass we estimate the number of frames to spread it over based upon past history.
1489 // For two pass we know how many frames there will be till the next kf.
1490 if (cpi->pass == 2)
1491 {
1492 if (cpi->frames_to_key > 16)
1493 cpi->kf_bitrate_adjustment = cpi->kf_overspend_bits / (int)cpi->frames_to_key;
1494 else
1495 cpi->kf_bitrate_adjustment = cpi->kf_overspend_bits / 16;
1496 }
1497 else
1498 cpi->kf_bitrate_adjustment = cpi->kf_overspend_bits / (int)av_key_frame_frequency;
1499 }
1500
1501 cpi->frames_since_key = 0;
1502 cpi->last_key_frame_size = cpi->projected_frame_size;
1503 cpi->key_frame_count++;
1504 }
1505
vp8_compute_frame_size_bounds(VP8_COMP * cpi,int * frame_under_shoot_limit,int * frame_over_shoot_limit)1506 void vp8_compute_frame_size_bounds(VP8_COMP *cpi, int *frame_under_shoot_limit, int *frame_over_shoot_limit)
1507 {
1508 // Set-up bounds on acceptable frame size:
1509 if (cpi->oxcf.fixed_q >= 0)
1510 {
1511 // Fixed Q scenario: frame size never outranges target (there is no target!)
1512 *frame_under_shoot_limit = 0;
1513 *frame_over_shoot_limit = INT_MAX;
1514 }
1515 else
1516 {
1517 if (cpi->common.frame_type == KEY_FRAME)
1518 {
1519 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
1520 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1521 }
1522 else
1523 {
1524 if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1525 {
1526 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
1527 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1528 }
1529 else
1530 {
1531 // For CBR take buffer fullness into account
1532 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
1533 {
1534 if (cpi->buffer_level >= ((cpi->oxcf.optimal_buffer_level + cpi->oxcf.maximum_buffer_size) >> 1))
1535 {
1536 // Buffer is too full so relax overshoot and tighten undershoot
1537 *frame_over_shoot_limit = cpi->this_frame_target * 12 / 8;
1538 *frame_under_shoot_limit = cpi->this_frame_target * 6 / 8;
1539 }
1540 else if (cpi->buffer_level <= (cpi->oxcf.optimal_buffer_level >> 1))
1541 {
1542 // Buffer is too low so relax undershoot and tighten overshoot
1543 *frame_over_shoot_limit = cpi->this_frame_target * 10 / 8;
1544 *frame_under_shoot_limit = cpi->this_frame_target * 4 / 8;
1545 }
1546 else
1547 {
1548 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1549 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1550 }
1551 }
1552 // VBR
1553 // Note that tighter restrictions here can help quality but hurt encode speed
1554 else
1555 {
1556 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1557 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1558 }
1559 }
1560 }
1561 }
1562 }
1563