summaryrefslogtreecommitdiff
path: root/libavfilter/af_adelay.c (plain)
blob: 187cacf28afd5ebd0dd7ff8d763aff8714bf045d
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/avstring.h"
22#include "libavutil/opt.h"
23#include "libavutil/samplefmt.h"
24#include "avfilter.h"
25#include "audio.h"
26#include "internal.h"
27
28typedef struct ChanDelay {
29 int delay;
30 unsigned delay_index;
31 unsigned index;
32 uint8_t *samples;
33} ChanDelay;
34
35typedef struct AudioDelayContext {
36 const AVClass *class;
37 char *delays;
38 ChanDelay *chandelay;
39 int nb_delays;
40 int block_align;
41 unsigned max_delay;
42 int64_t next_pts;
43
44 void (*delay_channel)(ChanDelay *d, int nb_samples,
45 const uint8_t *src, uint8_t *dst);
46} AudioDelayContext;
47
48#define OFFSET(x) offsetof(AudioDelayContext, x)
49#define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
50
51static const AVOption adelay_options[] = {
52 { "delays", "set list of delays for each channel", OFFSET(delays), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, A },
53 { NULL }
54};
55
56AVFILTER_DEFINE_CLASS(adelay);
57
58static int query_formats(AVFilterContext *ctx)
59{
60 AVFilterChannelLayouts *layouts;
61 AVFilterFormats *formats;
62 static const enum AVSampleFormat sample_fmts[] = {
63 AV_SAMPLE_FMT_U8P, AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P,
64 AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP,
65 AV_SAMPLE_FMT_NONE
66 };
67 int ret;
68
69 layouts = ff_all_channel_counts();
70 if (!layouts)
71 return AVERROR(ENOMEM);
72 ret = ff_set_common_channel_layouts(ctx, layouts);
73 if (ret < 0)
74 return ret;
75
76 formats = ff_make_format_list(sample_fmts);
77 if (!formats)
78 return AVERROR(ENOMEM);
79 ret = ff_set_common_formats(ctx, formats);
80 if (ret < 0)
81 return ret;
82
83 formats = ff_all_samplerates();
84 if (!formats)
85 return AVERROR(ENOMEM);
86 return ff_set_common_samplerates(ctx, formats);
87}
88
89#define DELAY(name, type, fill) \
90static void delay_channel_## name ##p(ChanDelay *d, int nb_samples, \
91 const uint8_t *ssrc, uint8_t *ddst) \
92{ \
93 const type *src = (type *)ssrc; \
94 type *dst = (type *)ddst; \
95 type *samples = (type *)d->samples; \
96 \
97 while (nb_samples) { \
98 if (d->delay_index < d->delay) { \
99 const int len = FFMIN(nb_samples, d->delay - d->delay_index); \
100 \
101 memcpy(&samples[d->delay_index], src, len * sizeof(type)); \
102 memset(dst, fill, len * sizeof(type)); \
103 d->delay_index += len; \
104 src += len; \
105 dst += len; \
106 nb_samples -= len; \
107 } else { \
108 *dst = samples[d->index]; \
109 samples[d->index] = *src; \
110 nb_samples--; \
111 d->index++; \
112 src++, dst++; \
113 d->index = d->index >= d->delay ? 0 : d->index; \
114 } \
115 } \
116}
117
118DELAY(u8, uint8_t, 0x80)
119DELAY(s16, int16_t, 0)
120DELAY(s32, int32_t, 0)
121DELAY(flt, float, 0)
122DELAY(dbl, double, 0)
123
124static int config_input(AVFilterLink *inlink)
125{
126 AVFilterContext *ctx = inlink->dst;
127 AudioDelayContext *s = ctx->priv;
128 char *p, *arg, *saveptr = NULL;
129 int i;
130
131 s->chandelay = av_calloc(inlink->channels, sizeof(*s->chandelay));
132 if (!s->chandelay)
133 return AVERROR(ENOMEM);
134 s->nb_delays = inlink->channels;
135 s->block_align = av_get_bytes_per_sample(inlink->format);
136
137 p = s->delays;
138 for (i = 0; i < s->nb_delays; i++) {
139 ChanDelay *d = &s->chandelay[i];
140 float delay;
141 char type = 0;
142 int ret;
143
144 if (!(arg = av_strtok(p, "|", &saveptr)))
145 break;
146
147 p = NULL;
148
149 ret = sscanf(arg, "%d%c", &d->delay, &type);
150 if (ret != 2 || type != 'S') {
151 sscanf(arg, "%f", &delay);
152 d->delay = delay * inlink->sample_rate / 1000.0;
153 }
154
155 if (d->delay < 0) {
156 av_log(ctx, AV_LOG_ERROR, "Delay must be non negative number.\n");
157 return AVERROR(EINVAL);
158 }
159 }
160
161 for (i = 0; i < s->nb_delays; i++) {
162 ChanDelay *d = &s->chandelay[i];
163
164 if (!d->delay)
165 continue;
166
167 d->samples = av_malloc_array(d->delay, s->block_align);
168 if (!d->samples)
169 return AVERROR(ENOMEM);
170
171 s->max_delay = FFMAX(s->max_delay, d->delay);
172 }
173
174 if (!s->max_delay) {
175 av_log(ctx, AV_LOG_ERROR, "At least one delay >0 must be specified.\n");
176 return AVERROR(EINVAL);
177 }
178
179 switch (inlink->format) {
180 case AV_SAMPLE_FMT_U8P : s->delay_channel = delay_channel_u8p ; break;
181 case AV_SAMPLE_FMT_S16P: s->delay_channel = delay_channel_s16p; break;
182 case AV_SAMPLE_FMT_S32P: s->delay_channel = delay_channel_s32p; break;
183 case AV_SAMPLE_FMT_FLTP: s->delay_channel = delay_channel_fltp; break;
184 case AV_SAMPLE_FMT_DBLP: s->delay_channel = delay_channel_dblp; break;
185 }
186
187 return 0;
188}
189
190static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
191{
192 AVFilterContext *ctx = inlink->dst;
193 AudioDelayContext *s = ctx->priv;
194 AVFrame *out_frame;
195 int i;
196
197 if (ctx->is_disabled || !s->delays)
198 return ff_filter_frame(ctx->outputs[0], frame);
199
200 out_frame = ff_get_audio_buffer(inlink, frame->nb_samples);
201 if (!out_frame) {
202 av_frame_free(&frame);
203 return AVERROR(ENOMEM);
204 }
205 av_frame_copy_props(out_frame, frame);
206
207 for (i = 0; i < s->nb_delays; i++) {
208 ChanDelay *d = &s->chandelay[i];
209 const uint8_t *src = frame->extended_data[i];
210 uint8_t *dst = out_frame->extended_data[i];
211
212 if (!d->delay)
213 memcpy(dst, src, frame->nb_samples * s->block_align);
214 else
215 s->delay_channel(d, frame->nb_samples, src, dst);
216 }
217
218 s->next_pts = frame->pts + av_rescale_q(frame->nb_samples, (AVRational){1, inlink->sample_rate}, inlink->time_base);
219 av_frame_free(&frame);
220 return ff_filter_frame(ctx->outputs[0], out_frame);
221}
222
223static int request_frame(AVFilterLink *outlink)
224{
225 AVFilterContext *ctx = outlink->src;
226 AudioDelayContext *s = ctx->priv;
227 int ret;
228
229 ret = ff_request_frame(ctx->inputs[0]);
230 if (ret == AVERROR_EOF && !ctx->is_disabled && s->max_delay) {
231 int nb_samples = FFMIN(s->max_delay, 2048);
232 AVFrame *frame;
233
234 frame = ff_get_audio_buffer(outlink, nb_samples);
235 if (!frame)
236 return AVERROR(ENOMEM);
237 s->max_delay -= nb_samples;
238
239 av_samples_set_silence(frame->extended_data, 0,
240 frame->nb_samples,
241 outlink->channels,
242 frame->format);
243
244 frame->pts = s->next_pts;
245 if (s->next_pts != AV_NOPTS_VALUE)
246 s->next_pts += av_rescale_q(nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
247
248 ret = filter_frame(ctx->inputs[0], frame);
249 }
250
251 return ret;
252}
253
254static av_cold void uninit(AVFilterContext *ctx)
255{
256 AudioDelayContext *s = ctx->priv;
257 int i;
258
259 for (i = 0; i < s->nb_delays; i++)
260 av_freep(&s->chandelay[i].samples);
261 av_freep(&s->chandelay);
262}
263
264static const AVFilterPad adelay_inputs[] = {
265 {
266 .name = "default",
267 .type = AVMEDIA_TYPE_AUDIO,
268 .config_props = config_input,
269 .filter_frame = filter_frame,
270 },
271 { NULL }
272};
273
274static const AVFilterPad adelay_outputs[] = {
275 {
276 .name = "default",
277 .request_frame = request_frame,
278 .type = AVMEDIA_TYPE_AUDIO,
279 },
280 { NULL }
281};
282
283AVFilter ff_af_adelay = {
284 .name = "adelay",
285 .description = NULL_IF_CONFIG_SMALL("Delay one or more audio channels."),
286 .query_formats = query_formats,
287 .priv_size = sizeof(AudioDelayContext),
288 .priv_class = &adelay_class,
289 .uninit = uninit,
290 .inputs = adelay_inputs,
291 .outputs = adelay_outputs,
292 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
293};
294
generated by cgit at 2024-05-17 03:41:28 (GMT)