/*

 * 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.

 */

#include <assert.h>

#include <string.h>

#include "config/aom_dsp_rtcd.h"

#include "config/av1_rtcd.h"

#include "av1/common/blockd.h"

#include "av1/common/convolve.h"

#include "av1/common/filter.h"

#include "av1/common/onyxc_int.h"

#include "av1/common/resize.h"

#include "aom_dsp/aom_dsp_common.h"

#include "aom_ports/mem.h"

void av1_convolve_horiz_rs_c(const uint8_t *src, int src_stride, uint8_t *dst,

                             int dst_stride, int w, int h,

                             const int16_t *x_filters, int x0_qn,

                             int x_step_qn) {

  src -= UPSCALE_NORMATIVE_TAPS / 2 - 1;

  for (int y = 0; y < h; ++y) {

    int x_qn = x0_qn;

    for (int x = 0; x < w; ++x) {

      const uint8_t *const src_x = &src[x_qn >> RS_SCALE_SUBPEL_BITS];

      const int x_filter_idx =

          (x_qn & RS_SCALE_SUBPEL_MASK) >> RS_SCALE_EXTRA_BITS;

      assert(x_filter_idx <= RS_SUBPEL_MASK);

      const int16_t *const x_filter =

          &x_filters[x_filter_idx * UPSCALE_NORMATIVE_TAPS];

      int sum = 0;

      for (int k = 0; k < UPSCALE_NORMATIVE_TAPS; ++k)

        sum += src_x[k] * x_filter[k];

      dst[x] = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS));

      x_qn += x_step_qn;

    }

    src += src_stride;

    dst += dst_stride;

  }

}

void av1_highbd_convolve_horiz_rs_c(const uint16_t *src, int src_stride,

                                    uint16_t *dst, int dst_stride, int w, int h,

                                    const int16_t *x_filters, int x0_qn,

                                    int x_step_qn, int bd) {

  src -= UPSCALE_NORMATIVE_TAPS / 2 - 1;

  for (int y = 0; y < h; ++y) {

    int x_qn = x0_qn;

    for (int x = 0; x < w; ++x) {

      const uint16_t *const src_x = &src[x_qn >> RS_SCALE_SUBPEL_BITS];

      const int x_filter_idx =

          (x_qn & RS_SCALE_SUBPEL_MASK) >> RS_SCALE_EXTRA_BITS;

      assert(x_filter_idx <= RS_SUBPEL_MASK);

      const int16_t *const x_filter =

          &x_filters[x_filter_idx * UPSCALE_NORMATIVE_TAPS];

      int sum = 0;

      for (int k = 0; k < UPSCALE_NORMATIVE_TAPS; ++k)

        sum += src_x[k] * x_filter[k];

      dst[x] = clip_pixel_highbd(ROUND_POWER_OF_TWO(sum, FILTER_BITS), bd);

      x_qn += x_step_qn;

    }

    src += src_stride;

    dst += dst_stride;

  }

}

void av1_convolve_2d_sr_c(const uint8_t *src, int src_stride, uint8_t *dst,

                          int dst_stride, int w, int h,

                          const InterpFilterParams *filter_params_x,

                          const InterpFilterParams *filter_params_y,

                          const int subpel_x_q4, const int subpel_y_q4,

                          ConvolveParams *conv_params) {

  int16_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;

  const int bits =

      FILTER_BITS * 2 - conv_params->round_0 - conv_params->round_1;

  // 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 (int y = 0; y < im_h; ++y) {

    for (int x = 0; x < w; ++x) {

      int32_t sum = (1 << (bd + FILTER_BITS - 1));

      for (int 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)));

      im_block[y * im_stride + x] =

          (int16_t)ROUND_POWER_OF_TWO(sum, conv_params->round_0);

    }

  }

  // vertical filter

  int16_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);

  const int offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;

  for (int y = 0; y < h; ++y) {

    for (int x = 0; x < w; ++x) {

      int32_t sum = 1 << offset_bits;

      for (int k = 0; k < filter_params_y->taps; ++k) {

        sum += y_filter[k] * src_vert[(y - fo_vert + k) * im_stride + x];

      }

      assert(0 <= sum && sum < (1 << (offset_bits + 2)));

      int16_t 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)));

      dst[y * dst_stride + x] = clip_pixel(ROUND_POWER_OF_TWO(res, bits));

    }

  }

}

