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