granicus.if.org Git - libvpx/blob - vp9/encoder/vp9_encoder.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 <limits.h>
  12 #include <math.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15
  16 #include "./vp9_rtcd.h"
  17 #include "./vpx_config.h"
  18 #include "./vpx_dsp_rtcd.h"
  19 #include "./vpx_scale_rtcd.h"
  20 #include "vpx_dsp/psnr.h"
  21 #include "vpx_dsp/vpx_dsp_common.h"
  22 #include "vpx_dsp/vpx_filter.h"
  23 #if CONFIG_INTERNAL_STATS
  24 #include "vpx_dsp/ssim.h"
  25 #endif
  26 #include "vpx_ports/mem.h"
  27 #include "vpx_ports/system_state.h"
  28 #include "vpx_ports/vpx_timer.h"
  29 #if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
  30 #include "vpx_util/vpx_debug_util.h"
  31 #endif  // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
  32
  33 #include "vp9/common/vp9_alloccommon.h"
  34 #include "vp9/common/vp9_filter.h"
  35 #include "vp9/common/vp9_idct.h"
  36 #if CONFIG_NON_GREEDY_MV
  37 #include "vp9/common/vp9_mvref_common.h"
  38 #endif
  39 #if CONFIG_VP9_POSTPROC
  40 #include "vp9/common/vp9_postproc.h"
  41 #endif
  42 #include "vp9/common/vp9_reconinter.h"
  43 #include "vp9/common/vp9_reconintra.h"
  44 #include "vp9/common/vp9_tile_common.h"
  45 #include "vp9/common/vp9_scan.h"
  46
  47 #if !CONFIG_REALTIME_ONLY
  48 #include "vp9/encoder/vp9_alt_ref_aq.h"
  49 #include "vp9/encoder/vp9_aq_360.h"
  50 #include "vp9/encoder/vp9_aq_complexity.h"
  51 #endif
  52 #include "vp9/encoder/vp9_aq_cyclicrefresh.h"
  53 #if !CONFIG_REALTIME_ONLY
  54 #include "vp9/encoder/vp9_aq_variance.h"
  55 #endif
  56 #include "vp9/encoder/vp9_bitstream.h"
  57 #if CONFIG_INTERNAL_STATS
  58 #include "vp9/encoder/vp9_blockiness.h"
  59 #endif
  60 #include "vp9/encoder/vp9_context_tree.h"
  61 #include "vp9/encoder/vp9_encodeframe.h"
  62 #include "vp9/encoder/vp9_encodemb.h"
  63 #include "vp9/encoder/vp9_encodemv.h"
  64 #include "vp9/encoder/vp9_encoder.h"
  65 #include "vp9/encoder/vp9_ethread.h"
  66 #include "vp9/encoder/vp9_extend.h"
  67 #include "vp9/encoder/vp9_firstpass.h"
  68 #include "vp9/encoder/vp9_mbgraph.h"
  69 #if CONFIG_NON_GREEDY_MV
  70 #include "vp9/encoder/vp9_mcomp.h"
  71 #endif
  72 #include "vp9/encoder/vp9_multi_thread.h"
  73 #include "vp9/encoder/vp9_noise_estimate.h"
  74 #include "vp9/encoder/vp9_picklpf.h"
  75 #include "vp9/encoder/vp9_ratectrl.h"
  76 #include "vp9/encoder/vp9_rd.h"
  77 #include "vp9/encoder/vp9_resize.h"
  78 #include "vp9/encoder/vp9_segmentation.h"
  79 #include "vp9/encoder/vp9_skin_detection.h"
  80 #include "vp9/encoder/vp9_speed_features.h"
  81 #include "vp9/encoder/vp9_svc_layercontext.h"
  82 #include "vp9/encoder/vp9_temporal_filter.h"
  83 #include "vp9/vp9_cx_iface.h"
  84
  85 #define AM_SEGMENT_ID_INACTIVE 7
  86 #define AM_SEGMENT_ID_ACTIVE 0
  87
  88 // Whether to use high precision mv for altref computation.
  89 #define ALTREF_HIGH_PRECISION_MV 1
  90
  91 // Q threshold for high precision mv. Choose a very high value for now so that
  92 // HIGH_PRECISION is always chosen.
  93 #define HIGH_PRECISION_MV_QTHRESH 200
  94
  95 #define FRAME_SIZE_FACTOR 128  // empirical params for context model threshold
  96 #define FRAME_RATE_FACTOR 8
  97
  98 #ifdef OUTPUT_YUV_DENOISED
  99 FILE *yuv_denoised_file = NULL;
 100 #endif
 101 #ifdef OUTPUT_YUV_SKINMAP
 102 static FILE *yuv_skinmap_file = NULL;
 103 #endif
 104 #ifdef OUTPUT_YUV_REC
 105 FILE *yuv_rec_file;
 106 #endif
 107 #ifdef OUTPUT_YUV_SVC_SRC
 108 FILE *yuv_svc_src[3] = { NULL, NULL, NULL };
 109 #endif
 110
 111 #if 0
 112 FILE *framepsnr;
 113 FILE *kf_list;
 114 FILE *keyfile;
 115 #endif
 116
 117 #ifdef ENABLE_KF_DENOISE
 118 // Test condition for spatial denoise of source.
 119 static int is_spatial_denoise_enabled(VP9_COMP *cpi) {
 120   VP9_COMMON *const cm = &cpi->common;
 121   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
 122
 123   return (oxcf->pass != 1) && !is_lossless_requested(&cpi->oxcf) &&
 124          frame_is_intra_only(cm);
 125 }
 126 #endif
 127
 128 #if CONFIG_VP9_HIGHBITDEPTH
 129 void highbd_wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
 130                          TX_SIZE tx_size);
 131 #endif
 132 void wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
 133                   TX_SIZE tx_size);
 134
 135 #if !CONFIG_REALTIME_ONLY
 136 // compute adaptive threshold for skip recoding
 137 static int compute_context_model_thresh(const VP9_COMP *const cpi) {
 138   const VP9_COMMON *const cm = &cpi->common;
 139   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
 140   const int frame_size = (cm->width * cm->height) >> 10;
 141   const int bitrate = (int)(oxcf->target_bandwidth >> 10);
 142   const int qindex_factor = cm->base_qindex + (MAXQ >> 1);
 143
 144   // This equation makes the threshold adaptive to frame size.
 145   // Coding gain obtained by recoding comes from alternate frames of large
 146   // content change. We skip recoding if the difference of previous and current
 147   // frame context probability model is less than a certain threshold.
 148   // The first component is the most critical part to guarantee adaptivity.
 149   // Other parameters are estimated based on normal setting of hd resolution
 150   // parameters. e.g frame_size = 1920x1080, bitrate = 8000, qindex_factor < 50
 151   const int thresh =
 152       ((FRAME_SIZE_FACTOR * frame_size - FRAME_RATE_FACTOR * bitrate) *
 153        qindex_factor) >>
 154       9;
 155
 156   return thresh;
 157 }
 158
 159 // compute the total cost difference between current
 160 // and previous frame context prob model.
 161 static int compute_context_model_diff(const VP9_COMMON *const cm) {
 162   const FRAME_CONTEXT *const pre_fc =
 163       &cm->frame_contexts[cm->frame_context_idx];
 164   const FRAME_CONTEXT *const cur_fc = cm->fc;
 165   const FRAME_COUNTS *counts = &cm->counts;
 166   vpx_prob pre_last_prob, cur_last_prob;
 167   int diff = 0;
 168   int i, j, k, l, m, n;
 169
 170   // y_mode_prob
 171   for (i = 0; i < BLOCK_SIZE_GROUPS; ++i) {
 172     for (j = 0; j < INTRA_MODES - 1; ++j) {
 173       diff += (int)counts->y_mode[i][j] *
 174               (pre_fc->y_mode_prob[i][j] - cur_fc->y_mode_prob[i][j]);
 175     }
 176     pre_last_prob = MAX_PROB - pre_fc->y_mode_prob[i][INTRA_MODES - 2];
 177     cur_last_prob = MAX_PROB - cur_fc->y_mode_prob[i][INTRA_MODES - 2];
 178
 179     diff += (int)counts->y_mode[i][INTRA_MODES - 1] *
 180             (pre_last_prob - cur_last_prob);
 181   }
 182
 183   // uv_mode_prob
 184   for (i = 0; i < INTRA_MODES; ++i) {
 185     for (j = 0; j < INTRA_MODES - 1; ++j) {
 186       diff += (int)counts->uv_mode[i][j] *
 187               (pre_fc->uv_mode_prob[i][j] - cur_fc->uv_mode_prob[i][j]);
 188     }
 189     pre_last_prob = MAX_PROB - pre_fc->uv_mode_prob[i][INTRA_MODES - 2];
 190     cur_last_prob = MAX_PROB - cur_fc->uv_mode_prob[i][INTRA_MODES - 2];
 191
 192     diff += (int)counts->uv_mode[i][INTRA_MODES - 1] *
 193             (pre_last_prob - cur_last_prob);
 194   }
 195
 196   // partition_prob
 197   for (i = 0; i < PARTITION_CONTEXTS; ++i) {
 198     for (j = 0; j < PARTITION_TYPES - 1; ++j) {
 199       diff += (int)counts->partition[i][j] *
 200               (pre_fc->partition_prob[i][j] - cur_fc->partition_prob[i][j]);
 201     }
 202     pre_last_prob = MAX_PROB - pre_fc->partition_prob[i][PARTITION_TYPES - 2];
 203     cur_last_prob = MAX_PROB - cur_fc->partition_prob[i][PARTITION_TYPES - 2];
 204
 205     diff += (int)counts->partition[i][PARTITION_TYPES - 1] *
 206             (pre_last_prob - cur_last_prob);
 207   }
 208
 209   // coef_probs
 210   for (i = 0; i < TX_SIZES; ++i) {
 211     for (j = 0; j < PLANE_TYPES; ++j) {
 212       for (k = 0; k < REF_TYPES; ++k) {
 213         for (l = 0; l < COEF_BANDS; ++l) {
 214           for (m = 0; m < BAND_COEFF_CONTEXTS(l); ++m) {
 215             for (n = 0; n < UNCONSTRAINED_NODES; ++n) {
 216               diff += (int)counts->coef[i][j][k][l][m][n] *
 217                       (pre_fc->coef_probs[i][j][k][l][m][n] -
 218                        cur_fc->coef_probs[i][j][k][l][m][n]);
 219             }
 220
 221             pre_last_prob =
 222                 MAX_PROB -
 223                 pre_fc->coef_probs[i][j][k][l][m][UNCONSTRAINED_NODES - 1];
 224             cur_last_prob =
 225                 MAX_PROB -
 226                 cur_fc->coef_probs[i][j][k][l][m][UNCONSTRAINED_NODES - 1];
 227
 228             diff += (int)counts->coef[i][j][k][l][m][UNCONSTRAINED_NODES] *
 229                     (pre_last_prob - cur_last_prob);
 230           }
 231         }
 232       }
 233     }
 234   }
 235
 236   // switchable_interp_prob
 237   for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i) {
 238     for (j = 0; j < SWITCHABLE_FILTERS - 1; ++j) {
 239       diff += (int)counts->switchable_interp[i][j] *
 240               (pre_fc->switchable_interp_prob[i][j] -
 241                cur_fc->switchable_interp_prob[i][j]);
 242     }
 243     pre_last_prob =
 244         MAX_PROB - pre_fc->switchable_interp_prob[i][SWITCHABLE_FILTERS - 2];
 245     cur_last_prob =
 246         MAX_PROB - cur_fc->switchable_interp_prob[i][SWITCHABLE_FILTERS - 2];
 247
 248     diff += (int)counts->switchable_interp[i][SWITCHABLE_FILTERS - 1] *
 249             (pre_last_prob - cur_last_prob);
 250   }
 251
 252   // inter_mode_probs
 253   for (i = 0; i < INTER_MODE_CONTEXTS; ++i) {
 254     for (j = 0; j < INTER_MODES - 1; ++j) {
 255       diff += (int)counts->inter_mode[i][j] *
 256               (pre_fc->inter_mode_probs[i][j] - cur_fc->inter_mode_probs[i][j]);
 257     }
 258     pre_last_prob = MAX_PROB - pre_fc->inter_mode_probs[i][INTER_MODES - 2];
 259     cur_last_prob = MAX_PROB - cur_fc->inter_mode_probs[i][INTER_MODES - 2];
 260
 261     diff += (int)counts->inter_mode[i][INTER_MODES - 1] *
 262             (pre_last_prob - cur_last_prob);
 263   }
 264
 265   // intra_inter_prob
 266   for (i = 0; i < INTRA_INTER_CONTEXTS; ++i) {
 267     diff += (int)counts->intra_inter[i][0] *
 268             (pre_fc->intra_inter_prob[i] - cur_fc->intra_inter_prob[i]);
 269
 270     pre_last_prob = MAX_PROB - pre_fc->intra_inter_prob[i];
 271     cur_last_prob = MAX_PROB - cur_fc->intra_inter_prob[i];
 272
 273     diff += (int)counts->intra_inter[i][1] * (pre_last_prob - cur_last_prob);
 274   }
 275
 276   // comp_inter_prob
 277   for (i = 0; i < COMP_INTER_CONTEXTS; ++i) {
 278     diff += (int)counts->comp_inter[i][0] *
 279             (pre_fc->comp_inter_prob[i] - cur_fc->comp_inter_prob[i]);
 280
 281     pre_last_prob = MAX_PROB - pre_fc->comp_inter_prob[i];
 282     cur_last_prob = MAX_PROB - cur_fc->comp_inter_prob[i];
 283
 284     diff += (int)counts->comp_inter[i][1] * (pre_last_prob - cur_last_prob);
 285   }
 286
 287   // single_ref_prob
 288   for (i = 0; i < REF_CONTEXTS; ++i) {
 289     for (j = 0; j < 2; ++j) {
 290       diff += (int)counts->single_ref[i][j][0] *
 291               (pre_fc->single_ref_prob[i][j] - cur_fc->single_ref_prob[i][j]);
 292
 293       pre_last_prob = MAX_PROB - pre_fc->single_ref_prob[i][j];
 294       cur_last_prob = MAX_PROB - cur_fc->single_ref_prob[i][j];
 295
 296       diff +=
 297           (int)counts->single_ref[i][j][1] * (pre_last_prob - cur_last_prob);
 298     }
 299   }
 300
 301   // comp_ref_prob
 302   for (i = 0; i < REF_CONTEXTS; ++i) {
 303     diff += (int)counts->comp_ref[i][0] *
 304             (pre_fc->comp_ref_prob[i] - cur_fc->comp_ref_prob[i]);
 305
 306     pre_last_prob = MAX_PROB - pre_fc->comp_ref_prob[i];
 307     cur_last_prob = MAX_PROB - cur_fc->comp_ref_prob[i];
 308
 309     diff += (int)counts->comp_ref[i][1] * (pre_last_prob - cur_last_prob);
 310   }
 311
 312   // tx_probs
 313   for (i = 0; i < TX_SIZE_CONTEXTS; ++i) {
 314     // p32x32
 315     for (j = 0; j < TX_SIZES - 1; ++j) {
 316       diff += (int)counts->tx.p32x32[i][j] *
 317               (pre_fc->tx_probs.p32x32[i][j] - cur_fc->tx_probs.p32x32[i][j]);
 318     }
 319     pre_last_prob = MAX_PROB - pre_fc->tx_probs.p32x32[i][TX_SIZES - 2];
 320     cur_last_prob = MAX_PROB - cur_fc->tx_probs.p32x32[i][TX_SIZES - 2];
 321
 322     diff += (int)counts->tx.p32x32[i][TX_SIZES - 1] *
 323             (pre_last_prob - cur_last_prob);
 324
 325     // p16x16
 326     for (j = 0; j < TX_SIZES - 2; ++j) {
 327       diff += (int)counts->tx.p16x16[i][j] *
 328               (pre_fc->tx_probs.p16x16[i][j] - cur_fc->tx_probs.p16x16[i][j]);
 329     }
 330     pre_last_prob = MAX_PROB - pre_fc->tx_probs.p16x16[i][TX_SIZES - 3];
 331     cur_last_prob = MAX_PROB - cur_fc->tx_probs.p16x16[i][TX_SIZES - 3];
 332
 333     diff += (int)counts->tx.p16x16[i][TX_SIZES - 2] *
 334             (pre_last_prob - cur_last_prob);
 335
 336     // p8x8
 337     for (j = 0; j < TX_SIZES - 3; ++j) {
 338       diff += (int)counts->tx.p8x8[i][j] *
 339               (pre_fc->tx_probs.p8x8[i][j] - cur_fc->tx_probs.p8x8[i][j]);
 340     }
 341     pre_last_prob = MAX_PROB - pre_fc->tx_probs.p8x8[i][TX_SIZES - 4];
 342     cur_last_prob = MAX_PROB - cur_fc->tx_probs.p8x8[i][TX_SIZES - 4];
 343
 344     diff +=
 345         (int)counts->tx.p8x8[i][TX_SIZES - 3] * (pre_last_prob - cur_last_prob);
 346   }
 347
 348   // skip_probs
 349   for (i = 0; i < SKIP_CONTEXTS; ++i) {
 350     diff += (int)counts->skip[i][0] *
 351             (pre_fc->skip_probs[i] - cur_fc->skip_probs[i]);
 352
 353     pre_last_prob = MAX_PROB - pre_fc->skip_probs[i];
 354     cur_last_prob = MAX_PROB - cur_fc->skip_probs[i];
 355
 356     diff += (int)counts->skip[i][1] * (pre_last_prob - cur_last_prob);
 357   }
 358
 359   // mv
 360   for (i = 0; i < MV_JOINTS - 1; ++i) {
 361     diff += (int)counts->mv.joints[i] *
 362             (pre_fc->nmvc.joints[i] - cur_fc->nmvc.joints[i]);
 363   }
 364   pre_last_prob = MAX_PROB - pre_fc->nmvc.joints[MV_JOINTS - 2];
 365   cur_last_prob = MAX_PROB - cur_fc->nmvc.joints[MV_JOINTS - 2];
 366
 367   diff +=
 368       (int)counts->mv.joints[MV_JOINTS - 1] * (pre_last_prob - cur_last_prob);
 369
 370   for (i = 0; i < 2; ++i) {
 371     const nmv_component_counts *nmv_count = &counts->mv.comps[i];
 372     const nmv_component *pre_nmv_prob = &pre_fc->nmvc.comps[i];
 373     const nmv_component *cur_nmv_prob = &cur_fc->nmvc.comps[i];
 374
 375     // sign
 376     diff += (int)nmv_count->sign[0] * (pre_nmv_prob->sign - cur_nmv_prob->sign);
 377
 378     pre_last_prob = MAX_PROB - pre_nmv_prob->sign;
 379     cur_last_prob = MAX_PROB - cur_nmv_prob->sign;
 380
 381     diff += (int)nmv_count->sign[1] * (pre_last_prob - cur_last_prob);
 382
 383     // classes
 384     for (j = 0; j < MV_CLASSES - 1; ++j) {
 385       diff += (int)nmv_count->classes[j] *
 386               (pre_nmv_prob->classes[j] - cur_nmv_prob->classes[j]);
 387     }
 388     pre_last_prob = MAX_PROB - pre_nmv_prob->classes[MV_CLASSES - 2];
 389     cur_last_prob = MAX_PROB - cur_nmv_prob->classes[MV_CLASSES - 2];
 390
 391     diff += (int)nmv_count->classes[MV_CLASSES - 1] *
 392             (pre_last_prob - cur_last_prob);
 393
 394     // class0
 395     for (j = 0; j < CLASS0_SIZE - 1; ++j) {
 396       diff += (int)nmv_count->class0[j] *
 397               (pre_nmv_prob->class0[j] - cur_nmv_prob->class0[j]);
 398     }
 399     pre_last_prob = MAX_PROB - pre_nmv_prob->class0[CLASS0_SIZE - 2];
 400     cur_last_prob = MAX_PROB - cur_nmv_prob->class0[CLASS0_SIZE - 2];
 401
 402     diff += (int)nmv_count->class0[CLASS0_SIZE - 1] *
 403             (pre_last_prob - cur_last_prob);
 404
 405     // bits
 406     for (j = 0; j < MV_OFFSET_BITS; ++j) {
 407       diff += (int)nmv_count->bits[j][0] *
 408               (pre_nmv_prob->bits[j] - cur_nmv_prob->bits[j]);
 409
 410       pre_last_prob = MAX_PROB - pre_nmv_prob->bits[j];
 411       cur_last_prob = MAX_PROB - cur_nmv_prob->bits[j];
 412
 413       diff += (int)nmv_count->bits[j][1] * (pre_last_prob - cur_last_prob);
 414     }
 415
 416     // class0_fp
 417     for (j = 0; j < CLASS0_SIZE; ++j) {
 418       for (k = 0; k < MV_FP_SIZE - 1; ++k) {
 419         diff += (int)nmv_count->class0_fp[j][k] *
 420                 (pre_nmv_prob->class0_fp[j][k] - cur_nmv_prob->class0_fp[j][k]);
 421       }
 422       pre_last_prob = MAX_PROB - pre_nmv_prob->class0_fp[j][MV_FP_SIZE - 2];
 423       cur_last_prob = MAX_PROB - cur_nmv_prob->class0_fp[j][MV_FP_SIZE - 2];
 424
 425       diff += (int)nmv_count->class0_fp[j][MV_FP_SIZE - 1] *
 426               (pre_last_prob - cur_last_prob);
 427     }
 428
 429     // fp
 430     for (j = 0; j < MV_FP_SIZE - 1; ++j) {
 431       diff +=
 432           (int)nmv_count->fp[j] * (pre_nmv_prob->fp[j] - cur_nmv_prob->fp[j]);
 433     }
 434     pre_last_prob = MAX_PROB - pre_nmv_prob->fp[MV_FP_SIZE - 2];
 435     cur_last_prob = MAX_PROB - cur_nmv_prob->fp[MV_FP_SIZE - 2];
 436
 437     diff +=
 438         (int)nmv_count->fp[MV_FP_SIZE - 1] * (pre_last_prob - cur_last_prob);
 439
 440     // class0_hp
 441     diff += (int)nmv_count->class0_hp[0] *
 442             (pre_nmv_prob->class0_hp - cur_nmv_prob->class0_hp);
 443
 444     pre_last_prob = MAX_PROB - pre_nmv_prob->class0_hp;
 445     cur_last_prob = MAX_PROB - cur_nmv_prob->class0_hp;
 446
 447     diff += (int)nmv_count->class0_hp[1] * (pre_last_prob - cur_last_prob);
 448
 449     // hp
 450     diff += (int)nmv_count->hp[0] * (pre_nmv_prob->hp - cur_nmv_prob->hp);
 451
 452     pre_last_prob = MAX_PROB - pre_nmv_prob->hp;
 453     cur_last_prob = MAX_PROB - cur_nmv_prob->hp;
 454
 455     diff += (int)nmv_count->hp[1] * (pre_last_prob - cur_last_prob);
 456   }
 457
 458   return -diff;
 459 }
 460 #endif  // !CONFIG_REALTIME_ONLY
 461
 462 // Test for whether to calculate metrics for the frame.
 463 static int is_psnr_calc_enabled(VP9_COMP *cpi) {
 464   VP9_COMMON *const cm = &cpi->common;
 465   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
 466
 467   return cpi->b_calculate_psnr && (oxcf->pass != 1) && cm->show_frame;
 468 }
 469
 470 /* clang-format off */
 471 const Vp9LevelSpec vp9_level_defs[VP9_LEVELS] = {
 472   //         sample rate    size   breadth  bitrate  cpb
 473   { LEVEL_1,   829440,      36864,    512,   200,    400,    2, 1,  4,  8 },
 474   { LEVEL_1_1, 2764800,     73728,    768,   800,    1000,   2, 1,  4,  8 },
 475   { LEVEL_2,   4608000,     122880,   960,   1800,   1500,   2, 1,  4,  8 },
 476   { LEVEL_2_1, 9216000,     245760,   1344,  3600,   2800,   2, 2,  4,  8 },
 477   { LEVEL_3,   20736000,    552960,   2048,  7200,   6000,   2, 4,  4,  8 },
 478   { LEVEL_3_1, 36864000,    983040,   2752,  12000,  10000,  2, 4,  4,  8 },
 479   { LEVEL_4,   83558400,    2228224,  4160,  18000,  16000,  4, 4,  4,  8 },
 480   { LEVEL_4_1, 160432128,   2228224,  4160,  30000,  18000,  4, 4,  5,  6 },
 481   { LEVEL_5,   311951360,   8912896,  8384,  60000,  36000,  6, 8,  6,  4 },
 482   { LEVEL_5_1, 588251136,   8912896,  8384,  120000, 46000,  8, 8,  10, 4 },
 483   // TODO(huisu): update max_cpb_size for level 5_2 ~ 6_2 when
 484   // they are finalized (currently tentative).
 485   { LEVEL_5_2, 1176502272,  8912896,  8384,  180000, 90000,  8, 8,  10, 4 },
 486   { LEVEL_6,   1176502272,  35651584, 16832, 180000, 90000,  8, 16, 10, 4 },
 487   { LEVEL_6_1, 2353004544u, 35651584, 16832, 240000, 180000, 8, 16, 10, 4 },
 488   { LEVEL_6_2, 4706009088u, 35651584, 16832, 480000, 360000, 8, 16, 10, 4 },
 489 };
 490 /* clang-format on */
 491
 492 static const char *level_fail_messages[TARGET_LEVEL_FAIL_IDS] = {
 493   "The average bit-rate is too high.",
 494   "The picture size is too large.",
 495   "The picture width/height is too large.",
 496   "The luma sample rate is too large.",
 497   "The CPB size is too large.",
 498   "The compression ratio is too small",
 499   "Too many column tiles are used.",
 500   "The alt-ref distance is too small.",
 501   "Too many reference buffers are used."
 502 };
 503
 504 static INLINE void Scale2Ratio(VPX_SCALING mode, int *hr, int *hs) {
 505   switch (mode) {
 506     case NORMAL:
 507       *hr = 1;
 508       *hs = 1;
 509       break;
 510     case FOURFIVE:
 511       *hr = 4;
 512       *hs = 5;
 513       break;
 514     case THREEFIVE:
 515       *hr = 3;
 516       *hs = 5;
 517       break;
 518     default:
 519       assert(mode == ONETWO);
 520       *hr = 1;
 521       *hs = 2;
 522       break;
 523   }
 524 }
 525
 526 // Mark all inactive blocks as active. Other segmentation features may be set
 527 // so memset cannot be used, instead only inactive blocks should be reset.
 528 static void suppress_active_map(VP9_COMP *cpi) {
 529   unsigned char *const seg_map = cpi->segmentation_map;
 530
 531   if (cpi->active_map.enabled || cpi->active_map.update) {
 532     const int rows = cpi->common.mi_rows;
 533     const int cols = cpi->common.mi_cols;
 534     int i;
 535
 536     for (i = 0; i < rows * cols; ++i)
 537       if (seg_map[i] == AM_SEGMENT_ID_INACTIVE)
 538         seg_map[i] = AM_SEGMENT_ID_ACTIVE;
 539   }
 540 }
 541
 542 static void apply_active_map(VP9_COMP *cpi) {
 543   struct segmentation *const seg = &cpi->common.seg;
 544   unsigned char *const seg_map = cpi->segmentation_map;
 545   const unsigned char *const active_map = cpi->active_map.map;
 546   int i;
 547
 548   assert(AM_SEGMENT_ID_ACTIVE == CR_SEGMENT_ID_BASE);
 549
 550   if (frame_is_intra_only(&cpi->common)) {
 551     cpi->active_map.enabled = 0;
 552     cpi->active_map.update = 1;
 553   }
 554
 555   if (cpi->active_map.update) {
 556     if (cpi->active_map.enabled) {
 557       for (i = 0; i < cpi->common.mi_rows * cpi->common.mi_cols; ++i)
 558         if (seg_map[i] == AM_SEGMENT_ID_ACTIVE) seg_map[i] = active_map[i];
 559       vp9_enable_segmentation(seg);
 560       vp9_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP);
 561       vp9_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF);
 562       // Setting the data to -MAX_LOOP_FILTER will result in the computed loop
 563       // filter level being zero regardless of the value of seg->abs_delta.
 564       vp9_set_segdata(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF,
 565                       -MAX_LOOP_FILTER);
 566     } else {
 567       vp9_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP);
 568       vp9_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF);
 569       if (seg->enabled) {
 570         seg->update_data = 1;
 571         seg->update_map = 1;
 572       }
 573     }
 574     cpi->active_map.update = 0;
 575   }
 576 }
 577
 578 static void apply_roi_map(VP9_COMP *cpi) {
 579   VP9_COMMON *cm = &cpi->common;
 580   struct segmentation *const seg = &cm->seg;
 581   vpx_roi_map_t *roi = &cpi->roi;
 582   const int *delta_q = roi->delta_q;
 583   const int *delta_lf = roi->delta_lf;
 584   const int *skip = roi->skip;
 585   int ref_frame[8];
 586   int internal_delta_q[MAX_SEGMENTS];
 587   int i;
 588   static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG,
 589                                     VP9_ALT_FLAG };
 590
 591   // TODO(jianj): Investigate why ROI not working in speed < 5 or in non
 592   // realtime mode.
 593   if (cpi->oxcf.mode != REALTIME || cpi->oxcf.speed < 5) return;
 594   if (!roi->enabled) return;
 595
 596   memcpy(&ref_frame, roi->ref_frame, sizeof(ref_frame));
 597
 598   vp9_enable_segmentation(seg);
 599   vp9_clearall_segfeatures(seg);
 600   // Select delta coding method;
 601   seg->abs_delta = SEGMENT_DELTADATA;
 602
 603   memcpy(cpi->segmentation_map, roi->roi_map, (cm->mi_rows * cm->mi_cols));
 604
 605   for (i = 0; i < MAX_SEGMENTS; ++i) {
 606     // Translate the external delta q values to internal values.
 607     internal_delta_q[i] = vp9_quantizer_to_qindex(abs(delta_q[i]));
 608     if (delta_q[i] < 0) internal_delta_q[i] = -internal_delta_q[i];
 609     vp9_disable_segfeature(seg, i, SEG_LVL_ALT_Q);
 610     vp9_disable_segfeature(seg, i, SEG_LVL_ALT_LF);
 611     if (internal_delta_q[i] != 0) {
 612       vp9_enable_segfeature(seg, i, SEG_LVL_ALT_Q);
 613       vp9_set_segdata(seg, i, SEG_LVL_ALT_Q, internal_delta_q[i]);
 614     }
 615     if (delta_lf[i] != 0) {
 616       vp9_enable_segfeature(seg, i, SEG_LVL_ALT_LF);
 617       vp9_set_segdata(seg, i, SEG_LVL_ALT_LF, delta_lf[i]);
 618     }
 619     if (skip[i] != 0) {
 620       vp9_enable_segfeature(seg, i, SEG_LVL_SKIP);
 621       vp9_set_segdata(seg, i, SEG_LVL_SKIP, skip[i]);
 622     }
 623     if (ref_frame[i] >= 0) {
 624       int valid_ref = 1;
 625       // ALTREF is not used as reference for nonrd_pickmode with 0 lag.
 626       if (ref_frame[i] == ALTREF_FRAME && cpi->sf.use_nonrd_pick_mode)
 627         valid_ref = 0;
 628       // If GOLDEN is selected, make sure it's set as reference.
 629       if (ref_frame[i] == GOLDEN_FRAME &&
 630           !(cpi->ref_frame_flags & flag_list[ref_frame[i]])) {
 631         valid_ref = 0;
 632       }
 633       // GOLDEN was updated in previous encoded frame, so GOLDEN and LAST are
 634       // same reference.
 635       if (ref_frame[i] == GOLDEN_FRAME && cpi->rc.frames_since_golden == 0)
 636         ref_frame[i] = LAST_FRAME;
 637       if (valid_ref) {
 638         vp9_enable_segfeature(seg, i, SEG_LVL_REF_FRAME);
 639         vp9_set_segdata(seg, i, SEG_LVL_REF_FRAME, ref_frame[i]);
 640       }
 641     }
 642   }
 643   roi->enabled = 1;
 644 }
 645
 646 static void init_level_info(Vp9LevelInfo *level_info) {
 647   Vp9LevelStats *const level_stats = &level_info->level_stats;
 648   Vp9LevelSpec *const level_spec = &level_info->level_spec;
 649
 650   memset(level_stats, 0, sizeof(*level_stats));
 651   memset(level_spec, 0, sizeof(*level_spec));
 652   level_spec->level = LEVEL_UNKNOWN;
 653   level_spec->min_altref_distance = INT_MAX;
 654 }
 655
 656 static int check_seg_range(int seg_data[8], int range) {
 657   return !(abs(seg_data[0]) > range || abs(seg_data[1]) > range ||
 658            abs(seg_data[2]) > range || abs(seg_data[3]) > range ||
 659            abs(seg_data[4]) > range || abs(seg_data[5]) > range ||
 660            abs(seg_data[6]) > range || abs(seg_data[7]) > range);
 661 }
 662
 663 VP9_LEVEL vp9_get_level(const Vp9LevelSpec *const level_spec) {
 664   int i;
 665   const Vp9LevelSpec *this_level;
 666
 667   vpx_clear_system_state();
 668
 669   for (i = 0; i < VP9_LEVELS; ++i) {
 670     this_level = &vp9_level_defs[i];
 671     if ((double)level_spec->max_luma_sample_rate >
 672             (double)this_level->max_luma_sample_rate *
 673                 (1 + SAMPLE_RATE_GRACE_P) ||
 674         level_spec->max_luma_picture_size > this_level->max_luma_picture_size ||
 675         level_spec->max_luma_picture_breadth >
 676             this_level->max_luma_picture_breadth ||
 677         level_spec->average_bitrate > this_level->average_bitrate ||
 678         level_spec->max_cpb_size > this_level->max_cpb_size ||
 679         level_spec->compression_ratio < this_level->compression_ratio ||
 680         level_spec->max_col_tiles > this_level->max_col_tiles ||
 681         level_spec->min_altref_distance < this_level->min_altref_distance ||
 682         level_spec->max_ref_frame_buffers > this_level->max_ref_frame_buffers)
 683       continue;
 684     break;
 685   }
 686   return (i == VP9_LEVELS) ? LEVEL_UNKNOWN : vp9_level_defs[i].level;
 687 }
 688
 689 int vp9_set_roi_map(VP9_COMP *cpi, unsigned char *map, unsigned int rows,
 690                     unsigned int cols, int delta_q[8], int delta_lf[8],
 691                     int skip[8], int ref_frame[8]) {
 692   VP9_COMMON *cm = &cpi->common;
 693   vpx_roi_map_t *roi = &cpi->roi;
 694   const int range = 63;
 695   const int ref_frame_range = 3;  // Alt-ref
 696   const int skip_range = 1;
 697   const int frame_rows = cpi->common.mi_rows;
 698   const int frame_cols = cpi->common.mi_cols;
 699
 700   // Check number of rows and columns match
 701   if (frame_rows != (int)rows || frame_cols != (int)cols) {
 702     return -1;
 703   }
 704
 705   if (!check_seg_range(delta_q, range) || !check_seg_range(delta_lf, range) ||
 706       !check_seg_range(ref_frame, ref_frame_range) ||
 707       !check_seg_range(skip, skip_range))
 708     return -1;
 709
 710   // Also disable segmentation if no deltas are specified.
 711   if (!map ||
 712       (!(delta_q[0] | delta_q[1] | delta_q[2] | delta_q[3] | delta_q[4] |
 713          delta_q[5] | delta_q[6] | delta_q[7] | delta_lf[0] | delta_lf[1] |
 714          delta_lf[2] | delta_lf[3] | delta_lf[4] | delta_lf[5] | delta_lf[6] |
 715          delta_lf[7] | skip[0] | skip[1] | skip[2] | skip[3] | skip[4] |
 716          skip[5] | skip[6] | skip[7]) &&
 717        (ref_frame[0] == -1 && ref_frame[1] == -1 && ref_frame[2] == -1 &&
 718         ref_frame[3] == -1 && ref_frame[4] == -1 && ref_frame[5] == -1 &&
 719         ref_frame[6] == -1 && ref_frame[7] == -1))) {
 720     vp9_disable_segmentation(&cm->seg);
 721     cpi->roi.enabled = 0;
 722     return 0;
 723   }
 724
 725   if (roi->roi_map) {
 726     vpx_free(roi->roi_map);
 727     roi->roi_map = NULL;
 728   }
 729   CHECK_MEM_ERROR(cm, roi->roi_map, vpx_malloc(rows * cols));
 730
 731   // Copy to ROI sturcture in the compressor.
 732   memcpy(roi->roi_map, map, rows * cols);
 733   memcpy(&roi->delta_q, delta_q, MAX_SEGMENTS * sizeof(delta_q[0]));
 734   memcpy(&roi->delta_lf, delta_lf, MAX_SEGMENTS * sizeof(delta_lf[0]));
 735   memcpy(&roi->skip, skip, MAX_SEGMENTS * sizeof(skip[0]));
 736   memcpy(&roi->ref_frame, ref_frame, MAX_SEGMENTS * sizeof(ref_frame[0]));
 737   roi->enabled = 1;
 738   roi->rows = rows;
 739   roi->cols = cols;
 740
 741   return 0;
 742 }
 743
 744 int vp9_set_active_map(VP9_COMP *cpi, unsigned char *new_map_16x16, int rows,
 745                        int cols) {
 746   if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols) {
 747     unsigned char *const active_map_8x8 = cpi->active_map.map;
 748     const int mi_rows = cpi->common.mi_rows;
 749     const int mi_cols = cpi->common.mi_cols;
 750     cpi->active_map.update = 1;
 751     if (new_map_16x16) {
 752       int r, c;
 753       for (r = 0; r < mi_rows; ++r) {
 754         for (c = 0; c < mi_cols; ++c) {
 755           active_map_8x8[r * mi_cols + c] =
 756               new_map_16x16[(r >> 1) * cols + (c >> 1)]
 757                   ? AM_SEGMENT_ID_ACTIVE
 758                   : AM_SEGMENT_ID_INACTIVE;
 759         }
 760       }
 761       cpi->active_map.enabled = 1;
 762     } else {
 763       cpi->active_map.enabled = 0;
 764     }
 765     return 0;
 766   } else {
 767     return -1;
 768   }
 769 }
 770
 771 int vp9_get_active_map(VP9_COMP *cpi, unsigned char *new_map_16x16, int rows,
 772                        int cols) {
 773   if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols &&
 774       new_map_16x16) {
 775     unsigned char *const seg_map_8x8 = cpi->segmentation_map;
 776     const int mi_rows = cpi->common.mi_rows;
 777     const int mi_cols = cpi->common.mi_cols;
 778     memset(new_map_16x16, !cpi->active_map.enabled, rows * cols);
 779     if (cpi->active_map.enabled) {
 780       int r, c;
 781       for (r = 0; r < mi_rows; ++r) {
 782         for (c = 0; c < mi_cols; ++c) {
 783           // Cyclic refresh segments are considered active despite not having
 784           // AM_SEGMENT_ID_ACTIVE
 785           new_map_16x16[(r >> 1) * cols + (c >> 1)] |=
 786               seg_map_8x8[r * mi_cols + c] != AM_SEGMENT_ID_INACTIVE;
 787         }
 788       }
 789     }
 790     return 0;
 791   } else {
 792     return -1;
 793   }
 794 }
 795
 796 void vp9_set_high_precision_mv(VP9_COMP *cpi, int allow_high_precision_mv) {
 797   MACROBLOCK *const mb = &cpi->td.mb;
 798   cpi->common.allow_high_precision_mv = allow_high_precision_mv;
 799   if (cpi->common.allow_high_precision_mv) {
 800     mb->mvcost = mb->nmvcost_hp;
 801     mb->mvsadcost = mb->nmvsadcost_hp;
 802   } else {
 803     mb->mvcost = mb->nmvcost;
 804     mb->mvsadcost = mb->nmvsadcost;
 805   }
 806 }
 807
 808 static void setup_frame(VP9_COMP *cpi) {
 809   VP9_COMMON *const cm = &cpi->common;
 810   // Set up entropy context depending on frame type. The decoder mandates
 811   // the use of the default context, index 0, for keyframes and inter
 812   // frames where the error_resilient_mode or intra_only flag is set. For
 813   // other inter-frames the encoder currently uses only two contexts;
 814   // context 1 for ALTREF frames and context 0 for the others.
 815   if (frame_is_intra_only(cm) || cm->error_resilient_mode) {
 816     vp9_setup_past_independence(cm);
 817   } else {
 818     if (!cpi->use_svc) cm->frame_context_idx = cpi->refresh_alt_ref_frame;
 819   }
 820
 821   // TODO(jingning): Overwrite the frame_context_idx index in multi-layer ARF
 822   // case. Need some further investigation on if we could apply this to single
 823   // layer ARF case as well.
 824   if (cpi->multi_layer_arf && !cpi->use_svc) {
 825     GF_GROUP *const gf_group = &cpi->twopass.gf_group;
 826     const int gf_group_index = gf_group->index;
 827     const int boost_frame =
 828         !cpi->rc.is_src_frame_alt_ref &&
 829         (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame);
 830
 831     // frame_context_idx           Frame Type
 832     //        0              Intra only frame, base layer ARF
 833     //        1              ARFs with layer depth = 2,3
 834     //        2              ARFs with layer depth > 3
 835     //        3              Non-boosted frames
 836     if (frame_is_intra_only(cm)) {
 837       cm->frame_context_idx = 0;
 838     } else if (boost_frame) {
 839       if (gf_group->rf_level[gf_group_index] == GF_ARF_STD)
 840         cm->frame_context_idx = 0;
 841       else if (gf_group->layer_depth[gf_group_index] <= 3)
 842         cm->frame_context_idx = 1;
 843       else
 844         cm->frame_context_idx = 2;
 845     } else {
 846       cm->frame_context_idx = 3;
 847     }
 848   }
 849
 850   if (cm->frame_type == KEY_FRAME) {
 851     cpi->refresh_golden_frame = 1;
 852     cpi->refresh_alt_ref_frame = 1;
 853     vp9_zero(cpi->interp_filter_selected);
 854   } else {
 855     *cm->fc = cm->frame_contexts[cm->frame_context_idx];
 856     vp9_zero(cpi->interp_filter_selected[0]);
 857   }
 858 }
 859
 860 static void vp9_enc_setup_mi(VP9_COMMON *cm) {
 861   int i;
 862   cm->mi = cm->mip + cm->mi_stride + 1;
 863   memset(cm->mip, 0, cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mip));
 864   cm->prev_mi = cm->prev_mip + cm->mi_stride + 1;
 865   // Clear top border row
 866   memset(cm->prev_mip, 0, sizeof(*cm->prev_mip) * cm->mi_stride);
 867   // Clear left border column
 868   for (i = 1; i < cm->mi_rows + 1; ++i)
 869     memset(&cm->prev_mip[i * cm->mi_stride], 0, sizeof(*cm->prev_mip));
 870
 871   cm->mi_grid_visible = cm->mi_grid_base + cm->mi_stride + 1;
 872   cm->prev_mi_grid_visible = cm->prev_mi_grid_base + cm->mi_stride + 1;
 873
 874   memset(cm->mi_grid_base, 0,
 875          cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mi_grid_base));
 876 }
 877
 878 static int vp9_enc_alloc_mi(VP9_COMMON *cm, int mi_size) {
 879   cm->mip = vpx_calloc(mi_size, sizeof(*cm->mip));
 880   if (!cm->mip) return 1;
 881   cm->prev_mip = vpx_calloc(mi_size, sizeof(*cm->prev_mip));
 882   if (!cm->prev_mip) return 1;
 883   cm->mi_alloc_size = mi_size;
 884
 885   cm->mi_grid_base = (MODE_INFO **)vpx_calloc(mi_size, sizeof(MODE_INFO *));
 886   if (!cm->mi_grid_base) return 1;
 887   cm->prev_mi_grid_base =
 888       (MODE_INFO **)vpx_calloc(mi_size, sizeof(MODE_INFO *));
 889   if (!cm->prev_mi_grid_base) return 1;
 890
 891   return 0;
 892 }
 893
 894 static void vp9_enc_free_mi(VP9_COMMON *cm) {
 895   vpx_free(cm->mip);
 896   cm->mip = NULL;
 897   vpx_free(cm->prev_mip);
 898   cm->prev_mip = NULL;
 899   vpx_free(cm->mi_grid_base);
 900   cm->mi_grid_base = NULL;
 901   vpx_free(cm->prev_mi_grid_base);
 902   cm->prev_mi_grid_base = NULL;
 903   cm->mi_alloc_size = 0;
 904 }
 905
 906 static void vp9_swap_mi_and_prev_mi(VP9_COMMON *cm) {
 907   // Current mip will be the prev_mip for the next frame.
 908   MODE_INFO **temp_base = cm->prev_mi_grid_base;
 909   MODE_INFO *temp = cm->prev_mip;
 910
 911   // Skip update prev_mi frame in show_existing_frame mode.
 912   if (cm->show_existing_frame) return;
 913
 914   cm->prev_mip = cm->mip;
 915   cm->mip = temp;
 916
 917   // Update the upper left visible macroblock ptrs.
 918   cm->mi = cm->mip + cm->mi_stride + 1;
 919   cm->prev_mi = cm->prev_mip + cm->mi_stride + 1;
 920
 921   cm->prev_mi_grid_base = cm->mi_grid_base;
 922   cm->mi_grid_base = temp_base;
 923   cm->mi_grid_visible = cm->mi_grid_base + cm->mi_stride + 1;
 924   cm->prev_mi_grid_visible = cm->prev_mi_grid_base + cm->mi_stride + 1;
 925 }
 926
 927 void vp9_initialize_enc(void) {
 928   static volatile int init_done = 0;
 929
 930   if (!init_done) {
 931     vp9_rtcd();
 932     vpx_dsp_rtcd();
 933     vpx_scale_rtcd();
 934     vp9_init_intra_predictors();
 935     vp9_init_me_luts();
 936     vp9_rc_init_minq_luts();
 937     vp9_entropy_mv_init();
 938 #if !CONFIG_REALTIME_ONLY
 939     vp9_temporal_filter_init();
 940 #endif
 941     init_done = 1;
 942   }
 943 }
 944
 945 static void dealloc_compressor_data(VP9_COMP *cpi) {
 946   VP9_COMMON *const cm = &cpi->common;
 947   int i;
 948
 949   vpx_free(cpi->mbmi_ext_base);
 950   cpi->mbmi_ext_base = NULL;
 951
 952   vpx_free(cpi->tile_data);
 953   cpi->tile_data = NULL;
 954
 955   vpx_free(cpi->segmentation_map);
 956   cpi->segmentation_map = NULL;
 957   vpx_free(cpi->coding_context.last_frame_seg_map_copy);
 958   cpi->coding_context.last_frame_seg_map_copy = NULL;
 959
 960   vpx_free(cpi->nmvcosts[0]);
 961   vpx_free(cpi->nmvcosts[1]);
 962   cpi->nmvcosts[0] = NULL;
 963   cpi->nmvcosts[1] = NULL;
 964
 965   vpx_free(cpi->nmvcosts_hp[0]);
 966   vpx_free(cpi->nmvcosts_hp[1]);
 967   cpi->nmvcosts_hp[0] = NULL;
 968   cpi->nmvcosts_hp[1] = NULL;
 969
 970   vpx_free(cpi->nmvsadcosts[0]);
 971   vpx_free(cpi->nmvsadcosts[1]);
 972   cpi->nmvsadcosts[0] = NULL;
 973   cpi->nmvsadcosts[1] = NULL;
 974
 975   vpx_free(cpi->nmvsadcosts_hp[0]);
 976   vpx_free(cpi->nmvsadcosts_hp[1]);
 977   cpi->nmvsadcosts_hp[0] = NULL;
 978   cpi->nmvsadcosts_hp[1] = NULL;
 979
 980   vpx_free(cpi->skin_map);
 981   cpi->skin_map = NULL;
 982
 983   vpx_free(cpi->prev_partition);
 984   cpi->prev_partition = NULL;
 985
 986   vpx_free(cpi->svc.prev_partition_svc);
 987   cpi->svc.prev_partition_svc = NULL;
 988
 989   vpx_free(cpi->prev_segment_id);
 990   cpi->prev_segment_id = NULL;
 991
 992   vpx_free(cpi->prev_variance_low);
 993   cpi->prev_variance_low = NULL;
 994
 995   vpx_free(cpi->copied_frame_cnt);
 996   cpi->copied_frame_cnt = NULL;
 997
 998   vpx_free(cpi->content_state_sb_fd);
 999   cpi->content_state_sb_fd = NULL;
1000
1001   vpx_free(cpi->count_arf_frame_usage);
1002   cpi->count_arf_frame_usage = NULL;
1003   vpx_free(cpi->count_lastgolden_frame_usage);
1004   cpi->count_lastgolden_frame_usage = NULL;
1005
1006   vp9_cyclic_refresh_free(cpi->cyclic_refresh);
1007   cpi->cyclic_refresh = NULL;
1008
1009   vpx_free(cpi->active_map.map);
1010   cpi->active_map.map = NULL;
1011
1012   vpx_free(cpi->roi.roi_map);
1013   cpi->roi.roi_map = NULL;
1014
1015   vpx_free(cpi->consec_zero_mv);
1016   cpi->consec_zero_mv = NULL;
1017
1018   vpx_free(cpi->mb_wiener_variance);
1019   cpi->mb_wiener_variance = NULL;
1020
1021   vpx_free(cpi->mi_ssim_rdmult_scaling_factors);
1022   cpi->mi_ssim_rdmult_scaling_factors = NULL;
1023
1024   vp9_free_ref_frame_buffers(cm->buffer_pool);
1025 #if CONFIG_VP9_POSTPROC
1026   vp9_free_postproc_buffers(cm);
1027 #endif
1028   vp9_free_context_buffers(cm);
1029
1030   vpx_free_frame_buffer(&cpi->last_frame_uf);
1031   vpx_free_frame_buffer(&cpi->scaled_source);
1032   vpx_free_frame_buffer(&cpi->scaled_last_source);
1033   vpx_free_frame_buffer(&cpi->alt_ref_buffer);
1034 #ifdef ENABLE_KF_DENOISE
1035   vpx_free_frame_buffer(&cpi->raw_unscaled_source);
1036   vpx_free_frame_buffer(&cpi->raw_scaled_source);
1037 #endif
1038
1039   vp9_lookahead_destroy(cpi->lookahead);
1040
1041   vpx_free(cpi->tile_tok[0][0]);
1042   cpi->tile_tok[0][0] = 0;
1043
1044   vpx_free(cpi->tplist[0][0]);
1045   cpi->tplist[0][0] = NULL;
1046
1047   vp9_free_pc_tree(&cpi->td);
1048
1049   for (i = 0; i < cpi->svc.number_spatial_layers; ++i) {
1050     LAYER_CONTEXT *const lc = &cpi->svc.layer_context[i];
1051     vpx_free(lc->rc_twopass_stats_in.buf);
1052     lc->rc_twopass_stats_in.buf = NULL;
1053     lc->rc_twopass_stats_in.sz = 0;
1054   }
1055
1056   if (cpi->source_diff_var != NULL) {
1057     vpx_free(cpi->source_diff_var);
1058     cpi->source_diff_var = NULL;
1059   }
1060
1061   for (i = 0; i < MAX_LAG_BUFFERS; ++i) {
1062     vpx_free_frame_buffer(&cpi->svc.scaled_frames[i]);
1063   }
1064   memset(&cpi->svc.scaled_frames[0], 0,
1065          MAX_LAG_BUFFERS * sizeof(cpi->svc.scaled_frames[0]));
1066
1067   vpx_free_frame_buffer(&cpi->svc.scaled_temp);
1068   memset(&cpi->svc.scaled_temp, 0, sizeof(cpi->svc.scaled_temp));
1069
1070   vpx_free_frame_buffer(&cpi->svc.empty_frame.img);
1071   memset(&cpi->svc.empty_frame, 0, sizeof(cpi->svc.empty_frame));
1072
1073   vp9_free_svc_cyclic_refresh(cpi);
1074 }
1075
1076 static void save_coding_context(VP9_COMP *cpi) {
1077   CODING_CONTEXT *const cc = &cpi->coding_context;
1078   VP9_COMMON *cm = &cpi->common;
1079
1080   // Stores a snapshot of key state variables which can subsequently be
1081   // restored with a call to vp9_restore_coding_context. These functions are
1082   // intended for use in a re-code loop in vp9_compress_frame where the
1083   // quantizer value is adjusted between loop iterations.
1084   vp9_copy(cc->nmvjointcost, cpi->td.mb.nmvjointcost);
1085
1086   memcpy(cc->nmvcosts[0], cpi->nmvcosts[0],
1087          MV_VALS * sizeof(*cpi->nmvcosts[0]));
1088   memcpy(cc->nmvcosts[1], cpi->nmvcosts[1],
1089          MV_VALS * sizeof(*cpi->nmvcosts[1]));
1090   memcpy(cc->nmvcosts_hp[0], cpi->nmvcosts_hp[0],
1091          MV_VALS * sizeof(*cpi->nmvcosts_hp[0]));
1092   memcpy(cc->nmvcosts_hp[1], cpi->nmvcosts_hp[1],
1093          MV_VALS * sizeof(*cpi->nmvcosts_hp[1]));
1094
1095   vp9_copy(cc->segment_pred_probs, cm->seg.pred_probs);
1096
1097   memcpy(cpi->coding_context.last_frame_seg_map_copy, cm->last_frame_seg_map,
1098          (cm->mi_rows * cm->mi_cols));
1099
1100   vp9_copy(cc->last_ref_lf_deltas, cm->lf.last_ref_deltas);
1101   vp9_copy(cc->last_mode_lf_deltas, cm->lf.last_mode_deltas);
1102
1103   cc->fc = *cm->fc;
1104 }
1105
1106 static void restore_coding_context(VP9_COMP *cpi) {
1107   CODING_CONTEXT *const cc = &cpi->coding_context;
1108   VP9_COMMON *cm = &cpi->common;
1109
1110   // Restore key state variables to the snapshot state stored in the
1111   // previous call to vp9_save_coding_context.
1112   vp9_copy(cpi->td.mb.nmvjointcost, cc->nmvjointcost);
1113
1114   memcpy(cpi->nmvcosts[0], cc->nmvcosts[0], MV_VALS * sizeof(*cc->nmvcosts[0]));
1115   memcpy(cpi->nmvcosts[1], cc->nmvcosts[1], MV_VALS * sizeof(*cc->nmvcosts[1]));
1116   memcpy(cpi->nmvcosts_hp[0], cc->nmvcosts_hp[0],
1117          MV_VALS * sizeof(*cc->nmvcosts_hp[0]));
1118   memcpy(cpi->nmvcosts_hp[1], cc->nmvcosts_hp[1],
1119          MV_VALS * sizeof(*cc->nmvcosts_hp[1]));
1120
1121   vp9_copy(cm->seg.pred_probs, cc->segment_pred_probs);
1122
1123   memcpy(cm->last_frame_seg_map, cpi->coding_context.last_frame_seg_map_copy,
1124          (cm->mi_rows * cm->mi_cols));
1125
1126   vp9_copy(cm->lf.last_ref_deltas, cc->last_ref_lf_deltas);
1127   vp9_copy(cm->lf.last_mode_deltas, cc->last_mode_lf_deltas);
1128
1129   *cm->fc = cc->fc;
1130 }
1131
1132 #if !CONFIG_REALTIME_ONLY
1133 static void configure_static_seg_features(VP9_COMP *cpi) {
1134   VP9_COMMON *const cm = &cpi->common;
1135   const RATE_CONTROL *const rc = &cpi->rc;
1136   struct segmentation *const seg = &cm->seg;
1137
1138   int high_q = (int)(rc->avg_q > 48.0);
1139   int qi_delta;
1140
1141   // Disable and clear down for KF
1142   if (cm->frame_type == KEY_FRAME) {
1143     // Clear down the global segmentation map
1144     memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
1145     seg->update_map = 0;
1146     seg->update_data = 0;
1147     cpi->static_mb_pct = 0;
1148
1149     // Disable segmentation
1150     vp9_disable_segmentation(seg);
1151
1152     // Clear down the segment features.
1153     vp9_clearall_segfeatures(seg);
1154   } else if (cpi->refresh_alt_ref_frame) {
1155     // If this is an alt ref frame
1156     // Clear down the global segmentation map
1157     memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
1158     seg->update_map = 0;
1159     seg->update_data = 0;
1160     cpi->static_mb_pct = 0;
1161
1162     // Disable segmentation and individual segment features by default
1163     vp9_disable_segmentation(seg);
1164     vp9_clearall_segfeatures(seg);
1165
1166     // Scan frames from current to arf frame.
1167     // This function re-enables segmentation if appropriate.
1168     vp9_update_mbgraph_stats(cpi);
1169
1170     // If segmentation was enabled set those features needed for the
1171     // arf itself.
1172     if (seg->enabled) {
1173       seg->update_map = 1;
1174       seg->update_data = 1;
1175
1176       qi_delta =
1177           vp9_compute_qdelta(rc, rc->avg_q, rc->avg_q * 0.875, cm->bit_depth);
1178       vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta - 2);
1179       vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2);
1180
1181       vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
1182       vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF);
1183
1184       // Where relevant assume segment data is delta data
1185       seg->abs_delta = SEGMENT_DELTADATA;
1186     }
1187   } else if (seg->enabled) {
1188     // All other frames if segmentation has been enabled
1189
1190     // First normal frame in a valid gf or alt ref group
1191     if (rc->frames_since_golden == 0) {
1192       // Set up segment features for normal frames in an arf group
1193       if (rc->source_alt_ref_active) {
1194         seg->update_map = 0;
1195         seg->update_data = 1;
1196         seg->abs_delta = SEGMENT_DELTADATA;
1197
1198         qi_delta =
1199             vp9_compute_qdelta(rc, rc->avg_q, rc->avg_q * 1.125, cm->bit_depth);
1200         vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta + 2);
1201         vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
1202
1203         vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2);
1204         vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF);
1205
1206         // Segment coding disabled for compred testing
1207         if (high_q || (cpi->static_mb_pct == 100)) {
1208           vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
1209           vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
1210           vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP);
1211         }
1212       } else {
1213         // Disable segmentation and clear down features if alt ref
1214         // is not active for this group
1215
1216         vp9_disable_segmentation(seg);
1217
1218         memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
1219
1220         seg->update_map = 0;
1221         seg->update_data = 0;
1222
1223         vp9_clearall_segfeatures(seg);
1224       }
1225     } else if (rc->is_src_frame_alt_ref) {
1226       // Special case where we are coding over the top of a previous
1227       // alt ref frame.
1228       // Segment coding disabled for compred testing
1229
1230       // Enable ref frame features for segment 0 as well
1231       vp9_enable_segfeature(seg, 0, SEG_LVL_REF_FRAME);
1232       vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
1233
1234       // All mbs should use ALTREF_FRAME
1235       vp9_clear_segdata(seg, 0, SEG_LVL_REF_FRAME);
1236       vp9_set_segdata(seg, 0, SEG_LVL_REF_FRAME, ALTREF_FRAME);
1237       vp9_clear_segdata(seg, 1, SEG_LVL_REF_FRAME);
1238       vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
1239
1240       // Skip all MBs if high Q (0,0 mv and skip coeffs)
1241       if (high_q) {
1242         vp9_enable_segfeature(seg, 0, SEG_LVL_SKIP);
1243         vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP);
1244       }
1245       // Enable data update
1246       seg->update_data = 1;
1247     } else {
1248       // All other frames.
1249
1250       // No updates.. leave things as they are.
1251       seg->update_map = 0;
1252       seg->update_data = 0;
1253     }
1254   }
1255 }
1256 #endif  // !CONFIG_REALTIME_ONLY
1257
1258 static void update_reference_segmentation_map(VP9_COMP *cpi) {
1259   VP9_COMMON *const cm = &cpi->common;
1260   MODE_INFO **mi_8x8_ptr = cm->mi_grid_visible;
1261   uint8_t *cache_ptr = cm->last_frame_seg_map;
1262   int row, col;
1263
1264   for (row = 0; row < cm->mi_rows; row++) {
1265     MODE_INFO **mi_8x8 = mi_8x8_ptr;
1266     uint8_t *cache = cache_ptr;
1267     for (col = 0; col < cm->mi_cols; col++, mi_8x8++, cache++)
1268       cache[0] = mi_8x8[0]->segment_id;
1269     mi_8x8_ptr += cm->mi_stride;
1270     cache_ptr += cm->mi_cols;
1271   }
1272 }
1273
1274 static void alloc_raw_frame_buffers(VP9_COMP *cpi) {
1275   VP9_COMMON *cm = &cpi->common;
1276   const VP9EncoderConfig *oxcf = &cpi->oxcf;
1277
1278   if (!cpi->lookahead)
1279     cpi->lookahead = vp9_lookahead_init(oxcf->width, oxcf->height,
1280                                         cm->subsampling_x, cm->subsampling_y,
1281 #if CONFIG_VP9_HIGHBITDEPTH
1282                                         cm->use_highbitdepth,
1283 #endif
1284                                         oxcf->lag_in_frames);
1285   if (!cpi->lookahead)
1286     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1287                        "Failed to allocate lag buffers");
1288
1289   // TODO(agrange) Check if ARF is enabled and skip allocation if not.
1290   if (vpx_realloc_frame_buffer(&cpi->alt_ref_buffer, oxcf->width, oxcf->height,
1291                                cm->subsampling_x, cm->subsampling_y,
1292 #if CONFIG_VP9_HIGHBITDEPTH
1293                                cm->use_highbitdepth,
1294 #endif
1295                                VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1296                                NULL, NULL, NULL))
1297     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1298                        "Failed to allocate altref buffer");
1299 }
1300
1301 static void alloc_util_frame_buffers(VP9_COMP *cpi) {
1302   VP9_COMMON *const cm = &cpi->common;
1303   if (vpx_realloc_frame_buffer(&cpi->last_frame_uf, cm->width, cm->height,
1304                                cm->subsampling_x, cm->subsampling_y,
1305 #if CONFIG_VP9_HIGHBITDEPTH
1306                                cm->use_highbitdepth,
1307 #endif
1308                                VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1309                                NULL, NULL, NULL))
1310     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1311                        "Failed to allocate last frame buffer");
1312
1313   if (vpx_realloc_frame_buffer(&cpi->scaled_source, cm->width, cm->height,
1314                                cm->subsampling_x, cm->subsampling_y,
1315 #if CONFIG_VP9_HIGHBITDEPTH
1316                                cm->use_highbitdepth,
1317 #endif
1318                                VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1319                                NULL, NULL, NULL))
1320     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1321                        "Failed to allocate scaled source buffer");
1322
1323   // For 1 pass cbr: allocate scaled_frame that may be used as an intermediate
1324   // buffer for a 2 stage down-sampling: two stages of 1:2 down-sampling for a
1325   // target of 1/4x1/4. number_spatial_layers must be greater than 2.
1326   if (is_one_pass_cbr_svc(cpi) && !cpi->svc.scaled_temp_is_alloc &&
1327       cpi->svc.number_spatial_layers > 2) {
1328     cpi->svc.scaled_temp_is_alloc = 1;
1329     if (vpx_realloc_frame_buffer(
1330             &cpi->svc.scaled_temp, cm->width >> 1, cm->height >> 1,
1331             cm->subsampling_x, cm->subsampling_y,
1332 #if CONFIG_VP9_HIGHBITDEPTH
1333             cm->use_highbitdepth,
1334 #endif
1335             VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment, NULL, NULL, NULL))
1336       vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1337                          "Failed to allocate scaled_frame for svc ");
1338   }
1339
1340   if (vpx_realloc_frame_buffer(&cpi->scaled_last_source, cm->width, cm->height,
1341                                cm->subsampling_x, cm->subsampling_y,
1342 #if CONFIG_VP9_HIGHBITDEPTH
1343                                cm->use_highbitdepth,
1344 #endif
1345                                VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1346                                NULL, NULL, NULL))
1347     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1348                        "Failed to allocate scaled last source buffer");
1349 #ifdef ENABLE_KF_DENOISE
1350   if (vpx_realloc_frame_buffer(&cpi->raw_unscaled_source, cm->width, cm->height,
1351                                cm->subsampling_x, cm->subsampling_y,
1352 #if CONFIG_VP9_HIGHBITDEPTH
1353                                cm->use_highbitdepth,
1354 #endif
1355                                VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1356                                NULL, NULL, NULL))
1357     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1358                        "Failed to allocate unscaled raw source frame buffer");
1359
1360   if (vpx_realloc_frame_buffer(&cpi->raw_scaled_source, cm->width, cm->height,
1361                                cm->subsampling_x, cm->subsampling_y,
1362 #if CONFIG_VP9_HIGHBITDEPTH
1363                                cm->use_highbitdepth,
1364 #endif
1365                                VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1366                                NULL, NULL, NULL))
1367     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1368                        "Failed to allocate scaled raw source frame buffer");
1369 #endif
1370 }
1371
1372 static int alloc_context_buffers_ext(VP9_COMP *cpi) {
1373   VP9_COMMON *cm = &cpi->common;
1374   int mi_size = cm->mi_cols * cm->mi_rows;
1375
1376   cpi->mbmi_ext_base = vpx_calloc(mi_size, sizeof(*cpi->mbmi_ext_base));
1377   if (!cpi->mbmi_ext_base) return 1;
1378
1379   return 0;
1380 }
1381
1382 static void alloc_compressor_data(VP9_COMP *cpi) {
1383   VP9_COMMON *cm = &cpi->common;
1384   int sb_rows;
1385
1386   vp9_alloc_context_buffers(cm, cm->width, cm->height);
1387
1388   alloc_context_buffers_ext(cpi);
1389
1390   vpx_free(cpi->tile_tok[0][0]);
1391
1392   {
1393     unsigned int tokens = get_token_alloc(cm->mb_rows, cm->mb_cols);
1394     CHECK_MEM_ERROR(cm, cpi->tile_tok[0][0],
1395                     vpx_calloc(tokens, sizeof(*cpi->tile_tok[0][0])));
1396   }
1397
1398   sb_rows = mi_cols_aligned_to_sb(cm->mi_rows) >> MI_BLOCK_SIZE_LOG2;
1399   vpx_free(cpi->tplist[0][0]);
1400   CHECK_MEM_ERROR(
1401       cm, cpi->tplist[0][0],
1402       vpx_calloc(sb_rows * 4 * (1 << 6), sizeof(*cpi->tplist[0][0])));
1403
1404   vp9_setup_pc_tree(&cpi->common, &cpi->td);
1405 }
1406
1407 void vp9_new_framerate(VP9_COMP *cpi, double framerate) {
1408   cpi->framerate = framerate < 0.1 ? 30 : framerate;
1409   vp9_rc_update_framerate(cpi);
1410 }
1411
1412 static void set_tile_limits(VP9_COMP *cpi) {
1413   VP9_COMMON *const cm = &cpi->common;
1414
1415   int min_log2_tile_cols, max_log2_tile_cols;
1416   vp9_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
1417
1418   cm->log2_tile_cols =
1419       clamp(cpi->oxcf.tile_columns, min_log2_tile_cols, max_log2_tile_cols);
1420   cm->log2_tile_rows = cpi->oxcf.tile_rows;
1421
1422   if (cpi->oxcf.target_level == LEVEL_AUTO) {
1423     const int level_tile_cols =
1424         log_tile_cols_from_picsize_level(cpi->common.width, cpi->common.height);
1425     if (cm->log2_tile_cols > level_tile_cols) {
1426       cm->log2_tile_cols = VPXMAX(level_tile_cols, min_log2_tile_cols);
1427     }
1428   }
1429 }
1430
1431 static void update_frame_size(VP9_COMP *cpi) {
1432   VP9_COMMON *const cm = &cpi->common;
1433   MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
1434
1435   vp9_set_mb_mi(cm, cm->width, cm->height);
1436   vp9_init_context_buffers(cm);
1437   vp9_init_macroblockd(cm, xd, NULL);
1438   cpi->td.mb.mbmi_ext_base = cpi->mbmi_ext_base;
1439   memset(cpi->mbmi_ext_base, 0,
1440          cm->mi_rows * cm->mi_cols * sizeof(*cpi->mbmi_ext_base));
1441
1442   set_tile_limits(cpi);
1443 }
1444
1445 static void init_buffer_indices(VP9_COMP *cpi) {
1446   int ref_frame;
1447
1448   for (ref_frame = 0; ref_frame < REF_FRAMES; ++ref_frame)
1449     cpi->ref_fb_idx[ref_frame] = ref_frame;
1450
1451   cpi->lst_fb_idx = cpi->ref_fb_idx[LAST_FRAME - 1];
1452   cpi->gld_fb_idx = cpi->ref_fb_idx[GOLDEN_FRAME - 1];
1453   cpi->alt_fb_idx = cpi->ref_fb_idx[ALTREF_FRAME - 1];
1454 }
1455
1456 static void init_level_constraint(LevelConstraint *lc) {
1457   lc->level_index = -1;
1458   lc->max_cpb_size = INT_MAX;
1459   lc->max_frame_size = INT_MAX;
1460   lc->fail_flag = 0;
1461 }
1462
1463 static void set_level_constraint(LevelConstraint *ls, int8_t level_index) {
1464   vpx_clear_system_state();
1465   ls->level_index = level_index;
1466   if (level_index >= 0) {
1467     ls->max_cpb_size = vp9_level_defs[level_index].max_cpb_size * (double)1000;
1468   }
1469 }
1470
1471 static void init_config(struct VP9_COMP *cpi, VP9EncoderConfig *oxcf) {
1472   VP9_COMMON *const cm = &cpi->common;
1473
1474   cpi->oxcf = *oxcf;
1475   cpi->framerate = oxcf->init_framerate;
1476   cm->profile = oxcf->profile;
1477   cm->bit_depth = oxcf->bit_depth;
1478 #if CONFIG_VP9_HIGHBITDEPTH
1479   cm->use_highbitdepth = oxcf->use_highbitdepth;
1480 #endif
1481   cm->color_space = oxcf->color_space;
1482   cm->color_range = oxcf->color_range;
1483
1484   cpi->target_level = oxcf->target_level;
1485   cpi->keep_level_stats = oxcf->target_level != LEVEL_MAX;
1486   set_level_constraint(&cpi->level_constraint,
1487                        get_level_index(cpi->target_level));
1488
1489   cm->width = oxcf->width;
1490   cm->height = oxcf->height;
1491   alloc_compressor_data(cpi);
1492
1493   cpi->svc.temporal_layering_mode = oxcf->temporal_layering_mode;
1494
1495   // Single thread case: use counts in common.
1496   cpi->td.counts = &cm->counts;
1497
1498   // Spatial scalability.
1499   cpi->svc.number_spatial_layers = oxcf->ss_number_layers;
1500   // Temporal scalability.
1501   cpi->svc.number_temporal_layers = oxcf->ts_number_layers;
1502
1503   if ((cpi->svc.number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) ||
1504       ((cpi->svc.number_temporal_layers > 1 ||
1505         cpi->svc.number_spatial_layers > 1) &&
1506        cpi->oxcf.pass != 1)) {
1507     vp9_init_layer_context(cpi);
1508   }
1509
1510   // change includes all joint functionality
1511   vp9_change_config(cpi, oxcf);
1512
1513   cpi->static_mb_pct = 0;
1514   cpi->ref_frame_flags = 0;
1515
1516   init_buffer_indices(cpi);
1517
1518   vp9_noise_estimate_init(&cpi->noise_estimate, cm->width, cm->height);
1519 }
1520
1521 static void set_rc_buffer_sizes(RATE_CONTROL *rc,
1522                                 const VP9EncoderConfig *oxcf) {
1523   const int64_t bandwidth = oxcf->target_bandwidth;
1524   const int64_t starting = oxcf->starting_buffer_level_ms;
1525   const int64_t optimal = oxcf->optimal_buffer_level_ms;
1526   const int64_t maximum = oxcf->maximum_buffer_size_ms;
1527
1528   rc->starting_buffer_level = starting * bandwidth / 1000;
1529   rc->optimal_buffer_level =
1530       (optimal == 0) ? bandwidth / 8 : optimal * bandwidth / 1000;
1531   rc->maximum_buffer_size =
1532       (maximum == 0) ? bandwidth / 8 : maximum * bandwidth / 1000;
1533 }
1534
1535 #if CONFIG_VP9_HIGHBITDEPTH
1536 // TODO(angiebird): make sdx8f available for highbitdepth if needed
1537 #define HIGHBD_BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF) \
1538   cpi->fn_ptr[BT].sdf = SDF;                             \
1539   cpi->fn_ptr[BT].sdaf = SDAF;                           \
1540   cpi->fn_ptr[BT].vf = VF;                               \
1541   cpi->fn_ptr[BT].svf = SVF;                             \
1542   cpi->fn_ptr[BT].svaf = SVAF;                           \
1543   cpi->fn_ptr[BT].sdx4df = SDX4DF;                       \
1544   cpi->fn_ptr[BT].sdx8f = NULL;
1545
1546 #define MAKE_BFP_SAD_WRAPPER(fnname)                                           \
1547   static unsigned int fnname##_bits8(const uint8_t *src_ptr,                   \
1548                                      int source_stride,                        \
1549                                      const uint8_t *ref_ptr, int ref_stride) { \
1550     return fnname(src_ptr, source_stride, ref_ptr, ref_stride);                \
1551   }                                                                            \
1552   static unsigned int fnname##_bits10(                                         \
1553       const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr,       \
1554       int ref_stride) {                                                        \
1555     return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 2;           \
1556   }                                                                            \
1557   static unsigned int fnname##_bits12(                                         \
1558       const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr,       \
1559       int ref_stride) {                                                        \
1560     return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 4;           \
1561   }
1562
1563 #define MAKE_BFP_SADAVG_WRAPPER(fnname)                                        \
1564   static unsigned int fnname##_bits8(                                          \
1565       const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr,       \
1566       int ref_stride, const uint8_t *second_pred) {                            \
1567     return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred);   \
1568   }                                                                            \
1569   static unsigned int fnname##_bits10(                                         \
1570       const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr,       \
1571       int ref_stride, const uint8_t *second_pred) {                            \
1572     return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred) >> \
1573            2;                                                                  \
1574   }                                                                            \
1575   static unsigned int fnname##_bits12(                                         \
1576       const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr,       \
1577       int ref_stride, const uint8_t *second_pred) {                            \
1578     return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred) >> \
1579            4;                                                                  \
1580   }
1581
1582 #define MAKE_BFP_SAD4D_WRAPPER(fnname)                                        \
1583   static void fnname##_bits8(const uint8_t *src_ptr, int source_stride,       \
1584                              const uint8_t *const ref_ptr[], int ref_stride,  \
1585                              unsigned int *sad_array) {                       \
1586     fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array);           \
1587   }                                                                           \
1588   static void fnname##_bits10(const uint8_t *src_ptr, int source_stride,      \
1589                               const uint8_t *const ref_ptr[], int ref_stride, \
1590                               unsigned int *sad_array) {                      \
1591     int i;                                                                    \
1592     fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array);           \
1593     for (i = 0; i < 4; i++) sad_array[i] >>= 2;                               \
1594   }                                                                           \
1595   static void fnname##_bits12(const uint8_t *src_ptr, int source_stride,      \
1596                               const uint8_t *const ref_ptr[], int ref_stride, \
1597                               unsigned int *sad_array) {                      \
1598     int i;                                                                    \
1599     fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array);           \
1600     for (i = 0; i < 4; i++) sad_array[i] >>= 4;                               \
1601   }
1602
1603 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad32x16)
1604 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad32x16_avg)
1605 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad32x16x4d)
1606 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad16x32)
1607 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad16x32_avg)
1608 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad16x32x4d)
1609 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad64x32)
1610 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad64x32_avg)
1611 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad64x32x4d)
1612 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad32x64)
1613 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad32x64_avg)
1614 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad32x64x4d)
1615 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad32x32)
1616 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad32x32_avg)
1617 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad32x32x4d)
1618 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad64x64)
1619 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad64x64_avg)
1620 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad64x64x4d)
1621 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad16x16)
1622 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad16x16_avg)
1623 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad16x16x4d)
1624 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad16x8)
1625 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad16x8_avg)
1626 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad16x8x4d)
1627 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad8x16)
1628 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad8x16_avg)
1629 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad8x16x4d)
1630 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad8x8)
1631 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad8x8_avg)
1632 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad8x8x4d)
1633 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad8x4)
1634 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad8x4_avg)
1635 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad8x4x4d)
1636 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad4x8)
1637 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad4x8_avg)
1638 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad4x8x4d)
1639 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad4x4)
1640 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad4x4_avg)
1641 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad4x4x4d)
1642
1643 static void highbd_set_var_fns(VP9_COMP *const cpi) {
1644   VP9_COMMON *const cm = &cpi->common;
1645   if (cm->use_highbitdepth) {
1646     switch (cm->bit_depth) {
1647       case VPX_BITS_8:
1648         HIGHBD_BFP(BLOCK_32X16, vpx_highbd_sad32x16_bits8,
1649                    vpx_highbd_sad32x16_avg_bits8, vpx_highbd_8_variance32x16,
1650                    vpx_highbd_8_sub_pixel_variance32x16,
1651                    vpx_highbd_8_sub_pixel_avg_variance32x16,
1652                    vpx_highbd_sad32x16x4d_bits8)
1653
1654         HIGHBD_BFP(BLOCK_16X32, vpx_highbd_sad16x32_bits8,
1655                    vpx_highbd_sad16x32_avg_bits8, vpx_highbd_8_variance16x32,
1656                    vpx_highbd_8_sub_pixel_variance16x32,
1657                    vpx_highbd_8_sub_pixel_avg_variance16x32,
1658                    vpx_highbd_sad16x32x4d_bits8)
1659
1660         HIGHBD_BFP(BLOCK_64X32, vpx_highbd_sad64x32_bits8,
1661                    vpx_highbd_sad64x32_avg_bits8, vpx_highbd_8_variance64x32,
1662                    vpx_highbd_8_sub_pixel_variance64x32,
1663                    vpx_highbd_8_sub_pixel_avg_variance64x32,
1664                    vpx_highbd_sad64x32x4d_bits8)
1665
1666         HIGHBD_BFP(BLOCK_32X64, vpx_highbd_sad32x64_bits8,
1667                    vpx_highbd_sad32x64_avg_bits8, vpx_highbd_8_variance32x64,
1668                    vpx_highbd_8_sub_pixel_variance32x64,
1669                    vpx_highbd_8_sub_pixel_avg_variance32x64,
1670                    vpx_highbd_sad32x64x4d_bits8)
1671
1672         HIGHBD_BFP(BLOCK_32X32, vpx_highbd_sad32x32_bits8,
1673                    vpx_highbd_sad32x32_avg_bits8, vpx_highbd_8_variance32x32,
1674                    vpx_highbd_8_sub_pixel_variance32x32,
1675                    vpx_highbd_8_sub_pixel_avg_variance32x32,
1676                    vpx_highbd_sad32x32x4d_bits8)
1677
1678         HIGHBD_BFP(BLOCK_64X64, vpx_highbd_sad64x64_bits8,
1679                    vpx_highbd_sad64x64_avg_bits8, vpx_highbd_8_variance64x64,
1680                    vpx_highbd_8_sub_pixel_variance64x64,
1681                    vpx_highbd_8_sub_pixel_avg_variance64x64,
1682                    vpx_highbd_sad64x64x4d_bits8)
1683
1684         HIGHBD_BFP(BLOCK_16X16, vpx_highbd_sad16x16_bits8,
1685                    vpx_highbd_sad16x16_avg_bits8, vpx_highbd_8_variance16x16,
1686                    vpx_highbd_8_sub_pixel_variance16x16,
1687                    vpx_highbd_8_sub_pixel_avg_variance16x16,
1688                    vpx_highbd_sad16x16x4d_bits8)
1689
1690         HIGHBD_BFP(BLOCK_16X8, vpx_highbd_sad16x8_bits8,
1691                    vpx_highbd_sad16x8_avg_bits8, vpx_highbd_8_variance16x8,
1692                    vpx_highbd_8_sub_pixel_variance16x8,
1693                    vpx_highbd_8_sub_pixel_avg_variance16x8,
1694                    vpx_highbd_sad16x8x4d_bits8)
1695
1696         HIGHBD_BFP(BLOCK_8X16, vpx_highbd_sad8x16_bits8,
1697                    vpx_highbd_sad8x16_avg_bits8, vpx_highbd_8_variance8x16,
1698                    vpx_highbd_8_sub_pixel_variance8x16,
1699                    vpx_highbd_8_sub_pixel_avg_variance8x16,
1700                    vpx_highbd_sad8x16x4d_bits8)
1701
1702         HIGHBD_BFP(
1703             BLOCK_8X8, vpx_highbd_sad8x8_bits8, vpx_highbd_sad8x8_avg_bits8,
1704             vpx_highbd_8_variance8x8, vpx_highbd_8_sub_pixel_variance8x8,
1705             vpx_highbd_8_sub_pixel_avg_variance8x8, vpx_highbd_sad8x8x4d_bits8)
1706
1707         HIGHBD_BFP(
1708             BLOCK_8X4, vpx_highbd_sad8x4_bits8, vpx_highbd_sad8x4_avg_bits8,
1709             vpx_highbd_8_variance8x4, vpx_highbd_8_sub_pixel_variance8x4,
1710             vpx_highbd_8_sub_pixel_avg_variance8x4, vpx_highbd_sad8x4x4d_bits8)
1711
1712         HIGHBD_BFP(
1713             BLOCK_4X8, vpx_highbd_sad4x8_bits8, vpx_highbd_sad4x8_avg_bits8,
1714             vpx_highbd_8_variance4x8, vpx_highbd_8_sub_pixel_variance4x8,
1715             vpx_highbd_8_sub_pixel_avg_variance4x8, vpx_highbd_sad4x8x4d_bits8)
1716
1717         HIGHBD_BFP(
1718             BLOCK_4X4, vpx_highbd_sad4x4_bits8, vpx_highbd_sad4x4_avg_bits8,
1719             vpx_highbd_8_variance4x4, vpx_highbd_8_sub_pixel_variance4x4,
1720             vpx_highbd_8_sub_pixel_avg_variance4x4, vpx_highbd_sad4x4x4d_bits8)
1721         break;
1722
1723       case VPX_BITS_10:
1724         HIGHBD_BFP(BLOCK_32X16, vpx_highbd_sad32x16_bits10,
1725                    vpx_highbd_sad32x16_avg_bits10, vpx_highbd_10_variance32x16,
1726                    vpx_highbd_10_sub_pixel_variance32x16,
1727                    vpx_highbd_10_sub_pixel_avg_variance32x16,
1728                    vpx_highbd_sad32x16x4d_bits10)
1729
1730         HIGHBD_BFP(BLOCK_16X32, vpx_highbd_sad16x32_bits10,
1731                    vpx_highbd_sad16x32_avg_bits10, vpx_highbd_10_variance16x32,
1732                    vpx_highbd_10_sub_pixel_variance16x32,
1733                    vpx_highbd_10_sub_pixel_avg_variance16x32,
1734                    vpx_highbd_sad16x32x4d_bits10)
1735
1736         HIGHBD_BFP(BLOCK_64X32, vpx_highbd_sad64x32_bits10,
1737                    vpx_highbd_sad64x32_avg_bits10, vpx_highbd_10_variance64x32,
1738                    vpx_highbd_10_sub_pixel_variance64x32,
1739                    vpx_highbd_10_sub_pixel_avg_variance64x32,
1740                    vpx_highbd_sad64x32x4d_bits10)
1741
1742         HIGHBD_BFP(BLOCK_32X64, vpx_highbd_sad32x64_bits10,
1743                    vpx_highbd_sad32x64_avg_bits10, vpx_highbd_10_variance32x64,
1744                    vpx_highbd_10_sub_pixel_variance32x64,
1745                    vpx_highbd_10_sub_pixel_avg_variance32x64,
1746                    vpx_highbd_sad32x64x4d_bits10)
1747
1748         HIGHBD_BFP(BLOCK_32X32, vpx_highbd_sad32x32_bits10,
1749                    vpx_highbd_sad32x32_avg_bits10, vpx_highbd_10_variance32x32,
1750                    vpx_highbd_10_sub_pixel_variance32x32,
1751                    vpx_highbd_10_sub_pixel_avg_variance32x32,
1752                    vpx_highbd_sad32x32x4d_bits10)
1753
1754         HIGHBD_BFP(BLOCK_64X64, vpx_highbd_sad64x64_bits10,
1755                    vpx_highbd_sad64x64_avg_bits10, vpx_highbd_10_variance64x64,
1756                    vpx_highbd_10_sub_pixel_variance64x64,
1757                    vpx_highbd_10_sub_pixel_avg_variance64x64,
1758                    vpx_highbd_sad64x64x4d_bits10)
1759
1760         HIGHBD_BFP(BLOCK_16X16, vpx_highbd_sad16x16_bits10,
1761                    vpx_highbd_sad16x16_avg_bits10, vpx_highbd_10_variance16x16,
1762                    vpx_highbd_10_sub_pixel_variance16x16,
1763                    vpx_highbd_10_sub_pixel_avg_variance16x16,
1764                    vpx_highbd_sad16x16x4d_bits10)
1765
1766         HIGHBD_BFP(BLOCK_16X8, vpx_highbd_sad16x8_bits10,
1767                    vpx_highbd_sad16x8_avg_bits10, vpx_highbd_10_variance16x8,
1768                    vpx_highbd_10_sub_pixel_variance16x8,
1769                    vpx_highbd_10_sub_pixel_avg_variance16x8,
1770                    vpx_highbd_sad16x8x4d_bits10)
1771
1772         HIGHBD_BFP(BLOCK_8X16, vpx_highbd_sad8x16_bits10,
1773                    vpx_highbd_sad8x16_avg_bits10, vpx_highbd_10_variance8x16,
1774                    vpx_highbd_10_sub_pixel_variance8x16,
1775                    vpx_highbd_10_sub_pixel_avg_variance8x16,
1776                    vpx_highbd_sad8x16x4d_bits10)
1777
1778         HIGHBD_BFP(BLOCK_8X8, vpx_highbd_sad8x8_bits10,
1779                    vpx_highbd_sad8x8_avg_bits10, vpx_highbd_10_variance8x8,
1780                    vpx_highbd_10_sub_pixel_variance8x8,
1781                    vpx_highbd_10_sub_pixel_avg_variance8x8,
1782                    vpx_highbd_sad8x8x4d_bits10)
1783
1784         HIGHBD_BFP(BLOCK_8X4, vpx_highbd_sad8x4_bits10,
1785                    vpx_highbd_sad8x4_avg_bits10, vpx_highbd_10_variance8x4,
1786                    vpx_highbd_10_sub_pixel_variance8x4,
1787                    vpx_highbd_10_sub_pixel_avg_variance8x4,
1788                    vpx_highbd_sad8x4x4d_bits10)
1789
1790         HIGHBD_BFP(BLOCK_4X8, vpx_highbd_sad4x8_bits10,
1791                    vpx_highbd_sad4x8_avg_bits10, vpx_highbd_10_variance4x8,
1792                    vpx_highbd_10_sub_pixel_variance4x8,
1793                    vpx_highbd_10_sub_pixel_avg_variance4x8,
1794                    vpx_highbd_sad4x8x4d_bits10)
1795
1796         HIGHBD_BFP(BLOCK_4X4, vpx_highbd_sad4x4_bits10,
1797                    vpx_highbd_sad4x4_avg_bits10, vpx_highbd_10_variance4x4,
1798                    vpx_highbd_10_sub_pixel_variance4x4,
1799                    vpx_highbd_10_sub_pixel_avg_variance4x4,
1800                    vpx_highbd_sad4x4x4d_bits10)
1801         break;
1802
1803       default:
1804         assert(cm->bit_depth == VPX_BITS_12);
1805         HIGHBD_BFP(BLOCK_32X16, vpx_highbd_sad32x16_bits12,
1806                    vpx_highbd_sad32x16_avg_bits12, vpx_highbd_12_variance32x16,
1807                    vpx_highbd_12_sub_pixel_variance32x16,
1808                    vpx_highbd_12_sub_pixel_avg_variance32x16,
1809                    vpx_highbd_sad32x16x4d_bits12)
1810
1811         HIGHBD_BFP(BLOCK_16X32, vpx_highbd_sad16x32_bits12,
1812                    vpx_highbd_sad16x32_avg_bits12, vpx_highbd_12_variance16x32,
1813                    vpx_highbd_12_sub_pixel_variance16x32,
1814                    vpx_highbd_12_sub_pixel_avg_variance16x32,
1815                    vpx_highbd_sad16x32x4d_bits12)
1816
1817         HIGHBD_BFP(BLOCK_64X32, vpx_highbd_sad64x32_bits12,
1818                    vpx_highbd_sad64x32_avg_bits12, vpx_highbd_12_variance64x32,
1819                    vpx_highbd_12_sub_pixel_variance64x32,
1820                    vpx_highbd_12_sub_pixel_avg_variance64x32,
1821                    vpx_highbd_sad64x32x4d_bits12)
1822
1823         HIGHBD_BFP(BLOCK_32X64, vpx_highbd_sad32x64_bits12,
1824                    vpx_highbd_sad32x64_avg_bits12, vpx_highbd_12_variance32x64,
1825                    vpx_highbd_12_sub_pixel_variance32x64,
1826                    vpx_highbd_12_sub_pixel_avg_variance32x64,
1827                    vpx_highbd_sad32x64x4d_bits12)
1828
1829         HIGHBD_BFP(BLOCK_32X32, vpx_highbd_sad32x32_bits12,
1830                    vpx_highbd_sad32x32_avg_bits12, vpx_highbd_12_variance32x32,
1831                    vpx_highbd_12_sub_pixel_variance32x32,
1832                    vpx_highbd_12_sub_pixel_avg_variance32x32,
1833                    vpx_highbd_sad32x32x4d_bits12)
1834
1835         HIGHBD_BFP(BLOCK_64X64, vpx_highbd_sad64x64_bits12,
1836                    vpx_highbd_sad64x64_avg_bits12, vpx_highbd_12_variance64x64,
1837                    vpx_highbd_12_sub_pixel_variance64x64,
1838                    vpx_highbd_12_sub_pixel_avg_variance64x64,
1839                    vpx_highbd_sad64x64x4d_bits12)
1840
1841         HIGHBD_BFP(BLOCK_16X16, vpx_highbd_sad16x16_bits12,
1842                    vpx_highbd_sad16x16_avg_bits12, vpx_highbd_12_variance16x16,
1843                    vpx_highbd_12_sub_pixel_variance16x16,
1844                    vpx_highbd_12_sub_pixel_avg_variance16x16,
1845                    vpx_highbd_sad16x16x4d_bits12)
1846
1847         HIGHBD_BFP(BLOCK_16X8, vpx_highbd_sad16x8_bits12,
1848                    vpx_highbd_sad16x8_avg_bits12, vpx_highbd_12_variance16x8,
1849                    vpx_highbd_12_sub_pixel_variance16x8,
1850                    vpx_highbd_12_sub_pixel_avg_variance16x8,
1851                    vpx_highbd_sad16x8x4d_bits12)
1852
1853         HIGHBD_BFP(BLOCK_8X16, vpx_highbd_sad8x16_bits12,
1854                    vpx_highbd_sad8x16_avg_bits12, vpx_highbd_12_variance8x16,
1855                    vpx_highbd_12_sub_pixel_variance8x16,
1856                    vpx_highbd_12_sub_pixel_avg_variance8x16,
1857                    vpx_highbd_sad8x16x4d_bits12)
1858
1859         HIGHBD_BFP(BLOCK_8X8, vpx_highbd_sad8x8_bits12,
1860                    vpx_highbd_sad8x8_avg_bits12, vpx_highbd_12_variance8x8,
1861                    vpx_highbd_12_sub_pixel_variance8x8,
1862                    vpx_highbd_12_sub_pixel_avg_variance8x8,
1863                    vpx_highbd_sad8x8x4d_bits12)
1864
1865         HIGHBD_BFP(BLOCK_8X4, vpx_highbd_sad8x4_bits12,
1866                    vpx_highbd_sad8x4_avg_bits12, vpx_highbd_12_variance8x4,
1867                    vpx_highbd_12_sub_pixel_variance8x4,
1868                    vpx_highbd_12_sub_pixel_avg_variance8x4,
1869                    vpx_highbd_sad8x4x4d_bits12)
1870
1871         HIGHBD_BFP(BLOCK_4X8, vpx_highbd_sad4x8_bits12,
1872                    vpx_highbd_sad4x8_avg_bits12, vpx_highbd_12_variance4x8,
1873                    vpx_highbd_12_sub_pixel_variance4x8,
1874                    vpx_highbd_12_sub_pixel_avg_variance4x8,
1875                    vpx_highbd_sad4x8x4d_bits12)
1876
1877         HIGHBD_BFP(BLOCK_4X4, vpx_highbd_sad4x4_bits12,
1878                    vpx_highbd_sad4x4_avg_bits12, vpx_highbd_12_variance4x4,
1879                    vpx_highbd_12_sub_pixel_variance4x4,
1880                    vpx_highbd_12_sub_pixel_avg_variance4x4,
1881                    vpx_highbd_sad4x4x4d_bits12)
1882         break;
1883     }
1884   }
1885 }
1886 #endif  // CONFIG_VP9_HIGHBITDEPTH
1887
1888 static void realloc_segmentation_maps(VP9_COMP *cpi) {
1889   VP9_COMMON *const cm = &cpi->common;
1890
1891   // Create the encoder segmentation map and set all entries to 0
1892   vpx_free(cpi->segmentation_map);
1893   CHECK_MEM_ERROR(cm, cpi->segmentation_map,
1894                   vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1895
1896   // Create a map used for cyclic background refresh.
1897   if (cpi->cyclic_refresh) vp9_cyclic_refresh_free(cpi->cyclic_refresh);
1898   CHECK_MEM_ERROR(cm, cpi->cyclic_refresh,
1899                   vp9_cyclic_refresh_alloc(cm->mi_rows, cm->mi_cols));
1900
1901   // Create a map used to mark inactive areas.
1902   vpx_free(cpi->active_map.map);
1903   CHECK_MEM_ERROR(cm, cpi->active_map.map,
1904                   vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1905
1906   // And a place holder structure is the coding context
1907   // for use if we want to save and restore it
1908   vpx_free(cpi->coding_context.last_frame_seg_map_copy);
1909   CHECK_MEM_ERROR(cm, cpi->coding_context.last_frame_seg_map_copy,
1910                   vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1911 }
1912
1913 static void alloc_copy_partition_data(VP9_COMP *cpi) {
1914   VP9_COMMON *const cm = &cpi->common;
1915   if (cpi->prev_partition == NULL) {
1916     CHECK_MEM_ERROR(cm, cpi->prev_partition,
1917                     (BLOCK_SIZE *)vpx_calloc(cm->mi_stride * cm->mi_rows,
1918                                              sizeof(*cpi->prev_partition)));
1919   }
1920   if (cpi->prev_segment_id == NULL) {
1921     CHECK_MEM_ERROR(
1922         cm, cpi->prev_segment_id,
1923         (int8_t *)vpx_calloc((cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1),
1924                              sizeof(*cpi->prev_segment_id)));
1925   }
1926   if (cpi->prev_variance_low == NULL) {
1927     CHECK_MEM_ERROR(cm, cpi->prev_variance_low,
1928                     (uint8_t *)vpx_calloc(
1929                         (cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1) * 25,
1930                         sizeof(*cpi->prev_variance_low)));
1931   }
1932   if (cpi->copied_frame_cnt == NULL) {
1933     CHECK_MEM_ERROR(
1934         cm, cpi->copied_frame_cnt,
1935         (uint8_t *)vpx_calloc((cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1),
1936                               sizeof(*cpi->copied_frame_cnt)));
1937   }
1938 }
1939
1940 void vp9_change_config(struct VP9_COMP *cpi, const VP9EncoderConfig *oxcf) {
1941   VP9_COMMON *const cm = &cpi->common;
1942   RATE_CONTROL *const rc = &cpi->rc;
1943   int last_w = cpi->oxcf.width;
1944   int last_h = cpi->oxcf.height;
1945
1946   vp9_init_quantizer(cpi);
1947   if (cm->profile != oxcf->profile) cm->profile = oxcf->profile;
1948   cm->bit_depth = oxcf->bit_depth;
1949   cm->color_space = oxcf->color_space;
1950   cm->color_range = oxcf->color_range;
1951
1952   cpi->target_level = oxcf->target_level;
1953   cpi->keep_level_stats = oxcf->target_level != LEVEL_MAX;
1954   set_level_constraint(&cpi->level_constraint,
1955                        get_level_index(cpi->target_level));
1956
1957   if (cm->profile <= PROFILE_1)
1958     assert(cm->bit_depth == VPX_BITS_8);
1959   else
1960     assert(cm->bit_depth > VPX_BITS_8);
1961
1962   cpi->oxcf = *oxcf;
1963 #if CONFIG_VP9_HIGHBITDEPTH
1964   cpi->td.mb.e_mbd.bd = (int)cm->bit_depth;
1965 #endif  // CONFIG_VP9_HIGHBITDEPTH
1966
1967   if ((oxcf->pass == 0) && (oxcf->rc_mode == VPX_Q)) {
1968     rc->baseline_gf_interval = FIXED_GF_INTERVAL;
1969   } else {
1970     rc->baseline_gf_interval = (MIN_GF_INTERVAL + MAX_GF_INTERVAL) / 2;
1971   }
1972
1973   cpi->refresh_golden_frame = 0;
1974   cpi->refresh_last_frame = 1;
1975   cm->refresh_frame_context = 1;
1976   cm->reset_frame_context = 0;
1977
1978   vp9_reset_segment_features(&cm->seg);
1979   vp9_set_high_precision_mv(cpi, 0);
1980
1981   {
1982     int i;
1983
1984     for (i = 0; i < MAX_SEGMENTS; i++)
1985       cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
1986   }
1987   cpi->encode_breakout = cpi->oxcf.encode_breakout;
1988
1989   set_rc_buffer_sizes(rc, &cpi->oxcf);
1990
1991   // Under a configuration change, where maximum_buffer_size may change,
1992   // keep buffer level clipped to the maximum allowed buffer size.
1993   rc->bits_off_target = VPXMIN(rc->bits_off_target, rc->maximum_buffer_size);
1994   rc->buffer_level = VPXMIN(rc->buffer_level, rc->maximum_buffer_size);
1995
1996   // Set up frame rate and related parameters rate control values.
1997   vp9_new_framerate(cpi, cpi->framerate);
1998
1999   // Set absolute upper and lower quality limits
2000   rc->worst_quality = cpi->oxcf.worst_allowed_q;
2001   rc->best_quality = cpi->oxcf.best_allowed_q;
2002
2003   cm->interp_filter = cpi->sf.default_interp_filter;
2004
2005   if (cpi->oxcf.render_width > 0 && cpi->oxcf.render_height > 0) {
2006     cm->render_width = cpi->oxcf.render_width;
2007     cm->render_height = cpi->oxcf.render_height;
2008   } else {
2009     cm->render_width = cpi->oxcf.width;
2010     cm->render_height = cpi->oxcf.height;
2011   }
2012   if (last_w != cpi->oxcf.width || last_h != cpi->oxcf.height) {
2013     cm->width = cpi->oxcf.width;
2014     cm->height = cpi->oxcf.height;
2015     cpi->external_resize = 1;
2016   }
2017
2018   if (cpi->initial_width) {
2019     int new_mi_size = 0;
2020     vp9_set_mb_mi(cm, cm->width, cm->height);
2021     new_mi_size = cm->mi_stride * calc_mi_size(cm->mi_rows);
2022     if (cm->mi_alloc_size < new_mi_size) {
2023       vp9_free_context_buffers(cm);
2024       alloc_compressor_data(cpi);
2025       realloc_segmentation_maps(cpi);
2026       cpi->initial_width = cpi->initial_height = 0;
2027       cpi->external_resize = 0;
2028     } else if (cm->mi_alloc_size == new_mi_size &&
2029                (cpi->oxcf.width > last_w || cpi->oxcf.height > last_h)) {
2030       vp9_alloc_loop_filter(cm);
2031     }
2032   }
2033
2034   if (cm->current_video_frame == 0 || last_w != cpi->oxcf.width ||
2035       last_h != cpi->oxcf.height)
2036     update_frame_size(cpi);
2037
2038   if (last_w != cpi->oxcf.width || last_h != cpi->oxcf.height) {
2039     memset(cpi->consec_zero_mv, 0,
2040            cm->mi_rows * cm->mi_cols * sizeof(*cpi->consec_zero_mv));
2041     if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ)
2042       vp9_cyclic_refresh_reset_resize(cpi);
2043     rc->rc_1_frame = 0;
2044     rc->rc_2_frame = 0;
2045   }
2046
2047   if ((cpi->svc.number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) ||
2048       ((cpi->svc.number_temporal_layers > 1 ||
2049         cpi->svc.number_spatial_layers > 1) &&
2050        cpi->oxcf.pass != 1)) {
2051     vp9_update_layer_context_change_config(cpi,
2052                                            (int)cpi->oxcf.target_bandwidth);
2053   }
2054
2055   // Check for resetting the rc flags (rc_1_frame, rc_2_frame) if the
2056   // configuration change has a large change in avg_frame_bandwidth.
2057   // For SVC check for resetting based on spatial layer average bandwidth.
2058   // Also reset buffer level to optimal level.
2059   if (cm->current_video_frame > 0) {
2060     if (cpi->use_svc) {
2061       vp9_svc_check_reset_layer_rc_flag(cpi);
2062     } else {
2063       if (rc->avg_frame_bandwidth > (3 * rc->last_avg_frame_bandwidth >> 1) ||
2064           rc->avg_frame_bandwidth < (rc->last_avg_frame_bandwidth >> 1)) {
2065         rc->rc_1_frame = 0;
2066         rc->rc_2_frame = 0;
2067         rc->bits_off_target = rc->optimal_buffer_level;
2068         rc->buffer_level = rc->optimal_buffer_level;
2069       }
2070     }
2071   }
2072
2073   cpi->alt_ref_source = NULL;
2074   rc->is_src_frame_alt_ref = 0;
2075
2076 #if 0
2077   // Experimental RD Code
2078   cpi->frame_distortion = 0;
2079   cpi->last_frame_distortion = 0;
2080 #endif
2081
2082   set_tile_limits(cpi);
2083
2084   cpi->ext_refresh_frame_flags_pending = 0;
2085   cpi->ext_refresh_frame_context_pending = 0;
2086
2087 #if CONFIG_VP9_HIGHBITDEPTH
2088   highbd_set_var_fns(cpi);
2089 #endif
2090
2091   vp9_set_row_mt(cpi);
2092 }
2093
2094 #ifndef M_LOG2_E
2095 #define M_LOG2_E 0.693147180559945309417
2096 #endif
2097 #define log2f(x) (log(x) / (float)M_LOG2_E)
2098
2099 /***********************************************************************
2100  * Read before modifying 'cal_nmvjointsadcost' or 'cal_nmvsadcosts'    *
2101  ***********************************************************************
2102  * The following 2 functions ('cal_nmvjointsadcost' and                *
2103  * 'cal_nmvsadcosts') are used to calculate cost lookup tables         *
2104  * used by 'vp9_diamond_search_sad'. The C implementation of the       *
2105  * function is generic, but the AVX intrinsics optimised version       *
2106  * relies on the following properties of the computed tables:          *
2107  * For cal_nmvjointsadcost:                                            *
2108  *   - mvjointsadcost[1] == mvjointsadcost[2] == mvjointsadcost[3]     *
2109  * For cal_nmvsadcosts:                                                *
2110  *   - For all i: mvsadcost[0][i] == mvsadcost[1][i]                   *
2111  *         (Equal costs for both components)                           *
2112  *   - For all i: mvsadcost[0][i] == mvsadcost[0][-i]                  *
2113  *         (Cost function is even)                                     *
2114  * If these do not hold, then the AVX optimised version of the         *
2115  * 'vp9_diamond_search_sad' function cannot be used as it is, in which *
2116  * case you can revert to using the C function instead.                *
2117  ***********************************************************************/
2118
2119 static void cal_nmvjointsadcost(int *mvjointsadcost) {
2120   /*********************************************************************
2121    * Warning: Read the comments above before modifying this function   *
2122    *********************************************************************/
2123   mvjointsadcost[0] = 600;
2124   mvjointsadcost[1] = 300;
2125   mvjointsadcost[2] = 300;
2126   mvjointsadcost[3] = 300;
2127 }
2128
2129 static void cal_nmvsadcosts(int *mvsadcost[2]) {
2130   /*********************************************************************
2131    * Warning: Read the comments above before modifying this function   *
2132    *********************************************************************/
2133   int i = 1;
2134
2135   mvsadcost[0][0] = 0;
2136   mvsadcost[1][0] = 0;
2137
2138   do {
2139     double z = 256 * (2 * (log2f(8 * i) + .6));
2140     mvsadcost[0][i] = (int)z;
2141     mvsadcost[1][i] = (int)z;
2142     mvsadcost[0][-i] = (int)z;
2143     mvsadcost[1][-i] = (int)z;
2144   } while (++i <= MV_MAX);
2145 }
2146
2147 static void cal_nmvsadcosts_hp(int *mvsadcost[2]) {
2148   int i = 1;
2149
2150   mvsadcost[0][0] = 0;
2151   mvsadcost[1][0] = 0;
2152
2153   do {
2154     double z = 256 * (2 * (log2f(8 * i) + .6));
2155     mvsadcost[0][i] = (int)z;
2156     mvsadcost[1][i] = (int)z;
2157     mvsadcost[0][-i] = (int)z;
2158     mvsadcost[1][-i] = (int)z;
2159   } while (++i <= MV_MAX);
2160 }
2161
2162 static void init_ref_frame_bufs(VP9_COMMON *cm) {
2163   int i;
2164   BufferPool *const pool = cm->buffer_pool;
2165   cm->new_fb_idx = INVALID_IDX;
2166   for (i = 0; i < REF_FRAMES; ++i) {
2167     cm->ref_frame_map[i] = INVALID_IDX;
2168   }
2169   for (i = 0; i < FRAME_BUFFERS; ++i) {
2170     pool->frame_bufs[i].ref_count = 0;
2171   }
2172 }
2173
2174 VP9_COMP *vp9_create_compressor(VP9EncoderConfig *oxcf,
2175                                 BufferPool *const pool) {
2176   unsigned int i;
2177   VP9_COMP *volatile const cpi = vpx_memalign(32, sizeof(VP9_COMP));
2178   VP9_COMMON *volatile const cm = cpi != NULL ? &cpi->common : NULL;
2179
2180   if (!cm) return NULL;
2181
2182   vp9_zero(*cpi);
2183
2184   if (setjmp(cm->error.jmp)) {
2185     cm->error.setjmp = 0;
2186     vp9_remove_compressor(cpi);
2187     return 0;
2188   }
2189
2190   cm->error.setjmp = 1;
2191   cm->alloc_mi = vp9_enc_alloc_mi;
2192   cm->free_mi = vp9_enc_free_mi;
2193   cm->setup_mi = vp9_enc_setup_mi;
2194
2195   CHECK_MEM_ERROR(cm, cm->fc, (FRAME_CONTEXT *)vpx_calloc(1, sizeof(*cm->fc)));
2196   CHECK_MEM_ERROR(
2197       cm, cm->frame_contexts,
2198       (FRAME_CONTEXT *)vpx_calloc(FRAME_CONTEXTS, sizeof(*cm->frame_contexts)));
2199
2200   cpi->use_svc = 0;
2201   cpi->resize_state = ORIG;
2202   cpi->external_resize = 0;
2203   cpi->resize_avg_qp = 0;
2204   cpi->resize_buffer_underflow = 0;
2205   cpi->use_skin_detection = 0;
2206   cpi->common.buffer_pool = pool;
2207   init_ref_frame_bufs(cm);
2208
2209   cpi->force_update_segmentation = 0;
2210
2211   init_config(cpi, oxcf);
2212   cpi->frame_info = vp9_get_frame_info(oxcf);
2213
2214   vp9_rc_init(&cpi->oxcf, oxcf->pass, &cpi->rc);
2215
2216   cm->current_video_frame = 0;
2217   cpi->partition_search_skippable_frame = 0;
2218   cpi->tile_data = NULL;
2219
2220   realloc_segmentation_maps(cpi);
2221
2222   CHECK_MEM_ERROR(
2223       cm, cpi->skin_map,
2224       vpx_calloc(cm->mi_rows * cm->mi_cols, sizeof(cpi->skin_map[0])));
2225
2226 #if !CONFIG_REALTIME_ONLY
2227   CHECK_MEM_ERROR(cm, cpi->alt_ref_aq, vp9_alt_ref_aq_create());
2228 #endif
2229
2230   CHECK_MEM_ERROR(
2231       cm, cpi->consec_zero_mv,
2232       vpx_calloc(cm->mi_rows * cm->mi_cols, sizeof(*cpi->consec_zero_mv)));
2233
2234   CHECK_MEM_ERROR(cm, cpi->nmvcosts[0],
2235                   vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts[0])));
2236   CHECK_MEM_ERROR(cm, cpi->nmvcosts[1],
2237                   vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts[1])));
2238   CHECK_MEM_ERROR(cm, cpi->nmvcosts_hp[0],
2239                   vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts_hp[0])));
2240   CHECK_MEM_ERROR(cm, cpi->nmvcosts_hp[1],
2241                   vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts_hp[1])));
2242   CHECK_MEM_ERROR(cm, cpi->nmvsadcosts[0],
2243                   vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts[0])));
2244   CHECK_MEM_ERROR(cm, cpi->nmvsadcosts[1],
2245                   vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts[1])));
2246   CHECK_MEM_ERROR(cm, cpi->nmvsadcosts_hp[0],
2247                   vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts_hp[0])));
2248   CHECK_MEM_ERROR(cm, cpi->nmvsadcosts_hp[1],
2249                   vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts_hp[1])));
2250
2251   for (i = 0; i < (sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]));
2252        i++) {
2253     CHECK_MEM_ERROR(
2254         cm, cpi->mbgraph_stats[i].mb_stats,
2255         vpx_calloc(cm->MBs * sizeof(*cpi->mbgraph_stats[i].mb_stats), 1));
2256   }
2257
2258 #if CONFIG_FP_MB_STATS
2259   cpi->use_fp_mb_stats = 0;
2260   if (cpi->use_fp_mb_stats) {
2261     // a place holder used to store the first pass mb stats in the first pass
2262     CHECK_MEM_ERROR(cm, cpi->twopass.frame_mb_stats_buf,
2263                     vpx_calloc(cm->MBs * sizeof(uint8_t), 1));
2264   } else {
2265     cpi->twopass.frame_mb_stats_buf = NULL;
2266   }
2267 #endif
2268
2269   cpi->refresh_alt_ref_frame = 0;
2270   cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
2271
2272   init_level_info(&cpi->level_info);
2273   init_level_constraint(&cpi->level_constraint);
2274
2275 #if CONFIG_INTERNAL_STATS
2276   cpi->b_calculate_blockiness = 1;
2277   cpi->b_calculate_consistency = 1;
2278   cpi->total_inconsistency = 0;
2279   cpi->psnr.worst = 100.0;
2280   cpi->worst_ssim = 100.0;
2281
2282   cpi->count = 0;
2283   cpi->bytes = 0;
2284
2285   if (cpi->b_calculate_psnr) {
2286     cpi->total_sq_error = 0;
2287     cpi->total_samples = 0;
2288
2289     cpi->totalp_sq_error = 0;
2290     cpi->totalp_samples = 0;
2291
2292     cpi->tot_recode_hits = 0;
2293     cpi->summed_quality = 0;
2294     cpi->summed_weights = 0;
2295     cpi->summedp_quality = 0;
2296     cpi->summedp_weights = 0;
2297   }
2298
2299   cpi->fastssim.worst = 100.0;
2300
2301   cpi->psnrhvs.worst = 100.0;
2302
2303   if (cpi->b_calculate_blockiness) {
2304     cpi->total_blockiness = 0;
2305     cpi->worst_blockiness = 0.0;
2306   }
2307
2308   if (cpi->b_calculate_consistency) {
2309     CHECK_MEM_ERROR(cm, cpi->ssim_vars,
2310                     vpx_calloc(cpi->common.mi_rows * cpi->common.mi_cols,
2311                                sizeof(*cpi->ssim_vars) * 4));
2312     cpi->worst_consistency = 100.0;
2313   } else {
2314     cpi->ssim_vars = NULL;
2315   }
2316
2317 #endif
2318
2319   cpi->first_time_stamp_ever = INT64_MAX;
2320
2321   /*********************************************************************
2322    * Warning: Read the comments around 'cal_nmvjointsadcost' and       *
2323    * 'cal_nmvsadcosts' before modifying how these tables are computed. *
2324    *********************************************************************/
2325   cal_nmvjointsadcost(cpi->td.mb.nmvjointsadcost);
2326   cpi->td.mb.nmvcost[0] = &cpi->nmvcosts[0][MV_MAX];
2327   cpi->td.mb.nmvcost[1] = &cpi->nmvcosts[1][MV_MAX];
2328   cpi->td.mb.nmvsadcost[0] = &cpi->nmvsadcosts[0][MV_MAX];
2329   cpi->td.mb.nmvsadcost[1] = &cpi->nmvsadcosts[1][MV_MAX];
2330   cal_nmvsadcosts(cpi->td.mb.nmvsadcost);
2331
2332   cpi->td.mb.nmvcost_hp[0] = &cpi->nmvcosts_hp[0][MV_MAX];
2333   cpi->td.mb.nmvcost_hp[1] = &cpi->nmvcosts_hp[1][MV_MAX];
2334   cpi->td.mb.nmvsadcost_hp[0] = &cpi->nmvsadcosts_hp[0][MV_MAX];
2335   cpi->td.mb.nmvsadcost_hp[1] = &cpi->nmvsadcosts_hp[1][MV_MAX];
2336   cal_nmvsadcosts_hp(cpi->td.mb.nmvsadcost_hp);
2337
2338 #if CONFIG_VP9_TEMPORAL_DENOISING
2339 #ifdef OUTPUT_YUV_DENOISED
2340   yuv_denoised_file = fopen("denoised.yuv", "ab");
2341 #endif
2342 #endif
2343 #ifdef OUTPUT_YUV_SKINMAP
2344   yuv_skinmap_file = fopen("skinmap.yuv", "wb");
2345 #endif
2346 #ifdef OUTPUT_YUV_REC
2347   yuv_rec_file = fopen("rec.yuv", "wb");
2348 #endif
2349 #ifdef OUTPUT_YUV_SVC_SRC
2350   yuv_svc_src[0] = fopen("svc_src_0.yuv", "wb");
2351   yuv_svc_src[1] = fopen("svc_src_1.yuv", "wb");
2352   yuv_svc_src[2] = fopen("svc_src_2.yuv", "wb");
2353 #endif
2354
2355 #if 0
2356   framepsnr = fopen("framepsnr.stt", "a");
2357   kf_list = fopen("kf_list.stt", "w");
2358 #endif
2359
2360   cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
2361
2362 #if !CONFIG_REALTIME_ONLY
2363   if (oxcf->pass == 1) {
2364     vp9_init_first_pass(cpi);
2365   } else if (oxcf->pass == 2) {
2366     const size_t packet_sz = sizeof(FIRSTPASS_STATS);
2367     const int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz);
2368
2369     if (cpi->svc.number_spatial_layers > 1 ||
2370         cpi->svc.number_temporal_layers > 1) {
2371       FIRSTPASS_STATS *const stats = oxcf->two_pass_stats_in.buf;
2372       FIRSTPASS_STATS *stats_copy[VPX_SS_MAX_LAYERS] = { 0 };
2373       int i;
2374
2375       for (i = 0; i < oxcf->ss_number_layers; ++i) {
2376         FIRSTPASS_STATS *const last_packet_for_layer =
2377             &stats[packets - oxcf->ss_number_layers + i];
2378         const int layer_id = (int)last_packet_for_layer->spatial_layer_id;
2379         const int packets_in_layer = (int)last_packet_for_layer->count + 1;
2380         if (layer_id >= 0 && layer_id < oxcf->ss_number_layers) {
2381           int num_frames;
2382           LAYER_CONTEXT *const lc = &cpi->svc.layer_context[layer_id];
2383
2384           vpx_free(lc->rc_twopass_stats_in.buf);
2385
2386           lc->rc_twopass_stats_in.sz = packets_in_layer * packet_sz;
2387           CHECK_MEM_ERROR(cm, lc->rc_twopass_stats_in.buf,
2388                           vpx_malloc(lc->rc_twopass_stats_in.sz));
2389           lc->twopass.stats_in_start = lc->rc_twopass_stats_in.buf;
2390           lc->twopass.stats_in = lc->twopass.stats_in_start;
2391           lc->twopass.stats_in_end =
2392               lc->twopass.stats_in_start + packets_in_layer - 1;
2393           // Note the last packet is cumulative first pass stats.
2394           // So the number of frames is packet number minus one
2395           num_frames = packets_in_layer - 1;
2396           fps_init_first_pass_info(&lc->twopass.first_pass_info,
2397                                    lc->rc_twopass_stats_in.buf, num_frames);
2398           stats_copy[layer_id] = lc->rc_twopass_stats_in.buf;
2399         }
2400       }
2401
2402       for (i = 0; i < packets; ++i) {
2403         const int layer_id = (int)stats[i].spatial_layer_id;
2404         if (layer_id >= 0 && layer_id < oxcf->ss_number_layers &&
2405             stats_copy[layer_id] != NULL) {
2406           *stats_copy[layer_id] = stats[i];
2407           ++stats_copy[layer_id];
2408         }
2409       }
2410
2411       vp9_init_second_pass_spatial_svc(cpi);
2412     } else {
2413       int num_frames;
2414 #if CONFIG_FP_MB_STATS
2415       if (cpi->use_fp_mb_stats) {
2416         const size_t psz = cpi->common.MBs * sizeof(uint8_t);
2417         const int ps = (int)(oxcf->firstpass_mb_stats_in.sz / psz);
2418
2419         cpi->twopass.firstpass_mb_stats.mb_stats_start =
2420             oxcf->firstpass_mb_stats_in.buf;
2421         cpi->twopass.firstpass_mb_stats.mb_stats_end =
2422             cpi->twopass.firstpass_mb_stats.mb_stats_start +
2423             (ps - 1) * cpi->common.MBs * sizeof(uint8_t);
2424       }
2425 #endif
2426
2427       cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf;
2428       cpi->twopass.stats_in = cpi->twopass.stats_in_start;
2429       cpi->twopass.stats_in_end = &cpi->twopass.stats_in[packets - 1];
2430       // Note the last packet is cumulative first pass stats.
2431       // So the number of frames is packet number minus one
2432       num_frames = packets - 1;
2433       fps_init_first_pass_info(&cpi->twopass.first_pass_info,
2434                                oxcf->two_pass_stats_in.buf, num_frames);
2435
2436       vp9_init_second_pass(cpi);
2437     }
2438   }
2439 #endif  // !CONFIG_REALTIME_ONLY
2440
2441   cpi->mb_wiener_var_cols = 0;
2442   cpi->mb_wiener_var_rows = 0;
2443   cpi->mb_wiener_variance = NULL;
2444
2445   vp9_set_speed_features_framesize_independent(cpi, oxcf->speed);
2446   vp9_set_speed_features_framesize_dependent(cpi, oxcf->speed);
2447
2448   {
2449     const int bsize = BLOCK_16X16;
2450     const int w = num_8x8_blocks_wide_lookup[bsize];
2451     const int h = num_8x8_blocks_high_lookup[bsize];
2452     const int num_cols = (cm->mi_cols + w - 1) / w;
2453     const int num_rows = (cm->mi_rows + h - 1) / h;
2454     CHECK_MEM_ERROR(cm, cpi->mi_ssim_rdmult_scaling_factors,
2455                     vpx_calloc(num_rows * num_cols,
2456                                sizeof(*cpi->mi_ssim_rdmult_scaling_factors)));
2457   }
2458
2459   cpi->kmeans_data_arr_alloc = 0;
2460 #if CONFIG_NON_GREEDY_MV
2461   cpi->tpl_ready = 0;
2462 #endif  // CONFIG_NON_GREEDY_MV
2463   for (i = 0; i < MAX_ARF_GOP_SIZE; ++i) cpi->tpl_stats[i].tpl_stats_ptr = NULL;
2464
2465   // Allocate memory to store variances for a frame.
2466   CHECK_MEM_ERROR(cm, cpi->source_diff_var, vpx_calloc(cm->MBs, sizeof(diff)));
2467   cpi->source_var_thresh = 0;
2468   cpi->frames_till_next_var_check = 0;
2469 #define BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF, SDX8F) \
2470   cpi->fn_ptr[BT].sdf = SDF;                             \
2471   cpi->fn_ptr[BT].sdaf = SDAF;                           \
2472   cpi->fn_ptr[BT].vf = VF;                               \
2473   cpi->fn_ptr[BT].svf = SVF;                             \
2474   cpi->fn_ptr[BT].svaf = SVAF;                           \
2475   cpi->fn_ptr[BT].sdx4df = SDX4DF;                       \
2476   cpi->fn_ptr[BT].sdx8f = SDX8F;
2477
2478   // TODO(angiebird): make sdx8f available for every block size
2479   BFP(BLOCK_32X16, vpx_sad32x16, vpx_sad32x16_avg, vpx_variance32x16,
2480       vpx_sub_pixel_variance32x16, vpx_sub_pixel_avg_variance32x16,
2481       vpx_sad32x16x4d, NULL)
2482
2483   BFP(BLOCK_16X32, vpx_sad16x32, vpx_sad16x32_avg, vpx_variance16x32,
2484       vpx_sub_pixel_variance16x32, vpx_sub_pixel_avg_variance16x32,
2485       vpx_sad16x32x4d, NULL)
2486
2487   BFP(BLOCK_64X32, vpx_sad64x32, vpx_sad64x32_avg, vpx_variance64x32,
2488       vpx_sub_pixel_variance64x32, vpx_sub_pixel_avg_variance64x32,
2489       vpx_sad64x32x4d, NULL)
2490
2491   BFP(BLOCK_32X64, vpx_sad32x64, vpx_sad32x64_avg, vpx_variance32x64,
2492       vpx_sub_pixel_variance32x64, vpx_sub_pixel_avg_variance32x64,
2493       vpx_sad32x64x4d, NULL)
2494
2495   BFP(BLOCK_32X32, vpx_sad32x32, vpx_sad32x32_avg, vpx_variance32x32,
2496       vpx_sub_pixel_variance32x32, vpx_sub_pixel_avg_variance32x32,
2497       vpx_sad32x32x4d, vpx_sad32x32x8)
2498
2499   BFP(BLOCK_64X64, vpx_sad64x64, vpx_sad64x64_avg, vpx_variance64x64,
2500       vpx_sub_pixel_variance64x64, vpx_sub_pixel_avg_variance64x64,
2501       vpx_sad64x64x4d, NULL)
2502
2503   BFP(BLOCK_16X16, vpx_sad16x16, vpx_sad16x16_avg, vpx_variance16x16,
2504       vpx_sub_pixel_variance16x16, vpx_sub_pixel_avg_variance16x16,
2505       vpx_sad16x16x4d, vpx_sad16x16x8)
2506
2507   BFP(BLOCK_16X8, vpx_sad16x8, vpx_sad16x8_avg, vpx_variance16x8,
2508       vpx_sub_pixel_variance16x8, vpx_sub_pixel_avg_variance16x8,
2509       vpx_sad16x8x4d, vpx_sad16x8x8)
2510
2511   BFP(BLOCK_8X16, vpx_sad8x16, vpx_sad8x16_avg, vpx_variance8x16,
2512       vpx_sub_pixel_variance8x16, vpx_sub_pixel_avg_variance8x16,
2513       vpx_sad8x16x4d, vpx_sad8x16x8)
2514
2515   BFP(BLOCK_8X8, vpx_sad8x8, vpx_sad8x8_avg, vpx_variance8x8,
2516       vpx_sub_pixel_variance8x8, vpx_sub_pixel_avg_variance8x8, vpx_sad8x8x4d,
2517       vpx_sad8x8x8)
2518
2519   BFP(BLOCK_8X4, vpx_sad8x4, vpx_sad8x4_avg, vpx_variance8x4,
2520       vpx_sub_pixel_variance8x4, vpx_sub_pixel_avg_variance8x4, vpx_sad8x4x4d,
2521       NULL)
2522
2523   BFP(BLOCK_4X8, vpx_sad4x8, vpx_sad4x8_avg, vpx_variance4x8,
2524       vpx_sub_pixel_variance4x8, vpx_sub_pixel_avg_variance4x8, vpx_sad4x8x4d,
2525       NULL)
2526
2527   BFP(BLOCK_4X4, vpx_sad4x4, vpx_sad4x4_avg, vpx_variance4x4,
2528       vpx_sub_pixel_variance4x4, vpx_sub_pixel_avg_variance4x4, vpx_sad4x4x4d,
2529       vpx_sad4x4x8)
2530
2531 #if CONFIG_VP9_HIGHBITDEPTH
2532   highbd_set_var_fns(cpi);
2533 #endif
2534
2535   /* vp9_init_quantizer() is first called here. Add check in
2536    * vp9_frame_init_quantizer() so that vp9_init_quantizer is only
2537    * called later when needed. This will avoid unnecessary calls of
2538    * vp9_init_quantizer() for every frame.
2539    */
2540   vp9_init_quantizer(cpi);
2541
2542   vp9_loop_filter_init(cm);
2543
2544   // Set up the unit scaling factor used during motion search.
2545 #if CONFIG_VP9_HIGHBITDEPTH
2546   vp9_setup_scale_factors_for_frame(&cpi->me_sf, cm->width, cm->height,
2547                                     cm->width, cm->height,
2548                                     cm->use_highbitdepth);
2549 #else
2550   vp9_setup_scale_factors_for_frame(&cpi->me_sf, cm->width, cm->height,
2551                                     cm->width, cm->height);
2552 #endif  // CONFIG_VP9_HIGHBITDEPTH
2553   cpi->td.mb.me_sf = &cpi->me_sf;
2554
2555   cm->error.setjmp = 0;
2556
2557   return cpi;
2558 }
2559
2560 #if CONFIG_INTERNAL_STATS
2561 #define SNPRINT(H, T) snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T))
2562
2563 #define SNPRINT2(H, T, V) \
2564   snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T), (V))
2565 #endif  // CONFIG_INTERNAL_STATS
2566
2567 static void free_tpl_buffer(VP9_COMP *cpi);
2568
2569 void vp9_remove_compressor(VP9_COMP *cpi) {
2570   VP9_COMMON *cm;
2571   unsigned int i;
2572   int t;
2573
2574   if (!cpi) return;
2575
2576 #if CONFIG_INTERNAL_STATS
2577   vpx_free(cpi->ssim_vars);
2578 #endif
2579
2580   cm = &cpi->common;
2581   if (cm->current_video_frame > 0) {
2582 #if CONFIG_INTERNAL_STATS
2583     vpx_clear_system_state();
2584
2585     if (cpi->oxcf.pass != 1) {
2586       char headings[512] = { 0 };
2587       char results[512] = { 0 };
2588       FILE *f = fopen("opsnr.stt", "a");
2589       double time_encoded =
2590           (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
2591           10000000.000;
2592       double total_encode_time =
2593           (cpi->time_receive_data + cpi->time_compress_data) / 1000.000;
2594       const double dr =
2595           (double)cpi->bytes * (double)8 / (double)1000 / time_encoded;
2596       const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
2597       const double target_rate = (double)cpi->oxcf.target_bandwidth / 1000;
2598       const double rate_err = ((100.0 * (dr - target_rate)) / target_rate);
2599
2600       if (cpi->b_calculate_psnr) {
2601         const double total_psnr = vpx_sse_to_psnr(
2602             (double)cpi->total_samples, peak, (double)cpi->total_sq_error);
2603         const double totalp_psnr = vpx_sse_to_psnr(
2604             (double)cpi->totalp_samples, peak, (double)cpi->totalp_sq_error);
2605         const double total_ssim =
2606             100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0);
2607         const double totalp_ssim =
2608             100 * pow(cpi->summedp_quality / cpi->summedp_weights, 8.0);
2609
2610         snprintf(headings, sizeof(headings),
2611                  "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\t"
2612                  "VPXSSIM\tVPSSIMP\tFASTSIM\tPSNRHVS\t"
2613                  "WstPsnr\tWstSsim\tWstFast\tWstHVS\t"
2614                  "AVPsnrY\tAPsnrCb\tAPsnrCr");
2615         snprintf(results, sizeof(results),
2616                  "%7.2f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2617                  "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2618                  "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2619                  "%7.3f\t%7.3f\t%7.3f",
2620                  dr, cpi->psnr.stat[ALL] / cpi->count, total_psnr,
2621                  cpi->psnrp.stat[ALL] / cpi->count, totalp_psnr, total_ssim,
2622                  totalp_ssim, cpi->fastssim.stat[ALL] / cpi->count,
2623                  cpi->psnrhvs.stat[ALL] / cpi->count, cpi->psnr.worst,
2624                  cpi->worst_ssim, cpi->fastssim.worst, cpi->psnrhvs.worst,
2625                  cpi->psnr.stat[Y] / cpi->count, cpi->psnr.stat[U] / cpi->count,
2626                  cpi->psnr.stat[V] / cpi->count);
2627
2628         if (cpi->b_calculate_blockiness) {
2629           SNPRINT(headings, "\t  Block\tWstBlck");
2630           SNPRINT2(results, "\t%7.3f", cpi->total_blockiness / cpi->count);
2631           SNPRINT2(results, "\t%7.3f", cpi->worst_blockiness);
2632         }
2633
2634         if (cpi->b_calculate_consistency) {
2635           double consistency =
2636               vpx_sse_to_psnr((double)cpi->totalp_samples, peak,
2637                               (double)cpi->total_inconsistency);
2638
2639           SNPRINT(headings, "\tConsist\tWstCons");
2640           SNPRINT2(results, "\t%7.3f", consistency);
2641           SNPRINT2(results, "\t%7.3f", cpi->worst_consistency);
2642         }
2643
2644         SNPRINT(headings, "\t    Time\tRcErr\tAbsErr");
2645         SNPRINT2(results, "\t%8.0f", total_encode_time);
2646         SNPRINT2(results, "\t%7.2f", rate_err);
2647         SNPRINT2(results, "\t%7.2f", fabs(rate_err));
2648
2649         fprintf(f, "%s\tAPsnr611\n", headings);
2650         fprintf(
2651             f, "%s\t%7.3f\n", results,
2652             (6 * cpi->psnr.stat[Y] + cpi->psnr.stat[U] + cpi->psnr.stat[V]) /
2653                 (cpi->count * 8));
2654       }
2655
2656       fclose(f);
2657     }
2658 #endif
2659
2660 #if 0
2661     {
2662       printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2663       printf("\n_frames recive_data encod_mb_row compress_frame  Total\n");
2664       printf("%6d %10ld %10ld %10ld %10ld\n", cpi->common.current_video_frame,
2665              cpi->time_receive_data / 1000, cpi->time_encode_sb_row / 1000,
2666              cpi->time_compress_data / 1000,
2667              (cpi->time_receive_data + cpi->time_compress_data) / 1000);
2668     }
2669 #endif
2670   }
2671
2672 #if CONFIG_VP9_TEMPORAL_DENOISING
2673   vp9_denoiser_free(&(cpi->denoiser));
2674 #endif
2675
2676   if (cpi->kmeans_data_arr_alloc) {
2677 #if CONFIG_MULTITHREAD
2678     pthread_mutex_destroy(&cpi->kmeans_mutex);
2679 #endif
2680     vpx_free(cpi->kmeans_data_arr);
2681   }
2682
2683   free_tpl_buffer(cpi);
2684
2685   for (t = 0; t < cpi->num_workers; ++t) {
2686     VPxWorker *const worker = &cpi->workers[t];
2687     EncWorkerData *const thread_data = &cpi->tile_thr_data[t];
2688
2689     // Deallocate allocated threads.
2690     vpx_get_worker_interface()->end(worker);
2691
2692     // Deallocate allocated thread data.
2693     if (t < cpi->num_workers - 1) {
2694       vpx_free(thread_data->td->counts);
2695       vp9_free_pc_tree(thread_data->td);
2696       vpx_free(thread_data->td);
2697     }
2698   }
2699   vpx_free(cpi->tile_thr_data);
2700   vpx_free(cpi->workers);
2701   vp9_row_mt_mem_dealloc(cpi);
2702
2703   if (cpi->num_workers > 1) {
2704     vp9_loop_filter_dealloc(&cpi->lf_row_sync);
2705     vp9_bitstream_encode_tiles_buffer_dealloc(cpi);
2706   }
2707
2708 #if !CONFIG_REALTIME_ONLY
2709   vp9_alt_ref_aq_destroy(cpi->alt_ref_aq);
2710 #endif
2711
2712   dealloc_compressor_data(cpi);
2713
2714   for (i = 0; i < sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]);
2715        ++i) {
2716     vpx_free(cpi->mbgraph_stats[i].mb_stats);
2717   }
2718
2719 #if CONFIG_FP_MB_STATS
2720   if (cpi->use_fp_mb_stats) {
2721     vpx_free(cpi->twopass.frame_mb_stats_buf);
2722     cpi->twopass.frame_mb_stats_buf = NULL;
2723   }
2724 #endif
2725
2726   vp9_remove_common(cm);
2727   vp9_free_ref_frame_buffers(cm->buffer_pool);
2728 #if CONFIG_VP9_POSTPROC
2729   vp9_free_postproc_buffers(cm);
2730 #endif
2731   vpx_free(cpi);
2732
2733 #if CONFIG_VP9_TEMPORAL_DENOISING
2734 #ifdef OUTPUT_YUV_DENOISED
2735   fclose(yuv_denoised_file);
2736 #endif
2737 #endif
2738 #ifdef OUTPUT_YUV_SKINMAP
2739   fclose(yuv_skinmap_file);
2740 #endif
2741 #ifdef OUTPUT_YUV_REC
2742   fclose(yuv_rec_file);
2743 #endif
2744 #ifdef OUTPUT_YUV_SVC_SRC
2745   fclose(yuv_svc_src[0]);
2746   fclose(yuv_svc_src[1]);
2747   fclose(yuv_svc_src[2]);
2748 #endif
2749
2750 #if 0
2751
2752   if (keyfile)
2753     fclose(keyfile);
2754
2755   if (framepsnr)
2756     fclose(framepsnr);
2757
2758   if (kf_list)
2759     fclose(kf_list);
2760
2761 #endif
2762 }
2763
2764 static void generate_psnr_packet(VP9_COMP *cpi) {
2765   struct vpx_codec_cx_pkt pkt;
2766   int i;
2767   PSNR_STATS psnr;
2768 #if CONFIG_VP9_HIGHBITDEPTH
2769   vpx_calc_highbd_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, &psnr,
2770                        cpi->td.mb.e_mbd.bd, cpi->oxcf.input_bit_depth);
2771 #else
2772   vpx_calc_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, &psnr);
2773 #endif
2774
2775   for (i = 0; i < 4; ++i) {
2776     pkt.data.psnr.samples[i] = psnr.samples[i];
2777     pkt.data.psnr.sse[i] = psnr.sse[i];
2778     pkt.data.psnr.psnr[i] = psnr.psnr[i];
2779   }
2780   pkt.kind = VPX_CODEC_PSNR_PKT;
2781   if (cpi->use_svc)
2782     cpi->svc
2783         .layer_context[cpi->svc.spatial_layer_id *
2784                        cpi->svc.number_temporal_layers]
2785         .psnr_pkt = pkt.data.psnr;
2786   else
2787     vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
2788 }
2789
2790 int vp9_use_as_reference(VP9_COMP *cpi, int ref_frame_flags) {
2791   if (ref_frame_flags > 7) return -1;
2792
2793   cpi->ref_frame_flags = ref_frame_flags;
2794   return 0;
2795 }
2796
2797 void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags) {
2798   cpi->ext_refresh_golden_frame = (ref_frame_flags & VP9_GOLD_FLAG) != 0;
2799   cpi->ext_refresh_alt_ref_frame = (ref_frame_flags & VP9_ALT_FLAG) != 0;
2800   cpi->ext_refresh_last_frame = (ref_frame_flags & VP9_LAST_FLAG) != 0;
2801   cpi->ext_refresh_frame_flags_pending = 1;
2802 }
2803
2804 static YV12_BUFFER_CONFIG *get_vp9_ref_frame_buffer(
2805     VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag) {
2806   MV_REFERENCE_FRAME ref_frame = NONE;
2807   if (ref_frame_flag == VP9_LAST_FLAG)
2808     ref_frame = LAST_FRAME;
2809   else if (ref_frame_flag == VP9_GOLD_FLAG)
2810     ref_frame = GOLDEN_FRAME;
2811   else if (ref_frame_flag == VP9_ALT_FLAG)
2812     ref_frame = ALTREF_FRAME;
2813
2814   return ref_frame == NONE ? NULL : get_ref_frame_buffer(cpi, ref_frame);
2815 }
2816
2817 int vp9_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
2818                            YV12_BUFFER_CONFIG *sd) {
2819   YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag);
2820   if (cfg) {
2821     vpx_yv12_copy_frame(cfg, sd);
2822     return 0;
2823   } else {
2824     return -1;
2825   }
2826 }
2827
2828 int vp9_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
2829                           YV12_BUFFER_CONFIG *sd) {
2830   YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag);
2831   if (cfg) {
2832     vpx_yv12_copy_frame(sd, cfg);
2833     return 0;
2834   } else {
2835     return -1;
2836   }
2837 }
2838
2839 int vp9_update_entropy(VP9_COMP *cpi, int update) {
2840   cpi->ext_refresh_frame_context = update;
2841   cpi->ext_refresh_frame_context_pending = 1;
2842   return 0;
2843 }
2844
2845 #ifdef OUTPUT_YUV_REC
2846 void vp9_write_yuv_rec_frame(VP9_COMMON *cm) {
2847   YV12_BUFFER_CONFIG *s = cm->frame_to_show;
2848   uint8_t *src = s->y_buffer;
2849   int h = cm->height;
2850
2851 #if CONFIG_VP9_HIGHBITDEPTH
2852   if (s->flags & YV12_FLAG_HIGHBITDEPTH) {
2853     uint16_t *src16 = CONVERT_TO_SHORTPTR(s->y_buffer);
2854
2855     do {
2856       fwrite(src16, s->y_width, 2, yuv_rec_file);
2857       src16 += s->y_stride;
2858     } while (--h);
2859
2860     src16 = CONVERT_TO_SHORTPTR(s->u_buffer);
2861     h = s->uv_height;
2862
2863     do {
2864       fwrite(src16, s->uv_width, 2, yuv_rec_file);
2865       src16 += s->uv_stride;
2866     } while (--h);
2867
2868     src16 = CONVERT_TO_SHORTPTR(s->v_buffer);
2869     h = s->uv_height;
2870
2871     do {
2872       fwrite(src16, s->uv_width, 2, yuv_rec_file);
2873       src16 += s->uv_stride;
2874     } while (--h);
2875
2876     fflush(yuv_rec_file);
2877     return;
2878   }
2879 #endif  // CONFIG_VP9_HIGHBITDEPTH
2880
2881   do {
2882     fwrite(src, s->y_width, 1, yuv_rec_file);
2883     src += s->y_stride;
2884   } while (--h);
2885
2886   src = s->u_buffer;
2887   h = s->uv_height;
2888
2889   do {
2890     fwrite(src, s->uv_width, 1, yuv_rec_file);
2891     src += s->uv_stride;
2892   } while (--h);
2893
2894   src = s->v_buffer;
2895   h = s->uv_height;
2896
2897   do {
2898     fwrite(src, s->uv_width, 1, yuv_rec_file);
2899     src += s->uv_stride;
2900   } while (--h);
2901
2902   fflush(yuv_rec_file);
2903 }
2904 #endif
2905
2906 #if CONFIG_VP9_HIGHBITDEPTH
2907 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src,
2908                                                 YV12_BUFFER_CONFIG *dst,
2909                                                 int bd) {
2910 #else
2911 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src,
2912                                                 YV12_BUFFER_CONFIG *dst) {
2913 #endif  // CONFIG_VP9_HIGHBITDEPTH
2914   // TODO(dkovalev): replace YV12_BUFFER_CONFIG with vpx_image_t
2915   int i;
2916   const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer,
2917                                    src->v_buffer };
2918   const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride };
2919   const int src_widths[3] = { src->y_crop_width, src->uv_crop_width,
2920                               src->uv_crop_width };
2921   const int src_heights[3] = { src->y_crop_height, src->uv_crop_height,
2922                                src->uv_crop_height };
2923   uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer };
2924   const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride };
2925   const int dst_widths[3] = { dst->y_crop_width, dst->uv_crop_width,
2926                               dst->uv_crop_width };
2927   const int dst_heights[3] = { dst->y_crop_height, dst->uv_crop_height,
2928                                dst->uv_crop_height };
2929
2930   for (i = 0; i < MAX_MB_PLANE; ++i) {
2931 #if CONFIG_VP9_HIGHBITDEPTH
2932     if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
2933       vp9_highbd_resize_plane(srcs[i], src_heights[i], src_widths[i],
2934                               src_strides[i], dsts[i], dst_heights[i],
2935                               dst_widths[i], dst_strides[i], bd);
2936     } else {
2937       vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i],
2938                        dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]);
2939     }
2940 #else
2941     vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i],
2942                      dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]);
2943 #endif  // CONFIG_VP9_HIGHBITDEPTH
2944   }
2945   vpx_extend_frame_borders(dst);
2946 }
2947
2948 #if CONFIG_VP9_HIGHBITDEPTH
2949 static void scale_and_extend_frame(const YV12_BUFFER_CONFIG *src,
2950                                    YV12_BUFFER_CONFIG *dst, int bd,
2951                                    INTERP_FILTER filter_type,
2952                                    int phase_scaler) {
2953   const int src_w = src->y_crop_width;
2954   const int src_h = src->y_crop_height;
2955   const int dst_w = dst->y_crop_width;
2956   const int dst_h = dst->y_crop_height;
2957   const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer,
2958                                    src->v_buffer };
2959   const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride };
2960   uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer };
2961   const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride };
2962   const InterpKernel *const kernel = vp9_filter_kernels[filter_type];
2963   int x, y, i;
2964
2965   for (i = 0; i < MAX_MB_PLANE; ++i) {
2966     const int factor = (i == 0 || i == 3 ? 1 : 2);
2967     const int src_stride = src_strides[i];
2968     const int dst_stride = dst_strides[i];
2969     for (y = 0; y < dst_h; y += 16) {
2970       const int y_q4 = y * (16 / factor) * src_h / dst_h + phase_scaler;
2971       for (x = 0; x < dst_w; x += 16) {
2972         const int x_q4 = x * (16 / factor) * src_w / dst_w + phase_scaler;
2973         const uint8_t *src_ptr = srcs[i] +
2974                                  (y / factor) * src_h / dst_h * src_stride +
2975                                  (x / factor) * src_w / dst_w;
2976         uint8_t *dst_ptr = dsts[i] + (y / factor) * dst_stride + (x / factor);
2977
2978         if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
2979           vpx_highbd_convolve8(CONVERT_TO_SHORTPTR(src_ptr), src_stride,
2980                                CONVERT_TO_SHORTPTR(dst_ptr), dst_stride, kernel,
2981                                x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf,
2982                                16 * src_h / dst_h, 16 / factor, 16 / factor,
2983                                bd);
2984         } else {
2985           vpx_scaled_2d(src_ptr, src_stride, dst_ptr, dst_stride, kernel,
2986                         x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf,
2987                         16 * src_h / dst_h, 16 / factor, 16 / factor);
2988         }
2989       }
2990     }
2991   }
2992
2993   vpx_extend_frame_borders(dst);
2994 }
2995 #endif  // CONFIG_VP9_HIGHBITDEPTH
2996
2997 #if !CONFIG_REALTIME_ONLY
2998 static int scale_down(VP9_COMP *cpi, int q) {
2999   RATE_CONTROL *const rc = &cpi->rc;
3000   GF_GROUP *const gf_group = &cpi->twopass.gf_group;
3001   int scale = 0;
3002   assert(frame_is_kf_gf_arf(cpi));
3003
3004   if (rc->frame_size_selector == UNSCALED &&
3005       q >= rc->rf_level_maxq[gf_group->rf_level[gf_group->index]]) {
3006     const int max_size_thresh =
3007         (int)(rate_thresh_mult[SCALE_STEP1] *
3008               VPXMAX(rc->this_frame_target, rc->avg_frame_bandwidth));
3009     scale = rc->projected_frame_size > max_size_thresh ? 1 : 0;
3010   }
3011   return scale;
3012 }
3013
3014 static int big_rate_miss_high_threshold(VP9_COMP *cpi) {
3015   const RATE_CONTROL *const rc = &cpi->rc;
3016   int big_miss_high;
3017
3018   if (frame_is_kf_gf_arf(cpi))
3019     big_miss_high = rc->this_frame_target * 3 / 2;
3020   else
3021     big_miss_high = rc->this_frame_target * 2;
3022
3023   return big_miss_high;
3024 }
3025
3026 static int big_rate_miss(VP9_COMP *cpi) {
3027   const RATE_CONTROL *const rc = &cpi->rc;
3028   int big_miss_high;
3029   int big_miss_low;
3030
3031   // Ignore for overlay frames
3032   if (rc->is_src_frame_alt_ref) {
3033     return 0;
3034   } else {
3035     big_miss_low = (rc->this_frame_target / 2);
3036     big_miss_high = big_rate_miss_high_threshold(cpi);
3037
3038     return (rc->projected_frame_size > big_miss_high) ||
3039            (rc->projected_frame_size < big_miss_low);
3040   }
3041 }
3042
3043 // test in two pass for the first
3044 static int two_pass_first_group_inter(VP9_COMP *cpi) {
3045   if (cpi->oxcf.pass == 2) {
3046     TWO_PASS *const twopass = &cpi->twopass;
3047     GF_GROUP *const gf_group = &twopass->gf_group;
3048     const int gfg_index = gf_group->index;
3049
3050     if (gfg_index == 0) return gf_group->update_type[gfg_index] == LF_UPDATE;
3051     return gf_group->update_type[gfg_index - 1] != LF_UPDATE &&
3052            gf_group->update_type[gfg_index] == LF_UPDATE;
3053   } else {
3054     return 0;
3055   }
3056 }
3057
3058 // Function to test for conditions that indicate we should loop
3059 // back and recode a frame.
3060 static int recode_loop_test(VP9_COMP *cpi, int high_limit, int low_limit, int q,
3061                             int maxq, int minq) {
3062   const RATE_CONTROL *const rc = &cpi->rc;
3063   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
3064   const int frame_is_kfgfarf = frame_is_kf_gf_arf(cpi);
3065   int force_recode = 0;
3066
3067   if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3068       big_rate_miss(cpi) || (cpi->sf.recode_loop == ALLOW_RECODE) ||
3069       (two_pass_first_group_inter(cpi) &&
3070        (cpi->sf.recode_loop == ALLOW_RECODE_FIRST)) ||
3071       (frame_is_kfgfarf && (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF))) {
3072     if (frame_is_kfgfarf && (oxcf->resize_mode == RESIZE_DYNAMIC) &&
3073         scale_down(cpi, q)) {
3074       // Code this group at a lower resolution.
3075       cpi->resize_pending = 1;
3076       return 1;
3077     }
3078
3079     // Force recode for extreme overshoot.
3080     if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3081         (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF &&
3082          rc->projected_frame_size >= big_rate_miss_high_threshold(cpi))) {
3083       return 1;
3084     }
3085
3086     // TODO(agrange) high_limit could be greater than the scale-down threshold.
3087     if ((rc->projected_frame_size > high_limit && q < maxq) ||
3088         (rc->projected_frame_size < low_limit && q > minq)) {
3089       force_recode = 1;
3090     } else if (cpi->oxcf.rc_mode == VPX_CQ) {
3091       // Deal with frame undershoot and whether or not we are
3092       // below the automatically set cq level.
3093       if (q > oxcf->cq_level &&
3094           rc->projected_frame_size < ((rc->this_frame_target * 7) >> 3)) {
3095         force_recode = 1;
3096       }
3097     }
3098   }
3099   return force_recode;
3100 }
3101 #endif  // !CONFIG_REALTIME_ONLY
3102
3103 static void update_ref_frames(VP9_COMP *cpi) {
3104   VP9_COMMON *const cm = &cpi->common;
3105   BufferPool *const pool = cm->buffer_pool;
3106   GF_GROUP *const gf_group = &cpi->twopass.gf_group;
3107
3108   if (cpi->rc.show_arf_as_gld) {
3109     int tmp = cpi->alt_fb_idx;
3110     cpi->alt_fb_idx = cpi->gld_fb_idx;
3111     cpi->gld_fb_idx = tmp;
3112   } else if (cm->show_existing_frame) {
3113     // Pop ARF.
3114     cpi->lst_fb_idx = cpi->alt_fb_idx;
3115     cpi->alt_fb_idx =
3116         stack_pop(gf_group->arf_index_stack, gf_group->stack_size);
3117     --gf_group->stack_size;
3118   }
3119
3120   // At this point the new frame has been encoded.
3121   // If any buffer copy / swapping is signaled it should be done here.
3122   if (cm->frame_type == KEY_FRAME) {
3123     ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
3124                cm->new_fb_idx);
3125     ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx],
3126                cm->new_fb_idx);
3127   } else if (vp9_preserve_existing_gf(cpi)) {
3128     // We have decided to preserve the previously existing golden frame as our
3129     // new ARF frame. However, in the short term in function
3130     // vp9_get_refresh_mask() we left it in the GF slot and, if
3131     // we're updating the GF with the current decoded frame, we save it to the
3132     // ARF slot instead.
3133     // We now have to update the ARF with the current frame and swap gld_fb_idx
3134     // and alt_fb_idx so that, overall, we've stored the old GF in the new ARF
3135     // slot and, if we're updating the GF, the current frame becomes the new GF.
3136     int tmp;
3137
3138     ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx],
3139                cm->new_fb_idx);
3140
3141     tmp = cpi->alt_fb_idx;
3142     cpi->alt_fb_idx = cpi->gld_fb_idx;
3143     cpi->gld_fb_idx = tmp;
3144   } else { /* For non key/golden frames */
3145     if (cpi->refresh_alt_ref_frame) {
3146       int arf_idx = gf_group->top_arf_idx;
3147
3148       // Push new ARF into stack.
3149       stack_push(gf_group->arf_index_stack, cpi->alt_fb_idx,
3150                  gf_group->stack_size);
3151       ++gf_group->stack_size;
3152
3153       assert(arf_idx < REF_FRAMES);
3154
3155       ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[arf_idx], cm->new_fb_idx);
3156       memcpy(cpi->interp_filter_selected[ALTREF_FRAME],
3157              cpi->interp_filter_selected[0],
3158              sizeof(cpi->interp_filter_selected[0]));
3159
3160       cpi->alt_fb_idx = arf_idx;
3161     }
3162
3163     if (cpi->refresh_golden_frame) {
3164       ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
3165                  cm->new_fb_idx);
3166       if (!cpi->rc.is_src_frame_alt_ref)
3167         memcpy(cpi->interp_filter_selected[GOLDEN_FRAME],
3168                cpi->interp_filter_selected[0],
3169                sizeof(cpi->interp_filter_selected[0]));
3170       else
3171         memcpy(cpi->interp_filter_selected[GOLDEN_FRAME],
3172                cpi->interp_filter_selected[ALTREF_FRAME],
3173                sizeof(cpi->interp_filter_selected[ALTREF_FRAME]));
3174     }
3175   }
3176
3177   if (cpi->refresh_last_frame) {
3178     ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->lst_fb_idx],
3179                cm->new_fb_idx);
3180     if (!cpi->rc.is_src_frame_alt_ref)
3181       memcpy(cpi->interp_filter_selected[LAST_FRAME],
3182              cpi->interp_filter_selected[0],
3183              sizeof(cpi->interp_filter_selected[0]));
3184   }
3185
3186   if (gf_group->update_type[gf_group->index] == MID_OVERLAY_UPDATE) {
3187     cpi->alt_fb_idx =
3188         stack_pop(gf_group->arf_index_stack, gf_group->stack_size);
3189     --gf_group->stack_size;
3190   }
3191 }
3192
3193 void vp9_update_reference_frames(VP9_COMP *cpi) {
3194   update_ref_frames(cpi);
3195
3196 #if CONFIG_VP9_TEMPORAL_DENOISING
3197   vp9_denoiser_update_ref_frame(cpi);
3198 #endif
3199
3200   if (is_one_pass_cbr_svc(cpi)) vp9_svc_update_ref_frame(cpi);
3201 }
3202
3203 static void loopfilter_frame(VP9_COMP *cpi, VP9_COMMON *cm) {
3204   MACROBLOCKD *xd = &cpi->td.mb.e_mbd;
3205   struct loopfilter *lf = &cm->lf;
3206   int is_reference_frame =
3207       (cm->frame_type == KEY_FRAME || cpi->refresh_last_frame ||
3208        cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame);
3209   if (cpi->use_svc &&
3210       cpi->svc.temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS)
3211     is_reference_frame = !cpi->svc.non_reference_frame;
3212
3213   // Skip loop filter in show_existing_frame mode.
3214   if (cm->show_existing_frame) {
3215     lf->filter_level = 0;
3216     return;
3217   }
3218
3219   if (xd->lossless) {
3220     lf->filter_level = 0;
3221     lf->last_filt_level = 0;
3222   } else {
3223     struct vpx_usec_timer timer;
3224
3225     vpx_clear_system_state();
3226
3227     vpx_usec_timer_start(&timer);
3228
3229     if (!cpi->rc.is_src_frame_alt_ref) {
3230       if ((cpi->common.frame_type == KEY_FRAME) &&
3231           (!cpi->rc.this_key_frame_forced)) {
3232         lf->last_filt_level = 0;
3233       }
3234       vp9_pick_filter_level(cpi->Source, cpi, cpi->sf.lpf_pick);
3235       lf->last_filt_level = lf->filter_level;
3236     } else {
3237       lf->filter_level = 0;
3238     }
3239
3240     vpx_usec_timer_mark(&timer);
3241     cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
3242   }
3243
3244   if (lf->filter_level > 0 && is_reference_frame) {
3245     vp9_build_mask_frame(cm, lf->filter_level, 0);
3246
3247     if (cpi->num_workers > 1)
3248       vp9_loop_filter_frame_mt(cm->frame_to_show, cm, xd->plane,
3249                                lf->filter_level, 0, 0, cpi->workers,
3250                                cpi->num_workers, &cpi->lf_row_sync);
3251     else
3252       vp9_loop_filter_frame(cm->frame_to_show, cm, xd, lf->filter_level, 0, 0);
3253   }
3254
3255   vpx_extend_frame_inner_borders(cm->frame_to_show);
3256 }
3257
3258 static INLINE void alloc_frame_mvs(VP9_COMMON *const cm, int buffer_idx) {
3259   RefCntBuffer *const new_fb_ptr = &cm->buffer_pool->frame_bufs[buffer_idx];
3260   if (new_fb_ptr->mvs == NULL || new_fb_ptr->mi_rows < cm->mi_rows ||
3261       new_fb_ptr->mi_cols < cm->mi_cols) {
3262     vpx_free(new_fb_ptr->mvs);
3263     CHECK_MEM_ERROR(cm, new_fb_ptr->mvs,
3264                     (MV_REF *)vpx_calloc(cm->mi_rows * cm->mi_cols,
3265                                          sizeof(*new_fb_ptr->mvs)));
3266     new_fb_ptr->mi_rows = cm->mi_rows;
3267     new_fb_ptr->mi_cols = cm->mi_cols;
3268   }
3269 }
3270
3271 void vp9_scale_references(VP9_COMP *cpi) {
3272   VP9_COMMON *cm = &cpi->common;
3273   MV_REFERENCE_FRAME ref_frame;
3274   const VP9_REFFRAME ref_mask[3] = { VP9_LAST_FLAG, VP9_GOLD_FLAG,
3275                                      VP9_ALT_FLAG };
3276
3277   for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3278     // Need to convert from VP9_REFFRAME to index into ref_mask (subtract 1).
3279     if (cpi->ref_frame_flags & ref_mask[ref_frame - 1]) {
3280       BufferPool *const pool = cm->buffer_pool;
3281       const YV12_BUFFER_CONFIG *const ref =
3282           get_ref_frame_buffer(cpi, ref_frame);
3283
3284       if (ref == NULL) {
3285         cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3286         continue;
3287       }
3288
3289 #if CONFIG_VP9_HIGHBITDEPTH
3290       if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
3291         RefCntBuffer *new_fb_ptr = NULL;
3292         int force_scaling = 0;
3293         int new_fb = cpi->scaled_ref_idx[ref_frame - 1];
3294         if (new_fb == INVALID_IDX) {
3295           new_fb = get_free_fb(cm);
3296           force_scaling = 1;
3297         }
3298         if (new_fb == INVALID_IDX) return;
3299         new_fb_ptr = &pool->frame_bufs[new_fb];
3300         if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width ||
3301             new_fb_ptr->buf.y_crop_height != cm->height) {
3302           if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height,
3303                                        cm->subsampling_x, cm->subsampling_y,
3304                                        cm->use_highbitdepth,
3305                                        VP9_ENC_BORDER_IN_PIXELS,
3306                                        cm->byte_alignment, NULL, NULL, NULL))
3307             vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3308                                "Failed to allocate frame buffer");
3309           scale_and_extend_frame(ref, &new_fb_ptr->buf, (int)cm->bit_depth,
3310                                  EIGHTTAP, 0);
3311           cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
3312           alloc_frame_mvs(cm, new_fb);
3313         }
3314 #else
3315       if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
3316         RefCntBuffer *new_fb_ptr = NULL;
3317         int force_scaling = 0;
3318         int new_fb = cpi->scaled_ref_idx[ref_frame - 1];
3319         if (new_fb == INVALID_IDX) {
3320           new_fb = get_free_fb(cm);
3321           force_scaling = 1;
3322         }
3323         if (new_fb == INVALID_IDX) return;
3324         new_fb_ptr = &pool->frame_bufs[new_fb];
3325         if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width ||
3326             new_fb_ptr->buf.y_crop_height != cm->height) {
3327           if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height,
3328                                        cm->subsampling_x, cm->subsampling_y,
3329                                        VP9_ENC_BORDER_IN_PIXELS,
3330                                        cm->byte_alignment, NULL, NULL, NULL))
3331             vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3332                                "Failed to allocate frame buffer");
3333           vp9_scale_and_extend_frame(ref, &new_fb_ptr->buf, EIGHTTAP, 0);
3334           cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
3335           alloc_frame_mvs(cm, new_fb);
3336         }
3337 #endif  // CONFIG_VP9_HIGHBITDEPTH
3338       } else {
3339         int buf_idx;
3340         RefCntBuffer *buf = NULL;
3341         if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
3342           // Check for release of scaled reference.
3343           buf_idx = cpi->scaled_ref_idx[ref_frame - 1];
3344           if (buf_idx != INVALID_IDX) {
3345             buf = &pool->frame_bufs[buf_idx];
3346             --buf->ref_count;
3347             cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3348           }
3349         }
3350         buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
3351         buf = &pool->frame_bufs[buf_idx];
3352         buf->buf.y_crop_width = ref->y_crop_width;
3353         buf->buf.y_crop_height = ref->y_crop_height;
3354         cpi->scaled_ref_idx[ref_frame - 1] = buf_idx;
3355         ++buf->ref_count;
3356       }
3357     } else {
3358       if (cpi->oxcf.pass != 0 || cpi->use_svc)
3359         cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3360     }
3361   }
3362 }
3363
3364 static void release_scaled_references(VP9_COMP *cpi) {
3365   VP9_COMMON *cm = &cpi->common;
3366   int i;
3367   if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
3368     // Only release scaled references under certain conditions:
3369     // if reference will be updated, or if scaled reference has same resolution.
3370     int refresh[3];
3371     refresh[0] = (cpi->refresh_last_frame) ? 1 : 0;
3372     refresh[1] = (cpi->refresh_golden_frame) ? 1 : 0;
3373     refresh[2] = (cpi->refresh_alt_ref_frame) ? 1 : 0;
3374     for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
3375       const int idx = cpi->scaled_ref_idx[i - 1];
3376       if (idx != INVALID_IDX) {
3377         RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx];
3378         const YV12_BUFFER_CONFIG *const ref = get_ref_frame_buffer(cpi, i);
3379         if (refresh[i - 1] || (buf->buf.y_crop_width == ref->y_crop_width &&
3380                                buf->buf.y_crop_height == ref->y_crop_height)) {
3381           --buf->ref_count;
3382           cpi->scaled_ref_idx[i - 1] = INVALID_IDX;
3383         }
3384       }
3385     }
3386   } else {
3387     for (i = 0; i < REFS_PER_FRAME; ++i) {
3388       const int idx = cpi->scaled_ref_idx[i];
3389       if (idx != INVALID_IDX) {
3390         RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx];
3391         --buf->ref_count;
3392         cpi->scaled_ref_idx[i] = INVALID_IDX;
3393       }
3394     }
3395   }
3396 }
3397
3398 static void full_to_model_count(unsigned int *model_count,
3399                                 unsigned int *full_count) {
3400   int n;
3401   model_count[ZERO_TOKEN] = full_count[ZERO_TOKEN];
3402   model_count[ONE_TOKEN] = full_count[ONE_TOKEN];
3403   model_count[TWO_TOKEN] = full_count[TWO_TOKEN];
3404   for (n = THREE_TOKEN; n < EOB_TOKEN; ++n)
3405     model_count[TWO_TOKEN] += full_count[n];
3406   model_count[EOB_MODEL_TOKEN] = full_count[EOB_TOKEN];
3407 }
3408
3409 static void full_to_model_counts(vp9_coeff_count_model *model_count,
3410                                  vp9_coeff_count *full_count) {
3411   int i, j, k, l;
3412
3413   for (i = 0; i < PLANE_TYPES; ++i)
3414     for (j = 0; j < REF_TYPES; ++j)
3415       for (k = 0; k < COEF_BANDS; ++k)
3416         for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l)
3417           full_to_model_count(model_count[i][j][k][l], full_count[i][j][k][l]);
3418 }
3419
3420 #if 0 && CONFIG_INTERNAL_STATS
3421 static void output_frame_level_debug_stats(VP9_COMP *cpi) {
3422   VP9_COMMON *const cm = &cpi->common;
3423   FILE *const f = fopen("tmp.stt", cm->current_video_frame ? "a" : "w");
3424   int64_t recon_err;
3425
3426   vpx_clear_system_state();
3427
3428 #if CONFIG_VP9_HIGHBITDEPTH
3429   if (cm->use_highbitdepth) {
3430     recon_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3431   } else {
3432     recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3433   }
3434 #else
3435   recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3436 #endif  // CONFIG_VP9_HIGHBITDEPTH
3437
3438
3439   if (cpi->twopass.total_left_stats.coded_error != 0.0) {
3440     double dc_quant_devisor;
3441 #if CONFIG_VP9_HIGHBITDEPTH
3442     switch (cm->bit_depth) {
3443       case VPX_BITS_8:
3444         dc_quant_devisor = 4.0;
3445         break;
3446       case VPX_BITS_10:
3447         dc_quant_devisor = 16.0;
3448         break;
3449       default:
3450         assert(cm->bit_depth == VPX_BITS_12);
3451         dc_quant_devisor = 64.0;
3452         break;
3453     }
3454 #else
3455     dc_quant_devisor = 4.0;
3456 #endif
3457
3458     if (!cm->current_video_frame) {
3459       fprintf(f, "frame, width, height, last ts, last end ts, "
3460           "source_alt_ref_pending, source_alt_ref_active, "
3461           "this_frame_target, projected_frame_size, "
3462           "projected_frame_size / MBs, "
3463           "projected_frame_size - this_frame_target, "
3464           "vbr_bits_off_target, vbr_bits_off_target_fast, "
3465           "twopass.extend_minq, twopass.extend_minq_fast, "
3466           "total_target_vs_actual, "
3467           "starting_buffer_level - bits_off_target, "
3468           "total_actual_bits, base_qindex, q for base_qindex, "
3469           "dc quant, q for active_worst_quality, avg_q, q for oxcf.cq_level, "
3470           "refresh_last_frame, refresh_golden_frame, refresh_alt_ref_frame, "
3471           "frame_type, gfu_boost, "
3472           "twopass.bits_left, "
3473           "twopass.total_left_stats.coded_error, "
3474           "twopass.bits_left / (1 + twopass.total_left_stats.coded_error), "
3475           "tot_recode_hits, recon_err, kf_boost, "
3476           "twopass.kf_zeromotion_pct, twopass.fr_content_type, "
3477           "filter_level, seg.aq_av_offset\n");
3478     }
3479
3480     fprintf(f, "%10u, %d, %d, %10"PRId64", %10"PRId64", %d, %d, %10d, %10d, "
3481         "%10d, %10d, %10"PRId64", %10"PRId64", %5d, %5d, %10"PRId64", "
3482         "%10"PRId64", %10"PRId64", %10d, %7.2lf, %7.2lf, %7.2lf, %7.2lf, "
3483         "%7.2lf, %6d, %6d, %5d, %5d, %5d, %10"PRId64", %10.3lf, %10lf, %8u, "
3484         "%10"PRId64", %10d, %10d, %10d, %10d, %10d\n",
3485         cpi->common.current_video_frame,
3486         cm->width, cm->height,
3487         cpi->last_time_stamp_seen,
3488         cpi->last_end_time_stamp_seen,
3489         cpi->rc.source_alt_ref_pending,
3490         cpi->rc.source_alt_ref_active,
3491         cpi->rc.this_frame_target,
3492         cpi->rc.projected_frame_size,
3493         cpi->rc.projected_frame_size / cpi->common.MBs,
3494         (cpi->rc.projected_frame_size - cpi->rc.this_frame_target),
3495         cpi->rc.vbr_bits_off_target,
3496         cpi->rc.vbr_bits_off_target_fast,
3497         cpi->twopass.extend_minq,
3498         cpi->twopass.extend_minq_fast,
3499         cpi->rc.total_target_vs_actual,
3500         (cpi->rc.starting_buffer_level - cpi->rc.bits_off_target),
3501         cpi->rc.total_actual_bits, cm->base_qindex,
3502         vp9_convert_qindex_to_q(cm->base_qindex, cm->bit_depth),
3503         (double)vp9_dc_quant(cm->base_qindex, 0, cm->bit_depth) /
3504             dc_quant_devisor,
3505         vp9_convert_qindex_to_q(cpi->twopass.active_worst_quality,
3506                                 cm->bit_depth),
3507         cpi->rc.avg_q,
3508         vp9_convert_qindex_to_q(cpi->oxcf.cq_level, cm->bit_depth),
3509         cpi->refresh_last_frame, cpi->refresh_golden_frame,
3510         cpi->refresh_alt_ref_frame, cm->frame_type, cpi->rc.gfu_boost,
3511         cpi->twopass.bits_left,
3512         cpi->twopass.total_left_stats.coded_error,
3513         cpi->twopass.bits_left /
3514             (1 + cpi->twopass.total_left_stats.coded_error),
3515         cpi->tot_recode_hits, recon_err, cpi->rc.kf_boost,
3516         cpi->twopass.kf_zeromotion_pct,
3517         cpi->twopass.fr_content_type,
3518         cm->lf.filter_level,
3519         cm->seg.aq_av_offset);
3520   }
3521   fclose(f);
3522
3523   if (0) {
3524     FILE *const fmodes = fopen("Modes.stt", "a");
3525     int i;
3526
3527     fprintf(fmodes, "%6d:%1d:%1d:%1d ", cpi->common.current_video_frame,
3528             cm->frame_type, cpi->refresh_golden_frame,
3529             cpi->refresh_alt_ref_frame);
3530
3531     for (i = 0; i < MAX_MODES; ++i)
3532       fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
3533
3534     fprintf(fmodes, "\n");
3535
3536     fclose(fmodes);
3537   }
3538 }
3539 #endif
3540
3541 static void set_mv_search_params(VP9_COMP *cpi) {
3542   const VP9_COMMON *const cm = &cpi->common;
3543   const unsigned int max_mv_def = VPXMIN(cm->width, cm->height);
3544
3545   // Default based on max resolution.
3546   cpi->mv_step_param = vp9_init_search_range(max_mv_def);
3547
3548   if (cpi->sf.mv.auto_mv_step_size) {
3549     if (frame_is_intra_only(cm)) {
3550       // Initialize max_mv_magnitude for use in the first INTER frame
3551       // after a key/intra-only frame.
3552       cpi->max_mv_magnitude = max_mv_def;
3553     } else {
3554       if (cm->show_frame) {
3555         // Allow mv_steps to correspond to twice the max mv magnitude found
3556         // in the previous frame, capped by the default max_mv_magnitude based
3557         // on resolution.
3558         cpi->mv_step_param = vp9_init_search_range(
3559             VPXMIN(max_mv_def, 2 * cpi->max_mv_magnitude));
3560       }
3561       cpi->max_mv_magnitude = 0;
3562     }
3563   }
3564 }
3565
3566 static void set_size_independent_vars(VP9_COMP *cpi) {
3567   vp9_set_speed_features_framesize_independent(cpi, cpi->oxcf.speed);
3568   vp9_set_rd_speed_thresholds(cpi);
3569   vp9_set_rd_speed_thresholds_sub8x8(cpi);
3570   cpi->common.interp_filter = cpi->sf.default_interp_filter;
3571 }
3572
3573 static void set_size_dependent_vars(VP9_COMP *cpi, int *q, int *bottom_index,
3574                                     int *top_index) {
3575   VP9_COMMON *const cm = &cpi->common;
3576
3577   // Setup variables that depend on the dimensions of the frame.
3578   vp9_set_speed_features_framesize_dependent(cpi, cpi->oxcf.speed);
3579
3580   // Decide q and q bounds.
3581   *q = vp9_rc_pick_q_and_bounds(cpi, bottom_index, top_index);
3582
3583   if (cpi->oxcf.rc_mode == VPX_CBR && cpi->rc.force_max_q) {
3584     *q = cpi->rc.worst_quality;
3585     cpi->rc.force_max_q = 0;
3586   }
3587
3588   if (!frame_is_intra_only(cm)) {
3589     vp9_set_high_precision_mv(cpi, (*q) < HIGH_PRECISION_MV_QTHRESH);
3590   }
3591
3592 #if !CONFIG_REALTIME_ONLY
3593   // Configure experimental use of segmentation for enhanced coding of
3594   // static regions if indicated.
3595   // Only allowed in the second pass of a two pass encode, as it requires
3596   // lagged coding, and if the relevant speed feature flag is set.
3597   if (cpi->oxcf.pass == 2 && cpi->sf.static_segmentation)
3598     configure_static_seg_features(cpi);
3599 #endif  // !CONFIG_REALTIME_ONLY
3600
3601 #if CONFIG_VP9_POSTPROC && !(CONFIG_VP9_TEMPORAL_DENOISING)
3602   if (cpi->oxcf.noise_sensitivity > 0) {
3603     int l = 0;
3604     switch (cpi->oxcf.noise_sensitivity) {
3605       case 1: l = 20; break;
3606       case 2: l = 40; break;
3607       case 3: l = 60; break;
3608       case 4:
3609       case 5: l = 100; break;
3610       case 6: l = 150; break;
3611     }
3612     if (!cpi->common.postproc_state.limits) {
3613       cpi->common.postproc_state.limits =
3614           vpx_calloc(cpi->un_scaled_source->y_width,
3615                      sizeof(*cpi->common.postproc_state.limits));
3616     }
3617     vp9_denoise(&cpi->common, cpi->Source, cpi->Source, l,
3618                 cpi->common.postproc_state.limits);
3619   }
3620 #endif  // CONFIG_VP9_POSTPROC
3621 }
3622
3623 #if CONFIG_VP9_TEMPORAL_DENOISING
3624 static void setup_denoiser_buffer(VP9_COMP *cpi) {
3625   VP9_COMMON *const cm = &cpi->common;
3626   if (cpi->oxcf.noise_sensitivity > 0 &&
3627       !cpi->denoiser.frame_buffer_initialized) {
3628     if (vp9_denoiser_alloc(cm, &cpi->svc, &cpi->denoiser, cpi->use_svc,
3629                            cpi->oxcf.noise_sensitivity, cm->width, cm->height,
3630                            cm->subsampling_x, cm->subsampling_y,
3631 #if CONFIG_VP9_HIGHBITDEPTH
3632                            cm->use_highbitdepth,
3633 #endif
3634                            VP9_ENC_BORDER_IN_PIXELS))
3635       vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3636                          "Failed to allocate denoiser");
3637   }
3638 }
3639 #endif
3640
3641 static void init_motion_estimation(VP9_COMP *cpi) {
3642   int y_stride = cpi->scaled_source.y_stride;
3643
3644   if (cpi->sf.mv.search_method == NSTEP) {
3645     vp9_init3smotion_compensation(&cpi->ss_cfg, y_stride);
3646   } else if (cpi->sf.mv.search_method == DIAMOND) {
3647     vp9_init_dsmotion_compensation(&cpi->ss_cfg, y_stride);
3648   }
3649 }
3650
3651 static void set_frame_size(VP9_COMP *cpi) {
3652   int ref_frame;
3653   VP9_COMMON *const cm = &cpi->common;
3654   VP9EncoderConfig *const oxcf = &cpi->oxcf;
3655   MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
3656
3657 #if !CONFIG_REALTIME_ONLY
3658   if (oxcf->pass == 2 && oxcf->rc_mode == VPX_VBR &&
3659       ((oxcf->resize_mode == RESIZE_FIXED && cm->current_video_frame == 0) ||
3660        (oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending))) {
3661     calculate_coded_size(cpi, &oxcf->scaled_frame_width,
3662                          &oxcf->scaled_frame_height);
3663
3664     // There has been a change in frame size.
3665     vp9_set_size_literal(cpi, oxcf->scaled_frame_width,
3666                          oxcf->scaled_frame_height);
3667   }
3668 #endif  // !CONFIG_REALTIME_ONLY
3669
3670   if (oxcf->pass == 0 && oxcf->rc_mode == VPX_CBR && !cpi->use_svc &&
3671       oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending != 0) {
3672     oxcf->scaled_frame_width =
3673         (oxcf->width * cpi->resize_scale_num) / cpi->resize_scale_den;
3674     oxcf->scaled_frame_height =
3675         (oxcf->height * cpi->resize_scale_num) / cpi->resize_scale_den;
3676     // There has been a change in frame size.
3677     vp9_set_size_literal(cpi, oxcf->scaled_frame_width,
3678                          oxcf->scaled_frame_height);
3679
3680     // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed.
3681     set_mv_search_params(cpi);
3682
3683     vp9_noise_estimate_init(&cpi->noise_estimate, cm->width, cm->height);
3684 #if CONFIG_VP9_TEMPORAL_DENOISING
3685     // Reset the denoiser on the resized frame.
3686     if (cpi->oxcf.noise_sensitivity > 0) {
3687       vp9_denoiser_free(&(cpi->denoiser));
3688       setup_denoiser_buffer(cpi);
3689       // Dynamic resize is only triggered for non-SVC, so we can force
3690       // golden frame update here as temporary fix to denoiser.
3691       cpi->refresh_golden_frame = 1;
3692     }
3693 #endif
3694   }
3695
3696   if ((oxcf->pass == 2) && !cpi->use_svc) {
3697     vp9_set_target_rate(cpi);
3698   }
3699
3700   alloc_frame_mvs(cm, cm->new_fb_idx);
3701
3702   // Reset the frame pointers to the current frame size.
3703   if (vpx_realloc_frame_buffer(get_frame_new_buffer(cm), cm->width, cm->height,
3704                                cm->subsampling_x, cm->subsampling_y,
3705 #if CONFIG_VP9_HIGHBITDEPTH
3706                                cm->use_highbitdepth,
3707 #endif
3708                                VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
3709                                NULL, NULL, NULL))
3710     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3711                        "Failed to allocate frame buffer");
3712
3713   alloc_util_frame_buffers(cpi);
3714   init_motion_estimation(cpi);
3715
3716   for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3717     RefBuffer *const ref_buf = &cm->frame_refs[ref_frame - 1];
3718     const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
3719
3720     ref_buf->idx = buf_idx;
3721
3722     if (buf_idx != INVALID_IDX) {
3723       YV12_BUFFER_CONFIG *const buf = &cm->buffer_pool->frame_bufs[buf_idx].buf;
3724       ref_buf->buf = buf;
3725 #if CONFIG_VP9_HIGHBITDEPTH
3726       vp9_setup_scale_factors_for_frame(
3727           &ref_buf->sf, buf->y_crop_width, buf->y_crop_height, cm->width,
3728           cm->height, (buf->flags & YV12_FLAG_HIGHBITDEPTH) ? 1 : 0);
3729 #else
3730       vp9_setup_scale_factors_for_frame(&ref_buf->sf, buf->y_crop_width,
3731                                         buf->y_crop_height, cm->width,
3732                                         cm->height);
3733 #endif  // CONFIG_VP9_HIGHBITDEPTH
3734       if (vp9_is_scaled(&ref_buf->sf)) vpx_extend_frame_borders(buf);
3735     } else {
3736       ref_buf->buf = NULL;
3737     }
3738   }
3739
3740   set_ref_ptrs(cm, xd, LAST_FRAME, LAST_FRAME);
3741 }
3742
3743 #if CONFIG_CONSISTENT_RECODE
3744 static void save_encode_params(VP9_COMP *cpi) {
3745   VP9_COMMON *const cm = &cpi->common;
3746   const int tile_cols = 1 << cm->log2_tile_cols;
3747   const int tile_rows = 1 << cm->log2_tile_rows;
3748   int tile_col, tile_row;
3749   int i, j;
3750   RD_OPT *rd_opt = &cpi->rd;
3751   for (i = 0; i < MAX_REF_FRAMES; i++) {
3752     for (j = 0; j < REFERENCE_MODES; j++)
3753       rd_opt->prediction_type_threshes_prev[i][j] =
3754           rd_opt->prediction_type_threshes[i][j];
3755
3756     for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; j++)
3757       rd_opt->filter_threshes_prev[i][j] = rd_opt->filter_threshes[i][j];
3758   }
3759
3760   if (cpi->tile_data != NULL) {
3761     for (tile_row = 0; tile_row < tile_rows; ++tile_row)
3762       for (tile_col = 0; tile_col < tile_cols; ++tile_col) {
3763         TileDataEnc *tile_data =
3764             &cpi->tile_data[tile_row * tile_cols + tile_col];
3765         for (i = 0; i < BLOCK_SIZES; ++i) {
3766           for (j = 0; j < MAX_MODES; ++j) {
3767             tile_data->thresh_freq_fact_prev[i][j] =
3768                 tile_data->thresh_freq_fact[i][j];
3769           }
3770         }
3771       }
3772   }
3773 }
3774 #endif
3775
3776 static INLINE void set_raw_source_frame(VP9_COMP *cpi) {
3777 #ifdef ENABLE_KF_DENOISE
3778   if (is_spatial_denoise_enabled(cpi)) {
3779     cpi->raw_source_frame = vp9_scale_if_required(
3780         cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
3781         (oxcf->pass == 0), EIGHTTAP, 0);
3782   } else {
3783     cpi->raw_source_frame = cpi->Source;
3784   }
3785 #else
3786   cpi->raw_source_frame = cpi->Source;
3787 #endif
3788 }
3789
3790 static int encode_without_recode_loop(VP9_COMP *cpi, size_t *size,
3791                                       uint8_t *dest) {
3792   VP9_COMMON *const cm = &cpi->common;
3793   SVC *const svc = &cpi->svc;
3794   int q = 0, bottom_index = 0, top_index = 0;
3795   int no_drop_scene_change = 0;
3796   const INTERP_FILTER filter_scaler =
3797       (is_one_pass_cbr_svc(cpi))
3798           ? svc->downsample_filter_type[svc->spatial_layer_id]
3799           : EIGHTTAP;
3800   const int phase_scaler =
3801       (is_one_pass_cbr_svc(cpi))
3802           ? svc->downsample_filter_phase[svc->spatial_layer_id]
3803           : 0;
3804
3805   if (cm->show_existing_frame) {
3806     cpi->rc.this_frame_target = 0;
3807     if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi);
3808     return 1;
3809   }
3810
3811   svc->time_stamp_prev[svc->spatial_layer_id] = svc->time_stamp_superframe;
3812
3813   // Flag to check if its valid to compute the source sad (used for
3814   // scene detection and for superblock content state in CBR mode).
3815   // The flag may get reset below based on SVC or resizing state.
3816   cpi->compute_source_sad_onepass = cpi->oxcf.mode == REALTIME;
3817
3818   vpx_clear_system_state();
3819
3820   set_frame_size(cpi);
3821
3822   if (is_one_pass_cbr_svc(cpi) &&
3823       cpi->un_scaled_source->y_width == cm->width << 2 &&
3824       cpi->un_scaled_source->y_height == cm->height << 2 &&
3825       svc->scaled_temp.y_width == cm->width << 1 &&
3826       svc->scaled_temp.y_height == cm->height << 1) {
3827     // For svc, if it is a 1/4x1/4 downscaling, do a two-stage scaling to take
3828     // advantage of the 1:2 optimized scaler. In the process, the 1/2x1/2
3829     // result will be saved in scaled_temp and might be used later.
3830     const INTERP_FILTER filter_scaler2 = svc->downsample_filter_type[1];
3831     const int phase_scaler2 = svc->downsample_filter_phase[1];
3832     cpi->Source = vp9_svc_twostage_scale(
3833         cm, cpi->un_scaled_source, &cpi->scaled_source, &svc->scaled_temp,
3834         filter_scaler, phase_scaler, filter_scaler2, phase_scaler2);
3835     svc->scaled_one_half = 1;
3836   } else if (is_one_pass_cbr_svc(cpi) &&
3837              cpi->un_scaled_source->y_width == cm->width << 1 &&
3838              cpi->un_scaled_source->y_height == cm->height << 1 &&
3839              svc->scaled_one_half) {
3840     // If the spatial layer is 1/2x1/2 and the scaling is already done in the
3841     // two-stage scaling, use the result directly.
3842     cpi->Source = &svc->scaled_temp;
3843     svc->scaled_one_half = 0;
3844   } else {
3845     cpi->Source = vp9_scale_if_required(
3846         cm, cpi->un_scaled_source, &cpi->scaled_source, (cpi->oxcf.pass == 0),
3847         filter_scaler, phase_scaler);
3848   }
3849 #ifdef OUTPUT_YUV_SVC_SRC
3850   // Write out at most 3 spatial layers.
3851   if (is_one_pass_cbr_svc(cpi) && svc->spatial_layer_id < 3) {
3852     vpx_write_yuv_frame(yuv_svc_src[svc->spatial_layer_id], cpi->Source);
3853   }
3854 #endif
3855   // Unfiltered raw source used in metrics calculation if the source
3856   // has been filtered.
3857   if (is_psnr_calc_enabled(cpi)) {
3858 #ifdef ENABLE_KF_DENOISE
3859     if (is_spatial_denoise_enabled(cpi)) {
3860       cpi->raw_source_frame = vp9_scale_if_required(
3861           cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
3862           (cpi->oxcf.pass == 0), EIGHTTAP, phase_scaler);
3863     } else {
3864       cpi->raw_source_frame = cpi->Source;
3865     }
3866 #else
3867     cpi->raw_source_frame = cpi->Source;
3868 #endif
3869   }
3870
3871   if ((cpi->use_svc &&
3872        (svc->spatial_layer_id < svc->number_spatial_layers - 1 ||
3873         svc->temporal_layer_id < svc->number_temporal_layers - 1 ||
3874         svc->current_superframe < 1)) ||
3875       cpi->resize_pending || cpi->resize_state || cpi->external_resize ||
3876       cpi->resize_state != ORIG) {
3877     cpi->compute_source_sad_onepass = 0;
3878     if (cpi->content_state_sb_fd != NULL)
3879       memset(cpi->content_state_sb_fd, 0,
3880              (cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1) *
3881                  sizeof(*cpi->content_state_sb_fd));
3882   }
3883
3884   // Avoid scaling last_source unless its needed.
3885   // Last source is needed if avg_source_sad() is used, or if
3886   // partition_search_type == SOURCE_VAR_BASED_PARTITION, or if noise
3887   // estimation is enabled.
3888   if (cpi->unscaled_last_source != NULL &&
3889       (cpi->oxcf.content == VP9E_CONTENT_SCREEN ||
3890        (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_VBR &&
3891         cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5) ||
3892        cpi->sf.partition_search_type == SOURCE_VAR_BASED_PARTITION ||
3893        (cpi->noise_estimate.enabled && !cpi->oxcf.noise_sensitivity) ||
3894        cpi->compute_source_sad_onepass))
3895     cpi->Last_Source = vp9_scale_if_required(
3896         cm, cpi->unscaled_last_source, &cpi->scaled_last_source,
3897         (cpi->oxcf.pass == 0), EIGHTTAP, 0);
3898
3899   if (cpi->Last_Source == NULL ||
3900       cpi->Last_Source->y_width != cpi->Source->y_width ||
3901       cpi->Last_Source->y_height != cpi->Source->y_height)
3902     cpi->compute_source_sad_onepass = 0;
3903
3904   if (frame_is_intra_only(cm) || cpi->resize_pending != 0) {
3905     memset(cpi->consec_zero_mv, 0,
3906            cm->mi_rows * cm->mi_cols * sizeof(*cpi->consec_zero_mv));
3907   }
3908
3909 #if CONFIG_VP9_TEMPORAL_DENOISING
3910   if (cpi->oxcf.noise_sensitivity > 0 && cpi->use_svc)
3911     vp9_denoiser_reset_on_first_frame(cpi);
3912 #endif
3913
3914   // Scene detection is always used for VBR mode or screen-content case.
3915   // For other cases (e.g., CBR mode) use it for 5 <= speed < 8 for now
3916   // (need to check encoding time cost for doing this for speed 8).
3917   cpi->rc.high_source_sad = 0;
3918   cpi->rc.hybrid_intra_scene_change = 0;
3919   cpi->rc.re_encode_maxq_scene_change = 0;
3920   if (cm->show_frame && cpi->oxcf.mode == REALTIME &&
3921       (cpi->oxcf.rc_mode == VPX_VBR ||
3922        cpi->oxcf.content == VP9E_CONTENT_SCREEN ||
3923        (cpi->oxcf.speed >= 5 && cpi->oxcf.speed < 8)))
3924     vp9_scene_detection_onepass(cpi);
3925
3926   if (svc->spatial_layer_id == svc->first_spatial_layer_to_encode) {
3927     svc->high_source_sad_superframe = cpi->rc.high_source_sad;
3928     svc->high_num_blocks_with_motion = cpi->rc.high_num_blocks_with_motion;
3929     // On scene change reset temporal layer pattern to TL0.
3930     // Note that if the base/lower spatial layers are skipped: instead of
3931     // inserting base layer here, we force max-q for the next superframe
3932     // with lower spatial layers: this is done in vp9_encodedframe_overshoot()
3933     // when max-q is decided for the current layer.
3934     // Only do this reset for bypass/flexible mode.
3935     if (svc->high_source_sad_superframe && svc->temporal_layer_id > 0 &&
3936         svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS) {
3937       // rc->high_source_sad will get reset so copy it to restore it.
3938       int tmp_high_source_sad = cpi->rc.high_source_sad;
3939       vp9_svc_reset_temporal_layers(cpi, cm->frame_type == KEY_FRAME);
3940       cpi->rc.high_source_sad = tmp_high_source_sad;
3941     }
3942   }
3943
3944   vp9_update_noise_estimate(cpi);
3945
3946   // For 1 pass CBR, check if we are dropping this frame.
3947   // Never drop on key frame, if base layer is key for svc,
3948   // on scene change, or if superframe has layer sync.
3949   if ((cpi->rc.high_source_sad || svc->high_source_sad_superframe) &&
3950       !(cpi->rc.use_post_encode_drop && svc->last_layer_dropped[0]))
3951     no_drop_scene_change = 1;
3952   if (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_CBR &&
3953       !frame_is_intra_only(cm) && !no_drop_scene_change &&
3954       !svc->superframe_has_layer_sync &&
3955       (!cpi->use_svc ||
3956        !svc->layer_context[svc->temporal_layer_id].is_key_frame)) {
3957     if (vp9_rc_drop_frame(cpi)) return 0;
3958   }
3959
3960   // For 1 pass CBR SVC, only ZEROMV is allowed for spatial reference frame
3961   // when svc->force_zero_mode_spatial_ref = 1. Under those conditions we can
3962   // avoid this frame-level upsampling (for non intra_only frames).
3963   if (frame_is_intra_only(cm) == 0 &&
3964       !(is_one_pass_cbr_svc(cpi) && svc->force_zero_mode_spatial_ref)) {
3965     vp9_scale_references(cpi);
3966   }
3967
3968   set_size_independent_vars(cpi);
3969   set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
3970
3971   // search method and step parameter might be changed in speed settings.
3972   init_motion_estimation(cpi);
3973
3974   if (cpi->sf.copy_partition_flag) alloc_copy_partition_data(cpi);
3975
3976   if (cpi->sf.svc_use_lowres_part &&
3977       svc->spatial_layer_id == svc->number_spatial_layers - 2) {
3978     if (svc->prev_partition_svc == NULL) {
3979       CHECK_MEM_ERROR(
3980           cm, svc->prev_partition_svc,
3981           (BLOCK_SIZE *)vpx_calloc(cm->mi_stride * cm->mi_rows,
3982                                    sizeof(*svc->prev_partition_svc)));
3983     }
3984   }
3985
3986   // TODO(jianj): Look into issue of skin detection with high bitdepth.
3987   if (cm->bit_depth == 8 && cpi->oxcf.speed >= 5 && cpi->oxcf.pass == 0 &&
3988       cpi->oxcf.rc_mode == VPX_CBR &&
3989       cpi->oxcf.content != VP9E_CONTENT_SCREEN &&
3990       cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
3991     cpi->use_skin_detection = 1;
3992   }
3993
3994   // Enable post encode frame dropping for CBR on non key frame, when
3995   // ext_use_post_encode_drop is specified by user.
3996   cpi->rc.use_post_encode_drop = cpi->rc.ext_use_post_encode_drop &&
3997                                  cpi->oxcf.rc_mode == VPX_CBR &&
3998                                  cm->frame_type != KEY_FRAME;
3999
4000   vp9_set_quantizer(cm, q);
4001   vp9_set_variance_partition_thresholds(cpi, q, 0);
4002
4003   setup_frame(cpi);
4004
4005   suppress_active_map(cpi);
4006
4007   if (cpi->use_svc) {
4008     // On non-zero spatial layer, check for disabling inter-layer
4009     // prediction.
4010     if (svc->spatial_layer_id > 0) vp9_svc_constrain_inter_layer_pred(cpi);
4011     vp9_svc_assert_constraints_pattern(cpi);
4012   }
4013
4014   if (cpi->rc.last_post_encode_dropped_scene_change) {
4015     cpi->rc.high_source_sad = 1;
4016     svc->high_source_sad_superframe = 1;
4017     // For now disable use_source_sad since Last_Source will not be the previous
4018     // encoded but the dropped one.
4019     cpi->sf.use_source_sad = 0;
4020     cpi->rc.last_post_encode_dropped_scene_change = 0;
4021   }
4022   // Check if this high_source_sad (scene/slide change) frame should be
4023   // encoded at high/max QP, and if so, set the q and adjust some rate
4024   // control parameters.
4025   if (cpi->sf.overshoot_detection_cbr_rt == FAST_DETECTION_MAXQ &&
4026       (cpi->rc.high_source_sad ||
4027        (cpi->use_svc && svc->high_source_sad_superframe))) {
4028     if (vp9_encodedframe_overshoot(cpi, -1, &q)) {
4029       vp9_set_quantizer(cm, q);
4030       vp9_set_variance_partition_thresholds(cpi, q, 0);
4031     }
4032   }
4033
4034 #if !CONFIG_REALTIME_ONLY
4035   // Variance adaptive and in frame q adjustment experiments are mutually
4036   // exclusive.
4037   if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
4038     vp9_vaq_frame_setup(cpi);
4039   } else if (cpi->oxcf.aq_mode == EQUATOR360_AQ) {
4040     vp9_360aq_frame_setup(cpi);
4041   } else if (cpi->oxcf.aq_mode == COMPLEXITY_AQ) {
4042     vp9_setup_in_frame_q_adj(cpi);
4043   } else if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ) {
4044     // it may be pretty bad for rate-control,
4045     // and I should handle it somehow
4046     vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi);
4047   } else {
4048 #endif
4049     if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4050       vp9_cyclic_refresh_setup(cpi);
4051     } else if (cpi->roi.enabled && !frame_is_intra_only(cm)) {
4052       apply_roi_map(cpi);
4053     }
4054 #if !CONFIG_REALTIME_ONLY
4055   }
4056 #endif
4057
4058   apply_active_map(cpi);
4059
4060   vp9_encode_frame(cpi);
4061
4062   // Check if we should re-encode this frame at high Q because of high
4063   // overshoot based on the encoded frame size. Only for frames where
4064   // high temporal-source SAD is detected.
4065   // For SVC: all spatial layers are checked for re-encoding.
4066   if (cpi->sf.overshoot_detection_cbr_rt == RE_ENCODE_MAXQ &&
4067       (cpi->rc.high_source_sad ||
4068        (cpi->use_svc && svc->high_source_sad_superframe))) {
4069     int frame_size = 0;
4070     // Get an estimate of the encoded frame size.
4071     save_coding_context(cpi);
4072     vp9_pack_bitstream(cpi, dest, size);
4073     restore_coding_context(cpi);
4074     frame_size = (int)(*size) << 3;
4075     // Check if encoded frame will overshoot too much, and if so, set the q and
4076     // adjust some rate control parameters, and return to re-encode the frame.
4077     if (vp9_encodedframe_overshoot(cpi, frame_size, &q)) {
4078       vpx_clear_system_state();
4079       vp9_set_quantizer(cm, q);
4080       vp9_set_variance_partition_thresholds(cpi, q, 0);
4081       suppress_active_map(cpi);
4082       // Turn-off cyclic refresh for re-encoded frame.
4083       if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4084         CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
4085         unsigned char *const seg_map = cpi->segmentation_map;
4086         memset(seg_map, 0, cm->mi_rows * cm->mi_cols);
4087         memset(cr->last_coded_q_map, MAXQ,
4088                cm->mi_rows * cm->mi_cols * sizeof(*cr->last_coded_q_map));
4089         cr->sb_index = 0;
4090         vp9_disable_segmentation(&cm->seg);
4091       }
4092       apply_active_map(cpi);
4093       vp9_encode_frame(cpi);
4094     }
4095   }
4096
4097   // Update some stats from cyclic refresh, and check for golden frame update.
4098   if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && cm->seg.enabled &&
4099       !frame_is_intra_only(cm))
4100     vp9_cyclic_refresh_postencode(cpi);
4101
4102   // Update the skip mb flag probabilities based on the distribution
4103   // seen in the last encoder iteration.
4104   // update_base_skip_probs(cpi);
4105   vpx_clear_system_state();
4106   return 1;
4107 }
4108
4109 #if !CONFIG_REALTIME_ONLY
4110 #define MAX_QSTEP_ADJ 4
4111 static int get_qstep_adj(int rate_excess, int rate_limit) {
4112   int qstep =
4113       rate_limit ? ((rate_excess + rate_limit / 2) / rate_limit) : INT_MAX;
4114   return VPXMIN(qstep, MAX_QSTEP_ADJ);
4115 }
4116
4117 static void encode_with_recode_loop(VP9_COMP *cpi, size_t *size,
4118                                     uint8_t *dest) {
4119   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4120   VP9_COMMON *const cm = &cpi->common;
4121   RATE_CONTROL *const rc = &cpi->rc;
4122   int bottom_index, top_index;
4123   int loop_count = 0;
4124   int loop_at_this_size = 0;
4125   int loop = 0;
4126   int overshoot_seen = 0;
4127   int undershoot_seen = 0;
4128   int frame_over_shoot_limit;
4129   int frame_under_shoot_limit;
4130   int q = 0, q_low = 0, q_high = 0;
4131   int enable_acl;
4132 #ifdef AGGRESSIVE_VBR
4133   int qrange_adj = 1;
4134 #endif
4135
4136   if (cm->show_existing_frame) {
4137     rc->this_frame_target = 0;
4138     if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi);
4139     return;
4140   }
4141
4142   set_size_independent_vars(cpi);
4143
4144   enable_acl = cpi->sf.allow_acl ? (cm->frame_type == KEY_FRAME) ||
4145                                        (cpi->twopass.gf_group.index == 1)
4146                                  : 0;
4147
4148   do {
4149     vpx_clear_system_state();
4150
4151     set_frame_size(cpi);
4152
4153     if (loop_count == 0 || cpi->resize_pending != 0) {
4154       set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
4155
4156 #ifdef AGGRESSIVE_VBR
4157       if (two_pass_first_group_inter(cpi)) {
4158         // Adjustment limits for min and max q
4159         qrange_adj = VPXMAX(1, (top_index - bottom_index) / 2);
4160
4161         bottom_index =
4162             VPXMAX(bottom_index - qrange_adj / 2, oxcf->best_allowed_q);
4163         top_index = VPXMIN(oxcf->worst_allowed_q, top_index + qrange_adj / 2);
4164       }
4165 #endif
4166       // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed.
4167       set_mv_search_params(cpi);
4168
4169       // Reset the loop state for new frame size.
4170       overshoot_seen = 0;
4171       undershoot_seen = 0;
4172
4173       // Reconfiguration for change in frame size has concluded.
4174       cpi->resize_pending = 0;
4175
4176       q_low = bottom_index;
4177       q_high = top_index;
4178
4179       loop_at_this_size = 0;
4180     }
4181
4182     // Decide frame size bounds first time through.
4183     if (loop_count == 0) {
4184       vp9_rc_compute_frame_size_bounds(cpi, rc->this_frame_target,
4185                                        &frame_under_shoot_limit,
4186                                        &frame_over_shoot_limit);
4187     }
4188
4189     cpi->Source =
4190         vp9_scale_if_required(cm, cpi->un_scaled_source, &cpi->scaled_source,
4191                               (oxcf->pass == 0), EIGHTTAP, 0);
4192
4193     // Unfiltered raw source used in metrics calculation if the source
4194     // has been filtered.
4195     if (is_psnr_calc_enabled(cpi)) {
4196 #ifdef ENABLE_KF_DENOISE
4197       if (is_spatial_denoise_enabled(cpi)) {
4198         cpi->raw_source_frame = vp9_scale_if_required(
4199             cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
4200             (oxcf->pass == 0), EIGHTTAP, 0);
4201       } else {
4202         cpi->raw_source_frame = cpi->Source;
4203       }
4204 #else
4205       cpi->raw_source_frame = cpi->Source;
4206 #endif
4207     }
4208
4209     if (cpi->unscaled_last_source != NULL)
4210       cpi->Last_Source = vp9_scale_if_required(cm, cpi->unscaled_last_source,
4211                                                &cpi->scaled_last_source,
4212                                                (oxcf->pass == 0), EIGHTTAP, 0);
4213
4214     if (frame_is_intra_only(cm) == 0) {
4215       if (loop_count > 0) {
4216         release_scaled_references(cpi);
4217       }
4218       vp9_scale_references(cpi);
4219     }
4220
4221     vp9_set_quantizer(cm, q);
4222
4223     if (loop_count == 0) setup_frame(cpi);
4224
4225     // Variance adaptive and in frame q adjustment experiments are mutually
4226     // exclusive.
4227     if (oxcf->aq_mode == VARIANCE_AQ) {
4228       vp9_vaq_frame_setup(cpi);
4229     } else if (oxcf->aq_mode == EQUATOR360_AQ) {
4230       vp9_360aq_frame_setup(cpi);
4231     } else if (oxcf->aq_mode == COMPLEXITY_AQ) {
4232       vp9_setup_in_frame_q_adj(cpi);
4233     } else if (oxcf->aq_mode == LOOKAHEAD_AQ) {
4234       vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi);
4235     } else if (oxcf->aq_mode == PSNR_AQ) {
4236       vp9_psnr_aq_mode_setup(&cm->seg);
4237     }
4238
4239     vp9_encode_frame(cpi);
4240
4241     // Update the skip mb flag probabilities based on the distribution
4242     // seen in the last encoder iteration.
4243     // update_base_skip_probs(cpi);
4244
4245     vpx_clear_system_state();
4246
4247     // Dummy pack of the bitstream using up to date stats to get an
4248     // accurate estimate of output frame size to determine if we need
4249     // to recode.
4250     if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF) {
4251       save_coding_context(cpi);
4252       if (!cpi->sf.use_nonrd_pick_mode) vp9_pack_bitstream(cpi, dest, size);
4253
4254       rc->projected_frame_size = (int)(*size) << 3;
4255
4256       if (frame_over_shoot_limit == 0) frame_over_shoot_limit = 1;
4257     }
4258
4259     if (oxcf->rc_mode == VPX_Q) {
4260       loop = 0;
4261     } else {
4262       if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced &&
4263           (rc->projected_frame_size < rc->max_frame_bandwidth)) {
4264         int last_q = q;
4265         int64_t kf_err;
4266
4267         int64_t high_err_target = cpi->ambient_err;
4268         int64_t low_err_target = cpi->ambient_err >> 1;
4269
4270 #if CONFIG_VP9_HIGHBITDEPTH
4271         if (cm->use_highbitdepth) {
4272           kf_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4273         } else {
4274           kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4275         }
4276 #else
4277         kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4278 #endif  // CONFIG_VP9_HIGHBITDEPTH
4279
4280         // Prevent possible divide by zero error below for perfect KF
4281         kf_err += !kf_err;
4282
4283         // The key frame is not good enough or we can afford
4284         // to make it better without undue risk of popping.
4285         if ((kf_err > high_err_target &&
4286              rc->projected_frame_size <= frame_over_shoot_limit) ||
4287             (kf_err > low_err_target &&
4288              rc->projected_frame_size <= frame_under_shoot_limit)) {
4289           // Lower q_high
4290           q_high = q > q_low ? q - 1 : q_low;
4291
4292           // Adjust Q
4293           q = (int)((q * high_err_target) / kf_err);
4294           q = VPXMIN(q, (q_high + q_low) >> 1);
4295         } else if (kf_err < low_err_target &&
4296                    rc->projected_frame_size >= frame_under_shoot_limit) {
4297           // The key frame is much better than the previous frame
4298           // Raise q_low
4299           q_low = q < q_high ? q + 1 : q_high;
4300
4301           // Adjust Q
4302           q = (int)((q * low_err_target) / kf_err);
4303           q = VPXMIN(q, (q_high + q_low + 1) >> 1);
4304         }
4305
4306         // Clamp Q to upper and lower limits:
4307         q = clamp(q, q_low, q_high);
4308
4309         loop = q != last_q;
4310       } else if (recode_loop_test(cpi, frame_over_shoot_limit,
4311                                   frame_under_shoot_limit, q,
4312                                   VPXMAX(q_high, top_index), bottom_index)) {
4313         // Is the projected frame size out of range and are we allowed
4314         // to attempt to recode.
4315         int last_q = q;
4316         int retries = 0;
4317         int qstep;
4318
4319         if (cpi->resize_pending == 1) {
4320           // Change in frame size so go back around the recode loop.
4321           cpi->rc.frame_size_selector =
4322               SCALE_STEP1 - cpi->rc.frame_size_selector;
4323           cpi->rc.next_frame_size_selector = cpi->rc.frame_size_selector;
4324
4325 #if CONFIG_INTERNAL_STATS
4326           ++cpi->tot_recode_hits;
4327 #endif
4328           ++loop_count;
4329           loop = 1;
4330           continue;
4331         }
4332
4333         // Frame size out of permitted range:
4334         // Update correction factor & compute new Q to try...
4335
4336         // Frame is too large
4337         if (rc->projected_frame_size > rc->this_frame_target) {
4338           // Special case if the projected size is > the max allowed.
4339           if ((q == q_high) &&
4340               ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
4341                (!rc->is_src_frame_alt_ref &&
4342                 (rc->projected_frame_size >=
4343                  big_rate_miss_high_threshold(cpi))))) {
4344             int max_rate = VPXMAX(1, VPXMIN(rc->max_frame_bandwidth,
4345                                             big_rate_miss_high_threshold(cpi)));
4346             double q_val_high;
4347             q_val_high = vp9_convert_qindex_to_q(q_high, cm->bit_depth);
4348             q_val_high =
4349                 q_val_high * ((double)rc->projected_frame_size / max_rate);
4350             q_high = vp9_convert_q_to_qindex(q_val_high, cm->bit_depth);
4351             q_high = clamp(q_high, rc->best_quality, rc->worst_quality);
4352           }
4353
4354           // Raise Qlow as to at least the current value
4355           qstep =
4356               get_qstep_adj(rc->projected_frame_size, rc->this_frame_target);
4357           q_low = VPXMIN(q + qstep, q_high);
4358
4359           if (undershoot_seen || loop_at_this_size > 1) {
4360             // Update rate_correction_factor unless
4361             vp9_rc_update_rate_correction_factors(cpi);
4362
4363             q = (q_high + q_low + 1) / 2;
4364           } else {
4365             // Update rate_correction_factor unless
4366             vp9_rc_update_rate_correction_factors(cpi);
4367
4368             q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4369                                   VPXMAX(q_high, top_index));
4370
4371             while (q < q_low && retries < 10) {
4372               vp9_rc_update_rate_correction_factors(cpi);
4373               q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4374                                     VPXMAX(q_high, top_index));
4375               retries++;
4376             }
4377           }
4378
4379           overshoot_seen = 1;
4380         } else {
4381           // Frame is too small
4382           qstep =
4383               get_qstep_adj(rc->this_frame_target, rc->projected_frame_size);
4384           q_high = VPXMAX(q - qstep, q_low);
4385
4386           if (overshoot_seen || loop_at_this_size > 1) {
4387             vp9_rc_update_rate_correction_factors(cpi);
4388             q = (q_high + q_low) / 2;
4389           } else {
4390             vp9_rc_update_rate_correction_factors(cpi);
4391             q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
4392                                   VPXMIN(q_low, bottom_index), top_index);
4393             // Special case reset for qlow for constrained quality.
4394             // This should only trigger where there is very substantial
4395             // undershoot on a frame and the auto cq level is above
4396             // the user passsed in value.
4397             if (oxcf->rc_mode == VPX_CQ && q < q_low) {
4398               q_low = q;
4399             }
4400
4401             while (q > q_high && retries < 10) {
4402               vp9_rc_update_rate_correction_factors(cpi);
4403               q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
4404                                     VPXMIN(q_low, bottom_index), top_index);
4405               retries++;
4406             }
4407           }
4408           undershoot_seen = 1;
4409         }
4410
4411         // Clamp Q to upper and lower limits:
4412         q = clamp(q, q_low, q_high);
4413
4414         loop = (q != last_q);
4415       } else {
4416         loop = 0;
4417       }
4418     }
4419
4420     // Special case for overlay frame.
4421     if (rc->is_src_frame_alt_ref &&
4422         rc->projected_frame_size < rc->max_frame_bandwidth)
4423       loop = 0;
4424
4425     if (loop) {
4426       ++loop_count;
4427       ++loop_at_this_size;
4428
4429 #if CONFIG_INTERNAL_STATS
4430       ++cpi->tot_recode_hits;
4431 #endif
4432     }
4433
4434     if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF)
4435       if (loop || !enable_acl) restore_coding_context(cpi);
4436   } while (loop);
4437
4438 #ifdef AGGRESSIVE_VBR
4439   if (two_pass_first_group_inter(cpi)) {
4440     cpi->twopass.active_worst_quality =
4441         VPXMIN(q + qrange_adj, oxcf->worst_allowed_q);
4442   } else if (!frame_is_kf_gf_arf(cpi)) {
4443 #else
4444   if (!frame_is_kf_gf_arf(cpi)) {
4445 #endif
4446     // Have we been forced to adapt Q outside the expected range by an extreme
4447     // rate miss. If so adjust the active maxQ for the subsequent frames.
4448     if (!rc->is_src_frame_alt_ref && (q > cpi->twopass.active_worst_quality)) {
4449       cpi->twopass.active_worst_quality = q;
4450     } else if (oxcf->vbr_corpus_complexity && q == q_low &&
4451                rc->projected_frame_size < rc->this_frame_target) {
4452       cpi->twopass.active_worst_quality =
4453           VPXMAX(q, cpi->twopass.active_worst_quality - 1);
4454     }
4455   }
4456
4457   if (enable_acl) {
4458     // Skip recoding, if model diff is below threshold
4459     const int thresh = compute_context_model_thresh(cpi);
4460     const int diff = compute_context_model_diff(cm);
4461     if (diff < thresh) {
4462       vpx_clear_system_state();
4463       restore_coding_context(cpi);
4464       return;
4465     }
4466
4467     vp9_encode_frame(cpi);
4468     vpx_clear_system_state();
4469     restore_coding_context(cpi);
4470   }
4471 }
4472 #endif  // !CONFIG_REALTIME_ONLY
4473
4474 static int get_ref_frame_flags(const VP9_COMP *cpi) {
4475   const int *const map = cpi->common.ref_frame_map;
4476   const int gold_is_last = map[cpi->gld_fb_idx] == map[cpi->lst_fb_idx];
4477   const int alt_is_last = map[cpi->alt_fb_idx] == map[cpi->lst_fb_idx];
4478   const int gold_is_alt = map[cpi->gld_fb_idx] == map[cpi->alt_fb_idx];
4479   int flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
4480
4481   if (gold_is_last) flags &= ~VP9_GOLD_FLAG;
4482
4483   if (cpi->rc.frames_till_gf_update_due == INT_MAX &&
4484       (cpi->svc.number_temporal_layers == 1 &&
4485        cpi->svc.number_spatial_layers == 1))
4486     flags &= ~VP9_GOLD_FLAG;
4487
4488   if (alt_is_last) flags &= ~VP9_ALT_FLAG;
4489
4490   if (gold_is_alt) flags &= ~VP9_ALT_FLAG;
4491
4492   return flags;
4493 }
4494
4495 static void set_ext_overrides(VP9_COMP *cpi) {
4496   // Overrides the defaults with the externally supplied values with
4497   // vp9_update_reference() and vp9_update_entropy() calls
4498   // Note: The overrides are valid only for the next frame passed
4499   // to encode_frame_to_data_rate() function
4500   if (cpi->ext_refresh_frame_context_pending) {
4501     cpi->common.refresh_frame_context = cpi->ext_refresh_frame_context;
4502     cpi->ext_refresh_frame_context_pending = 0;
4503   }
4504   if (cpi->ext_refresh_frame_flags_pending) {
4505     cpi->refresh_last_frame = cpi->ext_refresh_last_frame;
4506     cpi->refresh_golden_frame = cpi->ext_refresh_golden_frame;
4507     cpi->refresh_alt_ref_frame = cpi->ext_refresh_alt_ref_frame;
4508   }
4509 }
4510
4511 YV12_BUFFER_CONFIG *vp9_svc_twostage_scale(
4512     VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled,
4513     YV12_BUFFER_CONFIG *scaled_temp, INTERP_FILTER filter_type,
4514     int phase_scaler, INTERP_FILTER filter_type2, int phase_scaler2) {
4515   if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
4516       cm->mi_rows * MI_SIZE != unscaled->y_height) {
4517 #if CONFIG_VP9_HIGHBITDEPTH
4518     if (cm->bit_depth == VPX_BITS_8) {
4519       vp9_scale_and_extend_frame(unscaled, scaled_temp, filter_type2,
4520                                  phase_scaler2);
4521       vp9_scale_and_extend_frame(scaled_temp, scaled, filter_type,
4522                                  phase_scaler);
4523     } else {
4524       scale_and_extend_frame(unscaled, scaled_temp, (int)cm->bit_depth,
4525                              filter_type2, phase_scaler2);
4526       scale_and_extend_frame(scaled_temp, scaled, (int)cm->bit_depth,
4527                              filter_type, phase_scaler);
4528     }
4529 #else
4530     vp9_scale_and_extend_frame(unscaled, scaled_temp, filter_type2,
4531                                phase_scaler2);
4532     vp9_scale_and_extend_frame(scaled_temp, scaled, filter_type, phase_scaler);
4533 #endif  // CONFIG_VP9_HIGHBITDEPTH
4534     return scaled;
4535   } else {
4536     return unscaled;
4537   }
4538 }
4539
4540 YV12_BUFFER_CONFIG *vp9_scale_if_required(
4541     VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled,
4542     int use_normative_scaler, INTERP_FILTER filter_type, int phase_scaler) {
4543   if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
4544       cm->mi_rows * MI_SIZE != unscaled->y_height) {
4545 #if CONFIG_VP9_HIGHBITDEPTH
4546     if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) &&
4547         unscaled->y_height <= (scaled->y_height << 1))
4548       if (cm->bit_depth == VPX_BITS_8)
4549         vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler);
4550       else
4551         scale_and_extend_frame(unscaled, scaled, (int)cm->bit_depth,
4552                                filter_type, phase_scaler);
4553     else
4554       scale_and_extend_frame_nonnormative(unscaled, scaled, (int)cm->bit_depth);
4555 #else
4556     if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) &&
4557         unscaled->y_height <= (scaled->y_height << 1))
4558       vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler);
4559     else
4560       scale_and_extend_frame_nonnormative(unscaled, scaled);
4561 #endif  // CONFIG_VP9_HIGHBITDEPTH
4562     return scaled;
4563   } else {
4564     return unscaled;
4565   }
4566 }
4567
4568 static void set_ref_sign_bias(VP9_COMP *cpi) {
4569   VP9_COMMON *const cm = &cpi->common;
4570   RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx);
4571   const int cur_frame_index = ref_buffer->frame_index;
4572   MV_REFERENCE_FRAME ref_frame;
4573
4574   for (ref_frame = LAST_FRAME; ref_frame < MAX_REF_FRAMES; ++ref_frame) {
4575     const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
4576     const RefCntBuffer *const ref_cnt_buf =
4577         get_ref_cnt_buffer(&cpi->common, buf_idx);
4578     if (ref_cnt_buf) {
4579       cm->ref_frame_sign_bias[ref_frame] =
4580           cur_frame_index < ref_cnt_buf->frame_index;
4581     }
4582   }
4583 }
4584
4585 static int setup_interp_filter_search_mask(VP9_COMP *cpi) {
4586   INTERP_FILTER ifilter;
4587   int ref_total[MAX_REF_FRAMES] = { 0 };
4588   MV_REFERENCE_FRAME ref;
4589   int mask = 0;
4590   if (cpi->common.last_frame_type == KEY_FRAME || cpi->refresh_alt_ref_frame)
4591     return mask;
4592   for (ref = LAST_FRAME; ref <= ALTREF_FRAME; ++ref)
4593     for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter)
4594       ref_total[ref] += cpi->interp_filter_selected[ref][ifilter];
4595
4596   for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter) {
4597     if ((ref_total[LAST_FRAME] &&
4598          cpi->interp_filter_selected[LAST_FRAME][ifilter] == 0) &&
4599         (ref_total[GOLDEN_FRAME] == 0 ||
4600          cpi->interp_filter_selected[GOLDEN_FRAME][ifilter] * 50 <
4601              ref_total[GOLDEN_FRAME]) &&
4602         (ref_total[ALTREF_FRAME] == 0 ||
4603          cpi->interp_filter_selected[ALTREF_FRAME][ifilter] * 50 <
4604              ref_total[ALTREF_FRAME]))
4605       mask |= 1 << ifilter;
4606   }
4607   return mask;
4608 }
4609
4610 #ifdef ENABLE_KF_DENOISE
4611 // Baseline Kernal weights for denoise
4612 static uint8_t dn_kernal_3[9] = { 1, 2, 1, 2, 4, 2, 1, 2, 1 };
4613 static uint8_t dn_kernal_5[25] = { 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 4,
4614                                    2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1 };
4615
4616 static INLINE void add_denoise_point(int centre_val, int data_val, int thresh,
4617                                      uint8_t point_weight, int *sum_val,
4618                                      int *sum_weight) {
4619   if (abs(centre_val - data_val) <= thresh) {
4620     *sum_weight += point_weight;
4621     *sum_val += (int)data_val * (int)point_weight;
4622   }
4623 }
4624
4625 static void spatial_denoise_point(uint8_t *src_ptr, const int stride,
4626                                   const int strength) {
4627   int sum_weight = 0;
4628   int sum_val = 0;
4629   int thresh = strength;
4630   int kernal_size = 5;
4631   int half_k_size = 2;
4632   int i, j;
4633   int max_diff = 0;
4634   uint8_t *tmp_ptr;
4635   uint8_t *kernal_ptr;
4636
4637   // Find the maximum deviation from the source point in the locale.
4638   tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1);
4639   for (i = 0; i < kernal_size + 2; ++i) {
4640     for (j = 0; j < kernal_size + 2; ++j) {
4641       max_diff = VPXMAX(max_diff, abs((int)*src_ptr - (int)tmp_ptr[j]));
4642     }
4643     tmp_ptr += stride;
4644   }
4645
4646   // Select the kernal size.
4647   if (max_diff > (strength + (strength >> 1))) {
4648     kernal_size = 3;
4649     half_k_size = 1;
4650     thresh = thresh >> 1;
4651   }
4652   kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5;
4653
4654   // Apply the kernal
4655   tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size;
4656   for (i = 0; i < kernal_size; ++i) {
4657     for (j = 0; j < kernal_size; ++j) {
4658       add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr,
4659                         &sum_val, &sum_weight);
4660       ++kernal_ptr;
4661     }
4662     tmp_ptr += stride;
4663   }
4664
4665   // Update the source value with the new filtered value
4666   *src_ptr = (uint8_t)((sum_val + (sum_weight >> 1)) / sum_weight);
4667 }
4668
4669 #if CONFIG_VP9_HIGHBITDEPTH
4670 static void highbd_spatial_denoise_point(uint16_t *src_ptr, const int stride,
4671                                          const int strength) {
4672   int sum_weight = 0;
4673   int sum_val = 0;
4674   int thresh = strength;
4675   int kernal_size = 5;
4676   int half_k_size = 2;
4677   int i, j;
4678   int max_diff = 0;
4679   uint16_t *tmp_ptr;
4680   uint8_t *kernal_ptr;
4681
4682   // Find the maximum deviation from the source point in the locale.
4683   tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1);
4684   for (i = 0; i < kernal_size + 2; ++i) {
4685     for (j = 0; j < kernal_size + 2; ++j) {
4686       max_diff = VPXMAX(max_diff, abs((int)src_ptr - (int)tmp_ptr[j]));
4687     }
4688     tmp_ptr += stride;
4689   }
4690
4691   // Select the kernal size.
4692   if (max_diff > (strength + (strength >> 1))) {
4693     kernal_size = 3;
4694     half_k_size = 1;
4695     thresh = thresh >> 1;
4696   }
4697   kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5;
4698
4699   // Apply the kernal
4700   tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size;
4701   for (i = 0; i < kernal_size; ++i) {
4702     for (j = 0; j < kernal_size; ++j) {
4703       add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr,
4704                         &sum_val, &sum_weight);
4705       ++kernal_ptr;
4706     }
4707     tmp_ptr += stride;
4708   }
4709
4710   // Update the source value with the new filtered value
4711   *src_ptr = (uint16_t)((sum_val + (sum_weight >> 1)) / sum_weight);
4712 }
4713 #endif  // CONFIG_VP9_HIGHBITDEPTH
4714
4715 // Apply thresholded spatial noise supression to a given buffer.
4716 static void spatial_denoise_buffer(VP9_COMP *cpi, uint8_t *buffer,
4717                                    const int stride, const int width,
4718                                    const int height, const int strength) {
4719   VP9_COMMON *const cm = &cpi->common;
4720   uint8_t *src_ptr = buffer;
4721   int row;
4722   int col;
4723
4724   for (row = 0; row < height; ++row) {
4725     for (col = 0; col < width; ++col) {
4726 #if CONFIG_VP9_HIGHBITDEPTH
4727       if (cm->use_highbitdepth)
4728         highbd_spatial_denoise_point(CONVERT_TO_SHORTPTR(&src_ptr[col]), stride,
4729                                      strength);
4730       else
4731         spatial_denoise_point(&src_ptr[col], stride, strength);
4732 #else
4733       spatial_denoise_point(&src_ptr[col], stride, strength);
4734 #endif  // CONFIG_VP9_HIGHBITDEPTH
4735     }
4736     src_ptr += stride;
4737   }
4738 }
4739
4740 // Apply thresholded spatial noise supression to source.
4741 static void spatial_denoise_frame(VP9_COMP *cpi) {
4742   YV12_BUFFER_CONFIG *src = cpi->Source;
4743   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4744   TWO_PASS *const twopass = &cpi->twopass;
4745   VP9_COMMON *const cm = &cpi->common;
4746
4747   // Base the filter strength on the current active max Q.
4748   const int q = (int)(vp9_convert_qindex_to_q(twopass->active_worst_quality,
4749                                               cm->bit_depth));
4750   int strength =
4751       VPXMAX(oxcf->arnr_strength >> 2, VPXMIN(oxcf->arnr_strength, (q >> 4)));
4752
4753   // Denoise each of Y,U and V buffers.
4754   spatial_denoise_buffer(cpi, src->y_buffer, src->y_stride, src->y_width,
4755                          src->y_height, strength);
4756
4757   strength += (strength >> 1);
4758   spatial_denoise_buffer(cpi, src->u_buffer, src->uv_stride, src->uv_width,
4759                          src->uv_height, strength << 1);
4760
4761   spatial_denoise_buffer(cpi, src->v_buffer, src->uv_stride, src->uv_width,
4762                          src->uv_height, strength << 1);
4763 }
4764 #endif  // ENABLE_KF_DENOISE
4765
4766 #if !CONFIG_REALTIME_ONLY
4767 static void vp9_try_disable_lookahead_aq(VP9_COMP *cpi, size_t *size,
4768                                          uint8_t *dest) {
4769   if (cpi->common.seg.enabled)
4770     if (ALT_REF_AQ_PROTECT_GAIN) {
4771       size_t nsize = *size;
4772       int overhead;
4773
4774       // TODO(yuryg): optimize this, as
4775       // we don't really need to repack
4776
4777       save_coding_context(cpi);
4778       vp9_disable_segmentation(&cpi->common.seg);
4779       vp9_pack_bitstream(cpi, dest, &nsize);
4780       restore_coding_context(cpi);
4781
4782       overhead = (int)*size - (int)nsize;
4783
4784       if (vp9_alt_ref_aq_disable_if(cpi->alt_ref_aq, overhead, (int)*size))
4785         vp9_encode_frame(cpi);
4786       else
4787         vp9_enable_segmentation(&cpi->common.seg);
4788     }
4789 }
4790 #endif
4791
4792 static void set_frame_index(VP9_COMP *cpi, VP9_COMMON *cm) {
4793   RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx);
4794
4795   if (ref_buffer) {
4796     const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
4797     ref_buffer->frame_index =
4798         cm->current_video_frame + gf_group->arf_src_offset[gf_group->index];
4799   }
4800 }
4801
4802 // Implementation and modifications of C. Yeo, H. L. Tan, and Y. H. Tan, "On
4803 // rate distortion optimization using SSIM," Circuits and Systems for Video
4804 // Technology, IEEE Transactions on, vol. 23, no. 7, pp. 1170-1181, 2013.
4805 // SSIM_VAR_SCALE defines the strength of the bias towards SSIM in RDO.
4806 // Some sample values are:
4807 // (for midres test set)
4808 // SSIM_VAR_SCALE  avg_psnr   ssim   ms_ssim
4809 //      8.0          9.421   -5.537  -6.898
4810 //     16.0          4.703   -5.378  -6.238
4811 //     32.0          1.929   -4.308  -4.807
4812 #define SSIM_VAR_SCALE 16.0
4813 static void set_mb_ssim_rdmult_scaling(VP9_COMP *cpi) {
4814   VP9_COMMON *cm = &cpi->common;
4815   ThreadData *td = &cpi->td;
4816   MACROBLOCK *x = &td->mb;
4817   MACROBLOCKD *xd = &x->e_mbd;
4818   uint8_t *y_buffer = cpi->Source->y_buffer;
4819   const int y_stride = cpi->Source->y_stride;
4820   const int block_size = BLOCK_16X16;
4821
4822   const int num_8x8_w = num_8x8_blocks_wide_lookup[block_size];
4823   const int num_8x8_h = num_8x8_blocks_high_lookup[block_size];
4824   const int num_cols = (cm->mi_cols + num_8x8_w - 1) / num_8x8_w;
4825   const int num_rows = (cm->mi_rows + num_8x8_h - 1) / num_8x8_h;
4826   double log_sum = 0.0;
4827   int row, col;
4828
4829   const double c2 = 58.5225 * SSIM_VAR_SCALE;  // 58.5225 = (.03*255)^2
4830
4831   // Loop through each 64x64 block.
4832   for (row = 0; row < num_rows; ++row) {
4833     for (col = 0; col < num_cols; ++col) {
4834       int mi_row, mi_col;
4835       double var = 0.0, num_of_var = 0.0;
4836       const int index = row * num_cols + col;
4837
4838       for (mi_row = row * num_8x8_h;
4839            mi_row < cm->mi_rows && mi_row < (row + 1) * num_8x8_h; ++mi_row) {
4840         for (mi_col = col * num_8x8_w;
4841              mi_col < cm->mi_cols && mi_col < (col + 1) * num_8x8_w; ++mi_col) {
4842           struct buf_2d buf;
4843           const int row_offset_y = mi_row << 3;
4844           const int col_offset_y = mi_col << 3;
4845
4846           buf.buf = y_buffer + row_offset_y * y_stride + col_offset_y;
4847           buf.stride = y_stride;
4848
4849           // In order to make SSIM_VAR_SCALE in a same scale for both 8 bit
4850           // and high bit videos, the variance needs to be divided by 2.0 or
4851           // 64.0 separately.
4852           // TODO(sdeng): need to tune for 12bit videos.
4853 #if CONFIG_VP9_HIGHBITDEPTH
4854           if (cpi->Source->flags & YV12_FLAG_HIGHBITDEPTH)
4855             var += vp9_high_get_sby_variance(cpi, &buf, BLOCK_8X8, xd->bd);
4856           else
4857 #endif
4858             var += vp9_get_sby_variance(cpi, &buf, BLOCK_8X8);
4859
4860           num_of_var += 1.0;
4861         }
4862       }
4863       var = var / num_of_var / 64.0;
4864       var = 2.0 * var + c2;
4865       cpi->mi_ssim_rdmult_scaling_factors[index] = var;
4866       log_sum += log(var);
4867     }
4868   }
4869   log_sum = exp(log_sum / (double)(num_rows * num_cols));
4870
4871   for (row = 0; row < num_rows; ++row) {
4872     for (col = 0; col < num_cols; ++col) {
4873       const int index = row * num_cols + col;
4874       cpi->mi_ssim_rdmult_scaling_factors[index] /= log_sum;
4875     }
4876   }
4877
4878   (void)xd;
4879 }
4880
4881 // Process the wiener variance in 16x16 block basis.
4882 static int qsort_comp(const void *elem1, const void *elem2) {
4883   int a = *((const int *)elem1);
4884   int b = *((const int *)elem2);
4885   if (a > b) return 1;
4886   if (a < b) return -1;
4887   return 0;
4888 }
4889
4890 static void init_mb_wiener_var_buffer(VP9_COMP *cpi) {
4891   VP9_COMMON *cm = &cpi->common;
4892
4893   if (cpi->mb_wiener_variance && cpi->mb_wiener_var_rows >= cm->mb_rows &&
4894       cpi->mb_wiener_var_cols >= cm->mb_cols)
4895     return;
4896
4897   vpx_free(cpi->mb_wiener_variance);
4898   cpi->mb_wiener_variance = NULL;
4899
4900   CHECK_MEM_ERROR(
4901       cm, cpi->mb_wiener_variance,
4902       vpx_calloc(cm->mb_rows * cm->mb_cols, sizeof(*cpi->mb_wiener_variance)));
4903   cpi->mb_wiener_var_rows = cm->mb_rows;
4904   cpi->mb_wiener_var_cols = cm->mb_cols;
4905 }
4906
4907 static void set_mb_wiener_variance(VP9_COMP *cpi) {
4908   VP9_COMMON *cm = &cpi->common;
4909   uint8_t *buffer = cpi->Source->y_buffer;
4910   int buf_stride = cpi->Source->y_stride;
4911
4912 #if CONFIG_VP9_HIGHBITDEPTH
4913   ThreadData *td = &cpi->td;
4914   MACROBLOCK *x = &td->mb;
4915   MACROBLOCKD *xd = &x->e_mbd;
4916   DECLARE_ALIGNED(16, uint16_t, zero_pred16[32 * 32]);
4917   DECLARE_ALIGNED(16, uint8_t, zero_pred8[32 * 32]);
4918   uint8_t *zero_pred;
4919 #else
4920   DECLARE_ALIGNED(16, uint8_t, zero_pred[32 * 32]);
4921 #endif
4922
4923   DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]);
4924   DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]);
4925
4926   int mb_row, mb_col, count = 0;
4927   // Hard coded operating block size
4928   const int block_size = 16;
4929   const int coeff_count = block_size * block_size;
4930   const TX_SIZE tx_size = TX_16X16;
4931
4932 #if CONFIG_VP9_HIGHBITDEPTH
4933   xd->cur_buf = cpi->Source;
4934   if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
4935     zero_pred = CONVERT_TO_BYTEPTR(zero_pred16);
4936     memset(zero_pred16, 0, sizeof(*zero_pred16) * coeff_count);
4937   } else {
4938     zero_pred = zero_pred8;
4939     memset(zero_pred8, 0, sizeof(*zero_pred8) * coeff_count);
4940   }
4941 #else
4942   memset(zero_pred, 0, sizeof(*zero_pred) * coeff_count);
4943 #endif
4944
4945   cpi->norm_wiener_variance = 0;
4946
4947   for (mb_row = 0; mb_row < cm->mb_rows; ++mb_row) {
4948     for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {
4949       int idx;
4950       int16_t median_val = 0;
4951       uint8_t *mb_buffer =
4952           buffer + mb_row * block_size * buf_stride + mb_col * block_size;
4953       int64_t wiener_variance = 0;
4954
4955 #if CONFIG_VP9_HIGHBITDEPTH
4956       if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
4957         vpx_highbd_subtract_block(block_size, block_size, src_diff, block_size,
4958                                   mb_buffer, buf_stride, zero_pred, block_size,
4959                                   xd->bd);
4960         highbd_wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
4961       } else {
4962         vpx_subtract_block(block_size, block_size, src_diff, block_size,
4963                            mb_buffer, buf_stride, zero_pred, block_size);
4964         wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
4965       }
4966 #else
4967       vpx_subtract_block(block_size, block_size, src_diff, block_size,
4968                          mb_buffer, buf_stride, zero_pred, block_size);
4969       wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
4970 #endif  // CONFIG_VP9_HIGHBITDEPTH
4971
4972       coeff[0] = 0;
4973       for (idx = 1; idx < coeff_count; ++idx) coeff[idx] = abs(coeff[idx]);
4974
4975       qsort(coeff, coeff_count - 1, sizeof(*coeff), qsort_comp);
4976
4977       // Noise level estimation
4978       median_val = coeff[coeff_count / 2];
4979
4980       // Wiener filter
4981       for (idx = 1; idx < coeff_count; ++idx) {
4982         int64_t sqr_coeff = (int64_t)coeff[idx] * coeff[idx];
4983         int64_t tmp_coeff = (int64_t)coeff[idx];
4984         if (median_val) {
4985           tmp_coeff = (sqr_coeff * coeff[idx]) /
4986                       (sqr_coeff + (int64_t)median_val * median_val);
4987         }
4988         wiener_variance += tmp_coeff * tmp_coeff;
4989       }
4990       cpi->mb_wiener_variance[mb_row * cm->mb_cols + mb_col] =
4991           wiener_variance / coeff_count;
4992       cpi->norm_wiener_variance +=
4993           cpi->mb_wiener_variance[mb_row * cm->mb_cols + mb_col];
4994       ++count;
4995     }
4996   }
4997
4998   if (count) cpi->norm_wiener_variance /= count;
4999   cpi->norm_wiener_variance = VPXMAX(1, cpi->norm_wiener_variance);
5000 }
5001
5002 static void encode_frame_to_data_rate(VP9_COMP *cpi, size_t *size,
5003                                       uint8_t *dest,
5004                                       unsigned int *frame_flags) {
5005   VP9_COMMON *const cm = &cpi->common;
5006   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
5007   struct segmentation *const seg = &cm->seg;
5008   TX_SIZE t;
5009
5010   // SVC: skip encoding of enhancement layer if the layer target bandwidth = 0.
5011   // No need to set svc.skip_enhancement_layer if whole superframe will be
5012   // dropped.
5013   if (cpi->use_svc && cpi->svc.spatial_layer_id > 0 &&
5014       cpi->oxcf.target_bandwidth == 0 &&
5015       !(cpi->svc.framedrop_mode != LAYER_DROP &&
5016         (cpi->svc.framedrop_mode != CONSTRAINED_FROM_ABOVE_DROP ||
5017          cpi->svc
5018              .force_drop_constrained_from_above[cpi->svc.number_spatial_layers -
5019                                                 1]) &&
5020         cpi->svc.drop_spatial_layer[0])) {
5021     cpi->svc.skip_enhancement_layer = 1;
5022     vp9_rc_postencode_update_drop_frame(cpi);
5023     cpi->ext_refresh_frame_flags_pending = 0;
5024     cpi->last_frame_dropped = 1;
5025     cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 1;
5026     cpi->svc.drop_spatial_layer[cpi->svc.spatial_layer_id] = 1;
5027     vp9_inc_frame_in_layer(cpi);
5028     return;
5029   }
5030
5031   set_ext_overrides(cpi);
5032   vpx_clear_system_state();
5033
5034 #ifdef ENABLE_KF_DENOISE
5035   // Spatial denoise of key frame.
5036   if (is_spatial_denoise_enabled(cpi)) spatial_denoise_frame(cpi);
5037 #endif
5038
5039   if (cm->show_existing_frame == 0) {
5040     // Update frame index
5041     set_frame_index(cpi, cm);
5042
5043     // Set the arf sign bias for this frame.
5044     set_ref_sign_bias(cpi);
5045   }
5046
5047   // Set default state for segment based loop filter update flags.
5048   cm->lf.mode_ref_delta_update = 0;
5049
5050   if (cpi->oxcf.pass == 2 && cpi->sf.adaptive_interp_filter_search)
5051     cpi->sf.interp_filter_search_mask = setup_interp_filter_search_mask(cpi);
5052
5053   // Set various flags etc to special state if it is a key frame.
5054   if (frame_is_intra_only(cm)) {
5055     // Reset the loop filter deltas and segmentation map.
5056     vp9_reset_segment_features(&cm->seg);
5057
5058     // If segmentation is enabled force a map update for key frames.
5059     if (seg->enabled) {
5060       seg->update_map = 1;
5061       seg->update_data = 1;
5062     }
5063
5064     // The alternate reference frame cannot be active for a key frame.
5065     cpi->rc.source_alt_ref_active = 0;
5066
5067     cm->error_resilient_mode = oxcf->error_resilient_mode;
5068     cm->frame_parallel_decoding_mode = oxcf->frame_parallel_decoding_mode;
5069
5070     // By default, encoder assumes decoder can use prev_mi.
5071     if (cm->error_resilient_mode) {
5072       cm->frame_parallel_decoding_mode = 1;
5073       cm->reset_frame_context = 0;
5074       cm->refresh_frame_context = 0;
5075     } else if (cm->intra_only) {
5076       // Only reset the current context.
5077       cm->reset_frame_context = 2;
5078     }
5079   }
5080
5081   if (oxcf->tuning == VP8_TUNE_SSIM) set_mb_ssim_rdmult_scaling(cpi);
5082
5083   if (oxcf->aq_mode == PERCEPTUAL_AQ) {
5084     init_mb_wiener_var_buffer(cpi);
5085     set_mb_wiener_variance(cpi);
5086   }
5087
5088   vpx_clear_system_state();
5089
5090 #if CONFIG_INTERNAL_STATS
5091   memset(cpi->mode_chosen_counts, 0,
5092          MAX_MODES * sizeof(*cpi->mode_chosen_counts));
5093 #endif
5094 #if CONFIG_CONSISTENT_RECODE
5095   // Backup to ensure consistency between recodes
5096   save_encode_params(cpi);
5097 #endif
5098
5099   if (cpi->sf.recode_loop == DISALLOW_RECODE) {
5100     if (!encode_without_recode_loop(cpi, size, dest)) return;
5101   } else {
5102 #if !CONFIG_REALTIME_ONLY
5103     encode_with_recode_loop(cpi, size, dest);
5104 #endif
5105   }
5106
5107   // TODO(jingning): When using show existing frame mode, we assume that the
5108   // current ARF will be directly used as the final reconstructed frame. This is
5109   // an encoder control scheme. One could in principle explore other
5110   // possibilities to arrange the reference frame buffer and their coding order.
5111   if (cm->show_existing_frame) {
5112     ref_cnt_fb(cm->buffer_pool->frame_bufs, &cm->new_fb_idx,
5113                cm->ref_frame_map[cpi->alt_fb_idx]);
5114   }
5115
5116 #if !CONFIG_REALTIME_ONLY
5117   // Disable segmentation if it decrease rate/distortion ratio
5118   if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ)
5119     vp9_try_disable_lookahead_aq(cpi, size, dest);
5120 #endif
5121
5122 #if CONFIG_VP9_TEMPORAL_DENOISING
5123 #ifdef OUTPUT_YUV_DENOISED
5124   if (oxcf->noise_sensitivity > 0 && denoise_svc(cpi)) {
5125     vpx_write_yuv_frame(yuv_denoised_file,
5126                         &cpi->denoiser.running_avg_y[INTRA_FRAME]);
5127   }
5128 #endif
5129 #endif
5130 #ifdef OUTPUT_YUV_SKINMAP
5131   if (cpi->common.current_video_frame > 1) {
5132     vp9_output_skin_map(cpi, yuv_skinmap_file);
5133   }
5134 #endif
5135
5136   // Special case code to reduce pulsing when key frames are forced at a
5137   // fixed interval. Note the reconstruction error if it is the frame before
5138   // the force key frame
5139   if (cpi->rc.next_key_frame_forced && cpi->rc.frames_to_key == 1) {
5140 #if CONFIG_VP9_HIGHBITDEPTH
5141     if (cm->use_highbitdepth) {
5142       cpi->ambient_err =
5143           vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5144     } else {
5145       cpi->ambient_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5146     }
5147 #else
5148     cpi->ambient_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5149 #endif  // CONFIG_VP9_HIGHBITDEPTH
5150   }
5151
5152   // If the encoder forced a KEY_FRAME decision
5153   if (cm->frame_type == KEY_FRAME) cpi->refresh_last_frame = 1;
5154
5155   cm->frame_to_show = get_frame_new_buffer(cm);
5156   cm->frame_to_show->color_space = cm->color_space;
5157   cm->frame_to_show->color_range = cm->color_range;
5158   cm->frame_to_show->render_width = cm->render_width;
5159   cm->frame_to_show->render_height = cm->render_height;
5160
5161   // Pick the loop filter level for the frame.
5162   loopfilter_frame(cpi, cm);
5163
5164   if (cpi->rc.use_post_encode_drop) save_coding_context(cpi);
5165
5166   // build the bitstream
5167   vp9_pack_bitstream(cpi, dest, size);
5168
5169   if (cpi->rc.use_post_encode_drop && cm->base_qindex < cpi->rc.worst_quality &&
5170       cpi->svc.spatial_layer_id == 0 && post_encode_drop_cbr(cpi, size)) {
5171     restore_coding_context(cpi);
5172     return;
5173   }
5174
5175   cpi->last_frame_dropped = 0;
5176   cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 0;
5177   if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1)
5178     cpi->svc.num_encoded_top_layer++;
5179
5180   // Keep track of the frame buffer index updated/refreshed for the
5181   // current encoded TL0 superframe.
5182   if (cpi->svc.temporal_layer_id == 0) {
5183     if (cpi->refresh_last_frame)
5184       cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->lst_fb_idx;
5185     else if (cpi->refresh_golden_frame)
5186       cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->gld_fb_idx;
5187     else if (cpi->refresh_alt_ref_frame)
5188       cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->alt_fb_idx;
5189   }
5190
5191   if (cm->seg.update_map) update_reference_segmentation_map(cpi);
5192
5193   if (frame_is_intra_only(cm) == 0) {
5194     release_scaled_references(cpi);
5195   }
5196   vp9_update_reference_frames(cpi);
5197
5198   if (!cm->show_existing_frame) {
5199     for (t = TX_4X4; t <= TX_32X32; ++t) {
5200       full_to_model_counts(cpi->td.counts->coef[t],
5201                            cpi->td.rd_counts.coef_counts[t]);
5202     }
5203
5204     if (!cm->error_resilient_mode && !cm->frame_parallel_decoding_mode) {
5205       if (!frame_is_intra_only(cm)) {
5206         vp9_adapt_mode_probs(cm);
5207         vp9_adapt_mv_probs(cm, cm->allow_high_precision_mv);
5208       }
5209       vp9_adapt_coef_probs(cm);
5210     }
5211   }
5212
5213   cpi->ext_refresh_frame_flags_pending = 0;
5214
5215   if (cpi->refresh_golden_frame == 1)
5216     cpi->frame_flags |= FRAMEFLAGS_GOLDEN;
5217   else
5218     cpi->frame_flags &= ~FRAMEFLAGS_GOLDEN;
5219
5220   if (cpi->refresh_alt_ref_frame == 1)
5221     cpi->frame_flags |= FRAMEFLAGS_ALTREF;
5222   else
5223     cpi->frame_flags &= ~FRAMEFLAGS_ALTREF;
5224
5225   cpi->ref_frame_flags = get_ref_frame_flags(cpi);
5226
5227   cm->last_frame_type = cm->frame_type;
5228
5229   vp9_rc_postencode_update(cpi, *size);
5230
5231   *size = VPXMAX(1, *size);
5232
5233 #if 0
5234   output_frame_level_debug_stats(cpi);
5235 #endif
5236
5237   if (cm->frame_type == KEY_FRAME) {
5238     // Tell the caller that the frame was coded as a key frame
5239     *frame_flags = cpi->frame_flags | FRAMEFLAGS_KEY;
5240   } else {
5241     *frame_flags = cpi->frame_flags & ~FRAMEFLAGS_KEY;
5242   }
5243
5244   // Clear the one shot update flags for segmentation map and mode/ref loop
5245   // filter deltas.
5246   cm->seg.update_map = 0;
5247   cm->seg.update_data = 0;
5248   cm->lf.mode_ref_delta_update = 0;
5249
5250   // keep track of the last coded dimensions
5251   cm->last_width = cm->width;
5252   cm->last_height = cm->height;
5253
5254   // reset to normal state now that we are done.
5255   if (!cm->show_existing_frame) {
5256     cm->last_show_frame = cm->show_frame;
5257     cm->prev_frame = cm->cur_frame;
5258   }
5259
5260   if (cm->show_frame) {
5261     vp9_swap_mi_and_prev_mi(cm);
5262     // Don't increment frame counters if this was an altref buffer
5263     // update not a real frame
5264     ++cm->current_video_frame;
5265     if (cpi->use_svc) vp9_inc_frame_in_layer(cpi);
5266   }
5267
5268   if (cpi->use_svc) {
5269     cpi->svc
5270         .layer_context[cpi->svc.spatial_layer_id *
5271                            cpi->svc.number_temporal_layers +
5272                        cpi->svc.temporal_layer_id]
5273         .last_frame_type = cm->frame_type;
5274     // Reset layer_sync back to 0 for next frame.
5275     cpi->svc.spatial_layer_sync[cpi->svc.spatial_layer_id] = 0;
5276   }
5277
5278   cpi->force_update_segmentation = 0;
5279
5280 #if !CONFIG_REALTIME_ONLY
5281   if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ)
5282     vp9_alt_ref_aq_unset_all(cpi->alt_ref_aq, cpi);
5283 #endif
5284
5285   cpi->svc.previous_frame_is_intra_only = cm->intra_only;
5286   cpi->svc.set_intra_only_frame = 0;
5287 }
5288
5289 static void SvcEncode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5290                       unsigned int *frame_flags) {
5291   vp9_rc_get_svc_params(cpi);
5292   encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5293 }
5294
5295 static void Pass0Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5296                         unsigned int *frame_flags) {
5297   if (cpi->oxcf.rc_mode == VPX_CBR) {
5298     vp9_rc_get_one_pass_cbr_params(cpi);
5299   } else {
5300     vp9_rc_get_one_pass_vbr_params(cpi);
5301   }
5302   encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5303 }
5304
5305 #if !CONFIG_REALTIME_ONLY
5306 static void Pass2Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5307                         unsigned int *frame_flags) {
5308   cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
5309 #if CONFIG_MISMATCH_DEBUG
5310   mismatch_move_frame_idx_w();
5311 #endif
5312   encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5313
5314   vp9_twopass_postencode_update(cpi);
5315 }
5316 #endif  // !CONFIG_REALTIME_ONLY
5317
5318 static void update_initial_width(VP9_COMP *cpi, int use_highbitdepth,
5319                                  int subsampling_x, int subsampling_y) {
5320   VP9_COMMON *const cm = &cpi->common;
5321 #if !CONFIG_VP9_HIGHBITDEPTH
5322   (void)use_highbitdepth;
5323   assert(use_highbitdepth == 0);
5324 #endif
5325
5326   if (!cpi->initial_width ||
5327 #if CONFIG_VP9_HIGHBITDEPTH
5328       cm->use_highbitdepth != use_highbitdepth ||
5329 #endif
5330       cm->subsampling_x != subsampling_x ||
5331       cm->subsampling_y != subsampling_y) {
5332     cm->subsampling_x = subsampling_x;
5333     cm->subsampling_y = subsampling_y;
5334 #if CONFIG_VP9_HIGHBITDEPTH
5335     cm->use_highbitdepth = use_highbitdepth;
5336 #endif
5337
5338     cpi->initial_width = cm->width;
5339     cpi->initial_height = cm->height;
5340     cpi->initial_mbs = cm->MBs;
5341   }
5342 }
5343
5344 int vp9_receive_raw_frame(VP9_COMP *cpi, vpx_enc_frame_flags_t frame_flags,
5345                           YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
5346                           int64_t end_time) {
5347   VP9_COMMON *const cm = &cpi->common;
5348   struct vpx_usec_timer timer;
5349   int res = 0;
5350   const int subsampling_x = sd->subsampling_x;
5351   const int subsampling_y = sd->subsampling_y;
5352 #if CONFIG_VP9_HIGHBITDEPTH
5353   const int use_highbitdepth = (sd->flags & YV12_FLAG_HIGHBITDEPTH) != 0;
5354 #else
5355   const int use_highbitdepth = 0;
5356 #endif
5357
5358   update_initial_width(cpi, use_highbitdepth, subsampling_x, subsampling_y);
5359 #if CONFIG_VP9_TEMPORAL_DENOISING
5360   setup_denoiser_buffer(cpi);
5361 #endif
5362
5363   alloc_raw_frame_buffers(cpi);
5364
5365   vpx_usec_timer_start(&timer);
5366
5367   if (vp9_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
5368 #if CONFIG_VP9_HIGHBITDEPTH
5369                          use_highbitdepth,
5370 #endif  // CONFIG_VP9_HIGHBITDEPTH
5371                          frame_flags))
5372     res = -1;
5373   vpx_usec_timer_mark(&timer);
5374   cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
5375
5376   if ((cm->profile == PROFILE_0 || cm->profile == PROFILE_2) &&
5377       (subsampling_x != 1 || subsampling_y != 1)) {
5378     vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
5379                        "Non-4:2:0 color format requires profile 1 or 3");
5380     res = -1;
5381   }
5382   if ((cm->profile == PROFILE_1 || cm->profile == PROFILE_3) &&
5383       (subsampling_x == 1 && subsampling_y == 1)) {
5384     vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
5385                        "4:2:0 color format requires profile 0 or 2");
5386     res = -1;
5387   }
5388
5389   return res;
5390 }
5391
5392 static int frame_is_reference(const VP9_COMP *cpi) {
5393   const VP9_COMMON *cm = &cpi->common;
5394
5395   return cm->frame_type == KEY_FRAME || cpi->refresh_last_frame ||
5396          cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame ||
5397          cm->refresh_frame_context || cm->lf.mode_ref_delta_update ||
5398          cm->seg.update_map || cm->seg.update_data;
5399 }
5400
5401 static void adjust_frame_rate(VP9_COMP *cpi,
5402                               const struct lookahead_entry *source) {
5403   int64_t this_duration;
5404   int step = 0;
5405
5406   if (source->ts_start == cpi->first_time_stamp_ever) {
5407     this_duration = source->ts_end - source->ts_start;
5408     step = 1;
5409   } else {
5410     int64_t last_duration =
5411         cpi->last_end_time_stamp_seen - cpi->last_time_stamp_seen;
5412
5413     this_duration = source->ts_end - cpi->last_end_time_stamp_seen;
5414
5415     // do a step update if the duration changes by 10%
5416     if (last_duration)
5417       step = (int)((this_duration - last_duration) * 10 / last_duration);
5418   }
5419
5420   if (this_duration) {
5421     if (step) {
5422       vp9_new_framerate(cpi, 10000000.0 / this_duration);
5423     } else {
5424       // Average this frame's rate into the last second's average
5425       // frame rate. If we haven't seen 1 second yet, then average
5426       // over the whole interval seen.
5427       const double interval = VPXMIN(
5428           (double)(source->ts_end - cpi->first_time_stamp_ever), 10000000.0);
5429       double avg_duration = 10000000.0 / cpi->framerate;
5430       avg_duration *= (interval - avg_duration + this_duration);
5431       avg_duration /= interval;
5432
5433       vp9_new_framerate(cpi, 10000000.0 / avg_duration);
5434     }
5435   }
5436   cpi->last_time_stamp_seen = source->ts_start;
5437   cpi->last_end_time_stamp_seen = source->ts_end;
5438 }
5439
5440 // Returns 0 if this is not an alt ref else the offset of the source frame
5441 // used as the arf midpoint.
5442 static int get_arf_src_index(VP9_COMP *cpi) {
5443   RATE_CONTROL *const rc = &cpi->rc;
5444   int arf_src_index = 0;
5445   if (is_altref_enabled(cpi)) {
5446     if (cpi->oxcf.pass == 2) {
5447       const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
5448       if (gf_group->update_type[gf_group->index] == ARF_UPDATE) {
5449         arf_src_index = gf_group->arf_src_offset[gf_group->index];
5450       }
5451     } else if (rc->source_alt_ref_pending) {
5452       arf_src_index = rc->frames_till_gf_update_due;
5453     }
5454   }
5455   return arf_src_index;
5456 }
5457
5458 static void check_src_altref(VP9_COMP *cpi,
5459                              const struct lookahead_entry *source) {
5460   RATE_CONTROL *const rc = &cpi->rc;
5461
5462   if (cpi->oxcf.pass == 2) {
5463     const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
5464     rc->is_src_frame_alt_ref =
5465         (gf_group->update_type[gf_group->index] == OVERLAY_UPDATE);
5466   } else {
5467     rc->is_src_frame_alt_ref =
5468         cpi->alt_ref_source && (source == cpi->alt_ref_source);
5469   }
5470
5471   if (rc->is_src_frame_alt_ref) {
5472     // Current frame is an ARF overlay frame.
5473     cpi->alt_ref_source = NULL;
5474
5475     // Don't refresh the last buffer for an ARF overlay frame. It will
5476     // become the GF so preserve last as an alternative prediction option.
5477     cpi->refresh_last_frame = 0;
5478   }
5479 }
5480
5481 #if CONFIG_INTERNAL_STATS
5482 static void adjust_image_stat(double y, double u, double v, double all,
5483                               ImageStat *s) {
5484   s->stat[Y] += y;
5485   s->stat[U] += u;
5486   s->stat[V] += v;
5487   s->stat[ALL] += all;
5488   s->worst = VPXMIN(s->worst, all);
5489 }
5490 #endif  // CONFIG_INTERNAL_STATS
5491
5492 // Adjust the maximum allowable frame size for the target level.
5493 static void level_rc_framerate(VP9_COMP *cpi, int arf_src_index) {
5494   RATE_CONTROL *const rc = &cpi->rc;
5495   LevelConstraint *const ls = &cpi->level_constraint;
5496   VP9_COMMON *const cm = &cpi->common;
5497   const double max_cpb_size = ls->max_cpb_size;
5498   vpx_clear_system_state();
5499   rc->max_frame_bandwidth = VPXMIN(rc->max_frame_bandwidth, ls->max_frame_size);
5500   if (frame_is_intra_only(cm)) {
5501     rc->max_frame_bandwidth =
5502         VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.5));
5503   } else if (arf_src_index > 0) {
5504     rc->max_frame_bandwidth =
5505         VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.4));
5506   } else {
5507     rc->max_frame_bandwidth =
5508         VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.2));
5509   }
5510 }
5511
5512 static void update_level_info(VP9_COMP *cpi, size_t *size, int arf_src_index) {
5513   VP9_COMMON *const cm = &cpi->common;
5514   Vp9LevelInfo *const level_info = &cpi->level_info;
5515   Vp9LevelSpec *const level_spec = &level_info->level_spec;
5516   Vp9LevelStats *const level_stats = &level_info->level_stats;
5517   int i, idx;
5518   uint64_t luma_samples, dur_end;
5519   const uint32_t luma_pic_size = cm->width * cm->height;
5520   const uint32_t luma_pic_breadth = VPXMAX(cm->width, cm->height);
5521   LevelConstraint *const level_constraint = &cpi->level_constraint;
5522   const int8_t level_index = level_constraint->level_index;
5523   double cpb_data_size;
5524
5525   vpx_clear_system_state();
5526
5527   // update level_stats
5528   level_stats->total_compressed_size += *size;
5529   if (cm->show_frame) {
5530     level_stats->total_uncompressed_size +=
5531         luma_pic_size +
5532         2 * (luma_pic_size >> (cm->subsampling_x + cm->subsampling_y));
5533     level_stats->time_encoded =
5534         (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
5535         (double)TICKS_PER_SEC;
5536   }
5537
5538   if (arf_src_index > 0) {
5539     if (!level_stats->seen_first_altref) {
5540       level_stats->seen_first_altref = 1;
5541     } else if (level_stats->frames_since_last_altref <
5542                level_spec->min_altref_distance) {
5543       level_spec->min_altref_distance = level_stats->frames_since_last_altref;
5544     }
5545     level_stats->frames_since_last_altref = 0;
5546   } else {
5547     ++level_stats->frames_since_last_altref;
5548   }
5549
5550   if (level_stats->frame_window_buffer.len < FRAME_WINDOW_SIZE - 1) {
5551     idx = (level_stats->frame_window_buffer.start +
5552            level_stats->frame_window_buffer.len++) %
5553           FRAME_WINDOW_SIZE;
5554   } else {
5555     idx = level_stats->frame_window_buffer.start;
5556     level_stats->frame_window_buffer.start = (idx + 1) % FRAME_WINDOW_SIZE;
5557   }
5558   level_stats->frame_window_buffer.buf[idx].ts = cpi->last_time_stamp_seen;
5559   level_stats->frame_window_buffer.buf[idx].size = (uint32_t)(*size);
5560   level_stats->frame_window_buffer.buf[idx].luma_samples = luma_pic_size;
5561
5562   if (cm->frame_type == KEY_FRAME) {
5563     level_stats->ref_refresh_map = 0;
5564   } else {
5565     int count = 0;
5566     level_stats->ref_refresh_map |= vp9_get_refresh_mask(cpi);
5567     // Also need to consider the case where the encoder refers to a buffer
5568     // that has been implicitly refreshed after encoding a keyframe.
5569     if (!cm->intra_only) {
5570       level_stats->ref_refresh_map |= (1 << cpi->lst_fb_idx);
5571       level_stats->ref_refresh_map |= (1 << cpi->gld_fb_idx);
5572       level_stats->ref_refresh_map |= (1 << cpi->alt_fb_idx);
5573     }
5574     for (i = 0; i < REF_FRAMES; ++i) {
5575       count += (level_stats->ref_refresh_map >> i) & 1;
5576     }
5577     if (count > level_spec->max_ref_frame_buffers) {
5578       level_spec->max_ref_frame_buffers = count;
5579     }
5580   }
5581
5582   // update average_bitrate
5583   level_spec->average_bitrate = (double)level_stats->total_compressed_size /
5584                                 125.0 / level_stats->time_encoded;
5585
5586   // update max_luma_sample_rate
5587   luma_samples = 0;
5588   for (i = 0; i < level_stats->frame_window_buffer.len; ++i) {
5589     idx = (level_stats->frame_window_buffer.start +
5590            level_stats->frame_window_buffer.len - 1 - i) %
5591           FRAME_WINDOW_SIZE;
5592     if (i == 0) {
5593       dur_end = level_stats->frame_window_buffer.buf[idx].ts;
5594     }
5595     if (dur_end - level_stats->frame_window_buffer.buf[idx].ts >=
5596         TICKS_PER_SEC) {
5597       break;
5598     }
5599     luma_samples += level_stats->frame_window_buffer.buf[idx].luma_samples;
5600   }
5601   if (luma_samples > level_spec->max_luma_sample_rate) {
5602     level_spec->max_luma_sample_rate = luma_samples;
5603   }
5604
5605   // update max_cpb_size
5606   cpb_data_size = 0;
5607   for (i = 0; i < CPB_WINDOW_SIZE; ++i) {
5608     if (i >= level_stats->frame_window_buffer.len) break;
5609     idx = (level_stats->frame_window_buffer.start +
5610            level_stats->frame_window_buffer.len - 1 - i) %
5611           FRAME_WINDOW_SIZE;
5612     cpb_data_size += level_stats->frame_window_buffer.buf[idx].size;
5613   }
5614   cpb_data_size = cpb_data_size / 125.0;
5615   if (cpb_data_size > level_spec->max_cpb_size) {
5616     level_spec->max_cpb_size = cpb_data_size;
5617   }
5618
5619   // update max_luma_picture_size
5620   if (luma_pic_size > level_spec->max_luma_picture_size) {
5621     level_spec->max_luma_picture_size = luma_pic_size;
5622   }
5623
5624   // update max_luma_picture_breadth
5625   if (luma_pic_breadth > level_spec->max_luma_picture_breadth) {
5626     level_spec->max_luma_picture_breadth = luma_pic_breadth;
5627   }
5628
5629   // update compression_ratio
5630   level_spec->compression_ratio = (double)level_stats->total_uncompressed_size *
5631                                   cm->bit_depth /
5632                                   level_stats->total_compressed_size / 8.0;
5633
5634   // update max_col_tiles
5635   if (level_spec->max_col_tiles < (1 << cm->log2_tile_cols)) {
5636     level_spec->max_col_tiles = (1 << cm->log2_tile_cols);
5637   }
5638
5639   if (level_index >= 0 && level_constraint->fail_flag == 0) {
5640     if (level_spec->max_luma_picture_size >
5641         vp9_level_defs[level_index].max_luma_picture_size) {
5642       level_constraint->fail_flag |= (1 << LUMA_PIC_SIZE_TOO_LARGE);
5643       vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5644                          "Failed to encode to the target level %d. %s",
5645                          vp9_level_defs[level_index].level,
5646                          level_fail_messages[LUMA_PIC_SIZE_TOO_LARGE]);
5647     }
5648
5649     if (level_spec->max_luma_picture_breadth >
5650         vp9_level_defs[level_index].max_luma_picture_breadth) {
5651       level_constraint->fail_flag |= (1 << LUMA_PIC_BREADTH_TOO_LARGE);
5652       vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5653                          "Failed to encode to the target level %d. %s",
5654                          vp9_level_defs[level_index].level,
5655                          level_fail_messages[LUMA_PIC_BREADTH_TOO_LARGE]);
5656     }
5657
5658     if ((double)level_spec->max_luma_sample_rate >
5659         (double)vp9_level_defs[level_index].max_luma_sample_rate *
5660             (1 + SAMPLE_RATE_GRACE_P)) {
5661       level_constraint->fail_flag |= (1 << LUMA_SAMPLE_RATE_TOO_LARGE);
5662       vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5663                          "Failed to encode to the target level %d. %s",
5664                          vp9_level_defs[level_index].level,
5665                          level_fail_messages[LUMA_SAMPLE_RATE_TOO_LARGE]);
5666     }
5667
5668     if (level_spec->max_col_tiles > vp9_level_defs[level_index].max_col_tiles) {
5669       level_constraint->fail_flag |= (1 << TOO_MANY_COLUMN_TILE);
5670       vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5671                          "Failed to encode to the target level %d. %s",
5672                          vp9_level_defs[level_index].level,
5673                          level_fail_messages[TOO_MANY_COLUMN_TILE]);
5674     }
5675
5676     if (level_spec->min_altref_distance <
5677         vp9_level_defs[level_index].min_altref_distance) {
5678       level_constraint->fail_flag |= (1 << ALTREF_DIST_TOO_SMALL);
5679       vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5680                          "Failed to encode to the target level %d. %s",
5681                          vp9_level_defs[level_index].level,
5682                          level_fail_messages[ALTREF_DIST_TOO_SMALL]);
5683     }
5684
5685     if (level_spec->max_ref_frame_buffers >
5686         vp9_level_defs[level_index].max_ref_frame_buffers) {
5687       level_constraint->fail_flag |= (1 << TOO_MANY_REF_BUFFER);
5688       vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5689                          "Failed to encode to the target level %d. %s",
5690                          vp9_level_defs[level_index].level,
5691                          level_fail_messages[TOO_MANY_REF_BUFFER]);
5692     }
5693
5694     if (level_spec->max_cpb_size > vp9_level_defs[level_index].max_cpb_size) {
5695       level_constraint->fail_flag |= (1 << CPB_TOO_LARGE);
5696       vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5697                          "Failed to encode to the target level %d. %s",
5698                          vp9_level_defs[level_index].level,
5699                          level_fail_messages[CPB_TOO_LARGE]);
5700     }
5701
5702     // Set an upper bound for the next frame size. It will be used in
5703     // level_rc_framerate() before encoding the next frame.
5704     cpb_data_size = 0;
5705     for (i = 0; i < CPB_WINDOW_SIZE - 1; ++i) {
5706       if (i >= level_stats->frame_window_buffer.len) break;
5707       idx = (level_stats->frame_window_buffer.start +
5708              level_stats->frame_window_buffer.len - 1 - i) %
5709             FRAME_WINDOW_SIZE;
5710       cpb_data_size += level_stats->frame_window_buffer.buf[idx].size;
5711     }
5712     cpb_data_size = cpb_data_size / 125.0;
5713     level_constraint->max_frame_size =
5714         (int)((vp9_level_defs[level_index].max_cpb_size - cpb_data_size) *
5715               1000.0);
5716     if (level_stats->frame_window_buffer.len < CPB_WINDOW_SIZE - 1)
5717       level_constraint->max_frame_size >>= 1;
5718   }
5719 }
5720
5721 typedef struct GF_PICTURE {
5722   YV12_BUFFER_CONFIG *frame;
5723   int ref_frame[3];
5724   FRAME_UPDATE_TYPE update_type;
5725 } GF_PICTURE;
5726
5727 static void init_gop_frames(VP9_COMP *cpi, GF_PICTURE *gf_picture,
5728                             const GF_GROUP *gf_group, int *tpl_group_frames) {
5729   VP9_COMMON *cm = &cpi->common;
5730   int frame_idx = 0;
5731   int i;
5732   int gld_index = -1;
5733   int alt_index = -1;
5734   int lst_index = -1;
5735   int arf_index_stack[MAX_ARF_LAYERS];
5736   int arf_stack_size = 0;
5737   int extend_frame_count = 0;
5738   int pframe_qindex = cpi->tpl_stats[2].base_qindex;
5739   int frame_gop_offset = 0;
5740
5741   RefCntBuffer *frame_bufs = cm->buffer_pool->frame_bufs;
5742   int8_t recon_frame_index[REFS_PER_FRAME + MAX_ARF_LAYERS];
5743
5744   memset(recon_frame_index, -1, sizeof(recon_frame_index));
5745   stack_init(arf_index_stack, MAX_ARF_LAYERS);
5746
5747   // TODO(jingning): To be used later for gf frame type parsing.
5748   (void)gf_group;
5749
5750   for (i = 0; i < FRAME_BUFFERS; ++i) {
5751     if (frame_bufs[i].ref_count == 0) {
5752       alloc_frame_mvs(cm, i);
5753       if (vpx_realloc_frame_buffer(&frame_bufs[i].buf, cm->width, cm->height,
5754                                    cm->subsampling_x, cm->subsampling_y,
5755 #if CONFIG_VP9_HIGHBITDEPTH
5756                                    cm->use_highbitdepth,
5757 #endif
5758                                    VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
5759                                    NULL, NULL, NULL))
5760         vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
5761                            "Failed to allocate frame buffer");
5762
5763       recon_frame_index[frame_idx] = i;
5764       ++frame_idx;
5765
5766       if (frame_idx >= REFS_PER_FRAME + cpi->oxcf.enable_auto_arf) break;
5767     }
5768   }
5769
5770   for (i = 0; i < REFS_PER_FRAME + 1; ++i) {
5771     assert(recon_frame_index[i] >= 0);
5772     cpi->tpl_recon_frames[i] = &frame_bufs[recon_frame_index[i]].buf;
5773   }
5774
5775   *tpl_group_frames = 0;
5776
5777   // Initialize Golden reference frame.
5778   gf_picture[0].frame = get_ref_frame_buffer(cpi, GOLDEN_FRAME);
5779   for (i = 0; i < 3; ++i) gf_picture[0].ref_frame[i] = -1;
5780   gf_picture[0].update_type = gf_group->update_type[0];
5781   gld_index = 0;
5782   ++*tpl_group_frames;
5783
5784   // Initialize base layer ARF frame
5785   gf_picture[1].frame = cpi->Source;
5786   gf_picture[1].ref_frame[0] = gld_index;
5787   gf_picture[1].ref_frame[1] = lst_index;
5788   gf_picture[1].ref_frame[2] = alt_index;
5789   gf_picture[1].update_type = gf_group->update_type[1];
5790   alt_index = 1;
5791   ++*tpl_group_frames;
5792
5793   // Initialize P frames
5794   for (frame_idx = 2; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) {
5795     struct lookahead_entry *buf;
5796     frame_gop_offset = gf_group->frame_gop_index[frame_idx];
5797     buf = vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1);
5798
5799     if (buf == NULL) break;
5800
5801     gf_picture[frame_idx].frame = &buf->img;
5802     gf_picture[frame_idx].ref_frame[0] = gld_index;
5803     gf_picture[frame_idx].ref_frame[1] = lst_index;
5804     gf_picture[frame_idx].ref_frame[2] = alt_index;
5805     gf_picture[frame_idx].update_type = gf_group->update_type[frame_idx];
5806
5807     switch (gf_group->update_type[frame_idx]) {
5808       case ARF_UPDATE:
5809         stack_push(arf_index_stack, alt_index, arf_stack_size);
5810         ++arf_stack_size;
5811         alt_index = frame_idx;
5812         break;
5813       case LF_UPDATE: lst_index = frame_idx; break;
5814       case OVERLAY_UPDATE:
5815         gld_index = frame_idx;
5816         alt_index = stack_pop(arf_index_stack, arf_stack_size);
5817         --arf_stack_size;
5818         break;
5819       case USE_BUF_FRAME:
5820         lst_index = alt_index;
5821         alt_index = stack_pop(arf_index_stack, arf_stack_size);
5822         --arf_stack_size;
5823         break;
5824       default: break;
5825     }
5826
5827     ++*tpl_group_frames;
5828
5829     // The length of group of pictures is baseline_gf_interval, plus the
5830     // beginning golden frame from last GOP, plus the last overlay frame in
5831     // the same GOP.
5832     if (frame_idx == gf_group->gf_group_size) break;
5833   }
5834
5835   alt_index = -1;
5836   ++frame_idx;
5837   ++frame_gop_offset;
5838
5839   // Extend two frames outside the current gf group.
5840   for (; frame_idx < MAX_LAG_BUFFERS && extend_frame_count < 2; ++frame_idx) {
5841     struct lookahead_entry *buf =
5842         vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1);
5843
5844     if (buf == NULL) break;
5845
5846     cpi->tpl_stats[frame_idx].base_qindex = pframe_qindex;
5847
5848     gf_picture[frame_idx].frame = &buf->img;
5849     gf_picture[frame_idx].ref_frame[0] = gld_index;
5850     gf_picture[frame_idx].ref_frame[1] = lst_index;
5851     gf_picture[frame_idx].ref_frame[2] = alt_index;
5852     gf_picture[frame_idx].update_type = LF_UPDATE;
5853     lst_index = frame_idx;
5854     ++*tpl_group_frames;
5855     ++extend_frame_count;
5856     ++frame_gop_offset;
5857   }
5858 }
5859
5860 static void init_tpl_stats(VP9_COMP *cpi) {
5861   int frame_idx;
5862   for (frame_idx = 0; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) {
5863     TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
5864     memset(tpl_frame->tpl_stats_ptr, 0,
5865            tpl_frame->height * tpl_frame->width *
5866                sizeof(*tpl_frame->tpl_stats_ptr));
5867     tpl_frame->is_valid = 0;
5868   }
5869 }
5870
5871 #if CONFIG_NON_GREEDY_MV
5872 static uint32_t full_pixel_motion_search(VP9_COMP *cpi, ThreadData *td,
5873                                          MotionField *motion_field,
5874                                          int frame_idx, uint8_t *cur_frame_buf,
5875                                          uint8_t *ref_frame_buf, int stride,
5876                                          BLOCK_SIZE bsize, int mi_row,
5877                                          int mi_col, MV *mv) {
5878   MACROBLOCK *const x = &td->mb;
5879   MACROBLOCKD *const xd = &x->e_mbd;
5880   MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5881   int step_param;
5882   uint32_t bestsme = UINT_MAX;
5883   const MvLimits tmp_mv_limits = x->mv_limits;
5884   // lambda is used to adjust the importance of motion vector consitency.
5885   // TODO(angiebird): Figure out lambda's proper value.
5886   const int lambda = cpi->tpl_stats[frame_idx].lambda;
5887   int_mv nb_full_mvs[NB_MVS_NUM];
5888   int nb_full_mv_num;
5889
5890   MV best_ref_mv1 = { 0, 0 };
5891   MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
5892
5893   best_ref_mv1_full.col = best_ref_mv1.col >> 3;
5894   best_ref_mv1_full.row = best_ref_mv1.row >> 3;
5895
5896   // Setup frame pointers
5897   x->plane[0].src.buf = cur_frame_buf;
5898   x->plane[0].src.stride = stride;
5899   xd->plane[0].pre[0].buf = ref_frame_buf;
5900   xd->plane[0].pre[0].stride = stride;
5901
5902   step_param = mv_sf->reduce_first_step_size;
5903   step_param = VPXMIN(step_param, MAX_MVSEARCH_STEPS - 2);
5904
5905   vp9_set_mv_search_range(&x->mv_limits, &best_ref_mv1);
5906
5907   nb_full_mv_num =
5908       vp9_prepare_nb_full_mvs(motion_field, mi_row, mi_col, nb_full_mvs);
5909   vp9_full_pixel_diamond_new(cpi, x, bsize, &best_ref_mv1_full, step_param,
5910                              lambda, 1, nb_full_mvs, nb_full_mv_num, mv);
5911
5912   /* restore UMV window */
5913   x->mv_limits = tmp_mv_limits;
5914
5915   return bestsme;
5916 }
5917
5918 static uint32_t sub_pixel_motion_search(VP9_COMP *cpi, ThreadData *td,
5919                                         uint8_t *cur_frame_buf,
5920                                         uint8_t *ref_frame_buf, int stride,
5921                                         BLOCK_SIZE bsize, MV *mv) {
5922   MACROBLOCK *const x = &td->mb;
5923   MACROBLOCKD *const xd = &x->e_mbd;
5924   MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5925   uint32_t bestsme = UINT_MAX;
5926   uint32_t distortion;
5927   uint32_t sse;
5928   int cost_list[5];
5929
5930   MV best_ref_mv1 = { 0, 0 };
5931
5932   // Setup frame pointers
5933   x->plane[0].src.buf = cur_frame_buf;
5934   x->plane[0].src.stride = stride;
5935   xd->plane[0].pre[0].buf = ref_frame_buf;
5936   xd->plane[0].pre[0].stride = stride;
5937
5938   // TODO(yunqing): may use higher tap interp filter than 2 taps.
5939   // Ignore mv costing by sending NULL pointer instead of cost array
5940   bestsme = cpi->find_fractional_mv_step(
5941       x, mv, &best_ref_mv1, cpi->common.allow_high_precision_mv, x->errorperbit,
5942       &cpi->fn_ptr[bsize], 0, mv_sf->subpel_search_level,
5943       cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, 0, 0,
5944       USE_2_TAPS);
5945
5946   return bestsme;
5947 }
5948
5949 #else  // CONFIG_NON_GREEDY_MV
5950 static uint32_t motion_compensated_prediction(VP9_COMP *cpi, ThreadData *td,
5951                                               uint8_t *cur_frame_buf,
5952                                               uint8_t *ref_frame_buf,
5953                                               int stride, BLOCK_SIZE bsize,
5954                                               MV *mv) {
5955   MACROBLOCK *const x = &td->mb;
5956   MACROBLOCKD *const xd = &x->e_mbd;
5957   MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5958   const SEARCH_METHODS search_method = NSTEP;
5959   int step_param;
5960   int sadpb = x->sadperbit16;
5961   uint32_t bestsme = UINT_MAX;
5962   uint32_t distortion;
5963   uint32_t sse;
5964   int cost_list[5];
5965   const MvLimits tmp_mv_limits = x->mv_limits;
5966
5967   MV best_ref_mv1 = { 0, 0 };
5968   MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
5969
5970   best_ref_mv1_full.col = best_ref_mv1.col >> 3;
5971   best_ref_mv1_full.row = best_ref_mv1.row >> 3;
5972
5973   // Setup frame pointers
5974   x->plane[0].src.buf = cur_frame_buf;
5975   x->plane[0].src.stride = stride;
5976   xd->plane[0].pre[0].buf = ref_frame_buf;
5977   xd->plane[0].pre[0].stride = stride;
5978
5979   step_param = mv_sf->reduce_first_step_size;
5980   step_param = VPXMIN(step_param, MAX_MVSEARCH_STEPS - 2);
5981
5982   vp9_set_mv_search_range(&x->mv_limits, &best_ref_mv1);
5983
5984   vp9_full_pixel_search(cpi, x, bsize, &best_ref_mv1_full, step_param,
5985                         search_method, sadpb, cond_cost_list(cpi, cost_list),
5986                         &best_ref_mv1, mv, 0, 0);
5987
5988   /* restore UMV window */
5989   x->mv_limits = tmp_mv_limits;
5990
5991   // TODO(yunqing): may use higher tap interp filter than 2 taps.
5992   // Ignore mv costing by sending NULL pointer instead of cost array
5993   bestsme = cpi->find_fractional_mv_step(
5994       x, mv, &best_ref_mv1, cpi->common.allow_high_precision_mv, x->errorperbit,
5995       &cpi->fn_ptr[bsize], 0, mv_sf->subpel_search_level,
5996       cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, 0, 0,
5997       USE_2_TAPS);
5998
5999   return bestsme;
6000 }
6001 #endif
6002
6003 static int get_overlap_area(int grid_pos_row, int grid_pos_col, int ref_pos_row,
6004                             int ref_pos_col, int block, BLOCK_SIZE bsize) {
6005   int width = 0, height = 0;
6006   int bw = 4 << b_width_log2_lookup[bsize];
6007   int bh = 4 << b_height_log2_lookup[bsize];
6008
6009   switch (block) {
6010     case 0:
6011       width = grid_pos_col + bw - ref_pos_col;
6012       height = grid_pos_row + bh - ref_pos_row;
6013       break;
6014     case 1:
6015       width = ref_pos_col + bw - grid_pos_col;
6016       height = grid_pos_row + bh - ref_pos_row;
6017       break;
6018     case 2:
6019       width = grid_pos_col + bw - ref_pos_col;
6020       height = ref_pos_row + bh - grid_pos_row;
6021       break;
6022     case 3:
6023       width = ref_pos_col + bw - grid_pos_col;
6024       height = ref_pos_row + bh - grid_pos_row;
6025       break;
6026     default: assert(0);
6027   }
6028
6029   return width * height;
6030 }
6031
6032 static int round_floor(int ref_pos, int bsize_pix) {
6033   int round;
6034   if (ref_pos < 0)
6035     round = -(1 + (-ref_pos - 1) / bsize_pix);
6036   else
6037     round = ref_pos / bsize_pix;
6038
6039   return round;
6040 }
6041
6042 static void tpl_model_store(TplDepStats *tpl_stats, int mi_row, int mi_col,
6043                             BLOCK_SIZE bsize, int stride) {
6044   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6045   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6046   const TplDepStats *src_stats = &tpl_stats[mi_row * stride + mi_col];
6047   int idx, idy;
6048
6049   for (idy = 0; idy < mi_height; ++idy) {
6050     for (idx = 0; idx < mi_width; ++idx) {
6051       TplDepStats *tpl_ptr = &tpl_stats[(mi_row + idy) * stride + mi_col + idx];
6052       const int64_t mc_flow = tpl_ptr->mc_flow;
6053       const int64_t mc_ref_cost = tpl_ptr->mc_ref_cost;
6054       *tpl_ptr = *src_stats;
6055       tpl_ptr->mc_flow = mc_flow;
6056       tpl_ptr->mc_ref_cost = mc_ref_cost;
6057       tpl_ptr->mc_dep_cost = tpl_ptr->intra_cost + tpl_ptr->mc_flow;
6058     }
6059   }
6060 }
6061
6062 static void tpl_model_update_b(TplDepFrame *tpl_frame, TplDepStats *tpl_stats,
6063                                int mi_row, int mi_col, const BLOCK_SIZE bsize) {
6064   TplDepFrame *ref_tpl_frame = &tpl_frame[tpl_stats->ref_frame_index];
6065   TplDepStats *ref_stats = ref_tpl_frame->tpl_stats_ptr;
6066   MV mv = tpl_stats->mv.as_mv;
6067   int mv_row = mv.row >> 3;
6068   int mv_col = mv.col >> 3;
6069
6070   int ref_pos_row = mi_row * MI_SIZE + mv_row;
6071   int ref_pos_col = mi_col * MI_SIZE + mv_col;
6072
6073   const int bw = 4 << b_width_log2_lookup[bsize];
6074   const int bh = 4 << b_height_log2_lookup[bsize];
6075   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6076   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6077   const int pix_num = bw * bh;
6078
6079   // top-left on grid block location in pixel
6080   int grid_pos_row_base = round_floor(ref_pos_row, bh) * bh;
6081   int grid_pos_col_base = round_floor(ref_pos_col, bw) * bw;
6082   int block;
6083
6084   for (block = 0; block < 4; ++block) {
6085     int grid_pos_row = grid_pos_row_base + bh * (block >> 1);
6086     int grid_pos_col = grid_pos_col_base + bw * (block & 0x01);
6087
6088     if (grid_pos_row >= 0 && grid_pos_row < ref_tpl_frame->mi_rows * MI_SIZE &&
6089         grid_pos_col >= 0 && grid_pos_col < ref_tpl_frame->mi_cols * MI_SIZE) {
6090       int overlap_area = get_overlap_area(
6091           grid_pos_row, grid_pos_col, ref_pos_row, ref_pos_col, block, bsize);
6092       int ref_mi_row = round_floor(grid_pos_row, bh) * mi_height;
6093       int ref_mi_col = round_floor(grid_pos_col, bw) * mi_width;
6094
6095       int64_t mc_flow = tpl_stats->mc_dep_cost -
6096                         (tpl_stats->mc_dep_cost * tpl_stats->inter_cost) /
6097                             tpl_stats->intra_cost;
6098
6099       int idx, idy;
6100
6101       for (idy = 0; idy < mi_height; ++idy) {
6102         for (idx = 0; idx < mi_width; ++idx) {
6103           TplDepStats *des_stats =
6104               &ref_stats[(ref_mi_row + idy) * ref_tpl_frame->stride +
6105                          (ref_mi_col + idx)];
6106
6107           des_stats->mc_flow += (mc_flow * overlap_area) / pix_num;
6108           des_stats->mc_ref_cost +=
6109               ((tpl_stats->intra_cost - tpl_stats->inter_cost) * overlap_area) /
6110               pix_num;
6111           assert(overlap_area >= 0);
6112         }
6113       }
6114     }
6115   }
6116 }
6117
6118 static void tpl_model_update(TplDepFrame *tpl_frame, TplDepStats *tpl_stats,
6119                              int mi_row, int mi_col, const BLOCK_SIZE bsize) {
6120   int idx, idy;
6121   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6122   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6123
6124   for (idy = 0; idy < mi_height; ++idy) {
6125     for (idx = 0; idx < mi_width; ++idx) {
6126       TplDepStats *tpl_ptr =
6127           &tpl_stats[(mi_row + idy) * tpl_frame->stride + (mi_col + idx)];
6128       tpl_model_update_b(tpl_frame, tpl_ptr, mi_row + idy, mi_col + idx,
6129                          BLOCK_8X8);
6130     }
6131   }
6132 }
6133
6134 static void get_quantize_error(MACROBLOCK *x, int plane, tran_low_t *coeff,
6135                                tran_low_t *qcoeff, tran_low_t *dqcoeff,
6136                                TX_SIZE tx_size, int64_t *recon_error,
6137                                int64_t *sse) {
6138   MACROBLOCKD *const xd = &x->e_mbd;
6139   const struct macroblock_plane *const p = &x->plane[plane];
6140   const struct macroblockd_plane *const pd = &xd->plane[plane];
6141   const scan_order *const scan_order = &vp9_default_scan_orders[tx_size];
6142   uint16_t eob;
6143   int pix_num = 1 << num_pels_log2_lookup[txsize_to_bsize[tx_size]];
6144   const int shift = tx_size == TX_32X32 ? 0 : 2;
6145
6146 #if CONFIG_VP9_HIGHBITDEPTH
6147   if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6148     vp9_highbd_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp,
6149                                  p->quant_fp, qcoeff, dqcoeff, pd->dequant,
6150                                  &eob, scan_order->scan, scan_order->iscan);
6151   } else {
6152     vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp,
6153                           p->quant_fp, qcoeff, dqcoeff, pd->dequant, &eob,
6154                           scan_order->scan, scan_order->iscan);
6155   }
6156 #else
6157   vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp, p->quant_fp,
6158                         qcoeff, dqcoeff, pd->dequant, &eob, scan_order->scan,
6159                         scan_order->iscan);
6160 #endif  // CONFIG_VP9_HIGHBITDEPTH
6161
6162   *recon_error = vp9_block_error(coeff, dqcoeff, pix_num, sse) >> shift;
6163   *recon_error = VPXMAX(*recon_error, 1);
6164
6165   *sse = (*sse) >> shift;
6166   *sse = VPXMAX(*sse, 1);
6167 }
6168
6169 #if CONFIG_VP9_HIGHBITDEPTH
6170 void highbd_wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
6171                          TX_SIZE tx_size) {
6172   // TODO(sdeng): Implement SIMD based high bit-depth Hadamard transforms.
6173   switch (tx_size) {
6174     case TX_8X8: vpx_highbd_hadamard_8x8(src_diff, bw, coeff); break;
6175     case TX_16X16: vpx_highbd_hadamard_16x16(src_diff, bw, coeff); break;
6176     case TX_32X32: vpx_highbd_hadamard_32x32(src_diff, bw, coeff); break;
6177     default: assert(0);
6178   }
6179 }
6180 #endif  // CONFIG_VP9_HIGHBITDEPTH
6181
6182 void wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
6183                   TX_SIZE tx_size) {
6184   switch (tx_size) {
6185     case TX_8X8: vpx_hadamard_8x8(src_diff, bw, coeff); break;
6186     case TX_16X16: vpx_hadamard_16x16(src_diff, bw, coeff); break;
6187     case TX_32X32: vpx_hadamard_32x32(src_diff, bw, coeff); break;
6188     default: assert(0);
6189   }
6190 }
6191
6192 static void set_mv_limits(const VP9_COMMON *cm, MACROBLOCK *x, int mi_row,
6193                           int mi_col) {
6194   x->mv_limits.row_min = -((mi_row * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND));
6195   x->mv_limits.row_max =
6196       (cm->mi_rows - 1 - mi_row) * MI_SIZE + (17 - 2 * VP9_INTERP_EXTEND);
6197   x->mv_limits.col_min = -((mi_col * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND));
6198   x->mv_limits.col_max =
6199       ((cm->mi_cols - 1 - mi_col) * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND);
6200 }
6201
6202 static void mode_estimation(VP9_COMP *cpi, MACROBLOCK *x, MACROBLOCKD *xd,
6203                             struct scale_factors *sf, GF_PICTURE *gf_picture,
6204                             int frame_idx, TplDepFrame *tpl_frame,
6205                             int16_t *src_diff, tran_low_t *coeff,
6206                             tran_low_t *qcoeff, tran_low_t *dqcoeff, int mi_row,
6207                             int mi_col, BLOCK_SIZE bsize, TX_SIZE tx_size,
6208                             YV12_BUFFER_CONFIG *ref_frame[], uint8_t *predictor,
6209                             int64_t *recon_error, int64_t *sse) {
6210   VP9_COMMON *cm = &cpi->common;
6211   ThreadData *td = &cpi->td;
6212
6213   const int bw = 4 << b_width_log2_lookup[bsize];
6214   const int bh = 4 << b_height_log2_lookup[bsize];
6215   const int pix_num = bw * bh;
6216   int best_rf_idx = -1;
6217   int_mv best_mv;
6218   int64_t best_inter_cost = INT64_MAX;
6219   int64_t inter_cost;
6220   int rf_idx;
6221   const InterpKernel *const kernel = vp9_filter_kernels[EIGHTTAP];
6222
6223   int64_t best_intra_cost = INT64_MAX;
6224   int64_t intra_cost;
6225   PREDICTION_MODE mode;
6226   int mb_y_offset = mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6227   MODE_INFO mi_above, mi_left;
6228   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6229   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6230   TplDepStats *tpl_stats =
6231       &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6232
6233   xd->mb_to_top_edge = -((mi_row * MI_SIZE) * 8);
6234   xd->mb_to_bottom_edge = ((cm->mi_rows - 1 - mi_row) * MI_SIZE) * 8;
6235   xd->mb_to_left_edge = -((mi_col * MI_SIZE) * 8);
6236   xd->mb_to_right_edge = ((cm->mi_cols - 1 - mi_col) * MI_SIZE) * 8;
6237   xd->above_mi = (mi_row > 0) ? &mi_above : NULL;
6238   xd->left_mi = (mi_col > 0) ? &mi_left : NULL;
6239
6240   // Intra prediction search
6241   for (mode = DC_PRED; mode <= TM_PRED; ++mode) {
6242     uint8_t *src, *dst;
6243     int src_stride, dst_stride;
6244
6245     src = xd->cur_buf->y_buffer + mb_y_offset;
6246     src_stride = xd->cur_buf->y_stride;
6247
6248     dst = &predictor[0];
6249     dst_stride = bw;
6250
6251     xd->mi[0]->sb_type = bsize;
6252     xd->mi[0]->ref_frame[0] = INTRA_FRAME;
6253
6254     vp9_predict_intra_block(xd, b_width_log2_lookup[bsize], tx_size, mode, src,
6255                             src_stride, dst, dst_stride, 0, 0, 0);
6256
6257 #if CONFIG_VP9_HIGHBITDEPTH
6258     if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6259       vpx_highbd_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst,
6260                                 dst_stride, xd->bd);
6261       highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6262       intra_cost = vpx_highbd_satd(coeff, pix_num);
6263     } else {
6264       vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst,
6265                          dst_stride);
6266       wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6267       intra_cost = vpx_satd(coeff, pix_num);
6268     }
6269 #else
6270     vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst, dst_stride);
6271     wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6272     intra_cost = vpx_satd(coeff, pix_num);
6273 #endif  // CONFIG_VP9_HIGHBITDEPTH
6274
6275     if (intra_cost < best_intra_cost) best_intra_cost = intra_cost;
6276   }
6277
6278   // Motion compensated prediction
6279   best_mv.as_int = 0;
6280
6281   set_mv_limits(cm, x, mi_row, mi_col);
6282
6283   for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6284     int_mv mv;
6285 #if CONFIG_NON_GREEDY_MV
6286     MotionField *motion_field;
6287 #endif
6288     if (ref_frame[rf_idx] == NULL) continue;
6289
6290 #if CONFIG_NON_GREEDY_MV
6291     (void)td;
6292     motion_field = vp9_motion_field_info_get_motion_field(
6293         &cpi->motion_field_info, frame_idx, rf_idx, bsize);
6294     mv = vp9_motion_field_mi_get_mv(motion_field, mi_row, mi_col);
6295 #else
6296     motion_compensated_prediction(cpi, td, xd->cur_buf->y_buffer + mb_y_offset,
6297                                   ref_frame[rf_idx]->y_buffer + mb_y_offset,
6298                                   xd->cur_buf->y_stride, bsize, &mv.as_mv);
6299 #endif
6300
6301 #if CONFIG_VP9_HIGHBITDEPTH
6302     if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6303       vp9_highbd_build_inter_predictor(
6304           CONVERT_TO_SHORTPTR(ref_frame[rf_idx]->y_buffer + mb_y_offset),
6305           ref_frame[rf_idx]->y_stride, CONVERT_TO_SHORTPTR(&predictor[0]), bw,
6306           &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE,
6307           mi_row * MI_SIZE, xd->bd);
6308       vpx_highbd_subtract_block(
6309           bh, bw, src_diff, bw, xd->cur_buf->y_buffer + mb_y_offset,
6310           xd->cur_buf->y_stride, &predictor[0], bw, xd->bd);
6311       highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6312       inter_cost = vpx_highbd_satd(coeff, pix_num);
6313     } else {
6314       vp9_build_inter_predictor(
6315           ref_frame[rf_idx]->y_buffer + mb_y_offset,
6316           ref_frame[rf_idx]->y_stride, &predictor[0], bw, &mv.as_mv, sf, bw, bh,
6317           0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE, mi_row * MI_SIZE);
6318       vpx_subtract_block(bh, bw, src_diff, bw,
6319                          xd->cur_buf->y_buffer + mb_y_offset,
6320                          xd->cur_buf->y_stride, &predictor[0], bw);
6321       wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6322       inter_cost = vpx_satd(coeff, pix_num);
6323     }
6324 #else
6325     vp9_build_inter_predictor(ref_frame[rf_idx]->y_buffer + mb_y_offset,
6326                               ref_frame[rf_idx]->y_stride, &predictor[0], bw,
6327                               &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3,
6328                               mi_col * MI_SIZE, mi_row * MI_SIZE);
6329     vpx_subtract_block(bh, bw, src_diff, bw,
6330                        xd->cur_buf->y_buffer + mb_y_offset,
6331                        xd->cur_buf->y_stride, &predictor[0], bw);
6332     wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6333     inter_cost = vpx_satd(coeff, pix_num);
6334 #endif
6335
6336     if (inter_cost < best_inter_cost) {
6337       best_rf_idx = rf_idx;
6338       best_inter_cost = inter_cost;
6339       best_mv.as_int = mv.as_int;
6340       get_quantize_error(x, 0, coeff, qcoeff, dqcoeff, tx_size, recon_error,
6341                          sse);
6342     }
6343   }
6344   best_intra_cost = VPXMAX(best_intra_cost, 1);
6345   best_inter_cost = VPXMIN(best_intra_cost, best_inter_cost);
6346   tpl_stats->inter_cost = VPXMAX(
6347       1, (best_inter_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width));
6348   tpl_stats->intra_cost = VPXMAX(
6349       1, (best_intra_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width));
6350   tpl_stats->ref_frame_index = gf_picture[frame_idx].ref_frame[best_rf_idx];
6351   tpl_stats->mv.as_int = best_mv.as_int;
6352 }
6353
6354 #if CONFIG_NON_GREEDY_MV
6355 static int get_block_src_pred_buf(MACROBLOCKD *xd, GF_PICTURE *gf_picture,
6356                                   int frame_idx, int rf_idx, int mi_row,
6357                                   int mi_col, struct buf_2d *src,
6358                                   struct buf_2d *pre) {
6359   const int mb_y_offset =
6360       mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6361   YV12_BUFFER_CONFIG *ref_frame = NULL;
6362   int ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6363   if (ref_frame_idx != -1) {
6364     ref_frame = gf_picture[ref_frame_idx].frame;
6365     src->buf = xd->cur_buf->y_buffer + mb_y_offset;
6366     src->stride = xd->cur_buf->y_stride;
6367     pre->buf = ref_frame->y_buffer + mb_y_offset;
6368     pre->stride = ref_frame->y_stride;
6369     assert(src->stride == pre->stride);
6370     return 1;
6371   } else {
6372     printf("invalid ref_frame_idx");
6373     assert(ref_frame_idx != -1);
6374     return 0;
6375   }
6376 }
6377
6378 #define kMvPreCheckLines 5
6379 #define kMvPreCheckSize 15
6380
6381 #define MV_REF_POS_NUM 3
6382 POSITION mv_ref_pos[MV_REF_POS_NUM] = {
6383   { -1, 0 },
6384   { 0, -1 },
6385   { -1, -1 },
6386 };
6387
6388 static int_mv *get_select_mv(VP9_COMP *cpi, TplDepFrame *tpl_frame, int mi_row,
6389                              int mi_col) {
6390   return &cpi->select_mv_arr[mi_row * tpl_frame->stride + mi_col];
6391 }
6392
6393 static int_mv find_ref_mv(int mv_mode, VP9_COMP *cpi, TplDepFrame *tpl_frame,
6394                           BLOCK_SIZE bsize, int mi_row, int mi_col) {
6395   int i;
6396   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6397   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6398   int_mv nearest_mv, near_mv, invalid_mv;
6399   nearest_mv.as_int = INVALID_MV;
6400   near_mv.as_int = INVALID_MV;
6401   invalid_mv.as_int = INVALID_MV;
6402   for (i = 0; i < MV_REF_POS_NUM; ++i) {
6403     int nb_row = mi_row + mv_ref_pos[i].row * mi_height;
6404     int nb_col = mi_col + mv_ref_pos[i].col * mi_width;
6405     assert(mv_ref_pos[i].row <= 0);
6406     assert(mv_ref_pos[i].col <= 0);
6407     if (nb_row >= 0 && nb_col >= 0) {
6408       if (nearest_mv.as_int == INVALID_MV) {
6409         nearest_mv = *get_select_mv(cpi, tpl_frame, nb_row, nb_col);
6410       } else {
6411         int_mv mv = *get_select_mv(cpi, tpl_frame, nb_row, nb_col);
6412         if (mv.as_int == nearest_mv.as_int) {
6413           continue;
6414         } else {
6415           near_mv = mv;
6416           break;
6417         }
6418       }
6419     }
6420   }
6421   if (nearest_mv.as_int == INVALID_MV) {
6422     nearest_mv.as_mv.row = 0;
6423     nearest_mv.as_mv.col = 0;
6424   }
6425   if (near_mv.as_int == INVALID_MV) {
6426     near_mv.as_mv.row = 0;
6427     near_mv.as_mv.col = 0;
6428   }
6429   if (mv_mode == NEAREST_MV_MODE) {
6430     return nearest_mv;
6431   }
6432   if (mv_mode == NEAR_MV_MODE) {
6433     return near_mv;
6434   }
6435   assert(0);
6436   return invalid_mv;
6437 }
6438
6439 static int_mv get_mv_from_mv_mode(int mv_mode, VP9_COMP *cpi,
6440                                   MotionField *motion_field,
6441                                   TplDepFrame *tpl_frame, BLOCK_SIZE bsize,
6442                                   int mi_row, int mi_col) {
6443   int_mv mv;
6444   switch (mv_mode) {
6445     case ZERO_MV_MODE:
6446       mv.as_mv.row = 0;
6447       mv.as_mv.col = 0;
6448       break;
6449     case NEW_MV_MODE:
6450       mv = vp9_motion_field_mi_get_mv(motion_field, mi_row, mi_col);
6451       break;
6452     case NEAREST_MV_MODE:
6453       mv = find_ref_mv(mv_mode, cpi, tpl_frame, bsize, mi_row, mi_col);
6454       break;
6455     case NEAR_MV_MODE:
6456       mv = find_ref_mv(mv_mode, cpi, tpl_frame, bsize, mi_row, mi_col);
6457       break;
6458     default:
6459       mv.as_int = INVALID_MV;
6460       assert(0);
6461       break;
6462   }
6463   return mv;
6464 }
6465
6466 static double get_mv_dist(int mv_mode, VP9_COMP *cpi, MACROBLOCKD *xd,
6467                           GF_PICTURE *gf_picture, MotionField *motion_field,
6468                           int frame_idx, TplDepFrame *tpl_frame, int rf_idx,
6469                           BLOCK_SIZE bsize, int mi_row, int mi_col,
6470                           int_mv *mv) {
6471   uint32_t sse;
6472   struct buf_2d src;
6473   struct buf_2d pre;
6474   MV full_mv;
6475   *mv = get_mv_from_mv_mode(mv_mode, cpi, motion_field, tpl_frame, bsize,
6476                             mi_row, mi_col);
6477   full_mv = get_full_mv(&mv->as_mv);
6478   if (get_block_src_pred_buf(xd, gf_picture, frame_idx, rf_idx, mi_row, mi_col,
6479                              &src, &pre)) {
6480     // TODO(angiebird): Consider subpixel when computing the sse.
6481     cpi->fn_ptr[bsize].vf(src.buf, src.stride, get_buf_from_mv(&pre, &full_mv),
6482                           pre.stride, &sse);
6483     return (double)(sse << VP9_DIST_SCALE_LOG2);
6484   } else {
6485     assert(0);
6486     return 0;
6487   }
6488 }
6489
6490 static int get_mv_mode_cost(int mv_mode) {
6491   // TODO(angiebird): The probabilities are roughly inferred from
6492   // default_inter_mode_probs. Check if there is a better way to set the
6493   // probabilities.
6494   const int zero_mv_prob = 16;
6495   const int new_mv_prob = 24 * 1;
6496   const int ref_mv_prob = 256 - zero_mv_prob - new_mv_prob;
6497   assert(zero_mv_prob + new_mv_prob + ref_mv_prob == 256);
6498   switch (mv_mode) {
6499     case ZERO_MV_MODE: return vp9_prob_cost[zero_mv_prob]; break;
6500     case NEW_MV_MODE: return vp9_prob_cost[new_mv_prob]; break;
6501     case NEAREST_MV_MODE: return vp9_prob_cost[ref_mv_prob]; break;
6502     case NEAR_MV_MODE: return vp9_prob_cost[ref_mv_prob]; break;
6503     default: assert(0); return -1;
6504   }
6505 }
6506
6507 static INLINE double get_mv_diff_cost(MV *new_mv, MV *ref_mv) {
6508   double mv_diff_cost = log2(1 + abs(new_mv->row - ref_mv->row)) +
6509                         log2(1 + abs(new_mv->col - ref_mv->col));
6510   mv_diff_cost *= (1 << VP9_PROB_COST_SHIFT);
6511   return mv_diff_cost;
6512 }
6513 static double get_mv_cost(int mv_mode, VP9_COMP *cpi, MotionField *motion_field,
6514                           TplDepFrame *tpl_frame, BLOCK_SIZE bsize, int mi_row,
6515                           int mi_col) {
6516   double mv_cost = get_mv_mode_cost(mv_mode);
6517   if (mv_mode == NEW_MV_MODE) {
6518     MV new_mv = get_mv_from_mv_mode(mv_mode, cpi, motion_field, tpl_frame,
6519                                     bsize, mi_row, mi_col)
6520                     .as_mv;
6521     MV nearest_mv = get_mv_from_mv_mode(NEAREST_MV_MODE, cpi, motion_field,
6522                                         tpl_frame, bsize, mi_row, mi_col)
6523                         .as_mv;
6524     MV near_mv = get_mv_from_mv_mode(NEAR_MV_MODE, cpi, motion_field, tpl_frame,
6525                                      bsize, mi_row, mi_col)
6526                      .as_mv;
6527     double nearest_cost = get_mv_diff_cost(&new_mv, &nearest_mv);
6528     double near_cost = get_mv_diff_cost(&new_mv, &near_mv);
6529     mv_cost += nearest_cost < near_cost ? nearest_cost : near_cost;
6530   }
6531   return mv_cost;
6532 }
6533
6534 static double eval_mv_mode(int mv_mode, VP9_COMP *cpi, MACROBLOCK *x,
6535                            GF_PICTURE *gf_picture, MotionField *motion_field,
6536                            int frame_idx, TplDepFrame *tpl_frame, int rf_idx,
6537                            BLOCK_SIZE bsize, int mi_row, int mi_col,
6538                            int_mv *mv) {
6539   MACROBLOCKD *xd = &x->e_mbd;
6540   double mv_dist =
6541       get_mv_dist(mv_mode, cpi, xd, gf_picture, motion_field, frame_idx,
6542                   tpl_frame, rf_idx, bsize, mi_row, mi_col, mv);
6543   double mv_cost =
6544       get_mv_cost(mv_mode, cpi, motion_field, tpl_frame, bsize, mi_row, mi_col);
6545   double mult = 180;
6546
6547   return mv_cost + mult * log2f(1 + mv_dist);
6548 }
6549
6550 static int find_best_ref_mv_mode(VP9_COMP *cpi, MACROBLOCK *x,
6551                                  GF_PICTURE *gf_picture,
6552                                  MotionField *motion_field, int frame_idx,
6553                                  TplDepFrame *tpl_frame, int rf_idx,
6554                                  BLOCK_SIZE bsize, int mi_row, int mi_col,
6555                                  double *rd, int_mv *mv) {
6556   int best_mv_mode = ZERO_MV_MODE;
6557   int update = 0;
6558   int mv_mode;
6559   *rd = 0;
6560   for (mv_mode = 0; mv_mode < MAX_MV_MODE; ++mv_mode) {
6561     double this_rd;
6562     int_mv this_mv;
6563     if (mv_mode == NEW_MV_MODE) {
6564       continue;
6565     }
6566     this_rd = eval_mv_mode(mv_mode, cpi, x, gf_picture, motion_field, frame_idx,
6567                            tpl_frame, rf_idx, bsize, mi_row, mi_col, &this_mv);
6568     if (update == 0) {
6569       *rd = this_rd;
6570       *mv = this_mv;
6571       best_mv_mode = mv_mode;
6572       update = 1;
6573     } else {
6574       if (this_rd < *rd) {
6575         *rd = this_rd;
6576         *mv = this_mv;
6577         best_mv_mode = mv_mode;
6578       }
6579     }
6580   }
6581   return best_mv_mode;
6582 }
6583
6584 static void predict_mv_mode(VP9_COMP *cpi, MACROBLOCK *x,
6585                             GF_PICTURE *gf_picture, MotionField *motion_field,
6586                             int frame_idx, TplDepFrame *tpl_frame, int rf_idx,
6587                             BLOCK_SIZE bsize, int mi_row, int mi_col) {
6588   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6589   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6590   int tmp_mv_mode_arr[kMvPreCheckSize];
6591   int *mv_mode_arr = tpl_frame->mv_mode_arr[rf_idx];
6592   double *rd_diff_arr = tpl_frame->rd_diff_arr[rf_idx];
6593   int_mv *select_mv_arr = cpi->select_mv_arr;
6594   int_mv tmp_select_mv_arr[kMvPreCheckSize];
6595   int stride = tpl_frame->stride;
6596   double new_mv_rd = 0;
6597   double no_new_mv_rd = 0;
6598   double this_new_mv_rd = 0;
6599   double this_no_new_mv_rd = 0;
6600   int idx;
6601   int tmp_idx;
6602   assert(kMvPreCheckSize == (kMvPreCheckLines * (kMvPreCheckLines + 1)) >> 1);
6603
6604   // no new mv
6605   // diagnal scan order
6606   tmp_idx = 0;
6607   for (idx = 0; idx < kMvPreCheckLines; ++idx) {
6608     int r;
6609     for (r = 0; r <= idx; ++r) {
6610       int c = idx - r;
6611       int nb_row = mi_row + r * mi_height;
6612       int nb_col = mi_col + c * mi_width;
6613       if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6614         double this_rd;
6615         int_mv *mv = &select_mv_arr[nb_row * stride + nb_col];
6616         mv_mode_arr[nb_row * stride + nb_col] = find_best_ref_mv_mode(
6617             cpi, x, gf_picture, motion_field, frame_idx, tpl_frame, rf_idx,
6618             bsize, nb_row, nb_col, &this_rd, mv);
6619         if (r == 0 && c == 0) {
6620           this_no_new_mv_rd = this_rd;
6621         }
6622         no_new_mv_rd += this_rd;
6623         tmp_mv_mode_arr[tmp_idx] = mv_mode_arr[nb_row * stride + nb_col];
6624         tmp_select_mv_arr[tmp_idx] = select_mv_arr[nb_row * stride + nb_col];
6625         ++tmp_idx;
6626       }
6627     }
6628   }
6629
6630   // new mv
6631   mv_mode_arr[mi_row * stride + mi_col] = NEW_MV_MODE;
6632   this_new_mv_rd = eval_mv_mode(
6633       NEW_MV_MODE, cpi, x, gf_picture, motion_field, frame_idx, tpl_frame,
6634       rf_idx, bsize, mi_row, mi_col, &select_mv_arr[mi_row * stride + mi_col]);
6635   new_mv_rd = this_new_mv_rd;
6636   // We start from idx = 1 because idx = 0 is evaluated as NEW_MV_MODE
6637   // beforehand.
6638   for (idx = 1; idx < kMvPreCheckLines; ++idx) {
6639     int r;
6640     for (r = 0; r <= idx; ++r) {
6641       int c = idx - r;
6642       int nb_row = mi_row + r * mi_height;
6643       int nb_col = mi_col + c * mi_width;
6644       if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6645         double this_rd;
6646         int_mv *mv = &select_mv_arr[nb_row * stride + nb_col];
6647         mv_mode_arr[nb_row * stride + nb_col] = find_best_ref_mv_mode(
6648             cpi, x, gf_picture, motion_field, frame_idx, tpl_frame, rf_idx,
6649             bsize, nb_row, nb_col, &this_rd, mv);
6650         new_mv_rd += this_rd;
6651       }
6652     }
6653   }
6654
6655   // update best_mv_mode
6656   tmp_idx = 0;
6657   if (no_new_mv_rd < new_mv_rd) {
6658     for (idx = 0; idx < kMvPreCheckLines; ++idx) {
6659       int r;
6660       for (r = 0; r <= idx; ++r) {
6661         int c = idx - r;
6662         int nb_row = mi_row + r * mi_height;
6663         int nb_col = mi_col + c * mi_width;
6664         if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6665           mv_mode_arr[nb_row * stride + nb_col] = tmp_mv_mode_arr[tmp_idx];
6666           select_mv_arr[nb_row * stride + nb_col] = tmp_select_mv_arr[tmp_idx];
6667           ++tmp_idx;
6668         }
6669       }
6670     }
6671     rd_diff_arr[mi_row * stride + mi_col] = 0;
6672   } else {
6673     rd_diff_arr[mi_row * stride + mi_col] =
6674         (no_new_mv_rd - this_no_new_mv_rd) - (new_mv_rd - this_new_mv_rd);
6675   }
6676 }
6677
6678 static void predict_mv_mode_arr(VP9_COMP *cpi, MACROBLOCK *x,
6679                                 GF_PICTURE *gf_picture,
6680                                 MotionField *motion_field, int frame_idx,
6681                                 TplDepFrame *tpl_frame, int rf_idx,
6682                                 BLOCK_SIZE bsize) {
6683   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6684   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6685   const int unit_rows = tpl_frame->mi_rows / mi_height;
6686   const int unit_cols = tpl_frame->mi_cols / mi_width;
6687   const int max_diagonal_lines = unit_rows + unit_cols - 1;
6688   int idx;
6689   for (idx = 0; idx < max_diagonal_lines; ++idx) {
6690     int r;
6691     for (r = VPXMAX(idx - unit_cols + 1, 0); r <= VPXMIN(idx, unit_rows - 1);
6692          ++r) {
6693       int c = idx - r;
6694       int mi_row = r * mi_height;
6695       int mi_col = c * mi_width;
6696       assert(c >= 0 && c < unit_cols);
6697       assert(mi_row >= 0 && mi_row < tpl_frame->mi_rows);
6698       assert(mi_col >= 0 && mi_col < tpl_frame->mi_cols);
6699       predict_mv_mode(cpi, x, gf_picture, motion_field, frame_idx, tpl_frame,
6700                       rf_idx, bsize, mi_row, mi_col);
6701     }
6702   }
6703 }
6704
6705 static void do_motion_search(VP9_COMP *cpi, ThreadData *td,
6706                              MotionField *motion_field, int frame_idx,
6707                              YV12_BUFFER_CONFIG *ref_frame, BLOCK_SIZE bsize,
6708                              int mi_row, int mi_col) {
6709   VP9_COMMON *cm = &cpi->common;
6710   MACROBLOCK *x = &td->mb;
6711   MACROBLOCKD *xd = &x->e_mbd;
6712   const int mb_y_offset =
6713       mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6714   assert(ref_frame != NULL);
6715   set_mv_limits(cm, x, mi_row, mi_col);
6716   {
6717     int_mv mv = vp9_motion_field_mi_get_mv(motion_field, mi_row, mi_col);
6718     uint8_t *cur_frame_buf = xd->cur_buf->y_buffer + mb_y_offset;
6719     uint8_t *ref_frame_buf = ref_frame->y_buffer + mb_y_offset;
6720     const int stride = xd->cur_buf->y_stride;
6721     full_pixel_motion_search(cpi, td, motion_field, frame_idx, cur_frame_buf,
6722                              ref_frame_buf, stride, bsize, mi_row, mi_col,
6723                              &mv.as_mv);
6724     sub_pixel_motion_search(cpi, td, cur_frame_buf, ref_frame_buf, stride,
6725                             bsize, &mv.as_mv);
6726     vp9_motion_field_mi_set_mv(motion_field, mi_row, mi_col, mv);
6727   }
6728 }
6729
6730 static void build_motion_field(
6731     VP9_COMP *cpi, int frame_idx,
6732     YV12_BUFFER_CONFIG *ref_frame[MAX_INTER_REF_FRAMES], BLOCK_SIZE bsize) {
6733   VP9_COMMON *cm = &cpi->common;
6734   ThreadData *td = &cpi->td;
6735   TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6736   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6737   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6738   const int pw = num_4x4_blocks_wide_lookup[bsize] << 2;
6739   const int ph = num_4x4_blocks_high_lookup[bsize] << 2;
6740   int mi_row, mi_col;
6741   int rf_idx;
6742
6743   tpl_frame->lambda = (pw * ph) >> 2;
6744   assert(pw * ph == tpl_frame->lambda << 2);
6745
6746   for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6747     MotionField *motion_field = vp9_motion_field_info_get_motion_field(
6748         &cpi->motion_field_info, frame_idx, rf_idx, bsize);
6749     if (ref_frame[rf_idx] == NULL) {
6750       continue;
6751     }
6752     vp9_motion_field_reset_mvs(motion_field);
6753     for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6754       for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6755         do_motion_search(cpi, td, motion_field, frame_idx, ref_frame[rf_idx],
6756                          bsize, mi_row, mi_col);
6757       }
6758     }
6759   }
6760 }
6761 #endif  // CONFIG_NON_GREEDY_MV
6762
6763 static void mc_flow_dispenser(VP9_COMP *cpi, GF_PICTURE *gf_picture,
6764                               int frame_idx, BLOCK_SIZE bsize) {
6765   TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6766   YV12_BUFFER_CONFIG *this_frame = gf_picture[frame_idx].frame;
6767   YV12_BUFFER_CONFIG *ref_frame[MAX_INTER_REF_FRAMES] = { NULL, NULL, NULL };
6768
6769   VP9_COMMON *cm = &cpi->common;
6770   struct scale_factors sf;
6771   int rdmult, idx;
6772   ThreadData *td = &cpi->td;
6773   MACROBLOCK *x = &td->mb;
6774   MACROBLOCKD *xd = &x->e_mbd;
6775   int mi_row, mi_col;
6776
6777 #if CONFIG_VP9_HIGHBITDEPTH
6778   DECLARE_ALIGNED(16, uint16_t, predictor16[32 * 32 * 3]);
6779   DECLARE_ALIGNED(16, uint8_t, predictor8[32 * 32 * 3]);
6780   uint8_t *predictor;
6781 #else
6782   DECLARE_ALIGNED(16, uint8_t, predictor[32 * 32 * 3]);
6783 #endif
6784   DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]);
6785   DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]);
6786   DECLARE_ALIGNED(16, tran_low_t, qcoeff[32 * 32]);
6787   DECLARE_ALIGNED(16, tran_low_t, dqcoeff[32 * 32]);
6788
6789   const TX_SIZE tx_size = max_txsize_lookup[bsize];
6790   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6791   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6792   int64_t recon_error, sse;
6793 #if CONFIG_NON_GREEDY_MV
6794   int square_block_idx;
6795   int rf_idx;
6796 #endif
6797
6798   // Setup scaling factor
6799 #if CONFIG_VP9_HIGHBITDEPTH
6800   vp9_setup_scale_factors_for_frame(
6801       &sf, this_frame->y_crop_width, this_frame->y_crop_height,
6802       this_frame->y_crop_width, this_frame->y_crop_height,
6803       cpi->common.use_highbitdepth);
6804
6805   if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH)
6806     predictor = CONVERT_TO_BYTEPTR(predictor16);
6807   else
6808     predictor = predictor8;
6809 #else
6810   vp9_setup_scale_factors_for_frame(
6811       &sf, this_frame->y_crop_width, this_frame->y_crop_height,
6812       this_frame->y_crop_width, this_frame->y_crop_height);
6813 #endif  // CONFIG_VP9_HIGHBITDEPTH
6814
6815   // Prepare reference frame pointers. If any reference frame slot is
6816   // unavailable, the pointer will be set to Null.
6817   for (idx = 0; idx < MAX_INTER_REF_FRAMES; ++idx) {
6818     int rf_idx = gf_picture[frame_idx].ref_frame[idx];
6819     if (rf_idx != -1) ref_frame[idx] = gf_picture[rf_idx].frame;
6820   }
6821
6822   xd->mi = cm->mi_grid_visible;
6823   xd->mi[0] = cm->mi;
6824   xd->cur_buf = this_frame;
6825
6826   // Get rd multiplier set up.
6827   rdmult = vp9_compute_rd_mult_based_on_qindex(cpi, tpl_frame->base_qindex);
6828   set_error_per_bit(&cpi->td.mb, rdmult);
6829   vp9_initialize_me_consts(cpi, &cpi->td.mb, tpl_frame->base_qindex);
6830
6831   tpl_frame->is_valid = 1;
6832
6833   cm->base_qindex = tpl_frame->base_qindex;
6834   vp9_frame_init_quantizer(cpi);
6835
6836 #if CONFIG_NON_GREEDY_MV
6837   for (square_block_idx = 0; square_block_idx < SQUARE_BLOCK_SIZES;
6838        ++square_block_idx) {
6839     BLOCK_SIZE square_bsize = square_block_idx_to_bsize(square_block_idx);
6840     build_motion_field(cpi, frame_idx, ref_frame, square_bsize);
6841   }
6842   for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6843     int ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6844     if (ref_frame_idx != -1) {
6845       MotionField *motion_field = vp9_motion_field_info_get_motion_field(
6846           &cpi->motion_field_info, frame_idx, rf_idx, bsize);
6847       predict_mv_mode_arr(cpi, x, gf_picture, motion_field, frame_idx,
6848                           tpl_frame, rf_idx, bsize);
6849     }
6850   }
6851 #endif
6852
6853   for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6854     for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6855       mode_estimation(cpi, x, xd, &sf, gf_picture, frame_idx, tpl_frame,
6856                       src_diff, coeff, qcoeff, dqcoeff, mi_row, mi_col, bsize,
6857                       tx_size, ref_frame, predictor, &recon_error, &sse);
6858       // Motion flow dependency dispenser.
6859       tpl_model_store(tpl_frame->tpl_stats_ptr, mi_row, mi_col, bsize,
6860                       tpl_frame->stride);
6861
6862       tpl_model_update(cpi->tpl_stats, tpl_frame->tpl_stats_ptr, mi_row, mi_col,
6863                        bsize);
6864     }
6865   }
6866 }
6867
6868 #if CONFIG_NON_GREEDY_MV
6869 #define DUMP_TPL_STATS 0
6870 #if DUMP_TPL_STATS
6871 static void dump_buf(uint8_t *buf, int stride, int row, int col, int h, int w) {
6872   int i, j;
6873   printf("%d %d\n", h, w);
6874   for (i = 0; i < h; ++i) {
6875     for (j = 0; j < w; ++j) {
6876       printf("%d ", buf[(row + i) * stride + col + j]);
6877     }
6878   }
6879   printf("\n");
6880 }
6881
6882 static void dump_frame_buf(const YV12_BUFFER_CONFIG *frame_buf) {
6883   dump_buf(frame_buf->y_buffer, frame_buf->y_stride, 0, 0, frame_buf->y_height,
6884            frame_buf->y_width);
6885   dump_buf(frame_buf->u_buffer, frame_buf->uv_stride, 0, 0,
6886            frame_buf->uv_height, frame_buf->uv_width);
6887   dump_buf(frame_buf->v_buffer, frame_buf->uv_stride, 0, 0,
6888            frame_buf->uv_height, frame_buf->uv_width);
6889 }
6890
6891 static void dump_tpl_stats(const VP9_COMP *cpi, int tpl_group_frames,
6892                            const GF_GROUP *gf_group,
6893                            const GF_PICTURE *gf_picture, BLOCK_SIZE bsize) {
6894   int frame_idx;
6895   const VP9_COMMON *cm = &cpi->common;
6896   int rf_idx;
6897   for (frame_idx = 1; frame_idx < tpl_group_frames; ++frame_idx) {
6898     for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6899       const TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6900       int mi_row, mi_col;
6901       int ref_frame_idx;
6902       const int mi_height = num_8x8_blocks_high_lookup[bsize];
6903       const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6904       ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6905       if (ref_frame_idx != -1) {
6906         YV12_BUFFER_CONFIG *ref_frame_buf = gf_picture[ref_frame_idx].frame;
6907         const int gf_frame_offset = gf_group->frame_gop_index[frame_idx];
6908         const int ref_gf_frame_offset =
6909             gf_group->frame_gop_index[ref_frame_idx];
6910         printf("=\n");
6911         printf(
6912             "frame_idx %d mi_rows %d mi_cols %d bsize %d ref_frame_idx %d "
6913             "rf_idx %d gf_frame_offset %d ref_gf_frame_offset %d\n",
6914             frame_idx, cm->mi_rows, cm->mi_cols, mi_width * MI_SIZE,
6915             ref_frame_idx, rf_idx, gf_frame_offset, ref_gf_frame_offset);
6916         for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) {
6917           for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
6918             if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) {
6919               int_mv mv = vp9_motion_field_info_get_mv(&cpi->motion_field_info,
6920                                                        frame_idx, rf_idx, bsize,
6921                                                        mi_row, mi_col);
6922               printf("%d %d %d %d\n", mi_row, mi_col, mv.as_mv.row,
6923                      mv.as_mv.col);
6924             }
6925           }
6926         }
6927         for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) {
6928           for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
6929             if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) {
6930               const TplDepStats *tpl_ptr =
6931                   &tpl_frame
6932                        ->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6933               printf("%f ", tpl_ptr->feature_score);
6934             }
6935           }
6936         }
6937         printf("\n");
6938
6939         for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6940           for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6941             const int mv_mode =
6942                 tpl_frame
6943                     ->mv_mode_arr[rf_idx][mi_row * tpl_frame->stride + mi_col];
6944             printf("%d ", mv_mode);
6945           }
6946         }
6947         printf("\n");
6948
6949         dump_frame_buf(gf_picture[frame_idx].frame);
6950         dump_frame_buf(ref_frame_buf);
6951       }
6952     }
6953   }
6954 }
6955 #endif  // DUMP_TPL_STATS
6956 #endif  // CONFIG_NON_GREEDY_MV
6957
6958 static void init_tpl_buffer(VP9_COMP *cpi) {
6959   VP9_COMMON *cm = &cpi->common;
6960   int frame;
6961
6962   const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
6963   const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
6964 #if CONFIG_NON_GREEDY_MV
6965   int rf_idx;
6966
6967   vpx_free(cpi->select_mv_arr);
6968   CHECK_MEM_ERROR(
6969       cm, cpi->select_mv_arr,
6970       vpx_calloc(mi_rows * mi_cols * 4, sizeof(*cpi->select_mv_arr)));
6971 #endif
6972
6973   // TODO(jingning): Reduce the actual memory use for tpl model build up.
6974   for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) {
6975     if (cpi->tpl_stats[frame].width >= mi_cols &&
6976         cpi->tpl_stats[frame].height >= mi_rows &&
6977         cpi->tpl_stats[frame].tpl_stats_ptr)
6978       continue;
6979
6980 #if CONFIG_NON_GREEDY_MV
6981     for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6982       vpx_free(cpi->tpl_stats[frame].mv_mode_arr[rf_idx]);
6983       CHECK_MEM_ERROR(
6984           cm, cpi->tpl_stats[frame].mv_mode_arr[rf_idx],
6985           vpx_calloc(mi_rows * mi_cols * 4,
6986                      sizeof(*cpi->tpl_stats[frame].mv_mode_arr[rf_idx])));
6987       vpx_free(cpi->tpl_stats[frame].rd_diff_arr[rf_idx]);
6988       CHECK_MEM_ERROR(
6989           cm, cpi->tpl_stats[frame].rd_diff_arr[rf_idx],
6990           vpx_calloc(mi_rows * mi_cols * 4,
6991                      sizeof(*cpi->tpl_stats[frame].rd_diff_arr[rf_idx])));
6992     }
6993 #endif
6994     vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr);
6995     CHECK_MEM_ERROR(cm, cpi->tpl_stats[frame].tpl_stats_ptr,
6996                     vpx_calloc(mi_rows * mi_cols,
6997                                sizeof(*cpi->tpl_stats[frame].tpl_stats_ptr)));
6998     cpi->tpl_stats[frame].is_valid = 0;
6999     cpi->tpl_stats[frame].width = mi_cols;
7000     cpi->tpl_stats[frame].height = mi_rows;
7001     cpi->tpl_stats[frame].stride = mi_cols;
7002     cpi->tpl_stats[frame].mi_rows = cm->mi_rows;
7003     cpi->tpl_stats[frame].mi_cols = cm->mi_cols;
7004   }
7005
7006   for (frame = 0; frame < REF_FRAMES; ++frame) {
7007     cpi->enc_frame_buf[frame].mem_valid = 0;
7008     cpi->enc_frame_buf[frame].released = 1;
7009   }
7010 }
7011
7012 static void free_tpl_buffer(VP9_COMP *cpi) {
7013   int frame;
7014 #if CONFIG_NON_GREEDY_MV
7015   vp9_free_motion_field_info(&cpi->motion_field_info);
7016   vpx_free(cpi->select_mv_arr);
7017 #endif
7018   for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) {
7019 #if CONFIG_NON_GREEDY_MV
7020     int rf_idx;
7021     for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
7022       vpx_free(cpi->tpl_stats[frame].mv_mode_arr[rf_idx]);
7023       vpx_free(cpi->tpl_stats[frame].rd_diff_arr[rf_idx]);
7024     }
7025 #endif
7026     vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr);
7027     cpi->tpl_stats[frame].is_valid = 0;
7028   }
7029 }
7030
7031 static void setup_tpl_stats(VP9_COMP *cpi) {
7032   GF_PICTURE gf_picture[MAX_ARF_GOP_SIZE];
7033   const GF_GROUP *gf_group = &cpi->twopass.gf_group;
7034   int tpl_group_frames = 0;
7035   int frame_idx;
7036   cpi->tpl_bsize = BLOCK_32X32;
7037
7038   init_gop_frames(cpi, gf_picture, gf_group, &tpl_group_frames);
7039
7040   init_tpl_stats(cpi);
7041
7042   // Backward propagation from tpl_group_frames to 1.
7043   for (frame_idx = tpl_group_frames - 1; frame_idx > 0; --frame_idx) {
7044     if (gf_picture[frame_idx].update_type == USE_BUF_FRAME) continue;
7045     mc_flow_dispenser(cpi, gf_picture, frame_idx, cpi->tpl_bsize);
7046   }
7047 #if CONFIG_NON_GREEDY_MV
7048   cpi->tpl_ready = 1;
7049 #if DUMP_TPL_STATS
7050   dump_tpl_stats(cpi, tpl_group_frames, gf_group, gf_picture, cpi->tpl_bsize);
7051 #endif  // DUMP_TPL_STATS
7052 #endif  // CONFIG_NON_GREEDY_MV
7053 }
7054
7055 int vp9_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags,
7056                             size_t *size, uint8_t *dest, int64_t *time_stamp,
7057                             int64_t *time_end, int flush) {
7058   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
7059   VP9_COMMON *const cm = &cpi->common;
7060   BufferPool *const pool = cm->buffer_pool;
7061   RATE_CONTROL *const rc = &cpi->rc;
7062   struct vpx_usec_timer cmptimer;
7063   YV12_BUFFER_CONFIG *force_src_buffer = NULL;
7064   struct lookahead_entry *last_source = NULL;
7065   struct lookahead_entry *source = NULL;
7066   int arf_src_index;
7067   const int gf_group_index = cpi->twopass.gf_group.index;
7068   int i;
7069
7070   if (is_one_pass_cbr_svc(cpi)) {
7071     vp9_one_pass_cbr_svc_start_layer(cpi);
7072   }
7073
7074   vpx_usec_timer_start(&cmptimer);
7075
7076   vp9_set_high_precision_mv(cpi, ALTREF_HIGH_PRECISION_MV);
7077
7078   // Is multi-arf enabled.
7079   // Note that at the moment multi_arf is only configured for 2 pass VBR and
7080   // will not work properly with svc.
7081   // Enable the Jingning's new "multi_layer_arf" code if "enable_auto_arf"
7082   // is greater than or equal to 2.
7083   if ((oxcf->pass == 2) && !cpi->use_svc && (cpi->oxcf.enable_auto_arf >= 2))
7084     cpi->multi_layer_arf = 1;
7085   else
7086     cpi->multi_layer_arf = 0;
7087
7088   // Normal defaults
7089   cm->reset_frame_context = 0;
7090   cm->refresh_frame_context = 1;
7091   if (!is_one_pass_cbr_svc(cpi)) {
7092     cpi->refresh_last_frame = 1;
7093     cpi->refresh_golden_frame = 0;
7094     cpi->refresh_alt_ref_frame = 0;
7095   }
7096
7097   // Should we encode an arf frame.
7098   arf_src_index = get_arf_src_index(cpi);
7099
7100   if (arf_src_index) {
7101     for (i = 0; i <= arf_src_index; ++i) {
7102       struct lookahead_entry *e = vp9_lookahead_peek(cpi->lookahead, i);
7103       // Avoid creating an alt-ref if there's a forced keyframe pending.
7104       if (e == NULL) {
7105         break;
7106       } else if (e->flags == VPX_EFLAG_FORCE_KF) {
7107         arf_src_index = 0;
7108         flush = 1;
7109         break;
7110       }
7111     }
7112   }
7113
7114   // Clear arf index stack before group of pictures processing starts.
7115   if (gf_group_index == 1) {
7116     stack_init(cpi->twopass.gf_group.arf_index_stack, MAX_LAG_BUFFERS * 2);
7117     cpi->twopass.gf_group.stack_size = 0;
7118   }
7119
7120   if (arf_src_index) {
7121     assert(arf_src_index <= rc->frames_to_key);
7122     if ((source = vp9_lookahead_peek(cpi->lookahead, arf_src_index)) != NULL) {
7123       cpi->alt_ref_source = source;
7124
7125 #if !CONFIG_REALTIME_ONLY
7126       if ((oxcf->mode != REALTIME) && (oxcf->arnr_max_frames > 0) &&
7127           (oxcf->arnr_strength > 0)) {
7128         int bitrate = cpi->rc.avg_frame_bandwidth / 40;
7129         int not_low_bitrate = bitrate > ALT_REF_AQ_LOW_BITRATE_BOUNDARY;
7130
7131         int not_last_frame = (cpi->lookahead->sz - arf_src_index > 1);
7132         not_last_frame |= ALT_REF_AQ_APPLY_TO_LAST_FRAME;
7133
7134         // Produce the filtered ARF frame.
7135         vp9_temporal_filter(cpi, arf_src_index);
7136         vpx_extend_frame_borders(&cpi->alt_ref_buffer);
7137
7138         // for small bitrates segmentation overhead usually
7139         // eats all bitrate gain from enabling delta quantizers
7140         if (cpi->oxcf.alt_ref_aq != 0 && not_low_bitrate && not_last_frame)
7141           vp9_alt_ref_aq_setup_mode(cpi->alt_ref_aq, cpi);
7142
7143         force_src_buffer = &cpi->alt_ref_buffer;
7144       }
7145 #endif
7146       cm->show_frame = 0;
7147       cm->intra_only = 0;
7148       cpi->refresh_alt_ref_frame = 1;
7149       cpi->refresh_golden_frame = 0;
7150       cpi->refresh_last_frame = 0;
7151       rc->is_src_frame_alt_ref = 0;
7152       rc->source_alt_ref_pending = 0;
7153     } else {
7154       rc->source_alt_ref_pending = 0;
7155     }
7156   }
7157
7158   if (!source) {
7159     // Get last frame source.
7160     if (cm->current_video_frame > 0) {
7161       if ((last_source = vp9_lookahead_peek(cpi->lookahead, -1)) == NULL)
7162         return -1;
7163     }
7164
7165     // Read in the source frame.
7166     if (cpi->use_svc || cpi->svc.set_intra_only_frame)
7167       source = vp9_svc_lookahead_pop(cpi, cpi->lookahead, flush);
7168     else
7169       source = vp9_lookahead_pop(cpi->lookahead, flush);
7170
7171     if (source != NULL) {
7172       cm->show_frame = 1;
7173       cm->intra_only = 0;
7174       // If the flags indicate intra frame, but if the current picture is for
7175       // spatial layer above first_spatial_layer_to_encode, it should not be an
7176       // intra picture.
7177       if ((source->flags & VPX_EFLAG_FORCE_KF) && cpi->use_svc &&
7178           cpi->svc.spatial_layer_id > cpi->svc.first_spatial_layer_to_encode) {
7179         source->flags &= ~(unsigned int)(VPX_EFLAG_FORCE_KF);
7180       }
7181
7182       // Check to see if the frame should be encoded as an arf overlay.
7183       check_src_altref(cpi, source);
7184     }
7185   }
7186
7187   if (source) {
7188     cpi->un_scaled_source = cpi->Source =
7189         force_src_buffer ? force_src_buffer : &source->img;
7190
7191 #ifdef ENABLE_KF_DENOISE
7192     // Copy of raw source for metrics calculation.
7193     if (is_psnr_calc_enabled(cpi))
7194       vp9_copy_and_extend_frame(cpi->Source, &cpi->raw_unscaled_source);
7195 #endif
7196
7197     cpi->unscaled_last_source = last_source != NULL ? &last_source->img : NULL;
7198
7199     *time_stamp = source->ts_start;
7200     *time_end = source->ts_end;
7201     *frame_flags = (source->flags & VPX_EFLAG_FORCE_KF) ? FRAMEFLAGS_KEY : 0;
7202   } else {
7203     *size = 0;
7204 #if !CONFIG_REALTIME_ONLY
7205     if (flush && oxcf->pass == 1 && !cpi->twopass.first_pass_done) {
7206       vp9_end_first_pass(cpi); /* get last stats packet */
7207       cpi->twopass.first_pass_done = 1;
7208     }
7209 #endif  // !CONFIG_REALTIME_ONLY
7210     return -1;
7211   }
7212
7213   if (source->ts_start < cpi->first_time_stamp_ever) {
7214     cpi->first_time_stamp_ever = source->ts_start;
7215     cpi->last_end_time_stamp_seen = source->ts_start;
7216   }
7217
7218   // Clear down mmx registers
7219   vpx_clear_system_state();
7220
7221   // adjust frame rates based on timestamps given
7222   if (cm->show_frame) {
7223     if (cpi->use_svc && cpi->svc.use_set_ref_frame_config &&
7224         cpi->svc.duration[cpi->svc.spatial_layer_id] > 0)
7225       vp9_svc_adjust_frame_rate(cpi);
7226     else
7227       adjust_frame_rate(cpi, source);
7228   }
7229
7230   if (is_one_pass_cbr_svc(cpi)) {
7231     vp9_update_temporal_layer_framerate(cpi);
7232     vp9_restore_layer_context(cpi);
7233   }
7234
7235   // Find a free buffer for the new frame, releasing the reference previously
7236   // held.
7237   if (cm->new_fb_idx != INVALID_IDX) {
7238     --pool->frame_bufs[cm->new_fb_idx].ref_count;
7239   }
7240   cm->new_fb_idx = get_free_fb(cm);
7241
7242   if (cm->new_fb_idx == INVALID_IDX) return -1;
7243
7244   cm->cur_frame = &pool->frame_bufs[cm->new_fb_idx];
7245
7246   // Start with a 0 size frame.
7247   *size = 0;
7248
7249   cpi->frame_flags = *frame_flags;
7250
7251 #if !CONFIG_REALTIME_ONLY
7252   if ((oxcf->pass == 2) && !cpi->use_svc) {
7253     vp9_rc_get_second_pass_params(cpi);
7254   } else if (oxcf->pass == 1) {
7255     set_frame_size(cpi);
7256   }
7257 #endif  // !CONFIG_REALTIME_ONLY
7258
7259   if (oxcf->pass != 1 && cpi->level_constraint.level_index >= 0 &&
7260       cpi->level_constraint.fail_flag == 0)
7261     level_rc_framerate(cpi, arf_src_index);
7262
7263   if (cpi->oxcf.pass != 0 || cpi->use_svc || frame_is_intra_only(cm) == 1) {
7264     for (i = 0; i < REFS_PER_FRAME; ++i) cpi->scaled_ref_idx[i] = INVALID_IDX;
7265   }
7266
7267   if (cpi->kmeans_data_arr_alloc == 0) {
7268     const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7269     const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7270 #if CONFIG_MULTITHREAD
7271     pthread_mutex_init(&cpi->kmeans_mutex, NULL);
7272 #endif
7273     CHECK_MEM_ERROR(
7274         cm, cpi->kmeans_data_arr,
7275         vpx_calloc(mi_rows * mi_cols, sizeof(*cpi->kmeans_data_arr)));
7276     cpi->kmeans_data_stride = mi_cols;
7277     cpi->kmeans_data_arr_alloc = 1;
7278   }
7279
7280 #if CONFIG_NON_GREEDY_MV
7281   {
7282     const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7283     const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7284     Status status = vp9_alloc_motion_field_info(
7285         &cpi->motion_field_info, MAX_ARF_GOP_SIZE, mi_rows, mi_cols);
7286     if (status == STATUS_FAILED) {
7287       vpx_internal_error(&(cm)->error, VPX_CODEC_MEM_ERROR,
7288                          "vp9_alloc_motion_field_info failed");
7289     }
7290   }
7291 #endif  // CONFIG_NON_GREEDY_MV
7292
7293   if (gf_group_index == 1 &&
7294       cpi->twopass.gf_group.update_type[gf_group_index] == ARF_UPDATE &&
7295       cpi->sf.enable_tpl_model) {
7296     init_tpl_buffer(cpi);
7297     vp9_estimate_qp_gop(cpi);
7298     setup_tpl_stats(cpi);
7299   }
7300
7301 #if CONFIG_BITSTREAM_DEBUG
7302   assert(cpi->oxcf.max_threads == 0 &&
7303          "bitstream debug tool does not support multithreading");
7304   bitstream_queue_record_write();
7305 #endif
7306 #if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
7307   bitstream_queue_set_frame_write(cm->current_video_frame * 2 + cm->show_frame);
7308 #endif
7309
7310   cpi->td.mb.fp_src_pred = 0;
7311 #if CONFIG_REALTIME_ONLY
7312   if (cpi->use_svc) {
7313     SvcEncode(cpi, size, dest, frame_flags);
7314   } else {
7315     // One pass encode
7316     Pass0Encode(cpi, size, dest, frame_flags);
7317   }
7318 #else  // !CONFIG_REALTIME_ONLY
7319   if (oxcf->pass == 1 && !cpi->use_svc) {
7320     const int lossless = is_lossless_requested(oxcf);
7321 #if CONFIG_VP9_HIGHBITDEPTH
7322     if (cpi->oxcf.use_highbitdepth)
7323       cpi->td.mb.fwd_txfm4x4 =
7324           lossless ? vp9_highbd_fwht4x4 : vpx_highbd_fdct4x4;
7325     else
7326       cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4;
7327     cpi->td.mb.highbd_inv_txfm_add =
7328         lossless ? vp9_highbd_iwht4x4_add : vp9_highbd_idct4x4_add;
7329 #else
7330     cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4;
7331 #endif  // CONFIG_VP9_HIGHBITDEPTH
7332     cpi->td.mb.inv_txfm_add = lossless ? vp9_iwht4x4_add : vp9_idct4x4_add;
7333     vp9_first_pass(cpi, source);
7334   } else if (oxcf->pass == 2 && !cpi->use_svc) {
7335     Pass2Encode(cpi, size, dest, frame_flags);
7336   } else if (cpi->use_svc) {
7337     SvcEncode(cpi, size, dest, frame_flags);
7338   } else {
7339     // One pass encode
7340     Pass0Encode(cpi, size, dest, frame_flags);
7341   }
7342 #endif  // CONFIG_REALTIME_ONLY
7343
7344   if (cm->show_frame) cm->cur_show_frame_fb_idx = cm->new_fb_idx;
7345
7346   if (cm->refresh_frame_context)
7347     cm->frame_contexts[cm->frame_context_idx] = *cm->fc;
7348
7349   // No frame encoded, or frame was dropped, release scaled references.
7350   if ((*size == 0) && (frame_is_intra_only(cm) == 0)) {
7351     release_scaled_references(cpi);
7352   }
7353
7354   if (*size > 0) {
7355     cpi->droppable = !frame_is_reference(cpi);
7356   }
7357
7358   // Save layer specific state.
7359   if (is_one_pass_cbr_svc(cpi) || ((cpi->svc.number_temporal_layers > 1 ||
7360                                     cpi->svc.number_spatial_layers > 1) &&
7361                                    oxcf->pass == 2)) {
7362     vp9_save_layer_context(cpi);
7363   }
7364
7365   vpx_usec_timer_mark(&cmptimer);
7366   cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
7367
7368   // Should we calculate metrics for the frame.
7369   if (is_psnr_calc_enabled(cpi)) generate_psnr_packet(cpi);
7370
7371   if (cpi->keep_level_stats && oxcf->pass != 1)
7372     update_level_info(cpi, size, arf_src_index);
7373
7374 #if CONFIG_INTERNAL_STATS
7375
7376   if (oxcf->pass != 1) {
7377     double samples = 0.0;
7378     cpi->bytes += (int)(*size);
7379
7380     if (cm->show_frame) {
7381       uint32_t bit_depth = 8;
7382       uint32_t in_bit_depth = 8;
7383       cpi->count++;
7384 #if CONFIG_VP9_HIGHBITDEPTH
7385       if (cm->use_highbitdepth) {
7386         in_bit_depth = cpi->oxcf.input_bit_depth;
7387         bit_depth = cm->bit_depth;
7388       }
7389 #endif
7390
7391       if (cpi->b_calculate_psnr) {
7392         YV12_BUFFER_CONFIG *orig = cpi->raw_source_frame;
7393         YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
7394         YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer;
7395         PSNR_STATS psnr;
7396 #if CONFIG_VP9_HIGHBITDEPTH
7397         vpx_calc_highbd_psnr(orig, recon, &psnr, cpi->td.mb.e_mbd.bd,
7398                              in_bit_depth);
7399 #else
7400         vpx_calc_psnr(orig, recon, &psnr);
7401 #endif  // CONFIG_VP9_HIGHBITDEPTH
7402
7403         adjust_image_stat(psnr.psnr[1], psnr.psnr[2], psnr.psnr[3],
7404                           psnr.psnr[0], &cpi->psnr);
7405         cpi->total_sq_error += psnr.sse[0];
7406         cpi->total_samples += psnr.samples[0];
7407         samples = psnr.samples[0];
7408
7409         {
7410           PSNR_STATS psnr2;
7411           double frame_ssim2 = 0, weight = 0;
7412 #if CONFIG_VP9_POSTPROC
7413           if (vpx_alloc_frame_buffer(
7414                   pp, recon->y_crop_width, recon->y_crop_height,
7415                   cm->subsampling_x, cm->subsampling_y,
7416 #if CONFIG_VP9_HIGHBITDEPTH
7417                   cm->use_highbitdepth,
7418 #endif
7419                   VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment) < 0) {
7420             vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
7421                                "Failed to allocate post processing buffer");
7422           }
7423           {
7424             vp9_ppflags_t ppflags;
7425             ppflags.post_proc_flag = VP9D_DEBLOCK;
7426             ppflags.deblocking_level = 0;  // not used in vp9_post_proc_frame()
7427             ppflags.noise_level = 0;       // not used in vp9_post_proc_frame()
7428             vp9_post_proc_frame(cm, pp, &ppflags,
7429                                 cpi->un_scaled_source->y_width);
7430           }
7431 #endif
7432           vpx_clear_system_state();
7433
7434 #if CONFIG_VP9_HIGHBITDEPTH
7435           vpx_calc_highbd_psnr(orig, pp, &psnr2, cpi->td.mb.e_mbd.bd,
7436                                cpi->oxcf.input_bit_depth);
7437 #else
7438           vpx_calc_psnr(orig, pp, &psnr2);
7439 #endif  // CONFIG_VP9_HIGHBITDEPTH
7440
7441           cpi->totalp_sq_error += psnr2.sse[0];
7442           cpi->totalp_samples += psnr2.samples[0];
7443           adjust_image_stat(psnr2.psnr[1], psnr2.psnr[2], psnr2.psnr[3],
7444                             psnr2.psnr[0], &cpi->psnrp);
7445
7446 #if CONFIG_VP9_HIGHBITDEPTH
7447           if (cm->use_highbitdepth) {
7448             frame_ssim2 = vpx_highbd_calc_ssim(orig, recon, &weight, bit_depth,
7449                                                in_bit_depth);
7450           } else {
7451             frame_ssim2 = vpx_calc_ssim(orig, recon, &weight);
7452           }
7453 #else
7454           frame_ssim2 = vpx_calc_ssim(orig, recon, &weight);
7455 #endif  // CONFIG_VP9_HIGHBITDEPTH
7456
7457           cpi->worst_ssim = VPXMIN(cpi->worst_ssim, frame_ssim2);
7458           cpi->summed_quality += frame_ssim2 * weight;
7459           cpi->summed_weights += weight;
7460
7461 #if CONFIG_VP9_HIGHBITDEPTH
7462           if (cm->use_highbitdepth) {
7463             frame_ssim2 = vpx_highbd_calc_ssim(orig, pp, &weight, bit_depth,
7464                                                in_bit_depth);
7465           } else {
7466             frame_ssim2 = vpx_calc_ssim(orig, pp, &weight);
7467           }
7468 #else
7469           frame_ssim2 = vpx_calc_ssim(orig, pp, &weight);
7470 #endif  // CONFIG_VP9_HIGHBITDEPTH
7471
7472           cpi->summedp_quality += frame_ssim2 * weight;
7473           cpi->summedp_weights += weight;
7474 #if 0
7475           if (cm->show_frame) {
7476             FILE *f = fopen("q_used.stt", "a");
7477             fprintf(f, "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n",
7478                     cpi->common.current_video_frame, psnr2.psnr[1],
7479                     psnr2.psnr[2], psnr2.psnr[3], psnr2.psnr[0], frame_ssim2);
7480             fclose(f);
7481           }
7482 #endif
7483         }
7484       }
7485       if (cpi->b_calculate_blockiness) {
7486 #if CONFIG_VP9_HIGHBITDEPTH
7487         if (!cm->use_highbitdepth)
7488 #endif
7489         {
7490           double frame_blockiness = vp9_get_blockiness(
7491               cpi->Source->y_buffer, cpi->Source->y_stride,
7492               cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride,
7493               cpi->Source->y_width, cpi->Source->y_height);
7494           cpi->worst_blockiness =
7495               VPXMAX(cpi->worst_blockiness, frame_blockiness);
7496           cpi->total_blockiness += frame_blockiness;
7497         }
7498       }
7499
7500       if (cpi->b_calculate_consistency) {
7501 #if CONFIG_VP9_HIGHBITDEPTH
7502         if (!cm->use_highbitdepth)
7503 #endif
7504         {
7505           double this_inconsistency = vpx_get_ssim_metrics(
7506               cpi->Source->y_buffer, cpi->Source->y_stride,
7507               cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride,
7508               cpi->Source->y_width, cpi->Source->y_height, cpi->ssim_vars,
7509               &cpi->metrics, 1);
7510
7511           const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
7512           double consistency =
7513               vpx_sse_to_psnr(samples, peak, (double)cpi->total_inconsistency);
7514           if (consistency > 0.0)
7515             cpi->worst_consistency =
7516                 VPXMIN(cpi->worst_consistency, consistency);
7517           cpi->total_inconsistency += this_inconsistency;
7518         }
7519       }
7520
7521       {
7522         double y, u, v, frame_all;
7523         frame_all = vpx_calc_fastssim(cpi->Source, cm->frame_to_show, &y, &u,
7524                                       &v, bit_depth, in_bit_depth);
7525         adjust_image_stat(y, u, v, frame_all, &cpi->fastssim);
7526       }
7527       {
7528         double y, u, v, frame_all;
7529         frame_all = vpx_psnrhvs(cpi->Source, cm->frame_to_show, &y, &u, &v,
7530                                 bit_depth, in_bit_depth);
7531         adjust_image_stat(y, u, v, frame_all, &cpi->psnrhvs);
7532       }
7533     }
7534   }
7535
7536 #endif
7537
7538   if (is_one_pass_cbr_svc(cpi)) {
7539     if (cm->show_frame) {
7540       ++cpi->svc.spatial_layer_to_encode;
7541       if (cpi->svc.spatial_layer_to_encode >= cpi->svc.number_spatial_layers)
7542         cpi->svc.spatial_layer_to_encode = 0;
7543     }
7544   }
7545
7546   vpx_clear_system_state();
7547   return 0;
7548 }
7549
7550 int vp9_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
7551                               vp9_ppflags_t *flags) {
7552   VP9_COMMON *cm = &cpi->common;
7553 #if !CONFIG_VP9_POSTPROC
7554   (void)flags;
7555 #endif
7556
7557   if (!cm->show_frame) {
7558     return -1;
7559   } else {
7560     int ret;
7561 #if CONFIG_VP9_POSTPROC
7562     ret = vp9_post_proc_frame(cm, dest, flags, cpi->un_scaled_source->y_width);
7563 #else
7564     if (cm->frame_to_show) {
7565       *dest = *cm->frame_to_show;
7566       dest->y_width = cm->width;
7567       dest->y_height = cm->height;
7568       dest->uv_width = cm->width >> cm->subsampling_x;
7569       dest->uv_height = cm->height >> cm->subsampling_y;
7570       ret = 0;
7571     } else {
7572       ret = -1;
7573     }
7574 #endif  // !CONFIG_VP9_POSTPROC
7575     vpx_clear_system_state();
7576     return ret;
7577   }
7578 }
7579
7580 int vp9_set_internal_size(VP9_COMP *cpi, VPX_SCALING horiz_mode,
7581                           VPX_SCALING vert_mode) {
7582   VP9_COMMON *cm = &cpi->common;
7583   int hr = 0, hs = 0, vr = 0, vs = 0;
7584
7585   if (horiz_mode > ONETWO || vert_mode > ONETWO) return -1;
7586
7587   Scale2Ratio(horiz_mode, &hr, &hs);
7588   Scale2Ratio(vert_mode, &vr, &vs);
7589
7590   // always go to the next whole number
7591   cm->width = (hs - 1 + cpi->oxcf.width * hr) / hs;
7592   cm->height = (vs - 1 + cpi->oxcf.height * vr) / vs;
7593   if (cm->current_video_frame) {
7594     assert(cm->width <= cpi->initial_width);
7595     assert(cm->height <= cpi->initial_height);
7596   }
7597
7598   update_frame_size(cpi);
7599
7600   return 0;
7601 }
7602
7603 int vp9_set_size_literal(VP9_COMP *cpi, unsigned int width,
7604                          unsigned int height) {
7605   VP9_COMMON *cm = &cpi->common;
7606 #if CONFIG_VP9_HIGHBITDEPTH
7607   update_initial_width(cpi, cm->use_highbitdepth, 1, 1);
7608 #else
7609   update_initial_width(cpi, 0, 1, 1);
7610 #endif  // CONFIG_VP9_HIGHBITDEPTH
7611
7612 #if CONFIG_VP9_TEMPORAL_DENOISING
7613   setup_denoiser_buffer(cpi);
7614 #endif
7615   alloc_raw_frame_buffers(cpi);
7616   if (width) {
7617     cm->width = width;
7618     if (cm->width > cpi->initial_width) {
7619       cm->width = cpi->initial_width;
7620       printf("Warning: Desired width too large, changed to %d\n", cm->width);
7621     }
7622   }
7623
7624   if (height) {
7625     cm->height = height;
7626     if (cm->height > cpi->initial_height) {
7627       cm->height = cpi->initial_height;
7628       printf("Warning: Desired height too large, changed to %d\n", cm->height);
7629     }
7630   }
7631   assert(cm->width <= cpi->initial_width);
7632   assert(cm->height <= cpi->initial_height);
7633
7634   update_frame_size(cpi);
7635
7636   return 0;
7637 }
7638
7639 void vp9_set_svc(VP9_COMP *cpi, int use_svc) {
7640   cpi->use_svc = use_svc;
7641   return;
7642 }
7643
7644 int vp9_get_quantizer(VP9_COMP *cpi) { return cpi->common.base_qindex; }
7645
7646 void vp9_apply_encoding_flags(VP9_COMP *cpi, vpx_enc_frame_flags_t flags) {
7647   if (flags &
7648       (VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF)) {
7649     int ref = 7;
7650
7651     if (flags & VP8_EFLAG_NO_REF_LAST) ref ^= VP9_LAST_FLAG;
7652
7653     if (flags & VP8_EFLAG_NO_REF_GF) ref ^= VP9_GOLD_FLAG;
7654
7655     if (flags & VP8_EFLAG_NO_REF_ARF) ref ^= VP9_ALT_FLAG;
7656
7657     vp9_use_as_reference(cpi, ref);
7658   }
7659
7660   if (flags &
7661       (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
7662        VP8_EFLAG_FORCE_GF | VP8_EFLAG_FORCE_ARF)) {
7663     int upd = 7;
7664
7665     if (flags & VP8_EFLAG_NO_UPD_LAST) upd ^= VP9_LAST_FLAG;
7666
7667     if (flags & VP8_EFLAG_NO_UPD_GF) upd ^= VP9_GOLD_FLAG;
7668
7669     if (flags & VP8_EFLAG_NO_UPD_ARF) upd ^= VP9_ALT_FLAG;
7670
7671     vp9_update_reference(cpi, upd);
7672   }
7673
7674   if (flags & VP8_EFLAG_NO_UPD_ENTROPY) {
7675     vp9_update_entropy(cpi, 0);
7676   }
7677 }
7678
7679 void vp9_set_row_mt(VP9_COMP *cpi) {
7680   // Enable row based multi-threading for supported modes of encoding
7681   cpi->row_mt = 0;
7682   if (((cpi->oxcf.mode == GOOD || cpi->oxcf.mode == BEST) &&
7683        cpi->oxcf.speed < 5 && cpi->oxcf.pass == 1) &&
7684       cpi->oxcf.row_mt && !cpi->use_svc)
7685     cpi->row_mt = 1;
7686
7687   if (cpi->oxcf.mode == GOOD && cpi->oxcf.speed < 5 &&
7688       (cpi->oxcf.pass == 0 || cpi->oxcf.pass == 2) && cpi->oxcf.row_mt &&
7689       !cpi->use_svc)
7690     cpi->row_mt = 1;
7691
7692   // In realtime mode, enable row based multi-threading for all the speed levels
7693   // where non-rd path is used.
7694   if (cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5 && cpi->oxcf.row_mt) {
7695     cpi->row_mt = 1;
7696   }
7697
7698   if (cpi->row_mt)
7699     cpi->row_mt_bit_exact = 1;
7700   else
7701     cpi->row_mt_bit_exact = 0;
7702 }