granicus.if.org Git - libvpx/blob - vp9/encoder/vp9_resize.c

   1 /*
   2  *  Copyright (c) 2014 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include <assert.h>
  12 #include <limits.h>
  13 #include <math.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17
  18 #include "./vpx_config.h"
  19 #if CONFIG_VP9_HIGHBITDEPTH
  20 #include "vpx_dsp/vpx_dsp_common.h"
  21 #endif  // CONFIG_VP9_HIGHBITDEPTH
  22 #include "vpx_ports/mem.h"
  23 #include "vp9/common/vp9_common.h"
  24 #include "vp9/encoder/vp9_resize.h"
  25
  26 #define FILTER_BITS 7
  27
  28 #define INTERP_TAPS 8
  29 #define SUBPEL_BITS 5
  30 #define SUBPEL_MASK ((1 << SUBPEL_BITS) - 1)
  31 #define INTERP_PRECISION_BITS 32
  32
  33 typedef int16_t interp_kernel[INTERP_TAPS];
  34
  35 // Filters for interpolation (0.5-band) - note this also filters integer pels.
  36 static const interp_kernel filteredinterp_filters500[(1 << SUBPEL_BITS)] = {
  37   { -3, 0, 35, 64, 35, 0, -3, 0 },    { -3, -1, 34, 64, 36, 1, -3, 0 },
  38   { -3, -1, 32, 64, 38, 1, -3, 0 },   { -2, -2, 31, 63, 39, 2, -3, 0 },
  39   { -2, -2, 29, 63, 41, 2, -3, 0 },   { -2, -2, 28, 63, 42, 3, -4, 0 },
  40   { -2, -3, 27, 63, 43, 4, -4, 0 },   { -2, -3, 25, 62, 45, 5, -4, 0 },
  41   { -2, -3, 24, 62, 46, 5, -4, 0 },   { -2, -3, 23, 61, 47, 6, -4, 0 },
  42   { -2, -3, 21, 60, 49, 7, -4, 0 },   { -1, -4, 20, 60, 50, 8, -4, -1 },
  43   { -1, -4, 19, 59, 51, 9, -4, -1 },  { -1, -4, 17, 58, 52, 10, -4, 0 },
  44   { -1, -4, 16, 57, 53, 12, -4, -1 }, { -1, -4, 15, 56, 54, 13, -4, -1 },
  45   { -1, -4, 14, 55, 55, 14, -4, -1 }, { -1, -4, 13, 54, 56, 15, -4, -1 },
  46   { -1, -4, 12, 53, 57, 16, -4, -1 }, { 0, -4, 10, 52, 58, 17, -4, -1 },
  47   { -1, -4, 9, 51, 59, 19, -4, -1 },  { -1, -4, 8, 50, 60, 20, -4, -1 },
  48   { 0, -4, 7, 49, 60, 21, -3, -2 },   { 0, -4, 6, 47, 61, 23, -3, -2 },
  49   { 0, -4, 5, 46, 62, 24, -3, -2 },   { 0, -4, 5, 45, 62, 25, -3, -2 },
  50   { 0, -4, 4, 43, 63, 27, -3, -2 },   { 0, -4, 3, 42, 63, 28, -2, -2 },
  51   { 0, -3, 2, 41, 63, 29, -2, -2 },   { 0, -3, 2, 39, 63, 31, -2, -2 },
  52   { 0, -3, 1, 38, 64, 32, -1, -3 },   { 0, -3, 1, 36, 64, 34, -1, -3 }
  53 };
  54
  55 // Filters for interpolation (0.625-band) - note this also filters integer pels.
  56 static const interp_kernel filteredinterp_filters625[(1 << SUBPEL_BITS)] = {
  57   { -1, -8, 33, 80, 33, -8, -1, 0 }, { -1, -8, 30, 80, 35, -8, -1, 1 },
  58   { -1, -8, 28, 80, 37, -7, -2, 1 }, { 0, -8, 26, 79, 39, -7, -2, 1 },
  59   { 0, -8, 24, 79, 41, -7, -2, 1 },  { 0, -8, 22, 78, 43, -6, -2, 1 },
  60   { 0, -8, 20, 78, 45, -5, -3, 1 },  { 0, -8, 18, 77, 48, -5, -3, 1 },
  61   { 0, -8, 16, 76, 50, -4, -3, 1 },  { 0, -8, 15, 75, 52, -3, -4, 1 },
  62   { 0, -7, 13, 74, 54, -3, -4, 1 },  { 0, -7, 11, 73, 56, -2, -4, 1 },
  63   { 0, -7, 10, 71, 58, -1, -4, 1 },  { 1, -7, 8, 70, 60, 0, -5, 1 },
  64   { 1, -6, 6, 68, 62, 1, -5, 1 },    { 1, -6, 5, 67, 63, 2, -5, 1 },
  65   { 1, -6, 4, 65, 65, 4, -6, 1 },    { 1, -5, 2, 63, 67, 5, -6, 1 },
  66   { 1, -5, 1, 62, 68, 6, -6, 1 },    { 1, -5, 0, 60, 70, 8, -7, 1 },
  67   { 1, -4, -1, 58, 71, 10, -7, 0 },  { 1, -4, -2, 56, 73, 11, -7, 0 },
  68   { 1, -4, -3, 54, 74, 13, -7, 0 },  { 1, -4, -3, 52, 75, 15, -8, 0 },
  69   { 1, -3, -4, 50, 76, 16, -8, 0 },  { 1, -3, -5, 48, 77, 18, -8, 0 },
  70   { 1, -3, -5, 45, 78, 20, -8, 0 },  { 1, -2, -6, 43, 78, 22, -8, 0 },
  71   { 1, -2, -7, 41, 79, 24, -8, 0 },  { 1, -2, -7, 39, 79, 26, -8, 0 },
  72   { 1, -2, -7, 37, 80, 28, -8, -1 }, { 1, -1, -8, 35, 80, 30, -8, -1 },
  73 };
  74
  75 // Filters for interpolation (0.75-band) - note this also filters integer pels.
  76 static const interp_kernel filteredinterp_filters750[(1 << SUBPEL_BITS)] = {
  77   { 2, -11, 25, 96, 25, -11, 2, 0 }, { 2, -11, 22, 96, 28, -11, 2, 0 },
  78   { 2, -10, 19, 95, 31, -11, 2, 0 }, { 2, -10, 17, 95, 34, -12, 2, 0 },
  79   { 2, -9, 14, 94, 37, -12, 2, 0 },  { 2, -8, 12, 93, 40, -12, 1, 0 },
  80   { 2, -8, 9, 92, 43, -12, 1, 1 },   { 2, -7, 7, 91, 46, -12, 1, 0 },
  81   { 2, -7, 5, 90, 49, -12, 1, 0 },   { 2, -6, 3, 88, 52, -12, 0, 1 },
  82   { 2, -5, 1, 86, 55, -12, 0, 1 },   { 2, -5, -1, 84, 58, -11, 0, 1 },
  83   { 2, -4, -2, 82, 61, -11, -1, 1 }, { 2, -4, -4, 80, 64, -10, -1, 1 },
  84   { 1, -3, -5, 77, 67, -9, -1, 1 },  { 1, -3, -6, 75, 70, -8, -2, 1 },
  85   { 1, -2, -7, 72, 72, -7, -2, 1 },  { 1, -2, -8, 70, 75, -6, -3, 1 },
  86   { 1, -1, -9, 67, 77, -5, -3, 1 },  { 1, -1, -10, 64, 80, -4, -4, 2 },
  87   { 1, -1, -11, 61, 82, -2, -4, 2 }, { 1, 0, -11, 58, 84, -1, -5, 2 },
  88   { 1, 0, -12, 55, 86, 1, -5, 2 },   { 1, 0, -12, 52, 88, 3, -6, 2 },
  89   { 0, 1, -12, 49, 90, 5, -7, 2 },   { 0, 1, -12, 46, 91, 7, -7, 2 },
  90   { 1, 1, -12, 43, 92, 9, -8, 2 },   { 0, 1, -12, 40, 93, 12, -8, 2 },
  91   { 0, 2, -12, 37, 94, 14, -9, 2 },  { 0, 2, -12, 34, 95, 17, -10, 2 },
  92   { 0, 2, -11, 31, 95, 19, -10, 2 }, { 0, 2, -11, 28, 96, 22, -11, 2 }
  93 };
  94
  95 // Filters for interpolation (0.875-band) - note this also filters integer pels.
  96 static const interp_kernel filteredinterp_filters875[(1 << SUBPEL_BITS)] = {
  97   { 3, -8, 13, 112, 13, -8, 3, 0 },   { 3, -7, 10, 112, 17, -9, 3, -1 },
  98   { 2, -6, 7, 111, 21, -9, 3, -1 },   { 2, -5, 4, 111, 24, -10, 3, -1 },
  99   { 2, -4, 1, 110, 28, -11, 3, -1 },  { 1, -3, -1, 108, 32, -12, 4, -1 },
 100   { 1, -2, -3, 106, 36, -13, 4, -1 }, { 1, -1, -6, 105, 40, -14, 4, -1 },
 101   { 1, -1, -7, 102, 44, -14, 4, -1 }, { 1, 0, -9, 100, 48, -15, 4, -1 },
 102   { 1, 1, -11, 97, 53, -16, 4, -1 },  { 0, 1, -12, 95, 57, -16, 4, -1 },
 103   { 0, 2, -13, 91, 61, -16, 4, -1 },  { 0, 2, -14, 88, 65, -16, 4, -1 },
 104   { 0, 3, -15, 84, 69, -17, 4, 0 },   { 0, 3, -16, 81, 73, -16, 3, 0 },
 105   { 0, 3, -16, 77, 77, -16, 3, 0 },   { 0, 3, -16, 73, 81, -16, 3, 0 },
 106   { 0, 4, -17, 69, 84, -15, 3, 0 },   { -1, 4, -16, 65, 88, -14, 2, 0 },
 107   { -1, 4, -16, 61, 91, -13, 2, 0 },  { -1, 4, -16, 57, 95, -12, 1, 0 },
 108   { -1, 4, -16, 53, 97, -11, 1, 1 },  { -1, 4, -15, 48, 100, -9, 0, 1 },
 109   { -1, 4, -14, 44, 102, -7, -1, 1 }, { -1, 4, -14, 40, 105, -6, -1, 1 },
 110   { -1, 4, -13, 36, 106, -3, -2, 1 }, { -1, 4, -12, 32, 108, -1, -3, 1 },
 111   { -1, 3, -11, 28, 110, 1, -4, 2 },  { -1, 3, -10, 24, 111, 4, -5, 2 },
 112   { -1, 3, -9, 21, 111, 7, -6, 2 },   { -1, 3, -9, 17, 112, 10, -7, 3 }
 113 };
 114
 115 // Filters for interpolation (full-band) - no filtering for integer pixels
 116 static const interp_kernel filteredinterp_filters1000[(1 << SUBPEL_BITS)] = {
 117   { 0, 0, 0, 128, 0, 0, 0, 0 },        { 0, 1, -3, 128, 3, -1, 0, 0 },
 118   { -1, 2, -6, 127, 7, -2, 1, 0 },     { -1, 3, -9, 126, 12, -4, 1, 0 },
 119   { -1, 4, -12, 125, 16, -5, 1, 0 },   { -1, 4, -14, 123, 20, -6, 2, 0 },
 120   { -1, 5, -15, 120, 25, -8, 2, 0 },   { -1, 5, -17, 118, 30, -9, 3, -1 },
 121   { -1, 6, -18, 114, 35, -10, 3, -1 }, { -1, 6, -19, 111, 41, -12, 3, -1 },
 122   { -1, 6, -20, 107, 46, -13, 4, -1 }, { -1, 6, -21, 103, 52, -14, 4, -1 },
 123   { -1, 6, -21, 99, 57, -16, 5, -1 },  { -1, 6, -21, 94, 63, -17, 5, -1 },
 124   { -1, 6, -20, 89, 68, -18, 5, -1 },  { -1, 6, -20, 84, 73, -19, 6, -1 },
 125   { -1, 6, -20, 79, 79, -20, 6, -1 },  { -1, 6, -19, 73, 84, -20, 6, -1 },
 126   { -1, 5, -18, 68, 89, -20, 6, -1 },  { -1, 5, -17, 63, 94, -21, 6, -1 },
 127   { -1, 5, -16, 57, 99, -21, 6, -1 },  { -1, 4, -14, 52, 103, -21, 6, -1 },
 128   { -1, 4, -13, 46, 107, -20, 6, -1 }, { -1, 3, -12, 41, 111, -19, 6, -1 },
 129   { -1, 3, -10, 35, 114, -18, 6, -1 }, { -1, 3, -9, 30, 118, -17, 5, -1 },
 130   { 0, 2, -8, 25, 120, -15, 5, -1 },   { 0, 2, -6, 20, 123, -14, 4, -1 },
 131   { 0, 1, -5, 16, 125, -12, 4, -1 },   { 0, 1, -4, 12, 126, -9, 3, -1 },
 132   { 0, 1, -2, 7, 127, -6, 2, -1 },     { 0, 0, -1, 3, 128, -3, 1, 0 }
 133 };
 134
 135 // Filters for factor of 2 downsampling.
 136 static const int16_t vp9_down2_symeven_half_filter[] = { 56, 12, -3, -1 };
 137 static const int16_t vp9_down2_symodd_half_filter[] = { 64, 35, 0, -3 };
 138
 139 static const interp_kernel *choose_interp_filter(int inlength, int outlength) {
 140   int outlength16 = outlength * 16;
 141   if (outlength16 >= inlength * 16)
 142     return filteredinterp_filters1000;
 143   else if (outlength16 >= inlength * 13)
 144     return filteredinterp_filters875;
 145   else if (outlength16 >= inlength * 11)
 146     return filteredinterp_filters750;
 147   else if (outlength16 >= inlength * 9)
 148     return filteredinterp_filters625;
 149   else
 150     return filteredinterp_filters500;
 151 }
 152
 153 static void interpolate(const uint8_t *const input, int inlength,
 154                         uint8_t *output, int outlength) {
 155   const int64_t delta =
 156       (((uint64_t)inlength << 32) + outlength / 2) / outlength;
 157   const int64_t offset =
 158       inlength > outlength
 159           ? (((int64_t)(inlength - outlength) << 31) + outlength / 2) /
 160                 outlength
 161           : -(((int64_t)(outlength - inlength) << 31) + outlength / 2) /
 162                 outlength;
 163   uint8_t *optr = output;
 164   int x, x1, x2, sum, k, int_pel, sub_pel;
 165   int64_t y;
 166
 167   const interp_kernel *interp_filters =
 168       choose_interp_filter(inlength, outlength);
 169
 170   x = 0;
 171   y = offset;
 172   while ((y >> INTERP_PRECISION_BITS) < (INTERP_TAPS / 2 - 1)) {
 173     x++;
 174     y += delta;
 175   }
 176   x1 = x;
 177   x = outlength - 1;
 178   y = delta * x + offset;
 179   while ((y >> INTERP_PRECISION_BITS) + (int64_t)(INTERP_TAPS / 2) >=
 180          inlength) {
 181     x--;
 182     y -= delta;
 183   }
 184   x2 = x;
 185   if (x1 > x2) {
 186     for (x = 0, y = offset; x < outlength; ++x, y += delta) {
 187       const int16_t *filter;
 188       int_pel = y >> INTERP_PRECISION_BITS;
 189       sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
 190       filter = interp_filters[sub_pel];
 191       sum = 0;
 192       for (k = 0; k < INTERP_TAPS; ++k) {
 193         const int pk = int_pel - INTERP_TAPS / 2 + 1 + k;
 194         sum += filter[k] *
 195                input[(pk < 0 ? 0 : (pk >= inlength ? inlength - 1 : pk))];
 196       }
 197       *optr++ = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS));
 198     }
 199   } else {
 200     // Initial part.
 201     for (x = 0, y = offset; x < x1; ++x, y += delta) {
 202       const int16_t *filter;
 203       int_pel = y >> INTERP_PRECISION_BITS;
 204       sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
 205       filter = interp_filters[sub_pel];
 206       sum = 0;
 207       for (k = 0; k < INTERP_TAPS; ++k)
 208         sum += filter[k] * input[(int_pel - INTERP_TAPS / 2 + 1 + k < 0
 209                                       ? 0
 210                                       : int_pel - INTERP_TAPS / 2 + 1 + k)];
 211       *optr++ = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS));
 212     }
 213     // Middle part.
 214     for (; x <= x2; ++x, y += delta) {
 215       const int16_t *filter;
 216       int_pel = y >> INTERP_PRECISION_BITS;
 217       sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
 218       filter = interp_filters[sub_pel];
 219       sum = 0;
 220       for (k = 0; k < INTERP_TAPS; ++k)
 221         sum += filter[k] * input[int_pel - INTERP_TAPS / 2 + 1 + k];
 222       *optr++ = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS));
 223     }
 224     // End part.
 225     for (; x < outlength; ++x, y += delta) {
 226       const int16_t *filter;
 227       int_pel = y >> INTERP_PRECISION_BITS;
 228       sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
 229       filter = interp_filters[sub_pel];
 230       sum = 0;
 231       for (k = 0; k < INTERP_TAPS; ++k)
 232         sum += filter[k] * input[(int_pel - INTERP_TAPS / 2 + 1 + k >= inlength
 233                                       ? inlength - 1
 234                                       : int_pel - INTERP_TAPS / 2 + 1 + k)];
 235       *optr++ = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS));
 236     }
 237   }
 238 }
 239
 240 static void down2_symeven(const uint8_t *const input, int length,
 241                           uint8_t *output) {
 242   // Actual filter len = 2 * filter_len_half.
 243   const int16_t *filter = vp9_down2_symeven_half_filter;
 244   const int filter_len_half = sizeof(vp9_down2_symeven_half_filter) / 2;
 245   int i, j;
 246   uint8_t *optr = output;
 247   int l1 = filter_len_half;
 248   int l2 = (length - filter_len_half);
 249   l1 += (l1 & 1);
 250   l2 += (l2 & 1);
 251   if (l1 > l2) {
 252     // Short input length.
 253     for (i = 0; i < length; i += 2) {
 254       int sum = (1 << (FILTER_BITS - 1));
 255       for (j = 0; j < filter_len_half; ++j) {
 256         sum += (input[(i - j < 0 ? 0 : i - j)] +
 257                 input[(i + 1 + j >= length ? length - 1 : i + 1 + j)]) *
 258                filter[j];
 259       }
 260       sum >>= FILTER_BITS;
 261       *optr++ = clip_pixel(sum);
 262     }
 263   } else {
 264     // Initial part.
 265     for (i = 0; i < l1; i += 2) {
 266       int sum = (1 << (FILTER_BITS - 1));
 267       for (j = 0; j < filter_len_half; ++j) {
 268         sum += (input[(i - j < 0 ? 0 : i - j)] + input[i + 1 + j]) * filter[j];
 269       }
 270       sum >>= FILTER_BITS;
 271       *optr++ = clip_pixel(sum);
 272     }
 273     // Middle part.
 274     for (; i < l2; i += 2) {
 275       int sum = (1 << (FILTER_BITS - 1));
 276       for (j = 0; j < filter_len_half; ++j) {
 277         sum += (input[i - j] + input[i + 1 + j]) * filter[j];
 278       }
 279       sum >>= FILTER_BITS;
 280       *optr++ = clip_pixel(sum);
 281     }
 282     // End part.
 283     for (; i < length; i += 2) {
 284       int sum = (1 << (FILTER_BITS - 1));
 285       for (j = 0; j < filter_len_half; ++j) {
 286         sum += (input[i - j] +
 287                 input[(i + 1 + j >= length ? length - 1 : i + 1 + j)]) *
 288                filter[j];
 289       }
 290       sum >>= FILTER_BITS;
 291       *optr++ = clip_pixel(sum);
 292     }
 293   }
 294 }
 295
 296 static void down2_symodd(const uint8_t *const input, int length,
 297                          uint8_t *output) {
 298   // Actual filter len = 2 * filter_len_half - 1.
 299   const int16_t *filter = vp9_down2_symodd_half_filter;
 300   const int filter_len_half = sizeof(vp9_down2_symodd_half_filter) / 2;
 301   int i, j;
 302   uint8_t *optr = output;
 303   int l1 = filter_len_half - 1;
 304   int l2 = (length - filter_len_half + 1);
 305   l1 += (l1 & 1);
 306   l2 += (l2 & 1);
 307   if (l1 > l2) {
 308     // Short input length.
 309     for (i = 0; i < length; i += 2) {
 310       int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
 311       for (j = 1; j < filter_len_half; ++j) {
 312         sum += (input[(i - j < 0 ? 0 : i - j)] +
 313                 input[(i + j >= length ? length - 1 : i + j)]) *
 314                filter[j];
 315       }
 316       sum >>= FILTER_BITS;
 317       *optr++ = clip_pixel(sum);
 318     }
 319   } else {
 320     // Initial part.
 321     for (i = 0; i < l1; i += 2) {
 322       int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
 323       for (j = 1; j < filter_len_half; ++j) {
 324         sum += (input[(i - j < 0 ? 0 : i - j)] + input[i + j]) * filter[j];
 325       }
 326       sum >>= FILTER_BITS;
 327       *optr++ = clip_pixel(sum);
 328     }
 329     // Middle part.
 330     for (; i < l2; i += 2) {
 331       int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
 332       for (j = 1; j < filter_len_half; ++j) {
 333         sum += (input[i - j] + input[i + j]) * filter[j];
 334       }
 335       sum >>= FILTER_BITS;
 336       *optr++ = clip_pixel(sum);
 337     }
 338     // End part.
 339     for (; i < length; i += 2) {
 340       int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
 341       for (j = 1; j < filter_len_half; ++j) {
 342         sum += (input[i - j] + input[(i + j >= length ? length - 1 : i + j)]) *
 343                filter[j];
 344       }
 345       sum >>= FILTER_BITS;
 346       *optr++ = clip_pixel(sum);
 347     }
 348   }
 349 }
 350
 351 static int get_down2_length(int length, int steps) {
 352   int s;
 353   for (s = 0; s < steps; ++s) length = (length + 1) >> 1;
 354   return length;
 355 }
 356
 357 static int get_down2_steps(int in_length, int out_length) {
 358   int steps = 0;
 359   int proj_in_length;
 360   while ((proj_in_length = get_down2_length(in_length, 1)) >= out_length) {
 361     ++steps;
 362     in_length = proj_in_length;
 363   }
 364   return steps;
 365 }
 366
 367 static void resize_multistep(const uint8_t *const input, int length,
 368                              uint8_t *output, int olength, uint8_t *otmp) {
 369   int steps;
 370   if (length == olength) {
 371     memcpy(output, input, sizeof(output[0]) * length);
 372     return;
 373   }
 374   steps = get_down2_steps(length, olength);
 375
 376   if (steps > 0) {
 377     int s;
 378     uint8_t *out = NULL;
 379     uint8_t *otmp2;
 380     int filteredlength = length;
 381
 382     assert(otmp != NULL);
 383     otmp2 = otmp + get_down2_length(length, 1);
 384     for (s = 0; s < steps; ++s) {
 385       const int proj_filteredlength = get_down2_length(filteredlength, 1);
 386       const uint8_t *const in = (s == 0 ? input : out);
 387       if (s == steps - 1 && proj_filteredlength == olength)
 388         out = output;
 389       else
 390         out = (s & 1 ? otmp2 : otmp);
 391       if (filteredlength & 1)
 392         down2_symodd(in, filteredlength, out);
 393       else
 394         down2_symeven(in, filteredlength, out);
 395       filteredlength = proj_filteredlength;
 396     }
 397     if (filteredlength != olength) {
 398       interpolate(out, filteredlength, output, olength);
 399     }
 400   } else {
 401     interpolate(input, length, output, olength);
 402   }
 403 }
 404
 405 static void fill_col_to_arr(uint8_t *img, int stride, int len, uint8_t *arr) {
 406   int i;
 407   uint8_t *iptr = img;
 408   uint8_t *aptr = arr;
 409   for (i = 0; i < len; ++i, iptr += stride) {
 410     *aptr++ = *iptr;
 411   }
 412 }
 413
 414 static void fill_arr_to_col(uint8_t *img, int stride, int len, uint8_t *arr) {
 415   int i;
 416   uint8_t *iptr = img;
 417   uint8_t *aptr = arr;
 418   for (i = 0; i < len; ++i, iptr += stride) {
 419     *iptr = *aptr++;
 420   }
 421 }
 422
 423 void vp9_resize_plane(const uint8_t *const input, int height, int width,
 424                       int in_stride, uint8_t *output, int height2, int width2,
 425                       int out_stride) {
 426   int i;
 427   uint8_t *intbuf = (uint8_t *)malloc(sizeof(uint8_t) * width2 * height);
 428   uint8_t *tmpbuf =
 429       (uint8_t *)malloc(sizeof(uint8_t) * (width < height ? height : width));
 430   uint8_t *arrbuf = (uint8_t *)malloc(sizeof(uint8_t) * height);
 431   uint8_t *arrbuf2 = (uint8_t *)malloc(sizeof(uint8_t) * height2);
 432   if (intbuf == NULL || tmpbuf == NULL || arrbuf == NULL || arrbuf2 == NULL)
 433     goto Error;
 434   assert(width > 0);
 435   assert(height > 0);
 436   assert(width2 > 0);
 437   assert(height2 > 0);
 438   for (i = 0; i < height; ++i)
 439     resize_multistep(input + in_stride * i, width, intbuf + width2 * i, width2,
 440                      tmpbuf);
 441   for (i = 0; i < width2; ++i) {
 442     fill_col_to_arr(intbuf + i, width2, height, arrbuf);
 443     resize_multistep(arrbuf, height, arrbuf2, height2, tmpbuf);
 444     fill_arr_to_col(output + i, out_stride, height2, arrbuf2);
 445   }
 446
 447 Error:
 448   free(intbuf);
 449   free(tmpbuf);
 450   free(arrbuf);
 451   free(arrbuf2);
 452 }
 453
 454 #if CONFIG_VP9_HIGHBITDEPTH
 455 static void highbd_interpolate(const uint16_t *const input, int inlength,
 456                                uint16_t *output, int outlength, int bd) {
 457   const int64_t delta =
 458       (((uint64_t)inlength << 32) + outlength / 2) / outlength;
 459   const int64_t offset =
 460       inlength > outlength
 461           ? (((int64_t)(inlength - outlength) << 31) + outlength / 2) /
 462                 outlength
 463           : -(((int64_t)(outlength - inlength) << 31) + outlength / 2) /
 464                 outlength;
 465   uint16_t *optr = output;
 466   int x, x1, x2, sum, k, int_pel, sub_pel;
 467   int64_t y;
 468
 469   const interp_kernel *interp_filters =
 470       choose_interp_filter(inlength, outlength);
 471
 472   x = 0;
 473   y = offset;
 474   while ((y >> INTERP_PRECISION_BITS) < (INTERP_TAPS / 2 - 1)) {
 475     x++;
 476     y += delta;
 477   }
 478   x1 = x;
 479   x = outlength - 1;
 480   y = delta * x + offset;
 481   while ((y >> INTERP_PRECISION_BITS) + (int64_t)(INTERP_TAPS / 2) >=
 482          inlength) {
 483     x--;
 484     y -= delta;
 485   }
 486   x2 = x;
 487   if (x1 > x2) {
 488     for (x = 0, y = offset; x < outlength; ++x, y += delta) {
 489       const int16_t *filter;
 490       int_pel = y >> INTERP_PRECISION_BITS;
 491       sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
 492       filter = interp_filters[sub_pel];
 493       sum = 0;
 494       for (k = 0; k < INTERP_TAPS; ++k) {
 495         const int pk = int_pel - INTERP_TAPS / 2 + 1 + k;
 496         sum += filter[k] *
 497                input[(pk < 0 ? 0 : (pk >= inlength ? inlength - 1 : pk))];
 498       }
 499       *optr++ = clip_pixel_highbd(ROUND_POWER_OF_TWO(sum, FILTER_BITS), bd);
 500     }
 501   } else {
 502     // Initial part.
 503     for (x = 0, y = offset; x < x1; ++x, y += delta) {
 504       const int16_t *filter;
 505       int_pel = y >> INTERP_PRECISION_BITS;
 506       sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
 507       filter = interp_filters[sub_pel];
 508       sum = 0;
 509       for (k = 0; k < INTERP_TAPS; ++k)
 510         sum += filter[k] * input[(int_pel - INTERP_TAPS / 2 + 1 + k < 0
 511                                       ? 0
 512                                       : int_pel - INTERP_TAPS / 2 + 1 + k)];
 513       *optr++ = clip_pixel_highbd(ROUND_POWER_OF_TWO(sum, FILTER_BITS), bd);
 514     }
 515     // Middle part.
 516     for (; x <= x2; ++x, y += delta) {
 517       const int16_t *filter;
 518       int_pel = y >> INTERP_PRECISION_BITS;
 519       sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
 520       filter = interp_filters[sub_pel];
 521       sum = 0;
 522       for (k = 0; k < INTERP_TAPS; ++k)
 523         sum += filter[k] * input[int_pel - INTERP_TAPS / 2 + 1 + k];
 524       *optr++ = clip_pixel_highbd(ROUND_POWER_OF_TWO(sum, FILTER_BITS), bd);
 525     }
 526     // End part.
 527     for (; x < outlength; ++x, y += delta) {
 528       const int16_t *filter;
 529       int_pel = y >> INTERP_PRECISION_BITS;
 530       sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
 531       filter = interp_filters[sub_pel];
 532       sum = 0;
 533       for (k = 0; k < INTERP_TAPS; ++k)
 534         sum += filter[k] * input[(int_pel - INTERP_TAPS / 2 + 1 + k >= inlength
 535                                       ? inlength - 1
 536                                       : int_pel - INTERP_TAPS / 2 + 1 + k)];
 537       *optr++ = clip_pixel_highbd(ROUND_POWER_OF_TWO(sum, FILTER_BITS), bd);
 538     }
 539   }
 540 }
 541
 542 static void highbd_down2_symeven(const uint16_t *const input, int length,
 543                                  uint16_t *output, int bd) {
 544   // Actual filter len = 2 * filter_len_half.
 545   static const int16_t *filter = vp9_down2_symeven_half_filter;
 546   const int filter_len_half = sizeof(vp9_down2_symeven_half_filter) / 2;
 547   int i, j;
 548   uint16_t *optr = output;
 549   int l1 = filter_len_half;
 550   int l2 = (length - filter_len_half);
 551   l1 += (l1 & 1);
 552   l2 += (l2 & 1);
 553   if (l1 > l2) {
 554     // Short input length.
 555     for (i = 0; i < length; i += 2) {
 556       int sum = (1 << (FILTER_BITS - 1));
 557       for (j = 0; j < filter_len_half; ++j) {
 558         sum += (input[(i - j < 0 ? 0 : i - j)] +
 559                 input[(i + 1 + j >= length ? length - 1 : i + 1 + j)]) *
 560                filter[j];
 561       }
 562       sum >>= FILTER_BITS;
 563       *optr++ = clip_pixel_highbd(sum, bd);
 564     }
 565   } else {
 566     // Initial part.
 567     for (i = 0; i < l1; i += 2) {
 568       int sum = (1 << (FILTER_BITS - 1));
 569       for (j = 0; j < filter_len_half; ++j) {
 570         sum += (input[(i - j < 0 ? 0 : i - j)] + input[i + 1 + j]) * filter[j];
 571       }
 572       sum >>= FILTER_BITS;
 573       *optr++ = clip_pixel_highbd(sum, bd);
 574     }
 575     // Middle part.
 576     for (; i < l2; i += 2) {
 577       int sum = (1 << (FILTER_BITS - 1));
 578       for (j = 0; j < filter_len_half; ++j) {
 579         sum += (input[i - j] + input[i + 1 + j]) * filter[j];
 580       }
 581       sum >>= FILTER_BITS;
 582       *optr++ = clip_pixel_highbd(sum, bd);
 583     }
 584     // End part.
 585     for (; i < length; i += 2) {
 586       int sum = (1 << (FILTER_BITS - 1));
 587       for (j = 0; j < filter_len_half; ++j) {
 588         sum += (input[i - j] +
 589                 input[(i + 1 + j >= length ? length - 1 : i + 1 + j)]) *
 590                filter[j];
 591       }
 592       sum >>= FILTER_BITS;
 593       *optr++ = clip_pixel_highbd(sum, bd);
 594     }
 595   }
 596 }
 597
 598 static void highbd_down2_symodd(const uint16_t *const input, int length,
 599                                 uint16_t *output, int bd) {
 600   // Actual filter len = 2 * filter_len_half - 1.
 601   static const int16_t *filter = vp9_down2_symodd_half_filter;
 602   const int filter_len_half = sizeof(vp9_down2_symodd_half_filter) / 2;
 603   int i, j;
 604   uint16_t *optr = output;
 605   int l1 = filter_len_half - 1;
 606   int l2 = (length - filter_len_half + 1);
 607   l1 += (l1 & 1);
 608   l2 += (l2 & 1);
 609   if (l1 > l2) {
 610     // Short input length.
 611     for (i = 0; i < length; i += 2) {
 612       int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
 613       for (j = 1; j < filter_len_half; ++j) {
 614         sum += (input[(i - j < 0 ? 0 : i - j)] +
 615                 input[(i + j >= length ? length - 1 : i + j)]) *
 616                filter[j];
 617       }
 618       sum >>= FILTER_BITS;
 619       *optr++ = clip_pixel_highbd(sum, bd);
 620     }
 621   } else {
 622     // Initial part.
 623     for (i = 0; i < l1; i += 2) {
 624       int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
 625       for (j = 1; j < filter_len_half; ++j) {
 626         sum += (input[(i - j < 0 ? 0 : i - j)] + input[i + j]) * filter[j];
 627       }
 628       sum >>= FILTER_BITS;
 629       *optr++ = clip_pixel_highbd(sum, bd);
 630     }
 631     // Middle part.
 632     for (; i < l2; i += 2) {
 633       int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
 634       for (j = 1; j < filter_len_half; ++j) {
 635         sum += (input[i - j] + input[i + j]) * filter[j];
 636       }
 637       sum >>= FILTER_BITS;
 638       *optr++ = clip_pixel_highbd(sum, bd);
 639     }
 640     // End part.
 641     for (; i < length; i += 2) {
 642       int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
 643       for (j = 1; j < filter_len_half; ++j) {
 644         sum += (input[i - j] + input[(i + j >= length ? length - 1 : i + j)]) *
 645                filter[j];
 646       }
 647       sum >>= FILTER_BITS;
 648       *optr++ = clip_pixel_highbd(sum, bd);
 649     }
 650   }
 651 }
 652
 653 static void highbd_resize_multistep(const uint16_t *const input, int length,
 654                                     uint16_t *output, int olength,
 655                                     uint16_t *otmp, int bd) {
 656   int steps;
 657   if (length == olength) {
 658     memcpy(output, input, sizeof(output[0]) * length);
 659     return;
 660   }
 661   steps = get_down2_steps(length, olength);
 662
 663   if (steps > 0) {
 664     int s;
 665     uint16_t *out = NULL;
 666     uint16_t *otmp2;
 667     int filteredlength = length;
 668
 669     assert(otmp != NULL);
 670     otmp2 = otmp + get_down2_length(length, 1);
 671     for (s = 0; s < steps; ++s) {
 672       const int proj_filteredlength = get_down2_length(filteredlength, 1);
 673       const uint16_t *const in = (s == 0 ? input : out);
 674       if (s == steps - 1 && proj_filteredlength == olength)
 675         out = output;
 676       else
 677         out = (s & 1 ? otmp2 : otmp);
 678       if (filteredlength & 1)
 679         highbd_down2_symodd(in, filteredlength, out, bd);
 680       else
 681         highbd_down2_symeven(in, filteredlength, out, bd);
 682       filteredlength = proj_filteredlength;
 683     }
 684     if (filteredlength != olength) {
 685       highbd_interpolate(out, filteredlength, output, olength, bd);
 686     }
 687   } else {
 688     highbd_interpolate(input, length, output, olength, bd);
 689   }
 690 }
 691
 692 static void highbd_fill_col_to_arr(uint16_t *img, int stride, int len,
 693                                    uint16_t *arr) {
 694   int i;
 695   uint16_t *iptr = img;
 696   uint16_t *aptr = arr;
 697   for (i = 0; i < len; ++i, iptr += stride) {
 698     *aptr++ = *iptr;
 699   }
 700 }
 701
 702 static void highbd_fill_arr_to_col(uint16_t *img, int stride, int len,
 703                                    uint16_t *arr) {
 704   int i;
 705   uint16_t *iptr = img;
 706   uint16_t *aptr = arr;
 707   for (i = 0; i < len; ++i, iptr += stride) {
 708     *iptr = *aptr++;
 709   }
 710 }
 711
 712 void vp9_highbd_resize_plane(const uint8_t *const input, int height, int width,
 713                              int in_stride, uint8_t *output, int height2,
 714                              int width2, int out_stride, int bd) {
 715   int i;
 716   uint16_t *intbuf = (uint16_t *)malloc(sizeof(uint16_t) * width2 * height);
 717   uint16_t *tmpbuf =
 718       (uint16_t *)malloc(sizeof(uint16_t) * (width < height ? height : width));
 719   uint16_t *arrbuf = (uint16_t *)malloc(sizeof(uint16_t) * height);
 720   uint16_t *arrbuf2 = (uint16_t *)malloc(sizeof(uint16_t) * height2);
 721   if (intbuf == NULL || tmpbuf == NULL || arrbuf == NULL || arrbuf2 == NULL)
 722     goto Error;
 723   for (i = 0; i < height; ++i) {
 724     highbd_resize_multistep(CONVERT_TO_SHORTPTR(input + in_stride * i), width,
 725                             intbuf + width2 * i, width2, tmpbuf, bd);
 726   }
 727   for (i = 0; i < width2; ++i) {
 728     highbd_fill_col_to_arr(intbuf + i, width2, height, arrbuf);
 729     highbd_resize_multistep(arrbuf, height, arrbuf2, height2, tmpbuf, bd);
 730     highbd_fill_arr_to_col(CONVERT_TO_SHORTPTR(output + i), out_stride, height2,
 731                            arrbuf2);
 732   }
 733
 734 Error:
 735   free(intbuf);
 736   free(tmpbuf);
 737   free(arrbuf);
 738   free(arrbuf2);
 739 }
 740 #endif  // CONFIG_VP9_HIGHBITDEPTH
 741
 742 void vp9_resize_frame420(const uint8_t *const y, int y_stride,
 743                          const uint8_t *const u, const uint8_t *const v,
 744                          int uv_stride, int height, int width, uint8_t *oy,
 745                          int oy_stride, uint8_t *ou, uint8_t *ov,
 746                          int ouv_stride, int oheight, int owidth) {
 747   vp9_resize_plane(y, height, width, y_stride, oy, oheight, owidth, oy_stride);
 748   vp9_resize_plane(u, height / 2, width / 2, uv_stride, ou, oheight / 2,
 749                    owidth / 2, ouv_stride);
 750   vp9_resize_plane(v, height / 2, width / 2, uv_stride, ov, oheight / 2,
 751                    owidth / 2, ouv_stride);
 752 }
 753
 754 void vp9_resize_frame422(const uint8_t *const y, int y_stride,
 755                          const uint8_t *const u, const uint8_t *const v,
 756                          int uv_stride, int height, int width, uint8_t *oy,
 757                          int oy_stride, uint8_t *ou, uint8_t *ov,
 758                          int ouv_stride, int oheight, int owidth) {
 759   vp9_resize_plane(y, height, width, y_stride, oy, oheight, owidth, oy_stride);
 760   vp9_resize_plane(u, height, width / 2, uv_stride, ou, oheight, owidth / 2,
 761                    ouv_stride);
 762   vp9_resize_plane(v, height, width / 2, uv_stride, ov, oheight, owidth / 2,
 763                    ouv_stride);
 764 }
 765
 766 void vp9_resize_frame444(const uint8_t *const y, int y_stride,
 767                          const uint8_t *const u, const uint8_t *const v,
 768                          int uv_stride, int height, int width, uint8_t *oy,
 769                          int oy_stride, uint8_t *ou, uint8_t *ov,
 770                          int ouv_stride, int oheight, int owidth) {
 771   vp9_resize_plane(y, height, width, y_stride, oy, oheight, owidth, oy_stride);
 772   vp9_resize_plane(u, height, width, uv_stride, ou, oheight, owidth,
 773                    ouv_stride);
 774   vp9_resize_plane(v, height, width, uv_stride, ov, oheight, owidth,
 775                    ouv_stride);
 776 }
 777
 778 #if CONFIG_VP9_HIGHBITDEPTH
 779 void vp9_highbd_resize_frame420(const uint8_t *const y, int y_stride,
 780                                 const uint8_t *const u, const uint8_t *const v,
 781                                 int uv_stride, int height, int width,
 782                                 uint8_t *oy, int oy_stride, uint8_t *ou,
 783                                 uint8_t *ov, int ouv_stride, int oheight,
 784                                 int owidth, int bd) {
 785   vp9_highbd_resize_plane(y, height, width, y_stride, oy, oheight, owidth,
 786                           oy_stride, bd);
 787   vp9_highbd_resize_plane(u, height / 2, width / 2, uv_stride, ou, oheight / 2,
 788                           owidth / 2, ouv_stride, bd);
 789   vp9_highbd_resize_plane(v, height / 2, width / 2, uv_stride, ov, oheight / 2,
 790                           owidth / 2, ouv_stride, bd);
 791 }
 792
 793 void vp9_highbd_resize_frame422(const uint8_t *const y, int y_stride,
 794                                 const uint8_t *const u, const uint8_t *const v,
 795                                 int uv_stride, int height, int width,
 796                                 uint8_t *oy, int oy_stride, uint8_t *ou,
 797                                 uint8_t *ov, int ouv_stride, int oheight,
 798                                 int owidth, int bd) {
 799   vp9_highbd_resize_plane(y, height, width, y_stride, oy, oheight, owidth,
 800                           oy_stride, bd);
 801   vp9_highbd_resize_plane(u, height, width / 2, uv_stride, ou, oheight,
 802                           owidth / 2, ouv_stride, bd);
 803   vp9_highbd_resize_plane(v, height, width / 2, uv_stride, ov, oheight,
 804                           owidth / 2, ouv_stride, bd);
 805 }
 806
 807 void vp9_highbd_resize_frame444(const uint8_t *const y, int y_stride,
 808                                 const uint8_t *const u, const uint8_t *const v,
 809                                 int uv_stride, int height, int width,
 810                                 uint8_t *oy, int oy_stride, uint8_t *ou,
 811                                 uint8_t *ov, int ouv_stride, int oheight,
 812                                 int owidth, int bd) {
 813   vp9_highbd_resize_plane(y, height, width, y_stride, oy, oheight, owidth,
 814                           oy_stride, bd);
 815   vp9_highbd_resize_plane(u, height, width, uv_stride, ou, oheight, owidth,
 816                           ouv_stride, bd);
 817   vp9_highbd_resize_plane(v, height, width, uv_stride, ov, oheight, owidth,
 818                           ouv_stride, bd);
 819 }
 820 #endif  // CONFIG_VP9_HIGHBITDEPTH