2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
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.
19 #include "vp8/common/common.h"
21 #include "vp8/common/entropymode.h"
22 #include "vpx_mem/vpx_mem.h"
23 #include "vp8/common/systemdependent.h"
27 #define MIN_BPB_FACTOR 0.01
28 #define MAX_BPB_FACTOR 50
30 extern const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES];
35 extern int y_modes[5];
36 extern int uv_modes[4];
37 extern int b_modes[10];
39 extern int inter_y_modes[10];
40 extern int inter_uv_modes[4];
41 extern int inter_b_modes[10];
44 // Bits Per MB at different Q (Multiplied by 512)
45 #define BPER_MB_NORMBITS 9
47 // Work in progress recalibration of baseline rate tables based on
48 // the assumption that bits per mb is inversely proportional to the
50 const int vp8_bits_per_mb[2][QINDEX_RANGE] =
52 // Intra case 450000/Qintra
54 1125000,900000, 750000, 642857, 562500, 500000, 450000, 450000,
55 409090, 375000, 346153, 321428, 300000, 281250, 264705, 264705,
56 250000, 236842, 225000, 225000, 214285, 214285, 204545, 204545,
57 195652, 195652, 187500, 180000, 180000, 173076, 166666, 160714,
58 155172, 150000, 145161, 140625, 136363, 132352, 128571, 125000,
59 121621, 121621, 118421, 115384, 112500, 109756, 107142, 104651,
60 102272, 100000, 97826, 97826, 95744, 93750, 91836, 90000,
61 88235, 86538, 84905, 83333, 81818, 80357, 78947, 77586,
62 76271, 75000, 73770, 72580, 71428, 70312, 69230, 68181,
63 67164, 66176, 65217, 64285, 63380, 62500, 61643, 60810,
64 60000, 59210, 59210, 58441, 57692, 56962, 56250, 55555,
65 54878, 54216, 53571, 52941, 52325, 51724, 51136, 50561,
66 49450, 48387, 47368, 46875, 45918, 45000, 44554, 44117,
67 43269, 42452, 41666, 40909, 40178, 39473, 38793, 38135,
68 36885, 36290, 35714, 35156, 34615, 34090, 33582, 33088,
69 32608, 32142, 31468, 31034, 30405, 29801, 29220, 28662,
71 // Inter case 285000/Qinter
73 712500, 570000, 475000, 407142, 356250, 316666, 285000, 259090,
74 237500, 219230, 203571, 190000, 178125, 167647, 158333, 150000,
75 142500, 135714, 129545, 123913, 118750, 114000, 109615, 105555,
76 101785, 98275, 95000, 91935, 89062, 86363, 83823, 81428,
77 79166, 77027, 75000, 73076, 71250, 69512, 67857, 66279,
78 64772, 63333, 61956, 60638, 59375, 58163, 57000, 55882,
79 54807, 53773, 52777, 51818, 50892, 50000, 49137, 47500,
80 45967, 44531, 43181, 41911, 40714, 39583, 38513, 37500,
81 36538, 35625, 34756, 33928, 33139, 32386, 31666, 30978,
82 30319, 29687, 29081, 28500, 27941, 27403, 26886, 26388,
83 25909, 25446, 25000, 24568, 23949, 23360, 22800, 22265,
84 21755, 21268, 20802, 20357, 19930, 19520, 19127, 18750,
85 18387, 18037, 17701, 17378, 17065, 16764, 16473, 16101,
86 15745, 15405, 15079, 14766, 14467, 14179, 13902, 13636,
87 13380, 13133, 12895, 12666, 12445, 12179, 11924, 11632,
88 11445, 11220, 11003, 10795, 10594, 10401, 10215, 10035,
92 static const int kf_boost_qadjustment[QINDEX_RANGE] =
94 128, 129, 130, 131, 132, 133, 134, 135,
95 136, 137, 138, 139, 140, 141, 142, 143,
96 144, 145, 146, 147, 148, 149, 150, 151,
97 152, 153, 154, 155, 156, 157, 158, 159,
98 160, 161, 162, 163, 164, 165, 166, 167,
99 168, 169, 170, 171, 172, 173, 174, 175,
100 176, 177, 178, 179, 180, 181, 182, 183,
101 184, 185, 186, 187, 188, 189, 190, 191,
102 192, 193, 194, 195, 196, 197, 198, 199,
103 200, 200, 201, 201, 202, 203, 203, 203,
104 204, 204, 205, 205, 206, 206, 207, 207,
105 208, 208, 209, 209, 210, 210, 211, 211,
106 212, 212, 213, 213, 214, 214, 215, 215,
107 216, 216, 217, 217, 218, 218, 219, 219,
108 220, 220, 220, 220, 220, 220, 220, 220,
109 220, 220, 220, 220, 220, 220, 220, 220,
112 //#define GFQ_ADJUSTMENT (Q+100)
113 #define GFQ_ADJUSTMENT vp8_gf_boost_qadjustment[Q]
114 const int vp8_gf_boost_qadjustment[QINDEX_RANGE] =
116 80, 82, 84, 86, 88, 90, 92, 94,
117 96, 97, 98, 99, 100, 101, 102, 103,
118 104, 105, 106, 107, 108, 109, 110, 111,
119 112, 113, 114, 115, 116, 117, 118, 119,
120 120, 121, 122, 123, 124, 125, 126, 127,
121 128, 129, 130, 131, 132, 133, 134, 135,
122 136, 137, 138, 139, 140, 141, 142, 143,
123 144, 145, 146, 147, 148, 149, 150, 151,
124 152, 153, 154, 155, 156, 157, 158, 159,
125 160, 161, 162, 163, 164, 165, 166, 167,
126 168, 169, 170, 171, 172, 173, 174, 175,
127 176, 177, 178, 179, 180, 181, 182, 183,
128 184, 184, 185, 185, 186, 186, 187, 187,
129 188, 188, 189, 189, 190, 190, 191, 191,
130 192, 192, 193, 193, 194, 194, 194, 194,
131 195, 195, 196, 196, 197, 197, 198, 198
135 const int vp8_gf_boost_qadjustment[QINDEX_RANGE] =
137 100,101,102,103,104,105,105,106,
138 106,107,107,108,109,109,110,111,
139 112,113,114,115,116,117,118,119,
140 120,121,122,123,124,125,126,127,
141 128,129,130,131,132,133,134,135,
142 136,137,138,139,140,141,142,143,
143 144,145,146,147,148,149,150,151,
144 152,153,154,155,156,157,158,159,
145 160,161,162,163,164,165,166,167,
146 168,169,170,170,171,171,172,172,
147 173,173,173,174,174,174,175,175,
148 175,176,176,176,177,177,177,177,
149 178,178,179,179,180,180,181,181,
150 182,182,183,183,184,184,185,185,
151 186,186,187,187,188,188,189,189,
152 190,190,191,191,192,192,193,193,
156 static const int kf_gf_boost_qlimits[QINDEX_RANGE] =
158 150, 155, 160, 165, 170, 175, 180, 185,
159 190, 195, 200, 205, 210, 215, 220, 225,
160 230, 235, 240, 245, 250, 255, 260, 265,
161 270, 275, 280, 285, 290, 295, 300, 305,
162 310, 320, 330, 340, 350, 360, 370, 380,
163 390, 400, 410, 420, 430, 440, 450, 460,
164 470, 480, 490, 500, 510, 520, 530, 540,
165 550, 560, 570, 580, 590, 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 600, 600, 600, 600, 600, 600, 600, 600,
176 // % adjustment to target kf size based on seperation from previous frame
177 static const int kf_boost_seperation_adjustment[16] =
179 30, 40, 50, 55, 60, 65, 70, 75,
180 80, 85, 90, 95, 100, 100, 100, 100,
184 static const int gf_adjust_table[101] =
187 115, 130, 145, 160, 175, 190, 200, 210, 220, 230,
188 240, 260, 270, 280, 290, 300, 310, 320, 330, 340,
189 350, 360, 370, 380, 390, 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 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
199 static const int gf_intra_usage_adjustment[20] =
201 125, 120, 115, 110, 105, 100, 95, 85, 80, 75,
202 70, 65, 60, 55, 50, 50, 50, 50, 50, 50,
205 static const int gf_interval_table[101] =
208 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
209 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
210 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
211 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
212 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
213 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
214 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
215 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
216 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
217 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
220 static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = { 1, 2, 3, 4, 5 };
223 void vp8_save_coding_context(VP8_COMP *cpi)
225 CODING_CONTEXT *const cc = & cpi->coding_context;
227 // Stores a snapshot of key state variables which can subsequently be
228 // restored with a call to vp8_restore_coding_context. These functions are
229 // intended for use in a re-code loop in vp8_compress_frame where the
230 // quantizer value is adjusted between loop iterations.
232 cc->frames_since_key = cpi->frames_since_key;
233 cc->filter_level = cpi->common.filter_level;
234 cc->frames_till_gf_update_due = cpi->frames_till_gf_update_due;
235 cc->frames_since_golden = cpi->common.frames_since_golden;
237 vp8_copy(cc->mvc, cpi->common.fc.mvc);
238 vp8_copy(cc->mvcosts, cpi->mb.mvcosts);
240 vp8_copy(cc->kf_ymode_prob, cpi->common.kf_ymode_prob);
241 vp8_copy(cc->ymode_prob, cpi->common.fc.ymode_prob);
242 vp8_copy(cc->kf_uv_mode_prob, cpi->common.kf_uv_mode_prob);
243 vp8_copy(cc->uv_mode_prob, cpi->common.fc.uv_mode_prob);
245 vp8_copy(cc->ymode_count, cpi->ymode_count);
246 vp8_copy(cc->uv_mode_count, cpi->uv_mode_count);
251 vp8_copy(cc->y_modes, y_modes);
252 vp8_copy(cc->uv_modes, uv_modes);
253 vp8_copy(cc->b_modes, b_modes);
254 vp8_copy(cc->inter_y_modes, inter_y_modes);
255 vp8_copy(cc->inter_uv_modes, inter_uv_modes);
256 vp8_copy(cc->inter_b_modes, inter_b_modes);
259 cc->this_frame_percent_intra = cpi->this_frame_percent_intra;
263 void vp8_restore_coding_context(VP8_COMP *cpi)
265 CODING_CONTEXT *const cc = & cpi->coding_context;
267 // Restore key state variables to the snapshot state stored in the
268 // previous call to vp8_save_coding_context.
270 cpi->frames_since_key = cc->frames_since_key;
271 cpi->common.filter_level = cc->filter_level;
272 cpi->frames_till_gf_update_due = cc->frames_till_gf_update_due;
273 cpi->common.frames_since_golden = cc->frames_since_golden;
275 vp8_copy(cpi->common.fc.mvc, cc->mvc);
277 vp8_copy(cpi->mb.mvcosts, cc->mvcosts);
279 vp8_copy(cpi->common.kf_ymode_prob, cc->kf_ymode_prob);
280 vp8_copy(cpi->common.fc.ymode_prob, cc->ymode_prob);
281 vp8_copy(cpi->common.kf_uv_mode_prob, cc->kf_uv_mode_prob);
282 vp8_copy(cpi->common.fc.uv_mode_prob, cc->uv_mode_prob);
284 vp8_copy(cpi->ymode_count, cc->ymode_count);
285 vp8_copy(cpi->uv_mode_count, cc->uv_mode_count);
289 vp8_copy(y_modes, cc->y_modes);
290 vp8_copy(uv_modes, cc->uv_modes);
291 vp8_copy(b_modes, cc->b_modes);
292 vp8_copy(inter_y_modes, cc->inter_y_modes);
293 vp8_copy(inter_uv_modes, cc->inter_uv_modes);
294 vp8_copy(inter_b_modes, cc->inter_b_modes);
298 cpi->this_frame_percent_intra = cc->this_frame_percent_intra;
302 void vp8_setup_key_frame(VP8_COMP *cpi)
304 // Setup for Key frame:
306 vp8_default_coef_probs(& cpi->common);
309 vp8_kf_default_bmode_probs(cpi->common.kf_bmode_prob);
311 vpx_memcpy(cpi->common.fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));
313 int flag[2] = {1, 1};
314 vp8_build_component_cost_table(cpi->mb.mvcost, (const MV_CONTEXT *) cpi->common.fc.mvc, flag);
317 vpx_memset(cpi->common.fc.pre_mvc, 0, sizeof(cpi->common.fc.pre_mvc)); //initialize pre_mvc to all zero.
319 // Make sure we initialize separate contexts for altref,gold, and normal.
320 // TODO shouldn't need 3 different copies of structure to do this!
321 vpx_memcpy(&cpi->lfc_a, &cpi->common.fc, sizeof(cpi->common.fc));
322 vpx_memcpy(&cpi->lfc_g, &cpi->common.fc, sizeof(cpi->common.fc));
323 vpx_memcpy(&cpi->lfc_n, &cpi->common.fc, sizeof(cpi->common.fc));
325 //cpi->common.filter_level = 0; // Reset every key frame.
326 cpi->common.filter_level = cpi->common.base_qindex * 3 / 8 ;
328 // Provisional interval before next GF
330 //cpi->frames_till_gf_update_due = DEFAULT_GF_INTERVAL;
331 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
333 cpi->frames_till_gf_update_due = cpi->goldfreq;
335 cpi->common.refresh_golden_frame = 1;
336 cpi->common.refresh_alt_ref_frame = 1;
340 static int estimate_bits_at_q(int frame_kind, int Q, int MBs,
341 double correction_factor)
343 int Bpm = (int)(.5 + correction_factor * vp8_bits_per_mb[frame_kind][Q]);
345 /* Attempt to retain reasonable accuracy without overflow. The cutoff is
346 * chosen such that the maximum product of Bpm and MBs fits 31 bits. The
347 * largest Bpm takes 20 bits.
350 return (Bpm >> BPER_MB_NORMBITS) * MBs;
352 return (Bpm * MBs) >> BPER_MB_NORMBITS;
356 static void calc_iframe_target_size(VP8_COMP *cpi)
358 // boost defaults to half second
362 // Clear down mmx registers to allow floating point in what follows
363 vp8_clear_system_state(); //__asm emms;
365 if (cpi->oxcf.fixed_q >= 0)
367 int Q = cpi->oxcf.key_q;
369 target = estimate_bits_at_q(INTRA_FRAME, Q, cpi->common.MBs,
370 cpi->key_frame_rate_correction_factor);
372 else if (cpi->pass == 2)
375 target = cpi->per_frame_bandwidth;
377 // First Frame is a special case
378 else if (cpi->common.current_video_frame == 0)
380 /* 1 Pass there is no information on which to base size so use
381 * bandwidth per second * fraction of the initial buffer
384 target = cpi->oxcf.starting_buffer_level / 2;
386 if(target > cpi->oxcf.target_bandwidth * 3 / 2)
387 target = cpi->oxcf.target_bandwidth * 3 / 2;
391 // if this keyframe was forced, use a more recent Q estimate
392 int Q = (cpi->common.frame_flags & FRAMEFLAGS_KEY)
393 ? cpi->avg_frame_qindex : cpi->ni_av_qi;
395 int initial_boost = 24; // Corresponds to: |2.5 * per_frame_bandwidth|
396 // Boost depends somewhat on frame rate: only used for 1 layer case.
397 if (cpi->oxcf.number_of_layers == 1) {
398 kf_boost = MAX(initial_boost, (int)(2 * cpi->output_frame_rate - 16));
401 // Initial factor: set target size to: |2.5 * per_frame_bandwidth|.
402 kf_boost = initial_boost;
405 // adjustment up based on q: this factor ranges from ~1.2 to 2.2.
406 kf_boost = kf_boost * kf_boost_qadjustment[Q] / 100;
408 // frame separation adjustment ( down)
409 if (cpi->frames_since_key < cpi->output_frame_rate / 2)
410 kf_boost = (int)(kf_boost
411 * cpi->frames_since_key / (cpi->output_frame_rate / 2));
413 // Minimal target size is |2* per_frame_bandwidth|.
417 target = ((16 + kf_boost) * cpi->per_frame_bandwidth) >> 4;
421 if (cpi->oxcf.rc_max_intra_bitrate_pct)
423 unsigned int max_rate = cpi->per_frame_bandwidth
424 * cpi->oxcf.rc_max_intra_bitrate_pct / 100;
426 if (target > max_rate)
430 cpi->this_frame_target = target;
432 // TODO: if we separate rate targeting from Q targetting, move this.
433 // Reset the active worst quality to the baseline value for key frames.
435 cpi->active_worst_quality = cpi->worst_quality;
441 f = fopen("kf_boost.stt", "a");
442 //fprintf(f, " %8d %10d %10d %10d %10d %10d %10d\n",
443 // 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 );
445 fprintf(f, " %8u %10d %10d %10d\n",
446 cpi->common.current_video_frame, cpi->gfu_boost, cpi->baseline_gf_interval, cpi->source_alt_ref_pending);
454 // Do the best we can to define the parameters for the next GF based on what
455 // information we have available.
456 static void calc_gf_params(VP8_COMP *cpi)
458 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
461 int gf_frame_useage = 0; // Golden frame useage since last GF
462 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
463 cpi->recent_ref_frame_usage[LAST_FRAME] +
464 cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
465 cpi->recent_ref_frame_usage[ALTREF_FRAME];
467 int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols);
469 // Reset the last boost indicator
470 //cpi->last_boost = 100;
473 gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs;
475 if (pct_gf_active > gf_frame_useage)
476 gf_frame_useage = pct_gf_active;
481 // Single Pass lagged mode: TBD
486 // Single Pass compression: Has to use current and historical data
491 int index = cpi->one_pass_frame_index;
492 int frames_to_scan = (cpi->max_gf_interval <= MAX_LAG_BUFFERS) ? cpi->max_gf_interval : MAX_LAG_BUFFERS;
495 // *************** Experimental code - incomplete
496 double decay_val = 1.0;
497 double IIAccumulator = 0.0;
498 double last_iiaccumulator = 0.0;
501 cpi->one_pass_frame_index = cpi->common.current_video_frame%MAX_LAG_BUFFERS;
503 for ( i = 0; i < (frames_to_scan - 1); i++ )
506 index = MAX_LAG_BUFFERS;
509 if ( cpi->one_pass_frame_stats[index].frame_coded_error > 0.0 )
511 IIRatio = cpi->one_pass_frame_stats[index].frame_intra_error / cpi->one_pass_frame_stats[index].frame_coded_error;
513 if ( IIRatio > 30.0 )
519 IIAccumulator += IIRatio * decay_val;
521 decay_val = decay_val * cpi->one_pass_frame_stats[index].frame_pcnt_inter;
523 if ( (i > MIN_GF_INTERVAL) &&
524 ((IIAccumulator - last_iiaccumulator) < 2.0) )
528 last_iiaccumulator = IIAccumulator;
531 Boost = IIAccumulator*100.0/16.0;
532 cpi->baseline_gf_interval = i;
537 /*************************************************************/
540 // Adjust boost based upon ambient Q
541 Boost = GFQ_ADJUSTMENT;
543 // Adjust based upon most recently measure intra useage
544 Boost = Boost * gf_intra_usage_adjustment[(cpi->this_frame_percent_intra < 15) ? cpi->this_frame_percent_intra : 14] / 100;
546 // Adjust gf boost based upon GF usage since last GF
547 Boost = Boost * gf_adjust_table[gf_frame_useage] / 100;
551 // golden frame boost without recode loop often goes awry. be safe by keeping numbers down.
552 if (!cpi->sf.recode_loop)
554 if (cpi->compressor_speed == 2)
558 // Apply an upper limit based on Q for 1 pass encodes
559 if (Boost > kf_gf_boost_qlimits[Q] && (cpi->pass == 0))
560 Boost = kf_gf_boost_qlimits[Q];
562 // Apply lower limits to boost.
563 else if (Boost < 110)
566 // Note the boost used
567 cpi->last_boost = Boost;
571 // Estimate next interval
572 // This is updated once the real frame size/boost is known.
573 if (cpi->oxcf.fixed_q == -1)
575 if (cpi->pass == 2) // 2 Pass
577 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
581 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
583 if (cpi->last_boost > 750)
584 cpi->frames_till_gf_update_due++;
586 if (cpi->last_boost > 1000)
587 cpi->frames_till_gf_update_due++;
589 if (cpi->last_boost > 1250)
590 cpi->frames_till_gf_update_due++;
592 if (cpi->last_boost >= 1500)
593 cpi->frames_till_gf_update_due ++;
595 if (gf_interval_table[gf_frame_useage] > cpi->frames_till_gf_update_due)
596 cpi->frames_till_gf_update_due = gf_interval_table[gf_frame_useage];
598 if (cpi->frames_till_gf_update_due > cpi->max_gf_interval)
599 cpi->frames_till_gf_update_due = cpi->max_gf_interval;
603 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
608 // For now Alt ref is not allowed except in 2 pass modes.
609 cpi->source_alt_ref_pending = 0;
611 /*if ( cpi->oxcf.fixed_q == -1)
613 if ( cpi->oxcf.play_alternate && (cpi->last_boost > (100 + (AF_THRESH*cpi->frames_till_gf_update_due)) ) )
614 cpi->source_alt_ref_pending = 1;
616 cpi->source_alt_ref_pending = 0;
622 static void calc_pframe_target_size(VP8_COMP *cpi)
624 int min_frame_target;
626 int old_per_frame_bandwidth = cpi->per_frame_bandwidth;
628 if ( cpi->current_layer > 0)
629 cpi->per_frame_bandwidth =
630 cpi->layer_context[cpi->current_layer].avg_frame_size_for_layer;
632 min_frame_target = 0;
636 min_frame_target = cpi->min_frame_bandwidth;
638 if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5))
639 min_frame_target = cpi->av_per_frame_bandwidth >> 5;
641 else if (min_frame_target < cpi->per_frame_bandwidth / 4)
642 min_frame_target = cpi->per_frame_bandwidth / 4;
645 // Special alt reference frame case
646 if((cpi->common.refresh_alt_ref_frame) && (cpi->oxcf.number_of_layers == 1))
650 cpi->per_frame_bandwidth = cpi->twopass.gf_bits; // Per frame bit target for the alt ref frame
651 cpi->this_frame_target = cpi->per_frame_bandwidth;
654 /* One Pass ??? TBD */
657 int frames_in_section;
658 int allocation_chunks;
659 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
663 alt_boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100);
664 alt_boost += (cpi->frames_till_gf_update_due * 50);
666 // If alt ref is not currently active then we have a pottential double hit with GF and ARF so reduce the boost a bit.
667 // A similar thing is done on GFs that preceed a arf update.
668 if ( !cpi->source_alt_ref_active )
669 alt_boost = alt_boost * 3 / 4;
671 frames_in_section = cpi->frames_till_gf_update_due+1; // Standard frames + GF
672 allocation_chunks = (frames_in_section * 100) + alt_boost;
674 // Normalize Altboost and allocations chunck down to prevent overflow
675 while ( alt_boost > 1000 )
678 allocation_chunks /= 2;
685 if ( cpi->kf_overspend_bits > 0 )
687 Adjustment = (cpi->kf_bitrate_adjustment <= cpi->kf_overspend_bits) ? cpi->kf_bitrate_adjustment : cpi->kf_overspend_bits;
689 if ( Adjustment > (cpi->per_frame_bandwidth - min_frame_target) )
690 Adjustment = (cpi->per_frame_bandwidth - min_frame_target);
692 cpi->kf_overspend_bits -= Adjustment;
694 // Calculate an inter frame bandwidth target for the next few frames designed to recover
695 // any extra bits spent on the key frame.
696 cpi->inter_frame_target = cpi->per_frame_bandwidth - Adjustment;
697 if ( cpi->inter_frame_target < min_frame_target )
698 cpi->inter_frame_target = min_frame_target;
701 cpi->inter_frame_target = cpi->per_frame_bandwidth;
703 bits_in_section = cpi->inter_frame_target * frames_in_section;
705 // Avoid loss of precision but avoid overflow
706 if ( (bits_in_section>>7) > allocation_chunks )
707 cpi->this_frame_target = alt_boost * (bits_in_section / allocation_chunks);
709 cpi->this_frame_target = (alt_boost * bits_in_section) / allocation_chunks;
715 // Normal frames (gf,and inter)
721 cpi->this_frame_target = cpi->per_frame_bandwidth;
726 // Make rate adjustment to recover bits spent in key frame
727 // Test to see if the key frame inter data rate correction should still be in force
728 if (cpi->kf_overspend_bits > 0)
730 Adjustment = (cpi->kf_bitrate_adjustment <= cpi->kf_overspend_bits) ? cpi->kf_bitrate_adjustment : cpi->kf_overspend_bits;
732 if (Adjustment > (cpi->per_frame_bandwidth - min_frame_target))
733 Adjustment = (cpi->per_frame_bandwidth - min_frame_target);
735 cpi->kf_overspend_bits -= Adjustment;
737 // Calculate an inter frame bandwidth target for the next few frames designed to recover
738 // any extra bits spent on the key frame.
739 cpi->this_frame_target = cpi->per_frame_bandwidth - Adjustment;
741 if (cpi->this_frame_target < min_frame_target)
742 cpi->this_frame_target = min_frame_target;
745 cpi->this_frame_target = cpi->per_frame_bandwidth;
747 // If appropriate make an adjustment to recover bits spent on a recent GF
748 if ((cpi->gf_overspend_bits > 0) && (cpi->this_frame_target > min_frame_target))
750 int Adjustment = (cpi->non_gf_bitrate_adjustment <= cpi->gf_overspend_bits) ? cpi->non_gf_bitrate_adjustment : cpi->gf_overspend_bits;
752 if (Adjustment > (cpi->this_frame_target - min_frame_target))
753 Adjustment = (cpi->this_frame_target - min_frame_target);
755 cpi->gf_overspend_bits -= Adjustment;
756 cpi->this_frame_target -= Adjustment;
759 // Apply small + and - boosts for non gf frames
760 if ((cpi->last_boost > 150) && (cpi->frames_till_gf_update_due > 0) &&
761 (cpi->current_gf_interval >= (MIN_GF_INTERVAL << 1)))
763 // % Adjustment limited to the range 1% to 10%
764 Adjustment = (cpi->last_boost - 100) >> 5;
768 else if (Adjustment > 10)
772 Adjustment = (cpi->this_frame_target * Adjustment) / 100;
774 if (Adjustment > (cpi->this_frame_target - min_frame_target))
775 Adjustment = (cpi->this_frame_target - min_frame_target);
777 if (cpi->common.frames_since_golden == (cpi->current_gf_interval >> 1))
778 cpi->this_frame_target += ((cpi->current_gf_interval - 1) * Adjustment);
780 cpi->this_frame_target -= Adjustment;
785 // Sanity check that the total sum of adjustments is not above the maximum allowed
786 // That is that having allowed for KF and GF penalties we have not pushed the
787 // current interframe target to low. If the adjustment we apply here is not capable of recovering
788 // all the extra bits we have spent in the KF or GF then the remainder will have to be recovered over
789 // a longer time span via other buffer / rate control mechanisms.
790 if (cpi->this_frame_target < min_frame_target)
791 cpi->this_frame_target = min_frame_target;
793 if (!cpi->common.refresh_alt_ref_frame)
794 // Note the baseline target data rate for this inter frame.
795 cpi->inter_frame_target = cpi->this_frame_target;
797 // One Pass specific code
800 // Adapt target frame size with respect to any buffering constraints:
801 if (cpi->buffered_mode)
803 int one_percent_bits = 1 + cpi->oxcf.optimal_buffer_level / 100;
805 if ((cpi->buffer_level < cpi->oxcf.optimal_buffer_level) ||
806 (cpi->bits_off_target < cpi->oxcf.optimal_buffer_level))
810 // Decide whether or not we need to adjust the frame data rate target.
812 // If we are are below the optimal buffer fullness level and adherence
813 // to buffering constraints is important to the end usage then adjust
814 // the per frame target.
815 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
816 (cpi->buffer_level < cpi->oxcf.optimal_buffer_level))
819 (cpi->oxcf.optimal_buffer_level - cpi->buffer_level) /
822 // Are we overshooting the long term clip data rate...
823 else if (cpi->bits_off_target < 0)
825 // Adjust per frame data target downwards to compensate.
826 percent_low = (int)(100 * -cpi->bits_off_target /
827 (cpi->total_byte_count * 8));
830 if (percent_low > cpi->oxcf.under_shoot_pct)
831 percent_low = cpi->oxcf.under_shoot_pct;
832 else if (percent_low < 0)
835 // lower the target bandwidth for this frame.
836 cpi->this_frame_target -=
837 (cpi->this_frame_target * percent_low) / 200;
839 // Are we using allowing control of active_worst_allowed_q
840 // according to buffer level.
841 if (cpi->auto_worst_q && cpi->ni_frames > 150)
843 int critical_buffer_level;
845 // For streaming applications the most important factor is
846 // cpi->buffer_level as this takes into account the
847 // specified short term buffering constraints. However,
848 // hitting the long term clip data rate target is also
850 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
852 // Take the smaller of cpi->buffer_level and
853 // cpi->bits_off_target
854 critical_buffer_level =
855 (cpi->buffer_level < cpi->bits_off_target)
856 ? cpi->buffer_level : cpi->bits_off_target;
858 // For local file playback short term buffering constraints
859 // are less of an issue
862 // Consider only how we are doing for the clip as a
864 critical_buffer_level = cpi->bits_off_target;
867 // Set the active worst quality based upon the selected
868 // buffer fullness number.
869 if (critical_buffer_level < cpi->oxcf.optimal_buffer_level)
871 if ( critical_buffer_level >
872 (cpi->oxcf.optimal_buffer_level >> 2) )
874 int64_t qadjustment_range =
875 cpi->worst_quality - cpi->ni_av_qi;
877 (critical_buffer_level -
878 (cpi->oxcf.optimal_buffer_level >> 2));
880 // Step active worst quality down from
881 // cpi->ni_av_qi when (critical_buffer_level ==
882 // cpi->optimal_buffer_level) to
883 // cpi->worst_quality when
884 // (critical_buffer_level ==
885 // cpi->optimal_buffer_level >> 2)
886 cpi->active_worst_quality =
888 ((qadjustment_range * above_base) /
889 (cpi->oxcf.optimal_buffer_level*3>>2));
893 cpi->active_worst_quality = cpi->worst_quality;
898 cpi->active_worst_quality = cpi->ni_av_qi;
903 cpi->active_worst_quality = cpi->worst_quality;
908 int percent_high = 0;
910 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
911 && (cpi->buffer_level > cpi->oxcf.optimal_buffer_level))
913 percent_high = (cpi->buffer_level
914 - cpi->oxcf.optimal_buffer_level)
917 else if (cpi->bits_off_target > cpi->oxcf.optimal_buffer_level)
919 percent_high = (int)((100 * cpi->bits_off_target)
920 / (cpi->total_byte_count * 8));
923 if (percent_high > cpi->oxcf.over_shoot_pct)
924 percent_high = cpi->oxcf.over_shoot_pct;
925 else if (percent_high < 0)
928 cpi->this_frame_target += (cpi->this_frame_target *
931 // Are we allowing control of active_worst_allowed_q according
933 if (cpi->auto_worst_q && cpi->ni_frames > 150)
935 // When using the relaxed buffer model stick to the user specified value
936 cpi->active_worst_quality = cpi->ni_av_qi;
940 cpi->active_worst_quality = cpi->worst_quality;
944 // Set active_best_quality to prevent quality rising too high
945 cpi->active_best_quality = cpi->best_quality;
947 // Worst quality obviously must not be better than best quality
948 if (cpi->active_worst_quality <= cpi->active_best_quality)
949 cpi->active_worst_quality = cpi->active_best_quality + 1;
951 if(cpi->active_worst_quality > 127)
952 cpi->active_worst_quality = 127;
954 // Unbuffered mode (eg. video conferencing)
957 // Set the active worst quality
958 cpi->active_worst_quality = cpi->worst_quality;
961 // Special trap for constrained quality mode
962 // "active_worst_quality" may never drop below cq level
963 // for any frame type.
964 if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY &&
965 cpi->active_worst_quality < cpi->cq_target_quality)
967 cpi->active_worst_quality = cpi->cq_target_quality;
971 // Test to see if we have to drop a frame
972 // The auto-drop frame code is only used in buffered mode.
973 // In unbufferd mode (eg vide conferencing) the descision to
974 // code or drop a frame is made outside the codec in response to real
975 // world comms or buffer considerations.
976 if (cpi->drop_frames_allowed && cpi->buffered_mode &&
977 (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
978 ((cpi->common.frame_type != KEY_FRAME))) //|| !cpi->oxcf.allow_spatial_resampling) )
980 // Check for a buffer underun-crisis in which case we have to drop a frame
981 if ((cpi->buffer_level < 0))
984 FILE *f = fopen("dec.stt", "a");
985 fprintf(f, "%10d %10d %10d %10d ***** BUFFER EMPTY\n",
986 (int) cpi->common.current_video_frame,
987 cpi->decimation_factor, cpi->common.horiz_scale,
988 (cpi->buffer_level * 100) / cpi->oxcf.optimal_buffer_level);
991 //vpx_log("Decoder: Drop frame due to bandwidth: %d \n",cpi->buffer_level, cpi->av_per_frame_bandwidth);
997 // Check for other drop frame crtieria (Note 2 pass cbr uses decimation on whole KF sections)
998 else if ((cpi->buffer_level < cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100) &&
999 (cpi->drop_count < cpi->max_drop_count) && (cpi->pass == 0))
1001 cpi->drop_frame = 1;
1006 if (cpi->drop_frame)
1008 // Update the buffer level variable.
1009 cpi->bits_off_target += cpi->av_per_frame_bandwidth;
1010 if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
1011 cpi->bits_off_target = cpi->oxcf.maximum_buffer_size;
1012 cpi->buffer_level = cpi->bits_off_target;
1015 cpi->drop_count = 0;
1018 // Adjust target frame size for Golden Frames:
1019 if (cpi->oxcf.error_resilient_mode == 0 &&
1020 (cpi->frames_till_gf_update_due == 0) && !cpi->drop_frame)
1023 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
1025 int gf_frame_useage = 0; // Golden frame useage since last GF
1026 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
1027 cpi->recent_ref_frame_usage[LAST_FRAME] +
1028 cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
1029 cpi->recent_ref_frame_usage[ALTREF_FRAME];
1031 int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols);
1033 // Reset the last boost indicator
1034 //cpi->last_boost = 100;
1037 gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs;
1039 if (pct_gf_active > gf_frame_useage)
1040 gf_frame_useage = pct_gf_active;
1042 // Is a fixed manual GF frequency being used
1045 // For one pass throw a GF if recent frame intra useage is low or the GF useage is high
1046 if ((cpi->pass == 0) && (cpi->this_frame_percent_intra < 15 || gf_frame_useage >= 5))
1047 cpi->common.refresh_golden_frame = 1;
1049 // Two pass GF descision
1050 else if (cpi->pass == 2)
1051 cpi->common.refresh_golden_frame = 1;
1061 f = fopen("gf_useaget.stt", "a");
1062 fprintf(f, " %8ld %10ld %10ld %10ld %10ld\n",
1063 cpi->common.current_video_frame, cpi->gfu_boost, GFQ_ADJUSTMENT, cpi->gfu_boost, gf_frame_useage);
1069 if (cpi->common.refresh_golden_frame == 1)
1077 f = fopen("GFexit.stt", "a");
1078 fprintf(f, "%8ld GF coded\n", cpi->common.current_video_frame);
1084 if (cpi->auto_adjust_gold_quantizer)
1086 calc_gf_params(cpi);
1089 // If we are using alternate ref instead of gf then do not apply the boost
1090 // It will instead be applied to the altref update
1091 // Jims modified boost
1092 if (!cpi->source_alt_ref_active)
1094 if (cpi->oxcf.fixed_q < 0)
1098 cpi->this_frame_target = cpi->per_frame_bandwidth; // The spend on the GF is defined in the two pass code for two pass encodes
1102 int Boost = cpi->last_boost;
1103 int frames_in_section = cpi->frames_till_gf_update_due + 1;
1104 int allocation_chunks = (frames_in_section * 100) + (Boost - 100);
1105 int bits_in_section = cpi->inter_frame_target * frames_in_section;
1107 // Normalize Altboost and allocations chunck down to prevent overflow
1108 while (Boost > 1000)
1111 allocation_chunks /= 2;
1114 // Avoid loss of precision but avoid overflow
1115 if ((bits_in_section >> 7) > allocation_chunks)
1116 cpi->this_frame_target = Boost * (bits_in_section / allocation_chunks);
1118 cpi->this_frame_target = (Boost * bits_in_section) / allocation_chunks;
1122 cpi->this_frame_target =
1123 (estimate_bits_at_q(1, Q, cpi->common.MBs, 1.0)
1124 * cpi->last_boost) / 100;
1127 // If there is an active ARF at this location use the minimum
1128 // bits on this frame even if it is a contructed arf.
1129 // The active maximum quantizer insures that an appropriate
1130 // number of bits will be spent if needed for contstructed ARFs.
1133 cpi->this_frame_target = 0;
1136 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
1141 cpi->per_frame_bandwidth = old_per_frame_bandwidth;
1145 void vp8_update_rate_correction_factors(VP8_COMP *cpi, int damp_var)
1147 int Q = cpi->common.base_qindex;
1148 int correction_factor = 100;
1149 double rate_correction_factor;
1150 double adjustment_limit;
1152 int projected_size_based_on_q = 0;
1154 // Clear down mmx registers to allow floating point in what follows
1155 vp8_clear_system_state(); //__asm emms;
1157 if (cpi->common.frame_type == KEY_FRAME)
1159 rate_correction_factor = cpi->key_frame_rate_correction_factor;
1163 if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1164 rate_correction_factor = cpi->gf_rate_correction_factor;
1166 rate_correction_factor = cpi->rate_correction_factor;
1169 // Work out how big we would have expected the frame to be at this Q given the current correction factor.
1170 // Stay in double to avoid int overflow when values are large
1171 //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;
1172 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));
1174 // Make some allowance for cpi->zbin_over_quant
1175 if (cpi->zbin_over_quant > 0)
1177 int Z = cpi->zbin_over_quant;
1178 double Factor = 0.99;
1179 double factor_adjustment = 0.01 / 256.0; //(double)ZBIN_OQ_MAX;
1184 projected_size_based_on_q =
1185 (int)(Factor * projected_size_based_on_q);
1186 Factor += factor_adjustment;
1188 if (Factor >= 0.999)
1193 // Work out a size correction factor.
1194 //if ( cpi->this_frame_target > 0 )
1195 // correction_factor = (100 * cpi->projected_frame_size) / cpi->this_frame_target;
1196 if (projected_size_based_on_q > 0)
1197 correction_factor = (100 * cpi->projected_frame_size) / projected_size_based_on_q;
1199 // More heavily damped adjustment used if we have been oscillating either side of target
1203 adjustment_limit = 0.75;
1206 adjustment_limit = 0.375;
1210 adjustment_limit = 0.25;
1214 //if ( (correction_factor > 102) && (Q < cpi->active_worst_quality) )
1215 if (correction_factor > 102)
1217 // We are not already at the worst allowable quality
1218 correction_factor = (int)(100.5 + ((correction_factor - 100) * adjustment_limit));
1219 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1221 // Keep rate_correction_factor within limits
1222 if (rate_correction_factor > MAX_BPB_FACTOR)
1223 rate_correction_factor = MAX_BPB_FACTOR;
1225 //else if ( (correction_factor < 99) && (Q > cpi->active_best_quality) )
1226 else if (correction_factor < 99)
1228 // We are not already at the best allowable quality
1229 correction_factor = (int)(100.5 - ((100 - correction_factor) * adjustment_limit));
1230 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1232 // Keep rate_correction_factor within limits
1233 if (rate_correction_factor < MIN_BPB_FACTOR)
1234 rate_correction_factor = MIN_BPB_FACTOR;
1237 if (cpi->common.frame_type == KEY_FRAME)
1238 cpi->key_frame_rate_correction_factor = rate_correction_factor;
1241 if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1242 cpi->gf_rate_correction_factor = rate_correction_factor;
1244 cpi->rate_correction_factor = rate_correction_factor;
1249 int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame)
1251 int Q = cpi->active_worst_quality;
1253 // Reset Zbin OQ value
1254 cpi->zbin_over_quant = 0;
1256 if (cpi->oxcf.fixed_q >= 0)
1258 Q = cpi->oxcf.fixed_q;
1260 if (cpi->common.frame_type == KEY_FRAME)
1262 Q = cpi->oxcf.key_q;
1264 else if (cpi->common.refresh_alt_ref_frame)
1266 Q = cpi->oxcf.alt_q;
1268 else if (cpi->common.refresh_golden_frame)
1270 Q = cpi->oxcf.gold_q;
1277 int last_error = INT_MAX;
1278 int target_bits_per_mb;
1279 int bits_per_mb_at_this_q;
1280 double correction_factor;
1282 // Select the appropriate correction factor based upon type of frame.
1283 if (cpi->common.frame_type == KEY_FRAME)
1284 correction_factor = cpi->key_frame_rate_correction_factor;
1287 if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1288 correction_factor = cpi->gf_rate_correction_factor;
1290 correction_factor = cpi->rate_correction_factor;
1293 // Calculate required scaling factor based on target frame size and size of frame produced using previous Q
1294 if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
1295 target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs) << BPER_MB_NORMBITS; // Case where we would overflow int
1297 target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
1299 i = cpi->active_best_quality;
1303 bits_per_mb_at_this_q = (int)(.5 + correction_factor * vp8_bits_per_mb[cpi->common.frame_type][i]);
1305 if (bits_per_mb_at_this_q <= target_bits_per_mb)
1307 if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
1315 last_error = bits_per_mb_at_this_q - target_bits_per_mb;
1317 while (++i <= cpi->active_worst_quality);
1320 // If we are at MAXQ then enable Q over-run which seeks to claw back additional bits through things like
1321 // the RD multiplier and zero bin size.
1326 double Factor = 0.99;
1327 double factor_adjustment = 0.01 / 256.0; //(double)ZBIN_OQ_MAX;
1329 if (cpi->common.frame_type == KEY_FRAME)
1330 zbin_oqmax = 0; //ZBIN_OQ_MAX/16
1331 else if (cpi->common.refresh_alt_ref_frame || (cpi->common.refresh_golden_frame && !cpi->source_alt_ref_active))
1334 zbin_oqmax = ZBIN_OQ_MAX;
1337 double Factor = (double)target_bits_per_mb/(double)bits_per_mb_at_this_q;
1340 Factor = Factor/1.2683;
1342 Oq = pow( Factor, (1.0/-0.165) );
1344 if ( Oq > zbin_oqmax )
1347 cpi->zbin_over_quant = (int)Oq;
1350 // Each incrment in the zbin is assumed to have a fixed effect on bitrate. This is not of course true.
1351 // The effect will be highly clip dependent and may well have sudden steps.
1352 // The idea here is to acheive higher effective quantizers than the normal maximum by expanding the zero
1353 // bin and hence decreasing the number of low magnitude non zero coefficients.
1354 while (cpi->zbin_over_quant < zbin_oqmax)
1356 cpi->zbin_over_quant ++;
1358 if (cpi->zbin_over_quant > zbin_oqmax)
1359 cpi->zbin_over_quant = zbin_oqmax;
1361 // Adjust bits_per_mb_at_this_q estimate
1362 bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q);
1363 Factor += factor_adjustment;
1365 if (Factor >= 0.999)
1368 if (bits_per_mb_at_this_q <= target_bits_per_mb) // Break out if we get down to the target rate
1379 static int estimate_keyframe_frequency(VP8_COMP *cpi)
1383 // Average key frame frequency
1384 int av_key_frame_frequency = 0;
1386 /* First key frame at start of sequence is a special case. We have no
1389 if (cpi->key_frame_count == 1)
1391 /* Assume a default of 1 kf every 2 seconds, or the max kf interval,
1392 * whichever is smaller.
1394 int key_freq = cpi->oxcf.key_freq>0 ? cpi->oxcf.key_freq : 1;
1395 av_key_frame_frequency = (int)cpi->output_frame_rate * 2;
1397 if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq)
1398 av_key_frame_frequency = cpi->oxcf.key_freq;
1400 cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1]
1401 = av_key_frame_frequency;
1405 unsigned int total_weight = 0;
1406 int last_kf_interval =
1407 (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;
1409 /* reset keyframe context and calculate weighted average of last
1410 * KEY_FRAME_CONTEXT keyframes
1412 for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1414 if (i < KEY_FRAME_CONTEXT - 1)
1415 cpi->prior_key_frame_distance[i]
1416 = cpi->prior_key_frame_distance[i+1];
1418 cpi->prior_key_frame_distance[i] = last_kf_interval;
1420 av_key_frame_frequency += prior_key_frame_weight[i]
1421 * cpi->prior_key_frame_distance[i];
1422 total_weight += prior_key_frame_weight[i];
1425 av_key_frame_frequency /= total_weight;
1428 return av_key_frame_frequency;
1432 void vp8_adjust_key_frame_context(VP8_COMP *cpi)
1434 // Clear down mmx registers to allow floating point in what follows
1435 vp8_clear_system_state();
1437 // Do we have any key frame overspend to recover?
1438 // Two-pass overspend handled elsewhere.
1439 if ((cpi->pass != 2)
1440 && (cpi->projected_frame_size > cpi->per_frame_bandwidth))
1444 /* Update the count of key frame overspend to be recovered in
1445 * subsequent frames. A portion of the KF overspend is treated as gf
1446 * overspend (and hence recovered more quickly) as the kf is also a
1447 * gf. Otherwise the few frames following each kf tend to get more
1448 * bits allocated than those following other gfs.
1450 overspend = (cpi->projected_frame_size - cpi->per_frame_bandwidth);
1452 if (cpi->oxcf.number_of_layers > 1)
1453 cpi->kf_overspend_bits += overspend;
1456 cpi->kf_overspend_bits += overspend * 7 / 8;
1457 cpi->gf_overspend_bits += overspend * 1 / 8;
1460 /* Work out how much to try and recover per frame. */
1461 cpi->kf_bitrate_adjustment = cpi->kf_overspend_bits
1462 / estimate_keyframe_frequency(cpi);
1465 cpi->frames_since_key = 0;
1466 cpi->key_frame_count++;
1470 void vp8_compute_frame_size_bounds(VP8_COMP *cpi, int *frame_under_shoot_limit, int *frame_over_shoot_limit)
1472 // Set-up bounds on acceptable frame size:
1473 if (cpi->oxcf.fixed_q >= 0)
1475 // Fixed Q scenario: frame size never outranges target (there is no target!)
1476 *frame_under_shoot_limit = 0;
1477 *frame_over_shoot_limit = INT_MAX;
1481 if (cpi->common.frame_type == KEY_FRAME)
1483 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
1484 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1488 if (cpi->oxcf.number_of_layers > 1 ||
1489 cpi->common.refresh_alt_ref_frame ||
1490 cpi->common.refresh_golden_frame)
1492 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
1493 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1497 // For CBR take buffer fullness into account
1498 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
1500 if (cpi->buffer_level >= ((cpi->oxcf.optimal_buffer_level + cpi->oxcf.maximum_buffer_size) >> 1))
1502 // Buffer is too full so relax overshoot and tighten undershoot
1503 *frame_over_shoot_limit = cpi->this_frame_target * 12 / 8;
1504 *frame_under_shoot_limit = cpi->this_frame_target * 6 / 8;
1506 else if (cpi->buffer_level <= (cpi->oxcf.optimal_buffer_level >> 1))
1508 // Buffer is too low so relax undershoot and tighten overshoot
1509 *frame_over_shoot_limit = cpi->this_frame_target * 10 / 8;
1510 *frame_under_shoot_limit = cpi->this_frame_target * 4 / 8;
1514 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1515 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1519 // Note that tighter restrictions here can help quality but hurt encode speed
1522 // Stron overshoot limit for constrained quality
1523 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
1525 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1526 *frame_under_shoot_limit = cpi->this_frame_target * 2 / 8;
1530 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1531 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1537 // For very small rate targets where the fractional adjustment
1538 // (eg * 7/8) may be tiny make sure there is at least a minimum
1540 *frame_over_shoot_limit += 200;
1541 *frame_under_shoot_limit -= 200;
1542 if ( *frame_under_shoot_limit < 0 )
1543 *frame_under_shoot_limit = 0;
1549 // return of 0 means drop frame
1550 int vp8_pick_frame_size(VP8_COMP *cpi)
1552 VP8_COMMON *cm = &cpi->common;
1554 if (cm->frame_type == KEY_FRAME)
1555 calc_iframe_target_size(cpi);
1558 calc_pframe_target_size(cpi);
1560 // Check if we're dropping the frame:
1561 if (cpi->drop_frame)
1563 cpi->drop_frame = 0;