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
 390   // Set baseline threshold values
 391   for (i = 0; i < MAX_MODES; ++i)
 392   cpi->rd_thresh_mult[i] = is_slowest_mode(cpi->oxcf.mode) ? -500 : 0;
 393
 394   cpi->rd_thresh_mult[THR_NEARESTMV] = 0;
 395   cpi->rd_thresh_mult[THR_NEARESTG] = 0;
 396   cpi->rd_thresh_mult[THR_NEARESTA] = 0;
 397
 398   cpi->rd_thresh_mult[THR_DC] += 1000;
 399
 400   cpi->rd_thresh_mult[THR_NEWMV] += 1000;
 401   cpi->rd_thresh_mult[THR_NEWA] += 1000;
 402   cpi->rd_thresh_mult[THR_NEWG] += 1000;
 403
 404   cpi->rd_thresh_mult[THR_NEARMV] += 1000;
 405   cpi->rd_thresh_mult[THR_NEARA] += 1000;
 406   cpi->rd_thresh_mult[THR_COMP_NEARESTLA] += 1000;
 407   cpi->rd_thresh_mult[THR_COMP_NEARESTGA] += 1000;
 408
 409   cpi->rd_thresh_mult[THR_TM] += 1000;
 410
 411   cpi->rd_thresh_mult[THR_COMP_NEARLA] += 1500;
 412   cpi->rd_thresh_mult[THR_COMP_NEWLA] += 2000;
 413   cpi->rd_thresh_mult[THR_NEARG] += 1000;
 414   cpi->rd_thresh_mult[THR_COMP_NEARGA] += 1500;
 415   cpi->rd_thresh_mult[THR_COMP_NEWGA] += 2000;
 416
 417   cpi->rd_thresh_mult[THR_ZEROMV] += 2000;
 418   cpi->rd_thresh_mult[THR_ZEROG] += 2000;
 419   cpi->rd_thresh_mult[THR_ZEROA] += 2000;
 420   cpi->rd_thresh_mult[THR_COMP_ZEROLA] += 2500;
 421   cpi->rd_thresh_mult[THR_COMP_ZEROGA] += 2500;
 422
 423   cpi->rd_thresh_mult[THR_H_PRED] += 2000;
 424   cpi->rd_thresh_mult[THR_V_PRED] += 2000;
 425   cpi->rd_thresh_mult[THR_D45_PRED ] += 2500;
 426   cpi->rd_thresh_mult[THR_D135_PRED] += 2500;
 427   cpi->rd_thresh_mult[THR_D117_PRED] += 2500;
 428   cpi->rd_thresh_mult[THR_D153_PRED] += 2500;
 429   cpi->rd_thresh_mult[THR_D207_PRED] += 2500;
 430   cpi->rd_thresh_mult[THR_D63_PRED] += 2500;
 431
 432   /* disable frame modes if flags not set */
 433   if (!(cpi->ref_frame_flags & VP9_LAST_FLAG)) {
 434     cpi->rd_thresh_mult[THR_NEWMV    ] = INT_MAX;
 435     cpi->rd_thresh_mult[THR_NEARESTMV] = INT_MAX;
 436     cpi->rd_thresh_mult[THR_ZEROMV   ] = INT_MAX;
 437     cpi->rd_thresh_mult[THR_NEARMV   ] = INT_MAX;
 438   }
 439   if (!(cpi->ref_frame_flags & VP9_GOLD_FLAG)) {
 440     cpi->rd_thresh_mult[THR_NEARESTG ] = INT_MAX;
 441     cpi->rd_thresh_mult[THR_ZEROG    ] = INT_MAX;
 442     cpi->rd_thresh_mult[THR_NEARG    ] = INT_MAX;
 443     cpi->rd_thresh_mult[THR_NEWG     ] = INT_MAX;
 444   }
 445   if (!(cpi->ref_frame_flags & VP9_ALT_FLAG)) {
 446     cpi->rd_thresh_mult[THR_NEARESTA ] = INT_MAX;
 447     cpi->rd_thresh_mult[THR_ZEROA    ] = INT_MAX;
 448     cpi->rd_thresh_mult[THR_NEARA    ] = INT_MAX;
 449     cpi->rd_thresh_mult[THR_NEWA     ] = INT_MAX;
 450   }
 451
 452   if ((cpi->ref_frame_flags & (VP9_LAST_FLAG | VP9_ALT_FLAG)) !=
 453       (VP9_LAST_FLAG | VP9_ALT_FLAG)) {
 454     cpi->rd_thresh_mult[THR_COMP_ZEROLA   ] = INT_MAX;
 455     cpi->rd_thresh_mult[THR_COMP_NEARESTLA] = INT_MAX;
 456     cpi->rd_thresh_mult[THR_COMP_NEARLA   ] = INT_MAX;
 457     cpi->rd_thresh_mult[THR_COMP_NEWLA    ] = INT_MAX;
 458   }
 459   if ((cpi->ref_frame_flags & (VP9_GOLD_FLAG | VP9_ALT_FLAG)) !=
 460       (VP9_GOLD_FLAG | VP9_ALT_FLAG)) {
 461     cpi->rd_thresh_mult[THR_COMP_ZEROGA   ] = INT_MAX;
 462     cpi->rd_thresh_mult[THR_COMP_NEARESTGA] = INT_MAX;
 463     cpi->rd_thresh_mult[THR_COMP_NEARGA   ] = INT_MAX;
 464     cpi->rd_thresh_mult[THR_COMP_NEWGA    ] = INT_MAX;
 465   }
 466 }
 467
 468 static void set_rd_speed_thresholds_sub8x8(VP9_COMP *cpi) {
 469   const SPEED_FEATURES *const sf = &cpi->sf;
 470   int i;
 471
 472   for (i = 0; i < MAX_REFS; ++i)
 473     cpi->rd_thresh_mult_sub8x8[i] = is_slowest_mode(cpi->oxcf.mode)  ? -500 : 0;
 474
 475   cpi->rd_thresh_mult_sub8x8[THR_LAST] += 2500;
 476   cpi->rd_thresh_mult_sub8x8[THR_GOLD] += 2500;
 477   cpi->rd_thresh_mult_sub8x8[THR_ALTR] += 2500;
 478   cpi->rd_thresh_mult_sub8x8[THR_INTRA] += 2500;
 479   cpi->rd_thresh_mult_sub8x8[THR_COMP_LA] += 4500;
 480   cpi->rd_thresh_mult_sub8x8[THR_COMP_GA] += 4500;
 481
 482   // Check for masked out split cases.
 483   for (i = 0; i < MAX_REFS; i++)
 484     if (sf->disable_split_mask & (1 << i))
 485       cpi->rd_thresh_mult_sub8x8[i] = INT_MAX;
 486
 487   // disable mode test if frame flag is not set
 488   if (!(cpi->ref_frame_flags & VP9_LAST_FLAG))
 489     cpi->rd_thresh_mult_sub8x8[THR_LAST] = INT_MAX;
 490   if (!(cpi->ref_frame_flags & VP9_GOLD_FLAG))
 491     cpi->rd_thresh_mult_sub8x8[THR_GOLD] = INT_MAX;
 492   if (!(cpi->ref_frame_flags & VP9_ALT_FLAG))
 493     cpi->rd_thresh_mult_sub8x8[THR_ALTR] = INT_MAX;
 494   if ((cpi->ref_frame_flags & (VP9_LAST_FLAG | VP9_ALT_FLAG)) !=
 495       (VP9_LAST_FLAG | VP9_ALT_FLAG))
 496     cpi->rd_thresh_mult_sub8x8[THR_COMP_LA] = INT_MAX;
 497   if ((cpi->ref_frame_flags & (VP9_GOLD_FLAG | VP9_ALT_FLAG)) !=
 498       (VP9_GOLD_FLAG | VP9_ALT_FLAG))
 499     cpi->rd_thresh_mult_sub8x8[THR_COMP_GA] = INT_MAX;
 500 }
 501
 502 static void set_speed_features(VP9_COMP *cpi) {
 503 #if CONFIG_INTERNAL_STATS
 504   int i;
 505   for (i = 0; i < MAX_MODES; ++i)
 506     cpi->mode_chosen_counts[i] = 0;
 507 #endif
 508
 509   vp9_set_speed_features(cpi);
 510
 511   // Set rd thresholds based on mode and speed setting
 512   set_rd_speed_thresholds(cpi);
 513   set_rd_speed_thresholds_sub8x8(cpi);
 514
 515   cpi->mb.fwd_txm4x4 = vp9_fdct4x4;
 516   if (cpi->oxcf.lossless || cpi->mb.e_mbd.lossless) {
 517     cpi->mb.fwd_txm4x4 = vp9_fwht4x4;
 518   }
 519 }
 520
 521 static void alloc_raw_frame_buffers(VP9_COMP *cpi) {
 522   VP9_COMMON *cm = &cpi->common;
 523   const VP9_CONFIG *oxcf = &cpi->oxcf;
 524
 525   cpi->lookahead = vp9_lookahead_init(oxcf->width, oxcf->height,
 526                                       cm->subsampling_x, cm->subsampling_y,
 527                                       oxcf->lag_in_frames);
 528   if (!cpi->lookahead)
 529     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 530                        "Failed to allocate lag buffers");
 531
 532   if (vp9_realloc_frame_buffer(&cpi->alt_ref_buffer,
 533                                oxcf->width, oxcf->height,
 534                                cm->subsampling_x, cm->subsampling_y,
 535                                VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL))
 536     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 537                        "Failed to allocate altref buffer");
 538 }
 539
 540 void vp9_alloc_compressor_data(VP9_COMP *cpi) {
 541   VP9_COMMON *cm = &cpi->common;
 542
 543   if (vp9_alloc_frame_buffers(cm, cm->width, cm->height))
 544     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 545                        "Failed to allocate frame buffers");
 546
 547   if (vp9_alloc_frame_buffer(&cpi->last_frame_uf,
 548                              cm->width, cm->height,
 549                              cm->subsampling_x, cm->subsampling_y,
 550                              VP9_ENC_BORDER_IN_PIXELS))
 551     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 552                        "Failed to allocate last frame buffer");
 553
 554   if (vp9_alloc_frame_buffer(&cpi->scaled_source,
 555                              cm->width, cm->height,
 556                              cm->subsampling_x, cm->subsampling_y,
 557                              VP9_ENC_BORDER_IN_PIXELS))
 558     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 559                        "Failed to allocate scaled source buffer");
 560
 561   if (vp9_alloc_frame_buffer(&cpi->scaled_last_source,
 562                              cm->width, cm->height,
 563                              cm->subsampling_x, cm->subsampling_y,
 564                              VP9_ENC_BORDER_IN_PIXELS))
 565     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 566                        "Failed to allocate scaled last source buffer");
 567
 568   vpx_free(cpi->tok);
 569
 570   {
 571     unsigned int tokens = get_token_alloc(cm->mb_rows, cm->mb_cols);
 572
 573     CHECK_MEM_ERROR(cm, cpi->tok, vpx_calloc(tokens, sizeof(*cpi->tok)));
 574   }
 575
 576   vpx_free(cpi->mb_activity_map);
 577   CHECK_MEM_ERROR(cm, cpi->mb_activity_map,
 578                   vpx_calloc(sizeof(unsigned int),
 579                              cm->mb_rows * cm->mb_cols));
 580
 581   vpx_free(cpi->mb_norm_activity_map);
 582   CHECK_MEM_ERROR(cm, cpi->mb_norm_activity_map,
 583                   vpx_calloc(sizeof(unsigned int),
 584                              cm->mb_rows * cm->mb_cols));
 585 }
 586
 587
 588 static void update_frame_size(VP9_COMP *cpi) {
 589   VP9_COMMON *const cm = &cpi->common;
 590   MACROBLOCKD *const xd = &cpi->mb.e_mbd;
 591
 592   vp9_update_frame_size(cm);
 593
 594   // Update size of buffers local to this frame
 595   if (vp9_realloc_frame_buffer(&cpi->last_frame_uf,
 596                                cm->width, cm->height,
 597                                cm->subsampling_x, cm->subsampling_y,
 598                                VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL))
 599     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 600                        "Failed to reallocate last frame buffer");
 601
 602   if (vp9_realloc_frame_buffer(&cpi->scaled_source,
 603                                cm->width, cm->height,
 604                                cm->subsampling_x, cm->subsampling_y,
 605                                VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL))
 606     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 607                        "Failed to reallocate scaled source buffer");
 608
 609   if (vp9_realloc_frame_buffer(&cpi->scaled_last_source,
 610                                cm->width, cm->height,
 611                                cm->subsampling_x, cm->subsampling_y,
 612                                VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL))
 613     vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
 614                        "Failed to reallocate scaled last source buffer");
 615
 616   {
 617     int y_stride = cpi->scaled_source.y_stride;
 618
 619     if (cpi->sf.search_method == NSTEP) {
 620       vp9_init3smotion_compensation(&cpi->mb, y_stride);
 621     } else if (cpi->sf.search_method == DIAMOND) {
 622       vp9_init_dsmotion_compensation(&cpi->mb, y_stride);
 623     }
 624   }
 625
 626   init_macroblockd(cm, xd);
 627 }
 628
 629 void vp9_new_framerate(VP9_COMP *cpi, double framerate) {
 630   VP9_COMMON *const cm = &cpi->common;
 631   RATE_CONTROL *const rc = &cpi->rc;
 632   VP9_CONFIG *const oxcf = &cpi->oxcf;
 633   int vbr_max_bits;
 634
 635   oxcf->framerate = framerate < 0.1 ? 30 : framerate;
 636   rc->av_per_frame_bandwidth = (int)(oxcf->target_bandwidth /
 637                                    oxcf->framerate);
 638   rc->min_frame_bandwidth = (int)(rc->av_per_frame_bandwidth *
 639                                   oxcf->two_pass_vbrmin_section / 100);
 640
 641   rc->min_frame_bandwidth = MAX(rc->min_frame_bandwidth, FRAME_OVERHEAD_BITS);
 642
 643   // A maximum bitrate for a frame is defined.
 644   // The baseline for this aligns with HW implementations that
 645   // can support decode of 1080P content up to a bitrate of MAX_MB_RATE bits
 646   // per 16x16 MB (averaged over a frame). However this limit is extended if
 647   // a very high rate is given on the command line or the the rate cannnot
 648   // be acheived because of a user specificed max q (e.g. when the user
 649   // specifies lossless encode.
 650   //
 651   vbr_max_bits = (int)(((int64_t)rc->av_per_frame_bandwidth *
 652       oxcf->two_pass_vbrmax_section) / 100);
 653   rc->max_frame_bandwidth = MAX(MAX((cm->MBs * MAX_MB_RATE), MAXRATE_1080P),
 654                                 vbr_max_bits);
 655
 656   // Set Maximum gf/arf interval
 657   rc->max_gf_interval = 16;
 658
 659   // Extended interval for genuinely static scenes
 660   rc->static_scene_max_gf_interval = cpi->key_frame_frequency >> 1;
 661
 662   // Special conditions when alt ref frame enabled in lagged compress mode
 663   if (oxcf->play_alternate && oxcf->lag_in_frames) {
 664     if (rc->max_gf_interval > oxcf->lag_in_frames - 1)
 665       rc->max_gf_interval = oxcf->lag_in_frames - 1;
 666
 667     if (rc->static_scene_max_gf_interval > oxcf->lag_in_frames - 1)
 668       rc->static_scene_max_gf_interval = oxcf->lag_in_frames - 1;
 669   }
 670
 671   if (rc->max_gf_interval > rc->static_scene_max_gf_interval)
 672     rc->max_gf_interval = rc->static_scene_max_gf_interval;
 673 }
 674
 675 int64_t vp9_rescale(int64_t val, int64_t num, int denom) {
 676   int64_t llnum = num;
 677   int64_t llden = denom;
 678   int64_t llval = val;
 679
 680   return (llval * llnum / llden);
 681 }
 682
 683 static void set_tile_limits(VP9_COMP *cpi) {
 684   VP9_COMMON *const cm = &cpi->common;
 685
 686   int min_log2_tile_cols, max_log2_tile_cols;
 687   vp9_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
 688
 689   cm->log2_tile_cols = clamp(cpi->oxcf.tile_columns,
 690                              min_log2_tile_cols, max_log2_tile_cols);
 691   cm->log2_tile_rows = cpi->oxcf.tile_rows;
 692 }
 693
 694 static void init_config(struct VP9_COMP *cpi, VP9_CONFIG *oxcf) {
 695   VP9_COMMON *const cm = &cpi->common;
 696   int i;
 697
 698   cpi->oxcf = *oxcf;
 699
 700   cm->profile = oxcf->profile;
 701   cm->bit_depth = oxcf->bit_depth;
 702
 703   cm->width = oxcf->width;
 704   cm->height = oxcf->height;
 705   cm->subsampling_x = 0;
 706   cm->subsampling_y = 0;
 707   vp9_alloc_compressor_data(cpi);
 708
 709   // Spatial scalability.
 710   cpi->svc.number_spatial_layers = oxcf->ss_number_layers;
 711   // Temporal scalability.
 712   cpi->svc.number_temporal_layers = oxcf->ts_number_layers;
 713
 714   if ((cpi->svc.number_temporal_layers > 1 &&
 715       cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) ||
 716       (cpi->svc.number_spatial_layers > 1 &&
 717       cpi->oxcf.mode == MODE_SECONDPASS_BEST)) {
 718     vp9_init_layer_context(cpi);
 719   }
 720
 721   // change includes all joint functionality
 722   vp9_change_config(cpi, oxcf);
 723
 724   cpi->static_mb_pct = 0;
 725
 726   cpi->lst_fb_idx = 0;
 727   cpi->gld_fb_idx = 1;
 728   cpi->alt_fb_idx = 2;
 729
 730   set_tile_limits(cpi);
 731
 732   cpi->fixed_divide[0] = 0;
 733   for (i = 1; i < 512; i++)
 734     cpi->fixed_divide[i] = 0x80000 / i;
 735 }
 736
 737 void vp9_change_config(struct VP9_COMP *cpi, const VP9_CONFIG *oxcf) {
 738   VP9_COMMON *const cm = &cpi->common;
 739   RATE_CONTROL *const rc = &cpi->rc;
 740
 741   if (cm->profile != oxcf->profile)
 742     cm->profile = oxcf->profile;
 743   cm->bit_depth = oxcf->bit_depth;
 744
 745   if (cm->profile <= PROFILE_1)
 746     assert(cm->bit_depth == BITS_8);
 747   else
 748     assert(cm->bit_depth > BITS_8);
 749
 750   cpi->oxcf = *oxcf;
 751
 752   if (cpi->oxcf.cpu_used == -6)
 753     cpi->oxcf.play_alternate = 0;
 754
 755   switch (cpi->oxcf.mode) {
 756       // Real time and one pass deprecated in test code base
 757     case MODE_GOODQUALITY:
 758       cpi->pass = 0;
 759       cpi->oxcf.cpu_used = clamp(cpi->oxcf.cpu_used, -5, 5);
 760       break;
 761
 762     case MODE_BESTQUALITY:
 763       cpi->pass = 0;
 764       break;
 765
 766     case MODE_FIRSTPASS:
 767       cpi->pass = 1;
 768       break;
 769
 770     case MODE_SECONDPASS:
 771       cpi->pass = 2;
 772       cpi->oxcf.cpu_used = clamp(cpi->oxcf.cpu_used, -5, 5);
 773       break;
 774
 775     case MODE_SECONDPASS_BEST:
 776       cpi->pass = 2;
 777       break;
 778
 779     case MODE_REALTIME:
 780       cpi->pass = 0;
 781       break;
 782   }
 783
 784   cpi->oxcf.lossless = oxcf->lossless;
 785   if (cpi->oxcf.lossless) {
 786     // In lossless mode, make sure right quantizer range and correct transform
 787     // is set.
 788     cpi->oxcf.worst_allowed_q = 0;
 789     cpi->oxcf.best_allowed_q = 0;
 790     cpi->mb.e_mbd.itxm_add = vp9_iwht4x4_add;
 791   } else {
 792     cpi->mb.e_mbd.itxm_add = vp9_idct4x4_add;
 793   }
 794   rc->baseline_gf_interval = DEFAULT_GF_INTERVAL;
 795   cpi->ref_frame_flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
 796
 797   cpi->refresh_golden_frame = 0;
 798   cpi->refresh_last_frame = 1;
 799   cm->refresh_frame_context = 1;
 800   cm->reset_frame_context = 0;
 801
 802   vp9_reset_segment_features(&cm->seg);
 803   set_high_precision_mv(cpi, 0);
 804
 805   {
 806     int i;
 807
 808     for (i = 0; i < MAX_SEGMENTS; i++)
 809       cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
 810   }
 811   cpi->encode_breakout = cpi->oxcf.encode_breakout;
 812
 813   // local file playback mode == really big buffer
 814   if (cpi->oxcf.end_usage == USAGE_LOCAL_FILE_PLAYBACK) {
 815     cpi->oxcf.starting_buffer_level   = 60000;
 816     cpi->oxcf.optimal_buffer_level    = 60000;
 817     cpi->oxcf.maximum_buffer_size     = 240000;
 818   }
 819
 820   // Convert target bandwidth from Kbit/s to Bit/s
 821   cpi->oxcf.target_bandwidth       *= 1000;
 822
 823   cpi->oxcf.starting_buffer_level =
 824       vp9_rescale(cpi->oxcf.starting_buffer_level,
 825                   cpi->oxcf.target_bandwidth, 1000);
 826
 827   // Set or reset optimal and maximum buffer levels.
 828   if (cpi->oxcf.optimal_buffer_level == 0)
 829     cpi->oxcf.optimal_buffer_level = cpi->oxcf.target_bandwidth / 8;
 830   else
 831     cpi->oxcf.optimal_buffer_level =
 832         vp9_rescale(cpi->oxcf.optimal_buffer_level,
 833                     cpi->oxcf.target_bandwidth, 1000);
 834
 835   if (cpi->oxcf.maximum_buffer_size == 0)
 836     cpi->oxcf.maximum_buffer_size = cpi->oxcf.target_bandwidth / 8;
 837   else
 838     cpi->oxcf.maximum_buffer_size =
 839         vp9_rescale(cpi->oxcf.maximum_buffer_size,
 840                     cpi->oxcf.target_bandwidth, 1000);
 841   // Under a configuration change, where maximum_buffer_size may change,
 842   // keep buffer level clipped to the maximum allowed buffer size.
 843   rc->bits_off_target = MIN(rc->bits_off_target, cpi->oxcf.maximum_buffer_size);
 844   rc->buffer_level = MIN(rc->buffer_level, cpi->oxcf.maximum_buffer_size);
 845
 846   // Set up frame rate and related parameters rate control values.
 847   vp9_new_framerate(cpi, cpi->oxcf.framerate);
 848
 849   // Set absolute upper and lower quality limits
 850   rc->worst_quality = cpi->oxcf.worst_allowed_q;
 851   rc->best_quality = cpi->oxcf.best_allowed_q;
 852
 853   // active values should only be modified if out of new range
 854
 855   cpi->cq_target_quality = cpi->oxcf.cq_level;
 856
 857   cm->interp_filter = DEFAULT_INTERP_FILTER;
 858
 859   cm->display_width = cpi->oxcf.width;
 860   cm->display_height = cpi->oxcf.height;
 861
 862   // VP8 sharpness level mapping 0-7 (vs 0-10 in general VPx dialogs)
 863   cpi->oxcf.sharpness = MIN(7, cpi->oxcf.sharpness);
 864
 865   cpi->common.lf.sharpness_level = cpi->oxcf.sharpness;
 866
 867   if (cpi->initial_width) {
 868     // Increasing the size of the frame beyond the first seen frame, or some
 869     // otherwise signaled maximum size, is not supported.
 870     // TODO(jkoleszar): exit gracefully.
 871     assert(cm->width <= cpi->initial_width);
 872     assert(cm->height <= cpi->initial_height);
 873   }
 874   update_frame_size(cpi);
 875
 876   if ((cpi->svc.number_temporal_layers > 1 &&
 877       cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) ||
 878       (cpi->svc.number_spatial_layers > 1 && cpi->pass == 2)) {
 879     vp9_update_layer_context_change_config(cpi,
 880                                            (int)cpi->oxcf.target_bandwidth);
 881   }
 882
 883   cpi->speed = abs(cpi->oxcf.cpu_used);
 884
 885   // Limit on lag buffers as these are not currently dynamically allocated.
 886   if (cpi->oxcf.lag_in_frames > MAX_LAG_BUFFERS)
 887     cpi->oxcf.lag_in_frames = MAX_LAG_BUFFERS;
 888
 889 #if CONFIG_MULTIPLE_ARF
 890   vp9_zero(cpi->alt_ref_source);
 891 #else
 892   cpi->alt_ref_source = NULL;
 893 #endif
 894   rc->is_src_frame_alt_ref = 0;
 895
 896 #if 0
 897   // Experimental RD Code
 898   cpi->frame_distortion = 0;
 899   cpi->last_frame_distortion = 0;
 900 #endif
 901
 902   set_tile_limits(cpi);
 903
 904   cpi->ext_refresh_frame_flags_pending = 0;
 905   cpi->ext_refresh_frame_context_pending = 0;
 906 }
 907
 908 #ifndef M_LOG2_E
 909 #define M_LOG2_E 0.693147180559945309417
 910 #endif
 911 #define log2f(x) (log (x) / (float) M_LOG2_E)
 912
 913 static void cal_nmvjointsadcost(int *mvjointsadcost) {
 914   mvjointsadcost[0] = 600;
 915   mvjointsadcost[1] = 300;
 916   mvjointsadcost[2] = 300;
 917   mvjointsadcost[3] = 300;
 918 }
 919
 920 static void cal_nmvsadcosts(int *mvsadcost[2]) {
 921   int i = 1;
 922
 923   mvsadcost[0][0] = 0;
 924   mvsadcost[1][0] = 0;
 925
 926   do {
 927     double z = 256 * (2 * (log2f(8 * i) + .6));
 928     mvsadcost[0][i] = (int)z;
 929     mvsadcost[1][i] = (int)z;
 930     mvsadcost[0][-i] = (int)z;
 931     mvsadcost[1][-i] = (int)z;
 932   } while (++i <= MV_MAX);
 933 }
 934
 935 static void cal_nmvsadcosts_hp(int *mvsadcost[2]) {
 936   int i = 1;
 937
 938   mvsadcost[0][0] = 0;
 939   mvsadcost[1][0] = 0;
 940
 941   do {
 942     double z = 256 * (2 * (log2f(8 * i) + .6));
 943     mvsadcost[0][i] = (int)z;
 944     mvsadcost[1][i] = (int)z;
 945     mvsadcost[0][-i] = (int)z;
 946     mvsadcost[1][-i] = (int)z;
 947   } while (++i <= MV_MAX);
 948 }
 949
 950 static void alloc_mode_context(VP9_COMMON *cm, int num_4x4_blk,
 951                                PICK_MODE_CONTEXT *ctx) {
 952   int num_pix = num_4x4_blk << 4;
 953   int i, k;
 954   ctx->num_4x4_blk = num_4x4_blk;
 955
 956   CHECK_MEM_ERROR(cm, ctx->zcoeff_blk,
 957                   vpx_calloc(num_4x4_blk, sizeof(uint8_t)));
 958   for (i = 0; i < MAX_MB_PLANE; ++i) {
 959     for (k = 0; k < 3; ++k) {
 960       CHECK_MEM_ERROR(cm, ctx->coeff[i][k],
 961                       vpx_memalign(16, num_pix * sizeof(int16_t)));
 962       CHECK_MEM_ERROR(cm, ctx->qcoeff[i][k],
 963                       vpx_memalign(16, num_pix * sizeof(int16_t)));
 964       CHECK_MEM_ERROR(cm, ctx->dqcoeff[i][k],
 965                       vpx_memalign(16, num_pix * sizeof(int16_t)));
 966       CHECK_MEM_ERROR(cm, ctx->eobs[i][k],
 967                       vpx_memalign(16, num_pix * sizeof(uint16_t)));
 968       ctx->coeff_pbuf[i][k]   = ctx->coeff[i][k];
 969       ctx->qcoeff_pbuf[i][k]  = ctx->qcoeff[i][k];
 970       ctx->dqcoeff_pbuf[i][k] = ctx->dqcoeff[i][k];
 971       ctx->eobs_pbuf[i][k]    = ctx->eobs[i][k];
 972     }
 973   }
 974 }
 975
 976 static void free_mode_context(PICK_MODE_CONTEXT *ctx) {
 977   int i, k;
 978   vpx_free(ctx->zcoeff_blk);
 979   ctx->zcoeff_blk = 0;
 980   for (i = 0; i < MAX_MB_PLANE; ++i) {
 981     for (k = 0; k < 3; ++k) {
 982       vpx_free(ctx->coeff[i][k]);
 983       ctx->coeff[i][k] = 0;
 984       vpx_free(ctx->qcoeff[i][k]);
 985       ctx->qcoeff[i][k] = 0;
 986       vpx_free(ctx->dqcoeff[i][k]);
 987       ctx->dqcoeff[i][k] = 0;
 988       vpx_free(ctx->eobs[i][k]);
 989       ctx->eobs[i][k] = 0;
 990     }
 991   }
 992 }
 993
 994 static void init_pick_mode_context(VP9_COMP *cpi) {
 995   int i;
 996   VP9_COMMON *const cm = &cpi->common;
 997   MACROBLOCK *const x  = &cpi->mb;
 998
 999   for (i = 0; i < BLOCK_SIZES; ++i) {
1000     const int num_4x4_w = num_4x4_blocks_wide_lookup[i];
1001     const int num_4x4_h = num_4x4_blocks_high_lookup[i];
1002     const int num_4x4_blk = MAX(4, num_4x4_w * num_4x4_h);
1003     if (i < BLOCK_16X16) {
1004       for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1005         for (x->mb_index = 0; x->mb_index < 4; ++x->mb_index) {
1006           for (x->b_index = 0; x->b_index < 16 / num_4x4_blk; ++x->b_index) {
1007             PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1008             alloc_mode_context(cm, num_4x4_blk, ctx);
1009           }
1010         }
1011       }
1012     } else if (i < BLOCK_32X32) {
1013       for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1014         for (x->mb_index = 0; x->mb_index < 64 / num_4x4_blk; ++x->mb_index) {
1015           PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1016           ctx->num_4x4_blk = num_4x4_blk;
1017           alloc_mode_context(cm, num_4x4_blk, ctx);
1018         }
1019       }
1020     } else if (i < BLOCK_64X64) {
1021       for (x->sb_index = 0; x->sb_index < 256 / num_4x4_blk; ++x->sb_index) {
1022         PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1023         ctx->num_4x4_blk = num_4x4_blk;
1024         alloc_mode_context(cm, num_4x4_blk, ctx);
1025       }
1026     } else {
1027       PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1028       ctx->num_4x4_blk = num_4x4_blk;
1029       alloc_mode_context(cm, num_4x4_blk, ctx);
1030     }
1031   }
1032 }
1033
1034 static void free_pick_mode_context(MACROBLOCK *x) {
1035   int i;
1036
1037   for (i = 0; i < BLOCK_SIZES; ++i) {
1038     const int num_4x4_w = num_4x4_blocks_wide_lookup[i];
1039     const int num_4x4_h = num_4x4_blocks_high_lookup[i];
1040     const int num_4x4_blk = MAX(4, num_4x4_w * num_4x4_h);
1041     if (i < BLOCK_16X16) {
1042       for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1043         for (x->mb_index = 0; x->mb_index < 4; ++x->mb_index) {
1044           for (x->b_index = 0; x->b_index < 16 / num_4x4_blk; ++x->b_index) {
1045             PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1046             free_mode_context(ctx);
1047           }
1048         }
1049       }
1050     } else if (i < BLOCK_32X32) {
1051       for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1052         for (x->mb_index = 0; x->mb_index < 64 / num_4x4_blk; ++x->mb_index) {
1053           PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1054           free_mode_context(ctx);
1055         }
1056       }
1057     } else if (i < BLOCK_64X64) {
1058       for (x->sb_index = 0; x->sb_index < 256 / num_4x4_blk; ++x->sb_index) {
1059         PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1060         free_mode_context(ctx);
1061       }
1062     } else {
1063       PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1064       free_mode_context(ctx);
1065     }
1066   }
1067 }
1068
1069 VP9_COMP *vp9_create_compressor(VP9_CONFIG *oxcf) {
1070   int i, j;
1071   VP9_COMP *const cpi = vpx_memalign(32, sizeof(VP9_COMP));
1072   VP9_COMMON *const cm = cpi != NULL ? &cpi->common : NULL;
1073
1074   if (!cm)
1075     return NULL;
1076
1077   vp9_zero(*cpi);
1078
1079   if (setjmp(cm->error.jmp)) {
1080     cm->error.setjmp = 0;
1081     vp9_remove_compressor(cpi);
1082     return 0;
1083   }
1084
1085   cm->error.setjmp = 1;
1086
1087   CHECK_MEM_ERROR(cm, cpi->mb.ss, vpx_calloc(sizeof(search_site),
1088                                              (MAX_MVSEARCH_STEPS * 8) + 1));
1089
1090   vp9_rtcd();
1091
1092   cpi->use_svc = 0;
1093
1094   init_config(cpi, oxcf);
1095   vp9_rc_init(&cpi->oxcf, cpi->pass, &cpi->rc);
1096   init_pick_mode_context(cpi);
1097
1098   cm->current_video_frame = 0;
1099
1100   // Set reference frame sign bias for ALTREF frame to 1 (for now)
1101   cm->ref_frame_sign_bias[ALTREF_FRAME] = 1;
1102
1103   cpi->gold_is_last = 0;
1104   cpi->alt_is_last = 0;
1105   cpi->gold_is_alt = 0;
1106
1107   // Create the encoder segmentation map and set all entries to 0
1108   CHECK_MEM_ERROR(cm, cpi->segmentation_map,
1109                   vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1110
1111   // Create a complexity map used for rd adjustment
1112   CHECK_MEM_ERROR(cm, cpi->complexity_map,
1113                   vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1114
1115   // Create a map used for cyclic background refresh.
1116   CHECK_MEM_ERROR(cm, cpi->cyclic_refresh,
1117                   vp9_cyclic_refresh_alloc(cm->mi_rows, cm->mi_cols));
1118
1119   // And a place holder structure is the coding context
1120   // for use if we want to save and restore it
1121   CHECK_MEM_ERROR(cm, cpi->coding_context.last_frame_seg_map_copy,
1122                   vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1123
1124   CHECK_MEM_ERROR(cm, cpi->active_map, vpx_calloc(cm->MBs, 1));
1125   vpx_memset(cpi->active_map, 1, cm->MBs);
1126   cpi->active_map_enabled = 0;
1127
1128   for (i = 0; i < (sizeof(cpi->mbgraph_stats) /
1129                    sizeof(cpi->mbgraph_stats[0])); i++) {
1130     CHECK_MEM_ERROR(cm, cpi->mbgraph_stats[i].mb_stats,
1131                     vpx_calloc(cm->MBs *
1132                                sizeof(*cpi->mbgraph_stats[i].mb_stats), 1));
1133   }
1134
1135   /*Initialize the feed-forward activity masking.*/
1136   cpi->activity_avg = 90 << 12;
1137   cpi->key_frame_frequency = cpi->oxcf.key_freq;
1138   cpi->refresh_alt_ref_frame = 0;
1139
1140 #if CONFIG_MULTIPLE_ARF
1141   // Turn multiple ARF usage on/off. This is a quick hack for the initial test
1142   // version. It should eventually be set via the codec API.
1143   cpi->multi_arf_enabled = 1;
1144
1145   if (cpi->multi_arf_enabled) {
1146     cpi->sequence_number = 0;
1147     cpi->frame_coding_order_period = 0;
1148     vp9_zero(cpi->frame_coding_order);
1149     vp9_zero(cpi->arf_buffer_idx);
1150   }
1151 #endif
1152
1153   cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
1154 #if CONFIG_INTERNAL_STATS
1155   cpi->b_calculate_ssimg = 0;
1156
1157   cpi->count = 0;
1158   cpi->bytes = 0;
1159
1160   if (cpi->b_calculate_psnr) {
1161     cpi->total_y = 0.0;
1162     cpi->total_u = 0.0;
1163     cpi->total_v = 0.0;
1164     cpi->total = 0.0;
1165     cpi->total_sq_error = 0;
1166     cpi->total_samples = 0;
1167
1168     cpi->totalp_y = 0.0;
1169     cpi->totalp_u = 0.0;
1170     cpi->totalp_v = 0.0;
1171     cpi->totalp = 0.0;
1172     cpi->totalp_sq_error = 0;
1173     cpi->totalp_samples = 0;
1174
1175     cpi->tot_recode_hits = 0;
1176     cpi->summed_quality = 0;
1177     cpi->summed_weights = 0;
1178     cpi->summedp_quality = 0;
1179     cpi->summedp_weights = 0;
1180   }
1181
1182   if (cpi->b_calculate_ssimg) {
1183     cpi->total_ssimg_y = 0;
1184     cpi->total_ssimg_u = 0;
1185     cpi->total_ssimg_v = 0;
1186     cpi->total_ssimg_all = 0;
1187   }
1188
1189 #endif
1190
1191   cpi->first_time_stamp_ever = INT64_MAX;
1192
1193   cal_nmvjointsadcost(cpi->mb.nmvjointsadcost);
1194   cpi->mb.nmvcost[0] = &cpi->mb.nmvcosts[0][MV_MAX];
1195   cpi->mb.nmvcost[1] = &cpi->mb.nmvcosts[1][MV_MAX];
1196   cpi->mb.nmvsadcost[0] = &cpi->mb.nmvsadcosts[0][MV_MAX];
1197   cpi->mb.nmvsadcost[1] = &cpi->mb.nmvsadcosts[1][MV_MAX];
1198   cal_nmvsadcosts(cpi->mb.nmvsadcost);
1199
1200   cpi->mb.nmvcost_hp[0] = &cpi->mb.nmvcosts_hp[0][MV_MAX];
1201   cpi->mb.nmvcost_hp[1] = &cpi->mb.nmvcosts_hp[1][MV_MAX];
1202   cpi->mb.nmvsadcost_hp[0] = &cpi->mb.nmvsadcosts_hp[0][MV_MAX];
1203   cpi->mb.nmvsadcost_hp[1] = &cpi->mb.nmvsadcosts_hp[1][MV_MAX];
1204   cal_nmvsadcosts_hp(cpi->mb.nmvsadcost_hp);
1205
1206 #ifdef OUTPUT_YUV_SRC
1207   yuv_file = fopen("bd.yuv", "ab");
1208 #endif
1209 #ifdef OUTPUT_YUV_REC
1210   yuv_rec_file = fopen("rec.yuv", "wb");
1211 #endif
1212
1213 #if 0
1214   framepsnr = fopen("framepsnr.stt", "a");
1215   kf_list = fopen("kf_list.stt", "w");
1216 #endif
1217
1218   cpi->output_pkt_list = oxcf->output_pkt_list;
1219
1220   cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
1221
1222   if (cpi->pass == 1) {
1223     vp9_init_first_pass(cpi);
1224   } else if (cpi->pass == 2) {
1225     const size_t packet_sz = sizeof(FIRSTPASS_STATS);
1226     const int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz);
1227
1228     if (cpi->svc.number_spatial_layers > 1
1229         && cpi->svc.number_temporal_layers == 1) {
1230       FIRSTPASS_STATS *const stats = oxcf->two_pass_stats_in.buf;
1231       FIRSTPASS_STATS *stats_copy[VPX_SS_MAX_LAYERS] = {0};
1232       int i;
1233
1234       for (i = 0; i < oxcf->ss_number_layers; ++i) {
1235         FIRSTPASS_STATS *const last_packet_for_layer =
1236             &stats[packets - oxcf->ss_number_layers + i];
1237         const int layer_id = (int)last_packet_for_layer->spatial_layer_id;
1238         const int packets_in_layer = (int)last_packet_for_layer->count + 1;
1239         if (layer_id >= 0 && layer_id < oxcf->ss_number_layers) {
1240           LAYER_CONTEXT *const lc = &cpi->svc.layer_context[layer_id];
1241
1242           vpx_free(lc->rc_twopass_stats_in.buf);
1243
1244           lc->rc_twopass_stats_in.sz = packets_in_layer * packet_sz;
1245           CHECK_MEM_ERROR(cm, lc->rc_twopass_stats_in.buf,
1246                           vpx_malloc(lc->rc_twopass_stats_in.sz));
1247           lc->twopass.stats_in_start = lc->rc_twopass_stats_in.buf;
1248           lc->twopass.stats_in = lc->twopass.stats_in_start;
1249           lc->twopass.stats_in_end = lc->twopass.stats_in_start
1250                                      + packets_in_layer - 1;
1251           stats_copy[layer_id] = lc->rc_twopass_stats_in.buf;
1252         }
1253       }
1254
1255       for (i = 0; i < packets; ++i) {
1256         const int layer_id = (int)stats[i].spatial_layer_id;
1257         if (layer_id >= 0 && layer_id < oxcf->ss_number_layers
1258             && stats_copy[layer_id] != NULL) {
1259           *stats_copy[layer_id] = stats[i];
1260           ++stats_copy[layer_id];
1261         }
1262       }
1263
1264       vp9_init_second_pass_spatial_svc(cpi);
1265     } else {
1266       cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf;
1267       cpi->twopass.stats_in = cpi->twopass.stats_in_start;
1268       cpi->twopass.stats_in_end = &cpi->twopass.stats_in[packets - 1];
1269
1270       vp9_init_second_pass(cpi);
1271     }
1272   }
1273
1274   set_speed_features(cpi);
1275
1276   // Default rd threshold factors for mode selection
1277   for (i = 0; i < BLOCK_SIZES; ++i) {
1278     for (j = 0; j < MAX_MODES; ++j)
1279       cpi->rd_thresh_freq_fact[i][j] = 32;
1280     for (j = 0; j < MAX_REFS; ++j)
1281       cpi->rd_thresh_freq_sub8x8[i][j] = 32;
1282   }
1283
1284 #define BFP(BT, SDF, SDAF, VF, SVF, SVAF, SVFHH, SVFHV, SVFHHV, \
1285             SDX3F, SDX8F, SDX4DF)\
1286     cpi->fn_ptr[BT].sdf            = SDF; \
1287     cpi->fn_ptr[BT].sdaf           = SDAF; \
1288     cpi->fn_ptr[BT].vf             = VF; \
1289     cpi->fn_ptr[BT].svf            = SVF; \
1290     cpi->fn_ptr[BT].svaf           = SVAF; \
1291     cpi->fn_ptr[BT].svf_halfpix_h  = SVFHH; \
1292     cpi->fn_ptr[BT].svf_halfpix_v  = SVFHV; \
1293     cpi->fn_ptr[BT].svf_halfpix_hv = SVFHHV; \
1294     cpi->fn_ptr[BT].sdx3f          = SDX3F; \
1295     cpi->fn_ptr[BT].sdx8f          = SDX8F; \
1296     cpi->fn_ptr[BT].sdx4df         = SDX4DF;
1297
1298   BFP(BLOCK_32X16, vp9_sad32x16, vp9_sad32x16_avg,
1299       vp9_variance32x16, vp9_sub_pixel_variance32x16,
1300       vp9_sub_pixel_avg_variance32x16, NULL, NULL,
1301       NULL, NULL, NULL,
1302       vp9_sad32x16x4d)
1303
1304   BFP(BLOCK_16X32, vp9_sad16x32, vp9_sad16x32_avg,
1305       vp9_variance16x32, vp9_sub_pixel_variance16x32,
1306       vp9_sub_pixel_avg_variance16x32, NULL, NULL,
1307       NULL, NULL, NULL,
1308       vp9_sad16x32x4d)
1309
1310   BFP(BLOCK_64X32, vp9_sad64x32, vp9_sad64x32_avg,
1311       vp9_variance64x32, vp9_sub_pixel_variance64x32,
1312       vp9_sub_pixel_avg_variance64x32, NULL, NULL,
1313       NULL, NULL, NULL,
1314       vp9_sad64x32x4d)
1315
1316   BFP(BLOCK_32X64, vp9_sad32x64, vp9_sad32x64_avg,
1317       vp9_variance32x64, vp9_sub_pixel_variance32x64,
1318       vp9_sub_pixel_avg_variance32x64, NULL, NULL,
1319       NULL, NULL, NULL,
1320       vp9_sad32x64x4d)
1321
1322   BFP(BLOCK_32X32, vp9_sad32x32, vp9_sad32x32_avg,
1323       vp9_variance32x32, vp9_sub_pixel_variance32x32,
1324       vp9_sub_pixel_avg_variance32x32, vp9_variance_halfpixvar32x32_h,
1325       vp9_variance_halfpixvar32x32_v,
1326       vp9_variance_halfpixvar32x32_hv, vp9_sad32x32x3, vp9_sad32x32x8,
1327       vp9_sad32x32x4d)
1328
1329   BFP(BLOCK_64X64, vp9_sad64x64, vp9_sad64x64_avg,
1330       vp9_variance64x64, vp9_sub_pixel_variance64x64,
1331       vp9_sub_pixel_avg_variance64x64, vp9_variance_halfpixvar64x64_h,
1332       vp9_variance_halfpixvar64x64_v,
1333       vp9_variance_halfpixvar64x64_hv, vp9_sad64x64x3, vp9_sad64x64x8,
1334       vp9_sad64x64x4d)
1335
1336   BFP(BLOCK_16X16, vp9_sad16x16, vp9_sad16x16_avg,
1337       vp9_variance16x16, vp9_sub_pixel_variance16x16,
1338       vp9_sub_pixel_avg_variance16x16, vp9_variance_halfpixvar16x16_h,
1339       vp9_variance_halfpixvar16x16_v,
1340       vp9_variance_halfpixvar16x16_hv, vp9_sad16x16x3, vp9_sad16x16x8,
1341       vp9_sad16x16x4d)
1342
1343   BFP(BLOCK_16X8, vp9_sad16x8, vp9_sad16x8_avg,
1344       vp9_variance16x8, vp9_sub_pixel_variance16x8,
1345       vp9_sub_pixel_avg_variance16x8, NULL, NULL, NULL,
1346       vp9_sad16x8x3, vp9_sad16x8x8, vp9_sad16x8x4d)
1347
1348   BFP(BLOCK_8X16, vp9_sad8x16, vp9_sad8x16_avg,
1349       vp9_variance8x16, vp9_sub_pixel_variance8x16,
1350       vp9_sub_pixel_avg_variance8x16, NULL, NULL, NULL,
1351       vp9_sad8x16x3, vp9_sad8x16x8, vp9_sad8x16x4d)
1352
1353   BFP(BLOCK_8X8, vp9_sad8x8, vp9_sad8x8_avg,
1354       vp9_variance8x8, vp9_sub_pixel_variance8x8,
1355       vp9_sub_pixel_avg_variance8x8, NULL, NULL, NULL,
1356       vp9_sad8x8x3, vp9_sad8x8x8, vp9_sad8x8x4d)
1357
1358   BFP(BLOCK_8X4, vp9_sad8x4, vp9_sad8x4_avg,
1359       vp9_variance8x4, vp9_sub_pixel_variance8x4,
1360       vp9_sub_pixel_avg_variance8x4, NULL, NULL,
1361       NULL, NULL, vp9_sad8x4x8,
1362       vp9_sad8x4x4d)
1363
1364   BFP(BLOCK_4X8, vp9_sad4x8, vp9_sad4x8_avg,
1365       vp9_variance4x8, vp9_sub_pixel_variance4x8,
1366       vp9_sub_pixel_avg_variance4x8, NULL, NULL,
1367       NULL, NULL, vp9_sad4x8x8,
1368       vp9_sad4x8x4d)
1369
1370   BFP(BLOCK_4X4, vp9_sad4x4, vp9_sad4x4_avg,
1371       vp9_variance4x4, vp9_sub_pixel_variance4x4,
1372       vp9_sub_pixel_avg_variance4x4, NULL, NULL, NULL,
1373       vp9_sad4x4x3, vp9_sad4x4x8, vp9_sad4x4x4d)
1374
1375   cpi->full_search_sad = vp9_full_search_sad;
1376   cpi->diamond_search_sad = vp9_diamond_search_sad;
1377   cpi->refining_search_sad = vp9_refining_search_sad;
1378
1379   /* vp9_init_quantizer() is first called here. Add check in
1380    * vp9_frame_init_quantizer() so that vp9_init_quantizer is only
1381    * called later when needed. This will avoid unnecessary calls of
1382    * vp9_init_quantizer() for every frame.
1383    */
1384   vp9_init_quantizer(cpi);
1385
1386   vp9_loop_filter_init(cm);
1387
1388   cm->error.setjmp = 0;
1389
1390   vp9_zero(cpi->common.counts.uv_mode);
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   vp9_rc_postencode_update(cpi, *size);
2663
2664   if (cm->frame_type == KEY_FRAME) {
2665     // Tell the caller that the frame was coded as a key frame
2666     *frame_flags = cm->frame_flags | FRAMEFLAGS_KEY;
2667
2668 #if CONFIG_MULTIPLE_ARF
2669     // Reset the sequence number.
2670     if (cpi->multi_arf_enabled) {
2671       cpi->sequence_number = 0;
2672       cpi->frame_coding_order_period = cpi->new_frame_coding_order_period;
2673       cpi->new_frame_coding_order_period = -1;
2674     }
2675 #endif
2676   } else {
2677     *frame_flags = cm->frame_flags&~FRAMEFLAGS_KEY;
2678
2679 #if CONFIG_MULTIPLE_ARF
2680     /* Increment position in the coded frame sequence. */
2681     if (cpi->multi_arf_enabled) {
2682       ++cpi->sequence_number;
2683       if (cpi->sequence_number >= cpi->frame_coding_order_period) {
2684         cpi->sequence_number = 0;
2685         cpi->frame_coding_order_period = cpi->new_frame_coding_order_period;
2686         cpi->new_frame_coding_order_period = -1;
2687       }
2688       cpi->this_frame_weight = cpi->arf_weight[cpi->sequence_number];
2689       assert(cpi->this_frame_weight >= 0);
2690     }
2691 #endif
2692   }
2693
2694   // Clear the one shot update flags for segmentation map and mode/ref loop
2695   // filter deltas.
2696   cm->seg.update_map = 0;
2697   cm->seg.update_data = 0;
2698   cm->lf.mode_ref_delta_update = 0;
2699
2700   // keep track of the last coded dimensions
2701   cm->last_width = cm->width;
2702   cm->last_height = cm->height;
2703
2704   // reset to normal state now that we are done.
2705   if (!cm->show_existing_frame)
2706     cm->last_show_frame = cm->show_frame;
2707
2708   if (cm->show_frame) {
2709     vp9_swap_mi_and_prev_mi(cm);
2710
2711     // Don't increment frame counters if this was an altref buffer
2712     // update not a real frame
2713     ++cm->current_video_frame;
2714     if (cpi->use_svc)
2715       vp9_inc_frame_in_layer(&cpi->svc);
2716   }
2717 }
2718
2719 static void SvcEncode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
2720                       unsigned int *frame_flags) {
2721   vp9_rc_get_svc_params(cpi);
2722   encode_frame_to_data_rate(cpi, size, dest, frame_flags);
2723 }
2724
2725 static void Pass0Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
2726                         unsigned int *frame_flags) {
2727   if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
2728     vp9_rc_get_one_pass_cbr_params(cpi);
2729   } else {
2730     vp9_rc_get_one_pass_vbr_params(cpi);
2731   }
2732   encode_frame_to_data_rate(cpi, size, dest, frame_flags);
2733 }
2734
2735 static void Pass1Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
2736                         unsigned int *frame_flags) {
2737   (void) size;
2738   (void) dest;
2739   (void) frame_flags;
2740
2741   vp9_rc_get_first_pass_params(cpi);
2742   vp9_set_quantizer(&cpi->common, find_fp_qindex());
2743   vp9_first_pass(cpi);
2744 }
2745
2746 static void Pass2Encode(VP9_COMP *cpi, size_t *size,
2747                         uint8_t *dest, unsigned int *frame_flags) {
2748   cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
2749
2750   vp9_rc_get_second_pass_params(cpi);
2751   encode_frame_to_data_rate(cpi, size, dest, frame_flags);
2752
2753   vp9_twopass_postencode_update(cpi);
2754 }
2755
2756 static void check_initial_width(VP9_COMP *cpi, int subsampling_x,
2757                                 int subsampling_y) {
2758   VP9_COMMON *const cm = &cpi->common;
2759
2760   if (!cpi->initial_width) {
2761     cm->subsampling_x = subsampling_x;
2762     cm->subsampling_y = subsampling_y;
2763     alloc_raw_frame_buffers(cpi);
2764     cpi->initial_width = cm->width;
2765     cpi->initial_height = cm->height;
2766   }
2767 }
2768
2769
2770 int vp9_receive_raw_frame(VP9_COMP *cpi, unsigned int frame_flags,
2771                           YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
2772                           int64_t end_time) {
2773   VP9_COMMON *cm = &cpi->common;
2774   struct vpx_usec_timer timer;
2775   int res = 0;
2776   const int subsampling_x = sd->uv_width  < sd->y_width;
2777   const int subsampling_y = sd->uv_height < sd->y_height;
2778
2779   check_initial_width(cpi, subsampling_x, subsampling_y);
2780   vpx_usec_timer_start(&timer);
2781   if (vp9_lookahead_push(cpi->lookahead,
2782                          sd, time_stamp, end_time, frame_flags))
2783     res = -1;
2784   vpx_usec_timer_mark(&timer);
2785   cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
2786
2787   if (cm->profile == PROFILE_0 && (subsampling_x != 1 || subsampling_y != 1)) {
2788     vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
2789                        "Non-4:2:0 color space requires profile >= 1");
2790     res = -1;
2791   }
2792
2793   return res;
2794 }
2795
2796
2797 static int frame_is_reference(const VP9_COMP *cpi) {
2798   const VP9_COMMON *cm = &cpi->common;
2799
2800   return cm->frame_type == KEY_FRAME ||
2801          cpi->refresh_last_frame ||
2802          cpi->refresh_golden_frame ||
2803          cpi->refresh_alt_ref_frame ||
2804          cm->refresh_frame_context ||
2805          cm->lf.mode_ref_delta_update ||
2806          cm->seg.update_map ||
2807          cm->seg.update_data;
2808 }
2809
2810 #if CONFIG_MULTIPLE_ARF
2811 int is_next_frame_arf(VP9_COMP *cpi) {
2812   // Negative entry in frame_coding_order indicates an ARF at this position.
2813   return cpi->frame_coding_order[cpi->sequence_number + 1] < 0 ? 1 : 0;
2814 }
2815 #endif
2816
2817 void adjust_frame_rate(VP9_COMP *cpi) {
2818   int64_t this_duration;
2819   int step = 0;
2820
2821   if (cpi->source->ts_start == cpi->first_time_stamp_ever) {
2822     this_duration = cpi->source->ts_end - cpi->source->ts_start;
2823     step = 1;
2824   } else {
2825     int64_t last_duration = cpi->last_end_time_stamp_seen
2826         - cpi->last_time_stamp_seen;
2827
2828     this_duration = cpi->source->ts_end - cpi->last_end_time_stamp_seen;
2829
2830     // do a step update if the duration changes by 10%
2831     if (last_duration)
2832       step = (int)((this_duration - last_duration) * 10 / last_duration);
2833   }
2834
2835   if (this_duration) {
2836     if (step) {
2837       vp9_new_framerate(cpi, 10000000.0 / this_duration);
2838     } else {
2839       // Average this frame's rate into the last second's average
2840       // frame rate. If we haven't seen 1 second yet, then average
2841       // over the whole interval seen.
2842       const double interval = MIN((double)(cpi->source->ts_end
2843                                    - cpi->first_time_stamp_ever), 10000000.0);
2844       double avg_duration = 10000000.0 / cpi->oxcf.framerate;
2845       avg_duration *= (interval - avg_duration + this_duration);
2846       avg_duration /= interval;
2847
2848       vp9_new_framerate(cpi, 10000000.0 / avg_duration);
2849     }
2850   }
2851   cpi->last_time_stamp_seen = cpi->source->ts_start;
2852   cpi->last_end_time_stamp_seen = cpi->source->ts_end;
2853 }
2854
2855 int vp9_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags,
2856                             size_t *size, uint8_t *dest,
2857                             int64_t *time_stamp, int64_t *time_end, int flush) {
2858   VP9_COMMON *const cm = &cpi->common;
2859   MACROBLOCKD *const xd = &cpi->mb.e_mbd;
2860   RATE_CONTROL *const rc = &cpi->rc;
2861   struct vpx_usec_timer  cmptimer;
2862   YV12_BUFFER_CONFIG *force_src_buffer = NULL;
2863   MV_REFERENCE_FRAME ref_frame;
2864
2865   if (!cpi)
2866     return -1;
2867
2868   if (cpi->svc.number_spatial_layers > 1 && cpi->pass == 2) {
2869     vp9_restore_layer_context(cpi);
2870   }
2871
2872   vpx_usec_timer_start(&cmptimer);
2873
2874   cpi->source = NULL;
2875   cpi->last_source = NULL;
2876
2877   set_high_precision_mv(cpi, ALTREF_HIGH_PRECISION_MV);
2878
2879   // Normal defaults
2880   cm->reset_frame_context = 0;
2881   cm->refresh_frame_context = 1;
2882   cpi->refresh_last_frame = 1;
2883   cpi->refresh_golden_frame = 0;
2884   cpi->refresh_alt_ref_frame = 0;
2885
2886   // Should we code an alternate reference frame.
2887   if (cpi->oxcf.play_alternate && rc->source_alt_ref_pending) {
2888     int frames_to_arf;
2889
2890 #if CONFIG_MULTIPLE_ARF
2891     assert(!cpi->multi_arf_enabled ||
2892            cpi->frame_coding_order[cpi->sequence_number] < 0);
2893
2894     if (cpi->multi_arf_enabled && (cpi->pass == 2))
2895       frames_to_arf = (-cpi->frame_coding_order[cpi->sequence_number])
2896           - cpi->next_frame_in_order;
2897     else
2898 #endif
2899       frames_to_arf = rc->frames_till_gf_update_due;
2900
2901     assert(frames_to_arf <= rc->frames_to_key);
2902
2903     if ((cpi->source = vp9_lookahead_peek(cpi->lookahead, frames_to_arf))) {
2904 #if CONFIG_MULTIPLE_ARF
2905       cpi->alt_ref_source[cpi->arf_buffered] = cpi->source;
2906 #else
2907       cpi->alt_ref_source = cpi->source;
2908 #endif
2909
2910       if (cpi->oxcf.arnr_max_frames > 0) {
2911         // Produce the filtered ARF frame.
2912         // TODO(agrange) merge these two functions.
2913         vp9_configure_arnr_filter(cpi, frames_to_arf, rc->gfu_boost);
2914         vp9_temporal_filter_prepare(cpi, frames_to_arf);
2915         vp9_extend_frame_borders(&cpi->alt_ref_buffer);
2916         force_src_buffer = &cpi->alt_ref_buffer;
2917       }
2918
2919       cm->show_frame = 0;
2920       cpi->refresh_alt_ref_frame = 1;
2921       cpi->refresh_golden_frame = 0;
2922       cpi->refresh_last_frame = 0;
2923       rc->is_src_frame_alt_ref = 0;
2924
2925 #if CONFIG_MULTIPLE_ARF
2926       if (!cpi->multi_arf_enabled)
2927 #endif
2928         rc->source_alt_ref_pending = 0;
2929     } else {
2930       rc->source_alt_ref_pending = 0;
2931     }
2932   }
2933
2934   if (!cpi->source) {
2935 #if CONFIG_MULTIPLE_ARF
2936     int i;
2937 #endif
2938
2939     // Get last frame source.
2940     if (cm->current_video_frame > 0) {
2941       if ((cpi->last_source = vp9_lookahead_peek(cpi->lookahead, -1)) == NULL)
2942         return -1;
2943     }
2944
2945     if ((cpi->source = vp9_lookahead_pop(cpi->lookahead, flush))) {
2946       cm->show_frame = 1;
2947       cm->intra_only = 0;
2948
2949 #if CONFIG_MULTIPLE_ARF
2950       // Is this frame the ARF overlay.
2951       rc->is_src_frame_alt_ref = 0;
2952       for (i = 0; i < cpi->arf_buffered; ++i) {
2953         if (cpi->source == cpi->alt_ref_source[i]) {
2954           rc->is_src_frame_alt_ref = 1;
2955           cpi->refresh_golden_frame = 1;
2956           break;
2957         }
2958       }
2959 #else
2960       rc->is_src_frame_alt_ref = cpi->alt_ref_source &&
2961                                  (cpi->source == cpi->alt_ref_source);
2962 #endif
2963       if (rc->is_src_frame_alt_ref) {
2964         // Current frame is an ARF overlay frame.
2965 #if CONFIG_MULTIPLE_ARF
2966         cpi->alt_ref_source[i] = NULL;
2967 #else
2968         cpi->alt_ref_source = NULL;
2969 #endif
2970         // Don't refresh the last buffer for an ARF overlay frame. It will
2971         // become the GF so preserve last as an alternative prediction option.
2972         cpi->refresh_last_frame = 0;
2973       }
2974 #if CONFIG_MULTIPLE_ARF
2975       ++cpi->next_frame_in_order;
2976 #endif
2977     }
2978   }
2979
2980   if (cpi->source) {
2981     cpi->un_scaled_source = cpi->Source = force_src_buffer ? force_src_buffer
2982                                                            : &cpi->source->img;
2983
2984   if (cpi->last_source != NULL) {
2985     cpi->unscaled_last_source = &cpi->last_source->img;
2986   } else {
2987     cpi->unscaled_last_source = NULL;
2988   }
2989
2990     *time_stamp = cpi->source->ts_start;
2991     *time_end = cpi->source->ts_end;
2992     *frame_flags = cpi->source->flags;
2993
2994 #if CONFIG_MULTIPLE_ARF
2995     if (cm->frame_type != KEY_FRAME && cpi->pass == 2)
2996       rc->source_alt_ref_pending = is_next_frame_arf(cpi);
2997 #endif
2998   } else {
2999     *size = 0;
3000     if (flush && cpi->pass == 1 && !cpi->twopass.first_pass_done) {
3001       vp9_end_first_pass(cpi);    /* get last stats packet */
3002       cpi->twopass.first_pass_done = 1;
3003     }
3004     return -1;
3005   }
3006
3007   if (cpi->source->ts_start < cpi->first_time_stamp_ever) {
3008     cpi->first_time_stamp_ever = cpi->source->ts_start;
3009     cpi->last_end_time_stamp_seen = cpi->source->ts_start;
3010   }
3011
3012   // adjust frame rates based on timestamps given
3013   if (cm->show_frame) {
3014     adjust_frame_rate(cpi);
3015   }
3016
3017   if (cpi->svc.number_temporal_layers > 1 &&
3018       cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
3019     vp9_update_temporal_layer_framerate(cpi);
3020     vp9_restore_layer_context(cpi);
3021   }
3022
3023   // start with a 0 size frame
3024   *size = 0;
3025
3026   // Clear down mmx registers
3027   vp9_clear_system_state();
3028
3029   /* find a free buffer for the new frame, releasing the reference previously
3030    * held.
3031    */
3032   cm->frame_bufs[cm->new_fb_idx].ref_count--;
3033   cm->new_fb_idx = get_free_fb(cm);
3034
3035 #if CONFIG_MULTIPLE_ARF
3036   /* Set up the correct ARF frame. */
3037   if (cpi->refresh_alt_ref_frame) {
3038     ++cpi->arf_buffered;
3039   }
3040   if (cpi->multi_arf_enabled && (cm->frame_type != KEY_FRAME) &&
3041       (cpi->pass == 2)) {
3042     cpi->alt_fb_idx = cpi->arf_buffer_idx[cpi->sequence_number];
3043   }
3044 #endif
3045
3046   cm->frame_flags = *frame_flags;
3047
3048   // Reset the frame pointers to the current frame size
3049   vp9_realloc_frame_buffer(get_frame_new_buffer(cm),
3050                            cm->width, cm->height,
3051                            cm->subsampling_x, cm->subsampling_y,
3052                            VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL);
3053
3054   for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3055     const int idx = cm->ref_frame_map[get_ref_frame_idx(cpi, ref_frame)];
3056     YV12_BUFFER_CONFIG *const buf = &cm->frame_bufs[idx].buf;
3057     RefBuffer *const ref_buf = &cm->frame_refs[ref_frame - 1];
3058     ref_buf->buf = buf;
3059     ref_buf->idx = idx;
3060     vp9_setup_scale_factors_for_frame(&ref_buf->sf,
3061                                       buf->y_crop_width, buf->y_crop_height,
3062                                       cm->width, cm->height);
3063
3064     if (vp9_is_scaled(&ref_buf->sf))
3065       vp9_extend_frame_borders(buf);
3066   }
3067
3068   set_ref_ptrs(cm, xd, LAST_FRAME, LAST_FRAME);
3069
3070   if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
3071     vp9_vaq_init();
3072   }
3073
3074   if (cpi->pass == 1 &&
3075       (!cpi->use_svc || cpi->svc.number_temporal_layers == 1)) {
3076     Pass1Encode(cpi, size, dest, frame_flags);
3077   } else if (cpi->pass == 2 &&
3078       (!cpi->use_svc || cpi->svc.number_temporal_layers == 1)) {
3079     Pass2Encode(cpi, size, dest, frame_flags);
3080   } else if (cpi->use_svc) {
3081     SvcEncode(cpi, size, dest, frame_flags);
3082   } else {
3083     // One pass encode
3084     Pass0Encode(cpi, size, dest, frame_flags);
3085   }
3086
3087   if (cm->refresh_frame_context)
3088     cm->frame_contexts[cm->frame_context_idx] = cm->fc;
3089
3090   // Frame was dropped, release scaled references.
3091   if (*size == 0) {
3092     release_scaled_references(cpi);
3093   }
3094
3095   if (*size > 0) {
3096     cpi->droppable = !frame_is_reference(cpi);
3097   }
3098
3099   // Save layer specific state.
3100   if ((cpi->svc.number_temporal_layers > 1 &&
3101       cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) ||
3102       (cpi->svc.number_spatial_layers > 1 && cpi->pass == 2)) {
3103     vp9_save_layer_context(cpi);
3104   }
3105
3106   vpx_usec_timer_mark(&cmptimer);
3107   cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
3108
3109   if (cpi->b_calculate_psnr && cpi->pass != 1 && cm->show_frame)
3110     generate_psnr_packet(cpi);
3111
3112 #if CONFIG_INTERNAL_STATS
3113
3114   if (cpi->pass != 1) {
3115     cpi->bytes += (int)(*size);
3116
3117     if (cm->show_frame) {
3118       cpi->count++;
3119
3120       if (cpi->b_calculate_psnr) {
3121         YV12_BUFFER_CONFIG *orig = cpi->Source;
3122         YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
3123         YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer;
3124         PSNR_STATS psnr;
3125         calc_psnr(orig, recon, &psnr);
3126
3127         cpi->total += psnr.psnr[0];
3128         cpi->total_y += psnr.psnr[1];
3129         cpi->total_u += psnr.psnr[2];
3130         cpi->total_v += psnr.psnr[3];
3131         cpi->total_sq_error += psnr.sse[0];
3132         cpi->total_samples += psnr.samples[0];
3133
3134         {
3135           PSNR_STATS psnr2;
3136           double frame_ssim2 = 0, weight = 0;
3137 #if CONFIG_VP9_POSTPROC
3138           vp9_deblock(cm->frame_to_show, &cm->post_proc_buffer,
3139                       cm->lf.filter_level * 10 / 6);
3140 #endif
3141           vp9_clear_system_state();
3142
3143           calc_psnr(orig, pp, &psnr2);
3144
3145           cpi->totalp += psnr2.psnr[0];
3146           cpi->totalp_y += psnr2.psnr[1];
3147           cpi->totalp_u += psnr2.psnr[2];
3148           cpi->totalp_v += psnr2.psnr[3];
3149           cpi->totalp_sq_error += psnr2.sse[0];
3150           cpi->totalp_samples += psnr2.samples[0];
3151
3152           frame_ssim2 = vp9_calc_ssim(orig, recon, 1, &weight);
3153
3154           cpi->summed_quality += frame_ssim2 * weight;
3155           cpi->summed_weights += weight;
3156
3157           frame_ssim2 = vp9_calc_ssim(orig, &cm->post_proc_buffer, 1, &weight);
3158
3159           cpi->summedp_quality += frame_ssim2 * weight;
3160           cpi->summedp_weights += weight;
3161 #if 0
3162           {
3163             FILE *f = fopen("q_used.stt", "a");
3164             fprintf(f, "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n",
3165                     cpi->common.current_video_frame, y2, u2, v2,
3166                     frame_psnr2, frame_ssim2);
3167             fclose(f);
3168           }
3169 #endif
3170         }
3171       }
3172
3173       if (cpi->b_calculate_ssimg) {
3174         double y, u, v, frame_all;
3175         frame_all = vp9_calc_ssimg(cpi->Source, cm->frame_to_show, &y, &u, &v);
3176         cpi->total_ssimg_y += y;
3177         cpi->total_ssimg_u += u;
3178         cpi->total_ssimg_v += v;
3179         cpi->total_ssimg_all += frame_all;
3180       }
3181     }
3182   }
3183
3184 #endif
3185   return 0;
3186 }
3187
3188 int vp9_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
3189                               vp9_ppflags_t *flags) {
3190   VP9_COMMON *cm = &cpi->common;
3191
3192   if (!cm->show_frame) {
3193     return -1;
3194   } else {
3195     int ret;
3196 #if CONFIG_VP9_POSTPROC
3197     ret = vp9_post_proc_frame(cm, dest, flags);
3198 #else
3199
3200     if (cm->frame_to_show) {
3201       *dest = *cm->frame_to_show;
3202       dest->y_width = cm->width;
3203       dest->y_height = cm->height;
3204       dest->uv_width = cm->width >> cm->subsampling_x;
3205       dest->uv_height = cm->height >> cm->subsampling_y;
3206       ret = 0;
3207     } else {
3208       ret = -1;
3209     }
3210
3211 #endif  // !CONFIG_VP9_POSTPROC
3212     vp9_clear_system_state();
3213     return ret;
3214   }
3215 }
3216
3217 int vp9_set_roimap(VP9_COMP *cpi, unsigned char *map, unsigned int rows,
3218                    unsigned int cols, int delta_q[MAX_SEGMENTS],
3219                    int delta_lf[MAX_SEGMENTS],
3220                    unsigned int threshold[MAX_SEGMENTS]) {
3221   signed char feature_data[SEG_LVL_MAX][MAX_SEGMENTS];
3222   struct segmentation *seg = &cpi->common.seg;
3223   int i;
3224
3225   if (cpi->common.mb_rows != rows || cpi->common.mb_cols != cols)
3226     return -1;
3227
3228   if (!map) {
3229     vp9_disable_segmentation(seg);
3230     return 0;
3231   }
3232
3233   // Set the segmentation Map
3234   vp9_set_segmentation_map(cpi, map);
3235
3236   // Activate segmentation.
3237   vp9_enable_segmentation(seg);
3238
3239   // Set up the quant, LF and breakout threshold segment data
3240   for (i = 0; i < MAX_SEGMENTS; i++) {
3241     feature_data[SEG_LVL_ALT_Q][i] = delta_q[i];
3242     feature_data[SEG_LVL_ALT_LF][i] = delta_lf[i];
3243     cpi->segment_encode_breakout[i] = threshold[i];
3244   }
3245
3246   // Enable the loop and quant changes in the feature mask
3247   for (i = 0; i < MAX_SEGMENTS; i++) {
3248     if (delta_q[i])
3249       vp9_enable_segfeature(seg, i, SEG_LVL_ALT_Q);
3250     else
3251       vp9_disable_segfeature(seg, i, SEG_LVL_ALT_Q);
3252
3253     if (delta_lf[i])
3254       vp9_enable_segfeature(seg, i, SEG_LVL_ALT_LF);
3255     else
3256       vp9_disable_segfeature(seg, i, SEG_LVL_ALT_LF);
3257   }
3258
3259   // Initialize the feature data structure
3260   // SEGMENT_DELTADATA    0, SEGMENT_ABSDATA      1
3261   vp9_set_segment_data(seg, &feature_data[0][0], SEGMENT_DELTADATA);
3262
3263   return 0;
3264 }
3265
3266 int vp9_set_active_map(VP9_COMP *cpi, unsigned char *map,
3267                        unsigned int rows, unsigned int cols) {
3268   if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols) {
3269     if (map) {
3270       vpx_memcpy(cpi->active_map, map, rows * cols);
3271       cpi->active_map_enabled = 1;
3272     } else {
3273       cpi->active_map_enabled = 0;
3274     }
3275
3276     return 0;
3277   } else {
3278     // cpi->active_map_enabled = 0;
3279     return -1;
3280   }
3281 }
3282
3283 int vp9_set_internal_size(VP9_COMP *cpi,
3284                           VPX_SCALING horiz_mode, VPX_SCALING vert_mode) {
3285   VP9_COMMON *cm = &cpi->common;
3286   int hr = 0, hs = 0, vr = 0, vs = 0;
3287
3288   if (horiz_mode > ONETWO || vert_mode > ONETWO)
3289     return -1;
3290
3291   Scale2Ratio(horiz_mode, &hr, &hs);
3292   Scale2Ratio(vert_mode, &vr, &vs);
3293
3294   // always go to the next whole number
3295   cm->width = (hs - 1 + cpi->oxcf.width * hr) / hs;
3296   cm->height = (vs - 1 + cpi->oxcf.height * vr) / vs;
3297
3298   assert(cm->width <= cpi->initial_width);
3299   assert(cm->height <= cpi->initial_height);
3300   update_frame_size(cpi);
3301   return 0;
3302 }
3303
3304 int vp9_set_size_literal(VP9_COMP *cpi, unsigned int width,
3305                          unsigned int height) {
3306   VP9_COMMON *cm = &cpi->common;
3307
3308   check_initial_width(cpi, 1, 1);
3309
3310   if (width) {
3311     cm->width = width;
3312     if (cm->width * 5 < cpi->initial_width) {
3313       cm->width = cpi->initial_width / 5 + 1;
3314       printf("Warning: Desired width too small, changed to %d\n", cm->width);
3315     }
3316     if (cm->width > cpi->initial_width) {
3317       cm->width = cpi->initial_width;
3318       printf("Warning: Desired width too large, changed to %d\n", cm->width);
3319     }
3320   }
3321
3322   if (height) {
3323     cm->height = height;
3324     if (cm->height * 5 < cpi->initial_height) {
3325       cm->height = cpi->initial_height / 5 + 1;
3326       printf("Warning: Desired height too small, changed to %d\n", cm->height);
3327     }
3328     if (cm->height > cpi->initial_height) {
3329       cm->height = cpi->initial_height;
3330       printf("Warning: Desired height too large, changed to %d\n", cm->height);
3331     }
3332   }
3333
3334   assert(cm->width <= cpi->initial_width);
3335   assert(cm->height <= cpi->initial_height);
3336   update_frame_size(cpi);
3337   return 0;
3338 }
3339
3340 void vp9_set_svc(VP9_COMP *cpi, int use_svc) {
3341   cpi->use_svc = use_svc;
3342   return;
3343 }
3344
3345 int vp9_get_y_sse(const YV12_BUFFER_CONFIG *a, const YV12_BUFFER_CONFIG *b) {
3346   assert(a->y_crop_width == b->y_crop_width);
3347   assert(a->y_crop_height == b->y_crop_height);
3348
3349   return (int)get_sse(a->y_buffer, a->y_stride, b->y_buffer, b->y_stride,
3350                       a->y_crop_width, a->y_crop_height);
3351 }
3352
3353
3354 int vp9_get_quantizer(VP9_COMP *cpi) {
3355   return cpi->common.base_qindex;
3356 }