• Martin Storsjö's avatar
    arm: Add NEON optimizations for 10 and 12 bit vp9 loop filter · 1e5d87ee
    Martin Storsjö authored
    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: 's avatarMartin Storsjö <martin@martin.st>
    1e5d87ee
Makefile 8.1 KB