buffersrc.c 12.2 KB
Newer Older
1 2 3
/*
 * Copyright (c) 2008 Vitor Sessak
 *
4
 * This file is part of Libav.
5
 *
6
 * Libav is free software; you can redistribute it and/or
7 8 9 10
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
11
 * Libav is distributed in the hope that it will be useful,
12 13 14 15 16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with Libav; if not, write to the Free Software
18 19 20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

Stefano Sabatini's avatar
Stefano Sabatini committed
21 22 23 24 25
/**
 * @file
 * memory buffer source filter
 */

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 33

#include "libavutil/audioconvert.h"
34
#include "libavutil/common.h"
35
#include "libavutil/fifo.h"
36
#include "libavutil/imgutils.h"
37 38
#include "libavutil/opt.h"
#include "libavutil/samplefmt.h"
39 40

typedef struct {
41
    const AVClass    *class;
42
    AVFifoBuffer     *fifo;
43 44 45
    AVRational        time_base;     ///< time_base to set in the output link

    /* video only */
46 47
    int               h, w;
    enum PixelFormat  pix_fmt;
48
    AVRational        pixel_aspect;
49 50 51 52 53 54 55 56

    /* audio only */
    int sample_rate;
    enum AVSampleFormat sample_fmt;
    char               *sample_fmt_str;
    uint64_t channel_layout;
    char    *channel_layout_str;

57
    int eof;
58 59
} BufferSourceContext;

60
#define CHECK_VIDEO_PARAM_CHANGE(s, c, width, height, format)\
61 62 63 64 65
    if (c->w != width || c->h != height || c->pix_fmt != format) {\
        av_log(s, AV_LOG_ERROR, "Changing frame properties on the fly is not supported.\n");\
        return AVERROR(EINVAL);\
    }

66 67 68 69 70 71 72
#define CHECK_AUDIO_PARAM_CHANGE(s, c, srate, ch_layout, format)\
    if (c->sample_fmt != format || c->sample_rate != srate ||\
        c->channel_layout != ch_layout) {\
        av_log(s, AV_LOG_ERROR, "Changing frame properties on the fly is not supported.\n");\
        return AVERROR(EINVAL);\
    }

73
int av_buffersrc_write_frame(AVFilterContext *buffer_filter, AVFrame *frame)
74 75
{
    BufferSourceContext *c = buffer_filter->priv;
76 77
    AVFilterBufferRef *buf;
    int ret;
78

79
    if (!frame) {
80 81 82 83 84
        c->eof = 1;
        return 0;
    } else if (c->eof)
        return AVERROR(EINVAL);

85 86 87 88
    if (!av_fifo_space(c->fifo) &&
        (ret = av_fifo_realloc2(c->fifo, av_fifo_size(c->fifo) +
                                         sizeof(buf))) < 0)
        return ret;
89

90 91 92 93
    switch (buffer_filter->outputs[0]->type) {
    case AVMEDIA_TYPE_VIDEO:
        CHECK_VIDEO_PARAM_CHANGE(buffer_filter, c, frame->width, frame->height,
                                 frame->format);
94 95
        buf = ff_get_video_buffer(buffer_filter->outputs[0], AV_PERM_WRITE,
                                  c->w, c->h);
96 97 98
        if (!buf)
            return AVERROR(ENOMEM);

99 100 101 102 103 104 105 106
        av_image_copy(buf->data, buf->linesize, frame->data, frame->linesize,
                      c->pix_fmt, c->w, c->h);
        break;
    case AVMEDIA_TYPE_AUDIO:
        CHECK_AUDIO_PARAM_CHANGE(buffer_filter, c, frame->sample_rate, frame->channel_layout,
                                 frame->format);
        buf = ff_get_audio_buffer(buffer_filter->outputs[0], AV_PERM_WRITE,
                                  frame->nb_samples);
107 108 109
        if (!buf)
            return AVERROR(ENOMEM);

110 111 112 113 114 115 116 117
        av_samples_copy(buf->extended_data, frame->extended_data,
                        0, 0, frame->nb_samples,
                        av_get_channel_layout_nb_channels(frame->channel_layout),
                        frame->format);
        break;
    default:
        return AVERROR(EINVAL);
    }
118

119 120 121 122 123 124
    avfilter_copy_frame_props(buf, frame);

    if ((ret = av_fifo_generic_write(c->fifo, &buf, sizeof(buf), NULL)) < 0) {
        avfilter_unref_buffer(buf);
        return ret;
    }
125 126 127 128 129 130 131

    return 0;
}

