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 140 /* TEMP debug code */ 141 #if OUTPUT_FPF 142 143 { 144 FILE *fpfile; 145 fpfile = fopen("firstpass.stt", "a"); 146 147 fprintf(fpfile, "%12.0f %12.0f %12.0f %12.4f %12.4f %12.4f %12.4f" 148 " %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f" 149 " %12.0f %12.0f %12.4f\n", 150 stats->frame, 151 stats->intra_error, 152 stats->coded_error, 153 stats->ssim_weighted_pred_err, 154 stats->pcnt_inter, 155 stats->pcnt_motion, 156 stats->pcnt_second_ref, 157 stats->pcnt_neutral, 158 stats->MVr, 159 stats->mvr_abs, 160 stats->MVc, 161 stats->mvc_abs, 162 stats->MVrv, 163 stats->MVcv, 164 stats->mv_in_out_count, 165 stats->new_mv_count, 166 stats->count, 167 stats->duration); 168 fclose(fpfile); 169 } 170 #endif 171 } 172 173 static void zero_stats(FIRSTPASS_STATS *section) 174 { 175 section->frame = 0.0; 176 section->intra_error = 0.0; 177 section->coded_error = 0.0; 178 section->ssim_weighted_pred_err = 0.0; 179 section->pcnt_inter = 0.0; 180 section->pcnt_motion = 0.0; 181 section->pcnt_second_ref = 0.0; 182 section->pcnt_neutral = 0.0; 183 section->MVr = 0.0; 184 section->mvr_abs = 0.0; 185 section->MVc = 0.0; 186 section->mvc_abs = 0.0; 187 section->MVrv = 0.0; 188 section->MVcv = 0.0; 189 section->mv_in_out_count = 0.0; 190 section->new_mv_count = 0.0; 191 section->count = 0.0; 192 section->duration = 1.0; 193 } 194 195 static void accumulate_stats(FIRSTPASS_STATS *section, FIRSTPASS_STATS *frame) 196 { 197 section->frame += frame->frame; 198 section->intra_error += frame->intra_error; 199 section->coded_error += frame->coded_error; 200 section->ssim_weighted_pred_err += frame->ssim_weighted_pred_err; 201 section->pcnt_inter += frame->pcnt_inter; 202 section->pcnt_motion += frame->pcnt_motion; 203 section->pcnt_second_ref += frame->pcnt_second_ref; 204 section->pcnt_neutral += frame->pcnt_neutral; 205 section->MVr += frame->MVr; 206 section->mvr_abs += frame->mvr_abs; 207 section->MVc += frame->MVc; 208 section->mvc_abs += frame->mvc_abs; 209 section->MVrv += frame->MVrv; 210 section->MVcv += frame->MVcv; 211 section->mv_in_out_count += frame->mv_in_out_count; 212 section->new_mv_count += frame->new_mv_count; 213 section->count += frame->count; 214 section->duration += frame->duration; 215 } 216 217 static void subtract_stats(FIRSTPASS_STATS *section, FIRSTPASS_STATS *frame) 218 { 219 section->frame -= frame->frame; 220 section->intra_error -= frame->intra_error; 221 section->coded_error -= frame->coded_error; 222 section->ssim_weighted_pred_err -= frame->ssim_weighted_pred_err; 223 section->pcnt_inter -= frame->pcnt_inter; 224 section->pcnt_motion -= frame->pcnt_motion; 225 section->pcnt_second_ref -= frame->pcnt_second_ref; 226 section->pcnt_neutral -= frame->pcnt_neutral; 227 section->MVr -= frame->MVr; 228 section->mvr_abs -= frame->mvr_abs; 229 section->MVc -= frame->MVc; 230 section->mvc_abs -= frame->mvc_abs; 231 section->MVrv -= frame->MVrv; 232 section->MVcv -= frame->MVcv; 233 section->mv_in_out_count -= frame->mv_in_out_count; 234 section->new_mv_count -= frame->new_mv_count; 235 section->count -= frame->count; 236 section->duration -= frame->duration; 237 } 238 239 static void avg_stats(FIRSTPASS_STATS *section) 240 { 241 if (section->count < 1.0) 242 return; 243 244 section->intra_error /= section->count; 245 section->coded_error /= section->count; 246 section->ssim_weighted_pred_err /= section->count; 247 section->pcnt_inter /= section->count; 248 section->pcnt_second_ref /= section->count; 249 section->pcnt_neutral /= section->count; 250 section->pcnt_motion /= section->count; 251 section->MVr /= section->count; 252 section->mvr_abs /= section->count; 253 section->MVc /= section->count; 254 section->mvc_abs /= section->count; 255 section->MVrv /= section->count; 256 section->MVcv /= section->count; 257 section->mv_in_out_count /= section->count; 258 section->duration /= section->count; 259 } 260 261 /* Calculate a modified Error used in distributing bits between easier 262 * and harder frames 263 */ 264 static double calculate_modified_err(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame) 265 { 266 double av_err = ( cpi->twopass.total_stats.ssim_weighted_pred_err / 267 cpi->twopass.total_stats.count ); 268 double this_err = this_frame->ssim_weighted_pred_err; 269 double modified_err; 270 271 if (this_err > av_err) 272 modified_err = av_err * pow((this_err / DOUBLE_DIVIDE_CHECK(av_err)), POW1); 273 else 274 modified_err = av_err * pow((this_err / DOUBLE_DIVIDE_CHECK(av_err)), POW2); 275 276 return modified_err; 277 } 278 279 static const double weight_table[256] = { 280 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 281 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 282 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 283 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 284 0.020000, 0.031250, 0.062500, 0.093750, 0.125000, 0.156250, 0.187500, 0.218750, 285 0.250000, 0.281250, 0.312500, 0.343750, 0.375000, 0.406250, 0.437500, 0.468750, 286 0.500000, 0.531250, 0.562500, 0.593750, 0.625000, 0.656250, 0.687500, 0.718750, 287 0.750000, 0.781250, 0.812500, 0.843750, 0.875000, 0.906250, 0.937500, 0.968750, 288 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 289 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 290 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 291 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 292 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 293 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 294 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 295 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 296 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 297 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 298 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 299 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 300 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 301 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 302 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 303 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 304 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 305 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 306 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 307 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 308 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 309 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 310 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 311 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000 312 }; 313 314 static double simple_weight(YV12_BUFFER_CONFIG *source) 315 { 316 int i, j; 317 318 unsigned char *src = source->y_buffer; 319 double sum_weights = 0.0; 320 321 /* Loop throught the Y plane raw examining levels and creating a weight 322 * for the image 323 */ 324 i = source->y_height; 325 do 326 { 327 j = source->y_width; 328 do 329 { 330 sum_weights += weight_table[ *src]; 331 src++; 332 }while(--j); 333 src -= source->y_width; 334 src += source->y_stride; 335 }while(--i); 336 337 sum_weights /= (source->y_height * source->y_width); 338 339 return sum_weights; 340 } 341 342 343 /* This function returns the current per frame maximum bitrate target */ 344 static int frame_max_bits(VP8_COMP *cpi) 345 { 346 /* Max allocation for a single frame based on the max section guidelines 347 * passed in and how many bits are left 348 */ 349 int max_bits; 350 351 /* For CBR we need to also consider buffer fullness. 352 * If we are running below the optimal level then we need to gradually 353 * tighten up on max_bits. 354 */ 355 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 356 { 357 double buffer_fullness_ratio = (double)cpi->buffer_level / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.optimal_buffer_level); 358 359 /* For CBR base this on the target average bits per frame plus the 360 * maximum sedction rate passed in by the user 361 */ 362 max_bits = (int)(cpi->av_per_frame_bandwidth * ((double)cpi->oxcf.two_pass_vbrmax_section / 100.0)); 363 364 /* If our buffer is below the optimum level */ 365 if (buffer_fullness_ratio < 1.0) 366 { 367 /* The lower of max_bits / 4 or cpi->av_per_frame_bandwidth / 4. */ 368 int min_max_bits = ((cpi->av_per_frame_bandwidth >> 2) < (max_bits >> 2)) ? cpi->av_per_frame_bandwidth >> 2 : max_bits >> 2; 369 370 max_bits = (int)(max_bits * buffer_fullness_ratio); 371 372 /* Lowest value we will set ... which should allow the buffer to 373 * refill. 374 */ 375 if (max_bits < min_max_bits) 376 max_bits = min_max_bits; 377 } 378 } 379 /* VBR */ 380 else 381 { 382 /* For VBR base this on the bits and frames left plus the 383 * two_pass_vbrmax_section rate passed in by the user 384 */ 385 max_bits = (int)(((double)cpi->twopass.bits_left / (cpi->twopass.total_stats.count - (double)cpi->common.current_video_frame)) * ((double)cpi->oxcf.two_pass_vbrmax_section / 100.0)); 386 } 387 388 /* Trap case where we are out of bits */ 389 if (max_bits < 0) 390 max_bits = 0; 391 392 return max_bits; 393 } 394 395 void vp8_init_first_pass(VP8_COMP *cpi) 396 { 397 zero_stats(&cpi->twopass.total_stats); 398 } 399 400 void vp8_end_first_pass(VP8_COMP *cpi) 401 { 402 output_stats(cpi, cpi->output_pkt_list, &cpi->twopass.total_stats); 403 } 404 405 static void zz_motion_search( VP8_COMP *cpi, MACROBLOCK * x, 406 YV12_BUFFER_CONFIG * raw_buffer, 407 int * raw_motion_err, 408 YV12_BUFFER_CONFIG * recon_buffer, 409 int * best_motion_err, int recon_yoffset) 410 { 411 MACROBLOCKD * const xd = & x->e_mbd; 412 BLOCK *b = &x->block[0]; 413 BLOCKD *d = &x->e_mbd.block[0]; 414 415 unsigned char *src_ptr = (*(b->base_src) + b->src); 416 int src_stride = b->src_stride; 417 unsigned char *raw_ptr; 418 int raw_stride = raw_buffer->y_stride; 419 unsigned char *ref_ptr; 420 int ref_stride = x->e_mbd.pre.y_stride; 421 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 =((((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 } 1413 1414 /* This function gives and estimate of how badly we believe the prediction 1415 * quality is decaying from frame to frame. 1416 */ 1417 static double get_prediction_decay_rate(VP8_COMP *cpi, FIRSTPASS_STATS *next_frame) 1418 { 1419 double prediction_decay_rate; 1420 double motion_decay; 1421 double motion_pct = next_frame->pcnt_motion; 1422 1423 /* Initial basis is the % mbs inter coded */ 1424 prediction_decay_rate = next_frame->pcnt_inter; 1425 1426 /* High % motion -> somewhat higher decay rate */ 1427 motion_decay = (1.0 - (motion_pct / 20.0)); 1428 if (motion_decay < prediction_decay_rate) 1429 prediction_decay_rate = motion_decay; 1430 1431 /* Adjustment to decay rate based on speed of motion */ 1432 { 1433 double this_mv_rabs; 1434 double this_mv_cabs; 1435 double distance_factor; 1436 1437 this_mv_rabs = fabs(next_frame->mvr_abs * motion_pct); 1438 this_mv_cabs = fabs(next_frame->mvc_abs * motion_pct); 1439 1440 distance_factor = sqrt((this_mv_rabs * this_mv_rabs) + 1441 (this_mv_cabs * this_mv_cabs)) / 250.0; 1442 distance_factor = ((distance_factor > 1.0) 1443 ? 0.0 : (1.0 - distance_factor)); 1444 if (distance_factor < prediction_decay_rate) 1445 prediction_decay_rate = distance_factor; 1446 } 1447 1448 return prediction_decay_rate; 1449 } 1450 1451 /* Function to test for a condition where a complex transition is followed 1452 * by a static section. For example in slide shows where there is a fade 1453 * between slides. This is to help with more optimal kf and gf positioning. 1454 */ 1455 static int detect_transition_to_still( 1456 VP8_COMP *cpi, 1457 int frame_interval, 1458 int still_interval, 1459 double loop_decay_rate, 1460 double decay_accumulator ) 1461 { 1462 int trans_to_still = 0; 1463 1464 /* Break clause to detect very still sections after motion 1465 * For example a static image after a fade or other transition 1466 * instead of a clean scene cut. 1467 */ 1468 if ( (frame_interval > MIN_GF_INTERVAL) && 1469 (loop_decay_rate >= 0.999) && 1470 (decay_accumulator < 0.9) ) 1471 { 1472 int j; 1473 FIRSTPASS_STATS * position = cpi->twopass.stats_in; 1474 FIRSTPASS_STATS tmp_next_frame; 1475 double decay_rate; 1476 1477 /* Look ahead a few frames to see if static condition persists... */ 1478 for ( j = 0; j < still_interval; j++ ) 1479 { 1480 if (EOF == input_stats(cpi, &tmp_next_frame)) 1481 break; 1482 1483 decay_rate = get_prediction_decay_rate(cpi, &tmp_next_frame); 1484 if ( decay_rate < 0.999 ) 1485 break; 1486 } 1487 /* Reset file position */ 1488 reset_fpf_position(cpi, position); 1489 1490 /* Only if it does do we signal a transition to still */ 1491 if ( j == still_interval ) 1492 trans_to_still = 1; 1493 } 1494 1495 return trans_to_still; 1496 } 1497 1498 /* This function detects a flash through the high relative pcnt_second_ref 1499 * score in the frame following a flash frame. The offset passed in should 1500 * reflect this 1501 */ 1502 static int detect_flash( VP8_COMP *cpi, int offset ) 1503 { 1504 FIRSTPASS_STATS next_frame; 1505 1506 int flash_detected = 0; 1507 1508 /* Read the frame data. */ 1509 /* The return is 0 (no flash detected) if not a valid frame */ 1510 if ( read_frame_stats(cpi, &next_frame, offset) != EOF ) 1511 { 1512 /* What we are looking for here is a situation where there is a 1513 * brief break in prediction (such as a flash) but subsequent frames 1514 * are reasonably well predicted by an earlier (pre flash) frame. 1515 * The recovery after a flash is indicated by a high pcnt_second_ref 1516 * comapred to pcnt_inter. 1517 */ 1518 if ( (next_frame.pcnt_second_ref > next_frame.pcnt_inter) && 1519 (next_frame.pcnt_second_ref >= 0.5 ) ) 1520 { 1521 flash_detected = 1; 1522 1523 /*if (1) 1524 { 1525 FILE *f = fopen("flash.stt", "a"); 1526 fprintf(f, "%8.0f %6.2f %6.2f\n", 1527 next_frame.frame, 1528 next_frame.pcnt_inter, 1529 next_frame.pcnt_second_ref); 1530 fclose(f); 1531 }*/ 1532 } 1533 } 1534 1535 return flash_detected; 1536 } 1537 1538 /* Update the motion related elements to the GF arf boost calculation */ 1539 static void accumulate_frame_motion_stats( 1540 VP8_COMP *cpi, 1541 FIRSTPASS_STATS * this_frame, 1542 double * this_frame_mv_in_out, 1543 double * mv_in_out_accumulator, 1544 double * abs_mv_in_out_accumulator, 1545 double * mv_ratio_accumulator ) 1546 { 1547 double this_frame_mvr_ratio; 1548 double this_frame_mvc_ratio; 1549 double motion_pct; 1550 1551 /* Accumulate motion stats. */ 1552 motion_pct = this_frame->pcnt_motion; 1553 1554 /* Accumulate Motion In/Out of frame stats */ 1555 *this_frame_mv_in_out = this_frame->mv_in_out_count * motion_pct; 1556 *mv_in_out_accumulator += this_frame->mv_in_out_count * motion_pct; 1557 *abs_mv_in_out_accumulator += 1558 fabs(this_frame->mv_in_out_count * motion_pct); 1559 1560 /* Accumulate a measure of how uniform (or conversely how random) 1561 * the motion field is. (A ratio of absmv / mv) 1562 */ 1563 if (motion_pct > 0.05) 1564 { 1565 this_frame_mvr_ratio = fabs(this_frame->mvr_abs) / 1566 DOUBLE_DIVIDE_CHECK(fabs(this_frame->MVr)); 1567 1568 this_frame_mvc_ratio = fabs(this_frame->mvc_abs) / 1569 DOUBLE_DIVIDE_CHECK(fabs(this_frame->MVc)); 1570 1571 *mv_ratio_accumulator += 1572 (this_frame_mvr_ratio < this_frame->mvr_abs) 1573 ? (this_frame_mvr_ratio * motion_pct) 1574 : this_frame->mvr_abs * motion_pct; 1575 1576 *mv_ratio_accumulator += 1577 (this_frame_mvc_ratio < this_frame->mvc_abs) 1578 ? (this_frame_mvc_ratio * motion_pct) 1579 : this_frame->mvc_abs * motion_pct; 1580 1581 } 1582 } 1583 1584 /* Calculate a baseline boost number for the current frame. */ 1585 static double calc_frame_boost( 1586 VP8_COMP *cpi, 1587 FIRSTPASS_STATS * this_frame, 1588 double this_frame_mv_in_out ) 1589 { 1590 double frame_boost; 1591 1592 /* Underlying boost factor is based on inter intra error ratio */ 1593 if (this_frame->intra_error > cpi->twopass.gf_intra_err_min) 1594 frame_boost = (IIFACTOR * this_frame->intra_error / 1595 DOUBLE_DIVIDE_CHECK(this_frame->coded_error)); 1596 else 1597 frame_boost = (IIFACTOR * cpi->twopass.gf_intra_err_min / 1598 DOUBLE_DIVIDE_CHECK(this_frame->coded_error)); 1599 1600 /* Increase boost for frames where new data coming into frame 1601 * (eg zoom out). Slightly reduce boost if there is a net balance 1602 * of motion out of the frame (zoom in). 1603 * The range for this_frame_mv_in_out is -1.0 to +1.0 1604 */ 1605 if (this_frame_mv_in_out > 0.0) 1606 frame_boost += frame_boost * (this_frame_mv_in_out * 2.0); 1607 /* In extreme case boost is halved */ 1608 else 1609 frame_boost += frame_boost * (this_frame_mv_in_out / 2.0); 1610 1611 /* Clip to maximum */ 1612 if (frame_boost > GF_RMAX) 1613 frame_boost = GF_RMAX; 1614 1615 return frame_boost; 1616 } 1617 1618 #if NEW_BOOST 1619 static int calc_arf_boost( 1620 VP8_COMP *cpi, 1621 int offset, 1622 int f_frames, 1623 int b_frames, 1624 int *f_boost, 1625 int *b_boost ) 1626 { 1627 FIRSTPASS_STATS this_frame; 1628 1629 int i; 1630 double boost_score = 0.0; 1631 double mv_ratio_accumulator = 0.0; 1632 double decay_accumulator = 1.0; 1633 double this_frame_mv_in_out = 0.0; 1634 double mv_in_out_accumulator = 0.0; 1635 double abs_mv_in_out_accumulator = 0.0; 1636 double r; 1637 int flash_detected = 0; 1638 1639 /* Search forward from the proposed arf/next gf position */ 1640 for ( i = 0; i < f_frames; i++ ) 1641 { 1642 if ( read_frame_stats(cpi, &this_frame, (i+offset)) == EOF ) 1643 break; 1644 1645 /* Update the motion related elements to the boost calculation */ 1646 accumulate_frame_motion_stats( cpi, &this_frame, 1647 &this_frame_mv_in_out, &mv_in_out_accumulator, 1648 &abs_mv_in_out_accumulator, &mv_ratio_accumulator ); 1649 1650 /* Calculate the baseline boost number for this frame */ 1651 r = calc_frame_boost( cpi, &this_frame, this_frame_mv_in_out ); 1652 1653 /* We want to discount the the flash frame itself and the recovery 1654 * frame that follows as both will have poor scores. 1655 */ 1656 flash_detected = detect_flash(cpi, (i+offset)) || 1657 detect_flash(cpi, (i+offset+1)); 1658 1659 /* Cumulative effect of prediction quality decay */ 1660 if ( !flash_detected ) 1661 { 1662 decay_accumulator = 1663 decay_accumulator * 1664 get_prediction_decay_rate(cpi, &this_frame); 1665 decay_accumulator = 1666 decay_accumulator < 0.1 ? 0.1 : decay_accumulator; 1667 } 1668 boost_score += (decay_accumulator * r); 1669 1670 /* Break out conditions. */ 1671 if ( (!flash_detected) && 1672 ((mv_ratio_accumulator > 100.0) || 1673 (abs_mv_in_out_accumulator > 3.0) || 1674 (mv_in_out_accumulator < -2.0) ) ) 1675 { 1676 break; 1677 } 1678 } 1679 1680 *f_boost = (int)(boost_score * 100.0) >> 4; 1681 1682 /* Reset for backward looking loop */ 1683 boost_score = 0.0; 1684 mv_ratio_accumulator = 0.0; 1685 decay_accumulator = 1.0; 1686 this_frame_mv_in_out = 0.0; 1687 mv_in_out_accumulator = 0.0; 1688 abs_mv_in_out_accumulator = 0.0; 1689 1690 /* Search forward from the proposed arf/next gf position */ 1691 for ( i = -1; i >= -b_frames; i-- ) 1692 { 1693 if ( read_frame_stats(cpi, &this_frame, (i+offset)) == EOF ) 1694 break; 1695 1696 /* Update the motion related elements to the boost calculation */ 1697 accumulate_frame_motion_stats( cpi, &this_frame, 1698 &this_frame_mv_in_out, &mv_in_out_accumulator, 1699 &abs_mv_in_out_accumulator, &mv_ratio_accumulator ); 1700 1701 /* Calculate the baseline boost number for this frame */ 1702 r = calc_frame_boost( cpi, &this_frame, this_frame_mv_in_out ); 1703 1704 /* We want to discount the the flash frame itself and the recovery 1705 * frame that follows as both will have poor scores. 1706 */ 1707 flash_detected = detect_flash(cpi, (i+offset)) || 1708 detect_flash(cpi, (i+offset+1)); 1709 1710 /* Cumulative effect of prediction quality decay */ 1711 if ( !flash_detected ) 1712 { 1713 decay_accumulator = 1714 decay_accumulator * 1715 get_prediction_decay_rate(cpi, &this_frame); 1716 decay_accumulator = 1717 decay_accumulator < 0.1 ? 0.1 : decay_accumulator; 1718 } 1719 1720 boost_score += (decay_accumulator * r); 1721 1722 /* Break out conditions. */ 1723 if ( (!flash_detected) && 1724 ((mv_ratio_accumulator > 100.0) || 1725 (abs_mv_in_out_accumulator > 3.0) || 1726 (mv_in_out_accumulator < -2.0) ) ) 1727 { 1728 break; 1729 } 1730 } 1731 *b_boost = (int)(boost_score * 100.0) >> 4; 1732 1733 return (*f_boost + *b_boost); 1734 } 1735 #endif 1736 1737 /* Analyse and define a gf/arf group . */ 1738 static void define_gf_group(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame) 1739 { 1740 FIRSTPASS_STATS next_frame; 1741 FIRSTPASS_STATS *start_pos; 1742 int i; 1743 double r; 1744 double boost_score = 0.0; 1745 double old_boost_score = 0.0; 1746 double gf_group_err = 0.0; 1747 double gf_first_frame_err = 0.0; 1748 double mod_frame_err = 0.0; 1749 1750 double mv_ratio_accumulator = 0.0; 1751 double decay_accumulator = 1.0; 1752 1753 double loop_decay_rate = 1.00; /* Starting decay rate */ 1754 1755 double this_frame_mv_in_out = 0.0; 1756 double mv_in_out_accumulator = 0.0; 1757 double abs_mv_in_out_accumulator = 0.0; 1758 double mod_err_per_mb_accumulator = 0.0; 1759 1760 int max_bits = frame_max_bits(cpi); /* Max for a single frame */ 1761 1762 unsigned int allow_alt_ref = 1763 cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames; 1764 1765 int alt_boost = 0; 1766 int f_boost = 0; 1767 int b_boost = 0; 1768 int flash_detected; 1769 1770 cpi->twopass.gf_group_bits = 0; 1771 cpi->twopass.gf_decay_rate = 0; 1772 1773 vp8_clear_system_state(); 1774 1775 start_pos = cpi->twopass.stats_in; 1776 1777 vpx_memset(&next_frame, 0, sizeof(next_frame)); /* assure clean */ 1778 1779 /* Load stats for the current frame. */ 1780 mod_frame_err = calculate_modified_err(cpi, this_frame); 1781 1782 /* Note the error of the frame at the start of the group (this will be 1783 * the GF frame error if we code a normal gf 1784 */ 1785 gf_first_frame_err = mod_frame_err; 1786 1787 /* Special treatment if the current frame is a key frame (which is also 1788 * a gf). If it is then its error score (and hence bit allocation) need 1789 * to be subtracted out from the calculation for the GF group 1790 */ 1791 if (cpi->common.frame_type == KEY_FRAME) 1792 gf_group_err -= gf_first_frame_err; 1793 1794 /* Scan forward to try and work out how many frames the next gf group 1795 * should contain and what level of boost is appropriate for the GF 1796 * or ARF that will be coded with the group 1797 */ 1798 i = 0; 1799 1800 while (((i < cpi->twopass.static_scene_max_gf_interval) || 1801 ((cpi->twopass.frames_to_key - i) < MIN_GF_INTERVAL)) && 1802 (i < cpi->twopass.frames_to_key)) 1803 { 1804 i++; 1805 1806 /* Accumulate error score of frames in this gf group */ 1807 mod_frame_err = calculate_modified_err(cpi, this_frame); 1808 1809 gf_group_err += mod_frame_err; 1810 1811 mod_err_per_mb_accumulator += 1812 mod_frame_err / DOUBLE_DIVIDE_CHECK((double)cpi->common.MBs); 1813 1814 if (EOF == input_stats(cpi, &next_frame)) 1815 break; 1816 1817 /* Test for the case where there is a brief flash but the prediction 1818 * quality back to an earlier frame is then restored. 1819 */ 1820 flash_detected = detect_flash(cpi, 0); 1821 1822 /* Update the motion related elements to the boost calculation */ 1823 accumulate_frame_motion_stats( cpi, &next_frame, 1824 &this_frame_mv_in_out, &mv_in_out_accumulator, 1825 &abs_mv_in_out_accumulator, &mv_ratio_accumulator ); 1826 1827 /* Calculate a baseline boost number for this frame */ 1828 r = calc_frame_boost( cpi, &next_frame, this_frame_mv_in_out ); 1829 1830 /* Cumulative effect of prediction quality decay */ 1831 if ( !flash_detected ) 1832 { 1833 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame); 1834 decay_accumulator = decay_accumulator * loop_decay_rate; 1835 decay_accumulator = 1836 decay_accumulator < 0.1 ? 0.1 : decay_accumulator; 1837 } 1838 boost_score += (decay_accumulator * r); 1839 1840 /* Break clause to detect very still sections after motion 1841 * For example a staic image after a fade or other transition. 1842 */ 1843 if ( detect_transition_to_still( cpi, i, 5, 1844 loop_decay_rate, 1845 decay_accumulator ) ) 1846 { 1847 allow_alt_ref = 0; 1848 boost_score = old_boost_score; 1849 break; 1850 } 1851 1852 /* Break out conditions. */ 1853 if ( 1854 /* Break at cpi->max_gf_interval unless almost totally static */ 1855 (i >= cpi->max_gf_interval && (decay_accumulator < 0.995)) || 1856 ( 1857 /* Dont break out with a very short interval */ 1858 (i > MIN_GF_INTERVAL) && 1859 /* Dont break out very close to a key frame */ 1860 ((cpi->twopass.frames_to_key - i) >= MIN_GF_INTERVAL) && 1861 ((boost_score > 20.0) || (next_frame.pcnt_inter < 0.75)) && 1862 (!flash_detected) && 1863 ((mv_ratio_accumulator > 100.0) || 1864 (abs_mv_in_out_accumulator > 3.0) || 1865 (mv_in_out_accumulator < -2.0) || 1866 ((boost_score - old_boost_score) < 2.0)) 1867 ) ) 1868 { 1869 boost_score = old_boost_score; 1870 break; 1871 } 1872 1873 vpx_memcpy(this_frame, &next_frame, sizeof(*this_frame)); 1874 1875 old_boost_score = boost_score; 1876 } 1877 1878 cpi->twopass.gf_decay_rate = 1879 (i > 0) ? (int)(100.0 * (1.0 - decay_accumulator)) / i : 0; 1880 1881 /* When using CBR apply additional buffer related upper limits */ 1882 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 1883 { 1884 double max_boost; 1885 1886 /* For cbr apply buffer related limits */ 1887 if (cpi->drop_frames_allowed) 1888 { 1889 int64_t df_buffer_level = cpi->oxcf.drop_frames_water_mark * 1890 (cpi->oxcf.optimal_buffer_level / 100); 1891 1892 if (cpi->buffer_level > df_buffer_level) 1893 max_boost = ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth); 1894 else 1895 max_boost = 0.0; 1896 } 1897 else if (cpi->buffer_level > 0) 1898 { 1899 max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth); 1900 } 1901 else 1902 { 1903 max_boost = 0.0; 1904 } 1905 1906 if (boost_score > max_boost) 1907 boost_score = max_boost; 1908 } 1909 1910 /* Dont allow conventional gf too near the next kf */ 1911 if ((cpi->twopass.frames_to_key - i) < MIN_GF_INTERVAL) 1912 { 1913 while (i < cpi->twopass.frames_to_key) 1914 { 1915 i++; 1916 1917 if (EOF == input_stats(cpi, this_frame)) 1918 break; 1919 1920 if (i < cpi->twopass.frames_to_key) 1921 { 1922 mod_frame_err = calculate_modified_err(cpi, this_frame); 1923 gf_group_err += mod_frame_err; 1924 } 1925 } 1926 } 1927 1928 cpi->gfu_boost = (int)(boost_score * 100.0) >> 4; 1929 1930 #if NEW_BOOST 1931 /* Alterrnative boost calculation for alt ref */ 1932 alt_boost = calc_arf_boost( cpi, 0, (i-1), (i-1), &f_boost, &b_boost ); 1933 #endif 1934 1935 /* Should we use the alternate refernce frame */ 1936 if (allow_alt_ref && 1937 (i >= MIN_GF_INTERVAL) && 1938 /* dont use ARF very near next kf */ 1939 (i <= (cpi->twopass.frames_to_key - MIN_GF_INTERVAL)) && 1940 #if NEW_BOOST 1941 ((next_frame.pcnt_inter > 0.75) || 1942 (next_frame.pcnt_second_ref > 0.5)) && 1943 ((mv_in_out_accumulator / (double)i > -0.2) || 1944 (mv_in_out_accumulator > -2.0)) && 1945 (b_boost > 100) && 1946 (f_boost > 100) ) 1947 #else 1948 (next_frame.pcnt_inter > 0.75) && 1949 ((mv_in_out_accumulator / (double)i > -0.2) || 1950 (mv_in_out_accumulator > -2.0)) && 1951 (cpi->gfu_boost > 100) && 1952 (cpi->twopass.gf_decay_rate <= 1953 (ARF_DECAY_THRESH + (cpi->gfu_boost / 200))) ) 1954 #endif 1955 { 1956 int Boost; 1957 int allocation_chunks; 1958 int Q = (cpi->oxcf.fixed_q < 0) 1959 ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q; 1960 int tmp_q; 1961 int arf_frame_bits = 0; 1962 int group_bits; 1963 1964 #if NEW_BOOST 1965 cpi->gfu_boost = alt_boost; 1966 #endif 1967 1968 /* Estimate the bits to be allocated to the group as a whole */ 1969 if ((cpi->twopass.kf_group_bits > 0) && 1970 (cpi->twopass.kf_group_error_left > 0)) 1971 { 1972 group_bits = (int)((double)cpi->twopass.kf_group_bits * 1973 (gf_group_err / (double)cpi->twopass.kf_group_error_left)); 1974 } 1975 else 1976 group_bits = 0; 1977 1978 /* Boost for arf frame */ 1979 #if NEW_BOOST 1980 Boost = (alt_boost * GFQ_ADJUSTMENT) / 100; 1981 #else 1982 Boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100); 1983 #endif 1984 Boost += (i * 50); 1985 1986 /* Set max and minimum boost and hence minimum allocation */ 1987 if (Boost > ((cpi->baseline_gf_interval + 1) * 200)) 1988 Boost = ((cpi->baseline_gf_interval + 1) * 200); 1989 else if (Boost < 125) 1990 Boost = 125; 1991 1992 allocation_chunks = (i * 100) + Boost; 1993 1994 /* Normalize Altboost and allocations chunck down to prevent overflow */ 1995 while (Boost > 1000) 1996 { 1997 Boost /= 2; 1998 allocation_chunks /= 2; 1999 } 2000 2001 /* Calculate the number of bits to be spent on the arf based on the 2002 * boost number 2003 */ 2004 arf_frame_bits = (int)((double)Boost * (group_bits / 2005 (double)allocation_chunks)); 2006 2007 /* Estimate if there are enough bits available to make worthwhile use 2008 * of an arf. 2009 */ 2010 tmp_q = estimate_q(cpi, mod_frame_err, (int)arf_frame_bits); 2011 2012 /* Only use an arf if it is likely we will be able to code 2013 * it at a lower Q than the surrounding frames. 2014 */ 2015 if (tmp_q < cpi->worst_quality) 2016 { 2017 int half_gf_int; 2018 int frames_after_arf; 2019 int frames_bwd = cpi->oxcf.arnr_max_frames - 1; 2020 int frames_fwd = cpi->oxcf.arnr_max_frames - 1; 2021 2022 cpi->source_alt_ref_pending = 1; 2023 2024 /* 2025 * For alt ref frames the error score for the end frame of the 2026 * group (the alt ref frame) should not contribute to the group 2027 * total and hence the number of bit allocated to the group. 2028 * Rather it forms part of the next group (it is the GF at the 2029 * start of the next group) 2030 * gf_group_err -= mod_frame_err; 2031 * 2032 * For alt ref frames alt ref frame is technically part of the 2033 * GF frame for the next group but we always base the error 2034 * calculation and bit allocation on the current group of frames. 2035 * 2036 * Set the interval till the next gf or arf. 2037 * For ARFs this is the number of frames to be coded before the 2038 * future frame that is coded as an ARF. 2039 * The future frame itself is part of the next group 2040 */ 2041 cpi->baseline_gf_interval = i; 2042 2043 /* 2044 * Define the arnr filter width for this group of frames: 2045 * We only filter frames that lie within a distance of half 2046 * the GF interval from the ARF frame. We also have to trap 2047 * cases where the filter extends beyond the end of clip. 2048 * Note: this_frame->frame has been updated in the loop 2049 * so it now points at the ARF frame. 2050 */ 2051 half_gf_int = cpi->baseline_gf_interval >> 1; 2052 frames_after_arf = (int)(cpi->twopass.total_stats.count - 2053 this_frame->frame - 1); 2054 2055 switch (cpi->oxcf.arnr_type) 2056 { 2057 case 1: /* Backward filter */ 2058 frames_fwd = 0; 2059 if (frames_bwd > half_gf_int) 2060 frames_bwd = half_gf_int; 2061 break; 2062 2063 case 2: /* Forward filter */ 2064 if (frames_fwd > half_gf_int) 2065 frames_fwd = half_gf_int; 2066 if (frames_fwd > frames_after_arf) 2067 frames_fwd = frames_after_arf; 2068 frames_bwd = 0; 2069 break; 2070 2071 case 3: /* Centered filter */ 2072 default: 2073 frames_fwd >>= 1; 2074 if (frames_fwd > frames_after_arf) 2075 frames_fwd = frames_after_arf; 2076 if (frames_fwd > half_gf_int) 2077 frames_fwd = half_gf_int; 2078 2079 frames_bwd = frames_fwd; 2080 2081 /* For even length filter there is one more frame backward 2082 * than forward: e.g. len=6 ==> bbbAff, len=7 ==> bbbAfff. 2083 */ 2084 if (frames_bwd < half_gf_int) 2085 frames_bwd += (cpi->oxcf.arnr_max_frames+1) & 0x1; 2086 break; 2087 } 2088 2089 cpi->active_arnr_frames = frames_bwd + 1 + frames_fwd; 2090 } 2091 else 2092 { 2093 cpi->source_alt_ref_pending = 0; 2094 cpi->baseline_gf_interval = i; 2095 } 2096 } 2097 else 2098 { 2099 cpi->source_alt_ref_pending = 0; 2100 cpi->baseline_gf_interval = i; 2101 } 2102 2103 /* 2104 * Now decide how many bits should be allocated to the GF group as a 2105 * proportion of those remaining in the kf group. 2106 * The final key frame group in the clip is treated as a special case 2107 * where cpi->twopass.kf_group_bits is tied to cpi->twopass.bits_left. 2108 * This is also important for short clips where there may only be one 2109 * key frame. 2110 */ 2111 if (cpi->twopass.frames_to_key >= (int)(cpi->twopass.total_stats.count - 2112 cpi->common.current_video_frame)) 2113 { 2114 cpi->twopass.kf_group_bits = 2115 (cpi->twopass.bits_left > 0) ? cpi->twopass.bits_left : 0; 2116 } 2117 2118 /* Calculate the bits to be allocated to the group as a whole */ 2119 if ((cpi->twopass.kf_group_bits > 0) && 2120 (cpi->twopass.kf_group_error_left > 0)) 2121 { 2122 cpi->twopass.gf_group_bits = 2123 (int64_t)(cpi->twopass.kf_group_bits * 2124 (gf_group_err / cpi->twopass.kf_group_error_left)); 2125 } 2126 else 2127 cpi->twopass.gf_group_bits = 0; 2128 2129 cpi->twopass.gf_group_bits = 2130 (cpi->twopass.gf_group_bits < 0) 2131 ? 0 2132 : (cpi->twopass.gf_group_bits > cpi->twopass.kf_group_bits) 2133 ? cpi->twopass.kf_group_bits : cpi->twopass.gf_group_bits; 2134 2135 /* Clip cpi->twopass.gf_group_bits based on user supplied data rate 2136 * variability limit (cpi->oxcf.two_pass_vbrmax_section) 2137 */ 2138 if (cpi->twopass.gf_group_bits > 2139 (int64_t)max_bits * cpi->baseline_gf_interval) 2140 cpi->twopass.gf_group_bits = 2141 (int64_t)max_bits * cpi->baseline_gf_interval; 2142 2143 /* Reset the file position */ 2144 reset_fpf_position(cpi, start_pos); 2145 2146 /* Update the record of error used so far (only done once per gf group) */ 2147 cpi->twopass.modified_error_used += gf_group_err; 2148 2149 /* Assign bits to the arf or gf. */ 2150 for (i = 0; i <= (cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME); i++) { 2151 int Boost; 2152 int allocation_chunks; 2153 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q; 2154 int gf_bits; 2155 2156 /* For ARF frames */ 2157 if (cpi->source_alt_ref_pending && i == 0) 2158 { 2159 #if NEW_BOOST 2160 Boost = (alt_boost * GFQ_ADJUSTMENT) / 100; 2161 #else 2162 Boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100); 2163 #endif 2164 Boost += (cpi->baseline_gf_interval * 50); 2165 2166 /* Set max and minimum boost and hence minimum allocation */ 2167 if (Boost > ((cpi->baseline_gf_interval + 1) * 200)) 2168 Boost = ((cpi->baseline_gf_interval + 1) * 200); 2169 else if (Boost < 125) 2170 Boost = 125; 2171 2172 allocation_chunks = 2173 ((cpi->baseline_gf_interval + 1) * 100) + Boost; 2174 } 2175 /* Else for standard golden frames */ 2176 else 2177 { 2178 /* boost based on inter / intra ratio of subsequent frames */ 2179 Boost = (cpi->gfu_boost * GFQ_ADJUSTMENT) / 100; 2180 2181 /* Set max and minimum boost and hence minimum allocation */ 2182 if (Boost > (cpi->baseline_gf_interval * 150)) 2183 Boost = (cpi->baseline_gf_interval * 150); 2184 else if (Boost < 125) 2185 Boost = 125; 2186 2187 allocation_chunks = 2188 (cpi->baseline_gf_interval * 100) + (Boost - 100); 2189 } 2190 2191 /* Normalize Altboost and allocations chunck down to prevent overflow */ 2192 while (Boost > 1000) 2193 { 2194 Boost /= 2; 2195 allocation_chunks /= 2; 2196 } 2197 2198 /* Calculate the number of bits to be spent on the gf or arf based on 2199 * the boost number 2200 */ 2201 gf_bits = (int)((double)Boost * 2202 (cpi->twopass.gf_group_bits / 2203 (double)allocation_chunks)); 2204 2205 /* If the frame that is to be boosted is simpler than the average for 2206 * the gf/arf group then use an alternative calculation 2207 * based on the error score of the frame itself 2208 */ 2209 if (mod_frame_err < gf_group_err / (double)cpi->baseline_gf_interval) 2210 { 2211 double alt_gf_grp_bits; 2212 int alt_gf_bits; 2213 2214 alt_gf_grp_bits = 2215 (double)cpi->twopass.kf_group_bits * 2216 (mod_frame_err * (double)cpi->baseline_gf_interval) / 2217 DOUBLE_DIVIDE_CHECK((double)cpi->twopass.kf_group_error_left); 2218 2219 alt_gf_bits = (int)((double)Boost * (alt_gf_grp_bits / 2220 (double)allocation_chunks)); 2221 2222 if (gf_bits > alt_gf_bits) 2223 { 2224 gf_bits = alt_gf_bits; 2225 } 2226 } 2227 /* Else if it is harder than other frames in the group make sure it at 2228 * least receives an allocation in keeping with its relative error 2229 * score, otherwise it may be worse off than an "un-boosted" frame 2230 */ 2231 else 2232 { 2233 int alt_gf_bits = 2234 (int)((double)cpi->twopass.kf_group_bits * 2235 mod_frame_err / 2236 DOUBLE_DIVIDE_CHECK((double)cpi->twopass.kf_group_error_left)); 2237 2238 if (alt_gf_bits > gf_bits) 2239 { 2240 gf_bits = alt_gf_bits; 2241 } 2242 } 2243 2244 /* Apply an additional limit for CBR */ 2245 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 2246 { 2247 if (cpi->twopass.gf_bits > (int)(cpi->buffer_level >> 1)) 2248 cpi->twopass.gf_bits = (int)(cpi->buffer_level >> 1); 2249 } 2250 2251 /* Dont allow a negative value for gf_bits */ 2252 if (gf_bits < 0) 2253 gf_bits = 0; 2254 2255 /* Add in minimum for a frame */ 2256 gf_bits += cpi->min_frame_bandwidth; 2257 2258 if (i == 0) 2259 { 2260 cpi->twopass.gf_bits = gf_bits; 2261 } 2262 if (i == 1 || (!cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME))) 2263 { 2264 /* Per frame bit target for this frame */ 2265 cpi->per_frame_bandwidth = gf_bits; 2266 } 2267 } 2268 2269 { 2270 /* Adjust KF group bits and error remainin */ 2271 cpi->twopass.kf_group_error_left -= (int64_t)gf_group_err; 2272 cpi->twopass.kf_group_bits -= cpi->twopass.gf_group_bits; 2273 2274 if (cpi->twopass.kf_group_bits < 0) 2275 cpi->twopass.kf_group_bits = 0; 2276 2277 /* Note the error score left in the remaining frames of the group. 2278 * For normal GFs we want to remove the error score for the first 2279 * frame of the group (except in Key frame case where this has 2280 * already happened) 2281 */ 2282 if (!cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME) 2283 cpi->twopass.gf_group_error_left = (int)(gf_group_err - 2284 gf_first_frame_err); 2285 else 2286 cpi->twopass.gf_group_error_left = (int) gf_group_err; 2287 2288 cpi->twopass.gf_group_bits -= cpi->twopass.gf_bits - cpi->min_frame_bandwidth; 2289 2290 if (cpi->twopass.gf_group_bits < 0) 2291 cpi->twopass.gf_group_bits = 0; 2292 2293 /* This condition could fail if there are two kfs very close together 2294 * despite (MIN_GF_INTERVAL) and would cause a devide by 0 in the 2295 * calculation of cpi->twopass.alt_extra_bits. 2296 */ 2297 if ( cpi->baseline_gf_interval >= 3 ) 2298 { 2299 #if NEW_BOOST 2300 int boost = (cpi->source_alt_ref_pending) 2301 ? b_boost : cpi->gfu_boost; 2302 #else 2303 int boost = cpi->gfu_boost; 2304 #endif 2305 if ( boost >= 150 ) 2306 { 2307 int pct_extra; 2308 2309 pct_extra = (boost - 100) / 50; 2310 pct_extra = (pct_extra > 20) ? 20 : pct_extra; 2311 2312 cpi->twopass.alt_extra_bits = 2313 (cpi->twopass.gf_group_bits * pct_extra) / 100; 2314 cpi->twopass.gf_group_bits -= cpi->twopass.alt_extra_bits; 2315 cpi->twopass.alt_extra_bits /= 2316 ((cpi->baseline_gf_interval-1)>>1); 2317 } 2318 else 2319 cpi->twopass.alt_extra_bits = 0; 2320 } 2321 else 2322 cpi->twopass.alt_extra_bits = 0; 2323 } 2324 2325 /* Adjustments based on a measure of complexity of the section */ 2326 if (cpi->common.frame_type != KEY_FRAME) 2327 { 2328 FIRSTPASS_STATS sectionstats; 2329 double Ratio; 2330 2331 zero_stats(§ionstats); 2332 reset_fpf_position(cpi, start_pos); 2333 2334 for (i = 0 ; i < cpi->baseline_gf_interval ; i++) 2335 { 2336 input_stats(cpi, &next_frame); 2337 accumulate_stats(§ionstats, &next_frame); 2338 } 2339 2340 avg_stats(§ionstats); 2341 2342 cpi->twopass.section_intra_rating = (unsigned int) 2343 (sectionstats.intra_error / 2344 DOUBLE_DIVIDE_CHECK(sectionstats.coded_error)); 2345 2346 Ratio = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error); 2347 cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025); 2348 2349 if (cpi->twopass.section_max_qfactor < 0.80) 2350 cpi->twopass.section_max_qfactor = 0.80; 2351 2352 reset_fpf_position(cpi, start_pos); 2353 } 2354 } 2355 2356 /* Allocate bits to a normal frame that is neither a gf an arf or a key frame. */ 2357 static void assign_std_frame_bits(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame) 2358 { 2359 int target_frame_size; 2360 2361 double modified_err; 2362 double err_fraction; 2363 2364 int max_bits = frame_max_bits(cpi); /* Max for a single frame */ 2365 2366 /* Calculate modified prediction error used in bit allocation */ 2367 modified_err = calculate_modified_err(cpi, this_frame); 2368 2369 /* What portion of the remaining GF group error is used by this frame */ 2370 if (cpi->twopass.gf_group_error_left > 0) 2371 err_fraction = modified_err / cpi->twopass.gf_group_error_left; 2372 else 2373 err_fraction = 0.0; 2374 2375 /* How many of those bits available for allocation should we give it? */ 2376 target_frame_size = (int)((double)cpi->twopass.gf_group_bits * err_fraction); 2377 2378 /* Clip to target size to 0 - max_bits (or cpi->twopass.gf_group_bits) 2379 * at the top end. 2380 */ 2381 if (target_frame_size < 0) 2382 target_frame_size = 0; 2383 else 2384 { 2385 if (target_frame_size > max_bits) 2386 target_frame_size = max_bits; 2387 2388 if (target_frame_size > cpi->twopass.gf_group_bits) 2389 target_frame_size = cpi->twopass.gf_group_bits; 2390 } 2391 2392 /* Adjust error and bits remaining */ 2393 cpi->twopass.gf_group_error_left -= (int)modified_err; 2394 cpi->twopass.gf_group_bits -= target_frame_size; 2395 2396 if (cpi->twopass.gf_group_bits < 0) 2397 cpi->twopass.gf_group_bits = 0; 2398 2399 /* Add in the minimum number of bits that is set aside for every frame. */ 2400 target_frame_size += cpi->min_frame_bandwidth; 2401 2402 /* Every other frame gets a few extra bits */ 2403 if ( (cpi->frames_since_golden & 0x01) && 2404 (cpi->frames_till_gf_update_due > 0) ) 2405 { 2406 target_frame_size += cpi->twopass.alt_extra_bits; 2407 } 2408 2409 /* Per frame bit target for this frame */ 2410 cpi->per_frame_bandwidth = target_frame_size; 2411 } 2412 2413 void vp8_second_pass(VP8_COMP *cpi) 2414 { 2415 int tmp_q; 2416 int frames_left = (int)(cpi->twopass.total_stats.count - cpi->common.current_video_frame); 2417 2418 FIRSTPASS_STATS this_frame = {0}; 2419 FIRSTPASS_STATS this_frame_copy; 2420 2421 double this_frame_intra_error; 2422 double this_frame_coded_error; 2423 2424 int overhead_bits; 2425 2426 if (!cpi->twopass.stats_in) 2427 { 2428 return ; 2429 } 2430 2431 vp8_clear_system_state(); 2432 2433 if (EOF == input_stats(cpi, &this_frame)) 2434 return; 2435 2436 this_frame_intra_error = this_frame.intra_error; 2437 this_frame_coded_error = this_frame.coded_error; 2438 2439 /* keyframe and section processing ! */ 2440 if (cpi->twopass.frames_to_key == 0) 2441 { 2442 /* Define next KF group and assign bits to it */ 2443 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame)); 2444 find_next_key_frame(cpi, &this_frame_copy); 2445 2446 /* Special case: Error error_resilient_mode mode does not make much 2447 * sense for two pass but with its current meaning but this code is 2448 * designed to stop outlandish behaviour if someone does set it when 2449 * using two pass. It effectively disables GF groups. This is 2450 * temporary code till we decide what should really happen in this 2451 * case. 2452 */ 2453 if (cpi->oxcf.error_resilient_mode) 2454 { 2455 cpi->twopass.gf_group_bits = cpi->twopass.kf_group_bits; 2456 cpi->twopass.gf_group_error_left = 2457 (int)cpi->twopass.kf_group_error_left; 2458 cpi->baseline_gf_interval = cpi->twopass.frames_to_key; 2459 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval; 2460 cpi->source_alt_ref_pending = 0; 2461 } 2462 2463 } 2464 2465 /* Is this a GF / ARF (Note that a KF is always also a GF) */ 2466 if (cpi->frames_till_gf_update_due == 0) 2467 { 2468 /* Define next gf group and assign bits to it */ 2469 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame)); 2470 define_gf_group(cpi, &this_frame_copy); 2471 2472 /* If we are going to code an altref frame at the end of the group 2473 * and the current frame is not a key frame.... If the previous 2474 * group used an arf this frame has already benefited from that arf 2475 * boost and it should not be given extra bits If the previous 2476 * group was NOT coded using arf we may want to apply some boost to 2477 * this GF as well 2478 */ 2479 if (cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME)) 2480 { 2481 /* Assign a standard frames worth of bits from those allocated 2482 * to the GF group 2483 */ 2484 int bak = cpi->per_frame_bandwidth; 2485 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame)); 2486 assign_std_frame_bits(cpi, &this_frame_copy); 2487 cpi->per_frame_bandwidth = bak; 2488 } 2489 } 2490 2491 /* Otherwise this is an ordinary frame */ 2492 else 2493 { 2494 /* Special case: Error error_resilient_mode mode does not make much 2495 * sense for two pass but with its current meaning but this code is 2496 * designed to stop outlandish behaviour if someone does set it 2497 * when using two pass. It effectively disables GF groups. This is 2498 * temporary code till we decide what should really happen in this 2499 * case. 2500 */ 2501 if (cpi->oxcf.error_resilient_mode) 2502 { 2503 cpi->frames_till_gf_update_due = cpi->twopass.frames_to_key; 2504 2505 if (cpi->common.frame_type != KEY_FRAME) 2506 { 2507 /* Assign bits from those allocated to the GF group */ 2508 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame)); 2509 assign_std_frame_bits(cpi, &this_frame_copy); 2510 } 2511 } 2512 else 2513 { 2514 /* Assign bits from those allocated to the GF group */ 2515 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame)); 2516 assign_std_frame_bits(cpi, &this_frame_copy); 2517 } 2518 } 2519 2520 /* Keep a globally available copy of this and the next frame's iiratio. */ 2521 cpi->twopass.this_iiratio = (unsigned int)(this_frame_intra_error / 2522 DOUBLE_DIVIDE_CHECK(this_frame_coded_error)); 2523 { 2524 FIRSTPASS_STATS next_frame; 2525 if ( lookup_next_frame_stats(cpi, &next_frame) != EOF ) 2526 { 2527 cpi->twopass.next_iiratio = (unsigned int)(next_frame.intra_error / 2528 DOUBLE_DIVIDE_CHECK(next_frame.coded_error)); 2529 } 2530 } 2531 2532 /* Set nominal per second bandwidth for this frame */ 2533 cpi->target_bandwidth = (int) 2534 (cpi->per_frame_bandwidth * cpi->output_framerate); 2535 if (cpi->target_bandwidth < 0) 2536 cpi->target_bandwidth = 0; 2537 2538 2539 /* Account for mv, mode and other overheads. */ 2540 overhead_bits = (int)estimate_modemvcost( 2541 cpi, &cpi->twopass.total_left_stats ); 2542 2543 /* Special case code for first frame. */ 2544 if (cpi->common.current_video_frame == 0) 2545 { 2546 cpi->twopass.est_max_qcorrection_factor = 1.0; 2547 2548 /* Set a cq_level in constrained quality mode. */ 2549 if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY ) 2550 { 2551 int est_cq; 2552 2553 est_cq = 2554 estimate_cq( cpi, 2555 &cpi->twopass.total_left_stats, 2556 (int)(cpi->twopass.bits_left / frames_left), 2557 overhead_bits ); 2558 2559 cpi->cq_target_quality = cpi->oxcf.cq_level; 2560 if ( est_cq > cpi->cq_target_quality ) 2561 cpi->cq_target_quality = est_cq; 2562 } 2563 2564 /* guess at maxq needed in 2nd pass */ 2565 cpi->twopass.maxq_max_limit = cpi->worst_quality; 2566 cpi->twopass.maxq_min_limit = cpi->best_quality; 2567 2568 tmp_q = estimate_max_q( 2569 cpi, 2570 &cpi->twopass.total_left_stats, 2571 (int)(cpi->twopass.bits_left / frames_left), 2572 overhead_bits ); 2573 2574 /* Limit the maxq value returned subsequently. 2575 * This increases the risk of overspend or underspend if the initial 2576 * estimate for the clip is bad, but helps prevent excessive 2577 * variation in Q, especially near the end of a clip 2578 * where for example a small overspend may cause Q to crash 2579 */ 2580 cpi->twopass.maxq_max_limit = ((tmp_q + 32) < cpi->worst_quality) 2581 ? (tmp_q + 32) : cpi->worst_quality; 2582 cpi->twopass.maxq_min_limit = ((tmp_q - 32) > cpi->best_quality) 2583 ? (tmp_q - 32) : cpi->best_quality; 2584 2585 cpi->active_worst_quality = tmp_q; 2586 cpi->ni_av_qi = tmp_q; 2587 } 2588 2589 /* The last few frames of a clip almost always have to few or too many 2590 * bits and for the sake of over exact rate control we dont want to make 2591 * radical adjustments to the allowed quantizer range just to use up a 2592 * few surplus bits or get beneath the target rate. 2593 */ 2594 else if ( (cpi->common.current_video_frame < 2595 (((unsigned int)cpi->twopass.total_stats.count * 255)>>8)) && 2596 ((cpi->common.current_video_frame + cpi->baseline_gf_interval) < 2597 (unsigned int)cpi->twopass.total_stats.count) ) 2598 { 2599 if (frames_left < 1) 2600 frames_left = 1; 2601 2602 tmp_q = estimate_max_q( 2603 cpi, 2604 &cpi->twopass.total_left_stats, 2605 (int)(cpi->twopass.bits_left / frames_left), 2606 overhead_bits ); 2607 2608 /* Move active_worst_quality but in a damped way */ 2609 if (tmp_q > cpi->active_worst_quality) 2610 cpi->active_worst_quality ++; 2611 else if (tmp_q < cpi->active_worst_quality) 2612 cpi->active_worst_quality --; 2613 2614 cpi->active_worst_quality = 2615 ((cpi->active_worst_quality * 3) + tmp_q + 2) / 4; 2616 } 2617 2618 cpi->twopass.frames_to_key --; 2619 2620 /* Update the total stats remaining sturcture */ 2621 subtract_stats(&cpi->twopass.total_left_stats, &this_frame ); 2622 } 2623 2624 2625 static int test_candidate_kf(VP8_COMP *cpi, FIRSTPASS_STATS *last_frame, FIRSTPASS_STATS *this_frame, FIRSTPASS_STATS *next_frame) 2626 { 2627 int is_viable_kf = 0; 2628 2629 /* Does the frame satisfy the primary criteria of a key frame 2630 * If so, then examine how well it predicts subsequent frames 2631 */ 2632 if ((this_frame->pcnt_second_ref < 0.10) && 2633 (next_frame->pcnt_second_ref < 0.10) && 2634 ((this_frame->pcnt_inter < 0.05) || 2635 ( 2636 ((this_frame->pcnt_inter - this_frame->pcnt_neutral) < .25) && 2637 ((this_frame->intra_error / DOUBLE_DIVIDE_CHECK(this_frame->coded_error)) < 2.5) && 2638 ((fabs(last_frame->coded_error - this_frame->coded_error) / DOUBLE_DIVIDE_CHECK(this_frame->coded_error) > .40) || 2639 (fabs(last_frame->intra_error - this_frame->intra_error) / DOUBLE_DIVIDE_CHECK(this_frame->intra_error) > .40) || 2640 ((next_frame->intra_error / DOUBLE_DIVIDE_CHECK(next_frame->coded_error)) > 3.5) 2641 ) 2642 ) 2643 ) 2644 ) 2645 { 2646 int i; 2647 FIRSTPASS_STATS *start_pos; 2648 2649 FIRSTPASS_STATS local_next_frame; 2650 2651 double boost_score = 0.0; 2652 double old_boost_score = 0.0; 2653 double decay_accumulator = 1.0; 2654 double next_iiratio; 2655 2656 vpx_memcpy(&local_next_frame, next_frame, sizeof(*next_frame)); 2657 2658 /* Note the starting file position so we can reset to it */ 2659 start_pos = cpi->twopass.stats_in; 2660 2661 /* Examine how well the key frame predicts subsequent frames */ 2662 for (i = 0 ; i < 16; i++) 2663 { 2664 next_iiratio = (IIKFACTOR1 * local_next_frame.intra_error / DOUBLE_DIVIDE_CHECK(local_next_frame.coded_error)) ; 2665 2666 if (next_iiratio > RMAX) 2667 next_iiratio = RMAX; 2668 2669 /* Cumulative effect of decay in prediction quality */ 2670 if (local_next_frame.pcnt_inter > 0.85) 2671 decay_accumulator = decay_accumulator * local_next_frame.pcnt_inter; 2672 else 2673 decay_accumulator = decay_accumulator * ((0.85 + local_next_frame.pcnt_inter) / 2.0); 2674 2675 /* Keep a running total */ 2676 boost_score += (decay_accumulator * next_iiratio); 2677 2678 /* Test various breakout clauses */ 2679 if ((local_next_frame.pcnt_inter < 0.05) || 2680 (next_iiratio < 1.5) || 2681 (((local_next_frame.pcnt_inter - 2682 local_next_frame.pcnt_neutral) < 0.20) && 2683 (next_iiratio < 3.0)) || 2684 ((boost_score - old_boost_score) < 0.5) || 2685 (local_next_frame.intra_error < 200) 2686 ) 2687 { 2688 break; 2689 } 2690 2691 old_boost_score = boost_score; 2692 2693 /* Get the next frame details */ 2694 if (EOF == input_stats(cpi, &local_next_frame)) 2695 break; 2696 } 2697 2698 /* If there is tolerable prediction for at least the next 3 frames 2699 * then break out else discard this pottential key frame and move on 2700 */ 2701 if (boost_score > 5.0 && (i > 3)) 2702 is_viable_kf = 1; 2703 else 2704 { 2705 /* Reset the file position */ 2706 reset_fpf_position(cpi, start_pos); 2707 2708 is_viable_kf = 0; 2709 } 2710 } 2711 2712 return is_viable_kf; 2713 } 2714 static void find_next_key_frame(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame) 2715 { 2716 int i,j; 2717 FIRSTPASS_STATS last_frame; 2718 FIRSTPASS_STATS first_frame; 2719 FIRSTPASS_STATS next_frame; 2720 FIRSTPASS_STATS *start_position; 2721 2722 double decay_accumulator = 1.0; 2723 double boost_score = 0; 2724 double old_boost_score = 0.0; 2725 double loop_decay_rate; 2726 2727 double kf_mod_err = 0.0; 2728 double kf_group_err = 0.0; 2729 double kf_group_intra_err = 0.0; 2730 double kf_group_coded_err = 0.0; 2731 double recent_loop_decay[8] = {1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0}; 2732 2733 vpx_memset(&next_frame, 0, sizeof(next_frame)); 2734 2735 vp8_clear_system_state(); 2736 start_position = cpi->twopass.stats_in; 2737 2738 cpi->common.frame_type = KEY_FRAME; 2739 2740 /* is this a forced key frame by interval */ 2741 cpi->this_key_frame_forced = cpi->next_key_frame_forced; 2742 2743 /* Clear the alt ref active flag as this can never be active on a key 2744 * frame 2745 */ 2746 cpi->source_alt_ref_active = 0; 2747 2748 /* Kf is always a gf so clear frames till next gf counter */ 2749 cpi->frames_till_gf_update_due = 0; 2750 2751 cpi->twopass.frames_to_key = 1; 2752 2753 /* Take a copy of the initial frame details */ 2754 vpx_memcpy(&first_frame, this_frame, sizeof(*this_frame)); 2755 2756 cpi->twopass.kf_group_bits = 0; 2757 cpi->twopass.kf_group_error_left = 0; 2758 2759 kf_mod_err = calculate_modified_err(cpi, this_frame); 2760 2761 /* find the next keyframe */ 2762 i = 0; 2763 while (cpi->twopass.stats_in < cpi->twopass.stats_in_end) 2764 { 2765 /* Accumulate kf group error */ 2766 kf_group_err += calculate_modified_err(cpi, this_frame); 2767 2768 /* These figures keep intra and coded error counts for all frames 2769 * including key frames in the group. The effect of the key frame 2770 * itself can be subtracted out using the first_frame data 2771 * collected above 2772 */ 2773 kf_group_intra_err += this_frame->intra_error; 2774 kf_group_coded_err += this_frame->coded_error; 2775 2776 /* load a the next frame's stats */ 2777 vpx_memcpy(&last_frame, this_frame, sizeof(*this_frame)); 2778 input_stats(cpi, this_frame); 2779 2780 /* Provided that we are not at the end of the file... */ 2781 if (cpi->oxcf.auto_key 2782 && lookup_next_frame_stats(cpi, &next_frame) != EOF) 2783 { 2784 /* Normal scene cut check */ 2785 if ( ( i >= MIN_GF_INTERVAL ) && 2786 test_candidate_kf(cpi, &last_frame, this_frame, &next_frame) ) 2787 { 2788 break; 2789 } 2790 2791 /* How fast is prediction quality decaying */ 2792 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame); 2793 2794 /* We want to know something about the recent past... rather than 2795 * as used elsewhere where we are concened with decay in prediction 2796 * quality since the last GF or KF. 2797 */ 2798 recent_loop_decay[i%8] = loop_decay_rate; 2799 decay_accumulator = 1.0; 2800 for (j = 0; j < 8; j++) 2801 { 2802 decay_accumulator = decay_accumulator * recent_loop_decay[j]; 2803 } 2804 2805 /* Special check for transition or high motion followed by a 2806 * static scene. 2807 */ 2808 if ( detect_transition_to_still( cpi, i, 2809 (cpi->key_frame_frequency-i), 2810 loop_decay_rate, 2811 decay_accumulator ) ) 2812 { 2813 break; 2814 } 2815 2816 2817 /* Step on to the next frame */ 2818 cpi->twopass.frames_to_key ++; 2819 2820 /* If we don't have a real key frame within the next two 2821 * forcekeyframeevery intervals then break out of the loop. 2822 */ 2823 if (cpi->twopass.frames_to_key >= 2 *(int)cpi->key_frame_frequency) 2824 break; 2825 } else 2826 cpi->twopass.frames_to_key ++; 2827 2828 i++; 2829 } 2830 2831 /* If there is a max kf interval set by the user we must obey it. 2832 * We already breakout of the loop above at 2x max. 2833 * This code centers the extra kf if the actual natural 2834 * interval is between 1x and 2x 2835 */ 2836 if (cpi->oxcf.auto_key 2837 && cpi->twopass.frames_to_key > (int)cpi->key_frame_frequency ) 2838 { 2839 FIRSTPASS_STATS *current_pos = cpi->twopass.stats_in; 2840 FIRSTPASS_STATS tmp_frame; 2841 2842 cpi->twopass.frames_to_key /= 2; 2843 2844 /* Copy first frame details */ 2845 vpx_memcpy(&tmp_frame, &first_frame, sizeof(first_frame)); 2846 2847 /* Reset to the start of the group */ 2848 reset_fpf_position(cpi, start_position); 2849 2850 kf_group_err = 0; 2851 kf_group_intra_err = 0; 2852 kf_group_coded_err = 0; 2853 2854 /* Rescan to get the correct error data for the forced kf group */ 2855 for( i = 0; i < cpi->twopass.frames_to_key; i++ ) 2856 { 2857 /* Accumulate kf group errors */ 2858 kf_group_err += calculate_modified_err(cpi, &tmp_frame); 2859 kf_group_intra_err += tmp_frame.intra_error; 2860 kf_group_coded_err += tmp_frame.coded_error; 2861 2862 /* Load a the next frame's stats */ 2863 input_stats(cpi, &tmp_frame); 2864 } 2865 2866 /* Reset to the start of the group */ 2867 reset_fpf_position(cpi, current_pos); 2868 2869 cpi->next_key_frame_forced = 1; 2870 } 2871 else 2872 cpi->next_key_frame_forced = 0; 2873 2874 /* Special case for the last frame of the file */ 2875 if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end) 2876 { 2877 /* Accumulate kf group error */ 2878 kf_group_err += calculate_modified_err(cpi, this_frame); 2879 2880 /* These figures keep intra and coded error counts for all frames 2881 * including key frames in the group. The effect of the key frame 2882 * itself can be subtracted out using the first_frame data 2883 * collected above 2884 */ 2885 kf_group_intra_err += this_frame->intra_error; 2886 kf_group_coded_err += this_frame->coded_error; 2887 } 2888 2889 /* Calculate the number of bits that should be assigned to the kf group. */ 2890 if ((cpi->twopass.bits_left > 0) && (cpi->twopass.modified_error_left > 0.0)) 2891 { 2892 /* Max for a single normal frame (not key frame) */ 2893 int max_bits = frame_max_bits(cpi); 2894 2895 /* Maximum bits for the kf group */ 2896 int64_t max_grp_bits; 2897 2898 /* Default allocation based on bits left and relative 2899 * complexity of the section 2900 */ 2901 cpi->twopass.kf_group_bits = (int64_t)( cpi->twopass.bits_left * 2902 ( kf_group_err / 2903 cpi->twopass.modified_error_left )); 2904 2905 /* Clip based on maximum per frame rate defined by the user. */ 2906 max_grp_bits = (int64_t)max_bits * (int64_t)cpi->twopass.frames_to_key; 2907 if (cpi->twopass.kf_group_bits > max_grp_bits) 2908 cpi->twopass.kf_group_bits = max_grp_bits; 2909 2910 /* Additional special case for CBR if buffer is getting full. */ 2911 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 2912 { 2913 int64_t opt_buffer_lvl = cpi->oxcf.optimal_buffer_level; 2914 int64_t buffer_lvl = cpi->buffer_level; 2915 2916 /* If the buffer is near or above the optimal and this kf group is 2917 * not being allocated much then increase the allocation a bit. 2918 */ 2919 if (buffer_lvl >= opt_buffer_lvl) 2920 { 2921 int64_t high_water_mark = (opt_buffer_lvl + 2922 cpi->oxcf.maximum_buffer_size) >> 1; 2923 2924 int64_t av_group_bits; 2925 2926 /* Av bits per frame * number of frames */ 2927 av_group_bits = (int64_t)cpi->av_per_frame_bandwidth * 2928 (int64_t)cpi->twopass.frames_to_key; 2929 2930 /* We are at or above the maximum. */ 2931 if (cpi->buffer_level >= high_water_mark) 2932 { 2933 int64_t min_group_bits; 2934 2935 min_group_bits = av_group_bits + 2936 (int64_t)(buffer_lvl - 2937 high_water_mark); 2938 2939 if (cpi->twopass.kf_group_bits < min_group_bits) 2940 cpi->twopass.kf_group_bits = min_group_bits; 2941 } 2942 /* We are above optimal but below the maximum */ 2943 else if (cpi->twopass.kf_group_bits < av_group_bits) 2944 { 2945 int64_t bits_below_av = av_group_bits - 2946 cpi->twopass.kf_group_bits; 2947 2948 cpi->twopass.kf_group_bits += 2949 (int64_t)((double)bits_below_av * 2950 (double)(buffer_lvl - opt_buffer_lvl) / 2951 (double)(high_water_mark - opt_buffer_lvl)); 2952 } 2953 } 2954 } 2955 } 2956 else 2957 cpi->twopass.kf_group_bits = 0; 2958 2959 /* Reset the first pass file position */ 2960 reset_fpf_position(cpi, start_position); 2961 2962 /* determine how big to make this keyframe based on how well the 2963 * subsequent frames use inter blocks 2964 */ 2965 decay_accumulator = 1.0; 2966 boost_score = 0.0; 2967 loop_decay_rate = 1.00; /* Starting decay rate */ 2968 2969 for (i = 0 ; i < cpi->twopass.frames_to_key ; i++) 2970 { 2971 double r; 2972 2973 if (EOF == input_stats(cpi, &next_frame)) 2974 break; 2975 2976 if (next_frame.intra_error > cpi->twopass.kf_intra_err_min) 2977 r = (IIKFACTOR2 * next_frame.intra_error / 2978 DOUBLE_DIVIDE_CHECK(next_frame.coded_error)); 2979 else 2980 r = (IIKFACTOR2 * cpi->twopass.kf_intra_err_min / 2981 DOUBLE_DIVIDE_CHECK(next_frame.coded_error)); 2982 2983 if (r > RMAX) 2984 r = RMAX; 2985 2986 /* How fast is prediction quality decaying */ 2987 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame); 2988 2989 decay_accumulator = decay_accumulator * loop_decay_rate; 2990 decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator; 2991 2992 boost_score += (decay_accumulator * r); 2993 2994 if ((i > MIN_GF_INTERVAL) && 2995 ((boost_score - old_boost_score) < 1.0)) 2996 { 2997 break; 2998 } 2999 3000 old_boost_score = boost_score; 3001 } 3002 3003 if (1) 3004 { 3005 FIRSTPASS_STATS sectionstats; 3006 double Ratio; 3007 3008 zero_stats(§ionstats); 3009 reset_fpf_position(cpi, start_position); 3010 3011 for (i = 0 ; i < cpi->twopass.frames_to_key ; i++) 3012 { 3013 input_stats(cpi, &next_frame); 3014 accumulate_stats(§ionstats, &next_frame); 3015 } 3016 3017 avg_stats(§ionstats); 3018 3019 cpi->twopass.section_intra_rating = (unsigned int) 3020 (sectionstats.intra_error 3021 / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error)); 3022 3023 Ratio = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error); 3024 cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025); 3025 3026 if (cpi->twopass.section_max_qfactor < 0.80) 3027 cpi->twopass.section_max_qfactor = 0.80; 3028 } 3029 3030 /* When using CBR apply additional buffer fullness related upper limits */ 3031 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 3032 { 3033 double max_boost; 3034 3035 if (cpi->drop_frames_allowed) 3036 { 3037 int df_buffer_level = (int)(cpi->oxcf.drop_frames_water_mark 3038 * (cpi->oxcf.optimal_buffer_level / 100)); 3039 3040 if (cpi->buffer_level > df_buffer_level) 3041 max_boost = ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth); 3042 else 3043 max_boost = 0.0; 3044 } 3045 else if (cpi->buffer_level > 0) 3046 { 3047 max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth); 3048 } 3049 else 3050 { 3051 max_boost = 0.0; 3052 } 3053 3054 if (boost_score > max_boost) 3055 boost_score = max_boost; 3056 } 3057 3058 /* Reset the first pass file position */ 3059 reset_fpf_position(cpi, start_position); 3060 3061 /* Work out how many bits to allocate for the key frame itself */ 3062 if (1) 3063 { 3064 int kf_boost = (int)boost_score; 3065 int allocation_chunks; 3066 int Counter = cpi->twopass.frames_to_key; 3067 int alt_kf_bits; 3068 YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx]; 3069 /* Min boost based on kf interval */ 3070 #if 0 3071 3072 while ((kf_boost < 48) && (Counter > 0)) 3073 { 3074 Counter -= 2; 3075 kf_boost ++; 3076 } 3077 3078 #endif 3079 3080 if (kf_boost < 48) 3081 { 3082 kf_boost += ((Counter + 1) >> 1); 3083 3084 if (kf_boost > 48) kf_boost = 48; 3085 } 3086 3087 /* bigger frame sizes need larger kf boosts, smaller frames smaller 3088 * boosts... 3089 */ 3090 if ((lst_yv12->y_width * lst_yv12->y_height) > (320 * 240)) 3091 kf_boost += 2 * (lst_yv12->y_width * lst_yv12->y_height) / (320 * 240); 3092 else if ((lst_yv12->y_width * lst_yv12->y_height) < (320 * 240)) 3093 kf_boost -= 4 * (320 * 240) / (lst_yv12->y_width * lst_yv12->y_height); 3094 3095 /* Min KF boost */ 3096 kf_boost = (int)((double)kf_boost * 100.0) >> 4; /* Scale 16 to 100 */ 3097 if (kf_boost < 250) 3098 kf_boost = 250; 3099 3100 /* 3101 * We do three calculations for kf size. 3102 * The first is based on the error score for the whole kf group. 3103 * The second (optionaly) on the key frames own error if this is 3104 * smaller than the average for the group. 3105 * The final one insures that the frame receives at least the 3106 * allocation it would have received based on its own error score vs 3107 * the error score remaining 3108 * Special case if the sequence appears almost totaly static 3109 * as measured by the decay accumulator. In this case we want to 3110 * spend almost all of the bits on the key frame. 3111 * cpi->twopass.frames_to_key-1 because key frame itself is taken 3112 * care of by kf_boost. 3113 */ 3114 if ( decay_accumulator >= 0.99 ) 3115 { 3116 allocation_chunks = 3117 ((cpi->twopass.frames_to_key - 1) * 10) + kf_boost; 3118 } 3119 else 3120 { 3121 allocation_chunks = 3122 ((cpi->twopass.frames_to_key - 1) * 100) + kf_boost; 3123 } 3124 3125 /* Normalize Altboost and allocations chunck down to prevent overflow */ 3126 while (kf_boost > 1000) 3127 { 3128 kf_boost /= 2; 3129 allocation_chunks /= 2; 3130 } 3131 3132 cpi->twopass.kf_group_bits = (cpi->twopass.kf_group_bits < 0) ? 0 : cpi->twopass.kf_group_bits; 3133 3134 /* Calculate the number of bits to be spent on the key frame */ 3135 cpi->twopass.kf_bits = (int)((double)kf_boost * ((double)cpi->twopass.kf_group_bits / (double)allocation_chunks)); 3136 3137 /* Apply an additional limit for CBR */ 3138 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 3139 { 3140 if (cpi->twopass.kf_bits > (int)((3 * cpi->buffer_level) >> 2)) 3141 cpi->twopass.kf_bits = (int)((3 * cpi->buffer_level) >> 2); 3142 } 3143 3144 /* If the key frame is actually easier than the average for the 3145 * kf group (which does sometimes happen... eg a blank intro frame) 3146 * Then use an alternate calculation based on the kf error score 3147 * which should give a smaller key frame. 3148 */ 3149 if (kf_mod_err < kf_group_err / cpi->twopass.frames_to_key) 3150 { 3151 double alt_kf_grp_bits = 3152 ((double)cpi->twopass.bits_left * 3153 (kf_mod_err * (double)cpi->twopass.frames_to_key) / 3154 DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left)); 3155 3156 alt_kf_bits = (int)((double)kf_boost * 3157 (alt_kf_grp_bits / (double)allocation_chunks)); 3158 3159 if (cpi->twopass.kf_bits > alt_kf_bits) 3160 { 3161 cpi->twopass.kf_bits = alt_kf_bits; 3162 } 3163 } 3164 /* Else if it is much harder than other frames in the group make sure 3165 * it at least receives an allocation in keeping with its relative 3166 * error score 3167 */ 3168 else 3169 { 3170 alt_kf_bits = 3171 (int)((double)cpi->twopass.bits_left * 3172 (kf_mod_err / 3173 DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left))); 3174 3175 if (alt_kf_bits > cpi->twopass.kf_bits) 3176 { 3177 cpi->twopass.kf_bits = alt_kf_bits; 3178 } 3179 } 3180 3181 cpi->twopass.kf_group_bits -= cpi->twopass.kf_bits; 3182 /* Add in the minimum frame allowance */ 3183 cpi->twopass.kf_bits += cpi->min_frame_bandwidth; 3184 3185 /* Peer frame bit target for this frame */ 3186 cpi->per_frame_bandwidth = cpi->twopass.kf_bits; 3187 3188 /* Convert to a per second bitrate */ 3189 cpi->target_bandwidth = (int)(cpi->twopass.kf_bits * 3190 cpi->output_framerate); 3191 } 3192 3193 /* Note the total error score of the kf group minus the key frame itself */ 3194 cpi->twopass.kf_group_error_left = (int)(kf_group_err - kf_mod_err); 3195 3196 /* Adjust the count of total modified error left. The count of bits left 3197 * is adjusted elsewhere based on real coded frame sizes 3198 */ 3199 cpi->twopass.modified_error_left -= kf_group_err; 3200 3201 if (cpi->oxcf.allow_spatial_resampling) 3202 { 3203 int resample_trigger = 0; 3204 int last_kf_resampled = 0; 3205 int kf_q; 3206 int scale_val = 0; 3207 int hr, hs, vr, vs; 3208 int new_width = cpi->oxcf.Width; 3209 int new_height = cpi->oxcf.Height; 3210 3211 int projected_buffer_level = (int)cpi->buffer_level; 3212 int tmp_q; 3213 3214 double projected_bits_perframe; 3215 double group_iiratio = (kf_group_intra_err - first_frame.intra_error) / (kf_group_coded_err - first_frame.coded_error); 3216 double err_per_frame = kf_group_err / cpi->twopass.frames_to_key; 3217 double bits_per_frame; 3218 double av_bits_per_frame; 3219 double effective_size_ratio; 3220 3221 if ((cpi->common.Width != cpi->oxcf.Width) || (cpi->common.Height != cpi->oxcf.Height)) 3222 last_kf_resampled = 1; 3223 3224 /* Set back to unscaled by defaults */ 3225 cpi->common.horiz_scale = NORMAL; 3226 cpi->common.vert_scale = NORMAL; 3227 3228 /* Calculate Average bits per frame. */ 3229 av_bits_per_frame = cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->framerate); 3230 3231 /* CBR... Use the clip average as the target for deciding resample */ 3232 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 3233 { 3234 bits_per_frame = av_bits_per_frame; 3235 } 3236 3237 /* In VBR we want to avoid downsampling in easy section unless we 3238 * are under extreme pressure So use the larger of target bitrate 3239 * for this section or average bitrate for sequence 3240 */ 3241 else 3242 { 3243 /* This accounts for how hard the section is... */ 3244 bits_per_frame = (double) 3245 (cpi->twopass.kf_group_bits / cpi->twopass.frames_to_key); 3246 3247 /* Dont turn to resampling in easy sections just because they 3248 * have been assigned a small number of bits 3249 */ 3250 if (bits_per_frame < av_bits_per_frame) 3251 bits_per_frame = av_bits_per_frame; 3252 } 3253 3254 /* bits_per_frame should comply with our minimum */ 3255 if (bits_per_frame < (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100)) 3256 bits_per_frame = (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100); 3257 3258 /* Work out if spatial resampling is necessary */ 3259 kf_q = estimate_kf_group_q(cpi, err_per_frame, 3260 (int)bits_per_frame, group_iiratio); 3261 3262 /* If we project a required Q higher than the maximum allowed Q then 3263 * make a guess at the actual size of frames in this section 3264 */ 3265 projected_bits_perframe = bits_per_frame; 3266 tmp_q = kf_q; 3267 3268 while (tmp_q > cpi->worst_quality) 3269 { 3270 projected_bits_perframe *= 1.04; 3271 tmp_q--; 3272 } 3273 3274 /* Guess at buffer level at the end of the section */ 3275 projected_buffer_level = (int) 3276 (cpi->buffer_level - (int) 3277 ((projected_bits_perframe - av_bits_per_frame) * 3278 cpi->twopass.frames_to_key)); 3279 3280 if (0) 3281 { 3282 FILE *f = fopen("Subsamle.stt", "a"); 3283 fprintf(f, " %8d %8d %8d %8d %12.0f %8d %8d %8d\n", cpi->common.current_video_frame, kf_q, cpi->common.horiz_scale, cpi->common.vert_scale, kf_group_err / cpi->twopass.frames_to_key, (int)(cpi->twopass.kf_group_bits / cpi->twopass.frames_to_key), new_height, new_width); 3284 fclose(f); 3285 } 3286 3287 /* The trigger for spatial resampling depends on the various 3288 * parameters such as whether we are streaming (CBR) or VBR. 3289 */ 3290 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 3291 { 3292 /* Trigger resample if we are projected to fall below down 3293 * sample level or resampled last time and are projected to 3294 * remain below the up sample level 3295 */ 3296 if ((projected_buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100)) || 3297 (last_kf_resampled && (projected_buffer_level < (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100)))) 3298 resample_trigger = 1; 3299 else 3300 resample_trigger = 0; 3301 } 3302 else 3303 { 3304 int64_t clip_bits = (int64_t)(cpi->twopass.total_stats.count * cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->framerate)); 3305 int64_t over_spend = cpi->oxcf.starting_buffer_level - cpi->buffer_level; 3306 3307 /* If triggered last time the threshold for triggering again is 3308 * reduced: 3309 * 3310 * Projected Q higher than allowed and Overspend > 5% of total 3311 * bits 3312 */ 3313 if ((last_kf_resampled && (kf_q > cpi->worst_quality)) || 3314 ((kf_q > cpi->worst_quality) && 3315 (over_spend > clip_bits / 20))) 3316 resample_trigger = 1; 3317 else 3318 resample_trigger = 0; 3319 3320 } 3321 3322 if (resample_trigger) 3323 { 3324 while ((kf_q >= cpi->worst_quality) && (scale_val < 6)) 3325 { 3326 scale_val ++; 3327 3328 cpi->common.vert_scale = vscale_lookup[scale_val]; 3329 cpi->common.horiz_scale = hscale_lookup[scale_val]; 3330 3331 Scale2Ratio(cpi->common.horiz_scale, &hr, &hs); 3332 Scale2Ratio(cpi->common.vert_scale, &vr, &vs); 3333 3334 new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs; 3335 new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs; 3336 3337 /* Reducing the area to 1/4 does not reduce the complexity 3338 * (err_per_frame) to 1/4... effective_sizeratio attempts 3339 * to provide a crude correction for this 3340 */ 3341 effective_size_ratio = (double)(new_width * new_height) / (double)(cpi->oxcf.Width * cpi->oxcf.Height); 3342 effective_size_ratio = (1.0 + (3.0 * effective_size_ratio)) / 4.0; 3343 3344 /* Now try again and see what Q we get with the smaller 3345 * image size 3346 */ 3347 kf_q = estimate_kf_group_q(cpi, 3348 err_per_frame * effective_size_ratio, 3349 (int)bits_per_frame, group_iiratio); 3350 3351 if (0) 3352 { 3353 FILE *f = fopen("Subsamle.stt", "a"); 3354 fprintf(f, "******** %8d %8d %8d %12.0f %8d %8d %8d\n", kf_q, cpi->common.horiz_scale, cpi->common.vert_scale, kf_group_err / cpi->twopass.frames_to_key, (int)(cpi->twopass.kf_group_bits / cpi->twopass.frames_to_key), new_height, new_width); 3355 fclose(f); 3356 } 3357 } 3358 } 3359 3360 if ((cpi->common.Width != new_width) || (cpi->common.Height != new_height)) 3361 { 3362 cpi->common.Width = new_width; 3363 cpi->common.Height = new_height; 3364 vp8_alloc_compressor_data(cpi); 3365 } 3366 } 3367 } 3368
