summaryrefslogtreecommitdiff
path: root/libavdevice/lavfi.c (plain)
blob: eca3f159348405e0e2677e3533b1fe3ac398bb4b
1/*
2 * Copyright (c) 2011 Stefano Sabatini
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 * libavfilter virtual input device
24 */
25
26/* #define DEBUG */
27
28#include <float.h> /* DBL_MIN, DBL_MAX */
29
30#include "libavutil/bprint.h"
31#include "libavutil/channel_layout.h"
32#include "libavutil/file.h"
33#include "libavutil/imgutils.h"
34#include "libavutil/internal.h"
35#include "libavutil/log.h"
36#include "libavutil/mem.h"
37#include "libavutil/opt.h"
38#include "libavutil/parseutils.h"
39#include "libavutil/pixdesc.h"
40#include "libavfilter/avfilter.h"
41#include "libavfilter/avfiltergraph.h"
42#include "libavfilter/buffersink.h"
43#include "libavformat/avio_internal.h"
44#include "libavformat/internal.h"
45#include "avdevice.h"
46
47typedef struct {
48 AVClass *class; ///< class for private options
49 char *graph_str;
50 char *graph_filename;
51 char *dump_graph;
52 AVFilterGraph *graph;
53 AVFilterContext **sinks;
54 int *sink_stream_map;
55 int *sink_eof;
56 int *stream_sink_map;
57 int *sink_stream_subcc_map;
58 AVFrame *decoded_frame;
59 int nb_sinks;
60 AVPacket subcc_packet;
61} LavfiContext;
62
63static int *create_all_formats(int n)
64{
65 int i, j, *fmts, count = 0;
66
67 for (i = 0; i < n; i++) {
68 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(i);
69 if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
70 count++;
71 }
72
73 if (!(fmts = av_malloc((count+1) * sizeof(int))))
74 return NULL;
75 for (j = 0, i = 0; i < n; i++) {
76 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(i);
77 if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
78 fmts[j++] = i;
79 }
80 fmts[j] = -1;
81 return fmts;
82}
83
84av_cold static int lavfi_read_close(AVFormatContext *avctx)
85{
86 LavfiContext *lavfi = avctx->priv_data;
87
88 av_freep(&lavfi->sink_stream_map);
89 av_freep(&lavfi->sink_eof);
90 av_freep(&lavfi->stream_sink_map);
91 av_freep(&lavfi->sink_stream_subcc_map);
92 av_freep(&lavfi->sinks);
93 avfilter_graph_free(&lavfi->graph);
94 av_frame_free(&lavfi->decoded_frame);
95
96 return 0;
97}
98
99static int create_subcc_streams(AVFormatContext *avctx)
100{
101 LavfiContext *lavfi = avctx->priv_data;
102 AVStream *st;
103 int stream_idx, sink_idx;
104
105 for (stream_idx = 0; stream_idx < lavfi->nb_sinks; stream_idx++) {
106 sink_idx = lavfi->stream_sink_map[stream_idx];
107 if (lavfi->sink_stream_subcc_map[sink_idx]) {
108 lavfi->sink_stream_subcc_map[sink_idx] = avctx->nb_streams;
109 if (!(st = avformat_new_stream(avctx, NULL)))
110 return AVERROR(ENOMEM);
111 st->codecpar->codec_id = AV_CODEC_ID_EIA_608;
112 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
113 } else {
114 lavfi->sink_stream_subcc_map[sink_idx] = -1;
115 }
116 }
117 return 0;
118}
119
120av_cold static int lavfi_read_header(AVFormatContext *avctx)
121{
122 LavfiContext *lavfi = avctx->priv_data;
123 AVFilterInOut *input_links = NULL, *output_links = NULL, *inout;
124 AVFilter *buffersink, *abuffersink;
125 int *pix_fmts = create_all_formats(AV_PIX_FMT_NB);
126 enum AVMediaType type;
127 int ret = 0, i, n;
128
129#define FAIL(ERR) { ret = ERR; goto end; }
130
131 if (!pix_fmts)
132 FAIL(AVERROR(ENOMEM));
133
134 avfilter_register_all();
135
136 buffersink = avfilter_get_by_name("buffersink");
137 abuffersink = avfilter_get_by_name("abuffersink");
138
139 if (lavfi->graph_filename && lavfi->graph_str) {
140 av_log(avctx, AV_LOG_ERROR,
141 "Only one of the graph or graph_file options must be specified\n");
142 FAIL(AVERROR(EINVAL));
143 }
144
145 if (lavfi->graph_filename) {
146 AVBPrint graph_file_pb;
147 AVIOContext *avio = NULL;
148 AVDictionary *options = NULL;
149 if (avctx->protocol_whitelist && (ret = av_dict_set(&options, "protocol_whitelist", avctx->protocol_whitelist, 0)) < 0)
150 goto end;
151 ret = avio_open2(&avio, lavfi->graph_filename, AVIO_FLAG_READ, &avctx->interrupt_callback, &options);
152 av_dict_set(&options, "protocol_whitelist", NULL, 0);
153 if (ret < 0)
154 goto end;
155 av_bprint_init(&graph_file_pb, 0, AV_BPRINT_SIZE_UNLIMITED);
156 ret = avio_read_to_bprint(avio, &graph_file_pb, INT_MAX);
157 avio_closep(&avio);
158 av_bprint_chars(&graph_file_pb, '\0', 1);
159 if (!ret && !av_bprint_is_complete(&graph_file_pb))
160 ret = AVERROR(ENOMEM);
161 if (ret) {
162 av_bprint_finalize(&graph_file_pb, NULL);
163 goto end;
164 }
165 if ((ret = av_bprint_finalize(&graph_file_pb, &lavfi->graph_str)))
166 goto end;
167 }
168
169 if (!lavfi->graph_str)
170 lavfi->graph_str = av_strdup(avctx->filename);
171
172 /* parse the graph, create a stream for each open output */
173 if (!(lavfi->graph = avfilter_graph_alloc()))
174 FAIL(AVERROR(ENOMEM));
175
176 if ((ret = avfilter_graph_parse_ptr(lavfi->graph, lavfi->graph_str,
177 &input_links, &output_links, avctx)) < 0)
178 goto end;
179
180 if (input_links) {
181 av_log(avctx, AV_LOG_ERROR,
182 "Open inputs in the filtergraph are not acceptable\n");
183 FAIL(AVERROR(EINVAL));
184 }
185
186 /* count the outputs */
187 for (n = 0, inout = output_links; inout; n++, inout = inout->next);
188 lavfi->nb_sinks = n;
189
190 if (!(lavfi->sink_stream_map = av_malloc(sizeof(int) * n)))
191 FAIL(AVERROR(ENOMEM));
192 if (!(lavfi->sink_eof = av_mallocz(sizeof(int) * n)))
193 FAIL(AVERROR(ENOMEM));
194 if (!(lavfi->stream_sink_map = av_malloc(sizeof(int) * n)))
195 FAIL(AVERROR(ENOMEM));
196 if (!(lavfi->sink_stream_subcc_map = av_malloc(sizeof(int) * n)))
197 FAIL(AVERROR(ENOMEM));
198
199 for (i = 0; i < n; i++)
200 lavfi->stream_sink_map[i] = -1;
201
202 /* parse the output link names - they need to be of the form out0, out1, ...
203 * create a mapping between them and the streams */
204 for (i = 0, inout = output_links; inout; i++, inout = inout->next) {
205 int stream_idx = 0, suffix = 0, use_subcc = 0;
206 sscanf(inout->name, "out%n%d%n", &suffix, &stream_idx, &suffix);
207 if (!suffix) {
208 av_log(avctx, AV_LOG_ERROR,
209 "Invalid outpad name '%s'\n", inout->name);
210 FAIL(AVERROR(EINVAL));
211 }
212 if (inout->name[suffix]) {
213 if (!strcmp(inout->name + suffix, "+subcc")) {
214 use_subcc = 1;
215 } else {
216 av_log(avctx, AV_LOG_ERROR,
217 "Invalid outpad suffix '%s'\n", inout->name);
218 FAIL(AVERROR(EINVAL));
219 }
220 }
221
222 if ((unsigned)stream_idx >= n) {
223 av_log(avctx, AV_LOG_ERROR,
224 "Invalid index was specified in output '%s', "
225 "must be a non-negative value < %d\n",
226 inout->name, n);
227 FAIL(AVERROR(EINVAL));
228 }
229
230 if (lavfi->stream_sink_map[stream_idx] != -1) {
231 av_log(avctx, AV_LOG_ERROR,
232 "An output with stream index %d was already specified\n",
233 stream_idx);
234 FAIL(AVERROR(EINVAL));
235 }
236 lavfi->sink_stream_map[i] = stream_idx;
237 lavfi->stream_sink_map[stream_idx] = i;
238 lavfi->sink_stream_subcc_map[i] = !!use_subcc;
239 }
240
241 /* for each open output create a corresponding stream */
242 for (i = 0, inout = output_links; inout; i++, inout = inout->next) {
243 AVStream *st;
244 if (!(st = avformat_new_stream(avctx, NULL)))
245 FAIL(AVERROR(ENOMEM));
246 st->id = i;
247 }
248
249 /* create a sink for each output and connect them to the graph */
250 lavfi->sinks = av_malloc_array(lavfi->nb_sinks, sizeof(AVFilterContext *));
251 if (!lavfi->sinks)
252 FAIL(AVERROR(ENOMEM));
253
254 for (i = 0, inout = output_links; inout; i++, inout = inout->next) {
255 AVFilterContext *sink;
256
257 type = avfilter_pad_get_type(inout->filter_ctx->output_pads, inout->pad_idx);
258
259 if (type == AVMEDIA_TYPE_VIDEO && ! buffersink ||
260 type == AVMEDIA_TYPE_AUDIO && ! abuffersink) {
261 av_log(avctx, AV_LOG_ERROR, "Missing required buffersink filter, aborting.\n");
262 FAIL(AVERROR_FILTER_NOT_FOUND);
263 }
264
265 if (type == AVMEDIA_TYPE_VIDEO) {
266 ret = avfilter_graph_create_filter(&sink, buffersink,
267 inout->name, NULL,
268 NULL, lavfi->graph);
269 if (ret >= 0)
270 ret = av_opt_set_int_list(sink, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
271 if (ret < 0)
272 goto end;
273 } else if (type == AVMEDIA_TYPE_AUDIO) {
274 enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_U8,
275 AV_SAMPLE_FMT_S16,
276 AV_SAMPLE_FMT_S32,
277 AV_SAMPLE_FMT_FLT,
278 AV_SAMPLE_FMT_DBL, -1 };
279
280 ret = avfilter_graph_create_filter(&sink, abuffersink,
281 inout->name, NULL,
282 NULL, lavfi->graph);
283 if (ret >= 0)
284 ret = av_opt_set_int_list(sink, "sample_fmts", sample_fmts, AV_SAMPLE_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
285 if (ret < 0)
286 goto end;
287 ret = av_opt_set_int(sink, "all_channel_counts", 1,
288 AV_OPT_SEARCH_CHILDREN);
289 if (ret < 0)
290 goto end;
291 } else {
292 av_log(avctx, AV_LOG_ERROR,
293 "Output '%s' is not a video or audio output, not yet supported\n", inout->name);
294 FAIL(AVERROR(EINVAL));
295 }
296
297 lavfi->sinks[i] = sink;
298 if ((ret = avfilter_link(inout->filter_ctx, inout->pad_idx, sink, 0)) < 0)
299 goto end;
300 }
301
302 /* configure the graph */
303 if ((ret = avfilter_graph_config(lavfi->graph, avctx)) < 0)
304 goto end;
305
306 if (lavfi->dump_graph) {
307 char *dump = avfilter_graph_dump(lavfi->graph, lavfi->dump_graph);
308 fputs(dump, stderr);
309 fflush(stderr);
310 av_free(dump);
311 }
312
313 /* fill each stream with the information in the corresponding sink */
314 for (i = 0; i < lavfi->nb_sinks; i++) {
315 AVFilterContext *sink = lavfi->sinks[lavfi->stream_sink_map[i]];
316 AVRational time_base = av_buffersink_get_time_base(sink);
317 AVStream *st = avctx->streams[i];
318 st->codecpar->codec_type = av_buffersink_get_type(sink);
319 avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
320 if (av_buffersink_get_type(sink) == AVMEDIA_TYPE_VIDEO) {
321 st->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
322 st->codecpar->format = av_buffersink_get_format(sink);
323 st->codecpar->width = av_buffersink_get_w(sink);
324 st->codecpar->height = av_buffersink_get_h(sink);
325 st ->sample_aspect_ratio =
326 st->codecpar->sample_aspect_ratio = av_buffersink_get_sample_aspect_ratio(sink);
327 avctx->probesize = FFMAX(avctx->probesize,
328 av_buffersink_get_w(sink) * av_buffersink_get_h(sink) *
329 av_get_padded_bits_per_pixel(av_pix_fmt_desc_get(av_buffersink_get_format(sink))) *
330 30);
331 } else if (av_buffersink_get_type(sink) == AVMEDIA_TYPE_AUDIO) {
332 st->codecpar->codec_id = av_get_pcm_codec(av_buffersink_get_format(sink), -1);
333 st->codecpar->channels = av_buffersink_get_channels(sink);
334 st->codecpar->format = av_buffersink_get_format(sink);
335 st->codecpar->sample_rate = av_buffersink_get_sample_rate(sink);
336 st->codecpar->channel_layout = av_buffersink_get_channel_layout(sink);
337 if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
338 av_log(avctx, AV_LOG_ERROR,
339 "Could not find PCM codec for sample format %s.\n",
340 av_get_sample_fmt_name(av_buffersink_get_format(sink)));
341 }
342 }
343
344 if ((ret = create_subcc_streams(avctx)) < 0)
345 goto end;
346
347 if (!(lavfi->decoded_frame = av_frame_alloc()))
348 FAIL(AVERROR(ENOMEM));
349
350end:
351 av_free(pix_fmts);
352 avfilter_inout_free(&input_links);
353 avfilter_inout_free(&output_links);
354 if (ret < 0)
355 lavfi_read_close(avctx);
356 return ret;
357}
358
359static int create_subcc_packet(AVFormatContext *avctx, AVFrame *frame,
360 int sink_idx)
361{
362 LavfiContext *lavfi = avctx->priv_data;
363 AVFrameSideData *sd;
364 int stream_idx, i, ret;
365
366 if ((stream_idx = lavfi->sink_stream_subcc_map[sink_idx]) < 0)
367 return 0;
368 for (i = 0; i < frame->nb_side_data; i++)
369 if (frame->side_data[i]->type == AV_FRAME_DATA_A53_CC)
370 break;
371 if (i >= frame->nb_side_data)
372 return 0;
373 sd = frame->side_data[i];
374 if ((ret = av_new_packet(&lavfi->subcc_packet, sd->size)) < 0)
375 return ret;
376 memcpy(lavfi->subcc_packet.data, sd->data, sd->size);
377 lavfi->subcc_packet.stream_index = stream_idx;
378 lavfi->subcc_packet.pts = frame->pts;
379 lavfi->subcc_packet.pos = av_frame_get_pkt_pos(frame);
380 return 0;
381}
382
383static int lavfi_read_packet(AVFormatContext *avctx, AVPacket *pkt)
384{
385 LavfiContext *lavfi = avctx->priv_data;
386 double min_pts = DBL_MAX;
387 int stream_idx, min_pts_sink_idx = 0;
388 AVFrame *frame = lavfi->decoded_frame;
389 AVDictionary *frame_metadata;
390 int ret, i;
391 int size = 0;
392
393 if (lavfi->subcc_packet.size) {
394 *pkt = lavfi->subcc_packet;
395 av_init_packet(&lavfi->subcc_packet);
396 lavfi->subcc_packet.size = 0;
397 lavfi->subcc_packet.data = NULL;
398 return pkt->size;
399 }
400
401 /* iterate through all the graph sinks. Select the sink with the
402 * minimum PTS */
403 for (i = 0; i < lavfi->nb_sinks; i++) {
404 AVRational tb = av_buffersink_get_time_base(lavfi->sinks[i]);
405 double d;
406 int ret;
407
408 if (lavfi->sink_eof[i])
409 continue;
410
411 ret = av_buffersink_get_frame_flags(lavfi->sinks[i], frame,
412 AV_BUFFERSINK_FLAG_PEEK);
413 if (ret == AVERROR_EOF) {
414 ff_dlog(avctx, "EOF sink_idx:%d\n", i);
415 lavfi->sink_eof[i] = 1;
416 continue;
417 } else if (ret < 0)
418 return ret;
419 d = av_rescale_q_rnd(frame->pts, tb, AV_TIME_BASE_Q, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
420 ff_dlog(avctx, "sink_idx:%d time:%f\n", i, d);
421 av_frame_unref(frame);
422
423 if (d < min_pts) {
424 min_pts = d;
425 min_pts_sink_idx = i;
426 }
427 }
428 if (min_pts == DBL_MAX)
429 return AVERROR_EOF;
430
431 ff_dlog(avctx, "min_pts_sink_idx:%i\n", min_pts_sink_idx);
432
433 av_buffersink_get_frame_flags(lavfi->sinks[min_pts_sink_idx], frame, 0);
434 stream_idx = lavfi->sink_stream_map[min_pts_sink_idx];
435
436 if (frame->width /* FIXME best way of testing a video */) {
437 size = av_image_get_buffer_size(frame->format, frame->width, frame->height, 1);
438 if ((ret = av_new_packet(pkt, size)) < 0)
439 return ret;
440
441 av_image_copy_to_buffer(pkt->data, size, (const uint8_t **)frame->data, frame->linesize,
442 frame->format, frame->width, frame->height, 1);
443 } else if (av_frame_get_channels(frame) /* FIXME test audio */) {
444 size = frame->nb_samples * av_get_bytes_per_sample(frame->format) *
445 av_frame_get_channels(frame);
446 if ((ret = av_new_packet(pkt, size)) < 0)
447 return ret;
448 memcpy(pkt->data, frame->data[0], size);
449 }
450
451 frame_metadata = av_frame_get_metadata(frame);
452 if (frame_metadata) {
453 uint8_t *metadata;
454 AVDictionaryEntry *e = NULL;
455 AVBPrint meta_buf;
456
457 av_bprint_init(&meta_buf, 0, AV_BPRINT_SIZE_UNLIMITED);
458 while ((e = av_dict_get(frame_metadata, "", e, AV_DICT_IGNORE_SUFFIX))) {
459 av_bprintf(&meta_buf, "%s", e->key);
460 av_bprint_chars(&meta_buf, '\0', 1);
461 av_bprintf(&meta_buf, "%s", e->value);
462 av_bprint_chars(&meta_buf, '\0', 1);
463 }
464 if (!av_bprint_is_complete(&meta_buf) ||
465 !(metadata = av_packet_new_side_data(pkt, AV_PKT_DATA_STRINGS_METADATA,
466 meta_buf.len))) {
467 av_bprint_finalize(&meta_buf, NULL);
468 return AVERROR(ENOMEM);
469 }
470 memcpy(metadata, meta_buf.str, meta_buf.len);
471 av_bprint_finalize(&meta_buf, NULL);
472 }
473
474 if ((ret = create_subcc_packet(avctx, frame, min_pts_sink_idx)) < 0) {
475 av_frame_unref(frame);
476 av_packet_unref(pkt);
477 return ret;
478 }
479
480 pkt->stream_index = stream_idx;
481 pkt->pts = frame->pts;
482 pkt->pos = av_frame_get_pkt_pos(frame);
483 pkt->size = size;
484 av_frame_unref(frame);
485 return size;
486}
487
488#define OFFSET(x) offsetof(LavfiContext, x)
489
490#define DEC AV_OPT_FLAG_DECODING_PARAM
491
492static const AVOption options[] = {
493 { "graph", "set libavfilter graph", OFFSET(graph_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
494 { "graph_file","set libavfilter graph filename", OFFSET(graph_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC},
495 { "dumpgraph", "dump graph to stderr", OFFSET(dump_graph), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
496 { NULL },
497};
498
499static const AVClass lavfi_class = {
500 .class_name = "lavfi indev",
501 .item_name = av_default_item_name,
502 .option = options,
503 .version = LIBAVUTIL_VERSION_INT,
504 .category = AV_CLASS_CATEGORY_DEVICE_INPUT,
505};
506
507AVInputFormat ff_lavfi_demuxer = {
508 .name = "lavfi",
509 .long_name = NULL_IF_CONFIG_SMALL("Libavfilter virtual input device"),
510 .priv_data_size = sizeof(LavfiContext),
511 .read_header = lavfi_read_header,
512 .read_packet = lavfi_read_packet,
513 .read_close = lavfi_read_close,
514 .flags = AVFMT_NOFILE,
515 .priv_class = &lavfi_class,
516};
517
generated by cgit at 2024-05-17 04:14:10 (GMT)