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