[deb_ffmpeg.git] / ffmpeg / libavfilter / af_aecho.c

/*
 * Copyright (c) 2013 Paul B Mahol
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "libavutil/avassert.h"
#include "libavutil/avstring.h"
#include "libavutil/opt.h"
#include "libavutil/samplefmt.h"
#include "avfilter.h"
#include "audio.h"
#include "internal.h"

typedef struct AudioEchoContext {
    const AVClass *class;
    float in_gain, out_gain;
    char *delays, *decays;
    float *delay, *decay;
    int nb_echoes;
    int delay_index;
    uint8_t **delayptrs;
    int max_samples, fade_out;
    int *samples;
    int64_t next_pts;

    void (*echo_samples)(struct AudioEchoContext *ctx, uint8_t **delayptrs,
                         uint8_t * const *src, uint8_t **dst,
                         int nb_samples, int channels);
} AudioEchoContext;

#define OFFSET(x) offsetof(AudioEchoContext, x)
#define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

static const AVOption aecho_options[] = {
    { "in_gain",  "set signal input gain",  OFFSET(in_gain),  AV_OPT_TYPE_FLOAT,  {.dbl=0.6}, 0, 1, A },
    { "out_gain", "set signal output gain", OFFSET(out_gain), AV_OPT_TYPE_FLOAT,  {.dbl=0.3}, 0, 1, A },
    { "delays",   "set list of signal delays", OFFSET(delays), AV_OPT_TYPE_STRING, {.str="1000"}, 0, 0, A },
    { "decays",   "set list of signal decays", OFFSET(decays), AV_OPT_TYPE_STRING, {.str="0.5"}, 0, 0, A },
    { NULL }
};

AVFILTER_DEFINE_CLASS(aecho);

static void count_items(char *item_str, int *nb_items)
{
    char *p;

    *nb_items = 1;
    for (p = item_str; *p; p++) {
        if (*p == '|')
            (*nb_items)++;
    }

}

static void fill_items(char *item_str, int *nb_items, float *items)
{
    char *p, *saveptr = NULL;
    int i, new_nb_items = 0;

    p = item_str;
    for (i = 0; i < *nb_items; i++) {
        char *tstr = av_strtok(p, "|", &saveptr);
        p = NULL;
        new_nb_items += sscanf(tstr, "%f", &items[i]) == 1;
    }

    *nb_items = new_nb_items;
}

static av_cold void uninit(AVFilterContext *ctx)
{
    AudioEchoContext *s = ctx->priv;

    av_freep(&s->delay);
    av_freep(&s->decay);
    av_freep(&s->samples);

    if (s->delayptrs)
        av_freep(&s->delayptrs[0]);
    av_freep(&s->delayptrs);
}

static av_cold int init(AVFilterContext *ctx)
{
    AudioEchoContext *s = ctx->priv;
    int nb_delays, nb_decays, i;

    if (!s->delays || !s->decays) {
        av_log(ctx, AV_LOG_ERROR, "Missing delays and/or decays.\n");
        return AVERROR(EINVAL);
    }

    count_items(s->delays, &nb_delays);
    count_items(s->decays, &nb_decays);

    s->delay = av_realloc_f(s->delay, nb_delays, sizeof(*s->delay));
    s->decay = av_realloc_f(s->decay, nb_decays, sizeof(*s->decay));
    if (!s->delay || !s->decay)
        return AVERROR(ENOMEM);

    fill_items(s->delays, &nb_delays, s->delay);
    fill_items(s->decays, &nb_decays, s->decay);

    if (nb_delays != nb_decays) {
        av_log(ctx, AV_LOG_ERROR, "Number of delays %d differs from number of decays %d.\n", nb_delays, nb_decays);
        return AVERROR(EINVAL);
    }

    s->nb_echoes = nb_delays;
    if (!s->nb_echoes) {
        av_log(ctx, AV_LOG_ERROR, "At least one decay & delay must be set.\n");
        return AVERROR(EINVAL);
    }

    s->samples = av_realloc_f(s->samples, nb_delays, sizeof(*s->samples));
    if (!s->samples)
        return AVERROR(ENOMEM);

    for (i = 0; i < nb_delays; i++) {
        if (s->delay[i] <= 0 || s->delay[i] > 90000) {
            av_log(ctx, AV_LOG_ERROR, "delay[%d]: %f is out of allowed range: (0, 90000]\n", i, s->delay[i]);
            return AVERROR(EINVAL);
        }
        if (s->decay[i] <= 0 || s->decay[i] > 1) {
            av_log(ctx, AV_LOG_ERROR, "decay[%d]: %f is out of allowed range: (0, 1]\n", i, s->decay[i]);
            return AVERROR(EINVAL);
        }
    }

    s->next_pts = AV_NOPTS_VALUE;

    av_log(ctx, AV_LOG_DEBUG, "nb_echoes:%d\n", s->nb_echoes);
    return 0;
}

static int query_formats(AVFilterContext *ctx)
{
    AVFilterChannelLayouts *layouts;
    AVFilterFormats *formats;
    static const enum AVSampleFormat sample_fmts[] = {
        AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P,
        AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP,
        AV_SAMPLE_FMT_NONE
    };

    layouts = ff_all_channel_layouts();
    if (!layouts)
        return AVERROR(ENOMEM);
    ff_set_common_channel_layouts(ctx, layouts);

    formats = ff_make_format_list(sample_fmts);
    if (!formats)
        return AVERROR(ENOMEM);
    ff_set_common_formats(ctx, formats);

    formats = ff_all_samplerates();
    if (!formats)
        return AVERROR(ENOMEM);
    ff_set_common_samplerates(ctx, formats);

    return 0;
}

#define MOD(a, b) (((a) >= (b)) ? (a) - (b) : (a))

#define ECHO(name, type, min, max)                                          \
static void echo_samples_## name ##p(AudioEchoContext *ctx,                 \
                                     uint8_t **delayptrs,                   \
                                     uint8_t * const *src, uint8_t **dst,   \
                                     int nb_samples, int channels)          \
{                                                                           \
    const double out_gain = ctx->out_gain;                                  \
    const double in_gain = ctx->in_gain;                                    \
    const int nb_echoes = ctx->nb_echoes;                                   \
    const int max_samples = ctx->max_samples;                               \
    int i, j, chan, av_uninit(index);                                       \
                                                                            \
    av_assert1(channels > 0); /* would corrupt delay_index */               \
                                                                            \
    for (chan = 0; chan < channels; chan++) {                               \
        const type *s = (type *)src[chan];                                  \
        type *d = (type *)dst[chan];                                        \
        type *dbuf = (type *)delayptrs[chan];                               \
                                                                            \
        index = ctx->delay_index;                                           \
        for (i = 0; i < nb_samples; i++, s++, d++) {                        \
            double out, in;                                                 \
                                                                            \
            in = *s;                                                        \
            out = in * in_gain;                                             \
            for (j = 0; j < nb_echoes; j++) {                               \
                int ix = index + max_samples - ctx->samples[j];             \
                ix = MOD(ix, max_samples);                                  \
                out += dbuf[ix] * ctx->decay[j];                            \
            }                                                               \
            out *= out_gain;                                                \
                                                                            \
            *d = av_clipd(out, min, max);                                   \
            dbuf[index] = in;                                               \
                                                                            \
            index = MOD(index + 1, max_samples);                            \
        }                                                                   \
    }                                                                       \
    ctx->delay_index = index;                                               \
}

