virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

Add a float DSP framework to libavutil

Browse Source 
Move vector_fmul() from DSPContext to AVFloatDSPContext.
This commit is contained in:
Justin Ruggles 2012-05-21 12:58:41 -04:00
parent 98db4e2a4e
commit d5a7229ba4
39 changed files with 602 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libavcodec/aac.h
View File

@ -30,6 +30,7 @@
#ifndef AVCODEC_AAC_H #ifndef AVCODEC_AAC_H
#define AVCODEC_AAC_H #define AVCODEC_AAC_H
#include "libavutil/float_dsp.h"
#include "avcodec.h" #include "avcodec.h"
#include "dsputil.h" #include "dsputil.h"
#include "fft.h" #include "fft.h"
@ -292,6 +293,7 @@ typedef struct {
FFTContext mdct_ltp; FFTContext mdct_ltp;
DSPContext dsp; DSPContext dsp;
FmtConvertContext fmt_conv; FmtConvertContext fmt_conv;
AVFloatDSPContext fdsp;
int random_state; int random_state;
/** @} */ /** @} */

7
libavcodec/aacdec.c
View File

@ -79,7 +79,7 @@
Parametric Stereo. Parametric Stereo.
*/ */
#include "libavutil/float_dsp.h"
#include "avcodec.h" #include "avcodec.h"
#include "internal.h" #include "internal.h"
#include "get_bits.h" #include "get_bits.h"
@ -867,6 +867,7 @@ static av_cold int aac_decode_init(AVCodecContext *avctx)
ff_dsputil_init(&ac->dsp, avctx); ff_dsputil_init(&ac->dsp, avctx);
ff_fmt_convert_init(&ac->fmt_conv, avctx); ff_fmt_convert_init(&ac->fmt_conv, avctx);
avpriv_float_dsp_init(&ac->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
ac->random_state = 0x1f2e3d4c; ac->random_state = 0x1f2e3d4c;
@ -2032,10 +2033,10 @@ static void windowing_and_mdct_ltp(AACContext *ac, float *out,
const float *swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128; const float *swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
if (ics->window_sequence[0] != LONG_STOP_SEQUENCE) { if (ics->window_sequence[0] != LONG_STOP_SEQUENCE) {
ac->dsp.vector_fmul(in, in, lwindow_prev, 1024); ac->fdsp.vector_fmul(in, in, lwindow_prev, 1024);
} else { } else {
memset(in, 0, 448 * sizeof(float)); memset(in, 0, 448 * sizeof(float));
ac->dsp.vector_fmul(in + 448, in + 448, swindow_prev, 128); ac->fdsp.vector_fmul(in + 448, in + 448, swindow_prev, 128);
} }
if (ics->window_sequence[0] != LONG_START_SEQUENCE) { if (ics->window_sequence[0] != LONG_START_SEQUENCE) {
ac->dsp.vector_fmul_reverse(in + 1024, in + 1024, lwindow, 1024); ac->dsp.vector_fmul_reverse(in + 1024, in + 1024, lwindow, 1024);

20
libavcodec/aacenc.c
View File

@ -30,6 +30,7 @@
* add temporal noise shaping * add temporal noise shaping
***********************************/ ***********************************/
#include "libavutil/float_dsp.h"
#include "libavutil/opt.h" #include "libavutil/opt.h"
#include "avcodec.h" #include "avcodec.h"
#include "put_bits.h" #include "put_bits.h"
@ -182,7 +183,9 @@ static void put_audio_specific_config(AVCodecContext *avctx)
} }
#define WINDOW_FUNC(type) \ #define WINDOW_FUNC(type) \
static void apply_ ##type ##_window(DSPContext *dsp, SingleChannelElement *sce, const float *audio) static void apply_ ##type ##_window(DSPContext *dsp, AVFloatDSPContext *fdsp, \
SingleChannelElement *sce, \
const float *audio)
WINDOW_FUNC(only_long) WINDOW_FUNC(only_long)
{ {
@ -190,7 +193,7 @@ WINDOW_FUNC(only_long)
const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024; const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
float *out = sce->ret; float *out = sce->ret;
dsp->vector_fmul (out, audio, lwindow, 1024); fdsp->vector_fmul (out, audio, lwindow, 1024);
dsp->vector_fmul_reverse(out + 1024, audio + 1024, pwindow, 1024); dsp->vector_fmul_reverse(out + 1024, audio + 1024, pwindow, 1024);
} }
@ -200,7 +203,7 @@ WINDOW_FUNC(long_start)
const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128; const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
float *out = sce->ret; float *out = sce->ret;
dsp->vector_fmul(out, audio, lwindow, 1024); fdsp->vector_fmul(out, audio, lwindow, 1024);
memcpy(out + 1024, audio + 1024, sizeof(out[0]) * 448); memcpy(out + 1024, audio + 1024, sizeof(out[0]) * 448);
dsp->vector_fmul_reverse(out + 1024 + 448, audio + 1024 + 448, swindow, 128); dsp->vector_fmul_reverse(out + 1024 + 448, audio + 1024 + 448, swindow, 128);
memset(out + 1024 + 576, 0, sizeof(out[0]) * 448); memset(out + 1024 + 576, 0, sizeof(out[0]) * 448);
@ -213,7 +216,7 @@ WINDOW_FUNC(long_stop)
float *out = sce->ret; float *out = sce->ret;
memset(out, 0, sizeof(out[0]) * 448); memset(out, 0, sizeof(out[0]) * 448);
dsp->vector_fmul(out + 448, audio + 448, swindow, 128); fdsp->vector_fmul(out + 448, audio + 448, swindow, 128);
memcpy(out + 576, audio + 576, sizeof(out[0]) * 448); memcpy(out + 576, audio + 576, sizeof(out[0]) * 448);
dsp->vector_fmul_reverse(out + 1024, audio + 1024, lwindow, 1024); dsp->vector_fmul_reverse(out + 1024, audio + 1024, lwindow, 1024);
} }
@ -227,7 +230,7 @@ WINDOW_FUNC(eight_short)
int w; int w;
for (w = 0; w < 8; w++) { for (w = 0; w < 8; w++) {
dsp->vector_fmul (out, in, w ? pwindow : swindow, 128); fdsp->vector_fmul (out, in, w ? pwindow : swindow, 128);
out += 128; out += 128;
in += 128; in += 128;
dsp->vector_fmul_reverse(out, in, swindow, 128); dsp->vector_fmul_reverse(out, in, swindow, 128);
@ -235,7 +238,9 @@ WINDOW_FUNC(eight_short)
} }
} }
static void (*const apply_window[4])(DSPContext *dsp, SingleChannelElement *sce, const float *audio) = { static void (*const apply_window[4])(DSPContext *dsp, AVFloatDSPContext *fdsp,
SingleChannelElement *sce,
const float *audio) = {
[ONLY_LONG_SEQUENCE] = apply_only_long_window, [ONLY_LONG_SEQUENCE] = apply_only_long_window,
[LONG_START_SEQUENCE] = apply_long_start_window, [LONG_START_SEQUENCE] = apply_long_start_window,
[EIGHT_SHORT_SEQUENCE] = apply_eight_short_window, [EIGHT_SHORT_SEQUENCE] = apply_eight_short_window,
@ -248,7 +253,7 @@ static void apply_window_and_mdct(AACEncContext *s, SingleChannelElement *sce,
int i; int i;
float *output = sce->ret; float *output = sce->ret;
apply_window[sce->ics.window_sequence[0]](&s->dsp, sce, audio); apply_window[sce->ics.window_sequence[0]](&s->dsp, &s->fdsp, sce, audio);
if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE)
s->mdct1024.mdct_calc(&s->mdct1024, sce->coeffs, output); s->mdct1024.mdct_calc(&s->mdct1024, sce->coeffs, output);
@ -694,6 +699,7 @@ static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s)
int ret = 0; int ret = 0;
ff_dsputil_init(&s->dsp, avctx); ff_dsputil_init(&s->dsp, avctx);
avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
// window init // window init
ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024); ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);

