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 = (uint64_t)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 =
331 VPXMAX(initial_boost, (int)round(2 * cpi->output_framerate - 16));
332 // cpi->output_framerate may be as large as 10M. Keep kf_boost small
333 // enough to allow for integer math when multiplying by values in
334 // kf_boost_qadjustment[].
335 const int kMaxKfBoost = 2000;
336 if (kf_boost > kMaxKfBoost) kf_boost = kMaxKfBoost;
337 } else {
338 /* Initial factor: set target size to: |3.0 * per_frame_bandwidth|. */
339 kf_boost = initial_boost;
340 }
341
342 /* adjustment up based on q: this factor ranges from ~1.2 to 2.2. */
343 kf_boost = kf_boost * kf_boost_qadjustment[Q] / 100;
344
345 /* frame separation adjustment ( down) */
346 if (cpi->frames_since_key < cpi->output_framerate / 2) {
347 kf_boost =
348 (int)(kf_boost * cpi->frames_since_key / (cpi->output_framerate / 2));
349 }
350
351 /* Minimal target size is |2* per_frame_bandwidth|. */
352 if (kf_boost < 16) kf_boost = 16;
353
354 target = ((uint64_t)(16 + kf_boost) * cpi->per_frame_bandwidth) >> 4;
355 target = VPXMIN(INT_MAX, target);
356 }
357
358 if (cpi->oxcf.rc_max_intra_bitrate_pct) {
359 unsigned int max_rate;
360 // This product may overflow unsigned int
361 uint64_t product = cpi->per_frame_bandwidth;
362 product *= cpi->oxcf.rc_max_intra_bitrate_pct;
363 product /= 100;
364 max_rate = (unsigned int)VPXMIN(INT_MAX, product);
365
366 if (target > max_rate) target = max_rate;
367 }
368
369 cpi->this_frame_target = (int)target;
370
371 /* TODO: if we separate rate targeting from Q targeting, move this.
372 * Reset the active worst quality to the baseline value for key frames.
373 */
374 if (cpi->pass != 2) cpi->active_worst_quality = cpi->worst_quality;
375
376 #if 0
377 {
378 FILE *f;
379
380 f = fopen("kf_boost.stt", "a");
381 fprintf(f, " %8u %10d %10d %10d\n",
382 cpi->common.current_video_frame, cpi->gfu_boost, cpi->baseline_gf_interval, cpi->source_alt_ref_pending);
383
384 fclose(f);
385 }
386 #endif
387 }
388
389 /* Do the best we can to define the parameters for the next GF based on what
390 * information we have available.
391 */
calc_gf_params(VP8_COMP * cpi)392 static void calc_gf_params(VP8_COMP *cpi) {
393 int Q =
394 (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
395 int Boost = 0;
396
397 int gf_frame_usage = 0; /* Golden frame usage since last GF */
398 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
399 cpi->recent_ref_frame_usage[LAST_FRAME] +
400 cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
401 cpi->recent_ref_frame_usage[ALTREF_FRAME];
402
403 int pct_gf_active = (100 * cpi->gf_active_count) /
404 (cpi->common.mb_rows * cpi->common.mb_cols);
405
406 if (tot_mbs) {
407 gf_frame_usage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
408 cpi->recent_ref_frame_usage[ALTREF_FRAME]) *
409 100 / tot_mbs;
410 }
411
412 if (pct_gf_active > gf_frame_usage) gf_frame_usage = pct_gf_active;
413
414 /* Not two pass */
415 if (cpi->pass != 2) {
416 /* Single Pass lagged mode: TBD */
417 if (0) {
418 }
419
420 /* Single Pass compression: Has to use current and historical data */
421 else {
422 #if 0
423 /* Experimental code */
424 int index = cpi->one_pass_frame_index;
425 int frames_to_scan = (cpi->max_gf_interval <= MAX_LAG_BUFFERS) ? cpi->max_gf_interval : MAX_LAG_BUFFERS;
426
427 /* ************** Experimental code - incomplete */
428 /*
429 double decay_val = 1.0;
430 double IIAccumulator = 0.0;
431 double last_iiaccumulator = 0.0;
432 double IIRatio;
433
434 cpi->one_pass_frame_index = cpi->common.current_video_frame%MAX_LAG_BUFFERS;
435
436 for ( i = 0; i < (frames_to_scan - 1); i++ )
437 {
438 if ( index < 0 )
439 index = MAX_LAG_BUFFERS;
440 index --;
441
442 if ( cpi->one_pass_frame_stats[index].frame_coded_error > 0.0 )
443 {
444 IIRatio = cpi->one_pass_frame_stats[index].frame_intra_error / cpi->one_pass_frame_stats[index].frame_coded_error;
445
446 if ( IIRatio > 30.0 )
447 IIRatio = 30.0;
448 }
449 else
450 IIRatio = 30.0;
451
452 IIAccumulator += IIRatio * decay_val;
453
454 decay_val = decay_val * cpi->one_pass_frame_stats[index].frame_pcnt_inter;
455
456 if ( (i > MIN_GF_INTERVAL) &&
457 ((IIAccumulator - last_iiaccumulator) < 2.0) )
458 {
459 break;
460 }
461 last_iiaccumulator = IIAccumulator;
462 }
463
464 Boost = IIAccumulator*100.0/16.0;
465 cpi->baseline_gf_interval = i;
466
467 */
468 #else
469
470 /*************************************************************/
471 /* OLD code */
472
473 /* Adjust boost based upon ambient Q */
474 Boost = GFQ_ADJUSTMENT;
475
476 /* Adjust based upon most recently measure intra usage */
477 Boost = Boost *
478 gf_intra_usage_adjustment[(cpi->this_frame_percent_intra < 15)
479 ? cpi->this_frame_percent_intra
480 : 14] /
481 100;
482
483 /* Adjust gf boost based upon GF usage since last GF */
484 Boost = Boost * gf_adjust_table[gf_frame_usage] / 100;
485 #endif
486 }
487
488 /* golden frame boost without recode loop often goes awry. be
489 * safe by keeping numbers down.
490 */
491 if (!cpi->sf.recode_loop) {
492 if (cpi->compressor_speed == 2) Boost = Boost / 2;
493 }
494
495 /* Apply an upper limit based on Q for 1 pass encodes */
496 if (Boost > kf_gf_boost_qlimits[Q] && (cpi->pass == 0)) {
497 Boost = kf_gf_boost_qlimits[Q];
498
499 /* Apply lower limits to boost. */
500 } else if (Boost < 110) {
501 Boost = 110;
502 }
503
504 /* Note the boost used */
505 cpi->last_boost = Boost;
506 }
507
508 /* Estimate next interval
509 * This is updated once the real frame size/boost is known.
510 */
511 if (cpi->oxcf.fixed_q == -1) {
512 if (cpi->pass == 2) { /* 2 Pass */
513 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
514 } else { /* 1 Pass */
515 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
516
517 if (cpi->last_boost > 750) cpi->frames_till_gf_update_due++;
518
519 if (cpi->last_boost > 1000) cpi->frames_till_gf_update_due++;
520
521 if (cpi->last_boost > 1250) cpi->frames_till_gf_update_due++;
522
523 if (cpi->last_boost >= 1500) cpi->frames_till_gf_update_due++;
524
525 if (gf_interval_table[gf_frame_usage] > cpi->frames_till_gf_update_due) {
526 cpi->frames_till_gf_update_due = gf_interval_table[gf_frame_usage];
527 }
528
529 if (cpi->frames_till_gf_update_due > cpi->max_gf_interval) {
530 cpi->frames_till_gf_update_due = cpi->max_gf_interval;
531 }
532 }
533 } else {
534 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
535 }
536
537 /* ARF on or off */
538 if (cpi->pass != 2) {
539 /* For now Alt ref is not allowed except in 2 pass modes. */
540 cpi->source_alt_ref_pending = 0;
541
542 /*if ( cpi->oxcf.fixed_q == -1)
543 {
544 if ( cpi->oxcf.play_alternate && (cpi->last_boost > (100 +
545 (AF_THRESH*cpi->frames_till_gf_update_due)) ) )
546 cpi->source_alt_ref_pending = 1;
547 else
548 cpi->source_alt_ref_pending = 0;
549 }*/
550 }
551 }
552
calc_pframe_target_size(VP8_COMP * cpi)553 static void calc_pframe_target_size(VP8_COMP *cpi) {
554 int min_frame_target;
555 int old_per_frame_bandwidth = cpi->per_frame_bandwidth;
556
557 if (cpi->current_layer > 0) {
558 cpi->per_frame_bandwidth =
559 cpi->layer_context[cpi->current_layer].avg_frame_size_for_layer;
560 }
561
562 min_frame_target = 0;
563
564 if (cpi->pass == 2) {
565 min_frame_target = cpi->min_frame_bandwidth;
566
567 if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5)) {
568 min_frame_target = cpi->av_per_frame_bandwidth >> 5;
569 }
570 } else if (min_frame_target < cpi->per_frame_bandwidth / 4) {
571 min_frame_target = cpi->per_frame_bandwidth / 4;
572 }
573
574 /* Special alt reference frame case */
575 if ((cpi->common.refresh_alt_ref_frame) &&
576 (cpi->oxcf.number_of_layers == 1)) {
577 if (cpi->pass == 2) {
578 /* Per frame bit target for the alt ref frame */
579 cpi->per_frame_bandwidth = cpi->twopass.gf_bits;
580 cpi->this_frame_target = cpi->per_frame_bandwidth;
581 }
582
583 /* One Pass ??? TBD */
584 }
585
586 /* Normal frames (gf,and inter) */
587 else {
588 /* 2 pass */
589 if (cpi->pass == 2) {
590 cpi->this_frame_target = cpi->per_frame_bandwidth;
591 }
592 /* 1 pass */
593 else {
594 int Adjustment;
595 /* Make rate adjustment to recover bits spent in key frame
596 * Test to see if the key frame inter data rate correction
597 * should still be in force
598 */
599 if (cpi->kf_overspend_bits > 0) {
600 Adjustment = (cpi->kf_bitrate_adjustment <= cpi->kf_overspend_bits)
601 ? cpi->kf_bitrate_adjustment
602 : cpi->kf_overspend_bits;
603
604 if (Adjustment > (cpi->per_frame_bandwidth - min_frame_target)) {
605 Adjustment = (cpi->per_frame_bandwidth - min_frame_target);
606 }
607
608 cpi->kf_overspend_bits -= Adjustment;
609
610 /* Calculate an inter frame bandwidth target for the next
611 * few frames designed to recover any extra bits spent on
612 * the key frame.
613 */
614 cpi->this_frame_target = cpi->per_frame_bandwidth - Adjustment;
615
616 if (cpi->this_frame_target < min_frame_target) {
617 cpi->this_frame_target = min_frame_target;
618 }
619 } else {
620 cpi->this_frame_target = cpi->per_frame_bandwidth;
621 }
622
623 /* If appropriate make an adjustment to recover bits spent on a
624 * recent GF
625 */
626 if ((cpi->gf_overspend_bits > 0) &&
627 (cpi->this_frame_target > min_frame_target)) {
628 Adjustment = (cpi->non_gf_bitrate_adjustment <= cpi->gf_overspend_bits)
629 ? cpi->non_gf_bitrate_adjustment
630 : cpi->gf_overspend_bits;
631
632 if (Adjustment > (cpi->this_frame_target - min_frame_target)) {
633 Adjustment = (cpi->this_frame_target - min_frame_target);
634 }
635
636 cpi->gf_overspend_bits -= Adjustment;
637 cpi->this_frame_target -= Adjustment;
638 }
639
640 /* Apply small + and - boosts for non gf frames */
641 if ((cpi->last_boost > 150) && (cpi->frames_till_gf_update_due > 0) &&
642 (cpi->current_gf_interval >= (MIN_GF_INTERVAL << 1))) {
643 /* % Adjustment limited to the range 1% to 10% */
644 Adjustment = (cpi->last_boost - 100) >> 5;
645
646 if (Adjustment < 1) {
647 Adjustment = 1;
648 } else if (Adjustment > 10) {
649 Adjustment = 10;
650 }
651
652 /* Convert to bits */
653 Adjustment = (cpi->this_frame_target * Adjustment) / 100;
654
655 if (Adjustment > (cpi->this_frame_target - min_frame_target)) {
656 Adjustment = (cpi->this_frame_target - min_frame_target);
657 }
658
659 if (cpi->frames_since_golden == (cpi->current_gf_interval >> 1)) {
660 Adjustment = (cpi->current_gf_interval - 1) * Adjustment;
661 // Limit adjustment to 10% of current target.
662 if (Adjustment > (10 * cpi->this_frame_target) / 100) {
663 Adjustment = (10 * cpi->this_frame_target) / 100;
664 }
665 cpi->this_frame_target += Adjustment;
666 } else {
667 cpi->this_frame_target -= Adjustment;
668 }
669 }
670 }
671 }
672
673 /* Sanity check that the total sum of adjustments is not above the
674 * maximum allowed That is that having allowed for KF and GF penalties
675 * we have not pushed the current interframe target to low. If the
676 * adjustment we apply here is not capable of recovering all the extra
677 * bits we have spent in the KF or GF then the remainder will have to
678 * be recovered over a longer time span via other buffer / rate control
679 * mechanisms.
680 */
681 if (cpi->this_frame_target < min_frame_target) {
682 cpi->this_frame_target = min_frame_target;
683 }
684
685 if (!cpi->common.refresh_alt_ref_frame) {
686 /* Note the baseline target data rate for this inter frame. */
687 cpi->inter_frame_target = cpi->this_frame_target;
688 }
689
690 /* One Pass specific code */
691 if (cpi->pass == 0) {
692 /* Adapt target frame size with respect to any buffering constraints: */
693 if (cpi->buffered_mode) {
694 int one_percent_bits = (int)(1 + cpi->oxcf.optimal_buffer_level / 100);
695
696 if ((cpi->buffer_level < cpi->oxcf.optimal_buffer_level) ||
697 (cpi->bits_off_target < cpi->oxcf.optimal_buffer_level)) {
698 int percent_low = 0;
699
700 /* Decide whether or not we need to adjust the frame data
701 * rate target.
702 *
703 * If we are are below the optimal buffer fullness level
704 * and adherence to buffering constraints is important to
705 * the end usage then adjust the per frame target.
706 */
707 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
708 (cpi->buffer_level < cpi->oxcf.optimal_buffer_level)) {
709 percent_low =
710 (int)((cpi->oxcf.optimal_buffer_level - cpi->buffer_level) /
711 one_percent_bits);
712 }
713 /* Are we overshooting the long term clip data rate... */
714 else if (cpi->bits_off_target < 0) {
715 /* Adjust per frame data target downwards to compensate. */
716 percent_low =
717 (int)(100 * -cpi->bits_off_target / (cpi->total_byte_count * 8));
718 }
719
720 if (percent_low > cpi->oxcf.under_shoot_pct) {
721 percent_low = cpi->oxcf.under_shoot_pct;
722 } else if (percent_low < 0) {
723 percent_low = 0;
724 }
725
726 /* lower the target bandwidth for this frame. */
727 cpi->this_frame_target -=
728 (int)(((int64_t)cpi->this_frame_target * percent_low) / 200);
729
730 /* Are we using allowing control of active_worst_allowed_q
731 * according to buffer level.
732 */
733 if (cpi->auto_worst_q && cpi->ni_frames > 150) {
734 int64_t critical_buffer_level;
735
736 /* For streaming applications the most important factor is
737 * cpi->buffer_level as this takes into account the
738 * specified short term buffering constraints. However,
739 * hitting the long term clip data rate target is also
740 * important.
741 */
742 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
743 /* Take the smaller of cpi->buffer_level and
744 * cpi->bits_off_target
745 */
746 critical_buffer_level = (cpi->buffer_level < cpi->bits_off_target)
747 ? cpi->buffer_level
748 : cpi->bits_off_target;
749 }
750 /* For local file playback short term buffering constraints
751 * are less of an issue
752 */
753 else {
754 /* Consider only how we are doing for the clip as a
755 * whole
756 */
757 critical_buffer_level = cpi->bits_off_target;
758 }
759
760 /* Set the active worst quality based upon the selected
761 * buffer fullness number.
762 */
763 if (critical_buffer_level < cpi->oxcf.optimal_buffer_level) {
764 if (critical_buffer_level > (cpi->oxcf.optimal_buffer_level >> 2)) {
765 int64_t qadjustment_range = cpi->worst_quality - cpi->ni_av_qi;
766 int64_t above_base = (critical_buffer_level -
767 (cpi->oxcf.optimal_buffer_level >> 2));
768
769 /* Step active worst quality down from
770 * cpi->ni_av_qi when (critical_buffer_level ==
771 * cpi->optimal_buffer_level) to
772 * cpi->worst_quality when
773 * (critical_buffer_level ==
774 * cpi->optimal_buffer_level >> 2)
775 */
776 cpi->active_worst_quality =
777 cpi->worst_quality -
778 (int)((qadjustment_range * above_base) /
779 (cpi->oxcf.optimal_buffer_level * 3 >> 2));
780 } else {
781 cpi->active_worst_quality = cpi->worst_quality;
782 }
783 } else {
784 cpi->active_worst_quality = cpi->ni_av_qi;
785 }
786 } else {
787 cpi->active_worst_quality = cpi->worst_quality;
788 }
789 } else {
790 int percent_high = 0;
791 int64_t target = cpi->this_frame_target;
792
793 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
794 (cpi->buffer_level > cpi->oxcf.optimal_buffer_level)) {
795 percent_high =
796 (int)((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) /
797 one_percent_bits);
798 } else if (cpi->bits_off_target > cpi->oxcf.optimal_buffer_level) {
799 if (cpi->total_byte_count > 0) {
800 percent_high = (int)((100 * cpi->bits_off_target) /
801 (cpi->total_byte_count * 8));
802 } else {
803 percent_high = cpi->oxcf.over_shoot_pct;
804 }
805 }
806
807 if (percent_high > cpi->oxcf.over_shoot_pct) {
808 percent_high = cpi->oxcf.over_shoot_pct;
809 } else if (percent_high < 0) {
810 percent_high = 0;
811 }
812
813 target += (target * percent_high) / 200;
814 target = VPXMIN(target, INT_MAX);
815 cpi->this_frame_target = (int)target;
816
817 /* Are we allowing control of active_worst_allowed_q according
818 * to buffer level.
819 */
820 if (cpi->auto_worst_q && cpi->ni_frames > 150) {
821 /* When using the relaxed buffer model stick to the
822 * user specified value
823 */
824 cpi->active_worst_quality = cpi->ni_av_qi;
825 } else {
826 cpi->active_worst_quality = cpi->worst_quality;
827 }
828 }
829
830 /* Set active_best_quality to prevent quality rising too high */
831 cpi->active_best_quality = cpi->best_quality;
832
833 /* Worst quality obviously must not be better than best quality */
834 if (cpi->active_worst_quality <= cpi->active_best_quality) {
835 cpi->active_worst_quality = cpi->active_best_quality + 1;
836 }
837
838 if (cpi->active_worst_quality > 127) cpi->active_worst_quality = 127;
839 }
840 /* Unbuffered mode (eg. video conferencing) */
841 else {
842 /* Set the active worst quality */
843 cpi->active_worst_quality = cpi->worst_quality;
844 }
845
846 /* Special trap for constrained quality mode
847 * "active_worst_quality" may never drop below cq level
848 * for any frame type.
849 */
850 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY &&
851 cpi->active_worst_quality < cpi->cq_target_quality) {
852 cpi->active_worst_quality = cpi->cq_target_quality;
853 }
854 }
855
856 /* Test to see if we have to drop a frame
857 * The auto-drop frame code is only used in buffered mode.
858 * In unbufferd mode (eg vide conferencing) the descision to
859 * code or drop a frame is made outside the codec in response to real
860 * world comms or buffer considerations.
861 */
862 if (cpi->drop_frames_allowed &&
863 (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
864 ((cpi->common.frame_type != KEY_FRAME))) {
865 /* Check for a buffer underun-crisis in which case we have to drop
866 * a frame
867 */
868 if ((cpi->buffer_level < 0)) {
869 #if 0
870 FILE *f = fopen("dec.stt", "a");
871 fprintf(f, "%10d %10d %10d %10d ***** BUFFER EMPTY\n",
872 (int) cpi->common.current_video_frame,
873 cpi->decimation_factor, cpi->common.horiz_scale,
874 (cpi->buffer_level * 100) / cpi->oxcf.optimal_buffer_level);
875 fclose(f);
876 #endif
877 cpi->drop_frame = 1;
878
879 /* Update the buffer level variable. */
880 cpi->bits_off_target += cpi->av_per_frame_bandwidth;
881 if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size) {
882 cpi->bits_off_target = (int)cpi->oxcf.maximum_buffer_size;
883 }
884 cpi->buffer_level = cpi->bits_off_target;
885
886 if (cpi->oxcf.number_of_layers > 1) {
887 unsigned int i;
888
889 // Propagate bits saved by dropping the frame to higher layers.
890 for (i = cpi->current_layer + 1; i < cpi->oxcf.number_of_layers; ++i) {
891 LAYER_CONTEXT *lc = &cpi->layer_context[i];
892 lc->bits_off_target += (int)(lc->target_bandwidth / lc->framerate);
893 if (lc->bits_off_target > lc->maximum_buffer_size) {
894 lc->bits_off_target = lc->maximum_buffer_size;
895 }
896 lc->buffer_level = lc->bits_off_target;
897 }
898 }
899 }
900 }
901
902 /* Adjust target frame size for Golden Frames: */
903 if (cpi->oxcf.error_resilient_mode == 0 &&
904 (cpi->frames_till_gf_update_due == 0) && !cpi->drop_frame) {
905 if (!cpi->gf_update_onepass_cbr) {
906 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME]
907 : cpi->oxcf.fixed_q;
908
909 int gf_frame_usage = 0; /* Golden frame usage since last GF */
910 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
911 cpi->recent_ref_frame_usage[LAST_FRAME] +
912 cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
913 cpi->recent_ref_frame_usage[ALTREF_FRAME];
914
915 int pct_gf_active = (100 * cpi->gf_active_count) /
916 (cpi->common.mb_rows * cpi->common.mb_cols);
917
918 if (tot_mbs) {
919 gf_frame_usage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
920 cpi->recent_ref_frame_usage[ALTREF_FRAME]) *
921 100 / tot_mbs;
922 }
923
924 if (pct_gf_active > gf_frame_usage) gf_frame_usage = pct_gf_active;
925
926 /* Is a fixed manual GF frequency being used */
927 if (cpi->auto_gold) {
928 /* For one pass throw a GF if recent frame intra usage is
929 * low or the GF usage is high
930 */
931 if ((cpi->pass == 0) &&
932 (cpi->this_frame_percent_intra < 15 || gf_frame_usage >= 5)) {
933 cpi->common.refresh_golden_frame = 1;
934
935 /* Two pass GF descision */
936 } else if (cpi->pass == 2) {
937 cpi->common.refresh_golden_frame = 1;
938 }
939 }
940
941 #if 0
942
943 /* Debug stats */
944 if (0) {
945 FILE *f;
946
947 f = fopen("gf_usaget.stt", "a");
948 fprintf(f, " %8ld %10ld %10ld %10ld %10ld\n",
949 cpi->common.current_video_frame, cpi->gfu_boost,
950 GFQ_ADJUSTMENT, cpi->gfu_boost, gf_frame_usage);
951 fclose(f);
952 }
953
954 #endif
955
956 if (cpi->common.refresh_golden_frame == 1) {
957 #if 0
958
959 if (0) {
960 FILE *f;
961
962 f = fopen("GFexit.stt", "a");
963 fprintf(f, "%8ld GF coded\n", cpi->common.current_video_frame);
964 fclose(f);
965 }
966
967 #endif
968
969 if (cpi->auto_adjust_gold_quantizer) {
970 calc_gf_params(cpi);
971 }
972
973 /* If we are using alternate ref instead of gf then do not apply the
974 * boost It will instead be applied to the altref update Jims
975 * modified boost
976 */
977 if (!cpi->source_alt_ref_active) {
978 if (cpi->oxcf.fixed_q < 0) {
979 if (cpi->pass == 2) {
980 /* The spend on the GF is defined in the two pass
981 * code for two pass encodes
982 */
983 cpi->this_frame_target = cpi->per_frame_bandwidth;
984 } else {
985 int Boost = cpi->last_boost;
986 int frames_in_section = cpi->frames_till_gf_update_due + 1;
987 int allocation_chunks = (frames_in_section * 100) + (Boost - 100);
988 int bits_in_section = cpi->inter_frame_target * frames_in_section;
989
990 /* Normalize Altboost and allocations chunck down to
991 * prevent overflow
992 */
993 while (Boost > 1000) {
994 Boost /= 2;
995 allocation_chunks /= 2;
996 }
997
998 /* Avoid loss of precision but avoid overflow */
999 if ((bits_in_section >> 7) > allocation_chunks) {
1000 cpi->this_frame_target =
1001 Boost * (bits_in_section / allocation_chunks);
1002 } else {
1003 cpi->this_frame_target =
1004 (Boost * bits_in_section) / allocation_chunks;
1005 }
1006 }
1007 } else {
1008 cpi->this_frame_target =
1009 (estimate_bits_at_q(1, Q, cpi->common.MBs, 1.0) *
1010 cpi->last_boost) /
1011 100;
1012 }
1013 } else {
1014 /* If there is an active ARF at this location use the minimum
1015 * bits on this frame even if it is a contructed arf.
1016 * The active maximum quantizer insures that an appropriate
1017 * number of bits will be spent if needed for contstructed ARFs.
1018 */
1019 cpi->this_frame_target = 0;
1020 }
1021
1022 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
1023 }
1024 } else {
1025 // Special case for 1 pass CBR: fixed gf period.
1026 // TODO(marpan): Adjust this boost/interval logic.
1027 // If gf_cbr_boost_pct is small (below threshold) set the flag
1028 // gf_noboost_onepass_cbr = 1, which forces the gf to use the same
1029 // rate correction factor as last.
1030 cpi->gf_noboost_onepass_cbr = (cpi->oxcf.gf_cbr_boost_pct <= 100);
1031 cpi->baseline_gf_interval = cpi->gf_interval_onepass_cbr;
1032 // Skip this update if the zero_mvcount is low.
1033 if (cpi->zeromv_count > (cpi->common.MBs >> 1)) {
1034 cpi->common.refresh_golden_frame = 1;
1035 cpi->this_frame_target =
1036 (cpi->this_frame_target * (100 + cpi->oxcf.gf_cbr_boost_pct)) / 100;
1037 }
1038 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
1039 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
1040 }
1041 }
1042
1043 cpi->per_frame_bandwidth = old_per_frame_bandwidth;
1044 }
1045
vp8_update_rate_correction_factors(VP8_COMP * cpi,int damp_var)1046 void vp8_update_rate_correction_factors(VP8_COMP *cpi, int damp_var) {
1047 int Q = cpi->common.base_qindex;
1048 int correction_factor = 100;
1049 double rate_correction_factor;
1050 double adjustment_limit;
1051
1052 int projected_size_based_on_q = 0;
1053
1054 /* Clear down mmx registers to allow floating point in what follows */
1055 vpx_clear_system_state();
1056
1057 if (cpi->common.frame_type == KEY_FRAME) {
1058 rate_correction_factor = cpi->key_frame_rate_correction_factor;
1059 } else {
1060 if (cpi->oxcf.number_of_layers == 1 && !cpi->gf_noboost_onepass_cbr &&
1061 (cpi->common.refresh_alt_ref_frame ||
1062 cpi->common.refresh_golden_frame)) {
1063 rate_correction_factor = cpi->gf_rate_correction_factor;
1064 } else {
1065 rate_correction_factor = cpi->rate_correction_factor;
1066 }
1067 }
1068
1069 /* Work out how big we would have expected the frame to be at this Q
1070 * given the current correction factor. Stay in double to avoid int
1071 * overflow when values are large
1072 */
1073 projected_size_based_on_q =
1074 (int)(((.5 + rate_correction_factor *
1075 vp8_bits_per_mb[cpi->common.frame_type][Q]) *
1076 cpi->common.MBs) /
1077 (1 << BPER_MB_NORMBITS));
1078
1079 /* Make some allowance for cpi->zbin_over_quant */
1080 if (cpi->mb.zbin_over_quant > 0) {
1081 int Z = cpi->mb.zbin_over_quant;
1082 double Factor = 0.99;
1083 double factor_adjustment = 0.01 / 256.0;
1084
1085 while (Z > 0) {
1086 Z--;
1087 projected_size_based_on_q = (int)(Factor * projected_size_based_on_q);
1088 Factor += factor_adjustment;
1089
1090 if (Factor >= 0.999) Factor = 0.999;
1091 }
1092 }
1093
1094 /* Work out a size correction factor. */
1095 if (projected_size_based_on_q > 0) {
1096 correction_factor = (int)((100 * (int64_t)cpi->projected_frame_size) /
1097 projected_size_based_on_q);
1098 }
1099
1100 /* More heavily damped adjustment used if we have been oscillating
1101 * either side of target
1102 */
1103 switch (damp_var) {
1104 case 0: adjustment_limit = 0.75; break;
1105 case 1: adjustment_limit = 0.375; break;
1106 case 2:
1107 default: adjustment_limit = 0.25; break;
1108 }
1109
1110 if (correction_factor > 102) {
1111 /* We are not already at the worst allowable quality */
1112 correction_factor =
1113 (int)(100.5 + ((correction_factor - 100) * adjustment_limit));
1114 rate_correction_factor =
1115 ((rate_correction_factor * correction_factor) / 100);
1116
1117 /* Keep rate_correction_factor within limits */
1118 if (rate_correction_factor > MAX_BPB_FACTOR) {
1119 rate_correction_factor = MAX_BPB_FACTOR;
1120 }
1121 } else if (correction_factor < 99) {
1122 /* We are not already at the best allowable quality */
1123 correction_factor =
1124 (int)(100.5 - ((100 - correction_factor) * adjustment_limit));
1125 rate_correction_factor =
1126 ((rate_correction_factor * correction_factor) / 100);
1127
1128 /* Keep rate_correction_factor within limits */
1129 if (rate_correction_factor < MIN_BPB_FACTOR) {
1130 rate_correction_factor = MIN_BPB_FACTOR;
1131 }
1132 }
1133
1134 if (cpi->common.frame_type == KEY_FRAME) {
1135 cpi->key_frame_rate_correction_factor = rate_correction_factor;
1136 } else {
1137 if (cpi->oxcf.number_of_layers == 1 && !cpi->gf_noboost_onepass_cbr &&
1138 (cpi->common.refresh_alt_ref_frame ||
1139 cpi->common.refresh_golden_frame)) {
1140 cpi->gf_rate_correction_factor = rate_correction_factor;
1141 } else {
1142 cpi->rate_correction_factor = rate_correction_factor;
1143 }
1144 }
1145 }
1146
limit_q_cbr_inter(int last_q,int current_q)1147 static int limit_q_cbr_inter(int last_q, int current_q) {
1148 int limit_down = 12;
1149 if (last_q - current_q > limit_down)
1150 return (last_q - limit_down);
1151 else
1152 return current_q;
1153 }
1154
vp8_regulate_q(VP8_COMP * cpi,int target_bits_per_frame)1155 int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame) {
1156 int Q = cpi->active_worst_quality;
1157
1158 if (cpi->force_maxqp == 1) {
1159 cpi->active_worst_quality = cpi->worst_quality;
1160 return cpi->worst_quality;
1161 }
1162 /* Reset Zbin OQ value */
1163 cpi->mb.zbin_over_quant = 0;
1164
1165 if (cpi->oxcf.fixed_q >= 0) {
1166 Q = cpi->oxcf.fixed_q;
1167
1168 if (cpi->common.frame_type == KEY_FRAME) {
1169 Q = cpi->oxcf.key_q;
1170 } else if (cpi->oxcf.number_of_layers == 1 &&
1171 cpi->common.refresh_alt_ref_frame &&
1172 !cpi->gf_noboost_onepass_cbr) {
1173 Q = cpi->oxcf.alt_q;
1174 } else if (cpi->oxcf.number_of_layers == 1 &&
1175 cpi->common.refresh_golden_frame &&
1176 !cpi->gf_noboost_onepass_cbr) {
1177 Q = cpi->oxcf.gold_q;
1178 }
1179 } else {
1180 int i;
1181 int last_error = INT_MAX;
1182 int target_bits_per_mb;
1183 int bits_per_mb_at_this_q;
1184 double correction_factor;
1185
1186 /* Select the appropriate correction factor based upon type of frame. */
1187 if (cpi->common.frame_type == KEY_FRAME) {
1188 correction_factor = cpi->key_frame_rate_correction_factor;
1189 } else {
1190 if (cpi->oxcf.number_of_layers == 1 && !cpi->gf_noboost_onepass_cbr &&
1191 (cpi->common.refresh_alt_ref_frame ||
1192 cpi->common.refresh_golden_frame)) {
1193 correction_factor = cpi->gf_rate_correction_factor;
1194 } else {
1195 correction_factor = cpi->rate_correction_factor;
1196 }
1197 }
1198
1199 /* Calculate required scaling factor based on target frame size and
1200 * size of frame produced using previous Q
1201 */
1202 if (target_bits_per_frame > (INT_MAX >> BPER_MB_NORMBITS)) {
1203 int temp = target_bits_per_frame / cpi->common.MBs;
1204 if (temp > (INT_MAX >> BPER_MB_NORMBITS)) {
1205 target_bits_per_mb = INT_MAX;
1206 } else {
1207 target_bits_per_mb = temp << BPER_MB_NORMBITS;
1208 }
1209 } else {
1210 target_bits_per_mb =
1211 (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
1212 }
1213
1214 i = cpi->active_best_quality;
1215
1216 do {
1217 bits_per_mb_at_this_q =
1218 (int)(.5 +
1219 correction_factor * vp8_bits_per_mb[cpi->common.frame_type][i]);
1220
1221 if (bits_per_mb_at_this_q <= target_bits_per_mb) {
1222 if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error) {
1223 Q = i;
1224 } else {
1225 Q = i - 1;
1226 }
1227
1228 break;
1229 } else {
1230 last_error = bits_per_mb_at_this_q - target_bits_per_mb;
1231 }
1232 } while (++i <= cpi->active_worst_quality);
1233
1234 /* If we are at MAXQ then enable Q over-run which seeks to claw
1235 * back additional bits through things like the RD multiplier
1236 * and zero bin size.
1237 */
1238 if (Q >= MAXQ) {
1239 int zbin_oqmax;
1240
1241 double Factor = 0.99;
1242 double factor_adjustment = 0.01 / 256.0;
1243
1244 if (cpi->common.frame_type == KEY_FRAME) {
1245 zbin_oqmax = 0;
1246 } else if (cpi->oxcf.number_of_layers == 1 &&
1247 !cpi->gf_noboost_onepass_cbr &&
1248 (cpi->common.refresh_alt_ref_frame ||
1249 (cpi->common.refresh_golden_frame &&
1250 !cpi->source_alt_ref_active))) {
1251 zbin_oqmax = 16;
1252 } else {
1253 zbin_oqmax = ZBIN_OQ_MAX;
1254 }
1255
1256 /*{
1257 double Factor =
1258 (double)target_bits_per_mb/(double)bits_per_mb_at_this_q;
1259 double Oq;
1260
1261 Factor = Factor/1.2683;
1262
1263 Oq = pow( Factor, (1.0/-0.165) );
1264
1265 if ( Oq > zbin_oqmax )
1266 Oq = zbin_oqmax;
1267
1268 cpi->zbin_over_quant = (int)Oq;
1269 }*/
1270
1271 /* Each incrment in the zbin is assumed to have a fixed effect
1272 * on bitrate. This is not of course true. The effect will be
1273 * highly clip dependent and may well have sudden steps. The
1274 * idea here is to acheive higher effective quantizers than the
1275 * normal maximum by expanding the zero bin and hence
1276 * decreasing the number of low magnitude non zero coefficients.
1277 */
1278 while (cpi->mb.zbin_over_quant < zbin_oqmax) {
1279 cpi->mb.zbin_over_quant++;
1280
1281 if (cpi->mb.zbin_over_quant > zbin_oqmax) {
1282 cpi->mb.zbin_over_quant = zbin_oqmax;
1283 }
1284
1285 /* Adjust bits_per_mb_at_this_q estimate */
1286 bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q);
1287 Factor += factor_adjustment;
1288
1289 if (Factor >= 0.999) Factor = 0.999;
1290
1291 /* Break out if we get down to the target rate */
1292 if (bits_per_mb_at_this_q <= target_bits_per_mb) break;
1293 }
1294 }
1295 }
1296
1297 // Limit decrease in Q for 1 pass CBR screen content mode.
1298 if (cpi->common.frame_type != KEY_FRAME && cpi->pass == 0 &&
1299 cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER &&
1300 cpi->oxcf.screen_content_mode)
1301 Q = limit_q_cbr_inter(cpi->last_q[1], Q);
1302
1303 return Q;
1304 }
1305
estimate_keyframe_frequency(VP8_COMP * cpi)1306 static int estimate_keyframe_frequency(VP8_COMP *cpi) {
1307 int i;
1308
1309 /* Average key frame frequency */
1310 int av_key_frame_frequency = 0;
1311
1312 /* First key frame at start of sequence is a special case. We have no
1313 * frequency data.
1314 */
1315 if (cpi->key_frame_count == 1) {
1316 /* Assume a default of 1 kf every 2 seconds, or the max kf interval,
1317 * whichever is smaller.
1318 */
1319 int key_freq = cpi->oxcf.key_freq > 0 ? cpi->oxcf.key_freq : 1;
1320 av_key_frame_frequency = 1 + (int)cpi->output_framerate * 2;
1321
1322 if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq) {
1323 av_key_frame_frequency = key_freq;
1324 }
1325
1326 cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1] =
1327 av_key_frame_frequency;
1328 } else {
1329 unsigned int total_weight = 0;
1330 int last_kf_interval =
1331 (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;
1332
1333 /* reset keyframe context and calculate weighted average of last
1334 * KEY_FRAME_CONTEXT keyframes
1335 */
1336 for (i = 0; i < KEY_FRAME_CONTEXT; ++i) {
1337 if (i < KEY_FRAME_CONTEXT - 1) {
1338 cpi->prior_key_frame_distance[i] = cpi->prior_key_frame_distance[i + 1];
1339 } else {
1340 cpi->prior_key_frame_distance[i] = last_kf_interval;
1341 }
1342
1343 av_key_frame_frequency +=
1344 prior_key_frame_weight[i] * cpi->prior_key_frame_distance[i];
1345 total_weight += prior_key_frame_weight[i];
1346 }
1347
1348 av_key_frame_frequency /= total_weight;
1349 }
1350 // TODO (marpan): Given the checks above, |av_key_frame_frequency|
1351 // should always be above 0. But for now we keep the sanity check in.
1352 if (av_key_frame_frequency == 0) av_key_frame_frequency = 1;
1353 return av_key_frame_frequency;
1354 }
1355
vp8_adjust_key_frame_context(VP8_COMP * cpi)1356 void vp8_adjust_key_frame_context(VP8_COMP *cpi) {
1357 /* Clear down mmx registers to allow floating point in what follows */
1358 vpx_clear_system_state();
1359
1360 /* Do we have any key frame overspend to recover? */
1361 /* Two-pass overspend handled elsewhere. */
1362 if ((cpi->pass != 2) &&
1363 (cpi->projected_frame_size > cpi->per_frame_bandwidth)) {
1364 int overspend;
1365
1366 /* Update the count of key frame overspend to be recovered in
1367 * subsequent frames. A portion of the KF overspend is treated as gf
1368 * overspend (and hence recovered more quickly) as the kf is also a
1369 * gf. Otherwise the few frames following each kf tend to get more
1370 * bits allocated than those following other gfs.
1371 */
1372 overspend = (cpi->projected_frame_size - cpi->per_frame_bandwidth);
1373
1374 if (cpi->oxcf.number_of_layers > 1) {
1375 cpi->kf_overspend_bits += overspend;
1376 } else {
1377 cpi->kf_overspend_bits += overspend * 7 / 8;
1378 cpi->gf_overspend_bits += overspend * 1 / 8;
1379 }
1380
1381 /* Work out how much to try and recover per frame. */
1382 cpi->kf_bitrate_adjustment =
1383 cpi->kf_overspend_bits / estimate_keyframe_frequency(cpi);
1384 }
1385
1386 cpi->frames_since_key = 0;
1387 cpi->key_frame_count++;
1388 }
1389
vp8_compute_frame_size_bounds(VP8_COMP * cpi,int * frame_under_shoot_limit,int * frame_over_shoot_limit)1390 void vp8_compute_frame_size_bounds(VP8_COMP *cpi, int *frame_under_shoot_limit,
1391 int *frame_over_shoot_limit) {
1392 /* Set-up bounds on acceptable frame size: */
1393 if (cpi->oxcf.fixed_q >= 0) {
1394 /* Fixed Q scenario: frame size never outranges target
1395 * (there is no target!)
1396 */
1397 *frame_under_shoot_limit = 0;
1398 *frame_over_shoot_limit = INT_MAX;
1399 } else {
1400 const int64_t this_frame_target = cpi->this_frame_target;
1401 int64_t over_shoot_limit, under_shoot_limit;
1402
1403 if (cpi->common.frame_type == KEY_FRAME) {
1404 over_shoot_limit = this_frame_target * 9 / 8;
1405 under_shoot_limit = this_frame_target * 7 / 8;
1406 } else {
1407 if (cpi->oxcf.number_of_layers > 1 || cpi->common.refresh_alt_ref_frame ||
1408 cpi->common.refresh_golden_frame) {
1409 over_shoot_limit = this_frame_target * 9 / 8;
1410 under_shoot_limit = this_frame_target * 7 / 8;
1411 } else {
1412 /* For CBR take buffer fullness into account */
1413 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
1414 if (cpi->buffer_level >= ((cpi->oxcf.optimal_buffer_level +
1415 cpi->oxcf.maximum_buffer_size) >>
1416 1)) {
1417 /* Buffer is too full so relax overshoot and tighten
1418 * undershoot
1419 */
1420 over_shoot_limit = this_frame_target * 12 / 8;
1421 under_shoot_limit = this_frame_target * 6 / 8;
1422 } else if (cpi->buffer_level <=
1423 (cpi->oxcf.optimal_buffer_level >> 1)) {
1424 /* Buffer is too low so relax undershoot and tighten
1425 * overshoot
1426 */
1427 over_shoot_limit = this_frame_target * 10 / 8;
1428 under_shoot_limit = this_frame_target * 4 / 8;
1429 } else {
1430 over_shoot_limit = this_frame_target * 11 / 8;
1431 under_shoot_limit = this_frame_target * 5 / 8;
1432 }
1433 }
1434 /* VBR and CQ mode */
1435 /* Note that tighter restrictions here can help quality
1436 * but hurt encode speed
1437 */
1438 else {
1439 /* Stron overshoot limit for constrained quality */
1440 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
1441 over_shoot_limit = this_frame_target * 11 / 8;
1442 under_shoot_limit = this_frame_target * 2 / 8;
1443 } else {
1444 over_shoot_limit = this_frame_target * 11 / 8;
1445 under_shoot_limit = this_frame_target * 5 / 8;
1446 }
1447 }
1448 }
1449 }
1450
1451 /* For very small rate targets where the fractional adjustment
1452 * (eg * 7/8) may be tiny make sure there is at least a minimum
1453 * range.
1454 */
1455 over_shoot_limit += 200;
1456 under_shoot_limit -= 200;
1457 if (under_shoot_limit < 0) under_shoot_limit = 0;
1458 if (under_shoot_limit > INT_MAX) under_shoot_limit = INT_MAX;
1459 if (over_shoot_limit > INT_MAX) over_shoot_limit = INT_MAX;
1460 *frame_under_shoot_limit = (int)under_shoot_limit;
1461 *frame_over_shoot_limit = (int)over_shoot_limit;
1462 }
1463 }
1464
1465 /* return of 0 means drop frame */
vp8_pick_frame_size(VP8_COMP * cpi)1466 int vp8_pick_frame_size(VP8_COMP *cpi) {
1467 VP8_COMMON *cm = &cpi->common;
1468
1469 if (cm->frame_type == KEY_FRAME) {
1470 calc_iframe_target_size(cpi);
1471 } else {
1472 calc_pframe_target_size(cpi);
1473
1474 /* Check if we're dropping the frame: */
1475 if (cpi->drop_frame) {
1476 cpi->drop_frame = 0;
1477 return 0;
1478 }
1479 }
1480 return 1;
1481 }
1482 // If this just encoded frame (mcomp/transform/quant, but before loopfilter and
1483 // pack_bitstream) has large overshoot, and was not being encoded close to the
1484 // max QP, then drop this frame and force next frame to be encoded at max QP.
1485 // Allow this for screen_content_mode = 2, or if drop frames is allowed.
1486 // TODO(marpan): Should do this exit condition during the encode_frame
1487 // (i.e., halfway during the encoding of the frame) to save cycles.
vp8_drop_encodedframe_overshoot(VP8_COMP * cpi,int Q)1488 int vp8_drop_encodedframe_overshoot(VP8_COMP *cpi, int Q) {
1489 int force_drop_overshoot = 0;
1490 #if CONFIG_MULTI_RES_ENCODING
1491 // Only check for dropping due to overshoot on the lowest stream.
1492 // If the lowest stream of the multi-res encoding was dropped due to
1493 // overshoot, then force dropping on all upper layer streams
1494 // (mr_encoder_id > 0).
1495 LOWER_RES_FRAME_INFO *low_res_frame_info =
1496 (LOWER_RES_FRAME_INFO *)cpi->oxcf.mr_low_res_mode_info;
1497 if (cpi->oxcf.mr_total_resolutions > 1 && cpi->oxcf.mr_encoder_id > 0) {
1498 force_drop_overshoot = low_res_frame_info->is_frame_dropped_overshoot_maxqp;
1499 if (!force_drop_overshoot) {
1500 cpi->force_maxqp = 0;
1501 cpi->frames_since_last_drop_overshoot++;
1502 return 0;
1503 }
1504 }
1505 #endif
1506 if (cpi->common.frame_type != KEY_FRAME &&
1507 (cpi->oxcf.screen_content_mode == 2 ||
1508 (cpi->drop_frames_allowed &&
1509 (force_drop_overshoot ||
1510 (cpi->rate_correction_factor < (8.0f * MIN_BPB_FACTOR) &&
1511 cpi->frames_since_last_drop_overshoot > (int)cpi->framerate))))) {
1512 // Note: the "projected_frame_size" from encode_frame() only gives estimate
1513 // of mode/motion vector rate (in non-rd mode): so below we only require
1514 // that projected_frame_size is somewhat greater than per-frame-bandwidth,
1515 // but add additional condition with high threshold on prediction residual.
1516
1517 // QP threshold: only allow dropping if we are not close to qp_max.
1518 int thresh_qp = 3 * cpi->worst_quality >> 2;
1519 // Rate threshold, in bytes.
1520 int thresh_rate = 2 * (cpi->av_per_frame_bandwidth >> 3);
1521 // Threshold for the average (over all macroblocks) of the pixel-sum
1522 // residual error over 16x16 block.
1523 int thresh_pred_err_mb = (200 << 4);
1524 int pred_err_mb = (int)(cpi->mb.prediction_error / cpi->common.MBs);
1525 // Reduce/ignore thresh_rate if pred_err_mb much larger than its threshold,
1526 // give more weight to pred_err metric for overshoot detection.
1527 if (cpi->drop_frames_allowed && pred_err_mb > (thresh_pred_err_mb << 4))
1528 thresh_rate = thresh_rate >> 3;
1529 if ((Q < thresh_qp && cpi->projected_frame_size > thresh_rate &&
1530 pred_err_mb > thresh_pred_err_mb &&
1531 pred_err_mb > 2 * cpi->last_pred_err_mb) ||
1532 force_drop_overshoot) {
1533 unsigned int i;
1534 double new_correction_factor;
1535 int target_bits_per_mb;
1536 const int target_size = cpi->av_per_frame_bandwidth;
1537 // Flag to indicate we will force next frame to be encoded at max QP.
1538 cpi->force_maxqp = 1;
1539 // Reset the buffer levels.
1540 cpi->buffer_level = cpi->oxcf.optimal_buffer_level;
1541 cpi->bits_off_target = cpi->oxcf.optimal_buffer_level;
1542 // Compute a new rate correction factor, corresponding to the current
1543 // target frame size and max_QP, and adjust the rate correction factor
1544 // upwards, if needed.
1545 // This is to prevent a bad state where the re-encoded frame at max_QP
1546 // undershoots significantly, and then we end up dropping every other
1547 // frame because the QP/rate_correction_factor may have been too low
1548 // before the drop and then takes too long to come up.
1549 if (target_size > (INT_MAX >> BPER_MB_NORMBITS)) {
1550 int temp = target_size / cpi->common.MBs;
1551 if (temp > (INT_MAX >> BPER_MB_NORMBITS)) {
1552 target_bits_per_mb = INT_MAX;
1553 } else {
1554 target_bits_per_mb = temp << BPER_MB_NORMBITS;
1555 }
1556 } else {
1557 target_bits_per_mb =
1558 (target_size << BPER_MB_NORMBITS) / cpi->common.MBs;
1559 }
1560 // Rate correction factor based on target_size_per_mb and max_QP.
1561 new_correction_factor =
1562 (double)target_bits_per_mb /
1563 (double)vp8_bits_per_mb[INTER_FRAME][cpi->worst_quality];
1564 if (new_correction_factor > cpi->rate_correction_factor) {
1565 cpi->rate_correction_factor =
1566 VPXMIN(2.0 * cpi->rate_correction_factor, new_correction_factor);
1567 }
1568 if (cpi->rate_correction_factor > MAX_BPB_FACTOR) {
1569 cpi->rate_correction_factor = MAX_BPB_FACTOR;
1570 }
1571 // Drop this frame: update frame counters.
1572 cpi->common.current_video_frame++;
1573 cpi->frames_since_key++;
1574 cpi->temporal_pattern_counter++;
1575 cpi->frames_since_last_drop_overshoot = 0;
1576 if (cpi->oxcf.number_of_layers > 1) {
1577 // Set max_qp and rate correction for all temporal layers if overshoot
1578 // is detected.
1579 for (i = 0; i < cpi->oxcf.number_of_layers; ++i) {
1580 LAYER_CONTEXT *lc = &cpi->layer_context[i];
1581 lc->force_maxqp = 1;
1582 lc->frames_since_last_drop_overshoot = 0;
1583 lc->rate_correction_factor = cpi->rate_correction_factor;
1584 }
1585 }
1586 #if CONFIG_MULTI_RES_ENCODING
1587 if (cpi->oxcf.mr_total_resolutions > 1)
1588 low_res_frame_info->is_frame_dropped_overshoot_maxqp = 1;
1589 #endif
1590 return 1;
1591 }
1592 cpi->force_maxqp = 0;
1593 cpi->frames_since_last_drop_overshoot++;
1594 #if CONFIG_MULTI_RES_ENCODING
1595 if (cpi->oxcf.mr_total_resolutions > 1)
1596 low_res_frame_info->is_frame_dropped_overshoot_maxqp = 0;
1597 #endif
1598 return 0;
1599 }
1600 cpi->force_maxqp = 0;
1601 cpi->frames_since_last_drop_overshoot++;
1602 #if CONFIG_MULTI_RES_ENCODING
1603 if (cpi->oxcf.mr_total_resolutions > 1)
1604 low_res_frame_info->is_frame_dropped_overshoot_maxqp = 0;
1605 #endif
1606 return 0;
1607 }
1608