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 void vp9_remove_compressor(VP9_COMP *cpi) {
2542   VP9_COMMON *cm;
2543   unsigned int i, frame;
2544   int t;
2545
2546   if (!cpi) return;
2547
2548 #if CONFIG_INTERNAL_STATS
2549   vpx_free(cpi->ssim_vars);
2550 #endif
2551
2552   cm = &cpi->common;
2553   if (cm->current_video_frame > 0) {
2554 #if CONFIG_INTERNAL_STATS
2555     vpx_clear_system_state();
2556
2557     if (cpi->oxcf.pass != 1) {
2558       char headings[512] = { 0 };
2559       char results[512] = { 0 };
2560       FILE *f = fopen("opsnr.stt", "a");
2561       double time_encoded =
2562           (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
2563           10000000.000;
2564       double total_encode_time =
2565           (cpi->time_receive_data + cpi->time_compress_data) / 1000.000;
2566       const double dr =
2567           (double)cpi->bytes * (double)8 / (double)1000 / time_encoded;
2568       const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
2569       const double target_rate = (double)cpi->oxcf.target_bandwidth / 1000;
2570       const double rate_err = ((100.0 * (dr - target_rate)) / target_rate);
2571
2572       if (cpi->b_calculate_psnr) {
2573         const double total_psnr = vpx_sse_to_psnr(
2574             (double)cpi->total_samples, peak, (double)cpi->total_sq_error);
2575         const double totalp_psnr = vpx_sse_to_psnr(
2576             (double)cpi->totalp_samples, peak, (double)cpi->totalp_sq_error);
2577         const double total_ssim =
2578             100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0);
2579         const double totalp_ssim =
2580             100 * pow(cpi->summedp_quality / cpi->summedp_weights, 8.0);
2581
2582         snprintf(headings, sizeof(headings),
2583                  "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\t"
2584                  "VPXSSIM\tVPSSIMP\tFASTSIM\tPSNRHVS\t"
2585                  "WstPsnr\tWstSsim\tWstFast\tWstHVS\t"
2586                  "AVPsnrY\tAPsnrCb\tAPsnrCr");
2587         snprintf(results, sizeof(results),
2588                  "%7.2f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2589                  "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2590                  "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2591                  "%7.3f\t%7.3f\t%7.3f",
2592                  dr, cpi->psnr.stat[ALL] / cpi->count, total_psnr,
2593                  cpi->psnrp.stat[ALL] / cpi->count, totalp_psnr, total_ssim,
2594                  totalp_ssim, cpi->fastssim.stat[ALL] / cpi->count,
2595                  cpi->psnrhvs.stat[ALL] / cpi->count, cpi->psnr.worst,
2596                  cpi->worst_ssim, cpi->fastssim.worst, cpi->psnrhvs.worst,
2597                  cpi->psnr.stat[Y] / cpi->count, cpi->psnr.stat[U] / cpi->count,
2598                  cpi->psnr.stat[V] / cpi->count);
2599
2600         if (cpi->b_calculate_blockiness) {
2601           SNPRINT(headings, "\t  Block\tWstBlck");
2602           SNPRINT2(results, "\t%7.3f", cpi->total_blockiness / cpi->count);
2603           SNPRINT2(results, "\t%7.3f", cpi->worst_blockiness);
2604         }
2605
2606         if (cpi->b_calculate_consistency) {
2607           double consistency =
2608               vpx_sse_to_psnr((double)cpi->totalp_samples, peak,
2609                               (double)cpi->total_inconsistency);
2610
2611           SNPRINT(headings, "\tConsist\tWstCons");
2612           SNPRINT2(results, "\t%7.3f", consistency);
2613           SNPRINT2(results, "\t%7.3f", cpi->worst_consistency);
2614         }
2615
2616         fprintf(f, "%s\t    Time\tRcErr\tAbsErr\n", headings);
2617         fprintf(f, "%s\t%8.0f\t%7.2f\t%7.2f\n", results, total_encode_time,
2618                 rate_err, fabs(rate_err));
2619       }
2620
2621       fclose(f);
2622     }
2623 #endif
2624
2625 #if 0
2626     {
2627       printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2628       printf("\n_frames recive_data encod_mb_row compress_frame  Total\n");
2629       printf("%6d %10ld %10ld %10ld %10ld\n", cpi->common.current_video_frame,
2630              cpi->time_receive_data / 1000, cpi->time_encode_sb_row / 1000,
2631              cpi->time_compress_data / 1000,
2632              (cpi->time_receive_data + cpi->time_compress_data) / 1000);
2633     }
2634 #endif
2635   }
2636
2637 #if CONFIG_VP9_TEMPORAL_DENOISING
2638   vp9_denoiser_free(&(cpi->denoiser));
2639 #endif
2640
2641   if (cpi->kmeans_data_arr_alloc) {
2642 #if CONFIG_MULTITHREAD
2643     pthread_mutex_destroy(&cpi->kmeans_mutex);
2644 #endif
2645     vpx_free(cpi->kmeans_data_arr);
2646   }
2647
2648 #if CONFIG_NON_GREEDY_MV
2649   vpx_free(cpi->feature_score_loc_arr);
2650   vpx_free(cpi->feature_score_loc_sort);
2651   vpx_free(cpi->feature_score_loc_heap);
2652   vpx_free(cpi->select_mv_arr);
2653 #endif
2654   for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) {
2655 #if CONFIG_NON_GREEDY_MV
2656     int rf_idx;
2657     for (rf_idx = 0; rf_idx < 3; ++rf_idx) {
2658       int sqr_bsize;
2659       for (sqr_bsize = 0; sqr_bsize < SQUARE_BLOCK_SIZES; ++sqr_bsize) {
2660         vpx_free(cpi->tpl_stats[frame].pyramid_mv_arr[rf_idx][sqr_bsize]);
2661       }
2662       vpx_free(cpi->tpl_stats[frame].mv_mode_arr[rf_idx]);
2663       vpx_free(cpi->tpl_stats[frame].rd_diff_arr[rf_idx]);
2664     }
2665 #endif
2666     vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr);
2667     cpi->tpl_stats[frame].is_valid = 0;
2668   }
2669
2670   for (t = 0; t < cpi->num_workers; ++t) {
2671     VPxWorker *const worker = &cpi->workers[t];
2672     EncWorkerData *const thread_data = &cpi->tile_thr_data[t];
2673
2674     // Deallocate allocated threads.
2675     vpx_get_worker_interface()->end(worker);
2676
2677     // Deallocate allocated thread data.
2678     if (t < cpi->num_workers - 1) {
2679       vpx_free(thread_data->td->counts);
2680       vp9_free_pc_tree(thread_data->td);
2681       vpx_free(thread_data->td);
2682     }
2683   }
2684   vpx_free(cpi->tile_thr_data);
2685   vpx_free(cpi->workers);
2686   vp9_row_mt_mem_dealloc(cpi);
2687
2688   if (cpi->num_workers > 1) {
2689     vp9_loop_filter_dealloc(&cpi->lf_row_sync);
2690     vp9_bitstream_encode_tiles_buffer_dealloc(cpi);
2691   }
2692
2693 #if !CONFIG_REALTIME_ONLY
2694   vp9_alt_ref_aq_destroy(cpi->alt_ref_aq);
2695 #endif
2696
2697   dealloc_compressor_data(cpi);
2698
2699   for (i = 0; i < sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]);
2700        ++i) {
2701     vpx_free(cpi->mbgraph_stats[i].mb_stats);
2702   }
2703
2704 #if CONFIG_FP_MB_STATS
2705   if (cpi->use_fp_mb_stats) {
2706     vpx_free(cpi->twopass.frame_mb_stats_buf);
2707     cpi->twopass.frame_mb_stats_buf = NULL;
2708   }
2709 #endif
2710
2711   vp9_remove_common(cm);
2712   vp9_free_ref_frame_buffers(cm->buffer_pool);
2713 #if CONFIG_VP9_POSTPROC
2714   vp9_free_postproc_buffers(cm);
2715 #endif
2716   vpx_free(cpi);
2717
2718 #if CONFIG_VP9_TEMPORAL_DENOISING
2719 #ifdef OUTPUT_YUV_DENOISED
2720   fclose(yuv_denoised_file);
2721 #endif
2722 #endif
2723 #ifdef OUTPUT_YUV_SKINMAP
2724   fclose(yuv_skinmap_file);
2725 #endif
2726 #ifdef OUTPUT_YUV_REC
2727   fclose(yuv_rec_file);
2728 #endif
2729 #ifdef OUTPUT_YUV_SVC_SRC
2730   fclose(yuv_svc_src[0]);
2731   fclose(yuv_svc_src[1]);
2732   fclose(yuv_svc_src[2]);
2733 #endif
2734
2735 #if 0
2736
2737   if (keyfile)
2738     fclose(keyfile);
2739
2740   if (framepsnr)
2741     fclose(framepsnr);
2742
2743   if (kf_list)
2744     fclose(kf_list);
2745
2746 #endif
2747 }
2748
2749 static void generate_psnr_packet(VP9_COMP *cpi) {
2750   struct vpx_codec_cx_pkt pkt;
2751   int i;
2752   PSNR_STATS psnr;
2753 #if CONFIG_VP9_HIGHBITDEPTH
2754   vpx_calc_highbd_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, &psnr,
2755                        cpi->td.mb.e_mbd.bd, cpi->oxcf.input_bit_depth);
2756 #else
2757   vpx_calc_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, &psnr);
2758 #endif
2759
2760   for (i = 0; i < 4; ++i) {
2761     pkt.data.psnr.samples[i] = psnr.samples[i];
2762     pkt.data.psnr.sse[i] = psnr.sse[i];
2763     pkt.data.psnr.psnr[i] = psnr.psnr[i];
2764   }
2765   pkt.kind = VPX_CODEC_PSNR_PKT;
2766   if (cpi->use_svc)
2767     cpi->svc
2768         .layer_context[cpi->svc.spatial_layer_id *
2769                        cpi->svc.number_temporal_layers]
2770         .psnr_pkt = pkt.data.psnr;
2771   else
2772     vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
2773 }
2774
2775 int vp9_use_as_reference(VP9_COMP *cpi, int ref_frame_flags) {
2776   if (ref_frame_flags > 7) return -1;
2777
2778   cpi->ref_frame_flags = ref_frame_flags;
2779   return 0;
2780 }
2781
2782 void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags) {
2783   cpi->ext_refresh_golden_frame = (ref_frame_flags & VP9_GOLD_FLAG) != 0;
2784   cpi->ext_refresh_alt_ref_frame = (ref_frame_flags & VP9_ALT_FLAG) != 0;
2785   cpi->ext_refresh_last_frame = (ref_frame_flags & VP9_LAST_FLAG) != 0;
2786   cpi->ext_refresh_frame_flags_pending = 1;
2787 }
2788
2789 static YV12_BUFFER_CONFIG *get_vp9_ref_frame_buffer(
2790     VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag) {
2791   MV_REFERENCE_FRAME ref_frame = NONE;
2792   if (ref_frame_flag == VP9_LAST_FLAG)
2793     ref_frame = LAST_FRAME;
2794   else if (ref_frame_flag == VP9_GOLD_FLAG)
2795     ref_frame = GOLDEN_FRAME;
2796   else if (ref_frame_flag == VP9_ALT_FLAG)
2797     ref_frame = ALTREF_FRAME;
2798
2799   return ref_frame == NONE ? NULL : get_ref_frame_buffer(cpi, ref_frame);
2800 }
2801
2802 int vp9_copy_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(cfg, sd);
2807     return 0;
2808   } else {
2809     return -1;
2810   }
2811 }
2812
2813 int vp9_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
2814                           YV12_BUFFER_CONFIG *sd) {
2815   YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag);
2816   if (cfg) {
2817     vpx_yv12_copy_frame(sd, cfg);
2818     return 0;
2819   } else {
2820     return -1;
2821   }
2822 }
2823
2824 int vp9_update_entropy(VP9_COMP *cpi, int update) {
2825   cpi->ext_refresh_frame_context = update;
2826   cpi->ext_refresh_frame_context_pending = 1;
2827   return 0;
2828 }
2829
2830 #ifdef OUTPUT_YUV_REC
2831 void vp9_write_yuv_rec_frame(VP9_COMMON *cm) {
2832   YV12_BUFFER_CONFIG *s = cm->frame_to_show;
2833   uint8_t *src = s->y_buffer;
2834   int h = cm->height;
2835
2836 #if CONFIG_VP9_HIGHBITDEPTH
2837   if (s->flags & YV12_FLAG_HIGHBITDEPTH) {
2838     uint16_t *src16 = CONVERT_TO_SHORTPTR(s->y_buffer);
2839
2840     do {
2841       fwrite(src16, s->y_width, 2, yuv_rec_file);
2842       src16 += s->y_stride;
2843     } while (--h);
2844
2845     src16 = CONVERT_TO_SHORTPTR(s->u_buffer);
2846     h = s->uv_height;
2847
2848     do {
2849       fwrite(src16, s->uv_width, 2, yuv_rec_file);
2850       src16 += s->uv_stride;
2851     } while (--h);
2852
2853     src16 = CONVERT_TO_SHORTPTR(s->v_buffer);
2854     h = s->uv_height;
2855
2856     do {
2857       fwrite(src16, s->uv_width, 2, yuv_rec_file);
2858       src16 += s->uv_stride;
2859     } while (--h);
2860
2861     fflush(yuv_rec_file);
2862     return;
2863   }
2864 #endif  // CONFIG_VP9_HIGHBITDEPTH
2865
2866   do {
2867     fwrite(src, s->y_width, 1, yuv_rec_file);
2868     src += s->y_stride;
2869   } while (--h);
2870
2871   src = s->u_buffer;
2872   h = s->uv_height;
2873
2874   do {
2875     fwrite(src, s->uv_width, 1, yuv_rec_file);
2876     src += s->uv_stride;
2877   } while (--h);
2878
2879   src = s->v_buffer;
2880   h = s->uv_height;
2881
2882   do {
2883     fwrite(src, s->uv_width, 1, yuv_rec_file);
2884     src += s->uv_stride;
2885   } while (--h);
2886
2887   fflush(yuv_rec_file);
2888 }
2889 #endif
2890
2891 #if CONFIG_VP9_HIGHBITDEPTH
2892 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src,
2893                                                 YV12_BUFFER_CONFIG *dst,
2894                                                 int bd) {
2895 #else
2896 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src,
2897                                                 YV12_BUFFER_CONFIG *dst) {
2898 #endif  // CONFIG_VP9_HIGHBITDEPTH
2899   // TODO(dkovalev): replace YV12_BUFFER_CONFIG with vpx_image_t
2900   int i;
2901   const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer,
2902                                    src->v_buffer };
2903   const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride };
2904   const int src_widths[3] = { src->y_crop_width, src->uv_crop_width,
2905                               src->uv_crop_width };
2906   const int src_heights[3] = { src->y_crop_height, src->uv_crop_height,
2907                                src->uv_crop_height };
2908   uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer };
2909   const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride };
2910   const int dst_widths[3] = { dst->y_crop_width, dst->uv_crop_width,
2911                               dst->uv_crop_width };
2912   const int dst_heights[3] = { dst->y_crop_height, dst->uv_crop_height,
2913                                dst->uv_crop_height };
2914
2915   for (i = 0; i < MAX_MB_PLANE; ++i) {
2916 #if CONFIG_VP9_HIGHBITDEPTH
2917     if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
2918       vp9_highbd_resize_plane(srcs[i], src_heights[i], src_widths[i],
2919                               src_strides[i], dsts[i], dst_heights[i],
2920                               dst_widths[i], dst_strides[i], bd);
2921     } else {
2922       vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i],
2923                        dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]);
2924     }
2925 #else
2926     vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i],
2927                      dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]);
2928 #endif  // CONFIG_VP9_HIGHBITDEPTH
2929   }
2930   vpx_extend_frame_borders(dst);
2931 }
2932
2933 #if CONFIG_VP9_HIGHBITDEPTH
2934 static void scale_and_extend_frame(const YV12_BUFFER_CONFIG *src,
2935                                    YV12_BUFFER_CONFIG *dst, int bd,
2936                                    INTERP_FILTER filter_type,
2937                                    int phase_scaler) {
2938   const int src_w = src->y_crop_width;
2939   const int src_h = src->y_crop_height;
2940   const int dst_w = dst->y_crop_width;
2941   const int dst_h = dst->y_crop_height;
2942   const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer,
2943                                    src->v_buffer };
2944   const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride };
2945   uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer };
2946   const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride };
2947   const InterpKernel *const kernel = vp9_filter_kernels[filter_type];
2948   int x, y, i;
2949
2950   for (i = 0; i < MAX_MB_PLANE; ++i) {
2951     const int factor = (i == 0 || i == 3 ? 1 : 2);
2952     const int src_stride = src_strides[i];
2953     const int dst_stride = dst_strides[i];
2954     for (y = 0; y < dst_h; y += 16) {
2955       const int y_q4 = y * (16 / factor) * src_h / dst_h + phase_scaler;
2956       for (x = 0; x < dst_w; x += 16) {
2957         const int x_q4 = x * (16 / factor) * src_w / dst_w + phase_scaler;
2958         const uint8_t *src_ptr = srcs[i] +
2959                                  (y / factor) * src_h / dst_h * src_stride +
2960                                  (x / factor) * src_w / dst_w;
2961         uint8_t *dst_ptr = dsts[i] + (y / factor) * dst_stride + (x / factor);
2962
2963         if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
2964           vpx_highbd_convolve8(CONVERT_TO_SHORTPTR(src_ptr), src_stride,
2965                                CONVERT_TO_SHORTPTR(dst_ptr), dst_stride, kernel,
2966                                x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf,
2967                                16 * src_h / dst_h, 16 / factor, 16 / factor,
2968                                bd);
2969         } else {
2970           vpx_scaled_2d(src_ptr, src_stride, dst_ptr, dst_stride, kernel,
2971                         x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf,
2972                         16 * src_h / dst_h, 16 / factor, 16 / factor);
2973         }
2974       }
2975     }
2976   }
2977
2978   vpx_extend_frame_borders(dst);
2979 }
2980 #endif  // CONFIG_VP9_HIGHBITDEPTH
2981
2982 #if !CONFIG_REALTIME_ONLY
2983 static int scale_down(VP9_COMP *cpi, int q) {
2984   RATE_CONTROL *const rc = &cpi->rc;
2985   GF_GROUP *const gf_group = &cpi->twopass.gf_group;
2986   int scale = 0;
2987   assert(frame_is_kf_gf_arf(cpi));
2988
2989   if (rc->frame_size_selector == UNSCALED &&
2990       q >= rc->rf_level_maxq[gf_group->rf_level[gf_group->index]]) {
2991     const int max_size_thresh =
2992         (int)(rate_thresh_mult[SCALE_STEP1] *
2993               VPXMAX(rc->this_frame_target, rc->avg_frame_bandwidth));
2994     scale = rc->projected_frame_size > max_size_thresh ? 1 : 0;
2995   }
2996   return scale;
2997 }
2998
2999 static int big_rate_miss_high_threshold(VP9_COMP *cpi) {
3000   const RATE_CONTROL *const rc = &cpi->rc;
3001   int big_miss_high;
3002
3003   if (frame_is_kf_gf_arf(cpi))
3004     big_miss_high = rc->this_frame_target * 3 / 2;
3005   else
3006     big_miss_high = rc->this_frame_target * 2;
3007
3008   return big_miss_high;
3009 }
3010
3011 static int big_rate_miss(VP9_COMP *cpi) {
3012   const RATE_CONTROL *const rc = &cpi->rc;
3013   int big_miss_high;
3014   int big_miss_low;
3015
3016   // Ignore for overlay frames
3017   if (rc->is_src_frame_alt_ref) {
3018     return 0;
3019   } else {
3020     big_miss_low = (rc->this_frame_target / 2);
3021     big_miss_high = big_rate_miss_high_threshold(cpi);
3022
3023     return (rc->projected_frame_size > big_miss_high) ||
3024            (rc->projected_frame_size < big_miss_low);
3025   }
3026 }
3027
3028 // test in two pass for the first
3029 static int two_pass_first_group_inter(VP9_COMP *cpi) {
3030   if (cpi->oxcf.pass == 2) {
3031     TWO_PASS *const twopass = &cpi->twopass;
3032     GF_GROUP *const gf_group = &twopass->gf_group;
3033     const int gfg_index = gf_group->index;
3034
3035     if (gfg_index == 0) return gf_group->update_type[gfg_index] == LF_UPDATE;
3036     return gf_group->update_type[gfg_index - 1] != LF_UPDATE &&
3037            gf_group->update_type[gfg_index] == LF_UPDATE;
3038   } else {
3039     return 0;
3040   }
3041 }
3042
3043 // Function to test for conditions that indicate we should loop
3044 // back and recode a frame.
3045 static int recode_loop_test(VP9_COMP *cpi, int high_limit, int low_limit, int q,
3046                             int maxq, int minq) {
3047   const RATE_CONTROL *const rc = &cpi->rc;
3048   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
3049   const int frame_is_kfgfarf = frame_is_kf_gf_arf(cpi);
3050   int force_recode = 0;
3051
3052   if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3053       big_rate_miss(cpi) || (cpi->sf.recode_loop == ALLOW_RECODE) ||
3054       (two_pass_first_group_inter(cpi) &&
3055        (cpi->sf.recode_loop == ALLOW_RECODE_FIRST)) ||
3056       (frame_is_kfgfarf && (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF))) {
3057     if (frame_is_kfgfarf && (oxcf->resize_mode == RESIZE_DYNAMIC) &&
3058         scale_down(cpi, q)) {
3059       // Code this group at a lower resolution.
3060       cpi->resize_pending = 1;
3061       return 1;
3062     }
3063
3064     // Force recode for extreme overshoot.
3065     if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3066         (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF &&
3067          rc->projected_frame_size >= big_rate_miss_high_threshold(cpi))) {
3068       return 1;
3069     }
3070
3071     // TODO(agrange) high_limit could be greater than the scale-down threshold.
3072     if ((rc->projected_frame_size > high_limit && q < maxq) ||
3073         (rc->projected_frame_size < low_limit && q > minq)) {
3074       force_recode = 1;
3075     } else if (cpi->oxcf.rc_mode == VPX_CQ) {
3076       // Deal with frame undershoot and whether or not we are
3077       // below the automatically set cq level.
3078       if (q > oxcf->cq_level &&
3079           rc->projected_frame_size < ((rc->this_frame_target * 7) >> 3)) {
3080         force_recode = 1;
3081       }
3082     }
3083   }
3084   return force_recode;
3085 }
3086 #endif  // !CONFIG_REALTIME_ONLY
3087
3088 static void update_ref_frames(VP9_COMP *cpi) {
3089   VP9_COMMON *const cm = &cpi->common;
3090   BufferPool *const pool = cm->buffer_pool;
3091   GF_GROUP *const gf_group = &cpi->twopass.gf_group;
3092
3093   if (cpi->rc.show_arf_as_gld) {
3094     int tmp = cpi->alt_fb_idx;
3095     cpi->alt_fb_idx = cpi->gld_fb_idx;
3096     cpi->gld_fb_idx = tmp;
3097   } else if (cm->show_existing_frame) {
3098     // Pop ARF.
3099     cpi->lst_fb_idx = cpi->alt_fb_idx;
3100     cpi->alt_fb_idx =
3101         stack_pop(gf_group->arf_index_stack, gf_group->stack_size);
3102     --gf_group->stack_size;
3103   }
3104
3105   // At this point the new frame has been encoded.
3106   // If any buffer copy / swapping is signaled it should be done here.
3107   if (cm->frame_type == KEY_FRAME) {
3108     ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
3109                cm->new_fb_idx);
3110     ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx],
3111                cm->new_fb_idx);
3112   } else if (vp9_preserve_existing_gf(cpi)) {
3113     // We have decided to preserve the previously existing golden frame as our
3114     // new ARF frame. However, in the short term in function
3115     // vp9_get_refresh_mask() we left it in the GF slot and, if
3116     // we're updating the GF with the current decoded frame, we save it to the
3117     // ARF slot instead.
3118     // We now have to update the ARF with the current frame and swap gld_fb_idx
3119     // and alt_fb_idx so that, overall, we've stored the old GF in the new ARF
3120     // slot and, if we're updating the GF, the current frame becomes the new GF.
3121     int tmp;
3122
3123     ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx],
3124                cm->new_fb_idx);
3125
3126     tmp = cpi->alt_fb_idx;
3127     cpi->alt_fb_idx = cpi->gld_fb_idx;
3128     cpi->gld_fb_idx = tmp;
3129   } else { /* For non key/golden frames */
3130     if (cpi->refresh_alt_ref_frame) {
3131       int arf_idx = gf_group->top_arf_idx;
3132
3133       // Push new ARF into stack.
3134       stack_push(gf_group->arf_index_stack, cpi->alt_fb_idx,
3135                  gf_group->stack_size);
3136       ++gf_group->stack_size;
3137
3138       assert(arf_idx < REF_FRAMES);
3139
3140       ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[arf_idx], cm->new_fb_idx);
3141       memcpy(cpi->interp_filter_selected[ALTREF_FRAME],
3142              cpi->interp_filter_selected[0],
3143              sizeof(cpi->interp_filter_selected[0]));
3144
3145       cpi->alt_fb_idx = arf_idx;
3146     }
3147
3148     if (cpi->refresh_golden_frame) {
3149       ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
3150                  cm->new_fb_idx);
3151       if (!cpi->rc.is_src_frame_alt_ref)
3152         memcpy(cpi->interp_filter_selected[GOLDEN_FRAME],
3153                cpi->interp_filter_selected[0],
3154                sizeof(cpi->interp_filter_selected[0]));
3155       else
3156         memcpy(cpi->interp_filter_selected[GOLDEN_FRAME],
3157                cpi->interp_filter_selected[ALTREF_FRAME],
3158                sizeof(cpi->interp_filter_selected[ALTREF_FRAME]));
3159     }
3160   }
3161
3162   if (cpi->refresh_last_frame) {
3163     ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->lst_fb_idx],
3164                cm->new_fb_idx);
3165     if (!cpi->rc.is_src_frame_alt_ref)
3166       memcpy(cpi->interp_filter_selected[LAST_FRAME],
3167              cpi->interp_filter_selected[0],
3168              sizeof(cpi->interp_filter_selected[0]));
3169   }
3170
3171   if (gf_group->update_type[gf_group->index] == MID_OVERLAY_UPDATE) {
3172     cpi->alt_fb_idx =
3173         stack_pop(gf_group->arf_index_stack, gf_group->stack_size);
3174     --gf_group->stack_size;
3175   }
3176 }
3177
3178 void vp9_update_reference_frames(VP9_COMP *cpi) {
3179   update_ref_frames(cpi);
3180
3181 #if CONFIG_VP9_TEMPORAL_DENOISING
3182   vp9_denoiser_update_ref_frame(cpi);
3183 #endif
3184
3185   if (is_one_pass_cbr_svc(cpi)) vp9_svc_update_ref_frame(cpi);
3186 }
3187
3188 static void loopfilter_frame(VP9_COMP *cpi, VP9_COMMON *cm) {
3189   MACROBLOCKD *xd = &cpi->td.mb.e_mbd;
3190   struct loopfilter *lf = &cm->lf;
3191   int is_reference_frame =
3192       (cm->frame_type == KEY_FRAME || cpi->refresh_last_frame ||
3193        cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame);
3194   if (cpi->use_svc &&
3195       cpi->svc.temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS)
3196     is_reference_frame = !cpi->svc.non_reference_frame;
3197
3198   // Skip loop filter in show_existing_frame mode.
3199   if (cm->show_existing_frame) {
3200     lf->filter_level = 0;
3201     return;
3202   }
3203
3204   if (xd->lossless) {
3205     lf->filter_level = 0;
3206     lf->last_filt_level = 0;
3207   } else {
3208     struct vpx_usec_timer timer;
3209
3210     vpx_clear_system_state();
3211
3212     vpx_usec_timer_start(&timer);
3213
3214     if (!cpi->rc.is_src_frame_alt_ref) {
3215       if ((cpi->common.frame_type == KEY_FRAME) &&
3216           (!cpi->rc.this_key_frame_forced)) {
3217         lf->last_filt_level = 0;
3218       }
3219       vp9_pick_filter_level(cpi->Source, cpi, cpi->sf.lpf_pick);
3220       lf->last_filt_level = lf->filter_level;
3221     } else {
3222       lf->filter_level = 0;
3223     }
3224
3225     vpx_usec_timer_mark(&timer);
3226     cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
3227   }
3228
3229   if (lf->filter_level > 0 && is_reference_frame) {
3230     vp9_build_mask_frame(cm, lf->filter_level, 0);
3231
3232     if (cpi->num_workers > 1)
3233       vp9_loop_filter_frame_mt(cm->frame_to_show, cm, xd->plane,
3234                                lf->filter_level, 0, 0, cpi->workers,
3235                                cpi->num_workers, &cpi->lf_row_sync);
3236     else
3237       vp9_loop_filter_frame(cm->frame_to_show, cm, xd, lf->filter_level, 0, 0);
3238   }
3239
3240   vpx_extend_frame_inner_borders(cm->frame_to_show);
3241 }
3242
3243 static INLINE void alloc_frame_mvs(VP9_COMMON *const cm, int buffer_idx) {
3244   RefCntBuffer *const new_fb_ptr = &cm->buffer_pool->frame_bufs[buffer_idx];
3245   if (new_fb_ptr->mvs == NULL || new_fb_ptr->mi_rows < cm->mi_rows ||
3246       new_fb_ptr->mi_cols < cm->mi_cols) {
3247     vpx_free(new_fb_ptr->mvs);
3248     CHECK_MEM_ERROR(cm, new_fb_ptr->mvs,
3249                     (MV_REF *)vpx_calloc(cm->mi_rows * cm->mi_cols,
3250                                          sizeof(*new_fb_ptr->mvs)));
3251     new_fb_ptr->mi_rows = cm->mi_rows;
3252     new_fb_ptr->mi_cols = cm->mi_cols;
3253   }
3254 }
3255
3256 void vp9_scale_references(VP9_COMP *cpi) {
3257   VP9_COMMON *cm = &cpi->common;
3258   MV_REFERENCE_FRAME ref_frame;
3259   const VP9_REFFRAME ref_mask[3] = { VP9_LAST_FLAG, VP9_GOLD_FLAG,
3260                                      VP9_ALT_FLAG };
3261
3262   for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3263     // Need to convert from VP9_REFFRAME to index into ref_mask (subtract 1).
3264     if (cpi->ref_frame_flags & ref_mask[ref_frame - 1]) {
3265       BufferPool *const pool = cm->buffer_pool;
3266       const YV12_BUFFER_CONFIG *const ref =
3267           get_ref_frame_buffer(cpi, ref_frame);
3268
3269       if (ref == NULL) {
3270         cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3271         continue;
3272       }
3273
3274 #if CONFIG_VP9_HIGHBITDEPTH
3275       if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
3276         RefCntBuffer *new_fb_ptr = NULL;
3277         int force_scaling = 0;
3278         int new_fb = cpi->scaled_ref_idx[ref_frame - 1];
3279         if (new_fb == INVALID_IDX) {
3280           new_fb = get_free_fb(cm);
3281           force_scaling = 1;
3282         }
3283         if (new_fb == INVALID_IDX) return;
3284         new_fb_ptr = &pool->frame_bufs[new_fb];
3285         if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width ||
3286             new_fb_ptr->buf.y_crop_height != cm->height) {
3287           if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height,
3288                                        cm->subsampling_x, cm->subsampling_y,
3289                                        cm->use_highbitdepth,
3290                                        VP9_ENC_BORDER_IN_PIXELS,
3291                                        cm->byte_alignment, NULL, NULL, NULL))
3292             vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3293                                "Failed to allocate frame buffer");
3294           scale_and_extend_frame(ref, &new_fb_ptr->buf, (int)cm->bit_depth,
3295                                  EIGHTTAP, 0);
3296           cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
3297           alloc_frame_mvs(cm, new_fb);
3298         }
3299 #else
3300       if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
3301         RefCntBuffer *new_fb_ptr = NULL;
3302         int force_scaling = 0;
3303         int new_fb = cpi->scaled_ref_idx[ref_frame - 1];
3304         if (new_fb == INVALID_IDX) {
3305           new_fb = get_free_fb(cm);
3306           force_scaling = 1;
3307         }
3308         if (new_fb == INVALID_IDX) return;
3309         new_fb_ptr = &pool->frame_bufs[new_fb];
3310         if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width ||
3311             new_fb_ptr->buf.y_crop_height != cm->height) {
3312           if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height,
3313                                        cm->subsampling_x, cm->subsampling_y,
3314                                        VP9_ENC_BORDER_IN_PIXELS,
3315                                        cm->byte_alignment, NULL, NULL, NULL))
3316             vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3317                                "Failed to allocate frame buffer");
3318           vp9_scale_and_extend_frame(ref, &new_fb_ptr->buf, EIGHTTAP, 0);
3319           cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
3320           alloc_frame_mvs(cm, new_fb);
3321         }
3322 #endif  // CONFIG_VP9_HIGHBITDEPTH
3323       } else {
3324         int buf_idx;
3325         RefCntBuffer *buf = NULL;
3326         if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
3327           // Check for release of scaled reference.
3328           buf_idx = cpi->scaled_ref_idx[ref_frame - 1];
3329           if (buf_idx != INVALID_IDX) {
3330             buf = &pool->frame_bufs[buf_idx];
3331             --buf->ref_count;
3332             cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3333           }
3334         }
3335         buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
3336         buf = &pool->frame_bufs[buf_idx];
3337         buf->buf.y_crop_width = ref->y_crop_width;
3338         buf->buf.y_crop_height = ref->y_crop_height;
3339         cpi->scaled_ref_idx[ref_frame - 1] = buf_idx;
3340         ++buf->ref_count;
3341       }
3342     } else {
3343       if (cpi->oxcf.pass != 0 || cpi->use_svc)
3344         cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3345     }
3346   }
3347 }
3348
3349 static void release_scaled_references(VP9_COMP *cpi) {
3350   VP9_COMMON *cm = &cpi->common;
3351   int i;
3352   if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
3353     // Only release scaled references under certain conditions:
3354     // if reference will be updated, or if scaled reference has same resolution.
3355     int refresh[3];
3356     refresh[0] = (cpi->refresh_last_frame) ? 1 : 0;
3357     refresh[1] = (cpi->refresh_golden_frame) ? 1 : 0;
3358     refresh[2] = (cpi->refresh_alt_ref_frame) ? 1 : 0;
3359     for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
3360       const int idx = cpi->scaled_ref_idx[i - 1];
3361       if (idx != INVALID_IDX) {
3362         RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx];
3363         const YV12_BUFFER_CONFIG *const ref = get_ref_frame_buffer(cpi, i);
3364         if (refresh[i - 1] || (buf->buf.y_crop_width == ref->y_crop_width &&
3365                                buf->buf.y_crop_height == ref->y_crop_height)) {
3366           --buf->ref_count;
3367           cpi->scaled_ref_idx[i - 1] = INVALID_IDX;
3368         }
3369       }
3370     }
3371   } else {
3372     for (i = 0; i < REFS_PER_FRAME; ++i) {
3373       const int idx = cpi->scaled_ref_idx[i];
3374       if (idx != INVALID_IDX) {
3375         RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx];
3376         --buf->ref_count;
3377         cpi->scaled_ref_idx[i] = INVALID_IDX;
3378       }
3379     }
3380   }
3381 }
3382
3383 static void full_to_model_count(unsigned int *model_count,
3384                                 unsigned int *full_count) {
3385   int n;
3386   model_count[ZERO_TOKEN] = full_count[ZERO_TOKEN];
3387   model_count[ONE_TOKEN] = full_count[ONE_TOKEN];
3388   model_count[TWO_TOKEN] = full_count[TWO_TOKEN];
3389   for (n = THREE_TOKEN; n < EOB_TOKEN; ++n)
3390     model_count[TWO_TOKEN] += full_count[n];
3391   model_count[EOB_MODEL_TOKEN] = full_count[EOB_TOKEN];
3392 }
3393
3394 static void full_to_model_counts(vp9_coeff_count_model *model_count,
3395                                  vp9_coeff_count *full_count) {
3396   int i, j, k, l;
3397
3398   for (i = 0; i < PLANE_TYPES; ++i)
3399     for (j = 0; j < REF_TYPES; ++j)
3400       for (k = 0; k < COEF_BANDS; ++k)
3401         for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l)
3402           full_to_model_count(model_count[i][j][k][l], full_count[i][j][k][l]);
3403 }
3404
3405 #if 0 && CONFIG_INTERNAL_STATS
3406 static void output_frame_level_debug_stats(VP9_COMP *cpi) {
3407   VP9_COMMON *const cm = &cpi->common;
3408   FILE *const f = fopen("tmp.stt", cm->current_video_frame ? "a" : "w");
3409   int64_t recon_err;
3410
3411   vpx_clear_system_state();
3412
3413 #if CONFIG_VP9_HIGHBITDEPTH
3414   if (cm->use_highbitdepth) {
3415     recon_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3416   } else {
3417     recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3418   }
3419 #else
3420   recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3421 #endif  // CONFIG_VP9_HIGHBITDEPTH
3422
3423
3424   if (cpi->twopass.total_left_stats.coded_error != 0.0) {
3425     double dc_quant_devisor;
3426 #if CONFIG_VP9_HIGHBITDEPTH
3427     switch (cm->bit_depth) {
3428       case VPX_BITS_8:
3429         dc_quant_devisor = 4.0;
3430         break;
3431       case VPX_BITS_10:
3432         dc_quant_devisor = 16.0;
3433         break;
3434       default:
3435         assert(cm->bit_depth == VPX_BITS_12);
3436         dc_quant_devisor = 64.0;
3437         break;
3438     }
3439 #else
3440     dc_quant_devisor = 4.0;
3441 #endif
3442
3443     if (!cm->current_video_frame) {
3444       fprintf(f, "frame, width, height, last ts, last end ts, "
3445           "source_alt_ref_pending, source_alt_ref_active, "
3446           "this_frame_target, projected_frame_size, "
3447           "projected_frame_size / MBs, "
3448           "projected_frame_size - this_frame_target, "
3449           "vbr_bits_off_target, vbr_bits_off_target_fast, "
3450           "twopass.extend_minq, twopass.extend_minq_fast, "
3451           "total_target_vs_actual, "
3452           "starting_buffer_level - bits_off_target, "
3453           "total_actual_bits, base_qindex, q for base_qindex, "
3454           "dc quant, q for active_worst_quality, avg_q, q for oxcf.cq_level, "
3455           "refresh_last_frame, refresh_golden_frame, refresh_alt_ref_frame, "
3456           "frame_type, gfu_boost, "
3457           "twopass.bits_left, "
3458           "twopass.total_left_stats.coded_error, "
3459           "twopass.bits_left / (1 + twopass.total_left_stats.coded_error), "
3460           "tot_recode_hits, recon_err, kf_boost, "
3461           "twopass.kf_zeromotion_pct, twopass.fr_content_type, "
3462           "filter_level, seg.aq_av_offset\n");
3463     }
3464
3465     fprintf(f, "%10u, %d, %d, %10"PRId64", %10"PRId64", %d, %d, %10d, %10d, "
3466         "%10d, %10d, %10"PRId64", %10"PRId64", %5d, %5d, %10"PRId64", "
3467         "%10"PRId64", %10"PRId64", %10d, %7.2lf, %7.2lf, %7.2lf, %7.2lf, "
3468         "%7.2lf, %6d, %6d, %5d, %5d, %5d, %10"PRId64", %10.3lf, %10lf, %8u, "
3469         "%10"PRId64", %10d, %10d, %10d, %10d, %10d\n",
3470         cpi->common.current_video_frame,
3471         cm->width, cm->height,
3472         cpi->last_time_stamp_seen,
3473         cpi->last_end_time_stamp_seen,
3474         cpi->rc.source_alt_ref_pending,
3475         cpi->rc.source_alt_ref_active,
3476         cpi->rc.this_frame_target,
3477         cpi->rc.projected_frame_size,
3478         cpi->rc.projected_frame_size / cpi->common.MBs,
3479         (cpi->rc.projected_frame_size - cpi->rc.this_frame_target),
3480         cpi->rc.vbr_bits_off_target,
3481         cpi->rc.vbr_bits_off_target_fast,
3482         cpi->twopass.extend_minq,
3483         cpi->twopass.extend_minq_fast,
3484         cpi->rc.total_target_vs_actual,
3485         (cpi->rc.starting_buffer_level - cpi->rc.bits_off_target),
3486         cpi->rc.total_actual_bits, cm->base_qindex,
3487         vp9_convert_qindex_to_q(cm->base_qindex, cm->bit_depth),
3488         (double)vp9_dc_quant(cm->base_qindex, 0, cm->bit_depth) /
3489             dc_quant_devisor,
3490         vp9_convert_qindex_to_q(cpi->twopass.active_worst_quality,
3491                                 cm->bit_depth),
3492         cpi->rc.avg_q,
3493         vp9_convert_qindex_to_q(cpi->oxcf.cq_level, cm->bit_depth),
3494         cpi->refresh_last_frame, cpi->refresh_golden_frame,
3495         cpi->refresh_alt_ref_frame, cm->frame_type, cpi->rc.gfu_boost,
3496         cpi->twopass.bits_left,
3497         cpi->twopass.total_left_stats.coded_error,
3498         cpi->twopass.bits_left /
3499             (1 + cpi->twopass.total_left_stats.coded_error),
3500         cpi->tot_recode_hits, recon_err, cpi->rc.kf_boost,
3501         cpi->twopass.kf_zeromotion_pct,
3502         cpi->twopass.fr_content_type,
3503         cm->lf.filter_level,
3504         cm->seg.aq_av_offset);
3505   }
3506   fclose(f);
3507
3508   if (0) {
3509     FILE *const fmodes = fopen("Modes.stt", "a");
3510     int i;
3511
3512     fprintf(fmodes, "%6d:%1d:%1d:%1d ", cpi->common.current_video_frame,
3513             cm->frame_type, cpi->refresh_golden_frame,
3514             cpi->refresh_alt_ref_frame);
3515
3516     for (i = 0; i < MAX_MODES; ++i)
3517       fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
3518
3519     fprintf(fmodes, "\n");
3520
3521     fclose(fmodes);
3522   }
3523 }
3524 #endif
3525
3526 static void set_mv_search_params(VP9_COMP *cpi) {
3527   const VP9_COMMON *const cm = &cpi->common;
3528   const unsigned int max_mv_def = VPXMIN(cm->width, cm->height);
3529
3530   // Default based on max resolution.
3531   cpi->mv_step_param = vp9_init_search_range(max_mv_def);
3532
3533   if (cpi->sf.mv.auto_mv_step_size) {
3534     if (frame_is_intra_only(cm)) {
3535       // Initialize max_mv_magnitude for use in the first INTER frame
3536       // after a key/intra-only frame.
3537       cpi->max_mv_magnitude = max_mv_def;
3538     } else {
3539       if (cm->show_frame) {
3540         // Allow mv_steps to correspond to twice the max mv magnitude found
3541         // in the previous frame, capped by the default max_mv_magnitude based
3542         // on resolution.
3543         cpi->mv_step_param = vp9_init_search_range(
3544             VPXMIN(max_mv_def, 2 * cpi->max_mv_magnitude));
3545       }
3546       cpi->max_mv_magnitude = 0;
3547     }
3548   }
3549 }
3550
3551 static void set_size_independent_vars(VP9_COMP *cpi) {
3552   vp9_set_speed_features_framesize_independent(cpi, cpi->oxcf.speed);
3553   vp9_set_rd_speed_thresholds(cpi);
3554   vp9_set_rd_speed_thresholds_sub8x8(cpi);
3555   cpi->common.interp_filter = cpi->sf.default_interp_filter;
3556 }
3557
3558 static void set_size_dependent_vars(VP9_COMP *cpi, int *q, int *bottom_index,
3559                                     int *top_index) {
3560   VP9_COMMON *const cm = &cpi->common;
3561
3562   // Setup variables that depend on the dimensions of the frame.
3563   vp9_set_speed_features_framesize_dependent(cpi, cpi->oxcf.speed);
3564
3565   // Decide q and q bounds.
3566   *q = vp9_rc_pick_q_and_bounds(cpi, bottom_index, top_index);
3567
3568   if (cpi->oxcf.rc_mode == VPX_CBR && cpi->rc.force_max_q) {
3569     *q = cpi->rc.worst_quality;
3570     cpi->rc.force_max_q = 0;
3571   }
3572
3573   if (!frame_is_intra_only(cm)) {
3574     vp9_set_high_precision_mv(cpi, (*q) < HIGH_PRECISION_MV_QTHRESH);
3575   }
3576
3577 #if !CONFIG_REALTIME_ONLY
3578   // Configure experimental use of segmentation for enhanced coding of
3579   // static regions if indicated.
3580   // Only allowed in the second pass of a two pass encode, as it requires
3581   // lagged coding, and if the relevant speed feature flag is set.
3582   if (cpi->oxcf.pass == 2 && cpi->sf.static_segmentation)
3583     configure_static_seg_features(cpi);
3584 #endif  // !CONFIG_REALTIME_ONLY
3585
3586 #if CONFIG_VP9_POSTPROC && !(CONFIG_VP9_TEMPORAL_DENOISING)
3587   if (cpi->oxcf.noise_sensitivity > 0) {
3588     int l = 0;
3589     switch (cpi->oxcf.noise_sensitivity) {
3590       case 1: l = 20; break;
3591       case 2: l = 40; break;
3592       case 3: l = 60; break;
3593       case 4:
3594       case 5: l = 100; break;
3595       case 6: l = 150; break;
3596     }
3597     if (!cpi->common.postproc_state.limits) {
3598       cpi->common.postproc_state.limits =
3599           vpx_calloc(cpi->un_scaled_source->y_width,
3600                      sizeof(*cpi->common.postproc_state.limits));
3601     }
3602     vp9_denoise(&cpi->common, cpi->Source, cpi->Source, l,
3603                 cpi->common.postproc_state.limits);
3604   }
3605 #endif  // CONFIG_VP9_POSTPROC
3606 }
3607
3608 #if CONFIG_VP9_TEMPORAL_DENOISING
3609 static void setup_denoiser_buffer(VP9_COMP *cpi) {
3610   VP9_COMMON *const cm = &cpi->common;
3611   if (cpi->oxcf.noise_sensitivity > 0 &&
3612       !cpi->denoiser.frame_buffer_initialized) {
3613     if (vp9_denoiser_alloc(cm, &cpi->svc, &cpi->denoiser, cpi->use_svc,
3614                            cpi->oxcf.noise_sensitivity, cm->width, cm->height,
3615                            cm->subsampling_x, cm->subsampling_y,
3616 #if CONFIG_VP9_HIGHBITDEPTH
3617                            cm->use_highbitdepth,
3618 #endif
3619                            VP9_ENC_BORDER_IN_PIXELS))
3620       vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3621                          "Failed to allocate denoiser");
3622   }
3623 }
3624 #endif
3625
3626 static void init_motion_estimation(VP9_COMP *cpi) {
3627   int y_stride = cpi->scaled_source.y_stride;
3628
3629   if (cpi->sf.mv.search_method == NSTEP) {
3630     vp9_init3smotion_compensation(&cpi->ss_cfg, y_stride);
3631   } else if (cpi->sf.mv.search_method == DIAMOND) {
3632     vp9_init_dsmotion_compensation(&cpi->ss_cfg, y_stride);
3633   }
3634 }
3635
3636 static void set_frame_size(VP9_COMP *cpi) {
3637   int ref_frame;
3638   VP9_COMMON *const cm = &cpi->common;
3639   VP9EncoderConfig *const oxcf = &cpi->oxcf;
3640   MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
3641
3642 #if !CONFIG_REALTIME_ONLY
3643   if (oxcf->pass == 2 && oxcf->rc_mode == VPX_VBR &&
3644       ((oxcf->resize_mode == RESIZE_FIXED && cm->current_video_frame == 0) ||
3645        (oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending))) {
3646     calculate_coded_size(cpi, &oxcf->scaled_frame_width,
3647                          &oxcf->scaled_frame_height);
3648
3649     // There has been a change in frame size.
3650     vp9_set_size_literal(cpi, oxcf->scaled_frame_width,
3651                          oxcf->scaled_frame_height);
3652   }
3653 #endif  // !CONFIG_REALTIME_ONLY
3654
3655   if (oxcf->pass == 0 && oxcf->rc_mode == VPX_CBR && !cpi->use_svc &&
3656       oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending != 0) {
3657     oxcf->scaled_frame_width =
3658         (oxcf->width * cpi->resize_scale_num) / cpi->resize_scale_den;
3659     oxcf->scaled_frame_height =
3660         (oxcf->height * cpi->resize_scale_num) / cpi->resize_scale_den;
3661     // There has been a change in frame size.
3662     vp9_set_size_literal(cpi, oxcf->scaled_frame_width,
3663                          oxcf->scaled_frame_height);
3664
3665     // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed.
3666     set_mv_search_params(cpi);
3667
3668     vp9_noise_estimate_init(&cpi->noise_estimate, cm->width, cm->height);
3669 #if CONFIG_VP9_TEMPORAL_DENOISING
3670     // Reset the denoiser on the resized frame.
3671     if (cpi->oxcf.noise_sensitivity > 0) {
3672       vp9_denoiser_free(&(cpi->denoiser));
3673       setup_denoiser_buffer(cpi);
3674       // Dynamic resize is only triggered for non-SVC, so we can force
3675       // golden frame update here as temporary fix to denoiser.
3676       cpi->refresh_golden_frame = 1;
3677     }
3678 #endif
3679   }
3680
3681   if ((oxcf->pass == 2) && !cpi->use_svc) {
3682     vp9_set_target_rate(cpi);
3683   }
3684
3685   alloc_frame_mvs(cm, cm->new_fb_idx);
3686
3687   // Reset the frame pointers to the current frame size.
3688   if (vpx_realloc_frame_buffer(get_frame_new_buffer(cm), cm->width, cm->height,
3689                                cm->subsampling_x, cm->subsampling_y,
3690 #if CONFIG_VP9_HIGHBITDEPTH
3691                                cm->use_highbitdepth,
3692 #endif
3693                                VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
3694                                NULL, NULL, NULL))
3695     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3696                        "Failed to allocate frame buffer");
3697
3698   alloc_util_frame_buffers(cpi);
3699   init_motion_estimation(cpi);
3700
3701   for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3702     RefBuffer *const ref_buf = &cm->frame_refs[ref_frame - 1];
3703     const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
3704
3705     ref_buf->idx = buf_idx;
3706
3707     if (buf_idx != INVALID_IDX) {
3708       YV12_BUFFER_CONFIG *const buf = &cm->buffer_pool->frame_bufs[buf_idx].buf;
3709       ref_buf->buf = buf;
3710 #if CONFIG_VP9_HIGHBITDEPTH
3711       vp9_setup_scale_factors_for_frame(
3712           &ref_buf->sf, buf->y_crop_width, buf->y_crop_height, cm->width,
3713           cm->height, (buf->flags & YV12_FLAG_HIGHBITDEPTH) ? 1 : 0);
3714 #else
3715       vp9_setup_scale_factors_for_frame(&ref_buf->sf, buf->y_crop_width,
3716                                         buf->y_crop_height, cm->width,
3717                                         cm->height);
3718 #endif  // CONFIG_VP9_HIGHBITDEPTH
3719       if (vp9_is_scaled(&ref_buf->sf)) vpx_extend_frame_borders(buf);
3720     } else {
3721       ref_buf->buf = NULL;
3722     }
3723   }
3724
3725   set_ref_ptrs(cm, xd, LAST_FRAME, LAST_FRAME);
3726 }
3727
3728 #if CONFIG_CONSISTENT_RECODE
3729 static void save_encode_params(VP9_COMP *cpi) {
3730   VP9_COMMON *const cm = &cpi->common;
3731   const int tile_cols = 1 << cm->log2_tile_cols;
3732   const int tile_rows = 1 << cm->log2_tile_rows;
3733   int tile_col, tile_row;
3734   int i, j;
3735   RD_OPT *rd_opt = &cpi->rd;
3736   for (i = 0; i < MAX_REF_FRAMES; i++) {
3737     for (j = 0; j < REFERENCE_MODES; j++)
3738       rd_opt->prediction_type_threshes_prev[i][j] =
3739           rd_opt->prediction_type_threshes[i][j];
3740
3741     for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; j++)
3742       rd_opt->filter_threshes_prev[i][j] = rd_opt->filter_threshes[i][j];
3743   }
3744
3745   if (cpi->tile_data != NULL) {
3746     for (tile_row = 0; tile_row < tile_rows; ++tile_row)
3747       for (tile_col = 0; tile_col < tile_cols; ++tile_col) {
3748         TileDataEnc *tile_data =
3749             &cpi->tile_data[tile_row * tile_cols + tile_col];
3750         for (i = 0; i < BLOCK_SIZES; ++i) {
3751           for (j = 0; j < MAX_MODES; ++j) {
3752             tile_data->thresh_freq_fact_prev[i][j] =
3753                 tile_data->thresh_freq_fact[i][j];
3754           }
3755         }
3756       }
3757   }
3758 }
3759 #endif
3760
3761 static INLINE void set_raw_source_frame(VP9_COMP *cpi) {
3762 #ifdef ENABLE_KF_DENOISE
3763   if (is_spatial_denoise_enabled(cpi)) {
3764     cpi->raw_source_frame = vp9_scale_if_required(
3765         cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
3766         (oxcf->pass == 0), EIGHTTAP, 0);
3767   } else {
3768     cpi->raw_source_frame = cpi->Source;
3769   }
3770 #else
3771   cpi->raw_source_frame = cpi->Source;
3772 #endif
3773 }
3774
3775 static int encode_without_recode_loop(VP9_COMP *cpi, size_t *size,
3776                                       uint8_t *dest) {
3777   VP9_COMMON *const cm = &cpi->common;
3778   SVC *const svc = &cpi->svc;
3779   int q = 0, bottom_index = 0, top_index = 0;
3780   int no_drop_scene_change = 0;
3781   const INTERP_FILTER filter_scaler =
3782       (is_one_pass_cbr_svc(cpi))
3783           ? svc->downsample_filter_type[svc->spatial_layer_id]
3784           : EIGHTTAP;
3785   const int phase_scaler =
3786       (is_one_pass_cbr_svc(cpi))
3787           ? svc->downsample_filter_phase[svc->spatial_layer_id]
3788           : 0;
3789
3790   if (cm->show_existing_frame) {
3791     cpi->rc.this_frame_target = 0;
3792     if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi);
3793     return 1;
3794   }
3795
3796   svc->time_stamp_prev[svc->spatial_layer_id] = svc->time_stamp_superframe;
3797
3798   // Flag to check if its valid to compute the source sad (used for
3799   // scene detection and for superblock content state in CBR mode).
3800   // The flag may get reset below based on SVC or resizing state.
3801   cpi->compute_source_sad_onepass = cpi->oxcf.mode == REALTIME;
3802
3803   vpx_clear_system_state();
3804
3805   set_frame_size(cpi);
3806
3807   if (is_one_pass_cbr_svc(cpi) &&
3808       cpi->un_scaled_source->y_width == cm->width << 2 &&
3809       cpi->un_scaled_source->y_height == cm->height << 2 &&
3810       svc->scaled_temp.y_width == cm->width << 1 &&
3811       svc->scaled_temp.y_height == cm->height << 1) {
3812     // For svc, if it is a 1/4x1/4 downscaling, do a two-stage scaling to take
3813     // advantage of the 1:2 optimized scaler. In the process, the 1/2x1/2
3814     // result will be saved in scaled_temp and might be used later.
3815     const INTERP_FILTER filter_scaler2 = svc->downsample_filter_type[1];
3816     const int phase_scaler2 = svc->downsample_filter_phase[1];
3817     cpi->Source = vp9_svc_twostage_scale(
3818         cm, cpi->un_scaled_source, &cpi->scaled_source, &svc->scaled_temp,
3819         filter_scaler, phase_scaler, filter_scaler2, phase_scaler2);
3820     svc->scaled_one_half = 1;
3821   } else if (is_one_pass_cbr_svc(cpi) &&
3822              cpi->un_scaled_source->y_width == cm->width << 1 &&
3823              cpi->un_scaled_source->y_height == cm->height << 1 &&
3824              svc->scaled_one_half) {
3825     // If the spatial layer is 1/2x1/2 and the scaling is already done in the
3826     // two-stage scaling, use the result directly.
3827     cpi->Source = &svc->scaled_temp;
3828     svc->scaled_one_half = 0;
3829   } else {
3830     cpi->Source = vp9_scale_if_required(
3831         cm, cpi->un_scaled_source, &cpi->scaled_source, (cpi->oxcf.pass == 0),
3832         filter_scaler, phase_scaler);
3833   }
3834 #ifdef OUTPUT_YUV_SVC_SRC
3835   // Write out at most 3 spatial layers.
3836   if (is_one_pass_cbr_svc(cpi) && svc->spatial_layer_id < 3) {
3837     vpx_write_yuv_frame(yuv_svc_src[svc->spatial_layer_id], cpi->Source);
3838   }
3839 #endif
3840   // Unfiltered raw source used in metrics calculation if the source
3841   // has been filtered.
3842   if (is_psnr_calc_enabled(cpi)) {
3843 #ifdef ENABLE_KF_DENOISE
3844     if (is_spatial_denoise_enabled(cpi)) {
3845       cpi->raw_source_frame = vp9_scale_if_required(
3846           cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
3847           (cpi->oxcf.pass == 0), EIGHTTAP, phase_scaler);
3848     } else {
3849       cpi->raw_source_frame = cpi->Source;
3850     }
3851 #else
3852     cpi->raw_source_frame = cpi->Source;
3853 #endif
3854   }
3855
3856   if ((cpi->use_svc &&
3857        (svc->spatial_layer_id < svc->number_spatial_layers - 1 ||
3858         svc->temporal_layer_id < svc->number_temporal_layers - 1 ||
3859         svc->current_superframe < 1)) ||
3860       cpi->resize_pending || cpi->resize_state || cpi->external_resize ||
3861       cpi->resize_state != ORIG) {
3862     cpi->compute_source_sad_onepass = 0;
3863     if (cpi->content_state_sb_fd != NULL)
3864       memset(cpi->content_state_sb_fd, 0,
3865              (cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1) *
3866                  sizeof(*cpi->content_state_sb_fd));
3867   }
3868
3869   // Avoid scaling last_source unless its needed.
3870   // Last source is needed if avg_source_sad() is used, or if
3871   // partition_search_type == SOURCE_VAR_BASED_PARTITION, or if noise
3872   // estimation is enabled.
3873   if (cpi->unscaled_last_source != NULL &&
3874       (cpi->oxcf.content == VP9E_CONTENT_SCREEN ||
3875        (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_VBR &&
3876         cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5) ||
3877        cpi->sf.partition_search_type == SOURCE_VAR_BASED_PARTITION ||
3878        (cpi->noise_estimate.enabled && !cpi->oxcf.noise_sensitivity) ||
3879        cpi->compute_source_sad_onepass))
3880     cpi->Last_Source = vp9_scale_if_required(
3881         cm, cpi->unscaled_last_source, &cpi->scaled_last_source,
3882         (cpi->oxcf.pass == 0), EIGHTTAP, 0);
3883
3884   if (cpi->Last_Source == NULL ||
3885       cpi->Last_Source->y_width != cpi->Source->y_width ||
3886       cpi->Last_Source->y_height != cpi->Source->y_height)
3887     cpi->compute_source_sad_onepass = 0;
3888
3889   if (frame_is_intra_only(cm) || cpi->resize_pending != 0) {
3890     memset(cpi->consec_zero_mv, 0,
3891            cm->mi_rows * cm->mi_cols * sizeof(*cpi->consec_zero_mv));
3892   }
3893
3894 #if CONFIG_VP9_TEMPORAL_DENOISING
3895   if (cpi->oxcf.noise_sensitivity > 0 && cpi->use_svc)
3896     vp9_denoiser_reset_on_first_frame(cpi);
3897 #endif
3898
3899   // Scene detection is always used for VBR mode or screen-content case.
3900   // For other cases (e.g., CBR mode) use it for 5 <= speed < 8 for now
3901   // (need to check encoding time cost for doing this for speed 8).
3902   cpi->rc.high_source_sad = 0;
3903   cpi->rc.hybrid_intra_scene_change = 0;
3904   cpi->rc.re_encode_maxq_scene_change = 0;
3905   if (cm->show_frame && cpi->oxcf.mode == REALTIME &&
3906       (cpi->oxcf.rc_mode == VPX_VBR ||
3907        cpi->oxcf.content == VP9E_CONTENT_SCREEN ||
3908        (cpi->oxcf.speed >= 5 && cpi->oxcf.speed < 8)))
3909     vp9_scene_detection_onepass(cpi);
3910
3911   if (svc->spatial_layer_id == svc->first_spatial_layer_to_encode) {
3912     svc->high_source_sad_superframe = cpi->rc.high_source_sad;
3913     svc->high_num_blocks_with_motion = cpi->rc.high_num_blocks_with_motion;
3914     // On scene change reset temporal layer pattern to TL0.
3915     // Note that if the base/lower spatial layers are skipped: instead of
3916     // inserting base layer here, we force max-q for the next superframe
3917     // with lower spatial layers: this is done in vp9_encodedframe_overshoot()
3918     // when max-q is decided for the current layer.
3919     // Only do this reset for bypass/flexible mode.
3920     if (svc->high_source_sad_superframe && svc->temporal_layer_id > 0 &&
3921         svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS) {
3922       // rc->high_source_sad will get reset so copy it to restore it.
3923       int tmp_high_source_sad = cpi->rc.high_source_sad;
3924       vp9_svc_reset_temporal_layers(cpi, cm->frame_type == KEY_FRAME);
3925       cpi->rc.high_source_sad = tmp_high_source_sad;
3926     }
3927   }
3928
3929   vp9_update_noise_estimate(cpi);
3930
3931   // For 1 pass CBR, check if we are dropping this frame.
3932   // Never drop on key frame, if base layer is key for svc,
3933   // on scene change, or if superframe has layer sync.
3934   if ((cpi->rc.high_source_sad || svc->high_source_sad_superframe) &&
3935       !(cpi->rc.use_post_encode_drop && svc->last_layer_dropped[0]))
3936     no_drop_scene_change = 1;
3937   if (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_CBR &&
3938       !frame_is_intra_only(cm) && !no_drop_scene_change &&
3939       !svc->superframe_has_layer_sync &&
3940       (!cpi->use_svc ||
3941        !svc->layer_context[svc->temporal_layer_id].is_key_frame)) {
3942     if (vp9_rc_drop_frame(cpi)) return 0;
3943   }
3944
3945   // For 1 pass CBR SVC, only ZEROMV is allowed for spatial reference frame
3946   // when svc->force_zero_mode_spatial_ref = 1. Under those conditions we can
3947   // avoid this frame-level upsampling (for non intra_only frames).
3948   if (frame_is_intra_only(cm) == 0 &&
3949       !(is_one_pass_cbr_svc(cpi) && svc->force_zero_mode_spatial_ref)) {
3950     vp9_scale_references(cpi);
3951   }
3952
3953   set_size_independent_vars(cpi);
3954   set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
3955
3956   // search method and step parameter might be changed in speed settings.
3957   init_motion_estimation(cpi);
3958
3959   if (cpi->sf.copy_partition_flag) alloc_copy_partition_data(cpi);
3960
3961   if (cpi->sf.svc_use_lowres_part &&
3962       svc->spatial_layer_id == svc->number_spatial_layers - 2) {
3963     if (svc->prev_partition_svc == NULL) {
3964       CHECK_MEM_ERROR(
3965           cm, svc->prev_partition_svc,
3966           (BLOCK_SIZE *)vpx_calloc(cm->mi_stride * cm->mi_rows,
3967                                    sizeof(*svc->prev_partition_svc)));
3968     }
3969   }
3970
3971   // TODO(jianj): Look into issue of skin detection with high bitdepth.
3972   if (cm->bit_depth == 8 && cpi->oxcf.speed >= 5 && cpi->oxcf.pass == 0 &&
3973       cpi->oxcf.rc_mode == VPX_CBR &&
3974       cpi->oxcf.content != VP9E_CONTENT_SCREEN &&
3975       cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
3976     cpi->use_skin_detection = 1;
3977   }
3978
3979   // Enable post encode frame dropping for CBR on non key frame, when
3980   // ext_use_post_encode_drop is specified by user.
3981   cpi->rc.use_post_encode_drop = cpi->rc.ext_use_post_encode_drop &&
3982                                  cpi->oxcf.rc_mode == VPX_CBR &&
3983                                  cm->frame_type != KEY_FRAME;
3984
3985   vp9_set_quantizer(cm, q);
3986   vp9_set_variance_partition_thresholds(cpi, q, 0);
3987
3988   setup_frame(cpi);
3989
3990   suppress_active_map(cpi);
3991
3992   if (cpi->use_svc) {
3993     // On non-zero spatial layer, check for disabling inter-layer
3994     // prediction.
3995     if (svc->spatial_layer_id > 0) vp9_svc_constrain_inter_layer_pred(cpi);
3996     vp9_svc_assert_constraints_pattern(cpi);
3997   }
3998
3999   if (cpi->rc.last_post_encode_dropped_scene_change) {
4000     cpi->rc.high_source_sad = 1;
4001     svc->high_source_sad_superframe = 1;
4002     // For now disable use_source_sad since Last_Source will not be the previous
4003     // encoded but the dropped one.
4004     cpi->sf.use_source_sad = 0;
4005     cpi->rc.last_post_encode_dropped_scene_change = 0;
4006   }
4007   // Check if this high_source_sad (scene/slide change) frame should be
4008   // encoded at high/max QP, and if so, set the q and adjust some rate
4009   // control parameters.
4010   if (cpi->sf.overshoot_detection_cbr_rt == FAST_DETECTION_MAXQ &&
4011       (cpi->rc.high_source_sad ||
4012        (cpi->use_svc && svc->high_source_sad_superframe))) {
4013     if (vp9_encodedframe_overshoot(cpi, -1, &q)) {
4014       vp9_set_quantizer(cm, q);
4015       vp9_set_variance_partition_thresholds(cpi, q, 0);
4016     }
4017   }
4018
4019 #if !CONFIG_REALTIME_ONLY
4020   // Variance adaptive and in frame q adjustment experiments are mutually
4021   // exclusive.
4022   if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
4023     vp9_vaq_frame_setup(cpi);
4024   } else if (cpi->oxcf.aq_mode == EQUATOR360_AQ) {
4025     vp9_360aq_frame_setup(cpi);
4026   } else if (cpi->oxcf.aq_mode == COMPLEXITY_AQ) {
4027     vp9_setup_in_frame_q_adj(cpi);
4028   } else if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ) {
4029     // it may be pretty bad for rate-control,
4030     // and I should handle it somehow
4031     vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi);
4032   } else {
4033 #endif
4034     if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4035       vp9_cyclic_refresh_setup(cpi);
4036     } else if (cpi->roi.enabled && !frame_is_intra_only(cm)) {
4037       apply_roi_map(cpi);
4038     }
4039 #if !CONFIG_REALTIME_ONLY
4040   }
4041 #endif
4042
4043   apply_active_map(cpi);
4044
4045   vp9_encode_frame(cpi);
4046
4047   // Check if we should re-encode this frame at high Q because of high
4048   // overshoot based on the encoded frame size. Only for frames where
4049   // high temporal-source SAD is detected.
4050   // For SVC: all spatial layers are checked for re-encoding.
4051   if (cpi->sf.overshoot_detection_cbr_rt == RE_ENCODE_MAXQ &&
4052       (cpi->rc.high_source_sad ||
4053        (cpi->use_svc && svc->high_source_sad_superframe))) {
4054     int frame_size = 0;
4055     // Get an estimate of the encoded frame size.
4056     save_coding_context(cpi);
4057     vp9_pack_bitstream(cpi, dest, size);
4058     restore_coding_context(cpi);
4059     frame_size = (int)(*size) << 3;
4060     // Check if encoded frame will overshoot too much, and if so, set the q and
4061     // adjust some rate control parameters, and return to re-encode the frame.
4062     if (vp9_encodedframe_overshoot(cpi, frame_size, &q)) {
4063       vpx_clear_system_state();
4064       vp9_set_quantizer(cm, q);
4065       vp9_set_variance_partition_thresholds(cpi, q, 0);
4066       suppress_active_map(cpi);
4067       // Turn-off cyclic refresh for re-encoded frame.
4068       if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4069         CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
4070         unsigned char *const seg_map = cpi->segmentation_map;
4071         memset(seg_map, 0, cm->mi_rows * cm->mi_cols);
4072         memset(cr->last_coded_q_map, MAXQ,
4073                cm->mi_rows * cm->mi_cols * sizeof(*cr->last_coded_q_map));
4074         cr->sb_index = 0;
4075         vp9_disable_segmentation(&cm->seg);
4076       }
4077       apply_active_map(cpi);
4078       vp9_encode_frame(cpi);
4079     }
4080   }
4081
4082   // Update some stats from cyclic refresh, and check for golden frame update.
4083   if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && cm->seg.enabled &&
4084       !frame_is_intra_only(cm))
4085     vp9_cyclic_refresh_postencode(cpi);
4086
4087   // Update the skip mb flag probabilities based on the distribution
4088   // seen in the last encoder iteration.
4089   // update_base_skip_probs(cpi);
4090   vpx_clear_system_state();
4091   return 1;
4092 }
4093
4094 #if !CONFIG_REALTIME_ONLY
4095 #define MAX_QSTEP_ADJ 4
4096 static int get_qstep_adj(int rate_excess, int rate_limit) {
4097   int qstep =
4098       rate_limit ? ((rate_excess + rate_limit / 2) / rate_limit) : INT_MAX;
4099   return VPXMIN(qstep, MAX_QSTEP_ADJ);
4100 }
4101
4102 static void encode_with_recode_loop(VP9_COMP *cpi, size_t *size,
4103                                     uint8_t *dest) {
4104   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4105   VP9_COMMON *const cm = &cpi->common;
4106   RATE_CONTROL *const rc = &cpi->rc;
4107   int bottom_index, top_index;
4108   int loop_count = 0;
4109   int loop_at_this_size = 0;
4110   int loop = 0;
4111   int overshoot_seen = 0;
4112   int undershoot_seen = 0;
4113   int frame_over_shoot_limit;
4114   int frame_under_shoot_limit;
4115   int q = 0, q_low = 0, q_high = 0;
4116   int enable_acl;
4117 #ifdef AGGRESSIVE_VBR
4118   int qrange_adj = 1;
4119 #endif
4120
4121   if (cm->show_existing_frame) {
4122     rc->this_frame_target = 0;
4123     if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi);
4124     return;
4125   }
4126
4127   set_size_independent_vars(cpi);
4128
4129   enable_acl = cpi->sf.allow_acl ? (cm->frame_type == KEY_FRAME) ||
4130                                        (cpi->twopass.gf_group.index == 1)
4131                                  : 0;
4132
4133   do {
4134     vpx_clear_system_state();
4135
4136     set_frame_size(cpi);
4137
4138     if (loop_count == 0 || cpi->resize_pending != 0) {
4139       set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
4140
4141 #ifdef AGGRESSIVE_VBR
4142       if (two_pass_first_group_inter(cpi)) {
4143         // Adjustment limits for min and max q
4144         qrange_adj = VPXMAX(1, (top_index - bottom_index) / 2);
4145
4146         bottom_index =
4147             VPXMAX(bottom_index - qrange_adj / 2, oxcf->best_allowed_q);
4148         top_index = VPXMIN(oxcf->worst_allowed_q, top_index + qrange_adj / 2);
4149       }
4150 #endif
4151       // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed.
4152       set_mv_search_params(cpi);
4153
4154       // Reset the loop state for new frame size.
4155       overshoot_seen = 0;
4156       undershoot_seen = 0;
4157
4158       // Reconfiguration for change in frame size has concluded.
4159       cpi->resize_pending = 0;
4160
4161       q_low = bottom_index;
4162       q_high = top_index;
4163
4164       loop_at_this_size = 0;
4165     }
4166
4167     // Decide frame size bounds first time through.
4168     if (loop_count == 0) {
4169       vp9_rc_compute_frame_size_bounds(cpi, rc->this_frame_target,
4170                                        &frame_under_shoot_limit,
4171                                        &frame_over_shoot_limit);
4172     }
4173
4174     cpi->Source =
4175         vp9_scale_if_required(cm, cpi->un_scaled_source, &cpi->scaled_source,
4176                               (oxcf->pass == 0), EIGHTTAP, 0);
4177
4178     // Unfiltered raw source used in metrics calculation if the source
4179     // has been filtered.
4180     if (is_psnr_calc_enabled(cpi)) {
4181 #ifdef ENABLE_KF_DENOISE
4182       if (is_spatial_denoise_enabled(cpi)) {
4183         cpi->raw_source_frame = vp9_scale_if_required(
4184             cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
4185             (oxcf->pass == 0), EIGHTTAP, 0);
4186       } else {
4187         cpi->raw_source_frame = cpi->Source;
4188       }
4189 #else
4190       cpi->raw_source_frame = cpi->Source;
4191 #endif
4192     }
4193
4194     if (cpi->unscaled_last_source != NULL)
4195       cpi->Last_Source = vp9_scale_if_required(cm, cpi->unscaled_last_source,
4196                                                &cpi->scaled_last_source,
4197                                                (oxcf->pass == 0), EIGHTTAP, 0);
4198
4199     if (frame_is_intra_only(cm) == 0) {
4200       if (loop_count > 0) {
4201         release_scaled_references(cpi);
4202       }
4203       vp9_scale_references(cpi);
4204     }
4205
4206     vp9_set_quantizer(cm, q);
4207
4208     if (loop_count == 0) setup_frame(cpi);
4209
4210     // Variance adaptive and in frame q adjustment experiments are mutually
4211     // exclusive.
4212     if (oxcf->aq_mode == VARIANCE_AQ) {
4213       vp9_vaq_frame_setup(cpi);
4214     } else if (oxcf->aq_mode == EQUATOR360_AQ) {
4215       vp9_360aq_frame_setup(cpi);
4216     } else if (oxcf->aq_mode == COMPLEXITY_AQ) {
4217       vp9_setup_in_frame_q_adj(cpi);
4218     } else if (oxcf->aq_mode == LOOKAHEAD_AQ) {
4219       vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi);
4220     } else if (oxcf->aq_mode == PSNR_AQ) {
4221       vp9_psnr_aq_mode_setup(&cm->seg);
4222     }
4223
4224     vp9_encode_frame(cpi);
4225
4226     // Update the skip mb flag probabilities based on the distribution
4227     // seen in the last encoder iteration.
4228     // update_base_skip_probs(cpi);
4229
4230     vpx_clear_system_state();
4231
4232     // Dummy pack of the bitstream using up to date stats to get an
4233     // accurate estimate of output frame size to determine if we need
4234     // to recode.
4235     if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF) {
4236       save_coding_context(cpi);
4237       if (!cpi->sf.use_nonrd_pick_mode) vp9_pack_bitstream(cpi, dest, size);
4238
4239       rc->projected_frame_size = (int)(*size) << 3;
4240
4241       if (frame_over_shoot_limit == 0) frame_over_shoot_limit = 1;
4242     }
4243
4244     if (oxcf->rc_mode == VPX_Q) {
4245       loop = 0;
4246     } else {
4247       if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced &&
4248           (rc->projected_frame_size < rc->max_frame_bandwidth)) {
4249         int last_q = q;
4250         int64_t kf_err;
4251
4252         int64_t high_err_target = cpi->ambient_err;
4253         int64_t low_err_target = cpi->ambient_err >> 1;
4254
4255 #if CONFIG_VP9_HIGHBITDEPTH
4256         if (cm->use_highbitdepth) {
4257           kf_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4258         } else {
4259           kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4260         }
4261 #else
4262         kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4263 #endif  // CONFIG_VP9_HIGHBITDEPTH
4264
4265         // Prevent possible divide by zero error below for perfect KF
4266         kf_err += !kf_err;
4267
4268         // The key frame is not good enough or we can afford
4269         // to make it better without undue risk of popping.
4270         if ((kf_err > high_err_target &&
4271              rc->projected_frame_size <= frame_over_shoot_limit) ||
4272             (kf_err > low_err_target &&
4273              rc->projected_frame_size <= frame_under_shoot_limit)) {
4274           // Lower q_high
4275           q_high = q > q_low ? q - 1 : q_low;
4276
4277           // Adjust Q
4278           q = (int)((q * high_err_target) / kf_err);
4279           q = VPXMIN(q, (q_high + q_low) >> 1);
4280         } else if (kf_err < low_err_target &&
4281                    rc->projected_frame_size >= frame_under_shoot_limit) {
4282           // The key frame is much better than the previous frame
4283           // Raise q_low
4284           q_low = q < q_high ? q + 1 : q_high;
4285
4286           // Adjust Q
4287           q = (int)((q * low_err_target) / kf_err);
4288           q = VPXMIN(q, (q_high + q_low + 1) >> 1);
4289         }
4290
4291         // Clamp Q to upper and lower limits:
4292         q = clamp(q, q_low, q_high);
4293
4294         loop = q != last_q;
4295       } else if (recode_loop_test(cpi, frame_over_shoot_limit,
4296                                   frame_under_shoot_limit, q,
4297                                   VPXMAX(q_high, top_index), bottom_index)) {
4298         // Is the projected frame size out of range and are we allowed
4299         // to attempt to recode.
4300         int last_q = q;
4301         int retries = 0;
4302         int qstep;
4303
4304         if (cpi->resize_pending == 1) {
4305           // Change in frame size so go back around the recode loop.
4306           cpi->rc.frame_size_selector =
4307               SCALE_STEP1 - cpi->rc.frame_size_selector;
4308           cpi->rc.next_frame_size_selector = cpi->rc.frame_size_selector;
4309
4310 #if CONFIG_INTERNAL_STATS
4311           ++cpi->tot_recode_hits;
4312 #endif
4313           ++loop_count;
4314           loop = 1;
4315           continue;
4316         }
4317
4318         // Frame size out of permitted range:
4319         // Update correction factor & compute new Q to try...
4320
4321         // Frame is too large
4322         if (rc->projected_frame_size > rc->this_frame_target) {
4323           // Special case if the projected size is > the max allowed.
4324           if ((q == q_high) &&
4325               ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
4326                (!rc->is_src_frame_alt_ref &&
4327                 (rc->projected_frame_size >=
4328                  big_rate_miss_high_threshold(cpi))))) {
4329             int max_rate = VPXMAX(1, VPXMIN(rc->max_frame_bandwidth,
4330                                             big_rate_miss_high_threshold(cpi)));
4331             double q_val_high;
4332             q_val_high = vp9_convert_qindex_to_q(q_high, cm->bit_depth);
4333             q_val_high =
4334                 q_val_high * ((double)rc->projected_frame_size / max_rate);
4335             q_high = vp9_convert_q_to_qindex(q_val_high, cm->bit_depth);
4336             q_high = clamp(q_high, rc->best_quality, rc->worst_quality);
4337           }
4338
4339           // Raise Qlow as to at least the current value
4340           qstep =
4341               get_qstep_adj(rc->projected_frame_size, rc->this_frame_target);
4342           q_low = VPXMIN(q + qstep, q_high);
4343
4344           if (undershoot_seen || loop_at_this_size > 1) {
4345             // Update rate_correction_factor unless
4346             vp9_rc_update_rate_correction_factors(cpi);
4347
4348             q = (q_high + q_low + 1) / 2;
4349           } else {
4350             // Update rate_correction_factor unless
4351             vp9_rc_update_rate_correction_factors(cpi);
4352
4353             q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4354                                   VPXMAX(q_high, top_index));
4355
4356             while (q < q_low && retries < 10) {
4357               vp9_rc_update_rate_correction_factors(cpi);
4358               q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4359                                     VPXMAX(q_high, top_index));
4360               retries++;
4361             }
4362           }
4363
4364           overshoot_seen = 1;
4365         } else {
4366           // Frame is too small
4367           qstep =
4368               get_qstep_adj(rc->this_frame_target, rc->projected_frame_size);
4369           q_high = VPXMAX(q - qstep, q_low);
4370
4371           if (overshoot_seen || loop_at_this_size > 1) {
4372             vp9_rc_update_rate_correction_factors(cpi);
4373             q = (q_high + q_low) / 2;
4374           } else {
4375             vp9_rc_update_rate_correction_factors(cpi);
4376             q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
4377                                   VPXMIN(q_low, bottom_index), top_index);
4378             // Special case reset for qlow for constrained quality.
4379             // This should only trigger where there is very substantial
4380             // undershoot on a frame and the auto cq level is above
4381             // the user passsed in value.
4382             if (oxcf->rc_mode == VPX_CQ && q < q_low) {
4383               q_low = q;
4384             }
4385
4386             while (q > q_high && retries < 10) {
4387               vp9_rc_update_rate_correction_factors(cpi);
4388               q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
4389                                     VPXMIN(q_low, bottom_index), top_index);
4390               retries++;
4391             }
4392           }
4393           undershoot_seen = 1;
4394         }
4395
4396         // Clamp Q to upper and lower limits:
4397         q = clamp(q, q_low, q_high);
4398
4399         loop = (q != last_q);
4400       } else {
4401         loop = 0;
4402       }
4403     }
4404
4405     // Special case for overlay frame.
4406     if (rc->is_src_frame_alt_ref &&
4407         rc->projected_frame_size < rc->max_frame_bandwidth)
4408       loop = 0;
4409
4410     if (loop) {
4411       ++loop_count;
4412       ++loop_at_this_size;
4413
4414 #if CONFIG_INTERNAL_STATS
4415       ++cpi->tot_recode_hits;
4416 #endif
4417     }
4418
4419     if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF)
4420       if (loop || !enable_acl) restore_coding_context(cpi);
4421   } while (loop);
4422
4423 #ifdef AGGRESSIVE_VBR
4424   if (two_pass_first_group_inter(cpi)) {
4425     cpi->twopass.active_worst_quality =
4426         VPXMIN(q + qrange_adj, oxcf->worst_allowed_q);
4427   } else if (!frame_is_kf_gf_arf(cpi)) {
4428 #else
4429   if (!frame_is_kf_gf_arf(cpi)) {
4430 #endif
4431     // Have we been forced to adapt Q outside the expected range by an extreme
4432     // rate miss. If so adjust the active maxQ for the subsequent frames.
4433     if (!rc->is_src_frame_alt_ref && (q > cpi->twopass.active_worst_quality)) {
4434       cpi->twopass.active_worst_quality = q;
4435     } else if (oxcf->vbr_corpus_complexity && q == q_low &&
4436                rc->projected_frame_size < rc->this_frame_target) {
4437       cpi->twopass.active_worst_quality =
4438           VPXMAX(q, cpi->twopass.active_worst_quality - 1);
4439     }
4440   }
4441
4442   if (enable_acl) {
4443     // Skip recoding, if model diff is below threshold
4444     const int thresh = compute_context_model_thresh(cpi);
4445     const int diff = compute_context_model_diff(cm);
4446     if (diff < thresh) {
4447       vpx_clear_system_state();
4448       restore_coding_context(cpi);
4449       return;
4450     }
4451
4452     vp9_encode_frame(cpi);
4453     vpx_clear_system_state();
4454     restore_coding_context(cpi);
4455   }
4456 }
4457 #endif  // !CONFIG_REALTIME_ONLY
4458
4459 static int get_ref_frame_flags(const VP9_COMP *cpi) {
4460   const int *const map = cpi->common.ref_frame_map;
4461   const int gold_is_last = map[cpi->gld_fb_idx] == map[cpi->lst_fb_idx];
4462   const int alt_is_last = map[cpi->alt_fb_idx] == map[cpi->lst_fb_idx];
4463   const int gold_is_alt = map[cpi->gld_fb_idx] == map[cpi->alt_fb_idx];
4464   int flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
4465
4466   if (gold_is_last) flags &= ~VP9_GOLD_FLAG;
4467
4468   if (cpi->rc.frames_till_gf_update_due == INT_MAX &&
4469       (cpi->svc.number_temporal_layers == 1 &&
4470        cpi->svc.number_spatial_layers == 1))
4471     flags &= ~VP9_GOLD_FLAG;
4472
4473   if (alt_is_last) flags &= ~VP9_ALT_FLAG;
4474
4475   if (gold_is_alt) flags &= ~VP9_ALT_FLAG;
4476
4477   return flags;
4478 }
4479
4480 static void set_ext_overrides(VP9_COMP *cpi) {
4481   // Overrides the defaults with the externally supplied values with
4482   // vp9_update_reference() and vp9_update_entropy() calls
4483   // Note: The overrides are valid only for the next frame passed
4484   // to encode_frame_to_data_rate() function
4485   if (cpi->ext_refresh_frame_context_pending) {
4486     cpi->common.refresh_frame_context = cpi->ext_refresh_frame_context;
4487     cpi->ext_refresh_frame_context_pending = 0;
4488   }
4489   if (cpi->ext_refresh_frame_flags_pending) {
4490     cpi->refresh_last_frame = cpi->ext_refresh_last_frame;
4491     cpi->refresh_golden_frame = cpi->ext_refresh_golden_frame;
4492     cpi->refresh_alt_ref_frame = cpi->ext_refresh_alt_ref_frame;
4493   }
4494 }
4495
4496 YV12_BUFFER_CONFIG *vp9_svc_twostage_scale(
4497     VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled,
4498     YV12_BUFFER_CONFIG *scaled_temp, INTERP_FILTER filter_type,
4499     int phase_scaler, INTERP_FILTER filter_type2, int phase_scaler2) {
4500   if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
4501       cm->mi_rows * MI_SIZE != unscaled->y_height) {
4502 #if CONFIG_VP9_HIGHBITDEPTH
4503     if (cm->bit_depth == VPX_BITS_8) {
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,
4507                                  phase_scaler);
4508     } else {
4509       scale_and_extend_frame(unscaled, scaled_temp, (int)cm->bit_depth,
4510                              filter_type2, phase_scaler2);
4511       scale_and_extend_frame(scaled_temp, scaled, (int)cm->bit_depth,
4512                              filter_type, phase_scaler);
4513     }
4514 #else
4515     vp9_scale_and_extend_frame(unscaled, scaled_temp, filter_type2,
4516                                phase_scaler2);
4517     vp9_scale_and_extend_frame(scaled_temp, scaled, filter_type, phase_scaler);
4518 #endif  // CONFIG_VP9_HIGHBITDEPTH
4519     return scaled;
4520   } else {
4521     return unscaled;
4522   }
4523 }
4524
4525 YV12_BUFFER_CONFIG *vp9_scale_if_required(
4526     VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled,
4527     int use_normative_scaler, INTERP_FILTER filter_type, int phase_scaler) {
4528   if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
4529       cm->mi_rows * MI_SIZE != unscaled->y_height) {
4530 #if CONFIG_VP9_HIGHBITDEPTH
4531     if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) &&
4532         unscaled->y_height <= (scaled->y_height << 1))
4533       if (cm->bit_depth == VPX_BITS_8)
4534         vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler);
4535       else
4536         scale_and_extend_frame(unscaled, scaled, (int)cm->bit_depth,
4537                                filter_type, phase_scaler);
4538     else
4539       scale_and_extend_frame_nonnormative(unscaled, scaled, (int)cm->bit_depth);
4540 #else
4541     if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) &&
4542         unscaled->y_height <= (scaled->y_height << 1))
4543       vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler);
4544     else
4545       scale_and_extend_frame_nonnormative(unscaled, scaled);
4546 #endif  // CONFIG_VP9_HIGHBITDEPTH
4547     return scaled;
4548   } else {
4549     return unscaled;
4550   }
4551 }
4552
4553 static void set_ref_sign_bias(VP9_COMP *cpi) {
4554   VP9_COMMON *const cm = &cpi->common;
4555   RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx);
4556   const int cur_frame_index = ref_buffer->frame_index;
4557   MV_REFERENCE_FRAME ref_frame;
4558
4559   for (ref_frame = LAST_FRAME; ref_frame < MAX_REF_FRAMES; ++ref_frame) {
4560     const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
4561     const RefCntBuffer *const ref_cnt_buf =
4562         get_ref_cnt_buffer(&cpi->common, buf_idx);
4563     if (ref_cnt_buf) {
4564       cm->ref_frame_sign_bias[ref_frame] =
4565           cur_frame_index < ref_cnt_buf->frame_index;
4566     }
4567   }
4568 }
4569
4570 static int setup_interp_filter_search_mask(VP9_COMP *cpi) {
4571   INTERP_FILTER ifilter;
4572   int ref_total[MAX_REF_FRAMES] = { 0 };
4573   MV_REFERENCE_FRAME ref;
4574   int mask = 0;
4575   if (cpi->common.last_frame_type == KEY_FRAME || cpi->refresh_alt_ref_frame)
4576     return mask;
4577   for (ref = LAST_FRAME; ref <= ALTREF_FRAME; ++ref)
4578     for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter)
4579       ref_total[ref] += cpi->interp_filter_selected[ref][ifilter];
4580
4581   for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter) {
4582     if ((ref_total[LAST_FRAME] &&
4583          cpi->interp_filter_selected[LAST_FRAME][ifilter] == 0) &&
4584         (ref_total[GOLDEN_FRAME] == 0 ||
4585          cpi->interp_filter_selected[GOLDEN_FRAME][ifilter] * 50 <
4586              ref_total[GOLDEN_FRAME]) &&
4587         (ref_total[ALTREF_FRAME] == 0 ||
4588          cpi->interp_filter_selected[ALTREF_FRAME][ifilter] * 50 <
4589              ref_total[ALTREF_FRAME]))
4590       mask |= 1 << ifilter;
4591   }
4592   return mask;
4593 }
4594
4595 #ifdef ENABLE_KF_DENOISE
4596 // Baseline Kernal weights for denoise
4597 static uint8_t dn_kernal_3[9] = { 1, 2, 1, 2, 4, 2, 1, 2, 1 };
4598 static uint8_t dn_kernal_5[25] = { 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 4,
4599                                    2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1 };
4600
4601 static INLINE void add_denoise_point(int centre_val, int data_val, int thresh,
4602                                      uint8_t point_weight, int *sum_val,
4603                                      int *sum_weight) {
4604   if (abs(centre_val - data_val) <= thresh) {
4605     *sum_weight += point_weight;
4606     *sum_val += (int)data_val * (int)point_weight;
4607   }
4608 }
4609
4610 static void spatial_denoise_point(uint8_t *src_ptr, const int stride,
4611                                   const int strength) {
4612   int sum_weight = 0;
4613   int sum_val = 0;
4614   int thresh = strength;
4615   int kernal_size = 5;
4616   int half_k_size = 2;
4617   int i, j;
4618   int max_diff = 0;
4619   uint8_t *tmp_ptr;
4620   uint8_t *kernal_ptr;
4621
4622   // Find the maximum deviation from the source point in the locale.
4623   tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1);
4624   for (i = 0; i < kernal_size + 2; ++i) {
4625     for (j = 0; j < kernal_size + 2; ++j) {
4626       max_diff = VPXMAX(max_diff, abs((int)*src_ptr - (int)tmp_ptr[j]));
4627     }
4628     tmp_ptr += stride;
4629   }
4630
4631   // Select the kernal size.
4632   if (max_diff > (strength + (strength >> 1))) {
4633     kernal_size = 3;
4634     half_k_size = 1;
4635     thresh = thresh >> 1;
4636   }
4637   kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5;
4638
4639   // Apply the kernal
4640   tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size;
4641   for (i = 0; i < kernal_size; ++i) {
4642     for (j = 0; j < kernal_size; ++j) {
4643       add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr,
4644                         &sum_val, &sum_weight);
4645       ++kernal_ptr;
4646     }
4647     tmp_ptr += stride;
4648   }
4649
4650   // Update the source value with the new filtered value
4651   *src_ptr = (uint8_t)((sum_val + (sum_weight >> 1)) / sum_weight);
4652 }
4653
4654 #if CONFIG_VP9_HIGHBITDEPTH
4655 static void highbd_spatial_denoise_point(uint16_t *src_ptr, const int stride,
4656                                          const int strength) {
4657   int sum_weight = 0;
4658   int sum_val = 0;
4659   int thresh = strength;
4660   int kernal_size = 5;
4661   int half_k_size = 2;
4662   int i, j;
4663   int max_diff = 0;
4664   uint16_t *tmp_ptr;
4665   uint8_t *kernal_ptr;
4666
4667   // Find the maximum deviation from the source point in the locale.
4668   tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1);
4669   for (i = 0; i < kernal_size + 2; ++i) {
4670     for (j = 0; j < kernal_size + 2; ++j) {
4671       max_diff = VPXMAX(max_diff, abs((int)src_ptr - (int)tmp_ptr[j]));
4672     }
4673     tmp_ptr += stride;
4674   }
4675
4676   // Select the kernal size.
4677   if (max_diff > (strength + (strength >> 1))) {
4678     kernal_size = 3;
4679     half_k_size = 1;
4680     thresh = thresh >> 1;
4681   }
4682   kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5;
4683
4684   // Apply the kernal
4685   tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size;
4686   for (i = 0; i < kernal_size; ++i) {
4687     for (j = 0; j < kernal_size; ++j) {
4688       add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr,
4689                         &sum_val, &sum_weight);
4690       ++kernal_ptr;
4691     }
4692     tmp_ptr += stride;
4693   }
4694
4695   // Update the source value with the new filtered value
4696   *src_ptr = (uint16_t)((sum_val + (sum_weight >> 1)) / sum_weight);
4697 }
4698 #endif  // CONFIG_VP9_HIGHBITDEPTH
4699
4700 // Apply thresholded spatial noise supression to a given buffer.
4701 static void spatial_denoise_buffer(VP9_COMP *cpi, uint8_t *buffer,
4702                                    const int stride, const int width,
4703                                    const int height, const int strength) {
4704   VP9_COMMON *const cm = &cpi->common;
4705   uint8_t *src_ptr = buffer;
4706   int row;
4707   int col;
4708
4709   for (row = 0; row < height; ++row) {
4710     for (col = 0; col < width; ++col) {
4711 #if CONFIG_VP9_HIGHBITDEPTH
4712       if (cm->use_highbitdepth)
4713         highbd_spatial_denoise_point(CONVERT_TO_SHORTPTR(&src_ptr[col]), stride,
4714                                      strength);
4715       else
4716         spatial_denoise_point(&src_ptr[col], stride, strength);
4717 #else
4718       spatial_denoise_point(&src_ptr[col], stride, strength);
4719 #endif  // CONFIG_VP9_HIGHBITDEPTH
4720     }
4721     src_ptr += stride;
4722   }
4723 }
4724
4725 // Apply thresholded spatial noise supression to source.
4726 static void spatial_denoise_frame(VP9_COMP *cpi) {
4727   YV12_BUFFER_CONFIG *src = cpi->Source;
4728   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4729   TWO_PASS *const twopass = &cpi->twopass;
4730   VP9_COMMON *const cm = &cpi->common;
4731
4732   // Base the filter strength on the current active max Q.
4733   const int q = (int)(vp9_convert_qindex_to_q(twopass->active_worst_quality,
4734                                               cm->bit_depth));
4735   int strength =
4736       VPXMAX(oxcf->arnr_strength >> 2, VPXMIN(oxcf->arnr_strength, (q >> 4)));
4737
4738   // Denoise each of Y,U and V buffers.
4739   spatial_denoise_buffer(cpi, src->y_buffer, src->y_stride, src->y_width,
4740                          src->y_height, strength);
4741
4742   strength += (strength >> 1);
4743   spatial_denoise_buffer(cpi, src->u_buffer, src->uv_stride, src->uv_width,
4744                          src->uv_height, strength << 1);
4745
4746   spatial_denoise_buffer(cpi, src->v_buffer, src->uv_stride, src->uv_width,
4747                          src->uv_height, strength << 1);
4748 }
4749 #endif  // ENABLE_KF_DENOISE
4750
4751 #if !CONFIG_REALTIME_ONLY
4752 static void vp9_try_disable_lookahead_aq(VP9_COMP *cpi, size_t *size,
4753                                          uint8_t *dest) {
4754   if (cpi->common.seg.enabled)
4755     if (ALT_REF_AQ_PROTECT_GAIN) {
4756       size_t nsize = *size;
4757       int overhead;
4758
4759       // TODO(yuryg): optimize this, as
4760       // we don't really need to repack
4761
4762       save_coding_context(cpi);
4763       vp9_disable_segmentation(&cpi->common.seg);
4764       vp9_pack_bitstream(cpi, dest, &nsize);
4765       restore_coding_context(cpi);
4766
4767       overhead = (int)*size - (int)nsize;
4768
4769       if (vp9_alt_ref_aq_disable_if(cpi->alt_ref_aq, overhead, (int)*size))
4770         vp9_encode_frame(cpi);
4771       else
4772         vp9_enable_segmentation(&cpi->common.seg);
4773     }
4774 }
4775 #endif
4776
4777 static void set_frame_index(VP9_COMP *cpi, VP9_COMMON *cm) {
4778   RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx);
4779
4780   if (ref_buffer) {
4781     const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
4782     ref_buffer->frame_index =
4783         cm->current_video_frame + gf_group->arf_src_offset[gf_group->index];
4784   }
4785 }
4786
4787 // Implementation and modifications of C. Yeo, H. L. Tan, and Y. H. Tan, "On
4788 // rate distortion optimization using SSIM," Circuits and Systems for Video
4789 // Technology, IEEE Transactions on, vol. 23, no. 7, pp. 1170-1181, 2013.
4790 // SSIM_VAR_SCALE defines the strength of the bias towards SSIM in RDO.
4791 // Some sample values are:
4792 // (for midres test set)
4793 // SSIM_VAR_SCALE  avg_psnr   ssim   ms_ssim
4794 //      8.0          9.421   -5.537  -6.898
4795 //     16.0          4.703   -5.378  -6.238
4796 //     32.0          1.929   -4.308  -4.807
4797 #define SSIM_VAR_SCALE 16.0
4798 static void set_mb_ssim_rdmult_scaling(VP9_COMP *cpi) {
4799   VP9_COMMON *cm = &cpi->common;
4800   ThreadData *td = &cpi->td;
4801   MACROBLOCK *x = &td->mb;
4802   MACROBLOCKD *xd = &x->e_mbd;
4803   uint8_t *y_buffer = cpi->Source->y_buffer;
4804   const int y_stride = cpi->Source->y_stride;
4805   const int block_size = BLOCK_16X16;
4806
4807   const int num_8x8_w = num_8x8_blocks_wide_lookup[block_size];
4808   const int num_8x8_h = num_8x8_blocks_high_lookup[block_size];
4809   const int num_cols = (cm->mi_cols + num_8x8_w - 1) / num_8x8_w;
4810   const int num_rows = (cm->mi_rows + num_8x8_h - 1) / num_8x8_h;
4811   double log_sum = 0.0;
4812   int row, col;
4813
4814   const double c2 = 58.5225 * SSIM_VAR_SCALE;  // 58.5225 = (.03*255)^2
4815
4816   // Loop through each 64x64 block.
4817   for (row = 0; row < num_rows; ++row) {
4818     for (col = 0; col < num_cols; ++col) {
4819       int mi_row, mi_col;
4820       double var = 0.0, num_of_var = 0.0;
4821       const int index = row * num_cols + col;
4822
4823       for (mi_row = row * num_8x8_h;
4824            mi_row < cm->mi_rows && mi_row < (row + 1) * num_8x8_h; ++mi_row) {
4825         for (mi_col = col * num_8x8_w;
4826              mi_col < cm->mi_cols && mi_col < (col + 1) * num_8x8_w; ++mi_col) {
4827           struct buf_2d buf;
4828           const int row_offset_y = mi_row << 3;
4829           const int col_offset_y = mi_col << 3;
4830
4831           buf.buf = y_buffer + row_offset_y * y_stride + col_offset_y;
4832           buf.stride = y_stride;
4833
4834           // In order to make SSIM_VAR_SCALE in a same scale for both 8 bit
4835           // and high bit videos, the variance needs to be divided by 2.0 or
4836           // 64.0 separately.
4837           // TODO(sdeng): need to tune for 12bit videos.
4838 #if CONFIG_VP9_HIGHBITDEPTH
4839           if (cpi->Source->flags & YV12_FLAG_HIGHBITDEPTH)
4840             var += vp9_high_get_sby_variance(cpi, &buf, BLOCK_8X8, xd->bd);
4841           else
4842 #endif
4843             var += vp9_get_sby_variance(cpi, &buf, BLOCK_8X8);
4844
4845           num_of_var += 1.0;
4846         }
4847       }
4848       var = var / num_of_var / 64.0;
4849       var = 2.0 * var + c2;
4850       cpi->mi_ssim_rdmult_scaling_factors[index] = var;
4851       log_sum += log(var);
4852     }
4853   }
4854   log_sum = exp(log_sum / (double)(num_rows * num_cols));
4855
4856   for (row = 0; row < num_rows; ++row) {
4857     for (col = 0; col < num_cols; ++col) {
4858       const int index = row * num_cols + col;
4859       cpi->mi_ssim_rdmult_scaling_factors[index] /= log_sum;
4860     }
4861   }
4862
4863   (void)xd;
4864 }
4865
4866 // Process the wiener variance in 16x16 block basis.
4867 static int qsort_comp(const void *elem1, const void *elem2) {
4868   int a = *((const int *)elem1);
4869   int b = *((const int *)elem2);
4870   if (a > b) return 1;
4871   if (a < b) return -1;
4872   return 0;
4873 }
4874
4875 static void init_mb_wiener_var_buffer(VP9_COMP *cpi) {
4876   VP9_COMMON *cm = &cpi->common;
4877
4878   if (cpi->mb_wiener_variance && cpi->mb_wiener_var_rows >= cm->mb_rows &&
4879       cpi->mb_wiener_var_cols >= cm->mb_cols)
4880     return;
4881
4882   vpx_free(cpi->mb_wiener_variance);
4883   cpi->mb_wiener_variance = NULL;
4884
4885   CHECK_MEM_ERROR(
4886       cm, cpi->mb_wiener_variance,
4887       vpx_calloc(cm->mb_rows * cm->mb_cols, sizeof(*cpi->mb_wiener_variance)));
4888   cpi->mb_wiener_var_rows = cm->mb_rows;
4889   cpi->mb_wiener_var_cols = cm->mb_cols;
4890 }
4891
4892 static void set_mb_wiener_variance(VP9_COMP *cpi) {
4893   VP9_COMMON *cm = &cpi->common;
4894   uint8_t *buffer = cpi->Source->y_buffer;
4895   int buf_stride = cpi->Source->y_stride;
4896
4897 #if CONFIG_VP9_HIGHBITDEPTH
4898   ThreadData *td = &cpi->td;
4899   MACROBLOCK *x = &td->mb;
4900   MACROBLOCKD *xd = &x->e_mbd;
4901   DECLARE_ALIGNED(16, uint16_t, zero_pred16[32 * 32]);
4902   DECLARE_ALIGNED(16, uint8_t, zero_pred8[32 * 32]);
4903   uint8_t *zero_pred;
4904 #else
4905   DECLARE_ALIGNED(16, uint8_t, zero_pred[32 * 32]);
4906 #endif
4907
4908   DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]);
4909   DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]);
4910
4911   int mb_row, mb_col, count = 0;
4912   // Hard coded operating block size
4913   const int block_size = 16;
4914   const int coeff_count = block_size * block_size;
4915   const TX_SIZE tx_size = TX_16X16;
4916
4917 #if CONFIG_VP9_HIGHBITDEPTH
4918   xd->cur_buf = cpi->Source;
4919   if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
4920     zero_pred = CONVERT_TO_BYTEPTR(zero_pred16);
4921     memset(zero_pred16, 0, sizeof(*zero_pred16) * coeff_count);
4922   } else {
4923     zero_pred = zero_pred8;
4924     memset(zero_pred8, 0, sizeof(*zero_pred8) * coeff_count);
4925   }
4926 #else
4927   memset(zero_pred, 0, sizeof(*zero_pred) * coeff_count);
4928 #endif
4929
4930   cpi->norm_wiener_variance = 0;
4931
4932   for (mb_row = 0; mb_row < cm->mb_rows; ++mb_row) {
4933     for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {
4934       int idx;
4935       int16_t median_val = 0;
4936       uint8_t *mb_buffer =
4937           buffer + mb_row * block_size * buf_stride + mb_col * block_size;
4938       int64_t wiener_variance = 0;
4939
4940 #if CONFIG_VP9_HIGHBITDEPTH
4941       if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
4942         vpx_highbd_subtract_block(block_size, block_size, src_diff, block_size,
4943                                   mb_buffer, buf_stride, zero_pred, block_size,
4944                                   xd->bd);
4945         highbd_wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
4946       } else {
4947         vpx_subtract_block(block_size, block_size, src_diff, block_size,
4948                            mb_buffer, buf_stride, zero_pred, block_size);
4949         wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
4950       }
4951 #else
4952       vpx_subtract_block(block_size, block_size, src_diff, block_size,
4953                          mb_buffer, buf_stride, zero_pred, block_size);
4954       wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
4955 #endif  // CONFIG_VP9_HIGHBITDEPTH
4956
4957       coeff[0] = 0;
4958       for (idx = 1; idx < coeff_count; ++idx) coeff[idx] = abs(coeff[idx]);
4959
4960       qsort(coeff, coeff_count - 1, sizeof(*coeff), qsort_comp);
4961
4962       // Noise level estimation
4963       median_val = coeff[coeff_count / 2];
4964
4965       // Wiener filter
4966       for (idx = 1; idx < coeff_count; ++idx) {
4967         int64_t sqr_coeff = (int64_t)coeff[idx] * coeff[idx];
4968         int64_t tmp_coeff = (int64_t)coeff[idx];
4969         if (median_val) {
4970           tmp_coeff = (sqr_coeff * coeff[idx]) /
4971                       (sqr_coeff + (int64_t)median_val * median_val);
4972         }
4973         wiener_variance += tmp_coeff * tmp_coeff;
4974       }
4975       cpi->mb_wiener_variance[mb_row * cm->mb_cols + mb_col] =
4976           wiener_variance / coeff_count;
4977       cpi->norm_wiener_variance +=
4978           cpi->mb_wiener_variance[mb_row * cm->mb_cols + mb_col];
4979       ++count;
4980     }
4981   }
4982
4983   if (count) cpi->norm_wiener_variance /= count;
4984   cpi->norm_wiener_variance = VPXMAX(1, cpi->norm_wiener_variance);
4985 }
4986
4987 static void encode_frame_to_data_rate(VP9_COMP *cpi, size_t *size,
4988                                       uint8_t *dest,
4989                                       unsigned int *frame_flags) {
4990   VP9_COMMON *const cm = &cpi->common;
4991   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4992   struct segmentation *const seg = &cm->seg;
4993   TX_SIZE t;
4994
4995   // SVC: skip encoding of enhancement layer if the layer target bandwidth = 0.
4996   // If in constrained layer drop mode (svc.framedrop_mode != LAYER_DROP) and
4997   // base spatial layer was dropped, no need to set svc.skip_enhancement_layer,
4998   // as whole superframe will be dropped.
4999   if (cpi->use_svc && cpi->svc.spatial_layer_id > 0 &&
5000       cpi->oxcf.target_bandwidth == 0 &&
5001       !(cpi->svc.framedrop_mode != LAYER_DROP &&
5002         cpi->svc.drop_spatial_layer[0])) {
5003     cpi->svc.skip_enhancement_layer = 1;
5004     vp9_rc_postencode_update_drop_frame(cpi);
5005     cpi->ext_refresh_frame_flags_pending = 0;
5006     cpi->last_frame_dropped = 1;
5007     cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 1;
5008     cpi->svc.drop_spatial_layer[cpi->svc.spatial_layer_id] = 1;
5009     if (cpi->svc.framedrop_mode == LAYER_DROP ||
5010         cpi->svc.drop_spatial_layer[0] == 0) {
5011       // For the case of constrained drop mode where the base is dropped
5012       // (drop_spatial_layer[0] == 1), which means full superframe dropped,
5013       // we don't increment the svc frame counters. In particular temporal
5014       // layer counter (which is incremented in vp9_inc_frame_in_layer())
5015       // won't be incremented, so on a dropped frame we try the same
5016       // temporal_layer_id on next incoming frame. This is to avoid an
5017       // issue with temporal alignement with full superframe dropping.
5018       vp9_inc_frame_in_layer(cpi);
5019     }
5020     return;
5021   }
5022
5023   set_ext_overrides(cpi);
5024   vpx_clear_system_state();
5025
5026 #ifdef ENABLE_KF_DENOISE
5027   // Spatial denoise of key frame.
5028   if (is_spatial_denoise_enabled(cpi)) spatial_denoise_frame(cpi);
5029 #endif
5030
5031   if (cm->show_existing_frame == 0) {
5032     // Update frame index
5033     set_frame_index(cpi, cm);
5034
5035     // Set the arf sign bias for this frame.
5036     set_ref_sign_bias(cpi);
5037   }
5038
5039   // Set default state for segment based loop filter update flags.
5040   cm->lf.mode_ref_delta_update = 0;
5041
5042   if (cpi->oxcf.pass == 2 && cpi->sf.adaptive_interp_filter_search)
5043     cpi->sf.interp_filter_search_mask = setup_interp_filter_search_mask(cpi);
5044
5045   // Set various flags etc to special state if it is a key frame.
5046   if (frame_is_intra_only(cm)) {
5047     // Reset the loop filter deltas and segmentation map.
5048     vp9_reset_segment_features(&cm->seg);
5049
5050     // If segmentation is enabled force a map update for key frames.
5051     if (seg->enabled) {
5052       seg->update_map = 1;
5053       seg->update_data = 1;
5054     }
5055
5056     // The alternate reference frame cannot be active for a key frame.
5057     cpi->rc.source_alt_ref_active = 0;
5058
5059     cm->error_resilient_mode = oxcf->error_resilient_mode;
5060     cm->frame_parallel_decoding_mode = oxcf->frame_parallel_decoding_mode;
5061
5062     // By default, encoder assumes decoder can use prev_mi.
5063     if (cm->error_resilient_mode) {
5064       cm->frame_parallel_decoding_mode = 1;
5065       cm->reset_frame_context = 0;
5066       cm->refresh_frame_context = 0;
5067     } else if (cm->intra_only) {
5068       // Only reset the current context.
5069       cm->reset_frame_context = 2;
5070     }
5071   }
5072
5073   if (oxcf->tuning == VP8_TUNE_SSIM) set_mb_ssim_rdmult_scaling(cpi);
5074
5075   if (oxcf->aq_mode == PERCEPTUAL_AQ) {
5076     init_mb_wiener_var_buffer(cpi);
5077     set_mb_wiener_variance(cpi);
5078   }
5079
5080   vpx_clear_system_state();
5081
5082 #if CONFIG_INTERNAL_STATS
5083   memset(cpi->mode_chosen_counts, 0,
5084          MAX_MODES * sizeof(*cpi->mode_chosen_counts));
5085 #endif
5086 #if CONFIG_CONSISTENT_RECODE
5087   // Backup to ensure consistency between recodes
5088   save_encode_params(cpi);
5089 #endif
5090
5091   if (cpi->sf.recode_loop == DISALLOW_RECODE) {
5092     if (!encode_without_recode_loop(cpi, size, dest)) return;
5093   } else {
5094 #if !CONFIG_REALTIME_ONLY
5095     encode_with_recode_loop(cpi, size, dest);
5096 #endif
5097   }
5098
5099   // TODO(jingning): When using show existing frame mode, we assume that the
5100   // current ARF will be directly used as the final reconstructed frame. This is
5101   // an encoder control scheme. One could in principle explore other
5102   // possibilities to arrange the reference frame buffer and their coding order.
5103   if (cm->show_existing_frame) {
5104     ref_cnt_fb(cm->buffer_pool->frame_bufs, &cm->new_fb_idx,
5105                cm->ref_frame_map[cpi->alt_fb_idx]);
5106   }
5107
5108 #if !CONFIG_REALTIME_ONLY
5109   // Disable segmentation if it decrease rate/distortion ratio
5110   if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ)
5111     vp9_try_disable_lookahead_aq(cpi, size, dest);
5112 #endif
5113
5114 #if CONFIG_VP9_TEMPORAL_DENOISING
5115 #ifdef OUTPUT_YUV_DENOISED
5116   if (oxcf->noise_sensitivity > 0 && denoise_svc(cpi)) {
5117     vpx_write_yuv_frame(yuv_denoised_file,
5118                         &cpi->denoiser.running_avg_y[INTRA_FRAME]);
5119   }
5120 #endif
5121 #endif
5122 #ifdef OUTPUT_YUV_SKINMAP
5123   if (cpi->common.current_video_frame > 1) {
5124     vp9_output_skin_map(cpi, yuv_skinmap_file);
5125   }
5126 #endif
5127
5128   // Special case code to reduce pulsing when key frames are forced at a
5129   // fixed interval. Note the reconstruction error if it is the frame before
5130   // the force key frame
5131   if (cpi->rc.next_key_frame_forced && cpi->rc.frames_to_key == 1) {
5132 #if CONFIG_VP9_HIGHBITDEPTH
5133     if (cm->use_highbitdepth) {
5134       cpi->ambient_err =
5135           vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5136     } else {
5137       cpi->ambient_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5138     }
5139 #else
5140     cpi->ambient_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5141 #endif  // CONFIG_VP9_HIGHBITDEPTH
5142   }
5143
5144   // If the encoder forced a KEY_FRAME decision
5145   if (cm->frame_type == KEY_FRAME) cpi->refresh_last_frame = 1;
5146
5147   cm->frame_to_show = get_frame_new_buffer(cm);
5148   cm->frame_to_show->color_space = cm->color_space;
5149   cm->frame_to_show->color_range = cm->color_range;
5150   cm->frame_to_show->render_width = cm->render_width;
5151   cm->frame_to_show->render_height = cm->render_height;
5152
5153   // Pick the loop filter level for the frame.
5154   loopfilter_frame(cpi, cm);
5155
5156   if (cpi->rc.use_post_encode_drop) save_coding_context(cpi);
5157
5158   // build the bitstream
5159   vp9_pack_bitstream(cpi, dest, size);
5160
5161   if (cpi->rc.use_post_encode_drop && cm->base_qindex < cpi->rc.worst_quality &&
5162       cpi->svc.spatial_layer_id == 0 && post_encode_drop_cbr(cpi, size)) {
5163     restore_coding_context(cpi);
5164     return;
5165   }
5166
5167   cpi->last_frame_dropped = 0;
5168   cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 0;
5169   if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1)
5170     cpi->svc.num_encoded_top_layer++;
5171
5172   // Keep track of the frame buffer index updated/refreshed for the
5173   // current encoded TL0 superframe.
5174   if (cpi->svc.temporal_layer_id == 0) {
5175     if (cpi->refresh_last_frame)
5176       cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->lst_fb_idx;
5177     else if (cpi->refresh_golden_frame)
5178       cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->gld_fb_idx;
5179     else if (cpi->refresh_alt_ref_frame)
5180       cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->alt_fb_idx;
5181   }
5182
5183   if (cm->seg.update_map) update_reference_segmentation_map(cpi);
5184
5185   if (frame_is_intra_only(cm) == 0) {
5186     release_scaled_references(cpi);
5187   }
5188   vp9_update_reference_frames(cpi);
5189
5190   if (!cm->show_existing_frame) {
5191     for (t = TX_4X4; t <= TX_32X32; ++t) {
5192       full_to_model_counts(cpi->td.counts->coef[t],
5193                            cpi->td.rd_counts.coef_counts[t]);
5194     }
5195
5196     if (!cm->error_resilient_mode && !cm->frame_parallel_decoding_mode) {
5197       if (!frame_is_intra_only(cm)) {
5198         vp9_adapt_mode_probs(cm);
5199         vp9_adapt_mv_probs(cm, cm->allow_high_precision_mv);
5200       }
5201       vp9_adapt_coef_probs(cm);
5202     }
5203   }
5204
5205   cpi->ext_refresh_frame_flags_pending = 0;
5206
5207   if (cpi->refresh_golden_frame == 1)
5208     cpi->frame_flags |= FRAMEFLAGS_GOLDEN;
5209   else
5210     cpi->frame_flags &= ~FRAMEFLAGS_GOLDEN;
5211
5212   if (cpi->refresh_alt_ref_frame == 1)
5213     cpi->frame_flags |= FRAMEFLAGS_ALTREF;
5214   else
5215     cpi->frame_flags &= ~FRAMEFLAGS_ALTREF;
5216
5217   cpi->ref_frame_flags = get_ref_frame_flags(cpi);
5218
5219   cm->last_frame_type = cm->frame_type;
5220
5221   vp9_rc_postencode_update(cpi, *size);
5222
5223   *size = VPXMAX(1, *size);
5224
5225 #if 0
5226   output_frame_level_debug_stats(cpi);
5227 #endif
5228
5229   if (cm->frame_type == KEY_FRAME) {
5230     // Tell the caller that the frame was coded as a key frame
5231     *frame_flags = cpi->frame_flags | FRAMEFLAGS_KEY;
5232   } else {
5233     *frame_flags = cpi->frame_flags & ~FRAMEFLAGS_KEY;
5234   }
5235
5236   // Clear the one shot update flags for segmentation map and mode/ref loop
5237   // filter deltas.
5238   cm->seg.update_map = 0;
5239   cm->seg.update_data = 0;
5240   cm->lf.mode_ref_delta_update = 0;
5241
5242   // keep track of the last coded dimensions
5243   cm->last_width = cm->width;
5244   cm->last_height = cm->height;
5245
5246   // reset to normal state now that we are done.
5247   if (!cm->show_existing_frame) {
5248     cm->last_show_frame = cm->show_frame;
5249     cm->prev_frame = cm->cur_frame;
5250   }
5251
5252   if (cm->show_frame) {
5253     vp9_swap_mi_and_prev_mi(cm);
5254     // Don't increment frame counters if this was an altref buffer
5255     // update not a real frame
5256     ++cm->current_video_frame;
5257     if (cpi->use_svc) vp9_inc_frame_in_layer(cpi);
5258   }
5259
5260   if (cpi->use_svc) {
5261     cpi->svc
5262         .layer_context[cpi->svc.spatial_layer_id *
5263                            cpi->svc.number_temporal_layers +
5264                        cpi->svc.temporal_layer_id]
5265         .last_frame_type = cm->frame_type;
5266     // Reset layer_sync back to 0 for next frame.
5267     cpi->svc.spatial_layer_sync[cpi->svc.spatial_layer_id] = 0;
5268   }
5269
5270   cpi->force_update_segmentation = 0;
5271
5272 #if !CONFIG_REALTIME_ONLY
5273   if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ)
5274     vp9_alt_ref_aq_unset_all(cpi->alt_ref_aq, cpi);
5275 #endif
5276
5277   cpi->svc.previous_frame_is_intra_only = cm->intra_only;
5278   cpi->svc.set_intra_only_frame = 0;
5279 }
5280
5281 static void SvcEncode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5282                       unsigned int *frame_flags) {
5283   vp9_rc_get_svc_params(cpi);
5284   encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5285 }
5286
5287 static void Pass0Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5288                         unsigned int *frame_flags) {
5289   if (cpi->oxcf.rc_mode == VPX_CBR) {
5290     vp9_rc_get_one_pass_cbr_params(cpi);
5291   } else {
5292     vp9_rc_get_one_pass_vbr_params(cpi);
5293   }
5294   encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5295 }
5296
5297 #if !CONFIG_REALTIME_ONLY
5298 static void Pass2Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5299                         unsigned int *frame_flags) {
5300   cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
5301 #if CONFIG_MISMATCH_DEBUG
5302   mismatch_move_frame_idx_w();
5303 #endif
5304   encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5305
5306   vp9_twopass_postencode_update(cpi);
5307 }
5308 #endif  // !CONFIG_REALTIME_ONLY
5309
5310 static void init_ref_frame_bufs(VP9_COMMON *cm) {
5311   int i;
5312   BufferPool *const pool = cm->buffer_pool;
5313   cm->new_fb_idx = INVALID_IDX;
5314   for (i = 0; i < REF_FRAMES; ++i) {
5315     cm->ref_frame_map[i] = INVALID_IDX;
5316   }
5317   for (i = 0; i < FRAME_BUFFERS; ++i) {
5318     pool->frame_bufs[i].ref_count = 0;
5319   }
5320 }
5321
5322 static void check_initial_width(VP9_COMP *cpi,
5323 #if CONFIG_VP9_HIGHBITDEPTH
5324                                 int use_highbitdepth,
5325 #endif
5326                                 int subsampling_x, int subsampling_y) {
5327   VP9_COMMON *const cm = &cpi->common;
5328
5329   if (!cpi->initial_width ||
5330 #if CONFIG_VP9_HIGHBITDEPTH
5331       cm->use_highbitdepth != use_highbitdepth ||
5332 #endif
5333       cm->subsampling_x != subsampling_x ||
5334       cm->subsampling_y != subsampling_y) {
5335     cm->subsampling_x = subsampling_x;
5336     cm->subsampling_y = subsampling_y;
5337 #if CONFIG_VP9_HIGHBITDEPTH
5338     cm->use_highbitdepth = use_highbitdepth;
5339 #endif
5340
5341     alloc_raw_frame_buffers(cpi);
5342     init_ref_frame_bufs(cm);
5343     alloc_util_frame_buffers(cpi);
5344
5345     init_motion_estimation(cpi);  // TODO(agrange) This can be removed.
5346
5347     cpi->initial_width = cm->width;
5348     cpi->initial_height = cm->height;
5349     cpi->initial_mbs = cm->MBs;
5350   }
5351 }
5352
5353 int vp9_receive_raw_frame(VP9_COMP *cpi, vpx_enc_frame_flags_t frame_flags,
5354                           YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
5355                           int64_t end_time) {
5356   VP9_COMMON *const cm = &cpi->common;
5357   struct vpx_usec_timer timer;
5358   int res = 0;
5359   const int subsampling_x = sd->subsampling_x;
5360   const int subsampling_y = sd->subsampling_y;
5361 #if CONFIG_VP9_HIGHBITDEPTH
5362   const int use_highbitdepth = (sd->flags & YV12_FLAG_HIGHBITDEPTH) != 0;
5363 #endif
5364
5365 #if CONFIG_VP9_HIGHBITDEPTH
5366   check_initial_width(cpi, use_highbitdepth, subsampling_x, subsampling_y);
5367 #else
5368   check_initial_width(cpi, subsampling_x, subsampling_y);
5369 #endif  // CONFIG_VP9_HIGHBITDEPTH
5370
5371 #if CONFIG_VP9_HIGHBITDEPTH
5372   // Disable denoiser for high bitdepth since vp9_denoiser_filter only works for
5373   // 8 bits.
5374   if (cm->bit_depth > 8) cpi->oxcf.noise_sensitivity = 0;
5375 #endif
5376
5377 #if CONFIG_VP9_TEMPORAL_DENOISING
5378   setup_denoiser_buffer(cpi);
5379 #endif
5380   vpx_usec_timer_start(&timer);
5381
5382   if (vp9_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
5383 #if CONFIG_VP9_HIGHBITDEPTH
5384                          use_highbitdepth,
5385 #endif  // CONFIG_VP9_HIGHBITDEPTH
5386                          frame_flags))
5387     res = -1;
5388   vpx_usec_timer_mark(&timer);
5389   cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
5390
5391   if ((cm->profile == PROFILE_0 || cm->profile == PROFILE_2) &&
5392       (subsampling_x != 1 || subsampling_y != 1)) {
5393     vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
5394                        "Non-4:2:0 color format requires profile 1 or 3");
5395     res = -1;
5396   }
5397   if ((cm->profile == PROFILE_1 || cm->profile == PROFILE_3) &&
5398       (subsampling_x == 1 && subsampling_y == 1)) {
5399     vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
5400                        "4:2:0 color format requires profile 0 or 2");
5401     res = -1;
5402   }
5403
5404   return res;
5405 }
5406
5407 static int frame_is_reference(const VP9_COMP *cpi) {
5408   const VP9_COMMON *cm = &cpi->common;
5409
5410   return cm->frame_type == KEY_FRAME || cpi->refresh_last_frame ||
5411          cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame ||
5412          cm->refresh_frame_context || cm->lf.mode_ref_delta_update ||
5413          cm->seg.update_map || cm->seg.update_data;
5414 }
5415
5416 static void adjust_frame_rate(VP9_COMP *cpi,
5417                               const struct lookahead_entry *source) {
5418   int64_t this_duration;
5419   int step = 0;
5420
5421   if (source->ts_start == cpi->first_time_stamp_ever) {
5422     this_duration = source->ts_end - source->ts_start;
5423     step = 1;
5424   } else {
5425     int64_t last_duration =
5426         cpi->last_end_time_stamp_seen - cpi->last_time_stamp_seen;
5427
5428     this_duration = source->ts_end - cpi->last_end_time_stamp_seen;
5429
5430     // do a step update if the duration changes by 10%
5431     if (last_duration)
5432       step = (int)((this_duration - last_duration) * 10 / last_duration);
5433   }
5434
5435   if (this_duration) {
5436     if (step) {
5437       vp9_new_framerate(cpi, 10000000.0 / this_duration);
5438     } else {
5439       // Average this frame's rate into the last second's average
5440       // frame rate. If we haven't seen 1 second yet, then average
5441       // over the whole interval seen.
5442       const double interval = VPXMIN(
5443           (double)(source->ts_end - cpi->first_time_stamp_ever), 10000000.0);
5444       double avg_duration = 10000000.0 / cpi->framerate;
5445       avg_duration *= (interval - avg_duration + this_duration);
5446       avg_duration /= interval;
5447
5448       vp9_new_framerate(cpi, 10000000.0 / avg_duration);
5449     }
5450   }
5451   cpi->last_time_stamp_seen = source->ts_start;
5452   cpi->last_end_time_stamp_seen = source->ts_end;
5453 }
5454
5455 // Returns 0 if this is not an alt ref else the offset of the source frame
5456 // used as the arf midpoint.
5457 static int get_arf_src_index(VP9_COMP *cpi) {
5458   RATE_CONTROL *const rc = &cpi->rc;
5459   int arf_src_index = 0;
5460   if (is_altref_enabled(cpi)) {
5461     if (cpi->oxcf.pass == 2) {
5462       const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
5463       if (gf_group->update_type[gf_group->index] == ARF_UPDATE) {
5464         arf_src_index = gf_group->arf_src_offset[gf_group->index];
5465       }
5466     } else if (rc->source_alt_ref_pending) {
5467       arf_src_index = rc->frames_till_gf_update_due;
5468     }
5469   }
5470   return arf_src_index;
5471 }
5472
5473 static void check_src_altref(VP9_COMP *cpi,
5474                              const struct lookahead_entry *source) {
5475   RATE_CONTROL *const rc = &cpi->rc;
5476
5477   if (cpi->oxcf.pass == 2) {
5478     const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
5479     rc->is_src_frame_alt_ref =
5480         (gf_group->update_type[gf_group->index] == OVERLAY_UPDATE);
5481   } else {
5482     rc->is_src_frame_alt_ref =
5483         cpi->alt_ref_source && (source == cpi->alt_ref_source);
5484   }
5485
5486   if (rc->is_src_frame_alt_ref) {
5487     // Current frame is an ARF overlay frame.
5488     cpi->alt_ref_source = NULL;
5489
5490     // Don't refresh the last buffer for an ARF overlay frame. It will
5491     // become the GF so preserve last as an alternative prediction option.
5492     cpi->refresh_last_frame = 0;
5493   }
5494 }
5495
5496 #if CONFIG_INTERNAL_STATS
5497 static void adjust_image_stat(double y, double u, double v, double all,
5498                               ImageStat *s) {
5499   s->stat[Y] += y;
5500   s->stat[U] += u;
5501   s->stat[V] += v;
5502   s->stat[ALL] += all;
5503   s->worst = VPXMIN(s->worst, all);
5504 }
5505 #endif  // CONFIG_INTERNAL_STATS
5506
5507 // Adjust the maximum allowable frame size for the target level.
5508 static void level_rc_framerate(VP9_COMP *cpi, int arf_src_index) {
5509   RATE_CONTROL *const rc = &cpi->rc;
5510   LevelConstraint *const ls = &cpi->level_constraint;
5511   VP9_COMMON *const cm = &cpi->common;
5512   const double max_cpb_size = ls->max_cpb_size;
5513   vpx_clear_system_state();
5514   rc->max_frame_bandwidth = VPXMIN(rc->max_frame_bandwidth, ls->max_frame_size);
5515   if (frame_is_intra_only(cm)) {
5516     rc->max_frame_bandwidth =
5517         VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.5));
5518   } else if (arf_src_index > 0) {
5519     rc->max_frame_bandwidth =
5520         VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.4));
5521   } else {
5522     rc->max_frame_bandwidth =
5523         VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.2));
5524   }
5525 }
5526
5527 static void update_level_info(VP9_COMP *cpi, size_t *size, int arf_src_index) {
5528   VP9_COMMON *const cm = &cpi->common;
5529   Vp9LevelInfo *const level_info = &cpi->level_info;
5530   Vp9LevelSpec *const level_spec = &level_info->level_spec;
5531   Vp9LevelStats *const level_stats = &level_info->level_stats;
5532   int i, idx;
5533   uint64_t luma_samples, dur_end;
5534   const uint32_t luma_pic_size = cm->width * cm->height;
5535   const uint32_t luma_pic_breadth = VPXMAX(cm->width, cm->height);
5536   LevelConstraint *const level_constraint = &cpi->level_constraint;
5537   const int8_t level_index = level_constraint->level_index;
5538   double cpb_data_size;
5539
5540   vpx_clear_system_state();
5541
5542   // update level_stats
5543   level_stats->total_compressed_size += *size;
5544   if (cm->show_frame) {
5545     level_stats->total_uncompressed_size +=
5546         luma_pic_size +
5547         2 * (luma_pic_size >> (cm->subsampling_x + cm->subsampling_y));
5548     level_stats->time_encoded =
5549         (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
5550         (double)TICKS_PER_SEC;
5551   }
5552
5553   if (arf_src_index > 0) {
5554     if (!level_stats->seen_first_altref) {
5555       level_stats->seen_first_altref = 1;
5556     } else if (level_stats->frames_since_last_altref <
5557                level_spec->min_altref_distance) {
5558       level_spec->min_altref_distance = level_stats->frames_since_last_altref;
5559     }
5560     level_stats->frames_since_last_altref = 0;
5561   } else {
5562     ++level_stats->frames_since_last_altref;
5563   }
5564
5565   if (level_stats->frame_window_buffer.len < FRAME_WINDOW_SIZE - 1) {
5566     idx = (level_stats->frame_window_buffer.start +
5567            level_stats->frame_window_buffer.len++) %
5568           FRAME_WINDOW_SIZE;
5569   } else {
5570     idx = level_stats->frame_window_buffer.start;
5571     level_stats->frame_window_buffer.start = (idx + 1) % FRAME_WINDOW_SIZE;
5572   }
5573   level_stats->frame_window_buffer.buf[idx].ts = cpi->last_time_stamp_seen;
5574   level_stats->frame_window_buffer.buf[idx].size = (uint32_t)(*size);
5575   level_stats->frame_window_buffer.buf[idx].luma_samples = luma_pic_size;
5576
5577   if (cm->frame_type == KEY_FRAME) {
5578     level_stats->ref_refresh_map = 0;
5579   } else {
5580     int count = 0;
5581     level_stats->ref_refresh_map |= vp9_get_refresh_mask(cpi);
5582     // Also need to consider the case where the encoder refers to a buffer
5583     // that has been implicitly refreshed after encoding a keyframe.
5584     if (!cm->intra_only) {
5585       level_stats->ref_refresh_map |= (1 << cpi->lst_fb_idx);
5586       level_stats->ref_refresh_map |= (1 << cpi->gld_fb_idx);
5587       level_stats->ref_refresh_map |= (1 << cpi->alt_fb_idx);
5588     }
5589     for (i = 0; i < REF_FRAMES; ++i) {
5590       count += (level_stats->ref_refresh_map >> i) & 1;
5591     }
5592     if (count > level_spec->max_ref_frame_buffers) {
5593       level_spec->max_ref_frame_buffers = count;
5594     }
5595   }
5596
5597   // update average_bitrate
5598   level_spec->average_bitrate = (double)level_stats->total_compressed_size /
5599                                 125.0 / level_stats->time_encoded;
5600
5601   // update max_luma_sample_rate
5602   luma_samples = 0;
5603   for (i = 0; i < level_stats->frame_window_buffer.len; ++i) {
5604     idx = (level_stats->frame_window_buffer.start +
5605            level_stats->frame_window_buffer.len - 1 - i) %
5606           FRAME_WINDOW_SIZE;
5607     if (i == 0) {
5608       dur_end = level_stats->frame_window_buffer.buf[idx].ts;
5609     }
5610     if (dur_end - level_stats->frame_window_buffer.buf[idx].ts >=
5611         TICKS_PER_SEC) {
5612       break;
5613     }
5614     luma_samples += level_stats->frame_window_buffer.buf[idx].luma_samples;
5615   }
5616   if (luma_samples > level_spec->max_luma_sample_rate) {
5617     level_spec->max_luma_sample_rate = luma_samples;
5618   }
5619
5620   // update max_cpb_size
5621   cpb_data_size = 0;
5622   for (i = 0; i < CPB_WINDOW_SIZE; ++i) {
5623     if (i >= level_stats->frame_window_buffer.len) break;
5624     idx = (level_stats->frame_window_buffer.start +
5625            level_stats->frame_window_buffer.len - 1 - i) %
5626           FRAME_WINDOW_SIZE;
5627     cpb_data_size += level_stats->frame_window_buffer.buf[idx].size;
5628   }
5629   cpb_data_size = cpb_data_size / 125.0;
5630   if (cpb_data_size > level_spec->max_cpb_size) {
5631     level_spec->max_cpb_size = cpb_data_size;
5632   }
5633
5634   // update max_luma_picture_size
5635   if (luma_pic_size > level_spec->max_luma_picture_size) {
5636     level_spec->max_luma_picture_size = luma_pic_size;
5637   }
5638
5639   // update max_luma_picture_breadth
5640   if (luma_pic_breadth > level_spec->max_luma_picture_breadth) {
5641     level_spec->max_luma_picture_breadth = luma_pic_breadth;
5642   }
5643
5644   // update compression_ratio
5645   level_spec->compression_ratio = (double)level_stats->total_uncompressed_size *
5646                                   cm->bit_depth /
5647                                   level_stats->total_compressed_size / 8.0;
5648
5649   // update max_col_tiles
5650   if (level_spec->max_col_tiles < (1 << cm->log2_tile_cols)) {
5651     level_spec->max_col_tiles = (1 << cm->log2_tile_cols);
5652   }
5653
5654   if (level_index >= 0 && level_constraint->fail_flag == 0) {
5655     if (level_spec->max_luma_picture_size >
5656         vp9_level_defs[level_index].max_luma_picture_size) {
5657       level_constraint->fail_flag |= (1 << LUMA_PIC_SIZE_TOO_LARGE);
5658       vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5659                          "Failed to encode to the target level %d. %s",
5660                          vp9_level_defs[level_index].level,
5661                          level_fail_messages[LUMA_PIC_SIZE_TOO_LARGE]);
5662     }
5663
5664     if (level_spec->max_luma_picture_breadth >
5665         vp9_level_defs[level_index].max_luma_picture_breadth) {
5666       level_constraint->fail_flag |= (1 << LUMA_PIC_BREADTH_TOO_LARGE);
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[LUMA_PIC_BREADTH_TOO_LARGE]);
5671     }
5672
5673     if ((double)level_spec->max_luma_sample_rate >
5674         (double)vp9_level_defs[level_index].max_luma_sample_rate *
5675             (1 + SAMPLE_RATE_GRACE_P)) {
5676       level_constraint->fail_flag |= (1 << LUMA_SAMPLE_RATE_TOO_LARGE);
5677       vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5678                          "Failed to encode to the target level %d. %s",
5679                          vp9_level_defs[level_index].level,
5680                          level_fail_messages[LUMA_SAMPLE_RATE_TOO_LARGE]);
5681     }
5682
5683     if (level_spec->max_col_tiles > vp9_level_defs[level_index].max_col_tiles) {
5684       level_constraint->fail_flag |= (1 << TOO_MANY_COLUMN_TILE);
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_COLUMN_TILE]);
5689     }
5690
5691     if (level_spec->min_altref_distance <
5692         vp9_level_defs[level_index].min_altref_distance) {
5693       level_constraint->fail_flag |= (1 << ALTREF_DIST_TOO_SMALL);
5694       vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5695                          "Failed to encode to the target level %d. %s",
5696                          vp9_level_defs[level_index].level,
5697                          level_fail_messages[ALTREF_DIST_TOO_SMALL]);
5698     }
5699
5700     if (level_spec->max_ref_frame_buffers >
5701         vp9_level_defs[level_index].max_ref_frame_buffers) {
5702       level_constraint->fail_flag |= (1 << TOO_MANY_REF_BUFFER);
5703       vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5704                          "Failed to encode to the target level %d. %s",
5705                          vp9_level_defs[level_index].level,
5706                          level_fail_messages[TOO_MANY_REF_BUFFER]);
5707     }
5708
5709     if (level_spec->max_cpb_size > vp9_level_defs[level_index].max_cpb_size) {
5710       level_constraint->fail_flag |= (1 << CPB_TOO_LARGE);
5711       vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5712                          "Failed to encode to the target level %d. %s",
5713                          vp9_level_defs[level_index].level,
5714                          level_fail_messages[CPB_TOO_LARGE]);
5715     }
5716
5717     // Set an upper bound for the next frame size. It will be used in
5718     // level_rc_framerate() before encoding the next frame.
5719     cpb_data_size = 0;
5720     for (i = 0; i < CPB_WINDOW_SIZE - 1; ++i) {
5721       if (i >= level_stats->frame_window_buffer.len) break;
5722       idx = (level_stats->frame_window_buffer.start +
5723              level_stats->frame_window_buffer.len - 1 - i) %
5724             FRAME_WINDOW_SIZE;
5725       cpb_data_size += level_stats->frame_window_buffer.buf[idx].size;
5726     }
5727     cpb_data_size = cpb_data_size / 125.0;
5728     level_constraint->max_frame_size =
5729         (int)((vp9_level_defs[level_index].max_cpb_size - cpb_data_size) *
5730               1000.0);
5731     if (level_stats->frame_window_buffer.len < CPB_WINDOW_SIZE - 1)
5732       level_constraint->max_frame_size >>= 1;
5733   }
5734 }
5735
5736 typedef struct GF_PICTURE {
5737   YV12_BUFFER_CONFIG *frame;
5738   int ref_frame[3];
5739   FRAME_UPDATE_TYPE update_type;
5740 } GF_PICTURE;
5741
5742 static void init_gop_frames(VP9_COMP *cpi, GF_PICTURE *gf_picture,
5743                             const GF_GROUP *gf_group, int *tpl_group_frames) {
5744   VP9_COMMON *cm = &cpi->common;
5745   int frame_idx = 0;
5746   int i;
5747   int gld_index = -1;
5748   int alt_index = -1;
5749   int lst_index = -1;
5750   int arf_index_stack[MAX_ARF_LAYERS];
5751   int arf_stack_size = 0;
5752   int extend_frame_count = 0;
5753   int pframe_qindex = cpi->tpl_stats[2].base_qindex;
5754   int frame_gop_offset = 0;
5755
5756   RefCntBuffer *frame_bufs = cm->buffer_pool->frame_bufs;
5757   int8_t recon_frame_index[REFS_PER_FRAME + MAX_ARF_LAYERS];
5758
5759   memset(recon_frame_index, -1, sizeof(recon_frame_index));
5760   stack_init(arf_index_stack, MAX_ARF_LAYERS);
5761
5762   // TODO(jingning): To be used later for gf frame type parsing.
5763   (void)gf_group;
5764
5765   for (i = 0; i < FRAME_BUFFERS; ++i) {
5766     if (frame_bufs[i].ref_count == 0) {
5767       alloc_frame_mvs(cm, i);
5768       if (vpx_realloc_frame_buffer(&frame_bufs[i].buf, cm->width, cm->height,
5769                                    cm->subsampling_x, cm->subsampling_y,
5770 #if CONFIG_VP9_HIGHBITDEPTH
5771                                    cm->use_highbitdepth,
5772 #endif
5773                                    VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
5774                                    NULL, NULL, NULL))
5775         vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
5776                            "Failed to allocate frame buffer");
5777
5778       recon_frame_index[frame_idx] = i;
5779       ++frame_idx;
5780
5781       if (frame_idx >= REFS_PER_FRAME + cpi->oxcf.enable_auto_arf) break;
5782     }
5783   }
5784
5785   for (i = 0; i < REFS_PER_FRAME + 1; ++i) {
5786     assert(recon_frame_index[i] >= 0);
5787     cpi->tpl_recon_frames[i] = &frame_bufs[recon_frame_index[i]].buf;
5788   }
5789
5790   *tpl_group_frames = 0;
5791
5792   // Initialize Golden reference frame.
5793   gf_picture[0].frame = get_ref_frame_buffer(cpi, GOLDEN_FRAME);
5794   for (i = 0; i < 3; ++i) gf_picture[0].ref_frame[i] = -1;
5795   gf_picture[0].update_type = gf_group->update_type[0];
5796   gld_index = 0;
5797   ++*tpl_group_frames;
5798
5799   // Initialize base layer ARF frame
5800   gf_picture[1].frame = cpi->Source;
5801   gf_picture[1].ref_frame[0] = gld_index;
5802   gf_picture[1].ref_frame[1] = lst_index;
5803   gf_picture[1].ref_frame[2] = alt_index;
5804   gf_picture[1].update_type = gf_group->update_type[1];
5805   alt_index = 1;
5806   ++*tpl_group_frames;
5807
5808   // Initialize P frames
5809   for (frame_idx = 2; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) {
5810     struct lookahead_entry *buf;
5811     frame_gop_offset = gf_group->frame_gop_index[frame_idx];
5812     buf = vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1);
5813
5814     if (buf == NULL) break;
5815
5816     gf_picture[frame_idx].frame = &buf->img;
5817     gf_picture[frame_idx].ref_frame[0] = gld_index;
5818     gf_picture[frame_idx].ref_frame[1] = lst_index;
5819     gf_picture[frame_idx].ref_frame[2] = alt_index;
5820     gf_picture[frame_idx].update_type = gf_group->update_type[frame_idx];
5821
5822     switch (gf_group->update_type[frame_idx]) {
5823       case ARF_UPDATE:
5824         stack_push(arf_index_stack, alt_index, arf_stack_size);
5825         ++arf_stack_size;
5826         alt_index = frame_idx;
5827         break;
5828       case LF_UPDATE: lst_index = frame_idx; break;
5829       case OVERLAY_UPDATE:
5830         gld_index = frame_idx;
5831         alt_index = stack_pop(arf_index_stack, arf_stack_size);
5832         --arf_stack_size;
5833         break;
5834       case USE_BUF_FRAME:
5835         lst_index = alt_index;
5836         alt_index = stack_pop(arf_index_stack, arf_stack_size);
5837         --arf_stack_size;
5838         break;
5839       default: break;
5840     }
5841
5842     ++*tpl_group_frames;
5843
5844     // The length of group of pictures is baseline_gf_interval, plus the
5845     // beginning golden frame from last GOP, plus the last overlay frame in
5846     // the same GOP.
5847     if (frame_idx == gf_group->gf_group_size) break;
5848   }
5849
5850   alt_index = -1;
5851   ++frame_idx;
5852   ++frame_gop_offset;
5853
5854   // Extend two frames outside the current gf group.
5855   for (; frame_idx < MAX_LAG_BUFFERS && extend_frame_count < 2; ++frame_idx) {
5856     struct lookahead_entry *buf =
5857         vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1);
5858
5859     if (buf == NULL) break;
5860
5861     cpi->tpl_stats[frame_idx].base_qindex = pframe_qindex;
5862
5863     gf_picture[frame_idx].frame = &buf->img;
5864     gf_picture[frame_idx].ref_frame[0] = gld_index;
5865     gf_picture[frame_idx].ref_frame[1] = lst_index;
5866     gf_picture[frame_idx].ref_frame[2] = alt_index;
5867     gf_picture[frame_idx].update_type = LF_UPDATE;
5868     lst_index = frame_idx;
5869     ++*tpl_group_frames;
5870     ++extend_frame_count;
5871     ++frame_gop_offset;
5872   }
5873 }
5874
5875 static void init_tpl_stats(VP9_COMP *cpi) {
5876   int frame_idx;
5877   for (frame_idx = 0; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) {
5878     TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
5879     memset(tpl_frame->tpl_stats_ptr, 0,
5880            tpl_frame->height * tpl_frame->width *
5881                sizeof(*tpl_frame->tpl_stats_ptr));
5882     tpl_frame->is_valid = 0;
5883   }
5884 }
5885
5886 #if CONFIG_NON_GREEDY_MV
5887 static uint32_t motion_compensated_prediction(
5888     VP9_COMP *cpi, ThreadData *td, int frame_idx, uint8_t *cur_frame_buf,
5889     uint8_t *ref_frame_buf, int stride, BLOCK_SIZE bsize, int mi_row,
5890     int mi_col, MV *mv, int rf_idx) {
5891 #else   // CONFIG_NON_GREEDY_MV
5892 static uint32_t motion_compensated_prediction(VP9_COMP *cpi, ThreadData *td,
5893                                               int frame_idx,
5894                                               uint8_t *cur_frame_buf,
5895                                               uint8_t *ref_frame_buf,
5896                                               int stride, BLOCK_SIZE bsize,
5897                                               int mi_row, int mi_col, MV *mv) {
5898 #endif  // CONFIG_NON_GREEDY_MV
5899   MACROBLOCK *const x = &td->mb;
5900   MACROBLOCKD *const xd = &x->e_mbd;
5901   MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5902   const SEARCH_METHODS search_method = NSTEP;
5903   int step_param;
5904   int sadpb = x->sadperbit16;
5905   uint32_t bestsme = UINT_MAX;
5906   uint32_t distortion;
5907   uint32_t sse;
5908   int cost_list[5];
5909   const MvLimits tmp_mv_limits = x->mv_limits;
5910 #if CONFIG_NON_GREEDY_MV
5911   // lambda is used to adjust the importance of motion vector consitency.
5912   // TODO(angiebird): Figure out lambda's proper value.
5913   const int lambda = cpi->tpl_stats[frame_idx].lambda;
5914   int_mv nb_full_mvs[NB_MVS_NUM];
5915   int nb_full_mv_num;
5916 #endif
5917
5918   MV best_ref_mv1 = { 0, 0 };
5919   MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
5920
5921   best_ref_mv1_full.col = best_ref_mv1.col >> 3;
5922   best_ref_mv1_full.row = best_ref_mv1.row >> 3;
5923
5924   // Setup frame pointers
5925   x->plane[0].src.buf = cur_frame_buf;
5926   x->plane[0].src.stride = stride;
5927   xd->plane[0].pre[0].buf = ref_frame_buf;
5928   xd->plane[0].pre[0].stride = stride;
5929
5930   step_param = mv_sf->reduce_first_step_size;
5931   step_param = VPXMIN(step_param, MAX_MVSEARCH_STEPS - 2);
5932
5933   vp9_set_mv_search_range(&x->mv_limits, &best_ref_mv1);
5934
5935 #if CONFIG_NON_GREEDY_MV
5936   (void)search_method;
5937   (void)sadpb;
5938   nb_full_mv_num = vp9_prepare_nb_full_mvs(&cpi->tpl_stats[frame_idx], mi_row,
5939                                            mi_col, rf_idx, bsize, nb_full_mvs);
5940   vp9_full_pixel_diamond_new(cpi, x, bsize, &best_ref_mv1_full, step_param,
5941                              lambda, 1, nb_full_mvs, nb_full_mv_num, mv);
5942 #else
5943   (void)frame_idx;
5944   (void)mi_row;
5945   (void)mi_col;
5946   vp9_full_pixel_search(cpi, x, bsize, &best_ref_mv1_full, step_param,
5947                         search_method, sadpb, cond_cost_list(cpi, cost_list),
5948                         &best_ref_mv1, mv, 0, 0);
5949 #endif
5950
5951   /* restore UMV window */
5952   x->mv_limits = tmp_mv_limits;
5953
5954   // TODO(yunqing): may use higher tap interp filter than 2 taps.
5955   // Ignore mv costing by sending NULL pointer instead of cost array
5956   bestsme = cpi->find_fractional_mv_step(
5957       x, mv, &best_ref_mv1, cpi->common.allow_high_precision_mv, x->errorperbit,
5958       &cpi->fn_ptr[bsize], 0, mv_sf->subpel_search_level,
5959       cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, 0, 0,
5960       USE_2_TAPS);
5961
5962   return bestsme;
5963 }
5964
5965 static int get_overlap_area(int grid_pos_row, int grid_pos_col, int ref_pos_row,
5966                             int ref_pos_col, int block, BLOCK_SIZE bsize) {
5967   int width = 0, height = 0;
5968   int bw = 4 << b_width_log2_lookup[bsize];
5969   int bh = 4 << b_height_log2_lookup[bsize];
5970
5971   switch (block) {
5972     case 0:
5973       width = grid_pos_col + bw - ref_pos_col;
5974       height = grid_pos_row + bh - ref_pos_row;
5975       break;
5976     case 1:
5977       width = ref_pos_col + bw - grid_pos_col;
5978       height = grid_pos_row + bh - ref_pos_row;
5979       break;
5980     case 2:
5981       width = grid_pos_col + bw - ref_pos_col;
5982       height = ref_pos_row + bh - grid_pos_row;
5983       break;
5984     case 3:
5985       width = ref_pos_col + bw - grid_pos_col;
5986       height = ref_pos_row + bh - grid_pos_row;
5987       break;
5988     default: assert(0);
5989   }
5990
5991   return width * height;
5992 }
5993
5994 static int round_floor(int ref_pos, int bsize_pix) {
5995   int round;
5996   if (ref_pos < 0)
5997     round = -(1 + (-ref_pos - 1) / bsize_pix);
5998   else
5999     round = ref_pos / bsize_pix;
6000
6001   return round;
6002 }
6003
6004 static void tpl_model_store(TplDepStats *tpl_stats, int mi_row, int mi_col,
6005                             BLOCK_SIZE bsize, int stride) {
6006   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6007   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6008   const TplDepStats *src_stats = &tpl_stats[mi_row * stride + mi_col];
6009   int idx, idy;
6010
6011   for (idy = 0; idy < mi_height; ++idy) {
6012     for (idx = 0; idx < mi_width; ++idx) {
6013       TplDepStats *tpl_ptr = &tpl_stats[(mi_row + idy) * stride + mi_col + idx];
6014       const int64_t mc_flow = tpl_ptr->mc_flow;
6015       const int64_t mc_ref_cost = tpl_ptr->mc_ref_cost;
6016       *tpl_ptr = *src_stats;
6017       tpl_ptr->mc_flow = mc_flow;
6018       tpl_ptr->mc_ref_cost = mc_ref_cost;
6019       tpl_ptr->mc_dep_cost = tpl_ptr->intra_cost + tpl_ptr->mc_flow;
6020     }
6021   }
6022 }
6023
6024 static void tpl_model_update_b(TplDepFrame *tpl_frame, TplDepStats *tpl_stats,
6025                                int mi_row, int mi_col, const BLOCK_SIZE bsize) {
6026   TplDepFrame *ref_tpl_frame = &tpl_frame[tpl_stats->ref_frame_index];
6027   TplDepStats *ref_stats = ref_tpl_frame->tpl_stats_ptr;
6028   MV mv = tpl_stats->mv.as_mv;
6029   int mv_row = mv.row >> 3;
6030   int mv_col = mv.col >> 3;
6031
6032   int ref_pos_row = mi_row * MI_SIZE + mv_row;
6033   int ref_pos_col = mi_col * MI_SIZE + mv_col;
6034
6035   const int bw = 4 << b_width_log2_lookup[bsize];
6036   const int bh = 4 << b_height_log2_lookup[bsize];
6037   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6038   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6039   const int pix_num = bw * bh;
6040
6041   // top-left on grid block location in pixel
6042   int grid_pos_row_base = round_floor(ref_pos_row, bh) * bh;
6043   int grid_pos_col_base = round_floor(ref_pos_col, bw) * bw;
6044   int block;
6045
6046   for (block = 0; block < 4; ++block) {
6047     int grid_pos_row = grid_pos_row_base + bh * (block >> 1);
6048     int grid_pos_col = grid_pos_col_base + bw * (block & 0x01);
6049
6050     if (grid_pos_row >= 0 && grid_pos_row < ref_tpl_frame->mi_rows * MI_SIZE &&
6051         grid_pos_col >= 0 && grid_pos_col < ref_tpl_frame->mi_cols * MI_SIZE) {
6052       int overlap_area = get_overlap_area(
6053           grid_pos_row, grid_pos_col, ref_pos_row, ref_pos_col, block, bsize);
6054       int ref_mi_row = round_floor(grid_pos_row, bh) * mi_height;
6055       int ref_mi_col = round_floor(grid_pos_col, bw) * mi_width;
6056
6057       int64_t mc_flow = tpl_stats->mc_dep_cost -
6058                         (tpl_stats->mc_dep_cost * tpl_stats->inter_cost) /
6059                             tpl_stats->intra_cost;
6060
6061       int idx, idy;
6062
6063       for (idy = 0; idy < mi_height; ++idy) {
6064         for (idx = 0; idx < mi_width; ++idx) {
6065           TplDepStats *des_stats =
6066               &ref_stats[(ref_mi_row + idy) * ref_tpl_frame->stride +
6067                          (ref_mi_col + idx)];
6068
6069           des_stats->mc_flow += (mc_flow * overlap_area) / pix_num;
6070           des_stats->mc_ref_cost +=
6071               ((tpl_stats->intra_cost - tpl_stats->inter_cost) * overlap_area) /
6072               pix_num;
6073           assert(overlap_area >= 0);
6074         }
6075       }
6076     }
6077   }
6078 }
6079
6080 static void tpl_model_update(TplDepFrame *tpl_frame, TplDepStats *tpl_stats,
6081                              int mi_row, int mi_col, const BLOCK_SIZE bsize) {
6082   int idx, idy;
6083   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6084   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6085
6086   for (idy = 0; idy < mi_height; ++idy) {
6087     for (idx = 0; idx < mi_width; ++idx) {
6088       TplDepStats *tpl_ptr =
6089           &tpl_stats[(mi_row + idy) * tpl_frame->stride + (mi_col + idx)];
6090       tpl_model_update_b(tpl_frame, tpl_ptr, mi_row + idy, mi_col + idx,
6091                          BLOCK_8X8);
6092     }
6093   }
6094 }
6095
6096 static void get_quantize_error(MACROBLOCK *x, int plane, tran_low_t *coeff,
6097                                tran_low_t *qcoeff, tran_low_t *dqcoeff,
6098                                TX_SIZE tx_size, int64_t *recon_error,
6099                                int64_t *sse) {
6100   MACROBLOCKD *const xd = &x->e_mbd;
6101   const struct macroblock_plane *const p = &x->plane[plane];
6102   const struct macroblockd_plane *const pd = &xd->plane[plane];
6103   const scan_order *const scan_order = &vp9_default_scan_orders[tx_size];
6104   uint16_t eob;
6105   int pix_num = 1 << num_pels_log2_lookup[txsize_to_bsize[tx_size]];
6106   const int shift = tx_size == TX_32X32 ? 0 : 2;
6107
6108 #if CONFIG_VP9_HIGHBITDEPTH
6109   if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6110     vp9_highbd_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp,
6111                                  p->quant_fp, qcoeff, dqcoeff, pd->dequant,
6112                                  &eob, scan_order->scan, scan_order->iscan);
6113   } else {
6114     vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp,
6115                           p->quant_fp, qcoeff, dqcoeff, pd->dequant, &eob,
6116                           scan_order->scan, scan_order->iscan);
6117   }
6118 #else
6119   vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp, p->quant_fp,
6120                         qcoeff, dqcoeff, pd->dequant, &eob, scan_order->scan,
6121                         scan_order->iscan);
6122 #endif  // CONFIG_VP9_HIGHBITDEPTH
6123
6124   *recon_error = vp9_block_error(coeff, dqcoeff, pix_num, sse) >> shift;
6125   *recon_error = VPXMAX(*recon_error, 1);
6126
6127   *sse = (*sse) >> shift;
6128   *sse = VPXMAX(*sse, 1);
6129 }
6130
6131 #if CONFIG_VP9_HIGHBITDEPTH
6132 void highbd_wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
6133                          TX_SIZE tx_size) {
6134   // TODO(sdeng): Implement SIMD based high bit-depth Hadamard transforms.
6135   switch (tx_size) {
6136     case TX_8X8: vpx_highbd_hadamard_8x8(src_diff, bw, coeff); break;
6137     case TX_16X16: vpx_highbd_hadamard_16x16(src_diff, bw, coeff); break;
6138     case TX_32X32: vpx_highbd_hadamard_32x32(src_diff, bw, coeff); break;
6139     default: assert(0);
6140   }
6141 }
6142 #endif  // CONFIG_VP9_HIGHBITDEPTH
6143
6144 void wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
6145                   TX_SIZE tx_size) {
6146   switch (tx_size) {
6147     case TX_8X8: vpx_hadamard_8x8(src_diff, bw, coeff); break;
6148     case TX_16X16: vpx_hadamard_16x16(src_diff, bw, coeff); break;
6149     case TX_32X32: vpx_hadamard_32x32(src_diff, bw, coeff); break;
6150     default: assert(0);
6151   }
6152 }
6153
6154 static void set_mv_limits(const VP9_COMMON *cm, MACROBLOCK *x, int mi_row,
6155                           int mi_col) {
6156   x->mv_limits.row_min = -((mi_row * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND));
6157   x->mv_limits.row_max =
6158       (cm->mi_rows - 1 - mi_row) * MI_SIZE + (17 - 2 * VP9_INTERP_EXTEND);
6159   x->mv_limits.col_min = -((mi_col * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND));
6160   x->mv_limits.col_max =
6161       ((cm->mi_cols - 1 - mi_col) * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND);
6162 }
6163
6164 static void mode_estimation(VP9_COMP *cpi, MACROBLOCK *x, MACROBLOCKD *xd,
6165                             struct scale_factors *sf, GF_PICTURE *gf_picture,
6166                             int frame_idx, TplDepFrame *tpl_frame,
6167                             int16_t *src_diff, tran_low_t *coeff,
6168                             tran_low_t *qcoeff, tran_low_t *dqcoeff, int mi_row,
6169                             int mi_col, BLOCK_SIZE bsize, TX_SIZE tx_size,
6170                             YV12_BUFFER_CONFIG *ref_frame[], uint8_t *predictor,
6171                             int64_t *recon_error, int64_t *sse) {
6172   VP9_COMMON *cm = &cpi->common;
6173   ThreadData *td = &cpi->td;
6174
6175   const int bw = 4 << b_width_log2_lookup[bsize];
6176   const int bh = 4 << b_height_log2_lookup[bsize];
6177   const int pix_num = bw * bh;
6178   int best_rf_idx = -1;
6179   int_mv best_mv;
6180   int64_t best_inter_cost = INT64_MAX;
6181   int64_t inter_cost;
6182   int rf_idx;
6183   const InterpKernel *const kernel = vp9_filter_kernels[EIGHTTAP];
6184
6185   int64_t best_intra_cost = INT64_MAX;
6186   int64_t intra_cost;
6187   PREDICTION_MODE mode;
6188   int mb_y_offset = mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6189   MODE_INFO mi_above, mi_left;
6190   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6191   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6192   TplDepStats *tpl_stats =
6193       &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6194
6195   xd->mb_to_top_edge = -((mi_row * MI_SIZE) * 8);
6196   xd->mb_to_bottom_edge = ((cm->mi_rows - 1 - mi_row) * MI_SIZE) * 8;
6197   xd->mb_to_left_edge = -((mi_col * MI_SIZE) * 8);
6198   xd->mb_to_right_edge = ((cm->mi_cols - 1 - mi_col) * MI_SIZE) * 8;
6199   xd->above_mi = (mi_row > 0) ? &mi_above : NULL;
6200   xd->left_mi = (mi_col > 0) ? &mi_left : NULL;
6201
6202   // Intra prediction search
6203   for (mode = DC_PRED; mode <= TM_PRED; ++mode) {
6204     uint8_t *src, *dst;
6205     int src_stride, dst_stride;
6206
6207     src = xd->cur_buf->y_buffer + mb_y_offset;
6208     src_stride = xd->cur_buf->y_stride;
6209
6210     dst = &predictor[0];
6211     dst_stride = bw;
6212
6213     xd->mi[0]->sb_type = bsize;
6214     xd->mi[0]->ref_frame[0] = INTRA_FRAME;
6215
6216     vp9_predict_intra_block(xd, b_width_log2_lookup[bsize], tx_size, mode, src,
6217                             src_stride, dst, dst_stride, 0, 0, 0);
6218
6219 #if CONFIG_VP9_HIGHBITDEPTH
6220     if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6221       vpx_highbd_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst,
6222                                 dst_stride, xd->bd);
6223       highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6224       intra_cost = vpx_highbd_satd(coeff, pix_num);
6225     } else {
6226       vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst,
6227                          dst_stride);
6228       wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6229       intra_cost = vpx_satd(coeff, pix_num);
6230     }
6231 #else
6232     vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst, dst_stride);
6233     wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6234     intra_cost = vpx_satd(coeff, pix_num);
6235 #endif  // CONFIG_VP9_HIGHBITDEPTH
6236
6237     if (intra_cost < best_intra_cost) best_intra_cost = intra_cost;
6238   }
6239
6240   // Motion compensated prediction
6241   best_mv.as_int = 0;
6242
6243   set_mv_limits(cm, x, mi_row, mi_col);
6244
6245   for (rf_idx = 0; rf_idx < 3; ++rf_idx) {
6246     int_mv mv;
6247     if (ref_frame[rf_idx] == NULL) continue;
6248
6249 #if CONFIG_NON_GREEDY_MV
6250     (void)td;
6251     mv.as_int =
6252         get_pyramid_mv(tpl_frame, rf_idx, bsize, mi_row, mi_col)->as_int;
6253 #else
6254     motion_compensated_prediction(
6255         cpi, td, frame_idx, xd->cur_buf->y_buffer + mb_y_offset,
6256         ref_frame[rf_idx]->y_buffer + mb_y_offset, xd->cur_buf->y_stride, bsize,
6257         mi_row, mi_col, &mv.as_mv);
6258 #endif
6259
6260 #if CONFIG_VP9_HIGHBITDEPTH
6261     if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6262       vp9_highbd_build_inter_predictor(
6263           CONVERT_TO_SHORTPTR(ref_frame[rf_idx]->y_buffer + mb_y_offset),
6264           ref_frame[rf_idx]->y_stride, CONVERT_TO_SHORTPTR(&predictor[0]), bw,
6265           &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE,
6266           mi_row * MI_SIZE, xd->bd);
6267       vpx_highbd_subtract_block(
6268           bh, bw, src_diff, bw, xd->cur_buf->y_buffer + mb_y_offset,
6269           xd->cur_buf->y_stride, &predictor[0], bw, xd->bd);
6270       highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6271       inter_cost = vpx_highbd_satd(coeff, pix_num);
6272     } else {
6273       vp9_build_inter_predictor(
6274           ref_frame[rf_idx]->y_buffer + mb_y_offset,
6275           ref_frame[rf_idx]->y_stride, &predictor[0], bw, &mv.as_mv, sf, bw, bh,
6276           0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE, mi_row * MI_SIZE);
6277       vpx_subtract_block(bh, bw, src_diff, bw,
6278                          xd->cur_buf->y_buffer + mb_y_offset,
6279                          xd->cur_buf->y_stride, &predictor[0], bw);
6280       wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6281       inter_cost = vpx_satd(coeff, pix_num);
6282     }
6283 #else
6284     vp9_build_inter_predictor(ref_frame[rf_idx]->y_buffer + mb_y_offset,
6285                               ref_frame[rf_idx]->y_stride, &predictor[0], bw,
6286                               &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3,
6287                               mi_col * MI_SIZE, mi_row * MI_SIZE);
6288     vpx_subtract_block(bh, bw, src_diff, bw,
6289                        xd->cur_buf->y_buffer + mb_y_offset,
6290                        xd->cur_buf->y_stride, &predictor[0], bw);
6291     wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6292     inter_cost = vpx_satd(coeff, pix_num);
6293 #endif
6294
6295     if (inter_cost < best_inter_cost) {
6296       best_rf_idx = rf_idx;
6297       best_inter_cost = inter_cost;
6298       best_mv.as_int = mv.as_int;
6299       get_quantize_error(x, 0, coeff, qcoeff, dqcoeff, tx_size, recon_error,
6300                          sse);
6301     }
6302   }
6303   best_intra_cost = VPXMAX(best_intra_cost, 1);
6304   best_inter_cost = VPXMIN(best_intra_cost, best_inter_cost);
6305   tpl_stats->inter_cost = VPXMAX(
6306       1, (best_inter_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width));
6307   tpl_stats->intra_cost = VPXMAX(
6308       1, (best_intra_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width));
6309   tpl_stats->ref_frame_index = gf_picture[frame_idx].ref_frame[best_rf_idx];
6310   tpl_stats->mv.as_int = best_mv.as_int;
6311 }
6312
6313 #if CONFIG_NON_GREEDY_MV
6314 static int get_block_src_pred_buf(MACROBLOCKD *xd, GF_PICTURE *gf_picture,
6315                                   int frame_idx, int rf_idx, int mi_row,
6316                                   int mi_col, struct buf_2d *src,
6317                                   struct buf_2d *pre) {
6318   const int mb_y_offset =
6319       mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6320   YV12_BUFFER_CONFIG *ref_frame = NULL;
6321   int ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6322   if (ref_frame_idx != -1) {
6323     ref_frame = gf_picture[ref_frame_idx].frame;
6324     src->buf = xd->cur_buf->y_buffer + mb_y_offset;
6325     src->stride = xd->cur_buf->y_stride;
6326     pre->buf = ref_frame->y_buffer + mb_y_offset;
6327     pre->stride = ref_frame->y_stride;
6328     assert(src->stride == pre->stride);
6329     return 1;
6330   } else {
6331     printf("invalid ref_frame_idx");
6332     assert(ref_frame_idx != -1);
6333     return 0;
6334   }
6335 }
6336
6337 #define kMvPreCheckLines 5
6338 #define kMvPreCheckSize 15
6339
6340 #define MV_REF_POS_NUM 3
6341 POSITION mv_ref_pos[MV_REF_POS_NUM] = {
6342   { -1, 0 },
6343   { 0, -1 },
6344   { -1, -1 },
6345 };
6346
6347 static int_mv *get_select_mv(VP9_COMP *cpi, TplDepFrame *tpl_frame, int mi_row,
6348                              int mi_col) {
6349   return &cpi->select_mv_arr[mi_row * tpl_frame->stride + mi_col];
6350 }
6351
6352 static int_mv find_ref_mv(int mv_mode, VP9_COMP *cpi, TplDepFrame *tpl_frame,
6353                           BLOCK_SIZE bsize, int mi_row, int mi_col) {
6354   int i;
6355   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6356   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6357   int_mv nearest_mv, near_mv, invalid_mv;
6358   nearest_mv.as_int = INVALID_MV;
6359   near_mv.as_int = INVALID_MV;
6360   invalid_mv.as_int = INVALID_MV;
6361   for (i = 0; i < MV_REF_POS_NUM; ++i) {
6362     int nb_row = mi_row + mv_ref_pos[i].row * mi_height;
6363     int nb_col = mi_col + mv_ref_pos[i].col * mi_width;
6364     assert(mv_ref_pos[i].row <= 0);
6365     assert(mv_ref_pos[i].col <= 0);
6366     if (nb_row >= 0 && nb_col >= 0) {
6367       if (nearest_mv.as_int == INVALID_MV) {
6368         nearest_mv = *get_select_mv(cpi, tpl_frame, nb_row, nb_col);
6369       } else {
6370         int_mv mv = *get_select_mv(cpi, tpl_frame, nb_row, nb_col);
6371         if (mv.as_int == nearest_mv.as_int) {
6372           continue;
6373         } else {
6374           near_mv = mv;
6375           break;
6376         }
6377       }
6378     }
6379   }
6380   if (nearest_mv.as_int == INVALID_MV) {
6381     nearest_mv.as_mv.row = 0;
6382     nearest_mv.as_mv.col = 0;
6383   }
6384   if (near_mv.as_int == INVALID_MV) {
6385     near_mv.as_mv.row = 0;
6386     near_mv.as_mv.col = 0;
6387   }
6388   if (mv_mode == NEAREST_MV_MODE) {
6389     return nearest_mv;
6390   }
6391   if (mv_mode == NEAR_MV_MODE) {
6392     return near_mv;
6393   }
6394   assert(0);
6395   return invalid_mv;
6396 }
6397
6398 static int_mv get_mv_from_mv_mode(int mv_mode, VP9_COMP *cpi,
6399                                   TplDepFrame *tpl_frame, int rf_idx,
6400                                   BLOCK_SIZE bsize, int mi_row, int mi_col) {
6401   int_mv mv;
6402   switch (mv_mode) {
6403     case ZERO_MV_MODE:
6404       mv.as_mv.row = 0;
6405       mv.as_mv.col = 0;
6406       break;
6407     case NEW_MV_MODE:
6408       mv = *get_pyramid_mv(tpl_frame, rf_idx, bsize, mi_row, mi_col);
6409       break;
6410     case NEAREST_MV_MODE:
6411       mv = find_ref_mv(mv_mode, cpi, tpl_frame, bsize, mi_row, mi_col);
6412       break;
6413     case NEAR_MV_MODE:
6414       mv = find_ref_mv(mv_mode, cpi, tpl_frame, bsize, mi_row, mi_col);
6415       break;
6416     default:
6417       mv.as_int = INVALID_MV;
6418       assert(0);
6419       break;
6420   }
6421   return mv;
6422 }
6423
6424 static double get_mv_dist(int mv_mode, VP9_COMP *cpi, MACROBLOCKD *xd,
6425                           GF_PICTURE *gf_picture, int frame_idx,
6426                           TplDepFrame *tpl_frame, int rf_idx, BLOCK_SIZE bsize,
6427                           int mi_row, int mi_col, int_mv *mv) {
6428   uint32_t sse;
6429   struct buf_2d src;
6430   struct buf_2d pre;
6431   MV full_mv;
6432   *mv = get_mv_from_mv_mode(mv_mode, cpi, tpl_frame, rf_idx, bsize, mi_row,
6433                             mi_col);
6434   full_mv = get_full_mv(&mv->as_mv);
6435   if (get_block_src_pred_buf(xd, gf_picture, frame_idx, rf_idx, mi_row, mi_col,
6436                              &src, &pre)) {
6437     // TODO(angiebird): Consider subpixel when computing the sse.
6438     cpi->fn_ptr[bsize].vf(src.buf, src.stride, get_buf_from_mv(&pre, &full_mv),
6439                           pre.stride, &sse);
6440     return (double)(sse << VP9_DIST_SCALE_LOG2);
6441   } else {
6442     assert(0);
6443     return 0;
6444   }
6445 }
6446
6447 static int get_mv_mode_cost(int mv_mode) {
6448   // TODO(angiebird): The probabilities are roughly inferred from
6449   // default_inter_mode_probs. Check if there is a better way to set the
6450   // probabilities.
6451   const int zero_mv_prob = 16;
6452   const int new_mv_prob = 24 * 1;
6453   const int ref_mv_prob = 256 - zero_mv_prob - new_mv_prob;
6454   assert(zero_mv_prob + new_mv_prob + ref_mv_prob == 256);
6455   switch (mv_mode) {
6456     case ZERO_MV_MODE: return vp9_prob_cost[zero_mv_prob]; break;
6457     case NEW_MV_MODE: return vp9_prob_cost[new_mv_prob]; break;
6458     case NEAREST_MV_MODE: return vp9_prob_cost[ref_mv_prob]; break;
6459     case NEAR_MV_MODE: return vp9_prob_cost[ref_mv_prob]; break;
6460     default: assert(0); return -1;
6461   }
6462 }
6463
6464 static INLINE double get_mv_diff_cost(MV *new_mv, MV *ref_mv) {
6465   double mv_diff_cost = log2(1 + abs(new_mv->row - ref_mv->row)) +
6466                         log2(1 + abs(new_mv->col - ref_mv->col));
6467   mv_diff_cost *= (1 << VP9_PROB_COST_SHIFT);
6468   return mv_diff_cost;
6469 }
6470 static double get_mv_cost(int mv_mode, VP9_COMP *cpi, TplDepFrame *tpl_frame,
6471                           int rf_idx, BLOCK_SIZE bsize, int mi_row,
6472                           int mi_col) {
6473   double mv_cost = get_mv_mode_cost(mv_mode);
6474   if (mv_mode == NEW_MV_MODE) {
6475     MV new_mv = get_mv_from_mv_mode(mv_mode, cpi, tpl_frame, rf_idx, bsize,
6476                                     mi_row, mi_col)
6477                     .as_mv;
6478     MV nearest_mv = get_mv_from_mv_mode(NEAREST_MV_MODE, cpi, tpl_frame, rf_idx,
6479                                         bsize, mi_row, mi_col)
6480                         .as_mv;
6481     MV near_mv = get_mv_from_mv_mode(NEAR_MV_MODE, cpi, tpl_frame, rf_idx,
6482                                      bsize, mi_row, mi_col)
6483                      .as_mv;
6484     double nearest_cost = get_mv_diff_cost(&new_mv, &nearest_mv);
6485     double near_cost = get_mv_diff_cost(&new_mv, &near_mv);
6486     mv_cost += nearest_cost < near_cost ? nearest_cost : near_cost;
6487   }
6488   return mv_cost;
6489 }
6490
6491 static double eval_mv_mode(int mv_mode, VP9_COMP *cpi, MACROBLOCK *x,
6492                            GF_PICTURE *gf_picture, int frame_idx,
6493                            TplDepFrame *tpl_frame, int rf_idx, BLOCK_SIZE bsize,
6494                            int mi_row, int mi_col, int_mv *mv) {
6495   MACROBLOCKD *xd = &x->e_mbd;
6496   double mv_dist = get_mv_dist(mv_mode, cpi, xd, gf_picture, frame_idx,
6497                                tpl_frame, rf_idx, bsize, mi_row, mi_col, mv);
6498   double mv_cost =
6499       get_mv_cost(mv_mode, cpi, tpl_frame, rf_idx, bsize, mi_row, mi_col);
6500   double mult = 180;
6501
6502   return mv_cost + mult * log2f(1 + mv_dist);
6503 }
6504
6505 static int find_best_ref_mv_mode(VP9_COMP *cpi, MACROBLOCK *x,
6506                                  GF_PICTURE *gf_picture, int frame_idx,
6507                                  TplDepFrame *tpl_frame, int rf_idx,
6508                                  BLOCK_SIZE bsize, int mi_row, int mi_col,
6509                                  double *rd, int_mv *mv) {
6510   int best_mv_mode = ZERO_MV_MODE;
6511   int update = 0;
6512   int mv_mode;
6513   *rd = 0;
6514   for (mv_mode = 0; mv_mode < MAX_MV_MODE; ++mv_mode) {
6515     double this_rd;
6516     int_mv this_mv;
6517     if (mv_mode == NEW_MV_MODE) {
6518       continue;
6519     }
6520     this_rd = eval_mv_mode(mv_mode, cpi, x, gf_picture, frame_idx, tpl_frame,
6521                            rf_idx, bsize, mi_row, mi_col, &this_mv);
6522     if (update == 0) {
6523       *rd = this_rd;
6524       *mv = this_mv;
6525       best_mv_mode = mv_mode;
6526       update = 1;
6527     } else {
6528       if (this_rd < *rd) {
6529         *rd = this_rd;
6530         *mv = this_mv;
6531         best_mv_mode = mv_mode;
6532       }
6533     }
6534   }
6535   return best_mv_mode;
6536 }
6537
6538 static void predict_mv_mode(VP9_COMP *cpi, MACROBLOCK *x,
6539                             GF_PICTURE *gf_picture, int frame_idx,
6540                             TplDepFrame *tpl_frame, int rf_idx,
6541                             BLOCK_SIZE bsize, int mi_row, int mi_col) {
6542   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6543   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6544   int tmp_mv_mode_arr[kMvPreCheckSize];
6545   int *mv_mode_arr = tpl_frame->mv_mode_arr[rf_idx];
6546   double *rd_diff_arr = tpl_frame->rd_diff_arr[rf_idx];
6547   int_mv *select_mv_arr = cpi->select_mv_arr;
6548   int_mv tmp_select_mv_arr[kMvPreCheckSize];
6549   int stride = tpl_frame->stride;
6550   double new_mv_rd = 0;
6551   double no_new_mv_rd = 0;
6552   double this_new_mv_rd = 0;
6553   double this_no_new_mv_rd = 0;
6554   int idx;
6555   int tmp_idx;
6556   assert(kMvPreCheckSize == (kMvPreCheckLines * (kMvPreCheckLines + 1)) >> 1);
6557
6558   // no new mv
6559   // diagnal scan order
6560   tmp_idx = 0;
6561   for (idx = 0; idx < kMvPreCheckLines; ++idx) {
6562     int r;
6563     for (r = 0; r <= idx; ++r) {
6564       int c = idx - r;
6565       int nb_row = mi_row + r * mi_height;
6566       int nb_col = mi_col + c * mi_width;
6567       if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6568         double this_rd;
6569         int_mv *mv = &select_mv_arr[nb_row * stride + nb_col];
6570         mv_mode_arr[nb_row * stride + nb_col] =
6571             find_best_ref_mv_mode(cpi, x, gf_picture, frame_idx, tpl_frame,
6572                                   rf_idx, bsize, nb_row, nb_col, &this_rd, mv);
6573         if (r == 0 && c == 0) {
6574           this_no_new_mv_rd = this_rd;
6575         }
6576         no_new_mv_rd += this_rd;
6577         tmp_mv_mode_arr[tmp_idx] = mv_mode_arr[nb_row * stride + nb_col];
6578         tmp_select_mv_arr[tmp_idx] = select_mv_arr[nb_row * stride + nb_col];
6579         ++tmp_idx;
6580       }
6581     }
6582   }
6583
6584   // new mv
6585   mv_mode_arr[mi_row * stride + mi_col] = NEW_MV_MODE;
6586   this_new_mv_rd = eval_mv_mode(NEW_MV_MODE, cpi, x, gf_picture, frame_idx,
6587                                 tpl_frame, rf_idx, bsize, mi_row, mi_col,
6588                                 &select_mv_arr[mi_row * stride + mi_col]);
6589   new_mv_rd = this_new_mv_rd;
6590   // We start from idx = 1 because idx = 0 is evaluated as NEW_MV_MODE
6591   // beforehand.
6592   for (idx = 1; idx < kMvPreCheckLines; ++idx) {
6593     int r;
6594     for (r = 0; r <= idx; ++r) {
6595       int c = idx - r;
6596       int nb_row = mi_row + r * mi_height;
6597       int nb_col = mi_col + c * mi_width;
6598       if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6599         double this_rd;
6600         int_mv *mv = &select_mv_arr[nb_row * stride + nb_col];
6601         mv_mode_arr[nb_row * stride + nb_col] =
6602             find_best_ref_mv_mode(cpi, x, gf_picture, frame_idx, tpl_frame,
6603                                   rf_idx, bsize, nb_row, nb_col, &this_rd, mv);
6604         new_mv_rd += this_rd;
6605       }
6606     }
6607   }
6608
6609   // update best_mv_mode
6610   tmp_idx = 0;
6611   if (no_new_mv_rd < new_mv_rd) {
6612     for (idx = 0; idx < kMvPreCheckLines; ++idx) {
6613       int r;
6614       for (r = 0; r <= idx; ++r) {
6615         int c = idx - r;
6616         int nb_row = mi_row + r * mi_height;
6617         int nb_col = mi_col + c * mi_width;
6618         if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6619           mv_mode_arr[nb_row * stride + nb_col] = tmp_mv_mode_arr[tmp_idx];
6620           select_mv_arr[nb_row * stride + nb_col] = tmp_select_mv_arr[tmp_idx];
6621           ++tmp_idx;
6622         }
6623       }
6624     }
6625     rd_diff_arr[mi_row * stride + mi_col] = 0;
6626   } else {
6627     rd_diff_arr[mi_row * stride + mi_col] =
6628         (no_new_mv_rd - this_no_new_mv_rd) - (new_mv_rd - this_new_mv_rd);
6629   }
6630 }
6631
6632 static void predict_mv_mode_arr(VP9_COMP *cpi, MACROBLOCK *x,
6633                                 GF_PICTURE *gf_picture, int frame_idx,
6634                                 TplDepFrame *tpl_frame, int rf_idx,
6635                                 BLOCK_SIZE bsize) {
6636   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6637   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6638   const int unit_rows = tpl_frame->mi_rows / mi_height;
6639   const int unit_cols = tpl_frame->mi_cols / mi_width;
6640   const int max_diagonal_lines = unit_rows + unit_cols - 1;
6641   int idx;
6642   for (idx = 0; idx < max_diagonal_lines; ++idx) {
6643     int r;
6644     for (r = VPXMAX(idx - unit_cols + 1, 0); r <= VPXMIN(idx, unit_rows - 1);
6645          ++r) {
6646       int c = idx - r;
6647       int mi_row = r * mi_height;
6648       int mi_col = c * mi_width;
6649       assert(c >= 0 && c < unit_cols);
6650       assert(mi_row >= 0 && mi_row < tpl_frame->mi_rows);
6651       assert(mi_col >= 0 && mi_col < tpl_frame->mi_cols);
6652       predict_mv_mode(cpi, x, gf_picture, frame_idx, tpl_frame, rf_idx, bsize,
6653                       mi_row, mi_col);
6654     }
6655   }
6656 }
6657
6658 static double get_feature_score(uint8_t *buf, ptrdiff_t stride, int rows,
6659                                 int cols) {
6660   double IxIx = 0;
6661   double IxIy = 0;
6662   double IyIy = 0;
6663   double score;
6664   int r, c;
6665   vpx_clear_system_state();
6666   for (r = 0; r + 1 < rows; ++r) {
6667     for (c = 0; c + 1 < cols; ++c) {
6668       int diff_x = buf[r * stride + c] - buf[r * stride + c + 1];
6669       int diff_y = buf[r * stride + c] - buf[(r + 1) * stride + c];
6670       IxIx += diff_x * diff_x;
6671       IxIy += diff_x * diff_y;
6672       IyIy += diff_y * diff_y;
6673     }
6674   }
6675   IxIx /= (rows - 1) * (cols - 1);
6676   IxIy /= (rows - 1) * (cols - 1);
6677   IyIy /= (rows - 1) * (cols - 1);
6678   score = (IxIx * IyIy - IxIy * IxIy + 0.0001) / (IxIx + IyIy + 0.0001);
6679   return score;
6680 }
6681
6682 static int compare_feature_score(const void *a, const void *b) {
6683   const FEATURE_SCORE_LOC *aa = *(FEATURE_SCORE_LOC *const *)a;
6684   const FEATURE_SCORE_LOC *bb = *(FEATURE_SCORE_LOC *const *)b;
6685   if (aa->feature_score < bb->feature_score) {
6686     return 1;
6687   } else if (aa->feature_score > bb->feature_score) {
6688     return -1;
6689   } else {
6690     return 0;
6691   }
6692 }
6693
6694 static void do_motion_search(VP9_COMP *cpi, ThreadData *td, int frame_idx,
6695                              YV12_BUFFER_CONFIG **ref_frame, BLOCK_SIZE bsize,
6696                              int mi_row, int mi_col) {
6697   VP9_COMMON *cm = &cpi->common;
6698   MACROBLOCK *x = &td->mb;
6699   MACROBLOCKD *xd = &x->e_mbd;
6700   TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6701   TplDepStats *tpl_stats =
6702       &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6703   const int mb_y_offset =
6704       mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6705   int rf_idx;
6706
6707   set_mv_limits(cm, x, mi_row, mi_col);
6708
6709   for (rf_idx = 0; rf_idx < 3; ++rf_idx) {
6710     int_mv *mv = get_pyramid_mv(tpl_frame, rf_idx, bsize, mi_row, mi_col);
6711     if (ref_frame[rf_idx] == NULL) {
6712       tpl_stats->ready[rf_idx] = 0;
6713       continue;
6714     } else {
6715       tpl_stats->ready[rf_idx] = 1;
6716     }
6717     motion_compensated_prediction(
6718         cpi, td, frame_idx, xd->cur_buf->y_buffer + mb_y_offset,
6719         ref_frame[rf_idx]->y_buffer + mb_y_offset, xd->cur_buf->y_stride, bsize,
6720         mi_row, mi_col, &mv->as_mv, rf_idx);
6721   }
6722 }
6723
6724 #define CHANGE_MV_SEARCH_ORDER 1
6725 #define USE_PQSORT 1
6726
6727 #if CHANGE_MV_SEARCH_ORDER
6728 #if USE_PQSORT
6729 static void max_heap_pop(FEATURE_SCORE_LOC **heap, int *size,
6730                          FEATURE_SCORE_LOC **output) {
6731   if (*size > 0) {
6732     *output = heap[0];
6733     --*size;
6734     if (*size > 0) {
6735       int p, l, r;
6736       heap[0] = heap[*size];
6737       p = 0;
6738       l = 2 * p + 1;
6739       r = 2 * p + 2;
6740       while (l < *size) {
6741         FEATURE_SCORE_LOC *tmp;
6742         int c = l;
6743         if (r < *size && heap[r]->feature_score > heap[l]->feature_score) {
6744           c = r;
6745         }
6746         if (heap[p]->feature_score >= heap[c]->feature_score) {
6747           break;
6748         }
6749         tmp = heap[p];
6750         heap[p] = heap[c];
6751         heap[c] = tmp;
6752         p = c;
6753         l = 2 * p + 1;
6754         r = 2 * p + 2;
6755       }
6756     }
6757   } else {
6758     assert(0);
6759   }
6760 }
6761
6762 static void max_heap_push(FEATURE_SCORE_LOC **heap, int *size,
6763                           FEATURE_SCORE_LOC *input) {
6764   int c, p;
6765   FEATURE_SCORE_LOC *tmp;
6766   input->visited = 1;
6767   heap[*size] = input;
6768   ++*size;
6769   c = *size - 1;
6770   p = c >> 1;
6771   while (c > 0 && heap[c]->feature_score > heap[p]->feature_score) {
6772     tmp = heap[p];
6773     heap[p] = heap[c];
6774     heap[c] = tmp;
6775     c = p;
6776     p >>= 1;
6777   }
6778 }
6779
6780 static void add_nb_blocks_to_heap(VP9_COMP *cpi, const TplDepFrame *tpl_frame,
6781                                   BLOCK_SIZE bsize, int mi_row, int mi_col,
6782                                   int *heap_size) {
6783   const int mi_unit = num_8x8_blocks_wide_lookup[bsize];
6784   const int dirs[NB_MVS_NUM][2] = { { -1, 0 }, { 0, -1 }, { 1, 0 }, { 0, 1 } };
6785   int i;
6786   for (i = 0; i < NB_MVS_NUM; ++i) {
6787     int r = dirs[i][0] * mi_unit;
6788     int c = dirs[i][1] * mi_unit;
6789     if (mi_row + r >= 0 && mi_row + r < tpl_frame->mi_rows && mi_col + c >= 0 &&
6790         mi_col + c < tpl_frame->mi_cols) {
6791       FEATURE_SCORE_LOC *fs_loc =
6792           &cpi->feature_score_loc_arr[(mi_row + r) * tpl_frame->stride +
6793                                       (mi_col + c)];
6794       if (fs_loc->visited == 0) {
6795         max_heap_push(cpi->feature_score_loc_heap, heap_size, fs_loc);
6796       }
6797     }
6798   }
6799 }
6800 #endif  // USE_PQSORT
6801 #endif  // CHANGE_MV_SEARCH_ORDER
6802
6803 static void build_motion_field(VP9_COMP *cpi, MACROBLOCKD *xd, int frame_idx,
6804                                YV12_BUFFER_CONFIG *ref_frame[3],
6805                                BLOCK_SIZE bsize) {
6806   VP9_COMMON *cm = &cpi->common;
6807   ThreadData *td = &cpi->td;
6808   TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6809   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6810   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6811   const int pw = num_4x4_blocks_wide_lookup[bsize] << 2;
6812   const int ph = num_4x4_blocks_high_lookup[bsize] << 2;
6813   int fs_loc_sort_size;
6814   int fs_loc_heap_size;
6815   int mi_row, mi_col;
6816
6817   tpl_frame->lambda = (pw * ph) >> 2;
6818   assert(pw * ph == tpl_frame->lambda << 2);
6819
6820   fs_loc_sort_size = 0;
6821   for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6822     for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6823       const int mb_y_offset =
6824           mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6825       const int bw = 4 << b_width_log2_lookup[bsize];
6826       const int bh = 4 << b_height_log2_lookup[bsize];
6827       TplDepStats *tpl_stats =
6828           &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6829       FEATURE_SCORE_LOC *fs_loc =
6830           &cpi->feature_score_loc_arr[mi_row * tpl_frame->stride + mi_col];
6831       tpl_stats->feature_score = get_feature_score(
6832           xd->cur_buf->y_buffer + mb_y_offset, xd->cur_buf->y_stride, bw, bh);
6833       fs_loc->visited = 0;
6834       fs_loc->feature_score = tpl_stats->feature_score;
6835       fs_loc->mi_row = mi_row;
6836       fs_loc->mi_col = mi_col;
6837       cpi->feature_score_loc_sort[fs_loc_sort_size] = fs_loc;
6838       ++fs_loc_sort_size;
6839     }
6840   }
6841
6842   qsort(cpi->feature_score_loc_sort, fs_loc_sort_size,
6843         sizeof(*cpi->feature_score_loc_sort), compare_feature_score);
6844
6845   for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6846     for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6847       int rf_idx;
6848       for (rf_idx = 0; rf_idx < 3; ++rf_idx) {
6849         TplDepStats *tpl_stats =
6850             &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6851         tpl_stats->ready[rf_idx] = 0;
6852       }
6853     }
6854   }
6855
6856 #if CHANGE_MV_SEARCH_ORDER
6857 #if !USE_PQSORT
6858   for (i = 0; i < fs_loc_sort_size; ++i) {
6859     FEATURE_SCORE_LOC *fs_loc = cpi->feature_score_loc_sort[i];
6860     do_motion_search(cpi, td, frame_idx, ref_frame, bsize, fs_loc->mi_row,
6861                      fs_loc->mi_col);
6862   }
6863 #else   // !USE_PQSORT
6864   fs_loc_heap_size = 0;
6865   max_heap_push(cpi->feature_score_loc_heap, &fs_loc_heap_size,
6866                 cpi->feature_score_loc_sort[0]);
6867
6868   while (fs_loc_heap_size > 0) {
6869     FEATURE_SCORE_LOC *fs_loc;
6870     max_heap_pop(cpi->feature_score_loc_heap, &fs_loc_heap_size, &fs_loc);
6871
6872     do_motion_search(cpi, td, frame_idx, ref_frame, bsize, fs_loc->mi_row,
6873                      fs_loc->mi_col);
6874
6875     add_nb_blocks_to_heap(cpi, tpl_frame, bsize, fs_loc->mi_row, fs_loc->mi_col,
6876                           &fs_loc_heap_size);
6877   }
6878 #endif  // !USE_PQSORT
6879 #else   // CHANGE_MV_SEARCH_ORDER
6880   for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6881     for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6882       do_motion_search(cpi, td, frame_idx, ref_frame, bsize, mi_row, mi_col);
6883     }
6884   }
6885 #endif  // CHANGE_MV_SEARCH_ORDER
6886 }
6887 #endif  // CONFIG_NON_GREEDY_MV
6888
6889 static void mc_flow_dispenser(VP9_COMP *cpi, GF_PICTURE *gf_picture,
6890                               int frame_idx, BLOCK_SIZE bsize) {
6891   TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6892   YV12_BUFFER_CONFIG *this_frame = gf_picture[frame_idx].frame;
6893   YV12_BUFFER_CONFIG *ref_frame[3] = { NULL, NULL, NULL };
6894
6895   VP9_COMMON *cm = &cpi->common;
6896   struct scale_factors sf;
6897   int rdmult, idx;
6898   ThreadData *td = &cpi->td;
6899   MACROBLOCK *x = &td->mb;
6900   MACROBLOCKD *xd = &x->e_mbd;
6901   int mi_row, mi_col;
6902
6903 #if CONFIG_VP9_HIGHBITDEPTH
6904   DECLARE_ALIGNED(16, uint16_t, predictor16[32 * 32 * 3]);
6905   DECLARE_ALIGNED(16, uint8_t, predictor8[32 * 32 * 3]);
6906   uint8_t *predictor;
6907 #else
6908   DECLARE_ALIGNED(16, uint8_t, predictor[32 * 32 * 3]);
6909 #endif
6910   DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]);
6911   DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]);
6912   DECLARE_ALIGNED(16, tran_low_t, qcoeff[32 * 32]);
6913   DECLARE_ALIGNED(16, tran_low_t, dqcoeff[32 * 32]);
6914
6915   const TX_SIZE tx_size = max_txsize_lookup[bsize];
6916   const int mi_height = num_8x8_blocks_high_lookup[bsize];
6917   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6918   int64_t recon_error, sse;
6919 #if CONFIG_NON_GREEDY_MV
6920   int square_block_idx;
6921   int rf_idx;
6922 #endif
6923
6924   // Setup scaling factor
6925 #if CONFIG_VP9_HIGHBITDEPTH
6926   vp9_setup_scale_factors_for_frame(
6927       &sf, this_frame->y_crop_width, this_frame->y_crop_height,
6928       this_frame->y_crop_width, this_frame->y_crop_height,
6929       cpi->common.use_highbitdepth);
6930
6931   if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH)
6932     predictor = CONVERT_TO_BYTEPTR(predictor16);
6933   else
6934     predictor = predictor8;
6935 #else
6936   vp9_setup_scale_factors_for_frame(
6937       &sf, this_frame->y_crop_width, this_frame->y_crop_height,
6938       this_frame->y_crop_width, this_frame->y_crop_height);
6939 #endif  // CONFIG_VP9_HIGHBITDEPTH
6940
6941   // Prepare reference frame pointers. If any reference frame slot is
6942   // unavailable, the pointer will be set to Null.
6943   for (idx = 0; idx < 3; ++idx) {
6944     int rf_idx = gf_picture[frame_idx].ref_frame[idx];
6945     if (rf_idx != -1) ref_frame[idx] = gf_picture[rf_idx].frame;
6946   }
6947
6948   xd->mi = cm->mi_grid_visible;
6949   xd->mi[0] = cm->mi;
6950   xd->cur_buf = this_frame;
6951
6952   // Get rd multiplier set up.
6953   rdmult = vp9_compute_rd_mult_based_on_qindex(cpi, tpl_frame->base_qindex);
6954   set_error_per_bit(&cpi->td.mb, rdmult);
6955   vp9_initialize_me_consts(cpi, &cpi->td.mb, tpl_frame->base_qindex);
6956
6957   tpl_frame->is_valid = 1;
6958
6959   cm->base_qindex = tpl_frame->base_qindex;
6960   vp9_frame_init_quantizer(cpi);
6961
6962 #if CONFIG_NON_GREEDY_MV
6963   for (square_block_idx = 0; square_block_idx < SQUARE_BLOCK_SIZES;
6964        ++square_block_idx) {
6965     BLOCK_SIZE square_bsize = square_block_idx_to_bsize(square_block_idx);
6966     build_motion_field(cpi, xd, frame_idx, ref_frame, square_bsize);
6967   }
6968   for (rf_idx = 0; rf_idx < 3; ++rf_idx) {
6969     int ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6970     if (ref_frame_idx != -1) {
6971       predict_mv_mode_arr(cpi, x, gf_picture, frame_idx, tpl_frame, rf_idx,
6972                           bsize);
6973     }
6974   }
6975 #endif
6976
6977   for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6978     for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6979       mode_estimation(cpi, x, xd, &sf, gf_picture, frame_idx, tpl_frame,
6980                       src_diff, coeff, qcoeff, dqcoeff, mi_row, mi_col, bsize,
6981                       tx_size, ref_frame, predictor, &recon_error, &sse);
6982       // Motion flow dependency dispenser.
6983       tpl_model_store(tpl_frame->tpl_stats_ptr, mi_row, mi_col, bsize,
6984                       tpl_frame->stride);
6985
6986       tpl_model_update(cpi->tpl_stats, tpl_frame->tpl_stats_ptr, mi_row, mi_col,
6987                        bsize);
6988     }
6989   }
6990 }
6991
6992 #if CONFIG_NON_GREEDY_MV
6993 #define DUMP_TPL_STATS 0
6994 #if DUMP_TPL_STATS
6995 static void dump_buf(uint8_t *buf, int stride, int row, int col, int h, int w) {
6996   int i, j;
6997   printf("%d %d\n", h, w);
6998   for (i = 0; i < h; ++i) {
6999     for (j = 0; j < w; ++j) {
7000       printf("%d ", buf[(row + i) * stride + col + j]);
7001     }
7002   }
7003   printf("\n");
7004 }
7005
7006 static void dump_frame_buf(const YV12_BUFFER_CONFIG *frame_buf) {
7007   dump_buf(frame_buf->y_buffer, frame_buf->y_stride, 0, 0, frame_buf->y_height,
7008            frame_buf->y_width);
7009   dump_buf(frame_buf->u_buffer, frame_buf->uv_stride, 0, 0,
7010            frame_buf->uv_height, frame_buf->uv_width);
7011   dump_buf(frame_buf->v_buffer, frame_buf->uv_stride, 0, 0,
7012            frame_buf->uv_height, frame_buf->uv_width);
7013 }
7014
7015 static void dump_tpl_stats(const VP9_COMP *cpi, int tpl_group_frames,
7016                            const GF_GROUP *gf_group,
7017                            const GF_PICTURE *gf_picture, BLOCK_SIZE bsize) {
7018   int frame_idx;
7019   const VP9_COMMON *cm = &cpi->common;
7020   int rf_idx;
7021   for (frame_idx = 1; frame_idx < tpl_group_frames; ++frame_idx) {
7022     for (rf_idx = 0; rf_idx < 3; ++rf_idx) {
7023       const TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
7024       int mi_row, mi_col;
7025       int ref_frame_idx;
7026       const int mi_height = num_8x8_blocks_high_lookup[bsize];
7027       const int mi_width = num_8x8_blocks_wide_lookup[bsize];
7028       ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
7029       if (ref_frame_idx != -1) {
7030         YV12_BUFFER_CONFIG *ref_frame_buf = gf_picture[ref_frame_idx].frame;
7031         const int gf_frame_offset = gf_group->frame_gop_index[frame_idx];
7032         const int ref_gf_frame_offset =
7033             gf_group->frame_gop_index[ref_frame_idx];
7034         printf("=\n");
7035         printf(
7036             "frame_idx %d mi_rows %d mi_cols %d bsize %d ref_frame_idx %d "
7037             "rf_idx %d gf_frame_offset %d ref_gf_frame_offset %d\n",
7038             frame_idx, cm->mi_rows, cm->mi_cols, mi_width * MI_SIZE,
7039             ref_frame_idx, rf_idx, gf_frame_offset, ref_gf_frame_offset);
7040         for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) {
7041           for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
7042             if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) {
7043               int_mv mv =
7044                   *get_pyramid_mv(tpl_frame, rf_idx, bsize, mi_row, mi_col);
7045               printf("%d %d %d %d\n", mi_row, mi_col, mv.as_mv.row,
7046                      mv.as_mv.col);
7047             }
7048           }
7049         }
7050         for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) {
7051           for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
7052             if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) {
7053               const TplDepStats *tpl_ptr =
7054                   &tpl_frame
7055                        ->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
7056               printf("%f ", tpl_ptr->feature_score);
7057             }
7058           }
7059         }
7060         printf("\n");
7061
7062         for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
7063           for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
7064             const int mv_mode =
7065                 tpl_frame
7066                     ->mv_mode_arr[rf_idx][mi_row * tpl_frame->stride + mi_col];
7067             printf("%d ", mv_mode);
7068           }
7069         }
7070         printf("\n");
7071
7072         dump_frame_buf(gf_picture[frame_idx].frame);
7073         dump_frame_buf(ref_frame_buf);
7074       }
7075     }
7076   }
7077 }
7078 #endif  // DUMP_TPL_STATS
7079 #endif  // CONFIG_NON_GREEDY_MV
7080
7081 static void init_tpl_buffer(VP9_COMP *cpi) {
7082   VP9_COMMON *cm = &cpi->common;
7083   int frame;
7084
7085   const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7086   const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7087 #if CONFIG_NON_GREEDY_MV
7088   int sqr_bsize;
7089   int rf_idx;
7090
7091   // TODO(angiebird): This probably needs further modifications to support
7092   // frame scaling later on.
7093   if (cpi->feature_score_loc_alloc == 0) {
7094     // The smallest block size of motion field is 4x4, but the mi_unit is 8x8,
7095     // therefore the number of units is "mi_rows * mi_cols * 4" here.
7096     CHECK_MEM_ERROR(
7097         cm, cpi->feature_score_loc_arr,
7098         vpx_calloc(mi_rows * mi_cols * 4, sizeof(*cpi->feature_score_loc_arr)));
7099     CHECK_MEM_ERROR(cm, cpi->feature_score_loc_sort,
7100                     vpx_calloc(mi_rows * mi_cols * 4,
7101                                sizeof(*cpi->feature_score_loc_sort)));
7102     CHECK_MEM_ERROR(cm, cpi->feature_score_loc_heap,
7103                     vpx_calloc(mi_rows * mi_cols * 4,
7104                                sizeof(*cpi->feature_score_loc_heap)));
7105
7106     cpi->feature_score_loc_alloc = 1;
7107   }
7108   vpx_free(cpi->select_mv_arr);
7109   CHECK_MEM_ERROR(
7110       cm, cpi->select_mv_arr,
7111       vpx_calloc(mi_rows * mi_cols * 4, sizeof(*cpi->select_mv_arr)));
7112 #endif
7113
7114   // TODO(jingning): Reduce the actual memory use for tpl model build up.
7115   for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) {
7116     if (cpi->tpl_stats[frame].width >= mi_cols &&
7117         cpi->tpl_stats[frame].height >= mi_rows &&
7118         cpi->tpl_stats[frame].tpl_stats_ptr)
7119       continue;
7120
7121 #if CONFIG_NON_GREEDY_MV
7122     for (rf_idx = 0; rf_idx < 3; ++rf_idx) {
7123       for (sqr_bsize = 0; sqr_bsize < SQUARE_BLOCK_SIZES; ++sqr_bsize) {
7124         vpx_free(cpi->tpl_stats[frame].pyramid_mv_arr[rf_idx][sqr_bsize]);
7125         CHECK_MEM_ERROR(
7126             cm, cpi->tpl_stats[frame].pyramid_mv_arr[rf_idx][sqr_bsize],
7127             vpx_calloc(
7128                 mi_rows * mi_cols * 4,
7129                 sizeof(
7130                     *cpi->tpl_stats[frame].pyramid_mv_arr[rf_idx][sqr_bsize])));
7131       }
7132       vpx_free(cpi->tpl_stats[frame].mv_mode_arr[rf_idx]);
7133       CHECK_MEM_ERROR(
7134           cm, cpi->tpl_stats[frame].mv_mode_arr[rf_idx],
7135           vpx_calloc(mi_rows * mi_cols * 4,
7136                      sizeof(*cpi->tpl_stats[frame].mv_mode_arr[rf_idx])));
7137       vpx_free(cpi->tpl_stats[frame].rd_diff_arr[rf_idx]);
7138       CHECK_MEM_ERROR(
7139           cm, cpi->tpl_stats[frame].rd_diff_arr[rf_idx],
7140           vpx_calloc(mi_rows * mi_cols * 4,
7141                      sizeof(*cpi->tpl_stats[frame].rd_diff_arr[rf_idx])));
7142     }
7143 #endif
7144     vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr);
7145     CHECK_MEM_ERROR(cm, cpi->tpl_stats[frame].tpl_stats_ptr,
7146                     vpx_calloc(mi_rows * mi_cols,
7147                                sizeof(*cpi->tpl_stats[frame].tpl_stats_ptr)));
7148     cpi->tpl_stats[frame].is_valid = 0;
7149     cpi->tpl_stats[frame].width = mi_cols;
7150     cpi->tpl_stats[frame].height = mi_rows;
7151     cpi->tpl_stats[frame].stride = mi_cols;
7152     cpi->tpl_stats[frame].mi_rows = cm->mi_rows;
7153     cpi->tpl_stats[frame].mi_cols = cm->mi_cols;
7154   }
7155
7156   for (frame = 0; frame < REF_FRAMES; ++frame) {
7157     cpi->enc_frame_buf[frame].mem_valid = 0;
7158     cpi->enc_frame_buf[frame].released = 1;
7159   }
7160 }
7161
7162 static void setup_tpl_stats(VP9_COMP *cpi) {
7163   GF_PICTURE gf_picture[MAX_ARF_GOP_SIZE];
7164   const GF_GROUP *gf_group = &cpi->twopass.gf_group;
7165   int tpl_group_frames = 0;
7166   int frame_idx;
7167   cpi->tpl_bsize = BLOCK_32X32;
7168
7169   init_gop_frames(cpi, gf_picture, gf_group, &tpl_group_frames);
7170
7171   init_tpl_stats(cpi);
7172
7173   // Backward propagation from tpl_group_frames to 1.
7174   for (frame_idx = tpl_group_frames - 1; frame_idx > 0; --frame_idx) {
7175     if (gf_picture[frame_idx].update_type == USE_BUF_FRAME) continue;
7176     mc_flow_dispenser(cpi, gf_picture, frame_idx, cpi->tpl_bsize);
7177   }
7178 #if CONFIG_NON_GREEDY_MV
7179   cpi->tpl_ready = 1;
7180 #if DUMP_TPL_STATS
7181   dump_tpl_stats(cpi, tpl_group_frames, gf_group, gf_picture, cpi->tpl_bsize);
7182 #endif  // DUMP_TPL_STATS
7183 #endif  // CONFIG_NON_GREEDY_MV
7184 }
7185
7186 int vp9_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags,
7187                             size_t *size, uint8_t *dest, int64_t *time_stamp,
7188                             int64_t *time_end, int flush) {
7189   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
7190   VP9_COMMON *const cm = &cpi->common;
7191   BufferPool *const pool = cm->buffer_pool;
7192   RATE_CONTROL *const rc = &cpi->rc;
7193   struct vpx_usec_timer cmptimer;
7194   YV12_BUFFER_CONFIG *force_src_buffer = NULL;
7195   struct lookahead_entry *last_source = NULL;
7196   struct lookahead_entry *source = NULL;
7197   int arf_src_index;
7198   const int gf_group_index = cpi->twopass.gf_group.index;
7199   int i;
7200
7201   if (is_one_pass_cbr_svc(cpi)) {
7202     vp9_one_pass_cbr_svc_start_layer(cpi);
7203   }
7204
7205   vpx_usec_timer_start(&cmptimer);
7206
7207   vp9_set_high_precision_mv(cpi, ALTREF_HIGH_PRECISION_MV);
7208
7209   // Is multi-arf enabled.
7210   // Note that at the moment multi_arf is only configured for 2 pass VBR and
7211   // will not work properly with svc.
7212   // Enable the Jingning's new "multi_layer_arf" code if "enable_auto_arf"
7213   // is greater than or equal to 2.
7214   if ((oxcf->pass == 2) && !cpi->use_svc && (cpi->oxcf.enable_auto_arf >= 2))
7215     cpi->multi_layer_arf = 1;
7216   else
7217     cpi->multi_layer_arf = 0;
7218
7219   // Normal defaults
7220   cm->reset_frame_context = 0;
7221   cm->refresh_frame_context = 1;
7222   if (!is_one_pass_cbr_svc(cpi)) {
7223     cpi->refresh_last_frame = 1;
7224     cpi->refresh_golden_frame = 0;
7225     cpi->refresh_alt_ref_frame = 0;
7226   }
7227
7228   // Should we encode an arf frame.
7229   arf_src_index = get_arf_src_index(cpi);
7230
7231   if (arf_src_index) {
7232     for (i = 0; i <= arf_src_index; ++i) {
7233       struct lookahead_entry *e = vp9_lookahead_peek(cpi->lookahead, i);
7234       // Avoid creating an alt-ref if there's a forced keyframe pending.
7235       if (e == NULL) {
7236         break;
7237       } else if (e->flags == VPX_EFLAG_FORCE_KF) {
7238         arf_src_index = 0;
7239         flush = 1;
7240         break;
7241       }
7242     }
7243   }
7244
7245   // Clear arf index stack before group of pictures processing starts.
7246   if (gf_group_index == 1) {
7247     stack_init(cpi->twopass.gf_group.arf_index_stack, MAX_LAG_BUFFERS * 2);
7248     cpi->twopass.gf_group.stack_size = 0;
7249   }
7250
7251   if (arf_src_index) {
7252     assert(arf_src_index <= rc->frames_to_key);
7253     if ((source = vp9_lookahead_peek(cpi->lookahead, arf_src_index)) != NULL) {
7254       cpi->alt_ref_source = source;
7255
7256 #if !CONFIG_REALTIME_ONLY
7257       if ((oxcf->mode != REALTIME) && (oxcf->arnr_max_frames > 0) &&
7258           (oxcf->arnr_strength > 0)) {
7259         int bitrate = cpi->rc.avg_frame_bandwidth / 40;
7260         int not_low_bitrate = bitrate > ALT_REF_AQ_LOW_BITRATE_BOUNDARY;
7261
7262         int not_last_frame = (cpi->lookahead->sz - arf_src_index > 1);
7263         not_last_frame |= ALT_REF_AQ_APPLY_TO_LAST_FRAME;
7264
7265         // Produce the filtered ARF frame.
7266         vp9_temporal_filter(cpi, arf_src_index);
7267         vpx_extend_frame_borders(&cpi->alt_ref_buffer);
7268
7269         // for small bitrates segmentation overhead usually
7270         // eats all bitrate gain from enabling delta quantizers
7271         if (cpi->oxcf.alt_ref_aq != 0 && not_low_bitrate && not_last_frame)
7272           vp9_alt_ref_aq_setup_mode(cpi->alt_ref_aq, cpi);
7273
7274         force_src_buffer = &cpi->alt_ref_buffer;
7275       }
7276 #endif
7277       cm->show_frame = 0;
7278       cm->intra_only = 0;
7279       cpi->refresh_alt_ref_frame = 1;
7280       cpi->refresh_golden_frame = 0;
7281       cpi->refresh_last_frame = 0;
7282       rc->is_src_frame_alt_ref = 0;
7283       rc->source_alt_ref_pending = 0;
7284     } else {
7285       rc->source_alt_ref_pending = 0;
7286     }
7287   }
7288
7289   if (!source) {
7290     // Get last frame source.
7291     if (cm->current_video_frame > 0) {
7292       if ((last_source = vp9_lookahead_peek(cpi->lookahead, -1)) == NULL)
7293         return -1;
7294     }
7295
7296     // Read in the source frame.
7297     if (cpi->use_svc || cpi->svc.set_intra_only_frame)
7298       source = vp9_svc_lookahead_pop(cpi, cpi->lookahead, flush);
7299     else
7300       source = vp9_lookahead_pop(cpi->lookahead, flush);
7301
7302     if (source != NULL) {
7303       cm->show_frame = 1;
7304       cm->intra_only = 0;
7305       // if the flags indicate intra frame, but if the current picture is for
7306       // non-zero spatial layer, it should not be an intra picture.
7307       if ((source->flags & VPX_EFLAG_FORCE_KF) && cpi->use_svc &&
7308           cpi->svc.spatial_layer_id > 0) {
7309         source->flags &= ~(unsigned int)(VPX_EFLAG_FORCE_KF);
7310       }
7311
7312       // Check to see if the frame should be encoded as an arf overlay.
7313       check_src_altref(cpi, source);
7314     }
7315   }
7316
7317   if (source) {
7318     cpi->un_scaled_source = cpi->Source =
7319         force_src_buffer ? force_src_buffer : &source->img;
7320
7321 #ifdef ENABLE_KF_DENOISE
7322     // Copy of raw source for metrics calculation.
7323     if (is_psnr_calc_enabled(cpi))
7324       vp9_copy_and_extend_frame(cpi->Source, &cpi->raw_unscaled_source);
7325 #endif
7326
7327     cpi->unscaled_last_source = last_source != NULL ? &last_source->img : NULL;
7328
7329     *time_stamp = source->ts_start;
7330     *time_end = source->ts_end;
7331     *frame_flags = (source->flags & VPX_EFLAG_FORCE_KF) ? FRAMEFLAGS_KEY : 0;
7332   } else {
7333     *size = 0;
7334 #if !CONFIG_REALTIME_ONLY
7335     if (flush && oxcf->pass == 1 && !cpi->twopass.first_pass_done) {
7336       vp9_end_first_pass(cpi); /* get last stats packet */
7337       cpi->twopass.first_pass_done = 1;
7338     }
7339 #endif  // !CONFIG_REALTIME_ONLY
7340     return -1;
7341   }
7342
7343   if (source->ts_start < cpi->first_time_stamp_ever) {
7344     cpi->first_time_stamp_ever = source->ts_start;
7345     cpi->last_end_time_stamp_seen = source->ts_start;
7346   }
7347
7348   // Clear down mmx registers
7349   vpx_clear_system_state();
7350
7351   // adjust frame rates based on timestamps given
7352   if (cm->show_frame) {
7353     if (cpi->use_svc && cpi->svc.use_set_ref_frame_config &&
7354         cpi->svc.duration[cpi->svc.spatial_layer_id] > 0)
7355       vp9_svc_adjust_frame_rate(cpi);
7356     else
7357       adjust_frame_rate(cpi, source);
7358   }
7359
7360   if (is_one_pass_cbr_svc(cpi)) {
7361     vp9_update_temporal_layer_framerate(cpi);
7362     vp9_restore_layer_context(cpi);
7363   }
7364
7365   // Find a free buffer for the new frame, releasing the reference previously
7366   // held.
7367   if (cm->new_fb_idx != INVALID_IDX) {
7368     --pool->frame_bufs[cm->new_fb_idx].ref_count;
7369   }
7370   cm->new_fb_idx = get_free_fb(cm);
7371
7372   if (cm->new_fb_idx == INVALID_IDX) return -1;
7373
7374   cm->cur_frame = &pool->frame_bufs[cm->new_fb_idx];
7375
7376   // Start with a 0 size frame.
7377   *size = 0;
7378
7379   cpi->frame_flags = *frame_flags;
7380
7381 #if !CONFIG_REALTIME_ONLY
7382   if ((oxcf->pass == 2) && !cpi->use_svc) {
7383     vp9_rc_get_second_pass_params(cpi);
7384   } else if (oxcf->pass == 1) {
7385     set_frame_size(cpi);
7386   }
7387 #endif  // !CONFIG_REALTIME_ONLY
7388
7389   if (oxcf->pass != 1 && cpi->level_constraint.level_index >= 0 &&
7390       cpi->level_constraint.fail_flag == 0)
7391     level_rc_framerate(cpi, arf_src_index);
7392
7393   if (cpi->oxcf.pass != 0 || cpi->use_svc || frame_is_intra_only(cm) == 1) {
7394     for (i = 0; i < REFS_PER_FRAME; ++i) cpi->scaled_ref_idx[i] = INVALID_IDX;
7395   }
7396
7397   if (cpi->kmeans_data_arr_alloc == 0) {
7398     const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7399     const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7400 #if CONFIG_MULTITHREAD
7401     pthread_mutex_init(&cpi->kmeans_mutex, NULL);
7402 #endif
7403     CHECK_MEM_ERROR(
7404         cm, cpi->kmeans_data_arr,
7405         vpx_calloc(mi_rows * mi_cols, sizeof(*cpi->kmeans_data_arr)));
7406     cpi->kmeans_data_stride = mi_cols;
7407     cpi->kmeans_data_arr_alloc = 1;
7408   }
7409
7410   if (gf_group_index == 1 &&
7411       cpi->twopass.gf_group.update_type[gf_group_index] == ARF_UPDATE &&
7412       cpi->sf.enable_tpl_model) {
7413     init_tpl_buffer(cpi);
7414     vp9_estimate_qp_gop(cpi);
7415     setup_tpl_stats(cpi);
7416   }
7417
7418 #if CONFIG_BITSTREAM_DEBUG
7419   assert(cpi->oxcf.max_threads == 0 &&
7420          "bitstream debug tool does not support multithreading");
7421   bitstream_queue_record_write();
7422 #endif
7423 #if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
7424   bitstream_queue_set_frame_write(cm->current_video_frame * 2 + cm->show_frame);
7425 #endif
7426
7427   cpi->td.mb.fp_src_pred = 0;
7428 #if CONFIG_REALTIME_ONLY
7429   if (cpi->use_svc) {
7430     SvcEncode(cpi, size, dest, frame_flags);
7431   } else {
7432     // One pass encode
7433     Pass0Encode(cpi, size, dest, frame_flags);
7434   }
7435 #else  // !CONFIG_REALTIME_ONLY
7436   if (oxcf->pass == 1 && !cpi->use_svc) {
7437     const int lossless = is_lossless_requested(oxcf);
7438 #if CONFIG_VP9_HIGHBITDEPTH
7439     if (cpi->oxcf.use_highbitdepth)
7440       cpi->td.mb.fwd_txfm4x4 =
7441           lossless ? vp9_highbd_fwht4x4 : vpx_highbd_fdct4x4;
7442     else
7443       cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4;
7444     cpi->td.mb.highbd_inv_txfm_add =
7445         lossless ? vp9_highbd_iwht4x4_add : vp9_highbd_idct4x4_add;
7446 #else
7447     cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4;
7448 #endif  // CONFIG_VP9_HIGHBITDEPTH
7449     cpi->td.mb.inv_txfm_add = lossless ? vp9_iwht4x4_add : vp9_idct4x4_add;
7450     vp9_first_pass(cpi, source);
7451   } else if (oxcf->pass == 2 && !cpi->use_svc) {
7452     Pass2Encode(cpi, size, dest, frame_flags);
7453   } else if (cpi->use_svc) {
7454     SvcEncode(cpi, size, dest, frame_flags);
7455   } else {
7456     // One pass encode
7457     Pass0Encode(cpi, size, dest, frame_flags);
7458   }
7459 #endif  // CONFIG_REALTIME_ONLY
7460
7461   if (cm->show_frame) cm->cur_show_frame_fb_idx = cm->new_fb_idx;
7462
7463   if (cm->refresh_frame_context)
7464     cm->frame_contexts[cm->frame_context_idx] = *cm->fc;
7465
7466   // No frame encoded, or frame was dropped, release scaled references.
7467   if ((*size == 0) && (frame_is_intra_only(cm) == 0)) {
7468     release_scaled_references(cpi);
7469   }
7470
7471   if (*size > 0) {
7472     cpi->droppable = !frame_is_reference(cpi);
7473   }
7474
7475   // Save layer specific state.
7476   if (is_one_pass_cbr_svc(cpi) || ((cpi->svc.number_temporal_layers > 1 ||
7477                                     cpi->svc.number_spatial_layers > 1) &&
7478                                    oxcf->pass == 2)) {
7479     vp9_save_layer_context(cpi);
7480   }
7481
7482   vpx_usec_timer_mark(&cmptimer);
7483   cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
7484
7485   // Should we calculate metrics for the frame.
7486   if (is_psnr_calc_enabled(cpi)) generate_psnr_packet(cpi);
7487
7488   if (cpi->keep_level_stats && oxcf->pass != 1)
7489     update_level_info(cpi, size, arf_src_index);
7490
7491 #if CONFIG_INTERNAL_STATS
7492
7493   if (oxcf->pass != 1) {
7494     double samples = 0.0;
7495     cpi->bytes += (int)(*size);
7496
7497     if (cm->show_frame) {
7498       uint32_t bit_depth = 8;
7499       uint32_t in_bit_depth = 8;
7500       cpi->count++;
7501 #if CONFIG_VP9_HIGHBITDEPTH
7502       if (cm->use_highbitdepth) {
7503         in_bit_depth = cpi->oxcf.input_bit_depth;
7504         bit_depth = cm->bit_depth;
7505       }
7506 #endif
7507
7508       if (cpi->b_calculate_psnr) {
7509         YV12_BUFFER_CONFIG *orig = cpi->raw_source_frame;
7510         YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
7511         YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer;
7512         PSNR_STATS psnr;
7513 #if CONFIG_VP9_HIGHBITDEPTH
7514         vpx_calc_highbd_psnr(orig, recon, &psnr, cpi->td.mb.e_mbd.bd,
7515                              in_bit_depth);
7516 #else
7517         vpx_calc_psnr(orig, recon, &psnr);
7518 #endif  // CONFIG_VP9_HIGHBITDEPTH
7519
7520         adjust_image_stat(psnr.psnr[1], psnr.psnr[2], psnr.psnr[3],
7521                           psnr.psnr[0], &cpi->psnr);
7522         cpi->total_sq_error += psnr.sse[0];
7523         cpi->total_samples += psnr.samples[0];
7524         samples = psnr.samples[0];
7525
7526         {
7527           PSNR_STATS psnr2;
7528           double frame_ssim2 = 0, weight = 0;
7529 #if CONFIG_VP9_POSTPROC
7530           if (vpx_alloc_frame_buffer(
7531                   pp, recon->y_crop_width, recon->y_crop_height,
7532                   cm->subsampling_x, cm->subsampling_y,
7533 #if CONFIG_VP9_HIGHBITDEPTH
7534                   cm->use_highbitdepth,
7535 #endif
7536                   VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment) < 0) {
7537             vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
7538                                "Failed to allocate post processing buffer");
7539           }
7540           {
7541             vp9_ppflags_t ppflags;
7542             ppflags.post_proc_flag = VP9D_DEBLOCK;
7543             ppflags.deblocking_level = 0;  // not used in vp9_post_proc_frame()
7544             ppflags.noise_level = 0;       // not used in vp9_post_proc_frame()
7545             vp9_post_proc_frame(cm, pp, &ppflags,
7546                                 cpi->un_scaled_source->y_width);
7547           }
7548 #endif
7549           vpx_clear_system_state();
7550
7551 #if CONFIG_VP9_HIGHBITDEPTH
7552           vpx_calc_highbd_psnr(orig, pp, &psnr2, cpi->td.mb.e_mbd.bd,
7553                                cpi->oxcf.input_bit_depth);
7554 #else
7555           vpx_calc_psnr(orig, pp, &psnr2);
7556 #endif  // CONFIG_VP9_HIGHBITDEPTH
7557
7558           cpi->totalp_sq_error += psnr2.sse[0];
7559           cpi->totalp_samples += psnr2.samples[0];
7560           adjust_image_stat(psnr2.psnr[1], psnr2.psnr[2], psnr2.psnr[3],
7561                             psnr2.psnr[0], &cpi->psnrp);
7562
7563 #if CONFIG_VP9_HIGHBITDEPTH
7564           if (cm->use_highbitdepth) {
7565             frame_ssim2 = vpx_highbd_calc_ssim(orig, recon, &weight, bit_depth,
7566                                                in_bit_depth);
7567           } else {
7568             frame_ssim2 = vpx_calc_ssim(orig, recon, &weight);
7569           }
7570 #else
7571           frame_ssim2 = vpx_calc_ssim(orig, recon, &weight);
7572 #endif  // CONFIG_VP9_HIGHBITDEPTH
7573
7574           cpi->worst_ssim = VPXMIN(cpi->worst_ssim, frame_ssim2);
7575           cpi->summed_quality += frame_ssim2 * weight;
7576           cpi->summed_weights += weight;
7577
7578 #if CONFIG_VP9_HIGHBITDEPTH
7579           if (cm->use_highbitdepth) {
7580             frame_ssim2 = vpx_highbd_calc_ssim(orig, pp, &weight, bit_depth,
7581                                                in_bit_depth);
7582           } else {
7583             frame_ssim2 = vpx_calc_ssim(orig, pp, &weight);
7584           }
7585 #else
7586           frame_ssim2 = vpx_calc_ssim(orig, pp, &weight);
7587 #endif  // CONFIG_VP9_HIGHBITDEPTH
7588
7589           cpi->summedp_quality += frame_ssim2 * weight;
7590           cpi->summedp_weights += weight;
7591 #if 0
7592           if (cm->show_frame) {
7593             FILE *f = fopen("q_used.stt", "a");
7594             fprintf(f, "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n",
7595                     cpi->common.current_video_frame, psnr2.psnr[1],
7596                     psnr2.psnr[2], psnr2.psnr[3], psnr2.psnr[0], frame_ssim2);
7597             fclose(f);
7598           }
7599 #endif
7600         }
7601       }
7602       if (cpi->b_calculate_blockiness) {
7603 #if CONFIG_VP9_HIGHBITDEPTH
7604         if (!cm->use_highbitdepth)
7605 #endif
7606         {
7607           double frame_blockiness = vp9_get_blockiness(
7608               cpi->Source->y_buffer, cpi->Source->y_stride,
7609               cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride,
7610               cpi->Source->y_width, cpi->Source->y_height);
7611           cpi->worst_blockiness =
7612               VPXMAX(cpi->worst_blockiness, frame_blockiness);
7613           cpi->total_blockiness += frame_blockiness;
7614         }
7615       }
7616
7617       if (cpi->b_calculate_consistency) {
7618 #if CONFIG_VP9_HIGHBITDEPTH
7619         if (!cm->use_highbitdepth)
7620 #endif
7621         {
7622           double this_inconsistency = vpx_get_ssim_metrics(
7623               cpi->Source->y_buffer, cpi->Source->y_stride,
7624               cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride,
7625               cpi->Source->y_width, cpi->Source->y_height, cpi->ssim_vars,
7626               &cpi->metrics, 1);
7627
7628           const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
7629           double consistency =
7630               vpx_sse_to_psnr(samples, peak, (double)cpi->total_inconsistency);
7631           if (consistency > 0.0)
7632             cpi->worst_consistency =
7633                 VPXMIN(cpi->worst_consistency, consistency);
7634           cpi->total_inconsistency += this_inconsistency;
7635         }
7636       }
7637
7638       {
7639         double y, u, v, frame_all;
7640         frame_all = vpx_calc_fastssim(cpi->Source, cm->frame_to_show, &y, &u,
7641                                       &v, bit_depth, in_bit_depth);
7642         adjust_image_stat(y, u, v, frame_all, &cpi->fastssim);
7643       }
7644       {
7645         double y, u, v, frame_all;
7646         frame_all = vpx_psnrhvs(cpi->Source, cm->frame_to_show, &y, &u, &v,
7647                                 bit_depth, in_bit_depth);
7648         adjust_image_stat(y, u, v, frame_all, &cpi->psnrhvs);
7649       }
7650     }
7651   }
7652
7653 #endif
7654
7655   if (is_one_pass_cbr_svc(cpi)) {
7656     if (cm->show_frame) {
7657       ++cpi->svc.spatial_layer_to_encode;
7658       if (cpi->svc.spatial_layer_to_encode >= cpi->svc.number_spatial_layers)
7659         cpi->svc.spatial_layer_to_encode = 0;
7660     }
7661   }
7662
7663   vpx_clear_system_state();
7664   return 0;
7665 }
7666
7667 int vp9_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
7668                               vp9_ppflags_t *flags) {
7669   VP9_COMMON *cm = &cpi->common;
7670 #if !CONFIG_VP9_POSTPROC
7671   (void)flags;
7672 #endif
7673
7674   if (!cm->show_frame) {
7675     return -1;
7676   } else {
7677     int ret;
7678 #if CONFIG_VP9_POSTPROC
7679     ret = vp9_post_proc_frame(cm, dest, flags, cpi->un_scaled_source->y_width);
7680 #else
7681     if (cm->frame_to_show) {
7682       *dest = *cm->frame_to_show;
7683       dest->y_width = cm->width;
7684       dest->y_height = cm->height;
7685       dest->uv_width = cm->width >> cm->subsampling_x;
7686       dest->uv_height = cm->height >> cm->subsampling_y;
7687       ret = 0;
7688     } else {
7689       ret = -1;
7690     }
7691 #endif  // !CONFIG_VP9_POSTPROC
7692     vpx_clear_system_state();
7693     return ret;
7694   }
7695 }
7696
7697 int vp9_set_internal_size(VP9_COMP *cpi, VPX_SCALING horiz_mode,
7698                           VPX_SCALING vert_mode) {
7699   VP9_COMMON *cm = &cpi->common;
7700   int hr = 0, hs = 0, vr = 0, vs = 0;
7701
7702   if (horiz_mode > ONETWO || vert_mode > ONETWO) return -1;
7703
7704   Scale2Ratio(horiz_mode, &hr, &hs);
7705   Scale2Ratio(vert_mode, &vr, &vs);
7706
7707   // always go to the next whole number
7708   cm->width = (hs - 1 + cpi->oxcf.width * hr) / hs;
7709   cm->height = (vs - 1 + cpi->oxcf.height * vr) / vs;
7710   if (cm->current_video_frame) {
7711     assert(cm->width <= cpi->initial_width);
7712     assert(cm->height <= cpi->initial_height);
7713   }
7714
7715   update_frame_size(cpi);
7716
7717   return 0;
7718 }
7719
7720 int vp9_set_size_literal(VP9_COMP *cpi, unsigned int width,
7721                          unsigned int height) {
7722   VP9_COMMON *cm = &cpi->common;
7723 #if CONFIG_VP9_HIGHBITDEPTH
7724   check_initial_width(cpi, cm->use_highbitdepth, 1, 1);
7725 #else
7726   check_initial_width(cpi, 1, 1);
7727 #endif  // CONFIG_VP9_HIGHBITDEPTH
7728
7729 #if CONFIG_VP9_TEMPORAL_DENOISING
7730   setup_denoiser_buffer(cpi);
7731 #endif
7732
7733   if (width) {
7734     cm->width = width;
7735     if (cm->width > cpi->initial_width) {
7736       cm->width = cpi->initial_width;
7737       printf("Warning: Desired width too large, changed to %d\n", cm->width);
7738     }
7739   }
7740
7741   if (height) {
7742     cm->height = height;
7743     if (cm->height > cpi->initial_height) {
7744       cm->height = cpi->initial_height;
7745       printf("Warning: Desired height too large, changed to %d\n", cm->height);
7746     }
7747   }
7748   assert(cm->width <= cpi->initial_width);
7749   assert(cm->height <= cpi->initial_height);
7750
7751   update_frame_size(cpi);
7752
7753   return 0;
7754 }
7755
7756 void vp9_set_svc(VP9_COMP *cpi, int use_svc) {
7757   cpi->use_svc = use_svc;
7758   return;
7759 }
7760
7761 int vp9_get_quantizer(VP9_COMP *cpi) { return cpi->common.base_qindex; }
7762
7763 void vp9_apply_encoding_flags(VP9_COMP *cpi, vpx_enc_frame_flags_t flags) {
7764   if (flags &
7765       (VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF)) {
7766     int ref = 7;
7767
7768     if (flags & VP8_EFLAG_NO_REF_LAST) ref ^= VP9_LAST_FLAG;
7769
7770     if (flags & VP8_EFLAG_NO_REF_GF) ref ^= VP9_GOLD_FLAG;
7771
7772     if (flags & VP8_EFLAG_NO_REF_ARF) ref ^= VP9_ALT_FLAG;
7773
7774     vp9_use_as_reference(cpi, ref);
7775   }
7776
7777   if (flags &
7778       (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
7779        VP8_EFLAG_FORCE_GF | VP8_EFLAG_FORCE_ARF)) {
7780     int upd = 7;
7781
7782     if (flags & VP8_EFLAG_NO_UPD_LAST) upd ^= VP9_LAST_FLAG;
7783
7784     if (flags & VP8_EFLAG_NO_UPD_GF) upd ^= VP9_GOLD_FLAG;
7785
7786     if (flags & VP8_EFLAG_NO_UPD_ARF) upd ^= VP9_ALT_FLAG;
7787
7788     vp9_update_reference(cpi, upd);
7789   }
7790
7791   if (flags & VP8_EFLAG_NO_UPD_ENTROPY) {
7792     vp9_update_entropy(cpi, 0);
7793   }
7794 }
7795
7796 void vp9_set_row_mt(VP9_COMP *cpi) {
7797   // Enable row based multi-threading for supported modes of encoding
7798   cpi->row_mt = 0;
7799   if (((cpi->oxcf.mode == GOOD || cpi->oxcf.mode == BEST) &&
7800        cpi->oxcf.speed < 5 && cpi->oxcf.pass == 1) &&
7801       cpi->oxcf.row_mt && !cpi->use_svc)
7802     cpi->row_mt = 1;
7803
7804   if (cpi->oxcf.mode == GOOD && cpi->oxcf.speed < 5 &&
7805       (cpi->oxcf.pass == 0 || cpi->oxcf.pass == 2) && cpi->oxcf.row_mt &&
7806       !cpi->use_svc)
7807     cpi->row_mt = 1;
7808
7809   // In realtime mode, enable row based multi-threading for all the speed levels
7810   // where non-rd path is used.
7811   if (cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5 && cpi->oxcf.row_mt) {
7812     cpi->row_mt = 1;
7813   }
7814
7815   if (cpi->row_mt)
7816     cpi->row_mt_bit_exact = 1;
7817   else
7818     cpi->row_mt_bit_exact = 0;
7819 }