void av1_convolve_y_sr_c(const uint8_t *src, int src_stride, uint8_t *dst,

                         int dst_stride, int w, int h,

                         const InterpFilterParams *filter_params_x,

                         const InterpFilterParams *filter_params_y,

                         const int subpel_x_q4, const int subpel_y_q4,

                         ConvolveParams *conv_params) {

  const int fo_vert = filter_params_y->taps / 2 - 1;

  (void)filter_params_x;

  (void)subpel_x_q4;

  (void)conv_params;

  assert(conv_params->round_0 <= FILTER_BITS);

  assert(((conv_params->round_0 + conv_params->round_1) <= (FILTER_BITS + 1)) ||

         ((conv_params->round_0 + conv_params->round_1) == (2 * FILTER_BITS)));

  // vertical filter

  const int16_t *y_filter = av1_get_interp_filter_subpel_kernel(

      filter_params_y, subpel_y_q4 & SUBPEL_MASK);

  for (int y = 0; y < h; ++y) {

    for (int x = 0; x < w; ++x) {

      int32_t res = 0;

      for (int k = 0; k < filter_params_y->taps; ++k) {

        res += y_filter[k] * src[(y - fo_vert + k) * src_stride + x];

      }

      dst[y * dst_stride + x] =

          clip_pixel(ROUND_POWER_OF_TWO(res, FILTER_BITS));

    }

  }

}

void av1_convolve_x_sr_c(const uint8_t *src, int src_stride, uint8_t *dst,

                         int dst_stride, int w, int h,

                         const InterpFilterParams *filter_params_x,

                         const InterpFilterParams *filter_params_y,

                         const int subpel_x_q4, const int subpel_y_q4,

                         ConvolveParams *conv_params) {

  const int fo_horiz = filter_params_x->taps / 2 - 1;

  const int bits = FILTER_BITS - conv_params->round_0;

  (void)filter_params_y;

  (void)subpel_y_q4;

  (void)conv_params;

  assert(bits >= 0);

  assert((FILTER_BITS - conv_params->round_1) >= 0 ||

         ((conv_params->round_0 + conv_params->round_1) == 2 * FILTER_BITS));

  // horizontal filter

  const int16_t *x_filter = av1_get_interp_filter_subpel_kernel(

      filter_params_x, subpel_x_q4 & SUBPEL_MASK);

  for (int y = 0; y < h; ++y) {

    for (int x = 0; x < w; ++x) {

      int32_t res = 0;

      for (int k = 0; k < filter_params_x->taps; ++k) {

        res += x_filter[k] * src[y * src_stride + x - fo_horiz + k];

      }

      res = ROUND_POWER_OF_TWO(res, conv_params->round_0);

      dst[y * dst_stride + x] = clip_pixel(ROUND_POWER_OF_TWO(res, bits));

    }

  }

}

void av1_convolve_2d_copy_sr_c(const uint8_t *src, int src_stride, uint8_t *dst,

                               int dst_stride, int w, int h,

                               const InterpFilterParams *filter_params_x,

                               const InterpFilterParams *filter_params_y,

                               const int subpel_x_q4, const int subpel_y_q4,

                               ConvolveParams *conv_params) {

  (void)filter_params_x;

  (void)filter_params_y;

  (void)subpel_x_q4;

  (void)subpel_y_q4;

  (void)conv_params;

  for (int y = 0; y < h; ++y) {

    memcpy(dst + y * dst_stride, src + y * src_stride, w * sizeof(src[0]));

  }

}

