libvpx: Pull from upstream

source/libvpx/vp9/encoder/vp9_onyx_if.c

 /*
  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 
 #include "vpx_config.h"
 #include "vp9/common/vp9_onyxc_int.h"
 #include "vp9/encoder/vp9_onyx_int.h"
 #include "vp9/common/vp9_systemdependent.h"
 #include "vp9/encoder/vp9_quantize.h"
 #include "vp9/common/vp9_alloccommon.h"
 #include "vp9/encoder/vp9_mcomp.h"
 #include "vp9/encoder/vp9_firstpass.h"
 #include "vp9/encoder/vp9_psnr.h"
-#include "vpx_scale/vpxscale.h"
+#include "vpx_scale/vpx_scale.h"
 #include "vp9/common/vp9_extend.h"
 #include "vp9/encoder/vp9_ratectrl.h"
 #include "vp9/common/vp9_quant_common.h"
 #include "vp9/encoder/vp9_segmentation.h"
 #include "./vp9_rtcd.h"
 #include "./vpx_scale_rtcd.h"
 #if CONFIG_POSTPROC
 #include "vp9/common/vp9_postproc.h"
 #endif
 #include "vpx_mem/vpx_mem.h"
@@ skipping 10 matching lines @@
 #include "vp9/encoder/vp9_temporal_filter.h"
 
 #include <math.h>
 #include <stdio.h>
 #include <limits.h>
 
 extern void print_tree_update_probs();
 
 static void set_default_lf_deltas(VP9_COMP *cpi);
 
-#define DEFAULT_INTERP_FILTER EIGHTTAP  /* SWITCHABLE for better performance */
+#define DEFAULT_INTERP_FILTER SWITCHABLE
+
 #define SEARCH_BEST_FILTER 0            /* to search exhaustively for
                                            best filter */
 #define RESET_FOREACH_FILTER 0          /* whether to reset the encoder state
                                            before trying each new filter */
 #define SHARP_FILTER_QTHRESH 0          /* Q threshold for 8-tap sharp filter */
 
 #define ALTREF_HIGH_PRECISION_MV 1      /* whether to use high precision mv
                                            for altref computation */
 #define HIGH_PRECISION_MV_QTHRESH 200   /* Q threshold for use of high precision
                                            mv. Choose a very high value for
