FFmpeg  4.4.6
lavfi.c
Go to the documentation of this file.
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"
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/buffersink.h"
43 #include "libavformat/internal.h"
44 #include "avdevice.h"
45 
46 typedef struct {
47  AVClass *class; ///< class for private options
48  char *graph_str;
50  char *dump_graph;
54  int *sink_eof;
58  int nb_sinks;
60 } LavfiContext;
61 
62 static int *create_all_formats(int n)
63 {
64  int i, j, *fmts, count = 0;
65 
66  for (i = 0; i < n; i++) {
68  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
69  count++;
70  }
71 
72  if (!(fmts = av_malloc_array(count + 1, sizeof(*fmts))))
73  return NULL;
74  for (j = 0, i = 0; i < n; i++) {
76  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
77  fmts[j++] = i;
78  }
79  fmts[j] = -1;
80  return fmts;
81 }
82 
84 {
85  LavfiContext *lavfi = avctx->priv_data;
86 
87  av_freep(&lavfi->sink_stream_map);
88  av_freep(&lavfi->sink_eof);
89  av_freep(&lavfi->stream_sink_map);
91  av_freep(&lavfi->sinks);
92  avfilter_graph_free(&lavfi->graph);
94 
95  return 0;
96 }
97 
99 {
100  LavfiContext *lavfi = avctx->priv_data;
101  AVStream *st;
102  int stream_idx, sink_idx;
103 
104  for (stream_idx = 0; stream_idx < lavfi->nb_sinks; stream_idx++) {
105  sink_idx = lavfi->stream_sink_map[stream_idx];
106  if (lavfi->sink_stream_subcc_map[sink_idx]) {
107  lavfi->sink_stream_subcc_map[sink_idx] = avctx->nb_streams;
108  if (!(st = avformat_new_stream(avctx, NULL)))
109  return AVERROR(ENOMEM);
112  } else {
113  lavfi->sink_stream_subcc_map[sink_idx] = -1;
114  }
115  }
116  return 0;
117 }
118 
120 {
121  LavfiContext *lavfi = avctx->priv_data;
122  AVFilterInOut *input_links = NULL, *output_links = NULL, *inout;
123  const AVFilter *buffersink, *abuffersink;
125  enum AVMediaType type;
126  int ret = 0, i, n;
127 
128 #define FAIL(ERR) { ret = ERR; goto end; }
129 
130  if (!pix_fmts)
131  FAIL(AVERROR(ENOMEM));
132 
133  buffersink = avfilter_get_by_name("buffersink");
134  abuffersink = avfilter_get_by_name("abuffersink");
135 
136  if (lavfi->graph_filename && lavfi->graph_str) {
137  av_log(avctx, AV_LOG_ERROR,
138  "Only one of the graph or graph_file options must be specified\n");
139  FAIL(AVERROR(EINVAL));
140  }
141 
142  if (lavfi->graph_filename) {
143  AVBPrint graph_file_pb;
144  AVIOContext *avio = NULL;
146  if (avctx->protocol_whitelist && (ret = av_dict_set(&options, "protocol_whitelist", avctx->protocol_whitelist, 0)) < 0)
147  goto end;
148  ret = avio_open2(&avio, lavfi->graph_filename, AVIO_FLAG_READ, &avctx->interrupt_callback, &options);
149  av_dict_set(&options, "protocol_whitelist", NULL, 0);
150  if (ret < 0)
151  goto end;
152  av_bprint_init(&graph_file_pb, 0, AV_BPRINT_SIZE_UNLIMITED);
153  ret = avio_read_to_bprint(avio, &graph_file_pb, INT_MAX);
154  avio_closep(&avio);
155  av_bprint_chars(&graph_file_pb, '\0', 1);
156  if (!ret && !av_bprint_is_complete(&graph_file_pb))
157  ret = AVERROR(ENOMEM);
158  if (ret) {
159  av_bprint_finalize(&graph_file_pb, NULL);
160  goto end;
161  }
162  if ((ret = av_bprint_finalize(&graph_file_pb, &lavfi->graph_str)))
163  goto end;
164  }
165 
166  if (!lavfi->graph_str)
167  lavfi->graph_str = av_strdup(avctx->url);
168 
169  /* parse the graph, create a stream for each open output */
170  if (!(lavfi->graph = avfilter_graph_alloc()))
171  FAIL(AVERROR(ENOMEM));
172 
173  if ((ret = avfilter_graph_parse_ptr(lavfi->graph, lavfi->graph_str,
174  &input_links, &output_links, avctx)) < 0)
175  goto end;
176 
177  if (input_links) {
178  av_log(avctx, AV_LOG_ERROR,
179  "Open inputs in the filtergraph are not acceptable\n");
180  FAIL(AVERROR(EINVAL));
181  }
182 
183  /* count the outputs */
184  for (n = 0, inout = output_links; inout; n++, inout = inout->next);
185  lavfi->nb_sinks = n;
186 
187  if (!(lavfi->sink_stream_map = av_malloc(sizeof(int) * n)))
188  FAIL(AVERROR(ENOMEM));
189  if (!(lavfi->sink_eof = av_mallocz(sizeof(int) * n)))
190  FAIL(AVERROR(ENOMEM));
191  if (!(lavfi->stream_sink_map = av_malloc(sizeof(int) * n)))
192  FAIL(AVERROR(ENOMEM));
193  if (!(lavfi->sink_stream_subcc_map = av_malloc(sizeof(int) * n)))
194  FAIL(AVERROR(ENOMEM));
195 
196  for (i = 0; i < n; i++)
197  lavfi->stream_sink_map[i] = -1;
198 
199  /* parse the output link names - they need to be of the form out0, out1, ...
200  * create a mapping between them and the streams */
201  for (i = 0, inout = output_links; inout; i++, inout = inout->next) {
202  int stream_idx = 0, suffix = 0, use_subcc = 0;
203  sscanf(inout->name, "out%n%d%n", &suffix, &stream_idx, &suffix);
204  if (!suffix) {
205  av_log(avctx, AV_LOG_ERROR,
206  "Invalid outpad name '%s'\n", inout->name);
207  FAIL(AVERROR(EINVAL));
208  }
209  if (inout->name[suffix]) {
210  if (!strcmp(inout->name + suffix, "+subcc")) {
211  use_subcc = 1;
212  } else {
213  av_log(avctx, AV_LOG_ERROR,
214  "Invalid outpad suffix '%s'\n", inout->name);
215  FAIL(AVERROR(EINVAL));
216  }
217  }
218 
219  if ((unsigned)stream_idx >= n) {
220  av_log(avctx, AV_LOG_ERROR,
221  "Invalid index was specified in output '%s', "
222  "must be a non-negative value < %d\n",
223  inout->name, n);
224  FAIL(AVERROR(EINVAL));
225  }
226 
227  if (lavfi->stream_sink_map[stream_idx] != -1) {
228  av_log(avctx, AV_LOG_ERROR,
229  "An output with stream index %d was already specified\n",
230  stream_idx);
231  FAIL(AVERROR(EINVAL));
232  }
233  lavfi->sink_stream_map[i] = stream_idx;
234  lavfi->stream_sink_map[stream_idx] = i;
235  lavfi->sink_stream_subcc_map[i] = !!use_subcc;
236  }
237 
238  /* for each open output create a corresponding stream */
239  for (i = 0, inout = output_links; inout; i++, inout = inout->next) {
240  AVStream *st;
241  if (!(st = avformat_new_stream(avctx, NULL)))
242  FAIL(AVERROR(ENOMEM));
243  st->id = i;
244  }
245 
246  /* create a sink for each output and connect them to the graph */
247  lavfi->sinks = av_malloc_array(lavfi->nb_sinks, sizeof(AVFilterContext *));
248  if (!lavfi->sinks)
249  FAIL(AVERROR(ENOMEM));
250 
251  for (i = 0, inout = output_links; inout; i++, inout = inout->next) {
252  AVFilterContext *sink;
253 
254  type = avfilter_pad_get_type(inout->filter_ctx->output_pads, inout->pad_idx);
255 
256  if (type == AVMEDIA_TYPE_VIDEO && ! buffersink ||
257  type == AVMEDIA_TYPE_AUDIO && ! abuffersink) {
258  av_log(avctx, AV_LOG_ERROR, "Missing required buffersink filter, aborting.\n");
260  }
261 
262  if (type == AVMEDIA_TYPE_VIDEO) {
263  ret = avfilter_graph_create_filter(&sink, buffersink,
264  inout->name, NULL,
265  NULL, lavfi->graph);
266  if (ret >= 0)
268  if (ret < 0)
269  goto end;
270  } else if (type == AVMEDIA_TYPE_AUDIO) {
275  AV_SAMPLE_FMT_DBL, -1 };
276 
277  ret = avfilter_graph_create_filter(&sink, abuffersink,
278  inout->name, NULL,
279  NULL, lavfi->graph);
280  if (ret >= 0)
282  if (ret < 0)
283  goto end;
284  ret = av_opt_set_int(sink, "all_channel_counts", 1,
286  if (ret < 0)
287  goto end;
288  } else {
289  av_log(avctx, AV_LOG_ERROR,
290  "Output '%s' is not a video or audio output, not yet supported\n", inout->name);
291  FAIL(AVERROR(EINVAL));
292  }
293 
294  lavfi->sinks[i] = sink;
295  if ((ret = avfilter_link(inout->filter_ctx, inout->pad_idx, sink, 0)) < 0)
296  goto end;
297  }
298 
299  /* configure the graph */
300  if ((ret = avfilter_graph_config(lavfi->graph, avctx)) < 0)
301  goto end;
302 
303  if (lavfi->dump_graph) {
304  char *dump = avfilter_graph_dump(lavfi->graph, lavfi->dump_graph);
305  if (dump != NULL) {
306  fputs(dump, stderr);
307  fflush(stderr);
308  av_free(dump);
309  } else {
310  FAIL(AVERROR(ENOMEM));
311  }
312  }
313 
314  /* fill each stream with the information in the corresponding sink */
315  for (i = 0; i < lavfi->nb_sinks; i++) {
316  AVFilterContext *sink = lavfi->sinks[lavfi->stream_sink_map[i]];
317  AVRational time_base = av_buffersink_get_time_base(sink);
318  AVStream *st = avctx->streams[i];
320  avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
324  st->codecpar->width = av_buffersink_get_w(sink);
325  st->codecpar->height = av_buffersink_get_h(sink);
326  st ->sample_aspect_ratio =
328  avctx->probesize = FFMAX(avctx->probesize,
331  30);
332  } else if (av_buffersink_get_type(sink) == AVMEDIA_TYPE_AUDIO) {
338  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
339  av_log(avctx, AV_LOG_ERROR,
340  "Could not find PCM codec for sample format %s.\n",
342  }
343  }
344 
345  if ((ret = create_subcc_streams(avctx)) < 0)
346  goto end;
347 
348  if (!(lavfi->decoded_frame = av_frame_alloc()))
349  FAIL(AVERROR(ENOMEM));
350 
351 end:
352  av_free(pix_fmts);
353  avfilter_inout_free(&input_links);
354  avfilter_inout_free(&output_links);
355  if (ret < 0)
356  lavfi_read_close(avctx);
357  return ret;
358 }
359 
361  int sink_idx)
362 {
363  LavfiContext *lavfi = avctx->priv_data;
364  AVFrameSideData *sd;
365  int stream_idx, ret;
366 
367  if ((stream_idx = lavfi->sink_stream_subcc_map[sink_idx]) < 0)
368  return 0;
370  return 0;
371  if ((ret = av_new_packet(&lavfi->subcc_packet, sd->size)) < 0)
372  return ret;
373  memcpy(lavfi->subcc_packet.data, sd->data, sd->size);
374  lavfi->subcc_packet.stream_index = stream_idx;
375  lavfi->subcc_packet.pts = frame->pts;
376  lavfi->subcc_packet.pos = frame->pkt_pos;
377  return 0;
378 }
379 
381 {
382  LavfiContext *lavfi = avctx->priv_data;
383  double min_pts = DBL_MAX;
384  int stream_idx, min_pts_sink_idx = 0;
385  AVFrame *frame = lavfi->decoded_frame;
386  AVDictionary *frame_metadata;
387  int ret, i;
388  int size = 0;
389  AVStream *st;
390 
391  if (lavfi->subcc_packet.size) {
393  return pkt->size;
394  }
395 
396  /* iterate through all the graph sinks. Select the sink with the
397  * minimum PTS */
398  for (i = 0; i < lavfi->nb_sinks; i++) {
400  double d;
401  int ret;
402 
403  if (lavfi->sink_eof[i])
404  continue;
405 
408  if (ret == AVERROR_EOF) {
409  ff_dlog(avctx, "EOF sink_idx:%d\n", i);
410  lavfi->sink_eof[i] = 1;
411  continue;
412  } else if (ret < 0)
413  return ret;
415  ff_dlog(avctx, "sink_idx:%d time:%f\n", i, d);
417 
418  if (d < min_pts) {
419  min_pts = d;
420  min_pts_sink_idx = i;
421  }
422  }
423  if (min_pts == DBL_MAX)
424  return AVERROR_EOF;
425 
426  ff_dlog(avctx, "min_pts_sink_idx:%i\n", min_pts_sink_idx);
427 
428  av_buffersink_get_frame_flags(lavfi->sinks[min_pts_sink_idx], frame, 0);
429  stream_idx = lavfi->sink_stream_map[min_pts_sink_idx];
430  st = avctx->streams[stream_idx];
431 
432  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
434  if ((ret = av_new_packet(pkt, size)) < 0)
435  goto fail;
436 
438  frame->format, frame->width, frame->height, 1);
439  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
441  frame->channels;
442  if ((ret = av_new_packet(pkt, size)) < 0)
443  goto fail;
444  memcpy(pkt->data, frame->data[0], size);
445  }
446 
447  frame_metadata = frame->metadata;
448  if (frame_metadata) {
450  uint8_t *metadata = av_packet_pack_dictionary(frame_metadata, &size);
451 
452  if (!metadata) {
453  ret = AVERROR(ENOMEM);
454  goto fail;
455  }
457  metadata, size)) < 0) {
458  av_freep(&metadata);
459  goto fail;
460  }
461  }
462 
463  if ((ret = create_subcc_packet(avctx, frame, min_pts_sink_idx)) < 0) {
464  goto fail;
465  }
466 
467  pkt->stream_index = stream_idx;
468  pkt->pts = frame->pts;
469  pkt->pos = frame->pkt_pos;
471  return size;
472 fail:
474  return ret;
475 
476 }
477 
478 #define OFFSET(x) offsetof(LavfiContext, x)
479 
480 #define DEC AV_OPT_FLAG_DECODING_PARAM
481 
482 static const AVOption options[] = {
483  { "graph", "set libavfilter graph", OFFSET(graph_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
484  { "graph_file","set libavfilter graph filename", OFFSET(graph_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC},
485  { "dumpgraph", "dump graph to stderr", OFFSET(dump_graph), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
486  { NULL },
487 };
488 
489 static const AVClass lavfi_class = {
490  .class_name = "lavfi indev",
491  .item_name = av_default_item_name,
492  .option = options,
493  .version = LIBAVUTIL_VERSION_INT,
494  .category = AV_CLASS_CATEGORY_DEVICE_INPUT,
495 };
496 
498  .name = "lavfi",
499  .long_name = NULL_IF_CONFIG_SMALL("Libavfilter virtual input device"),
500  .priv_data_size = sizeof(LavfiContext),
504  .flags = AVFMT_NOFILE,
505  .priv_class = &lavfi_class,
506 };
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:925
#define av_cold
Definition: attributes.h:88
AV_SAMPLE_FMT_U8
uint8_t
Main libavdevice API header.
Main libavfilter public API header.
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:458
#define AVIO_FLAG_READ
read-only
Definition: avio.h:674
int avio_open2(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:1166
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
Definition: aviobuf.c:1195
int avio_read_to_bprint(AVIOContext *h, struct AVBPrint *pb, size_t max_size)
Read contents of h into print buffer, up to max_size bytes, or up to EOF.
Definition: aviobuf.c:1253
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
uint8_t * av_packet_pack_dictionary(AVDictionary *dict, int *size)
Definition: avpacket.c:511
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:140
#define AV_BPRINT_SIZE_UNLIMITED
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
memory buffer sink API for audio and video
#define flags(name, subs,...)
Definition: cbs_av1.c:572
audio channel layout utility functions
const char * suffix
Definition: checkasm.c:208
#define fail()
Definition: checkasm.h:133
#define FFMAX(a, b)
Definition: common.h:103
#define NULL
Definition: coverity.c:32
static AVFrame * frame
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:545
Misc file utilities.
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:560
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:62
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
@ AV_CODEC_ID_EIA_608
Definition: codec_id.h:534
enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be)
Return the PCM codec associated with a sample format.
Definition: utils.c:617
FF_ENABLE_DEPRECATION_WARNINGS int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as a packet side data.
Definition: avpacket.c:309
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:690
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:99
@ AV_PKT_DATA_STRINGS_METADATA
A list of zero terminated key/value strings.
Definition: packet.h:172
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4509
enum AVMediaType av_buffersink_get_type(const AVFilterContext *ctx)
int av_buffersink_get_sample_rate(const AVFilterContext *ctx)
int av_buffersink_get_format(const AVFilterContext *ctx)
uint64_t av_buffersink_get_channel_layout(const AVFilterContext *ctx)
int av_buffersink_get_h(const AVFilterContext *ctx)
AVRational av_buffersink_get_sample_aspect_ratio(const AVFilterContext *ctx)
AVRational av_buffersink_get_time_base(const AVFilterContext *ctx)
int av_buffersink_get_w(const AVFilterContext *ctx)
int av_buffersink_get_channels(const AVFilterContext *ctx)
int attribute_align_arg av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags)
Get a frame with filtered data from sink and put it in frame.
Definition: buffersink.c:140
#define AV_BUFFERSINK_FLAG_PEEK
Tell av_buffersink_get_buffer_ref() to read video/samples buffer reference, but not remove it from th...
Definition: buffersink.h:89
int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
Check validity and configure all the links and formats in the graph.
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
Definition: graphparser.c:212
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
Definition: avfilter.c:1055
int avfilter_graph_parse_ptr(AVFilterGraph *graph, const char *filters, AVFilterInOut **inputs, AVFilterInOut **outputs, void *log_ctx)
Add a graph described by a string to a graph.
Definition: graphparser.c:549
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
Definition: avfiltergraph.c:83
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)
Link two filters together.
Definition: avfilter.c:135
int avfilter_graph_create_filter(AVFilterContext **filt_ctx, const AVFilter *filt, const char *name, const char *args, void *opaque, AVFilterGraph *graph_ctx)
Create and add a filter instance into an existing graph.
char * avfilter_graph_dump(AVFilterGraph *graph, const char *options)
Dump a graph into a human-readable string representation.
Definition: graphdump.c:154
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: allfilters.c:545
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
#define AVERROR_FILTER_NOT_FOUND
Filter not found.
Definition: error.h:58
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AVERROR(e)
Definition: error.h:43
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:738
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
@ AV_ROUND_PASS_MINMAX
Flag telling rescaling functions to pass INT64_MIN/MAX through unchanged, avoiding special cases for ...
Definition: mathematics.h:108
@ AV_ROUND_NEAR_INF
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:84
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.
Definition: mathematics.c:134
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
AVMediaType
Definition: avutil.h:199
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)
Return the size in bytes of the amount of data required to store an image with the given parameters.
Definition: imgutils.c:466
int av_image_copy_to_buffer(uint8_t *dst, int dst_size, const uint8_t *const src_data[4], const int src_linesize[4], enum AVPixelFormat pix_fmt, int width, int height, int align)
Copy image data from an image into a buffer.
Definition: imgutils.c:505
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:49
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:63
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:62
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
@ AV_SAMPLE_FMT_DBL
double
Definition: samplefmt.h:64
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:586
#define av_opt_set_int_list(obj, name, val, term, flags)
Set a binary option to an integer list.
Definition: opt.h:727
for(j=16;j >0;--j)
cl_device_type type
misc image utilities
int i
Definition: input.c:407
AVInputFormat ff_lavfi_demuxer
Definition: lavfi.c:497
static int create_subcc_streams(AVFormatContext *avctx)
Definition: lavfi.c:98
static const AVOption options[]
Definition: lavfi.c:482
static int * create_all_formats(int n)
Definition: lavfi.c:62
static av_cold int lavfi_read_close(AVFormatContext *avctx)
Definition: lavfi.c:83
static av_cold int lavfi_read_header(AVFormatContext *avctx)
Definition: lavfi.c:119
static int lavfi_read_packet(AVFormatContext *avctx, AVPacket *pkt)
Definition: lavfi.c:380
static int create_subcc_packet(AVFormatContext *avctx, AVFrame *frame, int sink_idx)
Definition: lavfi.c:360
#define FAIL(ERR)
#define OFFSET(x)
Definition: lavfi.c:478
static const AVClass lavfi_class
Definition: lavfi.c:489
#define DEC
Definition: lavfi.c:480
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4945
common internal API header
int buffer_size_t
Definition: internal.h:306
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:309
const char * desc
Definition: libsvtav1.c:79
@ AV_CLASS_CATEGORY_DEVICE_INPUT
Definition: log.h:46
Memory handling functions.
AVOptions.
misc parsing utilities
int av_get_padded_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel for the pixel format described by pixdesc, including any padding ...
Definition: pixdesc.c:2538
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:140
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AV_PIX_FMT_NB
number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of...
Definition: pixfmt.h:363
#define tb
Definition: regdef.h:68
Describe the class of an AVClass context structure.
Definition: log.h:67
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
int channels
Audio only.
Definition: codec_par.h:166
int width
Video only.
Definition: codec_par.h:126
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:136
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int sample_rate
Audio only.
Definition: codec_par.h:170
An instance of a filter.
Definition: avfilter.h:341
A linked-list of the inputs/outputs of the filter chain.
Definition: avfilter.h:1013
Filter definition.
Definition: avfilter.h:145
const char * name
Filter name.
Definition: avfilter.h:149
Format I/O context.
Definition: avformat.h:1232
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1288
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1512
char * url
input or output URL.
Definition: avformat.h:1328
void * priv_data
Format private data.
Definition: avformat.h:1260
int64_t probesize
Maximum size of the data read from input for determining the input container format.
Definition: avformat.h:1400
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1300
char * protocol_whitelist
',' separated list of allowed protocols.
Definition: avformat.h:1806
Structure to hold side data for an AVFrame.
Definition: frame.h:220
uint8_t * data
Definition: frame.h:222
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:411
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int width
Definition: frame.h:376
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
Definition: frame.h:589
int height
Definition: frame.h:376
int channels
number of audio channels, only used for audio.
Definition: frame.h:624
AVDictionary * metadata
metadata.
Definition: frame.h:604
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:391
Bytestream IO Context.
Definition: avio.h:161
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:645
AVOption.
Definition: opt.h:248
This structure stores compressed data.
Definition: packet.h:346
int stream_index
Definition: packet.h:371
int size
Definition: packet.h:370
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
uint8_t * data
Definition: packet.h:369
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:389
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int num
Numerator.
Definition: rational.h:59
int den
Denominator.
Definition: rational.h:60
Stream structure.
Definition: avformat.h:873
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1038
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:935
int id
Format-specific stream ID.
Definition: avformat.h:880
char * graph_str
Definition: lavfi.c:48
AVFilterContext ** sinks
Definition: lavfi.c:52
AVFrame * decoded_frame
Definition: lavfi.c:57
AVPacket subcc_packet
Definition: lavfi.c:59
AVFilterGraph * graph
Definition: lavfi.c:51
int * sink_eof
Definition: lavfi.c:54
int nb_sinks
Definition: lavfi.c:58
char * graph_filename
Definition: lavfi.c:49
char * dump_graph
Definition: lavfi.c:50
int * sink_stream_map
Definition: lavfi.c:53
int * sink_stream_subcc_map
Definition: lavfi.c:56
int * stream_sink_map
Definition: lavfi.c:55
#define av_free(p)
#define av_malloc_array(a, b)
#define ff_dlog(a,...)
#define av_freep(p)
#define av_malloc(s)
#define av_log(a,...)
AVPacket * pkt
Definition: movenc.c:59
int size