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 support a PTS correction mechanism
27  */
28 
29 #include "config_components.h"
30 
31 #include <stdint.h>
32 
33 #include "libavutil/attributes.h"
34 #include "libavutil/avstring.h"
36 #include "libavutil/mem.h"
37 #include "libavutil/opt.h"
38 #include "libavutil/internal.h"
39 
40 #include "libavcodec/avcodec.h"
41 
42 #include "libavformat/avformat.h"
43 
44 #include "audio.h"
45 #include "avfilter.h"
46 #include "filters.h"
47 #include "formats.h"
48 #include "internal.h"
49 #include "video.h"
50 
51 typedef struct MovieStream {
56  int64_t last_pts;
58  int eof;
59 } MovieStream;
60 
61 typedef struct MovieContext {
62  /* common A/V fields */
63  const AVClass *class;
64  int64_t seek_point; ///< seekpoint in microseconds
65  double seek_point_d;
66  char *format_name;
67  char *file_name;
68  char *stream_specs; /**< user-provided list of streams, separated by + */
69  int stream_index; /**< for compatibility */
72  int64_t ts_offset;
74 
77 
78  int eof;
79  int max_stream_index; /**< max stream # actually used for output */
80  MovieStream *st; /**< array of all streams, one per output */
81  int *out_index; /**< stream number -> output number map, or -1 */
83 } MovieContext;
84 
85 #define OFFSET(x) offsetof(MovieContext, x)
86 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_VIDEO_PARAM
87 
88 static const AVOption movie_options[]= {
89  { "filename", NULL, OFFSET(file_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
90  { "format_name", "set format name", OFFSET(format_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
91  { "f", "set format name", OFFSET(format_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
92  { "stream_index", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
93  { "si", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
94  { "seek_point", "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0, (INT64_MAX-1) / 1000000, FLAGS },
95  { "sp", "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0, (INT64_MAX-1) / 1000000, FLAGS },
96  { "streams", "set streams", OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, FLAGS },
97  { "s", "set streams", OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, FLAGS },
98  { "loop", "set loop count", OFFSET(loop_count), AV_OPT_TYPE_INT, {.i64 = 1}, 0, INT_MAX, FLAGS },
99  { "discontinuity", "set discontinuity threshold", OFFSET(discontinuity_threshold), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, INT64_MAX, FLAGS },
100  { "dec_threads", "set the number of threads for decoding", OFFSET(dec_threads), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, FLAGS },
101  { "format_opts", "set format options for the opened file", OFFSET(format_opts), AV_OPT_TYPE_DICT, {.str = NULL}, 0, 0, FLAGS},
102  { NULL },
103 };
104 
105 static int movie_config_output_props(AVFilterLink *outlink);
106 
107 static AVStream *find_stream(void *log, AVFormatContext *avf, const char *spec)
108 {
109  int i, ret, already = 0, stream_id = -1;
110  char type_char[2], dummy;
111  AVStream *found = NULL;
112  enum AVMediaType type;
113 
114  ret = sscanf(spec, "d%1[av]%d%c", type_char, &stream_id, &dummy);
115  if (ret >= 1 && ret <= 2) {
116  type = type_char[0] == 'v' ? AVMEDIA_TYPE_VIDEO : AVMEDIA_TYPE_AUDIO;
117  ret = av_find_best_stream(avf, type, stream_id, -1, NULL, 0);
118  if (ret < 0) {
119  av_log(log, AV_LOG_ERROR, "No %s stream with index '%d' found\n",
120  av_get_media_type_string(type), stream_id);
121  return NULL;
122  }
123  return avf->streams[ret];
124  }
125  for (i = 0; i < avf->nb_streams; i++) {
126  ret = avformat_match_stream_specifier(avf, avf->streams[i], spec);
127  if (ret < 0) {
129  "Invalid stream specifier \"%s\"\n", spec);
130  return NULL;
131  }
132  if (!ret)
133  continue;
134  if (avf->streams[i]->discard != AVDISCARD_ALL) {
135  already++;
136  continue;
137  }
138  if (found) {
140  "Ambiguous stream specifier \"%s\", using #%d\n", spec, i);
141  break;
142  }
143  found = avf->streams[i];
144  }
145  if (!found) {
146  av_log(log, AV_LOG_WARNING, "Stream specifier \"%s\" %s\n", spec,
147  already ? "matched only already used streams" :
148  "did not match any stream");
149  return NULL;
150  }
151  if (found->codecpar->codec_type != AVMEDIA_TYPE_VIDEO &&
153  av_log(log, AV_LOG_ERROR, "Stream specifier \"%s\" matched a %s stream,"
154  "currently unsupported by libavfilter\n", spec,
156  return NULL;
157  }
158  return found;
159 }
160 
161 static int get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
162 {
163  int linesize_align[AV_NUM_DATA_POINTERS];
164  MovieStream *st = avctx->opaque;
165  AVFilterLink *outlink = st->link;
166  int w, h, ow, oh, copy = 0;
167  AVFrame *new;
168 
169  h = oh = frame->height;
170  w = ow = frame->width;
171 
172  copy = frame->format != outlink->format;
173  switch (avctx->codec_type) {
174  case AVMEDIA_TYPE_VIDEO:
175  if (w != outlink->w || h != outlink->h)
176  copy |= 1;
177  break;
178  case AVMEDIA_TYPE_AUDIO:
179  if (outlink->sample_rate != frame->sample_rate ||
180  av_channel_layout_compare(&outlink->ch_layout, &frame->ch_layout))
181  copy |= 1;
182  break;
183  }
184 
185  if (copy || !(avctx->codec->capabilities & AV_CODEC_CAP_DR1))
186  return avcodec_default_get_buffer2(avctx, frame, flags);
187 
188  switch (avctx->codec_type) {
189  case AVMEDIA_TYPE_VIDEO:
190  avcodec_align_dimensions2(avctx, &w, &h, linesize_align);
191  new = ff_default_get_video_buffer(outlink, w, h);
192  break;
193  case AVMEDIA_TYPE_AUDIO:
194  new = ff_default_get_audio_buffer(outlink, frame->nb_samples);
195  break;
196  default:
197  return -1;
198  }
199 
202  av_frame_move_ref(frame, new);
203  av_frame_free(&new);
204 
205  frame->width = ow;
206  frame->height = oh;
207 
208  return 0;
209 }
210 
211 static int open_stream(AVFilterContext *ctx, MovieStream *st, int dec_threads)
212 {
213  const AVCodec *codec;
214  int ret;
215 
216  codec = avcodec_find_decoder(st->st->codecpar->codec_id);
217  if (!codec) {
218  av_log(ctx, AV_LOG_ERROR, "Failed to find any codec\n");
219  return AVERROR(EINVAL);
220  }
221 
222  st->codec_ctx = avcodec_alloc_context3(codec);
223  if (!st->codec_ctx)
224  return AVERROR(ENOMEM);
225 
226  st->codec_ctx->opaque = st;
229  if (ret < 0)
230  return ret;
231 
232  if (!dec_threads)
233  dec_threads = ff_filter_get_nb_threads(ctx);
234  st->codec_ctx->thread_count = dec_threads;
235 
236  if ((ret = avcodec_open2(st->codec_ctx, codec, NULL)) < 0) {
237  av_log(ctx, AV_LOG_ERROR, "Failed to open codec\n");
238  return ret;
239  }
240 
241  return 0;
242 }
243 
244 static int guess_channel_layout(MovieStream *st, int st_index, void *log_ctx)
245 {
246  AVCodecParameters *dec_par = st->st->codecpar;
247  char buf[256];
248  AVChannelLayout chl = { 0 };
249 
251 
252  if (!KNOWN(&chl)) {
253  av_log(log_ctx, AV_LOG_WARNING,
254  "Channel layout is not set in stream %d, and could not "
255  "be guessed from the number of channels (%d)\n",
256  st_index, dec_par->ch_layout.nb_channels);
257  return av_channel_layout_copy(&dec_par->ch_layout, &chl);
258  }
259 
260  av_channel_layout_describe(&chl, buf, sizeof(buf));
261  av_log(log_ctx, AV_LOG_WARNING,
262  "Channel layout is not set in output stream %d, "
263  "guessed channel layout is '%s'\n",
264  st_index, buf);
265  return av_channel_layout_copy(&dec_par->ch_layout, &chl);
266 }
267 
269 {
270  MovieContext *movie = ctx->priv;
271  const AVInputFormat *iformat = NULL;
272  int64_t timestamp;
273  int nb_streams = 1, ret, i;
274  char default_streams[16], *stream_specs, *spec, *cursor;
275  AVStream *st;
276 
277  if (!movie->file_name) {
278  av_log(ctx, AV_LOG_ERROR, "No filename provided!\n");
279  return AVERROR(EINVAL);
280  }
281 
282  movie->seek_point = movie->seek_point_d * 1000000 + 0.5;
283 
284  stream_specs = movie->stream_specs;
285  if (!stream_specs) {
286  snprintf(default_streams, sizeof(default_streams), "d%c%d",
287  !strcmp(ctx->filter->name, "amovie") ? 'a' : 'v',
288  movie->stream_index);
289  stream_specs = default_streams;
290  }
291  for (cursor = stream_specs; *cursor; cursor++)
292  if (*cursor == '+')
293  nb_streams++;
294 
295  if (movie->loop_count != 1 && nb_streams != 1) {
297  "Loop with several streams is currently unsupported\n");
298  return AVERROR_PATCHWELCOME;
299  }
300 
301  // Try to find the movie format (container)
303 
304  movie->format_ctx = NULL;
305  if ((ret = avformat_open_input(&movie->format_ctx, movie->file_name, iformat, &movie->format_opts)) < 0) {
307  "Failed to avformat_open_input '%s'\n", movie->file_name);
308  return ret;
309  }
310  if ((ret = avformat_find_stream_info(movie->format_ctx, NULL)) < 0)
311  av_log(ctx, AV_LOG_WARNING, "Failed to find stream info\n");
312 
313  // if seeking requested, we execute it
314  if (movie->seek_point > 0) {
315  timestamp = movie->seek_point;
316  // add the stream start time, should it exist
317  if (movie->format_ctx->start_time != AV_NOPTS_VALUE) {
318  if (timestamp > 0 && movie->format_ctx->start_time > INT64_MAX - timestamp) {
320  "%s: seek value overflow with start_time:%"PRId64" seek_point:%"PRId64"\n",
321  movie->file_name, movie->format_ctx->start_time, movie->seek_point);
322  return AVERROR(EINVAL);
323  }
324  timestamp += movie->format_ctx->start_time;
325  }
326  if ((ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD)) < 0) {
327  av_log(ctx, AV_LOG_ERROR, "%s: could not seek to position %"PRId64"\n",
328  movie->file_name, timestamp);
329  return ret;
330  }
331  }
332 
333  for (i = 0; i < movie->format_ctx->nb_streams; i++)
335 
336  movie->pkt = av_packet_alloc();
337  if (!movie->pkt)
338  return AVERROR(ENOMEM);
339  movie->st = av_calloc(nb_streams, sizeof(*movie->st));
340  if (!movie->st)
341  return AVERROR(ENOMEM);
342 
343  for (i = 0; i < nb_streams; i++) {
344  spec = av_strtok(stream_specs, "+", &cursor);
345  if (!spec)
346  return AVERROR_BUG;
347  stream_specs = NULL; /* for next strtok */
348  st = find_stream(ctx, movie->format_ctx, spec);
349  if (!st)
350  return AVERROR(EINVAL);
352  movie->st[i].st = st;
353  movie->max_stream_index = FFMAX(movie->max_stream_index, st->index);
354  movie->st[i].discontinuity_threshold =
356 
357  movie->st[i].frame = av_frame_alloc();
358  if (!movie->st[i].frame)
359  return AVERROR(ENOMEM);
360  }
361  if (av_strtok(NULL, "+", &cursor))
362  return AVERROR_BUG;
363 
364  movie->out_index = av_calloc(movie->max_stream_index + 1,
365  sizeof(*movie->out_index));
366  if (!movie->out_index)
367  return AVERROR(ENOMEM);
368  for (i = 0; i <= movie->max_stream_index; i++)
369  movie->out_index[i] = -1;
370  for (i = 0; i < nb_streams; i++) {
371  AVFilterPad pad = { 0 };
372  movie->out_index[movie->st[i].st->index] = i;
373  pad.type = movie->st[i].st->codecpar->codec_type;
374  pad.name = av_asprintf("out%d", i);
375  if (!pad.name)
376  return AVERROR(ENOMEM);
378  if ((ret = ff_append_outpad_free_name(ctx, &pad)) < 0)
379  return ret;
380  if ( movie->st[i].st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
381  !KNOWN(&movie->st[i].st->codecpar->ch_layout)) {
382  ret = guess_channel_layout(&movie->st[i], i, ctx);
383  if (ret < 0)
384  return ret;
385  }
386  ret = open_stream(ctx, &movie->st[i], movie->dec_threads);
387  if (ret < 0)
388  return ret;
389  }
390 
391  av_log(ctx, AV_LOG_VERBOSE, "seek_point:%"PRIi64" format_name:%s file_name:%s stream_index:%d\n",
392  movie->seek_point, movie->format_name, movie->file_name,
393  movie->stream_index);
394 
395  return 0;
396 }
397 
399 {
400  MovieContext *movie = ctx->priv;
401  int i;
402 
403  for (i = 0; i < ctx->nb_outputs; i++) {
404  if (movie->st[i].st)
406  av_frame_free(&movie->st[i].frame);
407  }
408  av_packet_free(&movie->pkt);
409  av_freep(&movie->st);
410  av_freep(&movie->out_index);
411  if (movie->format_ctx)
413 }
414 
416 {
417  MovieContext *movie = ctx->priv;
418  int list[] = { 0, -1 };
419  AVChannelLayout list64[] = { { 0 }, { 0 } };
420  int i, ret;
421 
422  for (i = 0; i < ctx->nb_outputs; i++) {
423  MovieStream *st = &movie->st[i];
424  AVCodecParameters *c = st->st->codecpar;
425  AVFilterLink *outlink = ctx->outputs[i];
426 
427  switch (c->codec_type) {
428  case AVMEDIA_TYPE_VIDEO:
429  list[0] = c->format;
430  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.formats)) < 0)
431  return ret;
432  break;
433  case AVMEDIA_TYPE_AUDIO:
434  list[0] = c->format;
435  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.formats)) < 0)
436  return ret;
437  list[0] = c->sample_rate;
438  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.samplerates)) < 0)
439  return ret;
440  list64[0] = c->ch_layout;
442  &outlink->incfg.channel_layouts)) < 0)
443  return ret;
444  break;
445  }
446  }
447 
448  return 0;
449 }
450 
452 {
453  AVFilterContext *ctx = outlink->src;
454  MovieContext *movie = ctx->priv;
455  unsigned out_id = FF_OUTLINK_IDX(outlink);
456  MovieStream *st = &movie->st[out_id];
457  AVCodecParameters *c = st->st->codecpar;
458 
459  outlink->time_base = st->st->time_base;
460 
461  switch (c->codec_type) {
462  case AVMEDIA_TYPE_VIDEO:
463  outlink->w = c->width;
464  outlink->h = c->height;
465  outlink->frame_rate = st->st->r_frame_rate;
466  break;
467  case AVMEDIA_TYPE_AUDIO:
468  break;
469  }
470 
471  st->link = outlink;
472 
473  return 0;
474 }
475 
477 {
478  MovieContext *movie = ctx->priv;
479  int64_t timestamp = movie->seek_point;
480  int ret, i;
481 
482  if (movie->format_ctx->start_time != AV_NOPTS_VALUE)
483  timestamp += movie->format_ctx->start_time;
484  ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD);
485  if (ret < 0) {
486  av_log(ctx, AV_LOG_ERROR, "Unable to loop: %s\n", av_err2str(ret));
487  movie->loop_count = 1; /* do not try again */
488  return ret;
489  }
490 
491  for (i = 0; i < ctx->nb_outputs; i++) {
493  }
494  return 0;
495 }
496 
498 {
499  MovieContext *movie = ctx->priv;
500  AVCodecContext *dec = movie->st[i].codec_ctx;
501 
502  return avcodec_send_packet(dec, NULL);
503 }
504 
506 {
507  AVFilterLink *outlink = ctx->outputs[i];
508  MovieContext *movie = ctx->priv;
509  MovieStream *st = &movie->st[i];
510  AVCodecContext *dec = movie->st[i].codec_ctx;
511  AVFrame *frame = movie->st[i].frame;
512  AVPacket *pkt = movie->pkt;
513  int ret = 0;
514 
515  // submit the packet to the decoder
516  if (!movie->eof) {
517  ret = avcodec_send_packet(dec, pkt);
518  if (ret < 0)
519  return ret;
520  }
521 
522  // get all the available frames from the decoder
523  if (ret >= 0) {
525  if (ret < 0) {
526  // those two return values are special and mean there is no output
527  // frame available, but there were no errors during decoding
528  if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN))
529  return 0;
530  return ret;
531  }
532 
533  frame->pts = frame->best_effort_timestamp;
534  if (frame->pts != AV_NOPTS_VALUE) {
535  if (movie->ts_offset)
537  if (st->discontinuity_threshold) {
538  if (st->last_pts != AV_NOPTS_VALUE) {
539  int64_t diff = frame->pts - st->last_pts;
540  if (diff < 0 || diff > st->discontinuity_threshold) {
541  av_log(ctx, AV_LOG_VERBOSE, "Discontinuity in stream:%d diff:%"PRId64"\n", i, diff);
543  frame->pts -= diff;
544  }
545  }
546  }
547  st->last_pts = frame->pts;
548  }
550  if (ret < 0)
551  return ret;
552  if (ret == 0)
553  return 1;
554  }
555 
556  return 0;
557 }
558 
560 {
561  MovieContext *movie = ctx->priv;
562  int wanted = 0, ret;
563 
564  for (int i = 0; i < ctx->nb_outputs; i++) {
565  if (ff_outlink_frame_wanted(ctx->outputs[i]))
566  wanted++;
567  }
568 
569  if (wanted == 0)
570  return FFERROR_NOT_READY;
571 
572  if (!movie->eof) {
573  ret = av_read_frame(movie->format_ctx, movie->pkt);
574  if (ret < 0) {
575  movie->eof = 1;
576  for (int i = 0; i < ctx->nb_outputs; i++)
577  flush_decoder(ctx, i);
578  ff_filter_set_ready(ctx, 100);
579  return 0;
580  } else {
581  int pkt_out_id = movie->pkt->stream_index > movie->max_stream_index ? -1 :
582  movie->out_index[movie->pkt->stream_index];
583 
584  if (pkt_out_id >= 0) {
585  ret = decode_packet(ctx, pkt_out_id);
586  }
587  av_packet_unref(movie->pkt);
588  ff_filter_set_ready(ctx, 100);
589  return (ret <= 0) ? ret : 0;
590  }
591  } else {
592  int nb_eofs = 0;
593 
594  for (int i = 0; i < ctx->nb_outputs; i++) {
595  if (!movie->st[i].eof) {
596  ret = decode_packet(ctx, i);
597  if (ret <= 0)
598  movie->st[i].eof = 1;
599  }
600  nb_eofs += movie->st[i].eof == 1;
601  }
602  if (nb_eofs == ctx->nb_outputs && movie->loop_count != 1) {
603  ret = rewind_file(ctx);
604  if (ret < 0)
605  return ret;
606  movie->loop_count -= movie->loop_count > 1;
607  av_log(ctx, AV_LOG_VERBOSE, "Stream finished, looping.\n");
608  ff_filter_set_ready(ctx, 100);
609  for (int i = 0; i < ctx->nb_outputs; i++)
610  movie->st[i].eof = 0;
611  movie->eof = 0;
612  return 0;
613  } else {
614  for (int i = 0; i < ctx->nb_outputs; i++) {
615  if (movie->st[i].eof) {
616  ff_outlink_set_status(ctx->outputs[i], AVERROR_EOF, movie->st[i].last_pts);
617  nb_eofs++;
618  }
619  }
620  }
621 
622  if (nb_eofs < ctx->nb_outputs)
623  ff_filter_set_ready(ctx, 100);
624  return 0;
625  }
626 
627  return FFERROR_NOT_READY;
628 }
629 
630 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
631  char *res, int res_len, int flags)
632 {
633  MovieContext *movie = ctx->priv;
634  int ret = AVERROR(ENOSYS);
635 
636  if (!strcmp(cmd, "seek")) {
637  int idx, flags, i;
638  int64_t ts;
639  char tail[2];
640 
641  if (sscanf(args, "%i|%"SCNi64"|%i %1s", &idx, &ts, &flags, tail) != 3)
642  return AVERROR(EINVAL);
643 
644  ret = av_seek_frame(movie->format_ctx, idx, ts, flags);
645  if (ret < 0)
646  return ret;
647 
648  for (i = 0; i < ctx->nb_outputs; i++) {
650  }
651  return ret;
652  } else if (!strcmp(cmd, "get_duration")) {
653  int print_len;
654  char tail[2];
655 
656  if (!res || res_len <= 0)
657  return AVERROR(EINVAL);
658 
659  if (args && sscanf(args, "%1s", tail) == 1)
660  return AVERROR(EINVAL);
661 
662  print_len = snprintf(res, res_len, "%"PRId64, movie->format_ctx->duration);
663  if (print_len < 0 || print_len >= res_len)
664  return AVERROR(EINVAL);
665 
666  return 0;
667  }
668 
669  return ret;
670 }
671 
672 AVFILTER_DEFINE_CLASS_EXT(movie, "(a)movie", movie_options);
673 
674 #if CONFIG_MOVIE_FILTER
675 
676 const AVFilter ff_avsrc_movie = {
677  .name = "movie",
678  .description = NULL_IF_CONFIG_SMALL("Read from a movie source."),
679  .priv_size = sizeof(MovieContext),
680  .priv_class = &movie_class,
682  .activate = activate,
683  .uninit = movie_uninit,
685 
686  .inputs = NULL,
687  .outputs = NULL,
689  .process_command = process_command
690 };
691 
692 #endif /* CONFIG_MOVIE_FILTER */
693 
694 #if CONFIG_AMOVIE_FILTER
695 
696 const AVFilter ff_avsrc_amovie = {
697  .name = "amovie",
698  .description = NULL_IF_CONFIG_SMALL("Read audio from a movie source."),
699  .priv_class = &movie_class,
700  .priv_size = sizeof(MovieContext),
702  .activate = activate,
703  .uninit = movie_uninit,
705 
706  .inputs = NULL,
707  .outputs = NULL,
709  .process_command = process_command,
710 };
711 
712 #endif /* CONFIG_AMOVIE_FILTER */
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:427
AVCodec
AVCodec.
Definition: codec.h:187
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVFilterFormatsConfig::samplerates
AVFilterFormats * samplerates
Lists of supported sample rates, only for audio.
Definition: avfilter.h:515
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:436
AVFilterFormatsConfig::channel_layouts
AVFilterChannelLayouts * channel_layouts
Lists of supported channel layouts, only for audio.
Definition: avfilter.h:520
av_find_best_stream
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, const AVCodec **decoder_ret, int flags)
Definition: avformat.c:443
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1015
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:674
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:814
MovieContext::eof
int eof
Definition: src_movie.c:78
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
MovieContext::stream_index
int stream_index
for compatibility
Definition: src_movie.c:69
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
FLAGS
#define FLAGS
Definition: src_movie.c:86
normalize.log
log
Definition: normalize.py:21
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1323
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:206
w
uint8_t w
Definition: llviddspenc.c:38
AVOption
AVOption.
Definition: opt.h:357
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:159
format_opts
AVDictionary * format_opts
Definition: cmdutils.c:58
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Definition: opt.h:259
MovieStream::link
AVFilterLink * link
Definition: src_movie.c:52
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
movie_options
static const AVOption movie_options[]
Definition: src_movie.c:88
MovieStream::eof
int eof
Definition: src_movie.c:58
AVDictionary
Definition: dict.c:34
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1538
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
video.h
guess_channel_layout
static int guess_channel_layout(MovieStream *st, int st_index, void *log_ctx)
Definition: src_movie.c:244
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: packet.c:74
ff_avsrc_movie
const AVFilter ff_avsrc_movie
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: src_movie.c:630
formats.h
MovieContext::out_index
int * out_index
stream number -> output number map, or -1
Definition: src_movie.c:81
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:363
ff_default_get_video_buffer
AVFrame * ff_default_get_video_buffer(AVFilterLink *link, int w, int h)
Definition: video.c:107
MovieContext::file_name
char * file_name
Definition: src_movie.c:67
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:454
decode_packet
static int decode_packet(AVFilterContext *ctx, int i)
Definition: src_movie.c:505
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1583
MovieStream::frame
AVFrame * frame
Definition: src_movie.c:57
dummy
int dummy
Definition: motion.c:66
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:134
ff_avsrc_amovie
const AVFilter ff_avsrc_amovie
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:148
AVCodecContext::get_buffer2
int(* get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags)
This callback is called at the beginning of each frame to get data buffer(s) for it.
Definition: avcodec.h:1222
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:548
av_cold
#define av_cold
Definition: attributes.h:90
avformat_open_input
int avformat_open_input(AVFormatContext **ps, const char *url, const AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: demux.c:215
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:644
ff_outlink_set_status
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: filters.h:189
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:149
av_seek_frame
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Seek to the keyframe at timestamp.
Definition: seek.c:640
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:247
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:679
FF_OUTLINK_IDX
#define FF_OUTLINK_IDX(link)
Definition: internal.h:332
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:178
avcodec_receive_frame
int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder or encoder (when the AV_CODEC_FLAG_RECON_FRAME flag is used...
Definition: avcodec.c:698
MovieContext::ts_offset
int64_t ts_offset
Definition: src_movie.c:72
filters.h
ctx
AVFormatContext * ctx
Definition: movenc.c:49
get_buffer
static int get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Definition: src_movie.c:161
nb_streams
static int nb_streams
Definition: ffprobe.c:384
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:593
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
avcodec_align_dimensions2
void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, int linesize_align[AV_NUM_DATA_POINTERS])
Modify width and height values so that they will result in a memory buffer that is acceptable for the...
Definition: utils.c:144
MovieContext::format_ctx
AVFormatContext * format_ctx
Definition: src_movie.c:76
MovieContext
Definition: src_movie.c:61
find_stream
static AVStream * find_stream(void *log, AVFormatContext *avf, const char *spec)
Definition: src_movie.c:107
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const struct AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2445
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:782
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:709
MovieStream::discontinuity_threshold
int64_t discontinuity_threshold
Definition: src_movie.c:55
avcodec_free_context
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
Definition: options.c:164
MovieContext::discontinuity_threshold
int64_t discontinuity_threshold
Definition: src_movie.c:71
AVFILTER_DEFINE_CLASS_EXT
AVFILTER_DEFINE_CLASS_EXT(movie, "(a)movie", movie_options)
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:252
MovieStream::last_pts
int64_t last_pts
Definition: src_movie.c:56
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:25
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:142
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
MovieStream::codec_ctx
AVCodecContext * codec_ctx
Definition: src_movie.c:54
MovieContext::format_name
char * format_name
Definition: src_movie.c:66
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
MovieStream::st
AVStream * st
Definition: src_movie.c:53
MovieContext::seek_point_d
double seek_point_d
Definition: src_movie.c:65
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:964
AVFILTER_FLAG_DYNAMIC_OUTPUTS
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:112
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1311
AVFilterPad::config_props
int(* config_props)(AVFilterLink *link)
Link configuration callback.
Definition: internal.h:113
avformat_find_stream_info
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: demux.c:2516
movie_common_init
static av_cold int movie_common_init(AVFilterContext *ctx)
Definition: src_movie.c:268
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVMediaType
AVMediaType
Definition: avutil.h:199
movie_query_formats
static int movie_query_formats(AVFilterContext *ctx)
Definition: src_movie.c:415
movie_uninit
static av_cold void movie_uninit(AVFilterContext *ctx)
Definition: src_movie.c:398
avformat_match_stream_specifier
int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the stream st contained in s is matched by the stream specifier spec.
Definition: avformat.c:681
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:186
AVDISCARD_DEFAULT
@ AVDISCARD_DEFAULT
discard useless packets like 0 size packets in avi
Definition: defs.h:214
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:303
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:122
MovieContext::loop_count
int loop_count
Definition: src_movie.c:70
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:375
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:165
attributes.h
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:63
MovieContext::pkt
AVPacket * pkt
Definition: src_movie.c:75
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:800
MovieContext::format_opts
AVDictionary * format_opts
Definition: src_movie.c:82
internal.h
iformat
static const AVInputFormat * iformat
Definition: ffprobe.c:360
av_channel_layout_default
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
Get the default channel layout for a given number of channels.
Definition: channel_layout.c:830
avcodec_default_get_buffer2
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: get_buffer.c:254
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:696
uninit
static void uninit(AVBSFContext *ctx)
Definition: pcm_rechunk.c:68
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
rewind_file
static int rewind_file(AVFilterContext *ctx)
Definition: src_movie.c:476
internal.h
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:827
av_frame_move_ref
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:633
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:606
MovieContext::max_stream_index
int max_stream_index
max stream # actually used for output
Definition: src_movie.c:79
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
avcodec.h
AVFilter
Filter definition.
Definition: avfilter.h:166
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:44
avcodec_flush_buffers
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:364
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AVCodecContext::opaque
void * opaque
Private data of the user, can be used to carry app specific stuff.
Definition: avcodec.h:487
avformat.h
activate
static int activate(AVFilterContext *ctx)
Definition: src_movie.c:559
movie_config_output_props
static int movie_config_output_props(AVFilterLink *outlink)
Definition: src_movie.c:451
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:28
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:749
format_name
static int format_name(const char *buf, char **s, int index, const char *varname)
Definition: hlsenc.c:1942
channel_layout.h
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
avfilter.h
flush_decoder
static int flush_decoder(AVFilterContext *ctx, int i)
Definition: src_movie.c:497
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:909
KNOWN
#define KNOWN(l)
Definition: formats.h:111
av_find_input_format
const AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:144
MovieContext::stream_specs
char * stream_specs
user-provided list of streams, separated by +
Definition: src_movie.c:68
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1390
AVPacket::stream_index
int stream_index
Definition: packet.h:526
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:440
MovieContext::st
MovieStream * st
array of all streams, one per output
Definition: src_movie.c:80
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:453
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
audio.h
ff_default_get_audio_buffer
AVFrame * ff_default_get_audio_buffer(AVFilterLink *link, int nb_samples)
default handler for get_audio_buffer() for audio inputs
Definition: audio.c:45
AVFilterFormatsConfig::formats
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:510
MovieContext::dec_threads
int dec_threads
Definition: src_movie.c:73
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:501
ff_append_outpad_free_name
int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:143
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
ff_make_channel_layout_list
AVFilterChannelLayouts * ff_make_channel_layout_list(const AVChannelLayout *fmts)
Definition: formats.c:445
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
MovieContext::seek_point
int64_t seek_point
seekpoint in microseconds
Definition: src_movie.c:64
AVFormatContext::start_time
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1380
h
h
Definition: vp9dsp_template.c:2038
ff_outlink_frame_wanted
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function. If this function returns true
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:249
MovieStream
Definition: src_movie.c:51
snprintf
#define snprintf
Definition: snprintf.h:34
OFFSET
#define OFFSET(x)
Definition: src_movie.c:85
open_stream
static int open_stream(AVFilterContext *ctx, MovieStream *st, int dec_threads)
Definition: src_movie.c:211
av_rescale_q_rnd
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.
Definition: mathematics.c:134
ff_filter_set_ready
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.
Definition: avfilter.c:235