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"
35 #include "libavutil/channel_layout.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 "video.h"
49 
50 typedef struct MovieStream {
51  AVFilterLink *link;
52  AVStream *st;
53  AVCodecContext *codec_ctx;
54  int64_t discontinuity_threshold;
55  int64_t last_pts;
56  AVFrame *frame;
57  int eof;
58 } MovieStream;
59 
60 typedef struct MovieContext {
61  /* common A/V fields */
62  const AVClass *class;
63  int64_t seek_point; ///< seekpoint in microseconds
64  double seek_point_d;
65  char *format_name;
66  char *file_name;
67  char *stream_specs; /**< user-provided list of streams, separated by + */
68  int stream_index; /**< for compatibility */
69  int loop_count;
70  int64_t discontinuity_threshold;
71  int64_t ts_offset;
72  int dec_threads;
73 
74  AVPacket *pkt;
75  AVFormatContext *format_ctx;
76 
77  int eof;
78  int max_stream_index; /**< max stream # actually used for output */
79  MovieStream *st; /**< array of all streams, one per output */
80  int *out_index; /**< stream number -> output number map, or -1 */
81  AVDictionary *format_opts;
82 } MovieContext;
83 
84 #define OFFSET(x) offsetof(MovieContext, x)
85 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_VIDEO_PARAM
86 
87 static const AVOption movie_options[]= {
88  { "filename", NULL, OFFSET(file_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
89  { "format_name", "set format name", OFFSET(format_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
90  { "f", "set format name", OFFSET(format_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
91  { "stream_index", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
92  { "si", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
93  { "seek_point", "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0, (INT64_MAX-1) / 1000000, FLAGS },
94  { "sp", "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0, (INT64_MAX-1) / 1000000, FLAGS },
95  { "streams", "set streams", OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, FLAGS },
96  { "s", "set streams", OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, FLAGS },
97  { "loop", "set loop count", OFFSET(loop_count), AV_OPT_TYPE_INT, {.i64 = 1}, 0, INT_MAX, FLAGS },
98  { "discontinuity", "set discontinuity threshold", OFFSET(discontinuity_threshold), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, INT64_MAX, FLAGS },
99  { "dec_threads", "set the number of threads for decoding", OFFSET(dec_threads), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, FLAGS },
100  { "format_opts", "set format options for the opened file", OFFSET(format_opts), AV_OPT_TYPE_DICT, {.str = NULL}, 0, 0, FLAGS},
101  { NULL },
102 };
103 
104 static int movie_config_output_props(AVFilterLink *outlink);
105 
106 static AVStream *find_stream(void *log, AVFormatContext *avf, const char *spec)
107 {
108  int i, ret, already = 0, stream_id = -1;
109  char type_char[2], dummy;
110  AVStream *found = NULL;
111  enum AVMediaType type;
112 
113  ret = sscanf(spec, "d%1[av]%d%c", type_char, &stream_id, &dummy);
114  if (ret >= 1 && ret <= 2) {
115  type = type_char[0] == 'v' ? AVMEDIA_TYPE_VIDEO : AVMEDIA_TYPE_AUDIO;
116  ret = av_find_best_stream(avf, type, stream_id, -1, NULL, 0);
117  if (ret < 0) {
118  av_log(log, AV_LOG_ERROR, "No %s stream with index '%d' found\n",
119  av_get_media_type_string(type), stream_id);
120  return NULL;
121  }
122  return avf->streams[ret];
123  }
124  for (i = 0; i < avf->nb_streams; i++) {
125  ret = avformat_match_stream_specifier(avf, avf->streams[i], spec);
126  if (ret < 0) {
127  av_log(log, AV_LOG_ERROR,
128  "Invalid stream specifier \"%s\"\n", spec);
129  return NULL;
130  }
131  if (!ret)
132  continue;
133  if (avf->streams[i]->discard != AVDISCARD_ALL) {
134  already++;
135  continue;
136  }
137  if (found) {
138  av_log(log, AV_LOG_WARNING,
139  "Ambiguous stream specifier \"%s\", using #%d\n", spec, i);
140  break;
141  }
142  found = avf->streams[i];
143  }
144  if (!found) {
145  av_log(log, AV_LOG_WARNING, "Stream specifier \"%s\" %s\n", spec,
146  already ? "matched only already used streams" :
147  "did not match any stream");
148  return NULL;
149  }
150  if (found->codecpar->codec_type != AVMEDIA_TYPE_VIDEO &&
151  found->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
152  av_log(log, AV_LOG_ERROR, "Stream specifier \"%s\" matched a %s stream,"
153  "currently unsupported by libavfilter\n", spec,
154  av_get_media_type_string(found->codecpar->codec_type));
155  return NULL;
156  }
157  return found;
158 }
159 
160 static int get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
161 {
162  int linesize_align[AV_NUM_DATA_POINTERS];
163  MovieStream *st = avctx->opaque;
164  AVFilterLink *outlink = st->link;
165  int w, h, ow, oh, copy = 0;
166  AVFrame *new;
167 
168  h = oh = frame->height;
169  w = ow = frame->width;
170 
171  copy = frame->format != outlink->format;
172  switch (avctx->codec_type) {
173  case AVMEDIA_TYPE_VIDEO:
174  if (w != outlink->w || h != outlink->h)
175  copy |= 1;
176  break;
177  case AVMEDIA_TYPE_AUDIO:
178  if (outlink->sample_rate != frame->sample_rate ||
179  av_channel_layout_compare(&outlink->ch_layout, &frame->ch_layout))
180  copy |= 1;
181  break;
182  }
183 
184  if (copy || !(avctx->codec->capabilities & AV_CODEC_CAP_DR1))
185  return avcodec_default_get_buffer2(avctx, frame, flags);
186 
187  switch (avctx->codec_type) {
188  case AVMEDIA_TYPE_VIDEO:
189  avcodec_align_dimensions2(avctx, &w, &h, linesize_align);
190  new = ff_default_get_video_buffer(outlink, w, h);
191  break;
192  case AVMEDIA_TYPE_AUDIO:
193  new = ff_default_get_audio_buffer(outlink, frame->nb_samples);
194  break;
195  default:
196  return -1;
197  }
198 
199  av_frame_copy_props(new, frame);
200  av_frame_unref(frame);
201  av_frame_move_ref(frame, new);
202  av_frame_free(&new);
203 
204  frame->width = ow;
205  frame->height = oh;
206 
207  return 0;
208 }
209 
210 static int open_stream(AVFilterContext *ctx, MovieStream *st, int dec_threads)
211 {
212  const AVCodec *codec;
213  int ret;
214 
215  codec = avcodec_find_decoder(st->st->codecpar->codec_id);
216  if (!codec) {
217  av_log(ctx, AV_LOG_ERROR, "Failed to find any codec\n");
218  return AVERROR(EINVAL);
219  }
220 
221  st->codec_ctx = avcodec_alloc_context3(codec);
222  if (!st->codec_ctx)
223  return AVERROR(ENOMEM);
224 
225  st->codec_ctx->opaque = st;
226  st->codec_ctx->get_buffer2 = get_buffer;
227  ret = avcodec_parameters_to_context(st->codec_ctx, st->st->codecpar);
228  if (ret < 0)
229  return ret;
230  st->codec_ctx->pkt_timebase = st->st->time_base;
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 
250  av_channel_layout_default(&chl, dec_par->ch_layout.nb_channels);
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 
268 static av_cold int movie_common_init(AVFilterContext *ctx)
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) {
296  av_log(ctx, AV_LOG_ERROR,
297  "Loop with several streams is currently unsupported\n");
298  return AVERROR_PATCHWELCOME;
299  }
300 
301  // Try to find the movie format (container)
302  iformat = movie->format_name ? av_find_input_format(movie->format_name) : NULL;
303 
304  movie->format_ctx = NULL;
305  if ((ret = avformat_open_input(&movie->format_ctx, movie->file_name, iformat, &movie->format_opts)) < 0) {
306  av_log(ctx, AV_LOG_ERROR,
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) {
319  av_log(ctx, AV_LOG_ERROR,
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++)
334  movie->format_ctx->streams[i]->discard = AVDISCARD_ALL;
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);
351  st->discard = AVDISCARD_DEFAULT;
352  movie->st[i].st = st;
353  movie->max_stream_index = FFMAX(movie->max_stream_index, st->index);
354  movie->st[i].discontinuity_threshold =
355  av_rescale_q(movie->discontinuity_threshold, AV_TIME_BASE_Q, st->time_base);
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);
377  pad.config_props = movie_config_output_props;
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 
398 static av_cold void movie_uninit(AVFilterContext *ctx)
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)
405  avcodec_free_context(&movie->st[i].codec_ctx);
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)
412  avformat_close_input(&movie->format_ctx);
413 }
414 
415 static int movie_query_formats(const AVFilterContext *ctx,
416  AVFilterFormatsConfig **cfg_in,
417  AVFilterFormatsConfig **cfg_out)
418 {
419  const MovieContext *movie = ctx->priv;
420  int list[] = { 0, -1 };
421  AVChannelLayout list64[] = { { 0 }, { 0 } };
422  int i, ret;
423 
424  for (i = 0; i < ctx->nb_outputs; i++) {
425  const MovieStream *st = &movie->st[i];
426  const AVCodecParameters *c = st->st->codecpar;
427  AVFilterFormatsConfig *cfg = cfg_out[i];
428 
429  switch (c->codec_type) {
430  case AVMEDIA_TYPE_VIDEO:
431  list[0] = c->format;
432  if ((ret = ff_formats_ref(ff_make_format_list(list), &cfg->formats)) < 0)
433  return ret;
434  list[0] = c->color_space;
435  if ((ret = ff_formats_ref(ff_make_format_list(list), &cfg->color_spaces)) < 0)
436  return ret;
437  list[0] = c->color_range;
438  if ((ret = ff_formats_ref(ff_make_format_list(list), &cfg->color_ranges)) < 0)
439  return ret;
440  break;
441  case AVMEDIA_TYPE_AUDIO:
442  list[0] = c->format;
443  if ((ret = ff_formats_ref(ff_make_format_list(list), &cfg->formats)) < 0)
444  return ret;
445  list[0] = c->sample_rate;
446  if ((ret = ff_formats_ref(ff_make_format_list(list), &cfg->samplerates)) < 0)
447  return ret;
448  list64[0] = c->ch_layout;
449  if ((ret = ff_channel_layouts_ref(ff_make_channel_layout_list(list64),
450  &cfg->channel_layouts)) < 0)
451  return ret;
452  break;
453  }
454  }
455 
456  return 0;
457 }
458 
459 static int movie_config_output_props(AVFilterLink *outlink)
460 {
461  FilterLink *l = ff_filter_link(outlink);
462  AVFilterContext *ctx = outlink->src;
463  MovieContext *movie = ctx->priv;
464  unsigned out_id = FF_OUTLINK_IDX(outlink);
465  MovieStream *st = &movie->st[out_id];
466  AVCodecParameters *c = st->st->codecpar;
467 
468  outlink->time_base = st->st->time_base;
469 
470  switch (c->codec_type) {
471  case AVMEDIA_TYPE_VIDEO:
472  outlink->w = c->width;
473  outlink->h = c->height;
474  l->frame_rate = st->st->r_frame_rate;
475  break;
476  case AVMEDIA_TYPE_AUDIO:
477  break;
478  }
479 
480  st->link = outlink;
481 
482  return 0;
483 }
484 
485 static int rewind_file(AVFilterContext *ctx)
486 {
487  MovieContext *movie = ctx->priv;
488  int64_t timestamp = movie->seek_point;
489  int ret, i;
490 
491  if (movie->format_ctx->start_time != AV_NOPTS_VALUE)
492  timestamp += movie->format_ctx->start_time;
493  ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD);
494  if (ret < 0) {
495  av_log(ctx, AV_LOG_ERROR, "Unable to loop: %s\n", av_err2str(ret));
496  movie->loop_count = 1; /* do not try again */
497  return ret;
498  }
499 
500  for (i = 0; i < ctx->nb_outputs; i++) {
501  avcodec_flush_buffers(movie->st[i].codec_ctx);
502  }
503  return 0;
504 }
505 
506 static int flush_decoder(AVFilterContext *ctx, int i)
507 {
508  MovieContext *movie = ctx->priv;
509  AVCodecContext *dec = movie->st[i].codec_ctx;
510 
511  return avcodec_send_packet(dec, NULL);
512 }
513 
514 static int decode_packet(AVFilterContext *ctx, int i)
515 {
516  AVFilterLink *outlink = ctx->outputs[i];
517  MovieContext *movie = ctx->priv;
518  MovieStream *st = &movie->st[i];
519  AVCodecContext *dec = movie->st[i].codec_ctx;
520  AVFrame *frame = movie->st[i].frame;
521  AVPacket *pkt = movie->pkt;
522  int ret = 0;
523 
524  // submit the packet to the decoder
525  if (!movie->eof) {
526  ret = avcodec_send_packet(dec, pkt);
527  if (ret < 0)
528  return ret;
529  }
530 
531  // get all the available frames from the decoder
532  if (ret >= 0) {
533  ret = avcodec_receive_frame(dec, frame);
534  if (ret < 0) {
535  // those two return values are special and mean there is no output
536  // frame available, but there were no errors during decoding
537  if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN))
538  return 0;
539  return ret;
540  }
541 
542  frame->pts = frame->best_effort_timestamp;
543  if (frame->pts != AV_NOPTS_VALUE) {
544  if (movie->ts_offset)
545  frame->pts += av_rescale_q_rnd(movie->ts_offset, AV_TIME_BASE_Q, outlink->time_base, AV_ROUND_UP);
546  if (st->discontinuity_threshold) {
547  if (st->last_pts != AV_NOPTS_VALUE) {
548  int64_t diff = frame->pts - st->last_pts;
549  if (diff < 0 || diff > st->discontinuity_threshold) {
550  av_log(ctx, AV_LOG_VERBOSE, "Discontinuity in stream:%d diff:%"PRId64"\n", i, diff);
551  movie->ts_offset += av_rescale_q_rnd(-diff, outlink->time_base, AV_TIME_BASE_Q, AV_ROUND_UP);
552  frame->pts -= diff;
553  }
554  }
555  }
556  st->last_pts = frame->pts;
557  }
558  ret = ff_filter_frame(outlink, av_frame_clone(frame));
559  if (ret < 0)
560  return ret;
561  if (ret == 0)
562  return 1;
563  }
564 
565  return 0;
566 }
567 
568 static int activate(AVFilterContext *ctx)
569 {
570  MovieContext *movie = ctx->priv;
571  int wanted = 0, ret;
572 
573  for (int i = 0; i < ctx->nb_outputs; i++) {
574  if (ff_outlink_frame_wanted(ctx->outputs[i]))
575  wanted++;
576  }
577 
578  if (wanted == 0)
579  return FFERROR_NOT_READY;
580 
581  if (!movie->eof) {
582  ret = av_read_frame(movie->format_ctx, movie->pkt);
583  if (ret < 0) {
584  movie->eof = 1;
585  for (int i = 0; i < ctx->nb_outputs; i++)
586  flush_decoder(ctx, i);
587  ff_filter_set_ready(ctx, 100);
588  return 0;
589  } else {
590  int pkt_out_id = movie->pkt->stream_index > movie->max_stream_index ? -1 :
591  movie->out_index[movie->pkt->stream_index];
592 
593  if (pkt_out_id >= 0) {
594  ret = decode_packet(ctx, pkt_out_id);
595  }
596  av_packet_unref(movie->pkt);
597  ff_filter_set_ready(ctx, 100);
598  return (ret <= 0) ? ret : 0;
599  }
600  } else {
601  int nb_eofs = 0;
602 
603  for (int i = 0; i < ctx->nb_outputs; i++) {
604  if (!movie->st[i].eof) {
605  ret = decode_packet(ctx, i);
606  if (ret <= 0)
607  movie->st[i].eof = 1;
608  }
609  nb_eofs += movie->st[i].eof == 1;
610  }
611  if (nb_eofs == ctx->nb_outputs && movie->loop_count != 1) {
612  ret = rewind_file(ctx);
613  if (ret < 0)
614  return ret;
615  movie->loop_count -= movie->loop_count > 1;
616  av_log(ctx, AV_LOG_VERBOSE, "Stream finished, looping.\n");
617  ff_filter_set_ready(ctx, 100);
618  for (int i = 0; i < ctx->nb_outputs; i++)
619  movie->st[i].eof = 0;
620  movie->eof = 0;
621  return 0;
622  } else {
623  for (int i = 0; i < ctx->nb_outputs; i++) {
624  if (movie->st[i].eof) {
625  ff_outlink_set_status(ctx->outputs[i], AVERROR_EOF, movie->st[i].last_pts);
626  nb_eofs++;
627  }
628  }
629  }
630 
631  if (nb_eofs < ctx->nb_outputs)
632  ff_filter_set_ready(ctx, 100);
633  return 0;
634  }
635 
636  return FFERROR_NOT_READY;
637 }
638 
639 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
640  char *res, int res_len, int flags)
641 {
642  MovieContext *movie = ctx->priv;
643  int ret = AVERROR(ENOSYS);
644 
645  if (!strcmp(cmd, "seek")) {
646  int idx, flags, i;
647  int64_t ts;
648  char tail[2];
649 
650  if (sscanf(args, "%i|%"SCNi64"|%i %1s", &idx, &ts, &flags, tail) != 3)
651  return AVERROR(EINVAL);
652 
653  ret = av_seek_frame(movie->format_ctx, idx, ts, flags);
654  if (ret < 0)
655  return ret;
656 
657  for (i = 0; i < ctx->nb_outputs; i++) {
658  avcodec_flush_buffers(movie->st[i].codec_ctx);
659  }
660  return ret;
661  } else if (!strcmp(cmd, "get_duration")) {
662  int print_len;
663  char tail[2];
664 
665  if (!res || res_len <= 0)
666  return AVERROR(EINVAL);
667 
668  if (args && sscanf(args, "%1s", tail) == 1)
669  return AVERROR(EINVAL);
670 
671  print_len = snprintf(res, res_len, "%"PRId64, movie->format_ctx->duration);
672  if (print_len < 0 || print_len >= res_len)
673  return AVERROR(EINVAL);
674 
675  return 0;
676  }
677 
678  return ret;
679 }
680 
681 AVFILTER_DEFINE_CLASS_EXT(movie, "(a)movie", movie_options);
682 
683 #if CONFIG_MOVIE_FILTER
684 
685 const FFFilter ff_avsrc_movie = {
686  .p.name = "movie",
687  .p.description = NULL_IF_CONFIG_SMALL("Read from a movie source."),
688  .p.priv_class = &movie_class,
689  .p.flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
690  .priv_size = sizeof(MovieContext),
691  .init = movie_common_init,
692  .activate = activate,
693  .uninit = movie_uninit,
694  FILTER_QUERY_FUNC2(movie_query_formats),
695 
696  .process_command = process_command
697 };
698 
699 #endif /* CONFIG_MOVIE_FILTER */
700 
701 #if CONFIG_AMOVIE_FILTER
702 
703 const FFFilter ff_avsrc_amovie = {
704  .p.name = "amovie",
705  .p.description = NULL_IF_CONFIG_SMALL("Read audio from a movie source."),
706  .p.priv_class = &movie_class,
707  .p.flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
708  .priv_size = sizeof(MovieContext),
709  .init = movie_common_init,
710  .activate = activate,
711  .uninit = movie_uninit,
712  FILTER_QUERY_FUNC2(movie_query_formats),
713 
714  .process_command = process_command,
715 };
716 
717 #endif /* CONFIG_AMOVIE_FILTER */
flags
const SwsFlags flags[]
Definition: swscale.c:61
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:430
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:134
AVCodec
AVCodec.
Definition: codec.h:172
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AVFilterFormatsConfig::samplerates
AVFilterFormats * samplerates
Lists of supported sample rates, only for audio.
Definition: avfilter.h:119
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_OUTLINK_IDX
#define FF_OUTLINK_IDX(link)
Definition: filters.h:214
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:435
AVFilterFormatsConfig::channel_layouts
AVFilterChannelLayouts * channel_layouts
Lists of supported channel layouts, only for audio.
Definition: avfilter.h:124
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:376
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:1053
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:673
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:816
MovieContext::eof
int eof
Definition: src_movie.c:77
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
int64_t
long long int64_t
Definition: coverity.c:34
MovieContext::stream_index
int stream_index
for compatibility
Definition: src_movie.c:68
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
FLAGS
#define FLAGS
Definition: src_movie.c:85
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:63
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:410
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1333
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:191
w
uint8_t w
Definition: llviddspenc.c:38
AVOption
AVOption.
Definition: opt.h:429
format_opts
AVDictionary * format_opts
Definition: cmdutils.c:58
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Underlying C type is int64_t.
Definition: opt.h:319
MovieStream::link
AVFilterLink * link
Definition: src_movie.c:51
ff_avsrc_movie
const FFFilter ff_avsrc_movie
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
movie_options
static const AVOption movie_options[]
Definition: src_movie.c:87
MovieStream::eof
int eof
Definition: src_movie.c:57
AVDictionary
Definition: dict.c:32
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:203
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1529
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
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:75
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:639
formats.h
MovieContext::out_index
int * out_index
stream number -> output number map, or -1
Definition: src_movie.c:80
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:367
ff_default_get_video_buffer
AVFrame * ff_default_get_video_buffer(AVFilterLink *link, int w, int h)
Definition: video.c:111
MovieContext::file_name
char * file_name
Definition: src_movie.c:66
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:440
decode_packet
static int decode_packet(AVFilterContext *ctx, int i)
Definition: src_movie.c:514
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1561
MovieStream::frame
AVFrame * frame
Definition: src_movie.c:56
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
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:38
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:51
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:1200
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:210
AVInputFormat
Definition: avformat.h:545
av_cold
#define av_cold
Definition: attributes.h:90
FFFilter
Definition: filters.h:265
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:217
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:653
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:627
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:641
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Underlying C type is double.
Definition: opt.h:267
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:678
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:702
MovieContext::ts_offset
int64_t ts_offset
Definition: src_movie.c:71
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:160
nb_streams
static int nb_streams
Definition: ffprobe.c:336
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:485
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
AVFilterFormatsConfig::color_spaces
AVFilterFormats * color_spaces
Lists of supported YUV color metadata, only for YUV video.
Definition: avfilter.h:129
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:141
MovieContext::format_ctx
AVFormatContext * format_ctx
Definition: src_movie.c:75
MovieContext
Definition: src_movie.c:60
find_stream
static AVStream * find_stream(void *log, AVFormatContext *avf, const char *spec)
Definition: src_movie.c:106
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:221
AVFormatContext
Format I/O context.
Definition: avformat.h:1265
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:768
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:2379
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
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:784
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:601
MovieStream::discontinuity_threshold
int64_t discontinuity_threshold
Definition: src_movie.c:54
avcodec_free_context
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
Definition: options.c:164
MovieContext::discontinuity_threshold
int64_t discontinuity_threshold
Definition: src_movie.c:70
AVFILTER_DEFINE_CLASS_EXT
AVFILTER_DEFINE_CLASS_EXT(movie, "(a)movie", movie_options)
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Underlying C type is AVDictionary*.
Definition: opt.h:290
MovieStream::last_pts
int64_t last_pts
Definition: src_movie.c:55
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:25
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:143
movie_query_formats
static int movie_query_formats(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: src_movie.c:415
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
MovieStream::codec_ctx
AVCodecContext * codec_ctx
Definition: src_movie.c:53
MovieContext::format_name
char * format_name
Definition: src_movie.c:65
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
MovieStream::st
AVStream * st
Definition: src_movie.c:52
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:109
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:197
MovieContext::seek_point_d
double seek_point_d
Definition: src_movie.c:64
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:1016
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:145
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1321
AVFilterPad::config_props
int(* config_props)(AVFilterLink *link)
Link configuration callback.
Definition: filters.h:118
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:2507
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:368
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_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:614
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:216
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:319
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:69
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:542
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:411
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:166
attributes.h
AVFilterFormatsConfig::color_ranges
AVFilterFormats * color_ranges
AVColorRange.
Definition: avfilter.h:130
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:64
MovieContext::pkt
AVPacket * pkt
Definition: src_movie.c:74
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:809
MovieContext::format_opts
AVDictionary * format_opts
Definition: src_movie.c:81
iformat
static const AVInputFormat * iformat
Definition: ffprobe.c:328
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:839
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:253
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:704
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:485
internal.h
ff_avsrc_amovie
const FFFilter ff_avsrc_amovie
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:840
FILTER_QUERY_FUNC2
#define FILTER_QUERY_FUNC2(func)
Definition: filters.h:239
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:525
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:498
MovieContext::max_stream_index
int max_stream_index
max stream # actually used for output
Definition: src_movie.c:78
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:44
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:745
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: filters.h:49
avcodec_flush_buffers
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:374
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:473
avformat.h
activate
static int activate(AVFilterContext *ctx)
Definition: src_movie.c:568
movie_config_output_props
static int movie_config_output_props(AVFilterLink *outlink)
Definition: src_movie.c:459
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:431
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:751
format_name
static int format_name(const char *buf, char **s, int index, const char *varname)
Definition: hlsenc.c:2028
channel_layout.h
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
avfilter.h
flush_decoder
static int flush_decoder(AVFilterContext *ctx, int i)
Definition: src_movie.c:506
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:879
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:67
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1400
AVPacket::stream_index
int stream_index
Definition: packet.h:537
AVFilterContext
An instance of a filter.
Definition: avfilter.h:257
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:449
MovieContext::st
MovieStream * st
array of all streams, one per output
Definition: src_movie.c:79
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:439
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FFFilter::p
AVFilter p
The public AVFilter.
Definition: filters.h:269
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:46
AVFilterFormatsConfig::formats
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:114
MovieContext::dec_threads
int dec_threads
Definition: src_movie.c:72
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:512
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:35
ff_make_channel_layout_list
AVFilterChannelLayouts * ff_make_channel_layout_list(const AVChannelLayout *fmts)
Definition: formats.c:444
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:63
AVFormatContext::start_time
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1390
h
h
Definition: vp9dsp_template.c:2070
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
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
MovieStream
Definition: src_movie.c:50
snprintf
#define snprintf
Definition: snprintf.h:34
OFFSET
#define OFFSET(x)
Definition: src_movie.c:84
open_stream
static int open_stream(AVFilterContext *ctx, MovieStream *st, int dec_threads)
Definition: src_movie.c:210
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:229
Generated on Wed Apr 23 2025 19:22:27 for FFmpeg by   doxygen 1.8.17