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