granicus.if.org Git - libvpx/blob - vp9/encoder/vp9_encoder.c

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