59 #define MUL16(a, b) ((a) * (b)) 61 #define CMAC(pre, pim, are, aim, bre, bim) \ 63 pre += (MUL16(are, bre) - MUL16(aim, bim)); \ 64 pim += (MUL16(are, bim) + MUL16(bre, aim)); \ 67 #if FFT_FLOAT || AVFFT 69 #define REF_SCALE(x, bits) (x) 73 #define REF_SCALE(x, bits) (x) 77 #define REF_SCALE(x, bits) ((x) / (1 << (bits))) 87 int i, n = 1 << nbits;
93 for (i = 0; i < (n / 2); i++) {
94 double alpha = 2 *
M_PI * (float) i / (
float) n;
95 double c1 = cos(alpha),
s1 = sin(alpha);
110 for (i = 0; i < n; i++) {
111 double tmp_re = 0, tmp_im = 0;
113 for (j = 0; j < n; j++) {
115 int k = (i * j) & (n - 1);
123 CMAC(tmp_re, tmp_im, c, s, q->
re, q->
im);
134 int i, k, n = 1 << nbits;
136 for (i = 0; i < n; i++) {
138 for (k = 0; k < n / 2; k++) {
139 int a = (2 * i + 1 + (n / 2)) * (2 * k + 1);
140 double f = cos(
M_PI * a / (
double) (2 * n));
150 int i, k, n = 1 << nbits;
153 for (k = 0; k < n / 2; k++) {
155 for (i = 0; i < n; i++) {
156 double a = (2 *
M_PI * (2 * i + 1 + n / 2) * (2 * k + 1) / (4 * n));
168 int i, k, n = 1 << nbits;
171 for (i = 0; i < n; i++) {
172 double s = 0.5 *
input[0];
173 for (k = 1; k < n; k++) {
174 double a =
M_PI * k * (i + 0.5) / n;
175 s +=
input[k] * cos(a);
183 int i, k, n = 1 << nbits;
186 for (k = 0; k < n; k++) {
188 for (i = 0; i < n; i++) {
189 double a =
M_PI * k * (i + 0.5) / n;
208 for (i = 0; i < n; i++) {
209 double e =
fabs(tab1[i] - (tab2[i] / scale)) /
RANGE;
212 i, tab1[i], tab2[i]);
354 "usage: fft-test [-h] [-s] [-i] [-n b]\n" 355 "-h print this help\n" 360 "-i inverse transform test\n" 361 "-n b set the transform size to 2^b\n" 362 "-f x set scale factor for output data of (I)MDCT to x\n");
376 int main(
int argc,
char **argv)
387 int do_speed = 0, do_inverse = 0;
388 int fft_nbits = 9, fft_size;
397 #if !AVFFT && FFT_FLOAT 405 int c =
getopt(argc, argv,
"hsimrdn:f:c:");
446 fft_size = 1 << fft_nbits;
452 if (!(tab && tab1 && tab_ref && tab2))
463 mdct_init(&m, fft_nbits, do_inverse, scale);
471 fft_init(&s, fft_nbits, do_inverse);
505 for (i = 0; i < fft_size; i++) {
517 imdct_ref(&tab_ref->
re, &tab1->
re, fft_nbits);
521 mdct_ref(&tab_ref->
re, &tab1->
re, fft_nbits);
523 err =
check_diff(&tab_ref->
re, tab2, fft_size / 2, scale);
528 memcpy(tab, tab1, fft_size *
sizeof(
FFTComplex));
532 fft_ref(tab_ref, tab1, fft_nbits);
539 int fft_size_2 = fft_size >> 1;
542 tab1[fft_size_2].
im = 0;
543 for (i = 1; i < fft_size_2; i++) {
544 tab1[fft_size_2 +
i].
re = tab1[fft_size_2 -
i].
re;
545 tab1[fft_size_2 +
i].
im = -tab1[fft_size_2 -
i].
im;
548 memcpy(tab2, tab1, fft_size *
sizeof(
FFTSample));
549 tab2[1] = tab1[fft_size_2].
re;
552 fft_ref(tab_ref, tab1, fft_nbits);
553 for (i = 0; i < fft_size; i++) {
559 for (i = 0; i < fft_size; i++) {
560 tab2[
i] = tab1[
i].
re;
564 fft_ref(tab_ref, tab1, fft_nbits);
565 tab_ref[0].
im = tab_ref[fft_size_2].
re;
573 memcpy(tab, tab1, fft_size *
sizeof(
FFTComplex));
574 dct_calc(d, &tab->
re);
576 idct_ref(&tab_ref->
re, &tab1->
re, fft_nbits);
578 dct_ref(&tab_ref->
re, &tab1->
re, fft_nbits);
596 for (it = 0; it < nb_its; it++) {
605 memcpy(tab, tab1, fft_size *
sizeof(
FFTComplex));
610 memcpy(tab2, tab1, fft_size *
sizeof(
FFTSample));
614 memcpy(tab2, tab1, fft_size *
sizeof(
FFTSample));
621 if (duration >= 1000000)
626 "time: %0.1f us/transform [total time=%0.2f s its=%d]\n",
627 (
double) duration / nb_its,
628 (
double) duration / 1000000.0,
667 #if !AVFFT && FFT_FLOAT 673 printf(
"Error: %d.\n", err);
Context structure for the Lagged Fibonacci PRNG.
av_cold void ff_rdft_end(RDFTContext *s)
ptrdiff_t const GLvoid * data
av_cold void av_fft_end(FFTContext *s)
void av_mdct_end(FFTContext *s)
FFTContext * av_mdct_init(int nbits, int inverse, double scale)
DCTContext * av_dct_init(int nbits, enum DCTTransformType type)
Set up DCT.
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
void av_fft_permute(FFTContext *s, FFTComplex *z)
Do the permutation needed BEFORE calling ff_fft_calc().
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static void error(const char *err)
static void imdct_calc(struct FFTContext *s, FFTSample *output, const FFTSample *input)
static FFTSample frandom(AVLFG *prng)
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
static void fft_permute(FFTContext *s, FFTComplex *z)
static int fft_ref_init(int nbits, int inverse)
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s it
#define CMAC(pre, pim, are, aim, bre, bim)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static void fft_ref(FFTComplex *tabr, FFTComplex *tab, int nbits)
void(* fft_permute)(struct FFTContext *s, FFTComplex *z)
Do the permutation needed BEFORE calling fft_calc().
static __device__ float fabs(float a)
static struct @136 * exptab
void(* mdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
FFTContext * av_fft_init(int nbits, int inverse)
Set up a complex FFT.
void(* imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
int av_parse_cpu_caps(unsigned *flags, const char *s)
Parse CPU caps from a string and update the given AV_CPU_* flags based on that.
void av_rdft_calc(RDFTContext *s, FFTSample *data)
#define REF_SCALE(x, bits)
void(* dct_calc)(struct DCTContext *s, FFTSample *data)
void av_rdft_end(RDFTContext *s)
RDFTContext * av_rdft_init(int nbits, enum RDFTransformType trans)
Set up a real FFT.
void(* rdft_calc)(struct RDFTContext *s, FFTSample *z)
static void mdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input)
static void fft_end(FFTContext *s)
static const int8_t transform[32][32]
#define AV_LOG_INFO
Standard information.
void av_imdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input)
static const int16_t alpha[]
static int check_diff(FFTSample *tab1, FFTSample *tab2, int n, double scale)
static int getopt(int argc, char *argv[], char *opts)
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
void av_dct_end(DCTContext *s)
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
av_cold int ff_dct_init(DCTContext *s, int nbits, enum DCTTransformType inverse)
Set up DCT.
static void fft_calc(FFTContext *s, FFTComplex *z)
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
static av_cold int dct_init(MpegEncContext *s)
void(* fft_calc)(struct FFTContext *s, FFTComplex *z)
Do a complex FFT with the parameters defined in ff_fft_init().
static void mdct_end(FFTContext *s)
static void mdct_init(FFTContext **s, int nbits, int inverse, double scale)
void av_dct_calc(DCTContext *s, FFTSample *data)
int main(int argc, char **argv)
printf("static const uint8_t my_array[100] = {\n")
av_cold void ff_dct_end(DCTContext *s)
static const struct twinvq_data tab
void av_mdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input)
static uint32_t inverse(uint32_t v)
find multiplicative inverse modulo 2 ^ 32
#define av_malloc_array(a, b)
void av_force_cpu_flags(int arg)
Disables cpu detection and forces the specified flags.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static void fft_init(FFTContext **s, int nbits, int inverse)
av_cold int ff_rdft_init(RDFTContext *s, int nbits, enum RDFTransformType trans)
Set up a real FFT.
void av_fft_calc(FFTContext *s, FFTComplex *z)
Do a complex FFT with the parameters defined in av_fft_init().
static av_cold void cleanup(FlashSV2Context *s)