void av1_jnt_convolve_2d_c(const uint8_t *src, int src_stride, uint8_t *dst8,

                           int dst8_stride, int w, int h,

                           const InterpFilterParams *filter_params_x,

                           const InterpFilterParams *filter_params_y,

                           const int subpel_x_q4, const int subpel_y_q4,

                           ConvolveParams *conv_params) {

  CONV_BUF_TYPE *dst = conv_params->dst;

  int dst_stride = conv_params->dst_stride;

  int16_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;

  const int round_bits =

      2 * FILTER_BITS - conv_params->round_0 - conv_params->round_1;

  // 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 (int y = 0; y < im_h; ++y) {

    for (int x = 0; x < w; ++x) {

      int32_t sum = (1 << (bd + FILTER_BITS - 1));

      for (int 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)));

      im_block[y * im_stride + x] =

          (int16_t)ROUND_POWER_OF_TWO(sum, conv_params->round_0);

    }

  }

  // vertical filter

  int16_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);

  const int offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;

  for (int y = 0; y < h; ++y) {

    for (int x = 0; x < w; ++x) {

      int32_t sum = 1 << offset_bits;

      for (int k = 0; k < filter_params_y->taps; ++k) {

        sum += y_filter[k] * src_vert[(y - fo_vert + k) * im_stride + x];

      }

      assert(0 <= sum && sum < (1 << (offset_bits + 2)));

      CONV_BUF_TYPE res = ROUND_POWER_OF_TWO(sum, conv_params->round_1);

      if (conv_params->do_average) {

        int32_t tmp = dst[y * dst_stride + x];

        if (conv_params->use_jnt_comp_avg) {

          tmp = tmp * conv_params->fwd_offset + res * conv_params->bck_offset;

          tmp = tmp >> DIST_PRECISION_BITS;

        } else {

          tmp += res;

          tmp = tmp >> 1;

        }

        tmp -= (1 << (offset_bits - conv_params->round_1)) +

               (1 << (offset_bits - conv_params->round_1 - 1));

        dst8[y * dst8_stride + x] =

            clip_pixel(ROUND_POWER_OF_TWO(tmp, round_bits));

      } else {

        dst[y * dst_stride + x] = res;

      }

    }

  }

}

void av1_jnt_convolve_y_c(const uint8_t *src, int src_stride, uint8_t *dst8,

                          int dst8_stride, int w, int h,

                          const InterpFilterParams *filter_params_x,

                          const InterpFilterParams *filter_params_y,

                          const int subpel_x_q4, const int subpel_y_q4,

                          ConvolveParams *conv_params) {

  CONV_BUF_TYPE *dst = conv_params->dst;

  int dst_stride = conv_params->dst_stride;

  const int fo_vert = filter_params_y->taps / 2 - 1;

  const int bits = FILTER_BITS - conv_params->round_0;

  const int bd = 8;

  const int offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;

  const int round_offset = (1 << (offset_bits - conv_params->round_1)) +

                           (1 << (offset_bits - conv_params->round_1 - 1));

  const int round_bits =

      2 * FILTER_BITS - conv_params->round_0 - conv_params->round_1;

  (void)filter_params_x;

  (void)subpel_x_q4;

  // vertical filter

  const int16_t *y_filter = av1_get_interp_filter_subpel_kernel(

      filter_params_y, subpel_y_q4 & SUBPEL_MASK);

  for (int y = 0; y < h; ++y) {

    for (int x = 0; x < w; ++x) {

      int32_t res = 0;

      for (int k = 0; k < filter_params_y->taps; ++k) {

        res += y_filter[k] * src[(y - fo_vert + k) * src_stride + x];

      }

      res *= (1 << bits);

      res = ROUND_POWER_OF_TWO(res, conv_params->round_1) + round_offset;

      if (conv_params->do_average) {

        int32_t tmp = dst[y * dst_stride + x];

        if (conv_params->use_jnt_comp_avg) {

          tmp = tmp * conv_params->fwd_offset + res * conv_params->bck_offset;

          tmp = tmp >> DIST_PRECISION_BITS;

        } else {

          tmp += res;

          tmp = tmp >> 1;

        }

        tmp -= round_offset;

        dst8[y * dst8_stride + x] =

            clip_pixel(ROUND_POWER_OF_TWO(tmp, round_bits));

      } else {

        dst[y * dst_stride + x] = res;

      }

    }

  }

}

