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 {
54  int done;
56  int64_t last_pts;
57 } MovieStream;
58 
59 typedef struct MovieContext {
60  /* common A/V fields */
61  const AVClass *class;
62  int64_t seek_point; ///< seekpoint in microseconds
63  double seek_point_d;
64  char *format_name;
65  char *file_name;
66  char *stream_specs; /**< user-provided list of streams, separated by + */
67  int stream_index; /**< for compatibility */
70  int64_t ts_offset;
71 
73  int eof;
75 
76  int max_stream_index; /**< max stream # actually used for output */
77  MovieStream *st; /**< array of all streams, one per output */
78  int *out_index; /**< stream number -> output number map, or -1 */
79 } MovieContext;
80 
81 #define OFFSET(x) offsetof(MovieContext, x)
82 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_VIDEO_PARAM
83 
84 static const AVOption movie_options[]= {
85  { "filename", NULL, OFFSET(file_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
86  { "format_name", "set format name", OFFSET(format_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
87  { "f", "set format name", OFFSET(format_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
88  { "stream_index", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
89  { "si", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
90  { "seek_point", "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0, (INT64_MAX-1) / 1000000, FLAGS },
91  { "sp", "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0, (INT64_MAX-1) / 1000000, FLAGS },
92  { "streams", "set streams", OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, FLAGS },
93  { "s", "set streams", OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, FLAGS },
94  { "loop", "set loop count", OFFSET(loop_count), AV_OPT_TYPE_INT, {.i64 = 1}, 0, INT_MAX, FLAGS },
95  { "discontinuity", "set discontinuity threshold", OFFSET(discontinuity_threshold), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, INT64_MAX, FLAGS },
96  { NULL },
97 };
98 
99 static int movie_config_output_props(AVFilterLink *outlink);
100 static int movie_request_frame(AVFilterLink *outlink);
101 
102 static AVStream *find_stream(void *log, AVFormatContext *avf, const char *spec)
103 {
104  int i, ret, already = 0, stream_id = -1;
105  char type_char[2], dummy;
106  AVStream *found = NULL;
107  enum AVMediaType type;
108 
109  ret = sscanf(spec, "d%1[av]%d%c", type_char, &stream_id, &dummy);
110  if (ret >= 1 && ret <= 2) {
111  type = type_char[0] == 'v' ? AVMEDIA_TYPE_VIDEO : AVMEDIA_TYPE_AUDIO;
112  ret = av_find_best_stream(avf, type, stream_id, -1, NULL, 0);
113  if (ret < 0) {
114  av_log(log, AV_LOG_ERROR, "No %s stream with index '%d' found\n",
115  av_get_media_type_string(type), stream_id);
116  return NULL;
117  }
118  return avf->streams[ret];
119  }
120  for (i = 0; i < avf->nb_streams; i++) {
121  ret = avformat_match_stream_specifier(avf, avf->streams[i], spec);
122  if (ret < 0) {
123  av_log(log, AV_LOG_ERROR,
124  "Invalid stream specifier \"%s\"\n", spec);
125  return NULL;
126  }
127  if (!ret)
128  continue;
129  if (avf->streams[i]->discard != AVDISCARD_ALL) {
130  already++;
131  continue;
132  }
133  if (found) {
134  av_log(log, AV_LOG_WARNING,
135  "Ambiguous stream specifier \"%s\", using #%d\n", spec, i);
136  break;
137  }
138  found = avf->streams[i];
139  }
140  if (!found) {
141  av_log(log, AV_LOG_WARNING, "Stream specifier \"%s\" %s\n", spec,
142  already ? "matched only already used streams" :
143  "did not match any stream");
144  return NULL;
145  }
146  if (found->codecpar->codec_type != AVMEDIA_TYPE_VIDEO &&
148  av_log(log, AV_LOG_ERROR, "Stream specifier \"%s\" matched a %s stream,"
149  "currently unsupported by libavfilter\n", spec,
151  return NULL;
152  }
153  return found;
154 }
155 
157 {
158  const AVCodec *codec;
159  int ret;
160 
161  codec = avcodec_find_decoder(st->st->codecpar->codec_id);
162  if (!codec) {
163  av_log(ctx, AV_LOG_ERROR, "Failed to find any codec\n");
164  return AVERROR(EINVAL);
165  }
166 
167  st->codec_ctx = avcodec_alloc_context3(codec);
168  if (!st->codec_ctx)
169  return AVERROR(ENOMEM);
170 
172  if (ret < 0)
173  return ret;
174 
175  st->codec_ctx->refcounted_frames = 1;
177 
178  if ((ret = avcodec_open2(st->codec_ctx, codec, NULL)) < 0) {
179  av_log(ctx, AV_LOG_ERROR, "Failed to open codec\n");
180  return ret;
181  }
182 
183  return 0;
184 }
185 
186 static int guess_channel_layout(MovieStream *st, int st_index, void *log_ctx)
187 {
188  AVCodecParameters *dec_par = st->st->codecpar;
189  char buf[256];
190  int64_t chl = av_get_default_channel_layout(dec_par->channels);
191 
192  if (!chl) {
193  av_log(log_ctx, AV_LOG_ERROR,
194  "Channel layout is not set in stream %d, and could not "
195  "be guessed from the number of channels (%d)\n",
196  st_index, dec_par->channels);
197  return AVERROR(EINVAL);
198  }
199 
200  av_get_channel_layout_string(buf, sizeof(buf), dec_par->channels, chl);
201  av_log(log_ctx, AV_LOG_WARNING,
202  "Channel layout is not set in output stream %d, "
203  "guessed channel layout is '%s'\n",
204  st_index, buf);
205  dec_par->channel_layout = chl;
206  return 0;
207 }
208 
210 {
211  MovieContext *movie = ctx->priv;
213  int64_t timestamp;
214  int nb_streams = 1, ret, i;
215  char default_streams[16], *stream_specs, *spec, *cursor;
216  AVStream *st;
217 
218  if (!movie->file_name) {
219  av_log(ctx, AV_LOG_ERROR, "No filename provided!\n");
220  return AVERROR(EINVAL);
221  }
222 
223  movie->seek_point = movie->seek_point_d * 1000000 + 0.5;
224 
225  stream_specs = movie->stream_specs;
226  if (!stream_specs) {
227  snprintf(default_streams, sizeof(default_streams), "d%c%d",
228  !strcmp(ctx->filter->name, "amovie") ? 'a' : 'v',
229  movie->stream_index);
230  stream_specs = default_streams;
231  }
232  for (cursor = stream_specs; *cursor; cursor++)
233  if (*cursor == '+')
234  nb_streams++;
235 
236  if (movie->loop_count != 1 && nb_streams != 1) {
237  av_log(ctx, AV_LOG_ERROR,
238  "Loop with several streams is currently unsupported\n");
239  return AVERROR_PATCHWELCOME;
240  }
241 
242  // Try to find the movie format (container)
243  iformat = movie->format_name ? av_find_input_format(movie->format_name) : NULL;
244 
245  movie->format_ctx = NULL;
246  if ((ret = avformat_open_input(&movie->format_ctx, movie->file_name, iformat, NULL)) < 0) {
247  av_log(ctx, AV_LOG_ERROR,
248  "Failed to avformat_open_input '%s'\n", movie->file_name);
249  return ret;
250  }
251  if ((ret = avformat_find_stream_info(movie->format_ctx, NULL)) < 0)
252  av_log(ctx, AV_LOG_WARNING, "Failed to find stream info\n");
253 
254  // if seeking requested, we execute it
255  if (movie->seek_point > 0) {
256  timestamp = movie->seek_point;
257  // add the stream start time, should it exist
258  if (movie->format_ctx->start_time != AV_NOPTS_VALUE) {
259  if (timestamp > 0 && movie->format_ctx->start_time > INT64_MAX - timestamp) {
260  av_log(ctx, AV_LOG_ERROR,
261  "%s: seek value overflow with start_time:%"PRId64" seek_point:%"PRId64"\n",
262  movie->file_name, movie->format_ctx->start_time, movie->seek_point);
263  return AVERROR(EINVAL);
264  }
265  timestamp += movie->format_ctx->start_time;
266  }
267  if ((ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD)) < 0) {
268  av_log(ctx, AV_LOG_ERROR, "%s: could not seek to position %"PRId64"\n",
269  movie->file_name, timestamp);
270  return ret;
271  }
272  }
273 
274  for (i = 0; i < movie->format_ctx->nb_streams; i++)
275  movie->format_ctx->streams[i]->discard = AVDISCARD_ALL;
276 
277  movie->st = av_calloc(nb_streams, sizeof(*movie->st));
278  if (!movie->st)
279  return AVERROR(ENOMEM);
280 
281  for (i = 0; i < nb_streams; i++) {
282  spec = av_strtok(stream_specs, "+", &cursor);
283  if (!spec)
284  return AVERROR_BUG;
285  stream_specs = NULL; /* for next strtok */
286  st = find_stream(ctx, movie->format_ctx, spec);
287  if (!st)
288  return AVERROR(EINVAL);
290  movie->st[i].st = st;
291  movie->max_stream_index = FFMAX(movie->max_stream_index, st->index);
292  movie->st[i].discontinuity_threshold =
294  }
295  if (av_strtok(NULL, "+", &cursor))
296  return AVERROR_BUG;
297 
298  movie->out_index = av_calloc(movie->max_stream_index + 1,
299  sizeof(*movie->out_index));
300  if (!movie->out_index)
301  return AVERROR(ENOMEM);
302  for (i = 0; i <= movie->max_stream_index; i++)
303  movie->out_index[i] = -1;
304  for (i = 0; i < nb_streams; i++) {
305  AVFilterPad pad = { 0 };
306  movie->out_index[movie->st[i].st->index] = i;
307  pad.type = movie->st[i].st->codecpar->codec_type;
308  pad.name = av_asprintf("out%d", i);
309  if (!pad.name)
310  return AVERROR(ENOMEM);
313  if ((ret = ff_insert_outpad(ctx, i, &pad)) < 0) {
314  av_freep(&pad.name);
315  return ret;
316  }
317  if ( movie->st[i].st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
318  !movie->st[i].st->codecpar->channel_layout) {
319  ret = guess_channel_layout(&movie->st[i], i, ctx);
320  if (ret < 0)
321  return ret;
322  }
323  ret = open_stream(ctx, &movie->st[i]);
324  if (ret < 0)
325  return ret;
326  }
327 
328  av_log(ctx, AV_LOG_VERBOSE, "seek_point:%"PRIi64" format_name:%s file_name:%s stream_index:%d\n",
329  movie->seek_point, movie->format_name, movie->file_name,
330  movie->stream_index);
331 
332  return 0;
333 }
334 
336 {
337  MovieContext *movie = ctx->priv;
338  int i;
339 
340  for (i = 0; i < ctx->nb_outputs; i++) {
341  av_freep(&ctx->output_pads[i].name);
342  if (movie->st[i].st)
343  avcodec_free_context(&movie->st[i].codec_ctx);
344  }
345  av_freep(&movie->st);
346  av_freep(&movie->out_index);
347  av_packet_unref(&movie->pkt);
348  if (movie->format_ctx)
350 }
351 
353 {
354  MovieContext *movie = ctx->priv;
355  int list[] = { 0, -1 };
356  int64_t list64[] = { 0, -1 };
357  int i, ret;
358 
359  for (i = 0; i < ctx->nb_outputs; i++) {
360  MovieStream *st = &movie->st[i];
361  AVCodecParameters *c = st->st->codecpar;
362  AVFilterLink *outlink = ctx->outputs[i];
363 
364  switch (c->codec_type) {
365  case AVMEDIA_TYPE_VIDEO:
366  list[0] = c->format;
367  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.formats)) < 0)
368  return ret;
369  break;
370  case AVMEDIA_TYPE_AUDIO:
371  list[0] = c->format;
372  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.formats)) < 0)
373  return ret;
374  list[0] = c->sample_rate;
375  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.samplerates)) < 0)
376  return ret;
377  list64[0] = c->channel_layout;
379  &outlink->incfg.channel_layouts)) < 0)
380  return ret;
381  break;
382  }
383  }
384 
385  return 0;
386 }
387 
389 {
390  AVFilterContext *ctx = outlink->src;
391  MovieContext *movie = ctx->priv;
392  unsigned out_id = FF_OUTLINK_IDX(outlink);
393  MovieStream *st = &movie->st[out_id];
394  AVCodecParameters *c = st->st->codecpar;
395 
396  outlink->time_base = st->st->time_base;
397 
398  switch (c->codec_type) {
399  case AVMEDIA_TYPE_VIDEO:
400  outlink->w = c->width;
401  outlink->h = c->height;
402  outlink->frame_rate = st->st->r_frame_rate;
403  break;
404  case AVMEDIA_TYPE_AUDIO:
405  break;
406  }
407 
408  return 0;
409 }
410 
411 static char *describe_frame_to_str(char *dst, size_t dst_size,
414 {
415  switch (frame_type) {
416  case AVMEDIA_TYPE_VIDEO:
417  snprintf(dst, dst_size,
418  "video pts:%s time:%s size:%dx%d aspect:%d/%d",
419  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &link->time_base),
420  frame->width, frame->height,
421  frame->sample_aspect_ratio.num,
422  frame->sample_aspect_ratio.den);
423  break;
424  case AVMEDIA_TYPE_AUDIO:
425  snprintf(dst, dst_size,
426  "audio pts:%s time:%s samples:%d",
427  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &link->time_base),
428  frame->nb_samples);
429  break;
430  default:
431  snprintf(dst, dst_size, "%s BUG", av_get_media_type_string(frame_type));
432  break;
433  }
434  return dst;
435 }
436 
438 {
439  MovieContext *movie = ctx->priv;
440  int64_t timestamp = movie->seek_point;
441  int ret, i;
442 
443  if (movie->format_ctx->start_time != AV_NOPTS_VALUE)
444  timestamp += movie->format_ctx->start_time;
445  ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD);
446  if (ret < 0) {
447  av_log(ctx, AV_LOG_ERROR, "Unable to loop: %s\n", av_err2str(ret));
448  movie->loop_count = 1; /* do not try again */
449  return ret;
450  }
451 
452  for (i = 0; i < ctx->nb_outputs; i++) {
454  movie->st[i].done = 0;
455  }
456  movie->eof = 0;
457  return 0;
458 }
459 
460 /**
461  * Try to push a frame to the requested output.
462  *
463  * @param ctx filter context
464  * @param out_id number of output where a frame is wanted;
465  * if the frame is read from file, used to set the return value;
466  * if the codec is being flushed, flush the corresponding stream
467  * @return 1 if a frame was pushed on the requested output,
468  * 0 if another attempt is possible,
469  * <0 AVERROR code
470  */
471 static int movie_push_frame(AVFilterContext *ctx, unsigned out_id)
472 {
473  MovieContext *movie = ctx->priv;
474  AVPacket *pkt = &movie->pkt;
475  enum AVMediaType frame_type;
476  MovieStream *st;
477  int ret, got_frame = 0, pkt_out_id;
478  AVFilterLink *outlink;
479  AVFrame *frame;
480 
481  if (!pkt->size) {
482  if (movie->eof) {
483  if (movie->st[out_id].done) {
484  if (movie->loop_count != 1) {
485  ret = rewind_file(ctx);
486  if (ret < 0)
487  return ret;
488  movie->loop_count -= movie->loop_count > 1;
489  av_log(ctx, AV_LOG_VERBOSE, "Stream finished, looping.\n");
490  return 0; /* retry */
491  }
492  return AVERROR_EOF;
493  }
494  pkt->stream_index = movie->st[out_id].st->index;
495  /* packet is already ready for flushing */
496  } else {
497  ret = av_read_frame(movie->format_ctx, pkt);
498  if (ret < 0) {
499  if (ret == AVERROR_EOF) {
500  movie->eof = 1;
501  return 0; /* start flushing */
502  }
503  return ret;
504  }
505  }
506  }
507 
508  pkt_out_id = pkt->stream_index > movie->max_stream_index ? -1 :
509  movie->out_index[pkt->stream_index];
510  if (pkt_out_id < 0) {
511  av_packet_unref(pkt);
512  return 0;
513  }
514  st = &movie->st[pkt_out_id];
515  outlink = ctx->outputs[pkt_out_id];
516 
517  frame = av_frame_alloc();
518  if (!frame)
519  return AVERROR(ENOMEM);
520 
521  frame_type = st->st->codecpar->codec_type;
522  switch (frame_type) {
523  case AVMEDIA_TYPE_VIDEO:
524  ret = avcodec_decode_video2(st->codec_ctx, frame, &got_frame, pkt);
525  break;
526  case AVMEDIA_TYPE_AUDIO:
527  ret = avcodec_decode_audio4(st->codec_ctx, frame, &got_frame, pkt);
528  break;
529  default:
530  ret = AVERROR(ENOSYS);
531  break;
532  }
533  if (ret < 0) {
534  av_log(ctx, AV_LOG_WARNING, "Decode error: %s\n", av_err2str(ret));
535  av_frame_free(&frame);
536  av_packet_unref(pkt);
537  return 0;
538  }
539  if (!ret || st->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
540  ret = pkt->size;
541 
542  pkt->data += ret;
543  pkt->size -= ret;
544  if (pkt->size <= 0)
545  av_packet_unref(pkt);
546  if (!got_frame) {
547  if (!ret)
548  st->done = 1;
549  av_frame_free(&frame);
550  return 0;
551  }
552 
553  frame->pts = frame->best_effort_timestamp;
554  if (frame->pts != AV_NOPTS_VALUE) {
555  if (movie->ts_offset)
556  frame->pts += av_rescale_q_rnd(movie->ts_offset, AV_TIME_BASE_Q, outlink->time_base, AV_ROUND_UP);
557  if (st->discontinuity_threshold) {
558  if (st->last_pts != AV_NOPTS_VALUE) {
559  int64_t diff = frame->pts - st->last_pts;
560  if (diff < 0 || diff > st->discontinuity_threshold) {
561  av_log(ctx, AV_LOG_VERBOSE, "Discontinuity in stream:%d diff:%"PRId64"\n", pkt_out_id, diff);
562  movie->ts_offset += av_rescale_q_rnd(-diff, outlink->time_base, AV_TIME_BASE_Q, AV_ROUND_UP);
563  frame->pts -= diff;
564  }
565  }
566  }
567  st->last_pts = frame->pts;
568  }
569  ff_dlog(ctx, "movie_push_frame(): file:'%s' %s\n", movie->file_name,
570  describe_frame_to_str((char[1024]){0}, 1024, frame, frame_type, outlink));
571 
572  if (st->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
573  if (frame->format != outlink->format) {
574  av_log(ctx, AV_LOG_ERROR, "Format changed %s -> %s, discarding frame\n",
575  av_get_pix_fmt_name(outlink->format),
577  );
578  av_frame_free(&frame);
579  return 0;
580  }
581  }
582  ret = ff_filter_frame(outlink, frame);
583 
584  if (ret < 0)
585  return ret;
586  return pkt_out_id == out_id;
587 }
588 
589 static int movie_request_frame(AVFilterLink *outlink)
590 {
591  AVFilterContext *ctx = outlink->src;
592  unsigned out_id = FF_OUTLINK_IDX(outlink);
593  int ret;
594 
595  while (1) {
596  ret = movie_push_frame(ctx, out_id);
597  if (ret)
598  return FFMIN(ret, 0);
599  }
600 }
601 
602 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
603  char *res, int res_len, int flags)
604 {
605  MovieContext *movie = ctx->priv;
606  int ret = AVERROR(ENOSYS);
607 
608  if (!strcmp(cmd, "seek")) {
609  int idx, flags, i;
610  int64_t ts;
611  char tail[2];
612 
613  if (sscanf(args, "%i|%"SCNi64"|%i %1s", &idx, &ts, &flags, tail) != 3)
614  return AVERROR(EINVAL);
615 
616  ret = av_seek_frame(movie->format_ctx, idx, ts, flags);
617  if (ret < 0)
618  return ret;
619 
620  for (i = 0; i < ctx->nb_outputs; i++) {
622  movie->st[i].done = 0;
623  }
624  return ret;
625  } else if (!strcmp(cmd, "get_duration")) {
626  int print_len;
627  char tail[2];
628 
629  if (!res || res_len <= 0)
630  return AVERROR(EINVAL);
631 
632  if (args && sscanf(args, "%1s", tail) == 1)
633  return AVERROR(EINVAL);
634 
635  print_len = snprintf(res, res_len, "%"PRId64, movie->format_ctx->duration);
636  if (print_len < 0 || print_len >= res_len)
637  return AVERROR(EINVAL);
638 
639  return 0;
640  }
641 
642  return ret;
643 }
644 
645 #if CONFIG_MOVIE_FILTER
646 
647 AVFILTER_DEFINE_CLASS(movie);
648 
650  .name = "movie",
651  .description = NULL_IF_CONFIG_SMALL("Read from a movie source."),
652  .priv_size = sizeof(MovieContext),
653  .priv_class = &movie_class,
655  .uninit = movie_uninit,
657 
658  .inputs = NULL,
659  .outputs = NULL,
662 };
663 
664 #endif /* CONFIG_MOVIE_FILTER */
665 
666 #if CONFIG_AMOVIE_FILTER
667 
668 #define amovie_options movie_options
669 AVFILTER_DEFINE_CLASS(amovie);
670 
672  .name = "amovie",
673  .description = NULL_IF_CONFIG_SMALL("Read audio from a movie source."),
674  .priv_size = sizeof(MovieContext),
676  .uninit = movie_uninit,
678 
679  .inputs = NULL,
680  .outputs = NULL,
681  .priv_class = &amovie_class,
684 };
685 
686 #endif /* CONFIG_AMOVIE_FILTER */
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2507
#define NULL
Definition: coverity.c:32
static AVStream * find_stream(void *log, AVFormatContext *avf, const char *spec)
Definition: src_movie.c:102
int64_t discontinuity_threshold
Definition: src_movie.c:55
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
AVOption.
Definition: opt.h:248
int64_t ts_offset
Definition: src_movie.c:70
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:335
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:56
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:877
int size
Definition: packet.h:364
static const AVOption movie_options[]
Definition: src_movie.c:84
attribute_deprecated int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, const AVPacket *avpkt)
Decode the audio frame of size avpkt->size from avpkt->data into frame.
Definition: decode.c:826
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:500
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:66
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:65
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:1351
double seek_point_d
Definition: src_movie.c:63
const char * name
Pad name.
Definition: internal.h:60
static int open_stream(AVFilterContext *ctx, MovieStream *st)
Definition: src_movie.c:156
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:350
Round toward +infinity.
Definition: mathematics.h:83
static int nb_streams
Definition: ffprobe.c:282
#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:5250
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:401
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1419
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:2157
uint8_t * data
Definition: packet.h:363
#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:4175
AVFilter ff_avsrc_amovie
int width
Definition: frame.h:366
#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:352
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
void * priv
private data for use by the filter
Definition: avfilter.h:354
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:443
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:186
#define FLAGS
Definition: src_movie.c:82
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:1407
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
#define FFMIN(a, b)
Definition: common.h:96
AVFilterChannelLayouts * channel_layouts
Lists of supported channel layouts, only for audio.
Definition: avfilter.h:453
int64_t discontinuity_threshold
Definition: src_movie.c:69
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:68
#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:388
char * format_name
Definition: src_movie.c:64
int dummy
Definition: motion.c:64
AVFilterFormats * samplerates
Lists of supported sample rates, only for audio.
Definition: avfilter.h:448
int max_stream_index
max stream # actually used for output
Definition: src_movie.c:76
static av_cold int movie_common_init(AVFilterContext *ctx)
Definition: src_movie.c:209
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:1785
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:876
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: utils.c:1065
#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:381
int * out_index
stream number -> output number map, or -1
Definition: src_movie.c:78
static AVInputFormat * iformat
Definition: ffprobe.c:259
Libavcodec external API header.
attribute_deprecated int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, const AVPacket *avpkt)
Decode the video frame of size avpkt->size from avpkt->data into picture.
Definition: decode.c:819
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:526
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:602
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:396
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:62
static int movie_push_frame(AVFilterContext *ctx, unsigned out_id)
Try to push a frame to the requested output.
Definition: src_movie.c:471
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:550
#define snprintf
Definition: snprintf.h:34
int64_t best_effort_timestamp
frame timestamp estimated using various heuristics, in stream time base
Definition: frame.h:572
AVFilter ff_avsrc_movie
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:351
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1711
attribute_deprecated int refcounted_frames
If non-zero, the decoded audio and video frames returned from avcodec_decode_video2() and avcodec_dec...
Definition: avcodec.h:1357
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:931
static char * describe_frame_to_str(char *dst, size_t dst_size, AVFrame *frame, enum AVMediaType frame_type, AVFilterLink *link)
Definition: src_movie.c:411
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:560
static int format_name(const char *buf, char **s, int index, const char *varname)
Definition: hlsenc.c:1850
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
Definition: avformat.h:1456
int stream_index
for compatibility
Definition: src_movie.c:67
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Seek to the keyframe at timestamp.
Definition: utils.c:2458
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:81
static int movie_request_frame(AVFilterLink *outlink)
Definition: src_movie.c:589
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:3546
int den
Denominator.
Definition: rational.h:60
AVPacket pkt
Definition: src_movie.c:74
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4422
static int movie_query_formats(AVFilterContext *ctx)
Definition: src_movie.c:352
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:437
AVCodecContext * codec_ctx
Definition: src_movie.c:53
AVFormatContext * format_ctx
Definition: src_movie.c:72
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:339
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:1466
int height
Definition: frame.h:366
#define av_freep(p)
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
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:905
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:931
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1000
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:374
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:342
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:77