libvpx: Pull from upstream

source/libvpx/vp8/encoder/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 "./vp8_rtcd.h"
+#include "./vpx_dsp_rtcd.h"
 #include "onyx_int.h"
 #include "mcomp.h"
 #include "vpx_mem/vpx_mem.h"
 #include "vpx_config.h"
 #include <stdio.h>
 #include <limits.h>
 #include <math.h>
 #include "vp8/common/findnearmv.h"
 #include "vp8/common/common.h"
 
@@ skipping 871 matching lines @@
     /* adjust ref_mv to make sure it is within MV range */
     vp8_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 *)(base_pre + d->offset);
     this_offset = base_offset + (br * (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, UINT_MAX)
+    bestsad = vfp->sdf(what, what_stride, this_offset, in_what_stride)
             + mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, sad_per_bit);
 
 #if CONFIG_MULTI_RES_ENCODING
     /* Lower search range based on prediction info */
     if (search_param >= 6) goto cal_neighbors;
     else if (search_param >= 5) hex_range = 4;
     else if (search_param >= 4) hex_range = 6;
     else if (search_param >= 3) hex_range = 15;
     else if (search_param >= 2) hex_range = 31;
     else if (search_param >= 1) hex_range = 63;
 
     dia_range = 8;
 #else
     (void)search_param;
 #endif
 
     /* hex search */
     CHECK_BOUNDS(2)
 
     if(all_in)
     {
         for (i = 0; i < 6; i++)
         {
             this_mv.as_mv.row = br + hex[i].row;
             this_mv.as_mv.col = bc + hex[i].col;
             this_offset = base_offset + (this_mv.as_mv.row * in_what_stride) + this_mv.as_mv.col;
-            thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride, bestsad);
+            thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride);
             CHECK_BETTER
         }
     }else
     {
         for (i = 0; i < 6; i++)
         {
             this_mv.as_mv.row = br + hex[i].row;
             this_mv.as_mv.col = bc + hex[i].col;
             CHECK_POINT
             this_offset = base_offset + (this_mv.as_mv.row * in_what_stride) + this_mv.as_mv.col;
-            thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride, bestsad);
+            thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride);
             CHECK_BETTER
         }
     }
 
     if (best_site == -1)
         goto cal_neighbors;
     else
     {
         br += hex[best_site].row;
         bc += hex[best_site].col;
         k = best_site;
     }
 
     for (j = 1; j < hex_range; j++)
     {
         best_site = -1;
         CHECK_BOUNDS(2)
 
         if(all_in)
         {
             for (i = 0; i < 3; i++)
             {
                 this_mv.as_mv.row = br + next_chkpts[k][i].row;
                 this_mv.as_mv.col = bc + next_chkpts[k][i].col;
                 this_offset = base_offset + (this_mv.as_mv.row * (in_what_stride)) + this_mv.as_mv.col;
-                thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride, bestsad);
+                thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride);
                 CHECK_BETTER
             }
         }else
         {
             for (i = 0; i < 3; i++)
             {
                 this_mv.as_mv.row = br + next_chkpts[k][i].row;
                 this_mv.as_mv.col = bc + next_chkpts[k][i].col;
                 CHECK_POINT
                 this_offset = base_offset + (this_mv.as_mv.row * (in_what_stride)) + this_mv.as_mv.col;
-                thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride, bestsad);
+                thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride);
                 CHECK_BETTER
             }
         }
 
         if (best_site == -1)
             break;
         else
         {
             br += next_chkpts[k][best_site].row;
             bc += next_chkpts[k][best_site].col;
@@ skipping 10 matching lines @@
         best_site = -1;
         CHECK_BOUNDS(1)
 
         if(all_in)
         {
             for (i = 0; i < 4; i++)
             {
                 this_mv.as_mv.row = br + neighbors[i].row;
                 this_mv.as_mv.col = bc + neighbors[i].col;
                 this_offset = base_offset + (this_mv.as_mv.row * (in_what_stride)) + this_mv.as_mv.col;
-                thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride, bestsad);
+                thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride);
                 CHECK_BETTER
             }
         }else
         {
             for (i = 0; i < 4; i++)
             {
                 this_mv.as_mv.row = br + neighbors[i].row;
                 this_mv.as_mv.col = bc + neighbors[i].col;
                 CHECK_POINT
                 this_offset = base_offset + (this_mv.as_mv.row * (in_what_stride)) + this_mv.as_mv.col;
-                thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride, bestsad);
+                thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride);
                 CHECK_BETTER
             }
         }
 
         if (best_site == -1)
             break;
         else
         {
             br += neighbors[best_site].row;
             bc += neighbors[best_site].col;
@@ skipping 63 matching lines @@
     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 *)(base_pre + d->offset + (ref_row * pre_stride) + ref_col);
     best_address = in_what;
 
     /* Check the starting position */
