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 (void)cpi;
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 (void)cpi;
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 unsigned char *src_ptr = (*(b->base_src) + b->src);
415 int src_stride = b->src_stride;
416 unsigned char *raw_ptr;
417 int raw_stride = raw_buffer->y_stride;
418 unsigned char *ref_ptr;
419 int ref_stride = x->e_mbd.pre.y_stride;
420
421 (void)cpi;
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 (void)cpi;
1413 }
1414
1415 /* This function gives and estimate of how badly we believe the prediction
1416 * quality is decaying from frame to frame.
1417 */
get_prediction_decay_rate(VP8_COMP * cpi,FIRSTPASS_STATS * next_frame)1418 static double get_prediction_decay_rate(VP8_COMP *cpi, FIRSTPASS_STATS *next_frame)
1419 {
1420 double prediction_decay_rate;
1421 double motion_decay;
1422 double motion_pct = next_frame->pcnt_motion;
1423
1424 (void)cpi;
1425 /* Initial basis is the % mbs inter coded */
1426 prediction_decay_rate = next_frame->pcnt_inter;
1427 /* High % motion -> somewhat higher decay rate */
1428 motion_decay = (1.0 - (motion_pct / 20.0));
1429 if (motion_decay < prediction_decay_rate)
1430 prediction_decay_rate = motion_decay;
1431
1432 /* Adjustment to decay rate based on speed of motion */
1433 {
1434 double this_mv_rabs;
1435 double this_mv_cabs;
1436 double distance_factor;
1437
1438 this_mv_rabs = fabs(next_frame->mvr_abs * motion_pct);
1439 this_mv_cabs = fabs(next_frame->mvc_abs * motion_pct);
1440
1441 distance_factor = sqrt((this_mv_rabs * this_mv_rabs) +
1442 (this_mv_cabs * this_mv_cabs)) / 250.0;
1443 distance_factor = ((distance_factor > 1.0)
1444 ? 0.0 : (1.0 - distance_factor));
1445 if (distance_factor < prediction_decay_rate)
1446 prediction_decay_rate = distance_factor;
1447 }
1448
1449 return prediction_decay_rate;
1450 }
1451
1452 /* Function to test for a condition where a complex transition is followed
1453 * by a static section. For example in slide shows where there is a fade
1454 * between slides. This is to help with more optimal kf and gf positioning.
1455 */
detect_transition_to_still(VP8_COMP * cpi,int frame_interval,int still_interval,double loop_decay_rate,double decay_accumulator)1456 static int detect_transition_to_still(
1457 VP8_COMP *cpi,
1458 int frame_interval,
1459 int still_interval,
1460 double loop_decay_rate,
1461 double decay_accumulator )
1462 {
1463 int trans_to_still = 0;
1464
1465 /* Break clause to detect very still sections after motion
1466 * For example a static image after a fade or other transition
1467 * instead of a clean scene cut.
1468 */
1469 if ( (frame_interval > MIN_GF_INTERVAL) &&
1470 (loop_decay_rate >= 0.999) &&
1471 (decay_accumulator < 0.9) )
1472 {
1473 int j;
1474 FIRSTPASS_STATS * position = cpi->twopass.stats_in;
1475 FIRSTPASS_STATS tmp_next_frame;
1476 double decay_rate;
1477
1478 /* Look ahead a few frames to see if static condition persists... */
1479 for ( j = 0; j < still_interval; j++ )
1480 {
1481 if (EOF == input_stats(cpi, &tmp_next_frame))
1482 break;
1483
1484 decay_rate = get_prediction_decay_rate(cpi, &tmp_next_frame);
1485 if ( decay_rate < 0.999 )
1486 break;
1487 }
1488 /* Reset file position */
1489 reset_fpf_position(cpi, position);
1490
1491 /* Only if it does do we signal a transition to still */
1492 if ( j == still_interval )
1493 trans_to_still = 1;
1494 }
1495
1496 return trans_to_still;
1497 }
1498
1499 /* This function detects a flash through the high relative pcnt_second_ref
1500 * score in the frame following a flash frame. The offset passed in should
1501 * reflect this
1502 */
detect_flash(VP8_COMP * cpi,int offset)1503 static int detect_flash( VP8_COMP *cpi, int offset )
1504 {
1505 FIRSTPASS_STATS next_frame;
1506
1507 int flash_detected = 0;
1508
1509 /* Read the frame data. */
1510 /* The return is 0 (no flash detected) if not a valid frame */
1511 if ( read_frame_stats(cpi, &next_frame, offset) != EOF )
1512 {
1513 /* What we are looking for here is a situation where there is a
1514 * brief break in prediction (such as a flash) but subsequent frames
1515 * are reasonably well predicted by an earlier (pre flash) frame.
1516 * The recovery after a flash is indicated by a high pcnt_second_ref
1517 * comapred to pcnt_inter.
1518 */
1519 if ( (next_frame.pcnt_second_ref > next_frame.pcnt_inter) &&
1520 (next_frame.pcnt_second_ref >= 0.5 ) )
1521 {
1522 flash_detected = 1;
1523
1524 /*if (1)
1525 {
1526 FILE *f = fopen("flash.stt", "a");
1527 fprintf(f, "%8.0f %6.2f %6.2f\n",
1528 next_frame.frame,
1529 next_frame.pcnt_inter,
1530 next_frame.pcnt_second_ref);
1531 fclose(f);
1532 }*/
1533 }
1534 }
1535
1536 return flash_detected;
1537 }
1538
1539 /* 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)1540 static void accumulate_frame_motion_stats(
1541 VP8_COMP *cpi,
1542 FIRSTPASS_STATS * this_frame,
1543 double * this_frame_mv_in_out,
1544 double * mv_in_out_accumulator,
1545 double * abs_mv_in_out_accumulator,
1546 double * mv_ratio_accumulator )
1547 {
1548 double this_frame_mvr_ratio;
1549 double this_frame_mvc_ratio;
1550 double motion_pct;
1551
1552 (void)cpi;
1553 /* Accumulate motion stats. */
1554 motion_pct = this_frame->pcnt_motion;
1555
1556 /* Accumulate Motion In/Out of frame stats */
1557 *this_frame_mv_in_out = this_frame->mv_in_out_count * motion_pct;
1558 *mv_in_out_accumulator += this_frame->mv_in_out_count * motion_pct;
1559 *abs_mv_in_out_accumulator +=
1560 fabs(this_frame->mv_in_out_count * motion_pct);
1561
1562 /* Accumulate a measure of how uniform (or conversely how random)
1563 * the motion field is. (A ratio of absmv / mv)
1564 */
1565 if (motion_pct > 0.05)
1566 {
1567 this_frame_mvr_ratio = fabs(this_frame->mvr_abs) /
1568 DOUBLE_DIVIDE_CHECK(fabs(this_frame->MVr));
1569
1570 this_frame_mvc_ratio = fabs(this_frame->mvc_abs) /
1571 DOUBLE_DIVIDE_CHECK(fabs(this_frame->MVc));
1572
1573 *mv_ratio_accumulator +=
1574 (this_frame_mvr_ratio < this_frame->mvr_abs)
1575 ? (this_frame_mvr_ratio * motion_pct)
1576 : this_frame->mvr_abs * motion_pct;
1577
1578 *mv_ratio_accumulator +=
1579 (this_frame_mvc_ratio < this_frame->mvc_abs)
1580 ? (this_frame_mvc_ratio * motion_pct)
1581 : this_frame->mvc_abs * motion_pct;
1582
1583 }
1584 }
1585
1586 /* 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)1587 static double calc_frame_boost(
1588 VP8_COMP *cpi,
1589 FIRSTPASS_STATS * this_frame,
1590 double this_frame_mv_in_out )
1591 {
1592 double frame_boost;
1593
1594 /* Underlying boost factor is based on inter intra error ratio */
1595 if (this_frame->intra_error > cpi->twopass.gf_intra_err_min)
1596 frame_boost = (IIFACTOR * this_frame->intra_error /
1597 DOUBLE_DIVIDE_CHECK(this_frame->coded_error));
1598 else
1599 frame_boost = (IIFACTOR * cpi->twopass.gf_intra_err_min /
1600 DOUBLE_DIVIDE_CHECK(this_frame->coded_error));
1601
1602 /* Increase boost for frames where new data coming into frame
1603 * (eg zoom out). Slightly reduce boost if there is a net balance
1604 * of motion out of the frame (zoom in).
1605 * The range for this_frame_mv_in_out is -1.0 to +1.0
1606 */
1607 if (this_frame_mv_in_out > 0.0)
1608 frame_boost += frame_boost * (this_frame_mv_in_out * 2.0);
1609 /* In extreme case boost is halved */
1610 else
1611 frame_boost += frame_boost * (this_frame_mv_in_out / 2.0);
1612
1613 /* Clip to maximum */
1614 if (frame_boost > GF_RMAX)
1615 frame_boost = GF_RMAX;
1616
1617 return frame_boost;
1618 }
1619
1620 #if NEW_BOOST
calc_arf_boost(VP8_COMP * cpi,int offset,int f_frames,int b_frames,int * f_boost,int * b_boost)1621 static int calc_arf_boost(
1622 VP8_COMP *cpi,
1623 int offset,
1624 int f_frames,
1625 int b_frames,
1626 int *f_boost,
1627 int *b_boost )
1628 {
1629 FIRSTPASS_STATS this_frame;
1630
1631 int i;
1632 double boost_score = 0.0;
1633 double mv_ratio_accumulator = 0.0;
1634 double decay_accumulator = 1.0;
1635 double this_frame_mv_in_out = 0.0;
1636 double mv_in_out_accumulator = 0.0;
1637 double abs_mv_in_out_accumulator = 0.0;
1638 double r;
1639 int flash_detected = 0;
1640
1641 /* Search forward from the proposed arf/next gf position */
1642 for ( i = 0; i < f_frames; i++ )
1643 {
1644 if ( read_frame_stats(cpi, &this_frame, (i+offset)) == EOF )
1645 break;
1646
1647 /* Update the motion related elements to the boost calculation */
1648 accumulate_frame_motion_stats( cpi, &this_frame,
1649 &this_frame_mv_in_out, &mv_in_out_accumulator,
1650 &abs_mv_in_out_accumulator, &mv_ratio_accumulator );
1651
1652 /* Calculate the baseline boost number for this frame */
1653 r = calc_frame_boost( cpi, &this_frame, this_frame_mv_in_out );
1654
1655 /* We want to discount the the flash frame itself and the recovery
1656 * frame that follows as both will have poor scores.
1657 */
1658 flash_detected = detect_flash(cpi, (i+offset)) ||
1659 detect_flash(cpi, (i+offset+1));
1660
1661 /* Cumulative effect of prediction quality decay */
1662 if ( !flash_detected )
1663 {
1664 decay_accumulator =
1665 decay_accumulator *
1666 get_prediction_decay_rate(cpi, &this_frame);
1667 decay_accumulator =
1668 decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
1669 }
1670 boost_score += (decay_accumulator * r);
1671
1672 /* Break out conditions. */
1673 if ( (!flash_detected) &&
1674 ((mv_ratio_accumulator > 100.0) ||
1675 (abs_mv_in_out_accumulator > 3.0) ||
1676 (mv_in_out_accumulator < -2.0) ) )
1677 {
1678 break;
1679 }
1680 }
1681
1682 *f_boost = (int)(boost_score * 100.0) >> 4;
1683
1684 /* Reset for backward looking loop */
1685 boost_score = 0.0;
1686 mv_ratio_accumulator = 0.0;
1687 decay_accumulator = 1.0;
1688 this_frame_mv_in_out = 0.0;
1689 mv_in_out_accumulator = 0.0;
1690 abs_mv_in_out_accumulator = 0.0;
1691
1692 /* Search forward from the proposed arf/next gf position */
1693 for ( i = -1; i >= -b_frames; i-- )
1694 {
1695 if ( read_frame_stats(cpi, &this_frame, (i+offset)) == EOF )
1696 break;
1697
1698 /* Update the motion related elements to the boost calculation */
1699 accumulate_frame_motion_stats( cpi, &this_frame,
1700 &this_frame_mv_in_out, &mv_in_out_accumulator,
1701 &abs_mv_in_out_accumulator, &mv_ratio_accumulator );
1702
1703 /* Calculate the baseline boost number for this frame */
1704 r = calc_frame_boost( cpi, &this_frame, this_frame_mv_in_out );
1705
1706 /* We want to discount the the flash frame itself and the recovery
1707 * frame that follows as both will have poor scores.
1708 */
1709 flash_detected = detect_flash(cpi, (i+offset)) ||
1710 detect_flash(cpi, (i+offset+1));
1711
1712 /* Cumulative effect of prediction quality decay */
1713 if ( !flash_detected )
1714 {
1715 decay_accumulator =
1716 decay_accumulator *
1717 get_prediction_decay_rate(cpi, &this_frame);
1718 decay_accumulator =
1719 decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
1720 }
1721
1722 boost_score += (decay_accumulator * r);
1723
1724 /* Break out conditions. */
1725 if ( (!flash_detected) &&
1726 ((mv_ratio_accumulator > 100.0) ||
1727 (abs_mv_in_out_accumulator > 3.0) ||
1728 (mv_in_out_accumulator < -2.0) ) )
1729 {
1730 break;
1731 }
1732 }
1733 *b_boost = (int)(boost_score * 100.0) >> 4;
1734
1735 return (*f_boost + *b_boost);
1736 }
1737 #endif
1738
1739 /* Analyse and define a gf/arf group . */
define_gf_group(VP8_COMP * cpi,FIRSTPASS_STATS * this_frame)1740 static void define_gf_group(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
1741 {
1742 FIRSTPASS_STATS next_frame;
1743 FIRSTPASS_STATS *start_pos;
1744 int i;
1745 double r;
1746 double boost_score = 0.0;
1747 double old_boost_score = 0.0;
1748 double gf_group_err = 0.0;
1749 double gf_first_frame_err = 0.0;
1750 double mod_frame_err = 0.0;
1751
1752 double mv_ratio_accumulator = 0.0;
1753 double decay_accumulator = 1.0;
1754
1755 double loop_decay_rate = 1.00; /* Starting decay rate */
1756
1757 double this_frame_mv_in_out = 0.0;
1758 double mv_in_out_accumulator = 0.0;
1759 double abs_mv_in_out_accumulator = 0.0;
1760 double mod_err_per_mb_accumulator = 0.0;
1761
1762 int max_bits = frame_max_bits(cpi); /* Max for a single frame */
1763
1764 unsigned int allow_alt_ref =
1765 cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames;
1766
1767 int alt_boost = 0;
1768 int f_boost = 0;
1769 int b_boost = 0;
1770 int flash_detected;
1771
1772 cpi->twopass.gf_group_bits = 0;
1773 cpi->twopass.gf_decay_rate = 0;
1774
1775 vp8_clear_system_state();
1776
1777 start_pos = cpi->twopass.stats_in;
1778
1779 vpx_memset(&next_frame, 0, sizeof(next_frame)); /* assure clean */
1780
1781 /* Load stats for the current frame. */
1782 mod_frame_err = calculate_modified_err(cpi, this_frame);
1783
1784 /* Note the error of the frame at the start of the group (this will be
1785 * the GF frame error if we code a normal gf
1786 */
1787 gf_first_frame_err = mod_frame_err;
1788
1789 /* Special treatment if the current frame is a key frame (which is also
1790 * a gf). If it is then its error score (and hence bit allocation) need
1791 * to be subtracted out from the calculation for the GF group
1792 */
1793 if (cpi->common.frame_type == KEY_FRAME)
1794 gf_group_err -= gf_first_frame_err;
1795
1796 /* Scan forward to try and work out how many frames the next gf group
1797 * should contain and what level of boost is appropriate for the GF
1798 * or ARF that will be coded with the group
1799 */
1800 i = 0;
1801
1802 while (((i < cpi->twopass.static_scene_max_gf_interval) ||
1803 ((cpi->twopass.frames_to_key - i) < MIN_GF_INTERVAL)) &&
1804 (i < cpi->twopass.frames_to_key))
1805 {
1806 i++;
1807
1808 /* Accumulate error score of frames in this gf group */
1809 mod_frame_err = calculate_modified_err(cpi, this_frame);
1810
1811 gf_group_err += mod_frame_err;
1812
1813 mod_err_per_mb_accumulator +=
1814 mod_frame_err / DOUBLE_DIVIDE_CHECK((double)cpi->common.MBs);
1815
1816 if (EOF == input_stats(cpi, &next_frame))
1817 break;
1818
1819 /* Test for the case where there is a brief flash but the prediction
1820 * quality back to an earlier frame is then restored.
1821 */
1822 flash_detected = detect_flash(cpi, 0);
1823
1824 /* Update the motion related elements to the boost calculation */
1825 accumulate_frame_motion_stats( cpi, &next_frame,
1826 &this_frame_mv_in_out, &mv_in_out_accumulator,
1827 &abs_mv_in_out_accumulator, &mv_ratio_accumulator );
1828
1829 /* Calculate a baseline boost number for this frame */
1830 r = calc_frame_boost( cpi, &next_frame, this_frame_mv_in_out );
1831
1832 /* Cumulative effect of prediction quality decay */
1833 if ( !flash_detected )
1834 {
1835 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
1836 decay_accumulator = decay_accumulator * loop_decay_rate;
1837 decay_accumulator =
1838 decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
1839 }
1840 boost_score += (decay_accumulator * r);
1841
1842 /* Break clause to detect very still sections after motion
1843 * For example a staic image after a fade or other transition.
1844 */
1845 if ( detect_transition_to_still( cpi, i, 5,
1846 loop_decay_rate,
1847 decay_accumulator ) )
1848 {
1849 allow_alt_ref = 0;
1850 boost_score = old_boost_score;
1851 break;
1852 }
1853
1854 /* Break out conditions. */
1855 if (
1856 /* Break at cpi->max_gf_interval unless almost totally static */
1857 (i >= cpi->max_gf_interval && (decay_accumulator < 0.995)) ||
1858 (
1859 /* Dont break out with a very short interval */
1860 (i > MIN_GF_INTERVAL) &&
1861 /* Dont break out very close to a key frame */
1862 ((cpi->twopass.frames_to_key - i) >= MIN_GF_INTERVAL) &&
1863 ((boost_score > 20.0) || (next_frame.pcnt_inter < 0.75)) &&
1864 (!flash_detected) &&
1865 ((mv_ratio_accumulator > 100.0) ||
1866 (abs_mv_in_out_accumulator > 3.0) ||
1867 (mv_in_out_accumulator < -2.0) ||
1868 ((boost_score - old_boost_score) < 2.0))
1869 ) )
1870 {
1871 boost_score = old_boost_score;
1872 break;
1873 }
1874
1875 vpx_memcpy(this_frame, &next_frame, sizeof(*this_frame));
1876
1877 old_boost_score = boost_score;
1878 }
1879
1880 cpi->twopass.gf_decay_rate =
1881 (i > 0) ? (int)(100.0 * (1.0 - decay_accumulator)) / i : 0;
1882
1883 /* When using CBR apply additional buffer related upper limits */
1884 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
1885 {
1886 double max_boost;
1887
1888 /* For cbr apply buffer related limits */
1889 if (cpi->drop_frames_allowed)
1890 {
1891 int64_t df_buffer_level = cpi->oxcf.drop_frames_water_mark *
1892 (cpi->oxcf.optimal_buffer_level / 100);
1893
1894 if (cpi->buffer_level > df_buffer_level)
1895 max_boost = ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
1896 else
1897 max_boost = 0.0;
1898 }
1899 else if (cpi->buffer_level > 0)
1900 {
1901 max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
1902 }
1903 else
1904 {
1905 max_boost = 0.0;
1906 }
1907
1908 if (boost_score > max_boost)
1909 boost_score = max_boost;
1910 }
1911
1912 /* Dont allow conventional gf too near the next kf */
1913 if ((cpi->twopass.frames_to_key - i) < MIN_GF_INTERVAL)
1914 {
1915 while (i < cpi->twopass.frames_to_key)
1916 {
1917 i++;
1918
1919 if (EOF == input_stats(cpi, this_frame))
1920 break;
1921
1922 if (i < cpi->twopass.frames_to_key)
1923 {
1924 mod_frame_err = calculate_modified_err(cpi, this_frame);
1925 gf_group_err += mod_frame_err;
1926 }
1927 }
1928 }
1929
1930 cpi->gfu_boost = (int)(boost_score * 100.0) >> 4;
1931
1932 #if NEW_BOOST
1933 /* Alterrnative boost calculation for alt ref */
1934 alt_boost = calc_arf_boost( cpi, 0, (i-1), (i-1), &f_boost, &b_boost );
1935 #endif
1936
1937 /* Should we use the alternate refernce frame */
1938 if (allow_alt_ref &&
1939 (i >= MIN_GF_INTERVAL) &&
1940 /* dont use ARF very near next kf */
1941 (i <= (cpi->twopass.frames_to_key - MIN_GF_INTERVAL)) &&
1942 #if NEW_BOOST
1943 ((next_frame.pcnt_inter > 0.75) ||
1944 (next_frame.pcnt_second_ref > 0.5)) &&
1945 ((mv_in_out_accumulator / (double)i > -0.2) ||
1946 (mv_in_out_accumulator > -2.0)) &&
1947 (b_boost > 100) &&
1948 (f_boost > 100) )
1949 #else
1950 (next_frame.pcnt_inter > 0.75) &&
1951 ((mv_in_out_accumulator / (double)i > -0.2) ||
1952 (mv_in_out_accumulator > -2.0)) &&
1953 (cpi->gfu_boost > 100) &&
1954 (cpi->twopass.gf_decay_rate <=
1955 (ARF_DECAY_THRESH + (cpi->gfu_boost / 200))) )
1956 #endif
1957 {
1958 int Boost;
1959 int allocation_chunks;
1960 int Q = (cpi->oxcf.fixed_q < 0)
1961 ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
1962 int tmp_q;
1963 int arf_frame_bits = 0;
1964 int group_bits;
1965
1966 #if NEW_BOOST
1967 cpi->gfu_boost = alt_boost;
1968 #endif
1969
1970 /* Estimate the bits to be allocated to the group as a whole */
1971 if ((cpi->twopass.kf_group_bits > 0) &&
1972 (cpi->twopass.kf_group_error_left > 0))
1973 {
1974 group_bits = (int)((double)cpi->twopass.kf_group_bits *
1975 (gf_group_err / (double)cpi->twopass.kf_group_error_left));
1976 }
1977 else
1978 group_bits = 0;
1979
1980 /* Boost for arf frame */
1981 #if NEW_BOOST
1982 Boost = (alt_boost * GFQ_ADJUSTMENT) / 100;
1983 #else
1984 Boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100);
1985 #endif
1986 Boost += (i * 50);
1987
1988 /* Set max and minimum boost and hence minimum allocation */
1989 if (Boost > ((cpi->baseline_gf_interval + 1) * 200))
1990 Boost = ((cpi->baseline_gf_interval + 1) * 200);
1991 else if (Boost < 125)
1992 Boost = 125;
1993
1994 allocation_chunks = (i * 100) + Boost;
1995
1996 /* Normalize Altboost and allocations chunck down to prevent overflow */
1997 while (Boost > 1000)
1998 {
1999 Boost /= 2;
2000 allocation_chunks /= 2;
2001 }
2002
2003 /* Calculate the number of bits to be spent on the arf based on the
2004 * boost number
2005 */
2006 arf_frame_bits = (int)((double)Boost * (group_bits /
2007 (double)allocation_chunks));
2008
2009 /* Estimate if there are enough bits available to make worthwhile use
2010 * of an arf.
2011 */
2012 tmp_q = estimate_q(cpi, mod_frame_err, (int)arf_frame_bits);
2013
2014 /* Only use an arf if it is likely we will be able to code
2015 * it at a lower Q than the surrounding frames.
2016 */
2017 if (tmp_q < cpi->worst_quality)
2018 {
2019 int half_gf_int;
2020 int frames_after_arf;
2021 int frames_bwd = cpi->oxcf.arnr_max_frames - 1;
2022 int frames_fwd = cpi->oxcf.arnr_max_frames - 1;
2023
2024 cpi->source_alt_ref_pending = 1;
2025
2026 /*
2027 * For alt ref frames the error score for the end frame of the
2028 * group (the alt ref frame) should not contribute to the group
2029 * total and hence the number of bit allocated to the group.
2030 * Rather it forms part of the next group (it is the GF at the
2031 * start of the next group)
2032 * gf_group_err -= mod_frame_err;
2033 *
2034 * For alt ref frames alt ref frame is technically part of the
2035 * GF frame for the next group but we always base the error
2036 * calculation and bit allocation on the current group of frames.
2037 *
2038 * Set the interval till the next gf or arf.
2039 * For ARFs this is the number of frames to be coded before the
2040 * future frame that is coded as an ARF.
2041 * The future frame itself is part of the next group
2042 */
2043 cpi->baseline_gf_interval = i;
2044
2045 /*
2046 * Define the arnr filter width for this group of frames:
2047 * We only filter frames that lie within a distance of half
2048 * the GF interval from the ARF frame. We also have to trap
2049 * cases where the filter extends beyond the end of clip.
2050 * Note: this_frame->frame has been updated in the loop
2051 * so it now points at the ARF frame.
2052 */
2053 half_gf_int = cpi->baseline_gf_interval >> 1;
2054 frames_after_arf = (int)(cpi->twopass.total_stats.count -
2055 this_frame->frame - 1);
2056
2057 switch (cpi->oxcf.arnr_type)
2058 {
2059 case 1: /* Backward filter */
2060 frames_fwd = 0;
2061 if (frames_bwd > half_gf_int)
2062 frames_bwd = half_gf_int;
2063 break;
2064
2065 case 2: /* Forward filter */
2066 if (frames_fwd > half_gf_int)
2067 frames_fwd = half_gf_int;
2068 if (frames_fwd > frames_after_arf)
2069 frames_fwd = frames_after_arf;
2070 frames_bwd = 0;
2071 break;
2072
2073 case 3: /* Centered filter */
2074 default:
2075 frames_fwd >>= 1;
2076 if (frames_fwd > frames_after_arf)
2077 frames_fwd = frames_after_arf;
2078 if (frames_fwd > half_gf_int)
2079 frames_fwd = half_gf_int;
2080
2081 frames_bwd = frames_fwd;
2082
2083 /* For even length filter there is one more frame backward
2084 * than forward: e.g. len=6 ==> bbbAff, len=7 ==> bbbAfff.
2085 */
2086 if (frames_bwd < half_gf_int)
2087 frames_bwd += (cpi->oxcf.arnr_max_frames+1) & 0x1;
2088 break;
2089 }
2090
2091 cpi->active_arnr_frames = frames_bwd + 1 + frames_fwd;
2092 }
2093 else
2094 {
2095 cpi->source_alt_ref_pending = 0;
2096 cpi->baseline_gf_interval = i;
2097 }
2098 }
2099 else
2100 {
2101 cpi->source_alt_ref_pending = 0;
2102 cpi->baseline_gf_interval = i;
2103 }
2104
2105 /*
2106 * Now decide how many bits should be allocated to the GF group as a
2107 * proportion of those remaining in the kf group.
2108 * The final key frame group in the clip is treated as a special case
2109 * where cpi->twopass.kf_group_bits is tied to cpi->twopass.bits_left.
2110 * This is also important for short clips where there may only be one
2111 * key frame.
2112 */
2113 if (cpi->twopass.frames_to_key >= (int)(cpi->twopass.total_stats.count -
2114 cpi->common.current_video_frame))
2115 {
2116 cpi->twopass.kf_group_bits =
2117 (cpi->twopass.bits_left > 0) ? cpi->twopass.bits_left : 0;
2118 }
2119
2120 /* Calculate the bits to be allocated to the group as a whole */
2121 if ((cpi->twopass.kf_group_bits > 0) &&
2122 (cpi->twopass.kf_group_error_left > 0))
2123 {
2124 cpi->twopass.gf_group_bits =
2125 (int64_t)(cpi->twopass.kf_group_bits *
2126 (gf_group_err / cpi->twopass.kf_group_error_left));
2127 }
2128 else
2129 cpi->twopass.gf_group_bits = 0;
2130
2131 cpi->twopass.gf_group_bits =
2132 (cpi->twopass.gf_group_bits < 0)
2133 ? 0
2134 : (cpi->twopass.gf_group_bits > cpi->twopass.kf_group_bits)
2135 ? cpi->twopass.kf_group_bits : cpi->twopass.gf_group_bits;
2136
2137 /* Clip cpi->twopass.gf_group_bits based on user supplied data rate
2138 * variability limit (cpi->oxcf.two_pass_vbrmax_section)
2139 */
2140 if (cpi->twopass.gf_group_bits >
2141 (int64_t)max_bits * cpi->baseline_gf_interval)
2142 cpi->twopass.gf_group_bits =
2143 (int64_t)max_bits * cpi->baseline_gf_interval;
2144
2145 /* Reset the file position */
2146 reset_fpf_position(cpi, start_pos);
2147
2148 /* Update the record of error used so far (only done once per gf group) */
2149 cpi->twopass.modified_error_used += gf_group_err;
2150
2151 /* Assign bits to the arf or gf. */
2152 for (i = 0; i <= (cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME); i++) {
2153 int Boost;
2154 int allocation_chunks;
2155 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
2156 int gf_bits;
2157
2158 /* For ARF frames */
2159 if (cpi->source_alt_ref_pending && i == 0)
2160 {
2161 #if NEW_BOOST
2162 Boost = (alt_boost * GFQ_ADJUSTMENT) / 100;
2163 #else
2164 Boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100);
2165 #endif
2166 Boost += (cpi->baseline_gf_interval * 50);
2167
2168 /* Set max and minimum boost and hence minimum allocation */
2169 if (Boost > ((cpi->baseline_gf_interval + 1) * 200))
2170 Boost = ((cpi->baseline_gf_interval + 1) * 200);
2171 else if (Boost < 125)
2172 Boost = 125;
2173
2174 allocation_chunks =
2175 ((cpi->baseline_gf_interval + 1) * 100) + Boost;
2176 }
2177 /* Else for standard golden frames */
2178 else
2179 {
2180 /* boost based on inter / intra ratio of subsequent frames */
2181 Boost = (cpi->gfu_boost * GFQ_ADJUSTMENT) / 100;
2182
2183 /* Set max and minimum boost and hence minimum allocation */
2184 if (Boost > (cpi->baseline_gf_interval * 150))
2185 Boost = (cpi->baseline_gf_interval * 150);
2186 else if (Boost < 125)
2187 Boost = 125;
2188
2189 allocation_chunks =
2190 (cpi->baseline_gf_interval * 100) + (Boost - 100);
2191 }
2192
2193 /* Normalize Altboost and allocations chunck down to prevent overflow */
2194 while (Boost > 1000)
2195 {
2196 Boost /= 2;
2197 allocation_chunks /= 2;
2198 }
2199
2200 /* Calculate the number of bits to be spent on the gf or arf based on
2201 * the boost number
2202 */
2203 gf_bits = (int)((double)Boost *
2204 (cpi->twopass.gf_group_bits /
2205 (double)allocation_chunks));
2206
2207 /* If the frame that is to be boosted is simpler than the average for
2208 * the gf/arf group then use an alternative calculation
2209 * based on the error score of the frame itself
2210 */
2211 if (mod_frame_err < gf_group_err / (double)cpi->baseline_gf_interval)
2212 {
2213 double alt_gf_grp_bits;
2214 int alt_gf_bits;
2215
2216 alt_gf_grp_bits =
2217 (double)cpi->twopass.kf_group_bits *
2218 (mod_frame_err * (double)cpi->baseline_gf_interval) /
2219 DOUBLE_DIVIDE_CHECK((double)cpi->twopass.kf_group_error_left);
2220
2221 alt_gf_bits = (int)((double)Boost * (alt_gf_grp_bits /
2222 (double)allocation_chunks));
2223
2224 if (gf_bits > alt_gf_bits)
2225 {
2226 gf_bits = alt_gf_bits;
2227 }
2228 }
2229 /* Else if it is harder than other frames in the group make sure it at
2230 * least receives an allocation in keeping with its relative error
2231 * score, otherwise it may be worse off than an "un-boosted" frame
2232 */
2233 else
2234 {
2235 int alt_gf_bits =
2236 (int)((double)cpi->twopass.kf_group_bits *
2237 mod_frame_err /
2238 DOUBLE_DIVIDE_CHECK((double)cpi->twopass.kf_group_error_left));
2239
2240 if (alt_gf_bits > gf_bits)
2241 {
2242 gf_bits = alt_gf_bits;
2243 }
2244 }
2245
2246 /* Apply an additional limit for CBR */
2247 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2248 {
2249 if (cpi->twopass.gf_bits > (int)(cpi->buffer_level >> 1))
2250 cpi->twopass.gf_bits = (int)(cpi->buffer_level >> 1);
2251 }
2252
2253 /* Dont allow a negative value for gf_bits */
2254 if (gf_bits < 0)
2255 gf_bits = 0;
2256
2257 /* Add in minimum for a frame */
2258 gf_bits += cpi->min_frame_bandwidth;
2259
2260 if (i == 0)
2261 {
2262 cpi->twopass.gf_bits = gf_bits;
2263 }
2264 if (i == 1 || (!cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME)))
2265 {
2266 /* Per frame bit target for this frame */
2267 cpi->per_frame_bandwidth = gf_bits;
2268 }
2269 }
2270
2271 {
2272 /* Adjust KF group bits and error remainin */
2273 cpi->twopass.kf_group_error_left -= (int64_t)gf_group_err;
2274 cpi->twopass.kf_group_bits -= cpi->twopass.gf_group_bits;
2275
2276 if (cpi->twopass.kf_group_bits < 0)
2277 cpi->twopass.kf_group_bits = 0;
2278
2279 /* Note the error score left in the remaining frames of the group.
2280 * For normal GFs we want to remove the error score for the first
2281 * frame of the group (except in Key frame case where this has
2282 * already happened)
2283 */
2284 if (!cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME)
2285 cpi->twopass.gf_group_error_left = (int)(gf_group_err -
2286 gf_first_frame_err);
2287 else
2288 cpi->twopass.gf_group_error_left = (int) gf_group_err;
2289
2290 cpi->twopass.gf_group_bits -= cpi->twopass.gf_bits - cpi->min_frame_bandwidth;
2291
2292 if (cpi->twopass.gf_group_bits < 0)
2293 cpi->twopass.gf_group_bits = 0;
2294
2295 /* This condition could fail if there are two kfs very close together
2296 * despite (MIN_GF_INTERVAL) and would cause a devide by 0 in the
2297 * calculation of cpi->twopass.alt_extra_bits.
2298 */
2299 if ( cpi->baseline_gf_interval >= 3 )
2300 {
2301 #if NEW_BOOST
2302 int boost = (cpi->source_alt_ref_pending)
2303 ? b_boost : cpi->gfu_boost;
2304 #else
2305 int boost = cpi->gfu_boost;
2306 #endif
2307 if ( boost >= 150 )
2308 {
2309 int pct_extra;
2310
2311 pct_extra = (boost - 100) / 50;
2312 pct_extra = (pct_extra > 20) ? 20 : pct_extra;
2313
2314 cpi->twopass.alt_extra_bits =
2315 (int)(cpi->twopass.gf_group_bits * pct_extra) / 100;
2316 cpi->twopass.gf_group_bits -= cpi->twopass.alt_extra_bits;
2317 cpi->twopass.alt_extra_bits /=
2318 ((cpi->baseline_gf_interval-1)>>1);
2319 }
2320 else
2321 cpi->twopass.alt_extra_bits = 0;
2322 }
2323 else
2324 cpi->twopass.alt_extra_bits = 0;
2325 }
2326
2327 /* Adjustments based on a measure of complexity of the section */
2328 if (cpi->common.frame_type != KEY_FRAME)
2329 {
2330 FIRSTPASS_STATS sectionstats;
2331 double Ratio;
2332
2333 zero_stats(§ionstats);
2334 reset_fpf_position(cpi, start_pos);
2335
2336 for (i = 0 ; i < cpi->baseline_gf_interval ; i++)
2337 {
2338 input_stats(cpi, &next_frame);
2339 accumulate_stats(§ionstats, &next_frame);
2340 }
2341
2342 avg_stats(§ionstats);
2343
2344 cpi->twopass.section_intra_rating = (unsigned int)
2345 (sectionstats.intra_error /
2346 DOUBLE_DIVIDE_CHECK(sectionstats.coded_error));
2347
2348 Ratio = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
2349 cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025);
2350
2351 if (cpi->twopass.section_max_qfactor < 0.80)
2352 cpi->twopass.section_max_qfactor = 0.80;
2353
2354 reset_fpf_position(cpi, start_pos);
2355 }
2356 }
2357
2358 /* 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)2359 static void assign_std_frame_bits(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
2360 {
2361 int target_frame_size;
2362
2363 double modified_err;
2364 double err_fraction;
2365
2366 int max_bits = frame_max_bits(cpi); /* Max for a single frame */
2367
2368 /* Calculate modified prediction error used in bit allocation */
2369 modified_err = calculate_modified_err(cpi, this_frame);
2370
2371 /* What portion of the remaining GF group error is used by this frame */
2372 if (cpi->twopass.gf_group_error_left > 0)
2373 err_fraction = modified_err / cpi->twopass.gf_group_error_left;
2374 else
2375 err_fraction = 0.0;
2376
2377 /* How many of those bits available for allocation should we give it? */
2378 target_frame_size = (int)((double)cpi->twopass.gf_group_bits * err_fraction);
2379
2380 /* Clip to target size to 0 - max_bits (or cpi->twopass.gf_group_bits)
2381 * at the top end.
2382 */
2383 if (target_frame_size < 0)
2384 target_frame_size = 0;
2385 else
2386 {
2387 if (target_frame_size > max_bits)
2388 target_frame_size = max_bits;
2389
2390 if (target_frame_size > cpi->twopass.gf_group_bits)
2391 target_frame_size = (int)cpi->twopass.gf_group_bits;
2392 }
2393
2394 /* Adjust error and bits remaining */
2395 cpi->twopass.gf_group_error_left -= (int)modified_err;
2396 cpi->twopass.gf_group_bits -= target_frame_size;
2397
2398 if (cpi->twopass.gf_group_bits < 0)
2399 cpi->twopass.gf_group_bits = 0;
2400
2401 /* Add in the minimum number of bits that is set aside for every frame. */
2402 target_frame_size += cpi->min_frame_bandwidth;
2403
2404 /* Every other frame gets a few extra bits */
2405 if ( (cpi->frames_since_golden & 0x01) &&
2406 (cpi->frames_till_gf_update_due > 0) )
2407 {
2408 target_frame_size += cpi->twopass.alt_extra_bits;
2409 }
2410
2411 /* Per frame bit target for this frame */
2412 cpi->per_frame_bandwidth = target_frame_size;
2413 }
2414
vp8_second_pass(VP8_COMP * cpi)2415 void vp8_second_pass(VP8_COMP *cpi)
2416 {
2417 int tmp_q;
2418 int frames_left = (int)(cpi->twopass.total_stats.count - cpi->common.current_video_frame);
2419
2420 FIRSTPASS_STATS this_frame;
2421 FIRSTPASS_STATS this_frame_copy;
2422
2423 double this_frame_intra_error;
2424 double this_frame_coded_error;
2425
2426 int overhead_bits;
2427
2428 memset(&this_frame, 0, sizeof(FIRSTPASS_STATS));
2429 if (!cpi->twopass.stats_in)
2430 {
2431 return ;
2432 }
2433
2434 vp8_clear_system_state();
2435
2436 if (EOF == input_stats(cpi, &this_frame))
2437 return;
2438
2439 this_frame_intra_error = this_frame.intra_error;
2440 this_frame_coded_error = this_frame.coded_error;
2441
2442 /* keyframe and section processing ! */
2443 if (cpi->twopass.frames_to_key == 0)
2444 {
2445 /* Define next KF group and assign bits to it */
2446 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2447 find_next_key_frame(cpi, &this_frame_copy);
2448
2449 /* Special case: Error error_resilient_mode mode does not make much
2450 * sense for two pass but with its current meaning this code is
2451 * designed to stop outlandish behaviour if someone does set it when
2452 * using two pass. It effectively disables GF groups. This is
2453 * temporary code until we decide what should really happen in this
2454 * case.
2455 */
2456 if (cpi->oxcf.error_resilient_mode)
2457 {
2458 cpi->twopass.gf_group_bits = cpi->twopass.kf_group_bits;
2459 cpi->twopass.gf_group_error_left =
2460 (int)cpi->twopass.kf_group_error_left;
2461 cpi->baseline_gf_interval = cpi->twopass.frames_to_key;
2462 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
2463 cpi->source_alt_ref_pending = 0;
2464 }
2465
2466 }
2467
2468 /* Is this a GF / ARF (Note that a KF is always also a GF) */
2469 if (cpi->frames_till_gf_update_due == 0)
2470 {
2471 /* Define next gf group and assign bits to it */
2472 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2473 define_gf_group(cpi, &this_frame_copy);
2474
2475 /* If we are going to code an altref frame at the end of the group
2476 * and the current frame is not a key frame.... If the previous
2477 * group used an arf this frame has already benefited from that arf
2478 * boost and it should not be given extra bits If the previous
2479 * group was NOT coded using arf we may want to apply some boost to
2480 * this GF as well
2481 */
2482 if (cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME))
2483 {
2484 /* Assign a standard frames worth of bits from those allocated
2485 * to the GF group
2486 */
2487 int bak = cpi->per_frame_bandwidth;
2488 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2489 assign_std_frame_bits(cpi, &this_frame_copy);
2490 cpi->per_frame_bandwidth = bak;
2491 }
2492 }
2493
2494 /* Otherwise this is an ordinary frame */
2495 else
2496 {
2497 /* Special case: Error error_resilient_mode mode does not make much
2498 * sense for two pass but with its current meaning but this code is
2499 * designed to stop outlandish behaviour if someone does set it
2500 * when using two pass. It effectively disables GF groups. This is
2501 * temporary code till we decide what should really happen in this
2502 * case.
2503 */
2504 if (cpi->oxcf.error_resilient_mode)
2505 {
2506 cpi->frames_till_gf_update_due = cpi->twopass.frames_to_key;
2507
2508 if (cpi->common.frame_type != KEY_FRAME)
2509 {
2510 /* Assign bits from those allocated to the GF group */
2511 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2512 assign_std_frame_bits(cpi, &this_frame_copy);
2513 }
2514 }
2515 else
2516 {
2517 /* Assign bits from those allocated to the GF group */
2518 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2519 assign_std_frame_bits(cpi, &this_frame_copy);
2520 }
2521 }
2522
2523 /* Keep a globally available copy of this and the next frame's iiratio. */
2524 cpi->twopass.this_iiratio = (unsigned int)(this_frame_intra_error /
2525 DOUBLE_DIVIDE_CHECK(this_frame_coded_error));
2526 {
2527 FIRSTPASS_STATS next_frame;
2528 if ( lookup_next_frame_stats(cpi, &next_frame) != EOF )
2529 {
2530 cpi->twopass.next_iiratio = (unsigned int)(next_frame.intra_error /
2531 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2532 }
2533 }
2534
2535 /* Set nominal per second bandwidth for this frame */
2536 cpi->target_bandwidth = (int)
2537 (cpi->per_frame_bandwidth * cpi->output_framerate);
2538 if (cpi->target_bandwidth < 0)
2539 cpi->target_bandwidth = 0;
2540
2541
2542 /* Account for mv, mode and other overheads. */
2543 overhead_bits = (int)estimate_modemvcost(
2544 cpi, &cpi->twopass.total_left_stats );
2545
2546 /* Special case code for first frame. */
2547 if (cpi->common.current_video_frame == 0)
2548 {
2549 cpi->twopass.est_max_qcorrection_factor = 1.0;
2550
2551 /* Set a cq_level in constrained quality mode. */
2552 if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY )
2553 {
2554 int est_cq;
2555
2556 est_cq =
2557 estimate_cq( cpi,
2558 &cpi->twopass.total_left_stats,
2559 (int)(cpi->twopass.bits_left / frames_left),
2560 overhead_bits );
2561
2562 cpi->cq_target_quality = cpi->oxcf.cq_level;
2563 if ( est_cq > cpi->cq_target_quality )
2564 cpi->cq_target_quality = est_cq;
2565 }
2566
2567 /* guess at maxq needed in 2nd pass */
2568 cpi->twopass.maxq_max_limit = cpi->worst_quality;
2569 cpi->twopass.maxq_min_limit = cpi->best_quality;
2570
2571 tmp_q = estimate_max_q(
2572 cpi,
2573 &cpi->twopass.total_left_stats,
2574 (int)(cpi->twopass.bits_left / frames_left),
2575 overhead_bits );
2576
2577 /* Limit the maxq value returned subsequently.
2578 * This increases the risk of overspend or underspend if the initial
2579 * estimate for the clip is bad, but helps prevent excessive
2580 * variation in Q, especially near the end of a clip
2581 * where for example a small overspend may cause Q to crash
2582 */
2583 cpi->twopass.maxq_max_limit = ((tmp_q + 32) < cpi->worst_quality)
2584 ? (tmp_q + 32) : cpi->worst_quality;
2585 cpi->twopass.maxq_min_limit = ((tmp_q - 32) > cpi->best_quality)
2586 ? (tmp_q - 32) : cpi->best_quality;
2587
2588 cpi->active_worst_quality = tmp_q;
2589 cpi->ni_av_qi = tmp_q;
2590 }
2591
2592 /* The last few frames of a clip almost always have to few or too many
2593 * bits and for the sake of over exact rate control we dont want to make
2594 * radical adjustments to the allowed quantizer range just to use up a
2595 * few surplus bits or get beneath the target rate.
2596 */
2597 else if ( (cpi->common.current_video_frame <
2598 (((unsigned int)cpi->twopass.total_stats.count * 255)>>8)) &&
2599 ((cpi->common.current_video_frame + cpi->baseline_gf_interval) <
2600 (unsigned int)cpi->twopass.total_stats.count) )
2601 {
2602 if (frames_left < 1)
2603 frames_left = 1;
2604
2605 tmp_q = estimate_max_q(
2606 cpi,
2607 &cpi->twopass.total_left_stats,
2608 (int)(cpi->twopass.bits_left / frames_left),
2609 overhead_bits );
2610
2611 /* Move active_worst_quality but in a damped way */
2612 if (tmp_q > cpi->active_worst_quality)
2613 cpi->active_worst_quality ++;
2614 else if (tmp_q < cpi->active_worst_quality)
2615 cpi->active_worst_quality --;
2616
2617 cpi->active_worst_quality =
2618 ((cpi->active_worst_quality * 3) + tmp_q + 2) / 4;
2619 }
2620
2621 cpi->twopass.frames_to_key --;
2622
2623 /* Update the total stats remaining sturcture */
2624 subtract_stats(&cpi->twopass.total_left_stats, &this_frame );
2625 }
2626
2627
test_candidate_kf(VP8_COMP * cpi,FIRSTPASS_STATS * last_frame,FIRSTPASS_STATS * this_frame,FIRSTPASS_STATS * next_frame)2628 static int test_candidate_kf(VP8_COMP *cpi, FIRSTPASS_STATS *last_frame, FIRSTPASS_STATS *this_frame, FIRSTPASS_STATS *next_frame)
2629 {
2630 int is_viable_kf = 0;
2631
2632 /* Does the frame satisfy the primary criteria of a key frame
2633 * If so, then examine how well it predicts subsequent frames
2634 */
2635 if ((this_frame->pcnt_second_ref < 0.10) &&
2636 (next_frame->pcnt_second_ref < 0.10) &&
2637 ((this_frame->pcnt_inter < 0.05) ||
2638 (
2639 ((this_frame->pcnt_inter - this_frame->pcnt_neutral) < .25) &&
2640 ((this_frame->intra_error / DOUBLE_DIVIDE_CHECK(this_frame->coded_error)) < 2.5) &&
2641 ((fabs(last_frame->coded_error - this_frame->coded_error) / DOUBLE_DIVIDE_CHECK(this_frame->coded_error) > .40) ||
2642 (fabs(last_frame->intra_error - this_frame->intra_error) / DOUBLE_DIVIDE_CHECK(this_frame->intra_error) > .40) ||
2643 ((next_frame->intra_error / DOUBLE_DIVIDE_CHECK(next_frame->coded_error)) > 3.5)
2644 )
2645 )
2646 )
2647 )
2648 {
2649 int i;
2650 FIRSTPASS_STATS *start_pos;
2651
2652 FIRSTPASS_STATS local_next_frame;
2653
2654 double boost_score = 0.0;
2655 double old_boost_score = 0.0;
2656 double decay_accumulator = 1.0;
2657 double next_iiratio;
2658
2659 vpx_memcpy(&local_next_frame, next_frame, sizeof(*next_frame));
2660
2661 /* Note the starting file position so we can reset to it */
2662 start_pos = cpi->twopass.stats_in;
2663
2664 /* Examine how well the key frame predicts subsequent frames */
2665 for (i = 0 ; i < 16; i++)
2666 {
2667 next_iiratio = (IIKFACTOR1 * local_next_frame.intra_error / DOUBLE_DIVIDE_CHECK(local_next_frame.coded_error)) ;
2668
2669 if (next_iiratio > RMAX)
2670 next_iiratio = RMAX;
2671
2672 /* Cumulative effect of decay in prediction quality */
2673 if (local_next_frame.pcnt_inter > 0.85)
2674 decay_accumulator = decay_accumulator * local_next_frame.pcnt_inter;
2675 else
2676 decay_accumulator = decay_accumulator * ((0.85 + local_next_frame.pcnt_inter) / 2.0);
2677
2678 /* Keep a running total */
2679 boost_score += (decay_accumulator * next_iiratio);
2680
2681 /* Test various breakout clauses */
2682 if ((local_next_frame.pcnt_inter < 0.05) ||
2683 (next_iiratio < 1.5) ||
2684 (((local_next_frame.pcnt_inter -
2685 local_next_frame.pcnt_neutral) < 0.20) &&
2686 (next_iiratio < 3.0)) ||
2687 ((boost_score - old_boost_score) < 0.5) ||
2688 (local_next_frame.intra_error < 200)
2689 )
2690 {
2691 break;
2692 }
2693
2694 old_boost_score = boost_score;
2695
2696 /* Get the next frame details */
2697 if (EOF == input_stats(cpi, &local_next_frame))
2698 break;
2699 }
2700
2701 /* If there is tolerable prediction for at least the next 3 frames
2702 * then break out else discard this pottential key frame and move on
2703 */
2704 if (boost_score > 5.0 && (i > 3))
2705 is_viable_kf = 1;
2706 else
2707 {
2708 /* Reset the file position */
2709 reset_fpf_position(cpi, start_pos);
2710
2711 is_viable_kf = 0;
2712 }
2713 }
2714
2715 return is_viable_kf;
2716 }
find_next_key_frame(VP8_COMP * cpi,FIRSTPASS_STATS * this_frame)2717 static void find_next_key_frame(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
2718 {
2719 int i,j;
2720 FIRSTPASS_STATS last_frame;
2721 FIRSTPASS_STATS first_frame;
2722 FIRSTPASS_STATS next_frame;
2723 FIRSTPASS_STATS *start_position;
2724
2725 double decay_accumulator = 1.0;
2726 double boost_score = 0;
2727 double old_boost_score = 0.0;
2728 double loop_decay_rate;
2729
2730 double kf_mod_err = 0.0;
2731 double kf_group_err = 0.0;
2732 double kf_group_intra_err = 0.0;
2733 double kf_group_coded_err = 0.0;
2734 double recent_loop_decay[8] = {1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0};
2735
2736 vpx_memset(&next_frame, 0, sizeof(next_frame));
2737
2738 vp8_clear_system_state();
2739 start_position = cpi->twopass.stats_in;
2740
2741 cpi->common.frame_type = KEY_FRAME;
2742
2743 /* is this a forced key frame by interval */
2744 cpi->this_key_frame_forced = cpi->next_key_frame_forced;
2745
2746 /* Clear the alt ref active flag as this can never be active on a key
2747 * frame
2748 */
2749 cpi->source_alt_ref_active = 0;
2750
2751 /* Kf is always a gf so clear frames till next gf counter */
2752 cpi->frames_till_gf_update_due = 0;
2753
2754 cpi->twopass.frames_to_key = 1;
2755
2756 /* Take a copy of the initial frame details */
2757 vpx_memcpy(&first_frame, this_frame, sizeof(*this_frame));
2758
2759 cpi->twopass.kf_group_bits = 0;
2760 cpi->twopass.kf_group_error_left = 0;
2761
2762 kf_mod_err = calculate_modified_err(cpi, this_frame);
2763
2764 /* find the next keyframe */
2765 i = 0;
2766 while (cpi->twopass.stats_in < cpi->twopass.stats_in_end)
2767 {
2768 /* Accumulate kf group error */
2769 kf_group_err += calculate_modified_err(cpi, this_frame);
2770
2771 /* These figures keep intra and coded error counts for all frames
2772 * including key frames in the group. The effect of the key frame
2773 * itself can be subtracted out using the first_frame data
2774 * collected above
2775 */
2776 kf_group_intra_err += this_frame->intra_error;
2777 kf_group_coded_err += this_frame->coded_error;
2778
2779 /* Load the next frame's stats. */
2780 vpx_memcpy(&last_frame, this_frame, sizeof(*this_frame));
2781 input_stats(cpi, this_frame);
2782
2783 /* Provided that we are not at the end of the file... */
2784 if (cpi->oxcf.auto_key
2785 && lookup_next_frame_stats(cpi, &next_frame) != EOF)
2786 {
2787 /* Normal scene cut check */
2788 if ( ( i >= MIN_GF_INTERVAL ) &&
2789 test_candidate_kf(cpi, &last_frame, this_frame, &next_frame) )
2790 {
2791 break;
2792 }
2793
2794 /* How fast is prediction quality decaying */
2795 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
2796
2797 /* We want to know something about the recent past... rather than
2798 * as used elsewhere where we are concened with decay in prediction
2799 * quality since the last GF or KF.
2800 */
2801 recent_loop_decay[i%8] = loop_decay_rate;
2802 decay_accumulator = 1.0;
2803 for (j = 0; j < 8; j++)
2804 {
2805 decay_accumulator = decay_accumulator * recent_loop_decay[j];
2806 }
2807
2808 /* Special check for transition or high motion followed by a
2809 * static scene.
2810 */
2811 if ( detect_transition_to_still( cpi, i,
2812 (cpi->key_frame_frequency-i),
2813 loop_decay_rate,
2814 decay_accumulator ) )
2815 {
2816 break;
2817 }
2818
2819
2820 /* Step on to the next frame */
2821 cpi->twopass.frames_to_key ++;
2822
2823 /* If we don't have a real key frame within the next two
2824 * forcekeyframeevery intervals then break out of the loop.
2825 */
2826 if (cpi->twopass.frames_to_key >= 2 *(int)cpi->key_frame_frequency)
2827 break;
2828 } else
2829 cpi->twopass.frames_to_key ++;
2830
2831 i++;
2832 }
2833
2834 /* If there is a max kf interval set by the user we must obey it.
2835 * We already breakout of the loop above at 2x max.
2836 * This code centers the extra kf if the actual natural
2837 * interval is between 1x and 2x
2838 */
2839 if (cpi->oxcf.auto_key
2840 && cpi->twopass.frames_to_key > (int)cpi->key_frame_frequency )
2841 {
2842 FIRSTPASS_STATS *current_pos = cpi->twopass.stats_in;
2843 FIRSTPASS_STATS tmp_frame;
2844
2845 cpi->twopass.frames_to_key /= 2;
2846
2847 /* Copy first frame details */
2848 vpx_memcpy(&tmp_frame, &first_frame, sizeof(first_frame));
2849
2850 /* Reset to the start of the group */
2851 reset_fpf_position(cpi, start_position);
2852
2853 kf_group_err = 0;
2854 kf_group_intra_err = 0;
2855 kf_group_coded_err = 0;
2856
2857 /* Rescan to get the correct error data for the forced kf group */
2858 for( i = 0; i < cpi->twopass.frames_to_key; i++ )
2859 {
2860 /* Accumulate kf group errors */
2861 kf_group_err += calculate_modified_err(cpi, &tmp_frame);
2862 kf_group_intra_err += tmp_frame.intra_error;
2863 kf_group_coded_err += tmp_frame.coded_error;
2864
2865 /* Load a the next frame's stats */
2866 input_stats(cpi, &tmp_frame);
2867 }
2868
2869 /* Reset to the start of the group */
2870 reset_fpf_position(cpi, current_pos);
2871
2872 cpi->next_key_frame_forced = 1;
2873 }
2874 else
2875 cpi->next_key_frame_forced = 0;
2876
2877 /* Special case for the last frame of the file */
2878 if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end)
2879 {
2880 /* Accumulate kf group error */
2881 kf_group_err += calculate_modified_err(cpi, this_frame);
2882
2883 /* These figures keep intra and coded error counts for all frames
2884 * including key frames in the group. The effect of the key frame
2885 * itself can be subtracted out using the first_frame data
2886 * collected above
2887 */
2888 kf_group_intra_err += this_frame->intra_error;
2889 kf_group_coded_err += this_frame->coded_error;
2890 }
2891
2892 /* Calculate the number of bits that should be assigned to the kf group. */
2893 if ((cpi->twopass.bits_left > 0) && (cpi->twopass.modified_error_left > 0.0))
2894 {
2895 /* Max for a single normal frame (not key frame) */
2896 int max_bits = frame_max_bits(cpi);
2897
2898 /* Maximum bits for the kf group */
2899 int64_t max_grp_bits;
2900
2901 /* Default allocation based on bits left and relative
2902 * complexity of the section
2903 */
2904 cpi->twopass.kf_group_bits = (int64_t)( cpi->twopass.bits_left *
2905 ( kf_group_err /
2906 cpi->twopass.modified_error_left ));
2907
2908 /* Clip based on maximum per frame rate defined by the user. */
2909 max_grp_bits = (int64_t)max_bits * (int64_t)cpi->twopass.frames_to_key;
2910 if (cpi->twopass.kf_group_bits > max_grp_bits)
2911 cpi->twopass.kf_group_bits = max_grp_bits;
2912
2913 /* Additional special case for CBR if buffer is getting full. */
2914 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2915 {
2916 int64_t opt_buffer_lvl = cpi->oxcf.optimal_buffer_level;
2917 int64_t buffer_lvl = cpi->buffer_level;
2918
2919 /* If the buffer is near or above the optimal and this kf group is
2920 * not being allocated much then increase the allocation a bit.
2921 */
2922 if (buffer_lvl >= opt_buffer_lvl)
2923 {
2924 int64_t high_water_mark = (opt_buffer_lvl +
2925 cpi->oxcf.maximum_buffer_size) >> 1;
2926
2927 int64_t av_group_bits;
2928
2929 /* Av bits per frame * number of frames */
2930 av_group_bits = (int64_t)cpi->av_per_frame_bandwidth *
2931 (int64_t)cpi->twopass.frames_to_key;
2932
2933 /* We are at or above the maximum. */
2934 if (cpi->buffer_level >= high_water_mark)
2935 {
2936 int64_t min_group_bits;
2937
2938 min_group_bits = av_group_bits +
2939 (int64_t)(buffer_lvl -
2940 high_water_mark);
2941
2942 if (cpi->twopass.kf_group_bits < min_group_bits)
2943 cpi->twopass.kf_group_bits = min_group_bits;
2944 }
2945 /* We are above optimal but below the maximum */
2946 else if (cpi->twopass.kf_group_bits < av_group_bits)
2947 {
2948 int64_t bits_below_av = av_group_bits -
2949 cpi->twopass.kf_group_bits;
2950
2951 cpi->twopass.kf_group_bits +=
2952 (int64_t)((double)bits_below_av *
2953 (double)(buffer_lvl - opt_buffer_lvl) /
2954 (double)(high_water_mark - opt_buffer_lvl));
2955 }
2956 }
2957 }
2958 }
2959 else
2960 cpi->twopass.kf_group_bits = 0;
2961
2962 /* Reset the first pass file position */
2963 reset_fpf_position(cpi, start_position);
2964
2965 /* determine how big to make this keyframe based on how well the
2966 * subsequent frames use inter blocks
2967 */
2968 decay_accumulator = 1.0;
2969 boost_score = 0.0;
2970 loop_decay_rate = 1.00; /* Starting decay rate */
2971
2972 for (i = 0 ; i < cpi->twopass.frames_to_key ; i++)
2973 {
2974 double r;
2975
2976 if (EOF == input_stats(cpi, &next_frame))
2977 break;
2978
2979 if (next_frame.intra_error > cpi->twopass.kf_intra_err_min)
2980 r = (IIKFACTOR2 * next_frame.intra_error /
2981 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2982 else
2983 r = (IIKFACTOR2 * cpi->twopass.kf_intra_err_min /
2984 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2985
2986 if (r > RMAX)
2987 r = RMAX;
2988
2989 /* How fast is prediction quality decaying */
2990 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
2991
2992 decay_accumulator = decay_accumulator * loop_decay_rate;
2993 decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
2994
2995 boost_score += (decay_accumulator * r);
2996
2997 if ((i > MIN_GF_INTERVAL) &&
2998 ((boost_score - old_boost_score) < 1.0))
2999 {
3000 break;
3001 }
3002
3003 old_boost_score = boost_score;
3004 }
3005
3006 if (1)
3007 {
3008 FIRSTPASS_STATS sectionstats;
3009 double Ratio;
3010
3011 zero_stats(§ionstats);
3012 reset_fpf_position(cpi, start_position);
3013
3014 for (i = 0 ; i < cpi->twopass.frames_to_key ; i++)
3015 {
3016 input_stats(cpi, &next_frame);
3017 accumulate_stats(§ionstats, &next_frame);
3018 }
3019
3020 avg_stats(§ionstats);
3021
3022 cpi->twopass.section_intra_rating = (unsigned int)
3023 (sectionstats.intra_error
3024 / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error));
3025
3026 Ratio = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
3027 cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025);
3028
3029 if (cpi->twopass.section_max_qfactor < 0.80)
3030 cpi->twopass.section_max_qfactor = 0.80;
3031 }
3032
3033 /* When using CBR apply additional buffer fullness related upper limits */
3034 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
3035 {
3036 double max_boost;
3037
3038 if (cpi->drop_frames_allowed)
3039 {
3040 int df_buffer_level = (int)(cpi->oxcf.drop_frames_water_mark
3041 * (cpi->oxcf.optimal_buffer_level / 100));
3042
3043 if (cpi->buffer_level > df_buffer_level)
3044 max_boost = ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
3045 else
3046 max_boost = 0.0;
3047 }
3048 else if (cpi->buffer_level > 0)
3049 {
3050 max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
3051 }
3052 else
3053 {
3054 max_boost = 0.0;
3055 }
3056
3057 if (boost_score > max_boost)
3058 boost_score = max_boost;
3059 }
3060
3061 /* Reset the first pass file position */
3062 reset_fpf_position(cpi, start_position);
3063
3064 /* Work out how many bits to allocate for the key frame itself */
3065 if (1)
3066 {
3067 int kf_boost = (int)boost_score;
3068 int allocation_chunks;
3069 int Counter = cpi->twopass.frames_to_key;
3070 int alt_kf_bits;
3071 YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
3072 /* Min boost based on kf interval */
3073 #if 0
3074
3075 while ((kf_boost < 48) && (Counter > 0))
3076 {
3077 Counter -= 2;
3078 kf_boost ++;
3079 }
3080
3081 #endif
3082
3083 if (kf_boost < 48)
3084 {
3085 kf_boost += ((Counter + 1) >> 1);
3086
3087 if (kf_boost > 48) kf_boost = 48;
3088 }
3089
3090 /* bigger frame sizes need larger kf boosts, smaller frames smaller
3091 * boosts...
3092 */
3093 if ((lst_yv12->y_width * lst_yv12->y_height) > (320 * 240))
3094 kf_boost += 2 * (lst_yv12->y_width * lst_yv12->y_height) / (320 * 240);
3095 else if ((lst_yv12->y_width * lst_yv12->y_height) < (320 * 240))
3096 kf_boost -= 4 * (320 * 240) / (lst_yv12->y_width * lst_yv12->y_height);
3097
3098 /* Min KF boost */
3099 kf_boost = (int)((double)kf_boost * 100.0) >> 4; /* Scale 16 to 100 */
3100 if (kf_boost < 250)
3101 kf_boost = 250;
3102
3103 /*
3104 * We do three calculations for kf size.
3105 * The first is based on the error score for the whole kf group.
3106 * The second (optionaly) on the key frames own error if this is
3107 * smaller than the average for the group.
3108 * The final one insures that the frame receives at least the
3109 * allocation it would have received based on its own error score vs
3110 * the error score remaining
3111 * Special case if the sequence appears almost totaly static
3112 * as measured by the decay accumulator. In this case we want to
3113 * spend almost all of the bits on the key frame.
3114 * cpi->twopass.frames_to_key-1 because key frame itself is taken
3115 * care of by kf_boost.
3116 */
3117 if ( decay_accumulator >= 0.99 )
3118 {
3119 allocation_chunks =
3120 ((cpi->twopass.frames_to_key - 1) * 10) + kf_boost;
3121 }
3122 else
3123 {
3124 allocation_chunks =
3125 ((cpi->twopass.frames_to_key - 1) * 100) + kf_boost;
3126 }
3127
3128 /* Normalize Altboost and allocations chunck down to prevent overflow */
3129 while (kf_boost > 1000)
3130 {
3131 kf_boost /= 2;
3132 allocation_chunks /= 2;
3133 }
3134
3135 cpi->twopass.kf_group_bits = (cpi->twopass.kf_group_bits < 0) ? 0 : cpi->twopass.kf_group_bits;
3136
3137 /* Calculate the number of bits to be spent on the key frame */
3138 cpi->twopass.kf_bits = (int)((double)kf_boost * ((double)cpi->twopass.kf_group_bits / (double)allocation_chunks));
3139
3140 /* Apply an additional limit for CBR */
3141 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
3142 {
3143 if (cpi->twopass.kf_bits > (int)((3 * cpi->buffer_level) >> 2))
3144 cpi->twopass.kf_bits = (int)((3 * cpi->buffer_level) >> 2);
3145 }
3146
3147 /* If the key frame is actually easier than the average for the
3148 * kf group (which does sometimes happen... eg a blank intro frame)
3149 * Then use an alternate calculation based on the kf error score
3150 * which should give a smaller key frame.
3151 */
3152 if (kf_mod_err < kf_group_err / cpi->twopass.frames_to_key)
3153 {
3154 double alt_kf_grp_bits =
3155 ((double)cpi->twopass.bits_left *
3156 (kf_mod_err * (double)cpi->twopass.frames_to_key) /
3157 DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left));
3158
3159 alt_kf_bits = (int)((double)kf_boost *
3160 (alt_kf_grp_bits / (double)allocation_chunks));
3161
3162 if (cpi->twopass.kf_bits > alt_kf_bits)
3163 {
3164 cpi->twopass.kf_bits = alt_kf_bits;
3165 }
3166 }
3167 /* Else if it is much harder than other frames in the group make sure
3168 * it at least receives an allocation in keeping with its relative
3169 * error score
3170 */
3171 else
3172 {
3173 alt_kf_bits =
3174 (int)((double)cpi->twopass.bits_left *
3175 (kf_mod_err /
3176 DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left)));
3177
3178 if (alt_kf_bits > cpi->twopass.kf_bits)
3179 {
3180 cpi->twopass.kf_bits = alt_kf_bits;
3181 }
3182 }
3183
3184 cpi->twopass.kf_group_bits -= cpi->twopass.kf_bits;
3185 /* Add in the minimum frame allowance */
3186 cpi->twopass.kf_bits += cpi->min_frame_bandwidth;
3187
3188 /* Peer frame bit target for this frame */
3189 cpi->per_frame_bandwidth = cpi->twopass.kf_bits;
3190
3191 /* Convert to a per second bitrate */
3192 cpi->target_bandwidth = (int)(cpi->twopass.kf_bits *
3193 cpi->output_framerate);
3194 }
3195
3196 /* Note the total error score of the kf group minus the key frame itself */
3197 cpi->twopass.kf_group_error_left = (int)(kf_group_err - kf_mod_err);
3198
3199 /* Adjust the count of total modified error left. The count of bits left
3200 * is adjusted elsewhere based on real coded frame sizes
3201 */
3202 cpi->twopass.modified_error_left -= kf_group_err;
3203
3204 if (cpi->oxcf.allow_spatial_resampling)
3205 {
3206 int resample_trigger = 0;
3207 int last_kf_resampled = 0;
3208 int kf_q;
3209 int scale_val = 0;
3210 int hr, hs, vr, vs;
3211 int new_width = cpi->oxcf.Width;
3212 int new_height = cpi->oxcf.Height;
3213
3214 int projected_buffer_level = (int)cpi->buffer_level;
3215 int tmp_q;
3216
3217 double projected_bits_perframe;
3218 double group_iiratio = (kf_group_intra_err - first_frame.intra_error) / (kf_group_coded_err - first_frame.coded_error);
3219 double err_per_frame = kf_group_err / cpi->twopass.frames_to_key;
3220 double bits_per_frame;
3221 double av_bits_per_frame;
3222 double effective_size_ratio;
3223
3224 if ((cpi->common.Width != cpi->oxcf.Width) || (cpi->common.Height != cpi->oxcf.Height))
3225 last_kf_resampled = 1;
3226
3227 /* Set back to unscaled by defaults */
3228 cpi->common.horiz_scale = NORMAL;
3229 cpi->common.vert_scale = NORMAL;
3230
3231 /* Calculate Average bits per frame. */
3232 av_bits_per_frame = cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->framerate);
3233
3234 /* CBR... Use the clip average as the target for deciding resample */
3235 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
3236 {
3237 bits_per_frame = av_bits_per_frame;
3238 }
3239
3240 /* In VBR we want to avoid downsampling in easy section unless we
3241 * are under extreme pressure So use the larger of target bitrate
3242 * for this section or average bitrate for sequence
3243 */
3244 else
3245 {
3246 /* This accounts for how hard the section is... */
3247 bits_per_frame = (double)
3248 (cpi->twopass.kf_group_bits / cpi->twopass.frames_to_key);
3249
3250 /* Dont turn to resampling in easy sections just because they
3251 * have been assigned a small number of bits
3252 */
3253 if (bits_per_frame < av_bits_per_frame)
3254 bits_per_frame = av_bits_per_frame;
3255 }
3256
3257 /* bits_per_frame should comply with our minimum */
3258 if (bits_per_frame < (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100))
3259 bits_per_frame = (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100);
3260
3261 /* Work out if spatial resampling is necessary */
3262 kf_q = estimate_kf_group_q(cpi, err_per_frame,
3263 (int)bits_per_frame, group_iiratio);
3264
3265 /* If we project a required Q higher than the maximum allowed Q then
3266 * make a guess at the actual size of frames in this section
3267 */
3268 projected_bits_perframe = bits_per_frame;
3269 tmp_q = kf_q;
3270
3271 while (tmp_q > cpi->worst_quality)
3272 {
3273 projected_bits_perframe *= 1.04;
3274 tmp_q--;
3275 }
3276
3277 /* Guess at buffer level at the end of the section */
3278 projected_buffer_level = (int)
3279 (cpi->buffer_level - (int)
3280 ((projected_bits_perframe - av_bits_per_frame) *
3281 cpi->twopass.frames_to_key));
3282
3283 if (0)
3284 {
3285 FILE *f = fopen("Subsamle.stt", "a");
3286 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);
3287 fclose(f);
3288 }
3289
3290 /* The trigger for spatial resampling depends on the various
3291 * parameters such as whether we are streaming (CBR) or VBR.
3292 */
3293 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
3294 {
3295 /* Trigger resample if we are projected to fall below down
3296 * sample level or resampled last time and are projected to
3297 * remain below the up sample level
3298 */
3299 if ((projected_buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100)) ||
3300 (last_kf_resampled && (projected_buffer_level < (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))))
3301 resample_trigger = 1;
3302 else
3303 resample_trigger = 0;
3304 }
3305 else
3306 {
3307 int64_t clip_bits = (int64_t)(cpi->twopass.total_stats.count * cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->framerate));
3308 int64_t over_spend = cpi->oxcf.starting_buffer_level - cpi->buffer_level;
3309
3310 /* If triggered last time the threshold for triggering again is
3311 * reduced:
3312 *
3313 * Projected Q higher than allowed and Overspend > 5% of total
3314 * bits
3315 */
3316 if ((last_kf_resampled && (kf_q > cpi->worst_quality)) ||
3317 ((kf_q > cpi->worst_quality) &&
3318 (over_spend > clip_bits / 20)))
3319 resample_trigger = 1;
3320 else
3321 resample_trigger = 0;
3322
3323 }
3324
3325 if (resample_trigger)
3326 {
3327 while ((kf_q >= cpi->worst_quality) && (scale_val < 6))
3328 {
3329 scale_val ++;
3330
3331 cpi->common.vert_scale = vscale_lookup[scale_val];
3332 cpi->common.horiz_scale = hscale_lookup[scale_val];
3333
3334 Scale2Ratio(cpi->common.horiz_scale, &hr, &hs);
3335 Scale2Ratio(cpi->common.vert_scale, &vr, &vs);
3336
3337 new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs;
3338 new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs;
3339
3340 /* Reducing the area to 1/4 does not reduce the complexity
3341 * (err_per_frame) to 1/4... effective_sizeratio attempts
3342 * to provide a crude correction for this
3343 */
3344 effective_size_ratio = (double)(new_width * new_height) / (double)(cpi->oxcf.Width * cpi->oxcf.Height);
3345 effective_size_ratio = (1.0 + (3.0 * effective_size_ratio)) / 4.0;
3346
3347 /* Now try again and see what Q we get with the smaller
3348 * image size
3349 */
3350 kf_q = estimate_kf_group_q(cpi,
3351 err_per_frame * effective_size_ratio,
3352 (int)bits_per_frame, group_iiratio);
3353
3354 if (0)
3355 {
3356 FILE *f = fopen("Subsamle.stt", "a");
3357 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);
3358 fclose(f);
3359 }
3360 }
3361 }
3362
3363 if ((cpi->common.Width != new_width) || (cpi->common.Height != new_height))
3364 {
3365 cpi->common.Width = new_width;
3366 cpi->common.Height = new_height;
3367 vp8_alloc_compressor_data(cpi);
3368 }
3369 }
3370 }
3371