convolve.c 64.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
/*
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
 *
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
 */

12
#include <assert.h>
Angie Chiang's avatar
Angie Chiang committed
13
#include <string.h>
14

15
#include "./aom_dsp_rtcd.h"
Yaowu Xu's avatar
Yaowu Xu committed
16
#include "./av1_rtcd.h"
17
#include "av1/common/blockd.h"
18
#include "av1/common/convolve.h"
19
#include "av1/common/filter.h"
Angie Chiang's avatar
Angie Chiang committed
20
#include "av1/common/onyxc_int.h"
Yaowu Xu's avatar
Yaowu Xu committed
21
#include "aom_dsp/aom_dsp_common.h"
22
#include "aom_ports/mem.h"
23

24 25
#define MAX_BLOCK_WIDTH (MAX_SB_SIZE)
#define MAX_BLOCK_HEIGHT (MAX_SB_SIZE)
26 27
#define MAX_STEP (32)

Yaowu Xu's avatar
Yaowu Xu committed
28 29 30
void av1_convolve_horiz_c(const uint8_t *src, int src_stride, uint8_t *dst,
                          int dst_stride, int w, int h,
                          const InterpFilterParams filter_params,
31 32
                          const int subpel_x_q4, int x_step_q4,
                          ConvolveParams *conv_params) {
33
  int x, y;
34
  int filter_size = filter_params.taps;
Angie Chiang's avatar
Angie Chiang committed
35
  assert(conv_params->round == CONVOLVE_OPT_ROUND);
36 37 38 39 40
  src -= filter_size / 2 - 1;
  for (y = 0; y < h; ++y) {
    int x_q4 = subpel_x_q4;
    for (x = 0; x < w; ++x) {
      const uint8_t *const src_x = &src[x_q4 >> SUBPEL_BITS];
Yaowu Xu's avatar
Yaowu Xu committed
41
      const int16_t *x_filter = av1_get_interp_filter_subpel_kernel(
clang-format's avatar
clang-format committed
42
          filter_params, x_q4 & SUBPEL_MASK);
43 44
      int k, sum = 0;
      for (k = 0; k < filter_size; ++k) sum += src_x[k] * x_filter[k];
45

Angie Chiang's avatar
Angie Chiang committed
46
      sum = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS));
47
      if (conv_params->do_average)
Angie Chiang's avatar
Angie Chiang committed
48 49 50
        dst[x] = ROUND_POWER_OF_TWO(dst[x] + sum, 1);
      else
        dst[x] = sum;
51

52 53 54 55 56 57 58
      x_q4 += x_step_q4;
    }
    src += src_stride;
    dst += dst_stride;
  }
}

Fergus Simpson's avatar
Fergus Simpson committed
59 60 61 62 63 64 65
void av1_convolve_horiz_scale(const uint8_t *src, int src_stride, uint8_t *dst,
                              int dst_stride, int w, int h,
                              const InterpFilterParams filter_params,
                              const int subpel_x_qn, int x_step_qn,
                              ConvolveParams *conv_params) {
  int x, y;
  int filter_size = filter_params.taps;
66
  assert(conv_params->round == CONVOLVE_OPT_ROUND);
Fergus Simpson's avatar
Fergus Simpson committed
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
  src -= filter_size / 2 - 1;
  for (y = 0; y < h; ++y) {
    int x_qn = subpel_x_qn;
    for (x = 0; x < w; ++x) {
      const uint8_t *const src_x = &src[x_qn >> SCALE_SUBPEL_BITS];
      const int x_filter_idx = (x_qn & SCALE_SUBPEL_MASK) >> SCALE_EXTRA_BITS;
      assert(x_filter_idx < SUBPEL_SHIFTS);
      const int16_t *x_filter =
          av1_get_interp_filter_subpel_kernel(filter_params, x_filter_idx);
      int k, sum = 0;
      for (k = 0; k < filter_size; ++k) sum += src_x[k] * x_filter[k];

      sum = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS));
      if (conv_params->do_average)
        dst[x] = ROUND_POWER_OF_TWO(dst[x] + sum, 1);
      else
        dst[x] = sum;

      x_qn += x_step_qn;
    }
    src += src_stride;
    dst += dst_stride;
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
92 93 94
void av1_convolve_vert_c(const uint8_t *src, int src_stride, uint8_t *dst,
                         int dst_stride, int w, int h,
                         const InterpFilterParams filter_params,
95 96
                         const int subpel_y_q4, int y_step_q4,
                         ConvolveParams *conv_params) {
97
  int x, y;
98
  int filter_size = filter_params.taps;
Angie Chiang's avatar
Angie Chiang committed
99
  assert(conv_params->round == CONVOLVE_OPT_ROUND);
100 101 102 103 104
  src -= src_stride * (filter_size / 2 - 1);
  for (x = 0; x < w; ++x) {
    int y_q4 = subpel_y_q4;
    for (y = 0; y < h; ++y) {
      const uint8_t *const src_y = &src[(y_q4 >> SUBPEL_BITS) * src_stride];
Yaowu Xu's avatar
Yaowu Xu committed
105
      const int16_t *y_filter = av1_get_interp_filter_subpel_kernel(
clang-format's avatar
clang-format committed
106
          filter_params, y_q4 & SUBPEL_MASK);
107 108 109
      int k, sum = 0;
      for (k = 0; k < filter_size; ++k)
        sum += src_y[k * src_stride] * y_filter[k];
110

Angie Chiang's avatar
Angie Chiang committed
111
      sum = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS));
112
      if (conv_params->do_average)
Angie Chiang's avatar
Angie Chiang committed
113 114 115
        dst[y * dst_stride] = ROUND_POWER_OF_TWO(dst[y * dst_stride] + sum, 1);
      else
        dst[y * dst_stride] = sum;
116

117 118 119 120 121 122 123
      y_q4 += y_step_q4;
    }
    ++src;
    ++dst;
  }
}

Fergus Simpson's avatar
Fergus Simpson committed
124 125 126 127 128 129 130
void av1_convolve_vert_scale(const uint8_t *src, int src_stride, uint8_t *dst,
                             int dst_stride, int w, int h,
                             const InterpFilterParams filter_params,
                             const int subpel_y_qn, int y_step_qn,
                             ConvolveParams *conv_params) {
  int x, y;
  int filter_size = filter_params.taps;
131
  assert(conv_params->round == CONVOLVE_OPT_ROUND);
Fergus Simpson's avatar
Fergus Simpson committed
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
  src -= src_stride * (filter_size / 2 - 1);
  for (x = 0; x < w; ++x) {
    int y_qn = subpel_y_qn;
    for (y = 0; y < h; ++y) {
      const uint8_t *const src_y =
          &src[(y_qn >> SCALE_SUBPEL_BITS) * src_stride];
      const int y_filter_idx = (y_qn & SCALE_SUBPEL_MASK) >> SCALE_EXTRA_BITS;
      assert(y_filter_idx < SUBPEL_SHIFTS);
      const int16_t *y_filter =
          av1_get_interp_filter_subpel_kernel(filter_params, y_filter_idx);
      int k, sum = 0;
      for (k = 0; k < filter_size; ++k)
        sum += src_y[k * src_stride] * y_filter[k];

      sum = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS));
      if (conv_params->do_average)
        dst[y * dst_stride] = ROUND_POWER_OF_TWO(dst[y * dst_stride] + sum, 1);
      else
        dst[y * dst_stride] = sum;

      y_qn += y_step_qn;
    }
    ++src;
    ++dst;
  }
}

