libvpx: Pull from upstream

source/libvpx/vp9/encoder/vp9_mcomp.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 "vp9/encoder/vp9_onyx_int.h"
 #include "vp9/encoder/vp9_mcomp.h"
 #include "vpx_mem/vpx_mem.h"
-#include "vpx_ports/config.h"
+#include "./vpx_config.h"
 #include <stdio.h>
 #include <limits.h>
 #include <math.h>
 #include "vp9/common/vp9_findnearmv.h"
+#include "vp9/common/vp9_common.h"
 
 #ifdef ENTROPY_STATS
 static int mv_ref_ct [31] [4] [2];
 static int mv_mode_cts [4] [2];
 #endif
 
 void vp9_clamp_mv_min_max(MACROBLOCK *x, int_mv *ref_mv) {
   int col_min = (ref_mv->as_mv.col >> 3) - MAX_FULL_PEL_VAL +
       ((ref_mv->as_mv.col & 7) ? 1 : 0);
   int row_min = (ref_mv->as_mv.row >> 3) - MAX_FULL_PEL_VAL +
@@ skipping 204 matching lines @@
       if ((v = MVC(r, c) + thismse) < besterr) {                         \
         besterr = v;                                                     \
         br = r;                                                          \
         bc = c;                                                          \
         *distortion = thismse;                                           \
         *sse1 = sse;                                                     \
       }                                                                  \
     },                                                                   \
     v = INT_MAX;)
 
