mirror of
https://github.com/FFmpeg/FFmpeg.git
synced 2024-12-23 12:43:46 +02:00
f3eb008343
These decoders use a special non-MPEG2 IDCT. Call it directly instead of going through dsputil. There is never any reason to use a regular IDCT with these decoders or to use the EA IDCT with other codecs. This also fixes the bizarre situation of eamad and eatqi decoding incorrectly if eatgq is disabled. Signed-off-by: Mans Rullgard <mans@mansr.com>
745 lines
29 KiB
C
745 lines
29 KiB
C
/*
|
|
* DSP utils
|
|
* Copyright (c) 2000, 2001, 2002 Fabrice Bellard
|
|
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
|
|
*
|
|
* This file is part of Libav.
|
|
*
|
|
* Libav 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.
|
|
*
|
|
* Libav 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 Libav; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
* DSP utils.
|
|
* note, many functions in here may use MMX which trashes the FPU state, it is
|
|
* absolutely necessary to call emms_c() between dsp & float/double code
|
|
*/
|
|
|
|
#ifndef AVCODEC_DSPUTIL_H
|
|
#define AVCODEC_DSPUTIL_H
|
|
|
|
#include "libavutil/intreadwrite.h"
|
|
#include "avcodec.h"
|
|
|
|
|
|
//#define DEBUG
|
|
/* dct code */
|
|
typedef short DCTELEM;
|
|
|
|
void ff_fdct_ifast (DCTELEM *data);
|
|
void ff_fdct_ifast248 (DCTELEM *data);
|
|
void ff_jpeg_fdct_islow_8(DCTELEM *data);
|
|
void ff_jpeg_fdct_islow_10(DCTELEM *data);
|
|
void ff_fdct248_islow_8(DCTELEM *data);
|
|
void ff_fdct248_islow_10(DCTELEM *data);
|
|
|
|
void ff_j_rev_dct (DCTELEM *data);
|
|
void ff_wmv2_idct_c(DCTELEM *data);
|
|
|
|
void ff_fdct_mmx(DCTELEM *block);
|
|
void ff_fdct_mmx2(DCTELEM *block);
|
|
void ff_fdct_sse2(DCTELEM *block);
|
|
|
|
#define H264_IDCT(depth) \
|
|
void ff_h264_idct8_add_ ## depth ## _c(uint8_t *dst, DCTELEM *block, int stride);\
|
|
void ff_h264_idct_add_ ## depth ## _c(uint8_t *dst, DCTELEM *block, int stride);\
|
|
void ff_h264_idct8_dc_add_ ## depth ## _c(uint8_t *dst, DCTELEM *block, int stride);\
|
|
void ff_h264_idct_dc_add_ ## depth ## _c(uint8_t *dst, DCTELEM *block, int stride);\
|
|
void ff_h264_idct_add16_ ## depth ## _c(uint8_t *dst, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]);\
|
|
void ff_h264_idct_add16intra_ ## depth ## _c(uint8_t *dst, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]);\
|
|
void ff_h264_idct8_add4_ ## depth ## _c(uint8_t *dst, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]);\
|
|
void ff_h264_idct_add8_422_ ## depth ## _c(uint8_t **dest, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]);\
|
|
void ff_h264_idct_add8_ ## depth ## _c(uint8_t **dest, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]);\
|
|
void ff_h264_luma_dc_dequant_idct_ ## depth ## _c(DCTELEM *output, DCTELEM *input, int qmul);\
|
|
void ff_h264_chroma422_dc_dequant_idct_ ## depth ## _c(DCTELEM *block, int qmul);\
|
|
void ff_h264_chroma_dc_dequant_idct_ ## depth ## _c(DCTELEM *block, int qmul);
|
|
|
|
H264_IDCT( 8)
|
|
H264_IDCT( 9)
|
|
H264_IDCT(10)
|
|
|
|
void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *output, DCTELEM *input, int qp);
|
|
void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc);
|
|
|
|
/* encoding scans */
|
|
extern const uint8_t ff_alternate_horizontal_scan[64];
|
|
extern const uint8_t ff_alternate_vertical_scan[64];
|
|
extern const uint8_t ff_zigzag_direct[64];
|
|
extern const uint8_t ff_zigzag248_direct[64];
|
|
|
|
/* pixel operations */
|
|
#define MAX_NEG_CROP 1024
|
|
|
|
/* temporary */
|
|
extern uint32_t ff_squareTbl[512];
|
|
extern uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP];
|
|
|
|
#define PUTAVG_PIXELS(depth)\
|
|
void ff_put_pixels8x8_ ## depth ## _c(uint8_t *dst, uint8_t *src, int stride);\
|
|
void ff_avg_pixels8x8_ ## depth ## _c(uint8_t *dst, uint8_t *src, int stride);\
|
|
void ff_put_pixels16x16_ ## depth ## _c(uint8_t *dst, uint8_t *src, int stride);\
|
|
void ff_avg_pixels16x16_ ## depth ## _c(uint8_t *dst, uint8_t *src, int stride);
|
|
|
|
PUTAVG_PIXELS( 8)
|
|
PUTAVG_PIXELS( 9)
|
|
PUTAVG_PIXELS(10)
|
|
|
|
#define ff_put_pixels8x8_c ff_put_pixels8x8_8_c
|
|
#define ff_avg_pixels8x8_c ff_avg_pixels8x8_8_c
|
|
#define ff_put_pixels16x16_c ff_put_pixels16x16_8_c
|
|
#define ff_avg_pixels16x16_c ff_avg_pixels16x16_8_c
|
|
|
|
/* RV40 functions */
|
|
void ff_put_rv40_qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride);
|
|
void ff_avg_rv40_qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride);
|
|
void ff_put_rv40_qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride);
|
|
void ff_avg_rv40_qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride);
|
|
|
|
/* 1/2^n downscaling functions from imgconvert.c */
|
|
void ff_shrink22(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
|
|
void ff_shrink44(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
|
|
void ff_shrink88(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
|
|
|
|
void ff_gmc_c(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
|
|
int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height);
|
|
|
|
/* minimum alignment rules ;)
|
|
If you notice errors in the align stuff, need more alignment for some ASM code
|
|
for some CPU or need to use a function with less aligned data then send a mail
|
|
to the libav-devel mailing list, ...
|
|
|
|
!warning These alignments might not match reality, (missing attribute((align))
|
|
stuff somewhere possible).
|
|
I (Michael) did not check them, these are just the alignments which I think
|
|
could be reached easily ...
|
|
|
|
!future video codecs might need functions with less strict alignment
|
|
*/
|
|
|
|
/*
|
|
void get_pixels_c(DCTELEM *block, const uint8_t *pixels, int line_size);
|
|
void diff_pixels_c(DCTELEM *block, const uint8_t *s1, const uint8_t *s2, int stride);
|
|
void put_pixels_clamped_c(const DCTELEM *block, uint8_t *pixels, int line_size);
|
|
void add_pixels_clamped_c(const DCTELEM *block, uint8_t *pixels, int line_size);
|
|
void clear_blocks_c(DCTELEM *blocks);
|
|
*/
|
|
|
|
/* add and put pixel (decoding) */
|
|
// blocksizes for op_pixels_func are 8x4,8x8 16x8 16x16
|
|
//h for op_pixels_func is limited to {width/2, width} but never larger than 16 and never smaller than 4
|
|
typedef void (*op_pixels_func)(uint8_t *block/*align width (8 or 16)*/, const uint8_t *pixels/*align 1*/, int line_size, int h);
|
|
typedef void (*tpel_mc_func)(uint8_t *block/*align width (8 or 16)*/, const uint8_t *pixels/*align 1*/, int line_size, int w, int h);
|
|
typedef void (*qpel_mc_func)(uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);
|
|
typedef void (*h264_chroma_mc_func)(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int srcStride, int h, int x, int y);
|
|
|
|
typedef void (*op_fill_func)(uint8_t *block/*align width (8 or 16)*/, uint8_t value, int line_size, int h);
|
|
|
|
#define DEF_OLD_QPEL(name)\
|
|
void ff_put_ ## name (uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);\
|
|
void ff_put_no_rnd_ ## name (uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);\
|
|
void ff_avg_ ## name (uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);
|
|
|
|
DEF_OLD_QPEL(qpel16_mc11_old_c)
|
|
DEF_OLD_QPEL(qpel16_mc31_old_c)
|
|
DEF_OLD_QPEL(qpel16_mc12_old_c)
|
|
DEF_OLD_QPEL(qpel16_mc32_old_c)
|
|
DEF_OLD_QPEL(qpel16_mc13_old_c)
|
|
DEF_OLD_QPEL(qpel16_mc33_old_c)
|
|
DEF_OLD_QPEL(qpel8_mc11_old_c)
|
|
DEF_OLD_QPEL(qpel8_mc31_old_c)
|
|
DEF_OLD_QPEL(qpel8_mc12_old_c)
|
|
DEF_OLD_QPEL(qpel8_mc32_old_c)
|
|
DEF_OLD_QPEL(qpel8_mc13_old_c)
|
|
DEF_OLD_QPEL(qpel8_mc33_old_c)
|
|
|
|
#define CALL_2X_PIXELS(a, b, n)\
|
|
static void a(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
|
|
b(block , pixels , line_size, h);\
|
|
b(block+n, pixels+n, line_size, h);\
|
|
}
|
|
|
|
/* motion estimation */
|
|
// h is limited to {width/2, width, 2*width} but never larger than 16 and never smaller than 2
|
|
// although currently h<4 is not used as functions with width <8 are neither used nor implemented
|
|
typedef int (*me_cmp_func)(void /*MpegEncContext*/ *s, uint8_t *blk1/*align width (8 or 16)*/, uint8_t *blk2/*align 1*/, int line_size, int h)/* __attribute__ ((const))*/;
|
|
|
|
/**
|
|
* Scantable.
|
|
*/
|
|
typedef struct ScanTable{
|
|
const uint8_t *scantable;
|
|
uint8_t permutated[64];
|
|
uint8_t raster_end[64];
|
|
} ScanTable;
|
|
|
|
void ff_init_scantable(uint8_t *, ScanTable *st, const uint8_t *src_scantable);
|
|
void ff_init_scantable_permutation(uint8_t *idct_permutation,
|
|
int idct_permutation_type);
|
|
|
|
#define EMULATED_EDGE(depth) \
|
|
void ff_emulated_edge_mc_ ## depth (uint8_t *buf, const uint8_t *src, int linesize,\
|
|
int block_w, int block_h,\
|
|
int src_x, int src_y, int w, int h);
|
|
|
|
EMULATED_EDGE(8)
|
|
EMULATED_EDGE(9)
|
|
EMULATED_EDGE(10)
|
|
|
|
void ff_add_pixels_clamped_c(const DCTELEM *block, uint8_t *dest, int linesize);
|
|
void ff_put_pixels_clamped_c(const DCTELEM *block, uint8_t *dest, int linesize);
|
|
void ff_put_signed_pixels_clamped_c(const DCTELEM *block, uint8_t *dest, int linesize);
|
|
|
|
/**
|
|
* DSPContext.
|
|
*/
|
|
typedef struct DSPContext {
|
|
/**
|
|
* Size of DCT coefficients.
|
|
*/
|
|
int dct_bits;
|
|
|
|
/* pixel ops : interface with DCT */
|
|
void (*get_pixels)(DCTELEM *block/*align 16*/, const uint8_t *pixels/*align 8*/, int line_size);
|
|
void (*diff_pixels)(DCTELEM *block/*align 16*/, const uint8_t *s1/*align 8*/, const uint8_t *s2/*align 8*/, int stride);
|
|
void (*put_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
|
|
void (*put_signed_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
|
|
void (*add_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
|
|
void (*add_pixels8)(uint8_t *pixels, DCTELEM *block, int line_size);
|
|
void (*add_pixels4)(uint8_t *pixels, DCTELEM *block, int line_size);
|
|
int (*sum_abs_dctelem)(DCTELEM *block/*align 16*/);
|
|
/**
|
|
* Motion estimation with emulated edge values.
|
|
* @param buf pointer to destination buffer (unaligned)
|
|
* @param src pointer to pixel source (unaligned)
|
|
* @param linesize width (in pixels) for src/buf
|
|
* @param block_w number of pixels (per row) to copy to buf
|
|
* @param block_h nummber of pixel rows to copy to buf
|
|
* @param src_x offset of src to start of row - this may be negative
|
|
* @param src_y offset of src to top of image - this may be negative
|
|
* @param w width of src in pixels
|
|
* @param h height of src in pixels
|
|
*/
|
|
void (*emulated_edge_mc)(uint8_t *buf, const uint8_t *src, int linesize,
|
|
int block_w, int block_h,
|
|
int src_x, int src_y, int w, int h);
|
|
/**
|
|
* translational global motion compensation.
|
|
*/
|
|
void (*gmc1)(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int srcStride, int h, int x16, int y16, int rounder);
|
|
/**
|
|
* global motion compensation.
|
|
*/
|
|
void (*gmc )(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int ox, int oy,
|
|
int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height);
|
|
void (*clear_block)(DCTELEM *block/*align 16*/);
|
|
void (*clear_blocks)(DCTELEM *blocks/*align 16*/);
|
|
int (*pix_sum)(uint8_t * pix, int line_size);
|
|
int (*pix_norm1)(uint8_t * pix, int line_size);
|
|
// 16x16 8x8 4x4 2x2 16x8 8x4 4x2 8x16 4x8 2x4
|
|
|
|
me_cmp_func sad[6]; /* identical to pix_absAxA except additional void * */
|
|
me_cmp_func sse[6];
|
|
me_cmp_func hadamard8_diff[6];
|
|
me_cmp_func dct_sad[6];
|
|
me_cmp_func quant_psnr[6];
|
|
me_cmp_func bit[6];
|
|
me_cmp_func rd[6];
|
|
me_cmp_func vsad[6];
|
|
me_cmp_func vsse[6];
|
|
me_cmp_func nsse[6];
|
|
me_cmp_func w53[6];
|
|
me_cmp_func w97[6];
|
|
me_cmp_func dct_max[6];
|
|
me_cmp_func dct264_sad[6];
|
|
|
|
me_cmp_func me_pre_cmp[6];
|
|
me_cmp_func me_cmp[6];
|
|
me_cmp_func me_sub_cmp[6];
|
|
me_cmp_func mb_cmp[6];
|
|
me_cmp_func ildct_cmp[6]; //only width 16 used
|
|
me_cmp_func frame_skip_cmp[6]; //only width 8 used
|
|
|
|
int (*ssd_int8_vs_int16)(const int8_t *pix1, const int16_t *pix2,
|
|
int size);
|
|
|
|
/**
|
|
* Halfpel motion compensation with rounding (a+b+1)>>1.
|
|
* this is an array[4][4] of motion compensation functions for 4
|
|
* horizontal blocksizes (8,16) and the 4 halfpel positions<br>
|
|
* *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
|
|
* @param block destination where the result is stored
|
|
* @param pixels source
|
|
* @param line_size number of bytes in a horizontal line of block
|
|
* @param h height
|
|
*/
|
|
op_pixels_func put_pixels_tab[4][4];
|
|
|
|
/**
|
|
* Halfpel motion compensation with rounding (a+b+1)>>1.
|
|
* This is an array[4][4] of motion compensation functions for 4
|
|
* horizontal blocksizes (8,16) and the 4 halfpel positions<br>
|
|
* *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
|
|
* @param block destination into which the result is averaged (a+b+1)>>1
|
|
* @param pixels source
|
|
* @param line_size number of bytes in a horizontal line of block
|
|
* @param h height
|
|
*/
|
|
op_pixels_func avg_pixels_tab[4][4];
|
|
|
|
/**
|
|
* Halfpel motion compensation with no rounding (a+b)>>1.
|
|
* this is an array[2][4] of motion compensation functions for 2
|
|
* horizontal blocksizes (8,16) and the 4 halfpel positions<br>
|
|
* *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
|
|
* @param block destination where the result is stored
|
|
* @param pixels source
|
|
* @param line_size number of bytes in a horizontal line of block
|
|
* @param h height
|
|
*/
|
|
op_pixels_func put_no_rnd_pixels_tab[4][4];
|
|
|
|
/**
|
|
* Halfpel motion compensation with no rounding (a+b)>>1.
|
|
* this is an array[2][4] of motion compensation functions for 2
|
|
* horizontal blocksizes (8,16) and the 4 halfpel positions<br>
|
|
* *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
|
|
* @param block destination into which the result is averaged (a+b)>>1
|
|
* @param pixels source
|
|
* @param line_size number of bytes in a horizontal line of block
|
|
* @param h height
|
|
*/
|
|
op_pixels_func avg_no_rnd_pixels_tab[4][4];
|
|
|
|
void (*put_no_rnd_pixels_l2[2])(uint8_t *block/*align width (8 or 16)*/, const uint8_t *a/*align 1*/, const uint8_t *b/*align 1*/, int line_size, int h);
|
|
|
|
/**
|
|
* Thirdpel motion compensation with rounding (a+b+1)>>1.
|
|
* this is an array[12] of motion compensation functions for the 9 thirdpe
|
|
* positions<br>
|
|
* *pixels_tab[ xthirdpel + 4*ythirdpel ]
|
|
* @param block destination where the result is stored
|
|
* @param pixels source
|
|
* @param line_size number of bytes in a horizontal line of block
|
|
* @param h height
|
|
*/
|
|
tpel_mc_func put_tpel_pixels_tab[11]; //FIXME individual func ptr per width?
|
|
tpel_mc_func avg_tpel_pixels_tab[11]; //FIXME individual func ptr per width?
|
|
|
|
qpel_mc_func put_qpel_pixels_tab[2][16];
|
|
qpel_mc_func avg_qpel_pixels_tab[2][16];
|
|
qpel_mc_func put_no_rnd_qpel_pixels_tab[2][16];
|
|
qpel_mc_func avg_no_rnd_qpel_pixels_tab[2][16];
|
|
qpel_mc_func put_mspel_pixels_tab[8];
|
|
|
|
/**
|
|
* h264 Chroma MC
|
|
*/
|
|
h264_chroma_mc_func put_h264_chroma_pixels_tab[3];
|
|
h264_chroma_mc_func avg_h264_chroma_pixels_tab[3];
|
|
|
|
qpel_mc_func put_h264_qpel_pixels_tab[4][16];
|
|
qpel_mc_func avg_h264_qpel_pixels_tab[4][16];
|
|
|
|
qpel_mc_func put_2tap_qpel_pixels_tab[4][16];
|
|
qpel_mc_func avg_2tap_qpel_pixels_tab[4][16];
|
|
|
|
me_cmp_func pix_abs[2][4];
|
|
|
|
/* huffyuv specific */
|
|
void (*add_bytes)(uint8_t *dst/*align 16*/, uint8_t *src/*align 16*/, int w);
|
|
void (*diff_bytes)(uint8_t *dst/*align 16*/, uint8_t *src1/*align 16*/, uint8_t *src2/*align 1*/,int w);
|
|
/**
|
|
* subtract huffyuv's variant of median prediction
|
|
* note, this might read from src1[-1], src2[-1]
|
|
*/
|
|
void (*sub_hfyu_median_prediction)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int w, int *left, int *left_top);
|
|
void (*add_hfyu_median_prediction)(uint8_t *dst, const uint8_t *top, const uint8_t *diff, int w, int *left, int *left_top);
|
|
int (*add_hfyu_left_prediction)(uint8_t *dst, const uint8_t *src, int w, int left);
|
|
void (*add_hfyu_left_prediction_bgr32)(uint8_t *dst, const uint8_t *src, int w, int *red, int *green, int *blue, int *alpha);
|
|
void (*bswap_buf)(uint32_t *dst, const uint32_t *src, int w);
|
|
void (*bswap16_buf)(uint16_t *dst, const uint16_t *src, int len);
|
|
|
|
void (*h263_v_loop_filter)(uint8_t *src, int stride, int qscale);
|
|
void (*h263_h_loop_filter)(uint8_t *src, int stride, int qscale);
|
|
|
|
void (*h261_loop_filter)(uint8_t *src, int stride);
|
|
|
|
void (*x8_v_loop_filter)(uint8_t *src, int stride, int qscale);
|
|
void (*x8_h_loop_filter)(uint8_t *src, int stride, int qscale);
|
|
|
|
/* assume len is a multiple of 4, and arrays are 16-byte aligned */
|
|
void (*vorbis_inverse_coupling)(float *mag, float *ang, int blocksize);
|
|
void (*ac3_downmix)(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len);
|
|
/* assume len is a multiple of 16, and arrays are 32-byte aligned */
|
|
void (*vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len);
|
|
/* assume len is a multiple of 8, and src arrays are 16-byte aligned */
|
|
void (*vector_fmul_add)(float *dst, const float *src0, const float *src1, const float *src2, int len);
|
|
/* assume len is a multiple of 4, and arrays are 16-byte aligned */
|
|
void (*vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len);
|
|
/* assume len is a multiple of 8, and arrays are 16-byte aligned */
|
|
void (*vector_clipf)(float *dst /* align 16 */, const float *src /* align 16 */, float min, float max, int len /* align 16 */);
|
|
/**
|
|
* Multiply a vector of floats by a scalar float. Source and
|
|
* destination vectors must overlap exactly or not at all.
|
|
* @param dst result vector, 16-byte aligned
|
|
* @param src input vector, 16-byte aligned
|
|
* @param mul scalar value
|
|
* @param len length of vector, multiple of 4
|
|
*/
|
|
void (*vector_fmul_scalar)(float *dst, const float *src, float mul,
|
|
int len);
|
|
/**
|
|
* Calculate the scalar product of two vectors of floats.
|
|
* @param v1 first vector, 16-byte aligned
|
|
* @param v2 second vector, 16-byte aligned
|
|
* @param len length of vectors, multiple of 4
|
|
*/
|
|
float (*scalarproduct_float)(const float *v1, const float *v2, int len);
|
|
/**
|
|
* Calculate the sum and difference of two vectors of floats.
|
|
* @param v1 first input vector, sum output, 16-byte aligned
|
|
* @param v2 second input vector, difference output, 16-byte aligned
|
|
* @param len length of vectors, multiple of 4
|
|
*/
|
|
void (*butterflies_float)(float *restrict v1, float *restrict v2, int len);
|
|
|
|
/**
|
|
* Calculate the sum and difference of two vectors of floats and interleave
|
|
* results into a separate output vector of floats, with each sum
|
|
* positioned before the corresponding difference.
|
|
*
|
|
* @param dst output vector
|
|
* constraints: 16-byte aligned
|
|
* @param src0 first input vector
|
|
* constraints: 32-byte aligned
|
|
* @param src1 second input vector
|
|
* constraints: 32-byte aligned
|
|
* @param len number of elements in the input
|
|
* constraints: multiple of 8
|
|
*/
|
|
void (*butterflies_float_interleave)(float *dst, const float *src0,
|
|
const float *src1, int len);
|
|
|
|
/* (I)DCT */
|
|
void (*fdct)(DCTELEM *block/* align 16*/);
|
|
void (*fdct248)(DCTELEM *block/* align 16*/);
|
|
|
|
/* IDCT really*/
|
|
void (*idct)(DCTELEM *block/* align 16*/);
|
|
|
|
/**
|
|
* block -> idct -> clip to unsigned 8 bit -> dest.
|
|
* (-1392, 0, 0, ...) -> idct -> (-174, -174, ...) -> put -> (0, 0, ...)
|
|
* @param line_size size in bytes of a horizontal line of dest
|
|
*/
|
|
void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
|
|
|
|
/**
|
|
* block -> idct -> add dest -> clip to unsigned 8 bit -> dest.
|
|
* @param line_size size in bytes of a horizontal line of dest
|
|
*/
|
|
void (*idct_add)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
|
|
|
|
/**
|
|
* idct input permutation.
|
|
* several optimized IDCTs need a permutated input (relative to the normal order of the reference
|
|
* IDCT)
|
|
* this permutation must be performed before the idct_put/add, note, normally this can be merged
|
|
* with the zigzag/alternate scan<br>
|
|
* an example to avoid confusion:
|
|
* - (->decode coeffs -> zigzag reorder -> dequant -> reference idct ->...)
|
|
* - (x -> reference dct -> reference idct -> x)
|
|
* - (x -> reference dct -> simple_mmx_perm = idct_permutation -> simple_idct_mmx -> x)
|
|
* - (->decode coeffs -> zigzag reorder -> simple_mmx_perm -> dequant -> simple_idct_mmx ->...)
|
|
*/
|
|
uint8_t idct_permutation[64];
|
|
int idct_permutation_type;
|
|
#define FF_NO_IDCT_PERM 1
|
|
#define FF_LIBMPEG2_IDCT_PERM 2
|
|
#define FF_SIMPLE_IDCT_PERM 3
|
|
#define FF_TRANSPOSE_IDCT_PERM 4
|
|
#define FF_PARTTRANS_IDCT_PERM 5
|
|
#define FF_SSE2_IDCT_PERM 6
|
|
|
|
int (*try_8x8basis)(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale);
|
|
void (*add_8x8basis)(int16_t rem[64], int16_t basis[64], int scale);
|
|
#define BASIS_SHIFT 16
|
|
#define RECON_SHIFT 6
|
|
|
|
void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides);
|
|
#define EDGE_WIDTH 16
|
|
#define EDGE_TOP 1
|
|
#define EDGE_BOTTOM 2
|
|
|
|
void (*prefetch)(void *mem, int stride, int h);
|
|
|
|
void (*shrink[4])(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
|
|
|
|
/* mlp/truehd functions */
|
|
void (*mlp_filter_channel)(int32_t *state, const int32_t *coeff,
|
|
int firorder, int iirorder,
|
|
unsigned int filter_shift, int32_t mask, int blocksize,
|
|
int32_t *sample_buffer);
|
|
|
|
/* intrax8 functions */
|
|
void (*x8_spatial_compensation[12])(uint8_t *src , uint8_t *dst, int linesize);
|
|
void (*x8_setup_spatial_compensation)(uint8_t *src, uint8_t *dst, int linesize,
|
|
int * range, int * sum, int edges);
|
|
|
|
/**
|
|
* Calculate scalar product of two vectors.
|
|
* @param len length of vectors, should be multiple of 16
|
|
*/
|
|
int32_t (*scalarproduct_int16)(const int16_t *v1, const int16_t *v2/*align 16*/, int len);
|
|
/* ape functions */
|
|
/**
|
|
* Calculate scalar product of v1 and v2,
|
|
* and v1[i] += v3[i] * mul
|
|
* @param len length of vectors, should be multiple of 16
|
|
*/
|
|
int32_t (*scalarproduct_and_madd_int16)(int16_t *v1/*align 16*/, const int16_t *v2, const int16_t *v3, int len, int mul);
|
|
|
|
/**
|
|
* Apply symmetric window in 16-bit fixed-point.
|
|
* @param output destination array
|
|
* constraints: 16-byte aligned
|
|
* @param input source array
|
|
* constraints: 16-byte aligned
|
|
* @param window window array
|
|
* constraints: 16-byte aligned, at least len/2 elements
|
|
* @param len full window length
|
|
* constraints: multiple of ? greater than zero
|
|
*/
|
|
void (*apply_window_int16)(int16_t *output, const int16_t *input,
|
|
const int16_t *window, unsigned int len);
|
|
|
|
/**
|
|
* Clip each element in an array of int32_t to a given minimum and maximum value.
|
|
* @param dst destination array
|
|
* constraints: 16-byte aligned
|
|
* @param src source array
|
|
* constraints: 16-byte aligned
|
|
* @param min minimum value
|
|
* constraints: must be in the range [-(1 << 24), 1 << 24]
|
|
* @param max maximum value
|
|
* constraints: must be in the range [-(1 << 24), 1 << 24]
|
|
* @param len number of elements in the array
|
|
* constraints: multiple of 32 greater than zero
|
|
*/
|
|
void (*vector_clip_int32)(int32_t *dst, const int32_t *src, int32_t min,
|
|
int32_t max, unsigned int len);
|
|
|
|
op_fill_func fill_block_tab[2];
|
|
} DSPContext;
|
|
|
|
void ff_dsputil_static_init(void);
|
|
void ff_dsputil_init(DSPContext* p, AVCodecContext *avctx);
|
|
|
|
int ff_check_alignment(void);
|
|
|
|
/**
|
|
* permute block according to permuatation.
|
|
* @param last last non zero element in scantable order
|
|
*/
|
|
void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last);
|
|
|
|
void ff_set_cmp(DSPContext* c, me_cmp_func *cmp, int type);
|
|
|
|
#define BYTE_VEC32(c) ((c)*0x01010101UL)
|
|
#define BYTE_VEC64(c) ((c)*0x0001000100010001UL)
|
|
|
|
static inline uint32_t rnd_avg32(uint32_t a, uint32_t b)
|
|
{
|
|
return (a | b) - (((a ^ b) & ~BYTE_VEC32(0x01)) >> 1);
|
|
}
|
|
|
|
static inline uint32_t no_rnd_avg32(uint32_t a, uint32_t b)
|
|
{
|
|
return (a & b) + (((a ^ b) & ~BYTE_VEC32(0x01)) >> 1);
|
|
}
|
|
|
|
static inline uint64_t rnd_avg64(uint64_t a, uint64_t b)
|
|
{
|
|
return (a | b) - (((a ^ b) & ~BYTE_VEC64(0x01)) >> 1);
|
|
}
|
|
|
|
static inline uint64_t no_rnd_avg64(uint64_t a, uint64_t b)
|
|
{
|
|
return (a & b) + (((a ^ b) & ~BYTE_VEC64(0x01)) >> 1);
|
|
}
|
|
|
|
static inline int get_penalty_factor(int lambda, int lambda2, int type){
|
|
switch(type&0xFF){
|
|
default:
|
|
case FF_CMP_SAD:
|
|
return lambda>>FF_LAMBDA_SHIFT;
|
|
case FF_CMP_DCT:
|
|
return (3*lambda)>>(FF_LAMBDA_SHIFT+1);
|
|
case FF_CMP_W53:
|
|
return (4*lambda)>>(FF_LAMBDA_SHIFT);
|
|
case FF_CMP_W97:
|
|
return (2*lambda)>>(FF_LAMBDA_SHIFT);
|
|
case FF_CMP_SATD:
|
|
case FF_CMP_DCT264:
|
|
return (2*lambda)>>FF_LAMBDA_SHIFT;
|
|
case FF_CMP_RD:
|
|
case FF_CMP_PSNR:
|
|
case FF_CMP_SSE:
|
|
case FF_CMP_NSSE:
|
|
return lambda2>>FF_LAMBDA_SHIFT;
|
|
case FF_CMP_BIT:
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
void ff_dsputil_init_alpha(DSPContext* c, AVCodecContext *avctx);
|
|
void ff_dsputil_init_arm(DSPContext* c, AVCodecContext *avctx);
|
|
void ff_dsputil_init_bfin(DSPContext* c, AVCodecContext *avctx);
|
|
void ff_dsputil_init_mmi(DSPContext* c, AVCodecContext *avctx);
|
|
void ff_dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx);
|
|
void ff_dsputil_init_ppc(DSPContext* c, AVCodecContext *avctx);
|
|
void ff_dsputil_init_sh4(DSPContext* c, AVCodecContext *avctx);
|
|
void ff_dsputil_init_vis(DSPContext* c, AVCodecContext *avctx);
|
|
|
|
void ff_dsputil_init_dwt(DSPContext *c);
|
|
void ff_intrax8dsp_init(DSPContext* c, AVCodecContext *avctx);
|
|
void ff_mlp_init(DSPContext* c, AVCodecContext *avctx);
|
|
void ff_mlp_init_x86(DSPContext* c, AVCodecContext *avctx);
|
|
|
|
#if (ARCH_ARM && HAVE_NEON) || ARCH_PPC || HAVE_MMI || HAVE_MMX
|
|
# define STRIDE_ALIGN 16
|
|
#else
|
|
# define STRIDE_ALIGN 8
|
|
#endif
|
|
|
|
#define LOCAL_ALIGNED_A(a, t, v, s, o, ...) \
|
|
uint8_t la_##v[sizeof(t s o) + (a)]; \
|
|
t (*v) o = (void *)FFALIGN((uintptr_t)la_##v, a)
|
|
|
|
#define LOCAL_ALIGNED_D(a, t, v, s, o, ...) DECLARE_ALIGNED(a, t, v) s o
|
|
|
|
#define LOCAL_ALIGNED(a, t, v, ...) LOCAL_ALIGNED_A(a, t, v, __VA_ARGS__,,)
|
|
|
|
#if HAVE_LOCAL_ALIGNED_8
|
|
# define LOCAL_ALIGNED_8(t, v, ...) LOCAL_ALIGNED_D(8, t, v, __VA_ARGS__,,)
|
|
#else
|
|
# define LOCAL_ALIGNED_8(t, v, ...) LOCAL_ALIGNED(8, t, v, __VA_ARGS__)
|
|
#endif
|
|
|
|
#if HAVE_LOCAL_ALIGNED_16
|
|
# define LOCAL_ALIGNED_16(t, v, ...) LOCAL_ALIGNED_D(16, t, v, __VA_ARGS__,,)
|
|
#else
|
|
# define LOCAL_ALIGNED_16(t, v, ...) LOCAL_ALIGNED(16, t, v, __VA_ARGS__)
|
|
#endif
|
|
|
|
#define WRAPPER8_16(name8, name16)\
|
|
static int name16(void /*MpegEncContext*/ *s, uint8_t *dst, uint8_t *src, int stride, int h){\
|
|
return name8(s, dst , src , stride, h)\
|
|
+name8(s, dst+8 , src+8 , stride, h);\
|
|
}
|
|
|
|
#define WRAPPER8_16_SQ(name8, name16)\
|
|
static int name16(void /*MpegEncContext*/ *s, uint8_t *dst, uint8_t *src, int stride, int h){\
|
|
int score=0;\
|
|
score +=name8(s, dst , src , stride, 8);\
|
|
score +=name8(s, dst+8 , src+8 , stride, 8);\
|
|
if(h==16){\
|
|
dst += 8*stride;\
|
|
src += 8*stride;\
|
|
score +=name8(s, dst , src , stride, 8);\
|
|
score +=name8(s, dst+8 , src+8 , stride, 8);\
|
|
}\
|
|
return score;\
|
|
}
|
|
|
|
|
|
static inline void copy_block2(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
|
|
{
|
|
int i;
|
|
for(i=0; i<h; i++)
|
|
{
|
|
AV_WN16(dst , AV_RN16(src ));
|
|
dst+=dstStride;
|
|
src+=srcStride;
|
|
}
|
|
}
|
|
|
|
static inline void copy_block4(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
|
|
{
|
|
int i;
|
|
for(i=0; i<h; i++)
|
|
{
|
|
AV_WN32(dst , AV_RN32(src ));
|
|
dst+=dstStride;
|
|
src+=srcStride;
|
|
}
|
|
}
|
|
|
|
static inline void copy_block8(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
|
|
{
|
|
int i;
|
|
for(i=0; i<h; i++)
|
|
{
|
|
AV_WN32(dst , AV_RN32(src ));
|
|
AV_WN32(dst+4 , AV_RN32(src+4 ));
|
|
dst+=dstStride;
|
|
src+=srcStride;
|
|
}
|
|
}
|
|
|
|
static inline void copy_block9(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
|
|
{
|
|
int i;
|
|
for(i=0; i<h; i++)
|
|
{
|
|
AV_WN32(dst , AV_RN32(src ));
|
|
AV_WN32(dst+4 , AV_RN32(src+4 ));
|
|
dst[8]= src[8];
|
|
dst+=dstStride;
|
|
src+=srcStride;
|
|
}
|
|
}
|
|
|
|
static inline void copy_block16(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
|
|
{
|
|
int i;
|
|
for(i=0; i<h; i++)
|
|
{
|
|
AV_WN32(dst , AV_RN32(src ));
|
|
AV_WN32(dst+4 , AV_RN32(src+4 ));
|
|
AV_WN32(dst+8 , AV_RN32(src+8 ));
|
|
AV_WN32(dst+12, AV_RN32(src+12));
|
|
dst+=dstStride;
|
|
src+=srcStride;
|
|
}
|
|
}
|
|
|
|
static inline void copy_block17(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
|
|
{
|
|
int i;
|
|
for(i=0; i<h; i++)
|
|
{
|
|
AV_WN32(dst , AV_RN32(src ));
|
|
AV_WN32(dst+4 , AV_RN32(src+4 ));
|
|
AV_WN32(dst+8 , AV_RN32(src+8 ));
|
|
AV_WN32(dst+12, AV_RN32(src+12));
|
|
dst[16]= src[16];
|
|
dst+=dstStride;
|
|
src+=srcStride;
|
|
}
|
|
}
|
|
|
|
#endif /* AVCODEC_DSPUTIL_H */
|