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