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