Refactor Neon compound convolution functions 3/7
Refactor the Armv8.4 and Armv8.6 dot-product implementations of
av1_dist_wtd_convolve_x_neon:
Move the final right shift into the convolution inline functions and
return unsigned types - removing the need for a lot of bulky result
vector type casting.
Change-Id: Ic22c88815c9b31af4f3dcabda9e59530e67c1bbd
diff --git a/av1/common/arm/jnt_convolve_neon.c b/av1/common/arm/jnt_convolve_neon.c
index 177a837..243df36 100644
--- a/av1/common/arm/jnt_convolve_neon.c
+++ b/av1/common/arm/jnt_convolve_neon.c
@@ -1102,23 +1102,79 @@
#if defined(__aarch64__) && defined(__ARM_FEATURE_MATMUL_INT8)
+static INLINE uint16x4_t convolve8_4_x(uint8x16_t samples,
+ const int8x8_t x_filter,
+ const uint8x16x2_t permute_tbl,
+ const int32x4_t round_offset) {
+ uint8x16_t permuted_samples[2];
+ int32x4_t sum;
+
+ // Permute samples ready for dot product.
+ // { 0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6 }
+ permuted_samples[0] = vqtbl1q_u8(samples, permute_tbl.val[0]);
+ // { 4, 5, 6, 7, 5, 6, 7, 8, 6, 7, 8, 9, 7, 8, 9, 10 }
+ permuted_samples[1] = vqtbl1q_u8(samples, permute_tbl.val[1]);
+
+ // First 4 output values.
+ sum = vusdotq_lane_s32(round_offset, permuted_samples[0], x_filter, 0);
+ sum = vusdotq_lane_s32(sum, permuted_samples[1], x_filter, 1);
+
+ // We halved the convolution filter values so -1 from the right shift.
+ return vreinterpret_u16_s16(vshrn_n_s32(sum, ROUND0_BITS - 1));
+}
+
+static INLINE uint16x8_t convolve8_8_x(uint8x16_t samples,
+ const int8x8_t x_filter,
+ const uint8x16x3_t permute_tbl,
+ const int32x4_t round_offset) {
+ uint8x16_t permuted_samples[3];
+ int32x4_t sum[2];
+
+ // Permute samples ready for dot product.
+ // { 0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6 }
+ permuted_samples[0] = vqtbl1q_u8(samples, permute_tbl.val[0]);
+ // { 4, 5, 6, 7, 5, 6, 7, 8, 6, 7, 8, 9, 7, 8, 9, 10 }
+ permuted_samples[1] = vqtbl1q_u8(samples, permute_tbl.val[1]);
+ // { 8, 9, 10, 11, 9, 10, 11, 12, 10, 11, 12, 13, 11, 12, 13, 14 }
+ permuted_samples[2] = vqtbl1q_u8(samples, permute_tbl.val[2]);
+
+ // First 4 output values.
+ sum[0] = vusdotq_lane_s32(round_offset, permuted_samples[0], x_filter, 0);
+ sum[0] = vusdotq_lane_s32(sum[0], permuted_samples[1], x_filter, 1);
+ // Second 4 output values.
+ sum[1] = vusdotq_lane_s32(round_offset, permuted_samples[1], x_filter, 0);
+ sum[1] = vusdotq_lane_s32(sum[1], permuted_samples[2], x_filter, 1);
+
+ // Narrow and re-pack.
+ // We halved the convolution filter values so -1 from the right shift.
+ int16x8_t res = vcombine_s16(vshrn_n_s32(sum[0], ROUND0_BITS - 1),
+ vshrn_n_s32(sum[1], ROUND0_BITS - 1));
+ return vreinterpretq_u16_s16(res);
+}
+
void av1_dist_wtd_convolve_x_neon(const uint8_t *src, int src_stride,
uint8_t *dst8, int dst8_stride, int w, int h,
const InterpFilterParams *filter_params_x,
const int subpel_x_qn,
ConvolveParams *conv_params) {
- assert(!(w % 4));
- assert(!(h % 4));
+ assert(w % 4 == 0);
+ assert(h % 4 == 0);
- const int horiz_offset = filter_params_x->taps / 2 - 1;
const int bd = 8;
const int offset_bits = bd + 2 * FILTER_BITS - ROUND0_BITS;
const int16_t round_offset = (1 << (offset_bits - COMPOUND_ROUND1_BITS)) +
(1 << (offset_bits - COMPOUND_ROUND1_BITS - 1));
const int16x8_t round_offset_vec = vdupq_n_s16(round_offset);
+ // A shim of 1 << ((ROUND0_BITS - 1) - 1) enables us to use non-rounding
+ // shifts - which are generally faster than rounding shifts on modern CPUs.
+ // (The extra -1 is needed because we halved the filter values.)
+ const int32x4_t round_offset_shim = vdupq_n_s32(
+ (round_offset << (ROUND0_BITS - 1)) + (1 << ((ROUND0_BITS - 1) - 1)));
+
+ const int do_average = conv_params->do_average;
+ const int use_dist_wtd_comp_avg = conv_params->use_dist_wtd_comp_avg;
const uint16_t fwd_offset = conv_params->fwd_offset;
const uint16_t bck_offset = conv_params->bck_offset;
- const int use_dist_wtd_comp_avg = conv_params->use_dist_wtd_comp_avg;
// Horizontal filter.
const int16_t *x_filter_ptr = av1_get_interp_filter_subpel_kernel(
@@ -1126,18 +1182,12 @@
// Filter values are even, so downshift by 1 to reduce intermediate precision
// requirements.
const int8x8_t x_filter = vshrn_n_s16(vld1q_s16(x_filter_ptr), 1);
- // This shim of 1 << ((ROUND0_BITS - 1) - 1) enables us to use non-rounding
- // shifts - which are generally faster than rounding shifts on modern CPUs.
- // The outermost -1 is needed because we halved the filter values.
- const int32x4_t horiz_const = vdupq_n_s32(
- (round_offset << (ROUND0_BITS - 1)) + (1 << ((ROUND0_BITS - 1) - 1)));
+ const int horiz_offset = filter_params_x->taps / 2 - 1;
const uint8_t *src_ptr = src - horiz_offset;
- CONV_BUF_TYPE *dst = conv_params->dst;
- CONV_BUF_TYPE *dst_ptr = dst;
- uint8_t *dst_u8_ptr = dst8;
+ CONV_BUF_TYPE *dst_ptr = conv_params->dst;
+ uint8_t *dst8_ptr = dst8;
int dst_stride = conv_params->dst_stride;
- int width = w;
int height = h;
if (w == 4) {
@@ -1145,122 +1195,161 @@
do {
uint8x16_t s0, s1, s2, s3;
- int32x4_t d0, d1, d2, d3;
- int16x8_t d01, d23;
- uint16x4_t dd0, dd1, dd2, dd3;
+ uint16x4_t d0, d1, d2, d3, dd0, dd1, dd2, dd3;
uint8x8_t d01_u8, d23_u8;
load_u8_16x4(src_ptr, src_stride, &s0, &s1, &s2, &s3);
- d0 = convolve8_4_usdot(s0, x_filter, permute_tbl, horiz_const);
- d1 = convolve8_4_usdot(s1, x_filter, permute_tbl, horiz_const);
- d2 = convolve8_4_usdot(s2, x_filter, permute_tbl, horiz_const);
- d3 = convolve8_4_usdot(s3, x_filter, permute_tbl, horiz_const);
+ d0 = convolve8_4_x(s0, x_filter, permute_tbl, round_offset_shim);
+ d1 = convolve8_4_x(s1, x_filter, permute_tbl, round_offset_shim);
+ d2 = convolve8_4_x(s2, x_filter, permute_tbl, round_offset_shim);
+ d3 = convolve8_4_x(s3, x_filter, permute_tbl, round_offset_shim);
- // We halved the convolution filter values so -1 from the right shift.
- d01 = vcombine_s16(vshrn_n_s32(d0, ROUND0_BITS - 1),
- vshrn_n_s32(d1, ROUND0_BITS - 1));
- d23 = vcombine_s16(vshrn_n_s32(d2, ROUND0_BITS - 1),
- vshrn_n_s32(d3, ROUND0_BITS - 1));
-
- if (conv_params->do_average) {
+ if (do_average) {
load_u16_4x4(dst_ptr, dst_stride, &dd0, &dd1, &dd2, &dd3);
- compute_avg_4x4(
- dd0, dd1, dd2, dd3, vreinterpret_u16_s16(vget_low_s16(d01)),
- vreinterpret_u16_s16(vget_high_s16(d01)),
- vreinterpret_u16_s16(vget_low_s16(d23)),
- vreinterpret_u16_s16(vget_high_s16(d23)), fwd_offset, bck_offset,
- round_offset_vec, use_dist_wtd_comp_avg, &d01_u8, &d23_u8);
+ compute_avg_4x4(dd0, dd1, dd2, dd3, d0, d1, d2, d3, fwd_offset,
+ bck_offset, round_offset_vec, use_dist_wtd_comp_avg,
+ &d01_u8, &d23_u8);
- store_u8_4x1(dst_u8_ptr + 0 * dst8_stride, d01_u8, 0);
- store_u8_4x1(dst_u8_ptr + 1 * dst8_stride, d01_u8, 1);
- store_u8_4x1(dst_u8_ptr + 2 * dst8_stride, d23_u8, 0);
- store_u8_4x1(dst_u8_ptr + 3 * dst8_stride, d23_u8, 1);
+ store_u8_4x1(dst8_ptr + 0 * dst8_stride, d01_u8, 0);
+ store_u8_4x1(dst8_ptr + 1 * dst8_stride, d01_u8, 1);
+ store_u8_4x1(dst8_ptr + 2 * dst8_stride, d23_u8, 0);
+ store_u8_4x1(dst8_ptr + 3 * dst8_stride, d23_u8, 1);
} else {
- store_u16_4x4(dst_ptr, dst_stride,
- vreinterpret_u16_s16(vget_low_s16(d01)),
- vreinterpret_u16_s16(vget_high_s16(d01)),
- vreinterpret_u16_s16(vget_low_s16(d23)),
- vreinterpret_u16_s16(vget_high_s16(d23)));
+ store_u16_4x4(dst_ptr, dst_stride, d0, d1, d2, d3);
}
src_ptr += 4 * src_stride;
dst_ptr += 4 * dst_stride;
- dst_u8_ptr += 4 * dst8_stride;
+ dst8_ptr += 4 * dst8_stride;
height -= 4;
- } while (height > 0);
+ } while (height != 0);
} else {
const uint8x16x3_t permute_tbl = vld1q_u8_x3(dot_prod_permute_tbl);
do {
const uint8_t *s = src_ptr;
CONV_BUF_TYPE *d = dst_ptr;
- uint8_t *d_u8 = dst_u8_ptr;
- width = w;
+ uint8_t *d_u8 = dst8_ptr;
+ int width = w;
do {
uint8x16_t s0, s1, s2, s3;
- int16x8_t d0, d1, d2, d3;
- uint16x8_t dd0, dd1, dd2, dd3;
+ uint16x8_t d0, d1, d2, d3, dd0, dd1, dd2, dd3;
uint8x8_t d0_u8, d1_u8, d2_u8, d3_u8;
load_u8_16x4(s, src_stride, &s0, &s1, &s2, &s3);
- d0 = convolve8_horiz_8_usdot(s0, x_filter, permute_tbl, horiz_const);
- d1 = convolve8_horiz_8_usdot(s1, x_filter, permute_tbl, horiz_const);
- d2 = convolve8_horiz_8_usdot(s2, x_filter, permute_tbl, horiz_const);
- d3 = convolve8_horiz_8_usdot(s3, x_filter, permute_tbl, horiz_const);
+ d0 = convolve8_8_x(s0, x_filter, permute_tbl, round_offset_shim);
+ d1 = convolve8_8_x(s1, x_filter, permute_tbl, round_offset_shim);
+ d2 = convolve8_8_x(s2, x_filter, permute_tbl, round_offset_shim);
+ d3 = convolve8_8_x(s3, x_filter, permute_tbl, round_offset_shim);
- if (conv_params->do_average) {
+ if (do_average) {
load_u16_8x4(d, dst_stride, &dd0, &dd1, &dd2, &dd3);
- compute_avg_8x4(dd0, dd1, dd2, dd3, vreinterpretq_u16_s16(d0),
- vreinterpretq_u16_s16(d1), vreinterpretq_u16_s16(d2),
- vreinterpretq_u16_s16(d3), fwd_offset, bck_offset,
- round_offset_vec, use_dist_wtd_comp_avg, &d0_u8,
- &d1_u8, &d2_u8, &d3_u8);
+ compute_avg_8x4(dd0, dd1, dd2, dd3, d0, d1, d2, d3, fwd_offset,
+ bck_offset, round_offset_vec, use_dist_wtd_comp_avg,
+ &d0_u8, &d1_u8, &d2_u8, &d3_u8);
store_u8_8x4(d_u8, dst8_stride, d0_u8, d1_u8, d2_u8, d3_u8);
} else {
- store_u16_8x4(d, dst_stride, vreinterpretq_u16_s16(d0),
- vreinterpretq_u16_s16(d1), vreinterpretq_u16_s16(d2),
- vreinterpretq_u16_s16(d3));
+ store_u16_8x4(d, dst_stride, d0, d1, d2, d3);
}
s += 8;
d += 8;
d_u8 += 8;
width -= 8;
- } while (width > 0);
-
+ } while (width != 0);
src_ptr += 4 * src_stride;
dst_ptr += 4 * dst_stride;
- dst_u8_ptr += 4 * dst8_stride;
+ dst8_ptr += 4 * dst8_stride;
height -= 4;
- } while (height > 0);
+ } while (height != 0);
}
}
#elif defined(__aarch64__) && defined(__ARM_FEATURE_DOTPROD)
+static INLINE uint16x4_t convolve8_4_x(uint8x16_t samples,
+ const int8x8_t x_filter,
+ const int32x4_t correction,
+ const uint8x16_t range_limit,
+ const uint8x16x2_t permute_tbl) {
+ int8x16_t clamped_samples, permuted_samples[2];
+ int32x4_t sum;
+
+ // Clamp sample range to [-128, 127] for 8-bit signed dot product.
+ clamped_samples = vreinterpretq_s8_u8(vsubq_u8(samples, range_limit));
+
+ // Permute samples ready for dot product.
+ // { 0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6 }
+ permuted_samples[0] = vqtbl1q_s8(clamped_samples, permute_tbl.val[0]);
+ // { 4, 5, 6, 7, 5, 6, 7, 8, 6, 7, 8, 9, 7, 8, 9, 10 }
+ permuted_samples[1] = vqtbl1q_s8(clamped_samples, permute_tbl.val[1]);
+
+ // Accumulate dot product into 'correction' to account for range clamp.
+ sum = vdotq_lane_s32(correction, permuted_samples[0], x_filter, 0);
+ sum = vdotq_lane_s32(sum, permuted_samples[1], x_filter, 1);
+
+ // We halved the convolution filter values so -1 from the right shift.
+ return vreinterpret_u16_s16(vshrn_n_s32(sum, ROUND0_BITS - 1));
+}
+
+static INLINE uint16x8_t convolve8_8_x(uint8x16_t samples,
+ const int8x8_t x_filter,
+ const int32x4_t correction,
+ const uint8x16_t range_limit,
+ const uint8x16x3_t permute_tbl) {
+ int8x16_t clamped_samples, permuted_samples[3];
+ int32x4_t sum[2];
+
+ // Clamp sample range to [-128, 127] for 8-bit signed dot product.
+ clamped_samples = vreinterpretq_s8_u8(vsubq_u8(samples, range_limit));
+
+ // Permute samples ready for dot product. */
+ // { 0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6 }
+ permuted_samples[0] = vqtbl1q_s8(clamped_samples, permute_tbl.val[0]);
+ // { 4, 5, 6, 7, 5, 6, 7, 8, 6, 7, 8, 9, 7, 8, 9, 10 }
+ permuted_samples[1] = vqtbl1q_s8(clamped_samples, permute_tbl.val[1]);
+ // { 8, 9, 10, 11, 9, 10, 11, 12, 10, 11, 12, 13, 11, 12, 13, 14 }
+ permuted_samples[2] = vqtbl1q_s8(clamped_samples, permute_tbl.val[2]);
+
+ // Accumulate dot product into 'correction' to account for range clamp.
+ // First 4 output values.
+ sum[0] = vdotq_lane_s32(correction, permuted_samples[0], x_filter, 0);
+ sum[0] = vdotq_lane_s32(sum[0], permuted_samples[1], x_filter, 1);
+ // Second 4 output values.
+ sum[1] = vdotq_lane_s32(correction, permuted_samples[1], x_filter, 0);
+ sum[1] = vdotq_lane_s32(sum[1], permuted_samples[2], x_filter, 1);
+
+ // Narrow and re-pack.
+ // We halved the convolution filter values so -1 from the right shift.
+ int16x8_t res = vcombine_s16(vshrn_n_s32(sum[0], ROUND0_BITS - 1),
+ vshrn_n_s32(sum[1], ROUND0_BITS - 1));
+ return vreinterpretq_u16_s16(res);
+}
+
void av1_dist_wtd_convolve_x_neon(const uint8_t *src, int src_stride,
uint8_t *dst8, int dst8_stride, int w, int h,
const InterpFilterParams *filter_params_x,
const int subpel_x_qn,
ConvolveParams *conv_params) {
- assert(!(w % 4));
- assert(!(h % 4));
+ assert(w % 4 == 0);
+ assert(h % 4 == 0);
- const int horiz_offset = filter_params_x->taps / 2 - 1;
const int bd = 8;
const int offset_bits = bd + 2 * FILTER_BITS - ROUND0_BITS;
const int16_t round_offset = (1 << (offset_bits - COMPOUND_ROUND1_BITS)) +
(1 << (offset_bits - COMPOUND_ROUND1_BITS - 1));
const int16x8_t round_offset_vec = vdupq_n_s16(round_offset);
+
+ const int do_average = conv_params->do_average;
+ const int use_dist_wtd_comp_avg = conv_params->use_dist_wtd_comp_avg;
const uint16_t fwd_offset = conv_params->fwd_offset;
const uint16_t bck_offset = conv_params->bck_offset;
- const int use_dist_wtd_comp_avg = conv_params->use_dist_wtd_comp_avg;
// Horizontal filter.
const int16_t *x_filter_ptr = av1_get_interp_filter_subpel_kernel(
@@ -1268,22 +1357,23 @@
// Filter values are even, so downshift by 1 to reduce intermediate precision
// requirements.
const int8x8_t x_filter = vshrn_n_s16(vld1q_s16(x_filter_ptr), 1);
- // Dot-product constants.
+
+ // Dot-product constants and other shims.
const uint8x16_t range_limit = vdupq_n_u8(128);
const int32_t correction_s32 = vaddlvq_s16(vshll_n_s8(x_filter, 7));
- // This shim of 1 << ((ROUND0_BITS - 1) - 1) enables us to use non-rounding
- // shifts - which are generally faster than rounding shifts on modern CPUs.
- // The outermost -1 is needed because we halved the filter values.
+ // Fold round_offset into the dot-product filter correction constant. The
+ // additional shim of 1 << ((ROUND0_BITS - 1) - 1) enables us to use non-
+ // rounding shifts - which are generally faster than rounding shifts on
+ // modern CPUs. (The extra -1 is needed because we halved the filter values.)
int32x4_t correction =
vdupq_n_s32(correction_s32 + (round_offset << (ROUND0_BITS - 1)) +
(1 << ((ROUND0_BITS - 1) - 1)));
+ const int horiz_offset = filter_params_x->taps / 2 - 1;
const uint8_t *src_ptr = src - horiz_offset;
- CONV_BUF_TYPE *dst = conv_params->dst;
- CONV_BUF_TYPE *dst_ptr = dst;
- uint8_t *dst_u8_ptr = dst8;
+ CONV_BUF_TYPE *dst_ptr = conv_params->dst;
+ uint8_t *dst8_ptr = dst8;
int dst_stride = conv_params->dst_stride;
- int width = w;
int height = h;
if (w == 4) {
@@ -1291,104 +1381,79 @@
do {
uint8x16_t s0, s1, s2, s3;
- int32x4_t d0, d1, d2, d3;
- int16x8_t d01, d23;
- uint16x4_t dd0, dd1, dd2, dd3;
+ uint16x4_t d0, d1, d2, d3, dd0, dd1, dd2, dd3;
uint8x8_t d01_u8, d23_u8;
load_u8_16x4(src_ptr, src_stride, &s0, &s1, &s2, &s3);
- d0 = convolve8_4_sdot(s0, x_filter, correction, range_limit, permute_tbl);
- d1 = convolve8_4_sdot(s1, x_filter, correction, range_limit, permute_tbl);
- d2 = convolve8_4_sdot(s2, x_filter, correction, range_limit, permute_tbl);
- d3 = convolve8_4_sdot(s3, x_filter, correction, range_limit, permute_tbl);
+ d0 = convolve8_4_x(s0, x_filter, correction, range_limit, permute_tbl);
+ d1 = convolve8_4_x(s1, x_filter, correction, range_limit, permute_tbl);
+ d2 = convolve8_4_x(s2, x_filter, correction, range_limit, permute_tbl);
+ d3 = convolve8_4_x(s3, x_filter, correction, range_limit, permute_tbl);
- // We halved the convolution filter values so -1 from the right shift.
- d01 = vcombine_s16(vshrn_n_s32(d0, ROUND0_BITS - 1),
- vshrn_n_s32(d1, ROUND0_BITS - 1));
- d23 = vcombine_s16(vshrn_n_s32(d2, ROUND0_BITS - 1),
- vshrn_n_s32(d3, ROUND0_BITS - 1));
-
- if (conv_params->do_average) {
+ if (do_average) {
load_u16_4x4(dst_ptr, dst_stride, &dd0, &dd1, &dd2, &dd3);
- compute_avg_4x4(
- dd0, dd1, dd2, dd3, vreinterpret_u16_s16(vget_low_s16(d01)),
- vreinterpret_u16_s16(vget_high_s16(d01)),
- vreinterpret_u16_s16(vget_low_s16(d23)),
- vreinterpret_u16_s16(vget_high_s16(d23)), fwd_offset, bck_offset,
- round_offset_vec, use_dist_wtd_comp_avg, &d01_u8, &d23_u8);
+ compute_avg_4x4(dd0, dd1, dd2, dd3, d0, d1, d2, d3, fwd_offset,
+ bck_offset, round_offset_vec, use_dist_wtd_comp_avg,
+ &d01_u8, &d23_u8);
- store_u8_4x1(dst_u8_ptr + 0 * dst8_stride, d01_u8, 0);
- store_u8_4x1(dst_u8_ptr + 1 * dst8_stride, d01_u8, 1);
- store_u8_4x1(dst_u8_ptr + 2 * dst8_stride, d23_u8, 0);
- store_u8_4x1(dst_u8_ptr + 3 * dst8_stride, d23_u8, 1);
+ store_u8_4x1(dst8_ptr + 0 * dst8_stride, d01_u8, 0);
+ store_u8_4x1(dst8_ptr + 1 * dst8_stride, d01_u8, 1);
+ store_u8_4x1(dst8_ptr + 2 * dst8_stride, d23_u8, 0);
+ store_u8_4x1(dst8_ptr + 3 * dst8_stride, d23_u8, 1);
} else {
- store_u16_4x4(dst_ptr, dst_stride,
- vreinterpret_u16_s16(vget_low_s16(d01)),
- vreinterpret_u16_s16(vget_high_s16(d01)),
- vreinterpret_u16_s16(vget_low_s16(d23)),
- vreinterpret_u16_s16(vget_high_s16(d23)));
+ store_u16_4x4(dst_ptr, dst_stride, d0, d1, d2, d3);
}
src_ptr += 4 * src_stride;
dst_ptr += 4 * dst_stride;
- dst_u8_ptr += 4 * dst8_stride;
+ dst8_ptr += 4 * dst8_stride;
height -= 4;
- } while (height > 0);
+ } while (height != 0);
} else {
const uint8x16x3_t permute_tbl = vld1q_u8_x3(dot_prod_permute_tbl);
do {
const uint8_t *s = src_ptr;
CONV_BUF_TYPE *d = dst_ptr;
- uint8_t *d_u8 = dst_u8_ptr;
- width = w;
+ uint8_t *d_u8 = dst8_ptr;
+ int width = w;
do {
uint8x16_t s0, s1, s2, s3;
- int16x8_t d0, d1, d2, d3;
- uint16x8_t dd0, dd1, dd2, dd3;
+ uint16x8_t d0, d1, d2, d3, dd0, dd1, dd2, dd3;
uint8x8_t d0_u8, d1_u8, d2_u8, d3_u8;
load_u8_16x4(s, src_stride, &s0, &s1, &s2, &s3);
- d0 = convolve8_horiz_8_sdot(s0, x_filter, correction, range_limit,
- permute_tbl);
- d1 = convolve8_horiz_8_sdot(s1, x_filter, correction, range_limit,
- permute_tbl);
- d2 = convolve8_horiz_8_sdot(s2, x_filter, correction, range_limit,
- permute_tbl);
- d3 = convolve8_horiz_8_sdot(s3, x_filter, correction, range_limit,
- permute_tbl);
+ d0 = convolve8_8_x(s0, x_filter, correction, range_limit, permute_tbl);
+ d1 = convolve8_8_x(s1, x_filter, correction, range_limit, permute_tbl);
+ d2 = convolve8_8_x(s2, x_filter, correction, range_limit, permute_tbl);
+ d3 = convolve8_8_x(s3, x_filter, correction, range_limit, permute_tbl);
- if (conv_params->do_average) {
+ if (do_average) {
load_u16_8x4(d, dst_stride, &dd0, &dd1, &dd2, &dd3);
- compute_avg_8x4(dd0, dd1, dd2, dd3, vreinterpretq_u16_s16(d0),
- vreinterpretq_u16_s16(d1), vreinterpretq_u16_s16(d2),
- vreinterpretq_u16_s16(d3), fwd_offset, bck_offset,
- round_offset_vec, use_dist_wtd_comp_avg, &d0_u8,
- &d1_u8, &d2_u8, &d3_u8);
+ compute_avg_8x4(dd0, dd1, dd2, dd3, d0, d1, d2, d3, fwd_offset,
+ bck_offset, round_offset_vec, use_dist_wtd_comp_avg,
+ &d0_u8, &d1_u8, &d2_u8, &d3_u8);
store_u8_8x4(d_u8, dst8_stride, d0_u8, d1_u8, d2_u8, d3_u8);
} else {
- store_u16_8x4(d, dst_stride, vreinterpretq_u16_s16(d0),
- vreinterpretq_u16_s16(d1), vreinterpretq_u16_s16(d2),
- vreinterpretq_u16_s16(d3));
+ store_u16_8x4(d, dst_stride, d0, d1, d2, d3);
}
s += 8;
d += 8;
d_u8 += 8;
width -= 8;
- } while (width > 0);
-
+ } while (width != 0);
src_ptr += 4 * src_stride;
dst_ptr += 4 * dst_stride;
- dst_u8_ptr += 4 * dst8_stride;
+ dst8_ptr += 4 * dst8_stride;
height -= 4;
- } while (height > 0);
+ } while (height != 0);
}
}