@@ skipping 48 matching lines @@
 #endif
 
 #ifdef SPEEDSTATS
 unsigned int frames_at_speed[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 #endif
 
 #if defined(SECTIONBITS_OUTPUT)
 extern unsigned __int64 Sectionbits[500];
 #endif
 #ifdef MODE_STATS
-extern INT64 Sectionbits[500];
+extern int64_t Sectionbits[500];
 extern unsigned int y_modes[VP9_YMODES];
 extern unsigned int i8x8_modes[VP9_I8X8_MODES];
 extern unsigned int uv_modes[VP9_UV_MODES];
 extern unsigned int uv_modes_y[VP9_YMODES][VP9_UV_MODES];
 extern unsigned int b_modes[B_MODE_COUNT];
 extern unsigned int inter_y_modes[MB_MODE_COUNT];
 extern unsigned int inter_uv_modes[VP9_UV_MODES];
 extern unsigned int inter_b_modes[B_MODE_COUNT];
 #endif
 
 extern void vp9_init_quantizer(VP9_COMP *cpi);
 
 static int base_skip_false_prob[QINDEX_RANGE][3];
 
 // Tables relating active max Q to active min Q
 static int kf_low_motion_minq[QINDEX_RANGE];
 static int kf_high_motion_minq[QINDEX_RANGE];
 static int gf_low_motion_minq[QINDEX_RANGE];
 static int gf_high_motion_minq[QINDEX_RANGE];
 static int inter_minq[QINDEX_RANGE];
 
 // Functions to compute the active minq lookup table entries based on a
 // formulaic approach to facilitate easier adjustment of the Q tables.
 // The formulae were derived from computing a 3rd order polynomial best
 // fit to the original data (after plotting real maxq vs minq (not q index))
 static int calculate_minq_index(double maxq,
                                 double x3, double x2, double x, double c) {
   int i;
   double minqtarget;
-  double thisq;
 
   minqtarget = ((x3 * maxq * maxq * maxq) +
                 (x2 * maxq * maxq) +
                 (x * maxq) +
                 c);
 
   if (minqtarget > maxq)
     minqtarget = maxq;
 
   for (i = 0; i < QINDEX_RANGE; i++) {
-    thisq = vp9_convert_qindex_to_q(i);
     if (minqtarget <= vp9_convert_qindex_to_q(i))
       return i;
   }
   return QINDEX_RANGE - 1;
 }
 
 static void init_minq_luts(void) {
   int i;
   double maxq;
 
@@ skipping 36 matching lines @@
     mb->mvsadcost = mb->nmvsadcost_hp;
 
   } else {
     mb->mvcost = mb->nmvcost;
     mb->mvsadcost = mb->nmvsadcost;
   }
 }
 static void init_base_skip_probs(void) {
   int i;
   double q;
-  int skip_prob, t;
+  int t;
 
   for (i = 0; i < QINDEX_RANGE; i++) {
     q = vp9_convert_qindex_to_q(i);
 
     // Exponential decay caluclation of baseline skip prob with clamping
     // Based on crude best fit of old table.
     t = (int)(564.25 * pow(2.71828, (-0.012 * q)));
 
-    skip_prob = t;
-    if (skip_prob < 1)
-      skip_prob = 1;
-    else if (skip_prob > 255)
-      skip_prob = 255;
-    base_skip_false_prob[i][1] = skip_prob;
-
-    skip_prob = t * 3 / 4;
-    if (skip_prob < 1)
-      skip_prob = 1;
-    else if (skip_prob > 255)
-      skip_prob = 255;
-    base_skip_false_prob[i][2] = skip_prob;
-
-    skip_prob = t * 5 / 4;
-    if (skip_prob < 1)
-      skip_prob = 1;
-    else if (skip_prob > 255)
-      skip_prob = 255;
-    base_skip_false_prob[i][0] = skip_prob;
+    base_skip_false_prob[i][1] = clip_prob(t);
+    base_skip_false_prob[i][2] = clip_prob(t * 3 / 4);
+    base_skip_false_prob[i][0] = clip_prob(t * 5 / 4);
   }
 }
 
 static void update_base_skip_probs(VP9_COMP *cpi) {
   VP9_COMMON *cm = &cpi->common;
 
   if (cm->frame_type != KEY_FRAME) {
     vp9_update_skip_probs(cpi);
 
     if (cm->refresh_alt_ref_frame) {
@@ skipping 308 matching lines @@
       map_index++;
     }
     fprintf(statsfile, "\n");
   }
   fprintf(statsfile, "\n");
 
   fclose(statsfile);
 }
 
 static void update_reference_segmentation_map(VP9_COMP *cpi) {
-  VP9_COMMON *cm = &cpi->common;
-  int row, col, sb_rows = (cm->mb_rows + 1) >> 1, sb_cols = (cm->mb_cols + 1) >> 1;
-  MODE_INFO *mi = cm->mi;
-  uint8_t *segmap = cpi->segmentation_map;
-  uint8_t *segcache = cm->last_frame_seg_map;
+  VP9_COMMON *const cm = &cpi->common;
+  int row, col;
+  MODE_INFO *mi, *mi_ptr = cm->mi;
+  uint8_t *cache_ptr = cm->last_frame_seg_map, *cache;
 
-  for (row = 0; row < sb_rows; row++) {
-    for (col = 0; col < sb_cols; col++) {
-      MODE_INFO *miptr = mi + col * 2;
-      uint8_t *cache = segcache + col * 2;
-#if CONFIG_SUPERBLOCKS
-      if (miptr->mbmi.encoded_as_sb) {
-        cache[0] = miptr->mbmi.segment_id;
-        if (!(cm->mb_cols & 1) || col < sb_cols - 1)
-          cache[1] = miptr->mbmi.segment_id;
-        if (!(cm->mb_rows & 1) || row < sb_rows - 1) {
-          cache[cm->mb_cols] = miptr->mbmi.segment_id;
-          if (!(cm->mb_cols & 1) || col < sb_cols - 1)
-            cache[cm->mb_cols + 1] = miptr->mbmi.segment_id;
-        }
-      } else
-#endif
-      {
-        cache[0] = miptr[0].mbmi.segment_id;
-        if (!(cm->mb_cols & 1) || col < sb_cols - 1)
-          cache[1] = miptr[1].mbmi.segment_id;
-        if (!(cm->mb_rows & 1) || row < sb_rows - 1) {
-          cache[cm->mb_cols] = miptr[cm->mode_info_stride].mbmi.segment_id;
-          if (!(cm->mb_cols & 1) || col < sb_cols - 1)
-            cache[1] = miptr[1].mbmi.segment_id;
-          cache[cm->mb_cols + 1] = miptr[cm->mode_info_stride + 1].mbmi.segment_id;
-        }
-      }
+  for (row = 0; row < cm->mb_rows; row++) {
+    mi = mi_ptr;
+    cache = cache_ptr;
+    for (col = 0; col < cm->mb_cols; col++, mi++, cache++) {
+      cache[0] = mi->mbmi.segment_id;
     }
-    segmap += 2 * cm->mb_cols;
-    segcache += 2 * cm->mb_cols;
-    mi += 2 * cm->mode_info_stride;
+    mi_ptr += cm->mode_info_stride;
+    cache_ptr += cm->mb_cols;
   }
 }
 
 static void set_default_lf_deltas(VP9_COMP *cpi) {
   cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 1;
   cpi->mb.e_mbd.mode_ref_lf_delta_update = 1;
 
   vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
   vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
 
@@ skipping 38 matching lines @@
   sf->iterative_sub_pixel = 1;
 #if CONFIG_LOSSLESS
   sf->optimize_coefficients = 0;
 #else
   sf->optimize_coefficients = 1;
 #endif
   sf->no_skip_block4x4_search = 1;
 
   sf->first_step = 0;
   sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
-  sf->improved_mv_pred = 1;
 
   // default thresholds to 0
   for (i = 0; i < MAX_MODES; i++)
     sf->thresh_mult[i] = 0;
 
   switch (Mode) {
     case 0: // best quality mode
-#if CONFIG_PRED_FILTER
-      sf->thresh_mult[THR_ZEROMV        ] = 0;
-      sf->thresh_mult[THR_ZEROMV_FILT   ] = 0;
-      sf->thresh_mult[THR_ZEROG         ] = 0;
-      sf->thresh_mult[THR_ZEROG_FILT    ] = 0;
-      sf->thresh_mult[THR_ZEROA         ] = 0;
-      sf->thresh_mult[THR_ZEROA_FILT    ] = 0;
-      sf->thresh_mult[THR_NEARESTMV     ] = 0;
-      sf->thresh_mult[THR_NEARESTMV_FILT] = 0;
-      sf->thresh_mult[THR_NEARESTG      ] = 0;
-      sf->thresh_mult[THR_NEARESTG_FILT ] = 0;
-      sf->thresh_mult[THR_NEARESTA      ] = 0;
-      sf->thresh_mult[THR_NEARESTA_FILT ] = 0;
-      sf->thresh_mult[THR_NEARMV        ] = 0;
-      sf->thresh_mult[THR_NEARMV_FILT   ] = 0;
-      sf->thresh_mult[THR_NEARG         ] = 0;
-      sf->thresh_mult[THR_NEARG_FILT    ] = 0;
-      sf->thresh_mult[THR_NEARA         ] = 0;
-      sf->thresh_mult[THR_NEARA_FILT    ] = 0;
-
-      sf->thresh_mult[THR_DC       ] = 0;
-
-      sf->thresh_mult[THR_V_PRED   ] = 1000;
-      sf->thresh_mult[THR_H_PRED   ] = 1000;
-      sf->thresh_mult[THR_D45_PRED ] = 1000;
-      sf->thresh_mult[THR_D135_PRED] = 1000;
-      sf->thresh_mult[THR_D117_PRED] = 1000;
-      sf->thresh_mult[THR_D153_PRED] = 1000;
-      sf->thresh_mult[THR_D27_PRED ] = 1000;
-      sf->thresh_mult[THR_D63_PRED ] = 1000;
-      sf->thresh_mult[THR_B_PRED   ] = 2000;
-      sf->thresh_mult[THR_I8X8_PRED] = 2000;
-      sf->thresh_mult[THR_TM       ] = 1000;
-
-      sf->thresh_mult[THR_NEWMV    ] = 1000;
-      sf->thresh_mult[THR_NEWG     ] = 1000;
-      sf->thresh_mult[THR_NEWA     ] = 1000;
-      sf->thresh_mult[THR_NEWMV_FILT    ] = 1000;
-      sf->thresh_mult[THR_NEWG_FILT     ] = 1000;
-      sf->thresh_mult[THR_NEWA_FILT     ] = 1000;
-#else
       sf->thresh_mult[THR_ZEROMV   ] = 0;
       sf->thresh_mult[THR_ZEROG    ] = 0;
       sf->thresh_mult[THR_ZEROA    ] = 0;
       sf->thresh_mult[THR_NEARESTMV] = 0;
       sf->thresh_mult[THR_NEARESTG ] = 0;
       sf->thresh_mult[THR_NEARESTA ] = 0;
       sf->thresh_mult[THR_NEARMV   ] = 0;
       sf->thresh_mult[THR_NEARG    ] = 0;
       sf->thresh_mult[THR_NEARA    ] = 0;
 
       sf->thresh_mult[THR_DC       ] = 0;
 
       sf->thresh_mult[THR_V_PRED   ] = 1000;
       sf->thresh_mult[THR_H_PRED   ] = 1000;
       sf->thresh_mult[THR_D45_PRED ] = 1000;
       sf->thresh_mult[THR_D135_PRED] = 1000;
       sf->thresh_mult[THR_D117_PRED] = 1000;
       sf->thresh_mult[THR_D153_PRED] = 1000;
       sf->thresh_mult[THR_D27_PRED ] = 1000;
       sf->thresh_mult[THR_D63_PRED ] = 1000;
       sf->thresh_mult[THR_B_PRED   ] = 2000;
       sf->thresh_mult[THR_I8X8_PRED] = 2000;
       sf->thresh_mult[THR_TM       ] = 1000;
 
       sf->thresh_mult[THR_NEWMV    ] = 1000;
       sf->thresh_mult[THR_NEWG     ] = 1000;
       sf->thresh_mult[THR_NEWA     ] = 1000;
-#endif
+
       sf->thresh_mult[THR_SPLITMV  ] = 2500;
       sf->thresh_mult[THR_SPLITG   ] = 5000;
       sf->thresh_mult[THR_SPLITA   ] = 5000;
 
       sf->thresh_mult[THR_COMP_ZEROLG   ] = 0;
       sf->thresh_mult[THR_COMP_NEARESTLG] = 0;
       sf->thresh_mult[THR_COMP_NEARLG   ] = 0;
       sf->thresh_mult[THR_COMP_ZEROLA   ] = 0;
       sf->thresh_mult[THR_COMP_NEARESTLA] = 0;
       sf->thresh_mult[THR_COMP_NEARLA   ] = 0;
@@ skipping 22 matching lines @@
       sf->thresh_mult[THR_COMP_INTERINTRA_NEARESTA] = 0;
       sf->thresh_mult[THR_COMP_INTERINTRA_NEARA   ] = 0;
       sf->thresh_mult[THR_COMP_INTERINTRA_NEWA    ] = 0;
 #endif
 
       sf->first_step = 0;
       sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
       sf->search_best_filter = SEARCH_BEST_FILTER;
       break;
     case 1:
-#if CONFIG_PRED_FILTER
       sf->thresh_mult[THR_NEARESTMV] = 0;
-      sf->thresh_mult[THR_NEARESTMV_FILT] = 0;
       sf->thresh_mult[THR_ZEROMV   ] = 0;
-      sf->thresh_mult[THR_ZEROMV_FILT   ] = 0;
       sf->thresh_mult[THR_DC       ] = 0;
       sf->thresh_mult[THR_NEARMV   ] = 0;
-      sf->thresh_mult[THR_NEARMV_FILT   ] = 0;
       sf->thresh_mult[THR_V_PRED   ] = 1000;
       sf->thresh_mult[THR_H_PRED   ] = 1000;
       sf->thresh_mult[THR_D45_PRED ] = 1000;
       sf->thresh_mult[THR_D135_PRED] = 1000;
       sf->thresh_mult[THR_D117_PRED] = 1000;
       sf->thresh_mult[THR_D153_PRED] = 1000;
       sf->thresh_mult[THR_D27_PRED ] = 1000;
       sf->thresh_mult[THR_D63_PRED ] = 1000;
       sf->thresh_mult[THR_B_PRED   ] = 2500;
       sf->thresh_mult[THR_I8X8_PRED] = 2500;
       sf->thresh_mult[THR_TM       ] = 1000;
 
       sf->thresh_mult[THR_NEARESTG ] = 1000;
-      sf->thresh_mult[THR_NEARESTG_FILT ] = 1000;
       sf->thresh_mult[THR_NEARESTA ] = 1000;
-      sf->thresh_mult[THR_NEARESTA_FILT ] = 1000;
 
       sf->thresh_mult[THR_ZEROG    ] = 1000;
       sf->thresh_mult[THR_ZEROA    ] = 1000;
       sf->thresh_mult[THR_NEARG    ] = 1000;
       sf->thresh_mult[THR_NEARA    ] = 1000;
-      sf->thresh_mult[THR_ZEROG_FILT    ] = 1000;
-      sf->thresh_mult[THR_ZEROA_FILT    ] = 1000;
-      sf->thresh_mult[THR_NEARG_FILT    ] = 1000;
-      sf->thresh_mult[THR_NEARA_FILT    ] = 1000;
 
       sf->thresh_mult[THR_ZEROMV   ] = 0;
       sf->thresh_mult[THR_ZEROG    ] = 0;
       sf->thresh_mult[THR_ZEROA    ] = 0;
       sf->thresh_mult[THR_NEARESTMV] = 0;
       sf->thresh_mult[THR_NEARESTG ] = 0;
       sf->thresh_mult[THR_NEARESTA ] = 0;
       sf->thresh_mult[THR_NEARMV   ] = 0;
       sf->thresh_mult[THR_NEARG    ] = 0;
       sf->thresh_mult[THR_NEARA    ] = 0;
-      sf->thresh_mult[THR_ZEROMV_FILT   ] = 0;
-      sf->thresh_mult[THR_ZEROG_FILT    ] = 0;
-      sf->thresh_mult[THR_ZEROA_FILT    ] = 0;
-      sf->thresh_mult[THR_NEARESTMV_FILT] = 0;
-      sf->thresh_mult[THR_NEARESTG_FILT ] = 0;
-      sf->thresh_mult[THR_NEARESTA_FILT ] = 0;
-      sf->thresh_mult[THR_NEARMV_FILT   ] = 0;
-      sf->thresh_mult[THR_NEARG_FILT    ] = 0;
-      sf->thresh_mult[THR_NEARA_FILT    ] = 0;
-
-      sf->thresh_mult[THR_NEWMV    ] = 1000;
-      sf->thresh_mult[THR_NEWG     ] = 1000;
-      sf->thresh_mult[THR_NEWA     ] = 1000;
-      sf->thresh_mult[THR_NEWMV_FILT    ] = 1000;
-      sf->thresh_mult[THR_NEWG_FILT     ] = 1000;
-      sf->thresh_mult[THR_NEWA_FILT     ] = 1000;
-#else
-      sf->thresh_mult[THR_NEARESTMV] = 0;
-      sf->thresh_mult[THR_ZEROMV   ] = 0;
-      sf->thresh_mult[THR_DC       ] = 0;
-      sf->thresh_mult[THR_NEARMV   ] = 0;
-      sf->thresh_mult[THR_V_PRED   ] = 1000;
-      sf->thresh_mult[THR_H_PRED   ] = 1000;
-      sf->thresh_mult[THR_D45_PRED ] = 1000;
-      sf->thresh_mult[THR_D135_PRED] = 1000;
-      sf->thresh_mult[THR_D117_PRED] = 1000;
-      sf->thresh_mult[THR_D153_PRED] = 1000;
-      sf->thresh_mult[THR_D27_PRED ] = 1000;
-      sf->thresh_mult[THR_D63_PRED ] = 1000;
-      sf->thresh_mult[THR_B_PRED   ] = 2500;
-      sf->thresh_mult[THR_I8X8_PRED] = 2500;
-      sf->thresh_mult[THR_TM       ] = 1000;
-
-      sf->thresh_mult[THR_NEARESTG ] = 1000;
-      sf->thresh_mult[THR_NEARESTA ] = 1000;
-
-      sf->thresh_mult[THR_ZEROG    ] = 1000;
-      sf->thresh_mult[THR_ZEROA    ] = 1000;
-      sf->thresh_mult[THR_NEARG    ] = 1000;
-      sf->thresh_mult[THR_NEARA    ] = 1000;
-
-      sf->thresh_mult[THR_ZEROMV   ] = 0;
-      sf->thresh_mult[THR_ZEROG    ] = 0;
-      sf->thresh_mult[THR_ZEROA    ] = 0;
-      sf->thresh_mult[THR_NEARESTMV] = 0;
-      sf->thresh_mult[THR_NEARESTG ] = 0;
-      sf->thresh_mult[THR_NEARESTA ] = 0;
-      sf->thresh_mult[THR_NEARMV   ] = 0;
-      sf->thresh_mult[THR_NEARG    ] = 0;
-      sf->thresh_mult[THR_NEARA    ] = 0;
 
       sf->thresh_mult[THR_NEWMV    ] = 1000;
       sf->thresh_mult[THR_NEWG     ] = 1000;
       sf->thresh_mult[THR_NEWA     ] = 1000;
-#endif
+
       sf->thresh_mult[THR_SPLITMV  ] = 1700;
       sf->thresh_mult[THR_SPLITG   ] = 4500;
       sf->thresh_mult[THR_SPLITA   ] = 4500;
 
       sf->thresh_mult[THR_COMP_ZEROLG   ] = 0;
       sf->thresh_mult[THR_COMP_NEARESTLG] = 0;
       sf->thresh_mult[THR_COMP_NEARLG   ] = 0;
       sf->thresh_mult[THR_COMP_ZEROLA   ] = 0;
       sf->thresh_mult[THR_COMP_NEARESTLA] = 0;
       sf->thresh_mult[THR_COMP_NEARLA   ] = 0;
@@ skipping 55 matching lines @@
         sf->thresh_mult[THR_D135_PRED] = 1500;
         sf->thresh_mult[THR_D117_PRED] = 1500;
         sf->thresh_mult[THR_D153_PRED] = 1500;
         sf->thresh_mult[THR_D27_PRED ] = 1500;
         sf->thresh_mult[THR_D63_PRED ] = 1500;
         sf->thresh_mult[THR_B_PRED   ] = 5000;
         sf->thresh_mult[THR_I8X8_PRED] = 5000;
 
         if (cpi->ref_frame_flags & VP9_LAST_FLAG) {
           sf->thresh_mult[THR_NEWMV    ] = 2000;
-#if CONFIG_PRED_FILTER
-          sf->thresh_mult[THR_NEWMV_FILT    ] = 2000;
-#endif
           sf->thresh_mult[THR_SPLITMV  ] = 10000;
           sf->thresh_mult[THR_COMP_SPLITLG  ] = 20000;
         }
 
         if (cpi->ref_frame_flags & VP9_GOLD_FLAG) {
           sf->thresh_mult[THR_NEARESTG ] = 1500;
           sf->thresh_mult[THR_ZEROG    ] = 1500;
           sf->thresh_mult[THR_NEARG    ] = 1500;
           sf->thresh_mult[THR_NEWG     ] = 2000;
-#if CONFIG_PRED_FILTER
-          sf->thresh_mult[THR_NEARESTG_FILT ] = 1500;
-          sf->thresh_mult[THR_ZEROG_FILT    ] = 1500;
-          sf->thresh_mult[THR_NEARG_FILT    ] = 1500;
-          sf->thresh_mult[THR_NEWG_FILT     ] = 2000;
-#endif
           sf->thresh_mult[THR_SPLITG   ] = 20000;
           sf->thresh_mult[THR_COMP_SPLITGA  ] = 20000;
         }
 
         if (cpi->ref_frame_flags & VP9_ALT_FLAG) {
           sf->thresh_mult[THR_NEARESTA ] = 1500;
           sf->thresh_mult[THR_ZEROA    ] = 1500;
           sf->thresh_mult[THR_NEARA    ] = 1500;
           sf->thresh_mult[THR_NEWA     ] = 2000;
-#if CONFIG_PRED_FILTER
-          sf->thresh_mult[THR_NEARESTA_FILT ] = 1500;
-          sf->thresh_mult[THR_ZEROA_FILT    ] = 1500;
-          sf->thresh_mult[THR_NEARA_FILT    ] = 1500;
-          sf->thresh_mult[THR_NEWA_FILT     ] = 2000;
-#endif
           sf->thresh_mult[THR_SPLITA   ] = 20000;
           sf->thresh_mult[THR_COMP_SPLITLA  ] = 10000;
         }
 
         sf->thresh_mult[THR_COMP_ZEROLG   ] = 1500;
         sf->thresh_mult[THR_COMP_NEARESTLG] = 1500;
         sf->thresh_mult[THR_COMP_NEARLG   ] = 1500;
         sf->thresh_mult[THR_COMP_ZEROLA   ] = 1500;
         sf->thresh_mult[THR_COMP_NEARESTLA] = 1500;
         sf->thresh_mult[THR_COMP_NEARLA   ] = 1500;
@@ skipping 36 matching lines @@
         sf->thresh_mult[THR_D135_PRED] = 2000;
         sf->thresh_mult[THR_D117_PRED] = 2000;
         sf->thresh_mult[THR_D153_PRED] = 2000;
         sf->thresh_mult[THR_D27_PRED ] = 2000;
         sf->thresh_mult[THR_D63_PRED ] = 2000;
         sf->thresh_mult[THR_B_PRED   ] = 7500;
         sf->thresh_mult[THR_I8X8_PRED] = 7500;
 
         if (cpi->ref_frame_flags & VP9_LAST_FLAG) {
           sf->thresh_mult[THR_NEWMV    ] = 2000;
-#if CONFIG_PRED_FILTER
-          sf->thresh_mult[THR_NEWMV_FILT    ] = 2000;
-#endif
           sf->thresh_mult[THR_SPLITMV  ] = 25000;
           sf->thresh_mult[THR_COMP_SPLITLG  ] = 50000;
         }
 
         if (cpi->ref_frame_flags & VP9_GOLD_FLAG) {
           sf->thresh_mult[THR_NEARESTG ] = 2000;
           sf->thresh_mult[THR_ZEROG    ] = 2000;
           sf->thresh_mult[THR_NEARG    ] = 2000;
           sf->thresh_mult[THR_NEWG     ] = 2500;
-#if CONFIG_PRED_FILTER
-          sf->thresh_mult[THR_NEARESTG_FILT ] = 2000;
-          sf->thresh_mult[THR_ZEROG_FILT    ] = 2000;
-          sf->thresh_mult[THR_NEARG_FILT    ] = 2000;
-          sf->thresh_mult[THR_NEWG_FILT     ] = 2500;
-#endif
           sf->thresh_mult[THR_SPLITG   ] = 50000;
           sf->thresh_mult[THR_COMP_SPLITGA  ] = 50000;
         }
 
         if (cpi->ref_frame_flags & VP9_ALT_FLAG) {
           sf->thresh_mult[THR_NEARESTA ] = 2000;
           sf->thresh_mult[THR_ZEROA    ] = 2000;
           sf->thresh_mult[THR_NEARA    ] = 2000;
           sf->thresh_mult[THR_NEWA     ] = 2500;
-#if CONFIG_PRED_FILTER
-          sf->thresh_mult[THR_NEARESTA_FILT ] = 2000;
-          sf->thresh_mult[THR_ZEROA_FILT    ] = 2000;
-          sf->thresh_mult[THR_NEARA_FILT    ] = 2000;
-          sf->thresh_mult[THR_NEWA_FILT     ] = 2500;
-#endif
           sf->thresh_mult[THR_SPLITA   ] = 50000;
           sf->thresh_mult[THR_COMP_SPLITLA  ] = 25000;
         }
 
         sf->thresh_mult[THR_COMP_ZEROLG   ] = 2000;
         sf->thresh_mult[THR_COMP_NEARESTLG] = 2000;
         sf->thresh_mult[THR_COMP_NEARLG   ] = 2000;
         sf->thresh_mult[THR_COMP_ZEROLA   ] = 2000;
         sf->thresh_mult[THR_COMP_NEARESTLA] = 2000;
         sf->thresh_mult[THR_COMP_NEARLA   ] = 2000;
@@ skipping 30 matching lines @@
       break;
 
   }; /* switch */
 
   /* disable frame modes if flags not set */
   if (!(cpi->ref_frame_flags & VP9_LAST_FLAG)) {
     sf->thresh_mult[THR_NEWMV    ] = INT_MAX;
     sf->thresh_mult[THR_NEARESTMV] = INT_MAX;
     sf->thresh_mult[THR_ZEROMV   ] = INT_MAX;
     sf->thresh_mult[THR_NEARMV   ] = INT_MAX;
-#if CONFIG_PRED_FILTER
-    sf->thresh_mult[THR_NEWMV_FILT    ] = INT_MAX;
-    sf->thresh_mult[THR_NEARESTMV_FILT] = INT_MAX;
-    sf->thresh_mult[THR_ZEROMV_FILT   ] = INT_MAX;
-    sf->thresh_mult[THR_NEARMV_FILT   ] = INT_MAX;
-#endif
     sf->thresh_mult[THR_SPLITMV  ] = INT_MAX;
   }
 
   if (!(cpi->ref_frame_flags & VP9_GOLD_FLAG)) {
     sf->thresh_mult[THR_NEARESTG ] = INT_MAX;
     sf->thresh_mult[THR_ZEROG    ] = INT_MAX;
     sf->thresh_mult[THR_NEARG    ] = INT_MAX;
     sf->thresh_mult[THR_NEWG     ] = INT_MAX;
-#if CONFIG_PRED_FILTER
-    sf->thresh_mult[THR_NEARESTG_FILT ] = INT_MAX;
-    sf->thresh_mult[THR_ZEROG_FILT    ] = INT_MAX;
-    sf->thresh_mult[THR_NEARG_FILT    ] = INT_MAX;
-    sf->thresh_mult[THR_NEWG_FILT     ] = INT_MAX;
-#endif
 #if CONFIG_COMP_INTERINTRA_PRED
     sf->thresh_mult[THR_COMP_INTERINTRA_ZEROG   ] = INT_MAX;
     sf->thresh_mult[THR_COMP_INTERINTRA_NEARESTG] = INT_MAX;
     sf->thresh_mult[THR_COMP_INTERINTRA_NEARG   ] = INT_MAX;
     sf->thresh_mult[THR_COMP_INTERINTRA_NEWG    ] = INT_MAX;
 #endif
     sf->thresh_mult[THR_SPLITG   ] = INT_MAX;
   }
 
   if (!(cpi->ref_frame_flags & VP9_ALT_FLAG)) {
     sf->thresh_mult[THR_NEARESTA ] = INT_MAX;
     sf->thresh_mult[THR_ZEROA    ] = INT_MAX;
     sf->thresh_mult[THR_NEARA    ] = INT_MAX;
     sf->thresh_mult[THR_NEWA     ] = INT_MAX;
-#if CONFIG_PRED_FILTER
-    sf->thresh_mult[THR_NEARESTA_FILT ] = INT_MAX;
-    sf->thresh_mult[THR_ZEROA_FILT    ] = INT_MAX;
-    sf->thresh_mult[THR_NEARA_FILT    ] = INT_MAX;
-    sf->thresh_mult[THR_NEWA_FILT     ] = INT_MAX;
-#endif
 #if CONFIG_COMP_INTERINTRA_PRED
     sf->thresh_mult[THR_COMP_INTERINTRA_ZEROA   ] = INT_MAX;
     sf->thresh_mult[THR_COMP_INTERINTRA_NEARESTA] = INT_MAX;
     sf->thresh_mult[THR_COMP_INTERINTRA_NEARA   ] = INT_MAX;
     sf->thresh_mult[THR_COMP_INTERINTRA_NEWA    ] = INT_MAX;
 #endif
     sf->thresh_mult[THR_SPLITA   ] = INT_MAX;
   }
 
   if ((cpi->ref_frame_flags & (VP9_LAST_FLAG | VP9_GOLD_FLAG)) != (VP9_LAST_FLAG | VP9_GOLD_FLAG)) {
@@ skipping 613 matching lines @@
   memcpy(cpi->base_skip_false_prob, base_skip_false_prob, sizeof(base_skip_false_prob));
   cpi->common.current_video_frame   = 0;
   cpi->kf_overspend_bits            = 0;
   cpi->kf_bitrate_adjustment        = 0;
   cpi->frames_till_gf_update_due      = 0;
   cpi->gf_overspend_bits            = 0;
   cpi->non_gf_bitrate_adjustment     = 0;
   cm->prob_last_coded               = 128;
   cm->prob_gf_coded                 = 128;
   cm->prob_intra_coded              = 63;
-#if CONFIG_SUPERBLOCKS
-  cm->sb_coded                      = 200;
-#endif
+  cm->sb32_coded                    = 200;
+  cm->sb64_coded                    = 200;
   for (i = 0; i < COMP_PRED_CONTEXTS; i++)
     cm->prob_comppred[i]         = 128;
-  for (i = 0; i < TX_SIZE_MAX - 1; i++)
+  for (i = 0; i < TX_SIZE_MAX_SB - 1; i++)
     cm->prob_tx[i]               = 128;
 
   // Prime the recent reference frame useage counters.
   // Hereafter they will be maintained as a sort of moving average
   cpi->recent_ref_frame_usage[INTRA_FRAME]  = 1;
   cpi->recent_ref_frame_usage[LAST_FRAME]   = 1;
   cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1;
   cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1;
 
   // Set reference frame sign bias for ALTREF frame to 1 (for now)
@@ skipping 89 matching lines @@
 
   if (cpi->b_calculate_ssimg) {
     cpi->total_ssimg_y = 0;
     cpi->total_ssimg_u = 0;
     cpi->total_ssimg_v = 0;
     cpi->total_ssimg_all = 0;
   }
 
 #endif
 
-#ifndef LLONG_MAX
-#define LLONG_MAX  9223372036854775807LL
-#endif
-  cpi->first_time_stamp_ever = LLONG_MAX;
+  cpi->first_time_stamp_ever = INT64_MAX;
 
   cpi->frames_till_gf_update_due      = 0;
   cpi->key_frame_count              = 1;
 
   cpi->ni_av_qi                     = cpi->oxcf.worst_allowed_q;
   cpi->ni_tot_qi                    = 0;
   cpi->ni_frames                   = 0;
   cpi->tot_q = 0.0;
   cpi->avg_q = vp9_convert_qindex_to_q(cpi->oxcf.worst_allowed_q);
   cpi->total_byte_count             = 0;
@@ skipping 63 matching lines @@
     cpi->fn_ptr[BT].vf             = VF; \
     cpi->fn_ptr[BT].svf            = SVF; \
     cpi->fn_ptr[BT].svf_halfpix_h  = SVFHH; \
     cpi->fn_ptr[BT].svf_halfpix_v  = SVFHV; \
     cpi->fn_ptr[BT].svf_halfpix_hv = SVFHHV; \
     cpi->fn_ptr[BT].sdx3f          = SDX3F; \
     cpi->fn_ptr[BT].sdx8f          = SDX8F; \
     cpi->fn_ptr[BT].sdx4df         = SDX4DF;
 
 
-#if CONFIG_SUPERBLOCKS
   BFP(BLOCK_32X32, vp9_sad32x32, vp9_variance32x32, vp9_sub_pixel_variance32x32,
       vp9_variance_halfpixvar32x32_h, vp9_variance_halfpixvar32x32_v,
       vp9_variance_halfpixvar32x32_hv, vp9_sad32x32x3, vp9_sad32x32x8,
       vp9_sad32x32x4d)
-#endif
+
+  BFP(BLOCK_64X64, vp9_sad64x64, vp9_variance64x64, vp9_sub_pixel_variance64x64,
+      vp9_variance_halfpixvar64x64_h, vp9_variance_halfpixvar64x64_v,
+      vp9_variance_halfpixvar64x64_hv, vp9_sad64x64x3, vp9_sad64x64x8,
+      vp9_sad64x64x4d)
 
   BFP(BLOCK_16X16, vp9_sad16x16, vp9_variance16x16, vp9_sub_pixel_variance16x16,
        vp9_variance_halfpixvar16x16_h, vp9_variance_halfpixvar16x16_v,
        vp9_variance_halfpixvar16x16_hv, vp9_sad16x16x3, vp9_sad16x16x8,
        vp9_sad16x16x4d)
 
   BFP(BLOCK_16X8, vp9_sad16x8, vp9_variance16x8, vp9_sub_pixel_variance16x8,
       NULL, NULL, NULL, vp9_sad16x8x3, vp9_sad16x8x8, vp9_sad16x8x4d)
 
   BFP(BLOCK_8X16, vp9_sad8x16, vp9_variance8x16, vp9_sub_pixel_variance8x16,
@@ skipping 190 matching lines @@
 #ifdef ENTROPY_STATS
     {
       int i, j, k;
       FILE *fmode = fopen("vp9_modecontext.c", "w");
 
       fprintf(fmode, "\n#include \"vp9_entropymode.h\"\n\n");
       fprintf(fmode, "const unsigned int vp9_kf_default_bmode_counts ");
       fprintf(fmode, "[VP9_KF_BINTRAMODES][VP9_KF_BINTRAMODES]"
                      "[VP9_KF_BINTRAMODES] =\n{\n");
 
-      for (i = 0; i < VP8_KF_BINTRAMODES; i++) {
+      for (i = 0; i < VP9_KF_BINTRAMODES; i++) {
 
         fprintf(fmode, "    { // Above Mode :  %d\n", i);
 
-        for (j = 0; j < VP8_KF_BINTRAMODES; j++) {
+        for (j = 0; j < VP9_KF_BINTRAMODES; j++) {
 
           fprintf(fmode, "        {");
 
           for (k = 0; k < VP9_KF_BINTRAMODES; k++) {
             if (!intra_mode_stats[i][j][k])
               fprintf(fmode, " %5d, ", 1);
             else
               fprintf(fmode, " %5d, ", intra_mode_stats[i][j][k]);
           }
 
@@ skipping 64 matching lines @@
     fclose(framepsnr);
 
   if (kf_list)
     fclose(kf_list);
 
 #endif
 
 }
 
 
-static uint64_t calc_plane_error(unsigned char *orig, int orig_stride,
-                                 unsigned char *recon, int recon_stride,
+static uint64_t calc_plane_error(uint8_t *orig, int orig_stride,
+                                 uint8_t *recon, int recon_stride,
                                  unsigned int cols, unsigned int rows) {
   unsigned int row, col;
   uint64_t total_sse = 0;
   int diff;
 
   for (row = 0; row + 16 <= rows; row += 16) {
     for (col = 0; col + 16 <= cols; col += 16) {
       unsigned int sse;
 
       vp9_mse16x16(orig + col, orig_stride, recon + col, recon_stride, &sse);
       total_sse += sse;
     }
 
     /* Handle odd-sized width */
     if (col < cols) {
-      unsigned int   border_row, border_col;
-      unsigned char *border_orig = orig;
-      unsigned char *border_recon = recon;
+      unsigned int border_row, border_col;
+      uint8_t *border_orig = orig;
+      uint8_t *border_recon = recon;
 
       for (border_row = 0; border_row < 16; border_row++) {
         for (border_col = col; border_col < cols; border_col++) {
           diff = border_orig[border_col] - border_recon[border_col];
           total_sse += diff * diff;
         }
 
         border_orig += orig_stride;
         border_recon += recon_stride;
       }
@@ skipping 138 matching lines @@
   VP9_COMP *cpi = (VP9_COMP *) comp;
   VP9_COMMON *cm = &cpi->common;
   cm->refresh_entropy_probs = update;
 
   return 0;
 }
 
 
 #ifdef OUTPUT_YUV_SRC
 void vp9_write_yuv_frame(YV12_BUFFER_CONFIG *s) {
-  unsigned char *src = s->y_buffer;
+  uint8_t *src = s->y_buffer;
   int h = s->y_height;
 
   do {
     fwrite(src, s->y_width, 1,  yuv_file);
     src += s->y_stride;
   } while (--h);
 
   src = s->u_buffer;
   h = s->uv_height;
 
   do {
     fwrite(src, s->uv_width, 1,  yuv_file);
     src += s->uv_stride;
   } while (--h);
 
   src = s->v_buffer;
   h = s->uv_height;
 
   do {
     fwrite(src, s->uv_width, 1, yuv_file);
     src += s->uv_stride;
   } while (--h);
 }
 #endif
 
 #ifdef OUTPUT_YUV_REC
 void vp9_write_yuv_rec_frame(VP9_COMMON *cm) {
   YV12_BUFFER_CONFIG *s = cm->frame_to_show;
-  unsigned char *src = s->y_buffer;
+  uint8_t *src = s->y_buffer;
   int h = cm->Height;
 
   do {
     fwrite(src, s->y_width, 1,  yuv_rec_file);
     src += s->y_stride;
   } while (--h);
 
   src = s->u_buffer;
   h = (cm->Height + 1) / 2;
 
@@ skipping 152 matching lines @@
 
   fclose(yframe);
 }
 #endif
 
 static double compute_edge_pixel_proportion(YV12_BUFFER_CONFIG *frame) {
 #define EDGE_THRESH 128
   int i, j;
   int num_edge_pels = 0;
   int num_pels = (frame->y_height - 2) * (frame->y_width - 2);
-  unsigned char *prev = frame->y_buffer + 1;
-  unsigned char *curr = frame->y_buffer + 1 + frame->y_stride;
-  unsigned char *next = frame->y_buffer + 1 + 2 * frame->y_stride;
+  uint8_t *prev = frame->y_buffer + 1;
+  uint8_t *curr = frame->y_buffer + 1 + frame->y_stride;
+  uint8_t *next = frame->y_buffer + 1 + 2 * frame->y_stride;
   for (i = 1; i < frame->y_height - 1; i++) {
     for (j = 1; j < frame->y_width - 1; j++) {
       /* Sobel hor and ver gradients */
       int v = 2 * (curr[1] - curr[-1]) + (prev[1] - prev[-1]) + (next[1] - next[-1]);
       int h = 2 * (prev[0] - next[0]) + (prev[1] - next[1]) + (prev[-1] - next[-1]);
       h = (h < 0 ? -h : h);
       v = (v < 0 ? -v : v);
       if (h > EDGE_THRESH || v > EDGE_THRESH) num_edge_pels++;
       curr++;
       prev++;
       next++;
     }
     curr += frame->y_stride - frame->y_width + 2;
     prev += frame->y_stride - frame->y_width + 2;
     next += frame->y_stride - frame->y_width + 2;
   }
   return (double)num_edge_pels / (double)num_pels;
 }
 
 // Function to test for conditions that indicate we should loop
 // back and recode a frame.
-static BOOL recode_loop_test(VP9_COMP *cpi,
-                             int high_limit, int low_limit,
-                             int q, int maxq, int minq) {
-  BOOL    force_recode = FALSE;
+static int recode_loop_test(VP9_COMP *cpi,
+                            int high_limit, int low_limit,
+                            int q, int maxq, int minq) {
+  int force_recode = FALSE;
   VP9_COMMON *cm = &cpi->common;
 
   // Is frame recode allowed at all
   // Yes if either recode mode 1 is selected or mode two is selcted
   // and the frame is a key frame. golden frame or alt_ref_frame
   if ((cpi->sf.recode_loop == 1) ||
       ((cpi->sf.recode_loop == 2) &&
        ((cm->frame_type == KEY_FRAME) ||
         cm->refresh_golden_frame ||
         cm->refresh_alt_ref_frame))) {
@@ skipping 112 matching lines @@
       vp9_pick_filter_level_fast(cpi->Source, cpi);
     else
       vp9_pick_filter_level(cpi->Source, cpi);
 
     vpx_usec_timer_mark(&timer);
     cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
   }
 
   if (cm->filter_level > 0) {
     vp9_set_alt_lf_level(cpi, cm->filter_level);
-    vp9_loop_filter_frame(cm, &cpi->mb.e_mbd);
+    vp9_loop_filter_frame(cm, &cpi->mb.e_mbd, cm->filter_level, 0);
   }
 
   vp8_yv12_extend_frame_borders(cm->frame_to_show);
 
 }
 
-#if CONFIG_PRED_FILTER
-void select_pred_filter_mode(VP9_COMP *cpi) {
-  VP9_COMMON *cm = &cpi->common;
+void select_interp_filter_type(VP9_COMP *cpi) {
+  int i;
+  int high_filter_index = 0;
+  unsigned int thresh;
+  unsigned int high_count = 0;
+  unsigned int count_sum = 0;
+  unsigned int *hist = cpi->best_switchable_interp_count;
 
-  int prob_pred_filter_off = cm->prob_pred_filter_off;
+  if (DEFAULT_INTERP_FILTER != SWITCHABLE) {
+    cpi->common.mcomp_filter_type = DEFAULT_INTERP_FILTER;
+    return;
+  }
 
-  // Force filter on/off if probability is extreme
-  if (prob_pred_filter_off >= 255 * 0.95)
-    cm->pred_filter_mode = 0;   // Off at the frame level
-  else if (prob_pred_filter_off <= 255 * 0.05)
-    cm->pred_filter_mode = 1;   // On at the frame level
-  else
-    cm->pred_filter_mode = 2;   // Selectable at the MB level
+  // TODO(agrange): Look at using RD criteria to select the interpolation
+  // filter to use for the next frame rather than this simpler counting scheme.
+
+  // Select the interpolation filter mode for the next frame
+  // based on the selection frequency seen in the current frame.
+  for (i = 0; i < VP9_SWITCHABLE_FILTERS; ++i) {
+    unsigned int count = hist[i];
+    count_sum += count;
+    if (count > high_count) {
+      high_count = count;
+      high_filter_index = i;
+    }
+  }
+
+  thresh = (unsigned int)(0.80 * count_sum);
+
+  if (high_count > thresh) {
+    // One filter accounts for 80+% of cases so force the next
+    // frame to use this filter exclusively using frame-level flag.
+    cpi->common.mcomp_filter_type = vp9_switchable_interp[high_filter_index];
+  } else {
+    // Use a MB-level switchable filter selection strategy.
+    cpi->common.mcomp_filter_type = SWITCHABLE;
+  }
 }
 
-void update_pred_filt_prob(VP9_COMP *cpi) {
-  VP9_COMMON *cm = &cpi->common;
-  int prob_pred_filter_off;
-
-  // Based on the selection in the previous frame determine what mode
-  // to use for the current frame and work out the signaling probability
-  if (cpi->pred_filter_on_count + cpi->pred_filter_off_count) {
-    prob_pred_filter_off = cpi->pred_filter_off_count * 256 /
-                           (cpi->pred_filter_on_count + cpi->pred_filter_off_count);
-
-    if (prob_pred_filter_off < 1)
-      prob_pred_filter_off = 1;
-
-    if (prob_pred_filter_off > 255)
-      prob_pred_filter_off = 255;
-
-    cm->prob_pred_filter_off = prob_pred_filter_off;
-  } else
-    cm->prob_pred_filter_off = 128;
-  /*
-      {
-        FILE *fp = fopen("filt_use.txt", "a");
-        fprintf (fp, "%d %d prob=%d\n", cpi->pred_filter_off_count,
-                 cpi->pred_filter_on_count, cm->prob_pred_filter_off);
-        fclose(fp);
-      }
-  */
-}
-#endif
 #if CONFIG_COMP_INTERINTRA_PRED
 static void select_interintra_mode(VP9_COMP *cpi) {
   static const double threshold = 0.01;
   VP9_COMMON *cm = &cpi->common;
   // FIXME(debargha): Make this RD based
   int sum = cpi->interintra_select_count[1] + cpi->interintra_select_count[0];
   if (sum) {
     double fraction = (double) cpi->interintra_select_count[1] / sum;
     // printf("fraction: %f\n", fraction);
     cm->use_interintra = (fraction > threshold);
   }
 }
 #endif
 
-static void encode_frame_to_data_rate
-(
-  VP9_COMP *cpi,
-  unsigned long *size,
-  unsigned char *dest,
-  unsigned int *frame_flags
-) {
+static void encode_frame_to_data_rate(VP9_COMP *cpi,
+                                      unsigned long *size,
+                                      unsigned char *dest,
+                                      unsigned int *frame_flags) {
   VP9_COMMON *cm = &cpi->common;
   MACROBLOCKD *xd = &cpi->mb.e_mbd;
 
   int Q;
   int frame_over_shoot_limit;
   int frame_under_shoot_limit;
 
   int Loop = FALSE;
   int loop_count;
-  int this_q;
-  int last_zbin_oq;
 
   int q_low;
   int q_high;
   int zbin_oq_high;
   int zbin_oq_low = 0;
 
   int top_index;
   int bottom_index;
   int active_worst_qchanged = FALSE;
 
   int overshoot_seen = FALSE;
   int undershoot_seen = FALSE;
 
-  int loop_size_estimate = 0;
-
   SPEED_FEATURES *sf = &cpi->sf;
 #if RESET_FOREACH_FILTER
   int q_low0;
   int q_high0;
   int zbin_oq_high0;
   int zbin_oq_low0 = 0;
   int Q0;
+  int last_zbin_oq;
   int last_zbin_oq0;
   int active_best_quality0;
   int active_worst_quality0;
   double rate_correction_factor0;
   double gf_rate_correction_factor0;
 #endif
 
   /* list of filters to search over */
   int mcomp_filters_to_search[] = {
-    EIGHTTAP, EIGHTTAP_SHARP, SIXTAP, SWITCHABLE
+#if CONFIG_ENABLE_6TAP
+      EIGHTTAP, EIGHTTAP_SHARP, SIXTAP, SWITCHABLE
+#else
+      EIGHTTAP, EIGHTTAP_SHARP, EIGHTTAP_SMOOTH, SWITCHABLE
+#endif
   };
   int mcomp_filters = sizeof(mcomp_filters_to_search) /
       sizeof(*mcomp_filters_to_search);
   int mcomp_filter_index = 0;
-  INT64 mcomp_filter_cost[4];
+  int64_t mcomp_filter_cost[4];
 
   // Clear down mmx registers to allow floating point in what follows
   vp9_clear_system_state();
 
 
   // For an alt ref frame in 2 pass we skip the call to the second
   // pass function that sets the target bandwidth so must set it here
   if (cpi->common.refresh_alt_ref_frame) {
     cpi->per_frame_bandwidth = cpi->twopass.gf_bits;                           // Per frame bit target for the alt ref frame
     // per second target bitrate
@@ skipping 33 matching lines @@
   if ((cm->current_video_frame == 0) ||
       (cm->frame_flags & FRAMEFLAGS_KEY) ||
       (cpi->oxcf.auto_key && (cpi->frames_since_key % cpi->key_frame_frequency == 0))) {
     // Key frame from VFW/auto-keyframe/first frame
     cm->frame_type = KEY_FRAME;
   }
 
   // Set default state for segment based loop filter update flags
   xd->mode_ref_lf_delta_update = 0;
 
-#if CONFIG_NEW_MVREF
-  // Temp defaults probabilities for ecnoding the MV ref id signal
-  vpx_memset(xd->mb_mv_ref_id_probs, 192,
-             sizeof(xd->mb_mv_ref_id_probs));
-#endif
 
   // Set various flags etc to special state if it is a key frame
   if (cm->frame_type == KEY_FRAME) {
     int i;
 
     // Reset the loop filter deltas and segmentation map
     setup_features(cpi);
 
     // If segmentation is enabled force a map update for key frames
     if (xd->segmentation_enabled) {
@@ skipping 119 matching lines @@
 
   if (cpi->active_best_quality < cpi->best_quality)
     cpi->active_best_quality = cpi->best_quality;
 
   if (cpi->active_best_quality > cpi->worst_quality)
     cpi->active_best_quality = cpi->worst_quality;
 
   if (cpi->active_worst_quality < cpi->active_best_quality)
     cpi->active_worst_quality = cpi->active_best_quality;
 
-  // Specuial case code to try and match quality with forced key frames
+  // Special case code to try and match quality with forced key frames
   if ((cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced) {
     Q = cpi->last_boosted_qindex;
   } else {
     // Determine initial Q to try
     Q = vp9_regulate_q(cpi, cpi->this_frame_target);
   }
+#if RESET_FOREACH_FILTER
   last_zbin_oq = cpi->zbin_over_quant;
+#endif
 
   // Set highest allowed value for Zbin over quant
   if (cm->frame_type == KEY_FRAME)
     zbin_oq_high = 0; // ZBIN_OQ_MAX/16
   else if (cm->refresh_alt_ref_frame || (cm->refresh_golden_frame && !cpi->source_alt_ref_active))
     zbin_oq_high = 16;
   else
     zbin_oq_high = ZBIN_OQ_MAX;
 
   vp9_compute_frame_size_bounds(cpi, &frame_under_shoot_limit,
@@ skipping 22 matching lines @@
 
 #if CONFIG_COMP_INTERINTRA_PRED
   if (cm->current_video_frame == 0) {
     cm->use_interintra = 1;
   }
 #endif
 
 #if CONFIG_POSTPROC
 
   if (cpi->oxcf.noise_sensitivity > 0) {
-    unsigned char *src;
+    uint8_t *src;
     int l = 0;
 
     switch (cpi->oxcf.noise_sensitivity) {
       case 1:
         l = 20;
         break;
       case 2:
         l = 40;
         break;
       case 3:
@@ skipping 40 matching lines @@
     rate_correction_factor0 = cpi->rate_correction_factor;
     gf_rate_correction_factor0 = cpi->gf_rate_correction_factor;
     active_best_quality0 = cpi->active_best_quality;
     active_worst_quality0 = cpi->active_worst_quality;
   }
 #endif
   do {
     vp9_clear_system_state();  // __asm emms;
 
     vp9_set_quantizer(cpi, Q);
-    this_q = Q;
 
     if (loop_count == 0) {
 
       // setup skip prob for costing in mode/mv decision
       if (cpi->common.mb_no_coeff_skip) {
         int k;
         for (k = 0; k < MBSKIP_CONTEXTS; k++)
           cm->mbskip_pred_probs[k] = cpi->base_skip_false_prob[Q][k];
 
         if (cm->frame_type != KEY_FRAME) {
@@ skipping 43 matching lines @@
     // transform / motion compensation build reconstruction frame
 
     vp9_encode_frame(cpi);
 
     // Update the skip mb flag probabilities based on the distribution
     // seen in the last encoder iteration.
     update_base_skip_probs(cpi);
 
     vp9_clear_system_state();  // __asm emms;
 
-#if CONFIG_PRED_FILTER
-    // Update prediction filter on/off probability based on
-    // selection made for the current frame
-    if (cm->frame_type != KEY_FRAME)
-      update_pred_filt_prob(cpi);
-#endif
-
     // Dummy pack of the bitstream using up to date stats to get an
     // accurate estimate of output frame size to determine if we need
     // to recode.
     vp9_save_coding_context(cpi);
     cpi->dummy_packing = 1;
     vp9_pack_bitstream(cpi, dest, size);
     cpi->projected_frame_size = (*size) << 3;
     vp9_restore_coding_context(cpi);
 
     if (frame_over_shoot_limit == 0)
@@ skipping 145 matching lines @@
       else if (Q < q_low)
         Q = q_low;
 
       // Clamp cpi->zbin_over_quant
       cpi->zbin_over_quant = (cpi->zbin_over_quant < zbin_oq_low) ?
           zbin_oq_low : (cpi->zbin_over_quant > zbin_oq_high) ?
           zbin_oq_high : cpi->zbin_over_quant;
 
       // Loop = ((Q != last_q) || (last_zbin_oq != cpi->zbin_over_quant)) ? TRUE : FALSE;
       Loop = ((Q != last_q)) ? TRUE : FALSE;
+#if RESET_FOREACH_FILTER
       last_zbin_oq = cpi->zbin_over_quant;
+#endif
     } else
       Loop = FALSE;
 
     if (cpi->is_src_frame_alt_ref)
       Loop = FALSE;
 
-    if (cm->frame_type != KEY_FRAME &&
-        !sf->search_best_filter &&
-        cm->mcomp_filter_type == SWITCHABLE) {
-      int interp_factor = Q / 3;  /* denominator is 256 */
-      int count[VP9_SWITCHABLE_FILTERS];
-      int tot_count = 0, c = 0, thr;
-      int i, j;
-      for (i = 0; i < VP9_SWITCHABLE_FILTERS; ++i) {
-        count[i] = 0;
-        for (j = 0; j <= VP9_SWITCHABLE_FILTERS; ++j) {
-          count[i] += cpi->switchable_interp_count[j][i];
-        }
-        tot_count += count[i];
-      }
-
-      thr = ((tot_count * interp_factor + 128) >> 8);
-      for (i = 0; i < VP9_SWITCHABLE_FILTERS; ++i) {
-        c += (count[i] >= thr);
-      }
-      if (c == 1) {
-        /* Mostly one filter is used. So set the filter at frame level */
-        for (i = 0; i < VP9_SWITCHABLE_FILTERS; ++i) {
-          if (count[i]) {
-            cm->mcomp_filter_type = vp9_switchable_interp[i];
-            Loop = TRUE;  /* Make sure to loop since the filter changed */
-            break;
-          }
-        }
-      }
-    }
-
     if (Loop == FALSE && cm->frame_type != KEY_FRAME && sf->search_best_filter) {
       if (mcomp_filter_index < mcomp_filters) {
-        INT64 err = vp9_calc_ss_err(cpi->Source,
+        int64_t err = vp9_calc_ss_err(cpi->Source,
                                     &cm->yv12_fb[cm->new_fb_idx]);
-        INT64 rate = cpi->projected_frame_size << 8;
+        int64_t rate = cpi->projected_frame_size << 8;
         mcomp_filter_cost[mcomp_filter_index] =
           (RDCOST(cpi->RDMULT, cpi->RDDIV, rate, err));
         mcomp_filter_index++;
         if (mcomp_filter_index < mcomp_filters) {
           cm->mcomp_filter_type = mcomp_filters_to_search[mcomp_filter_index];
           loop_count = -1;
           Loop = TRUE;
         } else {
           int f;
-          INT64 best_cost = mcomp_filter_cost[0];
+          int64_t best_cost = mcomp_filter_cost[0];
           int mcomp_best_filter = mcomp_filters_to_search[0];
           for (f = 1; f < mcomp_filters; f++) {
             if (mcomp_filter_cost[f] < best_cost) {
               mcomp_best_filter = mcomp_filters_to_search[f];
               best_cost = mcomp_filter_cost[f];
             }
           }
           if (mcomp_best_filter != mcomp_filters_to_search[mcomp_filters - 1]) {
             loop_count = -1;
             Loop = TRUE;
@@ skipping 19 matching lines @@
           cpi->gf_rate_correction_factor = gf_rate_correction_factor0;
           cpi->active_best_quality = active_best_quality0;
           cpi->active_worst_quality = active_worst_quality0;
         }
 #endif
       }
     }
 
     if (Loop == TRUE) {
       loop_count++;
+
 #if CONFIG_INTERNAL_STATS
       cpi->tot_recode_hits++;
 #endif
     }
   } while (Loop == TRUE);
 
   // Special case code to reduce pulsing when key frames are forced at a
   // fixed interval. Note the reconstruction error if it is the frame before
   // the force key frame
   if (cpi->next_key_frame_forced && (cpi->twopass.frames_to_key == 0)) {
@@ skipping 55 matching lines @@
   loopfilter_frame(cpi, cm);
 
   // build the bitstream
   cpi->dummy_packing = 0;
   vp9_pack_bitstream(cpi, dest, size);
 
   if (cpi->mb.e_mbd.update_mb_segmentation_map) {
     update_reference_segmentation_map(cpi);
   }
 
-#if CONFIG_PRED_FILTER
-  // Select the prediction filtering mode to use for the
-  // next frame based on the current frame selections
-  if (cm->frame_type != KEY_FRAME)
-    select_pred_filter_mode(cpi);
-#endif
-
   update_reference_frames(cm);
-  vp9_copy(cpi->common.fc.coef_counts, cpi->coef_counts);
-  vp9_copy(cpi->common.fc.hybrid_coef_counts, cpi->hybrid_coef_counts);
+  vp9_copy(cpi->common.fc.coef_counts_4x4, cpi->coef_counts_4x4);
+  vp9_copy(cpi->common.fc.hybrid_coef_counts_4x4,
+           cpi->hybrid_coef_counts_4x4);
   vp9_copy(cpi->common.fc.coef_counts_8x8, cpi->coef_counts_8x8);
-  vp9_copy(cpi->common.fc.hybrid_coef_counts_8x8, cpi->hybrid_coef_counts_8x8);
+  vp9_copy(cpi->common.fc.hybrid_coef_counts_8x8,
+           cpi->hybrid_coef_counts_8x8);
   vp9_copy(cpi->common.fc.coef_counts_16x16, cpi->coef_counts_16x16);
   vp9_copy(cpi->common.fc.hybrid_coef_counts_16x16,
            cpi->hybrid_coef_counts_16x16);
+  vp9_copy(cpi->common.fc.coef_counts_32x32, cpi->coef_counts_32x32);
   vp9_adapt_coef_probs(&cpi->common);
   if (cpi->common.frame_type != KEY_FRAME) {
-#if CONFIG_SUPERBLOCKS
     vp9_copy(cpi->common.fc.sb_ymode_counts, cpi->sb_ymode_count);
-#endif
     vp9_copy(cpi->common.fc.ymode_counts, cpi->ymode_count);
     vp9_copy(cpi->common.fc.uv_mode_counts, cpi->y_uv_mode_count);
     vp9_copy(cpi->common.fc.bmode_counts, cpi->bmode_count);
     vp9_copy(cpi->common.fc.i8x8_mode_counts, cpi->i8x8_mode_count);
     vp9_copy(cpi->common.fc.sub_mv_ref_counts, cpi->sub_mv_ref_count);
     vp9_copy(cpi->common.fc.mbsplit_counts, cpi->mbsplit_count);
 #if CONFIG_COMP_INTERINTRA_PRED
     vp9_copy(cpi->common.fc.interintra_counts, cpi->interintra_count);
 #endif
     vp9_adapt_mode_probs(&cpi->common);
 
     cpi->common.fc.NMVcount = cpi->NMVcount;
     /*
     printf("2: %d %d %d %d\n", cpi->NMVcount.joints[0], cpi->NMVcount.joints[1],
                       cpi->NMVcount.joints[2], cpi->NMVcount.joints[3]);
                       */
     vp9_adapt_nmv_probs(&cpi->common, cpi->mb.e_mbd.allow_high_precision_mv);
   }
 #if CONFIG_COMP_INTERINTRA_PRED
   if (cm->frame_type != KEY_FRAME)
     select_interintra_mode(cpi);
 #endif
 
   /* Move storing frame_type out of the above loop since it is also
    * needed in motion search besides loopfilter */
   cm->last_frame_type = cm->frame_type;
 
-  // Keep a copy of the size estimate used in the loop
-  loop_size_estimate = cpi->projected_frame_size;
-
   // Update rate control heuristics
   cpi->total_byte_count += (*size);
   cpi->projected_frame_size = (*size) << 3;
 
   if (!active_worst_qchanged)
     vp9_update_rate_correction_factors(cpi, 2);
 
   cpi->last_q[cm->frame_type] = cm->base_qindex;
 
   // Keep record of last boosted (KF/KF/ARF) Q value.
@@ skipping 64 matching lines @@
     cpi->twopass.gf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
 
     if (cpi->twopass.gf_group_bits < 0)
       cpi->twopass.gf_group_bits = 0;
   }
 
   // Update the skip mb flag probabilities based on the distribution seen
   // in this frame.
   update_base_skip_probs(cpi);
 
-#if 0 //CONFIG_NEW_MVREF && CONFIG_INTERNAL_STATS
-  {
-    FILE *f = fopen("mv_ref_dist.stt", "a");
-    unsigned int i;
-    for (i = 0; i < MAX_MV_REFS; ++i) {
-      fprintf(f, "%10d", cpi->best_ref_index_counts[0][i]);
-    }
-    fprintf(f, "\n" );
-
-    fclose(f);
-  }
-#endif
-
 #if 0// 1 && CONFIG_INTERNAL_STATS
   {
     FILE *f = fopen("tmp.stt", "a");
     int recon_err;
 
     vp9_clear_system_state();  // __asm emms;
 
     recon_err = vp9_calc_ss_err(cpi->Source,
                                 &cm->yv12_fb[cm->new_fb_idx]);
 
     if (cpi->twopass.total_left_stats->coded_error != 0.0)
       fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d"
               "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f"
               "%6d %5d %5d %5d %8d %8.2f %10d %10.3f"
               "%10.3f %8d %10d %10d %10d\n",
               cpi->common.current_video_frame, cpi->this_frame_target,
-              cpi->projected_frame_size, loop_size_estimate,
+              cpi->projected_frame_size, 0, //loop_size_estimate,
               (cpi->projected_frame_size - cpi->this_frame_target),
               (int)cpi->total_target_vs_actual,
               (cpi->oxcf.starting_buffer_level - cpi->bits_off_target),
               (int)cpi->total_actual_bits,
               vp9_convert_qindex_to_q(cm->base_qindex),
               (double)vp9_dc_quant(cm->base_qindex, 0) / 4.0,
               vp9_convert_qindex_to_q(cpi->active_best_quality),
               vp9_convert_qindex_to_q(cpi->active_worst_quality),
               cpi->avg_q,
               vp9_convert_qindex_to_q(cpi->ni_av_qi),
               vp9_convert_qindex_to_q(cpi->cq_target_quality),
               cpi->zbin_over_quant,
               // cpi->avg_frame_qindex, cpi->zbin_over_quant,
               cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
               cm->frame_type, cpi->gfu_boost,
               cpi->twopass.est_max_qcorrection_factor,
               (int)cpi->twopass.bits_left,
               cpi->twopass.total_left_stats->coded_error,
               (double)cpi->twopass.bits_left /
               cpi->twopass.total_left_stats->coded_error,
               cpi->tot_recode_hits, recon_err, cpi->kf_boost,
               cpi->kf_zeromotion_pct);
     else
       fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d"
               "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f"
               "%6d %5d %5d %5d %8d %8.2f %10d %10.3f"
               "%8d %10d %10d %10d\n",
               cpi->common.current_video_frame,
               cpi->this_frame_target, cpi->projected_frame_size,
-              loop_size_estimate,
+              0, //loop_size_estimate,
               (cpi->projected_frame_size - cpi->this_frame_target),
               (int)cpi->total_target_vs_actual,
               (cpi->oxcf.starting_buffer_level - cpi->bits_off_target),
               (int)cpi->total_actual_bits,
               vp9_convert_qindex_to_q(cm->base_qindex),
               (double)vp9_dc_quant(cm->base_qindex, 0) / 4.0,
               vp9_convert_qindex_to_q(cpi->active_best_quality),
               vp9_convert_qindex_to_q(cpi->active_worst_quality),
               cpi->avg_q,
               vp9_convert_qindex_to_q(cpi->ni_av_qi),
@@ skipping 601 matching lines @@
 
   return 0;
 }
 
 
 
 int vp9_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest) {
   int i, j;
   int Total = 0;
 
-  unsigned char *src = source->y_buffer;
-  unsigned char *dst = dest->y_buffer;
+  uint8_t *src = source->y_buffer;
+  uint8_t *dst = dest->y_buffer;
 
   // Loop through the Y plane raw and reconstruction data summing (square differences)
   for (i = 0; i < source->y_height; i += 16) {
     for (j = 0; j < source->y_width; j += 16) {
       unsigned int sse;
       Total += vp9_mse16x16(src + j, source->y_stride, dst + j, dest->y_stride,
                             &sse);
     }
 
     src += 16 * source->y_stride;
     dst += 16 * dest->y_stride;
   }
 
   return Total;
 }
 
 
 int vp9_get_quantizer(VP9_PTR c) {
   VP9_COMP   *cpi = (VP9_COMP *) c;
   return cpi->common.base_qindex;
 }