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

   1 /*
   2  * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include <math.h>
  12 #include <stdio.h>
  13 #include <limits.h>
  14
  15 #include "./vpx_config.h"
  16 #include "./vpx_scale_rtcd.h"
  17 #include "vpx/internal/vpx_psnr.h"
  18 #include "vpx_ports/vpx_timer.h"
  19
  20 #include "vp9/common/vp9_alloccommon.h"
  21 #include "vp9/common/vp9_filter.h"
  22 #include "vp9/common/vp9_idct.h"
  23 #if CONFIG_VP9_POSTPROC
  24 #include "vp9/common/vp9_postproc.h"
  25 #endif
  26 #include "vp9/common/vp9_reconinter.h"
  27 #include "vp9/common/vp9_systemdependent.h"
  28 #include "vp9/common/vp9_tile_common.h"
  29
  30 #include "vp9/encoder/vp9_aq_complexity.h"
  31 #include "vp9/encoder/vp9_aq_cyclicrefresh.h"
  32 #include "vp9/encoder/vp9_aq_variance.h"
  33 #include "vp9/encoder/vp9_bitstream.h"
  34 #include "vp9/encoder/vp9_encodeframe.h"
  35 #include "vp9/encoder/vp9_encodemv.h"
  36 #include "vp9/encoder/vp9_firstpass.h"
  37 #include "vp9/encoder/vp9_mbgraph.h"
  38 #include "vp9/encoder/vp9_onyx_int.h"
  39 #include "vp9/encoder/vp9_picklpf.h"
  40 #include "vp9/encoder/vp9_ratectrl.h"
  41 #include "vp9/encoder/vp9_rdopt.h"
  42 #include "vp9/encoder/vp9_segmentation.h"
  43 #include "vp9/encoder/vp9_speed_features.h"
  44 #if CONFIG_INTERNAL_STATS
  45 #include "vp9/encoder/vp9_ssim.h"
  46 #endif
  47 #include "vp9/encoder/vp9_temporal_filter.h"
  48 #include "vp9/encoder/vp9_resize.h"
  49 #include "vp9/encoder/vp9_svc_layercontext.h"
  50
  51 void vp9_coef_tree_initialize();
  52
  53 #define DEFAULT_INTERP_FILTER SWITCHABLE
  54
  55 #define SHARP_FILTER_QTHRESH 0          /* Q threshold for 8-tap sharp filter */
  56
  57 #define ALTREF_HIGH_PRECISION_MV 1      // Whether to use high precision mv
  58                                          //  for altref computation.
  59 #define HIGH_PRECISION_MV_QTHRESH 200   // Q threshold for high precision
  60                                          // mv. Choose a very high value for
  61                                          // now so that HIGH_PRECISION is always
  62                                          // chosen.
  63
  64 // Max rate target for 1080P and below encodes under normal circumstances
  65 // (1920 * 1080 / (16 * 16)) * MAX_MB_RATE bits per MB
  66 #define MAX_MB_RATE 250
  67 #define MAXRATE_1080P 2025000
  68
  69 // #define OUTPUT_YUV_REC
  70
  71 #ifdef OUTPUT_YUV_SRC
  72 FILE *yuv_file;
  73 #endif
  74 #ifdef OUTPUT_YUV_REC
  75 FILE *yuv_rec_file;
  76 #endif
  77
  78 #if 0
  79 FILE *framepsnr;
  80 FILE *kf_list;
  81 FILE *keyfile;
  82 #endif
  83
  84 static INLINE void Scale2Ratio(VPX_SCALING mode, int *hr, int *hs) {
  85   switch (mode) {
  86     case NORMAL:
  87       *hr = 1;
  88       *hs = 1;
  89       break;
  90     case FOURFIVE:
  91       *hr = 4;
  92       *hs = 5;
  93       break;
  94     case THREEFIVE:
  95       *hr = 3;
  96       *hs = 5;
  97     break;
  98     case ONETWO:
  99       *hr = 1;
 100       *hs = 2;
 101     break;
 102     default:
 103       *hr = 1;
 104       *hs = 1;
 105        assert(0);
 106       break;
 107   }
 108 }
 109
 110 static void set_high_precision_mv(VP9_COMP *cpi, int allow_high_precision_mv) {
 111   MACROBLOCK *const mb = &cpi->mb;
 112   cpi->common.allow_high_precision_mv = allow_high_precision_mv;
 113   if (cpi->common.allow_high_precision_mv) {
 114     mb->mvcost = mb->nmvcost_hp;
 115     mb->mvsadcost = mb->nmvsadcost_hp;
 116   } else {
 117     mb->mvcost = mb->nmvcost;
 118     mb->mvsadcost = mb->nmvsadcost;
 119   }
 120 }
 121
 122 static void setup_key_frame(VP9_COMP *cpi) {
 123   vp9_setup_past_independence(&cpi->common);
 124
 125   // All buffers are implicitly updated on key frames.
 126   cpi->refresh_golden_frame = 1;
 127   cpi->refresh_alt_ref_frame = 1;
 128 }
 129
 130 static void setup_inter_frame(VP9_COMMON *cm) {
 131   if (cm->error_resilient_mode || cm->intra_only)
 132     vp9_setup_past_independence(cm);
 133
 134   assert(cm->frame_context_idx < FRAME_CONTEXTS);
 135   cm->fc = cm->frame_contexts[cm->frame_context_idx];
 136 }
 137
 138 void vp9_initialize_enc() {
 139   static int init_done = 0;
 140
 141   if (!init_done) {
 142     vp9_init_neighbors();
 143     vp9_init_quant_tables();
 144
 145     vp9_coef_tree_initialize();
 146     vp9_tokenize_initialize();
 147     vp9_init_me_luts();
 148     vp9_rc_init_minq_luts();
 149     vp9_entropy_mv_init();
 150     vp9_entropy_mode_init();
 151     init_done = 1;
 152   }
 153 }
 154
 155 static void dealloc_compressor_data(VP9_COMP *cpi) {
 156   VP9_COMMON *const cm = &cpi->common;
 157   int i;
 158
 159   // Delete sementation map
 160   vpx_free(cpi->segmentation_map);
 161   cpi->segmentation_map = NULL;
 162   vpx_free(cm->last_frame_seg_map);
 163   cm->last_frame_seg_map = NULL;
 164   vpx_free(cpi->coding_context.last_frame_seg_map_copy);
 165   cpi->coding_context.last_frame_seg_map_copy = NULL;
 166
 167   vpx_free(cpi->complexity_map);
 168   cpi->complexity_map = NULL;
 169
 170   vp9_cyclic_refresh_free(cpi->cyclic_refresh);
 171   cpi->cyclic_refresh = NULL;
 172
 173   vpx_free(cpi->active_map);
 174   cpi->active_map = NULL;
 175
 176   vp9_free_frame_buffers(cm);
 177
 178   vp9_free_frame_buffer(&cpi->last_frame_uf);
 179   vp9_free_frame_buffer(&cpi->scaled_source);
 180   vp9_free_frame_buffer(&cpi->scaled_last_source);
 181   vp9_free_frame_buffer(&cpi->alt_ref_buffer);
 182   vp9_lookahead_destroy(cpi->lookahead);
 183
 184   vpx_free(cpi->tok);
 185   cpi->tok = 0;
 186
 187   // Activity mask based per mb zbin adjustments
 188   vpx_free(cpi->mb_activity_map);
 189   cpi->mb_activity_map = 0;
 190   vpx_free(cpi->mb_norm_activity_map);
 191   cpi->mb_norm_activity_map = 0;
 192
 193   for (i = 0; i < cpi->svc.number_spatial_layers; ++i) {
 194     LAYER_CONTEXT *const lc = &cpi->svc.layer_context[i];
 195     vpx_free(lc->rc_twopass_stats_in.buf);
 196     lc->rc_twopass_stats_in.buf = NULL;
 197     lc->rc_twopass_stats_in.sz = 0;
 198   }
 199 }
 200
 201 static void save_coding_context(VP9_COMP *cpi) {
 202   CODING_CONTEXT *const cc = &cpi->coding_context;
 203   VP9_COMMON *cm = &cpi->common;
 204
 205   // Stores a snapshot of key state variables which can subsequently be
 206   // restored with a call to vp9_restore_coding_context. These functions are
 207   // intended for use in a re-code loop in vp9_compress_frame where the
 208   // quantizer value is adjusted between loop iterations.
 209   vp9_copy(cc->nmvjointcost,  cpi->mb.nmvjointcost);
 210   vp9_copy(cc->nmvcosts,  cpi->mb.nmvcosts);
 211   vp9_copy(cc->nmvcosts_hp,  cpi->mb.nmvcosts_hp);
 212
 213   vp9_copy(cc->segment_pred_probs, cm->seg.pred_probs);
 214
 215   vpx_memcpy(cpi->coding_context.last_frame_seg_map_copy,
 216              cm->last_frame_seg_map, (cm->mi_rows * cm->mi_cols));
 217
 218   vp9_copy(cc->last_ref_lf_deltas, cm->lf.last_ref_deltas);
 219   vp9_copy(cc->last_mode_lf_deltas, cm->lf.last_mode_deltas);
 220
 221   cc->fc = cm->fc;
 222 }
 223
 224 static void restore_coding_context(VP9_COMP *cpi) {
 225   CODING_CONTEXT *const cc = &cpi->coding_context;
 226   VP9_COMMON *cm = &cpi->common;
 227
 228   // Restore key state variables to the snapshot state stored in the
 229   // previous call to vp9_save_coding_context.
 230   vp9_copy(cpi->mb.nmvjointcost, cc->nmvjointcost);
 231   vp9_copy(cpi->mb.nmvcosts, cc->nmvcosts);
 232   vp9_copy(cpi->mb.nmvcosts_hp, cc->nmvcosts_hp);
 233
 234   vp9_copy(cm->seg.pred_probs, cc->segment_pred_probs);
 235
 236   vpx_memcpy(cm->last_frame_seg_map,
 237              cpi->coding_context.last_frame_seg_map_copy,
 238              (cm->mi_rows * cm->mi_cols));
 239
 240   vp9_copy(cm->lf.last_ref_deltas, cc->last_ref_lf_deltas);
 241   vp9_copy(cm->lf.last_mode_deltas, cc->last_mode_lf_deltas);
 242
 243   cm->fc = cc->fc;
 244 }
 245
 246 static void configure_static_seg_features(VP9_COMP *cpi) {
 247   VP9_COMMON *const cm = &cpi->common;
 248   const RATE_CONTROL *const rc = &cpi->rc;
 249   struct segmentation *const seg = &cm->seg;
 250
 251   int high_q = (int)(rc->avg_q > 48.0);
 252   int qi_delta;
 253
 254   // Disable and clear down for KF
 255   if (cm->frame_type == KEY_FRAME) {
 256     // Clear down the global segmentation map
 257     vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
 258     seg->update_map = 0;
 259     seg->update_data = 0;
 260     cpi->static_mb_pct = 0;
 261
 262     // Disable segmentation
 263     vp9_disable_segmentation(seg);
 264
 265     // Clear down the segment features.
 266     vp9_clearall_segfeatures(seg);
 267   } else if (cpi->refresh_alt_ref_frame) {
 268     // If this is an alt ref frame
 269     // Clear down the global segmentation map
 270     vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
 271     seg->update_map = 0;
 272     seg->update_data = 0;
 273     cpi->static_mb_pct = 0;
 274
 275     // Disable segmentation and individual segment features by default
 276     vp9_disable_segmentation(seg);
 277     vp9_clearall_segfeatures(seg);
 278
 279     // Scan frames from current to arf frame.
 280     // This function re-enables segmentation if appropriate.
 281     vp9_update_mbgraph_stats(cpi);
 282
 283     // If segmentation was enabled set those features needed for the
 284     // arf itself.
 285     if (seg->enabled) {
 286       seg->update_map = 1;
 287       seg->update_data = 1;
 288
 289       qi_delta = vp9_compute_qdelta(rc, rc->avg_q, rc->avg_q * 0.875);
 290       vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta - 2);
 291       vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2);
 292
 293       vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
 294       vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF);
 295
 296       // Where relevant assume segment data is delta data
 297       seg->abs_delta = SEGMENT_DELTADATA;
 298     }
 299   } else if (seg->enabled) {
 300     // All other frames if segmentation has been enabled
 301
 302     // First normal frame in a valid gf or alt ref group
 303     if (rc->frames_since_golden == 0) {
 304       // Set up segment features for normal frames in an arf group
 305       if (rc->source_alt_ref_active) {
 306         seg->update_map = 0;
 307         seg->update_data = 1;
 308         seg->abs_delta = SEGMENT_DELTADATA;
 309
 310         qi_delta = vp9_compute_qdelta(rc, rc->avg_q, rc->avg_q * 1.125);
 311         vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta + 2);
 312         vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
 313
 314         vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2);
 315         vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF);
 316
 317         // Segment coding disabled for compred testing
 318         if (high_q || (cpi->static_mb_pct == 100)) {
 319           vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
 320           vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
 321           vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP);
 322         }
 323       } else {
 324         // Disable segmentation and clear down features if alt ref
 325         // is not active for this group
 326
 327         vp9_disable_segmentation(seg);
 328
 329         vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
 330
 331         seg->update_map = 0;
 332         seg->update_data = 0;
 333
 334         vp9_clearall_segfeatures(seg);
 335       }
 336     } else if (rc->is_src_frame_alt_ref) {
 337       // Special case where we are coding over the top of a previous
 338       // alt ref frame.
 339       // Segment coding disabled for compred testing
 340
 341       // Enable ref frame features for segment 0 as well
 342       vp9_enable_segfeature(seg, 0, SEG_LVL_REF_FRAME);
 343       vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
 344
 345       // All mbs should use ALTREF_FRAME
 346       vp9_clear_segdata(seg, 0, SEG_LVL_REF_FRAME);
 347       vp9_set_segdata(seg, 0, SEG_LVL_REF_FRAME, ALTREF_FRAME);
 348       vp9_clear_segdata(seg, 1, SEG_LVL_REF_FRAME);
 349       vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
 350
 351       // Skip all MBs if high Q (0,0 mv and skip coeffs)
 352       if (high_q) {
 353         vp9_enable_segfeature(seg, 0, SEG_LVL_SKIP);
 354         vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP);
 355       }
 356       // Enable data update
 357       seg->update_data = 1;
 358     } else {
 359       // All other frames.
 360
 361       // No updates.. leave things as they are.
 362       seg->update_map = 0;
 363       seg->update_data = 0;
 364     }
 365   }
 366 }
 367
 368 static void update_reference_segmentation_map(VP9_COMP *cpi) {
 369   VP9_COMMON *const cm = &cpi->common;
 370   MODE_INFO **mi_8x8_ptr = cm->mi_grid_visible;
 371   uint8_t *cache_ptr = cm->last_frame_seg_map;
 372   int row, col;
 373
 374   for (row = 0; row < cm->mi_rows; row++) {
 375     MODE_INFO **mi_8x8 = mi_8x8_ptr;
 376     uint8_t *cache = cache_ptr;
 377     for (col = 0; col < cm->mi_cols; col++, mi_8x8++, cache++)
 378       cache[0] = mi_8x8[0]->mbmi.segment_id;
 379     mi_8x8_ptr += cm->mi_stride;
 380     cache_ptr += cm->mi_cols;
 381   }
 382 }
 383 static int is_slowest_mode(int mode) {
 384   return (mode == MODE_SECONDPASS_BEST || mode == MODE_BESTQUALITY);
 385 }
 386
 387 static void set_rd_speed_thresholds(VP9_COMP *cpi) {
 388   int i;
 389   RD_OPT *const rd = &cpi->rd;
 390
 391   // Set baseline threshold values
 392   for (i = 0; i < MAX_MODES; ++i)
 393     rd->thresh_mult[i] = is_slowest_mode(cpi->oxcf.mode) ? -500 : 0;
 394
 395   rd->thresh_mult[THR_NEARESTMV] = 0;
 396   rd->thresh_mult[THR_NEARESTG] = 0;
 397   rd->thresh_mult[THR_NEARESTA] = 0;
 398
 399   rd->thresh_mult[THR_DC] += 1000;
 400
 401   rd->thresh_mult[THR_NEWMV] += 1000;
 402   rd->thresh_mult[THR_NEWA] += 1000;
 403   rd->thresh_mult[THR_NEWG] += 1000;
 404
 405   rd->thresh_mult[THR_NEARMV] += 1000;
 406   rd->thresh_mult[THR_NEARA] += 1000;
 407   rd->thresh_mult[THR_COMP_NEARESTLA] += 1000;
 408   rd->thresh_mult[THR_COMP_NEARESTGA] += 1000;
 409
 410   rd->thresh_mult[THR_TM] += 1000;
 411
 412   rd->thresh_mult[THR_COMP_NEARLA] += 1500;
 413   rd->thresh_mult[THR_COMP_NEWLA] += 2000;
 414   rd->thresh_mult[THR_NEARG] += 1000;
 415   rd->thresh_mult[THR_COMP_NEARGA] += 1500;
 416   rd->thresh_mult[THR_COMP_NEWGA] += 2000;
 417
 418   rd->thresh_mult[THR_ZEROMV] += 2000;
 419   rd->thresh_mult[THR_ZEROG] += 2000;
 420   rd->thresh_mult[THR_ZEROA] += 2000;
 421   rd->thresh_mult[THR_COMP_ZEROLA] += 2500;
 422   rd->thresh_mult[THR_COMP_ZEROGA] += 2500;
 423
 424   rd->thresh_mult[THR_H_PRED] += 2000;
 425   rd->thresh_mult[THR_V_PRED] += 2000;
 426   rd->thresh_mult[THR_D45_PRED ] += 2500;
 427   rd->thresh_mult[THR_D135_PRED] += 2500;
 428   rd->thresh_mult[THR_D117_PRED] += 2500;
 429   rd->thresh_mult[THR_D153_PRED] += 2500;
 430   rd->thresh_mult[THR_D207_PRED] += 2500;
 431   rd->thresh_mult[THR_D63_PRED] += 2500;
 432
 433   /* disable frame modes if flags not set */
 434   if (!(cpi->ref_frame_flags & VP9_LAST_FLAG)) {
 435     rd->thresh_mult[THR_NEWMV    ] = INT_MAX;
 436     rd->thresh_mult[THR_NEARESTMV] = INT_MAX;
 437     rd->thresh_mult[THR_ZEROMV   ] = INT_MAX;
 438     rd->thresh_mult[THR_NEARMV   ] = INT_MAX;
 439   }
 440   if (!(cpi->ref_frame_flags & VP9_GOLD_FLAG)) {
 441     rd->thresh_mult[THR_NEARESTG ] = INT_MAX;
 442     rd->thresh_mult[THR_ZEROG    ] = INT_MAX;
 443     rd->thresh_mult[THR_NEARG    ] = INT_MAX;
 444     rd->thresh_mult[THR_NEWG     ] = INT_MAX;
 445   }
 446   if (!(cpi->ref_frame_flags & VP9_ALT_FLAG)) {
 447     rd->thresh_mult[THR_NEARESTA ] = INT_MAX;
 448     rd->thresh_mult[THR_ZEROA    ] = INT_MAX;
 449     rd->thresh_mult[THR_NEARA    ] = INT_MAX;
 450     rd->thresh_mult[THR_NEWA     ] = INT_MAX;
 451   }
 452
 453   if ((cpi->ref_frame_flags & (VP9_LAST_FLAG | VP9_ALT_FLAG)) !=
 454       (VP9_LAST_FLAG | VP9_ALT_FLAG)) {
 455     rd->thresh_mult[THR_COMP_ZEROLA   ] = INT_MAX;
 456     rd->thresh_mult[THR_COMP_NEARESTLA] = INT_MAX;
 457     rd->thresh_mult[THR_COMP_NEARLA   ] = INT_MAX;
 458     rd->thresh_mult[THR_COMP_NEWLA    ] = INT_MAX;
 459   }
 460   if ((cpi->ref_frame_flags & (VP9_GOLD_FLAG | VP9_ALT_FLAG)) !=
 461       (VP9_GOLD_FLAG | VP9_ALT_FLAG)) {
 462     rd->thresh_mult[THR_COMP_ZEROGA   ] = INT_MAX;
 463     rd->thresh_mult[THR_COMP_NEARESTGA] = INT_MAX;
 464     rd->thresh_mult[THR_COMP_NEARGA   ] = INT_MAX;
 465     rd->thresh_mult[THR_COMP_NEWGA    ] = INT_MAX;
 466   }
 467 }
 468
 469 static void set_rd_speed_thresholds_sub8x8(VP9_COMP *cpi) {
 470   const SPEED_FEATURES *const sf = &cpi->sf;
 471   RD_OPT *const rd = &cpi->rd;
 472   int i;
 473
 474   for (i = 0; i < MAX_REFS; ++i)
 475     rd->thresh_mult_sub8x8[i] = is_slowest_mode(cpi->oxcf.mode)  ? -500 : 0;
 476
 477   rd->thresh_mult_sub8x8[THR_LAST] += 2500;
 478   rd->thresh_mult_sub8x8[THR_GOLD] += 2500;
 479   rd->thresh_mult_sub8x8[THR_ALTR] += 2500;
 480   rd->thresh_mult_sub8x8[THR_INTRA] += 2500;
 481   rd->thresh_mult_sub8x8[THR_COMP_LA] += 4500;
 482   rd->thresh_mult_sub8x8[THR_COMP_GA] += 4500;
 483
 484   // Check for masked out split cases.
 485   for (i = 0; i < MAX_REFS; i++)
 486     if (sf->disable_split_mask & (1 << i))
 487       rd->thresh_mult_sub8x8[i] = INT_MAX;
 488
 489   // disable mode test if frame flag is not set
 490   if (!(cpi->ref_frame_flags & VP9_LAST_FLAG))
 491     rd->thresh_mult_sub8x8[THR_LAST] = INT_MAX;
 492   if (!(cpi->ref_frame_flags & VP9_GOLD_FLAG))
 493     rd->thresh_mult_sub8x8[THR_GOLD] = INT_MAX;
 494   if (!(cpi->ref_frame_flags & VP9_ALT_FLAG))
 495     rd->thresh_mult_sub8x8[THR_ALTR] = INT_MAX;
 496   if ((cpi->ref_frame_flags & (VP9_LAST_FLAG | VP9_ALT_FLAG)) !=
 497       (VP9_LAST_FLAG | VP9_ALT_FLAG))
 498     rd->thresh_mult_sub8x8[THR_COMP_LA] = INT_MAX;
 499   if ((cpi->ref_frame_flags & (VP9_GOLD_FLAG | VP9_ALT_FLAG)) !=
 500       (VP9_GOLD_FLAG | VP9_ALT_FLAG))
 501     rd->thresh_mult_sub8x8[THR_COMP_GA] = INT_MAX;
 502 }
 503
 504 static void set_speed_features(VP9_COMP *cpi) {
 505 #if CONFIG_INTERNAL_STATS
 506   int i;
 507   for (i = 0; i < MAX_MODES; ++i)
 508     cpi->mode_chosen_counts[i] = 0;
 509 #endif
 510
 511   vp9_set_speed_features(cpi);
 512
 513   // Set rd thresholds based on mode and speed setting
 514   set_rd_speed_thresholds(cpi);
 515   set_rd_speed_thresholds_sub8x8(cpi);
 516
 517   cpi->mb.fwd_txm4x4 = vp9_fdct4x4;
 518   if (cpi->oxcf.lossless || cpi->mb.e_mbd.lossless) {
 519     cpi->mb.fwd_txm4x4 = vp9_fwht4x4;
 520   }
 521 }
 522
 523 static void alloc_raw_frame_buffers(VP9_COMP *cpi) {
 524   VP9_COMMON *cm = &cpi->common;
 525   const VP9_CONFIG *oxcf = &cpi->oxcf;
 526
 527   cpi->lookahead = vp9_lookahead_init(oxcf->width, oxcf->height,
 528                                       cm->subsampling_x, cm->subsampling_y,
 529                                       oxcf->lag_in_frames);
 530   if (!cpi->lookahead)
 531     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 532                        "Failed to allocate lag buffers");
 533
 534   if (vp9_realloc_frame_buffer(&cpi->alt_ref_buffer,
 535                                oxcf->width, oxcf->height,
 536                                cm->subsampling_x, cm->subsampling_y,
 537                                VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL))
 538     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 539                        "Failed to allocate altref buffer");
 540 }
 541
 542 void vp9_alloc_compressor_data(VP9_COMP *cpi) {
 543   VP9_COMMON *cm = &cpi->common;
 544
 545   if (vp9_alloc_frame_buffers(cm, cm->width, cm->height))
 546     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 547                        "Failed to allocate frame buffers");
 548
 549   if (vp9_alloc_frame_buffer(&cpi->last_frame_uf,
 550                              cm->width, cm->height,
 551                              cm->subsampling_x, cm->subsampling_y,
 552                              VP9_ENC_BORDER_IN_PIXELS))
 553     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 554                        "Failed to allocate last frame buffer");
 555
 556   if (vp9_alloc_frame_buffer(&cpi->scaled_source,
 557                              cm->width, cm->height,
 558                              cm->subsampling_x, cm->subsampling_y,
 559                              VP9_ENC_BORDER_IN_PIXELS))
 560     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 561                        "Failed to allocate scaled source buffer");
 562
 563   if (vp9_alloc_frame_buffer(&cpi->scaled_last_source,
 564                              cm->width, cm->height,
 565                              cm->subsampling_x, cm->subsampling_y,
 566                              VP9_ENC_BORDER_IN_PIXELS))
 567     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 568                        "Failed to allocate scaled last source buffer");
 569
 570   vpx_free(cpi->tok);
 571
 572   {
 573     unsigned int tokens = get_token_alloc(cm->mb_rows, cm->mb_cols);
 574
 575     CHECK_MEM_ERROR(cm, cpi->tok, vpx_calloc(tokens, sizeof(*cpi->tok)));
 576   }
 577
 578   vpx_free(cpi->mb_activity_map);
 579   CHECK_MEM_ERROR(cm, cpi->mb_activity_map,
 580                   vpx_calloc(sizeof(unsigned int),
 581                              cm->mb_rows * cm->mb_cols));
 582
 583   vpx_free(cpi->mb_norm_activity_map);
 584   CHECK_MEM_ERROR(cm, cpi->mb_norm_activity_map,
 585                   vpx_calloc(sizeof(unsigned int),
 586                              cm->mb_rows * cm->mb_cols));
 587 }
 588
 589
 590 static void update_frame_size(VP9_COMP *cpi) {
 591   VP9_COMMON *const cm = &cpi->common;
 592   MACROBLOCKD *const xd = &cpi->mb.e_mbd;
 593
 594   vp9_update_frame_size(cm);
 595
 596   // Update size of buffers local to this frame
 597   if (vp9_realloc_frame_buffer(&cpi->last_frame_uf,
 598                                cm->width, cm->height,
 599                                cm->subsampling_x, cm->subsampling_y,
 600                                VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL))
 601     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 602                        "Failed to reallocate last frame buffer");
 603
 604   if (vp9_realloc_frame_buffer(&cpi->scaled_source,
 605                                cm->width, cm->height,
 606                                cm->subsampling_x, cm->subsampling_y,
 607                                VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL))
 608     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 609                        "Failed to reallocate scaled source buffer");
 610
 611   if (vp9_realloc_frame_buffer(&cpi->scaled_last_source,
 612                                cm->width, cm->height,
 613                                cm->subsampling_x, cm->subsampling_y,
 614                                VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL))
 615     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 616                        "Failed to reallocate scaled last source buffer");
 617
 618   {
 619     int y_stride = cpi->scaled_source.y_stride;
 620
 621     if (cpi->sf.search_method == NSTEP) {
 622       vp9_init3smotion_compensation(&cpi->mb, y_stride);
 623     } else if (cpi->sf.search_method == DIAMOND) {
 624       vp9_init_dsmotion_compensation(&cpi->mb, y_stride);
 625     }
 626   }
 627
 628   init_macroblockd(cm, xd);
 629 }
 630
 631 void vp9_new_framerate(VP9_COMP *cpi, double framerate) {
 632   VP9_COMMON *const cm = &cpi->common;
 633   RATE_CONTROL *const rc = &cpi->rc;
 634   VP9_CONFIG *const oxcf = &cpi->oxcf;
 635   int vbr_max_bits;
 636
 637   oxcf->framerate = framerate < 0.1 ? 30 : framerate;
 638   rc->av_per_frame_bandwidth = (int)(oxcf->target_bandwidth /
 639                                    oxcf->framerate);
 640   rc->min_frame_bandwidth = (int)(rc->av_per_frame_bandwidth *
 641                                   oxcf->two_pass_vbrmin_section / 100);
 642
 643   rc->min_frame_bandwidth = MAX(rc->min_frame_bandwidth, FRAME_OVERHEAD_BITS);
 644
 645   // A maximum bitrate for a frame is defined.
 646   // The baseline for this aligns with HW implementations that
 647   // can support decode of 1080P content up to a bitrate of MAX_MB_RATE bits
 648   // per 16x16 MB (averaged over a frame). However this limit is extended if
 649   // a very high rate is given on the command line or the the rate cannnot
 650   // be acheived because of a user specificed max q (e.g. when the user
 651   // specifies lossless encode.
 652   //
 653   vbr_max_bits = (int)(((int64_t)rc->av_per_frame_bandwidth *
 654       oxcf->two_pass_vbrmax_section) / 100);
 655   rc->max_frame_bandwidth = MAX(MAX((cm->MBs * MAX_MB_RATE), MAXRATE_1080P),
 656                                 vbr_max_bits);
 657
 658   // Set Maximum gf/arf interval
 659   rc->max_gf_interval = 16;
 660
 661   // Extended interval for genuinely static scenes
 662   rc->static_scene_max_gf_interval = cpi->key_frame_frequency >> 1;
 663
 664   // Special conditions when alt ref frame enabled in lagged compress mode
 665   if (oxcf->play_alternate && oxcf->lag_in_frames) {
 666     if (rc->max_gf_interval > oxcf->lag_in_frames - 1)
 667       rc->max_gf_interval = oxcf->lag_in_frames - 1;
 668
 669     if (rc->static_scene_max_gf_interval > oxcf->lag_in_frames - 1)
 670       rc->static_scene_max_gf_interval = oxcf->lag_in_frames - 1;
 671   }
 672
 673   if (rc->max_gf_interval > rc->static_scene_max_gf_interval)
 674     rc->max_gf_interval = rc->static_scene_max_gf_interval;
 675 }
 676
 677 int64_t vp9_rescale(int64_t val, int64_t num, int denom) {
 678   int64_t llnum = num;
 679   int64_t llden = denom;
 680   int64_t llval = val;
 681
 682   return (llval * llnum / llden);
 683 }
 684
 685 static void set_tile_limits(VP9_COMP *cpi) {
 686   VP9_COMMON *const cm = &cpi->common;
 687
 688   int min_log2_tile_cols, max_log2_tile_cols;
 689   vp9_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
 690
 691   cm->log2_tile_cols = clamp(cpi->oxcf.tile_columns,
 692                              min_log2_tile_cols, max_log2_tile_cols);
 693   cm->log2_tile_rows = cpi->oxcf.tile_rows;
 694 }
 695
 696 static void init_config(struct VP9_COMP *cpi, VP9_CONFIG *oxcf) {
 697   VP9_COMMON *const cm = &cpi->common;
 698   int i;
 699
 700   cpi->oxcf = *oxcf;
 701
 702   cm->profile = oxcf->profile;
 703   cm->bit_depth = oxcf->bit_depth;
 704
 705   cm->width = oxcf->width;
 706   cm->height = oxcf->height;
 707   cm->subsampling_x = 0;
 708   cm->subsampling_y = 0;
 709   vp9_alloc_compressor_data(cpi);
 710
 711   // Spatial scalability.
 712   cpi->svc.number_spatial_layers = oxcf->ss_number_layers;
 713   // Temporal scalability.
 714   cpi->svc.number_temporal_layers = oxcf->ts_number_layers;
 715
 716   if ((cpi->svc.number_temporal_layers > 1 &&
 717       cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) ||
 718       (cpi->svc.number_spatial_layers > 1 &&
 719       cpi->oxcf.mode == MODE_SECONDPASS_BEST)) {
 720     vp9_init_layer_context(cpi);
 721   }
 722
 723   // change includes all joint functionality
 724   vp9_change_config(cpi, oxcf);
 725
 726   cpi->static_mb_pct = 0;
 727
 728   cpi->lst_fb_idx = 0;
 729   cpi->gld_fb_idx = 1;
 730   cpi->alt_fb_idx = 2;
 731
 732   set_tile_limits(cpi);
 733
 734   cpi->fixed_divide[0] = 0;
 735   for (i = 1; i < 512; i++)
 736     cpi->fixed_divide[i] = 0x80000 / i;
 737 }
 738
 739 void vp9_change_config(struct VP9_COMP *cpi, const VP9_CONFIG *oxcf) {
 740   VP9_COMMON *const cm = &cpi->common;
 741   RATE_CONTROL *const rc = &cpi->rc;
 742
 743   if (cm->profile != oxcf->profile)
 744     cm->profile = oxcf->profile;
 745   cm->bit_depth = oxcf->bit_depth;
 746
 747   if (cm->profile <= PROFILE_1)
 748     assert(cm->bit_depth == BITS_8);
 749   else
 750     assert(cm->bit_depth > BITS_8);
 751
 752   cpi->oxcf = *oxcf;
 753
 754   if (cpi->oxcf.cpu_used == -6)
 755     cpi->oxcf.play_alternate = 0;
 756
 757   switch (cpi->oxcf.mode) {
 758       // Real time and one pass deprecated in test code base
 759     case MODE_GOODQUALITY:
 760       cpi->pass = 0;
 761       cpi->oxcf.cpu_used = clamp(cpi->oxcf.cpu_used, -5, 5);
 762       break;
 763
 764     case MODE_BESTQUALITY:
 765       cpi->pass = 0;
 766       break;
 767
 768     case MODE_FIRSTPASS:
 769       cpi->pass = 1;
 770       break;
 771
 772     case MODE_SECONDPASS:
 773       cpi->pass = 2;
 774       cpi->oxcf.cpu_used = clamp(cpi->oxcf.cpu_used, -5, 5);
 775       break;
 776
 777     case MODE_SECONDPASS_BEST:
 778       cpi->pass = 2;
 779       break;
 780
 781     case MODE_REALTIME:
 782       cpi->pass = 0;
 783       break;
 784   }
 785
 786   cpi->oxcf.lossless = oxcf->lossless;
 787   if (cpi->oxcf.lossless) {
 788     // In lossless mode, make sure right quantizer range and correct transform
 789     // is set.
 790     cpi->oxcf.worst_allowed_q = 0;
 791     cpi->oxcf.best_allowed_q = 0;
 792     cpi->mb.e_mbd.itxm_add = vp9_iwht4x4_add;
 793   } else {
 794     cpi->mb.e_mbd.itxm_add = vp9_idct4x4_add;
 795   }
 796   rc->baseline_gf_interval = DEFAULT_GF_INTERVAL;
 797   cpi->ref_frame_flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
 798
 799   cpi->refresh_golden_frame = 0;
 800   cpi->refresh_last_frame = 1;
 801   cm->refresh_frame_context = 1;
 802   cm->reset_frame_context = 0;
 803
 804   vp9_reset_segment_features(&cm->seg);
 805   set_high_precision_mv(cpi, 0);
 806
 807   {
 808     int i;
 809
 810     for (i = 0; i < MAX_SEGMENTS; i++)
 811       cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
 812   }
 813   cpi->encode_breakout = cpi->oxcf.encode_breakout;
 814
 815   // local file playback mode == really big buffer
 816   if (cpi->oxcf.end_usage == USAGE_LOCAL_FILE_PLAYBACK) {
 817     cpi->oxcf.starting_buffer_level   = 60000;
 818     cpi->oxcf.optimal_buffer_level    = 60000;
 819     cpi->oxcf.maximum_buffer_size     = 240000;
 820   }
 821
 822   // Convert target bandwidth from Kbit/s to Bit/s
 823   cpi->oxcf.target_bandwidth       *= 1000;
 824
 825   cpi->oxcf.starting_buffer_level =
 826       vp9_rescale(cpi->oxcf.starting_buffer_level,
 827                   cpi->oxcf.target_bandwidth, 1000);
 828
 829   // Set or reset optimal and maximum buffer levels.
 830   if (cpi->oxcf.optimal_buffer_level == 0)
 831     cpi->oxcf.optimal_buffer_level = cpi->oxcf.target_bandwidth / 8;
 832   else
 833     cpi->oxcf.optimal_buffer_level =
 834         vp9_rescale(cpi->oxcf.optimal_buffer_level,
 835                     cpi->oxcf.target_bandwidth, 1000);
 836
 837   if (cpi->oxcf.maximum_buffer_size == 0)
 838     cpi->oxcf.maximum_buffer_size = cpi->oxcf.target_bandwidth / 8;
 839   else
 840     cpi->oxcf.maximum_buffer_size =
 841         vp9_rescale(cpi->oxcf.maximum_buffer_size,
 842                     cpi->oxcf.target_bandwidth, 1000);
 843   // Under a configuration change, where maximum_buffer_size may change,
 844   // keep buffer level clipped to the maximum allowed buffer size.
 845   rc->bits_off_target = MIN(rc->bits_off_target, cpi->oxcf.maximum_buffer_size);
 846   rc->buffer_level = MIN(rc->buffer_level, cpi->oxcf.maximum_buffer_size);
 847
 848   // Set up frame rate and related parameters rate control values.
 849   vp9_new_framerate(cpi, cpi->oxcf.framerate);
 850
 851   // Set absolute upper and lower quality limits
 852   rc->worst_quality = cpi->oxcf.worst_allowed_q;
 853   rc->best_quality = cpi->oxcf.best_allowed_q;
 854
 855   // active values should only be modified if out of new range
 856
 857   cpi->cq_target_quality = cpi->oxcf.cq_level;
 858
 859   cm->interp_filter = DEFAULT_INTERP_FILTER;
 860
 861   cm->display_width = cpi->oxcf.width;
 862   cm->display_height = cpi->oxcf.height;
 863
 864   // VP8 sharpness level mapping 0-7 (vs 0-10 in general VPx dialogs)
 865   cpi->oxcf.sharpness = MIN(7, cpi->oxcf.sharpness);
 866
 867   cpi->common.lf.sharpness_level = cpi->oxcf.sharpness;
 868
 869   if (cpi->initial_width) {
 870     // Increasing the size of the frame beyond the first seen frame, or some
 871     // otherwise signaled maximum size, is not supported.
 872     // TODO(jkoleszar): exit gracefully.
 873     assert(cm->width <= cpi->initial_width);
 874     assert(cm->height <= cpi->initial_height);
 875   }
 876   update_frame_size(cpi);
 877
 878   if ((cpi->svc.number_temporal_layers > 1 &&
 879       cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) ||
 880       (cpi->svc.number_spatial_layers > 1 && cpi->pass == 2)) {
 881     vp9_update_layer_context_change_config(cpi,
 882                                            (int)cpi->oxcf.target_bandwidth);
 883   }
 884
 885   cpi->speed = abs(cpi->oxcf.cpu_used);
 886
 887   // Limit on lag buffers as these are not currently dynamically allocated.
 888   if (cpi->oxcf.lag_in_frames > MAX_LAG_BUFFERS)
 889     cpi->oxcf.lag_in_frames = MAX_LAG_BUFFERS;
 890
 891 #if CONFIG_MULTIPLE_ARF
 892   vp9_zero(cpi->alt_ref_source);
 893 #else
 894   cpi->alt_ref_source = NULL;
 895 #endif
 896   rc->is_src_frame_alt_ref = 0;
 897
 898 #if 0
 899   // Experimental RD Code
 900   cpi->frame_distortion = 0;
 901   cpi->last_frame_distortion = 0;
 902 #endif
 903
 904   set_tile_limits(cpi);
 905
 906   cpi->ext_refresh_frame_flags_pending = 0;
 907   cpi->ext_refresh_frame_context_pending = 0;
 908 }
 909
 910 #ifndef M_LOG2_E
 911 #define M_LOG2_E 0.693147180559945309417
 912 #endif
 913 #define log2f(x) (log (x) / (float) M_LOG2_E)
 914
 915 static void cal_nmvjointsadcost(int *mvjointsadcost) {
 916   mvjointsadcost[0] = 600;
 917   mvjointsadcost[1] = 300;
 918   mvjointsadcost[2] = 300;
 919   mvjointsadcost[3] = 300;
 920 }
 921
 922 static void cal_nmvsadcosts(int *mvsadcost[2]) {
 923   int i = 1;
 924
 925   mvsadcost[0][0] = 0;
 926   mvsadcost[1][0] = 0;
 927
 928   do {
 929     double z = 256 * (2 * (log2f(8 * i) + .6));
 930     mvsadcost[0][i] = (int)z;
 931     mvsadcost[1][i] = (int)z;
 932     mvsadcost[0][-i] = (int)z;
 933     mvsadcost[1][-i] = (int)z;
 934   } while (++i <= MV_MAX);
 935 }
 936
 937 static void cal_nmvsadcosts_hp(int *mvsadcost[2]) {
 938   int i = 1;
 939
 940   mvsadcost[0][0] = 0;
 941   mvsadcost[1][0] = 0;
 942
 943   do {
 944     double z = 256 * (2 * (log2f(8 * i) + .6));
 945     mvsadcost[0][i] = (int)z;
 946     mvsadcost[1][i] = (int)z;
 947     mvsadcost[0][-i] = (int)z;
 948     mvsadcost[1][-i] = (int)z;
 949   } while (++i <= MV_MAX);
 950 }
 951
 952 static void alloc_mode_context(VP9_COMMON *cm, int num_4x4_blk,
 953                                PICK_MODE_CONTEXT *ctx) {
 954   int num_pix = num_4x4_blk << 4;
 955   int i, k;
 956   ctx->num_4x4_blk = num_4x4_blk;
 957
 958   CHECK_MEM_ERROR(cm, ctx->zcoeff_blk,
 959                   vpx_calloc(num_4x4_blk, sizeof(uint8_t)));
 960   for (i = 0; i < MAX_MB_PLANE; ++i) {
 961     for (k = 0; k < 3; ++k) {
 962       CHECK_MEM_ERROR(cm, ctx->coeff[i][k],
 963                       vpx_memalign(16, num_pix * sizeof(int16_t)));
 964       CHECK_MEM_ERROR(cm, ctx->qcoeff[i][k],
 965                       vpx_memalign(16, num_pix * sizeof(int16_t)));
 966       CHECK_MEM_ERROR(cm, ctx->dqcoeff[i][k],
 967                       vpx_memalign(16, num_pix * sizeof(int16_t)));
 968       CHECK_MEM_ERROR(cm, ctx->eobs[i][k],
 969                       vpx_memalign(16, num_pix * sizeof(uint16_t)));
 970       ctx->coeff_pbuf[i][k]   = ctx->coeff[i][k];
 971       ctx->qcoeff_pbuf[i][k]  = ctx->qcoeff[i][k];
 972       ctx->dqcoeff_pbuf[i][k] = ctx->dqcoeff[i][k];
 973       ctx->eobs_pbuf[i][k]    = ctx->eobs[i][k];
 974     }
 975   }
 976 }
 977
 978 static void free_mode_context(PICK_MODE_CONTEXT *ctx) {
 979   int i, k;
 980   vpx_free(ctx->zcoeff_blk);
 981   ctx->zcoeff_blk = 0;
 982   for (i = 0; i < MAX_MB_PLANE; ++i) {
 983     for (k = 0; k < 3; ++k) {
 984       vpx_free(ctx->coeff[i][k]);
 985       ctx->coeff[i][k] = 0;
 986       vpx_free(ctx->qcoeff[i][k]);
 987       ctx->qcoeff[i][k] = 0;
 988       vpx_free(ctx->dqcoeff[i][k]);
 989       ctx->dqcoeff[i][k] = 0;
 990       vpx_free(ctx->eobs[i][k]);
 991       ctx->eobs[i][k] = 0;
 992     }
 993   }
 994 }
 995
 996 static void init_pick_mode_context(VP9_COMP *cpi) {
 997   int i;
 998   VP9_COMMON *const cm = &cpi->common;
 999   MACROBLOCK *const x  = &cpi->mb;
1000
1001   for (i = 0; i < BLOCK_SIZES; ++i) {
1002     const int num_4x4_w = num_4x4_blocks_wide_lookup[i];
1003     const int num_4x4_h = num_4x4_blocks_high_lookup[i];
1004     const int num_4x4_blk = MAX(4, num_4x4_w * num_4x4_h);
1005     if (i < BLOCK_16X16) {
1006       for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1007         for (x->mb_index = 0; x->mb_index < 4; ++x->mb_index) {
1008           for (x->b_index = 0; x->b_index < 16 / num_4x4_blk; ++x->b_index) {
1009             PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1010             alloc_mode_context(cm, num_4x4_blk, ctx);
1011           }
1012         }
1013       }
1014     } else if (i < BLOCK_32X32) {
1015       for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1016         for (x->mb_index = 0; x->mb_index < 64 / num_4x4_blk; ++x->mb_index) {
1017           PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1018           ctx->num_4x4_blk = num_4x4_blk;
1019           alloc_mode_context(cm, num_4x4_blk, ctx);
1020         }
1021       }
1022     } else if (i < BLOCK_64X64) {
1023       for (x->sb_index = 0; x->sb_index < 256 / num_4x4_blk; ++x->sb_index) {
1024         PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1025         ctx->num_4x4_blk = num_4x4_blk;
1026         alloc_mode_context(cm, num_4x4_blk, ctx);
1027       }
1028     } else {
1029       PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1030       ctx->num_4x4_blk = num_4x4_blk;
1031       alloc_mode_context(cm, num_4x4_blk, ctx);
1032     }
1033   }
1034 }
1035
1036 static void free_pick_mode_context(MACROBLOCK *x) {
1037   int i;
1038
1039   for (i = 0; i < BLOCK_SIZES; ++i) {
1040     const int num_4x4_w = num_4x4_blocks_wide_lookup[i];
1041     const int num_4x4_h = num_4x4_blocks_high_lookup[i];
1042     const int num_4x4_blk = MAX(4, num_4x4_w * num_4x4_h);
1043     if (i < BLOCK_16X16) {
1044       for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1045         for (x->mb_index = 0; x->mb_index < 4; ++x->mb_index) {
1046           for (x->b_index = 0; x->b_index < 16 / num_4x4_blk; ++x->b_index) {
1047             PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1048             free_mode_context(ctx);
1049           }
1050         }
1051       }
1052     } else if (i < BLOCK_32X32) {
1053       for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1054         for (x->mb_index = 0; x->mb_index < 64 / num_4x4_blk; ++x->mb_index) {
1055           PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1056           free_mode_context(ctx);
1057         }
1058       }
1059     } else if (i < BLOCK_64X64) {
1060       for (x->sb_index = 0; x->sb_index < 256 / num_4x4_blk; ++x->sb_index) {
1061         PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1062         free_mode_context(ctx);
1063       }
1064     } else {
1065       PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1066       free_mode_context(ctx);
1067     }
1068   }
1069 }
1070
1071 VP9_COMP *vp9_create_compressor(VP9_CONFIG *oxcf) {
1072   int i, j;
1073   VP9_COMP *const cpi = vpx_memalign(32, sizeof(VP9_COMP));
1074   VP9_COMMON *const cm = cpi != NULL ? &cpi->common : NULL;
1075
1076   if (!cm)
1077     return NULL;
1078
1079   vp9_zero(*cpi);
1080
1081   if (setjmp(cm->error.jmp)) {
1082     cm->error.setjmp = 0;
1083     vp9_remove_compressor(cpi);
1084     return 0;
1085   }
1086
1087   cm->error.setjmp = 1;
1088
1089   CHECK_MEM_ERROR(cm, cpi->mb.ss, vpx_calloc(sizeof(search_site),
1090                                              (MAX_MVSEARCH_STEPS * 8) + 1));
1091
1092   vp9_rtcd();
1093
1094   cpi->use_svc = 0;
1095
1096   init_config(cpi, oxcf);
1097   vp9_rc_init(&cpi->oxcf, cpi->pass, &cpi->rc);
1098   init_pick_mode_context(cpi);
1099
1100   cm->current_video_frame = 0;
1101
1102   // Set reference frame sign bias for ALTREF frame to 1 (for now)
1103   cm->ref_frame_sign_bias[ALTREF_FRAME] = 1;
1104
1105   cpi->gold_is_last = 0;
1106   cpi->alt_is_last = 0;
1107   cpi->gold_is_alt = 0;
1108
1109   // Create the encoder segmentation map and set all entries to 0
1110   CHECK_MEM_ERROR(cm, cpi->segmentation_map,
1111                   vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1112
1113   // Create a complexity map used for rd adjustment
1114   CHECK_MEM_ERROR(cm, cpi->complexity_map,
1115                   vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1116
1117   // Create a map used for cyclic background refresh.
1118   CHECK_MEM_ERROR(cm, cpi->cyclic_refresh,
1119                   vp9_cyclic_refresh_alloc(cm->mi_rows, cm->mi_cols));
1120
1121   // And a place holder structure is the coding context
1122   // for use if we want to save and restore it
1123   CHECK_MEM_ERROR(cm, cpi->coding_context.last_frame_seg_map_copy,
1124                   vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1125
1126   CHECK_MEM_ERROR(cm, cpi->active_map, vpx_calloc(cm->MBs, 1));
1127   vpx_memset(cpi->active_map, 1, cm->MBs);
1128   cpi->active_map_enabled = 0;
1129
1130   for (i = 0; i < (sizeof(cpi->mbgraph_stats) /
1131                    sizeof(cpi->mbgraph_stats[0])); i++) {
1132     CHECK_MEM_ERROR(cm, cpi->mbgraph_stats[i].mb_stats,
1133                     vpx_calloc(cm->MBs *
1134                                sizeof(*cpi->mbgraph_stats[i].mb_stats), 1));
1135   }
1136
1137   /*Initialize the feed-forward activity masking.*/
1138   cpi->activity_avg = 90 << 12;
1139   cpi->key_frame_frequency = cpi->oxcf.key_freq;
1140   cpi->refresh_alt_ref_frame = 0;
1141
1142 #if CONFIG_MULTIPLE_ARF
1143   // Turn multiple ARF usage on/off. This is a quick hack for the initial test
1144   // version. It should eventually be set via the codec API.
1145   cpi->multi_arf_enabled = 1;
1146
1147   if (cpi->multi_arf_enabled) {
1148     cpi->sequence_number = 0;
1149     cpi->frame_coding_order_period = 0;
1150     vp9_zero(cpi->frame_coding_order);
1151     vp9_zero(cpi->arf_buffer_idx);
1152   }
1153 #endif
1154
1155   cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
1156 #if CONFIG_INTERNAL_STATS
1157   cpi->b_calculate_ssimg = 0;
1158
1159   cpi->count = 0;
1160   cpi->bytes = 0;
1161
1162   if (cpi->b_calculate_psnr) {
1163     cpi->total_y = 0.0;
1164     cpi->total_u = 0.0;
1165     cpi->total_v = 0.0;
1166     cpi->total = 0.0;
1167     cpi->total_sq_error = 0;
1168     cpi->total_samples = 0;
1169
1170     cpi->totalp_y = 0.0;
1171     cpi->totalp_u = 0.0;
1172     cpi->totalp_v = 0.0;
1173     cpi->totalp = 0.0;
1174     cpi->totalp_sq_error = 0;
1175     cpi->totalp_samples = 0;
1176
1177     cpi->tot_recode_hits = 0;
1178     cpi->summed_quality = 0;
1179     cpi->summed_weights = 0;
1180     cpi->summedp_quality = 0;
1181     cpi->summedp_weights = 0;
1182   }
1183
1184   if (cpi->b_calculate_ssimg) {
1185     cpi->total_ssimg_y = 0;
1186     cpi->total_ssimg_u = 0;
1187     cpi->total_ssimg_v = 0;
1188     cpi->total_ssimg_all = 0;
1189   }
1190
1191 #endif
1192
1193   cpi->first_time_stamp_ever = INT64_MAX;
1194
1195   cal_nmvjointsadcost(cpi->mb.nmvjointsadcost);
1196   cpi->mb.nmvcost[0] = &cpi->mb.nmvcosts[0][MV_MAX];
1197   cpi->mb.nmvcost[1] = &cpi->mb.nmvcosts[1][MV_MAX];
1198   cpi->mb.nmvsadcost[0] = &cpi->mb.nmvsadcosts[0][MV_MAX];
1199   cpi->mb.nmvsadcost[1] = &cpi->mb.nmvsadcosts[1][MV_MAX];
1200   cal_nmvsadcosts(cpi->mb.nmvsadcost);
1201
1202   cpi->mb.nmvcost_hp[0] = &cpi->mb.nmvcosts_hp[0][MV_MAX];
1203   cpi->mb.nmvcost_hp[1] = &cpi->mb.nmvcosts_hp[1][MV_MAX];
1204   cpi->mb.nmvsadcost_hp[0] = &cpi->mb.nmvsadcosts_hp[0][MV_MAX];
1205   cpi->mb.nmvsadcost_hp[1] = &cpi->mb.nmvsadcosts_hp[1][MV_MAX];
1206   cal_nmvsadcosts_hp(cpi->mb.nmvsadcost_hp);
1207
1208 #ifdef OUTPUT_YUV_SRC
1209   yuv_file = fopen("bd.yuv", "ab");
1210 #endif
1211 #ifdef OUTPUT_YUV_REC
1212   yuv_rec_file = fopen("rec.yuv", "wb");
1213 #endif
1214
1215 #if 0
1216   framepsnr = fopen("framepsnr.stt", "a");
1217   kf_list = fopen("kf_list.stt", "w");
1218 #endif
1219
1220   cpi->output_pkt_list = oxcf->output_pkt_list;
1221
1222   cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
1223
1224   if (cpi->pass == 1) {
1225     vp9_init_first_pass(cpi);
1226   } else if (cpi->pass == 2) {
1227     const size_t packet_sz = sizeof(FIRSTPASS_STATS);
1228     const int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz);
1229
1230     if (cpi->svc.number_spatial_layers > 1
1231         && cpi->svc.number_temporal_layers == 1) {
1232       FIRSTPASS_STATS *const stats = oxcf->two_pass_stats_in.buf;
1233       FIRSTPASS_STATS *stats_copy[VPX_SS_MAX_LAYERS] = {0};
1234       int i;
1235
1236       for (i = 0; i < oxcf->ss_number_layers; ++i) {
1237         FIRSTPASS_STATS *const last_packet_for_layer =
1238             &stats[packets - oxcf->ss_number_layers + i];
1239         const int layer_id = (int)last_packet_for_layer->spatial_layer_id;
1240         const int packets_in_layer = (int)last_packet_for_layer->count + 1;
1241         if (layer_id >= 0 && layer_id < oxcf->ss_number_layers) {
1242           LAYER_CONTEXT *const lc = &cpi->svc.layer_context[layer_id];
1243
1244           vpx_free(lc->rc_twopass_stats_in.buf);
1245
1246           lc->rc_twopass_stats_in.sz = packets_in_layer * packet_sz;
1247           CHECK_MEM_ERROR(cm, lc->rc_twopass_stats_in.buf,
1248                           vpx_malloc(lc->rc_twopass_stats_in.sz));
1249           lc->twopass.stats_in_start = lc->rc_twopass_stats_in.buf;
1250           lc->twopass.stats_in = lc->twopass.stats_in_start;
1251           lc->twopass.stats_in_end = lc->twopass.stats_in_start
1252                                      + packets_in_layer - 1;
1253           stats_copy[layer_id] = lc->rc_twopass_stats_in.buf;
1254         }
1255       }
1256
1257       for (i = 0; i < packets; ++i) {
1258         const int layer_id = (int)stats[i].spatial_layer_id;
1259         if (layer_id >= 0 && layer_id < oxcf->ss_number_layers
1260             && stats_copy[layer_id] != NULL) {
1261           *stats_copy[layer_id] = stats[i];
1262           ++stats_copy[layer_id];
1263         }
1264       }
1265
1266       vp9_init_second_pass_spatial_svc(cpi);
1267     } else {
1268       cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf;
1269       cpi->twopass.stats_in = cpi->twopass.stats_in_start;
1270       cpi->twopass.stats_in_end = &cpi->twopass.stats_in[packets - 1];
1271
1272       vp9_init_second_pass(cpi);
1273     }
1274   }
1275
1276   set_speed_features(cpi);
1277
1278   // Default rd threshold factors for mode selection
1279   for (i = 0; i < BLOCK_SIZES; ++i) {
1280     for (j = 0; j < MAX_MODES; ++j)
1281       cpi->rd.thresh_freq_fact[i][j] = 32;
1282     for (j = 0; j < MAX_REFS; ++j)
1283       cpi->rd.thresh_freq_sub8x8[i][j] = 32;
1284   }
1285
1286 #define BFP(BT, SDF, SDAF, VF, SVF, SVAF, SVFHH, SVFHV, SVFHHV, \
1287             SDX3F, SDX8F, SDX4DF)\
1288     cpi->fn_ptr[BT].sdf            = SDF; \
1289     cpi->fn_ptr[BT].sdaf           = SDAF; \
1290     cpi->fn_ptr[BT].vf             = VF; \
1291     cpi->fn_ptr[BT].svf            = SVF; \
1292     cpi->fn_ptr[BT].svaf           = SVAF; \
1293     cpi->fn_ptr[BT].svf_halfpix_h  = SVFHH; \
1294     cpi->fn_ptr[BT].svf_halfpix_v  = SVFHV; \
1295     cpi->fn_ptr[BT].svf_halfpix_hv = SVFHHV; \
1296     cpi->fn_ptr[BT].sdx3f          = SDX3F; \
1297     cpi->fn_ptr[BT].sdx8f          = SDX8F; \
1298     cpi->fn_ptr[BT].sdx4df         = SDX4DF;
1299
1300   BFP(BLOCK_32X16, vp9_sad32x16, vp9_sad32x16_avg,
1301       vp9_variance32x16, vp9_sub_pixel_variance32x16,
1302       vp9_sub_pixel_avg_variance32x16, NULL, NULL,
1303       NULL, NULL, NULL,
1304       vp9_sad32x16x4d)
1305
1306   BFP(BLOCK_16X32, vp9_sad16x32, vp9_sad16x32_avg,
1307       vp9_variance16x32, vp9_sub_pixel_variance16x32,
1308       vp9_sub_pixel_avg_variance16x32, NULL, NULL,
1309       NULL, NULL, NULL,
1310       vp9_sad16x32x4d)
1311
1312   BFP(BLOCK_64X32, vp9_sad64x32, vp9_sad64x32_avg,
1313       vp9_variance64x32, vp9_sub_pixel_variance64x32,
1314       vp9_sub_pixel_avg_variance64x32, NULL, NULL,
1315       NULL, NULL, NULL,
1316       vp9_sad64x32x4d)
1317
1318   BFP(BLOCK_32X64, vp9_sad32x64, vp9_sad32x64_avg,
1319       vp9_variance32x64, vp9_sub_pixel_variance32x64,
1320       vp9_sub_pixel_avg_variance32x64, NULL, NULL,
1321       NULL, NULL, NULL,
1322       vp9_sad32x64x4d)
1323
1324   BFP(BLOCK_32X32, vp9_sad32x32, vp9_sad32x32_avg,
1325       vp9_variance32x32, vp9_sub_pixel_variance32x32,
1326       vp9_sub_pixel_avg_variance32x32, vp9_variance_halfpixvar32x32_h,
1327       vp9_variance_halfpixvar32x32_v,
1328       vp9_variance_halfpixvar32x32_hv, vp9_sad32x32x3, vp9_sad32x32x8,
1329       vp9_sad32x32x4d)
1330
1331   BFP(BLOCK_64X64, vp9_sad64x64, vp9_sad64x64_avg,
1332       vp9_variance64x64, vp9_sub_pixel_variance64x64,
1333       vp9_sub_pixel_avg_variance64x64, vp9_variance_halfpixvar64x64_h,
1334       vp9_variance_halfpixvar64x64_v,
1335       vp9_variance_halfpixvar64x64_hv, vp9_sad64x64x3, vp9_sad64x64x8,
1336       vp9_sad64x64x4d)
1337
1338   BFP(BLOCK_16X16, vp9_sad16x16, vp9_sad16x16_avg,
1339       vp9_variance16x16, vp9_sub_pixel_variance16x16,
1340       vp9_sub_pixel_avg_variance16x16, vp9_variance_halfpixvar16x16_h,
1341       vp9_variance_halfpixvar16x16_v,
1342       vp9_variance_halfpixvar16x16_hv, vp9_sad16x16x3, vp9_sad16x16x8,
1343       vp9_sad16x16x4d)
1344
1345   BFP(BLOCK_16X8, vp9_sad16x8, vp9_sad16x8_avg,
1346       vp9_variance16x8, vp9_sub_pixel_variance16x8,
1347       vp9_sub_pixel_avg_variance16x8, NULL, NULL, NULL,
1348       vp9_sad16x8x3, vp9_sad16x8x8, vp9_sad16x8x4d)
1349
1350   BFP(BLOCK_8X16, vp9_sad8x16, vp9_sad8x16_avg,
1351       vp9_variance8x16, vp9_sub_pixel_variance8x16,
1352       vp9_sub_pixel_avg_variance8x16, NULL, NULL, NULL,
1353       vp9_sad8x16x3, vp9_sad8x16x8, vp9_sad8x16x4d)
1354
1355   BFP(BLOCK_8X8, vp9_sad8x8, vp9_sad8x8_avg,
1356       vp9_variance8x8, vp9_sub_pixel_variance8x8,
1357       vp9_sub_pixel_avg_variance8x8, NULL, NULL, NULL,
1358       vp9_sad8x8x3, vp9_sad8x8x8, vp9_sad8x8x4d)
1359
1360   BFP(BLOCK_8X4, vp9_sad8x4, vp9_sad8x4_avg,
1361       vp9_variance8x4, vp9_sub_pixel_variance8x4,
1362       vp9_sub_pixel_avg_variance8x4, NULL, NULL,
1363       NULL, NULL, vp9_sad8x4x8,
1364       vp9_sad8x4x4d)
1365
1366   BFP(BLOCK_4X8, vp9_sad4x8, vp9_sad4x8_avg,
1367       vp9_variance4x8, vp9_sub_pixel_variance4x8,
1368       vp9_sub_pixel_avg_variance4x8, NULL, NULL,
1369       NULL, NULL, vp9_sad4x8x8,
1370       vp9_sad4x8x4d)
1371
1372   BFP(BLOCK_4X4, vp9_sad4x4, vp9_sad4x4_avg,
1373       vp9_variance4x4, vp9_sub_pixel_variance4x4,
1374       vp9_sub_pixel_avg_variance4x4, NULL, NULL, NULL,
1375       vp9_sad4x4x3, vp9_sad4x4x8, vp9_sad4x4x4d)
1376
1377   cpi->full_search_sad = vp9_full_search_sad;
1378   cpi->diamond_search_sad = vp9_diamond_search_sad;
1379   cpi->refining_search_sad = vp9_refining_search_sad;
1380
1381   /* vp9_init_quantizer() is first called here. Add check in
1382    * vp9_frame_init_quantizer() so that vp9_init_quantizer is only
1383    * called later when needed. This will avoid unnecessary calls of
1384    * vp9_init_quantizer() for every frame.
1385    */
1386   vp9_init_quantizer(cpi);
1387
1388   vp9_loop_filter_init(cm);
1389
1390   cm->error.setjmp = 0;
1391
1392 #ifdef MODE_TEST_HIT_STATS
1393   vp9_zero(cpi->mode_test_hits);
1394 #endif
1395
1396   return cpi;
1397 }
1398
1399 void vp9_remove_compressor(VP9_COMP *cpi) {
1400   int i;
1401
1402   if (!cpi)
1403     return;
1404
1405   if (cpi && (cpi->common.current_video_frame > 0)) {
1406 #if CONFIG_INTERNAL_STATS
1407
1408     vp9_clear_system_state();
1409
1410     // printf("\n8x8-4x4:%d-%d\n", cpi->t8x8_count, cpi->t4x4_count);
1411     if (cpi->pass != 1) {
1412       FILE *f = fopen("opsnr.stt", "a");
1413       double time_encoded = (cpi->last_end_time_stamp_seen
1414                              - cpi->first_time_stamp_ever) / 10000000.000;
1415       double total_encode_time = (cpi->time_receive_data +
1416                                   cpi->time_compress_data)   / 1000.000;
1417       double dr = (double)cpi->bytes * (double) 8 / (double)1000
1418                   / time_encoded;
1419
1420       if (cpi->b_calculate_psnr) {
1421         const double total_psnr =
1422             vpx_sse_to_psnr((double)cpi->total_samples, 255.0,
1423                             (double)cpi->total_sq_error);
1424         const double totalp_psnr =
1425             vpx_sse_to_psnr((double)cpi->totalp_samples, 255.0,
1426                             (double)cpi->totalp_sq_error);
1427         const double total_ssim = 100 * pow(cpi->summed_quality /
1428                                                 cpi->summed_weights, 8.0);
1429         const double totalp_ssim = 100 * pow(cpi->summedp_quality /
1430                                                 cpi->summedp_weights, 8.0);
1431
1432         fprintf(f, "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\t"
1433                 "VPXSSIM\tVPSSIMP\t  Time(ms)\n");
1434         fprintf(f, "%7.2f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%8.0f\n",
1435                 dr, cpi->total / cpi->count, total_psnr,
1436                 cpi->totalp / cpi->count, totalp_psnr, total_ssim, totalp_ssim,
1437                 total_encode_time);
1438       }
1439
1440       if (cpi->b_calculate_ssimg) {
1441         fprintf(f, "BitRate\tSSIM_Y\tSSIM_U\tSSIM_V\tSSIM_A\t  Time(ms)\n");
1442         fprintf(f, "%7.2f\t%6.4f\t%6.4f\t%6.4f\t%6.4f\t%8.0f\n", dr,
1443                 cpi->total_ssimg_y / cpi->count,
1444                 cpi->total_ssimg_u / cpi->count,
1445                 cpi->total_ssimg_v / cpi->count,
1446                 cpi->total_ssimg_all / cpi->count, total_encode_time);
1447       }
1448
1449       fclose(f);
1450     }
1451
1452 #endif
1453
1454 #ifdef MODE_TEST_HIT_STATS
1455     if (cpi->pass != 1) {
1456       double norm_per_pixel_mode_tests = 0;
1457       double norm_counts[BLOCK_SIZES];
1458       int i;
1459       int sb64_per_frame;
1460       int norm_factors[BLOCK_SIZES] =
1461         {256, 128, 128, 64, 32, 32, 16, 8, 8, 4, 2, 2, 1};
1462       FILE *f = fopen("mode_hit_stats.stt", "a");
1463
1464       // On average, how many mode tests do we do
1465       for (i = 0; i < BLOCK_SIZES; ++i) {
1466         norm_counts[i] = (double)cpi->mode_test_hits[i] /
1467                          (double)norm_factors[i];
1468         norm_per_pixel_mode_tests += norm_counts[i];
1469       }
1470       // Convert to a number per 64x64 and per frame
1471       sb64_per_frame = ((cpi->common.height + 63) / 64) *
1472                        ((cpi->common.width + 63) / 64);
1473       norm_per_pixel_mode_tests =
1474         norm_per_pixel_mode_tests /
1475         (double)(cpi->common.current_video_frame * sb64_per_frame);
1476
1477       fprintf(f, "%6.4f\n", norm_per_pixel_mode_tests);
1478       fclose(f);
1479     }
1480 #endif
1481
1482 #if 0
1483     {
1484       printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
1485       printf("\n_frames recive_data encod_mb_row compress_frame  Total\n");
1486       printf("%6d %10ld %10ld %10ld %10ld\n", cpi->common.current_video_frame,
1487              cpi->time_receive_data / 1000, cpi->time_encode_sb_row / 1000,
1488              cpi->time_compress_data / 1000,
1489              (cpi->time_receive_data + cpi->time_compress_data) / 1000);
1490     }
1491 #endif
1492   }
1493
1494   free_pick_mode_context(&cpi->mb);
1495   dealloc_compressor_data(cpi);
1496   vpx_free(cpi->mb.ss);
1497   vpx_free(cpi->tok);
1498
1499   for (i = 0; i < sizeof(cpi->mbgraph_stats) /
1500                   sizeof(cpi->mbgraph_stats[0]); ++i) {
1501     vpx_free(cpi->mbgraph_stats[i].mb_stats);
1502   }
1503
1504   vp9_remove_common(&cpi->common);
1505   vpx_free(cpi);
1506
1507 #ifdef OUTPUT_YUV_SRC
1508   fclose(yuv_file);
1509 #endif
1510 #ifdef OUTPUT_YUV_REC
1511   fclose(yuv_rec_file);
1512 #endif
1513
1514 #if 0
1515
1516   if (keyfile)
1517     fclose(keyfile);
1518
1519   if (framepsnr)
1520     fclose(framepsnr);
1521
1522   if (kf_list)
1523     fclose(kf_list);
1524
1525 #endif
1526 }
1527 static int64_t get_sse(const uint8_t *a, int a_stride,
1528                        const uint8_t *b, int b_stride,
1529                        int width, int height) {
1530   const int dw = width % 16;
1531   const int dh = height % 16;
1532   int64_t total_sse = 0;
1533   unsigned int sse = 0;
1534   int sum = 0;
1535   int x, y;
1536
1537   if (dw > 0) {
1538     variance(&a[width - dw], a_stride, &b[width - dw], b_stride,
1539              dw, height, &sse, &sum);
1540     total_sse += sse;
1541   }
1542
1543   if (dh > 0) {
1544     variance(&a[(height - dh) * a_stride], a_stride,
1545              &b[(height - dh) * b_stride], b_stride,
1546              width - dw, dh, &sse, &sum);
1547     total_sse += sse;
1548   }
1549
1550   for (y = 0; y < height / 16; ++y) {
1551     const uint8_t *pa = a;
1552     const uint8_t *pb = b;
1553     for (x = 0; x < width / 16; ++x) {
1554       vp9_mse16x16(pa, a_stride, pb, b_stride, &sse);
1555       total_sse += sse;
1556
1557       pa += 16;
1558       pb += 16;
1559     }
1560
1561     a += 16 * a_stride;
1562     b += 16 * b_stride;
1563   }
1564
1565   return total_sse;
1566 }
1567
1568 typedef struct {
1569   double psnr[4];       // total/y/u/v
1570   uint64_t sse[4];      // total/y/u/v
1571   uint32_t samples[4];  // total/y/u/v
1572 } PSNR_STATS;
1573
1574 static void calc_psnr(const YV12_BUFFER_CONFIG *a, const YV12_BUFFER_CONFIG *b,
1575                       PSNR_STATS *psnr) {
1576   const int widths[3]        = {a->y_width,  a->uv_width,  a->uv_width };
1577   const int heights[3]       = {a->y_height, a->uv_height, a->uv_height};
1578   const uint8_t *a_planes[3] = {a->y_buffer, a->u_buffer,  a->v_buffer };
1579   const int a_strides[3]     = {a->y_stride, a->uv_stride, a->uv_stride};
1580   const uint8_t *b_planes[3] = {b->y_buffer, b->u_buffer,  b->v_buffer };
1581   const int b_strides[3]     = {b->y_stride, b->uv_stride, b->uv_stride};
1582   int i;
1583   uint64_t total_sse = 0;
1584   uint32_t total_samples = 0;
1585
1586   for (i = 0; i < 3; ++i) {
1587     const int w = widths[i];
1588     const int h = heights[i];
1589     const uint32_t samples = w * h;
1590     const uint64_t sse = get_sse(a_planes[i], a_strides[i],
1591                                  b_planes[i], b_strides[i],
1592                                  w, h);
1593     psnr->sse[1 + i] = sse;
1594     psnr->samples[1 + i] = samples;
1595     psnr->psnr[1 + i] = vpx_sse_to_psnr(samples, 255.0, (double)sse);
1596
1597     total_sse += sse;
1598     total_samples += samples;
1599   }
1600
1601   psnr->sse[0] = total_sse;
1602   psnr->samples[0] = total_samples;
1603   psnr->psnr[0] = vpx_sse_to_psnr((double)total_samples, 255.0,
1604                                   (double)total_sse);
1605 }
1606
1607 static void generate_psnr_packet(VP9_COMP *cpi) {
1608   struct vpx_codec_cx_pkt pkt;
1609   int i;
1610   PSNR_STATS psnr;
1611   calc_psnr(cpi->Source, cpi->common.frame_to_show, &psnr);
1612   for (i = 0; i < 4; ++i) {
1613     pkt.data.psnr.samples[i] = psnr.samples[i];
1614     pkt.data.psnr.sse[i] = psnr.sse[i];
1615     pkt.data.psnr.psnr[i] = psnr.psnr[i];
1616   }
1617   pkt.kind = VPX_CODEC_PSNR_PKT;
1618   vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
1619 }
1620
1621 int vp9_use_as_reference(VP9_COMP *cpi, int ref_frame_flags) {
1622   if (ref_frame_flags > 7)
1623     return -1;
1624
1625   cpi->ref_frame_flags = ref_frame_flags;
1626   return 0;
1627 }
1628
1629 void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags) {
1630   cpi->ext_refresh_golden_frame = (ref_frame_flags & VP9_GOLD_FLAG) != 0;
1631   cpi->ext_refresh_alt_ref_frame = (ref_frame_flags & VP9_ALT_FLAG) != 0;
1632   cpi->ext_refresh_last_frame = (ref_frame_flags & VP9_LAST_FLAG) != 0;
1633   cpi->ext_refresh_frame_flags_pending = 1;
1634 }
1635
1636 static YV12_BUFFER_CONFIG *get_vp9_ref_frame_buffer(VP9_COMP *cpi,
1637                                 VP9_REFFRAME ref_frame_flag) {
1638   MV_REFERENCE_FRAME ref_frame = NONE;
1639   if (ref_frame_flag == VP9_LAST_FLAG)
1640     ref_frame = LAST_FRAME;
1641   else if (ref_frame_flag == VP9_GOLD_FLAG)
1642     ref_frame = GOLDEN_FRAME;
1643   else if (ref_frame_flag == VP9_ALT_FLAG)
1644     ref_frame = ALTREF_FRAME;
1645
1646   return ref_frame == NONE ? NULL : get_ref_frame_buffer(cpi, ref_frame);
1647 }
1648
1649 int vp9_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
1650                            YV12_BUFFER_CONFIG *sd) {
1651   YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag);
1652   if (cfg) {
1653     vp8_yv12_copy_frame(cfg, sd);
1654     return 0;
1655   } else {
1656     return -1;
1657   }
1658 }
1659
1660 int vp9_get_reference_enc(VP9_COMP *cpi, int index, YV12_BUFFER_CONFIG **fb) {
1661   VP9_COMMON *cm = &cpi->common;
1662
1663   if (index < 0 || index >= REF_FRAMES)
1664     return -1;
1665
1666   *fb = &cm->frame_bufs[cm->ref_frame_map[index]].buf;
1667   return 0;
1668 }
1669
1670 int vp9_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
1671                           YV12_BUFFER_CONFIG *sd) {
1672   YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag);
1673   if (cfg) {
1674     vp8_yv12_copy_frame(sd, cfg);
1675     return 0;
1676   } else {
1677     return -1;
1678   }
1679 }
1680
1681 int vp9_update_entropy(VP9_COMP * cpi, int update) {
1682   cpi->ext_refresh_frame_context = update;
1683   cpi->ext_refresh_frame_context_pending = 1;
1684   return 0;
1685 }
1686
1687
1688 #ifdef OUTPUT_YUV_SRC
1689 void vp9_write_yuv_frame(YV12_BUFFER_CONFIG *s) {
1690   uint8_t *src = s->y_buffer;
1691   int h = s->y_height;
1692
1693   do {
1694     fwrite(src, s->y_width, 1,  yuv_file);
1695     src += s->y_stride;
1696   } while (--h);
1697
1698   src = s->u_buffer;
1699   h = s->uv_height;
1700
1701   do {
1702     fwrite(src, s->uv_width, 1,  yuv_file);
1703     src += s->uv_stride;
1704   } while (--h);
1705
1706   src = s->v_buffer;
1707   h = s->uv_height;
1708
1709   do {
1710     fwrite(src, s->uv_width, 1, yuv_file);
1711     src += s->uv_stride;
1712   } while (--h);
1713 }
1714 #endif
1715
1716 #ifdef OUTPUT_YUV_REC
1717 void vp9_write_yuv_rec_frame(VP9_COMMON *cm) {
1718   YV12_BUFFER_CONFIG *s = cm->frame_to_show;
1719   uint8_t *src = s->y_buffer;
1720   int h = cm->height;
1721
1722   do {
1723     fwrite(src, s->y_width, 1,  yuv_rec_file);
1724     src += s->y_stride;
1725   } while (--h);
1726
1727   src = s->u_buffer;
1728   h = s->uv_height;
1729
1730   do {
1731     fwrite(src, s->uv_width, 1,  yuv_rec_file);
1732     src += s->uv_stride;
1733   } while (--h);
1734
1735   src = s->v_buffer;
1736   h = s->uv_height;
1737
1738   do {
1739     fwrite(src, s->uv_width, 1, yuv_rec_file);
1740     src += s->uv_stride;
1741   } while (--h);
1742
1743 #if CONFIG_ALPHA
1744   if (s->alpha_buffer) {
1745     src = s->alpha_buffer;
1746     h = s->alpha_height;
1747     do {
1748       fwrite(src, s->alpha_width, 1,  yuv_rec_file);
1749       src += s->alpha_stride;
1750     } while (--h);
1751   }
1752 #endif
1753
1754   fflush(yuv_rec_file);
1755 }
1756 #endif
1757
1758 static void scale_and_extend_frame_nonnormative(YV12_BUFFER_CONFIG *src_fb,
1759                                                 YV12_BUFFER_CONFIG *dst_fb) {
1760   const int in_w = src_fb->y_crop_width;
1761   const int in_h = src_fb->y_crop_height;
1762   const int out_w = dst_fb->y_crop_width;
1763   const int out_h = dst_fb->y_crop_height;
1764   const int in_w_uv = src_fb->uv_crop_width;
1765   const int in_h_uv = src_fb->uv_crop_height;
1766   const int out_w_uv = dst_fb->uv_crop_width;
1767   const int out_h_uv = dst_fb->uv_crop_height;
1768   int i;
1769
1770   uint8_t *srcs[4] = {src_fb->y_buffer, src_fb->u_buffer, src_fb->v_buffer,
1771     src_fb->alpha_buffer};
1772   int src_strides[4] = {src_fb->y_stride, src_fb->uv_stride, src_fb->uv_stride,
1773     src_fb->alpha_stride};
1774
1775   uint8_t *dsts[4] = {dst_fb->y_buffer, dst_fb->u_buffer, dst_fb->v_buffer,
1776     dst_fb->alpha_buffer};
1777   int dst_strides[4] = {dst_fb->y_stride, dst_fb->uv_stride, dst_fb->uv_stride,
1778     dst_fb->alpha_stride};
1779
1780   for (i = 0; i < MAX_MB_PLANE; ++i) {
1781     if (i == 0 || i == 3) {
1782       // Y and alpha planes
1783       vp9_resize_plane(srcs[i], in_h, in_w, src_strides[i],
1784                        dsts[i], out_h, out_w, dst_strides[i]);
1785     } else {
1786       // Chroma planes
1787       vp9_resize_plane(srcs[i], in_h_uv, in_w_uv, src_strides[i],
1788                        dsts[i], out_h_uv, out_w_uv, dst_strides[i]);
1789     }
1790   }
1791   vp8_yv12_extend_frame_borders(dst_fb);
1792 }
1793
1794 static void scale_and_extend_frame(YV12_BUFFER_CONFIG *src_fb,
1795                                    YV12_BUFFER_CONFIG *dst_fb) {
1796   const int in_w = src_fb->y_crop_width;
1797   const int in_h = src_fb->y_crop_height;
1798   const int out_w = dst_fb->y_crop_width;
1799   const int out_h = dst_fb->y_crop_height;
1800   int x, y, i;
1801
1802   uint8_t *srcs[4] = {src_fb->y_buffer, src_fb->u_buffer, src_fb->v_buffer,
1803                       src_fb->alpha_buffer};
1804   int src_strides[4] = {src_fb->y_stride, src_fb->uv_stride, src_fb->uv_stride,
1805                         src_fb->alpha_stride};
1806
1807   uint8_t *dsts[4] = {dst_fb->y_buffer, dst_fb->u_buffer, dst_fb->v_buffer,
1808                       dst_fb->alpha_buffer};
1809   int dst_strides[4] = {dst_fb->y_stride, dst_fb->uv_stride, dst_fb->uv_stride,
1810                         dst_fb->alpha_stride};
1811
1812   for (y = 0; y < out_h; y += 16) {
1813     for (x = 0; x < out_w; x += 16) {
1814       for (i = 0; i < MAX_MB_PLANE; ++i) {
1815         const int factor = (i == 0 || i == 3 ? 1 : 2);
1816         const int x_q4 = x * (16 / factor) * in_w / out_w;
1817         const int y_q4 = y * (16 / factor) * in_h / out_h;
1818         const int src_stride = src_strides[i];
1819         const int dst_stride = dst_strides[i];
1820         uint8_t *src = srcs[i] + y / factor * in_h / out_h * src_stride +
1821                                  x / factor * in_w / out_w;
1822         uint8_t *dst = dsts[i] + y / factor * dst_stride + x / factor;
1823
1824         vp9_convolve8(src, src_stride, dst, dst_stride,
1825                       vp9_sub_pel_filters_8[x_q4 & 0xf], 16 * in_w / out_w,
1826                       vp9_sub_pel_filters_8[y_q4 & 0xf], 16 * in_h / out_h,
1827                       16 / factor, 16 / factor);
1828       }
1829     }
1830   }
1831
1832   vp8_yv12_extend_frame_borders(dst_fb);
1833 }
1834
1835 static int find_fp_qindex() {
1836   int i;
1837
1838   for (i = 0; i < QINDEX_RANGE; i++) {
1839     if (vp9_convert_qindex_to_q(i) >= 30.0) {
1840       break;
1841     }
1842   }
1843
1844   if (i == QINDEX_RANGE)
1845     i--;
1846
1847   return i;
1848 }
1849
1850 #define WRITE_RECON_BUFFER 0
1851 #if WRITE_RECON_BUFFER
1852 void write_cx_frame_to_file(YV12_BUFFER_CONFIG *frame, int this_frame) {
1853   FILE *yframe;
1854   int i;
1855   char filename[255];
1856
1857   snprintf(filename, sizeof(filename), "cx\\y%04d.raw", this_frame);
1858   yframe = fopen(filename, "wb");
1859
1860   for (i = 0; i < frame->y_height; i++)
1861     fwrite(frame->y_buffer + i * frame->y_stride,
1862            frame->y_width, 1, yframe);
1863
1864   fclose(yframe);
1865   snprintf(filename, sizeof(filename), "cx\\u%04d.raw", this_frame);
1866   yframe = fopen(filename, "wb");
1867
1868   for (i = 0; i < frame->uv_height; i++)
1869     fwrite(frame->u_buffer + i * frame->uv_stride,
1870            frame->uv_width, 1, yframe);
1871
1872   fclose(yframe);
1873   snprintf(filename, sizeof(filename), "cx\\v%04d.raw", this_frame);
1874   yframe = fopen(filename, "wb");
1875
1876   for (i = 0; i < frame->uv_height; i++)
1877     fwrite(frame->v_buffer + i * frame->uv_stride,
1878            frame->uv_width, 1, yframe);
1879
1880   fclose(yframe);
1881 }
1882 #endif
1883
1884 // Function to test for conditions that indicate we should loop
1885 // back and recode a frame.
1886 static int recode_loop_test(const VP9_COMP *cpi,
1887                             int high_limit, int low_limit,
1888                             int q, int maxq, int minq) {
1889   const VP9_COMMON *const cm = &cpi->common;
1890   const RATE_CONTROL *const rc = &cpi->rc;
1891   int force_recode = 0;
1892
1893   // Special case trap if maximum allowed frame size exceeded.
1894   if (rc->projected_frame_size > rc->max_frame_bandwidth) {
1895     force_recode = 1;
1896
1897   // Is frame recode allowed.
1898   // Yes if either recode mode 1 is selected or mode 2 is selected
1899   // and the frame is a key frame, golden frame or alt_ref_frame
1900   } else if ((cpi->sf.recode_loop == ALLOW_RECODE) ||
1901              ((cpi->sf.recode_loop == ALLOW_RECODE_KFARFGF) &&
1902               (cm->frame_type == KEY_FRAME ||
1903                cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame))) {
1904     // General over and under shoot tests
1905     if ((rc->projected_frame_size > high_limit && q < maxq) ||
1906         (rc->projected_frame_size < low_limit && q > minq)) {
1907       force_recode = 1;
1908     } else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
1909       // Deal with frame undershoot and whether or not we are
1910       // below the automatically set cq level.
1911       if (q > cpi->cq_target_quality &&
1912           rc->projected_frame_size < ((rc->this_frame_target * 7) >> 3)) {
1913         force_recode = 1;
1914       }
1915     }
1916   }
1917   return force_recode;
1918 }
1919
1920 void vp9_update_reference_frames(VP9_COMP *cpi) {
1921   VP9_COMMON * const cm = &cpi->common;
1922
1923   // At this point the new frame has been encoded.
1924   // If any buffer copy / swapping is signaled it should be done here.
1925   if (cm->frame_type == KEY_FRAME) {
1926     ref_cnt_fb(cm->frame_bufs,
1927                &cm->ref_frame_map[cpi->gld_fb_idx], cm->new_fb_idx);
1928     ref_cnt_fb(cm->frame_bufs,
1929                &cm->ref_frame_map[cpi->alt_fb_idx], cm->new_fb_idx);
1930   }
1931 #if CONFIG_MULTIPLE_ARF
1932   else if (!cpi->multi_arf_enabled && cpi->refresh_golden_frame &&
1933       !cpi->refresh_alt_ref_frame) {
1934 #else
1935   else if (cpi->refresh_golden_frame && !cpi->refresh_alt_ref_frame &&
1936            !cpi->use_svc) {
1937 #endif
1938     /* Preserve the previously existing golden frame and update the frame in
1939      * the alt ref slot instead. This is highly specific to the current use of
1940      * alt-ref as a forward reference, and this needs to be generalized as
1941      * other uses are implemented (like RTC/temporal scaling)
1942      *
1943      * The update to the buffer in the alt ref slot was signaled in
1944      * vp9_pack_bitstream(), now swap the buffer pointers so that it's treated
1945      * as the golden frame next time.
1946      */
1947     int tmp;
1948
1949     ref_cnt_fb(cm->frame_bufs,
1950                &cm->ref_frame_map[cpi->alt_fb_idx], cm->new_fb_idx);
1951
1952     tmp = cpi->alt_fb_idx;
1953     cpi->alt_fb_idx = cpi->gld_fb_idx;
1954     cpi->gld_fb_idx = tmp;
1955   }  else { /* For non key/golden frames */
1956     if (cpi->refresh_alt_ref_frame) {
1957       int arf_idx = cpi->alt_fb_idx;
1958 #if CONFIG_MULTIPLE_ARF
1959       if (cpi->multi_arf_enabled) {
1960         arf_idx = cpi->arf_buffer_idx[cpi->sequence_number + 1];
1961       }
1962 #endif
1963       ref_cnt_fb(cm->frame_bufs,
1964                  &cm->ref_frame_map[arf_idx], cm->new_fb_idx);
1965     }
1966
1967     if (cpi->refresh_golden_frame) {
1968       ref_cnt_fb(cm->frame_bufs,
1969                  &cm->ref_frame_map[cpi->gld_fb_idx], cm->new_fb_idx);
1970     }
1971   }
1972
1973   if (cpi->refresh_last_frame) {
1974     ref_cnt_fb(cm->frame_bufs,
1975                &cm->ref_frame_map[cpi->lst_fb_idx], cm->new_fb_idx);
1976   }
1977 }
1978
1979 static void loopfilter_frame(VP9_COMP *cpi, VP9_COMMON *cm) {
1980   MACROBLOCKD *xd = &cpi->mb.e_mbd;
1981   struct loopfilter *lf = &cm->lf;
1982   if (xd->lossless) {
1983       lf->filter_level = 0;
1984   } else {
1985     struct vpx_usec_timer timer;
1986
1987     vp9_clear_system_state();
1988
1989     vpx_usec_timer_start(&timer);
1990
1991     vp9_pick_filter_level(cpi->Source, cpi, cpi->sf.lpf_pick);
1992
1993     vpx_usec_timer_mark(&timer);
1994     cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
1995   }
1996
1997   if (lf->filter_level > 0) {
1998     vp9_loop_filter_frame(cm, xd, lf->filter_level, 0, 0);
1999   }
2000
2001   vp9_extend_frame_inner_borders(cm->frame_to_show);
2002 }
2003
2004 void vp9_scale_references(VP9_COMP *cpi) {
2005   VP9_COMMON *cm = &cpi->common;
2006   MV_REFERENCE_FRAME ref_frame;
2007
2008   for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
2009     const int idx = cm->ref_frame_map[get_ref_frame_idx(cpi, ref_frame)];
2010     YV12_BUFFER_CONFIG *const ref = &cm->frame_bufs[idx].buf;
2011
2012     if (ref->y_crop_width != cm->width ||
2013         ref->y_crop_height != cm->height) {
2014       const int new_fb = get_free_fb(cm);
2015       vp9_realloc_frame_buffer(&cm->frame_bufs[new_fb].buf,
2016                                cm->width, cm->height,
2017                                cm->subsampling_x, cm->subsampling_y,
2018                                VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL);
2019       scale_and_extend_frame(ref, &cm->frame_bufs[new_fb].buf);
2020       cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
2021     } else {
2022       cpi->scaled_ref_idx[ref_frame - 1] = idx;
2023       cm->frame_bufs[idx].ref_count++;
2024     }
2025   }
2026 }
2027
2028 static void release_scaled_references(VP9_COMP *cpi) {
2029   VP9_COMMON *cm = &cpi->common;
2030   int i;
2031
2032   for (i = 0; i < 3; i++)
2033     cm->frame_bufs[cpi->scaled_ref_idx[i]].ref_count--;
2034 }
2035
2036 static void full_to_model_count(unsigned int *model_count,
2037                                 unsigned int *full_count) {
2038   int n;
2039   model_count[ZERO_TOKEN] = full_count[ZERO_TOKEN];
2040   model_count[ONE_TOKEN] = full_count[ONE_TOKEN];
2041   model_count[TWO_TOKEN] = full_count[TWO_TOKEN];
2042   for (n = THREE_TOKEN; n < EOB_TOKEN; ++n)
2043     model_count[TWO_TOKEN] += full_count[n];
2044   model_count[EOB_MODEL_TOKEN] = full_count[EOB_TOKEN];
2045 }
2046
2047 static void full_to_model_counts(vp9_coeff_count_model *model_count,
2048                                  vp9_coeff_count *full_count) {
2049   int i, j, k, l;
2050
2051   for (i = 0; i < PLANE_TYPES; ++i)
2052     for (j = 0; j < REF_TYPES; ++j)
2053       for (k = 0; k < COEF_BANDS; ++k)
2054         for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l)
2055           full_to_model_count(model_count[i][j][k][l], full_count[i][j][k][l]);
2056 }
2057
2058 #if 0 && CONFIG_INTERNAL_STATS
2059 static void output_frame_level_debug_stats(VP9_COMP *cpi) {
2060   VP9_COMMON *const cm = &cpi->common;
2061   FILE *const f = fopen("tmp.stt", cm->current_video_frame ? "a" : "w");
2062   int recon_err;
2063
2064   vp9_clear_system_state();
2065
2066   recon_err = vp9_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
2067
2068   if (cpi->twopass.total_left_stats.coded_error != 0.0)
2069     fprintf(f, "%10u %10d %10d %10d %10d %10d "
2070         "%10"PRId64" %10"PRId64" %10d "
2071         "%7.2lf %7.2lf %7.2lf %7.2lf %7.2lf"
2072         "%6d %6d %5d %5d %5d "
2073         "%10"PRId64" %10.3lf"
2074         "%10lf %8u %10d %10d %10d\n",
2075         cpi->common.current_video_frame, cpi->rc.this_frame_target,
2076         cpi->rc.projected_frame_size,
2077         cpi->rc.projected_frame_size / cpi->common.MBs,
2078         (cpi->rc.projected_frame_size - cpi->rc.this_frame_target),
2079         cpi->rc.total_target_vs_actual,
2080         (cpi->oxcf.starting_buffer_level - cpi->rc.bits_off_target),
2081         cpi->rc.total_actual_bits, cm->base_qindex,
2082         vp9_convert_qindex_to_q(cm->base_qindex),
2083         (double)vp9_dc_quant(cm->base_qindex, 0) / 4.0,
2084         cpi->rc.avg_q,
2085         vp9_convert_qindex_to_q(cpi->rc.ni_av_qi),
2086         vp9_convert_qindex_to_q(cpi->cq_target_quality),
2087         cpi->refresh_last_frame, cpi->refresh_golden_frame,
2088         cpi->refresh_alt_ref_frame, cm->frame_type, cpi->rc.gfu_boost,
2089         cpi->twopass.bits_left,
2090         cpi->twopass.total_left_stats.coded_error,
2091         cpi->twopass.bits_left /
2092             (1 + cpi->twopass.total_left_stats.coded_error),
2093         cpi->tot_recode_hits, recon_err, cpi->rc.kf_boost,
2094         cpi->twopass.kf_zeromotion_pct);
2095
2096   fclose(f);
2097
2098   if (0) {
2099     FILE *const fmodes = fopen("Modes.stt", "a");
2100     int i;
2101
2102     fprintf(fmodes, "%6d:%1d:%1d:%1d ", cpi->common.current_video_frame,
2103             cm->frame_type, cpi->refresh_golden_frame,
2104             cpi->refresh_alt_ref_frame);
2105
2106     for (i = 0; i < MAX_MODES; ++i)
2107       fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
2108
2109     fprintf(fmodes, "\n");
2110
2111     fclose(fmodes);
2112   }
2113 }
2114 #endif
2115
2116 static void encode_without_recode_loop(VP9_COMP *cpi,
2117                                        size_t *size,
2118                                        uint8_t *dest,
2119                                        int q) {
2120   VP9_COMMON *const cm = &cpi->common;
2121   vp9_clear_system_state();
2122   vp9_set_quantizer(cm, q);
2123
2124   // Set up entropy context depending on frame type. The decoder mandates
2125   // the use of the default context, index 0, for keyframes and inter
2126   // frames where the error_resilient_mode or intra_only flag is set. For
2127   // other inter-frames the encoder currently uses only two contexts;
2128   // context 1 for ALTREF frames and context 0 for the others.
2129   if (cm->frame_type == KEY_FRAME) {
2130     setup_key_frame(cpi);
2131   } else {
2132     if (!cm->intra_only && !cm->error_resilient_mode && !cpi->use_svc)
2133       cm->frame_context_idx = cpi->refresh_alt_ref_frame;
2134
2135     setup_inter_frame(cm);
2136   }
2137   // Variance adaptive and in frame q adjustment experiments are mutually
2138   // exclusive.
2139   if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
2140     vp9_vaq_frame_setup(cpi);
2141   } else if (cpi->oxcf.aq_mode == COMPLEXITY_AQ) {
2142     vp9_setup_in_frame_q_adj(cpi);
2143   } else if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
2144     vp9_cyclic_refresh_setup(cpi);
2145   }
2146   // transform / motion compensation build reconstruction frame
2147   vp9_encode_frame(cpi);
2148
2149   // Update the skip mb flag probabilities based on the distribution
2150   // seen in the last encoder iteration.
2151   // update_base_skip_probs(cpi);
2152   vp9_clear_system_state();
2153 }
2154
2155 static void encode_with_recode_loop(VP9_COMP *cpi,
2156                                     size_t *size,
2157                                     uint8_t *dest,
2158                                     int q,
2159                                     int bottom_index,
2160                                     int top_index) {
2161   VP9_COMMON *const cm = &cpi->common;
2162   RATE_CONTROL *const rc = &cpi->rc;
2163   int loop_count = 0;
2164   int loop = 0;
2165   int overshoot_seen = 0;
2166   int undershoot_seen = 0;
2167   int q_low = bottom_index, q_high = top_index;
2168   int frame_over_shoot_limit;
2169   int frame_under_shoot_limit;
2170
2171   // Decide frame size bounds
2172   vp9_rc_compute_frame_size_bounds(cpi, rc->this_frame_target,
2173                                    &frame_under_shoot_limit,
2174                                    &frame_over_shoot_limit);
2175
2176   do {
2177     vp9_clear_system_state();
2178
2179     vp9_set_quantizer(cm, q);
2180
2181     if (loop_count == 0) {
2182       // Set up entropy context depending on frame type. The decoder mandates
2183       // the use of the default context, index 0, for keyframes and inter
2184       // frames where the error_resilient_mode or intra_only flag is set. For
2185       // other inter-frames the encoder currently uses only two contexts;
2186       // context 1 for ALTREF frames and context 0 for the others.
2187       if (cm->frame_type == KEY_FRAME) {
2188         setup_key_frame(cpi);
2189       } else {
2190         if (!cm->intra_only && !cm->error_resilient_mode && !cpi->use_svc)
2191           cpi->common.frame_context_idx = cpi->refresh_alt_ref_frame;
2192
2193         setup_inter_frame(cm);
2194       }
2195     }
2196
2197     // Variance adaptive and in frame q adjustment experiments are mutually
2198     // exclusive.
2199     if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
2200       vp9_vaq_frame_setup(cpi);
2201     } else if (cpi->oxcf.aq_mode == COMPLEXITY_AQ) {
2202       vp9_setup_in_frame_q_adj(cpi);
2203     }
2204
2205     // transform / motion compensation build reconstruction frame
2206     vp9_encode_frame(cpi);
2207
2208     // Update the skip mb flag probabilities based on the distribution
2209     // seen in the last encoder iteration.
2210     // update_base_skip_probs(cpi);
2211
2212     vp9_clear_system_state();
2213
2214     // Dummy pack of the bitstream using up to date stats to get an
2215     // accurate estimate of output frame size to determine if we need
2216     // to recode.
2217     if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF) {
2218       save_coding_context(cpi);
2219       cpi->dummy_packing = 1;
2220       if (!cpi->sf.use_nonrd_pick_mode)
2221         vp9_pack_bitstream(cpi, dest, size);
2222
2223       rc->projected_frame_size = (int)(*size) << 3;
2224       restore_coding_context(cpi);
2225
2226       if (frame_over_shoot_limit == 0)
2227         frame_over_shoot_limit = 1;
2228     }
2229
2230     if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
2231       loop = 0;
2232     } else {
2233       if ((cm->frame_type == KEY_FRAME) &&
2234            rc->this_key_frame_forced &&
2235            (rc->projected_frame_size < rc->max_frame_bandwidth)) {
2236         int last_q = q;
2237         int kf_err = vp9_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
2238
2239         int high_err_target = cpi->ambient_err;
2240         int low_err_target = cpi->ambient_err >> 1;
2241
2242         // Prevent possible divide by zero error below for perfect KF
2243         kf_err += !kf_err;
2244
2245         // The key frame is not good enough or we can afford
2246         // to make it better without undue risk of popping.
2247         if ((kf_err > high_err_target &&
2248              rc->projected_frame_size <= frame_over_shoot_limit) ||
2249             (kf_err > low_err_target &&
2250              rc->projected_frame_size <= frame_under_shoot_limit)) {
2251           // Lower q_high
2252           q_high = q > q_low ? q - 1 : q_low;
2253
2254           // Adjust Q
2255           q = (q * high_err_target) / kf_err;
2256           q = MIN(q, (q_high + q_low) >> 1);
2257         } else if (kf_err < low_err_target &&
2258                    rc->projected_frame_size >= frame_under_shoot_limit) {
2259           // The key frame is much better than the previous frame
2260           // Raise q_low
2261           q_low = q < q_high ? q + 1 : q_high;
2262
2263           // Adjust Q
2264           q = (q * low_err_target) / kf_err;
2265           q = MIN(q, (q_high + q_low + 1) >> 1);
2266         }
2267
2268         // Clamp Q to upper and lower limits:
2269         q = clamp(q, q_low, q_high);
2270
2271         loop = q != last_q;
2272       } else if (recode_loop_test(
2273           cpi, frame_over_shoot_limit, frame_under_shoot_limit,
2274           q, MAX(q_high, top_index), bottom_index)) {
2275         // Is the projected frame size out of range and are we allowed
2276         // to attempt to recode.
2277         int last_q = q;
2278         int retries = 0;
2279
2280         // Frame size out of permitted range:
2281         // Update correction factor & compute new Q to try...
2282
2283         // Frame is too large
2284         if (rc->projected_frame_size > rc->this_frame_target) {
2285           // Special case if the projected size is > the max allowed.
2286           if (rc->projected_frame_size >= rc->max_frame_bandwidth)
2287             q_high = rc->worst_quality;
2288
2289           // Raise Qlow as to at least the current value
2290           q_low = q < q_high ? q + 1 : q_high;
2291
2292           if (undershoot_seen || loop_count > 1) {
2293             // Update rate_correction_factor unless
2294             vp9_rc_update_rate_correction_factors(cpi, 1);
2295
2296             q = (q_high + q_low + 1) / 2;
2297           } else {
2298             // Update rate_correction_factor unless
2299             vp9_rc_update_rate_correction_factors(cpi, 0);
2300
2301             q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
2302                                    bottom_index, MAX(q_high, top_index));
2303
2304             while (q < q_low && retries < 10) {
2305               vp9_rc_update_rate_correction_factors(cpi, 0);
2306               q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
2307                                      bottom_index, MAX(q_high, top_index));
2308               retries++;
2309             }
2310           }
2311
2312           overshoot_seen = 1;
2313         } else {
2314           // Frame is too small
2315           q_high = q > q_low ? q - 1 : q_low;
2316
2317           if (overshoot_seen || loop_count > 1) {
2318             vp9_rc_update_rate_correction_factors(cpi, 1);
2319             q = (q_high + q_low) / 2;
2320           } else {
2321             vp9_rc_update_rate_correction_factors(cpi, 0);
2322             q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
2323                                    bottom_index, top_index);
2324             // Special case reset for qlow for constrained quality.
2325             // This should only trigger where there is very substantial
2326             // undershoot on a frame and the auto cq level is above
2327             // the user passsed in value.
2328             if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY &&
2329                 q < q_low) {
2330               q_low = q;
2331             }
2332
2333             while (q > q_high && retries < 10) {
2334               vp9_rc_update_rate_correction_factors(cpi, 0);
2335               q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
2336                                      bottom_index, top_index);
2337               retries++;
2338             }
2339           }
2340
2341           undershoot_seen = 1;
2342         }
2343
2344         // Clamp Q to upper and lower limits:
2345         q = clamp(q, q_low, q_high);
2346
2347         loop = q != last_q;
2348       } else {
2349         loop = 0;
2350       }
2351     }
2352
2353     // Special case for overlay frame.
2354     if (rc->is_src_frame_alt_ref &&
2355         rc->projected_frame_size < rc->max_frame_bandwidth)
2356       loop = 0;
2357
2358     if (loop) {
2359       loop_count++;
2360
2361 #if CONFIG_INTERNAL_STATS
2362       cpi->tot_recode_hits++;
2363 #endif
2364     }
2365   } while (loop);
2366 }
2367
2368 static void get_ref_frame_flags(VP9_COMP *cpi) {
2369   if (cpi->refresh_last_frame & cpi->refresh_golden_frame)
2370     cpi->gold_is_last = 1;
2371   else if (cpi->refresh_last_frame ^ cpi->refresh_golden_frame)
2372     cpi->gold_is_last = 0;
2373
2374   if (cpi->refresh_last_frame & cpi->refresh_alt_ref_frame)
2375     cpi->alt_is_last = 1;
2376   else if (cpi->refresh_last_frame ^ cpi->refresh_alt_ref_frame)
2377     cpi->alt_is_last = 0;
2378
2379   if (cpi->refresh_alt_ref_frame & cpi->refresh_golden_frame)
2380     cpi->gold_is_alt = 1;
2381   else if (cpi->refresh_alt_ref_frame ^ cpi->refresh_golden_frame)
2382     cpi->gold_is_alt = 0;
2383
2384   cpi->ref_frame_flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
2385
2386   if (cpi->gold_is_last)
2387     cpi->ref_frame_flags &= ~VP9_GOLD_FLAG;
2388
2389   if (cpi->rc.frames_till_gf_update_due == INT_MAX)
2390     cpi->ref_frame_flags &= ~VP9_GOLD_FLAG;
2391
2392   if (cpi->alt_is_last)
2393     cpi->ref_frame_flags &= ~VP9_ALT_FLAG;
2394
2395   if (cpi->gold_is_alt)
2396     cpi->ref_frame_flags &= ~VP9_ALT_FLAG;
2397 }
2398
2399 static void set_ext_overrides(VP9_COMP *cpi) {
2400   // Overrides the defaults with the externally supplied values with
2401   // vp9_update_reference() and vp9_update_entropy() calls
2402   // Note: The overrides are valid only for the next frame passed
2403   // to encode_frame_to_data_rate() function
2404   if (cpi->ext_refresh_frame_context_pending) {
2405     cpi->common.refresh_frame_context = cpi->ext_refresh_frame_context;
2406     cpi->ext_refresh_frame_context_pending = 0;
2407   }
2408   if (cpi->ext_refresh_frame_flags_pending) {
2409     cpi->refresh_last_frame = cpi->ext_refresh_last_frame;
2410     cpi->refresh_golden_frame = cpi->ext_refresh_golden_frame;
2411     cpi->refresh_alt_ref_frame = cpi->ext_refresh_alt_ref_frame;
2412     cpi->ext_refresh_frame_flags_pending = 0;
2413   }
2414 }
2415
2416 static void encode_frame_to_data_rate(VP9_COMP *cpi,
2417                                       size_t *size,
2418                                       uint8_t *dest,
2419                                       unsigned int *frame_flags) {
2420   VP9_COMMON *const cm = &cpi->common;
2421   TX_SIZE t;
2422   int q;
2423   int top_index;
2424   int bottom_index;
2425
2426   const SPEED_FEATURES *const sf = &cpi->sf;
2427   const unsigned int max_mv_def = MIN(cm->width, cm->height);
2428   struct segmentation *const seg = &cm->seg;
2429
2430   set_ext_overrides(cpi);
2431
2432   /* Scale the source buffer, if required. */
2433   if (cm->mi_cols * MI_SIZE != cpi->un_scaled_source->y_width ||
2434       cm->mi_rows * MI_SIZE != cpi->un_scaled_source->y_height) {
2435     scale_and_extend_frame_nonnormative(cpi->un_scaled_source,
2436                                         &cpi->scaled_source);
2437     cpi->Source = &cpi->scaled_source;
2438   } else {
2439     cpi->Source = cpi->un_scaled_source;
2440   }
2441
2442   // Scale the last source buffer, if required.
2443   if (cpi->unscaled_last_source != NULL) {
2444     if (cm->mi_cols * MI_SIZE != cpi->unscaled_last_source->y_width ||
2445         cm->mi_rows * MI_SIZE != cpi->unscaled_last_source->y_height) {
2446       scale_and_extend_frame_nonnormative(cpi->unscaled_last_source,
2447                                           &cpi->scaled_last_source);
2448       cpi->Last_Source = &cpi->scaled_last_source;
2449     } else {
2450       cpi->Last_Source = cpi->unscaled_last_source;
2451     }
2452   }
2453
2454   vp9_scale_references(cpi);
2455
2456   vp9_clear_system_state();
2457
2458   // Enable or disable mode based tweaking of the zbin.
2459   // For 2 pass only used where GF/ARF prediction quality
2460   // is above a threshold.
2461   cpi->zbin_mode_boost = 0;
2462   cpi->zbin_mode_boost_enabled = 0;
2463
2464   // Current default encoder behavior for the altref sign bias.
2465   cm->ref_frame_sign_bias[ALTREF_FRAME] = cpi->rc.source_alt_ref_active;
2466
2467   // Set default state for segment based loop filter update flags.
2468   cm->lf.mode_ref_delta_update = 0;
2469
2470   // Initialize cpi->mv_step_param to default based on max resolution.
2471   cpi->mv_step_param = vp9_init_search_range(cpi, max_mv_def);
2472   // Initialize cpi->max_mv_magnitude and cpi->mv_step_param if appropriate.
2473   if (sf->auto_mv_step_size) {
2474     if (frame_is_intra_only(cm)) {
2475       // Initialize max_mv_magnitude for use in the first INTER frame
2476       // after a key/intra-only frame.
2477       cpi->max_mv_magnitude = max_mv_def;
2478     } else {
2479       if (cm->show_frame)
2480         // Allow mv_steps to correspond to twice the max mv magnitude found
2481         // in the previous frame, capped by the default max_mv_magnitude based
2482         // on resolution.
2483         cpi->mv_step_param = vp9_init_search_range(cpi, MIN(max_mv_def, 2 *
2484                                  cpi->max_mv_magnitude));
2485       cpi->max_mv_magnitude = 0;
2486     }
2487   }
2488
2489   // Set various flags etc to special state if it is a key frame.
2490   if (frame_is_intra_only(cm)) {
2491     setup_key_frame(cpi);
2492     // Reset the loop filter deltas and segmentation map.
2493     vp9_reset_segment_features(&cm->seg);
2494
2495     // If segmentation is enabled force a map update for key frames.
2496     if (seg->enabled) {
2497       seg->update_map = 1;
2498       seg->update_data = 1;
2499     }
2500
2501     // The alternate reference frame cannot be active for a key frame.
2502     cpi->rc.source_alt_ref_active = 0;
2503
2504     cm->error_resilient_mode = (cpi->oxcf.error_resilient_mode != 0);
2505     cm->frame_parallel_decoding_mode =
2506       (cpi->oxcf.frame_parallel_decoding_mode != 0);
2507
2508     // By default, encoder assumes decoder can use prev_mi.
2509     cm->coding_use_prev_mi = 1;
2510     if (cm->error_resilient_mode) {
2511       cm->coding_use_prev_mi = 0;
2512       cm->frame_parallel_decoding_mode = 1;
2513       cm->reset_frame_context = 0;
2514       cm->refresh_frame_context = 0;
2515     } else if (cm->intra_only) {
2516       // Only reset the current context.
2517       cm->reset_frame_context = 2;
2518     }
2519   }
2520
2521   // Configure experimental use of segmentation for enhanced coding of
2522   // static regions if indicated.
2523   // Only allowed in second pass of two pass (as requires lagged coding)
2524   // and if the relevant speed feature flag is set.
2525   if (cpi->pass == 2 && cpi->sf.static_segmentation)
2526     configure_static_seg_features(cpi);
2527
2528   // For 1 pass CBR, check if we are dropping this frame.
2529   // Never drop on key frame.
2530   if (cpi->pass == 0 &&
2531       cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER &&
2532       cm->frame_type != KEY_FRAME) {
2533     if (vp9_rc_drop_frame(cpi)) {
2534       vp9_rc_postencode_update_drop_frame(cpi);
2535       ++cm->current_video_frame;
2536       return;
2537     }
2538   }
2539
2540   vp9_clear_system_state();
2541
2542   vp9_zero(cpi->rd.tx_select_threshes);
2543
2544 #if CONFIG_VP9_POSTPROC
2545   if (cpi->oxcf.noise_sensitivity > 0) {
2546     int l = 0;
2547     switch (cpi->oxcf.noise_sensitivity) {
2548       case 1:
2549         l = 20;
2550         break;
2551       case 2:
2552         l = 40;
2553         break;
2554       case 3:
2555         l = 60;
2556         break;
2557       case 4:
2558       case 5:
2559         l = 100;
2560         break;
2561       case 6:
2562         l = 150;
2563         break;
2564     }
2565     vp9_denoise(cpi->Source, cpi->Source, l);
2566   }
2567 #endif
2568
2569 #ifdef OUTPUT_YUV_SRC
2570   vp9_write_yuv_frame(cpi->Source);
2571 #endif
2572
2573   set_speed_features(cpi);
2574
2575   // Decide q and q bounds.
2576   q = vp9_rc_pick_q_and_bounds(cpi, &bottom_index, &top_index);
2577
2578   if (!frame_is_intra_only(cm)) {
2579     cm->interp_filter = DEFAULT_INTERP_FILTER;
2580     /* TODO: Decide this more intelligently */
2581     set_high_precision_mv(cpi, q < HIGH_PRECISION_MV_QTHRESH);
2582   }
2583
2584   if (cpi->sf.recode_loop == DISALLOW_RECODE) {
2585     encode_without_recode_loop(cpi, size, dest, q);
2586   } else {
2587     encode_with_recode_loop(cpi, size, dest, q, bottom_index, top_index);
2588   }
2589
2590   // Special case code to reduce pulsing when key frames are forced at a
2591   // fixed interval. Note the reconstruction error if it is the frame before
2592   // the force key frame
2593   if (cpi->rc.next_key_frame_forced && cpi->rc.frames_to_key == 1) {
2594     cpi->ambient_err = vp9_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
2595   }
2596
2597   // If the encoder forced a KEY_FRAME decision
2598   if (cm->frame_type == KEY_FRAME)
2599     cpi->refresh_last_frame = 1;
2600
2601   cm->frame_to_show = get_frame_new_buffer(cm);
2602
2603 #if WRITE_RECON_BUFFER
2604   if (cm->show_frame)
2605     write_cx_frame_to_file(cm->frame_to_show,
2606                            cm->current_video_frame);
2607   else
2608     write_cx_frame_to_file(cm->frame_to_show,
2609                            cm->current_video_frame + 1000);
2610 #endif
2611
2612   // Pick the loop filter level for the frame.
2613   loopfilter_frame(cpi, cm);
2614
2615 #if WRITE_RECON_BUFFER
2616   if (cm->show_frame)
2617     write_cx_frame_to_file(cm->frame_to_show,
2618                            cm->current_video_frame + 2000);
2619   else
2620     write_cx_frame_to_file(cm->frame_to_show,
2621                            cm->current_video_frame + 3000);
2622 #endif
2623
2624   // build the bitstream
2625   cpi->dummy_packing = 0;
2626   vp9_pack_bitstream(cpi, dest, size);
2627
2628   if (cm->seg.update_map)
2629     update_reference_segmentation_map(cpi);
2630
2631   release_scaled_references(cpi);
2632   vp9_update_reference_frames(cpi);
2633
2634   for (t = TX_4X4; t <= TX_32X32; t++)
2635     full_to_model_counts(cm->counts.coef[t], cpi->coef_counts[t]);
2636
2637   if (!cm->error_resilient_mode && !cm->frame_parallel_decoding_mode)
2638     vp9_adapt_coef_probs(cm);
2639
2640   if (!frame_is_intra_only(cm)) {
2641     if (!cm->error_resilient_mode && !cm->frame_parallel_decoding_mode) {
2642       vp9_adapt_mode_probs(cm);
2643       vp9_adapt_mv_probs(cm, cm->allow_high_precision_mv);
2644     }
2645   }
2646
2647 #if 0
2648   output_frame_level_debug_stats(cpi);
2649 #endif
2650   if (cpi->refresh_golden_frame == 1)
2651     cm->frame_flags |= FRAMEFLAGS_GOLDEN;
2652   else
2653     cm->frame_flags &= ~FRAMEFLAGS_GOLDEN;
2654
2655   if (cpi->refresh_alt_ref_frame == 1)
2656     cm->frame_flags |= FRAMEFLAGS_ALTREF;
2657   else
2658     cm->frame_flags &= ~FRAMEFLAGS_ALTREF;
2659
2660   get_ref_frame_flags(cpi);
2661
2662   cm->last_frame_type = cm->frame_type;
2663   vp9_rc_postencode_update(cpi, *size);
2664
2665   if (cm->frame_type == KEY_FRAME) {
2666     // Tell the caller that the frame was coded as a key frame
2667     *frame_flags = cm->frame_flags | FRAMEFLAGS_KEY;
2668
2669 #if CONFIG_MULTIPLE_ARF
2670     // Reset the sequence number.
2671     if (cpi->multi_arf_enabled) {
2672       cpi->sequence_number = 0;
2673       cpi->frame_coding_order_period = cpi->new_frame_coding_order_period;
2674       cpi->new_frame_coding_order_period = -1;
2675     }
2676 #endif
2677   } else {
2678     *frame_flags = cm->frame_flags&~FRAMEFLAGS_KEY;
2679
2680 #if CONFIG_MULTIPLE_ARF
2681     /* Increment position in the coded frame sequence. */
2682     if (cpi->multi_arf_enabled) {
2683       ++cpi->sequence_number;
2684       if (cpi->sequence_number >= cpi->frame_coding_order_period) {
2685         cpi->sequence_number = 0;
2686         cpi->frame_coding_order_period = cpi->new_frame_coding_order_period;
2687         cpi->new_frame_coding_order_period = -1;
2688       }
2689       cpi->this_frame_weight = cpi->arf_weight[cpi->sequence_number];
2690       assert(cpi->this_frame_weight >= 0);
2691     }
2692 #endif
2693   }
2694
2695   // Clear the one shot update flags for segmentation map and mode/ref loop
2696   // filter deltas.
2697   cm->seg.update_map = 0;
2698   cm->seg.update_data = 0;
2699   cm->lf.mode_ref_delta_update = 0;
2700
2701   // keep track of the last coded dimensions
2702   cm->last_width = cm->width;
2703   cm->last_height = cm->height;
2704
2705   // reset to normal state now that we are done.
2706   if (!cm->show_existing_frame)
2707     cm->last_show_frame = cm->show_frame;
2708
2709   if (cm->show_frame) {
2710     vp9_swap_mi_and_prev_mi(cm);
2711
2712     // Don't increment frame counters if this was an altref buffer
2713     // update not a real frame
2714     ++cm->current_video_frame;
2715     if (cpi->use_svc)
2716       vp9_inc_frame_in_layer(&cpi->svc);
2717   }
2718 }
2719
2720 static void SvcEncode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
2721                       unsigned int *frame_flags) {
2722   vp9_rc_get_svc_params(cpi);
2723   encode_frame_to_data_rate(cpi, size, dest, frame_flags);
2724 }
2725
2726 static void Pass0Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
2727                         unsigned int *frame_flags) {
2728   if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
2729     vp9_rc_get_one_pass_cbr_params(cpi);
2730   } else {
2731     vp9_rc_get_one_pass_vbr_params(cpi);
2732   }
2733   encode_frame_to_data_rate(cpi, size, dest, frame_flags);
2734 }
2735
2736 static void Pass1Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
2737                         unsigned int *frame_flags) {
2738   (void) size;
2739   (void) dest;
2740   (void) frame_flags;
2741
2742   vp9_rc_get_first_pass_params(cpi);
2743   vp9_set_quantizer(&cpi->common, find_fp_qindex());
2744   vp9_first_pass(cpi);
2745 }
2746
2747 static void Pass2Encode(VP9_COMP *cpi, size_t *size,
2748                         uint8_t *dest, unsigned int *frame_flags) {
2749   cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
2750
2751   vp9_rc_get_second_pass_params(cpi);
2752   encode_frame_to_data_rate(cpi, size, dest, frame_flags);
2753
2754   vp9_twopass_postencode_update(cpi);
2755 }
2756
2757 static void check_initial_width(VP9_COMP *cpi, int subsampling_x,
2758                                 int subsampling_y) {
2759   VP9_COMMON *const cm = &cpi->common;
2760
2761   if (!cpi->initial_width) {
2762     cm->subsampling_x = subsampling_x;
2763     cm->subsampling_y = subsampling_y;
2764     alloc_raw_frame_buffers(cpi);
2765     cpi->initial_width = cm->width;
2766     cpi->initial_height = cm->height;
2767   }
2768 }
2769
2770
2771 int vp9_receive_raw_frame(VP9_COMP *cpi, unsigned int frame_flags,
2772                           YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
2773                           int64_t end_time) {
2774   VP9_COMMON *cm = &cpi->common;
2775   struct vpx_usec_timer timer;
2776   int res = 0;
2777   const int subsampling_x = sd->uv_width  < sd->y_width;
2778   const int subsampling_y = sd->uv_height < sd->y_height;
2779
2780   check_initial_width(cpi, subsampling_x, subsampling_y);
2781   vpx_usec_timer_start(&timer);
2782   if (vp9_lookahead_push(cpi->lookahead,
2783                          sd, time_stamp, end_time, frame_flags))
2784     res = -1;
2785   vpx_usec_timer_mark(&timer);
2786   cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
2787
2788   if (cm->profile == PROFILE_0 && (subsampling_x != 1 || subsampling_y != 1)) {
2789     vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
2790                        "Non-4:2:0 color space requires profile >= 1");
2791     res = -1;
2792   }
2793
2794   return res;
2795 }
2796
2797
2798 static int frame_is_reference(const VP9_COMP *cpi) {
2799   const VP9_COMMON *cm = &cpi->common;
2800
2801   return cm->frame_type == KEY_FRAME ||
2802          cpi->refresh_last_frame ||
2803          cpi->refresh_golden_frame ||
2804          cpi->refresh_alt_ref_frame ||
2805          cm->refresh_frame_context ||
2806          cm->lf.mode_ref_delta_update ||
2807          cm->seg.update_map ||
2808          cm->seg.update_data;
2809 }
2810
2811 #if CONFIG_MULTIPLE_ARF
2812 int is_next_frame_arf(VP9_COMP *cpi) {
2813   // Negative entry in frame_coding_order indicates an ARF at this position.
2814   return cpi->frame_coding_order[cpi->sequence_number + 1] < 0 ? 1 : 0;
2815 }
2816 #endif
2817
2818 void adjust_frame_rate(VP9_COMP *cpi) {
2819   int64_t this_duration;
2820   int step = 0;
2821
2822   if (cpi->source->ts_start == cpi->first_time_stamp_ever) {
2823     this_duration = cpi->source->ts_end - cpi->source->ts_start;
2824     step = 1;
2825   } else {
2826     int64_t last_duration = cpi->last_end_time_stamp_seen
2827         - cpi->last_time_stamp_seen;
2828
2829     this_duration = cpi->source->ts_end - cpi->last_end_time_stamp_seen;
2830
2831     // do a step update if the duration changes by 10%
2832     if (last_duration)
2833       step = (int)((this_duration - last_duration) * 10 / last_duration);
2834   }
2835
2836   if (this_duration) {
2837     if (step) {
2838       vp9_new_framerate(cpi, 10000000.0 / this_duration);
2839     } else {
2840       // Average this frame's rate into the last second's average
2841       // frame rate. If we haven't seen 1 second yet, then average
2842       // over the whole interval seen.
2843       const double interval = MIN((double)(cpi->source->ts_end
2844                                    - cpi->first_time_stamp_ever), 10000000.0);
2845       double avg_duration = 10000000.0 / cpi->oxcf.framerate;
2846       avg_duration *= (interval - avg_duration + this_duration);
2847       avg_duration /= interval;
2848
2849       vp9_new_framerate(cpi, 10000000.0 / avg_duration);
2850     }
2851   }
2852   cpi->last_time_stamp_seen = cpi->source->ts_start;
2853   cpi->last_end_time_stamp_seen = cpi->source->ts_end;
2854 }
2855
2856 int vp9_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags,
2857                             size_t *size, uint8_t *dest,
2858                             int64_t *time_stamp, int64_t *time_end, int flush) {
2859   VP9_COMMON *const cm = &cpi->common;
2860   MACROBLOCKD *const xd = &cpi->mb.e_mbd;
2861   RATE_CONTROL *const rc = &cpi->rc;
2862   struct vpx_usec_timer  cmptimer;
2863   YV12_BUFFER_CONFIG *force_src_buffer = NULL;
2864   MV_REFERENCE_FRAME ref_frame;
2865
2866   if (!cpi)
2867     return -1;
2868
2869   if (cpi->svc.number_spatial_layers > 1 && cpi->pass == 2) {
2870     vp9_restore_layer_context(cpi);
2871   }
2872
2873   vpx_usec_timer_start(&cmptimer);
2874
2875   cpi->source = NULL;
2876   cpi->last_source = NULL;
2877
2878   set_high_precision_mv(cpi, ALTREF_HIGH_PRECISION_MV);
2879
2880   // Normal defaults
2881   cm->reset_frame_context = 0;
2882   cm->refresh_frame_context = 1;
2883   cpi->refresh_last_frame = 1;
2884   cpi->refresh_golden_frame = 0;
2885   cpi->refresh_alt_ref_frame = 0;
2886
2887   // Should we code an alternate reference frame.
2888   if (cpi->oxcf.play_alternate && rc->source_alt_ref_pending) {
2889     int frames_to_arf;
2890
2891 #if CONFIG_MULTIPLE_ARF
2892     assert(!cpi->multi_arf_enabled ||
2893            cpi->frame_coding_order[cpi->sequence_number] < 0);
2894
2895     if (cpi->multi_arf_enabled && (cpi->pass == 2))
2896       frames_to_arf = (-cpi->frame_coding_order[cpi->sequence_number])
2897           - cpi->next_frame_in_order;
2898     else
2899 #endif
2900       frames_to_arf = rc->frames_till_gf_update_due;
2901
2902     assert(frames_to_arf <= rc->frames_to_key);
2903
2904     if ((cpi->source = vp9_lookahead_peek(cpi->lookahead, frames_to_arf))) {
2905 #if CONFIG_MULTIPLE_ARF
2906       cpi->alt_ref_source[cpi->arf_buffered] = cpi->source;
2907 #else
2908       cpi->alt_ref_source = cpi->source;
2909 #endif
2910
2911       if (cpi->oxcf.arnr_max_frames > 0) {
2912         // Produce the filtered ARF frame.
2913         // TODO(agrange) merge these two functions.
2914         vp9_configure_arnr_filter(cpi, frames_to_arf, rc->gfu_boost);
2915         vp9_temporal_filter_prepare(cpi, frames_to_arf);
2916         vp9_extend_frame_borders(&cpi->alt_ref_buffer);
2917         force_src_buffer = &cpi->alt_ref_buffer;
2918       }
2919
2920       cm->show_frame = 0;
2921       cpi->refresh_alt_ref_frame = 1;
2922       cpi->refresh_golden_frame = 0;
2923       cpi->refresh_last_frame = 0;
2924       rc->is_src_frame_alt_ref = 0;
2925
2926 #if CONFIG_MULTIPLE_ARF
2927       if (!cpi->multi_arf_enabled)
2928 #endif
2929         rc->source_alt_ref_pending = 0;
2930     } else {
2931       rc->source_alt_ref_pending = 0;
2932     }
2933   }
2934
2935   if (!cpi->source) {
2936 #if CONFIG_MULTIPLE_ARF
2937     int i;
2938 #endif
2939
2940     // Get last frame source.
2941     if (cm->current_video_frame > 0) {
2942       if ((cpi->last_source = vp9_lookahead_peek(cpi->lookahead, -1)) == NULL)
2943         return -1;
2944     }
2945
2946     if ((cpi->source = vp9_lookahead_pop(cpi->lookahead, flush))) {
2947       cm->show_frame = 1;
2948       cm->intra_only = 0;
2949
2950 #if CONFIG_MULTIPLE_ARF
2951       // Is this frame the ARF overlay.
2952       rc->is_src_frame_alt_ref = 0;
2953       for (i = 0; i < cpi->arf_buffered; ++i) {
2954         if (cpi->source == cpi->alt_ref_source[i]) {
2955           rc->is_src_frame_alt_ref = 1;
2956           cpi->refresh_golden_frame = 1;
2957           break;
2958         }
2959       }
2960 #else
2961       rc->is_src_frame_alt_ref = cpi->alt_ref_source &&
2962                                  (cpi->source == cpi->alt_ref_source);
2963 #endif
2964       if (rc->is_src_frame_alt_ref) {
2965         // Current frame is an ARF overlay frame.
2966 #if CONFIG_MULTIPLE_ARF
2967         cpi->alt_ref_source[i] = NULL;
2968 #else
2969         cpi->alt_ref_source = NULL;
2970 #endif
2971         // Don't refresh the last buffer for an ARF overlay frame. It will
2972         // become the GF so preserve last as an alternative prediction option.
2973         cpi->refresh_last_frame = 0;
2974       }
2975 #if CONFIG_MULTIPLE_ARF
2976       ++cpi->next_frame_in_order;
2977 #endif
2978     }
2979   }
2980
2981   if (cpi->source) {
2982     cpi->un_scaled_source = cpi->Source = force_src_buffer ? force_src_buffer
2983                                                            : &cpi->source->img;
2984
2985   if (cpi->last_source != NULL) {
2986     cpi->unscaled_last_source = &cpi->last_source->img;
2987   } else {
2988     cpi->unscaled_last_source = NULL;
2989   }
2990
2991     *time_stamp = cpi->source->ts_start;
2992     *time_end = cpi->source->ts_end;
2993     *frame_flags = cpi->source->flags;
2994
2995 #if CONFIG_MULTIPLE_ARF
2996     if (cm->frame_type != KEY_FRAME && cpi->pass == 2)
2997       rc->source_alt_ref_pending = is_next_frame_arf(cpi);
2998 #endif
2999   } else {
3000     *size = 0;
3001     if (flush && cpi->pass == 1 && !cpi->twopass.first_pass_done) {
3002       vp9_end_first_pass(cpi);    /* get last stats packet */
3003       cpi->twopass.first_pass_done = 1;
3004     }
3005     return -1;
3006   }
3007
3008   if (cpi->source->ts_start < cpi->first_time_stamp_ever) {
3009     cpi->first_time_stamp_ever = cpi->source->ts_start;
3010     cpi->last_end_time_stamp_seen = cpi->source->ts_start;
3011   }
3012
3013   // adjust frame rates based on timestamps given
3014   if (cm->show_frame) {
3015     adjust_frame_rate(cpi);
3016   }
3017
3018   if (cpi->svc.number_temporal_layers > 1 &&
3019       cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
3020     vp9_update_temporal_layer_framerate(cpi);
3021     vp9_restore_layer_context(cpi);
3022   }
3023
3024   // start with a 0 size frame
3025   *size = 0;
3026
3027   // Clear down mmx registers
3028   vp9_clear_system_state();
3029
3030   /* find a free buffer for the new frame, releasing the reference previously
3031    * held.
3032    */
3033   cm->frame_bufs[cm->new_fb_idx].ref_count--;
3034   cm->new_fb_idx = get_free_fb(cm);
3035
3036 #if CONFIG_MULTIPLE_ARF
3037   /* Set up the correct ARF frame. */
3038   if (cpi->refresh_alt_ref_frame) {
3039     ++cpi->arf_buffered;
3040   }
3041   if (cpi->multi_arf_enabled && (cm->frame_type != KEY_FRAME) &&
3042       (cpi->pass == 2)) {
3043     cpi->alt_fb_idx = cpi->arf_buffer_idx[cpi->sequence_number];
3044   }
3045 #endif
3046
3047   cm->frame_flags = *frame_flags;
3048
3049   // Reset the frame pointers to the current frame size
3050   vp9_realloc_frame_buffer(get_frame_new_buffer(cm),
3051                            cm->width, cm->height,
3052                            cm->subsampling_x, cm->subsampling_y,
3053                            VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL);
3054
3055   for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3056     const int idx = cm->ref_frame_map[get_ref_frame_idx(cpi, ref_frame)];
3057     YV12_BUFFER_CONFIG *const buf = &cm->frame_bufs[idx].buf;
3058     RefBuffer *const ref_buf = &cm->frame_refs[ref_frame - 1];
3059     ref_buf->buf = buf;
3060     ref_buf->idx = idx;
3061     vp9_setup_scale_factors_for_frame(&ref_buf->sf,
3062                                       buf->y_crop_width, buf->y_crop_height,
3063                                       cm->width, cm->height);
3064
3065     if (vp9_is_scaled(&ref_buf->sf))
3066       vp9_extend_frame_borders(buf);
3067   }
3068
3069   set_ref_ptrs(cm, xd, LAST_FRAME, LAST_FRAME);
3070
3071   if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
3072     vp9_vaq_init();
3073   }
3074
3075   if (cpi->pass == 1 &&
3076       (!cpi->use_svc || cpi->svc.number_temporal_layers == 1)) {
3077     Pass1Encode(cpi, size, dest, frame_flags);
3078   } else if (cpi->pass == 2 &&
3079       (!cpi->use_svc || cpi->svc.number_temporal_layers == 1)) {
3080     Pass2Encode(cpi, size, dest, frame_flags);
3081   } else if (cpi->use_svc) {
3082     SvcEncode(cpi, size, dest, frame_flags);
3083   } else {
3084     // One pass encode
3085     Pass0Encode(cpi, size, dest, frame_flags);
3086   }
3087
3088   if (cm->refresh_frame_context)
3089     cm->frame_contexts[cm->frame_context_idx] = cm->fc;
3090
3091   // Frame was dropped, release scaled references.
3092   if (*size == 0) {
3093     release_scaled_references(cpi);
3094   }
3095
3096   if (*size > 0) {
3097     cpi->droppable = !frame_is_reference(cpi);
3098   }
3099
3100   // Save layer specific state.
3101   if ((cpi->svc.number_temporal_layers > 1 &&
3102       cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) ||
3103       (cpi->svc.number_spatial_layers > 1 && cpi->pass == 2)) {
3104     vp9_save_layer_context(cpi);
3105   }
3106
3107   vpx_usec_timer_mark(&cmptimer);
3108   cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
3109
3110   if (cpi->b_calculate_psnr && cpi->pass != 1 && cm->show_frame)
3111     generate_psnr_packet(cpi);
3112
3113 #if CONFIG_INTERNAL_STATS
3114
3115   if (cpi->pass != 1) {
3116     cpi->bytes += (int)(*size);
3117
3118     if (cm->show_frame) {
3119       cpi->count++;
3120
3121       if (cpi->b_calculate_psnr) {
3122         YV12_BUFFER_CONFIG *orig = cpi->Source;
3123         YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
3124         YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer;
3125         PSNR_STATS psnr;
3126         calc_psnr(orig, recon, &psnr);
3127
3128         cpi->total += psnr.psnr[0];
3129         cpi->total_y += psnr.psnr[1];
3130         cpi->total_u += psnr.psnr[2];
3131         cpi->total_v += psnr.psnr[3];
3132         cpi->total_sq_error += psnr.sse[0];
3133         cpi->total_samples += psnr.samples[0];
3134
3135         {
3136           PSNR_STATS psnr2;
3137           double frame_ssim2 = 0, weight = 0;
3138 #if CONFIG_VP9_POSTPROC
3139           vp9_deblock(cm->frame_to_show, &cm->post_proc_buffer,
3140                       cm->lf.filter_level * 10 / 6);
3141 #endif
3142           vp9_clear_system_state();
3143
3144           calc_psnr(orig, pp, &psnr2);
3145
3146           cpi->totalp += psnr2.psnr[0];
3147           cpi->totalp_y += psnr2.psnr[1];
3148           cpi->totalp_u += psnr2.psnr[2];
3149           cpi->totalp_v += psnr2.psnr[3];
3150           cpi->totalp_sq_error += psnr2.sse[0];
3151           cpi->totalp_samples += psnr2.samples[0];
3152
3153           frame_ssim2 = vp9_calc_ssim(orig, recon, 1, &weight);
3154
3155           cpi->summed_quality += frame_ssim2 * weight;
3156           cpi->summed_weights += weight;
3157
3158           frame_ssim2 = vp9_calc_ssim(orig, &cm->post_proc_buffer, 1, &weight);
3159
3160           cpi->summedp_quality += frame_ssim2 * weight;
3161           cpi->summedp_weights += weight;
3162 #if 0
3163           {
3164             FILE *f = fopen("q_used.stt", "a");
3165             fprintf(f, "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n",
3166                     cpi->common.current_video_frame, y2, u2, v2,
3167                     frame_psnr2, frame_ssim2);
3168             fclose(f);
3169           }
3170 #endif
3171         }
3172       }
3173
3174       if (cpi->b_calculate_ssimg) {
3175         double y, u, v, frame_all;
3176         frame_all = vp9_calc_ssimg(cpi->Source, cm->frame_to_show, &y, &u, &v);
3177         cpi->total_ssimg_y += y;
3178         cpi->total_ssimg_u += u;
3179         cpi->total_ssimg_v += v;
3180         cpi->total_ssimg_all += frame_all;
3181       }
3182     }
3183   }
3184
3185 #endif
3186   return 0;
3187 }
3188
3189 int vp9_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
3190                               vp9_ppflags_t *flags) {
3191   VP9_COMMON *cm = &cpi->common;
3192
3193   if (!cm->show_frame) {
3194     return -1;
3195   } else {
3196     int ret;
3197 #if CONFIG_VP9_POSTPROC
3198     ret = vp9_post_proc_frame(cm, dest, flags);
3199 #else
3200
3201     if (cm->frame_to_show) {
3202       *dest = *cm->frame_to_show;
3203       dest->y_width = cm->width;
3204       dest->y_height = cm->height;
3205       dest->uv_width = cm->width >> cm->subsampling_x;
3206       dest->uv_height = cm->height >> cm->subsampling_y;
3207       ret = 0;
3208     } else {
3209       ret = -1;
3210     }
3211
3212 #endif  // !CONFIG_VP9_POSTPROC
3213     vp9_clear_system_state();
3214     return ret;
3215   }
3216 }
3217
3218 int vp9_set_roimap(VP9_COMP *cpi, unsigned char *map, unsigned int rows,
3219                    unsigned int cols, int delta_q[MAX_SEGMENTS],
3220                    int delta_lf[MAX_SEGMENTS],
3221                    unsigned int threshold[MAX_SEGMENTS]) {
3222   signed char feature_data[SEG_LVL_MAX][MAX_SEGMENTS];
3223   struct segmentation *seg = &cpi->common.seg;
3224   int i;
3225
3226   if (cpi->common.mb_rows != rows || cpi->common.mb_cols != cols)
3227     return -1;
3228
3229   if (!map) {
3230     vp9_disable_segmentation(seg);
3231     return 0;
3232   }
3233
3234   // Set the segmentation Map
3235   vp9_set_segmentation_map(cpi, map);
3236
3237   // Activate segmentation.
3238   vp9_enable_segmentation(seg);
3239
3240   // Set up the quant, LF and breakout threshold segment data
3241   for (i = 0; i < MAX_SEGMENTS; i++) {
3242     feature_data[SEG_LVL_ALT_Q][i] = delta_q[i];
3243     feature_data[SEG_LVL_ALT_LF][i] = delta_lf[i];
3244     cpi->segment_encode_breakout[i] = threshold[i];
3245   }
3246
3247   // Enable the loop and quant changes in the feature mask
3248   for (i = 0; i < MAX_SEGMENTS; i++) {
3249     if (delta_q[i])
3250       vp9_enable_segfeature(seg, i, SEG_LVL_ALT_Q);
3251     else
3252       vp9_disable_segfeature(seg, i, SEG_LVL_ALT_Q);
3253
3254     if (delta_lf[i])
3255       vp9_enable_segfeature(seg, i, SEG_LVL_ALT_LF);
3256     else
3257       vp9_disable_segfeature(seg, i, SEG_LVL_ALT_LF);
3258   }
3259
3260   // Initialize the feature data structure
3261   // SEGMENT_DELTADATA    0, SEGMENT_ABSDATA      1
3262   vp9_set_segment_data(seg, &feature_data[0][0], SEGMENT_DELTADATA);
3263
3264   return 0;
3265 }
3266
3267 int vp9_set_active_map(VP9_COMP *cpi, unsigned char *map,
3268                        unsigned int rows, unsigned int cols) {
3269   if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols) {
3270     if (map) {
3271       vpx_memcpy(cpi->active_map, map, rows * cols);
3272       cpi->active_map_enabled = 1;
3273     } else {
3274       cpi->active_map_enabled = 0;
3275     }
3276
3277     return 0;
3278   } else {
3279     // cpi->active_map_enabled = 0;
3280     return -1;
3281   }
3282 }
3283
3284 int vp9_set_internal_size(VP9_COMP *cpi,
3285                           VPX_SCALING horiz_mode, VPX_SCALING vert_mode) {
3286   VP9_COMMON *cm = &cpi->common;
3287   int hr = 0, hs = 0, vr = 0, vs = 0;
3288
3289   if (horiz_mode > ONETWO || vert_mode > ONETWO)
3290     return -1;
3291
3292   Scale2Ratio(horiz_mode, &hr, &hs);
3293   Scale2Ratio(vert_mode, &vr, &vs);
3294
3295   // always go to the next whole number
3296   cm->width = (hs - 1 + cpi->oxcf.width * hr) / hs;
3297   cm->height = (vs - 1 + cpi->oxcf.height * vr) / vs;
3298
3299   assert(cm->width <= cpi->initial_width);
3300   assert(cm->height <= cpi->initial_height);
3301   update_frame_size(cpi);
3302   return 0;
3303 }
3304
3305 int vp9_set_size_literal(VP9_COMP *cpi, unsigned int width,
3306                          unsigned int height) {
3307   VP9_COMMON *cm = &cpi->common;
3308
3309   check_initial_width(cpi, 1, 1);
3310
3311   if (width) {
3312     cm->width = width;
3313     if (cm->width * 5 < cpi->initial_width) {
3314       cm->width = cpi->initial_width / 5 + 1;
3315       printf("Warning: Desired width too small, changed to %d\n", cm->width);
3316     }
3317     if (cm->width > cpi->initial_width) {
3318       cm->width = cpi->initial_width;
3319       printf("Warning: Desired width too large, changed to %d\n", cm->width);
3320     }
3321   }
3322
3323   if (height) {
3324     cm->height = height;
3325     if (cm->height * 5 < cpi->initial_height) {
3326       cm->height = cpi->initial_height / 5 + 1;
3327       printf("Warning: Desired height too small, changed to %d\n", cm->height);
3328     }
3329     if (cm->height > cpi->initial_height) {
3330       cm->height = cpi->initial_height;
3331       printf("Warning: Desired height too large, changed to %d\n", cm->height);
3332     }
3333   }
3334
3335   assert(cm->width <= cpi->initial_width);
3336   assert(cm->height <= cpi->initial_height);
3337   update_frame_size(cpi);
3338   return 0;
3339 }
3340
3341 void vp9_set_svc(VP9_COMP *cpi, int use_svc) {
3342   cpi->use_svc = use_svc;
3343   return;
3344 }
3345
3346 int vp9_get_y_sse(const YV12_BUFFER_CONFIG *a, const YV12_BUFFER_CONFIG *b) {
3347   assert(a->y_crop_width == b->y_crop_width);
3348   assert(a->y_crop_height == b->y_crop_height);
3349
3350   return (int)get_sse(a->y_buffer, a->y_stride, b->y_buffer, b->y_stride,
3351                       a->y_crop_width, a->y_crop_height);
3352 }
3353
3354
3355 int vp9_get_quantizer(VP9_COMP *cpi) {
3356   return cpi->common.base_qindex;
3357 }