void av1_jnt_convolve_x_c(const uint8_t *src, int src_stride, uint8_t *dst8,

                          int dst8_stride, int w, int h,

                          const InterpFilterParams *filter_params_x,

                          const InterpFilterParams *filter_params_y,

                          const int subpel_x_q4, const int subpel_y_q4,

                          ConvolveParams *conv_params) {

  CONV_BUF_TYPE *dst = conv_params->dst;

  int dst_stride = conv_params->dst_stride;

  const int fo_horiz = filter_params_x->taps / 2 - 1;

  const int bits = FILTER_BITS - conv_params->round_1;

  const int bd = 8;

  const int offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;

  const int round_offset = (1 << (offset_bits - conv_params->round_1)) +

                           (1 << (offset_bits - conv_params->round_1 - 1));

  const int round_bits =

      2 * FILTER_BITS - conv_params->round_0 - conv_params->round_1;

  (void)filter_params_y;

  (void)subpel_y_q4;

  // horizontal filter

  const int16_t *x_filter = av1_get_interp_filter_subpel_kernel(

      filter_params_x, subpel_x_q4 & SUBPEL_MASK);

  for (int y = 0; y < h; ++y) {

    for (int x = 0; x < w; ++x) {

      int32_t res = 0;

      for (int k = 0; k < filter_params_x->taps; ++k) {

        res += x_filter[k] * src[y * src_stride + x - fo_horiz + k];

      }

      res = (1 << bits) * ROUND_POWER_OF_TWO(res, conv_params->round_0);

      res += round_offset;

      if (conv_params->do_average) {

        int32_t tmp = dst[y * dst_stride + x];

        if (conv_params->use_jnt_comp_avg) {

          tmp = tmp * conv_params->fwd_offset + res * conv_params->bck_offset;

          tmp = tmp >> DIST_PRECISION_BITS;

        } else {

          tmp += res;

          tmp = tmp >> 1;

        }

        tmp -= round_offset;

        dst8[y * dst8_stride + x] =

            clip_pixel(ROUND_POWER_OF_TWO(tmp, round_bits));

      } else {

        dst[y * dst_stride + x] = res;

      }

    }

  }

}

void av1_jnt_convolve_2d_copy_c(const uint8_t *src, int src_stride,

                                uint8_t *dst8, int dst8_stride, int w, int h,

                                const InterpFilterParams *filter_params_x,

                                const InterpFilterParams *filter_params_y,

                                const int subpel_x_q4, const int subpel_y_q4,

                                ConvolveParams *conv_params) {

  CONV_BUF_TYPE *dst = conv_params->dst;

  int dst_stride = conv_params->dst_stride;

  const int bits =

      FILTER_BITS * 2 - conv_params->round_1 - conv_params->round_0;

  const int bd = 8;

  const int offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;

  const int round_offset = (1 << (offset_bits - conv_params->round_1)) +

                           (1 << (offset_bits - conv_params->round_1 - 1));

  (void)filter_params_x;

  (void)filter_params_y;

  (void)subpel_x_q4;

  (void)subpel_y_q4;

  for (int y = 0; y < h; ++y) {

    for (int x = 0; x < w; ++x) {

      CONV_BUF_TYPE res = src[y * src_stride + x] << bits;

      res += round_offset;

      if (conv_params->do_average) {

        int32_t tmp = dst[y * dst_stride + x];

        if (conv_params->use_jnt_comp_avg) {

          tmp = tmp * conv_params->fwd_offset + res * conv_params->bck_offset;

          tmp = tmp >> DIST_PRECISION_BITS;

        } else {

          tmp += res;

          tmp = tmp >> 1;

        }

        tmp -= round_offset;

        dst8[y * dst8_stride + x] = clip_pixel(ROUND_POWER_OF_TWO(tmp, bits));

      } else {

        dst[y * dst_stride + x] = res;

      }

    }

  }

}

