buffersrc.c 11.6 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 27 28 29 30 31
#include "libavutil/channel_layout.h"
#include "libavutil/common.h"
#include "libavutil/fifo.h"
#include "libavutil/imgutils.h"
#include "libavutil/opt.h"
#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

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

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

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

56
    int eof;
57 58
} BufferSourceContext;

59
#define CHECK_VIDEO_PARAM_CHANGE(s, c, width, height, format)\
60 61 62 63 64
    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);\
    }

65 66 67 68 69 70 71
#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);\
    }

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

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

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

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

98 99 100 101 102 103 104 105
        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);
106 107 108
        if (!buf)
            return AVERROR(ENOMEM);

109 110 111 112 113 114 115 116
        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);
    }
117

118 119 120 121 122 123
    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;
    }
124 125 126 127 128 129 130

    return 0;
}

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

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

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

144 145 146 147 148 149 150 151 152 153 154
    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);
    }
155

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

    return 0;
}

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

168
    if (!args ||
169 170 171
        (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) {
172
        av_log(ctx, AV_LOG_ERROR, "Expected 7 arguments, but %d found in '%s'\n", n, args);
173 174
        return AVERROR(EINVAL);
    }
175
    if ((c->pix_fmt = av_get_pix_fmt(pix_fmt_str)) == AV_PIX_FMT_NONE) {
176 177
        char *tail;
        c->pix_fmt = strtol(pix_fmt_str, &tail, 10);
178
        if (*tail || c->pix_fmt < 0 || c->pix_fmt >= AV_PIX_FMT_NB) {
179 180 181 182
            av_log(ctx, AV_LOG_ERROR, "Invalid pixel format string '%s'\n", pix_fmt_str);
            return AVERROR(EINVAL);
        }
    }
183

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

187
    av_log(ctx, AV_LOG_VERBOSE, "w:%d h:%d pixfmt:%s\n", c->w, c->h, av_get_pix_fmt_name(c->pix_fmt));
188
    return 0;
189 190
}

191 192 193
#define OFFSET(x) offsetof(BufferSourceContext, x)
#define A AV_OPT_FLAG_AUDIO_PARAM
static const AVOption audio_options[] = {
194
    { "time_base",      NULL, OFFSET(time_base),           AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, INT_MAX, A },
195
    { "sample_rate",    NULL, OFFSET(sample_rate),         AV_OPT_TYPE_INT,      { .i64 = 0 }, 0, INT_MAX, A },
196 197 198 199 200 201 202 203 204 205 206 207
    { "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,
};

208
static av_cold int init_audio(AVFilterContext *ctx, const char *args)
209 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
{
    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;
}

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

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

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

282
        ff_add_format(&samplerates,       c->sample_rate);
283 284 285 286 287 288 289 290
        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);
    }
291 292 293 294 295 296 297 298

    return 0;
}

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

299 300 301 302 303 304 305 306 307 308 309 310 311
    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);
    }
312

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

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

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

330
    ff_filter_frame(link, buf);
331

332
    return ret;
333 334 335 336 337
}

static int poll_frame(AVFilterLink *link)
{
    BufferSourceContext *c = link->src->priv;
338 339 340 341
    int size = av_fifo_size(c->fifo);
    if (!size && c->eof)
        return AVERROR_EOF;
    return size/sizeof(AVFilterBufferRef*);
342 343
}

344 345 346 347 348 349 350 351 352 353 354
static const AVFilterPad avfilter_vsrc_buffer_outputs[] = {
    {
        .name          = "default",
        .type          = AVMEDIA_TYPE_VIDEO,
        .request_frame = request_frame,
        .poll_frame    = poll_frame,
        .config_props  = config_props,
    },
    { NULL }
};

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

361
    .init      = init_video,
362
    .uninit    = uninit,
363

364
    .inputs    = NULL,
365 366 367 368 369 370 371 372 373 374 375 376
    .outputs   = avfilter_vsrc_buffer_outputs,
};

static const AVFilterPad avfilter_asrc_abuffer_outputs[] = {
    {
        .name          = "default",
        .type          = AVMEDIA_TYPE_AUDIO,
        .request_frame = request_frame,
        .poll_frame    = poll_frame,
        .config_props  = config_props,
    },
    { NULL }
377
};
378 379 380 381 382 383 384 385 386 387

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,

388
    .inputs    = NULL,
389
    .outputs   = avfilter_asrc_abuffer_outputs,
390
};