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