| /* |
| * |
| * 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 "av1/common/resize.h" |
| #include "config/av1_rtcd.h" |
| #include "config/aom_scale_rtcd.h" |
| |
| static INLINE void scale_plane_2_to_1_phase_0(const uint8_t *src, |
| const int src_stride, |
| uint8_t *dst, |
| const int dst_stride, const int w, |
| const int h) { |
| const int max_width = (w + 15) & ~15; |
| int y = h; |
| |
| assert(w && h); |
| |
| do { |
| int x = max_width; |
| do { |
| const uint8x16x2_t s = vld2q_u8(src); |
| vst1q_u8(dst, s.val[0]); |
| src += 32; |
| dst += 16; |
| x -= 16; |
| } while (x); |
| src += 2 * (src_stride - max_width); |
| dst += dst_stride - max_width; |
| } while (--y); |
| } |
| |
| static INLINE void scale_plane_bilinear_kernel( |
| const uint8x16_t in0, const uint8x16_t in1, const uint8x16_t in2, |
| const uint8x16_t in3, const uint8x8_t coef0, const uint8x8_t coef1, |
| uint8_t *const dst) { |
| const uint16x8_t h0 = vmull_u8(vget_low_u8(in0), coef0); |
| const uint16x8_t h1 = vmull_u8(vget_high_u8(in0), coef0); |
| const uint16x8_t h2 = vmull_u8(vget_low_u8(in2), coef0); |
| const uint16x8_t h3 = vmull_u8(vget_high_u8(in2), coef0); |
| const uint16x8_t h4 = vmlal_u8(h0, vget_low_u8(in1), coef1); |
| const uint16x8_t h5 = vmlal_u8(h1, vget_high_u8(in1), coef1); |
| const uint16x8_t h6 = vmlal_u8(h2, vget_low_u8(in3), coef1); |
| const uint16x8_t h7 = vmlal_u8(h3, vget_high_u8(in3), coef1); |
| |
| const uint8x8_t hor0 = vrshrn_n_u16(h4, 7); // temp: 00 01 02 03 04 05 06 07 |
| const uint8x8_t hor1 = vrshrn_n_u16(h5, 7); // temp: 08 09 0A 0B 0C 0D 0E 0F |
| const uint8x8_t hor2 = vrshrn_n_u16(h6, 7); // temp: 10 11 12 13 14 15 16 17 |
| const uint8x8_t hor3 = vrshrn_n_u16(h7, 7); // temp: 18 19 1A 1B 1C 1D 1E 1F |
| const uint16x8_t v0 = vmull_u8(hor0, coef0); |
| const uint16x8_t v1 = vmull_u8(hor1, coef0); |
| const uint16x8_t v2 = vmlal_u8(v0, hor2, coef1); |
| const uint16x8_t v3 = vmlal_u8(v1, hor3, coef1); |
| // dst: 0 1 2 3 4 5 6 7 8 9 A B C D E F |
| const uint8x16_t d = vcombine_u8(vrshrn_n_u16(v2, 7), vrshrn_n_u16(v3, 7)); |
| vst1q_u8(dst, d); |
| } |
| |
| static INLINE void scale_plane_2_to_1_bilinear( |
| const uint8_t *const src, const int src_stride, uint8_t *dst, |
| const int dst_stride, const int w, const int h, const int16_t c0, |
| const int16_t c1) { |
| const int max_width = (w + 15) & ~15; |
| const uint8_t *src0 = src; |
| const uint8_t *src1 = src + src_stride; |
| const uint8x8_t coef0 = vdup_n_u8(c0); |
| const uint8x8_t coef1 = vdup_n_u8(c1); |
| int y = h; |
| |
| assert(w && h); |
| |
| do { |
| int x = max_width; |
| do { |
| // 000 002 004 006 008 00A 00C 00E 010 012 014 016 018 01A 01C 01E |
| // 001 003 005 007 009 00B 00D 00F 011 013 015 017 019 01B 01D 01F |
| const uint8x16x2_t s0 = vld2q_u8(src0); |
| // 100 102 104 106 108 10A 10C 10E 110 112 114 116 118 11A 11C 11E |
| // 101 103 105 107 109 10B 10D 10F 111 113 115 117 119 11B 11D 11F |
| const uint8x16x2_t s1 = vld2q_u8(src1); |
| scale_plane_bilinear_kernel(s0.val[0], s0.val[1], s1.val[0], s1.val[1], |
| coef0, coef1, dst); |
| src0 += 32; |
| src1 += 32; |
| dst += 16; |
| x -= 16; |
| } while (x); |
| src0 += 2 * (src_stride - max_width); |
| src1 += 2 * (src_stride - max_width); |
| dst += dst_stride - max_width; |
| } while (--y); |
| } |
| |
| void av1_resize_and_extend_frame_neon(const YV12_BUFFER_CONFIG *src, |
| YV12_BUFFER_CONFIG *dst, |
| const InterpFilter filter, |
| const int phase, const int num_planes) { |
| // We use AOMMIN(num_planes, MAX_MB_PLANE) instead of num_planes to quiet |
| // the static analysis warnings. |
| for (int i = 0; i < AOMMIN(num_planes, MAX_MB_PLANE); ++i) { |
| const int is_uv = i > 0; |
| const int src_w = src->crop_widths[is_uv]; |
| const int src_h = src->crop_heights[is_uv]; |
| const int dst_w = dst->crop_widths[is_uv]; |
| const int dst_h = dst->crop_heights[is_uv]; |
| |
| if (2 * dst_w == src_w && 2 * dst_h == src_h) { |
| if (phase == 0) { |
| scale_plane_2_to_1_phase_0(src->buffers[i], src->strides[is_uv], |
| dst->buffers[i], dst->strides[is_uv], dst_w, |
| dst_h); |
| } else if (filter == BILINEAR) { |
| const int16_t c0 = av1_bilinear_filters[phase][3]; |
| const int16_t c1 = av1_bilinear_filters[phase][4]; |
| scale_plane_2_to_1_bilinear(src->buffers[i], src->strides[is_uv], |
| dst->buffers[i], dst->strides[is_uv], dst_w, |
| dst_h, c0, c1); |
| } else { |
| av1_resize_plane(src->buffers[i], src_h, src_w, src->strides[is_uv], |
| dst->buffers[i], dst_h, dst_w, dst->strides[is_uv]); |
| } |
| } else { |
| av1_resize_plane(src->buffers[i], src_h, src_w, src->strides[is_uv], |
| dst->buffers[i], dst_h, dst_w, dst->strides[is_uv]); |
| } |
| } |
| aom_extend_frame_borders(dst, num_planes); |
| } |