int av_buffersrc_buffer(AVFilterContext *s, AVFilterBufferRef *buf)
{
    BufferSourceContext *c = s->priv;
132
    int ret;
133

134 135 136 137 138 139
    if (!buf) {
        c->eof = 1;
        return 0;
    } else if (c->eof)
        return AVERROR(EINVAL);

140 141 142 143
    if (!av_fifo_space(c->fifo) &&
        (ret = av_fifo_realloc2(c->fifo, av_fifo_size(c->fifo) +
                                         sizeof(buf))) < 0)
        return ret;
144

145 146 147 148 149 150 151 152 153 154 155
    switch (s->outputs[0]->type) {
    case AVMEDIA_TYPE_VIDEO:
        CHECK_VIDEO_PARAM_CHANGE(s, c, buf->video->w, buf->video->h, buf->format);
        break;
    case AVMEDIA_TYPE_AUDIO:
        CHECK_AUDIO_PARAM_CHANGE(s, c, buf->audio->sample_rate, buf->audio->channel_layout,
                                 buf->format);
        break;
    default:
        return AVERROR(EINVAL);
    }
156

157 158
    if ((ret = av_fifo_generic_write(c->fifo, &buf, sizeof(buf), NULL)) < 0)
        return ret;
159 160 161 162

    return 0;
}

163
static av_cold int init_video(AVFilterContext *ctx, const char *args)
164 165
{
    BufferSourceContext *c = ctx->priv;
166
    char pix_fmt_str[128];
167
    int n = 0;
168

169
    if (!args ||
170 171 172
        (n = sscanf(args, "%d:%d:%127[^:]:%d:%d:%d:%d", &c->w, &c->h, pix_fmt_str,
                    &c->time_base.num, &c->time_base.den,
                    &c->pixel_aspect.num, &c->pixel_aspect.den)) != 7) {
173
        av_log(ctx, AV_LOG_ERROR, "Expected 7 arguments, but %d found in '%s'\n", n, args);
174 175
        return AVERROR(EINVAL);
    }
176 177 178 179 180 181 182 183
    if ((c->pix_fmt = av_get_pix_fmt(pix_fmt_str)) == PIX_FMT_NONE) {
        char *tail;
        c->pix_fmt = strtol(pix_fmt_str, &tail, 10);
        if (*tail || c->pix_fmt < 0 || c->pix_fmt >= PIX_FMT_NB) {
            av_log(ctx, AV_LOG_ERROR, "Invalid pixel format string '%s'\n", pix_fmt_str);
            return AVERROR(EINVAL);
        }
    }
184

185 186 187
    if (!(c->fifo = av_fifo_alloc(sizeof(AVFilterBufferRef*))))
        return AVERROR(ENOMEM);

188
    av_log(ctx, AV_LOG_VERBOSE, "w:%d h:%d pixfmt:%s\n", c->w, c->h, av_pix_fmt_descriptors[c->pix_fmt].name);
189
    return 0;
190 191
}

