2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
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.
16 #include "encodeintra.h"
17 #include "vp8/common/setupintrarecon.h"
19 #include "vpx_scale/vpxscale.h"
21 #include "vp8/common/extend.h"
22 #include "vp8/common/systemdependent.h"
23 #include "vpx_scale/yv12extend.h"
24 #include "vpx_mem/vpx_mem.h"
25 #include "vp8/common/swapyv12buffer.h"
28 #include "vp8/common/quant_common.h"
31 //#define OUTPUT_FPF 1
33 #if CONFIG_RUNTIME_CPU_DETECT
34 #define IF_RTCD(x) (x)
36 #define IF_RTCD(x) NULL
39 extern void vp8_build_block_offsets(MACROBLOCK *x);
40 extern void vp8_setup_block_ptrs(MACROBLOCK *x);
41 extern void vp8cx_frame_init_quantizer(VP8_COMP *cpi);
42 extern void vp8_set_mbmode_and_mvs(MACROBLOCK *x, MB_PREDICTION_MODE mb, int_mv *mv);
43 extern void vp8_alloc_compressor_data(VP8_COMP *cpi);
45 //#define GFQ_ADJUSTMENT (40 + ((15*Q)/10))
46 //#define GFQ_ADJUSTMENT (80 + ((15*Q)/10))
47 #define GFQ_ADJUSTMENT vp8_gf_boost_qadjustment[Q]
48 extern int vp8_kf_boost_qadjustment[QINDEX_RANGE];
50 extern const int vp8_gf_boost_qadjustment[QINDEX_RANGE];
53 #define IIKFACTOR1 1.40
54 #define IIKFACTOR2 1.5
58 #define KF_MB_INTRA_MIN 300
59 #define GF_MB_INTRA_MIN 200
61 #define DOUBLE_DIVIDE_CHECK(X) ((X)<0?(X)-.000001:(X)+.000001)
63 #define POW1 (double)cpi->oxcf.two_pass_vbrbias/100.0
64 #define POW2 (double)cpi->oxcf.two_pass_vbrbias/100.0
66 static int vscale_lookup[7] = {0, 1, 1, 2, 2, 3, 3};
67 static int hscale_lookup[7] = {0, 0, 1, 1, 2, 2, 3};
70 static const int cq_level[QINDEX_RANGE] =
72 0,0,1,1,2,3,3,4,4,5,6,6,7,8,8,9,
73 9,10,11,11,12,13,13,14,15,15,16,17,17,18,19,20,
74 20,21,22,22,23,24,24,25,26,27,27,28,29,30,30,31,
75 32,33,33,34,35,36,36,37,38,39,39,40,41,42,42,43,
76 44,45,46,46,47,48,49,50,50,51,52,53,54,55,55,56,
77 57,58,59,60,60,61,62,63,64,65,66,67,67,68,69,70,
78 71,72,73,74,75,75,76,77,78,79,80,81,82,83,84,85,
79 86,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100
82 static void find_next_key_frame(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame);
84 // Resets the first pass file to the given position using a relative seek from the current position
85 static void reset_fpf_position(VP8_COMP *cpi, FIRSTPASS_STATS *Position)
87 cpi->twopass.stats_in = Position;
90 static int lookup_next_frame_stats(VP8_COMP *cpi, FIRSTPASS_STATS *next_frame)
92 if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end)
95 *next_frame = *cpi->twopass.stats_in;
99 // Calculate a modified Error used in distributing bits between easier and harder frames
100 static double calculate_modified_err(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
102 double av_err = cpi->twopass.total_stats->ssim_weighted_pred_err;
103 double this_err = this_frame->ssim_weighted_pred_err;
106 //double relative_next_iiratio;
107 //double next_iiratio;
108 //double sum_iiratio;
111 //FIRSTPASS_STATS next_frame;
112 //FIRSTPASS_STATS *start_pos;
114 /*start_pos = cpi->twopass.stats_in;
117 while ( (i < 1) && input_stats(cpi,&next_frame) != EOF )
120 next_iiratio = next_frame.intra_error / DOUBLE_DIVIDE_CHECK(next_frame.coded_error);
121 next_iiratio = ( next_iiratio < 1.0 ) ? 1.0 : (next_iiratio > 20.0) ? 20.0 : next_iiratio;
122 sum_iiratio += next_iiratio;
127 relative_next_iiratio = sum_iiratio / DOUBLE_DIVIDE_CHECK(cpi->twopass.avg_iiratio * (double)i);
131 relative_next_iiratio = 1.0;
133 reset_fpf_position(cpi, start_pos);*/
135 if (this_err > av_err)
136 modified_err = av_err * pow((this_err / DOUBLE_DIVIDE_CHECK(av_err)), POW1);
138 modified_err = av_err * pow((this_err / DOUBLE_DIVIDE_CHECK(av_err)), POW2);
141 relative_next_iiratio = pow(relative_next_iiratio,0.25);
142 modified_err = modified_err * relative_next_iiratio;
148 static const double weight_table[256] = {
149 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
150 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
151 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
152 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
153 0.020000, 0.031250, 0.062500, 0.093750, 0.125000, 0.156250, 0.187500, 0.218750,
154 0.250000, 0.281250, 0.312500, 0.343750, 0.375000, 0.406250, 0.437500, 0.468750,
155 0.500000, 0.531250, 0.562500, 0.593750, 0.625000, 0.656250, 0.687500, 0.718750,
156 0.750000, 0.781250, 0.812500, 0.843750, 0.875000, 0.906250, 0.937500, 0.968750,
157 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
158 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
159 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
160 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
161 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
162 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
163 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
164 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
165 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
166 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
167 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
168 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
169 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
170 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
171 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
172 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
173 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
174 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
175 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
176 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
177 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
178 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
179 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
180 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000
183 static double simple_weight(YV12_BUFFER_CONFIG *source)
187 unsigned char *src = source->y_buffer;
188 double sum_weights = 0.0;
190 // Loop throught the Y plane raw examining levels and creating a weight for the image
191 i = source->y_height;
197 sum_weights += weight_table[ *src];
200 src -= source->y_width;
201 src += source->y_stride;
204 sum_weights /= (source->y_height * source->y_width);
210 // This function returns the current per frame maximum bitrate target
211 static int frame_max_bits(VP8_COMP *cpi)
213 // Max allocation for a single frame based on the max section guidelines passed in and how many bits are left
216 // For CBR we need to also consider buffer fullness.
217 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
219 max_bits = 2 * cpi->av_per_frame_bandwidth;
220 max_bits -= cpi->buffered_av_per_frame_bandwidth;
221 max_bits *= ((double)cpi->oxcf.two_pass_vbrmax_section / 100.0);
226 // For VBR base this on the bits and frames left plus the two_pass_vbrmax_section rate passed in by the user
227 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));
230 // Trap case where we are out of bits
238 static int gf_group_max_bits(VP8_COMP *cpi)
240 // Max allocation for a golden frame group
243 // For CBR we need to also consider buffer fullness.
244 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
246 max_bits = cpi->av_per_frame_bandwidth * cpi->baseline_gf_interval;
247 if (max_bits > cpi->oxcf.optimal_buffer_level)
249 max_bits -= cpi->oxcf.optimal_buffer_level;
250 max_bits += cpi->buffer_level;
254 max_bits -= (cpi->buffered_av_per_frame_bandwidth
255 - cpi->av_per_frame_bandwidth)
256 * cpi->baseline_gf_interval;
259 max_bits *= ((double)cpi->oxcf.two_pass_vbrmax_section / 100.0);
263 // For VBR base this on the bits and frames left plus the two_pass_vbrmax_section rate passed in by the user
264 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));
265 max_bits *= cpi->baseline_gf_interval;
269 // Trap case where we are out of bits
277 static void output_stats(const VP8_COMP *cpi,
278 struct vpx_codec_pkt_list *pktlist,
279 FIRSTPASS_STATS *stats)
281 struct vpx_codec_cx_pkt pkt;
282 pkt.kind = VPX_CODEC_STATS_PKT;
283 pkt.data.twopass_stats.buf = stats;
284 pkt.data.twopass_stats.sz = sizeof(FIRSTPASS_STATS);
285 vpx_codec_pkt_list_add(pktlist, &pkt);
292 fpfile = fopen("firstpass.stt", "a");
294 fprintf(fpfile, "%12.0f %12.0f %12.0f %12.4f %12.4f %12.4f %12.4f"
295 " %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f"
300 stats->ssim_weighted_pred_err,
303 stats->pcnt_second_ref,
311 stats->mv_in_out_count,
319 static int input_stats(VP8_COMP *cpi, FIRSTPASS_STATS *fps)
321 if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end)
324 *fps = *cpi->twopass.stats_in;
325 cpi->twopass.stats_in =
326 (void*)((char *)cpi->twopass.stats_in + sizeof(FIRSTPASS_STATS));
330 static void zero_stats(FIRSTPASS_STATS *section)
332 section->frame = 0.0;
333 section->intra_error = 0.0;
334 section->coded_error = 0.0;
335 section->ssim_weighted_pred_err = 0.0;
336 section->pcnt_inter = 0.0;
337 section->pcnt_motion = 0.0;
338 section->pcnt_second_ref = 0.0;
339 section->pcnt_neutral = 0.0;
341 section->mvr_abs = 0.0;
343 section->mvc_abs = 0.0;
346 section->mv_in_out_count = 0.0;
347 section->count = 0.0;
348 section->duration = 1.0;
350 static void accumulate_stats(FIRSTPASS_STATS *section, FIRSTPASS_STATS *frame)
352 section->frame += frame->frame;
353 section->intra_error += frame->intra_error;
354 section->coded_error += frame->coded_error;
355 section->ssim_weighted_pred_err += frame->ssim_weighted_pred_err;
356 section->pcnt_inter += frame->pcnt_inter;
357 section->pcnt_motion += frame->pcnt_motion;
358 section->pcnt_second_ref += frame->pcnt_second_ref;
359 section->pcnt_neutral += frame->pcnt_neutral;
360 section->MVr += frame->MVr;
361 section->mvr_abs += frame->mvr_abs;
362 section->MVc += frame->MVc;
363 section->mvc_abs += frame->mvc_abs;
364 section->MVrv += frame->MVrv;
365 section->MVcv += frame->MVcv;
366 section->mv_in_out_count += frame->mv_in_out_count;
367 section->count += frame->count;
368 section->duration += frame->duration;
370 static void avg_stats(FIRSTPASS_STATS *section)
372 if (section->count < 1.0)
375 section->intra_error /= section->count;
376 section->coded_error /= section->count;
377 section->ssim_weighted_pred_err /= section->count;
378 section->pcnt_inter /= section->count;
379 section->pcnt_second_ref /= section->count;
380 section->pcnt_neutral /= section->count;
381 section->pcnt_motion /= section->count;
382 section->MVr /= section->count;
383 section->mvr_abs /= section->count;
384 section->MVc /= section->count;
385 section->mvc_abs /= section->count;
386 section->MVrv /= section->count;
387 section->MVcv /= section->count;
388 section->mv_in_out_count /= section->count;
389 section->duration /= section->count;
392 void vp8_init_first_pass(VP8_COMP *cpi)
394 zero_stats(cpi->twopass.total_stats);
397 void vp8_end_first_pass(VP8_COMP *cpi)
399 output_stats(cpi, cpi->output_pkt_list, cpi->twopass.total_stats);
402 static void zz_motion_search( VP8_COMP *cpi, MACROBLOCK * x, YV12_BUFFER_CONFIG * recon_buffer, int * best_motion_err, int recon_yoffset )
404 MACROBLOCKD * const xd = & x->e_mbd;
405 BLOCK *b = &x->block[0];
406 BLOCKD *d = &x->e_mbd.block[0];
408 unsigned char *src_ptr = (*(b->base_src) + b->src);
409 int src_stride = b->src_stride;
410 unsigned char *ref_ptr;
411 int ref_stride=d->pre_stride;
413 // Set up pointers for this macro block recon buffer
414 xd->pre.y_buffer = recon_buffer->y_buffer + recon_yoffset;
416 ref_ptr = (unsigned char *)(*(d->base_pre) + d->pre );
418 VARIANCE_INVOKE(IF_RTCD(&cpi->rtcd.variance), mse16x16) ( src_ptr, src_stride, ref_ptr, ref_stride, (unsigned int *)(best_motion_err));
421 static void first_pass_motion_search(VP8_COMP *cpi, MACROBLOCK *x,
422 int_mv *ref_mv, MV *best_mv,
423 YV12_BUFFER_CONFIG *recon_buffer,
424 int *best_motion_err, int recon_yoffset )
426 MACROBLOCKD *const xd = & x->e_mbd;
427 BLOCK *b = &x->block[0];
428 BLOCKD *d = &x->e_mbd.block[0];
434 int step_param = 3; //3; // Dont search over full range for first pass
435 int further_steps = (MAX_MVSEARCH_STEPS - 1) - step_param; //3;
437 vp8_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[BLOCK_16X16];
438 int new_mv_mode_penalty = 256;
440 // override the default variance function to use MSE
441 v_fn_ptr.vf = VARIANCE_INVOKE(IF_RTCD(&cpi->rtcd.variance), mse16x16);
443 // Set up pointers for this macro block recon buffer
444 xd->pre.y_buffer = recon_buffer->y_buffer + recon_yoffset;
446 // Initial step/diamond search centred on best mv
448 tmp_err = cpi->diamond_search_sad(x, b, d, ref_mv, &tmp_mv, step_param,
449 x->sadperbit16, &num00, &v_fn_ptr,
451 if ( tmp_err < INT_MAX-new_mv_mode_penalty )
452 tmp_err += new_mv_mode_penalty;
454 if (tmp_err < *best_motion_err)
456 *best_motion_err = tmp_err;
457 best_mv->row = tmp_mv.as_mv.row;
458 best_mv->col = tmp_mv.as_mv.col;
461 // Further step/diamond searches as necessary
465 while (n < further_steps)
473 tmp_err = cpi->diamond_search_sad(x, b, d, ref_mv, &tmp_mv,
474 step_param + n, x->sadperbit16,
475 &num00, &v_fn_ptr, x->mvcost,
477 if ( tmp_err < INT_MAX-new_mv_mode_penalty )
478 tmp_err += new_mv_mode_penalty;
480 if (tmp_err < *best_motion_err)
482 *best_motion_err = tmp_err;
483 best_mv->row = tmp_mv.as_mv.row;
484 best_mv->col = tmp_mv.as_mv.col;
490 void vp8_first_pass(VP8_COMP *cpi)
493 MACROBLOCK *const x = & cpi->mb;
494 VP8_COMMON *const cm = & cpi->common;
495 MACROBLOCKD *const xd = & x->e_mbd;
497 int recon_yoffset, recon_uvoffset;
498 YV12_BUFFER_CONFIG *lst_yv12 = &cm->yv12_fb[cm->lst_fb_idx];
499 YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
500 YV12_BUFFER_CONFIG *gld_yv12 = &cm->yv12_fb[cm->gld_fb_idx];
501 int recon_y_stride = lst_yv12->y_stride;
502 int recon_uv_stride = lst_yv12->uv_stride;
503 long long intra_error = 0;
504 long long coded_error = 0;
506 int sum_mvr = 0, sum_mvc = 0;
507 int sum_mvr_abs = 0, sum_mvc_abs = 0;
508 int sum_mvrs = 0, sum_mvcs = 0;
511 int second_ref_count = 0;
512 int intrapenalty = 256;
513 int neutral_count = 0;
515 int sum_in_vectors = 0;
519 zero_ref_mv.as_int = 0;
521 vp8_clear_system_state(); //__asm emms;
523 x->src = * cpi->Source;
527 x->partition_info = x->pi;
529 xd->mode_info_context = cm->mi;
531 vp8_build_block_offsets(x);
533 vp8_setup_block_dptrs(&x->e_mbd);
535 vp8_setup_block_ptrs(x);
537 // set up frame new frame for intra coded blocks
538 vp8_setup_intra_recon(new_yv12);
539 vp8cx_frame_init_quantizer(cpi);
541 // Initialise the MV cost table to the defaults
542 //if( cm->current_video_frame == 0)
545 int flag[2] = {1, 1};
546 vp8_initialize_rd_consts(cpi, vp8_dc_quant(cm->base_qindex, cm->y1dc_delta_q));
547 vpx_memcpy(cm->fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));
548 vp8_build_component_cost_table(cpi->mb.mvcost, (const MV_CONTEXT *) cm->fc.mvc, flag);
551 // for each macroblock row in image
552 for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
556 best_ref_mv.as_int = 0;
558 // reset above block coeffs
559 xd->up_available = (mb_row != 0);
560 recon_yoffset = (mb_row * recon_y_stride * 16);
561 recon_uvoffset = (mb_row * recon_uv_stride * 8);
563 // Set up limit values for motion vectors to prevent them extending outside the UMV borders
564 x->mv_row_min = -((mb_row * 16) + (VP8BORDERINPIXELS - 16));
565 x->mv_row_max = ((cm->mb_rows - 1 - mb_row) * 16) + (VP8BORDERINPIXELS - 16);
568 // for each macroblock col in image
569 for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
572 int gf_motion_error = INT_MAX;
573 int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
575 xd->dst.y_buffer = new_yv12->y_buffer + recon_yoffset;
576 xd->dst.u_buffer = new_yv12->u_buffer + recon_uvoffset;
577 xd->dst.v_buffer = new_yv12->v_buffer + recon_uvoffset;
578 xd->left_available = (mb_col != 0);
580 //Copy current mb to a buffer
581 RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer, x->src.y_stride, x->thismb, 16);
583 // do intra 16x16 prediction
584 this_error = vp8_encode_intra(cpi, x, use_dc_pred);
586 // "intrapenalty" below deals with situations where the intra and inter error scores are very low (eg a plain black frame)
587 // We do not have special cases in first pass for 0,0 and nearest etc so all inter modes carry an overhead cost estimate fot the mv.
588 // When the error score is very low this causes us to pick all or lots of INTRA modes and throw lots of key frames.
589 // This penalty adds a cost matching that of a 0,0 mv to the intra case.
590 this_error += intrapenalty;
592 // Cumulative intra error total
593 intra_error += (long long)this_error;
595 // Set up limit values for motion vectors to prevent them extending outside the UMV borders
596 x->mv_col_min = -((mb_col * 16) + (VP8BORDERINPIXELS - 16));
597 x->mv_col_max = ((cm->mb_cols - 1 - mb_col) * 16) + (VP8BORDERINPIXELS - 16);
599 // Other than for the first frame do a motion search
600 if (cm->current_video_frame > 0)
602 BLOCKD *d = &x->e_mbd.block[0];
605 int motion_error = INT_MAX;
607 // Simple 0,0 motion with no mv overhead
608 zz_motion_search( cpi, x, lst_yv12, &motion_error, recon_yoffset );
609 d->bmi.mv.as_mv.row = 0;
610 d->bmi.mv.as_mv.col = 0;
612 // Test last reference frame using the previous best mv as the
613 // starting point (best reference) for the search
614 first_pass_motion_search(cpi, x, &best_ref_mv,
615 &d->bmi.mv.as_mv, lst_yv12,
616 &motion_error, recon_yoffset);
618 // If the current best reference mv is not centred on 0,0 then do a 0,0 based search as well
619 if (best_ref_mv.as_int)
622 first_pass_motion_search(cpi, x, &zero_ref_mv, &tmp_mv,
623 lst_yv12, &tmp_err, recon_yoffset);
625 if ( tmp_err < motion_error )
627 motion_error = tmp_err;
628 d->bmi.mv.as_mv.row = tmp_mv.row;
629 d->bmi.mv.as_mv.col = tmp_mv.col;
633 // Experimental search in a second reference frame ((0,0) based only)
634 if (cm->current_video_frame > 1)
636 first_pass_motion_search(cpi, x, &zero_ref_mv, &tmp_mv, gld_yv12, &gf_motion_error, recon_yoffset);
638 if ((gf_motion_error < motion_error) && (gf_motion_error < this_error))
641 //motion_error = gf_motion_error;
642 //d->bmi.mv.as_mv.row = tmp_mv.row;
643 //d->bmi.mv.as_mv.col = tmp_mv.col;
647 xd->pre.y_buffer = cm->last_frame.y_buffer + recon_yoffset;
648 xd->pre.u_buffer = cm->last_frame.u_buffer + recon_uvoffset;
649 xd->pre.v_buffer = cm->last_frame.v_buffer + recon_uvoffset;
653 // Reset to last frame as reference buffer
654 xd->pre.y_buffer = lst_yv12->y_buffer + recon_yoffset;
655 xd->pre.u_buffer = lst_yv12->u_buffer + recon_uvoffset;
656 xd->pre.v_buffer = lst_yv12->v_buffer + recon_uvoffset;
659 /* Intra assumed best */
660 best_ref_mv.as_int = 0;
662 if (motion_error <= this_error)
664 // Keep a count of cases where the inter and intra were
665 // very close and very low. This helps with scene cut
666 // detection for example in cropped clips with black bars
667 // at the sides or top and bottom.
668 if( (((this_error-intrapenalty) * 9) <=
669 (motion_error*10)) &&
670 (this_error < (2*intrapenalty)) )
675 d->bmi.mv.as_mv.row <<= 3;
676 d->bmi.mv.as_mv.col <<= 3;
677 this_error = motion_error;
678 vp8_set_mbmode_and_mvs(x, NEWMV, &d->bmi.mv);
679 vp8_encode_inter16x16y(IF_RTCD(&cpi->rtcd), x);
680 sum_mvr += d->bmi.mv.as_mv.row;
681 sum_mvr_abs += abs(d->bmi.mv.as_mv.row);
682 sum_mvc += d->bmi.mv.as_mv.col;
683 sum_mvc_abs += abs(d->bmi.mv.as_mv.col);
684 sum_mvrs += d->bmi.mv.as_mv.row * d->bmi.mv.as_mv.row;
685 sum_mvcs += d->bmi.mv.as_mv.col * d->bmi.mv.as_mv.col;
688 best_ref_mv.as_int = d->bmi.mv.as_int;
690 // Was the vector non-zero
691 if (d->bmi.mv.as_int)
695 // Does the Row vector point inwards or outwards
696 if (mb_row < cm->mb_rows / 2)
698 if (d->bmi.mv.as_mv.row > 0)
700 else if (d->bmi.mv.as_mv.row < 0)
703 else if (mb_row > cm->mb_rows / 2)
705 if (d->bmi.mv.as_mv.row > 0)
707 else if (d->bmi.mv.as_mv.row < 0)
711 // Does the Row vector point inwards or outwards
712 if (mb_col < cm->mb_cols / 2)
714 if (d->bmi.mv.as_mv.col > 0)
716 else if (d->bmi.mv.as_mv.col < 0)
719 else if (mb_col > cm->mb_cols / 2)
721 if (d->bmi.mv.as_mv.col > 0)
723 else if (d->bmi.mv.as_mv.col < 0)
730 coded_error += (long long)this_error;
732 // adjust to the next column of macroblocks
733 x->src.y_buffer += 16;
734 x->src.u_buffer += 8;
735 x->src.v_buffer += 8;
741 // adjust to the next row of mbs
742 x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
743 x->src.u_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
744 x->src.v_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
746 //extend the recon for intra prediction
747 vp8_extend_mb_row(new_yv12, xd->dst.y_buffer + 16, xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
748 vp8_clear_system_state(); //__asm emms;
751 vp8_clear_system_state(); //__asm emms;
757 fps.frame = cm->current_video_frame ;
758 fps.intra_error = intra_error >> 8;
759 fps.coded_error = coded_error >> 8;
760 weight = simple_weight(cpi->Source);
766 fps.ssim_weighted_pred_err = fps.coded_error * weight;
768 fps.pcnt_inter = 0.0;
769 fps.pcnt_motion = 0.0;
776 fps.mv_in_out_count = 0.0;
779 fps.pcnt_inter = 1.0 * (double)intercount / cm->MBs;
780 fps.pcnt_second_ref = 1.0 * (double)second_ref_count / cm->MBs;
781 fps.pcnt_neutral = 1.0 * (double)neutral_count / cm->MBs;
785 fps.MVr = (double)sum_mvr / (double)mvcount;
786 fps.mvr_abs = (double)sum_mvr_abs / (double)mvcount;
787 fps.MVc = (double)sum_mvc / (double)mvcount;
788 fps.mvc_abs = (double)sum_mvc_abs / (double)mvcount;
789 fps.MVrv = ((double)sum_mvrs - (fps.MVr * fps.MVr / (double)mvcount)) / (double)mvcount;
790 fps.MVcv = ((double)sum_mvcs - (fps.MVc * fps.MVc / (double)mvcount)) / (double)mvcount;
791 fps.mv_in_out_count = (double)sum_in_vectors / (double)(mvcount * 2);
793 fps.pcnt_motion = 1.0 * (double)mvcount / cpi->common.MBs;
796 // TODO: handle the case when duration is set to 0, or something less
797 // than the full time between subsequent cpi->source_time_stamp s .
798 fps.duration = cpi->source->ts_end
799 - cpi->source->ts_start;
801 // don't want to do output stats with a stack variable!
802 memcpy(cpi->twopass.this_frame_stats,
804 sizeof(FIRSTPASS_STATS));
805 output_stats(cpi, cpi->output_pkt_list, cpi->twopass.this_frame_stats);
806 accumulate_stats(cpi->twopass.total_stats, &fps);
809 // Copy the previous Last Frame into the GF buffer if specific conditions for doing so are met
810 if ((cm->current_video_frame > 0) &&
811 (cpi->twopass.this_frame_stats->pcnt_inter > 0.20) &&
812 ((cpi->twopass.this_frame_stats->intra_error / cpi->twopass.this_frame_stats->coded_error) > 2.0))
814 vp8_yv12_copy_frame_ptr(lst_yv12, gld_yv12);
817 // swap frame pointers so last frame refers to the frame we just compressed
818 vp8_swap_yv12_buffer(lst_yv12, new_yv12);
819 vp8_yv12_extend_frame_borders(lst_yv12);
821 // Special case for the first frame. Copy into the GF buffer as a second reference.
822 if (cm->current_video_frame == 0)
824 vp8_yv12_copy_frame_ptr(lst_yv12, gld_yv12);
828 // use this to see what the first pass reconstruction looks like
833 sprintf(filename, "enc%04d.yuv", (int) cm->current_video_frame);
835 if (cm->current_video_frame == 0)
836 recon_file = fopen(filename, "wb");
838 recon_file = fopen(filename, "ab");
840 if(fwrite(lst_yv12->buffer_alloc, lst_yv12->frame_size, 1, recon_file));
844 cm->current_video_frame++;
847 extern const int vp8_bits_per_mb[2][QINDEX_RANGE];
849 #define BASE_ERRPERMB 150
850 static int estimate_max_q(VP8_COMP *cpi, double section_err, int section_target_bandwitdh)
853 int num_mbs = cpi->common.MBs;
854 int target_norm_bits_per_mb;
856 double err_per_mb = section_err / num_mbs;
857 double correction_factor;
859 double speed_correction = 1.0;
860 double rolling_ratio;
862 double pow_highq = 0.90;
863 double pow_lowq = 0.40;
865 if (section_target_bandwitdh <= 0)
866 return cpi->twopass.maxq_max_limit; // Highest value allowed
868 target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20)) ? (512 * section_target_bandwitdh) / num_mbs : 512 * (section_target_bandwitdh / num_mbs);
870 // Calculate a corrective factor based on a rolling ratio of bits spent vs target bits
871 if ((cpi->rolling_target_bits > 0.0) && (cpi->active_worst_quality < cpi->worst_quality))
873 rolling_ratio = (double)cpi->rolling_actual_bits / (double)cpi->rolling_target_bits;
875 //if ( cpi->twopass.est_max_qcorrection_factor > rolling_ratio )
876 if (rolling_ratio < 0.95)
877 //cpi->twopass.est_max_qcorrection_factor *= adjustment_rate;
878 cpi->twopass.est_max_qcorrection_factor -= 0.005;
879 //else if ( cpi->twopass.est_max_qcorrection_factor < rolling_ratio )
880 else if (rolling_ratio > 1.05)
881 cpi->twopass.est_max_qcorrection_factor += 0.005;
883 //cpi->twopass.est_max_qcorrection_factor /= adjustment_rate;
885 cpi->twopass.est_max_qcorrection_factor = (cpi->twopass.est_max_qcorrection_factor < 0.1) ? 0.1 : (cpi->twopass.est_max_qcorrection_factor > 10.0) ? 10.0 : cpi->twopass.est_max_qcorrection_factor;
888 // Corrections for higher compression speed settings (reduced compression expected)
889 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1))
891 if (cpi->oxcf.cpu_used <= 5)
892 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
894 speed_correction = 1.25;
897 // Correction factor used for Q values >= 20
898 corr_high = pow(err_per_mb / BASE_ERRPERMB, pow_highq);
899 corr_high = (corr_high < 0.05)
900 ? 0.05 : (corr_high > 5.0) ? 5.0 : corr_high;
902 // Try and pick a max Q that will be high enough to encode the
903 // content at the given rate.
904 for (Q = cpi->twopass.maxq_min_limit; Q < cpi->twopass.maxq_max_limit; Q++)
906 int bits_per_mb_at_this_q;
910 correction_factor = pow(err_per_mb / BASE_ERRPERMB, (pow_lowq + Q * 0.01));
911 correction_factor = (correction_factor < 0.05) ? 0.05 : (correction_factor > 5.0) ? 5.0 : correction_factor;
914 correction_factor = corr_high;
916 bits_per_mb_at_this_q = (int)(.5 + correction_factor
917 * speed_correction * cpi->twopass.est_max_qcorrection_factor
918 * cpi->twopass.section_max_qfactor
919 * (double)vp8_bits_per_mb[INTER_FRAME][Q] / 1.0);
920 //bits_per_mb_at_this_q = (int)(.5 + correction_factor * speed_correction * cpi->twopass.est_max_qcorrection_factor * (double)vp8_bits_per_mb[INTER_FRAME][Q] / 1.0);
922 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb)
926 // Restriction on active max q for constrained quality mode.
927 if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
928 (Q < cpi->cq_target_quality) )
929 //(Q < cpi->oxcf.cq_level;) )
931 Q = cpi->cq_target_quality;
932 //Q = cpi->oxcf.cq_level;
935 // Adjust maxq_min_limit and maxq_max_limit limits based on
936 // averaga q observed in clip for non kf/gf.arf frames
937 // Give average a chance to settle though.
938 if ( (cpi->ni_frames >
939 ((unsigned int)cpi->twopass.total_stats->count >> 8)) &&
940 (cpi->ni_frames > 150) )
942 cpi->twopass.maxq_max_limit = ((cpi->ni_av_qi + 32) < cpi->worst_quality)
943 ? (cpi->ni_av_qi + 32) : cpi->worst_quality;
944 cpi->twopass.maxq_min_limit = ((cpi->ni_av_qi - 32) > cpi->best_quality)
945 ? (cpi->ni_av_qi - 32) : cpi->best_quality;
950 static int estimate_q(VP8_COMP *cpi, double section_err, int section_target_bandwitdh)
953 int num_mbs = cpi->common.MBs;
954 int target_norm_bits_per_mb;
956 double err_per_mb = section_err / num_mbs;
957 double correction_factor;
959 double speed_correction = 1.0;
960 double pow_highq = 0.90;
961 double pow_lowq = 0.40;
963 target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20)) ? (512 * section_target_bandwitdh) / num_mbs : 512 * (section_target_bandwitdh / num_mbs);
965 // Corrections for higher compression speed settings (reduced compression expected)
966 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1))
968 if (cpi->oxcf.cpu_used <= 5)
969 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
971 speed_correction = 1.25;
974 // Correction factor used for Q values >= 20
975 corr_high = pow(err_per_mb / BASE_ERRPERMB, pow_highq);
976 corr_high = (corr_high < 0.05) ? 0.05 : (corr_high > 5.0) ? 5.0 : corr_high;
978 // Try and pick a Q that can encode the content at the given rate.
979 for (Q = 0; Q < MAXQ; Q++)
981 int bits_per_mb_at_this_q;
985 correction_factor = pow(err_per_mb / BASE_ERRPERMB, (pow_lowq + Q * 0.01));
986 correction_factor = (correction_factor < 0.05) ? 0.05 : (correction_factor > 5.0) ? 5.0 : correction_factor;
989 correction_factor = corr_high;
991 bits_per_mb_at_this_q = (int)(.5 + correction_factor * speed_correction * cpi->twopass.est_max_qcorrection_factor * (double)vp8_bits_per_mb[INTER_FRAME][Q] / 1.0);
993 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb)
1000 // Estimate a worst case Q for a KF group
1001 static int estimate_kf_group_q(VP8_COMP *cpi, double section_err, int section_target_bandwitdh, double group_iiratio)
1004 int num_mbs = cpi->common.MBs;
1005 int target_norm_bits_per_mb = (512 * section_target_bandwitdh) / num_mbs;
1006 int bits_per_mb_at_this_q;
1008 double err_per_mb = section_err / num_mbs;
1009 double err_correction_factor;
1011 double speed_correction = 1.0;
1012 double current_spend_ratio = 1.0;
1014 double pow_highq = (POW1 < 0.6) ? POW1 + 0.3 : 0.90;
1015 double pow_lowq = (POW1 < 0.7) ? POW1 + 0.1 : 0.80;
1017 double iiratio_correction_factor = 1.0;
1019 double combined_correction_factor;
1021 // Trap special case where the target is <= 0
1022 if (target_norm_bits_per_mb <= 0)
1025 // Calculate a corrective factor based on a rolling ratio of bits spent vs target bits
1026 // This is clamped to the range 0.1 to 10.0
1027 if (cpi->long_rolling_target_bits <= 0)
1028 current_spend_ratio = 10.0;
1031 current_spend_ratio = (double)cpi->long_rolling_actual_bits / (double)cpi->long_rolling_target_bits;
1032 current_spend_ratio = (current_spend_ratio > 10.0) ? 10.0 : (current_spend_ratio < 0.1) ? 0.1 : current_spend_ratio;
1035 // Calculate a correction factor based on the quality of prediction in the sequence as indicated by intra_inter error score ratio (IIRatio)
1036 // The idea here is to favour subsampling in the hardest sections vs the easyest.
1037 iiratio_correction_factor = 1.0 - ((group_iiratio - 6.0) * 0.1);
1039 if (iiratio_correction_factor < 0.5)
1040 iiratio_correction_factor = 0.5;
1042 // Corrections for higher compression speed settings (reduced compression expected)
1043 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1))
1045 if (cpi->oxcf.cpu_used <= 5)
1046 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
1048 speed_correction = 1.25;
1051 // Combine the various factors calculated above
1052 combined_correction_factor = speed_correction * iiratio_correction_factor * current_spend_ratio;
1054 // Correction factor used for Q values >= 20
1055 corr_high = pow(err_per_mb / BASE_ERRPERMB, pow_highq);
1056 corr_high = (corr_high < 0.05) ? 0.05 : (corr_high > 5.0) ? 5.0 : corr_high;
1058 // Try and pick a Q that should be high enough to encode the content at the given rate.
1059 for (Q = 0; Q < MAXQ; Q++)
1061 // Q values < 20 treated as a special case
1064 err_correction_factor = pow(err_per_mb / BASE_ERRPERMB, (pow_lowq + Q * 0.01));
1065 err_correction_factor = (err_correction_factor < 0.05) ? 0.05 : (err_correction_factor > 5.0) ? 5.0 : err_correction_factor;
1068 err_correction_factor = corr_high;
1070 bits_per_mb_at_this_q = (int)(.5 + err_correction_factor * combined_correction_factor * (double)vp8_bits_per_mb[INTER_FRAME][Q]);
1072 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb)
1076 // If we could not hit the target even at Max Q then estimate what Q would have bee required
1077 while ((bits_per_mb_at_this_q > target_norm_bits_per_mb) && (Q < (MAXQ * 2)))
1080 bits_per_mb_at_this_q = (int)(0.96 * bits_per_mb_at_this_q);
1086 FILE *f = fopen("estkf_q.stt", "a");
1087 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,
1088 target_norm_bits_per_mb, err_per_mb, err_correction_factor,
1089 current_spend_ratio, group_iiratio, iiratio_correction_factor,
1090 (double)cpi->buffer_level / (double)cpi->oxcf.optimal_buffer_level, Q);
1097 // For cq mode estimate a cq level that matches the observed
1098 // complexity and data rate.
1099 static int estimate_cq(VP8_COMP *cpi, double section_err, int section_target_bandwitdh)
1102 int num_mbs = cpi->common.MBs;
1103 int target_norm_bits_per_mb;
1105 double err_per_mb = section_err / num_mbs;
1106 double correction_factor;
1108 double speed_correction = 1.0;
1109 double pow_highq = 0.90;
1110 double pow_lowq = 0.40;
1111 double clip_iiratio;
1112 double clip_iifactor;
1114 target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20))
1115 ? (512 * section_target_bandwitdh) / num_mbs
1116 : 512 * (section_target_bandwitdh / num_mbs);
1118 // Corrections for higher compression speed settings
1119 // (reduced compression expected)
1120 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1))
1122 if (cpi->oxcf.cpu_used <= 5)
1123 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
1125 speed_correction = 1.25;
1127 // II ratio correction factor for clip as a whole
1128 clip_iiratio = cpi->twopass.total_stats->intra_error /
1129 DOUBLE_DIVIDE_CHECK(cpi->twopass.total_stats->coded_error);
1130 clip_iifactor = 1.0 - ((clip_iiratio - 10.0) * 0.025);
1131 if (clip_iifactor < 0.80)
1132 clip_iifactor = 0.80;
1134 // Correction factor used for Q values >= 20
1135 corr_high = pow(err_per_mb / BASE_ERRPERMB, pow_highq);
1136 corr_high = (corr_high < 0.05) ? 0.05 : (corr_high > 5.0) ? 5.0 : corr_high;
1138 // Try and pick a Q that can encode the content at the given rate.
1139 for (Q = 0; Q < MAXQ; Q++)
1141 int bits_per_mb_at_this_q;
1146 pow( err_per_mb / BASE_ERRPERMB, (pow_lowq + Q * 0.01));
1148 correction_factor = (correction_factor < 0.05) ? 0.05
1149 : (correction_factor > 5.0) ? 5.0
1150 : correction_factor;
1153 correction_factor = corr_high;
1155 bits_per_mb_at_this_q =
1156 (int)( .5 + correction_factor *
1159 (double)vp8_bits_per_mb[INTER_FRAME][Q] / 1.0);
1161 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb)
1168 extern void vp8_new_frame_rate(VP8_COMP *cpi, double framerate);
1170 void vp8_init_second_pass(VP8_COMP *cpi)
1172 FIRSTPASS_STATS this_frame;
1173 FIRSTPASS_STATS *start_pos;
1175 double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100);
1177 zero_stats(cpi->twopass.total_stats);
1179 if (!cpi->twopass.stats_in_end)
1182 *cpi->twopass.total_stats = *cpi->twopass.stats_in_end;
1184 cpi->twopass.total_error_left = cpi->twopass.total_stats->ssim_weighted_pred_err;
1185 cpi->twopass.total_intra_error_left = cpi->twopass.total_stats->intra_error;
1186 cpi->twopass.total_coded_error_left = cpi->twopass.total_stats->coded_error;
1187 cpi->twopass.start_tot_err_left = cpi->twopass.total_error_left;
1189 //cpi->twopass.bits_left = (long long)(cpi->twopass.total_stats->count * cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.frame_rate));
1190 //cpi->twopass.bits_left -= (long long)(cpi->twopass.total_stats->count * two_pass_min_rate / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.frame_rate));
1192 // each frame can have a different duration, as the frame rate in the source
1193 // isn't guaranteed to be constant. The frame rate prior to the first frame
1194 // encoded in the second pass is a guess. However the sum duration is not.
1195 // Its calculated based on the actual durations of all frames from the first
1197 vp8_new_frame_rate(cpi, 10000000.0 * cpi->twopass.total_stats->count / cpi->twopass.total_stats->duration);
1199 cpi->output_frame_rate = cpi->oxcf.frame_rate;
1200 cpi->twopass.bits_left = (long long)(cpi->twopass.total_stats->duration * cpi->oxcf.target_bandwidth / 10000000.0) ;
1201 cpi->twopass.bits_left -= (long long)(cpi->twopass.total_stats->duration * two_pass_min_rate / 10000000.0);
1202 cpi->twopass.clip_bits_total = cpi->twopass.bits_left;
1204 // Calculate a minimum intra value to be used in determining the IIratio
1205 // scores used in the second pass. We have this minimum to make sure
1206 // that clips that are static but "low complexity" in the intra domain
1207 // are still boosted appropriately for KF/GF/ARF
1208 cpi->twopass.kf_intra_err_min = KF_MB_INTRA_MIN * cpi->common.MBs;
1209 cpi->twopass.gf_intra_err_min = GF_MB_INTRA_MIN * cpi->common.MBs;
1211 avg_stats(cpi->twopass.total_stats);
1213 // Scan the first pass file and calculate an average Intra / Inter error score ratio for the sequence
1215 double sum_iiratio = 0.0;
1218 start_pos = cpi->twopass.stats_in; // Note starting "file" position
1220 while (input_stats(cpi, &this_frame) != EOF)
1222 IIRatio = this_frame.intra_error / DOUBLE_DIVIDE_CHECK(this_frame.coded_error);
1223 IIRatio = (IIRatio < 1.0) ? 1.0 : (IIRatio > 20.0) ? 20.0 : IIRatio;
1224 sum_iiratio += IIRatio;
1227 cpi->twopass.avg_iiratio = sum_iiratio / DOUBLE_DIVIDE_CHECK((double)cpi->twopass.total_stats->count);
1229 // Reset file position
1230 reset_fpf_position(cpi, start_pos);
1233 // Scan the first pass file and calculate a modified total error based upon the bias/power function
1234 // used to allocate bits
1236 start_pos = cpi->twopass.stats_in; // Note starting "file" position
1238 cpi->twopass.modified_error_total = 0.0;
1239 cpi->twopass.modified_error_used = 0.0;
1241 while (input_stats(cpi, &this_frame) != EOF)
1243 cpi->twopass.modified_error_total += calculate_modified_err(cpi, &this_frame);
1245 cpi->twopass.modified_error_left = cpi->twopass.modified_error_total;
1247 reset_fpf_position(cpi, start_pos); // Reset file position
1252 void vp8_end_second_pass(VP8_COMP *cpi)
1256 // This function gives and estimate of how badly we believe
1257 // the prediction quality is decaying from frame to frame.
1258 static double get_prediction_decay_rate(VP8_COMP *cpi, FIRSTPASS_STATS *next_frame)
1260 double prediction_decay_rate;
1261 double motion_decay;
1262 double motion_pct = next_frame->pcnt_motion;
1265 // Initial basis is the % mbs inter coded
1266 prediction_decay_rate = next_frame->pcnt_inter;
1268 // High % motion -> somewhat higher decay rate
1269 motion_decay = (1.0 - (motion_pct / 20.0));
1270 if (motion_decay < prediction_decay_rate)
1271 prediction_decay_rate = motion_decay;
1273 // Adjustment to decay rate based on speed of motion
1275 double this_mv_rabs;
1276 double this_mv_cabs;
1277 double distance_factor;
1279 this_mv_rabs = fabs(next_frame->mvr_abs * motion_pct);
1280 this_mv_cabs = fabs(next_frame->mvc_abs * motion_pct);
1282 distance_factor = sqrt((this_mv_rabs * this_mv_rabs) +
1283 (this_mv_cabs * this_mv_cabs)) / 250.0;
1284 distance_factor = ((distance_factor > 1.0)
1285 ? 0.0 : (1.0 - distance_factor));
1286 if (distance_factor < prediction_decay_rate)
1287 prediction_decay_rate = distance_factor;
1290 return prediction_decay_rate;
1293 // Function to test for a condition where a complex transition is followed
1294 // by a static section. For example in slide shows where there is a fade
1295 // between slides. This is to help with more optimal kf and gf positioning.
1296 static int detect_transition_to_still(
1300 double loop_decay_rate,
1301 double decay_accumulator )
1303 BOOL trans_to_still = FALSE;
1305 // Break clause to detect very still sections after motion
1306 // For example a static image after a fade or other transition
1307 // instead of a clean scene cut.
1308 if ( (frame_interval > MIN_GF_INTERVAL) &&
1309 (loop_decay_rate >= 0.999) &&
1310 (decay_accumulator < 0.9) )
1313 FIRSTPASS_STATS * position = cpi->twopass.stats_in;
1314 FIRSTPASS_STATS tmp_next_frame;
1317 // Look ahead a few frames to see if static condition
1319 for ( j = 0; j < still_interval; j++ )
1321 if (EOF == input_stats(cpi, &tmp_next_frame))
1324 decay_rate = get_prediction_decay_rate(cpi, &tmp_next_frame);
1325 if ( decay_rate < 0.999 )
1328 // Reset file position
1329 reset_fpf_position(cpi, position);
1331 // Only if it does do we signal a transition to still
1332 if ( j == still_interval )
1333 trans_to_still = TRUE;
1336 return trans_to_still;
1339 // Analyse and define a gf/arf group .
1340 static void define_gf_group(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
1342 FIRSTPASS_STATS next_frame;
1343 FIRSTPASS_STATS *start_pos;
1345 double boost_score = 0.0;
1346 double old_boost_score = 0.0;
1347 double gf_group_err = 0.0;
1348 double gf_first_frame_err = 0.0;
1349 double mod_frame_err = 0.0;
1351 double mv_accumulator_rabs = 0.0;
1352 double mv_accumulator_cabs = 0.0;
1353 double mv_ratio_accumulator = 0.0;
1354 double decay_accumulator = 1.0;
1356 double boost_factor = IIFACTOR;
1357 double loop_decay_rate = 1.00; // Starting decay rate
1359 double this_frame_mv_in_out = 0.0;
1360 double mv_in_out_accumulator = 0.0;
1361 double abs_mv_in_out_accumulator = 0.0;
1362 double mod_err_per_mb_accumulator = 0.0;
1366 unsigned int allow_alt_ref =
1367 cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames;
1369 cpi->twopass.gf_group_bits = 0;
1370 cpi->twopass.gf_decay_rate = 0;
1372 vp8_clear_system_state(); //__asm emms;
1374 start_pos = cpi->twopass.stats_in;
1376 vpx_memset(&next_frame, 0, sizeof(next_frame)); // assure clean
1378 // Preload the stats for the next frame.
1379 mod_frame_err = calculate_modified_err(cpi, this_frame);
1381 // Note the error of the frame at the start of the group (this will be
1382 // the GF frame error if we code a normal gf
1383 gf_first_frame_err = mod_frame_err;
1385 // Special treatment if the current frame is a key frame (which is also
1386 // a gf). If it is then its error score (and hence bit allocation) need
1387 // to be subtracted out from the calculation for the GF group
1388 if (cpi->common.frame_type == KEY_FRAME)
1389 gf_group_err -= gf_first_frame_err;
1391 // Scan forward to try and work out how many frames the next gf group
1392 // should contain and what level of boost is appropriate for the GF
1393 // or ARF that will be coded with the group
1396 while (((i < cpi->twopass.static_scene_max_gf_interval) ||
1397 ((cpi->twopass.frames_to_key - i) < MIN_GF_INTERVAL)) &&
1398 (i < cpi->twopass.frames_to_key))
1401 double this_frame_mvr_ratio;
1402 double this_frame_mvc_ratio;
1403 //double motion_pct = next_frame.pcnt_motion;
1406 i++; // Increment the loop counter
1408 // Accumulate error score of frames in this gf group
1409 mod_frame_err = calculate_modified_err(cpi, this_frame);
1411 gf_group_err += mod_frame_err;
1413 mod_err_per_mb_accumulator +=
1414 mod_frame_err / DOUBLE_DIVIDE_CHECK((double)cpi->common.MBs);
1416 if (EOF == input_stats(cpi, &next_frame))
1419 // Accumulate motion stats.
1420 motion_pct = next_frame.pcnt_motion;
1421 mv_accumulator_rabs += fabs(next_frame.mvr_abs * motion_pct);
1422 mv_accumulator_cabs += fabs(next_frame.mvc_abs * motion_pct);
1424 //Accumulate Motion In/Out of frame stats
1425 this_frame_mv_in_out =
1426 next_frame.mv_in_out_count * motion_pct;
1427 mv_in_out_accumulator +=
1428 next_frame.mv_in_out_count * motion_pct;
1429 abs_mv_in_out_accumulator +=
1430 fabs(next_frame.mv_in_out_count * motion_pct);
1432 // If there is a significant amount of motion
1433 if (motion_pct > 0.05)
1435 this_frame_mvr_ratio = fabs(next_frame.mvr_abs) /
1436 DOUBLE_DIVIDE_CHECK(fabs(next_frame.MVr));
1438 this_frame_mvc_ratio = fabs(next_frame.mvc_abs) /
1439 DOUBLE_DIVIDE_CHECK(fabs(next_frame.MVc));
1441 mv_ratio_accumulator +=
1442 (this_frame_mvr_ratio < next_frame.mvr_abs)
1443 ? (this_frame_mvr_ratio * motion_pct)
1444 : next_frame.mvr_abs * motion_pct;
1446 mv_ratio_accumulator +=
1447 (this_frame_mvc_ratio < next_frame.mvc_abs)
1448 ? (this_frame_mvc_ratio * motion_pct)
1449 : next_frame.mvc_abs * motion_pct;
1453 mv_ratio_accumulator += 0.0;
1454 this_frame_mvr_ratio = 1.0;
1455 this_frame_mvc_ratio = 1.0;
1458 // Underlying boost factor is based on inter intra error ratio
1459 r = ( boost_factor *
1460 ( next_frame.intra_error /
1461 DOUBLE_DIVIDE_CHECK(next_frame.coded_error)));
1463 if (next_frame.intra_error > cpi->twopass.gf_intra_err_min)
1464 r = (IIKFACTOR2 * next_frame.intra_error /
1465 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
1467 r = (IIKFACTOR2 * cpi->twopass.gf_intra_err_min /
1468 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
1470 // Increase boost for frames where new data coming into frame
1471 // (eg zoom out). Slightly reduce boost if there is a net balance
1472 // of motion out of the frame (zoom in).
1473 // The range for this_frame_mv_in_out is -1.0 to +1.0
1474 if (this_frame_mv_in_out > 0.0)
1475 r += r * (this_frame_mv_in_out * 2.0);
1476 // In extreme case boost is halved
1478 r += r * (this_frame_mv_in_out / 2.0);
1483 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
1485 // Cumulative effect of decay
1486 decay_accumulator = decay_accumulator * loop_decay_rate;
1487 decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
1489 boost_score += (decay_accumulator * r);
1491 // Break clause to detect very still sections after motion
1492 // For example a staic image after a fade or other transition.
1493 if ( detect_transition_to_still( cpi, i, 5,
1494 loop_decay_rate, decay_accumulator ) )
1496 allow_alt_ref = FALSE;
1497 boost_score = old_boost_score;
1501 // Break out conditions.
1503 // Break at cpi->max_gf_interval unless almost totally static
1504 (i >= cpi->max_gf_interval && (decay_accumulator < 0.995)) ||
1506 // Dont break out with a very short interval
1507 (i > MIN_GF_INTERVAL) &&
1508 // Dont break out very close to a key frame
1509 ((cpi->twopass.frames_to_key - i) >= MIN_GF_INTERVAL) &&
1510 ((boost_score > 20.0) || (next_frame.pcnt_inter < 0.75)) &&
1511 ((mv_ratio_accumulator > 100.0) ||
1512 (abs_mv_in_out_accumulator > 3.0) ||
1513 (mv_in_out_accumulator < -2.0) ||
1514 ((boost_score - old_boost_score) < 2.0))
1517 boost_score = old_boost_score;
1521 vpx_memcpy(this_frame, &next_frame, sizeof(*this_frame));
1523 old_boost_score = boost_score;
1526 cpi->twopass.gf_decay_rate =
1527 (i > 0) ? (int)(100.0 * (1.0 - decay_accumulator)) / i : 0;
1529 // When using CBR apply additional buffer related upper limits
1530 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
1534 // For cbr apply buffer related limits
1535 if (cpi->drop_frames_allowed)
1537 int df_buffer_level = cpi->oxcf.drop_frames_water_mark *
1538 (cpi->oxcf.optimal_buffer_level / 100);
1540 if (cpi->buffer_level > df_buffer_level)
1541 max_boost = ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
1545 else if (cpi->buffer_level > 0)
1547 max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
1554 if (boost_score > max_boost)
1555 boost_score = max_boost;
1558 cpi->gfu_boost = (int)(boost_score * 100.0) >> 4;
1560 // Dont allow conventional gf too near the next kf
1561 if ((cpi->twopass.frames_to_key - i) < MIN_GF_INTERVAL)
1563 while (i < cpi->twopass.frames_to_key)
1567 if (EOF == input_stats(cpi, this_frame))
1570 if (i < cpi->twopass.frames_to_key)
1572 mod_frame_err = calculate_modified_err(cpi, this_frame);
1573 gf_group_err += mod_frame_err;
1578 // Should we use the alternate refernce frame
1579 if (allow_alt_ref &&
1580 (i >= MIN_GF_INTERVAL) &&
1581 // dont use ARF very near next kf
1582 (i <= (cpi->twopass.frames_to_key - MIN_GF_INTERVAL)) &&
1583 (((next_frame.pcnt_inter > 0.75) &&
1584 ((mv_in_out_accumulator / (double)i > -0.2) || (mv_in_out_accumulator > -2.0)) &&
1585 //(cpi->gfu_boost>150) &&
1586 (cpi->gfu_boost > 100) &&
1587 //(cpi->gfu_boost>AF_THRESH2) &&
1588 //((cpi->gfu_boost/i)>AF_THRESH) &&
1589 //(decay_accumulator > 0.5) &&
1590 (cpi->twopass.gf_decay_rate <= (ARF_DECAY_THRESH + (cpi->gfu_boost / 200)))
1596 int allocation_chunks;
1597 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
1599 int arf_frame_bits = 0;
1602 // Estimate the bits to be allocated to the group as a whole
1603 if ((cpi->twopass.kf_group_bits > 0) && (cpi->twopass.kf_group_error_left > 0))
1604 group_bits = (int)((double)cpi->twopass.kf_group_bits * (gf_group_err / (double)cpi->twopass.kf_group_error_left));
1608 // Boost for arf frame
1609 Boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100);
1611 allocation_chunks = (i * 100) + Boost;
1613 // Normalize Altboost and allocations chunck down to prevent overflow
1614 while (Boost > 1000)
1617 allocation_chunks /= 2;
1620 // Calculate the number of bits to be spent on the arf based on the boost number
1621 arf_frame_bits = (int)((double)Boost * (group_bits / (double)allocation_chunks));
1623 // Estimate if there are enough bits available to make worthwhile use of an arf.
1624 tmp_q = estimate_q(cpi, mod_frame_err, (int)arf_frame_bits);
1626 // Only use an arf if it is likely we will be able to code it at a lower Q than the surrounding frames.
1627 if (tmp_q < cpi->worst_quality)
1630 int frames_after_arf;
1631 int frames_bwd = cpi->oxcf.arnr_max_frames - 1;
1632 int frames_fwd = cpi->oxcf.arnr_max_frames - 1;
1634 cpi->source_alt_ref_pending = TRUE;
1636 // For alt ref frames the error score for the end frame of the group (the alt ref frame) should not contribute to the group total and hence
1637 // the number of bit allocated to the group. Rather it forms part of the next group (it is the GF at the start of the next group)
1638 gf_group_err -= mod_frame_err;
1640 // Set the interval till the next gf or arf. For ARFs this is the number of frames to be coded before the future frame that is coded as an ARF.
1641 // The future frame itself is part of the next group
1642 cpi->baseline_gf_interval = i - 1;
1644 // Define the arnr filter width for this group of frames:
1645 // We only filter frames that lie within a distance of half
1646 // the GF interval from the ARF frame. We also have to trap
1647 // cases where the filter extends beyond the end of clip.
1648 // Note: this_frame->frame has been updated in the loop
1649 // so it now points at the ARF frame.
1650 half_gf_int = cpi->baseline_gf_interval >> 1;
1651 frames_after_arf = cpi->twopass.total_stats->count - this_frame->frame - 1;
1653 switch (cpi->oxcf.arnr_type)
1655 case 1: // Backward filter
1657 if (frames_bwd > half_gf_int)
1658 frames_bwd = half_gf_int;
1661 case 2: // Forward filter
1662 if (frames_fwd > half_gf_int)
1663 frames_fwd = half_gf_int;
1664 if (frames_fwd > frames_after_arf)
1665 frames_fwd = frames_after_arf;
1669 case 3: // Centered filter
1672 if (frames_fwd > frames_after_arf)
1673 frames_fwd = frames_after_arf;
1674 if (frames_fwd > half_gf_int)
1675 frames_fwd = half_gf_int;
1677 frames_bwd = frames_fwd;
1679 // For even length filter there is one more frame backward
1680 // than forward: e.g. len=6 ==> bbbAff, len=7 ==> bbbAfff.
1681 if (frames_bwd < half_gf_int)
1682 frames_bwd += (cpi->oxcf.arnr_max_frames+1) & 0x1;
1686 cpi->active_arnr_frames = frames_bwd + 1 + frames_fwd;
1690 cpi->source_alt_ref_pending = FALSE;
1691 cpi->baseline_gf_interval = i;
1696 cpi->source_alt_ref_pending = FALSE;
1697 cpi->baseline_gf_interval = i;
1700 // Now decide how many bits should be allocated to the GF group as a proportion of those remaining in the kf group.
1701 // The final key frame group in the clip is treated as a special case where cpi->twopass.kf_group_bits is tied to cpi->twopass.bits_left.
1702 // This is also important for short clips where there may only be one key frame.
1703 if (cpi->twopass.frames_to_key >= (int)(cpi->twopass.total_stats->count - cpi->common.current_video_frame))
1705 cpi->twopass.kf_group_bits = (cpi->twopass.bits_left > 0) ? cpi->twopass.bits_left : 0;
1708 // Calculate the bits to be allocated to the group as a whole
1709 if ((cpi->twopass.kf_group_bits > 0) && (cpi->twopass.kf_group_error_left > 0))
1710 cpi->twopass.gf_group_bits = (int)((double)cpi->twopass.kf_group_bits * (gf_group_err / (double)cpi->twopass.kf_group_error_left));
1712 cpi->twopass.gf_group_bits = 0;
1714 cpi->twopass.gf_group_bits = (cpi->twopass.gf_group_bits < 0) ? 0 : (cpi->twopass.gf_group_bits > cpi->twopass.kf_group_bits) ? cpi->twopass.kf_group_bits : cpi->twopass.gf_group_bits;
1716 // Clip cpi->twopass.gf_group_bits based on user supplied data rate variability limit (cpi->oxcf.two_pass_vbrmax_section)
1717 max_group_bits = gf_group_max_bits(cpi);
1718 if (cpi->twopass.gf_group_bits > max_group_bits)
1719 cpi->twopass.gf_group_bits = max_group_bits;
1721 // Reset the file position
1722 reset_fpf_position(cpi, start_pos);
1724 // Update the record of error used so far (only done once per gf group)
1725 cpi->twopass.modified_error_used += gf_group_err;
1727 // Assign bits to the arf or gf.
1728 for (i = 0; i <= (cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME); i++) {
1730 int frames_in_section;
1731 int allocation_chunks;
1732 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
1736 if (cpi->source_alt_ref_pending && i == 0)
1738 Boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100);
1739 //Boost += (cpi->baseline_gf_interval * 25);
1740 Boost += (cpi->baseline_gf_interval * 50);
1742 // Set max and minimum boost and hence minimum allocation
1743 if (Boost > ((cpi->baseline_gf_interval + 1) * 200))
1744 Boost = ((cpi->baseline_gf_interval + 1) * 200);
1745 else if (Boost < 125)
1748 frames_in_section = cpi->baseline_gf_interval + 1;
1749 allocation_chunks = (frames_in_section * 100) + Boost;
1751 // Else for standard golden frames
1754 // boost based on inter / intra ratio of subsequent frames
1755 Boost = (cpi->gfu_boost * GFQ_ADJUSTMENT) / 100;
1757 // Set max and minimum boost and hence minimum allocation
1758 if (Boost > (cpi->baseline_gf_interval * 150))
1759 Boost = (cpi->baseline_gf_interval * 150);
1760 else if (Boost < 125)
1763 frames_in_section = cpi->baseline_gf_interval;
1764 allocation_chunks = (frames_in_section * 100) + (Boost - 100);
1767 // Normalize Altboost and allocations chunck down to prevent overflow
1768 while (Boost > 1000)
1771 allocation_chunks /= 2;
1774 // Calculate the number of bits to be spent on the gf or arf based on the boost number
1775 gf_bits = (int)((double)Boost * (cpi->twopass.gf_group_bits / (double)allocation_chunks));
1777 // If the frame that is to be boosted is simpler than the average for
1778 // the gf/arf group then use an alternative calculation
1779 // based on the error score of the frame itself
1780 if (mod_frame_err < gf_group_err / (double)cpi->baseline_gf_interval)
1782 double alt_gf_grp_bits;
1786 (double)cpi->twopass.kf_group_bits *
1787 (mod_frame_err * (double)cpi->baseline_gf_interval) /
1788 DOUBLE_DIVIDE_CHECK((double)cpi->twopass.kf_group_error_left);
1790 alt_gf_bits = (int)((double)Boost * (alt_gf_grp_bits /
1791 (double)allocation_chunks));
1793 if (gf_bits > alt_gf_bits)
1795 gf_bits = alt_gf_bits;
1798 // Else if it is harder than other frames in the group make sure it at
1799 // least receives an allocation in keeping with its relative error
1800 // score, otherwise it may be worse off than an "un-boosted" frame
1804 (int)((double)cpi->twopass.kf_group_bits *
1806 DOUBLE_DIVIDE_CHECK((double)cpi->twopass.kf_group_error_left));
1808 if (alt_gf_bits > gf_bits)
1810 gf_bits = alt_gf_bits;
1814 // Dont allow a negative value for gf_bits
1818 gf_bits += cpi->min_frame_bandwidth; // Add in minimum for a frame
1822 cpi->twopass.gf_bits = gf_bits;
1824 if (i == 1 || (!cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME)))
1826 cpi->per_frame_bandwidth = gf_bits; // Per frame bit target for this frame
1831 // Adjust KF group bits and error remainin
1832 cpi->twopass.kf_group_error_left -= gf_group_err;
1833 cpi->twopass.kf_group_bits -= cpi->twopass.gf_group_bits;
1835 if (cpi->twopass.kf_group_bits < 0)
1836 cpi->twopass.kf_group_bits = 0;
1838 // Note the error score left in the remaining frames of the group.
1839 // For normal GFs we want to remove the error score for the first frame of the group (except in Key frame case where this has already happened)
1840 if (!cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME)
1841 cpi->twopass.gf_group_error_left = gf_group_err - gf_first_frame_err;
1843 cpi->twopass.gf_group_error_left = gf_group_err;
1845 cpi->twopass.gf_group_bits -= cpi->twopass.gf_bits - cpi->min_frame_bandwidth;
1847 if (cpi->twopass.gf_group_bits < 0)
1848 cpi->twopass.gf_group_bits = 0;
1850 // Set aside some bits for a mid gf sequence boost
1851 if ((cpi->gfu_boost > 150) && (cpi->baseline_gf_interval > 5))
1853 int pct_extra = (cpi->gfu_boost - 100) / 50;
1854 pct_extra = (pct_extra > 10) ? 10 : pct_extra;
1856 cpi->twopass.mid_gf_extra_bits = (cpi->twopass.gf_group_bits * pct_extra) / 100;
1857 cpi->twopass.gf_group_bits -= cpi->twopass.mid_gf_extra_bits;
1860 cpi->twopass.mid_gf_extra_bits = 0;
1863 // Adjustment to estimate_max_q based on a measure of complexity of the section
1864 if (cpi->common.frame_type != KEY_FRAME)
1866 FIRSTPASS_STATS sectionstats;
1869 zero_stats(§ionstats);
1870 reset_fpf_position(cpi, start_pos);
1872 for (i = 0 ; i < cpi->baseline_gf_interval ; i++)
1874 input_stats(cpi, &next_frame);
1875 accumulate_stats(§ionstats, &next_frame);
1878 avg_stats(§ionstats);
1880 cpi->twopass.section_intra_rating =
1881 sectionstats.intra_error /
1882 DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
1884 Ratio = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
1885 //if( (Ratio > 11) ) //&& (sectionstats.pcnt_second_ref < .20) )
1887 cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025);
1889 if (cpi->twopass.section_max_qfactor < 0.80)
1890 cpi->twopass.section_max_qfactor = 0.80;
1894 // cpi->twopass.section_max_qfactor = 1.0;
1896 reset_fpf_position(cpi, start_pos);
1900 // Allocate bits to a normal frame that is neither a gf an arf or a key frame.
1901 static void assign_std_frame_bits(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
1903 int target_frame_size; // gf_group_error_left
1905 double modified_err;
1906 double err_fraction; // What portion of the remaining GF group error is used by this frame
1908 int max_bits = frame_max_bits(cpi); // Max for a single frame
1910 // Calculate modified prediction error used in bit allocation
1911 modified_err = calculate_modified_err(cpi, this_frame);
1913 if (cpi->twopass.gf_group_error_left > 0)
1914 err_fraction = modified_err / cpi->twopass.gf_group_error_left; // What portion of the remaining GF group error is used by this frame
1918 target_frame_size = (int)((double)cpi->twopass.gf_group_bits * err_fraction); // How many of those bits available for allocation should we give it?
1920 // Clip to target size to 0 - max_bits (or cpi->twopass.gf_group_bits) at the top end.
1921 if (target_frame_size < 0)
1922 target_frame_size = 0;
1925 if (target_frame_size > max_bits)
1926 target_frame_size = max_bits;
1928 if (target_frame_size > cpi->twopass.gf_group_bits)
1929 target_frame_size = cpi->twopass.gf_group_bits;
1932 cpi->twopass.gf_group_error_left -= modified_err; // Adjust error remaining
1933 cpi->twopass.gf_group_bits -= target_frame_size; // Adjust bits remaining
1935 if (cpi->twopass.gf_group_bits < 0)
1936 cpi->twopass.gf_group_bits = 0;
1938 target_frame_size += cpi->min_frame_bandwidth; // Add in the minimum number of bits that is set aside for every frame.
1940 // Special case for the frame that lies half way between two gfs
1941 if (cpi->common.frames_since_golden == cpi->baseline_gf_interval / 2)
1942 target_frame_size += cpi->twopass.mid_gf_extra_bits;
1944 cpi->per_frame_bandwidth = target_frame_size; // Per frame bit target for this frame
1947 void vp8_second_pass(VP8_COMP *cpi)
1950 int frames_left = (int)(cpi->twopass.total_stats->count - cpi->common.current_video_frame);
1952 FIRSTPASS_STATS this_frame;
1953 FIRSTPASS_STATS this_frame_copy;
1955 double this_frame_error;
1956 double this_frame_intra_error;
1957 double this_frame_coded_error;
1959 FIRSTPASS_STATS *start_pos;
1961 if (!cpi->twopass.stats_in)
1966 vp8_clear_system_state();
1968 if (EOF == input_stats(cpi, &this_frame))
1971 this_frame_error = this_frame.ssim_weighted_pred_err;
1972 this_frame_intra_error = this_frame.intra_error;
1973 this_frame_coded_error = this_frame.coded_error;
1975 start_pos = cpi->twopass.stats_in;
1977 // keyframe and section processing !
1978 if (cpi->twopass.frames_to_key == 0)
1980 // Define next KF group and assign bits to it
1981 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
1982 find_next_key_frame(cpi, &this_frame_copy);
1984 // Special case: Error error_resilient_mode mode does not make much sense for two pass but with its current meaning but this code is designed to stop
1985 // outlandish behaviour if someone does set it when using two pass. It effectively disables GF groups.
1986 // This is temporary code till we decide what should really happen in this case.
1987 if (cpi->oxcf.error_resilient_mode)
1989 cpi->twopass.gf_group_bits = cpi->twopass.kf_group_bits;
1990 cpi->twopass.gf_group_error_left = cpi->twopass.kf_group_error_left;
1991 cpi->baseline_gf_interval = cpi->twopass.frames_to_key;
1992 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
1993 cpi->source_alt_ref_pending = FALSE;
1998 // Is this a GF / ARF (Note that a KF is always also a GF)
1999 if (cpi->frames_till_gf_update_due == 0)
2001 // Define next gf group and assign bits to it
2002 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2003 define_gf_group(cpi, &this_frame_copy);
2005 // If we are going to code an altref frame at the end of the group and the current frame is not a key frame....
2006 // If the previous group used an arf this frame has already benefited from that arf boost and it should not be given extra bits
2007 // If the previous group was NOT coded using arf we may want to apply some boost to this GF as well
2008 if (cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME))
2010 // Assign a standard frames worth of bits from those allocated to the GF group
2011 int bak = cpi->per_frame_bandwidth;
2012 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2013 assign_std_frame_bits(cpi, &this_frame_copy);
2014 cpi->per_frame_bandwidth = bak;
2018 // Otherwise this is an ordinary frame
2021 // Special case: Error error_resilient_mode mode does not make much sense for two pass but with its current meaning but this code is designed to stop
2022 // outlandish behaviour if someone does set it when using two pass. It effectively disables GF groups.
2023 // This is temporary code till we decide what should really happen in this case.
2024 if (cpi->oxcf.error_resilient_mode)
2026 cpi->frames_till_gf_update_due = cpi->twopass.frames_to_key;
2028 if (cpi->common.frame_type != KEY_FRAME)
2030 // Assign bits from those allocated to the GF group
2031 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2032 assign_std_frame_bits(cpi, &this_frame_copy);
2037 // Assign bits from those allocated to the GF group
2038 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2039 assign_std_frame_bits(cpi, &this_frame_copy);
2043 // Keep a globally available copy of this and the next frame's iiratio.
2044 cpi->twopass.this_iiratio = this_frame_intra_error /
2045 DOUBLE_DIVIDE_CHECK(this_frame_coded_error);
2047 FIRSTPASS_STATS next_frame;
2048 if ( lookup_next_frame_stats(cpi, &next_frame) != EOF )
2050 cpi->twopass.next_iiratio = next_frame.intra_error /
2051 DOUBLE_DIVIDE_CHECK(next_frame.coded_error);
2055 // Set nominal per second bandwidth for this frame
2056 cpi->target_bandwidth = cpi->per_frame_bandwidth * cpi->output_frame_rate;
2057 if (cpi->target_bandwidth < 0)
2058 cpi->target_bandwidth = 0;
2060 if (cpi->common.current_video_frame == 0)
2062 cpi->twopass.est_max_qcorrection_factor = 1.0;
2064 // Experimental code to try and set a cq_level in constrained
2066 if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY )
2072 (cpi->twopass.total_coded_error_left / frames_left),
2073 (int)(cpi->twopass.bits_left / frames_left));
2075 cpi->cq_target_quality = cpi->oxcf.cq_level;
2076 if ( est_cq > cpi->cq_target_quality )
2077 cpi->cq_target_quality = est_cq;
2080 // guess at maxq needed in 2nd pass
2081 cpi->twopass.maxq_max_limit = cpi->worst_quality;
2082 cpi->twopass.maxq_min_limit = cpi->best_quality;
2083 tmp_q = estimate_max_q( cpi,
2084 (cpi->twopass.total_coded_error_left / frames_left),
2085 (int)(cpi->twopass.bits_left / frames_left));
2087 // Limit the maxq value returned subsequently.
2088 // This increases the risk of overspend or underspend if the initial
2089 // estimate for the clip is bad, but helps prevent excessive
2090 // variation in Q, especially near the end of a clip
2091 // where for example a small overspend may cause Q to crash
2092 cpi->twopass.maxq_max_limit = ((tmp_q + 32) < cpi->worst_quality)
2093 ? (tmp_q + 32) : cpi->worst_quality;
2094 cpi->twopass.maxq_min_limit = ((tmp_q - 32) > cpi->best_quality)
2095 ? (tmp_q - 32) : cpi->best_quality;
2097 cpi->active_worst_quality = tmp_q;
2098 cpi->ni_av_qi = tmp_q;
2101 // The last few frames of a clip almost always have to few or too many
2102 // bits and for the sake of over exact rate control we dont want to make
2103 // radical adjustments to the allowed quantizer range just to use up a
2104 // few surplus bits or get beneath the target rate.
2105 else if ( (cpi->common.current_video_frame <
2106 (((unsigned int)cpi->twopass.total_stats->count * 255)>>8)) &&
2107 ((cpi->common.current_video_frame + cpi->baseline_gf_interval) <
2108 (unsigned int)cpi->twopass.total_stats->count) )
2110 if (frames_left < 1)
2113 tmp_q = estimate_max_q(cpi, (cpi->twopass.total_coded_error_left / frames_left), (int)(cpi->twopass.bits_left / frames_left));
2115 // Move active_worst_quality but in a damped way
2116 if (tmp_q > cpi->active_worst_quality)
2117 cpi->active_worst_quality ++;
2118 else if (tmp_q < cpi->active_worst_quality)
2119 cpi->active_worst_quality --;
2121 cpi->active_worst_quality = ((cpi->active_worst_quality * 3) + tmp_q + 2) / 4;
2124 cpi->twopass.frames_to_key --;
2125 cpi->twopass.total_error_left -= this_frame_error;
2126 cpi->twopass.total_intra_error_left -= this_frame_intra_error;
2127 cpi->twopass.total_coded_error_left -= this_frame_coded_error;
2131 static BOOL test_candidate_kf(VP8_COMP *cpi, FIRSTPASS_STATS *last_frame, FIRSTPASS_STATS *this_frame, FIRSTPASS_STATS *next_frame)
2133 BOOL is_viable_kf = FALSE;
2135 // Does the frame satisfy the primary criteria of a key frame
2136 // If so, then examine how well it predicts subsequent frames
2137 if ((this_frame->pcnt_second_ref < 0.10) &&
2138 (next_frame->pcnt_second_ref < 0.10) &&
2139 ((this_frame->pcnt_inter < 0.05) ||
2141 ((this_frame->pcnt_inter - this_frame->pcnt_neutral) < .25) &&
2142 ((this_frame->intra_error / DOUBLE_DIVIDE_CHECK(this_frame->coded_error)) < 2.5) &&
2143 ((fabs(last_frame->coded_error - this_frame->coded_error) / DOUBLE_DIVIDE_CHECK(this_frame->coded_error) > .40) ||
2144 (fabs(last_frame->intra_error - this_frame->intra_error) / DOUBLE_DIVIDE_CHECK(this_frame->intra_error) > .40) ||
2145 ((next_frame->intra_error / DOUBLE_DIVIDE_CHECK(next_frame->coded_error)) > 3.5)
2152 FIRSTPASS_STATS *start_pos;
2154 FIRSTPASS_STATS local_next_frame;
2156 double boost_score = 0.0;
2157 double old_boost_score = 0.0;
2158 double decay_accumulator = 1.0;
2159 double next_iiratio;
2161 vpx_memcpy(&local_next_frame, next_frame, sizeof(*next_frame));
2163 // Note the starting file position so we can reset to it
2164 start_pos = cpi->twopass.stats_in;
2166 // Examine how well the key frame predicts subsequent frames
2167 for (i = 0 ; i < 16; i++)
2169 next_iiratio = (IIKFACTOR1 * local_next_frame.intra_error / DOUBLE_DIVIDE_CHECK(local_next_frame.coded_error)) ;
2171 if (next_iiratio > RMAX)
2172 next_iiratio = RMAX;
2174 // Cumulative effect of decay in prediction quality
2175 if (local_next_frame.pcnt_inter > 0.85)
2176 decay_accumulator = decay_accumulator * local_next_frame.pcnt_inter;
2178 decay_accumulator = decay_accumulator * ((0.85 + local_next_frame.pcnt_inter) / 2.0);
2180 //decay_accumulator = decay_accumulator * local_next_frame.pcnt_inter;
2182 // Keep a running total
2183 boost_score += (decay_accumulator * next_iiratio);
2185 // Test various breakout clauses
2186 if ((local_next_frame.pcnt_inter < 0.05) ||
2187 (next_iiratio < 1.5) ||
2188 (((local_next_frame.pcnt_inter -
2189 local_next_frame.pcnt_neutral) < 0.20) &&
2190 (next_iiratio < 3.0)) ||
2191 ((boost_score - old_boost_score) < 0.5) ||
2192 (local_next_frame.intra_error < 200)
2198 old_boost_score = boost_score;
2200 // Get the next frame details
2201 if (EOF == input_stats(cpi, &local_next_frame))
2205 // If there is tolerable prediction for at least the next 3 frames then break out else discard this pottential key frame and move on
2206 if (boost_score > 5.0 && (i > 3))
2207 is_viable_kf = TRUE;
2210 // Reset the file position
2211 reset_fpf_position(cpi, start_pos);
2213 is_viable_kf = FALSE;
2217 return is_viable_kf;
2219 static void find_next_key_frame(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
2222 FIRSTPASS_STATS last_frame;
2223 FIRSTPASS_STATS first_frame;
2224 FIRSTPASS_STATS next_frame;
2225 FIRSTPASS_STATS *start_position;
2227 double decay_accumulator = 1.0;
2228 double boost_score = 0;
2229 double old_boost_score = 0.0;
2230 double loop_decay_rate;
2232 double kf_mod_err = 0.0;
2233 double kf_group_err = 0.0;
2234 double kf_group_intra_err = 0.0;
2235 double kf_group_coded_err = 0.0;
2236 double recent_loop_decay[8] = {1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0};
2238 vpx_memset(&next_frame, 0, sizeof(next_frame)); // assure clean
2240 vp8_clear_system_state(); //__asm emms;
2241 start_position = cpi->twopass.stats_in;
2243 cpi->common.frame_type = KEY_FRAME;
2245 // is this a forced key frame by interval
2246 cpi->this_key_frame_forced = cpi->next_key_frame_forced;
2248 // Clear the alt ref active flag as this can never be active on a key frame
2249 cpi->source_alt_ref_active = FALSE;
2251 // Kf is always a gf so clear frames till next gf counter
2252 cpi->frames_till_gf_update_due = 0;
2254 cpi->twopass.frames_to_key = 1;
2256 // Take a copy of the initial frame details
2257 vpx_memcpy(&first_frame, this_frame, sizeof(*this_frame));
2259 cpi->twopass.kf_group_bits = 0; // Total bits avaialable to kf group
2260 cpi->twopass.kf_group_error_left = 0; // Group modified error score.
2262 kf_mod_err = calculate_modified_err(cpi, this_frame);
2264 // find the next keyframe
2266 while (cpi->twopass.stats_in < cpi->twopass.stats_in_end)
2268 // Accumulate kf group error
2269 kf_group_err += calculate_modified_err(cpi, this_frame);
2271 // These figures keep intra and coded error counts for all frames including key frames in the group.
2272 // The effect of the key frame itself can be subtracted out using the first_frame data collected above
2273 kf_group_intra_err += this_frame->intra_error;
2274 kf_group_coded_err += this_frame->coded_error;
2276 // load a the next frame's stats
2277 vpx_memcpy(&last_frame, this_frame, sizeof(*this_frame));
2278 input_stats(cpi, this_frame);
2280 // Provided that we are not at the end of the file...
2281 if (cpi->oxcf.auto_key
2282 && lookup_next_frame_stats(cpi, &next_frame) != EOF)
2284 // Normal scene cut check
2285 if (test_candidate_kf(cpi, &last_frame, this_frame, &next_frame))
2288 // How fast is prediction quality decaying
2289 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
2291 // We want to know something about the recent past... rather than
2292 // as used elsewhere where we are concened with decay in prediction
2293 // quality since the last GF or KF.
2294 recent_loop_decay[i%8] = loop_decay_rate;
2295 decay_accumulator = 1.0;
2296 for (j = 0; j < 8; j++)
2298 decay_accumulator = decay_accumulator * recent_loop_decay[j];
2301 // Special check for transition or high motion followed by a
2302 // to a static scene.
2303 if ( detect_transition_to_still( cpi, i,
2304 (cpi->key_frame_frequency-i),
2306 decay_accumulator ) )
2312 // Step on to the next frame
2313 cpi->twopass.frames_to_key ++;
2315 // If we don't have a real key frame within the next two
2316 // forcekeyframeevery intervals then break out of the loop.
2317 if (cpi->twopass.frames_to_key >= 2 *(int)cpi->key_frame_frequency)
2320 cpi->twopass.frames_to_key ++;
2325 // If there is a max kf interval set by the user we must obey it.
2326 // We already breakout of the loop above at 2x max.
2327 // This code centers the extra kf if the actual natural
2328 // interval is between 1x and 2x
2329 if (cpi->oxcf.auto_key
2330 && cpi->twopass.frames_to_key > (int)cpi->key_frame_frequency )
2332 FIRSTPASS_STATS *current_pos = cpi->twopass.stats_in;
2333 FIRSTPASS_STATS tmp_frame;
2335 cpi->twopass.frames_to_key /= 2;
2337 // Copy first frame details
2338 vpx_memcpy(&tmp_frame, &first_frame, sizeof(first_frame));
2340 // Reset to the start of the group
2341 reset_fpf_position(cpi, start_position);
2344 kf_group_intra_err = 0;
2345 kf_group_coded_err = 0;
2347 // Rescan to get the correct error data for the forced kf group
2348 for( i = 0; i < cpi->twopass.frames_to_key; i++ )
2350 // Accumulate kf group errors
2351 kf_group_err += calculate_modified_err(cpi, &tmp_frame);
2352 kf_group_intra_err += tmp_frame.intra_error;
2353 kf_group_coded_err += tmp_frame.coded_error;
2355 // Load a the next frame's stats
2356 input_stats(cpi, &tmp_frame);
2359 // Reset to the start of the group
2360 reset_fpf_position(cpi, current_pos);
2362 cpi->next_key_frame_forced = TRUE;
2365 cpi->next_key_frame_forced = FALSE;
2367 // Special case for the last frame of the file
2368 if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end)
2370 // Accumulate kf group error
2371 kf_group_err += calculate_modified_err(cpi, this_frame);
2373 // These figures keep intra and coded error counts for all frames including key frames in the group.
2374 // The effect of the key frame itself can be subtracted out using the first_frame data collected above
2375 kf_group_intra_err += this_frame->intra_error;
2376 kf_group_coded_err += this_frame->coded_error;
2379 // Calculate the number of bits that should be assigned to the kf group.
2380 if ((cpi->twopass.bits_left > 0) && (cpi->twopass.modified_error_left > 0.0))
2382 // Max for a single normal frame (not key frame)
2383 int max_bits = frame_max_bits(cpi);
2385 // Maximum bits for the kf group
2386 long long max_grp_bits;
2388 // Default allocation based on bits left and relative
2389 // complexity of the section
2390 cpi->twopass.kf_group_bits = (long long)( cpi->twopass.bits_left *
2392 cpi->twopass.modified_error_left ));
2394 // Clip based on maximum per frame rate defined by the user.
2395 max_grp_bits = (long long)max_bits * (long long)cpi->twopass.frames_to_key;
2396 if (cpi->twopass.kf_group_bits > max_grp_bits)
2397 cpi->twopass.kf_group_bits = max_grp_bits;
2399 // Additional special case for CBR if buffer is getting full.
2400 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2402 int opt_buffer_lvl = cpi->oxcf.optimal_buffer_level;
2403 int buffer_lvl = cpi->buffer_level;
2405 // If the buffer is near or above the optimal and this kf group is
2406 // not being allocated much then increase the allocation a bit.
2407 if (buffer_lvl >= opt_buffer_lvl)
2409 int high_water_mark = (opt_buffer_lvl +
2410 cpi->oxcf.maximum_buffer_size) >> 1;
2412 long long av_group_bits;
2414 // Av bits per frame * number of frames
2415 av_group_bits = (long long)cpi->av_per_frame_bandwidth *
2416 (long long)cpi->twopass.frames_to_key;
2418 // We are at or above the maximum.
2419 if (cpi->buffer_level >= high_water_mark)
2421 long long min_group_bits;
2423 min_group_bits = av_group_bits +
2424 (long long)(buffer_lvl -
2427 if (cpi->twopass.kf_group_bits < min_group_bits)
2428 cpi->twopass.kf_group_bits = min_group_bits;
2430 // We are above optimal but below the maximum
2431 else if (cpi->twopass.kf_group_bits < av_group_bits)
2433 long long bits_below_av = av_group_bits -
2434 cpi->twopass.kf_group_bits;
2436 cpi->twopass.kf_group_bits +=
2437 (long long)((double)bits_below_av *
2438 (double)(buffer_lvl - opt_buffer_lvl) /
2439 (double)(high_water_mark - opt_buffer_lvl));
2445 cpi->twopass.kf_group_bits = 0;
2447 // Reset the first pass file position
2448 reset_fpf_position(cpi, start_position);
2450 // determine how big to make this keyframe based on how well the subsequent frames use inter blocks
2451 decay_accumulator = 1.0;
2453 loop_decay_rate = 1.00; // Starting decay rate
2455 for (i = 0 ; i < cpi->twopass.frames_to_key ; i++)
2459 if (EOF == input_stats(cpi, &next_frame))
2462 if (next_frame.intra_error > cpi->twopass.kf_intra_err_min)
2463 r = (IIKFACTOR2 * next_frame.intra_error /
2464 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2466 r = (IIKFACTOR2 * cpi->twopass.kf_intra_err_min /
2467 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2472 // How fast is prediction quality decaying
2473 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
2475 decay_accumulator = decay_accumulator * loop_decay_rate;
2476 decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
2478 boost_score += (decay_accumulator * r);
2480 if ((i > MIN_GF_INTERVAL) &&
2481 ((boost_score - old_boost_score) < 1.0))
2486 old_boost_score = boost_score;
2491 FIRSTPASS_STATS sectionstats;
2494 zero_stats(§ionstats);
2495 reset_fpf_position(cpi, start_position);
2497 for (i = 0 ; i < cpi->twopass.frames_to_key ; i++)
2499 input_stats(cpi, &next_frame);
2500 accumulate_stats(§ionstats, &next_frame);
2503 avg_stats(§ionstats);
2505 cpi->twopass.section_intra_rating =
2506 sectionstats.intra_error
2507 / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
2509 Ratio = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
2510 // if( (Ratio > 11) ) //&& (sectionstats.pcnt_second_ref < .20) )
2512 cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025);
2514 if (cpi->twopass.section_max_qfactor < 0.80)
2515 cpi->twopass.section_max_qfactor = 0.80;
2519 // cpi->twopass.section_max_qfactor = 1.0;
2522 // When using CBR apply additional buffer fullness related upper limits
2523 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2527 if (cpi->drop_frames_allowed)
2529 int df_buffer_level = cpi->oxcf.drop_frames_water_mark * (cpi->oxcf.optimal_buffer_level / 100);
2531 if (cpi->buffer_level > df_buffer_level)
2532 max_boost = ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
2536 else if (cpi->buffer_level > 0)
2538 max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
2545 if (boost_score > max_boost)
2546 boost_score = max_boost;
2549 // Reset the first pass file position
2550 reset_fpf_position(cpi, start_position);
2552 // Work out how many bits to allocate for the key frame itself
2555 int kf_boost = boost_score;
2556 int allocation_chunks;
2557 int Counter = cpi->twopass.frames_to_key;
2559 YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
2560 // Min boost based on kf interval
2563 while ((kf_boost < 48) && (Counter > 0))
2573 kf_boost += ((Counter + 1) >> 1);
2575 if (kf_boost > 48) kf_boost = 48;
2578 // bigger frame sizes need larger kf boosts, smaller frames smaller boosts...
2579 if ((lst_yv12->y_width * lst_yv12->y_height) > (320 * 240))
2580 kf_boost += 2 * (lst_yv12->y_width * lst_yv12->y_height) / (320 * 240);
2581 else if ((lst_yv12->y_width * lst_yv12->y_height) < (320 * 240))
2582 kf_boost -= 4 * (320 * 240) / (lst_yv12->y_width * lst_yv12->y_height);
2584 kf_boost = (int)((double)kf_boost * 100.0) >> 4; // Scale 16 to 100
2586 // Adjustment to boost based on recent average q
2587 //kf_boost = kf_boost * vp8_kf_boost_qadjustment[cpi->ni_av_qi] / 100;
2589 if (kf_boost < 250) // Min KF boost
2592 // We do three calculations for kf size.
2593 // The first is based on the error score for the whole kf group.
2594 // The second (optionaly) on the key frames own error if this is smaller than the average for the group.
2595 // The final one insures that the frame receives at least the allocation it would have received based on its own error score vs the error score remaining
2597 allocation_chunks = ((cpi->twopass.frames_to_key - 1) * 100) + kf_boost; // cpi->twopass.frames_to_key-1 because key frame itself is taken care of by kf_boost
2599 // Normalize Altboost and allocations chunck down to prevent overflow
2600 while (kf_boost > 1000)
2603 allocation_chunks /= 2;
2606 cpi->twopass.kf_group_bits = (cpi->twopass.kf_group_bits < 0) ? 0 : cpi->twopass.kf_group_bits;
2608 // Calculate the number of bits to be spent on the key frame
2609 cpi->twopass.kf_bits = (int)((double)kf_boost * ((double)cpi->twopass.kf_group_bits / (double)allocation_chunks));
2611 // Apply an additional limit for CBR
2612 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2614 if (cpi->twopass.kf_bits > ((3 * cpi->buffer_level) >> 2))
2615 cpi->twopass.kf_bits = (3 * cpi->buffer_level) >> 2;
2618 // If the key frame is actually easier than the average for the
2619 // kf group (which does sometimes happen... eg a blank intro frame)
2620 // Then use an alternate calculation based on the kf error score
2621 // which should give a smaller key frame.
2622 if (kf_mod_err < kf_group_err / cpi->twopass.frames_to_key)
2624 double alt_kf_grp_bits =
2625 ((double)cpi->twopass.bits_left *
2626 (kf_mod_err * (double)cpi->twopass.frames_to_key) /
2627 DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left));
2629 alt_kf_bits = (int)((double)kf_boost *
2630 (alt_kf_grp_bits / (double)allocation_chunks));
2632 if (cpi->twopass.kf_bits > alt_kf_bits)
2634 cpi->twopass.kf_bits = alt_kf_bits;
2637 // Else if it is much harder than other frames in the group make sure
2638 // it at least receives an allocation in keeping with its relative
2643 (int)((double)cpi->twopass.bits_left *
2645 DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left)));
2647 if (alt_kf_bits > cpi->twopass.kf_bits)
2649 cpi->twopass.kf_bits = alt_kf_bits;
2653 cpi->twopass.kf_group_bits -= cpi->twopass.kf_bits;
2654 cpi->twopass.kf_bits += cpi->min_frame_bandwidth; // Add in the minimum frame allowance
2656 cpi->per_frame_bandwidth = cpi->twopass.kf_bits; // Peer frame bit target for this frame
2657 cpi->target_bandwidth = cpi->twopass.kf_bits * cpi->output_frame_rate; // Convert to a per second bitrate
2660 // Note the total error score of the kf group minus the key frame itself
2661 cpi->twopass.kf_group_error_left = (int)(kf_group_err - kf_mod_err);
2663 // Adjust the count of total modified error left.
2664 // The count of bits left is adjusted elsewhere based on real coded frame sizes
2665 cpi->twopass.modified_error_left -= kf_group_err;
2667 if (cpi->oxcf.allow_spatial_resampling)
2669 int resample_trigger = FALSE;
2670 int last_kf_resampled = FALSE;
2674 int new_width = cpi->oxcf.Width;
2675 int new_height = cpi->oxcf.Height;
2677 int projected_buffer_level = cpi->buffer_level;
2680 double projected_bits_perframe;
2681 double group_iiratio = (kf_group_intra_err - first_frame.intra_error) / (kf_group_coded_err - first_frame.coded_error);
2682 double err_per_frame = kf_group_err / cpi->twopass.frames_to_key;
2683 double bits_per_frame;
2684 double av_bits_per_frame;
2685 double effective_size_ratio;
2687 if ((cpi->common.Width != cpi->oxcf.Width) || (cpi->common.Height != cpi->oxcf.Height))
2688 last_kf_resampled = TRUE;
2690 // Set back to unscaled by defaults
2691 cpi->common.horiz_scale = NORMAL;
2692 cpi->common.vert_scale = NORMAL;
2694 // Calculate Average bits per frame.
2695 //av_bits_per_frame = cpi->twopass.bits_left/(double)(cpi->twopass.total_stats->count - cpi->common.current_video_frame);
2696 av_bits_per_frame = cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.frame_rate);
2697 //if ( av_bits_per_frame < 0.0 )
2698 // av_bits_per_frame = 0.0
2700 // CBR... Use the clip average as the target for deciding resample
2701 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2703 bits_per_frame = av_bits_per_frame;
2706 // In VBR we want to avoid downsampling in easy section unless we are under extreme pressure
2707 // So use the larger of target bitrate for this sectoion or average bitrate for sequence
2710 bits_per_frame = cpi->twopass.kf_group_bits / cpi->twopass.frames_to_key; // This accounts for how hard the section is...
2712 if (bits_per_frame < av_bits_per_frame) // Dont turn to resampling in easy sections just because they have been assigned a small number of bits
2713 bits_per_frame = av_bits_per_frame;
2716 // bits_per_frame should comply with our minimum
2717 if (bits_per_frame < (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100))
2718 bits_per_frame = (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100);
2720 // Work out if spatial resampling is necessary
2721 kf_q = estimate_kf_group_q(cpi, err_per_frame, bits_per_frame, group_iiratio);
2723 // If we project a required Q higher than the maximum allowed Q then make a guess at the actual size of frames in this section
2724 projected_bits_perframe = bits_per_frame;
2727 while (tmp_q > cpi->worst_quality)
2729 projected_bits_perframe *= 1.04;
2733 // Guess at buffer level at the end of the section
2734 projected_buffer_level = cpi->buffer_level - (int)((projected_bits_perframe - av_bits_per_frame) * cpi->twopass.frames_to_key);
2738 FILE *f = fopen("Subsamle.stt", "a");
2739 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);
2743 // The trigger for spatial resampling depends on the various parameters such as whether we are streaming (CBR) or VBR.
2744 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2746 // Trigger resample if we are projected to fall below down sample level or
2747 // resampled last time and are projected to remain below the up sample level
2748 if ((projected_buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100)) ||
2749 (last_kf_resampled && (projected_buffer_level < (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))))
2750 //( ((cpi->buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100))) &&
2751 // ((projected_buffer_level < (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))) ))
2752 resample_trigger = TRUE;
2754 resample_trigger = FALSE;
2758 long long clip_bits = (long long)(cpi->twopass.total_stats->count * cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.frame_rate));
2759 long long over_spend = cpi->oxcf.starting_buffer_level - cpi->buffer_level;
2761 if ((last_kf_resampled && (kf_q > cpi->worst_quality)) || // If triggered last time the threshold for triggering again is reduced
2762 ((kf_q > cpi->worst_quality) && // Projected Q higher than allowed and ...
2763 (over_spend > clip_bits / 20))) // ... Overspend > 5% of total bits
2764 resample_trigger = TRUE;
2766 resample_trigger = FALSE;
2770 if (resample_trigger)
2772 while ((kf_q >= cpi->worst_quality) && (scale_val < 6))
2776 cpi->common.vert_scale = vscale_lookup[scale_val];
2777 cpi->common.horiz_scale = hscale_lookup[scale_val];
2779 Scale2Ratio(cpi->common.horiz_scale, &hr, &hs);
2780 Scale2Ratio(cpi->common.vert_scale, &vr, &vs);
2782 new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs;
2783 new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs;
2785 // Reducing the area to 1/4 does not reduce the complexity (err_per_frame) to 1/4...
2786 // effective_sizeratio attempts to provide a crude correction for this
2787 effective_size_ratio = (double)(new_width * new_height) / (double)(cpi->oxcf.Width * cpi->oxcf.Height);
2788 effective_size_ratio = (1.0 + (3.0 * effective_size_ratio)) / 4.0;
2790 // Now try again and see what Q we get with the smaller image size
2791 kf_q = estimate_kf_group_q(cpi, err_per_frame * effective_size_ratio, bits_per_frame, group_iiratio);
2795 FILE *f = fopen("Subsamle.stt", "a");
2796 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);
2802 if ((cpi->common.Width != new_width) || (cpi->common.Height != new_height))
2804 cpi->common.Width = new_width;
2805 cpi->common.Height = new_height;
2806 vp8_alloc_compressor_data(cpi);