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