192 193 194
#define OFFSET(x) offsetof(BufferSourceContext, x)
#define A AV_OPT_FLAG_AUDIO_PARAM
static const AVOption audio_options[] = {
195
    { "time_base",      NULL, OFFSET(time_base),           AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, INT_MAX, A },
196
    { "sample_rate",    NULL, OFFSET(sample_rate),         AV_OPT_TYPE_INT,      { .i64 = 0 }, 0, INT_MAX, A },
197 198 199 200 201 202 203 204 205 206 207 208
    { "sample_fmt",     NULL, OFFSET(sample_fmt_str),      AV_OPT_TYPE_STRING,             .flags = A },
    { "channel_layout", NULL, OFFSET(channel_layout_str),  AV_OPT_TYPE_STRING,             .flags = A },
    { NULL },
};

static const AVClass abuffer_class = {
    .class_name = "abuffer source",
    .item_name  = av_default_item_name,
    .option     = audio_options,
    .version    = LIBAVUTIL_VERSION_INT,
};

209
static av_cold int init_audio(AVFilterContext *ctx, const char *args)
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
{
    BufferSourceContext *s = ctx->priv;
    int ret = 0;

    s->class = &abuffer_class;
    av_opt_set_defaults(s);

    if ((ret = av_set_options_string(s, args, "=", ":")) < 0) {
        av_log(ctx, AV_LOG_ERROR, "Error parsing options string: %s.\n", args);
        goto fail;
    }

    s->sample_fmt = av_get_sample_fmt(s->sample_fmt_str);
    if (s->sample_fmt == AV_SAMPLE_FMT_NONE) {
        av_log(ctx, AV_LOG_ERROR, "Invalid sample format %s.\n",
               s->sample_fmt_str);
        ret = AVERROR(EINVAL);
        goto fail;
    }

    s->channel_layout = av_get_channel_layout(s->channel_layout_str);
    if (!s->channel_layout) {
        av_log(ctx, AV_LOG_ERROR, "Invalid channel layout %s.\n",
               s->channel_layout_str);
        ret = AVERROR(EINVAL);
        goto fail;
    }

    if (!(s->fifo = av_fifo_alloc(sizeof(AVFilterBufferRef*)))) {
        ret = AVERROR(ENOMEM);
        goto fail;
    }

    if (!s->time_base.num)
        s->time_base = (AVRational){1, s->sample_rate};

    av_log(ctx, AV_LOG_VERBOSE, "tb:%d/%d samplefmt:%s samplerate: %d "
           "ch layout:%s\n", s->time_base.num, s->time_base.den, s->sample_fmt_str,
           s->sample_rate, s->channel_layout_str);

fail:
    av_opt_free(s);
    return ret;
}

255 256 257
static av_cold void uninit(AVFilterContext *ctx)
{
    BufferSourceContext *s = ctx->priv;
258
    while (s->fifo && av_fifo_size(s->fifo)) {
259 260 261 262 263 264
        AVFilterBufferRef *buf;
        av_fifo_generic_read(s->fifo, &buf, sizeof(buf), NULL);
        avfilter_unref_buffer(buf);
    }
    av_fifo_free(s->fifo);
    s->fifo = NULL;
265 266
}

267 268 269
static int query_formats(AVFilterContext *ctx)
{
    BufferSourceContext *c = ctx->priv;
270 271 272 273 274 275
    AVFilterChannelLayouts *channel_layouts = NULL;
    AVFilterFormats *formats = NULL;
    AVFilterFormats *samplerates = NULL;

    switch (ctx->outputs[0]->type) {
    case AVMEDIA_TYPE_VIDEO:
276 277
        ff_add_format(&formats, c->pix_fmt);
        ff_set_common_formats(ctx, formats);
278 279
        break;
    case AVMEDIA_TYPE_AUDIO:
280 281
        ff_add_format(&formats,           c->sample_fmt);
        ff_set_common_formats(ctx, formats);
282

283
        ff_add_format(&samplerates,       c->sample_rate);
284 285 286 287 288 289 290 291
        ff_set_common_samplerates(ctx, samplerates);

        ff_add_channel_layout(&channel_layouts, c->channel_layout);
        ff_set_common_channel_layouts(ctx, channel_layouts);
        break;
    default:
        return AVERROR(EINVAL);
    }
292 293 294 295 296 297 298 299

    return 0;
}