2
libavcodec/aacenc.h
View File

@ -22,6 +22,7 @@
#ifndef AVCODEC_AACENC_H #ifndef AVCODEC_AACENC_H
#define AVCODEC_AACENC_H #define AVCODEC_AACENC_H
#include "libavutil/float_dsp.h"
#include "avcodec.h" #include "avcodec.h"
#include "put_bits.h" #include "put_bits.h"
#include "dsputil.h" #include "dsputil.h"
@ -58,6 +59,7 @@ typedef struct AACEncContext {
FFTContext mdct1024; ///< long (1024 samples) frame transform context FFTContext mdct1024; ///< long (1024 samples) frame transform context
FFTContext mdct128; ///< short (128 samples) frame transform context FFTContext mdct128; ///< short (128 samples) frame transform context
DSPContext dsp; DSPContext dsp;
AVFloatDSPContext fdsp;
float *planar_samples[6]; ///< saved preprocessed input float *planar_samples[6]; ///< saved preprocessed input
int samplerate_index; ///< MPEG-4 samplerate index int samplerate_index; ///< MPEG-4 samplerate index

1
libavcodec/ac3enc.c
View File

@ -2494,6 +2494,7 @@ av_cold int ff_ac3_encode_init(AVCodecContext *avctx)
#endif #endif
ff_dsputil_init(&s->dsp, avctx); ff_dsputil_init(&s->dsp, avctx);
avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT); ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
dprint_options(s); dprint_options(s);

3
libavcodec/ac3enc.h
View File

@ -29,6 +29,8 @@
#define AVCODEC_AC3ENC_H #define AVCODEC_AC3ENC_H
#include <stdint.h> #include <stdint.h>
#include "libavutil/float_dsp.h"
#include "ac3.h" #include "ac3.h"
#include "ac3dsp.h" #include "ac3dsp.h"
#include "avcodec.h" #include "avcodec.h"
@ -158,6 +160,7 @@ typedef struct AC3EncodeContext {
AVCodecContext *avctx; ///< parent AVCodecContext AVCodecContext *avctx; ///< parent AVCodecContext
PutBitContext pb; ///< bitstream writer context PutBitContext pb; ///< bitstream writer context
DSPContext dsp; DSPContext dsp;
AVFloatDSPContext fdsp;
AC3DSPContext ac3dsp; ///< AC-3 optimized functions AC3DSPContext ac3dsp; ///< AC-3 optimized functions
FFTContext mdct; ///< FFT context for MDCT calculation FFTContext mdct; ///< FFT context for MDCT calculation
const SampleType *mdct_window; ///< MDCT window function array const SampleType *mdct_window; ///< MDCT window function array

5
libavcodec/ac3enc_fixed.c
View File

@ -68,10 +68,11 @@ av_cold int AC3_NAME(mdct_init)(AC3EncodeContext *s)
/* /*
* Apply KBD window to input samples prior to MDCT. * Apply KBD window to input samples prior to MDCT.
*/ */
static void apply_window(DSPContext *dsp, int16_t *output, const int16_t *input, static void apply_window(void *dsp, int16_t *output, const int16_t *input,
const int16_t *window, unsigned int len) const int16_t *window, unsigned int len)
{ {
dsp->apply_window_int16(output, input, window, len); DSPContext *dsp0 = dsp;
dsp0->apply_window_int16(output, input, window, len);
} }

8
libavcodec/ac3enc_float.c
View File

@ -86,10 +86,12 @@ av_cold int ff_ac3_float_mdct_init(AC3EncodeContext *s)
/* /*
* Apply KBD window to input samples prior to MDCT. * Apply KBD window to input samples prior to MDCT.
*/ */
static void apply_window(DSPContext *dsp, float *output, const float *input, static void apply_window(void *dsp, float *output,
const float *window, unsigned int len) const float *input, const float *window,
unsigned int len)
{ {
dsp->vector_fmul(output, input, window, len); AVFloatDSPContext *fdsp = dsp;
fdsp->vector_fmul(output, input, window, len);
} }

7
libavcodec/ac3enc_template.c
View File

@ -33,7 +33,7 @@
static void scale_coefficients(AC3EncodeContext *s); static void scale_coefficients(AC3EncodeContext *s);
static void apply_window(DSPContext *dsp, SampleType *output, static void apply_window(void *dsp, SampleType *output,
const SampleType *input, const SampleType *window, const SampleType *input, const SampleType *window,
unsigned int len); unsigned int len);
@ -107,8 +107,13 @@ static void apply_mdct(AC3EncodeContext *s)
AC3Block *block = &s->blocks[blk]; AC3Block *block = &s->blocks[blk];
const SampleType *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE]; const SampleType *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE];
#if CONFIG_AC3ENC_FLOAT
apply_window(&s->fdsp, s->windowed_samples, input_samples,
s->mdct_window, AC3_WINDOW_SIZE);
#else
apply_window(&s->dsp, s->windowed_samples, input_samples, apply_window(&s->dsp, s->windowed_samples, input_samples,
s->mdct_window, AC3_WINDOW_SIZE); s->mdct_window, AC3_WINDOW_SIZE);
#endif
if (s->fixed_point) if (s->fixed_point)
block->coeff_shift[ch+1] = normalize_samples(s); block->coeff_shift[ch+1] = normalize_samples(s);

2
libavcodec/arm/dsputil_init_neon.c
View File

