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 <math.h>
12 #include <limits.h>
13 #include <stdio.h>
14
15 #include "./vpx_dsp_rtcd.h"
16 #include "./vpx_scale_rtcd.h"
17 #include "block.h"
18 #include "onyx_int.h"
19 #include "vpx_dsp/variance.h"
20 #include "encodeintra.h"
21 #include "vp8/common/common.h"
22 #include "vp8/common/setupintrarecon.h"
23 #include "vp8/common/systemdependent.h"
24 #include "mcomp.h"
25 #include "firstpass.h"
26 #include "vpx_scale/vpx_scale.h"
27 #include "encodemb.h"
28 #include "vp8/common/extend.h"
29 #include "vpx_ports/system_state.h"
30 #include "vpx_mem/vpx_mem.h"
31 #include "vp8/common/swapyv12buffer.h"
32 #include "rdopt.h"
33 #include "vp8/common/quant_common.h"
34 #include "encodemv.h"
35 #include "encodeframe.h"
36
37 #define OUTPUT_FPF 0
38
39 extern void vp8cx_frame_init_quantizer(VP8_COMP *cpi);
40
41 #define GFQ_ADJUSTMENT vp8_gf_boost_qadjustment[Q]
42 extern int vp8_kf_boost_qadjustment[QINDEX_RANGE];
43
44 extern const int vp8_gf_boost_qadjustment[QINDEX_RANGE];
45
46 #define IIFACTOR 1.5
47 #define IIKFACTOR1 1.40
48 #define IIKFACTOR2 1.5
49 #define RMAX 14.0
50 #define GF_RMAX 48.0
51
52 #define KF_MB_INTRA_MIN 300
53 #define GF_MB_INTRA_MIN 200
54
55 #define DOUBLE_DIVIDE_CHECK(X) ((X) < 0 ? (X)-.000001 : (X) + .000001)
56
57 #define POW1 (double)cpi->oxcf.two_pass_vbrbias / 100.0
58 #define POW2 (double)cpi->oxcf.two_pass_vbrbias / 100.0
59
60 #define NEW_BOOST 1
61
62 static int vscale_lookup[7] = { 0, 1, 1, 2, 2, 3, 3 };
63 static int hscale_lookup[7] = { 0, 0, 1, 1, 2, 2, 3 };
64
65 static const int cq_level[QINDEX_RANGE] = {
66 0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 6, 6, 7, 8, 8, 9, 9, 10, 11,
67 11, 12, 13, 13, 14, 15, 15, 16, 17, 17, 18, 19, 20, 20, 21, 22, 22, 23, 24,
68 24, 25, 26, 27, 27, 28, 29, 30, 30, 31, 32, 33, 33, 34, 35, 36, 36, 37, 38,
69 39, 39, 40, 41, 42, 42, 43, 44, 45, 46, 46, 47, 48, 49, 50, 50, 51, 52, 53,
70 54, 55, 55, 56, 57, 58, 59, 60, 60, 61, 62, 63, 64, 65, 66, 67, 67, 68, 69,
71 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 86,
72 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100
73 };
74
75 static void find_next_key_frame(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame);
76
77 /* Resets the first pass file to the given position using a relative seek
78 * from the current position
79 */
reset_fpf_position(VP8_COMP * cpi,FIRSTPASS_STATS * Position)80 static void reset_fpf_position(VP8_COMP *cpi, FIRSTPASS_STATS *Position) {
81 cpi->twopass.stats_in = Position;
82 }
83
lookup_next_frame_stats(VP8_COMP * cpi,FIRSTPASS_STATS * next_frame)84 static int lookup_next_frame_stats(VP8_COMP *cpi, FIRSTPASS_STATS *next_frame) {
85 if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end) return EOF;
86
87 *next_frame = *cpi->twopass.stats_in;
88 return 1;
89 }
90
91 /* Read frame stats at an offset from the current position */
read_frame_stats(VP8_COMP * cpi,FIRSTPASS_STATS * frame_stats,int offset)92 static int read_frame_stats(VP8_COMP *cpi, FIRSTPASS_STATS *frame_stats,
93 int offset) {
94 FIRSTPASS_STATS *fps_ptr = cpi->twopass.stats_in;
95
96 /* Check legality of offset */
97 if (offset >= 0) {
98 if (&fps_ptr[offset] >= cpi->twopass.stats_in_end) return EOF;
99 } else if (offset < 0) {
100 if (&fps_ptr[offset] < cpi->twopass.stats_in_start) return EOF;
101 }
102
103 *frame_stats = fps_ptr[offset];
104 return 1;
105 }
106
input_stats(VP8_COMP * cpi,FIRSTPASS_STATS * fps)107 static int input_stats(VP8_COMP *cpi, FIRSTPASS_STATS *fps) {
108 if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end) return EOF;
109
110 *fps = *cpi->twopass.stats_in;
111 cpi->twopass.stats_in =
112 (void *)((char *)cpi->twopass.stats_in + sizeof(FIRSTPASS_STATS));
113 return 1;
114 }
115
output_stats(const VP8_COMP * cpi,struct vpx_codec_pkt_list * pktlist,FIRSTPASS_STATS * stats)116 static void output_stats(const VP8_COMP *cpi,
117 struct vpx_codec_pkt_list *pktlist,
118 FIRSTPASS_STATS *stats) {
119 struct vpx_codec_cx_pkt pkt;
120 (void)cpi;
121 pkt.kind = VPX_CODEC_STATS_PKT;
122 pkt.data.twopass_stats.buf = stats;
123 pkt.data.twopass_stats.sz = sizeof(FIRSTPASS_STATS);
124 vpx_codec_pkt_list_add(pktlist, &pkt);
125
126 /* TEMP debug code */
127 #if OUTPUT_FPF
128
129 {
130 FILE *fpfile;
131 fpfile = fopen("firstpass.stt", "a");
132
133 fprintf(fpfile,
134 "%12.0f %12.0f %12.0f %12.4f %12.4f %12.4f %12.4f"
135 " %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f"
136 " %12.0f %12.0f %12.4f\n",
137 stats->frame, stats->intra_error, stats->coded_error,
138 stats->ssim_weighted_pred_err, stats->pcnt_inter,
139 stats->pcnt_motion, stats->pcnt_second_ref, stats->pcnt_neutral,
140 stats->MVr, stats->mvr_abs, stats->MVc, stats->mvc_abs, stats->MVrv,
141 stats->MVcv, stats->mv_in_out_count, stats->new_mv_count,
142 stats->count, stats->duration);
143 fclose(fpfile);
144 }
145 #endif
146 }
147
zero_stats(FIRSTPASS_STATS * section)148 static void zero_stats(FIRSTPASS_STATS *section) {
149 section->frame = 0.0;
150 section->intra_error = 0.0;
151 section->coded_error = 0.0;
152 section->ssim_weighted_pred_err = 0.0;
153 section->pcnt_inter = 0.0;
154 section->pcnt_motion = 0.0;
155 section->pcnt_second_ref = 0.0;
156 section->pcnt_neutral = 0.0;
157 section->MVr = 0.0;
158 section->mvr_abs = 0.0;
159 section->MVc = 0.0;
160 section->mvc_abs = 0.0;
161 section->MVrv = 0.0;
162 section->MVcv = 0.0;
163 section->mv_in_out_count = 0.0;
164 section->new_mv_count = 0.0;
165 section->count = 0.0;
166 section->duration = 1.0;
167 }
168
accumulate_stats(FIRSTPASS_STATS * section,FIRSTPASS_STATS * frame)169 static void accumulate_stats(FIRSTPASS_STATS *section, FIRSTPASS_STATS *frame) {
170 section->frame += frame->frame;
171 section->intra_error += frame->intra_error;
172 section->coded_error += frame->coded_error;
173 section->ssim_weighted_pred_err += frame->ssim_weighted_pred_err;
174 section->pcnt_inter += frame->pcnt_inter;
175 section->pcnt_motion += frame->pcnt_motion;
176 section->pcnt_second_ref += frame->pcnt_second_ref;
177 section->pcnt_neutral += frame->pcnt_neutral;
178 section->MVr += frame->MVr;
179 section->mvr_abs += frame->mvr_abs;
180 section->MVc += frame->MVc;
181 section->mvc_abs += frame->mvc_abs;
182 section->MVrv += frame->MVrv;
183 section->MVcv += frame->MVcv;
184 section->mv_in_out_count += frame->mv_in_out_count;
185 section->new_mv_count += frame->new_mv_count;
186 section->count += frame->count;
187 section->duration += frame->duration;
188 }
189
subtract_stats(FIRSTPASS_STATS * section,FIRSTPASS_STATS * frame)190 static void subtract_stats(FIRSTPASS_STATS *section, FIRSTPASS_STATS *frame) {
191 section->frame -= frame->frame;
192 section->intra_error -= frame->intra_error;
193 section->coded_error -= frame->coded_error;
194 section->ssim_weighted_pred_err -= frame->ssim_weighted_pred_err;
195 section->pcnt_inter -= frame->pcnt_inter;
196 section->pcnt_motion -= frame->pcnt_motion;
197 section->pcnt_second_ref -= frame->pcnt_second_ref;
198 section->pcnt_neutral -= frame->pcnt_neutral;
199 section->MVr -= frame->MVr;
200 section->mvr_abs -= frame->mvr_abs;
201 section->MVc -= frame->MVc;
202 section->mvc_abs -= frame->mvc_abs;
203 section->MVrv -= frame->MVrv;
204 section->MVcv -= frame->MVcv;
205 section->mv_in_out_count -= frame->mv_in_out_count;
206 section->new_mv_count -= frame->new_mv_count;
207 section->count -= frame->count;
208 section->duration -= frame->duration;
209 }
210
avg_stats(FIRSTPASS_STATS * section)211 static void avg_stats(FIRSTPASS_STATS *section) {
212 if (section->count < 1.0) return;
213
214 section->intra_error /= section->count;
215 section->coded_error /= section->count;
216 section->ssim_weighted_pred_err /= section->count;
217 section->pcnt_inter /= section->count;
218 section->pcnt_second_ref /= section->count;
219 section->pcnt_neutral /= section->count;
220 section->pcnt_motion /= section->count;
221 section->MVr /= section->count;
222 section->mvr_abs /= section->count;
223 section->MVc /= section->count;
224 section->mvc_abs /= section->count;
225 section->MVrv /= section->count;
226 section->MVcv /= section->count;
227 section->mv_in_out_count /= section->count;
228 section->duration /= section->count;
229 }
230
231 /* Calculate a modified Error used in distributing bits between easier
232 * and harder frames
233 */
calculate_modified_err(VP8_COMP * cpi,FIRSTPASS_STATS * this_frame)234 static double calculate_modified_err(VP8_COMP *cpi,
235 FIRSTPASS_STATS *this_frame) {
236 double av_err = (cpi->twopass.total_stats.ssim_weighted_pred_err /
237 cpi->twopass.total_stats.count);
238 double this_err = this_frame->ssim_weighted_pred_err;
239 double modified_err;
240
241 if (this_err > av_err) {
242 modified_err = av_err * pow((this_err / DOUBLE_DIVIDE_CHECK(av_err)), POW1);
243 } else {
244 modified_err = av_err * pow((this_err / DOUBLE_DIVIDE_CHECK(av_err)), POW2);
245 }
246
247 return modified_err;
248 }
249
250 static const double weight_table[256] = {
251 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
252 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
253 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
254 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
255 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.031250, 0.062500,
256 0.093750, 0.125000, 0.156250, 0.187500, 0.218750, 0.250000, 0.281250,
257 0.312500, 0.343750, 0.375000, 0.406250, 0.437500, 0.468750, 0.500000,
258 0.531250, 0.562500, 0.593750, 0.625000, 0.656250, 0.687500, 0.718750,
259 0.750000, 0.781250, 0.812500, 0.843750, 0.875000, 0.906250, 0.937500,
260 0.968750, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
261 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
262 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
263 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
264 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
265 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
266 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
267 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
268 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
269 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
270 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
271 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
272 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
273 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
274 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
275 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
276 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
277 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
278 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
279 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
280 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
281 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
282 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
283 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
284 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
285 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
286 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
287 1.000000, 1.000000, 1.000000, 1.000000
288 };
289
simple_weight(YV12_BUFFER_CONFIG * source)290 static double simple_weight(YV12_BUFFER_CONFIG *source) {
291 int i, j;
292
293 unsigned char *src = source->y_buffer;
294 double sum_weights = 0.0;
295
296 /* Loop throught the Y plane raw examining levels and creating a weight
297 * for the image
298 */
299 i = source->y_height;
300 do {
301 j = source->y_width;
302 do {
303 sum_weights += weight_table[*src];
304 src++;
305 } while (--j);
306 src -= source->y_width;
307 src += source->y_stride;
308 } while (--i);
309
310 sum_weights /= (source->y_height * source->y_width);
311
312 return sum_weights;
313 }
314
315 /* This function returns the current per frame maximum bitrate target */
frame_max_bits(VP8_COMP * cpi)316 static int frame_max_bits(VP8_COMP *cpi) {
317 /* Max allocation for a single frame based on the max section guidelines
318 * passed in and how many bits are left
319 */
320 int max_bits;
321
322 /* For CBR we need to also consider buffer fullness.
323 * If we are running below the optimal level then we need to gradually
324 * tighten up on max_bits.
325 */
326 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
327 double buffer_fullness_ratio =
328 (double)cpi->buffer_level /
329 DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.optimal_buffer_level);
330
331 /* For CBR base this on the target average bits per frame plus the
332 * maximum sedction rate passed in by the user
333 */
334 max_bits = (int)(cpi->av_per_frame_bandwidth *
335 ((double)cpi->oxcf.two_pass_vbrmax_section / 100.0));
336
337 /* If our buffer is below the optimum level */
338 if (buffer_fullness_ratio < 1.0) {
339 /* The lower of max_bits / 4 or cpi->av_per_frame_bandwidth / 4. */
340 int min_max_bits = ((cpi->av_per_frame_bandwidth >> 2) < (max_bits >> 2))
341 ? cpi->av_per_frame_bandwidth >> 2
342 : max_bits >> 2;
343
344 max_bits = (int)(max_bits * buffer_fullness_ratio);
345
346 /* Lowest value we will set ... which should allow the buffer to
347 * refill.
348 */
349 if (max_bits < min_max_bits) max_bits = min_max_bits;
350 }
351 }
352 /* VBR */
353 else {
354 /* For VBR base this on the bits and frames left plus the
355 * two_pass_vbrmax_section rate passed in by the user
356 */
357 max_bits = (int)(((double)cpi->twopass.bits_left /
358 (cpi->twopass.total_stats.count -
359 (double)cpi->common.current_video_frame)) *
360 ((double)cpi->oxcf.two_pass_vbrmax_section / 100.0));
361 }
362
363 /* Trap case where we are out of bits */
364 if (max_bits < 0) max_bits = 0;
365
366 return max_bits;
367 }
368
vp8_init_first_pass(VP8_COMP * cpi)369 void vp8_init_first_pass(VP8_COMP *cpi) {
370 zero_stats(&cpi->twopass.total_stats);
371 }
372
vp8_end_first_pass(VP8_COMP * cpi)373 void vp8_end_first_pass(VP8_COMP *cpi) {
374 output_stats(cpi, cpi->output_pkt_list, &cpi->twopass.total_stats);
375 }
376
zz_motion_search(VP8_COMP * cpi,MACROBLOCK * x,YV12_BUFFER_CONFIG * raw_buffer,int * raw_motion_err,YV12_BUFFER_CONFIG * recon_buffer,int * best_motion_err,int recon_yoffset)377 static void zz_motion_search(VP8_COMP *cpi, MACROBLOCK *x,
378 YV12_BUFFER_CONFIG *raw_buffer,
379 int *raw_motion_err,
380 YV12_BUFFER_CONFIG *recon_buffer,
381 int *best_motion_err, int recon_yoffset) {
382 MACROBLOCKD *const xd = &x->e_mbd;
383 BLOCK *b = &x->block[0];
384 BLOCKD *d = &x->e_mbd.block[0];
385
386 unsigned char *src_ptr = (*(b->base_src) + b->src);
387 int src_stride = b->src_stride;
388 unsigned char *raw_ptr;
389 int raw_stride = raw_buffer->y_stride;
390 unsigned char *ref_ptr;
391 int ref_stride = x->e_mbd.pre.y_stride;
392 (void)cpi;
393
394 /* Set up pointers for this macro block raw buffer */
395 raw_ptr = (unsigned char *)(raw_buffer->y_buffer + recon_yoffset + d->offset);
396 vpx_mse16x16(src_ptr, src_stride, raw_ptr, raw_stride,
397 (unsigned int *)(raw_motion_err));
398
399 /* Set up pointers for this macro block recon buffer */
400 xd->pre.y_buffer = recon_buffer->y_buffer + recon_yoffset;
401 ref_ptr = (unsigned char *)(xd->pre.y_buffer + d->offset);
402 vpx_mse16x16(src_ptr, src_stride, ref_ptr, ref_stride,
403 (unsigned int *)(best_motion_err));
404 }
405
first_pass_motion_search(VP8_COMP * cpi,MACROBLOCK * x,int_mv * ref_mv,MV * best_mv,YV12_BUFFER_CONFIG * recon_buffer,int * best_motion_err,int recon_yoffset)406 static void first_pass_motion_search(VP8_COMP *cpi, MACROBLOCK *x,
407 int_mv *ref_mv, MV *best_mv,
408 YV12_BUFFER_CONFIG *recon_buffer,
409 int *best_motion_err, int recon_yoffset) {
410 MACROBLOCKD *const xd = &x->e_mbd;
411 BLOCK *b = &x->block[0];
412 BLOCKD *d = &x->e_mbd.block[0];
413 int num00;
414
415 int_mv tmp_mv;
416 int_mv ref_mv_full;
417
418 int tmp_err;
419 int step_param = 3; /* Dont search over full range for first pass */
420 int further_steps = (MAX_MVSEARCH_STEPS - 1) - step_param;
421 int n;
422 vp8_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[BLOCK_16X16];
423 int new_mv_mode_penalty = 256;
424
425 /* override the default variance function to use MSE */
426 v_fn_ptr.vf = vpx_mse16x16;
427
428 /* Set up pointers for this macro block recon buffer */
429 xd->pre.y_buffer = recon_buffer->y_buffer + recon_yoffset;
430
431 /* Initial step/diamond search centred on best mv */
432 tmp_mv.as_int = 0;
433 ref_mv_full.as_mv.col = ref_mv->as_mv.col >> 3;
434 ref_mv_full.as_mv.row = ref_mv->as_mv.row >> 3;
435 tmp_err = cpi->diamond_search_sad(x, b, d, &ref_mv_full, &tmp_mv, step_param,
436 x->sadperbit16, &num00, &v_fn_ptr,
437 x->mvcost, ref_mv);
438 if (tmp_err < INT_MAX - new_mv_mode_penalty) tmp_err += new_mv_mode_penalty;
439
440 if (tmp_err < *best_motion_err) {
441 *best_motion_err = tmp_err;
442 best_mv->row = tmp_mv.as_mv.row;
443 best_mv->col = tmp_mv.as_mv.col;
444 }
445
446 /* Further step/diamond searches as necessary */
447 n = num00;
448 num00 = 0;
449
450 while (n < further_steps) {
451 n++;
452
453 if (num00) {
454 num00--;
455 } else {
456 tmp_err = cpi->diamond_search_sad(x, b, d, &ref_mv_full, &tmp_mv,
457 step_param + n, x->sadperbit16, &num00,
458 &v_fn_ptr, x->mvcost, ref_mv);
459 if (tmp_err < INT_MAX - new_mv_mode_penalty) {
460 tmp_err += new_mv_mode_penalty;
461 }
462
463 if (tmp_err < *best_motion_err) {
464 *best_motion_err = tmp_err;
465 best_mv->row = tmp_mv.as_mv.row;
466 best_mv->col = tmp_mv.as_mv.col;
467 }
468 }
469 }
470 }
471
vp8_first_pass(VP8_COMP * cpi)472 void vp8_first_pass(VP8_COMP *cpi) {
473 int mb_row, mb_col;
474 MACROBLOCK *const x = &cpi->mb;
475 VP8_COMMON *const cm = &cpi->common;
476 MACROBLOCKD *const xd = &x->e_mbd;
477
478 int recon_yoffset, recon_uvoffset;
479 YV12_BUFFER_CONFIG *lst_yv12 = &cm->yv12_fb[cm->lst_fb_idx];
480 YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
481 YV12_BUFFER_CONFIG *gld_yv12 = &cm->yv12_fb[cm->gld_fb_idx];
482 int recon_y_stride = lst_yv12->y_stride;
483 int recon_uv_stride = lst_yv12->uv_stride;
484 int64_t intra_error = 0;
485 int64_t coded_error = 0;
486
487 int sum_mvr = 0, sum_mvc = 0;
488 int sum_mvr_abs = 0, sum_mvc_abs = 0;
489 int sum_mvrs = 0, sum_mvcs = 0;
490 int mvcount = 0;
491 int intercount = 0;
492 int second_ref_count = 0;
493 int intrapenalty = 256;
494 int neutral_count = 0;
495 int new_mv_count = 0;
496 int sum_in_vectors = 0;
497 uint32_t lastmv_as_int = 0;
498
499 int_mv zero_ref_mv;
500
501 zero_ref_mv.as_int = 0;
502
503 vpx_clear_system_state();
504
505 x->src = *cpi->Source;
506 xd->pre = *lst_yv12;
507 xd->dst = *new_yv12;
508
509 x->partition_info = x->pi;
510
511 xd->mode_info_context = cm->mi;
512
513 if (!cm->use_bilinear_mc_filter) {
514 xd->subpixel_predict = vp8_sixtap_predict4x4;
515 xd->subpixel_predict8x4 = vp8_sixtap_predict8x4;
516 xd->subpixel_predict8x8 = vp8_sixtap_predict8x8;
517 xd->subpixel_predict16x16 = vp8_sixtap_predict16x16;
518 } else {
519 xd->subpixel_predict = vp8_bilinear_predict4x4;
520 xd->subpixel_predict8x4 = vp8_bilinear_predict8x4;
521 xd->subpixel_predict8x8 = vp8_bilinear_predict8x8;
522 xd->subpixel_predict16x16 = vp8_bilinear_predict16x16;
523 }
524
525 vp8_build_block_offsets(x);
526
527 /* set up frame new frame for intra coded blocks */
528 vp8_setup_intra_recon(new_yv12);
529 vp8cx_frame_init_quantizer(cpi);
530
531 /* Initialise the MV cost table to the defaults */
532 {
533 int flag[2] = { 1, 1 };
534 vp8_initialize_rd_consts(cpi, x,
535 vp8_dc_quant(cm->base_qindex, cm->y1dc_delta_q));
536 memcpy(cm->fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));
537 vp8_build_component_cost_table(cpi->mb.mvcost,
538 (const MV_CONTEXT *)cm->fc.mvc, flag);
539 }
540
541 /* for each macroblock row in image */
542 for (mb_row = 0; mb_row < cm->mb_rows; ++mb_row) {
543 int_mv best_ref_mv;
544
545 best_ref_mv.as_int = 0;
546
547 /* reset above block coeffs */
548 xd->up_available = (mb_row != 0);
549 recon_yoffset = (mb_row * recon_y_stride * 16);
550 recon_uvoffset = (mb_row * recon_uv_stride * 8);
551
552 /* Set up limit values for motion vectors to prevent them extending
553 * outside the UMV borders
554 */
555 x->mv_row_min = -((mb_row * 16) + (VP8BORDERINPIXELS - 16));
556 x->mv_row_max =
557 ((cm->mb_rows - 1 - mb_row) * 16) + (VP8BORDERINPIXELS - 16);
558
559 /* for each macroblock col in image */
560 for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {
561 int this_error;
562 int gf_motion_error = INT_MAX;
563 int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
564
565 xd->dst.y_buffer = new_yv12->y_buffer + recon_yoffset;
566 xd->dst.u_buffer = new_yv12->u_buffer + recon_uvoffset;
567 xd->dst.v_buffer = new_yv12->v_buffer + recon_uvoffset;
568 xd->left_available = (mb_col != 0);
569
570 /* Copy current mb to a buffer */
571 vp8_copy_mem16x16(x->src.y_buffer, x->src.y_stride, x->thismb, 16);
572
573 /* do intra 16x16 prediction */
574 this_error = vp8_encode_intra(cpi, x, use_dc_pred);
575
576 /* "intrapenalty" below deals with situations where the intra
577 * and inter error scores are very low (eg a plain black frame)
578 * We do not have special cases in first pass for 0,0 and
579 * nearest etc so all inter modes carry an overhead cost
580 * estimate fot the mv. When the error score is very low this
581 * causes us to pick all or lots of INTRA modes and throw lots
582 * of key frames. This penalty adds a cost matching that of a
583 * 0,0 mv to the intra case.
584 */
585 this_error += intrapenalty;
586
587 /* Cumulative intra error total */
588 intra_error += (int64_t)this_error;
589
590 /* Set up limit values for motion vectors to prevent them
591 * extending outside the UMV borders
592 */
593 x->mv_col_min = -((mb_col * 16) + (VP8BORDERINPIXELS - 16));
594 x->mv_col_max =
595 ((cm->mb_cols - 1 - mb_col) * 16) + (VP8BORDERINPIXELS - 16);
596
597 /* Other than for the first frame do a motion search */
598 if (cm->current_video_frame > 0) {
599 BLOCKD *d = &x->e_mbd.block[0];
600 MV tmp_mv = { 0, 0 };
601 int tmp_err;
602 int motion_error = INT_MAX;
603 int raw_motion_error = INT_MAX;
604
605 /* Simple 0,0 motion with no mv overhead */
606 zz_motion_search(cpi, x, cpi->last_frame_unscaled_source,
607 &raw_motion_error, lst_yv12, &motion_error,
608 recon_yoffset);
609 d->bmi.mv.as_mv.row = 0;
610 d->bmi.mv.as_mv.col = 0;
611
612 if (raw_motion_error < cpi->oxcf.encode_breakout) {
613 goto skip_motion_search;
614 }
615
616 /* Test last reference frame using the previous best mv as the
617 * starting point (best reference) for the search
618 */
619 first_pass_motion_search(cpi, x, &best_ref_mv, &d->bmi.mv.as_mv,
620 lst_yv12, &motion_error, recon_yoffset);
621
622 /* If the current best reference mv is not centred on 0,0
623 * then do a 0,0 based search as well
624 */
625 if (best_ref_mv.as_int) {
626 tmp_err = INT_MAX;
627 first_pass_motion_search(cpi, x, &zero_ref_mv, &tmp_mv, lst_yv12,
628 &tmp_err, recon_yoffset);
629
630 if (tmp_err < motion_error) {
631 motion_error = tmp_err;
632 d->bmi.mv.as_mv.row = tmp_mv.row;
633 d->bmi.mv.as_mv.col = tmp_mv.col;
634 }
635 }
636
637 /* Experimental search in a second reference frame ((0,0)
638 * based only)
639 */
640 if (cm->current_video_frame > 1) {
641 first_pass_motion_search(cpi, x, &zero_ref_mv, &tmp_mv, gld_yv12,
642 &gf_motion_error, recon_yoffset);
643
644 if ((gf_motion_error < motion_error) &&
645 (gf_motion_error < this_error)) {
646 second_ref_count++;
647 }
648
649 /* Reset to last frame as reference buffer */
650 xd->pre.y_buffer = lst_yv12->y_buffer + recon_yoffset;
651 xd->pre.u_buffer = lst_yv12->u_buffer + recon_uvoffset;
652 xd->pre.v_buffer = lst_yv12->v_buffer + recon_uvoffset;
653 }
654
655 skip_motion_search:
656 /* Intra assumed best */
657 best_ref_mv.as_int = 0;
658
659 if (motion_error <= this_error) {
660 /* Keep a count of cases where the inter and intra were
661 * very close and very low. This helps with scene cut
662 * detection for example in cropped clips with black bars
663 * at the sides or top and bottom.
664 */
665 if ((((this_error - intrapenalty) * 9) <= (motion_error * 10)) &&
666 (this_error < (2 * intrapenalty))) {
667 neutral_count++;
668 }
669
670 d->bmi.mv.as_mv.row *= 8;
671 d->bmi.mv.as_mv.col *= 8;
672 this_error = motion_error;
673 vp8_set_mbmode_and_mvs(x, NEWMV, &d->bmi.mv);
674 vp8_encode_inter16x16y(x);
675 sum_mvr += d->bmi.mv.as_mv.row;
676 sum_mvr_abs += abs(d->bmi.mv.as_mv.row);
677 sum_mvc += d->bmi.mv.as_mv.col;
678 sum_mvc_abs += abs(d->bmi.mv.as_mv.col);
679 sum_mvrs += d->bmi.mv.as_mv.row * d->bmi.mv.as_mv.row;
680 sum_mvcs += d->bmi.mv.as_mv.col * d->bmi.mv.as_mv.col;
681 intercount++;
682
683 best_ref_mv.as_int = d->bmi.mv.as_int;
684
685 /* Was the vector non-zero */
686 if (d->bmi.mv.as_int) {
687 mvcount++;
688
689 /* Was it different from the last non zero vector */
690 if (d->bmi.mv.as_int != lastmv_as_int) new_mv_count++;
691 lastmv_as_int = d->bmi.mv.as_int;
692
693 /* Does the Row vector point inwards or outwards */
694 if (mb_row < cm->mb_rows / 2) {
695 if (d->bmi.mv.as_mv.row > 0) {
696 sum_in_vectors--;
697 } else if (d->bmi.mv.as_mv.row < 0) {
698 sum_in_vectors++;
699 }
700 } else if (mb_row > cm->mb_rows / 2) {
701 if (d->bmi.mv.as_mv.row > 0) {
702 sum_in_vectors++;
703 } else if (d->bmi.mv.as_mv.row < 0) {
704 sum_in_vectors--;
705 }
706 }
707
708 /* Does the Row vector point inwards or outwards */
709 if (mb_col < cm->mb_cols / 2) {
710 if (d->bmi.mv.as_mv.col > 0) {
711 sum_in_vectors--;
712 } else if (d->bmi.mv.as_mv.col < 0) {
713 sum_in_vectors++;
714 }
715 } else if (mb_col > cm->mb_cols / 2) {
716 if (d->bmi.mv.as_mv.col > 0) {
717 sum_in_vectors++;
718 } else if (d->bmi.mv.as_mv.col < 0) {
719 sum_in_vectors--;
720 }
721 }
722 }
723 }
724 }
725
726 coded_error += (int64_t)this_error;
727
728 /* adjust to the next column of macroblocks */
729 x->src.y_buffer += 16;
730 x->src.u_buffer += 8;
731 x->src.v_buffer += 8;
732
733 recon_yoffset += 16;
734 recon_uvoffset += 8;
735 }
736
737 /* adjust to the next row of mbs */
738 x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
739 x->src.u_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
740 x->src.v_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
741
742 /* extend the recon for intra prediction */
743 vp8_extend_mb_row(new_yv12, xd->dst.y_buffer + 16, xd->dst.u_buffer + 8,
744 xd->dst.v_buffer + 8);
745 vpx_clear_system_state();
746 }
747
748 vpx_clear_system_state();
749 {
750 double weight = 0.0;
751
752 FIRSTPASS_STATS fps;
753
754 fps.frame = cm->current_video_frame;
755 fps.intra_error = (double)(intra_error >> 8);
756 fps.coded_error = (double)(coded_error >> 8);
757 weight = simple_weight(cpi->Source);
758
759 if (weight < 0.1) weight = 0.1;
760
761 fps.ssim_weighted_pred_err = fps.coded_error * weight;
762
763 fps.pcnt_inter = 0.0;
764 fps.pcnt_motion = 0.0;
765 fps.MVr = 0.0;
766 fps.mvr_abs = 0.0;
767 fps.MVc = 0.0;
768 fps.mvc_abs = 0.0;
769 fps.MVrv = 0.0;
770 fps.MVcv = 0.0;
771 fps.mv_in_out_count = 0.0;
772 fps.new_mv_count = 0.0;
773 fps.count = 1.0;
774
775 fps.pcnt_inter = 1.0 * (double)intercount / cm->MBs;
776 fps.pcnt_second_ref = 1.0 * (double)second_ref_count / cm->MBs;
777 fps.pcnt_neutral = 1.0 * (double)neutral_count / cm->MBs;
778
779 if (mvcount > 0) {
780 fps.MVr = (double)sum_mvr / (double)mvcount;
781 fps.mvr_abs = (double)sum_mvr_abs / (double)mvcount;
782 fps.MVc = (double)sum_mvc / (double)mvcount;
783 fps.mvc_abs = (double)sum_mvc_abs / (double)mvcount;
784 fps.MVrv = ((double)sum_mvrs - (fps.MVr * fps.MVr / (double)mvcount)) /
785 (double)mvcount;
786 fps.MVcv = ((double)sum_mvcs - (fps.MVc * fps.MVc / (double)mvcount)) /
787 (double)mvcount;
788 fps.mv_in_out_count = (double)sum_in_vectors / (double)(mvcount * 2);
789 fps.new_mv_count = new_mv_count;
790
791 fps.pcnt_motion = 1.0 * (double)mvcount / cpi->common.MBs;
792 }
793
794 /* TODO: handle the case when duration is set to 0, or something less
795 * than the full time between subsequent cpi->source_time_stamps
796 */
797 fps.duration = (double)(cpi->source->ts_end - cpi->source->ts_start);
798
799 /* don't want to do output stats with a stack variable! */
800 memcpy(&cpi->twopass.this_frame_stats, &fps, sizeof(FIRSTPASS_STATS));
801 output_stats(cpi, cpi->output_pkt_list, &cpi->twopass.this_frame_stats);
802 accumulate_stats(&cpi->twopass.total_stats, &fps);
803 }
804
805 /* Copy the previous Last Frame into the GF buffer if specific
806 * conditions for doing so are met
807 */
808 if ((cm->current_video_frame > 0) &&
809 (cpi->twopass.this_frame_stats.pcnt_inter > 0.20) &&
810 ((cpi->twopass.this_frame_stats.intra_error /
811 DOUBLE_DIVIDE_CHECK(cpi->twopass.this_frame_stats.coded_error)) >
812 2.0)) {
813 vp8_yv12_copy_frame(lst_yv12, gld_yv12);
814 }
815
816 /* swap frame pointers so last frame refers to the frame we just
817 * compressed
818 */
819 vp8_swap_yv12_buffer(lst_yv12, new_yv12);
820 vp8_yv12_extend_frame_borders(lst_yv12);
821
822 /* Special case for the first frame. Copy into the GF buffer as a
823 * second reference.
824 */
825 if (cm->current_video_frame == 0) {
826 vp8_yv12_copy_frame(lst_yv12, gld_yv12);
827 }
828
829 /* use this to see what the first pass reconstruction looks like */
830 if (0) {
831 char filename[512];
832 FILE *recon_file;
833 sprintf(filename, "enc%04d.yuv", (int)cm->current_video_frame);
834
835 if (cm->current_video_frame == 0) {
836 recon_file = fopen(filename, "wb");
837 } else {
838 recon_file = fopen(filename, "ab");
839 }
840
841 (void)fwrite(lst_yv12->buffer_alloc, lst_yv12->frame_size, 1, recon_file);
842 fclose(recon_file);
843 }
844
845 cm->current_video_frame++;
846 }
847 extern const int vp8_bits_per_mb[2][QINDEX_RANGE];
848
849 /* Estimate a cost per mb attributable to overheads such as the coding of
850 * modes and motion vectors.
851 * Currently simplistic in its assumptions for testing.
852 */
853
bitcost(double prob)854 static double bitcost(double prob) {
855 if (prob > 0.000122) {
856 return -log(prob) / log(2.0);
857 } else {
858 return 13.0;
859 }
860 }
estimate_modemvcost(VP8_COMP * cpi,FIRSTPASS_STATS * fpstats)861 static int64_t estimate_modemvcost(VP8_COMP *cpi, FIRSTPASS_STATS *fpstats) {
862 int mv_cost;
863 int64_t mode_cost;
864
865 double av_pct_inter = fpstats->pcnt_inter / fpstats->count;
866 double av_pct_motion = fpstats->pcnt_motion / fpstats->count;
867 double av_intra = (1.0 - av_pct_inter);
868
869 double zz_cost;
870 double motion_cost;
871 double intra_cost;
872
873 zz_cost = bitcost(av_pct_inter - av_pct_motion);
874 motion_cost = bitcost(av_pct_motion);
875 intra_cost = bitcost(av_intra);
876
877 /* Estimate of extra bits per mv overhead for mbs
878 * << 9 is the normalization to the (bits * 512) used in vp8_bits_per_mb
879 */
880 mv_cost = ((int)(fpstats->new_mv_count / fpstats->count) * 8) << 9;
881
882 /* Crude estimate of overhead cost from modes
883 * << 9 is the normalization to (bits * 512) used in vp8_bits_per_mb
884 */
885 mode_cost =
886 (int64_t)((((av_pct_inter - av_pct_motion) * zz_cost) +
887 (av_pct_motion * motion_cost) + (av_intra * intra_cost)) *
888 cpi->common.MBs) *
889 512;
890
891 return mv_cost + mode_cost;
892 }
893
calc_correction_factor(double err_per_mb,double err_devisor,double pt_low,double pt_high,int Q)894 static double calc_correction_factor(double err_per_mb, double err_devisor,
895 double pt_low, double pt_high, int Q) {
896 double power_term;
897 double error_term = err_per_mb / err_devisor;
898 double correction_factor;
899
900 /* Adjustment based on Q to power term. */
901 power_term = pt_low + (Q * 0.01);
902 power_term = (power_term > pt_high) ? pt_high : power_term;
903
904 /* Adjustments to error term */
905 /* TBD */
906
907 /* Calculate correction factor */
908 correction_factor = pow(error_term, power_term);
909
910 /* Clip range */
911 correction_factor = (correction_factor < 0.05)
912 ? 0.05
913 : (correction_factor > 5.0) ? 5.0 : correction_factor;
914
915 return correction_factor;
916 }
917
estimate_max_q(VP8_COMP * cpi,FIRSTPASS_STATS * fpstats,int section_target_bandwitdh,int overhead_bits)918 static int estimate_max_q(VP8_COMP *cpi, FIRSTPASS_STATS *fpstats,
919 int section_target_bandwitdh, int overhead_bits) {
920 int Q;
921 int num_mbs = cpi->common.MBs;
922 int target_norm_bits_per_mb;
923
924 double section_err = (fpstats->coded_error / fpstats->count);
925 double err_per_mb = section_err / num_mbs;
926 double err_correction_factor;
927 double speed_correction = 1.0;
928 int overhead_bits_per_mb;
929
930 if (section_target_bandwitdh <= 0) {
931 return cpi->twopass.maxq_max_limit; /* Highest value allowed */
932 }
933
934 target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20))
935 ? (512 * section_target_bandwitdh) / num_mbs
936 : 512 * (section_target_bandwitdh / num_mbs);
937
938 /* Calculate a corrective factor based on a rolling ratio of bits spent
939 * vs target bits
940 */
941 if ((cpi->rolling_target_bits > 0) &&
942 (cpi->active_worst_quality < cpi->worst_quality)) {
943 double rolling_ratio;
944
945 rolling_ratio =
946 (double)cpi->rolling_actual_bits / (double)cpi->rolling_target_bits;
947
948 if (rolling_ratio < 0.95) {
949 cpi->twopass.est_max_qcorrection_factor -= 0.005;
950 } else if (rolling_ratio > 1.05) {
951 cpi->twopass.est_max_qcorrection_factor += 0.005;
952 }
953
954 cpi->twopass.est_max_qcorrection_factor =
955 (cpi->twopass.est_max_qcorrection_factor < 0.1)
956 ? 0.1
957 : (cpi->twopass.est_max_qcorrection_factor > 10.0)
958 ? 10.0
959 : cpi->twopass.est_max_qcorrection_factor;
960 }
961
962 /* Corrections for higher compression speed settings
963 * (reduced compression expected)
964 */
965 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1)) {
966 if (cpi->oxcf.cpu_used <= 5) {
967 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
968 } else {
969 speed_correction = 1.25;
970 }
971 }
972
973 /* Estimate of overhead bits per mb */
974 /* Correction to overhead bits for min allowed Q. */
975 overhead_bits_per_mb = overhead_bits / num_mbs;
976 overhead_bits_per_mb = (int)(overhead_bits_per_mb *
977 pow(0.98, (double)cpi->twopass.maxq_min_limit));
978
979 /* Try and pick a max Q that will be high enough to encode the
980 * content at the given rate.
981 */
982 for (Q = cpi->twopass.maxq_min_limit; Q < cpi->twopass.maxq_max_limit; ++Q) {
983 int bits_per_mb_at_this_q;
984
985 /* Error per MB based correction factor */
986 err_correction_factor =
987 calc_correction_factor(err_per_mb, 150.0, 0.40, 0.90, Q);
988
989 bits_per_mb_at_this_q =
990 vp8_bits_per_mb[INTER_FRAME][Q] + overhead_bits_per_mb;
991
992 bits_per_mb_at_this_q = (int)(.5 +
993 err_correction_factor * speed_correction *
994 cpi->twopass.est_max_qcorrection_factor *
995 cpi->twopass.section_max_qfactor *
996 (double)bits_per_mb_at_this_q);
997
998 /* Mode and motion overhead */
999 /* As Q rises in real encode loop rd code will force overhead down
1000 * We make a crude adjustment for this here as *.98 per Q step.
1001 */
1002 overhead_bits_per_mb = (int)((double)overhead_bits_per_mb * 0.98);
1003
1004 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb) break;
1005 }
1006
1007 /* Restriction on active max q for constrained quality mode. */
1008 if ((cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
1009 (Q < cpi->cq_target_quality)) {
1010 Q = cpi->cq_target_quality;
1011 }
1012
1013 /* Adjust maxq_min_limit and maxq_max_limit limits based on
1014 * average q observed in clip for non kf/gf.arf frames
1015 * Give average a chance to settle though.
1016 */
1017 if ((cpi->ni_frames > ((int)cpi->twopass.total_stats.count >> 8)) &&
1018 (cpi->ni_frames > 150)) {
1019 cpi->twopass.maxq_max_limit = ((cpi->ni_av_qi + 32) < cpi->worst_quality)
1020 ? (cpi->ni_av_qi + 32)
1021 : cpi->worst_quality;
1022 cpi->twopass.maxq_min_limit = ((cpi->ni_av_qi - 32) > cpi->best_quality)
1023 ? (cpi->ni_av_qi - 32)
1024 : cpi->best_quality;
1025 }
1026
1027 return Q;
1028 }
1029
1030 /* For cq mode estimate a cq level that matches the observed
1031 * complexity and data rate.
1032 */
estimate_cq(VP8_COMP * cpi,FIRSTPASS_STATS * fpstats,int section_target_bandwitdh,int overhead_bits)1033 static int estimate_cq(VP8_COMP *cpi, FIRSTPASS_STATS *fpstats,
1034 int section_target_bandwitdh, int overhead_bits) {
1035 int Q;
1036 int num_mbs = cpi->common.MBs;
1037 int target_norm_bits_per_mb;
1038
1039 double section_err = (fpstats->coded_error / fpstats->count);
1040 double err_per_mb = section_err / num_mbs;
1041 double err_correction_factor;
1042 double speed_correction = 1.0;
1043 double clip_iiratio;
1044 double clip_iifactor;
1045 int overhead_bits_per_mb;
1046
1047 if (0) {
1048 FILE *f = fopen("epmp.stt", "a");
1049 fprintf(f, "%10.2f\n", err_per_mb);
1050 fclose(f);
1051 }
1052
1053 target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20))
1054 ? (512 * section_target_bandwitdh) / num_mbs
1055 : 512 * (section_target_bandwitdh / num_mbs);
1056
1057 /* Estimate of overhead bits per mb */
1058 overhead_bits_per_mb = overhead_bits / num_mbs;
1059
1060 /* Corrections for higher compression speed settings
1061 * (reduced compression expected)
1062 */
1063 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1)) {
1064 if (cpi->oxcf.cpu_used <= 5) {
1065 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
1066 } else {
1067 speed_correction = 1.25;
1068 }
1069 }
1070
1071 /* II ratio correction factor for clip as a whole */
1072 clip_iiratio = cpi->twopass.total_stats.intra_error /
1073 DOUBLE_DIVIDE_CHECK(cpi->twopass.total_stats.coded_error);
1074 clip_iifactor = 1.0 - ((clip_iiratio - 10.0) * 0.025);
1075 if (clip_iifactor < 0.80) clip_iifactor = 0.80;
1076
1077 /* Try and pick a Q that can encode the content at the given rate. */
1078 for (Q = 0; Q < MAXQ; ++Q) {
1079 int bits_per_mb_at_this_q;
1080
1081 /* Error per MB based correction factor */
1082 err_correction_factor =
1083 calc_correction_factor(err_per_mb, 100.0, 0.40, 0.90, Q);
1084
1085 bits_per_mb_at_this_q =
1086 vp8_bits_per_mb[INTER_FRAME][Q] + overhead_bits_per_mb;
1087
1088 bits_per_mb_at_this_q =
1089 (int)(.5 +
1090 err_correction_factor * speed_correction * clip_iifactor *
1091 (double)bits_per_mb_at_this_q);
1092
1093 /* Mode and motion overhead */
1094 /* As Q rises in real encode loop rd code will force overhead down
1095 * We make a crude adjustment for this here as *.98 per Q step.
1096 */
1097 overhead_bits_per_mb = (int)((double)overhead_bits_per_mb * 0.98);
1098
1099 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb) break;
1100 }
1101
1102 /* Clip value to range "best allowed to (worst allowed - 1)" */
1103 Q = cq_level[Q];
1104 if (Q >= cpi->worst_quality) Q = cpi->worst_quality - 1;
1105 if (Q < cpi->best_quality) Q = cpi->best_quality;
1106
1107 return Q;
1108 }
1109
estimate_q(VP8_COMP * cpi,double section_err,int section_target_bandwitdh)1110 static int estimate_q(VP8_COMP *cpi, double section_err,
1111 int section_target_bandwitdh) {
1112 int Q;
1113 int num_mbs = cpi->common.MBs;
1114 int target_norm_bits_per_mb;
1115
1116 double err_per_mb = section_err / num_mbs;
1117 double err_correction_factor;
1118 double speed_correction = 1.0;
1119
1120 target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20))
1121 ? (512 * section_target_bandwitdh) / num_mbs
1122 : 512 * (section_target_bandwitdh / num_mbs);
1123
1124 /* Corrections for higher compression speed settings
1125 * (reduced compression expected)
1126 */
1127 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1)) {
1128 if (cpi->oxcf.cpu_used <= 5) {
1129 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
1130 } else {
1131 speed_correction = 1.25;
1132 }
1133 }
1134
1135 /* Try and pick a Q that can encode the content at the given rate. */
1136 for (Q = 0; Q < MAXQ; ++Q) {
1137 int bits_per_mb_at_this_q;
1138
1139 /* Error per MB based correction factor */
1140 err_correction_factor =
1141 calc_correction_factor(err_per_mb, 150.0, 0.40, 0.90, Q);
1142
1143 bits_per_mb_at_this_q =
1144 (int)(.5 + (err_correction_factor * speed_correction *
1145 cpi->twopass.est_max_qcorrection_factor *
1146 (double)vp8_bits_per_mb[INTER_FRAME][Q] / 1.0));
1147
1148 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb) break;
1149 }
1150
1151 return Q;
1152 }
1153
1154 /* Estimate a worst case Q for a KF group */
estimate_kf_group_q(VP8_COMP * cpi,double section_err,int section_target_bandwitdh,double group_iiratio)1155 static int estimate_kf_group_q(VP8_COMP *cpi, double section_err,
1156 int section_target_bandwitdh,
1157 double group_iiratio) {
1158 int Q;
1159 int num_mbs = cpi->common.MBs;
1160 int target_norm_bits_per_mb = (512 * section_target_bandwitdh) / num_mbs;
1161 int bits_per_mb_at_this_q;
1162
1163 double err_per_mb = section_err / num_mbs;
1164 double err_correction_factor;
1165 double speed_correction = 1.0;
1166 double current_spend_ratio = 1.0;
1167
1168 double pow_highq = (POW1 < 0.6) ? POW1 + 0.3 : 0.90;
1169 double pow_lowq = (POW1 < 0.7) ? POW1 + 0.1 : 0.80;
1170
1171 double iiratio_correction_factor = 1.0;
1172
1173 double combined_correction_factor;
1174
1175 /* Trap special case where the target is <= 0 */
1176 if (target_norm_bits_per_mb <= 0) return MAXQ * 2;
1177
1178 /* Calculate a corrective factor based on a rolling ratio of bits spent
1179 * vs target bits
1180 * This is clamped to the range 0.1 to 10.0
1181 */
1182 if (cpi->long_rolling_target_bits <= 0) {
1183 current_spend_ratio = 10.0;
1184 } else {
1185 current_spend_ratio = (double)cpi->long_rolling_actual_bits /
1186 (double)cpi->long_rolling_target_bits;
1187 current_spend_ratio =
1188 (current_spend_ratio > 10.0)
1189 ? 10.0
1190 : (current_spend_ratio < 0.1) ? 0.1 : current_spend_ratio;
1191 }
1192
1193 /* Calculate a correction factor based on the quality of prediction in
1194 * the sequence as indicated by intra_inter error score ratio (IIRatio)
1195 * The idea here is to favour subsampling in the hardest sections vs
1196 * the easyest.
1197 */
1198 iiratio_correction_factor = 1.0 - ((group_iiratio - 6.0) * 0.1);
1199
1200 if (iiratio_correction_factor < 0.5) iiratio_correction_factor = 0.5;
1201
1202 /* Corrections for higher compression speed settings
1203 * (reduced compression expected)
1204 */
1205 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1)) {
1206 if (cpi->oxcf.cpu_used <= 5) {
1207 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
1208 } else {
1209 speed_correction = 1.25;
1210 }
1211 }
1212
1213 /* Combine the various factors calculated above */
1214 combined_correction_factor =
1215 speed_correction * iiratio_correction_factor * current_spend_ratio;
1216
1217 /* Try and pick a Q that should be high enough to encode the content at
1218 * the given rate.
1219 */
1220 for (Q = 0; Q < MAXQ; ++Q) {
1221 /* Error per MB based correction factor */
1222 err_correction_factor =
1223 calc_correction_factor(err_per_mb, 150.0, pow_lowq, pow_highq, Q);
1224
1225 bits_per_mb_at_this_q =
1226 (int)(.5 + (err_correction_factor * combined_correction_factor *
1227 (double)vp8_bits_per_mb[INTER_FRAME][Q]));
1228
1229 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb) break;
1230 }
1231
1232 /* If we could not hit the target even at Max Q then estimate what Q
1233 * would have been required
1234 */
1235 while ((bits_per_mb_at_this_q > target_norm_bits_per_mb) &&
1236 (Q < (MAXQ * 2))) {
1237 bits_per_mb_at_this_q = (int)(0.96 * bits_per_mb_at_this_q);
1238 Q++;
1239 }
1240
1241 if (0) {
1242 FILE *f = fopen("estkf_q.stt", "a");
1243 fprintf(f, "%8d %8d %8d %8.2f %8.3f %8.2f %8.3f %8.3f %8.3f %8d\n",
1244 cpi->common.current_video_frame, bits_per_mb_at_this_q,
1245 target_norm_bits_per_mb, err_per_mb, err_correction_factor,
1246 current_spend_ratio, group_iiratio, iiratio_correction_factor,
1247 (double)cpi->buffer_level / (double)cpi->oxcf.optimal_buffer_level,
1248 Q);
1249 fclose(f);
1250 }
1251
1252 return Q;
1253 }
1254
vp8_init_second_pass(VP8_COMP * cpi)1255 void vp8_init_second_pass(VP8_COMP *cpi) {
1256 FIRSTPASS_STATS this_frame;
1257 FIRSTPASS_STATS *start_pos;
1258
1259 double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth *
1260 cpi->oxcf.two_pass_vbrmin_section / 100);
1261
1262 zero_stats(&cpi->twopass.total_stats);
1263 zero_stats(&cpi->twopass.total_left_stats);
1264
1265 if (!cpi->twopass.stats_in_end) return;
1266
1267 cpi->twopass.total_stats = *cpi->twopass.stats_in_end;
1268 cpi->twopass.total_left_stats = cpi->twopass.total_stats;
1269
1270 /* each frame can have a different duration, as the frame rate in the
1271 * source isn't guaranteed to be constant. The frame rate prior to
1272 * the first frame encoded in the second pass is a guess. However the
1273 * sum duration is not. Its calculated based on the actual durations of
1274 * all frames from the first pass.
1275 */
1276 vp8_new_framerate(cpi, 10000000.0 * cpi->twopass.total_stats.count /
1277 cpi->twopass.total_stats.duration);
1278
1279 cpi->output_framerate = cpi->framerate;
1280 cpi->twopass.bits_left = (int64_t)(cpi->twopass.total_stats.duration *
1281 cpi->oxcf.target_bandwidth / 10000000.0);
1282 cpi->twopass.bits_left -= (int64_t)(cpi->twopass.total_stats.duration *
1283 two_pass_min_rate / 10000000.0);
1284
1285 /* Calculate a minimum intra value to be used in determining the IIratio
1286 * scores used in the second pass. We have this minimum to make sure
1287 * that clips that are static but "low complexity" in the intra domain
1288 * are still boosted appropriately for KF/GF/ARF
1289 */
1290 cpi->twopass.kf_intra_err_min = KF_MB_INTRA_MIN * cpi->common.MBs;
1291 cpi->twopass.gf_intra_err_min = GF_MB_INTRA_MIN * cpi->common.MBs;
1292
1293 /* Scan the first pass file and calculate an average Intra / Inter error
1294 * score ratio for the sequence
1295 */
1296 {
1297 double sum_iiratio = 0.0;
1298 double IIRatio;
1299
1300 start_pos = cpi->twopass.stats_in; /* Note starting "file" position */
1301
1302 while (input_stats(cpi, &this_frame) != EOF) {
1303 IIRatio =
1304 this_frame.intra_error / DOUBLE_DIVIDE_CHECK(this_frame.coded_error);
1305 IIRatio = (IIRatio < 1.0) ? 1.0 : (IIRatio > 20.0) ? 20.0 : IIRatio;
1306 sum_iiratio += IIRatio;
1307 }
1308
1309 cpi->twopass.avg_iiratio =
1310 sum_iiratio /
1311 DOUBLE_DIVIDE_CHECK((double)cpi->twopass.total_stats.count);
1312
1313 /* Reset file position */
1314 reset_fpf_position(cpi, start_pos);
1315 }
1316
1317 /* Scan the first pass file and calculate a modified total error based
1318 * upon the bias/power function used to allocate bits
1319 */
1320 {
1321 start_pos = cpi->twopass.stats_in; /* Note starting "file" position */
1322
1323 cpi->twopass.modified_error_total = 0.0;
1324 cpi->twopass.modified_error_used = 0.0;
1325
1326 while (input_stats(cpi, &this_frame) != EOF) {
1327 cpi->twopass.modified_error_total +=
1328 calculate_modified_err(cpi, &this_frame);
1329 }
1330 cpi->twopass.modified_error_left = cpi->twopass.modified_error_total;
1331
1332 reset_fpf_position(cpi, start_pos); /* Reset file position */
1333 }
1334 }
1335
vp8_end_second_pass(VP8_COMP * cpi)1336 void vp8_end_second_pass(VP8_COMP *cpi) { (void)cpi; }
1337
1338 /* This function gives and estimate of how badly we believe the prediction
1339 * quality is decaying from frame to frame.
1340 */
get_prediction_decay_rate(VP8_COMP * cpi,FIRSTPASS_STATS * next_frame)1341 static double get_prediction_decay_rate(VP8_COMP *cpi,
1342 FIRSTPASS_STATS *next_frame) {
1343 double prediction_decay_rate;
1344 double motion_decay;
1345 double motion_pct = next_frame->pcnt_motion;
1346 (void)cpi;
1347
1348 /* Initial basis is the % mbs inter coded */
1349 prediction_decay_rate = next_frame->pcnt_inter;
1350
1351 /* High % motion -> somewhat higher decay rate */
1352 motion_decay = (1.0 - (motion_pct / 20.0));
1353 if (motion_decay < prediction_decay_rate) {
1354 prediction_decay_rate = motion_decay;
1355 }
1356
1357 /* Adjustment to decay rate based on speed of motion */
1358 {
1359 double this_mv_rabs;
1360 double this_mv_cabs;
1361 double distance_factor;
1362
1363 this_mv_rabs = fabs(next_frame->mvr_abs * motion_pct);
1364 this_mv_cabs = fabs(next_frame->mvc_abs * motion_pct);
1365
1366 distance_factor =
1367 sqrt((this_mv_rabs * this_mv_rabs) + (this_mv_cabs * this_mv_cabs)) /
1368 250.0;
1369 distance_factor = ((distance_factor > 1.0) ? 0.0 : (1.0 - distance_factor));
1370 if (distance_factor < prediction_decay_rate) {
1371 prediction_decay_rate = distance_factor;
1372 }
1373 }
1374
1375 return prediction_decay_rate;
1376 }
1377
1378 /* Function to test for a condition where a complex transition is followed
1379 * by a static section. For example in slide shows where there is a fade
1380 * between slides. This is to help with more optimal kf and gf positioning.
1381 */
detect_transition_to_still(VP8_COMP * cpi,int frame_interval,int still_interval,double loop_decay_rate,double decay_accumulator)1382 static int detect_transition_to_still(VP8_COMP *cpi, int frame_interval,
1383 int still_interval,
1384 double loop_decay_rate,
1385 double decay_accumulator) {
1386 int trans_to_still = 0;
1387
1388 /* Break clause to detect very still sections after motion
1389 * For example a static image after a fade or other transition
1390 * instead of a clean scene cut.
1391 */
1392 if ((frame_interval > MIN_GF_INTERVAL) && (loop_decay_rate >= 0.999) &&
1393 (decay_accumulator < 0.9)) {
1394 int j;
1395 FIRSTPASS_STATS *position = cpi->twopass.stats_in;
1396 FIRSTPASS_STATS tmp_next_frame;
1397 double decay_rate;
1398
1399 /* Look ahead a few frames to see if static condition persists... */
1400 for (j = 0; j < still_interval; ++j) {
1401 if (EOF == input_stats(cpi, &tmp_next_frame)) break;
1402
1403 decay_rate = get_prediction_decay_rate(cpi, &tmp_next_frame);
1404 if (decay_rate < 0.999) break;
1405 }
1406 /* Reset file position */
1407 reset_fpf_position(cpi, position);
1408
1409 /* Only if it does do we signal a transition to still */
1410 if (j == still_interval) trans_to_still = 1;
1411 }
1412
1413 return trans_to_still;
1414 }
1415
1416 /* This function detects a flash through the high relative pcnt_second_ref
1417 * score in the frame following a flash frame. The offset passed in should
1418 * reflect this
1419 */
detect_flash(VP8_COMP * cpi,int offset)1420 static int detect_flash(VP8_COMP *cpi, int offset) {
1421 FIRSTPASS_STATS next_frame;
1422
1423 int flash_detected = 0;
1424
1425 /* Read the frame data. */
1426 /* The return is 0 (no flash detected) if not a valid frame */
1427 if (read_frame_stats(cpi, &next_frame, offset) != EOF) {
1428 /* What we are looking for here is a situation where there is a
1429 * brief break in prediction (such as a flash) but subsequent frames
1430 * are reasonably well predicted by an earlier (pre flash) frame.
1431 * The recovery after a flash is indicated by a high pcnt_second_ref
1432 * comapred to pcnt_inter.
1433 */
1434 if ((next_frame.pcnt_second_ref > next_frame.pcnt_inter) &&
1435 (next_frame.pcnt_second_ref >= 0.5)) {
1436 flash_detected = 1;
1437
1438 /*if (1)
1439 {
1440 FILE *f = fopen("flash.stt", "a");
1441 fprintf(f, "%8.0f %6.2f %6.2f\n",
1442 next_frame.frame,
1443 next_frame.pcnt_inter,
1444 next_frame.pcnt_second_ref);
1445 fclose(f);
1446 }*/
1447 }
1448 }
1449
1450 return flash_detected;
1451 }
1452
1453 /* Update the motion related elements to the GF arf boost calculation */
accumulate_frame_motion_stats(VP8_COMP * cpi,FIRSTPASS_STATS * this_frame,double * this_frame_mv_in_out,double * mv_in_out_accumulator,double * abs_mv_in_out_accumulator,double * mv_ratio_accumulator)1454 static void accumulate_frame_motion_stats(VP8_COMP *cpi,
1455 FIRSTPASS_STATS *this_frame,
1456 double *this_frame_mv_in_out,
1457 double *mv_in_out_accumulator,
1458 double *abs_mv_in_out_accumulator,
1459 double *mv_ratio_accumulator) {
1460 double this_frame_mvr_ratio;
1461 double this_frame_mvc_ratio;
1462 double motion_pct;
1463 (void)cpi;
1464
1465 /* Accumulate motion stats. */
1466 motion_pct = this_frame->pcnt_motion;
1467
1468 /* Accumulate Motion In/Out of frame stats */
1469 *this_frame_mv_in_out = this_frame->mv_in_out_count * motion_pct;
1470 *mv_in_out_accumulator += this_frame->mv_in_out_count * motion_pct;
1471 *abs_mv_in_out_accumulator += fabs(this_frame->mv_in_out_count * motion_pct);
1472
1473 /* Accumulate a measure of how uniform (or conversely how random)
1474 * the motion field is. (A ratio of absmv / mv)
1475 */
1476 if (motion_pct > 0.05) {
1477 this_frame_mvr_ratio =
1478 fabs(this_frame->mvr_abs) / DOUBLE_DIVIDE_CHECK(fabs(this_frame->MVr));
1479
1480 this_frame_mvc_ratio =
1481 fabs(this_frame->mvc_abs) / DOUBLE_DIVIDE_CHECK(fabs(this_frame->MVc));
1482
1483 *mv_ratio_accumulator += (this_frame_mvr_ratio < this_frame->mvr_abs)
1484 ? (this_frame_mvr_ratio * motion_pct)
1485 : this_frame->mvr_abs * motion_pct;
1486
1487 *mv_ratio_accumulator += (this_frame_mvc_ratio < this_frame->mvc_abs)
1488 ? (this_frame_mvc_ratio * motion_pct)
1489 : this_frame->mvc_abs * motion_pct;
1490 }
1491 }
1492
1493 /* Calculate a baseline boost number for the current frame. */
calc_frame_boost(VP8_COMP * cpi,FIRSTPASS_STATS * this_frame,double this_frame_mv_in_out)1494 static double calc_frame_boost(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame,
1495 double this_frame_mv_in_out) {
1496 double frame_boost;
1497
1498 /* Underlying boost factor is based on inter intra error ratio */
1499 if (this_frame->intra_error > cpi->twopass.gf_intra_err_min) {
1500 frame_boost = (IIFACTOR * this_frame->intra_error /
1501 DOUBLE_DIVIDE_CHECK(this_frame->coded_error));
1502 } else {
1503 frame_boost = (IIFACTOR * cpi->twopass.gf_intra_err_min /
1504 DOUBLE_DIVIDE_CHECK(this_frame->coded_error));
1505 }
1506
1507 /* Increase boost for frames where new data coming into frame
1508 * (eg zoom out). Slightly reduce boost if there is a net balance
1509 * of motion out of the frame (zoom in).
1510 * The range for this_frame_mv_in_out is -1.0 to +1.0
1511 */
1512 if (this_frame_mv_in_out > 0.0) {
1513 frame_boost += frame_boost * (this_frame_mv_in_out * 2.0);
1514 /* In extreme case boost is halved */
1515 } else {
1516 frame_boost += frame_boost * (this_frame_mv_in_out / 2.0);
1517 }
1518
1519 /* Clip to maximum */
1520 if (frame_boost > GF_RMAX) frame_boost = GF_RMAX;
1521
1522 return frame_boost;
1523 }
1524
1525 #if NEW_BOOST
calc_arf_boost(VP8_COMP * cpi,int offset,int f_frames,int b_frames,int * f_boost,int * b_boost)1526 static int calc_arf_boost(VP8_COMP *cpi, int offset, int f_frames, int b_frames,
1527 int *f_boost, int *b_boost) {
1528 FIRSTPASS_STATS this_frame;
1529
1530 int i;
1531 double boost_score = 0.0;
1532 double mv_ratio_accumulator = 0.0;
1533 double decay_accumulator = 1.0;
1534 double this_frame_mv_in_out = 0.0;
1535 double mv_in_out_accumulator = 0.0;
1536 double abs_mv_in_out_accumulator = 0.0;
1537 double r;
1538 int flash_detected = 0;
1539
1540 /* Search forward from the proposed arf/next gf position */
1541 for (i = 0; i < f_frames; ++i) {
1542 if (read_frame_stats(cpi, &this_frame, (i + offset)) == EOF) break;
1543
1544 /* Update the motion related elements to the boost calculation */
1545 accumulate_frame_motion_stats(
1546 cpi, &this_frame, &this_frame_mv_in_out, &mv_in_out_accumulator,
1547 &abs_mv_in_out_accumulator, &mv_ratio_accumulator);
1548
1549 /* Calculate the baseline boost number for this frame */
1550 r = calc_frame_boost(cpi, &this_frame, this_frame_mv_in_out);
1551
1552 /* We want to discount the the flash frame itself and the recovery
1553 * frame that follows as both will have poor scores.
1554 */
1555 flash_detected =
1556 detect_flash(cpi, (i + offset)) || detect_flash(cpi, (i + offset + 1));
1557
1558 /* Cumulative effect of prediction quality decay */
1559 if (!flash_detected) {
1560 decay_accumulator =
1561 decay_accumulator * get_prediction_decay_rate(cpi, &this_frame);
1562 decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
1563 }
1564 boost_score += (decay_accumulator * r);
1565
1566 /* Break out conditions. */
1567 if ((!flash_detected) &&
1568 ((mv_ratio_accumulator > 100.0) || (abs_mv_in_out_accumulator > 3.0) ||
1569 (mv_in_out_accumulator < -2.0))) {
1570 break;
1571 }
1572 }
1573
1574 *f_boost = (int)(boost_score * 100.0) >> 4;
1575
1576 /* Reset for backward looking loop */
1577 boost_score = 0.0;
1578 mv_ratio_accumulator = 0.0;
1579 decay_accumulator = 1.0;
1580 this_frame_mv_in_out = 0.0;
1581 mv_in_out_accumulator = 0.0;
1582 abs_mv_in_out_accumulator = 0.0;
1583
1584 /* Search forward from the proposed arf/next gf position */
1585 for (i = -1; i >= -b_frames; i--) {
1586 if (read_frame_stats(cpi, &this_frame, (i + offset)) == EOF) break;
1587
1588 /* Update the motion related elements to the boost calculation */
1589 accumulate_frame_motion_stats(
1590 cpi, &this_frame, &this_frame_mv_in_out, &mv_in_out_accumulator,
1591 &abs_mv_in_out_accumulator, &mv_ratio_accumulator);
1592
1593 /* Calculate the baseline boost number for this frame */
1594 r = calc_frame_boost(cpi, &this_frame, this_frame_mv_in_out);
1595
1596 /* We want to discount the the flash frame itself and the recovery
1597 * frame that follows as both will have poor scores.
1598 */
1599 flash_detected =
1600 detect_flash(cpi, (i + offset)) || detect_flash(cpi, (i + offset + 1));
1601
1602 /* Cumulative effect of prediction quality decay */
1603 if (!flash_detected) {
1604 decay_accumulator =
1605 decay_accumulator * get_prediction_decay_rate(cpi, &this_frame);
1606 decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
1607 }
1608
1609 boost_score += (decay_accumulator * r);
1610
1611 /* Break out conditions. */
1612 if ((!flash_detected) &&
1613 ((mv_ratio_accumulator > 100.0) || (abs_mv_in_out_accumulator > 3.0) ||
1614 (mv_in_out_accumulator < -2.0))) {
1615 break;
1616 }
1617 }
1618 *b_boost = (int)(boost_score * 100.0) >> 4;
1619
1620 return (*f_boost + *b_boost);
1621 }
1622 #endif
1623
1624 /* Analyse and define a gf/arf group . */
define_gf_group(VP8_COMP * cpi,FIRSTPASS_STATS * this_frame)1625 static void define_gf_group(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame) {
1626 FIRSTPASS_STATS next_frame;
1627 FIRSTPASS_STATS *start_pos;
1628 int i;
1629 double r;
1630 double boost_score = 0.0;
1631 double old_boost_score = 0.0;
1632 double gf_group_err = 0.0;
1633 double gf_first_frame_err = 0.0;
1634 double mod_frame_err = 0.0;
1635
1636 double mv_ratio_accumulator = 0.0;
1637 double decay_accumulator = 1.0;
1638
1639 double loop_decay_rate = 1.00; /* Starting decay rate */
1640
1641 double this_frame_mv_in_out = 0.0;
1642 double mv_in_out_accumulator = 0.0;
1643 double abs_mv_in_out_accumulator = 0.0;
1644 double mod_err_per_mb_accumulator = 0.0;
1645
1646 int max_bits = frame_max_bits(cpi); /* Max for a single frame */
1647
1648 unsigned int allow_alt_ref =
1649 cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames;
1650
1651 int alt_boost = 0;
1652 int f_boost = 0;
1653 int b_boost = 0;
1654 int flash_detected;
1655
1656 cpi->twopass.gf_group_bits = 0;
1657 cpi->twopass.gf_decay_rate = 0;
1658
1659 vpx_clear_system_state();
1660
1661 start_pos = cpi->twopass.stats_in;
1662
1663 memset(&next_frame, 0, sizeof(next_frame)); /* assure clean */
1664
1665 /* Load stats for the current frame. */
1666 mod_frame_err = calculate_modified_err(cpi, this_frame);
1667
1668 /* Note the error of the frame at the start of the group (this will be
1669 * the GF frame error if we code a normal gf
1670 */
1671 gf_first_frame_err = mod_frame_err;
1672
1673 /* Special treatment if the current frame is a key frame (which is also
1674 * a gf). If it is then its error score (and hence bit allocation) need
1675 * to be subtracted out from the calculation for the GF group
1676 */
1677 if (cpi->common.frame_type == KEY_FRAME) gf_group_err -= gf_first_frame_err;
1678
1679 /* Scan forward to try and work out how many frames the next gf group
1680 * should contain and what level of boost is appropriate for the GF
1681 * or ARF that will be coded with the group
1682 */
1683 i = 0;
1684
1685 while (((i < cpi->twopass.static_scene_max_gf_interval) ||
1686 ((cpi->twopass.frames_to_key - i) < MIN_GF_INTERVAL)) &&
1687 (i < cpi->twopass.frames_to_key)) {
1688 i++;
1689
1690 /* Accumulate error score of frames in this gf group */
1691 mod_frame_err = calculate_modified_err(cpi, this_frame);
1692
1693 gf_group_err += mod_frame_err;
1694
1695 mod_err_per_mb_accumulator +=
1696 mod_frame_err / DOUBLE_DIVIDE_CHECK((double)cpi->common.MBs);
1697
1698 if (EOF == input_stats(cpi, &next_frame)) break;
1699
1700 /* Test for the case where there is a brief flash but the prediction
1701 * quality back to an earlier frame is then restored.
1702 */
1703 flash_detected = detect_flash(cpi, 0);
1704
1705 /* Update the motion related elements to the boost calculation */
1706 accumulate_frame_motion_stats(
1707 cpi, &next_frame, &this_frame_mv_in_out, &mv_in_out_accumulator,
1708 &abs_mv_in_out_accumulator, &mv_ratio_accumulator);
1709
1710 /* Calculate a baseline boost number for this frame */
1711 r = calc_frame_boost(cpi, &next_frame, this_frame_mv_in_out);
1712
1713 /* Cumulative effect of prediction quality decay */
1714 if (!flash_detected) {
1715 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
1716 decay_accumulator = decay_accumulator * loop_decay_rate;
1717 decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
1718 }
1719 boost_score += (decay_accumulator * r);
1720
1721 /* Break clause to detect very still sections after motion
1722 * For example a staic image after a fade or other transition.
1723 */
1724 if (detect_transition_to_still(cpi, i, 5, loop_decay_rate,
1725 decay_accumulator)) {
1726 allow_alt_ref = 0;
1727 boost_score = old_boost_score;
1728 break;
1729 }
1730
1731 /* Break out conditions. */
1732 if (
1733 /* Break at cpi->max_gf_interval unless almost totally static */
1734 (i >= cpi->max_gf_interval && (decay_accumulator < 0.995)) ||
1735 (
1736 /* Dont break out with a very short interval */
1737 (i > MIN_GF_INTERVAL) &&
1738 /* Dont break out very close to a key frame */
1739 ((cpi->twopass.frames_to_key - i) >= MIN_GF_INTERVAL) &&
1740 ((boost_score > 20.0) || (next_frame.pcnt_inter < 0.75)) &&
1741 (!flash_detected) && ((mv_ratio_accumulator > 100.0) ||
1742 (abs_mv_in_out_accumulator > 3.0) ||
1743 (mv_in_out_accumulator < -2.0) ||
1744 ((boost_score - old_boost_score) < 2.0)))) {
1745 boost_score = old_boost_score;
1746 break;
1747 }
1748
1749 memcpy(this_frame, &next_frame, sizeof(*this_frame));
1750
1751 old_boost_score = boost_score;
1752 }
1753
1754 cpi->twopass.gf_decay_rate =
1755 (i > 0) ? (int)(100.0 * (1.0 - decay_accumulator)) / i : 0;
1756
1757 /* When using CBR apply additional buffer related upper limits */
1758 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
1759 double max_boost;
1760
1761 /* For cbr apply buffer related limits */
1762 if (cpi->drop_frames_allowed) {
1763 int64_t df_buffer_level = cpi->oxcf.drop_frames_water_mark *
1764 (cpi->oxcf.optimal_buffer_level / 100);
1765
1766 if (cpi->buffer_level > df_buffer_level) {
1767 max_boost =
1768 ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) /
1769 DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
1770 } else {
1771 max_boost = 0.0;
1772 }
1773 } else if (cpi->buffer_level > 0) {
1774 max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) /
1775 DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
1776 } else {
1777 max_boost = 0.0;
1778 }
1779
1780 if (boost_score > max_boost) boost_score = max_boost;
1781 }
1782
1783 /* Dont allow conventional gf too near the next kf */
1784 if ((cpi->twopass.frames_to_key - i) < MIN_GF_INTERVAL) {
1785 while (i < cpi->twopass.frames_to_key) {
1786 i++;
1787
1788 if (EOF == input_stats(cpi, this_frame)) break;
1789
1790 if (i < cpi->twopass.frames_to_key) {
1791 mod_frame_err = calculate_modified_err(cpi, this_frame);
1792 gf_group_err += mod_frame_err;
1793 }
1794 }
1795 }
1796
1797 cpi->gfu_boost = (int)(boost_score * 100.0) >> 4;
1798
1799 #if NEW_BOOST
1800 /* Alterrnative boost calculation for alt ref */
1801 alt_boost = calc_arf_boost(cpi, 0, (i - 1), (i - 1), &f_boost, &b_boost);
1802 #endif
1803
1804 /* Should we use the alternate refernce frame */
1805 if (allow_alt_ref && (i >= MIN_GF_INTERVAL) &&
1806 /* dont use ARF very near next kf */
1807 (i <= (cpi->twopass.frames_to_key - MIN_GF_INTERVAL)) &&
1808 #if NEW_BOOST
1809 ((next_frame.pcnt_inter > 0.75) || (next_frame.pcnt_second_ref > 0.5)) &&
1810 ((mv_in_out_accumulator / (double)i > -0.2) ||
1811 (mv_in_out_accumulator > -2.0)) &&
1812 (b_boost > 100) && (f_boost > 100))
1813 #else
1814 (next_frame.pcnt_inter > 0.75) &&
1815 ((mv_in_out_accumulator / (double)i > -0.2) ||
1816 (mv_in_out_accumulator > -2.0)) &&
1817 (cpi->gfu_boost > 100) && (cpi->twopass.gf_decay_rate <=
1818 (ARF_DECAY_THRESH + (cpi->gfu_boost / 200))))
1819 #endif
1820 {
1821 int Boost;
1822 int allocation_chunks;
1823 int Q =
1824 (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
1825 int tmp_q;
1826 int arf_frame_bits = 0;
1827 int group_bits;
1828
1829 #if NEW_BOOST
1830 cpi->gfu_boost = alt_boost;
1831 #endif
1832
1833 /* Estimate the bits to be allocated to the group as a whole */
1834 if ((cpi->twopass.kf_group_bits > 0) &&
1835 (cpi->twopass.kf_group_error_left > 0)) {
1836 group_bits =
1837 (int)((double)cpi->twopass.kf_group_bits *
1838 (gf_group_err / (double)cpi->twopass.kf_group_error_left));
1839 } else {
1840 group_bits = 0;
1841 }
1842
1843 /* Boost for arf frame */
1844 #if NEW_BOOST
1845 Boost = (alt_boost * GFQ_ADJUSTMENT) / 100;
1846 #else
1847 Boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100);
1848 #endif
1849 Boost += (i * 50);
1850
1851 /* Set max and minimum boost and hence minimum allocation */
1852 if (Boost > ((cpi->baseline_gf_interval + 1) * 200)) {
1853 Boost = ((cpi->baseline_gf_interval + 1) * 200);
1854 } else if (Boost < 125) {
1855 Boost = 125;
1856 }
1857
1858 allocation_chunks = (i * 100) + Boost;
1859
1860 /* Normalize Altboost and allocations chunck down to prevent overflow */
1861 while (Boost > 1000) {
1862 Boost /= 2;
1863 allocation_chunks /= 2;
1864 }
1865
1866 /* Calculate the number of bits to be spent on the arf based on the
1867 * boost number
1868 */
1869 arf_frame_bits =
1870 (int)((double)Boost * (group_bits / (double)allocation_chunks));
1871
1872 /* Estimate if there are enough bits available to make worthwhile use
1873 * of an arf.
1874 */
1875 tmp_q = estimate_q(cpi, mod_frame_err, (int)arf_frame_bits);
1876
1877 /* Only use an arf if it is likely we will be able to code
1878 * it at a lower Q than the surrounding frames.
1879 */
1880 if (tmp_q < cpi->worst_quality) {
1881 int half_gf_int;
1882 int frames_after_arf;
1883 int frames_bwd = cpi->oxcf.arnr_max_frames - 1;
1884 int frames_fwd = cpi->oxcf.arnr_max_frames - 1;
1885
1886 cpi->source_alt_ref_pending = 1;
1887
1888 /*
1889 * For alt ref frames the error score for the end frame of the
1890 * group (the alt ref frame) should not contribute to the group
1891 * total and hence the number of bit allocated to the group.
1892 * Rather it forms part of the next group (it is the GF at the
1893 * start of the next group)
1894 * gf_group_err -= mod_frame_err;
1895 *
1896 * For alt ref frames alt ref frame is technically part of the
1897 * GF frame for the next group but we always base the error
1898 * calculation and bit allocation on the current group of frames.
1899 *
1900 * Set the interval till the next gf or arf.
1901 * For ARFs this is the number of frames to be coded before the
1902 * future frame that is coded as an ARF.
1903 * The future frame itself is part of the next group
1904 */
1905 cpi->baseline_gf_interval = i;
1906
1907 /*
1908 * Define the arnr filter width for this group of frames:
1909 * We only filter frames that lie within a distance of half
1910 * the GF interval from the ARF frame. We also have to trap
1911 * cases where the filter extends beyond the end of clip.
1912 * Note: this_frame->frame has been updated in the loop
1913 * so it now points at the ARF frame.
1914 */
1915 half_gf_int = cpi->baseline_gf_interval >> 1;
1916 frames_after_arf =
1917 (int)(cpi->twopass.total_stats.count - this_frame->frame - 1);
1918
1919 switch (cpi->oxcf.arnr_type) {
1920 case 1: /* Backward filter */
1921 frames_fwd = 0;
1922 if (frames_bwd > half_gf_int) frames_bwd = half_gf_int;
1923 break;
1924
1925 case 2: /* Forward filter */
1926 if (frames_fwd > half_gf_int) frames_fwd = half_gf_int;
1927 if (frames_fwd > frames_after_arf) frames_fwd = frames_after_arf;
1928 frames_bwd = 0;
1929 break;
1930
1931 case 3: /* Centered filter */
1932 default:
1933 frames_fwd >>= 1;
1934 if (frames_fwd > frames_after_arf) frames_fwd = frames_after_arf;
1935 if (frames_fwd > half_gf_int) frames_fwd = half_gf_int;
1936
1937 frames_bwd = frames_fwd;
1938
1939 /* For even length filter there is one more frame backward
1940 * than forward: e.g. len=6 ==> bbbAff, len=7 ==> bbbAfff.
1941 */
1942 if (frames_bwd < half_gf_int) {
1943 frames_bwd += (cpi->oxcf.arnr_max_frames + 1) & 0x1;
1944 }
1945 break;
1946 }
1947
1948 cpi->active_arnr_frames = frames_bwd + 1 + frames_fwd;
1949 } else {
1950 cpi->source_alt_ref_pending = 0;
1951 cpi->baseline_gf_interval = i;
1952 }
1953 } else {
1954 cpi->source_alt_ref_pending = 0;
1955 cpi->baseline_gf_interval = i;
1956 }
1957
1958 /*
1959 * Now decide how many bits should be allocated to the GF group as a
1960 * proportion of those remaining in the kf group.
1961 * The final key frame group in the clip is treated as a special case
1962 * where cpi->twopass.kf_group_bits is tied to cpi->twopass.bits_left.
1963 * This is also important for short clips where there may only be one
1964 * key frame.
1965 */
1966 if (cpi->twopass.frames_to_key >=
1967 (int)(cpi->twopass.total_stats.count - cpi->common.current_video_frame)) {
1968 cpi->twopass.kf_group_bits =
1969 (cpi->twopass.bits_left > 0) ? cpi->twopass.bits_left : 0;
1970 }
1971
1972 /* Calculate the bits to be allocated to the group as a whole */
1973 if ((cpi->twopass.kf_group_bits > 0) &&
1974 (cpi->twopass.kf_group_error_left > 0)) {
1975 cpi->twopass.gf_group_bits =
1976 (int64_t)(cpi->twopass.kf_group_bits *
1977 (gf_group_err / cpi->twopass.kf_group_error_left));
1978 } else {
1979 cpi->twopass.gf_group_bits = 0;
1980 }
1981
1982 cpi->twopass.gf_group_bits =
1983 (cpi->twopass.gf_group_bits < 0)
1984 ? 0
1985 : (cpi->twopass.gf_group_bits > cpi->twopass.kf_group_bits)
1986 ? cpi->twopass.kf_group_bits
1987 : cpi->twopass.gf_group_bits;
1988
1989 /* Clip cpi->twopass.gf_group_bits based on user supplied data rate
1990 * variability limit (cpi->oxcf.two_pass_vbrmax_section)
1991 */
1992 if (cpi->twopass.gf_group_bits >
1993 (int64_t)max_bits * cpi->baseline_gf_interval) {
1994 cpi->twopass.gf_group_bits = (int64_t)max_bits * cpi->baseline_gf_interval;
1995 }
1996
1997 /* Reset the file position */
1998 reset_fpf_position(cpi, start_pos);
1999
2000 /* Update the record of error used so far (only done once per gf group) */
2001 cpi->twopass.modified_error_used += gf_group_err;
2002
2003 /* Assign bits to the arf or gf. */
2004 for (i = 0; i <= (cpi->source_alt_ref_pending &&
2005 cpi->common.frame_type != KEY_FRAME);
2006 i++) {
2007 int Boost;
2008 int allocation_chunks;
2009 int Q =
2010 (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
2011 int gf_bits;
2012
2013 /* For ARF frames */
2014 if (cpi->source_alt_ref_pending && i == 0) {
2015 #if NEW_BOOST
2016 Boost = (alt_boost * GFQ_ADJUSTMENT) / 100;
2017 #else
2018 Boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100);
2019 #endif
2020 Boost += (cpi->baseline_gf_interval * 50);
2021
2022 /* Set max and minimum boost and hence minimum allocation */
2023 if (Boost > ((cpi->baseline_gf_interval + 1) * 200)) {
2024 Boost = ((cpi->baseline_gf_interval + 1) * 200);
2025 } else if (Boost < 125) {
2026 Boost = 125;
2027 }
2028
2029 allocation_chunks = ((cpi->baseline_gf_interval + 1) * 100) + Boost;
2030 }
2031 /* Else for standard golden frames */
2032 else {
2033 /* boost based on inter / intra ratio of subsequent frames */
2034 Boost = (cpi->gfu_boost * GFQ_ADJUSTMENT) / 100;
2035
2036 /* Set max and minimum boost and hence minimum allocation */
2037 if (Boost > (cpi->baseline_gf_interval * 150)) {
2038 Boost = (cpi->baseline_gf_interval * 150);
2039 } else if (Boost < 125) {
2040 Boost = 125;
2041 }
2042
2043 allocation_chunks = (cpi->baseline_gf_interval * 100) + (Boost - 100);
2044 }
2045
2046 /* Normalize Altboost and allocations chunck down to prevent overflow */
2047 while (Boost > 1000) {
2048 Boost /= 2;
2049 allocation_chunks /= 2;
2050 }
2051
2052 /* Calculate the number of bits to be spent on the gf or arf based on
2053 * the boost number
2054 */
2055 gf_bits = (int)((double)Boost *
2056 (cpi->twopass.gf_group_bits / (double)allocation_chunks));
2057
2058 /* If the frame that is to be boosted is simpler than the average for
2059 * the gf/arf group then use an alternative calculation
2060 * based on the error score of the frame itself
2061 */
2062 if (mod_frame_err < gf_group_err / (double)cpi->baseline_gf_interval) {
2063 double alt_gf_grp_bits;
2064 int alt_gf_bits;
2065
2066 alt_gf_grp_bits =
2067 (double)cpi->twopass.kf_group_bits *
2068 (mod_frame_err * (double)cpi->baseline_gf_interval) /
2069 DOUBLE_DIVIDE_CHECK((double)cpi->twopass.kf_group_error_left);
2070
2071 alt_gf_bits =
2072 (int)((double)Boost * (alt_gf_grp_bits / (double)allocation_chunks));
2073
2074 if (gf_bits > alt_gf_bits) {
2075 gf_bits = alt_gf_bits;
2076 }
2077 }
2078 /* Else if it is harder than other frames in the group make sure it at
2079 * least receives an allocation in keeping with its relative error
2080 * score, otherwise it may be worse off than an "un-boosted" frame
2081 */
2082 else {
2083 int alt_gf_bits =
2084 (int)((double)cpi->twopass.kf_group_bits * mod_frame_err /
2085 DOUBLE_DIVIDE_CHECK((double)cpi->twopass.kf_group_error_left));
2086
2087 if (alt_gf_bits > gf_bits) {
2088 gf_bits = alt_gf_bits;
2089 }
2090 }
2091
2092 /* Apply an additional limit for CBR */
2093 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
2094 if (cpi->twopass.gf_bits > (int)(cpi->buffer_level >> 1)) {
2095 cpi->twopass.gf_bits = (int)(cpi->buffer_level >> 1);
2096 }
2097 }
2098
2099 /* Dont allow a negative value for gf_bits */
2100 if (gf_bits < 0) gf_bits = 0;
2101
2102 /* Add in minimum for a frame */
2103 gf_bits += cpi->min_frame_bandwidth;
2104
2105 if (i == 0) {
2106 cpi->twopass.gf_bits = gf_bits;
2107 }
2108 if (i == 1 || (!cpi->source_alt_ref_pending &&
2109 (cpi->common.frame_type != KEY_FRAME))) {
2110 /* Per frame bit target for this frame */
2111 cpi->per_frame_bandwidth = gf_bits;
2112 }
2113 }
2114
2115 {
2116 /* Adjust KF group bits and error remainin */
2117 cpi->twopass.kf_group_error_left -= (int64_t)gf_group_err;
2118 cpi->twopass.kf_group_bits -= cpi->twopass.gf_group_bits;
2119
2120 if (cpi->twopass.kf_group_bits < 0) cpi->twopass.kf_group_bits = 0;
2121
2122 /* Note the error score left in the remaining frames of the group.
2123 * For normal GFs we want to remove the error score for the first
2124 * frame of the group (except in Key frame case where this has
2125 * already happened)
2126 */
2127 if (!cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME) {
2128 cpi->twopass.gf_group_error_left =
2129 (int)(gf_group_err - gf_first_frame_err);
2130 } else {
2131 cpi->twopass.gf_group_error_left = (int)gf_group_err;
2132 }
2133
2134 cpi->twopass.gf_group_bits -=
2135 cpi->twopass.gf_bits - cpi->min_frame_bandwidth;
2136
2137 if (cpi->twopass.gf_group_bits < 0) cpi->twopass.gf_group_bits = 0;
2138
2139 /* This condition could fail if there are two kfs very close together
2140 * despite (MIN_GF_INTERVAL) and would cause a devide by 0 in the
2141 * calculation of cpi->twopass.alt_extra_bits.
2142 */
2143 if (cpi->baseline_gf_interval >= 3) {
2144 #if NEW_BOOST
2145 int boost = (cpi->source_alt_ref_pending) ? b_boost : cpi->gfu_boost;
2146 #else
2147 int boost = cpi->gfu_boost;
2148 #endif
2149 if (boost >= 150) {
2150 int pct_extra;
2151
2152 pct_extra = (boost - 100) / 50;
2153 pct_extra = (pct_extra > 20) ? 20 : pct_extra;
2154
2155 cpi->twopass.alt_extra_bits =
2156 (int)(cpi->twopass.gf_group_bits * pct_extra) / 100;
2157 cpi->twopass.gf_group_bits -= cpi->twopass.alt_extra_bits;
2158 cpi->twopass.alt_extra_bits /= ((cpi->baseline_gf_interval - 1) >> 1);
2159 } else {
2160 cpi->twopass.alt_extra_bits = 0;
2161 }
2162 } else {
2163 cpi->twopass.alt_extra_bits = 0;
2164 }
2165 }
2166
2167 /* Adjustments based on a measure of complexity of the section */
2168 if (cpi->common.frame_type != KEY_FRAME) {
2169 FIRSTPASS_STATS sectionstats;
2170 double Ratio;
2171
2172 zero_stats(§ionstats);
2173 reset_fpf_position(cpi, start_pos);
2174
2175 for (i = 0; i < cpi->baseline_gf_interval; ++i) {
2176 input_stats(cpi, &next_frame);
2177 accumulate_stats(§ionstats, &next_frame);
2178 }
2179
2180 avg_stats(§ionstats);
2181
2182 cpi->twopass.section_intra_rating =
2183 (unsigned int)(sectionstats.intra_error /
2184 DOUBLE_DIVIDE_CHECK(sectionstats.coded_error));
2185
2186 Ratio = sectionstats.intra_error /
2187 DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
2188 cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025);
2189
2190 if (cpi->twopass.section_max_qfactor < 0.80) {
2191 cpi->twopass.section_max_qfactor = 0.80;
2192 }
2193
2194 reset_fpf_position(cpi, start_pos);
2195 }
2196 }
2197
2198 /* Allocate bits to a normal frame that is neither a gf an arf or a key frame.
2199 */
assign_std_frame_bits(VP8_COMP * cpi,FIRSTPASS_STATS * this_frame)2200 static void assign_std_frame_bits(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame) {
2201 int target_frame_size;
2202
2203 double modified_err;
2204 double err_fraction;
2205
2206 int max_bits = frame_max_bits(cpi); /* Max for a single frame */
2207
2208 /* Calculate modified prediction error used in bit allocation */
2209 modified_err = calculate_modified_err(cpi, this_frame);
2210
2211 /* What portion of the remaining GF group error is used by this frame */
2212 if (cpi->twopass.gf_group_error_left > 0) {
2213 err_fraction = modified_err / cpi->twopass.gf_group_error_left;
2214 } else {
2215 err_fraction = 0.0;
2216 }
2217
2218 /* How many of those bits available for allocation should we give it? */
2219 target_frame_size = (int)((double)cpi->twopass.gf_group_bits * err_fraction);
2220
2221 /* Clip to target size to 0 - max_bits (or cpi->twopass.gf_group_bits)
2222 * at the top end.
2223 */
2224 if (target_frame_size < 0) {
2225 target_frame_size = 0;
2226 } else {
2227 if (target_frame_size > max_bits) target_frame_size = max_bits;
2228
2229 if (target_frame_size > cpi->twopass.gf_group_bits) {
2230 target_frame_size = (int)cpi->twopass.gf_group_bits;
2231 }
2232 }
2233
2234 /* Adjust error and bits remaining */
2235 cpi->twopass.gf_group_error_left -= (int)modified_err;
2236 cpi->twopass.gf_group_bits -= target_frame_size;
2237
2238 if (cpi->twopass.gf_group_bits < 0) cpi->twopass.gf_group_bits = 0;
2239
2240 /* Add in the minimum number of bits that is set aside for every frame. */
2241 target_frame_size += cpi->min_frame_bandwidth;
2242
2243 /* Every other frame gets a few extra bits */
2244 if ((cpi->frames_since_golden & 0x01) &&
2245 (cpi->frames_till_gf_update_due > 0)) {
2246 target_frame_size += cpi->twopass.alt_extra_bits;
2247 }
2248
2249 /* Per frame bit target for this frame */
2250 cpi->per_frame_bandwidth = target_frame_size;
2251 }
2252
vp8_second_pass(VP8_COMP * cpi)2253 void vp8_second_pass(VP8_COMP *cpi) {
2254 int tmp_q;
2255 int frames_left =
2256 (int)(cpi->twopass.total_stats.count - cpi->common.current_video_frame);
2257
2258 FIRSTPASS_STATS this_frame;
2259 FIRSTPASS_STATS this_frame_copy;
2260
2261 double this_frame_intra_error;
2262 double this_frame_coded_error;
2263
2264 int overhead_bits;
2265
2266 vp8_zero(this_frame);
2267
2268 if (!cpi->twopass.stats_in) {
2269 return;
2270 }
2271
2272 vpx_clear_system_state();
2273
2274 if (EOF == input_stats(cpi, &this_frame)) return;
2275
2276 this_frame_intra_error = this_frame.intra_error;
2277 this_frame_coded_error = this_frame.coded_error;
2278
2279 /* keyframe and section processing ! */
2280 if (cpi->twopass.frames_to_key == 0) {
2281 /* Define next KF group and assign bits to it */
2282 memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2283 find_next_key_frame(cpi, &this_frame_copy);
2284
2285 /* Special case: Error error_resilient_mode mode does not make much
2286 * sense for two pass but with its current meaning this code is
2287 * designed to stop outlandish behaviour if someone does set it when
2288 * using two pass. It effectively disables GF groups. This is
2289 * temporary code until we decide what should really happen in this
2290 * case.
2291 */
2292 if (cpi->oxcf.error_resilient_mode) {
2293 cpi->twopass.gf_group_bits = cpi->twopass.kf_group_bits;
2294 cpi->twopass.gf_group_error_left = (int)cpi->twopass.kf_group_error_left;
2295 cpi->baseline_gf_interval = cpi->twopass.frames_to_key;
2296 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
2297 cpi->source_alt_ref_pending = 0;
2298 }
2299 }
2300
2301 /* Is this a GF / ARF (Note that a KF is always also a GF) */
2302 if (cpi->frames_till_gf_update_due == 0) {
2303 /* Define next gf group and assign bits to it */
2304 memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2305 define_gf_group(cpi, &this_frame_copy);
2306
2307 /* If we are going to code an altref frame at the end of the group
2308 * and the current frame is not a key frame.... If the previous
2309 * group used an arf this frame has already benefited from that arf
2310 * boost and it should not be given extra bits If the previous
2311 * group was NOT coded using arf we may want to apply some boost to
2312 * this GF as well
2313 */
2314 if (cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME)) {
2315 /* Assign a standard frames worth of bits from those allocated
2316 * to the GF group
2317 */
2318 int bak = cpi->per_frame_bandwidth;
2319 memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2320 assign_std_frame_bits(cpi, &this_frame_copy);
2321 cpi->per_frame_bandwidth = bak;
2322 }
2323 }
2324
2325 /* Otherwise this is an ordinary frame */
2326 else {
2327 /* Special case: Error error_resilient_mode mode does not make much
2328 * sense for two pass but with its current meaning but this code is
2329 * designed to stop outlandish behaviour if someone does set it
2330 * when using two pass. It effectively disables GF groups. This is
2331 * temporary code till we decide what should really happen in this
2332 * case.
2333 */
2334 if (cpi->oxcf.error_resilient_mode) {
2335 cpi->frames_till_gf_update_due = cpi->twopass.frames_to_key;
2336
2337 if (cpi->common.frame_type != KEY_FRAME) {
2338 /* Assign bits from those allocated to the GF group */
2339 memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2340 assign_std_frame_bits(cpi, &this_frame_copy);
2341 }
2342 } else {
2343 /* Assign bits from those allocated to the GF group */
2344 memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2345 assign_std_frame_bits(cpi, &this_frame_copy);
2346 }
2347 }
2348
2349 /* Keep a globally available copy of this and the next frame's iiratio. */
2350 cpi->twopass.this_iiratio =
2351 (unsigned int)(this_frame_intra_error /
2352 DOUBLE_DIVIDE_CHECK(this_frame_coded_error));
2353 {
2354 FIRSTPASS_STATS next_frame;
2355 if (lookup_next_frame_stats(cpi, &next_frame) != EOF) {
2356 cpi->twopass.next_iiratio =
2357 (unsigned int)(next_frame.intra_error /
2358 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2359 }
2360 }
2361
2362 /* Set nominal per second bandwidth for this frame */
2363 cpi->target_bandwidth =
2364 (int)(cpi->per_frame_bandwidth * cpi->output_framerate);
2365 if (cpi->target_bandwidth < 0) cpi->target_bandwidth = 0;
2366
2367 /* Account for mv, mode and other overheads. */
2368 overhead_bits = (int)estimate_modemvcost(cpi, &cpi->twopass.total_left_stats);
2369
2370 /* Special case code for first frame. */
2371 if (cpi->common.current_video_frame == 0) {
2372 cpi->twopass.est_max_qcorrection_factor = 1.0;
2373
2374 /* Set a cq_level in constrained quality mode. */
2375 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
2376 int est_cq;
2377
2378 est_cq = estimate_cq(cpi, &cpi->twopass.total_left_stats,
2379 (int)(cpi->twopass.bits_left / frames_left),
2380 overhead_bits);
2381
2382 cpi->cq_target_quality = cpi->oxcf.cq_level;
2383 if (est_cq > cpi->cq_target_quality) cpi->cq_target_quality = est_cq;
2384 }
2385
2386 /* guess at maxq needed in 2nd pass */
2387 cpi->twopass.maxq_max_limit = cpi->worst_quality;
2388 cpi->twopass.maxq_min_limit = cpi->best_quality;
2389
2390 tmp_q = estimate_max_q(cpi, &cpi->twopass.total_left_stats,
2391 (int)(cpi->twopass.bits_left / frames_left),
2392 overhead_bits);
2393
2394 /* Limit the maxq value returned subsequently.
2395 * This increases the risk of overspend or underspend if the initial
2396 * estimate for the clip is bad, but helps prevent excessive
2397 * variation in Q, especially near the end of a clip
2398 * where for example a small overspend may cause Q to crash
2399 */
2400 cpi->twopass.maxq_max_limit =
2401 ((tmp_q + 32) < cpi->worst_quality) ? (tmp_q + 32) : cpi->worst_quality;
2402 cpi->twopass.maxq_min_limit =
2403 ((tmp_q - 32) > cpi->best_quality) ? (tmp_q - 32) : cpi->best_quality;
2404
2405 cpi->active_worst_quality = tmp_q;
2406 cpi->ni_av_qi = tmp_q;
2407 }
2408
2409 /* The last few frames of a clip almost always have to few or too many
2410 * bits and for the sake of over exact rate control we dont want to make
2411 * radical adjustments to the allowed quantizer range just to use up a
2412 * few surplus bits or get beneath the target rate.
2413 */
2414 else if ((cpi->common.current_video_frame <
2415 (((unsigned int)cpi->twopass.total_stats.count * 255) >> 8)) &&
2416 ((cpi->common.current_video_frame + cpi->baseline_gf_interval) <
2417 (unsigned int)cpi->twopass.total_stats.count)) {
2418 if (frames_left < 1) frames_left = 1;
2419
2420 tmp_q = estimate_max_q(cpi, &cpi->twopass.total_left_stats,
2421 (int)(cpi->twopass.bits_left / frames_left),
2422 overhead_bits);
2423
2424 /* Move active_worst_quality but in a damped way */
2425 if (tmp_q > cpi->active_worst_quality) {
2426 cpi->active_worst_quality++;
2427 } else if (tmp_q < cpi->active_worst_quality) {
2428 cpi->active_worst_quality--;
2429 }
2430
2431 cpi->active_worst_quality =
2432 ((cpi->active_worst_quality * 3) + tmp_q + 2) / 4;
2433 }
2434
2435 cpi->twopass.frames_to_key--;
2436
2437 /* Update the total stats remaining sturcture */
2438 subtract_stats(&cpi->twopass.total_left_stats, &this_frame);
2439 }
2440
test_candidate_kf(VP8_COMP * cpi,FIRSTPASS_STATS * last_frame,FIRSTPASS_STATS * this_frame,FIRSTPASS_STATS * next_frame)2441 static int test_candidate_kf(VP8_COMP *cpi, FIRSTPASS_STATS *last_frame,
2442 FIRSTPASS_STATS *this_frame,
2443 FIRSTPASS_STATS *next_frame) {
2444 int is_viable_kf = 0;
2445
2446 /* Does the frame satisfy the primary criteria of a key frame
2447 * If so, then examine how well it predicts subsequent frames
2448 */
2449 if ((this_frame->pcnt_second_ref < 0.10) &&
2450 (next_frame->pcnt_second_ref < 0.10) &&
2451 ((this_frame->pcnt_inter < 0.05) ||
2452 (((this_frame->pcnt_inter - this_frame->pcnt_neutral) < .25) &&
2453 ((this_frame->intra_error /
2454 DOUBLE_DIVIDE_CHECK(this_frame->coded_error)) < 2.5) &&
2455 ((fabs(last_frame->coded_error - this_frame->coded_error) /
2456 DOUBLE_DIVIDE_CHECK(this_frame->coded_error) >
2457 .40) ||
2458 (fabs(last_frame->intra_error - this_frame->intra_error) /
2459 DOUBLE_DIVIDE_CHECK(this_frame->intra_error) >
2460 .40) ||
2461 ((next_frame->intra_error /
2462 DOUBLE_DIVIDE_CHECK(next_frame->coded_error)) > 3.5))))) {
2463 int i;
2464 FIRSTPASS_STATS *start_pos;
2465
2466 FIRSTPASS_STATS local_next_frame;
2467
2468 double boost_score = 0.0;
2469 double old_boost_score = 0.0;
2470 double decay_accumulator = 1.0;
2471 double next_iiratio;
2472
2473 memcpy(&local_next_frame, next_frame, sizeof(*next_frame));
2474
2475 /* Note the starting file position so we can reset to it */
2476 start_pos = cpi->twopass.stats_in;
2477
2478 /* Examine how well the key frame predicts subsequent frames */
2479 for (i = 0; i < 16; ++i) {
2480 next_iiratio = (IIKFACTOR1 * local_next_frame.intra_error /
2481 DOUBLE_DIVIDE_CHECK(local_next_frame.coded_error));
2482
2483 if (next_iiratio > RMAX) next_iiratio = RMAX;
2484
2485 /* Cumulative effect of decay in prediction quality */
2486 if (local_next_frame.pcnt_inter > 0.85) {
2487 decay_accumulator = decay_accumulator * local_next_frame.pcnt_inter;
2488 } else {
2489 decay_accumulator =
2490 decay_accumulator * ((0.85 + local_next_frame.pcnt_inter) / 2.0);
2491 }
2492
2493 /* Keep a running total */
2494 boost_score += (decay_accumulator * next_iiratio);
2495
2496 /* Test various breakout clauses */
2497 if ((local_next_frame.pcnt_inter < 0.05) || (next_iiratio < 1.5) ||
2498 (((local_next_frame.pcnt_inter - local_next_frame.pcnt_neutral) <
2499 0.20) &&
2500 (next_iiratio < 3.0)) ||
2501 ((boost_score - old_boost_score) < 0.5) ||
2502 (local_next_frame.intra_error < 200)) {
2503 break;
2504 }
2505
2506 old_boost_score = boost_score;
2507
2508 /* Get the next frame details */
2509 if (EOF == input_stats(cpi, &local_next_frame)) break;
2510 }
2511
2512 /* If there is tolerable prediction for at least the next 3 frames
2513 * then break out else discard this pottential key frame and move on
2514 */
2515 if (boost_score > 5.0 && (i > 3)) {
2516 is_viable_kf = 1;
2517 } else {
2518 /* Reset the file position */
2519 reset_fpf_position(cpi, start_pos);
2520
2521 is_viable_kf = 0;
2522 }
2523 }
2524
2525 return is_viable_kf;
2526 }
find_next_key_frame(VP8_COMP * cpi,FIRSTPASS_STATS * this_frame)2527 static void find_next_key_frame(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame) {
2528 int i, j;
2529 FIRSTPASS_STATS last_frame;
2530 FIRSTPASS_STATS first_frame;
2531 FIRSTPASS_STATS next_frame;
2532 FIRSTPASS_STATS *start_position;
2533
2534 double decay_accumulator = 1.0;
2535 double boost_score = 0;
2536 double old_boost_score = 0.0;
2537 double loop_decay_rate;
2538
2539 double kf_mod_err = 0.0;
2540 double kf_group_err = 0.0;
2541 double kf_group_intra_err = 0.0;
2542 double kf_group_coded_err = 0.0;
2543 double recent_loop_decay[8] = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
2544
2545 memset(&next_frame, 0, sizeof(next_frame));
2546
2547 vpx_clear_system_state();
2548 start_position = cpi->twopass.stats_in;
2549
2550 cpi->common.frame_type = KEY_FRAME;
2551
2552 /* is this a forced key frame by interval */
2553 cpi->this_key_frame_forced = cpi->next_key_frame_forced;
2554
2555 /* Clear the alt ref active flag as this can never be active on a key
2556 * frame
2557 */
2558 cpi->source_alt_ref_active = 0;
2559
2560 /* Kf is always a gf so clear frames till next gf counter */
2561 cpi->frames_till_gf_update_due = 0;
2562
2563 cpi->twopass.frames_to_key = 1;
2564
2565 /* Take a copy of the initial frame details */
2566 memcpy(&first_frame, this_frame, sizeof(*this_frame));
2567
2568 cpi->twopass.kf_group_bits = 0;
2569 cpi->twopass.kf_group_error_left = 0;
2570
2571 kf_mod_err = calculate_modified_err(cpi, this_frame);
2572
2573 /* find the next keyframe */
2574 i = 0;
2575 while (cpi->twopass.stats_in < cpi->twopass.stats_in_end) {
2576 /* Accumulate kf group error */
2577 kf_group_err += calculate_modified_err(cpi, this_frame);
2578
2579 /* These figures keep intra and coded error counts for all frames
2580 * including key frames in the group. The effect of the key frame
2581 * itself can be subtracted out using the first_frame data
2582 * collected above
2583 */
2584 kf_group_intra_err += this_frame->intra_error;
2585 kf_group_coded_err += this_frame->coded_error;
2586
2587 /* Load the next frame's stats. */
2588 memcpy(&last_frame, this_frame, sizeof(*this_frame));
2589 input_stats(cpi, this_frame);
2590
2591 /* Provided that we are not at the end of the file... */
2592 if (cpi->oxcf.auto_key &&
2593 lookup_next_frame_stats(cpi, &next_frame) != EOF) {
2594 /* Normal scene cut check */
2595 if ((i >= MIN_GF_INTERVAL) &&
2596 test_candidate_kf(cpi, &last_frame, this_frame, &next_frame)) {
2597 break;
2598 }
2599
2600 /* How fast is prediction quality decaying */
2601 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
2602
2603 /* We want to know something about the recent past... rather than
2604 * as used elsewhere where we are concened with decay in prediction
2605 * quality since the last GF or KF.
2606 */
2607 recent_loop_decay[i % 8] = loop_decay_rate;
2608 decay_accumulator = 1.0;
2609 for (j = 0; j < 8; ++j) {
2610 decay_accumulator = decay_accumulator * recent_loop_decay[j];
2611 }
2612
2613 /* Special check for transition or high motion followed by a
2614 * static scene.
2615 */
2616 if (detect_transition_to_still(cpi, i,
2617 ((int)(cpi->key_frame_frequency) - (int)i),
2618 loop_decay_rate, decay_accumulator)) {
2619 break;
2620 }
2621
2622 /* Step on to the next frame */
2623 cpi->twopass.frames_to_key++;
2624
2625 /* If we don't have a real key frame within the next two
2626 * forcekeyframeevery intervals then break out of the loop.
2627 */
2628 if (cpi->twopass.frames_to_key >= 2 * (int)cpi->key_frame_frequency) {
2629 break;
2630 }
2631 } else {
2632 cpi->twopass.frames_to_key++;
2633 }
2634
2635 i++;
2636 }
2637
2638 /* If there is a max kf interval set by the user we must obey it.
2639 * We already breakout of the loop above at 2x max.
2640 * This code centers the extra kf if the actual natural
2641 * interval is between 1x and 2x
2642 */
2643 if (cpi->oxcf.auto_key &&
2644 cpi->twopass.frames_to_key > (int)cpi->key_frame_frequency) {
2645 FIRSTPASS_STATS *current_pos = cpi->twopass.stats_in;
2646 FIRSTPASS_STATS tmp_frame;
2647
2648 cpi->twopass.frames_to_key /= 2;
2649
2650 /* Copy first frame details */
2651 memcpy(&tmp_frame, &first_frame, sizeof(first_frame));
2652
2653 /* Reset to the start of the group */
2654 reset_fpf_position(cpi, start_position);
2655
2656 kf_group_err = 0;
2657 kf_group_intra_err = 0;
2658 kf_group_coded_err = 0;
2659
2660 /* Rescan to get the correct error data for the forced kf group */
2661 for (i = 0; i < cpi->twopass.frames_to_key; ++i) {
2662 /* Accumulate kf group errors */
2663 kf_group_err += calculate_modified_err(cpi, &tmp_frame);
2664 kf_group_intra_err += tmp_frame.intra_error;
2665 kf_group_coded_err += tmp_frame.coded_error;
2666
2667 /* Load a the next frame's stats */
2668 input_stats(cpi, &tmp_frame);
2669 }
2670
2671 /* Reset to the start of the group */
2672 reset_fpf_position(cpi, current_pos);
2673
2674 cpi->next_key_frame_forced = 1;
2675 } else {
2676 cpi->next_key_frame_forced = 0;
2677 }
2678
2679 /* Special case for the last frame of the file */
2680 if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end) {
2681 /* Accumulate kf group error */
2682 kf_group_err += calculate_modified_err(cpi, this_frame);
2683
2684 /* These figures keep intra and coded error counts for all frames
2685 * including key frames in the group. The effect of the key frame
2686 * itself can be subtracted out using the first_frame data
2687 * collected above
2688 */
2689 kf_group_intra_err += this_frame->intra_error;
2690 kf_group_coded_err += this_frame->coded_error;
2691 }
2692
2693 /* Calculate the number of bits that should be assigned to the kf group. */
2694 if ((cpi->twopass.bits_left > 0) &&
2695 (cpi->twopass.modified_error_left > 0.0)) {
2696 /* Max for a single normal frame (not key frame) */
2697 int max_bits = frame_max_bits(cpi);
2698
2699 /* Maximum bits for the kf group */
2700 int64_t max_grp_bits;
2701
2702 /* Default allocation based on bits left and relative
2703 * complexity of the section
2704 */
2705 cpi->twopass.kf_group_bits =
2706 (int64_t)(cpi->twopass.bits_left *
2707 (kf_group_err / cpi->twopass.modified_error_left));
2708
2709 /* Clip based on maximum per frame rate defined by the user. */
2710 max_grp_bits = (int64_t)max_bits * (int64_t)cpi->twopass.frames_to_key;
2711 if (cpi->twopass.kf_group_bits > max_grp_bits) {
2712 cpi->twopass.kf_group_bits = max_grp_bits;
2713 }
2714
2715 /* Additional special case for CBR if buffer is getting full. */
2716 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
2717 int64_t opt_buffer_lvl = cpi->oxcf.optimal_buffer_level;
2718 int64_t buffer_lvl = cpi->buffer_level;
2719
2720 /* If the buffer is near or above the optimal and this kf group is
2721 * not being allocated much then increase the allocation a bit.
2722 */
2723 if (buffer_lvl >= opt_buffer_lvl) {
2724 int64_t high_water_mark =
2725 (opt_buffer_lvl + cpi->oxcf.maximum_buffer_size) >> 1;
2726
2727 int64_t av_group_bits;
2728
2729 /* Av bits per frame * number of frames */
2730 av_group_bits = (int64_t)cpi->av_per_frame_bandwidth *
2731 (int64_t)cpi->twopass.frames_to_key;
2732
2733 /* We are at or above the maximum. */
2734 if (cpi->buffer_level >= high_water_mark) {
2735 int64_t min_group_bits;
2736
2737 min_group_bits =
2738 av_group_bits + (int64_t)(buffer_lvl - high_water_mark);
2739
2740 if (cpi->twopass.kf_group_bits < min_group_bits) {
2741 cpi->twopass.kf_group_bits = min_group_bits;
2742 }
2743 }
2744 /* We are above optimal but below the maximum */
2745 else if (cpi->twopass.kf_group_bits < av_group_bits) {
2746 int64_t bits_below_av = av_group_bits - cpi->twopass.kf_group_bits;
2747
2748 cpi->twopass.kf_group_bits += (int64_t)(
2749 (double)bits_below_av * (double)(buffer_lvl - opt_buffer_lvl) /
2750 (double)(high_water_mark - opt_buffer_lvl));
2751 }
2752 }
2753 }
2754 } else {
2755 cpi->twopass.kf_group_bits = 0;
2756 }
2757
2758 /* Reset the first pass file position */
2759 reset_fpf_position(cpi, start_position);
2760
2761 /* determine how big to make this keyframe based on how well the
2762 * subsequent frames use inter blocks
2763 */
2764 decay_accumulator = 1.0;
2765 boost_score = 0.0;
2766
2767 for (i = 0; i < cpi->twopass.frames_to_key; ++i) {
2768 double r;
2769
2770 if (EOF == input_stats(cpi, &next_frame)) break;
2771
2772 if (next_frame.intra_error > cpi->twopass.kf_intra_err_min) {
2773 r = (IIKFACTOR2 * next_frame.intra_error /
2774 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2775 } else {
2776 r = (IIKFACTOR2 * cpi->twopass.kf_intra_err_min /
2777 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2778 }
2779
2780 if (r > RMAX) r = RMAX;
2781
2782 /* How fast is prediction quality decaying */
2783 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
2784
2785 decay_accumulator = decay_accumulator * loop_decay_rate;
2786 decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
2787
2788 boost_score += (decay_accumulator * r);
2789
2790 if ((i > MIN_GF_INTERVAL) && ((boost_score - old_boost_score) < 1.0)) {
2791 break;
2792 }
2793
2794 old_boost_score = boost_score;
2795 }
2796
2797 if (1) {
2798 FIRSTPASS_STATS sectionstats;
2799 double Ratio;
2800
2801 zero_stats(§ionstats);
2802 reset_fpf_position(cpi, start_position);
2803
2804 for (i = 0; i < cpi->twopass.frames_to_key; ++i) {
2805 input_stats(cpi, &next_frame);
2806 accumulate_stats(§ionstats, &next_frame);
2807 }
2808
2809 avg_stats(§ionstats);
2810
2811 cpi->twopass.section_intra_rating =
2812 (unsigned int)(sectionstats.intra_error /
2813 DOUBLE_DIVIDE_CHECK(sectionstats.coded_error));
2814
2815 Ratio = sectionstats.intra_error /
2816 DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
2817 cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025);
2818
2819 if (cpi->twopass.section_max_qfactor < 0.80) {
2820 cpi->twopass.section_max_qfactor = 0.80;
2821 }
2822 }
2823
2824 /* When using CBR apply additional buffer fullness related upper limits */
2825 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
2826 double max_boost;
2827
2828 if (cpi->drop_frames_allowed) {
2829 int df_buffer_level = (int)(cpi->oxcf.drop_frames_water_mark *
2830 (cpi->oxcf.optimal_buffer_level / 100));
2831
2832 if (cpi->buffer_level > df_buffer_level) {
2833 max_boost =
2834 ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) /
2835 DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
2836 } else {
2837 max_boost = 0.0;
2838 }
2839 } else if (cpi->buffer_level > 0) {
2840 max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) /
2841 DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
2842 } else {
2843 max_boost = 0.0;
2844 }
2845
2846 if (boost_score > max_boost) boost_score = max_boost;
2847 }
2848
2849 /* Reset the first pass file position */
2850 reset_fpf_position(cpi, start_position);
2851
2852 /* Work out how many bits to allocate for the key frame itself */
2853 if (1) {
2854 int kf_boost = (int)boost_score;
2855 int allocation_chunks;
2856 int Counter = cpi->twopass.frames_to_key;
2857 int alt_kf_bits;
2858 YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
2859 /* Min boost based on kf interval */
2860 #if 0
2861
2862 while ((kf_boost < 48) && (Counter > 0))
2863 {
2864 Counter -= 2;
2865 kf_boost ++;
2866 }
2867
2868 #endif
2869
2870 if (kf_boost < 48) {
2871 kf_boost += ((Counter + 1) >> 1);
2872
2873 if (kf_boost > 48) kf_boost = 48;
2874 }
2875
2876 /* bigger frame sizes need larger kf boosts, smaller frames smaller
2877 * boosts...
2878 */
2879 if ((lst_yv12->y_width * lst_yv12->y_height) > (320 * 240)) {
2880 kf_boost += 2 * (lst_yv12->y_width * lst_yv12->y_height) / (320 * 240);
2881 } else if ((lst_yv12->y_width * lst_yv12->y_height) < (320 * 240)) {
2882 kf_boost -= 4 * (320 * 240) / (lst_yv12->y_width * lst_yv12->y_height);
2883 }
2884
2885 /* Min KF boost */
2886 kf_boost = (int)((double)kf_boost * 100.0) >> 4; /* Scale 16 to 100 */
2887 if (kf_boost < 250) kf_boost = 250;
2888
2889 /*
2890 * We do three calculations for kf size.
2891 * The first is based on the error score for the whole kf group.
2892 * The second (optionaly) on the key frames own error if this is
2893 * smaller than the average for the group.
2894 * The final one insures that the frame receives at least the
2895 * allocation it would have received based on its own error score vs
2896 * the error score remaining
2897 * Special case if the sequence appears almost totaly static
2898 * as measured by the decay accumulator. In this case we want to
2899 * spend almost all of the bits on the key frame.
2900 * cpi->twopass.frames_to_key-1 because key frame itself is taken
2901 * care of by kf_boost.
2902 */
2903 if (decay_accumulator >= 0.99) {
2904 allocation_chunks = ((cpi->twopass.frames_to_key - 1) * 10) + kf_boost;
2905 } else {
2906 allocation_chunks = ((cpi->twopass.frames_to_key - 1) * 100) + kf_boost;
2907 }
2908
2909 /* Normalize Altboost and allocations chunck down to prevent overflow */
2910 while (kf_boost > 1000) {
2911 kf_boost /= 2;
2912 allocation_chunks /= 2;
2913 }
2914
2915 cpi->twopass.kf_group_bits =
2916 (cpi->twopass.kf_group_bits < 0) ? 0 : cpi->twopass.kf_group_bits;
2917
2918 /* Calculate the number of bits to be spent on the key frame */
2919 cpi->twopass.kf_bits =
2920 (int)((double)kf_boost *
2921 ((double)cpi->twopass.kf_group_bits / (double)allocation_chunks));
2922
2923 /* Apply an additional limit for CBR */
2924 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
2925 if (cpi->twopass.kf_bits > (int)((3 * cpi->buffer_level) >> 2)) {
2926 cpi->twopass.kf_bits = (int)((3 * cpi->buffer_level) >> 2);
2927 }
2928 }
2929
2930 /* If the key frame is actually easier than the average for the
2931 * kf group (which does sometimes happen... eg a blank intro frame)
2932 * Then use an alternate calculation based on the kf error score
2933 * which should give a smaller key frame.
2934 */
2935 if (kf_mod_err < kf_group_err / cpi->twopass.frames_to_key) {
2936 double alt_kf_grp_bits =
2937 ((double)cpi->twopass.bits_left *
2938 (kf_mod_err * (double)cpi->twopass.frames_to_key) /
2939 DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left));
2940
2941 alt_kf_bits = (int)((double)kf_boost *
2942 (alt_kf_grp_bits / (double)allocation_chunks));
2943
2944 if (cpi->twopass.kf_bits > alt_kf_bits) {
2945 cpi->twopass.kf_bits = alt_kf_bits;
2946 }
2947 }
2948 /* Else if it is much harder than other frames in the group make sure
2949 * it at least receives an allocation in keeping with its relative
2950 * error score
2951 */
2952 else {
2953 alt_kf_bits = (int)((double)cpi->twopass.bits_left *
2954 (kf_mod_err / DOUBLE_DIVIDE_CHECK(
2955 cpi->twopass.modified_error_left)));
2956
2957 if (alt_kf_bits > cpi->twopass.kf_bits) {
2958 cpi->twopass.kf_bits = alt_kf_bits;
2959 }
2960 }
2961
2962 cpi->twopass.kf_group_bits -= cpi->twopass.kf_bits;
2963 /* Add in the minimum frame allowance */
2964 cpi->twopass.kf_bits += cpi->min_frame_bandwidth;
2965
2966 /* Peer frame bit target for this frame */
2967 cpi->per_frame_bandwidth = cpi->twopass.kf_bits;
2968
2969 /* Convert to a per second bitrate */
2970 cpi->target_bandwidth = (int)(cpi->twopass.kf_bits * cpi->output_framerate);
2971 }
2972
2973 /* Note the total error score of the kf group minus the key frame itself */
2974 cpi->twopass.kf_group_error_left = (int)(kf_group_err - kf_mod_err);
2975
2976 /* Adjust the count of total modified error left. The count of bits left
2977 * is adjusted elsewhere based on real coded frame sizes
2978 */
2979 cpi->twopass.modified_error_left -= kf_group_err;
2980
2981 if (cpi->oxcf.allow_spatial_resampling) {
2982 int resample_trigger = 0;
2983 int last_kf_resampled = 0;
2984 int kf_q;
2985 int scale_val = 0;
2986 int hr, hs, vr, vs;
2987 int new_width = cpi->oxcf.Width;
2988 int new_height = cpi->oxcf.Height;
2989
2990 int projected_buffer_level;
2991 int tmp_q;
2992
2993 double projected_bits_perframe;
2994 double group_iiratio = (kf_group_intra_err - first_frame.intra_error) /
2995 (kf_group_coded_err - first_frame.coded_error);
2996 double err_per_frame = kf_group_err / cpi->twopass.frames_to_key;
2997 double bits_per_frame;
2998 double av_bits_per_frame;
2999 double effective_size_ratio;
3000
3001 if ((cpi->common.Width != cpi->oxcf.Width) ||
3002 (cpi->common.Height != cpi->oxcf.Height)) {
3003 last_kf_resampled = 1;
3004 }
3005
3006 /* Set back to unscaled by defaults */
3007 cpi->common.horiz_scale = NORMAL;
3008 cpi->common.vert_scale = NORMAL;
3009
3010 /* Calculate Average bits per frame. */
3011 av_bits_per_frame = cpi->oxcf.target_bandwidth /
3012 DOUBLE_DIVIDE_CHECK((double)cpi->framerate);
3013
3014 /* CBR... Use the clip average as the target for deciding resample */
3015 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
3016 bits_per_frame = av_bits_per_frame;
3017 }
3018
3019 /* In VBR we want to avoid downsampling in easy section unless we
3020 * are under extreme pressure So use the larger of target bitrate
3021 * for this section or average bitrate for sequence
3022 */
3023 else {
3024 /* This accounts for how hard the section is... */
3025 bits_per_frame =
3026 (double)(cpi->twopass.kf_group_bits / cpi->twopass.frames_to_key);
3027
3028 /* Dont turn to resampling in easy sections just because they
3029 * have been assigned a small number of bits
3030 */
3031 if (bits_per_frame < av_bits_per_frame) {
3032 bits_per_frame = av_bits_per_frame;
3033 }
3034 }
3035
3036 /* bits_per_frame should comply with our minimum */
3037 if (bits_per_frame < (cpi->oxcf.target_bandwidth *
3038 cpi->oxcf.two_pass_vbrmin_section / 100)) {
3039 bits_per_frame = (cpi->oxcf.target_bandwidth *
3040 cpi->oxcf.two_pass_vbrmin_section / 100);
3041 }
3042
3043 /* Work out if spatial resampling is necessary */
3044 kf_q = estimate_kf_group_q(cpi, err_per_frame, (int)bits_per_frame,
3045 group_iiratio);
3046
3047 /* If we project a required Q higher than the maximum allowed Q then
3048 * make a guess at the actual size of frames in this section
3049 */
3050 projected_bits_perframe = bits_per_frame;
3051 tmp_q = kf_q;
3052
3053 while (tmp_q > cpi->worst_quality) {
3054 projected_bits_perframe *= 1.04;
3055 tmp_q--;
3056 }
3057
3058 /* Guess at buffer level at the end of the section */
3059 projected_buffer_level =
3060 (int)(cpi->buffer_level -
3061 (int)((projected_bits_perframe - av_bits_per_frame) *
3062 cpi->twopass.frames_to_key));
3063
3064 if (0) {
3065 FILE *f = fopen("Subsamle.stt", "a");
3066 fprintf(f, " %8d %8d %8d %8d %12.0f %8d %8d %8d\n",
3067 cpi->common.current_video_frame, kf_q, cpi->common.horiz_scale,
3068 cpi->common.vert_scale, kf_group_err / cpi->twopass.frames_to_key,
3069 (int)(cpi->twopass.kf_group_bits / cpi->twopass.frames_to_key),
3070 new_height, new_width);
3071 fclose(f);
3072 }
3073
3074 /* The trigger for spatial resampling depends on the various
3075 * parameters such as whether we are streaming (CBR) or VBR.
3076 */
3077 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
3078 /* Trigger resample if we are projected to fall below down
3079 * sample level or resampled last time and are projected to
3080 * remain below the up sample level
3081 */
3082 if ((projected_buffer_level < (cpi->oxcf.resample_down_water_mark *
3083 cpi->oxcf.optimal_buffer_level / 100)) ||
3084 (last_kf_resampled &&
3085 (projected_buffer_level < (cpi->oxcf.resample_up_water_mark *
3086 cpi->oxcf.optimal_buffer_level / 100)))) {
3087 resample_trigger = 1;
3088 } else {
3089 resample_trigger = 0;
3090 }
3091 } else {
3092 int64_t clip_bits = (int64_t)(
3093 cpi->twopass.total_stats.count * cpi->oxcf.target_bandwidth /
3094 DOUBLE_DIVIDE_CHECK((double)cpi->framerate));
3095 int64_t over_spend = cpi->oxcf.starting_buffer_level - cpi->buffer_level;
3096
3097 /* If triggered last time the threshold for triggering again is
3098 * reduced:
3099 *
3100 * Projected Q higher than allowed and Overspend > 5% of total
3101 * bits
3102 */
3103 if ((last_kf_resampled && (kf_q > cpi->worst_quality)) ||
3104 ((kf_q > cpi->worst_quality) && (over_spend > clip_bits / 20))) {
3105 resample_trigger = 1;
3106 } else {
3107 resample_trigger = 0;
3108 }
3109 }
3110
3111 if (resample_trigger) {
3112 while ((kf_q >= cpi->worst_quality) && (scale_val < 6)) {
3113 scale_val++;
3114
3115 cpi->common.vert_scale = vscale_lookup[scale_val];
3116 cpi->common.horiz_scale = hscale_lookup[scale_val];
3117
3118 Scale2Ratio(cpi->common.horiz_scale, &hr, &hs);
3119 Scale2Ratio(cpi->common.vert_scale, &vr, &vs);
3120
3121 new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs;
3122 new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs;
3123
3124 /* Reducing the area to 1/4 does not reduce the complexity
3125 * (err_per_frame) to 1/4... effective_sizeratio attempts
3126 * to provide a crude correction for this
3127 */
3128 effective_size_ratio = (double)(new_width * new_height) /
3129 (double)(cpi->oxcf.Width * cpi->oxcf.Height);
3130 effective_size_ratio = (1.0 + (3.0 * effective_size_ratio)) / 4.0;
3131
3132 /* Now try again and see what Q we get with the smaller
3133 * image size
3134 */
3135 kf_q = estimate_kf_group_q(cpi, err_per_frame * effective_size_ratio,
3136 (int)bits_per_frame, group_iiratio);
3137
3138 if (0) {
3139 FILE *f = fopen("Subsamle.stt", "a");
3140 fprintf(
3141 f, "******** %8d %8d %8d %12.0f %8d %8d %8d\n", kf_q,
3142 cpi->common.horiz_scale, cpi->common.vert_scale,
3143 kf_group_err / cpi->twopass.frames_to_key,
3144 (int)(cpi->twopass.kf_group_bits / cpi->twopass.frames_to_key),
3145 new_height, new_width);
3146 fclose(f);
3147 }
3148 }
3149 }
3150
3151 if ((cpi->common.Width != new_width) ||
3152 (cpi->common.Height != new_height)) {
3153 cpi->common.Width = new_width;
3154 cpi->common.Height = new_height;
3155 vp8_alloc_compressor_data(cpi);
3156 }
3157 }
3158 }
3159