FFmpeg
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
buffersrc.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2008 Vitor Sessak
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 /**
22  * @file
23  * memory buffer source filter
24  */
25 
26 #include "libavutil/channel_layout.h"
27 #include "libavutil/common.h"
28 #include "libavutil/fifo.h"
29 #include "libavutil/imgutils.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/samplefmt.h"
32 #include "audio.h"
33 #include "avfilter.h"
34 #include "buffersrc.h"
35 #include "formats.h"
36 #include "internal.h"
37 #include "video.h"
38 #include "avcodec.h"
39 
40 typedef struct {
41  const AVClass *class;
42  AVFifoBuffer *fifo;
43  AVRational time_base; ///< time_base to set in the output link
44  AVRational frame_rate; ///< frame_rate to set in the output link
45  unsigned nb_failed_requests;
46  unsigned warning_limit;
47 
48  /* video only */
49  int w, h;
50  enum AVPixelFormat pix_fmt;
51  AVRational pixel_aspect;
52  char *sws_param;
53 
54  /* audio only */
55  int sample_rate;
56  enum AVSampleFormat sample_fmt;
57  char *sample_fmt_str;
58  uint64_t channel_layout;
59  char *channel_layout_str;
60 
61  int eof;
62 } BufferSourceContext;
63 
64 #define CHECK_VIDEO_PARAM_CHANGE(s, c, width, height, format)\
65  if (c->w != width || c->h != height || c->pix_fmt != format) {\
66  av_log(s, AV_LOG_INFO, "Changing frame properties on the fly is not supported by all filters.\n");\
67  }
68 
69 #define CHECK_AUDIO_PARAM_CHANGE(s, c, srate, ch_layout, format)\
70  if (c->sample_fmt != format || c->sample_rate != srate ||\
71  c->channel_layout != ch_layout) {\
72  av_log(s, AV_LOG_ERROR, "Changing frame properties on the fly is not supported.\n");\
73  return AVERROR(EINVAL);\
74  }
75 
76 int av_buffersrc_add_frame(AVFilterContext *buffer_src,
77  const AVFrame *frame, int flags)
78 {
79  AVFilterBufferRef *picref;
80  int ret;
81 
82  if (!frame) /* NULL for EOF */
83  return av_buffersrc_add_ref(buffer_src, NULL, flags);
84 
85  picref = avfilter_get_buffer_ref_from_frame(buffer_src->outputs[0]->type,
86  frame, AV_PERM_WRITE);
87  if (!picref)
88  return AVERROR(ENOMEM);
89  ret = av_buffersrc_add_ref(buffer_src, picref, flags);
90  picref->buf->data[0] = NULL;
91  avfilter_unref_buffer(picref);
92  return ret;
93 }
94 
95 int av_buffersrc_write_frame(AVFilterContext *buffer_filter, const AVFrame *frame)
96 {
97  return av_buffersrc_add_frame(buffer_filter, frame, 0);
98 }
99 
100 int av_buffersrc_add_ref(AVFilterContext *s, AVFilterBufferRef *buf, int flags)
101 {
102  BufferSourceContext *c = s->priv;
103  AVFilterBufferRef *to_free = NULL;
104  int ret;
105 
106  if (!buf) {
107  c->eof = 1;
108  return 0;
109  } else if (c->eof)
110  return AVERROR(EINVAL);
111 
112  if (!av_fifo_space(c->fifo) &&
113  (ret = av_fifo_realloc2(c->fifo, av_fifo_size(c->fifo) +
114  sizeof(buf))) < 0)
115  return ret;
116 
117  if (!(flags & AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT)) {
118  switch (s->outputs[0]->type) {
119  case AVMEDIA_TYPE_VIDEO:
120  CHECK_VIDEO_PARAM_CHANGE(s, c, buf->video->w, buf->video->h, buf->format);
121  break;
122  case AVMEDIA_TYPE_AUDIO:
123  CHECK_AUDIO_PARAM_CHANGE(s, c, buf->audio->sample_rate, buf->audio->channel_layout,
124  buf->format);
125  break;
126  default:
127  return AVERROR(EINVAL);
128  }
129  }
130  if (!(flags & AV_BUFFERSRC_FLAG_NO_COPY))
131  to_free = buf = ff_copy_buffer_ref(s->outputs[0], buf);
132  if(!buf)
133  return -1;
134 
135  if ((ret = av_fifo_generic_write(c->fifo, &buf, sizeof(buf), NULL)) < 0) {
136  avfilter_unref_buffer(to_free);
137  return ret;
138  }
139  c->nb_failed_requests = 0;
140  if (c->warning_limit &&
141  av_fifo_size(c->fifo) / sizeof(buf) >= c->warning_limit) {
142  av_log(s, AV_LOG_WARNING,
143  "%d buffers queued in %s, something may be wrong.\n",
144  c->warning_limit,
145  (char *)av_x_if_null(s->name, s->filter->name));
146  c->warning_limit *= 10;
147  }
148 
149  if ((flags & AV_BUFFERSRC_FLAG_PUSH))
150  if ((ret = s->output_pads[0].request_frame(s->outputs[0])) < 0)
151  return ret;
152 
153  return 0;
154 }
155 
156 #ifdef FF_API_BUFFERSRC_BUFFER
157 int av_buffersrc_buffer(AVFilterContext *s, AVFilterBufferRef *buf)
158 {
159  return av_buffersrc_add_ref(s, buf, AV_BUFFERSRC_FLAG_NO_COPY);
160 }
161 #endif
162 
163 unsigned av_buffersrc_get_nb_failed_requests(AVFilterContext *buffer_src)
164 {
165  return ((BufferSourceContext *)buffer_src->priv)->nb_failed_requests;
166 }
167 
168 #define OFFSET(x) offsetof(BufferSourceContext, x)
169 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
170 static const AVOption buffer_options[] = {
171  { "time_base", NULL, OFFSET(time_base), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, INT_MAX, FLAGS },
172  { "frame_rate", NULL, OFFSET(frame_rate), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, INT_MAX, FLAGS },
173  { "video_size", NULL, OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, .flags = FLAGS },
174  { "pix_fmt", NULL, OFFSET(pix_fmt), AV_OPT_TYPE_PIXEL_FMT, .flags = FLAGS },
175  { "pixel_aspect", NULL, OFFSET(pixel_aspect), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, INT_MAX, FLAGS },
176  { "sws_param", NULL, OFFSET(sws_param), AV_OPT_TYPE_STRING, .flags = FLAGS },
177  { NULL },
178 };
179 #undef FLAGS
180 
181 AVFILTER_DEFINE_CLASS(buffer);
182 
183 static av_cold int init_video(AVFilterContext *ctx, const char *args)
184 {
185  BufferSourceContext *c = ctx->priv;
186  char pix_fmt_str[128], sws_param[256] = "", *colon, *equal;
187  int ret, n = 0;
188 
189  c->class = &buffer_class;
190 
191  if (!args) {
192  av_log(ctx, AV_LOG_ERROR, "Arguments required\n");
193  return AVERROR(EINVAL);
194  }
195  colon = strchr(args, ':');
196  equal = strchr(args, '=');
197  if (equal && (!colon || equal < colon)) {
198  av_opt_set_defaults(c);
199  ret = av_set_options_string(c, args, "=", ":");
200  if (ret < 0)
201  goto fail;
202  } else {
203  if ((n = sscanf(args, "%d:%d:%127[^:]:%d:%d:%d:%d:%255c", &c->w, &c->h, pix_fmt_str,
204  &c->time_base.num, &c->time_base.den,
205  &c->pixel_aspect.num, &c->pixel_aspect.den, sws_param)) < 7) {
206  av_log(ctx, AV_LOG_ERROR, "Expected at least 7 arguments, but only %d found in '%s'\n", n, args);
207  ret = AVERROR(EINVAL);
208  goto fail;
209  }
210  av_log(ctx, AV_LOG_WARNING, "Flat options syntax is deprecated, use key=value pairs\n");
211 
212  if ((ret = ff_parse_pixel_format(&c->pix_fmt, pix_fmt_str, ctx)) < 0)
213  goto fail;
214  c->sws_param = av_strdup(sws_param);
215  if (!c->sws_param) {
216  ret = AVERROR(ENOMEM);
217  goto fail;
218  }
219  }
220 
221  if (!(c->fifo = av_fifo_alloc(sizeof(AVFilterBufferRef*)))) {
222  ret = AVERROR(ENOMEM);
223  goto fail;
224  }
225 
226  av_log(ctx, AV_LOG_VERBOSE, "w:%d h:%d pixfmt:%s tb:%d/%d fr:%d/%d sar:%d/%d sws_param:%s\n",
227  c->w, c->h, av_get_pix_fmt_name(c->pix_fmt),
228  c->time_base.num, c->time_base.den, c->frame_rate.num, c->frame_rate.den,
229  c->pixel_aspect.num, c->pixel_aspect.den, (char *)av_x_if_null(c->sws_param, ""));
230  c->warning_limit = 100;
231  return 0;
232 
233 fail:
234  av_opt_free(c);
235  return ret;
236 }
237 
238 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_AUDIO_PARAM
239 static const AVOption abuffer_options[] = {
240  { "time_base", NULL, OFFSET(time_base), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, INT_MAX, FLAGS },
241  { "sample_rate", NULL, OFFSET(sample_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
242  { "sample_fmt", NULL, OFFSET(sample_fmt_str), AV_OPT_TYPE_STRING, .flags = FLAGS },
243  { "channel_layout", NULL, OFFSET(channel_layout_str), AV_OPT_TYPE_STRING, .flags = FLAGS },
244  { NULL },
245 };
246 
247 AVFILTER_DEFINE_CLASS(abuffer);
248 
249 static av_cold int init_audio(AVFilterContext *ctx, const char *args)
250 {
251  BufferSourceContext *s = ctx->priv;
252  int ret = 0;
253 
254  s->class = &abuffer_class;
255  av_opt_set_defaults(s);
256 
257  if ((ret = av_set_options_string(s, args, "=", ":")) < 0)
258  goto fail;
259 
260  s->sample_fmt = av_get_sample_fmt(s->sample_fmt_str);
261  if (s->sample_fmt == AV_SAMPLE_FMT_NONE) {
262  av_log(ctx, AV_LOG_ERROR, "Invalid sample format '%s'\n",
263  s->sample_fmt_str);
264  ret = AVERROR(EINVAL);
265  goto fail;
266  }
267 
268  s->channel_layout = av_get_channel_layout(s->channel_layout_str);
269  if (!s->channel_layout) {
270  av_log(ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n",
271  s->channel_layout_str);
272  ret = AVERROR(EINVAL);
273  goto fail;
274  }
275 
276  if (!(s->fifo = av_fifo_alloc(sizeof(AVFilterBufferRef*)))) {
277  ret = AVERROR(ENOMEM);
278  goto fail;
279  }
280 
281  if (!s->time_base.num)
282  s->time_base = (AVRational){1, s->sample_rate};
283 
284  av_log(ctx, AV_LOG_VERBOSE,
285  "tb:%d/%d samplefmt:%s samplerate:%d chlayout:%s\n",
286  s->time_base.num, s->time_base.den, s->sample_fmt_str,
287  s->sample_rate, s->channel_layout_str);
288  s->warning_limit = 100;
289 
290 fail:
291  av_opt_free(s);
292  return ret;
293 }
294 
295 static av_cold void uninit(AVFilterContext *ctx)
296 {
297  BufferSourceContext *s = ctx->priv;
298  while (s->fifo && av_fifo_size(s->fifo)) {
299  AVFilterBufferRef *buf;
300  av_fifo_generic_read(s->fifo, &buf, sizeof(buf), NULL);
301  avfilter_unref_buffer(buf);
302  }
303  av_fifo_free(s->fifo);
304  s->fifo = NULL;
305  av_freep(&s->sws_param);
306 }
307 
308 static int query_formats(AVFilterContext *ctx)
309 {
310  BufferSourceContext *c = ctx->priv;
311  AVFilterChannelLayouts *channel_layouts = NULL;
312  AVFilterFormats *formats = NULL;
313  AVFilterFormats *samplerates = NULL;
314 
315  switch (ctx->outputs[0]->type) {
316  case AVMEDIA_TYPE_VIDEO:
317  ff_add_format(&formats, c->pix_fmt);
318  ff_set_common_formats(ctx, formats);
319  break;
320  case AVMEDIA_TYPE_AUDIO:
321  ff_add_format(&formats, c->sample_fmt);
322  ff_set_common_formats(ctx, formats);
323 
324  ff_add_format(&samplerates, c->sample_rate);
325  ff_set_common_samplerates(ctx, samplerates);
326 
327  ff_add_channel_layout(&channel_layouts, c->channel_layout);
328  ff_set_common_channel_layouts(ctx, channel_layouts);
329  break;
330  default:
331  return AVERROR(EINVAL);
332  }
333 
334  return 0;
335 }
336 
337 static int config_props(AVFilterLink *link)
338 {
339  BufferSourceContext *c = link->src->priv;
340 
341  switch (link->type) {
342  case AVMEDIA_TYPE_VIDEO:
343  link->w = c->w;
344  link->h = c->h;
345  link->sample_aspect_ratio = c->pixel_aspect;
346  break;
347  case AVMEDIA_TYPE_AUDIO:
348  break;
349  default:
350  return AVERROR(EINVAL);
351  }
352 
353  link->time_base = c->time_base;
354  link->frame_rate = c->frame_rate;
355  return 0;
356 }
357 
358 static int request_frame(AVFilterLink *link)
359 {
360  BufferSourceContext *c = link->src->priv;
361  AVFilterBufferRef *buf;
362  int ret = 0;
363 
364  if (!av_fifo_size(c->fifo)) {
365  if (c->eof)
366  return AVERROR_EOF;
367  c->nb_failed_requests++;
368  return AVERROR(EAGAIN);
369  }
370  av_fifo_generic_read(c->fifo, &buf, sizeof(buf), NULL);
371 
372  ff_filter_frame(link, buf);
373 
374  return ret;
375 }
376 
377 static int poll_frame(AVFilterLink *link)
378 {
379  BufferSourceContext *c = link->src->priv;
380  int size = av_fifo_size(c->fifo);
381  if (!size && c->eof)
382  return AVERROR_EOF;
383  return size/sizeof(AVFilterBufferRef*);
384 }
385 
386 static const AVFilterPad avfilter_vsrc_buffer_outputs[] = {
387  {
388  .name = "default",
389  .type = AVMEDIA_TYPE_VIDEO,
390  .request_frame = request_frame,
391  .poll_frame = poll_frame,
392  .config_props = config_props,
393  },
394  { NULL }
395 };
396 
397 AVFilter avfilter_vsrc_buffer = {
398  .name = "buffer",
399  .description = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them accessible to the filterchain."),
400  .priv_size = sizeof(BufferSourceContext),
401  .query_formats = query_formats,
402 
403  .init = init_video,
404  .uninit = uninit,
405 
406  .inputs = NULL,
407  .outputs = avfilter_vsrc_buffer_outputs,
408  .priv_class = &buffer_class,
409 };
410 
411 static const AVFilterPad avfilter_asrc_abuffer_outputs[] = {
412  {
413  .name = "default",
414  .type = AVMEDIA_TYPE_AUDIO,
415  .request_frame = request_frame,
416  .poll_frame = poll_frame,
417  .config_props = config_props,
418  },
419  { NULL }
420 };
421 
422 AVFilter avfilter_asrc_abuffer = {
423  .name = "abuffer",
424  .description = NULL_IF_CONFIG_SMALL("Buffer audio frames, and make them accessible to the filterchain."),
425  .priv_size = sizeof(BufferSourceContext),
426  .query_formats = query_formats,
427 
428  .init = init_audio,
429  .uninit = uninit,
430 
431  .inputs = NULL,
432  .outputs = avfilter_asrc_abuffer_outputs,
433  .priv_class = &abuffer_class,
434 };
Generated on Sat May 25 2013 03:58:44 for FFmpeg by   doxygen 1.8.2