@ -150,7 +150,6 @@ void ff_avg_h264_chroma_mc2_neon(uint8_t *, uint8_t *, int, int, int, int);
void ff_vp3_v_loop_filter_neon(uint8_t *, int, int *); void ff_vp3_v_loop_filter_neon(uint8_t *, int, int *);
void ff_vp3_h_loop_filter_neon(uint8_t *, int, int *); void ff_vp3_h_loop_filter_neon(uint8_t *, int, int *);
void ff_vector_fmul_neon(float *dst, const float *src0, const float *src1, int len);
void ff_vector_fmul_window_neon(float *dst, const float *src0, void ff_vector_fmul_window_neon(float *dst, const float *src0,
const float *src1, const float *win, int len); const float *src1, const float *win, int len);
void ff_vector_fmul_scalar_neon(float *dst, const float *src, float mul, void ff_vector_fmul_scalar_neon(float *dst, const float *src, float mul,
@ -328,7 +327,6 @@ void ff_dsputil_init_neon(DSPContext *c, AVCodecContext *avctx)
c->vp3_idct_dc_add = ff_vp3_idct_dc_add_neon; c->vp3_idct_dc_add = ff_vp3_idct_dc_add_neon;
} }
c->vector_fmul = ff_vector_fmul_neon;
c->vector_fmul_window = ff_vector_fmul_window_neon; c->vector_fmul_window = ff_vector_fmul_window_neon;
c->vector_fmul_scalar = ff_vector_fmul_scalar_neon; c->vector_fmul_scalar = ff_vector_fmul_scalar_neon;
c->vector_fmac_scalar = ff_vector_fmac_scalar_neon; c->vector_fmac_scalar = ff_vector_fmac_scalar_neon;

7
libavcodec/arm/dsputil_init_vfp.c
View File

@ -18,20 +18,13 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include "libavutil/arm/cpu.h"
#include "libavcodec/dsputil.h" #include "libavcodec/dsputil.h"
#include "dsputil_arm.h" #include "dsputil_arm.h"
void ff_vector_fmul_vfp(float *dst, const float *src0,
const float *src1, int len);
void ff_vector_fmul_reverse_vfp(float *dst, const float *src0, void ff_vector_fmul_reverse_vfp(float *dst, const float *src0,
const float *src1, int len); const float *src1, int len);
void ff_dsputil_init_vfp(DSPContext* c, AVCodecContext *avctx) void ff_dsputil_init_vfp(DSPContext* c, AVCodecContext *avctx)
{ {
int cpu_flags = av_get_cpu_flags();
if (!have_vfpv3(cpu_flags))
c->vector_fmul = ff_vector_fmul_vfp;
c->vector_fmul_reverse = ff_vector_fmul_reverse_vfp; c->vector_fmul_reverse = ff_vector_fmul_reverse_vfp;
} }

39
libavcodec/arm/dsputil_neon.S
View File

