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

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