void av1_convolve_2d_scale_c(const uint8_t *src, int src_stride, uint8_t *dst8,

                             int dst8_stride, int w, int h,

                             const InterpFilterParams *filter_params_x,

                             const 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) {

  int16_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;

  CONV_BUF_TYPE *dst16 = conv_params->dst;

  const int dst16_stride = conv_params->dst_stride;

  const int bits =

      FILTER_BITS * 2 - conv_params->round_0 - conv_params->round_1;

  assert(bits >= 0);

  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 (int y = 0; y < im_h; ++y) {

    int x_qn = subpel_x_qn;

    for (int 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 (int 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] =

          (int16_t)ROUND_POWER_OF_TWO(sum, conv_params->round_0);

    }

    src_horiz += src_stride;

  }

  // vertical filter

  int16_t *src_vert = im_block + fo_vert * im_stride;

  const int offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;

  for (int x = 0; x < w; ++x) {

    int y_qn = subpel_y_qn;

    for (int y = 0; y < h; ++y, y_qn += y_step_qn) {

      const int16_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);

      int32_t sum = 1 << offset_bits;

      for (int 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);

      if (conv_params->is_compound) {

        if (conv_params->do_average) {

          int32_t tmp = dst16[y * dst16_stride + x];

          if (conv_params->use_jnt_comp_avg) {

            tmp = tmp * conv_params->fwd_offset + res * conv_params->bck_offset;

            tmp = tmp >> DIST_PRECISION_BITS;

          } else {

            tmp += res;

            tmp = tmp >> 1;

          }

          /* Subtract round offset and convolve round */

          tmp = tmp - ((1 << (offset_bits - conv_params->round_1)) +

                       (1 << (offset_bits - conv_params->round_1 - 1)));

          dst8[y * dst8_stride + x] = clip_pixel(ROUND_POWER_OF_TWO(tmp, bits));

        } else {

          dst16[y * dst16_stride + x] = res;

        }

      } else {

        /* Subtract round offset and convolve round */

        int32_t tmp = res - ((1 << (offset_bits - conv_params->round_1)) +

                             (1 << (offset_bits - conv_params->round_1 - 1)));

        dst8[y * dst8_stride + x] = clip_pixel(ROUND_POWER_OF_TWO(tmp, bits));

      }

    }

    src_vert++;

  }

}

static void convolve_2d_scale_wrapper(

    const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int w,

    int h, const InterpFilterParams *filter_params_x,

    const 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) {

  if (conv_params->is_compound) {

    assert(conv_params->dst != NULL);

  }

  av1_convolve_2d_scale(src, src_stride, dst, dst_stride, w, h, filter_params_x,

                        filter_params_y, subpel_x_qn, x_step_qn, subpel_y_qn,

                        y_step_qn, conv_params);

}

// TODO(huisu@google.com): bilinear filtering only needs 2 taps in general. So

// we may create optimized code to do 2-tap filtering for all bilinear filtering

// usages, not just IntraBC.

static void convolve_2d_for_intrabc(const uint8_t *src, int src_stride,

                                    uint8_t *dst, int dst_stride, int w, int h,

                                    int subpel_x_q4, int subpel_y_q4,

                                    ConvolveParams *conv_params) {

  const InterpFilterParams *filter_params_x =

      subpel_x_q4 ? &av1_intrabc_filter_params : NULL;

  const InterpFilterParams *filter_params_y =

      subpel_y_q4 ? &av1_intrabc_filter_params : NULL;

  if (subpel_x_q4 != 0 && subpel_y_q4 != 0) {

    av1_convolve_2d_sr_c(src, src_stride, dst, dst_stride, w, h,

                         filter_params_x, filter_params_y, 0, 0, conv_params);

  } else if (subpel_x_q4 != 0) {

    av1_convolve_x_sr_c(src, src_stride, dst, dst_stride, w, h, filter_params_x,

                        filter_params_y, 0, 0, conv_params);

  } else {

    av1_convolve_y_sr_c(src, src_stride, dst, dst_stride, w, h, filter_params_x,

                        filter_params_y, 0, 0, conv_params);

  }

}

