Quelle  highbd_convolve_rvv.c

/*
 * Copyright (c) 2025, 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 "config/aom_config.h"
#include "config/av1_rtcd.h"

#include "aom_dsp/riscv/mem_rvv.h"
#include "aom_ports/mem.h"
#include "av1/common/filter.h"
#include "av1/common/riscv/convolve_rvv.h"

static inline vuint16mf2_t highbd_convolve6_4_y_rvv(
    const vint16mf2_t s0, const vint16mf2_t s1, const vint16mf2_t s2,
    const vint16mf2_t s3, const vint16mf2_t s4, const vint16mf2_t s5,
    const int16_t *filter, const uint16_t max, size_t vl) {
  // Values at indices 0 and 7 of y_filter are zero.
  vint32m1_t sum = __riscv_vwmul_vx_i32m1(s0, filter[1], vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[2], s1, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[3], s2, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[4], s3, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[5], s4, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[6], s5, vl);

  // Add rounding constant and shift
  sum = __riscv_vadd_vx_i32m1(sum, 1 << (COMPOUND_ROUND1_BITS - 1), vl);

  // Narrow result to 16-bit with rounding and saturation
  vint16mf2_t res = __riscv_vnsra_wx_i16mf2(sum, COMPOUND_ROUND1_BITS, vl);

  // Clamp result to max value
  vuint16mf2_t d0 =
      __riscv_vreinterpret_v_i16mf2_u16mf2(__riscv_vmax_vx_i16mf2(res, 0, vl));
  return __riscv_vminu_vx_u16mf2(d0, max, vl);
}

static inline vuint16m1_t highbd_convolve6_8_y_rvv(
    const vint16m1_t s0, const vint16m1_t s1, const vint16m1_t s2,
    const vint16m1_t s3, const vint16m1_t s4, const vint16m1_t s5,
    const int16_t *filter, const uint16_t max, size_t vl) {
  // Values at indices 0 and 7 of y_filter are zero.
  vint32m2_t sum = __riscv_vwmul_vx_i32m2(s0, filter[1], vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[2], s1, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[3], s2, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[4], s3, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[5], s4, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[6], s5, vl);

  // Add rounding constant and shift
  sum = __riscv_vadd_vx_i32m2(sum, 1 << (COMPOUND_ROUND1_BITS - 1), vl);

  // Narrow result to 16-bit with rounding and saturation
  vint16m1_t res = __riscv_vnsra_wx_i16m1(sum, COMPOUND_ROUND1_BITS, vl);

  // Clamp result to max value
  vuint16m1_t d0 =
      __riscv_vreinterpret_v_i16m1_u16m1(__riscv_vmax_vx_i16m1(res, 0, vl));
  return __riscv_vminu_vx_u16m1(d0, max, vl);
}

static inline void highbd_convolve_y_sr_6tap_rvv(
    const uint16_t *src_ptr, int src_stride, uint16_t *dst_ptr, int dst_stride,
    int w, int h, const int16_t *y_filter, int bd) {
  const uint16_t max = (1 << bd) - 1;
  size_t vl = __riscv_vsetvl_e16m1(w);

  if (w == 4) {
    const int16_t *s = (const int16_t *)(src_ptr + src_stride);
    uint16_t *d = dst_ptr;

    // Load initial 5 rows of data
    vint16mf2_t s0, s1, s2, s3, s4;
    load_s16_4x5(s, src_stride, &s0, &s1, &s2, &s3, &s4, vl);
    s += 5 * src_stride;

    do {
      // Load next 4 rows of data
      vint16mf2_t s5, s6, s7, s8;
      load_s16_4x4(s, src_stride, &s5, &s6, &s7, &s8, vl);

      // Perform 6-tap convolution for 4 rows
      vuint16mf2_t d0 =
          highbd_convolve6_4_y_rvv(s0, s1, s2, s3, s4, s5, y_filter, max, vl);
      vuint16mf2_t d1 =
          highbd_convolve6_4_y_rvv(s1, s2, s3, s4, s5, s6, y_filter, max, vl);
      vuint16mf2_t d2 =
          highbd_convolve6_4_y_rvv(s2, s3, s4, s5, s6, s7, y_filter, max, vl);
      vuint16mf2_t d3 =
          highbd_convolve6_4_y_rvv(s3, s4, s5, s6, s7, s8, y_filter, max, vl);

      // Store results
      store_u16_4x4(d, dst_stride, d0, d1, d2, d3, vl);

      // Update source pointers for next iteration
      s0 = __riscv_vmv_v_v_i16mf2(s4, vl);
      s1 = __riscv_vmv_v_v_i16mf2(s5, vl);
      s2 = __riscv_vmv_v_v_i16mf2(s6, vl);
      s3 = __riscv_vmv_v_v_i16mf2(s7, vl);
      s4 = __riscv_vmv_v_v_i16mf2(s8, vl);

      s += 4 * src_stride;
      d += 4 * dst_stride;
      h -= 4;
    } while (h != 0);
  } else {
    do {
      int height = h;
      const int16_t *s = (const int16_t *)(src_ptr + src_stride);
      uint16_t *d = dst_ptr;

      // Load initial 5 rows of data
      vint16m1_t s0, s1, s2, s3, s4;
      load_s16_8x5(s, src_stride, &s0, &s1, &s2, &s3, &s4, vl);
      s += 5 * src_stride;

      do {
        // Load next 4 rows of data
        vint16m1_t s5, s6, s7, s8;
        load_s16_8x4(s, src_stride, &s5, &s6, &s7, &s8, vl);

        // Perform 6-tap convolution for 4 rows
        vuint16m1_t d0 =
            highbd_convolve6_8_y_rvv(s0, s1, s2, s3, s4, s5, y_filter, max, vl);
        vuint16m1_t d1 =
            highbd_convolve6_8_y_rvv(s1, s2, s3, s4, s5, s6, y_filter, max, vl);
        vuint16m1_t d2 =
            highbd_convolve6_8_y_rvv(s2, s3, s4, s5, s6, s7, y_filter, max, vl);
        vuint16m1_t d3 =
            highbd_convolve6_8_y_rvv(s3, s4, s5, s6, s7, s8, y_filter, max, vl);

        // Store results
        store_u16_8x4(d, dst_stride, d0, d1, d2, d3, vl);

        // Update source pointers for next iteration
        s0 = __riscv_vmv_v_v_i16m1(s4, vl);
        s1 = __riscv_vmv_v_v_i16m1(s5, vl);
        s2 = __riscv_vmv_v_v_i16m1(s6, vl);
        s3 = __riscv_vmv_v_v_i16m1(s7, vl);
        s4 = __riscv_vmv_v_v_i16m1(s8, vl);

        s += 4 * src_stride;
        d += 4 * dst_stride;
        height -= 4;
      } while (height != 0);

      src_ptr += vl;
      dst_ptr += vl;
      w -= vl;
    } while (w > 0);
  }
}

static inline vuint16mf2_t highbd_convolve8_4_y_rvv(
    const vint16mf2_t s0, const vint16mf2_t s1, const vint16mf2_t s2,
    const vint16mf2_t s3, const vint16mf2_t s4, const vint16mf2_t s5,
    const vint16mf2_t s6, const vint16mf2_t s7, const int16_t *filter,
    const uint16_t max, size_t vl) {
  vint32m1_t sum = __riscv_vwmul_vx_i32m1(s0, filter[0], vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[1], s1, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[2], s2, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[3], s3, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[4], s4, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[5], s5, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[6], s6, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[7], s7, vl);

  // Convert to unsigned 16-bit with saturation
  vuint32m1_t d0 =
      __riscv_vreinterpret_v_i32m1_u32m1(__riscv_vmax_vx_i32m1(sum, 0, vl));
  vuint16mf2_t res =
      __riscv_vnclipu_wx_u16mf2(d0, COMPOUND_ROUND1_BITS, __RISCV_VXRM_RNU, vl);

  // Clamp to max
  return __riscv_vminu_vx_u16mf2(res, max, vl);
}

static inline vuint16m1_t highbd_convolve8_8_y_rvv(
    const vint16m1_t s0, const vint16m1_t s1, const vint16m1_t s2,
    const vint16m1_t s3, const vint16m1_t s4, const vint16m1_t s5,
    const vint16m1_t s6, const vint16m1_t s7, const int16_t *filter,
    const uint16_t max, size_t vl) {
  vint32m2_t sum = __riscv_vwmul_vx_i32m2(s0, filter[0], vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[1], s1, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[2], s2, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[3], s3, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[4], s4, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[5], s5, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[6], s6, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[7], s7, vl);

  // Convert to unsigned 16-bit with saturation
  vuint32m2_t d0 =
      __riscv_vreinterpret_v_i32m2_u32m2(__riscv_vmax_vx_i32m2(sum, 0, vl));
  vuint16m1_t res =
      __riscv_vnclipu_wx_u16m1(d0, COMPOUND_ROUND1_BITS, __RISCV_VXRM_RNU, vl);

  // Clamp to max
  return __riscv_vminu_vx_u16m1(res, max, vl);
}

static inline void highbd_convolve_y_sr_8tap_rvv(
    const uint16_t *src_ptr, int src_stride, uint16_t *dst_ptr, int dst_stride,
    int w, int h, const int16_t *y_filter, int bd) {
  const uint16_t max = (1 << bd) - 1;
  size_t vl = __riscv_vsetvl_e16m1(w);

  if (w == 4) {
    const int16_t *s = (const int16_t *)src_ptr;
    uint16_t *d = dst_ptr;

    // Load initial 7 rows of data
    vint16mf2_t s0, s1, s2, s3, s4, s5, s6;
    load_s16_4x7(s, src_stride, &s0, &s1, &s2, &s3, &s4, &s5, &s6, vl);
    s += 7 * src_stride;

    do {
      // Load next 4 rows of data
      vint16mf2_t s7, s8, s9, s10;
      load_s16_4x4(s, src_stride, &s7, &s8, &s9, &s10, vl);

      // Perform 8-tap convolution for 4 rows
      vuint16mf2_t d0 = highbd_convolve8_4_y_rvv(s0, s1, s2, s3, s4, s5, s6, s7,
                                                 y_filter, max, vl);
      vuint16mf2_t d1 = highbd_convolve8_4_y_rvv(s1, s2, s3, s4, s5, s6, s7, s8,
                                                 y_filter, max, vl);
      vuint16mf2_t d2 = highbd_convolve8_4_y_rvv(s2, s3, s4, s5, s6, s7, s8, s9,
                                                 y_filter, max, vl);
      vuint16mf2_t d3 = highbd_convolve8_4_y_rvv(s3, s4, s5, s6, s7, s8, s9,
                                                 s10, y_filter, max, vl);

      // Store results
      store_u16_4x4(d, dst_stride, d0, d1, d2, d3, vl);

      // Update source pointers for next iteration
      s0 = __riscv_vmv_v_v_i16mf2(s4, vl);
      s1 = __riscv_vmv_v_v_i16mf2(s5, vl);
      s2 = __riscv_vmv_v_v_i16mf2(s6, vl);
      s3 = __riscv_vmv_v_v_i16mf2(s7, vl);
      s4 = __riscv_vmv_v_v_i16mf2(s8, vl);
      s5 = __riscv_vmv_v_v_i16mf2(s9, vl);
      s6 = __riscv_vmv_v_v_i16mf2(s10, vl);

      s += 4 * src_stride;
      d += 4 * dst_stride;
      h -= 4;
    } while (h != 0);
  } else {
    do {
      int height = h;
      const int16_t *s = (const int16_t *)src_ptr;
      uint16_t *d = dst_ptr;

      // Load initial 7 rows of data
      vint16m1_t s0, s1, s2, s3, s4, s5, s6;
      load_s16_8x7(s, src_stride, &s0, &s1, &s2, &s3, &s4, &s5, &s6, vl);
      s += 7 * src_stride;

      do {
        // Load next 4 rows of data
        vint16m1_t s7, s8, s9, s10;
        load_s16_8x4(s, src_stride, &s7, &s8, &s9, &s10, vl);

        // Perform 8-tap convolution for 4 rows
        vuint16m1_t d0 = highbd_convolve8_8_y_rvv(s0, s1, s2, s3, s4, s5, s6,
                                                  s7, y_filter, max, vl);
        vuint16m1_t d1 = highbd_convolve8_8_y_rvv(s1, s2, s3, s4, s5, s6, s7,
                                                  s8, y_filter, max, vl);
        vuint16m1_t d2 = highbd_convolve8_8_y_rvv(s2, s3, s4, s5, s6, s7, s8,
                                                  s9, y_filter, max, vl);
        vuint16m1_t d3 = highbd_convolve8_8_y_rvv(s3, s4, s5, s6, s7, s8, s9,
                                                  s10, y_filter, max, vl);

        // Store results
        store_u16_8x4(d, dst_stride, d0, d1, d2, d3, vl);

        // Update source pointers for next iteration
        s0 = __riscv_vmv_v_v_i16m1(s4, vl);
        s1 = __riscv_vmv_v_v_i16m1(s5, vl);
        s2 = __riscv_vmv_v_v_i16m1(s6, vl);
        s3 = __riscv_vmv_v_v_i16m1(s7, vl);
        s4 = __riscv_vmv_v_v_i16m1(s8, vl);
        s5 = __riscv_vmv_v_v_i16m1(s9, vl);
        s6 = __riscv_vmv_v_v_i16m1(s10, vl);

        s += 4 * src_stride;
        d += 4 * dst_stride;
        height -= 4;
      } while (height != 0);

      src_ptr += vl;
      dst_ptr += vl;
      w -= vl;
    } while (w > 0);
  }
}

static inline vuint16mf2_t highbd_convolve12_4_y_rvv(
    const vint16mf2_t s0, const vint16mf2_t s1, const vint16mf2_t s2,
    const vint16mf2_t s3, const vint16mf2_t s4, const vint16mf2_t s5,
    const vint16mf2_t s6, const vint16mf2_t s7, const vint16mf2_t s8,
    const vint16mf2_t s9, const vint16mf2_t s10, const vint16mf2_t s11,
    const int16_t *filter, const uint16_t max, size_t vl) {
  vint32m1_t sum = __riscv_vwmul_vx_i32m1(s0, filter[0], vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[1], s1, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[2], s2, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[3], s3, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[4], s4, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[5], s5, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[6], s6, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[7], s7, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[8], s8, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[9], s9, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[10], s10, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[11], s11, vl);

  // Convert to unsigned 16-bit with saturation
  vuint32m1_t d0 =
      __riscv_vreinterpret_v_i32m1_u32m1(__riscv_vmax_vx_i32m1(sum, 0, vl));
  vuint16mf2_t res =
      __riscv_vnclipu_wx_u16mf2(d0, COMPOUND_ROUND1_BITS, __RISCV_VXRM_RNU, vl);

  // Clamp to max
  return __riscv_vminu_vx_u16mf2(res, max, vl);
}

static inline vuint16m1_t highbd_convolve12_8_y_rvv(
    const vint16m1_t s0, const vint16m1_t s1, const vint16m1_t s2,
    const vint16m1_t s3, const vint16m1_t s4, const vint16m1_t s5,
    const vint16m1_t s6, const vint16m1_t s7, const vint16m1_t s8,
    const vint16m1_t s9, const vint16m1_t s10, const vint16m1_t s11,
    const int16_t *filter, const uint16_t max, size_t vl) {
  vint32m2_t sum = __riscv_vwmul_vx_i32m2(s0, filter[0], vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[1], s1, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[2], s2, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[3], s3, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[4], s4, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[5], s5, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[6], s6, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[7], s7, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[8], s8, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[9], s9, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[10], s10, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[11], s11, vl);

  // Convert to unsigned 16-bit with saturation
  vuint32m2_t d0 =
      __riscv_vreinterpret_v_i32m2_u32m2(__riscv_vmax_vx_i32m2(sum, 0, vl));
  vuint16m1_t res =
      __riscv_vnclipu_wx_u16m1(d0, COMPOUND_ROUND1_BITS, __RISCV_VXRM_RNU, vl);

  // Clamp to max
  return __riscv_vminu_vx_u16m1(res, max, vl);
}

static inline void highbd_convolve_y_sr_12tap_rvv(
    const uint16_t *src_ptr, int src_stride, uint16_t *dst_ptr, int dst_stride,
    int w, int h, const int16_t *y_filter, int bd) {
  const uint16_t max = (1 << bd) - 1;
  size_t vl = __riscv_vsetvl_e16m1(w);

  if (w == 4) {
    const int16_t *s = (const int16_t *)src_ptr;
    uint16_t *d = dst_ptr;

    // Load initial 11 rows of data
    vint16mf2_t s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
    load_s16_4x11(s, src_stride, &s0, &s1, &s2, &s3, &s4, &s5, &s6, &s7, &s8,
                  &s9, &s10, vl);
    s += 11 * src_stride;

    do {
      // Load next 4 rows of data
      vint16mf2_t s11, s12, s13, s14;
      load_s16_4x4(s, src_stride, &s11, &s12, &s13, &s14, vl);

      // Perform 12-tap convolution for 4 rows
      vuint16mf2_t d0 = highbd_convolve12_4_y_rvv(
          s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, y_filter, max, vl);
      vuint16mf2_t d1 = highbd_convolve12_4_y_rvv(
          s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, y_filter, max, vl);
      vuint16mf2_t d2 =
          highbd_convolve12_4_y_rvv(s2, s3, s4, s5, s6, s7, s8, s9, s10, s11,
                                    s12, s13, y_filter, max, vl);
      vuint16mf2_t d3 =
          highbd_convolve12_4_y_rvv(s3, s4, s5, s6, s7, s8, s9, s10, s11, s12,
                                    s13, s14, y_filter, max, vl);

      // Store results
      store_u16_4x4(d, dst_stride, d0, d1, d2, d3, vl);

      // Update source pointers for next iteration
      s0 = __riscv_vmv_v_v_i16mf2(s4, vl);
      s1 = __riscv_vmv_v_v_i16mf2(s5, vl);
      s2 = __riscv_vmv_v_v_i16mf2(s6, vl);
      s3 = __riscv_vmv_v_v_i16mf2(s7, vl);
      s4 = __riscv_vmv_v_v_i16mf2(s8, vl);
      s5 = __riscv_vmv_v_v_i16mf2(s9, vl);
      s6 = __riscv_vmv_v_v_i16mf2(s10, vl);
      s7 = __riscv_vmv_v_v_i16mf2(s11, vl);
      s8 = __riscv_vmv_v_v_i16mf2(s12, vl);
      s9 = __riscv_vmv_v_v_i16mf2(s13, vl);
      s10 = __riscv_vmv_v_v_i16mf2(s14, vl);

      s += 4 * src_stride;
      d += 4 * dst_stride;
      h -= 4;
    } while (h != 0);
  } else {
    do {
      int height = h;
      const int16_t *s = (const int16_t *)src_ptr;
      uint16_t *d = dst_ptr;

      // Load initial 11 rows of data
      vint16m1_t s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
      load_s16_8x11(s, src_stride, &s0, &s1, &s2, &s3, &s4, &s5, &s6, &s7, &s8,
                    &s9, &s10, vl);
      s += 11 * src_stride;

      do {
        // Load next 4 rows of data
        vint16m1_t s11, s12, s13, s14;
        load_s16_8x4(s, src_stride, &s11, &s12, &s13, &s14, vl);

        // Perform 12-tap convolution for 4 rows
        vuint16m1_t d0 =
            highbd_convolve12_8_y_rvv(s0, s1, s2, s3, s4, s5, s6, s7, s8, s9,
                                      s10, s11, y_filter, max, vl);
        vuint16m1_t d1 =
            highbd_convolve12_8_y_rvv(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10,
                                      s11, s12, y_filter, max, vl);
        vuint16m1_t d2 =
            highbd_convolve12_8_y_rvv(s2, s3, s4, s5, s6, s7, s8, s9, s10, s11,
                                      s12, s13, y_filter, max, vl);
        vuint16m1_t d3 =
            highbd_convolve12_8_y_rvv(s3, s4, s5, s6, s7, s8, s9, s10, s11, s12,
                                      s13, s14, y_filter, max, vl);

        // Store results
        store_u16_8x4(d, dst_stride, d0, d1, d2, d3, vl);

        // Update source pointers for next iteration
        s0 = __riscv_vmv_v_v_i16m1(s4, vl);
        s1 = __riscv_vmv_v_v_i16m1(s5, vl);
        s2 = __riscv_vmv_v_v_i16m1(s6, vl);
        s3 = __riscv_vmv_v_v_i16m1(s7, vl);
        s4 = __riscv_vmv_v_v_i16m1(s8, vl);
        s5 = __riscv_vmv_v_v_i16m1(s9, vl);
        s6 = __riscv_vmv_v_v_i16m1(s10, vl);
        s7 = __riscv_vmv_v_v_i16m1(s11, vl);
        s8 = __riscv_vmv_v_v_i16m1(s12, vl);
        s9 = __riscv_vmv_v_v_i16m1(s13, vl);
        s10 = __riscv_vmv_v_v_i16m1(s14, vl);

        s += 4 * src_stride;
        d += 4 * dst_stride;
        height -= 4;
      } while (height != 0);

      src_ptr += vl;
      dst_ptr += vl;
      w -= vl;
    } while (w > 0);
  }
}

void av1_highbd_convolve_y_sr_rvv(const uint16_t *src, int src_stride,
                                  uint16_t *dst, int dst_stride, int w, int h,
                                  const InterpFilterParams *filter_params_y,
                                  const int subpel_y_qn, int bd) {
  if (w == 2 || h == 2) {
    av1_highbd_convolve_y_sr_c(src, src_stride, dst, dst_stride, w, h,
                               filter_params_y, subpel_y_qn, bd);
    return;
  }

  const int y_filter_taps = get_filter_tap(filter_params_y, subpel_y_qn);
  const int vert_offset = filter_params_y->taps / 2 - 1;
  const int16_t *y_filter_ptr = av1_get_interp_filter_subpel_kernel(
      filter_params_y, subpel_y_qn & SUBPEL_MASK);

  src -= vert_offset * src_stride;

  if (y_filter_taps > 8) {
    highbd_convolve_y_sr_12tap_rvv(src, src_stride, dst, dst_stride, w, h,
                                   y_filter_ptr, bd);
    return;
  }
  if (y_filter_taps < 8) {
    highbd_convolve_y_sr_6tap_rvv(src, src_stride, dst, dst_stride, w, h,
                                  y_filter_ptr, bd);
    return;
  }

  highbd_convolve_y_sr_8tap_rvv(src, src_stride, dst, dst_stride, w, h,
                                y_filter_ptr, bd);
}

static inline vuint16m1_t highbd_convolve6_8_x_rvv(
    const vint16m1_t s0, const vint16m1_t s1, const vint16m1_t s2,
    const vint16m1_t s3, const vint16m1_t s4, const vint16m1_t s5,
    const int16_t *filter, const int32_t offset, const uint16_t max,
    size_t vl) {
  // Values at indices 0 and 7 of y_filter are zero.
  vint32m2_t sum = __riscv_vwmul_vx_i32m2(s0, filter[1], vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[2], s1, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[3], s2, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[4], s3, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[5], s4, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[6], s5, vl);

  // Add rounding constant and offset
  sum = __riscv_vadd_vx_i32m2(sum, (1 << (FILTER_BITS - 1)) + offset, vl);

  // Narrow result to 16-bit with rounding and saturation
  vint16m1_t res = __riscv_vnsra_wx_i16m1(sum, FILTER_BITS, vl);

  // Clamp result to max value
  vuint16m1_t d0 =
      __riscv_vreinterpret_v_i16m1_u16m1(__riscv_vmax_vx_i16m1(res, 0, vl));
  return __riscv_vminu_vx_u16m1(d0, max, vl);
}

static inline void highbd_convolve_x_sr_6tap_rvv(
    const uint16_t *src_ptr, int src_stride, uint16_t *dst_ptr, int dst_stride,
    int w, int h, const int16_t *x_filter, ConvolveParams *conv_params,
    int bd) {
  const uint16_t max = (1 << bd) - 1;
  // This shim allows to do only one rounding shift instead of two.
  const int32_t offset = 1 << (conv_params->round_0 - 1);

  int height = h;
  size_t vl = __riscv_vsetvl_e16m1(w);

  do {
    int width = w;
    const int16_t *s = (const int16_t *)src_ptr;
    uint16_t *d = dst_ptr;

    do {
      vint16m1_t s00, s01, s02, s03, s04, s05;
      vint16m1_t s10, s11, s12, s13, s14, s15;
      vint16m1_t s20, s21, s22, s23, s24, s25;
      vint16m1_t s30, s31, s32, s33, s34, s35;

      // Load 6 elements for each of 4 rows
      load_s16_8x6(s + 0 * src_stride, 1, &s00, &s01, &s02, &s03, &s04, &s05,
                   vl);
      load_s16_8x6(s + 1 * src_stride, 1, &s10, &s11, &s12, &s13, &s14, &s15,
                   vl);
      load_s16_8x6(s + 2 * src_stride, 1, &s20, &s21, &s22, &s23, &s24, &s25,
                   vl);
      load_s16_8x6(s + 3 * src_stride, 1, &s30, &s31, &s32, &s33, &s34, &s35,
                   vl);

      // Perform convolution
      vuint16m1_t d0 = highbd_convolve6_8_x_rvv(s00, s01, s02, s03, s04, s05,
                                                x_filter, offset, max, vl);
      vuint16m1_t d1 = highbd_convolve6_8_x_rvv(s10, s11, s12, s13, s14, s15,
                                                x_filter, offset, max, vl);
      vuint16m1_t d2 = highbd_convolve6_8_x_rvv(s20, s21, s22, s23, s24, s25,
                                                x_filter, offset, max, vl);
      vuint16m1_t d3 = highbd_convolve6_8_x_rvv(s30, s31, s32, s33, s34, s35,
                                                x_filter, offset, max, vl);

      // Store results
      store_u16_8x4(d, dst_stride, d0, d1, d2, d3, vl);

      s += vl;
      d += vl;
      width -= vl;
    } while (width > 0);

    src_ptr += 4 * src_stride;
    dst_ptr += 4 * dst_stride;
    height -= 4;
  } while (height != 0);
}

static inline vuint16mf2_t highbd_convolve4_4_x_rvv(
    const vint16mf2_t s0, const vint16mf2_t s1, const vint16mf2_t s2,
    const vint16mf2_t s3, const int16_t *filter, const int32_t offset,
    const uint16_t max, size_t vl) {
  vint32m1_t sum = __riscv_vwmul_vx_i32m1(s0, filter[0], vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[1], s1, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[2], s2, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[3], s3, vl);

  // Add rounding constant and offset
  sum = __riscv_vadd_vx_i32m1(sum, (1 << (FILTER_BITS - 1)) + offset, vl);

  // Narrow result to 16-bit with rounding and saturation
  vint16mf2_t res = __riscv_vnsra_wx_i16mf2(sum, FILTER_BITS, vl);

  // Clamp result to max value
  vuint16mf2_t d0 =
      __riscv_vreinterpret_v_i16mf2_u16mf2(__riscv_vmax_vx_i16mf2(res, 0, vl));
  return __riscv_vminu_vx_u16mf2(d0, max, vl);
}

static inline vuint16m1_t highbd_convolve8_8_x_rvv(
    const vint16m1_t s0, const vint16m1_t s1, const vint16m1_t s2,
    const vint16m1_t s3, const vint16m1_t s4, const vint16m1_t s5,
    const vint16m1_t s6, const vint16m1_t s7, const int16_t *filter,
    const int32_t offset, const uint16_t max, size_t vl) {
  vint32m2_t sum = __riscv_vwmul_vx_i32m2(s0, filter[0], vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[1], s1, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[2], s2, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[3], s3, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[4], s4, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[5], s5, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[6], s6, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[7], s7, vl);

  sum = __riscv_vwadd_wx_i32m2(sum, offset, vl);

  // Convert to unsigned 16-bit with saturation
  vuint32m2_t d0 =
      __riscv_vreinterpret_v_i32m2_u32m2(__riscv_vmax_vx_i32m2(sum, 0, vl));
  vuint16m1_t res =
      __riscv_vnclipu_wx_u16m1(d0, FILTER_BITS, __RISCV_VXRM_RNU, vl);

  // Clamp to max
  return __riscv_vminu_vx_u16m1(res, max, vl);
}

static inline void highbd_convolve_x_sr_rvv(const uint16_t *src_ptr,
                                            int src_stride, uint16_t *dst_ptr,
                                            int dst_stride, int w, int h,
                                            const int16_t *x_filter,
                                            ConvolveParams *conv_params,
                                            int bd) {
  // This shim allows to do only one rounding shift instead of two.
  const int32_t offset = 1 << (conv_params->round_0 - 1);
  const uint16_t max = (1 << bd) - 1;
  size_t vl = __riscv_vsetvl_e16m1(w);

  if (w == 4) {
    // 4-tap filters are used for blocks having width == 4.
    const int16_t *s = (const int16_t *)(src_ptr + 2);
    uint16_t *d = dst_ptr;
    const int16_t *x_filter_ptr = x_filter + 2;

    do {
      vint16mf2_t s00, s01, s02, s03;
      vint16mf2_t s10, s11, s12, s13;
      vint16mf2_t s20, s21, s22, s23;
      vint16mf2_t s30, s31, s32, s33;

      // Load pixels from each of 4 rows
      load_s16_4x4(s + 0 * src_stride, 1, &s00, &s01, &s02, &s03, vl);
      load_s16_4x4(s + 1 * src_stride, 1, &s10, &s11, &s12, &s13, vl);
      load_s16_4x4(s + 2 * src_stride, 1, &s20, &s21, &s22, &s23, vl);
      load_s16_4x4(s + 3 * src_stride, 1, &s30, &s31, &s32, &s33, vl);

      // Perform convolution for 4 rows
      vuint16mf2_t d0 = highbd_convolve4_4_x_rvv(s00, s01, s02, s03,
                                                 x_filter_ptr, offset, max, vl);
      vuint16mf2_t d1 = highbd_convolve4_4_x_rvv(s10, s11, s12, s13,
                                                 x_filter_ptr, offset, max, vl);
      vuint16mf2_t d2 = highbd_convolve4_4_x_rvv(s20, s21, s22, s23,
                                                 x_filter_ptr, offset, max, vl);
      vuint16mf2_t d3 = highbd_convolve4_4_x_rvv(s30, s31, s32, s33,
                                                 x_filter_ptr, offset, max, vl);

      // Store results
      store_u16_4x4(d, dst_stride, d0, d1, d2, d3, vl);

      s += 4 * src_stride;
      d += 4 * dst_stride;
      h -= 4;
    } while (h != 0);
  } else {
    int height = h;
    do {
      int width = w;
      const int16_t *s = (const int16_t *)src_ptr;
      uint16_t *d = dst_ptr;

      do {
        vint16m1_t s00, s01, s02, s03, s04, s05, s06, s07;
        vint16m1_t s10, s11, s12, s13, s14, s15, s16, s17;
        vint16m1_t s20, s21, s22, s23, s24, s25, s26, s27;
        vint16m1_t s30, s31, s32, s33, s34, s35, s36, s37;

        // Load elements for each of 4 rows
        load_s16_8x8(s + 0 * src_stride, 1, &s00, &s01, &s02, &s03, &s04, &s05,
                     &s06, &s07, vl);
        load_s16_8x8(s + 1 * src_stride, 1, &s10, &s11, &s12, &s13, &s14, &s15,
                     &s16, &s17, vl);
        load_s16_8x8(s + 2 * src_stride, 1, &s20, &s21, &s22, &s23, &s24, &s25,
                     &s26, &s27, vl);
        load_s16_8x8(s + 3 * src_stride, 1, &s30, &s31, &s32, &s33, &s34, &s35,
                     &s36, &s37, vl);

        // Perform convolution
        vuint16m1_t d0 = highbd_convolve8_8_x_rvv(
            s00, s01, s02, s03, s04, s05, s06, s07, x_filter, offset, max, vl);
        vuint16m1_t d1 = highbd_convolve8_8_x_rvv(
            s10, s11, s12, s13, s14, s15, s16, s17, x_filter, offset, max, vl);
        vuint16m1_t d2 = highbd_convolve8_8_x_rvv(
            s20, s21, s22, s23, s24, s25, s26, s27, x_filter, offset, max, vl);
        vuint16m1_t d3 = highbd_convolve8_8_x_rvv(
            s30, s31, s32, s33, s34, s35, s36, s37, x_filter, offset, max, vl);

        // Store results
        store_u16_8x4(d, dst_stride, d0, d1, d2, d3, vl);

        s += vl;
        d += vl;
        width -= vl;
      } while (width > 0);

      src_ptr += 4 * src_stride;
      dst_ptr += 4 * dst_stride;
      height -= 4;
    } while (height != 0);
  }
}

static inline vuint16mf2_t highbd_convolve12_4_x_rvv(
    const vint16mf2_t s0, const vint16mf2_t s1, const vint16mf2_t s2,
    const vint16mf2_t s3, const vint16mf2_t s4, const vint16mf2_t s5,
    const vint16mf2_t s6, const vint16mf2_t s7, const vint16mf2_t s8,
    const vint16mf2_t s9, const vint16mf2_t s10, const vint16mf2_t s11,
    const int16_t *filter, const int32_t offset, const uint16_t max,
    size_t vl) {
  vint32m1_t sum = __riscv_vwmul_vx_i32m1(s0, filter[0], vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[1], s1, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[2], s2, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[3], s3, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[4], s4, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[5], s5, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[6], s6, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[7], s7, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[8], s8, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[9], s9, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[10], s10, vl);
  sum = __riscv_vwmacc_vx_i32m1(sum, filter[11], s11, vl);
  sum = __riscv_vwadd_wx_i32m1(sum, offset, vl);

  // Convert to unsigned 16-bit with saturation
  vuint32m1_t d0 =
      __riscv_vreinterpret_v_i32m1_u32m1(__riscv_vmax_vx_i32m1(sum, 0, vl));
  vuint16mf2_t res =
      __riscv_vnclipu_wx_u16mf2(d0, FILTER_BITS, __RISCV_VXRM_RNU, vl);

  // Clamp to max
  return __riscv_vminu_vx_u16mf2(res, max, vl);
}

static inline vuint16m1_t highbd_convolve12_8_x_rvv(
    const vint16m1_t s0, const vint16m1_t s1, const vint16m1_t s2,
    const vint16m1_t s3, const vint16m1_t s4, const vint16m1_t s5,
    const vint16m1_t s6, const vint16m1_t s7, const vint16m1_t s8,
    const vint16m1_t s9, const vint16m1_t s10, const vint16m1_t s11,
    const int16_t *filter, const int32_t offset, const uint16_t max,
    size_t vl) {
  vint32m2_t sum = __riscv_vwmul_vx_i32m2(s0, filter[0], vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[1], s1, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[2], s2, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[3], s3, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[4], s4, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[5], s5, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[6], s6, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[7], s7, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[8], s8, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[9], s9, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[10], s10, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, filter[11], s11, vl);
  sum = __riscv_vwadd_wx_i32m2(sum, offset, vl);

  // Convert to unsigned 16-bit with saturation
  vuint32m2_t d0 =
      __riscv_vreinterpret_v_i32m2_u32m2(__riscv_vmax_vx_i32m2(sum, 0, vl));
  vuint16m1_t res =
      __riscv_vnclipu_wx_u16m1(d0, FILTER_BITS, __RISCV_VXRM_RNU, vl);

  // Clamp to max
  return __riscv_vminu_vx_u16m1(res, max, vl);
}

static inline void highbd_convolve_x_sr_12tap_rvv(
    const uint16_t *src_ptr, int src_stride, uint16_t *dst_ptr, int dst_stride,
    int w, int h, const int16_t *x_filter, ConvolveParams *conv_params,
    int bd) {
  // This shim allows to do only one rounding shift instead of two.
  const int32_t offset = 1 << (conv_params->round_0 - 1);
  const uint16_t max = (1 << bd) - 1;
  size_t vl = __riscv_vsetvl_e16m1(w);

  if (w == 4) {
    const int16_t *s = (const int16_t *)src_ptr;
    uint16_t *d = dst_ptr;

    do {
      vint16mf2_t s00, s01, s02, s03, s04, s05, s06, s07, s08, s09, s010, s011;
      vint16mf2_t s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s110, s111;
      vint16mf2_t s20, s21, s22, s23, s24, s25, s26, s27, s28, s29, s210, s211;
      vint16mf2_t s30, s31, s32, s33, s34, s35, s36, s37, s38, s39, s310, s311;

      // Load elements for each of 4 rows
      load_s16_4x12(s + 0 * src_stride, 1, &s00, &s01, &s02, &s03, &s04, &s05,
                    &s06, &s07, &s08, &s09, &s010, &s011, vl);
      load_s16_4x12(s + 1 * src_stride, 1, &s10, &s11, &s12, &s13, &s14, &s15,
                    &s16, &s17, &s18, &s19, &s110, &s111, vl);
      load_s16_4x12(s + 2 * src_stride, 1, &s20, &s21, &s22, &s23, &s24, &s25,
                    &s26, &s27, &s28, &s29, &s210, &s211, vl);
      load_s16_4x12(s + 3 * src_stride, 1, &s30, &s31, &s32, &s33, &s34, &s35,
                    &s36, &s37, &s38, &s39, &s310, &s311, vl);

      // Perform convolution
      vuint16mf2_t d0 =
          highbd_convolve12_4_x_rvv(s00, s01, s02, s03, s04, s05, s06, s07, s08,
                                    s09, s010, s011, x_filter, offset, max, vl);
      vuint16mf2_t d1 =
          highbd_convolve12_4_x_rvv(s10, s11, s12, s13, s14, s15, s16, s17, s18,
                                    s19, s110, s111, x_filter, offset, max, vl);
      vuint16mf2_t d2 =
          highbd_convolve12_4_x_rvv(s20, s21, s22, s23, s24, s25, s26, s27, s28,
                                    s29, s210, s211, x_filter, offset, max, vl);
      vuint16mf2_t d3 =
          highbd_convolve12_4_x_rvv(s30, s31, s32, s33, s34, s35, s36, s37, s38,
                                    s39, s310, s311, x_filter, offset, max, vl);

      // Store results
      store_u16_4x4(d, dst_stride, d0, d1, d2, d3, vl);

      s += 4 * src_stride;
      d += 4 * dst_stride;
      h -= 4;
    } while (h != 0);
  } else {
    int height = h;
    do {
      const int16_t *s = (const int16_t *)src_ptr;
      uint16_t *d = dst_ptr;
      int width = w;

      do {
        vint16m1_t s00, s01, s02, s03, s04, s05, s06, s07, s08, s09, s010, s011;
        vint16m1_t s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s110, s111;
        vint16m1_t s20, s21, s22, s23, s24, s25, s26, s27, s28, s29, s210, s211;
        vint16m1_t s30, s31, s32, s33, s34, s35, s36, s37, s38, s39, s310, s311;

        // Load elements for each of 4 rows
        load_s16_8x12(s + 0 * src_stride, 1, &s00, &s01, &s02, &s03, &s04, &s05,
                      &s06, &s07, &s08, &s09, &s010, &s011, vl);
        load_s16_8x12(s + 1 * src_stride, 1, &s10, &s11, &s12, &s13, &s14, &s15,
                      &s16, &s17, &s18, &s19, &s110, &s111, vl);
        load_s16_8x12(s + 2 * src_stride, 1, &s20, &s21, &s22, &s23, &s24, &s25,
                      &s26, &s27, &s28, &s29, &s210, &s211, vl);
        load_s16_8x12(s + 3 * src_stride, 1, &s30, &s31, &s32, &s33, &s34, &s35,
                      &s36, &s37, &s38, &s39, &s310, &s311, vl);

        // Perform convolution
        vuint16m1_t d0 = highbd_convolve12_8_x_rvv(
            s00, s01, s02, s03, s04, s05, s06, s07, s08, s09, s010, s011,
            x_filter, offset, max, vl);
        vuint16m1_t d1 = highbd_convolve12_8_x_rvv(
            s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s110, s111,
            x_filter, offset, max, vl);
        vuint16m1_t d2 = highbd_convolve12_8_x_rvv(
            s20, s21, s22, s23, s24, s25, s26, s27, s28, s29, s210, s211,
            x_filter, offset, max, vl);
        vuint16m1_t d3 = highbd_convolve12_8_x_rvv(
            s30, s31, s32, s33, s34, s35, s36, s37, s38, s39, s310, s311,
            x_filter, offset, max, vl);

        // Store results
        store_u16_8x4(d, dst_stride, d0, d1, d2, d3, vl);

        s += vl;
        d += vl;
        width -= vl;
      } while (width > 0);

      src_ptr += 4 * src_stride;
      dst_ptr += 4 * dst_stride;
      height -= 4;
    } while (height != 0);
  }
}

void av1_highbd_convolve_x_sr_rvv(const uint16_t *src, int src_stride,
                                  uint16_t *dst, int dst_stride, int w, int h,
                                  const InterpFilterParams *filter_params_x,
                                  const int subpel_x_qn,
                                  ConvolveParams *conv_params, int bd) {
  if (w == 2 || h == 2) {
    av1_highbd_convolve_x_sr_c(src, src_stride, dst, dst_stride, w, h,
                               filter_params_x, subpel_x_qn, conv_params, bd);
    return;
  }
  const int x_filter_taps = get_filter_tap(filter_params_x, subpel_x_qn);
  const int horiz_offset = filter_params_x->taps / 2 - 1;
  const int16_t *x_filter_ptr = av1_get_interp_filter_subpel_kernel(
      filter_params_x, subpel_x_qn & SUBPEL_MASK);

  src -= horiz_offset;

  if (x_filter_taps > 8) {
    highbd_convolve_x_sr_12tap_rvv(src, src_stride, dst, dst_stride, w, h,
                                   x_filter_ptr, conv_params, bd);
    return;
  }
  if (x_filter_taps <= 6 && w != 4) {
    highbd_convolve_x_sr_6tap_rvv(src + 1, src_stride, dst, dst_stride, w, h,
                                  x_filter_ptr, conv_params, bd);
    return;
  }

  highbd_convolve_x_sr_rvv(src, src_stride, dst, dst_stride, w, h, x_filter_ptr,
                           conv_params, bd);
}

// store_strided_u16_4xN
static inline void store_strided_u16_4xN(uint16_t *addr, vuint16m1_t vdst,
                                         ptrdiff_t stride, size_t vl) {
  __riscv_vse16_v_u16m1(addr, vdst, vl >> 1);
  vdst = __riscv_vslidedown_vx_u16m1(vdst, vl >> 1, vl);
  __riscv_vse16_v_u16m1(addr + stride, vdst, vl >> 1);
}

static inline vuint16m1_t highbd_convolve12_2d_v_rvv(
    const vint16m1_t s0, const vint16m1_t s1, const vint16m1_t s2,
    const vint16m1_t s3, const vint16m1_t s4, const vint16m1_t s5,
    const vint16m1_t s6, const vint16m1_t s7, const vint16m1_t s8,
    const vint16m1_t s9, const vint16m1_t s10, const vint16m1_t s11,
    const int16_t *y_filter, const int32_t offset, const int32_t shift,
    const uint16_t max, size_t vl) {
  vint32m2_t sum = __riscv_vwmul_vx_i32m2(s0, y_filter[0], vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[1], s1, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[2], s2, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[3], s3, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[4], s4, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[5], s5, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[6], s6, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[7], s7, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[8], s8, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[9], s9, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[10], s10, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[11], s11, vl);
  sum = __riscv_vadd_vx_i32m2(sum, offset, vl);

  vint16m1_t i16_sum = __riscv_vnsra_wx_i16m1(sum, shift, vl);
  vint16m1_t iclip_sum =
      __riscv_vmin_vx_i16m1(__riscv_vmax_vx_i16m1(i16_sum, 0, vl), max, vl);
  return __riscv_vreinterpret_v_i16m1_u16m1(iclip_sum);
}

static inline void highbd_convolve_2d_sr_vert_12tap_rvv(
    const uint16_t *src_ptr, int src_stride, uint16_t *dst_ptr, int dst_stride,
    int w, int h, const int16_t *y_filter_ptr, ConvolveParams *conv_params,
    const int bd, const int offset, size_t vl) {
  const int32_t shift_s32 = conv_params->round_1;
  const int32_t offset_s32 = offset;
  const uint16_t max_u16 = (1 << bd) - 1;

  if (w == 4) {
    int16_t *s = (int16_t *)src_ptr;
    vl = vl << 1;

    vint16m1_t s0 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s1 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s2 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s3 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s4 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s5 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s6 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s7 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s8 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s9 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;

    do {
      vint16m1_t s10 = load_strided_i16_4xN(s, src_stride, vl);
      s += src_stride;
      vint16m1_t s11 = load_strided_i16_4xN(s, src_stride, vl);
      s += src_stride;
      vint16m1_t s12 = load_strided_i16_4xN(s, src_stride, vl);
      s += src_stride;
      vint16m1_t s13 = load_strided_i16_4xN(s, src_stride, vl);
      s += src_stride;

      vuint16m1_t d0 = highbd_convolve12_2d_v_rvv(
          s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, y_filter_ptr,
          offset_s32, shift_s32, max_u16, vl);
      vuint16m1_t d1 = highbd_convolve12_2d_v_rvv(
          s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, y_filter_ptr,
          offset_s32, shift_s32, max_u16, vl);

      store_strided_u16_4xN(dst_ptr, d0, dst_stride, vl);
      dst_ptr += dst_stride << 1;
      store_strided_u16_4xN(dst_ptr, d1, dst_stride, vl);
      dst_ptr += dst_stride << 1;

      s0 = s4;
      s1 = s5;
      s2 = s6;
      s3 = s7;
      s4 = s8;
      s5 = s9;
      s6 = s10;
      s7 = s11;
      s8 = s12;
      s9 = s13;

      h -= 4;
    } while (h != 0);
  } else {
    do {
      int height = h;
      int16_t *s = (int16_t *)src_ptr;
      uint16_t *d = dst_ptr;

      vint16m1_t s0 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s1 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s2 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s3 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s4 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s5 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s6 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s7 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s8 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s9 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s10 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;

      do {
        vint16m1_t s11 = __riscv_vle16_v_i16m1(s, vl);
        s += src_stride;
        vint16m1_t s12 = __riscv_vle16_v_i16m1(s, vl);
        s += src_stride;
        vint16m1_t s13 = __riscv_vle16_v_i16m1(s, vl);
        s += src_stride;
        vint16m1_t s14 = __riscv_vle16_v_i16m1(s, vl);
        s += src_stride;

        vuint16m1_t d0 = highbd_convolve12_2d_v_rvv(
            s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, y_filter_ptr,
            offset_s32, shift_s32, max_u16, vl);
        vuint16m1_t d1 = highbd_convolve12_2d_v_rvv(
            s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, y_filter_ptr,
            offset_s32, shift_s32, max_u16, vl);
        vuint16m1_t d2 = highbd_convolve12_2d_v_rvv(
            s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, y_filter_ptr,
            offset_s32, shift_s32, max_u16, vl);
        vuint16m1_t d3 = highbd_convolve12_2d_v_rvv(
            s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, y_filter_ptr,
            offset_s32, shift_s32, max_u16, vl);

        __riscv_vse16_v_u16m1(d, d0, vl);
        d += dst_stride;
        __riscv_vse16_v_u16m1(d, d1, vl);
        d += dst_stride;
        __riscv_vse16_v_u16m1(d, d2, vl);
        d += dst_stride;
        __riscv_vse16_v_u16m1(d, d3, vl);
        d += dst_stride;

        s0 = s4;
        s1 = s5;
        s2 = s6;
        s3 = s7;
        s4 = s8;
        s5 = s9;
        s6 = s10;
        s7 = s11;
        s8 = s12;
        s9 = s13;
        s10 = s14;

        height -= 4;
      } while (height != 0);

      src_ptr += vl;
      dst_ptr += vl;
      w -= vl;
    } while (w != 0);
  }
}

static inline vuint16m1_t highbd_convolve8_2d_v_rvv(
    const vint16m1_t s0, const vint16m1_t s1, const vint16m1_t s2,
    const vint16m1_t s3, const vint16m1_t s4, const vint16m1_t s5,
    const vint16m1_t s6, const vint16m1_t s7, const int16_t *y_filter,
    const int32_t offset, const int32_t shift, const uint16_t max, size_t vl) {
  vint32m2_t sum = __riscv_vwmul_vx_i32m2(s0, y_filter[0], vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[1], s1, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[2], s2, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[3], s3, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[4], s4, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[5], s5, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[6], s6, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[7], s7, vl);
  sum = __riscv_vadd_vx_i32m2(sum, offset, vl);

  vint16m1_t i16_sum = __riscv_vnsra_wx_i16m1(sum, shift, vl);
  vint16m1_t iclip_sum =
      __riscv_vmin_vx_i16m1(__riscv_vmax_vx_i16m1(i16_sum, 0, vl), max, vl);
  return __riscv_vreinterpret_v_i16m1_u16m1(iclip_sum);
}

static inline void highbd_convolve_2d_sr_vert_8tap_rvv(
    const uint16_t *src_ptr, int src_stride, uint16_t *dst_ptr, int dst_stride,
    int w, int h, const int16_t *y_filter_ptr, ConvolveParams *conv_params,
    int bd, const int offset, size_t vl) {
  const int32_t shift_s32 = conv_params->round_1;
  const int32_t offset_s32 = offset;
  const uint16_t max_u16 = (1 << bd) - 1;

  if (w <= 4) {
    int16_t *s = (int16_t *)src_ptr;
    vl = vl << 1;

    vint16m1_t s0 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s1 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s2 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s3 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s4 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s5 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;

    do {
      vint16m1_t s6 = load_strided_i16_4xN(s, src_stride, vl);
      s += src_stride;
      vint16m1_t s7 = load_strided_i16_4xN(s, src_stride, vl);
      s += src_stride;

      vuint16m1_t d0 = highbd_convolve8_2d_v_rvv(s0, s1, s2, s3, s4, s5, s6, s7,
                                                 y_filter_ptr, offset_s32,
                                                 shift_s32, max_u16, vl);

      store_strided_u16_4xN(dst_ptr, d0, dst_stride, vl);
      dst_ptr += dst_stride << 1;

      s0 = s2;
      s1 = s3;
      s2 = s4;
      s3 = s5;
      s4 = s6;
      s5 = s7;

      h -= 2;
    } while (h != 0);
  } else {
    do {
      int height = h;
      int16_t *s = (int16_t *)src_ptr;
      uint16_t *d = dst_ptr;

      vint16m1_t s0 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s1 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s2 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s3 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s4 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s5 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s6 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;

      do {
        vint16m1_t s7 = __riscv_vle16_v_i16m1(s, vl);
        vuint16m1_t d0 = highbd_convolve8_2d_v_rvv(s0, s1, s2, s3, s4, s5, s6,
                                                   s7, y_filter_ptr, offset_s32,
                                                   shift_s32, max_u16, vl);
        __riscv_vse16_v_u16m1(d, d0, vl);

        s0 = s1;
        s1 = s2;
        s2 = s3;
        s3 = s4;
        s4 = s5;
        s5 = s6;
        s6 = s7;
        s += src_stride;
        d += dst_stride;
        height--;
      } while (height != 0);

      src_ptr += vl;
      dst_ptr += vl;
      w -= vl;
    } while (w != 0);
  }
}

static inline vuint16m1_t highbd_convolve6_2d_v_rvv(
    const vint16m1_t s0, const vint16m1_t s1, const vint16m1_t s2,
    const vint16m1_t s3, const vint16m1_t s4, const vint16m1_t s5,
    const int16_t *y_filter, const int32_t offset, const int32_t shift,
    const uint16_t max, size_t vl) {
  vint32m2_t sum = __riscv_vwmul_vx_i32m2(s0, y_filter[0], vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[1], s1, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[2], s2, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[3], s3, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[4], s4, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, y_filter[5], s5, vl);
  sum = __riscv_vadd_vx_i32m2(sum, offset, vl);

  vint16m1_t i16_sum = __riscv_vnsra_wx_i16m1(sum, shift, vl);
  vint16m1_t iclip_sum =
      __riscv_vmin_vx_i16m1(__riscv_vmax_vx_i16m1(i16_sum, 0, vl), max, vl);
  return __riscv_vreinterpret_v_i16m1_u16m1(iclip_sum);
}

static inline void highbd_convolve_2d_sr_vert_6tap_rvv(
    const uint16_t *src_ptr, int src_stride, uint16_t *dst_ptr, int dst_stride,
    int w, int h, const int16_t *y_filter_ptr, ConvolveParams *conv_params,
    int bd, const int offset, size_t vl) {
  const int32_t shift_s32 = conv_params->round_1;
  const int32_t offset_s32 = offset;
  const uint16_t max_u16 = (1 << bd) - 1;
  const int16_t *yfilter_6tap = y_filter_ptr + 1;

  if (w == 4) {
    int16_t *s = (int16_t *)src_ptr;
    vl = vl << 1;

    vint16m1_t s0 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s1 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s2 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;
    vint16m1_t s3 = load_strided_i16_4xN(s, src_stride, vl);
    s += src_stride;

    do {
      vint16m1_t s4 = load_strided_i16_4xN(s, src_stride, vl);
      s += src_stride;
      vint16m1_t s5 = load_strided_i16_4xN(s, src_stride, vl);
      s += src_stride;
      vint16m1_t s6 = load_strided_i16_4xN(s, src_stride, vl);
      s += src_stride;
      vint16m1_t s7 = load_strided_i16_4xN(s, src_stride, vl);
      s += src_stride;

      vuint16m1_t d0 =
          highbd_convolve6_2d_v_rvv(s0, s1, s2, s3, s4, s5, yfilter_6tap,
                                    offset_s32, shift_s32, max_u16, vl);
      vuint16m1_t d1 =
          highbd_convolve6_2d_v_rvv(s2, s3, s4, s5, s6, s7, yfilter_6tap,
                                    offset_s32, shift_s32, max_u16, vl);

      store_strided_u16_4xN(dst_ptr, d0, dst_stride, vl);
      dst_ptr += dst_stride << 1;
      store_strided_u16_4xN(dst_ptr, d1, dst_stride, vl);
      dst_ptr += dst_stride << 1;

      s0 = s4;
      s1 = s5;
      s2 = s6;
      s3 = s7;

      h -= 4;
    } while (h != 0);
  } else {
    do {
      int height = h;
      int16_t *s = (int16_t *)src_ptr;
      uint16_t *d = dst_ptr;

      vint16m1_t s0 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s1 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s2 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s3 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;
      vint16m1_t s4 = __riscv_vle16_v_i16m1(s, vl);
      s += src_stride;

      do {
        vint16m1_t s5 = __riscv_vle16_v_i16m1(s, vl);
        s += src_stride;
        vint16m1_t s6 = __riscv_vle16_v_i16m1(s, vl);
        s += src_stride;
        vint16m1_t s7 = __riscv_vle16_v_i16m1(s, vl);
        s += src_stride;
        vint16m1_t s8 = __riscv_vle16_v_i16m1(s, vl);
        s += src_stride;

        vuint16m1_t d0 =
            highbd_convolve6_2d_v_rvv(s0, s1, s2, s3, s4, s5, yfilter_6tap,
                                      offset_s32, shift_s32, max_u16, vl);
        vuint16m1_t d1 =
            highbd_convolve6_2d_v_rvv(s1, s2, s3, s4, s5, s6, yfilter_6tap,
                                      offset_s32, shift_s32, max_u16, vl);
        vuint16m1_t d2 =
            highbd_convolve6_2d_v_rvv(s2, s3, s4, s5, s6, s7, yfilter_6tap,
                                      offset_s32, shift_s32, max_u16, vl);
        vuint16m1_t d3 =
            highbd_convolve6_2d_v_rvv(s3, s4, s5, s6, s7, s8, yfilter_6tap,
                                      offset_s32, shift_s32, max_u16, vl);

        __riscv_vse16_v_u16m1(d, d0, vl);
        d += dst_stride;
        __riscv_vse16_v_u16m1(d, d1, vl);
        d += dst_stride;
        __riscv_vse16_v_u16m1(d, d2, vl);
        d += dst_stride;
        __riscv_vse16_v_u16m1(d, d3, vl);
        d += dst_stride;

        s0 = s4;
        s1 = s5;
        s2 = s6;
        s3 = s7;
        s4 = s8;

        height -= 4;
      } while (height != 0);

      src_ptr += vl;
      dst_ptr += vl;
      w -= vl;
    } while (w != 0);
  }
}

static inline vint16m1_t highbd_convolve12_8_2d_h_rvv(
    const vint16m1_t s0, const vint16m1_t s1, const vint16m1_t s2,
    const vint16m1_t s3, const vint16m1_t s4, const vint16m1_t s5,
    const vint16m1_t s6, const vint16m1_t s7, const vint16m1_t s8,
    const vint16m1_t s9, const vint16m1_t s10, const vint16m1_t s11,
    const int16_t *x_filter, const int32_t offset, const int32_t shift,
    size_t vl) {
  vint32m2_t sum = __riscv_vwmul_vx_i32m2(s0, x_filter[0], vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[1], s1, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[2], s2, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[3], s3, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[4], s4, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[5], s5, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[6], s6, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[7], s7, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[8], s8, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[9], s9, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[10], s10, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[11], s11, vl);

  sum = __riscv_vadd_vx_i32m2(sum, offset, vl);

  return __riscv_vnclip_wx_i16m1(sum, shift, __RISCV_VXRM_RNU, vl);
}

static inline void highbd_convolve_2d_sr_horiz_12tap_rvv(
    const uint16_t *src_ptr, int src_stride, uint16_t *dst_ptr, int dst_stride,
    int w, int h, const int16_t *x_filter_ptr, ConvolveParams *conv_params,
    const int offset, size_t vl) {
  assert(h >= 5);
  const int32_t shift_s32 = conv_params->round_0;
  const int32_t offset_s32 = offset;

  if (w == 4) {
    const int16_t *s = (int16_t *)src_ptr;
    int16_t *d = (int16_t *)dst_ptr;

    do {
      vint16m1_t t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11;

      load_s16_8x12(s, 1, &t0, &t1, &t2, &t3, &t4, &t5, &t6, &t7, &t8, &t9,
                    &t10, &t11, vl);

      vint16m1_t d0 = highbd_convolve12_8_2d_h_rvv(
          t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, x_filter_ptr,
          offset_s32, shift_s32, vl);

      __riscv_vse16_v_i16m1(d, d0, vl);

      s += src_stride;
      d += dst_stride;

    } while (--h != 0);
  } else {
    int height = h;

    do {
      const int16_t *s = (int16_t *)src_ptr;
      int16_t *d = (int16_t *)dst_ptr;
      int width = w;

      do {
        vint16m1_t t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11;

        load_s16_8x12(s, 1, &t0, &t1, &t2, &t3, &t4, &t5, &t6, &t7, &t8, &t9,
                      &t10, &t11, vl);

        vint16m1_t d0 = highbd_convolve12_8_2d_h_rvv(
            t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, x_filter_ptr,
            offset_s32, shift_s32, vl);

        __riscv_vse16_v_i16m1(d, d0, vl);

        s += vl;
        d += vl;
        width -= vl;
      } while (width != 0);
      src_ptr += src_stride;
      dst_ptr += dst_stride;
    } while (--height != 0);
  }
}

static inline vint16m1_t highbd_convolve8_4_2d_h_rvv(
    const vint16m1_t s0, const vint16m1_t s1, const vint16m1_t s2,
    const vint16m1_t s3, const int16_t *x_filter, const int32_t offset,
    const int32_t shift, size_t vl) {
  vint32m2_t sum = __riscv_vwmul_vx_i32m2(s0, x_filter[0], vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[1], s1, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[2], s2, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[3], s3, vl);

  sum = __riscv_vadd_vx_i32m2(sum, offset, vl);

  return __riscv_vnclip_wx_i16m1(sum, shift, __RISCV_VXRM_RNU, vl);
}

static inline vint16m1_t highbd_convolve8_8_2d_h_rvv(
    const vint16m1_t s0, const vint16m1_t s1, const vint16m1_t s2,
    const vint16m1_t s3, const vint16m1_t s4, const vint16m1_t s5,
    const vint16m1_t s6, const vint16m1_t s7, const int16_t *x_filter,
    const int32_t offset, const int32_t shift, size_t vl) {
  vint32m2_t sum = __riscv_vwmul_vx_i32m2(s0, x_filter[0], vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[1], s1, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[2], s2, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[3], s3, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[4], s4, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[5], s5, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[6], s6, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[7], s7, vl);

  sum = __riscv_vadd_vx_i32m2(sum, offset, vl);

  return __riscv_vnclip_wx_i16m1(sum, shift, __RISCV_VXRM_RNU, vl);
}

static inline void highbd_convolve_2d_sr_horiz_rvv(
    const uint16_t *src_ptr, int src_stride, uint16_t *dst_ptr, int dst_stride,
    int w, int h, const int16_t *x_filter_ptr, ConvolveParams *conv_params,
    const int offset, size_t vl) {
  assert(h >= 5);
  const int32_t shift_s32 = conv_params->round_0;
  const int32_t offset_s32 = offset;

  if (w == 4) {
    const int16_t *x_filter = (x_filter_ptr + 2);
    const int16_t *s = (int16_t *)(src_ptr + 1);
    int16_t *d = (int16_t *)dst_ptr;

    do {
      vint16m1_t t0, t1, t2, t3;

      load_s16_8x4(s, 1, &t0, &t1, &t2, &t3, vl);

      vint16m1_t d0 = highbd_convolve8_4_2d_h_rvv(t0, t1, t2, t3, x_filter,
                                                  offset_s32, shift_s32, vl);

      __riscv_vse16_v_i16m1(d, d0, vl);

      s += src_stride;
      d += dst_stride;
    } while (--h != 0);
  } else {
    do {
      const int16_t *s = (int16_t *)src_ptr;
      int16_t *d = (int16_t *)dst_ptr;
      int width = w;

      do {
        vint16m1_t t0, t1, t2, t3, t4, t5, t6, t7;

        load_s16_8x8(s, 1, &t0, &t1, &t2, &t3, &t4, &t5, &t6, &t7, vl);

        vint16m1_t d0 = highbd_convolve8_8_2d_h_rvv(t0, t1, t2, t3, t4, t5, t6,
                                                    t7, x_filter_ptr,
                                                    offset_s32, shift_s32, vl);
        __riscv_vse16_v_i16m1(d, d0, vl);

        s += vl;
        d += vl;
        width -= vl;
      } while (width != 0);
      src_ptr += src_stride;
      dst_ptr += dst_stride;
    } while (--h != 0);
  }
}

static inline vint16m1_t highbd_convolve6_8_2d_h_rvv(
    const vint16m1_t s0, const vint16m1_t s1, const vint16m1_t s2,
    const vint16m1_t s3, const vint16m1_t s4, const vint16m1_t s5,
    const int16_t *x_filter, const int32_t offset, const int32_t shift,
    size_t vl) {
  vint32m2_t sum = __riscv_vwmul_vx_i32m2(s0, x_filter[0], vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[1], s1, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[2], s2, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[3], s3, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[4], s4, vl);
  sum = __riscv_vwmacc_vx_i32m2(sum, x_filter[5], s5, vl);

  sum = __riscv_vadd_vx_i32m2(sum, offset, vl);

  return __riscv_vnclip_wx_i16m1(sum, shift, __RISCV_VXRM_RNU, vl);
}

static inline void highbd_convolve_2d_sr_horiz_6tap_rvv(
    const uint16_t *src_ptr, int src_stride, uint16_t *dst_ptr, int dst_stride,
    int w, int h, const int16_t *x_filter_ptr, ConvolveParams *conv_params,
    const int offset, size_t vl) {
  assert(h >= 5);
  const int32_t shift_s32 = conv_params->round_0;
  const int32_t offset_s32 = offset;
  const int16_t *x_filter = (x_filter_ptr + 1);

  do {
    const int16_t *s = (int16_t *)src_ptr;
    int16_t *d = (int16_t *)dst_ptr;
    int width = w;

    do {
      vint16m1_t t0, t1, t2, t3, t4, t5;

      load_s16_8x6(s, 1, &t0, &t1, &t2, &t3, &t4, &t5, vl);

      vint16m1_t d0 = highbd_convolve6_8_2d_h_rvv(
          t0, t1, t2, t3, t4, t5, x_filter, offset_s32, shift_s32, vl);

      __riscv_vse16_v_i16m1(d, d0, vl);

      s += vl;
      d += vl;
      width -= vl;
    } while (width != 0);
    src_ptr += src_stride;
    dst_ptr += dst_stride;
  } while (--h != 0);
}

void av1_highbd_convolve_2d_sr_rvv(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_qn, const int subpel_y_qn,
                                   ConvolveParams *conv_params, int bd) {
  if (w == 2 || h == 2) {
    av1_highbd_convolve_2d_sr_c(src, src_stride, dst, dst_stride, w, h,
                                filter_params_x, filter_params_y, subpel_x_qn,
                                subpel_y_qn, conv_params, bd);
    return;
  }
  DECLARE_ALIGNED(16, uint16_t,
                  im_block[(MAX_SB_SIZE + MAX_FILTER_TAP) * MAX_SB_SIZE]);
  const int x_filter_taps = get_filter_tap(filter_params_x, subpel_x_qn);
  const int clamped_x_taps = x_filter_taps < 6 ? 6 : x_filter_taps;

  const int y_filter_taps = get_filter_tap(filter_params_y, subpel_y_qn);
  const int clamped_y_taps = y_filter_taps < 6 ? 6 : y_filter_taps;
  const int im_h = h + clamped_y_taps - 1;
  const int im_stride = MAX_SB_SIZE;
  const int vert_offset = clamped_y_taps / 2 - 1;
  const int horiz_offset = clamped_x_taps / 2 - 1;
  const int x_offset_initial = (1 << (bd + FILTER_BITS - 1));
  const int y_offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;
  // The extra shim of (1 << (conv_params->round_1 - 1)) allows us to do a
  // simple shift left instead of a rounding saturating shift left.
  const int y_offset =
      (1 << (conv_params->round_1 - 1)) - (1 << (y_offset_bits - 1));

  const uint16_t *src_ptr = src - vert_offset * src_stride - horiz_offset;

  const int16_t *x_filter_ptr = av1_get_interp_filter_subpel_kernel(
      filter_params_x, subpel_x_qn & SUBPEL_MASK);
  const int16_t *y_filter_ptr = av1_get_interp_filter_subpel_kernel(
      filter_params_y, subpel_y_qn & SUBPEL_MASK);

  size_t vl = __riscv_vsetvl_e16m1(w);

  if (x_filter_taps > 8) {
    highbd_convolve_2d_sr_horiz_12tap_rvv(src_ptr, src_stride, im_block,
                                          im_stride, w, im_h, x_filter_ptr,
                                          conv_params, x_offset_initial, vl);

    highbd_convolve_2d_sr_vert_12tap_rvv(im_block, im_stride, dst, dst_stride,
                                         w, h, y_filter_ptr, conv_params, bd,
                                         y_offset, vl);
    return;
  }
  if (x_filter_taps <= 6 && w != 4) {
    highbd_convolve_2d_sr_horiz_6tap_rvv(src_ptr, src_stride, im_block,
                                         im_stride, w, im_h, x_filter_ptr,
                                         conv_params, x_offset_initial, vl);
  } else {
    highbd_convolve_2d_sr_horiz_rvv(src_ptr, src_stride, im_block, im_stride, w,
                                    im_h, x_filter_ptr, conv_params,
                                    x_offset_initial, vl);
  }

  if (y_filter_taps <= 6) {
    highbd_convolve_2d_sr_vert_6tap_rvv(im_block, im_stride, dst, dst_stride, w,
                                        h, y_filter_ptr, conv_params, bd,
                                        y_offset, vl);
  } else {
    highbd_convolve_2d_sr_vert_8tap_rvv(im_block, im_stride, dst, dst_stride, w,
                                        h, y_filter_ptr, conv_params, bd,
                                        y_offset, vl);
  }
}

// Filter used is [64, 64].
void av1_highbd_convolve_x_sr_intrabc_rvv(
    const uint16_t *src, int src_stride, uint16_t *dst, int dst_stride, int w,
    int h, const InterpFilterParams *filter_params_x, const int subpel_x_qn,
    ConvolveParams *conv_params, int bd) {
  assert(subpel_x_qn == 8);
  assert(filter_params_x->taps == 2);
  assert((conv_params->round_0 + conv_params->round_1) == 2 * FILTER_BITS);
  (void)filter_params_x;
  (void)subpel_x_qn;
  (void)conv_params;
  (void)bd;

  size_t vl = __riscv_vsetvl_e16m1(w);
  if (w <= 4) {
    do {
      // Load
      vuint16mf2_t s0_0 = __riscv_vle16_v_u16mf2(src, vl);
      vuint16mf2_t s0_1 = __riscv_vle16_v_u16mf2(src + 1, vl);
      vuint16mf2_t s1_0 = __riscv_vle16_v_u16mf2(src + src_stride, vl);
      vuint16mf2_t s1_1 = __riscv_vle16_v_u16mf2(src + src_stride + 1, vl);

      // Average the values
      vuint16mf2_t d0 =
          __riscv_vaaddu_vv_u16mf2(s0_0, s0_1, __RISCV_VXRM_RNU, vl);
      vuint16mf2_t d1 =
          __riscv_vaaddu_vv_u16mf2(s1_0, s1_1, __RISCV_VXRM_RNU, vl);

      // Store
      __riscv_vse16_v_u16mf2(dst, d0, vl);
      __riscv_vse16_v_u16mf2(dst + dst_stride, d1, vl);

      src += src_stride << 1;
      dst += dst_stride << 1;
      h -= 2;
    } while (h > 0);
  } else {
    do {
      const uint16_t *src_ptr = src;
      uint16_t *dst_ptr = dst;
      int width = w;

      do {
        // Load
        vuint16m1_t s0 = __riscv_vle16_v_u16m1(src_ptr, vl);
        vuint16m1_t s1 = __riscv_vle16_v_u16m1(src_ptr + 1, vl);
        vuint16m1_t s2 = __riscv_vle16_v_u16m1(src_ptr + src_stride, vl);
        vuint16m1_t s3 = __riscv_vle16_v_u16m1(src_ptr + src_stride + 1, vl);

        // Average the values
        vuint16m1_t d0 = __riscv_vaaddu_vv_u16m1(s0, s1, __RISCV_VXRM_RNU, vl);
        vuint16m1_t d1 = __riscv_vaaddu_vv_u16m1(s2, s3, __RISCV_VXRM_RNU, vl);

        // Store
        __riscv_vse16_v_u16m1(dst_ptr, d0, vl);
        __riscv_vse16_v_u16m1(dst_ptr + dst_stride, d1, vl);

        src_ptr += vl;
        dst_ptr += vl;
        width -= vl;
      } while (width > 0);
      src += src_stride << 1;
      dst += dst_stride << 1;
      h -= 2;
    } while (h > 0);
  }
}

// Filter used is [64, 64].
void av1_highbd_convolve_y_sr_intrabc_rvv(
    const uint16_t *src, int src_stride, uint16_t *dst, int dst_stride, int w,
    int h, const InterpFilterParams *filter_params_y, const int subpel_y_qn,
    int bd) {
  assert(subpel_y_qn == 8);
  assert(filter_params_y->taps == 2);
  (void)filter_params_y;
  (void)subpel_y_qn;
  (void)bd;

  size_t vl = __riscv_vsetvl_e16m1(w);
  if (w <= 4) {
    vuint16mf2_t s0 = __riscv_vle16_v_u16mf2(src, vl);

    do {
      vuint16mf2_t s1 = __riscv_vle16_v_u16mf2(src + src_stride, vl);
      vuint16mf2_t s2 = __riscv_vle16_v_u16mf2(src + 2 * src_stride, vl);

      // Average the values
      vuint16mf2_t d0 = __riscv_vaaddu_vv_u16mf2(s0, s1, __RISCV_VXRM_RNU, vl);
      vuint16mf2_t d1 = __riscv_vaaddu_vv_u16mf2(s1, s2, __RISCV_VXRM_RNU, vl);

      // Store
      __riscv_vse16_v_u16mf2(dst, d0, vl);
      __riscv_vse16_v_u16mf2(dst + dst_stride, d1, vl);

      s0 = s2;
      src += src_stride << 1;
      dst += dst_stride << 1;
      h -= 2;
    } while (h > 0);
  } else {
    do {
      const uint16_t *src_ptr = src;
      uint16_t *dst_ptr = dst;
      int height = h;

      vuint16m1_t s0 = __riscv_vle16_v_u16m1(src_ptr, vl);

      do {
        vuint16m1_t s1 = __riscv_vle16_v_u16m1(src_ptr + src_stride, vl);
        vuint16m1_t s2 = __riscv_vle16_v_u16m1(src_ptr + 2 * src_stride, vl);

        // Average the values
        vuint16m1_t d0 = __riscv_vaaddu_vv_u16m1(s0, s1, __RISCV_VXRM_RNU, vl);
        vuint16m1_t d1 = __riscv_vaaddu_vv_u16m1(s1, s2, __RISCV_VXRM_RNU, vl);

        // Store
        __riscv_vse16_v_u16m1(dst_ptr, d0, vl);
        __riscv_vse16_v_u16m1(dst_ptr + dst_stride, d1, vl);

        s0 = s2;
        src_ptr += src_stride << 1;
        dst_ptr += dst_stride << 1;
        height -= 2;
      } while (height > 0);
      src += vl;
      dst += vl;
      w -= vl;
    } while (w > 0);
  }
}

// Both horizontal and vertical passes use the same 2-tap filter: [64, 64].
void av1_highbd_convolve_2d_sr_intrabc_rvv(
    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_qn,
    const int subpel_y_qn, ConvolveParams *conv_params, int bd) {
  assert(subpel_x_qn == 8);
  assert(subpel_y_qn == 8);
  assert(filter_params_x->taps == 2 && filter_params_y->taps == 2);
  assert((conv_params->round_0 + conv_params->round_1) == 2 * FILTER_BITS);
  assert(w <= MAX_SB_SIZE && h <= MAX_SB_SIZE);
  (void)filter_params_x;
  (void)subpel_x_qn;
  (void)filter_params_y;
  (void)subpel_y_qn;
  (void)conv_params;
  (void)bd;

  size_t vl = __riscv_vsetvl_e16m1(w);

  if (w <= 8) {
    // Horizontal filter.
    vuint16m1_t s0 = __riscv_vle16_v_u16m1(src, vl);
    vuint16m1_t s1 = __riscv_vle16_v_u16m1(src + 1, vl);
    src += src_stride;

    vuint16m1_t sum0 = __riscv_vadd_vv_u16m1(s0, s1, vl);

    do {
      vuint16m1_t s2 = __riscv_vle16_v_u16m1(src, vl);
      vuint16m1_t s3 = __riscv_vle16_v_u16m1(src + 1, vl);
      src += src_stride;
      vuint16m1_t s4 = __riscv_vle16_v_u16m1(src, vl);
      vuint16m1_t s5 = __riscv_vle16_v_u16m1(src + 1, vl);
      src += src_stride;

      vuint16m1_t sum1 = __riscv_vadd_vv_u16m1(s2, s3, vl);
      vuint16m1_t sum2 = __riscv_vadd_vv_u16m1(s4, s5, vl);

      // Vertical filter.
      vuint16m1_t d0 =
          __riscv_vadd_vx_u16m1(__riscv_vadd_vv_u16m1(sum0, sum1, vl), 2, vl);
      vuint16m1_t d1 =
          __riscv_vadd_vx_u16m1(__riscv_vadd_vv_u16m1(sum1, sum2, vl), 2, vl);

      d0 = __riscv_vsrl_vx_u16m1(d0, 2, vl);
      d1 = __riscv_vsrl_vx_u16m1(d1, 2, vl);

      __riscv_vse16_v_u16m1(dst, d0, vl);
      dst += dst_stride;
      __riscv_vse16_v_u16m1(dst, d1, vl);
      dst += dst_stride;

      sum0 = sum2;
      h -= 2;
    } while (h != 0);
  } else {
    do {
      uint16_t *src_ptr = (uint16_t *)src;
      uint16_t *dst_ptr = dst;
      int height = h;

      // Horizontal filter.
      vuint16m1_t s0 = __riscv_vle16_v_u16m1(src_ptr, vl);
      vuint16m1_t s1 = __riscv_vle16_v_u16m1(src_ptr + 1, vl);
      src_ptr += src_stride;

      vuint16m1_t sum0 = __riscv_vadd_vv_u16m1(s0, s1, vl);

      do {
        vuint16m1_t s2 = __riscv_vle16_v_u16m1(src_ptr, vl);
        vuint16m1_t s3 = __riscv_vle16_v_u16m1(src_ptr + 1, vl);
        src_ptr += src_stride;
        vuint16m1_t s4 = __riscv_vle16_v_u16m1(src_ptr, vl);
        vuint16m1_t s5 = __riscv_vle16_v_u16m1(src_ptr + 1, vl);
        src_ptr += src_stride;

        vuint16m1_t sum1 = __riscv_vadd_vv_u16m1(s2, s3, vl);
        vuint16m1_t sum2 = __riscv_vadd_vv_u16m1(s4, s5, vl);

        // Vertical filter.
        vuint16m1_t d0 =
            __riscv_vadd_vx_u16m1(__riscv_vadd_vv_u16m1(sum0, sum1, vl), 2, vl);
        vuint16m1_t d1 =
            __riscv_vadd_vx_u16m1(__riscv_vadd_vv_u16m1(sum1, sum2, vl), 2, vl);

        d0 = __riscv_vsrl_vx_u16m1(d0, 2, vl);
        d1 = __riscv_vsrl_vx_u16m1(d1, 2, vl);

        __riscv_vse16_v_u16m1(dst_ptr, d0, vl);
        dst_ptr += dst_stride;
        __riscv_vse16_v_u16m1(dst_ptr, d1, vl);
        dst_ptr += dst_stride;

        sum0 = __riscv_vmv_v_v_u16m1(sum2, vl);
        height -= 2;
      } while (height != 0);

      src += vl;
      dst += vl;
      w -= vl;
    } while (w != 0);
  }
}