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