FFmpeg: libavfilter/src_movie.c Source File

FFmpeg
src_movie.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2010 Stefano Sabatini
3  * Copyright (c) 2008 Victor Paesa
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * movie video source
25  *
26  * @todo use direct rendering (no allocation of a new frame)
27  * @todo support a PTS correction mechanism
28  */
29 
30 #include <float.h>
31 #include <stdint.h>
32 
33 #include "libavutil/attributes.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/imgutils.h"
38 #include "libavutil/internal.h"
39 #include "libavutil/timestamp.h"
40 
41 #include "libavcodec/avcodec.h"
42 
43 #include "libavformat/avformat.h"
44 
45 #include "audio.h"
46 #include "avfilter.h"
47 #include "formats.h"
48 #include "internal.h"
49 #include "video.h"
50 
51  typedef struct MovieStream {
52   AVStream *st;
53   AVCodecContext *codec_ctx;
54   int64_t discontinuity_threshold;
55   int64_t last_pts;
56 } MovieStream;
57 
58  typedef struct MovieContext {
59  /* common A/V fields */
60   const AVClass *class;
61   int64_t seek_point; ///< seekpoint in microseconds
62   double seek_point_d;
63   char *format_name;
64   char *file_name;
65   char *stream_specs; /**< user-provided list of streams, separated by + */
66   int stream_index; /**< for compatibility */
67   int loop_count;
68   int64_t discontinuity_threshold;
69   int64_t ts_offset;
70   int dec_threads;
71 
72   AVFormatContext *format_ctx;
73 
74   int max_stream_index; /**< max stream # actually used for output */
75   MovieStream *st; /**< array of all streams, one per output */
76   int *out_index; /**< stream number -> output number map, or -1 */
77   AVDictionary *format_opts;
78 } MovieContext;
79 
80  #define OFFSET(x) offsetof(MovieContext, x)
81  #define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_VIDEO_PARAM
82 
83  static const AVOption movie_options[]= {
84  { "filename", NULL, OFFSET(file_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
85  { "format_name", "set format name", OFFSET(format_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
86  { "f", "set format name", OFFSET(format_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
87  { "stream_index", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
88  { "si", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
89  { "seek_point", "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0, (INT64_MAX-1) / 1000000, FLAGS },
90  { "sp", "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0, (INT64_MAX-1) / 1000000, FLAGS },
91  { "streams", "set streams", OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, FLAGS },
92  { "s", "set streams", OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, FLAGS },
93  { "loop", "set loop count", OFFSET(loop_count), AV_OPT_TYPE_INT, {.i64 = 1}, 0, INT_MAX, FLAGS },
94  { "discontinuity", "set discontinuity threshold", OFFSET(discontinuity_threshold), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, INT64_MAX, FLAGS },
95  { "dec_threads", "set the number of threads for decoding", OFFSET(dec_threads), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, FLAGS },
96  { "format_opts", "set format options for the opened file", OFFSET(format_opts), AV_OPT_TYPE_DICT, {.str = NULL}, 0, 0, FLAGS},
97  { NULL },
98 };
99 
100 static int movie_config_output_props(AVFilterLink *outlink);
101 static int movie_request_frame(AVFilterLink *outlink);
102 
103  static AVStream *find_stream(void *log, AVFormatContext *avf, const char *spec)
104 {
105  int i, ret, already = 0, stream_id = -1;
106  char type_char[2], dummy;
107  AVStream *found = NULL;
108  enum AVMediaType type;
109 
110  ret = sscanf(spec, "d%1[av]%d%c", type_char, &stream_id, &dummy);
111  if (ret >= 1 && ret <= 2) {
112  type = type_char[0] == 'v' ? AVMEDIA_TYPE_VIDEO : AVMEDIA_TYPE_AUDIO;
113  ret = av_find_best_stream(avf, type, stream_id, -1, NULL, 0);
114  if (ret < 0) {
115  av_log(log, AV_LOG_ERROR, "No %s stream with index '%d' found\n",
116  av_get_media_type_string(type), stream_id);
117  return NULL;
118  }
119  return avf->streams[ret];
120  }
121  for (i = 0; i < avf->nb_streams; i++) {
122  ret = avformat_match_stream_specifier(avf, avf->streams[i], spec);
123  if (ret < 0) {
124  av_log(log, AV_LOG_ERROR,
125  "Invalid stream specifier \"%s\"\n", spec);
126  return NULL;
127  }
128  if (!ret)
129  continue;
130  if (avf->streams[i]->discard != AVDISCARD_ALL) {
131  already++;
132  continue;
133  }
134  if (found) {
135  av_log(log, AV_LOG_WARNING,
136  "Ambiguous stream specifier \"%s\", using #%d\n", spec, i);
137  break;
138  }
139  found = avf->streams[i];
140  }
141  if (!found) {
142  av_log(log, AV_LOG_WARNING, "Stream specifier \"%s\" %s\n", spec,
143  already ? "matched only already used streams" :
144  "did not match any stream");
145  return NULL;
146  }
147  if (found->codecpar->codec_type != AVMEDIA_TYPE_VIDEO &&
148  found->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
149  av_log(log, AV_LOG_ERROR, "Stream specifier \"%s\" matched a %s stream,"
150  "currently unsupported by libavfilter\n", spec,
151  av_get_media_type_string(found->codecpar->codec_type));
152  return NULL;
153  }
154  return found;
155 }
156 
157  static int open_stream(AVFilterContext *ctx, MovieStream *st, int dec_threads)
158 {
159  const AVCodec *codec;
160  int ret;
161 
162  codec = avcodec_find_decoder(st->st->codecpar->codec_id);
163  if (!codec) {
164  av_log(ctx, AV_LOG_ERROR, "Failed to find any codec\n");
165  return AVERROR(EINVAL);
166  }
167 
168  st->codec_ctx = avcodec_alloc_context3(codec);
169  if (!st->codec_ctx)
170  return AVERROR(ENOMEM);
171 
172  ret = avcodec_parameters_to_context(st->codec_ctx, st->st->codecpar);
173  if (ret < 0)
174  return ret;
175 
176  if (!dec_threads)
177  dec_threads = ff_filter_get_nb_threads(ctx);
178  st->codec_ctx->thread_count = dec_threads;
179 
180  if ((ret = avcodec_open2(st->codec_ctx, codec, NULL)) < 0) {
181  av_log(ctx, AV_LOG_ERROR, "Failed to open codec\n");
182  return ret;
183  }
184 
185  return 0;
186 }
187 
188  static int guess_channel_layout(MovieStream *st, int st_index, void *log_ctx)
189 {
190  AVCodecParameters *dec_par = st->st->codecpar;
191  char buf[256];
192  int64_t chl = av_get_default_channel_layout(dec_par->channels);
193 
194  if (!chl) {
195  av_log(log_ctx, AV_LOG_ERROR,
196  "Channel layout is not set in stream %d, and could not "
197  "be guessed from the number of channels (%d)\n",
198  st_index, dec_par->channels);
199  return AVERROR(EINVAL);
200  }
201 
202  av_get_channel_layout_string(buf, sizeof(buf), dec_par->channels, chl);
203  av_log(log_ctx, AV_LOG_WARNING,
204  "Channel layout is not set in output stream %d, "
205  "guessed channel layout is '%s'\n",
206  st_index, buf);
207  dec_par->channel_layout = chl;
208  return 0;
209 }
210 
211  static av_cold int movie_common_init(AVFilterContext *ctx)
212 {
213  MovieContext *movie = ctx->priv;
214  const AVInputFormat *iformat = NULL;
215  int64_t timestamp;
216  int nb_streams = 1, ret, i;
217  char default_streams[16], *stream_specs, *spec, *cursor;
218  AVStream *st;
219 
220  if (!movie->file_name) {
221  av_log(ctx, AV_LOG_ERROR, "No filename provided!\n");
222  return AVERROR(EINVAL);
223  }
224 
225  movie->seek_point = movie->seek_point_d * 1000000 + 0.5;
226 
227  stream_specs = movie->stream_specs;
228  if (!stream_specs) {
229  snprintf(default_streams, sizeof(default_streams), "d%c%d",
230  !strcmp(ctx->filter->name, "amovie") ? 'a' : 'v',
231  movie->stream_index);
232  stream_specs = default_streams;
233  }
234  for (cursor = stream_specs; *cursor; cursor++)
235  if (*cursor == '+')
236  nb_streams++;
237 
238  if (movie->loop_count != 1 && nb_streams != 1) {
239  av_log(ctx, AV_LOG_ERROR,
240  "Loop with several streams is currently unsupported\n");
241  return AVERROR_PATCHWELCOME;
242  }
243 
244  // Try to find the movie format (container)
245  iformat = movie->format_name ? av_find_input_format(movie->format_name) : NULL;
246 
247  movie->format_ctx = NULL;
248  if ((ret = avformat_open_input(&movie->format_ctx, movie->file_name, iformat, &movie->format_opts)) < 0) {
249  av_log(ctx, AV_LOG_ERROR,
250  "Failed to avformat_open_input '%s'\n", movie->file_name);
251  return ret;
252  }
253  if ((ret = avformat_find_stream_info(movie->format_ctx, NULL)) < 0)
254  av_log(ctx, AV_LOG_WARNING, "Failed to find stream info\n");
255 
256  // if seeking requested, we execute it
257  if (movie->seek_point > 0) {
258  timestamp = movie->seek_point;
259  // add the stream start time, should it exist
260  if (movie->format_ctx->start_time != AV_NOPTS_VALUE) {
261  if (timestamp > 0 && movie->format_ctx->start_time > INT64_MAX - timestamp) {
262  av_log(ctx, AV_LOG_ERROR,
263  "%s: seek value overflow with start_time:%"PRId64" seek_point:%"PRId64"\n",
264  movie->file_name, movie->format_ctx->start_time, movie->seek_point);
265  return AVERROR(EINVAL);
266  }
267  timestamp += movie->format_ctx->start_time;
268  }
269  if ((ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD)) < 0) {
270  av_log(ctx, AV_LOG_ERROR, "%s: could not seek to position %"PRId64"\n",
271  movie->file_name, timestamp);
272  return ret;
273  }
274  }
275 
276  for (i = 0; i < movie->format_ctx->nb_streams; i++)
277  movie->format_ctx->streams[i]->discard = AVDISCARD_ALL;
278 
279  movie->st = av_calloc(nb_streams, sizeof(*movie->st));
280  if (!movie->st)
281  return AVERROR(ENOMEM);
282 
283  for (i = 0; i < nb_streams; i++) {
284  spec = av_strtok(stream_specs, "+", &cursor);
285  if (!spec)
286  return AVERROR_BUG;
287  stream_specs = NULL; /* for next strtok */
288  st = find_stream(ctx, movie->format_ctx, spec);
289  if (!st)
290  return AVERROR(EINVAL);
291  st->discard = AVDISCARD_DEFAULT;
292  movie->st[i].st = st;
293  movie->max_stream_index = FFMAX(movie->max_stream_index, st->index);
294  movie->st[i].discontinuity_threshold =
295  av_rescale_q(movie->discontinuity_threshold, AV_TIME_BASE_Q, st->time_base);
296  }
297  if (av_strtok(NULL, "+", &cursor))
298  return AVERROR_BUG;
299 
300  movie->out_index = av_calloc(movie->max_stream_index + 1,
301  sizeof(*movie->out_index));
302  if (!movie->out_index)
303  return AVERROR(ENOMEM);
304  for (i = 0; i <= movie->max_stream_index; i++)
305  movie->out_index[i] = -1;
306  for (i = 0; i < nb_streams; i++) {
307  AVFilterPad pad = { 0 };
308  movie->out_index[movie->st[i].st->index] = i;
309  pad.type = movie->st[i].st->codecpar->codec_type;
310  pad.name = av_asprintf("out%d", i);
311  if (!pad.name)
312  return AVERROR(ENOMEM);
313  pad.config_props = movie_config_output_props;
314  pad.request_frame = movie_request_frame;
315  if ((ret = ff_append_outpad_free_name(ctx, &pad)) < 0)
316  return ret;
317  if ( movie->st[i].st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
318  !movie->st[i].st->codecpar->channel_layout) {
319  ret = guess_channel_layout(&movie->st[i], i, ctx);
320  if (ret < 0)
321  return ret;
322  }
323  ret = open_stream(ctx, &movie->st[i], movie->dec_threads);
324  if (ret < 0)
325  return ret;
326  }
327 
328  av_log(ctx, AV_LOG_VERBOSE, "seek_point:%"PRIi64" format_name:%s file_name:%s stream_index:%d\n",
329  movie->seek_point, movie->format_name, movie->file_name,
330  movie->stream_index);
331 
332  return 0;
333 }
334 
335  static av_cold void movie_uninit(AVFilterContext *ctx)
336 {
337  MovieContext *movie = ctx->priv;
338  int i;
339 
340  for (i = 0; i < ctx->nb_outputs; i++) {
341  if (movie->st[i].st)
342  avcodec_free_context(&movie->st[i].codec_ctx);
343  }
344  av_freep(&movie->st);
345  av_freep(&movie->out_index);
346  if (movie->format_ctx)
347  avformat_close_input(&movie->format_ctx);
348 }
349 
350  static int movie_query_formats(AVFilterContext *ctx)
351 {
352  MovieContext *movie = ctx->priv;
353  int list[] = { 0, -1 };
354  int64_t list64[] = { 0, -1 };
355  int i, ret;
356 
357  for (i = 0; i < ctx->nb_outputs; i++) {
358  MovieStream *st = &movie->st[i];
359  AVCodecParameters *c = st->st->codecpar;
360  AVFilterLink *outlink = ctx->outputs[i];
361 
362  switch (c->codec_type) {
363  case AVMEDIA_TYPE_VIDEO:
364  list[0] = c->format;
365  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.formats)) < 0)
366  return ret;
367  break;
368  case AVMEDIA_TYPE_AUDIO:
369  list[0] = c->format;
370  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.formats)) < 0)
371  return ret;
372  list[0] = c->sample_rate;
373  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.samplerates)) < 0)
374  return ret;
375  list64[0] = c->channel_layout;
376  if ((ret = ff_channel_layouts_ref(ff_make_format64_list(list64),
377  &outlink->incfg.channel_layouts)) < 0)
378  return ret;
379  break;
380  }
381  }
382 
383  return 0;
384 }
385 
386  static int movie_config_output_props(AVFilterLink *outlink)
387 {
388  AVFilterContext *ctx = outlink->src;
389  MovieContext *movie = ctx->priv;
390  unsigned out_id = FF_OUTLINK_IDX(outlink);
391  MovieStream *st = &movie->st[out_id];
392  AVCodecParameters *c = st->st->codecpar;
393 
394  outlink->time_base = st->st->time_base;
395 
396  switch (c->codec_type) {
397  case AVMEDIA_TYPE_VIDEO:
398  outlink->w = c->width;
399  outlink->h = c->height;
400  outlink->frame_rate = st->st->r_frame_rate;
401  break;
402  case AVMEDIA_TYPE_AUDIO:
403  break;
404  }
405 
406  return 0;
407 }
408 
409  static char *describe_frame_to_str(char *dst, size_t dst_size,
410  AVFrame *frame, enum AVMediaType frame_type,
411  AVFilterLink *link)
412 {
413  switch (frame_type) {
414  case AVMEDIA_TYPE_VIDEO:
415  snprintf(dst, dst_size,
416  "video pts:%s time:%s size:%dx%d aspect:%d/%d",
417  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &link->time_base),
418  frame->width, frame->height,
419  frame->sample_aspect_ratio.num,
420  frame->sample_aspect_ratio.den);
421  break;
422  case AVMEDIA_TYPE_AUDIO:
423  snprintf(dst, dst_size,
424  "audio pts:%s time:%s samples:%d",
425  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &link->time_base),
426  frame->nb_samples);
427  break;
428  default:
429  snprintf(dst, dst_size, "%s BUG", av_get_media_type_string(frame_type));
430  break;
431  }
432  return dst;
433 }
434 
435  static int rewind_file(AVFilterContext *ctx)
436 {
437  MovieContext *movie = ctx->priv;
438  int64_t timestamp = movie->seek_point;
439  int ret, i;
440 
441  if (movie->format_ctx->start_time != AV_NOPTS_VALUE)
442  timestamp += movie->format_ctx->start_time;
443  ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD);
444  if (ret < 0) {
445  av_log(ctx, AV_LOG_ERROR, "Unable to loop: %s\n", av_err2str(ret));
446  movie->loop_count = 1; /* do not try again */
447  return ret;
448  }
449 
450  for (i = 0; i < ctx->nb_outputs; i++) {
451  avcodec_flush_buffers(movie->st[i].codec_ctx);
452  }
453  return 0;
454 }
455 
456  static int movie_decode_packet(AVFilterContext *ctx)
457 {
458  MovieContext *movie = ctx->priv;
459  AVPacket pkt = { 0 };
460  int pkt_out_id, ret;
461 
462  /* read a new packet from input stream */
463  ret = av_read_frame(movie->format_ctx, &pkt);
464  if (ret == AVERROR_EOF) {
465  /* EOF -> set all decoders for flushing */
466  for (int i = 0; i < ctx->nb_outputs; i++) {
467  ret = avcodec_send_packet(movie->st[i].codec_ctx, NULL);
468  if (ret < 0 && ret != AVERROR_EOF)
469  return ret;
470  }
471 
472  return 0;
473  } else if (ret < 0)
474  return ret;
475 
476  /* send the packet to its decoder, if any */
477  pkt_out_id = pkt.stream_index > movie->max_stream_index ? -1 :
478  movie->out_index[pkt.stream_index];
479  if (pkt_out_id >= 0)
480  ret = avcodec_send_packet(movie->st[pkt_out_id].codec_ctx, &pkt);
481  av_packet_unref(&pkt);
482 
483  return ret;
484 }
485 
486 /**
487  * Try to push a frame to the requested output.
488  *
489  * @param ctx filter context
490  * @param out_id number of output where a frame is wanted;
491  * @return 0 if a frame was pushed on the requested output,
492  * AVERROR(EAGAIN) if the decoder requires more input
493  * AVERROR(EOF) if the decoder has been completely flushed
494  * <0 AVERROR code
495  */
496  static int movie_push_frame(AVFilterContext *ctx, unsigned out_id)
497 {
498  MovieContext *movie = ctx->priv;
499  MovieStream *st = &movie->st[out_id];
500  AVFilterLink *outlink = ctx->outputs[out_id];
501  AVFrame *frame;
502  int ret;
503 
504  frame = av_frame_alloc();
505  if (!frame)
506  return AVERROR(ENOMEM);
507 
508  ret = avcodec_receive_frame(st->codec_ctx, frame);
509  if (ret < 0) {
510  if (ret != AVERROR_EOF && ret != AVERROR(EAGAIN))
511  av_log(ctx, AV_LOG_WARNING, "Decode error: %s\n", av_err2str(ret));
512 
513  av_frame_free(&frame);
514  return ret;
515  }
516 
517  frame->pts = frame->best_effort_timestamp;
518  if (frame->pts != AV_NOPTS_VALUE) {
519  if (movie->ts_offset)
520  frame->pts += av_rescale_q_rnd(movie->ts_offset, AV_TIME_BASE_Q, outlink->time_base, AV_ROUND_UP);
521  if (st->discontinuity_threshold) {
522  if (st->last_pts != AV_NOPTS_VALUE) {
523  int64_t diff = frame->pts - st->last_pts;
524  if (diff < 0 || diff > st->discontinuity_threshold) {
525  av_log(ctx, AV_LOG_VERBOSE, "Discontinuity in stream:%d diff:%"PRId64"\n", out_id, diff);
526  movie->ts_offset += av_rescale_q_rnd(-diff, outlink->time_base, AV_TIME_BASE_Q, AV_ROUND_UP);
527  frame->pts -= diff;
528  }
529  }
530  }
531  st->last_pts = frame->pts;
532  }
533  ff_dlog(ctx, "movie_push_frame(): file:'%s' %s\n", movie->file_name,
534  describe_frame_to_str((char[1024]){0}, 1024, frame,
535  st->st->codecpar->codec_type, outlink));
536 
537  if (st->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
538  if (frame->format != outlink->format) {
539  av_log(ctx, AV_LOG_ERROR, "Format changed %s -> %s, discarding frame\n",
540  av_get_pix_fmt_name(outlink->format),
541  av_get_pix_fmt_name(frame->format)
542  );
543  av_frame_free(&frame);
544  return 0;
545  }
546  }
547  ret = ff_filter_frame(outlink, frame);
548 
549  if (ret < 0)
550  return ret;
551  return 0;
552 }
553 
554  static int movie_request_frame(AVFilterLink *outlink)
555 {
556  AVFilterContext *ctx = outlink->src;
557  MovieContext *movie = ctx->priv;
558  unsigned out_id = FF_OUTLINK_IDX(outlink);
559 
560  while (1) {
561  int got_eagain = 0, got_eof = 0;
562  int ret = 0;
563 
564  /* check all decoders for available output */
565  for (int i = 0; i < ctx->nb_outputs; i++) {
566  ret = movie_push_frame(ctx, i);
567  if (ret == AVERROR(EAGAIN))
568  got_eagain++;
569  else if (ret == AVERROR_EOF)
570  got_eof++;
571  else if (ret < 0)
572  return ret;
573  else if (i == out_id)
574  return 0;
575  }
576 
577  if (got_eagain) {
578  /* all decoders require more input -> read a new packet */
579  ret = movie_decode_packet(ctx);
580  if (ret < 0)
581  return ret;
582  } else if (got_eof) {
583  /* all decoders flushed */
584  if (movie->loop_count != 1) {
585  ret = rewind_file(ctx);
586  if (ret < 0)
587  return ret;
588  movie->loop_count -= movie->loop_count > 1;
589  av_log(ctx, AV_LOG_VERBOSE, "Stream finished, looping.\n");
590  continue;
591  }
592  return AVERROR_EOF;
593  }
594  }
595 }
596 
597  static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
598  char *res, int res_len, int flags)
599 {
600  MovieContext *movie = ctx->priv;
601  int ret = AVERROR(ENOSYS);
602 
603  if (!strcmp(cmd, "seek")) {
604  int idx, flags, i;
605  int64_t ts;
606  char tail[2];
607 
608  if (sscanf(args, "%i|%"SCNi64"|%i %1s", &idx, &ts, &flags, tail) != 3)
609  return AVERROR(EINVAL);
610 
611  ret = av_seek_frame(movie->format_ctx, idx, ts, flags);
612  if (ret < 0)
613  return ret;
614 
615  for (i = 0; i < ctx->nb_outputs; i++) {
616  avcodec_flush_buffers(movie->st[i].codec_ctx);
617  }
618  return ret;
619  } else if (!strcmp(cmd, "get_duration")) {
620  int print_len;
621  char tail[2];
622 
623  if (!res || res_len <= 0)
624  return AVERROR(EINVAL);
625 
626  if (args && sscanf(args, "%1s", tail) == 1)
627  return AVERROR(EINVAL);
628 
629  print_len = snprintf(res, res_len, "%"PRId64, movie->format_ctx->duration);
630  if (print_len < 0 || print_len >= res_len)
631  return AVERROR(EINVAL);
632 
633  return 0;
634  }
635 
636  return ret;
637 }
638 
639 AVFILTER_DEFINE_CLASS_EXT(movie, "(a)movie", movie_options);
640 
641 #if CONFIG_MOVIE_FILTER
642 
643 const AVFilter ff_avsrc_movie = {
644  .name = "movie",
645  .description = NULL_IF_CONFIG_SMALL("Read from a movie source."),
646  .priv_size = sizeof(MovieContext),
647  .priv_class = &movie_class,
648  .init = movie_common_init,
649  .uninit = movie_uninit,
650  FILTER_QUERY_FUNC(movie_query_formats),
651 
652  .inputs = NULL,
653  .outputs = NULL,
654  .flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
655  .process_command = process_command
656 };
657 
658 #endif /* CONFIG_MOVIE_FILTER */
659 
660 #if CONFIG_AMOVIE_FILTER
661 
662 const AVFilter ff_avsrc_amovie = {
663  .name = "amovie",
664  .description = NULL_IF_CONFIG_SMALL("Read audio from a movie source."),
665  .priv_class = &movie_class,
666  .priv_size = sizeof(MovieContext),
667  .init = movie_common_init,
668  .uninit = movie_uninit,
669  FILTER_QUERY_FUNC(movie_query_formats),
670 
671  .inputs = NULL,
672  .outputs = NULL,
673  .flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
674  .process_command = process_command,
675 };
676 
677 #endif /* CONFIG_AMOVIE_FILTER */
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:424
AVCodec
AVCodec.
Definition: codec.h:202
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:511
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:56
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:381
movie_decode_packet
static int movie_decode_packet(AVFilterContext *ctx)
Definition: src_movie.c:456
AVFilterFormatsConfig::channel_layouts
AVFilterChannelLayouts * channel_layouts
Lists of supported channel layouts, only for audio.
Definition: avfilter.h:516
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1018
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:550
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:997
describe_frame_to_str
static char * describe_frame_to_str(char *dst, size_t dst_size, AVFrame *frame, enum AVMediaType frame_type, AVFilterLink *link)
Definition: src_movie.c:409
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
MovieContext::stream_index
int stream_index
for compatibility
Definition: src_movie.c:66
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
FLAGS
#define FLAGS
Definition: src_movie.c:81
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:109
av_get_channel_layout_string
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
Definition: channel_layout.c:217
ff_make_format64_list
AVFilterChannelLayouts * ff_make_format64_list(const int64_t *fmts)
Definition: formats.c:390
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1268
AVOption
AVOption.
Definition: opt.h:247
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:168
format_opts
AVDictionary * format_opts
Definition: cmdutils.c:71
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Definition: opt.h:238
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
float.h
movie_options
static const AVOption movie_options[]
Definition: src_movie.c:83
AVDictionary
Definition: dict.c:30
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:169
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1412
video.h
guess_channel_layout
static int guess_channel_layout(MovieStream *st, int st_index, void *log_ctx)
Definition: src_movie.c:188
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:597
formats.h
init
static int init
Definition: av_tx.c:47
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)
Find the "best" stream in the file.
Definition: utils.c:500
MovieContext::out_index
int * out_index
stream number -> output number map, or -1
Definition: src_movie.c:76
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:355
got_eagain
static int got_eagain(void)
Definition: ffmpeg.c:4107
MovieContext::file_name
char * file_name
Definition: src_movie.c:64
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1440
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:83
ff_avsrc_amovie
const AVFilter ff_avsrc_amovie
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:50
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:97
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:650
AVFilterPad::request_frame
int(* request_frame)(AVFilterLink *link)
Frame request callback.
Definition: internal.h:114
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:207
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:141
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:633
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:226
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:555
FF_OUTLINK_IDX
#define FF_OUTLINK_IDX(link)
Definition: internal.h:335
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:186
avcodec_receive_frame
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:642
MovieContext::ts_offset
int64_t ts_offset
Definition: src_movie.c:69
ctx
AVFormatContext * ctx
Definition: movenc.c:48
nb_streams
static int nb_streams
Definition: ffprobe.c:297
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:141
MovieContext::format_ctx
AVFormatContext * format_ctx
Definition: src_movie.c:72
MovieContext
Definition: src_movie.c:58
find_stream
static AVStream * find_stream(void *log, AVFormatContext *avf, const char *spec)
Definition: src_movie.c:103
link
Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a link
Definition: filter_design.txt:23
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:54
AVFormatContext
Format I/O context.
Definition: avformat.h:1200
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1095
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2275
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:965
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
movie_request_frame
static int movie_request_frame(AVFilterLink *outlink)
Definition: src_movie.c:554
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:156
MovieContext::discontinuity_threshold
int64_t discontinuity_threshold
Definition: src_movie.c:68
AVFILTER_DEFINE_CLASS_EXT
AVFILTER_DEFINE_CLASS_EXT(movie, "(a)movie", movie_options)
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:231
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:137
MovieStream::codec_ctx
AVCodecContext * codec_ctx
Definition: src_movie.c:53
MovieContext::format_name
char * format_name
Definition: src_movie.c:63
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
MovieContext::seek_point_d
double seek_point_d
Definition: src_movie.c:62
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:921
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:116
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1256
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
AVFilterPad::config_props
int(* config_props)(AVFilterLink *link)
Link configuration callback.
Definition: internal.h:130
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:2388
movie_common_init
static av_cold int movie_common_init(AVFilterContext *ctx)
Definition: src_movie.c:211
av_ts2timestr
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:76
AVMediaType
AVMediaType
Definition: avutil.h:199
movie_query_formats
static int movie_query_formats(AVFilterContext *ctx)
Definition: src_movie.c:350
movie_uninit
static av_cold void movie_uninit(AVFilterContext *ctx)
Definition: src_movie.c:335
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: utils.c:1543
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:117
AVDISCARD_DEFAULT
@ AVDISCARD_DEFAULT
discard useless packets like 0 size packets in avi
Definition: defs.h:49
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:121
MovieContext::loop_count
int loop_count
Definition: src_movie.c:67
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVFrame::time_base
AVRational time_base
Time base for the timestamps in this frame.
Definition: frame.h:439
attributes.h
MovieContext::format_opts
AVDictionary * format_opts
Definition: src_movie.c:77
internal.h
iformat
static const AVInputFormat * iformat
Definition: ffprobe.c:274
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:579
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
frame_type
frame_type
Definition: jpeg2000_parser.c:31
rewind_file
static int rewind_file(AVFilterContext *ctx)
Definition: src_movie.c:435
internal.h
avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: codec_par.c:147
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:803
MovieContext::max_stream_index
int max_stream_index
max stream # actually used for output
Definition: src_movie.c:74
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:56
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:271
avcodec.h
AVFilter
Filter definition.
Definition: avfilter.h:165
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:935
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:61
avcodec_flush_buffers
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:379
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
movie_push_frame
static int movie_push_frame(AVFilterContext *ctx, unsigned out_id)
Try to push a frame to the requested output.
Definition: src_movie.c:496
avformat.h
movie_config_output_props
static int movie_config_output_props(AVFilterLink *outlink)
Definition: src_movie.c:386
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:71
AVCodecContext
main external API structure.
Definition: avcodec.h:383
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:943
format_name
static int format_name(const char *buf, char **s, int index, const char *varname)
Definition: hlsenc.c:1926
channel_layout.h
dummy
int dummy
Definition: motion.c:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
avfilter.h
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1084
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:118
MovieContext::stream_specs
char * stream_specs
user-provided list of streams, separated by +
Definition: src_movie.c:65
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1302
AVPacket::stream_index
int stream_index
Definition: packet.h:375
AVFilterContext
An instance of a filter.
Definition: avfilter.h:402
MovieContext::st
MovieStream * st
array of all streams, one per output
Definition: src_movie.c:75
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
audio.h
AVFilterFormatsConfig::formats
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:506
av_get_default_channel_layout
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
Definition: channel_layout.c:231
MovieContext::dec_threads
int dec_threads
Definition: src_movie.c:70
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:350
ff_append_outpad_free_name
int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:155
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecParameters::channel_layout
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
imgutils.h
timestamp.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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:28
MovieContext::seek_point
int64_t seek_point
seekpoint in microseconds
Definition: src_movie.c:61
AVFormatContext::start_time
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1292
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
uninit
static av_cold int uninit(AVCodecContext *avctx)
Definition: crystalhd.c:282
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
MovieStream
Definition: src_movie.c:51
snprintf
#define snprintf
Definition: snprintf.h:34
OFFSET
#define OFFSET(x)
Definition: src_movie.c:80
open_stream
static int open_stream(AVFilterContext *ctx, MovieStream *st, int dec_threads)
Definition: src_movie.c:157
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:133
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2580
Generated on Wed Aug 24 2022 21:38:10 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /