From 7128a35f8c4bdfb8b749b1e453c69cfd15eb9f07 Mon Sep 17 00:00:00 2001 From: "Ronald S. Bultje" Date: Sat, 14 Jun 2014 14:11:03 -0400 Subject: [PATCH] swr: split out DSP functions. DSP bits of swri_resample go into their own mini-DSP functions; DSP init goes from a per-call branch in multiple_resample to a proper DSP init routine; x86 bits go into x86/; swri_resample() moves out of resample_template.c into resample.c because it's independent of DSP code or sample type; multiple_resample() is simplified. Signed-off-by: Michael Niedermayer --- libswresample/Makefile | 1 + libswresample/resample.c | 141 +++++++++------------------ libswresample/resample.h | 66 +++++++++++++ libswresample/resample_dsp.c | 69 +++++++++++++ libswresample/resample_template.c | 93 +++++++++--------- libswresample/x86/Makefile | 2 + libswresample/x86/resample_x86_dsp.c | 89 +++++++++++++++++ 7 files changed, 319 insertions(+), 142 deletions(-) create mode 100644 libswresample/resample.h create mode 100644 libswresample/resample_dsp.c create mode 100644 libswresample/x86/resample_x86_dsp.c diff --git a/libswresample/Makefile b/libswresample/Makefile index 953c9452a9..ca59d54581 100644 --- a/libswresample/Makefile +++ b/libswresample/Makefile @@ -10,6 +10,7 @@ OBJS = audioconvert.o \ dither.o \ rematrix.o \ resample.o \ + resample_dsp.o \ swresample.o \ OBJS-$(CONFIG_LIBSOXR) += soxr_resample.o diff --git a/libswresample/resample.c b/libswresample/resample.c index 5b7a0f9f23..9a67e6340c 100644 --- a/libswresample/resample.c +++ b/libswresample/resample.c @@ -25,32 +25,8 @@ * @author Michael Niedermayer */ -#include "libavutil/log.h" #include "libavutil/avassert.h" -#include "swresample_internal.h" - - -typedef struct ResampleContext { - const AVClass *av_class; - uint8_t *filter_bank; - int filter_length; - int filter_alloc; - int ideal_dst_incr; - int dst_incr; - int index; - int frac; - int src_incr; - int compensation_distance; - int phase_shift; - int phase_mask; - int linear; - enum SwrFilterType filter_type; - int kaiser_beta; - double factor; - enum AVSampleFormat format; - int felem_size; - int filter_shift; -} ResampleContext; +#include "resample.h" /** * 0th order modified bessel function of the first kind. @@ -197,7 +173,8 @@ static int build_filter(ResampleContext *c, void *filter, double factor, int tap static ResampleContext *resample_init(ResampleContext *c, int out_rate, int in_rate, int filter_size, int phase_shift, int linear, double cutoff0, enum AVSampleFormat format, enum SwrFilterType filter_type, int kaiser_beta, - double precision, int cheby){ + double precision, int cheby) +{ double cutoff = cutoff0? cutoff0 : 0.97; double factor= FFMIN(out_rate * cutoff / in_rate, 1.0); int phase_count= 1<index= -phase_count*((c->filter_length-1)/2); c->frac= 0; + swresample_dsp_init(c); + return c; error: av_freep(&c->filter_bank); @@ -282,59 +261,53 @@ static int set_compensation(ResampleContext *c, int sample_delta, int compensati return 0; } -#define TEMPLATE_RESAMPLE_S16 -#include "resample_template.c" -#undef TEMPLATE_RESAMPLE_S16 +static int swri_resample(ResampleContext *c, + uint8_t *dst, const uint8_t *src, int *consumed, + int src_size, int dst_size, int update_ctx) +{ + int fn_idx = c->format - AV_SAMPLE_FMT_S16P; -#define TEMPLATE_RESAMPLE_S32 -#include "resample_template.c" -#undef TEMPLATE_RESAMPLE_S32 + if (c->filter_length == 1 && c->phase_shift == 0) { + int index= c->index; + int frac= c->frac; + int dst_incr_frac= c->dst_incr % c->src_incr; + int dst_incr= c->dst_incr / c->src_incr; + int64_t index2= (1LL<<32)*c->frac/c->src_incr + (1LL<<32)*index; + int64_t incr= (1LL<<32) * c->dst_incr / c->src_incr; + int new_size = (src_size * (int64_t)c->src_incr - frac + c->dst_incr - 1) / c->dst_incr; -#define TEMPLATE_RESAMPLE_FLT -#include "resample_template.c" -#undef TEMPLATE_RESAMPLE_FLT + dst_size= FFMIN(dst_size, new_size); + c->dsp.resample_one[fn_idx](dst, src, dst_size, index2, incr); -#define TEMPLATE_RESAMPLE_DBL -#include "resample_template.c" -#undef TEMPLATE_RESAMPLE_DBL + index += dst_size * dst_incr; + index += (frac + dst_size * (int64_t)dst_incr_frac) / c->src_incr; + av_assert2(index >= 0); + *consumed= index; + if (update_ctx) { + c->frac = (frac + dst_size * (int64_t)dst_incr_frac) % c->src_incr; + c->index = 0; + } + } else { + int64_t end_index = (1LL + src_size - c->filter_length) << c->phase_shift; + int64_t delta_frac = (end_index - c->index) * c->src_incr - c->frac; + int delta_n = (delta_frac + c->dst_incr - 1) / c->dst_incr; -// XXX FIXME the whole C loop should be written in asm so this x86 specific code here isnt needed -#if HAVE_MMXEXT_INLINE + dst_size = FFMIN(dst_size, delta_n); + if (!c->linear) { + *consumed = c->dsp.resample_common[fn_idx](c, dst, src, dst_size, update_ctx); + } else { + *consumed = c->dsp.resample_linear[fn_idx](c, dst, src, dst_size, update_ctx); + } + } -#include "x86/resample_mmx.h" - -#define TEMPLATE_RESAMPLE_S16_MMX2 -#include "resample_template.c" -#undef TEMPLATE_RESAMPLE_S16_MMX2 - -#if HAVE_SSE_INLINE -#define TEMPLATE_RESAMPLE_FLT_SSE -#include "resample_template.c" -#undef TEMPLATE_RESAMPLE_FLT_SSE -#endif - -#if HAVE_SSE2_INLINE -#define TEMPLATE_RESAMPLE_S16_SSE2 -#include "resample_template.c" -#undef TEMPLATE_RESAMPLE_S16_SSE2 - -#define TEMPLATE_RESAMPLE_DBL_SSE2 -#include "resample_template.c" -#undef TEMPLATE_RESAMPLE_DBL_SSE2 -#endif - -#if HAVE_AVX_INLINE -#define TEMPLATE_RESAMPLE_FLT_AVX -#include "resample_template.c" -#undef TEMPLATE_RESAMPLE_FLT_AVX -#endif - -#endif // HAVE_MMXEXT_INLINE + return dst_size; +} static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, AudioData *src, int src_size, int *consumed){ int i, ret= -1; int av_unused mm_flags = av_get_cpu_flags(); - int need_emms= 0; + int need_emms = c->format == AV_SAMPLE_FMT_S16P && ARCH_X86_32 && + (mm_flags & (AV_CPU_FLAG_MMX2 | AV_CPU_FLAG_SSE2)) == AV_CPU_FLAG_MMX2; int64_t max_src_size = (INT64_MAX >> (c->phase_shift+1)) / c->src_incr; if (c->compensation_distance) @@ -342,32 +315,8 @@ static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, A src_size = FFMIN(src_size, max_src_size); for(i=0; ich_count; i++){ -#if HAVE_MMXEXT_INLINE -#if HAVE_SSE2_INLINE - if(c->format == AV_SAMPLE_FMT_S16P && (mm_flags&AV_CPU_FLAG_SSE2)) ret= swri_resample_int16_sse2 (c, (int16_t*)dst->ch[i], (const int16_t*)src->ch[i], consumed, src_size, dst_size, i+1==dst->ch_count); - else -#endif - if(c->format == AV_SAMPLE_FMT_S16P && (mm_flags&AV_CPU_FLAG_MMX2 )){ - ret= swri_resample_int16_mmx2 (c, (int16_t*)dst->ch[i], (const int16_t*)src->ch[i], consumed, src_size, dst_size, i+1==dst->ch_count); - need_emms= 1; - } else -#endif - if(c->format == AV_SAMPLE_FMT_S16P) ret= swri_resample_int16(c, (int16_t*)dst->ch[i], (const int16_t*)src->ch[i], consumed, src_size, dst_size, i+1==dst->ch_count); - else if(c->format == AV_SAMPLE_FMT_S32P) ret= swri_resample_int32(c, (int32_t*)dst->ch[i], (const int32_t*)src->ch[i], consumed, src_size, dst_size, i+1==dst->ch_count); -#if HAVE_AVX_INLINE - else if(c->format == AV_SAMPLE_FMT_FLTP && (mm_flags&AV_CPU_FLAG_AVX)) - ret= swri_resample_float_avx (c, (float*)dst->ch[i], (const float*)src->ch[i], consumed, src_size, dst_size, i+1==dst->ch_count); -#endif -#if HAVE_SSE_INLINE - else if(c->format == AV_SAMPLE_FMT_FLTP && (mm_flags&AV_CPU_FLAG_SSE)) - ret= swri_resample_float_sse (c, (float*)dst->ch[i], (const float*)src->ch[i], consumed, src_size, dst_size, i+1==dst->ch_count); -#endif - else if(c->format == AV_SAMPLE_FMT_FLTP) ret= swri_resample_float(c, (float *)dst->ch[i], (const float *)src->ch[i], consumed, src_size, dst_size, i+1==dst->ch_count); -#if HAVE_SSE2_INLINE - else if(c->format == AV_SAMPLE_FMT_DBLP && (mm_flags&AV_CPU_FLAG_SSE2)) - ret= swri_resample_double_sse2(c,(double *)dst->ch[i], (const double *)src->ch[i], consumed, src_size, dst_size, i+1==dst->ch_count); -#endif - else if(c->format == AV_SAMPLE_FMT_DBLP) ret= swri_resample_double(c,(double *)dst->ch[i], (const double *)src->ch[i], consumed, src_size, dst_size, i+1==dst->ch_count); + ret= swri_resample(c, dst->ch[i], src->ch[i], + consumed, src_size, dst_size, i+1==dst->ch_count); } if(need_emms) emms_c(); diff --git a/libswresample/resample.h b/libswresample/resample.h new file mode 100644 index 0000000000..b159c7b432 --- /dev/null +++ b/libswresample/resample.h @@ -0,0 +1,66 @@ +/* + * audio resampling + * Copyright (c) 2004-2012 Michael Niedermayer + * + * 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 SWRESAMPLE_RESAMPLE_H +#define SWRESAMPLE_RESAMPLE_H + +#include "libavutil/log.h" +#include "libavutil/samplefmt.h" + +#include "swresample_internal.h" + +typedef void (*resample_one_fn)(uint8_t *dst, const uint8_t *src, + int n, int64_t index, int64_t incr); +typedef int (*resample_fn)(struct ResampleContext *c, uint8_t *dst, + const uint8_t *src, int n, int update_ctx); + +typedef struct ResampleContext { + const AVClass *av_class; + uint8_t *filter_bank; + int filter_length; + int filter_alloc; + int ideal_dst_incr; + int dst_incr; + int index; + int frac; + int src_incr; + int compensation_distance; + int phase_shift; + int phase_mask; + int linear; + enum SwrFilterType filter_type; + int kaiser_beta; + double factor; + enum AVSampleFormat format; + int felem_size; + int filter_shift; + + struct { + resample_one_fn resample_one[AV_SAMPLE_FMT_NB - AV_SAMPLE_FMT_S16P]; + resample_fn resample_common[AV_SAMPLE_FMT_NB - AV_SAMPLE_FMT_S16P]; + resample_fn resample_linear[AV_SAMPLE_FMT_NB - AV_SAMPLE_FMT_S16P]; + } dsp; +} ResampleContext; + +void swresample_dsp_init(ResampleContext *c); +void swresample_dsp_x86_init(ResampleContext *c); + +#endif /* SWRESAMPLE_RESAMPLE_H */ diff --git a/libswresample/resample_dsp.c b/libswresample/resample_dsp.c new file mode 100644 index 0000000000..a48a5a98cf --- /dev/null +++ b/libswresample/resample_dsp.c @@ -0,0 +1,69 @@ +/* + * audio resampling + * Copyright (c) 2004-2012 Michael Niedermayer + * + * 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 + */ + +/** + * @file + * audio resampling + * @author Michael Niedermayer + */ + +#include "resample.h" + +#define DO_RESAMPLE_ONE 1 + +#define TEMPLATE_RESAMPLE_S16 +#include "resample_template.c" +#undef TEMPLATE_RESAMPLE_S16 + +#define TEMPLATE_RESAMPLE_S32 +#include "resample_template.c" +#undef TEMPLATE_RESAMPLE_S32 + +#define TEMPLATE_RESAMPLE_FLT +#include "resample_template.c" +#undef TEMPLATE_RESAMPLE_FLT + +#define TEMPLATE_RESAMPLE_DBL +#include "resample_template.c" +#undef TEMPLATE_RESAMPLE_DBL + +#undef DO_RESAMPLE_ONE + +void swresample_dsp_init(ResampleContext *c) +{ +#define FNIDX(fmt) (AV_SAMPLE_FMT_##fmt - AV_SAMPLE_FMT_S16P) + c->dsp.resample_one[FNIDX(S16P)] = (resample_one_fn) resample_one_int16; + c->dsp.resample_one[FNIDX(S32P)] = (resample_one_fn) resample_one_int32; + c->dsp.resample_one[FNIDX(FLTP)] = (resample_one_fn) resample_one_float; + c->dsp.resample_one[FNIDX(DBLP)] = (resample_one_fn) resample_one_double; + + c->dsp.resample_common[FNIDX(S16P)] = (resample_fn) resample_common_int16; + c->dsp.resample_common[FNIDX(S32P)] = (resample_fn) resample_common_int32; + c->dsp.resample_common[FNIDX(FLTP)] = (resample_fn) resample_common_float; + c->dsp.resample_common[FNIDX(DBLP)] = (resample_fn) resample_common_double; + + c->dsp.resample_linear[FNIDX(S16P)] = (resample_fn) resample_linear_int16; + c->dsp.resample_linear[FNIDX(S32P)] = (resample_fn) resample_linear_int32; + c->dsp.resample_linear[FNIDX(FLTP)] = (resample_fn) resample_linear_float; + c->dsp.resample_linear[FNIDX(DBLP)] = (resample_fn) resample_linear_double; + + if (ARCH_X86) swresample_dsp_x86_init(c); +} diff --git a/libswresample/resample_template.c b/libswresample/resample_template.c index 40def7a69c..6773e3ecc4 100644 --- a/libswresample/resample_template.c +++ b/libswresample/resample_template.c @@ -106,45 +106,30 @@ #endif -int RENAME(swri_resample)(ResampleContext *c, DELEM *dst, const DELEM *src, int *consumed, int src_size, int dst_size, int update_ctx){ +#if DO_RESAMPLE_ONE +static void RENAME(resample_one)(DELEM *dst, const DELEM *src, + int dst_size, int64_t index2, int64_t incr) +{ int dst_index; -#if !defined(COMMON_CORE) || !defined(LINEAR_CORE) - int i; + + for (dst_index = 0; dst_index < dst_size; dst_index++) { + dst[dst_index] = src[index2 >> 32]; + index2 += incr; + } +} #endif - int index= c->index; - int frac= c->frac; - int dst_incr_frac= c->dst_incr % c->src_incr; - int dst_incr= c->dst_incr / c->src_incr; - av_assert1(c->filter_shift == FILTER_SHIFT); - av_assert1(c->felem_size == sizeof(FELEM)); +static int RENAME(resample_common)(ResampleContext *c, + DELEM *dst, const DELEM *src, + int n, int update_ctx) +{ + int dst_index; + int index= c->index; + int frac= c->frac; + int dst_incr_frac= c->dst_incr % c->src_incr; + int dst_incr= c->dst_incr / c->src_incr; + int sample_index = index >> c->phase_shift; - if (c->filter_length == 1 && c->phase_shift == 0) { - int64_t index2= (1LL<<32)*c->frac/c->src_incr + (1LL<<32)*index; - int64_t incr= (1LL<<32) * c->dst_incr / c->src_incr; - int new_size = (src_size * (int64_t)c->src_incr - frac + c->dst_incr - 1) / c->dst_incr; - - dst_size= FFMIN(dst_size, new_size); - - for(dst_index=0; dst_index < dst_size; dst_index++){ - dst[dst_index] = src[index2>>32]; - index2 += incr; - } - index += dst_index * dst_incr; - index += (frac + dst_index * (int64_t)dst_incr_frac) / c->src_incr; - frac = (frac + dst_index * (int64_t)dst_incr_frac) % c->src_incr; - av_assert2(index >= 0); - *consumed= index; - index = 0; - } else { - int64_t end_index = (1LL + src_size - c->filter_length) << c->phase_shift; - int64_t delta_frac = (end_index - index) * c->src_incr - c->frac; - int delta_n = (delta_frac + c->dst_incr - 1) / c->dst_incr; - int n = FFMIN(dst_size, delta_n); - int sample_index; - - if (!c->linear) { - sample_index = index >> c->phase_shift; index &= c->phase_mask; for (dst_index = 0; dst_index < n; dst_index++) { FELEM *filter = ((FELEM *) c->filter_bank) + c->filter_alloc * index; @@ -153,6 +138,7 @@ int RENAME(swri_resample)(ResampleContext *c, DELEM *dst, const DELEM *src, int COMMON_CORE #else FELEM2 val=0; + int i; for (i = 0; i < c->filter_length; i++) { val += src[sample_index + i] * (FELEM2)filter[i]; } @@ -168,8 +154,26 @@ int RENAME(swri_resample)(ResampleContext *c, DELEM *dst, const DELEM *src, int sample_index += index >> c->phase_shift; index &= c->phase_mask; } - } else { - sample_index = index >> c->phase_shift; + + if(update_ctx){ + c->frac= frac; + c->index= index; + } + + return sample_index; +} + +static int RENAME(resample_linear)(ResampleContext *c, + DELEM *dst, const DELEM *src, + int n, int update_ctx) +{ + int dst_index; + int index= c->index; + int frac= c->frac; + int dst_incr_frac= c->dst_incr % c->src_incr; + int dst_incr= c->dst_incr / c->src_incr; + int sample_index = index >> c->phase_shift; + index &= c->phase_mask; for (dst_index = 0; dst_index < n; dst_index++) { FELEM *filter = ((FELEM *) c->filter_bank) + c->filter_alloc * index; @@ -178,6 +182,7 @@ int RENAME(swri_resample)(ResampleContext *c, DELEM *dst, const DELEM *src, int #ifdef LINEAR_CORE LINEAR_CORE #else + int i; for (i = 0; i < c->filter_length; i++) { val += src[sample_index + i] * (FELEM2)filter[i]; v2 += src[sample_index + i] * (FELEM2)filter[i + c->filter_alloc]; @@ -195,17 +200,13 @@ int RENAME(swri_resample)(ResampleContext *c, DELEM *dst, const DELEM *src, int sample_index += index >> c->phase_shift; index &= c->phase_mask; } - } - *consumed = sample_index; - } + if(update_ctx){ + c->frac= frac; + c->index= index; + } - if(update_ctx){ - c->frac= frac; - c->index= index; - } - - return dst_index; + return sample_index; } #undef COMMON_CORE diff --git a/libswresample/x86/Makefile b/libswresample/x86/Makefile index 1d1ab6ead6..cc3e65f26f 100644 --- a/libswresample/x86/Makefile +++ b/libswresample/x86/Makefile @@ -2,4 +2,6 @@ YASM-OBJS += x86/swresample_x86.o\ x86/audio_convert.o\ x86/rematrix.o\ +OBJS += x86/resample_x86_dsp.o\ + OBJS-$(CONFIG_XMM_CLOBBER_TEST) += x86/w64xmmtest.o diff --git a/libswresample/x86/resample_x86_dsp.c b/libswresample/x86/resample_x86_dsp.c new file mode 100644 index 0000000000..02a7db51c2 --- /dev/null +++ b/libswresample/x86/resample_x86_dsp.c @@ -0,0 +1,89 @@ +/* + * audio resampling + * Copyright (c) 2004-2012 Michael Niedermayer + * + * 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 + */ + +/** + * @file + * audio resampling + * @author Michael Niedermayer + */ + +#include "libswresample/resample.h" + +#if HAVE_MMXEXT_INLINE + +#define DO_RESAMPLE_ONE 0 + +#include "resample_mmx.h" + +#define TEMPLATE_RESAMPLE_S16_MMX2 +#include "libswresample/resample_template.c" +#undef TEMPLATE_RESAMPLE_S16_MMX2 + +#if HAVE_SSE_INLINE +#define TEMPLATE_RESAMPLE_FLT_SSE +#include "libswresample/resample_template.c" +#undef TEMPLATE_RESAMPLE_FLT_SSE +#endif + +#if HAVE_SSE2_INLINE +#define TEMPLATE_RESAMPLE_S16_SSE2 +#include "libswresample/resample_template.c" +#undef TEMPLATE_RESAMPLE_S16_SSE2 + +#define TEMPLATE_RESAMPLE_DBL_SSE2 +#include "libswresample/resample_template.c" +#undef TEMPLATE_RESAMPLE_DBL_SSE2 +#endif + +#if HAVE_AVX_INLINE +#define TEMPLATE_RESAMPLE_FLT_AVX +#include "libswresample/resample_template.c" +#undef TEMPLATE_RESAMPLE_FLT_AVX +#endif + +#undef DO_RESAMPLE_ONE + +#endif // HAVE_MMXEXT_INLINE + +void swresample_dsp_x86_init(ResampleContext *c) +{ + int av_unused mm_flags = av_get_cpu_flags(); + +#define FNIDX(fmt) (AV_SAMPLE_FMT_##fmt - AV_SAMPLE_FMT_S16P) + if (ARCH_X86_32 && HAVE_MMXEXT_INLINE && mm_flags & AV_CPU_FLAG_MMX2) { + c->dsp.resample_common[FNIDX(S16P)] = (resample_fn) resample_common_int16_mmx2; + c->dsp.resample_linear[FNIDX(S16P)] = (resample_fn) resample_linear_int16_mmx2; + } + if (HAVE_SSE_INLINE && mm_flags & AV_CPU_FLAG_SSE) { + c->dsp.resample_common[FNIDX(FLTP)] = (resample_fn) resample_common_float_sse; + c->dsp.resample_linear[FNIDX(FLTP)] = (resample_fn) resample_linear_float_sse; + } + if (HAVE_SSE2_INLINE && mm_flags & AV_CPU_FLAG_SSE2) { + c->dsp.resample_common[FNIDX(S16P)] = (resample_fn) resample_common_int16_sse2; + c->dsp.resample_linear[FNIDX(S16P)] = (resample_fn) resample_linear_int16_sse2; + c->dsp.resample_common[FNIDX(DBLP)] = (resample_fn) resample_common_double_sse2; + c->dsp.resample_linear[FNIDX(DBLP)] = (resample_fn) resample_linear_double_sse2; + } + if (HAVE_AVX_INLINE && mm_flags & AV_CPU_FLAG_AVX) { + c->dsp.resample_common[FNIDX(FLTP)] = (resample_fn) resample_common_float_avx; + c->dsp.resample_linear[FNIDX(FLTP)] = (resample_fn) resample_linear_float_avx; + } +}