GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/af_afir.c Lines: 14 553 2.5 %
Date: 2020-08-14 10:39:37 Branches: 2 307 0.7 %

Line Branch Exec Source
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/avstring.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 "filters.h"
39
#include "formats.h"
40
#include "internal.h"
41
#include "af_afir.h"
42
43
3
static void fcmul_add_c(float *sum, const float *t, const float *c, ptrdiff_t len)
44
{
45
    int n;
46
47
771
    for (n = 0; n < len; n++) {
48
768
        const float cre = c[2 * n    ];
49
768
        const float cim = c[2 * n + 1];
50
768
        const float tre = t[2 * n    ];
51
768
        const float tim = t[2 * n + 1];
52
53
768
        sum[2 * n    ] += tre * cre - tim * cim;
54
768
        sum[2 * n + 1] += tre * cim + tim * cre;
55
    }
56
57
3
    sum[2 * n] += t[2 * n] * c[2 * n];
58
3
}
59
60
static void direct(const float *in, const FFTComplex *ir, int len, float *out)
61
{
62
    for (int n = 0; n < len; n++)
63
        for (int m = 0; m <= n; m++)
64
            out[n] += ir[m].re * in[n - m];
65
}
66
67
static int fir_quantum(AVFilterContext *ctx, AVFrame *out, int ch, int offset)
68
{
69
    AudioFIRContext *s = ctx->priv;
70
    const float *in = (const float *)s->in->extended_data[ch] + offset;
71
    float *block, *buf, *ptr = (float *)out->extended_data[ch] + offset;
72
    const int nb_samples = FFMIN(s->min_part_size, out->nb_samples - offset);
73
    int n, i, j;
74
75
    for (int segment = 0; segment < s->nb_segments; segment++) {
76
        AudioFIRSegment *seg = &s->seg[segment];
77
        float *src = (float *)seg->input->extended_data[ch];
78
        float *dst = (float *)seg->output->extended_data[ch];
79
        float *sum = (float *)seg->sum->extended_data[ch];
80
81
        if (s->min_part_size >= 8) {
82
            s->fdsp->vector_fmul_scalar(src + seg->input_offset, in, s->dry_gain, FFALIGN(nb_samples, 4));
83
            emms_c();
84
        } else {
85
            for (n = 0; n < nb_samples; n++)
86
                src[seg->input_offset + n] = in[n] * s->dry_gain;
87
        }
88
89
        seg->output_offset[ch] += s->min_part_size;
90
        if (seg->output_offset[ch] == seg->part_size) {
91
            seg->output_offset[ch] = 0;
92
        } else {
93
            memmove(src, src + s->min_part_size, (seg->input_size - s->min_part_size) * sizeof(*src));
94
95
            dst += seg->output_offset[ch];
96
            for (n = 0; n < nb_samples; n++) {
97
                ptr[n] += dst[n];
98
            }
99
            continue;
100
        }
101
102
        if (seg->part_size < 8) {
103
            memset(dst, 0, sizeof(*dst) * seg->part_size * seg->nb_partitions);
104
105
            j = seg->part_index[ch];
106
107
            for (i = 0; i < seg->nb_partitions; i++) {
108
                const int coffset = j * seg->coeff_size;
109
                const FFTComplex *coeff = (const FFTComplex *)seg->coeff->extended_data[ch * !s->one2many] + coffset;
110
111
                direct(src, coeff, nb_samples, dst);
112
113
                if (j == 0)
114
                    j = seg->nb_partitions;
115
                j--;
116
            }
117
118
            seg->part_index[ch] = (seg->part_index[ch] + 1) % seg->nb_partitions;
119
120
            memmove(src, src + s->min_part_size, (seg->input_size - s->min_part_size) * sizeof(*src));
121
122
            for (n = 0; n < nb_samples; n++) {
123
                ptr[n] += dst[n];
124
            }
125
            continue;
126
        }
127
128
        memset(sum, 0, sizeof(*sum) * seg->fft_length);
129
        block = (float *)seg->block->extended_data[ch] + seg->part_index[ch] * seg->block_size;
130
        memset(block + seg->part_size, 0, sizeof(*block) * (seg->fft_length - seg->part_size));
131
132
        memcpy(block, src, sizeof(*src) * seg->part_size);
133
134
        av_rdft_calc(seg->rdft[ch], block);
135
        block[2 * seg->part_size] = block[1];
136
        block[1] = 0;
137
138
        j = seg->part_index[ch];
139
140
        for (i = 0; i < seg->nb_partitions; i++) {
141
            const int coffset = j * seg->coeff_size;
142
            const float *block = (const float *)seg->block->extended_data[ch] + i * seg->block_size;
143
            const FFTComplex *coeff = (const FFTComplex *)seg->coeff->extended_data[ch * !s->one2many] + coffset;
144
145
            s->afirdsp.fcmul_add(sum, block, (const float *)coeff, seg->part_size);
146
147
            if (j == 0)
148
                j = seg->nb_partitions;
149
            j--;
150
        }
151
152
        sum[1] = sum[2 * seg->part_size];
153
        av_rdft_calc(seg->irdft[ch], sum);
154
155
        buf = (float *)seg->buffer->extended_data[ch];
156
        for (n = 0; n < seg->part_size; n++) {
157
            buf[n] += sum[n];
158
        }
159
160
        memcpy(dst, buf, seg->part_size * sizeof(*dst));
161
162
        buf = (float *)seg->buffer->extended_data[ch];
163
        memcpy(buf, sum + seg->part_size, seg->part_size * sizeof(*buf));
164
165
        seg->part_index[ch] = (seg->part_index[ch] + 1) % seg->nb_partitions;
166
167
        memmove(src, src + s->min_part_size, (seg->input_size - s->min_part_size) * sizeof(*src));
168
169
        for (n = 0; n < nb_samples; n++) {
170
            ptr[n] += dst[n];
171
        }
172
    }
173
174
    if (s->min_part_size >= 8) {
175
        s->fdsp->vector_fmul_scalar(ptr, ptr, s->wet_gain, FFALIGN(nb_samples, 4));
176
        emms_c();
177
    } else {
178
        for (n = 0; n < nb_samples; n++)
179
            ptr[n] *= s->wet_gain;
180
    }
181
182
    return 0;
183
}
184
185
static int fir_channel(AVFilterContext *ctx, AVFrame *out, int ch)
186
{
187
    AudioFIRContext *s = ctx->priv;
188
189
    for (int offset = 0; offset < out->nb_samples; offset += s->min_part_size) {
190
        fir_quantum(ctx, out, ch, offset);
191
    }
192
193
    return 0;
194
}
195
196
static int fir_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
197
{
198
    AVFrame *out = arg;
199
    const int start = (out->channels * jobnr) / nb_jobs;
200
    const int end = (out->channels * (jobnr+1)) / nb_jobs;
201
202
    for (int ch = start; ch < end; ch++) {
203
        fir_channel(ctx, out, ch);
204
    }
205
206
    return 0;
207
}
208
209
static int fir_frame(AudioFIRContext *s, AVFrame *in, AVFilterLink *outlink)
210
{
211
    AVFilterContext *ctx = outlink->src;
212
    AVFrame *out = NULL;
213
214
    out = ff_get_audio_buffer(outlink, in->nb_samples);
215
    if (!out) {
216
        av_frame_free(&in);
217
        return AVERROR(ENOMEM);
218
    }
219
220
    if (s->pts == AV_NOPTS_VALUE)
221
        s->pts = in->pts;
222
    s->in = in;
223
    ctx->internal->execute(ctx, fir_channels, out, NULL, FFMIN(outlink->channels,
224
                                                               ff_filter_get_nb_threads(ctx)));
225
226
    out->pts = s->pts;
227
    if (s->pts != AV_NOPTS_VALUE)
228
        s->pts += av_rescale_q(out->nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
229
230
    av_frame_free(&in);
231
    s->in = NULL;
232
233
    return ff_filter_frame(outlink, out);
234
}
235
236
static void drawtext(AVFrame *pic, int x, int y, const char *txt, uint32_t color)
237
{
238
    const uint8_t *font;
239
    int font_height;
240
    int i;
241
242
    font = avpriv_cga_font, font_height = 8;
243
244
    for (i = 0; txt[i]; i++) {
245
        int char_y, mask;
246
247
        uint8_t *p = pic->data[0] + y * pic->linesize[0] + (x + i * 8) * 4;
248
        for (char_y = 0; char_y < font_height; char_y++) {
249
            for (mask = 0x80; mask; mask >>= 1) {
250
                if (font[txt[i] * font_height + char_y] & mask)
251
                    AV_WL32(p, color);
252
                p += 4;
253
            }
254
            p += pic->linesize[0] - 8 * 4;
255
        }
256
    }
257
}
258
259
static void draw_line(AVFrame *out, int x0, int y0, int x1, int y1, uint32_t color)
260
{
261
    int dx = FFABS(x1-x0);
262
    int dy = FFABS(y1-y0), sy = y0 < y1 ? 1 : -1;
263
    int err = (dx>dy ? dx : -dy) / 2, e2;
264
265
    for (;;) {
266
        AV_WL32(out->data[0] + y0 * out->linesize[0] + x0 * 4, color);
267
268
        if (x0 == x1 && y0 == y1)
269
            break;
270
271
        e2 = err;
272
273
        if (e2 >-dx) {
274
            err -= dy;
275
            x0--;
276
        }
277
278
        if (e2 < dy) {
279
            err += dx;
280
            y0 += sy;
281
        }
282
    }
283
}
284
285
static void draw_response(AVFilterContext *ctx, AVFrame *out)
286
{
287
    AudioFIRContext *s = ctx->priv;
288
    float *mag, *phase, *delay, min = FLT_MAX, max = FLT_MIN;
289
    float min_delay = FLT_MAX, max_delay = FLT_MIN;
290
    int prev_ymag = -1, prev_yphase = -1, prev_ydelay = -1;
291
    char text[32];
292
    int channel, i, x;
293
294
    memset(out->data[0], 0, s->h * out->linesize[0]);
295
296
    phase = av_malloc_array(s->w, sizeof(*phase));
297
    mag = av_malloc_array(s->w, sizeof(*mag));
298
    delay = av_malloc_array(s->w, sizeof(*delay));
299
    if (!mag || !phase || !delay)
300
        goto end;
301
302
    channel = av_clip(s->ir_channel, 0, s->ir[s->selir]->channels - 1);
303
    for (i = 0; i < s->w; i++) {
304
        const float *src = (const float *)s->ir[s->selir]->extended_data[channel];
305
        double w = i * M_PI / (s->w - 1);
306
        double div, real_num = 0., imag_num = 0., real = 0., imag = 0.;
307
308
        for (x = 0; x < s->nb_taps; x++) {
309
            real += cos(-x * w) * src[x];
310
            imag += sin(-x * w) * src[x];
311
            real_num += cos(-x * w) * src[x] * x;
312
            imag_num += sin(-x * w) * src[x] * x;
313
        }
314
315
        mag[i] = hypot(real, imag);
316
        phase[i] = atan2(imag, real);
317
        div = real * real + imag * imag;
318
        delay[i] = (real_num * real + imag_num * imag) / div;
319
        min = fminf(min, mag[i]);
320
        max = fmaxf(max, mag[i]);
321
        min_delay = fminf(min_delay, delay[i]);
322
        max_delay = fmaxf(max_delay, delay[i]);
323
    }
324
325
    for (i = 0; i < s->w; i++) {
326
        int ymag = mag[i] / max * (s->h - 1);
327
        int ydelay = (delay[i] - min_delay) / (max_delay - min_delay) * (s->h - 1);
328
        int yphase = (0.5 * (1. + phase[i] / M_PI)) * (s->h - 1);
329
330
        ymag = s->h - 1 - av_clip(ymag, 0, s->h - 1);
331
        yphase = s->h - 1 - av_clip(yphase, 0, s->h - 1);
332
        ydelay = s->h - 1 - av_clip(ydelay, 0, s->h - 1);
333
334
        if (prev_ymag < 0)
335
            prev_ymag = ymag;
336
        if (prev_yphase < 0)
337
            prev_yphase = yphase;
338
        if (prev_ydelay < 0)
339
            prev_ydelay = ydelay;
340
341
        draw_line(out, i,   ymag, FFMAX(i - 1, 0),   prev_ymag, 0xFFFF00FF);
342
        draw_line(out, i, yphase, FFMAX(i - 1, 0), prev_yphase, 0xFF00FF00);
343
        draw_line(out, i, ydelay, FFMAX(i - 1, 0), prev_ydelay, 0xFF00FFFF);
344
345
        prev_ymag   = ymag;
346
        prev_yphase = yphase;
347
        prev_ydelay = ydelay;
348
    }
349
350
    if (s->w > 400 && s->h > 100) {
351
        drawtext(out, 2, 2, "Max Magnitude:", 0xDDDDDDDD);
352
        snprintf(text, sizeof(text), "%.2f", max);
353
        drawtext(out, 15 * 8 + 2, 2, text, 0xDDDDDDDD);
354
355
        drawtext(out, 2, 12, "Min Magnitude:", 0xDDDDDDDD);
356
        snprintf(text, sizeof(text), "%.2f", min);
357
        drawtext(out, 15 * 8 + 2, 12, text, 0xDDDDDDDD);
358
359
        drawtext(out, 2, 22, "Max Delay:", 0xDDDDDDDD);
360
        snprintf(text, sizeof(text), "%.2f", max_delay);
361
        drawtext(out, 11 * 8 + 2, 22, text, 0xDDDDDDDD);
362
363
        drawtext(out, 2, 32, "Min Delay:", 0xDDDDDDDD);
364
        snprintf(text, sizeof(text), "%.2f", min_delay);
365
        drawtext(out, 11 * 8 + 2, 32, text, 0xDDDDDDDD);
366
    }
367
368
end:
369
    av_free(delay);
370
    av_free(phase);
371
    av_free(mag);
372
}
373
374
static int init_segment(AVFilterContext *ctx, AudioFIRSegment *seg,
375
                        int offset, int nb_partitions, int part_size)
376
{
377
    AudioFIRContext *s = ctx->priv;
378
379
    seg->rdft  = av_calloc(ctx->inputs[0]->channels, sizeof(*seg->rdft));
380
    seg->irdft = av_calloc(ctx->inputs[0]->channels, sizeof(*seg->irdft));
381
    if (!seg->rdft || !seg->irdft)
382
        return AVERROR(ENOMEM);
383
384
    seg->fft_length    = part_size * 2 + 1;
385
    seg->part_size     = part_size;
386
    seg->block_size    = FFALIGN(seg->fft_length, 32);
387
    seg->coeff_size    = FFALIGN(seg->part_size + 1, 32);
388
    seg->nb_partitions = nb_partitions;
389
    seg->input_size    = offset + s->min_part_size;
390
    seg->input_offset  = offset;
391
392
    seg->part_index    = av_calloc(ctx->inputs[0]->channels, sizeof(*seg->part_index));
393
    seg->output_offset = av_calloc(ctx->inputs[0]->channels, sizeof(*seg->output_offset));
394
    if (!seg->part_index || !seg->output_offset)
395
        return AVERROR(ENOMEM);
396
397
    for (int ch = 0; ch < ctx->inputs[0]->channels && part_size >= 8; ch++) {
398
        seg->rdft[ch]  = av_rdft_init(av_log2(2 * part_size), DFT_R2C);
399
        seg->irdft[ch] = av_rdft_init(av_log2(2 * part_size), IDFT_C2R);
400
        if (!seg->rdft[ch] || !seg->irdft[ch])
401
            return AVERROR(ENOMEM);
402
    }
403
404
    seg->sum    = ff_get_audio_buffer(ctx->inputs[0], seg->fft_length);
405
    seg->block  = ff_get_audio_buffer(ctx->inputs[0], seg->nb_partitions * seg->block_size);
406
    seg->buffer = ff_get_audio_buffer(ctx->inputs[0], seg->part_size);
407
    seg->coeff  = ff_get_audio_buffer(ctx->inputs[1 + s->selir], seg->nb_partitions * seg->coeff_size * 2);
408
    seg->input  = ff_get_audio_buffer(ctx->inputs[0], seg->input_size);
409
    seg->output = ff_get_audio_buffer(ctx->inputs[0], seg->part_size);
410
    if (!seg->buffer || !seg->sum || !seg->block || !seg->coeff || !seg->input || !seg->output)
411
        return AVERROR(ENOMEM);
412
413
    return 0;
414
}
415
416
static void uninit_segment(AVFilterContext *ctx, AudioFIRSegment *seg)
417
{
418
    AudioFIRContext *s = ctx->priv;
419
420
    if (seg->rdft) {
421
        for (int ch = 0; ch < s->nb_channels; ch++) {
422
            av_rdft_end(seg->rdft[ch]);
423
        }
424
    }
425
    av_freep(&seg->rdft);
426
427
    if (seg->irdft) {
428
        for (int ch = 0; ch < s->nb_channels; ch++) {
429
            av_rdft_end(seg->irdft[ch]);
430
        }
431
    }
432
    av_freep(&seg->irdft);
433
434
    av_freep(&seg->output_offset);
435
    av_freep(&seg->part_index);
436
437
    av_frame_free(&seg->block);
438
    av_frame_free(&seg->sum);
439
    av_frame_free(&seg->buffer);
440
    av_frame_free(&seg->coeff);
441
    av_frame_free(&seg->input);
442
    av_frame_free(&seg->output);
443
    seg->input_size = 0;
444
}
445
446
static int convert_coeffs(AVFilterContext *ctx)
447
{
448
    AudioFIRContext *s = ctx->priv;
449
    int ret, i, ch, n, cur_nb_taps;
450
    float power = 0;
451
452
    if (!s->nb_taps) {
453
        int part_size, max_part_size;
454
        int left, offset = 0;
455
456
        s->nb_taps = ff_inlink_queued_samples(ctx->inputs[1 + s->selir]);
457
        if (s->nb_taps <= 0)
458
            return AVERROR(EINVAL);
459
460
        if (s->minp > s->maxp) {
461
            s->maxp = s->minp;
462
        }
463
464
        left = s->nb_taps;
465
        part_size = 1 << av_log2(s->minp);
466
        max_part_size = 1 << av_log2(s->maxp);
467
468
        s->min_part_size = part_size;
469
470
        for (i = 0; left > 0; i++) {
471
            int step = part_size == max_part_size ? INT_MAX : 1 + (i == 0);
472
            int nb_partitions = FFMIN(step, (left + part_size - 1) / part_size);
473
474
            s->nb_segments = i + 1;
475
            ret = init_segment(ctx, &s->seg[i], offset, nb_partitions, part_size);
476
            if (ret < 0)
477
                return ret;
478
            offset += nb_partitions * part_size;
479
            left -= nb_partitions * part_size;
480
            part_size *= 2;
481
            part_size = FFMIN(part_size, max_part_size);
482
        }
483
    }
484
485
    if (!s->ir[s->selir]) {
486
        ret = ff_inlink_consume_samples(ctx->inputs[1 + s->selir], s->nb_taps, s->nb_taps, &s->ir[s->selir]);
487
        if (ret < 0)
488
            return ret;
489
        if (ret == 0)
490
            return AVERROR_BUG;
491
    }
492
493
    if (s->response)
494
        draw_response(ctx, s->video);
495
496
    s->gain = 1;
497
    cur_nb_taps = s->ir[s->selir]->nb_samples;
498
499
    switch (s->gtype) {
500
    case -1:
501
        /* nothing to do */
502
        break;
503
    case 0:
504
        for (ch = 0; ch < ctx->inputs[1 + s->selir]->channels; ch++) {
505
            float *time = (float *)s->ir[s->selir]->extended_data[!s->one2many * ch];
506
507
            for (i = 0; i < cur_nb_taps; i++)
508
                power += FFABS(time[i]);
509
        }
510
        s->gain = ctx->inputs[1 + s->selir]->channels / power;
511
        break;
512
    case 1:
513
        for (ch = 0; ch < ctx->inputs[1 + s->selir]->channels; ch++) {
514
            float *time = (float *)s->ir[s->selir]->extended_data[!s->one2many * ch];
515
516
            for (i = 0; i < cur_nb_taps; i++)
517
                power += time[i];
518
        }
519
        s->gain = ctx->inputs[1 + s->selir]->channels / power;
520
        break;
521
    case 2:
522
        for (ch = 0; ch < ctx->inputs[1 + s->selir]->channels; ch++) {
523
            float *time = (float *)s->ir[s->selir]->extended_data[!s->one2many * ch];
524
525
            for (i = 0; i < cur_nb_taps; i++)
526
                power += time[i] * time[i];
527
        }
528
        s->gain = sqrtf(ch / power);
529
        break;
530
    default:
531
        return AVERROR_BUG;
532
    }
533
534
    s->gain = FFMIN(s->gain * s->ir_gain, 1.f);
535
    av_log(ctx, AV_LOG_DEBUG, "power %f, gain %f\n", power, s->gain);
536
    for (ch = 0; ch < ctx->inputs[1 + s->selir]->channels; ch++) {
537
        float *time = (float *)s->ir[s->selir]->extended_data[!s->one2many * ch];
538
539
        s->fdsp->vector_fmul_scalar(time, time, s->gain, FFALIGN(cur_nb_taps, 4));
540
    }
541
542
    av_log(ctx, AV_LOG_DEBUG, "nb_taps: %d\n", cur_nb_taps);
543
    av_log(ctx, AV_LOG_DEBUG, "nb_segments: %d\n", s->nb_segments);
544
545
    for (ch = 0; ch < ctx->inputs[1 + s->selir]->channels; ch++) {
546
        float *time = (float *)s->ir[s->selir]->extended_data[!s->one2many * ch];
547
        int toffset = 0;
548
549
        for (i = FFMAX(1, s->length * s->nb_taps); i < s->nb_taps; i++)
550
            time[i] = 0;
551
552
        av_log(ctx, AV_LOG_DEBUG, "channel: %d\n", ch);
553
554
        for (int segment = 0; segment < s->nb_segments; segment++) {
555
            AudioFIRSegment *seg = &s->seg[segment];
556
            float *block = (float *)seg->block->extended_data[ch];
557
            FFTComplex *coeff = (FFTComplex *)seg->coeff->extended_data[ch];
558
559
            av_log(ctx, AV_LOG_DEBUG, "segment: %d\n", segment);
560
561
            for (i = 0; i < seg->nb_partitions; i++) {
562
                const float scale = 1.f / seg->part_size;
563
                const int coffset = i * seg->coeff_size;
564
                const int remaining = s->nb_taps - toffset;
565
                const int size = remaining >= seg->part_size ? seg->part_size : remaining;
566
567
                if (size < 8) {
568
                    for (n = 0; n < size; n++)
569
                        coeff[coffset + n].re = time[toffset + n];
570
571
                    toffset += size;
572
                    continue;
573
                }
574
575
                memset(block, 0, sizeof(*block) * seg->fft_length);
576
                memcpy(block, time + toffset, size * sizeof(*block));
577
578
                av_rdft_calc(seg->rdft[0], block);
579
580
                coeff[coffset].re = block[0] * scale;
581
                coeff[coffset].im = 0;
582
                for (n = 1; n < seg->part_size; n++) {
583
                    coeff[coffset + n].re = block[2 * n] * scale;
584
                    coeff[coffset + n].im = block[2 * n + 1] * scale;
585
                }
586
                coeff[coffset + seg->part_size].re = block[1] * scale;
587
                coeff[coffset + seg->part_size].im = 0;
588
589
                toffset += size;
590
            }
591
592
            av_log(ctx, AV_LOG_DEBUG, "nb_partitions: %d\n", seg->nb_partitions);
593
            av_log(ctx, AV_LOG_DEBUG, "partition size: %d\n", seg->part_size);
594
            av_log(ctx, AV_LOG_DEBUG, "block size: %d\n", seg->block_size);
595
            av_log(ctx, AV_LOG_DEBUG, "fft_length: %d\n", seg->fft_length);
596
            av_log(ctx, AV_LOG_DEBUG, "coeff_size: %d\n", seg->coeff_size);
597
            av_log(ctx, AV_LOG_DEBUG, "input_size: %d\n", seg->input_size);
598
            av_log(ctx, AV_LOG_DEBUG, "input_offset: %d\n", seg->input_offset);
599
        }
600
    }
601
602
    s->have_coeffs = 1;
603
604
    return 0;
605
}
606
607
static int check_ir(AVFilterLink *link, AVFrame *frame)
608
{
609
    AVFilterContext *ctx = link->dst;
610
    AudioFIRContext *s = ctx->priv;
611
    int nb_taps, max_nb_taps;
612
613
    nb_taps = ff_inlink_queued_samples(link);
614
    max_nb_taps = s->max_ir_len * ctx->outputs[0]->sample_rate;
615
    if (nb_taps > max_nb_taps) {
616
        av_log(ctx, AV_LOG_ERROR, "Too big number of coefficients: %d > %d.\n", nb_taps, max_nb_taps);
617
        return AVERROR(EINVAL);
618
    }
619
620
    return 0;
621
}
622
623
static int activate(AVFilterContext *ctx)
624
{
625
    AudioFIRContext *s = ctx->priv;
626
    AVFilterLink *outlink = ctx->outputs[0];
627
    int ret, status, available, wanted;
628
    AVFrame *in = NULL;
629
    int64_t pts;
630
631
    FF_FILTER_FORWARD_STATUS_BACK_ALL(ctx->outputs[0], ctx);
632
    if (s->response)
633
        FF_FILTER_FORWARD_STATUS_BACK_ALL(ctx->outputs[1], ctx);
634
    if (!s->eof_coeffs[s->selir]) {
635
        AVFrame *ir = NULL;
636
637
        ret = check_ir(ctx->inputs[1 + s->selir], ir);
638
        if (ret < 0)
639
            return ret;
640
641
        if (ff_outlink_get_status(ctx->inputs[1 + s->selir]) == AVERROR_EOF)
642
            s->eof_coeffs[s->selir] = 1;
643
644
        if (!s->eof_coeffs[s->selir]) {
645
            if (ff_outlink_frame_wanted(ctx->outputs[0]))
646
                ff_inlink_request_frame(ctx->inputs[1 + s->selir]);
647
            else if (s->response && ff_outlink_frame_wanted(ctx->outputs[1]))
648
                ff_inlink_request_frame(ctx->inputs[1 + s->selir]);
649
            return 0;
650
        }
651
    }
652
653
    if (!s->have_coeffs && s->eof_coeffs[s->selir]) {
654
        ret = convert_coeffs(ctx);
655
        if (ret < 0)
656
            return ret;
657
    }
658
659
    available = ff_inlink_queued_samples(ctx->inputs[0]);
660
    wanted = FFMAX(s->min_part_size, (available / s->min_part_size) * s->min_part_size);
661
    ret = ff_inlink_consume_samples(ctx->inputs[0], wanted, wanted, &in);
662
    if (ret > 0)
663
        ret = fir_frame(s, in, outlink);
664
665
    if (ret < 0)
666
        return ret;
667
668
    if (s->response && s->have_coeffs) {
669
        int64_t old_pts = s->video->pts;
670
        int64_t new_pts = av_rescale_q(s->pts, ctx->inputs[0]->time_base, ctx->outputs[1]->time_base);
671
672
        if (ff_outlink_frame_wanted(ctx->outputs[1]) && old_pts < new_pts) {
673
            AVFrame *clone;
674
            s->video->pts = new_pts;
675
            clone = av_frame_clone(s->video);
676
            if (!clone)
677
                return AVERROR(ENOMEM);
678
            return ff_filter_frame(ctx->outputs[1], clone);
679
        }
680
    }
681
682
    if (ff_inlink_queued_samples(ctx->inputs[0]) >= s->min_part_size) {
683
        ff_filter_set_ready(ctx, 10);
684
        return 0;
685
    }
686
687
    if (ff_inlink_acknowledge_status(ctx->inputs[0], &status, &pts)) {
688
        if (status == AVERROR_EOF) {
689
            ff_outlink_set_status(ctx->outputs[0], status, pts);
690
            if (s->response)
691
                ff_outlink_set_status(ctx->outputs[1], status, pts);
692
            return 0;
693
        }
694
    }
695
696
    if (ff_outlink_frame_wanted(ctx->outputs[0]) &&
697
        !ff_outlink_get_status(ctx->inputs[0])) {
698
        ff_inlink_request_frame(ctx->inputs[0]);
699
        return 0;
700
    }
701
702
    if (s->response &&
703
        ff_outlink_frame_wanted(ctx->outputs[1]) &&
704
        !ff_outlink_get_status(ctx->inputs[0])) {
705
        ff_inlink_request_frame(ctx->inputs[0]);
706
        return 0;
707
    }
708
709
    return FFERROR_NOT_READY;
710
}
711
712
static int query_formats(AVFilterContext *ctx)
713
{
714
    AudioFIRContext *s = ctx->priv;
715
    AVFilterFormats *formats;
716
    AVFilterChannelLayouts *layouts;
717
    static const enum AVSampleFormat sample_fmts[] = {
718
        AV_SAMPLE_FMT_FLTP,
719
        AV_SAMPLE_FMT_NONE
720
    };
721
    static const enum AVPixelFormat pix_fmts[] = {
722
        AV_PIX_FMT_RGB0,
723
        AV_PIX_FMT_NONE
724
    };
725
    int ret;
726
727
    if (s->response) {
728
        AVFilterLink *videolink = ctx->outputs[1];
729
        formats = ff_make_format_list(pix_fmts);
730
        if ((ret = ff_formats_ref(formats, &videolink->in_formats)) < 0)
731
            return ret;
732
    }
733
734
    layouts = ff_all_channel_counts();
735
    if (!layouts)
736
        return AVERROR(ENOMEM);
737
738
    if (s->ir_format) {
739
        ret = ff_set_common_channel_layouts(ctx, layouts);
740
        if (ret < 0)
741
            return ret;
742
    } else {
743
        AVFilterChannelLayouts *mono = NULL;
744
745
        ret = ff_add_channel_layout(&mono, AV_CH_LAYOUT_MONO);
746
        if (ret)
747
            return ret;
748
749
        if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->out_channel_layouts)) < 0)