void av1_convolve_2d_facade(const uint8_t *src, int src_stride, uint8_t *dst,

                            int dst_stride, int w, int h,

                            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,

                            const struct scale_factors *sf, int is_intrabc) {

  assert(IMPLIES(is_intrabc, !scaled));

  (void)x_step_q4;

  (void)y_step_q4;

  (void)dst;

  (void)dst_stride;

  if (is_intrabc && (subpel_x_q4 != 0 || subpel_y_q4 != 0)) {

    convolve_2d_for_intrabc(src, src_stride, dst, dst_stride, w, h, subpel_x_q4,

                            subpel_y_q4, conv_params);

    return;

  }

  InterpFilter filter_x = 0;

  InterpFilter filter_y = 0;

  const int need_filter_params_x = (subpel_x_q4 != 0) | scaled;

  const int need_filter_params_y = (subpel_y_q4 != 0) | scaled;

  if (need_filter_params_x)

    filter_x = av1_extract_interp_filter(interp_filters, 1);

  if (need_filter_params_y)

    filter_y = av1_extract_interp_filter(interp_filters, 0);

  const InterpFilterParams *filter_params_x =

      need_filter_params_x

          ? av1_get_interp_filter_params_with_block_size(filter_x, w)

          : NULL;

  const InterpFilterParams *filter_params_y =

      need_filter_params_y

          ? av1_get_interp_filter_params_with_block_size(filter_y, h)

          : NULL;

  if (scaled) {

    convolve_2d_scale_wrapper(src, src_stride, dst, 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 {

    sf->convolve[subpel_x_q4 != 0][subpel_y_q4 != 0][conv_params->is_compound](

        src, src_stride, dst, dst_stride, w, h, filter_params_x,

        filter_params_y, subpel_x_q4, subpel_y_q4, conv_params);

  }

}

void av1_highbd_convolve_2d_copy_sr_c(

    const uint16_t *src, int src_stride, uint16_t *dst, int dst_stride, int w,

    int h, const InterpFilterParams *filter_params_x,

    const InterpFilterParams *filter_params_y, const int subpel_x_q4,

    const int subpel_y_q4, ConvolveParams *conv_params, int bd) {

  (void)filter_params_x;

  (void)filter_params_y;

  (void)subpel_x_q4;

  (void)subpel_y_q4;

  (void)conv_params;

  (void)bd;

  for (int y = 0; y < h; ++y) {

    memcpy(dst + y * dst_stride, src + y * src_stride, w * sizeof(src[0]));

  }

}

void av1_highbd_convolve_x_sr_c(const uint16_t *src, int src_stride,

                                uint16_t *dst, int dst_stride, int w, int h,

                                const InterpFilterParams *filter_params_x,

                                const InterpFilterParams *filter_params_y,

                                const int subpel_x_q4, const int subpel_y_q4,

                                ConvolveParams *conv_params, int bd) {

  const int fo_horiz = filter_params_x->taps / 2 - 1;

  const int bits = FILTER_BITS - conv_params->round_0;

  (void)filter_params_y;

  (void)subpel_y_q4;

  assert(bits >= 0);

  assert((FILTER_BITS - conv_params->round_1) >= 0 ||

         ((conv_params->round_0 + conv_params->round_1) == 2 * FILTER_BITS));

  // horizontal filter

  const int16_t *x_filter = av1_get_interp_filter_subpel_kernel(

      filter_params_x, subpel_x_q4 & SUBPEL_MASK);

  for (int y = 0; y < h; ++y) {

    for (int x = 0; x < w; ++x) {

      int32_t res = 0;

      for (int k = 0; k < filter_params_x->taps; ++k) {

        res += x_filter[k] * src[y * src_stride + x - fo_horiz + k];

      }

      res = ROUND_POWER_OF_TWO(res, conv_params->round_0);

      dst[y * dst_stride + x] =

          clip_pixel_highbd(ROUND_POWER_OF_TWO(res, bits), bd);

    }

  }

}

void av1_highbd_convolve_y_sr_c(const uint16_t *src, int src_stride,

                                uint16_t *dst, int dst_stride, int w, int h,

                                const InterpFilterParams *filter_params_x,

                                const InterpFilterParams *filter_params_y,

                                const int subpel_x_q4, const int subpel_y_q4,

                                ConvolveParams *conv_params, int bd) {

  const int fo_vert = filter_params_y->taps / 2 - 1;

  (void)filter_params_x;

  (void)subpel_x_q4;

  (void)conv_params;

  assert(conv_params->round_0 <= FILTER_BITS);

  assert(((conv_params->round_0 + conv_params->round_1) <= (FILTER_BITS + 1)) ||

         ((conv_params->round_0 + conv_params->round_1) == (2 * FILTER_BITS)));

  // vertical filter

  const int16_t *y_filter = av1_get_interp_filter_subpel_kernel(

      filter_params_y, subpel_y_q4 & SUBPEL_MASK);

  for (int y = 0; y < h; ++y) {

    for (int x = 0; x < w; ++x) {

      int32_t res = 0;

      for (int k = 0; k < filter_params_y->taps; ++k) {

        res += y_filter[k] * src[(y - fo_vert + k) * src_stride + x];

      }

      dst[y * dst_stride + x] =

          clip_pixel_highbd(ROUND_POWER_OF_TWO(res, FILTER_BITS), bd);

    }

  }

}

void av1_highbd_convolve_2d_sr_c(const uint16_t *src, int src_stride,

                                 uint16_t *dst, int dst_stride, int w, int h,

                                 const InterpFilterParams *filter_params_x,

                                 const InterpFilterParams *filter_params_y,

                                 const int subpel_x_q4, const int subpel_y_q4,

                                 ConvolveParams *conv_params, int bd) {

  int16_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 bits =

      FILTER_BITS * 2 - conv_params->round_0 - conv_params->round_1;

  assert(bits >= 0);

  // 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 (int y = 0; y < im_h; ++y) {

    for (int x = 0; x < w; ++x) {

      int32_t sum = (1 << (bd + FILTER_BITS - 1));

      for (int 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)));

      im_block[y * im_stride + x] =

          ROUND_POWER_OF_TWO(sum, conv_params->round_0);

    }

  }

  // vertical filter

  int16_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);

  const int offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;

  for (int y = 0; y < h; ++y) {

    for (int x = 0; x < w; ++x) {

      int32_t sum = 1 << offset_bits;

      for (int k = 0; k < filter_params_y->taps; ++k) {

        sum += y_filter[k] * src_vert[(y - fo_vert + k) * im_stride + x];

      }

      assert(0 <= sum && sum < (1 << (offset_bits + 2)));

      int32_t 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)));

      dst[y * dst_stride + x] =

          clip_pixel_highbd(ROUND_POWER_OF_TWO(res, bits), bd);

    }

  }

}

