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 <<= 3; 715 d->bmi.mv.as_mv.col <<= 3; 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 return -(log( prob ) / log( 2.0 )); 913 } 914 static int64_t estimate_modemvcost(VP8_COMP *cpi, 915 FIRSTPASS_STATS * fpstats) 916 { 917 int mv_cost; 918 int mode_cost; 919 920 double av_pct_inter = fpstats->pcnt_inter / fpstats->count; 921 double av_pct_motion = fpstats->pcnt_motion / fpstats->count; 922 double av_intra = (1.0 - av_pct_inter); 923 924 double zz_cost; 925 double motion_cost; 926 double intra_cost; 927 928 zz_cost = bitcost(av_pct_inter - av_pct_motion); 929 motion_cost = bitcost(av_pct_motion); 930 intra_cost = bitcost(av_intra); 931 932 /* Estimate of extra bits per mv overhead for mbs 933 * << 9 is the normalization to the (bits * 512) used in vp8_bits_per_mb 934 */ 935 mv_cost = ((int)(fpstats->new_mv_count / fpstats->count) * 8) << 9; 936 937 /* Crude estimate of overhead cost from modes 938 * << 9 is the normalization to (bits * 512) used in vp8_bits_per_mb 939 */ 940 mode_cost = 941 (int)( ( ((av_pct_inter - av_pct_motion) * zz_cost) + 942 (av_pct_motion * motion_cost) + 943 (av_intra * intra_cost) ) * cpi->common.MBs ) << 9; 944 945 return mv_cost + mode_cost; 946 } 947 948 static double calc_correction_factor( double err_per_mb, 949 double err_devisor, 950 double pt_low, 951 double pt_high, 952 int Q ) 953 { 954 double power_term; 955 double error_term = err_per_mb / err_devisor; 956 double correction_factor; 957 958 /* Adjustment based on Q to power term. */ 959 power_term = pt_low + (Q * 0.01); 960 power_term = (power_term > pt_high) ? pt_high : power_term; 961 962 /* Adjustments to error term */ 963 /* TBD */ 964 965 /* Calculate correction factor */ 966 correction_factor = pow(error_term, power_term); 967 968 /* Clip range */ 969 correction_factor = 970 (correction_factor < 0.05) 971 ? 0.05 : (correction_factor > 5.0) ? 5.0 : correction_factor; 972 973 return correction_factor; 974 } 975 976 static int estimate_max_q(VP8_COMP *cpi, 977 FIRSTPASS_STATS * fpstats, 978 int section_target_bandwitdh, 979 int overhead_bits ) 980 { 981 int Q; 982 int num_mbs = cpi->common.MBs; 983 int target_norm_bits_per_mb; 984 985 double section_err = (fpstats->coded_error / fpstats->count); 986 double err_per_mb = section_err / num_mbs; 987 double err_correction_factor; 988 double speed_correction = 1.0; 989 int overhead_bits_per_mb; 990 991 if (section_target_bandwitdh <= 0) 992 return cpi->twopass.maxq_max_limit; /* Highest value allowed */ 993 994 target_norm_bits_per_mb = 995 (section_target_bandwitdh < (1 << 20)) 996 ? (512 * section_target_bandwitdh) / num_mbs 997 : 512 * (section_target_bandwitdh / num_mbs); 998 999 /* Calculate a corrective factor based on a rolling ratio of bits spent 1000 * vs target bits 1001 */ 1002 if ((cpi->rolling_target_bits > 0) && 1003 (cpi->active_worst_quality < cpi->worst_quality)) 1004 { 1005 double rolling_ratio; 1006 1007 rolling_ratio = (double)cpi->rolling_actual_bits / 1008 (double)cpi->rolling_target_bits; 1009 1010 if (rolling_ratio < 0.95) 1011 cpi->twopass.est_max_qcorrection_factor -= 0.005; 1012 else if (rolling_ratio > 1.05) 1013 cpi->twopass.est_max_qcorrection_factor += 0.005; 1014 1015 cpi->twopass.est_max_qcorrection_factor = 1016 (cpi->twopass.est_max_qcorrection_factor < 0.1) 1017 ? 0.1 1018 : (cpi->twopass.est_max_qcorrection_factor > 10.0) 1019 ? 10.0 : cpi->twopass.est_max_qcorrection_factor; 1020 } 1021 1022 /* Corrections for higher compression speed settings 1023 * (reduced compression expected) 1024 */ 1025 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1)) 1026 { 1027 if (cpi->oxcf.cpu_used <= 5) 1028 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04); 1029 else 1030 speed_correction = 1.25; 1031 } 1032 1033 /* Estimate of overhead bits per mb */ 1034 /* Correction to overhead bits for min allowed Q. */ 1035 overhead_bits_per_mb = overhead_bits / num_mbs; 1036 overhead_bits_per_mb = (int)(overhead_bits_per_mb * 1037 pow( 0.98, (double)cpi->twopass.maxq_min_limit )); 1038 1039 /* Try and pick a max Q that will be high enough to encode the 1040 * content at the given rate. 1041 */ 1042 for (Q = cpi->twopass.maxq_min_limit; Q < cpi->twopass.maxq_max_limit; Q++) 1043 { 1044 int bits_per_mb_at_this_q; 1045 1046 /* Error per MB based correction factor */ 1047 err_correction_factor = 1048 calc_correction_factor(err_per_mb, 150.0, 0.40, 0.90, Q); 1049 1050 bits_per_mb_at_this_q = 1051 vp8_bits_per_mb[INTER_FRAME][Q] + overhead_bits_per_mb; 1052 1053 bits_per_mb_at_this_q = (int)(.5 + err_correction_factor 1054 * speed_correction * cpi->twopass.est_max_qcorrection_factor 1055 * cpi->twopass.section_max_qfactor 1056 * (double)bits_per_mb_at_this_q); 1057 1058 /* Mode and motion overhead */ 1059 /* As Q rises in real encode loop rd code will force overhead down 1060 * We make a crude adjustment for this here as *.98 per Q step. 1061 */ 1062 overhead_bits_per_mb = (int)((double)overhead_bits_per_mb * 0.98); 1063 1064 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb) 1065 break; 1066 } 1067 1068 /* Restriction on active max q for constrained quality mode. */ 1069 if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) && 1070 (Q < cpi->cq_target_quality) ) 1071 { 1072 Q = cpi->cq_target_quality; 1073 } 1074 1075 /* Adjust maxq_min_limit and maxq_max_limit limits based on 1076 * average q observed in clip for non kf/gf.arf frames 1077 * Give average a chance to settle though. 1078 */ 1079 if ( (cpi->ni_frames > 1080 ((int)cpi->twopass.total_stats.count >> 8)) && 1081 (cpi->ni_frames > 150) ) 1082 { 1083 cpi->twopass.maxq_max_limit = ((cpi->ni_av_qi + 32) < cpi->worst_quality) 1084 ? (cpi->ni_av_qi + 32) : cpi->worst_quality; 1085 cpi->twopass.maxq_min_limit = ((cpi->ni_av_qi - 32) > cpi->best_quality) 1086 ? (cpi->ni_av_qi - 32) : cpi->best_quality; 1087 } 1088 1089 return Q; 1090 } 1091 1092 /* For cq mode estimate a cq level that matches the observed 1093 * complexity and data rate. 1094 */ 1095 static int estimate_cq( VP8_COMP *cpi, 1096 FIRSTPASS_STATS * fpstats, 1097 int section_target_bandwitdh, 1098 int overhead_bits ) 1099 { 1100 int Q; 1101 int num_mbs = cpi->common.MBs; 1102 int target_norm_bits_per_mb; 1103 1104 double section_err = (fpstats->coded_error / fpstats->count); 1105 double err_per_mb = section_err / num_mbs; 1106 double err_correction_factor; 1107 double speed_correction = 1.0; 1108 double clip_iiratio; 1109 double clip_iifactor; 1110 int overhead_bits_per_mb; 1111 1112 if (0) 1113 { 1114 FILE *f = fopen("epmp.stt", "a"); 1115 fprintf(f, "%10.2f\n", err_per_mb ); 1116 fclose(f); 1117 } 1118 1119 target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20)) 1120 ? (512 * section_target_bandwitdh) / num_mbs 1121 : 512 * (section_target_bandwitdh / num_mbs); 1122 1123 /* Estimate of overhead bits per mb */ 1124 overhead_bits_per_mb = overhead_bits / num_mbs; 1125 1126 /* Corrections for higher compression speed settings 1127 * (reduced compression expected) 1128 */ 1129 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1)) 1130 { 1131 if (cpi->oxcf.cpu_used <= 5) 1132 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04); 1133 else 1134 speed_correction = 1.25; 1135 } 1136 1137 /* II ratio correction factor for clip as a whole */ 1138 clip_iiratio = cpi->twopass.total_stats.intra_error / 1139 DOUBLE_DIVIDE_CHECK(cpi->twopass.total_stats.coded_error); 1140 clip_iifactor = 1.0 - ((clip_iiratio - 10.0) * 0.025); 1141 if (clip_iifactor < 0.80) 1142 clip_iifactor = 0.80; 1143 1144 /* Try and pick a Q that can encode the content at the given rate. */ 1145 for (Q = 0; Q < MAXQ; Q++) 1146 { 1147 int bits_per_mb_at_this_q; 1148 1149 /* Error per MB based correction factor */ 1150 err_correction_factor = 1151 calc_correction_factor(err_per_mb, 100.0, 0.40, 0.90, Q); 1152 1153 bits_per_mb_at_this_q = 1154 vp8_bits_per_mb[INTER_FRAME][Q] + overhead_bits_per_mb; 1155 1156 bits_per_mb_at_this_q = 1157 (int)( .5 + err_correction_factor * 1158 speed_correction * 1159 clip_iifactor * 1160 (double)bits_per_mb_at_this_q); 1161 1162 /* Mode and motion overhead */ 1163 /* As Q rises in real encode loop rd code will force overhead down 1164 * We make a crude adjustment for this here as *.98 per Q step. 1165 */ 1166 overhead_bits_per_mb = (int)((double)overhead_bits_per_mb * 0.98); 1167 1168 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb) 1169 break; 1170 } 1171 1172 /* Clip value to range "best allowed to (worst allowed - 1)" */ 1173 Q = cq_level[Q]; 1174 if ( Q >= cpi->worst_quality ) 1175 Q = cpi->worst_quality - 1; 1176 if ( Q < cpi->best_quality ) 1177 Q = cpi->best_quality; 1178 1179 return Q; 1180 } 1181 1182 static int estimate_q(VP8_COMP *cpi, double section_err, int section_target_bandwitdh) 1183 { 1184 int Q; 1185 int num_mbs = cpi->common.MBs; 1186 int target_norm_bits_per_mb; 1187 1188 double err_per_mb = section_err / num_mbs; 1189 double err_correction_factor; 1190 double speed_correction = 1.0; 1191 1192 target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20)) ? (512 * section_target_bandwitdh) / num_mbs : 512 * (section_target_bandwitdh / num_mbs); 1193 1194 /* Corrections for higher compression speed settings 1195 * (reduced compression expected) 1196 */ 1197 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1)) 1198 { 1199 if (cpi->oxcf.cpu_used <= 5) 1200 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04); 1201 else 1202 speed_correction = 1.25; 1203 } 1204 1205 /* Try and pick a Q that can encode the content at the given rate. */ 1206 for (Q = 0; Q < MAXQ; Q++) 1207 { 1208 int bits_per_mb_at_this_q; 1209 1210 /* Error per MB based correction factor */ 1211 err_correction_factor = 1212 calc_correction_factor(err_per_mb, 150.0, 0.40, 0.90, Q); 1213 1214 bits_per_mb_at_this_q = 1215 (int)( .5 + ( err_correction_factor * 1216 speed_correction * 1217 cpi->twopass.est_max_qcorrection_factor * 1218 (double)vp8_bits_per_mb[INTER_FRAME][Q] / 1.0 ) ); 1219 1220 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb) 1221 break; 1222 } 1223 1224 return Q; 1225 } 1226 1227 /* Estimate a worst case Q for a KF group */ 1228 static int estimate_kf_group_q(VP8_COMP *cpi, double section_err, int section_target_bandwitdh, double group_iiratio) 1229 { 1230 int Q; 1231 int num_mbs = cpi->common.MBs; 1232 int target_norm_bits_per_mb = (512 * section_target_bandwitdh) / num_mbs; 1233 int bits_per_mb_at_this_q; 1234 1235 double err_per_mb = section_err / num_mbs; 1236 double err_correction_factor; 1237 double speed_correction = 1.0; 1238 double current_spend_ratio = 1.0; 1239 1240 double pow_highq = (POW1 < 0.6) ? POW1 + 0.3 : 0.90; 1241 double pow_lowq = (POW1 < 0.7) ? POW1 + 0.1 : 0.80; 1242 1243 double iiratio_correction_factor = 1.0; 1244 1245 double combined_correction_factor; 1246 1247 /* Trap special case where the target is <= 0 */ 1248 if (target_norm_bits_per_mb <= 0) 1249 return MAXQ * 2; 1250 1251 /* Calculate a corrective factor based on a rolling ratio of bits spent 1252 * vs target bits 1253 * This is clamped to the range 0.1 to 10.0 1254 */ 1255 if (cpi->long_rolling_target_bits <= 0) 1256 current_spend_ratio = 10.0; 1257 else 1258 { 1259 current_spend_ratio = (double)cpi->long_rolling_actual_bits / (double)cpi->long_rolling_target_bits; 1260 current_spend_ratio = (current_spend_ratio > 10.0) ? 10.0 : (current_spend_ratio < 0.1) ? 0.1 : current_spend_ratio; 1261 } 1262 1263 /* Calculate a correction factor based on the quality of prediction in 1264 * the sequence as indicated by intra_inter error score ratio (IIRatio) 1265 * The idea here is to favour subsampling in the hardest sections vs 1266 * the easyest. 1267 */ 1268 iiratio_correction_factor = 1.0 - ((group_iiratio - 6.0) * 0.1); 1269 1270 if (iiratio_correction_factor < 0.5) 1271 iiratio_correction_factor = 0.5; 1272 1273 /* Corrections for higher compression speed settings 1274 * (reduced compression expected) 1275 */ 1276 if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1)) 1277 { 1278 if (cpi->oxcf.cpu_used <= 5) 1279 speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04); 1280 else 1281 speed_correction = 1.25; 1282 } 1283 1284 /* Combine the various factors calculated above */ 1285 combined_correction_factor = speed_correction * iiratio_correction_factor * current_spend_ratio; 1286 1287 /* Try and pick a Q that should be high enough to encode the content at 1288 * the given rate. 1289 */ 1290 for (Q = 0; Q < MAXQ; Q++) 1291 { 1292 /* Error per MB based correction factor */ 1293 err_correction_factor = 1294 calc_correction_factor(err_per_mb, 150.0, pow_lowq, pow_highq, Q); 1295 1296 bits_per_mb_at_this_q = 1297 (int)(.5 + ( err_correction_factor * 1298 combined_correction_factor * 1299 (double)vp8_bits_per_mb[INTER_FRAME][Q]) ); 1300 1301 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb) 1302 break; 1303 } 1304 1305 /* If we could not hit the target even at Max Q then estimate what Q 1306 * would have been required 1307 */ 1308 while ((bits_per_mb_at_this_q > target_norm_bits_per_mb) && (Q < (MAXQ * 2))) 1309 { 1310 1311 bits_per_mb_at_this_q = (int)(0.96 * bits_per_mb_at_this_q); 1312 Q++; 1313 } 1314 1315 if (0) 1316 { 1317 FILE *f = fopen("estkf_q.stt", "a"); 1318 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, 1319 target_norm_bits_per_mb, err_per_mb, err_correction_factor, 1320 current_spend_ratio, group_iiratio, iiratio_correction_factor, 1321 (double)cpi->buffer_level / (double)cpi->oxcf.optimal_buffer_level, Q); 1322 fclose(f); 1323 } 1324 1325 return Q; 1326 } 1327 1328 extern void vp8_new_framerate(VP8_COMP *cpi, double framerate); 1329 1330 void vp8_init_second_pass(VP8_COMP *cpi) 1331 { 1332 FIRSTPASS_STATS this_frame; 1333 FIRSTPASS_STATS *start_pos; 1334 1335 double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100); 1336 1337 zero_stats(&cpi->twopass.total_stats); 1338 zero_stats(&cpi->twopass.total_left_stats); 1339 1340 if (!cpi->twopass.stats_in_end) 1341 return; 1342 1343 cpi->twopass.total_stats = *cpi->twopass.stats_in_end; 1344 cpi->twopass.total_left_stats = cpi->twopass.total_stats; 1345 1346 /* each frame can have a different duration, as the frame rate in the 1347 * source isn't guaranteed to be constant. The frame rate prior to 1348 * the first frame encoded in the second pass is a guess. However the 1349 * sum duration is not. Its calculated based on the actual durations of 1350 * all frames from the first pass. 1351 */ 1352 vp8_new_framerate(cpi, 10000000.0 * cpi->twopass.total_stats.count / cpi->twopass.total_stats.duration); 1353 1354 cpi->output_framerate = cpi->framerate; 1355 cpi->twopass.bits_left = (int64_t)(cpi->twopass.total_stats.duration * cpi->oxcf.target_bandwidth / 10000000.0) ; 1356 cpi->twopass.bits_left -= (int64_t)(cpi->twopass.total_stats.duration * two_pass_min_rate / 10000000.0); 1357 1358 /* Calculate a minimum intra value to be used in determining the IIratio 1359 * scores used in the second pass. We have this minimum to make sure 1360 * that clips that are static but "low complexity" in the intra domain 1361 * are still boosted appropriately for KF/GF/ARF 1362 */ 1363 cpi->twopass.kf_intra_err_min = KF_MB_INTRA_MIN * cpi->common.MBs; 1364 cpi->twopass.gf_intra_err_min = GF_MB_INTRA_MIN * cpi->common.MBs; 1365 1366 /* Scan the first pass file and calculate an average Intra / Inter error 1367 * score ratio for the sequence 1368 */ 1369 { 1370 double sum_iiratio = 0.0; 1371 double IIRatio; 1372 1373 start_pos = cpi->twopass.stats_in; /* Note starting "file" position */ 1374 1375 while (input_stats(cpi, &this_frame) != EOF) 1376 { 1377 IIRatio = this_frame.intra_error / DOUBLE_DIVIDE_CHECK(this_frame.coded_error); 1378 IIRatio = (IIRatio < 1.0) ? 1.0 : (IIRatio > 20.0) ? 20.0 : IIRatio; 1379 sum_iiratio += IIRatio; 1380 } 1381 1382 cpi->twopass.avg_iiratio = sum_iiratio / DOUBLE_DIVIDE_CHECK((double)cpi->twopass.total_stats.count); 1383 1384 /* Reset file position */ 1385 reset_fpf_position(cpi, start_pos); 1386 } 1387 1388 /* Scan the first pass file and calculate a modified total error based 1389 * upon the bias/power function used to allocate bits 1390 */ 1391 { 1392 start_pos = cpi->twopass.stats_in; /* Note starting "file" position */ 1393 1394 cpi->twopass.modified_error_total = 0.0; 1395 cpi->twopass.modified_error_used = 0.0; 1396 1397 while (input_stats(cpi, &this_frame) != EOF) 1398 { 1399 cpi->twopass.modified_error_total += calculate_modified_err(cpi, &this_frame); 1400 } 1401 cpi->twopass.modified_error_left = cpi->twopass.modified_error_total; 1402 1403 reset_fpf_position(cpi, start_pos); /* Reset file position */ 1404 1405 } 1406 } 1407 1408 void vp8_end_second_pass(VP8_COMP *cpi) 1409 { 1410 } 1411 1412 /* This function gives and estimate of how badly we believe the prediction 1413 * quality is decaying from frame to frame. 1414 */ 1415 static double get_prediction_decay_rate(VP8_COMP *cpi, FIRSTPASS_STATS *next_frame) 1416 { 1417 double prediction_decay_rate; 1418 double motion_decay; 1419 double motion_pct = next_frame->pcnt_motion; 1420 1421 /* Initial basis is the % mbs inter coded */ 1422 prediction_decay_rate = next_frame->pcnt_inter; 1423 1424 /* High % motion -> somewhat higher decay rate */ 1425 motion_decay = (1.0 - (motion_pct / 20.0)); 1426 if (motion_decay < prediction_decay_rate) 1427 prediction_decay_rate = motion_decay; 1428 1429 /* Adjustment to decay rate based on speed of motion */ 1430 { 1431 double this_mv_rabs; 1432 double this_mv_cabs; 1433 double distance_factor; 1434 1435 this_mv_rabs = fabs(next_frame->mvr_abs * motion_pct); 1436 this_mv_cabs = fabs(next_frame->mvc_abs * motion_pct); 1437 1438 distance_factor = sqrt((this_mv_rabs * this_mv_rabs) + 1439 (this_mv_cabs * this_mv_cabs)) / 250.0; 1440 distance_factor = ((distance_factor > 1.0) 1441 ? 0.0 : (1.0 - distance_factor)); 1442 if (distance_factor < prediction_decay_rate) 1443 prediction_decay_rate = distance_factor; 1444 } 1445 1446 return prediction_decay_rate; 1447 } 1448 1449 /* Function to test for a condition where a complex transition is followed 1450 * by a static section. For example in slide shows where there is a fade 1451 * between slides. This is to help with more optimal kf and gf positioning. 1452 */ 1453 static int detect_transition_to_still( 1454 VP8_COMP *cpi, 1455 int frame_interval, 1456 int still_interval, 1457 double loop_decay_rate, 1458 double decay_accumulator ) 1459 { 1460 int trans_to_still = 0; 1461 1462 /* Break clause to detect very still sections after motion 1463 * For example a static image after a fade or other transition 1464 * instead of a clean scene cut. 1465 */ 1466 if ( (frame_interval > MIN_GF_INTERVAL) && 1467 (loop_decay_rate >= 0.999) && 1468 (decay_accumulator < 0.9) ) 1469 { 1470 int j; 1471 FIRSTPASS_STATS * position = cpi->twopass.stats_in; 1472 FIRSTPASS_STATS tmp_next_frame; 1473 double decay_rate; 1474 1475 /* Look ahead a few frames to see if static condition persists... */ 1476 for ( j = 0; j < still_interval; j++ ) 1477 { 1478 if (EOF == input_stats(cpi, &tmp_next_frame)) 1479 break; 1480 1481 decay_rate = get_prediction_decay_rate(cpi, &tmp_next_frame); 1482 if ( decay_rate < 0.999 ) 1483 break; 1484 } 1485 /* Reset file position */ 1486 reset_fpf_position(cpi, position); 1487 1488 /* Only if it does do we signal a transition to still */ 1489 if ( j == still_interval ) 1490 trans_to_still = 1; 1491 } 1492 1493 return trans_to_still; 1494 } 1495 1496 /* This function detects a flash through the high relative pcnt_second_ref 1497 * score in the frame following a flash frame. The offset passed in should 1498 * reflect this 1499 */ 1500 static int detect_flash( VP8_COMP *cpi, int offset ) 1501 { 1502 FIRSTPASS_STATS next_frame; 1503 1504 int flash_detected = 0; 1505 1506 /* Read the frame data. */ 1507 /* The return is 0 (no flash detected) if not a valid frame */ 1508 if ( read_frame_stats(cpi, &next_frame, offset) != EOF ) 1509 { 1510 /* What we are looking for here is a situation where there is a 1511 * brief break in prediction (such as a flash) but subsequent frames 1512 * are reasonably well predicted by an earlier (pre flash) frame. 1513 * The recovery after a flash is indicated by a high pcnt_second_ref 1514 * comapred to pcnt_inter. 1515 */ 1516 if ( (next_frame.pcnt_second_ref > next_frame.pcnt_inter) && 1517 (next_frame.pcnt_second_ref >= 0.5 ) ) 1518 { 1519 flash_detected = 1; 1520 1521 /*if (1) 1522 { 1523 FILE *f = fopen("flash.stt", "a"); 1524 fprintf(f, "%8.0f %6.2f %6.2f\n", 1525 next_frame.frame, 1526 next_frame.pcnt_inter, 1527 next_frame.pcnt_second_ref); 1528 fclose(f); 1529 }*/ 1530 } 1531 } 1532 1533 return flash_detected; 1534 } 1535 1536 /* Update the motion related elements to the GF arf boost calculation */ 1537 static void accumulate_frame_motion_stats( 1538 VP8_COMP *cpi, 1539 FIRSTPASS_STATS * this_frame, 1540 double * this_frame_mv_in_out, 1541 double * mv_in_out_accumulator, 1542 double * abs_mv_in_out_accumulator, 1543 double * mv_ratio_accumulator ) 1544 { 1545 double this_frame_mvr_ratio; 1546 double this_frame_mvc_ratio; 1547 double motion_pct; 1548 1549 /* Accumulate motion stats. */ 1550 motion_pct = this_frame->pcnt_motion; 1551 1552 /* Accumulate Motion In/Out of frame stats */ 1553 *this_frame_mv_in_out = this_frame->mv_in_out_count * motion_pct; 1554 *mv_in_out_accumulator += this_frame->mv_in_out_count * motion_pct; 1555 *abs_mv_in_out_accumulator += 1556 fabs(this_frame->mv_in_out_count * motion_pct); 1557 1558 /* Accumulate a measure of how uniform (or conversely how random) 1559 * the motion field is. (A ratio of absmv / mv) 1560 */ 1561 if (motion_pct > 0.05) 1562 { 1563 this_frame_mvr_ratio = fabs(this_frame->mvr_abs) / 1564 DOUBLE_DIVIDE_CHECK(fabs(this_frame->MVr)); 1565 1566 this_frame_mvc_ratio = fabs(this_frame->mvc_abs) / 1567 DOUBLE_DIVIDE_CHECK(fabs(this_frame->MVc)); 1568 1569 *mv_ratio_accumulator += 1570 (this_frame_mvr_ratio < this_frame->mvr_abs) 1571 ? (this_frame_mvr_ratio * motion_pct) 1572 : this_frame->mvr_abs * motion_pct; 1573 1574 *mv_ratio_accumulator += 1575 (this_frame_mvc_ratio < this_frame->mvc_abs) 1576 ? (this_frame_mvc_ratio * motion_pct) 1577 : this_frame->mvc_abs * motion_pct; 1578 1579 } 1580 } 1581 1582 /* Calculate a baseline boost number for the current frame. */ 1583 static double calc_frame_boost( 1584 VP8_COMP *cpi, 1585 FIRSTPASS_STATS * this_frame, 1586 double this_frame_mv_in_out ) 1587 { 1588 double frame_boost; 1589 1590 /* Underlying boost factor is based on inter intra error ratio */ 1591 if (this_frame->intra_error > cpi->twopass.gf_intra_err_min) 1592 frame_boost = (IIFACTOR * this_frame->intra_error / 1593 DOUBLE_DIVIDE_CHECK(this_frame->coded_error)); 1594 else 1595 frame_boost = (IIFACTOR * cpi->twopass.gf_intra_err_min / 1596 DOUBLE_DIVIDE_CHECK(this_frame->coded_error)); 1597 1598 /* Increase boost for frames where new data coming into frame 1599 * (eg zoom out). Slightly reduce boost if there is a net balance 1600 * of motion out of the frame (zoom in). 1601 * The range for this_frame_mv_in_out is -1.0 to +1.0 1602 */ 1603 if (this_frame_mv_in_out > 0.0) 1604 frame_boost += frame_boost * (this_frame_mv_in_out * 2.0); 1605 /* In extreme case boost is halved */ 1606 else 1607 frame_boost += frame_boost * (this_frame_mv_in_out / 2.0); 1608 1609 /* Clip to maximum */ 1610 if (frame_boost > GF_RMAX) 1611 frame_boost = GF_RMAX; 1612 1613 return frame_boost; 1614 } 1615 1616 #if NEW_BOOST 1617 static int calc_arf_boost( 1618 VP8_COMP *cpi, 1619 int offset, 1620 int f_frames, 1621 int b_frames, 1622 int *f_boost, 1623 int *b_boost ) 1624 { 1625 FIRSTPASS_STATS this_frame; 1626 1627 int i; 1628 double boost_score = 0.0; 1629 double mv_ratio_accumulator = 0.0; 1630 double decay_accumulator = 1.0; 1631 double this_frame_mv_in_out = 0.0; 1632 double mv_in_out_accumulator = 0.0; 1633 double abs_mv_in_out_accumulator = 0.0; 1634 double r; 1635 int flash_detected = 0; 1636 1637 /* Search forward from the proposed arf/next gf position */ 1638 for ( i = 0; i < f_frames; i++ ) 1639 { 1640 if ( read_frame_stats(cpi, &this_frame, (i+offset)) == EOF ) 1641 break; 1642 1643 /* Update the motion related elements to the boost calculation */ 1644 accumulate_frame_motion_stats( cpi, &this_frame, 1645 &this_frame_mv_in_out, &mv_in_out_accumulator, 1646 &abs_mv_in_out_accumulator, &mv_ratio_accumulator ); 1647 1648 /* Calculate the baseline boost number for this frame */ 1649 r = calc_frame_boost( cpi, &this_frame, this_frame_mv_in_out ); 1650 1651 /* We want to discount the the flash frame itself and the recovery 1652 * frame that follows as both will have poor scores. 1653 */ 1654 flash_detected = detect_flash(cpi, (i+offset)) || 1655 detect_flash(cpi, (i+offset+1)); 1656 1657 /* Cumulative effect of prediction quality decay */ 1658 if ( !flash_detected ) 1659 { 1660 decay_accumulator = 1661 decay_accumulator * 1662 get_prediction_decay_rate(cpi, &this_frame); 1663 decay_accumulator = 1664 decay_accumulator < 0.1 ? 0.1 : decay_accumulator; 1665 } 1666 boost_score += (decay_accumulator * r); 1667 1668 /* Break out conditions. */ 1669 if ( (!flash_detected) && 1670 ((mv_ratio_accumulator > 100.0) || 1671 (abs_mv_in_out_accumulator > 3.0) || 1672 (mv_in_out_accumulator < -2.0) ) ) 1673 { 1674 break; 1675 } 1676 } 1677 1678 *f_boost = (int)(boost_score * 100.0) >> 4; 1679 1680 /* Reset for backward looking loop */ 1681 boost_score = 0.0; 1682 mv_ratio_accumulator = 0.0; 1683 decay_accumulator = 1.0; 1684 this_frame_mv_in_out = 0.0; 1685 mv_in_out_accumulator = 0.0; 1686 abs_mv_in_out_accumulator = 0.0; 1687 1688 /* Search forward from the proposed arf/next gf position */ 1689 for ( i = -1; i >= -b_frames; i-- ) 1690 { 1691 if ( read_frame_stats(cpi, &this_frame, (i+offset)) == EOF ) 1692 break; 1693 1694 /* Update the motion related elements to the boost calculation */ 1695 accumulate_frame_motion_stats( cpi, &this_frame, 1696 &this_frame_mv_in_out, &mv_in_out_accumulator, 1697 &abs_mv_in_out_accumulator, &mv_ratio_accumulator ); 1698 1699 /* Calculate the baseline boost number for this frame */ 1700 r = calc_frame_boost( cpi, &this_frame, this_frame_mv_in_out ); 1701 1702 /* We want to discount the the flash frame itself and the recovery 1703 * frame that follows as both will have poor scores. 1704 */ 1705 flash_detected = detect_flash(cpi, (i+offset)) || 1706 detect_flash(cpi, (i+offset+1)); 1707 1708 /* Cumulative effect of prediction quality decay */ 1709 if ( !flash_detected ) 1710 { 1711 decay_accumulator = 1712 decay_accumulator * 1713 get_prediction_decay_rate(cpi, &this_frame); 1714 decay_accumulator = 1715 decay_accumulator < 0.1 ? 0.1 : decay_accumulator; 1716 } 1717 1718 boost_score += (decay_accumulator * r); 1719 1720 /* Break out conditions. */ 1721 if ( (!flash_detected) && 1722 ((mv_ratio_accumulator > 100.0) || 1723 (abs_mv_in_out_accumulator > 3.0) || 1724 (mv_in_out_accumulator < -2.0) ) ) 1725 { 1726 break; 1727 } 1728 } 1729 *b_boost = (int)(boost_score * 100.0) >> 4; 1730 1731 return (*f_boost + *b_boost); 1732 } 1733 #endif 1734 1735 /* Analyse and define a gf/arf group . */ 1736 static void define_gf_group(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame) 1737 { 1738 FIRSTPASS_STATS next_frame; 1739 FIRSTPASS_STATS *start_pos; 1740 int i; 1741 double r; 1742 double boost_score = 0.0; 1743 double old_boost_score = 0.0; 1744 double gf_group_err = 0.0; 1745 double gf_first_frame_err = 0.0; 1746 double mod_frame_err = 0.0; 1747 1748 double mv_ratio_accumulator = 0.0; 1749 double decay_accumulator = 1.0; 1750 1751 double loop_decay_rate = 1.00; /* Starting decay rate */ 1752 1753 double this_frame_mv_in_out = 0.0; 1754 double mv_in_out_accumulator = 0.0; 1755 double abs_mv_in_out_accumulator = 0.0; 1756 double mod_err_per_mb_accumulator = 0.0; 1757 1758 int max_bits = frame_max_bits(cpi); /* Max for a single frame */ 1759 1760 unsigned int allow_alt_ref = 1761 cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames; 1762 1763 int alt_boost = 0; 1764 int f_boost = 0; 1765 int b_boost = 0; 1766 int flash_detected; 1767 1768 cpi->twopass.gf_group_bits = 0; 1769 cpi->twopass.gf_decay_rate = 0; 1770 1771 vp8_clear_system_state(); 1772 1773 start_pos = cpi->twopass.stats_in; 1774 1775 vpx_memset(&next_frame, 0, sizeof(next_frame)); /* assure clean */ 1776 1777 /* Load stats for the current frame. */ 1778 mod_frame_err = calculate_modified_err(cpi, this_frame); 1779 1780 /* Note the error of the frame at the start of the group (this will be 1781 * the GF frame error if we code a normal gf 1782 */ 1783 gf_first_frame_err = mod_frame_err; 1784 1785 /* Special treatment if the current frame is a key frame (which is also 1786 * a gf). If it is then its error score (and hence bit allocation) need 1787 * to be subtracted out from the calculation for the GF group 1788 */ 1789 if (cpi->common.frame_type == KEY_FRAME) 1790 gf_group_err -= gf_first_frame_err; 1791 1792 /* Scan forward to try and work out how many frames the next gf group 1793 * should contain and what level of boost is appropriate for the GF 1794 * or ARF that will be coded with the group 1795 */ 1796 i = 0; 1797 1798 while (((i < cpi->twopass.static_scene_max_gf_interval) || 1799 ((cpi->twopass.frames_to_key - i) < MIN_GF_INTERVAL)) && 1800 (i < cpi->twopass.frames_to_key)) 1801 { 1802 i++; 1803 1804 /* Accumulate error score of frames in this gf group */ 1805 mod_frame_err = calculate_modified_err(cpi, this_frame); 1806 1807 gf_group_err += mod_frame_err; 1808 1809 mod_err_per_mb_accumulator += 1810 mod_frame_err / DOUBLE_DIVIDE_CHECK((double)cpi->common.MBs); 1811 1812 if (EOF == input_stats(cpi, &next_frame)) 1813 break; 1814 1815 /* Test for the case where there is a brief flash but the prediction 1816 * quality back to an earlier frame is then restored. 1817 */ 1818 flash_detected = detect_flash(cpi, 0); 1819 1820 /* Update the motion related elements to the boost calculation */ 1821 accumulate_frame_motion_stats( cpi, &next_frame, 1822 &this_frame_mv_in_out, &mv_in_out_accumulator, 1823 &abs_mv_in_out_accumulator, &mv_ratio_accumulator ); 1824 1825 /* Calculate a baseline boost number for this frame */ 1826 r = calc_frame_boost( cpi, &next_frame, this_frame_mv_in_out ); 1827 1828 /* Cumulative effect of prediction quality decay */ 1829 if ( !flash_detected ) 1830 { 1831 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame); 1832 decay_accumulator = decay_accumulator * loop_decay_rate; 1833 decay_accumulator = 1834 decay_accumulator < 0.1 ? 0.1 : decay_accumulator; 1835 } 1836 boost_score += (decay_accumulator * r); 1837 1838 /* Break clause to detect very still sections after motion 1839 * For example a staic image after a fade or other transition. 1840 */ 1841 if ( detect_transition_to_still( cpi, i, 5, 1842 loop_decay_rate, 1843 decay_accumulator ) ) 1844 { 1845 allow_alt_ref = 0; 1846 boost_score = old_boost_score; 1847 break; 1848 } 1849 1850 /* Break out conditions. */ 1851 if ( 1852 /* Break at cpi->max_gf_interval unless almost totally static */ 1853 (i >= cpi->max_gf_interval && (decay_accumulator < 0.995)) || 1854 ( 1855 /* Dont break out with a very short interval */ 1856 (i > MIN_GF_INTERVAL) && 1857 /* Dont break out very close to a key frame */ 1858 ((cpi->twopass.frames_to_key - i) >= MIN_GF_INTERVAL) && 1859 ((boost_score > 20.0) || (next_frame.pcnt_inter < 0.75)) && 1860 (!flash_detected) && 1861 ((mv_ratio_accumulator > 100.0) || 1862 (abs_mv_in_out_accumulator > 3.0) || 1863 (mv_in_out_accumulator < -2.0) || 1864 ((boost_score - old_boost_score) < 2.0)) 1865 ) ) 1866 { 1867 boost_score = old_boost_score; 1868 break; 1869 } 1870 1871 vpx_memcpy(this_frame, &next_frame, sizeof(*this_frame)); 1872 1873 old_boost_score = boost_score; 1874 } 1875 1876 cpi->twopass.gf_decay_rate = 1877 (i > 0) ? (int)(100.0 * (1.0 - decay_accumulator)) / i : 0; 1878 1879 /* When using CBR apply additional buffer related upper limits */ 1880 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 1881 { 1882 double max_boost; 1883 1884 /* For cbr apply buffer related limits */ 1885 if (cpi->drop_frames_allowed) 1886 { 1887 int64_t df_buffer_level = cpi->oxcf.drop_frames_water_mark * 1888 (cpi->oxcf.optimal_buffer_level / 100); 1889 1890 if (cpi->buffer_level > df_buffer_level) 1891 max_boost = ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth); 1892 else 1893 max_boost = 0.0; 1894 } 1895 else if (cpi->buffer_level > 0) 1896 { 1897 max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth); 1898 } 1899 else 1900 { 1901 max_boost = 0.0; 1902 } 1903 1904 if (boost_score > max_boost) 1905 boost_score = max_boost; 1906 } 1907 1908 /* Dont allow conventional gf too near the next kf */ 1909 if ((cpi->twopass.frames_to_key - i) < MIN_GF_INTERVAL) 1910 { 1911 while (i < cpi->twopass.frames_to_key) 1912 { 1913 i++; 1914 1915 if (EOF == input_stats(cpi, this_frame)) 1916 break; 1917 1918 if (i < cpi->twopass.frames_to_key) 1919 { 1920 mod_frame_err = calculate_modified_err(cpi, this_frame); 1921 gf_group_err += mod_frame_err; 1922 } 1923 } 1924 } 1925 1926 cpi->gfu_boost = (int)(boost_score * 100.0) >> 4; 1927 1928 #if NEW_BOOST 1929 /* Alterrnative boost calculation for alt ref */ 1930 alt_boost = calc_arf_boost( cpi, 0, (i-1), (i-1), &f_boost, &b_boost ); 1931 #endif 1932 1933 /* Should we use the alternate refernce frame */ 1934 if (allow_alt_ref && 1935 (i >= MIN_GF_INTERVAL) && 1936 /* dont use ARF very near next kf */ 1937 (i <= (cpi->twopass.frames_to_key - MIN_GF_INTERVAL)) && 1938 #if NEW_BOOST 1939 ((next_frame.pcnt_inter > 0.75) || 1940 (next_frame.pcnt_second_ref > 0.5)) && 1941 ((mv_in_out_accumulator / (double)i > -0.2) || 1942 (mv_in_out_accumulator > -2.0)) && 1943 (b_boost > 100) && 1944 (f_boost > 100) ) 1945 #else 1946 (next_frame.pcnt_inter > 0.75) && 1947 ((mv_in_out_accumulator / (double)i > -0.2) || 1948 (mv_in_out_accumulator > -2.0)) && 1949 (cpi->gfu_boost > 100) && 1950 (cpi->twopass.gf_decay_rate <= 1951 (ARF_DECAY_THRESH + (cpi->gfu_boost / 200))) ) 1952 #endif 1953 { 1954 int Boost; 1955 int allocation_chunks; 1956 int Q = (cpi->oxcf.fixed_q < 0) 1957 ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q; 1958 int tmp_q; 1959 int arf_frame_bits = 0; 1960 int group_bits; 1961 1962 #if NEW_BOOST 1963 cpi->gfu_boost = alt_boost; 1964 #endif 1965 1966 /* Estimate the bits to be allocated to the group as a whole */ 1967 if ((cpi->twopass.kf_group_bits > 0) && 1968 (cpi->twopass.kf_group_error_left > 0)) 1969 { 1970 group_bits = (int)((double)cpi->twopass.kf_group_bits * 1971 (gf_group_err / (double)cpi->twopass.kf_group_error_left)); 1972 } 1973 else 1974 group_bits = 0; 1975 1976 /* Boost for arf frame */ 1977 #if NEW_BOOST 1978 Boost = (alt_boost * GFQ_ADJUSTMENT) / 100; 1979 #else 1980 Boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100); 1981 #endif 1982 Boost += (i * 50); 1983 1984 /* Set max and minimum boost and hence minimum allocation */ 1985 if (Boost > ((cpi->baseline_gf_interval + 1) * 200)) 1986 Boost = ((cpi->baseline_gf_interval + 1) * 200); 1987 else if (Boost < 125) 1988 Boost = 125; 1989 1990 allocation_chunks = (i * 100) + Boost; 1991 1992 /* Normalize Altboost and allocations chunck down to prevent overflow */ 1993 while (Boost > 1000) 1994 { 1995 Boost /= 2; 1996 allocation_chunks /= 2; 1997 } 1998 1999 /* Calculate the number of bits to be spent on the arf based on the 2000 * boost number 2001 */ 2002 arf_frame_bits = (int)((double)Boost * (group_bits / 2003 (double)allocation_chunks)); 2004 2005 /* Estimate if there are enough bits available to make worthwhile use 2006 * of an arf. 2007 */ 2008 tmp_q = estimate_q(cpi, mod_frame_err, (int)arf_frame_bits); 2009 2010 /* Only use an arf if it is likely we will be able to code 2011 * it at a lower Q than the surrounding frames. 2012 */ 2013 if (tmp_q < cpi->worst_quality) 2014 { 2015 int half_gf_int; 2016 int frames_after_arf; 2017 int frames_bwd = cpi->oxcf.arnr_max_frames - 1; 2018 int frames_fwd = cpi->oxcf.arnr_max_frames - 1; 2019 2020 cpi->source_alt_ref_pending = 1; 2021 2022 /* 2023 * For alt ref frames the error score for the end frame of the 2024 * group (the alt ref frame) should not contribute to the group 2025 * total and hence the number of bit allocated to the group. 2026 * Rather it forms part of the next group (it is the GF at the 2027 * start of the next group) 2028 * gf_group_err -= mod_frame_err; 2029 * 2030 * For alt ref frames alt ref frame is technically part of the 2031 * GF frame for the next group but we always base the error 2032 * calculation and bit allocation on the current group of frames. 2033 * 2034 * Set the interval till the next gf or arf. 2035 * For ARFs this is the number of frames to be coded before the 2036 * future frame that is coded as an ARF. 2037 * The future frame itself is part of the next group 2038 */ 2039 cpi->baseline_gf_interval = i; 2040 2041 /* 2042 * Define the arnr filter width for this group of frames: 2043 * We only filter frames that lie within a distance of half 2044 * the GF interval from the ARF frame. We also have to trap 2045 * cases where the filter extends beyond the end of clip. 2046 * Note: this_frame->frame has been updated in the loop 2047 * so it now points at the ARF frame. 2048 */ 2049 half_gf_int = cpi->baseline_gf_interval >> 1; 2050 frames_after_arf = (int)(cpi->twopass.total_stats.count - 2051 this_frame->frame - 1); 2052 2053 switch (cpi->oxcf.arnr_type) 2054 { 2055 case 1: /* Backward filter */ 2056 frames_fwd = 0; 2057 if (frames_bwd > half_gf_int) 2058 frames_bwd = half_gf_int; 2059 break; 2060 2061 case 2: /* Forward filter */ 2062 if (frames_fwd > half_gf_int) 2063 frames_fwd = half_gf_int; 2064 if (frames_fwd > frames_after_arf) 2065 frames_fwd = frames_after_arf; 2066 frames_bwd = 0; 2067 break; 2068 2069 case 3: /* Centered filter */ 2070 default: 2071 frames_fwd >>= 1; 2072 if (frames_fwd > frames_after_arf) 2073 frames_fwd = frames_after_arf; 2074 if (frames_fwd > half_gf_int) 2075 frames_fwd = half_gf_int; 2076 2077 frames_bwd = frames_fwd; 2078 2079 /* For even length filter there is one more frame backward 2080 * than forward: e.g. len=6 ==> bbbAff, len=7 ==> bbbAfff. 2081 */ 2082 if (frames_bwd < half_gf_int) 2083 frames_bwd += (cpi->oxcf.arnr_max_frames+1) & 0x1; 2084 break; 2085 } 2086 2087 cpi->active_arnr_frames = frames_bwd + 1 + frames_fwd; 2088 } 2089 else 2090 { 2091 cpi->source_alt_ref_pending = 0; 2092 cpi->baseline_gf_interval = i; 2093 } 2094 } 2095 else 2096 { 2097 cpi->source_alt_ref_pending = 0; 2098 cpi->baseline_gf_interval = i; 2099 } 2100 2101 /* 2102 * Now decide how many bits should be allocated to the GF group as a 2103 * proportion of those remaining in the kf group. 2104 * The final key frame group in the clip is treated as a special case 2105 * where cpi->twopass.kf_group_bits is tied to cpi->twopass.bits_left. 2106 * This is also important for short clips where there may only be one 2107 * key frame. 2108 */ 2109 if (cpi->twopass.frames_to_key >= (int)(cpi->twopass.total_stats.count - 2110 cpi->common.current_video_frame)) 2111 { 2112 cpi->twopass.kf_group_bits = 2113 (cpi->twopass.bits_left > 0) ? cpi->twopass.bits_left : 0; 2114 } 2115 2116 /* Calculate the bits to be allocated to the group as a whole */ 2117 if ((cpi->twopass.kf_group_bits > 0) && 2118 (cpi->twopass.kf_group_error_left > 0)) 2119 { 2120 cpi->twopass.gf_group_bits = 2121 (int64_t)(cpi->twopass.kf_group_bits * 2122 (gf_group_err / cpi->twopass.kf_group_error_left)); 2123 } 2124 else 2125 cpi->twopass.gf_group_bits = 0; 2126 2127 cpi->twopass.gf_group_bits = 2128 (cpi->twopass.gf_group_bits < 0) 2129 ? 0 2130 : (cpi->twopass.gf_group_bits > cpi->twopass.kf_group_bits) 2131 ? cpi->twopass.kf_group_bits : cpi->twopass.gf_group_bits; 2132 2133 /* Clip cpi->twopass.gf_group_bits based on user supplied data rate 2134 * variability limit (cpi->oxcf.two_pass_vbrmax_section) 2135 */ 2136 if (cpi->twopass.gf_group_bits > 2137 (int64_t)max_bits * cpi->baseline_gf_interval) 2138 cpi->twopass.gf_group_bits = 2139 (int64_t)max_bits * cpi->baseline_gf_interval; 2140 2141 /* Reset the file position */ 2142 reset_fpf_position(cpi, start_pos); 2143 2144 /* Update the record of error used so far (only done once per gf group) */ 2145 cpi->twopass.modified_error_used += gf_group_err; 2146 2147 /* Assign bits to the arf or gf. */ 2148 for (i = 0; i <= (cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME); i++) { 2149 int Boost; 2150 int allocation_chunks; 2151 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q; 2152 int gf_bits; 2153 2154 /* For ARF frames */ 2155 if (cpi->source_alt_ref_pending && i == 0) 2156 { 2157 #if NEW_BOOST 2158 Boost = (alt_boost * GFQ_ADJUSTMENT) / 100; 2159 #else 2160 Boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100); 2161 #endif 2162 Boost += (cpi->baseline_gf_interval * 50); 2163 2164 /* Set max and minimum boost and hence minimum allocation */ 2165 if (Boost > ((cpi->baseline_gf_interval + 1) * 200)) 2166 Boost = ((cpi->baseline_gf_interval + 1) * 200); 2167 else if (Boost < 125) 2168 Boost = 125; 2169 2170 allocation_chunks = 2171 ((cpi->baseline_gf_interval + 1) * 100) + Boost; 2172 } 2173 /* Else for standard golden frames */ 2174 else 2175 { 2176 /* boost based on inter / intra ratio of subsequent frames */ 2177 Boost = (cpi->gfu_boost * GFQ_ADJUSTMENT) / 100; 2178 2179 /* Set max and minimum boost and hence minimum allocation */ 2180 if (Boost > (cpi->baseline_gf_interval * 150)) 2181 Boost = (cpi->baseline_gf_interval * 150); 2182 else if (Boost < 125) 2183 Boost = 125; 2184 2185 allocation_chunks = 2186 (cpi->baseline_gf_interval * 100) + (Boost - 100); 2187 } 2188 2189 /* Normalize Altboost and allocations chunck down to prevent overflow */ 2190 while (Boost > 1000) 2191 { 2192 Boost /= 2; 2193 allocation_chunks /= 2; 2194 } 2195 2196 /* Calculate the number of bits to be spent on the gf or arf based on 2197 * the boost number 2198 */ 2199 gf_bits = (int)((double)Boost * 2200 (cpi->twopass.gf_group_bits / 2201 (double)allocation_chunks)); 2202 2203 /* If the frame that is to be boosted is simpler than the average for 2204 * the gf/arf group then use an alternative calculation 2205 * based on the error score of the frame itself 2206 */ 2207 if (mod_frame_err < gf_group_err / (double)cpi->baseline_gf_interval) 2208 { 2209 double alt_gf_grp_bits; 2210 int alt_gf_bits; 2211 2212 alt_gf_grp_bits = 2213 (double)cpi->twopass.kf_group_bits * 2214 (mod_frame_err * (double)cpi->baseline_gf_interval) / 2215 DOUBLE_DIVIDE_CHECK((double)cpi->twopass.kf_group_error_left); 2216 2217 alt_gf_bits = (int)((double)Boost * (alt_gf_grp_bits / 2218 (double)allocation_chunks)); 2219 2220 if (gf_bits > alt_gf_bits) 2221 { 2222 gf_bits = alt_gf_bits; 2223 } 2224 } 2225 /* Else if it is harder than other frames in the group make sure it at 2226 * least receives an allocation in keeping with its relative error 2227 * score, otherwise it may be worse off than an "un-boosted" frame 2228 */ 2229 else 2230 { 2231 int alt_gf_bits = 2232 (int)((double)cpi->twopass.kf_group_bits * 2233 mod_frame_err / 2234 DOUBLE_DIVIDE_CHECK((double)cpi->twopass.kf_group_error_left)); 2235 2236 if (alt_gf_bits > gf_bits) 2237 { 2238 gf_bits = alt_gf_bits; 2239 } 2240 } 2241 2242 /* Apply an additional limit for CBR */ 2243 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 2244 { 2245 if (cpi->twopass.gf_bits > (int)(cpi->buffer_level >> 1)) 2246 cpi->twopass.gf_bits = (int)(cpi->buffer_level >> 1); 2247 } 2248 2249 /* Dont allow a negative value for gf_bits */ 2250 if (gf_bits < 0) 2251 gf_bits = 0; 2252 2253 /* Add in minimum for a frame */ 2254 gf_bits += cpi->min_frame_bandwidth; 2255 2256 if (i == 0) 2257 { 2258 cpi->twopass.gf_bits = gf_bits; 2259 } 2260 if (i == 1 || (!cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME))) 2261 { 2262 /* Per frame bit target for this frame */ 2263 cpi->per_frame_bandwidth = gf_bits; 2264 } 2265 } 2266 2267 { 2268 /* Adjust KF group bits and error remainin */ 2269 cpi->twopass.kf_group_error_left -= (int64_t)gf_group_err; 2270 cpi->twopass.kf_group_bits -= cpi->twopass.gf_group_bits; 2271 2272 if (cpi->twopass.kf_group_bits < 0) 2273 cpi->twopass.kf_group_bits = 0; 2274 2275 /* Note the error score left in the remaining frames of the group. 2276 * For normal GFs we want to remove the error score for the first 2277 * frame of the group (except in Key frame case where this has 2278 * already happened) 2279 */ 2280 if (!cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME) 2281 cpi->twopass.gf_group_error_left = (int)(gf_group_err - 2282 gf_first_frame_err); 2283 else 2284 cpi->twopass.gf_group_error_left = (int) gf_group_err; 2285 2286 cpi->twopass.gf_group_bits -= cpi->twopass.gf_bits - cpi->min_frame_bandwidth; 2287 2288 if (cpi->twopass.gf_group_bits < 0) 2289 cpi->twopass.gf_group_bits = 0; 2290 2291 /* This condition could fail if there are two kfs very close together 2292 * despite (MIN_GF_INTERVAL) and would cause a devide by 0 in the 2293 * calculation of cpi->twopass.alt_extra_bits. 2294 */ 2295 if ( cpi->baseline_gf_interval >= 3 ) 2296 { 2297 #if NEW_BOOST 2298 int boost = (cpi->source_alt_ref_pending) 2299 ? b_boost : cpi->gfu_boost; 2300 #else 2301 int boost = cpi->gfu_boost; 2302 #endif 2303 if ( boost >= 150 ) 2304 { 2305 int pct_extra; 2306 2307 pct_extra = (boost - 100) / 50; 2308 pct_extra = (pct_extra > 20) ? 20 : pct_extra; 2309 2310 cpi->twopass.alt_extra_bits = 2311 (cpi->twopass.gf_group_bits * pct_extra) / 100; 2312 cpi->twopass.gf_group_bits -= cpi->twopass.alt_extra_bits; 2313 cpi->twopass.alt_extra_bits /= 2314 ((cpi->baseline_gf_interval-1)>>1); 2315 } 2316 else 2317 cpi->twopass.alt_extra_bits = 0; 2318 } 2319 else 2320 cpi->twopass.alt_extra_bits = 0; 2321 } 2322 2323 /* Adjustments based on a measure of complexity of the section */ 2324 if (cpi->common.frame_type != KEY_FRAME) 2325 { 2326 FIRSTPASS_STATS sectionstats; 2327 double Ratio; 2328 2329 zero_stats(§ionstats); 2330 reset_fpf_position(cpi, start_pos); 2331 2332 for (i = 0 ; i < cpi->baseline_gf_interval ; i++) 2333 { 2334 input_stats(cpi, &next_frame); 2335 accumulate_stats(§ionstats, &next_frame); 2336 } 2337 2338 avg_stats(§ionstats); 2339 2340 cpi->twopass.section_intra_rating = (unsigned int) 2341 (sectionstats.intra_error / 2342 DOUBLE_DIVIDE_CHECK(sectionstats.coded_error)); 2343 2344 Ratio = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error); 2345 cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025); 2346 2347 if (cpi->twopass.section_max_qfactor < 0.80) 2348 cpi->twopass.section_max_qfactor = 0.80; 2349 2350 reset_fpf_position(cpi, start_pos); 2351 } 2352 } 2353 2354 /* Allocate bits to a normal frame that is neither a gf an arf or a key frame. */ 2355 static void assign_std_frame_bits(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame) 2356 { 2357 int target_frame_size; 2358 2359 double modified_err; 2360 double err_fraction; 2361 2362 int max_bits = frame_max_bits(cpi); /* Max for a single frame */ 2363 2364 /* Calculate modified prediction error used in bit allocation */ 2365 modified_err = calculate_modified_err(cpi, this_frame); 2366 2367 /* What portion of the remaining GF group error is used by this frame */ 2368 if (cpi->twopass.gf_group_error_left > 0) 2369 err_fraction = modified_err / cpi->twopass.gf_group_error_left; 2370 else 2371 err_fraction = 0.0; 2372 2373 /* How many of those bits available for allocation should we give it? */ 2374 target_frame_size = (int)((double)cpi->twopass.gf_group_bits * err_fraction); 2375 2376 /* Clip to target size to 0 - max_bits (or cpi->twopass.gf_group_bits) 2377 * at the top end. 2378 */ 2379 if (target_frame_size < 0) 2380 target_frame_size = 0; 2381 else 2382 { 2383 if (target_frame_size > max_bits) 2384 target_frame_size = max_bits; 2385 2386 if (target_frame_size > cpi->twopass.gf_group_bits) 2387 target_frame_size = cpi->twopass.gf_group_bits; 2388 } 2389 2390 /* Adjust error and bits remaining */ 2391 cpi->twopass.gf_group_error_left -= (int)modified_err; 2392 cpi->twopass.gf_group_bits -= target_frame_size; 2393 2394 if (cpi->twopass.gf_group_bits < 0) 2395 cpi->twopass.gf_group_bits = 0; 2396 2397 /* Add in the minimum number of bits that is set aside for every frame. */ 2398 target_frame_size += cpi->min_frame_bandwidth; 2399 2400 /* Every other frame gets a few extra bits */ 2401 if ( (cpi->frames_since_golden & 0x01) && 2402 (cpi->frames_till_gf_update_due > 0) ) 2403 { 2404 target_frame_size += cpi->twopass.alt_extra_bits; 2405 } 2406 2407 /* Per frame bit target for this frame */ 2408 cpi->per_frame_bandwidth = target_frame_size; 2409 } 2410 2411 void vp8_second_pass(VP8_COMP *cpi) 2412 { 2413 int tmp_q; 2414 int frames_left = (int)(cpi->twopass.total_stats.count - cpi->common.current_video_frame); 2415 2416 FIRSTPASS_STATS this_frame = {0}; 2417 FIRSTPASS_STATS this_frame_copy; 2418 2419 double this_frame_intra_error; 2420 double this_frame_coded_error; 2421 2422 int overhead_bits; 2423 2424 if (!cpi->twopass.stats_in) 2425 { 2426 return ; 2427 } 2428 2429 vp8_clear_system_state(); 2430 2431 if (EOF == input_stats(cpi, &this_frame)) 2432 return; 2433 2434 this_frame_intra_error = this_frame.intra_error; 2435 this_frame_coded_error = this_frame.coded_error; 2436 2437 /* keyframe and section processing ! */ 2438 if (cpi->twopass.frames_to_key == 0) 2439 { 2440 /* Define next KF group and assign bits to it */ 2441 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame)); 2442 find_next_key_frame(cpi, &this_frame_copy); 2443 2444 /* Special case: Error error_resilient_mode mode does not make much 2445 * sense for two pass but with its current meaning but this code is 2446 * designed to stop outlandish behaviour if someone does set it when 2447 * using two pass. It effectively disables GF groups. This is 2448 * temporary code till we decide what should really happen in this 2449 * case. 2450 */ 2451 if (cpi->oxcf.error_resilient_mode) 2452 { 2453 cpi->twopass.gf_group_bits = cpi->twopass.kf_group_bits; 2454 cpi->twopass.gf_group_error_left = 2455 (int)cpi->twopass.kf_group_error_left; 2456 cpi->baseline_gf_interval = cpi->twopass.frames_to_key; 2457 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval; 2458 cpi->source_alt_ref_pending = 0; 2459 } 2460 2461 } 2462 2463 /* Is this a GF / ARF (Note that a KF is always also a GF) */ 2464 if (cpi->frames_till_gf_update_due == 0) 2465 { 2466 /* Define next gf group and assign bits to it */ 2467 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame)); 2468 define_gf_group(cpi, &this_frame_copy); 2469 2470 /* If we are going to code an altref frame at the end of the group 2471 * and the current frame is not a key frame.... If the previous 2472 * group used an arf this frame has already benefited from that arf 2473 * boost and it should not be given extra bits If the previous 2474 * group was NOT coded using arf we may want to apply some boost to 2475 * this GF as well 2476 */ 2477 if (cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME)) 2478 { 2479 /* Assign a standard frames worth of bits from those allocated 2480 * to the GF group 2481 */ 2482 int bak = cpi->per_frame_bandwidth; 2483 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame)); 2484 assign_std_frame_bits(cpi, &this_frame_copy); 2485 cpi->per_frame_bandwidth = bak; 2486 } 2487 } 2488 2489 /* Otherwise this is an ordinary frame */ 2490 else 2491 { 2492 /* Special case: Error error_resilient_mode mode does not make much 2493 * sense for two pass but with its current meaning but this code is 2494 * designed to stop outlandish behaviour if someone does set it 2495 * when using two pass. It effectively disables GF groups. This is 2496 * temporary code till we decide what should really happen in this 2497 * case. 2498 */ 2499 if (cpi->oxcf.error_resilient_mode) 2500 { 2501 cpi->frames_till_gf_update_due = cpi->twopass.frames_to_key; 2502 2503 if (cpi->common.frame_type != KEY_FRAME) 2504 { 2505 /* Assign bits from those allocated to the GF group */ 2506 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame)); 2507 assign_std_frame_bits(cpi, &this_frame_copy); 2508 } 2509 } 2510 else 2511 { 2512 /* Assign bits from those allocated to the GF group */ 2513 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame)); 2514 assign_std_frame_bits(cpi, &this_frame_copy); 2515 } 2516 } 2517 2518 /* Keep a globally available copy of this and the next frame's iiratio. */ 2519 cpi->twopass.this_iiratio = (unsigned int)(this_frame_intra_error / 2520 DOUBLE_DIVIDE_CHECK(this_frame_coded_error)); 2521 { 2522 FIRSTPASS_STATS next_frame; 2523 if ( lookup_next_frame_stats(cpi, &next_frame) != EOF ) 2524 { 2525 cpi->twopass.next_iiratio = (unsigned int)(next_frame.intra_error / 2526 DOUBLE_DIVIDE_CHECK(next_frame.coded_error)); 2527 } 2528 } 2529 2530 /* Set nominal per second bandwidth for this frame */ 2531 cpi->target_bandwidth = (int) 2532 (cpi->per_frame_bandwidth * cpi->output_framerate); 2533 if (cpi->target_bandwidth < 0) 2534 cpi->target_bandwidth = 0; 2535 2536 2537 /* Account for mv, mode and other overheads. */ 2538 overhead_bits = (int)estimate_modemvcost( 2539 cpi, &cpi->twopass.total_left_stats ); 2540 2541 /* Special case code for first frame. */ 2542 if (cpi->common.current_video_frame == 0) 2543 { 2544 cpi->twopass.est_max_qcorrection_factor = 1.0; 2545 2546 /* Set a cq_level in constrained quality mode. */ 2547 if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY ) 2548 { 2549 int est_cq; 2550 2551 est_cq = 2552 estimate_cq( cpi, 2553 &cpi->twopass.total_left_stats, 2554 (int)(cpi->twopass.bits_left / frames_left), 2555 overhead_bits ); 2556 2557 cpi->cq_target_quality = cpi->oxcf.cq_level; 2558 if ( est_cq > cpi->cq_target_quality ) 2559 cpi->cq_target_quality = est_cq; 2560 } 2561 2562 /* guess at maxq needed in 2nd pass */ 2563 cpi->twopass.maxq_max_limit = cpi->worst_quality; 2564 cpi->twopass.maxq_min_limit = cpi->best_quality; 2565 2566 tmp_q = estimate_max_q( 2567 cpi, 2568 &cpi->twopass.total_left_stats, 2569 (int)(cpi->twopass.bits_left / frames_left), 2570 overhead_bits ); 2571 2572 /* Limit the maxq value returned subsequently. 2573 * This increases the risk of overspend or underspend if the initial 2574 * estimate for the clip is bad, but helps prevent excessive 2575 * variation in Q, especially near the end of a clip 2576 * where for example a small overspend may cause Q to crash 2577 */ 2578 cpi->twopass.maxq_max_limit = ((tmp_q + 32) < cpi->worst_quality) 2579 ? (tmp_q + 32) : cpi->worst_quality; 2580 cpi->twopass.maxq_min_limit = ((tmp_q - 32) > cpi->best_quality) 2581 ? (tmp_q - 32) : cpi->best_quality; 2582 2583 cpi->active_worst_quality = tmp_q; 2584 cpi->ni_av_qi = tmp_q; 2585 } 2586 2587 /* The last few frames of a clip almost always have to few or too many 2588 * bits and for the sake of over exact rate control we dont want to make 2589 * radical adjustments to the allowed quantizer range just to use up a 2590 * few surplus bits or get beneath the target rate. 2591 */ 2592 else if ( (cpi->common.current_video_frame < 2593 (((unsigned int)cpi->twopass.total_stats.count * 255)>>8)) && 2594 ((cpi->common.current_video_frame + cpi->baseline_gf_interval) < 2595 (unsigned int)cpi->twopass.total_stats.count) ) 2596 { 2597 if (frames_left < 1) 2598 frames_left = 1; 2599 2600 tmp_q = estimate_max_q( 2601 cpi, 2602 &cpi->twopass.total_left_stats, 2603 (int)(cpi->twopass.bits_left / frames_left), 2604 overhead_bits ); 2605 2606 /* Move active_worst_quality but in a damped way */ 2607 if (tmp_q > cpi->active_worst_quality) 2608 cpi->active_worst_quality ++; 2609 else if (tmp_q < cpi->active_worst_quality) 2610 cpi->active_worst_quality --; 2611 2612 cpi->active_worst_quality = 2613 ((cpi->active_worst_quality * 3) + tmp_q + 2) / 4; 2614 } 2615 2616 cpi->twopass.frames_to_key --; 2617 2618 /* Update the total stats remaining sturcture */ 2619 subtract_stats(&cpi->twopass.total_left_stats, &this_frame ); 2620 } 2621 2622 2623 static int test_candidate_kf(VP8_COMP *cpi, FIRSTPASS_STATS *last_frame, FIRSTPASS_STATS *this_frame, FIRSTPASS_STATS *next_frame) 2624 { 2625 int is_viable_kf = 0; 2626 2627 /* Does the frame satisfy the primary criteria of a key frame 2628 * If so, then examine how well it predicts subsequent frames 2629 */ 2630 if ((this_frame->pcnt_second_ref < 0.10) && 2631 (next_frame->pcnt_second_ref < 0.10) && 2632 ((this_frame->pcnt_inter < 0.05) || 2633 ( 2634 ((this_frame->pcnt_inter - this_frame->pcnt_neutral) < .25) && 2635 ((this_frame->intra_error / DOUBLE_DIVIDE_CHECK(this_frame->coded_error)) < 2.5) && 2636 ((fabs(last_frame->coded_error - this_frame->coded_error) / DOUBLE_DIVIDE_CHECK(this_frame->coded_error) > .40) || 2637 (fabs(last_frame->intra_error - this_frame->intra_error) / DOUBLE_DIVIDE_CHECK(this_frame->intra_error) > .40) || 2638 ((next_frame->intra_error / DOUBLE_DIVIDE_CHECK(next_frame->coded_error)) > 3.5) 2639 ) 2640 ) 2641 ) 2642 ) 2643 { 2644 int i; 2645 FIRSTPASS_STATS *start_pos; 2646 2647 FIRSTPASS_STATS local_next_frame; 2648 2649 double boost_score = 0.0; 2650 double old_boost_score = 0.0; 2651 double decay_accumulator = 1.0; 2652 double next_iiratio; 2653 2654 vpx_memcpy(&local_next_frame, next_frame, sizeof(*next_frame)); 2655 2656 /* Note the starting file position so we can reset to it */ 2657 start_pos = cpi->twopass.stats_in; 2658 2659 /* Examine how well the key frame predicts subsequent frames */ 2660 for (i = 0 ; i < 16; i++) 2661 { 2662 next_iiratio = (IIKFACTOR1 * local_next_frame.intra_error / DOUBLE_DIVIDE_CHECK(local_next_frame.coded_error)) ; 2663 2664 if (next_iiratio > RMAX) 2665 next_iiratio = RMAX; 2666 2667 /* Cumulative effect of decay in prediction quality */ 2668 if (local_next_frame.pcnt_inter > 0.85) 2669 decay_accumulator = decay_accumulator * local_next_frame.pcnt_inter; 2670 else 2671 decay_accumulator = decay_accumulator * ((0.85 + local_next_frame.pcnt_inter) / 2.0); 2672 2673 /* Keep a running total */ 2674 boost_score += (decay_accumulator * next_iiratio); 2675 2676 /* Test various breakout clauses */ 2677 if ((local_next_frame.pcnt_inter < 0.05) || 2678 (next_iiratio < 1.5) || 2679 (((local_next_frame.pcnt_inter - 2680 local_next_frame.pcnt_neutral) < 0.20) && 2681 (next_iiratio < 3.0)) || 2682 ((boost_score - old_boost_score) < 0.5) || 2683 (local_next_frame.intra_error < 200) 2684 ) 2685 { 2686 break; 2687 } 2688 2689 old_boost_score = boost_score; 2690 2691 /* Get the next frame details */ 2692 if (EOF == input_stats(cpi, &local_next_frame)) 2693 break; 2694 } 2695 2696 /* If there is tolerable prediction for at least the next 3 frames 2697 * then break out else discard this pottential key frame and move on 2698 */ 2699 if (boost_score > 5.0 && (i > 3)) 2700 is_viable_kf = 1; 2701 else 2702 { 2703 /* Reset the file position */ 2704 reset_fpf_position(cpi, start_pos); 2705 2706 is_viable_kf = 0; 2707 } 2708 } 2709 2710 return is_viable_kf; 2711 } 2712 static void find_next_key_frame(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame) 2713 { 2714 int i,j; 2715 FIRSTPASS_STATS last_frame; 2716 FIRSTPASS_STATS first_frame; 2717 FIRSTPASS_STATS next_frame; 2718 FIRSTPASS_STATS *start_position; 2719 2720 double decay_accumulator = 1.0; 2721 double boost_score = 0; 2722 double old_boost_score = 0.0; 2723 double loop_decay_rate; 2724 2725 double kf_mod_err = 0.0; 2726 double kf_group_err = 0.0; 2727 double kf_group_intra_err = 0.0; 2728 double kf_group_coded_err = 0.0; 2729 double recent_loop_decay[8] = {1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0}; 2730 2731 vpx_memset(&next_frame, 0, sizeof(next_frame)); 2732 2733 vp8_clear_system_state(); 2734 start_position = cpi->twopass.stats_in; 2735 2736 cpi->common.frame_type = KEY_FRAME; 2737 2738 /* is this a forced key frame by interval */ 2739 cpi->this_key_frame_forced = cpi->next_key_frame_forced; 2740 2741 /* Clear the alt ref active flag as this can never be active on a key 2742 * frame 2743 */ 2744 cpi->source_alt_ref_active = 0; 2745 2746 /* Kf is always a gf so clear frames till next gf counter */ 2747 cpi->frames_till_gf_update_due = 0; 2748 2749 cpi->twopass.frames_to_key = 1; 2750 2751 /* Take a copy of the initial frame details */ 2752 vpx_memcpy(&first_frame, this_frame, sizeof(*this_frame)); 2753 2754 cpi->twopass.kf_group_bits = 0; 2755 cpi->twopass.kf_group_error_left = 0; 2756 2757 kf_mod_err = calculate_modified_err(cpi, this_frame); 2758 2759 /* find the next keyframe */ 2760 i = 0; 2761 while (cpi->twopass.stats_in < cpi->twopass.stats_in_end) 2762 { 2763 /* Accumulate kf group error */ 2764 kf_group_err += calculate_modified_err(cpi, this_frame); 2765 2766 /* These figures keep intra and coded error counts for all frames 2767 * including key frames in the group. The effect of the key frame 2768 * itself can be subtracted out using the first_frame data 2769 * collected above 2770 */ 2771 kf_group_intra_err += this_frame->intra_error; 2772 kf_group_coded_err += this_frame->coded_error; 2773 2774 /* load a the next frame's stats */ 2775 vpx_memcpy(&last_frame, this_frame, sizeof(*this_frame)); 2776 input_stats(cpi, this_frame); 2777 2778 /* Provided that we are not at the end of the file... */ 2779 if (cpi->oxcf.auto_key 2780 && lookup_next_frame_stats(cpi, &next_frame) != EOF) 2781 { 2782 /* Normal scene cut check */ 2783 if ( ( i >= MIN_GF_INTERVAL ) && 2784 test_candidate_kf(cpi, &last_frame, this_frame, &next_frame) ) 2785 { 2786 break; 2787 } 2788 2789 /* How fast is prediction quality decaying */ 2790 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame); 2791 2792 /* We want to know something about the recent past... rather than 2793 * as used elsewhere where we are concened with decay in prediction 2794 * quality since the last GF or KF. 2795 */ 2796 recent_loop_decay[i%8] = loop_decay_rate; 2797 decay_accumulator = 1.0; 2798 for (j = 0; j < 8; j++) 2799 { 2800 decay_accumulator = decay_accumulator * recent_loop_decay[j]; 2801 } 2802 2803 /* Special check for transition or high motion followed by a 2804 * static scene. 2805 */ 2806 if ( detect_transition_to_still( cpi, i, 2807 (cpi->key_frame_frequency-i), 2808 loop_decay_rate, 2809 decay_accumulator ) ) 2810 { 2811 break; 2812 } 2813 2814 2815 /* Step on to the next frame */ 2816 cpi->twopass.frames_to_key ++; 2817 2818 /* If we don't have a real key frame within the next two 2819 * forcekeyframeevery intervals then break out of the loop. 2820 */ 2821 if (cpi->twopass.frames_to_key >= 2 *(int)cpi->key_frame_frequency) 2822 break; 2823 } else 2824 cpi->twopass.frames_to_key ++; 2825 2826 i++; 2827 } 2828 2829 /* If there is a max kf interval set by the user we must obey it. 2830 * We already breakout of the loop above at 2x max. 2831 * This code centers the extra kf if the actual natural 2832 * interval is between 1x and 2x 2833 */ 2834 if (cpi->oxcf.auto_key 2835 && cpi->twopass.frames_to_key > (int)cpi->key_frame_frequency ) 2836 { 2837 FIRSTPASS_STATS *current_pos = cpi->twopass.stats_in; 2838 FIRSTPASS_STATS tmp_frame; 2839 2840 cpi->twopass.frames_to_key /= 2; 2841 2842 /* Copy first frame details */ 2843 vpx_memcpy(&tmp_frame, &first_frame, sizeof(first_frame)); 2844 2845 /* Reset to the start of the group */ 2846 reset_fpf_position(cpi, start_position); 2847 2848 kf_group_err = 0; 2849 kf_group_intra_err = 0; 2850 kf_group_coded_err = 0; 2851 2852 /* Rescan to get the correct error data for the forced kf group */ 2853 for( i = 0; i < cpi->twopass.frames_to_key; i++ ) 2854 { 2855 /* Accumulate kf group errors */ 2856 kf_group_err += calculate_modified_err(cpi, &tmp_frame); 2857 kf_group_intra_err += tmp_frame.intra_error; 2858 kf_group_coded_err += tmp_frame.coded_error; 2859 2860 /* Load a the next frame's stats */ 2861 input_stats(cpi, &tmp_frame); 2862 } 2863 2864 /* Reset to the start of the group */ 2865 reset_fpf_position(cpi, current_pos); 2866 2867 cpi->next_key_frame_forced = 1; 2868 } 2869 else 2870 cpi->next_key_frame_forced = 0; 2871 2872 /* Special case for the last frame of the file */ 2873 if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end) 2874 { 2875 /* Accumulate kf group error */ 2876 kf_group_err += calculate_modified_err(cpi, this_frame); 2877 2878 /* These figures keep intra and coded error counts for all frames 2879 * including key frames in the group. The effect of the key frame 2880 * itself can be subtracted out using the first_frame data 2881 * collected above 2882 */ 2883 kf_group_intra_err += this_frame->intra_error; 2884 kf_group_coded_err += this_frame->coded_error; 2885 } 2886 2887 /* Calculate the number of bits that should be assigned to the kf group. */ 2888 if ((cpi->twopass.bits_left > 0) && (cpi->twopass.modified_error_left > 0.0)) 2889 { 2890 /* Max for a single normal frame (not key frame) */ 2891 int max_bits = frame_max_bits(cpi); 2892 2893 /* Maximum bits for the kf group */ 2894 int64_t max_grp_bits; 2895 2896 /* Default allocation based on bits left and relative 2897 * complexity of the section 2898 */ 2899 cpi->twopass.kf_group_bits = (int64_t)( cpi->twopass.bits_left * 2900 ( kf_group_err / 2901 cpi->twopass.modified_error_left )); 2902 2903 /* Clip based on maximum per frame rate defined by the user. */ 2904 max_grp_bits = (int64_t)max_bits * (int64_t)cpi->twopass.frames_to_key; 2905 if (cpi->twopass.kf_group_bits > max_grp_bits) 2906 cpi->twopass.kf_group_bits = max_grp_bits; 2907 2908 /* Additional special case for CBR if buffer is getting full. */ 2909 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 2910 { 2911 int64_t opt_buffer_lvl = cpi->oxcf.optimal_buffer_level; 2912 int64_t buffer_lvl = cpi->buffer_level; 2913 2914 /* If the buffer is near or above the optimal and this kf group is 2915 * not being allocated much then increase the allocation a bit. 2916 */ 2917 if (buffer_lvl >= opt_buffer_lvl) 2918 { 2919 int64_t high_water_mark = (opt_buffer_lvl + 2920 cpi->oxcf.maximum_buffer_size) >> 1; 2921 2922 int64_t av_group_bits; 2923 2924 /* Av bits per frame * number of frames */ 2925 av_group_bits = (int64_t)cpi->av_per_frame_bandwidth * 2926 (int64_t)cpi->twopass.frames_to_key; 2927 2928 /* We are at or above the maximum. */ 2929 if (cpi->buffer_level >= high_water_mark) 2930 { 2931 int64_t min_group_bits; 2932 2933 min_group_bits = av_group_bits + 2934 (int64_t)(buffer_lvl - 2935 high_water_mark); 2936 2937 if (cpi->twopass.kf_group_bits < min_group_bits) 2938 cpi->twopass.kf_group_bits = min_group_bits; 2939 } 2940 /* We are above optimal but below the maximum */ 2941 else if (cpi->twopass.kf_group_bits < av_group_bits) 2942 { 2943 int64_t bits_below_av = av_group_bits - 2944 cpi->twopass.kf_group_bits; 2945 2946 cpi->twopass.kf_group_bits += 2947 (int64_t)((double)bits_below_av * 2948 (double)(buffer_lvl - opt_buffer_lvl) / 2949 (double)(high_water_mark - opt_buffer_lvl)); 2950 } 2951 } 2952 } 2953 } 2954 else 2955 cpi->twopass.kf_group_bits = 0; 2956 2957 /* Reset the first pass file position */ 2958 reset_fpf_position(cpi, start_position); 2959 2960 /* determine how big to make this keyframe based on how well the 2961 * subsequent frames use inter blocks 2962 */ 2963 decay_accumulator = 1.0; 2964 boost_score = 0.0; 2965 loop_decay_rate = 1.00; /* Starting decay rate */ 2966 2967 for (i = 0 ; i < cpi->twopass.frames_to_key ; i++) 2968 { 2969 double r; 2970 2971 if (EOF == input_stats(cpi, &next_frame)) 2972 break; 2973 2974 if (next_frame.intra_error > cpi->twopass.kf_intra_err_min) 2975 r = (IIKFACTOR2 * next_frame.intra_error / 2976 DOUBLE_DIVIDE_CHECK(next_frame.coded_error)); 2977 else 2978 r = (IIKFACTOR2 * cpi->twopass.kf_intra_err_min / 2979 DOUBLE_DIVIDE_CHECK(next_frame.coded_error)); 2980 2981 if (r > RMAX) 2982 r = RMAX; 2983 2984 /* How fast is prediction quality decaying */ 2985 loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame); 2986 2987 decay_accumulator = decay_accumulator * loop_decay_rate; 2988 decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator; 2989 2990 boost_score += (decay_accumulator * r); 2991 2992 if ((i > MIN_GF_INTERVAL) && 2993 ((boost_score - old_boost_score) < 1.0)) 2994 { 2995 break; 2996 } 2997 2998 old_boost_score = boost_score; 2999 } 3000 3001 if (1) 3002 { 3003 FIRSTPASS_STATS sectionstats; 3004 double Ratio; 3005 3006 zero_stats(§ionstats); 3007 reset_fpf_position(cpi, start_position); 3008 3009 for (i = 0 ; i < cpi->twopass.frames_to_key ; i++) 3010 { 3011 input_stats(cpi, &next_frame); 3012 accumulate_stats(§ionstats, &next_frame); 3013 } 3014 3015 avg_stats(§ionstats); 3016 3017 cpi->twopass.section_intra_rating = (unsigned int) 3018 (sectionstats.intra_error 3019 / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error)); 3020 3021 Ratio = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error); 3022 cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025); 3023 3024 if (cpi->twopass.section_max_qfactor < 0.80) 3025 cpi->twopass.section_max_qfactor = 0.80; 3026 } 3027 3028 /* When using CBR apply additional buffer fullness related upper limits */ 3029 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 3030 { 3031 double max_boost; 3032 3033 if (cpi->drop_frames_allowed) 3034 { 3035 int df_buffer_level = (int)(cpi->oxcf.drop_frames_water_mark 3036 * (cpi->oxcf.optimal_buffer_level / 100)); 3037 3038 if (cpi->buffer_level > df_buffer_level) 3039 max_boost = ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth); 3040 else 3041 max_boost = 0.0; 3042 } 3043 else if (cpi->buffer_level > 0) 3044 { 3045 max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth); 3046 } 3047 else 3048 { 3049 max_boost = 0.0; 3050 } 3051 3052 if (boost_score > max_boost) 3053 boost_score = max_boost; 3054 } 3055 3056 /* Reset the first pass file position */ 3057 reset_fpf_position(cpi, start_position); 3058 3059 /* Work out how many bits to allocate for the key frame itself */ 3060 if (1) 3061 { 3062 int kf_boost = (int)boost_score; 3063 int allocation_chunks; 3064 int Counter = cpi->twopass.frames_to_key; 3065 int alt_kf_bits; 3066 YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx]; 3067 /* Min boost based on kf interval */ 3068 #if 0 3069 3070 while ((kf_boost < 48) && (Counter > 0)) 3071 { 3072 Counter -= 2; 3073 kf_boost ++; 3074 } 3075 3076 #endif 3077 3078 if (kf_boost < 48) 3079 { 3080 kf_boost += ((Counter + 1) >> 1); 3081 3082 if (kf_boost > 48) kf_boost = 48; 3083 } 3084 3085 /* bigger frame sizes need larger kf boosts, smaller frames smaller 3086 * boosts... 3087 */ 3088 if ((lst_yv12->y_width * lst_yv12->y_height) > (320 * 240)) 3089 kf_boost += 2 * (lst_yv12->y_width * lst_yv12->y_height) / (320 * 240); 3090 else if ((lst_yv12->y_width * lst_yv12->y_height) < (320 * 240)) 3091 kf_boost -= 4 * (320 * 240) / (lst_yv12->y_width * lst_yv12->y_height); 3092 3093 /* Min KF boost */ 3094 kf_boost = (int)((double)kf_boost * 100.0) >> 4; /* Scale 16 to 100 */ 3095 if (kf_boost < 250) 3096 kf_boost = 250; 3097 3098 /* 3099 * We do three calculations for kf size. 3100 * The first is based on the error score for the whole kf group. 3101 * The second (optionaly) on the key frames own error if this is 3102 * smaller than the average for the group. 3103 * The final one insures that the frame receives at least the 3104 * allocation it would have received based on its own error score vs 3105 * the error score remaining 3106 * Special case if the sequence appears almost totaly static 3107 * as measured by the decay accumulator. In this case we want to 3108 * spend almost all of the bits on the key frame. 3109 * cpi->twopass.frames_to_key-1 because key frame itself is taken 3110 * care of by kf_boost. 3111 */ 3112 if ( decay_accumulator >= 0.99 ) 3113 { 3114 allocation_chunks = 3115 ((cpi->twopass.frames_to_key - 1) * 10) + kf_boost; 3116 } 3117 else 3118 { 3119 allocation_chunks = 3120 ((cpi->twopass.frames_to_key - 1) * 100) + kf_boost; 3121 } 3122 3123 /* Normalize Altboost and allocations chunck down to prevent overflow */ 3124 while (kf_boost > 1000) 3125 { 3126 kf_boost /= 2; 3127 allocation_chunks /= 2; 3128 } 3129 3130 cpi->twopass.kf_group_bits = (cpi->twopass.kf_group_bits < 0) ? 0 : cpi->twopass.kf_group_bits; 3131 3132 /* Calculate the number of bits to be spent on the key frame */ 3133 cpi->twopass.kf_bits = (int)((double)kf_boost * ((double)cpi->twopass.kf_group_bits / (double)allocation_chunks)); 3134 3135 /* Apply an additional limit for CBR */ 3136 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 3137 { 3138 if (cpi->twopass.kf_bits > (int)((3 * cpi->buffer_level) >> 2)) 3139 cpi->twopass.kf_bits = (int)((3 * cpi->buffer_level) >> 2); 3140 } 3141 3142 /* If the key frame is actually easier than the average for the 3143 * kf group (which does sometimes happen... eg a blank intro frame) 3144 * Then use an alternate calculation based on the kf error score 3145 * which should give a smaller key frame. 3146 */ 3147 if (kf_mod_err < kf_group_err / cpi->twopass.frames_to_key) 3148 { 3149 double alt_kf_grp_bits = 3150 ((double)cpi->twopass.bits_left * 3151 (kf_mod_err * (double)cpi->twopass.frames_to_key) / 3152 DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left)); 3153 3154 alt_kf_bits = (int)((double)kf_boost * 3155 (alt_kf_grp_bits / (double)allocation_chunks)); 3156 3157 if (cpi->twopass.kf_bits > alt_kf_bits) 3158 { 3159 cpi->twopass.kf_bits = alt_kf_bits; 3160 } 3161 } 3162 /* Else if it is much harder than other frames in the group make sure 3163 * it at least receives an allocation in keeping with its relative 3164 * error score 3165 */ 3166 else 3167 { 3168 alt_kf_bits = 3169 (int)((double)cpi->twopass.bits_left * 3170 (kf_mod_err / 3171 DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left))); 3172 3173 if (alt_kf_bits > cpi->twopass.kf_bits) 3174 { 3175 cpi->twopass.kf_bits = alt_kf_bits; 3176 } 3177 } 3178 3179 cpi->twopass.kf_group_bits -= cpi->twopass.kf_bits; 3180 /* Add in the minimum frame allowance */ 3181 cpi->twopass.kf_bits += cpi->min_frame_bandwidth; 3182 3183 /* Peer frame bit target for this frame */ 3184 cpi->per_frame_bandwidth = cpi->twopass.kf_bits; 3185 3186 /* Convert to a per second bitrate */ 3187 cpi->target_bandwidth = (int)(cpi->twopass.kf_bits * 3188 cpi->output_framerate); 3189 } 3190 3191 /* Note the total error score of the kf group minus the key frame itself */ 3192 cpi->twopass.kf_group_error_left = (int)(kf_group_err - kf_mod_err); 3193 3194 /* Adjust the count of total modified error left. The count of bits left 3195 * is adjusted elsewhere based on real coded frame sizes 3196 */ 3197 cpi->twopass.modified_error_left -= kf_group_err; 3198 3199 if (cpi->oxcf.allow_spatial_resampling) 3200 { 3201 int resample_trigger = 0; 3202 int last_kf_resampled = 0; 3203 int kf_q; 3204 int scale_val = 0; 3205 int hr, hs, vr, vs; 3206 int new_width = cpi->oxcf.Width; 3207 int new_height = cpi->oxcf.Height; 3208 3209 int projected_buffer_level = (int)cpi->buffer_level; 3210 int tmp_q; 3211 3212 double projected_bits_perframe; 3213 double group_iiratio = (kf_group_intra_err - first_frame.intra_error) / (kf_group_coded_err - first_frame.coded_error); 3214 double err_per_frame = kf_group_err / cpi->twopass.frames_to_key; 3215 double bits_per_frame; 3216 double av_bits_per_frame; 3217 double effective_size_ratio; 3218 3219 if ((cpi->common.Width != cpi->oxcf.Width) || (cpi->common.Height != cpi->oxcf.Height)) 3220 last_kf_resampled = 1; 3221 3222 /* Set back to unscaled by defaults */ 3223 cpi->common.horiz_scale = NORMAL; 3224 cpi->common.vert_scale = NORMAL; 3225 3226 /* Calculate Average bits per frame. */ 3227 av_bits_per_frame = cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->framerate); 3228 3229 /* CBR... Use the clip average as the target for deciding resample */ 3230 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 3231 { 3232 bits_per_frame = av_bits_per_frame; 3233 } 3234 3235 /* In VBR we want to avoid downsampling in easy section unless we 3236 * are under extreme pressure So use the larger of target bitrate 3237 * for this section or average bitrate for sequence 3238 */ 3239 else 3240 { 3241 /* This accounts for how hard the section is... */ 3242 bits_per_frame = (double) 3243 (cpi->twopass.kf_group_bits / cpi->twopass.frames_to_key); 3244 3245 /* Dont turn to resampling in easy sections just because they 3246 * have been assigned a small number of bits 3247 */ 3248 if (bits_per_frame < av_bits_per_frame) 3249 bits_per_frame = av_bits_per_frame; 3250 } 3251 3252 /* bits_per_frame should comply with our minimum */ 3253 if (bits_per_frame < (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100)) 3254 bits_per_frame = (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100); 3255 3256 /* Work out if spatial resampling is necessary */ 3257 kf_q = estimate_kf_group_q(cpi, err_per_frame, 3258 (int)bits_per_frame, group_iiratio); 3259 3260 /* If we project a required Q higher than the maximum allowed Q then 3261 * make a guess at the actual size of frames in this section 3262 */ 3263 projected_bits_perframe = bits_per_frame; 3264 tmp_q = kf_q; 3265 3266 while (tmp_q > cpi->worst_quality) 3267 { 3268 projected_bits_perframe *= 1.04; 3269 tmp_q--; 3270 } 3271 3272 /* Guess at buffer level at the end of the section */ 3273 projected_buffer_level = (int) 3274 (cpi->buffer_level - (int) 3275 ((projected_bits_perframe - av_bits_per_frame) * 3276 cpi->twopass.frames_to_key)); 3277 3278 if (0) 3279 { 3280 FILE *f = fopen("Subsamle.stt", "a"); 3281 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); 3282 fclose(f); 3283 } 3284 3285 /* The trigger for spatial resampling depends on the various 3286 * parameters such as whether we are streaming (CBR) or VBR. 3287 */ 3288 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 3289 { 3290 /* Trigger resample if we are projected to fall below down 3291 * sample level or resampled last time and are projected to 3292 * remain below the up sample level 3293 */ 3294 if ((projected_buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100)) || 3295 (last_kf_resampled && (projected_buffer_level < (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100)))) 3296 resample_trigger = 1; 3297 else 3298 resample_trigger = 0; 3299 } 3300 else 3301 { 3302 int64_t clip_bits = (int64_t)(cpi->twopass.total_stats.count * cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->framerate)); 3303 int64_t over_spend = cpi->oxcf.starting_buffer_level - cpi->buffer_level; 3304 3305 /* If triggered last time the threshold for triggering again is 3306 * reduced: 3307 * 3308 * Projected Q higher than allowed and Overspend > 5% of total 3309 * bits 3310 */ 3311 if ((last_kf_resampled && (kf_q > cpi->worst_quality)) || 3312 ((kf_q > cpi->worst_quality) && 3313 (over_spend > clip_bits / 20))) 3314 resample_trigger = 1; 3315 else 3316 resample_trigger = 0; 3317 3318 } 3319 3320 if (resample_trigger) 3321 { 3322 while ((kf_q >= cpi->worst_quality) && (scale_val < 6)) 3323 { 3324 scale_val ++; 3325 3326 cpi->common.vert_scale = vscale_lookup[scale_val]; 3327 cpi->common.horiz_scale = hscale_lookup[scale_val]; 3328 3329 Scale2Ratio(cpi->common.horiz_scale, &hr, &hs); 3330 Scale2Ratio(cpi->common.vert_scale, &vr, &vs); 3331 3332 new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs; 3333 new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs; 3334 3335 /* Reducing the area to 1/4 does not reduce the complexity 3336 * (err_per_frame) to 1/4... effective_sizeratio attempts 3337 * to provide a crude correction for this 3338 */ 3339 effective_size_ratio = (double)(new_width * new_height) / (double)(cpi->oxcf.Width * cpi->oxcf.Height); 3340 effective_size_ratio = (1.0 + (3.0 * effective_size_ratio)) / 4.0; 3341 3342 /* Now try again and see what Q we get with the smaller 3343 * image size 3344 */ 3345 kf_q = estimate_kf_group_q(cpi, 3346 err_per_frame * effective_size_ratio, 3347 (int)bits_per_frame, group_iiratio); 3348 3349 if (0) 3350 { 3351 FILE *f = fopen("Subsamle.stt", "a"); 3352 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); 3353 fclose(f); 3354 } 3355 } 3356 } 3357 3358 if ((cpi->common.Width != new_width) || (cpi->common.Height != new_height)) 3359 { 3360 cpi->common.Width = new_width; 3361 cpi->common.Height = new_height; 3362 vp8_alloc_compressor_data(cpi); 3363 } 3364 } 3365 } 3366
