/*
* Copyright (c) 2020, 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 <arm_neon.h>
#include <assert.h>
#include "config/aom_config.h"
#include "config/av1_rtcd.h"
#include "aom/aom_integer.h"
#include "aom_dsp/arm/mem_neon.h"
#include "aom_dsp/arm/sum_neon.h"
#define MAX_UPSAMPLE_SZ 16
// TODO(aomedia:349436249): enable for armv7 after SIGBUS is fixed.
#if AOM_ARCH_AARCH64
// These kernels are a transposed version of those defined in reconintra.c,
// with the absolute value of the negatives taken in the top row.
DECLARE_ALIGNED(16,
const uint8_t,
av1_filter_intra_taps_neon[FILTER_INTRA_MODES][7][8]) = {
// clang-format off
{
{ 6, 5, 3, 3, 4, 3, 3, 3 },
{ 10, 2, 1, 1, 6, 2, 2, 1 },
{ 0, 10, 1, 1, 0, 6, 2, 2 },
{ 0, 0, 10, 2, 0, 0, 6, 2 },
{ 0, 0, 0, 10, 0, 0, 0, 6 },
{ 12, 9, 7, 5, 2, 2, 2, 3 },
{ 0, 0, 0, 0, 12, 9, 7, 5 }
},
{
{ 10, 6, 4, 2, 10, 6, 4, 2 },
{ 16, 0, 0, 0, 16, 0, 0, 0 },
{ 0, 16, 0, 0, 0, 16, 0, 0 },
{ 0, 0, 16, 0, 0, 0, 16, 0 },
{ 0, 0, 0, 16, 0, 0, 0, 16 },
{ 10, 6, 4, 2, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 10, 6, 4, 2 }
},
{
{ 8, 8, 8, 8, 4, 4, 4, 4 },
{ 8, 0, 0, 0, 4, 0, 0, 0 },
{ 0, 8, 0, 0, 0, 4, 0, 0 },
{ 0, 0, 8, 0, 0, 0, 4, 0 },
{ 0, 0, 0, 8, 0, 0, 0, 4 },
{ 16, 16, 16, 16, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 16, 16, 16, 16 }
},
{
{ 2, 1, 1, 0, 1, 1, 1, 1 },
{ 8, 3, 2, 1, 4, 3, 2, 2 },
{ 0, 8, 3, 2, 0, 4, 3, 2 },
{ 0, 0, 8, 3, 0, 0, 4, 3 },
{ 0, 0, 0, 8, 0, 0, 0, 4 },
{ 10, 6, 4, 2, 3, 4, 4, 3 },
{ 0, 0, 0, 0, 10, 6, 4, 3 }
},
{
{ 12, 10, 9, 8, 10, 9, 8, 7 },
{ 14, 0, 0, 0, 12, 1, 0, 0 },
{ 0, 14, 0, 0, 0, 12, 0, 0 },
{ 0, 0, 14, 0, 0, 0, 12, 1 },
{ 0, 0, 0, 14, 0, 0, 0, 12 },
{ 14, 12, 11, 10, 0, 0, 1, 1 },
{ 0, 0, 0, 0, 14, 12, 11, 9 }
}
// clang-format on
};
#define FILTER_INTRA_SCALE_BITS 4
void av1_filter_intra_predictor_neon(uint8_t *dst, ptrdiff_t stride,
TX_SIZE tx_size,
const uint8_t *above,
const uint8_t *left,
int mode) {
const int width = tx_size_wide[tx_size];
const int height = tx_size_high[tx_size];
assert(width <= 32 && height <= 32);
const uint8x8_t f0 = vld1_u8(av1_filter_intra_taps_neon[mode][0]);
const uint8x8_t f1 = vld1_u8(av1_filter_intra_taps_neon[mode][1]);
const uint8x8_t f2 = vld1_u8(av1_filter_intra_taps_neon[mode][2]);
const uint8x8_t f3 = vld1_u8(av1_filter_intra_taps_neon[mode][3]);
const uint8x8_t f4 = vld1_u8(av1_filter_intra_taps_neon[mode][4]);
const uint8x8_t f5 = vld1_u8(av1_filter_intra_taps_neon[mode][5]);
const uint8x8_t f6 = vld1_u8(av1_filter_intra_taps_neon[mode][6]);
uint8_t buffer[33][33];
// Populate the top row in the scratch buffer with data from above.
memcpy(buffer[0], &above[-1], (width + 1) *
sizeof(uint8_t));
// Populate the first column in the scratch buffer with data from the left.
int r = 0;
do {
buffer[r + 1][0] = left[r];
}
while (++r < height);
// Computing 4 cols per iteration (instead of 8) for 8x<h> blocks is faster.
if (width <= 8) {
r = 1;
do {
int c = 1;
uint8x8_t s0 = vld1_dup_u8(&buffer[r - 1][c - 1]);
uint8x8_t s5 = vld1_dup_u8(&buffer[r + 0][c - 1]);
uint8x8_t s6 = vld1_dup_u8(&buffer[r + 1][c - 1]);
do {
uint8x8_t s1234 = load_u8_4x1(&buffer[r - 1][c - 1] + 1);
uint8x8_t s1 = vdup_lane_u8(s1234, 0);
uint8x8_t s2 = vdup_lane_u8(s1234, 1);
uint8x8_t s3 = vdup_lane_u8(s1234, 2);
uint8x8_t s4 = vdup_lane_u8(s1234, 3);
uint16x8_t sum = vmull_u8(s1, f1);
// First row of each filter has all negative values so subtract.
sum = vmlsl_u8(sum, s0, f0);
sum = vmlal_u8(sum, s2, f2);
sum = vmlal_u8(sum, s3, f3);
sum = vmlal_u8(sum, s4, f4);
sum = vmlal_u8(sum, s5, f5);
sum = vmlal_u8(sum, s6, f6);
uint8x8_t res =
vqrshrun_n_s16(vreinterpretq_s16_u16(sum), FILTER_INTRA_SCALE_BITS);
// Store buffer[r + 0][c] and buffer[r + 1][c].
store_u8x4_strided_x2(&buffer[r][c], 33, res);
store_u8x4_strided_x2(dst + (r - 1) * stride + c - 1, stride, res);
s0 = s4;
s5 = vdup_lane_u8(res, 3);
s6 = vdup_lane_u8(res, 7);
c += 4;
}
while (c < width + 1);
r += 2;
}
while (r < height + 1);
}
else {
r = 1;
do {
int c = 1;
uint8x8_t s0_lo = vld1_dup_u8(&buffer[r - 1][c - 1]);
uint8x8_t s5_lo = vld1_dup_u8(&buffer[r + 0][c - 1]);
uint8x8_t s6_lo = vld1_dup_u8(&buffer[r + 1][c - 1]);
do {
uint8x8_t s1234 = vld1_u8(&buffer[r - 1][c - 1] + 1);
uint8x8_t s1_lo = vdup_lane_u8(s1234, 0);
uint8x8_t s2_lo = vdup_lane_u8(s1234, 1);
uint8x8_t s3_lo = vdup_lane_u8(s1234, 2);
uint8x8_t s4_lo = vdup_lane_u8(s1234, 3);
uint16x8_t sum_lo = vmull_u8(s1_lo, f1);
// First row of each filter has all negative values so subtract.
sum_lo = vmlsl_u8(sum_lo, s0_lo, f0);
sum_lo = vmlal_u8(sum_lo, s2_lo, f2);
sum_lo = vmlal_u8(sum_lo, s3_lo, f3);
sum_lo = vmlal_u8(sum_lo, s4_lo, f4);
sum_lo = vmlal_u8(sum_lo, s5_lo, f5);
sum_lo = vmlal_u8(sum_lo, s6_lo, f6);
uint8x8_t res_lo = vqrshrun_n_s16(vreinterpretq_s16_u16(sum_lo),
FILTER_INTRA_SCALE_BITS);
uint8x8_t s0_hi = s4_lo;
uint8x8_t s1_hi = vdup_lane_u8(s1234, 4);
uint8x8_t s2_hi = vdup_lane_u8(s1234, 5);
uint8x8_t s3_hi = vdup_lane_u8(s1234, 6);
uint8x8_t s4_hi = vdup_lane_u8(s1234, 7);
uint8x8_t s5_hi = vdup_lane_u8(res_lo, 3);
uint8x8_t s6_hi = vdup_lane_u8(res_lo, 7);
uint16x8_t sum_hi = vmull_u8(s1_hi, f1);
// First row of each filter has all negative values so subtract.
sum_hi = vmlsl_u8(sum_hi, s0_hi, f0);
sum_hi = vmlal_u8(sum_hi, s2_hi, f2);
sum_hi = vmlal_u8(sum_hi, s3_hi, f3);
sum_hi = vmlal_u8(sum_hi, s4_hi, f4);
sum_hi = vmlal_u8(sum_hi, s5_hi, f5);
sum_hi = vmlal_u8(sum_hi, s6_hi, f6);
uint8x8_t res_hi = vqrshrun_n_s16(vreinterpretq_s16_u16(sum_hi),
FILTER_INTRA_SCALE_BITS);
uint32x2x2_t res =
vzip_u32(vreinterpret_u32_u8(res_lo), vreinterpret_u32_u8(res_hi));
vst1_u8(&buffer[r + 0][c], vreinterpret_u8_u32(res.val[0]));
vst1_u8(&buffer[r + 1][c], vreinterpret_u8_u32(res.val[1]));
vst1_u8(dst + (r - 1) * stride + c - 1,
vreinterpret_u8_u32(res.val[0]));
vst1_u8(dst + (r + 0) * stride + c - 1,
vreinterpret_u8_u32(res.val[1]));
s0_lo = s4_hi;
s5_lo = vdup_lane_u8(res_hi, 3);
s6_lo = vdup_lane_u8(res_hi, 7);
c += 8;
}
while (c < width + 1);
r += 2;
}
while (r < height + 1);
}
}
#endif // AOM_ARCH_AARCH64
void av1_filter_intra_edge_neon(uint8_t *p,
int sz,
int strength) {
if (!strength)
return;
assert(sz >= 0 && sz <= 129);
uint8_t edge[160];
// Max value of sz + enough padding for vector accesses.
memcpy(edge + 1, p, sz *
sizeof(*p));
// Populate extra space appropriately.
edge[0] = edge[1];
edge[sz + 1] = edge[sz];
edge[sz + 2] = edge[sz];
// Don't overwrite first pixel.
uint8_t *dst = p + 1;
sz--;
if (strength == 1) {
// Filter: {4, 8, 4}.
const uint8_t *src = edge + 1;
while (sz >= 8) {
uint8x8_t s0 = vld1_u8(src);
uint8x8_t s1 = vld1_u8(src + 1);
uint8x8_t s2 = vld1_u8(src + 2);
// Make use of the identity:
// (4*a + 8*b + 4*c) >> 4 == (a + (b << 1) + c) >> 2
uint16x8_t t0 = vaddl_u8(s0, s2);
uint16x8_t t1 = vaddl_u8(s1, s1);
uint16x8_t sum = vaddq_u16(t0, t1);
uint8x8_t res = vrshrn_n_u16(sum, 2);
vst1_u8(dst, res);
src += 8;
dst += 8;
sz -= 8;
}
if (sz > 0) {
// Handle sz < 8 to avoid modifying out-of-bounds values.
uint8x8_t s0 = vld1_u8(src);
uint8x8_t s1 = vld1_u8(src + 1);
uint8x8_t s2 = vld1_u8(src + 2);
uint16x8_t t0 = vaddl_u8(s0, s2);
uint16x8_t t1 = vaddl_u8(s1, s1);
uint16x8_t sum = vaddq_u16(t0, t1);
uint8x8_t res = vrshrn_n_u16(sum, 2);
// Mask off out-of-bounds indices.
uint8x8_t current_dst = vld1_u8(dst);
uint8x8_t mask = vcgt_u8(vdup_n_u8(sz), vcreate_u8(0x0706050403020100));
res = vbsl_u8(mask, res, current_dst);
vst1_u8(dst, res);
}
}
else if (strength == 2) {
// Filter: {5, 6, 5}.
const uint8_t *src = edge + 1;
const uint8x8x3_t filter = { { vdup_n_u8(5), vdup_n_u8(6), vdup_n_u8(5) } };
while (sz >= 8) {
uint8x8_t s0 = vld1_u8(src);
uint8x8_t s1 = vld1_u8(src + 1);
uint8x8_t s2 = vld1_u8(src + 2);
uint16x8_t accum = vmull_u8(s0, filter.val[0]);
accum = vmlal_u8(accum, s1, filter.val[1]);
accum = vmlal_u8(accum, s2, filter.val[2]);
uint8x8_t res = vrshrn_n_u16(accum, 4);
vst1_u8(dst, res);
src += 8;
dst += 8;
sz -= 8;
}
if (sz > 0) {
// Handle sz < 8 to avoid modifying out-of-bounds values.
uint8x8_t s0 = vld1_u8(src);
uint8x8_t s1 = vld1_u8(src + 1);
uint8x8_t s2 = vld1_u8(src + 2);
uint16x8_t accum = vmull_u8(s0, filter.val[0]);
accum = vmlal_u8(accum, s1, filter.val[1]);
accum = vmlal_u8(accum, s2, filter.val[2]);
uint8x8_t res = vrshrn_n_u16(accum, 4);
// Mask off out-of-bounds indices.
uint8x8_t current_dst = vld1_u8(dst);
uint8x8_t mask = vcgt_u8(vdup_n_u8(sz), vcreate_u8(0x0706050403020100));
res = vbsl_u8(mask, res, current_dst);
vst1_u8(dst, res);
}
}
else {
// Filter {2, 4, 4, 4, 2}.
const uint8_t *src = edge;
while (sz >= 8) {
uint8x8_t s0 = vld1_u8(src);
uint8x8_t s1 = vld1_u8(src + 1);
uint8x8_t s2 = vld1_u8(src + 2);
uint8x8_t s3 = vld1_u8(src + 3);
uint8x8_t s4 = vld1_u8(src + 4);
// Make use of the identity:
// (2*a + 4*b + 4*c + 4*d + 2*e) >> 4 == (a + ((b + c + d) << 1) + e) >> 3
uint16x8_t t0 = vaddl_u8(s0, s4);
uint16x8_t t1 = vaddl_u8(s1, s2);
t1 = vaddw_u8(t1, s3);
t1 = vaddq_u16(t1, t1);
uint16x8_t sum = vaddq_u16(t0, t1);
uint8x8_t res = vrshrn_n_u16(sum, 3);
vst1_u8(dst, res);
src += 8;
dst += 8;
sz -= 8;
}
if (sz > 0) {
// Handle sz < 8 to avoid modifying out-of-bounds values.
uint8x8_t s0 = vld1_u8(src);
uint8x8_t s1 = vld1_u8(src + 1);
uint8x8_t s2 = vld1_u8(src + 2);
uint8x8_t s3 = vld1_u8(src + 3);
uint8x8_t s4 = vld1_u8(src + 4);
uint16x8_t t0 = vaddl_u8(s0, s4);
uint16x8_t t1 = vaddl_u8(s1, s2);
t1 = vaddw_u8(t1, s3);
t1 = vaddq_u16(t1, t1);
uint16x8_t sum = vaddq_u16(t0, t1);
uint8x8_t res = vrshrn_n_u16(sum, 3);
// Mask off out-of-bounds indices.
uint8x8_t current_dst = vld1_u8(dst);
uint8x8_t mask = vcgt_u8(vdup_n_u8(sz), vcreate_u8(0x0706050403020100));
res = vbsl_u8(mask, res, current_dst);
vst1_u8(dst, res);
}
}
}
void av1_upsample_intra_edge_neon(uint8_t *p,
int sz) {
if (!sz)
return;
assert(sz <= MAX_UPSAMPLE_SZ);
uint8_t edge[MAX_UPSAMPLE_SZ + 3];
const uint8_t *src = edge;
// Copy p[-1..(sz-1)] and pad out both ends.
edge[0] = p[-1];
edge[1] = p[-1];
memcpy(edge + 2, p, sz);
edge[sz + 2] = p[sz - 1];
p[-2] = p[-1];
uint8_t *dst = p - 1;
do {
uint8x8_t s0 = vld1_u8(src);
uint8x8_t s1 = vld1_u8(src + 1);
uint8x8_t s2 = vld1_u8(src + 2);
uint8x8_t s3 = vld1_u8(src + 3);
int16x8_t t0 = vreinterpretq_s16_u16(vaddl_u8(s0, s3));
int16x8_t t1 = vreinterpretq_s16_u16(vaddl_u8(s1, s2));
t1 = vmulq_n_s16(t1, 9);
t1 = vsubq_s16(t1, t0);
uint8x8x2_t res = { { vqrshrun_n_s16(t1, 4), s2 } };
vst2_u8(dst, res);
src += 8;
dst += 16;
sz -= 8;
}
while (sz > 0);
}