ECHO(dbl, double,  -1.0,      1.0      )
ECHO(flt, float,   -1.0,      1.0      )
ECHO(s16, int16_t, INT16_MIN, INT16_MAX)
ECHO(s32, int32_t, INT32_MIN, INT32_MAX)

static int config_output(AVFilterLink *outlink)
{
    AVFilterContext *ctx = outlink->src;
    AudioEchoContext *s = ctx->priv;
    float volume = 1.0;
    int i;

    for (i = 0; i < s->nb_echoes; i++) {
        s->samples[i] = s->delay[i] * outlink->sample_rate / 1000.0;
        s->max_samples = FFMAX(s->max_samples, s->samples[i]);
        volume += s->decay[i];
    }

    if (s->max_samples <= 0) {
        av_log(ctx, AV_LOG_ERROR, "Nothing to echo - missing delay samples.\n");
        return AVERROR(EINVAL);
    }
    s->fade_out = s->max_samples;

    if (volume * s->in_gain * s->out_gain > 1.0)
        av_log(ctx, AV_LOG_WARNING,
               "out_gain %f can cause saturation of output\n", s->out_gain);

    switch (outlink->format) {
    case AV_SAMPLE_FMT_DBLP: s->echo_samples = echo_samples_dblp; break;
    case AV_SAMPLE_FMT_FLTP: s->echo_samples = echo_samples_fltp; break;
    case AV_SAMPLE_FMT_S16P: s->echo_samples = echo_samples_s16p; break;
    case AV_SAMPLE_FMT_S32P: s->echo_samples = echo_samples_s32p; break;
    }


    if (s->delayptrs)
        av_freep(&s->delayptrs[0]);
    av_freep(&s->delayptrs);

    return av_samples_alloc_array_and_samples(&s->delayptrs, NULL,
                                              outlink->channels,
                                              s->max_samples,
                                              outlink->format, 0);
}

