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