void av1_highbd_jnt_convolve_2d_c(const uint16_t *src, int src_stride,

                                  uint16_t *dst16, int dst16_stride, int w,

                                  int h,

                                  const InterpFilterParams *filter_params_x,

                                  const InterpFilterParams *filter_params_y,

                                  const int subpel_x_q4, const int subpel_y_q4,

                                  ConvolveParams *conv_params, int bd) {

  int x, y, k;

  int16_t im_block[(MAX_SB_SIZE + MAX_FILTER_TAP - 1) * MAX_SB_SIZE];

  CONV_BUF_TYPE *dst = conv_params->dst;

  int dst_stride = conv_params->dst_stride;

  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 round_bits =

      2 * FILTER_BITS - conv_params->round_0 - conv_params->round_1;

  assert(round_bits >= 0);

  // 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)));

      (void)bd;

      im_block[y * im_stride + x] =

          (int16_t)ROUND_POWER_OF_TWO(sum, conv_params->round_0);

    }

  }

  // vertical filter

  int16_t *src_vert = im_block + fo_vert * im_stride;

  const int offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;

  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) {

      int32_t sum = 1 << offset_bits;

      for (k = 0; k < filter_params_y->taps; ++k) {

        sum += y_filter[k] * src_vert[(y - fo_vert + k) * im_stride + x];

      }

      assert(0 <= sum && sum < (1 << (offset_bits + 2)));

      CONV_BUF_TYPE res = ROUND_POWER_OF_TWO(sum, conv_params->round_1);

      if (conv_params->do_average) {

        int32_t tmp = dst[y * dst_stride + x];

        if (conv_params->use_jnt_comp_avg) {

          tmp = tmp * conv_params->fwd_offset + res * conv_params->bck_offset;

          tmp = tmp >> DIST_PRECISION_BITS;

        } else {

          tmp += res;

          tmp = tmp >> 1;

        }

        tmp -= (1 << (offset_bits - conv_params->round_1)) +

               (1 << (offset_bits - conv_params->round_1 - 1));

        dst16[y * dst16_stride + x] =

            clip_pixel_highbd(ROUND_POWER_OF_TWO(tmp, round_bits), bd);

      } else {

        dst[y * dst_stride + x] = res;

      }

    }

  }

}

