granicus.if.org Git - libvpx/blob - vp8/encoder/onyx_if.c

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