cf13f204 |
/*
* Copyright (c) 2008 Vitor Sessak
* |
1cbf7fb4 |
* This file is part of FFmpeg. |
cf13f204 |
* |
1cbf7fb4 |
* FFmpeg is free software; you can redistribute it and/or |
cf13f204 |
* 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.
* |
1cbf7fb4 |
* FFmpeg is distributed in the hope that it will be useful, |
cf13f204 |
* 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 |
1cbf7fb4 |
* License along with FFmpeg; if not, write to the Free Software |
cf13f204 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
|
b5634e45 |
/**
* @file
* memory buffer source filter
*/
|
0d58bbb2 |
#include <float.h>
|
a903f8f0 |
#include "libavutil/channel_layout.h"
#include "libavutil/common.h"
#include "libavutil/fifo.h" |
7e350379 |
#include "libavutil/frame.h" |
a903f8f0 |
#include "libavutil/imgutils.h" |
7950e519 |
#include "libavutil/internal.h" |
a903f8f0 |
#include "libavutil/opt.h"
#include "libavutil/samplefmt.h" |
4c66c407 |
#include "audio.h" |
cf13f204 |
#include "avfilter.h" |
e1d9dbf2 |
#include "buffersrc.h" |
4c66c407 |
#include "formats.h" |
aa1246ea |
#include "internal.h" |
803391f7 |
#include "video.h" |
4c66c407 |
|
58400ac1 |
typedef struct BufferSourceContext { |
4c66c407 |
const AVClass *class; |
95587d29 |
AVFifoBuffer *fifo; |
4c66c407 |
AVRational time_base; ///< time_base to set in the output link |
9ca44067 |
AVRational frame_rate; ///< frame_rate to set in the output link |
aa1246ea |
unsigned nb_failed_requests; |
05d6cc11 |
unsigned warning_limit; |
4c66c407 |
/* video only */ |
dcaa4efc |
int w, h; |
716d413c |
enum AVPixelFormat pix_fmt; |
cf13f204 |
AVRational pixel_aspect; |
dcaa4efc |
char *sws_param; |
4c66c407 |
|
b3dd30db |
AVBufferRef *hw_frames_ctx;
|
4c66c407 |
/* audio only */
int sample_rate;
enum AVSampleFormat sample_fmt; |
ea645e90 |
int channels; |
4c66c407 |
uint64_t channel_layout;
char *channel_layout_str;
|
b3dd30db |
int got_format_from_params; |
7ae7c414 |
int eof; |
cf13f204 |
} BufferSourceContext;
|
4c66c407 |
#define CHECK_VIDEO_PARAM_CHANGE(s, c, width, height, format)\ |
5d25140f |
if (c->w != width || c->h != height || c->pix_fmt != format) {\ |
6cbb8a45 |
av_log(s, AV_LOG_INFO, "Changing frame properties on the fly is not supported by all filters.\n");\ |
5d25140f |
}
|
f29c28a8 |
#define CHECK_AUDIO_PARAM_CHANGE(s, c, srate, ch_layout, ch_count, format)\ |
4c66c407 |
if (c->sample_fmt != format || c->sample_rate != srate ||\ |
f29c28a8 |
c->channel_layout != ch_layout || c->channels != ch_count) {\ |
4c66c407 |
av_log(s, AV_LOG_ERROR, "Changing frame properties on the fly is not supported.\n");\
return AVERROR(EINVAL);\
}
|
b3dd30db |
AVBufferSrcParameters *av_buffersrc_parameters_alloc(void)
{
AVBufferSrcParameters *par = av_mallocz(sizeof(*par));
if (!par)
return NULL;
par->format = -1;
return par;
}
int av_buffersrc_parameters_set(AVFilterContext *ctx, AVBufferSrcParameters *param)
{
BufferSourceContext *s = ctx->priv;
if (param->time_base.num > 0 && param->time_base.den > 0)
s->time_base = param->time_base;
switch (ctx->filter->outputs[0].type) {
case AVMEDIA_TYPE_VIDEO:
if (param->format != AV_PIX_FMT_NONE) {
s->got_format_from_params = 1;
s->pix_fmt = param->format;
}
if (param->width > 0)
s->w = param->width;
if (param->height > 0)
s->h = param->height;
if (param->sample_aspect_ratio.num > 0 && param->sample_aspect_ratio.den > 0)
s->pixel_aspect = param->sample_aspect_ratio;
if (param->frame_rate.num > 0 && param->frame_rate.den > 0)
s->frame_rate = param->frame_rate;
if (param->hw_frames_ctx) {
av_buffer_unref(&s->hw_frames_ctx);
s->hw_frames_ctx = av_buffer_ref(param->hw_frames_ctx);
if (!s->hw_frames_ctx)
return AVERROR(ENOMEM);
}
break;
case AVMEDIA_TYPE_AUDIO:
if (param->format != AV_SAMPLE_FMT_NONE) {
s->got_format_from_params = 1;
s->sample_fmt = param->format;
}
if (param->sample_rate > 0)
s->sample_rate = param->sample_rate;
if (param->channel_layout)
s->channel_layout = param->channel_layout;
break;
default:
return AVERROR_BUG;
}
return 0;
}
|
af2a196e |
int attribute_align_arg av_buffersrc_write_frame(AVFilterContext *ctx, const AVFrame *frame) |
720c6b78 |
{ |
b0012de4 |
return av_buffersrc_add_frame_flags(ctx, (AVFrame *)frame,
AV_BUFFERSRC_FLAG_KEEP_REF); |
a05a44e2 |
}
|
af2a196e |
int attribute_align_arg av_buffersrc_add_frame(AVFilterContext *ctx, AVFrame *frame) |
720c6b78 |
{ |
b0012de4 |
return av_buffersrc_add_frame_flags(ctx, frame, 0);
}
static int av_buffersrc_add_frame_internal(AVFilterContext *ctx,
AVFrame *frame, int flags);
|
af2a196e |
int attribute_align_arg av_buffersrc_add_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags) |
b0012de4 |
{
AVFrame *copy = NULL; |
7e350379 |
int ret = 0; |
cf13f204 |
|
b71db3f3 |
if (frame && frame->channel_layout && |
6af050d7 |
av_get_channel_layout_nb_channels(frame->channel_layout) != frame->channels) { |
8280b7db |
av_log(ctx, AV_LOG_ERROR, "Layout indicates a different number of channels than actually present\n"); |
a05a44e2 |
return AVERROR(EINVAL);
} |
7ae7c414 |
|
b0012de4 |
if (!(flags & AV_BUFFERSRC_FLAG_KEEP_REF) || !frame)
return av_buffersrc_add_frame_internal(ctx, frame, flags);
|
7e350379 |
if (!(copy = av_frame_alloc())) |
aa1246ea |
return AVERROR(ENOMEM); |
7e350379 |
ret = av_frame_ref(copy, frame);
if (ret >= 0) |
b0012de4 |
ret = av_buffersrc_add_frame_internal(ctx, copy, flags); |
e1d9dbf2 |
|
7e350379 |
av_frame_free(©);
return ret; |
e1d9dbf2 |
}
|
1daacba9 |
static int push_frame(AVFilterGraph *graph)
{
int ret;
while (1) {
ret = ff_filter_graph_run_once(graph);
if (ret == AVERROR(EAGAIN))
break;
if (ret < 0)
return ret;
}
return 0;
}
|
af2a196e |
static int av_buffersrc_add_frame_internal(AVFilterContext *ctx,
AVFrame *frame, int flags) |
e1d9dbf2 |
{ |
7e350379 |
BufferSourceContext *s = ctx->priv;
AVFrame *copy; |
104a97be |
int refcounted, ret; |
e1d9dbf2 |
|
e3e6aa7a |
s->nb_failed_requests = 0;
|
5ba2aef6 |
if (!frame)
return av_buffersrc_close(ctx, AV_NOPTS_VALUE, flags);
if (s->eof) |
7ae7c414 |
return AVERROR(EINVAL);
|
104a97be |
refcounted = !!frame->buf[0];
|
b0012de4 |
if (!(flags & AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT)) {
|
7e350379 |
switch (ctx->outputs[0]->type) { |
4c66c407 |
case AVMEDIA_TYPE_VIDEO: |
7e350379 |
CHECK_VIDEO_PARAM_CHANGE(ctx, s, frame->width, frame->height, |
4c66c407 |
frame->format);
break;
case AVMEDIA_TYPE_AUDIO: |
3cd34263 |
/* For layouts unknown on input but known on link after negotiation. */
if (!frame->channel_layout)
frame->channel_layout = s->channel_layout; |
7e350379 |
CHECK_AUDIO_PARAM_CHANGE(ctx, s, frame->sample_rate, frame->channel_layout, |
6af050d7 |
frame->channels, frame->format); |
4c66c407 |
break;
default:
return AVERROR(EINVAL); |
aa1246ea |
} |
5d25140f |
|
b0012de4 |
}
|
7e350379 |
if (!av_fifo_space(s->fifo) &&
(ret = av_fifo_realloc2(s->fifo, av_fifo_size(s->fifo) +
sizeof(copy))) < 0) |
95587d29 |
return ret; |
cf13f204 |
|
7e350379 |
if (!(copy = av_frame_alloc()))
return AVERROR(ENOMEM); |
104a97be |
if (refcounted) {
av_frame_move_ref(copy, frame);
} else {
ret = av_frame_ref(copy, frame);
if (ret < 0) {
av_frame_free(©);
return ret;
}
} |
95587d29 |
|
7e350379 |
if ((ret = av_fifo_generic_write(s->fifo, ©, sizeof(copy), NULL)) < 0) { |
104a97be |
if (refcounted)
av_frame_move_ref(frame, copy); |
7e350379 |
av_frame_free(©); |
95587d29 |
return ret;
} |
5bbe4142 |
|
02aa0701 |
if ((ret = ctx->output_pads[0].request_frame(ctx->outputs[0])) < 0)
return ret; |
b0012de4 |
|
1daacba9 |
if ((flags & AV_BUFFERSRC_FLAG_PUSH)) {
ret = push_frame(ctx->graph);
if (ret < 0)
return ret;
}
|
cf13f204 |
return 0;
}
|
5ba2aef6 |
int av_buffersrc_close(AVFilterContext *ctx, int64_t pts, unsigned flags)
{
BufferSourceContext *s = ctx->priv;
s->eof = 1;
ff_avfilter_link_set_in_status(ctx->outputs[0], AVERROR_EOF, pts);
return (flags & AV_BUFFERSRC_FLAG_PUSH) ? push_frame(ctx->graph) : 0;
}
|
d69a4177 |
static av_cold int init_video(AVFilterContext *ctx) |
cf13f204 |
{
BufferSourceContext *c = ctx->priv; |
dcaa4efc |
|
10424024 |
if (!(c->pix_fmt != AV_PIX_FMT_NONE || c->got_format_from_params) || !c->w || !c->h || |
b3dd30db |
av_q2d(c->time_base) <= 0) { |
0d58bbb2 |
av_log(ctx, AV_LOG_ERROR, "Invalid parameters provided.\n"); |
dcaa4efc |
return AVERROR(EINVAL);
} |
a05a44e2 |
|
7e350379 |
if (!(c->fifo = av_fifo_alloc(sizeof(AVFrame*)))) |
95587d29 |
return AVERROR(ENOMEM);
|
fda968aa |
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", |
13afee95 |
c->w, c->h, av_get_pix_fmt_name(c->pix_fmt), |
9ca44067 |
c->time_base.num, c->time_base.den, c->frame_rate.num, c->frame_rate.den, |
dcaa4efc |
c->pixel_aspect.num, c->pixel_aspect.den, (char *)av_x_if_null(c->sws_param, "")); |
05d6cc11 |
c->warning_limit = 100; |
b8dddebf |
return 0; |
cf13f204 |
}
|
a05a44e2 |
unsigned av_buffersrc_get_nb_failed_requests(AVFilterContext *buffer_src)
{
return ((BufferSourceContext *)buffer_src->priv)->nb_failed_requests;
}
|
0d58bbb2 |
#define OFFSET(x) offsetof(BufferSourceContext, x)
#define A AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_AUDIO_PARAM
#define V AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
static const AVOption buffer_options[] = {
{ "width", NULL, OFFSET(w), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, V },
{ "video_size", NULL, OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, .flags = V }, |
16e5e13c |
{ "height", NULL, OFFSET(h), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, V }, |
023693d7 |
{ "pix_fmt", NULL, OFFSET(pix_fmt), AV_OPT_TYPE_PIXEL_FMT, { .i64 = AV_PIX_FMT_NONE }, .min = AV_PIX_FMT_NONE, .max = INT_MAX, .flags = V }, |
c084d6d2 |
{ "sar", "sample aspect ratio", OFFSET(pixel_aspect), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, DBL_MAX, V }, |
ae3c0a9c |
{ "pixel_aspect", "sample aspect ratio", OFFSET(pixel_aspect), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, DBL_MAX, V }, |
0d58bbb2 |
{ "time_base", NULL, OFFSET(time_base), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, DBL_MAX, V },
{ "frame_rate", NULL, OFFSET(frame_rate), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, DBL_MAX, V },
{ "sws_param", NULL, OFFSET(sws_param), AV_OPT_TYPE_STRING, .flags = V },
{ NULL },
};
AVFILTER_DEFINE_CLASS(buffer);
|
c17808ce |
static const AVOption abuffer_options[] = { |
0d58bbb2 |
{ "time_base", NULL, OFFSET(time_base), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, INT_MAX, A },
{ "sample_rate", NULL, OFFSET(sample_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, A }, |
cd355d4d |
{ "sample_fmt", NULL, OFFSET(sample_fmt), AV_OPT_TYPE_SAMPLE_FMT, { .i64 = AV_SAMPLE_FMT_NONE }, .min = AV_SAMPLE_FMT_NONE, .max = INT_MAX, .flags = A }, |
0d58bbb2 |
{ "channel_layout", NULL, OFFSET(channel_layout_str), AV_OPT_TYPE_STRING, .flags = A }, |
c378ba19 |
{ "channels", NULL, OFFSET(channels), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, A }, |
4c66c407 |
{ NULL },
};
|
c17808ce |
AVFILTER_DEFINE_CLASS(abuffer); |
4c66c407 |
|
d69a4177 |
static av_cold int init_audio(AVFilterContext *ctx) |
4c66c407 |
{
BufferSourceContext *s = ctx->priv;
int ret = 0;
|
10424024 |
if (!(s->sample_fmt != AV_SAMPLE_FMT_NONE || s->got_format_from_params)) { |
cd355d4d |
av_log(ctx, AV_LOG_ERROR, "Sample format was not set or was invalid\n"); |
0d58bbb2 |
return AVERROR(EINVAL); |
4c66c407 |
}
|
42959044 |
if (s->channel_layout_str || s->channel_layout) { |
ea645e90 |
int n; |
b18d1b09 |
if (!s->channel_layout) { |
42959044 |
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);
return AVERROR(EINVAL);
} |
b18d1b09 |
} |
ea645e90 |
n = av_get_channel_layout_nb_channels(s->channel_layout);
if (s->channels) {
if (n != s->channels) {
av_log(ctx, AV_LOG_ERROR,
"Mismatching channel count %d and layout '%s' "
"(%d channels)\n",
s->channels, s->channel_layout_str, n); |
0d58bbb2 |
return AVERROR(EINVAL); |
ea645e90 |
}
}
s->channels = n;
} else if (!s->channels) {
av_log(ctx, AV_LOG_ERROR, "Neither number of channels nor "
"channel layout specified\n"); |
0d58bbb2 |
return AVERROR(EINVAL); |
ea645e90 |
} |
4c66c407 |
|
0d58bbb2 |
if (!(s->fifo = av_fifo_alloc(sizeof(AVFrame*))))
return AVERROR(ENOMEM); |
4c66c407 |
if (!s->time_base.num)
s->time_base = (AVRational){1, s->sample_rate};
|
fda968aa |
av_log(ctx, AV_LOG_VERBOSE, |
6be8cfa0 |
"tb:%d/%d samplefmt:%s samplerate:%d chlayout:%s\n", |
cd355d4d |
s->time_base.num, s->time_base.den, av_get_sample_fmt_name(s->sample_fmt), |
4c66c407 |
s->sample_rate, s->channel_layout_str); |
05d6cc11 |
s->warning_limit = 100; |
4c66c407 |
return ret;
}
|
43fe6a29 |
static av_cold void uninit(AVFilterContext *ctx)
{
BufferSourceContext *s = ctx->priv; |
8b05e13d |
while (s->fifo && av_fifo_size(s->fifo)) { |
7e350379 |
AVFrame *frame;
av_fifo_generic_read(s->fifo, &frame, sizeof(frame), NULL);
av_frame_free(&frame); |
95587d29 |
} |
b3dd30db |
av_buffer_unref(&s->hw_frames_ctx); |
70b63419 |
av_fifo_freep(&s->fifo); |
43fe6a29 |
}
|
cf13f204 |
static int query_formats(AVFilterContext *ctx)
{
BufferSourceContext *c = ctx->priv; |
4c66c407 |
AVFilterChannelLayouts *channel_layouts = NULL;
AVFilterFormats *formats = NULL;
AVFilterFormats *samplerates = NULL; |
6aaac24d |
int ret; |
4c66c407 |
switch (ctx->outputs[0]->type) {
case AVMEDIA_TYPE_VIDEO: |
6aaac24d |
if ((ret = ff_add_format (&formats, c->pix_fmt)) < 0 ||
(ret = ff_set_common_formats (ctx , formats )) < 0)
return ret; |
4c66c407 |
break;
case AVMEDIA_TYPE_AUDIO: |
6aaac24d |
if ((ret = ff_add_format (&formats , c->sample_fmt )) < 0 ||
(ret = ff_set_common_formats (ctx , formats )) < 0 ||
(ret = ff_add_format (&samplerates, c->sample_rate)) < 0 ||
(ret = ff_set_common_samplerates (ctx , samplerates )) < 0)
return ret; |
4c66c407 |
|
6aaac24d |
if ((ret = ff_add_channel_layout(&channel_layouts, |
ea645e90 |
c->channel_layout ? c->channel_layout : |
6aaac24d |
FF_COUNT2LAYOUT(c->channels))) < 0)
return ret;
if ((ret = ff_set_common_channel_layouts(ctx, channel_layouts)) < 0)
return ret; |
4c66c407 |
break;
default:
return AVERROR(EINVAL);
} |
cf13f204 |
return 0;
}
static int config_props(AVFilterLink *link)
{
BufferSourceContext *c = link->src->priv;
|
4c66c407 |
switch (link->type) {
case AVMEDIA_TYPE_VIDEO:
link->w = c->w;
link->h = c->h;
link->sample_aspect_ratio = c->pixel_aspect; |
b3dd30db |
if (c->hw_frames_ctx) {
link->hw_frames_ctx = av_buffer_ref(c->hw_frames_ctx);
if (!link->hw_frames_ctx)
return AVERROR(ENOMEM);
} |
4c66c407 |
break;
case AVMEDIA_TYPE_AUDIO: |
01649c79 |
if (!c->channel_layout)
c->channel_layout = link->channel_layout; |
4c66c407 |
break;
default:
return AVERROR(EINVAL);
} |
cf13f204 |
|
4c66c407 |
link->time_base = c->time_base; |
9ca44067 |
link->frame_rate = c->frame_rate; |
cf13f204 |
return 0;
}
static int request_frame(AVFilterLink *link)
{
BufferSourceContext *c = link->src->priv; |
7e350379 |
AVFrame *frame; |
9a9f3f15 |
int ret; |
cf13f204 |
|
95587d29 |
if (!av_fifo_size(c->fifo)) { |
7ae7c414 |
if (c->eof)
return AVERROR_EOF; |
aa1246ea |
c->nb_failed_requests++; |
5cb4f1a1 |
return AVERROR(EAGAIN); |
cf13f204 |
} |
7e350379 |
av_fifo_generic_read(c->fifo, &frame, sizeof(frame), NULL); |
cf13f204 |
|
fb25d99b |
ret = ff_filter_frame(link, frame); |
4c66c407 |
|
cd991462 |
return ret; |
cf13f204 |
}
static int poll_frame(AVFilterLink *link)
{
BufferSourceContext *c = link->src->priv; |
7ae7c414 |
int size = av_fifo_size(c->fifo);
if (!size && c->eof)
return AVERROR_EOF; |
7e350379 |
return size/sizeof(AVFrame*); |
cf13f204 |
}
|
568c70e7 |
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 }
};
|
cd43ca04 |
AVFilter ff_vsrc_buffer = { |
cf13f204 |
.name = "buffer", |
ce1f8536 |
.description = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them accessible to the filterchain."), |
cf13f204 |
.priv_size = sizeof(BufferSourceContext),
.query_formats = query_formats,
|
4c66c407 |
.init = init_video, |
43fe6a29 |
.uninit = uninit, |
cf13f204 |
|
1fce361d |
.inputs = NULL, |
568c70e7 |
.outputs = avfilter_vsrc_buffer_outputs, |
42d621d1 |
.priv_class = &buffer_class, |
cf13f204 |
}; |
4c66c407 |
|
568c70e7 |
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 } |
cf13f204 |
}; |
4c66c407 |
|
cd43ca04 |
AVFilter ff_asrc_abuffer = { |
4c66c407 |
.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,
|
1fce361d |
.inputs = NULL, |
568c70e7 |
.outputs = avfilter_asrc_abuffer_outputs, |
42d621d1 |
.priv_class = &abuffer_class, |
4c66c407 |
}; |