FFmpeg
demux.c
Go to the documentation of this file.
1 /*
2  * Core demuxing component
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
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 #include <stdint.h>
23 
24 #include "config_components.h"
25 
26 #include "libavutil/avassert.h"
27 #include "libavutil/avstring.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/mem.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/pixfmt.h"
35 #include "libavutil/time.h"
36 #include "libavutil/timestamp.h"
37 
38 #include "libavcodec/avcodec.h"
39 #include "libavcodec/bsf.h"
40 #include "libavcodec/codec_desc.h"
41 #include "libavcodec/internal.h"
43 #include "libavcodec/raw.h"
44 
45 #include "avformat.h"
46 #include "avio_internal.h"
47 #include "demux.h"
48 #include "id3v2.h"
49 #include "internal.h"
50 #include "url.h"
51 
52 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
53 {
54  const FFStream *const sti = cffstream(st);
55  if (sti->pts_wrap_behavior != AV_PTS_WRAP_IGNORE && st->pts_wrap_bits < 64 &&
56  sti->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
58  timestamp < sti->pts_wrap_reference)
59  return timestamp + (1ULL << st->pts_wrap_bits);
60  else if (sti->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
61  timestamp >= sti->pts_wrap_reference)
62  return timestamp - (1ULL << st->pts_wrap_bits);
63  }
64  return timestamp;
65 }
66 
67 int64_t ff_wrap_timestamp(const AVStream *st, int64_t timestamp)
68 {
69  return wrap_timestamp(st, timestamp);
70 }
71 
73 {
74  const AVCodec *codec;
75 
76 #if CONFIG_H264_DECODER
77  /* Other parts of the code assume this decoder to be used for h264,
78  * so force it if possible. */
80  return avcodec_find_decoder_by_name("h264");
81 #endif
82 
83  codec = ff_find_decoder(s, st, codec_id);
84  if (!codec)
85  return NULL;
86 
88  const AVCodec *probe_codec = NULL;
89  void *iter = NULL;
90  while ((probe_codec = av_codec_iterate(&iter))) {
91  if (probe_codec->id == codec->id &&
94  return probe_codec;
95  }
96  }
97  }
98 
99  return codec;
100 }
101 
103  AVProbeData *pd)
104 {
105  static const struct {
106  const char *name;
107  enum AVCodecID id;
108  enum AVMediaType type;
109  } fmt_id_type[] = {
121  { "mjpeg_2000", AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
123  { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
124  { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
127  { 0 }
128  };
129  int score;
130  const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
131  FFStream *const sti = ffstream(st);
132 
133  if (fmt) {
135  "Probe with size=%d, packets=%d detected %s with score=%d\n",
136  pd->buf_size, s->max_probe_packets - sti->probe_packets,
137  fmt->name, score);
138  for (int i = 0; fmt_id_type[i].name; i++) {
139  if (!strcmp(fmt->name, fmt_id_type[i].name)) {
140  if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
141  st->codecpar->sample_rate)
142  continue;
143  if (sti->request_probe > score &&
144  st->codecpar->codec_id != fmt_id_type[i].id)
145  continue;
146  st->codecpar->codec_id = fmt_id_type[i].id;
147  st->codecpar->codec_type = fmt_id_type[i].type;
148  sti->need_context_update = 1;
149  return score;
150  }
151  }
152  }
153  return 0;
154 }
155 
156 static int init_input(AVFormatContext *s, const char *filename,
158 {
159  int ret;
160  AVProbeData pd = { filename, NULL, 0 };
161  int score = AVPROBE_SCORE_RETRY;
162 
163  if (s->pb) {
164  s->flags |= AVFMT_FLAG_CUSTOM_IO;
165  if (!s->iformat)
166  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
167  s, 0, s->format_probesize);
168  else if (s->iformat->flags & AVFMT_NOFILE)
169  av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
170  "will be ignored with AVFMT_NOFILE format.\n");
171  return 0;
172  }
173 
174  if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
175  (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
176  return score;
177 
178  if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
179  return ret;
180 
181  if (s->iformat)
182  return 0;
183  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
184  s, 0, s->format_probesize);
185 }
186 
188 {
189  int ret;
190  for (unsigned i = 0; i < s->nb_streams; i++) {
191  AVStream *const st = s->streams[i];
192  FFStream *const sti = ffstream(st);
193 
194  if (!sti->need_context_update)
195  continue;
196 
197  /* close parser, because it depends on the codec */
198  if (sti->parser && sti->avctx->codec_id != st->codecpar->codec_id) {
199  av_parser_close(sti->parser);
200  sti->parser = NULL;
201  }
202 
203  /* update internal codec context, for the parser */
205  if (ret < 0)
206  return ret;
207 
209 
210  sti->need_context_update = 0;
211  }
212  return 0;
213 }
214 
215 int avformat_open_input(AVFormatContext **ps, const char *filename,
216  const AVInputFormat *fmt, AVDictionary **options)
217 {
218  AVFormatContext *s = *ps;
219  FFFormatContext *si;
220  AVDictionary *tmp = NULL;
221  ID3v2ExtraMeta *id3v2_extra_meta = NULL;
222  int ret = 0;
223 
224  if (!s && !(s = avformat_alloc_context()))
225  return AVERROR(ENOMEM);
226  si = ffformatcontext(s);
227  if (!s->av_class) {
228  av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
229  return AVERROR(EINVAL);
230  }
231  if (fmt)
232  s->iformat = fmt;
233 
234  if (options)
235  av_dict_copy(&tmp, *options, 0);
236 
237  if (s->pb) // must be before any goto fail
238  s->flags |= AVFMT_FLAG_CUSTOM_IO;
239 
240  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
241  goto fail;
242 
243  if (!(s->url = av_strdup(filename ? filename : ""))) {
244  ret = AVERROR(ENOMEM);
245  goto fail;
246  }
247 
248  if ((ret = init_input(s, filename, &tmp)) < 0)
249  goto fail;
250  s->probe_score = ret;
251 
252  if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
253  s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
254  if (!s->protocol_whitelist) {
255  ret = AVERROR(ENOMEM);
256  goto fail;
257  }
258  }
259 
260  if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
261  s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
262  if (!s->protocol_blacklist) {
263  ret = AVERROR(ENOMEM);
264  goto fail;
265  }
266  }
267 
268  if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
269  av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
270  ret = AVERROR(EINVAL);
271  goto fail;
272  }
273 
274  avio_skip(s->pb, s->skip_initial_bytes);
275 
276  /* Check filename in case an image number is expected. */
277  if (s->iformat->flags & AVFMT_NEEDNUMBER) {
278  if (!av_filename_number_test(filename)) {
279  ret = AVERROR(EINVAL);
280  goto fail;
281  }
282  }
283 
284  s->duration = s->start_time = AV_NOPTS_VALUE;
285 
286  /* Allocate private data. */
287  if (ffifmt(s->iformat)->priv_data_size > 0) {
288  if (!(s->priv_data = av_mallocz(ffifmt(s->iformat)->priv_data_size))) {
289  ret = AVERROR(ENOMEM);
290  goto fail;
291  }
292  if (s->iformat->priv_class) {
293  *(const AVClass **) s->priv_data = s->iformat->priv_class;
294  av_opt_set_defaults(s->priv_data);
295  if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
296  goto fail;
297  }
298  }
299 
300  /* e.g. AVFMT_NOFILE formats will not have an AVIOContext */
301  if (s->pb)
302  ff_id3v2_read_dict(s->pb, &si->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
303 
304  if (ffifmt(s->iformat)->read_header)
305  if ((ret = ffifmt(s->iformat)->read_header(s)) < 0) {
307  goto close;
308  goto fail;
309  }
310 
311  if (!s->metadata) {
312  s->metadata = si->id3v2_meta;
313  si->id3v2_meta = NULL;
314  } else if (si->id3v2_meta) {
315  av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
316  av_dict_free(&si->id3v2_meta);
317  }
318 
319  if (id3v2_extra_meta) {
320  if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
321  !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
322  if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
323  goto close;
324  if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
325  goto close;
326  if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
327  goto close;
328  } else
329  av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
330  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
331  }
332 
334  goto close;
335 
336  if (s->pb && !si->data_offset)
337  si->data_offset = avio_tell(s->pb);
338 
339  si->raw_packet_buffer_size = 0;
340 
342 
343  if (options) {
345  *options = tmp;
346  }
347  *ps = s;
348  return 0;
349 
350 close:
351  if (ffifmt(s->iformat)->read_close)
352  ffifmt(s->iformat)->read_close(s);
353 fail:
354  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
355  av_dict_free(&tmp);
356  if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
357  avio_closep(&s->pb);
359  *ps = NULL;
360  return ret;
361 }
362 
364 {
366  AVIOContext *pb;
367 
368  if (!ps || !*ps)
369  return;
370 
371  s = *ps;
372  pb = s->pb;
373 
374  if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
375  (s->flags & AVFMT_FLAG_CUSTOM_IO))
376  pb = NULL;
377 
378  if (s->iformat)
379  if (ffifmt(s->iformat)->read_close)
380  ffifmt(s->iformat)->read_close(s);
381 
383 
384  *ps = NULL;
385 
386  avio_close(pb);
387 }
388 
390 {
391  switch (st->codecpar->codec_type) {
392  case AVMEDIA_TYPE_VIDEO:
393  if (s->video_codec_id)
394  st->codecpar->codec_id = s->video_codec_id;
395  break;
396  case AVMEDIA_TYPE_AUDIO:
397  if (s->audio_codec_id)
398  st->codecpar->codec_id = s->audio_codec_id;
399  break;
401  if (s->subtitle_codec_id)
402  st->codecpar->codec_id = s->subtitle_codec_id;
403  break;
404  case AVMEDIA_TYPE_DATA:
405  if (s->data_codec_id)
406  st->codecpar->codec_id = s->data_codec_id;
407  break;
408  }
409 }
410 
412 {
413  FFFormatContext *const si = ffformatcontext(s);
414  FFStream *const sti = ffstream(st);
415 
416  if (sti->request_probe > 0) {
417  AVProbeData *const pd = &sti->probe_data;
418  int end;
419  av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, sti->probe_packets);
420  --sti->probe_packets;
421 
422  if (pkt) {
423  uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
424  if (!new_buf) {
426  "Failed to reallocate probe buffer for stream %d\n",
427  st->index);
428  goto no_packet;
429  }
430  pd->buf = new_buf;
431  memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
432  pd->buf_size += pkt->size;
433  memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
434  } else {
435 no_packet:
436  sti->probe_packets = 0;
437  if (!pd->buf_size) {
439  "nothing to probe for stream %d\n", st->index);
440  }
441  }
442 
443  end = si->raw_packet_buffer_size >= s->probesize
444  || sti->probe_packets <= 0;
445 
446  if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
447  int score = set_codec_from_probe_data(s, st, pd);
449  || end) {
450  pd->buf_size = 0;
451  av_freep(&pd->buf);
452  sti->request_probe = -1;
453  if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
454  av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
455  } else
456  av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
457  }
458  force_codec_ids(s, st);
459  }
460  }
461  return 0;
462 }
463 
464 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
465 {
466  FFStream *const sti = ffstream(st);
467  int64_t ref = pkt->dts;
468  int pts_wrap_behavior;
469  int64_t pts_wrap_reference;
470  AVProgram *first_program;
471 
472  if (ref == AV_NOPTS_VALUE)
473  ref = pkt->pts;
474  if (sti->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
475  return 0;
476  ref &= (1LL << st->pts_wrap_bits)-1;
477 
478  // reference time stamp should be 60 s before first time stamp
479  pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
480  // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
481  pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
482  (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
484 
485  first_program = av_find_program_from_stream(s, NULL, stream_index);
486 
487  if (!first_program) {
488  int default_stream_index = av_find_default_stream_index(s);
489  FFStream *const default_sti = ffstream(s->streams[default_stream_index]);
490  if (default_sti->pts_wrap_reference == AV_NOPTS_VALUE) {
491  for (unsigned i = 0; i < s->nb_streams; i++) {
492  FFStream *const sti = ffstream(s->streams[i]);
494  continue;
495  sti->pts_wrap_reference = pts_wrap_reference;
496  sti->pts_wrap_behavior = pts_wrap_behavior;
497  }
498  } else {
499  sti->pts_wrap_reference = default_sti->pts_wrap_reference;
500  sti->pts_wrap_behavior = default_sti->pts_wrap_behavior;
501  }
502  } else {
503  AVProgram *program = first_program;
504  while (program) {
505  if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
506  pts_wrap_reference = program->pts_wrap_reference;
507  pts_wrap_behavior = program->pts_wrap_behavior;
508  break;
509  }
510  program = av_find_program_from_stream(s, program, stream_index);
511  }
512 
513  // update every program with differing pts_wrap_reference
514  program = first_program;
515  while (program) {
516  if (program->pts_wrap_reference != pts_wrap_reference) {
517  for (unsigned i = 0; i < program->nb_stream_indexes; i++) {
518  FFStream *const sti = ffstream(s->streams[program->stream_index[i]]);
519  sti->pts_wrap_reference = pts_wrap_reference;
520  sti->pts_wrap_behavior = pts_wrap_behavior;
521  }
522 
523  program->pts_wrap_reference = pts_wrap_reference;
524  program->pts_wrap_behavior = pts_wrap_behavior;
525  }
526  program = av_find_program_from_stream(s, program, stream_index);
527  }
528  }
529  return 1;
530 }
531 
533 {
534  FFStream *const sti = ffstream(st);
535 
537  // correct first time stamps to negative values
538  if (!is_relative(sti->first_dts))
539  sti->first_dts = wrap_timestamp(st, sti->first_dts);
540  if (!is_relative(st->start_time))
541  st->start_time = wrap_timestamp(st, st->start_time);
542  if (!is_relative(sti->cur_dts))
543  sti->cur_dts = wrap_timestamp(st, sti->cur_dts);
544  }
545 
546  pkt->dts = wrap_timestamp(st, pkt->dts);
547  pkt->pts = wrap_timestamp(st, pkt->pts);
548 
549  force_codec_ids(s, st);
550 
551  /* TODO: audio: time filter; video: frame reordering (pts != dts) */
552  if (s->use_wallclock_as_timestamps)
554 }
555 
556 /**
557  * Handle a new packet and either return it directly if possible and
558  * allow_passthrough is true or queue the packet (or drop the packet
559  * if corrupt).
560  *
561  * @return < 0 on error, 0 if the packet was passed through,
562  * 1 if it was queued or dropped
563  */
564 static int handle_new_packet(AVFormatContext *s, AVPacket *pkt, int allow_passthrough)
565 {
566  FFFormatContext *const si = ffformatcontext(s);
567  AVStream *st;
568  FFStream *sti;
569  int err;
570 
571  av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
572  "Invalid stream index.\n");
573 
574  if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
576  "Packet corrupt (stream = %d, dts = %s)%s.\n",
578  s->flags & AVFMT_FLAG_DISCARD_CORRUPT ? ", dropping it" : "");
579  if (s->flags & AVFMT_FLAG_DISCARD_CORRUPT) {
581  return 1;
582  }
583  }
584 
585  st = s->streams[pkt->stream_index];
586  sti = ffstream(st);
587 
588  update_timestamps(s, st, pkt);
589 
590  if (sti->request_probe <= 0 && allow_passthrough && !si->raw_packet_buffer.head)
591  return 0;
592 
594  if (err < 0) {
596  return err;
597  }
598 
599  pkt = &si->raw_packet_buffer.tail->pkt;
601 
602  err = probe_codec(s, st, pkt);
603  if (err < 0)
604  return err;
605 
606  return 1;
607 }
608 
610 {
611  int err = handle_new_packet(s, pkt, 0);
612 
613  return err < 0 ? err : 0;
614 }
615 
617 {
618  FFFormatContext *const si = ffformatcontext(s);
619  int err;
620 
621 #if FF_API_INIT_PACKET
623  pkt->data = NULL;
624  pkt->size = 0;
625  av_init_packet(pkt);
627 #else
629 #endif
630 
631  for (;;) {
633 
634  if (pktl) {
635  AVStream *const st = s->streams[pktl->pkt.stream_index];
636  if (si->raw_packet_buffer_size >= s->probesize)
637  if ((err = probe_codec(s, st, NULL)) < 0)
638  return err;
639  if (ffstream(st)->request_probe <= 0) {
642  return 0;
643  }
644  }
645 
646  err = ffifmt(s->iformat)->read_packet(s, pkt);
647  if (err < 0) {
649 
650  /* Some demuxers return FFERROR_REDO when they consume
651  data and discard it (ignored streams, junk, extradata).
652  We must re-call the demuxer to get the real packet. */
653  if (err == FFERROR_REDO)
654  continue;
655  if (!pktl || err == AVERROR(EAGAIN))
656  return err;
657  for (unsigned i = 0; i < s->nb_streams; i++) {
658  AVStream *const st = s->streams[i];
659  FFStream *const sti = ffstream(st);
660  if (sti->probe_packets || sti->request_probe > 0)
661  if ((err = probe_codec(s, st, NULL)) < 0)
662  return err;
663  av_assert0(sti->request_probe <= 0);
664  }
665  continue;
666  }
667 
669  if (err < 0) {
671  return err;
672  }
673 
674  err = handle_new_packet(s, pkt, 1);
675  if (err <= 0) /* Error or passthrough */
676  return err;
677  }
678 }
679 
680 /**
681  * Return the frame duration in seconds. Return 0 if not available.
682  */
683 static void compute_frame_duration(AVFormatContext *s, int *pnum, int *pden,
685  AVPacket *pkt)
686 {
687  FFStream *const sti = ffstream(st);
688  AVRational codec_framerate = sti->avctx->framerate;
689  int frame_size, sample_rate;
690 
691  *pnum = 0;
692  *pden = 0;
693  switch (st->codecpar->codec_type) {
694  case AVMEDIA_TYPE_VIDEO:
695  if (st->r_frame_rate.num && (!pc || !codec_framerate.num)) {
696  *pnum = st->r_frame_rate.den;
697  *pden = st->r_frame_rate.num;
698  } else if ((s->iformat->flags & AVFMT_NOTIMESTAMPS) &&
699  !codec_framerate.num &&
700  st->avg_frame_rate.num && st->avg_frame_rate.den) {
701  *pnum = st->avg_frame_rate.den;
702  *pden = st->avg_frame_rate.num;
703  } else if (st->time_base.num * 1000LL > st->time_base.den) {
704  *pnum = st->time_base.num;
705  *pden = st->time_base.den;
706  } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
707  int ticks_per_frame = (sti->codec_desc &&
708  (sti->codec_desc->props & AV_CODEC_PROP_FIELDS)) ? 2 : 1;
709  av_reduce(pnum, pden,
710  codec_framerate.den,
711  codec_framerate.num * (int64_t)ticks_per_frame,
712  INT_MAX);
713 
714  if (pc && pc->repeat_pict) {
715  av_reduce(pnum, pden,
716  (*pnum) * (1LL + pc->repeat_pict),
717  (*pden),
718  INT_MAX);
719  }
720  /* If this codec can be interlaced or progressive then we need
721  * a parser to compute duration of a packet. Thus if we have
722  * no parser in such case leave duration undefined. */
723  if (sti->codec_desc &&
724  (sti->codec_desc->props & AV_CODEC_PROP_FIELDS) && !pc)
725  *pnum = *pden = 0;
726  }
727  break;
728  case AVMEDIA_TYPE_AUDIO:
729  if (sti->avctx_inited) {
731  sample_rate = sti->avctx->sample_rate;
732  } else {
735  }
736  if (frame_size <= 0 || sample_rate <= 0)
737  break;
738  *pnum = frame_size;
739  *pden = sample_rate;
740  break;
741  default:
742  break;
743  }
744 }
745 
747 {
748  FFStream *const sti = ffstream(st);
749  if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
750  if (!sti->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
751  return 1;
752 #if CONFIG_H264_DECODER
753  if (sti->avctx->has_b_frames &&
755  return 1;
756 #endif
757  if (sti->avctx->has_b_frames < 3)
758  return sti->nb_decoded_frames >= 7;
759  else if (sti->avctx->has_b_frames < 4)
760  return sti->nb_decoded_frames >= 18;
761  else
762  return sti->nb_decoded_frames >= 20;
763 }
764 
766  PacketListEntry *pktl)
767 {
768  FFFormatContext *const si = ffformatcontext(s);
769  if (pktl->next)
770  return pktl->next;
771  if (pktl == si->packet_buffer.tail)
772  return si->parse_queue.head;
773  return NULL;
774 }
775 
776 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts)
777 {
778  FFStream *const sti = ffstream(st);
779  int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
782 
783  if (!onein_oneout) {
784  int delay = sti->avctx->has_b_frames;
785 
786  if (dts == AV_NOPTS_VALUE) {
787  int64_t best_score = INT64_MAX;
788  for (int i = 0; i < delay; i++) {
789  if (sti->pts_reorder_error_count[i]) {
790  int64_t score = sti->pts_reorder_error[i] / sti->pts_reorder_error_count[i];
791  if (score < best_score) {
792  best_score = score;
793  dts = pts_buffer[i];
794  }
795  }
796  }
797  } else {
798  for (int i = 0; i < delay; i++) {
799  if (pts_buffer[i] != AV_NOPTS_VALUE) {
800  int64_t diff = FFABS(pts_buffer[i] - dts)
801  + (uint64_t)sti->pts_reorder_error[i];
802  diff = FFMAX(diff, sti->pts_reorder_error[i]);
803  sti->pts_reorder_error[i] = diff;
804  sti->pts_reorder_error_count[i]++;
805  if (sti->pts_reorder_error_count[i] > 250) {
806  sti->pts_reorder_error[i] >>= 1;
807  sti->pts_reorder_error_count[i] >>= 1;
808  }
809  }
810  }
811  }
812  }
813 
814  if (dts == AV_NOPTS_VALUE)
815  dts = pts_buffer[0];
816 
817  return dts;
818 }
819 
820 /**
821  * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
822  * of the packets in a window.
823  */
824 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
825  PacketListEntry *pkt_buffer)
826 {
827  AVStream *const st = s->streams[stream_index];
828  int delay = ffstream(st)->avctx->has_b_frames;
829 
830  int64_t pts_buffer[MAX_REORDER_DELAY+1];
831 
832  for (int i = 0; i < MAX_REORDER_DELAY + 1; i++)
833  pts_buffer[i] = AV_NOPTS_VALUE;
834 
835  for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
836  if (pkt_buffer->pkt.stream_index != stream_index)
837  continue;
838 
839  if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
840  pts_buffer[0] = pkt_buffer->pkt.pts;
841  for (int i = 0; i < delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
842  FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
843 
844  pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
845  }
846  }
847 }
848 
849 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
850  int64_t dts, int64_t pts, AVPacket *pkt)
851 {
852  FFFormatContext *const si = ffformatcontext(s);
853  AVStream *const st = s->streams[stream_index];
854  FFStream *const sti = ffstream(st);
856 
857  uint64_t shift;
858 
859  if (sti->first_dts != AV_NOPTS_VALUE ||
860  dts == AV_NOPTS_VALUE ||
861  sti->cur_dts == AV_NOPTS_VALUE ||
862  sti->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
863  dts < INT_MIN + (sti->cur_dts - RELATIVE_TS_BASE) ||
864  is_relative(dts))
865  return;
866 
867  sti->first_dts = dts - (sti->cur_dts - RELATIVE_TS_BASE);
868  sti->cur_dts = dts;
869  shift = (uint64_t)sti->first_dts - RELATIVE_TS_BASE;
870 
871  if (is_relative(pts))
872  pts += shift;
873 
874  for (PacketListEntry *pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
875  if (pktl_it->pkt.stream_index != stream_index)
876  continue;
877  if (is_relative(pktl_it->pkt.pts))
878  pktl_it->pkt.pts += shift;
879 
880  if (is_relative(pktl_it->pkt.dts))
881  pktl_it->pkt.dts += shift;
882 
883  if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
884  st->start_time = pktl_it->pkt.pts;
886  st->start_time = av_sat_add64(st->start_time, av_rescale_q(sti->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
887  }
888  }
889 
891  update_dts_from_pts(s, stream_index, pktl);
892 
893  if (st->start_time == AV_NOPTS_VALUE) {
895  st->start_time = pts;
896  }
898  st->start_time = av_sat_add64(st->start_time, av_rescale_q(sti->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
899  }
900 }
901 
903  int stream_index, int64_t duration)
904 {
905  FFFormatContext *const si = ffformatcontext(s);
906  FFStream *const sti = ffstream(st);
908  int64_t cur_dts = RELATIVE_TS_BASE;
909 
910  if (sti->first_dts != AV_NOPTS_VALUE) {
912  return;
914  cur_dts = sti->first_dts;
915  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
916  if (pktl->pkt.stream_index == stream_index) {
917  if (pktl->pkt.pts != pktl->pkt.dts ||
918  pktl->pkt.dts != AV_NOPTS_VALUE ||
919  pktl->pkt.duration)
920  break;
921  cur_dts -= duration;
922  }
923  }
924  if (pktl && pktl->pkt.dts != sti->first_dts) {
925  av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
926  av_ts2str(sti->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
927  return;
928  }
929  if (!pktl) {
930  av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(sti->first_dts));
931  return;
932  }
933  pktl = si->packet_buffer.head ? si->packet_buffer.head : si->parse_queue.head;
934  sti->first_dts = cur_dts;
935  } else if (sti->cur_dts != RELATIVE_TS_BASE)
936  return;
937 
938  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
939  if (pktl->pkt.stream_index != stream_index)
940  continue;
941  if ((pktl->pkt.pts == pktl->pkt.dts ||
942  pktl->pkt.pts == AV_NOPTS_VALUE) &&
943  (pktl->pkt.dts == AV_NOPTS_VALUE ||
944  pktl->pkt.dts == sti->first_dts ||
945  pktl->pkt.dts == RELATIVE_TS_BASE) &&
946  !pktl->pkt.duration &&
947  av_sat_add64(cur_dts, duration) == cur_dts + (uint64_t)duration
948  ) {
949  pktl->pkt.dts = cur_dts;
950  if (!sti->avctx->has_b_frames)
951  pktl->pkt.pts = cur_dts;
952  pktl->pkt.duration = duration;
953  } else
954  break;
955  cur_dts = pktl->pkt.dts + pktl->pkt.duration;
956  }
957  if (!pktl)
958  sti->cur_dts = cur_dts;
959 }
960 
963  int64_t next_dts, int64_t next_pts)
964 {
965  FFFormatContext *const si = ffformatcontext(s);
966  FFStream *const sti = ffstream(st);
967  int num, den, presentation_delayed, delay;
968  int64_t offset;
970  int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
973 
974  if (s->flags & AVFMT_FLAG_NOFILLIN)
975  return;
976 
978  if (pkt->dts == pkt->pts && sti->last_dts_for_order_check != AV_NOPTS_VALUE) {
979  if (sti->last_dts_for_order_check <= pkt->dts) {
980  sti->dts_ordered++;
981  } else {
983  "DTS %"PRIi64" < %"PRIi64" out of order\n",
984  pkt->dts,
986  sti->dts_misordered++;
987  }
988  if (sti->dts_ordered + sti->dts_misordered > 250) {
989  sti->dts_ordered >>= 1;
990  sti->dts_misordered >>= 1;
991  }
992  }
993 
995  if (sti->dts_ordered < 8 * sti->dts_misordered && pkt->dts == pkt->pts)
997  }
998 
999  if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1000  pkt->dts = AV_NOPTS_VALUE;
1001 
1002  if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1003  && !sti->avctx->has_b_frames)
1004  //FIXME Set low_delay = 0 when has_b_frames = 1
1005  sti->avctx->has_b_frames = 1;
1006 
1007  /* do we have a video B-frame ? */
1008  delay = sti->avctx->has_b_frames;
1009  presentation_delayed = 0;
1010 
1011  /* XXX: need has_b_frame, but cannot get it if the codec is
1012  * not initialized */
1013  if (delay &&
1014  pc && pc->pict_type != AV_PICTURE_TYPE_B)
1015  presentation_delayed = 1;
1016 
1017  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1018  st->pts_wrap_bits < 63 && pkt->dts > INT64_MIN + (1LL << st->pts_wrap_bits) &&
1019  pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1020  if (is_relative(sti->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > sti->cur_dts) {
1021  pkt->dts -= 1LL << st->pts_wrap_bits;
1022  } else
1023  pkt->pts += 1LL << st->pts_wrap_bits;
1024  }
1025 
1026  /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1027  * We take the conservative approach and discard both.
1028  * Note: If this is misbehaving for an H.264 file, then possibly
1029  * presentation_delayed is not set correctly. */
1030  if (delay == 1 && pkt->dts == pkt->pts &&
1031  pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1032  av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1033  if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1034  && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1035  pkt->dts = AV_NOPTS_VALUE;
1036  }
1037 
1039  if (pkt->duration <= 0) {
1040  compute_frame_duration(s, &num, &den, st, pc, pkt);
1041  if (den && num) {
1042  duration = (AVRational) {num, den};
1044  num * (int64_t) st->time_base.den,
1045  den * (int64_t) st->time_base.num,
1046  AV_ROUND_DOWN);
1047  }
1048  }
1049 
1050  if (pkt->duration > 0 && (si->packet_buffer.head || si->parse_queue.head))
1052 
1053  /* Correct timestamps with byte offset if demuxers only have timestamps
1054  * on packet boundaries */
1055  if (pc && sti->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1056  /* this will estimate bitrate based on this frame's duration and size */
1058  if (pkt->pts != AV_NOPTS_VALUE)
1059  pkt->pts += offset;
1060  if (pkt->dts != AV_NOPTS_VALUE)
1061  pkt->dts += offset;
1062  }
1063 
1064  /* This may be redundant, but it should not hurt. */
1065  if (pkt->dts != AV_NOPTS_VALUE &&
1066  pkt->pts != AV_NOPTS_VALUE &&
1067  pkt->pts > pkt->dts)
1068  presentation_delayed = 1;
1069 
1070  if (s->debug & FF_FDEBUG_TS)
1072  "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1073  presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(sti->cur_dts),
1074  pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1075 
1076  /* Interpolate PTS and DTS if they are not present. We skip H264
1077  * currently because delay and has_b_frames are not reliably set. */
1078  if ((delay == 0 || (delay == 1 && pc)) &&
1079  onein_oneout) {
1080  if (presentation_delayed) {
1081  /* DTS = decompression timestamp */
1082  /* PTS = presentation timestamp */
1083  if (pkt->dts == AV_NOPTS_VALUE)
1084  pkt->dts = sti->last_IP_pts;
1086  if (pkt->dts == AV_NOPTS_VALUE)
1087  pkt->dts = sti->cur_dts;
1088 
1089  /* This is tricky: the dts must be incremented by the duration
1090  * of the frame we are displaying, i.e. the last I- or P-frame. */
1091  if (sti->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1092  sti->last_IP_duration = pkt->duration;
1093  if (pkt->dts != AV_NOPTS_VALUE)
1094  sti->cur_dts = av_sat_add64(pkt->dts, sti->last_IP_duration);
1095  if (pkt->dts != AV_NOPTS_VALUE &&
1096  pkt->pts == AV_NOPTS_VALUE &&
1097  sti->last_IP_duration > 0 &&
1098  ((uint64_t)sti->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1099  next_dts != next_pts &&
1100  next_pts != AV_NOPTS_VALUE)
1101  pkt->pts = next_dts;
1102 
1103  if ((uint64_t)pkt->duration <= INT32_MAX)
1104  sti->last_IP_duration = pkt->duration;
1105  sti->last_IP_pts = pkt->pts;
1106  /* Cannot compute PTS if not present (we can compute it only
1107  * by knowing the future. */
1108  } else if (pkt->pts != AV_NOPTS_VALUE ||
1109  pkt->dts != AV_NOPTS_VALUE ||
1110  pkt->duration > 0 ) {
1111 
1112  /* presentation is not delayed : PTS and DTS are the same */
1113  if (pkt->pts == AV_NOPTS_VALUE)
1114  pkt->pts = pkt->dts;
1116  pkt->pts, pkt);
1117  if (pkt->pts == AV_NOPTS_VALUE)
1118  pkt->pts = sti->cur_dts;
1119  pkt->dts = pkt->pts;
1120  if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1121  sti->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1122  }
1123  }
1124 
1125  if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1126  sti->pts_buffer[0] = pkt->pts;
1127  for (int i = 0; i < delay && sti->pts_buffer[i] > sti->pts_buffer[i + 1]; i++)
1128  FFSWAP(int64_t, sti->pts_buffer[i], sti->pts_buffer[i + 1]);
1129 
1132  }
1133  // We skipped it above so we try here.
1134  if (!onein_oneout)
1135  // This should happen on the first packet
1137  if (pkt->dts > sti->cur_dts)
1138  sti->cur_dts = pkt->dts;
1139 
1140  if (s->debug & FF_FDEBUG_TS)
1141  av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1142  presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(sti->cur_dts), st->index, st->id);
1143 
1144  /* update flags */
1147 }
1148 
1149 /**
1150  * Parse a packet, add all split parts to parse_queue.
1151  *
1152  * @param pkt Packet to parse; must not be NULL.
1153  * @param flush Indicates whether to flush. If set, pkt must be blank.
1154  */
1156  int stream_index, int flush)
1157 {
1158  FFFormatContext *const si = ffformatcontext(s);
1159  AVPacket *out_pkt = si->parse_pkt;
1160  AVStream *st = s->streams[stream_index];
1161  FFStream *const sti = ffstream(st);
1162  const uint8_t *data = pkt->data;
1163  int size = pkt->size;
1164  int ret = 0, got_output = flush;
1165 
1166  if (!size && !flush && sti->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1167  // preserve 0-size sync packets
1169  }
1170 
1171  while (size > 0 || (flush && got_output)) {
1172  int64_t next_pts = pkt->pts;
1173  int64_t next_dts = pkt->dts;
1174  int len;
1175 
1176  len = av_parser_parse2(sti->parser, sti->avctx,
1177  &out_pkt->data, &out_pkt->size, data, size,
1178  pkt->pts, pkt->dts, pkt->pos);
1179 
1180  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1181  pkt->pos = -1;
1182  /* increment read pointer */
1183  av_assert1(data || !len);
1184  data = len ? data + len : data;
1185  size -= len;
1186 
1187  got_output = !!out_pkt->size;
1188 
1189  if (!out_pkt->size)
1190  continue;
1191 
1192  if (pkt->buf && out_pkt->data == pkt->data) {
1193  /* reference pkt->buf only when out_pkt->data is guaranteed to point
1194  * to data in it and not in the parser's internal buffer. */
1195  /* XXX: Ensure this is the case with all parsers when sti->parser->flags
1196  * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1197  out_pkt->buf = av_buffer_ref(pkt->buf);
1198  if (!out_pkt->buf) {
1199  ret = AVERROR(ENOMEM);
1200  goto fail;
1201  }
1202  } else {
1203  ret = av_packet_make_refcounted(out_pkt);
1204  if (ret < 0)
1205  goto fail;
1206  }
1207 
1208  if (pkt->side_data) {
1209  out_pkt->side_data = pkt->side_data;
1210  out_pkt->side_data_elems = pkt->side_data_elems;
1211  pkt->side_data = NULL;
1212  pkt->side_data_elems = 0;
1213  }
1214 
1215  /* set the duration */
1216  out_pkt->duration = (sti->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1218  if (sti->avctx->sample_rate > 0) {
1219  out_pkt->duration =
1221  (AVRational) { 1, sti->avctx->sample_rate },
1222  st->time_base,
1223  AV_ROUND_DOWN);
1224  }
1225  } else if (st->codecpar->codec_id == AV_CODEC_ID_GIF) {
1226  if (st->time_base.num > 0 && st->time_base.den > 0 &&
1227  sti->parser->duration) {
1228  out_pkt->duration = sti->parser->duration;
1229  }
1230  }
1231 
1232  out_pkt->stream_index = st->index;
1233  out_pkt->pts = sti->parser->pts;
1234  out_pkt->dts = sti->parser->dts;
1235  out_pkt->pos = sti->parser->pos;
1237 
1239  out_pkt->pos = sti->parser->frame_offset;
1240 
1241  if (sti->parser->key_frame == 1 ||
1242  (sti->parser->key_frame == -1 &&
1244  out_pkt->flags |= AV_PKT_FLAG_KEY;
1245 
1247  out_pkt->flags |= AV_PKT_FLAG_KEY;
1248 
1249  compute_pkt_fields(s, st, sti->parser, out_pkt, next_dts, next_pts);
1250 
1252  out_pkt, NULL, 0);
1253  if (ret < 0)
1254  goto fail;
1255  }
1256 
1257  /* end of the stream => close and free the parser */
1258  if (flush) {
1259  av_parser_close(sti->parser);
1260  sti->parser = NULL;
1261  }
1262 
1263 fail:
1264  if (ret < 0)
1265  av_packet_unref(out_pkt);
1267  return ret;
1268 }
1269 
1270 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1271 {
1272  return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1273 }
1274 
1275 static int codec_close(FFStream *sti)
1276 {
1277  AVCodecContext *avctx_new = NULL;
1278  AVCodecParameters *par_tmp = NULL;
1279  int ret;
1280 
1281  avctx_new = avcodec_alloc_context3(sti->avctx->codec);
1282  if (!avctx_new) {
1283  ret = AVERROR(ENOMEM);
1284  goto fail;
1285  }
1286 
1287  par_tmp = avcodec_parameters_alloc();
1288  if (!par_tmp) {
1289  ret = AVERROR(ENOMEM);
1290  goto fail;
1291  }
1292 
1293  ret = avcodec_parameters_from_context(par_tmp, sti->avctx);
1294  if (ret < 0)
1295  goto fail;
1296 
1297  ret = avcodec_parameters_to_context(avctx_new, par_tmp);
1298  if (ret < 0)
1299  goto fail;
1300 
1301  avctx_new->pkt_timebase = sti->avctx->pkt_timebase;
1302 
1303 #if FF_API_TICKS_PER_FRAME
1305  avctx_new->ticks_per_frame = sti->avctx->ticks_per_frame;
1307 #endif
1308 
1309  avcodec_free_context(&sti->avctx);
1310  sti->avctx = avctx_new;
1311 
1312  avctx_new = NULL;
1313  ret = 0;
1314 
1315 fail:
1316  avcodec_free_context(&avctx_new);
1317  avcodec_parameters_free(&par_tmp);
1318 
1319  return ret;
1320 }
1321 
1323 {
1324  FFFormatContext *const si = ffformatcontext(s);
1325  int ret, got_packet = 0;
1326  AVDictionary *metadata = NULL;
1327 
1328  while (!got_packet && !si->parse_queue.head) {
1329  AVStream *st;
1330  FFStream *sti;
1331 
1332  /* read next packet */
1333  ret = ff_read_packet(s, pkt);
1334  if (ret < 0) {
1335  if (ret == AVERROR(EAGAIN))
1336  return ret;
1337  /* flush the parsers */
1338  for (unsigned i = 0; i < s->nb_streams; i++) {
1339  AVStream *const st = s->streams[i];
1340  FFStream *const sti = ffstream(st);
1341  if (sti->parser && sti->need_parsing)
1342  parse_packet(s, pkt, st->index, 1);
1343  }
1344  /* all remaining packets are now in parse_queue =>
1345  * really terminate parsing */
1346  break;
1347  }
1348  ret = 0;
1349  st = s->streams[pkt->stream_index];
1350  sti = ffstream(st);
1351 
1353 
1354  /* update context if required */
1355  if (sti->need_context_update) {
1356  if (avcodec_is_open(sti->avctx)) {
1357  av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1358  ret = codec_close(sti);
1359  sti->info->found_decoder = 0;
1360  if (ret < 0)
1361  return ret;
1362  }
1363 
1364  /* close parser, because it depends on the codec */
1365  if (sti->parser && sti->avctx->codec_id != st->codecpar->codec_id) {
1366  av_parser_close(sti->parser);
1367  sti->parser = NULL;
1368  }
1369 
1371  if (ret < 0) {
1373  return ret;
1374  }
1375 
1377 
1378  sti->need_context_update = 0;
1379  }
1380 
1381  if (pkt->pts != AV_NOPTS_VALUE &&
1382  pkt->dts != AV_NOPTS_VALUE &&
1383  pkt->pts < pkt->dts) {
1385  "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1386  pkt->stream_index,
1387  av_ts2str(pkt->pts),
1388  av_ts2str(pkt->dts),
1389  pkt->size);
1390  }
1391  if (s->debug & FF_FDEBUG_TS)
1393  "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1394  pkt->stream_index,
1395  av_ts2str(pkt->pts),
1396  av_ts2str(pkt->dts),
1397  pkt->size, pkt->duration, pkt->flags);
1398 
1399  if (sti->need_parsing && !sti->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1400  sti->parser = av_parser_init(st->codecpar->codec_id);
1401  if (!sti->parser) {
1402  av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1403  "%s, packets or times may be invalid.\n",
1405  /* no parser available: just output the raw packets */
1407  } else if (sti->need_parsing == AVSTREAM_PARSE_HEADERS)
1409  else if (sti->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1410  sti->parser->flags |= PARSER_FLAG_ONCE;
1411  else if (sti->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1413  }
1414 
1415  if (!sti->need_parsing || !sti->parser) {
1416  /* no parsing needed: we just output the packet as is */
1418  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1420  ff_reduce_index(s, st->index);
1421  av_add_index_entry(st, pkt->pos, pkt->dts,
1422  0, 0, AVINDEX_KEYFRAME);
1423  }
1424  got_packet = 1;
1425  } else if (st->discard < AVDISCARD_ALL) {
1426  if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1427  return ret;
1428  st->codecpar->sample_rate = sti->avctx->sample_rate;
1429  st->codecpar->bit_rate = sti->avctx->bit_rate;
1431  if (ret < 0)
1432  return ret;
1433  st->codecpar->codec_id = sti->avctx->codec_id;
1434  } else {
1435  /* free packet */
1437  }
1438  if (pkt->flags & AV_PKT_FLAG_KEY)
1439  sti->skip_to_keyframe = 0;
1440  if (sti->skip_to_keyframe) {
1442  got_packet = 0;
1443  }
1444  }
1445 
1446  if (!got_packet && si->parse_queue.head)
1448 
1449  if (ret >= 0) {
1450  AVStream *const st = s->streams[pkt->stream_index];
1451  FFStream *const sti = ffstream(st);
1452  int discard_padding = 0;
1453  if (sti->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1454  int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1455  int64_t sample = ts_to_samples(st, pts);
1456  int64_t duration = ts_to_samples(st, pkt->duration);
1457  int64_t end_sample = sample + duration;
1458  if (duration > 0 && end_sample >= sti->first_discard_sample &&
1459  sample < sti->last_discard_sample)
1460  discard_padding = FFMIN(end_sample - sti->first_discard_sample, duration);
1461  }
1462  if (sti->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1463  sti->skip_samples = sti->start_skip_samples;
1464  sti->skip_samples = FFMAX(0, sti->skip_samples);
1465  if (sti->skip_samples || discard_padding) {
1467  if (p) {
1468  AV_WL32(p, sti->skip_samples);
1469  AV_WL32(p + 4, discard_padding);
1470  av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %u / discard %u\n",
1471  (unsigned)sti->skip_samples, (unsigned)discard_padding);
1472  }
1473  sti->skip_samples = 0;
1474  }
1475 
1476 #if FF_API_AVSTREAM_SIDE_DATA
1477  if (sti->inject_global_side_data) {
1478  for (int i = 0; i < st->codecpar->nb_coded_side_data; i++) {
1479  const AVPacketSideData *const src_sd = &st->codecpar->coded_side_data[i];
1480  uint8_t *dst_data;
1481 
1482  if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1483  continue;
1484 
1485  dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1486  if (!dst_data) {
1487  av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1488  continue;
1489  }
1490 
1491  memcpy(dst_data, src_sd->data, src_sd->size);
1492  }
1493  sti->inject_global_side_data = 0;
1494  }
1495 #endif
1496  }
1497 
1498  if (!si->metafree) {
1499  int metaret = av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1500  if (metadata) {
1501  s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1502  av_dict_copy(&s->metadata, metadata, 0);
1503  av_dict_free(&metadata);
1505  }
1506  si->metafree = metaret == AVERROR_OPTION_NOT_FOUND;
1507  }
1508 
1509  if (s->debug & FF_FDEBUG_TS)
1511  "read_frame_internal stream=%d, pts=%s, dts=%s, "
1512  "size=%d, duration=%"PRId64", flags=%d\n",
1513  pkt->stream_index,
1514  av_ts2str(pkt->pts),
1515  av_ts2str(pkt->dts),
1516  pkt->size, pkt->duration, pkt->flags);
1517 
1518  /* A demuxer might have returned EOF because of an IO error, let's
1519  * propagate this back to the user. */
1520  if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1521  ret = s->pb->error;
1522 
1523  return ret;
1524 }
1525 
1527 {
1528  FFFormatContext *const si = ffformatcontext(s);
1529  const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1530  int eof = 0;
1531  int ret;
1532  AVStream *st;
1533 
1534  if (!genpts) {
1535  ret = si->packet_buffer.head
1538  if (ret < 0)
1539  return ret;
1540  goto return_packet;
1541  }
1542 
1543  for (;;) {
1544  PacketListEntry *pktl = si->packet_buffer.head;
1545 
1546  if (pktl) {
1547  AVPacket *next_pkt = &pktl->pkt;
1548 
1549  if (next_pkt->dts != AV_NOPTS_VALUE) {
1550  int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1551  // last dts seen for this stream. if any of packets following
1552  // current one had no dts, we will set this to AV_NOPTS_VALUE.
1553  int64_t last_dts = next_pkt->dts;
1554  av_assert2(wrap_bits <= 64);
1555  while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1556  if (pktl->pkt.stream_index == next_pkt->stream_index &&
1557  av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1558  if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1559  // not B-frame
1560  next_pkt->pts = pktl->pkt.dts;
1561  }
1562  if (last_dts != AV_NOPTS_VALUE) {
1563  // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1564  last_dts = pktl->pkt.dts;
1565  }
1566  }
1567  pktl = pktl->next;
1568  }
1569  if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1570  // Fixing the last reference frame had none pts issue (For MXF etc).
1571  // We only do this when
1572  // 1. eof.
1573  // 2. we are not able to resolve a pts value for current packet.
1574  // 3. the packets for this stream at the end of the files had valid dts.
1575  next_pkt->pts = last_dts + next_pkt->duration;
1576  }
1577  pktl = si->packet_buffer.head;
1578  }
1579 
1580  /* read packet from packet buffer, if there is data */
1581  st = s->streams[next_pkt->stream_index];
1582  if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1583  next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1585  goto return_packet;
1586  }
1587  }
1588 
1590  if (ret < 0) {
1591  if (pktl && ret != AVERROR(EAGAIN)) {
1592  eof = 1;
1593  continue;
1594  } else
1595  return ret;
1596  }
1597 
1599  pkt, NULL, 0);
1600  if (ret < 0) {
1602  return ret;
1603  }
1604  }
1605 
1606 return_packet:
1607  st = s->streams[pkt->stream_index];
1608  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1609  ff_reduce_index(s, st->index);
1611  }
1612 
1613  if (is_relative(pkt->dts))
1614  pkt->dts -= RELATIVE_TS_BASE;
1615  if (is_relative(pkt->pts))
1616  pkt->pts -= RELATIVE_TS_BASE;
1617 
1618  return ret;
1619 }
1620 
1621 /**
1622  * Return TRUE if the stream has accurate duration in any stream.
1623  *
1624  * @return TRUE if the stream has accurate duration for at least one component.
1625  */
1627 {
1628  for (unsigned i = 0; i < ic->nb_streams; i++) {
1629  const AVStream *const st = ic->streams[i];
1630  if (st->duration != AV_NOPTS_VALUE)
1631  return 1;
1632  }
1633  if (ic->duration != AV_NOPTS_VALUE)
1634  return 1;
1635  return 0;
1636 }
1637 
1638 /**
1639  * Estimate the stream timings from the one of each components.
1640  *
1641  * Also computes the global bitrate if possible.
1642  */
1644 {
1645  int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
1646  int64_t duration, duration1, duration_text, filesize;
1647 
1648  start_time = INT64_MAX;
1649  start_time_text = INT64_MAX;
1650  end_time = INT64_MIN;
1651  end_time_text = INT64_MIN;
1652  duration = INT64_MIN;
1653  duration_text = INT64_MIN;
1654 
1655  for (unsigned i = 0; i < ic->nb_streams; i++) {
1656  AVStream *const st = ic->streams[i];
1657  int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
1659 
1660  if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1661  start_time1 = av_rescale_q(st->start_time, st->time_base,
1662  AV_TIME_BASE_Q);
1663  if (is_text)
1664  start_time_text = FFMIN(start_time_text, start_time1);
1665  else
1666  start_time = FFMIN(start_time, start_time1);
1667  end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
1670  if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
1671  end_time1 += start_time1;
1672  if (is_text)
1673  end_time_text = FFMAX(end_time_text, end_time1);
1674  else
1675  end_time = FFMAX(end_time, end_time1);
1676  }
1677  for (AVProgram *p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
1678  if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
1679  p->start_time = start_time1;
1680  if (p->end_time < end_time1)
1681  p->end_time = end_time1;
1682  }
1683  }
1684  if (st->duration != AV_NOPTS_VALUE) {
1685  duration1 = av_rescale_q(st->duration, st->time_base,
1686  AV_TIME_BASE_Q);
1687  if (is_text)
1688  duration_text = FFMAX(duration_text, duration1);
1689  else
1690  duration = FFMAX(duration, duration1);
1691  }
1692  }
1693  if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
1694  start_time = start_time_text;
1695  else if (start_time > start_time_text)
1696  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
1697 
1698  if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
1699  end_time = end_time_text;
1700  else if (end_time < end_time_text)
1701  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
1702 
1703  if (duration == INT64_MIN || (duration < duration_text && (uint64_t)duration_text - duration < AV_TIME_BASE))
1704  duration = duration_text;
1705  else if (duration < duration_text)
1706  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
1707 
1708  if (start_time != INT64_MAX) {
1709  ic->start_time = start_time;
1710  if (end_time != INT64_MIN) {
1711  if (ic->nb_programs > 1) {
1712  for (unsigned i = 0; i < ic->nb_programs; i++) {
1713  AVProgram *const p = ic->programs[i];
1714 
1715  if (p->start_time != AV_NOPTS_VALUE &&
1716  p->end_time > p->start_time &&
1717  p->end_time - (uint64_t)p->start_time <= INT64_MAX)
1719  }
1720  } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
1721  duration = FFMAX(duration, end_time - start_time);
1722  }
1723  }
1724  }
1725  if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
1726  ic->duration = duration;
1727  }
1728  if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
1729  /* compute the bitrate */
1730  double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
1731  (double) ic->duration;
1732  if (bitrate >= 0 && bitrate <= INT64_MAX)
1733  ic->bit_rate = bitrate;
1734  }
1735 }
1736 
1738 {
1740  for (unsigned i = 0; i < ic->nb_streams; i++) {
1741  AVStream *const st = ic->streams[i];
1742 
1743  if (st->start_time == AV_NOPTS_VALUE) {
1744  if (ic->start_time != AV_NOPTS_VALUE)
1746  st->time_base);
1747  if (ic->duration != AV_NOPTS_VALUE)
1749  st->time_base);
1750  }
1751  }
1752 }
1753 
1755 {
1756  FFFormatContext *const si = ffformatcontext(ic);
1757  int show_warning = 0;
1758 
1759  /* if bit_rate is already set, we believe it */
1760  if (ic->bit_rate <= 0) {
1761  int64_t bit_rate = 0;
1762  for (unsigned i = 0; i < ic->nb_streams; i++) {
1763  const AVStream *const st = ic->streams[i];
1764  const FFStream *const sti = cffstream(st);
1765  if (st->codecpar->bit_rate <= 0 && sti->avctx->bit_rate > 0)
1766  st->codecpar->bit_rate = sti->avctx->bit_rate;
1767  if (st->codecpar->bit_rate > 0) {
1768  if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
1769  bit_rate = 0;
1770  break;
1771  }
1772  bit_rate += st->codecpar->bit_rate;
1773  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && sti->codec_info_nb_frames > 1) {
1774  // If we have a videostream with packets but without a bitrate
1775  // then consider the sum not known
1776  bit_rate = 0;
1777  break;
1778  }
1779  }
1780  ic->bit_rate = bit_rate;
1781  }
1782 
1783  /* if duration is already set, we believe it */
1784  if (ic->duration == AV_NOPTS_VALUE &&
1785  ic->bit_rate != 0) {
1786  int64_t filesize = ic->pb ? avio_size(ic->pb) : 0;
1787  if (filesize > si->data_offset) {
1788  filesize -= si->data_offset;
1789  for (unsigned i = 0; i < ic->nb_streams; i++) {
1790  AVStream *const st = ic->streams[i];
1791 
1792  if ( st->time_base.num <= INT64_MAX / ic->bit_rate
1793  && st->duration == AV_NOPTS_VALUE) {
1794  st->duration = av_rescale(filesize, 8LL * st->time_base.den,
1795  ic->bit_rate *
1796  (int64_t) st->time_base.num);
1797  show_warning = 1;
1798  }
1799  }
1800  }
1801  }
1802  if (show_warning)
1803  av_log(ic, AV_LOG_WARNING,
1804  "Estimating duration from bitrate, this may be inaccurate\n");
1805 }
1806 
1807 #define DURATION_DEFAULT_MAX_READ_SIZE 250000LL
1808 #define DURATION_DEFAULT_MAX_RETRY 6
1809 #define DURATION_MAX_RETRY 1
1810 
1811 /* only usable for MPEG-PS streams */
1812 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1813 {
1814  FFFormatContext *const si = ffformatcontext(ic);
1815  AVPacket *const pkt = si->pkt;
1816  int num, den, read_size, ret;
1817  int64_t duration_max_read_size = ic->duration_probesize ? ic->duration_probesize >> DURATION_MAX_RETRY : DURATION_DEFAULT_MAX_READ_SIZE;
1818  int duration_max_retry = ic->duration_probesize ? DURATION_MAX_RETRY : DURATION_DEFAULT_MAX_RETRY;
1819  int found_duration = 0;
1820  int is_end;
1821  int64_t filesize, offset, duration;
1822  int retry = 0;
1823 
1824  /* flush packet queue */
1826 
1827  for (unsigned i = 0; i < ic->nb_streams; i++) {
1828  AVStream *const st = ic->streams[i];
1829  FFStream *const sti = ffstream(st);
1830 
1831  if (st->start_time == AV_NOPTS_VALUE &&
1832  sti->first_dts == AV_NOPTS_VALUE &&
1834  av_log(ic, AV_LOG_WARNING,
1835  "start time for stream %d is not set in estimate_timings_from_pts\n", i);
1836 
1837  if (sti->parser) {
1838  av_parser_close(sti->parser);
1839  sti->parser = NULL;
1840  }
1841  }
1842 
1844  av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
1845  goto skip_duration_calc;
1846  }
1847 
1848  av_opt_set_int(ic, "skip_changes", 1, AV_OPT_SEARCH_CHILDREN);
1849  /* estimate the end time (duration) */
1850  /* XXX: may need to support wrapping */
1851  filesize = ic->pb ? avio_size(ic->pb) : 0;
1852  do {
1853  is_end = found_duration;
1854  offset = filesize - (duration_max_read_size << retry);
1855  if (offset < 0)
1856  offset = 0;
1857 
1858  avio_seek(ic->pb, offset, SEEK_SET);
1859  read_size = 0;
1860  for (;;) {
1861  AVStream *st;
1862  FFStream *sti;
1863  if (read_size >= duration_max_read_size << (FFMAX(retry - 1, 0)))
1864  break;
1865 
1866  do {
1867  ret = ff_read_packet(ic, pkt);
1868  } while (ret == AVERROR(EAGAIN));
1869  if (ret != 0)
1870  break;
1871  read_size += pkt->size;
1872  st = ic->streams[pkt->stream_index];
1873  sti = ffstream(st);
1874  if (pkt->pts != AV_NOPTS_VALUE &&
1875  (st->start_time != AV_NOPTS_VALUE ||
1876  sti->first_dts != AV_NOPTS_VALUE)) {
1877  if (pkt->duration == 0) {
1878  compute_frame_duration(ic, &num, &den, st, sti->parser, pkt);
1879  if (den && num) {
1881  num * (int64_t) st->time_base.den,
1882  den * (int64_t) st->time_base.num,
1883  AV_ROUND_DOWN);
1884  }
1885  }
1886  duration = pkt->pts + pkt->duration;
1887  found_duration = 1;
1888  if (st->start_time != AV_NOPTS_VALUE)
1889  duration -= st->start_time;
1890  else
1891  duration -= sti->first_dts;
1892  if (duration > 0) {
1893  if (st->duration == AV_NOPTS_VALUE || sti->info->last_duration<= 0 ||
1894  (st->duration < duration && FFABS(duration - sti->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
1895  st->duration = duration;
1896  sti->info->last_duration = duration;
1897  }
1898  }
1900  }
1901 
1902  /* check if all audio/video streams have valid duration */
1903  if (!is_end) {
1904  is_end = 1;
1905  for (unsigned i = 0; i < ic->nb_streams; i++) {
1906  const AVStream *const st = ic->streams[i];
1907  switch (st->codecpar->codec_type) {
1908  case AVMEDIA_TYPE_VIDEO:
1909  case AVMEDIA_TYPE_AUDIO:
1910  if (st->duration == AV_NOPTS_VALUE)
1911  is_end = 0;
1912  }
1913  }
1914  }
1915  } while (!is_end &&
1916  offset &&
1917  ++retry <= duration_max_retry);
1918 
1919  av_opt_set_int(ic, "skip_changes", 0, AV_OPT_SEARCH_CHILDREN);
1920 
1921  /* warn about audio/video streams which duration could not be estimated */
1922  for (unsigned i = 0; i < ic->nb_streams; i++) {
1923  const AVStream *const st = ic->streams[i];
1924  const FFStream *const sti = cffstream(st);
1925 
1926  if (st->duration == AV_NOPTS_VALUE) {
1927  switch (st->codecpar->codec_type) {
1928  case AVMEDIA_TYPE_VIDEO:
1929  case AVMEDIA_TYPE_AUDIO:
1930  if (st->start_time != AV_NOPTS_VALUE || sti->first_dts != AV_NOPTS_VALUE) {
1931  av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
1932  } else
1933  av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
1934  }
1935  }
1936  }
1937 skip_duration_calc:
1939 
1940  avio_seek(ic->pb, old_offset, SEEK_SET);
1941  for (unsigned i = 0; i < ic->nb_streams; i++) {
1942  AVStream *const st = ic->streams[i];
1943  FFStream *const sti = ffstream(st);
1944 
1945  sti->cur_dts = sti->first_dts;
1946  sti->last_IP_pts = AV_NOPTS_VALUE;
1948  for (int j = 0; j < MAX_REORDER_DELAY + 1; j++)
1949  sti->pts_buffer[j] = AV_NOPTS_VALUE;
1950  }
1951 }
1952 
1953 /* 1:1 map to AVDurationEstimationMethod */
1954 static const char *const duration_name[] = {
1955  [AVFMT_DURATION_FROM_PTS] = "pts",
1956  [AVFMT_DURATION_FROM_STREAM] = "stream",
1957  [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
1958 };
1959 
1961 {
1962  return duration_name[method];
1963 }
1964 
1965 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
1966 {
1967  int64_t file_size;
1968 
1969  /* get the file size, if possible */
1970  if (ic->iformat->flags & AVFMT_NOFILE) {
1971  file_size = 0;
1972  } else {
1973  file_size = avio_size(ic->pb);
1974  file_size = FFMAX(0, file_size);
1975  }
1976 
1977  if ((!strcmp(ic->iformat->name, "mpeg") ||
1978  !strcmp(ic->iformat->name, "mpegts")) &&
1979  file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
1980  /* get accurate estimate from the PTSes */
1981  estimate_timings_from_pts(ic, old_offset);
1983  } else if (has_duration(ic)) {
1984  /* at least one component has timings - we use them for all
1985  * the components */
1987  /* nut demuxer estimate the duration from PTS */
1988  if (!strcmp(ic->iformat->name, "nut"))
1990  else
1992  } else {
1993  /* less precise: use bitrate info */
1996  }
1998 
1999  for (unsigned i = 0; i < ic->nb_streams; i++) {
2000  AVStream *const st = ic->streams[i];
2001  if (st->time_base.den)
2002  av_log(ic, AV_LOG_TRACE, "stream %u: start_time: %s duration: %s\n", i,
2003  av_ts2timestr(st->start_time, &st->time_base),
2004  av_ts2timestr(st->duration, &st->time_base));
2005  }
2006  av_log(ic, AV_LOG_TRACE,
2007  "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
2011  (int64_t)ic->bit_rate / 1000);
2012 }
2013 
2014 static int determinable_frame_size(const AVCodecContext *avctx)
2015 {
2016  switch(avctx->codec_id) {
2017  case AV_CODEC_ID_MP1:
2018  case AV_CODEC_ID_MP2:
2019  case AV_CODEC_ID_MP3:
2020  case AV_CODEC_ID_CODEC2:
2021  return 1;
2022  }
2023 
2024  return 0;
2025 }
2026 
2027 static int has_codec_parameters(const AVStream *st, const char **errmsg_ptr)
2028 {
2029  const FFStream *const sti = cffstream(st);
2030  const AVCodecContext *const avctx = sti->avctx;
2031 
2032 #define FAIL(errmsg) do { \
2033  if (errmsg_ptr) \
2034  *errmsg_ptr = errmsg; \
2035  return 0; \
2036  } while (0)
2037 
2038  if ( avctx->codec_id == AV_CODEC_ID_NONE
2039  && avctx->codec_type != AVMEDIA_TYPE_DATA)
2040  FAIL("unknown codec");
2041  switch (avctx->codec_type) {
2042  case AVMEDIA_TYPE_AUDIO:
2043  if (!avctx->frame_size && determinable_frame_size(avctx))
2044  FAIL("unspecified frame size");
2045  if (sti->info->found_decoder >= 0 &&
2046  avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2047  FAIL("unspecified sample format");
2048  if (!avctx->sample_rate)
2049  FAIL("unspecified sample rate");
2050  if (!avctx->ch_layout.nb_channels)
2051  FAIL("unspecified number of channels");
2052  if (sti->info->found_decoder >= 0 && !sti->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2053  FAIL("no decodable DTS frames");
2054  break;
2055  case AVMEDIA_TYPE_VIDEO:
2056  if (!avctx->width)
2057  FAIL("unspecified size");
2058  if (sti->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2059  FAIL("unspecified pixel format");
2062  FAIL("no frame in rv30/40 and no sar");
2063  break;
2064  case AVMEDIA_TYPE_SUBTITLE:
2065  if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2066  FAIL("unspecified size");
2067  break;
2068  case AVMEDIA_TYPE_DATA:
2069  if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2070  }
2071 
2072  return 1;
2073 }
2074 
2075 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2077  const AVPacket *pkt, AVDictionary **options)
2078 {
2079  FFStream *const sti = ffstream(st);
2080  AVCodecContext *const avctx = sti->avctx;
2081  const AVCodec *codec;
2082  int got_picture = 1, ret = 0;
2084  AVSubtitle subtitle;
2085  int do_skip_frame = 0;
2086  enum AVDiscard skip_frame;
2087  int pkt_to_send = pkt->size > 0;
2088 
2089  if (!frame)
2090  return AVERROR(ENOMEM);
2091 
2092  if (!avcodec_is_open(avctx) &&
2093  sti->info->found_decoder <= 0 &&
2094  (st->codecpar->codec_id != -sti->info->found_decoder || !st->codecpar->codec_id)) {
2095  AVDictionary *thread_opt = NULL;
2096 
2097  codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2098 
2099  if (!codec) {
2100  sti->info->found_decoder = -st->codecpar->codec_id;
2101  ret = -1;
2102  goto fail;
2103  }
2104 
2105  /* Force thread count to 1 since the H.264 decoder will not extract
2106  * SPS and PPS to extradata during multi-threaded decoding. */
2107  av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2108  /* Force lowres to 0. The decoder might reduce the video size by the
2109  * lowres factor, and we don't want that propagated to the stream's
2110  * codecpar */
2111  av_dict_set(options ? options : &thread_opt, "lowres", "0", 0);
2112  if (s->codec_whitelist)
2113  av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2114  ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2115  if (!options)
2116  av_dict_free(&thread_opt);
2117  if (ret < 0) {
2118  sti->info->found_decoder = -avctx->codec_id;
2119  goto fail;
2120  }
2121  sti->info->found_decoder = 1;
2122  } else if (!sti->info->found_decoder)
2123  sti->info->found_decoder = 1;
2124 
2125  if (sti->info->found_decoder < 0) {
2126  ret = -1;
2127  goto fail;
2128  }
2129 
2131  do_skip_frame = 1;
2132  skip_frame = avctx->skip_frame;
2133  avctx->skip_frame = AVDISCARD_ALL;
2134  }
2135 
2136  while ((pkt_to_send || (!pkt->data && got_picture)) &&
2137  ret >= 0 &&
2139  (!sti->codec_info_nb_frames &&
2141  got_picture = 0;
2142  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
2143  avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2144  ret = avcodec_send_packet(avctx, pkt);
2145  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
2146  break;
2147  if (ret >= 0)
2148  pkt_to_send = 0;
2149  ret = avcodec_receive_frame(avctx, frame);
2150  if (ret >= 0)
2151  got_picture = 1;
2152  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
2153  ret = 0;
2154  } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2155  ret = avcodec_decode_subtitle2(avctx, &subtitle,
2156  &got_picture, pkt);
2157  if (got_picture)
2158  avsubtitle_free(&subtitle);
2159  if (ret >= 0)
2160  pkt_to_send = 0;
2161  }
2162  if (ret >= 0) {
2163  if (got_picture)
2164  sti->nb_decoded_frames++;
2165  ret = got_picture;
2166  }
2167  }
2168 
2169 fail:
2170  if (do_skip_frame) {
2171  avctx->skip_frame = skip_frame;
2172  }
2173 
2174  av_frame_free(&frame);
2175  return ret;
2176 }
2177 
2178 static int chapter_start_cmp(const void *p1, const void *p2)
2179 {
2180  const AVChapter *const ch1 = *(AVChapter**)p1;
2181  const AVChapter *const ch2 = *(AVChapter**)p2;
2182  int delta = av_compare_ts(ch1->start, ch1->time_base, ch2->start, ch2->time_base);
2183  if (delta)
2184  return delta;
2185  return FFDIFFSIGN(ch1->id, ch2->id);
2186 }
2187 
2189 {
2190  int64_t max_time = 0;
2191  AVChapter **timetable;
2192 
2193  if (!s->nb_chapters)
2194  return 0;
2195 
2196  if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
2197  max_time = s->duration +
2198  ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2199 
2200  timetable = av_memdup(s->chapters, s->nb_chapters * sizeof(*timetable));
2201  if (!timetable)
2202  return AVERROR(ENOMEM);
2203  qsort(timetable, s->nb_chapters, sizeof(*timetable), chapter_start_cmp);
2204 
2205  for (unsigned i = 0; i < s->nb_chapters; i++)
2206  if (timetable[i]->end == AV_NOPTS_VALUE) {
2207  AVChapter *const ch = timetable[i];
2208  int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2209  ch->time_base)
2210  : INT64_MAX;
2211 
2212  if (i + 1 < s->nb_chapters) {
2213  const AVChapter *const ch1 = timetable[i + 1];
2214  int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2215  ch->time_base);
2216  if (next_start > ch->start && next_start < end)
2217  end = next_start;
2218  }
2219  ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
2220  }
2221  av_free(timetable);
2222  return 0;
2223 }
2224 
2225 static int get_std_framerate(int i)
2226 {
2227  if (i < 30*12)
2228  return (i + 1) * 1001;
2229  i -= 30*12;
2230 
2231  if (i < 30)
2232  return (i + 31) * 1001 * 12;
2233  i -= 30;
2234 
2235  if (i < 3)
2236  return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
2237 
2238  i -= 3;
2239 
2240  return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2241 }
2242 
2243 /* Is the time base unreliable?
2244  * This is a heuristic to balance between quick acceptance of the values in
2245  * the headers vs. some extra checks.
2246  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2247  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2248  * And there are "variable" fps files this needs to detect as well. */
2250 {
2251  FFStream *const sti = ffstream(st);
2252  const AVCodecDescriptor *desc = sti->codec_desc;
2253  AVCodecContext *c = sti->avctx;
2254  AVRational mul = (AVRational){ desc && (desc->props & AV_CODEC_PROP_FIELDS) ? 2 : 1, 1 };
2255  AVRational time_base = c->framerate.num ? av_inv_q(av_mul_q(c->framerate, mul))
2256  /* NOHEADER check added to not break existing behavior */
2257  : (((ic->ctx_flags & AVFMTCTX_NOHEADER) ||
2259  : st->time_base);
2260 
2261  if (time_base.den >= 101LL * time_base.num ||
2262  time_base.den < 5LL * time_base.num ||
2263  // c->codec_tag == AV_RL32("DIVX") ||
2264  // c->codec_tag == AV_RL32("XVID") ||
2265  c->codec_tag == AV_RL32("mp4v") ||
2266  c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2267  c->codec_id == AV_CODEC_ID_GIF ||
2268  c->codec_id == AV_CODEC_ID_HEVC ||
2269  c->codec_id == AV_CODEC_ID_H264)
2270  return 1;
2271  return 0;
2272 }
2273 
2274 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2275 {
2276  FFStream *const sti = ffstream(st);
2277  FFStreamInfo *info = sti->info;
2278  int64_t last = info->last_dts;
2279 
2280  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2281  && ts - (uint64_t)last < INT64_MAX) {
2282  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2283  int64_t duration = ts - last;
2284 
2285  if (!info->duration_error)
2286  info->duration_error = av_mallocz(sizeof(info->duration_error[0])*2);
2287  if (!info->duration_error)
2288  return AVERROR(ENOMEM);
2289 
2290 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2291 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2292  for (int i = 0; i < MAX_STD_TIMEBASES; i++) {
2293  if (info->duration_error[0][1][i] < 1e10) {
2294  int framerate = get_std_framerate(i);
2295  double sdts = dts*framerate/(1001*12);
2296  for (int j = 0; j < 2; j++) {
2297  int64_t ticks = llrint(sdts+j*0.5);
2298  double error = sdts - ticks + j*0.5;
2299  info->duration_error[j][0][i] += error;
2300  info->duration_error[j][1][i] += error*error;
2301  }
2302  }
2303  }
2304  if (info->rfps_duration_sum <= INT64_MAX - duration) {
2305  info->duration_count++;
2306  info->rfps_duration_sum += duration;
2307  }
2308 
2309  if (info->duration_count % 10 == 0) {
2310  int n = info->duration_count;
2311  for (int i = 0; i < MAX_STD_TIMEBASES; i++) {
2312  if (info->duration_error[0][1][i] < 1e10) {
2313  double a0 = info->duration_error[0][0][i] / n;
2314  double error0 = info->duration_error[0][1][i] / n - a0*a0;
2315  double a1 = info->duration_error[1][0][i] / n;
2316  double error1 = info->duration_error[1][1][i] / n - a1*a1;
2317  if (error0 > 0.04 && error1 > 0.04) {
2318  info->duration_error[0][1][i] = 2e10;
2319  info->duration_error[1][1][i] = 2e10;
2320  }
2321  }
2322  }
2323  }
2324 
2325  // ignore the first 4 values, they might have some random jitter
2326  if (info->duration_count > 3 && is_relative(ts) == is_relative(last))
2327  info->duration_gcd = av_gcd(info->duration_gcd, duration);
2328  }
2329  if (ts != AV_NOPTS_VALUE)
2330  info->last_dts = ts;
2331 
2332  return 0;
2333 }
2334 
2336 {
2337  for (unsigned i = 0; i < ic->nb_streams; i++) {
2338  AVStream *const st = ic->streams[i];
2339  FFStream *const sti = ffstream(st);
2340 
2342  continue;
2343  // the check for tb_unreliable() is not completely correct, since this is not about handling
2344  // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2345  // ipmovie.c produces.
2346  if (tb_unreliable(ic, st) && sti->info->duration_count > 15 && sti->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num &&
2347  sti->info->duration_gcd < INT64_MAX / st->time_base.num)
2348  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * sti->info->duration_gcd, INT_MAX);
2349  if (sti->info->duration_count > 1 && !st->r_frame_rate.num
2350  && tb_unreliable(ic, st)) {
2351  int num = 0;
2352  double best_error = 0.01;
2353  AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2354 
2355  for (int j = 0; j < MAX_STD_TIMEBASES; j++) {
2356  if (sti->info->codec_info_duration &&
2357  sti->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
2358  continue;
2359  if (!sti->info->codec_info_duration && get_std_framerate(j) < 1001*12)
2360  continue;
2361 
2362  if (av_q2d(st->time_base) * sti->info->rfps_duration_sum / sti->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2363  continue;
2364 
2365  for (int k = 0; k < 2; k++) {
2366  int n = sti->info->duration_count;
2367  double a = sti->info->duration_error[k][0][j] / n;
2368  double error = sti->info->duration_error[k][1][j]/n - a*a;
2369 
2370  if (error < best_error && best_error> 0.000000001) {
2371  best_error= error;
2372  num = get_std_framerate(j);
2373  }
2374  if (error < 0.02)
2375  av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2376  }
2377  }
2378  // do not increase frame rate by more than 1 % in order to match a standard rate.
2379  if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2380  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2381  }
2382  if ( !st->avg_frame_rate.num
2383  && st->r_frame_rate.num && sti->info->rfps_duration_sum
2384  && sti->info->codec_info_duration <= 0
2385  && sti->info->duration_count > 2
2386  && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - sti->info->rfps_duration_sum / (double)sti->info->duration_count) <= 1.0
2387  ) {
2388  av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2389  st->avg_frame_rate = st->r_frame_rate;
2390  }
2391 
2392  av_freep(&sti->info->duration_error);
2393  sti->info->last_dts = AV_NOPTS_VALUE;
2394  sti->info->duration_count = 0;
2395  sti->info->rfps_duration_sum = 0;
2396  }
2397 }
2398 
2400 {
2401  const AVBitStreamFilter *const f = av_bsf_get_by_name("extract_extradata");
2402  if (!f)
2403  return 0;
2404 
2405  if (f->codec_ids) {
2406  const enum AVCodecID *ids;
2407  for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
2408  if (*ids == st->codecpar->codec_id)
2409  return 1;
2410  }
2411 
2412  return 0;
2413 }
2414 
2416 {
2417  FFStream *const sti = ffstream(st);
2418  const AVBitStreamFilter *f;
2419  int ret;
2420 
2421  f = av_bsf_get_by_name("extract_extradata");
2422  if (!f)
2423  goto finish;
2424 
2425  /* check that the codec id is supported */
2427  if (!ret)
2428  goto finish;
2429 
2431  if (ret < 0)
2432  return ret;
2433 
2435  st->codecpar);
2436  if (ret < 0)
2437  goto fail;
2438 
2440 
2442  if (ret < 0)
2443  goto fail;
2444 
2445 finish:
2446  sti->extract_extradata.inited = 1;
2447 
2448  return 0;
2449 fail:
2451  return ret;
2452 }
2453 
2455 {
2456  FFStream *const sti = ffstream(st);
2457  AVPacket *const pkt_ref = si->parse_pkt;
2458  int ret;
2459 
2460  if (!sti->extract_extradata.inited) {
2462  if (ret < 0)
2463  return ret;
2464  }
2465 
2466  if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
2467  return 0;
2468 
2469  ret = av_packet_ref(pkt_ref, pkt);
2470  if (ret < 0)
2471  return ret;
2472 
2473  ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
2474  if (ret < 0) {
2475  av_packet_unref(pkt_ref);
2476  return ret;
2477  }
2478 
2479  while (ret >= 0 && !sti->avctx->extradata) {
2481  if (ret < 0) {
2482  if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
2483  return ret;
2484  continue;
2485  }
2486 
2487  for (int i = 0; i < pkt_ref->side_data_elems; i++) {
2488  AVPacketSideData *const side_data = &pkt_ref->side_data[i];
2489  if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) {
2490  sti->avctx->extradata = side_data->data;
2491  sti->avctx->extradata_size = side_data->size;
2492  side_data->data = NULL;
2493  side_data->size = 0;
2494  break;
2495  }
2496  }
2497  av_packet_unref(pkt_ref);
2498  }
2499 
2500  return 0;
2501 }
2502 
2504 {
2505  FFFormatContext *const si = ffformatcontext(ic);
2506  int count = 0, ret = 0;
2507  int64_t read_size;
2508  AVPacket *pkt1 = si->pkt;
2509  int64_t old_offset = avio_tell(ic->pb);
2510  // new streams might appear, no options for those
2511  int orig_nb_streams = ic->nb_streams;
2512  int flush_codecs;
2513  int64_t max_analyze_duration = ic->max_analyze_duration;
2514  int64_t max_stream_analyze_duration;
2515  int64_t max_subtitle_analyze_duration;
2516  int64_t probesize = ic->probesize;
2517  int eof_reached = 0;
2518  int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
2519 
2520  flush_codecs = probesize > 0;
2521 
2522  av_opt_set_int(ic, "skip_clear", 1, AV_OPT_SEARCH_CHILDREN);
2523 
2524  max_stream_analyze_duration = max_analyze_duration;
2525  max_subtitle_analyze_duration = max_analyze_duration;
2526  if (!max_analyze_duration) {
2527  max_stream_analyze_duration =
2528  max_analyze_duration = 5*AV_TIME_BASE;
2529  max_subtitle_analyze_duration = 30*AV_TIME_BASE;
2530  if (!strcmp(ic->iformat->name, "flv"))
2531  max_stream_analyze_duration = 90*AV_TIME_BASE;
2532  if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
2533  max_stream_analyze_duration = 7*AV_TIME_BASE;
2534  }
2535 
2536  if (ic->pb) {
2537  FFIOContext *const ctx = ffiocontext(ic->pb);
2538  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
2539  avio_tell(ic->pb), ctx->bytes_read, ctx->seek_count, ic->nb_streams);
2540  }
2541 
2542  for (unsigned i = 0; i < ic->nb_streams; i++) {
2543  const AVCodec *codec;
2544  AVDictionary *thread_opt = NULL;
2545  AVStream *const st = ic->streams[i];
2546  FFStream *const sti = ffstream(st);
2547  AVCodecContext *const avctx = sti->avctx;
2548 
2549  /* check if the caller has overridden the codec id */
2550  // only for the split stuff
2551  if (!sti->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && sti->request_probe <= 0) {
2552  sti->parser = av_parser_init(st->codecpar->codec_id);
2553  if (sti->parser) {
2554  if (sti->need_parsing == AVSTREAM_PARSE_HEADERS) {
2556  } else if (sti->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2558  }
2559  } else if (sti->need_parsing) {
2560  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2561  "%s, packets or times may be invalid.\n",
2563  }
2564  }
2565 
2567  if (ret < 0)
2568  goto find_stream_info_err;
2569  if (sti->request_probe <= 0)
2570  sti->avctx_inited = 1;
2571 
2572  codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
2573 
2574  /* Force thread count to 1 since the H.264 decoder will not extract
2575  * SPS and PPS to extradata during multi-threaded decoding. */
2576  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2577  /* Force lowres to 0. The decoder might reduce the video size by the
2578  * lowres factor, and we don't want that propagated to the stream's
2579  * codecpar */
2580  av_dict_set(options ? &options[i] : &thread_opt, "lowres", "0", 0);
2581 
2582  if (ic->codec_whitelist)
2583  av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
2584 
2585  // Try to just open decoders, in case this is enough to get parameters.
2586  // Also ensure that subtitle_header is properly set.
2587  if (!has_codec_parameters(st, NULL) && sti->request_probe <= 0 ||
2589  if (codec && !avctx->codec)
2590  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
2591  av_log(ic, AV_LOG_WARNING,
2592  "Failed to open codec in %s\n", __func__);
2593  }
2594  if (!options)
2595  av_dict_free(&thread_opt);
2596  }
2597 
2598  read_size = 0;
2599  for (;;) {
2600  const AVPacket *pkt;
2601  AVStream *st;
2602  FFStream *sti;
2603  AVCodecContext *avctx;
2604  int analyzed_all_streams;
2605  unsigned i;
2607  ret = AVERROR_EXIT;
2608  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2609  break;
2610  }
2611 
2612  /* check if one codec still needs to be handled */
2613  for (i = 0; i < ic->nb_streams; i++) {
2614  AVStream *const st = ic->streams[i];
2615  FFStream *const sti = ffstream(st);
2616  int fps_analyze_framecount = 20;
2617  int count;
2618 
2619  if (!has_codec_parameters(st, NULL))
2620  break;
2621  /* If the timebase is coarse (like the usual millisecond precision
2622  * of mkv), we need to analyze more frames to reliably arrive at
2623  * the correct fps. */
2624  if (av_q2d(st->time_base) > 0.0005)
2625  fps_analyze_framecount *= 2;
2626  if (!tb_unreliable(ic, st))
2627  fps_analyze_framecount = 0;
2628  if (ic->fps_probe_size >= 0)
2629  fps_analyze_framecount = ic->fps_probe_size;
2631  fps_analyze_framecount = 0;
2632  /* variable fps and no guess at the real fps */
2633  count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
2635  sti->info->duration_count;
2636  if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
2638  if (count < fps_analyze_framecount)
2639  break;
2640  }
2641  // Look at the first 3 frames if there is evidence of frame delay
2642  // but the decoder delay is not set.
2643  if (sti->info->frame_delay_evidence && count < 2 && sti->avctx->has_b_frames == 0)
2644  break;
2645  if (!sti->avctx->extradata &&
2646  (!sti->extract_extradata.inited || sti->extract_extradata.bsf) &&
2648  break;
2649  if (sti->first_dts == AV_NOPTS_VALUE &&
2654  break;
2655  }
2656  analyzed_all_streams = 0;
2657  if (!missing_streams || !*missing_streams)
2658  if (i == ic->nb_streams) {
2659  analyzed_all_streams = 1;
2660  /* NOTE: If the format has no header, then we need to read some
2661  * packets to get most of the streams, so we cannot stop here. */
2662  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2663  /* If we found the info for all the codecs, we can stop. */
2664  ret = count;
2665  av_log(ic, AV_LOG_DEBUG, "All info found\n");
2666  flush_codecs = 0;
2667  break;
2668  }
2669  }
2670  /* We did not get all the codec info, but we read too much data. */
2671  if (read_size >= probesize) {
2672  ret = count;
2673  av_log(ic, AV_LOG_DEBUG,
2674  "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
2675  for (unsigned i = 0; i < ic->nb_streams; i++) {
2676  AVStream *const st = ic->streams[i];
2677  FFStream *const sti = ffstream(st);
2678  if (!st->r_frame_rate.num &&
2679  sti->info->duration_count <= 1 &&
2681  strcmp(ic->iformat->name, "image2"))
2682  av_log(ic, AV_LOG_WARNING,
2683  "Stream #%d: not enough frames to estimate rate; "
2684  "consider increasing probesize\n", i);
2685  }
2686  break;
2687  }
2688 
2689  /* NOTE: A new stream can be added there if no header in file
2690  * (AVFMTCTX_NOHEADER). */
2691  ret = read_frame_internal(ic, pkt1);
2692  if (ret == AVERROR(EAGAIN))
2693  continue;
2694 
2695  if (ret < 0) {
2696  /* EOF or error*/
2697  eof_reached = 1;
2698  break;
2699  }
2700 
2701  if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
2703  pkt1, NULL, 0);
2704  if (ret < 0)
2705  goto unref_then_goto_end;
2706 
2707  pkt = &si->packet_buffer.tail->pkt;
2708  } else {
2709  pkt = pkt1;
2710  }
2711 
2712  st = ic->streams[pkt->stream_index];
2713  sti = ffstream(st);
2715  read_size += pkt->size;
2716 
2717  avctx = sti->avctx;
2718  if (!sti->avctx_inited) {
2720  if (ret < 0)
2721  goto unref_then_goto_end;
2722  sti->avctx_inited = 1;
2723  }
2724 
2725  if (pkt->dts != AV_NOPTS_VALUE && sti->codec_info_nb_frames > 1) {
2726  /* check for non-increasing dts */
2727  if (sti->info->fps_last_dts != AV_NOPTS_VALUE &&
2728  sti->info->fps_last_dts >= pkt->dts) {
2729  av_log(ic, AV_LOG_DEBUG,
2730  "Non-increasing DTS in stream %d: packet %d with DTS "
2731  "%"PRId64", packet %d with DTS %"PRId64"\n",
2732  st->index, sti->info->fps_last_dts_idx,
2734  pkt->dts);
2735  sti->info->fps_first_dts =
2737  }
2738  /* Check for a discontinuity in dts. If the difference in dts
2739  * is more than 1000 times the average packet duration in the
2740  * sequence, we treat it as a discontinuity. */
2741  if (sti->info->fps_last_dts != AV_NOPTS_VALUE &&
2742  sti->info->fps_last_dts_idx > sti->info->fps_first_dts_idx &&
2743  (pkt->dts - (uint64_t)sti->info->fps_last_dts) / 1000 >
2744  (sti->info->fps_last_dts - (uint64_t)sti->info->fps_first_dts) /
2745  (sti->info->fps_last_dts_idx - sti->info->fps_first_dts_idx)) {
2746  av_log(ic, AV_LOG_WARNING,
2747  "DTS discontinuity in stream %d: packet %d with DTS "
2748  "%"PRId64", packet %d with DTS %"PRId64"\n",
2749  st->index, sti->info->fps_last_dts_idx,
2751  pkt->dts);
2752  sti->info->fps_first_dts =
2754  }
2755 
2756  /* update stored dts values */
2757  if (sti->info->fps_first_dts == AV_NOPTS_VALUE) {
2758  sti->info->fps_first_dts = pkt->dts;
2760  }
2761  sti->info->fps_last_dts = pkt->dts;
2763  }
2764  if (sti->codec_info_nb_frames > 1) {
2765  int64_t t = 0;
2766  int64_t limit;
2767 
2768  if (st->time_base.den > 0)
2770  if (st->avg_frame_rate.num > 0)
2772 
2773  if ( t == 0
2774  && sti->codec_info_nb_frames > 30
2775  && sti->info->fps_first_dts != AV_NOPTS_VALUE
2776  && sti->info->fps_last_dts != AV_NOPTS_VALUE) {
2777  int64_t dur = av_sat_sub64(sti->info->fps_last_dts, sti->info->fps_first_dts);
2778  t = FFMAX(t, av_rescale_q(dur, st->time_base, AV_TIME_BASE_Q));
2779  }
2780 
2781  if (analyzed_all_streams) limit = max_analyze_duration;
2782  else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
2783  else limit = max_stream_analyze_duration;
2784 
2785  if (t >= limit) {
2786  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
2787  limit,
2788  t, pkt->stream_index);
2789  if (ic->flags & AVFMT_FLAG_NOBUFFER)
2790  av_packet_unref(pkt1);
2791  break;
2792  }
2793  if (pkt->duration > 0) {
2794  const int fields = sti->codec_desc && (sti->codec_desc->props & AV_CODEC_PROP_FIELDS);
2796  && (uint64_t)pkt->pts - st->start_time < INT64_MAX
2797  ) {
2799  } else
2801  sti->info->codec_info_duration_fields += sti->parser && sti->need_parsing && fields
2802  ? sti->parser->repeat_pict + 1 : 2;
2803  }
2804  }
2805  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2806 #if FF_API_R_FRAME_RATE
2807  ff_rfps_add_frame(ic, st, pkt->dts);
2808 #endif
2809  if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
2810  sti->info->frame_delay_evidence = 1;
2811  }
2812  if (!sti->avctx->extradata) {
2813  ret = extract_extradata(si, st, pkt);
2814  if (ret < 0)
2815  goto unref_then_goto_end;
2816  }
2817 
2818  /* If still no information, we try to open the codec and to
2819  * decompress the frame. We try to avoid that in most cases as
2820  * it takes longer and uses more memory. For MPEG-4, we need to
2821  * decompress for QuickTime.
2822  *
2823  * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2824  * least one frame of codec data, this makes sure the codec initializes
2825  * the channel configuration and does not only trust the values from
2826  * the container. */
2827  try_decode_frame(ic, st, pkt,
2828  (options && i < orig_nb_streams) ? &options[i] : NULL);
2829 
2830  if (ic->flags & AVFMT_FLAG_NOBUFFER)
2831  av_packet_unref(pkt1);
2832 
2833  sti->codec_info_nb_frames++;
2834  count++;
2835  }
2836 
2837  if (eof_reached) {
2838  for (unsigned stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
2839  AVStream *const st = ic->streams[stream_index];
2840  AVCodecContext *const avctx = ffstream(st)->avctx;
2841  if (!has_codec_parameters(st, NULL)) {
2842  const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
2843  if (codec && !avctx->codec) {
2844  AVDictionary *opts = NULL;
2845  if (ic->codec_whitelist)
2846  av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
2847  if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
2848  av_log(ic, AV_LOG_WARNING,
2849  "Failed to open codec in %s\n", __func__);
2850  av_dict_free(&opts);
2851  }
2852  }
2853 
2854  // EOF already reached while reading the stream above.
2855  // So continue with reoordering DTS with whatever delay we have.
2857  update_dts_from_pts(ic, stream_index, si->packet_buffer.head);
2858  }
2859  }
2860  }
2861 
2862  if (flush_codecs) {
2863  AVPacket *empty_pkt = si->pkt;
2864  int err = 0;
2865  av_packet_unref(empty_pkt);
2866 
2867  for (unsigned i = 0; i < ic->nb_streams; i++) {
2868  AVStream *const st = ic->streams[i];
2869  FFStream *const sti = ffstream(st);
2870 
2871  /* flush the decoders */
2872  if (sti->info->found_decoder == 1) {
2873  err = try_decode_frame(ic, st, empty_pkt,
2874  (options && i < orig_nb_streams)
2875  ? &options[i] : NULL);
2876 
2877  if (err < 0) {
2878  av_log(ic, AV_LOG_INFO,
2879  "decoding for stream %d failed\n", st->index);
2880  }
2881  }
2882  }
2883  }
2884 
2885  ff_rfps_calculate(ic);
2886 
2887  for (unsigned i = 0; i < ic->nb_streams; i++) {
2888  AVStream *const st = ic->streams[i];
2889  FFStream *const sti = ffstream(st);
2890  AVCodecContext *const avctx = sti->avctx;
2891 
2892  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
2893  if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
2894  uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
2896  avctx->codec_tag= tag;
2897  }
2898 
2899  /* estimate average framerate if not set by demuxer */
2900  if (sti->info->codec_info_duration_fields &&
2901  !st->avg_frame_rate.num &&
2902  sti->info->codec_info_duration) {
2903  int best_fps = 0;
2904  double best_error = 0.01;
2905  AVRational codec_frame_rate = avctx->framerate;
2906 
2907  if (sti->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
2908  sti->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
2909  sti->info->codec_info_duration < 0)
2910  continue;
2912  sti->info->codec_info_duration_fields * (int64_t) st->time_base.den,
2913  sti->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
2914 
2915  /* Round guessed framerate to a "standard" framerate if it's
2916  * within 1% of the original estimate. */
2917  for (int j = 0; j < MAX_STD_TIMEBASES; j++) {
2918  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
2919  double error = fabs(av_q2d(st->avg_frame_rate) /
2920  av_q2d(std_fps) - 1);
2921 
2922  if (error < best_error) {
2923  best_error = error;
2924  best_fps = std_fps.num;
2925  }
2926 
2927  if (si->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
2928  error = fabs(av_q2d(codec_frame_rate) /
2929  av_q2d(std_fps) - 1);
2930  if (error < best_error) {
2931  best_error = error;
2932  best_fps = std_fps.num;
2933  }
2934  }
2935  }
2936  if (best_fps)
2938  best_fps, 12 * 1001, INT_MAX);
2939  }
2940  if (!st->r_frame_rate.num) {
2941  const AVCodecDescriptor *desc = sti->codec_desc;
2942  AVRational mul = (AVRational){ desc && (desc->props & AV_CODEC_PROP_FIELDS) ? 2 : 1, 1 };
2943  AVRational fr = av_mul_q(avctx->framerate, mul);
2944 
2945  if (fr.num && fr.den && av_cmp_q(st->time_base, av_inv_q(fr)) <= 0) {
2946  st->r_frame_rate = fr;
2947  } else {
2948  st->r_frame_rate.num = st->time_base.den;
2949  st->r_frame_rate.den = st->time_base.num;
2950  }
2951  }
2952  st->codecpar->framerate = avctx->framerate;
2953  if (sti->display_aspect_ratio.num && sti->display_aspect_ratio.den) {
2954  AVRational hw_ratio = { avctx->height, avctx->width };
2956  hw_ratio);
2957  }
2958  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2959  if (!avctx->bits_per_coded_sample)
2960  avctx->bits_per_coded_sample =
2962  // set stream disposition based on audio service type
2963  switch (avctx->audio_service_type) {
2966  break;
2969  break;
2972  break;
2975  break;
2978  break;
2979  }
2980  }
2981  }
2982 
2983  if (probesize)
2984  estimate_timings(ic, old_offset);
2985 
2986  av_opt_set_int(ic, "skip_clear", 0, AV_OPT_SEARCH_CHILDREN);
2987 
2988  if (ret >= 0 && ic->nb_streams)
2989  /* We could not have all the codec parameters before EOF. */
2990  ret = -1;
2991  for (unsigned i = 0; i < ic->nb_streams; i++) {
2992  AVStream *const st = ic->streams[i];
2993  FFStream *const sti = ffstream(st);
2994  const char *errmsg;
2995 
2996  /* if no packet was ever seen, update context now for has_codec_parameters */
2997  if (!sti->avctx_inited) {
2998  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3000  st->codecpar->format = sti->avctx->sample_fmt;
3002  if (ret < 0)
3003  goto find_stream_info_err;
3004  }
3005  if (!has_codec_parameters(st, &errmsg)) {
3006  char buf[256];
3007  avcodec_string(buf, sizeof(buf), sti->avctx, 0);
3008  av_log(ic, AV_LOG_WARNING,
3009  "Could not find codec parameters for stream %d (%s): %s\n"
3010  "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
3011  i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
3012  } else {
3013  ret = 0;
3014  }
3015  }
3016 
3017  ret = compute_chapters_end(ic);
3018  if (ret < 0)
3019  goto find_stream_info_err;
3020 
3021  /* update the stream parameters from the internal codec contexts */
3022  for (unsigned i = 0; i < ic->nb_streams; i++) {
3023  AVStream *const st = ic->streams[i];
3024  FFStream *const sti = ffstream(st);
3025 
3026  if (sti->avctx_inited) {
3028  if (ret < 0)
3029  goto find_stream_info_err;
3030 
3031  if (sti->avctx->rc_buffer_size > 0 || sti->avctx->rc_max_rate > 0 ||
3032  sti->avctx->rc_min_rate) {
3033  size_t cpb_size;
3034  AVCPBProperties *props = av_cpb_properties_alloc(&cpb_size);
3035  if (props) {
3036  if (sti->avctx->rc_buffer_size > 0)
3037  props->buffer_size = sti->avctx->rc_buffer_size;
3038  if (sti->avctx->rc_min_rate > 0)
3039  props->min_bitrate = sti->avctx->rc_min_rate;
3040  if (sti->avctx->rc_max_rate > 0)
3041  props->max_bitrate = sti->avctx->rc_max_rate;
3045  (uint8_t *)props, cpb_size, 0))
3046  av_free(props);
3047  }
3048  }
3049  }
3050 
3051  sti->avctx_inited = 0;
3052 #if FF_API_AVSTREAM_SIDE_DATA
3054  if (st->codecpar->nb_coded_side_data > 0) {
3055  av_assert0(!st->side_data && !st->nb_side_data);
3056  st->side_data = av_calloc(st->codecpar->nb_coded_side_data, sizeof(*st->side_data));
3057  if (!st->side_data) {
3058  ret = AVERROR(ENOMEM);
3059  goto find_stream_info_err;
3060  }
3061 
3062  for (int j = 0; j < st->codecpar->nb_coded_side_data; j++) {
3063  uint8_t *data = av_memdup(st->codecpar->coded_side_data[j].data,
3064  st->codecpar->coded_side_data[j].size);
3065  if (!data) {
3066  ret = AVERROR(ENOMEM);
3067  goto find_stream_info_err;
3068  }
3069  st->side_data[j].type = st->codecpar->coded_side_data[j].type;
3070  st->side_data[j].size = st->codecpar->coded_side_data[j].size;
3071  st->side_data[j].data = data;
3072  st->nb_side_data++;
3073  }
3074  }
3076 #endif
3077  }
3078 
3079 find_stream_info_err:
3080  for (unsigned i = 0; i < ic->nb_streams; i++) {
3081  AVStream *const st = ic->streams[i];
3082  FFStream *const sti = ffstream(st);
3083  int err;
3084 
3085  if (sti->info) {
3086  av_freep(&sti->info->duration_error);
3087  av_freep(&sti->info);
3088  }
3089 
3090  err = codec_close(sti);
3091  if (err < 0 && ret >= 0)
3092  ret = err;
3094  }
3095  if (ic->pb) {
3096  FFIOContext *const ctx = ffiocontext(ic->pb);
3097  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3098  avio_tell(ic->pb), ctx->bytes_read, ctx->seek_count, count);
3099  }
3100  return ret;
3101 
3102 unref_then_goto_end:
3103  av_packet_unref(pkt1);
3104  goto find_stream_info_err;
3105 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:522
AVSubtitle
Definition: avcodec.h:2227
FFStreamInfo::fps_last_dts
int64_t fps_last_dts
Definition: demux.h:163
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1077
av_opt_get_dict_val
int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
Definition: opt.c:1326
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:427
AVCodec
AVCodec.
Definition: codec.h:187
ff_rfps_add_frame
int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
add frame for rfps calculation.
Definition: demux.c:2274
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AVBSFContext::par_in
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:90
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVFMT_FLAG_DISCARD_CORRUPT
#define AVFMT_FLAG_DISCARD_CORRUPT
Discard frames marked corrupted.
Definition: avformat.h:1415
FFStream::skip_samples
int skip_samples
Number of samples to skip at the start of the frame decoded from the next packet.
Definition: internal.h:273
name
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 default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
PacketList::head
PacketListEntry * head
Definition: packet_internal.h:34
AVCodecParserContext::pts
int64_t pts
Definition: avcodec.h:2726
DURATION_DEFAULT_MAX_RETRY
#define DURATION_DEFAULT_MAX_RETRY
Definition: demux.c:1808
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:443
program
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C program
Definition: undefined.txt:6
AVFMT_DURATION_FROM_BITRATE
@ AVFMT_DURATION_FROM_BITRATE
Duration estimated from bitrate (less accurate)
Definition: avformat.h:1238
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1640
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
FFFormatContext::prefer_codec_framerate
int prefer_codec_framerate
Definition: internal.h:175
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
av_probe_input_buffer2
int av_probe_input_buffer2(AVIOContext *pb, const AVInputFormat **fmt, const char *url, void *logctx, unsigned int offset, unsigned int max_probe_size)
Probe a bytestream to determine the input format.
Definition: format.c:251
AVCodecContext::audio_service_type
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:1097
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:424
av_compare_ts
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
Definition: mathematics.c:147
FF_FDEBUG_TS
#define FF_FDEBUG_TS
Definition: avformat.h:1534
AVSTREAM_EVENT_FLAG_NEW_PACKETS
#define AVSTREAM_EVENT_FLAG_NEW_PACKETS
Definition: avformat.h:899
av_add_stable
int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc)
Add a value to a timestamp.
Definition: mathematics.c:191
ff_find_decoder
const AVCodec * ff_find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
Definition: avformat.c:880
FFStream::first_dts
int64_t first_dts
Timestamp corresponding to the last dts sync point.
Definition: internal.h:409
AVCodecParserContext::pict_type
int pict_type
Definition: avcodec.h:2715
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
AVCodecContext::rc_min_rate
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1299
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
ffiocontext
static av_always_inline FFIOContext * ffiocontext(AVIOContext *ctx)
Definition: avio_internal.h:81
FFStream::bsf
struct AVBSFContext * bsf
Definition: internal.h:231
FFStream::last_IP_pts
int64_t last_IP_pts
Definition: internal.h:377
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:188
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:56
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AV_DISPOSITION_ATTACHED_PIC
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:674
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:814
av_find_program_from_stream
AVProgram * av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
Find the programs which belong to a given stream.
Definition: avformat.c:392
AV_PKT_FLAG_DISCARD
#define AV_PKT_FLAG_DISCARD
Flag is used to discard packets which are required to maintain valid decoder state but are not requir...
Definition: packet.h:586
AVCodecParserContext::duration
int duration
Duration of the current frame.
Definition: avcodec.h:2821
avcodec_string
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: avcodec.c:495
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:479
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
ff_buffer_packet
int ff_buffer_packet(AVFormatContext *s, AVPacket *pkt)
Definition: demux.c:609
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
id3v2.h
FFStream::first_discard_sample
int64_t first_discard_sample
If not 0, the first audio sample that should be discarded from the stream.
Definition: internal.h:290
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1323
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:375
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:206
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:524
AV_CODEC_ID_DVB_TELETEXT
@ AV_CODEC_ID_DVB_TELETEXT
Definition: codec_id.h:557
extract_extradata_check
static int extract_extradata_check(AVStream *st)
Definition: demux.c:2399
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:832
AVChapter::start
int64_t start
Definition: avformat.h:1217
AVFMT_FLAG_CUSTOM_IO
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don't avio_close() it.
Definition: avformat.h:1414
data
const char data[16]
Definition: mxf.c:148
has_duration
static int has_duration(AVFormatContext *ic)
Return TRUE if the stream has accurate duration in any stream.
Definition: demux.c:1626
AVFormatContext::duration_estimation_method
enum AVDurationEstimationMethod duration_estimation_method
The duration field can be estimated through various ways, and this field can be used to know how the ...
Definition: avformat.h:1686
AVCodecParameters::framerate
AVRational framerate
Video only.
Definition: codec_par.h:156
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1456
handle_new_packet
static int handle_new_packet(AVFormatContext *s, AVPacket *pkt, int allow_passthrough)
Handle a new packet and either return it directly if possible and allow_passthrough is true or queue ...
Definition: demux.c:564
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:542
ts_to_samples
static int64_t ts_to_samples(AVStream *st, int64_t ts)
Definition: demux.c:1270
mathematics.h
AVDictionary
Definition: dict.c:34
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:454
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AVFormatContext::probesize
int64_t probesize
Maximum number of bytes read from input in order to determine stream properties.
Definition: avformat.h:1442
estimate_timings_from_pts
static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
Definition: demux.c:1812
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1526
cffstream
static const av_always_inline FFStream * cffstream(const AVStream *st)
Definition: internal.h:422
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:690
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
wrap_timestamp
static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
Definition: demux.c:52
FFInputFormat::priv_data_size
int priv_data_size
Size of private data so that it can be allocated in the wrapper.
Definition: demux.h:51
FFStream::last_dts_for_order_check
int64_t last_dts_for_order_check
Internal data to analyze DTS and detect faulty mpeg streams.
Definition: internal.h:352
AV_CODEC_ID_HDMV_PGS_SUBTITLE
@ AV_CODEC_ID_HDMV_PGS_SUBTITLE
Definition: codec_id.h:556
FFInputFormat::read_header
int(* read_header)(struct AVFormatContext *)
Read the format header and initialize the AVFormatContext structure.
Definition: demux.h:70
av_bsf_free
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
Definition: bsf.c:52
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:323
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:484
update_stream_timings
static void update_stream_timings(AVFormatContext *ic)
Estimate the stream timings from the one of each components.
Definition: demux.c:1643
FFIOContext
Definition: avio_internal.h:28
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:579
sample_rate
sample_rate
Definition: ffmpeg_filter.c:424
codec_close
static int codec_close(FFStream *sti)
Definition: demux.c:1275
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:610
FFStream::codec_desc
const struct AVCodecDescriptor * codec_desc
Definition: internal.h:412
avcodec_pix_fmt_to_codec_tag
unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt)
Return a value representing the fourCC code associated to the pixel format pix_fmt,...
Definition: raw.c:308
av_gcd
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
genpts
static int genpts
Definition: ffplay.c:329
av_filename_number_test
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:127
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:304
avformat_queue_attached_pictures
int avformat_queue_attached_pictures(AVFormatContext *s)
Definition: demux_utils.c:93
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:560
avformat_close_input
void avformat_close_input(AVFormatContext **ps)
Close an opened input AVFormatContext.
Definition: demux.c:363
AVPacketSideData::size
size_t size
Definition: packet.h:377
AVCodecParserContext::offset
int64_t offset
byte offset from starting packet start
Definition: avcodec.h:2747
MAX_STD_TIMEBASES
#define MAX_STD_TIMEBASES
Definition: demux.h:138
AVFormatContext::interrupt_callback
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1528
AVCodecParserContext::key_frame
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
Definition: avcodec.h:2756
FFStream::dts_ordered
uint8_t dts_ordered
Definition: internal.h:353
finish
static void finish(void)
Definition: movenc.c:373
FFStream::last_IP_duration
int last_IP_duration
Definition: internal.h:378
force_codec_ids
static void force_codec_ids(AVFormatContext *s, AVStream *st)
Definition: demux.c:389
bsf.h
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:454
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:417
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
update_initial_timestamps
static void update_initial_timestamps(AVFormatContext *s, int stream_index, int64_t dts, int64_t pts, AVPacket *pkt)
Definition: demux.c:849
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1819
fail
#define fail()
Definition: checkasm.h:179
av_add_index_entry
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: seek.c:121
AVSTREAM_PARSE_FULL_ONCE
@ AVSTREAM_PARSE_FULL_ONCE
full parsing and repack of the first frame only, only implemented for H.264 currently
Definition: avformat.h:596
FFStreamInfo::fps_first_dts
int64_t fps_first_dts
Those are used for average framerate estimation.
Definition: demux.h:161
FFStream::inited
int inited
Definition: internal.h:232
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
avpriv_packet_list_get
int avpriv_packet_list_get(PacketList *pkt_buffer, AVPacket *pkt)
Remove the oldest AVPacket in the list and return it.
Definition: packet.c:580
AVERROR_OPTION_NOT_FOUND
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:63
FFStream::avctx
struct AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:221
AVChapter
Definition: avformat.h:1214
AVFMT_GENERIC_INDEX
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:480
AVFMT_DURATION_FROM_PTS
@ AVFMT_DURATION_FROM_PTS
Duration accurately estimated from PTSes.
Definition: avformat.h:1236
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
AVPROBE_PADDING_SIZE
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:465
av_parser_init
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:32
pts
static int64_t pts
Definition: transcode_aac.c:644
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:441
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:802
FFFormatContext::metafree
int metafree
Contexts and child contexts do not contain a metadata option.
Definition: internal.h:185
av_probe_input_format3
const AVInputFormat * av_probe_input_format3(const AVProbeData *pd, int is_opened, int *score_ret)
Guess the file format.
Definition: format.c:154
AV_PTS_WRAP_IGNORE
#define AV_PTS_WRAP_IGNORE
Options for behavior on timestamp wrap detection.
Definition: avformat.h:732
ff_check_interrupt
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrupt a blocking function associated with cb.
Definition: avio.c:854
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
extract_extradata_init
static int extract_extradata_init(AVStream *st)
Definition: demux.c:2415
AVCodecParserContext::dts
int64_t dts
Definition: avcodec.h:2727
AVRational::num
int num
Numerator.
Definition: rational.h:59
FFDIFFSIGN
#define FFDIFFSIGN(x, y)
Comparator.
Definition: macros.h:45
ff_id3v2_parse_chapters
int ff_id3v2_parse_chapters(AVFormatContext *s, ID3v2ExtraMeta *cur)
Create chapters for all CHAP tags found in the ID3v2 header.
Definition: id3v2.c:1193
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:393
raw.h
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:148
AV_CODEC_ID_DVB_SUBTITLE
@ AV_CODEC_ID_DVB_SUBTITLE
Definition: codec_id.h:551
a1
#define a1
Definition: regdef.h:47
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1397
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:547
avcodec_decode_subtitle2
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, const AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:930
AV_DISPOSITION_CLEAN_EFFECTS
#define AV_DISPOSITION_CLEAN_EFFECTS
The audio stream contains music and sound effects without voice.
Definition: avformat.h:666
AVFormatContext::max_ts_probe
int max_ts_probe
Maximum number of packets to read while waiting for the first timestamp.
Definition: avformat.h:1583
avassert.h
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
pkt
AVPacket * pkt
Definition: movenc.c:60
chapter_start_cmp
static int chapter_start_cmp(const void *p1, const void *p2)
Definition: demux.c:2178
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AV_CODEC_CAP_EXPERIMENTAL
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: codec.h:102
AVInputFormat
Definition: avformat.h:548
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:580
ID3v2ExtraMeta
Definition: id3v2.h:84
AVFormatContext::ctx_flags
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1304
duration
int64_t duration
Definition: movenc.c:65
avformat_open_input
int avformat_open_input(AVFormatContext **ps, const char *filename, const AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: demux.c:215
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:723
FFFormatContext::parse_queue
PacketList parse_queue
Packets split by the parser get queued here.
Definition: internal.h:113
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:149
AVChapter::end
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1217
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CODEC_ID_EVC
@ AV_CODEC_ID_EVC
Definition: codec_id.h:321
FFInputFormat::flags_internal
int flags_internal
Internal flags.
Definition: demux.h:56
FFFormatContext::packet_buffer
PacketList packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:98
FFStreamInfo::last_dts
int64_t last_dts
Definition: demux.h:140
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1406
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:144
duration_name
static const char *const duration_name[]
Definition: demux.c:1954
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1455
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
bitrate
int64_t bitrate
Definition: av1_levels.c:47
AVFormatContext::iformat
const struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1267
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
frame_size
int frame_size
Definition: mxfenc.c:2423
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:440
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
info
MIPS optimizations info
Definition: mips.txt:2
RELATIVE_TS_BASE
#define RELATIVE_TS_BASE
Definition: demux.h:173
FFStream::nb_decoded_frames
int nb_decoded_frames
Number of internally decoded frames, used internally in libavformat, do not access its lifetime diffe...
Definition: internal.h:303
av_opt_set_dict_val
int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
Definition: opt.c:915
avpriv_h264_has_num_reorder_frames
int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
Definition: h264dec.c:61
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:695
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AVPacketSideData::data
uint8_t * data
Definition: packet.h:376
FFFormatContext::data_offset
int64_t data_offset
offset of the first packet
Definition: internal.h:101
ctx
AVFormatContext * ctx
Definition: movenc.c:49
FFStream::codec_info_nb_frames
int codec_info_nb_frames
Number of frames that have been demuxed during avformat_find_stream_info()
Definition: internal.h:392
AVBSFContext::time_base_in
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: bsf.h:102
FFStream::pts_reorder_error_count
uint8_t pts_reorder_error_count[MAX_REORDER_DELAY+1]
Definition: internal.h:345
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
FFStream::display_aspect_ratio
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
Definition: internal.h:368
AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
@ AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
Definition: defs.h:226
av_bsf_alloc
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:104
DURATION_MAX_RETRY
#define DURATION_MAX_RETRY
Definition: demux.c:1809
AV_CODEC_ID_CODEC2
@ AV_CODEC_ID_CODEC2
Definition: codec_id.h:507
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:387
AVProgram::start_time
int64_t start_time
Definition: avformat.h:1199
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1292
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:86
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
FFStream::pts_reorder_error
int64_t pts_reorder_error[MAX_REORDER_DELAY+1]
Internal data to generate dts from pts.
Definition: internal.h:344
determinable_frame_size
static int determinable_frame_size(const AVCodecContext *avctx)
Definition: demux.c:2014
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:269
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
PacketList::tail
PacketListEntry * tail
Definition: packet_internal.h:34
AVFMT_NEEDNUMBER
#define AVFMT_NEEDNUMBER
Needs 'd' in filename.
Definition: avformat.h:469
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:455
FFStreamInfo::found_decoder
int found_decoder
0 -> decoder has not been searched for yet.
Definition: demux.h:154
AVFormatContext::max_analyze_duration
int64_t max_analyze_duration
Maximum duration (in AV_TIME_BASE units) of the data read from input in avformat_find_stream_info().
Definition: avformat.h:1450
AVCodecDescriptor::props
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
AVFMT_FLAG_NOPARSE
#define AVFMT_FLAG_NOPARSE
Do not use AVParsers, you also must set AVFMT_FLAG_NOFILLIN as the fillin code works on frames and no...
Definition: avformat.h:1412
fields
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 then the processing requires a frame on this link and the filter is expected to make efforts in that direction The status of input links is stored by the fifo and status_out fields
Definition: filter_design.txt:155
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:73
if
if(ret)
Definition: filter_design.txt:179
av_probe_input_format2
const AVInputFormat * av_probe_input_format2(const AVProbeData *pd, int is_opened, int *score_max)
Guess the file format.
Definition: format.c:233
get_std_framerate
static int get_std_framerate(int i)
Definition: demux.c:2225
has_codec_parameters
static int has_codec_parameters(const AVStream *st, const char **errmsg_ptr)
Definition: demux.c:2027
FFFormatContext
Definition: internal.h:64
FF_INFMT_FLAG_INIT_CLEANUP
#define FF_INFMT_FLAG_INIT_CLEANUP
For an FFInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition: demux.h:35
AVCodecParserContext::repeat_pict
int repeat_pict
This field is used for proper frame duration computation in lavf.
Definition: avcodec.h:2725
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:386
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1277
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
opts
AVDictionary * opts
Definition: movenc.c:51
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:507
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.
framerate
float framerate
Definition: av1_levels.c:29
av_bsf_init
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:149
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
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
FFStream::avctx_inited
int avctx_inited
1 if avctx has been initialized with the values from the codec parameters
Definition: internal.h:225
avcodec_find_decoder_by_name
const AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:1001
av_match_list
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
Definition: avstring.c:444
avcodec_parameters_free
void avcodec_parameters_free(AVCodecParameters **ppar)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: codec_par.c:66
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1206
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:230
FFStreamInfo::codec_info_duration
int64_t codec_info_duration
Definition: demux.h:145
avpriv_packet_list_put
int avpriv_packet_list_put(PacketList *packet_buffer, AVPacket *pkt, int(*copy)(AVPacket *dst, const AVPacket *src), int flags)
Append an AVPacket to the list.
Definition: packet.c:541
AVFormatContext::fps_probe_size
int fps_probe_size
The number of frames used for determining the framerate in avformat_find_stream_info().
Definition: avformat.h:1510
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
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVFMT_DURATION_FROM_STREAM
@ AVFMT_DURATION_FROM_STREAM
Duration estimated from a stream with a known duration.
Definition: avformat.h:1237
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:495
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:378
AV_DISPOSITION_COMMENT
#define AV_DISPOSITION_COMMENT
The stream is a commentary track.
Definition: avformat.h:639
AVSTREAM_PARSE_NONE
@ AVSTREAM_PARSE_NONE
Definition: avformat.h:592
update_initial_durations
static void update_initial_durations(AVFormatContext *s, AVStream *st, int stream_index, int64_t duration)
Definition: demux.c:902
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
ff_id3v2_parse_apic
int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create a stream for each APIC (attached picture) extracted from the ID3v2 header.
Definition: id3v2.c:1162
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1297
probe_codec
static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
Definition: demux.c:411
FFStream::extract_extradata
struct FFStream::@325 extract_extradata
AVDurationEstimationMethod
AVDurationEstimationMethod
The duration of a video can be estimated through various ways, and this enum can be used to know how ...
Definition: avformat.h:1235
AVFormatContext::duration_probesize
int64_t duration_probesize
Maximum number of bytes read from input in order to determine stream durations when using estimate_ti...
Definition: avformat.h:1882
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AV_ROUND_NEAR_INF
@ AV_ROUND_NEAR_INF
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:135
get_next_pkt
static PacketListEntry * get_next_pkt(AVFormatContext *s, AVStream *st, PacketListEntry *pktl)
Definition: demux.c:765
double
double
Definition: af_crystalizer.c:131
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:142
AVCodecParserContext::flags
int flags
Definition: avcodec.h:2740
time.h
AVFormatContext::skip_estimate_duration_from_pts
int skip_estimate_duration_from_pts
Skip duration calcuation in estimate_timings_from_pts.
Definition: avformat.h:1671
FFStreamInfo::codec_info_duration_fields
int64_t codec_info_duration_fields
Definition: demux.h:146
av_packet_ref
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: packet.c:435
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
PacketListEntry::next
struct PacketListEntry * next
Definition: packet_internal.h:29
read_frame_internal
static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
Definition: demux.c:1322
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
FAIL
#define FAIL(errmsg)
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:791
duration_estimate_name
static const char * duration_estimate_name(enum AVDurationEstimationMethod method)
Definition: demux.c:1960
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
FFInputFormat::read_packet
int(* read_packet)(struct AVFormatContext *, AVPacket *pkt)
Read one packet and put it in 'pkt'.
Definition: demux.h:80
AV_CODEC_ID_EAC3
@ AV_CODEC_ID_EAC3
Definition: codec_id.h:480
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1311
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:106
FFFormatContext::id3v2_meta
AVDictionary * id3v2_meta
ID3v2 tag useful for MP3 demuxing.
Definition: internal.h:170
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:442
AVFMT_FLAG_NOFILLIN
#define AVFMT_FLAG_NOFILLIN
Do not infer any values from other values, just return what is stored in the container.
Definition: avformat.h:1411
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:86
av_sat_sub64
#define av_sat_sub64
Definition: common.h:144
av_rescale_rnd
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
options
const OptionDef options[]
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:2503
f
f
Definition: af_crystalizer.c:121
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
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:83
AVMediaType
AVMediaType
Definition: avutil.h:199
AVCodecParserContext::frame_offset
int64_t frame_offset
Definition: avcodec.h:2710
AV_PTS_WRAP_SUB_OFFSET
#define AV_PTS_WRAP_SUB_OFFSET
subtract the format specific offset on wrap detection
Definition: avformat.h:734
AVPacket::size
int size
Definition: packet.h:525
avpriv_pix_fmt_find
enum AVPixelFormat avpriv_pix_fmt_find(enum PixelFormatTagLists list, unsigned fourcc)
Definition: raw.c:355
FFFormatContext::parse_pkt
AVPacket * parse_pkt
The generic code uses this as a temporary packet to parse packets or for muxing, especially flushing.
Definition: internal.h:127
FFStreamInfo
Definition: demux.h:139
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:161
init_input
static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
Definition: demux.c:156
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:261
FFStream
Definition: internal.h:193
shift
static int shift(int a, int b)
Definition: bonk.c:261
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:202
AVProgram::end_time
int64_t end_time
Definition: avformat.h:1200
start_time
static int64_t start_time
Definition: ffplay.c:326
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:444
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1057
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:551
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
sample
#define sample
Definition: flacdsp_template.c:44
FFStreamInfo::duration_count
int duration_count
Definition: demux.h:142
size
int size
Definition: twinvq_data.h:10344
ID3v2_DEFAULT_MAGIC
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
Definition: id3v2.h:35
PIX_FMT_LIST_RAW
@ PIX_FMT_LIST_RAW
Definition: raw.h:40
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AV_CODEC_PROP_FIELDS
#define AV_CODEC_PROP_FIELDS
Video codec supports separate coding of fields in interlaced frames.
Definition: codec_desc.h:97
update_wrap_reference
static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
Definition: demux.c:464
AVStream::event_flags
int event_flags
Flags indicating events happening on the stream, a combination of AVSTREAM_EVENT_FLAG_*.
Definition: avformat.h:886
FFStream::dts_misordered
uint8_t dts_misordered
Definition: internal.h:354
av_get_audio_frame_duration2
int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)
This function is the same as av_get_audio_frame_duration(), except it works with AVCodecParameters in...
Definition: utils.c:796
PacketListEntry::pkt
AVPacket pkt
Definition: packet_internal.h:30
AV_PTS_WRAP_ADD_OFFSET
#define AV_PTS_WRAP_ADD_OFFSET
add the format specific offset on wrap detection
Definition: avformat.h:733
AVFMT_FLAG_IGNDTS
#define AVFMT_FLAG_IGNDTS
Ignore DTS on frames that contain both DTS & PTS.
Definition: avformat.h:1410
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:278
AVCPBProperties::min_bitrate
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: defs.h:279
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:821
set_codec_from_probe_data
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
Definition: demux.c:102
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:165
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
The stream is intended for hearing impaired audiences.
Definition: avformat.h:658
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:523
update_stream_avctx
static int update_stream_avctx(AVFormatContext *s)
Definition: demux.c:187
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
AV_CODEC_ID_VVC
@ AV_CODEC_ID_VVC
Definition: codec_id.h:250
av_packet_side_data_add
AVPacketSideData * av_packet_side_data_add(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, void *data, size_t size, int flags)
Wrap existing data as packet side data.
Definition: packet.c:697
AV_CODEC_ID_RV30
@ AV_CODEC_ID_RV30
Definition: codec_id.h:120
offset
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 offset
Definition: writing_filters.txt:86
FFStream::pts_wrap_behavior
int pts_wrap_behavior
Options for behavior, when a wrap is detected.
Definition: internal.h:332
FFStreamInfo::last_duration
int64_t last_duration
Definition: demux.h:156
FFFormatContext::raw_packet_buffer_size
int raw_packet_buffer_size
Sum of the size of packets in raw_packet_buffer, in bytes.
Definition: internal.h:138
av_packet_make_refcounted
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: packet.c:490
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:530
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
FFStreamInfo::rfps_duration_sum
int64_t rfps_duration_sum
Definition: demux.h:143
FFStream::update_initial_durations_done
int update_initial_durations_done
Internal data to prevent doing update_initial_durations() twice.
Definition: internal.h:337
FFStream::start_skip_samples
int64_t start_skip_samples
If not 0, the number of samples that should be skipped from the start of the stream (the samples are ...
Definition: internal.h:282
estimate_timings_from_bit_rate
static void estimate_timings_from_bit_rate(AVFormatContext *ic)
Definition: demux.c:1754
FFStream::probe_packets
int probe_packets
Number of packets to buffer for codec probing.
Definition: internal.h:383
a0
#define a0
Definition: regdef.h:46
ff_rfps_calculate
void ff_rfps_calculate(AVFormatContext *ic)
Definition: demux.c:2335
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
FFERROR_REDO
#define FFERROR_REDO
Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data).
Definition: demux.h:171
FFStream::probe_data
AVProbeData probe_data
Definition: internal.h:370
av_opt_ptr
void * av_opt_ptr(const AVClass *class, void *obj, const char *name)
Gets a pointer to the requested field in a struct.
Definition: opt.c:2018
AVCodec::id
enum AVCodecID id
Definition: codec.h:201
filesize
static int64_t filesize(AVIOContext *pb)
Definition: ffmpeg_mux.c:51
FFStream::skip_to_keyframe
int skip_to_keyframe
Indicates that everything up to the next keyframe should be discarded.
Definition: internal.h:268
avcodec_parameters_alloc
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: codec_par.c:56
FFStreamInfo::duration_error
double(* duration_error)[2][MAX_STD_TIMEBASES]
Definition: demux.h:144
AV_CODEC_ID_GIF
@ AV_CODEC_ID_GIF
Definition: codec_id.h:149
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:406
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1567
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
FFFormatContext::raw_packet_buffer
PacketList raw_packet_buffer
Raw packets from the demuxer, prior to parsing and decoding.
Definition: internal.h:109
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
AVFMT_FLAG_NOBUFFER
#define AVFMT_FLAG_NOBUFFER
Do not buffer frames when possible.
Definition: avformat.h:1413
AV_PKT_DATA_CPB_PROPERTIES
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:146
ff_is_intra_only
int ff_is_intra_only(enum AVCodecID id)
Definition: avformat.c:926
AV_CODEC_ID_RV40
@ AV_CODEC_ID_RV40
Definition: codec_id.h:121
AVCodecParserContext::pos
int64_t pos
Byte position of currently parsed frame in stream.
Definition: avcodec.h:2809
PacketListEntry
Definition: packet_internal.h:28
PARSER_FLAG_COMPLETE_FRAMES
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:2741
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:517
avio_internal.h
ff_read_packet
int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
Read a transport packet from a media file.
Definition: demux.c:616
AVChapter::id
int64_t id
unique ID to identify the chapter
Definition: avformat.h:1215
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: packet.c:252
internal.h
find_probe_decoder
static const AVCodec * find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
Definition: demux.c:72
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
ff_id3v2_read_dict
void ff_id3v2_read_dict(AVIOContext *pb, AVDictionary **metadata, const char *magic, ID3v2ExtraMeta **extra_meta)
Read an ID3v2 tag into specified dictionary and retrieve supported extra metadata.
Definition: id3v2.c:1134
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
AVFormatContext::codec_whitelist
char * codec_whitelist
',' separated list of allowed decoders.
Definition: avformat.h:1742
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:274
compute_frame_duration
static void compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st, AVCodecParserContext *pc, AVPacket *pkt)
Return the frame duration in seconds.
Definition: demux.c:683
delta
float delta
Definition: vorbis_enc_data.h:430
AV_ROUND_DOWN
@ AV_ROUND_DOWN
Round toward -infinity.
Definition: mathematics.h:133
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
AV_DISPOSITION_KARAOKE
#define AV_DISPOSITION_KARAOKE
The stream contains karaoke audio.
Definition: avformat.h:647
ff_wrap_timestamp
int64_t ff_wrap_timestamp(const AVStream *st, int64_t timestamp)
Wrap a given time stamp, if there is an indication for an overflow.
Definition: demux.c:67
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
url.h
FFStream::pts_buffer
int64_t pts_buffer[MAX_REORDER_DELAY+1]
Definition: internal.h:347
av_find_default_stream_index
int av_find_default_stream_index(AVFormatContext *s)
Definition: avformat.c:407
AVPROBE_SCORE_RETRY
#define AVPROBE_SCORE_RETRY
Definition: avformat.h:458
AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
@ AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
Definition: defs.h:225
av_get_audio_frame_duration
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:783
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1179
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
demux.h
len
int len
Definition: vorbis_enc_data.h:426
AV_CODEC_ID_JPEG2000
@ AV_CODEC_ID_JPEG2000
Definition: codec_id.h:140
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition: codec_par.h:81
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
FFStreamInfo::frame_delay_evidence
int frame_delay_evidence
Definition: demux.h:147
update_timestamps
static void update_timestamps(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: demux.c:532
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
av_codec_iterate
const AVCodec * av_codec_iterate(void **opaque)
Iterate over all registered codecs.
Definition: allcodecs.c:924
try_decode_frame
static int try_decode_frame(AVFormatContext *s, AVStream *st, const AVPacket *pkt, AVDictionary **options)
Definition: demux.c:2076
avcodec.h
limit
static double limit(double x)
Definition: vf_pseudocolor.c:142
AVCodecParserContext
Definition: avcodec.h:2707
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
MAX_REORDER_DELAY
@ MAX_REORDER_DELAY
Definition: vaapi_encode.h:45
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:812
AVFMT_FLAG_GENPTS
#define AVFMT_FLAG_GENPTS
Generate missing pts even if it requires parsing future frames.
Definition: avformat.h:1407
AV_DISPOSITION_VISUAL_IMPAIRED
#define AV_DISPOSITION_VISUAL_IMPAIRED
The stream is intended for visually impaired audiences.
Definition: avformat.h:662
tag
uint32_t tag
Definition: movenc.c:1787
av_compare_mod
int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod)
Compare the remainders of two integer operands divided by a common divisor.
Definition: mathematics.c:160
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:755
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
pixfmt.h
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
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
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:290
tb_unreliable
static int tb_unreliable(AVFormatContext *ic, AVStream *st)
Definition: demux.c:2249
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:594
avformat.h
dict.h
AV_AUDIO_SERVICE_TYPE_KARAOKE
@ AV_AUDIO_SERVICE_TYPE_KARAOKE
Definition: defs.h:231
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:535
id
enum AVCodecID id
Definition: dts2pts.c:365
av_sat_add64
#define av_sat_add64
Definition: common.h:141
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
FFInputFormat::read_close
int(* read_close)(struct AVFormatContext *)
Close the stream.
Definition: demux.h:86
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:749
FFStreamInfo::fps_first_dts_idx
int fps_first_dts_idx
Definition: demux.h:162
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
FFStreamInfo::duration_gcd
int64_t duration_gcd
Definition: demux.h:141
AVBitStreamFilter
Definition: bsf.h:111
av_packet_new_side_data
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
Definition: packet.c:231
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:567
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_AUDIO_SERVICE_TYPE_COMMENTARY
@ AV_AUDIO_SERVICE_TYPE_COMMENTARY
Definition: defs.h:228
ffifmt
static const FFInputFormat * ffifmt(const AVInputFormat *fmt)
Definition: demux.h:133
ff_flush_packet_queue
void ff_flush_packet_queue(AVFormatContext *s)
Definition: avformat.c:131
update_dts_from_pts
static void update_dts_from_pts(AVFormatContext *s, int stream_index, PacketListEntry *pkt_buffer)
Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts of the packets in a wind...
Definition: demux.c:824
DURATION_DEFAULT_MAX_READ_SIZE
#define DURATION_DEFAULT_MAX_READ_SIZE
Definition: demux.c:1807
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:141
PARSER_FLAG_USE_CODEC_TS
#define PARSER_FLAG_USE_CODEC_TS
Definition: avcodec.h:2745
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:909
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:157
AVCodecContext::ticks_per_frame
attribute_deprecated int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:576
compute_pkt_fields
static void compute_pkt_fields(AVFormatContext *s, AVStream *st, AVCodecParserContext *pc, AVPacket *pkt, int64_t next_dts, int64_t next_pts)
Definition: demux.c:961
AVSTREAM_PARSE_FULL_RAW
@ AVSTREAM_PARSE_FULL_RAW
full parsing and repack with timestamp and position generation by parser for raw this assumes that ea...
Definition: avformat.h:597
FFStream::info
struct FFStreamInfo * info
Stream information used internally by avformat_find_stream_info()
Definition: internal.h:247
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1390
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVPacket::stream_index
int stream_index
Definition: packet.h:526
AVPROBE_SCORE_STREAM_RETRY
#define AVPROBE_SCORE_STREAM_RETRY
Definition: avformat.h:459
parse_packet
static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index, int flush)
Parse a packet, add all split parts to parse_queue.
Definition: demux.c:1155
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:318
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:440
av_gettime
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:617
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:453
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
desc
const char * desc
Definition: libsvtav1.c:75
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_parser_parse2
int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int64_t pts, int64_t dts, int64_t pos)
Parse a packet.
Definition: parser.c:115
extract_extradata
static int extract_extradata(FFFormatContext *si, AVStream *st, const AVPacket *pkt)
Definition: demux.c:2454
mem.h
packet_internal.h
FFFormatContext::pkt
AVPacket * pkt
Used to hold temporary packets for the generic demuxing code.
Definition: internal.h:134
llrint
#define llrint(x)
Definition: libm.h:394
avcodec_parameters_from_context
int avcodec_parameters_from_context(struct AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: codec_par.c:137
AVCodecParameters::format
int format
Definition: codec_par.h:92
FFStream::request_probe
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: internal.h:263
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:470
AV_AUDIO_SERVICE_TYPE_EFFECTS
@ AV_AUDIO_SERVICE_TYPE_EFFECTS
Definition: defs.h:224
AV_ROUND_PASS_MINMAX
@ AV_ROUND_PASS_MINMAX
Flag telling rescaling functions to pass INT64_MIN/MAX through unchanged, avoiding special cases for ...
Definition: mathematics.h:159
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:501
fill_all_stream_timings
static void fill_all_stream_timings(AVFormatContext *ic)
Definition: demux.c:1737
avio_closep
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
Definition: avio.c:649
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:237
select_from_pts_buffer
static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts)
Definition: demux.c:776
ff_id3v2_free_extra_meta
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
Definition: id3v2.c:1146
FFStream::cur_dts
int64_t cur_dts
Definition: internal.h:410
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:544
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
timestamp.h
FFStream::need_context_update
int need_context_update
Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar)
Definition: internal.h:238
avio_close
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: avio.c:616
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
ff_id3v2_parse_priv
int ff_id3v2_parse_priv(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Add metadata for all PRIV tags in the ID3v2 header.
Definition: id3v2.c:1258
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
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
AV_CODEC_ID_AAC_LATM
@ AV_CODEC_ID_AAC_LATM
Definition: codec_id.h:489
FFStreamInfo::fps_last_dts_idx
int fps_last_dts_idx
Definition: demux.h:164
FFStream::parser
struct AVCodecParserContext * parser
Definition: internal.h:387
AV_CODEC_CAP_AVOID_PROBING
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition: codec.h:138
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
estimate_timings
static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
Definition: demux.c:1965
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:58
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3734
has_decode_delay_been_guessed
static int has_decode_delay_been_guessed(AVStream *st)
Definition: demux.c:746
is_relative
static av_always_inline int is_relative(int64_t ts)
Definition: demux.h:175
av_opt_set_dict
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1947
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:792
PARSER_FLAG_ONCE
#define PARSER_FLAG_ONCE
Definition: avcodec.h:2742
AV_CODEC_ID_APTX
@ AV_CODEC_ID_APTX
Definition: codec_id.h:525
avstring.h
ff_reduce_index
void ff_reduce_index(AVFormatContext *s, int stream_index)
Ensure the index uses less memory than the maximum specified in AVFormatContext.max_index_size by dis...
Definition: seek.c:49
AVSTREAM_PARSE_TIMESTAMPS
@ AVSTREAM_PARSE_TIMESTAMPS
full parsing and interpolation of timestamps for frames not starting on a packet boundary
Definition: avformat.h:595
AVDiscard
AVDiscard
Definition: defs.h:210
AVStream::pts_wrap_bits
int pts_wrap_bits
Number of bits in timestamps.
Definition: avformat.h:918
AVChapter::time_base
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1216
codec_desc.h
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
AV_CODEC_ID_MP1
@ AV_CODEC_ID_MP1
Definition: codec_id.h:482
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1283
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
FFStream::pts_wrap_reference
int64_t pts_wrap_reference
Internal data to check for wrapping of the time stamp.
Definition: internal.h:320
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
compute_chapters_end
static int compute_chapters_end(AVFormatContext *s)
Definition: demux.c:2188
avpriv_codec_get_cap_skip_frame_fill_param
int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec)
Definition: utils.c:402
AVFMT_EVENT_FLAG_METADATA_UPDATED
#define AVFMT_EVENT_FLAG_METADATA_UPDATED
Definition: avformat.h:1632
AVInputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:578
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:106
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:536
av_parser_close
void av_parser_close(AVCodecParserContext *s)
Definition: parser.c:193
av_cpb_properties_alloc
AVCPBProperties * av_cpb_properties_alloc(size_t *size)
Allocate a CPB properties structure and initialize its fields to default values.
Definition: utils.c:975
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:155
av_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:86