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