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