vp8/encoder/onyx_if.c

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