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