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