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