-    bestsad = fn_ptr->sdf(what, what_stride, in_what, in_what_stride, UINT_MAX)
+    bestsad = fn_ptr->sdf(what, what_stride, in_what, in_what_stride)
             + mvsad_err_cost(best_mv, &fcenter_mv, 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.
      */
     ss = &x->ss[search_param * x->searches_per_step];
     tot_steps = (x->ss_count / x->searches_per_step) - search_param;
 
     i = 1;
 
     for (step = 0; step < tot_steps ; step++)
     {
         for (j = 0 ; j < x->searches_per_step ; j++)
         {
             /* Trap illegal vectors */
             this_row_offset = best_mv->as_mv.row + ss[i].mv.row;
             this_col_offset = best_mv->as_mv.col + ss[i].mv.col;
 
             if ((this_col_offset > x->mv_col_min) && (this_col_offset < x->mv_col_max) &&
             (this_row_offset > x->mv_row_min) && (this_row_offset < x->mv_row_max))
 
             {
                 check_here = ss[i].offset + best_address;
-                thissad = fn_ptr->sdf(what, what_stride, check_here, in_what_stride, bestsad);
+                thissad = fn_ptr->sdf(what, what_stride, check_here, in_what_stride);
 
                 if (thissad < bestsad)
                 {
                     this_mv.as_mv.row = this_row_offset;
                     this_mv.as_mv.col = this_col_offset;
                     thissad += mvsad_err_cost(&this_mv, &fcenter_mv,
                                               mvsadcost, sad_per_bit);
 
                     if (thissad < bestsad)
                     {
@@ skipping 78 matching lines @@
     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 *)(base_pre + d->offset + (ref_row * pre_stride) + ref_col);
     best_address = in_what;
 
     /* Check the starting position */
-    bestsad = fn_ptr->sdf(what, what_stride, in_what, in_what_stride, UINT_MAX)
+    bestsad = fn_ptr->sdf(what, what_stride, in_what, in_what_stride)
             + mvsad_err_cost(best_mv, &fcenter_mv, 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.
      */
     ss = &x->ss[search_param * x->searches_per_step];
     tot_steps = (x->ss_count / x->searches_per_step) - search_param;
 
     i = 1;
@@ skipping 47 matching lines @@
             for (j = 0 ; j < x->searches_per_step ; j++)
             {
                 /* Trap illegal vectors */
                 this_row_offset = best_mv->as_mv.row + ss[i].mv.row;
                 this_col_offset = best_mv->as_mv.col + ss[i].mv.col;
 
                 if ((this_col_offset > x->mv_col_min) && (this_col_offset < x->mv_col_max) &&
                 (this_row_offset > x->mv_row_min) && (this_row_offset < x->mv_row_max))
                 {
                     check_here = ss[i].offset + best_address;
-                    thissad = fn_ptr->sdf(what, what_stride, check_here, in_what_stride, bestsad);
+                    thissad = fn_ptr->sdf(what, what_stride, check_here, in_what_stride);
 
                     if (thissad < bestsad)
                     {
                         this_mv.as_mv.row = this_row_offset;
                         this_mv.as_mv.col = this_col_offset;
                         thissad += mvsad_err_cost(&this_mv, &fcenter_mv,
                                                   mvsadcost, sad_per_bit);
 
                         if (thissad < bestsad)
                         {
@@ skipping 62 matching lines @@
     fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 
     /* Work out the mid point for the search */
     in_what = base_pre + d->offset;
     bestaddress = in_what + (ref_row * pre_stride) + ref_col;
 
     best_mv->as_mv.row = ref_row;
     best_mv->as_mv.col = ref_col;
 
     /* Baseline value at the centre */
-    bestsad = fn_ptr->sdf(what, what_stride, bestaddress,
-                          in_what_stride, UINT_MAX)
+    bestsad = fn_ptr->sdf(what, what_stride, bestaddress, in_what_stride)
             + mvsad_err_cost(best_mv, &fcenter_mv, mvsadcost, sad_per_bit);
 
     /* Apply further limits to prevent us looking using vectors that
      * stretch beyiond the UMV border
      */
     if (col_min < x->mv_col_min)
         col_min = x->mv_col_min;
 
     if (col_max > x->mv_col_max)
         col_max = x->mv_col_max;
 
     if (row_min < x->mv_row_min)
         row_min = x->mv_row_min;
 
     if (row_max > x->mv_row_max)
         row_max = x->mv_row_max;
 
     for (r = row_min; r < row_max ; r++)
     {
         this_mv.as_mv.row = r;
         check_here = r * mv_stride + in_what + col_min;
 
         for (c = col_min; c < col_max; c++)
         {
-            thissad = fn_ptr->sdf(what, what_stride, check_here, in_what_stride, bestsad);
+            thissad = fn_ptr->sdf(what, what_stride, check_here, in_what_stride);
 
             this_mv.as_mv.col = c;
             thissad += mvsad_err_cost(&this_mv, &fcenter_mv,
                                       mvsadcost, sad_per_bit);
 
             if (thissad < bestsad)
             {
                 bestsad = thissad;
                 best_mv->as_mv.row = r;
                 best_mv->as_mv.col = c;
@@ skipping 51 matching lines @@
     fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 
     /* Work out the mid point for the search */
     in_what = base_pre + d->offset;
     bestaddress = in_what + (ref_row * pre_stride) + ref_col;
 
     best_mv->as_mv.row = ref_row;
     best_mv->as_mv.col = ref_col;
 
     /* Baseline value at the centre */
-    bestsad = fn_ptr->sdf(what, what_stride, bestaddress,
-                          in_what_stride, UINT_MAX)
+    bestsad = fn_ptr->sdf(what, what_stride, bestaddress, in_what_stride)
             + mvsad_err_cost(best_mv, &fcenter_mv, mvsadcost, sad_per_bit);
 
     /* Apply further limits to prevent us looking using vectors that stretch
      * beyond the UMV border
      */
     if (col_min < x->mv_col_min)
         col_min = x->mv_col_min;
 
     if (col_max > x->mv_col_max)
         col_max = x->mv_col_max;
@@ skipping 35 matching lines @@
                     }
                 }
 
                 check_here++;
                 c++;
             }
         }
 
         while (c < col_max)
         {
-            thissad = fn_ptr->sdf(what, what_stride, check_here, in_what_stride, bestsad);
+            thissad = fn_ptr->sdf(what, what_stride, check_here, in_what_stride);
 
             if (thissad < bestsad)
             {
                 this_mv.as_mv.col = c;
                 thissad += mvsad_err_cost(&this_mv, &fcenter_mv,
                                           mvsadcost, sad_per_bit);
 
                 if (thissad < bestsad)
                 {
                     bestsad = thissad;
@@ skipping 38 matching lines @@
     unsigned char *check_here;
 
     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);
+    // TODO(johannkoenig): check if this alignment is necessary.
+    DECLARE_ALIGNED(16, unsigned int, sad_array8[8]);
     unsigned int sad_array[3];
 
     int *mvsadcost[2];
     int_mv fcenter_mv;
 
     mvsadcost[0] = x->mvsadcost[0];
     mvsadcost[1] = x->mvsadcost[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 */
     in_what = base_pre + d->offset;
     bestaddress = in_what + (ref_row * pre_stride) + ref_col;
 
     best_mv->as_mv.row = ref_row;
     best_mv->as_mv.col = ref_col;
 
     /* Baseline value at the centre */
-    bestsad = fn_ptr->sdf(what, what_stride,
-                          bestaddress, in_what_stride, UINT_MAX)
+    bestsad = fn_ptr->sdf(what, what_stride, bestaddress, in_what_stride)
             + mvsad_err_cost(best_mv, &fcenter_mv, mvsadcost, sad_per_bit);
 
     /* Apply further limits to prevent us looking using vectors that stretch
      * beyond the UMV border
      */
     if (col_min < x->mv_col_min)
         col_min = x->mv_col_min;
 
     if (col_max > x->mv_col_max)
         col_max = x->mv_col_max;
@@ skipping 65 matching lines @@
                     }
                 }
 
                 check_here++;
                 c++;
             }
         }
 
         while (c < col_max)
         {
-            thissad = fn_ptr->sdf(what, what_stride, check_here , in_what_stride, bestsad);
+            thissad = fn_ptr->sdf(what, what_stride, check_here , in_what_stride);
 
             if (thissad < bestsad)
             {
                 this_mv.as_mv.col = c;
                 thissad  += mvsad_err_cost(&this_mv, &fcenter_mv,
                     mvsadcost, sad_per_bit);
 
                 if (thissad < bestsad)
                 {
                     bestsad = thissad;
@@ skipping 37 matching lines @@
     unsigned int thissad;
 
     int *mvsadcost[2];
     int_mv fcenter_mv;
 
     mvsadcost[0] = x->mvsadcost[0];
     mvsadcost[1] = x->mvsadcost[1];
     fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
     fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 
-    bestsad = fn_ptr->sdf(what, what_stride, best_address,
-                          in_what_stride, UINT_MAX)
+    bestsad = fn_ptr->sdf(what, what_stride, best_address, in_what_stride)
             + mvsad_err_cost(ref_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
     for (i=0; i<search_range; i++)
     {
         int best_site = -1;
 
         for (j = 0 ; j < 4 ; j++)
         {
             this_row_offset = ref_mv->as_mv.row + neighbors[j].row;
             this_col_offset = ref_mv->as_mv.col + neighbors[j].col;
 
             if ((this_col_offset > x->mv_col_min) && (this_col_offset < x->mv_col_max) &&
             (this_row_offset > x->mv_row_min) && (this_row_offset < x->mv_row_max))
             {
                 check_here = (neighbors[j].row)*in_what_stride + neighbors[j].col + best_address;
-                thissad = fn_ptr->sdf(what, what_stride, check_here , in_what_stride, bestsad);
+                thissad = fn_ptr->sdf(what, what_stride, check_here , in_what_stride);
 
                 if (thissad < bestsad)
                 {
                     this_mv.as_mv.row = this_row_offset;
                     this_mv.as_mv.col = this_col_offset;
                     thissad += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
                     if (thissad < bestsad)
                     {
                         bestsad = thissad;
@@ skipping 42 matching lines @@
     unsigned int thissad;
 
     int *mvsadcost[2];
     int_mv fcenter_mv;
 
     mvsadcost[0] = x->mvsadcost[0];
     mvsadcost[1] = x->mvsadcost[1];
     fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
     fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 
-    bestsad = fn_ptr->sdf(what, what_stride, best_address,
-                          in_what_stride, UINT_MAX)
+    bestsad = fn_ptr->sdf(what, what_stride, best_address, in_what_stride)
             + mvsad_err_cost(ref_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
     for (i=0; i<search_range; i++)
     {
         int best_site = -1;
         int all_in = 1;
 
         all_in &= ((ref_mv->as_mv.row - 1) > x->mv_row_min);
         all_in &= ((ref_mv->as_mv.row + 1) < x->mv_row_max);
         all_in &= ((ref_mv->as_mv.col - 1) > x->mv_col_min);
@@ skipping 30 matching lines @@
         {
             for (j = 0 ; j < 4 ; j++)
             {
                 this_row_offset = ref_mv->as_mv.row + neighbors[j].row;
                 this_col_offset = ref_mv->as_mv.col + neighbors[j].col;
 
                 if ((this_col_offset > x->mv_col_min) && (this_col_offset < x->mv_col_max) &&
                 (this_row_offset > x->mv_row_min) && (this_row_offset < x->mv_row_max))
                 {
                     check_here = (neighbors[j].row)*in_what_stride + neighbors[j].col + best_address;
-                    thissad = fn_ptr->sdf(what, what_stride, check_here , in_what_stride, bestsad);
+                    thissad = fn_ptr->sdf(what, what_stride, check_here , in_what_stride);
 
                     if (thissad < bestsad)
                     {
                         this_mv.as_mv.row = this_row_offset;
                         this_mv.as_mv.col = this_col_offset;
                         thissad += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
                         if (thissad < bestsad)
                         {
                             bestsad = thissad;
@@ skipping 71 matching lines @@
     }
 
     fprintf(f, "};\n");
     fclose(f);
 }
 
 /* MV ref count VP8_ENTROPY_STATS stats code */
 #ifdef VP8_ENTROPY_STATS
 void init_mv_ref_counts()
 {
-    vpx_memset(mv_ref_ct, 0, sizeof(mv_ref_ct));
-    vpx_memset(mv_mode_cts, 0, sizeof(mv_mode_cts));
+    memset(mv_ref_ct, 0, sizeof(mv_ref_ct));
+    memset(mv_mode_cts, 0, sizeof(mv_mode_cts));
 }
 
 void accum_mv_refs(MB_PREDICTION_MODE m, const int ct[4])
 {
     if (m == ZEROMV)
     {
         ++mv_ref_ct [ct[0]] [0] [0];
         ++mv_mode_cts[0][0];
     }
     else
@@ skipping 32 matching lines @@
                     ++mv_mode_cts[3][1];
                 }
             }
         }
     }
 }
 
 #endif/* END MV ref count VP8_ENTROPY_STATS stats code */
 
 #endif