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, 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 static int encode_intra(VP8_COMP *cpi, MACROBLOCK *x, int use_dc_pred)
88 int intra_pred_var = 0;
93 x->e_mbd.mode_info_context->mbmi.mode = DC_PRED;
94 x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
95 x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
97 vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);
101 for (i = 0; i < 16; i++)
103 BLOCKD *b = &x->e_mbd.block[i];
104 BLOCK *be = &x->block[i];
106 vp8_encode_intra4x4block(IF_RTCD(&cpi->rtcd), x, be, b, B_DC_PRED);
110 intra_pred_var = VARIANCE_INVOKE(&cpi->rtcd.variance, getmbss)(x->src_diff);
112 return intra_pred_var;
115 // Resets the first pass file to the given position using a relative seek from the current position
116 static void reset_fpf_position(VP8_COMP *cpi, FIRSTPASS_STATS *Position)
118 cpi->stats_in = Position;
121 static int lookup_next_frame_stats(VP8_COMP *cpi, FIRSTPASS_STATS *next_frame)
123 if (cpi->stats_in >= cpi->stats_in_end)
126 *next_frame = *cpi->stats_in;
130 // Calculate a modified Error used in distributing bits between easier and harder frames
131 static double calculate_modified_err(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
133 double av_err = cpi->total_stats->ssim_weighted_pred_err;
134 double this_err = this_frame->ssim_weighted_pred_err;
137 //double relative_next_iiratio;
138 //double next_iiratio;
139 //double sum_iiratio;
142 //FIRSTPASS_STATS next_frame;
143 //FIRSTPASS_STATS *start_pos;
145 /*start_pos = cpi->stats_in;
148 while ( (i < 1) && input_stats(cpi,&next_frame) != EOF )
151 next_iiratio = next_frame.intra_error / DOUBLE_DIVIDE_CHECK(next_frame.coded_error);
152 next_iiratio = ( next_iiratio < 1.0 ) ? 1.0 : (next_iiratio > 20.0) ? 20.0 : next_iiratio;
153 sum_iiratio += next_iiratio;
158 relative_next_iiratio = sum_iiratio / DOUBLE_DIVIDE_CHECK(cpi->avg_iiratio * (double)i);
162 relative_next_iiratio = 1.0;
164 reset_fpf_position(cpi, start_pos);*/
166 if (this_err > av_err)
167 modified_err = av_err * pow((this_err / DOUBLE_DIVIDE_CHECK(av_err)), POW1);
169 modified_err = av_err * pow((this_err / DOUBLE_DIVIDE_CHECK(av_err)), POW2);
172 relative_next_iiratio = pow(relative_next_iiratio,0.25);
173 modified_err = modified_err * relative_next_iiratio;
179 static const double weight_table[256] = {
180 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
181 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
182 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
183 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
184 0.020000, 0.031250, 0.062500, 0.093750, 0.125000, 0.156250, 0.187500, 0.218750,
185 0.250000, 0.281250, 0.312500, 0.343750, 0.375000, 0.406250, 0.437500, 0.468750,
186 0.500000, 0.531250, 0.562500, 0.593750, 0.625000, 0.656250, 0.687500, 0.718750,
187 0.750000, 0.781250, 0.812500, 0.843750, 0.875000, 0.906250, 0.937500, 0.968750,
188 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
189 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
190 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
191 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
192 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
193 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
194 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
195 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
196 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
197 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
198 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
199 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
200 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
201 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
202 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
203 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
204 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
205 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
206 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
207 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
208 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
209 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
210 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
211 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000
214 static double simple_weight(YV12_BUFFER_CONFIG *source)
218 unsigned char *src = source->y_buffer;
219 double sum_weights = 0.0;
221 // Loop throught the Y plane raw examining levels and creating a weight for the image
222 i = source->y_height;
228 sum_weights += weight_table[ *src];
231 src -= source->y_width;
232 src += source->y_stride;
235 sum_weights /= (source->y_height * source->y_width);
241 // This function returns the current per frame maximum bitrate target
242 static int frame_max_bits(VP8_COMP *cpi)
244 // Max allocation for a single frame based on the max section guidelines passed in and how many bits are left
247 // For CBR we need to also consider buffer fullness.
248 // If we are running below the optimal level then we need to gradually tighten up on max_bits.
249 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
251 double buffer_fullness_ratio = (double)cpi->buffer_level / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.optimal_buffer_level);
253 // For CBR base this on the target average bits per frame plus the maximum sedction rate passed in by the user
254 max_bits = (int)(cpi->av_per_frame_bandwidth * ((double)cpi->oxcf.two_pass_vbrmax_section / 100.0));
256 // If our buffer is below the optimum level
257 if (buffer_fullness_ratio < 1.0)
259 // The lower of max_bits / 4 or cpi->av_per_frame_bandwidth / 4.
260 int min_max_bits = ((cpi->av_per_frame_bandwidth >> 2) < (max_bits >> 2)) ? cpi->av_per_frame_bandwidth >> 2 : max_bits >> 2;
262 max_bits = (int)(max_bits * buffer_fullness_ratio);
264 if (max_bits < min_max_bits)
265 max_bits = min_max_bits; // Lowest value we will set ... which should allow the buffer to refil.
271 // For VBR base this on the bits and frames left plus the two_pass_vbrmax_section rate passed in by the user
272 max_bits = (int)(((double)cpi->bits_left / (cpi->total_stats->count - (double)cpi->common.current_video_frame)) * ((double)cpi->oxcf.two_pass_vbrmax_section / 100.0));
275 // Trap case where we are out of bits
283 static void output_stats(const VP8_COMP *cpi,
284 struct vpx_codec_pkt_list *pktlist,
285 FIRSTPASS_STATS *stats)
287 struct vpx_codec_cx_pkt pkt;
288 pkt.kind = VPX_CODEC_STATS_PKT;
289 pkt.data.twopass_stats.buf = stats;
290 pkt.data.twopass_stats.sz = sizeof(FIRSTPASS_STATS);
291 vpx_codec_pkt_list_add(pktlist, &pkt);
298 fpfile = fopen("firstpass.stt", "a");
300 fprintf(fpfile, "%12.0f %12.0f %12.0f %12.4f %12.4f %12.4f %12.4f"
301 " %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f"
306 stats->ssim_weighted_pred_err,
309 stats->pcnt_second_ref,
317 stats->mv_in_out_count,
325 static int input_stats(VP8_COMP *cpi, FIRSTPASS_STATS *fps)
327 if (cpi->stats_in >= cpi->stats_in_end)
330 *fps = *cpi->stats_in;
331 cpi->stats_in = (void*)((char *)cpi->stats_in + sizeof(FIRSTPASS_STATS));
335 static void zero_stats(FIRSTPASS_STATS *section)
337 section->frame = 0.0;
338 section->intra_error = 0.0;
339 section->coded_error = 0.0;
340 section->ssim_weighted_pred_err = 0.0;
341 section->pcnt_inter = 0.0;
342 section->pcnt_motion = 0.0;
343 section->pcnt_second_ref = 0.0;
344 section->pcnt_neutral = 0.0;
346 section->mvr_abs = 0.0;
348 section->mvc_abs = 0.0;
351 section->mv_in_out_count = 0.0;
352 section->count = 0.0;
353 section->duration = 1.0;
355 static void accumulate_stats(FIRSTPASS_STATS *section, FIRSTPASS_STATS *frame)
357 section->frame += frame->frame;
358 section->intra_error += frame->intra_error;
359 section->coded_error += frame->coded_error;
360 section->ssim_weighted_pred_err += frame->ssim_weighted_pred_err;
361 section->pcnt_inter += frame->pcnt_inter;
362 section->pcnt_motion += frame->pcnt_motion;
363 section->pcnt_second_ref += frame->pcnt_second_ref;
364 section->pcnt_neutral += frame->pcnt_neutral;
365 section->MVr += frame->MVr;
366 section->mvr_abs += frame->mvr_abs;
367 section->MVc += frame->MVc;
368 section->mvc_abs += frame->mvc_abs;
369 section->MVrv += frame->MVrv;
370 section->MVcv += frame->MVcv;
371 section->mv_in_out_count += frame->mv_in_out_count;
372 section->count += frame->count;
373 section->duration += frame->duration;
375 static void avg_stats(FIRSTPASS_STATS *section)
377 if (section->count < 1.0)
380 section->intra_error /= section->count;
381 section->coded_error /= section->count;
382 section->ssim_weighted_pred_err /= section->count;
383 section->pcnt_inter /= section->count;
384 section->pcnt_second_ref /= section->count;
385 section->pcnt_neutral /= section->count;
386 section->pcnt_motion /= section->count;
387 section->MVr /= section->count;
388 section->mvr_abs /= section->count;
389 section->MVc /= section->count;
390 section->mvc_abs /= section->count;
391 section->MVrv /= section->count;
392 section->MVcv /= section->count;
393 section->mv_in_out_count /= section->count;
394 section->duration /= section->count;
397 void vp8_init_first_pass(VP8_COMP *cpi)
399 zero_stats(cpi->total_stats);
402 void vp8_end_first_pass(VP8_COMP *cpi)
404 output_stats(cpi, cpi->output_pkt_list, cpi->total_stats);
407 static void zz_motion_search( VP8_COMP *cpi, MACROBLOCK * x, YV12_BUFFER_CONFIG * recon_buffer, int * best_motion_err, int recon_yoffset )
409 MACROBLOCKD * const xd = & x->e_mbd;
410 BLOCK *b = &x->block[0];
411 BLOCKD *d = &x->e_mbd.block[0];
413 unsigned char *src_ptr = (*(b->base_src) + b->src);
414 int src_stride = b->src_stride;
415 unsigned char *ref_ptr;
416 int ref_stride=d->pre_stride;
418 // Set up pointers for this macro block recon buffer
419 xd->pre.y_buffer = recon_buffer->y_buffer + recon_yoffset;
421 ref_ptr = (unsigned char *)(*(d->base_pre) + d->pre );
423 VARIANCE_INVOKE(IF_RTCD(&cpi->rtcd.variance), mse16x16) ( src_ptr, src_stride, ref_ptr, ref_stride, (unsigned int *)(best_motion_err));
426 static void first_pass_motion_search(VP8_COMP *cpi, MACROBLOCK *x, MV *ref_mv, MV *best_mv, YV12_BUFFER_CONFIG *recon_buffer, int *best_motion_err, int recon_yoffset )
428 MACROBLOCKD *const xd = & x->e_mbd;
429 BLOCK *b = &x->block[0];
430 BLOCKD *d = &x->e_mbd.block[0];
436 int step_param = 3; //3; // Dont search over full range for first pass
437 int further_steps = (MAX_MVSEARCH_STEPS - 1) - step_param; //3;
439 vp8_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[BLOCK_16X16];
440 int new_mv_mode_penalty = 256;
442 // override the default variance function to use MSE
443 v_fn_ptr.vf = VARIANCE_INVOKE(IF_RTCD(&cpi->rtcd.variance), mse16x16);
445 // Set up pointers for this macro block recon buffer
446 xd->pre.y_buffer = recon_buffer->y_buffer + recon_yoffset;
448 // Initial step/diamond search centred on best mv
449 tmp_err = cpi->diamond_search_sad(x, b, d, ref_mv, &tmp_mv, step_param, x->errorperbit, &num00, &v_fn_ptr, x->mvcost, ref_mv);
450 if ( tmp_err < INT_MAX-new_mv_mode_penalty )
451 tmp_err += new_mv_mode_penalty;
453 if (tmp_err < *best_motion_err)
455 *best_motion_err = tmp_err;
456 best_mv->row = tmp_mv.row;
457 best_mv->col = tmp_mv.col;
460 // Further step/diamond searches as necessary
464 while (n < further_steps)
472 tmp_err = cpi->diamond_search_sad(x, b, d, ref_mv, &tmp_mv, step_param + n, x->errorperbit, &num00, &v_fn_ptr, x->mvcost, ref_mv);
473 if ( tmp_err < INT_MAX-new_mv_mode_penalty )
474 tmp_err += new_mv_mode_penalty;
476 if (tmp_err < *best_motion_err)
478 *best_motion_err = tmp_err;
479 best_mv->row = tmp_mv.row;
480 best_mv->col = tmp_mv.col;
486 void vp8_first_pass(VP8_COMP *cpi)
489 MACROBLOCK *const x = & cpi->mb;
490 VP8_COMMON *const cm = & cpi->common;
491 MACROBLOCKD *const xd = & x->e_mbd;
493 int recon_yoffset, recon_uvoffset;
494 YV12_BUFFER_CONFIG *lst_yv12 = &cm->yv12_fb[cm->lst_fb_idx];
495 YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
496 YV12_BUFFER_CONFIG *gld_yv12 = &cm->yv12_fb[cm->gld_fb_idx];
497 int recon_y_stride = lst_yv12->y_stride;
498 int recon_uv_stride = lst_yv12->uv_stride;
499 long long intra_error = 0;
500 long long coded_error = 0;
502 int sum_mvr = 0, sum_mvc = 0;
503 int sum_mvr_abs = 0, sum_mvc_abs = 0;
504 int sum_mvrs = 0, sum_mvcs = 0;
507 int second_ref_count = 0;
508 int intrapenalty = 256;
509 int neutral_count = 0;
511 int sum_in_vectors = 0;
513 MV zero_ref_mv = {0, 0};
515 vp8_clear_system_state(); //__asm emms;
517 x->src = * cpi->Source;
521 x->partition_info = x->pi;
523 xd->mode_info_context = cm->mi;
525 vp8_build_block_offsets(x);
527 vp8_setup_block_dptrs(&x->e_mbd);
529 vp8_setup_block_ptrs(x);
531 // set up frame new frame for intra coded blocks
532 vp8_setup_intra_recon(new_yv12);
533 vp8cx_frame_init_quantizer(cpi);
535 // Initialise the MV cost table to the defaults
536 //if( cm->current_video_frame == 0)
539 int flag[2] = {1, 1};
540 vp8_initialize_rd_consts(cpi, vp8_dc_quant(cm->base_qindex, cm->y1dc_delta_q));
541 vpx_memcpy(cm->fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));
542 vp8_build_component_cost_table(cpi->mb.mvcost, (const MV_CONTEXT *) cm->fc.mvc, flag);
545 // for each macroblock row in image
546 for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
550 best_ref_mv.as_int = 0;
552 // reset above block coeffs
553 xd->up_available = (mb_row != 0);
554 recon_yoffset = (mb_row * recon_y_stride * 16);
555 recon_uvoffset = (mb_row * recon_uv_stride * 8);
557 // Set up limit values for motion vectors to prevent them extending outside the UMV borders
558 x->mv_row_min = -((mb_row * 16) + (VP8BORDERINPIXELS - 16));
559 x->mv_row_max = ((cm->mb_rows - 1 - mb_row) * 16) + (VP8BORDERINPIXELS - 16);
562 // for each macroblock col in image
563 for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
566 int gf_motion_error = INT_MAX;
567 int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
569 xd->dst.y_buffer = new_yv12->y_buffer + recon_yoffset;
570 xd->dst.u_buffer = new_yv12->u_buffer + recon_uvoffset;
571 xd->dst.v_buffer = new_yv12->v_buffer + recon_uvoffset;
572 xd->left_available = (mb_col != 0);
574 // do intra 16x16 prediction
575 this_error = encode_intra(cpi, x, use_dc_pred);
577 // "intrapenalty" below deals with situations where the intra and inter error scores are very low (eg a plain black frame)
578 // We do not have special cases in first pass for 0,0 and nearest etc so all inter modes carry an overhead cost estimate fot the mv.
579 // When the error score is very low this causes us to pick all or lots of INTRA modes and throw lots of key frames.
580 // This penalty adds a cost matching that of a 0,0 mv to the intra case.
581 this_error += intrapenalty;
583 // Cumulative intra error total
584 intra_error += (long long)this_error;
586 // Set up limit values for motion vectors to prevent them extending outside the UMV borders
587 x->mv_col_min = -((mb_col * 16) + (VP8BORDERINPIXELS - 16));
588 x->mv_col_max = ((cm->mb_cols - 1 - mb_col) * 16) + (VP8BORDERINPIXELS - 16);
590 // Other than for the first frame do a motion search
591 if (cm->current_video_frame > 0)
593 BLOCKD *d = &x->e_mbd.block[0];
596 int motion_error = INT_MAX;
598 // Simple 0,0 motion with no mv overhead
599 zz_motion_search( cpi, x, lst_yv12, &motion_error, recon_yoffset );
600 d->bmi.mv.as_mv.row = 0;
601 d->bmi.mv.as_mv.col = 0;
603 // Test last reference frame using the previous best mv as the
604 // starting point (best reference) for the search
605 first_pass_motion_search(cpi, x, &best_ref_mv.as_mv,
606 &d->bmi.mv.as_mv, lst_yv12,
607 &motion_error, recon_yoffset);
609 // If the current best reference mv is not centred on 0,0 then do a 0,0 based search as well
610 if (best_ref_mv.as_int)
613 first_pass_motion_search(cpi, x, &zero_ref_mv, &tmp_mv,
614 lst_yv12, &tmp_err, recon_yoffset);
616 if ( tmp_err < motion_error )
618 motion_error = tmp_err;
619 d->bmi.mv.as_mv.row = tmp_mv.row;
620 d->bmi.mv.as_mv.col = tmp_mv.col;
624 // Experimental search in a second reference frame ((0,0) based only)
625 if (cm->current_video_frame > 1)
627 first_pass_motion_search(cpi, x, &zero_ref_mv, &tmp_mv, gld_yv12, &gf_motion_error, recon_yoffset);
629 if ((gf_motion_error < motion_error) && (gf_motion_error < this_error))
632 //motion_error = gf_motion_error;
633 //d->bmi.mv.as_mv.row = tmp_mv.row;
634 //d->bmi.mv.as_mv.col = tmp_mv.col;
638 xd->pre.y_buffer = cm->last_frame.y_buffer + recon_yoffset;
639 xd->pre.u_buffer = cm->last_frame.u_buffer + recon_uvoffset;
640 xd->pre.v_buffer = cm->last_frame.v_buffer + recon_uvoffset;
644 // Reset to last frame as reference buffer
645 xd->pre.y_buffer = lst_yv12->y_buffer + recon_yoffset;
646 xd->pre.u_buffer = lst_yv12->u_buffer + recon_uvoffset;
647 xd->pre.v_buffer = lst_yv12->v_buffer + recon_uvoffset;
650 /* Intra assumed best */
651 best_ref_mv.as_int = 0;
653 if (motion_error <= this_error)
655 // Keep a count of cases where the inter and intra were
656 // very close and very low. This helps with scene cut
657 // detection for example in cropped clips with black bars
658 // at the sides or top and bottom.
659 if( (((this_error-intrapenalty) * 9) <=
660 (motion_error*10)) &&
661 (this_error < (2*intrapenalty)) )
666 d->bmi.mv.as_mv.row <<= 3;
667 d->bmi.mv.as_mv.col <<= 3;
668 this_error = motion_error;
669 vp8_set_mbmode_and_mvs(x, NEWMV, &d->bmi.mv.as_mv);
670 vp8_encode_inter16x16y(IF_RTCD(&cpi->rtcd), x);
671 sum_mvr += d->bmi.mv.as_mv.row;
672 sum_mvr_abs += abs(d->bmi.mv.as_mv.row);
673 sum_mvc += d->bmi.mv.as_mv.col;
674 sum_mvc_abs += abs(d->bmi.mv.as_mv.col);
675 sum_mvrs += d->bmi.mv.as_mv.row * d->bmi.mv.as_mv.row;
676 sum_mvcs += d->bmi.mv.as_mv.col * d->bmi.mv.as_mv.col;
679 best_ref_mv.as_int = d->bmi.mv.as_int;
681 // Was the vector non-zero
682 if (d->bmi.mv.as_int)
686 // Does the Row vector point inwards or outwards
687 if (mb_row < cm->mb_rows / 2)
689 if (d->bmi.mv.as_mv.row > 0)
691 else if (d->bmi.mv.as_mv.row < 0)
694 else if (mb_row > cm->mb_rows / 2)
696 if (d->bmi.mv.as_mv.row > 0)
698 else if (d->bmi.mv.as_mv.row < 0)
702 // Does the Row vector point inwards or outwards
703 if (mb_col < cm->mb_cols / 2)
705 if (d->bmi.mv.as_mv.col > 0)
707 else if (d->bmi.mv.as_mv.col < 0)
710 else if (mb_col > cm->mb_cols / 2)
712 if (d->bmi.mv.as_mv.col > 0)
714 else if (d->bmi.mv.as_mv.col < 0)
721 coded_error += (long long)this_error;
723 // adjust to the next column of macroblocks
724 x->src.y_buffer += 16;
725 x->src.u_buffer += 8;
726 x->src.v_buffer += 8;
732 // adjust to the next row of mbs
733 x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
734 x->src.u_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
735 x->src.v_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
737 //extend the recon for intra prediction
738 vp8_extend_mb_row(new_yv12, xd->dst.y_buffer + 16, xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
739 vp8_clear_system_state(); //__asm emms;
742 vp8_clear_system_state(); //__asm emms;
748 fps.frame = cm->current_video_frame ;
749 fps.intra_error = intra_error >> 8;
750 fps.coded_error = coded_error >> 8;
751 weight = simple_weight(cpi->Source);
757 fps.ssim_weighted_pred_err = fps.coded_error * weight;
759 fps.pcnt_inter = 0.0;
760 fps.pcnt_motion = 0.0;
767 fps.mv_in_out_count = 0.0;
770 fps.pcnt_inter = 1.0 * (double)intercount / cm->MBs;
771 fps.pcnt_second_ref = 1.0 * (double)second_ref_count / cm->MBs;
772 fps.pcnt_neutral = 1.0 * (double)neutral_count / cm->MBs;
776 fps.MVr = (double)sum_mvr / (double)mvcount;
777 fps.mvr_abs = (double)sum_mvr_abs / (double)mvcount;
778 fps.MVc = (double)sum_mvc / (double)mvcount;
779 fps.mvc_abs = (double)sum_mvc_abs / (double)mvcount;
780 fps.MVrv = ((double)sum_mvrs - (fps.MVr * fps.MVr / (double)mvcount)) / (double)mvcount;
781 fps.MVcv = ((double)sum_mvcs - (fps.MVc * fps.MVc / (double)mvcount)) / (double)mvcount;
782 fps.mv_in_out_count = (double)sum_in_vectors / (double)(mvcount * 2);
784 fps.pcnt_motion = 1.0 * (double)mvcount / cpi->common.MBs;
787 // TODO: handle the case when duration is set to 0, or something less
788 // than the full time between subsequent cpi->source_time_stamp s .
789 fps.duration = cpi->source->ts_end
790 - cpi->source->ts_start;
792 // don't want to do output stats with a stack variable!
793 memcpy(cpi->this_frame_stats,
795 sizeof(FIRSTPASS_STATS));
796 output_stats(cpi, cpi->output_pkt_list, cpi->this_frame_stats);
797 accumulate_stats(cpi->total_stats, &fps);
800 // Copy the previous Last Frame into the GF buffer if specific conditions for doing so are met
801 if ((cm->current_video_frame > 0) &&
802 (cpi->this_frame_stats->pcnt_inter > 0.20) &&
803 ((cpi->this_frame_stats->intra_error / cpi->this_frame_stats->coded_error) > 2.0))
805 vp8_yv12_copy_frame_ptr(lst_yv12, gld_yv12);
808 // swap frame pointers so last frame refers to the frame we just compressed
809 vp8_swap_yv12_buffer(lst_yv12, new_yv12);
810 vp8_yv12_extend_frame_borders(lst_yv12);
812 // Special case for the first frame. Copy into the GF buffer as a second reference.
813 if (cm->current_video_frame == 0)
815 vp8_yv12_copy_frame_ptr(lst_yv12, gld_yv12);
819 // use this to see what the first pass reconstruction looks like
824 sprintf(filename, "enc%04d.yuv", (int) cm->current_video_frame);
826 if (cm->current_video_frame == 0)
827 recon_file = fopen(filename, "wb");
829 recon_file = fopen(filename, "ab");
831 if(fwrite(lst_yv12->buffer_alloc, lst_yv12->frame_size, 1, recon_file));
835 cm->current_video_frame++;
838 extern const int vp8_bits_per_mb[2][QINDEX_RANGE];
840 #define BASE_ERRPERMB 150
841 static int estimate_max_q(VP8_COMP *cpi, double section_err, int section_target_bandwitdh)
844 int num_mbs = cpi->common.MBs;
845 int target_norm_bits_per_mb;
847 double err_per_mb = section_err / num_mbs;
848 double correction_factor;
850 double speed_correction = 1.0;
851 double rolling_ratio;
853 double pow_highq = 0.90;
854 double pow_lowq = 0.40;
856 if (section_target_bandwitdh <= 0)
857 return cpi->maxq_max_limit; // Highest value allowed
859 target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20)) ? (512 * section_target_bandwitdh) / num_mbs : 512 * (section_target_bandwitdh / num_mbs);
861 // Calculate a corrective factor based on a rolling ratio of bits spent vs target bits
862 if ((cpi->rolling_target_bits > 0.0) && (cpi->active_worst_quality < cpi->worst_quality))
864 rolling_ratio = (double)cpi->rolling_actual_bits / (double)cpi->rolling_target_bits;
866 //if ( cpi->est_max_qcorrection_factor > rolling_ratio )
867 if (rolling_ratio < 0.95)
868 //cpi->est_max_qcorrection_factor *= adjustment_rate;
869 cpi->est_max_qcorrection_factor -= 0.005;
870 //else if ( cpi->est_max_qcorrection_factor < rolling_ratio )
871 else if (rolling_ratio > 1.05)
872 cpi->est_max_qcorrection_factor += 0.005;
874 //cpi->est_max_qcorrection_factor /= adjustment_rate;
876 cpi->est_max_qcorrection_factor = (cpi->est_max_qcorrection_factor < 0.1) ? 0.1 : (cpi->est_max_qcorrection_factor > 10.0) ? 10.0 : cpi->est_max_qcorrection_factor;
879 // Corrections for higher compression speed settings (reduced compression expected)
880 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1))
882 if (cpi->oxcf.cpu_used <= 5)
883 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
885 speed_correction = 1.25;
888 // Correction factor used for Q values >= 20
889 corr_high = pow(err_per_mb / BASE_ERRPERMB, pow_highq);
890 corr_high = (corr_high < 0.05)
891 ? 0.05 : (corr_high > 5.0) ? 5.0 : corr_high;
893 // Try and pick a max Q that will be high enough to encode the
894 // content at the given rate.
895 for (Q = cpi->maxq_min_limit; Q < cpi->maxq_max_limit; Q++)
897 int bits_per_mb_at_this_q;
901 correction_factor = pow(err_per_mb / BASE_ERRPERMB, (pow_lowq + Q * 0.01));
902 correction_factor = (correction_factor < 0.05) ? 0.05 : (correction_factor > 5.0) ? 5.0 : correction_factor;
905 correction_factor = corr_high;
907 bits_per_mb_at_this_q = (int)(.5 + correction_factor * speed_correction * cpi->est_max_qcorrection_factor * cpi->section_max_qfactor * (double)vp8_bits_per_mb[INTER_FRAME][Q] / 1.0);
908 //bits_per_mb_at_this_q = (int)(.5 + correction_factor * speed_correction * cpi->est_max_qcorrection_factor * (double)vp8_bits_per_mb[INTER_FRAME][Q] / 1.0);
910 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb)
914 // Restriction on active max q for constrained quality mode.
915 if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
916 (Q < cpi->cq_target_quality) )
917 //(Q < cpi->oxcf.cq_level;) )
919 Q = cpi->cq_target_quality;
920 //Q = cpi->oxcf.cq_level;
923 // Adjust maxq_min_limit and maxq_max_limit limits based on
924 // averaga q observed in clip for non kf/gf.arf frames
925 // Give average a chance to settle though.
926 if ( (cpi->ni_frames >
927 ((unsigned int)cpi->total_stats->count >> 8)) &&
928 (cpi->ni_frames > 150) )
930 cpi->maxq_max_limit = ((cpi->ni_av_qi + 32) < cpi->worst_quality)
931 ? (cpi->ni_av_qi + 32) : cpi->worst_quality;
932 cpi->maxq_min_limit = ((cpi->ni_av_qi - 32) > cpi->best_quality)
933 ? (cpi->ni_av_qi - 32) : cpi->best_quality;
938 static int estimate_q(VP8_COMP *cpi, double section_err, int section_target_bandwitdh)
941 int num_mbs = cpi->common.MBs;
942 int target_norm_bits_per_mb;
944 double err_per_mb = section_err / num_mbs;
945 double correction_factor;
947 double speed_correction = 1.0;
948 double pow_highq = 0.90;
949 double pow_lowq = 0.40;
951 target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20)) ? (512 * section_target_bandwitdh) / num_mbs : 512 * (section_target_bandwitdh / num_mbs);
953 // Corrections for higher compression speed settings (reduced compression expected)
954 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1))
956 if (cpi->oxcf.cpu_used <= 5)
957 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
959 speed_correction = 1.25;
962 // Correction factor used for Q values >= 20
963 corr_high = pow(err_per_mb / BASE_ERRPERMB, pow_highq);
964 corr_high = (corr_high < 0.05) ? 0.05 : (corr_high > 5.0) ? 5.0 : corr_high;
966 // Try and pick a Q that can encode the content at the given rate.
967 for (Q = 0; Q < MAXQ; Q++)
969 int bits_per_mb_at_this_q;
973 correction_factor = pow(err_per_mb / BASE_ERRPERMB, (pow_lowq + Q * 0.01));
974 correction_factor = (correction_factor < 0.05) ? 0.05 : (correction_factor > 5.0) ? 5.0 : correction_factor;
977 correction_factor = corr_high;
979 bits_per_mb_at_this_q = (int)(.5 + correction_factor * speed_correction * cpi->est_max_qcorrection_factor * (double)vp8_bits_per_mb[INTER_FRAME][Q] / 1.0);
981 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb)
988 // Estimate a worst case Q for a KF group
989 static int estimate_kf_group_q(VP8_COMP *cpi, double section_err, int section_target_bandwitdh, double group_iiratio)
992 int num_mbs = cpi->common.MBs;
993 int target_norm_bits_per_mb = (512 * section_target_bandwitdh) / num_mbs;
994 int bits_per_mb_at_this_q;
996 double err_per_mb = section_err / num_mbs;
997 double err_correction_factor;
999 double speed_correction = 1.0;
1000 double current_spend_ratio = 1.0;
1002 double pow_highq = (POW1 < 0.6) ? POW1 + 0.3 : 0.90;
1003 double pow_lowq = (POW1 < 0.7) ? POW1 + 0.1 : 0.80;
1005 double iiratio_correction_factor = 1.0;
1007 double combined_correction_factor;
1009 // Trap special case where the target is <= 0
1010 if (target_norm_bits_per_mb <= 0)
1013 // Calculate a corrective factor based on a rolling ratio of bits spent vs target bits
1014 // This is clamped to the range 0.1 to 10.0
1015 if (cpi->long_rolling_target_bits <= 0)
1016 current_spend_ratio = 10.0;
1019 current_spend_ratio = (double)cpi->long_rolling_actual_bits / (double)cpi->long_rolling_target_bits;
1020 current_spend_ratio = (current_spend_ratio > 10.0) ? 10.0 : (current_spend_ratio < 0.1) ? 0.1 : current_spend_ratio;
1023 // Calculate a correction factor based on the quality of prediction in the sequence as indicated by intra_inter error score ratio (IIRatio)
1024 // The idea here is to favour subsampling in the hardest sections vs the easyest.
1025 iiratio_correction_factor = 1.0 - ((group_iiratio - 6.0) * 0.1);
1027 if (iiratio_correction_factor < 0.5)
1028 iiratio_correction_factor = 0.5;
1030 // Corrections for higher compression speed settings (reduced compression expected)
1031 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1))
1033 if (cpi->oxcf.cpu_used <= 5)
1034 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
1036 speed_correction = 1.25;
1039 // Combine the various factors calculated above
1040 combined_correction_factor = speed_correction * iiratio_correction_factor * current_spend_ratio;
1042 // Correction factor used for Q values >= 20
1043 corr_high = pow(err_per_mb / BASE_ERRPERMB, pow_highq);
1044 corr_high = (corr_high < 0.05) ? 0.05 : (corr_high > 5.0) ? 5.0 : corr_high;
1046 // Try and pick a Q that should be high enough to encode the content at the given rate.
1047 for (Q = 0; Q < MAXQ; Q++)
1049 // Q values < 20 treated as a special case
1052 err_correction_factor = pow(err_per_mb / BASE_ERRPERMB, (pow_lowq + Q * 0.01));
1053 err_correction_factor = (err_correction_factor < 0.05) ? 0.05 : (err_correction_factor > 5.0) ? 5.0 : err_correction_factor;
1056 err_correction_factor = corr_high;
1058 bits_per_mb_at_this_q = (int)(.5 + err_correction_factor * combined_correction_factor * (double)vp8_bits_per_mb[INTER_FRAME][Q]);
1060 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb)
1064 // If we could not hit the target even at Max Q then estimate what Q would have bee required
1065 while ((bits_per_mb_at_this_q > target_norm_bits_per_mb) && (Q < (MAXQ * 2)))
1068 bits_per_mb_at_this_q = (int)(0.96 * bits_per_mb_at_this_q);
1074 FILE *f = fopen("estkf_q.stt", "a");
1075 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,
1076 target_norm_bits_per_mb, err_per_mb, err_correction_factor,
1077 current_spend_ratio, group_iiratio, iiratio_correction_factor,
1078 (double)cpi->buffer_level / (double)cpi->oxcf.optimal_buffer_level, Q);
1085 // For cq mode estimate a cq level that matches the observed
1086 // complexity and data rate.
1087 static int estimate_cq(VP8_COMP *cpi, double section_err, int section_target_bandwitdh)
1090 int num_mbs = cpi->common.MBs;
1091 int target_norm_bits_per_mb;
1093 double err_per_mb = section_err / num_mbs;
1094 double correction_factor;
1096 double speed_correction = 1.0;
1097 double pow_highq = 0.90;
1098 double pow_lowq = 0.40;
1099 double clip_iiratio;
1100 double clip_iifactor;
1102 target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20))
1103 ? (512 * section_target_bandwitdh) / num_mbs
1104 : 512 * (section_target_bandwitdh / num_mbs);
1106 // Corrections for higher compression speed settings
1107 // (reduced compression expected)
1108 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1))
1110 if (cpi->oxcf.cpu_used <= 5)
1111 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
1113 speed_correction = 1.25;
1115 // II ratio correction factor for clip as a whole
1116 clip_iiratio = cpi->total_stats->intra_error /
1117 DOUBLE_DIVIDE_CHECK(cpi->total_stats->coded_error);
1118 clip_iifactor = 1.0 - ((clip_iiratio - 10.0) * 0.025);
1119 if (clip_iifactor < 0.80)
1120 clip_iifactor = 0.80;
1122 // Correction factor used for Q values >= 20
1123 corr_high = pow(err_per_mb / BASE_ERRPERMB, pow_highq);
1124 corr_high = (corr_high < 0.05) ? 0.05 : (corr_high > 5.0) ? 5.0 : corr_high;
1126 // Try and pick a Q that can encode the content at the given rate.
1127 for (Q = 0; Q < MAXQ; Q++)
1129 int bits_per_mb_at_this_q;
1134 pow( err_per_mb / BASE_ERRPERMB, (pow_lowq + Q * 0.01));
1136 correction_factor = (correction_factor < 0.05) ? 0.05
1137 : (correction_factor > 5.0) ? 5.0
1138 : correction_factor;
1141 correction_factor = corr_high;
1143 bits_per_mb_at_this_q =
1144 (int)( .5 + correction_factor *
1147 (double)vp8_bits_per_mb[INTER_FRAME][Q] / 1.0);
1149 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb)
1156 extern void vp8_new_frame_rate(VP8_COMP *cpi, double framerate);
1158 void vp8_init_second_pass(VP8_COMP *cpi)
1160 FIRSTPASS_STATS this_frame;
1161 FIRSTPASS_STATS *start_pos;
1163 double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100);
1165 zero_stats(cpi->total_stats);
1167 if (!cpi->stats_in_end)
1170 *cpi->total_stats = *cpi->stats_in_end;
1172 cpi->total_error_left = cpi->total_stats->ssim_weighted_pred_err;
1173 cpi->total_intra_error_left = cpi->total_stats->intra_error;
1174 cpi->total_coded_error_left = cpi->total_stats->coded_error;
1175 cpi->start_tot_err_left = cpi->total_error_left;
1177 //cpi->bits_left = (long long)(cpi->total_stats->count * cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.frame_rate));
1178 //cpi->bits_left -= (long long)(cpi->total_stats->count * two_pass_min_rate / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.frame_rate));
1180 // each frame can have a different duration, as the frame rate in the source
1181 // isn't guaranteed to be constant. The frame rate prior to the first frame
1182 // encoded in the second pass is a guess. However the sum duration is not.
1183 // Its calculated based on the actual durations of all frames from the first
1185 vp8_new_frame_rate(cpi, 10000000.0 * cpi->total_stats->count / cpi->total_stats->duration);
1187 cpi->output_frame_rate = cpi->oxcf.frame_rate;
1188 cpi->bits_left = (long long)(cpi->total_stats->duration * cpi->oxcf.target_bandwidth / 10000000.0) ;
1189 cpi->bits_left -= (long long)(cpi->total_stats->duration * two_pass_min_rate / 10000000.0);
1190 cpi->clip_bits_total = cpi->bits_left;
1192 // Calculate a minimum intra value to be used in determining the IIratio
1193 // scores used in the second pass. We have this minimum to make sure
1194 // that clips that are static but "low complexity" in the intra domain
1195 // are still boosted appropriately for KF/GF/ARF
1196 cpi->kf_intra_err_min = KF_MB_INTRA_MIN * cpi->common.MBs;
1197 cpi->gf_intra_err_min = GF_MB_INTRA_MIN * cpi->common.MBs;
1199 avg_stats(cpi->total_stats);
1201 // Scan the first pass file and calculate an average Intra / Inter error score ratio for the sequence
1203 double sum_iiratio = 0.0;
1206 start_pos = cpi->stats_in; // Note starting "file" position
1208 while (input_stats(cpi, &this_frame) != EOF)
1210 IIRatio = this_frame.intra_error / DOUBLE_DIVIDE_CHECK(this_frame.coded_error);
1211 IIRatio = (IIRatio < 1.0) ? 1.0 : (IIRatio > 20.0) ? 20.0 : IIRatio;
1212 sum_iiratio += IIRatio;
1215 cpi->avg_iiratio = sum_iiratio / DOUBLE_DIVIDE_CHECK((double)cpi->total_stats->count);
1217 // Reset file position
1218 reset_fpf_position(cpi, start_pos);
1221 // Scan the first pass file and calculate a modified total error based upon the bias/power function
1222 // used to allocate bits
1224 start_pos = cpi->stats_in; // Note starting "file" position
1226 cpi->modified_error_total = 0.0;
1227 cpi->modified_error_used = 0.0;
1229 while (input_stats(cpi, &this_frame) != EOF)
1231 cpi->modified_error_total += calculate_modified_err(cpi, &this_frame);
1233 cpi->modified_error_left = cpi->modified_error_total;
1235 reset_fpf_position(cpi, start_pos); // Reset file position
1239 // Calculate the clip target modified bits per error
1240 // The observed bpe starts as the same number.
1241 cpi->clip_bpe = cpi->bits_left /
1242 DOUBLE_DIVIDE_CHECK(cpi->modified_error_total);
1243 cpi->observed_bpe = cpi->clip_bpe;
1246 void vp8_end_second_pass(VP8_COMP *cpi)
1250 // This function gives and estimate of how badly we believe
1251 // the prediction quality is decaying from frame to frame.
1252 static double get_prediction_decay_rate(VP8_COMP *cpi, FIRSTPASS_STATS *next_frame)
1254 double prediction_decay_rate;
1255 double motion_decay;
1256 double motion_pct = next_frame->pcnt_motion;
1259 // Initial basis is the % mbs inter coded
1260 prediction_decay_rate = next_frame->pcnt_inter;
1262 // High % motion -> somewhat higher decay rate
1263 motion_decay = (1.0 - (motion_pct / 20.0));
1264 if (motion_decay < prediction_decay_rate)
1265 prediction_decay_rate = motion_decay;
1267 // Adjustment to decay rate based on speed of motion
1269 double this_mv_rabs;
1270 double this_mv_cabs;
1271 double distance_factor;
1273 this_mv_rabs = fabs(next_frame->mvr_abs * motion_pct);
1274 this_mv_cabs = fabs(next_frame->mvc_abs * motion_pct);
1276 distance_factor = sqrt((this_mv_rabs * this_mv_rabs) +
1277 (this_mv_cabs * this_mv_cabs)) / 250.0;
1278 distance_factor = ((distance_factor > 1.0)
1279 ? 0.0 : (1.0 - distance_factor));
1280 if (distance_factor < prediction_decay_rate)
1281 prediction_decay_rate = distance_factor;
1284 return prediction_decay_rate;
1287 // Function to test for a condition where a complex transition is followed
1288 // by a static section. For example in slide shows where there is a fade
1289 // between slides. This is to help with more optimal kf and gf positioning.
1290 static int detect_transition_to_still(
1294 double loop_decay_rate,
1295 double decay_accumulator )
1297 BOOL trans_to_still = FALSE;
1299 // Break clause to detect very still sections after motion
1300 // For example a static image after a fade or other transition
1301 // instead of a clean scene cut.
1302 if ( (frame_interval > MIN_GF_INTERVAL) &&
1303 (loop_decay_rate >= 0.999) &&
1304 (decay_accumulator < 0.9) )
1307 FIRSTPASS_STATS * position = cpi->stats_in;
1308 FIRSTPASS_STATS tmp_next_frame;
1311 // Look ahead a few frames to see if static condition
1313 for ( j = 0; j < still_interval; j++ )
1315 if (EOF == input_stats(cpi, &tmp_next_frame))
1318 decay_rate = get_prediction_decay_rate(cpi, &tmp_next_frame);
1319 if ( decay_rate < 0.999 )
1322 // Reset file position
1323 reset_fpf_position(cpi, position);
1325 // Only if it does do we signal a transition to still
1326 if ( j == still_interval )
1327 trans_to_still = TRUE;
1330 return trans_to_still;
1333 // Analyse and define a gf/arf group .
1334 static void define_gf_group(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
1336 FIRSTPASS_STATS next_frame;
1337 FIRSTPASS_STATS *start_pos;
1339 double boost_score = 0.0;
1340 double old_boost_score = 0.0;
1341 double gf_group_err = 0.0;
1342 double gf_first_frame_err = 0.0;
1343 double mod_frame_err = 0.0;
1345 double mv_accumulator_rabs = 0.0;
1346 double mv_accumulator_cabs = 0.0;
1347 double mv_ratio_accumulator = 0.0;
1348 double decay_accumulator = 1.0;
1350 double boost_factor = IIFACTOR;
1351 double loop_decay_rate = 1.00; // Starting decay rate
1353 double this_frame_mv_in_out = 0.0;
1354 double mv_in_out_accumulator = 0.0;
1355 double abs_mv_in_out_accumulator = 0.0;
1356 double mod_err_per_mb_accumulator = 0.0;
1358 int max_bits = frame_max_bits(cpi); // Max for a single frame
1360 unsigned int allow_alt_ref =
1361 cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames;
1363 cpi->gf_group_bits = 0;
1364 cpi->gf_decay_rate = 0;
1366 vp8_clear_system_state(); //__asm emms;
1368 start_pos = cpi->stats_in;
1370 vpx_memset(&next_frame, 0, sizeof(next_frame)); // assure clean
1372 // Preload the stats for the next frame.
1373 mod_frame_err = calculate_modified_err(cpi, this_frame);
1375 // Note the error of the frame at the start of the group (this will be
1376 // the GF frame error if we code a normal gf
1377 gf_first_frame_err = mod_frame_err;
1379 // Special treatment if the current frame is a key frame (which is also
1380 // a gf). If it is then its error score (and hence bit allocation) need
1381 // to be subtracted out from the calculation for the GF group
1382 if (cpi->common.frame_type == KEY_FRAME)
1383 gf_group_err -= gf_first_frame_err;
1385 // Scan forward to try and work out how many frames the next gf group
1386 // should contain and what level of boost is appropriate for the GF
1387 // or ARF that will be coded with the group
1390 while (((i < cpi->static_scene_max_gf_interval) ||
1391 ((cpi->frames_to_key - i) < MIN_GF_INTERVAL)) &&
1392 (i < cpi->frames_to_key))
1395 double this_frame_mvr_ratio;
1396 double this_frame_mvc_ratio;
1397 //double motion_pct = next_frame.pcnt_motion;
1400 i++; // Increment the loop counter
1402 // Accumulate error score of frames in this gf group
1403 mod_frame_err = calculate_modified_err(cpi, this_frame);
1405 gf_group_err += mod_frame_err;
1407 mod_err_per_mb_accumulator +=
1408 mod_frame_err / DOUBLE_DIVIDE_CHECK((double)cpi->common.MBs);
1410 if (EOF == input_stats(cpi, &next_frame))
1413 // Accumulate motion stats.
1414 motion_pct = next_frame.pcnt_motion;
1415 mv_accumulator_rabs += fabs(next_frame.mvr_abs * motion_pct);
1416 mv_accumulator_cabs += fabs(next_frame.mvc_abs * motion_pct);
1418 //Accumulate Motion In/Out of frame stats
1419 this_frame_mv_in_out =
1420 next_frame.mv_in_out_count * motion_pct;
1421 mv_in_out_accumulator +=
1422 next_frame.mv_in_out_count * motion_pct;
1423 abs_mv_in_out_accumulator +=
1424 fabs(next_frame.mv_in_out_count * motion_pct);
1426 // If there is a significant amount of motion
1427 if (motion_pct > 0.05)
1429 this_frame_mvr_ratio = fabs(next_frame.mvr_abs) /
1430 DOUBLE_DIVIDE_CHECK(fabs(next_frame.MVr));
1432 this_frame_mvc_ratio = fabs(next_frame.mvc_abs) /
1433 DOUBLE_DIVIDE_CHECK(fabs(next_frame.MVc));
1435 mv_ratio_accumulator +=
1436 (this_frame_mvr_ratio < next_frame.mvr_abs)
1437 ? (this_frame_mvr_ratio * motion_pct)
1438 : next_frame.mvr_abs * motion_pct;
1440 mv_ratio_accumulator +=
1441 (this_frame_mvc_ratio < next_frame.mvc_abs)
1442 ? (this_frame_mvc_ratio * motion_pct)
1443 : next_frame.mvc_abs * motion_pct;
1447 mv_ratio_accumulator += 0.0;
1448 this_frame_mvr_ratio = 1.0;
1449 this_frame_mvc_ratio = 1.0;
1452 // Underlying boost factor is based on inter intra error ratio
1453 r = ( boost_factor *
1454 ( next_frame.intra_error /
1455 DOUBLE_DIVIDE_CHECK(next_frame.coded_error)));
1457 if (next_frame.intra_error > cpi->gf_intra_err_min)
1458 r = (IIKFACTOR2 * next_frame.intra_error /
1459 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
1461 r = (IIKFACTOR2 * cpi->gf_intra_err_min /
1462 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
1464 // Increase boost for frames where new data coming into frame
1465 // (eg zoom out). Slightly reduce boost if there is a net balance
1466 // of motion out of the frame (zoom in).
1467 // The range for this_frame_mv_in_out is -1.0 to +1.0
1468 if (this_frame_mv_in_out > 0.0)
1469 r += r * (this_frame_mv_in_out * 2.0);
1470 // In extreme case boost is halved
1472 r += r * (this_frame_mv_in_out / 2.0);
1477 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
1479 // Cumulative effect of decay
1480 decay_accumulator = decay_accumulator * loop_decay_rate;
1481 decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
1483 boost_score += (decay_accumulator * r);
1485 // Break clause to detect very still sections after motion
1486 // For example a staic image after a fade or other transition.
1487 if ( detect_transition_to_still( cpi, i, 5,
1488 loop_decay_rate, decay_accumulator ) )
1490 allow_alt_ref = FALSE;
1491 boost_score = old_boost_score;
1495 // Break out conditions.
1497 // Break at cpi->max_gf_interval unless almost totally static
1498 (i >= cpi->max_gf_interval && (decay_accumulator < 0.995)) ||
1500 // Dont break out with a very short interval
1501 (i > MIN_GF_INTERVAL) &&
1502 // Dont break out very close to a key frame
1503 ((cpi->frames_to_key - i) >= MIN_GF_INTERVAL) &&
1504 ((boost_score > 20.0) || (next_frame.pcnt_inter < 0.75)) &&
1505 ((mv_ratio_accumulator > 100.0) ||
1506 (abs_mv_in_out_accumulator > 3.0) ||
1507 (mv_in_out_accumulator < -2.0) ||
1508 ((boost_score - old_boost_score) < 2.0))
1511 boost_score = old_boost_score;
1515 vpx_memcpy(this_frame, &next_frame, sizeof(*this_frame));
1517 old_boost_score = boost_score;
1520 cpi->gf_decay_rate =
1521 (i > 0) ? (int)(100.0 * (1.0 - decay_accumulator)) / i : 0;
1523 // When using CBR apply additional buffer related upper limits
1524 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
1528 // For cbr apply buffer related limits
1529 if (cpi->drop_frames_allowed)
1531 int df_buffer_level = cpi->oxcf.drop_frames_water_mark *
1532 (cpi->oxcf.optimal_buffer_level / 100);
1534 if (cpi->buffer_level > df_buffer_level)
1535 max_boost = ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
1539 else if (cpi->buffer_level > 0)
1541 max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
1548 if (boost_score > max_boost)
1549 boost_score = max_boost;
1552 cpi->gfu_boost = (int)(boost_score * 100.0) >> 4;
1554 // Should we use the alternate refernce frame
1555 if (allow_alt_ref &&
1556 (i >= MIN_GF_INTERVAL) &&
1557 // dont use ARF very near next kf
1558 (i <= (cpi->frames_to_key - MIN_GF_INTERVAL)) &&
1559 (((next_frame.pcnt_inter > 0.75) &&
1560 ((mv_in_out_accumulator / (double)i > -0.2) || (mv_in_out_accumulator > -2.0)) &&
1561 //(cpi->gfu_boost>150) &&
1562 (cpi->gfu_boost > 100) &&
1563 //(cpi->gfu_boost>AF_THRESH2) &&
1564 //((cpi->gfu_boost/i)>AF_THRESH) &&
1565 //(decay_accumulator > 0.5) &&
1566 (cpi->gf_decay_rate <= (ARF_DECAY_THRESH + (cpi->gfu_boost / 200)))
1572 int allocation_chunks;
1573 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
1575 int arf_frame_bits = 0;
1578 // Estimate the bits to be allocated to the group as a whole
1579 if ((cpi->kf_group_bits > 0) && (cpi->kf_group_error_left > 0))
1580 group_bits = (int)((double)cpi->kf_group_bits * (gf_group_err / (double)cpi->kf_group_error_left));
1584 // Boost for arf frame
1585 Boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100);
1587 allocation_chunks = (i * 100) + Boost;
1589 // Normalize Altboost and allocations chunck down to prevent overflow
1590 while (Boost > 1000)
1593 allocation_chunks /= 2;
1596 // Calculate the number of bits to be spent on the arf based on the boost number
1597 arf_frame_bits = (int)((double)Boost * (group_bits / (double)allocation_chunks));
1599 // Estimate if there are enough bits available to make worthwhile use of an arf.
1600 tmp_q = estimate_q(cpi, mod_frame_err, (int)arf_frame_bits);
1602 // Only use an arf if it is likely we will be able to code it at a lower Q than the surrounding frames.
1603 if (tmp_q < cpi->worst_quality)
1606 int frames_after_arf;
1607 int frames_bwd = cpi->oxcf.arnr_max_frames - 1;
1608 int frames_fwd = cpi->oxcf.arnr_max_frames - 1;
1610 cpi->source_alt_ref_pending = TRUE;
1612 // 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
1613 // 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)
1614 gf_group_err -= mod_frame_err;
1616 // 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.
1617 // The future frame itself is part of the next group
1618 cpi->baseline_gf_interval = i - 1;
1620 // Define the arnr filter width for this group of frames:
1621 // We only filter frames that lie within a distance of half
1622 // the GF interval from the ARF frame. We also have to trap
1623 // cases where the filter extends beyond the end of clip.
1624 // Note: this_frame->frame has been updated in the loop
1625 // so it now points at the ARF frame.
1626 half_gf_int = cpi->baseline_gf_interval >> 1;
1627 frames_after_arf = cpi->total_stats->count - this_frame->frame - 1;
1629 switch (cpi->oxcf.arnr_type)
1631 case 1: // Backward filter
1633 if (frames_bwd > half_gf_int)
1634 frames_bwd = half_gf_int;
1637 case 2: // Forward filter
1638 if (frames_fwd > half_gf_int)
1639 frames_fwd = half_gf_int;
1640 if (frames_fwd > frames_after_arf)
1641 frames_fwd = frames_after_arf;
1645 case 3: // Centered filter
1648 if (frames_fwd > frames_after_arf)
1649 frames_fwd = frames_after_arf;
1650 if (frames_fwd > half_gf_int)
1651 frames_fwd = half_gf_int;
1653 frames_bwd = frames_fwd;
1655 // For even length filter there is one more frame backward
1656 // than forward: e.g. len=6 ==> bbbAff, len=7 ==> bbbAfff.
1657 if (frames_bwd < half_gf_int)
1658 frames_bwd += (cpi->oxcf.arnr_max_frames+1) & 0x1;
1662 cpi->active_arnr_frames = frames_bwd + 1 + frames_fwd;
1666 cpi->source_alt_ref_pending = FALSE;
1667 cpi->baseline_gf_interval = i;
1672 cpi->source_alt_ref_pending = FALSE;
1673 cpi->baseline_gf_interval = i;
1677 if (!cpi->source_alt_ref_pending)
1679 // Dont allow conventional gf too near the next kf
1680 if ((cpi->frames_to_key - cpi->baseline_gf_interval) < MIN_GF_INTERVAL)
1682 while (cpi->baseline_gf_interval < cpi->frames_to_key)
1684 if (EOF == input_stats(cpi, this_frame))
1687 cpi->baseline_gf_interval++;
1689 if (cpi->baseline_gf_interval < cpi->frames_to_key)
1690 gf_group_err += calculate_modified_err(cpi, this_frame);
1695 // Now decide how many bits should be allocated to the GF group as a proportion of those remaining in the kf group.
1696 // The final key frame group in the clip is treated as a special case where cpi->kf_group_bits is tied to cpi->bits_left.
1697 // This is also important for short clips where there may only be one key frame.
1698 if (cpi->frames_to_key >= (int)(cpi->total_stats->count - cpi->common.current_video_frame))
1700 cpi->kf_group_bits = (cpi->bits_left > 0) ? cpi->bits_left : 0;
1703 // Calculate the bits to be allocated to the group as a whole
1704 if ((cpi->kf_group_bits > 0) && (cpi->kf_group_error_left > 0))
1705 cpi->gf_group_bits = (int)((double)cpi->kf_group_bits * (gf_group_err / (double)cpi->kf_group_error_left));
1707 cpi->gf_group_bits = 0;
1709 cpi->gf_group_bits = (cpi->gf_group_bits < 0) ? 0 : (cpi->gf_group_bits > cpi->kf_group_bits) ? cpi->kf_group_bits : cpi->gf_group_bits;
1711 // Clip cpi->gf_group_bits based on user supplied data rate variability limit (cpi->oxcf.two_pass_vbrmax_section)
1712 if (cpi->gf_group_bits > max_bits * cpi->baseline_gf_interval)
1713 cpi->gf_group_bits = max_bits * cpi->baseline_gf_interval;
1715 // Reset the file position
1716 reset_fpf_position(cpi, start_pos);
1718 // Update the record of error used so far (only done once per gf group)
1719 cpi->modified_error_used += gf_group_err;
1721 // Assign bits to the arf or gf.
1724 int frames_in_section;
1725 int allocation_chunks;
1726 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
1729 if (cpi->source_alt_ref_pending)
1731 Boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100);
1732 //Boost += (cpi->baseline_gf_interval * 25);
1733 Boost += (cpi->baseline_gf_interval * 50);
1735 // Set max and minimum boost and hence minimum allocation
1736 if (Boost > ((cpi->baseline_gf_interval + 1) * 200))
1737 Boost = ((cpi->baseline_gf_interval + 1) * 200);
1738 else if (Boost < 125)
1741 frames_in_section = cpi->baseline_gf_interval + 1;
1742 allocation_chunks = (frames_in_section * 100) + Boost;
1744 // Else for standard golden frames
1747 // boost based on inter / intra ratio of subsequent frames
1748 Boost = (cpi->gfu_boost * GFQ_ADJUSTMENT) / 100;
1750 // Set max and minimum boost and hence minimum allocation
1751 if (Boost > (cpi->baseline_gf_interval * 150))
1752 Boost = (cpi->baseline_gf_interval * 150);
1753 else if (Boost < 125)
1756 frames_in_section = cpi->baseline_gf_interval;
1757 allocation_chunks = (frames_in_section * 100) + (Boost - 100);
1760 // Normalize Altboost and allocations chunck down to prevent overflow
1761 while (Boost > 1000)
1764 allocation_chunks /= 2;
1767 // Calculate the number of bits to be spent on the gf or arf based on the boost number
1768 cpi->gf_bits = (int)((double)Boost * (cpi->gf_group_bits / (double)allocation_chunks));
1770 // If the frame that is to be boosted is simpler than the average for
1771 // the gf/arf group then use an alternative calculation
1772 // based on the error score of the frame itself
1773 if (mod_frame_err < gf_group_err / (double)cpi->baseline_gf_interval)
1775 double alt_gf_grp_bits;
1779 (double)cpi->kf_group_bits *
1780 (mod_frame_err * (double)cpi->baseline_gf_interval) /
1781 DOUBLE_DIVIDE_CHECK((double)cpi->kf_group_error_left);
1783 alt_gf_bits = (int)((double)Boost * (alt_gf_grp_bits /
1784 (double)allocation_chunks));
1786 if (cpi->gf_bits > alt_gf_bits)
1788 cpi->gf_bits = alt_gf_bits;
1791 // Else if it is harder than other frames in the group make sure it at
1792 // least receives an allocation in keeping with its relative error
1793 // score, otherwise it may be worse off than an "un-boosted" frame
1797 (int)((double)cpi->kf_group_bits *
1799 DOUBLE_DIVIDE_CHECK((double)cpi->kf_group_error_left));
1801 if (alt_gf_bits > cpi->gf_bits)
1803 cpi->gf_bits = alt_gf_bits;
1807 // Apply an additional limit for CBR
1808 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
1810 if (cpi->gf_bits > (cpi->buffer_level >> 1))
1811 cpi->gf_bits = cpi->buffer_level >> 1;
1814 // Dont allow a negative value for gf_bits
1815 if (cpi->gf_bits < 0)
1818 // Adjust KF group bits and error remainin
1819 cpi->kf_group_error_left -= gf_group_err;
1820 cpi->kf_group_bits -= cpi->gf_group_bits;
1822 if (cpi->kf_group_bits < 0)
1823 cpi->kf_group_bits = 0;
1825 // Note the error score left in the remaining frames of the group.
1826 // 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)
1827 if (!cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME)
1828 cpi->gf_group_error_left = gf_group_err - gf_first_frame_err;
1830 cpi->gf_group_error_left = gf_group_err;
1832 cpi->gf_group_bits -= cpi->gf_bits;
1834 if (cpi->gf_group_bits < 0)
1835 cpi->gf_group_bits = 0;
1837 // Set aside some bits for a mid gf sequence boost
1838 if ((cpi->gfu_boost > 150) && (cpi->baseline_gf_interval > 5))
1840 int pct_extra = (cpi->gfu_boost - 100) / 50;
1841 pct_extra = (pct_extra > 10) ? 10 : pct_extra;
1843 cpi->mid_gf_extra_bits = (cpi->gf_group_bits * pct_extra) / 100;
1844 cpi->gf_group_bits -= cpi->mid_gf_extra_bits;
1847 cpi->mid_gf_extra_bits = 0;
1849 cpi->gf_bits += cpi->min_frame_bandwidth; // Add in minimum for a frame
1852 if (!cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME)) // Normal GF and not a KF
1854 cpi->per_frame_bandwidth = cpi->gf_bits; // Per frame bit target for this frame
1857 // Adjustment to estimate_max_q based on a measure of complexity of the section
1858 if (cpi->common.frame_type != KEY_FRAME)
1860 FIRSTPASS_STATS sectionstats;
1863 zero_stats(§ionstats);
1864 reset_fpf_position(cpi, start_pos);
1866 for (i = 0 ; i < cpi->baseline_gf_interval ; i++)
1868 input_stats(cpi, &next_frame);
1869 accumulate_stats(§ionstats, &next_frame);
1872 avg_stats(§ionstats);
1874 cpi->section_intra_rating =
1875 sectionstats.intra_error /
1876 DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
1878 Ratio = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
1879 //if( (Ratio > 11) ) //&& (sectionstats.pcnt_second_ref < .20) )
1881 cpi->section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025);
1883 if (cpi->section_max_qfactor < 0.80)
1884 cpi->section_max_qfactor = 0.80;
1888 // cpi->section_max_qfactor = 1.0;
1890 reset_fpf_position(cpi, start_pos);
1894 // Allocate bits to a normal frame that is neither a gf an arf or a key frame.
1895 static void assign_std_frame_bits(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
1897 int target_frame_size; // gf_group_error_left
1899 double modified_err;
1900 double err_fraction; // What portion of the remaining GF group error is used by this frame
1902 int max_bits = frame_max_bits(cpi); // Max for a single frame
1904 // The final few frames have special treatment
1905 if (cpi->frames_till_gf_update_due >= (int)(cpi->total_stats->count - cpi->common.current_video_frame))
1907 cpi->gf_group_bits = (cpi->bits_left > 0) ? cpi->bits_left : 0;;
1910 // Calculate modified prediction error used in bit allocation
1911 modified_err = calculate_modified_err(cpi, this_frame);
1913 if (cpi->gf_group_error_left > 0)
1914 err_fraction = modified_err / cpi->gf_group_error_left; // What portion of the remaining GF group error is used by this frame
1918 target_frame_size = (int)((double)cpi->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->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->gf_group_bits)
1929 target_frame_size = cpi->gf_group_bits;
1932 cpi->gf_group_error_left -= modified_err; // Adjust error remaining
1933 cpi->gf_group_bits -= target_frame_size; // Adjust bits remaining
1935 if (cpi->gf_group_bits < 0)
1936 cpi->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->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->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;
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 // Store information regarding level of motion etc for use mode decisions.
1976 cpi->motion_speed = (int)(fabs(this_frame.MVr) + fabs(this_frame.MVc));
1977 cpi->motion_var = (int)(fabs(this_frame.MVrv) + fabs(this_frame.MVcv));
1978 cpi->inter_lvl = (int)(this_frame.pcnt_inter * 100);
1979 cpi->intra_lvl = (int)((1.0 - this_frame.pcnt_inter) * 100);
1980 cpi->motion_lvl = (int)(this_frame.pcnt_motion * 100);
1982 start_pos = cpi->stats_in;
1984 // keyframe and section processing !
1985 if (cpi->frames_to_key == 0)
1987 // Define next KF group and assign bits to it
1988 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
1989 find_next_key_frame(cpi, &this_frame_copy);
1991 // 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
1992 // outlandish behaviour if someone does set it when using two pass. It effectively disables GF groups.
1993 // This is temporary code till we decide what should really happen in this case.
1994 if (cpi->oxcf.error_resilient_mode)
1996 cpi->gf_group_bits = cpi->kf_group_bits;
1997 cpi->gf_group_error_left = cpi->kf_group_error_left;
1998 cpi->baseline_gf_interval = cpi->frames_to_key;
1999 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
2000 cpi->source_alt_ref_pending = FALSE;
2005 // Is this a GF / ARF (Note that a KF is always also a GF)
2006 if (cpi->frames_till_gf_update_due == 0)
2008 // Update monitor of the bits per error observed so far.
2009 // Done once per gf group based on what has gone before
2010 // so do nothing if this is the first frame.
2011 if (cpi->common.current_video_frame > 0)
2014 (double)(cpi->clip_bits_total - cpi->bits_left) /
2015 cpi->modified_error_used;
2018 // Define next gf group and assign bits to it
2019 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2020 define_gf_group(cpi, &this_frame_copy);
2022 // If we are going to code an altref frame at the end of the group and the current frame is not a key frame....
2023 // If the previous group used an arf this frame has already benefited from that arf boost and it should not be given extra bits
2024 // If the previous group was NOT coded using arf we may want to apply some boost to this GF as well
2025 if (cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME))
2027 // Assign a standard frames worth of bits from those allocated to the GF group
2028 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2029 assign_std_frame_bits(cpi, &this_frame_copy);
2031 // If appropriate (we are switching into ARF active but it was not previously active) apply a boost for the gf at the start of the group.
2032 //if ( !cpi->source_alt_ref_active && (cpi->gfu_boost > 150) )
2036 int pct_extra = (cpi->gfu_boost - 100) / 50;
2038 pct_extra = (pct_extra > 20) ? 20 : pct_extra;
2040 extra_bits = (cpi->gf_group_bits * pct_extra) / 100;
2041 cpi->gf_group_bits -= extra_bits;
2042 cpi->per_frame_bandwidth += extra_bits;
2047 // Otherwise this is an ordinary frame
2050 // 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
2051 // outlandish behaviour if someone does set it when using two pass. It effectively disables GF groups.
2052 // This is temporary code till we decide what should really happen in this case.
2053 if (cpi->oxcf.error_resilient_mode)
2055 cpi->frames_till_gf_update_due = cpi->frames_to_key;
2057 if (cpi->common.frame_type != KEY_FRAME)
2059 // Assign bits from those allocated to the GF group
2060 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2061 assign_std_frame_bits(cpi, &this_frame_copy);
2066 // Assign bits from those allocated to the GF group
2067 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2068 assign_std_frame_bits(cpi, &this_frame_copy);
2072 // Keep a globally available copy of this and the next frame's iiratio.
2073 cpi->this_iiratio = this_frame_intra_error /
2074 DOUBLE_DIVIDE_CHECK(this_frame_coded_error);
2076 FIRSTPASS_STATS next_frame;
2077 if ( lookup_next_frame_stats(cpi, &next_frame) != EOF )
2079 cpi->next_iiratio = next_frame.intra_error /
2080 DOUBLE_DIVIDE_CHECK(next_frame.coded_error);
2084 // Set nominal per second bandwidth for this frame
2085 cpi->target_bandwidth = cpi->per_frame_bandwidth * cpi->output_frame_rate;
2086 if (cpi->target_bandwidth < 0)
2087 cpi->target_bandwidth = 0;
2089 if (cpi->common.current_video_frame == 0)
2091 cpi->est_max_qcorrection_factor = 1.0;
2093 // Experimental code to try and set a cq_level in constrained
2095 if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY )
2101 (cpi->total_coded_error_left / frames_left),
2102 (int)(cpi->bits_left / frames_left));
2104 cpi->cq_target_quality = cpi->oxcf.cq_level;
2105 if ( est_cq > cpi->cq_target_quality )
2106 cpi->cq_target_quality = est_cq;
2109 // guess at maxq needed in 2nd pass
2110 cpi->maxq_max_limit = cpi->worst_quality;
2111 cpi->maxq_min_limit = cpi->best_quality;
2112 tmp_q = estimate_max_q( cpi,
2113 (cpi->total_coded_error_left / frames_left),
2114 (int)(cpi->bits_left / frames_left));
2116 // Limit the maxq value returned subsequently.
2117 // This increases the risk of overspend or underspend if the initial
2118 // estimate for the clip is bad, but helps prevent excessive
2119 // variation in Q, especially near the end of a clip
2120 // where for example a small overspend may cause Q to crash
2121 cpi->maxq_max_limit = ((tmp_q + 32) < cpi->worst_quality)
2122 ? (tmp_q + 32) : cpi->worst_quality;
2123 cpi->maxq_min_limit = ((tmp_q - 32) > cpi->best_quality)
2124 ? (tmp_q - 32) : cpi->best_quality;
2126 cpi->active_worst_quality = tmp_q;
2127 cpi->ni_av_qi = tmp_q;
2130 // The last few frames of a clip almost always have to few or too many
2131 // bits and for the sake of over exact rate control we dont want to make
2132 // radical adjustments to the allowed quantizer range just to use up a
2133 // few surplus bits or get beneath the target rate.
2134 else if ( (cpi->common.current_video_frame <
2135 (((unsigned int)cpi->total_stats->count * 255)>>8)) &&
2136 ((cpi->common.current_video_frame + cpi->baseline_gf_interval) <
2137 (unsigned int)cpi->total_stats->count) )
2139 if (frames_left < 1)
2142 tmp_q = estimate_max_q(cpi, (cpi->total_coded_error_left / frames_left), (int)(cpi->bits_left / frames_left));
2144 // Move active_worst_quality but in a damped way
2145 if (tmp_q > cpi->active_worst_quality)
2146 cpi->active_worst_quality ++;
2147 else if (tmp_q < cpi->active_worst_quality)
2148 cpi->active_worst_quality --;
2150 cpi->active_worst_quality = ((cpi->active_worst_quality * 3) + tmp_q + 2) / 4;
2153 cpi->frames_to_key --;
2154 cpi->total_error_left -= this_frame_error;
2155 cpi->total_intra_error_left -= this_frame_intra_error;
2156 cpi->total_coded_error_left -= this_frame_coded_error;
2160 static BOOL test_candidate_kf(VP8_COMP *cpi, FIRSTPASS_STATS *last_frame, FIRSTPASS_STATS *this_frame, FIRSTPASS_STATS *next_frame)
2162 BOOL is_viable_kf = FALSE;
2164 // Does the frame satisfy the primary criteria of a key frame
2165 // If so, then examine how well it predicts subsequent frames
2166 if ((this_frame->pcnt_second_ref < 0.10) &&
2167 (next_frame->pcnt_second_ref < 0.10) &&
2168 ((this_frame->pcnt_inter < 0.05) ||
2170 ((this_frame->pcnt_inter - this_frame->pcnt_neutral) < .25) &&
2171 ((this_frame->intra_error / DOUBLE_DIVIDE_CHECK(this_frame->coded_error)) < 2.5) &&
2172 ((fabs(last_frame->coded_error - this_frame->coded_error) / DOUBLE_DIVIDE_CHECK(this_frame->coded_error) > .40) ||
2173 (fabs(last_frame->intra_error - this_frame->intra_error) / DOUBLE_DIVIDE_CHECK(this_frame->intra_error) > .40) ||
2174 ((next_frame->intra_error / DOUBLE_DIVIDE_CHECK(next_frame->coded_error)) > 3.5)
2181 FIRSTPASS_STATS *start_pos;
2183 FIRSTPASS_STATS local_next_frame;
2185 double boost_score = 0.0;
2186 double old_boost_score = 0.0;
2187 double decay_accumulator = 1.0;
2188 double next_iiratio;
2190 vpx_memcpy(&local_next_frame, next_frame, sizeof(*next_frame));
2192 // Note the starting file position so we can reset to it
2193 start_pos = cpi->stats_in;
2195 // Examine how well the key frame predicts subsequent frames
2196 for (i = 0 ; i < 16; i++)
2198 next_iiratio = (IIKFACTOR1 * local_next_frame.intra_error / DOUBLE_DIVIDE_CHECK(local_next_frame.coded_error)) ;
2200 if (next_iiratio > RMAX)
2201 next_iiratio = RMAX;
2203 // Cumulative effect of decay in prediction quality
2204 if (local_next_frame.pcnt_inter > 0.85)
2205 decay_accumulator = decay_accumulator * local_next_frame.pcnt_inter;
2207 decay_accumulator = decay_accumulator * ((0.85 + local_next_frame.pcnt_inter) / 2.0);
2209 //decay_accumulator = decay_accumulator * local_next_frame.pcnt_inter;
2211 // Keep a running total
2212 boost_score += (decay_accumulator * next_iiratio);
2214 // Test various breakout clauses
2215 if ((local_next_frame.pcnt_inter < 0.05) ||
2216 (next_iiratio < 1.5) ||
2217 (((local_next_frame.pcnt_inter -
2218 local_next_frame.pcnt_neutral) < 0.20) &&
2219 (next_iiratio < 3.0)) ||
2220 ((boost_score - old_boost_score) < 0.5) ||
2221 (local_next_frame.intra_error < 200)
2227 old_boost_score = boost_score;
2229 // Get the next frame details
2230 if (EOF == input_stats(cpi, &local_next_frame))
2234 // If there is tolerable prediction for at least the next 3 frames then break out else discard this pottential key frame and move on
2235 if (boost_score > 5.0 && (i > 3))
2236 is_viable_kf = TRUE;
2239 // Reset the file position
2240 reset_fpf_position(cpi, start_pos);
2242 is_viable_kf = FALSE;
2246 return is_viable_kf;
2248 static void find_next_key_frame(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
2251 FIRSTPASS_STATS last_frame;
2252 FIRSTPASS_STATS first_frame;
2253 FIRSTPASS_STATS next_frame;
2254 FIRSTPASS_STATS *start_position;
2256 double decay_accumulator = 1.0;
2257 double boost_score = 0;
2258 double old_boost_score = 0.0;
2259 double loop_decay_rate;
2261 double kf_mod_err = 0.0;
2262 double kf_group_err = 0.0;
2263 double kf_group_intra_err = 0.0;
2264 double kf_group_coded_err = 0.0;
2265 double recent_loop_decay[8] = {1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0};
2267 vpx_memset(&next_frame, 0, sizeof(next_frame)); // assure clean
2269 vp8_clear_system_state(); //__asm emms;
2270 start_position = cpi->stats_in;
2272 cpi->common.frame_type = KEY_FRAME;
2274 // is this a forced key frame by interval
2275 cpi->this_key_frame_forced = cpi->next_key_frame_forced;
2277 // Clear the alt ref active flag as this can never be active on a key frame
2278 cpi->source_alt_ref_active = FALSE;
2280 // Kf is always a gf so clear frames till next gf counter
2281 cpi->frames_till_gf_update_due = 0;
2283 cpi->frames_to_key = 1;
2285 // Take a copy of the initial frame details
2286 vpx_memcpy(&first_frame, this_frame, sizeof(*this_frame));
2288 cpi->kf_group_bits = 0; // Total bits avaialable to kf group
2289 cpi->kf_group_error_left = 0; // Group modified error score.
2291 kf_mod_err = calculate_modified_err(cpi, this_frame);
2293 // find the next keyframe
2295 while (cpi->stats_in < cpi->stats_in_end)
2297 // Accumulate kf group error
2298 kf_group_err += calculate_modified_err(cpi, this_frame);
2300 // These figures keep intra and coded error counts for all frames including key frames in the group.
2301 // The effect of the key frame itself can be subtracted out using the first_frame data collected above
2302 kf_group_intra_err += this_frame->intra_error;
2303 kf_group_coded_err += this_frame->coded_error;
2305 // load a the next frame's stats
2306 vpx_memcpy(&last_frame, this_frame, sizeof(*this_frame));
2307 input_stats(cpi, this_frame);
2309 // Provided that we are not at the end of the file...
2310 if (cpi->oxcf.auto_key
2311 && lookup_next_frame_stats(cpi, &next_frame) != EOF)
2313 // Normal scene cut check
2314 if (test_candidate_kf(cpi, &last_frame, this_frame, &next_frame))
2317 // How fast is prediction quality decaying
2318 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
2320 // We want to know something about the recent past... rather than
2321 // as used elsewhere where we are concened with decay in prediction
2322 // quality since the last GF or KF.
2323 recent_loop_decay[i%8] = loop_decay_rate;
2324 decay_accumulator = 1.0;
2325 for (j = 0; j < 8; j++)
2327 decay_accumulator = decay_accumulator * recent_loop_decay[j];
2330 // Special check for transition or high motion followed by a
2331 // to a static scene.
2332 if ( detect_transition_to_still( cpi, i,
2333 (cpi->key_frame_frequency-i),
2335 decay_accumulator ) )
2341 // Step on to the next frame
2342 cpi->frames_to_key ++;
2344 // If we don't have a real key frame within the next two
2345 // forcekeyframeevery intervals then break out of the loop.
2346 if (cpi->frames_to_key >= 2 *(int)cpi->key_frame_frequency)
2349 cpi->frames_to_key ++;
2354 // If there is a max kf interval set by the user we must obey it.
2355 // We already breakout of the loop above at 2x max.
2356 // This code centers the extra kf if the actual natural
2357 // interval is between 1x and 2x
2358 if (cpi->oxcf.auto_key
2359 && cpi->frames_to_key > (int)cpi->key_frame_frequency )
2361 FIRSTPASS_STATS *current_pos = cpi->stats_in;
2362 FIRSTPASS_STATS tmp_frame;
2364 cpi->frames_to_key /= 2;
2366 // Copy first frame details
2367 vpx_memcpy(&tmp_frame, &first_frame, sizeof(first_frame));
2369 // Reset to the start of the group
2370 reset_fpf_position(cpi, start_position);
2373 kf_group_intra_err = 0;
2374 kf_group_coded_err = 0;
2376 // Rescan to get the correct error data for the forced kf group
2377 for( i = 0; i < cpi->frames_to_key; i++ )
2379 // Accumulate kf group errors
2380 kf_group_err += calculate_modified_err(cpi, &tmp_frame);
2381 kf_group_intra_err += tmp_frame.intra_error;
2382 kf_group_coded_err += tmp_frame.coded_error;
2384 // Load a the next frame's stats
2385 input_stats(cpi, &tmp_frame);
2388 // Reset to the start of the group
2389 reset_fpf_position(cpi, current_pos);
2391 cpi->next_key_frame_forced = TRUE;
2394 cpi->next_key_frame_forced = FALSE;
2396 // Special case for the last frame of the file
2397 if (cpi->stats_in >= cpi->stats_in_end)
2399 // Accumulate kf group error
2400 kf_group_err += calculate_modified_err(cpi, this_frame);
2402 // These figures keep intra and coded error counts for all frames including key frames in the group.
2403 // The effect of the key frame itself can be subtracted out using the first_frame data collected above
2404 kf_group_intra_err += this_frame->intra_error;
2405 kf_group_coded_err += this_frame->coded_error;
2408 // Calculate the number of bits that should be assigned to the kf group.
2409 if ((cpi->bits_left > 0) && (cpi->modified_error_left > 0.0))
2411 // Max for a single normal frame (not key frame)
2412 int max_bits = frame_max_bits(cpi);
2414 // Maximum bits for the kf group
2415 long long max_grp_bits;
2417 // Default allocation based on bits left and relative
2418 // complexity of the section
2419 cpi->kf_group_bits = (long long)( cpi->bits_left *
2421 cpi->modified_error_left ));
2423 // Clip based on maximum per frame rate defined by the user.
2424 max_grp_bits = (long long)max_bits * (long long)cpi->frames_to_key;
2425 if (cpi->kf_group_bits > max_grp_bits)
2426 cpi->kf_group_bits = max_grp_bits;
2428 // Additional special case for CBR if buffer is getting full.
2429 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2431 int opt_buffer_lvl = cpi->oxcf.optimal_buffer_level;
2432 int buffer_lvl = cpi->buffer_level;
2434 // If the buffer is near or above the optimal and this kf group is
2435 // not being allocated much then increase the allocation a bit.
2436 if (buffer_lvl >= opt_buffer_lvl)
2438 int high_water_mark = (opt_buffer_lvl +
2439 cpi->oxcf.maximum_buffer_size) >> 1;
2441 long long av_group_bits;
2443 // Av bits per frame * number of frames
2444 av_group_bits = (long long)cpi->av_per_frame_bandwidth *
2445 (long long)cpi->frames_to_key;
2447 // We are at or above the maximum.
2448 if (cpi->buffer_level >= high_water_mark)
2450 long long min_group_bits;
2452 min_group_bits = av_group_bits +
2453 (long long)(buffer_lvl -
2456 if (cpi->kf_group_bits < min_group_bits)
2457 cpi->kf_group_bits = min_group_bits;
2459 // We are above optimal but below the maximum
2460 else if (cpi->kf_group_bits < av_group_bits)
2462 long long bits_below_av = av_group_bits -
2465 cpi->kf_group_bits +=
2466 (long long)((double)bits_below_av *
2467 (double)(buffer_lvl - opt_buffer_lvl) /
2468 (double)(high_water_mark - opt_buffer_lvl));
2474 cpi->kf_group_bits = 0;
2476 // Reset the first pass file position
2477 reset_fpf_position(cpi, start_position);
2479 // determine how big to make this keyframe based on how well the subsequent frames use inter blocks
2480 decay_accumulator = 1.0;
2482 loop_decay_rate = 1.00; // Starting decay rate
2484 for (i = 0 ; i < cpi->frames_to_key ; i++)
2488 if (EOF == input_stats(cpi, &next_frame))
2491 if (next_frame.intra_error > cpi->kf_intra_err_min)
2492 r = (IIKFACTOR2 * next_frame.intra_error /
2493 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2495 r = (IIKFACTOR2 * cpi->kf_intra_err_min /
2496 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2501 // How fast is prediction quality decaying
2502 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
2504 decay_accumulator = decay_accumulator * loop_decay_rate;
2505 decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
2507 boost_score += (decay_accumulator * r);
2509 if ((i > MIN_GF_INTERVAL) &&
2510 ((boost_score - old_boost_score) < 1.0))
2515 old_boost_score = boost_score;
2520 FIRSTPASS_STATS sectionstats;
2523 zero_stats(§ionstats);
2524 reset_fpf_position(cpi, start_position);
2526 for (i = 0 ; i < cpi->frames_to_key ; i++)
2528 input_stats(cpi, &next_frame);
2529 accumulate_stats(§ionstats, &next_frame);
2532 avg_stats(§ionstats);
2534 cpi->section_intra_rating = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
2536 Ratio = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
2537 // if( (Ratio > 11) ) //&& (sectionstats.pcnt_second_ref < .20) )
2539 cpi->section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025);
2541 if (cpi->section_max_qfactor < 0.80)
2542 cpi->section_max_qfactor = 0.80;
2546 // cpi->section_max_qfactor = 1.0;
2549 // When using CBR apply additional buffer fullness related upper limits
2550 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2554 if (cpi->drop_frames_allowed)
2556 int df_buffer_level = cpi->oxcf.drop_frames_water_mark * (cpi->oxcf.optimal_buffer_level / 100);
2558 if (cpi->buffer_level > df_buffer_level)
2559 max_boost = ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
2563 else if (cpi->buffer_level > 0)
2565 max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
2572 if (boost_score > max_boost)
2573 boost_score = max_boost;
2576 // Reset the first pass file position
2577 reset_fpf_position(cpi, start_position);
2579 // Work out how many bits to allocate for the key frame itself
2582 int kf_boost = boost_score;
2583 int allocation_chunks;
2584 int Counter = cpi->frames_to_key;
2586 YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
2587 // Min boost based on kf interval
2590 while ((kf_boost < 48) && (Counter > 0))
2600 kf_boost += ((Counter + 1) >> 1);
2602 if (kf_boost > 48) kf_boost = 48;
2605 // bigger frame sizes need larger kf boosts, smaller frames smaller boosts...
2606 if ((lst_yv12->y_width * lst_yv12->y_height) > (320 * 240))
2607 kf_boost += 2 * (lst_yv12->y_width * lst_yv12->y_height) / (320 * 240);
2608 else if ((lst_yv12->y_width * lst_yv12->y_height) < (320 * 240))
2609 kf_boost -= 4 * (320 * 240) / (lst_yv12->y_width * lst_yv12->y_height);
2611 kf_boost = (int)((double)kf_boost * 100.0) >> 4; // Scale 16 to 100
2613 // Adjustment to boost based on recent average q
2614 //kf_boost = kf_boost * vp8_kf_boost_qadjustment[cpi->ni_av_qi] / 100;
2616 if (kf_boost < 250) // Min KF boost
2619 // We do three calculations for kf size.
2620 // The first is based on the error score for the whole kf group.
2621 // The second (optionaly) on the key frames own error if this is smaller than the average for the group.
2622 // 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
2624 allocation_chunks = ((cpi->frames_to_key - 1) * 100) + kf_boost; // cpi->frames_to_key-1 because key frame itself is taken care of by kf_boost
2626 // Normalize Altboost and allocations chunck down to prevent overflow
2627 while (kf_boost > 1000)
2630 allocation_chunks /= 2;
2633 cpi->kf_group_bits = (cpi->kf_group_bits < 0) ? 0 : cpi->kf_group_bits;
2635 // Calculate the number of bits to be spent on the key frame
2636 cpi->kf_bits = (int)((double)kf_boost * ((double)cpi->kf_group_bits / (double)allocation_chunks));
2638 // Apply an additional limit for CBR
2639 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2641 if (cpi->kf_bits > ((3 * cpi->buffer_level) >> 2))
2642 cpi->kf_bits = (3 * cpi->buffer_level) >> 2;
2645 // If the key frame is actually easier than the average for the
2646 // kf group (which does sometimes happen... eg a blank intro frame)
2647 // Then use an alternate calculation based on the kf error score
2648 // which should give a smaller key frame.
2649 if (kf_mod_err < kf_group_err / cpi->frames_to_key)
2651 double alt_kf_grp_bits =
2652 ((double)cpi->bits_left *
2653 (kf_mod_err * (double)cpi->frames_to_key) /
2654 DOUBLE_DIVIDE_CHECK(cpi->modified_error_left));
2656 alt_kf_bits = (int)((double)kf_boost *
2657 (alt_kf_grp_bits / (double)allocation_chunks));
2659 if (cpi->kf_bits > alt_kf_bits)
2661 cpi->kf_bits = alt_kf_bits;
2664 // Else if it is much harder than other frames in the group make sure
2665 // it at least receives an allocation in keeping with its relative
2670 (int)((double)cpi->bits_left *
2672 DOUBLE_DIVIDE_CHECK(cpi->modified_error_left)));
2674 if (alt_kf_bits > cpi->kf_bits)
2676 cpi->kf_bits = alt_kf_bits;
2680 cpi->kf_group_bits -= cpi->kf_bits;
2681 cpi->kf_bits += cpi->min_frame_bandwidth; // Add in the minimum frame allowance
2683 cpi->per_frame_bandwidth = cpi->kf_bits; // Peer frame bit target for this frame
2684 cpi->target_bandwidth = cpi->kf_bits * cpi->output_frame_rate; // Convert to a per second bitrate
2687 // Note the total error score of the kf group minus the key frame itself
2688 cpi->kf_group_error_left = (int)(kf_group_err - kf_mod_err);
2690 // Adjust the count of total modified error left.
2691 // The count of bits left is adjusted elsewhere based on real coded frame sizes
2692 cpi->modified_error_left -= kf_group_err;
2694 if (cpi->oxcf.allow_spatial_resampling)
2696 int resample_trigger = FALSE;
2697 int last_kf_resampled = FALSE;
2701 int new_width = cpi->oxcf.Width;
2702 int new_height = cpi->oxcf.Height;
2704 int projected_buffer_level = cpi->buffer_level;
2707 double projected_bits_perframe;
2708 double group_iiratio = (kf_group_intra_err - first_frame.intra_error) / (kf_group_coded_err - first_frame.coded_error);
2709 double err_per_frame = kf_group_err / cpi->frames_to_key;
2710 double bits_per_frame;
2711 double av_bits_per_frame;
2712 double effective_size_ratio;
2714 if ((cpi->common.Width != cpi->oxcf.Width) || (cpi->common.Height != cpi->oxcf.Height))
2715 last_kf_resampled = TRUE;
2717 // Set back to unscaled by defaults
2718 cpi->common.horiz_scale = NORMAL;
2719 cpi->common.vert_scale = NORMAL;
2721 // Calculate Average bits per frame.
2722 //av_bits_per_frame = cpi->bits_left/(double)(cpi->total_stats->count - cpi->common.current_video_frame);
2723 av_bits_per_frame = cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.frame_rate);
2724 //if ( av_bits_per_frame < 0.0 )
2725 // av_bits_per_frame = 0.0
2727 // CBR... Use the clip average as the target for deciding resample
2728 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2730 bits_per_frame = av_bits_per_frame;
2733 // In VBR we want to avoid downsampling in easy section unless we are under extreme pressure
2734 // So use the larger of target bitrate for this sectoion or average bitrate for sequence
2737 bits_per_frame = cpi->kf_group_bits / cpi->frames_to_key; // This accounts for how hard the section is...
2739 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
2740 bits_per_frame = av_bits_per_frame;
2743 // bits_per_frame should comply with our minimum
2744 if (bits_per_frame < (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100))
2745 bits_per_frame = (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100);
2747 // Work out if spatial resampling is necessary
2748 kf_q = estimate_kf_group_q(cpi, err_per_frame, bits_per_frame, group_iiratio);
2750 // 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
2751 projected_bits_perframe = bits_per_frame;
2754 while (tmp_q > cpi->worst_quality)
2756 projected_bits_perframe *= 1.04;
2760 // Guess at buffer level at the end of the section
2761 projected_buffer_level = cpi->buffer_level - (int)((projected_bits_perframe - av_bits_per_frame) * cpi->frames_to_key);
2765 FILE *f = fopen("Subsamle.stt", "a");
2766 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->frames_to_key, (int)(cpi->kf_group_bits / cpi->frames_to_key), new_height, new_width);
2770 // The trigger for spatial resampling depends on the various parameters such as whether we are streaming (CBR) or VBR.
2771 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2773 // Trigger resample if we are projected to fall below down sample level or
2774 // resampled last time and are projected to remain below the up sample level
2775 if ((projected_buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100)) ||
2776 (last_kf_resampled && (projected_buffer_level < (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))))
2777 //( ((cpi->buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100))) &&
2778 // ((projected_buffer_level < (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))) ))
2779 resample_trigger = TRUE;
2781 resample_trigger = FALSE;
2785 long long clip_bits = (long long)(cpi->total_stats->count * cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.frame_rate));
2786 long long over_spend = cpi->oxcf.starting_buffer_level - cpi->buffer_level;
2788 if ((last_kf_resampled && (kf_q > cpi->worst_quality)) || // If triggered last time the threshold for triggering again is reduced
2789 ((kf_q > cpi->worst_quality) && // Projected Q higher than allowed and ...
2790 (over_spend > clip_bits / 20))) // ... Overspend > 5% of total bits
2791 resample_trigger = TRUE;
2793 resample_trigger = FALSE;
2797 if (resample_trigger)
2799 while ((kf_q >= cpi->worst_quality) && (scale_val < 6))
2803 cpi->common.vert_scale = vscale_lookup[scale_val];
2804 cpi->common.horiz_scale = hscale_lookup[scale_val];
2806 Scale2Ratio(cpi->common.horiz_scale, &hr, &hs);
2807 Scale2Ratio(cpi->common.vert_scale, &vr, &vs);
2809 new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs;
2810 new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs;
2812 // Reducing the area to 1/4 does not reduce the complexity (err_per_frame) to 1/4...
2813 // effective_sizeratio attempts to provide a crude correction for this
2814 effective_size_ratio = (double)(new_width * new_height) / (double)(cpi->oxcf.Width * cpi->oxcf.Height);
2815 effective_size_ratio = (1.0 + (3.0 * effective_size_ratio)) / 4.0;
2817 // Now try again and see what Q we get with the smaller image size
2818 kf_q = estimate_kf_group_q(cpi, err_per_frame * effective_size_ratio, bits_per_frame, group_iiratio);
2822 FILE *f = fopen("Subsamle.stt", "a");
2823 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->frames_to_key, (int)(cpi->kf_group_bits / cpi->frames_to_key), new_height, new_width);
2829 if ((cpi->common.Width != new_width) || (cpi->common.Height != new_height))
2831 cpi->common.Width = new_width;
2832 cpi->common.Height = new_height;
2833 vp8_alloc_compressor_data(cpi);