-#define MIN(x,y) (((x)<(y))?(x):(y))
-#define MAX(x,y) (((x)>(y))?(x):(y))
-
 int vp9_find_best_sub_pixel_step_iteratively(MACROBLOCK *x, BLOCK *b, BLOCKD *d,
                                              int_mv *bestmv, int_mv *ref_mv,
                                              int error_per_bit,
                                              const vp9_variance_fn_ptr_t *vfp,
                                              int *mvjcost, int *mvcost[2],
                                              int *distortion,
                                              unsigned int *sse1) {
-  unsigned char *z = (*(b->base_src) + b->src);
+  uint8_t *z = (*(b->base_src) + b->src);
   MACROBLOCKD *xd = &x->e_mbd;
 
   int rr, rc, br, bc, hstep;
   int tr, tc;
   unsigned int besterr = INT_MAX;
   unsigned int left, right, up, down, diag;
   unsigned int sse;
   unsigned int whichdir;
   unsigned int halfiters = 4;
   unsigned int quarteriters = 4;
   unsigned int eighthiters = 4;
   int thismse;
   int maxc, minc, maxr, minr;
   int y_stride;
   int offset;
   int usehp = xd->allow_high_precision_mv;
 
-#if !CONFIG_SUPERBLOCKS && (ARCH_X86 || ARCH_X86_64)
-  unsigned char *y0 = *(d->base_pre) + d->pre + (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col;
-  unsigned char *y;
-  int buf_r1, buf_r2, buf_c1, buf_c2;
-
-  // Clamping to avoid out-of-range data access
-  buf_r1 = ((bestmv->as_mv.row - VP9_INTERP_EXTEND) < x->mv_row_min) ?
-      (bestmv->as_mv.row - x->mv_row_min) : VP9_INTERP_EXTEND - 1;
-  buf_r2 = ((bestmv->as_mv.row + VP9_INTERP_EXTEND) > x->mv_row_max) ?
-      (x->mv_row_max - bestmv->as_mv.row) : VP9_INTERP_EXTEND - 1;
-  buf_c1 = ((bestmv->as_mv.col - VP9_INTERP_EXTEND) < x->mv_col_min) ?
-      (bestmv->as_mv.col - x->mv_col_min) : VP9_INTERP_EXTEND - 1;
-  buf_c2 = ((bestmv->as_mv.col + VP9_INTERP_EXTEND) > x->mv_col_max) ?
-      (x->mv_col_max - bestmv->as_mv.col) : VP9_INTERP_EXTEND - 1;
-  y_stride = 32;
-
-  /* Copy to intermediate buffer before searching. */
-  vfp->copymem(y0 - buf_c1 - d->pre_stride * buf_r1, d->pre_stride, xd->y_buf, y_stride, 16 + buf_r1 + buf_r2);
-  y = xd->y_buf + y_stride * buf_r1 + buf_c1;
-#else
-  unsigned char *y = *(d->base_pre) + d->pre + (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col;
+  uint8_t *y = *(d->base_pre) + d->pre +
+               (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col;
   y_stride = d->pre_stride;
-#endif
 
   rr = ref_mv->as_mv.row;
   rc = ref_mv->as_mv.col;
   br = bestmv->as_mv.row << 3;
   bc = bestmv->as_mv.col << 3;
   hstep = 4;
   minc = MAX(x->mv_col_min << 3, (ref_mv->as_mv.col) - ((1 << MV_MAX_BITS) - 1));
   maxc = MIN(x->mv_col_max << 3, (ref_mv->as_mv.col) + ((1 << MV_MAX_BITS) - 1));
   minr = MAX(x->mv_row_min << 3, (ref_mv->as_mv.row) - ((1 << MV_MAX_BITS) - 1));
   maxr = MIN(x->mv_row_max << 3, (ref_mv->as_mv.row) + ((1 << MV_MAX_BITS) - 1));
@@ skipping 142 matching lines @@
                                  int_mv *bestmv, int_mv *ref_mv,
                                  int error_per_bit,
                                  const vp9_variance_fn_ptr_t *vfp,
                                  int *mvjcost, int *mvcost[2], int *distortion,
                                  unsigned int *sse1) {
   int bestmse = INT_MAX;
   int_mv startmv;
   int_mv this_mv;
   int_mv orig_mv;
   int yrow_movedback = 0, ycol_movedback = 0;
-  unsigned char *z = (*(b->base_src) + b->src);
+  uint8_t *z = (*(b->base_src) + b->src);
   int left, right, up, down, diag;
   unsigned int sse;
   int whichdir;
   int thismse;
   int y_stride;
   MACROBLOCKD *xd = &x->e_mbd;
   int usehp = xd->allow_high_precision_mv;
 
-#if !CONFIG_SUPERBLOCKS && (ARCH_X86 || ARCH_X86_64)
-  unsigned char *y0 = *(d->base_pre) + d->pre + (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col;
-  unsigned char *y;
-
-  y_stride = 32;
-  /* Copy 18 rows x 32 cols area to intermediate buffer before searching. */
-  vfp->copymem(y0 - 1 - d->pre_stride, d->pre_stride, xd->y_buf, y_stride, 18);
-  y = xd->y_buf + y_stride + 1;
-#else
-  unsigned char *y = *(d->base_pre) + d->pre + (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col;
+  uint8_t *y = *(d->base_pre) + d->pre +
+               (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col;
   y_stride = d->pre_stride;
-#endif
 
   // central mv
   bestmv->as_mv.row <<= 3;
   bestmv->as_mv.col <<= 3;
   startmv = *bestmv;
   orig_mv = *bestmv;
 
   // calculate central point error
   bestmse = vfp->vf(y, y_stride, z, b->src_stride, sse1);
   *distortion = bestmse;
@@ skipping 438 matching lines @@
 int vp9_find_best_half_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d,
                                   int_mv *bestmv, int_mv *ref_mv,
                                   int error_per_bit,
                                   const vp9_variance_fn_ptr_t *vfp,
                                   int *mvjcost, int *mvcost[2],
                                   int *distortion,
                                   unsigned int *sse1) {
   int bestmse = INT_MAX;
   int_mv startmv;
   int_mv this_mv;
-  unsigned char *z = (*(b->base_src) + b->src);
+  uint8_t *z = (*(b->base_src) + b->src);
   int left, right, up, down, diag;
   unsigned int sse;
   int whichdir;
   int thismse;
   int y_stride;
   MACROBLOCKD *xd = &x->e_mbd;
 
-#if !CONFIG_SUPERBLOCKS && (ARCH_X86 || ARCH_X86_64)
-  unsigned char *y0 = *(d->base_pre) + d->pre +
-      (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col;
-  unsigned char *y;
-
-  y_stride = 32;
-  /* Copy 18 rows x 32 cols area to intermediate buffer before searching. */
-  vfp->copymem(y0 - 1 - d->pre_stride, d->pre_stride, xd->y_buf, y_stride, 18);
-  y = xd->y_buf + y_stride + 1;
-#else
-  unsigned char *y = *(d->base_pre) + d->pre +
+  uint8_t *y = *(d->base_pre) + d->pre +
       (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col;
   y_stride = d->pre_stride;
-#endif
 
   // central mv
   bestmv->as_mv.row <<= 3;
   bestmv->as_mv.col <<= 3;
   startmv = *bestmv;
 
   // calculate central point error
   bestmse = vfp->vf(y, y_stride, z, b->src_stride, sse1);
   *distortion = bestmse;
   bestmse += mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit,
@@ skipping 143 matching lines @@
   int sad_per_bit,
   const vp9_variance_fn_ptr_t *vfp,
   int *mvjsadcost, int *mvsadcost[2],
   int *mvjcost, int *mvcost[2],
   int_mv *center_mv
 ) {
   MV hex[6] = { { -1, -2}, {1, -2}, {2, 0}, {1, 2}, { -1, 2}, { -2, 0} };
   MV neighbors[4] = {{0, -1}, { -1, 0}, {1, 0}, {0, 1}};
   int i, j;
 
-  unsigned char *what = (*(b->base_src) + b->src);
+  uint8_t *what = (*(b->base_src) + b->src);
   int what_stride = b->src_stride;
   int in_what_stride = d->pre_stride;
   int br, bc;
   int_mv this_mv;
   unsigned int bestsad = 0x7fffffff;
   unsigned int thissad;
-  unsigned char *base_offset;
-  unsigned char *this_offset;
+  uint8_t *base_offset;
+  uint8_t *this_offset;
   int k = -1;
   int all_in;
   int best_site = -1;
 
   int_mv fcenter_mv;
   fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
   fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 
   // adjust ref_mv to make sure it is within MV range
   clamp_mv(ref_mv, x->mv_col_min, x->mv_col_max, x->mv_row_min, x->mv_row_max);
   br = ref_mv->as_mv.row;
   bc = ref_mv->as_mv.col;
 
   // Work out the start point for the search
-  base_offset = (unsigned char *)(*(d->base_pre) + d->pre);
+  base_offset = (uint8_t *)(*(d->base_pre) + d->pre);
   this_offset = base_offset + (br * (d->pre_stride)) + bc;
   this_mv.as_mv.row = br;
   this_mv.as_mv.col = bc;
   bestsad = vfp->sdf(what, what_stride, this_offset,
                      in_what_stride, 0x7fffffff)
             + mvsad_err_cost(&this_mv, &fcenter_mv, mvjsadcost, mvsadcost,
                              sad_per_bit);
 
   // hex search
   // j=0
@@ skipping 102 matching lines @@
 #undef CHECK_POINT
 #undef CHECK_BETTER
 
 int vp9_diamond_search_sad_c(MACROBLOCK *x, BLOCK *b, BLOCKD *d,
                              int_mv *ref_mv, int_mv *best_mv,
                              int search_param, int sad_per_bit, int *num00,
                              vp9_variance_fn_ptr_t *fn_ptr, int *mvjcost,
                              int *mvcost[2], int_mv *center_mv) {
   int i, j, step;
 
-  unsigned char *what = (*(b->base_src) + b->src);
+  uint8_t *what = (*(b->base_src) + b->src);
   int what_stride = b->src_stride;
-  unsigned char *in_what;
+  uint8_t *in_what;
   int in_what_stride = d->pre_stride;
-  unsigned char *best_address;
+  uint8_t *best_address;
 
   int tot_steps;
   int_mv this_mv;
 
   int bestsad = INT_MAX;
   int best_site = 0;
   int last_site = 0;
 
   int ref_row, ref_col;
   int this_row_offset, this_col_offset;
   search_site *ss;
 
-  unsigned char *check_here;
+  uint8_t *check_here;
   int thissad;
   MACROBLOCKD *xd = &x->e_mbd;
   int_mv fcenter_mv;
 
   int *mvjsadcost = x->nmvjointsadcost;
   int *mvsadcost[2] = {x->nmvsadcost[0], x->nmvsadcost[1]};
 
   fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
   fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 
   clamp_mv(ref_mv, x->mv_col_min, x->mv_col_max, x->mv_row_min, x->mv_row_max);
   ref_row = ref_mv->as_mv.row;
   ref_col = ref_mv->as_mv.col;
   *num00 = 0;
   best_mv->as_mv.row = ref_row;
   best_mv->as_mv.col = ref_col;
 
   // Work out the start point for the search
-  in_what = (unsigned char *)(*(d->base_pre) + d->pre + (ref_row * (d->pre_stride)) + ref_col);
+  in_what = (uint8_t *)(*(d->base_pre) + d->pre +
+                        (ref_row * (d->pre_stride)) + ref_col);
   best_address = in_what;
 
   // Check the starting position
   bestsad = fn_ptr->sdf(what, what_stride, in_what,
                         in_what_stride, 0x7fffffff)
             + mvsad_err_cost(best_mv, &fcenter_mv, mvjsadcost, mvsadcost,
                              sad_per_bit);
 
   // search_param determines the length of the initial step and hence the number of iterations
   // 0 = initial step (MAX_FIRST_STEP) pel : 1 = (MAX_FIRST_STEP/2) pel, 2 = (MAX_FIRST_STEP/4) pel... etc.
@@ skipping 53 matching lines @@
                   xd->allow_high_precision_mv);
 }
 
 int vp9_diamond_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d,
                              int_mv *ref_mv, int_mv *best_mv, int search_param,
                              int sad_per_bit, int *num00,
                              vp9_variance_fn_ptr_t *fn_ptr,
                              int *mvjcost, int *mvcost[2], int_mv *center_mv) {
   int i, j, step;
 
-  unsigned char *what = (*(b->base_src) + b->src);
+  uint8_t *what = (*(b->base_src) + b->src);
   int what_stride = b->src_stride;
-  unsigned char *in_what;
+  uint8_t *in_what;
   int in_what_stride = d->pre_stride;
-  unsigned char *best_address;
+  uint8_t *best_address;
 
   int tot_steps;
   int_mv this_mv;
 
   unsigned int bestsad = INT_MAX;
   int best_site = 0;
   int last_site = 0;
 
   int ref_row;
   int ref_col;
   int this_row_offset;
   int this_col_offset;
   search_site *ss;
 
-  unsigned char *check_here;
+  uint8_t *check_here;
   unsigned int thissad;
   MACROBLOCKD *xd = &x->e_mbd;
   int_mv fcenter_mv;
 
   int *mvjsadcost = x->nmvjointsadcost;
   int *mvsadcost[2] = {x->nmvsadcost[0], x->nmvsadcost[1]};
 
   fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
   fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 
   clamp_mv(ref_mv, x->mv_col_min, x->mv_col_max, x->mv_row_min, x->mv_row_max);
   ref_row = ref_mv->as_mv.row;
   ref_col = ref_mv->as_mv.col;
   *num00 = 0;
   best_mv->as_mv.row = ref_row;
   best_mv->as_mv.col = ref_col;
 
   // Work out the start point for the search
-  in_what = (unsigned char *)(*(d->base_pre) + d->pre + (ref_row * (d->pre_stride)) + ref_col);
+  in_what = (uint8_t *)(*(d->base_pre) + d->pre +
+                        (ref_row * (d->pre_stride)) + ref_col);
   best_address = in_what;
 
   // Check the starting position
   bestsad = fn_ptr->sdf(what, what_stride,
                         in_what, in_what_stride, 0x7fffffff)
             + mvsad_err_cost(best_mv, &fcenter_mv, mvjsadcost, mvsadcost,
                              sad_per_bit);
 
   // search_param determines the length of the initial step and hence the number of iterations
   // 0 = initial step (MAX_FIRST_STEP) pel : 1 = (MAX_FIRST_STEP/2) pel, 2 = (MAX_FIRST_STEP/4) pel... etc.
@@ skipping 147 matching lines @@
     }
   }
   return bestsme;
 }
 
 int vp9_full_search_sad_c(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv,
                           int sad_per_bit, int distance,
                           vp9_variance_fn_ptr_t *fn_ptr, int *mvjcost,
                           int *mvcost[2],
                           int_mv *center_mv) {
-  unsigned char *what = (*(b->base_src) + b->src);
+  uint8_t *what = (*(b->base_src) + b->src);
   int what_stride = b->src_stride;
-  unsigned char *in_what;
+  uint8_t *in_what;
   int in_what_stride = d->pre_stride;
   int mv_stride = d->pre_stride;
-  unsigned char *bestaddress;
+  uint8_t *bestaddress;
   int_mv *best_mv = &d->bmi.as_mv.first;
   int_mv this_mv;
   int bestsad = INT_MAX;
   int r, c;
 
-  unsigned char *check_here;
+  uint8_t *check_here;
   int thissad;
   MACROBLOCKD *xd = &x->e_mbd;
 
   int ref_row = ref_mv->as_mv.row;
   int ref_col = ref_mv->as_mv.col;
 
   int row_min = ref_row - distance;
   int row_max = ref_row + distance;
   int col_min = ref_col - distance;
   int col_max = ref_col + distance;
@@ skipping 63 matching lines @@
         mv_err_cost(&this_mv, center_mv, mvjcost, mvcost, x->errorperbit,
                     xd->allow_high_precision_mv);
   else
     return INT_MAX;
 }
 
 int vp9_full_search_sadx3(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv,
                           int sad_per_bit, int distance,
                           vp9_variance_fn_ptr_t *fn_ptr, int *mvjcost,
                           int *mvcost[2], int_mv *center_mv) {
-  unsigned char *what = (*(b->base_src) + b->src);
+  uint8_t *what = (*(b->base_src) + b->src);
   int what_stride = b->src_stride;
-  unsigned char *in_what;
+  uint8_t *in_what;
   int in_what_stride = d->pre_stride;
   int mv_stride = d->pre_stride;
-  unsigned char *bestaddress;
+  uint8_t *bestaddress;
   int_mv *best_mv = &d->bmi.as_mv.first;
   int_mv this_mv;
   unsigned int bestsad = INT_MAX;
   int r, c;
 
-  unsigned char *check_here;
+  uint8_t *check_here;
   unsigned int thissad;
   MACROBLOCKD *xd = &x->e_mbd;
 
   int ref_row = ref_mv->as_mv.row;
   int ref_col = ref_mv->as_mv.col;
 
   int row_min = ref_row - distance;
   int row_max = ref_row + distance;
   int col_min = ref_col - distance;
   int col_max = ref_col + distance;
@@ skipping 97 matching lines @@
                     xd->allow_high_precision_mv);
   else
     return INT_MAX;
 }
 
 int vp9_full_search_sadx8(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv,
                           int sad_per_bit, int distance,
                           vp9_variance_fn_ptr_t *fn_ptr,
                           int *mvjcost, int *mvcost[2],
                           int_mv *center_mv) {
-  unsigned char *what = (*(b->base_src) + b->src);
+  uint8_t *what = (*(b->base_src) + b->src);
   int what_stride = b->src_stride;
-  unsigned char *in_what;
+  uint8_t *in_what;
   int in_what_stride = d->pre_stride;
   int mv_stride = d->pre_stride;
-  unsigned char *bestaddress;
+  uint8_t *bestaddress;
   int_mv *best_mv = &d->bmi.as_mv.first;
   int_mv this_mv;
   unsigned int bestsad = INT_MAX;
   int r, c;
 
-  unsigned char *check_here;
+  uint8_t *check_here;
   unsigned int thissad;
   MACROBLOCKD *xd = &x->e_mbd;
 
   int ref_row = ref_mv->as_mv.row;
   int ref_col = ref_mv->as_mv.col;
 
   int row_min = ref_row - distance;
   int row_max = ref_row + distance;
   int col_min = ref_col - distance;
   int col_max = ref_col + distance;
 
-  DECLARE_ALIGNED_ARRAY(16, unsigned short, sad_array8, 8);
+  DECLARE_ALIGNED_ARRAY(16, uint16_t, sad_array8, 8);
   unsigned int sad_array[3];
   int_mv fcenter_mv;
 
   int *mvjsadcost = x->nmvjointsadcost;
   int *mvsadcost[2] = {x->nmvsadcost[0], x->nmvsadcost[1]};
 
   fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
   fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 
   // Work out the mid point for the search
@@ skipping 111 matching lines @@
                     xd->allow_high_precision_mv);
   else
     return INT_MAX;
 }
 int vp9_refining_search_sad_c(MACROBLOCK *x, BLOCK *b, BLOCKD *d,
                               int_mv *ref_mv, int error_per_bit,
                               int search_range, vp9_variance_fn_ptr_t *fn_ptr,
                               int *mvjcost, int *mvcost[2], int_mv *center_mv) {
   MV neighbors[4] = {{ -1, 0}, {0, -1}, {0, 1}, {1, 0}};
   int i, j;
-  short this_row_offset, this_col_offset;
+  int this_row_offset, this_col_offset;
 
   int what_stride = b->src_stride;
   int in_what_stride = d->pre_stride;
-  unsigned char *what = (*(b->base_src) + b->src);
-  unsigned char *best_address = (unsigned char *)(*(d->base_pre) + d->pre +
-                                                  (ref_mv->as_mv.row * (d->pre_stride)) + ref_mv->as_mv.col);
-  unsigned char *check_here;
+  uint8_t *what = (*(b->base_src) + b->src);
+  uint8_t *best_address = (uint8_t *)(*(d->base_pre) + d->pre +
+                                      (ref_mv->as_mv.row * (d->pre_stride)) +
+                                      ref_mv->as_mv.col);
+  uint8_t *check_here;
   unsigned int thissad;
   int_mv this_mv;
   unsigned int bestsad = INT_MAX;
   MACROBLOCKD *xd = &x->e_mbd;
   int_mv fcenter_mv;
 
   int *mvjsadcost = x->nmvjointsadcost;
   int *mvsadcost[2] = {x->nmvsadcost[0], x->nmvsadcost[1]};
 
   fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
@@ skipping 49 matching lines @@
   else
     return INT_MAX;
 }
 
 int vp9_refining_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d,
                               int_mv *ref_mv, int error_per_bit,
                               int search_range, vp9_variance_fn_ptr_t *fn_ptr,
                               int *mvjcost, int *mvcost[2], int_mv *center_mv) {
   MV neighbors[4] = {{ -1, 0}, {0, -1}, {0, 1}, {1, 0}};
   int i, j;
-  short this_row_offset, this_col_offset;
+  int this_row_offset, this_col_offset;
 
   int what_stride = b->src_stride;
   int in_what_stride = d->pre_stride;
-  unsigned char *what = (*(b->base_src) + b->src);
-  unsigned char *best_address = (unsigned char *)(*(d->base_pre) + d->pre +
-                                                  (ref_mv->as_mv.row * (d->pre_stride)) + ref_mv->as_mv.col);
-  unsigned char *check_here;
+  uint8_t *what = (*(b->base_src) + b->src);
+  uint8_t *best_address = (uint8_t *)(*(d->base_pre) + d->pre +
+                                      (ref_mv->as_mv.row * (d->pre_stride)) +
+                                      ref_mv->as_mv.col);
+  uint8_t *check_here;
   unsigned int thissad;
   int_mv this_mv;
   unsigned int bestsad = INT_MAX;
   MACROBLOCKD *xd = &x->e_mbd;
   int_mv fcenter_mv;
 
   int *mvjsadcost = x->nmvjointsadcost;
   int *mvsadcost[2] = {x->nmvsadcost[0], x->nmvsadcost[1]};
 
   fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
@@ skipping 89 matching lines @@
   int i, j;
 
   fprintf(f, "#include \"vp9_entropy.h\"\n");
   fprintf(f, "const int vp9_mode_contexts[6][4] =");
   fprintf(f, "{\n");
   for (j = 0; j < 6; j++) {
     fprintf(f, "  {/* %d */ ", j);
     fprintf(f, "    ");
     for (i = 0; i < 4; i++) {
       int this_prob;
-      int count;
 
       // context probs
-      count = mv_ref_ct[j][i][0] + mv_ref_ct[j][i][1];
-      if (count)
-        this_prob = 256 * mv_ref_ct[j][i][0] / count;
-      else
-        this_prob = 128;
+      this_prob = get_binary_prob(mv_ref_ct[j][i][0], mv_ref_ct[j][i][1]);
 
-      if (this_prob == 0)
-        this_prob = 1;
       fprintf(f, "%5d, ", this_prob);
     }
     fprintf(f, "  },\n");
   }
 
   fprintf(f, "};\n");
   fclose(f);
 }
 
 /* MV ref count ENTROPY_STATS stats code */
@@ skipping 30 matching lines @@
         } else {
           ++mv_ref_ct [ct[3]] [3] [1];
           ++mv_mode_cts[3][1];
         }
       }
     }
   }
 }
 
 #endif/* END MV ref count ENTROPY_STATS stats code */