static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
{
    AVFilterContext *ctx = inlink->dst;
    AudioEchoContext *s = ctx->priv;
    AVFrame *out_frame;

    if (av_frame_is_writable(frame)) {
        out_frame = frame;
    } else {
        out_frame = ff_get_audio_buffer(inlink, frame->nb_samples);
        if (!out_frame)
            return AVERROR(ENOMEM);
        av_frame_copy_props(out_frame, frame);
    }

    s->echo_samples(s, s->delayptrs, frame->extended_data, out_frame->extended_data,
                    frame->nb_samples, inlink->channels);

    s->next_pts = frame->pts + av_rescale_q(frame->nb_samples, (AVRational){1, inlink->sample_rate}, inlink->time_base);

    if (frame != out_frame)
        av_frame_free(&frame);

    return ff_filter_frame(ctx->outputs[0], out_frame);
}

static int request_frame(AVFilterLink *outlink)
{
    AVFilterContext *ctx = outlink->src;
    AudioEchoContext *s = ctx->priv;
    int ret;

    ret = ff_request_frame(ctx->inputs[0]);

    if (ret == AVERROR_EOF && !ctx->is_disabled && s->fade_out) {
        int nb_samples = FFMIN(s->fade_out, 2048);
        AVFrame *frame;

        frame = ff_get_audio_buffer(outlink, nb_samples);
        if (!frame)
            return AVERROR(ENOMEM);
        s->fade_out -= nb_samples;

        av_samples_set_silence(frame->extended_data, 0,
                               frame->nb_samples,
                               outlink->channels,
                               frame->format);

        s->echo_samples(s, s->delayptrs, frame->extended_data, frame->extended_data,
                        frame->nb_samples, outlink->channels);

        frame->pts = s->next_pts;
        if (s->next_pts != AV_NOPTS_VALUE)
            s->next_pts += av_rescale_q(nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);

        return ff_filter_frame(outlink, frame);
    }

    return ret;
}

static const AVFilterPad aecho_inputs[] = {
    {
        .name         = "default",
        .type         = AVMEDIA_TYPE_AUDIO,
        .filter_frame = filter_frame,
    },
    { NULL }
};

static const AVFilterPad aecho_outputs[] = {
    {
        .name          = "default",
        .request_frame = request_frame,
        .config_props  = config_output,
        .type          = AVMEDIA_TYPE_AUDIO,
    },
    { NULL }
};

