libvpx: Pull from upstream

source/libvpx/vp8/encoder/pickinter.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 <limits.h>
 #include "vpx_config.h"
+#include "./vpx_dsp_rtcd.h"
 #include "onyx_int.h"
 #include "modecosts.h"
 #include "encodeintra.h"
 #include "vp8/common/common.h"
 #include "vp8/common/entropymode.h"
 #include "pickinter.h"
 #include "vp8/common/findnearmv.h"
 #include "encodemb.h"
 #include "vp8/common/reconinter.h"
 #include "vp8/common/reconintra4x4.h"
 #include "vp8/common/variance.h"
 #include "mcomp.h"
 #include "rdopt.h"
 #include "vpx_mem/vpx_mem.h"
 #if CONFIG_TEMPORAL_DENOISING
 #include "denoising.h"
 #endif
 
-extern int VP8_UVSSE(MACROBLOCK *x);
-
 #ifdef SPEEDSTATS
 extern unsigned int cnt_pm;
 #endif
 
 extern const int vp8_ref_frame_order[MAX_MODES];
 extern const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES];
 
-extern int vp8_cost_mv_ref(MB_PREDICTION_MODE m, const int near_mv_ref_ct[4]);
-
 // Fixed point implementation of a skin color classifier. Skin color
 // is model by a Gaussian distribution in the CbCr color space.
 // See ../../test/skin_color_detector_test.cc where the reference
 // skin color classifier is defined.
 
 // Fixed-point skin color model parameters.
 static const int skin_mean[2] = {7463, 9614};                 // q6
 static const int skin_inv_cov[4] = {4107, 1663, 1663, 2157};  // q16
 static const int skin_threshold = 1570636;                    // q18
 
@@ skipping 159 matching lines @@
     {
         return vfp->svf(in_what, in_what_stride, xoffset, yoffset, what, what_stride, sse);
     }
     else
     {
         return vfp->vf(what, what_stride, in_what, in_what_stride, sse);
     }
 
 }
 
-
-unsigned int vp8_get4x4sse_cs_c
-(
-    const unsigned char *src_ptr,
-    int  source_stride,
-    const unsigned char *ref_ptr,
-    int  recon_stride
-)
-{
-    int distortion = 0;
-    int r, c;
-
-    for (r = 0; r < 4; r++)
-    {
-        for (c = 0; c < 4; c++)
-        {
-            int diff = src_ptr[c] - ref_ptr[c];
-            distortion += diff * diff;
-        }
-
-        src_ptr += source_stride;
-        ref_ptr += recon_stride;
-    }
-
-    return distortion;
-}
-
 static int get_prediction_error(BLOCK *be, BLOCKD *b)
 {
     unsigned char *sptr;
     unsigned char *dptr;
     sptr = (*(be->base_src) + be->src);
     dptr = b->predictor;
 
-    return vp8_get4x4sse_cs(sptr, be->src_stride, dptr, 16);
+    return vpx_get4x4sse_cs(sptr, be->src_stride, dptr, 16);
 
 }
 
 static int pick_intra4x4block(
     MACROBLOCK *x,
     int ib,
     B_PREDICTION_MODE *best_mode,
     const int *mode_costs,
 
     int *bestrate,
@@ skipping 767 matching lines @@
             distortion2 = best_rd_sse;
             pick_intra4x4mby_modes(x, &rate, &distortion2);
 
             if (distortion2 == INT_MAX)
             {
                 this_rd = INT_MAX;
             }
             else
             {
                 rate2 += rate;
-                distortion2 = vp8_variance16x16(
+                distortion2 = vpx_variance16x16(
                                     *(b->base_src), b->src_stride,
                                     x->e_mbd.predictor, 16, &sse);
                 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2);
 
                 if (this_rd < best_intra_rd)
                 {
                     best_intra_rd = this_rd;
                     *returnintra = distortion2;
                 }
             }
 
             break;
 
         case SPLITMV:
 
             /* Split MV modes currently not supported when RD is not enabled. */
             break;
 
         case DC_PRED:
         case V_PRED:
         case H_PRED:
         case TM_PRED:
             vp8_build_intra_predictors_mby_s(xd,
                                              xd->dst.y_buffer - xd->dst.y_stride,
                                              xd->dst.y_buffer - 1,
                                              xd->dst.y_stride,
                                              xd->predictor,
                                              16);
-            distortion2 = vp8_variance16x16
+            distortion2 = vpx_variance16x16
                                           (*(b->base_src), b->src_stride,
                                           x->e_mbd.predictor, 16, &sse);
             rate2 += x->mbmode_cost[x->e_mbd.frame_type][x->e_mbd.mode_info_context->mbmi.mode];
             this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2);
 
             if (this_rd < best_intra_rd)
             {
                 best_intra_rd = this_rd;
                 *returnintra = distortion2;
             }
@@ skipping 460 matching lines @@
 
     for (mode = DC_PRED; mode <= TM_PRED; mode ++)
     {
         xd->mode_info_context->mbmi.mode = mode;
         vp8_build_intra_predictors_mby_s(xd,
                                          xd->dst.y_buffer - xd->dst.y_stride,
                                          xd->dst.y_buffer - 1,
                                          xd->dst.y_stride,
                                          xd->predictor,
                                          16);
-        distortion = vp8_variance16x16
+        distortion = vpx_variance16x16
             (*(b->base_src), b->src_stride, xd->predictor, 16, &sse);
         rate = x->mbmode_cost[xd->frame_type][mode];
         this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
 
         if (error16x16 > this_rd)
         {
             error16x16 = this_rd;
             best_mode = mode;
             best_sse = sse;
             best_rate = rate;
         }
     }
     xd->mode_info_context->mbmi.mode = best_mode;
 
     error4x4 = pick_intra4x4mby_modes(x, &rate,
                                       &best_sse);
     if (error4x4 < error16x16)
     {
         xd->mode_info_context->mbmi.mode = B_PRED;
         best_rate = rate;
     }
 
     *rate_ = best_rate;
 }