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}, CHAR_MAX, CHAR_MAX, FLAGS },
93  { "s", "set streams", OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str = 0}, CHAR_MAX, CHAR_MAX, 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  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  char name[16];
217  AVStream *st;
218 
219  if (!movie->file_name) {
220  av_log(ctx, AV_LOG_ERROR, "No filename provided!\n");
221  return AVERROR(EINVAL);
222  }
223 
224  movie->seek_point = movie->seek_point_d * 1000000 + 0.5;
225 
226  stream_specs = movie->stream_specs;
227  if (!stream_specs) {
228  snprintf(default_streams, sizeof(default_streams), "d%c%d",
229  !strcmp(ctx->filter->name, "amovie") ? 'a' : 'v',
230  movie->stream_index);
231  stream_specs = default_streams;
232  }
233  for (cursor = stream_specs; *cursor; cursor++)
234  if (*cursor == '+')
235  nb_streams++;
236 
237  if (movie->loop_count != 1 && nb_streams != 1) {
238  av_log(ctx, AV_LOG_ERROR,
239  "Loop with several streams is currently unsupported\n");
240  return AVERROR_PATCHWELCOME;
241  }
242 
243  // Try to find the movie format (container)
244  iformat = movie->format_name ? av_find_input_format(movie->format_name) : NULL;
245 
246  movie->format_ctx = NULL;
247  if ((ret = avformat_open_input(&movie->format_ctx, movie->file_name, iformat, NULL)) < 0) {
248  av_log(ctx, AV_LOG_ERROR,
249  "Failed to avformat_open_input '%s'\n", movie->file_name);
250  return ret;
251  }
252  if ((ret = avformat_find_stream_info(movie->format_ctx, NULL)) < 0)
253  av_log(ctx, AV_LOG_WARNING, "Failed to find stream info\n");
254 
255  // if seeking requested, we execute it
256  if (movie->seek_point > 0) {
257  timestamp = movie->seek_point;
258  // add the stream start time, should it exist
259  if (movie->format_ctx->start_time != AV_NOPTS_VALUE) {
260  if (timestamp > 0 && movie->format_ctx->start_time > INT64_MAX - timestamp) {
261  av_log(ctx, AV_LOG_ERROR,
262  "%s: seek value overflow with start_time:%"PRId64" seek_point:%"PRId64"\n",
263  movie->file_name, movie->format_ctx->start_time, movie->seek_point);
264  return AVERROR(EINVAL);
265  }
266  timestamp += movie->format_ctx->start_time;
267  }
268  if ((ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD)) < 0) {
269  av_log(ctx, AV_LOG_ERROR, "%s: could not seek to position %"PRId64"\n",
270  movie->file_name, timestamp);
271  return ret;
272  }
273  }
274 
275  for (i = 0; i < movie->format_ctx->nb_streams; i++)
276  movie->format_ctx->streams[i]->discard = AVDISCARD_ALL;
277 
278  movie->st = av_calloc(nb_streams, sizeof(*movie->st));
279  if (!movie->st)
280  return AVERROR(ENOMEM);
281 
282  for (i = 0; i < nb_streams; i++) {
283  spec = av_strtok(stream_specs, "+", &cursor);
284  if (!spec)
285  return AVERROR_BUG;
286  stream_specs = NULL; /* for next strtok */
287  st = find_stream(ctx, movie->format_ctx, spec);
288  if (!st)
289  return AVERROR(EINVAL);
291  movie->st[i].st = st;
292  movie->max_stream_index = FFMAX(movie->max_stream_index, st->index);
293  movie->st[i].discontinuity_threshold =
295  }
296  if (av_strtok(NULL, "+", &cursor))
297  return AVERROR_BUG;
298 
299  movie->out_index = av_calloc(movie->max_stream_index + 1,
300  sizeof(*movie->out_index));
301  if (!movie->out_index)
302  return AVERROR(ENOMEM);
303  for (i = 0; i <= movie->max_stream_index; i++)
304  movie->out_index[i] = -1;
305  for (i = 0; i < nb_streams; i++) {
306  AVFilterPad pad = { 0 };
307  movie->out_index[movie->st[i].st->index] = i;
308  snprintf(name, sizeof(name), "out%d", i);
309  pad.type = movie->st[i].st->codecpar->codec_type;
310  pad.name = av_strdup(name);
311  if (!pad.name)
312  return AVERROR(ENOMEM);
315  if ((ret = ff_insert_outpad(ctx, i, &pad)) < 0) {
316  av_freep(&pad.name);
317  return ret;
318  }
319  if ( movie->st[i].st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
320  !movie->st[i].st->codecpar->channel_layout) {
321  ret = guess_channel_layout(&movie->st[i], i, ctx);
322  if (ret < 0)
323  return ret;
324  }
325  ret = open_stream(ctx, &movie->st[i]);
326  if (ret < 0)
327  return ret;
328  }
329 
330  av_log(ctx, AV_LOG_VERBOSE, "seek_point:%"PRIi64" format_name:%s file_name:%s stream_index:%d\n",
331  movie->seek_point, movie->format_name, movie->file_name,
332  movie->stream_index);
333 
334  return 0;
335 }
336 
338 {
339  MovieContext *movie = ctx->priv;
340  int i;
341 
342  for (i = 0; i < ctx->nb_outputs; i++) {
343  av_freep(&ctx->output_pads[i].name);
344  if (movie->st[i].st)
345  avcodec_free_context(&movie->st[i].codec_ctx);
346  }
347  av_freep(&movie->st);
348  av_freep(&movie->out_index);
349  if (movie->format_ctx)
351 }
352 
354 {
355  MovieContext *movie = ctx->priv;
356  int list[] = { 0, -1 };
357  int64_t list64[] = { 0, -1 };
358  int i, ret;
359 
360  for (i = 0; i < ctx->nb_outputs; i++) {
361  MovieStream *st = &movie->st[i];
362  AVCodecParameters *c = st->st->codecpar;
363  AVFilterLink *outlink = ctx->outputs[i];
364 
365  switch (c->codec_type) {
366  case AVMEDIA_TYPE_VIDEO:
367  list[0] = c->format;
368  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->in_formats)) < 0)
369  return ret;
370  break;
371  case AVMEDIA_TYPE_AUDIO:
372  list[0] = c->format;
373  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->in_formats)) < 0)
374  return ret;
375  list[0] = c->sample_rate;
376  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->in_samplerates)) < 0)
377  return ret;
378  list64[0] = c->channel_layout;
380  &outlink->in_channel_layouts)) < 0)
381  return ret;
382  break;
383  }
384  }
385 
386  return 0;
387 }
388 
390 {
391  AVFilterContext *ctx = outlink->src;
392  MovieContext *movie = ctx->priv;
393  unsigned out_id = FF_OUTLINK_IDX(outlink);
394  MovieStream *st = &movie->st[out_id];
395  AVCodecParameters *c = st->st->codecpar;
396 
397  outlink->time_base = st->st->time_base;
398 
399  switch (c->codec_type) {
400  case AVMEDIA_TYPE_VIDEO:
401  outlink->w = c->width;
402  outlink->h = c->height;
403  outlink->frame_rate = st->st->r_frame_rate;
404  break;
405  case AVMEDIA_TYPE_AUDIO:
406  break;
407  }
408 
409  return 0;
410 }
411 
412 static char *describe_frame_to_str(char *dst, size_t dst_size,
413  AVFrame *frame, enum AVMediaType frame_type,
415 {
416  switch (frame_type) {
417  case AVMEDIA_TYPE_VIDEO:
418  snprintf(dst, dst_size,
419  "video pts:%s time:%s size:%dx%d aspect:%d/%d",
420  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &link->time_base),
421  frame->width, frame->height,
422  frame->sample_aspect_ratio.num,
423  frame->sample_aspect_ratio.den);
424  break;
425  case AVMEDIA_TYPE_AUDIO:
426  snprintf(dst, dst_size,
427  "audio pts:%s time:%s samples:%d",
428  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &link->time_base),
429  frame->nb_samples);
430  break;
431  default:
432  snprintf(dst, dst_size, "%s BUG", av_get_media_type_string(frame_type));
433  break;
434  }
435  return dst;
436 }
437 
439 {
440  MovieContext *movie = ctx->priv;
441  int64_t timestamp = movie->seek_point;
442  int ret, i;
443 
444  if (movie->format_ctx->start_time != AV_NOPTS_VALUE)
445  timestamp += movie->format_ctx->start_time;
446  ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD);
447  if (ret < 0) {
448  av_log(ctx, AV_LOG_ERROR, "Unable to loop: %s\n", av_err2str(ret));
449  movie->loop_count = 1; /* do not try again */
450  return ret;
451  }
452 
453  for (i = 0; i < ctx->nb_outputs; i++) {
455  movie->st[i].done = 0;
456  }
457  movie->eof = 0;
458  return 0;
459 }
460 
461 /**
462  * Try to push a frame to the requested output.
463  *
464  * @param ctx filter context
465  * @param out_id number of output where a frame is wanted;
466  * if the frame is read from file, used to set the return value;
467  * if the codec is being flushed, flush the corresponding stream
468  * @return 1 if a frame was pushed on the requested output,
469  * 0 if another attempt is possible,
470  * <0 AVERROR code
471  */
472 static int movie_push_frame(AVFilterContext *ctx, unsigned out_id)
473 {
474  MovieContext *movie = ctx->priv;
475  AVPacket *pkt = &movie->pkt;
476  enum AVMediaType frame_type;
477  MovieStream *st;
478  int ret, got_frame = 0, pkt_out_id;
479  AVFilterLink *outlink;
480  AVFrame *frame;
481 
482  if (!pkt->size) {
483  if (movie->eof) {
484  if (movie->st[out_id].done) {
485  if (movie->loop_count != 1) {
486  ret = rewind_file(ctx);
487  if (ret < 0)
488  return ret;
489  movie->loop_count -= movie->loop_count > 1;
490  av_log(ctx, AV_LOG_VERBOSE, "Stream finished, looping.\n");
491  return 0; /* retry */
492  }
493  return AVERROR_EOF;
494  }
495  pkt->stream_index = movie->st[out_id].st->index;
496  /* packet is already ready for flushing */
497  } else {
498  ret = av_read_frame(movie->format_ctx, &movie->pkt0);
499  if (ret < 0) {
500  av_init_packet(&movie->pkt0); /* ready for flushing */
501  *pkt = movie->pkt0;
502  if (ret == AVERROR_EOF) {
503  movie->eof = 1;
504  return 0; /* start flushing */
505  }
506  return ret;
507  }
508  *pkt = movie->pkt0;
509  }
510  }
511 
512  pkt_out_id = pkt->stream_index > movie->max_stream_index ? -1 :
513  movie->out_index[pkt->stream_index];
514  if (pkt_out_id < 0) {
515  av_packet_unref(&movie->pkt0);
516  pkt->size = 0; /* ready for next run */
517  pkt->data = NULL;
518  return 0;
519  }
520  st = &movie->st[pkt_out_id];
521  outlink = ctx->outputs[pkt_out_id];
522 
523  frame = av_frame_alloc();
524  if (!frame)
525  return AVERROR(ENOMEM);
526 
527  frame_type = st->st->codecpar->codec_type;
528  switch (frame_type) {
529  case AVMEDIA_TYPE_VIDEO:
530  ret = avcodec_decode_video2(st->codec_ctx, frame, &got_frame, pkt);
531  break;
532  case AVMEDIA_TYPE_AUDIO:
533  ret = avcodec_decode_audio4(st->codec_ctx, frame, &got_frame, pkt);
534  break;
535  default:
536  ret = AVERROR(ENOSYS);
537  break;
538  }
539  if (ret < 0) {
540  av_log(ctx, AV_LOG_WARNING, "Decode error: %s\n", av_err2str(ret));
541  av_frame_free(&frame);
542  av_packet_unref(&movie->pkt0);
543  movie->pkt.size = 0;
544  movie->pkt.data = NULL;
545  return 0;
546  }
547  if (!ret || st->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
548  ret = pkt->size;
549 
550  pkt->data += ret;
551  pkt->size -= ret;
552  if (pkt->size <= 0) {
553  av_packet_unref(&movie->pkt0);
554  pkt->size = 0; /* ready for next run */
555  pkt->data = NULL;
556  }
557  if (!got_frame) {
558  if (!ret)
559  st->done = 1;
560  av_frame_free(&frame);
561  return 0;
562  }
563 
564  frame->pts = frame->best_effort_timestamp;
565  if (frame->pts != AV_NOPTS_VALUE) {
566  if (movie->ts_offset)
567  frame->pts += av_rescale_q_rnd(movie->ts_offset, AV_TIME_BASE_Q, outlink->time_base, AV_ROUND_UP);
568  if (st->discontinuity_threshold) {
569  if (st->last_pts != AV_NOPTS_VALUE) {
570  int64_t diff = frame->pts - st->last_pts;
571  if (diff < 0 || diff > st->discontinuity_threshold) {
572  av_log(ctx, AV_LOG_VERBOSE, "Discontinuity in stream:%d diff:%"PRId64"\n", pkt_out_id, diff);
573  movie->ts_offset += av_rescale_q_rnd(-diff, outlink->time_base, AV_TIME_BASE_Q, AV_ROUND_UP);
574  frame->pts -= diff;
575  }
576  }
577  }
578  st->last_pts = frame->pts;
579  }
580  ff_dlog(ctx, "movie_push_frame(): file:'%s' %s\n", movie->file_name,
581  describe_frame_to_str((char[1024]){0}, 1024, frame, frame_type, outlink));
582 
583  if (st->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
584  if (frame->format != outlink->format) {
585  av_log(ctx, AV_LOG_ERROR, "Format changed %s -> %s, discarding frame\n",
586  av_get_pix_fmt_name(outlink->format),
588  );
589  av_frame_free(&frame);
590  return 0;
591  }
592  }
593  ret = ff_filter_frame(outlink, frame);
594 
595  if (ret < 0)
596  return ret;
597  return pkt_out_id == out_id;
598 }
599 
600 static int movie_request_frame(AVFilterLink *outlink)
601 {
602  AVFilterContext *ctx = outlink->src;
603  unsigned out_id = FF_OUTLINK_IDX(outlink);
604  int ret;
605 
606  while (1) {
607  ret = movie_push_frame(ctx, out_id);
608  if (ret)
609  return FFMIN(ret, 0);
610  }
611 }
612 
613 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
614  char *res, int res_len, int flags)
615 {
616  MovieContext *movie = ctx->priv;
617  int ret = AVERROR(ENOSYS);
618 
619  if (!strcmp(cmd, "seek")) {
620  int idx, flags, i;
621  int64_t ts;
622  char tail[2];
623 
624  if (sscanf(args, "%i|%"SCNi64"|%i %1s", &idx, &ts, &flags, tail) != 3)
625  return AVERROR(EINVAL);
626 
627  ret = av_seek_frame(movie->format_ctx, idx, ts, flags);
628  if (ret < 0)
629  return ret;
630 
631  for (i = 0; i < ctx->nb_outputs; i++) {
633  movie->st[i].done = 0;
634  }
635  return ret;
636  } else if (!strcmp(cmd, "get_duration")) {
637  int print_len;
638  char tail[2];
639 
640  if (!res || res_len <= 0)
641  return AVERROR(EINVAL);
642 
643  if (args && sscanf(args, "%1s", tail) == 1)
644  return AVERROR(EINVAL);
645 
646  print_len = snprintf(res, res_len, "%"PRId64, movie->format_ctx->duration);
647  if (print_len < 0 || print_len >= res_len)
648  return AVERROR(EINVAL);
649 
650  return 0;
651  }
652 
653  return ret;
654 }
655 
656 #if CONFIG_MOVIE_FILTER
657 
658 AVFILTER_DEFINE_CLASS(movie);
659 
661  .name = "movie",
662  .description = NULL_IF_CONFIG_SMALL("Read from a movie source."),
663  .priv_size = sizeof(MovieContext),
664  .priv_class = &movie_class,
666  .uninit = movie_uninit,
668 
669  .inputs = NULL,
670  .outputs = NULL,
673 };
674 
675 #endif /* CONFIG_MOVIE_FILTER */
676 
677 #if CONFIG_AMOVIE_FILTER
678 
679 #define amovie_options movie_options
680 AVFILTER_DEFINE_CLASS(amovie);
681 
683  .name = "amovie",
684  .description = NULL_IF_CONFIG_SMALL("Read audio from a movie source."),
685  .priv_size = sizeof(MovieContext),
687  .uninit = movie_uninit,
689 
690  .inputs = NULL,
691  .outputs = NULL,
692  .priv_class = &amovie_class,
695 };
696 
697 #endif /* CONFIG_AMOVIE_FILTER */
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2518
#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:295
AVOption.
Definition: opt.h:246
int64_t ts_offset
Definition: src_movie.c:70
static av_cold void movie_uninit(AVFilterContext *ctx)
Definition: src_movie.c:337
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
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: avcodec.h:3968
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:882
int size
Definition: avcodec.h:1481
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:904
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:539
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:65
#define FF_OUTLINK_IDX(link)
Definition: internal.h:349
discard all
Definition: avcodec.h:814
static AVPacket pkt
char * stream_specs
user-provided list of streams, separated by +
Definition: src_movie.c:66
AVCodec.
Definition: avcodec.h:3492
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3960
char * file_name
Definition: src_movie.c:65
Macro definitions for various function/variable attributes.
AVPacket pkt0
Definition: src_movie.c:74
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
Format I/O context.
Definition: avformat.h:1358
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:434
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1093
AVFilterPad * output_pads
array of output pads
Definition: avfilter.h:349
Round toward +infinity.
Definition: mathematics.h:83
static int nb_streams
Definition: ffprobe.c:280
#define av_cold
Definition: attributes.h:82
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
int width
Video only.
Definition: avcodec.h:4034
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:5310
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
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:2115
uint8_t * data
Definition: avcodec.h:1480
#define ff_dlog(a,...)
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:111
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4070
#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:4226
AVFilter ff_avsrc_amovie
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int width
Definition: frame.h:353
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#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:351
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3964
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
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
int(* config_props)(AVFilterLink *link)
Link configuration callback.
Definition: internal.h:129
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:802
#define FFMIN(a, b)
Definition: common.h:96
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:156
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:439
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:389
char * format_name
Definition: src_movie.c:64
int dummy
Definition: motion.c:64
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:2827
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:881
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal decoder state / flush internal buffers.
Definition: decode.c:2031
#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:368
int * out_index
stream number -> output number map, or -1
Definition: src_movie.c:78
static AVInputFormat * iformat
Definition: ffprobe.c:257
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
Libavcodec external API header.
AVFilterChannelLayouts * avfilter_make_format64_list(const int64_t *fmts)
Definition: formats.c:303
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:897
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:171
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
main external API structure.
Definition: avcodec.h:1568
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:896
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: src_movie.c:613
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:383
void * buf
Definition: avisynth_c.h:766
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:144
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:472
AVMediaType
Definition: avutil.h:199
discard useless packets like 0 size packets in avi
Definition: avcodec.h:809
const char * name
Filter name.
Definition: avfilter.h:148
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:548
#define snprintf
Definition: snprintf.h:34
int64_t best_effort_timestamp
frame timestamp estimated using various heuristics, in stream time base
Definition: frame.h:559
AVFilter ff_avsrc_movie
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1777
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:2399
static char * describe_frame_to_str(char *dst, size_t dst_size, AVFrame *frame, enum AVMediaType frame_type, AVFilterLink *link)
Definition: src_movie.c:412
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:1803
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
Definition: avformat.h:1463
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:2522
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:184
int sample_rate
Audio only.
Definition: avcodec.h:4078
#define OFFSET(x)
Definition: src_movie.c:81
static int movie_request_frame(AVFilterLink *outlink)
Definition: src_movie.c:600
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:3600
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
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:4474
static int movie_query_formats(AVFilterContext *ctx)
Definition: src_movie.c:353
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:334
static int rewind_file(AVFilterContext *ctx)
Definition: src_movie.c:438
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:113
int channels
Audio only.
Definition: avcodec.h:4074
An instance of a filter.
Definition: avfilter.h:338
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:1473
int height
Definition: frame.h:353
#define av_freep(p)
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
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:2438
int stream_index
Definition: avcodec.h:1482
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:910
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:936
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1005
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
Definition: internal.h:285
This structure stores compressed data.
Definition: avcodec.h:1457
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:341
for(j=16;j >0;--j)
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
const char * name
Definition: opengl_enc.c:102
MovieStream * st
array of all streams, one per output
Definition: src_movie.c:77