FFmpeg coverage

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/cpu.h"
29			#include "libavutil/mem.h"
30			#include "libavutil/tx.h"
31			#include "libavutil/avstring.h"
32			#include "libavutil/channel_layout.h"
33			#include "libavutil/float_dsp.h"
34			#include "libavutil/frame.h"
35			#include "libavutil/log.h"
36			#include "libavutil/opt.h"
37
38			#include "audio.h"
39			#include "avfilter.h"
40			#include "filters.h"
41			#include "formats.h"
42			#include "internal.h"
43			#include "af_afir.h"
44			#include "af_afirdsp.h"
45
46			#define DEPTH 32
47			#include "afir_template.c"
48
49			#undef DEPTH
50			#define DEPTH 64
51			#include "afir_template.c"
52
53		✗	static int fir_channel(AVFilterContext *ctx, AVFrame *out, int ch)
54			{
55		✗	AudioFIRContext *s = ctx->priv;
56		✗	const int min_part_size = s->min_part_size;
57		✗	const int prev_selir = s->prev_selir;
58		✗	const int selir = s->selir;
59
60		✗	for (int offset = 0; offset < out->nb_samples; offset += min_part_size) {
61		✗	switch (s->format) {
62		✗	case AV_SAMPLE_FMT_FLTP:
63		✗	fir_quantums_float(ctx, s, out, min_part_size, ch, offset, prev_selir, selir);
64		✗	break;
65		✗	case AV_SAMPLE_FMT_DBLP:
66		✗	fir_quantums_double(ctx, s, out, min_part_size, ch, offset, prev_selir, selir);
67		✗	break;
68			}
69
70		✗	if (selir != prev_selir && s->loading[ch] != 0)
71		✗	s->loading[ch] += min_part_size;
72			}
73
74		✗	return 0;
75			}
76
77		✗	static int fir_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
78			{
79		✗	AVFrame *out = arg;
80		✗	const int start = (out->ch_layout.nb_channels * jobnr) / nb_jobs;
81		✗	const int end = (out->ch_layout.nb_channels * (jobnr+1)) / nb_jobs;
82
83		✗	for (int ch = start; ch < end; ch++)
84		✗	fir_channel(ctx, out, ch);
85
86		✗	return 0;
87			}
88
89		✗	static int fir_frame(AudioFIRContext *s, AVFrame *in, AVFilterLink *outlink)
90			{
91		✗	AVFilterContext *ctx = outlink->src;
92			AVFrame *out;
93
94		✗	out = ff_get_audio_buffer(outlink, in->nb_samples);
95		✗	if (!out) {
96		✗	av_frame_free(&in);
97		✗	return AVERROR(ENOMEM);
98			}
99		✗	av_frame_copy_props(out, in);
100		✗	out->pts = s->pts = in->pts;
101
102		✗	s->in = in;
103		✗	ff_filter_execute(ctx, fir_channels, out, NULL,
104		✗	FFMIN(outlink->ch_layout.nb_channels, ff_filter_get_nb_threads(ctx)));
105		✗	s->prev_is_disabled = ctx->is_disabled;
106
107		✗	av_frame_free(&in);
108		✗	s->in = NULL;
109
110		✗	return ff_filter_frame(outlink, out);
111			}
112
113		✗	static int init_segment(AVFilterContext *ctx, AudioFIRSegment *seg, int selir,
114			int offset, int nb_partitions, int part_size, int index)
115			{
116		✗	AudioFIRContext *s = ctx->priv;
117		✗	const size_t cpu_align = av_cpu_max_align();
118			union { double d; float f; } cscale, scale, iscale;
119			enum AVTXType tx_type;
120			int ret;
121
122		✗	seg->tx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->tx));
123		✗	seg->ctx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->ctx));
124		✗	seg->itx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->itx));
125		✗	if (!seg->tx || !seg->ctx || !seg->itx)
126		✗	return AVERROR(ENOMEM);
127
128		✗	seg->fft_length = (part_size + 1) * 2;
129		✗	seg->part_size = part_size;
130		✗	seg->coeff_size = FFALIGN(seg->part_size + 1, cpu_align);
131		✗	seg->block_size = FFMAX(seg->coeff_size * 2, FFALIGN(seg->fft_length, cpu_align));
132		✗	seg->nb_partitions = nb_partitions;
133		✗	seg->input_size = offset + s->min_part_size;
134		✗	seg->input_offset = offset;
135
136		✗	seg->part_index = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->part_index));
137		✗	seg->output_offset = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->output_offset));
138		✗	if (!seg->part_index || !seg->output_offset)
139		✗	return AVERROR(ENOMEM);
140
141		✗	switch (s->format) {
142		✗	case AV_SAMPLE_FMT_FLTP:
143		✗	cscale.f = 1.f;
144		✗	scale.f = 1.f / sqrtf(2.f * part_size);
145		✗	iscale.f = 1.f / sqrtf(2.f * part_size);
146		✗	tx_type = AV_TX_FLOAT_RDFT;
147		✗	break;
148		✗	case AV_SAMPLE_FMT_DBLP:
149		✗	cscale.d = 1.0;
150		✗	scale.d = 1.0 / sqrt(2.0 * part_size);
151		✗	iscale.d = 1.0 / sqrt(2.0 * part_size);
152		✗	tx_type = AV_TX_DOUBLE_RDFT;
153		✗	break;
154			}
155
156		✗	for (int ch = 0; ch < ctx->inputs[0]->ch_layout.nb_channels && part_size >= 1; ch++) {
157		✗	ret = av_tx_init(&seg->ctx[ch], &seg->ctx_fn, tx_type,
158			0, 2 * part_size, &cscale, 0);
159		✗	if (ret < 0)
160		✗	return ret;
161
162		✗	ret = av_tx_init(&seg->tx[ch], &seg->tx_fn, tx_type,
163			0, 2 * part_size, &scale, 0);
164		✗	if (ret < 0)
165		✗	return ret;
166		✗	ret = av_tx_init(&seg->itx[ch], &seg->itx_fn, tx_type,
167			1, 2 * part_size, &iscale, 0);
168		✗	if (ret < 0)
169		✗	return ret;
170			}
171
172		✗	seg->sumin = ff_get_audio_buffer(ctx->inputs[0], seg->fft_length);
173		✗	seg->sumout = ff_get_audio_buffer(ctx->inputs[0], seg->fft_length);
174		✗	seg->blockout = ff_get_audio_buffer(ctx->inputs[0], seg->block_size * seg->nb_partitions);
175		✗	seg->tempin = ff_get_audio_buffer(ctx->inputs[0], seg->block_size);
176		✗	seg->tempout = ff_get_audio_buffer(ctx->inputs[0], seg->block_size);
177		✗	seg->buffer = ff_get_audio_buffer(ctx->inputs[0], seg->part_size);
178		✗	seg->input = ff_get_audio_buffer(ctx->inputs[0], seg->input_size);
179		✗	seg->output = ff_get_audio_buffer(ctx->inputs[0], seg->part_size * 5);
180		✗	if (!seg->buffer || !seg->sumin || !seg->sumout || !seg->blockout ||
181		✗	!seg->input || !seg->output || !seg->tempin || !seg->tempout)
182		✗	return AVERROR(ENOMEM);
183
184		✗	return 0;
185			}
186
187		✗	static void uninit_segment(AVFilterContext *ctx, AudioFIRSegment *seg)
188			{
189		✗	AudioFIRContext *s = ctx->priv;
190
191		✗	if (seg->ctx) {
192		✗	for (int ch = 0; ch < s->nb_channels; ch++)
193		✗	av_tx_uninit(&seg->ctx[ch]);
194			}
195		✗	av_freep(&seg->ctx);
196
197		✗	if (seg->tx) {
198		✗	for (int ch = 0; ch < s->nb_channels; ch++)
199		✗	av_tx_uninit(&seg->tx[ch]);
200			}
201		✗	av_freep(&seg->tx);
202
203		✗	if (seg->itx) {
204		✗	for (int ch = 0; ch < s->nb_channels; ch++)
205		✗	av_tx_uninit(&seg->itx[ch]);
206			}
207		✗	av_freep(&seg->itx);
208
209		✗	av_freep(&seg->output_offset);
210		✗	av_freep(&seg->part_index);
211
212		✗	av_frame_free(&seg->tempin);
213		✗	av_frame_free(&seg->tempout);
214		✗	av_frame_free(&seg->blockout);
215		✗	av_frame_free(&seg->sumin);
216		✗	av_frame_free(&seg->sumout);
217		✗	av_frame_free(&seg->buffer);
218		✗	av_frame_free(&seg->input);
219		✗	av_frame_free(&seg->output);
220		✗	seg->input_size = 0;
221
222		✗	for (int i = 0; i < MAX_IR_STREAMS; i++)
223		✗	av_frame_free(&seg->coeff);
224		✗	}
225
226		✗	static int convert_coeffs(AVFilterContext *ctx, int selir)
227			{
228		✗	AudioFIRContext *s = ctx->priv;
229			int ret, nb_taps, cur_nb_taps;
230
231		✗	if (!s->nb_taps[selir]) {
232			int part_size, max_part_size;
233		✗	int left, offset = 0;
234
235		✗	s->nb_taps[selir] = ff_inlink_queued_samples(ctx->inputs[1 + selir]);
236		✗	if (s->nb_taps[selir] <= 0)
237		✗	return AVERROR(EINVAL);
238
239		✗	if (s->minp > s->maxp)
240		✗	s->maxp = s->minp;
241
242		✗	if (s->nb_segments[selir])
243		✗	goto skip;
244
245		✗	left = s->nb_taps[selir];
246		✗	part_size = 1 << av_log2(s->minp);
247		✗	max_part_size = 1 << av_log2(s->maxp);
248
249		✗	for (int i = 0; left > 0; i++) {
250		✗	int step = (part_size == max_part_size) ? INT_MAX : 1 + (i == 0);
251		✗	int nb_partitions = FFMIN(step, (left + part_size - 1) / part_size);
252
253		✗	s->nb_segments[selir] = i + 1;
254		✗	ret = init_segment(ctx, &s->seg[selir][i], selir, offset, nb_partitions, part_size, i);
255		✗	if (ret < 0)
256		✗	return ret;
257		✗	offset += nb_partitions * part_size;
258		✗	s->max_offset[selir] = offset;
259		✗	left -= nb_partitions * part_size;
260		✗	part_size *= 2;
261		✗	part_size = FFMIN(part_size, max_part_size);
262			}
263			}
264
265		✗	skip:
266		✗	if (!s->ir[selir]) {
267		✗	ret = ff_inlink_consume_samples(ctx->inputs[1 + selir], s->nb_taps[selir], s->nb_taps[selir], &s->ir[selir]);
268		✗	if (ret < 0)
269		✗	return ret;
270		✗	if (ret == 0)
271		✗	return AVERROR_BUG;
272			}
273
274		✗	cur_nb_taps = s->ir[selir]->nb_samples;
275		✗	nb_taps = cur_nb_taps;
276
277		✗	if (!s->norm_ir[selir] || s->norm_ir[selir]->nb_samples < nb_taps) {
278		✗	av_frame_free(&s->norm_ir[selir]);
279		✗	s->norm_ir[selir] = ff_get_audio_buffer(ctx->inputs[0], FFALIGN(nb_taps, 8));
280		✗	if (!s->norm_ir[selir])
281		✗	return AVERROR(ENOMEM);
282			}
283
284		✗	av_log(ctx, AV_LOG_DEBUG, "nb_taps: %d\n", cur_nb_taps);
285		✗	av_log(ctx, AV_LOG_DEBUG, "nb_segments: %d\n", s->nb_segments[selir]);
286
287		✗	switch (s->format) {
288		✗	case AV_SAMPLE_FMT_FLTP:
289		✗	for (int ch = 0; ch < s->nb_channels; ch++) {
290		✗	const float *tsrc = (const float *)s->ir[selir]->extended_data[!s->one2many * ch];
291
292		✗	s->ch_gain[ch] = ir_gain_float(ctx, s, nb_taps, tsrc);
293			}
294
295		✗	if (s->ir_link) {
296		✗	float gain = +INFINITY;
297
298		✗	for (int ch = 0; ch < s->nb_channels; ch++)
299		✗	gain = fminf(gain, s->ch_gain[ch]);
300
301		✗	for (int ch = 0; ch < s->nb_channels; ch++)
302		✗	s->ch_gain[ch] = gain;
303			}
304
305		✗	for (int ch = 0; ch < s->nb_channels; ch++) {
306		✗	const float *tsrc = (const float *)s->ir[selir]->extended_data[!s->one2many * ch];
307		✗	float *time = (float *)s->norm_ir[selir]->extended_data[ch];
308
309		✗	memcpy(time, tsrc, sizeof(*time) * nb_taps);
310		✗	for (int i = FFMAX(1, s->length * nb_taps); i < nb_taps; i++)
311		✗	time[i] = 0;
312
313		✗	ir_scale_float(ctx, s, nb_taps, ch, time, s->ch_gain[ch]);
314
315		✗	for (int n = 0; n < s->nb_segments[selir]; n++) {
316		✗	AudioFIRSegment *seg = &s->seg[selir][n];
317
318		✗	if (!seg->coeff)
319		✗	seg->coeff = ff_get_audio_buffer(ctx->inputs[0], seg->nb_partitions * seg->coeff_size * 2);
320		✗	if (!seg->coeff)
321		✗	return AVERROR(ENOMEM);
322
323		✗	for (int i = 0; i < seg->nb_partitions; i++)
324		✗	convert_channel_float(ctx, s, ch, seg, i, selir);
325			}
326			}
327		✗	break;
328		✗	case AV_SAMPLE_FMT_DBLP:
329		✗	for (int ch = 0; ch < s->nb_channels; ch++) {
330		✗	const double *tsrc = (const double *)s->ir[selir]->extended_data[!s->one2many * ch];
331
332		✗	s->ch_gain[ch] = ir_gain_double(ctx, s, nb_taps, tsrc);
333			}
334
335		✗	if (s->ir_link) {
336		✗	double gain = +INFINITY;
337
338		✗	for (int ch = 0; ch < s->nb_channels; ch++)
339		✗	gain = fmin(gain, s->ch_gain[ch]);
340
341		✗	for (int ch = 0; ch < s->nb_channels; ch++)
342		✗	s->ch_gain[ch] = gain;
343			}
344
345		✗	for (int ch = 0; ch < s->nb_channels; ch++) {
346		✗	const double *tsrc = (const double *)s->ir[selir]->extended_data[!s->one2many * ch];
347		✗	double *time = (double *)s->norm_ir[selir]->extended_data[ch];
348
349		✗	memcpy(time, tsrc, sizeof(*time) * nb_taps);
350		✗	for (int i = FFMAX(1, s->length * nb_taps); i < nb_taps; i++)
351		✗	time[i] = 0;
352
353		✗	ir_scale_double(ctx, s, nb_taps, ch, time, s->ch_gain[ch]);
354
355		✗	for (int n = 0; n < s->nb_segments[selir]; n++) {
356		✗	AudioFIRSegment *seg = &s->seg[selir][n];
357
358		✗	if (!seg->coeff)
359		✗	seg->coeff = ff_get_audio_buffer(ctx->inputs[0], seg->nb_partitions * seg->coeff_size * 2);
360		✗	if (!seg->coeff)
361		✗	return AVERROR(ENOMEM);
362
363		✗	for (int i = 0; i < seg->nb_partitions; i++)
364		✗	convert_channel_double(ctx, s, ch, seg, i, selir);
365			}
366			}
367		✗	break;
368			}
369
370		✗	s->have_coeffs[selir] = 1;
371
372		✗	return 0;
373			}
374
375		✗	static int check_ir(AVFilterLink *link, int selir)
376			{
377		✗	AVFilterContext *ctx = link->dst;
378		✗	AudioFIRContext *s = ctx->priv;
379			int nb_taps, max_nb_taps;
380
381		✗	nb_taps = ff_inlink_queued_samples(link);
382		✗	max_nb_taps = s->max_ir_len * ctx->outputs[0]->sample_rate;
383		✗	if (nb_taps > max_nb_taps) {
384		✗	av_log(ctx, AV_LOG_ERROR, "Too big number of coefficients: %d > %d.\n", nb_taps, max_nb_taps);
385		✗	return AVERROR(EINVAL);
386			}
387
388		✗	if (ff_inlink_check_available_samples(link, nb_taps + 1) == 1)
389		✗	s->eof_coeffs[selir] = 1;
390
391		✗	return 0;
392			}
393
394		✗	static int activate(AVFilterContext *ctx)
395			{
396		✗	AudioFIRContext *s = ctx->priv;
397		✗	AVFilterLink *outlink = ctx->outputs[0];
398			int ret, status, available, wanted;
399		✗	AVFrame *in = NULL;
400			int64_t pts;
401
402		✗	FF_FILTER_FORWARD_STATUS_BACK_ALL(ctx->outputs[0], ctx);
403
404		✗	for (int i = 0; i < s->nb_irs; i++) {
405		✗	const int selir = i;
406
407		✗	if (s->ir_load && selir != s->selir)
408		✗	continue;
409
410		✗	if (!s->eof_coeffs[selir]) {
411		✗	ret = check_ir(ctx->inputs[1 + selir], selir);
412		✗	if (ret < 0)
413		✗	return ret;
414
415		✗	if (!s->eof_coeffs[selir]) {
416		✗	if (ff_outlink_frame_wanted(ctx->outputs[0]))
417		✗	ff_inlink_request_frame(ctx->inputs[1 + selir]);
418		✗	return 0;
419			}
420			}
421
422		✗	if (!s->have_coeffs[selir] && s->eof_coeffs[selir]) {
423		✗	ret = convert_coeffs(ctx, selir);
424		✗	if (ret < 0)
425		✗	return ret;
426			}
427			}
428
429		✗	available = ff_inlink_queued_samples(ctx->inputs[0]);
430		✗	wanted = FFMAX(s->min_part_size, (available / s->min_part_size) * s->min_part_size);
431		✗	ret = ff_inlink_consume_samples(ctx->inputs[0], wanted, wanted, &in);
432		✗	if (ret > 0)
433		✗	ret = fir_frame(s, in, outlink);
434
435		✗	if (s->selir != s->prev_selir && s->loading[0] == 0)
436		✗	s->prev_selir = s->selir;
437
438		✗	if (ret < 0)
439		✗	return ret;
440
441		✗	if (ff_inlink_queued_samples(ctx->inputs[0]) >= s->min_part_size) {
442		✗	ff_filter_set_ready(ctx, 10);
443		✗	return 0;
444			}
445
446		✗	if (ff_inlink_acknowledge_status(ctx->inputs[0], &status, &pts)) {
447		✗	if (status == AVERROR_EOF) {
448		✗	ff_outlink_set_status(ctx->outputs[0], status, pts);
449		✗	return 0;
450			}
451			}
452
453		✗	if (ff_outlink_frame_wanted(ctx->outputs[0])) {
454		✗	ff_inlink_request_frame(ctx->inputs[0]);
455		✗	return 0;
456			}
457
458		✗	return FFERROR_NOT_READY;
459			}
460
461		✗	static int query_formats(AVFilterContext *ctx)
462			{
463		✗	AudioFIRContext *s = ctx->priv;
464			static const enum AVSampleFormat sample_fmts[3][3] = {
465			{ AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_NONE },
466			{ AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE },
467			{ AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_NONE },
468			};
469			int ret;
470
471		✗	if (s->ir_format) {
472		✗	ret = ff_set_common_all_channel_counts(ctx);
473		✗	if (ret < 0)
474		✗	return ret;
475			} else {
476		✗	AVFilterChannelLayouts *mono = NULL;
477		✗	AVFilterChannelLayouts *layouts = ff_all_channel_counts();
478
479		✗	if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->outcfg.channel_layouts)) < 0)
480		✗	return ret;
481		✗	if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->incfg.channel_layouts)) < 0)
482		✗	return ret;
483
484		✗	ret = ff_add_channel_layout(&mono, &(AVChannelLayout)AV_CHANNEL_LAYOUT_MONO);
485		✗	if (ret)
486		✗	return ret;
487		✗	for (int i = 1; i < ctx->nb_inputs; i++) {
488		✗	if ((ret = ff_channel_layouts_ref(mono, &ctx->inputs[i]->outcfg.channel_layouts)) < 0)
489		✗	return ret;
490			}
491			}
492
493		✗	if ((ret = ff_set_common_formats_from_list(ctx, sample_fmts[s->precision])) < 0)
494		✗	return ret;
495
496		✗	return ff_set_common_all_samplerates(ctx);
497			}
498
499		✗	static int config_output(AVFilterLink *outlink)
500			{
501		✗	AVFilterContext *ctx = outlink->src;
502		✗	AudioFIRContext *s = ctx->priv;
503			int ret;
504
505		✗	s->one2many = ctx->inputs[1 + s->selir]->ch_layout.nb_channels == 1;
506		✗	outlink->sample_rate = ctx->inputs[0]->sample_rate;
507		✗	outlink->time_base = ctx->inputs[0]->time_base;
508		✗	if ((ret = av_channel_layout_copy(&outlink->ch_layout, &ctx->inputs[0]->ch_layout)) < 0)
509		✗	return ret;
510		✗	outlink->ch_layout.nb_channels = ctx->inputs[0]->ch_layout.nb_channels;
511
512		✗	s->format = outlink->format;
513		✗	s->nb_channels = outlink->ch_layout.nb_channels;
514		✗	s->ch_gain = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*s->ch_gain));
515		✗	s->loading = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*s->loading));
516		✗	if (!s->loading || !s->ch_gain)
517		✗	return AVERROR(ENOMEM);
518
519		✗	s->fadein[0] = ff_get_audio_buffer(outlink, s->min_part_size);
520		✗	s->fadein[1] = ff_get_audio_buffer(outlink, s->min_part_size);
521		✗	if (!s->fadein[0] || !s->fadein[1])
522		✗	return AVERROR(ENOMEM);
523
524		✗	s->xfade[0] = ff_get_audio_buffer(outlink, s->min_part_size);
525		✗	s->xfade[1] = ff_get_audio_buffer(outlink, s->min_part_size);
526		✗	if (!s->xfade[0] || !s->xfade[1])
527		✗	return AVERROR(ENOMEM);
528
529		✗	switch (s->format) {
530		✗	case AV_SAMPLE_FMT_FLTP:
531		✗	for (int ch = 0; ch < s->nb_channels; ch++) {
532		✗	float *dst0 = (float *)s->xfade[0]->extended_data[ch];
533		✗	float *dst1 = (float *)s->xfade[1]->extended_data[ch];
534
535		✗	for (int n = 0; n < s->min_part_size; n++) {
536		✗	dst0[n] = (n + 1.f) / s->min_part_size;
537		✗	dst1[n] = 1.f - dst0[n];
538			}
539			}
540		✗	break;
541		✗	case AV_SAMPLE_FMT_DBLP:
542		✗	for (int ch = 0; ch < s->nb_channels; ch++) {
543		✗	double *dst0 = (double *)s->xfade[0]->extended_data[ch];
544		✗	double *dst1 = (double *)s->xfade[1]->extended_data[ch];
545
546		✗	for (int n = 0; n < s->min_part_size; n++) {
547		✗	dst0[n] = (n + 1.0) / s->min_part_size;
548		✗	dst1[n] = 1.0 - dst0[n];
549			}
550			}
551		✗	break;
552			}
553
554		✗	return 0;
555			}
556
557		✗	static av_cold void uninit(AVFilterContext *ctx)
558			{
559		✗	AudioFIRContext *s = ctx->priv;
560
561		✗	av_freep(&s->fdsp);
562		✗	av_freep(&s->ch_gain);
563		✗	av_freep(&s->loading);
564
565		✗	for (int i = 0; i < s->nb_irs; i++) {
566		✗	for (int j = 0; j < s->nb_segments[i]; j++)
567		✗	uninit_segment(ctx, &s->seg[i][j]);
568
569		✗	av_frame_free(&s->ir[i]);
570		✗	av_frame_free(&s->norm_ir[i]);
571			}
572
573		✗	av_frame_free(&s->fadein[0]);
574		✗	av_frame_free(&s->fadein[1]);
575
576		✗	av_frame_free(&s->xfade[0]);
577		✗	av_frame_free(&s->xfade[1]);
578		✗	}
579
580		✗	static av_cold int init(AVFilterContext *ctx)
581			{
582		✗	AudioFIRContext *s = ctx->priv;
583			AVFilterPad pad;
584			int ret;
585
586		✗	s->prev_selir = FFMIN(s->nb_irs - 1, s->selir);
587
588		✗	pad = (AVFilterPad) {
589			.name = "main",
590			.type = AVMEDIA_TYPE_AUDIO,
591			};
592
593		✗	ret = ff_append_inpad(ctx, &pad);
594		✗	if (ret < 0)
595		✗	return ret;
596
597		✗	for (int n = 0; n < s->nb_irs; n++) {
598		✗	pad = (AVFilterPad) {
599		✗	.name = av_asprintf("ir%d", n),
600			.type = AVMEDIA_TYPE_AUDIO,
601			};
602
603		✗	if (!pad.name)
604		✗	return AVERROR(ENOMEM);
605
606		✗	ret = ff_append_inpad_free_name(ctx, &pad);
607		✗	if (ret < 0)
608		✗	return ret;
609			}
610
611		✗	s->fdsp = avpriv_float_dsp_alloc(0);
612		✗	if (!s->fdsp)
613		✗	return AVERROR(ENOMEM);
614
615		✗	ff_afir_init(&s->afirdsp);
616
617		✗	s->min_part_size = 1 << av_log2(s->minp);
618		✗	s->max_part_size = 1 << av_log2(s->maxp);
619
620		✗	return 0;
621			}
622
623		✗	static int process_command(AVFilterContext *ctx,
624			const char *cmd,
625			const char *arg,
626			char *res,
627			int res_len,
628			int flags)
629			{
630		✗	AudioFIRContext *s = ctx->priv;
631			int prev_selir, ret;
632
633		✗	prev_selir = s->selir;
634		✗	ret = ff_filter_process_command(ctx, cmd, arg, res, res_len, flags);
635		✗	if (ret < 0)
636		✗	return ret;
637
638		✗	s->selir = FFMIN(s->nb_irs - 1, s->selir);
639		✗	if (s->selir != prev_selir) {
640		✗	s->prev_selir = prev_selir;
641
642		✗	for (int ch = 0; ch < s->nb_channels; ch++)
643		✗	s->loading[ch] = 1;
644			}
645
646		✗	return 0;
647			}
648
649			#define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
650			#define AFR AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
651			#define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
652			#define OFFSET(x) offsetof(AudioFIRContext, x)
653
654			static const AVOption afir_options[] = {
655			{ "dry", "set dry gain", OFFSET(dry_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 10, AFR },
656			{ "wet", "set wet gain", OFFSET(wet_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 10, AFR },
657			{ "length", "set IR length", OFFSET(length), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF },
658			{ "gtype", "set IR auto gain type",OFFSET(gtype), AV_OPT_TYPE_INT, {.i64=0}, -1, 4, AF|AV_OPT_FLAG_DEPRECATED, .unit = "gtype" },
659			{ "none", "without auto gain", 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, AF|AV_OPT_FLAG_DEPRECATED, .unit = "gtype" },
660			{ "peak", "peak gain", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF|AV_OPT_FLAG_DEPRECATED, .unit = "gtype" },
661			{ "dc", "DC gain", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF|AV_OPT_FLAG_DEPRECATED, .unit = "gtype" },
662			{ "gn", "gain to noise", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF|AV_OPT_FLAG_DEPRECATED, .unit = "gtype" },
663			{ "ac", "AC gain", 0, AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, AF|AV_OPT_FLAG_DEPRECATED, .unit = "gtype" },
664			{ "rms", "RMS gain", 0, AV_OPT_TYPE_CONST, {.i64=4}, 0, 0, AF|AV_OPT_FLAG_DEPRECATED, .unit = "gtype" },
665			{ "irnorm", "set IR norm", OFFSET(ir_norm), AV_OPT_TYPE_FLOAT, {.dbl=1}, -1, 2, AF },
666			{ "irlink", "set IR link", OFFSET(ir_link), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, AF },
667			{ "irgain", "set IR gain", OFFSET(ir_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF },
668			{ "irfmt", "set IR format", OFFSET(ir_format), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, AF, .unit = "irfmt" },
669			{ "mono", "single channel", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, .unit = "irfmt" },
670			{ "input", "same as input", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, .unit = "irfmt" },
671			{ "maxir", "set max IR length", OFFSET(max_ir_len), AV_OPT_TYPE_FLOAT, {.dbl=30}, 0.1, 60, AF },
672			{ "response", "show IR frequency response", OFFSET(response), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, VF|AV_OPT_FLAG_DEPRECATED },
673			{ "channel", "set IR channel to display frequency response", OFFSET(ir_channel), AV_OPT_TYPE_INT, {.i64=0}, 0, 1024, VF|AV_OPT_FLAG_DEPRECATED },
674			{ "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "hd720"}, 0, 0, VF|AV_OPT_FLAG_DEPRECATED },
675			{ "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT32_MAX, VF|AV_OPT_FLAG_DEPRECATED },
676			{ "minp", "set min partition size", OFFSET(minp), AV_OPT_TYPE_INT, {.i64=8192}, 1, 65536, AF },
677			{ "maxp", "set max partition size", OFFSET(maxp), AV_OPT_TYPE_INT, {.i64=8192}, 8, 65536, AF },
678			{ "nbirs", "set number of input IRs",OFFSET(nb_irs),AV_OPT_TYPE_INT, {.i64=1}, 1, 32, AF },
679			{ "ir", "select IR", OFFSET(selir), AV_OPT_TYPE_INT, {.i64=0}, 0, 31, AFR },
680			{ "precision", "set processing precision", OFFSET(precision), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, AF, .unit = "precision" },
681			{ "auto", "set auto processing precision", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, .unit = "precision" },
682			{ "float", "set single-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, .unit = "precision" },
683			{ "double","set double-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF, .unit = "precision" },
684			{ "irload", "set IR loading type", OFFSET(ir_load), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, AF, .unit = "irload" },
685			{ "init", "load all IRs on init", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, .unit = "irload" },
686			{ "access", "load IR on access", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, .unit = "irload" },
687			{ NULL }
688			};
689
690			AVFILTER_DEFINE_CLASS(afir);
691
692			static const AVFilterPad outputs[] = {
693			{
694			.name = "default",
695			.type = AVMEDIA_TYPE_AUDIO,
696			.config_props = config_output,
697			},
698			};
699
700			const AVFilter ff_af_afir = {
701			.name = "afir",
702			.description = NULL_IF_CONFIG_SMALL("Apply Finite Impulse Response filter with supplied coefficients in additional stream(s)."),
703			.priv_size = sizeof(AudioFIRContext),
704			.priv_class = &afir_class,
705			FILTER_QUERY_FUNC(query_formats),
706			FILTER_OUTPUTS(outputs),
707			.init = init,
708			.activate = activate,
709			.uninit = uninit,
710			.process_command = process_command,
711			.flags = AVFILTER_FLAG_DYNAMIC_INPUTS |
712			AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
713			AVFILTER_FLAG_SLICE_THREADS,
714			};
715