Angie Chiang's avatar
Angie Chiang committed
159
static void convolve_copy(const uint8_t *src, int src_stride, uint8_t *dst,
160 161
                          int dst_stride, int w, int h,
                          ConvolveParams *conv_params) {
Angie Chiang's avatar
Angie Chiang committed
162
  assert(conv_params->round == CONVOLVE_OPT_ROUND);
163
  if (conv_params->do_average == 0) {
Angie Chiang's avatar
Angie Chiang committed
164
    int r;
Angie Chiang's avatar
Angie Chiang committed
165
    for (r = 0; r < h; ++r) {
Angie Chiang's avatar
Angie Chiang committed
166
      memcpy(dst, src, w);
Angie Chiang's avatar
Angie Chiang committed
167 168 169 170 171 172
      src += src_stride;
      dst += dst_stride;
    }
  } else {
    int r, c;
    for (r = 0; r < h; ++r) {
173
      for (c = 0; c < w; ++c) {
Angie Chiang's avatar
Angie Chiang committed
174
        dst[c] = clip_pixel(ROUND_POWER_OF_TWO(dst[c] + src[c], 1));
175
      }
Angie Chiang's avatar
Angie Chiang committed
176 177 178 179 180 181
      src += src_stride;
      dst += dst_stride;
    }
  }
}

182 183 184
void av1_convolve_horiz_facade(const uint8_t *src, int src_stride, uint8_t *dst,
                               int dst_stride, int w, int h,
                               const InterpFilterParams filter_params,
185 186
                               const int subpel_x_q4, int x_step_q4,
                               ConvolveParams *conv_params) {
Angie Chiang's avatar
Angie Chiang committed
187 188
  assert(conv_params->round == CONVOLVE_OPT_ROUND);
  if (filter_params.taps == SUBPEL_TAPS) {
189 190
    const int16_t *filter_x =
        av1_get_interp_filter_subpel_kernel(filter_params, subpel_x_q4);
191
    if (conv_params->do_average == 0)
192 193 194 195 196 197
      aom_convolve8_horiz(src, src_stride, dst, dst_stride, filter_x, x_step_q4,
                          NULL, -1, w, h);
    else
      aom_convolve8_avg_horiz(src, src_stride, dst, dst_stride, filter_x,
                              x_step_q4, NULL, -1, w, h);
  } else {
Angie Chiang's avatar
Angie Chiang committed
198 199
    av1_convolve_horiz(src, src_stride, dst, dst_stride, w, h, filter_params,
                       subpel_x_q4, x_step_q4, conv_params);
200 201 202
  }
}

203 204 205 206 207 208 209 210 211
void av1_convolve_horiz_facade_c(const uint8_t *src, int src_stride,
                                 uint8_t *dst, int dst_stride, int w, int h,
                                 const InterpFilterParams filter_params,
                                 const int subpel_x_q4, int x_step_q4,
                                 ConvolveParams *conv_params) {
  assert(conv_params->round == CONVOLVE_OPT_ROUND);
  if (filter_params.taps == SUBPEL_TAPS) {
    const int16_t *filter_x =
        av1_get_interp_filter_subpel_kernel(filter_params, subpel_x_q4);
212
    if (conv_params->do_average == 0)
213 214 215 216 217 218 219 220 221 222 223
      aom_convolve8_horiz_c(src, src_stride, dst, dst_stride, filter_x,
                            x_step_q4, NULL, -1, w, h);
    else
      aom_convolve8_avg_horiz_c(src, src_stride, dst, dst_stride, filter_x,
                                x_step_q4, NULL, -1, w, h);
  } else {
    av1_convolve_horiz_c(src, src_stride, dst, dst_stride, w, h, filter_params,
                         subpel_x_q4, x_step_q4, conv_params);
  }
}

Fergus Simpson's avatar
Fergus Simpson committed
224 225 226 227 228
void av1_convolve_horiz_facade_scale(const uint8_t *src, int src_stride,
                                     uint8_t *dst, int dst_stride, int w, int h,
                                     const InterpFilterParams filter_params,
                                     const int subpel_x_qn, int x_step_qn,
                                     ConvolveParams *conv_params) {
229
  assert(conv_params->round == CONVOLVE_OPT_ROUND);
Fergus Simpson's avatar
Fergus Simpson committed
230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
  if (filter_params.taps == SUBPEL_TAPS) {
    const int16_t *filter_x = av1_get_interp_filter_subpel_kernel(
        filter_params, subpel_x_qn >> SCALE_EXTRA_BITS);
    if (conv_params->do_average == 0)
      aom_convolve8_horiz_scale(src, src_stride, dst, dst_stride, filter_x,
                                subpel_x_qn, x_step_qn, NULL, 0, -1, w, h);
    else
      aom_convolve8_avg_horiz_scale(src, src_stride, dst, dst_stride, filter_x,
                                    subpel_x_qn, x_step_qn, NULL, 0, -1, w, h);
  } else {
    av1_convolve_horiz_scale(src, src_stride, dst, dst_stride, w, h,
                             filter_params, subpel_x_qn, x_step_qn,
                             conv_params);
  }
}

246 247 248
void av1_convolve_vert_facade(const uint8_t *src, int src_stride, uint8_t *dst,
                              int dst_stride, int w, int h,
                              const InterpFilterParams filter_params,
249 250
                              const int subpel_y_q4, int y_step_q4,
                              ConvolveParams *conv_params) {
Angie Chiang's avatar
Angie Chiang committed
251 252
  assert(conv_params->round == CONVOLVE_OPT_ROUND);
  if (filter_params.taps == SUBPEL_TAPS) {
253 254
    const int16_t *filter_y =
        av1_get_interp_filter_subpel_kernel(filter_params, subpel_y_q4);
255
    if (conv_params->do_average == 0) {
256 257 258 259 260 261 262
      aom_convolve8_vert(src, src_stride, dst, dst_stride, NULL, -1, filter_y,
                         y_step_q4, w, h);
    } else {
      aom_convolve8_avg_vert(src, src_stride, dst, dst_stride, NULL, -1,
                             filter_y, y_step_q4, w, h);
    }
  } else {
Angie Chiang's avatar
Angie Chiang committed
263 264
    av1_convolve_vert(src, src_stride, dst, dst_stride, w, h, filter_params,
                      subpel_y_q4, y_step_q4, conv_params);
265 266 267
  }
}

268 269 270 271 272 273 274 275 276
void av1_convolve_vert_facade_c(const uint8_t *src, int src_stride,
                                uint8_t *dst, int dst_stride, int w, int h,
                                const InterpFilterParams filter_params,
                                const int subpel_y_q4, int y_step_q4,
                                ConvolveParams *conv_params) {
  assert(conv_params->round == CONVOLVE_OPT_ROUND);
  if (filter_params.taps == SUBPEL_TAPS) {
    const int16_t *filter_y =
        av1_get_interp_filter_subpel_kernel(filter_params, subpel_y_q4);
277
    if (conv_params->do_average == 0) {
278 279 280 281 282 283 284 285 286 287 288 289
      aom_convolve8_vert_c(src, src_stride, dst, dst_stride, NULL, -1, filter_y,
                           y_step_q4, w, h);
    } else {
      aom_convolve8_avg_vert_c(src, src_stride, dst, dst_stride, NULL, -1,
                               filter_y, y_step_q4, w, h);
    }
  } else {
    av1_convolve_vert_c(src, src_stride, dst, dst_stride, w, h, filter_params,
                        subpel_y_q4, y_step_q4, conv_params);
  }
}

