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[] = {
122  { "mjpeg_2000", AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
124  { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
125  { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
128  { 0 }
129  };
130  int score;
131  const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
132  FFStream *const sti = ffstream(st);
133 
134  if (fmt) {
136  "Probe with size=%d, packets=%d detected %s with score=%d\n",
137  pd->buf_size, s->max_probe_packets - sti->probe_packets,
138  fmt->name, score);
139  for (int i = 0; fmt_id_type[i].name; i++) {
140  if (!strcmp(fmt->name, fmt_id_type[i].name)) {
141  if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
142  st->codecpar->sample_rate)
143  continue;
144  if (sti->request_probe > score &&
145  st->codecpar->codec_id != fmt_id_type[i].id)
146  continue;
147  st->codecpar->codec_id = fmt_id_type[i].id;
148  st->codecpar->codec_type = fmt_id_type[i].type;
149  sti->need_context_update = 1;
150  return score;
151  }
152  }
153  }
154  return 0;
155 }
156 
157 static int init_input(AVFormatContext *s, const char *filename,
159 {
160  int ret;
161  AVProbeData pd = { filename, NULL, 0 };
162  int score = AVPROBE_SCORE_RETRY;
163 
164  if (s->pb) {
165  s->flags |= AVFMT_FLAG_CUSTOM_IO;
166  if (!s->iformat)
167  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
168  s, 0, s->format_probesize);
169  else if (s->iformat->flags & AVFMT_NOFILE)
170  av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
171  "will be ignored with AVFMT_NOFILE format.\n");
172  return 0;
173  }
174 
175  if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
176  (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
177  return score;
178 
179  if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
180  return ret;
181 
182  if (s->iformat)
183  return 0;
184  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
185  s, 0, s->format_probesize);
186 }
187 
189 {
190  int ret;
191  for (unsigned i = 0; i < s->nb_streams; i++) {
192  AVStream *const st = s->streams[i];
193  FFStream *const sti = ffstream(st);
194 
195  if (!sti->need_context_update)
196  continue;
197 
198  /* close parser, because it depends on the codec */
199  if (sti->parser && sti->avctx->codec_id != st->codecpar->codec_id) {
200  av_parser_close(sti->parser);
201  sti->parser = NULL;
202  }
203 
204  /* update internal codec context, for the parser */
206  if (ret < 0)
207  return ret;
208 
210 
211  sti->need_context_update = 0;
212  }
213  return 0;
214 }
215 
216 int avformat_open_input(AVFormatContext **ps, const char *filename,
217  const AVInputFormat *fmt, AVDictionary **options)
218 {
220  AVFormatContext *s = *ps;
221  FFFormatContext *si;
222  AVDictionary *tmp = NULL;
223  ID3v2ExtraMeta *id3v2_extra_meta = NULL;
224  int ret = 0;
225 
226  if (!s && !(s = avformat_alloc_context()))
227  return AVERROR(ENOMEM);
228  fci = ff_fc_internal(s);
229  si = &fci->fc;
230  if (!s->av_class) {
231  av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
232  return AVERROR(EINVAL);
233  }
234  if (fmt)
235  s->iformat = fmt;
236 
237  if (options)
238  av_dict_copy(&tmp, *options, 0);
239 
240  if (s->pb) // must be before any goto fail
241  s->flags |= AVFMT_FLAG_CUSTOM_IO;
242 
243  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
244  goto fail;
245 
246  if (!(s->url = av_strdup(filename ? filename : ""))) {
247  ret = AVERROR(ENOMEM);
248  goto fail;
249  }
250 
251  if ((ret = init_input(s, filename, &tmp)) < 0)
252  goto fail;
253  s->probe_score = ret;
254 
255  if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
256  s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
257  if (!s->protocol_whitelist) {
258  ret = AVERROR(ENOMEM);
259  goto fail;
260  }
261  }
262 
263  if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
264  s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
265  if (!s->protocol_blacklist) {
266  ret = AVERROR(ENOMEM);
267  goto fail;
268  }
269  }
270 
271  if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
272  av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
273  ret = AVERROR(EINVAL);
274  goto fail;
275  }
276 
277  avio_skip(s->pb, s->skip_initial_bytes);
278 
279  /* Check filename in case an image number is expected. */
280  if (s->iformat->flags & AVFMT_NEEDNUMBER) {
281  if (!av_filename_number_test(filename)) {
282  ret = AVERROR(EINVAL);
283  goto fail;
284  }
285  }
286 
287  s->duration = s->start_time = AV_NOPTS_VALUE;
288 
289  /* Allocate private data. */
290  if (ffifmt(s->iformat)->priv_data_size > 0) {
291  if (!(s->priv_data = av_mallocz(ffifmt(s->iformat)->priv_data_size))) {
292  ret = AVERROR(ENOMEM);
293  goto fail;
294  }
295  if (s->iformat->priv_class) {
296  *(const AVClass **) s->priv_data = s->iformat->priv_class;
297  av_opt_set_defaults(s->priv_data);
298  if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
299  goto fail;
300  }
301  }
302 
303  /* e.g. AVFMT_NOFILE formats will not have an AVIOContext */
304  if (s->pb)
305  ff_id3v2_read_dict(s->pb, &si->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
306 
307  if (ffifmt(s->iformat)->read_header)
308  if ((ret = ffifmt(s->iformat)->read_header(s)) < 0) {
310  goto close;
311  goto fail;
312  }
313 
314  if (!s->metadata) {
315  s->metadata = si->id3v2_meta;
316  si->id3v2_meta = NULL;
317  } else if (si->id3v2_meta) {
318  av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
319  av_dict_free(&si->id3v2_meta);
320  }
321 
322  if (id3v2_extra_meta) {
323  if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
324  !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
325  if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
326  goto close;
327  if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
328  goto close;
329  if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
330  goto close;
331  } else
332  av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
333  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
334  }
335 
337  goto close;
338 
339  if (s->pb && !si->data_offset)
340  si->data_offset = avio_tell(s->pb);
341 
342  fci->raw_packet_buffer_size = 0;
343 
345 
346  if (options) {
348  *options = tmp;
349  }
350  *ps = s;
351  return 0;
352 
353 close:
354  if (ffifmt(s->iformat)->read_close)
355  ffifmt(s->iformat)->read_close(s);
356 fail:
357  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
358  av_dict_free(&tmp);
359  if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
360  avio_closep(&s->pb);
362  *ps = NULL;
363  return ret;
364 }
365 
367 {
369  AVIOContext *pb;
370 
371  if (!ps || !*ps)
372  return;
373 
374  s = *ps;
375  pb = s->pb;
376 
377  if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
378  (s->flags & AVFMT_FLAG_CUSTOM_IO))
379  pb = NULL;
380 
381  if (s->iformat)
382  if (ffifmt(s->iformat)->read_close)
383  ffifmt(s->iformat)->read_close(s);
384 
386 
387  *ps = NULL;
388 
389  avio_close(pb);
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
1177  }
1178 
1179  while (size > 0 || (flush && got_output)) {
1180  int64_t next_pts = pkt->pts;
1181  int64_t next_dts = pkt->dts;
1182  int len;
1183 
1184  len = av_parser_parse2(sti->parser, sti->avctx,
1185  &out_pkt->data, &out_pkt->size, data, size,
1186  pkt->pts, pkt->dts, pkt->pos);
1187 
1188  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1189  pkt->pos = -1;
1190  /* increment read pointer */
1191  av_assert1(data || !len);
1192  data = len ? data + len : data;
1193  size -= len;
1194 
1195  got_output = !!out_pkt->size;
1196 
1197  if (!out_pkt->size)
1198  continue;
1199 
1200  if (pkt->buf && out_pkt->data == pkt->data) {
1201  /* reference pkt->buf only when out_pkt->data is guaranteed to point
1202  * to data in it and not in the parser's internal buffer. */
1203  /* XXX: Ensure this is the case with all parsers when sti->parser->flags
1204  * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1205  out_pkt->buf = av_buffer_ref(pkt->buf);
1206  if (!out_pkt->buf) {
1207  ret = AVERROR(ENOMEM);
1208  goto fail;
1209  }
1210  } else {
1211  ret = av_packet_make_refcounted(out_pkt);
1212  if (ret < 0)
1213  goto fail;
1214  }
1215 
1216  if (pkt->side_data) {
1217  out_pkt->side_data = pkt->side_data;
1218  out_pkt->side_data_elems = pkt->side_data_elems;
1219  pkt->side_data = NULL;
1220  pkt->side_data_elems = 0;
1221  }
1222 
1223  /* set the duration */
1224  out_pkt->duration = (sti->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1226  if (sti->avctx->sample_rate > 0) {
1227  out_pkt->duration =
1229  (AVRational) { 1, sti->avctx->sample_rate },
1230  st->time_base,
1231  AV_ROUND_DOWN);
1232  }
1233  } else if (st->codecpar->codec_id == AV_CODEC_ID_GIF) {
1234  if (st->time_base.num > 0 && st->time_base.den > 0 &&
1235  sti->parser->duration) {
1236  out_pkt->duration = sti->parser->duration;
1237  }
1238  }
1239 
1240  out_pkt->stream_index = st->index;
1241  out_pkt->pts = sti->parser->pts;
1242  out_pkt->dts = sti->parser->dts;
1243  out_pkt->pos = sti->parser->pos;
1245 
1247  out_pkt->pos = sti->parser->frame_offset;
1248 
1249  if (sti->parser->key_frame == 1 ||
1250  (sti->parser->key_frame == -1 &&
1252  out_pkt->flags |= AV_PKT_FLAG_KEY;
1253 
1255  out_pkt->flags |= AV_PKT_FLAG_KEY;
1256 
1257  compute_pkt_fields(s, st, sti->parser, out_pkt, next_dts, next_pts);
1258 
1260  out_pkt, NULL, 0);
1261  if (ret < 0)
1262  goto fail;
1263  }
1264 
1265  /* end of the stream => close and free the parser */
1266  if (flush) {
1267  av_parser_close(sti->parser);
1268  sti->parser = NULL;
1269  }
1270 
1271 fail:
1272  if (ret < 0)
1273  av_packet_unref(out_pkt);
1275  return ret;
1276 }
1277 
1279 {
1280  return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1281 }
1282 
1283 static int codec_close(FFStream *sti)
1284 {
1285  AVCodecContext *avctx_new = NULL;
1286  AVCodecParameters *par_tmp = NULL;
1287  int ret;
1288 
1289  avctx_new = avcodec_alloc_context3(sti->avctx->codec);
1290  if (!avctx_new) {
1291  ret = AVERROR(ENOMEM);
1292  goto fail;
1293  }
1294 
1295  par_tmp = avcodec_parameters_alloc();
1296  if (!par_tmp) {
1297  ret = AVERROR(ENOMEM);
1298  goto fail;
1299  }
1300 
1301  ret = avcodec_parameters_from_context(par_tmp, sti->avctx);
1302  if (ret < 0)
1303  goto fail;
1304 
1305  ret = avcodec_parameters_to_context(avctx_new, par_tmp);
1306  if (ret < 0)
1307  goto fail;
1308 
1309  avctx_new->pkt_timebase = sti->avctx->pkt_timebase;
1310 
1311 #if FF_API_TICKS_PER_FRAME
1313  avctx_new->ticks_per_frame = sti->avctx->ticks_per_frame;
1315 #endif
1316 
1317  avcodec_free_context(&sti->avctx);
1318  sti->avctx = avctx_new;
1319 
1320  avctx_new = NULL;
1321  ret = 0;
1322 
1323 fail:
1324  avcodec_free_context(&avctx_new);
1325  avcodec_parameters_free(&par_tmp);
1326 
1327  return ret;
1328 }
1329 
1330 static int extract_extradata(FFFormatContext *si, AVStream *st, const AVPacket *pkt);
1331 
1333 {
1334  FormatContextInternal *const fci = ff_fc_internal(s);
1335  FFFormatContext *const si = &fci->fc;
1336  int ret, got_packet = 0;
1337  AVDictionary *metadata = NULL;
1338 
1339  while (!got_packet && !fci->parse_queue.head) {
1340  AVStream *st;
1341  FFStream *sti;
1342 
1343  /* read next packet */
1344  ret = ff_read_packet(s, pkt);
1345  if (ret < 0) {
1346  if (ret == AVERROR(EAGAIN))
1347  return ret;
1348  /* flush the parsers */
1349  for (unsigned i = 0; i < s->nb_streams; i++) {
1350  AVStream *const st = s->streams[i];
1351  FFStream *const sti = ffstream(st);
1352  if (sti->parser && sti->need_parsing)
1353  parse_packet(s, pkt, st->index, 1);
1354  }
1355  /* all remaining packets are now in parse_queue =>
1356  * really terminate parsing */
1357  break;
1358  }
1359  ret = 0;
1360  st = s->streams[pkt->stream_index];
1361  sti = ffstream(st);
1362 
1364 
1365  /* update context if required */
1366  if (sti->need_context_update) {
1367  if (avcodec_is_open(sti->avctx)) {
1368  av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1369  ret = codec_close(sti);
1370  sti->info->found_decoder = 0;
1371  if (ret < 0)
1372  return ret;
1373  }
1374 
1375  /* close parser, because it depends on the codec */
1376  if (sti->parser && sti->avctx->codec_id != st->codecpar->codec_id) {
1377  av_parser_close(sti->parser);
1378  sti->parser = NULL;
1379  }
1380 
1382  if (ret < 0) {
1384  return ret;
1385  }
1386 
1387  if (!sti->avctx->extradata) {
1388  sti->extract_extradata.inited = 0;
1389 
1390  ret = extract_extradata(si, st, pkt);
1391  if (ret < 0) {
1393  return ret;
1394  }
1395  }
1396 
1398 
1399  sti->need_context_update = 0;
1400  }
1401 
1402  if (pkt->pts != AV_NOPTS_VALUE &&
1403  pkt->dts != AV_NOPTS_VALUE &&
1404  pkt->pts < pkt->dts) {
1406  "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1407  pkt->stream_index,
1408  av_ts2str(pkt->pts),
1409  av_ts2str(pkt->dts),
1410  pkt->size);
1411  }
1412  if (s->debug & FF_FDEBUG_TS)
1414  "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1415  pkt->stream_index,
1416  av_ts2str(pkt->pts),
1417  av_ts2str(pkt->dts),
1418  pkt->size, pkt->duration, pkt->flags);
1419 
1420  if (sti->need_parsing && !sti->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1421  sti->parser = av_parser_init(st->codecpar->codec_id);
1422  if (!sti->parser) {
1423  av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1424  "%s, packets or times may be invalid.\n",
1426  /* no parser available: just output the raw packets */
1428  } else if (sti->need_parsing == AVSTREAM_PARSE_HEADERS)
1430  else if (sti->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1431  sti->parser->flags |= PARSER_FLAG_ONCE;
1432  else if (sti->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1434  }
1435 
1436  if (!sti->need_parsing || !sti->parser) {
1437  /* no parsing needed: we just output the packet as is */
1439  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1441  ff_reduce_index(s, st->index);
1442  av_add_index_entry(st, pkt->pos, pkt->dts,
1443  0, 0, AVINDEX_KEYFRAME);
1444  }
1445  got_packet = 1;
1446  } else if (st->discard < AVDISCARD_ALL) {
1447  if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1448  return ret;
1449  st->codecpar->sample_rate = sti->avctx->sample_rate;
1450  st->codecpar->bit_rate = sti->avctx->bit_rate;
1452  if (ret < 0)
1453  return ret;
1454  st->codecpar->codec_id = sti->avctx->codec_id;
1455  } else {
1456  /* free packet */
1458  }
1459  if (pkt->flags & AV_PKT_FLAG_KEY)
1460  sti->skip_to_keyframe = 0;
1461  if (sti->skip_to_keyframe) {
1463  got_packet = 0;
1464  }
1465  }
1466 
1467  if (!got_packet && fci->parse_queue.head)
1469 
1470  if (ret >= 0) {
1471  AVStream *const st = s->streams[pkt->stream_index];
1472  FFStream *const sti = ffstream(st);
1473  int discard_padding = 0;
1474  if (sti->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1478  int64_t end_sample = sample + duration;
1479  if (duration > 0 && end_sample >= sti->first_discard_sample &&
1480  sample < sti->last_discard_sample)
1481  discard_padding = FFMIN(end_sample - sti->first_discard_sample, duration);
1482  }
1483  if (sti->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1484  sti->skip_samples = sti->start_skip_samples;
1485  sti->skip_samples = FFMAX(0, sti->skip_samples);
1486  if (sti->skip_samples || discard_padding) {
1488  if (p) {
1489  AV_WL32(p, sti->skip_samples);
1490  AV_WL32(p + 4, discard_padding);
1491  av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %u / discard %u\n",
1492  (unsigned)sti->skip_samples, (unsigned)discard_padding);
1493  }
1494  sti->skip_samples = 0;
1495  }
1496 
1497 #if FF_API_AVSTREAM_SIDE_DATA
1498  if (sti->inject_global_side_data) {
1499  for (int i = 0; i < st->codecpar->nb_coded_side_data; i++) {
1500  const AVPacketSideData *const src_sd = &st->codecpar->coded_side_data[i];
1501  uint8_t *dst_data;
1502 
1503  if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1504  continue;
1505 
1506  dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1507  if (!dst_data) {
1508  av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1509  continue;
1510  }
1511 
1512  memcpy(dst_data, src_sd->data, src_sd->size);
1513  }
1514  sti->inject_global_side_data = 0;
1515  }
1516 #endif
1517  }
1518 
1519  if (!fci->metafree) {
1520  int metaret = av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1521  if (metadata) {
1522  s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1523  av_dict_copy(&s->metadata, metadata, 0);
1524  av_dict_free(&metadata);
1526  }
1527  fci->metafree = metaret == AVERROR_OPTION_NOT_FOUND;
1528  }
1529 
1530  if (s->debug & FF_FDEBUG_TS)
1532  "read_frame_internal stream=%d, pts=%s, dts=%s, "
1533  "size=%d, duration=%"PRId64", flags=%d\n",
1534  pkt->stream_index,
1535  av_ts2str(pkt->pts),
1536  av_ts2str(pkt->dts),
1537  pkt->size, pkt->duration, pkt->flags);
1538 
1539  /* A demuxer might have returned EOF because of an IO error, let's
1540  * propagate this back to the user. */
1541  if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1542  ret = s->pb->error;
1543 
1544  return ret;
1545 }
1546 
1548 {
1549  FFFormatContext *const si = ffformatcontext(s);
1550  const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1551  int eof = 0;
1552  int ret;
1553  AVStream *st;
1554 
1555  if (!genpts) {
1556  ret = si->packet_buffer.head
1559  if (ret < 0)
1560  return ret;
1561  goto return_packet;
1562  }
1563 
1564  for (;;) {
1565  PacketListEntry *pktl = si->packet_buffer.head;
1566 
1567  if (pktl) {
1568  AVPacket *next_pkt = &pktl->pkt;
1569 
1570  if (next_pkt->dts != AV_NOPTS_VALUE) {
1571  int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1572  // last dts seen for this stream. if any of packets following
1573  // current one had no dts, we will set this to AV_NOPTS_VALUE.
1574  int64_t last_dts = next_pkt->dts;
1575  av_assert2(wrap_bits <= 64);
1576  while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1577  if (pktl->pkt.stream_index == next_pkt->stream_index &&
1578  av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1579  if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1580  // not B-frame
1581  next_pkt->pts = pktl->pkt.dts;
1582  }
1583  if (last_dts != AV_NOPTS_VALUE) {
1584  // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1585  last_dts = pktl->pkt.dts;
1586  }
1587  }
1588  pktl = pktl->next;
1589  }
1590  if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1591  // Fixing the last reference frame had none pts issue (For MXF etc).
1592  // We only do this when
1593  // 1. eof.
1594  // 2. we are not able to resolve a pts value for current packet.
1595  // 3. the packets for this stream at the end of the files had valid dts.
1596  next_pkt->pts = last_dts + next_pkt->duration;
1597  }
1598  pktl = si->packet_buffer.head;
1599  }
1600 
1601  /* read packet from packet buffer, if there is data */
1602  st = s->streams[next_pkt->stream_index];
1603  if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1604  next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1606  goto return_packet;
1607  }
1608  }
1609 
1611  if (ret < 0) {
1612  if (pktl && ret != AVERROR(EAGAIN)) {
1613  eof = 1;
1614  continue;
1615  } else
1616  return ret;
1617  }
1618 
1620  pkt, NULL, 0);
1621  if (ret < 0) {
1623  return ret;
1624  }
1625  }
1626 
1627 return_packet:
1628  st = s->streams[pkt->stream_index];
1629  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1630  ff_reduce_index(s, st->index);
1632  }
1633 
1634  if (is_relative(pkt->dts))
1635  pkt->dts -= RELATIVE_TS_BASE;
1636  if (is_relative(pkt->pts))
1637  pkt->pts -= RELATIVE_TS_BASE;
1638 
1639  return ret;
1640 }
1641 
1642 /**
1643  * Return TRUE if the stream has accurate duration in any stream.
1644  *
1645  * @return TRUE if the stream has accurate duration for at least one component.
1646  */
1648 {
1649  for (unsigned i = 0; i < ic->nb_streams; i++) {
1650  const AVStream *const st = ic->streams[i];
1651  if (st->duration != AV_NOPTS_VALUE)
1652  return 1;
1653  }
1654  if (ic->duration != AV_NOPTS_VALUE)
1655  return 1;
1656  return 0;
1657 }
1658 
1659 /**
1660  * Estimate the stream timings from the one of each components.
1661  *
1662  * Also computes the global bitrate if possible.
1663  */
1665 {
1666  int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
1667  int64_t duration, duration1, duration_text, filesize;
1668 
1669  start_time = INT64_MAX;
1670  start_time_text = INT64_MAX;
1671  end_time = INT64_MIN;
1672  end_time_text = INT64_MIN;
1673  duration = INT64_MIN;
1674  duration_text = INT64_MIN;
1675 
1676  for (unsigned i = 0; i < ic->nb_streams; i++) {
1677  AVStream *const st = ic->streams[i];
1678  int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
1680 
1681  if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1682  start_time1 = av_rescale_q(st->start_time, st->time_base,
1683  AV_TIME_BASE_Q);
1684  if (is_text)
1685  start_time_text = FFMIN(start_time_text, start_time1);
1686  else
1687  start_time = FFMIN(start_time, start_time1);
1688  end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
1691  if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
1692  end_time1 += start_time1;
1693  if (is_text)
1694  end_time_text = FFMAX(end_time_text, end_time1);
1695  else
1696  end_time = FFMAX(end_time, end_time1);
1697  }
1698  for (AVProgram *p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
1699  if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
1700  p->start_time = start_time1;
1701  if (p->end_time < end_time1)
1702  p->end_time = end_time1;
1703  }
1704  }
1705  if (st->duration != AV_NOPTS_VALUE) {
1706  duration1 = av_rescale_q(st->duration, st->time_base,
1707  AV_TIME_BASE_Q);
1708  if (is_text)
1709  duration_text = FFMAX(duration_text, duration1);
1710  else
1711  duration = FFMAX(duration, duration1);
1712  }
1713  }
1714  if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
1715  start_time = start_time_text;
1716  else if (start_time > start_time_text)
1717  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
1718 
1719  if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
1720  end_time = end_time_text;
1721  else if (end_time < end_time_text)
1722  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
1723 
1724  if (duration == INT64_MIN || (duration < duration_text && (uint64_t)duration_text - duration < AV_TIME_BASE))
1725  duration = duration_text;
1726  else if (duration < duration_text)
1727  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
1728 
1729  if (start_time != INT64_MAX) {
1730  ic->start_time = start_time;
1731  if (end_time != INT64_MIN) {
1732  if (ic->nb_programs > 1) {
1733  for (unsigned i = 0; i < ic->nb_programs; i++) {
1734  AVProgram *const p = ic->programs[i];
1735 
1736  if (p->start_time != AV_NOPTS_VALUE &&
1737  p->end_time > p->start_time &&
1738  p->end_time - (uint64_t)p->start_time <= INT64_MAX)
1740  }
1741  } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
1742  duration = FFMAX(duration, end_time - start_time);
1743  }
1744  }
1745  }
1746  if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
1747  ic->duration = duration;
1748  }
1749  if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
1750  /* compute the bitrate */
1751  double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
1752  (double) ic->duration;
1753  if (bitrate >= 0 && bitrate <= INT64_MAX)
1754  ic->bit_rate = bitrate;
1755  }
1756 }
1757 
1759 {
1761  for (unsigned i = 0; i < ic->nb_streams; i++) {
1762  AVStream *const st = ic->streams[i];
1763 
1764  if (st->start_time == AV_NOPTS_VALUE) {
1765  if (ic->start_time != AV_NOPTS_VALUE)
1767  st->time_base);
1768  if (ic->duration != AV_NOPTS_VALUE)
1770  st->time_base);
1771  }
1772  }
1773 }
1774 
1776 {
1777  FFFormatContext *const si = ffformatcontext(ic);
1778  int show_warning = 0;
1779 
1780  /* if bit_rate is already set, we believe it */
1781  if (ic->bit_rate <= 0) {
1782  int64_t bit_rate = 0;
1783  for (unsigned i = 0; i < ic->nb_streams; i++) {
1784  const AVStream *const st = ic->streams[i];
1785  const FFStream *const sti = cffstream(st);
1786  if (st->codecpar->bit_rate <= 0 && sti->avctx->bit_rate > 0)
1787  st->codecpar->bit_rate = sti->avctx->bit_rate;
1788  if (st->codecpar->bit_rate > 0) {
1789  if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
1790  bit_rate = 0;
1791  break;
1792  }
1793  bit_rate += st->codecpar->bit_rate;
1794  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && sti->codec_info_nb_frames > 1) {
1795  // If we have a videostream with packets but without a bitrate
1796  // then consider the sum not known
1797  bit_rate = 0;
1798  break;
1799  }
1800  }
1801  ic->bit_rate = bit_rate;
1802  }
1803 
1804  /* if duration is already set, we believe it */
1805  if (ic->duration == AV_NOPTS_VALUE &&
1806  ic->bit_rate != 0) {
1807  int64_t filesize = ic->pb ? avio_size(ic->pb) : 0;
1808  if (filesize > si->data_offset) {
1809  filesize -= si->data_offset;
1810  for (unsigned i = 0; i < ic->nb_streams; i++) {
1811  AVStream *const st = ic->streams[i];
1812 
1813  if ( st->time_base.num <= INT64_MAX / ic->bit_rate
1814  && st->duration == AV_NOPTS_VALUE) {
1815  st->duration = av_rescale(filesize, 8LL * st->time_base.den,
1816  ic->bit_rate *
1817  (int64_t) st->time_base.num);
1818  show_warning = 1;
1819  }
1820  }
1821  }
1822  }
1823  if (show_warning)
1824  av_log(ic, AV_LOG_WARNING,
1825  "Estimating duration from bitrate, this may be inaccurate\n");
1826 }
1827 
1828 #define DURATION_DEFAULT_MAX_READ_SIZE 250000LL
1829 #define DURATION_DEFAULT_MAX_RETRY 6
1830 #define DURATION_MAX_RETRY 1
1831 
1832 /* only usable for MPEG-PS streams */
1834 {
1835  FFFormatContext *const si = ffformatcontext(ic);
1836  AVPacket *const pkt = si->pkt;
1837  int num, den, read_size, ret;
1839  int duration_max_retry = ic->duration_probesize ? DURATION_MAX_RETRY : DURATION_DEFAULT_MAX_RETRY;
1840  int found_duration = 0;
1841  int is_end;
1843  int retry = 0;
1844 
1845  /* flush packet queue */
1847 
1848  for (unsigned i = 0; i < ic->nb_streams; i++) {
1849  AVStream *const st = ic->streams[i];
1850  FFStream *const sti = ffstream(st);
1851 
1852  if (st->start_time == AV_NOPTS_VALUE &&
1853  sti->first_dts == AV_NOPTS_VALUE &&
1855  av_log(ic, AV_LOG_WARNING,
1856  "start time for stream %d is not set in estimate_timings_from_pts\n", i);
1857 
1858  if (sti->parser) {
1859  av_parser_close(sti->parser);
1860  sti->parser = NULL;
1861  }
1862  }
1863 
1865  av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
1866  goto skip_duration_calc;
1867  }
1868 
1869  av_opt_set_int(ic, "skip_changes", 1, AV_OPT_SEARCH_CHILDREN);
1870  /* estimate the end time (duration) */
1871  /* XXX: may need to support wrapping */
1872  filesize = ic->pb ? avio_size(ic->pb) : 0;
1873  do {
1874  is_end = found_duration;
1875  offset = filesize - (duration_max_read_size << retry);
1876  if (offset < 0)
1877  offset = 0;
1878 
1879  avio_seek(ic->pb, offset, SEEK_SET);
1880  read_size = 0;
1881  for (;;) {
1882  AVStream *st;
1883  FFStream *sti;
1884  if (read_size >= duration_max_read_size << (FFMAX(retry - 1, 0)))
1885  break;
1886 
1887  do {
1888  ret = ff_read_packet(ic, pkt);
1889  } while (ret == AVERROR(EAGAIN));
1890  if (ret != 0)
1891  break;
1892  read_size += pkt->size;
1893  st = ic->streams[pkt->stream_index];
1894  sti = ffstream(st);
1895  if (pkt->pts != AV_NOPTS_VALUE &&
1896  (st->start_time != AV_NOPTS_VALUE ||
1897  sti->first_dts != AV_NOPTS_VALUE)) {
1898  if (pkt->duration == 0) {
1899  compute_frame_duration(ic, &num, &den, st, sti->parser, pkt);
1900  if (den && num) {
1902  num * (int64_t) st->time_base.den,
1903  den * (int64_t) st->time_base.num,
1904  AV_ROUND_DOWN);
1905  }
1906  }
1907  duration = pkt->pts + pkt->duration;
1908  found_duration = 1;
1909  if (st->start_time != AV_NOPTS_VALUE)
1910  duration -= st->start_time;
1911  else
1912  duration -= sti->first_dts;
1913  if (duration > 0) {
1914  if (st->duration == AV_NOPTS_VALUE || sti->info->last_duration<= 0 ||
1915  (st->duration < duration && FFABS(duration - sti->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
1916  st->duration = duration;
1917  sti->info->last_duration = duration;
1918  }
1919  }
1921  }
1922 
1923  /* check if all audio/video streams have valid duration */
1924  if (!is_end) {
1925  is_end = 1;
1926  for (unsigned i = 0; i < ic->nb_streams; i++) {
1927  const AVStream *const st = ic->streams[i];
1928  switch (st->codecpar->codec_type) {
1929  case AVMEDIA_TYPE_VIDEO:
1930  case AVMEDIA_TYPE_AUDIO:
1931  if (st->duration == AV_NOPTS_VALUE)
1932  is_end = 0;
1933  }
1934  }
1935  }
1936  } while (!is_end &&
1937  offset &&
1938  ++retry <= duration_max_retry);
1939 
1940  av_opt_set_int(ic, "skip_changes", 0, AV_OPT_SEARCH_CHILDREN);
1941 
1942  /* warn about audio/video streams which duration could not be estimated */
1943  for (unsigned i = 0; i < ic->nb_streams; i++) {
1944  const AVStream *const st = ic->streams[i];
1945  const FFStream *const sti = cffstream(st);
1946 
1947  if (st->duration == AV_NOPTS_VALUE) {
1948  switch (st->codecpar->codec_type) {
1949  case AVMEDIA_TYPE_VIDEO:
1950  case AVMEDIA_TYPE_AUDIO:
1951  if (st->start_time != AV_NOPTS_VALUE || sti->first_dts != AV_NOPTS_VALUE) {
1952  av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
1953  } else
1954  av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
1955  }
1956  }
1957  }
1958 skip_duration_calc:
1960 
1961  avio_seek(ic->pb, old_offset, SEEK_SET);
1962  for (unsigned i = 0; i < ic->nb_streams; i++) {
1963  AVStream *const st = ic->streams[i];
1964  FFStream *const sti = ffstream(st);
1965 
1966  sti->cur_dts = sti->first_dts;
1967  sti->last_IP_pts = AV_NOPTS_VALUE;
1969  for (int j = 0; j < MAX_REORDER_DELAY + 1; j++)
1970  sti->pts_buffer[j] = AV_NOPTS_VALUE;
1971  }
1972 }
1973 
1974 /* 1:1 map to AVDurationEstimationMethod */
1975 static const char *const duration_name[] = {
1976  [AVFMT_DURATION_FROM_PTS] = "pts",
1977  [AVFMT_DURATION_FROM_STREAM] = "stream",
1978  [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
1979 };
1980 
1982 {
1983  return duration_name[method];
1984 }
1985 
1986 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
1987 {
1988  int64_t file_size;
1989 
1990  /* get the file size, if possible */
1991  if (ic->iformat->flags & AVFMT_NOFILE) {
1992  file_size = 0;
1993  } else {
1994  file_size = avio_size(ic->pb);
1995  file_size = FFMAX(0, file_size);
1996  }
1997 
1998  if ((!strcmp(ic->iformat->name, "mpeg") ||
1999  !strcmp(ic->iformat->name, "mpegts")) &&
2000  file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2001  /* get accurate estimate from the PTSes */
2002  estimate_timings_from_pts(ic, old_offset);
2004  } else if (has_duration(ic)) {
2005  /* at least one component has timings - we use them for all
2006  * the components */
2008  /* nut demuxer estimate the duration from PTS */
2009  if (!strcmp(ic->iformat->name, "nut"))
2011  else
2013  } else {
2014  /* less precise: use bitrate info */
2017  }
2019 
2020  for (unsigned i = 0; i < ic->nb_streams; i++) {
2021  AVStream *const st = ic->streams[i];
2022  if (st->time_base.den)
2023  av_log(ic, AV_LOG_TRACE, "stream %u: start_time: %s duration: %s\n", i,
2024  av_ts2timestr(st->start_time, &st->time_base),
2025  av_ts2timestr(st->duration, &st->time_base));
2026  }
2027  av_log(ic, AV_LOG_TRACE,
2028  "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
2032  (int64_t)ic->bit_rate / 1000);
2033 }
2034 
2035 static int determinable_frame_size(const AVCodecContext *avctx)
2036 {
2037  switch(avctx->codec_id) {
2038  case AV_CODEC_ID_MP1:
2039  case AV_CODEC_ID_MP2:
2040  case AV_CODEC_ID_MP3:
2041  case AV_CODEC_ID_CODEC2:
2042  return 1;
2043  }
2044 
2045  return 0;
2046 }
2047 
2048 static int has_codec_parameters(const AVStream *st, const char **errmsg_ptr)
2049 {
2050  const FFStream *const sti = cffstream(st);
2051  const AVCodecContext *const avctx = sti->avctx;
2052 
2053 #define FAIL(errmsg) do { \
2054  if (errmsg_ptr) \
2055  *errmsg_ptr = errmsg; \
2056  return 0; \
2057  } while (0)
2058 
2059  if ( avctx->codec_id == AV_CODEC_ID_NONE
2060  && avctx->codec_type != AVMEDIA_TYPE_DATA)
2061  FAIL("unknown codec");
2062  switch (avctx->codec_type) {
2063  case AVMEDIA_TYPE_AUDIO:
2064  if (!avctx->frame_size && determinable_frame_size(avctx))
2065  FAIL("unspecified frame size");
2066  if (sti->info->found_decoder >= 0 &&
2067  avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2068  FAIL("unspecified sample format");
2069  if (!avctx->sample_rate)
2070  FAIL("unspecified sample rate");
2071  if (!avctx->ch_layout.nb_channels)
2072  FAIL("unspecified number of channels");
2073  if (sti->info->found_decoder >= 0 && !sti->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2074  FAIL("no decodable DTS frames");
2075  break;
2076  case AVMEDIA_TYPE_VIDEO:
2077  if (!avctx->width)
2078  FAIL("unspecified size");
2079  if (sti->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2080  FAIL("unspecified pixel format");
2083  FAIL("no frame in rv30/40 and no sar");
2084  break;
2085  case AVMEDIA_TYPE_SUBTITLE:
2086  if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2087  FAIL("unspecified size");
2088  break;
2089  case AVMEDIA_TYPE_DATA:
2090  if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2091  }
2092 
2093  return 1;
2094 }
2095 
2096 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2098  const AVPacket *pkt, AVDictionary **options)
2099 {
2100  FFStream *const sti = ffstream(st);
2101  AVCodecContext *const avctx = sti->avctx;
2102  const AVCodec *codec;
2103  int got_picture = 1, ret = 0;
2105  AVSubtitle subtitle;
2106  int do_skip_frame = 0;
2107  enum AVDiscard skip_frame;
2108  int pkt_to_send = pkt->size > 0;
2109 
2110  if (!frame)
2111  return AVERROR(ENOMEM);
2112 
2113  if (!avcodec_is_open(avctx) &&
2114  sti->info->found_decoder <= 0 &&
2115  (st->codecpar->codec_id != -sti->info->found_decoder || !st->codecpar->codec_id)) {
2116  AVDictionary *thread_opt = NULL;
2117 
2118  codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2119 
2120  if (!codec) {
2121  sti->info->found_decoder = -st->codecpar->codec_id;
2122  ret = -1;
2123  goto fail;
2124  }
2125 
2126  /* Force thread count to 1 since the H.264 decoder will not extract
2127  * SPS and PPS to extradata during multi-threaded decoding. */
2128  av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2129  /* Force lowres to 0. The decoder might reduce the video size by the
2130  * lowres factor, and we don't want that propagated to the stream's
2131  * codecpar */
2132  av_dict_set(options ? options : &thread_opt, "lowres", "0", 0);
2133  if (s->codec_whitelist)
2134  av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2135  ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2136  if (!options)
2137  av_dict_free(&thread_opt);
2138  if (ret < 0) {
2139  sti->info->found_decoder = -avctx->codec_id;
2140  goto fail;
2141  }
2142  sti->info->found_decoder = 1;
2143  } else if (!sti->info->found_decoder)
2144  sti->info->found_decoder = 1;
2145 
2146  if (sti->info->found_decoder < 0) {
2147  ret = -1;
2148  goto fail;
2149  }
2150 
2152  do_skip_frame = 1;
2153  skip_frame = avctx->skip_frame;
2154  avctx->skip_frame = AVDISCARD_ALL;
2155  }
2156 
2157  while ((pkt_to_send || (!pkt->data && got_picture)) &&
2158  ret >= 0 &&
2160  (!sti->codec_info_nb_frames &&
2162  got_picture = 0;
2163  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
2164  avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2165  ret = avcodec_send_packet(avctx, pkt);
2166  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
2167  break;
2168  if (ret >= 0)
2169  pkt_to_send = 0;
2170  ret = avcodec_receive_frame(avctx, frame);
2171  if (ret >= 0)
2172  got_picture = 1;
2173  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
2174  ret = 0;
2175  } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2176  ret = avcodec_decode_subtitle2(avctx, &subtitle,
2177  &got_picture, pkt);
2178  if (got_picture)
2179  avsubtitle_free(&subtitle);
2180  if (ret >= 0)
2181  pkt_to_send = 0;
2182  }
2183  if (ret >= 0) {
2184  if (got_picture)
2185  sti->nb_decoded_frames++;
2186  ret = got_picture;
2187  }
2188  }
2189 
2190 fail:
2191  if (do_skip_frame) {
2192  avctx->skip_frame = skip_frame;
2193  }
2194 
2195  av_frame_free(&frame);
2196  return ret;
2197 }
2198 
2199 static int chapter_start_cmp(const void *p1, const void *p2)
2200 {
2201  const AVChapter *const ch1 = *(AVChapter**)p1;
2202  const AVChapter *const ch2 = *(AVChapter**)p2;
2203  int delta = av_compare_ts(ch1->start, ch1->time_base, ch2->start, ch2->time_base);
2204  if (delta)
2205  return delta;
2206  return FFDIFFSIGN(ch1->id, ch2->id);
2207 }
2208 
2210 {
2211  int64_t max_time = 0;
2212  AVChapter **timetable;
2213 
2214  if (!s->nb_chapters)
2215  return 0;
2216 
2217  if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
2218  max_time = s->duration +
2219  ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2220 
2221  timetable = av_memdup(s->chapters, s->nb_chapters * sizeof(*timetable));
2222  if (!timetable)
2223  return AVERROR(ENOMEM);
2224  qsort(timetable, s->nb_chapters, sizeof(*timetable), chapter_start_cmp);
2225 
2226  for (unsigned i = 0; i < s->nb_chapters; i++)
2227  if (timetable[i]->end == AV_NOPTS_VALUE) {
2228  AVChapter *const ch = timetable[i];
2229  int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2230  ch->time_base)
2231  : INT64_MAX;
2232 
2233  if (i + 1 < s->nb_chapters) {
2234  const AVChapter *const ch1 = timetable[i + 1];
2235  int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2236  ch->time_base);
2237  if (next_start > ch->start && next_start < end)
2238  end = next_start;
2239  }
2240  ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
2241  }
2242  av_free(timetable);
2243  return 0;
2244 }
2245 
2246 static int get_std_framerate(int i)
2247 {
2248  if (i < 30*12)
2249  return (i + 1) * 1001;
2250  i -= 30*12;
2251 
2252  if (i < 30)
2253  return (i + 31) * 1001 * 12;
2254  i -= 30;
2255 
2256  if (i < 3)
2257  return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
2258 
2259  i -= 3;
2260 
2261  return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2262 }
2263 
2264 /* Is the time base unreliable?
2265  * This is a heuristic to balance between quick acceptance of the values in
2266  * the headers vs. some extra checks.
2267  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2268  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2269  * And there are "variable" fps files this needs to detect as well. */
2271 {
2272  FFStream *const sti = ffstream(st);
2273  const AVCodecDescriptor *desc = sti->codec_desc;
2274  AVCodecContext *c = sti->avctx;
2275  AVRational mul = (AVRational){ desc && (desc->props & AV_CODEC_PROP_FIELDS) ? 2 : 1, 1 };
2276  AVRational time_base = c->framerate.num ? av_inv_q(av_mul_q(c->framerate, mul))
2277  /* NOHEADER check added to not break existing behavior */
2278  : (((ic->ctx_flags & AVFMTCTX_NOHEADER) ||
2280  : st->time_base);
2281 
2282  if (time_base.den >= 101LL * time_base.num ||
2283  time_base.den < 5LL * time_base.num ||
2284  // c->codec_tag == AV_RL32("DIVX") ||
2285  // c->codec_tag == AV_RL32("XVID") ||
2286  c->codec_tag == AV_RL32("mp4v") ||
2287  c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2288  c->codec_id == AV_CODEC_ID_GIF ||
2289  c->codec_id == AV_CODEC_ID_HEVC ||
2290  c->codec_id == AV_CODEC_ID_H264)
2291  return 1;
2292  return 0;
2293 }
2294 
2296 {
2297  FFStream *const sti = ffstream(st);
2298  FFStreamInfo *info = sti->info;
2299  int64_t last = info->last_dts;
2300 
2301  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2302  && ts - (uint64_t)last < INT64_MAX) {
2303  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2304  int64_t duration = ts - last;
2305 
2306  if (!info->duration_error)
2307  info->duration_error = av_mallocz(sizeof(info->duration_error[0])*2);
2308  if (!info->duration_error)
2309  return AVERROR(ENOMEM);
2310 
2311 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2312 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2313  for (int i = 0; i < MAX_STD_TIMEBASES; i++) {
2314  if (info->duration_error[0][1][i] < 1e10) {
2315  int framerate = get_std_framerate(i);
2316  double sdts = dts*framerate/(1001*12);
2317  for (int j = 0; j < 2; j++) {
2318  int64_t ticks = llrint(sdts+j*0.5);
2319  double error = sdts - ticks + j*0.5;
2320  info->duration_error[j][0][i] += error;
2321  info->duration_error[j][1][i] += error*error;
2322  }
2323  }
2324  }
2325  if (info->rfps_duration_sum <= INT64_MAX - duration) {
2326  info->duration_count++;
2327  info->rfps_duration_sum += duration;
2328  }
2329 
2330  if (info->duration_count % 10 == 0) {
2331  int n = info->duration_count;
2332  for (int i = 0; i < MAX_STD_TIMEBASES; i++) {
2333  if (info->duration_error[0][1][i] < 1e10) {
2334  double a0 = info->duration_error[0][0][i] / n;
2335  double error0 = info->duration_error[0][1][i] / n - a0*a0;
2336  double a1 = info->duration_error[1][0][i] / n;
2337  double error1 = info->duration_error[1][1][i] / n - a1*a1;
2338  if (error0 > 0.04 && error1 > 0.04) {
2339  info->duration_error[0][1][i] = 2e10;
2340  info->duration_error[1][1][i] = 2e10;
2341  }
2342  }
2343  }
2344  }
2345 
2346  // ignore the first 4 values, they might have some random jitter
2347  if (info->duration_count > 3 && is_relative(ts) == is_relative(last))
2348  info->duration_gcd = av_gcd(info->duration_gcd, duration);
2349  }
2350  if (ts != AV_NOPTS_VALUE)
2351  info->last_dts = ts;
2352 
2353  return 0;
2354 }
2355 
2357 {
2358  for (unsigned i = 0; i < ic->nb_streams; i++) {
2359  AVStream *const st = ic->streams[i];
2360  FFStream *const sti = ffstream(st);
2361 
2363  continue;
2364  // the check for tb_unreliable() is not completely correct, since this is not about handling
2365  // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2366  // ipmovie.c produces.
2367  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 &&
2368  sti->info->duration_gcd < INT64_MAX / st->time_base.num)
2369  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);
2370  if (sti->info->duration_count > 1 && !st->r_frame_rate.num
2371  && tb_unreliable(ic, st)) {
2372  int num = 0;
2373  double best_error = 0.01;
2374  AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2375 
2376  for (int j = 0; j < MAX_STD_TIMEBASES; j++) {
2377  if (sti->info->codec_info_duration &&
2378  sti->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
2379  continue;
2380  if (!sti->info->codec_info_duration && get_std_framerate(j) < 1001*12)
2381  continue;
2382 
2383  if (av_q2d(st->time_base) * sti->info->rfps_duration_sum / sti->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2384  continue;
2385 
2386  for (int k = 0; k < 2; k++) {
2387  int n = sti->info->duration_count;
2388  double a = sti->info->duration_error[k][0][j] / n;
2389  double error = sti->info->duration_error[k][1][j]/n - a*a;
2390 
2391  if (error < best_error && best_error> 0.000000001) {
2392  best_error= error;
2393  num = get_std_framerate(j);
2394  }
2395  if (error < 0.02)
2396  av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2397  }
2398  }
2399  // do not increase frame rate by more than 1 % in order to match a standard rate.
2400  if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2401  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2402  }
2403  if ( !st->avg_frame_rate.num
2404  && st->r_frame_rate.num && sti->info->rfps_duration_sum
2405  && sti->info->codec_info_duration <= 0
2406  && sti->info->duration_count > 2
2407  && 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
2408  ) {
2409  av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2410  st->avg_frame_rate = st->r_frame_rate;
2411  }
2412 
2413  av_freep(&sti->info->duration_error);
2414  sti->info->last_dts = AV_NOPTS_VALUE;
2415  sti->info->duration_count = 0;
2416  sti->info->rfps_duration_sum = 0;
2417  }
2418 }
2419 
2421 {
2422  const AVBitStreamFilter *const f = av_bsf_get_by_name("extract_extradata");
2423  if (!f)
2424  return 0;
2425 
2426  if (f->codec_ids) {
2427  const enum AVCodecID *ids;
2428  for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
2429  if (*ids == st->codecpar->codec_id)
2430  return 1;
2431  }
2432 
2433  return 0;
2434 }
2435 
2437 {
2438  FFStream *const sti = ffstream(st);
2439  const AVBitStreamFilter *f;
2440  int ret;
2441 
2442  f = av_bsf_get_by_name("extract_extradata");
2443  if (!f)
2444  goto finish;
2445 
2446  /* check that the codec id is supported */
2448  if (!ret)
2449  goto finish;
2450 
2453  if (ret < 0)
2454  return ret;
2455 
2457  st->codecpar);
2458  if (ret < 0)
2459  goto fail;
2460 
2462 
2464  if (ret < 0)
2465  goto fail;
2466 
2467 finish:
2468  sti->extract_extradata.inited = 1;
2469 
2470  return 0;
2471 fail:
2473  return ret;
2474 }
2475 
2477 {
2478  FFStream *const sti = ffstream(st);
2479  AVPacket *const pkt_ref = si->parse_pkt;
2480  int ret;
2481 
2482  if (!sti->extract_extradata.inited) {
2484  if (ret < 0)
2485  return ret;
2486  }
2487 
2488  if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
2489  return 0;
2490 
2491  ret = av_packet_ref(pkt_ref, pkt);
2492  if (ret < 0)
2493  return ret;
2494 
2495  ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
2496  if (ret < 0) {
2497  av_packet_unref(pkt_ref);
2498  return ret;
2499  }
2500 
2501  while (ret >= 0 && !sti->avctx->extradata) {
2503  if (ret < 0) {
2504  if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
2505  return ret;
2506  continue;
2507  }
2508 
2509  for (int i = 0; i < pkt_ref->side_data_elems; i++) {
2510  AVPacketSideData *const side_data = &pkt_ref->side_data[i];
2511  if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) {
2512  sti->avctx->extradata = side_data->data;
2513  sti->avctx->extradata_size = side_data->size;
2514  side_data->data = NULL;
2515  side_data->size = 0;
2516  break;
2517  }
2518  }
2519  av_packet_unref(pkt_ref);
2520  }
2521 
2522  return 0;
2523 }
2524 
2526 {
2527  FFFormatContext *const si = ffformatcontext(ic);
2528  int count = 0, ret = 0, err;
2529  int64_t read_size;
2530  AVPacket *pkt1 = si->pkt;
2531  int64_t old_offset = avio_tell(ic->pb);
2532  // new streams might appear, no options for those
2533  int orig_nb_streams = ic->nb_streams;
2534  int flush_codecs;
2535  int64_t max_analyze_duration = ic->max_analyze_duration;
2536  int64_t max_stream_analyze_duration;
2537  int64_t max_subtitle_analyze_duration;
2538  int64_t probesize = ic->probesize;
2539  int eof_reached = 0;
2540 
2541  flush_codecs = probesize > 0;
2542 
2543  av_opt_set_int(ic, "skip_clear", 1, AV_OPT_SEARCH_CHILDREN);
2544 
2545  max_stream_analyze_duration = max_analyze_duration;
2546  max_subtitle_analyze_duration = max_analyze_duration;
2547  if (!max_analyze_duration) {
2548  max_stream_analyze_duration =
2549  max_analyze_duration = 5*AV_TIME_BASE;
2550  max_subtitle_analyze_duration = 30*AV_TIME_BASE;
2551  if (!strcmp(ic->iformat->name, "flv"))
2552  max_stream_analyze_duration = 90*AV_TIME_BASE;
2553  if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
2554  max_stream_analyze_duration = 7*AV_TIME_BASE;
2555  }
2556 
2557  if (ic->pb) {
2558  FFIOContext *const ctx = ffiocontext(ic->pb);
2559  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
2560  avio_tell(ic->pb), ctx->bytes_read, ctx->seek_count, ic->nb_streams);
2561  }
2562 
2563  for (unsigned i = 0; i < ic->nb_streams; i++) {
2564  const AVCodec *codec;
2565  AVDictionary *thread_opt = NULL;
2566  AVStream *const st = ic->streams[i];
2567  FFStream *const sti = ffstream(st);
2568  AVCodecContext *const avctx = sti->avctx;
2569 
2570  /* check if the caller has overridden the codec id */
2571  // only for the split stuff
2572  if (!sti->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && sti->request_probe <= 0) {
2573  sti->parser = av_parser_init(st->codecpar->codec_id);
2574  if (sti->parser) {
2575  if (sti->need_parsing == AVSTREAM_PARSE_HEADERS) {
2577  } else if (sti->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2579  }
2580  } else if (sti->need_parsing) {
2581  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2582  "%s, packets or times may be invalid.\n",
2584  }
2585  }
2586 
2588  if (ret < 0)
2589  goto find_stream_info_err;
2590  if (sti->request_probe <= 0)
2591  sti->avctx_inited = 1;
2592 
2593  codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
2594 
2595  /* Force thread count to 1 since the H.264 decoder will not extract
2596  * SPS and PPS to extradata during multi-threaded decoding. */
2597  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2598  /* Force lowres to 0. The decoder might reduce the video size by the
2599  * lowres factor, and we don't want that propagated to the stream's
2600  * codecpar */
2601  av_dict_set(options ? &options[i] : &thread_opt, "lowres", "0", 0);
2602 
2603  if (ic->codec_whitelist)
2604  av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
2605 
2606  // Try to just open decoders, in case this is enough to get parameters.
2607  // Also ensure that subtitle_header is properly set.
2608  if (!has_codec_parameters(st, NULL) && sti->request_probe <= 0 ||
2610  if (codec && !avctx->codec)
2611  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
2612  av_log(ic, AV_LOG_WARNING,
2613  "Failed to open codec in %s\n", __func__);
2614  }
2615  if (!options)
2616  av_dict_free(&thread_opt);
2617  }
2618 
2619  read_size = 0;
2620  for (;;) {
2621  const AVPacket *pkt;
2622  AVStream *st;
2623  FFStream *sti;
2624  AVCodecContext *avctx;
2625  int analyzed_all_streams;
2626  unsigned i;
2628  ret = AVERROR_EXIT;
2629  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2630  break;
2631  }
2632 
2633  /* check if one codec still needs to be handled */
2634  for (i = 0; i < ic->nb_streams; i++) {
2635  AVStream *const st = ic->streams[i];
2636  FFStream *const sti = ffstream(st);
2637  int fps_analyze_framecount = 20;
2638  int count;
2639 
2640  if (!has_codec_parameters(st, NULL))
2641  break;
2642  /* If the timebase is coarse (like the usual millisecond precision
2643  * of mkv), we need to analyze more frames to reliably arrive at
2644  * the correct fps. */
2645  if (av_q2d(st->time_base) > 0.0005)
2646  fps_analyze_framecount *= 2;
2647  if (!tb_unreliable(ic, st))
2648  fps_analyze_framecount = 0;
2649  if (ic->fps_probe_size >= 0)
2650  fps_analyze_framecount = ic->fps_probe_size;
2652  fps_analyze_framecount = 0;
2653  /* variable fps and no guess at the real fps */
2654  count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
2656  sti->info->duration_count;
2657  if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
2659  if (count < fps_analyze_framecount)
2660  break;
2661  }
2662  // Look at the first 3 frames if there is evidence of frame delay
2663  // but the decoder delay is not set.
2664  if (sti->info->frame_delay_evidence && count < 2 && sti->avctx->has_b_frames == 0)
2665  break;
2666  if (!sti->avctx->extradata &&
2667  (!sti->extract_extradata.inited || sti->extract_extradata.bsf) &&
2669  break;
2670  if (sti->first_dts == AV_NOPTS_VALUE &&
2675  break;
2676  }
2677  analyzed_all_streams = 0;
2678  if (i == ic->nb_streams && !si->missing_streams) {
2679  analyzed_all_streams = 1;
2680  /* NOTE: If the format has no header, then we need to read some
2681  * packets to get most of the streams, so we cannot stop here. */
2682  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2683  /* If we found the info for all the codecs, we can stop. */
2684  ret = count;
2685  av_log(ic, AV_LOG_DEBUG, "All info found\n");
2686  flush_codecs = 0;
2687  break;
2688  }
2689  }
2690  /* We did not get all the codec info, but we read too much data. */
2691  if (read_size >= probesize) {
2692  ret = count;
2693  av_log(ic, AV_LOG_DEBUG,
2694  "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
2695  for (unsigned i = 0; i < ic->nb_streams; i++) {
2696  AVStream *const st = ic->streams[i];
2697  FFStream *const sti = ffstream(st);
2698  if (!st->r_frame_rate.num &&
2699  sti->info->duration_count <= 1 &&
2701  strcmp(ic->iformat->name, "image2"))
2702  av_log(ic, AV_LOG_WARNING,
2703  "Stream #%d: not enough frames to estimate rate; "
2704  "consider increasing probesize\n", i);
2705  }
2706  break;
2707  }
2708 
2709  /* NOTE: A new stream can be added there if no header in file
2710  * (AVFMTCTX_NOHEADER). */
2711  ret = read_frame_internal(ic, pkt1);
2712  if (ret == AVERROR(EAGAIN))
2713  continue;
2714 
2715  if (ret < 0) {
2716  /* EOF or error*/
2717  eof_reached = 1;
2718  break;
2719  }
2720 
2721  if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
2723  pkt1, NULL, 0);
2724  if (ret < 0)
2725  goto unref_then_goto_end;
2726 
2727  pkt = &si->packet_buffer.tail->pkt;
2728  } else {
2729  pkt = pkt1;
2730  }
2731 
2732  st = ic->streams[pkt->stream_index];
2733  sti = ffstream(st);
2735  read_size += pkt->size;
2736 
2737  avctx = sti->avctx;
2738  if (!sti->avctx_inited) {
2740  if (ret < 0)
2741  goto unref_then_goto_end;
2742  sti->avctx_inited = 1;
2743  }
2744 
2745  if (pkt->dts != AV_NOPTS_VALUE && sti->codec_info_nb_frames > 1) {
2746  /* check for non-increasing dts */
2747  if (sti->info->fps_last_dts != AV_NOPTS_VALUE &&
2748  sti->info->fps_last_dts >= pkt->dts) {
2749  av_log(ic, AV_LOG_DEBUG,
2750  "Non-increasing DTS in stream %d: packet %d with DTS "
2751  "%"PRId64", packet %d with DTS %"PRId64"\n",
2752  st->index, sti->info->fps_last_dts_idx,
2754  pkt->dts);
2755  sti->info->fps_first_dts =
2757  }
2758  /* Check for a discontinuity in dts. If the difference in dts
2759  * is more than 1000 times the average packet duration in the
2760  * sequence, we treat it as a discontinuity. */
2761  if (sti->info->fps_last_dts != AV_NOPTS_VALUE &&
2762  sti->info->fps_last_dts_idx > sti->info->fps_first_dts_idx &&
2763  (pkt->dts - (uint64_t)sti->info->fps_last_dts) / 1000 >
2764  (sti->info->fps_last_dts - (uint64_t)sti->info->fps_first_dts) /
2765  (sti->info->fps_last_dts_idx - sti->info->fps_first_dts_idx)) {
2766  av_log(ic, AV_LOG_WARNING,
2767  "DTS discontinuity in stream %d: packet %d with DTS "
2768  "%"PRId64", packet %d with DTS %"PRId64"\n",
2769  st->index, sti->info->fps_last_dts_idx,
2771  pkt->dts);
2772  sti->info->fps_first_dts =
2774  }
2775 
2776  /* update stored dts values */
2777  if (sti->info->fps_first_dts == AV_NOPTS_VALUE) {
2778  sti->info->fps_first_dts = pkt->dts;
2780  }
2781  sti->info->fps_last_dts = pkt->dts;
2783  }
2784  if (sti->codec_info_nb_frames > 1) {
2785  int64_t t = 0;
2786  int64_t limit;
2787 
2788  if (st->time_base.den > 0)
2790  if (st->avg_frame_rate.num > 0)
2792 
2793  if ( t == 0
2794  && sti->codec_info_nb_frames > 30
2795  && sti->info->fps_first_dts != AV_NOPTS_VALUE
2796  && sti->info->fps_last_dts != AV_NOPTS_VALUE) {
2798  t = FFMAX(t, av_rescale_q(dur, st->time_base, AV_TIME_BASE_Q));
2799  }
2800 
2801  if (analyzed_all_streams) limit = max_analyze_duration;
2802  else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
2803  else limit = max_stream_analyze_duration;
2804 
2805  if (t >= limit) {
2806  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
2807  limit,
2808  t, pkt->stream_index);
2809  if (ic->flags & AVFMT_FLAG_NOBUFFER)
2810  av_packet_unref(pkt1);
2811  break;
2812  }
2813  if (pkt->duration > 0) {
2814  const int fields = sti->codec_desc && (sti->codec_desc->props & AV_CODEC_PROP_FIELDS);
2816  && (uint64_t)pkt->pts - st->start_time < INT64_MAX
2817  ) {
2819  } else
2821  sti->info->codec_info_duration_fields += sti->parser && sti->need_parsing && fields
2822  ? sti->parser->repeat_pict + 1 : 2;
2823  }
2824  }
2825  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2826 #if FF_API_R_FRAME_RATE
2827  ff_rfps_add_frame(ic, st, pkt->dts);
2828 #endif
2829  if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
2830  sti->info->frame_delay_evidence = 1;
2831  }
2832  if (!sti->avctx->extradata) {
2833  ret = extract_extradata(si, st, pkt);
2834  if (ret < 0)
2835  goto unref_then_goto_end;
2836  }
2837 
2838  /* If still no information, we try to open the codec and to
2839  * decompress the frame. We try to avoid that in most cases as
2840  * it takes longer and uses more memory. For MPEG-4, we need to
2841  * decompress for QuickTime.
2842  *
2843  * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2844  * least one frame of codec data, this makes sure the codec initializes
2845  * the channel configuration and does not only trust the values from
2846  * the container. */
2847  try_decode_frame(ic, st, pkt,
2848  (options && i < orig_nb_streams) ? &options[i] : NULL);
2849 
2850  if (ic->flags & AVFMT_FLAG_NOBUFFER)
2851  av_packet_unref(pkt1);
2852 
2853  sti->codec_info_nb_frames++;
2854  count++;
2855  }
2856 
2857  if (eof_reached) {
2858  for (unsigned stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
2859  AVStream *const st = ic->streams[stream_index];
2860  AVCodecContext *const avctx = ffstream(st)->avctx;
2861  if (!has_codec_parameters(st, NULL)) {
2862  const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
2863  if (codec && !avctx->codec) {
2864  AVDictionary *opts = NULL;
2865  if (ic->codec_whitelist)
2866  av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
2867  if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
2868  av_log(ic, AV_LOG_WARNING,
2869  "Failed to open codec in %s\n", __func__);
2870  av_dict_free(&opts);
2871  }
2872  }
2873 
2874  // EOF already reached while reading the stream above.
2875  // So continue with reoordering DTS with whatever delay we have.
2877  update_dts_from_pts(ic, stream_index, si->packet_buffer.head);
2878  }
2879  }
2880  }
2881 
2882  if (flush_codecs) {
2883  AVPacket *empty_pkt = si->pkt;
2884  int err = 0;
2885  av_packet_unref(empty_pkt);
2886 
2887  for (unsigned i = 0; i < ic->nb_streams; i++) {
2888  AVStream *const st = ic->streams[i];
2889  FFStream *const sti = ffstream(st);
2890 
2891  /* flush the decoders */
2892  if (sti->info->found_decoder == 1) {
2893  err = try_decode_frame(ic, st, empty_pkt,
2894  (options && i < orig_nb_streams)
2895  ? &options[i] : NULL);
2896 
2897  if (err < 0) {
2898  av_log(ic, AV_LOG_INFO,
2899  "decoding for stream %d failed\n", st->index);
2900  }
2901  }
2902  }
2903  }
2904 
2905  ff_rfps_calculate(ic);
2906 
2907  for (unsigned i = 0; i < ic->nb_streams; i++) {
2908  AVStream *const st = ic->streams[i];
2909  FFStream *const sti = ffstream(st);
2910  AVCodecContext *const avctx = sti->avctx;
2911 
2912  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
2913  if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
2914  uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
2916  avctx->codec_tag= tag;
2917  }
2918 
2919  /* estimate average framerate if not set by demuxer */
2920  if (sti->info->codec_info_duration_fields &&
2921  !st->avg_frame_rate.num &&
2922  sti->info->codec_info_duration) {
2923  int best_fps = 0;
2924  double best_error = 0.01;
2925  AVRational codec_frame_rate = avctx->framerate;
2926 
2927  if (sti->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
2928  sti->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
2929  sti->info->codec_info_duration < 0)
2930  continue;
2933  sti->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
2934 
2935  /* Round guessed framerate to a "standard" framerate if it's
2936  * within 1% of the original estimate. */
2937  for (int j = 0; j < MAX_STD_TIMEBASES; j++) {
2938  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
2939  double error = fabs(av_q2d(st->avg_frame_rate) /
2940  av_q2d(std_fps) - 1);
2941 
2942  if (error < best_error) {
2943  best_error = error;
2944  best_fps = std_fps.num;
2945  }
2946 
2948  codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
2949  error = fabs(av_q2d(codec_frame_rate) /
2950  av_q2d(std_fps) - 1);
2951  if (error < best_error) {
2952  best_error = error;
2953  best_fps = std_fps.num;
2954  }
2955  }
2956  }
2957  if (best_fps)
2959  best_fps, 12 * 1001, INT_MAX);
2960  }
2961  if (!st->r_frame_rate.num) {
2962  const AVCodecDescriptor *desc = sti->codec_desc;
2963  AVRational mul = (AVRational){ desc && (desc->props & AV_CODEC_PROP_FIELDS) ? 2 : 1, 1 };
2964  AVRational fr = av_mul_q(avctx->framerate, mul);
2965 
2966  if (fr.num && fr.den && av_cmp_q(st->time_base, av_inv_q(fr)) <= 0) {
2967  st->r_frame_rate = fr;
2968  } else {
2969  st->r_frame_rate.num = st->time_base.den;
2970  st->r_frame_rate.den = st->time_base.num;
2971  }
2972  }
2973  st->codecpar->framerate = avctx->framerate;
2974  if (sti->display_aspect_ratio.num && sti->display_aspect_ratio.den) {
2975  AVRational hw_ratio = { avctx->height, avctx->width };
2977  hw_ratio);
2978  }
2979  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2980  if (!avctx->bits_per_coded_sample)
2981  avctx->bits_per_coded_sample =
2983  // set stream disposition based on audio service type
2984  switch (avctx->audio_service_type) {
2987  break;
2990  break;
2993  break;
2996  break;
2999  break;
3000  }
3001  }
3002  }
3003 
3004  if (probesize)
3005  estimate_timings(ic, old_offset);
3006 
3007  av_opt_set_int(ic, "skip_clear", 0, AV_OPT_SEARCH_CHILDREN);
3008 
3009  if (ret >= 0 && ic->nb_streams)
3010  /* We could not have all the codec parameters before EOF. */
3011  ret = -1;
3012  for (unsigned i = 0; i < ic->nb_streams; i++) {
3013  AVStream *const st = ic->streams[i];
3014  FFStream *const sti = ffstream(st);
3015  const char *errmsg;
3016 
3017  /* if no packet was ever seen, update context now for has_codec_parameters */
3018  if (!sti->avctx_inited) {
3019  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3021  st->codecpar->format = sti->avctx->sample_fmt;
3023  if (ret < 0)
3024  goto find_stream_info_err;
3025  }
3026  if (!has_codec_parameters(st, &errmsg)) {
3027  char buf[256];
3028  avcodec_string(buf, sizeof(buf), sti->avctx, 0);
3029  av_log(ic, AV_LOG_WARNING,
3030  "Could not find codec parameters for stream %d (%s): %s\n"
3031  "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
3032  i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
3033  } else {
3034  ret = 0;
3035  }
3036  }
3037 
3038  err = compute_chapters_end(ic);
3039  if (err < 0) {
3040  ret = err;
3041  goto find_stream_info_err;
3042  }
3043 
3044  /* update the stream parameters from the internal codec contexts */
3045  for (unsigned i = 0; i < ic->nb_streams; i++) {
3046  AVStream *const st = ic->streams[i];
3047  FFStream *const sti = ffstream(st);
3048 
3049  if (sti->avctx_inited) {
3051  if (ret < 0)
3052  goto find_stream_info_err;
3053 
3054  if (sti->avctx->rc_buffer_size > 0 || sti->avctx->rc_max_rate > 0 ||
3055  sti->avctx->rc_min_rate) {
3056  size_t cpb_size;
3057  AVCPBProperties *props = av_cpb_properties_alloc(&cpb_size);
3058  if (props) {
3059  if (sti->avctx->rc_buffer_size > 0)
3060  props->buffer_size = sti->avctx->rc_buffer_size;
3061  if (sti->avctx->rc_min_rate > 0)
3062  props->min_bitrate = sti->avctx->rc_min_rate;
3063  if (sti->avctx->rc_max_rate > 0)
3064  props->max_bitrate = sti->avctx->rc_max_rate;
3068  (uint8_t *)props, cpb_size, 0))
3069  av_free(props);
3070  }
3071  }
3072  }
3073 
3074  sti->avctx_inited = 0;
3075 #if FF_API_AVSTREAM_SIDE_DATA
3077  if (st->codecpar->nb_coded_side_data > 0) {
3078  av_assert0(!st->side_data && !st->nb_side_data);
3079  st->side_data = av_calloc(st->codecpar->nb_coded_side_data, sizeof(*st->side_data));
3080  if (!st->side_data) {
3081  ret = AVERROR(ENOMEM);
3082  goto find_stream_info_err;
3083  }
3084 
3085  for (int j = 0; j < st->codecpar->nb_coded_side_data; j++) {
3086  uint8_t *data = av_memdup(st->codecpar->coded_side_data[j].data,
3087  st->codecpar->coded_side_data[j].size);
3088  if (!data) {
3089  ret = AVERROR(ENOMEM);
3090  goto find_stream_info_err;
3091  }
3092  st->side_data[j].type = st->codecpar->coded_side_data[j].type;
3093  st->side_data[j].size = st->codecpar->coded_side_data[j].size;
3094  st->side_data[j].data = data;
3095  st->nb_side_data++;
3096  }
3097  }
3099 #endif
3100  }
3101 
3102 find_stream_info_err:
3103  for (unsigned i = 0; i < ic->nb_streams; i++) {
3104  AVStream *const st = ic->streams[i];
3105  FFStream *const sti = ffstream(st);
3106  int err;
3107 
3108  if (sti->info) {
3109  av_freep(&sti->info->duration_error);
3110  av_freep(&sti->info);
3111  }
3112 
3113  if (avcodec_is_open(sti->avctx)) {
3114  err = codec_close(sti);
3115  if (err < 0 && ret >= 0)
3116  ret = err;
3117  }
3118 
3120  }
3121  if (ic->pb) {
3122  FFIOContext *const ctx = ffiocontext(ic->pb);
3123  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3124  avio_tell(ic->pb), ctx->bytes_read, ctx->seek_count, count);
3125  }
3126  return ret;
3127 
3128 unref_then_goto_end:
3129  av_packet_unref(pkt1);
3130  goto find_stream_info_err;
3131 }
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:2238
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:1083
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:429
AVCodec
AVCodec.
Definition: codec.h:187
ff_rfps_add_frame
int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
add frame for rfps calculation.
Definition: demux.c:2295
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AVBSFContext::par_in
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:90
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AVFMT_FLAG_DISCARD_CORRUPT
#define AVFMT_FLAG_DISCARD_CORRUPT
Discard frames marked corrupted.
Definition: avformat.h:1460
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:212
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:2767
DURATION_DEFAULT_MAX_RETRY
#define DURATION_DEFAULT_MAX_RETRY
Definition: demux.c:1829
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:449
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:1283
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:251
AVCodecContext::audio_service_type
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:1103
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:1579
AVSTREAM_EVENT_FLAG_NEW_PACKETS
#define AVSTREAM_EVENT_FLAG_NEW_PACKETS
Definition: avformat.h:904
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:894
is_relative
static av_always_inline int is_relative(int64_t ts)
Definition: avformat_internal.h:114
FFStream::first_dts
int64_t first_dts
Timestamp corresponding to the last dts sync point.
Definition: internal.h:348
AVCodecParserContext::pict_type
int pict_type
Definition: avcodec.h:2756
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1056
AVCodecContext::rc_min_rate
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1309
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:170
FFStream::last_IP_pts
int64_t last_IP_pts
Definition: internal.h:316
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:127
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:56
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AV_DISPOSITION_ATTACHED_PIC
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:674
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:819
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:404
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:601
AVCodecParserContext::duration
int duration
Duration of the current frame.
Definition: avcodec.h:2862
avcodec_string
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: avcodec.c:513
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:479
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
int64_t
long long int64_t
Definition: coverity.c:34
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:162
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:229
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1368
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:390
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:206
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:539
AV_CODEC_ID_DVB_TELETEXT
@ AV_CODEC_ID_DVB_TELETEXT
Definition: codec_id.h:563
extract_extradata_check
static int extract_extradata_check(AVStream *st)
Definition: demux.c:2420
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:837
AVChapter::start
int64_t start
Definition: avformat.h:1262
AVFMT_FLAG_CUSTOM_IO
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don't avio_close() it.
Definition: avformat.h:1459
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:1647
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:1731
AVCodecParameters::framerate
AVRational framerate
Video only.
Definition: codec_par.h:156
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1501
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
FFStream::extract_extradata
struct FFStream::@391 extract_extradata
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:557
ts_to_samples
static int64_t ts_to_samples(AVStream *st, int64_t ts)
Definition: demux.c:1278
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:34
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:454
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AVFormatContext::probesize
int64_t probesize
Maximum number of bytes read from input in order to determine stream properties.
Definition: avformat.h:1487
estimate_timings_from_pts
static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
Definition: demux.c:1833
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1547
cffstream
static const av_always_inline FFStream * cffstream(const AVStream *st)
Definition: internal.h:363
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:708
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:327
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:291
AV_CODEC_ID_HDMV_PGS_SUBTITLE
@ AV_CODEC_ID_HDMV_PGS_SUBTITLE
Definition: codec_id.h:562
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:490
update_stream_timings
static void update_stream_timings(AVFormatContext *ic)
Estimate the stream timings from the one of each components.
Definition: demux.c:1664
FFIOContext
Definition: avio_internal.h:28
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:594
codec_close
static int codec_close(FFStream *sti)
Definition: demux.c:1283
FormatContextInternal
Definition: avformat_internal.h:33
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:610
FFStream::codec_desc
const struct AVCodecDescriptor * codec_desc
Definition: internal.h:351
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:316
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:114
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:96
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:566
avformat_close_input
void avformat_close_input(AVFormatContext **ps)
Close an opened input AVFormatContext.
Definition: demux.c:366
AVPacketSideData::size
size_t size
Definition: packet.h:392
AVCodecParserContext::offset
int64_t offset
byte offset from starting packet start
Definition: avcodec.h:2788
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:1573
AVCodecParserContext::key_frame
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
Definition: avcodec.h:2797
FFStream::dts_ordered
uint8_t dts_ordered
Definition: internal.h:292
finish
static void finish(void)
Definition: movenc.c:374
FFStream::last_IP_duration
int last_IP_duration
Definition: internal.h:317
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:460
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:358
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1071
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:1830
fail
#define fail()
Definition: checkasm.h:189
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:596
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:171
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:582
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:160
AVChapter
Definition: avformat.h:1259
AVFMT_GENERIC_INDEX
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:480
AVFMT_DURATION_FROM_PTS
@ AVFMT_DURATION_FROM_PTS
Duration accurately estimated from PTSes.
Definition: avformat.h:1281
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:447
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:807
av_probe_input_format3
const AVInputFormat * av_probe_input_format3(const AVProbeData *pd, int is_opened, int *score_ret)
Guess the file format.
Definition: format.c:154
AV_PTS_WRAP_IGNORE
#define AV_PTS_WRAP_IGNORE
Options for behavior on timestamp wrap detection.
Definition: avformat.h:737
ff_check_interrupt
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrupt a blocking function associated with cb.
Definition: avio.c:854
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
extract_extradata_init
static int extract_extradata_init(AVStream *st)
Definition: demux.c:2436
AVCodecParserContext::dts
int64_t dts
Definition: avcodec.h:2768
AVRational::num
int num
Numerator.
Definition: rational.h:59
FFDIFFSIGN
#define FFDIFFSIGN(x, y)
Comparator.
Definition: macros.h:45
ff_id3v2_parse_chapters
int ff_id3v2_parse_chapters(AVFormatContext *s, ID3v2ExtraMeta *cur)
Create chapters for all CHAP tags found in the ID3v2 header.
Definition: id3v2.c:1193
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:406
raw.h
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:150
AV_CODEC_ID_DVB_SUBTITLE
@ AV_CODEC_ID_DVB_SUBTITLE
Definition: codec_id.h:557
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1442
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:550
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:983
AV_DISPOSITION_CLEAN_EFFECTS
#define AV_DISPOSITION_CLEAN_EFFECTS
The audio stream contains music and sound effects without voice.
Definition: avformat.h:666
AVFormatContext::max_ts_probe
int max_ts_probe
Maximum number of packets to read while waiting for the first timestamp.
Definition: avformat.h:1628
avassert.h
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:235
pkt
AVPacket * pkt
Definition: movenc.c:60
chapter_start_cmp
static int chapter_start_cmp(const void *p1, const void *p2)
Definition: demux.c:2199
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
AV_CODEC_CAP_EXPERIMENTAL
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: codec.h:102
AVInputFormat
Definition: avformat.h:548
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:595
ID3v2ExtraMeta
Definition: id3v2.h:84
AVFormatContext::ctx_flags
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1349
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:216
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:530
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:729
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:1262
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:1451
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:1975
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1500
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
bitrate
int64_t bitrate
Definition: av1_levels.c:47
AVFormatContext::iformat
const struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1312
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:2429
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:446
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:242
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:713
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
AVPacketSideData::data
uint8_t * data
Definition: packet.h:391
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:331
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:284
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:307
AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
@ AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
Definition: defs.h:228
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:112
DURATION_MAX_RETRY
#define DURATION_MAX_RETRY
Definition: demux.c:1830
AV_CODEC_ID_CODEC2
@ AV_CODEC_ID_CODEC2
Definition: codec_id.h:513
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:410
AVProgram::start_time
int64_t start_time
Definition: avformat.h:1244
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1302
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:86
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
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:283
determinable_frame_size
static int determinable_frame_size(const AVCodecContext *avctx)
Definition: demux.c:2035
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:271
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:461
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:1495
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:1457
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:233
get_std_framerate
static int get_std_framerate(int i)
Definition: demux.c:2246
has_codec_parameters
static int has_codec_parameters(const AVStream *st, const char **errmsg_ptr)
Definition: demux.c:2048
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:2766
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:325
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1287
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:221
AVFormatContext
Format I/O context.
Definition: avformat.h:1300
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:522
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
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:75
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:787
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:164
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:1040
av_match_list
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
Definition: avstring.c:444
avcodec_parameters_free
void avcodec_parameters_free(AVCodecParameters **ppar)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: codec_par.c:66
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1251
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:543
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:1555
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:1282
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:501
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:393
AV_DISPOSITION_COMMENT
#define AV_DISPOSITION_COMMENT
The stream is a commentary track.
Definition: avformat.h:639
AVSTREAM_PARSE_NONE
@ AVSTREAM_PARSE_NONE
Definition: avformat.h:592
update_initial_durations
static void update_initial_durations(AVFormatContext *s, AVStream *st, int stream_index, int64_t duration)
Definition: demux.c:907
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
ff_id3v2_parse_apic
int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create a stream for each APIC (attached picture) extracted from the ID3v2 header.
Definition: id3v2.c:1162
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1342
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:1280
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:1927
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:42
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:2781
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:1716
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:437
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:1332
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:1981
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
AV_CODEC_ID_EAC3
@ AV_CODEC_ID_EAC3
Definition: codec_id.h:486
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1356
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:106
FFFormatContext::id3v2_meta
AVDictionary * id3v2_meta
ID3v2 tag useful for MP3 demuxing.
Definition: internal.h:122
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:448
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:1456
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:86
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:2525
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:199
AVCodecParserContext::frame_offset
int64_t frame_offset
Definition: avcodec.h:2751
AV_PTS_WRAP_SUB_OFFSET
#define AV_PTS_WRAP_SUB_OFFSET
subtract the format specific offset on wrap detection
Definition: avformat.h:739
AVPacket::size
int size
Definition: packet.h:540
avpriv_pix_fmt_find
enum AVPixelFormat avpriv_pix_fmt_find(enum PixelFormatTagLists list, unsigned fourcc)
Definition: raw.c:363
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:157
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:132
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:1245
start_time
static int64_t start_time
Definition: ffplay.c:326
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:450
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1063
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:557
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:40
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AV_CODEC_PROP_FIELDS
#define AV_CODEC_PROP_FIELDS
Video codec supports separate coding of fields in interlaced frames.
Definition: codec_desc.h:97
update_wrap_reference
static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
Definition: demux.c:467
AVStream::event_flags
int event_flags
Flags indicating events happening on the stream, a combination of AVSTREAM_EVENT_FLAG_*.
Definition: avformat.h:891
FFStream::dts_misordered
uint8_t dts_misordered
Definition: internal.h:293
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:799
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:738
AVFMT_FLAG_IGNDTS
#define AVFMT_FLAG_IGNDTS
Ignore DTS on frames that contain both DTS & PTS.
Definition: avformat.h:1455
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:278
AVCPBProperties::min_bitrate
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: defs.h:281
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:826
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:658
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
update_stream_avctx
static int update_stream_avctx(AVFormatContext *s)
Definition: demux.c:188
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:699
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:271
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:492
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
FFStreamInfo::rfps_duration_sum
int64_t rfps_duration_sum
Definition: demux.h:148
FFStream::update_initial_durations_done
int update_initial_durations_done
Internal data to prevent doing update_initial_durations() twice.
Definition: internal.h:276
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:221
estimate_timings_from_bit_rate
static void estimate_timings_from_bit_rate(AVFormatContext *ic)
Definition: demux.c:1775
FFStream::probe_packets
int probe_packets
Number of packets to buffer for codec probing.
Definition: internal.h:322
ff_rfps_calculate
void ff_rfps_calculate(AVFormatContext *ic)
Definition: demux.c:2356
avformat_internal.h
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:220
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:309
AVCodec::id
enum AVCodecID id
Definition: codec.h:201
filesize
static int64_t filesize(AVIOContext *pb)
Definition: ffmpeg_mux.c:51
FFStream::skip_to_keyframe
int skip_to_keyframe
Indicates that everything up to the next keyframe should be discarded.
Definition: internal.h:207
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:409
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1578
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:728
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
AVFMT_FLAG_NOBUFFER
#define AVFMT_FLAG_NOBUFFER
Do not buffer frames when possible.
Definition: avformat.h:1458
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:940
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:2850
PacketListEntry
Definition: packet_internal.h:28
PARSER_FLAG_COMPLETE_FRAMES
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:2782
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:532
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:1260
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:529
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: packet.c:252
internal.h
find_probe_decoder
static const AVCodec * find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
Definition: demux.c:73
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
ff_id3v2_read_dict
void ff_id3v2_read_dict(AVIOContext *pb, AVDictionary **metadata, const char *magic, ID3v2ExtraMeta **extra_meta)
Read an ID3v2 tag into specified dictionary and retrieve supported extra metadata.
Definition: id3v2.c:1134
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
AVFormatContext::codec_whitelist
char * codec_whitelist
',' separated list of allowed decoders.
Definition: avformat.h:1787
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:276
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:647
ff_wrap_timestamp
int64_t ff_wrap_timestamp(const AVStream *st, int64_t timestamp)
Wrap a given time stamp, if there is an indication for an overflow.
Definition: demux.c: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:286
av_find_default_stream_index
int av_find_default_stream_index(AVFormatContext *s)
Definition: avformat.c:419
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:227
av_get_audio_frame_duration
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:786
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:1224
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:624
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:663
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_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
av_codec_iterate
const AVCodec * av_codec_iterate(void **opaque)
Iterate over all registered codecs.
Definition: allcodecs.c:963
try_decode_frame
static int try_decode_frame(AVFormatContext *s, AVStream *st, const AVPacket *pkt, AVDictionary **options)
Definition: demux.c:2097
avcodec.h
limit
static double limit(double x)
Definition: vf_pseudocolor.c:142
AVCodecParserContext
Definition: avcodec.h:2748
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:124
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:817
AVFMT_FLAG_GENPTS
#define AVFMT_FLAG_GENPTS
Generate missing pts even if it requires parsing future frames.
Definition: avformat.h:1452
AV_DISPOSITION_VISUAL_IMPAIRED
#define AV_DISPOSITION_VISUAL_IMPAIRED
The stream is intended for visually impaired audiences.
Definition: avformat.h:662
tag
uint32_t tag
Definition: movenc.c:1879
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:760
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
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:292
tb_unreliable
static int tb_unreliable(AVFormatContext *ic, AVStream *st)
Definition: demux.c:2270
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:594
avformat.h
dict.h
AV_AUDIO_SERVICE_TYPE_KARAOKE
@ AV_AUDIO_SERVICE_TYPE_KARAOKE
Definition: defs.h:233
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:550
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:451
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:754
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:281
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:231
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:567
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_AUDIO_SERVICE_TYPE_COMMENTARY
@ AV_AUDIO_SERVICE_TYPE_COMMENTARY
Definition: defs.h:230
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:138
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:1828
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:149
ff_fc_internal
static av_always_inline FormatContextInternal * ff_fc_internal(AVFormatContext *s)
Definition: avformat_internal.h:107
PARSER_FLAG_USE_CODEC_TS
#define PARSER_FLAG_USE_CODEC_TS
Definition: avcodec.h:2786
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:914
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:153
AVCodecContext::ticks_per_frame
attribute_deprecated int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:582
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:597
FFStream::info
struct FFStreamInfo * info
Stream information used internally by avformat_find_stream_info()
Definition: internal.h:186
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1435
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:541
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:447
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:459
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:201
av_parser_parse2
int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int64_t pts, int64_t dts, int64_t pos)
Parse a packet.
Definition: parser.c:115
extract_extradata
static int extract_extradata(FFFormatContext *si, AVStream *st, const AVPacket *pkt)
Definition: demux.c:2476
mem.h
packet_internal.h
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:394
avcodec_parameters_from_context
int avcodec_parameters_from_context(struct AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: codec_par.c:137
AVCodecParameters::format
int format
Definition: codec_par.h:92
FFStream::request_probe
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: internal.h:202
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:476
AV_AUDIO_SERVICE_TYPE_EFFECTS
@ AV_AUDIO_SERVICE_TYPE_EFFECTS
Definition: defs.h:226
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:516
fill_all_stream_timings
static void fill_all_stream_timings(AVFormatContext *ic)
Definition: demux.c:1758
avio_closep
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
Definition: avio.c:649
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:237
select_from_pts_buffer
static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts)
Definition: demux.c: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:1146
FFStream::cur_dts
int64_t cur_dts
Definition: internal.h:349
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:559
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
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:177
avio_close
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: avio.c:616
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
ff_id3v2_parse_priv
int ff_id3v2_parse_priv(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Add metadata for all PRIV tags in the ID3v2 header.
Definition: id3v2.c:1258
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVFormatContext::start_time
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1425
AV_CODEC_ID_AAC_LATM
@ AV_CODEC_ID_AAC_LATM
Definition: codec_id.h:495
FFStreamInfo::fps_last_dts_idx
int fps_last_dts_idx
Definition: demux.h:169
FFStream::parser
struct AVCodecParserContext * parser
Definition: internal.h:326
AV_CODEC_CAP_AVOID_PROBING
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition: codec.h:138
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
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:1986
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:3759
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:797
PARSER_FLAG_ONCE
#define PARSER_FLAG_ONCE
Definition: avcodec.h:2783
AV_CODEC_ID_APTX
@ AV_CODEC_ID_APTX
Definition: codec_id.h:531
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:595
AVDiscard
AVDiscard
Definition: defs.h:212
AVStream::pts_wrap_bits
int pts_wrap_bits
Number of bits in timestamps.
Definition: avformat.h:923
AVChapter::time_base
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1261
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:488
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:259
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:2209
avpriv_codec_get_cap_skip_frame_fill_param
int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec)
Definition: utils.c:405
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:1677
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:551
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:951
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:87