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 support a PTS correction mechanism
27  */
28 
29 #include "config_components.h"
30 
31 #include <float.h>
32 #include <stdint.h>
33 
34 #include "libavutil/attributes.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/channel_layout.h"
37 #include "libavutil/opt.h"
38 #include "libavutil/imgutils.h"
39 #include "libavutil/internal.h"
40 #include "libavutil/timestamp.h"
41 
42 #include "libavcodec/avcodec.h"
43 
44 #include "libavformat/avformat.h"
45 
46 #include "audio.h"
47 #include "avfilter.h"
48 #include "filters.h"
49 #include "formats.h"
50 #include "internal.h"
51 #include "video.h"
52 
53  typedef struct MovieStream {
54   AVFilterLink *link;
55   AVStream *st;
56   AVCodecContext *codec_ctx;
57   int64_t discontinuity_threshold;
58   int64_t last_pts;
59   AVFrame *frame;
60   int eof;
61 } MovieStream;
62 
63  typedef struct MovieContext {
64  /* common A/V fields */
65   const AVClass *class;
66   int64_t seek_point; ///< seekpoint in microseconds
67   double seek_point_d;
68   char *format_name;
69   char *file_name;
70   char *stream_specs; /**< user-provided list of streams, separated by + */
71   int stream_index; /**< for compatibility */
72   int loop_count;
73   int64_t discontinuity_threshold;
74   int64_t ts_offset;
75   int dec_threads;
76 
77   AVPacket *pkt;
78   AVFormatContext *format_ctx;
79 
80   int eof;
81   int max_stream_index; /**< max stream # actually used for output */
82   MovieStream *st; /**< array of all streams, one per output */
83   int *out_index; /**< stream number -> output number map, or -1 */
84   AVDictionary *format_opts;
85 } MovieContext;
86 
87  #define OFFSET(x) offsetof(MovieContext, x)
88  #define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_VIDEO_PARAM
89 
90  static const AVOption movie_options[]= {
91  { "filename", NULL, OFFSET(file_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
92  { "format_name", "set format name", OFFSET(format_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
93  { "f", "set format name", OFFSET(format_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
94  { "stream_index", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
95  { "si", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
96  { "seek_point", "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0, (INT64_MAX-1) / 1000000, FLAGS },
97  { "sp", "set seekpoint (seconds)", OFFSET(seek_point_d), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0, (INT64_MAX-1) / 1000000, FLAGS },
98  { "streams", "set streams", OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, FLAGS },
99  { "s", "set streams", OFFSET(stream_specs), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, FLAGS },
100  { "loop", "set loop count", OFFSET(loop_count), AV_OPT_TYPE_INT, {.i64 = 1}, 0, INT_MAX, FLAGS },
101  { "discontinuity", "set discontinuity threshold", OFFSET(discontinuity_threshold), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, INT64_MAX, FLAGS },
102  { "dec_threads", "set the number of threads for decoding", OFFSET(dec_threads), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, FLAGS },
103  { "format_opts", "set format options for the opened file", OFFSET(format_opts), AV_OPT_TYPE_DICT, {.str = NULL}, 0, 0, FLAGS},
104  { NULL },
105 };
106 
107 static int movie_config_output_props(AVFilterLink *outlink);
108 
109  static AVStream *find_stream(void *log, AVFormatContext *avf, const char *spec)
110 {
111  int i, ret, already = 0, stream_id = -1;
112  char type_char[2], dummy;
113  AVStream *found = NULL;
114  enum AVMediaType type;
115 
116  ret = sscanf(spec, "d%1[av]%d%c", type_char, &stream_id, &dummy);
117  if (ret >= 1 && ret <= 2) {
118  type = type_char[0] == 'v' ? AVMEDIA_TYPE_VIDEO : AVMEDIA_TYPE_AUDIO;
119  ret = av_find_best_stream(avf, type, stream_id, -1, NULL, 0);
120  if (ret < 0) {
121  av_log(log, AV_LOG_ERROR, "No %s stream with index '%d' found\n",
122  av_get_media_type_string(type), stream_id);
123  return NULL;
124  }
125  return avf->streams[ret];
126  }
127  for (i = 0; i < avf->nb_streams; i++) {
128  ret = avformat_match_stream_specifier(avf, avf->streams[i], spec);
129  if (ret < 0) {
130  av_log(log, AV_LOG_ERROR,
131  "Invalid stream specifier \"%s\"\n", spec);
132  return NULL;
133  }
134  if (!ret)
135  continue;
136  if (avf->streams[i]->discard != AVDISCARD_ALL) {
137  already++;
138  continue;
139  }
140  if (found) {
141  av_log(log, AV_LOG_WARNING,
142  "Ambiguous stream specifier \"%s\", using #%d\n", spec, i);
143  break;
144  }
145  found = avf->streams[i];
146  }
147  if (!found) {
148  av_log(log, AV_LOG_WARNING, "Stream specifier \"%s\" %s\n", spec,
149  already ? "matched only already used streams" :
150  "did not match any stream");
151  return NULL;
152  }
153  if (found->codecpar->codec_type != AVMEDIA_TYPE_VIDEO &&
154  found->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
155  av_log(log, AV_LOG_ERROR, "Stream specifier \"%s\" matched a %s stream,"
156  "currently unsupported by libavfilter\n", spec,
157  av_get_media_type_string(found->codecpar->codec_type));
158  return NULL;
159  }
160  return found;
161 }
162 
163  static int get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
164 {
165  int linesize_align[AV_NUM_DATA_POINTERS];
166  MovieStream *st = avctx->opaque;
167  AVFilterLink *outlink = st->link;
168  int w, h, ow, oh, copy = 0;
169  AVFrame *new;
170 
171  h = oh = frame->height;
172  w = ow = frame->width;
173 
174  copy = frame->format != outlink->format;
175  switch (avctx->codec_type) {
176  case AVMEDIA_TYPE_VIDEO:
177  if (w != outlink->w || h != outlink->h)
178  copy |= 1;
179  break;
180  case AVMEDIA_TYPE_AUDIO:
181  if (outlink->sample_rate != frame->sample_rate ||
182  av_channel_layout_compare(&outlink->ch_layout, &frame->ch_layout))
183  copy |= 1;
184  break;
185  }
186 
187  if (copy || !(avctx->codec->capabilities & AV_CODEC_CAP_DR1))
188  return avcodec_default_get_buffer2(avctx, frame, flags);
189 
190  switch (avctx->codec_type) {
191  case AVMEDIA_TYPE_VIDEO:
192  avcodec_align_dimensions2(avctx, &w, &h, linesize_align);
193  new = ff_default_get_video_buffer(outlink, w, h);
194  break;
195  case AVMEDIA_TYPE_AUDIO:
196  new = ff_default_get_audio_buffer(outlink, frame->nb_samples);
197  break;
198  default:
199  return -1;
200  }
201 
202  av_frame_copy_props(new, frame);
203  av_frame_unref(frame);
204  av_frame_move_ref(frame, new);
205  av_frame_free(&new);
206 
207  frame->width = ow;
208  frame->height = oh;
209 
210  return 0;
211 }
212 
213  static int open_stream(AVFilterContext *ctx, MovieStream *st, int dec_threads)
214 {
215  const AVCodec *codec;
216  int ret;
217 
218  codec = avcodec_find_decoder(st->st->codecpar->codec_id);
219  if (!codec) {
220  av_log(ctx, AV_LOG_ERROR, "Failed to find any codec\n");
221  return AVERROR(EINVAL);
222  }
223 
224  st->codec_ctx = avcodec_alloc_context3(codec);
225  if (!st->codec_ctx)
226  return AVERROR(ENOMEM);
227 
228  st->codec_ctx->opaque = st;
229  st->codec_ctx->get_buffer2 = get_buffer;
230  ret = avcodec_parameters_to_context(st->codec_ctx, st->st->codecpar);
231  if (ret < 0)
232  return ret;
233 
234  if (!dec_threads)
235  dec_threads = ff_filter_get_nb_threads(ctx);
236  st->codec_ctx->thread_count = dec_threads;
237 
238  if ((ret = avcodec_open2(st->codec_ctx, codec, NULL)) < 0) {
239  av_log(ctx, AV_LOG_ERROR, "Failed to open codec\n");
240  return ret;
241  }
242 
243  return 0;
244 }
245 
246  static int guess_channel_layout(MovieStream *st, int st_index, void *log_ctx)
247 {
248  AVCodecParameters *dec_par = st->st->codecpar;
249  char buf[256];
250  AVChannelLayout chl = { 0 };
251 
252  av_channel_layout_default(&chl, dec_par->ch_layout.nb_channels);
253 
254  if (!KNOWN(&chl)) {
255  av_log(log_ctx, AV_LOG_WARNING,
256  "Channel layout is not set in stream %d, and could not "
257  "be guessed from the number of channels (%d)\n",
258  st_index, dec_par->ch_layout.nb_channels);
259  return av_channel_layout_copy(&dec_par->ch_layout, &chl);
260  }
261 
262  av_channel_layout_describe(&chl, buf, sizeof(buf));
263  av_log(log_ctx, AV_LOG_WARNING,
264  "Channel layout is not set in output stream %d, "
265  "guessed channel layout is '%s'\n",
266  st_index, buf);
267  return av_channel_layout_copy(&dec_par->ch_layout, &chl);
268 }
269 
270  static av_cold int movie_common_init(AVFilterContext *ctx)
271 {
272  MovieContext *movie = ctx->priv;
273  const AVInputFormat *iformat = NULL;
274  int64_t timestamp;
275  int nb_streams = 1, ret, i;
276  char default_streams[16], *stream_specs, *spec, *cursor;
277  AVStream *st;
278 
279  if (!movie->file_name) {
280  av_log(ctx, AV_LOG_ERROR, "No filename provided!\n");
281  return AVERROR(EINVAL);
282  }
283 
284  movie->seek_point = movie->seek_point_d * 1000000 + 0.5;
285 
286  stream_specs = movie->stream_specs;
287  if (!stream_specs) {
288  snprintf(default_streams, sizeof(default_streams), "d%c%d",
289  !strcmp(ctx->filter->name, "amovie") ? 'a' : 'v',
290  movie->stream_index);
291  stream_specs = default_streams;
292  }
293  for (cursor = stream_specs; *cursor; cursor++)
294  if (*cursor == '+')
295  nb_streams++;
296 
297  if (movie->loop_count != 1 && nb_streams != 1) {
298  av_log(ctx, AV_LOG_ERROR,
299  "Loop with several streams is currently unsupported\n");
300  return AVERROR_PATCHWELCOME;
301  }
302 
303  // Try to find the movie format (container)
304  iformat = movie->format_name ? av_find_input_format(movie->format_name) : NULL;
305 
306  movie->format_ctx = NULL;
307  if ((ret = avformat_open_input(&movie->format_ctx, movie->file_name, iformat, &movie->format_opts)) < 0) {
308  av_log(ctx, AV_LOG_ERROR,
309  "Failed to avformat_open_input '%s'\n", movie->file_name);
310  return ret;
311  }
312  if ((ret = avformat_find_stream_info(movie->format_ctx, NULL)) < 0)
313  av_log(ctx, AV_LOG_WARNING, "Failed to find stream info\n");
314 
315  // if seeking requested, we execute it
316  if (movie->seek_point > 0) {
317  timestamp = movie->seek_point;
318  // add the stream start time, should it exist
319  if (movie->format_ctx->start_time != AV_NOPTS_VALUE) {
320  if (timestamp > 0 && movie->format_ctx->start_time > INT64_MAX - timestamp) {
321  av_log(ctx, AV_LOG_ERROR,
322  "%s: seek value overflow with start_time:%"PRId64" seek_point:%"PRId64"\n",
323  movie->file_name, movie->format_ctx->start_time, movie->seek_point);
324  return AVERROR(EINVAL);
325  }
326  timestamp += movie->format_ctx->start_time;
327  }
328  if ((ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD)) < 0) {
329  av_log(ctx, AV_LOG_ERROR, "%s: could not seek to position %"PRId64"\n",
330  movie->file_name, timestamp);
331  return ret;
332  }
333  }
334 
335  for (i = 0; i < movie->format_ctx->nb_streams; i++)
336  movie->format_ctx->streams[i]->discard = AVDISCARD_ALL;
337 
338  movie->pkt = av_packet_alloc();
339  if (!movie->pkt)
340  return AVERROR(ENOMEM);
341  movie->st = av_calloc(nb_streams, sizeof(*movie->st));
342  if (!movie->st)
343  return AVERROR(ENOMEM);
344 
345  for (i = 0; i < nb_streams; i++) {
346  spec = av_strtok(stream_specs, "+", &cursor);
347  if (!spec)
348  return AVERROR_BUG;
349  stream_specs = NULL; /* for next strtok */
350  st = find_stream(ctx, movie->format_ctx, spec);
351  if (!st)
352  return AVERROR(EINVAL);
353  st->discard = AVDISCARD_DEFAULT;
354  movie->st[i].st = st;
355  movie->max_stream_index = FFMAX(movie->max_stream_index, st->index);
356  movie->st[i].discontinuity_threshold =
357  av_rescale_q(movie->discontinuity_threshold, AV_TIME_BASE_Q, st->time_base);
358 
359  movie->st[i].frame = av_frame_alloc();
360  if (!movie->st[i].frame)
361  return AVERROR(ENOMEM);
362  }
363  if (av_strtok(NULL, "+", &cursor))
364  return AVERROR_BUG;
365 
366  movie->out_index = av_calloc(movie->max_stream_index + 1,
367  sizeof(*movie->out_index));
368  if (!movie->out_index)
369  return AVERROR(ENOMEM);
370  for (i = 0; i <= movie->max_stream_index; i++)
371  movie->out_index[i] = -1;
372  for (i = 0; i < nb_streams; i++) {
373  AVFilterPad pad = { 0 };
374  movie->out_index[movie->st[i].st->index] = i;
375  pad.type = movie->st[i].st->codecpar->codec_type;
376  pad.name = av_asprintf("out%d", i);
377  if (!pad.name)
378  return AVERROR(ENOMEM);
379  pad.config_props = movie_config_output_props;
380  if ((ret = ff_append_outpad_free_name(ctx, &pad)) < 0)
381  return ret;
382  if ( movie->st[i].st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
383  !KNOWN(&movie->st[i].st->codecpar->ch_layout)) {
384  ret = guess_channel_layout(&movie->st[i], i, ctx);
385  if (ret < 0)
386  return ret;
387  }
388  ret = open_stream(ctx, &movie->st[i], movie->dec_threads);
389  if (ret < 0)
390  return ret;
391  }
392 
393  av_log(ctx, AV_LOG_VERBOSE, "seek_point:%"PRIi64" format_name:%s file_name:%s stream_index:%d\n",
394  movie->seek_point, movie->format_name, movie->file_name,
395  movie->stream_index);
396 
397  return 0;
398 }
399 
400  static av_cold void movie_uninit(AVFilterContext *ctx)
401 {
402  MovieContext *movie = ctx->priv;
403  int i;
404 
405  for (i = 0; i < ctx->nb_outputs; i++) {
406  if (movie->st[i].st)
407  avcodec_free_context(&movie->st[i].codec_ctx);
408  av_frame_free(&movie->st[i].frame);
409  }
410  av_packet_free(&movie->pkt);
411  av_freep(&movie->st);
412  av_freep(&movie->out_index);
413  if (movie->format_ctx)
414  avformat_close_input(&movie->format_ctx);
415 }
416 
417  static int movie_query_formats(AVFilterContext *ctx)
418 {
419  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  MovieStream *st = &movie->st[i];
426  AVCodecParameters *c = st->st->codecpar;
427  AVFilterLink *outlink = ctx->outputs[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), &outlink->incfg.formats)) < 0)
433  return ret;
434  break;
435  case AVMEDIA_TYPE_AUDIO:
436  list[0] = c->format;
437  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.formats)) < 0)
438  return ret;
439  list[0] = c->sample_rate;
440  if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.samplerates)) < 0)
441  return ret;
442  list64[0] = c->ch_layout;
443  if ((ret = ff_channel_layouts_ref(ff_make_channel_layout_list(list64),
444  &outlink->incfg.channel_layouts)) < 0)
445  return ret;
446  break;
447  }
448  }
449 
450  return 0;
451 }
452 
453  static int movie_config_output_props(AVFilterLink *outlink)
454 {
455  AVFilterContext *ctx = outlink->src;
456  MovieContext *movie = ctx->priv;
457  unsigned out_id = FF_OUTLINK_IDX(outlink);
458  MovieStream *st = &movie->st[out_id];
459  AVCodecParameters *c = st->st->codecpar;
460 
461  outlink->time_base = st->st->time_base;
462 
463  switch (c->codec_type) {
464  case AVMEDIA_TYPE_VIDEO:
465  outlink->w = c->width;
466  outlink->h = c->height;
467  outlink->frame_rate = st->st->r_frame_rate;
468  break;
469  case AVMEDIA_TYPE_AUDIO:
470  break;
471  }
472 
473  st->link = outlink;
474 
475  return 0;
476 }
477 
478  static int rewind_file(AVFilterContext *ctx)
479 {
480  MovieContext *movie = ctx->priv;
481  int64_t timestamp = movie->seek_point;
482  int ret, i;
483 
484  if (movie->format_ctx->start_time != AV_NOPTS_VALUE)
485  timestamp += movie->format_ctx->start_time;
486  ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD);
487  if (ret < 0) {
488  av_log(ctx, AV_LOG_ERROR, "Unable to loop: %s\n", av_err2str(ret));
489  movie->loop_count = 1; /* do not try again */
490  return ret;
491  }
492 
493  for (i = 0; i < ctx->nb_outputs; i++) {
494  avcodec_flush_buffers(movie->st[i].codec_ctx);
495  }
496  return 0;
497 }
498 
499  static int flush_decoder(AVFilterContext *ctx, int i)
500 {
501  MovieContext *movie = ctx->priv;
502  AVCodecContext *dec = movie->st[i].codec_ctx;
503 
504  return avcodec_send_packet(dec, NULL);
505 }
506 
507  static int decode_packet(AVFilterContext *ctx, int i)
508 {
509  AVFilterLink *outlink = ctx->outputs[i];
510  MovieContext *movie = ctx->priv;
511  MovieStream *st = &movie->st[i];
512  AVCodecContext *dec = movie->st[i].codec_ctx;
513  AVFrame *frame = movie->st[i].frame;
514  AVPacket *pkt = movie->pkt;
515  int ret = 0;
516 
517  // submit the packet to the decoder
518  if (!movie->eof) {
519  ret = avcodec_send_packet(dec, pkt);
520  if (ret < 0)
521  return ret;
522  }
523 
524  // get all the available frames from the decoder
525  if (ret >= 0) {
526  ret = avcodec_receive_frame(dec, frame);
527  if (ret < 0) {
528  // those two return values are special and mean there is no output
529  // frame available, but there were no errors during decoding
530  if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN))
531  return 0;
532  return ret;
533  }
534 
535  frame->pts = frame->best_effort_timestamp;
536  if (frame->pts != AV_NOPTS_VALUE) {
537  if (movie->ts_offset)
538  frame->pts += av_rescale_q_rnd(movie->ts_offset, AV_TIME_BASE_Q, outlink->time_base, AV_ROUND_UP);
539  if (st->discontinuity_threshold) {
540  if (st->last_pts != AV_NOPTS_VALUE) {
541  int64_t diff = frame->pts - st->last_pts;
542  if (diff < 0 || diff > st->discontinuity_threshold) {
543  av_log(ctx, AV_LOG_VERBOSE, "Discontinuity in stream:%d diff:%"PRId64"\n", i, diff);
544  movie->ts_offset += av_rescale_q_rnd(-diff, outlink->time_base, AV_TIME_BASE_Q, AV_ROUND_UP);
545  frame->pts -= diff;
546  }
547  }
548  }
549  st->last_pts = frame->pts;
550  }
551  ret = ff_filter_frame(outlink, av_frame_clone(frame));
552  if (ret < 0)
553  return ret;
554  if (ret == 0)
555  return 1;
556  }
557 
558  return 0;
559 }
560 
561  static int activate(AVFilterContext *ctx)
562 {
563  MovieContext *movie = ctx->priv;
564  int wanted = 0, ret;
565 
566  for (int i = 0; i < ctx->nb_outputs; i++) {
567  if (ff_outlink_frame_wanted(ctx->outputs[i]))
568  wanted++;
569  }
570 
571  if (wanted == 0)
572  return FFERROR_NOT_READY;
573 
574  if (!movie->eof) {
575  ret = av_read_frame(movie->format_ctx, movie->pkt);
576  if (ret < 0) {
577  movie->eof = 1;
578  for (int i = 0; i < ctx->nb_outputs; i++)
579  flush_decoder(ctx, i);
580  ff_filter_set_ready(ctx, 100);
581  return 0;
582  } else {
583  int pkt_out_id = movie->pkt->stream_index > movie->max_stream_index ? -1 :
584  movie->out_index[movie->pkt->stream_index];
585 
586  if (pkt_out_id >= 0) {
587  ret = decode_packet(ctx, pkt_out_id);
588  }
589  av_packet_unref(movie->pkt);
590  ff_filter_set_ready(ctx, 100);
591  return (ret <= 0) ? ret : 0;
592  }
593  } else {
594  int nb_eofs = 0;
595 
596  for (int i = 0; i < ctx->nb_outputs; i++) {
597  if (!movie->st[i].eof) {
598  ret = decode_packet(ctx, i);
599  if (ret <= 0)
600  movie->st[i].eof = 1;
601  }
602  nb_eofs += movie->st[i].eof == 1;
603  }
604  if (nb_eofs == ctx->nb_outputs && movie->loop_count != 1) {
605  ret = rewind_file(ctx);
606  if (ret < 0)
607  return ret;
608  movie->loop_count -= movie->loop_count > 1;
609  av_log(ctx, AV_LOG_VERBOSE, "Stream finished, looping.\n");
610  ff_filter_set_ready(ctx, 100);
611  for (int i = 0; i < ctx->nb_outputs; i++)
612  movie->st[i].eof = 0;
613  movie->eof = 0;
614  return 0;
615  } else {
616  for (int i = 0; i < ctx->nb_outputs; i++) {
617  if (movie->st[i].eof) {
618  ff_outlink_set_status(ctx->outputs[i], AVERROR_EOF, movie->st[i].last_pts);
619  nb_eofs++;
620  }
621  }
622  }
623 
624  if (nb_eofs < ctx->nb_outputs)
625  ff_filter_set_ready(ctx, 100);
626  return 0;
627  }
628 
629  return FFERROR_NOT_READY;
630 }
631 
632  static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
633  char *res, int res_len, int flags)
634 {
635  MovieContext *movie = ctx->priv;
636  int ret = AVERROR(ENOSYS);
637 
638  if (!strcmp(cmd, "seek")) {
639  int idx, flags, i;
640  int64_t ts;
641  char tail[2];
642 
643  if (sscanf(args, "%i|%"SCNi64"|%i %1s", &idx, &ts, &flags, tail) != 3)
644  return AVERROR(EINVAL);
645 
646  ret = av_seek_frame(movie->format_ctx, idx, ts, flags);
647  if (ret < 0)
648  return ret;
649 
650  for (i = 0; i < ctx->nb_outputs; i++) {
651  avcodec_flush_buffers(movie->st[i].codec_ctx);
652  }
653  return ret;
654  } else if (!strcmp(cmd, "get_duration")) {
655  int print_len;
656  char tail[2];
657 
658  if (!res || res_len <= 0)
659  return AVERROR(EINVAL);
660 
661  if (args && sscanf(args, "%1s", tail) == 1)
662  return AVERROR(EINVAL);
663 
664  print_len = snprintf(res, res_len, "%"PRId64, movie->format_ctx->duration);
665  if (print_len < 0 || print_len >= res_len)
666  return AVERROR(EINVAL);
667 
668  return 0;
669  }
670 
671  return ret;
672 }
673 
674 AVFILTER_DEFINE_CLASS_EXT(movie, "(a)movie", movie_options);
675 
676 #if CONFIG_MOVIE_FILTER
677 
678 const AVFilter ff_avsrc_movie = {
679  .name = "movie",
680  .description = NULL_IF_CONFIG_SMALL("Read from a movie source."),
681  .priv_size = sizeof(MovieContext),
682  .priv_class = &movie_class,
683  .init = movie_common_init,
684  .activate = activate,
685  .uninit = movie_uninit,
686  FILTER_QUERY_FUNC(movie_query_formats),
687 
688  .inputs = NULL,
689  .outputs = NULL,
690  .flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
691  .process_command = process_command
692 };
693 
694 #endif /* CONFIG_MOVIE_FILTER */
695 
696 #if CONFIG_AMOVIE_FILTER
697 
698 const AVFilter ff_avsrc_amovie = {
699  .name = "amovie",
700  .description = NULL_IF_CONFIG_SMALL("Read audio from a movie source."),
701  .priv_class = &movie_class,
702  .priv_size = sizeof(MovieContext),
703  .init = movie_common_init,
704  .activate = activate,
705  .uninit = movie_uninit,
706  FILTER_QUERY_FUNC(movie_query_formats),
707 
708  .inputs = NULL,
709  .outputs = NULL,
710  .flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
711  .process_command = process_command,
712 };
713 
714 #endif /* CONFIG_AMOVIE_FILTER */
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:427
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:134
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:435
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: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: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:814
MovieContext::eof
int eof
Definition: src_movie.c:80
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:71
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
FLAGS
#define FLAGS
Definition: src_movie.c:88
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:130
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:344
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1323
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:456
AVFrame::width
int width
Definition: frame.h:416
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:206
w
uint8_t w
Definition: llviddspenc.c:38
AVOption
AVOption.
Definition: opt.h:346
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:159
format_opts
AVDictionary * format_opts
Definition: cmdutils.c:61
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Definition: opt.h:249
MovieStream::link
AVFilterLink * link
Definition: src_movie.c:54
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:90
MovieStream::eof
int eof
Definition: src_movie.c:60
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:1525
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:246
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.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:632
formats.h
MovieContext::out_index
int * out_index
stream number -> output number map, or -1
Definition: src_movie.c:83
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:362
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:69
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:454
decode_packet
static int decode_packet(AVFilterContext *ctx, int i)
Definition: src_movie.c:507
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1582
MovieStream::frame
AVFrame * frame
Definition: src_movie.c:59
dummy
int dummy
Definition: motion.c:66
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:745
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
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:118
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:59
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:214
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:639
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:237
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
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:681
MovieContext::ts_offset
int64_t ts_offset
Definition: src_movie.c:74
filters.h
ctx
AVFormatContext * ctx
Definition: movenc.c:48
get_buffer
static int get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Definition: src_movie.c:163
nb_streams
static int nb_streams
Definition: ffprobe.c:383
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:563
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:78
MovieContext
Definition: src_movie.c:63
find_stream
static AVStream * find_stream(void *log, AVFormatContext *avf, const char *spec)
Definition: src_movie.c:109
frame
static AVFrame * frame
Definition: demux_decode.c:54
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:2433
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:679
MovieStream::discontinuity_threshold
int64_t discontinuity_threshold
Definition: src_movie.c:57
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:73
AVFILTER_DEFINE_CLASS_EXT
AVFILTER_DEFINE_CLASS_EXT(movie, "(a)movie", movie_options)
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:242
MovieStream::last_pts
int64_t last_pts
Definition: src_movie.c:58
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:128
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
MovieStream::codec_ctx
AVCodecContext * codec_ctx
Definition: src_movie.c:56
MovieContext::format_name
char * format_name
Definition: src_movie.c:68
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:55
MovieContext::seek_point_d
double seek_point_d
Definition: src_movie.c:67
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:971
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
AVFrame::best_effort_timestamp
int64_t best_effort_timestamp
frame timestamp estimated using various heuristics, in stream time base
Definition: frame.h:643
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:2499
movie_common_init
static av_cold int movie_common_init(AVFilterContext *ctx)
Definition: src_movie.c:270
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
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:417
movie_uninit
static av_cold void movie_uninit(AVFilterContext *ctx)
Definition: src_movie.c:400
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:106
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:185
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:121
AVFrame::sample_rate
int sample_rate
Sample rate of the audio data.
Definition: frame.h:543
MovieContext::loop_count
int loop_count
Definition: src_movie.c:72
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:345
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:431
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:164
attributes.h
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:63
MovieContext::pkt
AVPacket * pkt
Definition: src_movie.c:77
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:84
internal.h
iformat
static const AVInputFormat * iformat
Definition: ffprobe.c:359
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:675
uninit
static void uninit(AVBSFContext *ctx)
Definition: pcm_rechunk.c:68
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:424
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
rewind_file
static int rewind_file(AVFilterContext *ctx)
Definition: src_movie.c:478
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:825
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:603
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:576
MovieContext::max_stream_index
int max_stream_index
max stream # actually used for output
Definition: src_movie.c:81
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:262
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:350
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:561
movie_config_output_props
static int movie_config_output_props(AVFilterLink *outlink)
Definition: src_movie.c:453
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
AVFrame::height
int height
Definition: frame.h:416
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:1948
channel_layout.h
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
avfilter.h
flush_decoder
static int flush_decoder(AVFilterContext *ctx, int i)
Definition: src_movie.c:499
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:145
MovieContext::stream_specs
char * stream_specs
user-provided list of streams, separated by +
Definition: src_movie.c:70
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:524
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:439
MovieContext::st
MovieStream * st
array of all streams, one per output
Definition: src_movie.c:82
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:453
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:75
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:499
ff_append_outpad_free_name
int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:142
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:444
imgutils.h
timestamp.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
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:66
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:239
MovieStream
Definition: src_movie.c:53
snprintf
#define snprintf
Definition: snprintf.h:34
OFFSET
#define OFFSET(x)
Definition: src_movie.c:87
open_stream
static int open_stream(AVFilterContext *ctx, MovieStream *st, int dec_threads)
Definition: src_movie.c:213
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:234
Generated on Thu Sep 26 2024 23:15:34 for FFmpeg by   doxygen 1.8.17

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