arm: Add NEON optimizations for 10 and 12 bit vp9 MC
This work is sponsored by, and copyright, Google.
The plain pixel put/copy functions are used from the 8 bit version,
for the double size (e.g. put16 uses ff_vp9_copy32_neon), and a new
copy128 is added.
Compared with the 8 bit version, the filters can no longer use the
trick to accumulate in 16 bit with only saturation at the end, but now
the accumulators need to be 32 bit. This avoids the need to keep track
of which filter index is the largest though, reducing the size of the
executable code for these filters.
For the horizontal filters, we only do 4 or 8 pixels wide in parallel
(while doing two rows at a time), since we don't have enough register
space to filter 16 pixels wide.
For the vertical filters, we still do 4 and 8 pixels in parallel just
as in the 8 bit case, but we need to store the output after every 2
rows instead of after every 4 rows.
Examples of relative speedup compared to the C version, from checkasm:
Cortex A7 A8 A9 A53
vp9_avg4_10bpp_neon: 2.25 2.44 3.05 2.16
vp9_avg8_10bpp_neon: 3.66 8.48 3.86 3.50
vp9_avg16_10bpp_neon: 3.39 8.26 3.37 2.72
vp9_avg32_10bpp_neon: 4.03 10.20 4.07 3.42
vp9_avg64_10bpp_neon: 4.15 10.01 4.13 3.70
vp9_avg_8tap_smooth_4h_10bpp_neon: 3.38 6.22 3.41 4.75
vp9_avg_8tap_smooth_4hv_10bpp_neon: 3.89 6.39 4.30 5.32
vp9_avg_8tap_smooth_4v_10bpp_neon: 5.32 9.73 6.34 7.31
vp9_avg_8tap_smooth_8h_10bpp_neon: 4.45 9.40 4.68 6.87
vp9_avg_8tap_smooth_8hv_10bpp_neon: 4.64 8.91 5.44 6.47
vp9_avg_8tap_smooth_8v_10bpp_neon: 6.44 13.42 8.68 8.79
vp9_avg_8tap_smooth_64h_10bpp_neon: 4.66 9.02 4.84 7.71
vp9_avg_8tap_smooth_64hv_10bpp_neon: 4.61 9.14 4.92 7.10
vp9_avg_8tap_smooth_64v_10bpp_neon: 6.90 14.13 9.57 10.41
vp9_put4_10bpp_neon: 1.33 1.46 2.09 1.33
vp9_put8_10bpp_neon: 1.57 3.42 1.83 1.84
vp9_put16_10bpp_neon: 1.55 4.78 2.17 1.89
vp9_put32_10bpp_neon: 2.06 5.35 2.14 2.30
vp9_put64_10bpp_neon: 3.00 2.41 1.95 1.66
vp9_put_8tap_smooth_4h_10bpp_neon: 3.19 5.81 3.31 4.63
vp9_put_8tap_smooth_4hv_10bpp_neon: 3.86 6.22 4.32 5.21
vp9_put_8tap_smooth_4v_10bpp_neon: 5.40 9.77 6.08 7.21
vp9_put_8tap_smooth_8h_10bpp_neon: 4.22 8.41 4.46 6.63
vp9_put_8tap_smooth_8hv_10bpp_neon: 4.56 8.51 5.39 6.25
vp9_put_8tap_smooth_8v_10bpp_neon: 6.60 12.43 8.17 8.89
vp9_put_8tap_smooth_64h_10bpp_neon: 4.41 8.59 4.54 7.49
vp9_put_8tap_smooth_64hv_10bpp_neon: 4.43 8.58 5.34 6.63
vp9_put_8tap_smooth_64v_10bpp_neon: 7.26 13.92 9.27 10.92
For the larger 8tap filters, the speedup vs C code is around 4-14x.
Signed-off-by: Martin Storsjö <martin@martin.st>
2016-12-08 21:35:31 +00:00
|
|
|
/*
|
|
|
|
|
* Copyright (c) 2017 Google Inc.
|
|
|
|
|
*
|
|
|
|
|
* This file is part of FFmpeg.
|
|
|
|
|
*
|
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
|
|
|
|
|
|
#include "libavutil/attributes.h"
|
|
|
|
|
#include "libavutil/arm/cpu.h"
|
|
|
|
|
#include "vp9dsp_init.h"
|
|
|
|
|
|
|
|
|
|
#define declare_fpel(type, sz, suffix) \
|
|
|
|
|
void ff_vp9_##type##sz##suffix##_neon(uint8_t *dst, ptrdiff_t dst_stride, \
|
|
|
|
|
const uint8_t *src, ptrdiff_t src_stride, \
|
|
|
|
|
int h, int mx, int my)
|
|
|
|
|
|
|
|
|
|
#define decl_mc_func(op, filter, dir, sz, bpp) \
|
|
|
|
|
void ff_vp9_##op##_##filter##sz##_##dir##_##bpp##_neon(uint8_t *dst, ptrdiff_t dst_stride, \
|
|
|
|
|
const uint8_t *src, ptrdiff_t src_stride, \
|
|
|
|
|
int h, int mx, int my)
|
|
|
|
|
|
|
|
|
|
#define define_8tap_2d_fn(op, filter, sz, bpp) \
|
|
|
|
|
static void op##_##filter##sz##_hv_##bpp##_neon(uint8_t *dst, ptrdiff_t dst_stride, \
|
|
|
|
|
const uint8_t *src, \
|
|
|
|
|
ptrdiff_t src_stride, \
|
|
|
|
|
int h, int mx, int my) \
|
|
|
|
|
{ \
|
|
|
|
|
LOCAL_ALIGNED_16(uint8_t, temp, [((1 + (sz < 64)) * sz + 8) * sz * 2]); \
|
|
|
|
|
/* We only need h + 7 lines, but the horizontal filter assumes an \
|
|
|
|
|
* even number of rows, so filter h + 8 lines here. */ \
|
|
|
|
|
ff_vp9_put_##filter##sz##_h_##bpp##_neon(temp, 2 * sz, \
|
|
|
|
|
src - 3 * src_stride, src_stride, \
|
|
|
|
|
h + 8, mx, 0); \
|
|
|
|
|
ff_vp9_##op##_##filter##sz##_v_##bpp##_neon(dst, dst_stride, \
|
|
|
|
|
temp + 3 * 2 * sz, 2 * sz, \
|
|
|
|
|
h, 0, my); \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define decl_filter_funcs(op, dir, sz, bpp) \
|
|
|
|
|
decl_mc_func(op, regular, dir, sz, bpp); \
|
|
|
|
|
decl_mc_func(op, sharp, dir, sz, bpp); \
|
|
|
|
|
decl_mc_func(op, smooth, dir, sz, bpp)
|
|
|
|
|
|
|
|
|
|
#define decl_mc_funcs(sz, bpp) \
|
|
|
|
|
decl_filter_funcs(put, h, sz, bpp); \
|
|
|
|
|
decl_filter_funcs(avg, h, sz, bpp); \
|
|
|
|
|
decl_filter_funcs(put, v, sz, bpp); \
|
|
|
|
|
decl_filter_funcs(avg, v, sz, bpp); \
|
|
|
|
|
decl_filter_funcs(put, hv, sz, bpp); \
|
|
|
|
|
decl_filter_funcs(avg, hv, sz, bpp)
|
|
|
|
|
|
|
|
|
|
declare_fpel(copy, 128, );
|
|
|
|
|
declare_fpel(copy, 64, );
|
|
|
|
|
declare_fpel(copy, 32, );
|
|
|
|
|
declare_fpel(copy, 16, );
|
|
|
|
|
declare_fpel(copy, 8, );
|
|
|
|
|
declare_fpel(avg, 64, _16);
|
|
|
|
|
declare_fpel(avg, 32, _16);
|
|
|
|
|
declare_fpel(avg, 16, _16);
|
|
|
|
|
declare_fpel(avg, 8, _16);
|
|
|
|
|
declare_fpel(avg, 4, _16);
|
|
|
|
|
|
|
|
|
|
decl_mc_funcs(64, BPP);
|
|
|
|
|
decl_mc_funcs(32, BPP);
|
|
|
|
|
decl_mc_funcs(16, BPP);
|
|
|
|
|
decl_mc_funcs(8, BPP);
|
|
|
|
|
decl_mc_funcs(4, BPP);
|
|
|
|
|
|
|
|
|
|
#define define_8tap_2d_funcs(sz, bpp) \
|
|
|
|
|
define_8tap_2d_fn(put, regular, sz, bpp) \
|
|
|
|
|
define_8tap_2d_fn(put, sharp, sz, bpp) \
|
|
|
|
|
define_8tap_2d_fn(put, smooth, sz, bpp) \
|
|
|
|
|
define_8tap_2d_fn(avg, regular, sz, bpp) \
|
|
|
|
|
define_8tap_2d_fn(avg, sharp, sz, bpp) \
|
|
|
|
|
define_8tap_2d_fn(avg, smooth, sz, bpp)
|
|
|
|
|
|
|
|
|
|
define_8tap_2d_funcs(64, BPP)
|
|
|
|
|
define_8tap_2d_funcs(32, BPP)
|
|
|
|
|
define_8tap_2d_funcs(16, BPP)
|
|
|
|
|
define_8tap_2d_funcs(8, BPP)
|
|
|
|
|
define_8tap_2d_funcs(4, BPP)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static av_cold void vp9dsp_mc_init_arm(VP9DSPContext *dsp)
|
|
|
|
|
{
|
|
|
|
|
int cpu_flags = av_get_cpu_flags();
|
|
|
|
|
|
|
|
|
|
if (have_neon(cpu_flags)) {
|
|
|
|
|
#define init_fpel(idx1, idx2, sz, type, suffix) \
|
|
|
|
|
dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][0][0] = \
|
|
|
|
|
dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] = \
|
|
|
|
|
dsp->mc[idx1][FILTER_8TAP_SHARP ][idx2][0][0] = \
|
|
|
|
|
dsp->mc[idx1][FILTER_BILINEAR ][idx2][0][0] = ff_vp9_##type##sz##suffix##_neon
|
|
|
|
|
|
|
|
|
|
#define init_copy_avg(idx, sz1, sz2) \
|
|
|
|
|
init_fpel(idx, 0, sz2, copy, ); \
|
|
|
|
|
init_fpel(idx, 1, sz1, avg, _16)
|
|
|
|
|
|
|
|
|
|
#define init_mc_func(idx1, idx2, op, filter, fname, dir, mx, my, sz, pfx, bpp) \
|
|
|
|
|
dsp->mc[idx1][filter][idx2][mx][my] = pfx##op##_##fname##sz##_##dir##_##bpp##_neon
|
|
|
|
|
|
|
|
|
|
#define init_mc_funcs(idx, dir, mx, my, sz, pfx, bpp) \
|
|
|
|
|
init_mc_func(idx, 0, put, FILTER_8TAP_REGULAR, regular, dir, mx, my, sz, pfx, bpp); \
|
|
|
|
|
init_mc_func(idx, 0, put, FILTER_8TAP_SHARP, sharp, dir, mx, my, sz, pfx, bpp); \
|
|
|
|
|
init_mc_func(idx, 0, put, FILTER_8TAP_SMOOTH, smooth, dir, mx, my, sz, pfx, bpp); \
|
|
|
|
|
init_mc_func(idx, 1, avg, FILTER_8TAP_REGULAR, regular, dir, mx, my, sz, pfx, bpp); \
|
|
|
|
|
init_mc_func(idx, 1, avg, FILTER_8TAP_SHARP, sharp, dir, mx, my, sz, pfx, bpp); \
|
|
|
|
|
init_mc_func(idx, 1, avg, FILTER_8TAP_SMOOTH, smooth, dir, mx, my, sz, pfx, bpp)
|
|
|
|
|
|
|
|
|
|
#define init_mc_funcs_dirs(idx, sz, bpp) \
|
|
|
|
|
init_mc_funcs(idx, h, 1, 0, sz, ff_vp9_, bpp); \
|
|
|
|
|
init_mc_funcs(idx, v, 0, 1, sz, ff_vp9_, bpp); \
|
|
|
|
|
init_mc_funcs(idx, hv, 1, 1, sz, , bpp)
|
|
|
|
|
|
|
|
|
|
init_copy_avg(0, 64, 128);
|
|
|
|
|
init_copy_avg(1, 32, 64);
|
|
|
|
|
init_copy_avg(2, 16, 32);
|
|
|
|
|
init_copy_avg(3, 8, 16);
|
|
|
|
|
init_copy_avg(4, 4, 8);
|
|
|
|
|
|
|
|
|
|
init_mc_funcs_dirs(0, 64, BPP);
|
|
|
|
|
init_mc_funcs_dirs(1, 32, BPP);
|
|
|
|
|
init_mc_funcs_dirs(2, 16, BPP);
|
|
|
|
|
init_mc_funcs_dirs(3, 8, BPP);
|
|
|
|
|
init_mc_funcs_dirs(4, 4, BPP);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
arm: Add NEON optimizations for 10 and 12 bit vp9 itxfm
This work is sponsored by, and copyright, Google.
This is structured similarly to the 8 bit version. In the 8 bit
version, the coefficients are 16 bits, and intermediates are 32 bits.
Here, the coefficients are 32 bit. For the 4x4 transforms for 10 bit
content, the intermediates also fit in 32 bits, but for all other
transforms (4x4 for 12 bit content, and 8x8 and larger for both 10
and 12 bit) the intermediates are 64 bit.
For the existing 8 bit case, the 8x8 transform fit all coefficients in
registers; for 10/12 bit, when the coefficients are 32 bit, the 8x8
transform also has to be done in slices of 4 pixels (just as 16x16 and
32x32 for 8 bit).
The slice width also shrinks from 4 elements to 2 elements in parallel
for the 16x16 and 32x32 cases.
The 16 bit coefficients from idct_coeffs and similar tables also need
to be lenghtened to 32 bit in order to be used in multiplication with
vectors with 32 bit elements. This leads to the fixed coefficient
vectors needing more space, leading to more cases where they have to
be reloaded within the transform (in iadst16).
This technically would need testing in checkasm for subpartitions
in increments of 2, but that slows down normal checkasm runs
excessively.
Examples of relative speedup compared to the C version, from checkasm:
Cortex A7 A8 A9 A53
vp9_inv_adst_adst_4x4_sub4_add_10_neon: 4.83 11.36 5.22 6.77
vp9_inv_adst_adst_8x8_sub8_add_10_neon: 4.12 7.60 4.06 4.84
vp9_inv_adst_adst_16x16_sub16_add_10_neon: 3.93 8.16 4.52 5.35
vp9_inv_dct_dct_4x4_sub1_add_10_neon: 1.36 2.57 1.41 1.61
vp9_inv_dct_dct_4x4_sub4_add_10_neon: 4.24 8.66 5.06 5.81
vp9_inv_dct_dct_8x8_sub1_add_10_neon: 2.63 4.18 1.68 2.87
vp9_inv_dct_dct_8x8_sub4_add_10_neon: 4.52 9.47 4.24 5.39
vp9_inv_dct_dct_8x8_sub8_add_10_neon: 3.45 7.34 3.45 4.30
vp9_inv_dct_dct_16x16_sub1_add_10_neon: 3.56 6.21 2.47 4.32
vp9_inv_dct_dct_16x16_sub2_add_10_neon: 5.68 12.73 5.28 7.07
vp9_inv_dct_dct_16x16_sub8_add_10_neon: 4.42 9.28 4.24 5.45
vp9_inv_dct_dct_16x16_sub16_add_10_neon: 3.41 7.29 3.35 4.19
vp9_inv_dct_dct_32x32_sub1_add_10_neon: 4.52 8.35 3.83 6.40
vp9_inv_dct_dct_32x32_sub2_add_10_neon: 5.86 13.19 6.14 7.04
vp9_inv_dct_dct_32x32_sub16_add_10_neon: 4.29 8.11 4.59 5.06
vp9_inv_dct_dct_32x32_sub32_add_10_neon: 3.31 5.70 3.56 3.84
vp9_inv_wht_wht_4x4_sub4_add_10_neon: 1.89 2.80 1.82 1.97
The speedup compared to the C functions is around 1.3 to 7x for the
full transforms, even higher for the smaller subpartitions.
Signed-off-by: Martin Storsjö <martin@martin.st>
2016-12-17 22:22:15 +00:00
|
|
|
#define define_itxfm2(type_a, type_b, sz, bpp) \
|
|
|
|
|
void ff_vp9_##type_a##_##type_b##_##sz##x##sz##_add_##bpp##_neon(uint8_t *_dst, \
|
|
|
|
|
ptrdiff_t stride, \
|
|
|
|
|
int16_t *_block, int eob)
|
|
|
|
|
#define define_itxfm(type_a, type_b, sz, bpp) define_itxfm2(type_a, type_b, sz, bpp)
|
|
|
|
|
|
|
|
|
|
#define define_itxfm_funcs(sz, bpp) \
|
|
|
|
|
define_itxfm(idct, idct, sz, bpp); \
|
|
|
|
|
define_itxfm(iadst, idct, sz, bpp); \
|
|
|
|
|
define_itxfm(idct, iadst, sz, bpp); \
|
|
|
|
|
define_itxfm(iadst, iadst, sz, bpp)
|
|
|
|
|
|
|
|
|
|
define_itxfm_funcs(4, BPP);
|
|
|
|
|
define_itxfm_funcs(8, BPP);
|
|
|
|
|
define_itxfm_funcs(16, BPP);
|
|
|
|
|
define_itxfm(idct, idct, 32, BPP);
|
|
|
|
|
define_itxfm(iwht, iwht, 4, BPP);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static av_cold void vp9dsp_itxfm_init_arm(VP9DSPContext *dsp)
|
|
|
|
|
{
|
|
|
|
|
int cpu_flags = av_get_cpu_flags();
|
|
|
|
|
|
|
|
|
|
if (have_neon(cpu_flags)) {
|
|
|
|
|
#define init_itxfm2(tx, sz, bpp) \
|
|
|
|
|
dsp->itxfm_add[tx][DCT_DCT] = ff_vp9_idct_idct_##sz##_add_##bpp##_neon; \
|
|
|
|
|
dsp->itxfm_add[tx][DCT_ADST] = ff_vp9_iadst_idct_##sz##_add_##bpp##_neon; \
|
|
|
|
|
dsp->itxfm_add[tx][ADST_DCT] = ff_vp9_idct_iadst_##sz##_add_##bpp##_neon; \
|
|
|
|
|
dsp->itxfm_add[tx][ADST_ADST] = ff_vp9_iadst_iadst_##sz##_add_##bpp##_neon
|
|
|
|
|
#define init_itxfm(tx, sz, bpp) init_itxfm2(tx, sz, bpp)
|
|
|
|
|
|
|
|
|
|
#define init_idct2(tx, nm, bpp) \
|
|
|
|
|
dsp->itxfm_add[tx][DCT_DCT] = \
|
|
|
|
|
dsp->itxfm_add[tx][ADST_DCT] = \
|
|
|
|
|
dsp->itxfm_add[tx][DCT_ADST] = \
|
|
|
|
|
dsp->itxfm_add[tx][ADST_ADST] = ff_vp9_##nm##_add_##bpp##_neon
|
|
|
|
|
#define init_idct(tx, nm, bpp) init_idct2(tx, nm, bpp)
|
|
|
|
|
|
|
|
|
|
init_itxfm(TX_4X4, 4x4, BPP);
|
|
|
|
|
init_itxfm(TX_8X8, 8x8, BPP);
|
|
|
|
|
init_itxfm(TX_16X16, 16x16, BPP);
|
|
|
|
|
init_idct(TX_32X32, idct_idct_32x32, BPP);
|
|
|
|
|
init_idct(4, iwht_iwht_4x4, BPP);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
arm: Add NEON optimizations for 10 and 12 bit vp9 loop filter
This work is sponsored by, and copyright, Google.
This is pretty much similar to the 8 bpp version, but in some senses
simpler. All input pixels are 16 bits, and all intermediates also fit
in 16 bits, so there's no lengthening/narrowing in the filter at all.
For the full 16 pixel wide filter, we can only process 4 pixels at a time
(using an implementation very much similar to the one for 8 bpp),
but we can do 8 pixels at a time for the 4 and 8 pixel wide filters with
a different implementation of the core filter.
Examples of relative speedup compared to the C version, from checkasm:
Cortex A7 A8 A9 A53
vp9_loop_filter_h_4_8_10bpp_neon: 1.83 2.16 1.40 2.09
vp9_loop_filter_h_8_8_10bpp_neon: 1.39 1.67 1.24 1.70
vp9_loop_filter_h_16_8_10bpp_neon: 1.56 1.47 1.10 1.81
vp9_loop_filter_h_16_16_10bpp_neon: 1.94 1.69 1.33 2.24
vp9_loop_filter_mix2_h_44_16_10bpp_neon: 2.01 2.27 1.67 2.39
vp9_loop_filter_mix2_h_48_16_10bpp_neon: 1.84 2.06 1.45 2.19
vp9_loop_filter_mix2_h_84_16_10bpp_neon: 1.89 2.20 1.47 2.29
vp9_loop_filter_mix2_h_88_16_10bpp_neon: 1.69 2.12 1.47 2.08
vp9_loop_filter_mix2_v_44_16_10bpp_neon: 3.16 3.98 2.50 4.05
vp9_loop_filter_mix2_v_48_16_10bpp_neon: 2.84 3.64 2.25 3.77
vp9_loop_filter_mix2_v_84_16_10bpp_neon: 2.65 3.45 2.16 3.54
vp9_loop_filter_mix2_v_88_16_10bpp_neon: 2.55 3.30 2.16 3.55
vp9_loop_filter_v_4_8_10bpp_neon: 2.85 3.97 2.24 3.68
vp9_loop_filter_v_8_8_10bpp_neon: 2.27 3.19 1.96 3.08
vp9_loop_filter_v_16_8_10bpp_neon: 3.42 2.74 2.26 4.40
vp9_loop_filter_v_16_16_10bpp_neon: 2.86 2.44 1.93 3.88
The speedup vs C code measured in checkasm is around 1.1-4x.
These numbers are quite inconclusive though, since the checkasm test
runs multiple filterings on top of each other, so later rounds might
end up with different codepaths (different decisions on which filter
to apply, based on input pixel differences).
Based on START_TIMER/STOP_TIMER wrapping around a few individual
functions, the speedup vs C code is around 2-4x.
Signed-off-by: Martin Storsjö <martin@martin.st>
2017-01-05 10:51:08 +00:00
|
|
|
#define define_loop_filter(dir, wd, size, bpp) \
|
|
|
|
|
void ff_vp9_loop_filter_##dir##_##wd##_##size##_##bpp##_neon(uint8_t *dst, ptrdiff_t stride, int E, int I, int H)
|
|
|
|
|
|
|
|
|
|
#define define_loop_filters(wd, size, bpp) \
|
|
|
|
|
define_loop_filter(h, wd, size, bpp); \
|
|
|
|
|
define_loop_filter(v, wd, size, bpp)
|
|
|
|
|
|
|
|
|
|
define_loop_filters(4, 8, BPP);
|
|
|
|
|
define_loop_filters(8, 8, BPP);
|
|
|
|
|
define_loop_filters(16, 8, BPP);
|
|
|
|
|
|
|
|
|
|
define_loop_filters(16, 16, BPP);
|
|
|
|
|
|
|
|
|
|
define_loop_filters(44, 16, BPP);
|
|
|
|
|
define_loop_filters(48, 16, BPP);
|
|
|
|
|
define_loop_filters(84, 16, BPP);
|
|
|
|
|
define_loop_filters(88, 16, BPP);
|
|
|
|
|
|
|
|
|
|
static av_cold void vp9dsp_loopfilter_init_arm(VP9DSPContext *dsp)
|
|
|
|
|
{
|
|
|
|
|
int cpu_flags = av_get_cpu_flags();
|
|
|
|
|
|
|
|
|
|
if (have_neon(cpu_flags)) {
|
|
|
|
|
#define init_lpf_func_8(idx1, idx2, dir, wd, bpp) \
|
|
|
|
|
dsp->loop_filter_8[idx1][idx2] = ff_vp9_loop_filter_##dir##_##wd##_8_##bpp##_neon
|
|
|
|
|
|
|
|
|
|
#define init_lpf_func_16(idx, dir, bpp) \
|
|
|
|
|
dsp->loop_filter_16[idx] = ff_vp9_loop_filter_##dir##_16_16_##bpp##_neon
|
|
|
|
|
|
|
|
|
|
#define init_lpf_func_mix2(idx1, idx2, idx3, dir, wd, bpp) \
|
|
|
|
|
dsp->loop_filter_mix2[idx1][idx2][idx3] = ff_vp9_loop_filter_##dir##_##wd##_16_##bpp##_neon
|
|
|
|
|
|
|
|
|
|
#define init_lpf_funcs_8_wd(idx, wd, bpp) \
|
|
|
|
|
init_lpf_func_8(idx, 0, h, wd, bpp); \
|
|
|
|
|
init_lpf_func_8(idx, 1, v, wd, bpp)
|
|
|
|
|
|
|
|
|
|
#define init_lpf_funcs_16(bpp) \
|
|
|
|
|
init_lpf_func_16(0, h, bpp); \
|
|
|
|
|
init_lpf_func_16(1, v, bpp)
|
|
|
|
|
|
|
|
|
|
#define init_lpf_funcs_mix2_wd(idx1, idx2, wd, bpp) \
|
|
|
|
|
init_lpf_func_mix2(idx1, idx2, 0, h, wd, bpp); \
|
|
|
|
|
init_lpf_func_mix2(idx1, idx2, 1, v, wd, bpp)
|
|
|
|
|
|
|
|
|
|
#define init_lpf_funcs_8(bpp) \
|
|
|
|
|
init_lpf_funcs_8_wd(0, 4, bpp); \
|
|
|
|
|
init_lpf_funcs_8_wd(1, 8, bpp); \
|
|
|
|
|
init_lpf_funcs_8_wd(2, 16, bpp)
|
|
|
|
|
|
|
|
|
|
#define init_lpf_funcs_mix2(bpp) \
|
|
|
|
|
init_lpf_funcs_mix2_wd(0, 0, 44, bpp); \
|
|
|
|
|
init_lpf_funcs_mix2_wd(0, 1, 48, bpp); \
|
|
|
|
|
init_lpf_funcs_mix2_wd(1, 0, 84, bpp); \
|
|
|
|
|
init_lpf_funcs_mix2_wd(1, 1, 88, bpp)
|
|
|
|
|
|
|
|
|
|
init_lpf_funcs_8(BPP);
|
|
|
|
|
init_lpf_funcs_16(BPP);
|
|
|
|
|
init_lpf_funcs_mix2(BPP);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
arm: Add NEON optimizations for 10 and 12 bit vp9 MC
This work is sponsored by, and copyright, Google.
The plain pixel put/copy functions are used from the 8 bit version,
for the double size (e.g. put16 uses ff_vp9_copy32_neon), and a new
copy128 is added.
Compared with the 8 bit version, the filters can no longer use the
trick to accumulate in 16 bit with only saturation at the end, but now
the accumulators need to be 32 bit. This avoids the need to keep track
of which filter index is the largest though, reducing the size of the
executable code for these filters.
For the horizontal filters, we only do 4 or 8 pixels wide in parallel
(while doing two rows at a time), since we don't have enough register
space to filter 16 pixels wide.
For the vertical filters, we still do 4 and 8 pixels in parallel just
as in the 8 bit case, but we need to store the output after every 2
rows instead of after every 4 rows.
Examples of relative speedup compared to the C version, from checkasm:
Cortex A7 A8 A9 A53
vp9_avg4_10bpp_neon: 2.25 2.44 3.05 2.16
vp9_avg8_10bpp_neon: 3.66 8.48 3.86 3.50
vp9_avg16_10bpp_neon: 3.39 8.26 3.37 2.72
vp9_avg32_10bpp_neon: 4.03 10.20 4.07 3.42
vp9_avg64_10bpp_neon: 4.15 10.01 4.13 3.70
vp9_avg_8tap_smooth_4h_10bpp_neon: 3.38 6.22 3.41 4.75
vp9_avg_8tap_smooth_4hv_10bpp_neon: 3.89 6.39 4.30 5.32
vp9_avg_8tap_smooth_4v_10bpp_neon: 5.32 9.73 6.34 7.31
vp9_avg_8tap_smooth_8h_10bpp_neon: 4.45 9.40 4.68 6.87
vp9_avg_8tap_smooth_8hv_10bpp_neon: 4.64 8.91 5.44 6.47
vp9_avg_8tap_smooth_8v_10bpp_neon: 6.44 13.42 8.68 8.79
vp9_avg_8tap_smooth_64h_10bpp_neon: 4.66 9.02 4.84 7.71
vp9_avg_8tap_smooth_64hv_10bpp_neon: 4.61 9.14 4.92 7.10
vp9_avg_8tap_smooth_64v_10bpp_neon: 6.90 14.13 9.57 10.41
vp9_put4_10bpp_neon: 1.33 1.46 2.09 1.33
vp9_put8_10bpp_neon: 1.57 3.42 1.83 1.84
vp9_put16_10bpp_neon: 1.55 4.78 2.17 1.89
vp9_put32_10bpp_neon: 2.06 5.35 2.14 2.30
vp9_put64_10bpp_neon: 3.00 2.41 1.95 1.66
vp9_put_8tap_smooth_4h_10bpp_neon: 3.19 5.81 3.31 4.63
vp9_put_8tap_smooth_4hv_10bpp_neon: 3.86 6.22 4.32 5.21
vp9_put_8tap_smooth_4v_10bpp_neon: 5.40 9.77 6.08 7.21
vp9_put_8tap_smooth_8h_10bpp_neon: 4.22 8.41 4.46 6.63
vp9_put_8tap_smooth_8hv_10bpp_neon: 4.56 8.51 5.39 6.25
vp9_put_8tap_smooth_8v_10bpp_neon: 6.60 12.43 8.17 8.89
vp9_put_8tap_smooth_64h_10bpp_neon: 4.41 8.59 4.54 7.49
vp9_put_8tap_smooth_64hv_10bpp_neon: 4.43 8.58 5.34 6.63
vp9_put_8tap_smooth_64v_10bpp_neon: 7.26 13.92 9.27 10.92
For the larger 8tap filters, the speedup vs C code is around 4-14x.
Signed-off-by: Martin Storsjö <martin@martin.st>
2016-12-08 21:35:31 +00:00
|
|
|
av_cold void INIT_FUNC(VP9DSPContext *dsp)
|
|
|
|
|
{
|
|
|
|
|
vp9dsp_mc_init_arm(dsp);
|
arm: Add NEON optimizations for 10 and 12 bit vp9 loop filter
This work is sponsored by, and copyright, Google.
This is pretty much similar to the 8 bpp version, but in some senses
simpler. All input pixels are 16 bits, and all intermediates also fit
in 16 bits, so there's no lengthening/narrowing in the filter at all.
For the full 16 pixel wide filter, we can only process 4 pixels at a time
(using an implementation very much similar to the one for 8 bpp),
but we can do 8 pixels at a time for the 4 and 8 pixel wide filters with
a different implementation of the core filter.
Examples of relative speedup compared to the C version, from checkasm:
Cortex A7 A8 A9 A53
vp9_loop_filter_h_4_8_10bpp_neon: 1.83 2.16 1.40 2.09
vp9_loop_filter_h_8_8_10bpp_neon: 1.39 1.67 1.24 1.70
vp9_loop_filter_h_16_8_10bpp_neon: 1.56 1.47 1.10 1.81
vp9_loop_filter_h_16_16_10bpp_neon: 1.94 1.69 1.33 2.24
vp9_loop_filter_mix2_h_44_16_10bpp_neon: 2.01 2.27 1.67 2.39
vp9_loop_filter_mix2_h_48_16_10bpp_neon: 1.84 2.06 1.45 2.19
vp9_loop_filter_mix2_h_84_16_10bpp_neon: 1.89 2.20 1.47 2.29
vp9_loop_filter_mix2_h_88_16_10bpp_neon: 1.69 2.12 1.47 2.08
vp9_loop_filter_mix2_v_44_16_10bpp_neon: 3.16 3.98 2.50 4.05
vp9_loop_filter_mix2_v_48_16_10bpp_neon: 2.84 3.64 2.25 3.77
vp9_loop_filter_mix2_v_84_16_10bpp_neon: 2.65 3.45 2.16 3.54
vp9_loop_filter_mix2_v_88_16_10bpp_neon: 2.55 3.30 2.16 3.55
vp9_loop_filter_v_4_8_10bpp_neon: 2.85 3.97 2.24 3.68
vp9_loop_filter_v_8_8_10bpp_neon: 2.27 3.19 1.96 3.08
vp9_loop_filter_v_16_8_10bpp_neon: 3.42 2.74 2.26 4.40
vp9_loop_filter_v_16_16_10bpp_neon: 2.86 2.44 1.93 3.88
The speedup vs C code measured in checkasm is around 1.1-4x.
These numbers are quite inconclusive though, since the checkasm test
runs multiple filterings on top of each other, so later rounds might
end up with different codepaths (different decisions on which filter
to apply, based on input pixel differences).
Based on START_TIMER/STOP_TIMER wrapping around a few individual
functions, the speedup vs C code is around 2-4x.
Signed-off-by: Martin Storsjö <martin@martin.st>
2017-01-05 10:51:08 +00:00
|
|
|
vp9dsp_loopfilter_init_arm(dsp);
|
arm: Add NEON optimizations for 10 and 12 bit vp9 itxfm
This work is sponsored by, and copyright, Google.
This is structured similarly to the 8 bit version. In the 8 bit
version, the coefficients are 16 bits, and intermediates are 32 bits.
Here, the coefficients are 32 bit. For the 4x4 transforms for 10 bit
content, the intermediates also fit in 32 bits, but for all other
transforms (4x4 for 12 bit content, and 8x8 and larger for both 10
and 12 bit) the intermediates are 64 bit.
For the existing 8 bit case, the 8x8 transform fit all coefficients in
registers; for 10/12 bit, when the coefficients are 32 bit, the 8x8
transform also has to be done in slices of 4 pixels (just as 16x16 and
32x32 for 8 bit).
The slice width also shrinks from 4 elements to 2 elements in parallel
for the 16x16 and 32x32 cases.
The 16 bit coefficients from idct_coeffs and similar tables also need
to be lenghtened to 32 bit in order to be used in multiplication with
vectors with 32 bit elements. This leads to the fixed coefficient
vectors needing more space, leading to more cases where they have to
be reloaded within the transform (in iadst16).
This technically would need testing in checkasm for subpartitions
in increments of 2, but that slows down normal checkasm runs
excessively.
Examples of relative speedup compared to the C version, from checkasm:
Cortex A7 A8 A9 A53
vp9_inv_adst_adst_4x4_sub4_add_10_neon: 4.83 11.36 5.22 6.77
vp9_inv_adst_adst_8x8_sub8_add_10_neon: 4.12 7.60 4.06 4.84
vp9_inv_adst_adst_16x16_sub16_add_10_neon: 3.93 8.16 4.52 5.35
vp9_inv_dct_dct_4x4_sub1_add_10_neon: 1.36 2.57 1.41 1.61
vp9_inv_dct_dct_4x4_sub4_add_10_neon: 4.24 8.66 5.06 5.81
vp9_inv_dct_dct_8x8_sub1_add_10_neon: 2.63 4.18 1.68 2.87
vp9_inv_dct_dct_8x8_sub4_add_10_neon: 4.52 9.47 4.24 5.39
vp9_inv_dct_dct_8x8_sub8_add_10_neon: 3.45 7.34 3.45 4.30
vp9_inv_dct_dct_16x16_sub1_add_10_neon: 3.56 6.21 2.47 4.32
vp9_inv_dct_dct_16x16_sub2_add_10_neon: 5.68 12.73 5.28 7.07
vp9_inv_dct_dct_16x16_sub8_add_10_neon: 4.42 9.28 4.24 5.45
vp9_inv_dct_dct_16x16_sub16_add_10_neon: 3.41 7.29 3.35 4.19
vp9_inv_dct_dct_32x32_sub1_add_10_neon: 4.52 8.35 3.83 6.40
vp9_inv_dct_dct_32x32_sub2_add_10_neon: 5.86 13.19 6.14 7.04
vp9_inv_dct_dct_32x32_sub16_add_10_neon: 4.29 8.11 4.59 5.06
vp9_inv_dct_dct_32x32_sub32_add_10_neon: 3.31 5.70 3.56 3.84
vp9_inv_wht_wht_4x4_sub4_add_10_neon: 1.89 2.80 1.82 1.97
The speedup compared to the C functions is around 1.3 to 7x for the
full transforms, even higher for the smaller subpartitions.
Signed-off-by: Martin Storsjö <martin@martin.st>
2016-12-17 22:22:15 +00:00
|
|
|
vp9dsp_itxfm_init_arm(dsp);
|
arm: Add NEON optimizations for 10 and 12 bit vp9 MC
This work is sponsored by, and copyright, Google.
The plain pixel put/copy functions are used from the 8 bit version,
for the double size (e.g. put16 uses ff_vp9_copy32_neon), and a new
copy128 is added.
Compared with the 8 bit version, the filters can no longer use the
trick to accumulate in 16 bit with only saturation at the end, but now
the accumulators need to be 32 bit. This avoids the need to keep track
of which filter index is the largest though, reducing the size of the
executable code for these filters.
For the horizontal filters, we only do 4 or 8 pixels wide in parallel
(while doing two rows at a time), since we don't have enough register
space to filter 16 pixels wide.
For the vertical filters, we still do 4 and 8 pixels in parallel just
as in the 8 bit case, but we need to store the output after every 2
rows instead of after every 4 rows.
Examples of relative speedup compared to the C version, from checkasm:
Cortex A7 A8 A9 A53
vp9_avg4_10bpp_neon: 2.25 2.44 3.05 2.16
vp9_avg8_10bpp_neon: 3.66 8.48 3.86 3.50
vp9_avg16_10bpp_neon: 3.39 8.26 3.37 2.72
vp9_avg32_10bpp_neon: 4.03 10.20 4.07 3.42
vp9_avg64_10bpp_neon: 4.15 10.01 4.13 3.70
vp9_avg_8tap_smooth_4h_10bpp_neon: 3.38 6.22 3.41 4.75
vp9_avg_8tap_smooth_4hv_10bpp_neon: 3.89 6.39 4.30 5.32
vp9_avg_8tap_smooth_4v_10bpp_neon: 5.32 9.73 6.34 7.31
vp9_avg_8tap_smooth_8h_10bpp_neon: 4.45 9.40 4.68 6.87
vp9_avg_8tap_smooth_8hv_10bpp_neon: 4.64 8.91 5.44 6.47
vp9_avg_8tap_smooth_8v_10bpp_neon: 6.44 13.42 8.68 8.79
vp9_avg_8tap_smooth_64h_10bpp_neon: 4.66 9.02 4.84 7.71
vp9_avg_8tap_smooth_64hv_10bpp_neon: 4.61 9.14 4.92 7.10
vp9_avg_8tap_smooth_64v_10bpp_neon: 6.90 14.13 9.57 10.41
vp9_put4_10bpp_neon: 1.33 1.46 2.09 1.33
vp9_put8_10bpp_neon: 1.57 3.42 1.83 1.84
vp9_put16_10bpp_neon: 1.55 4.78 2.17 1.89
vp9_put32_10bpp_neon: 2.06 5.35 2.14 2.30
vp9_put64_10bpp_neon: 3.00 2.41 1.95 1.66
vp9_put_8tap_smooth_4h_10bpp_neon: 3.19 5.81 3.31 4.63
vp9_put_8tap_smooth_4hv_10bpp_neon: 3.86 6.22 4.32 5.21
vp9_put_8tap_smooth_4v_10bpp_neon: 5.40 9.77 6.08 7.21
vp9_put_8tap_smooth_8h_10bpp_neon: 4.22 8.41 4.46 6.63
vp9_put_8tap_smooth_8hv_10bpp_neon: 4.56 8.51 5.39 6.25
vp9_put_8tap_smooth_8v_10bpp_neon: 6.60 12.43 8.17 8.89
vp9_put_8tap_smooth_64h_10bpp_neon: 4.41 8.59 4.54 7.49
vp9_put_8tap_smooth_64hv_10bpp_neon: 4.43 8.58 5.34 6.63
vp9_put_8tap_smooth_64v_10bpp_neon: 7.26 13.92 9.27 10.92
For the larger 8tap filters, the speedup vs C code is around 4-14x.
Signed-off-by: Martin Storsjö <martin@martin.st>
2016-12-08 21:35:31 +00:00
|
|
|
}
|