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