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