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/fifo.h"
29 #include "asrc_abuffer.h"
33 // Audio format of incoming buffers
35 unsigned int sample_format;
36 int64_t channel_layout;
39 // FIFO buffer of audio buffer ref pointers
42 // Normalization filters
43 AVFilterContext *aconvert;
44 AVFilterContext *aresample;
45 } ABufferSourceContext;
49 static void buf_free(AVFilterBuffer *ptr)
55 static void set_link_source(AVFilterContext *src, AVFilterLink *link)
58 link->srcpad = &(src->output_pads[0]);
59 src->outputs[0] = link;
62 static int reconfigure_filter(ABufferSourceContext *abuffer, AVFilterContext *filt_ctx)
65 AVFilterLink * const inlink = filt_ctx->inputs[0];
66 AVFilterLink * const outlink = filt_ctx->outputs[0];
68 inlink->format = abuffer->sample_format;
69 inlink->channel_layout = abuffer->channel_layout;
70 inlink->planar = abuffer->packing_format;
71 inlink->sample_rate = abuffer->sample_rate;
73 filt_ctx->filter->uninit(filt_ctx);
74 memset(filt_ctx->priv, 0, filt_ctx->filter->priv_size);
75 if ((ret = filt_ctx->filter->init(filt_ctx, NULL , NULL)) < 0)
77 if ((ret = inlink->srcpad->config_props(inlink)) < 0)
79 return outlink->srcpad->config_props(outlink);
82 static int insert_filter(ABufferSourceContext *abuffer,
83 AVFilterLink *link, AVFilterContext **filt_ctx,
84 const char *filt_name)
88 if ((ret = avfilter_open(filt_ctx, avfilter_get_by_name(filt_name), NULL)) < 0)
91 link->src->outputs[0] = NULL;
92 if ((ret = avfilter_link(link->src, 0, *filt_ctx, 0)) < 0) {
93 link->src->outputs[0] = link;
97 set_link_source(*filt_ctx, link);
99 if ((ret = reconfigure_filter(abuffer, *filt_ctx)) < 0) {
100 avfilter_free(*filt_ctx);
107 static void remove_filter(AVFilterContext **filt_ctx)
109 AVFilterLink *outlink = (*filt_ctx)->outputs[0];
110 AVFilterContext *src = (*filt_ctx)->inputs[0]->src;
112 (*filt_ctx)->outputs[0] = NULL;
113 avfilter_free(*filt_ctx);
116 set_link_source(src, outlink);
119 static inline void log_input_change(void *ctx, AVFilterLink *link, AVFilterBufferRef *ref)
121 char old_layout_str[16], new_layout_str[16];
122 av_get_channel_layout_string(old_layout_str, sizeof(old_layout_str),
123 -1, link->channel_layout);
124 av_get_channel_layout_string(new_layout_str, sizeof(new_layout_str),
125 -1, ref->audio->channel_layout);
126 av_log(ctx, AV_LOG_INFO,
127 "Audio input format changed: "
128 "%s:%s:%d -> %s:%s:%d, normalizing\n",
129 av_get_sample_fmt_name(link->format),
130 old_layout_str, (int)link->sample_rate,
131 av_get_sample_fmt_name(ref->format),
132 new_layout_str, ref->audio->sample_rate);
135 int av_asrc_buffer_add_audio_buffer_ref(AVFilterContext *ctx,
136 AVFilterBufferRef *samplesref,
139 ABufferSourceContext *abuffer = ctx->priv;
143 if (av_fifo_space(abuffer->fifo) < sizeof(samplesref)) {
144 av_log(ctx, AV_LOG_ERROR,
145 "Buffering limit reached. Please consume some available frames "
146 "before adding new ones.\n");
147 return AVERROR(EINVAL);
152 link = ctx->outputs[0];
153 if (samplesref->audio->sample_rate != link->sample_rate) {
155 log_input_change(ctx, link, samplesref);
158 abuffer->sample_rate = samplesref->audio->sample_rate;
160 if (!abuffer->aresample) {
161 ret = insert_filter(abuffer, link, &abuffer->aresample, "aresample");
162 if (ret < 0) return ret;
164 link = abuffer->aresample->outputs[0];
165 if (samplesref->audio->sample_rate == link->sample_rate)
166 remove_filter(&abuffer->aresample);
168 if ((ret = reconfigure_filter(abuffer, abuffer->aresample)) < 0)
173 link = ctx->outputs[0];
174 if (samplesref->format != link->format ||
175 samplesref->audio->channel_layout != link->channel_layout ||
176 samplesref->audio->planar != link->planar) {
178 if (!logged) log_input_change(ctx, link, samplesref);
180 abuffer->sample_format = samplesref->format;
181 abuffer->channel_layout = samplesref->audio->channel_layout;
182 abuffer->packing_format = samplesref->audio->planar;
184 if (!abuffer->aconvert) {
185 ret = insert_filter(abuffer, link, &abuffer->aconvert, "aconvert");
186 if (ret < 0) return ret;
188 link = abuffer->aconvert->outputs[0];
189 if (samplesref->format == link->format &&
190 samplesref->audio->channel_layout == link->channel_layout &&
191 samplesref->audio->planar == link->planar
193 remove_filter(&abuffer->aconvert);
195 if ((ret = reconfigure_filter(abuffer, abuffer->aconvert)) < 0)
200 if (sizeof(samplesref) != av_fifo_generic_write(abuffer->fifo, &samplesref,
201 sizeof(samplesref), NULL)) {
202 av_log(ctx, AV_LOG_ERROR, "Error while writing to FIFO\n");
203 return AVERROR(EINVAL);
209 int av_asrc_buffer_add_samples(AVFilterContext *ctx,
210 uint8_t *data[8], int linesize[8],
211 int nb_samples, int sample_rate,
212 int sample_fmt, int64_t channel_layout, int planar,
213 int64_t pts, int av_unused flags)
215 AVFilterBufferRef *samplesref;
217 samplesref = avfilter_get_audio_buffer_ref_from_arrays(
218 data, linesize, AV_PERM_WRITE,
220 sample_fmt, channel_layout, planar);
222 return AVERROR(ENOMEM);
224 samplesref->buf->free = buf_free;
225 samplesref->pts = pts;
226 samplesref->audio->sample_rate = sample_rate;
228 return av_asrc_buffer_add_audio_buffer_ref(ctx, samplesref, 0);
231 int av_asrc_buffer_add_buffer(AVFilterContext *ctx,
232 uint8_t *buf, int buf_size, int sample_rate,
233 int sample_fmt, int64_t channel_layout, int planar,
234 int64_t pts, int av_unused flags)
238 int nb_channels = av_get_channel_layout_nb_channels(channel_layout),
239 nb_samples = buf_size / nb_channels / av_get_bytes_per_sample(sample_fmt);
241 av_samples_fill_arrays(data, linesize,
242 buf, nb_channels, nb_samples,
243 sample_fmt, planar, 16);
245 return av_asrc_buffer_add_samples(ctx,
246 data, linesize, nb_samples,
248 sample_fmt, channel_layout, planar,
252 static av_cold int init(AVFilterContext *ctx, const char *args0, void *opaque)
254 ABufferSourceContext *abuffer = ctx->priv;
255 char *arg = NULL, *ptr, chlayout_str[16];
256 char *args = av_strdup(args0);
259 arg = strtok_r(args, ":", &ptr);
261 #define ADD_FORMAT(fmt_name) \
264 if ((ret = ff_parse_##fmt_name(&abuffer->fmt_name, arg, ctx)) < 0) { \
269 arg = strtok_r(NULL, ":", &ptr)
271 ADD_FORMAT(sample_rate);
272 ADD_FORMAT(sample_format);
273 ADD_FORMAT(channel_layout);
274 ADD_FORMAT(packing_format);
276 abuffer->fifo = av_fifo_alloc(FIFO_SIZE*sizeof(AVFilterBufferRef*));
277 if (!abuffer->fifo) {
278 av_log(ctx, AV_LOG_ERROR, "Failed to allocate fifo, filter init failed.\n");
279 return AVERROR(ENOMEM);
282 av_get_channel_layout_string(chlayout_str, sizeof(chlayout_str),
283 -1, abuffer->channel_layout);
284 av_log(ctx, AV_LOG_INFO, "format:%s layout:%s rate:%d\n",
285 av_get_sample_fmt_name(abuffer->sample_format), chlayout_str,
286 abuffer->sample_rate);
292 av_log(ctx, AV_LOG_ERROR, "Invalid arguments, must be of the form "
293 "sample_rate:sample_fmt:channel_layout:packing\n");
295 return AVERROR(EINVAL);
298 static av_cold void uninit(AVFilterContext *ctx)
300 ABufferSourceContext *abuffer = ctx->priv;
301 av_fifo_free(abuffer->fifo);
304 static int query_formats(AVFilterContext *ctx)
306 ABufferSourceContext *abuffer = ctx->priv;
307 AVFilterFormats *formats;
310 avfilter_add_format(&formats, abuffer->sample_format);
311 avfilter_set_common_sample_formats(ctx, formats);
314 avfilter_add_format(&formats, abuffer->channel_layout);
315 avfilter_set_common_channel_layouts(ctx, formats);
318 avfilter_add_format(&formats, abuffer->packing_format);
319 avfilter_set_common_packing_formats(ctx, formats);
324 static int config_output(AVFilterLink *outlink)
326 ABufferSourceContext *abuffer = outlink->src->priv;
327 outlink->sample_rate = abuffer->sample_rate;
331 static int request_frame(AVFilterLink *outlink)
333 ABufferSourceContext *abuffer = outlink->src->priv;
334 AVFilterBufferRef *samplesref;
336 if (!av_fifo_size(abuffer->fifo)) {
337 av_log(outlink->src, AV_LOG_ERROR,
338 "request_frame() called with no available frames!\n");
339 return AVERROR(EINVAL);
342 av_fifo_generic_read(abuffer->fifo, &samplesref, sizeof(samplesref), NULL);
343 avfilter_filter_samples(outlink, avfilter_ref_buffer(samplesref, ~0));
344 avfilter_unref_buffer(samplesref);
349 static int poll_frame(AVFilterLink *outlink)
351 ABufferSourceContext *abuffer = outlink->src->priv;
352 return av_fifo_size(abuffer->fifo)/sizeof(AVFilterBufferRef*);
355 AVFilter avfilter_asrc_abuffer = {
357 .description = NULL_IF_CONFIG_SMALL("Buffer audio frames, and make them accessible to the filterchain."),
358 .priv_size = sizeof(ABufferSourceContext),
359 .query_formats = query_formats,
364 .inputs = (AVFilterPad[]) {{ .name = NULL }},
365 .outputs = (AVFilterPad[]) {{ .name = "default",
366 .type = AVMEDIA_TYPE_AUDIO,
367 .request_frame = request_frame,
368 .poll_frame = poll_frame,
369 .config_props = config_output, },