FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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/internal.h"
34 #include "libavutil/log.h"
35 #include "libavutil/mem.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/pixdesc.h"
39 #include "libavfilter/avfilter.h"
41 #include "libavfilter/buffersink.h"
42 #include "libavformat/internal.h"
43 #include "avdevice.h"
44 
45 typedef struct {
46  AVClass *class; ///< class for private options
47  char *graph_str;
49  char *dump_graph;
53  int *sink_eof;
57  int nb_sinks;
59 } LavfiContext;
60 
61 static int *create_all_formats(int n)
62 {
63  int i, j, *fmts, count = 0;
64 
65  for (i = 0; i < n; i++) {
66  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(i);
67  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
68  count++;
69  }
70 
71  if (!(fmts = av_malloc((count+1) * sizeof(int))))
72  return NULL;
73  for (j = 0, i = 0; i < n; i++) {
74  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(i);
75  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
76  fmts[j++] = i;
77  }
78  fmts[j] = -1;
79  return fmts;
80 }
81 
83 {
84  LavfiContext *lavfi = avctx->priv_data;
85 
86  av_freep(&lavfi->sink_stream_map);
87  av_freep(&lavfi->sink_eof);
88  av_freep(&lavfi->stream_sink_map);
90  av_freep(&lavfi->sinks);
91  avfilter_graph_free(&lavfi->graph);
93 
94  return 0;
95 }
96 
98 {
99  LavfiContext *lavfi = avctx->priv_data;
100  AVStream *st;
101  int stream_idx, sink_idx;
102 
103  for (stream_idx = 0; stream_idx < lavfi->nb_sinks; stream_idx++) {
104  sink_idx = lavfi->stream_sink_map[stream_idx];
105  if (lavfi->sink_stream_subcc_map[sink_idx]) {
106  lavfi->sink_stream_subcc_map[sink_idx] = avctx->nb_streams;
107  if (!(st = avformat_new_stream(avctx, NULL)))
108  return AVERROR(ENOMEM);
111  } else {
112  lavfi->sink_stream_subcc_map[sink_idx] = -1;
113  }
114  }
115  return 0;
116 }
117 
119 {
120  LavfiContext *lavfi = avctx->priv_data;
121  AVFilterInOut *input_links = NULL, *output_links = NULL, *inout;
122  AVFilter *buffersink, *abuffersink;
124  enum AVMediaType type;
125  int ret = 0, i, n;
126 
127 #define FAIL(ERR) { ret = ERR; goto end; }
128 
129  if (!pix_fmts)
130  FAIL(AVERROR(ENOMEM));
131 
133 
134  buffersink = avfilter_get_by_name("buffersink");
135  abuffersink = avfilter_get_by_name("abuffersink");
136 
137  if (lavfi->graph_filename && lavfi->graph_str) {
138  av_log(avctx, AV_LOG_ERROR,
139  "Only one of the graph or graph_file options must be specified\n");
140  FAIL(AVERROR(EINVAL));
141  }
142 
143  if (lavfi->graph_filename) {
144  AVBPrint graph_file_pb;
145  AVIOContext *avio = NULL;
146  ret = avio_open(&avio, lavfi->graph_filename, AVIO_FLAG_READ);
147  if (ret < 0)
148  goto end;
149  av_bprint_init(&graph_file_pb, 0, AV_BPRINT_SIZE_UNLIMITED);
150  ret = avio_read_to_bprint(avio, &graph_file_pb, INT_MAX);
151  avio_closep(&avio);
152  av_bprint_chars(&graph_file_pb, '\0', 1);
153  if (!ret && !av_bprint_is_complete(&graph_file_pb))
154  ret = AVERROR(ENOMEM);
155  if (ret) {
156  av_bprint_finalize(&graph_file_pb, NULL);
157  goto end;
158  }
159  if ((ret = av_bprint_finalize(&graph_file_pb, &lavfi->graph_str)))
160  goto end;
161  }
162 
163  if (!lavfi->graph_str)
164  lavfi->graph_str = av_strdup(avctx->filename);
165 
166  /* parse the graph, create a stream for each open output */
167  if (!(lavfi->graph = avfilter_graph_alloc()))
168  FAIL(AVERROR(ENOMEM));
169 
170  if ((ret = avfilter_graph_parse_ptr(lavfi->graph, lavfi->graph_str,
171  &input_links, &output_links, avctx)) < 0)
172  goto end;
173 
174  if (input_links) {
175  av_log(avctx, AV_LOG_ERROR,
176  "Open inputs in the filtergraph are not acceptable\n");
177  FAIL(AVERROR(EINVAL));
178  }
179 
180  /* count the outputs */
181  for (n = 0, inout = output_links; inout; n++, inout = inout->next);
182  lavfi->nb_sinks = n;
183 
184  if (!(lavfi->sink_stream_map = av_malloc(sizeof(int) * n)))
185  FAIL(AVERROR(ENOMEM));
186  if (!(lavfi->sink_eof = av_mallocz(sizeof(int) * n)))
187  FAIL(AVERROR(ENOMEM));
188  if (!(lavfi->stream_sink_map = av_malloc(sizeof(int) * n)))
189  FAIL(AVERROR(ENOMEM));
190  if (!(lavfi->sink_stream_subcc_map = av_malloc(sizeof(int) * n)))
191  FAIL(AVERROR(ENOMEM));
192 
193  for (i = 0; i < n; i++)
194  lavfi->stream_sink_map[i] = -1;
195 
196  /* parse the output link names - they need to be of the form out0, out1, ...
197  * create a mapping between them and the streams */
198  for (i = 0, inout = output_links; inout; i++, inout = inout->next) {
199  int stream_idx = 0, suffix = 0, use_subcc = 0;
200  sscanf(inout->name, "out%n%d%n", &suffix, &stream_idx, &suffix);
201  if (!suffix) {
202  av_log(avctx, AV_LOG_ERROR,
203  "Invalid outpad name '%s'\n", inout->name);
204  FAIL(AVERROR(EINVAL));
205  }
206  if (inout->name[suffix]) {
207  if (!strcmp(inout->name + suffix, "+subcc")) {
208  use_subcc = 1;
209  } else {
210  av_log(avctx, AV_LOG_ERROR,
211  "Invalid outpad suffix '%s'\n", inout->name);
212  FAIL(AVERROR(EINVAL));
213  }
214  }
215 
216  if ((unsigned)stream_idx >= n) {
217  av_log(avctx, AV_LOG_ERROR,
218  "Invalid index was specified in output '%s', "
219  "must be a non-negative value < %d\n",
220  inout->name, n);
221  FAIL(AVERROR(EINVAL));
222  }
223 
224  if (lavfi->stream_sink_map[stream_idx] != -1) {
225  av_log(avctx, AV_LOG_ERROR,
226  "An output with stream index %d was already specified\n",
227  stream_idx);
228  FAIL(AVERROR(EINVAL));
229  }
230  lavfi->sink_stream_map[i] = stream_idx;
231  lavfi->stream_sink_map[stream_idx] = i;
232  lavfi->sink_stream_subcc_map[i] = !!use_subcc;
233  }
234 
235  /* for each open output create a corresponding stream */
236  for (i = 0, inout = output_links; inout; i++, inout = inout->next) {
237  AVStream *st;
238  if (!(st = avformat_new_stream(avctx, NULL)))
239  FAIL(AVERROR(ENOMEM));
240  st->id = i;
241  }
242 
243  /* create a sink for each output and connect them to the graph */
244  lavfi->sinks = av_malloc_array(lavfi->nb_sinks, sizeof(AVFilterContext *));
245  if (!lavfi->sinks)
246  FAIL(AVERROR(ENOMEM));
247 
248  for (i = 0, inout = output_links; inout; i++, inout = inout->next) {
249  AVFilterContext *sink;
250 
251  type = avfilter_pad_get_type(inout->filter_ctx->output_pads, inout->pad_idx);
252 
253  if (type == AVMEDIA_TYPE_VIDEO && ! buffersink ||
254  type == AVMEDIA_TYPE_AUDIO && ! abuffersink) {
255  av_log(avctx, AV_LOG_ERROR, "Missing required buffersink filter, aborting.\n");
257  }
258 
259  if (type == AVMEDIA_TYPE_VIDEO) {
260  ret = avfilter_graph_create_filter(&sink, buffersink,
261  inout->name, NULL,
262  NULL, lavfi->graph);
263  if (ret >= 0)
264  ret = av_opt_set_int_list(sink, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
265  if (ret < 0)
266  goto end;
267  } else if (type == AVMEDIA_TYPE_AUDIO) {
272  AV_SAMPLE_FMT_DBL, -1 };
273 
274  ret = avfilter_graph_create_filter(&sink, abuffersink,
275  inout->name, NULL,
276  NULL, lavfi->graph);
277  if (ret >= 0)
278  ret = av_opt_set_int_list(sink, "sample_fmts", sample_fmts, AV_SAMPLE_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
279  if (ret < 0)
280  goto end;
281  ret = av_opt_set_int(sink, "all_channel_counts", 1,
283  if (ret < 0)
284  goto end;
285  } else {
286  av_log(avctx, AV_LOG_ERROR,
287  "Output '%s' is not a video or audio output, not yet supported\n", inout->name);
288  FAIL(AVERROR(EINVAL));
289  }
290 
291  lavfi->sinks[i] = sink;
292  if ((ret = avfilter_link(inout->filter_ctx, inout->pad_idx, sink, 0)) < 0)
293  goto end;
294  }
295 
296  /* configure the graph */
297  if ((ret = avfilter_graph_config(lavfi->graph, avctx)) < 0)
298  goto end;
299 
300  if (lavfi->dump_graph) {
301  char *dump = avfilter_graph_dump(lavfi->graph, lavfi->dump_graph);
302  fputs(dump, stderr);
303  fflush(stderr);
304  av_free(dump);
305  }
306 
307  /* fill each stream with the information in the corresponding sink */
308  for (i = 0; i < lavfi->nb_sinks; i++) {
309  AVFilterLink *link = lavfi->sinks[lavfi->stream_sink_map[i]]->inputs[0];
310  AVStream *st = avctx->streams[i];
311  st->codec->codec_type = link->type;
312  avpriv_set_pts_info(st, 64, link->time_base.num, link->time_base.den);
313  if (link->type == AVMEDIA_TYPE_VIDEO) {
315  st->codec->pix_fmt = link->format;
316  st->codec->time_base = link->time_base;
317  st->codec->width = link->w;
318  st->codec->height = link->h;
319  st ->sample_aspect_ratio =
321  avctx->probesize = FFMAX(avctx->probesize,
322  link->w * link->h *
324  30);
325  } else if (link->type == AVMEDIA_TYPE_AUDIO) {
326  st->codec->codec_id = av_get_pcm_codec(link->format, -1);
328  st->codec->sample_fmt = link->format;
329  st->codec->sample_rate = link->sample_rate;
330  st->codec->time_base = link->time_base;
331  st->codec->channel_layout = link->channel_layout;
332  if (st->codec->codec_id == AV_CODEC_ID_NONE)
333  av_log(avctx, AV_LOG_ERROR,
334  "Could not find PCM codec for sample format %s.\n",
336  }
337  }
338 
339  if ((ret = create_subcc_streams(avctx)) < 0)
340  goto end;
341 
342  if (!(lavfi->decoded_frame = av_frame_alloc()))
343  FAIL(AVERROR(ENOMEM));
344 
345 end:
346  av_free(pix_fmts);
347  avfilter_inout_free(&input_links);
348  avfilter_inout_free(&output_links);
349  if (ret < 0)
350  lavfi_read_close(avctx);
351  return ret;
352 }
353 
355  int sink_idx)
356 {
357  LavfiContext *lavfi = avctx->priv_data;
358  AVFrameSideData *sd;
359  int stream_idx, i, ret;
360 
361  if ((stream_idx = lavfi->sink_stream_subcc_map[sink_idx]) < 0)
362  return 0;
363  for (i = 0; i < frame->nb_side_data; i++)
364  if (frame->side_data[i]->type == AV_FRAME_DATA_A53_CC)
365  break;
366  if (i >= frame->nb_side_data)
367  return 0;
368  sd = frame->side_data[i];
369  if ((ret = av_new_packet(&lavfi->subcc_packet, sd->size)) < 0)
370  return ret;
371  memcpy(lavfi->subcc_packet.data, sd->data, sd->size);
372  lavfi->subcc_packet.stream_index = stream_idx;
373  lavfi->subcc_packet.pts = frame->pts;
374  lavfi->subcc_packet.pos = av_frame_get_pkt_pos(frame);
375  return 0;
376 }
377 
379 {
380  LavfiContext *lavfi = avctx->priv_data;
381  double min_pts = DBL_MAX;
382  int stream_idx, min_pts_sink_idx = 0;
383  AVFrame *frame = lavfi->decoded_frame;
384  AVPicture pict;
385  AVDictionary *frame_metadata;
386  int ret, i;
387  int size = 0;
388 
389  if (lavfi->subcc_packet.size) {
390  *pkt = lavfi->subcc_packet;
391  av_init_packet(&lavfi->subcc_packet);
392  lavfi->subcc_packet.size = 0;
393  lavfi->subcc_packet.data = NULL;
394  return pkt->size;
395  }
396 
397  /* iterate through all the graph sinks. Select the sink with the
398  * minimum PTS */
399  for (i = 0; i < lavfi->nb_sinks; i++) {
400  AVRational tb = lavfi->sinks[i]->inputs[0]->time_base;
401  double d;
402  int ret;
403 
404  if (lavfi->sink_eof[i])
405  continue;
406 
407  ret = av_buffersink_get_frame_flags(lavfi->sinks[i], frame,
409  if (ret == AVERROR_EOF) {
410  ff_dlog(avctx, "EOF sink_idx:%d\n", i);
411  lavfi->sink_eof[i] = 1;
412  continue;
413  } else if (ret < 0)
414  return ret;
416  ff_dlog(avctx, "sink_idx:%d time:%f\n", i, d);
417  av_frame_unref(frame);
418 
419  if (d < min_pts) {
420  min_pts = d;
421  min_pts_sink_idx = i;
422  }
423  }
424  if (min_pts == DBL_MAX)
425  return AVERROR_EOF;
426 
427  ff_dlog(avctx, "min_pts_sink_idx:%i\n", min_pts_sink_idx);
428 
429  av_buffersink_get_frame_flags(lavfi->sinks[min_pts_sink_idx], frame, 0);
430  stream_idx = lavfi->sink_stream_map[min_pts_sink_idx];
431 
432  if (frame->width /* FIXME best way of testing a video */) {
433  size = avpicture_get_size(frame->format, frame->width, frame->height);
434  if ((ret = av_new_packet(pkt, size)) < 0)
435  return ret;
436 
437  memcpy(pict.data, frame->data, 4*sizeof(frame->data[0]));
438  memcpy(pict.linesize, frame->linesize, 4*sizeof(frame->linesize[0]));
439 
440  avpicture_layout(&pict, frame->format, frame->width, frame->height,
441  pkt->data, size);
442  } else if (av_frame_get_channels(frame) /* FIXME test audio */) {
443  size = frame->nb_samples * av_get_bytes_per_sample(frame->format) *
444  av_frame_get_channels(frame);
445  if ((ret = av_new_packet(pkt, size)) < 0)
446  return ret;
447  memcpy(pkt->data, frame->data[0], size);
448  }
449 
450  frame_metadata = av_frame_get_metadata(frame);
451  if (frame_metadata) {
452  uint8_t *metadata;
453  AVDictionaryEntry *e = NULL;
454  AVBPrint meta_buf;
455 
457  while ((e = av_dict_get(frame_metadata, "", e, AV_DICT_IGNORE_SUFFIX))) {
458  av_bprintf(&meta_buf, "%s", e->key);
459  av_bprint_chars(&meta_buf, '\0', 1);
460  av_bprintf(&meta_buf, "%s", e->value);
461  av_bprint_chars(&meta_buf, '\0', 1);
462  }
463  if (!av_bprint_is_complete(&meta_buf) ||
465  meta_buf.len))) {
466  av_bprint_finalize(&meta_buf, NULL);
467  return AVERROR(ENOMEM);
468  }
469  memcpy(metadata, meta_buf.str, meta_buf.len);
470  av_bprint_finalize(&meta_buf, NULL);
471  }
472 
473  if ((ret = create_subcc_packet(avctx, frame, min_pts_sink_idx)) < 0) {
474  av_frame_unref(frame);
475  av_packet_unref(pkt);
476  return ret;
477  }
478 
479  pkt->stream_index = stream_idx;
480  pkt->pts = frame->pts;
481  pkt->pos = av_frame_get_pkt_pos(frame);
482  pkt->size = size;
483  av_frame_unref(frame);
484  return size;
485 }
486 
487 #define OFFSET(x) offsetof(LavfiContext, x)
488 
489 #define DEC AV_OPT_FLAG_DECODING_PARAM
490 
491 static const AVOption options[] = {
492  { "graph", "set libavfilter graph", OFFSET(graph_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
493  { "graph_file","set libavfilter graph filename", OFFSET(graph_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC},
494  { "dumpgraph", "dump graph to stderr", OFFSET(dump_graph), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
495  { NULL },
496 };
497 
498 static const AVClass lavfi_class = {
499  .class_name = "lavfi indev",
500  .item_name = av_default_item_name,
501  .option = options,
502  .version = LIBAVUTIL_VERSION_INT,
503  .category = AV_CLASS_CATEGORY_DEVICE_INPUT,
504 };
505 
507  .name = "lavfi",
508  .long_name = NULL_IF_CONFIG_SMALL("Libavfilter virtual input device"),
509  .priv_data_size = sizeof(LavfiContext),
513  .flags = AVFMT_NOFILE,
514  .priv_class = &lavfi_class,
515 };
int avio_open(AVIOContext **s, const char *url, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:913
int64_t probesize
Maximum size of the data read from input for determining the input container format.
Definition: avformat.h:1787
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:111
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
int linesize[AV_NUM_DATA_POINTERS]
number of bytes per line
Definition: avcodec.h:3746
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2129
This structure describes decoded (raw) audio or video data.
Definition: frame.h:171
AVOption.
Definition: opt.h:255
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
Definition: avfiltergraph.c:76
#define LIBAVUTIL_VERSION_INT
Definition: version.h:62
Main libavfilter public API header.
memory handling functions
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1448
static av_cold int lavfi_read_close(AVFormatContext *avctx)
Definition: lavfi.c:82
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:4083
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:187
#define av_opt_set_int_list(obj, name, val, term, flags)
Set a binary option to an integer list.
Definition: opt.h:757
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:1006
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
Definition: avfilter.c:1009
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:914
int num
numerator
Definition: rational.h:44
int size
Definition: avcodec.h:1424
#define AVIO_FLAG_READ
read-only
Definition: avio.h:485
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1902
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1722
int avpicture_layout(const AVPicture *src, enum AVPixelFormat pix_fmt, int width, int height, unsigned char *dest, int dest_size)
Copy pixel data from an AVPicture into a buffer.
Definition: avpicture.c:41
static AVPacket pkt
Picture data structure.
Definition: avcodec.h:3744
int * sink_eof
Definition: lavfi.c:53
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1631
Format I/O context.
Definition: avformat.h:1273
memory buffer sink API for audio and video
AVInputFormat ff_lavfi_demuxer
Definition: lavfi.c:506
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
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:641
int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)
Link two filters together.
Definition: avfilter.c:131
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2270
uint8_t
#define av_cold
Definition: attributes.h:74
#define av_malloc(s)
AV_SAMPLE_FMT_U8
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:135
AVOptions.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointers to the image data planes
Definition: avcodec.h:3745
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int id
Format-specific stream ID.
Definition: avformat.h:849
#define OFFSET(x)
Definition: lavfi.c:487
static const AVClass lavfi_class
Definition: lavfi.c:498
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:257
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:3749
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1341
void avfilter_register_all(void)
Initialize the filter system.
Definition: allfilters.c:40
static AVFrame * frame
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.
Misc file utilities.
Structure to hold side data for an AVFrame.
Definition: frame.h:134
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:39
uint8_t * data
Definition: avcodec.h:1423
#define ff_dlog(a,...)
#define AVERROR_EOF
End of file.
Definition: error.h:55
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
AVFrame * decoded_frame
Definition: lavfi.c:56
ptrdiff_t size
Definition: opengl_enc.c:101
int nb_sinks
Definition: lavfi.c:57
int * sink_stream_map
Definition: lavfi.c:52
signed 32 bits
Definition: samplefmt.h:63
int nb_side_data
Definition: frame.h:462
AVFrameSideData ** side_data
Definition: frame.h:461
#define av_log(a,...)
Main libavdevice API header.
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:83
const char * suffix
Definition: checkasm.c:75
int width
width and height of the video frame
Definition: frame.h:220
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
char * dump_graph
Definition: lavfi.c:49
#define AV_BPRINT_SIZE_UNLIMITED
static int create_subcc_streams(AVFormatContext *avctx)
Definition: lavfi.c:97
av_default_item_name
#define AVERROR(e)
Definition: error.h:43
int avfilter_link_get_channels(AVFilterLink *link)
Get the number of channels of a link.
Definition: avfilter.c:175
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:148
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:175
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
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:2094
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:491
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:75
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:123
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:47
GLsizei count
Definition: opengl_enc.c:109
#define FFMAX(a, b)
Definition: common.h:79
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:128
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2323
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:861
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: avfilter.c:487
common internal API header
static av_cold int lavfi_read_header(AVFormatContext *avctx)
Definition: lavfi.c:118
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1329
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:132
audio channel layout utility functions
char filename[1024]
input or output filename
Definition: avformat.h:1349
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:611
int width
picture width / height.
Definition: avcodec.h:1681
int n
Definition: avisynth_c.h:547
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
AVFilterContext ** sinks
Definition: lavfi.c:51
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:623
Stream structure.
Definition: avformat.h:842
A linked-list of the inputs/outputs of the filter chain.
Definition: avfilter.h:1355
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:232
enum AVMediaType codec_type
Definition: avcodec.h:1510
A list of zero terminated key/value strings.
Definition: avcodec.h:1330
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:59
enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be)
Return the PCM codec associated with a sample format.
Definition: utils.c:3371
enum AVCodecID codec_id
Definition: avcodec.h:1519
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:252
char * av_strdup(const char *s)
Duplicate the string s.
Definition: mem.c:267
int sample_rate
samples per second
Definition: avcodec.h:2262
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:199
uint8_t flags
Definition: pixdesc.h:90
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:550
uint8_t * data
Definition: frame.h:136
int * stream_sink_map
Definition: lavfi.c:54
GLint GLenum type
Definition: opengl_enc.c:105
AVDictionary * av_frame_get_metadata(const AVFrame *frame)
Describe the class of an AVClass context structure.
Definition: log.h:67
int av_frame_get_channels(const AVFrame *frame)
Filter definition.
Definition: avfilter.h:470
rational number numerator/denominator
Definition: rational.h:43
static int lavfi_read_packet(AVFormatContext *avctx, AVPacket *pkt)
Definition: lavfi.c:378
char * graph_filename
Definition: lavfi.c:48
AVMediaType
Definition: avutil.h:191
const char * name
Filter name.
Definition: avfilter.h:474
misc parsing utilities
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:209
#define FAIL(ERR)
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:464
enum AVFrameSideDataType type
Definition: frame.h:135
static int flags
Definition: cpu.c:47
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
#define AVERROR_FILTER_NOT_FOUND
Filter not found.
Definition: error.h:58
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:104
AVFilterGraph * graph
Definition: lavfi.c:50
static int create_subcc_packet(AVFormatContext *avctx, AVFrame *frame, int sink_idx)
Definition: lavfi.c:354
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:465
signed 16 bits
Definition: samplefmt.h:62
char * graph_str
Definition: lavfi.c:47
char * avfilter_graph_dump(AVFilterGraph *graph, const char *options)
Dump a graph into a human-readable string representation.
Definition: graphdump.c:155
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:49
char * key
Definition: dict.h:87
int den
denominator
Definition: rational.h:45
static const AVOption options[]
Definition: lavfi.c:491
Flag to pass INT64_MIN/MAX through instead of rescaling, this avoids special cases for AV_NOPTS_VALUE...
Definition: mathematics.h:76
#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:110
#define av_free(p)
char * value
Definition: dict.h:88
int channels
number of audio channels
Definition: avcodec.h:2263
int64_t av_frame_get_pkt_pos(const AVFrame *frame)
void * priv_data
Format private data.
Definition: avformat.h:1301
int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height)
Calculate the size in bytes that a picture of the given width and height would occupy if stored in th...
Definition: avpicture.c:49
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:530
An instance of a filter.
Definition: avfilter.h:633
AVPacket subcc_packet
Definition: lavfi.c:58
number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of...
Definition: pixfmt.h:328
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
int height
Definition: frame.h:220
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:628
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:72
#define av_malloc_array(a, b)
static int * create_all_formats(int n)
Definition: lavfi.c:61
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:299
int stream_index
Definition: avcodec.h:1425
int * sink_stream_subcc_map
Definition: lavfi.c:55
This structure stores compressed data.
Definition: avcodec.h:1400
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:959
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:225
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:252
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1416
for(j=16;j >0;--j)
#define tb
Definition: regdef.h:68
#define DEC
Definition: lavfi.c:489
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:140