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) {
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 
536  // correct first time stamps to negative values
537  if (!is_relative(sti->first_dts))
538  sti->first_dts = wrap_timestamp(st, sti->first_dts);
539  if (!is_relative(st->start_time))
540  st->start_time = wrap_timestamp(st, st->start_time);
541  if (!is_relative(sti->cur_dts))
542  sti->cur_dts = wrap_timestamp(st, sti->cur_dts);
543  }
544 
545  pkt->dts = wrap_timestamp(st, pkt->dts);
546  pkt->pts = wrap_timestamp(st, pkt->pts);
547 
548  force_codec_ids(s, st);
549 
550  /* TODO: audio: time filter; video: frame reordering (pts != dts) */
551  if (s->use_wallclock_as_timestamps)
553 }
554 
555 /**
556  * Handle a new packet and either return it directly if possible and
557  * allow_passthrough is true or queue the packet (or drop the packet
558  * if corrupt).
559  *
560  * @return < 0 on error, 0 if the packet was passed through,
561  * 1 if it was queued or dropped
562  */
563 static int handle_new_packet(AVFormatContext *s, AVPacket *pkt, int allow_passthrough)
564 {
565  FFFormatContext *const si = ffformatcontext(s);
566  AVStream *st;
567  FFStream *sti;
568  int err;
569 
570  av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
571  "Invalid stream index.\n");
572 
573  if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
575  "Packet corrupt (stream = %d, dts = %s)%s.\n",
577  s->flags & AVFMT_FLAG_DISCARD_CORRUPT ? ", dropping it" : "");
578  if (s->flags & AVFMT_FLAG_DISCARD_CORRUPT) {
580  return 1;
581  }
582  }
583 
584  st = s->streams[pkt->stream_index];
585  sti = ffstream(st);
586 
587  update_timestamps(s, st, pkt);
588 
589  if (sti->request_probe <= 0 && allow_passthrough && !si->raw_packet_buffer.head)
590  return 0;
591 
593  if (err < 0) {
595  return err;
596  }
597 
598  pkt = &si->raw_packet_buffer.tail->pkt;
600 
601  err = probe_codec(s, st, pkt);
602  if (err < 0)
603  return err;
604 
605  return 1;
606 }
607 
609 {
610  int err = handle_new_packet(s, pkt, 0);
611 
612  return err < 0 ? err : 0;
613 }
614 
616 {
617  FFFormatContext *const si = ffformatcontext(s);
618  int err;
619 
620 #if FF_API_INIT_PACKET
622  pkt->data = NULL;
623  pkt->size = 0;
624  av_init_packet(pkt);
626 #else
628 #endif
629 
630  for (;;) {
632 
633  if (pktl) {
634  AVStream *const st = s->streams[pktl->pkt.stream_index];
635  if (si->raw_packet_buffer_size >= s->probesize)
636  if ((err = probe_codec(s, st, NULL)) < 0)
637  return err;
638  if (ffstream(st)->request_probe <= 0) {
641  return 0;
642  }
643  }
644 
645  err = ffifmt(s->iformat)->read_packet(s, pkt);
646  if (err < 0) {
648 
649  /* Some demuxers return FFERROR_REDO when they consume
650  data and discard it (ignored streams, junk, extradata).
651  We must re-call the demuxer to get the real packet. */
652  if (err == FFERROR_REDO)
653  continue;
654  if (!pktl || err == AVERROR(EAGAIN))
655  return err;
656  for (unsigned i = 0; i < s->nb_streams; i++) {
657  AVStream *const st = s->streams[i];
658  FFStream *const sti = ffstream(st);
659  if (sti->probe_packets || sti->request_probe > 0)
660  if ((err = probe_codec(s, st, NULL)) < 0)
661  return err;
662  av_assert0(sti->request_probe <= 0);
663  }
664  continue;
665  }
666 
668  if (err < 0) {
670  return err;
671  }
672 
673  err = handle_new_packet(s, pkt, 1);
674  if (err <= 0) /* Error or passthrough */
675  return err;
676  }
677 }
678 
679 /**
680  * Return the frame duration in seconds. Return 0 if not available.
681  */
682 static void compute_frame_duration(AVFormatContext *s, int *pnum, int *pden,
684  AVPacket *pkt)
685 {
686  FFStream *const sti = ffstream(st);
687  AVRational codec_framerate = sti->avctx->framerate;
688  int frame_size, sample_rate;
689 
690  *pnum = 0;
691  *pden = 0;
692  switch (st->codecpar->codec_type) {
693  case AVMEDIA_TYPE_VIDEO:
694  if (st->r_frame_rate.num && (!pc || !codec_framerate.num)) {
695  *pnum = st->r_frame_rate.den;
696  *pden = st->r_frame_rate.num;
697  } else if ((s->iformat->flags & AVFMT_NOTIMESTAMPS) &&
698  !codec_framerate.num &&
699  st->avg_frame_rate.num && st->avg_frame_rate.den) {
700  *pnum = st->avg_frame_rate.den;
701  *pden = st->avg_frame_rate.num;
702  } else if (st->time_base.num * 1000LL > st->time_base.den) {
703  *pnum = st->time_base.num;
704  *pden = st->time_base.den;
705  } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
706  int ticks_per_frame = (sti->codec_desc &&
707  (sti->codec_desc->props & AV_CODEC_PROP_FIELDS)) ? 2 : 1;
708  av_reduce(pnum, pden,
709  codec_framerate.den,
710  codec_framerate.num * (int64_t)ticks_per_frame,
711  INT_MAX);
712 
713  if (pc && pc->repeat_pict) {
714  av_reduce(pnum, pden,
715  (*pnum) * (1LL + pc->repeat_pict),
716  (*pden),
717  INT_MAX);
718  }
719  /* If this codec can be interlaced or progressive then we need
720  * a parser to compute duration of a packet. Thus if we have
721  * no parser in such case leave duration undefined. */
722  if (sti->codec_desc &&
723  (sti->codec_desc->props & AV_CODEC_PROP_FIELDS) && !pc)
724  *pnum = *pden = 0;
725  }
726  break;
727  case AVMEDIA_TYPE_AUDIO:
728  if (sti->avctx_inited) {
730  sample_rate = sti->avctx->sample_rate;
731  } else {
734  }
735  if (frame_size <= 0 || sample_rate <= 0)
736  break;
737  *pnum = frame_size;
738  *pden = sample_rate;
739  break;
740  default:
741  break;
742  }
743 }
744 
746 {
747  FFStream *const sti = ffstream(st);
748  if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
749  if (!sti->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
750  return 1;
751 #if CONFIG_H264_DECODER
752  if (sti->avctx->has_b_frames &&
754  return 1;
755 #endif
756  if (sti->avctx->has_b_frames < 3)
757  return sti->nb_decoded_frames >= 7;
758  else if (sti->avctx->has_b_frames < 4)
759  return sti->nb_decoded_frames >= 18;
760  else
761  return sti->nb_decoded_frames >= 20;
762 }
763 
765  PacketListEntry *pktl)
766 {
767  FFFormatContext *const si = ffformatcontext(s);
768  if (pktl->next)
769  return pktl->next;
770  if (pktl == si->packet_buffer.tail)
771  return si->parse_queue.head;
772  return NULL;
773 }
774 
775 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts)
776 {
777  FFStream *const sti = ffstream(st);
778  int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
781 
782  if (!onein_oneout) {
783  int delay = sti->avctx->has_b_frames;
784 
785  if (dts == AV_NOPTS_VALUE) {
786  int64_t best_score = INT64_MAX;
787  for (int i = 0; i < delay; i++) {
788  if (sti->pts_reorder_error_count[i]) {
789  int64_t score = sti->pts_reorder_error[i] / sti->pts_reorder_error_count[i];
790  if (score < best_score) {
791  best_score = score;
792  dts = pts_buffer[i];
793  }
794  }
795  }
796  } else {
797  for (int i = 0; i < delay; i++) {
798  if (pts_buffer[i] != AV_NOPTS_VALUE) {
799  int64_t diff = FFABS(pts_buffer[i] - dts)
800  + (uint64_t)sti->pts_reorder_error[i];
801  diff = FFMAX(diff, sti->pts_reorder_error[i]);
802  sti->pts_reorder_error[i] = diff;
803  sti->pts_reorder_error_count[i]++;
804  if (sti->pts_reorder_error_count[i] > 250) {
805  sti->pts_reorder_error[i] >>= 1;
806  sti->pts_reorder_error_count[i] >>= 1;
807  }
808  }
809  }
810  }
811  }
812 
813  if (dts == AV_NOPTS_VALUE)
814  dts = pts_buffer[0];
815 
816  return dts;
817 }
818 
819 /**
820  * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
821  * of the packets in a window.
822  */
823 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
824  PacketListEntry *pkt_buffer)
825 {
826  AVStream *const st = s->streams[stream_index];
827  int delay = ffstream(st)->avctx->has_b_frames;
828 
829  int64_t pts_buffer[MAX_REORDER_DELAY+1];
830 
831  for (int i = 0; i < MAX_REORDER_DELAY + 1; i++)
832  pts_buffer[i] = AV_NOPTS_VALUE;
833 
834  for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
835  if (pkt_buffer->pkt.stream_index != stream_index)
836  continue;
837 
838  if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
839  pts_buffer[0] = pkt_buffer->pkt.pts;
840  for (int i = 0; i < delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
841  FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
842 
843  pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
844  }
845  }
846 }
847 
848 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
849  int64_t dts, int64_t pts, AVPacket *pkt)
850 {
851  FFFormatContext *const si = ffformatcontext(s);
852  AVStream *const st = s->streams[stream_index];
853  FFStream *const sti = ffstream(st);
855 
856  uint64_t shift;
857 
858  if (sti->first_dts != AV_NOPTS_VALUE ||
859  dts == AV_NOPTS_VALUE ||
860  sti->cur_dts == AV_NOPTS_VALUE ||
861  sti->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
862  dts < INT_MIN + (sti->cur_dts - RELATIVE_TS_BASE) ||
863  is_relative(dts))
864  return;
865 
866  sti->first_dts = dts - (sti->cur_dts - RELATIVE_TS_BASE);
867  sti->cur_dts = dts;
868  shift = (uint64_t)sti->first_dts - RELATIVE_TS_BASE;
869 
870  if (is_relative(pts))
871  pts += shift;
872 
873  for (PacketListEntry *pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
874  if (pktl_it->pkt.stream_index != stream_index)
875  continue;
876  if (is_relative(pktl_it->pkt.pts))
877  pktl_it->pkt.pts += shift;
878 
879  if (is_relative(pktl_it->pkt.dts))
880  pktl_it->pkt.dts += shift;
881 
882  if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
883  st->start_time = pktl_it->pkt.pts;
885  st->start_time = av_sat_add64(st->start_time, av_rescale_q(sti->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
886  }
887  }
888 
890  update_dts_from_pts(s, stream_index, pktl);
891 
892  if (st->start_time == AV_NOPTS_VALUE) {
894  st->start_time = pts;
895  }
897  st->start_time = av_sat_add64(st->start_time, av_rescale_q(sti->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
898  }
899 }
900 
902  int stream_index, int64_t duration)
903 {
904  FFFormatContext *const si = ffformatcontext(s);
905  FFStream *const sti = ffstream(st);
907  int64_t cur_dts = RELATIVE_TS_BASE;
908 
909  if (sti->first_dts != AV_NOPTS_VALUE) {
911  return;
913  cur_dts = sti->first_dts;
914  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
915  if (pktl->pkt.stream_index == stream_index) {
916  if (pktl->pkt.pts != pktl->pkt.dts ||
917  pktl->pkt.dts != AV_NOPTS_VALUE ||
918  pktl->pkt.duration)
919  break;
920  cur_dts -= duration;
921  }
922  }
923  if (pktl && pktl->pkt.dts != sti->first_dts) {
924  av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
925  av_ts2str(sti->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
926  return;
927  }
928  if (!pktl) {
929  av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(sti->first_dts));
930  return;
931  }
932  pktl = si->packet_buffer.head ? si->packet_buffer.head : si->parse_queue.head;
933  sti->first_dts = cur_dts;
934  } else if (sti->cur_dts != RELATIVE_TS_BASE)
935  return;
936 
937  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
938  if (pktl->pkt.stream_index != stream_index)
939  continue;
940  if ((pktl->pkt.pts == pktl->pkt.dts ||
941  pktl->pkt.pts == AV_NOPTS_VALUE) &&
942  (pktl->pkt.dts == AV_NOPTS_VALUE ||
943  pktl->pkt.dts == sti->first_dts ||
944  pktl->pkt.dts == RELATIVE_TS_BASE) &&
945  !pktl->pkt.duration &&
946  av_sat_add64(cur_dts, duration) == cur_dts + (uint64_t)duration
947  ) {
948  pktl->pkt.dts = cur_dts;
949  if (!sti->avctx->has_b_frames)
950  pktl->pkt.pts = cur_dts;
951  pktl->pkt.duration = duration;
952  } else
953  break;
954  cur_dts = pktl->pkt.dts + pktl->pkt.duration;
955  }
956  if (!pktl)
957  sti->cur_dts = cur_dts;
958 }
959 
962  int64_t next_dts, int64_t next_pts)
963 {
964  FFFormatContext *const si = ffformatcontext(s);
965  FFStream *const sti = ffstream(st);
966  int num, den, presentation_delayed, delay;
967  int64_t offset;
969  int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
972 
973  if (s->flags & AVFMT_FLAG_NOFILLIN)
974  return;
975 
977  if (pkt->dts == pkt->pts && sti->last_dts_for_order_check != AV_NOPTS_VALUE) {
978  if (sti->last_dts_for_order_check <= pkt->dts) {
979  sti->dts_ordered++;
980  } else {
982  "DTS %"PRIi64" < %"PRIi64" out of order\n",
983  pkt->dts,
985  sti->dts_misordered++;
986  }
987  if (sti->dts_ordered + sti->dts_misordered > 250) {
988  sti->dts_ordered >>= 1;
989  sti->dts_misordered >>= 1;
990  }
991  }
992 
994  if (sti->dts_ordered < 8 * sti->dts_misordered && pkt->dts == pkt->pts)
996  }
997 
998  if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1000 
1001  if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1002  && !sti->avctx->has_b_frames)
1003  //FIXME Set low_delay = 0 when has_b_frames = 1
1004  sti->avctx->has_b_frames = 1;
1005 
1006  /* do we have a video B-frame ? */
1007  delay = sti->avctx->has_b_frames;
1008  presentation_delayed = 0;
1009 
1010  /* XXX: need has_b_frame, but cannot get it if the codec is
1011  * not initialized */
1012  if (delay &&
1013  pc && pc->pict_type != AV_PICTURE_TYPE_B)
1014  presentation_delayed = 1;
1015 
1016  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1017  st->pts_wrap_bits < 63 && pkt->dts > INT64_MIN + (1LL << st->pts_wrap_bits) &&
1018  pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1019  if (is_relative(sti->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > sti->cur_dts) {
1020  pkt->dts -= 1LL << st->pts_wrap_bits;
1021  } else
1022  pkt->pts += 1LL << st->pts_wrap_bits;
1023  }
1024 
1025  /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1026  * We take the conservative approach and discard both.
1027  * Note: If this is misbehaving for an H.264 file, then possibly
1028  * presentation_delayed is not set correctly. */
1029  if (delay == 1 && pkt->dts == pkt->pts &&
1030  pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1031  av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1032  if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1033  && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1034  pkt->dts = AV_NOPTS_VALUE;
1035  }
1036 
1038  if (pkt->duration <= 0) {
1039  compute_frame_duration(s, &num, &den, st, pc, pkt);
1040  if (den && num) {
1041  duration = (AVRational) {num, den};
1043  num * (int64_t) st->time_base.den,
1044  den * (int64_t) st->time_base.num,
1045  AV_ROUND_DOWN);
1046  }
1047  }
1048 
1049  if (pkt->duration > 0 && (si->packet_buffer.head || si->parse_queue.head))
1051 
1052  /* Correct timestamps with byte offset if demuxers only have timestamps
1053  * on packet boundaries */
1054  if (pc && sti->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1055  /* this will estimate bitrate based on this frame's duration and size */
1057  if (pkt->pts != AV_NOPTS_VALUE)
1058  pkt->pts += offset;
1059  if (pkt->dts != AV_NOPTS_VALUE)
1060  pkt->dts += offset;
1061  }
1062 
1063  /* This may be redundant, but it should not hurt. */
1064  if (pkt->dts != AV_NOPTS_VALUE &&
1065  pkt->pts != AV_NOPTS_VALUE &&
1066  pkt->pts > pkt->dts)
1067  presentation_delayed = 1;
1068 
1069  if (s->debug & FF_FDEBUG_TS)
1071  "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1072  presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(sti->cur_dts),
1073  pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1074 
1075  /* Interpolate PTS and DTS if they are not present. We skip H264
1076  * currently because delay and has_b_frames are not reliably set. */
1077  if ((delay == 0 || (delay == 1 && pc)) &&
1078  onein_oneout) {
1079  if (presentation_delayed) {
1080  /* DTS = decompression timestamp */
1081  /* PTS = presentation timestamp */
1082  if (pkt->dts == AV_NOPTS_VALUE)
1083  pkt->dts = sti->last_IP_pts;
1085  if (pkt->dts == AV_NOPTS_VALUE)
1086  pkt->dts = sti->cur_dts;
1087 
1088  /* This is tricky: the dts must be incremented by the duration
1089  * of the frame we are displaying, i.e. the last I- or P-frame. */
1090  if (sti->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1091  sti->last_IP_duration = pkt->duration;
1092  if (pkt->dts != AV_NOPTS_VALUE)
1093  sti->cur_dts = av_sat_add64(pkt->dts, sti->last_IP_duration);
1094  if (pkt->dts != AV_NOPTS_VALUE &&
1095  pkt->pts == AV_NOPTS_VALUE &&
1096  sti->last_IP_duration > 0 &&
1097  ((uint64_t)sti->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1098  next_dts != next_pts &&
1099  next_pts != AV_NOPTS_VALUE)
1100  pkt->pts = next_dts;
1101 
1102  if ((uint64_t)pkt->duration <= INT32_MAX)
1103  sti->last_IP_duration = pkt->duration;
1104  sti->last_IP_pts = pkt->pts;
1105  /* Cannot compute PTS if not present (we can compute it only
1106  * by knowing the future. */
1107  } else if (pkt->pts != AV_NOPTS_VALUE ||
1108  pkt->dts != AV_NOPTS_VALUE ||
1109  pkt->duration > 0 ) {
1110 
1111  /* presentation is not delayed : PTS and DTS are the same */
1112  if (pkt->pts == AV_NOPTS_VALUE)
1113  pkt->pts = pkt->dts;
1115  pkt->pts, pkt);
1116  if (pkt->pts == AV_NOPTS_VALUE)
1117  pkt->pts = sti->cur_dts;
1118  pkt->dts = pkt->pts;
1119  if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1120  sti->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1121  }
1122  }
1123 
1124  if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1125  sti->pts_buffer[0] = pkt->pts;
1126  for (int i = 0; i < delay && sti->pts_buffer[i] > sti->pts_buffer[i + 1]; i++)
1127  FFSWAP(int64_t, sti->pts_buffer[i], sti->pts_buffer[i + 1]);
1128 
1131  }
1132  // We skipped it above so we try here.
1133  if (!onein_oneout)
1134  // This should happen on the first packet
1136  if (pkt->dts > sti->cur_dts)
1137  sti->cur_dts = pkt->dts;
1138 
1139  if (s->debug & FF_FDEBUG_TS)
1140  av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1141  presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(sti->cur_dts), st->index, st->id);
1142 
1143  /* update flags */
1146 }
1147 
1148 /**
1149  * Parse a packet, add all split parts to parse_queue.
1150  *
1151  * @param pkt Packet to parse; must not be NULL.
1152  * @param flush Indicates whether to flush. If set, pkt must be blank.
1153  */
1155  int stream_index, int flush)
1156 {
1157  FFFormatContext *const si = ffformatcontext(s);
1158  AVPacket *out_pkt = si->parse_pkt;
1159  AVStream *st = s->streams[stream_index];
1160  FFStream *const sti = ffstream(st);
1161  const uint8_t *data = pkt->data;
1162  int size = pkt->size;
1163  int ret = 0, got_output = flush;
1164 
1165  if (!size && !flush && sti->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1166  // preserve 0-size sync packets
1168  }
1169 
1170  while (size > 0 || (flush && got_output)) {
1171  int64_t next_pts = pkt->pts;
1172  int64_t next_dts = pkt->dts;
1173  int len;
1174 
1175  len = av_parser_parse2(sti->parser, sti->avctx,
1176  &out_pkt->data, &out_pkt->size, data, size,
1177  pkt->pts, pkt->dts, pkt->pos);
1178 
1179  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1180  pkt->pos = -1;
1181  /* increment read pointer */
1182  av_assert1(data || !len);
1183  data = len ? data + len : data;
1184  size -= len;
1185 
1186  got_output = !!out_pkt->size;
1187 
1188  if (!out_pkt->size)
1189  continue;
1190 
1191  if (pkt->buf && out_pkt->data == pkt->data) {
1192  /* reference pkt->buf only when out_pkt->data is guaranteed to point
1193  * to data in it and not in the parser's internal buffer. */
1194  /* XXX: Ensure this is the case with all parsers when sti->parser->flags
1195  * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1196  out_pkt->buf = av_buffer_ref(pkt->buf);
1197  if (!out_pkt->buf) {
1198  ret = AVERROR(ENOMEM);
1199  goto fail;
1200  }
1201  } else {
1202  ret = av_packet_make_refcounted(out_pkt);
1203  if (ret < 0)
1204  goto fail;
1205  }
1206 
1207  if (pkt->side_data) {
1208  out_pkt->side_data = pkt->side_data;
1209  out_pkt->side_data_elems = pkt->side_data_elems;
1210  pkt->side_data = NULL;
1211  pkt->side_data_elems = 0;
1212  }
1213 
1214  /* set the duration */
1215  out_pkt->duration = (sti->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1217  if (sti->avctx->sample_rate > 0) {
1218  out_pkt->duration =
1220  (AVRational) { 1, sti->avctx->sample_rate },
1221  st->time_base,
1222  AV_ROUND_DOWN);
1223  }
1224  } else if (st->codecpar->codec_id == AV_CODEC_ID_GIF) {
1225  if (st->time_base.num > 0 && st->time_base.den > 0 &&
1226  sti->parser->duration) {
1227  out_pkt->duration = sti->parser->duration;
1228  }
1229  }
1230 
1231  out_pkt->stream_index = st->index;
1232  out_pkt->pts = sti->parser->pts;
1233  out_pkt->dts = sti->parser->dts;
1234  out_pkt->pos = sti->parser->pos;
1236 
1238  out_pkt->pos = sti->parser->frame_offset;
1239 
1240  if (sti->parser->key_frame == 1 ||
1241  (sti->parser->key_frame == -1 &&
1243  out_pkt->flags |= AV_PKT_FLAG_KEY;
1244 
1246  out_pkt->flags |= AV_PKT_FLAG_KEY;
1247 
1248  compute_pkt_fields(s, st, sti->parser, out_pkt, next_dts, next_pts);
1249 
1251  out_pkt, NULL, 0);
1252  if (ret < 0)
1253  goto fail;
1254  }
1255 
1256  /* end of the stream => close and free the parser */
1257  if (flush) {
1258  av_parser_close(sti->parser);
1259  sti->parser = NULL;
1260  }
1261 
1262 fail:
1263  if (ret < 0)
1264  av_packet_unref(out_pkt);
1266  return ret;
1267 }
1268 
1269 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1270 {
1271  return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1272 }
1273 
1274 static int codec_close(FFStream *sti)
1275 {
1276  AVCodecContext *avctx_new = NULL;
1277  AVCodecParameters *par_tmp = NULL;
1278  int ret;
1279 
1280  avctx_new = avcodec_alloc_context3(sti->avctx->codec);
1281  if (!avctx_new) {
1282  ret = AVERROR(ENOMEM);
1283  goto fail;
1284  }
1285 
1286  par_tmp = avcodec_parameters_alloc();
1287  if (!par_tmp) {
1288  ret = AVERROR(ENOMEM);
1289  goto fail;
1290  }
1291 
1292  ret = avcodec_parameters_from_context(par_tmp, sti->avctx);
1293  if (ret < 0)
1294  goto fail;
1295 
1296  ret = avcodec_parameters_to_context(avctx_new, par_tmp);
1297  if (ret < 0)
1298  goto fail;
1299 
1300  avctx_new->pkt_timebase = sti->avctx->pkt_timebase;
1301 
1302 #if FF_API_TICKS_PER_FRAME
1304  avctx_new->ticks_per_frame = sti->avctx->ticks_per_frame;
1306 #endif
1307 
1308  avcodec_free_context(&sti->avctx);
1309  sti->avctx = avctx_new;
1310 
1311  avctx_new = NULL;
1312  ret = 0;
1313 
1314 fail:
1315  avcodec_free_context(&avctx_new);
1316  avcodec_parameters_free(&par_tmp);
1317 
1318  return ret;
1319 }
1320 
1322 {
1323  FFFormatContext *const si = ffformatcontext(s);
1324  int ret, got_packet = 0;
1325  AVDictionary *metadata = NULL;
1326 
1327  while (!got_packet && !si->parse_queue.head) {
1328  AVStream *st;
1329  FFStream *sti;
1330 
1331  /* read next packet */
1332  ret = ff_read_packet(s, pkt);
1333  if (ret < 0) {
1334  if (ret == AVERROR(EAGAIN))
1335  return ret;
1336  /* flush the parsers */
1337  for (unsigned i = 0; i < s->nb_streams; i++) {
1338  AVStream *const st = s->streams[i];
1339  FFStream *const sti = ffstream(st);
1340  if (sti->parser && sti->need_parsing)
1341  parse_packet(s, pkt, st->index, 1);
1342  }
1343  /* all remaining packets are now in parse_queue =>
1344  * really terminate parsing */
1345  break;
1346  }
1347  ret = 0;
1348  st = s->streams[pkt->stream_index];
1349  sti = ffstream(st);
1350 
1352 
1353  /* update context if required */
1354  if (sti->need_context_update) {
1355  if (avcodec_is_open(sti->avctx)) {
1356  av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1357  ret = codec_close(sti);
1358  sti->info->found_decoder = 0;
1359  if (ret < 0)
1360  return ret;
1361  }
1362 
1363  /* close parser, because it depends on the codec */
1364  if (sti->parser && sti->avctx->codec_id != st->codecpar->codec_id) {
1365  av_parser_close(sti->parser);
1366  sti->parser = NULL;
1367  }
1368 
1370  if (ret < 0) {
1372  return ret;
1373  }
1374 
1376 
1377  sti->need_context_update = 0;
1378  }
1379 
1380  if (pkt->pts != AV_NOPTS_VALUE &&
1381  pkt->dts != AV_NOPTS_VALUE &&
1382  pkt->pts < pkt->dts) {
1384  "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1385  pkt->stream_index,
1386  av_ts2str(pkt->pts),
1387  av_ts2str(pkt->dts),
1388  pkt->size);
1389  }
1390  if (s->debug & FF_FDEBUG_TS)
1392  "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1393  pkt->stream_index,
1394  av_ts2str(pkt->pts),
1395  av_ts2str(pkt->dts),
1396  pkt->size, pkt->duration, pkt->flags);
1397 
1398  if (sti->need_parsing && !sti->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1399  sti->parser = av_parser_init(st->codecpar->codec_id);
1400  if (!sti->parser) {
1401  av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1402  "%s, packets or times may be invalid.\n",
1404  /* no parser available: just output the raw packets */
1406  } else if (sti->need_parsing == AVSTREAM_PARSE_HEADERS)
1408  else if (sti->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1409  sti->parser->flags |= PARSER_FLAG_ONCE;
1410  else if (sti->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1412  }
1413 
1414  if (!sti->need_parsing || !sti->parser) {
1415  /* no parsing needed: we just output the packet as is */
1417  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1419  ff_reduce_index(s, st->index);
1420  av_add_index_entry(st, pkt->pos, pkt->dts,
1421  0, 0, AVINDEX_KEYFRAME);
1422  }
1423  got_packet = 1;
1424  } else if (st->discard < AVDISCARD_ALL) {
1425  if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1426  return ret;
1427  st->codecpar->sample_rate = sti->avctx->sample_rate;
1428  st->codecpar->bit_rate = sti->avctx->bit_rate;
1430  if (ret < 0)
1431  return ret;
1432  st->codecpar->codec_id = sti->avctx->codec_id;
1433  } else {
1434  /* free packet */
1436  }
1437  if (pkt->flags & AV_PKT_FLAG_KEY)
1438  sti->skip_to_keyframe = 0;
1439  if (sti->skip_to_keyframe) {
1441  got_packet = 0;
1442  }
1443  }
1444 
1445  if (!got_packet && si->parse_queue.head)
1447 
1448  if (ret >= 0) {
1449  AVStream *const st = s->streams[pkt->stream_index];
1450  FFStream *const sti = ffstream(st);
1451  int discard_padding = 0;
1452  if (sti->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1453  int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1454  int64_t sample = ts_to_samples(st, pts);
1455  int64_t duration = ts_to_samples(st, pkt->duration);
1456  int64_t end_sample = sample + duration;
1457  if (duration > 0 && end_sample >= sti->first_discard_sample &&
1458  sample < sti->last_discard_sample)
1459  discard_padding = FFMIN(end_sample - sti->first_discard_sample, duration);
1460  }
1461  if (sti->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1462  sti->skip_samples = sti->start_skip_samples;
1463  sti->skip_samples = FFMAX(0, sti->skip_samples);
1464  if (sti->skip_samples || discard_padding) {
1466  if (p) {
1467  AV_WL32(p, sti->skip_samples);
1468  AV_WL32(p + 4, discard_padding);
1469  av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %u / discard %u\n",
1470  (unsigned)sti->skip_samples, (unsigned)discard_padding);
1471  }
1472  sti->skip_samples = 0;
1473  }
1474 
1475 #if FF_API_AVSTREAM_SIDE_DATA
1476  if (sti->inject_global_side_data) {
1477  for (int i = 0; i < st->codecpar->nb_coded_side_data; i++) {
1478  const AVPacketSideData *const src_sd = &st->codecpar->coded_side_data[i];
1479  uint8_t *dst_data;
1480 
1481  if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1482  continue;
1483 
1484  dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1485  if (!dst_data) {
1486  av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1487  continue;
1488  }
1489 
1490  memcpy(dst_data, src_sd->data, src_sd->size);
1491  }
1492  sti->inject_global_side_data = 0;
1493  }
1494 #endif
1495  }
1496 
1497  if (!si->metafree) {
1498  int metaret = av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1499  if (metadata) {
1500  s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1501  av_dict_copy(&s->metadata, metadata, 0);
1502  av_dict_free(&metadata);
1504  }
1505  si->metafree = metaret == AVERROR_OPTION_NOT_FOUND;
1506  }
1507 
1508  if (s->debug & FF_FDEBUG_TS)
1510  "read_frame_internal stream=%d, pts=%s, dts=%s, "
1511  "size=%d, duration=%"PRId64", flags=%d\n",
1512  pkt->stream_index,
1513  av_ts2str(pkt->pts),
1514  av_ts2str(pkt->dts),
1515  pkt->size, pkt->duration, pkt->flags);
1516 
1517  /* A demuxer might have returned EOF because of an IO error, let's
1518  * propagate this back to the user. */
1519  if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1520  ret = s->pb->error;
1521 
1522  return ret;
1523 }
1524 
1526 {
1527  FFFormatContext *const si = ffformatcontext(s);
1528  const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1529  int eof = 0;
1530  int ret;
1531  AVStream *st;
1532 
1533  if (!genpts) {
1534  ret = si->packet_buffer.head
1537  if (ret < 0)
1538  return ret;
1539  goto return_packet;
1540  }
1541 
1542  for (;;) {
1543  PacketListEntry *pktl = si->packet_buffer.head;
1544 
1545  if (pktl) {
1546  AVPacket *next_pkt = &pktl->pkt;
1547 
1548  if (next_pkt->dts != AV_NOPTS_VALUE) {
1549  int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1550  // last dts seen for this stream. if any of packets following
1551  // current one had no dts, we will set this to AV_NOPTS_VALUE.
1552  int64_t last_dts = next_pkt->dts;
1553  av_assert2(wrap_bits <= 64);
1554  while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1555  if (pktl->pkt.stream_index == next_pkt->stream_index &&
1556  av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1557  if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1558  // not B-frame
1559  next_pkt->pts = pktl->pkt.dts;
1560  }
1561  if (last_dts != AV_NOPTS_VALUE) {
1562  // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1563  last_dts = pktl->pkt.dts;
1564  }
1565  }
1566  pktl = pktl->next;
1567  }
1568  if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1569  // Fixing the last reference frame had none pts issue (For MXF etc).
1570  // We only do this when
1571  // 1. eof.
1572  // 2. we are not able to resolve a pts value for current packet.
1573  // 3. the packets for this stream at the end of the files had valid dts.
1574  next_pkt->pts = last_dts + next_pkt->duration;
1575  }
1576  pktl = si->packet_buffer.head;
1577  }
1578 
1579  /* read packet from packet buffer, if there is data */
1580  st = s->streams[next_pkt->stream_index];
1581  if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1582  next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1584  goto return_packet;
1585  }
1586  }
1587 
1589  if (ret < 0) {
1590  if (pktl && ret != AVERROR(EAGAIN)) {
1591  eof = 1;
1592  continue;
1593  } else
1594  return ret;
1595  }
1596 
1598  pkt, NULL, 0);
1599  if (ret < 0) {
1601  return ret;
1602  }
1603  }
1604 
1605 return_packet:
1606  st = s->streams[pkt->stream_index];
1607  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1608  ff_reduce_index(s, st->index);
1610  }
1611 
1612  if (is_relative(pkt->dts))
1613  pkt->dts -= RELATIVE_TS_BASE;
1614  if (is_relative(pkt->pts))
1615  pkt->pts -= RELATIVE_TS_BASE;
1616 
1617  return ret;
1618 }
1619 
1620 /**
1621  * Return TRUE if the stream has accurate duration in any stream.
1622  *
1623  * @return TRUE if the stream has accurate duration for at least one component.
1624  */
1626 {
1627  for (unsigned i = 0; i < ic->nb_streams; i++) {
1628  const AVStream *const st = ic->streams[i];
1629  if (st->duration != AV_NOPTS_VALUE)
1630  return 1;
1631  }
1632  if (ic->duration != AV_NOPTS_VALUE)
1633  return 1;
1634  return 0;
1635 }
1636 
1637 /**
1638  * Estimate the stream timings from the one of each components.
1639  *
1640  * Also computes the global bitrate if possible.
1641  */
1643 {
1644  int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
1645  int64_t duration, duration1, duration_text, filesize;
1646 
1647  start_time = INT64_MAX;
1648  start_time_text = INT64_MAX;
1649  end_time = INT64_MIN;
1650  end_time_text = INT64_MIN;
1651  duration = INT64_MIN;
1652  duration_text = INT64_MIN;
1653 
1654  for (unsigned i = 0; i < ic->nb_streams; i++) {
1655  AVStream *const st = ic->streams[i];
1656  int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
1658 
1659  if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1660  start_time1 = av_rescale_q(st->start_time, st->time_base,
1661  AV_TIME_BASE_Q);
1662  if (is_text)
1663  start_time_text = FFMIN(start_time_text, start_time1);
1664  else
1665  start_time = FFMIN(start_time, start_time1);
1666  end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
1669  if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
1670  end_time1 += start_time1;
1671  if (is_text)
1672  end_time_text = FFMAX(end_time_text, end_time1);
1673  else
1674  end_time = FFMAX(end_time, end_time1);
1675  }
1676  for (AVProgram *p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
1677  if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
1678  p->start_time = start_time1;
1679  if (p->end_time < end_time1)
1680  p->end_time = end_time1;
1681  }
1682  }
1683  if (st->duration != AV_NOPTS_VALUE) {
1684  duration1 = av_rescale_q(st->duration, st->time_base,
1685  AV_TIME_BASE_Q);
1686  if (is_text)
1687  duration_text = FFMAX(duration_text, duration1);
1688  else
1689  duration = FFMAX(duration, duration1);
1690  }
1691  }
1692  if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
1693  start_time = start_time_text;
1694  else if (start_time > start_time_text)
1695  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
1696 
1697  if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
1698  end_time = end_time_text;
1699  else if (end_time < end_time_text)
1700  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
1701 
1702  if (duration == INT64_MIN || (duration < duration_text && (uint64_t)duration_text - duration < AV_TIME_BASE))
1703  duration = duration_text;
1704  else if (duration < duration_text)
1705  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
1706 
1707  if (start_time != INT64_MAX) {
1708  ic->start_time = start_time;
1709  if (end_time != INT64_MIN) {
1710  if (ic->nb_programs > 1) {
1711  for (unsigned i = 0; i < ic->nb_programs; i++) {
1712  AVProgram *const p = ic->programs[i];
1713 
1714  if (p->start_time != AV_NOPTS_VALUE &&
1715  p->end_time > p->start_time &&
1716  p->end_time - (uint64_t)p->start_time <= INT64_MAX)
1718  }
1719  } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
1720  duration = FFMAX(duration, end_time - start_time);
1721  }
1722  }
1723  }
1724  if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
1725  ic->duration = duration;
1726  }
1727  if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
1728  /* compute the bitrate */
1729  double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
1730  (double) ic->duration;
1731  if (bitrate >= 0 && bitrate <= INT64_MAX)
1732  ic->bit_rate = bitrate;
1733  }
1734 }
1735 
1737 {
1739  for (unsigned i = 0; i < ic->nb_streams; i++) {
1740  AVStream *const st = ic->streams[i];
1741 
1742  if (st->start_time == AV_NOPTS_VALUE) {
1743  if (ic->start_time != AV_NOPTS_VALUE)
1745  st->time_base);
1746  if (ic->duration != AV_NOPTS_VALUE)
1748  st->time_base);
1749  }
1750  }
1751 }
1752 
1754 {
1755  FFFormatContext *const si = ffformatcontext(ic);
1756  int show_warning = 0;
1757 
1758  /* if bit_rate is already set, we believe it */
1759  if (ic->bit_rate <= 0) {
1760  int64_t bit_rate = 0;
1761  for (unsigned i = 0; i < ic->nb_streams; i++) {
1762  const AVStream *const st = ic->streams[i];
1763  const FFStream *const sti = cffstream(st);
1764  if (st->codecpar->bit_rate <= 0 && sti->avctx->bit_rate > 0)
1765  st->codecpar->bit_rate = sti->avctx->bit_rate;
1766  if (st->codecpar->bit_rate > 0) {
1767  if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
1768  bit_rate = 0;
1769  break;
1770  }
1771  bit_rate += st->codecpar->bit_rate;
1772  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && sti->codec_info_nb_frames > 1) {
1773  // If we have a videostream with packets but without a bitrate
1774  // then consider the sum not known
1775  bit_rate = 0;
1776  break;
1777  }
1778  }
1779  ic->bit_rate = bit_rate;
1780  }
1781 
1782  /* if duration is already set, we believe it */
1783  if (ic->duration == AV_NOPTS_VALUE &&
1784  ic->bit_rate != 0) {
1785  int64_t filesize = ic->pb ? avio_size(ic->pb) : 0;
1786  if (filesize > si->data_offset) {
1787  filesize -= si->data_offset;
1788  for (unsigned i = 0; i < ic->nb_streams; i++) {
1789  AVStream *const st = ic->streams[i];
1790 
1791  if ( st->time_base.num <= INT64_MAX / ic->bit_rate
1792  && st->duration == AV_NOPTS_VALUE) {
1793  st->duration = av_rescale(filesize, 8LL * st->time_base.den,
1794  ic->bit_rate *
1795  (int64_t) st->time_base.num);
1796  show_warning = 1;
1797  }
1798  }
1799  }
1800  }
1801  if (show_warning)
1802  av_log(ic, AV_LOG_WARNING,
1803  "Estimating duration from bitrate, this may be inaccurate\n");
1804 }
1805 
1806 #define DURATION_MAX_READ_SIZE 250000LL
1807 #define DURATION_MAX_RETRY 6
1808 
1809 /* only usable for MPEG-PS streams */
1810 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1811 {
1812  FFFormatContext *const si = ffformatcontext(ic);
1813  AVPacket *const pkt = si->pkt;
1814  int num, den, read_size, ret;
1815  int found_duration = 0;
1816  int is_end;
1817  int64_t filesize, offset, duration;
1818  int retry = 0;
1819 
1820  /* flush packet queue */
1822 
1823  for (unsigned i = 0; i < ic->nb_streams; i++) {
1824  AVStream *const st = ic->streams[i];
1825  FFStream *const sti = ffstream(st);
1826 
1827  if (st->start_time == AV_NOPTS_VALUE &&
1828  sti->first_dts == AV_NOPTS_VALUE &&
1830  av_log(ic, AV_LOG_WARNING,
1831  "start time for stream %d is not set in estimate_timings_from_pts\n", i);
1832 
1833  if (sti->parser) {
1834  av_parser_close(sti->parser);
1835  sti->parser = NULL;
1836  }
1837  }
1838 
1840  av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
1841  goto skip_duration_calc;
1842  }
1843 
1844  av_opt_set_int(ic, "skip_changes", 1, AV_OPT_SEARCH_CHILDREN);
1845  /* estimate the end time (duration) */
1846  /* XXX: may need to support wrapping */
1847  filesize = ic->pb ? avio_size(ic->pb) : 0;
1848  do {
1849  is_end = found_duration;
1850  offset = filesize - (DURATION_MAX_READ_SIZE << retry);
1851  if (offset < 0)
1852  offset = 0;
1853 
1854  avio_seek(ic->pb, offset, SEEK_SET);
1855  read_size = 0;
1856  for (;;) {
1857  AVStream *st;
1858  FFStream *sti;
1859  if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
1860  break;
1861 
1862  do {
1863  ret = ff_read_packet(ic, pkt);
1864  } while (ret == AVERROR(EAGAIN));
1865  if (ret != 0)
1866  break;
1867  read_size += pkt->size;
1868  st = ic->streams[pkt->stream_index];
1869  sti = ffstream(st);
1870  if (pkt->pts != AV_NOPTS_VALUE &&
1871  (st->start_time != AV_NOPTS_VALUE ||
1872  sti->first_dts != AV_NOPTS_VALUE)) {
1873  if (pkt->duration == 0) {
1874  compute_frame_duration(ic, &num, &den, st, sti->parser, pkt);
1875  if (den && num) {
1877  num * (int64_t) st->time_base.den,
1878  den * (int64_t) st->time_base.num,
1879  AV_ROUND_DOWN);
1880  }
1881  }
1882  duration = pkt->pts + pkt->duration;
1883  found_duration = 1;
1884  if (st->start_time != AV_NOPTS_VALUE)
1885  duration -= st->start_time;
1886  else
1887  duration -= sti->first_dts;
1888  if (duration > 0) {
1889  if (st->duration == AV_NOPTS_VALUE || sti->info->last_duration<= 0 ||
1890  (st->duration < duration && FFABS(duration - sti->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
1891  st->duration = duration;
1892  sti->info->last_duration = duration;
1893  }
1894  }
1896  }
1897 
1898  /* check if all audio/video streams have valid duration */
1899  if (!is_end) {
1900  is_end = 1;
1901  for (unsigned i = 0; i < ic->nb_streams; i++) {
1902  const AVStream *const st = ic->streams[i];
1903  switch (st->codecpar->codec_type) {
1904  case AVMEDIA_TYPE_VIDEO:
1905  case AVMEDIA_TYPE_AUDIO:
1906  if (st->duration == AV_NOPTS_VALUE)
1907  is_end = 0;
1908  }
1909  }
1910  }
1911  } while (!is_end &&
1912  offset &&
1913  ++retry <= DURATION_MAX_RETRY);
1914 
1915  av_opt_set_int(ic, "skip_changes", 0, AV_OPT_SEARCH_CHILDREN);
1916 
1917  /* warn about audio/video streams which duration could not be estimated */
1918  for (unsigned i = 0; i < ic->nb_streams; i++) {
1919  const AVStream *const st = ic->streams[i];
1920  const FFStream *const sti = cffstream(st);
1921 
1922  if (st->duration == AV_NOPTS_VALUE) {
1923  switch (st->codecpar->codec_type) {
1924  case AVMEDIA_TYPE_VIDEO:
1925  case AVMEDIA_TYPE_AUDIO:
1926  if (st->start_time != AV_NOPTS_VALUE || sti->first_dts != AV_NOPTS_VALUE) {
1927  av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
1928  } else
1929  av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
1930  }
1931  }
1932  }
1933 skip_duration_calc:
1935 
1936  avio_seek(ic->pb, old_offset, SEEK_SET);
1937  for (unsigned i = 0; i < ic->nb_streams; i++) {
1938  AVStream *const st = ic->streams[i];
1939  FFStream *const sti = ffstream(st);
1940 
1941  sti->cur_dts = sti->first_dts;
1942  sti->last_IP_pts = AV_NOPTS_VALUE;
1944  for (int j = 0; j < MAX_REORDER_DELAY + 1; j++)
1945  sti->pts_buffer[j] = AV_NOPTS_VALUE;
1946  }
1947 }
1948 
1949 /* 1:1 map to AVDurationEstimationMethod */
1950 static const char *const duration_name[] = {
1951  [AVFMT_DURATION_FROM_PTS] = "pts",
1952  [AVFMT_DURATION_FROM_STREAM] = "stream",
1953  [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
1954 };
1955 
1957 {
1958  return duration_name[method];
1959 }
1960 
1961 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
1962 {
1963  int64_t file_size;
1964 
1965  /* get the file size, if possible */
1966  if (ic->iformat->flags & AVFMT_NOFILE) {
1967  file_size = 0;
1968  } else {
1969  file_size = avio_size(ic->pb);
1970  file_size = FFMAX(0, file_size);
1971  }
1972 
1973  if ((!strcmp(ic->iformat->name, "mpeg") ||
1974  !strcmp(ic->iformat->name, "mpegts")) &&
1975  file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
1976  /* get accurate estimate from the PTSes */
1977  estimate_timings_from_pts(ic, old_offset);
1979  } else if (has_duration(ic)) {
1980  /* at least one component has timings - we use them for all
1981  * the components */
1983  /* nut demuxer estimate the duration from PTS */
1984  if (!strcmp(ic->iformat->name, "nut"))
1986  else
1988  } else {
1989  /* less precise: use bitrate info */
1992  }
1994 
1995  for (unsigned i = 0; i < ic->nb_streams; i++) {
1996  AVStream *const st = ic->streams[i];
1997  if (st->time_base.den)
1998  av_log(ic, AV_LOG_TRACE, "stream %u: start_time: %s duration: %s\n", i,
1999  av_ts2timestr(st->start_time, &st->time_base),
2000  av_ts2timestr(st->duration, &st->time_base));
2001  }
2002  av_log(ic, AV_LOG_TRACE,
2003  "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
2007  (int64_t)ic->bit_rate / 1000);
2008 }
2009 
2010 static int determinable_frame_size(const AVCodecContext *avctx)
2011 {
2012  switch(avctx->codec_id) {
2013  case AV_CODEC_ID_MP1:
2014  case AV_CODEC_ID_MP2:
2015  case AV_CODEC_ID_MP3:
2016  case AV_CODEC_ID_CODEC2:
2017  return 1;
2018  }
2019 
2020  return 0;
2021 }
2022 
2023 static int has_codec_parameters(const AVStream *st, const char **errmsg_ptr)
2024 {
2025  const FFStream *const sti = cffstream(st);
2026  const AVCodecContext *const avctx = sti->avctx;
2027 
2028 #define FAIL(errmsg) do { \
2029  if (errmsg_ptr) \
2030  *errmsg_ptr = errmsg; \
2031  return 0; \
2032  } while (0)
2033 
2034  if ( avctx->codec_id == AV_CODEC_ID_NONE
2035  && avctx->codec_type != AVMEDIA_TYPE_DATA)
2036  FAIL("unknown codec");
2037  switch (avctx->codec_type) {
2038  case AVMEDIA_TYPE_AUDIO:
2039  if (!avctx->frame_size && determinable_frame_size(avctx))
2040  FAIL("unspecified frame size");
2041  if (sti->info->found_decoder >= 0 &&
2042  avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2043  FAIL("unspecified sample format");
2044  if (!avctx->sample_rate)
2045  FAIL("unspecified sample rate");
2046  if (!avctx->ch_layout.nb_channels)
2047  FAIL("unspecified number of channels");
2048  if (sti->info->found_decoder >= 0 && !sti->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2049  FAIL("no decodable DTS frames");
2050  break;
2051  case AVMEDIA_TYPE_VIDEO:
2052  if (!avctx->width)
2053  FAIL("unspecified size");
2054  if (sti->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2055  FAIL("unspecified pixel format");
2058  FAIL("no frame in rv30/40 and no sar");
2059  break;
2060  case AVMEDIA_TYPE_SUBTITLE:
2061  if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2062  FAIL("unspecified size");
2063  break;
2064  case AVMEDIA_TYPE_DATA:
2065  if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2066  }
2067 
2068  return 1;
2069 }
2070 
2071 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2073  const AVPacket *pkt, AVDictionary **options)
2074 {
2075  FFStream *const sti = ffstream(st);
2076  AVCodecContext *const avctx = sti->avctx;
2077  const AVCodec *codec;
2078  int got_picture = 1, ret = 0;
2080  AVSubtitle subtitle;
2081  int do_skip_frame = 0;
2082  enum AVDiscard skip_frame;
2083  int pkt_to_send = pkt->size > 0;
2084 
2085  if (!frame)
2086  return AVERROR(ENOMEM);
2087 
2088  if (!avcodec_is_open(avctx) &&
2089  sti->info->found_decoder <= 0 &&
2090  (st->codecpar->codec_id != -sti->info->found_decoder || !st->codecpar->codec_id)) {
2091  AVDictionary *thread_opt = NULL;
2092 
2093  codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2094 
2095  if (!codec) {
2096  sti->info->found_decoder = -st->codecpar->codec_id;
2097  ret = -1;
2098  goto fail;
2099  }
2100 
2101  /* Force thread count to 1 since the H.264 decoder will not extract
2102  * SPS and PPS to extradata during multi-threaded decoding. */
2103  av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2104  /* Force lowres to 0. The decoder might reduce the video size by the
2105  * lowres factor, and we don't want that propagated to the stream's
2106  * codecpar */
2107  av_dict_set(options ? options : &thread_opt, "lowres", "0", 0);
2108  if (s->codec_whitelist)
2109  av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2110  ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2111  if (!options)
2112  av_dict_free(&thread_opt);
2113  if (ret < 0) {
2114  sti->info->found_decoder = -avctx->codec_id;
2115  goto fail;
2116  }
2117  sti->info->found_decoder = 1;
2118  } else if (!sti->info->found_decoder)
2119  sti->info->found_decoder = 1;
2120 
2121  if (sti->info->found_decoder < 0) {
2122  ret = -1;
2123  goto fail;
2124  }
2125 
2127  do_skip_frame = 1;
2128  skip_frame = avctx->skip_frame;
2129  avctx->skip_frame = AVDISCARD_ALL;
2130  }
2131 
2132  while ((pkt_to_send || (!pkt->data && got_picture)) &&
2133  ret >= 0 &&
2135  (!sti->codec_info_nb_frames &&
2137  got_picture = 0;
2138  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
2139  avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2140  ret = avcodec_send_packet(avctx, pkt);
2141  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
2142  break;
2143  if (ret >= 0)
2144  pkt_to_send = 0;
2145  ret = avcodec_receive_frame(avctx, frame);
2146  if (ret >= 0)
2147  got_picture = 1;
2148  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
2149  ret = 0;
2150  } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2151  ret = avcodec_decode_subtitle2(avctx, &subtitle,
2152  &got_picture, pkt);
2153  if (got_picture)
2154  avsubtitle_free(&subtitle);
2155  if (ret >= 0)
2156  pkt_to_send = 0;
2157  }
2158  if (ret >= 0) {
2159  if (got_picture)
2160  sti->nb_decoded_frames++;
2161  ret = got_picture;
2162  }
2163  }
2164 
2165 fail:
2166  if (do_skip_frame) {
2167  avctx->skip_frame = skip_frame;
2168  }
2169 
2170  av_frame_free(&frame);
2171  return ret;
2172 }
2173 
2174 static int chapter_start_cmp(const void *p1, const void *p2)
2175 {
2176  const AVChapter *const ch1 = *(AVChapter**)p1;
2177  const AVChapter *const ch2 = *(AVChapter**)p2;
2178  int delta = av_compare_ts(ch1->start, ch1->time_base, ch2->start, ch2->time_base);
2179  if (delta)
2180  return delta;
2181  return FFDIFFSIGN(ch1->id, ch2->id);
2182 }
2183 
2185 {
2186  int64_t max_time = 0;
2187  AVChapter **timetable;
2188 
2189  if (!s->nb_chapters)
2190  return 0;
2191 
2192  if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
2193  max_time = s->duration +
2194  ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2195 
2196  timetable = av_memdup(s->chapters, s->nb_chapters * sizeof(*timetable));
2197  if (!timetable)
2198  return AVERROR(ENOMEM);
2199  qsort(timetable, s->nb_chapters, sizeof(*timetable), chapter_start_cmp);
2200 
2201  for (unsigned i = 0; i < s->nb_chapters; i++)
2202  if (timetable[i]->end == AV_NOPTS_VALUE) {
2203  AVChapter *const ch = timetable[i];
2204  int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2205  ch->time_base)
2206  : INT64_MAX;
2207 
2208  if (i + 1 < s->nb_chapters) {
2209  const AVChapter *const ch1 = timetable[i + 1];
2210  int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2211  ch->time_base);
2212  if (next_start > ch->start && next_start < end)
2213  end = next_start;
2214  }
2215  ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
2216  }
2217  av_free(timetable);
2218  return 0;
2219 }
2220 
2221 static int get_std_framerate(int i)
2222 {
2223  if (i < 30*12)
2224  return (i + 1) * 1001;
2225  i -= 30*12;
2226 
2227  if (i < 30)
2228  return (i + 31) * 1001 * 12;
2229  i -= 30;
2230 
2231  if (i < 3)
2232  return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
2233 
2234  i -= 3;
2235 
2236  return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2237 }
2238 
2239 /* Is the time base unreliable?
2240  * This is a heuristic to balance between quick acceptance of the values in
2241  * the headers vs. some extra checks.
2242  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2243  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2244  * And there are "variable" fps files this needs to detect as well. */
2246 {
2247  FFStream *const sti = ffstream(st);
2248  const AVCodecDescriptor *desc = sti->codec_desc;
2249  AVCodecContext *c = sti->avctx;
2250  AVRational mul = (AVRational){ desc && (desc->props & AV_CODEC_PROP_FIELDS) ? 2 : 1, 1 };
2251  AVRational time_base = c->framerate.num ? av_inv_q(av_mul_q(c->framerate, mul))
2252  /* NOHEADER check added to not break existing behavior */
2253  : (((ic->ctx_flags & AVFMTCTX_NOHEADER) ||
2255  : st->time_base);
2256 
2257  if (time_base.den >= 101LL * time_base.num ||
2258  time_base.den < 5LL * time_base.num ||
2259  // c->codec_tag == AV_RL32("DIVX") ||
2260  // c->codec_tag == AV_RL32("XVID") ||
2261  c->codec_tag == AV_RL32("mp4v") ||
2262  c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2263  c->codec_id == AV_CODEC_ID_GIF ||
2264  c->codec_id == AV_CODEC_ID_HEVC ||
2265  c->codec_id == AV_CODEC_ID_H264)
2266  return 1;
2267  return 0;
2268 }
2269 
2270 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2271 {
2272  FFStream *const sti = ffstream(st);
2273  FFStreamInfo *info = sti->info;
2274  int64_t last = info->last_dts;
2275 
2276  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2277  && ts - (uint64_t)last < INT64_MAX) {
2278  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2279  int64_t duration = ts - last;
2280 
2281  if (!info->duration_error)
2282  info->duration_error = av_mallocz(sizeof(info->duration_error[0])*2);
2283  if (!info->duration_error)
2284  return AVERROR(ENOMEM);
2285 
2286 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2287 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2288  for (int i = 0; i < MAX_STD_TIMEBASES; i++) {
2289  if (info->duration_error[0][1][i] < 1e10) {
2290  int framerate = get_std_framerate(i);
2291  double sdts = dts*framerate/(1001*12);
2292  for (int j = 0; j < 2; j++) {
2293  int64_t ticks = llrint(sdts+j*0.5);
2294  double error = sdts - ticks + j*0.5;
2295  info->duration_error[j][0][i] += error;
2296  info->duration_error[j][1][i] += error*error;
2297  }
2298  }
2299  }
2300  if (info->rfps_duration_sum <= INT64_MAX - duration) {
2301  info->duration_count++;
2302  info->rfps_duration_sum += duration;
2303  }
2304 
2305  if (info->duration_count % 10 == 0) {
2306  int n = info->duration_count;
2307  for (int i = 0; i < MAX_STD_TIMEBASES; i++) {
2308  if (info->duration_error[0][1][i] < 1e10) {
2309  double a0 = info->duration_error[0][0][i] / n;
2310  double error0 = info->duration_error[0][1][i] / n - a0*a0;
2311  double a1 = info->duration_error[1][0][i] / n;
2312  double error1 = info->duration_error[1][1][i] / n - a1*a1;
2313  if (error0 > 0.04 && error1 > 0.04) {
2314  info->duration_error[0][1][i] = 2e10;
2315  info->duration_error[1][1][i] = 2e10;
2316  }
2317  }
2318  }
2319  }
2320 
2321  // ignore the first 4 values, they might have some random jitter
2322  if (info->duration_count > 3 && is_relative(ts) == is_relative(last))
2323  info->duration_gcd = av_gcd(info->duration_gcd, duration);
2324  }
2325  if (ts != AV_NOPTS_VALUE)
2326  info->last_dts = ts;
2327 
2328  return 0;
2329 }
2330 
2332 {
2333  for (unsigned i = 0; i < ic->nb_streams; i++) {
2334  AVStream *const st = ic->streams[i];
2335  FFStream *const sti = ffstream(st);
2336 
2338  continue;
2339  // the check for tb_unreliable() is not completely correct, since this is not about handling
2340  // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2341  // ipmovie.c produces.
2342  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 &&
2343  sti->info->duration_gcd < INT64_MAX / st->time_base.num)
2344  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);
2345  if (sti->info->duration_count > 1 && !st->r_frame_rate.num
2346  && tb_unreliable(ic, st)) {
2347  int num = 0;
2348  double best_error = 0.01;
2349  AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2350 
2351  for (int j = 0; j < MAX_STD_TIMEBASES; j++) {
2352  if (sti->info->codec_info_duration &&
2353  sti->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
2354  continue;
2355  if (!sti->info->codec_info_duration && get_std_framerate(j) < 1001*12)
2356  continue;
2357 
2358  if (av_q2d(st->time_base) * sti->info->rfps_duration_sum / sti->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2359  continue;
2360 
2361  for (int k = 0; k < 2; k++) {
2362  int n = sti->info->duration_count;
2363  double a = sti->info->duration_error[k][0][j] / n;
2364  double error = sti->info->duration_error[k][1][j]/n - a*a;
2365 
2366  if (error < best_error && best_error> 0.000000001) {
2367  best_error= error;
2368  num = get_std_framerate(j);
2369  }
2370  if (error < 0.02)
2371  av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2372  }
2373  }
2374  // do not increase frame rate by more than 1 % in order to match a standard rate.
2375  if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2376  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2377  }
2378  if ( !st->avg_frame_rate.num
2379  && st->r_frame_rate.num && sti->info->rfps_duration_sum
2380  && sti->info->codec_info_duration <= 0
2381  && sti->info->duration_count > 2
2382  && 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
2383  ) {
2384  av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2385  st->avg_frame_rate = st->r_frame_rate;
2386  }
2387 
2388  av_freep(&sti->info->duration_error);
2389  sti->info->last_dts = AV_NOPTS_VALUE;
2390  sti->info->duration_count = 0;
2391  sti->info->rfps_duration_sum = 0;
2392  }
2393 }
2394 
2396 {
2397  const AVBitStreamFilter *const f = av_bsf_get_by_name("extract_extradata");
2398  if (!f)
2399  return 0;
2400 
2401  if (f->codec_ids) {
2402  const enum AVCodecID *ids;
2403  for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
2404  if (*ids == st->codecpar->codec_id)
2405  return 1;
2406  }
2407 
2408  return 0;
2409 }
2410 
2412 {
2413  FFStream *const sti = ffstream(st);
2414  const AVBitStreamFilter *f;
2415  int ret;
2416 
2417  f = av_bsf_get_by_name("extract_extradata");
2418  if (!f)
2419  goto finish;
2420 
2421  /* check that the codec id is supported */
2423  if (!ret)
2424  goto finish;
2425 
2427  if (ret < 0)
2428  return ret;
2429 
2431  st->codecpar);
2432  if (ret < 0)
2433  goto fail;
2434 
2436 
2438  if (ret < 0)
2439  goto fail;
2440 
2441 finish:
2442  sti->extract_extradata.inited = 1;
2443 
2444  return 0;
2445 fail:
2447  return ret;
2448 }
2449 
2451 {
2452  FFStream *const sti = ffstream(st);
2453  AVPacket *const pkt_ref = si->parse_pkt;
2454  int ret;
2455 
2456  if (!sti->extract_extradata.inited) {
2458  if (ret < 0)
2459  return ret;
2460  }
2461 
2462  if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
2463  return 0;
2464 
2465  ret = av_packet_ref(pkt_ref, pkt);
2466  if (ret < 0)
2467  return ret;
2468 
2469  ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
2470  if (ret < 0) {
2471  av_packet_unref(pkt_ref);
2472  return ret;
2473  }
2474 
2475  while (ret >= 0 && !sti->avctx->extradata) {
2477  if (ret < 0) {
2478  if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
2479  return ret;
2480  continue;
2481  }
2482 
2483  for (int i = 0; i < pkt_ref->side_data_elems; i++) {
2484  AVPacketSideData *const side_data = &pkt_ref->side_data[i];
2485  if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) {
2486  sti->avctx->extradata = side_data->data;
2487  sti->avctx->extradata_size = side_data->size;
2488  side_data->data = NULL;
2489  side_data->size = 0;
2490  break;
2491  }
2492  }
2493  av_packet_unref(pkt_ref);
2494  }
2495 
2496  return 0;
2497 }
2498 
2500 {
2501  FFFormatContext *const si = ffformatcontext(ic);
2502  int count = 0, ret = 0;
2503  int64_t read_size;
2504  AVPacket *pkt1 = si->pkt;
2505  int64_t old_offset = avio_tell(ic->pb);
2506  // new streams might appear, no options for those
2507  int orig_nb_streams = ic->nb_streams;
2508  int flush_codecs;
2509  int64_t max_analyze_duration = ic->max_analyze_duration;
2510  int64_t max_stream_analyze_duration;
2511  int64_t max_subtitle_analyze_duration;
2512  int64_t probesize = ic->probesize;
2513  int eof_reached = 0;
2514  int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
2515 
2516  flush_codecs = probesize > 0;
2517 
2518  av_opt_set_int(ic, "skip_clear", 1, AV_OPT_SEARCH_CHILDREN);
2519 
2520  max_stream_analyze_duration = max_analyze_duration;
2521  max_subtitle_analyze_duration = max_analyze_duration;
2522  if (!max_analyze_duration) {
2523  max_stream_analyze_duration =
2524  max_analyze_duration = 5*AV_TIME_BASE;
2525  max_subtitle_analyze_duration = 30*AV_TIME_BASE;
2526  if (!strcmp(ic->iformat->name, "flv"))
2527  max_stream_analyze_duration = 90*AV_TIME_BASE;
2528  if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
2529  max_stream_analyze_duration = 7*AV_TIME_BASE;
2530  }
2531 
2532  if (ic->pb) {
2533  FFIOContext *const ctx = ffiocontext(ic->pb);
2534  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
2535  avio_tell(ic->pb), ctx->bytes_read, ctx->seek_count, ic->nb_streams);
2536  }
2537 
2538  for (unsigned i = 0; i < ic->nb_streams; i++) {
2539  const AVCodec *codec;
2540  AVDictionary *thread_opt = NULL;
2541  AVStream *const st = ic->streams[i];
2542  FFStream *const sti = ffstream(st);
2543  AVCodecContext *const avctx = sti->avctx;
2544 
2545  /* check if the caller has overridden the codec id */
2546  // only for the split stuff
2547  if (!sti->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && sti->request_probe <= 0) {
2548  sti->parser = av_parser_init(st->codecpar->codec_id);
2549  if (sti->parser) {
2550  if (sti->need_parsing == AVSTREAM_PARSE_HEADERS) {
2552  } else if (sti->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2554  }
2555  } else if (sti->need_parsing) {
2556  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2557  "%s, packets or times may be invalid.\n",
2559  }
2560  }
2561 
2563  if (ret < 0)
2564  goto find_stream_info_err;
2565  if (sti->request_probe <= 0)
2566  sti->avctx_inited = 1;
2567 
2568  codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
2569 
2570  /* Force thread count to 1 since the H.264 decoder will not extract
2571  * SPS and PPS to extradata during multi-threaded decoding. */
2572  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2573  /* Force lowres to 0. The decoder might reduce the video size by the
2574  * lowres factor, and we don't want that propagated to the stream's
2575  * codecpar */
2576  av_dict_set(options ? &options[i] : &thread_opt, "lowres", "0", 0);
2577 
2578  if (ic->codec_whitelist)
2579  av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
2580 
2581  // Try to just open decoders, in case this is enough to get parameters.
2582  // Also ensure that subtitle_header is properly set.
2583  if (!has_codec_parameters(st, NULL) && sti->request_probe <= 0 ||
2585  if (codec && !avctx->codec)
2586  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
2587  av_log(ic, AV_LOG_WARNING,
2588  "Failed to open codec in %s\n", __func__);
2589  }
2590  if (!options)
2591  av_dict_free(&thread_opt);
2592  }
2593 
2594  read_size = 0;
2595  for (;;) {
2596  const AVPacket *pkt;
2597  AVStream *st;
2598  FFStream *sti;
2599  AVCodecContext *avctx;
2600  int analyzed_all_streams;
2601  unsigned i;
2603  ret = AVERROR_EXIT;
2604  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2605  break;
2606  }
2607 
2608  /* check if one codec still needs to be handled */
2609  for (i = 0; i < ic->nb_streams; i++) {
2610  AVStream *const st = ic->streams[i];
2611  FFStream *const sti = ffstream(st);
2612  int fps_analyze_framecount = 20;
2613  int count;
2614 
2615  if (!has_codec_parameters(st, NULL))
2616  break;
2617  /* If the timebase is coarse (like the usual millisecond precision
2618  * of mkv), we need to analyze more frames to reliably arrive at
2619  * the correct fps. */
2620  if (av_q2d(st->time_base) > 0.0005)
2621  fps_analyze_framecount *= 2;
2622  if (!tb_unreliable(ic, st))
2623  fps_analyze_framecount = 0;
2624  if (ic->fps_probe_size >= 0)
2625  fps_analyze_framecount = ic->fps_probe_size;
2627  fps_analyze_framecount = 0;
2628  /* variable fps and no guess at the real fps */
2629  count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
2631  sti->info->duration_count;
2632  if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
2634  if (count < fps_analyze_framecount)
2635  break;
2636  }
2637  // Look at the first 3 frames if there is evidence of frame delay
2638  // but the decoder delay is not set.
2639  if (sti->info->frame_delay_evidence && count < 2 && sti->avctx->has_b_frames == 0)
2640  break;
2641  if (!sti->avctx->extradata &&
2642  (!sti->extract_extradata.inited || sti->extract_extradata.bsf) &&
2644  break;
2645  if (sti->first_dts == AV_NOPTS_VALUE &&
2650  break;
2651  }
2652  analyzed_all_streams = 0;
2653  if (!missing_streams || !*missing_streams)
2654  if (i == ic->nb_streams) {
2655  analyzed_all_streams = 1;
2656  /* NOTE: If the format has no header, then we need to read some
2657  * packets to get most of the streams, so we cannot stop here. */
2658  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2659  /* If we found the info for all the codecs, we can stop. */
2660  ret = count;
2661  av_log(ic, AV_LOG_DEBUG, "All info found\n");
2662  flush_codecs = 0;
2663  break;
2664  }
2665  }
2666  /* We did not get all the codec info, but we read too much data. */
2667  if (read_size >= probesize) {
2668  ret = count;
2669  av_log(ic, AV_LOG_DEBUG,
2670  "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
2671  for (unsigned i = 0; i < ic->nb_streams; i++) {
2672  AVStream *const st = ic->streams[i];
2673  FFStream *const sti = ffstream(st);
2674  if (!st->r_frame_rate.num &&
2675  sti->info->duration_count <= 1 &&
2677  strcmp(ic->iformat->name, "image2"))
2678  av_log(ic, AV_LOG_WARNING,
2679  "Stream #%d: not enough frames to estimate rate; "
2680  "consider increasing probesize\n", i);
2681  }
2682  break;
2683  }
2684 
2685  /* NOTE: A new stream can be added there if no header in file
2686  * (AVFMTCTX_NOHEADER). */
2687  ret = read_frame_internal(ic, pkt1);
2688  if (ret == AVERROR(EAGAIN))
2689  continue;
2690 
2691  if (ret < 0) {
2692  /* EOF or error*/
2693  eof_reached = 1;
2694  break;
2695  }
2696 
2697  if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
2699  pkt1, NULL, 0);
2700  if (ret < 0)
2701  goto unref_then_goto_end;
2702 
2703  pkt = &si->packet_buffer.tail->pkt;
2704  } else {
2705  pkt = pkt1;
2706  }
2707 
2708  st = ic->streams[pkt->stream_index];
2709  sti = ffstream(st);
2711  read_size += pkt->size;
2712 
2713  avctx = sti->avctx;
2714  if (!sti->avctx_inited) {
2716  if (ret < 0)
2717  goto unref_then_goto_end;
2718  sti->avctx_inited = 1;
2719  }
2720 
2721  if (pkt->dts != AV_NOPTS_VALUE && sti->codec_info_nb_frames > 1) {
2722  /* check for non-increasing dts */
2723  if (sti->info->fps_last_dts != AV_NOPTS_VALUE &&
2724  sti->info->fps_last_dts >= pkt->dts) {
2725  av_log(ic, AV_LOG_DEBUG,
2726  "Non-increasing DTS in stream %d: packet %d with DTS "
2727  "%"PRId64", packet %d with DTS %"PRId64"\n",
2728  st->index, sti->info->fps_last_dts_idx,
2730  pkt->dts);
2731  sti->info->fps_first_dts =
2733  }
2734  /* Check for a discontinuity in dts. If the difference in dts
2735  * is more than 1000 times the average packet duration in the
2736  * sequence, we treat it as a discontinuity. */
2737  if (sti->info->fps_last_dts != AV_NOPTS_VALUE &&
2738  sti->info->fps_last_dts_idx > sti->info->fps_first_dts_idx &&
2739  (pkt->dts - (uint64_t)sti->info->fps_last_dts) / 1000 >
2740  (sti->info->fps_last_dts - (uint64_t)sti->info->fps_first_dts) /
2741  (sti->info->fps_last_dts_idx - sti->info->fps_first_dts_idx)) {
2742  av_log(ic, AV_LOG_WARNING,
2743  "DTS discontinuity in stream %d: packet %d with DTS "
2744  "%"PRId64", packet %d with DTS %"PRId64"\n",
2745  st->index, sti->info->fps_last_dts_idx,
2747  pkt->dts);
2748  sti->info->fps_first_dts =
2750  }
2751 
2752  /* update stored dts values */
2753  if (sti->info->fps_first_dts == AV_NOPTS_VALUE) {
2754  sti->info->fps_first_dts = pkt->dts;
2756  }
2757  sti->info->fps_last_dts = pkt->dts;
2759  }
2760  if (sti->codec_info_nb_frames > 1) {
2761  int64_t t = 0;
2762  int64_t limit;
2763 
2764  if (st->time_base.den > 0)
2766  if (st->avg_frame_rate.num > 0)
2768 
2769  if ( t == 0
2770  && sti->codec_info_nb_frames > 30
2771  && sti->info->fps_first_dts != AV_NOPTS_VALUE
2772  && sti->info->fps_last_dts != AV_NOPTS_VALUE) {
2773  int64_t dur = av_sat_sub64(sti->info->fps_last_dts, sti->info->fps_first_dts);
2774  t = FFMAX(t, av_rescale_q(dur, st->time_base, AV_TIME_BASE_Q));
2775  }
2776 
2777  if (analyzed_all_streams) limit = max_analyze_duration;
2778  else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
2779  else limit = max_stream_analyze_duration;
2780 
2781  if (t >= limit) {
2782  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
2783  limit,
2784  t, pkt->stream_index);
2785  if (ic->flags & AVFMT_FLAG_NOBUFFER)
2786  av_packet_unref(pkt1);
2787  break;
2788  }
2789  if (pkt->duration > 0) {
2790  const int fields = sti->codec_desc && (sti->codec_desc->props & AV_CODEC_PROP_FIELDS);
2792  && (uint64_t)pkt->pts - st->start_time < INT64_MAX
2793  ) {
2795  } else
2797  sti->info->codec_info_duration_fields += sti->parser && sti->need_parsing && fields
2798  ? sti->parser->repeat_pict + 1 : 2;
2799  }
2800  }
2801  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2802 #if FF_API_R_FRAME_RATE
2803  ff_rfps_add_frame(ic, st, pkt->dts);
2804 #endif
2805  if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
2806  sti->info->frame_delay_evidence = 1;
2807  }
2808  if (!sti->avctx->extradata) {
2809  ret = extract_extradata(si, st, pkt);
2810  if (ret < 0)
2811  goto unref_then_goto_end;
2812  }
2813 
2814  /* If still no information, we try to open the codec and to
2815  * decompress the frame. We try to avoid that in most cases as
2816  * it takes longer and uses more memory. For MPEG-4, we need to
2817  * decompress for QuickTime.
2818  *
2819  * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2820  * least one frame of codec data, this makes sure the codec initializes
2821  * the channel configuration and does not only trust the values from
2822  * the container. */
2823  try_decode_frame(ic, st, pkt,
2824  (options && i < orig_nb_streams) ? &options[i] : NULL);
2825 
2826  if (ic->flags & AVFMT_FLAG_NOBUFFER)
2827  av_packet_unref(pkt1);
2828 
2829  sti->codec_info_nb_frames++;
2830  count++;
2831  }
2832 
2833  if (eof_reached) {
2834  for (unsigned stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
2835  AVStream *const st = ic->streams[stream_index];
2836  AVCodecContext *const avctx = ffstream(st)->avctx;
2837  if (!has_codec_parameters(st, NULL)) {
2838  const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
2839  if (codec && !avctx->codec) {
2840  AVDictionary *opts = NULL;
2841  if (ic->codec_whitelist)
2842  av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
2843  if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
2844  av_log(ic, AV_LOG_WARNING,
2845  "Failed to open codec in %s\n", __func__);
2846  av_dict_free(&opts);
2847  }
2848  }
2849 
2850  // EOF already reached while reading the stream above.
2851  // So continue with reoordering DTS with whatever delay we have.
2853  update_dts_from_pts(ic, stream_index, si->packet_buffer.head);
2854  }
2855  }
2856  }
2857 
2858  if (flush_codecs) {
2859  AVPacket *empty_pkt = si->pkt;
2860  int err = 0;
2861  av_packet_unref(empty_pkt);
2862 
2863  for (unsigned i = 0; i < ic->nb_streams; i++) {
2864  AVStream *const st = ic->streams[i];
2865  FFStream *const sti = ffstream(st);
2866 
2867  /* flush the decoders */
2868  if (sti->info->found_decoder == 1) {
2869  err = try_decode_frame(ic, st, empty_pkt,
2870  (options && i < orig_nb_streams)
2871  ? &options[i] : NULL);
2872 
2873  if (err < 0) {
2874  av_log(ic, AV_LOG_INFO,
2875  "decoding for stream %d failed\n", st->index);
2876  }
2877  }
2878  }
2879  }
2880 
2881  ff_rfps_calculate(ic);
2882 
2883  for (unsigned i = 0; i < ic->nb_streams; i++) {
2884  AVStream *const st = ic->streams[i];
2885  FFStream *const sti = ffstream(st);
2886  AVCodecContext *const avctx = sti->avctx;
2887 
2888  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
2889  if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
2890  uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
2892  avctx->codec_tag= tag;
2893  }
2894 
2895  /* estimate average framerate if not set by demuxer */
2896  if (sti->info->codec_info_duration_fields &&
2897  !st->avg_frame_rate.num &&
2898  sti->info->codec_info_duration) {
2899  int best_fps = 0;
2900  double best_error = 0.01;
2901  AVRational codec_frame_rate = avctx->framerate;
2902 
2903  if (sti->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
2904  sti->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
2905  sti->info->codec_info_duration < 0)
2906  continue;
2908  sti->info->codec_info_duration_fields * (int64_t) st->time_base.den,
2909  sti->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
2910 
2911  /* Round guessed framerate to a "standard" framerate if it's
2912  * within 1% of the original estimate. */
2913  for (int j = 0; j < MAX_STD_TIMEBASES; j++) {
2914  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
2915  double error = fabs(av_q2d(st->avg_frame_rate) /
2916  av_q2d(std_fps) - 1);
2917 
2918  if (error < best_error) {
2919  best_error = error;
2920  best_fps = std_fps.num;
2921  }
2922 
2923  if (si->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
2924  error = fabs(av_q2d(codec_frame_rate) /
2925  av_q2d(std_fps) - 1);
2926  if (error < best_error) {
2927  best_error = error;
2928  best_fps = std_fps.num;
2929  }
2930  }
2931  }
2932  if (best_fps)
2934  best_fps, 12 * 1001, INT_MAX);
2935  }
2936  if (!st->r_frame_rate.num) {
2937  const AVCodecDescriptor *desc = sti->codec_desc;
2938  AVRational mul = (AVRational){ desc && (desc->props & AV_CODEC_PROP_FIELDS) ? 2 : 1, 1 };
2939  AVRational fr = av_mul_q(avctx->framerate, mul);
2940 
2941  if (fr.num && fr.den && av_cmp_q(st->time_base, av_inv_q(fr)) <= 0) {
2942  st->r_frame_rate = fr;
2943  } else {
2944  st->r_frame_rate.num = st->time_base.den;
2945  st->r_frame_rate.den = st->time_base.num;
2946  }
2947  }
2948  st->codecpar->framerate = avctx->framerate;
2949  if (sti->display_aspect_ratio.num && sti->display_aspect_ratio.den) {
2950  AVRational hw_ratio = { avctx->height, avctx->width };
2952  hw_ratio);
2953  }
2954  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2955  if (!avctx->bits_per_coded_sample)
2956  avctx->bits_per_coded_sample =
2958  // set stream disposition based on audio service type
2959  switch (avctx->audio_service_type) {
2962  break;
2965  break;
2968  break;
2971  break;
2974  break;
2975  }
2976  }
2977  }
2978 
2979  if (probesize)
2980  estimate_timings(ic, old_offset);
2981 
2982  av_opt_set_int(ic, "skip_clear", 0, AV_OPT_SEARCH_CHILDREN);
2983 
2984  if (ret >= 0 && ic->nb_streams)
2985  /* We could not have all the codec parameters before EOF. */
2986  ret = -1;
2987  for (unsigned i = 0; i < ic->nb_streams; i++) {
2988  AVStream *const st = ic->streams[i];
2989  FFStream *const sti = ffstream(st);
2990  const char *errmsg;
2991 
2992  /* if no packet was ever seen, update context now for has_codec_parameters */
2993  if (!sti->avctx_inited) {
2994  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2996  st->codecpar->format = sti->avctx->sample_fmt;
2998  if (ret < 0)
2999  goto find_stream_info_err;
3000  }
3001  if (!has_codec_parameters(st, &errmsg)) {
3002  char buf[256];
3003  avcodec_string(buf, sizeof(buf), sti->avctx, 0);
3004  av_log(ic, AV_LOG_WARNING,
3005  "Could not find codec parameters for stream %d (%s): %s\n"
3006  "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
3007  i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
3008  } else {
3009  ret = 0;
3010  }
3011  }
3012 
3013  ret = compute_chapters_end(ic);
3014  if (ret < 0)
3015  goto find_stream_info_err;
3016 
3017  /* update the stream parameters from the internal codec contexts */
3018  for (unsigned i = 0; i < ic->nb_streams; i++) {
3019  AVStream *const st = ic->streams[i];
3020  FFStream *const sti = ffstream(st);
3021 
3022  if (sti->avctx_inited) {
3024  if (ret < 0)
3025  goto find_stream_info_err;
3026 
3027  if (sti->avctx->rc_buffer_size > 0 || sti->avctx->rc_max_rate > 0 ||
3028  sti->avctx->rc_min_rate) {
3029  size_t cpb_size;
3030  AVCPBProperties *props = av_cpb_properties_alloc(&cpb_size);
3031  if (props) {
3032  if (sti->avctx->rc_buffer_size > 0)
3033  props->buffer_size = sti->avctx->rc_buffer_size;
3034  if (sti->avctx->rc_min_rate > 0)
3035  props->min_bitrate = sti->avctx->rc_min_rate;
3036  if (sti->avctx->rc_max_rate > 0)
3037  props->max_bitrate = sti->avctx->rc_max_rate;
3041  (uint8_t *)props, cpb_size, 0))
3042  av_free(props);
3043  }
3044  }
3045  }
3046 
3047  sti->avctx_inited = 0;
3048 #if FF_API_AVSTREAM_SIDE_DATA
3050  if (st->codecpar->nb_coded_side_data > 0) {
3051  av_assert0(!st->side_data && !st->nb_side_data);
3052  st->side_data = av_calloc(st->codecpar->nb_coded_side_data, sizeof(*st->side_data));
3053  if (!st->side_data) {
3054  ret = AVERROR(ENOMEM);
3055  goto find_stream_info_err;
3056  }
3057 
3058  for (int j = 0; j < st->codecpar->nb_coded_side_data; j++) {
3059  uint8_t *data = av_memdup(st->codecpar->coded_side_data[j].data,
3060  st->codecpar->coded_side_data[j].size);
3061  if (!data) {
3062  ret = AVERROR(ENOMEM);
3063  goto find_stream_info_err;
3064  }
3065  st->side_data[j].type = st->codecpar->coded_side_data[j].type;
3066  st->side_data[j].size = st->codecpar->coded_side_data[j].size;
3067  st->side_data[j].data = data;
3068  st->nb_side_data++;
3069  }
3070  }
3072 #endif
3073  }
3074 
3075 find_stream_info_err:
3076  for (unsigned i = 0; i < ic->nb_streams; i++) {
3077  AVStream *const st = ic->streams[i];
3078  FFStream *const sti = ffstream(st);
3079  int err;
3080 
3081  if (sti->info) {
3082  av_freep(&sti->info->duration_error);
3083  av_freep(&sti->info);
3084  }
3085 
3086  err = codec_close(sti);
3087  if (err < 0 && ret >= 0)
3088  ret = err;
3090  }
3091  if (ic->pb) {
3092  FFIOContext *const ctx = ffiocontext(ic->pb);
3093  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3094  avio_tell(ic->pb), ctx->bytes_read, ctx->seek_count, count);
3095  }
3096  return ret;
3097 
3098 unref_then_goto_end:
3099  av_packet_unref(pkt1);
3100  goto find_stream_info_err;
3101 }
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:2227
FFStreamInfo::fps_last_dts
int64_t fps_last_dts
Definition: demux.h:163
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1077
av_opt_get_dict_val
int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
Definition: opt.c:1326
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: 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:2270
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:273
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
PacketList::head
PacketListEntry * head
Definition: packet_internal.h:34
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:2726
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:443
program
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C program
Definition: undefined.txt:6
AVFMT_DURATION_FROM_BITRATE
@ AVFMT_DURATION_FROM_BITRATE
Duration estimated from bitrate (less accurate)
Definition: avformat.h:1238
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1640
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
FFFormatContext::prefer_codec_framerate
int prefer_codec_framerate
Definition: internal.h:175
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
av_probe_input_buffer2
int av_probe_input_buffer2(AVIOContext *pb, const AVInputFormat **fmt, const char *url, void *logctx, unsigned int offset, unsigned int max_probe_size)
Probe a bytestream to determine the input format.
Definition: format.c: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:409
AVCodecParserContext::pict_type
int pict_type
Definition: avcodec.h:2715
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
AVCodecContext::rc_min_rate
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1299
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
ffiocontext
static av_always_inline FFIOContext * ffiocontext(AVIOContext *ctx)
Definition: avio_internal.h:81
FFStream::bsf
struct AVBSFContext * bsf
Definition: internal.h:231
FFStream::last_IP_pts
int64_t last_IP_pts
Definition: internal.h:377
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:188
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:56
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AV_DISPOSITION_ATTACHED_PIC
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:674
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:814
av_find_program_from_stream
AVProgram * av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
Find the programs which belong to a given stream.
Definition: avformat.c:392
AV_PKT_FLAG_DISCARD
#define AV_PKT_FLAG_DISCARD
Flag is used to discard packets which are required to maintain valid decoder state but are not requir...
Definition: packet.h:584
AVCodecParserContext::duration
int duration
Duration of the current frame.
Definition: avcodec.h:2821
avcodec_string
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: avcodec.c:495
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:479
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
ff_buffer_packet
int ff_buffer_packet(AVFormatContext *s, AVPacket *pkt)
Definition: demux.c:608
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
id3v2.h
FFStream::extract_extradata
struct FFStream::@317 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:290
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1323
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h: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:2395
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:1625
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
handle_new_packet
static int handle_new_packet(AVFormatContext *s, AVPacket *pkt, int allow_passthrough)
Handle a new packet and either return it directly if possible and allow_passthrough is true or queue ...
Definition: demux.c:563
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:1269
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:1810
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1525
cffstream
static const av_always_inline FFStream * cffstream(const AVStream *st)
Definition: internal.h:422
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:690
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
wrap_timestamp
static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
Definition: demux.c: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:51
FFStream::last_dts_for_order_check
int64_t last_dts_for_order_check
Internal data to analyze DTS and detect faulty mpeg streams.
Definition: internal.h:352
AV_CODEC_ID_HDMV_PGS_SUBTITLE
@ AV_CODEC_ID_HDMV_PGS_SUBTITLE
Definition: codec_id.h:555
FFInputFormat::read_header
int(* read_header)(struct AVFormatContext *)
Read the format header and initialize the AVFormatContext structure.
Definition: demux.h:70
av_bsf_free
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
Definition: bsf.c:52
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c: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:1642
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:410
DURATION_MAX_READ_SIZE
#define DURATION_MAX_READ_SIZE
Definition: demux.c:1806
codec_close
static int codec_close(FFStream *sti)
Definition: demux.c:1274
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:610
FFStream::codec_desc
const struct AVCodecDescriptor * codec_desc
Definition: internal.h:412
avcodec_pix_fmt_to_codec_tag
unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt)
Return a value representing the fourCC code associated to the pixel format pix_fmt,...
Definition: raw.c:308
av_gcd
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
genpts
static int genpts
Definition: ffplay.c: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:2747
MAX_STD_TIMEBASES
#define MAX_STD_TIMEBASES
Definition: demux.h:138
AVFormatContext::interrupt_callback
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1528
AVCodecParserContext::key_frame
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
Definition: avcodec.h:2756
FFStream::dts_ordered
uint8_t dts_ordered
Definition: internal.h:353
finish
static void finish(void)
Definition: movenc.c:342
FFStream::last_IP_duration
int last_IP_duration
Definition: internal.h:378
force_codec_ids
static void force_codec_ids(AVFormatContext *s, AVStream *st)
Definition: demux.c: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:417
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
update_initial_timestamps
static void update_initial_timestamps(AVFormatContext *s, int stream_index, int64_t dts, int64_t pts, AVPacket *pkt)
Definition: demux.c:848
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:161
FFStream::inited
int inited
Definition: internal.h:232
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
AVERROR_OPTION_NOT_FOUND
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:63
FFStream::avctx
struct AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:221
AVChapter
Definition: avformat.h:1214
AVFMT_GENERIC_INDEX
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:480
AVFMT_DURATION_FROM_PTS
@ AVFMT_DURATION_FROM_PTS
Duration accurately estimated from PTSes.
Definition: avformat.h:1236
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AVPROBE_PADDING_SIZE
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:465
av_parser_init
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:32
pts
static int64_t pts
Definition: transcode_aac.c: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:185
av_probe_input_format3
const AVInputFormat * av_probe_input_format3(const AVProbeData *pd, int is_opened, int *score_ret)
Guess the file format.
Definition: format.c: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:2411
AVCodecParserContext::dts
int64_t dts
Definition: avcodec.h:2727
AVRational::num
int num
Numerator.
Definition: rational.h:59
FFDIFFSIGN
#define FFDIFFSIGN(x, y)
Comparator.
Definition: macros.h:45
ff_id3v2_parse_chapters
int ff_id3v2_parse_chapters(AVFormatContext *s, ID3v2ExtraMeta *cur)
Create chapters for all CHAP tags found in the ID3v2 header.
Definition: id3v2.c:1192
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:393
raw.h
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:148
AV_CODEC_ID_DVB_SUBTITLE
@ AV_CODEC_ID_DVB_SUBTITLE
Definition: codec_id.h: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:2174
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:113
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:149
AVChapter::end
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1217
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CODEC_ID_EVC
@ AV_CODEC_ID_EVC
Definition: codec_id.h:321
FFInputFormat::flags_internal
int flags_internal
Internal flags.
Definition: demux.h:56
FFFormatContext::packet_buffer
PacketList packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:98
FFStreamInfo::last_dts
int64_t last_dts
Definition: demux.h:140
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1406
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:144
duration_name
static const char *const duration_name[]
Definition: demux.c:1950
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:173
MAX_REORDER_DELAY
@ MAX_REORDER_DELAY
Definition: vaapi_encode.h:45
FFStream::nb_decoded_frames
int nb_decoded_frames
Number of internally decoded frames, used internally in libavformat, do not access its lifetime diffe...
Definition: internal.h:303
av_opt_set_dict_val
int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
Definition: opt.c:915
avpriv_h264_has_num_reorder_frames
int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
Definition: h264dec.c: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:695
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AVPacketSideData::data
uint8_t * data
Definition: packet.h:374
FFFormatContext::data_offset
int64_t data_offset
offset of the first packet
Definition: internal.h:101
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:392
AVBSFContext::time_base_in
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: bsf.h:102
FFStream::pts_reorder_error_count
uint8_t pts_reorder_error_count[MAX_REORDER_DELAY+1]
Definition: internal.h:345
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
FFStream::display_aspect_ratio
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
Definition: internal.h:368
AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
@ AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
Definition: defs.h:226
av_bsf_alloc
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:104
DURATION_MAX_RETRY
#define DURATION_MAX_RETRY
Definition: demux.c:1807
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:344
determinable_frame_size
static int determinable_frame_size(const AVCodecContext *avctx)
Definition: demux.c:2010
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:269
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
PacketList::tail
PacketListEntry * tail
Definition: packet_internal.h:34
AVFMT_NEEDNUMBER
#define AVFMT_NEEDNUMBER
Needs 'd' in filename.
Definition: avformat.h:469
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:455
FFStreamInfo::found_decoder
int found_decoder
0 -> decoder has not been searched for yet.
Definition: demux.h:154
AVFormatContext::max_analyze_duration
int64_t max_analyze_duration
Maximum duration (in AV_TIME_BASE units) of the data read from input in avformat_find_stream_info().
Definition: avformat.h:1450
AVCodecDescriptor::props
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
AVFMT_FLAG_NOPARSE
#define AVFMT_FLAG_NOPARSE
Do not use AVParsers, you also must set AVFMT_FLAG_NOFILLIN as the fillin code works on frames and no...
Definition: avformat.h:1412
fields
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the then the processing requires a frame on this link and the filter is expected to make efforts in that direction The status of input links is stored by the fifo and status_out fields
Definition: filter_design.txt:155
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h: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:2221
has_codec_parameters
static int has_codec_parameters(const AVStream *st, const char **errmsg_ptr)
Definition: demux.c:2023
FFFormatContext
Definition: internal.h:64
FF_INFMT_FLAG_INIT_CLEANUP
#define FF_INFMT_FLAG_INIT_CLEANUP
For an FFInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition: demux.h:35
AVCodecParserContext::repeat_pict
int repeat_pict
This field is used for proper frame duration computation in lavf.
Definition: avcodec.h:2725
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:386
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1277
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
opts
AVDictionary * opts
Definition: movenc.c: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:225
avcodec_find_decoder_by_name
const AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c: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:145
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:901
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:764
double
double
Definition: af_crystalizer.c:131
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:142
AVCodecParserContext::flags
int flags
Definition: avcodec.h:2740
time.h
AVFormatContext::skip_estimate_duration_from_pts
int skip_estimate_duration_from_pts
Skip duration calcuation in estimate_timings_from_pts.
Definition: avformat.h:1669
FFStreamInfo::codec_info_duration_fields
int64_t codec_info_duration_fields
Definition: demux.h:146
av_packet_ref
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: 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:1321
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
FAIL
#define FAIL(errmsg)
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:791
duration_estimate_name
static const char * duration_estimate_name(enum AVDurationEstimationMethod method)
Definition: demux.c:1956
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
FFInputFormat::read_packet
int(* read_packet)(struct AVFormatContext *, AVPacket *pkt)
Read one packet and put it in 'pkt'.
Definition: demux.h:80
AV_CODEC_ID_EAC3
@ AV_CODEC_ID_EAC3
Definition: codec_id.h:480
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1311
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:106
FFFormatContext::id3v2_meta
AVDictionary * id3v2_meta
ID3v2 tag useful for MP3 demuxing.
Definition: internal.h:170
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:442
AVFMT_FLAG_NOFILLIN
#define AVFMT_FLAG_NOFILLIN
Do not infer any values from other values, just return what is stored in the container.
Definition: avformat.h:1411
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:86
av_sat_sub64
#define av_sat_sub64
Definition: common.h: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:2499
f
f
Definition: af_crystalizer.c:121
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
av_ts2timestr
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:83
AVMediaType
AVMediaType
Definition: avutil.h:199
AVCodecParserContext::frame_offset
int64_t frame_offset
Definition: avcodec.h:2710
AV_PTS_WRAP_SUB_OFFSET
#define AV_PTS_WRAP_SUB_OFFSET
subtract the format specific offset on wrap detection
Definition: avformat.h:734
AVPacket::size
int size
Definition: packet.h: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:127
FFStreamInfo
Definition: demux.h:139
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:193
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:142
size
int size
Definition: twinvq_data.h:10344
ID3v2_DEFAULT_MAGIC
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
Definition: id3v2.h:35
PIX_FMT_LIST_RAW
@ PIX_FMT_LIST_RAW
Definition: raw.h:40
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AV_CODEC_PROP_FIELDS
#define AV_CODEC_PROP_FIELDS
Video codec supports separate coding of fields in interlaced frames.
Definition: codec_desc.h:97
update_wrap_reference
static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
Definition: demux.c: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:354
av_get_audio_frame_duration2
int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)
This function is the same as av_get_audio_frame_duration(), except it works with AVCodecParameters in...
Definition: utils.c:796
PacketListEntry::pkt
AVPacket pkt
Definition: packet_internal.h:30
AV_PTS_WRAP_ADD_OFFSET
#define AV_PTS_WRAP_ADD_OFFSET
add the format specific offset on wrap detection
Definition: avformat.h:733
AVFMT_FLAG_IGNDTS
#define AVFMT_FLAG_IGNDTS
Ignore DTS on frames that contain both DTS & PTS.
Definition: avformat.h:1410
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:278
AVCPBProperties::min_bitrate
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: defs.h:279
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:821
set_codec_from_probe_data
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
Definition: demux.c: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:332
FFStreamInfo::last_duration
int64_t last_duration
Definition: demux.h:156
FFFormatContext::raw_packet_buffer_size
int raw_packet_buffer_size
Sum of the size of packets in raw_packet_buffer, in bytes.
Definition: internal.h:138
av_packet_make_refcounted
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: 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:143
FFStream::update_initial_durations_done
int update_initial_durations_done
Internal data to prevent doing update_initial_durations() twice.
Definition: internal.h:337
FFStream::start_skip_samples
int64_t start_skip_samples
If not 0, the number of samples that should be skipped from the start of the stream (the samples are ...
Definition: internal.h:282
estimate_timings_from_bit_rate
static void estimate_timings_from_bit_rate(AVFormatContext *ic)
Definition: demux.c:1753
FFStream::probe_packets
int probe_packets
Number of packets to buffer for codec probing.
Definition: internal.h:383
a0
#define a0
Definition: regdef.h:46
ff_rfps_calculate
void ff_rfps_calculate(AVFormatContext *ic)
Definition: demux.c:2331
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
FFERROR_REDO
#define FFERROR_REDO
Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data).
Definition: demux.h:171
FFStream::probe_data
AVProbeData probe_data
Definition: internal.h:370
av_opt_ptr
void * av_opt_ptr(const AVClass *class, void *obj, const char *name)
Gets a pointer to the requested field in a struct.
Definition: opt.c:2018
AVCodec::id
enum AVCodecID id
Definition: codec.h:201
filesize
static int64_t filesize(AVIOContext *pb)
Definition: ffmpeg_mux.c:51
FFStream::skip_to_keyframe
int skip_to_keyframe
Indicates that everything up to the next keyframe should be discarded.
Definition: internal.h:268
avcodec_parameters_alloc
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: codec_par.c:56
FFStreamInfo::duration_error
double(* duration_error)[2][MAX_STD_TIMEBASES]
Definition: demux.h:144
AV_CODEC_ID_GIF
@ AV_CODEC_ID_GIF
Definition: codec_id.h:149
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:406
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1567
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:674
FFFormatContext::raw_packet_buffer
PacketList raw_packet_buffer
Raw packets from the demuxer, prior to parsing and decoding.
Definition: internal.h:109
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
AVFMT_FLAG_NOBUFFER
#define AVFMT_FLAG_NOBUFFER
Do not buffer frames when possible.
Definition: avformat.h:1413
AV_PKT_DATA_CPB_PROPERTIES
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:146
ff_is_intra_only
int ff_is_intra_only(enum AVCodecID id)
Definition: avformat.c:926
AV_CODEC_ID_RV40
@ AV_CODEC_ID_RV40
Definition: codec_id.h:121
AVCodecParserContext::pos
int64_t pos
Byte position of currently parsed frame in stream.
Definition: avcodec.h:2809
PacketListEntry
Definition: packet_internal.h:28
PARSER_FLAG_COMPLETE_FRAMES
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:2741
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c: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:615
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:682
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:347
av_find_default_stream_index
int av_find_default_stream_index(AVFormatContext *s)
Definition: avformat.c:407
AVPROBE_SCORE_RETRY
#define AVPROBE_SCORE_RETRY
Definition: avformat.h:458
AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
@ AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
Definition: defs.h:225
av_get_audio_frame_duration
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:783
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c: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:147
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:2072
avcodec.h
limit
static double limit(double x)
Definition: vf_pseudocolor.c:142
AVCodecParserContext
Definition: avcodec.h:2707
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
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
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:290
tb_unreliable
static int tb_unreliable(AVFormatContext *ic, AVStream *st)
Definition: demux.c:2245
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:86
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:749
FFStreamInfo::fps_first_dts_idx
int fps_first_dts_idx
Definition: demux.h:162
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
FFStreamInfo::duration_gcd
int64_t duration_gcd
Definition: demux.h:141
AVBitStreamFilter
Definition: bsf.h:111
av_packet_new_side_data
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
Definition: 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:133
ff_flush_packet_queue
void ff_flush_packet_queue(AVFormatContext *s)
Definition: avformat.c:131
update_dts_from_pts
static void update_dts_from_pts(AVFormatContext *s, int stream_index, PacketListEntry *pkt_buffer)
Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts of the packets in a wind...
Definition: demux.c:823
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:141
PARSER_FLAG_USE_CODEC_TS
#define PARSER_FLAG_USE_CODEC_TS
Definition: avcodec.h:2745
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:909
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:157
AVCodecContext::ticks_per_frame
attribute_deprecated int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:576
compute_pkt_fields
static void compute_pkt_fields(AVFormatContext *s, AVStream *st, AVCodecParserContext *pc, AVPacket *pkt, int64_t next_dts, int64_t next_pts)
Definition: demux.c:960
AVSTREAM_PARSE_FULL_RAW
@ AVSTREAM_PARSE_FULL_RAW
full parsing and repack with timestamp and position generation by parser for raw this assumes that ea...
Definition: avformat.h:597
FFStream::info
struct FFStreamInfo * info
Stream information used internally by avformat_find_stream_info()
Definition: internal.h:247
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1390
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVPacket::stream_index
int stream_index
Definition: packet.h: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:1154
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:75
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_parser_parse2
int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int64_t pts, int64_t dts, int64_t pos)
Parse a packet.
Definition: parser.c:115
extract_extradata
static int extract_extradata(FFFormatContext *si, AVStream *st, const AVPacket *pkt)
Definition: demux.c:2450
packet_internal.h
FFFormatContext::pkt
AVPacket * pkt
Used to hold temporary packets for the generic demuxing code.
Definition: internal.h:134
llrint
#define llrint(x)
Definition: libm.h:394
avcodec_parameters_from_context
int avcodec_parameters_from_context(struct AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: codec_par.c:137
AVCodecParameters::format
int format
Definition: codec_par.h:92
FFStream::request_probe
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: internal.h:263
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:470
AV_AUDIO_SERVICE_TYPE_EFFECTS
@ AV_AUDIO_SERVICE_TYPE_EFFECTS
Definition: defs.h:224
AV_ROUND_PASS_MINMAX
@ AV_ROUND_PASS_MINMAX
Flag telling rescaling functions to pass INT64_MIN/MAX through unchanged, avoiding special cases for ...
Definition: mathematics.h:159
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:499
fill_all_stream_timings
static void fill_all_stream_timings(AVFormatContext *ic)
Definition: demux.c:1736
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:775
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:410
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:238
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:164
FFStream::parser
struct AVCodecParserContext * parser
Definition: internal.h:387
AV_CODEC_CAP_AVOID_PROBING
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition: codec.h:138
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
estimate_timings
static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
Definition: demux.c:1961
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:745
is_relative
static av_always_inline int is_relative(int64_t ts)
Definition: demux.h:175
av_opt_set_dict
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1947
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:792
PARSER_FLAG_ONCE
#define PARSER_FLAG_ONCE
Definition: avcodec.h:2742
AV_CODEC_ID_APTX
@ AV_CODEC_ID_APTX
Definition: codec_id.h:525
avstring.h
ff_reduce_index
void ff_reduce_index(AVFormatContext *s, int stream_index)
Ensure the index uses less memory than the maximum specified in AVFormatContext.max_index_size by dis...
Definition: seek.c: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:320
av_rescale_q_rnd
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.
Definition: mathematics.c:134
compute_chapters_end
static int compute_chapters_end(AVFormatContext *s)
Definition: demux.c:2184
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