AVFilter ff_af_aecho = {
    .name          = "aecho",
    .description   = NULL_IF_CONFIG_SMALL("Add echoing to the audio."),
    .query_formats = query_formats,
    .priv_size     = sizeof(AudioEchoContext),
    .priv_class    = &aecho_class,
    .init          = init,
    .uninit        = uninit,
    .inputs        = aecho_inputs,
    .outputs       = aecho_outputs,
};
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* Copyright (c) 2013 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	#include "libavutil/avassert.h"
	22	#include "libavutil/avstring.h"
	23	#include "libavutil/opt.h"
	24	#include "libavutil/samplefmt.h"
	25	#include "avfilter.h"
	26	#include "audio.h"
	27	#include "internal.h"
	28
	29	typedef struct AudioEchoContext {
	30	const AVClass *class;
	31	float in_gain, out_gain;
	32	char delays, decays;
	33	float delay, decay;
	34	int nb_echoes;
	35	int delay_index;
	36	uint8_t **delayptrs;
	37	int max_samples, fade_out;
	38	int *samples;
	39	int64_t next_pts;
	40
	41	void (echo_samples)(struct AudioEchoContext ctx, uint8_t **delayptrs,
	42	uint8_t * const src, uint8_t *dst,
	43	int nb_samples, int channels);
	44	} AudioEchoContext;
	45
	46	#define OFFSET(x) offsetof(AudioEchoContext, x)
	47	#define A AV_OPT_FLAG_AUDIO_PARAM\|AV_OPT_FLAG_FILTERING_PARAM
	48
	49	static const AVOption aecho_options[] = {
	50	{ "in_gain", "set signal input gain", OFFSET(in_gain), AV_OPT_TYPE_FLOAT, {.dbl=0.6}, 0, 1, A },
	51	{ "out_gain", "set signal output gain", OFFSET(out_gain), AV_OPT_TYPE_FLOAT, {.dbl=0.3}, 0, 1, A },
	52	{ "delays", "set list of signal delays", OFFSET(delays), AV_OPT_TYPE_STRING, {.str="1000"}, 0, 0, A },
	53	{ "decays", "set list of signal decays", OFFSET(decays), AV_OPT_TYPE_STRING, {.str="0.5"}, 0, 0, A },
	54	{ NULL }
	55	};
	56
	57	AVFILTER_DEFINE_CLASS(aecho);
	58
	59	static void count_items(char item_str, int nb_items)
	60	{
	61	char *p;
	62
	63	*nb_items = 1;
	64	for (p = item_str; *p; p++) {
65	if (*p == '\|')
66	(*nb_items)++;
67	}
68
69	}
70
71	static void fill_items(char item_str, int nb_items, float *items)
72	{
73	char p, saveptr = NULL;
74	int i, new_nb_items = 0;
75
76	p = item_str;
77	for (i = 0; i < *nb_items; i++) {
78	char *tstr = av_strtok(p, "\|", &saveptr);
79	p = NULL;
80	new_nb_items += sscanf(tstr, "%f", &items[i]) == 1;
81	}
82
83	*nb_items = new_nb_items;
84	}
85
86	static av_cold void uninit(AVFilterContext *ctx)
87	{
88	AudioEchoContext *s = ctx->priv;
89
90	av_freep(&s->delay);
91	av_freep(&s->decay);
92	av_freep(&s->samples);
93
94	if (s->delayptrs)
95	av_freep(&s->delayptrs[0]);
96	av_freep(&s->delayptrs);
97	}
98
99	static av_cold int init(AVFilterContext *ctx)
100	{
101	AudioEchoContext *s = ctx->priv;
102	int nb_delays, nb_decays, i;
103
104	if (!s->delays \|\| !s->decays) {
105	av_log(ctx, AV_LOG_ERROR, "Missing delays and/or decays.\n");
106	return AVERROR(EINVAL);
107	}
108
109	count_items(s->delays, &nb_delays);
110	count_items(s->decays, &nb_decays);
111
112	s->delay = av_realloc_f(s->delay, nb_delays, sizeof(*s->delay));
113	s->decay = av_realloc_f(s->decay, nb_decays, sizeof(*s->decay));
114	if (!s->delay \|\| !s->decay)
115	return AVERROR(ENOMEM);
116
117	fill_items(s->delays, &nb_delays, s->delay);
118	fill_items(s->decays, &nb_decays, s->decay);
119
120	if (nb_delays != nb_decays) {
121	av_log(ctx, AV_LOG_ERROR, "Number of delays %d differs from number of decays %d.\n", nb_delays, nb_decays);
122	return AVERROR(EINVAL);
123	}
124
125	s->nb_echoes = nb_delays;
126	if (!s->nb_echoes) {
127	av_log(ctx, AV_LOG_ERROR, "At least one decay & delay must be set.\n");
128	return AVERROR(EINVAL);
129	}
130
131	s->samples = av_realloc_f(s->samples, nb_delays, sizeof(*s->samples));
132	if (!s->samples)
133	return AVERROR(ENOMEM);
134
135	for (i = 0; i < nb_delays; i++) {
136	if (s->delay[i] <= 0 \|\| s->delay[i] > 90000) {
137	av_log(ctx, AV_LOG_ERROR, "delay[%d]: %f is out of allowed range: (0, 90000]\n", i, s->delay[i]);
138	return AVERROR(EINVAL);
139	}
140	if (s->decay[i] <= 0 \|\| s->decay[i] > 1) {
141	av_log(ctx, AV_LOG_ERROR, "decay[%d]: %f is out of allowed range: (0, 1]\n", i, s->decay[i]);
142	return AVERROR(EINVAL);
143	}
144	}
145
146	s->next_pts = AV_NOPTS_VALUE;
147
148	av_log(ctx, AV_LOG_DEBUG, "nb_echoes:%d\n", s->nb_echoes);
149	return 0;
150	}
151
152	static int query_formats(AVFilterContext *ctx)
153	{
154	AVFilterChannelLayouts *layouts;
155	AVFilterFormats *formats;
156	static const enum AVSampleFormat sample_fmts[] = {
157	AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P,
158	AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP,
159	AV_SAMPLE_FMT_NONE
160	};
161
162	layouts = ff_all_channel_layouts();
163	if (!layouts)
164	return AVERROR(ENOMEM);
165	ff_set_common_channel_layouts(ctx, layouts);
166
167	formats = ff_make_format_list(sample_fmts);
168	if (!formats)
169	return AVERROR(ENOMEM);
170	ff_set_common_formats(ctx, formats);
171
172	formats = ff_all_samplerates();
173	if (!formats)
174	return AVERROR(ENOMEM);
175	ff_set_common_samplerates(ctx, formats);
176
177	return 0;
178	}
179
180	#define MOD(a, b) (((a) >= (b)) ? (a) - (b) : (a))
181
182	#define ECHO(name, type, min, max) \
183	static void echo_samples_## name ##p(AudioEchoContext *ctx, \
184	uint8_t **delayptrs, \
185	uint8_t * const src, uint8_t *dst, \
186	int nb_samples, int channels) \
187	{ \
188	const double out_gain = ctx->out_gain; \
189	const double in_gain = ctx->in_gain; \
190	const int nb_echoes = ctx->nb_echoes; \
191	const int max_samples = ctx->max_samples; \
192	int i, j, chan, av_uninit(index); \
193	\
194	av_assert1(channels > 0); /* would corrupt delay_index */ \
195	\
196	for (chan = 0; chan < channels; chan++) { \
197	const type s = (type )src[chan]; \
198	type d = (type )dst[chan]; \
199	type dbuf = (type )delayptrs[chan]; \
200	\
201	index = ctx->delay_index; \
202	for (i = 0; i < nb_samples; i++, s++, d++) { \
203	double out, in; \
204	\
205	in = *s; \
206	out = in * in_gain; \
207	for (j = 0; j < nb_echoes; j++) { \
208	int ix = index + max_samples - ctx->samples[j]; \
209	ix = MOD(ix, max_samples); \
210	out += dbuf[ix] * ctx->decay[j]; \
211	} \
212	out *= out_gain; \
213	\
214	*d = av_clipd(out, min, max); \
215	dbuf[index] = in; \
216	\
217	index = MOD(index + 1, max_samples); \
218	} \
219	} \
220	ctx->delay_index = index; \
221	}
222
223	ECHO(dbl, double, -1.0, 1.0 )
224	ECHO(flt, float, -1.0, 1.0 )
225	ECHO(s16, int16_t, INT16_MIN, INT16_MAX)
226	ECHO(s32, int32_t, INT32_MIN, INT32_MAX)
227
228	static int config_output(AVFilterLink *outlink)
229	{
230	AVFilterContext *ctx = outlink->src;
231	AudioEchoContext *s = ctx->priv;
232	float volume = 1.0;
233	int i;
234
235	for (i = 0; i < s->nb_echoes; i++) {
236	s->samples[i] = s->delay[i] * outlink->sample_rate / 1000.0;
237	s->max_samples = FFMAX(s->max_samples, s->samples[i]);
238	volume += s->decay[i];
239	}
240
241	if (s->max_samples <= 0) {
242	av_log(ctx, AV_LOG_ERROR, "Nothing to echo - missing delay samples.\n");
243	return AVERROR(EINVAL);
244	}
245	s->fade_out = s->max_samples;
246
247	if (volume * s->in_gain * s->out_gain > 1.0)
248	av_log(ctx, AV_LOG_WARNING,
249	"out_gain %f can cause saturation of output\n", s->out_gain);
250
251	switch (outlink->format) {
252	case AV_SAMPLE_FMT_DBLP: s->echo_samples = echo_samples_dblp; break;
253	case AV_SAMPLE_FMT_FLTP: s->echo_samples = echo_samples_fltp; break;
254	case AV_SAMPLE_FMT_S16P: s->echo_samples = echo_samples_s16p; break;
255	case AV_SAMPLE_FMT_S32P: s->echo_samples = echo_samples_s32p; break;
256	}
257
258
259	if (s->delayptrs)
260	av_freep(&s->delayptrs[0]);
261	av_freep(&s->delayptrs);
262
263	return av_samples_alloc_array_and_samples(&s->delayptrs, NULL,
264	outlink->channels,
265	s->max_samples,
266	outlink->format, 0);
267	}
268
269	static int filter_frame(AVFilterLink inlink, AVFrame frame)
270	{
271	AVFilterContext *ctx = inlink->dst;
272	AudioEchoContext *s = ctx->priv;
273	AVFrame *out_frame;
274
275	if (av_frame_is_writable(frame)) {
276	out_frame = frame;
277	} else {
278	out_frame = ff_get_audio_buffer(inlink, frame->nb_samples);
279	if (!out_frame)
280	return AVERROR(ENOMEM);
281	av_frame_copy_props(out_frame, frame);
282	}
283
284	s->echo_samples(s, s->delayptrs, frame->extended_data, out_frame->extended_data,
285	frame->nb_samples, inlink->channels);
286
287	s->next_pts = frame->pts + av_rescale_q(frame->nb_samples, (AVRational){1, inlink->sample_rate}, inlink->time_base);
288
289	if (frame != out_frame)
290	av_frame_free(&frame);
291
292	return ff_filter_frame(ctx->outputs[0], out_frame);
293	}
294
295	static int request_frame(AVFilterLink *outlink)
296	{
297	AVFilterContext *ctx = outlink->src;
298	AudioEchoContext *s = ctx->priv;
299	int ret;
300
301	ret = ff_request_frame(ctx->inputs[0]);
302
303	if (ret == AVERROR_EOF && !ctx->is_disabled && s->fade_out) {
304	int nb_samples = FFMIN(s->fade_out, 2048);
305	AVFrame *frame;
306
307	frame = ff_get_audio_buffer(outlink, nb_samples);
308	if (!frame)
309	return AVERROR(ENOMEM);
310	s->fade_out -= nb_samples;
311
312	av_samples_set_silence(frame->extended_data, 0,
313	frame->nb_samples,
314	outlink->channels,
315	frame->format);
316
317	s->echo_samples(s, s->delayptrs, frame->extended_data, frame->extended_data,
318	frame->nb_samples, outlink->channels);
319
320	frame->pts = s->next_pts;
321	if (s->next_pts != AV_NOPTS_VALUE)
322	s->next_pts += av_rescale_q(nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
323
324	return ff_filter_frame(outlink, frame);
325	}
326
327	return ret;
328	}
329
330	static const AVFilterPad aecho_inputs[] = {
331	{
332	.name = "default",
333	.type = AVMEDIA_TYPE_AUDIO,
334	.filter_frame = filter_frame,
335	},
336	{ NULL }
337	};
338
339	static const AVFilterPad aecho_outputs[] = {
340	{
341	.name = "default",
342	.request_frame = request_frame,
343	.config_props = config_output,
344	.type = AVMEDIA_TYPE_AUDIO,
345	},
346	{ NULL }
347	};
348
349	AVFilter ff_af_aecho = {
350	.name = "aecho",
351	.description = NULL_IF_CONFIG_SMALL("Add echoing to the audio."),
352	.query_formats = query_formats,
353	.priv_size = sizeof(AudioEchoContext),
354	.priv_class = &aecho_class,
355	.init = init,
356	.uninit = uninit,
357	.inputs = aecho_inputs,
358	.outputs = aecho_outputs,
359	};