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
  18 #include "vp9/common/vp9_alloccommon.h"
  19 #include "vp9/common/vp9_filter.h"
  20 #include "vp9/common/vp9_idct.h"
  21 #if CONFIG_VP9_POSTPROC
  22 #include "vp9/common/vp9_postproc.h"
  23 #endif
  24 #include "vp9/common/vp9_reconinter.h"
  25 #include "vp9/common/vp9_systemdependent.h"
  26 #include "vp9/common/vp9_tile_common.h"
  27 #include "vp9/encoder/vp9_firstpass.h"
  28 #include "vp9/encoder/vp9_mbgraph.h"
  29 #include "vp9/encoder/vp9_onyx_int.h"
  30 #include "vp9/encoder/vp9_picklpf.h"
  31 #include "vp9/encoder/vp9_psnr.h"
  32 #include "vp9/encoder/vp9_ratectrl.h"
  33 #include "vp9/encoder/vp9_rdopt.h"
  34 #include "vp9/encoder/vp9_segmentation.h"
  35 #include "vp9/encoder/vp9_temporal_filter.h"
  36 #include "vp9/encoder/vp9_vaq.h"
  37
  38 #include "vpx_ports/vpx_timer.h"
  39
  40
  41 extern void print_tree_update_probs();
  42
  43 static void set_default_lf_deltas(struct loopfilter *lf);
  44
  45 #define DEFAULT_INTERP_FILTER SWITCHABLE
  46
  47 #define SHARP_FILTER_QTHRESH 0          /* Q threshold for 8-tap sharp filter */
  48
  49 #define ALTREF_HIGH_PRECISION_MV 1      // Whether to use high precision mv
  50                                          //  for altref computation.
  51 #define HIGH_PRECISION_MV_QTHRESH 200   // Q threshold for high precision
  52                                          // mv. Choose a very high value for
  53                                          // now so that HIGH_PRECISION is always
  54                                          // chosen.
  55
  56 // Masks for partially or completely disabling split mode
  57 #define DISABLE_ALL_SPLIT         0x3F
  58 #define DISABLE_ALL_INTER_SPLIT   0x1F
  59 #define DISABLE_COMPOUND_SPLIT    0x18
  60 #define LAST_AND_INTRA_SPLIT_ONLY 0x1E
  61
  62 #if CONFIG_INTERNAL_STATS
  63 extern double vp9_calc_ssim(YV12_BUFFER_CONFIG *source,
  64                             YV12_BUFFER_CONFIG *dest, int lumamask,
  65                             double *weight);
  66
  67
  68 extern double vp9_calc_ssimg(YV12_BUFFER_CONFIG *source,
  69                              YV12_BUFFER_CONFIG *dest, double *ssim_y,
  70                              double *ssim_u, double *ssim_v);
  71
  72
  73 #endif
  74
  75 // #define OUTPUT_YUV_REC
  76
  77 #ifdef OUTPUT_YUV_SRC
  78 FILE *yuv_file;
  79 #endif
  80 #ifdef OUTPUT_YUV_REC
  81 FILE *yuv_rec_file;
  82 #endif
  83
  84 #if 0
  85 FILE *framepsnr;
  86 FILE *kf_list;
  87 FILE *keyfile;
  88 #endif
  89
  90
  91 #ifdef ENTROPY_STATS
  92 extern int intra_mode_stats[INTRA_MODES]
  93                            [INTRA_MODES]
  94                            [INTRA_MODES];
  95 #endif
  96
  97 #ifdef MODE_STATS
  98 extern void init_tx_count_stats();
  99 extern void write_tx_count_stats();
 100 extern void init_switchable_interp_stats();
 101 extern void write_switchable_interp_stats();
 102 #endif
 103
 104 #ifdef SPEEDSTATS
 105 unsigned int frames_at_speed[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 106                                     0, 0, 0};
 107 #endif
 108
 109 #if defined(SECTIONBITS_OUTPUT)
 110 extern unsigned __int64 Sectionbits[500];
 111 #endif
 112
 113 extern void vp9_init_quantizer(VP9_COMP *cpi);
 114
 115 // Tables relating active max Q to active min Q
 116 static int kf_low_motion_minq[QINDEX_RANGE];
 117 static int kf_high_motion_minq[QINDEX_RANGE];
 118 static int gf_low_motion_minq[QINDEX_RANGE];
 119 static int gf_high_motion_minq[QINDEX_RANGE];
 120 static int inter_minq[QINDEX_RANGE];
 121 static int afq_low_motion_minq[QINDEX_RANGE];
 122 static int afq_high_motion_minq[QINDEX_RANGE];
 123
 124 static INLINE void Scale2Ratio(int mode, int *hr, int *hs) {
 125   switch (mode) {
 126     case NORMAL:
 127       *hr = 1;
 128       *hs = 1;
 129       break;
 130     case FOURFIVE:
 131       *hr = 4;
 132       *hs = 5;
 133       break;
 134     case THREEFIVE:
 135       *hr = 3;
 136       *hs = 5;
 137     break;
 138     case ONETWO:
 139       *hr = 1;
 140       *hs = 2;
 141     break;
 142     default:
 143       *hr = 1;
 144       *hs = 1;
 145        assert(0);
 146       break;
 147   }
 148 }
 149
 150 // Functions to compute the active minq lookup table entries based on a
 151 // formulaic approach to facilitate easier adjustment of the Q tables.
 152 // The formulae were derived from computing a 3rd order polynomial best
 153 // fit to the original data (after plotting real maxq vs minq (not q index))
 154 static int calculate_minq_index(double maxq,
 155                                 double x3, double x2, double x1, double c) {
 156   int i;
 157   const double minqtarget = MIN(((x3 * maxq + x2) * maxq + x1) * maxq + c,
 158                                 maxq);
 159
 160   // Special case handling to deal with the step from q2.0
 161   // down to lossless mode represented by q 1.0.
 162   if (minqtarget <= 2.0)
 163     return 0;
 164
 165   for (i = 0; i < QINDEX_RANGE; i++) {
 166     if (minqtarget <= vp9_convert_qindex_to_q(i))
 167       return i;
 168   }
 169
 170   return QINDEX_RANGE - 1;
 171 }
 172
 173 static void init_minq_luts(void) {
 174   int i;
 175
 176   for (i = 0; i < QINDEX_RANGE; i++) {
 177     const double maxq = vp9_convert_qindex_to_q(i);
 178
 179
 180     kf_low_motion_minq[i] = calculate_minq_index(maxq,
 181                                                  0.000001,
 182                                                  -0.0004,
 183                                                  0.15,
 184                                                  0.0);
 185     kf_high_motion_minq[i] = calculate_minq_index(maxq,
 186                                                   0.000002,
 187                                                   -0.0012,
 188                                                   0.5,
 189                                                   0.0);
 190
 191     gf_low_motion_minq[i] = calculate_minq_index(maxq,
 192                                                  0.0000015,
 193                                                  -0.0009,
 194                                                  0.32,
 195                                                  0.0);
 196     gf_high_motion_minq[i] = calculate_minq_index(maxq,
 197                                                   0.0000021,
 198                                                   -0.00125,
 199                                                   0.50,
 200                                                   0.0);
 201     inter_minq[i] = calculate_minq_index(maxq,
 202                                          0.00000271,
 203                                          -0.00113,
 204                                          0.75,
 205                                          0.0);
 206     afq_low_motion_minq[i] = calculate_minq_index(maxq,
 207                                                   0.0000015,
 208                                                   -0.0009,
 209                                                   0.33,
 210                                                   0.0);
 211     afq_high_motion_minq[i] = calculate_minq_index(maxq,
 212                                                    0.0000021,
 213                                                    -0.00125,
 214                                                    0.55,
 215                                                    0.0);
 216   }
 217 }
 218
 219 static int get_active_quality(int q,
 220                               int gfu_boost,
 221                               int low,
 222                               int high,
 223                               int *low_motion_minq,
 224                               int *high_motion_minq) {
 225   int active_best_quality;
 226   if (gfu_boost > high) {
 227     active_best_quality = low_motion_minq[q];
 228   } else if (gfu_boost < low) {
 229     active_best_quality = high_motion_minq[q];
 230   } else {
 231     const int gap = high - low;
 232     const int offset = high - gfu_boost;
 233     const int qdiff = high_motion_minq[q] - low_motion_minq[q];
 234     const int adjustment = ((offset * qdiff) + (gap >> 1)) / gap;
 235     active_best_quality = low_motion_minq[q] + adjustment;
 236   }
 237   return active_best_quality;
 238 }
 239
 240 static void set_mvcost(VP9_COMP *cpi) {
 241   MACROBLOCK *const mb = &cpi->mb;
 242   if (cpi->common.allow_high_precision_mv) {
 243     mb->mvcost = mb->nmvcost_hp;
 244     mb->mvsadcost = mb->nmvsadcost_hp;
 245   } else {
 246     mb->mvcost = mb->nmvcost;
 247     mb->mvsadcost = mb->nmvsadcost;
 248   }
 249 }
 250
 251 void vp9_initialize_enc() {
 252   static int init_done = 0;
 253
 254   if (!init_done) {
 255     vp9_initialize_common();
 256     vp9_tokenize_initialize();
 257     vp9_init_quant_tables();
 258     vp9_init_me_luts();
 259     init_minq_luts();
 260     // init_base_skip_probs();
 261     init_done = 1;
 262   }
 263 }
 264
 265 static void setup_features(VP9_COMMON *cm) {
 266   struct loopfilter *const lf = &cm->lf;
 267   struct segmentation *const seg = &cm->seg;
 268
 269   // Set up default state for MB feature flags
 270   seg->enabled = 0;
 271
 272   seg->update_map = 0;
 273   seg->update_data = 0;
 274   vpx_memset(seg->tree_probs, 255, sizeof(seg->tree_probs));
 275
 276   vp9_clearall_segfeatures(seg);
 277
 278   lf->mode_ref_delta_enabled = 0;
 279   lf->mode_ref_delta_update = 0;
 280   vp9_zero(lf->ref_deltas);
 281   vp9_zero(lf->mode_deltas);
 282   vp9_zero(lf->last_ref_deltas);
 283   vp9_zero(lf->last_mode_deltas);
 284
 285   set_default_lf_deltas(lf);
 286 }
 287
 288 static void dealloc_compressor_data(VP9_COMP *cpi) {
 289   // Delete sementation map
 290   vpx_free(cpi->segmentation_map);
 291   cpi->segmentation_map = 0;
 292   vpx_free(cpi->common.last_frame_seg_map);
 293   cpi->common.last_frame_seg_map = 0;
 294   vpx_free(cpi->coding_context.last_frame_seg_map_copy);
 295   cpi->coding_context.last_frame_seg_map_copy = 0;
 296
 297   vpx_free(cpi->active_map);
 298   cpi->active_map = 0;
 299
 300   vp9_free_frame_buffers(&cpi->common);
 301
 302   vp9_free_frame_buffer(&cpi->last_frame_uf);
 303   vp9_free_frame_buffer(&cpi->scaled_source);
 304   vp9_free_frame_buffer(&cpi->alt_ref_buffer);
 305   vp9_lookahead_destroy(cpi->lookahead);
 306
 307   vpx_free(cpi->tok);
 308   cpi->tok = 0;
 309
 310   // Activity mask based per mb zbin adjustments
 311   vpx_free(cpi->mb_activity_map);
 312   cpi->mb_activity_map = 0;
 313   vpx_free(cpi->mb_norm_activity_map);
 314   cpi->mb_norm_activity_map = 0;
 315
 316   vpx_free(cpi->above_context[0]);
 317   cpi->above_context[0] = NULL;
 318
 319   vpx_free(cpi->above_seg_context);
 320   cpi->above_seg_context = NULL;
 321 }
 322
 323 // Computes a q delta (in "q index" terms) to get from a starting q value
 324 // to a target value
 325 // target q value
 326 int vp9_compute_qdelta(VP9_COMP *cpi, double qstart, double qtarget) {
 327   int i;
 328   int start_index = cpi->worst_quality;
 329   int target_index = cpi->worst_quality;
 330
 331   // Convert the average q value to an index.
 332   for (i = cpi->best_quality; i < cpi->worst_quality; i++) {
 333     start_index = i;
 334     if (vp9_convert_qindex_to_q(i) >= qstart)
 335       break;
 336   }
 337
 338   // Convert the q target to an index
 339   for (i = cpi->best_quality; i < cpi->worst_quality; i++) {
 340     target_index = i;
 341     if (vp9_convert_qindex_to_q(i) >= qtarget)
 342       break;
 343   }
 344
 345   return target_index - start_index;
 346 }
 347
 348 static void configure_static_seg_features(VP9_COMP *cpi) {
 349   VP9_COMMON *cm = &cpi->common;
 350   struct segmentation *seg = &cm->seg;
 351
 352   int high_q = (int)(cpi->avg_q > 48.0);
 353   int qi_delta;
 354
 355   // Disable and clear down for KF
 356   if (cm->frame_type == KEY_FRAME) {
 357     // Clear down the global segmentation map
 358     vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
 359     seg->update_map = 0;
 360     seg->update_data = 0;
 361     cpi->static_mb_pct = 0;
 362
 363     // Disable segmentation
 364     vp9_disable_segmentation((VP9_PTR)cpi);
 365
 366     // Clear down the segment features.
 367     vp9_clearall_segfeatures(seg);
 368   } else if (cpi->refresh_alt_ref_frame) {
 369     // If this is an alt ref frame
 370     // Clear down the global segmentation map
 371     vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
 372     seg->update_map = 0;
 373     seg->update_data = 0;
 374     cpi->static_mb_pct = 0;
 375
 376     // Disable segmentation and individual segment features by default
 377     vp9_disable_segmentation((VP9_PTR)cpi);
 378     vp9_clearall_segfeatures(seg);
 379
 380     // Scan frames from current to arf frame.
 381     // This function re-enables segmentation if appropriate.
 382     vp9_update_mbgraph_stats(cpi);
 383
 384     // If segmentation was enabled set those features needed for the
 385     // arf itself.
 386     if (seg->enabled) {
 387       seg->update_map = 1;
 388       seg->update_data = 1;
 389
 390       qi_delta = vp9_compute_qdelta(cpi, cpi->avg_q, (cpi->avg_q * 0.875));
 391       vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, (qi_delta - 2));
 392       vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2);
 393
 394       vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
 395       vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF);
 396
 397       // Where relevant assume segment data is delta data
 398       seg->abs_delta = SEGMENT_DELTADATA;
 399     }
 400   } else if (seg->enabled) {
 401     // All other frames if segmentation has been enabled
 402
 403     // First normal frame in a valid gf or alt ref group
 404     if (cpi->frames_since_golden == 0) {
 405       // Set up segment features for normal frames in an arf group
 406       if (cpi->source_alt_ref_active) {
 407         seg->update_map = 0;
 408         seg->update_data = 1;
 409         seg->abs_delta = SEGMENT_DELTADATA;
 410
 411         qi_delta = vp9_compute_qdelta(cpi, cpi->avg_q,
 412                                       (cpi->avg_q * 1.125));
 413         vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, (qi_delta + 2));
 414         vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
 415
 416         vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2);
 417         vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF);
 418
 419         // Segment coding disabled for compred testing
 420         if (high_q || (cpi->static_mb_pct == 100)) {
 421           vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
 422           vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
 423           vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP);
 424         }
 425       } else {
 426         // Disable segmentation and clear down features if alt ref
 427         // is not active for this group
 428
 429         vp9_disable_segmentation((VP9_PTR)cpi);
 430
 431         vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
 432
 433         seg->update_map = 0;
 434         seg->update_data = 0;
 435
 436         vp9_clearall_segfeatures(seg);
 437       }
 438     } else if (cpi->is_src_frame_alt_ref) {
 439       // Special case where we are coding over the top of a previous
 440       // alt ref frame.
 441       // Segment coding disabled for compred testing
 442
 443       // Enable ref frame features for segment 0 as well
 444       vp9_enable_segfeature(seg, 0, SEG_LVL_REF_FRAME);
 445       vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
 446
 447       // All mbs should use ALTREF_FRAME
 448       vp9_clear_segdata(seg, 0, SEG_LVL_REF_FRAME);
 449       vp9_set_segdata(seg, 0, SEG_LVL_REF_FRAME, ALTREF_FRAME);
 450       vp9_clear_segdata(seg, 1, SEG_LVL_REF_FRAME);
 451       vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
 452
 453       // Skip all MBs if high Q (0,0 mv and skip coeffs)
 454       if (high_q) {
 455         vp9_enable_segfeature(seg, 0, SEG_LVL_SKIP);
 456         vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP);
 457       }
 458       // Enable data update
 459       seg->update_data = 1;
 460     } else {
 461       // All other frames.
 462
 463       // No updates.. leave things as they are.
 464       seg->update_map = 0;
 465       seg->update_data = 0;
 466     }
 467   }
 468 }
 469
 470 #ifdef ENTROPY_STATS
 471 void vp9_update_mode_context_stats(VP9_COMP *cpi) {
 472   VP9_COMMON *cm = &cpi->common;
 473   int i, j;
 474   unsigned int (*inter_mode_counts)[INTER_MODES - 1][2] =
 475       cm->fc.inter_mode_counts;
 476   int64_t (*mv_ref_stats)[INTER_MODES - 1][2] = cpi->mv_ref_stats;
 477   FILE *f;
 478
 479   // Read the past stats counters
 480   f = fopen("mode_context.bin",  "rb");
 481   if (!f) {
 482     vpx_memset(cpi->mv_ref_stats, 0, sizeof(cpi->mv_ref_stats));
 483   } else {
 484     fread(cpi->mv_ref_stats, sizeof(cpi->mv_ref_stats), 1, f);
 485     fclose(f);
 486   }
 487
 488   // Add in the values for this frame
 489   for (i = 0; i < INTER_MODE_CONTEXTS; i++) {
 490     for (j = 0; j < INTER_MODES - 1; j++) {
 491       mv_ref_stats[i][j][0] += (int64_t)inter_mode_counts[i][j][0];
 492       mv_ref_stats[i][j][1] += (int64_t)inter_mode_counts[i][j][1];
 493     }
 494   }
 495
 496   // Write back the accumulated stats
 497   f = fopen("mode_context.bin",  "wb");
 498   fwrite(cpi->mv_ref_stats, sizeof(cpi->mv_ref_stats), 1, f);
 499   fclose(f);
 500 }
 501
 502 void print_mode_context(VP9_COMP *cpi) {
 503   FILE *f = fopen("vp9_modecont.c", "a");
 504   int i, j;
 505
 506   fprintf(f, "#include \"vp9_entropy.h\"\n");
 507   fprintf(
 508       f,
 509       "const int inter_mode_probs[INTER_MODE_CONTEXTS][INTER_MODES - 1] =");
 510   fprintf(f, "{\n");
 511   for (j = 0; j < INTER_MODE_CONTEXTS; j++) {
 512     fprintf(f, "  {/* %d */ ", j);
 513     fprintf(f, "    ");
 514     for (i = 0; i < INTER_MODES - 1; i++) {
 515       int this_prob;
 516       int64_t count = cpi->mv_ref_stats[j][i][0] + cpi->mv_ref_stats[j][i][1];
 517       if (count)
 518         this_prob = ((cpi->mv_ref_stats[j][i][0] * 256) + (count >> 1)) / count;
 519       else
 520         this_prob = 128;
 521
 522       // context probs
 523       fprintf(f, "%5d, ", this_prob);
 524     }
 525     fprintf(f, "  },\n");
 526   }
 527
 528   fprintf(f, "};\n");
 529   fclose(f);
 530 }
 531 #endif  // ENTROPY_STATS
 532
 533 // DEBUG: Print out the segment id of each MB in the current frame.
 534 static void print_seg_map(VP9_COMP *cpi) {
 535   VP9_COMMON *cm = &cpi->common;
 536   int row, col;
 537   int map_index = 0;
 538   FILE *statsfile = fopen("segmap.stt", "a");
 539
 540   fprintf(statsfile, "%10d\n", cm->current_video_frame);
 541
 542   for (row = 0; row < cpi->common.mi_rows; row++) {
 543     for (col = 0; col < cpi->common.mi_cols; col++) {
 544       fprintf(statsfile, "%10d", cpi->segmentation_map[map_index]);
 545       map_index++;
 546     }
 547     fprintf(statsfile, "\n");
 548   }
 549   fprintf(statsfile, "\n");
 550
 551   fclose(statsfile);
 552 }
 553
 554 static void update_reference_segmentation_map(VP9_COMP *cpi) {
 555   VP9_COMMON *const cm = &cpi->common;
 556   int row, col;
 557   MODE_INFO **mi_8x8, **mi_8x8_ptr = cm->mi_grid_visible;
 558   uint8_t *cache_ptr = cm->last_frame_seg_map, *cache;
 559
 560   for (row = 0; row < cm->mi_rows; row++) {
 561     mi_8x8 = mi_8x8_ptr;
 562     cache = cache_ptr;
 563     for (col = 0; col < cm->mi_cols; col++, mi_8x8++, cache++)
 564       cache[0] = mi_8x8[0]->mbmi.segment_id;
 565     mi_8x8_ptr += cm->mode_info_stride;
 566     cache_ptr += cm->mi_cols;
 567   }
 568 }
 569
 570 static void set_default_lf_deltas(struct loopfilter *lf) {
 571   lf->mode_ref_delta_enabled = 1;
 572   lf->mode_ref_delta_update = 1;
 573
 574   vp9_zero(lf->ref_deltas);
 575   vp9_zero(lf->mode_deltas);
 576
 577   // Test of ref frame deltas
 578   lf->ref_deltas[INTRA_FRAME] = 2;
 579   lf->ref_deltas[LAST_FRAME] = 0;
 580   lf->ref_deltas[GOLDEN_FRAME] = -2;
 581   lf->ref_deltas[ALTREF_FRAME] = -2;
 582
 583   lf->mode_deltas[0] = 0;   // Zero
 584   lf->mode_deltas[1] = 0;   // New mv
 585 }
 586
 587 static void set_rd_speed_thresholds(VP9_COMP *cpi, int mode) {
 588   SPEED_FEATURES *sf = &cpi->sf;
 589   int i;
 590
 591   // Set baseline threshold values
 592   for (i = 0; i < MAX_MODES; ++i)
 593     sf->thresh_mult[i] = mode == 0 ? -500 : 0;
 594
 595   sf->thresh_mult[THR_NEARESTMV] = 0;
 596   sf->thresh_mult[THR_NEARESTG] = 0;
 597   sf->thresh_mult[THR_NEARESTA] = 0;
 598
 599   sf->thresh_mult[THR_DC] += 1000;
 600
 601   sf->thresh_mult[THR_NEWMV] += 1000;
 602   sf->thresh_mult[THR_NEWA] += 1000;
 603   sf->thresh_mult[THR_NEWG] += 1000;
 604
 605   sf->thresh_mult[THR_NEARMV] += 1000;
 606   sf->thresh_mult[THR_NEARA] += 1000;
 607   sf->thresh_mult[THR_COMP_NEARESTLA] += 1000;
 608   sf->thresh_mult[THR_COMP_NEARESTGA] += 1000;
 609
 610   sf->thresh_mult[THR_TM] += 1000;
 611
 612   sf->thresh_mult[THR_COMP_NEARLA] += 1500;
 613   sf->thresh_mult[THR_COMP_NEWLA] += 2000;
 614   sf->thresh_mult[THR_NEARG] += 1000;
 615   sf->thresh_mult[THR_COMP_NEARGA] += 1500;
 616   sf->thresh_mult[THR_COMP_NEWGA] += 2000;
 617
 618   sf->thresh_mult[THR_ZEROMV] += 2000;
 619   sf->thresh_mult[THR_ZEROG] += 2000;
 620   sf->thresh_mult[THR_ZEROA] += 2000;
 621   sf->thresh_mult[THR_COMP_ZEROLA] += 2500;
 622   sf->thresh_mult[THR_COMP_ZEROGA] += 2500;
 623
 624   sf->thresh_mult[THR_H_PRED] += 2000;
 625   sf->thresh_mult[THR_V_PRED] += 2000;
 626   sf->thresh_mult[THR_D45_PRED ] += 2500;
 627   sf->thresh_mult[THR_D135_PRED] += 2500;
 628   sf->thresh_mult[THR_D117_PRED] += 2500;
 629   sf->thresh_mult[THR_D153_PRED] += 2500;
 630   sf->thresh_mult[THR_D207_PRED] += 2500;
 631   sf->thresh_mult[THR_D63_PRED] += 2500;
 632
 633   /* disable frame modes if flags not set */
 634   if (!(cpi->ref_frame_flags & VP9_LAST_FLAG)) {
 635     sf->thresh_mult[THR_NEWMV    ] = INT_MAX;
 636     sf->thresh_mult[THR_NEARESTMV] = INT_MAX;
 637     sf->thresh_mult[THR_ZEROMV   ] = INT_MAX;
 638     sf->thresh_mult[THR_NEARMV   ] = INT_MAX;
 639   }
 640   if (!(cpi->ref_frame_flags & VP9_GOLD_FLAG)) {
 641     sf->thresh_mult[THR_NEARESTG ] = INT_MAX;
 642     sf->thresh_mult[THR_ZEROG    ] = INT_MAX;
 643     sf->thresh_mult[THR_NEARG    ] = INT_MAX;
 644     sf->thresh_mult[THR_NEWG     ] = INT_MAX;
 645   }
 646   if (!(cpi->ref_frame_flags & VP9_ALT_FLAG)) {
 647     sf->thresh_mult[THR_NEARESTA ] = INT_MAX;
 648     sf->thresh_mult[THR_ZEROA    ] = INT_MAX;
 649     sf->thresh_mult[THR_NEARA    ] = INT_MAX;
 650     sf->thresh_mult[THR_NEWA     ] = INT_MAX;
 651   }
 652
 653   if ((cpi->ref_frame_flags & (VP9_LAST_FLAG | VP9_ALT_FLAG)) !=
 654       (VP9_LAST_FLAG | VP9_ALT_FLAG)) {
 655     sf->thresh_mult[THR_COMP_ZEROLA   ] = INT_MAX;
 656     sf->thresh_mult[THR_COMP_NEARESTLA] = INT_MAX;
 657     sf->thresh_mult[THR_COMP_NEARLA   ] = INT_MAX;
 658     sf->thresh_mult[THR_COMP_NEWLA    ] = INT_MAX;
 659   }
 660   if ((cpi->ref_frame_flags & (VP9_GOLD_FLAG | VP9_ALT_FLAG)) !=
 661       (VP9_GOLD_FLAG | VP9_ALT_FLAG)) {
 662     sf->thresh_mult[THR_COMP_ZEROGA   ] = INT_MAX;
 663     sf->thresh_mult[THR_COMP_NEARESTGA] = INT_MAX;
 664     sf->thresh_mult[THR_COMP_NEARGA   ] = INT_MAX;
 665     sf->thresh_mult[THR_COMP_NEWGA    ] = INT_MAX;
 666   }
 667 }
 668
 669 static void set_rd_speed_thresholds_sub8x8(VP9_COMP *cpi, int mode) {
 670   SPEED_FEATURES *sf = &cpi->sf;
 671   int i;
 672
 673   for (i = 0; i < MAX_REFS; ++i)
 674     sf->thresh_mult_sub8x8[i] = mode == 0 ? -500 : 0;
 675
 676   sf->thresh_mult_sub8x8[THR_LAST] += 2500;
 677   sf->thresh_mult_sub8x8[THR_GOLD] += 2500;
 678   sf->thresh_mult_sub8x8[THR_ALTR] += 2500;
 679   sf->thresh_mult_sub8x8[THR_INTRA] += 2500;
 680   sf->thresh_mult_sub8x8[THR_COMP_LA] += 4500;
 681   sf->thresh_mult_sub8x8[THR_COMP_GA] += 4500;
 682
 683   // Check for masked out split cases.
 684   for (i = 0; i < MAX_REFS; i++) {
 685     if (sf->disable_split_mask & (1 << i))
 686       sf->thresh_mult_sub8x8[i] = INT_MAX;
 687   }
 688
 689   // disable mode test if frame flag is not set
 690   if (!(cpi->ref_frame_flags & VP9_LAST_FLAG))
 691     sf->thresh_mult_sub8x8[THR_LAST] = INT_MAX;
 692   if (!(cpi->ref_frame_flags & VP9_GOLD_FLAG))
 693     sf->thresh_mult_sub8x8[THR_GOLD] = INT_MAX;
 694   if (!(cpi->ref_frame_flags & VP9_ALT_FLAG))
 695     sf->thresh_mult_sub8x8[THR_ALTR] = INT_MAX;
 696   if ((cpi->ref_frame_flags & (VP9_LAST_FLAG | VP9_ALT_FLAG)) !=
 697       (VP9_LAST_FLAG | VP9_ALT_FLAG))
 698     sf->thresh_mult_sub8x8[THR_COMP_LA] = INT_MAX;
 699   if ((cpi->ref_frame_flags & (VP9_GOLD_FLAG | VP9_ALT_FLAG)) !=
 700       (VP9_GOLD_FLAG | VP9_ALT_FLAG))
 701     sf->thresh_mult_sub8x8[THR_COMP_GA] = INT_MAX;
 702 }
 703
 704 void vp9_set_speed_features(VP9_COMP *cpi) {
 705   SPEED_FEATURES *sf = &cpi->sf;
 706   int mode = cpi->compressor_speed;
 707   int speed = cpi->speed;
 708   int i;
 709
 710   // Only modes 0 and 1 supported for now in experimental code basae
 711   if (mode > 1)
 712     mode = 1;
 713
 714   for (i = 0; i < MAX_MODES; ++i)
 715     cpi->mode_chosen_counts[i] = 0;
 716
 717   // best quality defaults
 718   sf->RD = 1;
 719   sf->search_method = NSTEP;
 720   sf->auto_filter = 1;
 721   sf->recode_loop = 1;
 722   sf->subpel_search_method = SUBPEL_TREE;
 723   sf->subpel_iters_per_step = 2;
 724   sf->optimize_coefficients = !cpi->oxcf.lossless;
 725   sf->reduce_first_step_size = 0;
 726   sf->auto_mv_step_size = 0;
 727   sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
 728   sf->comp_inter_joint_search_thresh = BLOCK_4X4;
 729   sf->adaptive_rd_thresh = 0;
 730   sf->use_lastframe_partitioning = LAST_FRAME_PARTITION_OFF;
 731   sf->tx_size_search_method = USE_FULL_RD;
 732   sf->use_lp32x32fdct = 0;
 733   sf->adaptive_motion_search = 0;
 734   sf->use_avoid_tested_higherror = 0;
 735   sf->reference_masking = 0;
 736   sf->use_one_partition_size_always = 0;
 737   sf->less_rectangular_check = 0;
 738   sf->use_square_partition_only = 0;
 739   sf->auto_min_max_partition_size = 0;
 740   sf->max_partition_size = BLOCK_64X64;
 741   sf->min_partition_size = BLOCK_4X4;
 742   sf->adjust_partitioning_from_last_frame = 0;
 743   sf->last_partitioning_redo_frequency = 4;
 744   sf->disable_split_mask = 0;
 745   sf->mode_search_skip_flags = 0;
 746   sf->disable_split_var_thresh = 0;
 747   sf->disable_filter_search_var_thresh = 0;
 748   for (i = 0; i < TX_SIZES; i++) {
 749     sf->intra_y_mode_mask[i] = ALL_INTRA_MODES;
 750     sf->intra_uv_mode_mask[i] = ALL_INTRA_MODES;
 751   }
 752   sf->use_rd_breakout = 0;
 753   sf->skip_encode_sb = 0;
 754   sf->use_uv_intra_rd_estimate = 0;
 755   sf->use_fast_lpf_pick = 0;
 756   sf->use_fast_coef_updates = 0;
 757   sf->using_small_partition_info = 0;
 758   sf->mode_skip_start = MAX_MODES;  // Mode index at which mode skip mask set
 759
 760 #if CONFIG_MULTIPLE_ARF
 761   // Switch segmentation off.
 762   sf->static_segmentation = 0;
 763 #else
 764   sf->static_segmentation = 0;
 765 #endif
 766
 767   switch (mode) {
 768     case 0:  // This is the best quality mode.
 769       break;
 770
 771     case 1:
 772 #if CONFIG_MULTIPLE_ARF
 773       // Switch segmentation off.
 774       sf->static_segmentation = 0;
 775 #else
 776       sf->static_segmentation = 0;
 777 #endif
 778       sf->use_avoid_tested_higherror = 1;
 779       sf->adaptive_rd_thresh = 1;
 780       sf->recode_loop = (speed < 1);
 781
 782       if (speed == 1) {
 783         sf->use_square_partition_only = !frame_is_intra_only(&cpi->common);
 784         sf->less_rectangular_check  = 1;
 785         sf->tx_size_search_method = frame_is_intra_only(&cpi->common)
 786                                      ? USE_FULL_RD : USE_LARGESTALL;
 787
 788         if (MIN(cpi->common.width, cpi->common.height) >= 720)
 789           sf->disable_split_mask = cpi->common.show_frame ?
 790               DISABLE_ALL_SPLIT : DISABLE_ALL_INTER_SPLIT;
 791         else
 792           sf->disable_split_mask = DISABLE_COMPOUND_SPLIT;
 793
 794         sf->use_rd_breakout = 1;
 795         sf->adaptive_motion_search = 1;
 796         sf->auto_mv_step_size = 1;
 797         sf->adaptive_rd_thresh = 2;
 798         sf->recode_loop = 2;
 799         sf->intra_y_mode_mask[TX_32X32] = INTRA_DC_H_V;
 800         sf->intra_uv_mode_mask[TX_32X32] = INTRA_DC_H_V;
 801         sf->intra_uv_mode_mask[TX_16X16] = INTRA_DC_H_V;
 802       }
 803       if (speed == 2) {
 804         sf->use_square_partition_only = !frame_is_intra_only(&cpi->common);
 805         sf->less_rectangular_check  = 1;
 806         sf->tx_size_search_method = frame_is_intra_only(&cpi->common)
 807                                      ? USE_FULL_RD : USE_LARGESTALL;
 808
 809         if (MIN(cpi->common.width, cpi->common.height) >= 720)
 810           sf->disable_split_mask = cpi->common.show_frame ?
 811               DISABLE_ALL_SPLIT : DISABLE_ALL_INTER_SPLIT;
 812         else
 813           sf->disable_split_mask = LAST_AND_INTRA_SPLIT_ONLY;
 814
 815
 816         sf->mode_search_skip_flags = FLAG_SKIP_INTRA_DIRMISMATCH |
 817                                      FLAG_SKIP_INTRA_BESTINTER |
 818                                      FLAG_SKIP_COMP_BESTINTRA |
 819                                      FLAG_SKIP_INTRA_LOWVAR;
 820
 821         sf->use_rd_breakout = 1;
 822         sf->adaptive_motion_search = 1;
 823         sf->auto_mv_step_size = 1;
 824
 825         sf->disable_filter_search_var_thresh = 16;
 826         sf->comp_inter_joint_search_thresh = BLOCK_SIZES;
 827
 828         sf->auto_min_max_partition_size = 1;
 829         sf->use_lastframe_partitioning = LAST_FRAME_PARTITION_LOW_MOTION;
 830         sf->adjust_partitioning_from_last_frame = 1;
 831         sf->last_partitioning_redo_frequency = 3;
 832
 833         sf->adaptive_rd_thresh = 2;
 834         sf->recode_loop = 2;
 835         sf->use_lp32x32fdct = 1;
 836         sf->mode_skip_start = 11;
 837         sf->intra_y_mode_mask[TX_32X32] = INTRA_DC_H_V;
 838         sf->intra_y_mode_mask[TX_16X16] = INTRA_DC_H_V;
 839         sf->intra_uv_mode_mask[TX_32X32] = INTRA_DC_H_V;
 840         sf->intra_uv_mode_mask[TX_16X16] = INTRA_DC_H_V;
 841       }
 842       if (speed == 3) {
 843         sf->use_square_partition_only = 1;
 844         sf->tx_size_search_method = USE_LARGESTALL;
 845
 846         if (MIN(cpi->common.width, cpi->common.height) >= 720)
 847           sf->disable_split_mask = DISABLE_ALL_SPLIT;
 848         else
 849           sf->disable_split_mask = DISABLE_ALL_INTER_SPLIT;
 850
 851         sf->mode_search_skip_flags = FLAG_SKIP_INTRA_DIRMISMATCH |
 852                                      FLAG_SKIP_INTRA_BESTINTER |
 853                                      FLAG_SKIP_COMP_BESTINTRA |
 854                                      FLAG_SKIP_INTRA_LOWVAR;
 855
 856         sf->use_rd_breakout = 1;
 857         sf->adaptive_motion_search = 1;
 858         sf->auto_mv_step_size = 1;
 859
 860         sf->disable_filter_search_var_thresh = 16;
 861         sf->comp_inter_joint_search_thresh = BLOCK_SIZES;
 862
 863         sf->auto_min_max_partition_size = 1;
 864         sf->use_lastframe_partitioning = LAST_FRAME_PARTITION_ALL;
 865         sf->adjust_partitioning_from_last_frame = 1;
 866         sf->last_partitioning_redo_frequency = 3;
 867
 868         sf->use_uv_intra_rd_estimate = 1;
 869         sf->skip_encode_sb = 1;
 870         sf->use_lp32x32fdct = 1;
 871         sf->subpel_iters_per_step = 1;
 872         sf->use_fast_coef_updates = 2;
 873
 874         sf->adaptive_rd_thresh = 4;
 875         sf->mode_skip_start = 6;
 876       }
 877       if (speed == 4) {
 878         sf->use_square_partition_only = 1;
 879         sf->tx_size_search_method = USE_LARGESTALL;
 880         sf->disable_split_mask = DISABLE_ALL_SPLIT;
 881
 882         sf->mode_search_skip_flags = FLAG_SKIP_INTRA_DIRMISMATCH |
 883                                      FLAG_SKIP_INTRA_BESTINTER |
 884                                      FLAG_SKIP_COMP_BESTINTRA |
 885                                      FLAG_SKIP_COMP_REFMISMATCH |
 886                                      FLAG_SKIP_INTRA_LOWVAR |
 887                                      FLAG_EARLY_TERMINATE;
 888
 889         sf->use_rd_breakout = 1;
 890         sf->adaptive_motion_search = 1;
 891         sf->auto_mv_step_size = 1;
 892
 893         sf->disable_filter_search_var_thresh = 16;
 894         sf->comp_inter_joint_search_thresh = BLOCK_SIZES;
 895
 896         sf->auto_min_max_partition_size = 1;
 897         sf->use_lastframe_partitioning = LAST_FRAME_PARTITION_ALL;
 898         sf->adjust_partitioning_from_last_frame = 1;
 899         sf->last_partitioning_redo_frequency = 3;
 900
 901         sf->use_uv_intra_rd_estimate = 1;
 902         sf->skip_encode_sb = 1;
 903         sf->use_lp32x32fdct = 1;
 904         sf->subpel_iters_per_step = 1;
 905         sf->use_fast_coef_updates = 2;
 906
 907         sf->adaptive_rd_thresh = 4;
 908         sf->mode_skip_start = 6;
 909
 910         /* sf->intra_y_mode_mask = INTRA_DC_ONLY;
 911         sf->intra_uv_mode_mask = INTRA_DC_ONLY;
 912         sf->search_method = BIGDIA;
 913         sf->disable_split_var_thresh = 64;
 914         sf->disable_filter_search_var_thresh = 64; */
 915       }
 916       if (speed == 5) {
 917         sf->comp_inter_joint_search_thresh = BLOCK_SIZES;
 918         sf->use_one_partition_size_always = 1;
 919         sf->always_this_block_size = BLOCK_16X16;
 920         sf->tx_size_search_method = frame_is_intra_only(&cpi->common) ?
 921                                      USE_FULL_RD : USE_LARGESTALL;
 922         sf->mode_search_skip_flags = FLAG_SKIP_INTRA_DIRMISMATCH |
 923                                      FLAG_SKIP_INTRA_BESTINTER |
 924                                      FLAG_SKIP_COMP_BESTINTRA |
 925                                      FLAG_SKIP_COMP_REFMISMATCH |
 926                                      FLAG_SKIP_INTRA_LOWVAR |
 927                                      FLAG_EARLY_TERMINATE;
 928         sf->use_rd_breakout = 1;
 929         sf->use_lp32x32fdct = 1;
 930         sf->optimize_coefficients = 0;
 931         sf->auto_mv_step_size = 1;
 932         // sf->reduce_first_step_size = 1;
 933         // sf->reference_masking = 1;
 934
 935         sf->disable_split_mask = DISABLE_ALL_SPLIT;
 936         sf->search_method = HEX;
 937         sf->subpel_iters_per_step = 1;
 938         sf->disable_split_var_thresh = 64;
 939         sf->disable_filter_search_var_thresh = 96;
 940         for (i = 0; i < TX_SIZES; i++) {
 941           sf->intra_y_mode_mask[i] = INTRA_DC_ONLY;
 942           sf->intra_uv_mode_mask[i] = INTRA_DC_ONLY;
 943         }
 944         sf->use_fast_coef_updates = 2;
 945         sf->adaptive_rd_thresh = 4;
 946         sf->mode_skip_start = 6;
 947       }
 948       break;
 949   }; /* switch */
 950
 951   // Set rd thresholds based on mode and speed setting
 952   set_rd_speed_thresholds(cpi, mode);
 953   set_rd_speed_thresholds_sub8x8(cpi, mode);
 954
 955   // Slow quant, dct and trellis not worthwhile for first pass
 956   // so make sure they are always turned off.
 957   if (cpi->pass == 1) {
 958     sf->optimize_coefficients = 0;
 959   }
 960
 961   // No recode for 1 pass.
 962   if (cpi->pass == 0) {
 963     sf->recode_loop = 0;
 964     sf->optimize_coefficients = 0;
 965   }
 966
 967   cpi->mb.fwd_txm4x4 = vp9_fdct4x4;
 968   if (cpi->oxcf.lossless || cpi->mb.e_mbd.lossless) {
 969     cpi->mb.fwd_txm4x4 = vp9_fwht4x4;
 970   }
 971
 972   if (cpi->sf.subpel_search_method == SUBPEL_ITERATIVE) {
 973     cpi->find_fractional_mv_step = vp9_find_best_sub_pixel_iterative;
 974     cpi->find_fractional_mv_step_comp = vp9_find_best_sub_pixel_comp_iterative;
 975   } else if (cpi->sf.subpel_search_method == SUBPEL_TREE) {
 976     cpi->find_fractional_mv_step = vp9_find_best_sub_pixel_tree;
 977     cpi->find_fractional_mv_step_comp = vp9_find_best_sub_pixel_comp_tree;
 978   }
 979
 980   cpi->mb.optimize = cpi->sf.optimize_coefficients == 1 && cpi->pass != 1;
 981
 982 #ifdef SPEEDSTATS
 983   frames_at_speed[cpi->speed]++;
 984 #endif
 985 }
 986
 987 static void alloc_raw_frame_buffers(VP9_COMP *cpi) {
 988   VP9_COMMON *cm = &cpi->common;
 989
 990   cpi->lookahead = vp9_lookahead_init(cpi->oxcf.width, cpi->oxcf.height,
 991                                       cm->subsampling_x, cm->subsampling_y,
 992                                       cpi->oxcf.lag_in_frames);
 993   if (!cpi->lookahead)
 994     vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
 995                        "Failed to allocate lag buffers");
 996
 997   if (vp9_realloc_frame_buffer(&cpi->alt_ref_buffer,
 998                                cpi->oxcf.width, cpi->oxcf.height,
 999                                cm->subsampling_x, cm->subsampling_y,
1000                                VP9BORDERINPIXELS))
1001     vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1002                        "Failed to allocate altref buffer");
1003 }
1004
1005 void vp9_alloc_compressor_data(VP9_COMP *cpi) {
1006   VP9_COMMON *cm = &cpi->common;
1007
1008   if (vp9_alloc_frame_buffers(cm, cm->width, cm->height))
1009     vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1010                        "Failed to allocate frame buffers");
1011
1012   if (vp9_alloc_frame_buffer(&cpi->last_frame_uf,
1013                              cm->width, cm->height,
1014                              cm->subsampling_x, cm->subsampling_y,
1015                              VP9BORDERINPIXELS))
1016     vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1017                        "Failed to allocate last frame buffer");
1018
1019   if (vp9_alloc_frame_buffer(&cpi->scaled_source,
1020                              cm->width, cm->height,
1021                              cm->subsampling_x, cm->subsampling_y,
1022                              VP9BORDERINPIXELS))
1023     vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1024                        "Failed to allocate scaled source buffer");
1025
1026   vpx_free(cpi->tok);
1027
1028   {
1029     unsigned int tokens = get_token_alloc(cm->mb_rows, cm->mb_cols);
1030
1031     CHECK_MEM_ERROR(cm, cpi->tok, vpx_calloc(tokens, sizeof(*cpi->tok)));
1032   }
1033
1034   vpx_free(cpi->mb_activity_map);
1035   CHECK_MEM_ERROR(cm, cpi->mb_activity_map,
1036                   vpx_calloc(sizeof(unsigned int),
1037                              cm->mb_rows * cm->mb_cols));
1038
1039   vpx_free(cpi->mb_norm_activity_map);
1040   CHECK_MEM_ERROR(cm, cpi->mb_norm_activity_map,
1041                   vpx_calloc(sizeof(unsigned int),
1042                              cm->mb_rows * cm->mb_cols));
1043
1044   // 2 contexts per 'mi unit', so that we have one context per 4x4 txfm
1045   // block where mi unit size is 8x8.
1046   vpx_free(cpi->above_context[0]);
1047   CHECK_MEM_ERROR(cm, cpi->above_context[0],
1048                   vpx_calloc(2 * mi_cols_aligned_to_sb(cm->mi_cols) *
1049                              MAX_MB_PLANE,
1050                              sizeof(*cpi->above_context[0])));
1051
1052   vpx_free(cpi->above_seg_context);
1053   CHECK_MEM_ERROR(cm, cpi->above_seg_context,
1054                   vpx_calloc(mi_cols_aligned_to_sb(cm->mi_cols),
1055                              sizeof(*cpi->above_seg_context)));
1056 }
1057
1058
1059 static void update_frame_size(VP9_COMP *cpi) {
1060   VP9_COMMON *cm = &cpi->common;
1061
1062   vp9_update_frame_size(cm);
1063
1064   // Update size of buffers local to this frame
1065   if (vp9_realloc_frame_buffer(&cpi->last_frame_uf,
1066                                cm->width, cm->height,
1067                                cm->subsampling_x, cm->subsampling_y,
1068                                VP9BORDERINPIXELS))
1069     vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1070                        "Failed to reallocate last frame buffer");
1071
1072   if (vp9_realloc_frame_buffer(&cpi->scaled_source,
1073                                cm->width, cm->height,
1074                                cm->subsampling_x, cm->subsampling_y,
1075                                VP9BORDERINPIXELS))
1076     vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1077                        "Failed to reallocate scaled source buffer");
1078
1079   {
1080     int y_stride = cpi->scaled_source.y_stride;
1081
1082     if (cpi->sf.search_method == NSTEP) {
1083       vp9_init3smotion_compensation(&cpi->mb, y_stride);
1084     } else if (cpi->sf.search_method == DIAMOND) {
1085       vp9_init_dsmotion_compensation(&cpi->mb, y_stride);
1086     }
1087   }
1088
1089   {
1090     int i;
1091     for (i = 1; i < MAX_MB_PLANE; ++i) {
1092       cpi->above_context[i] = cpi->above_context[0] +
1093                               i * sizeof(*cpi->above_context[0]) * 2 *
1094                               mi_cols_aligned_to_sb(cm->mi_cols);
1095     }
1096   }
1097 }
1098
1099
1100 // Table that converts 0-63 Q range values passed in outside to the Qindex
1101 // range used internally.
1102 static const int q_trans[] = {
1103   0,    4,   8,  12,  16,  20,  24,  28,
1104   32,   36,  40,  44,  48,  52,  56,  60,
1105   64,   68,  72,  76,  80,  84,  88,  92,
1106   96,  100, 104, 108, 112, 116, 120, 124,
1107   128, 132, 136, 140, 144, 148, 152, 156,
1108   160, 164, 168, 172, 176, 180, 184, 188,
1109   192, 196, 200, 204, 208, 212, 216, 220,
1110   224, 228, 232, 236, 240, 244, 249, 255,
1111 };
1112
1113 int vp9_reverse_trans(int x) {
1114   int i;
1115
1116   for (i = 0; i < 64; i++)
1117     if (q_trans[i] >= x)
1118       return i;
1119
1120   return 63;
1121 };
1122 void vp9_new_framerate(VP9_COMP *cpi, double framerate) {
1123   if (framerate < 0.1)
1124     framerate = 30;
1125
1126   cpi->oxcf.framerate = framerate;
1127   cpi->output_framerate = cpi->oxcf.framerate;
1128   cpi->per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth
1129                              / cpi->output_framerate);
1130   cpi->av_per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth
1131                                 / cpi->output_framerate);
1132   cpi->min_frame_bandwidth = (int)(cpi->av_per_frame_bandwidth *
1133                                    cpi->oxcf.two_pass_vbrmin_section / 100);
1134
1135
1136   cpi->min_frame_bandwidth = MAX(cpi->min_frame_bandwidth, FRAME_OVERHEAD_BITS);
1137
1138   // Set Maximum gf/arf interval
1139   cpi->max_gf_interval = 16;
1140
1141   // Extended interval for genuinely static scenes
1142   cpi->twopass.static_scene_max_gf_interval = cpi->key_frame_frequency >> 1;
1143
1144   // Special conditions when alt ref frame enabled in lagged compress mode
1145   if (cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames) {
1146     if (cpi->max_gf_interval > cpi->oxcf.lag_in_frames - 1)
1147       cpi->max_gf_interval = cpi->oxcf.lag_in_frames - 1;
1148
1149     if (cpi->twopass.static_scene_max_gf_interval > cpi->oxcf.lag_in_frames - 1)
1150       cpi->twopass.static_scene_max_gf_interval = cpi->oxcf.lag_in_frames - 1;
1151   }
1152
1153   if (cpi->max_gf_interval > cpi->twopass.static_scene_max_gf_interval)
1154     cpi->max_gf_interval = cpi->twopass.static_scene_max_gf_interval;
1155 }
1156
1157 static int64_t rescale(int val, int64_t num, int denom) {
1158   int64_t llnum = num;
1159   int64_t llden = denom;
1160   int64_t llval = val;
1161
1162   return (llval * llnum / llden);
1163 }
1164
1165 static void set_tile_limits(VP9_COMP *cpi) {
1166   VP9_COMMON *const cm = &cpi->common;
1167
1168   int min_log2_tile_cols, max_log2_tile_cols;
1169   vp9_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
1170
1171   cm->log2_tile_cols = clamp(cpi->oxcf.tile_columns,
1172                              min_log2_tile_cols, max_log2_tile_cols);
1173   cm->log2_tile_rows = cpi->oxcf.tile_rows;
1174 }
1175
1176 static void init_config(VP9_PTR ptr, VP9_CONFIG *oxcf) {
1177   VP9_COMP *cpi = (VP9_COMP *)(ptr);
1178   VP9_COMMON *const cm = &cpi->common;
1179   int i;
1180
1181   cpi->oxcf = *oxcf;
1182
1183   cm->version = oxcf->version;
1184
1185   cm->width = oxcf->width;
1186   cm->height = oxcf->height;
1187   cm->subsampling_x = 0;
1188   cm->subsampling_y = 0;
1189   vp9_alloc_compressor_data(cpi);
1190
1191   // change includes all joint functionality
1192   vp9_change_config(ptr, oxcf);
1193
1194   // Initialize active best and worst q and average q values.
1195   cpi->active_worst_quality         = cpi->oxcf.worst_allowed_q;
1196   cpi->active_best_quality          = cpi->oxcf.best_allowed_q;
1197   cpi->avg_frame_qindex             = cpi->oxcf.worst_allowed_q;
1198
1199   // Initialise the starting buffer levels
1200   cpi->buffer_level                 = cpi->oxcf.starting_buffer_level;
1201   cpi->bits_off_target              = cpi->oxcf.starting_buffer_level;
1202
1203   cpi->rolling_target_bits          = cpi->av_per_frame_bandwidth;
1204   cpi->rolling_actual_bits          = cpi->av_per_frame_bandwidth;
1205   cpi->long_rolling_target_bits     = cpi->av_per_frame_bandwidth;
1206   cpi->long_rolling_actual_bits     = cpi->av_per_frame_bandwidth;
1207
1208   cpi->total_actual_bits            = 0;
1209   cpi->total_target_vs_actual       = 0;
1210
1211   cpi->static_mb_pct = 0;
1212
1213   cpi->lst_fb_idx = 0;
1214   cpi->gld_fb_idx = 1;
1215   cpi->alt_fb_idx = 2;
1216
1217   cpi->current_layer = 0;
1218   cpi->use_svc = 0;
1219
1220   set_tile_limits(cpi);
1221
1222   cpi->fixed_divide[0] = 0;
1223   for (i = 1; i < 512; i++)
1224     cpi->fixed_divide[i] = 0x80000 / i;
1225 }
1226
1227
1228 void vp9_change_config(VP9_PTR ptr, VP9_CONFIG *oxcf) {
1229   VP9_COMP *cpi = (VP9_COMP *)(ptr);
1230   VP9_COMMON *const cm = &cpi->common;
1231
1232   if (!cpi || !oxcf)
1233     return;
1234
1235   if (cm->version != oxcf->version) {
1236     cm->version = oxcf->version;
1237   }
1238
1239   cpi->oxcf = *oxcf;
1240
1241   switch (cpi->oxcf.Mode) {
1242       // Real time and one pass deprecated in test code base
1243     case MODE_GOODQUALITY:
1244       cpi->pass = 0;
1245       cpi->compressor_speed = 2;
1246       cpi->oxcf.cpu_used = clamp(cpi->oxcf.cpu_used, -5, 5);
1247       break;
1248
1249     case MODE_FIRSTPASS:
1250       cpi->pass = 1;
1251       cpi->compressor_speed = 1;
1252       break;
1253
1254     case MODE_SECONDPASS:
1255       cpi->pass = 2;
1256       cpi->compressor_speed = 1;
1257       cpi->oxcf.cpu_used = clamp(cpi->oxcf.cpu_used, -5, 5);
1258       break;
1259
1260     case MODE_SECONDPASS_BEST:
1261       cpi->pass = 2;
1262       cpi->compressor_speed = 0;
1263       break;
1264   }
1265
1266   cpi->oxcf.worst_allowed_q = q_trans[oxcf->worst_allowed_q];
1267   cpi->oxcf.best_allowed_q = q_trans[oxcf->best_allowed_q];
1268   cpi->oxcf.cq_level = q_trans[cpi->oxcf.cq_level];
1269
1270   cpi->oxcf.lossless = oxcf->lossless;
1271   cpi->mb.e_mbd.itxm_add = cpi->oxcf.lossless ? vp9_iwht4x4_add
1272                                               : vp9_idct4x4_add;
1273   cpi->baseline_gf_interval = DEFAULT_GF_INTERVAL;
1274
1275   cpi->ref_frame_flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
1276
1277   // cpi->use_golden_frame_only = 0;
1278   // cpi->use_last_frame_only = 0;
1279   cpi->refresh_golden_frame = 0;
1280   cpi->refresh_last_frame = 1;
1281   cm->refresh_frame_context = 1;
1282   cm->reset_frame_context = 0;
1283
1284   setup_features(cm);
1285   cpi->common.allow_high_precision_mv = 0;  // Default mv precision
1286   set_mvcost(cpi);
1287
1288   {
1289     int i;
1290
1291     for (i = 0; i < MAX_SEGMENTS; i++)
1292       cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
1293   }
1294
1295   // At the moment the first order values may not be > MAXQ
1296   cpi->oxcf.fixed_q = MIN(cpi->oxcf.fixed_q, MAXQ);
1297
1298   // local file playback mode == really big buffer
1299   if (cpi->oxcf.end_usage == USAGE_LOCAL_FILE_PLAYBACK) {
1300     cpi->oxcf.starting_buffer_level   = 60000;
1301     cpi->oxcf.optimal_buffer_level    = 60000;
1302     cpi->oxcf.maximum_buffer_size     = 240000;
1303   }
1304
1305   // Convert target bandwidth from Kbit/s to Bit/s
1306   cpi->oxcf.target_bandwidth       *= 1000;
1307
1308   cpi->oxcf.starting_buffer_level = rescale(cpi->oxcf.starting_buffer_level,
1309                                             cpi->oxcf.target_bandwidth, 1000);
1310
1311   // Set or reset optimal and maximum buffer levels.
1312   if (cpi->oxcf.optimal_buffer_level == 0)
1313     cpi->oxcf.optimal_buffer_level = cpi->oxcf.target_bandwidth / 8;
1314   else
1315     cpi->oxcf.optimal_buffer_level = rescale(cpi->oxcf.optimal_buffer_level,
1316                                              cpi->oxcf.target_bandwidth, 1000);
1317
1318   if (cpi->oxcf.maximum_buffer_size == 0)
1319     cpi->oxcf.maximum_buffer_size = cpi->oxcf.target_bandwidth / 8;
1320   else
1321     cpi->oxcf.maximum_buffer_size = rescale(cpi->oxcf.maximum_buffer_size,
1322                                             cpi->oxcf.target_bandwidth, 1000);
1323
1324   // Set up frame rate and related parameters rate control values.
1325   vp9_new_framerate(cpi, cpi->oxcf.framerate);
1326
1327   // Set absolute upper and lower quality limits
1328   cpi->worst_quality = cpi->oxcf.worst_allowed_q;
1329   cpi->best_quality = cpi->oxcf.best_allowed_q;
1330
1331   // active values should only be modified if out of new range
1332   cpi->active_worst_quality = clamp(cpi->active_worst_quality,
1333                                     cpi->oxcf.best_allowed_q,
1334                                     cpi->oxcf.worst_allowed_q);
1335
1336   cpi->active_best_quality = clamp(cpi->active_best_quality,
1337                                    cpi->oxcf.best_allowed_q,
1338                                    cpi->oxcf.worst_allowed_q);
1339
1340   cpi->buffered_mode = cpi->oxcf.optimal_buffer_level > 0;
1341
1342   cpi->cq_target_quality = cpi->oxcf.cq_level;
1343
1344   cm->mcomp_filter_type = DEFAULT_INTERP_FILTER;
1345
1346   cpi->target_bandwidth = cpi->oxcf.target_bandwidth;
1347
1348   cm->display_width = cpi->oxcf.width;
1349   cm->display_height = cpi->oxcf.height;
1350
1351   // VP8 sharpness level mapping 0-7 (vs 0-10 in general VPx dialogs)
1352   cpi->oxcf.Sharpness = MIN(7, cpi->oxcf.Sharpness);
1353
1354   cpi->common.lf.sharpness_level = cpi->oxcf.Sharpness;
1355
1356   if (cpi->initial_width) {
1357     // Increasing the size of the frame beyond the first seen frame, or some
1358     // otherwise signalled maximum size, is not supported.
1359     // TODO(jkoleszar): exit gracefully.
1360     assert(cm->width <= cpi->initial_width);
1361     assert(cm->height <= cpi->initial_height);
1362   }
1363   update_frame_size(cpi);
1364
1365   if (cpi->oxcf.fixed_q >= 0) {
1366     cpi->last_q[0] = cpi->oxcf.fixed_q;
1367     cpi->last_q[1] = cpi->oxcf.fixed_q;
1368     cpi->last_boosted_qindex = cpi->oxcf.fixed_q;
1369   }
1370
1371   cpi->speed = cpi->oxcf.cpu_used;
1372
1373   if (cpi->oxcf.lag_in_frames == 0) {
1374     // force to allowlag to 0 if lag_in_frames is 0;
1375     cpi->oxcf.allow_lag = 0;
1376   } else if (cpi->oxcf.lag_in_frames > MAX_LAG_BUFFERS) {
1377      // Limit on lag buffers as these are not currently dynamically allocated
1378     cpi->oxcf.lag_in_frames = MAX_LAG_BUFFERS;
1379   }
1380
1381   // YX Temp
1382 #if CONFIG_MULTIPLE_ARF
1383   vp9_zero(cpi->alt_ref_source);
1384 #else
1385   cpi->alt_ref_source = NULL;
1386 #endif
1387   cpi->is_src_frame_alt_ref = 0;
1388
1389 #if 0
1390   // Experimental RD Code
1391   cpi->frame_distortion = 0;
1392   cpi->last_frame_distortion = 0;
1393 #endif
1394
1395   set_tile_limits(cpi);
1396 }
1397
1398 #define M_LOG2_E 0.693147180559945309417
1399 #define log2f(x) (log (x) / (float) M_LOG2_E)
1400
1401 static void cal_nmvjointsadcost(int *mvjointsadcost) {
1402   mvjointsadcost[0] = 600;
1403   mvjointsadcost[1] = 300;
1404   mvjointsadcost[2] = 300;
1405   mvjointsadcost[0] = 300;
1406 }
1407
1408 static void cal_nmvsadcosts(int *mvsadcost[2]) {
1409   int i = 1;
1410
1411   mvsadcost[0][0] = 0;
1412   mvsadcost[1][0] = 0;
1413
1414   do {
1415     double z = 256 * (2 * (log2f(8 * i) + .6));
1416     mvsadcost[0][i] = (int)z;
1417     mvsadcost[1][i] = (int)z;
1418     mvsadcost[0][-i] = (int)z;
1419     mvsadcost[1][-i] = (int)z;
1420   } while (++i <= MV_MAX);
1421 }
1422
1423 static void cal_nmvsadcosts_hp(int *mvsadcost[2]) {
1424   int i = 1;
1425
1426   mvsadcost[0][0] = 0;
1427   mvsadcost[1][0] = 0;
1428
1429   do {
1430     double z = 256 * (2 * (log2f(8 * i) + .6));
1431     mvsadcost[0][i] = (int)z;
1432     mvsadcost[1][i] = (int)z;
1433     mvsadcost[0][-i] = (int)z;
1434     mvsadcost[1][-i] = (int)z;
1435   } while (++i <= MV_MAX);
1436 }
1437
1438 static void alloc_mode_context(VP9_COMMON *cm, int num_4x4_blk,
1439                                PICK_MODE_CONTEXT *ctx) {
1440   int num_pix = num_4x4_blk << 4;
1441   int i, k;
1442   ctx->num_4x4_blk = num_4x4_blk;
1443   CHECK_MEM_ERROR(cm, ctx->zcoeff_blk,
1444                   vpx_calloc(num_4x4_blk, sizeof(uint8_t)));
1445   for (i = 0; i < MAX_MB_PLANE; ++i) {
1446     for (k = 0; k < 3; ++k) {
1447       CHECK_MEM_ERROR(cm, ctx->coeff[i][k],
1448                       vpx_memalign(16, num_pix * sizeof(int16_t)));
1449       CHECK_MEM_ERROR(cm, ctx->qcoeff[i][k],
1450                       vpx_memalign(16, num_pix * sizeof(int16_t)));
1451       CHECK_MEM_ERROR(cm, ctx->dqcoeff[i][k],
1452                       vpx_memalign(16, num_pix * sizeof(int16_t)));
1453       CHECK_MEM_ERROR(cm, ctx->eobs[i][k],
1454                       vpx_memalign(16, num_pix * sizeof(uint16_t)));
1455       ctx->coeff_pbuf[i][k]   = ctx->coeff[i][k];
1456       ctx->qcoeff_pbuf[i][k]  = ctx->qcoeff[i][k];
1457       ctx->dqcoeff_pbuf[i][k] = ctx->dqcoeff[i][k];
1458       ctx->eobs_pbuf[i][k]    = ctx->eobs[i][k];
1459     }
1460   }
1461 }
1462
1463 static void free_mode_context(PICK_MODE_CONTEXT *ctx) {
1464   int i, k;
1465   vpx_free(ctx->zcoeff_blk);
1466   ctx->zcoeff_blk = 0;
1467   for (i = 0; i < MAX_MB_PLANE; ++i) {
1468     for (k = 0; k < 3; ++k) {
1469       vpx_free(ctx->coeff[i][k]);
1470       ctx->coeff[i][k] = 0;
1471       vpx_free(ctx->qcoeff[i][k]);
1472       ctx->qcoeff[i][k] = 0;
1473       vpx_free(ctx->dqcoeff[i][k]);
1474       ctx->dqcoeff[i][k] = 0;
1475       vpx_free(ctx->eobs[i][k]);
1476       ctx->eobs[i][k] = 0;
1477     }
1478   }
1479 }
1480
1481 static void init_pick_mode_context(VP9_COMP *cpi) {
1482   int i;
1483   VP9_COMMON *const cm = &cpi->common;
1484   MACROBLOCK *const x  = &cpi->mb;
1485
1486
1487   for (i = 0; i < BLOCK_SIZES; ++i) {
1488     const int num_4x4_w = num_4x4_blocks_wide_lookup[i];
1489     const int num_4x4_h = num_4x4_blocks_high_lookup[i];
1490     const int num_4x4_blk = MAX(4, num_4x4_w * num_4x4_h);
1491     if (i < BLOCK_16X16) {
1492       for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1493         for (x->mb_index = 0; x->mb_index < 4; ++x->mb_index) {
1494           for (x->b_index = 0; x->b_index < 16 / num_4x4_blk; ++x->b_index) {
1495             PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1496             alloc_mode_context(cm, num_4x4_blk, ctx);
1497           }
1498         }
1499       }
1500     } else if (i < BLOCK_32X32) {
1501       for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1502         for (x->mb_index = 0; x->mb_index < 64 / num_4x4_blk; ++x->mb_index) {
1503           PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1504           ctx->num_4x4_blk = num_4x4_blk;
1505           alloc_mode_context(cm, num_4x4_blk, ctx);
1506         }
1507       }
1508     } else if (i < BLOCK_64X64) {
1509       for (x->sb_index = 0; x->sb_index < 256 / num_4x4_blk; ++x->sb_index) {
1510         PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1511         ctx->num_4x4_blk = num_4x4_blk;
1512         alloc_mode_context(cm, num_4x4_blk, ctx);
1513       }
1514     } else {
1515       PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1516       ctx->num_4x4_blk = num_4x4_blk;
1517       alloc_mode_context(cm, num_4x4_blk, ctx);
1518     }
1519   }
1520 }
1521
1522 static void free_pick_mode_context(MACROBLOCK *x) {
1523   int i;
1524
1525   for (i = 0; i < BLOCK_SIZES; ++i) {
1526     const int num_4x4_w = num_4x4_blocks_wide_lookup[i];
1527     const int num_4x4_h = num_4x4_blocks_high_lookup[i];
1528     const int num_4x4_blk = MAX(4, num_4x4_w * num_4x4_h);
1529     if (i < BLOCK_16X16) {
1530       for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1531         for (x->mb_index = 0; x->mb_index < 4; ++x->mb_index) {
1532           for (x->b_index = 0; x->b_index < 16 / num_4x4_blk; ++x->b_index) {
1533             PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1534             free_mode_context(ctx);
1535           }
1536         }
1537       }
1538     } else if (i < BLOCK_32X32) {
1539       for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1540         for (x->mb_index = 0; x->mb_index < 64 / num_4x4_blk; ++x->mb_index) {
1541           PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1542           free_mode_context(ctx);
1543         }
1544       }
1545     } else if (i < BLOCK_64X64) {
1546       for (x->sb_index = 0; x->sb_index < 256 / num_4x4_blk; ++x->sb_index) {
1547         PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1548         free_mode_context(ctx);
1549       }
1550     } else {
1551       PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1552       free_mode_context(ctx);
1553     }
1554   }
1555 }
1556
1557 VP9_PTR vp9_create_compressor(VP9_CONFIG *oxcf) {
1558   int i, j;
1559   volatile union {
1560     VP9_COMP *cpi;
1561     VP9_PTR   ptr;
1562   } ctx;
1563
1564   VP9_COMP *cpi;
1565   VP9_COMMON *cm;
1566
1567   cpi = ctx.cpi = vpx_memalign(32, sizeof(VP9_COMP));
1568   // Check that the CPI instance is valid
1569   if (!cpi)
1570     return 0;
1571
1572   cm = &cpi->common;
1573
1574   vp9_zero(*cpi);
1575
1576   if (setjmp(cm->error.jmp)) {
1577     VP9_PTR ptr = ctx.ptr;
1578
1579     ctx.cpi->common.error.setjmp = 0;
1580     vp9_remove_compressor(&ptr);
1581     return 0;
1582   }
1583
1584   cm->error.setjmp = 1;
1585
1586   CHECK_MEM_ERROR(cm, cpi->mb.ss, vpx_calloc(sizeof(search_site),
1587                                              (MAX_MVSEARCH_STEPS * 8) + 1));
1588
1589   vp9_create_common(cm);
1590
1591   init_config((VP9_PTR)cpi, oxcf);
1592
1593   init_pick_mode_context(cpi);
1594
1595   cm->current_video_frame   = 0;
1596   cpi->kf_overspend_bits            = 0;
1597   cpi->kf_bitrate_adjustment        = 0;
1598   cpi->frames_till_gf_update_due    = 0;
1599   cpi->gf_overspend_bits            = 0;
1600   cpi->non_gf_bitrate_adjustment    = 0;
1601
1602   // Set reference frame sign bias for ALTREF frame to 1 (for now)
1603   cm->ref_frame_sign_bias[ALTREF_FRAME] = 1;
1604
1605   cpi->baseline_gf_interval = DEFAULT_GF_INTERVAL;
1606
1607   cpi->gold_is_last = 0;
1608   cpi->alt_is_last  = 0;
1609   cpi->gold_is_alt  = 0;
1610
1611   // Spatial scalability
1612   cpi->number_spatial_layers = oxcf->ss_number_layers;
1613
1614   // Create the encoder segmentation map and set all entries to 0
1615   CHECK_MEM_ERROR(cm, cpi->segmentation_map,
1616                   vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1617
1618   // And a place holder structure is the coding context
1619   // for use if we want to save and restore it
1620   CHECK_MEM_ERROR(cm, cpi->coding_context.last_frame_seg_map_copy,
1621                   vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1622
1623   CHECK_MEM_ERROR(cm, cpi->active_map, vpx_calloc(cm->MBs, 1));
1624   vpx_memset(cpi->active_map, 1, cm->MBs);
1625   cpi->active_map_enabled = 0;
1626
1627   for (i = 0; i < (sizeof(cpi->mbgraph_stats) /
1628                    sizeof(cpi->mbgraph_stats[0])); i++) {
1629     CHECK_MEM_ERROR(cm, cpi->mbgraph_stats[i].mb_stats,
1630                     vpx_calloc(cm->MBs *
1631                                sizeof(*cpi->mbgraph_stats[i].mb_stats), 1));
1632   }
1633
1634 #ifdef ENTROPY_STATS
1635   if (cpi->pass != 1)
1636     init_context_counters();
1637 #endif
1638
1639 #ifdef MODE_STATS
1640   init_tx_count_stats();
1641   init_switchable_interp_stats();
1642 #endif
1643
1644   /*Initialize the feed-forward activity masking.*/
1645   cpi->activity_avg = 90 << 12;
1646
1647   cpi->frames_since_key = 8;  // Sensible default for first frame.
1648   cpi->key_frame_frequency = cpi->oxcf.key_freq;
1649   cpi->this_key_frame_forced = 0;
1650   cpi->next_key_frame_forced = 0;
1651
1652   cpi->source_alt_ref_pending = 0;
1653   cpi->source_alt_ref_active = 0;
1654   cpi->refresh_alt_ref_frame = 0;
1655
1656 #if CONFIG_MULTIPLE_ARF
1657   // Turn multiple ARF usage on/off. This is a quick hack for the initial test
1658   // version. It should eventually be set via the codec API.
1659   cpi->multi_arf_enabled = 1;
1660
1661   if (cpi->multi_arf_enabled) {
1662     cpi->sequence_number = 0;
1663     cpi->frame_coding_order_period = 0;
1664     vp9_zero(cpi->frame_coding_order);
1665     vp9_zero(cpi->arf_buffer_idx);
1666   }
1667 #endif
1668
1669   cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
1670 #if CONFIG_INTERNAL_STATS
1671   cpi->b_calculate_ssimg = 0;
1672
1673   cpi->count = 0;
1674   cpi->bytes = 0;
1675
1676   if (cpi->b_calculate_psnr) {
1677     cpi->total_sq_error = 0.0;
1678     cpi->total_sq_error2 = 0.0;
1679     cpi->total_y = 0.0;
1680     cpi->total_u = 0.0;
1681     cpi->total_v = 0.0;
1682     cpi->total = 0.0;
1683     cpi->totalp_y = 0.0;
1684     cpi->totalp_u = 0.0;
1685     cpi->totalp_v = 0.0;
1686     cpi->totalp = 0.0;
1687     cpi->tot_recode_hits = 0;
1688     cpi->summed_quality = 0;
1689     cpi->summed_weights = 0;
1690     cpi->summedp_quality = 0;
1691     cpi->summedp_weights = 0;
1692   }
1693
1694   if (cpi->b_calculate_ssimg) {
1695     cpi->total_ssimg_y = 0;
1696     cpi->total_ssimg_u = 0;
1697     cpi->total_ssimg_v = 0;
1698     cpi->total_ssimg_all = 0;
1699   }
1700
1701 #endif
1702
1703   cpi->first_time_stamp_ever = INT64_MAX;
1704
1705   cpi->frames_till_gf_update_due      = 0;
1706   cpi->key_frame_count              = 1;
1707
1708   cpi->ni_av_qi                     = cpi->oxcf.worst_allowed_q;
1709   cpi->ni_tot_qi                    = 0;
1710   cpi->ni_frames                   = 0;
1711   cpi->tot_q = 0.0;
1712   cpi->avg_q = vp9_convert_qindex_to_q(cpi->oxcf.worst_allowed_q);
1713   cpi->total_byte_count             = 0;
1714
1715   cpi->rate_correction_factor         = 1.0;
1716   cpi->key_frame_rate_correction_factor = 1.0;
1717   cpi->gf_rate_correction_factor  = 1.0;
1718   cpi->twopass.est_max_qcorrection_factor  = 1.0;
1719
1720   cal_nmvjointsadcost(cpi->mb.nmvjointsadcost);
1721   cpi->mb.nmvcost[0] = &cpi->mb.nmvcosts[0][MV_MAX];
1722   cpi->mb.nmvcost[1] = &cpi->mb.nmvcosts[1][MV_MAX];
1723   cpi->mb.nmvsadcost[0] = &cpi->mb.nmvsadcosts[0][MV_MAX];
1724   cpi->mb.nmvsadcost[1] = &cpi->mb.nmvsadcosts[1][MV_MAX];
1725   cal_nmvsadcosts(cpi->mb.nmvsadcost);
1726
1727   cpi->mb.nmvcost_hp[0] = &cpi->mb.nmvcosts_hp[0][MV_MAX];
1728   cpi->mb.nmvcost_hp[1] = &cpi->mb.nmvcosts_hp[1][MV_MAX];
1729   cpi->mb.nmvsadcost_hp[0] = &cpi->mb.nmvsadcosts_hp[0][MV_MAX];
1730   cpi->mb.nmvsadcost_hp[1] = &cpi->mb.nmvsadcosts_hp[1][MV_MAX];
1731   cal_nmvsadcosts_hp(cpi->mb.nmvsadcost_hp);
1732
1733   for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1734     cpi->prior_key_frame_distance[i] = (int)cpi->output_framerate;
1735
1736 #ifdef OUTPUT_YUV_SRC
1737   yuv_file = fopen("bd.yuv", "ab");
1738 #endif
1739 #ifdef OUTPUT_YUV_REC
1740   yuv_rec_file = fopen("rec.yuv", "wb");
1741 #endif
1742
1743 #if 0
1744   framepsnr = fopen("framepsnr.stt", "a");
1745   kf_list = fopen("kf_list.stt", "w");
1746 #endif
1747
1748   cpi->output_pkt_list = oxcf->output_pkt_list;
1749
1750   cpi->enable_encode_breakout = 1;
1751
1752   if (cpi->pass == 1) {
1753     vp9_init_first_pass(cpi);
1754   } else if (cpi->pass == 2) {
1755     size_t packet_sz = sizeof(FIRSTPASS_STATS);
1756     int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz);
1757
1758     cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf;
1759     cpi->twopass.stats_in = cpi->twopass.stats_in_start;
1760     cpi->twopass.stats_in_end = (void *)((char *)cpi->twopass.stats_in
1761                                          + (packets - 1) * packet_sz);
1762     vp9_init_second_pass(cpi);
1763   }
1764
1765   vp9_set_speed_features(cpi);
1766
1767   // Default rd threshold factors for mode selection
1768   for (i = 0; i < BLOCK_SIZES; ++i) {
1769     for (j = 0; j < MAX_MODES; ++j)
1770       cpi->rd_thresh_freq_fact[i][j] = 32;
1771     for (j = 0; j < MAX_REFS; ++j)
1772       cpi->rd_thresh_freq_sub8x8[i][j] = 32;
1773   }
1774
1775 #define BFP(BT, SDF, SDAF, VF, SVF, SVAF, SVFHH, SVFHV, SVFHHV, \
1776             SDX3F, SDX8F, SDX4DF)\
1777     cpi->fn_ptr[BT].sdf            = SDF; \
1778     cpi->fn_ptr[BT].sdaf           = SDAF; \
1779     cpi->fn_ptr[BT].vf             = VF; \
1780     cpi->fn_ptr[BT].svf            = SVF; \
1781     cpi->fn_ptr[BT].svaf           = SVAF; \
1782     cpi->fn_ptr[BT].svf_halfpix_h  = SVFHH; \
1783     cpi->fn_ptr[BT].svf_halfpix_v  = SVFHV; \
1784     cpi->fn_ptr[BT].svf_halfpix_hv = SVFHHV; \
1785     cpi->fn_ptr[BT].sdx3f          = SDX3F; \
1786     cpi->fn_ptr[BT].sdx8f          = SDX8F; \
1787     cpi->fn_ptr[BT].sdx4df         = SDX4DF;
1788
1789   BFP(BLOCK_32X16, vp9_sad32x16, vp9_sad32x16_avg,
1790       vp9_variance32x16, vp9_sub_pixel_variance32x16,
1791       vp9_sub_pixel_avg_variance32x16, NULL, NULL,
1792       NULL, NULL, NULL,
1793       vp9_sad32x16x4d)
1794
1795   BFP(BLOCK_16X32, vp9_sad16x32, vp9_sad16x32_avg,
1796       vp9_variance16x32, vp9_sub_pixel_variance16x32,
1797       vp9_sub_pixel_avg_variance16x32, NULL, NULL,
1798       NULL, NULL, NULL,
1799       vp9_sad16x32x4d)
1800
1801   BFP(BLOCK_64X32, vp9_sad64x32, vp9_sad64x32_avg,
1802       vp9_variance64x32, vp9_sub_pixel_variance64x32,
1803       vp9_sub_pixel_avg_variance64x32, NULL, NULL,
1804       NULL, NULL, NULL,
1805       vp9_sad64x32x4d)
1806
1807   BFP(BLOCK_32X64, vp9_sad32x64, vp9_sad32x64_avg,
1808       vp9_variance32x64, vp9_sub_pixel_variance32x64,
1809       vp9_sub_pixel_avg_variance32x64, NULL, NULL,
1810       NULL, NULL, NULL,
1811       vp9_sad32x64x4d)
1812
1813   BFP(BLOCK_32X32, vp9_sad32x32, vp9_sad32x32_avg,
1814       vp9_variance32x32, vp9_sub_pixel_variance32x32,
1815       vp9_sub_pixel_avg_variance32x32, vp9_variance_halfpixvar32x32_h,
1816       vp9_variance_halfpixvar32x32_v,
1817       vp9_variance_halfpixvar32x32_hv, vp9_sad32x32x3, vp9_sad32x32x8,
1818       vp9_sad32x32x4d)
1819
1820   BFP(BLOCK_64X64, vp9_sad64x64, vp9_sad64x64_avg,
1821       vp9_variance64x64, vp9_sub_pixel_variance64x64,
1822       vp9_sub_pixel_avg_variance64x64, vp9_variance_halfpixvar64x64_h,
1823       vp9_variance_halfpixvar64x64_v,
1824       vp9_variance_halfpixvar64x64_hv, vp9_sad64x64x3, vp9_sad64x64x8,
1825       vp9_sad64x64x4d)
1826
1827   BFP(BLOCK_16X16, vp9_sad16x16, vp9_sad16x16_avg,
1828       vp9_variance16x16, vp9_sub_pixel_variance16x16,
1829       vp9_sub_pixel_avg_variance16x16, vp9_variance_halfpixvar16x16_h,
1830       vp9_variance_halfpixvar16x16_v,
1831       vp9_variance_halfpixvar16x16_hv, vp9_sad16x16x3, vp9_sad16x16x8,
1832       vp9_sad16x16x4d)
1833
1834   BFP(BLOCK_16X8, vp9_sad16x8, vp9_sad16x8_avg,
1835       vp9_variance16x8, vp9_sub_pixel_variance16x8,
1836       vp9_sub_pixel_avg_variance16x8, NULL, NULL, NULL,
1837       vp9_sad16x8x3, vp9_sad16x8x8, vp9_sad16x8x4d)
1838
1839   BFP(BLOCK_8X16, vp9_sad8x16, vp9_sad8x16_avg,
1840       vp9_variance8x16, vp9_sub_pixel_variance8x16,
1841       vp9_sub_pixel_avg_variance8x16, NULL, NULL, NULL,
1842       vp9_sad8x16x3, vp9_sad8x16x8, vp9_sad8x16x4d)
1843
1844   BFP(BLOCK_8X8, vp9_sad8x8, vp9_sad8x8_avg,
1845       vp9_variance8x8, vp9_sub_pixel_variance8x8,
1846       vp9_sub_pixel_avg_variance8x8, NULL, NULL, NULL,
1847       vp9_sad8x8x3, vp9_sad8x8x8, vp9_sad8x8x4d)
1848
1849   BFP(BLOCK_8X4, vp9_sad8x4, vp9_sad8x4_avg,
1850       vp9_variance8x4, vp9_sub_pixel_variance8x4,
1851       vp9_sub_pixel_avg_variance8x4, NULL, NULL,
1852       NULL, NULL, vp9_sad8x4x8,
1853       vp9_sad8x4x4d)
1854
1855   BFP(BLOCK_4X8, vp9_sad4x8, vp9_sad4x8_avg,
1856       vp9_variance4x8, vp9_sub_pixel_variance4x8,
1857       vp9_sub_pixel_avg_variance4x8, NULL, NULL,
1858       NULL, NULL, vp9_sad4x8x8,
1859       vp9_sad4x8x4d)
1860
1861   BFP(BLOCK_4X4, vp9_sad4x4, vp9_sad4x4_avg,
1862       vp9_variance4x4, vp9_sub_pixel_variance4x4,
1863       vp9_sub_pixel_avg_variance4x4, NULL, NULL, NULL,
1864       vp9_sad4x4x3, vp9_sad4x4x8, vp9_sad4x4x4d)
1865
1866   cpi->full_search_sad = vp9_full_search_sad;
1867   cpi->diamond_search_sad = vp9_diamond_search_sad;
1868   cpi->refining_search_sad = vp9_refining_search_sad;
1869
1870   // make sure frame 1 is okay
1871   cpi->error_bins[0] = cpi->common.MBs;
1872
1873   /* vp9_init_quantizer() is first called here. Add check in
1874    * vp9_frame_init_quantizer() so that vp9_init_quantizer is only
1875    * called later when needed. This will avoid unnecessary calls of
1876    * vp9_init_quantizer() for every frame.
1877    */
1878   vp9_init_quantizer(cpi);
1879
1880   vp9_loop_filter_init(cm);
1881
1882   cpi->common.error.setjmp = 0;
1883
1884   vp9_zero(cpi->y_uv_mode_count);
1885
1886 #ifdef MODE_TEST_HIT_STATS
1887   vp9_zero(cpi->mode_test_hits);
1888 #endif
1889
1890   return (VP9_PTR) cpi;
1891 }
1892
1893 void vp9_remove_compressor(VP9_PTR *ptr) {
1894   VP9_COMP *cpi = (VP9_COMP *)(*ptr);
1895   int i;
1896
1897   if (!cpi)
1898     return;
1899
1900   if (cpi && (cpi->common.current_video_frame > 0)) {
1901     if (cpi->pass == 2) {
1902       vp9_end_second_pass(cpi);
1903     }
1904
1905 #ifdef ENTROPY_STATS
1906     if (cpi->pass != 1) {
1907       print_context_counters();
1908       print_tree_update_probs();
1909       print_mode_context(cpi);
1910     }
1911 #endif
1912
1913 #ifdef MODE_STATS
1914     if (cpi->pass != 1) {
1915       write_tx_count_stats();
1916       write_switchable_interp_stats();
1917     }
1918 #endif
1919
1920 #if CONFIG_INTERNAL_STATS
1921
1922     vp9_clear_system_state();
1923
1924     // printf("\n8x8-4x4:%d-%d\n", cpi->t8x8_count, cpi->t4x4_count);
1925     if (cpi->pass != 1) {
1926       FILE *f = fopen("opsnr.stt", "a");
1927       double time_encoded = (cpi->last_end_time_stamp_seen
1928                              - cpi->first_time_stamp_ever) / 10000000.000;
1929       double total_encode_time = (cpi->time_receive_data +
1930                                   cpi->time_compress_data)   / 1000.000;
1931       double dr = (double)cpi->bytes * (double) 8 / (double)1000
1932                   / time_encoded;
1933
1934       if (cpi->b_calculate_psnr) {
1935         YV12_BUFFER_CONFIG *lst_yv12 =
1936             &cpi->common.yv12_fb[cpi->common.ref_frame_map[cpi->lst_fb_idx]];
1937         double samples = 3.0 / 2 * cpi->count *
1938                          lst_yv12->y_width * lst_yv12->y_height;
1939         double total_psnr = vp9_mse2psnr(samples, 255.0, cpi->total_sq_error);
1940         double total_psnr2 = vp9_mse2psnr(samples, 255.0, cpi->total_sq_error2);
1941         double total_ssim = 100 * pow(cpi->summed_quality /
1942                                       cpi->summed_weights, 8.0);
1943         double total_ssimp = 100 * pow(cpi->summedp_quality /
1944                                        cpi->summedp_weights, 8.0);
1945
1946         fprintf(f, "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\t"
1947                 "VPXSSIM\tVPSSIMP\t  Time(ms)\n");
1948         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",
1949                 dr, cpi->total / cpi->count, total_psnr,
1950                 cpi->totalp / cpi->count, total_psnr2, total_ssim, total_ssimp,
1951                 total_encode_time);
1952       }
1953
1954       if (cpi->b_calculate_ssimg) {
1955         fprintf(f, "BitRate\tSSIM_Y\tSSIM_U\tSSIM_V\tSSIM_A\t  Time(ms)\n");
1956         fprintf(f, "%7.2f\t%6.4f\t%6.4f\t%6.4f\t%6.4f\t%8.0f\n", dr,
1957                 cpi->total_ssimg_y / cpi->count,
1958                 cpi->total_ssimg_u / cpi->count,
1959                 cpi->total_ssimg_v / cpi->count,
1960                 cpi->total_ssimg_all / cpi->count, total_encode_time);
1961       }
1962
1963       fclose(f);
1964     }
1965
1966 #endif
1967
1968 #ifdef MODE_TEST_HIT_STATS
1969     if (cpi->pass != 1) {
1970       double norm_per_pixel_mode_tests = 0;
1971       double norm_counts[BLOCK_SIZES];
1972       int i;
1973       int sb64_per_frame;
1974       int norm_factors[BLOCK_SIZES] =
1975         {256, 128, 128, 64, 32, 32, 16, 8, 8, 4, 2, 2, 1};
1976       FILE *f = fopen("mode_hit_stats.stt", "a");
1977
1978       // On average, how many mode tests do we do
1979       for (i = 0; i < BLOCK_SIZES; ++i) {
1980         norm_counts[i] = (double)cpi->mode_test_hits[i] /
1981                          (double)norm_factors[i];
1982         norm_per_pixel_mode_tests += norm_counts[i];
1983       }
1984       // Convert to a number per 64x64 and per frame
1985       sb64_per_frame = ((cpi->common.height + 63) / 64) *
1986                        ((cpi->common.width + 63) / 64);
1987       norm_per_pixel_mode_tests =
1988         norm_per_pixel_mode_tests /
1989         (double)(cpi->common.current_video_frame * sb64_per_frame);
1990
1991       fprintf(f, "%6.4f\n", norm_per_pixel_mode_tests);
1992       fclose(f);
1993     }
1994 #endif
1995
1996 #ifdef ENTROPY_STATS
1997     {
1998       int i, j, k;
1999       FILE *fmode = fopen("vp9_modecontext.c", "w");
2000
2001       fprintf(fmode, "\n#include \"vp9_entropymode.h\"\n\n");
2002       fprintf(fmode, "const unsigned int vp9_kf_default_bmode_counts ");
2003       fprintf(fmode, "[INTRA_MODES][INTRA_MODES]"
2004                      "[INTRA_MODES] =\n{\n");
2005
2006       for (i = 0; i < INTRA_MODES; i++) {
2007         fprintf(fmode, "    { // Above Mode :  %d\n", i);
2008
2009         for (j = 0; j < INTRA_MODES; j++) {
2010           fprintf(fmode, "        {");
2011
2012           for (k = 0; k < INTRA_MODES; k++) {
2013             if (!intra_mode_stats[i][j][k])
2014               fprintf(fmode, " %5d, ", 1);
2015             else
2016               fprintf(fmode, " %5d, ", intra_mode_stats[i][j][k]);
2017           }
2018
2019           fprintf(fmode, "}, // left_mode %d\n", j);
2020         }
2021
2022         fprintf(fmode, "    },\n");
2023       }
2024
2025       fprintf(fmode, "};\n");
2026       fclose(fmode);
2027     }
2028 #endif
2029
2030
2031 #if defined(SECTIONBITS_OUTPUT)
2032
2033     if (0) {
2034       int i;
2035       FILE *f = fopen("tokenbits.stt", "a");
2036
2037       for (i = 0; i < 28; i++)
2038         fprintf(f, "%8d", (int)(Sectionbits[i] / 256));
2039
2040       fprintf(f, "\n");
2041       fclose(f);
2042     }
2043
2044 #endif
2045
2046 #if 0
2047     {
2048       printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2049       printf("\n_frames recive_data encod_mb_row compress_frame  Total\n");
2050       printf("%6d %10ld %10ld %10ld %10ld\n", cpi->common.current_video_frame,
2051              cpi->time_receive_data / 1000, cpi->time_encode_sb_row / 1000,
2052              cpi->time_compress_data / 1000,
2053              (cpi->time_receive_data + cpi->time_compress_data) / 1000);
2054     }
2055 #endif
2056   }
2057
2058   free_pick_mode_context(&cpi->mb);
2059   dealloc_compressor_data(cpi);
2060   vpx_free(cpi->mb.ss);
2061   vpx_free(cpi->tok);
2062
2063   for (i = 0; i < sizeof(cpi->mbgraph_stats) /
2064                   sizeof(cpi->mbgraph_stats[0]); ++i) {
2065     vpx_free(cpi->mbgraph_stats[i].mb_stats);
2066   }
2067
2068   vp9_remove_common(&cpi->common);
2069   vpx_free(cpi);
2070   *ptr = 0;
2071
2072 #ifdef OUTPUT_YUV_SRC
2073   fclose(yuv_file);
2074 #endif
2075 #ifdef OUTPUT_YUV_REC
2076   fclose(yuv_rec_file);
2077 #endif
2078
2079 #if 0
2080
2081   if (keyfile)
2082     fclose(keyfile);
2083
2084   if (framepsnr)
2085     fclose(framepsnr);
2086
2087   if (kf_list)
2088     fclose(kf_list);
2089
2090 #endif
2091 }
2092
2093
2094 static uint64_t calc_plane_error(uint8_t *orig, int orig_stride,
2095                                  uint8_t *recon, int recon_stride,
2096                                  unsigned int cols, unsigned int rows) {
2097   unsigned int row, col;
2098   uint64_t total_sse = 0;
2099   int diff;
2100
2101   for (row = 0; row + 16 <= rows; row += 16) {
2102     for (col = 0; col + 16 <= cols; col += 16) {
2103       unsigned int sse;
2104
2105       vp9_mse16x16(orig + col, orig_stride, recon + col, recon_stride, &sse);
2106       total_sse += sse;
2107     }
2108
2109     /* Handle odd-sized width */
2110     if (col < cols) {
2111       unsigned int border_row, border_col;
2112       uint8_t *border_orig = orig;
2113       uint8_t *border_recon = recon;
2114
2115       for (border_row = 0; border_row < 16; border_row++) {
2116         for (border_col = col; border_col < cols; border_col++) {
2117           diff = border_orig[border_col] - border_recon[border_col];
2118           total_sse += diff * diff;
2119         }
2120
2121         border_orig += orig_stride;
2122         border_recon += recon_stride;
2123       }
2124     }
2125
2126     orig += orig_stride * 16;
2127     recon += recon_stride * 16;
2128   }
2129
2130   /* Handle odd-sized height */
2131   for (; row < rows; row++) {
2132     for (col = 0; col < cols; col++) {
2133       diff = orig[col] - recon[col];
2134       total_sse += diff * diff;
2135     }
2136
2137     orig += orig_stride;
2138     recon += recon_stride;
2139   }
2140
2141   return total_sse;
2142 }
2143
2144
2145 static void generate_psnr_packet(VP9_COMP *cpi) {
2146   YV12_BUFFER_CONFIG      *orig = cpi->Source;
2147   YV12_BUFFER_CONFIG      *recon = cpi->common.frame_to_show;
2148   struct vpx_codec_cx_pkt  pkt;
2149   uint64_t                 sse;
2150   int                      i;
2151   unsigned int             width = orig->y_crop_width;
2152   unsigned int             height = orig->y_crop_height;
2153
2154   pkt.kind = VPX_CODEC_PSNR_PKT;
2155   sse = calc_plane_error(orig->y_buffer, orig->y_stride,
2156                          recon->y_buffer, recon->y_stride,
2157                          width, height);
2158   pkt.data.psnr.sse[0] = sse;
2159   pkt.data.psnr.sse[1] = sse;
2160   pkt.data.psnr.samples[0] = width * height;
2161   pkt.data.psnr.samples[1] = width * height;
2162
2163   width = orig->uv_crop_width;
2164   height = orig->uv_crop_height;
2165
2166   sse = calc_plane_error(orig->u_buffer, orig->uv_stride,
2167                          recon->u_buffer, recon->uv_stride,
2168                          width, height);
2169   pkt.data.psnr.sse[0] += sse;
2170   pkt.data.psnr.sse[2] = sse;
2171   pkt.data.psnr.samples[0] += width * height;
2172   pkt.data.psnr.samples[2] = width * height;
2173
2174   sse = calc_plane_error(orig->v_buffer, orig->uv_stride,
2175                          recon->v_buffer, recon->uv_stride,
2176                          width, height);
2177   pkt.data.psnr.sse[0] += sse;
2178   pkt.data.psnr.sse[3] = sse;
2179   pkt.data.psnr.samples[0] += width * height;
2180   pkt.data.psnr.samples[3] = width * height;
2181
2182   for (i = 0; i < 4; i++)
2183     pkt.data.psnr.psnr[i] = vp9_mse2psnr(pkt.data.psnr.samples[i], 255.0,
2184                                          (double)pkt.data.psnr.sse[i]);
2185
2186   vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
2187 }
2188
2189
2190 int vp9_use_as_reference(VP9_PTR ptr, int ref_frame_flags) {
2191   VP9_COMP *cpi = (VP9_COMP *)(ptr);
2192
2193   if (ref_frame_flags > 7)
2194     return -1;
2195
2196   cpi->ref_frame_flags = ref_frame_flags;
2197   return 0;
2198 }
2199 int vp9_update_reference(VP9_PTR ptr, int ref_frame_flags) {
2200   VP9_COMP *cpi = (VP9_COMP *)(ptr);
2201
2202   if (ref_frame_flags > 7)
2203     return -1;
2204
2205   cpi->refresh_golden_frame = 0;
2206   cpi->refresh_alt_ref_frame = 0;
2207   cpi->refresh_last_frame   = 0;
2208
2209   if (ref_frame_flags & VP9_LAST_FLAG)
2210     cpi->refresh_last_frame = 1;
2211
2212   if (ref_frame_flags & VP9_GOLD_FLAG)
2213     cpi->refresh_golden_frame = 1;
2214
2215   if (ref_frame_flags & VP9_ALT_FLAG)
2216     cpi->refresh_alt_ref_frame = 1;
2217
2218   return 0;
2219 }
2220
2221 int vp9_copy_reference_enc(VP9_PTR ptr, VP9_REFFRAME ref_frame_flag,
2222                            YV12_BUFFER_CONFIG *sd) {
2223   VP9_COMP *cpi = (VP9_COMP *)(ptr);
2224   VP9_COMMON *cm = &cpi->common;
2225   int ref_fb_idx;
2226
2227   if (ref_frame_flag == VP9_LAST_FLAG)
2228     ref_fb_idx = cm->ref_frame_map[cpi->lst_fb_idx];
2229   else if (ref_frame_flag == VP9_GOLD_FLAG)
2230     ref_fb_idx = cm->ref_frame_map[cpi->gld_fb_idx];
2231   else if (ref_frame_flag == VP9_ALT_FLAG)
2232     ref_fb_idx = cm->ref_frame_map[cpi->alt_fb_idx];
2233   else
2234     return -1;
2235
2236   vp8_yv12_copy_frame(&cm->yv12_fb[ref_fb_idx], sd);
2237
2238   return 0;
2239 }
2240
2241 int vp9_get_reference_enc(VP9_PTR ptr, int index, YV12_BUFFER_CONFIG **fb) {
2242   VP9_COMP *cpi = (VP9_COMP *)(ptr);
2243   VP9_COMMON *cm = &cpi->common;
2244
2245   if (index < 0 || index >= NUM_REF_FRAMES)
2246     return -1;
2247
2248   *fb = &cm->yv12_fb[cm->ref_frame_map[index]];
2249   return 0;
2250 }
2251
2252 int vp9_set_reference_enc(VP9_PTR ptr, VP9_REFFRAME ref_frame_flag,
2253                           YV12_BUFFER_CONFIG *sd) {
2254   VP9_COMP *cpi = (VP9_COMP *)(ptr);
2255   VP9_COMMON *cm = &cpi->common;
2256
2257   int ref_fb_idx;
2258
2259   if (ref_frame_flag == VP9_LAST_FLAG)
2260     ref_fb_idx = cm->ref_frame_map[cpi->lst_fb_idx];
2261   else if (ref_frame_flag == VP9_GOLD_FLAG)
2262     ref_fb_idx = cm->ref_frame_map[cpi->gld_fb_idx];
2263   else if (ref_frame_flag == VP9_ALT_FLAG)
2264     ref_fb_idx = cm->ref_frame_map[cpi->alt_fb_idx];
2265   else
2266     return -1;
2267
2268   vp8_yv12_copy_frame(sd, &cm->yv12_fb[ref_fb_idx]);
2269
2270   return 0;
2271 }
2272 int vp9_update_entropy(VP9_PTR comp, int update) {
2273   ((VP9_COMP *)comp)->common.refresh_frame_context = update;
2274   return 0;
2275 }
2276
2277
2278 #ifdef OUTPUT_YUV_SRC
2279 void vp9_write_yuv_frame(YV12_BUFFER_CONFIG *s) {
2280   uint8_t *src = s->y_buffer;
2281   int h = s->y_height;
2282
2283   do {
2284     fwrite(src, s->y_width, 1,  yuv_file);
2285     src += s->y_stride;
2286   } while (--h);
2287
2288   src = s->u_buffer;
2289   h = s->uv_height;
2290
2291   do {
2292     fwrite(src, s->uv_width, 1,  yuv_file);
2293     src += s->uv_stride;
2294   } while (--h);
2295
2296   src = s->v_buffer;
2297   h = s->uv_height;
2298
2299   do {
2300     fwrite(src, s->uv_width, 1, yuv_file);
2301     src += s->uv_stride;
2302   } while (--h);
2303 }
2304 #endif
2305
2306 #ifdef OUTPUT_YUV_REC
2307 void vp9_write_yuv_rec_frame(VP9_COMMON *cm) {
2308   YV12_BUFFER_CONFIG *s = cm->frame_to_show;
2309   uint8_t *src = s->y_buffer;
2310   int h = cm->height;
2311
2312   do {
2313     fwrite(src, s->y_width, 1,  yuv_rec_file);
2314     src += s->y_stride;
2315   } while (--h);
2316
2317   src = s->u_buffer;
2318   h = s->uv_height;
2319
2320   do {
2321     fwrite(src, s->uv_width, 1,  yuv_rec_file);
2322     src += s->uv_stride;
2323   } while (--h);
2324
2325   src = s->v_buffer;
2326   h = s->uv_height;
2327
2328   do {
2329     fwrite(src, s->uv_width, 1, yuv_rec_file);
2330     src += s->uv_stride;
2331   } while (--h);
2332
2333 #if CONFIG_ALPHA
2334   if (s->alpha_buffer) {
2335     src = s->alpha_buffer;
2336     h = s->alpha_height;
2337     do {
2338       fwrite(src, s->alpha_width, 1,  yuv_rec_file);
2339       src += s->alpha_stride;
2340     } while (--h);
2341   }
2342 #endif
2343
2344   fflush(yuv_rec_file);
2345 }
2346 #endif
2347
2348 static void scale_and_extend_frame(YV12_BUFFER_CONFIG *src_fb,
2349                                    YV12_BUFFER_CONFIG *dst_fb) {
2350   const int in_w = src_fb->y_crop_width;
2351   const int in_h = src_fb->y_crop_height;
2352   const int out_w = dst_fb->y_crop_width;
2353   const int out_h = dst_fb->y_crop_height;
2354   int x, y, i;
2355
2356   uint8_t *srcs[4] = {src_fb->y_buffer, src_fb->u_buffer, src_fb->v_buffer,
2357                       src_fb->alpha_buffer};
2358   int src_strides[4] = {src_fb->y_stride, src_fb->uv_stride, src_fb->uv_stride,
2359                         src_fb->alpha_stride};
2360
2361   uint8_t *dsts[4] = {dst_fb->y_buffer, dst_fb->u_buffer, dst_fb->v_buffer,
2362                       dst_fb->alpha_buffer};
2363   int dst_strides[4] = {dst_fb->y_stride, dst_fb->uv_stride, dst_fb->uv_stride,
2364                         dst_fb->alpha_stride};
2365
2366   for (y = 0; y < out_h; y += 16) {
2367     for (x = 0; x < out_w; x += 16) {
2368       for (i = 0; i < MAX_MB_PLANE; ++i) {
2369         const int factor = i == 0 ? 1 : 2;
2370         const int x_q4 = x * (16 / factor) * in_w / out_w;
2371         const int y_q4 = y * (16 / factor) * in_h / out_h;
2372         const int src_stride = src_strides[i];
2373         const int dst_stride = dst_strides[i];
2374         uint8_t *src = srcs[i] + y / factor * in_h / out_h * src_stride +
2375                                  x / factor * in_w / out_w;
2376         uint8_t *dst = dsts[i] + y / factor * dst_stride + x / factor;
2377
2378         vp9_convolve8(src, src_stride, dst, dst_stride,
2379                       vp9_sub_pel_filters_8[x_q4 & 0xf], 16 * in_w / out_w,
2380                       vp9_sub_pel_filters_8[y_q4 & 0xf], 16 * in_h / out_h,
2381                       16 / factor, 16 / factor);
2382       }
2383     }
2384   }
2385
2386   vp8_yv12_extend_frame_borders(dst_fb);
2387 }
2388
2389
2390 static void update_alt_ref_frame_stats(VP9_COMP *cpi) {
2391   // this frame refreshes means next frames don't unless specified by user
2392   cpi->frames_since_golden = 0;
2393
2394 #if CONFIG_MULTIPLE_ARF
2395   if (!cpi->multi_arf_enabled)
2396 #endif
2397     // Clear the alternate reference update pending flag.
2398     cpi->source_alt_ref_pending = 0;
2399
2400   // Set the alternate reference frame active flag
2401   cpi->source_alt_ref_active = 1;
2402 }
2403 static void update_golden_frame_stats(VP9_COMP *cpi) {
2404   // Update the Golden frame usage counts.
2405   if (cpi->refresh_golden_frame) {
2406     // this frame refreshes means next frames don't unless specified by user
2407     cpi->refresh_golden_frame = 0;
2408     cpi->frames_since_golden = 0;
2409
2410     // ******** Fixed Q test code only ************
2411     // If we are going to use the ALT reference for the next group of frames
2412     // set a flag to say so.
2413     if (cpi->oxcf.fixed_q >= 0 &&
2414         cpi->oxcf.play_alternate && !cpi->refresh_alt_ref_frame) {
2415       cpi->source_alt_ref_pending = 1;
2416       cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
2417
2418       // TODO(ivan): For SVC encoder, GF automatic update is disabled by using
2419       // a large GF_interval.
2420       if (cpi->use_svc) {
2421         cpi->frames_till_gf_update_due = INT_MAX;
2422       }
2423     }
2424
2425     if (!cpi->source_alt_ref_pending)
2426       cpi->source_alt_ref_active = 0;
2427
2428     // Decrement count down till next gf
2429     if (cpi->frames_till_gf_update_due > 0)
2430       cpi->frames_till_gf_update_due--;
2431
2432   } else if (!cpi->refresh_alt_ref_frame) {
2433     // Decrement count down till next gf
2434     if (cpi->frames_till_gf_update_due > 0)
2435       cpi->frames_till_gf_update_due--;
2436
2437     if (cpi->frames_till_alt_ref_frame)
2438       cpi->frames_till_alt_ref_frame--;
2439
2440     cpi->frames_since_golden++;
2441   }
2442 }
2443
2444 static int find_fp_qindex() {
2445   int i;
2446
2447   for (i = 0; i < QINDEX_RANGE; i++) {
2448     if (vp9_convert_qindex_to_q(i) >= 30.0) {
2449       break;
2450     }
2451   }
2452
2453   if (i == QINDEX_RANGE)
2454     i--;
2455
2456   return i;
2457 }
2458
2459 static void Pass1Encode(VP9_COMP *cpi, unsigned long *size, unsigned char *dest,
2460                         unsigned int *frame_flags) {
2461   (void) size;
2462   (void) dest;
2463   (void) frame_flags;
2464
2465   vp9_set_quantizer(cpi, find_fp_qindex());
2466   vp9_first_pass(cpi);
2467 }
2468
2469 #define WRITE_RECON_BUFFER 0
2470 #if WRITE_RECON_BUFFER
2471 void write_cx_frame_to_file(YV12_BUFFER_CONFIG *frame, int this_frame) {
2472   FILE *yframe;
2473   int i;
2474   char filename[255];
2475
2476   snprintf(filename, sizeof(filename), "cx\\y%04d.raw", this_frame);
2477   yframe = fopen(filename, "wb");
2478
2479   for (i = 0; i < frame->y_height; i++)
2480     fwrite(frame->y_buffer + i * frame->y_stride,
2481            frame->y_width, 1, yframe);
2482
2483   fclose(yframe);
2484   snprintf(filename, sizeof(filename), "cx\\u%04d.raw", this_frame);
2485   yframe = fopen(filename, "wb");
2486
2487   for (i = 0; i < frame->uv_height; i++)
2488     fwrite(frame->u_buffer + i * frame->uv_stride,
2489            frame->uv_width, 1, yframe);
2490
2491   fclose(yframe);
2492   snprintf(filename, sizeof(filename), "cx\\v%04d.raw", this_frame);
2493   yframe = fopen(filename, "wb");
2494
2495   for (i = 0; i < frame->uv_height; i++)
2496     fwrite(frame->v_buffer + i * frame->uv_stride,
2497            frame->uv_width, 1, yframe);
2498
2499   fclose(yframe);
2500 }
2501 #endif
2502
2503 static double compute_edge_pixel_proportion(YV12_BUFFER_CONFIG *frame) {
2504 #define EDGE_THRESH 128
2505   int i, j;
2506   int num_edge_pels = 0;
2507   int num_pels = (frame->y_height - 2) * (frame->y_width - 2);
2508   uint8_t *prev = frame->y_buffer + 1;
2509   uint8_t *curr = frame->y_buffer + 1 + frame->y_stride;
2510   uint8_t *next = frame->y_buffer + 1 + 2 * frame->y_stride;
2511   for (i = 1; i < frame->y_height - 1; i++) {
2512     for (j = 1; j < frame->y_width - 1; j++) {
2513       /* Sobel hor and ver gradients */
2514       int v = 2 * (curr[1] - curr[-1]) + (prev[1] - prev[-1]) +
2515               (next[1] - next[-1]);
2516       int h = 2 * (prev[0] - next[0]) + (prev[1] - next[1]) +
2517               (prev[-1] - next[-1]);
2518       h = (h < 0 ? -h : h);
2519       v = (v < 0 ? -v : v);
2520       if (h > EDGE_THRESH || v > EDGE_THRESH)
2521         num_edge_pels++;
2522       curr++;
2523       prev++;
2524       next++;
2525     }
2526     curr += frame->y_stride - frame->y_width + 2;
2527     prev += frame->y_stride - frame->y_width + 2;
2528     next += frame->y_stride - frame->y_width + 2;
2529   }
2530   return (double)num_edge_pels / num_pels;
2531 }
2532
2533 // Function to test for conditions that indicate we should loop
2534 // back and recode a frame.
2535 static int recode_loop_test(VP9_COMP *cpi,
2536                             int high_limit, int low_limit,
2537                             int q, int maxq, int minq) {
2538   int force_recode = 0;
2539   VP9_COMMON *cm = &cpi->common;
2540
2541   // Is frame recode allowed at all
2542   // Yes if either recode mode 1 is selected or mode two is selected
2543   // and the frame is a key frame. golden frame or alt_ref_frame
2544   if ((cpi->sf.recode_loop == 1) ||
2545       ((cpi->sf.recode_loop == 2) &&
2546        ((cm->frame_type == KEY_FRAME) ||
2547         cpi->refresh_golden_frame ||
2548         cpi->refresh_alt_ref_frame))) {
2549     // General over and under shoot tests
2550     if (((cpi->projected_frame_size > high_limit) && (q < maxq)) ||
2551         ((cpi->projected_frame_size < low_limit) && (q > minq))) {
2552       force_recode = 1;
2553     } else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
2554       // Deal with frame undershoot and whether or not we are
2555       // below the automatically set cq level.
2556       if (q > cpi->cq_target_quality &&
2557           cpi->projected_frame_size < ((cpi->this_frame_target * 7) >> 3)) {
2558         force_recode = 1;
2559       } else if (q > cpi->oxcf.cq_level &&
2560                  cpi->projected_frame_size < cpi->min_frame_bandwidth &&
2561                  cpi->active_best_quality > cpi->oxcf.cq_level) {
2562         // Severe undershoot and between auto and user cq level
2563         force_recode = 1;
2564         cpi->active_best_quality = cpi->oxcf.cq_level;
2565       }
2566     }
2567   }
2568
2569   return force_recode;
2570 }
2571
2572 static void update_reference_frames(VP9_COMP * const cpi) {
2573   VP9_COMMON * const cm = &cpi->common;
2574
2575   // At this point the new frame has been encoded.
2576   // If any buffer copy / swapping is signaled it should be done here.
2577   if (cm->frame_type == KEY_FRAME) {
2578     ref_cnt_fb(cm->fb_idx_ref_cnt,
2579                &cm->ref_frame_map[cpi->gld_fb_idx], cm->new_fb_idx);
2580     ref_cnt_fb(cm->fb_idx_ref_cnt,
2581                &cm->ref_frame_map[cpi->alt_fb_idx], cm->new_fb_idx);
2582   }
2583 #if CONFIG_MULTIPLE_ARF
2584   else if (!cpi->multi_arf_enabled && cpi->refresh_golden_frame &&
2585       !cpi->refresh_alt_ref_frame) {
2586 #else
2587   else if (cpi->refresh_golden_frame && !cpi->refresh_alt_ref_frame &&
2588            !cpi->use_svc) {
2589 #endif
2590     /* Preserve the previously existing golden frame and update the frame in
2591      * the alt ref slot instead. This is highly specific to the current use of
2592      * alt-ref as a forward reference, and this needs to be generalized as
2593      * other uses are implemented (like RTC/temporal scaling)
2594      *
2595      * The update to the buffer in the alt ref slot was signaled in
2596      * vp9_pack_bitstream(), now swap the buffer pointers so that it's treated
2597      * as the golden frame next time.
2598      */
2599     int tmp;
2600
2601     ref_cnt_fb(cm->fb_idx_ref_cnt,
2602                &cm->ref_frame_map[cpi->alt_fb_idx], cm->new_fb_idx);
2603
2604     tmp = cpi->alt_fb_idx;
2605     cpi->alt_fb_idx = cpi->gld_fb_idx;
2606     cpi->gld_fb_idx = tmp;
2607   }  else { /* For non key/golden frames */
2608     if (cpi->refresh_alt_ref_frame) {
2609       int arf_idx = cpi->alt_fb_idx;
2610 #if CONFIG_MULTIPLE_ARF
2611       if (cpi->multi_arf_enabled) {
2612         arf_idx = cpi->arf_buffer_idx[cpi->sequence_number + 1];
2613       }
2614 #endif
2615       ref_cnt_fb(cm->fb_idx_ref_cnt,
2616                  &cm->ref_frame_map[arf_idx], cm->new_fb_idx);
2617     }
2618
2619     if (cpi->refresh_golden_frame) {
2620       ref_cnt_fb(cm->fb_idx_ref_cnt,
2621                  &cm->ref_frame_map[cpi->gld_fb_idx], cm->new_fb_idx);
2622     }
2623   }
2624
2625   if (cpi->refresh_last_frame) {
2626     ref_cnt_fb(cm->fb_idx_ref_cnt,
2627                &cm->ref_frame_map[cpi->lst_fb_idx], cm->new_fb_idx);
2628   }
2629 }
2630
2631 static void loopfilter_frame(VP9_COMP *cpi, VP9_COMMON *cm) {
2632   MACROBLOCKD *xd = &cpi->mb.e_mbd;
2633   struct loopfilter *lf = &cm->lf;
2634   if (xd->lossless) {
2635       lf->filter_level = 0;
2636   } else {
2637     struct vpx_usec_timer timer;
2638
2639     vp9_clear_system_state();
2640
2641     vpx_usec_timer_start(&timer);
2642
2643     vp9_pick_filter_level(cpi->Source, cpi, cpi->sf.use_fast_lpf_pick);
2644
2645     vpx_usec_timer_mark(&timer);
2646     cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
2647   }
2648
2649   if (lf->filter_level > 0) {
2650     vp9_set_alt_lf_level(cpi, lf->filter_level);
2651     vp9_loop_filter_frame(cm, xd, lf->filter_level, 0, 0);
2652   }
2653
2654   vp9_extend_frame_inner_borders(cm->frame_to_show,
2655                                  cm->subsampling_x, cm->subsampling_y);
2656 }
2657
2658 static void scale_references(VP9_COMP *cpi) {
2659   VP9_COMMON *cm = &cpi->common;
2660   int i;
2661   int refs[ALLOWED_REFS_PER_FRAME] = {cpi->lst_fb_idx, cpi->gld_fb_idx,
2662                                       cpi->alt_fb_idx};
2663
2664   for (i = 0; i < 3; i++) {
2665     YV12_BUFFER_CONFIG *ref = &cm->yv12_fb[cm->ref_frame_map[refs[i]]];
2666
2667     if (ref->y_crop_width != cm->width ||
2668         ref->y_crop_height != cm->height) {
2669       int new_fb = get_free_fb(cm);
2670
2671       vp9_realloc_frame_buffer(&cm->yv12_fb[new_fb],
2672                                cm->width, cm->height,
2673                                cm->subsampling_x, cm->subsampling_y,
2674                                VP9BORDERINPIXELS);
2675       scale_and_extend_frame(ref, &cm->yv12_fb[new_fb]);
2676       cpi->scaled_ref_idx[i] = new_fb;
2677     } else {
2678       cpi->scaled_ref_idx[i] = cm->ref_frame_map[refs[i]];
2679       cm->fb_idx_ref_cnt[cm->ref_frame_map[refs[i]]]++;
2680     }
2681   }
2682 }
2683
2684 static void release_scaled_references(VP9_COMP *cpi) {
2685   VP9_COMMON *cm = &cpi->common;
2686   int i;
2687
2688   for (i = 0; i < 3; i++)
2689     cm->fb_idx_ref_cnt[cpi->scaled_ref_idx[i]]--;
2690 }
2691
2692 static void full_to_model_count(unsigned int *model_count,
2693                                 unsigned int *full_count) {
2694   int n;
2695   model_count[ZERO_TOKEN] = full_count[ZERO_TOKEN];
2696   model_count[ONE_TOKEN] = full_count[ONE_TOKEN];
2697   model_count[TWO_TOKEN] = full_count[TWO_TOKEN];
2698   for (n = THREE_TOKEN; n < DCT_EOB_TOKEN; ++n)
2699     model_count[TWO_TOKEN] += full_count[n];
2700   model_count[DCT_EOB_MODEL_TOKEN] = full_count[DCT_EOB_TOKEN];
2701 }
2702
2703 static void full_to_model_counts(
2704     vp9_coeff_count_model *model_count, vp9_coeff_count *full_count) {
2705   int i, j, k, l;
2706   for (i = 0; i < BLOCK_TYPES; ++i)
2707     for (j = 0; j < REF_TYPES; ++j)
2708       for (k = 0; k < COEF_BANDS; ++k)
2709         for (l = 0; l < PREV_COEF_CONTEXTS; ++l) {
2710           if (l >= 3 && k == 0)
2711             continue;
2712           full_to_model_count(model_count[i][j][k][l], full_count[i][j][k][l]);
2713         }
2714 }
2715
2716 #if 0 && CONFIG_INTERNAL_STATS
2717 static void output_frame_level_debug_stats(VP9_COMP *cpi) {
2718   VP9_COMMON *const cm = &cpi->common;
2719   FILE *const f = fopen("tmp.stt", cm->current_video_frame ? "a" : "w");
2720   int recon_err;
2721
2722   vp9_clear_system_state();  // __asm emms;
2723
2724   recon_err = vp9_calc_ss_err(cpi->Source, get_frame_new_buffer(cm));
2725
2726   if (cpi->twopass.total_left_stats.coded_error != 0.0)
2727     fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %10d"
2728         "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f"
2729         "%6d %6d %5d %5d %5d %8.2f %10d %10.3f"
2730         "%10.3f %8d %10d %10d %10d\n",
2731         cpi->common.current_video_frame, cpi->this_frame_target,
2732         cpi->projected_frame_size, 0,
2733         (cpi->projected_frame_size - cpi->this_frame_target),
2734         (int)cpi->total_target_vs_actual,
2735         (int)(cpi->oxcf.starting_buffer_level - cpi->bits_off_target),
2736         (int)cpi->total_actual_bits, cm->base_qindex,
2737         vp9_convert_qindex_to_q(cm->base_qindex),
2738         (double)vp9_dc_quant(cm->base_qindex, 0) / 4.0,
2739         vp9_convert_qindex_to_q(cpi->active_best_quality),
2740         vp9_convert_qindex_to_q(cpi->active_worst_quality), cpi->avg_q,
2741         vp9_convert_qindex_to_q(cpi->ni_av_qi),
2742         vp9_convert_qindex_to_q(cpi->cq_target_quality),
2743         cpi->refresh_last_frame, cpi->refresh_golden_frame,
2744         cpi->refresh_alt_ref_frame, cm->frame_type, cpi->gfu_boost,
2745         cpi->twopass.est_max_qcorrection_factor, (int)cpi->twopass.bits_left,
2746         cpi->twopass.total_left_stats.coded_error,
2747         (double)cpi->twopass.bits_left /
2748             (1 + cpi->twopass.total_left_stats.coded_error),
2749         cpi->tot_recode_hits, recon_err, cpi->kf_boost, cpi->kf_zeromotion_pct);
2750
2751   fclose(f);
2752
2753   if (0) {
2754     FILE *const fmodes = fopen("Modes.stt", "a");
2755     int i;
2756
2757     fprintf(fmodes, "%6d:%1d:%1d:%1d ", cpi->common.current_video_frame,
2758             cm->frame_type, cpi->refresh_golden_frame,
2759             cpi->refresh_alt_ref_frame);
2760
2761     for (i = 0; i < MAX_MODES; ++i)
2762       fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
2763     for (i = 0; i < MAX_REFS; ++i)
2764       fprintf(fmodes, "%5d ", cpi->sub8x8_mode_chosen_counts[i]);
2765
2766     fprintf(fmodes, "\n");
2767
2768     fclose(fmodes);
2769   }
2770 }
2771 #endif
2772
2773 static int pick_q_and_adjust_q_bounds(VP9_COMP *cpi,
2774                                       int * bottom_index, int * top_index) {
2775   // Set an active best quality and if necessary active worst quality
2776   int q = cpi->active_worst_quality;
2777   VP9_COMMON *const cm = &cpi->common;
2778
2779   if (frame_is_intra_only(cm)) {
2780 #if !CONFIG_MULTIPLE_ARF
2781     // Handle the special case for key frames forced when we have75 reached
2782     // the maximum key frame interval. Here force the Q to a range
2783     // based on the ambient Q to reduce the risk of popping.
2784     if (cpi->this_key_frame_forced) {
2785       int delta_qindex;
2786       int qindex = cpi->last_boosted_qindex;
2787       double last_boosted_q = vp9_convert_qindex_to_q(qindex);
2788
2789       delta_qindex = vp9_compute_qdelta(cpi, last_boosted_q,
2790                                         (last_boosted_q * 0.75));
2791
2792       cpi->active_best_quality = MAX(qindex + delta_qindex,
2793                                      cpi->best_quality);
2794     } else {
2795       int high = 5000;
2796       int low = 400;
2797       double q_adj_factor = 1.0;
2798       double q_val;
2799
2800       // Baseline value derived from cpi->active_worst_quality and kf boost
2801       cpi->active_best_quality = get_active_quality(q, cpi->kf_boost,
2802                                                     low, high,
2803                                                     kf_low_motion_minq,
2804                                                     kf_high_motion_minq);
2805
2806       // Allow somewhat lower kf minq with small image formats.
2807       if ((cm->width * cm->height) <= (352 * 288)) {
2808         q_adj_factor -= 0.25;
2809       }
2810
2811       // Make a further adjustment based on the kf zero motion measure.
2812       q_adj_factor += 0.05 - (0.001 * (double)cpi->kf_zeromotion_pct);
2813
2814       // Convert the adjustment factor to a qindex delta
2815       // on active_best_quality.
2816       q_val = vp9_convert_qindex_to_q(cpi->active_best_quality);
2817       cpi->active_best_quality +=
2818           vp9_compute_qdelta(cpi, q_val, (q_val * q_adj_factor));
2819     }
2820 #else
2821     double current_q;
2822     // Force the KF quantizer to be 30% of the active_worst_quality.
2823     current_q = vp9_convert_qindex_to_q(cpi->active_worst_quality);
2824     cpi->active_best_quality = cpi->active_worst_quality
2825         + vp9_compute_qdelta(cpi, current_q, current_q * 0.3);
2826 #endif
2827   } else if (!cpi->is_src_frame_alt_ref &&
2828              (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
2829     int high = 2000;
2830     int low = 400;
2831
2832     // Use the lower of cpi->active_worst_quality and recent
2833     // average Q as basis for GF/ARF best Q limit unless last frame was
2834     // a key frame.
2835     if (cpi->frames_since_key > 1 &&
2836         cpi->avg_frame_qindex < cpi->active_worst_quality) {
2837       q = cpi->avg_frame_qindex;
2838     }
2839     // For constrained quality dont allow Q less than the cq level
2840     if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
2841       if (q < cpi->cq_target_quality)
2842         q = cpi->cq_target_quality;
2843       if (cpi->frames_since_key > 1) {
2844         cpi->active_best_quality = get_active_quality(q, cpi->gfu_boost,
2845                                                       low, high,
2846                                                       afq_low_motion_minq,
2847                                                       afq_high_motion_minq);
2848       } else {
2849         cpi->active_best_quality = get_active_quality(q, cpi->gfu_boost,
2850                                                       low, high,
2851                                                       gf_low_motion_minq,
2852                                                       gf_high_motion_minq);
2853       }
2854       // Constrained quality use slightly lower active best.
2855       cpi->active_best_quality = cpi->active_best_quality * 15 / 16;
2856
2857     } else if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
2858       if (!cpi->refresh_alt_ref_frame) {
2859         cpi->active_best_quality = cpi->cq_target_quality;
2860       } else {
2861         if (cpi->frames_since_key > 1) {
2862           cpi->active_best_quality = get_active_quality(q, cpi->gfu_boost,
2863                                                         low, high,
2864                                                         afq_low_motion_minq,
2865                                                         afq_high_motion_minq);
2866         } else {
2867           cpi->active_best_quality = get_active_quality(q, cpi->gfu_boost,
2868                                                         low, high,
2869                                                         gf_low_motion_minq,
2870                                                         gf_high_motion_minq);
2871         }
2872       }
2873     } else {
2874         cpi->active_best_quality = get_active_quality(q, cpi->gfu_boost,
2875                                                       low, high,
2876                                                       gf_low_motion_minq,
2877                                                       gf_high_motion_minq);
2878     }
2879   } else {
2880     if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
2881       cpi->active_best_quality = cpi->cq_target_quality;
2882     } else {
2883       cpi->active_best_quality = inter_minq[q];
2884       // 1-pass: for now, use the average Q for the active_best, if its lower
2885       // than active_worst.
2886       if (cpi->pass == 0 && (cpi->avg_frame_qindex < q))
2887         cpi->active_best_quality = inter_minq[cpi->avg_frame_qindex];
2888
2889       // For the constrained quality mode we don't want
2890       // q to fall below the cq level.
2891       if ((cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
2892           (cpi->active_best_quality < cpi->cq_target_quality)) {
2893         // If we are strongly undershooting the target rate in the last
2894         // frames then use the user passed in cq value not the auto
2895         // cq value.
2896         if (cpi->rolling_actual_bits < cpi->min_frame_bandwidth)
2897           cpi->active_best_quality = cpi->oxcf.cq_level;
2898         else
2899           cpi->active_best_quality = cpi->cq_target_quality;
2900       }
2901     }
2902   }
2903
2904   // Clip the active best and worst quality values to limits
2905   if (cpi->active_worst_quality > cpi->worst_quality)
2906     cpi->active_worst_quality = cpi->worst_quality;
2907
2908   if (cpi->active_best_quality < cpi->best_quality)
2909     cpi->active_best_quality = cpi->best_quality;
2910
2911   if (cpi->active_best_quality > cpi->worst_quality)
2912     cpi->active_best_quality = cpi->worst_quality;
2913
2914   if (cpi->active_worst_quality < cpi->active_best_quality)
2915     cpi->active_worst_quality = cpi->active_best_quality;
2916
2917   // Limit Q range for the adaptive loop.
2918   if (cm->frame_type == KEY_FRAME && !cpi->this_key_frame_forced) {
2919     *top_index =
2920       (cpi->active_worst_quality + cpi->active_best_quality * 3) / 4;
2921     // If this is the first (key) frame in 1-pass, active best is the user
2922     // best-allowed, and leave the top_index to active_worst.
2923     if (cpi->pass == 0 && cpi->common.current_video_frame == 0) {
2924       cpi->active_best_quality = cpi->oxcf.best_allowed_q;
2925       *top_index = cpi->oxcf.worst_allowed_q;
2926     }
2927   } else if (!cpi->is_src_frame_alt_ref &&
2928              (cpi->oxcf.end_usage != USAGE_STREAM_FROM_SERVER) &&
2929              (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
2930     *top_index =
2931       (cpi->active_worst_quality + cpi->active_best_quality) / 2;
2932   } else {
2933     *top_index = cpi->active_worst_quality;
2934   }
2935   *bottom_index = cpi->active_best_quality;
2936
2937   if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
2938     q = cpi->active_best_quality;
2939   // Special case code to try and match quality with forced key frames
2940   } else if ((cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced) {
2941     q = cpi->last_boosted_qindex;
2942   } else {
2943     // Determine initial Q to try.
2944     if (cpi->pass == 0) {
2945       // 1-pass: for now, use per-frame-bw for target size of frame, scaled
2946       // by |x| for key frame.
2947       int scale = (cm->frame_type == KEY_FRAME) ? 5 : 1;
2948       q = vp9_regulate_q(cpi, scale * cpi->av_per_frame_bandwidth);
2949     } else {
2950       q = vp9_regulate_q(cpi, cpi->this_frame_target);
2951     }
2952     if (q > *top_index)
2953       q = *top_index;
2954   }
2955
2956   return q;
2957 }
2958 static void encode_frame_to_data_rate(VP9_COMP *cpi,
2959                                       unsigned long *size,
2960                                       unsigned char *dest,
2961                                       unsigned int *frame_flags) {
2962   VP9_COMMON *const cm = &cpi->common;
2963   TX_SIZE t;
2964   int q;
2965   int frame_over_shoot_limit;
2966   int frame_under_shoot_limit;
2967
2968   int loop = 0;
2969   int loop_count;
2970
2971   int q_low;
2972   int q_high;
2973
2974   int top_index;
2975   int bottom_index;
2976   int active_worst_qchanged = 0;
2977
2978   int overshoot_seen = 0;
2979   int undershoot_seen = 0;
2980
2981   SPEED_FEATURES *const sf = &cpi->sf;
2982   unsigned int max_mv_def = MIN(cpi->common.width, cpi->common.height);
2983   struct segmentation *const seg = &cm->seg;
2984
2985   /* Scale the source buffer, if required. */
2986   if (cm->mi_cols * 8 != cpi->un_scaled_source->y_width ||
2987       cm->mi_rows * 8 != cpi->un_scaled_source->y_height) {
2988     scale_and_extend_frame(cpi->un_scaled_source, &cpi->scaled_source);
2989     cpi->Source = &cpi->scaled_source;
2990   } else {
2991     cpi->Source = cpi->un_scaled_source;
2992   }
2993   scale_references(cpi);
2994
2995   // Clear down mmx registers to allow floating point in what follows.
2996   vp9_clear_system_state();
2997
2998   // For an alt ref frame in 2 pass we skip the call to the second
2999   // pass function that sets the target bandwidth so we must set it here.
3000   if (cpi->refresh_alt_ref_frame) {
3001     // Set a per frame bit target for the alt ref frame.
3002     cpi->per_frame_bandwidth = cpi->twopass.gf_bits;
3003     // Set a per second target bitrate.
3004     cpi->target_bandwidth = (int)(cpi->twopass.gf_bits * cpi->output_framerate);
3005   }
3006
3007   // Clear zbin over-quant value and mode boost values.
3008   cpi->zbin_mode_boost = 0;
3009
3010   // Enable or disable mode based tweaking of the zbin.
3011   // For 2 pass only used where GF/ARF prediction quality
3012   // is above a threshold.
3013   cpi->zbin_mode_boost = 0;
3014   cpi->zbin_mode_boost_enabled = 0;
3015
3016   // Current default encoder behavior for the altref sign bias.
3017   cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = cpi->source_alt_ref_active;
3018
3019   // Check to see if a key frame is signaled.
3020   // For two pass with auto key frame enabled cm->frame_type may already be
3021   // set, but not for one pass.
3022   if ((cm->current_video_frame == 0) ||
3023       (cm->frame_flags & FRAMEFLAGS_KEY) ||
3024       (cpi->oxcf.auto_key && (cpi->frames_since_key %
3025                               cpi->key_frame_frequency == 0))) {
3026     // Set frame type to key frame for the force key frame, if we exceed the
3027     // maximum distance in an automatic keyframe selection or for the first
3028     // frame.
3029     cm->frame_type = KEY_FRAME;
3030   }
3031
3032   // Set default state for segment based loop filter update flags.
3033   cm->lf.mode_ref_delta_update = 0;
3034
3035   // Initialize cpi->mv_step_param to default based on max resolution.
3036   cpi->mv_step_param = vp9_init_search_range(cpi, max_mv_def);
3037   // Initialize cpi->max_mv_magnitude and cpi->mv_step_param if appropriate.
3038   if (sf->auto_mv_step_size) {
3039     if (frame_is_intra_only(&cpi->common)) {
3040       // Initialize max_mv_magnitude for use in the first INTER frame
3041       // after a key/intra-only frame.
3042       cpi->max_mv_magnitude = max_mv_def;
3043     } else {
3044       if (cm->show_frame)
3045         // Allow mv_steps to correspond to twice the max mv magnitude found
3046         // in the previous frame, capped by the default max_mv_magnitude based
3047         // on resolution.
3048         cpi->mv_step_param = vp9_init_search_range(
3049             cpi, MIN(max_mv_def, 2 * cpi->max_mv_magnitude));
3050       cpi->max_mv_magnitude = 0;
3051     }
3052   }
3053
3054   // Set various flags etc to special state if it is a key frame.
3055   if (frame_is_intra_only(cm)) {
3056     vp9_setup_key_frame(cpi);
3057     // Reset the loop filter deltas and segmentation map.
3058     setup_features(cm);
3059
3060     // If segmentation is enabled force a map update for key frames.
3061     if (seg->enabled) {
3062       seg->update_map = 1;
3063       seg->update_data = 1;
3064     }
3065
3066     // The alternate reference frame cannot be active for a key frame.
3067     cpi->source_alt_ref_active = 0;
3068
3069     cm->error_resilient_mode = (cpi->oxcf.error_resilient_mode != 0);
3070     cm->frame_parallel_decoding_mode =
3071       (cpi->oxcf.frame_parallel_decoding_mode != 0);
3072     if (cm->error_resilient_mode) {
3073       cm->frame_parallel_decoding_mode = 1;
3074       cm->reset_frame_context = 0;
3075       cm->refresh_frame_context = 0;
3076     } else if (cm->intra_only) {
3077       // Only reset the current context.
3078       cm->reset_frame_context = 2;
3079     }
3080   }
3081
3082   // Configure experimental use of segmentation for enhanced coding of
3083   // static regions if indicated.
3084   // Only allowed in second pass of two pass (as requires lagged coding)
3085   // and if the relevant speed feature flag is set.
3086   if ((cpi->pass == 2) && (cpi->sf.static_segmentation)) {
3087     configure_static_seg_features(cpi);
3088   }
3089
3090   // Decide how big to make the frame.
3091   vp9_pick_frame_size(cpi);
3092
3093   vp9_clear_system_state();
3094
3095   q = pick_q_and_adjust_q_bounds(cpi, &bottom_index, &top_index);
3096
3097   q_high = top_index;
3098   q_low  = bottom_index;
3099
3100   vp9_compute_frame_size_bounds(cpi, &frame_under_shoot_limit,
3101                                 &frame_over_shoot_limit);
3102
3103 #if CONFIG_MULTIPLE_ARF
3104   // Force the quantizer determined by the coding order pattern.
3105   if (cpi->multi_arf_enabled && (cm->frame_type != KEY_FRAME) &&
3106       cpi->oxcf.end_usage != USAGE_CONSTANT_QUALITY) {
3107     double new_q;
3108     double current_q = vp9_convert_qindex_to_q(cpi->active_worst_quality);
3109     int level = cpi->this_frame_weight;
3110     assert(level >= 0);
3111
3112     // Set quantizer steps at 10% increments.
3113     new_q = current_q * (1.0 - (0.2 * (cpi->max_arf_level - level)));
3114     q = cpi->active_worst_quality + vp9_compute_qdelta(cpi, current_q, new_q);
3115
3116     bottom_index = q;
3117     top_index    = q;
3118     q_low  = q;
3119     q_high = q;
3120
3121     printf("frame:%d q:%d\n", cm->current_video_frame, q);
3122   }
3123 #endif
3124
3125   loop_count = 0;
3126   vp9_zero(cpi->rd_tx_select_threshes);
3127
3128   if (!frame_is_intra_only(cm)) {
3129     cm->mcomp_filter_type = DEFAULT_INTERP_FILTER;
3130     /* TODO: Decide this more intelligently */
3131     cm->allow_high_precision_mv = q < HIGH_PRECISION_MV_QTHRESH;
3132     set_mvcost(cpi);
3133   }
3134
3135 #if CONFIG_VP9_POSTPROC
3136
3137   if (cpi->oxcf.noise_sensitivity > 0) {
3138     int l = 0;
3139
3140     switch (cpi->oxcf.noise_sensitivity) {
3141       case 1:
3142         l = 20;
3143         break;
3144       case 2:
3145         l = 40;
3146         break;
3147       case 3:
3148         l = 60;
3149         break;
3150       case 4:
3151       case 5:
3152         l = 100;
3153         break;
3154       case 6:
3155         l = 150;
3156         break;
3157     }
3158
3159     vp9_denoise(cpi->Source, cpi->Source, l);
3160   }
3161
3162 #endif
3163
3164 #ifdef OUTPUT_YUV_SRC
3165   vp9_write_yuv_frame(cpi->Source);
3166 #endif
3167
3168   do {
3169     vp9_clear_system_state();  // __asm emms;
3170
3171     vp9_set_quantizer(cpi, q);
3172
3173     if (loop_count == 0) {
3174       // Set up entropy context depending on frame type. The decoder mandates
3175       // the use of the default context, index 0, for keyframes and inter
3176       // frames where the error_resilient_mode or intra_only flag is set. For
3177       // other inter-frames the encoder currently uses only two contexts;
3178       // context 1 for ALTREF frames and context 0 for the others.
3179       if (cm->frame_type == KEY_FRAME) {
3180         vp9_setup_key_frame(cpi);
3181       } else {
3182         if (!cm->intra_only && !cm->error_resilient_mode) {
3183           cpi->common.frame_context_idx = cpi->refresh_alt_ref_frame;
3184         }
3185         vp9_setup_inter_frame(cpi);
3186       }
3187     }
3188
3189     if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
3190         vp9_vaq_frame_setup(cpi);
3191     }
3192
3193     // transform / motion compensation build reconstruction frame
3194
3195     vp9_encode_frame(cpi);
3196
3197     // Update the skip mb flag probabilities based on the distribution
3198     // seen in the last encoder iteration.
3199     // update_base_skip_probs(cpi);
3200
3201     vp9_clear_system_state();  // __asm emms;
3202
3203     // Dummy pack of the bitstream using up to date stats to get an
3204     // accurate estimate of output frame size to determine if we need
3205     // to recode.
3206     vp9_save_coding_context(cpi);
3207     cpi->dummy_packing = 1;
3208     vp9_pack_bitstream(cpi, dest, size);
3209     cpi->projected_frame_size = (*size) << 3;
3210     vp9_restore_coding_context(cpi);
3211
3212     if (frame_over_shoot_limit == 0)
3213       frame_over_shoot_limit = 1;
3214     active_worst_qchanged = 0;
3215
3216     if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
3217       loop = 0;
3218     } else {
3219       // Special case handling for forced key frames
3220       if ((cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced) {
3221         int last_q = q;
3222         int kf_err = vp9_calc_ss_err(cpi->Source, get_frame_new_buffer(cm));
3223
3224         int high_err_target = cpi->ambient_err;
3225         int low_err_target = cpi->ambient_err >> 1;
3226
3227         // Prevent possible divide by zero error below for perfect KF
3228         kf_err += !kf_err;
3229
3230         // The key frame is not good enough or we can afford
3231         // to make it better without undue risk of popping.
3232         if ((kf_err > high_err_target &&
3233              cpi->projected_frame_size <= frame_over_shoot_limit) ||
3234             (kf_err > low_err_target &&
3235              cpi->projected_frame_size <= frame_under_shoot_limit)) {
3236           // Lower q_high
3237           q_high = q > q_low ? q - 1 : q_low;
3238
3239           // Adjust Q
3240           q = (q * high_err_target) / kf_err;
3241           q = MIN(q, (q_high + q_low) >> 1);
3242         } else if (kf_err < low_err_target &&
3243                    cpi->projected_frame_size >= frame_under_shoot_limit) {
3244           // The key frame is much better than the previous frame
3245           // Raise q_low
3246           q_low = q < q_high ? q + 1 : q_high;
3247
3248           // Adjust Q
3249           q = (q * low_err_target) / kf_err;
3250           q = MIN(q, (q_high + q_low + 1) >> 1);
3251         }
3252
3253         // Clamp Q to upper and lower limits:
3254         q = clamp(q, q_low, q_high);
3255
3256         loop = q != last_q;
3257       } else if (recode_loop_test(
3258           cpi, frame_over_shoot_limit, frame_under_shoot_limit,
3259           q, top_index, bottom_index)) {
3260         // Is the projected frame size out of range and are we allowed
3261         // to attempt to recode.
3262         int last_q = q;
3263         int retries = 0;
3264
3265         // Frame size out of permitted range:
3266         // Update correction factor & compute new Q to try...
3267
3268         // Frame is too large
3269         if (cpi->projected_frame_size > cpi->this_frame_target) {
3270           // Raise Qlow as to at least the current value
3271           q_low = q < q_high ? q + 1 : q_high;
3272
3273           if (undershoot_seen || loop_count > 1) {
3274             // Update rate_correction_factor unless
3275             // cpi->active_worst_quality has changed.
3276             if (!active_worst_qchanged)
3277               vp9_update_rate_correction_factors(cpi, 1);
3278
3279             q = (q_high + q_low + 1) / 2;
3280           } else {
3281             // Update rate_correction_factor unless
3282             // cpi->active_worst_quality has changed.
3283             if (!active_worst_qchanged)
3284               vp9_update_rate_correction_factors(cpi, 0);
3285
3286             q = vp9_regulate_q(cpi, cpi->this_frame_target);
3287
3288             while (q < q_low && retries < 10) {
3289               vp9_update_rate_correction_factors(cpi, 0);
3290               q = vp9_regulate_q(cpi, cpi->this_frame_target);
3291               retries++;
3292             }
3293           }
3294
3295           overshoot_seen = 1;
3296         } else {
3297           // Frame is too small
3298           q_high = q > q_low ? q - 1 : q_low;
3299
3300           if (overshoot_seen || loop_count > 1) {
3301             // Update rate_correction_factor unless
3302             // cpi->active_worst_quality has changed.
3303             if (!active_worst_qchanged)
3304               vp9_update_rate_correction_factors(cpi, 1);
3305
3306             q = (q_high + q_low) / 2;
3307           } else {
3308             // Update rate_correction_factor unless
3309             // cpi->active_worst_quality has changed.
3310             if (!active_worst_qchanged)
3311               vp9_update_rate_correction_factors(cpi, 0);
3312
3313             q = vp9_regulate_q(cpi, cpi->this_frame_target);
3314
3315             // Special case reset for qlow for constrained quality.
3316             // This should only trigger where there is very substantial
3317             // undershoot on a frame and the auto cq level is above
3318             // the user passsed in value.
3319             if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY && q < q_low) {
3320               q_low = q;
3321             }
3322
3323             while (q > q_high && retries < 10) {
3324               vp9_update_rate_correction_factors(cpi, 0);
3325               q = vp9_regulate_q(cpi, cpi->this_frame_target);
3326               retries++;
3327             }
3328           }
3329
3330           undershoot_seen = 1;
3331         }
3332
3333         // Clamp Q to upper and lower limits:
3334         q = clamp(q, q_low, q_high);
3335
3336         loop = q != last_q;
3337       } else {
3338         loop = 0;
3339       }
3340     }
3341
3342     if (cpi->is_src_frame_alt_ref)
3343       loop = 0;
3344
3345     if (loop) {
3346       loop_count++;
3347
3348 #if CONFIG_INTERNAL_STATS
3349       cpi->tot_recode_hits++;
3350 #endif
3351     }
3352   } while (loop);
3353
3354   // Special case code to reduce pulsing when key frames are forced at a
3355   // fixed interval. Note the reconstruction error if it is the frame before
3356   // the force key frame
3357   if (cpi->next_key_frame_forced && (cpi->twopass.frames_to_key == 0)) {
3358     cpi->ambient_err = vp9_calc_ss_err(cpi->Source, get_frame_new_buffer(cm));
3359   }
3360
3361   if (cm->frame_type == KEY_FRAME)
3362     cpi->refresh_last_frame = 1;
3363
3364   cm->frame_to_show = get_frame_new_buffer(cm);
3365
3366 #if WRITE_RECON_BUFFER
3367   if (cm->show_frame)
3368     write_cx_frame_to_file(cm->frame_to_show,
3369                            cm->current_video_frame);
3370   else
3371     write_cx_frame_to_file(cm->frame_to_show,
3372                            cm->current_video_frame + 1000);
3373 #endif
3374
3375   // Pick the loop filter level for the frame.
3376   loopfilter_frame(cpi, cm);
3377
3378 #if WRITE_RECON_BUFFER
3379   if (cm->show_frame)
3380     write_cx_frame_to_file(cm->frame_to_show,
3381                            cm->current_video_frame + 2000);
3382   else
3383     write_cx_frame_to_file(cm->frame_to_show,
3384                            cm->current_video_frame + 3000);
3385 #endif
3386
3387   // build the bitstream
3388   cpi->dummy_packing = 0;
3389   vp9_pack_bitstream(cpi, dest, size);
3390
3391   if (cm->seg.update_map)
3392     update_reference_segmentation_map(cpi);
3393
3394   release_scaled_references(cpi);
3395   update_reference_frames(cpi);
3396
3397   for (t = TX_4X4; t <= TX_32X32; t++)
3398     full_to_model_counts(cpi->common.counts.coef[t],
3399                          cpi->coef_counts[t]);
3400   if (!cpi->common.error_resilient_mode &&
3401       !cpi->common.frame_parallel_decoding_mode) {
3402     vp9_adapt_coef_probs(&cpi->common);
3403   }
3404
3405   if (!frame_is_intra_only(&cpi->common)) {
3406     FRAME_COUNTS *counts = &cpi->common.counts;
3407
3408     vp9_copy(counts->y_mode, cpi->y_mode_count);
3409     vp9_copy(counts->uv_mode, cpi->y_uv_mode_count);
3410     vp9_copy(counts->partition, cpi->partition_count);
3411     vp9_copy(counts->intra_inter, cpi->intra_inter_count);
3412     vp9_copy(counts->comp_inter, cpi->comp_inter_count);
3413     vp9_copy(counts->single_ref, cpi->single_ref_count);
3414     vp9_copy(counts->comp_ref, cpi->comp_ref_count);
3415     counts->mv = cpi->NMVcount;
3416     if (!cpi->common.error_resilient_mode &&
3417         !cpi->common.frame_parallel_decoding_mode) {
3418       vp9_adapt_mode_probs(&cpi->common);
3419       vp9_adapt_mv_probs(&cpi->common, cpi->common.allow_high_precision_mv);
3420     }
3421   }
3422
3423 #ifdef ENTROPY_STATS
3424   vp9_update_mode_context_stats(cpi);
3425 #endif
3426
3427   /* Move storing frame_type out of the above loop since it is also
3428    * needed in motion search besides loopfilter */
3429   cm->last_frame_type = cm->frame_type;
3430
3431   // Update rate control heuristics
3432   cpi->total_byte_count += (*size);
3433   cpi->projected_frame_size = (*size) << 3;
3434
3435   // Post encode loop adjustment of Q prediction.
3436   if (!active_worst_qchanged)
3437     vp9_update_rate_correction_factors(cpi, (cpi->sf.recode_loop ||
3438         cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) ? 2 : 0);
3439
3440
3441   cpi->last_q[cm->frame_type] = cm->base_qindex;
3442
3443   // Keep record of last boosted (KF/KF/ARF) Q value.
3444   // If the current frame is coded at a lower Q then we also update it.
3445   // If all mbs in this group are skipped only update if the Q value is
3446   // better than that already stored.
3447   // This is used to help set quality in forced key frames to reduce popping
3448   if ((cm->base_qindex < cpi->last_boosted_qindex) ||
3449       ((cpi->static_mb_pct < 100) &&
3450        ((cm->frame_type == KEY_FRAME) ||
3451         cpi->refresh_alt_ref_frame ||
3452         (cpi->refresh_golden_frame && !cpi->is_src_frame_alt_ref)))) {
3453     cpi->last_boosted_qindex = cm->base_qindex;
3454   }
3455
3456   if (cm->frame_type == KEY_FRAME) {
3457     vp9_adjust_key_frame_context(cpi);
3458   }
3459
3460   // Keep a record of ambient average Q.
3461   if (cm->frame_type != KEY_FRAME)
3462     cpi->avg_frame_qindex = (2 + 3 * cpi->avg_frame_qindex +
3463                             cm->base_qindex) >> 2;
3464
3465   // Keep a record from which we can calculate the average Q excluding GF
3466   // updates and key frames.
3467   if (cm->frame_type != KEY_FRAME &&
3468       !cpi->refresh_golden_frame &&
3469       !cpi->refresh_alt_ref_frame) {
3470     cpi->ni_frames++;
3471     cpi->tot_q += vp9_convert_qindex_to_q(q);
3472     cpi->avg_q = cpi->tot_q / (double)cpi->ni_frames;
3473
3474     // Calculate the average Q for normal inter frames (not key or GFU frames).
3475     cpi->ni_tot_qi += q;
3476     cpi->ni_av_qi = cpi->ni_tot_qi / cpi->ni_frames;
3477   }
3478
3479   // Update the buffer level variable.
3480   // Non-viewable frames are a special case and are treated as pure overhead.
3481   if (!cm->show_frame)
3482     cpi->bits_off_target -= cpi->projected_frame_size;
3483   else
3484     cpi->bits_off_target += cpi->av_per_frame_bandwidth -
3485                             cpi->projected_frame_size;
3486
3487   // Clip the buffer level at the maximum buffer size
3488   if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
3489     cpi->bits_off_target = cpi->oxcf.maximum_buffer_size;
3490
3491   // Rolling monitors of whether we are over or underspending used to help
3492   // regulate min and Max Q in two pass.
3493   if (cm->frame_type != KEY_FRAME) {
3494     cpi->rolling_target_bits =
3495       ((cpi->rolling_target_bits * 3) + cpi->this_frame_target + 2) / 4;
3496     cpi->rolling_actual_bits =
3497       ((cpi->rolling_actual_bits * 3) + cpi->projected_frame_size + 2) / 4;
3498     cpi->long_rolling_target_bits =
3499       ((cpi->long_rolling_target_bits * 31) + cpi->this_frame_target + 16) / 32;
3500     cpi->long_rolling_actual_bits =
3501       ((cpi->long_rolling_actual_bits * 31) +
3502        cpi->projected_frame_size + 16) / 32;
3503   }
3504
3505   // Actual bits spent
3506   cpi->total_actual_bits += cpi->projected_frame_size;
3507
3508   // Debug stats
3509   cpi->total_target_vs_actual += (cpi->this_frame_target -
3510                                   cpi->projected_frame_size);
3511
3512   cpi->buffer_level = cpi->bits_off_target;
3513
3514 #ifndef DISABLE_RC_LONG_TERM_MEM
3515   // Update bits left to the kf and gf groups to account for overshoot or
3516   // undershoot on these frames
3517   if (cm->frame_type == KEY_FRAME) {
3518     cpi->twopass.kf_group_bits += cpi->this_frame_target -
3519                                   cpi->projected_frame_size;
3520
3521     cpi->twopass.kf_group_bits = MAX(cpi->twopass.kf_group_bits, 0);
3522   } else if (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame) {
3523     cpi->twopass.gf_group_bits += cpi->this_frame_target -
3524                                   cpi->projected_frame_size;
3525
3526     cpi->twopass.gf_group_bits = MAX(cpi->twopass.gf_group_bits, 0);
3527   }
3528 #endif
3529
3530 #if 0
3531   output_frame_level_debug_stats(cpi);
3532 #endif
3533   if (cpi->refresh_golden_frame == 1)
3534     cm->frame_flags = cm->frame_flags | FRAMEFLAGS_GOLDEN;
3535   else
3536     cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_GOLDEN;
3537
3538   if (cpi->refresh_alt_ref_frame == 1)
3539     cm->frame_flags = cm->frame_flags | FRAMEFLAGS_ALTREF;
3540   else
3541     cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_ALTREF;
3542
3543
3544   if (cpi->refresh_last_frame & cpi->refresh_golden_frame)
3545     cpi->gold_is_last = 1;
3546   else if (cpi->refresh_last_frame ^ cpi->refresh_golden_frame)
3547     cpi->gold_is_last = 0;
3548
3549   if (cpi->refresh_last_frame & cpi->refresh_alt_ref_frame)
3550     cpi->alt_is_last = 1;
3551   else if (cpi->refresh_last_frame ^ cpi->refresh_alt_ref_frame)
3552     cpi->alt_is_last = 0;
3553
3554   if (cpi->refresh_alt_ref_frame & cpi->refresh_golden_frame)
3555     cpi->gold_is_alt = 1;
3556   else if (cpi->refresh_alt_ref_frame ^ cpi->refresh_golden_frame)
3557     cpi->gold_is_alt = 0;
3558
3559   cpi->ref_frame_flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
3560
3561   if (cpi->gold_is_last)
3562     cpi->ref_frame_flags &= ~VP9_GOLD_FLAG;
3563
3564   if (cpi->alt_is_last)
3565     cpi->ref_frame_flags &= ~VP9_ALT_FLAG;
3566
3567   if (cpi->gold_is_alt)
3568     cpi->ref_frame_flags &= ~VP9_ALT_FLAG;
3569
3570   if (cpi->oxcf.play_alternate && cpi->refresh_alt_ref_frame
3571       && (cm->frame_type != KEY_FRAME))
3572     // Update the alternate reference frame stats as appropriate.
3573     update_alt_ref_frame_stats(cpi);
3574   else
3575     // Update the Golden frame stats as appropriate.
3576     update_golden_frame_stats(cpi);
3577
3578   if (cm->frame_type == KEY_FRAME) {
3579     // Tell the caller that the frame was coded as a key frame
3580     *frame_flags = cm->frame_flags | FRAMEFLAGS_KEY;
3581
3582 #if CONFIG_MULTIPLE_ARF
3583     // Reset the sequence number.
3584     if (cpi->multi_arf_enabled) {
3585       cpi->sequence_number = 0;
3586       cpi->frame_coding_order_period = cpi->new_frame_coding_order_period;
3587       cpi->new_frame_coding_order_period = -1;
3588     }
3589 #endif
3590
3591     // As this frame is a key frame the next defaults to an inter frame.
3592     cm->frame_type = INTER_FRAME;
3593   } else {
3594     *frame_flags = cm->frame_flags&~FRAMEFLAGS_KEY;
3595
3596 #if CONFIG_MULTIPLE_ARF
3597     /* Increment position in the coded frame sequence. */
3598     if (cpi->multi_arf_enabled) {
3599       ++cpi->sequence_number;
3600       if (cpi->sequence_number >= cpi->frame_coding_order_period) {
3601         cpi->sequence_number = 0;
3602         cpi->frame_coding_order_period = cpi->new_frame_coding_order_period;
3603         cpi->new_frame_coding_order_period = -1;
3604       }
3605       cpi->this_frame_weight = cpi->arf_weight[cpi->sequence_number];
3606       assert(cpi->this_frame_weight >= 0);
3607     }
3608 #endif
3609   }
3610
3611   // Clear the one shot update flags for segmentation map and mode/ref loop
3612   // filter deltas.
3613   cm->seg.update_map = 0;
3614   cm->seg.update_data = 0;
3615   cm->lf.mode_ref_delta_update = 0;
3616
3617   // keep track of the last coded dimensions
3618   cm->last_width = cm->width;
3619   cm->last_height = cm->height;
3620
3621   // reset to normal state now that we are done.
3622   cm->last_show_frame = cm->show_frame;
3623   if (cm->show_frame) {
3624     // current mip will be the prev_mip for the next frame
3625     MODE_INFO *temp = cm->prev_mip;
3626     MODE_INFO **temp2 = cm->prev_mi_grid_base;
3627     cm->prev_mip = cm->mip;
3628     cm->mip = temp;
3629     cm->prev_mi_grid_base = cm->mi_grid_base;
3630     cm->mi_grid_base = temp2;
3631
3632     // update the upper left visible macroblock ptrs
3633     cm->mi = cm->mip + cm->mode_info_stride + 1;
3634     cm->mi_grid_visible = cm->mi_grid_base + cm->mode_info_stride + 1;
3635
3636     cpi->mb.e_mbd.mi_8x8 = cm->mi_grid_visible;
3637     cpi->mb.e_mbd.mi_8x8[0] = cm->mi;
3638
3639     // Don't increment frame counters if this was an altref buffer
3640     // update not a real frame
3641     ++cm->current_video_frame;
3642     ++cpi->frames_since_key;
3643   }
3644   // restore prev_mi
3645   cm->prev_mi = cm->prev_mip + cm->mode_info_stride + 1;
3646   cm->prev_mi_grid_visible = cm->prev_mi_grid_base + cm->mode_info_stride + 1;
3647 }
3648
3649 static void Pass2Encode(VP9_COMP *cpi, unsigned long *size,
3650                         unsigned char *dest, unsigned int *frame_flags) {
3651   cpi->enable_encode_breakout = 1;
3652
3653   if (!cpi->refresh_alt_ref_frame)
3654     vp9_second_pass(cpi);
3655
3656   encode_frame_to_data_rate(cpi, size, dest, frame_flags);
3657   // vp9_print_modes_and_motion_vectors(&cpi->common, "encode.stt");
3658 #ifdef DISABLE_RC_LONG_TERM_MEM
3659   cpi->twopass.bits_left -=  cpi->this_frame_target;
3660 #else
3661   cpi->twopass.bits_left -= 8 * *size;
3662 #endif
3663
3664   if (!cpi->refresh_alt_ref_frame) {
3665     double lower_bounds_min_rate = FRAME_OVERHEAD_BITS * cpi->oxcf.framerate;
3666     double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth
3667                                         * cpi->oxcf.two_pass_vbrmin_section
3668                                         / 100);
3669
3670     if (two_pass_min_rate < lower_bounds_min_rate)
3671       two_pass_min_rate = lower_bounds_min_rate;
3672
3673     cpi->twopass.bits_left += (int64_t)(two_pass_min_rate
3674                               / cpi->oxcf.framerate);
3675   }
3676 }
3677
3678 static void check_initial_width(VP9_COMP *cpi, YV12_BUFFER_CONFIG *sd) {
3679   VP9_COMMON            *cm = &cpi->common;
3680   if (!cpi->initial_width) {
3681     // TODO(jkoleszar): Support 1/4 subsampling?
3682     cm->subsampling_x = (sd != NULL) && sd->uv_width < sd->y_width;
3683     cm->subsampling_y = (sd != NULL) && sd->uv_height < sd->y_height;
3684     alloc_raw_frame_buffers(cpi);
3685
3686     cpi->initial_width = cm->width;
3687     cpi->initial_height = cm->height;
3688   }
3689 }
3690
3691
3692 int vp9_receive_raw_frame(VP9_PTR ptr, unsigned int frame_flags,
3693                           YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
3694                           int64_t end_time) {
3695   VP9_COMP              *cpi = (VP9_COMP *) ptr;
3696   struct vpx_usec_timer  timer;
3697   int                    res = 0;
3698
3699   check_initial_width(cpi, sd);
3700   vpx_usec_timer_start(&timer);
3701   if (vp9_lookahead_push(cpi->lookahead, sd, time_stamp, end_time, frame_flags,
3702                          cpi->active_map_enabled ? cpi->active_map : NULL))
3703     res = -1;
3704   vpx_usec_timer_mark(&timer);
3705   cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
3706
3707   return res;
3708 }
3709
3710
3711 static int frame_is_reference(const VP9_COMP *cpi) {
3712   const VP9_COMMON *cm = &cpi->common;
3713
3714   return cm->frame_type == KEY_FRAME ||
3715          cpi->refresh_last_frame ||
3716          cpi->refresh_golden_frame ||
3717          cpi->refresh_alt_ref_frame ||
3718          cm->refresh_frame_context ||
3719          cm->lf.mode_ref_delta_update ||
3720          cm->seg.update_map ||
3721          cm->seg.update_data;
3722 }
3723
3724 #if CONFIG_MULTIPLE_ARF
3725 int is_next_frame_arf(VP9_COMP *cpi) {
3726   // Negative entry in frame_coding_order indicates an ARF at this position.
3727   return cpi->frame_coding_order[cpi->sequence_number + 1] < 0 ? 1 : 0;
3728 }
3729 #endif
3730
3731 int vp9_get_compressed_data(VP9_PTR ptr, unsigned int *frame_flags,
3732                             unsigned long *size, unsigned char *dest,
3733                             int64_t *time_stamp, int64_t *time_end, int flush) {
3734   VP9_COMP *cpi = (VP9_COMP *) ptr;
3735   VP9_COMMON *cm = &cpi->common;
3736   struct vpx_usec_timer  cmptimer;
3737   YV12_BUFFER_CONFIG    *force_src_buffer = NULL;
3738   int i;
3739   // FILE *fp_out = fopen("enc_frame_type.txt", "a");
3740
3741   if (!cpi)
3742     return -1;
3743
3744   vpx_usec_timer_start(&cmptimer);
3745
3746   cpi->source = NULL;
3747
3748   cpi->common.allow_high_precision_mv = ALTREF_HIGH_PRECISION_MV;
3749   set_mvcost(cpi);
3750
3751   // Should we code an alternate reference frame.
3752   if (cpi->oxcf.play_alternate && cpi->source_alt_ref_pending) {
3753     int frames_to_arf;
3754
3755 #if CONFIG_MULTIPLE_ARF
3756     assert(!cpi->multi_arf_enabled ||
3757            cpi->frame_coding_order[cpi->sequence_number] < 0);
3758
3759     if (cpi->multi_arf_enabled && (cpi->pass == 2))
3760       frames_to_arf = (-cpi->frame_coding_order[cpi->sequence_number])
3761         - cpi->next_frame_in_order;
3762     else
3763 #endif
3764       frames_to_arf = cpi->frames_till_gf_update_due;
3765
3766     assert(frames_to_arf < cpi->twopass.frames_to_key);
3767
3768     if ((cpi->source = vp9_lookahead_peek(cpi->lookahead, frames_to_arf))) {
3769 #if CONFIG_MULTIPLE_ARF
3770       cpi->alt_ref_source[cpi->arf_buffered] = cpi->source;
3771 #else
3772       cpi->alt_ref_source = cpi->source;
3773 #endif
3774
3775       if (cpi->oxcf.arnr_max_frames > 0) {
3776         // Produce the filtered ARF frame.
3777         // TODO(agrange) merge these two functions.
3778         configure_arnr_filter(cpi, cm->current_video_frame + frames_to_arf,
3779                               cpi->gfu_boost);
3780         vp9_temporal_filter_prepare(cpi, frames_to_arf);
3781         vp9_extend_frame_borders(&cpi->alt_ref_buffer,
3782                                  cm->subsampling_x, cm->subsampling_y);
3783         force_src_buffer = &cpi->alt_ref_buffer;
3784       }
3785
3786       cm->show_frame = 0;
3787       cpi->refresh_alt_ref_frame = 1;
3788       cpi->refresh_golden_frame = 0;
3789       cpi->refresh_last_frame = 0;
3790       cpi->is_src_frame_alt_ref = 0;
3791
3792       // TODO(agrange) This needs to vary depending on where the next ARF is.
3793       cpi->frames_till_alt_ref_frame = frames_to_arf;
3794
3795 #if CONFIG_MULTIPLE_ARF
3796       if (!cpi->multi_arf_enabled)
3797 #endif
3798         cpi->source_alt_ref_pending = 0;   // Clear Pending altf Ref flag.
3799     }
3800   }
3801
3802   if (!cpi->source) {
3803 #if CONFIG_MULTIPLE_ARF
3804     int i;
3805 #endif
3806     if ((cpi->source = vp9_lookahead_pop(cpi->lookahead, flush))) {
3807       cm->show_frame = 1;
3808       cm->intra_only = 0;
3809
3810 #if CONFIG_MULTIPLE_ARF
3811       // Is this frame the ARF overlay.
3812       cpi->is_src_frame_alt_ref = 0;
3813       for (i = 0; i < cpi->arf_buffered; ++i) {
3814         if (cpi->source == cpi->alt_ref_source[i]) {
3815           cpi->is_src_frame_alt_ref = 1;
3816           cpi->refresh_golden_frame = 1;
3817           break;
3818         }
3819       }
3820 #else
3821       cpi->is_src_frame_alt_ref = cpi->alt_ref_source
3822                                   && (cpi->source == cpi->alt_ref_source);
3823 #endif
3824       if (cpi->is_src_frame_alt_ref) {
3825         // Current frame is an ARF overlay frame.
3826 #if CONFIG_MULTIPLE_ARF
3827         cpi->alt_ref_source[i] = NULL;
3828 #else
3829         cpi->alt_ref_source = NULL;
3830 #endif
3831         // Don't refresh the last buffer for an ARF overlay frame. It will
3832         // become the GF so preserve last as an alternative prediction option.
3833         cpi->refresh_last_frame = 0;
3834       }
3835 #if CONFIG_MULTIPLE_ARF
3836       ++cpi->next_frame_in_order;
3837 #endif
3838     }
3839   }
3840
3841   if (cpi->source) {
3842     cpi->un_scaled_source = cpi->Source = force_src_buffer ? force_src_buffer
3843                                                            : &cpi->source->img;
3844     *time_stamp = cpi->source->ts_start;
3845     *time_end = cpi->source->ts_end;
3846     *frame_flags = cpi->source->flags;
3847
3848     // fprintf(fp_out, "   Frame:%d", cm->current_video_frame);
3849 #if CONFIG_MULTIPLE_ARF
3850     if (cpi->multi_arf_enabled) {
3851       // fprintf(fp_out, "   seq_no:%d  this_frame_weight:%d",
3852       //         cpi->sequence_number, cpi->this_frame_weight);
3853     } else {
3854       // fprintf(fp_out, "\n");
3855     }
3856 #else
3857     // fprintf(fp_out, "\n");
3858 #endif
3859
3860 #if CONFIG_MULTIPLE_ARF
3861     if ((cm->frame_type != KEY_FRAME) && (cpi->pass == 2))
3862       cpi->source_alt_ref_pending = is_next_frame_arf(cpi);
3863 #endif
3864   } else {
3865     *size = 0;
3866     if (flush && cpi->pass == 1 && !cpi->twopass.first_pass_done) {
3867       vp9_end_first_pass(cpi);    /* get last stats packet */
3868       cpi->twopass.first_pass_done = 1;
3869     }
3870
3871     // fclose(fp_out);
3872     return -1;
3873   }
3874
3875   if (cpi->source->ts_start < cpi->first_time_stamp_ever) {
3876     cpi->first_time_stamp_ever = cpi->source->ts_start;
3877     cpi->last_end_time_stamp_seen = cpi->source->ts_start;
3878   }
3879
3880   // adjust frame rates based on timestamps given
3881   if (!cpi->refresh_alt_ref_frame) {
3882     int64_t this_duration;
3883     int step = 0;
3884
3885     if (cpi->source->ts_start == cpi->first_time_stamp_ever) {
3886       this_duration = cpi->source->ts_end - cpi->source->ts_start;
3887       step = 1;
3888     } else {
3889       int64_t last_duration = cpi->last_end_time_stamp_seen
3890                                 - cpi->last_time_stamp_seen;
3891
3892       this_duration = cpi->source->ts_end - cpi->last_end_time_stamp_seen;
3893
3894       // do a step update if the duration changes by 10%
3895       if (last_duration)
3896         step = (int)((this_duration - last_duration) * 10 / last_duration);
3897     }
3898
3899     if (this_duration) {
3900       if (step) {
3901         vp9_new_framerate(cpi, 10000000.0 / this_duration);
3902       } else {
3903         // Average this frame's rate into the last second's average
3904         // frame rate. If we haven't seen 1 second yet, then average
3905         // over the whole interval seen.
3906         const double interval = MIN((double)(cpi->source->ts_end
3907                                      - cpi->first_time_stamp_ever), 10000000.0);
3908         double avg_duration = 10000000.0 / cpi->oxcf.framerate;
3909         avg_duration *= (interval - avg_duration + this_duration);
3910         avg_duration /= interval;
3911
3912         vp9_new_framerate(cpi, 10000000.0 / avg_duration);
3913       }
3914     }
3915
3916     cpi->last_time_stamp_seen = cpi->source->ts_start;
3917     cpi->last_end_time_stamp_seen = cpi->source->ts_end;
3918   }
3919
3920   // start with a 0 size frame
3921   *size = 0;
3922
3923   // Clear down mmx registers
3924   vp9_clear_system_state();  // __asm emms;
3925
3926   /* find a free buffer for the new frame, releasing the reference previously
3927    * held.
3928    */
3929   cm->fb_idx_ref_cnt[cm->new_fb_idx]--;
3930   cm->new_fb_idx = get_free_fb(cm);
3931
3932 #if CONFIG_MULTIPLE_ARF
3933   /* Set up the correct ARF frame. */
3934   if (cpi->refresh_alt_ref_frame) {
3935     ++cpi->arf_buffered;
3936   }
3937   if (cpi->multi_arf_enabled && (cm->frame_type != KEY_FRAME) &&
3938       (cpi->pass == 2)) {
3939     cpi->alt_fb_idx = cpi->arf_buffer_idx[cpi->sequence_number];
3940   }
3941 #endif
3942
3943   /* Get the mapping of L/G/A to the reference buffer pool */
3944   cm->active_ref_idx[0] = cm->ref_frame_map[cpi->lst_fb_idx];
3945   cm->active_ref_idx[1] = cm->ref_frame_map[cpi->gld_fb_idx];
3946   cm->active_ref_idx[2] = cm->ref_frame_map[cpi->alt_fb_idx];
3947
3948 #if 0  // CONFIG_MULTIPLE_ARF
3949   if (cpi->multi_arf_enabled) {
3950     fprintf(fp_out, "      idx(%d, %d, %d, %d) active(%d, %d, %d)",
3951         cpi->lst_fb_idx, cpi->gld_fb_idx, cpi->alt_fb_idx, cm->new_fb_idx,
3952         cm->active_ref_idx[0], cm->active_ref_idx[1], cm->active_ref_idx[2]);
3953     if (cpi->refresh_alt_ref_frame)
3954       fprintf(fp_out, "  type:ARF");
3955     if (cpi->is_src_frame_alt_ref)
3956       fprintf(fp_out, "  type:OVERLAY[%d]", cpi->alt_fb_idx);
3957     fprintf(fp_out, "\n");
3958   }
3959 #endif
3960
3961   cm->frame_type = INTER_FRAME;
3962   cm->frame_flags = *frame_flags;
3963
3964   // Reset the frame pointers to the current frame size
3965   vp9_realloc_frame_buffer(get_frame_new_buffer(cm),
3966                            cm->width, cm->height,
3967                            cm->subsampling_x, cm->subsampling_y,
3968                            VP9BORDERINPIXELS);
3969
3970   // Calculate scaling factors for each of the 3 available references
3971   for (i = 0; i < ALLOWED_REFS_PER_FRAME; ++i)
3972     vp9_setup_scale_factors(cm, i);
3973
3974   vp9_setup_interp_filters(&cpi->mb.e_mbd, DEFAULT_INTERP_FILTER, cm);
3975
3976   if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
3977       vp9_vaq_init();
3978   }
3979
3980   if (cpi->pass == 1) {
3981     Pass1Encode(cpi, size, dest, frame_flags);
3982   } else if (cpi->pass == 2) {
3983     Pass2Encode(cpi, size, dest, frame_flags);
3984   } else {
3985     encode_frame_to_data_rate(cpi, size, dest, frame_flags);
3986   }
3987
3988   if (cm->refresh_frame_context)
3989     cm->frame_contexts[cm->frame_context_idx] = cm->fc;
3990
3991   if (*size > 0) {
3992     // if its a dropped frame honor the requests on subsequent frames
3993     cpi->droppable = !frame_is_reference(cpi);
3994
3995     // return to normal state
3996     cm->reset_frame_context = 0;
3997     cm->refresh_frame_context = 1;
3998     cpi->refresh_alt_ref_frame = 0;
3999     cpi->refresh_golden_frame = 0;
4000     cpi->refresh_last_frame = 1;
4001     cm->frame_type = INTER_FRAME;
4002   }
4003
4004   vpx_usec_timer_mark(&cmptimer);
4005   cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
4006
4007   if (cpi->b_calculate_psnr && cpi->pass != 1 && cm->show_frame)
4008     generate_psnr_packet(cpi);
4009
4010 #if CONFIG_INTERNAL_STATS
4011
4012   if (cpi->pass != 1) {
4013     cpi->bytes += *size;
4014
4015     if (cm->show_frame) {
4016       cpi->count++;
4017
4018       if (cpi->b_calculate_psnr) {
4019         double ye, ue, ve;
4020         double frame_psnr;
4021         YV12_BUFFER_CONFIG      *orig = cpi->Source;
4022         YV12_BUFFER_CONFIG      *recon = cpi->common.frame_to_show;
4023         YV12_BUFFER_CONFIG      *pp = &cm->post_proc_buffer;
4024         int y_samples = orig->y_height * orig->y_width;
4025         int uv_samples = orig->uv_height * orig->uv_width;
4026         int t_samples = y_samples + 2 * uv_samples;
4027         double sq_error;
4028
4029         ye = (double)calc_plane_error(orig->y_buffer, orig->y_stride,
4030                               recon->y_buffer, recon->y_stride,
4031                               orig->y_crop_width, orig->y_crop_height);
4032
4033         ue = (double)calc_plane_error(orig->u_buffer, orig->uv_stride,
4034                               recon->u_buffer, recon->uv_stride,
4035                               orig->uv_crop_width, orig->uv_crop_height);
4036
4037         ve = (double)calc_plane_error(orig->v_buffer, orig->uv_stride,
4038                               recon->v_buffer, recon->uv_stride,
4039                               orig->uv_crop_width, orig->uv_crop_height);
4040
4041         sq_error = ye + ue + ve;
4042
4043         frame_psnr = vp9_mse2psnr(t_samples, 255.0, sq_error);
4044
4045         cpi->total_y += vp9_mse2psnr(y_samples, 255.0, ye);
4046         cpi->total_u += vp9_mse2psnr(uv_samples, 255.0, ue);
4047         cpi->total_v += vp9_mse2psnr(uv_samples, 255.0, ve);
4048         cpi->total_sq_error += sq_error;
4049         cpi->total  += frame_psnr;
4050         {
4051           double frame_psnr2, frame_ssim2 = 0;
4052           double weight = 0;
4053 #if CONFIG_VP9_POSTPROC
4054           vp9_deblock(cm->frame_to_show, &cm->post_proc_buffer,
4055                       cm->lf.filter_level * 10 / 6);
4056 #endif
4057           vp9_clear_system_state();
4058
4059           ye = (double)calc_plane_error(orig->y_buffer, orig->y_stride,
4060                                 pp->y_buffer, pp->y_stride,
4061                                 orig->y_crop_width, orig->y_crop_height);
4062
4063           ue = (double)calc_plane_error(orig->u_buffer, orig->uv_stride,
4064                                 pp->u_buffer, pp->uv_stride,
4065                                 orig->uv_crop_width, orig->uv_crop_height);
4066
4067           ve = (double)calc_plane_error(orig->v_buffer, orig->uv_stride,
4068                                 pp->v_buffer, pp->uv_stride,
4069                                 orig->uv_crop_width, orig->uv_crop_height);
4070
4071           sq_error = ye + ue + ve;
4072
4073           frame_psnr2 = vp9_mse2psnr(t_samples, 255.0, sq_error);
4074
4075           cpi->totalp_y += vp9_mse2psnr(y_samples, 255.0, ye);
4076           cpi->totalp_u += vp9_mse2psnr(uv_samples, 255.0, ue);
4077           cpi->totalp_v += vp9_mse2psnr(uv_samples, 255.0, ve);
4078           cpi->total_sq_error2 += sq_error;
4079           cpi->totalp  += frame_psnr2;
4080
4081           frame_ssim2 = vp9_calc_ssim(cpi->Source,
4082                                       recon, 1, &weight);
4083
4084           cpi->summed_quality += frame_ssim2 * weight;
4085           cpi->summed_weights += weight;
4086
4087           frame_ssim2 = vp9_calc_ssim(cpi->Source,
4088                                       &cm->post_proc_buffer, 1, &weight);
4089
4090           cpi->summedp_quality += frame_ssim2 * weight;
4091           cpi->summedp_weights += weight;
4092 #if 0
4093           {
4094             FILE *f = fopen("q_used.stt", "a");
4095             fprintf(f, "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n",
4096                     cpi->common.current_video_frame, y2, u2, v2,
4097                     frame_psnr2, frame_ssim2);
4098             fclose(f);
4099           }
4100 #endif
4101         }
4102       }
4103
4104       if (cpi->b_calculate_ssimg) {
4105         double y, u, v, frame_all;
4106         frame_all =  vp9_calc_ssimg(cpi->Source, cm->frame_to_show,
4107                                     &y, &u, &v);
4108         cpi->total_ssimg_y += y;
4109         cpi->total_ssimg_u += u;
4110         cpi->total_ssimg_v += v;
4111         cpi->total_ssimg_all += frame_all;
4112       }
4113     }
4114   }
4115
4116 #endif
4117   // fclose(fp_out);
4118   return 0;
4119 }
4120
4121 int vp9_get_preview_raw_frame(VP9_PTR comp, YV12_BUFFER_CONFIG *dest,
4122                               vp9_ppflags_t *flags) {
4123   VP9_COMP *cpi = (VP9_COMP *) comp;
4124
4125   if (!cpi->common.show_frame) {
4126     return -1;
4127   } else {
4128     int ret;
4129 #if CONFIG_VP9_POSTPROC
4130     ret = vp9_post_proc_frame(&cpi->common, dest, flags);
4131 #else
4132
4133     if (cpi->common.frame_to_show) {
4134       *dest = *cpi->common.frame_to_show;
4135       dest->y_width = cpi->common.width;
4136       dest->y_height = cpi->common.height;
4137       dest->uv_height = cpi->common.height / 2;
4138       ret = 0;
4139     } else {
4140       ret = -1;
4141     }
4142
4143 #endif  // !CONFIG_VP9_POSTPROC
4144     vp9_clear_system_state();
4145     return ret;
4146   }
4147 }
4148
4149 int vp9_set_roimap(VP9_PTR comp, unsigned char *map, unsigned int rows,
4150                    unsigned int cols, int delta_q[MAX_SEGMENTS],
4151                    int delta_lf[MAX_SEGMENTS],
4152                    unsigned int threshold[MAX_SEGMENTS]) {
4153   VP9_COMP *cpi = (VP9_COMP *) comp;
4154   signed char feature_data[SEG_LVL_MAX][MAX_SEGMENTS];
4155   struct segmentation *seg = &cpi->common.seg;
4156   int i;
4157
4158   if (cpi->common.mb_rows != rows || cpi->common.mb_cols != cols)
4159     return -1;
4160
4161   if (!map) {
4162     vp9_disable_segmentation((VP9_PTR)cpi);
4163     return 0;
4164   }
4165
4166   // Set the segmentation Map
4167   vp9_set_segmentation_map((VP9_PTR)cpi, map);
4168
4169   // Activate segmentation.
4170   vp9_enable_segmentation((VP9_PTR)cpi);
4171
4172   // Set up the quant, LF and breakout threshold segment data
4173   for (i = 0; i < MAX_SEGMENTS; i++) {
4174     feature_data[SEG_LVL_ALT_Q][i] = delta_q[i];
4175     feature_data[SEG_LVL_ALT_LF][i] = delta_lf[i];
4176     cpi->segment_encode_breakout[i] = threshold[i];
4177   }
4178
4179   // Enable the loop and quant changes in the feature mask
4180   for (i = 0; i < MAX_SEGMENTS; i++) {
4181     if (delta_q[i])
4182       vp9_enable_segfeature(seg, i, SEG_LVL_ALT_Q);
4183     else
4184       vp9_disable_segfeature(seg, i, SEG_LVL_ALT_Q);
4185
4186     if (delta_lf[i])
4187       vp9_enable_segfeature(seg, i, SEG_LVL_ALT_LF);
4188     else
4189       vp9_disable_segfeature(seg, i, SEG_LVL_ALT_LF);
4190   }
4191
4192   // Initialize the feature data structure
4193   // SEGMENT_DELTADATA    0, SEGMENT_ABSDATA      1
4194   vp9_set_segment_data((VP9_PTR)cpi, &feature_data[0][0], SEGMENT_DELTADATA);
4195
4196   return 0;
4197 }
4198
4199 int vp9_set_active_map(VP9_PTR comp, unsigned char *map,
4200                        unsigned int rows, unsigned int cols) {
4201   VP9_COMP *cpi = (VP9_COMP *) comp;
4202
4203   if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols) {
4204     if (map) {
4205       vpx_memcpy(cpi->active_map, map, rows * cols);
4206       cpi->active_map_enabled = 1;
4207     } else {
4208       cpi->active_map_enabled = 0;
4209     }
4210
4211     return 0;
4212   } else {
4213     // cpi->active_map_enabled = 0;
4214     return -1;
4215   }
4216 }
4217
4218 int vp9_set_internal_size(VP9_PTR comp,
4219                           VPX_SCALING horiz_mode, VPX_SCALING vert_mode) {
4220   VP9_COMP *cpi = (VP9_COMP *) comp;
4221   VP9_COMMON *cm = &cpi->common;
4222   int hr = 0, hs = 0, vr = 0, vs = 0;
4223
4224   if (horiz_mode > ONETWO || vert_mode > ONETWO)
4225     return -1;
4226
4227   Scale2Ratio(horiz_mode, &hr, &hs);
4228   Scale2Ratio(vert_mode, &vr, &vs);
4229
4230   // always go to the next whole number
4231   cm->width = (hs - 1 + cpi->oxcf.width * hr) / hs;
4232   cm->height = (vs - 1 + cpi->oxcf.height * vr) / vs;
4233
4234   assert(cm->width <= cpi->initial_width);
4235   assert(cm->height <= cpi->initial_height);
4236   update_frame_size(cpi);
4237   return 0;
4238 }
4239
4240 int vp9_set_size_literal(VP9_PTR comp, unsigned int width,
4241                          unsigned int height) {
4242   VP9_COMP *cpi = (VP9_COMP *)comp;
4243   VP9_COMMON *cm = &cpi->common;
4244
4245   check_initial_width(cpi, NULL);
4246
4247   if (width) {
4248     cm->width = width;
4249     if (cm->width * 5 < cpi->initial_width) {
4250       cm->width = cpi->initial_width / 5 + 1;
4251       printf("Warning: Desired width too small, changed to %d \n", cm->width);
4252     }
4253     if (cm->width > cpi->initial_width) {
4254       cm->width = cpi->initial_width;
4255       printf("Warning: Desired width too large, changed to %d \n", cm->width);
4256     }
4257   }
4258
4259   if (height) {
4260     cm->height = height;
4261     if (cm->height * 5 < cpi->initial_height) {
4262       cm->height = cpi->initial_height / 5 + 1;
4263       printf("Warning: Desired height too small, changed to %d \n", cm->height);
4264     }
4265     if (cm->height > cpi->initial_height) {
4266       cm->height = cpi->initial_height;
4267       printf("Warning: Desired height too large, changed to %d \n", cm->height);
4268     }
4269   }
4270
4271   assert(cm->width <= cpi->initial_width);
4272   assert(cm->height <= cpi->initial_height);
4273   update_frame_size(cpi);
4274   return 0;
4275 }
4276
4277 void vp9_set_svc(VP9_PTR comp, int use_svc) {
4278   VP9_COMP *cpi = (VP9_COMP *)comp;
4279   cpi->use_svc = use_svc;
4280   return;
4281 }
4282
4283 int vp9_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest) {
4284   int i, j;
4285   int total = 0;
4286
4287   uint8_t *src = source->y_buffer;
4288   uint8_t *dst = dest->y_buffer;
4289
4290   // Loop through the Y plane raw and reconstruction data summing
4291   // (square differences)
4292   for (i = 0; i < source->y_height; i += 16) {
4293     for (j = 0; j < source->y_width; j += 16) {
4294       unsigned int sse;
4295       total += vp9_mse16x16(src + j, source->y_stride, dst + j, dest->y_stride,
4296                             &sse);
4297     }
4298
4299     src += 16 * source->y_stride;
4300     dst += 16 * dest->y_stride;
4301   }
4302
4303   return total;
4304 }
4305
4306
4307 int vp9_get_quantizer(VP9_PTR c) {
4308   return ((VP9_COMP *)c)->common.base_qindex;
4309 }