2 * Copyright (c) 2010 S.N. Hemanth Meenakshisundaram
3 * Copyright (c) 2011 Mina Nagy Zaki
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * memory buffer source for audio
27 #include "libavutil/audioconvert.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/fifo.h"
30 #include "asrc_abuffer.h"
34 // Audio format of incoming buffers
36 unsigned int sample_format;
37 int64_t channel_layout;
40 // FIFO buffer of audio buffer ref pointers
43 // Normalization filters
44 AVFilterContext *aconvert;
45 AVFilterContext *aresample;
46 } ABufferSourceContext;
50 static void buf_free(AVFilterBuffer *ptr)
56 static void set_link_source(AVFilterContext *src, AVFilterLink *link)
59 link->srcpad = &(src->output_pads[0]);
60 src->outputs[0] = link;
63 static int reconfigure_filter(ABufferSourceContext *abuffer, AVFilterContext *filt_ctx)
66 AVFilterLink * const inlink = filt_ctx->inputs[0];
67 AVFilterLink * const outlink = filt_ctx->outputs[0];
69 inlink->format = abuffer->sample_format;
70 inlink->channel_layout = abuffer->channel_layout;
71 inlink->planar = abuffer->packing_format;
72 inlink->sample_rate = abuffer->sample_rate;
74 filt_ctx->filter->uninit(filt_ctx);
75 memset(filt_ctx->priv, 0, filt_ctx->filter->priv_size);
76 if ((ret = filt_ctx->filter->init(filt_ctx, NULL , NULL)) < 0)
78 if ((ret = inlink->srcpad->config_props(inlink)) < 0)
80 return outlink->srcpad->config_props(outlink);
83 static int insert_filter(ABufferSourceContext *abuffer,
84 AVFilterLink *link, AVFilterContext **filt_ctx,
85 const char *filt_name)
89 if ((ret = avfilter_open(filt_ctx, avfilter_get_by_name(filt_name), NULL)) < 0)
92 link->src->outputs[0] = NULL;
93 if ((ret = avfilter_link(link->src, 0, *filt_ctx, 0)) < 0) {
94 link->src->outputs[0] = link;
98 set_link_source(*filt_ctx, link);
100 if ((ret = reconfigure_filter(abuffer, *filt_ctx)) < 0) {
101 avfilter_free(*filt_ctx);
108 static void remove_filter(AVFilterContext **filt_ctx)
110 AVFilterLink *outlink = (*filt_ctx)->outputs[0];
111 AVFilterContext *src = (*filt_ctx)->inputs[0]->src;
113 (*filt_ctx)->outputs[0] = NULL;
114 avfilter_free(*filt_ctx);
117 set_link_source(src, outlink);
120 static inline void log_input_change(void *ctx, AVFilterLink *link, AVFilterBufferRef *ref)
122 char old_layout_str[16], new_layout_str[16];
123 av_get_channel_layout_string(old_layout_str, sizeof(old_layout_str),
124 -1, link->channel_layout);
125 av_get_channel_layout_string(new_layout_str, sizeof(new_layout_str),
126 -1, ref->audio->channel_layout);
127 av_log(ctx, AV_LOG_INFO,
128 "Audio input format changed: "
129 "%s:%s:%d -> %s:%s:%d, normalizing\n",
130 av_get_sample_fmt_name(link->format),
131 old_layout_str, (int)link->sample_rate,
132 av_get_sample_fmt_name(ref->format),
133 new_layout_str, ref->audio->sample_rate);
136 int av_asrc_buffer_add_audio_buffer_ref(AVFilterContext *ctx,
137 AVFilterBufferRef *samplesref,
140 ABufferSourceContext *abuffer = ctx->priv;
144 if (av_fifo_space(abuffer->fifo) < sizeof(samplesref)) {
145 av_log(ctx, AV_LOG_ERROR,
146 "Buffering limit reached. Please consume some available frames "
147 "before adding new ones.\n");
148 return AVERROR(EINVAL);
153 link = ctx->outputs[0];
154 if (samplesref->audio->sample_rate != link->sample_rate) {
156 log_input_change(ctx, link, samplesref);
159 abuffer->sample_rate = samplesref->audio->sample_rate;
161 if (!abuffer->aresample) {
162 ret = insert_filter(abuffer, link, &abuffer->aresample, "aresample");
163 if (ret < 0) return ret;
165 link = abuffer->aresample->outputs[0];
166 if (samplesref->audio->sample_rate == link->sample_rate)
167 remove_filter(&abuffer->aresample);
169 if ((ret = reconfigure_filter(abuffer, abuffer->aresample)) < 0)
174 link = ctx->outputs[0];
175 if (samplesref->format != link->format ||
176 samplesref->audio->channel_layout != link->channel_layout ||
177 samplesref->audio->planar != link->planar) {
179 if (!logged) log_input_change(ctx, link, samplesref);
181 abuffer->sample_format = samplesref->format;
182 abuffer->channel_layout = samplesref->audio->channel_layout;
183 abuffer->packing_format = samplesref->audio->planar;
185 if (!abuffer->aconvert) {
186 ret = insert_filter(abuffer, link, &abuffer->aconvert, "aconvert");
187 if (ret < 0) return ret;
189 link = abuffer->aconvert->outputs[0];
190 if (samplesref->format == link->format &&
191 samplesref->audio->channel_layout == link->channel_layout &&
192 samplesref->audio->planar == link->planar
194 remove_filter(&abuffer->aconvert);
196 if ((ret = reconfigure_filter(abuffer, abuffer->aconvert)) < 0)
201 if (sizeof(samplesref) != av_fifo_generic_write(abuffer->fifo, &samplesref,
202 sizeof(samplesref), NULL)) {
203 av_log(ctx, AV_LOG_ERROR, "Error while writing to FIFO\n");
204 return AVERROR(EINVAL);
210 int av_asrc_buffer_add_samples(AVFilterContext *ctx,
211 uint8_t *data[8], int linesize[8],
212 int nb_samples, int sample_rate,
213 int sample_fmt, int64_t channel_layout, int planar,
214 int64_t pts, int av_unused flags)
216 AVFilterBufferRef *samplesref;
218 samplesref = avfilter_get_audio_buffer_ref_from_arrays(
219 data, linesize, AV_PERM_WRITE,
221 sample_fmt, channel_layout, planar);
223 return AVERROR(ENOMEM);
225 samplesref->buf->free = buf_free;
226 samplesref->pts = pts;
227 samplesref->audio->sample_rate = sample_rate;
229 return av_asrc_buffer_add_audio_buffer_ref(ctx, samplesref, 0);
232 int av_asrc_buffer_add_buffer(AVFilterContext *ctx,
233 uint8_t *buf, int buf_size, int sample_rate,
234 int sample_fmt, int64_t channel_layout, int planar,
235 int64_t pts, int av_unused flags)
239 int nb_channels = av_get_channel_layout_nb_channels(channel_layout),
240 nb_samples = buf_size / nb_channels / av_get_bytes_per_sample(sample_fmt);
242 av_samples_fill_arrays(data, linesize,
243 buf, nb_channels, nb_samples,
244 sample_fmt, planar, 16);
246 return av_asrc_buffer_add_samples(ctx,
247 data, linesize, nb_samples,
249 sample_fmt, channel_layout, planar,
253 static av_cold int init(AVFilterContext *ctx, const char *args0, void *opaque)
255 ABufferSourceContext *abuffer = ctx->priv;
256 char *arg = NULL, *ptr, chlayout_str[16];
257 char *args = av_strdup(args0);
260 arg = av_strtok(args, ":", &ptr);
262 #define ADD_FORMAT(fmt_name) \
265 if ((ret = ff_parse_##fmt_name(&abuffer->fmt_name, arg, ctx)) < 0) { \
270 arg = av_strtok(NULL, ":", &ptr)
272 ADD_FORMAT(sample_rate);
273 ADD_FORMAT(sample_format);
274 ADD_FORMAT(channel_layout);
275 ADD_FORMAT(packing_format);
277 abuffer->fifo = av_fifo_alloc(FIFO_SIZE*sizeof(AVFilterBufferRef*));
278 if (!abuffer->fifo) {
279 av_log(ctx, AV_LOG_ERROR, "Failed to allocate fifo, filter init failed.\n");
280 return AVERROR(ENOMEM);
283 av_get_channel_layout_string(chlayout_str, sizeof(chlayout_str),
284 -1, abuffer->channel_layout);
285 av_log(ctx, AV_LOG_INFO, "format:%s layout:%s rate:%d\n",
286 av_get_sample_fmt_name(abuffer->sample_format), chlayout_str,
287 abuffer->sample_rate);
293 av_log(ctx, AV_LOG_ERROR, "Invalid arguments, must be of the form "
294 "sample_rate:sample_fmt:channel_layout:packing\n");
296 return AVERROR(EINVAL);
299 static av_cold void uninit(AVFilterContext *ctx)
301 ABufferSourceContext *abuffer = ctx->priv;
302 av_fifo_free(abuffer->fifo);
305 static int query_formats(AVFilterContext *ctx)
307 ABufferSourceContext *abuffer = ctx->priv;
308 AVFilterFormats *formats;
311 avfilter_add_format(&formats, abuffer->sample_format);
312 avfilter_set_common_sample_formats(ctx, formats);
315 avfilter_add_format(&formats, abuffer->channel_layout);
316 avfilter_set_common_channel_layouts(ctx, formats);
319 avfilter_add_format(&formats, abuffer->packing_format);
320 avfilter_set_common_packing_formats(ctx, formats);
325 static int config_output(AVFilterLink *outlink)
327 ABufferSourceContext *abuffer = outlink->src->priv;
328 outlink->sample_rate = abuffer->sample_rate;
332 static int request_frame(AVFilterLink *outlink)
334 ABufferSourceContext *abuffer = outlink->src->priv;
335 AVFilterBufferRef *samplesref;
337 if (!av_fifo_size(abuffer->fifo)) {
338 av_log(outlink->src, AV_LOG_ERROR,
339 "request_frame() called with no available frames!\n");
340 return AVERROR(EINVAL);
343 av_fifo_generic_read(abuffer->fifo, &samplesref, sizeof(samplesref), NULL);
344 avfilter_filter_samples(outlink, avfilter_ref_buffer(samplesref, ~0));
345 avfilter_unref_buffer(samplesref);
350 static int poll_frame(AVFilterLink *outlink)
352 ABufferSourceContext *abuffer = outlink->src->priv;
353 return av_fifo_size(abuffer->fifo)/sizeof(AVFilterBufferRef*);
356 AVFilter avfilter_asrc_abuffer = {
358 .description = NULL_IF_CONFIG_SMALL("Buffer audio frames, and make them accessible to the filterchain."),
359 .priv_size = sizeof(ABufferSourceContext),
360 .query_formats = query_formats,
365 .inputs = (const AVFilterPad[]) {{ .name = NULL }},
366 .outputs = (const AVFilterPad[]) {{ .name = "default",
367 .type = AVMEDIA_TYPE_AUDIO,
368 .request_frame = request_frame,
369 .poll_frame = poll_frame,
370 .config_props = config_output, },