libvpx: Pull from upstream

source/libvpx/vp9/common/x86/vp9_asm_stubs.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_ports/config.h"
+#include "./vpx_config.h"
 #include "vpx_ports/mem.h"
 #include "vp9/common/vp9_subpixel.h"
 
 extern const short vp9_six_tap_mmx[8][6 * 8];
 
-extern const short vp9_bilinear_filters_8x_mmx[8][2 * 8];
-
 extern void vp9_filter_block1d_h6_mmx(unsigned char   *src_ptr,
                                       unsigned short  *output_ptr,
                                       unsigned int     src_pixels_per_line,
                                       unsigned int     pixel_step,
                                       unsigned int     output_height,
                                       unsigned int     output_width,
                                       const short     *vp9_filter);
 
 extern void vp9_filter_block1dc_v6_mmx(unsigned short *src_ptr,
                                        unsigned char  *output_ptr,
@@ skipping 58 matching lines @@
                                               unsigned int   output_height,
                                               const short   *vp9_filter);
 
 extern void vp9_filter_block1d8_v6_only_sse2(unsigned char *src_ptr,
                                              unsigned int   src_pixels_per_line,
                                              unsigned char *output_ptr,
                                              int            dst_pitch,
                                              unsigned int   output_height,
                                              const short   *vp9_filter);
 
-extern prototype_subpixel_predict(vp9_bilinear_predict8x8_mmx);
-
 ///////////////////////////////////////////////////////////////////////////
 // the mmx function that does the bilinear filtering and var calculation //
 // int one pass                                                          //
 ///////////////////////////////////////////////////////////////////////////
 DECLARE_ALIGNED(16, const short, vp9_bilinear_filters_mmx[16][8]) = {
   { 128, 128, 128, 128,  0,  0,  0,  0 },
   { 120, 120, 120, 120,  8,  8,  8,  8 },
   { 112, 112, 112, 112, 16, 16, 16, 16 },
   { 104, 104, 104, 104, 24, 24, 24, 24 },
   {  96, 96, 96, 96, 32, 32, 32, 32 },
@@ skipping 115 matching lines @@
                             fdata2,   src_pixels_per_line, 1, 9, 16, hfilter);
   vp9_filter_block1d_h6_mmx(src_ptr - (2 * src_pixels_per_line) + 4,
                             fdata2 + 4, src_pixels_per_line, 1, 9, 16, hfilter);
 
   vfilter = vp9_six_tap_mmx[yoffset];
   vp9_filter_block1dc_v6_mmx(fdata2 + 16, dst_ptr,     dst_pitch,
                              16, 8, 4, 8, vfilter);
   vp9_filter_block1dc_v6_mmx(fdata2 + 20, dst_ptr + 4, dst_pitch,
                              16, 8, 4, 8, vfilter);
 }
-
-void vp9_bilinear_predict16x16_mmx(unsigned char  *src_ptr,
-                                   int  src_pixels_per_line,
-                                   int  xoffset,
-                                   int  yoffset,
-                                   unsigned char *dst_ptr,
-                                   int  dst_pitch) {
-  vp9_bilinear_predict8x8_mmx(src_ptr,
-                              src_pixels_per_line, xoffset, yoffset,
-                              dst_ptr, dst_pitch);
-  vp9_bilinear_predict8x8_mmx(src_ptr + 8,
-                              src_pixels_per_line, xoffset, yoffset,
-                              dst_ptr + 8, dst_pitch);
-  vp9_bilinear_predict8x8_mmx(src_ptr + 8 * src_pixels_per_line,
-                              src_pixels_per_line, xoffset, yoffset,
-                              dst_ptr + dst_pitch * 8, dst_pitch);
-  vp9_bilinear_predict8x8_mmx(src_ptr + 8 * src_pixels_per_line + 8,
-                              src_pixels_per_line, xoffset, yoffset,
-                              dst_ptr + dst_pitch * 8 + 8, dst_pitch);
-}
 #endif
 
 #if HAVE_SSE2
 void vp9_sixtap_predict16x16_sse2(unsigned char  *src_ptr,
                                   int  src_pixels_per_line,
                                   int  xoffset,
                                   int  yoffset,
                                   unsigned char *dst_ptr,
                                   int  dst_pitch) {
   /* Temp data bufffer used in filtering */
@@ skipping 351 matching lines @@
     if (hfilter_aligned16[3] != 128) {
       vp9_filter_block1d8_h8_ssse3(src_ptr, src_stride, dst_ptr, dst_stride, 4,
                                    hfilter_aligned16);
     } else {
       vp9_filter_block1d8_v8_ssse3(src_ptr - (3 * src_stride), src_stride,
                                    dst_ptr, dst_stride, 4, vfilter_aligned16);
     }
   }
 }
 #endif