2011-06-11 16:40:08 +03:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2011 Stefano Sabatini
|
|
|
|
*
|
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
|
|
|
* 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
|
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @file
|
|
|
|
* libavfilter virtual input device
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* #define DEBUG */
|
|
|
|
|
2012-12-06 17:09:47 +03:00
|
|
|
#include <float.h> /* DBL_MIN, DBL_MAX */
|
2011-06-11 16:40:08 +03:00
|
|
|
|
2012-10-17 00:49:03 +03:00
|
|
|
#include "libavutil/bprint.h"
|
2012-11-13 16:16:48 +03:00
|
|
|
#include "libavutil/channel_layout.h"
|
2012-10-23 02:13:23 +03:00
|
|
|
#include "libavutil/file.h"
|
2016-01-17 07:41:54 +02:00
|
|
|
#include "libavutil/imgutils.h"
|
2015-08-18 02:45:35 +02:00
|
|
|
#include "libavutil/internal.h"
|
2011-06-11 16:40:08 +03:00
|
|
|
#include "libavutil/log.h"
|
|
|
|
#include "libavutil/mem.h"
|
|
|
|
#include "libavutil/opt.h"
|
|
|
|
#include "libavutil/parseutils.h"
|
|
|
|
#include "libavutil/pixdesc.h"
|
|
|
|
#include "libavfilter/avfilter.h"
|
2011-09-06 19:37:44 +03:00
|
|
|
#include "libavfilter/buffersink.h"
|
2011-12-03 02:45:46 +03:00
|
|
|
#include "libavformat/internal.h"
|
2011-06-11 16:40:08 +03:00
|
|
|
#include "avdevice.h"
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
AVClass *class; ///< class for private options
|
|
|
|
char *graph_str;
|
2012-10-23 02:13:23 +03:00
|
|
|
char *graph_filename;
|
2012-01-19 21:38:11 +03:00
|
|
|
char *dump_graph;
|
2011-06-11 16:40:08 +03:00
|
|
|
AVFilterGraph *graph;
|
|
|
|
AVFilterContext **sinks;
|
|
|
|
int *sink_stream_map;
|
2012-09-20 12:41:11 +03:00
|
|
|
int *sink_eof;
|
2011-06-11 16:40:08 +03:00
|
|
|
int *stream_sink_map;
|
2014-12-04 14:37:08 +02:00
|
|
|
int *sink_stream_subcc_map;
|
|
|
|
int nb_sinks;
|
|
|
|
AVPacket subcc_packet;
|
2011-06-11 16:40:08 +03:00
|
|
|
} LavfiContext;
|
|
|
|
|
|
|
|
av_cold static int lavfi_read_close(AVFormatContext *avctx)
|
|
|
|
{
|
|
|
|
LavfiContext *lavfi = avctx->priv_data;
|
|
|
|
|
|
|
|
av_freep(&lavfi->sink_stream_map);
|
2012-09-20 12:41:11 +03:00
|
|
|
av_freep(&lavfi->sink_eof);
|
2011-06-11 16:40:08 +03:00
|
|
|
av_freep(&lavfi->stream_sink_map);
|
2014-12-04 14:37:08 +02:00
|
|
|
av_freep(&lavfi->sink_stream_subcc_map);
|
2011-12-15 21:51:38 +03:00
|
|
|
av_freep(&lavfi->sinks);
|
2011-06-11 16:40:08 +03:00
|
|
|
avfilter_graph_free(&lavfi->graph);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-12-04 14:37:08 +02:00
|
|
|
static int create_subcc_streams(AVFormatContext *avctx)
|
|
|
|
{
|
|
|
|
LavfiContext *lavfi = avctx->priv_data;
|
|
|
|
AVStream *st;
|
|
|
|
int stream_idx, sink_idx;
|
2021-08-02 14:00:52 +02:00
|
|
|
AVRational *time_base;
|
2014-12-04 14:37:08 +02:00
|
|
|
|
|
|
|
for (stream_idx = 0; stream_idx < lavfi->nb_sinks; stream_idx++) {
|
|
|
|
sink_idx = lavfi->stream_sink_map[stream_idx];
|
|
|
|
if (lavfi->sink_stream_subcc_map[sink_idx]) {
|
|
|
|
lavfi->sink_stream_subcc_map[sink_idx] = avctx->nb_streams;
|
|
|
|
if (!(st = avformat_new_stream(avctx, NULL)))
|
|
|
|
return AVERROR(ENOMEM);
|
2016-04-10 21:58:15 +02:00
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_EIA_608;
|
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
|
2021-08-02 14:00:52 +02:00
|
|
|
time_base = &avctx->streams[stream_idx]->time_base;
|
|
|
|
st->time_base.num = time_base->num;
|
|
|
|
st->time_base.den = time_base->den;
|
2014-12-04 14:37:08 +02:00
|
|
|
} else {
|
|
|
|
lavfi->sink_stream_subcc_map[sink_idx] = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-28 06:23:26 +03:00
|
|
|
av_cold static int lavfi_read_header(AVFormatContext *avctx)
|
2011-06-11 16:40:08 +03:00
|
|
|
{
|
|
|
|
LavfiContext *lavfi = avctx->priv_data;
|
|
|
|
AVFilterInOut *input_links = NULL, *output_links = NULL, *inout;
|
2017-10-21 20:22:52 +02:00
|
|
|
const AVFilter *buffersink, *abuffersink;
|
2011-08-18 16:39:24 +03:00
|
|
|
enum AVMediaType type;
|
2011-06-11 16:40:08 +03:00
|
|
|
int ret = 0, i, n;
|
|
|
|
|
|
|
|
#define FAIL(ERR) { ret = ERR; goto end; }
|
|
|
|
|
2013-03-11 23:49:04 +03:00
|
|
|
buffersink = avfilter_get_by_name("buffersink");
|
|
|
|
abuffersink = avfilter_get_by_name("abuffersink");
|
2011-06-11 16:40:08 +03:00
|
|
|
|
2012-10-23 02:13:23 +03:00
|
|
|
if (lavfi->graph_filename && lavfi->graph_str) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR,
|
|
|
|
"Only one of the graph or graph_file options must be specified\n");
|
2012-10-25 22:33:45 +03:00
|
|
|
FAIL(AVERROR(EINVAL));
|
2012-10-23 02:13:23 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (lavfi->graph_filename) {
|
2014-07-23 16:12:39 +03:00
|
|
|
AVBPrint graph_file_pb;
|
|
|
|
AVIOContext *avio = NULL;
|
2016-01-30 03:17:51 +02:00
|
|
|
AVDictionary *options = NULL;
|
|
|
|
if (avctx->protocol_whitelist && (ret = av_dict_set(&options, "protocol_whitelist", avctx->protocol_whitelist, 0)) < 0)
|
|
|
|
goto end;
|
|
|
|
ret = avio_open2(&avio, lavfi->graph_filename, AVIO_FLAG_READ, &avctx->interrupt_callback, &options);
|
2021-12-02 17:41:09 +02:00
|
|
|
av_dict_free(&options);
|
2014-07-13 16:56:06 +03:00
|
|
|
if (ret < 0)
|
2014-09-09 22:12:08 +03:00
|
|
|
goto end;
|
2014-07-23 16:12:39 +03:00
|
|
|
av_bprint_init(&graph_file_pb, 0, AV_BPRINT_SIZE_UNLIMITED);
|
|
|
|
ret = avio_read_to_bprint(avio, &graph_file_pb, INT_MAX);
|
2015-01-08 15:11:44 +02:00
|
|
|
avio_closep(&avio);
|
2014-07-23 16:12:39 +03:00
|
|
|
if (ret) {
|
|
|
|
av_bprint_finalize(&graph_file_pb, NULL);
|
2014-09-09 22:12:08 +03:00
|
|
|
goto end;
|
2012-10-23 02:13:23 +03:00
|
|
|
}
|
2014-07-23 16:12:39 +03:00
|
|
|
if ((ret = av_bprint_finalize(&graph_file_pb, &lavfi->graph_str)))
|
2014-09-09 22:12:08 +03:00
|
|
|
goto end;
|
2012-10-23 02:13:23 +03:00
|
|
|
}
|
|
|
|
|
2011-06-11 16:40:08 +03:00
|
|
|
if (!lavfi->graph_str)
|
2017-12-30 00:29:52 +02:00
|
|
|
lavfi->graph_str = av_strdup(avctx->url);
|
2011-06-11 16:40:08 +03:00
|
|
|
|
|
|
|
/* parse the graph, create a stream for each open output */
|
|
|
|
if (!(lavfi->graph = avfilter_graph_alloc()))
|
|
|
|
FAIL(AVERROR(ENOMEM));
|
|
|
|
|
2013-07-02 02:39:14 +03:00
|
|
|
if ((ret = avfilter_graph_parse_ptr(lavfi->graph, lavfi->graph_str,
|
2011-06-11 16:40:08 +03:00
|
|
|
&input_links, &output_links, avctx)) < 0)
|
2014-09-09 22:12:08 +03:00
|
|
|
goto end;
|
2011-06-11 16:40:08 +03:00
|
|
|
|
|
|
|
if (input_links) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR,
|
|
|
|
"Open inputs in the filtergraph are not acceptable\n");
|
|
|
|
FAIL(AVERROR(EINVAL));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* count the outputs */
|
|
|
|
for (n = 0, inout = output_links; inout; n++, inout = inout->next);
|
2014-12-04 14:37:08 +02:00
|
|
|
lavfi->nb_sinks = n;
|
2011-06-11 16:40:08 +03:00
|
|
|
|
|
|
|
if (!(lavfi->sink_stream_map = av_malloc(sizeof(int) * n)))
|
|
|
|
FAIL(AVERROR(ENOMEM));
|
2012-09-20 12:41:11 +03:00
|
|
|
if (!(lavfi->sink_eof = av_mallocz(sizeof(int) * n)))
|
|
|
|
FAIL(AVERROR(ENOMEM));
|
2011-06-11 16:40:08 +03:00
|
|
|
if (!(lavfi->stream_sink_map = av_malloc(sizeof(int) * n)))
|
|
|
|
FAIL(AVERROR(ENOMEM));
|
2014-12-04 14:37:08 +02:00
|
|
|
if (!(lavfi->sink_stream_subcc_map = av_malloc(sizeof(int) * n)))
|
|
|
|
FAIL(AVERROR(ENOMEM));
|
2011-06-11 16:40:08 +03:00
|
|
|
|
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
lavfi->stream_sink_map[i] = -1;
|
|
|
|
|
|
|
|
/* parse the output link names - they need to be of the form out0, out1, ...
|
|
|
|
* create a mapping between them and the streams */
|
|
|
|
for (i = 0, inout = output_links; inout; i++, inout = inout->next) {
|
2014-12-04 14:37:08 +02:00
|
|
|
int stream_idx = 0, suffix = 0, use_subcc = 0;
|
2023-05-10 12:38:28 +02:00
|
|
|
if (!inout->name) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "Missing %d outpad name\n", i);
|
|
|
|
FAIL(AVERROR(EINVAL));
|
|
|
|
}
|
2014-12-04 14:37:08 +02:00
|
|
|
sscanf(inout->name, "out%n%d%n", &suffix, &stream_idx, &suffix);
|
|
|
|
if (!suffix) {
|
2011-06-11 16:40:08 +03:00
|
|
|
av_log(avctx, AV_LOG_ERROR,
|
|
|
|
"Invalid outpad name '%s'\n", inout->name);
|
|
|
|
FAIL(AVERROR(EINVAL));
|
|
|
|
}
|
2014-12-04 14:37:08 +02:00
|
|
|
if (inout->name[suffix]) {
|
|
|
|
if (!strcmp(inout->name + suffix, "+subcc")) {
|
|
|
|
use_subcc = 1;
|
|
|
|
} else {
|
|
|
|
av_log(avctx, AV_LOG_ERROR,
|
|
|
|
"Invalid outpad suffix '%s'\n", inout->name);
|
|
|
|
FAIL(AVERROR(EINVAL));
|
|
|
|
}
|
|
|
|
}
|
2011-06-11 16:40:08 +03:00
|
|
|
|
|
|
|
if ((unsigned)stream_idx >= n) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR,
|
|
|
|
"Invalid index was specified in output '%s', "
|
|
|
|
"must be a non-negative value < %d\n",
|
|
|
|
inout->name, n);
|
|
|
|
FAIL(AVERROR(EINVAL));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lavfi->stream_sink_map[stream_idx] != -1) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR,
|
2011-12-18 03:03:40 +03:00
|
|
|
"An output with stream index %d was already specified\n",
|
2011-06-11 16:40:08 +03:00
|
|
|
stream_idx);
|
|
|
|
FAIL(AVERROR(EINVAL));
|
|
|
|
}
|
|
|
|
lavfi->sink_stream_map[i] = stream_idx;
|
|
|
|
lavfi->stream_sink_map[stream_idx] = i;
|
2014-12-04 14:37:08 +02:00
|
|
|
lavfi->sink_stream_subcc_map[i] = !!use_subcc;
|
2011-06-11 16:40:08 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* for each open output create a corresponding stream */
|
|
|
|
for (i = 0, inout = output_links; inout; i++, inout = inout->next) {
|
|
|
|
AVStream *st;
|
2011-11-05 15:11:18 +03:00
|
|
|
if (!(st = avformat_new_stream(avctx, NULL)))
|
2011-06-11 16:40:08 +03:00
|
|
|
FAIL(AVERROR(ENOMEM));
|
2011-11-05 15:11:18 +03:00
|
|
|
st->id = i;
|
2011-06-11 16:40:08 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* create a sink for each output and connect them to the graph */
|
2014-12-04 14:37:08 +02:00
|
|
|
lavfi->sinks = av_malloc_array(lavfi->nb_sinks, sizeof(AVFilterContext *));
|
2011-06-11 16:40:08 +03:00
|
|
|
if (!lavfi->sinks)
|
|
|
|
FAIL(AVERROR(ENOMEM));
|
|
|
|
|
|
|
|
for (i = 0, inout = output_links; inout; i++, inout = inout->next) {
|
|
|
|
AVFilterContext *sink;
|
2011-08-18 16:39:24 +03:00
|
|
|
|
2015-08-08 10:41:31 +02:00
|
|
|
type = avfilter_pad_get_type(inout->filter_ctx->output_pads, inout->pad_idx);
|
2011-08-18 16:39:24 +03:00
|
|
|
|
|
|
|
if (type == AVMEDIA_TYPE_VIDEO && ! buffersink ||
|
|
|
|
type == AVMEDIA_TYPE_AUDIO && ! abuffersink) {
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "Missing required buffersink filter, aborting.\n");
|
|
|
|
FAIL(AVERROR_FILTER_NOT_FOUND);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type == AVMEDIA_TYPE_VIDEO) {
|
2011-12-20 15:18:48 +03:00
|
|
|
ret = avfilter_graph_create_filter(&sink, buffersink,
|
|
|
|
inout->name, NULL,
|
2013-04-12 14:47:40 +03:00
|
|
|
NULL, lavfi->graph);
|
2011-12-20 15:18:48 +03:00
|
|
|
if (ret < 0)
|
|
|
|
goto end;
|
2011-08-18 16:39:24 +03:00
|
|
|
} else if (type == AVMEDIA_TYPE_AUDIO) {
|
2021-12-02 19:40:39 +02:00
|
|
|
static const enum AVSampleFormat sample_fmts[] = {
|
|
|
|
AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32,
|
2021-12-02 20:19:19 +02:00
|
|
|
AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL,
|
2021-12-02 19:40:39 +02:00
|
|
|
};
|
2011-08-18 16:39:24 +03:00
|
|
|
|
|
|
|
ret = avfilter_graph_create_filter(&sink, abuffersink,
|
|
|
|
inout->name, NULL,
|
2013-04-12 14:38:00 +03:00
|
|
|
NULL, lavfi->graph);
|
2013-04-12 21:34:35 +03:00
|
|
|
if (ret >= 0)
|
2021-12-02 20:19:19 +02:00
|
|
|
ret = av_opt_set_bin(sink, "sample_fmts", (const uint8_t*)sample_fmts,
|
|
|
|
sizeof(sample_fmts), AV_OPT_SEARCH_CHILDREN);
|
2011-08-18 16:39:24 +03:00
|
|
|
if (ret < 0)
|
|
|
|
goto end;
|
2013-10-28 13:50:09 +03:00
|
|
|
ret = av_opt_set_int(sink, "all_channel_counts", 1,
|
|
|
|
AV_OPT_SEARCH_CHILDREN);
|
|
|
|
if (ret < 0)
|
|
|
|
goto end;
|
2014-08-05 17:15:22 +03:00
|
|
|
} else {
|
|
|
|
av_log(avctx, AV_LOG_ERROR,
|
|
|
|
"Output '%s' is not a video or audio output, not yet supported\n", inout->name);
|
|
|
|
FAIL(AVERROR(EINVAL));
|
2011-08-18 16:39:24 +03:00
|
|
|
}
|
2011-08-18 17:21:47 +03:00
|
|
|
|
2011-06-11 16:40:08 +03:00
|
|
|
lavfi->sinks[i] = sink;
|
2011-08-14 02:17:02 +03:00
|
|
|
if ((ret = avfilter_link(inout->filter_ctx, inout->pad_idx, sink, 0)) < 0)
|
2014-09-09 22:12:08 +03:00
|
|
|
goto end;
|
2011-06-11 16:40:08 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* configure the graph */
|
|
|
|
if ((ret = avfilter_graph_config(lavfi->graph, avctx)) < 0)
|
2014-09-09 22:12:08 +03:00
|
|
|
goto end;
|
2011-06-11 16:40:08 +03:00
|
|
|
|
2012-01-19 21:38:11 +03:00
|
|
|
if (lavfi->dump_graph) {
|
|
|
|
char *dump = avfilter_graph_dump(lavfi->graph, lavfi->dump_graph);
|
2019-11-21 09:08:18 +02:00
|
|
|
if (dump != NULL) {
|
|
|
|
fputs(dump, stderr);
|
|
|
|
fflush(stderr);
|
|
|
|
av_free(dump);
|
|
|
|
} else {
|
|
|
|
FAIL(AVERROR(ENOMEM));
|
|
|
|
}
|
2012-01-19 21:38:11 +03:00
|
|
|
}
|
|
|
|
|
2011-06-11 16:40:08 +03:00
|
|
|
/* fill each stream with the information in the corresponding sink */
|
2014-12-04 14:37:08 +02:00
|
|
|
for (i = 0; i < lavfi->nb_sinks; i++) {
|
2016-12-18 13:35:25 +02:00
|
|
|
AVFilterContext *sink = lavfi->sinks[lavfi->stream_sink_map[i]];
|
|
|
|
AVRational time_base = av_buffersink_get_time_base(sink);
|
2022-07-06 23:45:24 +02:00
|
|
|
AVRational frame_rate = av_buffersink_get_frame_rate(sink);
|
2011-06-11 16:40:08 +03:00
|
|
|
AVStream *st = avctx->streams[i];
|
2021-12-02 19:08:13 +02:00
|
|
|
AVCodecParameters *const par = st->codecpar;
|
2016-12-18 13:35:25 +02:00
|
|
|
avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
|
2021-12-02 19:08:13 +02:00
|
|
|
par->codec_type = av_buffersink_get_type(sink);
|
2021-12-02 19:35:50 +02:00
|
|
|
if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
|
2022-06-29 21:24:28 +02:00
|
|
|
par->codec_id = AV_CODEC_ID_WRAPPED_AVFRAME;
|
2021-12-02 19:08:13 +02:00
|
|
|
par->format = av_buffersink_get_format(sink);
|
|
|
|
par->width = av_buffersink_get_w(sink);
|
|
|
|
par->height = av_buffersink_get_h(sink);
|
2022-06-29 21:24:28 +02:00
|
|
|
avctx->probesize = FFMAX(avctx->probesize, sizeof(AVFrame) * 30);
|
|
|
|
st ->sample_aspect_ratio =
|
2021-12-02 19:08:13 +02:00
|
|
|
par->sample_aspect_ratio = av_buffersink_get_sample_aspect_ratio(sink);
|
2022-07-06 23:45:24 +02:00
|
|
|
if (frame_rate.num > 0 && frame_rate.den > 0) {
|
|
|
|
st->avg_frame_rate = frame_rate;
|
|
|
|
st->r_frame_rate = frame_rate;
|
|
|
|
}
|
2021-12-02 19:35:50 +02:00
|
|
|
} else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
|
2021-12-02 19:08:13 +02:00
|
|
|
par->sample_rate = av_buffersink_get_sample_rate(sink);
|
2021-12-28 00:53:01 +02:00
|
|
|
ret = av_buffersink_get_ch_layout(sink, &par->ch_layout);
|
|
|
|
if (ret < 0)
|
|
|
|
goto end;
|
2021-12-02 19:08:13 +02:00
|
|
|
par->format = av_buffersink_get_format(sink);
|
2021-12-02 19:35:50 +02:00
|
|
|
par->codec_id = av_get_pcm_codec(par->format, -1);
|
2021-12-02 19:08:13 +02:00
|
|
|
if (par->codec_id == AV_CODEC_ID_NONE)
|
2012-02-16 17:00:18 +03:00
|
|
|
av_log(avctx, AV_LOG_ERROR,
|
|
|
|
"Could not find PCM codec for sample format %s.\n",
|
2021-12-02 19:35:50 +02:00
|
|
|
av_get_sample_fmt_name(par->format));
|
2011-06-11 16:40:08 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-04 14:37:08 +02:00
|
|
|
if ((ret = create_subcc_streams(avctx)) < 0)
|
2015-08-23 05:24:38 +02:00
|
|
|
goto end;
|
2014-12-04 14:37:08 +02:00
|
|
|
|
2011-06-11 16:40:08 +03:00
|
|
|
end:
|
|
|
|
avfilter_inout_free(&input_links);
|
|
|
|
avfilter_inout_free(&output_links);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-12-04 14:37:08 +02:00
|
|
|
static int create_subcc_packet(AVFormatContext *avctx, AVFrame *frame,
|
|
|
|
int sink_idx)
|
|
|
|
{
|
|
|
|
LavfiContext *lavfi = avctx->priv_data;
|
|
|
|
AVFrameSideData *sd;
|
2020-08-30 05:49:46 +02:00
|
|
|
int stream_idx, ret;
|
2014-12-04 14:37:08 +02:00
|
|
|
|
|
|
|
if ((stream_idx = lavfi->sink_stream_subcc_map[sink_idx]) < 0)
|
|
|
|
return 0;
|
2020-08-30 05:49:46 +02:00
|
|
|
if (!(sd = av_frame_get_side_data(frame, AV_FRAME_DATA_A53_CC)))
|
2014-12-04 14:37:08 +02:00
|
|
|
return 0;
|
|
|
|
if ((ret = av_new_packet(&lavfi->subcc_packet, sd->size)) < 0)
|
|
|
|
return ret;
|
|
|
|
memcpy(lavfi->subcc_packet.data, sd->data, sd->size);
|
|
|
|
lavfi->subcc_packet.stream_index = stream_idx;
|
|
|
|
lavfi->subcc_packet.pts = frame->pts;
|
lavu/frame: deprecate AVFrame.pkt_{pos,size}
These fields are supposed to store information about the packet the
frame was decoded from, specifically the byte offset it was stored at
and its size.
However,
- the fields are highly ad-hoc - there is no strong reason why
specifically those (and not any other) packet properties should have a
dedicated field in AVFrame; unlike e.g. the timestamps, there is no
fundamental link between coded packet offset/size and decoded frames
- they only make sense for frames produced by decoding demuxed packets,
and even then it is not always the case that the encoded data was
stored in the file as a contiguous sequence of bytes (in order for pos
to be well-defined)
- pkt_pos was added without much explanation, apparently to allow
passthrough of this information through lavfi in order to handle byte
seeking in ffplay. That is now implemented using arbitrary user data
passthrough in AVFrame.opaque_ref.
- several filters use pkt_pos as a variable available to user-supplied
expressions, but there seems to be no established motivation for using them.
- pkt_size was added for use in ffprobe, but that too is now handled
without using this field. Additonally, the values of this field
produced by libavcodec are flawed, as described in the previous
ffprobe conversion commit.
In summary - these fields are ill-defined and insufficiently motivated,
so deprecate them.
2023-03-10 11:48:34 +02:00
|
|
|
#if FF_API_FRAME_PKT
|
|
|
|
FF_DISABLE_DEPRECATION_WARNINGS
|
2017-04-22 10:56:47 +02:00
|
|
|
lavfi->subcc_packet.pos = frame->pkt_pos;
|
lavu/frame: deprecate AVFrame.pkt_{pos,size}
These fields are supposed to store information about the packet the
frame was decoded from, specifically the byte offset it was stored at
and its size.
However,
- the fields are highly ad-hoc - there is no strong reason why
specifically those (and not any other) packet properties should have a
dedicated field in AVFrame; unlike e.g. the timestamps, there is no
fundamental link between coded packet offset/size and decoded frames
- they only make sense for frames produced by decoding demuxed packets,
and even then it is not always the case that the encoded data was
stored in the file as a contiguous sequence of bytes (in order for pos
to be well-defined)
- pkt_pos was added without much explanation, apparently to allow
passthrough of this information through lavfi in order to handle byte
seeking in ffplay. That is now implemented using arbitrary user data
passthrough in AVFrame.opaque_ref.
- several filters use pkt_pos as a variable available to user-supplied
expressions, but there seems to be no established motivation for using them.
- pkt_size was added for use in ffprobe, but that too is now handled
without using this field. Additonally, the values of this field
produced by libavcodec are flawed, as described in the previous
ffprobe conversion commit.
In summary - these fields are ill-defined and insufficiently motivated,
so deprecate them.
2023-03-10 11:48:34 +02:00
|
|
|
FF_ENABLE_DEPRECATION_WARNINGS
|
|
|
|
#endif
|
2014-12-04 14:37:08 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-06-29 21:24:28 +02:00
|
|
|
static void lavfi_free_frame(void *opaque, uint8_t *data)
|
|
|
|
{
|
|
|
|
AVFrame *frame = (AVFrame*)data;
|
|
|
|
av_frame_free(&frame);
|
|
|
|
}
|
|
|
|
|
2011-06-11 16:40:08 +03:00
|
|
|
static int lavfi_read_packet(AVFormatContext *avctx, AVPacket *pkt)
|
|
|
|
{
|
|
|
|
LavfiContext *lavfi = avctx->priv_data;
|
|
|
|
double min_pts = DBL_MAX;
|
2011-08-18 16:39:24 +03:00
|
|
|
int stream_idx, min_pts_sink_idx = 0;
|
2023-09-29 19:25:39 +02:00
|
|
|
AVFrame *frame, *frame_to_free;
|
2013-03-12 16:21:27 +03:00
|
|
|
AVDictionary *frame_metadata;
|
2011-12-30 23:07:59 +03:00
|
|
|
int ret, i;
|
2020-09-17 15:46:50 +02:00
|
|
|
AVStream *st;
|
2011-06-11 16:40:08 +03:00
|
|
|
|
2014-12-04 14:37:08 +02:00
|
|
|
if (lavfi->subcc_packet.size) {
|
2020-08-30 05:45:47 +02:00
|
|
|
av_packet_move_ref(pkt, &lavfi->subcc_packet);
|
2014-12-04 14:37:08 +02:00
|
|
|
return pkt->size;
|
|
|
|
}
|
|
|
|
|
2022-06-29 21:24:28 +02:00
|
|
|
frame = av_frame_alloc();
|
|
|
|
if (!frame)
|
|
|
|
return AVERROR(ENOMEM);
|
2023-09-29 19:25:39 +02:00
|
|
|
frame_to_free = frame;
|
2022-06-29 21:24:28 +02:00
|
|
|
|
2011-06-11 16:40:08 +03:00
|
|
|
/* iterate through all the graph sinks. Select the sink with the
|
|
|
|
* minimum PTS */
|
2014-12-04 14:37:08 +02:00
|
|
|
for (i = 0; i < lavfi->nb_sinks; i++) {
|
2016-12-18 13:35:25 +02:00
|
|
|
AVRational tb = av_buffersink_get_time_base(lavfi->sinks[i]);
|
2011-06-11 16:40:08 +03:00
|
|
|
double d;
|
2012-09-20 12:41:11 +03:00
|
|
|
|
|
|
|
if (lavfi->sink_eof[i])
|
|
|
|
continue;
|
|
|
|
|
2013-03-12 16:21:27 +03:00
|
|
|
ret = av_buffersink_get_frame_flags(lavfi->sinks[i], frame,
|
|
|
|
AV_BUFFERSINK_FLAG_PEEK);
|
2012-09-20 12:41:11 +03:00
|
|
|
if (ret == AVERROR_EOF) {
|
2015-08-18 02:45:35 +02:00
|
|
|
ff_dlog(avctx, "EOF sink_idx:%d\n", i);
|
2012-09-20 12:41:11 +03:00
|
|
|
lavfi->sink_eof[i] = 1;
|
|
|
|
continue;
|
|
|
|
} else if (ret < 0)
|
2022-06-29 21:24:28 +02:00
|
|
|
goto fail;
|
2015-06-10 00:47:43 +02:00
|
|
|
d = av_rescale_q_rnd(frame->pts, tb, AV_TIME_BASE_Q, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
|
2015-08-18 02:45:35 +02:00
|
|
|
ff_dlog(avctx, "sink_idx:%d time:%f\n", i, d);
|
2013-03-12 16:21:27 +03:00
|
|
|
av_frame_unref(frame);
|
2011-08-29 19:41:50 +03:00
|
|
|
|
2011-06-11 16:40:08 +03:00
|
|
|
if (d < min_pts) {
|
|
|
|
min_pts = d;
|
|
|
|
min_pts_sink_idx = i;
|
|
|
|
}
|
|
|
|
}
|
2022-06-29 21:24:28 +02:00
|
|
|
if (min_pts == DBL_MAX) {
|
|
|
|
ret = AVERROR_EOF;
|
|
|
|
goto fail;
|
|
|
|
}
|
2012-09-20 12:41:11 +03:00
|
|
|
|
2015-08-18 02:45:35 +02:00
|
|
|
ff_dlog(avctx, "min_pts_sink_idx:%i\n", min_pts_sink_idx);
|
2011-06-11 16:40:08 +03:00
|
|
|
|
2013-03-12 16:21:27 +03:00
|
|
|
av_buffersink_get_frame_flags(lavfi->sinks[min_pts_sink_idx], frame, 0);
|
2011-08-18 16:39:24 +03:00
|
|
|
stream_idx = lavfi->sink_stream_map[min_pts_sink_idx];
|
2020-09-17 15:46:50 +02:00
|
|
|
st = avctx->streams[stream_idx];
|
2011-06-11 16:40:08 +03:00
|
|
|
|
2020-09-17 15:46:50 +02:00
|
|
|
if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
|
2022-06-29 21:24:28 +02:00
|
|
|
pkt->buf = av_buffer_create((uint8_t*)frame, sizeof(*frame),
|
|
|
|
&lavfi_free_frame, NULL, 0);
|
|
|
|
if (!pkt->buf) {
|
|
|
|
ret = AVERROR(ENOMEM);
|
2020-09-17 15:54:28 +02:00
|
|
|
goto fail;
|
2022-06-29 21:24:28 +02:00
|
|
|
}
|
2023-09-29 19:25:39 +02:00
|
|
|
frame_to_free = NULL;
|
2011-06-11 16:40:08 +03:00
|
|
|
|
2022-06-29 21:24:28 +02:00
|
|
|
pkt->data = pkt->buf->data;
|
|
|
|
pkt->size = pkt->buf->size;
|
|
|
|
pkt->flags |= AV_PKT_FLAG_TRUSTED;
|
2020-09-17 15:46:50 +02:00
|
|
|
} else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
|
2022-06-29 21:24:28 +02:00
|
|
|
int size = frame->nb_samples * av_get_bytes_per_sample(frame->format) *
|
|
|
|
frame->ch_layout.nb_channels;
|
2011-08-18 16:39:24 +03:00
|
|
|
if ((ret = av_new_packet(pkt, size)) < 0)
|
2021-03-01 07:10:44 +02:00
|
|
|
goto fail;
|
2013-03-12 16:21:27 +03:00
|
|
|
memcpy(pkt->data, frame->data[0], size);
|
2011-08-18 16:39:24 +03:00
|
|
|
}
|
2011-06-11 16:40:08 +03:00
|
|
|
|
2017-04-22 10:56:47 +02:00
|
|
|
frame_metadata = frame->metadata;
|
2013-03-12 16:21:27 +03:00
|
|
|
if (frame_metadata) {
|
2021-04-14 14:59:32 +02:00
|
|
|
size_t size;
|
2020-08-30 07:02:16 +02:00
|
|
|
uint8_t *metadata = av_packet_pack_dictionary(frame_metadata, &size);
|
|
|
|
|
2020-09-17 15:54:28 +02:00
|
|
|
if (!metadata) {
|
|
|
|
ret = AVERROR(ENOMEM);
|
|
|
|
goto fail;
|
|
|
|
}
|
2020-08-30 07:02:16 +02:00
|
|
|
if ((ret = av_packet_add_side_data(pkt, AV_PKT_DATA_STRINGS_METADATA,
|
|
|
|
metadata, size)) < 0) {
|
|
|
|
av_freep(&metadata);
|
2021-03-01 07:10:44 +02:00
|
|
|
goto fail;
|
2012-10-17 00:49:03 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-04 14:37:08 +02:00
|
|
|
if ((ret = create_subcc_packet(avctx, frame, min_pts_sink_idx)) < 0) {
|
2020-09-17 15:54:28 +02:00
|
|
|
goto fail;
|
2014-12-04 14:37:08 +02:00
|
|
|
}
|
|
|
|
|
2011-08-18 16:39:24 +03:00
|
|
|
pkt->stream_index = stream_idx;
|
2013-03-12 16:21:27 +03:00
|
|
|
pkt->pts = frame->pts;
|
lavu/frame: deprecate AVFrame.pkt_{pos,size}
These fields are supposed to store information about the packet the
frame was decoded from, specifically the byte offset it was stored at
and its size.
However,
- the fields are highly ad-hoc - there is no strong reason why
specifically those (and not any other) packet properties should have a
dedicated field in AVFrame; unlike e.g. the timestamps, there is no
fundamental link between coded packet offset/size and decoded frames
- they only make sense for frames produced by decoding demuxed packets,
and even then it is not always the case that the encoded data was
stored in the file as a contiguous sequence of bytes (in order for pos
to be well-defined)
- pkt_pos was added without much explanation, apparently to allow
passthrough of this information through lavfi in order to handle byte
seeking in ffplay. That is now implemented using arbitrary user data
passthrough in AVFrame.opaque_ref.
- several filters use pkt_pos as a variable available to user-supplied
expressions, but there seems to be no established motivation for using them.
- pkt_size was added for use in ffprobe, but that too is now handled
without using this field. Additonally, the values of this field
produced by libavcodec are flawed, as described in the previous
ffprobe conversion commit.
In summary - these fields are ill-defined and insufficiently motivated,
so deprecate them.
2023-03-10 11:48:34 +02:00
|
|
|
#if FF_API_FRAME_PKT
|
|
|
|
FF_DISABLE_DEPRECATION_WARNINGS
|
2017-04-22 10:56:47 +02:00
|
|
|
pkt->pos = frame->pkt_pos;
|
lavu/frame: deprecate AVFrame.pkt_{pos,size}
These fields are supposed to store information about the packet the
frame was decoded from, specifically the byte offset it was stored at
and its size.
However,
- the fields are highly ad-hoc - there is no strong reason why
specifically those (and not any other) packet properties should have a
dedicated field in AVFrame; unlike e.g. the timestamps, there is no
fundamental link between coded packet offset/size and decoded frames
- they only make sense for frames produced by decoding demuxed packets,
and even then it is not always the case that the encoded data was
stored in the file as a contiguous sequence of bytes (in order for pos
to be well-defined)
- pkt_pos was added without much explanation, apparently to allow
passthrough of this information through lavfi in order to handle byte
seeking in ffplay. That is now implemented using arbitrary user data
passthrough in AVFrame.opaque_ref.
- several filters use pkt_pos as a variable available to user-supplied
expressions, but there seems to be no established motivation for using them.
- pkt_size was added for use in ffprobe, but that too is now handled
without using this field. Additonally, the values of this field
produced by libavcodec are flawed, as described in the previous
ffprobe conversion commit.
In summary - these fields are ill-defined and insufficiently motivated,
so deprecate them.
2023-03-10 11:48:34 +02:00
|
|
|
FF_ENABLE_DEPRECATION_WARNINGS
|
|
|
|
#endif
|
2022-06-29 21:24:28 +02:00
|
|
|
|
2023-09-29 19:25:39 +02:00
|
|
|
av_frame_free(&frame_to_free);
|
2022-06-29 21:24:28 +02:00
|
|
|
|
|
|
|
return pkt->size;
|
2020-09-17 15:54:28 +02:00
|
|
|
fail:
|
2023-09-29 19:25:39 +02:00
|
|
|
av_frame_free(&frame_to_free);
|
2020-09-17 15:54:28 +02:00
|
|
|
return ret;
|
|
|
|
|
2011-06-11 16:40:08 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
#define OFFSET(x) offsetof(LavfiContext, x)
|
|
|
|
|
|
|
|
#define DEC AV_OPT_FLAG_DECODING_PARAM
|
|
|
|
|
|
|
|
static const AVOption options[] = {
|
2012-09-11 23:51:46 +03:00
|
|
|
{ "graph", "set libavfilter graph", OFFSET(graph_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
|
2012-10-23 02:13:23 +03:00
|
|
|
{ "graph_file","set libavfilter graph filename", OFFSET(graph_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC},
|
2012-09-11 23:51:46 +03:00
|
|
|
{ "dumpgraph", "dump graph to stderr", OFFSET(dump_graph), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
|
2011-06-11 16:40:08 +03:00
|
|
|
{ NULL },
|
|
|
|
};
|
|
|
|
|
|
|
|
static const AVClass lavfi_class = {
|
|
|
|
.class_name = "lavfi indev",
|
|
|
|
.option = options,
|
|
|
|
.version = LIBAVUTIL_VERSION_INT,
|
2014-02-23 01:32:51 +03:00
|
|
|
.category = AV_CLASS_CATEGORY_DEVICE_INPUT,
|
2011-06-11 16:40:08 +03:00
|
|
|
};
|
|
|
|
|
2021-04-19 18:56:01 +02:00
|
|
|
const AVInputFormat ff_lavfi_demuxer = {
|
2011-06-11 16:40:08 +03:00
|
|
|
.name = "lavfi",
|
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("Libavfilter virtual input device"),
|
|
|
|
.priv_data_size = sizeof(LavfiContext),
|
|
|
|
.read_header = lavfi_read_header,
|
|
|
|
.read_packet = lavfi_read_packet,
|
|
|
|
.read_close = lavfi_read_close,
|
|
|
|
.flags = AVFMT_NOFILE,
|
|
|
|
.priv_class = &lavfi_class,
|
2021-12-02 17:00:16 +02:00
|
|
|
.flags_internal = FF_FMT_INIT_CLEANUP,
|
2011-06-11 16:40:08 +03:00
|
|
|
};
|