2013-10-01 03:03:30 +00:00
|
|
|
/*
|
|
|
|
* VP9 compatible video decoder
|
|
|
|
*
|
|
|
|
* Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
|
|
|
|
* Copyright (C) 2013 Clément Bœsch <u pkh me>
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef AVCODEC_VP9DSP_H
|
|
|
|
#define AVCODEC_VP9DSP_H
|
|
|
|
|
2013-10-09 07:42:16 +00:00
|
|
|
#include <stddef.h>
|
2013-10-01 03:03:30 +00:00
|
|
|
#include <stdint.h>
|
|
|
|
|
|
|
|
#include "vp9.h"
|
|
|
|
|
|
|
|
typedef void (*vp9_mc_func)(uint8_t *dst, ptrdiff_t dst_stride,
|
|
|
|
const uint8_t *ref, ptrdiff_t ref_stride,
|
|
|
|
int h, int mx, int my);
|
2015-04-22 00:54:51 +00:00
|
|
|
typedef void (*vp9_scaled_mc_func)(uint8_t *dst, ptrdiff_t dst_stride,
|
|
|
|
const uint8_t *ref, ptrdiff_t ref_stride,
|
|
|
|
int h, int mx, int my, int dx, int dy);
|
2013-10-01 03:03:30 +00:00
|
|
|
|
|
|
|
typedef struct VP9DSPContext {
|
|
|
|
/*
|
|
|
|
* dimension 1: 0=4x4, 1=8x8, 2=16x16, 3=32x32
|
|
|
|
* dimension 2: intra prediction modes
|
|
|
|
*
|
|
|
|
* dst/left/top is aligned by transform-size (i.e. 4, 8, 16 or 32 pixels)
|
|
|
|
* stride is aligned by 16 pixels
|
|
|
|
* top[-1] is top/left; top[4,7] is top-right for 4x4
|
|
|
|
*/
|
|
|
|
// FIXME(rbultje) maybe replace left/top pointers with HAVE_TOP/
|
|
|
|
// HAVE_LEFT/HAVE_TOPRIGHT flags instead, and then handle it in-place?
|
2016-06-21 19:55:20 +00:00
|
|
|
// also needs to fit in with what H.264/VP8/etc do
|
2013-10-01 03:03:30 +00:00
|
|
|
void (*intra_pred[N_TXFM_SIZES][N_INTRA_PRED_MODES])(uint8_t *dst,
|
|
|
|
ptrdiff_t stride,
|
|
|
|
const uint8_t *left,
|
|
|
|
const uint8_t *top);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* dimension 1: 0=4x4, 1=8x8, 2=16x16, 3=32x32, 4=lossless (3-4=dct only)
|
|
|
|
* dimension 2: 0=dct/dct, 1=dct/adst, 2=adst/dct, 3=adst/adst
|
|
|
|
*
|
|
|
|
* dst is aligned by transform-size (i.e. 4, 8, 16 or 32 pixels)
|
|
|
|
* stride is aligned by 16 pixels
|
|
|
|
* block is 16-byte aligned
|
|
|
|
* eob indicates the position (+1) of the last non-zero coefficient,
|
|
|
|
* in scan-order. This can be used to write faster versions, e.g. a
|
|
|
|
* dc-only 4x4/8x8/16x16/32x32, or a 4x4-only (eob<10) 8x8/16x16/32x32,
|
|
|
|
* etc.
|
|
|
|
*/
|
|
|
|
// FIXME also write idct_add_block() versions for whole (inter) pred
|
|
|
|
// blocks, so we can do 2 4x4s at once
|
|
|
|
void (*itxfm_add[N_TXFM_SIZES + 1][N_TXFM_TYPES])(uint8_t *dst,
|
|
|
|
ptrdiff_t stride,
|
|
|
|
int16_t *block, int eob);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* dimension 1: width of filter (0=4, 1=8, 2=16)
|
|
|
|
* dimension 2: 0=col-edge filter (h), 1=row-edge filter (v)
|
|
|
|
*
|
|
|
|
* dst/stride are aligned by 8
|
|
|
|
*/
|
|
|
|
void (*loop_filter_8[3][2])(uint8_t *dst, ptrdiff_t stride,
|
|
|
|
int mb_lim, int lim, int hev_thr);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* dimension 1: 0=col-edge filter (h), 1=row-edge filter (v)
|
|
|
|
*
|
|
|
|
* The width of filter is assumed to be 16; dst/stride are aligned by 16
|
|
|
|
*/
|
|
|
|
void (*loop_filter_16[2])(uint8_t *dst, ptrdiff_t stride,
|
|
|
|
int mb_lim, int lim, int hev_thr);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* dimension 1/2: width of filter (0=4, 1=8) for each filter half
|
|
|
|
* dimension 3: 0=col-edge filter (h), 1=row-edge filter (v)
|
|
|
|
*
|
|
|
|
* dst/stride are aligned by operation size
|
|
|
|
* this basically calls loop_filter[d1][d3][0](), followed by
|
|
|
|
* loop_filter[d2][d3][0]() on the next 8 pixels
|
|
|
|
* mb_lim/lim/hev_thr contain two values in the lowest two bytes of the
|
|
|
|
* integer.
|
|
|
|
*/
|
|
|
|
// FIXME perhaps a mix4 that operates on 32px (for AVX2)
|
|
|
|
void (*loop_filter_mix2[2][2][2])(uint8_t *dst, ptrdiff_t stride,
|
|
|
|
int mb_lim, int lim, int hev_thr);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* dimension 1: hsize (0: 64, 1: 32, 2: 16, 3: 8, 4: 4)
|
|
|
|
* dimension 2: filter type (0: smooth, 1: regular, 2: sharp, 3: bilin)
|
|
|
|
* dimension 3: averaging type (0: put, 1: avg)
|
|
|
|
* dimension 4: x subpel interpolation (0: none, 1: 8tap/bilin)
|
2014-03-29 16:28:37 +00:00
|
|
|
* dimension 5: y subpel interpolation (0: none, 1: 8tap/bilin)
|
2013-10-01 03:03:30 +00:00
|
|
|
*
|
|
|
|
* dst/stride are aligned by hsize
|
|
|
|
*/
|
|
|
|
vp9_mc_func mc[5][4][2][2][2];
|
2015-04-22 00:54:51 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* for scalable MC, first 3 dimensions identical to above, the other two
|
|
|
|
* don't exist since it changes per stepsize.
|
|
|
|
*/
|
|
|
|
vp9_scaled_mc_func smc[5][4][2];
|
2013-10-01 03:03:30 +00:00
|
|
|
} VP9DSPContext;
|
|
|
|
|
2016-11-14 10:32:19 +00:00
|
|
|
|
|
|
|
extern const int16_t ff_vp9_subpel_filters[3][16][8];
|
|
|
|
|
2015-09-09 18:10:41 +00:00
|
|
|
void ff_vp9dsp_init(VP9DSPContext *dsp, int bpp, int bitexact);
|
2013-10-01 03:03:30 +00:00
|
|
|
|
2015-05-06 12:50:43 +00:00
|
|
|
void ff_vp9dsp_init_8(VP9DSPContext *dsp);
|
|
|
|
void ff_vp9dsp_init_10(VP9DSPContext *dsp);
|
|
|
|
void ff_vp9dsp_init_12(VP9DSPContext *dsp);
|
|
|
|
|
2016-11-14 10:32:25 +00:00
|
|
|
void ff_vp9dsp_init_aarch64(VP9DSPContext *dsp, int bpp);
|
arm: vp9: Add NEON optimizations of VP9 MC functions
This work is sponsored by, and copyright, Google.
The filter coefficients are signed values, where the product of the
multiplication with one individual filter coefficient doesn't
overflow a 16 bit signed value (the largest filter coefficient is
127). But when the products are accumulated, the resulting sum can
overflow the 16 bit signed range. Instead of accumulating in 32 bit,
we accumulate the largest product (either index 3 or 4) last with a
saturated addition.
(The VP8 MC asm does something similar, but slightly simpler, by
accumulating each half of the filter separately. In the VP9 MC
filters, each half of the filter can also overflow though, so the
largest component has to be handled individually.)
Examples of relative speedup compared to the C version, from checkasm:
Cortex A7 A8 A9 A53
vp9_avg4_neon: 1.71 1.15 1.42 1.49
vp9_avg8_neon: 2.51 3.63 3.14 2.58
vp9_avg16_neon: 2.95 6.76 3.01 2.84
vp9_avg32_neon: 3.29 6.64 2.85 3.00
vp9_avg64_neon: 3.47 6.67 3.14 2.80
vp9_avg_8tap_smooth_4h_neon: 3.22 4.73 2.76 4.67
vp9_avg_8tap_smooth_4hv_neon: 3.67 4.76 3.28 4.71
vp9_avg_8tap_smooth_4v_neon: 5.52 7.60 4.60 6.31
vp9_avg_8tap_smooth_8h_neon: 6.22 9.04 5.12 9.32
vp9_avg_8tap_smooth_8hv_neon: 6.38 8.21 5.72 8.17
vp9_avg_8tap_smooth_8v_neon: 9.22 12.66 8.15 11.10
vp9_avg_8tap_smooth_64h_neon: 7.02 10.23 5.54 11.58
vp9_avg_8tap_smooth_64hv_neon: 6.76 9.46 5.93 9.40
vp9_avg_8tap_smooth_64v_neon: 10.76 14.13 9.46 13.37
vp9_put4_neon: 1.11 1.47 1.00 1.21
vp9_put8_neon: 1.23 2.17 1.94 1.48
vp9_put16_neon: 1.63 4.02 1.73 1.97
vp9_put32_neon: 1.56 4.92 2.00 1.96
vp9_put64_neon: 2.10 5.28 2.03 2.35
vp9_put_8tap_smooth_4h_neon: 3.11 4.35 2.63 4.35
vp9_put_8tap_smooth_4hv_neon: 3.67 4.69 3.25 4.71
vp9_put_8tap_smooth_4v_neon: 5.45 7.27 4.49 6.52
vp9_put_8tap_smooth_8h_neon: 5.97 8.18 4.81 8.56
vp9_put_8tap_smooth_8hv_neon: 6.39 7.90 5.64 8.15
vp9_put_8tap_smooth_8v_neon: 9.03 11.84 8.07 11.51
vp9_put_8tap_smooth_64h_neon: 6.78 9.48 4.88 10.89
vp9_put_8tap_smooth_64hv_neon: 6.99 8.87 5.94 9.56
vp9_put_8tap_smooth_64v_neon: 10.69 13.30 9.43 14.34
For the larger 8tap filters, the speedup vs C code is around 5-14x.
This is significantly faster than libvpx's implementation of the same
functions, at least when comparing the put_8tap_smooth_64 functions
(compared to vpx_convolve8_horiz_neon and vpx_convolve8_vert_neon from
libvpx).
Absolute runtimes from checkasm:
Cortex A7 A8 A9 A53
vp9_put_8tap_smooth_64h_neon: 20150.3 14489.4 19733.6 10863.7
libvpx vpx_convolve8_horiz_neon: 52623.3 19736.4 21907.7 25027.7
vp9_put_8tap_smooth_64v_neon: 14455.0 12303.9 13746.4 9628.9
libvpx vpx_convolve8_vert_neon: 42090.0 17706.2 17659.9 16941.2
Thus, on the A9, the horizontal filter is only marginally faster than
libvpx, while our version is significantly faster on the other cores,
and the vertical filter is significantly faster on all cores. The
difference is especially large on the A7.
The libvpx implementation does the accumulation in 32 bit, which
probably explains most of the differences.
This is an adapted cherry-pick from libav commits
ffbd1d2b0002576ef0d976a41ff959c635373fdc,
392caa65df3efa8b2d48a80f08a6af4892c61c08,
557c1675cf0e803b2fee43b4c8b58433842c84d0 and
11623217e3c9b859daee544e31acdd0821b61039.
Signed-off-by: Ronald S. Bultje <rsbultje@gmail.com>
2016-11-14 10:32:21 +00:00
|
|
|
void ff_vp9dsp_init_arm(VP9DSPContext *dsp, int bpp);
|
2015-09-09 18:10:41 +00:00
|
|
|
void ff_vp9dsp_init_x86(VP9DSPContext *dsp, int bpp, int bitexact);
|
2015-07-09 13:15:26 +00:00
|
|
|
void ff_vp9dsp_init_mips(VP9DSPContext *dsp, int bpp);
|
2013-09-22 01:24:03 +00:00
|
|
|
|
2013-10-01 03:03:30 +00:00
|
|
|
#endif /* AVCODEC_VP9DSP_H */
|