Fergus Simpson's avatar
Fergus Simpson committed
290 291 292 293 294
void av1_convolve_vert_facade_scale(const uint8_t *src, int src_stride,
                                    uint8_t *dst, int dst_stride, int w, int h,
                                    const InterpFilterParams filter_params,
                                    const int subpel_y_qn, int y_step_qn,
                                    ConvolveParams *conv_params) {
295
  assert(conv_params->round == CONVOLVE_OPT_ROUND);
Fergus Simpson's avatar
Fergus Simpson committed
296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
  if (filter_params.taps == SUBPEL_TAPS) {
    const int16_t *filter_y = av1_get_interp_filter_subpel_kernel(
        filter_params, subpel_y_qn >> SCALE_EXTRA_BITS);
    if (conv_params->do_average == 0) {
      aom_convolve8_vert_scale(src, src_stride, dst, dst_stride, NULL, 0, -1,
                               filter_y, subpel_y_qn, y_step_qn, w, h);
    } else {
      aom_convolve8_avg_vert_scale(src, src_stride, dst, dst_stride, NULL, 0,
                                   -1, filter_y, subpel_y_qn, y_step_qn, w, h);
    }
  } else {
    av1_convolve_vert_scale(src, src_stride, dst, dst_stride, w, h,
                            filter_params, subpel_y_qn, y_step_qn, conv_params);
  }
}

Angie Chiang's avatar
Angie Chiang committed
312
#if CONFIG_CONVOLVE_ROUND
313 314
void av1_convolve_rounding_c(const int32_t *src, int src_stride, uint8_t *dst,
                             int dst_stride, int w, int h, int bits) {
Angie Chiang's avatar
Angie Chiang committed
315 316 317 318
  int r, c;
  for (r = 0; r < h; ++r) {
    for (c = 0; c < w; ++c) {
      dst[r * dst_stride + c] =
319
          clip_pixel(ROUND_POWER_OF_TWO(src[r * src_stride + c], bits));
Angie Chiang's avatar
Angie Chiang committed
320 321 322
    }
  }
}
Angie Chiang's avatar
Angie Chiang committed
323

324
#if CONFIG_COMPOUND_ROUND
David Barker's avatar
David Barker committed
325 326 327 328 329 330
void av1_convolve_2d_c(const uint8_t *src, int src_stride, CONV_BUF_TYPE *dst,
                       int dst_stride, int w, int h,
                       InterpFilterParams *filter_params_x,
                       InterpFilterParams *filter_params_y,
                       const int subpel_x_q4, const int subpel_y_q4,
                       ConvolveParams *conv_params) {
Angie Chiang's avatar
Angie Chiang committed
331
  int x, y, k;
332
  uint8_t im_block[(MAX_SB_SIZE + MAX_FILTER_TAP - 1) * MAX_SB_SIZE];
Angie Chiang's avatar
Angie Chiang committed
333 334 335 336
  int im_h = h + filter_params_y->taps - 1;
  int im_stride = w;
  const int fo_vert = filter_params_y->taps / 2 - 1;
  const int fo_horiz = filter_params_x->taps / 2 - 1;
337

Angie Chiang's avatar
Angie Chiang committed
338 339 340 341 342 343
  // horizontal filter
  const uint8_t *src_horiz = src - fo_vert * src_stride;
  const int16_t *x_filter = av1_get_interp_filter_subpel_kernel(
      *filter_params_x, subpel_x_q4 & SUBPEL_MASK);
  for (y = 0; y < im_h; ++y) {
    for (x = 0; x < w; ++x) {
344
      int32_t sum = 0;
Angie Chiang's avatar
Angie Chiang committed
345 346 347
      for (k = 0; k < filter_params_x->taps; ++k) {
        sum += x_filter[k] * src_horiz[y * src_stride + x - fo_horiz + k];
      }
Angie Chiang's avatar
Angie Chiang committed
348
      im_block[y * im_stride + x] =
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
          clip_pixel(ROUND_POWER_OF_TWO(sum, conv_params->round_0));
    }
  }

  // vertical filter
  uint8_t *src_vert = im_block + fo_vert * im_stride;
  const int16_t *y_filter = av1_get_interp_filter_subpel_kernel(
      *filter_params_y, subpel_y_q4 & SUBPEL_MASK);
  for (y = 0; y < h; ++y) {
    for (x = 0; x < w; ++x) {
      CONV_BUF_TYPE sum = 0;
      for (k = 0; k < filter_params_y->taps; ++k) {
        sum += y_filter[k] * src_vert[(y - fo_vert + k) * im_stride + x];
      }
      CONV_BUF_TYPE res = ROUND_POWER_OF_TWO(sum, conv_params->round_1);
364 365 366 367
      if (conv_params->do_average)
        dst[y * dst_stride + x] += res;
      else
        dst[y * dst_stride + x] = res;
368 369 370
    }
  }
}
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421

void av1_convolve_2d_scale_c(const uint8_t *src, int src_stride,
                             CONV_BUF_TYPE *dst, int dst_stride, int w, int h,
                             InterpFilterParams *filter_params_x,
                             InterpFilterParams *filter_params_y,
                             const int subpel_x_qn, const int x_step_qn,
                             const int subpel_y_qn, const int y_step_qn,
                             ConvolveParams *conv_params) {
  int x, y, k;
  uint8_t im_block[(2 * MAX_SB_SIZE + MAX_FILTER_TAP) * MAX_SB_SIZE];
  int im_h = (((h - 1) * y_step_qn + subpel_y_qn) >> SCALE_SUBPEL_BITS) +
             filter_params_y->taps;
  int im_stride = w;
  const int fo_vert = filter_params_y->taps / 2 - 1;
  const int fo_horiz = filter_params_x->taps / 2 - 1;

  // horizontal filter
  const uint8_t *src_horiz = src - fo_vert * src_stride;
  for (y = 0; y < im_h; ++y) {
    int x_qn = subpel_x_qn;
    for (x = 0; x < w; ++x, x_qn += x_step_qn) {
      const uint8_t *const src_x = &src_horiz[(x_qn >> SCALE_SUBPEL_BITS)];
      const int x_filter_idx = (x_qn & SCALE_SUBPEL_MASK) >> SCALE_EXTRA_BITS;
      assert(x_filter_idx < SUBPEL_SHIFTS);
      const int16_t *x_filter =
          av1_get_interp_filter_subpel_kernel(*filter_params_x, x_filter_idx);
      int sum = 0;
      for (k = 0; k < filter_params_x->taps; ++k)
        sum += x_filter[k] * src_x[k - fo_horiz];
      im_block[y * im_stride + x] =
          clip_pixel(ROUND_POWER_OF_TWO(sum, conv_params->round_0));
    }
    src_horiz += src_stride;
  }

  // vertical filter
  const uint8_t *src_vert = im_block + fo_vert * im_stride;
  for (x = 0; x < w; ++x) {
    int y_qn = subpel_y_qn;
    for (y = 0; y < h; ++y, y_qn += y_step_qn) {
      const uint8_t *const src_y =
          &src_vert[(y_qn >> SCALE_SUBPEL_BITS) * im_stride];
      const int y_filter_idx = (y_qn & SCALE_SUBPEL_MASK) >> SCALE_EXTRA_BITS;
      assert(y_filter_idx < SUBPEL_SHIFTS);
      const int16_t *y_filter =
          av1_get_interp_filter_subpel_kernel(*filter_params_y, y_filter_idx);
      CONV_BUF_TYPE sum = 0;
      for (k = 0; k < filter_params_y->taps; ++k) {
        sum += y_filter[k] * src_y[(k - fo_vert) * im_stride];
      }
      CONV_BUF_TYPE res = ROUND_POWER_OF_TWO(sum, conv_params->round_1);
422 423 424 425
      if (conv_params->do_average)
        dst[y * dst_stride + x] += res;
      else
        dst[y * dst_stride + x] = res;
426 427 428 429 430
    }
    src_vert++;
  }
}

Angie Chiang's avatar
Angie Chiang committed
431
#else
432

