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