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