libvpx: Pull from upstream

source/libvpx/vp9/encoder/vp9_resize.c

 /*
  *  Copyright (c) 2014 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.
  */
 
@@ skipping 11 matching lines @@
 #define FILTER_BITS               7
 
 #define INTERP_TAPS               8
 #define SUBPEL_BITS               5
 #define SUBPEL_MASK               ((1 << SUBPEL_BITS) - 1)
 #define INTERP_PRECISION_BITS     32
 
 typedef int16_t interp_kernel[INTERP_TAPS];
 
 // Filters for interpolation (0.5-band) - note this also filters integer pels.
-const interp_kernel vp9_filteredinterp_filters500[(1 << SUBPEL_BITS)] = {
+static const interp_kernel filteredinterp_filters500[(1 << SUBPEL_BITS)] = {
   {-3,  0, 35, 64, 35,  0, -3, 0},
   {-3, -1, 34, 64, 36,  1, -3, 0},
   {-3, -1, 32, 64, 38,  1, -3, 0},
   {-2, -2, 31, 63, 39,  2, -3, 0},
   {-2, -2, 29, 63, 41,  2, -3, 0},
   {-2, -2, 28, 63, 42,  3, -4, 0},
   {-2, -3, 27, 63, 43,  4, -4, 0},
   {-2, -3, 25, 62, 45,  5, -4, 0},
   {-2, -3, 24, 62, 46,  5, -4, 0},
   {-2, -3, 23, 61, 47,  6, -4, 0},
@@ skipping 15 matching lines @@
   {0, -4,  5, 45, 62, 25, -3, -2},
   {0, -4,  4, 43, 63, 27, -3, -2},
   {0, -4,  3, 42, 63, 28, -2, -2},
   {0, -3,  2, 41, 63, 29, -2, -2},
   {0, -3,  2, 39, 63, 31, -2, -2},
   {0, -3,  1, 38, 64, 32, -1, -3},
   {0, -3,  1, 36, 64, 34, -1, -3}
 };
 
 // Filters for interpolation (0.625-band) - note this also filters integer pels.
-const interp_kernel vp9_filteredinterp_filters625[(1 << SUBPEL_BITS)] = {
+static const interp_kernel filteredinterp_filters625[(1 << SUBPEL_BITS)] = {
   {-1, -8, 33, 80, 33, -8, -1, 0},
   {-1, -8, 30, 80, 35, -8, -1, 1},
   {-1, -8, 28, 80, 37, -7, -2, 1},
   {0, -8, 26, 79, 39, -7, -2, 1},
   {0, -8, 24, 79, 41, -7, -2, 1},
   {0, -8, 22, 78, 43, -6, -2, 1},
   {0, -8, 20, 78, 45, -5, -3, 1},
   {0, -8, 18, 77, 48, -5, -3, 1},
   {0, -8, 16, 76, 50, -4, -3, 1},
   {0, -8, 15, 75, 52, -3, -4, 1},
@@ skipping 15 matching lines @@
   {1, -3, -5, 48, 77, 18, -8, 0},
   {1, -3, -5, 45, 78, 20, -8, 0},
   {1, -2, -6, 43, 78, 22, -8, 0},
   {1, -2, -7, 41, 79, 24, -8, 0},
   {1, -2, -7, 39, 79, 26, -8, 0},
   {1, -2, -7, 37, 80, 28, -8, -1},
   {1, -1, -8, 35, 80, 30, -8, -1},
 };
 
 // Filters for interpolation (0.75-band) - note this also filters integer pels.
-const interp_kernel vp9_filteredinterp_filters750[(1 << SUBPEL_BITS)] = {
+static const interp_kernel filteredinterp_filters750[(1 << SUBPEL_BITS)] = {
   {2, -11,  25,  96,  25, -11,   2, 0},
   {2, -11,  22,  96,  28, -11,   2, 0},
   {2, -10,  19,  95,  31, -11,   2, 0},
   {2, -10,  17,  95,  34, -12,   2, 0},
   {2,  -9,  14,  94,  37, -12,   2, 0},
   {2,  -8,  12,  93,  40, -12,   1, 0},
   {2,  -8,   9,  92,  43, -12,   1, 1},
   {2,  -7,   7,  91,  46, -12,   1, 0},
   {2,  -7,   5,  90,  49, -12,   1, 0},
   {2,  -6,   3,  88,  52, -12,   0, 1},
@@ skipping 15 matching lines @@
   {0,   1, -12,  46,  91,   7,  -7, 2},
   {1,   1, -12,  43,  92,   9,  -8, 2},
   {0,   1, -12,  40,  93,  12,  -8, 2},
   {0,   2, -12,  37,  94,  14,  -9, 2},
   {0,   2, -12,  34,  95,  17, -10, 2},
   {0,   2, -11,  31,  95,  19, -10, 2},
   {0,   2, -11,  28,  96,  22, -11, 2}
 };
 
 // Filters for interpolation (0.875-band) - note this also filters integer pels.
-const interp_kernel vp9_filteredinterp_filters875[(1 << SUBPEL_BITS)] = {
+static const interp_kernel filteredinterp_filters875[(1 << SUBPEL_BITS)] = {
   {3,  -8,  13, 112,  13,  -8,   3, 0},
   {3,  -7,  10, 112,  17,  -9,   3, -1},
   {2,  -6,   7, 111,  21,  -9,   3, -1},
   {2,  -5,   4, 111,  24, -10,   3, -1},
   {2,  -4,   1, 110,  28, -11,   3, -1},
   {1,  -3,  -1, 108,  32, -12,   4, -1},
   {1,  -2,  -3, 106,  36, -13,   4, -1},
   {1,  -1,  -6, 105,  40, -14,   4, -1},
   {1,  -1,  -7, 102,  44, -14,   4, -1},
   {1,   0,  -9, 100,  48, -15,   4, -1},
@@ skipping 15 matching lines @@
   {-1,   4, -14,  40, 105,  -6,  -1, 1},
   {-1,   4, -13,  36, 106,  -3,  -2, 1},
   {-1,   4, -12,  32, 108,  -1,  -3, 1},
   {-1,   3, -11,  28, 110,   1,  -4, 2},
   {-1,   3, -10,  24, 111,   4,  -5, 2},
   {-1,   3,  -9,  21, 111,   7,  -6, 2},
   {-1,   3,  -9,  17, 112,  10,  -7, 3}
 };
 
 // Filters for interpolation (full-band) - no filtering for integer pixels
-const interp_kernel vp9_filteredinterp_filters1000[(1 << SUBPEL_BITS)] = {
+static const interp_kernel filteredinterp_filters1000[(1 << SUBPEL_BITS)] = {
   {0,   0,   0, 128,   0,   0,   0, 0},
   {0,   1,  -3, 128,   3,  -1,   0, 0},
   {-1,   2,  -6, 127,   7,  -2,   1, 0},
   {-1,   3,  -9, 126,  12,  -4,   1, 0},
   {-1,   4, -12, 125,  16,  -5,   1, 0},
   {-1,   4, -14, 123,  20,  -6,   2, 0},
   {-1,   5, -15, 120,  25,  -8,   2, 0},
   {-1,   5, -17, 118,  30,  -9,   3, -1},
   {-1,   6, -18, 114,  35, -10,   3, -1},
   {-1,   6, -19, 111,  41, -12,   3, -1},
@@ skipping 21 matching lines @@
   {0,   0,  -1,   3, 128,  -3,   1, 0}
 };
 
 // Filters for factor of 2 downsampling.
 static const int16_t vp9_down2_symeven_half_filter[] = {56, 12, -3, -1};
 static const int16_t vp9_down2_symodd_half_filter[] = {64, 35, 0, -3};
 
 static const interp_kernel *choose_interp_filter(int inlength, int outlength) {
   int outlength16 = outlength * 16;
   if (outlength16 >= inlength * 16)
-    return vp9_filteredinterp_filters1000;
+    return filteredinterp_filters1000;
   else if (outlength16 >= inlength * 13)
-    return vp9_filteredinterp_filters875;
+    return filteredinterp_filters875;
   else if (outlength16 >= inlength * 11)
-    return vp9_filteredinterp_filters750;
+    return filteredinterp_filters750;
   else if (outlength16 >= inlength * 9)
-    return vp9_filteredinterp_filters625;
+    return filteredinterp_filters625;
   else
-    return vp9_filteredinterp_filters500;
+    return filteredinterp_filters500;
 }
 
 static void interpolate(const uint8_t *const input, int inlength,
                         uint8_t *output, int outlength) {
   const int64_t delta = (((uint64_t)inlength << 32) + outlength / 2) /
       outlength;
   const int64_t offset = inlength > outlength ?
       (((int64_t)(inlength - outlength) << 31) + outlength / 2) / outlength :
       -(((int64_t)(outlength - inlength) << 31) + outlength / 2) / outlength;
   uint8_t *optr = output;
@@ skipping 679 matching lines @@
                                 uint8_t *ou, uint8_t *ov, int ouv_stride,
                                 int oheight, int owidth, int bd) {
   vp9_highbd_resize_plane(y, height, width, y_stride,
                           oy, oheight, owidth, oy_stride, bd);
   vp9_highbd_resize_plane(u, height, width, uv_stride,
                           ou, oheight, owidth, ouv_stride, bd);
   vp9_highbd_resize_plane(v, height, width, uv_stride,
                           ov, oheight, owidth, ouv_stride, bd);
 }
 #endif  // CONFIG_VP9_HIGHBITDEPTH