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