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