750
            return ret;
751
        if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0)
752
            return ret;
753
        for (int i = 1; i < ctx->nb_inputs; i++) {
754
            if ((ret = ff_channel_layouts_ref(mono, &ctx->inputs[i]->out_channel_layouts)) < 0)
755
                return ret;
756
        }
757
    }
758
759
    formats = ff_make_format_list(sample_fmts);
760
    if ((ret = ff_set_common_formats(ctx, formats)) < 0)
761
        return ret;
762
763
    formats = ff_all_samplerates();
764
    return ff_set_common_samplerates(ctx, formats);
765
}
766
767
static int config_output(AVFilterLink *outlink)
768
{
769
    AVFilterContext *ctx = outlink->src;
770
    AudioFIRContext *s = ctx->priv;
771
772
    s->one2many = ctx->inputs[1 + s->selir]->channels == 1;
773
    outlink->sample_rate = ctx->inputs[0]->sample_rate;
774
    outlink->time_base   = ctx->inputs[0]->time_base;
775
    outlink->channel_layout = ctx->inputs[0]->channel_layout;
776
    outlink->channels = ctx->inputs[0]->channels;
777
778
    s->nb_channels = outlink->channels;
779
    s->nb_coef_channels = ctx->inputs[1 + s->selir]->channels;
780
    s->pts = AV_NOPTS_VALUE;
781
782
    return 0;
783
}
784
785
static av_cold void uninit(AVFilterContext *ctx)
786
{
787
    AudioFIRContext *s = ctx->priv;
788
789
    for (int i = 0; i < s->nb_segments; i++) {
790
        uninit_segment(ctx, &s->seg[i]);
791
    }
792
793
    av_freep(&s->fdsp);
794
795
    for (int i = 0; i < s->nb_irs; i++) {
796
        av_frame_free(&s->ir[i]);
797
    }
798
799
    for (int i = 0; i < ctx->nb_inputs; i++)
800
        av_freep(&ctx->input_pads[i].name);
801
802
    for (int i = 0; i < ctx->nb_outputs; i++)
803
        av_freep(&ctx->output_pads[i].name);
804
    av_frame_free(&s->video);
805
}
806
807
static int config_video(AVFilterLink *outlink)
808
{
809
    AVFilterContext *ctx = outlink->src;
810
    AudioFIRContext *s = ctx->priv;
811
812
    outlink->sample_aspect_ratio = (AVRational){1,1};
813
    outlink->w = s->w;
814
    outlink->h = s->h;
815
    outlink->frame_rate = s->frame_rate;
816
    outlink->time_base = av_inv_q(outlink->frame_rate);
817
818
    av_frame_free(&s->video);
819
    s->video = ff_get_video_buffer(outlink, outlink->w, outlink->h);
820
    if (!s->video)
821
        return AVERROR(ENOMEM);
822
823
    return 0;
824
}
825
826
13
void ff_afir_init(AudioFIRDSPContext *dsp)
827
{
828
13
    dsp->fcmul_add = fcmul_add_c;
829
830
    if (ARCH_X86)
831
13
        ff_afir_init_x86(dsp);
832
13
}
833
834
static av_cold int init(AVFilterContext *ctx)
835
{
836
    AudioFIRContext *s = ctx->priv;
837
    AVFilterPad pad, vpad;
838
    int ret;
839
840
    pad = (AVFilterPad) {
841
        .name = av_strdup("main"),
842
        .type = AVMEDIA_TYPE_AUDIO,
843
    };
844
845
    if (!pad.name)
846
        return AVERROR(ENOMEM);
847
848
    ret = ff_insert_inpad(ctx, 0, &pad);
849
    if (ret < 0) {
850
        av_freep(&pad.name);
851
        return ret;
852
    }
853
854
    for (int n = 0; n < s->nb_irs; n++) {
855
        pad = (AVFilterPad) {
856
            .name = av_asprintf("ir%d", n),
857
            .type = AVMEDIA_TYPE_AUDIO,
858
        };
859
860
        if (!pad.name)
861
            return AVERROR(ENOMEM);
862
863
        ret = ff_insert_inpad(ctx, n + 1, &pad);
864
        if (ret < 0) {
865
            av_freep(&pad.name);
866
            return ret;
867
        }
868
    }
869
870
    pad = (AVFilterPad) {
871
        .name          = av_strdup("default"),
872
        .type          = AVMEDIA_TYPE_AUDIO,
873
        .config_props  = config_output,
874
    };
875
876
    if (!pad.name)
877
        return AVERROR(ENOMEM);
878
879
    ret = ff_insert_outpad(ctx, 0, &pad);
880
    if (ret < 0) {
881
        av_freep(&pad.name);
882
        return ret;
883
    }
884
885
    if (s->response) {
886
        vpad = (AVFilterPad){
887
            .name         = av_strdup("filter_response"),
888
            .type         = AVMEDIA_TYPE_VIDEO,
889
            .config_props = config_video,
890
        };
891
        if (!vpad.name)
892
            return AVERROR(ENOMEM);
893
894
        ret = ff_insert_outpad(ctx, 1, &vpad);
895
        if (ret < 0) {
896
            av_freep(&vpad.name);
897
            return ret;
898
        }
899
    }
900
901
    s->fdsp = avpriv_float_dsp_alloc(0);
902
    if (!s->fdsp)
903
        return AVERROR(ENOMEM);
904
905
    ff_afir_init(&s->afirdsp);
906
907
    return 0;
908
}
909
910
static int process_command(AVFilterContext *ctx,
911
                           const char *cmd,
912
                           const char *arg,
913
                           char *res,
914
                           int res_len,
915
                           int flags)
