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 12#include "vpx_config.h" 13#include "./vpx_scale_rtcd.h" 14#include "vp8/common/onyxc_int.h" 15#include "vp8/common/blockd.h" 16#include "onyx_int.h" 17#include "vp8/common/systemdependent.h" 18#include "quantize.h" 19#include "vp8/common/alloccommon.h" 20#include "mcomp.h" 21#include "firstpass.h" 22#include "vpx/internal/vpx_psnr.h" 23#include "vpx_scale/vpx_scale.h" 24#include "vp8/common/extend.h" 25#include "ratectrl.h" 26#include "vp8/common/quant_common.h" 27#include "segmentation.h" 28#if CONFIG_POSTPROC 29#include "vp8/common/postproc.h" 30#endif 31#include "vpx_mem/vpx_mem.h" 32#include "vp8/common/swapyv12buffer.h" 33#include "vp8/common/threading.h" 34#include "vpx_ports/vpx_timer.h" 35#if ARCH_ARM 36#include "vpx_ports/arm.h" 37#endif 38#if CONFIG_MULTI_RES_ENCODING 39#include "mr_dissim.h" 40#endif 41#include "encodeframe.h" 42 43#include <math.h> 44#include <stdio.h> 45#include <limits.h> 46 47#if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING 48extern int vp8_update_coef_context(VP8_COMP *cpi); 49extern void vp8_update_coef_probs(VP8_COMP *cpi); 50#endif 51 52extern void vp8cx_pick_filter_level_fast(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi); 53extern void vp8cx_set_alt_lf_level(VP8_COMP *cpi, int filt_val); 54extern void vp8cx_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi); 55 56extern void vp8_deblock_frame(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *post, int filt_lvl, int low_var_thresh, int flag); 57extern void print_parms(VP8_CONFIG *ocf, char *filenam); 58extern unsigned int vp8_get_processor_freq(); 59extern void print_tree_update_probs(); 60extern int vp8cx_create_encoder_threads(VP8_COMP *cpi); 61extern void vp8cx_remove_encoder_threads(VP8_COMP *cpi); 62 63int vp8_estimate_entropy_savings(VP8_COMP *cpi); 64 65int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest); 66 67extern void vp8_temporal_filter_prepare_c(VP8_COMP *cpi, int distance); 68 69static void set_default_lf_deltas(VP8_COMP *cpi); 70 71extern const int vp8_gf_interval_table[101]; 72 73#if CONFIG_INTERNAL_STATS 74#include "math.h" 75 76extern double vp8_calc_ssim 77( 78 YV12_BUFFER_CONFIG *source, 79 YV12_BUFFER_CONFIG *dest, 80 int lumamask, 81 double *weight 82); 83 84 85extern double vp8_calc_ssimg 86( 87 YV12_BUFFER_CONFIG *source, 88 YV12_BUFFER_CONFIG *dest, 89 double *ssim_y, 90 double *ssim_u, 91 double *ssim_v 92); 93 94 95#endif 96 97 98#ifdef OUTPUT_YUV_SRC 99FILE *yuv_file; 100#endif 101 102#if 0 103FILE *framepsnr; 104FILE *kf_list; 105FILE *keyfile; 106#endif 107 108#if 0 109extern int skip_true_count; 110extern int skip_false_count; 111#endif 112 113 114#ifdef VP8_ENTROPY_STATS 115extern int intra_mode_stats[10][10][10]; 116#endif 117 118#ifdef SPEEDSTATS 119unsigned int frames_at_speed[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; 120unsigned int tot_pm = 0; 121unsigned int cnt_pm = 0; 122unsigned int tot_ef = 0; 123unsigned int cnt_ef = 0; 124#endif 125 126#ifdef MODE_STATS 127extern unsigned __int64 Sectionbits[50]; 128extern int y_modes[5] ; 129extern int uv_modes[4] ; 130extern int b_modes[10] ; 131 132extern int inter_y_modes[10] ; 133extern int inter_uv_modes[4] ; 134extern unsigned int inter_b_modes[15]; 135#endif 136 137extern const int vp8_bits_per_mb[2][QINDEX_RANGE]; 138 139extern const int qrounding_factors[129]; 140extern const int qzbin_factors[129]; 141extern void vp8cx_init_quantizer(VP8_COMP *cpi); 142extern const int vp8cx_base_skip_false_prob[128]; 143 144/* Tables relating active max Q to active min Q */ 145static const unsigned char kf_low_motion_minq[QINDEX_RANGE] = 146{ 147 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 148 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 149 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 150 0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2, 151 3,3,3,3,3,3,4,4,4,5,5,5,5,5,6,6, 152 6,6,7,7,8,8,8,8,9,9,10,10,10,10,11,11, 153 11,11,12,12,13,13,13,13,14,14,15,15,15,15,16,16, 154 16,16,17,17,18,18,18,18,19,20,20,21,21,22,23,23 155}; 156static const unsigned char kf_high_motion_minq[QINDEX_RANGE] = 157{ 158 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 159 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 160 1,1,1,1,1,1,1,1,2,2,2,2,3,3,3,3, 161 3,3,3,3,4,4,4,4,5,5,5,5,5,5,6,6, 162 6,6,7,7,8,8,8,8,9,9,10,10,10,10,11,11, 163 11,11,12,12,13,13,13,13,14,14,15,15,15,15,16,16, 164 16,16,17,17,18,18,18,18,19,19,20,20,20,20,21,21, 165 21,21,22,22,23,23,24,25,25,26,26,27,28,28,29,30 166}; 167static const unsigned char gf_low_motion_minq[QINDEX_RANGE] = 168{ 169 0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2, 170 3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6, 171 7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10, 172 11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18, 173 19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26, 174 27,27,28,28,29,29,30,30,31,31,32,32,33,33,34,34, 175 35,35,36,36,37,37,38,38,39,39,40,40,41,41,42,42, 176 43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58 177}; 178static const unsigned char gf_mid_motion_minq[QINDEX_RANGE] = 179{ 180 0,0,0,0,1,1,1,1,1,1,2,2,3,3,3,4, 181 4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9, 182 9,10,10,10,10,11,11,11,12,12,12,12,13,13,13,14, 183 14,14,15,15,16,16,17,17,18,18,19,19,20,20,21,21, 184 22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29, 185 30,30,31,31,32,32,33,33,34,34,35,35,36,36,37,37, 186 38,39,39,40,40,41,41,42,42,43,43,44,45,46,47,48, 187 49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64 188}; 189static const unsigned char gf_high_motion_minq[QINDEX_RANGE] = 190{ 191 0,0,0,0,1,1,1,1,1,2,2,2,3,3,3,4, 192 4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9, 193 9,10,10,10,11,11,12,12,13,13,14,14,15,15,16,16, 194 17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24, 195 25,25,26,26,27,27,28,28,29,29,30,30,31,31,32,32, 196 33,33,34,34,35,35,36,36,37,37,38,38,39,39,40,40, 197 41,41,42,42,43,44,45,46,47,48,49,50,51,52,53,54, 198 55,56,57,58,59,60,62,64,66,68,70,72,74,76,78,80 199}; 200static const unsigned char inter_minq[QINDEX_RANGE] = 201{ 202 0,0,1,1,2,3,3,4,4,5,6,6,7,8,8,9, 203 9,10,11,11,12,13,13,14,15,15,16,17,17,18,19,20, 204 20,21,22,22,23,24,24,25,26,27,27,28,29,30,30,31, 205 32,33,33,34,35,36,36,37,38,39,39,40,41,42,42,43, 206 44,45,46,46,47,48,49,50,50,51,52,53,54,55,55,56, 207 57,58,59,60,60,61,62,63,64,65,66,67,67,68,69,70, 208 71,72,73,74,75,75,76,77,78,79,80,81,82,83,84,85, 209 86,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100 210}; 211 212#ifdef PACKET_TESTING 213extern FILE *vpxlogc; 214#endif 215 216static void save_layer_context(VP8_COMP *cpi) 217{ 218 LAYER_CONTEXT *lc = &cpi->layer_context[cpi->current_layer]; 219 220 /* Save layer dependent coding state */ 221 lc->target_bandwidth = cpi->target_bandwidth; 222 lc->starting_buffer_level = cpi->oxcf.starting_buffer_level; 223 lc->optimal_buffer_level = cpi->oxcf.optimal_buffer_level; 224 lc->maximum_buffer_size = cpi->oxcf.maximum_buffer_size; 225 lc->starting_buffer_level_in_ms = cpi->oxcf.starting_buffer_level_in_ms; 226 lc->optimal_buffer_level_in_ms = cpi->oxcf.optimal_buffer_level_in_ms; 227 lc->maximum_buffer_size_in_ms = cpi->oxcf.maximum_buffer_size_in_ms; 228 lc->buffer_level = cpi->buffer_level; 229 lc->bits_off_target = cpi->bits_off_target; 230 lc->total_actual_bits = cpi->total_actual_bits; 231 lc->worst_quality = cpi->worst_quality; 232 lc->active_worst_quality = cpi->active_worst_quality; 233 lc->best_quality = cpi->best_quality; 234 lc->active_best_quality = cpi->active_best_quality; 235 lc->ni_av_qi = cpi->ni_av_qi; 236 lc->ni_tot_qi = cpi->ni_tot_qi; 237 lc->ni_frames = cpi->ni_frames; 238 lc->avg_frame_qindex = cpi->avg_frame_qindex; 239 lc->rate_correction_factor = cpi->rate_correction_factor; 240 lc->key_frame_rate_correction_factor = cpi->key_frame_rate_correction_factor; 241 lc->gf_rate_correction_factor = cpi->gf_rate_correction_factor; 242 lc->zbin_over_quant = cpi->mb.zbin_over_quant; 243 lc->inter_frame_target = cpi->inter_frame_target; 244 lc->total_byte_count = cpi->total_byte_count; 245 lc->filter_level = cpi->common.filter_level; 246 247 lc->last_frame_percent_intra = cpi->last_frame_percent_intra; 248 249 memcpy (lc->count_mb_ref_frame_usage, 250 cpi->mb.count_mb_ref_frame_usage, 251 sizeof(cpi->mb.count_mb_ref_frame_usage)); 252} 253 254static void restore_layer_context(VP8_COMP *cpi, const int layer) 255{ 256 LAYER_CONTEXT *lc = &cpi->layer_context[layer]; 257 258 /* Restore layer dependent coding state */ 259 cpi->current_layer = layer; 260 cpi->target_bandwidth = lc->target_bandwidth; 261 cpi->oxcf.target_bandwidth = lc->target_bandwidth; 262 cpi->oxcf.starting_buffer_level = lc->starting_buffer_level; 263 cpi->oxcf.optimal_buffer_level = lc->optimal_buffer_level; 264 cpi->oxcf.maximum_buffer_size = lc->maximum_buffer_size; 265 cpi->oxcf.starting_buffer_level_in_ms = lc->starting_buffer_level_in_ms; 266 cpi->oxcf.optimal_buffer_level_in_ms = lc->optimal_buffer_level_in_ms; 267 cpi->oxcf.maximum_buffer_size_in_ms = lc->maximum_buffer_size_in_ms; 268 cpi->buffer_level = lc->buffer_level; 269 cpi->bits_off_target = lc->bits_off_target; 270 cpi->total_actual_bits = lc->total_actual_bits; 271 cpi->active_worst_quality = lc->active_worst_quality; 272 cpi->active_best_quality = lc->active_best_quality; 273 cpi->ni_av_qi = lc->ni_av_qi; 274 cpi->ni_tot_qi = lc->ni_tot_qi; 275 cpi->ni_frames = lc->ni_frames; 276 cpi->avg_frame_qindex = lc->avg_frame_qindex; 277 cpi->rate_correction_factor = lc->rate_correction_factor; 278 cpi->key_frame_rate_correction_factor = lc->key_frame_rate_correction_factor; 279 cpi->gf_rate_correction_factor = lc->gf_rate_correction_factor; 280 cpi->mb.zbin_over_quant = lc->zbin_over_quant; 281 cpi->inter_frame_target = lc->inter_frame_target; 282 cpi->total_byte_count = lc->total_byte_count; 283 cpi->common.filter_level = lc->filter_level; 284 285 cpi->last_frame_percent_intra = lc->last_frame_percent_intra; 286 287 memcpy (cpi->mb.count_mb_ref_frame_usage, 288 lc->count_mb_ref_frame_usage, 289 sizeof(cpi->mb.count_mb_ref_frame_usage)); 290} 291 292static int rescale(int val, int num, int denom) 293{ 294 int64_t llnum = num; 295 int64_t llden = denom; 296 int64_t llval = val; 297 298 return (int)(llval * llnum / llden); 299} 300 301static void init_temporal_layer_context(VP8_COMP *cpi, 302 VP8_CONFIG *oxcf, 303 const int layer, 304 double prev_layer_framerate) 305{ 306 LAYER_CONTEXT *lc = &cpi->layer_context[layer]; 307 308 lc->framerate = cpi->output_framerate / cpi->oxcf.rate_decimator[layer]; 309 lc->target_bandwidth = cpi->oxcf.target_bitrate[layer] * 1000; 310 311 lc->starting_buffer_level_in_ms = oxcf->starting_buffer_level; 312 lc->optimal_buffer_level_in_ms = oxcf->optimal_buffer_level; 313 lc->maximum_buffer_size_in_ms = oxcf->maximum_buffer_size; 314 315 lc->starting_buffer_level = 316 rescale((int)(oxcf->starting_buffer_level), 317 lc->target_bandwidth, 1000); 318 319 if (oxcf->optimal_buffer_level == 0) 320 lc->optimal_buffer_level = lc->target_bandwidth / 8; 321 else 322 lc->optimal_buffer_level = 323 rescale((int)(oxcf->optimal_buffer_level), 324 lc->target_bandwidth, 1000); 325 326 if (oxcf->maximum_buffer_size == 0) 327 lc->maximum_buffer_size = lc->target_bandwidth / 8; 328 else 329 lc->maximum_buffer_size = 330 rescale((int)(oxcf->maximum_buffer_size), 331 lc->target_bandwidth, 1000); 332 333 /* Work out the average size of a frame within this layer */ 334 if (layer > 0) 335 lc->avg_frame_size_for_layer = 336 (int)((cpi->oxcf.target_bitrate[layer] - 337 cpi->oxcf.target_bitrate[layer-1]) * 1000 / 338 (lc->framerate - prev_layer_framerate)); 339 340 lc->active_worst_quality = cpi->oxcf.worst_allowed_q; 341 lc->active_best_quality = cpi->oxcf.best_allowed_q; 342 lc->avg_frame_qindex = cpi->oxcf.worst_allowed_q; 343 344 lc->buffer_level = lc->starting_buffer_level; 345 lc->bits_off_target = lc->starting_buffer_level; 346 347 lc->total_actual_bits = 0; 348 lc->ni_av_qi = 0; 349 lc->ni_tot_qi = 0; 350 lc->ni_frames = 0; 351 lc->rate_correction_factor = 1.0; 352 lc->key_frame_rate_correction_factor = 1.0; 353 lc->gf_rate_correction_factor = 1.0; 354 lc->inter_frame_target = 0; 355} 356 357// Upon a run-time change in temporal layers, reset the layer context parameters 358// for any "new" layers. For "existing" layers, let them inherit the parameters 359// from the previous layer state (at the same layer #). In future we may want 360// to better map the previous layer state(s) to the "new" ones. 361static void reset_temporal_layer_change(VP8_COMP *cpi, 362 VP8_CONFIG *oxcf, 363 const int prev_num_layers) 364{ 365 int i; 366 double prev_layer_framerate = 0; 367 const int curr_num_layers = cpi->oxcf.number_of_layers; 368 // If the previous state was 1 layer, get current layer context from cpi. 369 // We need this to set the layer context for the new layers below. 370 if (prev_num_layers == 1) 371 { 372 cpi->current_layer = 0; 373 save_layer_context(cpi); 374 } 375 for (i = 0; i < curr_num_layers; i++) 376 { 377 LAYER_CONTEXT *lc = &cpi->layer_context[i]; 378 if (i >= prev_num_layers) 379 { 380 init_temporal_layer_context(cpi, oxcf, i, prev_layer_framerate); 381 } 382 // The initial buffer levels are set based on their starting levels. 383 // We could set the buffer levels based on the previous state (normalized 384 // properly by the layer bandwidths) but we would need to keep track of 385 // the previous set of layer bandwidths (i.e., target_bitrate[i]) 386 // before the layer change. For now, reset to the starting levels. 387 lc->buffer_level = cpi->oxcf.starting_buffer_level_in_ms * 388 cpi->oxcf.target_bitrate[i]; 389 lc->bits_off_target = lc->buffer_level; 390 // TDOD(marpan): Should we set the rate_correction_factor and 391 // active_worst/best_quality to values derived from the previous layer 392 // state (to smooth-out quality dips/rate fluctuation at transition)? 393 394 // We need to treat the 1 layer case separately: oxcf.target_bitrate[i] 395 // is not set for 1 layer, and the restore_layer_context/save_context() 396 // are not called in the encoding loop, so we need to call it here to 397 // pass the layer context state to |cpi|. 398 if (curr_num_layers == 1) 399 { 400 lc->target_bandwidth = cpi->oxcf.target_bandwidth; 401 lc->buffer_level = cpi->oxcf.starting_buffer_level_in_ms * 402 lc->target_bandwidth / 1000; 403 lc->bits_off_target = lc->buffer_level; 404 restore_layer_context(cpi, 0); 405 } 406 prev_layer_framerate = cpi->output_framerate / 407 cpi->oxcf.rate_decimator[i]; 408 } 409} 410 411static void setup_features(VP8_COMP *cpi) 412{ 413 // If segmentation enabled set the update flags 414 if ( cpi->mb.e_mbd.segmentation_enabled ) 415 { 416 cpi->mb.e_mbd.update_mb_segmentation_map = 1; 417 cpi->mb.e_mbd.update_mb_segmentation_data = 1; 418 } 419 else 420 { 421 cpi->mb.e_mbd.update_mb_segmentation_map = 0; 422 cpi->mb.e_mbd.update_mb_segmentation_data = 0; 423 } 424 425 cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 0; 426 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0; 427 vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas)); 428 vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas)); 429 vpx_memset(cpi->mb.e_mbd.last_ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas)); 430 vpx_memset(cpi->mb.e_mbd.last_mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas)); 431 432 set_default_lf_deltas(cpi); 433 434} 435 436 437static void dealloc_raw_frame_buffers(VP8_COMP *cpi); 438 439 440static void dealloc_compressor_data(VP8_COMP *cpi) 441{ 442 vpx_free(cpi->tplist); 443 cpi->tplist = NULL; 444 445 /* Delete last frame MV storage buffers */ 446 vpx_free(cpi->lfmv); 447 cpi->lfmv = 0; 448 449 vpx_free(cpi->lf_ref_frame_sign_bias); 450 cpi->lf_ref_frame_sign_bias = 0; 451 452 vpx_free(cpi->lf_ref_frame); 453 cpi->lf_ref_frame = 0; 454 455 /* Delete sementation map */ 456 vpx_free(cpi->segmentation_map); 457 cpi->segmentation_map = 0; 458 459 vpx_free(cpi->active_map); 460 cpi->active_map = 0; 461 462 vp8_de_alloc_frame_buffers(&cpi->common); 463 464 vp8_yv12_de_alloc_frame_buffer(&cpi->pick_lf_lvl_frame); 465 vp8_yv12_de_alloc_frame_buffer(&cpi->scaled_source); 466 dealloc_raw_frame_buffers(cpi); 467 468 vpx_free(cpi->tok); 469 cpi->tok = 0; 470 471 /* Structure used to monitor GF usage */ 472 vpx_free(cpi->gf_active_flags); 473 cpi->gf_active_flags = 0; 474 475 /* Activity mask based per mb zbin adjustments */ 476 vpx_free(cpi->mb_activity_map); 477 cpi->mb_activity_map = 0; 478 479 vpx_free(cpi->mb.pip); 480 cpi->mb.pip = 0; 481 482#if CONFIG_MULTITHREAD 483 vpx_free(cpi->mt_current_mb_col); 484 cpi->mt_current_mb_col = NULL; 485#endif 486} 487 488static void enable_segmentation(VP8_COMP *cpi) 489{ 490 /* Set the appropriate feature bit */ 491 cpi->mb.e_mbd.segmentation_enabled = 1; 492 cpi->mb.e_mbd.update_mb_segmentation_map = 1; 493 cpi->mb.e_mbd.update_mb_segmentation_data = 1; 494} 495static void disable_segmentation(VP8_COMP *cpi) 496{ 497 /* Clear the appropriate feature bit */ 498 cpi->mb.e_mbd.segmentation_enabled = 0; 499} 500 501/* Valid values for a segment are 0 to 3 502 * Segmentation map is arrange as [Rows][Columns] 503 */ 504static void set_segmentation_map(VP8_COMP *cpi, unsigned char *segmentation_map) 505{ 506 /* Copy in the new segmentation map */ 507 vpx_memcpy(cpi->segmentation_map, segmentation_map, (cpi->common.mb_rows * cpi->common.mb_cols)); 508 509 /* Signal that the map should be updated. */ 510 cpi->mb.e_mbd.update_mb_segmentation_map = 1; 511 cpi->mb.e_mbd.update_mb_segmentation_data = 1; 512} 513 514/* The values given for each segment can be either deltas (from the default 515 * value chosen for the frame) or absolute values. 516 * 517 * Valid range for abs values is: 518 * (0-127 for MB_LVL_ALT_Q), (0-63 for SEGMENT_ALT_LF) 519 * Valid range for delta values are: 520 * (+/-127 for MB_LVL_ALT_Q), (+/-63 for SEGMENT_ALT_LF) 521 * 522 * abs_delta = SEGMENT_DELTADATA (deltas) 523 * abs_delta = SEGMENT_ABSDATA (use the absolute values given). 524 * 525 */ 526static void set_segment_data(VP8_COMP *cpi, signed char *feature_data, unsigned char abs_delta) 527{ 528 cpi->mb.e_mbd.mb_segement_abs_delta = abs_delta; 529 vpx_memcpy(cpi->segment_feature_data, feature_data, sizeof(cpi->segment_feature_data)); 530} 531 532 533static void segmentation_test_function(VP8_COMP *cpi) 534{ 535 unsigned char *seg_map; 536 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS]; 537 538 // Create a temporary map for segmentation data. 539 CHECK_MEM_ERROR(seg_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1)); 540 541 // Set the segmentation Map 542 set_segmentation_map(cpi, seg_map); 543 544 // Activate segmentation. 545 enable_segmentation(cpi); 546 547 // Set up the quant segment data 548 feature_data[MB_LVL_ALT_Q][0] = 0; 549 feature_data[MB_LVL_ALT_Q][1] = 4; 550 feature_data[MB_LVL_ALT_Q][2] = 0; 551 feature_data[MB_LVL_ALT_Q][3] = 0; 552 // Set up the loop segment data 553 feature_data[MB_LVL_ALT_LF][0] = 0; 554 feature_data[MB_LVL_ALT_LF][1] = 0; 555 feature_data[MB_LVL_ALT_LF][2] = 0; 556 feature_data[MB_LVL_ALT_LF][3] = 0; 557 558 // Initialise the feature data structure 559 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1 560 set_segment_data(cpi, &feature_data[0][0], SEGMENT_DELTADATA); 561 562 // Delete sementation map 563 vpx_free(seg_map); 564 565 seg_map = 0; 566} 567 568/* A simple function to cyclically refresh the background at a lower Q */ 569static void cyclic_background_refresh(VP8_COMP *cpi, int Q, int lf_adjustment) 570{ 571 unsigned char *seg_map = cpi->segmentation_map; 572 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS]; 573 int i; 574 int block_count = cpi->cyclic_refresh_mode_max_mbs_perframe; 575 int mbs_in_frame = cpi->common.mb_rows * cpi->common.mb_cols; 576 577 cpi->cyclic_refresh_q = Q / 2; 578 579 // Set every macroblock to be eligible for update. 580 // For key frame this will reset seg map to 0. 581 vpx_memset(cpi->segmentation_map, 0, mbs_in_frame); 582 583 if (cpi->common.frame_type != KEY_FRAME) 584 { 585 /* Cycle through the macro_block rows */ 586 /* MB loop to set local segmentation map */ 587 i = cpi->cyclic_refresh_mode_index; 588 assert(i < mbs_in_frame); 589 do 590 { 591 /* If the MB is as a candidate for clean up then mark it for 592 * possible boost/refresh (segment 1) The segment id may get 593 * reset to 0 later if the MB gets coded anything other than 594 * last frame 0,0 as only (last frame 0,0) MBs are eligable for 595 * refresh : that is to say Mbs likely to be background blocks. 596 */ 597 if (cpi->cyclic_refresh_map[i] == 0) 598 { 599 seg_map[i] = 1; 600 block_count --; 601 } 602 else if (cpi->cyclic_refresh_map[i] < 0) 603 cpi->cyclic_refresh_map[i]++; 604 605 i++; 606 if (i == mbs_in_frame) 607 i = 0; 608 609 } 610 while(block_count && i != cpi->cyclic_refresh_mode_index); 611 612 cpi->cyclic_refresh_mode_index = i; 613 } 614 615 /* Activate segmentation. */ 616 cpi->mb.e_mbd.update_mb_segmentation_map = 1; 617 cpi->mb.e_mbd.update_mb_segmentation_data = 1; 618 enable_segmentation(cpi); 619 620 /* Set up the quant segment data */ 621 feature_data[MB_LVL_ALT_Q][0] = 0; 622 feature_data[MB_LVL_ALT_Q][1] = (cpi->cyclic_refresh_q - Q); 623 feature_data[MB_LVL_ALT_Q][2] = 0; 624 feature_data[MB_LVL_ALT_Q][3] = 0; 625 626 /* Set up the loop segment data */ 627 feature_data[MB_LVL_ALT_LF][0] = 0; 628 feature_data[MB_LVL_ALT_LF][1] = lf_adjustment; 629 feature_data[MB_LVL_ALT_LF][2] = 0; 630 feature_data[MB_LVL_ALT_LF][3] = 0; 631 632 /* Initialise the feature data structure */ 633 set_segment_data(cpi, &feature_data[0][0], SEGMENT_DELTADATA); 634 635} 636 637static void set_default_lf_deltas(VP8_COMP *cpi) 638{ 639 cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 1; 640 cpi->mb.e_mbd.mode_ref_lf_delta_update = 1; 641 642 vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas)); 643 vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas)); 644 645 /* Test of ref frame deltas */ 646 cpi->mb.e_mbd.ref_lf_deltas[INTRA_FRAME] = 2; 647 cpi->mb.e_mbd.ref_lf_deltas[LAST_FRAME] = 0; 648 cpi->mb.e_mbd.ref_lf_deltas[GOLDEN_FRAME] = -2; 649 cpi->mb.e_mbd.ref_lf_deltas[ALTREF_FRAME] = -2; 650 651 cpi->mb.e_mbd.mode_lf_deltas[0] = 4; /* BPRED */ 652 653 if(cpi->oxcf.Mode == MODE_REALTIME) 654 cpi->mb.e_mbd.mode_lf_deltas[1] = -12; /* Zero */ 655 else 656 cpi->mb.e_mbd.mode_lf_deltas[1] = -2; /* Zero */ 657 658 cpi->mb.e_mbd.mode_lf_deltas[2] = 2; /* New mv */ 659 cpi->mb.e_mbd.mode_lf_deltas[3] = 4; /* Split mv */ 660} 661 662/* Convenience macros for mapping speed and mode into a continuous 663 * range 664 */ 665#define GOOD(x) (x+1) 666#define RT(x) (x+7) 667 668static int speed_map(int speed, const int *map) 669{ 670 int res; 671 672 do 673 { 674 res = *map++; 675 } while(speed >= *map++); 676 return res; 677} 678 679static const int thresh_mult_map_znn[] = { 680 /* map common to zero, nearest, and near */ 681 0, GOOD(2), 1500, GOOD(3), 2000, RT(0), 1000, RT(2), 2000, INT_MAX 682}; 683 684static const int thresh_mult_map_vhpred[] = { 685 1000, GOOD(2), 1500, GOOD(3), 2000, RT(0), 1000, RT(1), 2000, 686 RT(7), INT_MAX, INT_MAX 687}; 688 689static const int thresh_mult_map_bpred[] = { 690 2000, GOOD(0), 2500, GOOD(2), 5000, GOOD(3), 7500, RT(0), 2500, RT(1), 5000, 691 RT(6), INT_MAX, INT_MAX 692}; 693 694static const int thresh_mult_map_tm[] = { 695 1000, GOOD(2), 1500, GOOD(3), 2000, RT(0), 0, RT(1), 1000, RT(2), 2000, 696 RT(7), INT_MAX, INT_MAX 697}; 698 699static const int thresh_mult_map_new1[] = { 700 1000, GOOD(2), 2000, RT(0), 2000, INT_MAX 701}; 702 703static const int thresh_mult_map_new2[] = { 704 1000, GOOD(2), 2000, GOOD(3), 2500, GOOD(5), 4000, RT(0), 2000, RT(2), 2500, 705 RT(5), 4000, INT_MAX 706}; 707 708static const int thresh_mult_map_split1[] = { 709 2500, GOOD(0), 1700, GOOD(2), 10000, GOOD(3), 25000, GOOD(4), INT_MAX, 710 RT(0), 5000, RT(1), 10000, RT(2), 25000, RT(3), INT_MAX, INT_MAX 711}; 712 713static const int thresh_mult_map_split2[] = { 714 5000, GOOD(0), 4500, GOOD(2), 20000, GOOD(3), 50000, GOOD(4), INT_MAX, 715 RT(0), 10000, RT(1), 20000, RT(2), 50000, RT(3), INT_MAX, INT_MAX 716}; 717 718static const int mode_check_freq_map_zn2[] = { 719 /* {zero,nearest}{2,3} */ 720 0, RT(10), 1<<1, RT(11), 1<<2, RT(12), 1<<3, INT_MAX 721}; 722 723static const int mode_check_freq_map_vhbpred[] = { 724 0, GOOD(5), 2, RT(0), 0, RT(3), 2, RT(5), 4, INT_MAX 725}; 726 727static const int mode_check_freq_map_near2[] = { 728 0, GOOD(5), 2, RT(0), 0, RT(3), 2, RT(10), 1<<2, RT(11), 1<<3, RT(12), 1<<4, 729 INT_MAX 730}; 731 732static const int mode_check_freq_map_new1[] = { 733 0, RT(10), 1<<1, RT(11), 1<<2, RT(12), 1<<3, INT_MAX 734}; 735 736static const int mode_check_freq_map_new2[] = { 737 0, GOOD(5), 4, RT(0), 0, RT(3), 4, RT(10), 1<<3, RT(11), 1<<4, RT(12), 1<<5, 738 INT_MAX 739}; 740 741static const int mode_check_freq_map_split1[] = { 742 0, GOOD(2), 2, GOOD(3), 7, RT(1), 2, RT(2), 7, INT_MAX 743}; 744 745static const int mode_check_freq_map_split2[] = { 746 0, GOOD(1), 2, GOOD(2), 4, GOOD(3), 15, RT(1), 4, RT(2), 15, INT_MAX 747}; 748 749void vp8_set_speed_features(VP8_COMP *cpi) 750{ 751 SPEED_FEATURES *sf = &cpi->sf; 752 int Mode = cpi->compressor_speed; 753 int Speed = cpi->Speed; 754 int i; 755 VP8_COMMON *cm = &cpi->common; 756 int last_improved_quant = sf->improved_quant; 757 int ref_frames; 758 759 /* Initialise default mode frequency sampling variables */ 760 for (i = 0; i < MAX_MODES; i ++) 761 { 762 cpi->mode_check_freq[i] = 0; 763 } 764 765 cpi->mb.mbs_tested_so_far = 0; 766 767 /* best quality defaults */ 768 sf->RD = 1; 769 sf->search_method = NSTEP; 770 sf->improved_quant = 1; 771 sf->improved_dct = 1; 772 sf->auto_filter = 1; 773 sf->recode_loop = 1; 774 sf->quarter_pixel_search = 1; 775 sf->half_pixel_search = 1; 776 sf->iterative_sub_pixel = 1; 777 sf->optimize_coefficients = 1; 778 sf->use_fastquant_for_pick = 0; 779 sf->no_skip_block4x4_search = 1; 780 781 sf->first_step = 0; 782 sf->max_step_search_steps = MAX_MVSEARCH_STEPS; 783 sf->improved_mv_pred = 1; 784 785 /* default thresholds to 0 */ 786 for (i = 0; i < MAX_MODES; i++) 787 sf->thresh_mult[i] = 0; 788 789 /* Count enabled references */ 790 ref_frames = 1; 791 if (cpi->ref_frame_flags & VP8_LAST_FRAME) 792 ref_frames++; 793 if (cpi->ref_frame_flags & VP8_GOLD_FRAME) 794 ref_frames++; 795 if (cpi->ref_frame_flags & VP8_ALTR_FRAME) 796 ref_frames++; 797 798 /* Convert speed to continuous range, with clamping */ 799 if (Mode == 0) 800 Speed = 0; 801 else if (Mode == 2) 802 Speed = RT(Speed); 803 else 804 { 805 if (Speed > 5) 806 Speed = 5; 807 Speed = GOOD(Speed); 808 } 809 810 sf->thresh_mult[THR_ZERO1] = 811 sf->thresh_mult[THR_NEAREST1] = 812 sf->thresh_mult[THR_NEAR1] = 813 sf->thresh_mult[THR_DC] = 0; /* always */ 814 815 sf->thresh_mult[THR_ZERO2] = 816 sf->thresh_mult[THR_ZERO3] = 817 sf->thresh_mult[THR_NEAREST2] = 818 sf->thresh_mult[THR_NEAREST3] = 819 sf->thresh_mult[THR_NEAR2] = 820 sf->thresh_mult[THR_NEAR3] = speed_map(Speed, thresh_mult_map_znn); 821 822 sf->thresh_mult[THR_V_PRED] = 823 sf->thresh_mult[THR_H_PRED] = speed_map(Speed, thresh_mult_map_vhpred); 824 sf->thresh_mult[THR_B_PRED] = speed_map(Speed, thresh_mult_map_bpred); 825 sf->thresh_mult[THR_TM] = speed_map(Speed, thresh_mult_map_tm); 826 sf->thresh_mult[THR_NEW1] = speed_map(Speed, thresh_mult_map_new1); 827 sf->thresh_mult[THR_NEW2] = 828 sf->thresh_mult[THR_NEW3] = speed_map(Speed, thresh_mult_map_new2); 829 sf->thresh_mult[THR_SPLIT1] = speed_map(Speed, thresh_mult_map_split1); 830 sf->thresh_mult[THR_SPLIT2] = 831 sf->thresh_mult[THR_SPLIT3] = speed_map(Speed, thresh_mult_map_split2); 832 833 cpi->mode_check_freq[THR_ZERO1] = 834 cpi->mode_check_freq[THR_NEAREST1] = 835 cpi->mode_check_freq[THR_NEAR1] = 836 cpi->mode_check_freq[THR_TM] = 837 cpi->mode_check_freq[THR_DC] = 0; /* always */ 838 839 cpi->mode_check_freq[THR_ZERO2] = 840 cpi->mode_check_freq[THR_ZERO3] = 841 cpi->mode_check_freq[THR_NEAREST2] = 842 cpi->mode_check_freq[THR_NEAREST3] = speed_map(Speed, 843 mode_check_freq_map_zn2); 844 845 cpi->mode_check_freq[THR_NEAR2] = 846 cpi->mode_check_freq[THR_NEAR3] = speed_map(Speed, 847 mode_check_freq_map_near2); 848 849 cpi->mode_check_freq[THR_V_PRED] = 850 cpi->mode_check_freq[THR_H_PRED] = 851 cpi->mode_check_freq[THR_B_PRED] = speed_map(Speed, 852 mode_check_freq_map_vhbpred); 853 cpi->mode_check_freq[THR_NEW1] = speed_map(Speed, 854 mode_check_freq_map_new1); 855 cpi->mode_check_freq[THR_NEW2] = 856 cpi->mode_check_freq[THR_NEW3] = speed_map(Speed, 857 mode_check_freq_map_new2); 858 cpi->mode_check_freq[THR_SPLIT1] = speed_map(Speed, 859 mode_check_freq_map_split1); 860 cpi->mode_check_freq[THR_SPLIT2] = 861 cpi->mode_check_freq[THR_SPLIT3] = speed_map(Speed, 862 mode_check_freq_map_split2); 863 Speed = cpi->Speed; 864 switch (Mode) 865 { 866#if !(CONFIG_REALTIME_ONLY) 867 case 0: /* best quality mode */ 868 sf->first_step = 0; 869 sf->max_step_search_steps = MAX_MVSEARCH_STEPS; 870 break; 871 case 1: 872 case 3: 873 if (Speed > 0) 874 { 875 /* Disable coefficient optimization above speed 0 */ 876 sf->optimize_coefficients = 0; 877 sf->use_fastquant_for_pick = 1; 878 sf->no_skip_block4x4_search = 0; 879 880 sf->first_step = 1; 881 } 882 883 if (Speed > 2) 884 { 885 sf->improved_quant = 0; 886 sf->improved_dct = 0; 887 888 /* Only do recode loop on key frames, golden frames and 889 * alt ref frames 890 */ 891 sf->recode_loop = 2; 892 893 } 894 895 if (Speed > 3) 896 { 897 sf->auto_filter = 1; 898 sf->recode_loop = 0; /* recode loop off */ 899 sf->RD = 0; /* Turn rd off */ 900 901 } 902 903 if (Speed > 4) 904 { 905 sf->auto_filter = 0; /* Faster selection of loop filter */ 906 } 907 908 break; 909#endif 910 case 2: 911 sf->optimize_coefficients = 0; 912 sf->recode_loop = 0; 913 sf->auto_filter = 1; 914 sf->iterative_sub_pixel = 1; 915 sf->search_method = NSTEP; 916 917 if (Speed > 0) 918 { 919 sf->improved_quant = 0; 920 sf->improved_dct = 0; 921 922 sf->use_fastquant_for_pick = 1; 923 sf->no_skip_block4x4_search = 0; 924 sf->first_step = 1; 925 } 926 927 if (Speed > 2) 928 sf->auto_filter = 0; /* Faster selection of loop filter */ 929 930 if (Speed > 3) 931 { 932 sf->RD = 0; 933 sf->auto_filter = 1; 934 } 935 936 if (Speed > 4) 937 { 938 sf->auto_filter = 0; /* Faster selection of loop filter */ 939 sf->search_method = HEX; 940 sf->iterative_sub_pixel = 0; 941 } 942 943 if (Speed > 6) 944 { 945 unsigned int sum = 0; 946 unsigned int total_mbs = cm->MBs; 947 int thresh; 948 unsigned int total_skip; 949 950 int min = 2000; 951 952 if (cpi->oxcf.encode_breakout > 2000) 953 min = cpi->oxcf.encode_breakout; 954 955 min >>= 7; 956 957 for (i = 0; i < min; i++) 958 { 959 sum += cpi->mb.error_bins[i]; 960 } 961 962 total_skip = sum; 963 sum = 0; 964 965 /* i starts from 2 to make sure thresh started from 2048 */ 966 for (; i < 1024; i++) 967 { 968 sum += cpi->mb.error_bins[i]; 969 970 if (10 * sum >= (unsigned int)(cpi->Speed - 6)*(total_mbs - total_skip)) 971 break; 972 } 973 974 i--; 975 thresh = (i << 7); 976 977 if (thresh < 2000) 978 thresh = 2000; 979 980 if (ref_frames > 1) 981 { 982 sf->thresh_mult[THR_NEW1 ] = thresh; 983 sf->thresh_mult[THR_NEAREST1 ] = thresh >> 1; 984 sf->thresh_mult[THR_NEAR1 ] = thresh >> 1; 985 } 986 987 if (ref_frames > 2) 988 { 989 sf->thresh_mult[THR_NEW2] = thresh << 1; 990 sf->thresh_mult[THR_NEAREST2 ] = thresh; 991 sf->thresh_mult[THR_NEAR2 ] = thresh; 992 } 993 994 if (ref_frames > 3) 995 { 996 sf->thresh_mult[THR_NEW3] = thresh << 1; 997 sf->thresh_mult[THR_NEAREST3 ] = thresh; 998 sf->thresh_mult[THR_NEAR3 ] = thresh; 999 } 1000 1001 sf->improved_mv_pred = 0; 1002 } 1003 1004 if (Speed > 8) 1005 sf->quarter_pixel_search = 0; 1006 1007 if(cm->version == 0) 1008 { 1009 cm->filter_type = NORMAL_LOOPFILTER; 1010 1011 if (Speed >= 14) 1012 cm->filter_type = SIMPLE_LOOPFILTER; 1013 } 1014 else 1015 { 1016 cm->filter_type = SIMPLE_LOOPFILTER; 1017 } 1018 1019 /* This has a big hit on quality. Last resort */ 1020 if (Speed >= 15) 1021 sf->half_pixel_search = 0; 1022 1023 vpx_memset(cpi->mb.error_bins, 0, sizeof(cpi->mb.error_bins)); 1024 1025 }; /* switch */ 1026 1027 /* Slow quant, dct and trellis not worthwhile for first pass 1028 * so make sure they are always turned off. 1029 */ 1030 if ( cpi->pass == 1 ) 1031 { 1032 sf->improved_quant = 0; 1033 sf->optimize_coefficients = 0; 1034 sf->improved_dct = 0; 1035 } 1036 1037 if (cpi->sf.search_method == NSTEP) 1038 { 1039 vp8_init3smotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride); 1040 } 1041 else if (cpi->sf.search_method == DIAMOND) 1042 { 1043 vp8_init_dsmotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride); 1044 } 1045 1046 if (cpi->sf.improved_dct) 1047 { 1048 cpi->mb.short_fdct8x4 = vp8_short_fdct8x4; 1049 cpi->mb.short_fdct4x4 = vp8_short_fdct4x4; 1050 } 1051 else 1052 { 1053 /* No fast FDCT defined for any platform at this time. */ 1054 cpi->mb.short_fdct8x4 = vp8_short_fdct8x4; 1055 cpi->mb.short_fdct4x4 = vp8_short_fdct4x4; 1056 } 1057 1058 cpi->mb.short_walsh4x4 = vp8_short_walsh4x4; 1059 1060 if (cpi->sf.improved_quant) 1061 { 1062 cpi->mb.quantize_b = vp8_regular_quantize_b; 1063 cpi->mb.quantize_b_pair = vp8_regular_quantize_b_pair; 1064 } 1065 else 1066 { 1067 cpi->mb.quantize_b = vp8_fast_quantize_b; 1068 cpi->mb.quantize_b_pair = vp8_fast_quantize_b_pair; 1069 } 1070 if (cpi->sf.improved_quant != last_improved_quant) 1071 vp8cx_init_quantizer(cpi); 1072 1073 if (cpi->sf.iterative_sub_pixel == 1) 1074 { 1075 cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step_iteratively; 1076 } 1077 else if (cpi->sf.quarter_pixel_search) 1078 { 1079 cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step; 1080 } 1081 else if (cpi->sf.half_pixel_search) 1082 { 1083 cpi->find_fractional_mv_step = vp8_find_best_half_pixel_step; 1084 } 1085 else 1086 { 1087 cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step; 1088 } 1089 1090 if (cpi->sf.optimize_coefficients == 1 && cpi->pass!=1) 1091 cpi->mb.optimize = 1; 1092 else 1093 cpi->mb.optimize = 0; 1094 1095 if (cpi->common.full_pixel) 1096 cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step; 1097 1098#ifdef SPEEDSTATS 1099 frames_at_speed[cpi->Speed]++; 1100#endif 1101} 1102#undef GOOD 1103#undef RT 1104 1105static void alloc_raw_frame_buffers(VP8_COMP *cpi) 1106{ 1107#if VP8_TEMPORAL_ALT_REF 1108 int width = (cpi->oxcf.Width + 15) & ~15; 1109 int height = (cpi->oxcf.Height + 15) & ~15; 1110#endif 1111 1112 cpi->lookahead = vp8_lookahead_init(cpi->oxcf.Width, cpi->oxcf.Height, 1113 cpi->oxcf.lag_in_frames); 1114 if(!cpi->lookahead) 1115 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR, 1116 "Failed to allocate lag buffers"); 1117 1118#if VP8_TEMPORAL_ALT_REF 1119 1120 if (vp8_yv12_alloc_frame_buffer(&cpi->alt_ref_buffer, 1121 width, height, VP8BORDERINPIXELS)) 1122 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR, 1123 "Failed to allocate altref buffer"); 1124 1125#endif 1126} 1127 1128 1129static void dealloc_raw_frame_buffers(VP8_COMP *cpi) 1130{ 1131#if VP8_TEMPORAL_ALT_REF 1132 vp8_yv12_de_alloc_frame_buffer(&cpi->alt_ref_buffer); 1133#endif 1134 vp8_lookahead_destroy(cpi->lookahead); 1135} 1136 1137 1138static int vp8_alloc_partition_data(VP8_COMP *cpi) 1139{ 1140 vpx_free(cpi->mb.pip); 1141 1142 cpi->mb.pip = vpx_calloc((cpi->common.mb_cols + 1) * 1143 (cpi->common.mb_rows + 1), 1144 sizeof(PARTITION_INFO)); 1145 if(!cpi->mb.pip) 1146 return 1; 1147 1148 cpi->mb.pi = cpi->mb.pip + cpi->common.mode_info_stride + 1; 1149 1150 return 0; 1151} 1152 1153void vp8_alloc_compressor_data(VP8_COMP *cpi) 1154{ 1155 VP8_COMMON *cm = & cpi->common; 1156 1157 int width = cm->Width; 1158 int height = cm->Height; 1159 1160 if (vp8_alloc_frame_buffers(cm, width, height)) 1161 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR, 1162 "Failed to allocate frame buffers"); 1163 1164 if (vp8_alloc_partition_data(cpi)) 1165 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR, 1166 "Failed to allocate partition data"); 1167 1168 1169 if ((width & 0xf) != 0) 1170 width += 16 - (width & 0xf); 1171 1172 if ((height & 0xf) != 0) 1173 height += 16 - (height & 0xf); 1174 1175 1176 if (vp8_yv12_alloc_frame_buffer(&cpi->pick_lf_lvl_frame, 1177 width, height, VP8BORDERINPIXELS)) 1178 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR, 1179 "Failed to allocate last frame buffer"); 1180 1181 if (vp8_yv12_alloc_frame_buffer(&cpi->scaled_source, 1182 width, height, VP8BORDERINPIXELS)) 1183 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR, 1184 "Failed to allocate scaled source buffer"); 1185 1186 vpx_free(cpi->tok); 1187 1188 { 1189#if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING 1190 unsigned int tokens = 8 * 24 * 16; /* one MB for each thread */ 1191#else 1192 unsigned int tokens = cm->mb_rows * cm->mb_cols * 24 * 16; 1193#endif 1194 CHECK_MEM_ERROR(cpi->tok, vpx_calloc(tokens, sizeof(*cpi->tok))); 1195 } 1196 1197 /* Data used for real time vc mode to see if gf needs refreshing */ 1198 cpi->zeromv_count = 0; 1199 1200 1201 /* Structures used to monitor GF usage */ 1202 vpx_free(cpi->gf_active_flags); 1203 CHECK_MEM_ERROR(cpi->gf_active_flags, 1204 vpx_calloc(sizeof(*cpi->gf_active_flags), 1205 cm->mb_rows * cm->mb_cols)); 1206 cpi->gf_active_count = cm->mb_rows * cm->mb_cols; 1207 1208 vpx_free(cpi->mb_activity_map); 1209 CHECK_MEM_ERROR(cpi->mb_activity_map, 1210 vpx_calloc(sizeof(*cpi->mb_activity_map), 1211 cm->mb_rows * cm->mb_cols)); 1212 1213 /* allocate memory for storing last frame's MVs for MV prediction. */ 1214 vpx_free(cpi->lfmv); 1215 CHECK_MEM_ERROR(cpi->lfmv, vpx_calloc((cm->mb_rows+2) * (cm->mb_cols+2), 1216 sizeof(*cpi->lfmv))); 1217 vpx_free(cpi->lf_ref_frame_sign_bias); 1218 CHECK_MEM_ERROR(cpi->lf_ref_frame_sign_bias, 1219 vpx_calloc((cm->mb_rows+2) * (cm->mb_cols+2), 1220 sizeof(*cpi->lf_ref_frame_sign_bias))); 1221 vpx_free(cpi->lf_ref_frame); 1222 CHECK_MEM_ERROR(cpi->lf_ref_frame, 1223 vpx_calloc((cm->mb_rows+2) * (cm->mb_cols+2), 1224 sizeof(*cpi->lf_ref_frame))); 1225 1226 /* Create the encoder segmentation map and set all entries to 0 */ 1227 vpx_free(cpi->segmentation_map); 1228 CHECK_MEM_ERROR(cpi->segmentation_map, 1229 vpx_calloc(cm->mb_rows * cm->mb_cols, 1230 sizeof(*cpi->segmentation_map))); 1231 cpi->cyclic_refresh_mode_index = 0; 1232 vpx_free(cpi->active_map); 1233 CHECK_MEM_ERROR(cpi->active_map, 1234 vpx_calloc(cm->mb_rows * cm->mb_cols, 1235 sizeof(*cpi->active_map))); 1236 vpx_memset(cpi->active_map , 1, (cm->mb_rows * cm->mb_cols)); 1237 1238#if CONFIG_MULTITHREAD 1239 if (width < 640) 1240 cpi->mt_sync_range = 1; 1241 else if (width <= 1280) 1242 cpi->mt_sync_range = 4; 1243 else if (width <= 2560) 1244 cpi->mt_sync_range = 8; 1245 else 1246 cpi->mt_sync_range = 16; 1247 1248 if (cpi->oxcf.multi_threaded > 1) 1249 { 1250 vpx_free(cpi->mt_current_mb_col); 1251 CHECK_MEM_ERROR(cpi->mt_current_mb_col, 1252 vpx_malloc(sizeof(*cpi->mt_current_mb_col) * cm->mb_rows)); 1253 } 1254 1255#endif 1256 1257 vpx_free(cpi->tplist); 1258 CHECK_MEM_ERROR(cpi->tplist, vpx_malloc(sizeof(TOKENLIST) * cm->mb_rows)); 1259} 1260 1261 1262/* Quant MOD */ 1263static const int q_trans[] = 1264{ 1265 0, 1, 2, 3, 4, 5, 7, 8, 1266 9, 10, 12, 13, 15, 17, 18, 19, 1267 20, 21, 23, 24, 25, 26, 27, 28, 1268 29, 30, 31, 33, 35, 37, 39, 41, 1269 43, 45, 47, 49, 51, 53, 55, 57, 1270 59, 61, 64, 67, 70, 73, 76, 79, 1271 82, 85, 88, 91, 94, 97, 100, 103, 1272 106, 109, 112, 115, 118, 121, 124, 127, 1273}; 1274 1275int vp8_reverse_trans(int x) 1276{ 1277 int i; 1278 1279 for (i = 0; i < 64; i++) 1280 if (q_trans[i] >= x) 1281 return i; 1282 1283 return 63; 1284} 1285void vp8_new_framerate(VP8_COMP *cpi, double framerate) 1286{ 1287 if(framerate < .1) 1288 framerate = 30; 1289 1290 cpi->framerate = framerate; 1291 cpi->output_framerate = framerate; 1292 cpi->per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth / 1293 cpi->output_framerate); 1294 cpi->av_per_frame_bandwidth = cpi->per_frame_bandwidth; 1295 cpi->min_frame_bandwidth = (int)(cpi->av_per_frame_bandwidth * 1296 cpi->oxcf.two_pass_vbrmin_section / 100); 1297 1298 /* Set Maximum gf/arf interval */ 1299 cpi->max_gf_interval = ((int)(cpi->output_framerate / 2.0) + 2); 1300 1301 if(cpi->max_gf_interval < 12) 1302 cpi->max_gf_interval = 12; 1303 1304 /* Extended interval for genuinely static scenes */ 1305 cpi->twopass.static_scene_max_gf_interval = cpi->key_frame_frequency >> 1; 1306 1307 /* Special conditions when altr ref frame enabled in lagged compress mode */ 1308 if (cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames) 1309 { 1310 if (cpi->max_gf_interval > cpi->oxcf.lag_in_frames - 1) 1311 cpi->max_gf_interval = cpi->oxcf.lag_in_frames - 1; 1312 1313 if (cpi->twopass.static_scene_max_gf_interval > cpi->oxcf.lag_in_frames - 1) 1314 cpi->twopass.static_scene_max_gf_interval = cpi->oxcf.lag_in_frames - 1; 1315 } 1316 1317 if ( cpi->max_gf_interval > cpi->twopass.static_scene_max_gf_interval ) 1318 cpi->max_gf_interval = cpi->twopass.static_scene_max_gf_interval; 1319} 1320 1321 1322static void init_config(VP8_COMP *cpi, VP8_CONFIG *oxcf) 1323{ 1324 VP8_COMMON *cm = &cpi->common; 1325 1326 cpi->oxcf = *oxcf; 1327 1328 cpi->auto_gold = 1; 1329 cpi->auto_adjust_gold_quantizer = 1; 1330 1331 cm->version = oxcf->Version; 1332 vp8_setup_version(cm); 1333 1334 /* frame rate is not available on the first frame, as it's derived from 1335 * the observed timestamps. The actual value used here doesn't matter 1336 * too much, as it will adapt quickly. If the reciprocal of the timebase 1337 * seems like a reasonable framerate, then use that as a guess, otherwise 1338 * use 30. 1339 */ 1340 cpi->framerate = (double)(oxcf->timebase.den) / 1341 (double)(oxcf->timebase.num); 1342 1343 if (cpi->framerate > 180) 1344 cpi->framerate = 30; 1345 1346 cpi->ref_framerate = cpi->framerate; 1347 1348 /* change includes all joint functionality */ 1349 vp8_change_config(cpi, oxcf); 1350 1351 /* Initialize active best and worst q and average q values. */ 1352 cpi->active_worst_quality = cpi->oxcf.worst_allowed_q; 1353 cpi->active_best_quality = cpi->oxcf.best_allowed_q; 1354 cpi->avg_frame_qindex = cpi->oxcf.worst_allowed_q; 1355 1356 /* Initialise the starting buffer levels */ 1357 cpi->buffer_level = cpi->oxcf.starting_buffer_level; 1358 cpi->bits_off_target = cpi->oxcf.starting_buffer_level; 1359 1360 cpi->rolling_target_bits = cpi->av_per_frame_bandwidth; 1361 cpi->rolling_actual_bits = cpi->av_per_frame_bandwidth; 1362 cpi->long_rolling_target_bits = cpi->av_per_frame_bandwidth; 1363 cpi->long_rolling_actual_bits = cpi->av_per_frame_bandwidth; 1364 1365 cpi->total_actual_bits = 0; 1366 cpi->total_target_vs_actual = 0; 1367 1368 /* Temporal scalabilty */ 1369 if (cpi->oxcf.number_of_layers > 1) 1370 { 1371 unsigned int i; 1372 double prev_layer_framerate=0; 1373 1374 for (i=0; i<cpi->oxcf.number_of_layers; i++) 1375 { 1376 init_temporal_layer_context(cpi, oxcf, i, prev_layer_framerate); 1377 prev_layer_framerate = cpi->output_framerate / 1378 cpi->oxcf.rate_decimator[i]; 1379 } 1380 } 1381 1382#if VP8_TEMPORAL_ALT_REF 1383 { 1384 int i; 1385 1386 cpi->fixed_divide[0] = 0; 1387 1388 for (i = 1; i < 512; i++) 1389 cpi->fixed_divide[i] = 0x80000 / i; 1390 } 1391#endif 1392} 1393 1394static void update_layer_contexts (VP8_COMP *cpi) 1395{ 1396 VP8_CONFIG *oxcf = &cpi->oxcf; 1397 1398 /* Update snapshots of the layer contexts to reflect new parameters */ 1399 if (oxcf->number_of_layers > 1) 1400 { 1401 unsigned int i; 1402 double prev_layer_framerate=0; 1403 1404 assert(oxcf->number_of_layers <= VPX_TS_MAX_LAYERS); 1405 for (i=0; i<oxcf->number_of_layers; i++) 1406 { 1407 LAYER_CONTEXT *lc = &cpi->layer_context[i]; 1408 1409 lc->framerate = 1410 cpi->ref_framerate / oxcf->rate_decimator[i]; 1411 lc->target_bandwidth = oxcf->target_bitrate[i] * 1000; 1412 1413 lc->starting_buffer_level = rescale( 1414 (int)oxcf->starting_buffer_level_in_ms, 1415 lc->target_bandwidth, 1000); 1416 1417 if (oxcf->optimal_buffer_level == 0) 1418 lc->optimal_buffer_level = lc->target_bandwidth / 8; 1419 else 1420 lc->optimal_buffer_level = rescale( 1421 (int)oxcf->optimal_buffer_level_in_ms, 1422 lc->target_bandwidth, 1000); 1423 1424 if (oxcf->maximum_buffer_size == 0) 1425 lc->maximum_buffer_size = lc->target_bandwidth / 8; 1426 else 1427 lc->maximum_buffer_size = rescale( 1428 (int)oxcf->maximum_buffer_size_in_ms, 1429 lc->target_bandwidth, 1000); 1430 1431 /* Work out the average size of a frame within this layer */ 1432 if (i > 0) 1433 lc->avg_frame_size_for_layer = 1434 (int)((oxcf->target_bitrate[i] - 1435 oxcf->target_bitrate[i-1]) * 1000 / 1436 (lc->framerate - prev_layer_framerate)); 1437 1438 prev_layer_framerate = lc->framerate; 1439 } 1440 } 1441} 1442 1443void vp8_change_config(VP8_COMP *cpi, VP8_CONFIG *oxcf) 1444{ 1445 VP8_COMMON *cm = &cpi->common; 1446 int last_w, last_h, prev_number_of_layers; 1447 1448 if (!cpi) 1449 return; 1450 1451 if (!oxcf) 1452 return; 1453 1454#if CONFIG_MULTITHREAD 1455 /* wait for the last picture loopfilter thread done */ 1456 if (cpi->b_lpf_running) 1457 { 1458 sem_wait(&cpi->h_event_end_lpf); 1459 cpi->b_lpf_running = 0; 1460 } 1461#endif 1462 1463 if (cm->version != oxcf->Version) 1464 { 1465 cm->version = oxcf->Version; 1466 vp8_setup_version(cm); 1467 } 1468 1469 last_w = cpi->oxcf.Width; 1470 last_h = cpi->oxcf.Height; 1471 prev_number_of_layers = cpi->oxcf.number_of_layers; 1472 1473 cpi->oxcf = *oxcf; 1474 1475 switch (cpi->oxcf.Mode) 1476 { 1477 1478 case MODE_REALTIME: 1479 cpi->pass = 0; 1480 cpi->compressor_speed = 2; 1481 1482 if (cpi->oxcf.cpu_used < -16) 1483 { 1484 cpi->oxcf.cpu_used = -16; 1485 } 1486 1487 if (cpi->oxcf.cpu_used > 16) 1488 cpi->oxcf.cpu_used = 16; 1489 1490 break; 1491 1492 case MODE_GOODQUALITY: 1493 cpi->pass = 0; 1494 cpi->compressor_speed = 1; 1495 1496 if (cpi->oxcf.cpu_used < -5) 1497 { 1498 cpi->oxcf.cpu_used = -5; 1499 } 1500 1501 if (cpi->oxcf.cpu_used > 5) 1502 cpi->oxcf.cpu_used = 5; 1503 1504 break; 1505 1506 case MODE_BESTQUALITY: 1507 cpi->pass = 0; 1508 cpi->compressor_speed = 0; 1509 break; 1510 1511 case MODE_FIRSTPASS: 1512 cpi->pass = 1; 1513 cpi->compressor_speed = 1; 1514 break; 1515 case MODE_SECONDPASS: 1516 cpi->pass = 2; 1517 cpi->compressor_speed = 1; 1518 1519 if (cpi->oxcf.cpu_used < -5) 1520 { 1521 cpi->oxcf.cpu_used = -5; 1522 } 1523 1524 if (cpi->oxcf.cpu_used > 5) 1525 cpi->oxcf.cpu_used = 5; 1526 1527 break; 1528 case MODE_SECONDPASS_BEST: 1529 cpi->pass = 2; 1530 cpi->compressor_speed = 0; 1531 break; 1532 } 1533 1534 if (cpi->pass == 0) 1535 cpi->auto_worst_q = 1; 1536 1537 cpi->oxcf.worst_allowed_q = q_trans[oxcf->worst_allowed_q]; 1538 cpi->oxcf.best_allowed_q = q_trans[oxcf->best_allowed_q]; 1539 cpi->oxcf.cq_level = q_trans[cpi->oxcf.cq_level]; 1540 1541 if (oxcf->fixed_q >= 0) 1542 { 1543 if (oxcf->worst_allowed_q < 0) 1544 cpi->oxcf.fixed_q = q_trans[0]; 1545 else 1546 cpi->oxcf.fixed_q = q_trans[oxcf->worst_allowed_q]; 1547 1548 if (oxcf->alt_q < 0) 1549 cpi->oxcf.alt_q = q_trans[0]; 1550 else 1551 cpi->oxcf.alt_q = q_trans[oxcf->alt_q]; 1552 1553 if (oxcf->key_q < 0) 1554 cpi->oxcf.key_q = q_trans[0]; 1555 else 1556 cpi->oxcf.key_q = q_trans[oxcf->key_q]; 1557 1558 if (oxcf->gold_q < 0) 1559 cpi->oxcf.gold_q = q_trans[0]; 1560 else 1561 cpi->oxcf.gold_q = q_trans[oxcf->gold_q]; 1562 1563 } 1564 1565 cpi->baseline_gf_interval = 1566 cpi->oxcf.alt_freq ? cpi->oxcf.alt_freq : DEFAULT_GF_INTERVAL; 1567 1568 cpi->ref_frame_flags = VP8_ALTR_FRAME | VP8_GOLD_FRAME | VP8_LAST_FRAME; 1569 1570 cm->refresh_golden_frame = 0; 1571 cm->refresh_last_frame = 1; 1572 cm->refresh_entropy_probs = 1; 1573 1574#if (CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING) 1575 cpi->oxcf.token_partitions = 3; 1576#endif 1577 1578 if (cpi->oxcf.token_partitions >= 0 && cpi->oxcf.token_partitions <= 3) 1579 cm->multi_token_partition = 1580 (TOKEN_PARTITION) cpi->oxcf.token_partitions; 1581 1582 setup_features(cpi); 1583 1584 { 1585 int i; 1586 1587 for (i = 0; i < MAX_MB_SEGMENTS; i++) 1588 cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout; 1589 } 1590 1591 /* At the moment the first order values may not be > MAXQ */ 1592 if (cpi->oxcf.fixed_q > MAXQ) 1593 cpi->oxcf.fixed_q = MAXQ; 1594 1595 /* local file playback mode == really big buffer */ 1596 if (cpi->oxcf.end_usage == USAGE_LOCAL_FILE_PLAYBACK) 1597 { 1598 cpi->oxcf.starting_buffer_level = 60000; 1599 cpi->oxcf.optimal_buffer_level = 60000; 1600 cpi->oxcf.maximum_buffer_size = 240000; 1601 cpi->oxcf.starting_buffer_level_in_ms = 60000; 1602 cpi->oxcf.optimal_buffer_level_in_ms = 60000; 1603 cpi->oxcf.maximum_buffer_size_in_ms = 240000; 1604 } 1605 1606 /* Convert target bandwidth from Kbit/s to Bit/s */ 1607 cpi->oxcf.target_bandwidth *= 1000; 1608 1609 cpi->oxcf.starting_buffer_level = 1610 rescale((int)cpi->oxcf.starting_buffer_level, 1611 cpi->oxcf.target_bandwidth, 1000); 1612 1613 /* Set or reset optimal and maximum buffer levels. */ 1614 if (cpi->oxcf.optimal_buffer_level == 0) 1615 cpi->oxcf.optimal_buffer_level = cpi->oxcf.target_bandwidth / 8; 1616 else 1617 cpi->oxcf.optimal_buffer_level = 1618 rescale((int)cpi->oxcf.optimal_buffer_level, 1619 cpi->oxcf.target_bandwidth, 1000); 1620 1621 if (cpi->oxcf.maximum_buffer_size == 0) 1622 cpi->oxcf.maximum_buffer_size = cpi->oxcf.target_bandwidth / 8; 1623 else 1624 cpi->oxcf.maximum_buffer_size = 1625 rescale((int)cpi->oxcf.maximum_buffer_size, 1626 cpi->oxcf.target_bandwidth, 1000); 1627 // Under a configuration change, where maximum_buffer_size may change, 1628 // keep buffer level clipped to the maximum allowed buffer size. 1629 if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size) { 1630 cpi->bits_off_target = cpi->oxcf.maximum_buffer_size; 1631 cpi->buffer_level = cpi->bits_off_target; 1632 } 1633 1634 /* Set up frame rate and related parameters rate control values. */ 1635 vp8_new_framerate(cpi, cpi->framerate); 1636 1637 /* Set absolute upper and lower quality limits */ 1638 cpi->worst_quality = cpi->oxcf.worst_allowed_q; 1639 cpi->best_quality = cpi->oxcf.best_allowed_q; 1640 1641 /* active values should only be modified if out of new range */ 1642 if (cpi->active_worst_quality > cpi->oxcf.worst_allowed_q) 1643 { 1644 cpi->active_worst_quality = cpi->oxcf.worst_allowed_q; 1645 } 1646 /* less likely */ 1647 else if (cpi->active_worst_quality < cpi->oxcf.best_allowed_q) 1648 { 1649 cpi->active_worst_quality = cpi->oxcf.best_allowed_q; 1650 } 1651 if (cpi->active_best_quality < cpi->oxcf.best_allowed_q) 1652 { 1653 cpi->active_best_quality = cpi->oxcf.best_allowed_q; 1654 } 1655 /* less likely */ 1656 else if (cpi->active_best_quality > cpi->oxcf.worst_allowed_q) 1657 { 1658 cpi->active_best_quality = cpi->oxcf.worst_allowed_q; 1659 } 1660 1661 cpi->buffered_mode = cpi->oxcf.optimal_buffer_level > 0; 1662 1663 cpi->cq_target_quality = cpi->oxcf.cq_level; 1664 1665 /* Only allow dropped frames in buffered mode */ 1666 cpi->drop_frames_allowed = cpi->oxcf.allow_df && cpi->buffered_mode; 1667 1668 cpi->target_bandwidth = cpi->oxcf.target_bandwidth; 1669 1670 // Check if the number of temporal layers has changed, and if so reset the 1671 // pattern counter and set/initialize the temporal layer context for the 1672 // new layer configuration. 1673 if (cpi->oxcf.number_of_layers != prev_number_of_layers) 1674 { 1675 // If the number of temporal layers are changed we must start at the 1676 // base of the pattern cycle, so reset temporal_pattern_counter. 1677 cpi->temporal_pattern_counter = 0; 1678 reset_temporal_layer_change(cpi, oxcf, prev_number_of_layers); 1679 } 1680 1681 cm->Width = cpi->oxcf.Width; 1682 cm->Height = cpi->oxcf.Height; 1683 1684 /* TODO(jkoleszar): if an internal spatial resampling is active, 1685 * and we downsize the input image, maybe we should clear the 1686 * internal scale immediately rather than waiting for it to 1687 * correct. 1688 */ 1689 1690 /* VP8 sharpness level mapping 0-7 (vs 0-10 in general VPx dialogs) */ 1691 if (cpi->oxcf.Sharpness > 7) 1692 cpi->oxcf.Sharpness = 7; 1693 1694 cm->sharpness_level = cpi->oxcf.Sharpness; 1695 1696 if (cm->horiz_scale != NORMAL || cm->vert_scale != NORMAL) 1697 { 1698 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs); 1699 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs); 1700 1701 Scale2Ratio(cm->horiz_scale, &hr, &hs); 1702 Scale2Ratio(cm->vert_scale, &vr, &vs); 1703 1704 /* always go to the next whole number */ 1705 cm->Width = (hs - 1 + cpi->oxcf.Width * hr) / hs; 1706 cm->Height = (vs - 1 + cpi->oxcf.Height * vr) / vs; 1707 } 1708 1709 if (last_w != cpi->oxcf.Width || last_h != cpi->oxcf.Height) 1710 cpi->force_next_frame_intra = 1; 1711 1712 if (((cm->Width + 15) & 0xfffffff0) != 1713 cm->yv12_fb[cm->lst_fb_idx].y_width || 1714 ((cm->Height + 15) & 0xfffffff0) != 1715 cm->yv12_fb[cm->lst_fb_idx].y_height || 1716 cm->yv12_fb[cm->lst_fb_idx].y_width == 0) 1717 { 1718 dealloc_raw_frame_buffers(cpi); 1719 alloc_raw_frame_buffers(cpi); 1720 vp8_alloc_compressor_data(cpi); 1721 } 1722 1723 if (cpi->oxcf.fixed_q >= 0) 1724 { 1725 cpi->last_q[0] = cpi->oxcf.fixed_q; 1726 cpi->last_q[1] = cpi->oxcf.fixed_q; 1727 } 1728 1729 cpi->Speed = cpi->oxcf.cpu_used; 1730 1731 /* force to allowlag to 0 if lag_in_frames is 0; */ 1732 if (cpi->oxcf.lag_in_frames == 0) 1733 { 1734 cpi->oxcf.allow_lag = 0; 1735 } 1736 /* Limit on lag buffers as these are not currently dynamically allocated */ 1737 else if (cpi->oxcf.lag_in_frames > MAX_LAG_BUFFERS) 1738 cpi->oxcf.lag_in_frames = MAX_LAG_BUFFERS; 1739 1740 /* YX Temp */ 1741 cpi->alt_ref_source = NULL; 1742 cpi->is_src_frame_alt_ref = 0; 1743 1744#if CONFIG_TEMPORAL_DENOISING 1745 if (cpi->oxcf.noise_sensitivity) 1746 { 1747 if (!cpi->denoiser.yv12_mc_running_avg.buffer_alloc) 1748 { 1749 int width = (cpi->oxcf.Width + 15) & ~15; 1750 int height = (cpi->oxcf.Height + 15) & ~15; 1751 vp8_denoiser_allocate(&cpi->denoiser, width, height); 1752 } 1753 } 1754#endif 1755 1756#if 0 1757 /* Experimental RD Code */ 1758 cpi->frame_distortion = 0; 1759 cpi->last_frame_distortion = 0; 1760#endif 1761 1762} 1763 1764#define M_LOG2_E 0.693147180559945309417 1765#define log2f(x) (log (x) / (float) M_LOG2_E) 1766static void cal_mvsadcosts(int *mvsadcost[2]) 1767{ 1768 int i = 1; 1769 1770 mvsadcost [0] [0] = 300; 1771 mvsadcost [1] [0] = 300; 1772 1773 do 1774 { 1775 double z = 256 * (2 * (log2f(8 * i) + .6)); 1776 mvsadcost [0][i] = (int) z; 1777 mvsadcost [1][i] = (int) z; 1778 mvsadcost [0][-i] = (int) z; 1779 mvsadcost [1][-i] = (int) z; 1780 } 1781 while (++i <= mvfp_max); 1782} 1783 1784struct VP8_COMP* vp8_create_compressor(VP8_CONFIG *oxcf) 1785{ 1786 int i; 1787 1788 VP8_COMP *cpi; 1789 VP8_COMMON *cm; 1790 1791 cpi = vpx_memalign(32, sizeof(VP8_COMP)); 1792 /* Check that the CPI instance is valid */ 1793 if (!cpi) 1794 return 0; 1795 1796 cm = &cpi->common; 1797 1798 vpx_memset(cpi, 0, sizeof(VP8_COMP)); 1799 1800 if (setjmp(cm->error.jmp)) 1801 { 1802 cpi->common.error.setjmp = 0; 1803 vp8_remove_compressor(&cpi); 1804 return 0; 1805 } 1806 1807 cpi->common.error.setjmp = 1; 1808 1809 CHECK_MEM_ERROR(cpi->mb.ss, vpx_calloc(sizeof(search_site), (MAX_MVSEARCH_STEPS * 8) + 1)); 1810 1811 vp8_create_common(&cpi->common); 1812 1813 init_config(cpi, oxcf); 1814 1815 memcpy(cpi->base_skip_false_prob, vp8cx_base_skip_false_prob, sizeof(vp8cx_base_skip_false_prob)); 1816 cpi->common.current_video_frame = 0; 1817 cpi->temporal_pattern_counter = 0; 1818 cpi->kf_overspend_bits = 0; 1819 cpi->kf_bitrate_adjustment = 0; 1820 cpi->frames_till_gf_update_due = 0; 1821 cpi->gf_overspend_bits = 0; 1822 cpi->non_gf_bitrate_adjustment = 0; 1823 cpi->prob_last_coded = 128; 1824 cpi->prob_gf_coded = 128; 1825 cpi->prob_intra_coded = 63; 1826 1827 /* Prime the recent reference frame usage counters. 1828 * Hereafter they will be maintained as a sort of moving average 1829 */ 1830 cpi->recent_ref_frame_usage[INTRA_FRAME] = 1; 1831 cpi->recent_ref_frame_usage[LAST_FRAME] = 1; 1832 cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1; 1833 cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1; 1834 1835 /* Set reference frame sign bias for ALTREF frame to 1 (for now) */ 1836 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1; 1837 1838 cpi->twopass.gf_decay_rate = 0; 1839 cpi->baseline_gf_interval = DEFAULT_GF_INTERVAL; 1840 1841 cpi->gold_is_last = 0 ; 1842 cpi->alt_is_last = 0 ; 1843 cpi->gold_is_alt = 0 ; 1844 1845 cpi->active_map_enabled = 0; 1846 1847#if 0 1848 /* Experimental code for lagged and one pass */ 1849 /* Initialise one_pass GF frames stats */ 1850 /* Update stats used for GF selection */ 1851 if (cpi->pass == 0) 1852 { 1853 cpi->one_pass_frame_index = 0; 1854 1855 for (i = 0; i < MAX_LAG_BUFFERS; i++) 1856 { 1857 cpi->one_pass_frame_stats[i].frames_so_far = 0; 1858 cpi->one_pass_frame_stats[i].frame_intra_error = 0.0; 1859 cpi->one_pass_frame_stats[i].frame_coded_error = 0.0; 1860 cpi->one_pass_frame_stats[i].frame_pcnt_inter = 0.0; 1861 cpi->one_pass_frame_stats[i].frame_pcnt_motion = 0.0; 1862 cpi->one_pass_frame_stats[i].frame_mvr = 0.0; 1863 cpi->one_pass_frame_stats[i].frame_mvr_abs = 0.0; 1864 cpi->one_pass_frame_stats[i].frame_mvc = 0.0; 1865 cpi->one_pass_frame_stats[i].frame_mvc_abs = 0.0; 1866 } 1867 } 1868#endif 1869 1870 /* Should we use the cyclic refresh method. 1871 * Currently this is tied to error resilliant mode 1872 */ 1873 cpi->cyclic_refresh_mode_enabled = cpi->oxcf.error_resilient_mode; 1874 cpi->cyclic_refresh_mode_max_mbs_perframe = (cpi->common.mb_rows * cpi->common.mb_cols) / 5; 1875 cpi->cyclic_refresh_mode_index = 0; 1876 cpi->cyclic_refresh_q = 32; 1877 1878 if (cpi->cyclic_refresh_mode_enabled) 1879 { 1880 CHECK_MEM_ERROR(cpi->cyclic_refresh_map, vpx_calloc((cpi->common.mb_rows * cpi->common.mb_cols), 1)); 1881 } 1882 else 1883 cpi->cyclic_refresh_map = (signed char *) NULL; 1884 1885#ifdef VP8_ENTROPY_STATS 1886 init_context_counters(); 1887#endif 1888 1889 /*Initialize the feed-forward activity masking.*/ 1890 cpi->activity_avg = 90<<12; 1891 1892 /* Give a sensible default for the first frame. */ 1893 cpi->frames_since_key = 8; 1894 cpi->key_frame_frequency = cpi->oxcf.key_freq; 1895 cpi->this_key_frame_forced = 0; 1896 cpi->next_key_frame_forced = 0; 1897 1898 cpi->source_alt_ref_pending = 0; 1899 cpi->source_alt_ref_active = 0; 1900 cpi->common.refresh_alt_ref_frame = 0; 1901 1902 cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS; 1903#if CONFIG_INTERNAL_STATS 1904 cpi->b_calculate_ssimg = 0; 1905 1906 cpi->count = 0; 1907 cpi->bytes = 0; 1908 1909 if (cpi->b_calculate_psnr) 1910 { 1911 cpi->total_sq_error = 0.0; 1912 cpi->total_sq_error2 = 0.0; 1913 cpi->total_y = 0.0; 1914 cpi->total_u = 0.0; 1915 cpi->total_v = 0.0; 1916 cpi->total = 0.0; 1917 cpi->totalp_y = 0.0; 1918 cpi->totalp_u = 0.0; 1919 cpi->totalp_v = 0.0; 1920 cpi->totalp = 0.0; 1921 cpi->tot_recode_hits = 0; 1922 cpi->summed_quality = 0; 1923 cpi->summed_weights = 0; 1924 } 1925 1926 if (cpi->b_calculate_ssimg) 1927 { 1928 cpi->total_ssimg_y = 0; 1929 cpi->total_ssimg_u = 0; 1930 cpi->total_ssimg_v = 0; 1931 cpi->total_ssimg_all = 0; 1932 } 1933 1934#endif 1935 1936 cpi->first_time_stamp_ever = 0x7FFFFFFF; 1937 1938 cpi->frames_till_gf_update_due = 0; 1939 cpi->key_frame_count = 1; 1940 1941 cpi->ni_av_qi = cpi->oxcf.worst_allowed_q; 1942 cpi->ni_tot_qi = 0; 1943 cpi->ni_frames = 0; 1944 cpi->total_byte_count = 0; 1945 1946 cpi->drop_frame = 0; 1947 1948 cpi->rate_correction_factor = 1.0; 1949 cpi->key_frame_rate_correction_factor = 1.0; 1950 cpi->gf_rate_correction_factor = 1.0; 1951 cpi->twopass.est_max_qcorrection_factor = 1.0; 1952 1953 for (i = 0; i < KEY_FRAME_CONTEXT; i++) 1954 { 1955 cpi->prior_key_frame_distance[i] = (int)cpi->output_framerate; 1956 } 1957 1958#ifdef OUTPUT_YUV_SRC 1959 yuv_file = fopen("bd.yuv", "ab"); 1960#endif 1961 1962#if 0 1963 framepsnr = fopen("framepsnr.stt", "a"); 1964 kf_list = fopen("kf_list.stt", "w"); 1965#endif 1966 1967 cpi->output_pkt_list = oxcf->output_pkt_list; 1968 1969#if !(CONFIG_REALTIME_ONLY) 1970 1971 if (cpi->pass == 1) 1972 { 1973 vp8_init_first_pass(cpi); 1974 } 1975 else if (cpi->pass == 2) 1976 { 1977 size_t packet_sz = sizeof(FIRSTPASS_STATS); 1978 int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz); 1979 1980 cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf; 1981 cpi->twopass.stats_in = cpi->twopass.stats_in_start; 1982 cpi->twopass.stats_in_end = (void*)((char *)cpi->twopass.stats_in 1983 + (packets - 1) * packet_sz); 1984 vp8_init_second_pass(cpi); 1985 } 1986 1987#endif 1988 1989 if (cpi->compressor_speed == 2) 1990 { 1991 cpi->avg_encode_time = 0; 1992 cpi->avg_pick_mode_time = 0; 1993 } 1994 1995 vp8_set_speed_features(cpi); 1996 1997 /* Set starting values of RD threshold multipliers (128 = *1) */ 1998 for (i = 0; i < MAX_MODES; i++) 1999 { 2000 cpi->mb.rd_thresh_mult[i] = 128; 2001 } 2002 2003#ifdef VP8_ENTROPY_STATS 2004 init_mv_ref_counts(); 2005#endif 2006 2007#if CONFIG_MULTITHREAD 2008 if(vp8cx_create_encoder_threads(cpi)) 2009 { 2010 vp8_remove_compressor(&cpi); 2011 return 0; 2012 } 2013#endif 2014 2015 cpi->fn_ptr[BLOCK_16X16].sdf = vp8_sad16x16; 2016 cpi->fn_ptr[BLOCK_16X16].vf = vp8_variance16x16; 2017 cpi->fn_ptr[BLOCK_16X16].svf = vp8_sub_pixel_variance16x16; 2018 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_h = vp8_variance_halfpixvar16x16_h; 2019 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_v = vp8_variance_halfpixvar16x16_v; 2020 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_hv = vp8_variance_halfpixvar16x16_hv; 2021 cpi->fn_ptr[BLOCK_16X16].sdx3f = vp8_sad16x16x3; 2022 cpi->fn_ptr[BLOCK_16X16].sdx8f = vp8_sad16x16x8; 2023 cpi->fn_ptr[BLOCK_16X16].sdx4df = vp8_sad16x16x4d; 2024 2025 cpi->fn_ptr[BLOCK_16X8].sdf = vp8_sad16x8; 2026 cpi->fn_ptr[BLOCK_16X8].vf = vp8_variance16x8; 2027 cpi->fn_ptr[BLOCK_16X8].svf = vp8_sub_pixel_variance16x8; 2028 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_h = NULL; 2029 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_v = NULL; 2030 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_hv = NULL; 2031 cpi->fn_ptr[BLOCK_16X8].sdx3f = vp8_sad16x8x3; 2032 cpi->fn_ptr[BLOCK_16X8].sdx8f = vp8_sad16x8x8; 2033 cpi->fn_ptr[BLOCK_16X8].sdx4df = vp8_sad16x8x4d; 2034 2035 cpi->fn_ptr[BLOCK_8X16].sdf = vp8_sad8x16; 2036 cpi->fn_ptr[BLOCK_8X16].vf = vp8_variance8x16; 2037 cpi->fn_ptr[BLOCK_8X16].svf = vp8_sub_pixel_variance8x16; 2038 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_h = NULL; 2039 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_v = NULL; 2040 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_hv = NULL; 2041 cpi->fn_ptr[BLOCK_8X16].sdx3f = vp8_sad8x16x3; 2042 cpi->fn_ptr[BLOCK_8X16].sdx8f = vp8_sad8x16x8; 2043 cpi->fn_ptr[BLOCK_8X16].sdx4df = vp8_sad8x16x4d; 2044 2045 cpi->fn_ptr[BLOCK_8X8].sdf = vp8_sad8x8; 2046 cpi->fn_ptr[BLOCK_8X8].vf = vp8_variance8x8; 2047 cpi->fn_ptr[BLOCK_8X8].svf = vp8_sub_pixel_variance8x8; 2048 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_h = NULL; 2049 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_v = NULL; 2050 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_hv = NULL; 2051 cpi->fn_ptr[BLOCK_8X8].sdx3f = vp8_sad8x8x3; 2052 cpi->fn_ptr[BLOCK_8X8].sdx8f = vp8_sad8x8x8; 2053 cpi->fn_ptr[BLOCK_8X8].sdx4df = vp8_sad8x8x4d; 2054 2055 cpi->fn_ptr[BLOCK_4X4].sdf = vp8_sad4x4; 2056 cpi->fn_ptr[BLOCK_4X4].vf = vp8_variance4x4; 2057 cpi->fn_ptr[BLOCK_4X4].svf = vp8_sub_pixel_variance4x4; 2058 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_h = NULL; 2059 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_v = NULL; 2060 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_hv = NULL; 2061 cpi->fn_ptr[BLOCK_4X4].sdx3f = vp8_sad4x4x3; 2062 cpi->fn_ptr[BLOCK_4X4].sdx8f = vp8_sad4x4x8; 2063 cpi->fn_ptr[BLOCK_4X4].sdx4df = vp8_sad4x4x4d; 2064 2065#if ARCH_X86 || ARCH_X86_64 2066 cpi->fn_ptr[BLOCK_16X16].copymem = vp8_copy32xn; 2067 cpi->fn_ptr[BLOCK_16X8].copymem = vp8_copy32xn; 2068 cpi->fn_ptr[BLOCK_8X16].copymem = vp8_copy32xn; 2069 cpi->fn_ptr[BLOCK_8X8].copymem = vp8_copy32xn; 2070 cpi->fn_ptr[BLOCK_4X4].copymem = vp8_copy32xn; 2071#endif 2072 2073 cpi->full_search_sad = vp8_full_search_sad; 2074 cpi->diamond_search_sad = vp8_diamond_search_sad; 2075 cpi->refining_search_sad = vp8_refining_search_sad; 2076 2077 /* make sure frame 1 is okay */ 2078 cpi->mb.error_bins[0] = cpi->common.MBs; 2079 2080 /* vp8cx_init_quantizer() is first called here. Add check in 2081 * vp8cx_frame_init_quantizer() so that vp8cx_init_quantizer is only 2082 * called later when needed. This will avoid unnecessary calls of 2083 * vp8cx_init_quantizer() for every frame. 2084 */ 2085 vp8cx_init_quantizer(cpi); 2086 2087 vp8_loop_filter_init(cm); 2088 2089 cpi->common.error.setjmp = 0; 2090 2091#if CONFIG_MULTI_RES_ENCODING 2092 2093 /* Calculate # of MBs in a row in lower-resolution level image. */ 2094 if (cpi->oxcf.mr_encoder_id > 0) 2095 vp8_cal_low_res_mb_cols(cpi); 2096 2097#endif 2098 2099 /* setup RD costs to MACROBLOCK struct */ 2100 2101 cpi->mb.mvcost[0] = &cpi->rd_costs.mvcosts[0][mv_max+1]; 2102 cpi->mb.mvcost[1] = &cpi->rd_costs.mvcosts[1][mv_max+1]; 2103 cpi->mb.mvsadcost[0] = &cpi->rd_costs.mvsadcosts[0][mvfp_max+1]; 2104 cpi->mb.mvsadcost[1] = &cpi->rd_costs.mvsadcosts[1][mvfp_max+1]; 2105 2106 cal_mvsadcosts(cpi->mb.mvsadcost); 2107 2108 cpi->mb.mbmode_cost = cpi->rd_costs.mbmode_cost; 2109 cpi->mb.intra_uv_mode_cost = cpi->rd_costs.intra_uv_mode_cost; 2110 cpi->mb.bmode_costs = cpi->rd_costs.bmode_costs; 2111 cpi->mb.inter_bmode_costs = cpi->rd_costs.inter_bmode_costs; 2112 cpi->mb.token_costs = cpi->rd_costs.token_costs; 2113 2114 /* setup block ptrs & offsets */ 2115 vp8_setup_block_ptrs(&cpi->mb); 2116 vp8_setup_block_dptrs(&cpi->mb.e_mbd); 2117 2118 return cpi; 2119} 2120 2121 2122void vp8_remove_compressor(VP8_COMP **ptr) 2123{ 2124 VP8_COMP *cpi = *ptr; 2125 2126 if (!cpi) 2127 return; 2128 2129 if (cpi && (cpi->common.current_video_frame > 0)) 2130 { 2131#if !(CONFIG_REALTIME_ONLY) 2132 2133 if (cpi->pass == 2) 2134 { 2135 vp8_end_second_pass(cpi); 2136 } 2137 2138#endif 2139 2140#ifdef VP8_ENTROPY_STATS 2141 print_context_counters(); 2142 print_tree_update_probs(); 2143 print_mode_context(); 2144#endif 2145 2146#if CONFIG_INTERNAL_STATS 2147 2148 if (cpi->pass != 1) 2149 { 2150 FILE *f = fopen("opsnr.stt", "a"); 2151 double time_encoded = (cpi->last_end_time_stamp_seen 2152 - cpi->first_time_stamp_ever) / 10000000.000; 2153 double total_encode_time = (cpi->time_receive_data + 2154 cpi->time_compress_data) / 1000.000; 2155 double dr = (double)cpi->bytes * 8.0 / 1000.0 / time_encoded; 2156 2157 if (cpi->b_calculate_psnr) 2158 { 2159 YV12_BUFFER_CONFIG *lst_yv12 = 2160 &cpi->common.yv12_fb[cpi->common.lst_fb_idx]; 2161 2162 if (cpi->oxcf.number_of_layers > 1) 2163 { 2164 int i; 2165 2166 fprintf(f, "Layer\tBitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\t" 2167 "GLPsnrP\tVPXSSIM\t\n"); 2168 for (i=0; i<(int)cpi->oxcf.number_of_layers; i++) 2169 { 2170 double dr = (double)cpi->bytes_in_layer[i] * 2171 8.0 / 1000.0 / time_encoded; 2172 double samples = 3.0 / 2 * cpi->frames_in_layer[i] * 2173 lst_yv12->y_width * lst_yv12->y_height; 2174 double total_psnr = 2175 vpx_sse_to_psnr(samples, 255.0, 2176 cpi->total_error2[i]); 2177 double total_psnr2 = 2178 vpx_sse_to_psnr(samples, 255.0, 2179 cpi->total_error2_p[i]); 2180 double total_ssim = 100 * pow(cpi->sum_ssim[i] / 2181 cpi->sum_weights[i], 8.0); 2182 2183 fprintf(f, "%5d\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t" 2184 "%7.3f\t%7.3f\n", 2185 i, dr, 2186 cpi->sum_psnr[i] / cpi->frames_in_layer[i], 2187 total_psnr, 2188 cpi->sum_psnr_p[i] / cpi->frames_in_layer[i], 2189 total_psnr2, total_ssim); 2190 } 2191 } 2192 else 2193 { 2194 double samples = 3.0 / 2 * cpi->count * 2195 lst_yv12->y_width * lst_yv12->y_height; 2196 double total_psnr = vpx_sse_to_psnr(samples, 255.0, 2197 cpi->total_sq_error); 2198 double total_psnr2 = vpx_sse_to_psnr(samples, 255.0, 2199 cpi->total_sq_error2); 2200 double total_ssim = 100 * pow(cpi->summed_quality / 2201 cpi->summed_weights, 8.0); 2202 2203 fprintf(f, "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\t" 2204 "GLPsnrP\tVPXSSIM\t Time(us)\n"); 2205 fprintf(f, "%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t" 2206 "%7.3f\t%8.0f\n", 2207 dr, cpi->total / cpi->count, total_psnr, 2208 cpi->totalp / cpi->count, total_psnr2, 2209 total_ssim, total_encode_time); 2210 } 2211 } 2212 2213 if (cpi->b_calculate_ssimg) 2214 { 2215 if (cpi->oxcf.number_of_layers > 1) 2216 { 2217 int i; 2218 2219 fprintf(f, "Layer\tBitRate\tSSIM_Y\tSSIM_U\tSSIM_V\tSSIM_A\t" 2220 "Time(us)\n"); 2221 for (i=0; i<(int)cpi->oxcf.number_of_layers; i++) 2222 { 2223 double dr = (double)cpi->bytes_in_layer[i] * 2224 8.0 / 1000.0 / time_encoded; 2225 fprintf(f, "%5d\t%7.3f\t%6.4f\t" 2226 "%6.4f\t%6.4f\t%6.4f\t%8.0f\n", 2227 i, dr, 2228 cpi->total_ssimg_y_in_layer[i] / 2229 cpi->frames_in_layer[i], 2230 cpi->total_ssimg_u_in_layer[i] / 2231 cpi->frames_in_layer[i], 2232 cpi->total_ssimg_v_in_layer[i] / 2233 cpi->frames_in_layer[i], 2234 cpi->total_ssimg_all_in_layer[i] / 2235 cpi->frames_in_layer[i], 2236 total_encode_time); 2237 } 2238 } 2239 else 2240 { 2241 fprintf(f, "BitRate\tSSIM_Y\tSSIM_U\tSSIM_V\tSSIM_A\t" 2242 "Time(us)\n"); 2243 fprintf(f, "%7.3f\t%6.4f\t%6.4f\t%6.4f\t%6.4f\t%8.0f\n", dr, 2244 cpi->total_ssimg_y / cpi->count, 2245 cpi->total_ssimg_u / cpi->count, 2246 cpi->total_ssimg_v / cpi->count, 2247 cpi->total_ssimg_all / cpi->count, total_encode_time); 2248 } 2249 } 2250 2251 fclose(f); 2252#if 0 2253 f = fopen("qskip.stt", "a"); 2254 fprintf(f, "minq:%d -maxq:%d skiptrue:skipfalse = %d:%d\n", cpi->oxcf.best_allowed_q, cpi->oxcf.worst_allowed_q, skiptruecount, skipfalsecount); 2255 fclose(f); 2256#endif 2257 2258 } 2259 2260#endif 2261 2262 2263#ifdef SPEEDSTATS 2264 2265 if (cpi->compressor_speed == 2) 2266 { 2267 int i; 2268 FILE *f = fopen("cxspeed.stt", "a"); 2269 cnt_pm /= cpi->common.MBs; 2270 2271 for (i = 0; i < 16; i++) 2272 fprintf(f, "%5d", frames_at_speed[i]); 2273 2274 fprintf(f, "\n"); 2275 fclose(f); 2276 } 2277 2278#endif 2279 2280 2281#ifdef MODE_STATS 2282 { 2283 extern int count_mb_seg[4]; 2284 FILE *f = fopen("modes.stt", "a"); 2285 double dr = (double)cpi->framerate * (double)bytes * (double)8 / (double)count / (double)1000 ; 2286 fprintf(f, "intra_mode in Intra Frames:\n"); 2287 fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d\n", y_modes[0], y_modes[1], y_modes[2], y_modes[3], y_modes[4]); 2288 fprintf(f, "UV:%8d, %8d, %8d, %8d\n", uv_modes[0], uv_modes[1], uv_modes[2], uv_modes[3]); 2289 fprintf(f, "B: "); 2290 { 2291 int i; 2292 2293 for (i = 0; i < 10; i++) 2294 fprintf(f, "%8d, ", b_modes[i]); 2295 2296 fprintf(f, "\n"); 2297 2298 } 2299 2300 fprintf(f, "Modes in Inter Frames:\n"); 2301 fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d\n", 2302 inter_y_modes[0], inter_y_modes[1], inter_y_modes[2], inter_y_modes[3], inter_y_modes[4], 2303 inter_y_modes[5], inter_y_modes[6], inter_y_modes[7], inter_y_modes[8], inter_y_modes[9]); 2304 fprintf(f, "UV:%8d, %8d, %8d, %8d\n", inter_uv_modes[0], inter_uv_modes[1], inter_uv_modes[2], inter_uv_modes[3]); 2305 fprintf(f, "B: "); 2306 { 2307 int i; 2308 2309 for (i = 0; i < 15; i++) 2310 fprintf(f, "%8d, ", inter_b_modes[i]); 2311 2312 fprintf(f, "\n"); 2313 2314 } 2315 fprintf(f, "P:%8d, %8d, %8d, %8d\n", count_mb_seg[0], count_mb_seg[1], count_mb_seg[2], count_mb_seg[3]); 2316 fprintf(f, "PB:%8d, %8d, %8d, %8d\n", inter_b_modes[LEFT4X4], inter_b_modes[ABOVE4X4], inter_b_modes[ZERO4X4], inter_b_modes[NEW4X4]); 2317 2318 2319 2320 fclose(f); 2321 } 2322#endif 2323 2324#ifdef VP8_ENTROPY_STATS 2325 { 2326 int i, j, k; 2327 FILE *fmode = fopen("modecontext.c", "w"); 2328 2329 fprintf(fmode, "\n#include \"entropymode.h\"\n\n"); 2330 fprintf(fmode, "const unsigned int vp8_kf_default_bmode_counts "); 2331 fprintf(fmode, "[VP8_BINTRAMODES] [VP8_BINTRAMODES] [VP8_BINTRAMODES] =\n{\n"); 2332 2333 for (i = 0; i < 10; i++) 2334 { 2335 2336 fprintf(fmode, " { /* Above Mode : %d */\n", i); 2337 2338 for (j = 0; j < 10; j++) 2339 { 2340 2341 fprintf(fmode, " {"); 2342 2343 for (k = 0; k < 10; k++) 2344 { 2345 if (!intra_mode_stats[i][j][k]) 2346 fprintf(fmode, " %5d, ", 1); 2347 else 2348 fprintf(fmode, " %5d, ", intra_mode_stats[i][j][k]); 2349 } 2350 2351 fprintf(fmode, "}, /* left_mode %d */\n", j); 2352 2353 } 2354 2355 fprintf(fmode, " },\n"); 2356 2357 } 2358 2359 fprintf(fmode, "};\n"); 2360 fclose(fmode); 2361 } 2362#endif 2363 2364 2365#if defined(SECTIONBITS_OUTPUT) 2366 2367 if (0) 2368 { 2369 int i; 2370 FILE *f = fopen("tokenbits.stt", "a"); 2371 2372 for (i = 0; i < 28; i++) 2373 fprintf(f, "%8d", (int)(Sectionbits[i] / 256)); 2374 2375 fprintf(f, "\n"); 2376 fclose(f); 2377 } 2378 2379#endif 2380 2381#if 0 2382 { 2383 printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000); 2384 printf("\n_frames recive_data encod_mb_row compress_frame Total\n"); 2385 printf("%6d %10ld %10ld %10ld %10ld\n", cpi->common.current_video_frame, cpi->time_receive_data / 1000, cpi->time_encode_mb_row / 1000, cpi->time_compress_data / 1000, (cpi->time_receive_data + cpi->time_compress_data) / 1000); 2386 } 2387#endif 2388 2389 } 2390 2391#if CONFIG_MULTITHREAD 2392 vp8cx_remove_encoder_threads(cpi); 2393#endif 2394 2395#if CONFIG_TEMPORAL_DENOISING 2396 vp8_denoiser_free(&cpi->denoiser); 2397#endif 2398 dealloc_compressor_data(cpi); 2399 vpx_free(cpi->mb.ss); 2400 vpx_free(cpi->tok); 2401 vpx_free(cpi->cyclic_refresh_map); 2402 2403 vp8_remove_common(&cpi->common); 2404 vpx_free(cpi); 2405 *ptr = 0; 2406 2407#ifdef OUTPUT_YUV_SRC 2408 fclose(yuv_file); 2409#endif 2410 2411#if 0 2412 2413 if (keyfile) 2414 fclose(keyfile); 2415 2416 if (framepsnr) 2417 fclose(framepsnr); 2418 2419 if (kf_list) 2420 fclose(kf_list); 2421 2422#endif 2423 2424} 2425 2426 2427static uint64_t calc_plane_error(unsigned char *orig, int orig_stride, 2428 unsigned char *recon, int recon_stride, 2429 unsigned int cols, unsigned int rows) 2430{ 2431 unsigned int row, col; 2432 uint64_t total_sse = 0; 2433 int diff; 2434 2435 for (row = 0; row + 16 <= rows; row += 16) 2436 { 2437 for (col = 0; col + 16 <= cols; col += 16) 2438 { 2439 unsigned int sse; 2440 2441 vp8_mse16x16(orig + col, orig_stride, 2442 recon + col, recon_stride, 2443 &sse); 2444 total_sse += sse; 2445 } 2446 2447 /* Handle odd-sized width */ 2448 if (col < cols) 2449 { 2450 unsigned int border_row, border_col; 2451 unsigned char *border_orig = orig; 2452 unsigned char *border_recon = recon; 2453 2454 for (border_row = 0; border_row < 16; border_row++) 2455 { 2456 for (border_col = col; border_col < cols; border_col++) 2457 { 2458 diff = border_orig[border_col] - border_recon[border_col]; 2459 total_sse += diff * diff; 2460 } 2461 2462 border_orig += orig_stride; 2463 border_recon += recon_stride; 2464 } 2465 } 2466 2467 orig += orig_stride * 16; 2468 recon += recon_stride * 16; 2469 } 2470 2471 /* Handle odd-sized height */ 2472 for (; row < rows; row++) 2473 { 2474 for (col = 0; col < cols; col++) 2475 { 2476 diff = orig[col] - recon[col]; 2477 total_sse += diff * diff; 2478 } 2479 2480 orig += orig_stride; 2481 recon += recon_stride; 2482 } 2483 2484 vp8_clear_system_state(); 2485 return total_sse; 2486} 2487 2488 2489static void generate_psnr_packet(VP8_COMP *cpi) 2490{ 2491 YV12_BUFFER_CONFIG *orig = cpi->Source; 2492 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show; 2493 struct vpx_codec_cx_pkt pkt; 2494 uint64_t sse; 2495 int i; 2496 unsigned int width = cpi->common.Width; 2497 unsigned int height = cpi->common.Height; 2498 2499 pkt.kind = VPX_CODEC_PSNR_PKT; 2500 sse = calc_plane_error(orig->y_buffer, orig->y_stride, 2501 recon->y_buffer, recon->y_stride, 2502 width, height); 2503 pkt.data.psnr.sse[0] = sse; 2504 pkt.data.psnr.sse[1] = sse; 2505 pkt.data.psnr.samples[0] = width * height; 2506 pkt.data.psnr.samples[1] = width * height; 2507 2508 width = (width + 1) / 2; 2509 height = (height + 1) / 2; 2510 2511 sse = calc_plane_error(orig->u_buffer, orig->uv_stride, 2512 recon->u_buffer, recon->uv_stride, 2513 width, height); 2514 pkt.data.psnr.sse[0] += sse; 2515 pkt.data.psnr.sse[2] = sse; 2516 pkt.data.psnr.samples[0] += width * height; 2517 pkt.data.psnr.samples[2] = width * height; 2518 2519 sse = calc_plane_error(orig->v_buffer, orig->uv_stride, 2520 recon->v_buffer, recon->uv_stride, 2521 width, height); 2522 pkt.data.psnr.sse[0] += sse; 2523 pkt.data.psnr.sse[3] = sse; 2524 pkt.data.psnr.samples[0] += width * height; 2525 pkt.data.psnr.samples[3] = width * height; 2526 2527 for (i = 0; i < 4; i++) 2528 pkt.data.psnr.psnr[i] = vpx_sse_to_psnr(pkt.data.psnr.samples[i], 255.0, 2529 (double)(pkt.data.psnr.sse[i])); 2530 2531 vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt); 2532} 2533 2534 2535int vp8_use_as_reference(VP8_COMP *cpi, int ref_frame_flags) 2536{ 2537 if (ref_frame_flags > 7) 2538 return -1 ; 2539 2540 cpi->ref_frame_flags = ref_frame_flags; 2541 return 0; 2542} 2543int vp8_update_reference(VP8_COMP *cpi, int ref_frame_flags) 2544{ 2545 if (ref_frame_flags > 7) 2546 return -1 ; 2547 2548 cpi->common.refresh_golden_frame = 0; 2549 cpi->common.refresh_alt_ref_frame = 0; 2550 cpi->common.refresh_last_frame = 0; 2551 2552 if (ref_frame_flags & VP8_LAST_FRAME) 2553 cpi->common.refresh_last_frame = 1; 2554 2555 if (ref_frame_flags & VP8_GOLD_FRAME) 2556 cpi->common.refresh_golden_frame = 1; 2557 2558 if (ref_frame_flags & VP8_ALTR_FRAME) 2559 cpi->common.refresh_alt_ref_frame = 1; 2560 2561 return 0; 2562} 2563 2564int vp8_get_reference(VP8_COMP *cpi, enum vpx_ref_frame_type ref_frame_flag, YV12_BUFFER_CONFIG *sd) 2565{ 2566 VP8_COMMON *cm = &cpi->common; 2567 int ref_fb_idx; 2568 2569 if (ref_frame_flag == VP8_LAST_FRAME) 2570 ref_fb_idx = cm->lst_fb_idx; 2571 else if (ref_frame_flag == VP8_GOLD_FRAME) 2572 ref_fb_idx = cm->gld_fb_idx; 2573 else if (ref_frame_flag == VP8_ALTR_FRAME) 2574 ref_fb_idx = cm->alt_fb_idx; 2575 else 2576 return -1; 2577 2578 vp8_yv12_copy_frame(&cm->yv12_fb[ref_fb_idx], sd); 2579 2580 return 0; 2581} 2582int vp8_set_reference(VP8_COMP *cpi, enum vpx_ref_frame_type ref_frame_flag, YV12_BUFFER_CONFIG *sd) 2583{ 2584 VP8_COMMON *cm = &cpi->common; 2585 2586 int ref_fb_idx; 2587 2588 if (ref_frame_flag == VP8_LAST_FRAME) 2589 ref_fb_idx = cm->lst_fb_idx; 2590 else if (ref_frame_flag == VP8_GOLD_FRAME) 2591 ref_fb_idx = cm->gld_fb_idx; 2592 else if (ref_frame_flag == VP8_ALTR_FRAME) 2593 ref_fb_idx = cm->alt_fb_idx; 2594 else 2595 return -1; 2596 2597 vp8_yv12_copy_frame(sd, &cm->yv12_fb[ref_fb_idx]); 2598 2599 return 0; 2600} 2601int vp8_update_entropy(VP8_COMP *cpi, int update) 2602{ 2603 VP8_COMMON *cm = &cpi->common; 2604 cm->refresh_entropy_probs = update; 2605 2606 return 0; 2607} 2608 2609 2610#if OUTPUT_YUV_SRC 2611void vp8_write_yuv_frame(const char *name, YV12_BUFFER_CONFIG *s) 2612{ 2613 FILE *yuv_file = fopen(name, "ab"); 2614 unsigned char *src = s->y_buffer; 2615 int h = s->y_height; 2616 2617 do 2618 { 2619 fwrite(src, s->y_width, 1, yuv_file); 2620 src += s->y_stride; 2621 } 2622 while (--h); 2623 2624 src = s->u_buffer; 2625 h = s->uv_height; 2626 2627 do 2628 { 2629 fwrite(src, s->uv_width, 1, yuv_file); 2630 src += s->uv_stride; 2631 } 2632 while (--h); 2633 2634 src = s->v_buffer; 2635 h = s->uv_height; 2636 2637 do 2638 { 2639 fwrite(src, s->uv_width, 1, yuv_file); 2640 src += s->uv_stride; 2641 } 2642 while (--h); 2643 2644 fclose(yuv_file); 2645} 2646#endif 2647 2648 2649static void scale_and_extend_source(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi) 2650{ 2651 VP8_COMMON *cm = &cpi->common; 2652 2653 /* are we resizing the image */ 2654 if (cm->horiz_scale != 0 || cm->vert_scale != 0) 2655 { 2656#if CONFIG_SPATIAL_RESAMPLING 2657 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs); 2658 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs); 2659 int tmp_height; 2660 2661 if (cm->vert_scale == 3) 2662 tmp_height = 9; 2663 else 2664 tmp_height = 11; 2665 2666 Scale2Ratio(cm->horiz_scale, &hr, &hs); 2667 Scale2Ratio(cm->vert_scale, &vr, &vs); 2668 2669 vpx_scale_frame(sd, &cpi->scaled_source, cm->temp_scale_frame.y_buffer, 2670 tmp_height, hs, hr, vs, vr, 0); 2671 2672 vp8_yv12_extend_frame_borders(&cpi->scaled_source); 2673 cpi->Source = &cpi->scaled_source; 2674#endif 2675 } 2676 else 2677 cpi->Source = sd; 2678} 2679 2680 2681static int resize_key_frame(VP8_COMP *cpi) 2682{ 2683#if CONFIG_SPATIAL_RESAMPLING 2684 VP8_COMMON *cm = &cpi->common; 2685 2686 /* Do we need to apply resampling for one pass cbr. 2687 * In one pass this is more limited than in two pass cbr. 2688 * The test and any change is only made once per key frame sequence. 2689 */ 2690 if (cpi->oxcf.allow_spatial_resampling && (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)) 2691 { 2692 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs); 2693 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs); 2694 int new_width, new_height; 2695 2696 /* If we are below the resample DOWN watermark then scale down a 2697 * notch. 2698 */ 2699 if (cpi->buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100)) 2700 { 2701 cm->horiz_scale = (cm->horiz_scale < ONETWO) ? cm->horiz_scale + 1 : ONETWO; 2702 cm->vert_scale = (cm->vert_scale < ONETWO) ? cm->vert_scale + 1 : ONETWO; 2703 } 2704 /* Should we now start scaling back up */ 2705 else if (cpi->buffer_level > (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100)) 2706 { 2707 cm->horiz_scale = (cm->horiz_scale > NORMAL) ? cm->horiz_scale - 1 : NORMAL; 2708 cm->vert_scale = (cm->vert_scale > NORMAL) ? cm->vert_scale - 1 : NORMAL; 2709 } 2710 2711 /* Get the new height and width */ 2712 Scale2Ratio(cm->horiz_scale, &hr, &hs); 2713 Scale2Ratio(cm->vert_scale, &vr, &vs); 2714 new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs; 2715 new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs; 2716 2717 /* If the image size has changed we need to reallocate the buffers 2718 * and resample the source image 2719 */ 2720 if ((cm->Width != new_width) || (cm->Height != new_height)) 2721 { 2722 cm->Width = new_width; 2723 cm->Height = new_height; 2724 vp8_alloc_compressor_data(cpi); 2725 scale_and_extend_source(cpi->un_scaled_source, cpi); 2726 return 1; 2727 } 2728 } 2729 2730#endif 2731 return 0; 2732} 2733 2734 2735static void update_alt_ref_frame_stats(VP8_COMP *cpi) 2736{ 2737 VP8_COMMON *cm = &cpi->common; 2738 2739 /* Select an interval before next GF or altref */ 2740 if (!cpi->auto_gold) 2741 cpi->frames_till_gf_update_due = DEFAULT_GF_INTERVAL; 2742 2743 if ((cpi->pass != 2) && cpi->frames_till_gf_update_due) 2744 { 2745 cpi->current_gf_interval = cpi->frames_till_gf_update_due; 2746 2747 /* Set the bits per frame that we should try and recover in 2748 * subsequent inter frames to account for the extra GF spend... 2749 * note that his does not apply for GF updates that occur 2750 * coincident with a key frame as the extra cost of key frames is 2751 * dealt with elsewhere. 2752 */ 2753 cpi->gf_overspend_bits += cpi->projected_frame_size; 2754 cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due; 2755 } 2756 2757 /* Update data structure that monitors level of reference to last GF */ 2758 vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols)); 2759 cpi->gf_active_count = cm->mb_rows * cm->mb_cols; 2760 2761 /* this frame refreshes means next frames don't unless specified by user */ 2762 cpi->frames_since_golden = 0; 2763 2764 /* Clear the alternate reference update pending flag. */ 2765 cpi->source_alt_ref_pending = 0; 2766 2767 /* Set the alternate reference frame active flag */ 2768 cpi->source_alt_ref_active = 1; 2769 2770 2771} 2772static void update_golden_frame_stats(VP8_COMP *cpi) 2773{ 2774 VP8_COMMON *cm = &cpi->common; 2775 2776 /* Update the Golden frame usage counts. */ 2777 if (cm->refresh_golden_frame) 2778 { 2779 /* Select an interval before next GF */ 2780 if (!cpi->auto_gold) 2781 cpi->frames_till_gf_update_due = DEFAULT_GF_INTERVAL; 2782 2783 if ((cpi->pass != 2) && (cpi->frames_till_gf_update_due > 0)) 2784 { 2785 cpi->current_gf_interval = cpi->frames_till_gf_update_due; 2786 2787 /* Set the bits per frame that we should try and recover in 2788 * subsequent inter frames to account for the extra GF spend... 2789 * note that his does not apply for GF updates that occur 2790 * coincident with a key frame as the extra cost of key frames 2791 * is dealt with elsewhere. 2792 */ 2793 if ((cm->frame_type != KEY_FRAME) && !cpi->source_alt_ref_active) 2794 { 2795 /* Calcluate GF bits to be recovered 2796 * Projected size - av frame bits available for inter 2797 * frames for clip as a whole 2798 */ 2799 cpi->gf_overspend_bits += (cpi->projected_frame_size - cpi->inter_frame_target); 2800 } 2801 2802 cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due; 2803 2804 } 2805 2806 /* Update data structure that monitors level of reference to last GF */ 2807 vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols)); 2808 cpi->gf_active_count = cm->mb_rows * cm->mb_cols; 2809 2810 /* this frame refreshes means next frames don't unless specified by 2811 * user 2812 */ 2813 cm->refresh_golden_frame = 0; 2814 cpi->frames_since_golden = 0; 2815 2816 cpi->recent_ref_frame_usage[INTRA_FRAME] = 1; 2817 cpi->recent_ref_frame_usage[LAST_FRAME] = 1; 2818 cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1; 2819 cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1; 2820 2821 /* ******** Fixed Q test code only ************ */ 2822 /* If we are going to use the ALT reference for the next group of 2823 * frames set a flag to say so. 2824 */ 2825 if (cpi->oxcf.fixed_q >= 0 && 2826 cpi->oxcf.play_alternate && !cpi->common.refresh_alt_ref_frame) 2827 { 2828 cpi->source_alt_ref_pending = 1; 2829 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval; 2830 } 2831 2832 if (!cpi->source_alt_ref_pending) 2833 cpi->source_alt_ref_active = 0; 2834 2835 /* Decrement count down till next gf */ 2836 if (cpi->frames_till_gf_update_due > 0) 2837 cpi->frames_till_gf_update_due--; 2838 2839 } 2840 else if (!cpi->common.refresh_alt_ref_frame) 2841 { 2842 /* Decrement count down till next gf */ 2843 if (cpi->frames_till_gf_update_due > 0) 2844 cpi->frames_till_gf_update_due--; 2845 2846 if (cpi->frames_till_alt_ref_frame) 2847 cpi->frames_till_alt_ref_frame --; 2848 2849 cpi->frames_since_golden ++; 2850 2851 if (cpi->frames_since_golden > 1) 2852 { 2853 cpi->recent_ref_frame_usage[INTRA_FRAME] += 2854 cpi->mb.count_mb_ref_frame_usage[INTRA_FRAME]; 2855 cpi->recent_ref_frame_usage[LAST_FRAME] += 2856 cpi->mb.count_mb_ref_frame_usage[LAST_FRAME]; 2857 cpi->recent_ref_frame_usage[GOLDEN_FRAME] += 2858 cpi->mb.count_mb_ref_frame_usage[GOLDEN_FRAME]; 2859 cpi->recent_ref_frame_usage[ALTREF_FRAME] += 2860 cpi->mb.count_mb_ref_frame_usage[ALTREF_FRAME]; 2861 } 2862 } 2863} 2864 2865/* This function updates the reference frame probability estimates that 2866 * will be used during mode selection 2867 */ 2868static void update_rd_ref_frame_probs(VP8_COMP *cpi) 2869{ 2870 VP8_COMMON *cm = &cpi->common; 2871 2872 const int *const rfct = cpi->mb.count_mb_ref_frame_usage; 2873 const int rf_intra = rfct[INTRA_FRAME]; 2874 const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]; 2875 2876 if (cm->frame_type == KEY_FRAME) 2877 { 2878 cpi->prob_intra_coded = 255; 2879 cpi->prob_last_coded = 128; 2880 cpi->prob_gf_coded = 128; 2881 } 2882 else if (!(rf_intra + rf_inter)) 2883 { 2884 cpi->prob_intra_coded = 63; 2885 cpi->prob_last_coded = 128; 2886 cpi->prob_gf_coded = 128; 2887 } 2888 2889 /* update reference frame costs since we can do better than what we got 2890 * last frame. 2891 */ 2892 if (cpi->oxcf.number_of_layers == 1) 2893 { 2894 if (cpi->common.refresh_alt_ref_frame) 2895 { 2896 cpi->prob_intra_coded += 40; 2897 if (cpi->prob_intra_coded > 255) 2898 cpi->prob_intra_coded = 255; 2899 cpi->prob_last_coded = 200; 2900 cpi->prob_gf_coded = 1; 2901 } 2902 else if (cpi->frames_since_golden == 0) 2903 { 2904 cpi->prob_last_coded = 214; 2905 } 2906 else if (cpi->frames_since_golden == 1) 2907 { 2908 cpi->prob_last_coded = 192; 2909 cpi->prob_gf_coded = 220; 2910 } 2911 else if (cpi->source_alt_ref_active) 2912 { 2913 cpi->prob_gf_coded -= 20; 2914 2915 if (cpi->prob_gf_coded < 10) 2916 cpi->prob_gf_coded = 10; 2917 } 2918 if (!cpi->source_alt_ref_active) 2919 cpi->prob_gf_coded = 255; 2920 } 2921} 2922 2923 2924/* 1 = key, 0 = inter */ 2925static int decide_key_frame(VP8_COMP *cpi) 2926{ 2927 VP8_COMMON *cm = &cpi->common; 2928 2929 int code_key_frame = 0; 2930 2931 cpi->kf_boost = 0; 2932 2933 if (cpi->Speed > 11) 2934 return 0; 2935 2936 /* Clear down mmx registers */ 2937 vp8_clear_system_state(); 2938 2939 if ((cpi->compressor_speed == 2) && (cpi->Speed >= 5) && (cpi->sf.RD == 0)) 2940 { 2941 double change = 1.0 * abs((int)(cpi->mb.intra_error - 2942 cpi->last_intra_error)) / (1 + cpi->last_intra_error); 2943 double change2 = 1.0 * abs((int)(cpi->mb.prediction_error - 2944 cpi->last_prediction_error)) / (1 + cpi->last_prediction_error); 2945 double minerror = cm->MBs * 256; 2946 2947 cpi->last_intra_error = cpi->mb.intra_error; 2948 cpi->last_prediction_error = cpi->mb.prediction_error; 2949 2950 if (10 * cpi->mb.intra_error / (1 + cpi->mb.prediction_error) < 15 2951 && cpi->mb.prediction_error > minerror 2952 && (change > .25 || change2 > .25)) 2953 { 2954 /*(change > 1.4 || change < .75)&& cpi->this_frame_percent_intra > cpi->last_frame_percent_intra + 3*/ 2955 return 1; 2956 } 2957 2958 return 0; 2959 2960 } 2961 2962 /* If the following are true we might as well code a key frame */ 2963 if (((cpi->this_frame_percent_intra == 100) && 2964 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 2))) || 2965 ((cpi->this_frame_percent_intra > 95) && 2966 (cpi->this_frame_percent_intra >= (cpi->last_frame_percent_intra + 5)))) 2967 { 2968 code_key_frame = 1; 2969 } 2970 /* in addition if the following are true and this is not a golden frame 2971 * then code a key frame Note that on golden frames there often seems 2972 * to be a pop in intra useage anyway hence this restriction is 2973 * designed to prevent spurious key frames. The Intra pop needs to be 2974 * investigated. 2975 */ 2976 else if (((cpi->this_frame_percent_intra > 60) && 2977 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 2))) || 2978 ((cpi->this_frame_percent_intra > 75) && 2979 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 3 / 2))) || 2980 ((cpi->this_frame_percent_intra > 90) && 2981 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 10)))) 2982 { 2983 if (!cm->refresh_golden_frame) 2984 code_key_frame = 1; 2985 } 2986 2987 return code_key_frame; 2988 2989} 2990 2991#if !(CONFIG_REALTIME_ONLY) 2992static void Pass1Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned int *frame_flags) 2993{ 2994 (void) size; 2995 (void) dest; 2996 (void) frame_flags; 2997 vp8_set_quantizer(cpi, 26); 2998 2999 vp8_first_pass(cpi); 3000} 3001#endif 3002 3003#if 0 3004void write_cx_frame_to_file(YV12_BUFFER_CONFIG *frame, int this_frame) 3005{ 3006 3007 /* write the frame */ 3008 FILE *yframe; 3009 int i; 3010 char filename[255]; 3011 3012 sprintf(filename, "cx\\y%04d.raw", this_frame); 3013 yframe = fopen(filename, "wb"); 3014 3015 for (i = 0; i < frame->y_height; i++) 3016 fwrite(frame->y_buffer + i * frame->y_stride, frame->y_width, 1, yframe); 3017 3018 fclose(yframe); 3019 sprintf(filename, "cx\\u%04d.raw", this_frame); 3020 yframe = fopen(filename, "wb"); 3021 3022 for (i = 0; i < frame->uv_height; i++) 3023 fwrite(frame->u_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe); 3024 3025 fclose(yframe); 3026 sprintf(filename, "cx\\v%04d.raw", this_frame); 3027 yframe = fopen(filename, "wb"); 3028 3029 for (i = 0; i < frame->uv_height; i++) 3030 fwrite(frame->v_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe); 3031 3032 fclose(yframe); 3033} 3034#endif 3035/* return of 0 means drop frame */ 3036 3037/* Function to test for conditions that indeicate we should loop 3038 * back and recode a frame. 3039 */ 3040static int recode_loop_test( VP8_COMP *cpi, 3041 int high_limit, int low_limit, 3042 int q, int maxq, int minq ) 3043{ 3044 int force_recode = 0; 3045 VP8_COMMON *cm = &cpi->common; 3046 3047 /* Is frame recode allowed at all 3048 * Yes if either recode mode 1 is selected or mode two is selcted 3049 * and the frame is a key frame. golden frame or alt_ref_frame 3050 */ 3051 if ( (cpi->sf.recode_loop == 1) || 3052 ( (cpi->sf.recode_loop == 2) && 3053 ( (cm->frame_type == KEY_FRAME) || 3054 cm->refresh_golden_frame || 3055 cm->refresh_alt_ref_frame ) ) ) 3056 { 3057 /* General over and under shoot tests */ 3058 if ( ((cpi->projected_frame_size > high_limit) && (q < maxq)) || 3059 ((cpi->projected_frame_size < low_limit) && (q > minq)) ) 3060 { 3061 force_recode = 1; 3062 } 3063 /* Special Constrained quality tests */ 3064 else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) 3065 { 3066 /* Undershoot and below auto cq level */ 3067 if ( (q > cpi->cq_target_quality) && 3068 (cpi->projected_frame_size < 3069 ((cpi->this_frame_target * 7) >> 3))) 3070 { 3071 force_recode = 1; 3072 } 3073 /* Severe undershoot and between auto and user cq level */ 3074 else if ( (q > cpi->oxcf.cq_level) && 3075 (cpi->projected_frame_size < cpi->min_frame_bandwidth) && 3076 (cpi->active_best_quality > cpi->oxcf.cq_level)) 3077 { 3078 force_recode = 1; 3079 cpi->active_best_quality = cpi->oxcf.cq_level; 3080 } 3081 } 3082 } 3083 3084 return force_recode; 3085} 3086 3087static void update_reference_frames(VP8_COMP *cpi) 3088{ 3089 VP8_COMMON *cm = &cpi->common; 3090 YV12_BUFFER_CONFIG *yv12_fb = cm->yv12_fb; 3091 3092 /* At this point the new frame has been encoded. 3093 * If any buffer copy / swapping is signaled it should be done here. 3094 */ 3095 3096 if (cm->frame_type == KEY_FRAME) 3097 { 3098 yv12_fb[cm->new_fb_idx].flags |= VP8_GOLD_FRAME | VP8_ALTR_FRAME ; 3099 3100 yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FRAME; 3101 yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALTR_FRAME; 3102 3103 cm->alt_fb_idx = cm->gld_fb_idx = cm->new_fb_idx; 3104 3105#if CONFIG_MULTI_RES_ENCODING 3106 cpi->current_ref_frames[GOLDEN_FRAME] = cm->current_video_frame; 3107 cpi->current_ref_frames[ALTREF_FRAME] = cm->current_video_frame; 3108#endif 3109 } 3110 else /* For non key frames */ 3111 { 3112 if (cm->refresh_alt_ref_frame) 3113 { 3114 assert(!cm->copy_buffer_to_arf); 3115 3116 cm->yv12_fb[cm->new_fb_idx].flags |= VP8_ALTR_FRAME; 3117 cm->yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALTR_FRAME; 3118 cm->alt_fb_idx = cm->new_fb_idx; 3119 3120#if CONFIG_MULTI_RES_ENCODING 3121 cpi->current_ref_frames[ALTREF_FRAME] = cm->current_video_frame; 3122#endif 3123 } 3124 else if (cm->copy_buffer_to_arf) 3125 { 3126 assert(!(cm->copy_buffer_to_arf & ~0x3)); 3127 3128 if (cm->copy_buffer_to_arf == 1) 3129 { 3130 if(cm->alt_fb_idx != cm->lst_fb_idx) 3131 { 3132 yv12_fb[cm->lst_fb_idx].flags |= VP8_ALTR_FRAME; 3133 yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALTR_FRAME; 3134 cm->alt_fb_idx = cm->lst_fb_idx; 3135 3136#if CONFIG_MULTI_RES_ENCODING 3137 cpi->current_ref_frames[ALTREF_FRAME] = 3138 cpi->current_ref_frames[LAST_FRAME]; 3139#endif 3140 } 3141 } 3142 else /* if (cm->copy_buffer_to_arf == 2) */ 3143 { 3144 if(cm->alt_fb_idx != cm->gld_fb_idx) 3145 { 3146 yv12_fb[cm->gld_fb_idx].flags |= VP8_ALTR_FRAME; 3147 yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALTR_FRAME; 3148 cm->alt_fb_idx = cm->gld_fb_idx; 3149 3150#if CONFIG_MULTI_RES_ENCODING 3151 cpi->current_ref_frames[ALTREF_FRAME] = 3152 cpi->current_ref_frames[GOLDEN_FRAME]; 3153#endif 3154 } 3155 } 3156 } 3157 3158 if (cm->refresh_golden_frame) 3159 { 3160 assert(!cm->copy_buffer_to_gf); 3161 3162 cm->yv12_fb[cm->new_fb_idx].flags |= VP8_GOLD_FRAME; 3163 cm->yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FRAME; 3164 cm->gld_fb_idx = cm->new_fb_idx; 3165 3166#if CONFIG_MULTI_RES_ENCODING 3167 cpi->current_ref_frames[GOLDEN_FRAME] = cm->current_video_frame; 3168#endif 3169 } 3170 else if (cm->copy_buffer_to_gf) 3171 { 3172 assert(!(cm->copy_buffer_to_arf & ~0x3)); 3173 3174 if (cm->copy_buffer_to_gf == 1) 3175 { 3176 if(cm->gld_fb_idx != cm->lst_fb_idx) 3177 { 3178 yv12_fb[cm->lst_fb_idx].flags |= VP8_GOLD_FRAME; 3179 yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FRAME; 3180 cm->gld_fb_idx = cm->lst_fb_idx; 3181 3182#if CONFIG_MULTI_RES_ENCODING 3183 cpi->current_ref_frames[GOLDEN_FRAME] = 3184 cpi->current_ref_frames[LAST_FRAME]; 3185#endif 3186 } 3187 } 3188 else /* if (cm->copy_buffer_to_gf == 2) */ 3189 { 3190 if(cm->alt_fb_idx != cm->gld_fb_idx) 3191 { 3192 yv12_fb[cm->alt_fb_idx].flags |= VP8_GOLD_FRAME; 3193 yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FRAME; 3194 cm->gld_fb_idx = cm->alt_fb_idx; 3195 3196#if CONFIG_MULTI_RES_ENCODING 3197 cpi->current_ref_frames[GOLDEN_FRAME] = 3198 cpi->current_ref_frames[ALTREF_FRAME]; 3199#endif 3200 } 3201 } 3202 } 3203 } 3204 3205 if (cm->refresh_last_frame) 3206 { 3207 cm->yv12_fb[cm->new_fb_idx].flags |= VP8_LAST_FRAME; 3208 cm->yv12_fb[cm->lst_fb_idx].flags &= ~VP8_LAST_FRAME; 3209 cm->lst_fb_idx = cm->new_fb_idx; 3210 3211#if CONFIG_MULTI_RES_ENCODING 3212 cpi->current_ref_frames[LAST_FRAME] = cm->current_video_frame; 3213#endif 3214 } 3215 3216#if CONFIG_TEMPORAL_DENOISING 3217 if (cpi->oxcf.noise_sensitivity) 3218 { 3219 /* we shouldn't have to keep multiple copies as we know in advance which 3220 * buffer we should start - for now to get something up and running 3221 * I've chosen to copy the buffers 3222 */ 3223 if (cm->frame_type == KEY_FRAME) 3224 { 3225 int i; 3226 vp8_yv12_copy_frame( 3227 cpi->Source, 3228 &cpi->denoiser.yv12_running_avg[LAST_FRAME]); 3229 3230 vp8_yv12_extend_frame_borders( 3231 &cpi->denoiser.yv12_running_avg[LAST_FRAME]); 3232 3233 for (i = 2; i < MAX_REF_FRAMES - 1; i++) 3234 vp8_yv12_copy_frame( 3235 &cpi->denoiser.yv12_running_avg[LAST_FRAME], 3236 &cpi->denoiser.yv12_running_avg[i]); 3237 } 3238 else /* For non key frames */ 3239 { 3240 vp8_yv12_extend_frame_borders( 3241 &cpi->denoiser.yv12_running_avg[INTRA_FRAME]); 3242 3243 if (cm->refresh_alt_ref_frame || cm->copy_buffer_to_arf) 3244 { 3245 vp8_yv12_copy_frame( 3246 &cpi->denoiser.yv12_running_avg[INTRA_FRAME], 3247 &cpi->denoiser.yv12_running_avg[ALTREF_FRAME]); 3248 } 3249 if (cm->refresh_golden_frame || cm->copy_buffer_to_gf) 3250 { 3251 vp8_yv12_copy_frame( 3252 &cpi->denoiser.yv12_running_avg[INTRA_FRAME], 3253 &cpi->denoiser.yv12_running_avg[GOLDEN_FRAME]); 3254 } 3255 if(cm->refresh_last_frame) 3256 { 3257 vp8_yv12_copy_frame( 3258 &cpi->denoiser.yv12_running_avg[INTRA_FRAME], 3259 &cpi->denoiser.yv12_running_avg[LAST_FRAME]); 3260 } 3261 } 3262 3263 } 3264#endif 3265 3266} 3267 3268void vp8_loopfilter_frame(VP8_COMP *cpi, VP8_COMMON *cm) 3269{ 3270 const FRAME_TYPE frame_type = cm->frame_type; 3271 3272 if (cm->no_lpf) 3273 { 3274 cm->filter_level = 0; 3275 } 3276 else 3277 { 3278 struct vpx_usec_timer timer; 3279 3280 vp8_clear_system_state(); 3281 3282 vpx_usec_timer_start(&timer); 3283 if (cpi->sf.auto_filter == 0) 3284 vp8cx_pick_filter_level_fast(cpi->Source, cpi); 3285 3286 else 3287 vp8cx_pick_filter_level(cpi->Source, cpi); 3288 3289 if (cm->filter_level > 0) 3290 { 3291 vp8cx_set_alt_lf_level(cpi, cm->filter_level); 3292 } 3293 3294 vpx_usec_timer_mark(&timer); 3295 cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer); 3296 } 3297 3298#if CONFIG_MULTITHREAD 3299 if (cpi->b_multi_threaded) 3300 sem_post(&cpi->h_event_end_lpf); /* signal that we have set filter_level */ 3301#endif 3302 3303 if (cm->filter_level > 0) 3304 { 3305 vp8_loop_filter_frame(cm, &cpi->mb.e_mbd, frame_type); 3306 } 3307 3308 vp8_yv12_extend_frame_borders(cm->frame_to_show); 3309 3310} 3311 3312static void encode_frame_to_data_rate 3313( 3314 VP8_COMP *cpi, 3315 unsigned long *size, 3316 unsigned char *dest, 3317 unsigned char* dest_end, 3318 unsigned int *frame_flags 3319) 3320{ 3321 int Q; 3322 int frame_over_shoot_limit; 3323 int frame_under_shoot_limit; 3324 3325 int Loop = 0; 3326 int loop_count; 3327 3328 VP8_COMMON *cm = &cpi->common; 3329 int active_worst_qchanged = 0; 3330 3331#if !(CONFIG_REALTIME_ONLY) 3332 int q_low; 3333 int q_high; 3334 int zbin_oq_high; 3335 int zbin_oq_low = 0; 3336 int top_index; 3337 int bottom_index; 3338 int overshoot_seen = 0; 3339 int undershoot_seen = 0; 3340#endif 3341 3342 int drop_mark = (int)(cpi->oxcf.drop_frames_water_mark * 3343 cpi->oxcf.optimal_buffer_level / 100); 3344 int drop_mark75 = drop_mark * 2 / 3; 3345 int drop_mark50 = drop_mark / 4; 3346 int drop_mark25 = drop_mark / 8; 3347 3348 3349 /* Clear down mmx registers to allow floating point in what follows */ 3350 vp8_clear_system_state(); 3351 3352#if CONFIG_MULTITHREAD 3353 /* wait for the last picture loopfilter thread done */ 3354 if (cpi->b_lpf_running) 3355 { 3356 sem_wait(&cpi->h_event_end_lpf); 3357 cpi->b_lpf_running = 0; 3358 } 3359#endif 3360 3361 if(cpi->force_next_frame_intra) 3362 { 3363 cm->frame_type = KEY_FRAME; /* delayed intra frame */ 3364 cpi->force_next_frame_intra = 0; 3365 } 3366 3367 /* For an alt ref frame in 2 pass we skip the call to the second pass 3368 * function that sets the target bandwidth 3369 */ 3370#if !(CONFIG_REALTIME_ONLY) 3371 3372 if (cpi->pass == 2) 3373 { 3374 if (cpi->common.refresh_alt_ref_frame) 3375 { 3376 /* Per frame bit target for the alt ref frame */ 3377 cpi->per_frame_bandwidth = cpi->twopass.gf_bits; 3378 /* per second target bitrate */ 3379 cpi->target_bandwidth = (int)(cpi->twopass.gf_bits * 3380 cpi->output_framerate); 3381 } 3382 } 3383 else 3384#endif 3385 cpi->per_frame_bandwidth = (int)(cpi->target_bandwidth / cpi->output_framerate); 3386 3387 /* Default turn off buffer to buffer copying */ 3388 cm->copy_buffer_to_gf = 0; 3389 cm->copy_buffer_to_arf = 0; 3390 3391 /* Clear zbin over-quant value and mode boost values. */ 3392 cpi->mb.zbin_over_quant = 0; 3393 cpi->mb.zbin_mode_boost = 0; 3394 3395 /* Enable or disable mode based tweaking of the zbin 3396 * For 2 Pass Only used where GF/ARF prediction quality 3397 * is above a threshold 3398 */ 3399 cpi->mb.zbin_mode_boost_enabled = 1; 3400 if (cpi->pass == 2) 3401 { 3402 if ( cpi->gfu_boost <= 400 ) 3403 { 3404 cpi->mb.zbin_mode_boost_enabled = 0; 3405 } 3406 } 3407 3408 /* Current default encoder behaviour for the altref sign bias */ 3409 if (cpi->source_alt_ref_active) 3410 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1; 3411 else 3412 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 0; 3413 3414 /* Check to see if a key frame is signaled 3415 * For two pass with auto key frame enabled cm->frame_type may already 3416 * be set, but not for one pass. 3417 */ 3418 if ((cm->current_video_frame == 0) || 3419 (cm->frame_flags & FRAMEFLAGS_KEY) || 3420 (cpi->oxcf.auto_key && (cpi->frames_since_key % cpi->key_frame_frequency == 0))) 3421 { 3422 /* Key frame from VFW/auto-keyframe/first frame */ 3423 cm->frame_type = KEY_FRAME; 3424 } 3425 3426#if CONFIG_MULTI_RES_ENCODING 3427 /* In multi-resolution encoding, frame_type is decided by lowest-resolution 3428 * encoder. Same frame_type is adopted while encoding at other resolution. 3429 */ 3430 if (cpi->oxcf.mr_encoder_id) 3431 { 3432 LOWER_RES_FRAME_INFO* low_res_frame_info 3433 = (LOWER_RES_FRAME_INFO*)cpi->oxcf.mr_low_res_mode_info; 3434 3435 cm->frame_type = low_res_frame_info->frame_type; 3436 3437 if(cm->frame_type != KEY_FRAME) 3438 { 3439 cpi->mr_low_res_mv_avail = 1; 3440 cpi->mr_low_res_mv_avail &= !(low_res_frame_info->is_frame_dropped); 3441 3442 if (cpi->ref_frame_flags & VP8_LAST_FRAME) 3443 cpi->mr_low_res_mv_avail &= (cpi->current_ref_frames[LAST_FRAME] 3444 == low_res_frame_info->low_res_ref_frames[LAST_FRAME]); 3445 3446 if (cpi->ref_frame_flags & VP8_GOLD_FRAME) 3447 cpi->mr_low_res_mv_avail &= (cpi->current_ref_frames[GOLDEN_FRAME] 3448 == low_res_frame_info->low_res_ref_frames[GOLDEN_FRAME]); 3449 3450 if (cpi->ref_frame_flags & VP8_ALTR_FRAME) 3451 cpi->mr_low_res_mv_avail &= (cpi->current_ref_frames[ALTREF_FRAME] 3452 == low_res_frame_info->low_res_ref_frames[ALTREF_FRAME]); 3453 } 3454 } 3455#endif 3456 3457 /* Set various flags etc to special state if it is a key frame */ 3458 if (cm->frame_type == KEY_FRAME) 3459 { 3460 int i; 3461 3462 // Set the loop filter deltas and segmentation map update 3463 setup_features(cpi); 3464 3465 /* The alternate reference frame cannot be active for a key frame */ 3466 cpi->source_alt_ref_active = 0; 3467 3468 /* Reset the RD threshold multipliers to default of * 1 (128) */ 3469 for (i = 0; i < MAX_MODES; i++) 3470 { 3471 cpi->mb.rd_thresh_mult[i] = 128; 3472 } 3473 } 3474 3475#if 0 3476 /* Experimental code for lagged compress and one pass 3477 * Initialise one_pass GF frames stats 3478 * Update stats used for GF selection 3479 */ 3480 { 3481 cpi->one_pass_frame_index = cm->current_video_frame % MAX_LAG_BUFFERS; 3482 3483 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frames_so_far = 0; 3484 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_intra_error = 0.0; 3485 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_coded_error = 0.0; 3486 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_inter = 0.0; 3487 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_motion = 0.0; 3488 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr = 0.0; 3489 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr_abs = 0.0; 3490 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc = 0.0; 3491 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc_abs = 0.0; 3492 } 3493#endif 3494 3495 update_rd_ref_frame_probs(cpi); 3496 3497 if (cpi->drop_frames_allowed) 3498 { 3499 /* The reset to decimation 0 is only done here for one pass. 3500 * Once it is set two pass leaves decimation on till the next kf. 3501 */ 3502 if ((cpi->buffer_level > drop_mark) && (cpi->decimation_factor > 0)) 3503 cpi->decimation_factor --; 3504 3505 if (cpi->buffer_level > drop_mark75 && cpi->decimation_factor > 0) 3506 cpi->decimation_factor = 1; 3507 3508 else if (cpi->buffer_level < drop_mark25 && (cpi->decimation_factor == 2 || cpi->decimation_factor == 3)) 3509 { 3510 cpi->decimation_factor = 3; 3511 } 3512 else if (cpi->buffer_level < drop_mark50 && (cpi->decimation_factor == 1 || cpi->decimation_factor == 2)) 3513 { 3514 cpi->decimation_factor = 2; 3515 } 3516 else if (cpi->buffer_level < drop_mark75 && (cpi->decimation_factor == 0 || cpi->decimation_factor == 1)) 3517 { 3518 cpi->decimation_factor = 1; 3519 } 3520 } 3521 3522 /* The following decimates the frame rate according to a regular 3523 * pattern (i.e. to 1/2 or 2/3 frame rate) This can be used to help 3524 * prevent buffer under-run in CBR mode. Alternatively it might be 3525 * desirable in some situations to drop frame rate but throw more bits 3526 * at each frame. 3527 * 3528 * Note that dropping a key frame can be problematic if spatial 3529 * resampling is also active 3530 */ 3531 if (cpi->decimation_factor > 0) 3532 { 3533 switch (cpi->decimation_factor) 3534 { 3535 case 1: 3536 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 3 / 2; 3537 break; 3538 case 2: 3539 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 5 / 4; 3540 break; 3541 case 3: 3542 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 5 / 4; 3543 break; 3544 } 3545 3546 /* Note that we should not throw out a key frame (especially when 3547 * spatial resampling is enabled). 3548 */ 3549 if (cm->frame_type == KEY_FRAME) 3550 { 3551 cpi->decimation_count = cpi->decimation_factor; 3552 } 3553 else if (cpi->decimation_count > 0) 3554 { 3555 cpi->decimation_count --; 3556 3557 cpi->bits_off_target += cpi->av_per_frame_bandwidth; 3558 if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size) 3559 cpi->bits_off_target = cpi->oxcf.maximum_buffer_size; 3560 3561#if CONFIG_MULTI_RES_ENCODING 3562 vp8_store_drop_frame_info(cpi); 3563#endif 3564 3565 cm->current_video_frame++; 3566 cpi->frames_since_key++; 3567 // We advance the temporal pattern for dropped frames. 3568 cpi->temporal_pattern_counter++; 3569 3570#if CONFIG_INTERNAL_STATS 3571 cpi->count ++; 3572#endif 3573 3574 cpi->buffer_level = cpi->bits_off_target; 3575 3576 if (cpi->oxcf.number_of_layers > 1) 3577 { 3578 unsigned int i; 3579 3580 /* Propagate bits saved by dropping the frame to higher 3581 * layers 3582 */ 3583 for (i=cpi->current_layer+1; i<cpi->oxcf.number_of_layers; i++) 3584 { 3585 LAYER_CONTEXT *lc = &cpi->layer_context[i]; 3586 lc->bits_off_target += (int)(lc->target_bandwidth / 3587 lc->framerate); 3588 if (lc->bits_off_target > lc->maximum_buffer_size) 3589 lc->bits_off_target = lc->maximum_buffer_size; 3590 lc->buffer_level = lc->bits_off_target; 3591 } 3592 } 3593 3594 return; 3595 } 3596 else 3597 cpi->decimation_count = cpi->decimation_factor; 3598 } 3599 else 3600 cpi->decimation_count = 0; 3601 3602 /* Decide how big to make the frame */ 3603 if (!vp8_pick_frame_size(cpi)) 3604 { 3605 /*TODO: 2 drop_frame and return code could be put together. */ 3606#if CONFIG_MULTI_RES_ENCODING 3607 vp8_store_drop_frame_info(cpi); 3608#endif 3609 cm->current_video_frame++; 3610 cpi->frames_since_key++; 3611 // We advance the temporal pattern for dropped frames. 3612 cpi->temporal_pattern_counter++; 3613 return; 3614 } 3615 3616 /* Reduce active_worst_allowed_q for CBR if our buffer is getting too full. 3617 * This has a knock on effect on active best quality as well. 3618 * For CBR if the buffer reaches its maximum level then we can no longer 3619 * save up bits for later frames so we might as well use them up 3620 * on the current frame. 3621 */ 3622 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) && 3623 (cpi->buffer_level >= cpi->oxcf.optimal_buffer_level) && cpi->buffered_mode) 3624 { 3625 /* Max adjustment is 1/4 */ 3626 int Adjustment = cpi->active_worst_quality / 4; 3627 3628 if (Adjustment) 3629 { 3630 int buff_lvl_step; 3631 3632 if (cpi->buffer_level < cpi->oxcf.maximum_buffer_size) 3633 { 3634 buff_lvl_step = (int) 3635 ((cpi->oxcf.maximum_buffer_size - 3636 cpi->oxcf.optimal_buffer_level) / 3637 Adjustment); 3638 3639 if (buff_lvl_step) 3640 Adjustment = (int) 3641 ((cpi->buffer_level - 3642 cpi->oxcf.optimal_buffer_level) / 3643 buff_lvl_step); 3644 else 3645 Adjustment = 0; 3646 } 3647 3648 cpi->active_worst_quality -= Adjustment; 3649 3650 if(cpi->active_worst_quality < cpi->active_best_quality) 3651 cpi->active_worst_quality = cpi->active_best_quality; 3652 } 3653 } 3654 3655 /* Set an active best quality and if necessary active worst quality 3656 * There is some odd behavior for one pass here that needs attention. 3657 */ 3658 if ( (cpi->pass == 2) || (cpi->ni_frames > 150)) 3659 { 3660 vp8_clear_system_state(); 3661 3662 Q = cpi->active_worst_quality; 3663 3664 if ( cm->frame_type == KEY_FRAME ) 3665 { 3666 if ( cpi->pass == 2 ) 3667 { 3668 if (cpi->gfu_boost > 600) 3669 cpi->active_best_quality = kf_low_motion_minq[Q]; 3670 else 3671 cpi->active_best_quality = kf_high_motion_minq[Q]; 3672 3673 /* Special case for key frames forced because we have reached 3674 * the maximum key frame interval. Here force the Q to a range 3675 * based on the ambient Q to reduce the risk of popping 3676 */ 3677 if ( cpi->this_key_frame_forced ) 3678 { 3679 if ( cpi->active_best_quality > cpi->avg_frame_qindex * 7/8) 3680 cpi->active_best_quality = cpi->avg_frame_qindex * 7/8; 3681 else if ( cpi->active_best_quality < cpi->avg_frame_qindex >> 2 ) 3682 cpi->active_best_quality = cpi->avg_frame_qindex >> 2; 3683 } 3684 } 3685 /* One pass more conservative */ 3686 else 3687 cpi->active_best_quality = kf_high_motion_minq[Q]; 3688 } 3689 3690 else if (cpi->oxcf.number_of_layers==1 && 3691 (cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame)) 3692 { 3693 /* Use the lower of cpi->active_worst_quality and recent 3694 * average Q as basis for GF/ARF Q limit unless last frame was 3695 * a key frame. 3696 */ 3697 if ( (cpi->frames_since_key > 1) && 3698 (cpi->avg_frame_qindex < cpi->active_worst_quality) ) 3699 { 3700 Q = cpi->avg_frame_qindex; 3701 } 3702 3703 /* For constrained quality dont allow Q less than the cq level */ 3704 if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) && 3705 (Q < cpi->cq_target_quality) ) 3706 { 3707 Q = cpi->cq_target_quality; 3708 } 3709 3710 if ( cpi->pass == 2 ) 3711 { 3712 if ( cpi->gfu_boost > 1000 ) 3713 cpi->active_best_quality = gf_low_motion_minq[Q]; 3714 else if ( cpi->gfu_boost < 400 ) 3715 cpi->active_best_quality = gf_high_motion_minq[Q]; 3716 else 3717 cpi->active_best_quality = gf_mid_motion_minq[Q]; 3718 3719 /* Constrained quality use slightly lower active best. */ 3720 if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY ) 3721 { 3722 cpi->active_best_quality = 3723 cpi->active_best_quality * 15/16; 3724 } 3725 } 3726 /* One pass more conservative */ 3727 else 3728 cpi->active_best_quality = gf_high_motion_minq[Q]; 3729 } 3730 else 3731 { 3732 cpi->active_best_quality = inter_minq[Q]; 3733 3734 /* For the constant/constrained quality mode we dont want 3735 * q to fall below the cq level. 3736 */ 3737 if ((cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) && 3738 (cpi->active_best_quality < cpi->cq_target_quality) ) 3739 { 3740 /* If we are strongly undershooting the target rate in the last 3741 * frames then use the user passed in cq value not the auto 3742 * cq value. 3743 */ 3744 if ( cpi->rolling_actual_bits < cpi->min_frame_bandwidth ) 3745 cpi->active_best_quality = cpi->oxcf.cq_level; 3746 else 3747 cpi->active_best_quality = cpi->cq_target_quality; 3748 } 3749 } 3750 3751 /* If CBR and the buffer is as full then it is reasonable to allow 3752 * higher quality on the frames to prevent bits just going to waste. 3753 */ 3754 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 3755 { 3756 /* Note that the use of >= here elliminates the risk of a devide 3757 * by 0 error in the else if clause 3758 */ 3759 if (cpi->buffer_level >= cpi->oxcf.maximum_buffer_size) 3760 cpi->active_best_quality = cpi->best_quality; 3761 3762 else if (cpi->buffer_level > cpi->oxcf.optimal_buffer_level) 3763 { 3764 int Fraction = (int) 3765 (((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) * 128) 3766 / (cpi->oxcf.maximum_buffer_size - 3767 cpi->oxcf.optimal_buffer_level)); 3768 int min_qadjustment = ((cpi->active_best_quality - 3769 cpi->best_quality) * Fraction) / 128; 3770 3771 cpi->active_best_quality -= min_qadjustment; 3772 } 3773 } 3774 } 3775 /* Make sure constrained quality mode limits are adhered to for the first 3776 * few frames of one pass encodes 3777 */ 3778 else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) 3779 { 3780 if ( (cm->frame_type == KEY_FRAME) || 3781 cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame ) 3782 { 3783 cpi->active_best_quality = cpi->best_quality; 3784 } 3785 else if (cpi->active_best_quality < cpi->cq_target_quality) 3786 { 3787 cpi->active_best_quality = cpi->cq_target_quality; 3788 } 3789 } 3790 3791 /* Clip the active best and worst quality values to limits */ 3792 if (cpi->active_worst_quality > cpi->worst_quality) 3793 cpi->active_worst_quality = cpi->worst_quality; 3794 3795 if (cpi->active_best_quality < cpi->best_quality) 3796 cpi->active_best_quality = cpi->best_quality; 3797 3798 if ( cpi->active_worst_quality < cpi->active_best_quality ) 3799 cpi->active_worst_quality = cpi->active_best_quality; 3800 3801 /* Determine initial Q to try */ 3802 Q = vp8_regulate_q(cpi, cpi->this_frame_target); 3803 3804#if !(CONFIG_REALTIME_ONLY) 3805 3806 /* Set highest allowed value for Zbin over quant */ 3807 if (cm->frame_type == KEY_FRAME) 3808 zbin_oq_high = 0; 3809 else if ((cpi->oxcf.number_of_layers == 1) && ((cm->refresh_alt_ref_frame || 3810 (cm->refresh_golden_frame && !cpi->source_alt_ref_active)))) 3811 { 3812 zbin_oq_high = 16; 3813 } 3814 else 3815 zbin_oq_high = ZBIN_OQ_MAX; 3816#endif 3817 3818 /* Setup background Q adjustment for error resilient mode. 3819 * For multi-layer encodes only enable this for the base layer. 3820 */ 3821 if (cpi->cyclic_refresh_mode_enabled) 3822 { 3823 if (cpi->current_layer==0) 3824 cyclic_background_refresh(cpi, Q, 0); 3825 else 3826 disable_segmentation(cpi); 3827 } 3828 3829 vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit); 3830 3831#if !(CONFIG_REALTIME_ONLY) 3832 /* Limit Q range for the adaptive loop. */ 3833 bottom_index = cpi->active_best_quality; 3834 top_index = cpi->active_worst_quality; 3835 q_low = cpi->active_best_quality; 3836 q_high = cpi->active_worst_quality; 3837#endif 3838 3839 vp8_save_coding_context(cpi); 3840 3841 loop_count = 0; 3842 3843 scale_and_extend_source(cpi->un_scaled_source, cpi); 3844 3845#if !(CONFIG_REALTIME_ONLY) && CONFIG_POSTPROC && !(CONFIG_TEMPORAL_DENOISING) 3846 3847 if (cpi->oxcf.noise_sensitivity > 0) 3848 { 3849 unsigned char *src; 3850 int l = 0; 3851 3852 switch (cpi->oxcf.noise_sensitivity) 3853 { 3854 case 1: 3855 l = 20; 3856 break; 3857 case 2: 3858 l = 40; 3859 break; 3860 case 3: 3861 l = 60; 3862 break; 3863 case 4: 3864 l = 80; 3865 break; 3866 case 5: 3867 l = 100; 3868 break; 3869 case 6: 3870 l = 150; 3871 break; 3872 } 3873 3874 3875 if (cm->frame_type == KEY_FRAME) 3876 { 3877 vp8_de_noise(cm, cpi->Source, cpi->Source, l , 1, 0); 3878 } 3879 else 3880 { 3881 vp8_de_noise(cm, cpi->Source, cpi->Source, l , 1, 0); 3882 3883 src = cpi->Source->y_buffer; 3884 3885 if (cpi->Source->y_stride < 0) 3886 { 3887 src += cpi->Source->y_stride * (cpi->Source->y_height - 1); 3888 } 3889 } 3890 } 3891 3892#endif 3893 3894#ifdef OUTPUT_YUV_SRC 3895 vp8_write_yuv_frame(cpi->Source); 3896#endif 3897 3898 do 3899 { 3900 vp8_clear_system_state(); 3901 3902 vp8_set_quantizer(cpi, Q); 3903 3904 /* setup skip prob for costing in mode/mv decision */ 3905 if (cpi->common.mb_no_coeff_skip) 3906 { 3907 cpi->prob_skip_false = cpi->base_skip_false_prob[Q]; 3908 3909 if (cm->frame_type != KEY_FRAME) 3910 { 3911 if (cpi->common.refresh_alt_ref_frame) 3912 { 3913 if (cpi->last_skip_false_probs[2] != 0) 3914 cpi->prob_skip_false = cpi->last_skip_false_probs[2]; 3915 3916 /* 3917 if(cpi->last_skip_false_probs[2]!=0 && abs(Q- cpi->last_skip_probs_q[2])<=16 ) 3918 cpi->prob_skip_false = cpi->last_skip_false_probs[2]; 3919 else if (cpi->last_skip_false_probs[2]!=0) 3920 cpi->prob_skip_false = (cpi->last_skip_false_probs[2] + cpi->prob_skip_false ) / 2; 3921 */ 3922 } 3923 else if (cpi->common.refresh_golden_frame) 3924 { 3925 if (cpi->last_skip_false_probs[1] != 0) 3926 cpi->prob_skip_false = cpi->last_skip_false_probs[1]; 3927 3928 /* 3929 if(cpi->last_skip_false_probs[1]!=0 && abs(Q- cpi->last_skip_probs_q[1])<=16 ) 3930 cpi->prob_skip_false = cpi->last_skip_false_probs[1]; 3931 else if (cpi->last_skip_false_probs[1]!=0) 3932 cpi->prob_skip_false = (cpi->last_skip_false_probs[1] + cpi->prob_skip_false ) / 2; 3933 */ 3934 } 3935 else 3936 { 3937 if (cpi->last_skip_false_probs[0] != 0) 3938 cpi->prob_skip_false = cpi->last_skip_false_probs[0]; 3939 3940 /* 3941 if(cpi->last_skip_false_probs[0]!=0 && abs(Q- cpi->last_skip_probs_q[0])<=16 ) 3942 cpi->prob_skip_false = cpi->last_skip_false_probs[0]; 3943 else if(cpi->last_skip_false_probs[0]!=0) 3944 cpi->prob_skip_false = (cpi->last_skip_false_probs[0] + cpi->prob_skip_false ) / 2; 3945 */ 3946 } 3947 3948 /* as this is for cost estimate, let's make sure it does not 3949 * go extreme eitehr way 3950 */ 3951 if (cpi->prob_skip_false < 5) 3952 cpi->prob_skip_false = 5; 3953 3954 if (cpi->prob_skip_false > 250) 3955 cpi->prob_skip_false = 250; 3956 3957 if (cpi->oxcf.number_of_layers == 1 && cpi->is_src_frame_alt_ref) 3958 cpi->prob_skip_false = 1; 3959 } 3960 3961#if 0 3962 3963 if (cpi->pass != 1) 3964 { 3965 FILE *f = fopen("skip.stt", "a"); 3966 fprintf(f, "%d, %d, %4d ", cpi->common.refresh_golden_frame, cpi->common.refresh_alt_ref_frame, cpi->prob_skip_false); 3967 fclose(f); 3968 } 3969 3970#endif 3971 3972 } 3973 3974 if (cm->frame_type == KEY_FRAME) 3975 { 3976 if(resize_key_frame(cpi)) 3977 { 3978 /* If the frame size has changed, need to reset Q, quantizer, 3979 * and background refresh. 3980 */ 3981 Q = vp8_regulate_q(cpi, cpi->this_frame_target); 3982 if (cpi->cyclic_refresh_mode_enabled) 3983 { 3984 if (cpi->current_layer==0) 3985 cyclic_background_refresh(cpi, Q, 0); 3986 else 3987 disable_segmentation(cpi); 3988 } 3989 vp8_set_quantizer(cpi, Q); 3990 } 3991 3992 vp8_setup_key_frame(cpi); 3993 } 3994 3995 3996 3997#if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING 3998 { 3999 if(cpi->oxcf.error_resilient_mode) 4000 cm->refresh_entropy_probs = 0; 4001 4002 if (cpi->oxcf.error_resilient_mode & VPX_ERROR_RESILIENT_PARTITIONS) 4003 { 4004 if (cm->frame_type == KEY_FRAME) 4005 cm->refresh_entropy_probs = 1; 4006 } 4007 4008 if (cm->refresh_entropy_probs == 0) 4009 { 4010 /* save a copy for later refresh */ 4011 vpx_memcpy(&cm->lfc, &cm->fc, sizeof(cm->fc)); 4012 } 4013 4014 vp8_update_coef_context(cpi); 4015 4016 vp8_update_coef_probs(cpi); 4017 4018 /* transform / motion compensation build reconstruction frame 4019 * +pack coef partitions 4020 */ 4021 vp8_encode_frame(cpi); 4022 4023 /* cpi->projected_frame_size is not needed for RT mode */ 4024 } 4025#else 4026 /* transform / motion compensation build reconstruction frame */ 4027 vp8_encode_frame(cpi); 4028 4029 cpi->projected_frame_size -= vp8_estimate_entropy_savings(cpi); 4030 cpi->projected_frame_size = (cpi->projected_frame_size > 0) ? cpi->projected_frame_size : 0; 4031#endif 4032 vp8_clear_system_state(); 4033 4034 /* Test to see if the stats generated for this frame indicate that 4035 * we should have coded a key frame (assuming that we didn't)! 4036 */ 4037 4038 if (cpi->pass != 2 && cpi->oxcf.auto_key && cm->frame_type != KEY_FRAME 4039 && cpi->compressor_speed != 2) 4040 { 4041#if !(CONFIG_REALTIME_ONLY) 4042 if (decide_key_frame(cpi)) 4043 { 4044 /* Reset all our sizing numbers and recode */ 4045 cm->frame_type = KEY_FRAME; 4046 4047 vp8_pick_frame_size(cpi); 4048 4049 /* Clear the Alt reference frame active flag when we have 4050 * a key frame 4051 */ 4052 cpi->source_alt_ref_active = 0; 4053 4054 // Set the loop filter deltas and segmentation map update 4055 setup_features(cpi); 4056 4057 vp8_restore_coding_context(cpi); 4058 4059 Q = vp8_regulate_q(cpi, cpi->this_frame_target); 4060 4061 vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit); 4062 4063 /* Limit Q range for the adaptive loop. */ 4064 bottom_index = cpi->active_best_quality; 4065 top_index = cpi->active_worst_quality; 4066 q_low = cpi->active_best_quality; 4067 q_high = cpi->active_worst_quality; 4068 4069 loop_count++; 4070 Loop = 1; 4071 4072 continue; 4073 } 4074#endif 4075 } 4076 4077 vp8_clear_system_state(); 4078 4079 if (frame_over_shoot_limit == 0) 4080 frame_over_shoot_limit = 1; 4081 4082 /* Are we are overshooting and up against the limit of active max Q. */ 4083 if (((cpi->pass != 2) || (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)) && 4084 (Q == cpi->active_worst_quality) && 4085 (cpi->active_worst_quality < cpi->worst_quality) && 4086 (cpi->projected_frame_size > frame_over_shoot_limit)) 4087 { 4088 int over_size_percent = ((cpi->projected_frame_size - frame_over_shoot_limit) * 100) / frame_over_shoot_limit; 4089 4090 /* If so is there any scope for relaxing it */ 4091 while ((cpi->active_worst_quality < cpi->worst_quality) && (over_size_percent > 0)) 4092 { 4093 cpi->active_worst_quality++; 4094 /* Assume 1 qstep = about 4% on frame size. */ 4095 over_size_percent = (int)(over_size_percent * 0.96); 4096 } 4097#if !(CONFIG_REALTIME_ONLY) 4098 top_index = cpi->active_worst_quality; 4099#endif 4100 /* If we have updated the active max Q do not call 4101 * vp8_update_rate_correction_factors() this loop. 4102 */ 4103 active_worst_qchanged = 1; 4104 } 4105 else 4106 active_worst_qchanged = 0; 4107 4108#if !(CONFIG_REALTIME_ONLY) 4109 /* Special case handling for forced key frames */ 4110 if ( (cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced ) 4111 { 4112 int last_q = Q; 4113 int kf_err = vp8_calc_ss_err(cpi->Source, 4114 &cm->yv12_fb[cm->new_fb_idx]); 4115 4116 /* The key frame is not good enough */ 4117 if ( kf_err > ((cpi->ambient_err * 7) >> 3) ) 4118 { 4119 /* Lower q_high */ 4120 q_high = (Q > q_low) ? (Q - 1) : q_low; 4121 4122 /* Adjust Q */ 4123 Q = (q_high + q_low) >> 1; 4124 } 4125 /* The key frame is much better than the previous frame */ 4126 else if ( kf_err < (cpi->ambient_err >> 1) ) 4127 { 4128 /* Raise q_low */ 4129 q_low = (Q < q_high) ? (Q + 1) : q_high; 4130 4131 /* Adjust Q */ 4132 Q = (q_high + q_low + 1) >> 1; 4133 } 4134 4135 /* Clamp Q to upper and lower limits: */ 4136 if (Q > q_high) 4137 Q = q_high; 4138 else if (Q < q_low) 4139 Q = q_low; 4140 4141 Loop = Q != last_q; 4142 } 4143 4144 /* Is the projected frame size out of range and are we allowed 4145 * to attempt to recode. 4146 */ 4147 else if ( recode_loop_test( cpi, 4148 frame_over_shoot_limit, frame_under_shoot_limit, 4149 Q, top_index, bottom_index ) ) 4150 { 4151 int last_q = Q; 4152 int Retries = 0; 4153 4154 /* Frame size out of permitted range. Update correction factor 4155 * & compute new Q to try... 4156 */ 4157 4158 /* Frame is too large */ 4159 if (cpi->projected_frame_size > cpi->this_frame_target) 4160 { 4161 /* Raise Qlow as to at least the current value */ 4162 q_low = (Q < q_high) ? (Q + 1) : q_high; 4163 4164 /* If we are using over quant do the same for zbin_oq_low */ 4165 if (cpi->mb.zbin_over_quant > 0) 4166 zbin_oq_low = (cpi->mb.zbin_over_quant < zbin_oq_high) ? 4167 (cpi->mb.zbin_over_quant + 1) : zbin_oq_high; 4168 4169 if (undershoot_seen) 4170 { 4171 /* Update rate_correction_factor unless 4172 * cpi->active_worst_quality has changed. 4173 */ 4174 if (!active_worst_qchanged) 4175 vp8_update_rate_correction_factors(cpi, 1); 4176 4177 Q = (q_high + q_low + 1) / 2; 4178 4179 /* Adjust cpi->zbin_over_quant (only allowed when Q 4180 * is max) 4181 */ 4182 if (Q < MAXQ) 4183 cpi->mb.zbin_over_quant = 0; 4184 else 4185 { 4186 zbin_oq_low = (cpi->mb.zbin_over_quant < zbin_oq_high) ? 4187 (cpi->mb.zbin_over_quant + 1) : zbin_oq_high; 4188 cpi->mb.zbin_over_quant = 4189 (zbin_oq_high + zbin_oq_low) / 2; 4190 } 4191 } 4192 else 4193 { 4194 /* Update rate_correction_factor unless 4195 * cpi->active_worst_quality has changed. 4196 */ 4197 if (!active_worst_qchanged) 4198 vp8_update_rate_correction_factors(cpi, 0); 4199 4200 Q = vp8_regulate_q(cpi, cpi->this_frame_target); 4201 4202 while (((Q < q_low) || 4203 (cpi->mb.zbin_over_quant < zbin_oq_low)) && 4204 (Retries < 10)) 4205 { 4206 vp8_update_rate_correction_factors(cpi, 0); 4207 Q = vp8_regulate_q(cpi, cpi->this_frame_target); 4208 Retries ++; 4209 } 4210 } 4211 4212 overshoot_seen = 1; 4213 } 4214 /* Frame is too small */ 4215 else 4216 { 4217 if (cpi->mb.zbin_over_quant == 0) 4218 /* Lower q_high if not using over quant */ 4219 q_high = (Q > q_low) ? (Q - 1) : q_low; 4220 else 4221 /* else lower zbin_oq_high */ 4222 zbin_oq_high = (cpi->mb.zbin_over_quant > zbin_oq_low) ? 4223 (cpi->mb.zbin_over_quant - 1) : zbin_oq_low; 4224 4225 if (overshoot_seen) 4226 { 4227 /* Update rate_correction_factor unless 4228 * cpi->active_worst_quality has changed. 4229 */ 4230 if (!active_worst_qchanged) 4231 vp8_update_rate_correction_factors(cpi, 1); 4232 4233 Q = (q_high + q_low) / 2; 4234 4235 /* Adjust cpi->zbin_over_quant (only allowed when Q 4236 * is max) 4237 */ 4238 if (Q < MAXQ) 4239 cpi->mb.zbin_over_quant = 0; 4240 else 4241 cpi->mb.zbin_over_quant = 4242 (zbin_oq_high + zbin_oq_low) / 2; 4243 } 4244 else 4245 { 4246 /* Update rate_correction_factor unless 4247 * cpi->active_worst_quality has changed. 4248 */ 4249 if (!active_worst_qchanged) 4250 vp8_update_rate_correction_factors(cpi, 0); 4251 4252 Q = vp8_regulate_q(cpi, cpi->this_frame_target); 4253 4254 /* Special case reset for qlow for constrained quality. 4255 * This should only trigger where there is very substantial 4256 * undershoot on a frame and the auto cq level is above 4257 * the user passsed in value. 4258 */ 4259 if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) && 4260 (Q < q_low) ) 4261 { 4262 q_low = Q; 4263 } 4264 4265 while (((Q > q_high) || 4266 (cpi->mb.zbin_over_quant > zbin_oq_high)) && 4267 (Retries < 10)) 4268 { 4269 vp8_update_rate_correction_factors(cpi, 0); 4270 Q = vp8_regulate_q(cpi, cpi->this_frame_target); 4271 Retries ++; 4272 } 4273 } 4274 4275 undershoot_seen = 1; 4276 } 4277 4278 /* Clamp Q to upper and lower limits: */ 4279 if (Q > q_high) 4280 Q = q_high; 4281 else if (Q < q_low) 4282 Q = q_low; 4283 4284 /* Clamp cpi->zbin_over_quant */ 4285 cpi->mb.zbin_over_quant = (cpi->mb.zbin_over_quant < zbin_oq_low) ? 4286 zbin_oq_low : (cpi->mb.zbin_over_quant > zbin_oq_high) ? 4287 zbin_oq_high : cpi->mb.zbin_over_quant; 4288 4289 Loop = Q != last_q; 4290 } 4291 else 4292#endif 4293 Loop = 0; 4294 4295 if (cpi->is_src_frame_alt_ref) 4296 Loop = 0; 4297 4298 if (Loop == 1) 4299 { 4300 vp8_restore_coding_context(cpi); 4301 loop_count++; 4302#if CONFIG_INTERNAL_STATS 4303 cpi->tot_recode_hits++; 4304#endif 4305 } 4306 } 4307 while (Loop == 1); 4308 4309#if 0 4310 /* Experimental code for lagged and one pass 4311 * Update stats used for one pass GF selection 4312 */ 4313 { 4314 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_coded_error = (double)cpi->prediction_error; 4315 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_intra_error = (double)cpi->intra_error; 4316 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_pcnt_inter = (double)(100 - cpi->this_frame_percent_intra) / 100.0; 4317 } 4318#endif 4319 4320 /* Special case code to reduce pulsing when key frames are forced at a 4321 * fixed interval. Note the reconstruction error if it is the frame before 4322 * the force key frame 4323 */ 4324 if ( cpi->next_key_frame_forced && (cpi->twopass.frames_to_key == 0) ) 4325 { 4326 cpi->ambient_err = vp8_calc_ss_err(cpi->Source, 4327 &cm->yv12_fb[cm->new_fb_idx]); 4328 } 4329 4330 /* This frame's MVs are saved and will be used in next frame's MV predictor. 4331 * Last frame has one more line(add to bottom) and one more column(add to 4332 * right) than cm->mip. The edge elements are initialized to 0. 4333 */ 4334#if CONFIG_MULTI_RES_ENCODING 4335 if(!cpi->oxcf.mr_encoder_id && cm->show_frame) 4336#else 4337 if(cm->show_frame) /* do not save for altref frame */ 4338#endif 4339 { 4340 int mb_row; 4341 int mb_col; 4342 /* Point to beginning of allocated MODE_INFO arrays. */ 4343 MODE_INFO *tmp = cm->mip; 4344 4345 if(cm->frame_type != KEY_FRAME) 4346 { 4347 for (mb_row = 0; mb_row < cm->mb_rows+1; mb_row ++) 4348 { 4349 for (mb_col = 0; mb_col < cm->mb_cols+1; mb_col ++) 4350 { 4351 if(tmp->mbmi.ref_frame != INTRA_FRAME) 4352 cpi->lfmv[mb_col + mb_row*(cm->mode_info_stride+1)].as_int = tmp->mbmi.mv.as_int; 4353 4354 cpi->lf_ref_frame_sign_bias[mb_col + mb_row*(cm->mode_info_stride+1)] = cm->ref_frame_sign_bias[tmp->mbmi.ref_frame]; 4355 cpi->lf_ref_frame[mb_col + mb_row*(cm->mode_info_stride+1)] = tmp->mbmi.ref_frame; 4356 tmp++; 4357 } 4358 } 4359 } 4360 } 4361 4362 /* Count last ref frame 0,0 usage on current encoded frame. */ 4363 { 4364 int mb_row; 4365 int mb_col; 4366 /* Point to beginning of MODE_INFO arrays. */ 4367 MODE_INFO *tmp = cm->mi; 4368 4369 cpi->zeromv_count = 0; 4370 4371 if(cm->frame_type != KEY_FRAME) 4372 { 4373 for (mb_row = 0; mb_row < cm->mb_rows; mb_row ++) 4374 { 4375 for (mb_col = 0; mb_col < cm->mb_cols; mb_col ++) 4376 { 4377 if(tmp->mbmi.mode == ZEROMV) 4378 cpi->zeromv_count++; 4379 tmp++; 4380 } 4381 tmp++; 4382 } 4383 } 4384 } 4385 4386#if CONFIG_MULTI_RES_ENCODING 4387 vp8_cal_dissimilarity(cpi); 4388#endif 4389 4390 /* Update the GF useage maps. 4391 * This is done after completing the compression of a frame when all 4392 * modes etc. are finalized but before loop filter 4393 */ 4394 if (cpi->oxcf.number_of_layers == 1) 4395 vp8_update_gf_useage_maps(cpi, cm, &cpi->mb); 4396 4397 if (cm->frame_type == KEY_FRAME) 4398 cm->refresh_last_frame = 1; 4399 4400#if 0 4401 { 4402 FILE *f = fopen("gfactive.stt", "a"); 4403 fprintf(f, "%8d %8d %8d %8d %8d\n", cm->current_video_frame, (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols), cpi->this_iiratio, cpi->next_iiratio, cm->refresh_golden_frame); 4404 fclose(f); 4405 } 4406#endif 4407 4408 /* For inter frames the current default behavior is that when 4409 * cm->refresh_golden_frame is set we copy the old GF over to the ARF buffer 4410 * This is purely an encoder decision at present. 4411 */ 4412 if (!cpi->oxcf.error_resilient_mode && cm->refresh_golden_frame) 4413 cm->copy_buffer_to_arf = 2; 4414 else 4415 cm->copy_buffer_to_arf = 0; 4416 4417 cm->frame_to_show = &cm->yv12_fb[cm->new_fb_idx]; 4418 4419#if CONFIG_MULTITHREAD 4420 if (cpi->b_multi_threaded) 4421 { 4422 /* start loopfilter in separate thread */ 4423 sem_post(&cpi->h_event_start_lpf); 4424 cpi->b_lpf_running = 1; 4425 } 4426 else 4427#endif 4428 { 4429 vp8_loopfilter_frame(cpi, cm); 4430 } 4431 4432 update_reference_frames(cpi); 4433 4434#if !(CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING) 4435 if (cpi->oxcf.error_resilient_mode) 4436 { 4437 cm->refresh_entropy_probs = 0; 4438 } 4439#endif 4440 4441#if CONFIG_MULTITHREAD 4442 /* wait that filter_level is picked so that we can continue with stream packing */ 4443 if (cpi->b_multi_threaded) 4444 sem_wait(&cpi->h_event_end_lpf); 4445#endif 4446 4447 /* build the bitstream */ 4448 vp8_pack_bitstream(cpi, dest, dest_end, size); 4449 4450#if CONFIG_MULTITHREAD 4451 /* if PSNR packets are generated we have to wait for the lpf */ 4452 if (cpi->b_lpf_running && cpi->b_calculate_psnr) 4453 { 4454 sem_wait(&cpi->h_event_end_lpf); 4455 cpi->b_lpf_running = 0; 4456 } 4457#endif 4458 4459 /* Move storing frame_type out of the above loop since it is also 4460 * needed in motion search besides loopfilter */ 4461 cm->last_frame_type = cm->frame_type; 4462 4463 /* Update rate control heuristics */ 4464 cpi->total_byte_count += (*size); 4465 cpi->projected_frame_size = (*size) << 3; 4466 4467 if (cpi->oxcf.number_of_layers > 1) 4468 { 4469 unsigned int i; 4470 for (i=cpi->current_layer+1; i<cpi->oxcf.number_of_layers; i++) 4471 cpi->layer_context[i].total_byte_count += (*size); 4472 } 4473 4474 if (!active_worst_qchanged) 4475 vp8_update_rate_correction_factors(cpi, 2); 4476 4477 cpi->last_q[cm->frame_type] = cm->base_qindex; 4478 4479 if (cm->frame_type == KEY_FRAME) 4480 { 4481 vp8_adjust_key_frame_context(cpi); 4482 } 4483 4484 /* Keep a record of ambient average Q. */ 4485 if (cm->frame_type != KEY_FRAME) 4486 cpi->avg_frame_qindex = (2 + 3 * cpi->avg_frame_qindex + cm->base_qindex) >> 2; 4487 4488 /* Keep a record from which we can calculate the average Q excluding 4489 * GF updates and key frames 4490 */ 4491 if ((cm->frame_type != KEY_FRAME) && ((cpi->oxcf.number_of_layers > 1) || 4492 (!cm->refresh_golden_frame && !cm->refresh_alt_ref_frame))) 4493 { 4494 cpi->ni_frames++; 4495 4496 /* Calculate the average Q for normal inter frames (not key or GFU 4497 * frames). 4498 */ 4499 if ( cpi->pass == 2 ) 4500 { 4501 cpi->ni_tot_qi += Q; 4502 cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames); 4503 } 4504 else 4505 { 4506 /* Damp value for first few frames */ 4507 if (cpi->ni_frames > 150 ) 4508 { 4509 cpi->ni_tot_qi += Q; 4510 cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames); 4511 } 4512 /* For one pass, early in the clip ... average the current frame Q 4513 * value with the worstq entered by the user as a dampening measure 4514 */ 4515 else 4516 { 4517 cpi->ni_tot_qi += Q; 4518 cpi->ni_av_qi = ((cpi->ni_tot_qi / cpi->ni_frames) + cpi->worst_quality + 1) / 2; 4519 } 4520 4521 /* If the average Q is higher than what was used in the last 4522 * frame (after going through the recode loop to keep the frame 4523 * size within range) then use the last frame value - 1. The -1 4524 * is designed to stop Q and hence the data rate, from 4525 * progressively falling away during difficult sections, but at 4526 * the same time reduce the number of itterations around the 4527 * recode loop. 4528 */ 4529 if (Q > cpi->ni_av_qi) 4530 cpi->ni_av_qi = Q - 1; 4531 } 4532 } 4533 4534 /* Update the buffer level variable. */ 4535 /* Non-viewable frames are a special case and are treated as pure overhead. */ 4536 if ( !cm->show_frame ) 4537 cpi->bits_off_target -= cpi->projected_frame_size; 4538 else 4539 cpi->bits_off_target += cpi->av_per_frame_bandwidth - cpi->projected_frame_size; 4540 4541 /* Clip the buffer level to the maximum specified buffer size */ 4542 if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size) 4543 cpi->bits_off_target = cpi->oxcf.maximum_buffer_size; 4544 4545 /* Rolling monitors of whether we are over or underspending used to 4546 * help regulate min and Max Q in two pass. 4547 */ 4548 cpi->rolling_target_bits = ((cpi->rolling_target_bits * 3) + cpi->this_frame_target + 2) / 4; 4549 cpi->rolling_actual_bits = ((cpi->rolling_actual_bits * 3) + cpi->projected_frame_size + 2) / 4; 4550 cpi->long_rolling_target_bits = ((cpi->long_rolling_target_bits * 31) + cpi->this_frame_target + 16) / 32; 4551 cpi->long_rolling_actual_bits = ((cpi->long_rolling_actual_bits * 31) + cpi->projected_frame_size + 16) / 32; 4552 4553 /* Actual bits spent */ 4554 cpi->total_actual_bits += cpi->projected_frame_size; 4555 4556 /* Debug stats */ 4557 cpi->total_target_vs_actual += (cpi->this_frame_target - cpi->projected_frame_size); 4558 4559 cpi->buffer_level = cpi->bits_off_target; 4560 4561 /* Propagate values to higher temporal layers */ 4562 if (cpi->oxcf.number_of_layers > 1) 4563 { 4564 unsigned int i; 4565 4566 for (i=cpi->current_layer+1; i<cpi->oxcf.number_of_layers; i++) 4567 { 4568 LAYER_CONTEXT *lc = &cpi->layer_context[i]; 4569 int bits_off_for_this_layer = 4570 (int)(lc->target_bandwidth / lc->framerate - 4571 cpi->projected_frame_size); 4572 4573 lc->bits_off_target += bits_off_for_this_layer; 4574 4575 /* Clip buffer level to maximum buffer size for the layer */ 4576 if (lc->bits_off_target > lc->maximum_buffer_size) 4577 lc->bits_off_target = lc->maximum_buffer_size; 4578 4579 lc->total_actual_bits += cpi->projected_frame_size; 4580 lc->total_target_vs_actual += bits_off_for_this_layer; 4581 lc->buffer_level = lc->bits_off_target; 4582 } 4583 } 4584 4585 /* Update bits left to the kf and gf groups to account for overshoot 4586 * or undershoot on these frames 4587 */ 4588 if (cm->frame_type == KEY_FRAME) 4589 { 4590 cpi->twopass.kf_group_bits += cpi->this_frame_target - cpi->projected_frame_size; 4591 4592 if (cpi->twopass.kf_group_bits < 0) 4593 cpi->twopass.kf_group_bits = 0 ; 4594 } 4595 else if (cm->refresh_golden_frame || cm->refresh_alt_ref_frame) 4596 { 4597 cpi->twopass.gf_group_bits += cpi->this_frame_target - cpi->projected_frame_size; 4598 4599 if (cpi->twopass.gf_group_bits < 0) 4600 cpi->twopass.gf_group_bits = 0 ; 4601 } 4602 4603 if (cm->frame_type != KEY_FRAME) 4604 { 4605 if (cpi->common.refresh_alt_ref_frame) 4606 { 4607 cpi->last_skip_false_probs[2] = cpi->prob_skip_false; 4608 cpi->last_skip_probs_q[2] = cm->base_qindex; 4609 } 4610 else if (cpi->common.refresh_golden_frame) 4611 { 4612 cpi->last_skip_false_probs[1] = cpi->prob_skip_false; 4613 cpi->last_skip_probs_q[1] = cm->base_qindex; 4614 } 4615 else 4616 { 4617 cpi->last_skip_false_probs[0] = cpi->prob_skip_false; 4618 cpi->last_skip_probs_q[0] = cm->base_qindex; 4619 4620 /* update the baseline */ 4621 cpi->base_skip_false_prob[cm->base_qindex] = cpi->prob_skip_false; 4622 4623 } 4624 } 4625 4626#if 0 && CONFIG_INTERNAL_STATS 4627 { 4628 FILE *f = fopen("tmp.stt", "a"); 4629 4630 vp8_clear_system_state(); 4631 4632 if (cpi->twopass.total_left_stats.coded_error != 0.0) 4633 fprintf(f, "%10d %10d %10d %10d %10d %10"PRId64" %10"PRId64 4634 "%10"PRId64" %10d %6d %6d %6d %6d %5d %5d %5d %8d " 4635 "%8.2lf %"PRId64" %10.3lf %10"PRId64" %8d\n", 4636 cpi->common.current_video_frame, cpi->this_frame_target, 4637 cpi->projected_frame_size, 4638 (cpi->projected_frame_size - cpi->this_frame_target), 4639 cpi->total_target_vs_actual, 4640 cpi->buffer_level, 4641 (cpi->oxcf.starting_buffer_level-cpi->bits_off_target), 4642 cpi->total_actual_bits, cm->base_qindex, 4643 cpi->active_best_quality, cpi->active_worst_quality, 4644 cpi->ni_av_qi, cpi->cq_target_quality, 4645 cm->refresh_golden_frame, cm->refresh_alt_ref_frame, 4646 cm->frame_type, cpi->gfu_boost, 4647 cpi->twopass.est_max_qcorrection_factor, 4648 cpi->twopass.bits_left, 4649 cpi->twopass.total_left_stats.coded_error, 4650 (double)cpi->twopass.bits_left / 4651 cpi->twopass.total_left_stats.coded_error, 4652 cpi->tot_recode_hits); 4653 else 4654 fprintf(f, "%10d %10d %10d %10d %10d %10"PRId64" %10"PRId64 4655 "%10"PRId64" %10d %6d %6d %6d %6d %5d %5d %5d %8d " 4656 "%8.2lf %"PRId64" %10.3lf %8d\n", 4657 cpi->common.current_video_frame, cpi->this_frame_target, 4658 cpi->projected_frame_size, 4659 (cpi->projected_frame_size - cpi->this_frame_target), 4660 cpi->total_target_vs_actual, 4661 cpi->buffer_level, 4662 (cpi->oxcf.starting_buffer_level-cpi->bits_off_target), 4663 cpi->total_actual_bits, cm->base_qindex, 4664 cpi->active_best_quality, cpi->active_worst_quality, 4665 cpi->ni_av_qi, cpi->cq_target_quality, 4666 cm->refresh_golden_frame, cm->refresh_alt_ref_frame, 4667 cm->frame_type, cpi->gfu_boost, 4668 cpi->twopass.est_max_qcorrection_factor, 4669 cpi->twopass.bits_left, 4670 cpi->twopass.total_left_stats.coded_error, 4671 cpi->tot_recode_hits); 4672 4673 fclose(f); 4674 4675 { 4676 FILE *fmodes = fopen("Modes.stt", "a"); 4677 4678 fprintf(fmodes, "%6d:%1d:%1d:%1d ", 4679 cpi->common.current_video_frame, 4680 cm->frame_type, cm->refresh_golden_frame, 4681 cm->refresh_alt_ref_frame); 4682 4683 fprintf(fmodes, "\n"); 4684 4685 fclose(fmodes); 4686 } 4687 } 4688 4689#endif 4690 4691 if (cm->refresh_golden_frame == 1) 4692 cm->frame_flags = cm->frame_flags | FRAMEFLAGS_GOLDEN; 4693 else 4694 cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_GOLDEN; 4695 4696 if (cm->refresh_alt_ref_frame == 1) 4697 cm->frame_flags = cm->frame_flags | FRAMEFLAGS_ALTREF; 4698 else 4699 cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_ALTREF; 4700 4701 4702 if (cm->refresh_last_frame & cm->refresh_golden_frame) 4703 /* both refreshed */ 4704 cpi->gold_is_last = 1; 4705 else if (cm->refresh_last_frame ^ cm->refresh_golden_frame) 4706 /* 1 refreshed but not the other */ 4707 cpi->gold_is_last = 0; 4708 4709 if (cm->refresh_last_frame & cm->refresh_alt_ref_frame) 4710 /* both refreshed */ 4711 cpi->alt_is_last = 1; 4712 else if (cm->refresh_last_frame ^ cm->refresh_alt_ref_frame) 4713 /* 1 refreshed but not the other */ 4714 cpi->alt_is_last = 0; 4715 4716 if (cm->refresh_alt_ref_frame & cm->refresh_golden_frame) 4717 /* both refreshed */ 4718 cpi->gold_is_alt = 1; 4719 else if (cm->refresh_alt_ref_frame ^ cm->refresh_golden_frame) 4720 /* 1 refreshed but not the other */ 4721 cpi->gold_is_alt = 0; 4722 4723 cpi->ref_frame_flags = VP8_ALTR_FRAME | VP8_GOLD_FRAME | VP8_LAST_FRAME; 4724 4725 if (cpi->gold_is_last) 4726 cpi->ref_frame_flags &= ~VP8_GOLD_FRAME; 4727 4728 if (cpi->alt_is_last) 4729 cpi->ref_frame_flags &= ~VP8_ALTR_FRAME; 4730 4731 if (cpi->gold_is_alt) 4732 cpi->ref_frame_flags &= ~VP8_ALTR_FRAME; 4733 4734 4735 if (!cpi->oxcf.error_resilient_mode) 4736 { 4737 if (cpi->oxcf.play_alternate && cm->refresh_alt_ref_frame && (cm->frame_type != KEY_FRAME)) 4738 /* Update the alternate reference frame stats as appropriate. */ 4739 update_alt_ref_frame_stats(cpi); 4740 else 4741 /* Update the Golden frame stats as appropriate. */ 4742 update_golden_frame_stats(cpi); 4743 } 4744 4745 if (cm->frame_type == KEY_FRAME) 4746 { 4747 /* Tell the caller that the frame was coded as a key frame */ 4748 *frame_flags = cm->frame_flags | FRAMEFLAGS_KEY; 4749 4750 /* As this frame is a key frame the next defaults to an inter frame. */ 4751 cm->frame_type = INTER_FRAME; 4752 4753 cpi->last_frame_percent_intra = 100; 4754 } 4755 else 4756 { 4757 *frame_flags = cm->frame_flags&~FRAMEFLAGS_KEY; 4758 4759 cpi->last_frame_percent_intra = cpi->this_frame_percent_intra; 4760 } 4761 4762 /* Clear the one shot update flags for segmentation map and mode/ref 4763 * loop filter deltas. 4764 */ 4765 cpi->mb.e_mbd.update_mb_segmentation_map = 0; 4766 cpi->mb.e_mbd.update_mb_segmentation_data = 0; 4767 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0; 4768 4769 4770 /* Dont increment frame counters if this was an altref buffer update 4771 * not a real frame 4772 */ 4773 if (cm->show_frame) 4774 { 4775 cm->current_video_frame++; 4776 cpi->frames_since_key++; 4777 cpi->temporal_pattern_counter++; 4778 } 4779 4780 /* reset to normal state now that we are done. */ 4781 4782 4783 4784#if 0 4785 { 4786 char filename[512]; 4787 FILE *recon_file; 4788 sprintf(filename, "enc%04d.yuv", (int) cm->current_video_frame); 4789 recon_file = fopen(filename, "wb"); 4790 fwrite(cm->yv12_fb[cm->lst_fb_idx].buffer_alloc, 4791 cm->yv12_fb[cm->lst_fb_idx].frame_size, 1, recon_file); 4792 fclose(recon_file); 4793 } 4794#endif 4795 4796 /* DEBUG */ 4797 /* vp8_write_yuv_frame("encoder_recon.yuv", cm->frame_to_show); */ 4798 4799 4800} 4801#if !(CONFIG_REALTIME_ONLY) 4802static void Pass2Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned char * dest_end, unsigned int *frame_flags) 4803{ 4804 4805 if (!cpi->common.refresh_alt_ref_frame) 4806 vp8_second_pass(cpi); 4807 4808 encode_frame_to_data_rate(cpi, size, dest, dest_end, frame_flags); 4809 cpi->twopass.bits_left -= 8 * *size; 4810 4811 if (!cpi->common.refresh_alt_ref_frame) 4812 { 4813 double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth 4814 *cpi->oxcf.two_pass_vbrmin_section / 100); 4815 cpi->twopass.bits_left += (int64_t)(two_pass_min_rate / cpi->framerate); 4816 } 4817} 4818#endif 4819 4820/* For ARM NEON, d8-d15 are callee-saved registers, and need to be saved. */ 4821#if HAVE_NEON 4822extern void vp8_push_neon(int64_t *store); 4823extern void vp8_pop_neon(int64_t *store); 4824#endif 4825 4826 4827int vp8_receive_raw_frame(VP8_COMP *cpi, unsigned int frame_flags, YV12_BUFFER_CONFIG *sd, int64_t time_stamp, int64_t end_time) 4828{ 4829#if HAVE_NEON 4830 int64_t store_reg[8]; 4831#if CONFIG_RUNTIME_CPU_DETECT 4832 VP8_COMMON *cm = &cpi->common; 4833#endif 4834#endif 4835 struct vpx_usec_timer timer; 4836 int res = 0; 4837 4838#if HAVE_NEON 4839#if CONFIG_RUNTIME_CPU_DETECT 4840 if (cm->cpu_caps & HAS_NEON) 4841#endif 4842 { 4843 vp8_push_neon(store_reg); 4844 } 4845#endif 4846 4847 vpx_usec_timer_start(&timer); 4848 4849 /* Reinit the lookahead buffer if the frame size changes */ 4850 if (sd->y_width != cpi->oxcf.Width || sd->y_height != cpi->oxcf.Height) 4851 { 4852 assert(cpi->oxcf.lag_in_frames < 2); 4853 dealloc_raw_frame_buffers(cpi); 4854 alloc_raw_frame_buffers(cpi); 4855 } 4856 4857 if(vp8_lookahead_push(cpi->lookahead, sd, time_stamp, end_time, 4858 frame_flags, cpi->active_map_enabled ? cpi->active_map : NULL)) 4859 res = -1; 4860 vpx_usec_timer_mark(&timer); 4861 cpi->time_receive_data += vpx_usec_timer_elapsed(&timer); 4862 4863#if HAVE_NEON 4864#if CONFIG_RUNTIME_CPU_DETECT 4865 if (cm->cpu_caps & HAS_NEON) 4866#endif 4867 { 4868 vp8_pop_neon(store_reg); 4869 } 4870#endif 4871 4872 return res; 4873} 4874 4875 4876static int frame_is_reference(const VP8_COMP *cpi) 4877{ 4878 const VP8_COMMON *cm = &cpi->common; 4879 const MACROBLOCKD *xd = &cpi->mb.e_mbd; 4880 4881 return cm->frame_type == KEY_FRAME || cm->refresh_last_frame 4882 || cm->refresh_golden_frame || cm->refresh_alt_ref_frame 4883 || cm->copy_buffer_to_gf || cm->copy_buffer_to_arf 4884 || cm->refresh_entropy_probs 4885 || xd->mode_ref_lf_delta_update 4886 || xd->update_mb_segmentation_map || xd->update_mb_segmentation_data; 4887} 4888 4889 4890int vp8_get_compressed_data(VP8_COMP *cpi, unsigned int *frame_flags, unsigned long *size, unsigned char *dest, unsigned char *dest_end, int64_t *time_stamp, int64_t *time_end, int flush) 4891{ 4892#if HAVE_NEON 4893 int64_t store_reg[8]; 4894#endif 4895 VP8_COMMON *cm; 4896 struct vpx_usec_timer tsctimer; 4897 struct vpx_usec_timer ticktimer; 4898 struct vpx_usec_timer cmptimer; 4899 YV12_BUFFER_CONFIG *force_src_buffer = NULL; 4900 4901 if (!cpi) 4902 return -1; 4903 4904 cm = &cpi->common; 4905 4906 if (setjmp(cpi->common.error.jmp)) 4907 { 4908 cpi->common.error.setjmp = 0; 4909 return VPX_CODEC_CORRUPT_FRAME; 4910 } 4911 4912 cpi->common.error.setjmp = 1; 4913 4914#if HAVE_NEON 4915#if CONFIG_RUNTIME_CPU_DETECT 4916 if (cm->cpu_caps & HAS_NEON) 4917#endif 4918 { 4919 vp8_push_neon(store_reg); 4920 } 4921#endif 4922 4923 vpx_usec_timer_start(&cmptimer); 4924 4925 cpi->source = NULL; 4926 4927#if !(CONFIG_REALTIME_ONLY) 4928 /* Should we code an alternate reference frame */ 4929 if (cpi->oxcf.error_resilient_mode == 0 && 4930 cpi->oxcf.play_alternate && 4931 cpi->source_alt_ref_pending) 4932 { 4933 if ((cpi->source = vp8_lookahead_peek(cpi->lookahead, 4934 cpi->frames_till_gf_update_due, 4935 PEEK_FORWARD))) 4936 { 4937 cpi->alt_ref_source = cpi->source; 4938 if (cpi->oxcf.arnr_max_frames > 0) 4939 { 4940 vp8_temporal_filter_prepare_c(cpi, 4941 cpi->frames_till_gf_update_due); 4942 force_src_buffer = &cpi->alt_ref_buffer; 4943 } 4944 cpi->frames_till_alt_ref_frame = cpi->frames_till_gf_update_due; 4945 cm->refresh_alt_ref_frame = 1; 4946 cm->refresh_golden_frame = 0; 4947 cm->refresh_last_frame = 0; 4948 cm->show_frame = 0; 4949 /* Clear Pending alt Ref flag. */ 4950 cpi->source_alt_ref_pending = 0; 4951 cpi->is_src_frame_alt_ref = 0; 4952 } 4953 } 4954#endif 4955 4956 if (!cpi->source) 4957 { 4958 /* Read last frame source if we are encoding first pass. */ 4959 if (cpi->pass == 1 && cm->current_video_frame > 0) 4960 { 4961 if((cpi->last_source = vp8_lookahead_peek(cpi->lookahead, 1, 4962 PEEK_BACKWARD)) == NULL) 4963 return -1; 4964 } 4965 4966 4967 if ((cpi->source = vp8_lookahead_pop(cpi->lookahead, flush))) 4968 { 4969 cm->show_frame = 1; 4970 4971 cpi->is_src_frame_alt_ref = cpi->alt_ref_source 4972 && (cpi->source == cpi->alt_ref_source); 4973 4974 if(cpi->is_src_frame_alt_ref) 4975 cpi->alt_ref_source = NULL; 4976 } 4977 } 4978 4979 if (cpi->source) 4980 { 4981 cpi->Source = force_src_buffer ? force_src_buffer : &cpi->source->img; 4982 cpi->un_scaled_source = cpi->Source; 4983 *time_stamp = cpi->source->ts_start; 4984 *time_end = cpi->source->ts_end; 4985 *frame_flags = cpi->source->flags; 4986 4987 if (cpi->pass == 1 && cm->current_video_frame > 0) 4988 { 4989 cpi->last_frame_unscaled_source = &cpi->last_source->img; 4990 } 4991 } 4992 else 4993 { 4994 *size = 0; 4995#if !(CONFIG_REALTIME_ONLY) 4996 4997 if (flush && cpi->pass == 1 && !cpi->twopass.first_pass_done) 4998 { 4999 vp8_end_first_pass(cpi); /* get last stats packet */ 5000 cpi->twopass.first_pass_done = 1; 5001 } 5002 5003#endif 5004 5005#if HAVE_NEON 5006#if CONFIG_RUNTIME_CPU_DETECT 5007 if (cm->cpu_caps & HAS_NEON) 5008#endif 5009 { 5010 vp8_pop_neon(store_reg); 5011 } 5012#endif 5013 return -1; 5014 } 5015 5016 if (cpi->source->ts_start < cpi->first_time_stamp_ever) 5017 { 5018 cpi->first_time_stamp_ever = cpi->source->ts_start; 5019 cpi->last_end_time_stamp_seen = cpi->source->ts_start; 5020 } 5021 5022 /* adjust frame rates based on timestamps given */ 5023 if (cm->show_frame) 5024 { 5025 int64_t this_duration; 5026 int step = 0; 5027 5028 if (cpi->source->ts_start == cpi->first_time_stamp_ever) 5029 { 5030 this_duration = cpi->source->ts_end - cpi->source->ts_start; 5031 step = 1; 5032 } 5033 else 5034 { 5035 int64_t last_duration; 5036 5037 this_duration = cpi->source->ts_end - cpi->last_end_time_stamp_seen; 5038 last_duration = cpi->last_end_time_stamp_seen 5039 - cpi->last_time_stamp_seen; 5040 /* do a step update if the duration changes by 10% */ 5041 if (last_duration) 5042 step = (int)(((this_duration - last_duration) * 5043 10 / last_duration)); 5044 } 5045 5046 if (this_duration) 5047 { 5048 if (step) 5049 cpi->ref_framerate = 10000000.0 / this_duration; 5050 else 5051 { 5052 double avg_duration, interval; 5053 5054 /* Average this frame's rate into the last second's average 5055 * frame rate. If we haven't seen 1 second yet, then average 5056 * over the whole interval seen. 5057 */ 5058 interval = (double)(cpi->source->ts_end - 5059 cpi->first_time_stamp_ever); 5060 if(interval > 10000000.0) 5061 interval = 10000000; 5062 5063 avg_duration = 10000000.0 / cpi->ref_framerate; 5064 avg_duration *= (interval - avg_duration + this_duration); 5065 avg_duration /= interval; 5066 5067 cpi->ref_framerate = 10000000.0 / avg_duration; 5068 } 5069 5070 if (cpi->oxcf.number_of_layers > 1) 5071 { 5072 unsigned int i; 5073 5074 /* Update frame rates for each layer */ 5075 assert(cpi->oxcf.number_of_layers <= VPX_TS_MAX_LAYERS); 5076 for (i=0; i<cpi->oxcf.number_of_layers; i++) 5077 { 5078 LAYER_CONTEXT *lc = &cpi->layer_context[i]; 5079 lc->framerate = cpi->ref_framerate / 5080 cpi->oxcf.rate_decimator[i]; 5081 } 5082 } 5083 else 5084 vp8_new_framerate(cpi, cpi->ref_framerate); 5085 } 5086 5087 cpi->last_time_stamp_seen = cpi->source->ts_start; 5088 cpi->last_end_time_stamp_seen = cpi->source->ts_end; 5089 } 5090 5091 if (cpi->oxcf.number_of_layers > 1) 5092 { 5093 int layer; 5094 5095 update_layer_contexts (cpi); 5096 5097 /* Restore layer specific context & set frame rate */ 5098 layer = cpi->oxcf.layer_id[ 5099 cpi->temporal_pattern_counter % cpi->oxcf.periodicity]; 5100 restore_layer_context (cpi, layer); 5101 vp8_new_framerate(cpi, cpi->layer_context[layer].framerate); 5102 } 5103 5104 if (cpi->compressor_speed == 2) 5105 { 5106 vpx_usec_timer_start(&tsctimer); 5107 vpx_usec_timer_start(&ticktimer); 5108 } 5109 5110 cpi->lf_zeromv_pct = (cpi->zeromv_count * 100)/cm->MBs; 5111 5112#if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING 5113 { 5114 int i; 5115 const int num_part = (1 << cm->multi_token_partition); 5116 /* the available bytes in dest */ 5117 const unsigned long dest_size = dest_end - dest; 5118 const int tok_part_buff_size = (dest_size * 9) / (10 * num_part); 5119 5120 unsigned char *dp = dest; 5121 5122 cpi->partition_d[0] = dp; 5123 dp += dest_size/10; /* reserve 1/10 for control partition */ 5124 cpi->partition_d_end[0] = dp; 5125 5126 for(i = 0; i < num_part; i++) 5127 { 5128 cpi->partition_d[i + 1] = dp; 5129 dp += tok_part_buff_size; 5130 cpi->partition_d_end[i + 1] = dp; 5131 } 5132 } 5133#endif 5134 5135 /* start with a 0 size frame */ 5136 *size = 0; 5137 5138 /* Clear down mmx registers */ 5139 vp8_clear_system_state(); 5140 5141 cm->frame_type = INTER_FRAME; 5142 cm->frame_flags = *frame_flags; 5143 5144#if 0 5145 5146 if (cm->refresh_alt_ref_frame) 5147 { 5148 cm->refresh_golden_frame = 0; 5149 cm->refresh_last_frame = 0; 5150 } 5151 else 5152 { 5153 cm->refresh_golden_frame = 0; 5154 cm->refresh_last_frame = 1; 5155 } 5156 5157#endif 5158 /* find a free buffer for the new frame */ 5159 { 5160 int i = 0; 5161 for(; i < NUM_YV12_BUFFERS; i++) 5162 { 5163 if(!cm->yv12_fb[i].flags) 5164 { 5165 cm->new_fb_idx = i; 5166 break; 5167 } 5168 } 5169 5170 assert(i < NUM_YV12_BUFFERS ); 5171 } 5172#if !(CONFIG_REALTIME_ONLY) 5173 5174 if (cpi->pass == 1) 5175 { 5176 Pass1Encode(cpi, size, dest, frame_flags); 5177 } 5178 else if (cpi->pass == 2) 5179 { 5180 Pass2Encode(cpi, size, dest, dest_end, frame_flags); 5181 } 5182 else 5183#endif 5184 encode_frame_to_data_rate(cpi, size, dest, dest_end, frame_flags); 5185 5186 if (cpi->compressor_speed == 2) 5187 { 5188 unsigned int duration, duration2; 5189 vpx_usec_timer_mark(&tsctimer); 5190 vpx_usec_timer_mark(&ticktimer); 5191 5192 duration = (int)(vpx_usec_timer_elapsed(&ticktimer)); 5193 duration2 = (unsigned int)((double)duration / 2); 5194 5195 if (cm->frame_type != KEY_FRAME) 5196 { 5197 if (cpi->avg_encode_time == 0) 5198 cpi->avg_encode_time = duration; 5199 else 5200 cpi->avg_encode_time = (7 * cpi->avg_encode_time + duration) >> 3; 5201 } 5202 5203 if (duration2) 5204 { 5205 { 5206 5207 if (cpi->avg_pick_mode_time == 0) 5208 cpi->avg_pick_mode_time = duration2; 5209 else 5210 cpi->avg_pick_mode_time = (7 * cpi->avg_pick_mode_time + duration2) >> 3; 5211 } 5212 } 5213 5214 } 5215 5216 if (cm->refresh_entropy_probs == 0) 5217 { 5218 vpx_memcpy(&cm->fc, &cm->lfc, sizeof(cm->fc)); 5219 } 5220 5221 /* Save the contexts separately for alt ref, gold and last. */ 5222 /* (TODO jbb -> Optimize this with pointers to avoid extra copies. ) */ 5223 if(cm->refresh_alt_ref_frame) 5224 vpx_memcpy(&cpi->lfc_a, &cm->fc, sizeof(cm->fc)); 5225 5226 if(cm->refresh_golden_frame) 5227 vpx_memcpy(&cpi->lfc_g, &cm->fc, sizeof(cm->fc)); 5228 5229 if(cm->refresh_last_frame) 5230 vpx_memcpy(&cpi->lfc_n, &cm->fc, sizeof(cm->fc)); 5231 5232 /* if its a dropped frame honor the requests on subsequent frames */ 5233 if (*size > 0) 5234 { 5235 cpi->droppable = !frame_is_reference(cpi); 5236 5237 /* return to normal state */ 5238 cm->refresh_entropy_probs = 1; 5239 cm->refresh_alt_ref_frame = 0; 5240 cm->refresh_golden_frame = 0; 5241 cm->refresh_last_frame = 1; 5242 cm->frame_type = INTER_FRAME; 5243 5244 } 5245 5246 /* Save layer specific state */ 5247 if (cpi->oxcf.number_of_layers > 1) 5248 save_layer_context (cpi); 5249 5250 vpx_usec_timer_mark(&cmptimer); 5251 cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer); 5252 5253 if (cpi->b_calculate_psnr && cpi->pass != 1 && cm->show_frame) 5254 { 5255 generate_psnr_packet(cpi); 5256 } 5257 5258#if CONFIG_INTERNAL_STATS 5259 5260 if (cpi->pass != 1) 5261 { 5262 cpi->bytes += *size; 5263 5264 if (cm->show_frame) 5265 { 5266 cpi->common.show_frame_mi = cpi->common.mi; 5267 cpi->count ++; 5268 5269 if (cpi->b_calculate_psnr) 5270 { 5271 uint64_t ye,ue,ve; 5272 double frame_psnr; 5273 YV12_BUFFER_CONFIG *orig = cpi->Source; 5274 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show; 5275 int y_samples = orig->y_height * orig->y_width ; 5276 int uv_samples = orig->uv_height * orig->uv_width ; 5277 int t_samples = y_samples + 2 * uv_samples; 5278 double sq_error, sq_error2; 5279 5280 ye = calc_plane_error(orig->y_buffer, orig->y_stride, 5281 recon->y_buffer, recon->y_stride, orig->y_width, orig->y_height); 5282 5283 ue = calc_plane_error(orig->u_buffer, orig->uv_stride, 5284 recon->u_buffer, recon->uv_stride, orig->uv_width, orig->uv_height); 5285 5286 ve = calc_plane_error(orig->v_buffer, orig->uv_stride, 5287 recon->v_buffer, recon->uv_stride, orig->uv_width, orig->uv_height); 5288 5289 sq_error = (double)(ye + ue + ve); 5290 5291 frame_psnr = vpx_sse_to_psnr(t_samples, 255.0, sq_error); 5292 5293 cpi->total_y += vpx_sse_to_psnr(y_samples, 255.0, (double)ye); 5294 cpi->total_u += vpx_sse_to_psnr(uv_samples, 255.0, (double)ue); 5295 cpi->total_v += vpx_sse_to_psnr(uv_samples, 255.0, (double)ve); 5296 cpi->total_sq_error += sq_error; 5297 cpi->total += frame_psnr; 5298#if CONFIG_POSTPROC 5299 { 5300 YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer; 5301 double frame_psnr2, frame_ssim2 = 0; 5302 double weight = 0; 5303 5304 vp8_deblock(cm, cm->frame_to_show, &cm->post_proc_buffer, cm->filter_level * 10 / 6, 1, 0); 5305 vp8_clear_system_state(); 5306 5307 ye = calc_plane_error(orig->y_buffer, orig->y_stride, 5308 pp->y_buffer, pp->y_stride, orig->y_width, orig->y_height); 5309 5310 ue = calc_plane_error(orig->u_buffer, orig->uv_stride, 5311 pp->u_buffer, pp->uv_stride, orig->uv_width, orig->uv_height); 5312 5313 ve = calc_plane_error(orig->v_buffer, orig->uv_stride, 5314 pp->v_buffer, pp->uv_stride, orig->uv_width, orig->uv_height); 5315 5316 sq_error2 = (double)(ye + ue + ve); 5317 5318 frame_psnr2 = vpx_sse_to_psnr(t_samples, 255.0, sq_error2); 5319 5320 cpi->totalp_y += vpx_sse_to_psnr(y_samples, 5321 255.0, (double)ye); 5322 cpi->totalp_u += vpx_sse_to_psnr(uv_samples, 5323 255.0, (double)ue); 5324 cpi->totalp_v += vpx_sse_to_psnr(uv_samples, 5325 255.0, (double)ve); 5326 cpi->total_sq_error2 += sq_error2; 5327 cpi->totalp += frame_psnr2; 5328 5329 frame_ssim2 = vp8_calc_ssim(cpi->Source, 5330 &cm->post_proc_buffer, 1, &weight); 5331 5332 cpi->summed_quality += frame_ssim2 * weight; 5333 cpi->summed_weights += weight; 5334 5335 if (cpi->oxcf.number_of_layers > 1) 5336 { 5337 unsigned int i; 5338 5339 for (i=cpi->current_layer; 5340 i<cpi->oxcf.number_of_layers; i++) 5341 { 5342 cpi->frames_in_layer[i]++; 5343 5344 cpi->bytes_in_layer[i] += *size; 5345 cpi->sum_psnr[i] += frame_psnr; 5346 cpi->sum_psnr_p[i] += frame_psnr2; 5347 cpi->total_error2[i] += sq_error; 5348 cpi->total_error2_p[i] += sq_error2; 5349 cpi->sum_ssim[i] += frame_ssim2 * weight; 5350 cpi->sum_weights[i] += weight; 5351 } 5352 } 5353 } 5354#endif 5355 } 5356 5357 if (cpi->b_calculate_ssimg) 5358 { 5359 double y, u, v, frame_all; 5360 frame_all = vp8_calc_ssimg(cpi->Source, cm->frame_to_show, 5361 &y, &u, &v); 5362 5363 if (cpi->oxcf.number_of_layers > 1) 5364 { 5365 unsigned int i; 5366 5367 for (i=cpi->current_layer; 5368 i<cpi->oxcf.number_of_layers; i++) 5369 { 5370 if (!cpi->b_calculate_psnr) 5371 cpi->frames_in_layer[i]++; 5372 5373 cpi->total_ssimg_y_in_layer[i] += y; 5374 cpi->total_ssimg_u_in_layer[i] += u; 5375 cpi->total_ssimg_v_in_layer[i] += v; 5376 cpi->total_ssimg_all_in_layer[i] += frame_all; 5377 } 5378 } 5379 else 5380 { 5381 cpi->total_ssimg_y += y; 5382 cpi->total_ssimg_u += u; 5383 cpi->total_ssimg_v += v; 5384 cpi->total_ssimg_all += frame_all; 5385 } 5386 } 5387 5388 } 5389 } 5390 5391#if 0 5392 5393 if (cpi->common.frame_type != 0 && cpi->common.base_qindex == cpi->oxcf.worst_allowed_q) 5394 { 5395 skiptruecount += cpi->skip_true_count; 5396 skipfalsecount += cpi->skip_false_count; 5397 } 5398 5399#endif 5400#if 0 5401 5402 if (cpi->pass != 1) 5403 { 5404 FILE *f = fopen("skip.stt", "a"); 5405 fprintf(f, "frame:%4d flags:%4x Q:%4d P:%4d Size:%5d\n", cpi->common.current_video_frame, *frame_flags, cpi->common.base_qindex, cpi->prob_skip_false, *size); 5406 5407 if (cpi->is_src_frame_alt_ref == 1) 5408 fprintf(f, "skipcount: %4d framesize: %d\n", cpi->skip_true_count , *size); 5409 5410 fclose(f); 5411 } 5412 5413#endif 5414#endif 5415 5416#if HAVE_NEON 5417#if CONFIG_RUNTIME_CPU_DETECT 5418 if (cm->cpu_caps & HAS_NEON) 5419#endif 5420 { 5421 vp8_pop_neon(store_reg); 5422 } 5423#endif 5424 5425 cpi->common.error.setjmp = 0; 5426 5427 return 0; 5428} 5429 5430int vp8_get_preview_raw_frame(VP8_COMP *cpi, YV12_BUFFER_CONFIG *dest, vp8_ppflags_t *flags) 5431{ 5432 if (cpi->common.refresh_alt_ref_frame) 5433 return -1; 5434 else 5435 { 5436 int ret; 5437 5438#if CONFIG_MULTITHREAD 5439 if(cpi->b_lpf_running) 5440 { 5441 sem_wait(&cpi->h_event_end_lpf); 5442 cpi->b_lpf_running = 0; 5443 } 5444#endif 5445 5446#if CONFIG_POSTPROC 5447 cpi->common.show_frame_mi = cpi->common.mi; 5448 ret = vp8_post_proc_frame(&cpi->common, dest, flags); 5449#else 5450 5451 if (cpi->common.frame_to_show) 5452 { 5453 *dest = *cpi->common.frame_to_show; 5454 dest->y_width = cpi->common.Width; 5455 dest->y_height = cpi->common.Height; 5456 dest->uv_height = cpi->common.Height / 2; 5457 ret = 0; 5458 } 5459 else 5460 { 5461 ret = -1; 5462 } 5463 5464#endif 5465 vp8_clear_system_state(); 5466 return ret; 5467 } 5468} 5469 5470int vp8_set_roimap(VP8_COMP *cpi, unsigned char *map, unsigned int rows, unsigned int cols, int delta_q[4], int delta_lf[4], unsigned int threshold[4]) 5471{ 5472 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS]; 5473 int internal_delta_q[MAX_MB_SEGMENTS]; 5474 const int range = 63; 5475 int i; 5476 5477 // This method is currently incompatible with the cyclic refresh method 5478 if ( cpi->cyclic_refresh_mode_enabled ) 5479 return -1; 5480 5481 // Check number of rows and columns match 5482 if (cpi->common.mb_rows != rows || cpi->common.mb_cols != cols) 5483 return -1; 5484 5485 // Range check the delta Q values and convert the external Q range values 5486 // to internal ones. 5487 if ( (abs(delta_q[0]) > range) || (abs(delta_q[1]) > range) || 5488 (abs(delta_q[2]) > range) || (abs(delta_q[3]) > range) ) 5489 return -1; 5490 5491 // Range check the delta lf values 5492 if ( (abs(delta_lf[0]) > range) || (abs(delta_lf[1]) > range) || 5493 (abs(delta_lf[2]) > range) || (abs(delta_lf[3]) > range) ) 5494 return -1; 5495 5496 if (!map) 5497 { 5498 disable_segmentation(cpi); 5499 return 0; 5500 } 5501 5502 // Translate the external delta q values to internal values. 5503 for ( i = 0; i < MAX_MB_SEGMENTS; i++ ) 5504 internal_delta_q[i] = 5505 ( delta_q[i] >= 0 ) ? q_trans[delta_q[i]] : -q_trans[-delta_q[i]]; 5506 5507 /* Set the segmentation Map */ 5508 set_segmentation_map(cpi, map); 5509 5510 /* Activate segmentation. */ 5511 enable_segmentation(cpi); 5512 5513 /* Set up the quant segment data */ 5514 feature_data[MB_LVL_ALT_Q][0] = internal_delta_q[0]; 5515 feature_data[MB_LVL_ALT_Q][1] = internal_delta_q[1]; 5516 feature_data[MB_LVL_ALT_Q][2] = internal_delta_q[2]; 5517 feature_data[MB_LVL_ALT_Q][3] = internal_delta_q[3]; 5518 5519 /* Set up the loop segment data s */ 5520 feature_data[MB_LVL_ALT_LF][0] = delta_lf[0]; 5521 feature_data[MB_LVL_ALT_LF][1] = delta_lf[1]; 5522 feature_data[MB_LVL_ALT_LF][2] = delta_lf[2]; 5523 feature_data[MB_LVL_ALT_LF][3] = delta_lf[3]; 5524 5525 cpi->segment_encode_breakout[0] = threshold[0]; 5526 cpi->segment_encode_breakout[1] = threshold[1]; 5527 cpi->segment_encode_breakout[2] = threshold[2]; 5528 cpi->segment_encode_breakout[3] = threshold[3]; 5529 5530 /* Initialise the feature data structure */ 5531 set_segment_data(cpi, &feature_data[0][0], SEGMENT_DELTADATA); 5532 5533 return 0; 5534} 5535 5536int vp8_set_active_map(VP8_COMP *cpi, unsigned char *map, unsigned int rows, unsigned int cols) 5537{ 5538 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols) 5539 { 5540 if (map) 5541 { 5542 vpx_memcpy(cpi->active_map, map, rows * cols); 5543 cpi->active_map_enabled = 1; 5544 } 5545 else 5546 cpi->active_map_enabled = 0; 5547 5548 return 0; 5549 } 5550 else 5551 { 5552 return -1 ; 5553 } 5554} 5555 5556int vp8_set_internal_size(VP8_COMP *cpi, VPX_SCALING horiz_mode, VPX_SCALING vert_mode) 5557{ 5558 if (horiz_mode <= ONETWO) 5559 cpi->common.horiz_scale = horiz_mode; 5560 else 5561 return -1; 5562 5563 if (vert_mode <= ONETWO) 5564 cpi->common.vert_scale = vert_mode; 5565 else 5566 return -1; 5567 5568 return 0; 5569} 5570 5571 5572 5573int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest) 5574{ 5575 int i, j; 5576 int Total = 0; 5577 5578 unsigned char *src = source->y_buffer; 5579 unsigned char *dst = dest->y_buffer; 5580 5581 /* Loop through the Y plane raw and reconstruction data summing 5582 * (square differences) 5583 */ 5584 for (i = 0; i < source->y_height; i += 16) 5585 { 5586 for (j = 0; j < source->y_width; j += 16) 5587 { 5588 unsigned int sse; 5589 Total += vp8_mse16x16(src + j, source->y_stride, dst + j, dest->y_stride, &sse); 5590 } 5591 5592 src += 16 * source->y_stride; 5593 dst += 16 * dest->y_stride; 5594 } 5595 5596 return Total; 5597} 5598 5599 5600int vp8_get_quantizer(VP8_COMP *cpi) 5601{ 5602 return cpi->common.base_qindex; 5603} 5604