lavfi/af_afir,af_aiir: Remove a variable that is always -1.
[ffmpeg.git] / libavfilter / af_afir.c
1 /*
2  * Copyright (c) 2017 Paul B Mahol
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 /**
22  * @file
23  * An arbitrary audio FIR filter
24  */
25
26 #include <float.h>
27
28 #include "libavutil/audio_fifo.h"
29 #include "libavutil/common.h"
30 #include "libavutil/float_dsp.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/xga_font_data.h"
34 #include "libavcodec/avfft.h"
35
36 #include "audio.h"
37 #include "avfilter.h"
38 #include "formats.h"
39 #include "internal.h"
40 #include "af_afir.h"
41
42 static void fcmul_add_c(float *sum, const float *t, const float *c, ptrdiff_t len)
43 {
44     int n;
45
46     for (n = 0; n < len; n++) {
47         const float cre = c[2 * n    ];
48         const float cim = c[2 * n + 1];
49         const float tre = t[2 * n    ];
50         const float tim = t[2 * n + 1];
51
52         sum[2 * n    ] += tre * cre - tim * cim;
53         sum[2 * n + 1] += tre * cim + tim * cre;
54     }
55
56     sum[2 * n] += t[2 * n] * c[2 * n];
57 }
58
59 static int fir_channel(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)
60 {
61     AudioFIRContext *s = ctx->priv;
62     const float *src = (const float *)s->in[0]->extended_data[ch];
63     int index1 = (s->index + 1) % 3;
64     int index2 = (s->index + 2) % 3;
65     float *sum = s->sum[ch];
66     AVFrame *out = arg;
67     float *block;
68     float *dst;
69     int n, i, j;
70
71     memset(sum, 0, sizeof(*sum) * s->fft_length);
72     block = s->block[ch] + s->part_index * s->block_size;
73     memset(block, 0, sizeof(*block) * s->fft_length);
74
75     s->fdsp->vector_fmul_scalar(block + s->part_size, src, s->dry_gain, FFALIGN(s->nb_samples, 4));
76     emms_c();
77
78     av_rdft_calc(s->rdft[ch], block);
79     block[2 * s->part_size] = block[1];
80     block[1] = 0;
81
82     j = s->part_index;
83
84     for (i = 0; i < s->nb_partitions; i++) {
85         const int coffset = i * s->coeff_size;
86         const FFTComplex *coeff = s->coeff[ch * !s->one2many] + coffset;
87
88         block = s->block[ch] + j * s->block_size;
89         s->fcmul_add(sum, block, (const float *)coeff, s->part_size);
90
91         if (j == 0)
92             j = s->nb_partitions;
93         j--;
94     }
95
96     sum[1] = sum[2 * s->part_size];
97     av_rdft_calc(s->irdft[ch], sum);
98
99     dst = (float *)s->buffer->extended_data[ch] + index1 * s->part_size;
100     for (n = 0; n < s->part_size; n++) {
101         dst[n] += sum[n];
102     }
103
104     dst = (float *)s->buffer->extended_data[ch] + index2 * s->part_size;
105
106     memcpy(dst, sum + s->part_size, s->part_size * sizeof(*dst));
107
108     dst = (float *)s->buffer->extended_data[ch] + s->index * s->part_size;
109
110     if (out) {
111         float *ptr = (float *)out->extended_data[ch];
112         s->fdsp->vector_fmul_scalar(ptr, dst, s->wet_gain, FFALIGN(out->nb_samples, 4));
113         emms_c();
114     }
115
116     return 0;
117 }
118
119 static int fir_frame(AudioFIRContext *s, AVFilterLink *outlink)
120 {
121     AVFilterContext *ctx = outlink->src;
122     AVFrame *out = NULL;
123     int ret;
124
125     s->nb_samples = FFMIN(s->part_size, av_audio_fifo_size(s->fifo[0]));
126
127     if (!s->want_skip) {
128         out = ff_get_audio_buffer(outlink, s->nb_samples);
129         if (!out)
130             return AVERROR(ENOMEM);
131     }
132
133     s->in[0] = ff_get_audio_buffer(ctx->inputs[0], s->nb_samples);
134     if (!s->in[0]) {
135         av_frame_free(&out);
136         return AVERROR(ENOMEM);
137     }
138
139     av_audio_fifo_peek(s->fifo[0], (void **)s->in[0]->extended_data, s->nb_samples);
140
141     ctx->internal->execute(ctx, fir_channel, out, NULL, outlink->channels);
142
143     s->part_index = (s->part_index + 1) % s->nb_partitions;
144
145     av_audio_fifo_drain(s->fifo[0], s->nb_samples);
146
147     if (!s->want_skip) {
148         out->pts = s->pts;
149         if (s->pts != AV_NOPTS_VALUE)
150             s->pts += av_rescale_q(out->nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
151     }
152
153     s->index++;
154     if (s->index == 3)
155         s->index = 0;
156
157     av_frame_free(&s->in[0]);
158
159     if (s->want_skip == 1) {
160         s->want_skip = 0;
161         ret = 0;
162     } else {
163         ret = ff_filter_frame(outlink, out);
164     }
165
166     return ret;
167 }
168
169 static void drawtext(AVFrame *pic, int x, int y, const char *txt, uint32_t color)
170 {
171     const uint8_t *font;
172     int font_height;
173     int i;
174
175     font = avpriv_cga_font, font_height = 8;
176
177     for (i = 0; txt[i]; i++) {
178         int char_y, mask;
179
180         uint8_t *p = pic->data[0] + y * pic->linesize[0] + (x + i * 8) * 4;
181         for (char_y = 0; char_y < font_height; char_y++) {
182             for (mask = 0x80; mask; mask >>= 1) {
183                 if (font[txt[i] * font_height + char_y] & mask)
184                     AV_WL32(p, color);
185                 p += 4;
186             }
187             p += pic->linesize[0] - 8 * 4;
188         }
189     }
190 }
191
192 static void draw_line(AVFrame *out, int x0, int y0, int x1, int y1, uint32_t color)
193 {
194     int dx = FFABS(x1-x0);
195     int dy = FFABS(y1-y0), sy = y0 < y1 ? 1 : -1;
196     int err = (dx>dy ? dx : -dy) / 2, e2;
197
198     for (;;) {
199         AV_WL32(out->data[0] + y0 * out->linesize[0] + x0 * 4, color);
200
201         if (x0 == x1 && y0 == y1)
202             break;
203
204         e2 = err;
205
206         if (e2 >-dx) {
207             err -= dy;
208             x0--;
209         }
210
211         if (e2 < dy) {
212             err += dx;
213             y0 += sy;
214         }
215     }
216 }
217
218 static void draw_response(AVFilterContext *ctx, AVFrame *out)
219 {
220     AudioFIRContext *s = ctx->priv;
221     float *mag, *phase, min = FLT_MAX, max = FLT_MIN;
222     int prev_ymag = -1, prev_yphase = -1;
223     char text[32];
224     int channel, i, x;
225
226     memset(out->data[0], 0, s->h * out->linesize[0]);
227
228     phase = av_malloc_array(s->w, sizeof(*phase));
229     mag = av_malloc_array(s->w, sizeof(*mag));
230     if (!mag || !phase)
231         goto end;
232
233     channel = av_clip(s->ir_channel, 0, s->in[1]->channels - 1);
234     for (i = 0; i < s->w; i++) {
235         const float *src = (const float *)s->in[1]->extended_data[channel];
236         double w = i * M_PI / (s->w - 1);
237         double real = 0.;
238         double imag = 0.;
239
240         for (x = 0; x < s->nb_taps; x++) {
241             real += cos(-x * w) * src[x];
242             imag += sin(-x * w) * src[x];
243         }
244
245         mag[i] = hypot(real, imag);
246         phase[i] = atan2(imag, real);
247         min = fminf(min, mag[i]);
248         max = fmaxf(max, mag[i]);
249     }
250
251     for (i = 0; i < s->w; i++) {
252         int ymag = mag[i] / max * (s->h - 1);
253         int yphase = (0.5 * (1. + phase[i] / M_PI)) * (s->h - 1);
254
255         ymag = s->h - 1 - av_clip(ymag, 0, s->h - 1);
256         yphase = s->h - 1 - av_clip(yphase, 0, s->h - 1);
257
258         if (prev_ymag < 0)
259             prev_ymag = ymag;
260         if (prev_yphase < 0)
261             prev_yphase = yphase;
262
263         draw_line(out, i,   ymag, FFMAX(i - 1, 0),   prev_ymag, 0xFFFF00FF);
264         draw_line(out, i, yphase, FFMAX(i - 1, 0), prev_yphase, 0xFF00FF00);
265
266         prev_ymag   = ymag;
267         prev_yphase = yphase;
268     }
269
270     if (s->w > 400 && s->h > 100) {
271         drawtext(out, 2, 2, "Max Magnitude:", 0xDDDDDDDD);
272         snprintf(text, sizeof(text), "%.2f", max);
273         drawtext(out, 15 * 8 + 2, 2, text, 0xDDDDDDDD);
274
275         drawtext(out, 2, 12, "Min Magnitude:", 0xDDDDDDDD);
276         snprintf(text, sizeof(text), "%.2f", min);
277         drawtext(out, 15 * 8 + 2, 12, text, 0xDDDDDDDD);
278     }
279
280 end:
281     av_free(phase);
282     av_free(mag);
283 }
284
285 static int convert_coeffs(AVFilterContext *ctx)
286 {
287     AudioFIRContext *s = ctx->priv;
288     int i, ch, n, N;
289
290     s->nb_taps = av_audio_fifo_size(s->fifo[1]);
291     if (s->nb_taps <= 0)
292         return AVERROR(EINVAL);
293
294     for (n = 4; (1 << n) < s->nb_taps; n++);
295     N = FFMIN(n, 16);
296     s->ir_length = 1 << n;
297     s->fft_length = (1 << (N + 1)) + 1;
298     s->part_size = 1 << (N - 1);
299     s->block_size = FFALIGN(s->fft_length, 32);
300     s->coeff_size = FFALIGN(s->part_size + 1, 32);
301     s->nb_partitions = (s->nb_taps + s->part_size - 1) / s->part_size;
302     s->nb_coeffs = s->ir_length + s->nb_partitions;
303
304     for (ch = 0; ch < ctx->inputs[0]->channels; ch++) {
305         s->sum[ch] = av_calloc(s->fft_length, sizeof(**s->sum));
306         if (!s->sum[ch])
307             return AVERROR(ENOMEM);
308     }
309
310     for (ch = 0; ch < ctx->inputs[1]->channels; ch++) {
311         s->coeff[ch] = av_calloc(s->nb_partitions * s->coeff_size, sizeof(**s->coeff));
312         if (!s->coeff[ch])
313             return AVERROR(ENOMEM);
314     }
315
316     for (ch = 0; ch < ctx->inputs[0]->channels; ch++) {
317         s->block[ch] = av_calloc(s->nb_partitions * s->block_size, sizeof(**s->block));
318         if (!s->block[ch])
319             return AVERROR(ENOMEM);
320     }
321
322     for (ch = 0; ch < ctx->inputs[0]->channels; ch++) {
323         s->rdft[ch]  = av_rdft_init(N, DFT_R2C);
324         s->irdft[ch] = av_rdft_init(N, IDFT_C2R);
325         if (!s->rdft[ch] || !s->irdft[ch])
326             return AVERROR(ENOMEM);
327     }
328
329     s->in[1] = ff_get_audio_buffer(ctx->inputs[1], s->nb_taps);
330     if (!s->in[1])
331         return AVERROR(ENOMEM);
332
333     s->buffer = ff_get_audio_buffer(ctx->inputs[0], s->part_size * 3);
334     if (!s->buffer)
335         return AVERROR(ENOMEM);
336
337     av_audio_fifo_read(s->fifo[1], (void **)s->in[1]->extended_data, s->nb_taps);
338
339     if (s->response)
340         draw_response(ctx, s->video);
341
342     if (s->again) {
343         float power = 0;
344
345         for (ch = 0; ch < ctx->inputs[1]->channels; ch++) {
346             float *time = (float *)s->in[1]->extended_data[!s->one2many * ch];
347
348             for (i = 0; i < s->nb_taps; i++)
349                 power += FFABS(time[i]);
350         }
351
352         s->gain = sqrtf(1.f / (ctx->inputs[1]->channels * power)) / (sqrtf(ctx->inputs[1]->channels));
353         for (ch = 0; ch < ctx->inputs[1]->channels; ch++) {
354             float *time = (float *)s->in[1]->extended_data[!s->one2many * ch];
355
356             s->fdsp->vector_fmul_scalar(time, time, s->gain, FFALIGN(s->nb_taps, 4));
357         }
358     }
359
360     for (ch = 0; ch < ctx->inputs[1]->channels; ch++) {
361         float *time = (float *)s->in[1]->extended_data[!s->one2many * ch];
362         float *block = s->block[ch];
363         FFTComplex *coeff = s->coeff[ch];
364
365         for (i = FFMAX(1, s->length * s->nb_taps); i < s->nb_taps; i++)
366             time[i] = 0;
367
368         for (i = 0; i < s->nb_partitions; i++) {
369             const float scale = 1.f / s->part_size;
370             const int toffset = i * s->part_size;
371             const int coffset = i * s->coeff_size;
372             const int boffset = s->part_size;
373             const int remaining = s->nb_taps - (i * s->part_size);
374             const int size = remaining >= s->part_size ? s->part_size : remaining;
375
376             memset(block, 0, sizeof(*block) * s->fft_length);
377             memcpy(block + boffset, time + toffset, size * sizeof(*block));
378
379             av_rdft_calc(s->rdft[0], block);
380
381             coeff[coffset].re = block[0] * scale;
382             coeff[coffset].im = 0;
383             for (n = 1; n < s->part_size; n++) {
384                 coeff[coffset + n].re = block[2 * n] * scale;
385                 coeff[coffset + n].im = block[2 * n + 1] * scale;
386             }
387             coeff[coffset + s->part_size].re = block[1] * scale;
388             coeff[coffset + s->part_size].im = 0;
389         }
390     }
391
392     av_frame_free(&s->in[1]);
393     av_log(ctx, AV_LOG_DEBUG, "nb_taps: %d\n", s->nb_taps);
394     av_log(ctx, AV_LOG_DEBUG, "nb_partitions: %d\n", s->nb_partitions);
395     av_log(ctx, AV_LOG_DEBUG, "partition size: %d\n", s->part_size);
396     av_log(ctx, AV_LOG_DEBUG, "ir_length: %d\n", s->ir_length);
397
398     s->have_coeffs = 1;
399
400     return 0;
401 }
402
403 static int read_ir(AVFilterLink *link, AVFrame *frame)
404 {
405     AVFilterContext *ctx = link->dst;
406     AudioFIRContext *s = ctx->priv;
407     int nb_taps, max_nb_taps, ret;
408
409     ret = av_audio_fifo_write(s->fifo[1], (void **)frame->extended_data,
410                              frame->nb_samples);
411     av_frame_free(&frame);
412     if (ret < 0)
413         return ret;
414
415     nb_taps = av_audio_fifo_size(s->fifo[1]);
416     max_nb_taps = s->max_ir_len * ctx->outputs[0]->sample_rate;
417     if (nb_taps > max_nb_taps) {
418         av_log(ctx, AV_LOG_ERROR, "Too big number of coefficients: %d > %d.\n", nb_taps, max_nb_taps);
419         return AVERROR(EINVAL);
420     }
421
422     return 0;
423 }
424
425 static int filter_frame(AVFilterLink *link, AVFrame *frame)
426 {
427     AVFilterContext *ctx = link->dst;
428     AudioFIRContext *s = ctx->priv;
429     AVFilterLink *outlink = ctx->outputs[0];
430     int ret;
431
432     ret = av_audio_fifo_write(s->fifo[0], (void **)frame->extended_data,
433                               frame->nb_samples);
434     if (ret > 0 && s->pts == AV_NOPTS_VALUE)
435         s->pts = frame->pts;
436
437     av_frame_free(&frame);
438
439     if (ret < 0)
440         return ret;
441
442     if (!s->have_coeffs && s->eof_coeffs) {
443         ret = convert_coeffs(ctx);
444         if (ret < 0)
445             return ret;
446     }
447
448     if (s->response && s->have_coeffs) {
449         s->video->pts = s->pts;
450         ret = ff_filter_frame(ctx->outputs[1], av_frame_clone(s->video));
451         if (ret < 0)
452             return ret;
453     }
454
455     if (s->have_coeffs) {
456         while (av_audio_fifo_size(s->fifo[0]) >= s->part_size) {
457             ret = fir_frame(s, outlink);
458             if (ret < 0)
459                 return ret;
460         }
461     }
462     return 0;
463 }
464
465 static int request_frame(AVFilterLink *outlink)
466 {
467     AVFilterContext *ctx = outlink->src;
468     AudioFIRContext *s = ctx->priv;
469     int ret;
470
471     if (!s->eof_coeffs) {
472         ret = ff_request_frame(ctx->inputs[1]);
473         if (ret == AVERROR_EOF) {
474             s->eof_coeffs = 1;
475             ret = 0;
476         }
477         return ret;
478     }
479     ret = ff_request_frame(ctx->inputs[0]);
480     if (ret == AVERROR_EOF && s->have_coeffs) {
481         if (s->need_padding) {
482             AVFrame *silence = ff_get_audio_buffer(outlink, s->part_size);
483
484             if (!silence)
485                 return AVERROR(ENOMEM);
486             ret = av_audio_fifo_write(s->fifo[0], (void **)silence->extended_data,
487                                       silence->nb_samples);
488             av_frame_free(&silence);
489             if (ret < 0)
490                 return ret;
491             s->need_padding = 0;
492         }
493
494         while (av_audio_fifo_size(s->fifo[0]) > 0) {
495             ret = fir_frame(s, outlink);
496             if (ret < 0)
497                 return ret;
498         }
499         ret = AVERROR_EOF;
500     }
501     return ret;
502 }
503
504 static int query_formats(AVFilterContext *ctx)
505 {
506     AudioFIRContext *s = ctx->priv;
507     AVFilterFormats *formats;
508     AVFilterChannelLayouts *layouts;
509     static const enum AVSampleFormat sample_fmts[] = {
510         AV_SAMPLE_FMT_FLTP,
511         AV_SAMPLE_FMT_NONE
512     };
513     static const enum AVPixelFormat pix_fmts[] = {
514         AV_PIX_FMT_RGB0,
515         AV_PIX_FMT_NONE
516     };
517     int ret, i;
518
519     if (s->response) {
520         AVFilterLink *videolink = ctx->outputs[1];
521         formats = ff_make_format_list(pix_fmts);
522         if ((ret = ff_formats_ref(formats, &videolink->in_formats)) < 0)
523             return ret;
524     }
525
526     layouts = ff_all_channel_counts();
527     if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0)
528         return ret;
529
530     for (i = 0; i < 2; i++) {
531         layouts = ff_all_channel_counts();
532         if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts)) < 0)
533             return ret;
534     }
535
536     formats = ff_make_format_list(sample_fmts);
537     if ((ret = ff_set_common_formats(ctx, formats)) < 0)
538         return ret;
539
540     formats = ff_all_samplerates();
541     return ff_set_common_samplerates(ctx, formats);
542 }
543
544 static int config_output(AVFilterLink *outlink)
545 {
546     AVFilterContext *ctx = outlink->src;
547     AudioFIRContext *s = ctx->priv;
548
549     if (ctx->inputs[0]->channels != ctx->inputs[1]->channels &&
550         ctx->inputs[1]->channels != 1) {
551         av_log(ctx, AV_LOG_ERROR,
552                "Second input must have same number of channels as first input or "
553                "exactly 1 channel.\n");
554         return AVERROR(EINVAL);
555     }
556
557     s->one2many = ctx->inputs[1]->channels == 1;
558     outlink->sample_rate = ctx->inputs[0]->sample_rate;
559     outlink->time_base   = ctx->inputs[0]->time_base;
560     outlink->channel_layout = ctx->inputs[0]->channel_layout;
561     outlink->channels = ctx->inputs[0]->channels;
562
563     s->fifo[0] = av_audio_fifo_alloc(ctx->inputs[0]->format, ctx->inputs[0]->channels, 1024);
564     s->fifo[1] = av_audio_fifo_alloc(ctx->inputs[1]->format, ctx->inputs[1]->channels, 1024);
565     if (!s->fifo[0] || !s->fifo[1])
566         return AVERROR(ENOMEM);
567
568     s->sum = av_calloc(outlink->channels, sizeof(*s->sum));
569     s->coeff = av_calloc(ctx->inputs[1]->channels, sizeof(*s->coeff));
570     s->block = av_calloc(ctx->inputs[0]->channels, sizeof(*s->block));
571     s->rdft = av_calloc(outlink->channels, sizeof(*s->rdft));
572     s->irdft = av_calloc(outlink->channels, sizeof(*s->irdft));
573     if (!s->sum || !s->coeff || !s->block || !s->rdft || !s->irdft)
574         return AVERROR(ENOMEM);
575
576     s->nb_channels = outlink->channels;
577     s->nb_coef_channels = ctx->inputs[1]->channels;
578     s->want_skip = 1;
579     s->need_padding = 1;
580     s->pts = AV_NOPTS_VALUE;
581
582     return 0;
583 }
584
585 static av_cold void uninit(AVFilterContext *ctx)
586 {
587     AudioFIRContext *s = ctx->priv;
588     int ch;
589
590     if (s->sum) {
591         for (ch = 0; ch < s->nb_channels; ch++) {
592             av_freep(&s->sum[ch]);
593         }
594     }
595     av_freep(&s->sum);
596
597     if (s->coeff) {
598         for (ch = 0; ch < s->nb_coef_channels; ch++) {
599             av_freep(&s->coeff[ch]);
600         }
601     }
602     av_freep(&s->coeff);
603
604     if (s->block) {
605         for (ch = 0; ch < s->nb_channels; ch++) {
606             av_freep(&s->block[ch]);
607         }
608     }
609     av_freep(&s->block);
610
611     if (s->rdft) {
612         for (ch = 0; ch < s->nb_channels; ch++) {
613             av_rdft_end(s->rdft[ch]);
614         }
615     }
616     av_freep(&s->rdft);
617
618     if (s->irdft) {
619         for (ch = 0; ch < s->nb_channels; ch++) {
620             av_rdft_end(s->irdft[ch]);
621         }
622     }
623     av_freep(&s->irdft);
624
625     av_frame_free(&s->in[0]);
626     av_frame_free(&s->in[1]);
627     av_frame_free(&s->buffer);
628
629     av_audio_fifo_free(s->fifo[0]);
630     av_audio_fifo_free(s->fifo[1]);
631
632     av_freep(&s->fdsp);
633
634     av_freep(&ctx->output_pads[0].name);
635     if (s->response)
636         av_freep(&ctx->output_pads[1].name);
637     av_frame_free(&s->video);
638 }
639
640 static int config_video(AVFilterLink *outlink)
641 {
642     AVFilterContext *ctx = outlink->src;
643     AudioFIRContext *s = ctx->priv;
644
645     outlink->sample_aspect_ratio = (AVRational){1,1};
646     outlink->w = s->w;
647     outlink->h = s->h;
648
649     av_frame_free(&s->video);
650     s->video = ff_get_video_buffer(outlink, outlink->w, outlink->h);
651     if (!s->video)
652         return AVERROR(ENOMEM);
653
654     return 0;
655 }
656
657 static av_cold int init(AVFilterContext *ctx)
658 {
659     AudioFIRContext *s = ctx->priv;
660     AVFilterPad pad, vpad;
661
662     pad = (AVFilterPad){
663         .name          = av_strdup("default"),
664         .type          = AVMEDIA_TYPE_AUDIO,
665         .config_props  = config_output,
666         .request_frame = request_frame,
667     };
668
669     if (!pad.name)
670         return AVERROR(ENOMEM);
671
672     if (s->response) {
673         vpad = (AVFilterPad){
674             .name         = av_strdup("filter_response"),
675             .type         = AVMEDIA_TYPE_VIDEO,
676             .config_props = config_video,
677         };
678         if (!vpad.name)
679             return AVERROR(ENOMEM);
680     }
681
682     ff_insert_outpad(ctx, 0, &pad);
683
684     if (s->response)
685         ff_insert_outpad(ctx, 1, &vpad);
686
687     s->fcmul_add = fcmul_add_c;
688
689     s->fdsp = avpriv_float_dsp_alloc(0);
690     if (!s->fdsp)
691         return AVERROR(ENOMEM);
692
693     if (ARCH_X86)
694         ff_afir_init_x86(s);
695
696     return 0;
697 }
698
699 static const AVFilterPad afir_inputs[] = {
700     {
701         .name           = "main",
702         .type           = AVMEDIA_TYPE_AUDIO,
703         .filter_frame   = filter_frame,
704     },{
705         .name           = "ir",
706         .type           = AVMEDIA_TYPE_AUDIO,
707         .filter_frame   = read_ir,
708     },
709     { NULL }
710 };
711
712 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
713 #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
714 #define OFFSET(x) offsetof(AudioFIRContext, x)
715
716 static const AVOption afir_options[] = {
717     { "dry",    "set dry gain",      OFFSET(dry_gain),   AV_OPT_TYPE_FLOAT, {.dbl=1},    0, 10, AF },
718     { "wet",    "set wet gain",      OFFSET(wet_gain),   AV_OPT_TYPE_FLOAT, {.dbl=1},    0, 10, AF },
719     { "length", "set IR length",     OFFSET(length),     AV_OPT_TYPE_FLOAT, {.dbl=1},    0,  1, AF },
720     { "again",  "enable auto gain",  OFFSET(again),      AV_OPT_TYPE_BOOL,  {.i64=1},    0,  1, AF },
721     { "maxir",  "set max IR length", OFFSET(max_ir_len), AV_OPT_TYPE_FLOAT, {.dbl=30}, 0.1, 60, AF },
722     { "response", "show IR frequency response", OFFSET(response), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, VF },
723     { "channel", "set IR channel to display frequency response", OFFSET(ir_channel), AV_OPT_TYPE_INT, {.i64=0}, 0, 1024, VF },
724     { "size",   "set video size",    OFFSET(w),          AV_OPT_TYPE_IMAGE_SIZE, {.str = "hd720"}, 0, 0, VF },
725     { NULL }
726 };
727
728 AVFILTER_DEFINE_CLASS(afir);
729
730 AVFilter ff_af_afir = {
731     .name          = "afir",
732     .description   = NULL_IF_CONFIG_SMALL("Apply Finite Impulse Response filter with supplied coefficients in 2nd stream."),
733     .priv_size     = sizeof(AudioFIRContext),
734     .priv_class    = &afir_class,
735     .query_formats = query_formats,
736     .init          = init,
737     .uninit        = uninit,
738     .inputs        = afir_inputs,
739     .flags         = AVFILTER_FLAG_DYNAMIC_OUTPUTS |
740                      AVFILTER_FLAG_SLICE_THREADS,
741 };