FFmpeg
src_movie.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2010 Stefano Sabatini
3  * Copyright (c) 2008 Victor Paesa
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * movie video source
25  *
26  * @todo use direct rendering (no allocation of a new frame)
27  * @todo support a PTS correction mechanism
28  */
29 
30 #include <float.h>
31 #include <stdint.h>
32 
33 #include "libavutil/attributes.h"
34 #include "libavutil/avstring.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/imgutils.h"
38 #include "libavutil/internal.h"
39 #include "libavutil/timestamp.h"
40 
41 #include "libavcodec/avcodec.h"
42 
43 #include "libavformat/avformat.h"
44 
45 #include "audio.h"
46 #include "avfilter.h"
47 #include "formats.h"
48 #include "internal.h"
49 #include "video.h"
50 
51 typedef struct MovieStream {
55  int64_t last_pts;
56 } MovieStream;
57 
58 typedef struct MovieContext {
59  /* common A/V fields */
60  const AVClass *class;
61  int64_t seek_point; ///< seekpoint in microseconds
62  double seek_point_d;
63  char *format_name;
64  char *file_name;
65  char *stream_specs; /**< user-provided list of streams, separated by + */
66  int stream_index; /**< for compatibility */
69  int64_t ts_offset;
70 
72 
73  int max_stream_index; /**< max stream # actually used for output */
74  MovieStream *st; /**< array of all streams, one per output */
75  int *out_index; /**< stream number -> output number map, or -1 */
76 } MovieContext;
77 
78 #define OFFSET(x) offsetof(MovieContext, x)
79 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_VIDEO_PARAM
80 
81 static const AVOption movie_options[]= {
82  { "filename", NULL, OFFSET(file_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
83  { "format_name", "set format name", OFFSET(format_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
84  { "f", "set format name", OFFSET(format_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
85  { "stream_index", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
86  { "si", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
87  { "seek_point", "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0, (INT64_MAX-1) / 1000000, FLAGS },
88  { "sp", "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0, (INT64_MAX-1) / 1000000, FLAGS },
89  { "streams", "set streams", OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, FLAGS },
90  { "s", "set streams", OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, FLAGS },
91  { "loop", "set loop count", OFFSET(loop_count), AV_OPT_TYPE_INT, {.i64 = 1}, 0, INT_MAX, FLAGS },
92  { "discontinuity", "set discontinuity threshold", OFFSET(discontinuity_threshold), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, INT64_MAX, FLAGS },
93  { NULL },
94 };
95 
96 static int movie_config_output_props(AVFilterLink *outlink);
97 static int movie_request_frame(AVFilterLink *outlink);
98 
99 static AVStream *find_stream(void *log, AVFormatContext *avf, const char *spec)
100 {
101  int i, ret, already = 0, stream_id = -1;
102  char type_char[2], dummy;
103  AVStream *found = NULL;
104  enum AVMediaType type;
105 
106  ret = sscanf(spec, "d%1[av]%d%c", type_char, &stream_id, &dummy);
107  if (ret >= 1 && ret <= 2) {
108  type = type_char[0] == 'v' ? AVMEDIA_TYPE_VIDEO : AVMEDIA_TYPE_AUDIO;
109  ret = av_find_best_stream(avf, type, stream_id, -1, NULL, 0);
110  if (ret < 0) {
111  av_log(log, AV_LOG_ERROR, "No %s stream with index '%d' found\n",
112  av_get_media_type_string(type), stream_id);
113  return NULL;
114  }
115  return avf->streams[ret];
116  }
117  for (i = 0; i < avf->nb_streams; i++) {
118  ret = avformat_match_stream_specifier(avf, avf->streams[i], spec);
119  if (ret < 0) {
120  av_log(log, AV_LOG_ERROR,
121  "Invalid stream specifier \"%s\"\n", spec);
122  return NULL;
123  }
124  if (!ret)
125  continue;
126  if (avf->streams[i]->discard != AVDISCARD_ALL) {
127  already++;
128  continue;
129  }
130  if (found) {
131  av_log(log, AV_LOG_WARNING,
132  "Ambiguous stream specifier \"%s\", using #%d\n", spec, i);
133  break;
134  }
135  found = avf->streams[i];
136  }
137  if (!found) {
138  av_log(log, AV_LOG_WARNING, "Stream specifier \"%s\" %s\n", spec,
139  already ? "matched only already used streams" :
140  "did not match any stream");
141  return NULL;
142  }
143  if (found->codecpar->codec_type != AVMEDIA_TYPE_VIDEO &&
145  av_log(log, AV_LOG_ERROR, "Stream specifier \"%s\" matched a %s stream,"
146  "currently unsupported by libavfilter\n", spec,
148  return NULL;
149  }
150  return found;
151 }
152 
154 {
155  const AVCodec *codec;
156  int ret;
157 
158  codec = avcodec_find_decoder(st->st->codecpar->codec_id);
159  if (!codec) {
160  av_log(ctx, AV_LOG_ERROR, "Failed to find any codec\n");
161  return AVERROR(EINVAL);
162  }
163 
164  st->codec_ctx = avcodec_alloc_context3(codec);
165  if (!st->codec_ctx)
166  return AVERROR(ENOMEM);
167 
169  if (ret < 0)
170  return ret;
171 
173 
174  if ((ret = avcodec_open2(st->codec_ctx, codec, NULL)) < 0) {
175  av_log(ctx, AV_LOG_ERROR, "Failed to open codec\n");
176  return ret;
177  }
178 
179  return 0;
180 }
181 
182 static int guess_channel_layout(MovieStream *st, int st_index, void *log_ctx)
183 {
184  AVCodecParameters *dec_par = st->st->codecpar;
185  char buf[256];
186  int64_t chl = av_get_default_channel_layout(dec_par->channels);
187 
188  if (!chl) {
189  av_log(log_ctx, AV_LOG_ERROR,
190  "Channel layout is not set in stream %d, and could not "
191  "be guessed from the number of channels (%d)\n",
192  st_index, dec_par->channels);
193  return AVERROR(EINVAL);
194  }
195 
196  av_get_channel_layout_string(buf, sizeof(buf), dec_par->channels, chl);
197  av_log(log_ctx, AV_LOG_WARNING,
198  "Channel layout is not set in output stream %d, "
199  "guessed channel layout is '%s'\n",
200  st_index, buf);
201  dec_par->channel_layout = chl;
202  return 0;
203 }
204 
206 {
207  MovieContext *movie = ctx->priv;
208  const AVInputFormat *iformat = NULL;
209  int64_t timestamp;
210  int nb_streams = 1, ret, i;
211  char default_streams[16], *stream_specs, *spec, *cursor;
212  AVStream *st;
213 
214  if (!movie->file_name) {
215  av_log(ctx, AV_LOG_ERROR, "No filename provided!\n");
216  return AVERROR(EINVAL);
217  }
218 
219  movie->seek_point = movie->seek_point_d * 1000000 + 0.5;
220 
221  stream_specs = movie->stream_specs;
222  if (!stream_specs) {
223  snprintf(default_streams, sizeof(default_streams), "d%c%d",
224  !strcmp(ctx->filter->name, "amovie") ? 'a' : 'v',
225  movie->stream_index);
226  stream_specs = default_streams;
227  }
228  for (cursor = stream_specs; *cursor; cursor++)
229  if (*cursor == '+')
230  nb_streams++;
231 
232  if (movie->loop_count != 1 && nb_streams != 1) {
234  "Loop with several streams is currently unsupported\n");
235  return AVERROR_PATCHWELCOME;
236  }
237 
238  // Try to find the movie format (container)
240 
241  movie->format_ctx = NULL;
242  if ((ret = avformat_open_input(&movie->format_ctx, movie->file_name, iformat, NULL)) < 0) {
244  "Failed to avformat_open_input '%s'\n", movie->file_name);
245  return ret;
246  }
247  if ((ret = avformat_find_stream_info(movie->format_ctx, NULL)) < 0)
248  av_log(ctx, AV_LOG_WARNING, "Failed to find stream info\n");
249 
250  // if seeking requested, we execute it
251  if (movie->seek_point > 0) {
252  timestamp = movie->seek_point;
253  // add the stream start time, should it exist
254  if (movie->format_ctx->start_time != AV_NOPTS_VALUE) {
255  if (timestamp > 0 && movie->format_ctx->start_time > INT64_MAX - timestamp) {
257  "%s: seek value overflow with start_time:%"PRId64" seek_point:%"PRId64"\n",
258  movie->file_name, movie->format_ctx->start_time, movie->seek_point);
259  return AVERROR(EINVAL);
260  }
261  timestamp += movie->format_ctx->start_time;
262  }
263  if ((ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD)) < 0) {
264  av_log(ctx, AV_LOG_ERROR, "%s: could not seek to position %"PRId64"\n",
265  movie->file_name, timestamp);
266  return ret;
267  }
268  }
269 
270  for (i = 0; i < movie->format_ctx->nb_streams; i++)
272 
273  movie->st = av_calloc(nb_streams, sizeof(*movie->st));
274  if (!movie->st)
275  return AVERROR(ENOMEM);
276 
277  for (i = 0; i < nb_streams; i++) {
278  spec = av_strtok(stream_specs, "+", &cursor);
279  if (!spec)
280  return AVERROR_BUG;
281  stream_specs = NULL; /* for next strtok */
282  st = find_stream(ctx, movie->format_ctx, spec);
283  if (!st)
284  return AVERROR(EINVAL);
286  movie->st[i].st = st;
287  movie->max_stream_index = FFMAX(movie->max_stream_index, st->index);
288  movie->st[i].discontinuity_threshold =
290  }
291  if (av_strtok(NULL, "+", &cursor))
292  return AVERROR_BUG;
293 
294  movie->out_index = av_calloc(movie->max_stream_index + 1,
295  sizeof(*movie->out_index));
296  if (!movie->out_index)
297  return AVERROR(ENOMEM);
298  for (i = 0; i <= movie->max_stream_index; i++)
299  movie->out_index[i] = -1;
300  for (i = 0; i < nb_streams; i++) {
301  AVFilterPad pad = { 0 };
302  movie->out_index[movie->st[i].st->index] = i;
303  pad.type = movie->st[i].st->codecpar->codec_type;
304  pad.name = av_asprintf("out%d", i);
305  if (!pad.name)
306  return AVERROR(ENOMEM);
309  if ((ret = ff_append_outpad_free_name(ctx, &pad)) < 0)
310  return ret;
311  if ( movie->st[i].st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
312  !movie->st[i].st->codecpar->channel_layout) {
313  ret = guess_channel_layout(&movie->st[i], i, ctx);
314  if (ret < 0)
315  return ret;
316  }
317  ret = open_stream(ctx, &movie->st[i]);
318  if (ret < 0)
319  return ret;
320  }
321 
322  av_log(ctx, AV_LOG_VERBOSE, "seek_point:%"PRIi64" format_name:%s file_name:%s stream_index:%d\n",
323  movie->seek_point, movie->format_name, movie->file_name,
324  movie->stream_index);
325 
326  return 0;
327 }
328 
330 {
331  MovieContext *movie = ctx->priv;
332  int i;
333 
334  for (i = 0; i < ctx->nb_outputs; i++) {
335  if (movie->st[i].st)
337  }
338  av_freep(&movie->st);
339  av_freep(&movie->out_index);
340  if (movie->format_ctx)
342 }
343 
345 {
346  MovieContext *movie = ctx->priv;
347  int list[] = { 0, -1 };
348  int64_t list64[] = { 0, -1 };
349  int i, ret;
350 
351  for (i = 0; i < ctx->nb_outputs; i++) {
352  MovieStream *st = &movie->st[i];
353  AVCodecParameters *c = st->st->codecpar;
354  AVFilterLink *outlink = ctx->outputs[i];
355 
356  switch (c->codec_type) {
357  case AVMEDIA_TYPE_VIDEO:
358  list[0] = c->format;
359  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.formats)) < 0)
360  return ret;
361  break;
362  case AVMEDIA_TYPE_AUDIO:
363  list[0] = c->format;
364  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.formats)) < 0)
365  return ret;
366  list[0] = c->sample_rate;
367  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.samplerates)) < 0)
368  return ret;
369  list64[0] = c->channel_layout;
371  &outlink->incfg.channel_layouts)) < 0)
372  return ret;
373  break;
374  }
375  }
376 
377  return 0;
378 }
379 
381 {
382  AVFilterContext *ctx = outlink->src;
383  MovieContext *movie = ctx->priv;
384  unsigned out_id = FF_OUTLINK_IDX(outlink);
385  MovieStream *st = &movie->st[out_id];
386  AVCodecParameters *c = st->st->codecpar;
387 
388  outlink->time_base = st->st->time_base;
389 
390  switch (c->codec_type) {
391  case AVMEDIA_TYPE_VIDEO:
392  outlink->w = c->width;
393  outlink->h = c->height;
394  outlink->frame_rate = st->st->r_frame_rate;
395  break;
396  case AVMEDIA_TYPE_AUDIO:
397  break;
398  }
399 
400  return 0;
401 }
402 
403 static char *describe_frame_to_str(char *dst, size_t dst_size,
406 {
407  switch (frame_type) {
408  case AVMEDIA_TYPE_VIDEO:
409  snprintf(dst, dst_size,
410  "video pts:%s time:%s size:%dx%d aspect:%d/%d",
411  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &link->time_base),
412  frame->width, frame->height,
413  frame->sample_aspect_ratio.num,
414  frame->sample_aspect_ratio.den);
415  break;
416  case AVMEDIA_TYPE_AUDIO:
417  snprintf(dst, dst_size,
418  "audio pts:%s time:%s samples:%d",
419  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &link->time_base),
420  frame->nb_samples);
421  break;
422  default:
423  snprintf(dst, dst_size, "%s BUG", av_get_media_type_string(frame_type));
424  break;
425  }
426  return dst;
427 }
428 
430 {
431  MovieContext *movie = ctx->priv;
432  int64_t timestamp = movie->seek_point;
433  int ret, i;
434 
435  if (movie->format_ctx->start_time != AV_NOPTS_VALUE)
436  timestamp += movie->format_ctx->start_time;
437  ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD);
438  if (ret < 0) {
439  av_log(ctx, AV_LOG_ERROR, "Unable to loop: %s\n", av_err2str(ret));
440  movie->loop_count = 1; /* do not try again */
441  return ret;
442  }
443 
444  for (i = 0; i < ctx->nb_outputs; i++) {
446  }
447  return 0;
448 }
449 
451 {
452  MovieContext *movie = ctx->priv;
453  AVPacket pkt = { 0 };
454  int pkt_out_id, ret;
455 
456  /* read a new packet from input stream */
457  ret = av_read_frame(movie->format_ctx, &pkt);
458  if (ret == AVERROR_EOF) {
459  /* EOF -> set all decoders for flushing */
460  for (int i = 0; i < ctx->nb_outputs; i++) {
462  if (ret < 0 && ret != AVERROR_EOF)
463  return ret;
464  }
465 
466  return 0;
467  } else if (ret < 0)
468  return ret;
469 
470  /* send the packet to its decoder, if any */
471  pkt_out_id = pkt.stream_index > movie->max_stream_index ? -1 :
472  movie->out_index[pkt.stream_index];
473  if (pkt_out_id >= 0)
474  ret = avcodec_send_packet(movie->st[pkt_out_id].codec_ctx, &pkt);
476 
477  return ret;
478 }
479 
480 /**
481  * Try to push a frame to the requested output.
482  *
483  * @param ctx filter context
484  * @param out_id number of output where a frame is wanted;
485  * @return 0 if a frame was pushed on the requested output,
486  * AVERROR(EAGAIN) if the decoder requires more input
487  * AVERROR(EOF) if the decoder has been completely flushed
488  * <0 AVERROR code
489  */
490 static int movie_push_frame(AVFilterContext *ctx, unsigned out_id)
491 {
492  MovieContext *movie = ctx->priv;
493  MovieStream *st = &movie->st[out_id];
494  AVFilterLink *outlink = ctx->outputs[out_id];
495  AVFrame *frame;
496  int ret;
497 
498  frame = av_frame_alloc();
499  if (!frame)
500  return AVERROR(ENOMEM);
501 
503  if (ret < 0) {
504  if (ret != AVERROR_EOF && ret != AVERROR(EAGAIN))
505  av_log(ctx, AV_LOG_WARNING, "Decode error: %s\n", av_err2str(ret));
506 
508  return ret;
509  }
510 
511  frame->pts = frame->best_effort_timestamp;
512  if (frame->pts != AV_NOPTS_VALUE) {
513  if (movie->ts_offset)
515  if (st->discontinuity_threshold) {
516  if (st->last_pts != AV_NOPTS_VALUE) {
517  int64_t diff = frame->pts - st->last_pts;
518  if (diff < 0 || diff > st->discontinuity_threshold) {
519  av_log(ctx, AV_LOG_VERBOSE, "Discontinuity in stream:%d diff:%"PRId64"\n", out_id, diff);
521  frame->pts -= diff;
522  }
523  }
524  }
525  st->last_pts = frame->pts;
526  }
527  ff_dlog(ctx, "movie_push_frame(): file:'%s' %s\n", movie->file_name,
528  describe_frame_to_str((char[1024]){0}, 1024, frame,
529  st->st->codecpar->codec_type, outlink));
530 
531  if (st->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
532  if (frame->format != outlink->format) {
533  av_log(ctx, AV_LOG_ERROR, "Format changed %s -> %s, discarding frame\n",
534  av_get_pix_fmt_name(outlink->format),
535  av_get_pix_fmt_name(frame->format)
536  );
538  return 0;
539  }
540  }
541  ret = ff_filter_frame(outlink, frame);
542 
543  if (ret < 0)
544  return ret;
545  return 0;
546 }
547 
548 static int movie_request_frame(AVFilterLink *outlink)
549 {
550  AVFilterContext *ctx = outlink->src;
551  MovieContext *movie = ctx->priv;
552  unsigned out_id = FF_OUTLINK_IDX(outlink);
553 
554  while (1) {
555  int got_eagain = 0, got_eof = 0;
556  int ret = 0;
557 
558  /* check all decoders for available output */
559  for (int i = 0; i < ctx->nb_outputs; i++) {
561  if (ret == AVERROR(EAGAIN))
562  got_eagain++;
563  else if (ret == AVERROR_EOF)
564  got_eof++;
565  else if (ret < 0)
566  return ret;
567  else if (i == out_id)
568  return 0;
569  }
570 
571  if (got_eagain) {
572  /* all decoders require more input -> read a new packet */
574  if (ret < 0)
575  return ret;
576  } else if (got_eof) {
577  /* all decoders flushed */
578  if (movie->loop_count != 1) {
579  ret = rewind_file(ctx);
580  if (ret < 0)
581  return ret;
582  movie->loop_count -= movie->loop_count > 1;
583  av_log(ctx, AV_LOG_VERBOSE, "Stream finished, looping.\n");
584  continue;
585  }
586  return AVERROR_EOF;
587  }
588  }
589 }
590 
591 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
592  char *res, int res_len, int flags)
593 {
594  MovieContext *movie = ctx->priv;
595  int ret = AVERROR(ENOSYS);
596 
597  if (!strcmp(cmd, "seek")) {
598  int idx, flags, i;
599  int64_t ts;
600  char tail[2];
601 
602  if (sscanf(args, "%i|%"SCNi64"|%i %1s", &idx, &ts, &flags, tail) != 3)
603  return AVERROR(EINVAL);
604 
605  ret = av_seek_frame(movie->format_ctx, idx, ts, flags);
606  if (ret < 0)
607  return ret;
608 
609  for (i = 0; i < ctx->nb_outputs; i++) {
611  }
612  return ret;
613  } else if (!strcmp(cmd, "get_duration")) {
614  int print_len;
615  char tail[2];
616 
617  if (!res || res_len <= 0)
618  return AVERROR(EINVAL);
619 
620  if (args && sscanf(args, "%1s", tail) == 1)
621  return AVERROR(EINVAL);
622 
623  print_len = snprintf(res, res_len, "%"PRId64, movie->format_ctx->duration);
624  if (print_len < 0 || print_len >= res_len)
625  return AVERROR(EINVAL);
626 
627  return 0;
628  }
629 
630  return ret;
631 }
632 
633 AVFILTER_DEFINE_CLASS_EXT(movie, "(a)movie", movie_options);
634 
635 #if CONFIG_MOVIE_FILTER
636 
637 const AVFilter ff_avsrc_movie = {
638  .name = "movie",
639  .description = NULL_IF_CONFIG_SMALL("Read from a movie source."),
640  .priv_size = sizeof(MovieContext),
641  .priv_class = &movie_class,
643  .uninit = movie_uninit,
645 
646  .inputs = NULL,
647  .outputs = NULL,
650 };
651 
652 #endif /* CONFIG_MOVIE_FILTER */
653 
654 #if CONFIG_AMOVIE_FILTER
655 
656 const AVFilter ff_avsrc_amovie = {
657  .name = "amovie",
658  .description = NULL_IF_CONFIG_SMALL("Read audio from a movie source."),
659  .priv_class = &movie_class,
660  .priv_size = sizeof(MovieContext),
662  .uninit = movie_uninit,
664 
665  .inputs = NULL,
666  .outputs = NULL,
669 };
670 
671 #endif /* CONFIG_AMOVIE_FILTER */
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:417
AVCodec
AVCodec.
Definition: codec.h:202
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVFilterFormatsConfig::samplerates
AVFilterFormats * samplerates
Lists of supported sample rates, only for audio.
Definition: avfilter.h:455
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:380
movie_decode_packet
static int movie_decode_packet(AVFilterContext *ctx)
Definition: src_movie.c:450
AVFilterFormatsConfig::channel_layouts
AVFilterChannelLayouts * channel_layouts
Lists of supported channel layouts, only for audio.
Definition: avfilter.h:460
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1019
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:548
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:894
describe_frame_to_str
static char * describe_frame_to_str(char *dst, size_t dst_size, AVFrame *frame, enum AVMediaType frame_type, AVFilterLink *link)
Definition: src_movie.c:403
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
MovieContext::stream_index
int stream_index
for compatibility
Definition: src_movie.c:66
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
FLAGS
#define FLAGS
Definition: src_movie.c:79
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
av_get_channel_layout_string
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
Definition: channel_layout.c:217
ff_make_format64_list
AVFilterChannelLayouts * ff_make_format64_list(const int64_t *fmts)
Definition: formats.c:389
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1165
AVOption
AVOption.
Definition: opt.h:247
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Definition: opt.h:238
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
float.h
movie_options
static const AVOption movie_options[]
Definition: src_movie.c:81
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:153
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1414
video.h
guess_channel_layout
static int guess_channel_layout(MovieStream *st, int st_index, void *log_ctx)
Definition: src_movie.c:182
ff_avsrc_movie
const AVFilter ff_avsrc_movie
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: src_movie.c:591
formats.h
av_find_best_stream
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, const AVCodec **decoder_ret, int flags)
Find the "best" stream in the file.
Definition: utils.c:500
MovieContext::out_index
int * out_index
stream number -> output number map, or -1
Definition: src_movie.c:75
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:355
got_eagain
static int got_eagain(void)
Definition: ffmpeg.c:4261
MovieContext::file_name
char * file_name
Definition: src_movie.c:64
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
open_stream
static int open_stream(AVFilterContext *ctx, MovieStream *st)
Definition: src_movie.c:153
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1440
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:83
ff_avsrc_amovie
const AVFilter ff_avsrc_amovie
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:50
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:99
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:626
AVFilterPad::request_frame
int(* request_frame)(AVFilterLink *link)
Frame request callback.
Definition: internal.h:114
av_cold
#define av_cold
Definition: attributes.h:90
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
avformat_open_input
int avformat_open_input(AVFormatContext **ps, const char *url, const AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: demux.c:207
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:141
av_seek_frame
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Seek to the keyframe at timestamp.
Definition: seek.c:633
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:226
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:553
FF_OUTLINK_IDX
#define FF_OUTLINK_IDX(link)
Definition: internal.h:298
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:186
avcodec_receive_frame
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:643
MovieContext::ts_offset
int64_t ts_offset
Definition: src_movie.c:69
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:192
ctx
AVFormatContext * ctx
Definition: movenc.c:48
nb_streams
static int nb_streams
Definition: ffprobe.c:289
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:141
MovieContext::format_ctx
AVFormatContext * format_ctx
Definition: src_movie.c:71
MovieContext
Definition: src_movie.c:58
find_stream
static AVStream * find_stream(void *log, AVFormatContext *avf, const char *spec)
Definition: src_movie.c:99
link
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a link
Definition: filter_design.txt:23
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:54
AVFormatContext
Format I/O context.
Definition: avformat.h:1097
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:992
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2151
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:868
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
movie_request_frame
static int movie_request_frame(AVFilterLink *outlink)
Definition: src_movie.c:548
MovieStream::discontinuity_threshold
int64_t discontinuity_threshold
Definition: src_movie.c:54
avcodec_free_context
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
Definition: options.c:156
MovieContext::discontinuity_threshold
int64_t discontinuity_threshold
Definition: src_movie.c:68
AVFILTER_DEFINE_CLASS_EXT
AVFILTER_DEFINE_CLASS_EXT(movie, "(a)movie", movie_options)
MovieStream::last_pts
int64_t last_pts
Definition: src_movie.c:55
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:25
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:137
MovieStream::codec_ctx
AVCodecContext * codec_ctx
Definition: src_movie.c:53
MovieContext::format_name
char * format_name
Definition: src_movie.c:63
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
MovieStream::st
AVStream * st
Definition: src_movie.c:52
MovieContext::seek_point_d
double seek_point_d
Definition: src_movie.c:62
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:917
AVFILTER_FLAG_DYNAMIC_OUTPUTS
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:116
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1153
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
AVFilterPad::config_props
int(* config_props)(AVFilterLink *link)
Link configuration callback.
Definition: internal.h:130
avformat_find_stream_info
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: demux.c:2396
movie_common_init
static av_cold int movie_common_init(AVFilterContext *ctx)
Definition: src_movie.c:205
av_ts2timestr
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:76
AVMediaType
AVMediaType
Definition: avutil.h:199
movie_query_formats
static int movie_query_formats(AVFilterContext *ctx)
Definition: src_movie.c:344
movie_uninit
static av_cold void movie_uninit(AVFilterContext *ctx)
Definition: src_movie.c:329
avformat_match_stream_specifier
int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the stream st contained in s is matched by the stream specifier spec.
Definition: utils.c:1492
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AVDISCARD_DEFAULT
@ AVDISCARD_DEFAULT
discard useless packets like 0 size packets in avi
Definition: defs.h:49
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:121
MovieContext::loop_count
int loop_count
Definition: src_movie.c:67
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
attributes.h
internal.h
iformat
static const AVInputFormat * iformat
Definition: ffprobe.c:266
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:580
i
int i
Definition: input.c:406
frame_type
frame_type
Definition: jpeg2000_parser.c:31
rewind_file
static int rewind_file(AVFilterContext *ctx)
Definition: src_movie.c:429
internal.h
avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: codec_par.c:147
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:804
MovieContext::max_stream_index
int max_stream_index
max stream # actually used for output
Definition: src_movie.c:73
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:56
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:271
avcodec.h
AVFilter
Filter definition.
Definition: avfilter.h:149
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:845
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:61
avcodec_flush_buffers
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:380
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
movie_push_frame
static int movie_push_frame(AVFilterContext *ctx, unsigned out_id)
Try to push a frame to the requested output.
Definition: src_movie.c:490
avformat.h
movie_config_output_props
static int movie_config_output_props(AVFilterLink *outlink)
Definition: src_movie.c:380
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:76
AVCodecContext
main external API structure.
Definition: avcodec.h:383
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:846
format_name
static int format_name(const char *buf, char **s, int index, const char *varname)
Definition: hlsenc.c:1925
channel_layout.h
dummy
int dummy
Definition: motion.c:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
avfilter.h
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:981
av_find_input_format
const AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:118
MovieContext::stream_specs
char * stream_specs
user-provided list of streams, separated by +
Definition: src_movie.c:65
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1199
AVPacket::stream_index
int stream_index
Definition: packet.h:375
AVFilterContext
An instance of a filter.
Definition: avfilter.h:346
MovieContext::st
MovieStream * st
array of all streams, one per output
Definition: src_movie.c:74
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
audio.h
AVFilterFormatsConfig::formats
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:450
av_get_default_channel_layout
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
Definition: channel_layout.c:231
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:350
ff_append_outpad_free_name
int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:156
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecParameters::channel_layout
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: aeval.c:244
imgutils.h
timestamp.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
MovieContext::seek_point
int64_t seek_point
seekpoint in microseconds
Definition: src_movie.c:61
AVFormatContext::start_time
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1189
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
uninit
static av_cold int uninit(AVCodecContext *avctx)
Definition: crystalhd.c:279
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
MovieStream
Definition: src_movie.c:51
snprintf
#define snprintf
Definition: snprintf.h:34
OFFSET
#define OFFSET(x)
Definition: src_movie.c:78
av_rescale_q_rnd
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:133
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2460