433 434 435 436 437 438
/* When convolve-round is enabled and compound-round is disabled, we use a
   high-precision convolve filter.
   Note: For notes on hardware implementations, including the required
   bit widths for various intermediate values, see the comments above
   av1_warp_affine_c.
*/
David Barker's avatar
David Barker committed
439 440 441 442 443 444
void av1_convolve_2d_c(const uint8_t *src, int src_stride, CONV_BUF_TYPE *dst,
                       int dst_stride, int w, int h,
                       InterpFilterParams *filter_params_x,
                       InterpFilterParams *filter_params_y,
                       const int subpel_x_q4, const int subpel_y_q4,
                       ConvolveParams *conv_params) {
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
  int x, y, k;
  int32_t im_block[(MAX_SB_SIZE + MAX_FILTER_TAP - 1) * MAX_SB_SIZE];
  int im_h = h + filter_params_y->taps - 1;
  int im_stride = w;
  const int fo_vert = filter_params_y->taps / 2 - 1;
  const int fo_horiz = filter_params_x->taps / 2 - 1;
  const int bd = 8;

  // horizontal filter
  const uint8_t *src_horiz = src - fo_vert * src_stride;
  const int16_t *x_filter = av1_get_interp_filter_subpel_kernel(
      *filter_params_x, subpel_x_q4 & SUBPEL_MASK);
  for (y = 0; y < im_h; ++y) {
    for (x = 0; x < w; ++x) {
      int32_t sum = (1 << (bd + FILTER_BITS - 1));
      for (k = 0; k < filter_params_x->taps; ++k) {
        sum += x_filter[k] * src_horiz[y * src_stride + x - fo_horiz + k];
      }
      assert(0 <= sum && sum < (1 << (bd + FILTER_BITS + 1)));
Angie Chiang's avatar
Angie Chiang committed
464
      im_block[y * im_stride + x] =
465
          ROUND_POWER_OF_TWO(sum, conv_params->round_0);
Angie Chiang's avatar
Angie Chiang committed
466 467 468 469
    }
  }

  // vertical filter
470
  int32_t *src_vert = im_block + fo_vert * im_stride;
Angie Chiang's avatar
Angie Chiang committed
471 472
  const int16_t *y_filter = av1_get_interp_filter_subpel_kernel(
      *filter_params_y, subpel_y_q4 & SUBPEL_MASK);
473
  const int offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;
Angie Chiang's avatar
Angie Chiang committed
474 475
  for (y = 0; y < h; ++y) {
    for (x = 0; x < w; ++x) {
476
      CONV_BUF_TYPE sum = 1 << offset_bits;
Angie Chiang's avatar
Angie Chiang committed
477 478 479
      for (k = 0; k < filter_params_y->taps; ++k) {
        sum += y_filter[k] * src_vert[(y - fo_vert + k) * im_stride + x];
      }
480 481 482 483
      assert(0 <= sum && sum < (1 << (offset_bits + 2)));
      CONV_BUF_TYPE res = ROUND_POWER_OF_TWO(sum, conv_params->round_1) -
                          ((1 << (offset_bits - conv_params->round_1)) +
                           (1 << (offset_bits - conv_params->round_1 - 1)));
484 485 486 487
      if (conv_params->do_average)
        dst[y * dst_stride + x] += res;
      else
        dst[y * dst_stride + x] = res;
Angie Chiang's avatar
Angie Chiang committed
488 489 490
    }
  }
}
491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547

void av1_convolve_2d_scale_c(const uint8_t *src, int src_stride,
                             CONV_BUF_TYPE *dst, int dst_stride, int w, int h,
                             InterpFilterParams *filter_params_x,
                             InterpFilterParams *filter_params_y,
                             const int subpel_x_qn, const int x_step_qn,
                             const int subpel_y_qn, const int y_step_qn,
                             ConvolveParams *conv_params) {
  int x, y, k;
  int32_t im_block[(2 * MAX_SB_SIZE + MAX_FILTER_TAP) * MAX_SB_SIZE];
  int im_h = (((h - 1) * y_step_qn + subpel_y_qn) >> SCALE_SUBPEL_BITS) +
             filter_params_y->taps;
  int im_stride = w;
  const int fo_vert = filter_params_y->taps / 2 - 1;
  const int fo_horiz = filter_params_x->taps / 2 - 1;
  const int bd = 8;

  // horizontal filter
  const uint8_t *src_horiz = src - fo_vert * src_stride;
  for (y = 0; y < im_h; ++y) {
    int x_qn = subpel_x_qn;
    for (x = 0; x < w; ++x, x_qn += x_step_qn) {
      const uint8_t *const src_x = &src_horiz[(x_qn >> SCALE_SUBPEL_BITS)];
      const int x_filter_idx = (x_qn & SCALE_SUBPEL_MASK) >> SCALE_EXTRA_BITS;
      assert(x_filter_idx < SUBPEL_SHIFTS);
      const int16_t *x_filter =
          av1_get_interp_filter_subpel_kernel(*filter_params_x, x_filter_idx);
      int32_t sum = (1 << (bd + FILTER_BITS - 1));
      for (k = 0; k < filter_params_x->taps; ++k) {
        sum += x_filter[k] * src_x[k - fo_horiz];
      }
      assert(0 <= sum && sum < (1 << (bd + FILTER_BITS + 1)));
      im_block[y * im_stride + x] =
          ROUND_POWER_OF_TWO(sum, conv_params->round_0);
    }
    src_horiz += src_stride;
  }

  // vertical filter
  int32_t *src_vert = im_block + fo_vert * im_stride;
  const int offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;
  for (x = 0; x < w; ++x) {
    int y_qn = subpel_y_qn;
    for (y = 0; y < h; ++y, y_qn += y_step_qn) {
      const int32_t *src_y = &src_vert[(y_qn >> SCALE_SUBPEL_BITS) * im_stride];
      const int y_filter_idx = (y_qn & SCALE_SUBPEL_MASK) >> SCALE_EXTRA_BITS;
      assert(y_filter_idx < SUBPEL_SHIFTS);
      const int16_t *y_filter =
          av1_get_interp_filter_subpel_kernel(*filter_params_y, y_filter_idx);
      CONV_BUF_TYPE sum = 1 << offset_bits;
      for (k = 0; k < filter_params_y->taps; ++k) {
        sum += y_filter[k] * src_y[(k - fo_vert) * im_stride];
      }
      assert(0 <= sum && sum < (1 << (offset_bits + 2)));
      CONV_BUF_TYPE res = ROUND_POWER_OF_TWO(sum, conv_params->round_1) -
                          ((1 << (offset_bits - conv_params->round_1)) +
                           (1 << (offset_bits - conv_params->round_1 - 1)));
548 549 550 551
      if (conv_params->do_average)
        dst[y * dst_stride + x] += res;
      else
        dst[y * dst_stride + x] = res;
552 553 554 555 556
    }
    src_vert++;
  }
}
#endif  // CONFIG_COMPOUND_ROUND
Angie Chiang's avatar
Angie Chiang committed
557 558 559

