Merge commit '7e350379f87e7f74420b4813170fe808e2313911'
[ffmpeg.git] / libavfilter / buffersrc.c
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/frame.h"
30 #include "libavutil/imgutils.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/samplefmt.h"
33 #include "audio.h"
34 #include "avfilter.h"
35 #include "buffersrc.h"
36 #include "formats.h"
37 #include "internal.h"
38 #include "video.h"
39 #include "avcodec.h"
40
41 typedef struct {
42     const AVClass    *class;
43     AVFifoBuffer     *fifo;
44     AVRational        time_base;     ///< time_base to set in the output link
45     AVRational        frame_rate;    ///< frame_rate to set in the output link
46     unsigned          nb_failed_requests;
47     unsigned          warning_limit;
48
49     /* video only */
50     int               w, h;
51     enum AVPixelFormat  pix_fmt;
52     AVRational        pixel_aspect;
53     char              *sws_param;
54
55     /* audio only */
56     int sample_rate;
57     enum AVSampleFormat sample_fmt;
58     char               *sample_fmt_str;
59     int channels;
60     uint64_t channel_layout;
61     char    *channel_layout_str;
62
63     int eof;
64 } BufferSourceContext;
65
66 #define CHECK_VIDEO_PARAM_CHANGE(s, c, width, height, format)\
67     if (c->w != width || c->h != height || c->pix_fmt != format) {\
68         av_log(s, AV_LOG_INFO, "Changing frame properties on the fly is not supported by all filters.\n");\
69     }
70
71 #define CHECK_AUDIO_PARAM_CHANGE(s, c, srate, ch_layout, format)\
72     if (c->sample_fmt != format || c->sample_rate != srate ||\
73         c->channel_layout != ch_layout) {\
74         av_log(s, AV_LOG_ERROR, "Changing frame properties on the fly is not supported.\n");\
75         return AVERROR(EINVAL);\
76     }
77
78 int av_buffersrc_add_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags)
79 {
80     return av_buffersrc_add_frame(ctx, frame);
81 }
82
83 int av_buffersrc_write_frame(AVFilterContext *ctx, const AVFrame *frame)
84 {
85     AVFrame *copy;
86     int ret = 0;
87     int64_t layout = frame->channel_layout;
88
89     if (layout && av_get_channel_layout_nb_channels(layout) != av_frame_get_channels(frame)) {
90         av_log(0, AV_LOG_ERROR, "Layout indicates a different number of channels than actually present\n");
91         return AVERROR(EINVAL);
92     }
93
94     if (!(copy = av_frame_alloc()))
95         return AVERROR(ENOMEM);
96     ret = av_frame_ref(copy, frame);
97     if (ret >= 0)
98         ret = av_buffersrc_add_frame(ctx, copy);
99
100     av_frame_free(&copy);
101     return ret;
102 }
103
104 int av_buffersrc_add_frame(AVFilterContext *ctx, AVFrame *frame)
105 {
106     BufferSourceContext *s = ctx->priv;
107     AVFrame *copy;
108     int ret;
109     int64_t layout;
110
111     if (!frame) {
112         s->eof = 1;
113         return 0;
114     } else if (s->eof)
115         return AVERROR(EINVAL);
116
117     switch (ctx->outputs[0]->type) {
118     case AVMEDIA_TYPE_VIDEO:
119         CHECK_VIDEO_PARAM_CHANGE(ctx, s, frame->width, frame->height,
120                                  frame->format);
121         break;
122     case AVMEDIA_TYPE_AUDIO:
123         CHECK_AUDIO_PARAM_CHANGE(ctx, s, frame->sample_rate, frame->channel_layout,
124                                  frame->format);
125
126         layout = frame->channel_layout;
127         if (layout && av_get_channel_layout_nb_channels(layout) != av_frame_get_channels(frame)) {
128             av_log(0, AV_LOG_ERROR, "Layout indicates a different number of channels than actually present\n");
129             return AVERROR(EINVAL);
130         }
131         break;
132     default:
133         return AVERROR(EINVAL);
134     }
135
136     if (!av_fifo_space(s->fifo) &&
137         (ret = av_fifo_realloc2(s->fifo, av_fifo_size(s->fifo) +
138                                          sizeof(copy))) < 0)
139         return ret;
140
141     if (!(copy = av_frame_alloc()))
142         return AVERROR(ENOMEM);
143     av_frame_move_ref(copy, frame);
144
145     if ((ret = av_fifo_generic_write(s->fifo, &copy, sizeof(copy), NULL)) < 0) {
146         av_frame_move_ref(frame, copy);
147         av_frame_free(&copy);
148         return ret;
149     }
150
151     return 0;
152 }
153
154 #if FF_API_AVFILTERBUFFER
155 static void compat_free_buffer(void *opaque, uint8_t *data)
156 {
157     AVFilterBufferRef *buf = opaque;
158     avfilter_unref_buffer(buf);
159 }
160
161 static void compat_unref_buffer(void *opaque, uint8_t *data)
162 {
163     AVBufferRef *buf = opaque;
164     av_buffer_unref(&buf);
165 }
166
167 int av_buffersrc_add_ref(AVFilterContext *ctx, AVFilterBufferRef *buf,
168                          int flags)
169 {
170     BufferSourceContext *s = ctx->priv;
171     AVFrame *frame = NULL;
172     AVBufferRef *dummy_buf = NULL;
173     int ret = 0, planes, i;
174
175     if (!buf) {
176         s->eof = 1;
177         return 0;
178     } else if (s->eof)
179         return AVERROR(EINVAL);
180
181     frame = av_frame_alloc();
182     if (!frame)
183         return AVERROR(ENOMEM);
184
185     dummy_buf = av_buffer_create(NULL, 0, compat_free_buffer, buf,
186                                  (buf->perms & AV_PERM_WRITE) ? 0 : AV_BUFFER_FLAG_READONLY);
187     if (!dummy_buf) {
188         ret = AVERROR(ENOMEM);
189         goto fail;
190     }
191
192     if ((ret = avfilter_copy_buf_props(frame, buf)) < 0)
193         goto fail;
194
195 #define WRAP_PLANE(ref_out, data, data_size)                            \
196 do {                                                                    \
197     AVBufferRef *dummy_ref = av_buffer_ref(dummy_buf);                  \
198     if (!dummy_ref) {                                                   \
199         ret = AVERROR(ENOMEM);                                          \
200         goto fail;                                                      \
201     }                                                                   \
202     ref_out = av_buffer_create(data, data_size, compat_unref_buffer,    \
203                                dummy_ref, (buf->perms & AV_PERM_WRITE) ? 0 : AV_BUFFER_FLAG_READONLY);                           \
204     if (!ref_out) {                                                     \
205         av_frame_unref(frame);                                          \
206         ret = AVERROR(ENOMEM);                                          \
207         goto fail;                                                      \
208     }                                                                   \
209 } while (0)
210
211     if (ctx->outputs[0]->type  == AVMEDIA_TYPE_VIDEO) {
212         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
213
214         if (!desc) {
215             ret = AVERROR(EINVAL);
216             goto fail;
217         }
218         planes = (desc->flags & PIX_FMT_PLANAR) ? desc->nb_components : 1;
219
220         for (i = 0; i < planes; i++) {
221             int h_shift    = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
222             int plane_size = (frame->width >> h_shift) * frame->linesize[i];
223
224             WRAP_PLANE(frame->buf[i], frame->data[i], plane_size);
225         }
226     } else {
227         int planar = av_sample_fmt_is_planar(frame->format);
228         int channels = av_get_channel_layout_nb_channels(frame->channel_layout);
229
230         planes = planar ? channels : 1;
231
232         if (planes > FF_ARRAY_ELEMS(frame->buf)) {
233             frame->nb_extended_buf = planes - FF_ARRAY_ELEMS(frame->buf);
234             frame->extended_buf = av_mallocz(sizeof(*frame->extended_buf) *
235                                              frame->nb_extended_buf);
236             if (!frame->extended_buf) {
237                 ret = AVERROR(ENOMEM);
238                 goto fail;
239             }
240         }
241
242         for (i = 0; i < FFMIN(planes, FF_ARRAY_ELEMS(frame->buf)); i++)
243             WRAP_PLANE(frame->buf[i], frame->extended_data[i], frame->linesize[0]);
244
245         for (i = 0; i < planes - FF_ARRAY_ELEMS(frame->buf); i++)
246             WRAP_PLANE(frame->extended_buf[i],
247                        frame->extended_data[i + FF_ARRAY_ELEMS(frame->buf)],
248                        frame->linesize[0]);
249     }
250
251     ret = av_buffersrc_add_frame_flags(ctx, frame, flags);
252
253 fail:
254     av_buffer_unref(&dummy_buf);
255     av_frame_free(&frame);
256
257     return ret;
258 }
259
260 int av_buffersrc_buffer(AVFilterContext *ctx, AVFilterBufferRef *buf)
261 {
262     return av_buffersrc_add_ref(ctx, buf, 0);
263 }
264 #endif
265
266 #define OFFSET(x) offsetof(BufferSourceContext, x)
267 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
268 static const AVOption buffer_options[] = {
269     { "time_base",      NULL, OFFSET(time_base),           AV_OPT_TYPE_RATIONAL,   { .dbl = 0 }, 0, INT_MAX, FLAGS },
270     { "frame_rate",     NULL, OFFSET(frame_rate),          AV_OPT_TYPE_RATIONAL,   { .dbl = 0 }, 0, INT_MAX, FLAGS },
271     { "video_size",     NULL, OFFSET(w),                   AV_OPT_TYPE_IMAGE_SIZE, .flags = FLAGS },
272     { "pix_fmt",        NULL, OFFSET(pix_fmt),             AV_OPT_TYPE_PIXEL_FMT,  .flags = FLAGS },
273     { "pixel_aspect",   NULL, OFFSET(pixel_aspect),        AV_OPT_TYPE_RATIONAL,   { .dbl = 0 }, 0, INT_MAX, FLAGS },
274     { "sws_param",      NULL, OFFSET(sws_param),           AV_OPT_TYPE_STRING,     .flags = FLAGS },
275     { NULL },
276 };
277 #undef FLAGS
278
279 AVFILTER_DEFINE_CLASS(buffer);
280
281 static av_cold int init_video(AVFilterContext *ctx, const char *args)
282 {
283     BufferSourceContext *c = ctx->priv;
284     char pix_fmt_str[128], *colon, *equal;
285     int ret, n = 0;
286
287     c->class = &buffer_class;
288
289     if (!args) {
290         av_log(ctx, AV_LOG_ERROR, "Arguments required\n");
291         return AVERROR(EINVAL);
292     }
293
294     colon = strchr(args, ':');
295     equal = strchr(args, '=');
296     if (equal && (!colon || equal < colon)) {
297         av_opt_set_defaults(c);
298         ret = av_set_options_string(c, args, "=", ":");
299         if (ret < 0)
300             goto fail;
301     } else {
302     if (!args ||
303         (n = sscanf(args, "%d:%d:%127[^:]:%d:%d:%d:%d", &c->w, &c->h, pix_fmt_str,
304                     &c->time_base.num, &c->time_base.den,
305                     &c->pixel_aspect.num, &c->pixel_aspect.den)) != 7) {
306         av_log(ctx, AV_LOG_ERROR, "Expected 7 arguments, but %d found in '%s'\n", n, args);
307         return AVERROR(EINVAL);
308     }
309     if ((c->pix_fmt = av_get_pix_fmt(pix_fmt_str)) == AV_PIX_FMT_NONE) {
310         char *tail;
311         c->pix_fmt = strtol(pix_fmt_str, &tail, 10);
312         if (*tail || c->pix_fmt < 0 || c->pix_fmt >= AV_PIX_FMT_NB) {
313             av_log(ctx, AV_LOG_ERROR, "Invalid pixel format string '%s'\n", pix_fmt_str);
314             return AVERROR(EINVAL);
315         }
316     }
317     }
318
319     if (!(c->fifo = av_fifo_alloc(sizeof(AVFrame*))))
320         return AVERROR(ENOMEM);
321
322     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",
323            c->w, c->h, av_get_pix_fmt_name(c->pix_fmt),
324            c->time_base.num, c->time_base.den, c->frame_rate.num, c->frame_rate.den,
325            c->pixel_aspect.num, c->pixel_aspect.den, (char *)av_x_if_null(c->sws_param, ""));
326     c->warning_limit = 100;
327     return 0;
328
329 fail:
330     av_opt_free(c);
331     return ret;
332 }
333
334 unsigned av_buffersrc_get_nb_failed_requests(AVFilterContext *buffer_src)
335 {
336     return ((BufferSourceContext *)buffer_src->priv)->nb_failed_requests;
337 }
338
339 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_AUDIO_PARAM
340 static const AVOption abuffer_options[] = {
341     { "time_base",      NULL, OFFSET(time_base),           AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, INT_MAX, FLAGS },
342     { "sample_rate",    NULL, OFFSET(sample_rate),         AV_OPT_TYPE_INT,      { .i64 = 0 }, 0, INT_MAX, FLAGS },
343     { "sample_fmt",     NULL, OFFSET(sample_fmt_str),      AV_OPT_TYPE_STRING, .flags = FLAGS },
344     { "channels",       NULL, OFFSET(channels),            AV_OPT_TYPE_INT,      { .i64 = 0 }, 0, INT_MAX, FLAGS },
345     { "channel_layout", NULL, OFFSET(channel_layout_str),  AV_OPT_TYPE_STRING, .flags = FLAGS },
346     { NULL },
347 };
348
349 AVFILTER_DEFINE_CLASS(abuffer);
350
351 static av_cold int init_audio(AVFilterContext *ctx, const char *args)
352 {
353     BufferSourceContext *s = ctx->priv;
354     int ret = 0;
355
356     s->class = &abuffer_class;
357     av_opt_set_defaults(s);
358
359     if ((ret = av_set_options_string(s, args, "=", ":")) < 0)
360         goto fail;
361
362     s->sample_fmt = av_get_sample_fmt(s->sample_fmt_str);
363     if (s->sample_fmt == AV_SAMPLE_FMT_NONE) {
364         av_log(ctx, AV_LOG_ERROR, "Invalid sample format '%s'\n",
365                s->sample_fmt_str);
366         ret = AVERROR(EINVAL);
367         goto fail;
368     }
369
370     if (s->channel_layout_str) {
371         int n;
372         /* TODO reindent */
373     s->channel_layout = av_get_channel_layout(s->channel_layout_str);
374     if (!s->channel_layout) {
375         av_log(ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n",
376                s->channel_layout_str);
377         ret = AVERROR(EINVAL);
378         goto fail;
379     }
380         n = av_get_channel_layout_nb_channels(s->channel_layout);
381         if (s->channels) {
382             if (n != s->channels) {
383                 av_log(ctx, AV_LOG_ERROR,
384                        "Mismatching channel count %d and layout '%s' "
385                        "(%d channels)\n",
386                        s->channels, s->channel_layout_str, n);
387                 ret = AVERROR(EINVAL);
388                 goto fail;
389             }
390         }
391         s->channels = n;
392     } else if (!s->channels) {
393         av_log(ctx, AV_LOG_ERROR, "Neither number of channels nor "
394                                   "channel layout specified\n");
395         ret = AVERROR(EINVAL);
396         goto fail;
397     }
398
399     if (!(s->fifo = av_fifo_alloc(sizeof(AVFrame*)))) {
400         ret = AVERROR(ENOMEM);
401         goto fail;
402     }
403
404     if (!s->time_base.num)
405         s->time_base = (AVRational){1, s->sample_rate};
406
407     av_log(ctx, AV_LOG_VERBOSE,
408            "tb:%d/%d samplefmt:%s samplerate:%d chlayout:%s\n",
409            s->time_base.num, s->time_base.den, s->sample_fmt_str,
410            s->sample_rate, s->channel_layout_str);
411     s->warning_limit = 100;
412
413 fail:
414     av_opt_free(s);
415     return ret;
416 }
417
418 static av_cold void uninit(AVFilterContext *ctx)
419 {
420     BufferSourceContext *s = ctx->priv;
421     while (s->fifo && av_fifo_size(s->fifo)) {
422         AVFrame *frame;
423         av_fifo_generic_read(s->fifo, &frame, sizeof(frame), NULL);
424         av_frame_free(&frame);
425     }
426     av_fifo_free(s->fifo);
427     s->fifo = NULL;
428     av_freep(&s->sws_param);
429 }
430
431 static int query_formats(AVFilterContext *ctx)
432 {
433     BufferSourceContext *c = ctx->priv;
434     AVFilterChannelLayouts *channel_layouts = NULL;
435     AVFilterFormats *formats = NULL;
436     AVFilterFormats *samplerates = NULL;
437
438     switch (ctx->outputs[0]->type) {
439     case AVMEDIA_TYPE_VIDEO:
440         ff_add_format(&formats, c->pix_fmt);
441         ff_set_common_formats(ctx, formats);
442         break;
443     case AVMEDIA_TYPE_AUDIO:
444         ff_add_format(&formats,           c->sample_fmt);
445         ff_set_common_formats(ctx, formats);
446
447         ff_add_format(&samplerates,       c->sample_rate);
448         ff_set_common_samplerates(ctx, samplerates);
449
450         ff_add_channel_layout(&channel_layouts,
451                               c->channel_layout ? c->channel_layout :
452                               FF_COUNT2LAYOUT(c->channels));
453         ff_set_common_channel_layouts(ctx, channel_layouts);
454         break;
455     default:
456         return AVERROR(EINVAL);
457     }
458
459     return 0;
460 }
461
462 static int config_props(AVFilterLink *link)
463 {
464     BufferSourceContext *c = link->src->priv;
465
466     switch (link->type) {
467     case AVMEDIA_TYPE_VIDEO:
468         link->w = c->w;
469         link->h = c->h;
470         link->sample_aspect_ratio = c->pixel_aspect;
471         break;
472     case AVMEDIA_TYPE_AUDIO:
473         if (!c->channel_layout)
474             c->channel_layout = link->channel_layout;
475         break;
476     default:
477         return AVERROR(EINVAL);
478     }
479
480     link->time_base = c->time_base;
481     link->frame_rate = c->frame_rate;
482     return 0;
483 }
484
485 static int request_frame(AVFilterLink *link)
486 {
487     BufferSourceContext *c = link->src->priv;
488     AVFrame *frame;
489     int ret = 0;
490
491     if (!av_fifo_size(c->fifo)) {
492         if (c->eof)
493             return AVERROR_EOF;
494         c->nb_failed_requests++;
495         return AVERROR(EAGAIN);
496     }
497     av_fifo_generic_read(c->fifo, &frame, sizeof(frame), NULL);
498
499     /* CIG TODO do not ignore error */
500     ff_filter_frame(link, frame);
501
502     return ret;
503 }
504
505 static int poll_frame(AVFilterLink *link)
506 {
507     BufferSourceContext *c = link->src->priv;
508     int size = av_fifo_size(c->fifo);
509     if (!size && c->eof)
510         return AVERROR_EOF;
511     return size/sizeof(AVFrame*);
512 }
513
514 static const AVFilterPad avfilter_vsrc_buffer_outputs[] = {
515     {
516         .name          = "default",
517         .type          = AVMEDIA_TYPE_VIDEO,
518         .request_frame = request_frame,
519         .poll_frame    = poll_frame,
520         .config_props  = config_props,
521     },
522     { NULL }
523 };
524
525 AVFilter avfilter_vsrc_buffer = {
526     .name      = "buffer",
527     .description = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them accessible to the filterchain."),
528     .priv_size = sizeof(BufferSourceContext),
529     .query_formats = query_formats,
530
531     .init      = init_video,
532     .uninit    = uninit,
533
534     .inputs    = NULL,
535     .outputs   = avfilter_vsrc_buffer_outputs,
536     .priv_class = &buffer_class,
537 };
538
539 static const AVFilterPad avfilter_asrc_abuffer_outputs[] = {
540     {
541         .name          = "default",
542         .type          = AVMEDIA_TYPE_AUDIO,
543         .request_frame = request_frame,
544         .poll_frame    = poll_frame,
545         .config_props  = config_props,
546     },
547     { NULL }
548 };
549
550 AVFilter avfilter_asrc_abuffer = {
551     .name          = "abuffer",
552     .description   = NULL_IF_CONFIG_SMALL("Buffer audio frames, and make them accessible to the filterchain."),
553     .priv_size     = sizeof(BufferSourceContext),
554     .query_formats = query_formats,
555
556     .init      = init_audio,
557     .uninit    = uninit,
558
559     .inputs    = NULL,
560     .outputs   = avfilter_asrc_abuffer_outputs,
561     .priv_class = &abuffer_class,
562 };