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