void av1_convolve_2d_facade(const uint8_t *src, int src_stride, uint8_t *dst,
                            int dst_stride, int w, int h,
560 561 562
                            InterpFilters interp_filters, const int subpel_x_q4,
                            int x_step_q4, const int subpel_y_q4, int y_step_q4,
                            int scaled, ConvolveParams *conv_params) {
Angie Chiang's avatar
Angie Chiang committed
563 564 565 566
  (void)x_step_q4;
  (void)y_step_q4;
  (void)dst;
  (void)dst_stride;
567 568 569 570

  InterpFilterParams filter_params_x, filter_params_y;
  av1_get_convolve_filter_params(interp_filters, 1, &filter_params_x,
                                 &filter_params_y);
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587

  if (filter_params_y.taps < filter_params_x.taps) {
    uint8_t tr_src[(MAX_SB_SIZE + MAX_FILTER_TAP - 1) *
                   (MAX_SB_SIZE + MAX_FILTER_TAP - 1)];
    int tr_src_stride = MAX_SB_SIZE + MAX_FILTER_TAP - 1;
    CONV_BUF_TYPE tr_dst[MAX_SB_SIZE * MAX_SB_SIZE];
    int tr_dst_stride = MAX_SB_SIZE;
    int fo_vert = filter_params_y.taps / 2 - 1;
    int fo_horiz = filter_params_x.taps / 2 - 1;

    transpose_uint8(tr_src, tr_src_stride,
                    src - fo_vert * src_stride - fo_horiz, src_stride,
                    w + filter_params_x.taps - 1, h + filter_params_y.taps - 1);
    transpose_int32(tr_dst, tr_dst_stride, conv_params->dst,
                    conv_params->dst_stride, w, h);

    // horizontal and vertical parameters are swapped because of the transpose
588 589 590 591 592 593 594 595 596 597
    if (scaled)
      av1_convolve_2d_scale(tr_src + fo_horiz * tr_src_stride + fo_vert,
                            tr_src_stride, tr_dst, tr_dst_stride, h, w,
                            &filter_params_y, &filter_params_x, subpel_y_q4,
                            y_step_q4, subpel_x_q4, x_step_q4, conv_params);
    else
      av1_convolve_2d(tr_src + fo_horiz * tr_src_stride + fo_vert,
                      tr_src_stride, tr_dst, tr_dst_stride, h, w,
                      &filter_params_y, &filter_params_x, subpel_y_q4,
                      subpel_x_q4, conv_params);
598 599 600
    transpose_int32(conv_params->dst, conv_params->dst_stride, tr_dst,
                    tr_dst_stride, h, w);
  } else {
601 602 603 604 605 606 607 608 609
    if (scaled)
      av1_convolve_2d_scale(src, src_stride, conv_params->dst,
                            conv_params->dst_stride, w, h, &filter_params_x,
                            &filter_params_y, subpel_x_q4, x_step_q4,
                            subpel_y_q4, y_step_q4, conv_params);
    else
      av1_convolve_2d(src, src_stride, conv_params->dst,
                      conv_params->dst_stride, w, h, &filter_params_x,
                      &filter_params_y, subpel_x_q4, subpel_y_q4, conv_params);
610
  }
Angie Chiang's avatar
Angie Chiang committed
611 612
}

613
#if CONFIG_HIGHBITDEPTH
614 615 616
void av1_highbd_convolve_rounding_c(const int32_t *src, int src_stride,
                                    uint8_t *dst8, int dst_stride, int w, int h,
                                    int bits, int bd) {
617 618 619 620 621
  uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
  int r, c;
  for (r = 0; r < h; ++r) {
    for (c = 0; c < w; ++c) {
      dst[r * dst_stride + c] = clip_pixel_highbd(
622
          ROUND_POWER_OF_TWO(src[r * src_stride + c], bits), bd);
623 624 625 626
    }
  }
}

627
#if CONFIG_COMPOUND_ROUND
David Barker's avatar
David Barker committed
628 629 630 631 632 633
void av1_highbd_convolve_2d_c(const uint16_t *src, int src_stride,
                              CONV_BUF_TYPE *dst, int dst_stride, int w, int h,
                              InterpFilterParams *filter_params_x,
                              InterpFilterParams *filter_params_y,
                              const int subpel_x_q4, const int subpel_y_q4,
                              ConvolveParams *conv_params, int bd) {
634
  int x, y, k;
635
  uint16_t im_block[(MAX_SB_SIZE + MAX_FILTER_TAP - 1) * MAX_SB_SIZE];
636 637 638 639
  int im_h = h + filter_params_y->taps - 1;
  int im_stride = w;
  const int fo_vert = filter_params_y->taps / 2 - 1;
  const int fo_horiz = filter_params_x->taps / 2 - 1;
640

641 642 643 644 645 646
  // horizontal filter
  const uint16_t *src_horiz = src - fo_vert * src_stride;
  const int16_t *x_filter = av1_get_interp_filter_subpel_kernel(
      *filter_params_x, subpel_x_q4 & SUBPEL_MASK);
  for (y = 0; y < im_h; ++y) {
    for (x = 0; x < w; ++x) {
647
      int32_t sum = 0;
648 649 650
      for (k = 0; k < filter_params_x->taps; ++k) {
        sum += x_filter[k] * src_horiz[y * src_stride + x - fo_horiz + k];
      }
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666
      im_block[y * im_stride + x] =
          clip_pixel_highbd(ROUND_POWER_OF_TWO(sum, conv_params->round_0), bd);
    }
  }

  // vertical filter
  uint16_t *src_vert = im_block + fo_vert * im_stride;
  const int16_t *y_filter = av1_get_interp_filter_subpel_kernel(
      *filter_params_y, subpel_y_q4 & SUBPEL_MASK);
  for (y = 0; y < h; ++y) {
    for (x = 0; x < w; ++x) {
      CONV_BUF_TYPE sum = 0;
      for (k = 0; k < filter_params_y->taps; ++k) {
        sum += y_filter[k] * src_vert[(y - fo_vert + k) * im_stride + x];
      }
      CONV_BUF_TYPE res = ROUND_POWER_OF_TWO(sum, conv_params->round_1);
667 668 669 670
      if (conv_params->do_average)
        dst[y * dst_stride + x] += res;
      else
        dst[y * dst_stride + x] = res;
671 672 673
    }
  }
}
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725

void av1_highbd_convolve_2d_scale_c(const uint16_t *src, int src_stride,
                                    CONV_BUF_TYPE *dst, int dst_stride, int w,
                                    int h, InterpFilterParams *filter_params_x,
                                    InterpFilterParams *filter_params_y,
                                    const int subpel_x_qn, const int x_step_qn,
                                    const int subpel_y_qn, const int y_step_qn,
                                    ConvolveParams *conv_params, int bd) {
  int x, y, k;
  uint16_t im_block[(2 * MAX_SB_SIZE + MAX_FILTER_TAP) * MAX_SB_SIZE];
  int im_h = (((h - 1) * y_step_qn + subpel_y_qn) >> SCALE_SUBPEL_BITS) +
             filter_params_y->taps;
  int im_stride = w;
  const int fo_vert = filter_params_y->taps / 2 - 1;
  const int fo_horiz = filter_params_x->taps / 2 - 1;
  (void)bd;

  // horizontal filter
  const uint16_t *src_horiz = src - fo_vert * src_stride;
  for (y = 0; y < im_h; ++y) {
    int x_qn = subpel_x_qn;
    for (x = 0; x < w; ++x, x_qn += x_step_qn) {
      const uint16_t *const src_x = &src_horiz[(x_qn >> SCALE_SUBPEL_BITS)];
      const int x_filter_idx = (x_qn & SCALE_SUBPEL_MASK) >> SCALE_EXTRA_BITS;
      assert(x_filter_idx < SUBPEL_SHIFTS);
      const int16_t *x_filter =
          av1_get_interp_filter_subpel_kernel(*filter_params_x, x_filter_idx);
      int sum = 0;
      for (k = 0; k < filter_params_x->taps; ++k)
        sum += x_filter[k] * src_x[k - fo_horiz];
      im_block[y * im_stride + x] =
          clip_pixel(ROUND_POWER_OF_TWO(sum, conv_params->round_0));
    }
    src_horiz += src_stride;
  }

  // vertical filter
  uint16_t *src_vert = im_block + fo_vert * im_stride;
  for (x = 0; x < w; ++x) {
    int y_qn = subpel_y_qn;
    for (y = 0; y < h; ++y, y_qn += y_step_qn) {
      const uint16_t *const src_y =
          &src_vert[(y_qn >> SCALE_SUBPEL_BITS) * im_stride];
      const int y_filter_idx = (y_qn & SCALE_SUBPEL_MASK) >> SCALE_EXTRA_BITS;
      assert(y_filter_idx < SUBPEL_SHIFTS);
      const int16_t *y_filter =
          av1_get_interp_filter_subpel_kernel(*filter_params_y, y_filter_idx);
      CONV_BUF_TYPE sum = 0;
      for (k = 0; k < filter_params_y->taps; ++k) {
        sum += y_filter[k] * src_y[(k - fo_vert) * im_stride];
      }
      CONV_BUF_TYPE res = ROUND_POWER_OF_TWO(sum, conv_params->round_1);
726 727 728 729
      if (conv_params->do_average)
        dst[y * dst_stride + x] += res;
      else
        dst[y * dst_stride + x] = res;
730 731 732 733 734
    }
    src_vert++;
  }
}

