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"
35 #include "libavutil/avassert.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;
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) {
233  av_log(ctx, AV_LOG_ERROR,
234  "Loop with several streams is currently unsupported\n");
235  return AVERROR_PATCHWELCOME;
236  }
237 
238  // Try to find the movie format (container)
239  iformat = movie->format_name ? av_find_input_format(movie->format_name) : NULL;
240 
241  movie->format_ctx = NULL;
242  if ((ret = avformat_open_input(&movie->format_ctx, movie->file_name, iformat, NULL)) < 0) {
243  av_log(ctx, AV_LOG_ERROR,
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) {
256  av_log(ctx, AV_LOG_ERROR,
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++)
271  movie->format_ctx->streams[i]->discard = AVDISCARD_ALL;
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_insert_outpad(ctx, i, &pad)) < 0) {
310  av_freep(&pad.name);
311  return ret;
312  }
313  if ( movie->st[i].st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
314  !movie->st[i].st->codecpar->channel_layout) {
315  ret = guess_channel_layout(&movie->st[i], i, ctx);
316  if (ret < 0)
317  return ret;
318  }
319  ret = open_stream(ctx, &movie->st[i]);
320  if (ret < 0)
321  return ret;
322  }
323 
324  av_log(ctx, AV_LOG_VERBOSE, "seek_point:%"PRIi64" format_name:%s file_name:%s stream_index:%d\n",
325  movie->seek_point, movie->format_name, movie->file_name,
326  movie->stream_index);
327 
328  return 0;
329 }
330 
332 {
333  MovieContext *movie = ctx->priv;
334  int i;
335 
336  for (i = 0; i < ctx->nb_outputs; i++) {
337  av_freep(&ctx->output_pads[i].name);
338  if (movie->st[i].st)
339  avcodec_free_context(&movie->st[i].codec_ctx);
340  }
341  av_freep(&movie->st);
342  av_freep(&movie->out_index);
343  if (movie->format_ctx)
345 }
346 
348 {
349  MovieContext *movie = ctx->priv;
350  int list[] = { 0, -1 };
351  int64_t list64[] = { 0, -1 };
352  int i, ret;
353 
354  for (i = 0; i < ctx->nb_outputs; i++) {
355  MovieStream *st = &movie->st[i];
356  AVCodecParameters *c = st->st->codecpar;
357  AVFilterLink *outlink = ctx->outputs[i];
358 
359  switch (c->codec_type) {
360  case AVMEDIA_TYPE_VIDEO:
361  list[0] = c->format;
362  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.formats)) < 0)
363  return ret;
364  break;
365  case AVMEDIA_TYPE_AUDIO:
366  list[0] = c->format;
367  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.formats)) < 0)
368  return ret;
369  list[0] = c->sample_rate;
370  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.samplerates)) < 0)
371  return ret;
372  list64[0] = c->channel_layout;
374  &outlink->incfg.channel_layouts)) < 0)
375  return ret;
376  break;
377  }
378  }
379 
380  return 0;
381 }
382 
384 {
385  AVFilterContext *ctx = outlink->src;
386  MovieContext *movie = ctx->priv;
387  unsigned out_id = FF_OUTLINK_IDX(outlink);
388  MovieStream *st = &movie->st[out_id];
389  AVCodecParameters *c = st->st->codecpar;
390 
391  outlink->time_base = st->st->time_base;
392 
393  switch (c->codec_type) {
394  case AVMEDIA_TYPE_VIDEO:
395  outlink->w = c->width;
396  outlink->h = c->height;
397  outlink->frame_rate = st->st->r_frame_rate;
398  break;
399  case AVMEDIA_TYPE_AUDIO:
400  break;
401  }
402 
403  return 0;
404 }
405 
406 static char *describe_frame_to_str(char *dst, size_t dst_size,
409 {
410  switch (frame_type) {
411  case AVMEDIA_TYPE_VIDEO:
412  snprintf(dst, dst_size,
413  "video pts:%s time:%s size:%dx%d aspect:%d/%d",
414  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &link->time_base),
415  frame->width, frame->height,
416  frame->sample_aspect_ratio.num,
417  frame->sample_aspect_ratio.den);
418  break;
419  case AVMEDIA_TYPE_AUDIO:
420  snprintf(dst, dst_size,
421  "audio pts:%s time:%s samples:%d",
422  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &link->time_base),
423  frame->nb_samples);
424  break;
425  default:
426  snprintf(dst, dst_size, "%s BUG", av_get_media_type_string(frame_type));
427  break;
428  }
429  return dst;
430 }
431 
433 {
434  MovieContext *movie = ctx->priv;
435  int64_t timestamp = movie->seek_point;
436  int ret, i;
437 
438  if (movie->format_ctx->start_time != AV_NOPTS_VALUE)
439  timestamp += movie->format_ctx->start_time;
440  ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD);
441  if (ret < 0) {
442  av_log(ctx, AV_LOG_ERROR, "Unable to loop: %s\n", av_err2str(ret));
443  movie->loop_count = 1; /* do not try again */
444  return ret;
445  }
446 
447  for (i = 0; i < ctx->nb_outputs; i++) {
449  }
450  return 0;
451 }
452 
454 {
455  MovieContext *movie = ctx->priv;
456  AVPacket pkt = { 0 };
457  int pkt_out_id, ret;
458 
459  /* read a new packet from input stream */
460  ret = av_read_frame(movie->format_ctx, &pkt);
461  if (ret == AVERROR_EOF) {
462  /* EOF -> set all decoders for flushing */
463  for (int i = 0; i < ctx->nb_outputs; i++) {
464  ret = avcodec_send_packet(movie->st[i].codec_ctx, NULL);
465  if (ret < 0 && ret != AVERROR_EOF)
466  return ret;
467  }
468 
469  return 0;
470  } else if (ret < 0)
471  return ret;
472 
473  /* send the packet to its decoder, if any */
474  pkt_out_id = pkt.stream_index > movie->max_stream_index ? -1 :
475  movie->out_index[pkt.stream_index];
476  if (pkt_out_id >= 0)
477  ret = avcodec_send_packet(movie->st[pkt_out_id].codec_ctx, &pkt);
478  av_packet_unref(&pkt);
479 
480  return ret;
481 }
482 
483 /**
484  * Try to push a frame to the requested output.
485  *
486  * @param ctx filter context
487  * @param out_id number of output where a frame is wanted;
488  * @return 0 if a frame was pushed on the requested output,
489  * AVERROR(EAGAIN) if the decoder requires more input
490  * AVERROR(EOF) if the decoder has been completely flushed
491  * <0 AVERROR code
492  */
493 static int movie_push_frame(AVFilterContext *ctx, unsigned out_id)
494 {
495  MovieContext *movie = ctx->priv;
496  MovieStream *st = &movie->st[out_id];
497  AVFilterLink *outlink = ctx->outputs[out_id];
498  AVFrame *frame;
499  int ret;
500 
501  frame = av_frame_alloc();
502  if (!frame)
503  return AVERROR(ENOMEM);
504 
505  ret = avcodec_receive_frame(st->codec_ctx, frame);
506  if (ret < 0) {
507  if (ret != AVERROR_EOF && ret != AVERROR(EAGAIN))
508  av_log(ctx, AV_LOG_WARNING, "Decode error: %s\n", av_err2str(ret));
509 
510  av_frame_free(&frame);
511  return ret;
512  }
513 
514  frame->pts = frame->best_effort_timestamp;
515  if (frame->pts != AV_NOPTS_VALUE) {
516  if (movie->ts_offset)
517  frame->pts += av_rescale_q_rnd(movie->ts_offset, AV_TIME_BASE_Q, outlink->time_base, AV_ROUND_UP);
518  if (st->discontinuity_threshold) {
519  if (st->last_pts != AV_NOPTS_VALUE) {
520  int64_t diff = frame->pts - st->last_pts;
521  if (diff < 0 || diff > st->discontinuity_threshold) {
522  av_log(ctx, AV_LOG_VERBOSE, "Discontinuity in stream:%d diff:%"PRId64"\n", out_id, diff);
523  movie->ts_offset += av_rescale_q_rnd(-diff, outlink->time_base, AV_TIME_BASE_Q, AV_ROUND_UP);
524  frame->pts -= diff;
525  }
526  }
527  }
528  st->last_pts = frame->pts;
529  }
530  ff_dlog(ctx, "movie_push_frame(): file:'%s' %s\n", movie->file_name,
531  describe_frame_to_str((char[1024]){0}, 1024, frame,
532  st->st->codecpar->codec_type, outlink));
533 
534  if (st->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
535  if (frame->format != outlink->format) {
536  av_log(ctx, AV_LOG_ERROR, "Format changed %s -> %s, discarding frame\n",
537  av_get_pix_fmt_name(outlink->format),
539  );
540  av_frame_free(&frame);
541  return 0;
542  }
543  }
544  ret = ff_filter_frame(outlink, frame);
545 
546  if (ret < 0)
547  return ret;
548  return 0;
549 }
550 
551 static int movie_request_frame(AVFilterLink *outlink)
552 {
553  AVFilterContext *ctx = outlink->src;
554  MovieContext *movie = ctx->priv;
555  unsigned out_id = FF_OUTLINK_IDX(outlink);
556 
557  while (1) {
558  int got_eagain = 0, got_eof = 0;
559  int ret = 0;
560 
561  /* check all decoders for available output */
562  for (int i = 0; i < ctx->nb_outputs; i++) {
563  ret = movie_push_frame(ctx, i);
564  if (ret == AVERROR(EAGAIN))
565  got_eagain++;
566  else if (ret == AVERROR_EOF)
567  got_eof++;
568  else if (ret < 0)
569  return ret;
570  else if (i == out_id)
571  return 0;
572  }
573 
574  if (got_eagain) {
575  /* all decoders require more input -> read a new packet */
576  ret = movie_decode_packet(ctx);
577  if (ret < 0)
578  return ret;
579  } else if (got_eof) {
580  /* all decoders flushed */
581  if (movie->loop_count != 1) {
582  ret = rewind_file(ctx);
583  if (ret < 0)
584  return ret;
585  movie->loop_count -= movie->loop_count > 1;
586  av_log(ctx, AV_LOG_VERBOSE, "Stream finished, looping.\n");
587  continue;
588  }
589  return AVERROR_EOF;
590  }
591  }
592 }
593 
594 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
595  char *res, int res_len, int flags)
596 {
597  MovieContext *movie = ctx->priv;
598  int ret = AVERROR(ENOSYS);
599 
600  if (!strcmp(cmd, "seek")) {
601  int idx, flags, i;
602  int64_t ts;
603  char tail[2];
604 
605  if (sscanf(args, "%i|%"SCNi64"|%i %1s", &idx, &ts, &flags, tail) != 3)
606  return AVERROR(EINVAL);
607 
608  ret = av_seek_frame(movie->format_ctx, idx, ts, flags);
609  if (ret < 0)
610  return ret;
611 
612  for (i = 0; i < ctx->nb_outputs; i++) {
614  }
615  return ret;
616  } else if (!strcmp(cmd, "get_duration")) {
617  int print_len;
618  char tail[2];
619 
620  if (!res || res_len <= 0)
621  return AVERROR(EINVAL);
622 
623  if (args && sscanf(args, "%1s", tail) == 1)
624  return AVERROR(EINVAL);
625 
626  print_len = snprintf(res, res_len, "%"PRId64, movie->format_ctx->duration);
627  if (print_len < 0 || print_len >= res_len)
628  return AVERROR(EINVAL);
629 
630  return 0;
631  }
632 
633  return ret;
634 }
635 
636 #if CONFIG_MOVIE_FILTER
637 
638 AVFILTER_DEFINE_CLASS(movie);
639 
641  .name = "movie",
642  .description = NULL_IF_CONFIG_SMALL("Read from a movie source."),
643  .priv_size = sizeof(MovieContext),
644  .priv_class = &movie_class,
646  .uninit = movie_uninit,
648 
649  .inputs = NULL,
650  .outputs = NULL,
653 };
654 
655 #endif /* CONFIG_MOVIE_FILTER */
656 
657 #if CONFIG_AMOVIE_FILTER
658 
659 #define amovie_options movie_options
660 AVFILTER_DEFINE_CLASS(amovie);
661 
663  .name = "amovie",
664  .description = NULL_IF_CONFIG_SMALL("Read audio from a movie source."),
665  .priv_size = sizeof(MovieContext),
667  .uninit = movie_uninit,
669 
670  .inputs = NULL,
671  .outputs = NULL,
672  .priv_class = &amovie_class,
675 };
676 
677 #endif /* CONFIG_AMOVIE_FILTER */
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2407
#define NULL
Definition: coverity.c:32
static AVStream * find_stream(void *log, AVFormatContext *avf, const char *spec)
Definition: src_movie.c:99
int64_t discontinuity_threshold
Definition: src_movie.c:54
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
AVOption.
Definition: opt.h:248
int64_t ts_offset
Definition: src_movie.c:69
AVFilterChannelLayouts * ff_make_format64_list(const int64_t *fmts)
Definition: formats.c:296
static av_cold void movie_uninit(AVFilterContext *ctx)
Definition: src_movie.c:331
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
Main libavfilter public API header.
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AVStream * st
Definition: src_movie.c:52
int64_t last_pts
Definition: src_movie.c:55
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:881
static const AVOption movie_options[]
Definition: src_movie.c:81
GLint GLenum type
Definition: opengl_enc.c:104
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:502
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:65
#define FF_OUTLINK_IDX(link)
Definition: internal.h:303
discard all
Definition: avcodec.h:236
static AVPacket pkt
char * stream_specs
user-provided list of streams, separated by +
Definition: src_movie.c:65
AVCodec.
Definition: codec.h:190
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
char * file_name
Definition: src_movie.c:64
Macro definitions for various function/variable attributes.
frame_type
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:287
Format I/O context.
Definition: avformat.h:1239
double seek_point_d
Definition: src_movie.c:62
const char * name
Pad name.
Definition: internal.h:60
static int open_stream(AVFilterContext *ctx, MovieStream *st)
Definition: src_movie.c:153
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:462
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1091
AVFilterPad * output_pads
array of output pads
Definition: avfilter.h:352
Round toward +infinity.
Definition: mathematics.h:83
static int nb_streams
Definition: ffprobe.c:283
#define av_cold
Definition: attributes.h:88
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
int width
Video only.
Definition: codec_par.h:126
static av_cold int uninit(AVCodecContext *avctx)
Definition: crystalhd.c:279
AVOptions.
timestamp utils, mostly useful for debugging/logging purposes
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
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:5274
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:407
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1307
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: utils.c:2169
#define ff_dlog(a,...)
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:112
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
#define av_log(a,...)
A filter pad used for either input or output.
Definition: internal.h:54
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec **decoder_ret, int flags)
Find the "best" stream in the file.
Definition: utils.c:4200
AVFilter ff_avsrc_amovie
int width
Definition: frame.h:372
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
#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
unsigned nb_outputs
number of output pads
Definition: avfilter.h:354
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:666
void * priv
private data for use by the filter
Definition: avfilter.h:356
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:445
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
ff_const59 AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:118
simple assert() macros that are a bit more flexible than ISO C assert().
#define FFMAX(a, b)
Definition: common.h:94
static int guess_channel_layout(MovieStream *st, int st_index, void *log_ctx)
Definition: src_movie.c:182
#define FLAGS
Definition: src_movie.c:79
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1295
int(* config_props)(AVFilterLink *link)
Link configuration callback.
Definition: internal.h:118
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:800
AVFilterChannelLayouts * channel_layouts
Lists of supported channel layouts, only for audio.
Definition: avfilter.h:455
int64_t discontinuity_threshold
Definition: src_movie.c:68
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:172
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:467
int loop_count
Definition: src_movie.c:67
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
AVFormatContext * ctx
Definition: movenc.c:48
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
static int movie_config_output_props(AVFilterLink *outlink)
Definition: src_movie.c:383
char * format_name
Definition: src_movie.c:63
int dummy
Definition: motion.c:64
static int movie_decode_packet(AVFilterContext *ctx)
Definition: src_movie.c:453
AVFilterFormats * samplerates
Lists of supported sample rates, only for audio.
Definition: avfilter.h:450
int max_stream_index
max stream # actually used for output
Definition: src_movie.c:73
static int got_eagain(void)
Definition: ffmpeg.c:4214
static av_cold int movie_common_init(AVFilterContext *ctx)
Definition: src_movie.c:205
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:1790
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.
Stream structure.
Definition: avformat.h:880
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: utils.c:1086
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:387
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:603
int * out_index
stream number -> output number map, or -1
Definition: src_movie.c:75
static AVInputFormat * iformat
Definition: ffprobe.c:260
Libavcodec external API header.
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:187
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
main external API structure.
Definition: avcodec.h:531
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:606
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: src_movie.c:594
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
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:402
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
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:145
int64_t seek_point
seekpoint in microseconds
Definition: src_movie.c:61
static int movie_push_frame(AVFilterContext *ctx, unsigned out_id)
Try to push a frame to the requested output.
Definition: src_movie.c:493
AVMediaType
Definition: avutil.h:199
discard useless packets like 0 size packets in avi
Definition: avcodec.h:231
const char * name
Filter name.
Definition: avfilter.h:149
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
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:545
#define snprintf
Definition: snprintf.h:34
int64_t best_effort_timestamp
frame timestamp estimated using various heuristics, in stream time base
Definition: frame.h:578
AVFilter ff_avsrc_movie
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:353
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1714
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:940
static char * describe_frame_to_str(char *dst, size_t dst_size, AVFrame *frame, enum AVMediaType frame_type, AVFilterLink *link)
Definition: src_movie.c:406
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
#define flags(name, subs,...)
Definition: cbs_av1.c:561
static int format_name(const char *buf, char **s, int index, const char *varname)
Definition: hlsenc.c:1942
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
Definition: avformat.h:1344
int stream_index
for compatibility
Definition: src_movie.c:66
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Seek to the keyframe at timestamp.
Definition: utils.c:2461
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
int sample_rate
Audio only.
Definition: codec_par.h:170
#define OFFSET(x)
Definition: src_movie.c:78
static int movie_request_frame(AVFilterLink *outlink)
Definition: src_movie.c:551
Main libavformat public API header.
static int query_formats(AVFilterContext *ctx)
Definition: aeval.c:244
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:3569
int den
Denominator.
Definition: rational.h:60
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4449
static int movie_query_formats(AVFilterContext *ctx)
Definition: src_movie.c:347
static av_always_inline int diff(const uint32_t a, const uint32_t b)
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
#define AVFILTER_DEFINE_CLASS(fname)
Definition: internal.h:288
static int rewind_file(AVFilterContext *ctx)
Definition: src_movie.c:432
AVCodecContext * codec_ctx
Definition: src_movie.c:53
AVFormatContext * format_ctx
Definition: src_movie.c:71
int(* request_frame)(AVFilterLink *link)
Frame request callback.
Definition: internal.h:102
int channels
Audio only.
Definition: codec_par.h:166
An instance of a filter.
Definition: avfilter.h:341
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1354
int height
Definition: frame.h:372
#define av_freep(p)
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1045
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
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:2489
int stream_index
Definition: packet.h:365
internal API functions
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:909
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
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:935
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1022
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
Definition: internal.h:248
This structure stores compressed data.
Definition: packet.h:340
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:380
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:344
for(j=16;j >0;--j)
int i
Definition: input.c:407
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
MovieStream * st
array of all streams, one per output
Definition: src_movie.c:74