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