735
#else
736

David Barker's avatar
David Barker committed
737 738 739 740 741 742
void av1_highbd_convolve_2d_c(const uint16_t *src, int src_stride,
                              CONV_BUF_TYPE *dst, int dst_stride, int w, int h,
                              InterpFilterParams *filter_params_x,
                              InterpFilterParams *filter_params_y,
                              const int subpel_x_q4, const int subpel_y_q4,
                              ConvolveParams *conv_params, int bd) {
743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
  int x, y, k;
  int32_t im_block[(MAX_SB_SIZE + MAX_FILTER_TAP - 1) * MAX_SB_SIZE];
  int im_h = h + filter_params_y->taps - 1;
  int im_stride = w;
  const int fo_vert = filter_params_y->taps / 2 - 1;
  const int fo_horiz = filter_params_x->taps / 2 - 1;

  // horizontal filter
  const uint16_t *src_horiz = src - fo_vert * src_stride;
  const int16_t *x_filter = av1_get_interp_filter_subpel_kernel(
      *filter_params_x, subpel_x_q4 & SUBPEL_MASK);
  for (y = 0; y < im_h; ++y) {
    for (x = 0; x < w; ++x) {
      int32_t sum = (1 << (bd + FILTER_BITS - 1));
      for (k = 0; k < filter_params_x->taps; ++k) {
        sum += x_filter[k] * src_horiz[y * src_stride + x - fo_horiz + k];
      }
      assert(0 <= sum && sum < (1 << (bd + FILTER_BITS + 1)));
761 762
      (void)bd;
      im_block[y * im_stride + x] =
763
          ROUND_POWER_OF_TWO(sum, conv_params->round_0);
764 765 766 767
    }
  }

  // vertical filter
768 769
  int32_t *src_vert = im_block + fo_vert * im_stride;
  const int offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;
770 771 772 773
  const int16_t *y_filter = av1_get_interp_filter_subpel_kernel(
      *filter_params_y, subpel_y_q4 & SUBPEL_MASK);
  for (y = 0; y < h; ++y) {
    for (x = 0; x < w; ++x) {
774
      CONV_BUF_TYPE sum = 1 << offset_bits;
775 776 777
      for (k = 0; k < filter_params_y->taps; ++k) {
        sum += y_filter[k] * src_vert[(y - fo_vert + k) * im_stride + x];
      }
778 779 780 781
      assert(0 <= sum && sum < (1 << (offset_bits + 2)));
      CONV_BUF_TYPE res = ROUND_POWER_OF_TWO(sum, conv_params->round_1) -
                          ((1 << (offset_bits - conv_params->round_1)) +
                           (1 << (offset_bits - conv_params->round_1 - 1)));
782 783 784 785
      if (conv_params->do_average)
        dst[y * dst_stride + x] += res;
      else
        dst[y * dst_stride + x] = res;
786 787 788
    }
  }
}
789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844

void av1_highbd_convolve_2d_scale_c(const uint16_t *src, int src_stride,
                                    CONV_BUF_TYPE *dst, int dst_stride, int w,
                                    int h, InterpFilterParams *filter_params_x,
                                    InterpFilterParams *filter_params_y,
                                    const int subpel_x_qn, const int x_step_qn,
                                    const int subpel_y_qn, const int y_step_qn,
                                    ConvolveParams *conv_params, int bd) {
  int x, y, k;
  int32_t im_block[(2 * MAX_SB_SIZE + MAX_FILTER_TAP) * MAX_SB_SIZE];
  int im_h = (((h - 1) * y_step_qn + subpel_y_qn) >> SCALE_SUBPEL_BITS) +
             filter_params_y->taps;
  int im_stride = w;
  const int fo_vert = filter_params_y->taps / 2 - 1;
  const int fo_horiz = filter_params_x->taps / 2 - 1;

  // horizontal filter
  const uint16_t *src_horiz = src - fo_vert * src_stride;
  for (y = 0; y < im_h; ++y) {
    int x_qn = subpel_x_qn;
    for (x = 0; x < w; ++x, x_qn += x_step_qn) {
      const uint16_t *const src_x = &src_horiz[(x_qn >> SCALE_SUBPEL_BITS)];
      const int x_filter_idx = (x_qn & SCALE_SUBPEL_MASK) >> SCALE_EXTRA_BITS;
      assert(x_filter_idx < SUBPEL_SHIFTS);
      const int16_t *x_filter =
          av1_get_interp_filter_subpel_kernel(*filter_params_x, x_filter_idx);
      int32_t sum = (1 << (bd + FILTER_BITS - 1));
      for (k = 0; k < filter_params_x->taps; ++k) {
        sum += x_filter[k] * src_x[k - fo_horiz];
      }
      assert(0 <= sum && sum < (1 << (bd + FILTER_BITS + 1)));
      im_block[y * im_stride + x] =
          ROUND_POWER_OF_TWO(sum, conv_params->round_0);
    }
    src_horiz += src_stride;
  }

  // vertical filter
  int32_t *src_vert = im_block + fo_vert * im_stride;
  const int offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;
  for (x = 0; x < w; ++x) {
    int y_qn = subpel_y_qn;
    for (y = 0; y < h; ++y, y_qn += y_step_qn) {
      const int32_t *src_y = &src_vert[(y_qn >> SCALE_SUBPEL_BITS) * im_stride];
      const int y_filter_idx = (y_qn & SCALE_SUBPEL_MASK) >> SCALE_EXTRA_BITS;
      assert(y_filter_idx < SUBPEL_SHIFTS);
      const int16_t *y_filter =
          av1_get_interp_filter_subpel_kernel(*filter_params_y, y_filter_idx);
      CONV_BUF_TYPE sum = 1 << offset_bits;
      for (k = 0; k < filter_params_y->taps; ++k) {
        sum += y_filter[k] * src_y[(k - fo_vert) * im_stride];
      }
      assert(0 <= sum && sum < (1 << (offset_bits + 2)));
      CONV_BUF_TYPE res = ROUND_POWER_OF_TWO(sum, conv_params->round_1) -
                          ((1 << (offset_bits - conv_params->round_1)) +
                           (1 << (offset_bits - conv_params->round_1 - 1)));
845 846 847 848
      if (conv_params->do_average)
        dst[y * dst_stride + x] += res;
      else
        dst[y * dst_stride + x] = res;
849 850 851 852 853
    }
    src_vert++;
  }
}
#endif  // CONFIG_COMPOUND_ROUND
854 855 856

