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