void av1_highbd_jnt_convolve_x_c(const uint16_t *src, int src_stride,

                                 uint16_t *dst16, int dst16_stride, int w,

                                 int h,

                                 const InterpFilterParams *filter_params_x,

                                 const InterpFilterParams *filter_params_y,

                                 const int subpel_x_q4, const int subpel_y_q4,

                                 ConvolveParams *conv_params, int bd) {

  CONV_BUF_TYPE *dst = conv_params->dst;

  int dst_stride = conv_params->dst_stride;

  const int fo_horiz = filter_params_x->taps / 2 - 1;

  const int bits = FILTER_BITS - conv_params->round_1;

  const int offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;

  const int round_offset = (1 << (offset_bits - conv_params->round_1)) +

                           (1 << (offset_bits - conv_params->round_1 - 1));

  const int round_bits =

      2 * FILTER_BITS - conv_params->round_0 - conv_params->round_1;

  assert(round_bits >= 0);

  (void)filter_params_y;

  (void)subpel_y_q4;

  assert(bits >= 0);

  // horizontal filter

  const int16_t *x_filter = av1_get_interp_filter_subpel_kernel(

      filter_params_x, subpel_x_q4 & SUBPEL_MASK);

  for (int y = 0; y < h; ++y) {

    for (int x = 0; x < w; ++x) {

      int32_t res = 0;

      for (int k = 0; k < filter_params_x->taps; ++k) {

        res += x_filter[k] * src[y * src_stride + x - fo_horiz + k];

      }

      res = (1 << bits) * ROUND_POWER_OF_TWO(res, conv_params->round_0);

      res += round_offset;

      if (conv_params->do_average) {

        int32_t tmp = dst[y * dst_stride + x];

        if (conv_params->use_jnt_comp_avg) {

          tmp = tmp * conv_params->fwd_offset + res * conv_params->bck_offset;

          tmp = tmp >> DIST_PRECISION_BITS;

        } else {

          tmp += res;

          tmp = tmp >> 1;

        }

        tmp -= round_offset;

        dst16[y * dst16_stride + x] =

            clip_pixel_highbd(ROUND_POWER_OF_TWO(tmp, round_bits), bd);

      } else {

        dst[y * dst_stride + x] = res;

      }

    }

  }

}

void av1_highbd_jnt_convolve_y_c(const uint16_t *src, int src_stride,

                                 uint16_t *dst16, int dst16_stride, int w,

                                 int h,

                                 const InterpFilterParams *filter_params_x,

                                 const InterpFilterParams *filter_params_y,

                                 const int subpel_x_q4, const int subpel_y_q4,

                                 ConvolveParams *conv_params, int bd) {

  CONV_BUF_TYPE *dst = conv_params->dst;

  int dst_stride = conv_params->dst_stride;

  const int fo_vert = filter_params_y->taps / 2 - 1;

  const int bits = FILTER_BITS - conv_params->round_0;

  const int offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;

  const int round_offset = (1 << (offset_bits - conv_params->round_1)) +

                           (1 << (offset_bits - conv_params->round_1 - 1));

  const int round_bits =

      2 * FILTER_BITS - conv_params->round_0 - conv_params->round_1;

  assert(round_bits >= 0);