void av1_highbd_convolve_2d_facade(const uint8_t *src8, int src_stride,
                                   uint8_t *dst, int dst_stride, int w, int h,
857
                                   InterpFilters interp_filters,
858 859
                                   const int subpel_x_q4, int x_step_q4,
                                   const int subpel_y_q4, int y_step_q4,
860 861
                                   int scaled, ConvolveParams *conv_params,
                                   int bd) {
862 863 864 865
  (void)x_step_q4;
  (void)y_step_q4;
  (void)dst;
  (void)dst_stride;
866 867 868 869 870

  InterpFilterParams filter_params_x, filter_params_y;
  av1_get_convolve_filter_params(interp_filters, 1, &filter_params_x,
                                 &filter_params_y);

871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887
  const uint16_t *src = CONVERT_TO_SHORTPTR(src8);
  if (filter_params_y.taps < filter_params_x.taps) {
    uint16_t tr_src[(MAX_SB_SIZE + MAX_FILTER_TAP - 1) *
                    (MAX_SB_SIZE + MAX_FILTER_TAP - 1)];
    int tr_src_stride = MAX_SB_SIZE + MAX_FILTER_TAP - 1;
    CONV_BUF_TYPE tr_dst[MAX_SB_SIZE * MAX_SB_SIZE];
    int tr_dst_stride = MAX_SB_SIZE;
    int fo_vert = filter_params_y.taps / 2 - 1;
    int fo_horiz = filter_params_x.taps / 2 - 1;

    transpose_uint16(
        tr_src, tr_src_stride, src - fo_vert * src_stride - fo_horiz,
        src_stride, w + filter_params_x.taps - 1, h + filter_params_y.taps - 1);
    transpose_int32(tr_dst, tr_dst_stride, conv_params->dst,
                    conv_params->dst_stride, w, h);

    // horizontal and vertical parameters are swapped because of the transpose
888 889 890 891 892 893 894 895 896 897
    if (scaled)
      av1_highbd_convolve_2d_scale(
          tr_src + fo_horiz * tr_src_stride + fo_vert, tr_src_stride, tr_dst,
          tr_dst_stride, h, w, &filter_params_y, &filter_params_x, subpel_y_q4,
          y_step_q4, subpel_x_q4, x_step_q4, conv_params, bd);
    else
      av1_highbd_convolve_2d(tr_src + fo_horiz * tr_src_stride + fo_vert,
                             tr_src_stride, tr_dst, tr_dst_stride, h, w,
                             &filter_params_y, &filter_params_x, subpel_y_q4,
                             subpel_x_q4, conv_params, bd);
898 899 900
    transpose_int32(conv_params->dst, conv_params->dst_stride, tr_dst,
                    tr_dst_stride, h, w);
  } else {
901 902 903 904 905 906 907 908 909 910 911 912
    if (scaled)
      av1_highbd_convolve_2d_scale(
          src, src_stride, conv_params->dst, conv_params->dst_stride, w, h,
          &filter_params_x, &filter_params_y, subpel_x_q4, x_step_q4,
          subpel_y_q4, y_step_q4, conv_params, bd);
    else
      av1_highbd_convolve_2d(src, src_stride, conv_params->dst,
                             conv_params->dst_stride, w, h, &filter_params_x,
                             &filter_params_y, subpel_x_q4, subpel_y_q4,
                             conv_params, bd);
  }
}
913 914
#endif  // CONFIG_HIGHBITDEPTH

Angie Chiang's avatar
Angie Chiang committed
915
#endif  // CONFIG_CONVOLVE_ROUND
Angie Chiang's avatar
Angie Chiang committed
916

917 918 919 920 921 922 923 924
typedef void (*ConvolveFunc)(const uint8_t *src, int src_stride, uint8_t *dst,
                             int dst_stride, int w, int h,
                             const InterpFilterParams filter_params,
                             const int subpel_q4, int step_q4,
                             ConvolveParams *conv_params);

static void convolve_helper(const uint8_t *src, int src_stride, uint8_t *dst,
                            int dst_stride, int w, int h,
925
                            const InterpFilters interp_filters,
926 927 928 929 930
                            const int subpel_x_q4, int x_step_q4,
                            const int subpel_y_q4, int y_step_q4,
                            ConvolveParams *conv_params,
                            ConvolveFunc convolve_horiz,
                            ConvolveFunc convolve_vert) {
Fergus Simpson's avatar
Fergus Simpson committed
931 932
  int ignore_horiz = x_step_q4 == SUBPEL_SHIFTS && subpel_x_q4 == 0;
  int ignore_vert = y_step_q4 == SUBPEL_SHIFTS && subpel_y_q4 == 0;
933 934 935 936 937

  InterpFilterParams filter_params_x, filter_params_y;
  av1_get_convolve_filter_params(interp_filters, 0, &filter_params_x,
                                 &filter_params_y);

Angie Chiang's avatar
Angie Chiang committed
938
  assert(conv_params->round == CONVOLVE_OPT_ROUND);
939 940 941 942 943 944

  assert(w <= MAX_BLOCK_WIDTH);
  assert(h <= MAX_BLOCK_HEIGHT);
  assert(y_step_q4 <= MAX_STEP);
  assert(x_step_q4 <= MAX_STEP);

Angie Chiang's avatar
Angie Chiang committed
945
  if (ignore_horiz && ignore_vert) {
946
    convolve_copy(src, src_stride, dst, dst_stride, w, h, conv_params);
Angie Chiang's avatar
Angie Chiang committed
947
  } else if (ignore_vert) {
948 949
    assert(filter_params_x.taps <= MAX_FILTER_TAP);
    convolve_horiz(src, src_stride, dst, dst_stride, w, h, filter_params_x,
950
                   subpel_x_q4, x_step_q4, conv_params);
Angie Chiang's avatar
Angie Chiang committed
951
  } else if (ignore_horiz) {
952 953
    assert(filter_params_y.taps <= MAX_FILTER_TAP);
    convolve_vert(src, src_stride, dst, dst_stride, w, h, filter_params_y,
954
                  subpel_y_q4, y_step_q4, conv_params);
Angie Chiang's avatar
Angie Chiang committed
955
  } else {
956 957 958 959 960 961
    // temp's size is set to a 256 aligned value to facilitate SIMD
    // implementation. The value is greater than (maximum possible intermediate
    // height or width) * MAX_SB_SIZE
    DECLARE_ALIGNED(16, uint8_t,
                    temp[((MAX_SB_SIZE * 2 + 16) + 16) * MAX_SB_SIZE]);
    int max_intermediate_size = ((MAX_SB_SIZE * 2 + 16) + 16);
962
    int filter_size;
963
#if CONFIG_DUAL_FILTER && USE_EXTRA_FILTER
964
    av1_convolve_filter_params_fixup_1212(&filter_params_x, &filter_params_y);
965

966 967 968 969
    // we do filter with fewer taps first to reduce hardware implementation
    // complexity
    if (filter_params_y.taps < filter_params_x.taps) {
      int intermediate_width;
970
      int temp_stride = max_intermediate_size;
971 972
      ConvolveParams temp_conv_params;
      temp_conv_params.ref = 0;
973
      temp_conv_params.do_average = 0;
974
      temp_conv_params.round = CONVOLVE_OPT_ROUND;
975 976 977
      filter_size = filter_params_x.taps;
      intermediate_width =
          (((w - 1) * x_step_q4 + subpel_x_q4) >> SUBPEL_BITS) + filter_size;
978
      assert(intermediate_width <= max_intermediate_size);
Angie Chiang's avatar
Angie Chiang committed
979

980
      assert(filter_params_y.taps <= MAX_FILTER_TAP);
981

982
      convolve_vert(src - (filter_size / 2 - 1), src_stride, temp, temp_stride,
983
                    intermediate_width, h, filter_params_y, subpel_y_q4,
984
                    y_step_q4, &temp_conv_params);
985

986
      assert(filter_params_x.taps <= MAX_FILTER_TAP);
987
      convolve_horiz(temp + (filter_size / 2 - 1), temp_stride, dst, dst_stride,
988 989
                     w, h, filter_params_x, subpel_x_q4, x_step_q4,
                     conv_params);
990
    } else
991
#endif  // CONFIG_DUAL_FILTER && USE_EXTRA_FILTER
992 993
    {
      int intermediate_height;
994
      int temp_stride = MAX_SB_SIZE;
995 996
      ConvolveParams temp_conv_params;
      temp_conv_params.ref = 0;
997
      temp_conv_params.do_average = 0;
998
      temp_conv_params.round = CONVOLVE_OPT_ROUND;
999 1000 1001
      filter_size = filter_params_y.taps;
      intermediate_height =
          (((h - 1) * y_step_q4 + subpel_y_q4) >> SUBPEL_BITS) + filter_size;
1002 1003
      assert(intermediate_height <= max_intermediate_size);
      (void)max_intermediate_size;
1004

1005
      assert(filter_params_x.taps <= MAX_FILTER_TAP);
1006

1007
      convolve_horiz(src - src_stride * (filter_size / 2 - 1), src_stride, temp,
1008
                     temp_stride, w, intermediate_height, filter_params_x,
1009
                     subpel_x_q4, x_step_q4, &temp_conv_params);
1010

1011
      assert(filter_params_y.taps <= MAX_FILTER_TAP);
1012

1013
      convolve_vert(temp + temp_stride * (filter_size / 2 - 1), temp_stride,
1014
                    dst, dst_stride, w, h, filter_params_y, subpel_y_q4,
1015
                    y_step_q4, conv_params);
1016
    }
Angie Chiang's avatar
Angie Chiang committed
1017
  }
1018 1019
}