916
{
917
    AudioFIRContext *s = ctx->priv;
918
    int prev_ir = s->selir;
919
    int ret = ff_filter_process_command(ctx, cmd, arg, res, res_len, flags);
920
921
    if (ret < 0)
922
        return ret;
923
924
    s->selir = FFMIN(s->nb_irs - 1, s->selir);
925
926
    if (prev_ir != s->selir) {
927
        s->have_coeffs = 0;
928
    }
929
930
    return 0;
931
}
932
933
#define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
934
#define AFR AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
935
#define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
936
#define OFFSET(x) offsetof(AudioFIRContext, x)
937
938
static const AVOption afir_options[] = {
939
    { "dry",    "set dry gain",      OFFSET(dry_gain),   AV_OPT_TYPE_FLOAT, {.dbl=1},    0, 10, AF },
940
    { "wet",    "set wet gain",      OFFSET(wet_gain),   AV_OPT_TYPE_FLOAT, {.dbl=1},    0, 10, AF },
941
    { "length", "set IR length",     OFFSET(length),     AV_OPT_TYPE_FLOAT, {.dbl=1},    0,  1, AF },
942
    { "gtype",  "set IR auto gain type",OFFSET(gtype),   AV_OPT_TYPE_INT,   {.i64=0},   -1,  2, AF, "gtype" },
943
    {  "none",  "without auto gain", 0,                  AV_OPT_TYPE_CONST, {.i64=-1},   0,  0, AF, "gtype" },
944
    {  "peak",  "peak gain",         0,                  AV_OPT_TYPE_CONST, {.i64=0},    0,  0, AF, "gtype" },
945
    {  "dc",    "DC gain",           0,                  AV_OPT_TYPE_CONST, {.i64=1},    0,  0, AF, "gtype" },
946
    {  "gn",    "gain to noise",     0,                  AV_OPT_TYPE_CONST, {.i64=2},    0,  0, AF, "gtype" },
947
    { "irgain", "set IR gain",       OFFSET(ir_gain),    AV_OPT_TYPE_FLOAT, {.dbl=1},    0,  1, AF },
948
    { "irfmt",  "set IR format",     OFFSET(ir_format),  AV_OPT_TYPE_INT,   {.i64=1},    0,  1, AF, "irfmt" },
949
    {  "mono",  "single channel",    0,                  AV_OPT_TYPE_CONST, {.i64=0},    0,  0, AF, "irfmt" },
950
    {  "input", "same as input",     0,                  AV_OPT_TYPE_CONST, {.i64=1},    0,  0, AF, "irfmt" },
951
    { "maxir",  "set max IR length", OFFSET(max_ir_len), AV_OPT_TYPE_FLOAT, {.dbl=30}, 0.1, 60, AF },
952
    { "response", "show IR frequency response", OFFSET(response), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, VF },
953
    { "channel", "set IR channel to display frequency response", OFFSET(ir_channel), AV_OPT_TYPE_INT, {.i64=0}, 0, 1024, VF },
954
    { "size",   "set video size",    OFFSET(w),          AV_OPT_TYPE_IMAGE_SIZE, {.str = "hd720"}, 0, 0, VF },
955
    { "rate",   "set video rate",    OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT32_MAX, VF },
956
    { "minp",   "set min partition size", OFFSET(minp),  AV_OPT_TYPE_INT,   {.i64=8192}, 1, 32768, AF },
957
    { "maxp",   "set max partition size", OFFSET(maxp),  AV_OPT_TYPE_INT,   {.i64=8192}, 8, 32768, AF },
958
    { "nbirs",  "set number of input IRs",OFFSET(nb_irs),AV_OPT_TYPE_INT,   {.i64=1},    1,    32, AF },
959
    { "ir",     "select IR",              OFFSET(selir), AV_OPT_TYPE_INT,   {.i64=0},    0,    31, AFR },
960
    { NULL }
961
};
962
963
AVFILTER_DEFINE_CLASS(afir);
964
965
AVFilter ff_af_afir = {
966
    .name          = "afir",
967
    .description   = NULL_IF_CONFIG_SMALL("Apply Finite Impulse Response filter with supplied coefficients in additional stream(s)."),
968
    .priv_size     = sizeof(AudioFIRContext),
969
    .priv_class    = &afir_class,
970
    .query_formats = query_formats,
971
    .init          = init,
972
    .activate      = activate,
973
    .uninit        = uninit,
974
    .process_command = process_command,
975
    .flags         = AVFILTER_FLAG_DYNAMIC_INPUTS  |
976
                     AVFILTER_FLAG_DYNAMIC_OUTPUTS |
977
                     AVFILTER_FLAG_SLICE_THREADS,
978
};