static int config_props(AVFilterLink *link)
{
    BufferSourceContext *c = link->src->priv;

300 301 302 303 304 305 306 307 308 309 310 311 312
    switch (link->type) {
    case AVMEDIA_TYPE_VIDEO:
        link->w = c->w;
        link->h = c->h;
        link->sample_aspect_ratio = c->pixel_aspect;
        break;
    case AVMEDIA_TYPE_AUDIO:
        link->channel_layout = c->channel_layout;
        link->sample_rate    = c->sample_rate;
        break;
    default:
        return AVERROR(EINVAL);
    }
313

314
    link->time_base = c->time_base;
315 316 317 318 319 320
    return 0;
}

static int request_frame(AVFilterLink *link)
{
    BufferSourceContext *c = link->src->priv;
321
    AVFilterBufferRef *buf;
322
    int ret = 0;
323

324
    if (!av_fifo_size(c->fifo)) {
325 326
        if (c->eof)
            return AVERROR_EOF;
327
        return AVERROR(EAGAIN);
328
    }
329
    av_fifo_generic_read(c->fifo, &buf, sizeof(buf), NULL);
330

331 332
    switch (link->type) {
    case AVMEDIA_TYPE_VIDEO:
333
        if ((ret = ff_start_frame(link, buf)) < 0 ||
334 335
            (ret = ff_draw_slice(link, 0, link->h, 1)) < 0 ||
            (ret = ff_end_frame(link)) < 0)
336
            return ret;
337 338
        break;
    case AVMEDIA_TYPE_AUDIO:
339
        ret = ff_filter_samples(link, buf);
340 341
        break;
    default:
342
        avfilter_unref_bufferp(&buf);
343 344 345
        return AVERROR(EINVAL);
    }

346
    return ret;
347 348 349 350 351
}

static int poll_frame(AVFilterLink *link)
{
    BufferSourceContext *c = link->src->priv;
352 353 354 355
    int size = av_fifo_size(c->fifo);
    if (!size && c->eof)
        return AVERROR_EOF;
    return size/sizeof(AVFilterBufferRef*);
356 357
}

358
AVFilter avfilter_vsrc_buffer = {
359
    .name      = "buffer",
360
    .description = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them accessible to the filterchain."),
361 362 363
    .priv_size = sizeof(BufferSourceContext),
    .query_formats = query_formats,

364
    .init      = init_video,
365
    .uninit    = uninit,
366

367 368 369 370 371 372 373
    .inputs    = (const AVFilterPad[]) {{ .name = NULL }},
    .outputs   = (const AVFilterPad[]) {{ .name            = "default",
                                          .type            = AVMEDIA_TYPE_VIDEO,
                                          .request_frame   = request_frame,
                                          .poll_frame      = poll_frame,
                                          .config_props    = config_props, },
                                        { .name = NULL}},
374
};
375 376 377 378 379 380 381 382 383 384

AVFilter avfilter_asrc_abuffer = {
    .name          = "abuffer",
    .description   = NULL_IF_CONFIG_SMALL("Buffer audio frames, and make them accessible to the filterchain."),
    .priv_size     = sizeof(BufferSourceContext),
    .query_formats = query_formats,

    .init      = init_audio,
    .uninit    = uninit,

385 386 387 388 389 390 391
    .inputs    = (const AVFilterPad[]) {{ .name = NULL }},
    .outputs   = (const AVFilterPad[]) {{ .name            = "default",
                                          .type            = AVMEDIA_TYPE_AUDIO,
                                          .request_frame   = request_frame,
                                          .poll_frame      = poll_frame,
                                          .config_props    = config_props, },
                                        { .name = NULL}},
392
};