add vpx high bitdepth convolve8 NEON intrinsics optimization
BUG=webm:1299 Change-Id: I236bfa0441e357b6ff05add8269a2cfb543924d1
This commit is contained in:
Linfeng Zhang
parent
6c309c1f59
commit
9c8981c666
@ -919,6 +919,24 @@ WRAP(convolve_copy_neon, 10)
|
||||
WRAP(convolve_avg_neon, 10)
|
||||
WRAP(convolve_copy_neon, 12)
|
||||
WRAP(convolve_avg_neon, 12)
|
||||
WRAP(convolve8_horiz_neon, 8)
|
||||
WRAP(convolve8_avg_horiz_neon, 8)
|
||||
WRAP(convolve8_vert_neon, 8)
|
||||
WRAP(convolve8_avg_vert_neon, 8)
|
||||
WRAP(convolve8_neon, 8)
|
||||
WRAP(convolve8_avg_neon, 8)
|
||||
WRAP(convolve8_horiz_neon, 10)
|
||||
WRAP(convolve8_avg_horiz_neon, 10)
|
||||
WRAP(convolve8_vert_neon, 10)
|
||||
WRAP(convolve8_avg_vert_neon, 10)
|
||||
WRAP(convolve8_neon, 10)
|
||||
WRAP(convolve8_avg_neon, 10)
|
||||
WRAP(convolve8_horiz_neon, 12)
|
||||
WRAP(convolve8_avg_horiz_neon, 12)
|
||||
WRAP(convolve8_vert_neon, 12)
|
||||
WRAP(convolve8_avg_vert_neon, 12)
|
||||
WRAP(convolve8_neon, 12)
|
||||
WRAP(convolve8_avg_neon, 12)
|
||||
#endif // HAVE_NEON
|
||||
|
||||
WRAP(convolve_copy_c, 8)
|
||||
@ -1056,27 +1074,28 @@ INSTANTIATE_TEST_CASE_P(AVX2, ConvolveTest,
|
||||
#if CONFIG_VP9_HIGHBITDEPTH
|
||||
const ConvolveFunctions convolve8_neon(
|
||||
wrap_convolve_copy_neon_8, wrap_convolve_avg_neon_8,
|
||||
wrap_convolve8_horiz_c_8, wrap_convolve8_avg_horiz_c_8,
|
||||
wrap_convolve8_vert_c_8, wrap_convolve8_avg_vert_c_8, wrap_convolve8_c_8,
|
||||
wrap_convolve8_avg_c_8, wrap_convolve8_horiz_c_8,
|
||||
wrap_convolve8_avg_horiz_c_8, wrap_convolve8_vert_c_8,
|
||||
wrap_convolve8_avg_vert_c_8, wrap_convolve8_c_8, wrap_convolve8_avg_c_8, 8);
|
||||
wrap_convolve8_horiz_neon_8, wrap_convolve8_avg_horiz_neon_8,
|
||||
wrap_convolve8_vert_neon_8, wrap_convolve8_avg_vert_neon_8,
|
||||
wrap_convolve8_neon_8, wrap_convolve8_avg_neon_8,
|
||||
wrap_convolve8_horiz_neon_8, wrap_convolve8_avg_horiz_neon_8,
|
||||
wrap_convolve8_vert_neon_8, wrap_convolve8_avg_vert_neon_8,
|
||||
wrap_convolve8_neon_8, wrap_convolve8_avg_neon_8, 8);
|
||||
const ConvolveFunctions convolve10_neon(
|
||||
wrap_convolve_copy_neon_10, wrap_convolve_avg_neon_10,
|
||||
wrap_convolve8_horiz_c_10, wrap_convolve8_avg_horiz_c_10,
|
||||
wrap_convolve8_vert_c_10, wrap_convolve8_avg_vert_c_10, wrap_convolve8_c_10,
|
||||
wrap_convolve8_avg_c_10, wrap_convolve8_horiz_c_10,
|
||||
wrap_convolve8_avg_horiz_c_10, wrap_convolve8_vert_c_10,
|
||||
wrap_convolve8_avg_vert_c_10, wrap_convolve8_c_10, wrap_convolve8_avg_c_10,
|
||||
10);
|
||||
wrap_convolve8_horiz_neon_10, wrap_convolve8_avg_horiz_neon_10,
|
||||
wrap_convolve8_vert_neon_10, wrap_convolve8_avg_vert_neon_10,
|
||||
wrap_convolve8_neon_10, wrap_convolve8_avg_neon_10,
|
||||
wrap_convolve8_horiz_neon_10, wrap_convolve8_avg_horiz_neon_10,
|
||||
wrap_convolve8_vert_neon_10, wrap_convolve8_avg_vert_neon_10,
|
||||
wrap_convolve8_neon_10, wrap_convolve8_avg_neon_10, 10);
|
||||
const ConvolveFunctions convolve12_neon(
|
||||
wrap_convolve_copy_neon_12, wrap_convolve_avg_neon_12,
|
||||
wrap_convolve8_horiz_c_12, wrap_convolve8_avg_horiz_c_12,
|
||||
wrap_convolve8_vert_c_12, wrap_convolve8_avg_vert_c_12, wrap_convolve8_c_12,
|
||||
wrap_convolve8_avg_c_12, wrap_convolve8_horiz_c_12,
|
||||
wrap_convolve8_avg_horiz_c_12, wrap_convolve8_vert_c_12,
|
||||
wrap_convolve8_avg_vert_c_12, wrap_convolve8_c_12, wrap_convolve8_avg_c_12,
|
||||
12);
|
||||
wrap_convolve8_horiz_neon_12, wrap_convolve8_avg_horiz_neon_12,
|
||||
wrap_convolve8_vert_neon_12, wrap_convolve8_avg_vert_neon_12,
|
||||
wrap_convolve8_neon_12, wrap_convolve8_avg_neon_12,
|
||||
wrap_convolve8_horiz_neon_12, wrap_convolve8_avg_horiz_neon_12,
|
||||
wrap_convolve8_vert_neon_12, wrap_convolve8_avg_vert_neon_12,
|
||||
wrap_convolve8_neon_12, wrap_convolve8_avg_neon_12, 12);
|
||||
const ConvolveParam kArrayConvolve_neon[] = { ALL_SIZES(convolve8_neon),
|
||||
ALL_SIZES(convolve10_neon),
|
||||
ALL_SIZES(convolve12_neon) };
|
||||
|
||||
923
vpx_dsp/arm/highbd_vpx_convolve8_neon.c
Normal file
923
vpx_dsp/arm/highbd_vpx_convolve8_neon.c
Normal file
@ -0,0 +1,923 @@
|
||||
/*
|
||||
* Copyright (c) 2016 The WebM project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#include <arm_neon.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "./vpx_config.h"
|
||||
#include "./vpx_dsp_rtcd.h"
|
||||
#include "vpx/vpx_integer.h"
|
||||
#include "vpx_dsp/arm/transpose_neon.h"
|
||||
#include "vpx_ports/mem.h"
|
||||
|
||||
static INLINE void load_4x4(const int16_t *s, ptrdiff_t p, int16x4_t *s0,
|
||||
int16x4_t *s1, int16x4_t *s2, int16x4_t *s3) {
|
||||
*s0 = vld1_s16(s);
|
||||
s += p;
|
||||
*s1 = vld1_s16(s);
|
||||
s += p;
|
||||
*s2 = vld1_s16(s);
|
||||
s += p;
|
||||
*s3 = vld1_s16(s);
|
||||
}
|
||||
|
||||
static INLINE void load_8x4(const uint16_t *s, ptrdiff_t p, uint16x8_t *s0,
|
||||
uint16x8_t *s1, uint16x8_t *s2, uint16x8_t *s3) {
|
||||
*s0 = vld1q_u16(s);
|
||||
s += p;
|
||||
*s1 = vld1q_u16(s);
|
||||
s += p;
|
||||
*s2 = vld1q_u16(s);
|
||||
s += p;
|
||||
*s3 = vld1q_u16(s);
|
||||
}
|
||||
|
||||
static INLINE void load_8x8(const int16_t *s, ptrdiff_t p, int16x8_t *s0,
|
||||
int16x8_t *s1, int16x8_t *s2, int16x8_t *s3,
|
||||
int16x8_t *s4, int16x8_t *s5, int16x8_t *s6,
|
||||
int16x8_t *s7) {
|
||||
*s0 = vld1q_s16(s);
|
||||
s += p;
|
||||
*s1 = vld1q_s16(s);
|
||||
s += p;
|
||||
*s2 = vld1q_s16(s);
|
||||
s += p;
|
||||
*s3 = vld1q_s16(s);
|
||||
s += p;
|
||||
*s4 = vld1q_s16(s);
|
||||
s += p;
|
||||
*s5 = vld1q_s16(s);
|
||||
s += p;
|
||||
*s6 = vld1q_s16(s);
|
||||
s += p;
|
||||
*s7 = vld1q_s16(s);
|
||||
}
|
||||
|
||||
static INLINE void store_8x8(uint16_t *s, ptrdiff_t p, const uint16x8_t s0,
|
||||
const uint16x8_t s1, const uint16x8_t s2,
|
||||
const uint16x8_t s3, const uint16x8_t s4,
|
||||
const uint16x8_t s5, const uint16x8_t s6,
|
||||
const uint16x8_t s7) {
|
||||
vst1q_u16(s, s0);
|
||||
s += p;
|
||||
vst1q_u16(s, s1);
|
||||
s += p;
|
||||
vst1q_u16(s, s2);
|
||||
s += p;
|
||||
vst1q_u16(s, s3);
|
||||
s += p;
|
||||
vst1q_u16(s, s4);
|
||||
s += p;
|
||||
vst1q_u16(s, s5);
|
||||
s += p;
|
||||
vst1q_u16(s, s6);
|
||||
s += p;
|
||||
vst1q_u16(s, s7);
|
||||
}
|
||||
|
||||
static INLINE int32x4_t convolve8_4(const int16x4_t s0, const int16x4_t s1,
|
||||
const int16x4_t s2, const int16x4_t s3,
|
||||
const int16x4_t s4, const int16x4_t s5,
|
||||
const int16x4_t s6, const int16x4_t s7,
|
||||
const int16x8_t filters) {
|
||||
const int16x4_t filters_lo = vget_low_s16(filters);
|
||||
const int16x4_t filters_hi = vget_high_s16(filters);
|
||||
int32x4_t sum = vdupq_n_s32(0);
|
||||
|
||||
sum = vmlal_lane_s16(sum, s0, filters_lo, 0);
|
||||
sum = vmlal_lane_s16(sum, s1, filters_lo, 1);
|
||||
sum = vmlal_lane_s16(sum, s2, filters_lo, 2);
|
||||
sum = vmlal_lane_s16(sum, s3, filters_lo, 3);
|
||||
sum = vmlal_lane_s16(sum, s4, filters_hi, 0);
|
||||
sum = vmlal_lane_s16(sum, s5, filters_hi, 1);
|
||||
sum = vmlal_lane_s16(sum, s6, filters_hi, 2);
|
||||
sum = vmlal_lane_s16(sum, s7, filters_hi, 3);
|
||||
return sum;
|
||||
}
|
||||
|
||||
static INLINE uint16x8_t convolve8_8(const int16x8_t s0, const int16x8_t s1,
|
||||
const int16x8_t s2, const int16x8_t s3,
|
||||
const int16x8_t s4, const int16x8_t s5,
|
||||
const int16x8_t s6, const int16x8_t s7,
|
||||
const int16x8_t filters,
|
||||
const uint16x8_t max) {
|
||||
const int16x4_t filters_lo = vget_low_s16(filters);
|
||||
const int16x4_t filters_hi = vget_high_s16(filters);
|
||||
int32x4_t sum0 = vdupq_n_s32(0);
|
||||
int32x4_t sum1 = vdupq_n_s32(0);
|
||||
uint16x8_t d;
|
||||
|
||||
sum0 = vmlal_lane_s16(sum0, vget_low_s16(s0), filters_lo, 0);
|
||||
sum0 = vmlal_lane_s16(sum0, vget_low_s16(s1), filters_lo, 1);
|
||||
sum0 = vmlal_lane_s16(sum0, vget_low_s16(s2), filters_lo, 2);
|
||||
sum0 = vmlal_lane_s16(sum0, vget_low_s16(s3), filters_lo, 3);
|
||||
sum0 = vmlal_lane_s16(sum0, vget_low_s16(s4), filters_hi, 0);
|
||||
sum0 = vmlal_lane_s16(sum0, vget_low_s16(s5), filters_hi, 1);
|
||||
sum0 = vmlal_lane_s16(sum0, vget_low_s16(s6), filters_hi, 2);
|
||||
sum0 = vmlal_lane_s16(sum0, vget_low_s16(s7), filters_hi, 3);
|
||||
sum1 = vmlal_lane_s16(sum1, vget_high_s16(s0), filters_lo, 0);
|
||||
sum1 = vmlal_lane_s16(sum1, vget_high_s16(s1), filters_lo, 1);
|
||||
sum1 = vmlal_lane_s16(sum1, vget_high_s16(s2), filters_lo, 2);
|
||||
sum1 = vmlal_lane_s16(sum1, vget_high_s16(s3), filters_lo, 3);
|
||||
sum1 = vmlal_lane_s16(sum1, vget_high_s16(s4), filters_hi, 0);
|
||||
sum1 = vmlal_lane_s16(sum1, vget_high_s16(s5), filters_hi, 1);
|
||||
sum1 = vmlal_lane_s16(sum1, vget_high_s16(s6), filters_hi, 2);
|
||||
sum1 = vmlal_lane_s16(sum1, vget_high_s16(s7), filters_hi, 3);
|
||||
d = vcombine_u16(vqrshrun_n_s32(sum0, 7), vqrshrun_n_s32(sum1, 7));
|
||||
d = vminq_u16(d, max);
|
||||
return d;
|
||||
}
|
||||
|
||||
void vpx_highbd_convolve8_horiz_neon(const uint8_t *src8, ptrdiff_t src_stride,
|
||||
uint8_t *dst8, ptrdiff_t dst_stride,
|
||||
const int16_t *filter_x, int x_step_q4,
|
||||
const int16_t *filter_y, // unused
|
||||
int y_step_q4, // unused
|
||||
int w, int h, int bd) {
|
||||
if (x_step_q4 != 16) {
|
||||
vpx_highbd_convolve8_horiz_c(src8, src_stride, dst8, dst_stride, filter_x,
|
||||
x_step_q4, filter_y, y_step_q4, w, h, bd);
|
||||
} else {
|
||||
const uint16_t *src = CONVERT_TO_SHORTPTR(src8);
|
||||
uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
|
||||
const int16x8_t filters = vld1q_s16(filter_x);
|
||||
const uint16x8_t max = vdupq_n_u16((1 << bd) - 1);
|
||||
uint16x8_t t0, t1, t2, t3;
|
||||
|
||||
assert(!((intptr_t)dst & 3));
|
||||
assert(!(dst_stride & 3));
|
||||
|
||||
src -= 3;
|
||||
|
||||
if (h == 4) {
|
||||
int16x4_t s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
|
||||
int32x4_t d0, d1, d2, d3;
|
||||
uint16x8_t d01, d23;
|
||||
|
||||
__builtin_prefetch(src + 0 * src_stride);
|
||||
__builtin_prefetch(src + 1 * src_stride);
|
||||
__builtin_prefetch(src + 2 * src_stride);
|
||||
__builtin_prefetch(src + 3 * src_stride);
|
||||
load_8x4(src, src_stride, &t0, &t1, &t2, &t3);
|
||||
transpose_u16_8x4(&t0, &t1, &t2, &t3);
|
||||
s0 = vreinterpret_s16_u16(vget_low_u16(t0));
|
||||
s1 = vreinterpret_s16_u16(vget_low_u16(t1));
|
||||
s2 = vreinterpret_s16_u16(vget_low_u16(t2));
|
||||
s3 = vreinterpret_s16_u16(vget_low_u16(t3));
|
||||
s4 = vreinterpret_s16_u16(vget_high_u16(t0));
|
||||
s5 = vreinterpret_s16_u16(vget_high_u16(t1));
|
||||
s6 = vreinterpret_s16_u16(vget_high_u16(t2));
|
||||
__builtin_prefetch(dst + 0 * dst_stride);
|
||||
__builtin_prefetch(dst + 1 * dst_stride);
|
||||
__builtin_prefetch(dst + 2 * dst_stride);
|
||||
__builtin_prefetch(dst + 3 * dst_stride);
|
||||
src += 7;
|
||||
|
||||
do {
|
||||
load_4x4((const int16_t *)src, src_stride, &s7, &s8, &s9, &s10);
|
||||
transpose_s16_4x4d(&s7, &s8, &s9, &s10);
|
||||
|
||||
d0 = convolve8_4(s0, s1, s2, s3, s4, s5, s6, s7, filters);
|
||||
d1 = convolve8_4(s1, s2, s3, s4, s5, s6, s7, s8, filters);
|
||||
d2 = convolve8_4(s2, s3, s4, s5, s6, s7, s8, s9, filters);
|
||||
d3 = convolve8_4(s3, s4, s5, s6, s7, s8, s9, s10, filters);
|
||||
|
||||
d01 = vcombine_u16(vqrshrun_n_s32(d0, 7), vqrshrun_n_s32(d1, 7));
|
||||
d23 = vcombine_u16(vqrshrun_n_s32(d2, 7), vqrshrun_n_s32(d3, 7));
|
||||
d01 = vminq_u16(d01, max);
|
||||
d23 = vminq_u16(d23, max);
|
||||
transpose_u16_4x4q(&d01, &d23);
|
||||
|
||||
vst1_u16(dst + 0 * dst_stride, vget_low_u16(d01));
|
||||
vst1_u16(dst + 1 * dst_stride, vget_low_u16(d23));
|
||||
vst1_u16(dst + 2 * dst_stride, vget_high_u16(d01));
|
||||
vst1_u16(dst + 3 * dst_stride, vget_high_u16(d23));
|
||||
|
||||
s0 = s4;
|
||||
s1 = s5;
|
||||
s2 = s6;
|
||||
s3 = s7;
|
||||
s4 = s8;
|
||||
s5 = s9;
|
||||
s6 = s10;
|
||||
src += 4;
|
||||
dst += 4;
|
||||
w -= 4;
|
||||
} while (w > 0);
|
||||
} else {
|
||||
int16x8_t t4, t5, t6, t7;
|
||||
int16x8_t s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
|
||||
uint16x8_t d0, d1, d2, d3;
|
||||
|
||||
if (w == 4) {
|
||||
do {
|
||||
load_8x8((const int16_t *)src, src_stride, &s0, &s1, &s2, &s3, &s4,
|
||||
&s5, &s6, &s7);
|
||||
transpose_s16_8x8(&s0, &s1, &s2, &s3, &s4, &s5, &s6, &s7);
|
||||
|
||||
load_8x8((const int16_t *)(src + 7), src_stride, &s7, &s8, &s9, &s10,
|
||||
&t4, &t5, &t6, &t7);
|
||||
src += 8 * src_stride;
|
||||
__builtin_prefetch(dst + 0 * dst_stride);
|
||||
__builtin_prefetch(dst + 1 * dst_stride);
|
||||
__builtin_prefetch(dst + 2 * dst_stride);
|
||||
__builtin_prefetch(dst + 3 * dst_stride);
|
||||
__builtin_prefetch(dst + 4 * dst_stride);
|
||||
__builtin_prefetch(dst + 5 * dst_stride);
|
||||
__builtin_prefetch(dst + 6 * dst_stride);
|
||||
__builtin_prefetch(dst + 7 * dst_stride);
|
||||
transpose_s16_8x8(&s7, &s8, &s9, &s10, &t4, &t5, &t6, &t7);
|
||||
|
||||
__builtin_prefetch(src + 0 * src_stride);
|
||||
__builtin_prefetch(src + 1 * src_stride);
|
||||
__builtin_prefetch(src + 2 * src_stride);
|
||||
__builtin_prefetch(src + 3 * src_stride);
|
||||
__builtin_prefetch(src + 4 * src_stride);
|
||||
__builtin_prefetch(src + 5 * src_stride);
|
||||
__builtin_prefetch(src + 6 * src_stride);
|
||||
__builtin_prefetch(src + 7 * src_stride);
|
||||
d0 = convolve8_8(s0, s1, s2, s3, s4, s5, s6, s7, filters, max);
|
||||
d1 = convolve8_8(s1, s2, s3, s4, s5, s6, s7, s8, filters, max);
|
||||
d2 = convolve8_8(s2, s3, s4, s5, s6, s7, s8, s9, filters, max);
|
||||
d3 = convolve8_8(s3, s4, s5, s6, s7, s8, s9, s10, filters, max);
|
||||
|
||||
transpose_u16_8x4(&d0, &d1, &d2, &d3);
|
||||
vst1_u16(dst, vget_low_u16(d0));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_low_u16(d1));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_low_u16(d2));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_low_u16(d3));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_high_u16(d0));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_high_u16(d1));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_high_u16(d2));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_high_u16(d3));
|
||||
dst += dst_stride;
|
||||
h -= 8;
|
||||
} while (h > 0);
|
||||
} else {
|
||||
int width;
|
||||
const uint16_t *s;
|
||||
uint16_t *d;
|
||||
int16x8_t s11, s12, s13, s14;
|
||||
uint16x8_t d4, d5, d6, d7;
|
||||
|
||||
do {
|
||||
__builtin_prefetch(src + 0 * src_stride);
|
||||
__builtin_prefetch(src + 1 * src_stride);
|
||||
__builtin_prefetch(src + 2 * src_stride);
|
||||
__builtin_prefetch(src + 3 * src_stride);
|
||||
__builtin_prefetch(src + 4 * src_stride);
|
||||
__builtin_prefetch(src + 5 * src_stride);
|
||||
__builtin_prefetch(src + 6 * src_stride);
|
||||
__builtin_prefetch(src + 7 * src_stride);
|
||||
load_8x8((const int16_t *)src, src_stride, &s0, &s1, &s2, &s3, &s4,
|
||||
&s5, &s6, &s7);
|
||||
transpose_s16_8x8(&s0, &s1, &s2, &s3, &s4, &s5, &s6, &s7);
|
||||
|
||||
width = w;
|
||||
s = src + 7;
|
||||
d = dst;
|
||||
__builtin_prefetch(dst + 0 * dst_stride);
|
||||
__builtin_prefetch(dst + 1 * dst_stride);
|
||||
__builtin_prefetch(dst + 2 * dst_stride);
|
||||
__builtin_prefetch(dst + 3 * dst_stride);
|
||||
__builtin_prefetch(dst + 4 * dst_stride);
|
||||
__builtin_prefetch(dst + 5 * dst_stride);
|
||||
__builtin_prefetch(dst + 6 * dst_stride);
|
||||
__builtin_prefetch(dst + 7 * dst_stride);
|
||||
|
||||
do {
|
||||
load_8x8((const int16_t *)s, src_stride, &s7, &s8, &s9, &s10, &s11,
|
||||
&s12, &s13, &s14);
|
||||
transpose_s16_8x8(&s7, &s8, &s9, &s10, &s11, &s12, &s13, &s14);
|
||||
|
||||
d0 = convolve8_8(s0, s1, s2, s3, s4, s5, s6, s7, filters, max);
|
||||
d1 = convolve8_8(s1, s2, s3, s4, s5, s6, s7, s8, filters, max);
|
||||
d2 = convolve8_8(s2, s3, s4, s5, s6, s7, s8, s9, filters, max);
|
||||
d3 = convolve8_8(s3, s4, s5, s6, s7, s8, s9, s10, filters, max);
|
||||
d4 = convolve8_8(s4, s5, s6, s7, s8, s9, s10, s11, filters, max);
|
||||
d5 = convolve8_8(s5, s6, s7, s8, s9, s10, s11, s12, filters, max);
|
||||
d6 = convolve8_8(s6, s7, s8, s9, s10, s11, s12, s13, filters, max);
|
||||
d7 = convolve8_8(s7, s8, s9, s10, s11, s12, s13, s14, filters, max);
|
||||
|
||||
transpose_u16_8x8(&d0, &d1, &d2, &d3, &d4, &d5, &d6, &d7);
|
||||
store_8x8(d, dst_stride, d0, d1, d2, d3, d4, d5, d6, d7);
|
||||
|
||||
s0 = s8;
|
||||
s1 = s9;
|
||||
s2 = s10;
|
||||
s3 = s11;
|
||||
s4 = s12;
|
||||
s5 = s13;
|
||||
s6 = s14;
|
||||
s += 8;
|
||||
d += 8;
|
||||
width -= 8;
|
||||
} while (width > 0);
|
||||
src += 8 * src_stride;
|
||||
dst += 8 * dst_stride;
|
||||
h -= 8;
|
||||
} while (h > 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void vpx_highbd_convolve8_avg_horiz_neon(const uint8_t *src8,
|
||||
ptrdiff_t src_stride, uint8_t *dst8,
|
||||
ptrdiff_t dst_stride,
|
||||
const int16_t *filter_x, int x_step_q4,
|
||||
const int16_t *filter_y, // unused
|
||||
int y_step_q4, // unused
|
||||
int w, int h, int bd) {
|
||||
if (x_step_q4 != 16) {
|
||||
vpx_highbd_convolve8_avg_horiz_c(src8, src_stride, dst8, dst_stride,
|
||||
filter_x, x_step_q4, filter_y, y_step_q4,
|
||||
w, h, bd);
|
||||
} else {
|
||||
const uint16_t *src = CONVERT_TO_SHORTPTR(src8);
|
||||
uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
|
||||
const int16x8_t filters = vld1q_s16(filter_x);
|
||||
const uint16x8_t max = vdupq_n_u16((1 << bd) - 1);
|
||||
uint16x8_t t0, t1, t2, t3;
|
||||
|
||||
assert(!((intptr_t)dst & 3));
|
||||
assert(!(dst_stride & 3));
|
||||
|
||||
src -= 3;
|
||||
|
||||
if (h == 4) {
|
||||
int16x4_t s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
|
||||
int32x4_t d0, d1, d2, d3;
|
||||
uint16x8_t d01, d23, t01, t23;
|
||||
|
||||
__builtin_prefetch(src + 0 * src_stride);
|
||||
__builtin_prefetch(src + 1 * src_stride);
|
||||
__builtin_prefetch(src + 2 * src_stride);
|
||||
__builtin_prefetch(src + 3 * src_stride);
|
||||
load_8x4(src, src_stride, &t0, &t1, &t2, &t3);
|
||||
transpose_u16_8x4(&t0, &t1, &t2, &t3);
|
||||
s0 = vreinterpret_s16_u16(vget_low_u16(t0));
|
||||
s1 = vreinterpret_s16_u16(vget_low_u16(t1));
|
||||
s2 = vreinterpret_s16_u16(vget_low_u16(t2));
|
||||
s3 = vreinterpret_s16_u16(vget_low_u16(t3));
|
||||
s4 = vreinterpret_s16_u16(vget_high_u16(t0));
|
||||
s5 = vreinterpret_s16_u16(vget_high_u16(t1));
|
||||
s6 = vreinterpret_s16_u16(vget_high_u16(t2));
|
||||
__builtin_prefetch(dst + 0 * dst_stride);
|
||||
__builtin_prefetch(dst + 1 * dst_stride);
|
||||
__builtin_prefetch(dst + 2 * dst_stride);
|
||||
__builtin_prefetch(dst + 3 * dst_stride);
|
||||
src += 7;
|
||||
|
||||
do {
|
||||
load_4x4((const int16_t *)src, src_stride, &s7, &s8, &s9, &s10);
|
||||
transpose_s16_4x4d(&s7, &s8, &s9, &s10);
|
||||
|
||||
d0 = convolve8_4(s0, s1, s2, s3, s4, s5, s6, s7, filters);
|
||||
d1 = convolve8_4(s1, s2, s3, s4, s5, s6, s7, s8, filters);
|
||||
d2 = convolve8_4(s2, s3, s4, s5, s6, s7, s8, s9, filters);
|
||||
d3 = convolve8_4(s3, s4, s5, s6, s7, s8, s9, s10, filters);
|
||||
|
||||
t01 = vcombine_u16(vqrshrun_n_s32(d0, 7), vqrshrun_n_s32(d1, 7));
|
||||
t23 = vcombine_u16(vqrshrun_n_s32(d2, 7), vqrshrun_n_s32(d3, 7));
|
||||
t01 = vminq_u16(t01, max);
|
||||
t23 = vminq_u16(t23, max);
|
||||
transpose_u16_4x4q(&t01, &t23);
|
||||
|
||||
d01 = vcombine_u16(vld1_u16(dst + 0 * dst_stride),
|
||||
vld1_u16(dst + 2 * dst_stride));
|
||||
d23 = vcombine_u16(vld1_u16(dst + 1 * dst_stride),
|
||||
vld1_u16(dst + 3 * dst_stride));
|
||||
d01 = vrhaddq_u16(d01, t01);
|
||||
d23 = vrhaddq_u16(d23, t23);
|
||||
|
||||
vst1_u16(dst + 0 * dst_stride, vget_low_u16(d01));
|
||||
vst1_u16(dst + 1 * dst_stride, vget_low_u16(d23));
|
||||
vst1_u16(dst + 2 * dst_stride, vget_high_u16(d01));
|
||||
vst1_u16(dst + 3 * dst_stride, vget_high_u16(d23));
|
||||
|
||||
s0 = s4;
|
||||
s1 = s5;
|
||||
s2 = s6;
|
||||
s3 = s7;
|
||||
s4 = s8;
|
||||
s5 = s9;
|
||||
s6 = s10;
|
||||
src += 4;
|
||||
dst += 4;
|
||||
w -= 4;
|
||||
} while (w > 0);
|
||||
} else {
|
||||
int16x8_t t4, t5, t6, t7;
|
||||
int16x8_t s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
|
||||
uint16x8_t d0, d1, d2, d3, t0, t1, t2, t3;
|
||||
|
||||
if (w == 4) {
|
||||
do {
|
||||
load_8x8((const int16_t *)src, src_stride, &s0, &s1, &s2, &s3, &s4,
|
||||
&s5, &s6, &s7);
|
||||
transpose_s16_8x8(&s0, &s1, &s2, &s3, &s4, &s5, &s6, &s7);
|
||||
|
||||
load_8x8((const int16_t *)(src + 7), src_stride, &s7, &s8, &s9, &s10,
|
||||
&t4, &t5, &t6, &t7);
|
||||
src += 8 * src_stride;
|
||||
__builtin_prefetch(dst + 0 * dst_stride);
|
||||
__builtin_prefetch(dst + 1 * dst_stride);
|
||||
__builtin_prefetch(dst + 2 * dst_stride);
|
||||
__builtin_prefetch(dst + 3 * dst_stride);
|
||||
__builtin_prefetch(dst + 4 * dst_stride);
|
||||
__builtin_prefetch(dst + 5 * dst_stride);
|
||||
__builtin_prefetch(dst + 6 * dst_stride);
|
||||
__builtin_prefetch(dst + 7 * dst_stride);
|
||||
transpose_s16_8x8(&s7, &s8, &s9, &s10, &t4, &t5, &t6, &t7);
|
||||
|
||||
__builtin_prefetch(src + 0 * src_stride);
|
||||
__builtin_prefetch(src + 1 * src_stride);
|
||||
__builtin_prefetch(src + 2 * src_stride);
|
||||
__builtin_prefetch(src + 3 * src_stride);
|
||||
__builtin_prefetch(src + 4 * src_stride);
|
||||
__builtin_prefetch(src + 5 * src_stride);
|
||||
__builtin_prefetch(src + 6 * src_stride);
|
||||
__builtin_prefetch(src + 7 * src_stride);
|
||||
t0 = convolve8_8(s0, s1, s2, s3, s4, s5, s6, s7, filters, max);
|
||||
t1 = convolve8_8(s1, s2, s3, s4, s5, s6, s7, s8, filters, max);
|
||||
t2 = convolve8_8(s2, s3, s4, s5, s6, s7, s8, s9, filters, max);
|
||||
t3 = convolve8_8(s3, s4, s5, s6, s7, s8, s9, s10, filters, max);
|
||||
transpose_u16_8x4(&t0, &t1, &t2, &t3);
|
||||
|
||||
d0 = vcombine_u16(vld1_u16(dst + 0 * dst_stride),
|
||||
vld1_u16(dst + 4 * dst_stride));
|
||||
d1 = vcombine_u16(vld1_u16(dst + 1 * dst_stride),
|
||||
vld1_u16(dst + 5 * dst_stride));
|
||||
d2 = vcombine_u16(vld1_u16(dst + 2 * dst_stride),
|
||||
vld1_u16(dst + 6 * dst_stride));
|
||||
d3 = vcombine_u16(vld1_u16(dst + 3 * dst_stride),
|
||||
vld1_u16(dst + 7 * dst_stride));
|
||||
d0 = vrhaddq_u16(d0, t0);
|
||||
d1 = vrhaddq_u16(d1, t1);
|
||||
d2 = vrhaddq_u16(d2, t2);
|
||||
d3 = vrhaddq_u16(d3, t3);
|
||||
|
||||
vst1_u16(dst, vget_low_u16(d0));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_low_u16(d1));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_low_u16(d2));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_low_u16(d3));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_high_u16(d0));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_high_u16(d1));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_high_u16(d2));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_high_u16(d3));
|
||||
dst += dst_stride;
|
||||
h -= 8;
|
||||
} while (h > 0);
|
||||
} else {
|
||||
int width;
|
||||
const uint16_t *s;
|
||||
uint16_t *d;
|
||||
int16x8_t s11, s12, s13, s14;
|
||||
uint16x8_t d4, d5, d6, d7;
|
||||
|
||||
do {
|
||||
__builtin_prefetch(src + 0 * src_stride);
|
||||
__builtin_prefetch(src + 1 * src_stride);
|
||||
__builtin_prefetch(src + 2 * src_stride);
|
||||
__builtin_prefetch(src + 3 * src_stride);
|
||||
__builtin_prefetch(src + 4 * src_stride);
|
||||
__builtin_prefetch(src + 5 * src_stride);
|
||||
__builtin_prefetch(src + 6 * src_stride);
|
||||
__builtin_prefetch(src + 7 * src_stride);
|
||||
load_8x8((const int16_t *)src, src_stride, &s0, &s1, &s2, &s3, &s4,
|
||||
&s5, &s6, &s7);
|
||||
transpose_s16_8x8(&s0, &s1, &s2, &s3, &s4, &s5, &s6, &s7);
|
||||
|
||||
width = w;
|
||||
s = src + 7;
|
||||
d = dst;
|
||||
__builtin_prefetch(dst + 0 * dst_stride);
|
||||
__builtin_prefetch(dst + 1 * dst_stride);
|
||||
__builtin_prefetch(dst + 2 * dst_stride);
|
||||
__builtin_prefetch(dst + 3 * dst_stride);
|
||||
__builtin_prefetch(dst + 4 * dst_stride);
|
||||
__builtin_prefetch(dst + 5 * dst_stride);
|
||||
__builtin_prefetch(dst + 6 * dst_stride);
|
||||
__builtin_prefetch(dst + 7 * dst_stride);
|
||||
|
||||
do {
|
||||
load_8x8((const int16_t *)s, src_stride, &s7, &s8, &s9, &s10, &s11,
|
||||
&s12, &s13, &s14);
|
||||
transpose_s16_8x8(&s7, &s8, &s9, &s10, &s11, &s12, &s13, &s14);
|
||||
|
||||
d0 = convolve8_8(s0, s1, s2, s3, s4, s5, s6, s7, filters, max);
|
||||
d1 = convolve8_8(s1, s2, s3, s4, s5, s6, s7, s8, filters, max);
|
||||
d2 = convolve8_8(s2, s3, s4, s5, s6, s7, s8, s9, filters, max);
|
||||
d3 = convolve8_8(s3, s4, s5, s6, s7, s8, s9, s10, filters, max);
|
||||
d4 = convolve8_8(s4, s5, s6, s7, s8, s9, s10, s11, filters, max);
|
||||
d5 = convolve8_8(s5, s6, s7, s8, s9, s10, s11, s12, filters, max);
|
||||
d6 = convolve8_8(s6, s7, s8, s9, s10, s11, s12, s13, filters, max);
|
||||
d7 = convolve8_8(s7, s8, s9, s10, s11, s12, s13, s14, filters, max);
|
||||
|
||||
transpose_u16_8x8(&d0, &d1, &d2, &d3, &d4, &d5, &d6, &d7);
|
||||
|
||||
d0 = vrhaddq_u16(d0, vld1q_u16(d + 0 * dst_stride));
|
||||
d1 = vrhaddq_u16(d1, vld1q_u16(d + 1 * dst_stride));
|
||||
d2 = vrhaddq_u16(d2, vld1q_u16(d + 2 * dst_stride));
|
||||
d3 = vrhaddq_u16(d3, vld1q_u16(d + 3 * dst_stride));
|
||||
d4 = vrhaddq_u16(d4, vld1q_u16(d + 4 * dst_stride));
|
||||
d5 = vrhaddq_u16(d5, vld1q_u16(d + 5 * dst_stride));
|
||||
d6 = vrhaddq_u16(d6, vld1q_u16(d + 6 * dst_stride));
|
||||
d7 = vrhaddq_u16(d7, vld1q_u16(d + 7 * dst_stride));
|
||||
|
||||
store_8x8(d, dst_stride, d0, d1, d2, d3, d4, d5, d6, d7);
|
||||
|
||||
s0 = s8;
|
||||
s1 = s9;
|
||||
s2 = s10;
|
||||
s3 = s11;
|
||||
s4 = s12;
|
||||
s5 = s13;
|
||||
s6 = s14;
|
||||
s += 8;
|
||||
d += 8;
|
||||
width -= 8;
|
||||
} while (width > 0);
|
||||
src += 8 * src_stride;
|
||||
dst += 8 * dst_stride;
|
||||
h -= 8;
|
||||
} while (h > 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void vpx_highbd_convolve8_vert_neon(const uint8_t *src8, ptrdiff_t src_stride,
|
||||
uint8_t *dst8, ptrdiff_t dst_stride,
|
||||
const int16_t *filter_x, // unused
|
||||
int x_step_q4, // unused
|
||||
const int16_t *filter_y, int y_step_q4,
|
||||
int w, int h, int bd) {
|
||||
if (y_step_q4 != 16) {
|
||||
vpx_highbd_convolve8_vert_c(src8, src_stride, dst8, dst_stride, filter_x,
|
||||
x_step_q4, filter_y, y_step_q4, w, h, bd);
|
||||
} else {
|
||||
const uint16_t *src = CONVERT_TO_SHORTPTR(src8);
|
||||
uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
|
||||
const int16x8_t filters = vld1q_s16(filter_y);
|
||||
const uint16x8_t max = vdupq_n_u16((1 << bd) - 1);
|
||||
|
||||
assert(!((intptr_t)dst & 3));
|
||||
assert(!(dst_stride & 3));
|
||||
|
||||
src -= 3 * src_stride;
|
||||
|
||||
if (w == 4) {
|
||||
int16x4_t s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
|
||||
int32x4_t d0, d1, d2, d3;
|
||||
uint16x8_t d01, d23;
|
||||
|
||||
s0 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s1 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s2 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s3 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s4 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s5 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s6 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
|
||||
do {
|
||||
s7 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s8 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s9 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s10 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
|
||||
__builtin_prefetch(dst + 0 * dst_stride);
|
||||
__builtin_prefetch(dst + 1 * dst_stride);
|
||||
__builtin_prefetch(dst + 2 * dst_stride);
|
||||
__builtin_prefetch(dst + 3 * dst_stride);
|
||||
__builtin_prefetch(src + 0 * src_stride);
|
||||
__builtin_prefetch(src + 1 * src_stride);
|
||||
__builtin_prefetch(src + 2 * src_stride);
|
||||
__builtin_prefetch(src + 3 * src_stride);
|
||||
d0 = convolve8_4(s0, s1, s2, s3, s4, s5, s6, s7, filters);
|
||||
d1 = convolve8_4(s1, s2, s3, s4, s5, s6, s7, s8, filters);
|
||||
d2 = convolve8_4(s2, s3, s4, s5, s6, s7, s8, s9, filters);
|
||||
d3 = convolve8_4(s3, s4, s5, s6, s7, s8, s9, s10, filters);
|
||||
|
||||
d01 = vcombine_u16(vqrshrun_n_s32(d0, 7), vqrshrun_n_s32(d1, 7));
|
||||
d23 = vcombine_u16(vqrshrun_n_s32(d2, 7), vqrshrun_n_s32(d3, 7));
|
||||
d01 = vminq_u16(d01, max);
|
||||
d23 = vminq_u16(d23, max);
|
||||
vst1_u16(dst, vget_low_u16(d01));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_high_u16(d01));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_low_u16(d23));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_high_u16(d23));
|
||||
dst += dst_stride;
|
||||
|
||||
s0 = s4;
|
||||
s1 = s5;
|
||||
s2 = s6;
|
||||
s3 = s7;
|
||||
s4 = s8;
|
||||
s5 = s9;
|
||||
s6 = s10;
|
||||
h -= 4;
|
||||
} while (h > 0);
|
||||
} else {
|
||||
int height;
|
||||
const uint16_t *s;
|
||||
uint16_t *d;
|
||||
int16x8_t s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
|
||||
uint16x8_t d0, d1, d2, d3;
|
||||
|
||||
do {
|
||||
__builtin_prefetch(src + 0 * src_stride);
|
||||
__builtin_prefetch(src + 1 * src_stride);
|
||||
__builtin_prefetch(src + 2 * src_stride);
|
||||
__builtin_prefetch(src + 3 * src_stride);
|
||||
__builtin_prefetch(src + 4 * src_stride);
|
||||
__builtin_prefetch(src + 5 * src_stride);
|
||||
__builtin_prefetch(src + 6 * src_stride);
|
||||
s = src;
|
||||
s0 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s1 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s2 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s3 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s4 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s5 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s6 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
d = dst;
|
||||
height = h;
|
||||
|
||||
do {
|
||||
s7 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s8 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s9 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s10 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
|
||||
__builtin_prefetch(d + 0 * dst_stride);
|
||||
__builtin_prefetch(d + 1 * dst_stride);
|
||||
__builtin_prefetch(d + 2 * dst_stride);
|
||||
__builtin_prefetch(d + 3 * dst_stride);
|
||||
__builtin_prefetch(s + 0 * src_stride);
|
||||
__builtin_prefetch(s + 1 * src_stride);
|
||||
__builtin_prefetch(s + 2 * src_stride);
|
||||
__builtin_prefetch(s + 3 * src_stride);
|
||||
d0 = convolve8_8(s0, s1, s2, s3, s4, s5, s6, s7, filters, max);
|
||||
d1 = convolve8_8(s1, s2, s3, s4, s5, s6, s7, s8, filters, max);
|
||||
d2 = convolve8_8(s2, s3, s4, s5, s6, s7, s8, s9, filters, max);
|
||||
d3 = convolve8_8(s3, s4, s5, s6, s7, s8, s9, s10, filters, max);
|
||||
|
||||
vst1q_u16(d, d0);
|
||||
d += dst_stride;
|
||||
vst1q_u16(d, d1);
|
||||
d += dst_stride;
|
||||
vst1q_u16(d, d2);
|
||||
d += dst_stride;
|
||||
vst1q_u16(d, d3);
|
||||
d += dst_stride;
|
||||
|
||||
s0 = s4;
|
||||
s1 = s5;
|
||||
s2 = s6;
|
||||
s3 = s7;
|
||||
s4 = s8;
|
||||
s5 = s9;
|
||||
s6 = s10;
|
||||
height -= 4;
|
||||
} while (height > 0);
|
||||
src += 8;
|
||||
dst += 8;
|
||||
w -= 8;
|
||||
} while (w > 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void vpx_highbd_convolve8_avg_vert_neon(const uint8_t *src8,
|
||||
ptrdiff_t src_stride, uint8_t *dst8,
|
||||
ptrdiff_t dst_stride,
|
||||
const int16_t *filter_x, // unused
|
||||
int x_step_q4, // unused
|
||||
const int16_t *filter_y, int y_step_q4,
|
||||
int w, int h, int bd) {
|
||||
if (y_step_q4 != 16) {
|
||||
vpx_highbd_convolve8_avg_vert_c(src8, src_stride, dst8, dst_stride,
|
||||
filter_x, x_step_q4, filter_y, y_step_q4, w,
|
||||
h, bd);
|
||||
} else {
|
||||
const uint16_t *src = CONVERT_TO_SHORTPTR(src8);
|
||||
uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
|
||||
const int16x8_t filters = vld1q_s16(filter_y);
|
||||
const uint16x8_t max = vdupq_n_u16((1 << bd) - 1);
|
||||
|
||||
assert(!((intptr_t)dst & 3));
|
||||
assert(!(dst_stride & 3));
|
||||
|
||||
src -= 3 * src_stride;
|
||||
|
||||
if (w == 4) {
|
||||
int16x4_t s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
|
||||
int32x4_t d0, d1, d2, d3;
|
||||
uint16x8_t d01, d23, t01, t23;
|
||||
|
||||
s0 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s1 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s2 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s3 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s4 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s5 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s6 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
|
||||
do {
|
||||
s7 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s8 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s9 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
s10 = vreinterpret_s16_u16(vld1_u16(src));
|
||||
src += src_stride;
|
||||
|
||||
__builtin_prefetch(dst + 0 * dst_stride);
|
||||
__builtin_prefetch(dst + 1 * dst_stride);
|
||||
__builtin_prefetch(dst + 2 * dst_stride);
|
||||
__builtin_prefetch(dst + 3 * dst_stride);
|
||||
__builtin_prefetch(src + 0 * src_stride);
|
||||
__builtin_prefetch(src + 1 * src_stride);
|
||||
__builtin_prefetch(src + 2 * src_stride);
|
||||
__builtin_prefetch(src + 3 * src_stride);
|
||||
d0 = convolve8_4(s0, s1, s2, s3, s4, s5, s6, s7, filters);
|
||||
d1 = convolve8_4(s1, s2, s3, s4, s5, s6, s7, s8, filters);
|
||||
d2 = convolve8_4(s2, s3, s4, s5, s6, s7, s8, s9, filters);
|
||||
d3 = convolve8_4(s3, s4, s5, s6, s7, s8, s9, s10, filters);
|
||||
|
||||
t01 = vcombine_u16(vqrshrun_n_s32(d0, 7), vqrshrun_n_s32(d1, 7));
|
||||
t23 = vcombine_u16(vqrshrun_n_s32(d2, 7), vqrshrun_n_s32(d3, 7));
|
||||
t01 = vminq_u16(t01, max);
|
||||
t23 = vminq_u16(t23, max);
|
||||
|
||||
d01 = vcombine_u16(vld1_u16(dst + 0 * dst_stride),
|
||||
vld1_u16(dst + 1 * dst_stride));
|
||||
d23 = vcombine_u16(vld1_u16(dst + 2 * dst_stride),
|
||||
vld1_u16(dst + 3 * dst_stride));
|
||||
d01 = vrhaddq_u16(d01, t01);
|
||||
d23 = vrhaddq_u16(d23, t23);
|
||||
|
||||
vst1_u16(dst, vget_low_u16(d01));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_high_u16(d01));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_low_u16(d23));
|
||||
dst += dst_stride;
|
||||
vst1_u16(dst, vget_high_u16(d23));
|
||||
dst += dst_stride;
|
||||
|
||||
s0 = s4;
|
||||
s1 = s5;
|
||||
s2 = s6;
|
||||
s3 = s7;
|
||||
s4 = s8;
|
||||
s5 = s9;
|
||||
s6 = s10;
|
||||
h -= 4;
|
||||
} while (h > 0);
|
||||
} else {
|
||||
int height;
|
||||
const uint16_t *s;
|
||||
uint16_t *d;
|
||||
int16x8_t s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
|
||||
uint16x8_t d0, d1, d2, d3, t0, t1, t2, t3;
|
||||
|
||||
do {
|
||||
__builtin_prefetch(src + 0 * src_stride);
|
||||
__builtin_prefetch(src + 1 * src_stride);
|
||||
__builtin_prefetch(src + 2 * src_stride);
|
||||
__builtin_prefetch(src + 3 * src_stride);
|
||||
__builtin_prefetch(src + 4 * src_stride);
|
||||
__builtin_prefetch(src + 5 * src_stride);
|
||||
__builtin_prefetch(src + 6 * src_stride);
|
||||
s = src;
|
||||
s0 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s1 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s2 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s3 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s4 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s5 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s6 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
d = dst;
|
||||
height = h;
|
||||
|
||||
do {
|
||||
s7 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s8 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s9 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
s10 = vreinterpretq_s16_u16(vld1q_u16(s));
|
||||
s += src_stride;
|
||||
|
||||
__builtin_prefetch(d + 0 * dst_stride);
|
||||
__builtin_prefetch(d + 1 * dst_stride);
|
||||
__builtin_prefetch(d + 2 * dst_stride);
|
||||
__builtin_prefetch(d + 3 * dst_stride);
|
||||
__builtin_prefetch(s + 0 * src_stride);
|
||||
__builtin_prefetch(s + 1 * src_stride);
|
||||
__builtin_prefetch(s + 2 * src_stride);
|
||||
__builtin_prefetch(s + 3 * src_stride);
|
||||
t0 = convolve8_8(s0, s1, s2, s3, s4, s5, s6, s7, filters, max);
|
||||
t1 = convolve8_8(s1, s2, s3, s4, s5, s6, s7, s8, filters, max);
|
||||
t2 = convolve8_8(s2, s3, s4, s5, s6, s7, s8, s9, filters, max);
|
||||
t3 = convolve8_8(s3, s4, s5, s6, s7, s8, s9, s10, filters, max);
|
||||
|
||||
d0 = vld1q_u16(d + 0 * dst_stride);
|
||||
d1 = vld1q_u16(d + 1 * dst_stride);
|
||||
d2 = vld1q_u16(d + 2 * dst_stride);
|
||||
d3 = vld1q_u16(d + 3 * dst_stride);
|
||||
d0 = vrhaddq_u16(d0, t0);
|
||||
d1 = vrhaddq_u16(d1, t1);
|
||||
d2 = vrhaddq_u16(d2, t2);
|
||||
d3 = vrhaddq_u16(d3, t3);
|
||||
|
||||
vst1q_u16(d, d0);
|
||||
d += dst_stride;
|
||||
vst1q_u16(d, d1);
|
||||
d += dst_stride;
|
||||
vst1q_u16(d, d2);
|
||||
d += dst_stride;
|
||||
vst1q_u16(d, d3);
|
||||
d += dst_stride;
|
||||
|
||||
s0 = s4;
|
||||
s1 = s5;
|
||||
s2 = s6;
|
||||
s3 = s7;
|
||||
s4 = s8;
|
||||
s5 = s9;
|
||||
s6 = s10;
|
||||
height -= 4;
|
||||
} while (height > 0);
|
||||
src += 8;
|
||||
dst += 8;
|
||||
w -= 8;
|
||||
} while (w > 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
65
vpx_dsp/arm/highbd_vpx_convolve_neon.c
Normal file
65
vpx_dsp/arm/highbd_vpx_convolve_neon.c
Normal file
@ -0,0 +1,65 @@
|
||||
/*
|
||||
* Copyright (c) 2016 The WebM project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#include "./vpx_dsp_rtcd.h"
|
||||
#include "vpx_dsp/vpx_dsp_common.h"
|
||||
#include "vpx_dsp/vpx_filter.h"
|
||||
#include "vpx_ports/mem.h"
|
||||
|
||||
void vpx_highbd_convolve8_neon(const uint8_t *src8, ptrdiff_t src_stride,
|
||||
uint8_t *dst, ptrdiff_t dst_stride,
|
||||
const int16_t *filter_x, int x_step_q4,
|
||||
const int16_t *filter_y, int y_step_q4, int w,
|
||||
int h, int bd) {
|
||||
const uint16_t *src = CONVERT_TO_SHORTPTR(src8);
|
||||
const int y0_q4 = get_filter_offset(filter_y, get_filter_base(filter_y));
|
||||
// + 1 to make it divisible by 4
|
||||
DECLARE_ALIGNED(16, uint16_t, temp[64 * 136]);
|
||||
const int intermediate_height =
|
||||
(((h - 1) * y_step_q4 + y0_q4) >> SUBPEL_BITS) + SUBPEL_TAPS;
|
||||
|
||||
/* Filter starting 3 lines back. The neon implementation will ignore the given
|
||||
* height and filter a multiple of 4 lines. Since this goes in to the temp
|
||||
* buffer which has lots of extra room and is subsequently discarded this is
|
||||
* safe if somewhat less than ideal. */
|
||||
vpx_highbd_convolve8_horiz_neon(CONVERT_TO_BYTEPTR(src - src_stride * 3),
|
||||
src_stride, CONVERT_TO_BYTEPTR(temp), w,
|
||||
filter_x, x_step_q4, filter_y, y_step_q4, w,
|
||||
intermediate_height, bd);
|
||||
|
||||
/* Step into the temp buffer 3 lines to get the actual frame data */
|
||||
vpx_highbd_convolve8_vert_neon(CONVERT_TO_BYTEPTR(temp + w * 3), w, dst,
|
||||
dst_stride, filter_x, x_step_q4, filter_y,
|
||||
y_step_q4, w, h, bd);
|
||||
}
|
||||
|
||||
void vpx_highbd_convolve8_avg_neon(const uint8_t *src8, ptrdiff_t src_stride,
|
||||
uint8_t *dst, ptrdiff_t dst_stride,
|
||||
const int16_t *filter_x, int x_step_q4,
|
||||
const int16_t *filter_y, int y_step_q4,
|
||||
int w, int h, int bd) {
|
||||
const uint16_t *src = CONVERT_TO_SHORTPTR(src8);
|
||||
const int y0_q4 = get_filter_offset(filter_y, get_filter_base(filter_y));
|
||||
// + 1 to make it divisible by 4
|
||||
DECLARE_ALIGNED(16, uint16_t, temp[64 * 136]);
|
||||
const int intermediate_height =
|
||||
(((h - 1) * y_step_q4 + y0_q4) >> SUBPEL_BITS) + SUBPEL_TAPS;
|
||||
|
||||
/* This implementation has the same issues as above. In addition, we only want
|
||||
* to average the values after both passes.
|
||||
*/
|
||||
vpx_highbd_convolve8_horiz_neon(CONVERT_TO_BYTEPTR(src - src_stride * 3),
|
||||
src_stride, CONVERT_TO_BYTEPTR(temp), w,
|
||||
filter_x, x_step_q4, filter_y, y_step_q4, w,
|
||||
intermediate_height, bd);
|
||||
vpx_highbd_convolve8_avg_vert_neon(CONVERT_TO_BYTEPTR(temp + w * 3), w, dst,
|
||||
dst_stride, filter_x, x_step_q4, filter_y,
|
||||
y_step_q4, w, h, bd);
|
||||
}
|
||||
@ -39,6 +39,15 @@ static INLINE uint8x16x2_t vpx_vtrnq_u64(uint32x4_t a0, uint32x4_t a1) {
|
||||
return b0;
|
||||
}
|
||||
|
||||
static INLINE uint16x8x2_t vpx_vtrnq_u64_to_u16(uint32x4_t a0, uint32x4_t a1) {
|
||||
uint16x8x2_t b0;
|
||||
b0.val[0] = vcombine_u16(vreinterpret_u16_u32(vget_low_u32(a0)),
|
||||
vreinterpret_u16_u32(vget_low_u32(a1)));
|
||||
b0.val[1] = vcombine_u16(vreinterpret_u16_u32(vget_high_u32(a0)),
|
||||
vreinterpret_u16_u32(vget_high_u32(a1)));
|
||||
return b0;
|
||||
}
|
||||
|
||||
static INLINE void transpose_u8_4x4(uint8x8_t *a0, uint8x8_t *a1) {
|
||||
// Swap 16 bit elements. Goes from:
|
||||
// a0: 00 01 02 03 10 11 12 13
|
||||
@ -68,6 +77,70 @@ static INLINE void transpose_u8_4x4(uint8x8_t *a0, uint8x8_t *a1) {
|
||||
*a1 = d0.val[1];
|
||||
}
|
||||
|
||||
static INLINE void transpose_s16_4x4d(int16x4_t *a0, int16x4_t *a1,
|
||||
int16x4_t *a2, int16x4_t *a3) {
|
||||
// Swap 16 bit elements. Goes from:
|
||||
// a0: 00 01 02 03
|
||||
// a1: 10 11 12 13
|
||||
// a2: 20 21 22 23
|
||||
// a3: 30 31 32 33
|
||||
// to:
|
||||
// b0.val[0]: 00 10 02 12
|
||||
// b0.val[1]: 01 11 03 13
|
||||
// b1.val[0]: 20 30 22 32
|
||||
// b1.val[1]: 21 31 23 33
|
||||
|
||||
const int16x4x2_t b0 = vtrn_s16(*a0, *a1);
|
||||
const int16x4x2_t b1 = vtrn_s16(*a2, *a3);
|
||||
|
||||
// Swap 32 bit elements resulting in:
|
||||
// c0.val[0]: 00 10 20 30
|
||||
// c0.val[1]: 02 12 22 32
|
||||
// c1.val[0]: 01 11 21 31
|
||||
// c1.val[1]: 03 13 23 33
|
||||
|
||||
const int32x2x2_t c0 = vtrn_s32(vreinterpret_s32_s16(b0.val[0]),
|
||||
vreinterpret_s32_s16(b1.val[0]));
|
||||
const int32x2x2_t c1 = vtrn_s32(vreinterpret_s32_s16(b0.val[1]),
|
||||
vreinterpret_s32_s16(b1.val[1]));
|
||||
|
||||
*a0 = vreinterpret_s16_s32(c0.val[0]);
|
||||
*a1 = vreinterpret_s16_s32(c1.val[0]);
|
||||
*a2 = vreinterpret_s16_s32(c0.val[1]);
|
||||
*a3 = vreinterpret_s16_s32(c1.val[1]);
|
||||
}
|
||||
|
||||
static INLINE void transpose_u16_4x4q(uint16x8_t *a0, uint16x8_t *a1) {
|
||||
// Swap 32 bit elements. Goes from:
|
||||
// a0: 00 01 02 03 10 11 12 13
|
||||
// a1: 20 21 22 23 30 31 32 33
|
||||
// to:
|
||||
// b0.val[0]: 00 01 20 21 10 11 30 31
|
||||
// b0.val[1]: 02 03 22 23 12 13 32 33
|
||||
|
||||
const uint32x4x2_t b0 =
|
||||
vtrnq_u32(vreinterpretq_u32_u16(*a0), vreinterpretq_u32_u16(*a1));
|
||||
|
||||
// Swap 64 bit elements resulting in:
|
||||
// c0.val[0]: 00 01 20 21 02 03 22 23
|
||||
// c0.val[1]: 10 11 30 31 12 13 32 33
|
||||
|
||||
const uint32x4_t c0 =
|
||||
vcombine_u32(vget_low_u32(b0.val[0]), vget_low_u32(b0.val[1]));
|
||||
const uint32x4_t c1 =
|
||||
vcombine_u32(vget_high_u32(b0.val[0]), vget_high_u32(b0.val[1]));
|
||||
|
||||
// Swap 16 bit elements resulting in:
|
||||
// d0.val[0]: 00 10 20 30 02 12 22 32
|
||||
// d0.val[1]: 01 11 21 31 03 13 23 33
|
||||
|
||||
const uint16x8x2_t d0 =
|
||||
vtrnq_u16(vreinterpretq_u16_u32(c0), vreinterpretq_u16_u32(c1));
|
||||
|
||||
*a0 = d0.val[0];
|
||||
*a1 = d0.val[1];
|
||||
}
|
||||
|
||||
static INLINE void transpose_u8_8x4(uint8x8_t *a0, uint8x8_t *a1, uint8x8_t *a2,
|
||||
uint8x8_t *a3) {
|
||||
// Swap 8 bit elements. Goes from:
|
||||
@ -101,6 +174,39 @@ static INLINE void transpose_u8_8x4(uint8x8_t *a0, uint8x8_t *a1, uint8x8_t *a2,
|
||||
*a3 = vreinterpret_u8_u16(c1.val[1]);
|
||||
}
|
||||
|
||||
static INLINE void transpose_u16_8x4(uint16x8_t *a0, uint16x8_t *a1,
|
||||
uint16x8_t *a2, uint16x8_t *a3) {
|
||||
// Swap 16 bit elements. Goes from:
|
||||
// a0: 00 01 02 03 04 05 06 07
|
||||
// a1: 10 11 12 13 14 15 16 17
|
||||
// a2: 20 21 22 23 24 25 26 27
|
||||
// a3: 30 31 32 33 34 35 36 37
|
||||
// to:
|
||||
// b0.val[0]: 00 10 02 12 04 14 06 16
|
||||
// b0.val[1]: 01 11 03 13 05 15 07 17
|
||||
// b1.val[0]: 20 30 22 32 24 34 26 36
|
||||
// b1.val[1]: 21 31 23 33 25 35 27 37
|
||||
|
||||
const uint16x8x2_t b0 = vtrnq_u16(*a0, *a1);
|
||||
const uint16x8x2_t b1 = vtrnq_u16(*a2, *a3);
|
||||
|
||||
// Swap 32 bit elements resulting in:
|
||||
// c0.val[0]: 00 10 20 30 04 14 24 34
|
||||
// c0.val[1]: 02 12 22 32 06 16 26 36
|
||||
// c1.val[0]: 01 11 21 31 05 15 25 35
|
||||
// c1.val[1]: 03 13 23 33 07 17 27 37
|
||||
|
||||
const uint32x4x2_t c0 = vtrnq_u32(vreinterpretq_u32_u16(b0.val[0]),
|
||||
vreinterpretq_u32_u16(b1.val[0]));
|
||||
const uint32x4x2_t c1 = vtrnq_u32(vreinterpretq_u32_u16(b0.val[1]),
|
||||
vreinterpretq_u32_u16(b1.val[1]));
|
||||
|
||||
*a0 = vreinterpretq_u16_u32(c0.val[0]);
|
||||
*a1 = vreinterpretq_u16_u32(c1.val[0]);
|
||||
*a2 = vreinterpretq_u16_u32(c0.val[1]);
|
||||
*a3 = vreinterpretq_u16_u32(c1.val[1]);
|
||||
}
|
||||
|
||||
// Note: Using 'd' registers or 'q' registers has almost identical speed. We use
|
||||
// 'q' registers here to save some instructions.
|
||||
static INLINE void transpose_u8_8x8(uint8x8_t *a0, uint8x8_t *a1, uint8x8_t *a2,
|
||||
@ -228,6 +334,77 @@ static INLINE void transpose_s16_8x8(int16x8_t *a0, int16x8_t *a1,
|
||||
*a7 = d3.val[1];
|
||||
}
|
||||
|
||||
static INLINE void transpose_u16_8x8(uint16x8_t *a0, uint16x8_t *a1,
|
||||
uint16x8_t *a2, uint16x8_t *a3,
|
||||
uint16x8_t *a4, uint16x8_t *a5,
|
||||
uint16x8_t *a6, uint16x8_t *a7) {
|
||||
// Swap 16 bit elements. Goes from:
|
||||
// a0: 00 01 02 03 04 05 06 07
|
||||
// a1: 10 11 12 13 14 15 16 17
|
||||
// a2: 20 21 22 23 24 25 26 27
|
||||
// a3: 30 31 32 33 34 35 36 37
|
||||
// a4: 40 41 42 43 44 45 46 47
|
||||
// a5: 50 51 52 53 54 55 56 57
|
||||
// a6: 60 61 62 63 64 65 66 67
|
||||
// a7: 70 71 72 73 74 75 76 77
|
||||
// to:
|
||||
// b0.val[0]: 00 10 02 12 04 14 06 16
|
||||
// b0.val[1]: 01 11 03 13 05 15 07 17
|
||||
// b1.val[0]: 20 30 22 32 24 34 26 36
|
||||
// b1.val[1]: 21 31 23 33 25 35 27 37
|
||||
// b2.val[0]: 40 50 42 52 44 54 46 56
|
||||
// b2.val[1]: 41 51 43 53 45 55 47 57
|
||||
// b3.val[0]: 60 70 62 72 64 74 66 76
|
||||
// b3.val[1]: 61 71 63 73 65 75 67 77
|
||||
|
||||
const uint16x8x2_t b0 = vtrnq_u16(*a0, *a1);
|
||||
const uint16x8x2_t b1 = vtrnq_u16(*a2, *a3);
|
||||
const uint16x8x2_t b2 = vtrnq_u16(*a4, *a5);
|
||||
const uint16x8x2_t b3 = vtrnq_u16(*a6, *a7);
|
||||
|
||||
// Swap 32 bit elements resulting in:
|
||||
// c0.val[0]: 00 10 20 30 04 14 24 34
|
||||
// c0.val[1]: 02 12 22 32 06 16 26 36
|
||||
// c1.val[0]: 01 11 21 31 05 15 25 35
|
||||
// c1.val[1]: 03 13 23 33 07 17 27 37
|
||||
// c2.val[0]: 40 50 60 70 44 54 64 74
|
||||
// c2.val[1]: 42 52 62 72 46 56 66 76
|
||||
// c3.val[0]: 41 51 61 71 45 55 65 75
|
||||
// c3.val[1]: 43 53 63 73 47 57 67 77
|
||||
|
||||
const uint32x4x2_t c0 = vtrnq_u32(vreinterpretq_u32_u16(b0.val[0]),
|
||||
vreinterpretq_u32_u16(b1.val[0]));
|
||||
const uint32x4x2_t c1 = vtrnq_u32(vreinterpretq_u32_u16(b0.val[1]),
|
||||
vreinterpretq_u32_u16(b1.val[1]));
|
||||
const uint32x4x2_t c2 = vtrnq_u32(vreinterpretq_u32_u16(b2.val[0]),
|
||||
vreinterpretq_u32_u16(b3.val[0]));
|
||||
const uint32x4x2_t c3 = vtrnq_u32(vreinterpretq_u32_u16(b2.val[1]),
|
||||
vreinterpretq_u32_u16(b3.val[1]));
|
||||
|
||||
// Swap 64 bit elements resulting in:
|
||||
// d0.val[0]: 00 10 20 30 40 50 60 70
|
||||
// d0.val[1]: 04 14 24 34 44 54 64 74
|
||||
// d1.val[0]: 01 11 21 31 41 51 61 71
|
||||
// d1.val[1]: 05 15 25 35 45 55 65 75
|
||||
// d2.val[0]: 02 12 22 32 42 52 62 72
|
||||
// d2.val[1]: 06 16 26 36 46 56 66 76
|
||||
// d3.val[0]: 03 13 23 33 43 53 63 73
|
||||
// d3.val[1]: 07 17 27 37 47 57 67 77
|
||||
const uint16x8x2_t d0 = vpx_vtrnq_u64_to_u16(c0.val[0], c2.val[0]);
|
||||
const uint16x8x2_t d1 = vpx_vtrnq_u64_to_u16(c1.val[0], c3.val[0]);
|
||||
const uint16x8x2_t d2 = vpx_vtrnq_u64_to_u16(c0.val[1], c2.val[1]);
|
||||
const uint16x8x2_t d3 = vpx_vtrnq_u64_to_u16(c1.val[1], c3.val[1]);
|
||||
|
||||
*a0 = d0.val[0];
|
||||
*a1 = d1.val[0];
|
||||
*a2 = d2.val[0];
|
||||
*a3 = d3.val[0];
|
||||
*a4 = d0.val[1];
|
||||
*a5 = d1.val[1];
|
||||
*a6 = d2.val[1];
|
||||
*a7 = d3.val[1];
|
||||
}
|
||||
|
||||
static INLINE void transpose_u8_16x8(
|
||||
const uint8x16_t i0, const uint8x16_t i1, const uint8x16_t i2,
|
||||
const uint8x16_t i3, const uint8x16_t i4, const uint8x16_t i5,
|
||||
|
||||
@ -820,14 +820,14 @@ void vpx_convolve8_vert_neon(const uint8_t *src, ptrdiff_t src_stride,
|
||||
s10 = vreinterpretq_s16_u16(vmovl_u8(vld1_u8(s)));
|
||||
s += src_stride;
|
||||
|
||||
__builtin_prefetch(dst + 0 * dst_stride);
|
||||
__builtin_prefetch(dst + 1 * dst_stride);
|
||||
__builtin_prefetch(dst + 2 * dst_stride);
|
||||
__builtin_prefetch(dst + 3 * dst_stride);
|
||||
__builtin_prefetch(src + 0 * src_stride);
|
||||
__builtin_prefetch(src + 1 * src_stride);
|
||||
__builtin_prefetch(src + 2 * src_stride);
|
||||
__builtin_prefetch(src + 3 * src_stride);
|
||||
__builtin_prefetch(d + 0 * dst_stride);
|
||||
__builtin_prefetch(d + 1 * dst_stride);
|
||||
__builtin_prefetch(d + 2 * dst_stride);
|
||||
__builtin_prefetch(d + 3 * dst_stride);
|
||||
__builtin_prefetch(s + 0 * src_stride);
|
||||
__builtin_prefetch(s + 1 * src_stride);
|
||||
__builtin_prefetch(s + 2 * src_stride);
|
||||
__builtin_prefetch(s + 3 * src_stride);
|
||||
d0 = convolve8_8(s0, s1, s2, s3, s4, s5, s6, s7, filters, filter3,
|
||||
filter4);
|
||||
d1 = convolve8_8(s1, s2, s3, s4, s5, s6, s7, s8, filters, filter3,
|
||||
@ -1002,14 +1002,14 @@ void vpx_convolve8_avg_vert_neon(const uint8_t *src, ptrdiff_t src_stride,
|
||||
s10 = vreinterpretq_s16_u16(vmovl_u8(vld1_u8(s)));
|
||||
s += src_stride;
|
||||
|
||||
__builtin_prefetch(dst + 0 * dst_stride);
|
||||
__builtin_prefetch(dst + 1 * dst_stride);
|
||||
__builtin_prefetch(dst + 2 * dst_stride);
|
||||
__builtin_prefetch(dst + 3 * dst_stride);
|
||||
__builtin_prefetch(src + 0 * src_stride);
|
||||
__builtin_prefetch(src + 1 * src_stride);
|
||||
__builtin_prefetch(src + 2 * src_stride);
|
||||
__builtin_prefetch(src + 3 * src_stride);
|
||||
__builtin_prefetch(d + 0 * dst_stride);
|
||||
__builtin_prefetch(d + 1 * dst_stride);
|
||||
__builtin_prefetch(d + 2 * dst_stride);
|
||||
__builtin_prefetch(d + 3 * dst_stride);
|
||||
__builtin_prefetch(s + 0 * src_stride);
|
||||
__builtin_prefetch(s + 1 * src_stride);
|
||||
__builtin_prefetch(s + 2 * src_stride);
|
||||
__builtin_prefetch(s + 3 * src_stride);
|
||||
d0 = convolve8_8(s0, s1, s2, s3, s4, s5, s6, s7, filters, filter3,
|
||||
filter4);
|
||||
d1 = convolve8_8(s1, s2, s3, s4, s5, s6, s7, s8, filters, filter3,
|
||||
|
||||
@ -24,16 +24,15 @@ void vpx_convolve8_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst,
|
||||
DECLARE_ALIGNED(8, uint8_t, temp[64 * 72]);
|
||||
|
||||
// Account for the vertical phase needing 3 lines prior and 4 lines post
|
||||
int intermediate_height = h + 7;
|
||||
const int intermediate_height = h + 7;
|
||||
|
||||
assert(y_step_q4 == 16);
|
||||
assert(x_step_q4 == 16);
|
||||
|
||||
/* Filter starting 3 lines back. The neon implementation will ignore the
|
||||
* given height and filter a multiple of 4 lines. Since this goes in to
|
||||
* the temp buffer which has lots of extra room and is subsequently discarded
|
||||
* this is safe if somewhat less than ideal.
|
||||
*/
|
||||
/* Filter starting 3 lines back. The neon implementation will ignore the given
|
||||
* height and filter a multiple of 4 lines. Since this goes in to the temp
|
||||
* buffer which has lots of extra room and is subsequently discarded this is
|
||||
* safe if somewhat less than ideal. */
|
||||
vpx_convolve8_horiz_neon(src - src_stride * 3, src_stride, temp, w, filter_x,
|
||||
x_step_q4, filter_y, y_step_q4, w,
|
||||
intermediate_height);
|
||||
@ -49,7 +48,7 @@ void vpx_convolve8_avg_neon(const uint8_t *src, ptrdiff_t src_stride,
|
||||
const int16_t *filter_y, int y_step_q4, int w,
|
||||
int h) {
|
||||
DECLARE_ALIGNED(8, uint8_t, temp[64 * 72]);
|
||||
int intermediate_height = h + 7;
|
||||
const int intermediate_height = h + 7;
|
||||
|
||||
assert(y_step_q4 == 16);
|
||||
assert(x_step_q4 == 16);
|
||||
|
||||
@ -131,7 +131,7 @@ static void convolve(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst,
|
||||
// --Require an additional SUBPEL_TAPS rows for the 8-tap filter tails.
|
||||
// --((64 - 1) * 32 + 15) >> 4 + 8 = 135.
|
||||
uint8_t temp[64 * 135];
|
||||
int intermediate_height =
|
||||
const int intermediate_height =
|
||||
(((h - 1) * y_step_q4 + y0_q4) >> SUBPEL_BITS) + SUBPEL_TAPS;
|
||||
|
||||
assert(w <= 64);
|
||||
@ -145,16 +145,6 @@ static void convolve(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst,
|
||||
y_filters, y0_q4, y_step_q4, w, h);
|
||||
}
|
||||
|
||||
static const InterpKernel *get_filter_base(const int16_t *filter) {
|
||||
// NOTE: This assumes that the filter table is 256-byte aligned.
|
||||
// TODO(agrange) Modify to make independent of table alignment.
|
||||
return (const InterpKernel *)(((intptr_t)filter) & ~((intptr_t)0xFF));
|
||||
}
|
||||
|
||||
static int get_filter_offset(const int16_t *f, const InterpKernel *base) {
|
||||
return (int)((const InterpKernel *)(intptr_t)f - base);
|
||||
}
|
||||
|
||||
void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride,
|
||||
uint8_t *dst, ptrdiff_t dst_stride,
|
||||
const int16_t *filter_x, int x_step_q4,
|
||||
@ -451,7 +441,7 @@ static void highbd_convolve(const uint8_t *src, ptrdiff_t src_stride,
|
||||
// --Require an additional SUBPEL_TAPS rows for the 8-tap filter tails.
|
||||
// --((64 - 1) * 32 + 15) >> 4 + 8 = 135.
|
||||
uint16_t temp[64 * 135];
|
||||
int intermediate_height =
|
||||
const int intermediate_height =
|
||||
(((h - 1) * y_step_q4 + y0_q4) >> SUBPEL_BITS) + SUBPEL_TAPS;
|
||||
|
||||
assert(w <= 64);
|
||||
|
||||
@ -88,6 +88,8 @@ DSP_SRCS-$(HAVE_SSE2) += x86/vpx_high_subpixel_8t_sse2.asm
|
||||
DSP_SRCS-$(HAVE_SSE2) += x86/vpx_high_subpixel_bilinear_sse2.asm
|
||||
DSP_SRCS-$(HAVE_NEON) += arm/highbd_vpx_convolve_copy_neon.c
|
||||
DSP_SRCS-$(HAVE_NEON) += arm/highbd_vpx_convolve_avg_neon.c
|
||||
DSP_SRCS-$(HAVE_NEON) += arm/highbd_vpx_convolve8_neon.c
|
||||
DSP_SRCS-$(HAVE_NEON) += arm/highbd_vpx_convolve_neon.c
|
||||
endif
|
||||
|
||||
DSP_SRCS-$(HAVE_SSE2) += x86/vpx_convolve_copy_sse2.asm
|
||||
|
||||
@ -398,22 +398,22 @@ if (vpx_config("CONFIG_VP9_HIGHBITDEPTH") eq "yes") {
|
||||
specialize qw/vpx_highbd_convolve_avg sse2 neon/;
|
||||
|
||||
add_proto qw/void vpx_highbd_convolve8/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
|
||||
specialize qw/vpx_highbd_convolve8/, "$sse2_x86_64";
|
||||
specialize qw/vpx_highbd_convolve8 neon/, "$sse2_x86_64";
|
||||
|
||||
add_proto qw/void vpx_highbd_convolve8_horiz/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
|
||||
specialize qw/vpx_highbd_convolve8_horiz/, "$sse2_x86_64";
|
||||
specialize qw/vpx_highbd_convolve8_horiz neon/, "$sse2_x86_64";
|
||||
|
||||
add_proto qw/void vpx_highbd_convolve8_vert/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
|
||||
specialize qw/vpx_highbd_convolve8_vert/, "$sse2_x86_64";
|
||||
specialize qw/vpx_highbd_convolve8_vert neon/, "$sse2_x86_64";
|
||||
|
||||
add_proto qw/void vpx_highbd_convolve8_avg/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
|
||||
specialize qw/vpx_highbd_convolve8_avg/, "$sse2_x86_64";
|
||||
specialize qw/vpx_highbd_convolve8_avg neon/, "$sse2_x86_64";
|
||||
|
||||
add_proto qw/void vpx_highbd_convolve8_avg_horiz/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
|
||||
specialize qw/vpx_highbd_convolve8_avg_horiz/, "$sse2_x86_64";
|
||||
specialize qw/vpx_highbd_convolve8_avg_horiz neon/, "$sse2_x86_64";
|
||||
|
||||
add_proto qw/void vpx_highbd_convolve8_avg_vert/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
|
||||
specialize qw/vpx_highbd_convolve8_avg_vert/, "$sse2_x86_64";
|
||||
specialize qw/vpx_highbd_convolve8_avg_vert neon/, "$sse2_x86_64";
|
||||
} # CONFIG_VP9_HIGHBITDEPTH
|
||||
|
||||
#
|
||||
|
||||
@ -26,6 +26,17 @@ extern "C" {
|
||||
|
||||
typedef int16_t InterpKernel[SUBPEL_TAPS];
|
||||
|
||||
static INLINE const InterpKernel *get_filter_base(const int16_t *filter) {
|
||||
// NOTE: This assumes that the filter table is 256-byte aligned.
|
||||
// TODO(agrange) Modify to make independent of table alignment.
|
||||
return (const InterpKernel *)(((intptr_t)filter) & ~((intptr_t)0xFF));
|
||||
}
|
||||
|
||||
static INLINE int get_filter_offset(const int16_t *f,
|
||||
const InterpKernel *base) {
|
||||
return (int)((const InterpKernel *)(intptr_t)f - base);
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
@ -860,16 +860,6 @@ static void scaledconvolve2d(const uint8_t *src, ptrdiff_t src_stride,
|
||||
}
|
||||
}
|
||||
|
||||
static const InterpKernel *get_filter_base(const int16_t *filter) {
|
||||
// NOTE: This assumes that the filter table is 256-byte aligned.
|
||||
// TODO(agrange) Modify to make independent of table alignment.
|
||||
return (const InterpKernel *)(((intptr_t)filter) & ~((intptr_t)0xFF));
|
||||
}
|
||||
|
||||
static int get_filter_offset(const int16_t *f, const InterpKernel *base) {
|
||||
return (int)((const InterpKernel *)(intptr_t)f - base);
|
||||
}
|
||||
|
||||
void vpx_scaled_2d_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst,
|
||||
ptrdiff_t dst_stride, const int16_t *filter_x,
|
||||
int x_step_q4, const int16_t *filter_y, int y_step_q4,
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user