@ -534,45 +534,6 @@ function ff_add_pixels_clamped_neon, export=1
bx lr bx lr
endfunc endfunc
function ff_vector_fmul_neon, export=1
subs r3, r3, #8
vld1.32 {d0-d3}, [r1,:128]!
vld1.32 {d4-d7}, [r2,:128]!
vmul.f32 q8, q0, q2
vmul.f32 q9, q1, q3
beq 3f
bics ip, r3, #15
beq 2f
1: subs ip, ip, #16
vld1.32 {d0-d1}, [r1,:128]!
vld1.32 {d4-d5}, [r2,:128]!
vmul.f32 q10, q0, q2
vld1.32 {d2-d3}, [r1,:128]!
vld1.32 {d6-d7}, [r2,:128]!
vmul.f32 q11, q1, q3
vst1.32 {d16-d19},[r0,:128]!
vld1.32 {d0-d1}, [r1,:128]!
vld1.32 {d4-d5}, [r2,:128]!
vmul.f32 q8, q0, q2
vld1.32 {d2-d3}, [r1,:128]!
vld1.32 {d6-d7}, [r2,:128]!
vmul.f32 q9, q1, q3
vst1.32 {d20-d23},[r0,:128]!
bne 1b
ands r3, r3, #15
beq 3f
2: vld1.32 {d0-d1}, [r1,:128]!
vld1.32 {d4-d5}, [r2,:128]!
vst1.32 {d16-d17},[r0,:128]!
vmul.f32 q8, q0, q2
vld1.32 {d2-d3}, [r1,:128]!
vld1.32 {d6-d7}, [r2,:128]!
vst1.32 {d18-d19},[r0,:128]!
vmul.f32 q9, q1, q3
3: vst1.32 {d16-d19},[r0,:128]!
bx lr
endfunc
function ff_vector_fmul_window_neon, export=1 function ff_vector_fmul_window_neon, export=1
push {r4,r5,lr} push {r4,r5,lr}
ldr lr, [sp, #12] ldr lr, [sp, #12]

47
libavcodec/arm/dsputil_vfp.S
View File

@ -36,53 +36,6 @@
* optimization manuals can be found at http://www.arm.com * optimization manuals can be found at http://www.arm.com
*/ */
/**
* ARM VFP optimized implementation of 'vector_fmul_c' function.
* Assume that len is a positive number and is multiple of 8
*/
@ void ff_vector_fmul_vfp(float *dst, const float *src0, const float *src1, int len)
function ff_vector_fmul_vfp, export=1
vpush {d8-d15}
fmrx r12, fpscr
orr r12, r12, #(3 << 16) /* set vector size to 4 */
fmxr fpscr, r12
vldmia r1!, {s0-s3}
vldmia r2!, {s8-s11}
vldmia r1!, {s4-s7}
vldmia r2!, {s12-s15}
vmul.f32 s8, s0, s8
1:
subs r3, r3, #16
vmul.f32 s12, s4, s12
itttt ge
vldmiage r1!, {s16-s19}
vldmiage r2!, {s24-s27}
vldmiage r1!, {s20-s23}
vldmiage r2!, {s28-s31}
it ge
vmulge.f32 s24, s16, s24
vstmia r0!, {s8-s11}
vstmia r0!, {s12-s15}
it ge
vmulge.f32 s28, s20, s28
itttt gt
vldmiagt r1!, {s0-s3}
vldmiagt r2!, {s8-s11}
vldmiagt r1!, {s4-s7}
vldmiagt r2!, {s12-s15}
ittt ge
vmulge.f32 s8, s0, s8
vstmiage r0!, {s24-s27}
vstmiage r0!, {s28-s31}
bgt 1b
bic r12, r12, #(7 << 16) /* set vector size back to 1 */
fmxr fpscr, r12
vpop {d8-d15}
bx lr
endfunc
/** /**
* ARM VFP optimized implementation of 'vector_fmul_reverse_c' function. * ARM VFP optimized implementation of 'vector_fmul_reverse_c' function.
* Assume that len is a positive number and is multiple of 8 * Assume that len is a positive number and is multiple of 8

8
libavcodec/atrac3.c
View File

@ -36,9 +36,9 @@
#include <stddef.h> #include <stddef.h>
#include <stdio.h> #include <stdio.h>
#include "libavutil/float_dsp.h"
#include "avcodec.h" #include "avcodec.h"
#include "get_bits.h" #include "get_bits.h"
#include "dsputil.h"
#include "bytestream.h" #include "bytestream.h"
#include "fft.h" #include "fft.h"
#include "fmtconvert.h" #include "fmtconvert.h"
@ -125,13 +125,13 @@ typedef struct {
FFTContext mdct_ctx; FFTContext mdct_ctx;
FmtConvertContext fmt_conv; FmtConvertContext fmt_conv;
AVFloatDSPContext fdsp;
} ATRAC3Context; } ATRAC3Context;
static DECLARE_ALIGNED(32, float, mdct_window)[MDCT_SIZE]; static DECLARE_ALIGNED(32, float, mdct_window)[MDCT_SIZE];
static VLC spectral_coeff_tab[7]; static VLC spectral_coeff_tab[7];
static float gain_tab1[16]; static float gain_tab1[16];
static float gain_tab2[31]; static float gain_tab2[31];
static DSPContext dsp;
/** /**
@ -164,7 +164,7 @@ static void IMLT(ATRAC3Context *q, float *pInput, float *pOutput, int odd_band)
q->mdct_ctx.imdct_calc(&q->mdct_ctx,pOutput,pInput); q->mdct_ctx.imdct_calc(&q->mdct_ctx,pOutput,pInput);
/* Perform windowing on the output. */ /* Perform windowing on the output. */
dsp.vector_fmul(pOutput, pOutput, mdct_window, MDCT_SIZE); q->fdsp.vector_fmul(pOutput, pOutput, mdct_window, MDCT_SIZE);
} }
@ -1039,7 +1039,7 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)
q->matrix_coeff_index_next[i] = 3; q->matrix_coeff_index_next[i] = 3;
} }
ff_dsputil_init(&dsp, avctx); avpriv_float_dsp_init(&q->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
ff_fmt_convert_init(&q->fmt_conv, avctx); ff_fmt_convert_init(&q->fmt_conv, avctx);
q->pUnits = av_mallocz(sizeof(channel_unit)*q->channels); q->pUnits = av_mallocz(sizeof(channel_unit)*q->channels);

7
libavcodec/dsputil.c
View File

@ -2363,12 +2363,6 @@ WRAPPER8_16_SQ(quant_psnr8x8_c, quant_psnr16_c)
WRAPPER8_16_SQ(rd8x8_c, rd16_c) WRAPPER8_16_SQ(rd8x8_c, rd16_c)
WRAPPER8_16_SQ(bit8x8_c, bit16_c) WRAPPER8_16_SQ(bit8x8_c, bit16_c)
static void vector_fmul_c(float *dst, const float *src0, const float *src1, int len){
int i;
for(i=0; i<len; i++)
dst[i] = src0[i] * src1[i];
}
static void vector_fmul_reverse_c(float *dst, const float *src0, const float *src1, int len){ static void vector_fmul_reverse_c(float *dst, const float *src0, const float *src1, int len){
int i; int i;
src1 += len-1; src1 += len-1;
@ -2898,7 +2892,6 @@ av_cold void ff_dsputil_init(DSPContext* c, AVCodecContext *avctx)
#if CONFIG_AC3_DECODER #if CONFIG_AC3_DECODER
c->ac3_downmix = ff_ac3_downmix_c; c->ac3_downmix = ff_ac3_downmix_c;
#endif #endif
c->vector_fmul = vector_fmul_c;
c->vector_fmul_reverse = vector_fmul_reverse_c; c->vector_fmul_reverse = vector_fmul_reverse_c;
c->vector_fmul_add = vector_fmul_add_c; c->vector_fmul_add = vector_fmul_add_c;
c->vector_fmul_window = vector_fmul_window_c; c->vector_fmul_window = vector_fmul_window_c;

1
libavcodec/dsputil.h
View File

@ -399,7 +399,6 @@ typedef struct DSPContext {
void (*vorbis_inverse_coupling)(float *mag, float *ang, int blocksize); 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); 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 */ /* assume len is a multiple of 16, and arrays are 32-byte aligned */
void (*vector_fmul)(float *dst, const float *src0, const float *src1, int len);
void (*vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len); 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 */ /* 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); void (*vector_fmul_add)(float *dst, const float *src0, const float *src1, const float *src2, int len);

7
libavcodec/nellymoserenc.c
View File

@ -35,6 +35,7 @@
* http://wiki.multimedia.cx/index.php?title=Nellymoser * http://wiki.multimedia.cx/index.php?title=Nellymoser
*/ */
#include "libavutil/float_dsp.h"
#include "libavutil/mathematics.h" #include "libavutil/mathematics.h"
#include "nellymoser.h" #include "nellymoser.h"
#include "avcodec.h" #include "avcodec.h"
@ -55,6 +56,7 @@ typedef struct NellyMoserEncodeContext {
AVCodecContext *avctx; AVCodecContext *avctx;
int last_frame; int last_frame;
DSPContext dsp; DSPContext dsp;
AVFloatDSPContext fdsp;
FFTContext mdct_ctx; FFTContext mdct_ctx;
AudioFrameQueue afq; AudioFrameQueue afq;
DECLARE_ALIGNED(32, float, mdct_out)[NELLY_SAMPLES]; DECLARE_ALIGNED(32, float, mdct_out)[NELLY_SAMPLES];
@ -120,11 +122,11 @@ static void apply_mdct(NellyMoserEncodeContext *s)
float *in1 = s->buf + NELLY_BUF_LEN; float *in1 = s->buf + NELLY_BUF_LEN;
float *in2 = s->buf + 2 * NELLY_BUF_LEN; float *in2 = s->buf + 2 * NELLY_BUF_LEN;
s->dsp.vector_fmul (s->in_buff, in0, ff_sine_128, NELLY_BUF_LEN); s->fdsp.vector_fmul (s->in_buff, in0, ff_sine_128, NELLY_BUF_LEN);
s->dsp.vector_fmul_reverse(s->in_buff + NELLY_BUF_LEN, in1, ff_sine_128, NELLY_BUF_LEN); s->dsp.vector_fmul_reverse(s->in_buff + NELLY_BUF_LEN, in1, ff_sine_128, NELLY_BUF_LEN);
s->mdct_ctx.mdct_calc(&s->mdct_ctx, s->mdct_out, s->in_buff); s->mdct_ctx.mdct_calc(&s->mdct_ctx, s->mdct_out, s->in_buff);
s->dsp.vector_fmul (s->in_buff, in1, ff_sine_128, NELLY_BUF_LEN); s->fdsp.vector_fmul (s->in_buff, in1, ff_sine_128, NELLY_BUF_LEN);
s->dsp.vector_fmul_reverse(s->in_buff + NELLY_BUF_LEN, in2, ff_sine_128, NELLY_BUF_LEN); s->dsp.vector_fmul_reverse(s->in_buff + NELLY_BUF_LEN, in2, ff_sine_128, NELLY_BUF_LEN);
s->mdct_ctx.mdct_calc(&s->mdct_ctx, s->mdct_out + NELLY_BUF_LEN, s->in_buff); s->mdct_ctx.mdct_calc(&s->mdct_ctx, s->mdct_out + NELLY_BUF_LEN, s->in_buff);
} }
@ -172,6 +174,7 @@ static av_cold int encode_init(AVCodecContext *avctx)
if ((ret = ff_mdct_init(&s->mdct_ctx, 8, 0, 32768.0)) < 0) if ((ret = ff_mdct_init(&s->mdct_ctx, 8, 0, 32768.0)) < 0)
goto error; goto error;
ff_dsputil_init(&s->dsp, avctx); ff_dsputil_init(&s->dsp, avctx);
avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
/* Generate overlap window */ /* Generate overlap window */
ff_sine_window_init(ff_sine_128, 128); ff_sine_window_init(ff_sine_128, 128);

16
libavcodec/ppc/float_altivec.c
View File

@ -23,21 +23,6 @@
#include "dsputil_altivec.h" #include "dsputil_altivec.h"
static void vector_fmul_altivec(float *dst, const float *src0, const float *src1, int len)
{
int i;
vector float d0, d1, s, zero = (vector float)vec_splat_u32(0);
for(i=0; i<len-7; i+=8) {
d0 = vec_ld(0, src0+i);
s = vec_ld(0, src1+i);
d1 = vec_ld(16, src0+i);
d0 = vec_madd(d0, s, zero);
d1 = vec_madd(d1, vec_ld(16,src1+i), zero);
vec_st(d0, 0, dst+i);
vec_st(d1, 16, dst+i);
}
}
static void vector_fmul_reverse_altivec(float *dst, const float *src0, static void vector_fmul_reverse_altivec(float *dst, const float *src0,
const float *src1, int len) const float *src1, int len)
{ {
@ -124,7 +109,6 @@ static void vector_fmul_window_altivec(float *dst, const float *src0, const floa
void ff_float_init_altivec(DSPContext* c, AVCodecContext *avctx) void ff_float_init_altivec(DSPContext* c, AVCodecContext *avctx)
{ {
c->vector_fmul = vector_fmul_altivec;
c->vector_fmul_reverse = vector_fmul_reverse_altivec; c->vector_fmul_reverse = vector_fmul_reverse_altivec;
c->vector_fmul_add = vector_fmul_add_altivec; c->vector_fmul_add = vector_fmul_add_altivec;
if(!(avctx->flags & CODEC_FLAG_BITEXACT)) { if(!(avctx->flags & CODEC_FLAG_BITEXACT)) {

9
libavcodec/ra288.c
View File

@ -19,6 +19,7 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include "libavutil/float_dsp.h"
#include "avcodec.h" #include "avcodec.h"
#define BITSTREAM_READER_LE #define BITSTREAM_READER_LE
#include "get_bits.h" #include "get_bits.h"
@ -26,7 +27,6 @@
#include "lpc.h" #include "lpc.h"
#include "celp_math.h" #include "celp_math.h"
#include "celp_filters.h" #include "celp_filters.h"
#include "dsputil.h"
#define MAX_BACKWARD_FILTER_ORDER 36 #define MAX_BACKWARD_FILTER_ORDER 36
#define MAX_BACKWARD_FILTER_LEN 40 #define MAX_BACKWARD_FILTER_LEN 40
@ -38,6 +38,7 @@
typedef struct { typedef struct {
AVFrame frame; AVFrame frame;
DSPContext dsp; DSPContext dsp;
AVFloatDSPContext fdsp;
DECLARE_ALIGNED(32, float, sp_lpc)[FFALIGN(36, 16)]; ///< LPC coefficients for speech data (spec: A) DECLARE_ALIGNED(32, float, sp_lpc)[FFALIGN(36, 16)]; ///< LPC coefficients for speech data (spec: A)
DECLARE_ALIGNED(32, float, gain_lpc)[FFALIGN(10, 16)]; ///< LPC coefficients for gain (spec: GB) DECLARE_ALIGNED(32, float, gain_lpc)[FFALIGN(10, 16)]; ///< LPC coefficients for gain (spec: GB)
@ -62,7 +63,7 @@ static av_cold int ra288_decode_init(AVCodecContext *avctx)
{ {
RA288Context *ractx = avctx->priv_data; RA288Context *ractx = avctx->priv_data;
avctx->sample_fmt = AV_SAMPLE_FMT_FLT; avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
ff_dsputil_init(&ractx->dsp, avctx); avpriv_float_dsp_init(&ractx->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
avcodec_get_frame_defaults(&ractx->frame); avcodec_get_frame_defaults(&ractx->frame);
avctx->coded_frame = &ractx->frame; avctx->coded_frame = &ractx->frame;
@ -137,7 +138,7 @@ static void do_hybrid_window(RA288Context *ractx,
MAX_BACKWARD_FILTER_LEN + MAX_BACKWARD_FILTER_LEN +
MAX_BACKWARD_FILTER_NONREC, 16)]); MAX_BACKWARD_FILTER_NONREC, 16)]);
ractx->dsp.vector_fmul(work, window, hist, FFALIGN(order + n + non_rec, 16)); ractx->fdsp.vector_fmul(work, window, hist, FFALIGN(order + n + non_rec, 16));
convolve(buffer1, work + order , n , order); convolve(buffer1, work + order , n , order);
convolve(buffer2, work + order + n, non_rec, order); convolve(buffer2, work + order + n, non_rec, order);
@ -164,7 +165,7 @@ static void backward_filter(RA288Context *ractx,
do_hybrid_window(ractx, order, n, non_rec, temp, hist, rec, window); do_hybrid_window(ractx, order, n, non_rec, temp, hist, rec, window);
if (!compute_lpc_coefs(temp, order, lpc, 0, 1, 1)) if (!compute_lpc_coefs(temp, order, lpc, 0, 1, 1))
ractx->dsp.vector_fmul(lpc, lpc, tab, FFALIGN(order, 16)); ractx->fdsp.vector_fmul(lpc, lpc, tab, FFALIGN(order, 16));
memmove(hist, hist + n, move_size*sizeof(*hist)); memmove(hist, hist + n, move_size*sizeof(*hist));
} }

9
libavcodec/twinvq.c
View File

@ -19,6 +19,7 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include "libavutil/float_dsp.h"
#include "avcodec.h" #include "avcodec.h"
#include "get_bits.h" #include "get_bits.h"
#include "dsputil.h" #include "dsputil.h"
@ -176,6 +177,7 @@ typedef struct TwinContext {
AVCodecContext *avctx; AVCodecContext *avctx;
AVFrame frame; AVFrame frame;
DSPContext dsp; DSPContext dsp;
AVFloatDSPContext fdsp;
FFTContext mdct_ctx[3]; FFTContext mdct_ctx[3];
const ModeTab *mtab; const ModeTab *mtab;
@ -787,8 +789,8 @@ static void read_and_decode_spectrum(TwinContext *tctx, GetBitContext *gb,
dec_bark_env(tctx, bark1[i][j], bark_use_hist[i][j], i, dec_bark_env(tctx, bark1[i][j], bark_use_hist[i][j], i,
tctx->tmp_buf, gain[sub*i+j], ftype); tctx->tmp_buf, gain[sub*i+j], ftype);
tctx->dsp.vector_fmul(chunk + block_size*j, chunk + block_size*j, tctx->tmp_buf, tctx->fdsp.vector_fmul(chunk + block_size*j, chunk + block_size*j,
block_size); tctx->tmp_buf, block_size);
} }
@ -809,7 +811,7 @@ static void read_and_decode_spectrum(TwinContext *tctx, GetBitContext *gb,
dec_lpc_spectrum_inv(tctx, lsp, ftype, tctx->tmp_buf); dec_lpc_spectrum_inv(tctx, lsp, ftype, tctx->tmp_buf);
for (j = 0; j < mtab->fmode[ftype].sub; j++) { for (j = 0; j < mtab->fmode[ftype].sub; j++) {
tctx->dsp.vector_fmul(chunk, chunk, tctx->tmp_buf, block_size); tctx->fdsp.vector_fmul(chunk, chunk, tctx->tmp_buf, block_size);
chunk += block_size; chunk += block_size;
} }
} }
@ -1156,6 +1158,7 @@ static av_cold int twin_decode_init(AVCodecContext *avctx)
} }
ff_dsputil_init(&tctx->dsp, avctx); ff_dsputil_init(&tctx->dsp, avctx);
avpriv_float_dsp_init(&tctx->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
if ((ret = init_mdct_win(tctx))) { if ((ret = init_mdct_win(tctx))) {
av_log(avctx, AV_LOG_ERROR, "Error initializing MDCT\n"); av_log(avctx, AV_LOG_ERROR, "Error initializing MDCT\n");
twin_decode_close(avctx); twin_decode_close(avctx);

5
libavcodec/vorbisdec.c
View File

@ -26,6 +26,7 @@
#include <math.h> #include <math.h>
#define BITSTREAM_READER_LE #define BITSTREAM_READER_LE
#include "libavutil/float_dsp.h"
#include "avcodec.h" #include "avcodec.h"
#include "get_bits.h" #include "get_bits.h"
#include "dsputil.h" #include "dsputil.h"
@ -124,6 +125,7 @@ typedef struct vorbis_context_s {
AVFrame frame; AVFrame frame;
GetBitContext gb; GetBitContext gb;
DSPContext dsp; DSPContext dsp;
AVFloatDSPContext fdsp;
FmtConvertContext fmt_conv; FmtConvertContext fmt_conv;
FFTContext mdct[2]; FFTContext mdct[2];
@ -983,6 +985,7 @@ static av_cold int vorbis_decode_init(AVCodecContext *avccontext)
vc->avccontext = avccontext; vc->avccontext = avccontext;
ff_dsputil_init(&vc->dsp, avccontext); ff_dsputil_init(&vc->dsp, avccontext);
avpriv_float_dsp_init(&vc->fdsp, avccontext->flags & CODEC_FLAG_BITEXACT);
ff_fmt_convert_init(&vc->fmt_conv, avccontext); ff_fmt_convert_init(&vc->fmt_conv, avccontext);
if (avccontext->request_sample_fmt == AV_SAMPLE_FMT_FLT) { if (avccontext->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
@ -1605,7 +1608,7 @@ static int vorbis_parse_audio_packet(vorbis_context *vc)
for (j = vc->audio_channels-1;j >= 0; j--) { for (j = vc->audio_channels-1;j >= 0; j--) {
ch_floor_ptr = vc->channel_floors + j * blocksize / 2; ch_floor_ptr = vc->channel_floors + j * blocksize / 2;
ch_res_ptr = vc->channel_residues + res_chan[j] * blocksize / 2; ch_res_ptr = vc->channel_residues + res_chan[j] * blocksize / 2;
vc->dsp.vector_fmul(ch_floor_ptr, ch_floor_ptr, ch_res_ptr, blocksize / 2); vc->fdsp.vector_fmul(ch_floor_ptr, ch_floor_ptr, ch_res_ptr, blocksize / 2);
mdct->imdct_half(mdct, ch_res_ptr, ch_floor_ptr); mdct->imdct_half(mdct, ch_res_ptr, ch_floor_ptr);
} }

7
libavcodec/x86/dsputil_mmx.c
View File

@ -2502,11 +2502,6 @@ int ff_add_hfyu_left_prediction_sse4(uint8_t *dst, const uint8_t *src,
float ff_scalarproduct_float_sse(const float *v1, const float *v2, int order); float ff_scalarproduct_float_sse(const float *v1, const float *v2, int order);
void ff_vector_fmul_sse(float *dst, const float *src0, const float *src1,
int len);
void ff_vector_fmul_avx(float *dst, const float *src0, const float *src1,
int len);
void ff_vector_fmul_reverse_sse(float *dst, const float *src0, void ff_vector_fmul_reverse_sse(float *dst, const float *src0,
const float *src1, int len); const float *src1, int len);
void ff_vector_fmul_reverse_avx(float *dst, const float *src0, void ff_vector_fmul_reverse_avx(float *dst, const float *src0,
@ -2833,7 +2828,6 @@ static void dsputil_init_sse(DSPContext *c, AVCodecContext *avctx, int mm_flags)
c->vorbis_inverse_coupling = vorbis_inverse_coupling_sse; c->vorbis_inverse_coupling = vorbis_inverse_coupling_sse;
c->ac3_downmix = ac3_downmix_sse; c->ac3_downmix = ac3_downmix_sse;
#if HAVE_YASM #if HAVE_YASM
c->vector_fmul = ff_vector_fmul_sse;
c->vector_fmul_reverse = ff_vector_fmul_reverse_sse; c->vector_fmul_reverse = ff_vector_fmul_reverse_sse;
c->vector_fmul_add = ff_vector_fmul_add_sse; c->vector_fmul_add = ff_vector_fmul_add_sse;
#endif #endif
@ -2995,7 +2989,6 @@ static void dsputil_init_avx(DSPContext *c, AVCodecContext *avctx, int mm_flags)
} }
} }
c->butterflies_float_interleave = ff_butterflies_float_interleave_avx; c->butterflies_float_interleave = ff_butterflies_float_interleave_avx;
c->vector_fmul = ff_vector_fmul_avx;
c->vector_fmul_reverse = ff_vector_fmul_reverse_avx; c->vector_fmul_reverse = ff_vector_fmul_reverse_avx;
c->vector_fmul_add = ff_vector_fmul_add_avx; c->vector_fmul_add = ff_vector_fmul_add_avx;
#endif #endif

32
libavcodec/x86/dsputil_yasm.asm
View File

@ -1129,38 +1129,6 @@ VECTOR_CLIP_INT32 11, 1, 1, 0
VECTOR_CLIP_INT32 6, 1, 0, 0 VECTOR_CLIP_INT32 6, 1, 0, 0
%endif %endif
;-----------------------------------------------------------------------------
; void vector_fmul(float *dst, const float *src0, const float *src1, int len)
;-----------------------------------------------------------------------------
%macro VECTOR_FMUL 0
cglobal vector_fmul, 4,4,2, dst, src0, src1, len
lea lenq, [lend*4 - 2*mmsize]
ALIGN 16
.loop
mova m0, [src0q + lenq]
mova m1, [src0q + lenq + mmsize]
mulps m0, m0, [src1q + lenq]
mulps m1, m1, [src1q + lenq + mmsize]
mova [dstq + lenq], m0
mova [dstq + lenq + mmsize], m1
sub lenq, 2*mmsize
jge .loop
%if mmsize == 32
vzeroupper
RET
%else
REP_RET
%endif
%endmacro
INIT_XMM sse
VECTOR_FMUL
%if HAVE_AVX
INIT_YMM avx
VECTOR_FMUL
%endif
;----------------------------------------------------------------------------- ;-----------------------------------------------------------------------------
; void vector_fmul_reverse(float *dst, const float *src0, const float *src1, ; void vector_fmul_reverse(float *dst, const float *src0, const float *src1,
; int len) ; int len)

1
libavutil/Makefile
View File

@ -57,6 +57,7 @@ OBJS = adler32.o \
eval.o \ eval.o \
fifo.o \ fifo.o \
file.o \ file.o \
float_dsp.o \
imgutils.o \ imgutils.o \
intfloat_readwrite.o \ intfloat_readwrite.o \
inverse.o \ inverse.o \

7
libavutil/arm/Makefile
View File

@ -1 +1,8 @@
OBJS += arm/cpu.o \ OBJS += arm/cpu.o \
arm/float_dsp_init_arm.o \
ARMVFP-OBJS += arm/float_dsp_init_vfp.o \
arm/float_dsp_vfp.o \
NEON-OBJS += arm/float_dsp_init_neon.o \
arm/float_dsp_neon.o \

29
libavutil/arm/float_dsp_arm.h Normal file
View File

@ -0,0 +1,29 @@
/*
* Copyright (c) 2009 Mans Rullgard <mans@mansr.com>
*
* 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
*/
#ifndef AVUTIL_ARM_FLOAT_DSP_ARM_H
#define AVUTIL_ARM_FLOAT_DSP_ARM_H
#include "libavutil/float_dsp.h"
void ff_dsputil_init_vfp (AVFloatDSPContext *fdsp);
void ff_dsputil_init_neon(AVFloatDSPContext *fdsp);
#endif /* AVUTIL_ARM_FLOAT_DSP_ARM_H */

33
libavutil/arm/float_dsp_init_arm.c Normal file
View File

@ -0,0 +1,33 @@
/*
* ARM optimized DSP utils
*
* 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
*/
#include "libavutil/arm/cpu.h"
#include "libavutil/float_dsp.h"
#include "float_dsp_arm.h"
void ff_float_dsp_init_arm(AVFloatDSPContext *fdsp)
{
int cpu_flags = av_get_cpu_flags();
if (have_vfp(cpu_flags))
ff_dsputil_init_vfp(fdsp);
if (have_neon(cpu_flags))
ff_dsputil_init_neon(fdsp);
}

32
libavutil/arm/float_dsp_init_neon.c Normal file
View File

@ -0,0 +1,32 @@
/*
* ARM NEON optimised Float DSP functions
* Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
*
* 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
*/
#include <stdint.h>
#include "libavutil/float_dsp.h"
#include "float_dsp_arm.h"
void ff_vector_fmul_neon(float *dst, const float *src0, const float *src1, int len);
void ff_dsputil_init_neon(AVFloatDSPContext *fdsp)
{
c->vector_fmul = ff_vector_fmul_neon;
}

34
libavutil/arm/float_dsp_init_vfp.c Normal file
View File

@ -0,0 +1,34 @@
/*
* Copyright (c) 2008 Siarhei Siamashka <ssvb@users.sourceforge.net>
*
* 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
*/
#include "libavutil/arm/cpu.h"
#include "libavutil/float_dsp.h"
#include "float_dsp_arm.h"
void ff_vector_fmul_vfp(float *dst, const float *src0, const float *src1,
int len);
void ff_dsputil_init_vfp(DSPContext* c, AVCodecContext *avctx)
{
int cpu_flags = av_get_cpu_flags();
if (!have_vfpv3(cpu_flags))
c->vector_fmul = ff_vector_fmul_vfp;
}

64
libavutil/arm/float_dsp_neon.S Normal file
View File

@ -0,0 +1,64 @@
/*
* ARM NEON optimised Float DSP functions
* Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
*
* 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
*/
#include "config.h"
#include "asm.S"
preserve8
function ff_vector_fmul_neon, export=1
subs r3, r3, #8
vld1.32 {d0-d3}, [r1,:128]!
vld1.32 {d4-d7}, [r2,:128]!
vmul.f32 q8, q0, q2
vmul.f32 q9, q1, q3
beq 3f
bics ip, r3, #15
beq 2f
1: subs ip, ip, #16
vld1.32 {d0-d1}, [r1,:128]!
vld1.32 {d4-d5}, [r2,:128]!
vmul.f32 q10, q0, q2
vld1.32 {d2-d3}, [r1,:128]!
vld1.32 {d6-d7}, [r2,:128]!
vmul.f32 q11, q1, q3
vst1.32 {d16-d19},[r0,:128]!
vld1.32 {d0-d1}, [r1,:128]!
vld1.32 {d4-d5}, [r2,:128]!
vmul.f32 q8, q0, q2
vld1.32 {d2-d3}, [r1,:128]!
vld1.32 {d6-d7}, [r2,:128]!
vmul.f32 q9, q1, q3
vst1.32 {d20-d23},[r0,:128]!
bne 1b
ands r3, r3, #15
beq 3f
2: vld1.32 {d0-d1}, [r1,:128]!
vld1.32 {d4-d5}, [r2,:128]!
vst1.32 {d16-d17},[r0,:128]!
vmul.f32 q8, q0, q2
vld1.32 {d2-d3}, [r1,:128]!
vld1.32 {d6-d7}, [r2,:128]!
vst1.32 {d18-d19},[r0,:128]!
vmul.f32 q9, q1, q3
3: vst1.32 {d16-d19},[r0,:128]!
bx lr
endfunc

68
libavutil/arm/float_dsp_vfp.S Normal file
View File

@ -0,0 +1,68 @@
/*
* Copyright (c) 2008 Siarhei Siamashka <ssvb@users.sourceforge.net>
*
* 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
*/
#include "config.h"
#include "asm.S"
/**
* Assume that len is a positive number and is multiple of 8
*/
@ void ff_vector_fmul_vfp(float *dst, const float *src0, const float *src1, int len)
function ff_vector_fmul_vfp, export=1
vpush {d8-d15}
fmrx r12, fpscr
orr r12, r12, #(3 << 16) /* set vector size to 4 */
fmxr fpscr, r12
vldmia r1!, {s0-s3}
vldmia r2!, {s8-s11}
vldmia r1!, {s4-s7}
vldmia r2!, {s12-s15}
vmul.f32 s8, s0, s8
1:
subs r3, r3, #16
vmul.f32 s12, s4, s12
itttt ge
vldmiage r1!, {s16-s19}
vldmiage r2!, {s24-s27}
vldmiage r1!, {s20-s23}
vldmiage r2!, {s28-s31}
it ge
vmulge.f32 s24, s16, s24
vstmia r0!, {s8-s11}
vstmia r0!, {s12-s15}
it ge
vmulge.f32 s28, s20, s28
itttt gt
vldmiagt r1!, {s0-s3}
vldmiagt r2!, {s8-s11}
vldmiagt r1!, {s4-s7}
vldmiagt r2!, {s12-s15}
ittt ge
vmulge.f32 s8, s0, s8
vstmiage r0!, {s24-s27}
vstmiage r0!, {s28-s31}
bgt 1b
bic r12, r12, #(7 << 16) /* set vector size back to 1 */
fmxr fpscr, r12
vpop {d8-d15}
bx lr
endfunc

42
libavutil/float_dsp.c Normal file
View File

@ -0,0 +1,42 @@
/*
* 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
*/
#include "config.h"
#include "float_dsp.h"
static void vector_fmul_c(float *dst, const float *src0, const float *src1,
int len)
{
int i;
for (i = 0; i < len; i++)
dst[i] = src0[i] * src1[i];
}
void avpriv_float_dsp_init(AVFloatDSPContext *fdsp, int bit_exact)
{
fdsp->vector_fmul = vector_fmul_c;
#if ARCH_ARM
ff_float_dsp_init_arm(fdsp);
#elif ARCH_PPC
ff_float_dsp_init_ppc(fdsp, bit_exact);
#elif ARCH_X86
ff_float_dsp_init_x86(fdsp);
#endif
}

53
libavutil/float_dsp.h Normal file
View File

@ -0,0 +1,53 @@
/*
* 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
*/
#ifndef AVUTIL_FLOAT_DSP_H
#define AVUTIL_FLOAT_DSP_H
typedef struct AVFloatDSPContext {
/**
* Calculate the product of two vectors of floats and store the result in
* a vector of floats.
*
* @param dst output vector
* constraints: 32-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 16
*/
void (*vector_fmul)(float *dst, const float *src0, const float *src1,
int len);
} AVFloatDSPContext;
/**
* Initialize a float DSP context.
*
* @param fdsp float DSP context
* @param strict setting to non-zero avoids using functions which may not be IEEE-754 compliant
*/
void avpriv_float_dsp_init(AVFloatDSPContext *fdsp, int strict);
void ff_float_dsp_init_arm(AVFloatDSPContext *fdsp);
void ff_float_dsp_init_ppc(AVFloatDSPContext *fdsp, int strict);
void ff_float_dsp_init_x86(AVFloatDSPContext *fdsp);
#endif /* AVUTIL_FLOAT_DSP_H */

3
libavutil/ppc/Makefile
View File

@ -1 +1,4 @@
OBJS += ppc/cpu.o \ OBJS += ppc/cpu.o \
ppc/float_dsp_init.o \
ALTIVEC-OBJS += ppc/float_dsp_altivec.o \

37
libavutil/ppc/float_dsp_altivec.c Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (c) 2006 Luca Barbato <lu_zero@gentoo.org>
*
* 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
*/
#include "util_altivec.h"
void ff_vector_fmul_altivec(float *dst, const float *src0, const float *src1,
int len)
{
int i;
vector float d0, d1, s, zero = (vector float)vec_splat_u32(0);
for (i = 0; i < len - 7; i += 8) {
d0 = vec_ld( 0, src0 + i);
s = vec_ld( 0, src1 + i);
d1 = vec_ld(16, src0 + i);
d0 = vec_madd(d0, s, zero);
d1 = vec_madd(d1, vec_ld(16, src1 + i), zero);
vec_st(d0, 0, dst + i);
vec_st(d1, 16, dst + i);
}
}

37
libavutil/ppc/float_dsp_init.c Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (c) 2006 Luca Barbato <lu_zero@gentoo.org>
*
* 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
*/
#include "libavutil/cpu.h"
#include "libavutil/float_dsp.h"
extern void ff_vector_fmul_altivec(float *dst, const float *src0,
const float *src1, int len);
void ff_float_dsp_init_ppc(AVFloatDSPContext *fdsp, int bit_exact)
{
#if HAVE_ALTIVEC
int mm_flags = av_get_cpu_flags();
if (!(mm_flags & AV_CPU_FLAG_ALTIVEC))
return;
fdsp->vector_fmul = ff_vector_fmul_altivec;
#endif
}

3
libavutil/x86/Makefile
View File

@ -1 +1,4 @@
OBJS += x86/cpu.o \ OBJS += x86/cpu.o \
x86/float_dsp_init.o \
YASM-OBJS += x86/float_dsp.o \

55
libavutil/x86/float_dsp.asm Normal file
View File

@ -0,0 +1,55 @@
;*****************************************************************************
;* x86-optimized Float DSP functions
;*
;* 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
;******************************************************************************
%include "x86inc.asm"
SECTION .text
;-----------------------------------------------------------------------------
; void vector_fmul(float *dst, const float *src0, const float *src1, int len)
;-----------------------------------------------------------------------------
%macro VECTOR_FMUL 0
cglobal vector_fmul, 4,4,2, dst, src0, src1, len
lea lenq, [lend*4 - 2*mmsize]
ALIGN 16
.loop
mova m0, [src0q + lenq]
mova m1, [src0q + lenq + mmsize]
mulps m0, m0, [src1q + lenq]
mulps m1, m1, [src1q + lenq + mmsize]
mova [dstq + lenq], m0
mova [dstq + lenq + mmsize], m1
sub lenq, 2*mmsize
jge .loop
%if mmsize == 32
vzeroupper
RET
%else
REP_RET
%endif
%endmacro
INIT_XMM sse
VECTOR_FMUL
%if HAVE_AVX
INIT_YMM avx
VECTOR_FMUL
%endif

41
libavutil/x86/float_dsp_init.c Normal file
View File

@ -0,0 +1,41 @@
/*
* 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
*/
#include "config.h"
#include "libavutil/cpu.h"
#include "libavutil/float_dsp.h"
extern void ff_vector_fmul_sse(float *dst, const float *src0, const float *src1,
int len);
extern void ff_vector_fmul_avx(float *dst, const float *src0, const float *src1,
int len);
void ff_float_dsp_init_x86(AVFloatDSPContext *fdsp)
{
#if HAVE_YASM
int mm_flags = av_get_cpu_flags();
if (mm_flags & AV_CPU_FLAG_SSE && HAVE_SSE) {
fdsp->vector_fmul = ff_vector_fmul_sse;
}
if (mm_flags & AV_CPU_FLAG_AVX && HAVE_AVX) {
fdsp->vector_fmul = ff_vector_fmul_avx;
}
#endif
}