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