Fergus Simpson's avatar
Fergus Simpson committed
1020 1021
static void convolve_scale_helper(const uint8_t *src, int src_stride,
                                  uint8_t *dst, int dst_stride, int w, int h,
1022
                                  const InterpFilters interp_filters,
Fergus Simpson's avatar
Fergus Simpson committed
1023 1024 1025 1026 1027 1028 1029
                                  const int subpel_x_qn, int x_step_qn,
                                  const int subpel_y_qn, int y_step_qn,
                                  ConvolveParams *conv_params,
                                  ConvolveFunc convolve_horiz,
                                  ConvolveFunc convolve_vert) {
  int ignore_horiz = x_step_qn == SCALE_SUBPEL_SHIFTS && subpel_x_qn == 0;
  int ignore_vert = y_step_qn == SCALE_SUBPEL_SHIFTS && subpel_y_qn == 0;
1030 1031 1032 1033 1034

  InterpFilterParams filter_params_x, filter_params_y;
  av1_get_convolve_filter_params(interp_filters, 0, &filter_params_x,
                                 &filter_params_y);

1035
  assert(conv_params->round == CONVOLVE_OPT_ROUND);
Fergus Simpson's avatar
Fergus Simpson committed
1036 1037 1038 1039 1040 1041 1042 1043 1044

  assert(w <= MAX_BLOCK_WIDTH);
  assert(h <= MAX_BLOCK_HEIGHT);
  assert(y_step_qn <= (MAX_STEP << SCALE_EXTRA_BITS));
  assert(x_step_qn <= (MAX_STEP << SCALE_EXTRA_BITS));

  if (ignore_horiz && ignore_vert) {
    convolve_copy(src, src_stride, dst, dst_stride, w, h, conv_params);
  } else if (ignore_vert) {
1045 1046
    assert(filter_params_x.taps <= MAX_FILTER_TAP);
    convolve_horiz(src, src_stride, dst, dst_stride, w, h, filter_params_x,
Fergus Simpson's avatar
Fergus Simpson committed
1047 1048
                   subpel_x_qn, x_step_qn, conv_params);
  } else if (ignore_horiz) {
1049 1050
    assert(filter_params_y.taps <= MAX_FILTER_TAP);
    convolve_vert(src, src_stride, dst, dst_stride, w, h, filter_params_y,
Fergus Simpson's avatar
Fergus Simpson committed
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
                  subpel_y_qn, y_step_qn, conv_params);
  } else {
    // temp's size is set to a 256 aligned value to facilitate SIMD
    // implementation. The value is greater than (maximum possible intermediate
    // height or width) * MAX_SB_SIZE
    DECLARE_ALIGNED(16, uint8_t,
                    temp[((MAX_SB_SIZE * 2 + 16) + 16) * MAX_SB_SIZE]);
    int max_intermediate_size = ((MAX_SB_SIZE * 2 + 16) + 16);
    int filter_size;
#if CONFIG_DUAL_FILTER && USE_EXTRA_FILTER
1061
    av1_convolve_filter_params_fixup_1212(&filter_params_x, &filter_params_y);
Fergus Simpson's avatar
Fergus Simpson committed
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077

    // we do filter with fewer taps first to reduce hardware implementation
    // complexity
    if (filter_params_y.taps < filter_params_x.taps) {
      int intermediate_width;
      int temp_stride = max_intermediate_size;
      ConvolveParams temp_conv_params;
      temp_conv_params.ref = 0;
      temp_conv_params.do_average = 0;
      temp_conv_params.round = CONVOLVE_OPT_ROUND;
      filter_size = filter_params_x.taps;
      intermediate_width =
          (((w - 1) * x_step_qn + subpel_x_qn) >> SCALE_SUBPEL_BITS) +
          filter_size;
      assert(intermediate_width <= max_intermediate_size);

1078
      assert(filter_params_y.taps <= MAX_FILTER_TAP);
Fergus Simpson's avatar
Fergus Simpson committed
1079 1080

      convolve_vert(src - (filter_size / 2 - 1), src_stride, temp, temp_stride,
1081
                    intermediate_width, h, filter_params_y, subpel_y_qn,
Fergus Simpson's avatar
Fergus Simpson committed
1082 1083
                    y_step_qn, &temp_conv_params);

1084
      assert(filter_params_x.taps <= MAX_FILTER_TAP);
Fergus Simpson's avatar
Fergus Simpson committed
1085
      convolve_horiz(temp + (filter_size / 2 - 1), temp_stride, dst, dst_stride,
1086 1087
                     w, h, filter_params_x, subpel_x_qn, x_step_qn,
                     conv_params);
Fergus Simpson's avatar
Fergus Simpson committed
1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
    } else {
#endif  // CONFIG_DUAL_FILTER && USE_EXTRA_FILTER
      int intermediate_height;
      int temp_stride = MAX_SB_SIZE;
      ConvolveParams temp_conv_params;
      temp_conv_params.ref = 0;
      temp_conv_params.do_average = 0;
      temp_conv_params.round = CONVOLVE_OPT_ROUND;
      filter_size = filter_params_y.taps;
      intermediate_height =
          (((h - 1) * y_step_qn + subpel_y_qn) >> SCALE_SUBPEL_BITS) +
          filter_size;
      assert(intermediate_height <= max_intermediate_size);
      (void)max_intermediate_size;

1103
      assert(filter_params_x.taps <= MAX_FILTER_TAP);
Fergus Simpson's avatar
Fergus Simpson committed
1104 1105

      convolve_horiz(src - src_stride * (filter_size / 2 - 1), src_stride, temp,
1106
                     temp_stride, w, intermediate_height, filter_params_x,
Fergus Simpson's avatar
Fergus Simpson committed
1107 1108
                     subpel_x_qn, x_step_qn, &temp_conv_params);

1109
      assert(filter_params_y.taps <= MAX_FILTER_TAP);
Fergus Simpson's avatar
Fergus Simpson committed
1110 1111

      convolve_vert(temp + temp_stride * (filter_size / 2 - 1), temp_stride,
1112
                    dst, dst_stride, w, h, filter_params_y, subpel_y_qn,
Fergus Simpson's avatar
Fergus Simpson committed
1113 1114 1115 1116 1117 1118 1119
                    y_step_qn, conv_params);
#if CONFIG_DUAL_FILTER && USE_EXTRA_FILTER
    }
#endif  // CONFIG_DUAL_FILTER && USE_EXTRA_FILTER
  }
}

1120
void av1_convolve(const uint8_t *src, int src_stride, uint8_t *dst,
1121
                  int dst_stride, int w, int h, InterpFilters interp_filters,