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 *avpkt, 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  AVPacket pkt = *avpkt;
1996  int do_skip_frame = 0;
1997  enum AVDiscard skip_frame;
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.size > 0 || (!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.size = 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.size = 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  if (c->time_base.den >= 101LL * c->time_base.num ||
2162  c->time_base.den < 5LL * c->time_base.num ||
2163  // c->codec_tag == AV_RL32("DIVX") ||
2164  // c->codec_tag == AV_RL32("XVID") ||
2165  c->codec_tag == AV_RL32("mp4v") ||
2166  c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2167  c->codec_id == AV_CODEC_ID_GIF ||
2168  c->codec_id == AV_CODEC_ID_HEVC ||
2169  c->codec_id == AV_CODEC_ID_H264)
2170  return 1;
2171  return 0;
2172 }
2173 
2174 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2175 {
2176  FFStream *const sti = ffstream(st);
2177  FFStreamInfo *info = sti->info;
2178  int64_t last = info->last_dts;
2179 
2180  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2181  && ts - (uint64_t)last < INT64_MAX) {
2182  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2183  int64_t duration = ts - last;
2184 
2185  if (!info->duration_error)
2186  info->duration_error = av_mallocz(sizeof(info->duration_error[0])*2);
2187  if (!info->duration_error)
2188  return AVERROR(ENOMEM);
2189 
2190 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2191 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2192  for (int i = 0; i < MAX_STD_TIMEBASES; i++) {
2193  if (info->duration_error[0][1][i] < 1e10) {
2194  int framerate = get_std_framerate(i);
2195  double sdts = dts*framerate/(1001*12);
2196  for (int j = 0; j < 2; j++) {
2197  int64_t ticks = llrint(sdts+j*0.5);
2198  double error = sdts - ticks + j*0.5;
2199  info->duration_error[j][0][i] += error;
2200  info->duration_error[j][1][i] += error*error;
2201  }
2202  }
2203  }
2204  if (info->rfps_duration_sum <= INT64_MAX - duration) {
2205  info->duration_count++;
2206  info->rfps_duration_sum += duration;
2207  }
2208 
2209  if (info->duration_count % 10 == 0) {
2210  int n = info->duration_count;
2211  for (int i = 0; i < MAX_STD_TIMEBASES; i++) {
2212  if (info->duration_error[0][1][i] < 1e10) {
2213  double a0 = info->duration_error[0][0][i] / n;
2214  double error0 = info->duration_error[0][1][i] / n - a0*a0;
2215  double a1 = info->duration_error[1][0][i] / n;
2216  double error1 = info->duration_error[1][1][i] / n - a1*a1;
2217  if (error0 > 0.04 && error1 > 0.04) {
2218  info->duration_error[0][1][i] = 2e10;
2219  info->duration_error[1][1][i] = 2e10;
2220  }
2221  }
2222  }
2223  }
2224 
2225  // ignore the first 4 values, they might have some random jitter
2226  if (info->duration_count > 3 && is_relative(ts) == is_relative(last))
2227  info->duration_gcd = av_gcd(info->duration_gcd, duration);
2228  }
2229  if (ts != AV_NOPTS_VALUE)
2230  info->last_dts = ts;
2231 
2232  return 0;
2233 }
2234 
2236 {
2237  for (unsigned i = 0; i < ic->nb_streams; i++) {
2238  AVStream *const st = ic->streams[i];
2239  FFStream *const sti = ffstream(st);
2240 
2242  continue;
2243  // the check for tb_unreliable() is not completely correct, since this is not about handling
2244  // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2245  // ipmovie.c produces.
2246  if (tb_unreliable(sti->avctx) && sti->info->duration_count > 15 && sti->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num &&
2247  sti->info->duration_gcd < INT64_MAX / st->time_base.num)
2248  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);
2249  if (sti->info->duration_count > 1 && !st->r_frame_rate.num
2250  && tb_unreliable(sti->avctx)) {
2251  int num = 0;
2252  double best_error = 0.01;
2253  AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2254 
2255  for (int j = 0; j < MAX_STD_TIMEBASES; j++) {
2256  if (sti->info->codec_info_duration &&
2257  sti->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
2258  continue;
2259  if (!sti->info->codec_info_duration && get_std_framerate(j) < 1001*12)
2260  continue;
2261 
2262  if (av_q2d(st->time_base) * sti->info->rfps_duration_sum / sti->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2263  continue;
2264 
2265  for (int k = 0; k < 2; k++) {
2266  int n = sti->info->duration_count;
2267  double a = sti->info->duration_error[k][0][j] / n;
2268  double error = sti->info->duration_error[k][1][j]/n - a*a;
2269 
2270  if (error < best_error && best_error> 0.000000001) {
2271  best_error= error;
2272  num = get_std_framerate(j);
2273  }
2274  if (error < 0.02)
2275  av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2276  }
2277  }
2278  // do not increase frame rate by more than 1 % in order to match a standard rate.
2279  if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2280  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2281  }
2282  if ( !st->avg_frame_rate.num
2283  && st->r_frame_rate.num && sti->info->rfps_duration_sum
2284  && sti->info->codec_info_duration <= 0
2285  && sti->info->duration_count > 2
2286  && 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
2287  ) {
2288  av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2289  st->avg_frame_rate = st->r_frame_rate;
2290  }
2291 
2292  av_freep(&sti->info->duration_error);
2293  sti->info->last_dts = AV_NOPTS_VALUE;
2294  sti->info->duration_count = 0;
2295  sti->info->rfps_duration_sum = 0;
2296  }
2297 }
2298 
2300 {
2301  const AVBitStreamFilter *const f = av_bsf_get_by_name("extract_extradata");
2302  if (!f)
2303  return 0;
2304 
2305  if (f->codec_ids) {
2306  const enum AVCodecID *ids;
2307  for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
2308  if (*ids == st->codecpar->codec_id)
2309  return 1;
2310  }
2311 
2312  return 0;
2313 }
2314 
2316 {
2317  FFStream *const sti = ffstream(st);
2318  const AVBitStreamFilter *f;
2319  int ret;
2320 
2321  f = av_bsf_get_by_name("extract_extradata");
2322  if (!f)
2323  goto finish;
2324 
2325  /* check that the codec id is supported */
2327  if (!ret)
2328  goto finish;
2329 
2331  if (ret < 0)
2332  return ret;
2333 
2335  st->codecpar);
2336  if (ret < 0)
2337  goto fail;
2338 
2340 
2342  if (ret < 0)
2343  goto fail;
2344 
2345 finish:
2346  sti->extract_extradata.inited = 1;
2347 
2348  return 0;
2349 fail:
2351  return ret;
2352 }
2353 
2355 {
2356  FFStream *const sti = ffstream(st);
2357  AVPacket *const pkt_ref = si->parse_pkt;
2358  int ret;
2359 
2360  if (!sti->extract_extradata.inited) {
2362  if (ret < 0)
2363  return ret;
2364  }
2365 
2366  if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
2367  return 0;
2368 
2369  ret = av_packet_ref(pkt_ref, pkt);
2370  if (ret < 0)
2371  return ret;
2372 
2373  ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
2374  if (ret < 0) {
2375  av_packet_unref(pkt_ref);
2376  return ret;
2377  }
2378 
2379  while (ret >= 0 && !sti->avctx->extradata) {
2381  if (ret < 0) {
2382  if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
2383  return ret;
2384  continue;
2385  }
2386 
2387  for (int i = 0; i < pkt_ref->side_data_elems; i++) {
2388  AVPacketSideData *const side_data = &pkt_ref->side_data[i];
2389  if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) {
2390  sti->avctx->extradata = side_data->data;
2391  sti->avctx->extradata_size = side_data->size;
2392  side_data->data = NULL;
2393  side_data->size = 0;
2394  break;
2395  }
2396  }
2397  av_packet_unref(pkt_ref);
2398  }
2399 
2400  return 0;
2401 }
2402 
2404 {
2405  for (int i = 0; i < avctx->nb_coded_side_data; i++) {
2406  const AVPacketSideData *const sd_src = &avctx->coded_side_data[i];
2407  uint8_t *dst_data;
2408  dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
2409  if (!dst_data)
2410  return AVERROR(ENOMEM);
2411  memcpy(dst_data, sd_src->data, sd_src->size);
2412  }
2413  return 0;
2414 }
2415 
2417 {
2418  FFFormatContext *const si = ffformatcontext(ic);
2419  int count = 0, ret = 0;
2420  int64_t read_size;
2421  AVPacket *pkt1 = si->pkt;
2422  int64_t old_offset = avio_tell(ic->pb);
2423  // new streams might appear, no options for those
2424  int orig_nb_streams = ic->nb_streams;
2425  int flush_codecs;
2426  int64_t max_analyze_duration = ic->max_analyze_duration;
2427  int64_t max_stream_analyze_duration;
2428  int64_t max_subtitle_analyze_duration;
2429  int64_t probesize = ic->probesize;
2430  int eof_reached = 0;
2431  int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
2432 
2433  flush_codecs = probesize > 0;
2434 
2435  av_opt_set_int(ic, "skip_clear", 1, AV_OPT_SEARCH_CHILDREN);
2436 
2437  max_stream_analyze_duration = max_analyze_duration;
2438  max_subtitle_analyze_duration = max_analyze_duration;
2439  if (!max_analyze_duration) {
2440  max_stream_analyze_duration =
2441  max_analyze_duration = 5*AV_TIME_BASE;
2442  max_subtitle_analyze_duration = 30*AV_TIME_BASE;
2443  if (!strcmp(ic->iformat->name, "flv"))
2444  max_stream_analyze_duration = 90*AV_TIME_BASE;
2445  if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
2446  max_stream_analyze_duration = 7*AV_TIME_BASE;
2447  }
2448 
2449  if (ic->pb) {
2450  FFIOContext *const ctx = ffiocontext(ic->pb);
2451  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
2452  avio_tell(ic->pb), ctx->bytes_read, ctx->seek_count, ic->nb_streams);
2453  }
2454 
2455  for (unsigned i = 0; i < ic->nb_streams; i++) {
2456  const AVCodec *codec;
2457  AVDictionary *thread_opt = NULL;
2458  AVStream *const st = ic->streams[i];
2459  FFStream *const sti = ffstream(st);
2460  AVCodecContext *const avctx = sti->avctx;
2461 
2462  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2464 /* if (!st->time_base.num)
2465  st->time_base = */
2466  if (!avctx->time_base.num)
2467  avctx->time_base = st->time_base;
2468  }
2469 
2470  /* check if the caller has overridden the codec id */
2471  // only for the split stuff
2472  if (!sti->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && sti->request_probe <= 0) {
2473  sti->parser = av_parser_init(st->codecpar->codec_id);
2474  if (sti->parser) {
2475  if (sti->need_parsing == AVSTREAM_PARSE_HEADERS) {
2477  } else if (sti->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2479  }
2480  } else if (sti->need_parsing) {
2481  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2482  "%s, packets or times may be invalid.\n",
2484  }
2485  }
2486 
2488  if (ret < 0)
2489  goto find_stream_info_err;
2490  if (sti->request_probe <= 0)
2491  sti->avctx_inited = 1;
2492 
2493  codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
2494 
2495  /* Force thread count to 1 since the H.264 decoder will not extract
2496  * SPS and PPS to extradata during multi-threaded decoding. */
2497  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2498  /* Force lowres to 0. The decoder might reduce the video size by the
2499  * lowres factor, and we don't want that propagated to the stream's
2500  * codecpar */
2501  av_dict_set(options ? &options[i] : &thread_opt, "lowres", "0", 0);
2502 
2503  if (ic->codec_whitelist)
2504  av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
2505 
2506  // Try to just open decoders, in case this is enough to get parameters.
2507  // Also ensure that subtitle_header is properly set.
2508  if (!has_codec_parameters(st, NULL) && sti->request_probe <= 0 ||
2510  if (codec && !avctx->codec)
2511  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
2512  av_log(ic, AV_LOG_WARNING,
2513  "Failed to open codec in %s\n",__FUNCTION__);
2514  }
2515  if (!options)
2516  av_dict_free(&thread_opt);
2517  }
2518 
2519  read_size = 0;
2520  for (;;) {
2521  const AVPacket *pkt;
2522  AVStream *st;
2523  FFStream *sti;
2524  AVCodecContext *avctx;
2525  int analyzed_all_streams;
2526  unsigned i;
2528  ret = AVERROR_EXIT;
2529  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2530  break;
2531  }
2532 
2533  /* check if one codec still needs to be handled */
2534  for (i = 0; i < ic->nb_streams; i++) {
2535  AVStream *const st = ic->streams[i];
2536  FFStream *const sti = ffstream(st);
2537  int fps_analyze_framecount = 20;
2538  int count;
2539 
2540  if (!has_codec_parameters(st, NULL))
2541  break;
2542  /* If the timebase is coarse (like the usual millisecond precision
2543  * of mkv), we need to analyze more frames to reliably arrive at
2544  * the correct fps. */
2545  if (av_q2d(st->time_base) > 0.0005)
2546  fps_analyze_framecount *= 2;
2547  if (!tb_unreliable(sti->avctx))
2548  fps_analyze_framecount = 0;
2549  if (ic->fps_probe_size >= 0)
2550  fps_analyze_framecount = ic->fps_probe_size;
2552  fps_analyze_framecount = 0;
2553  /* variable fps and no guess at the real fps */
2554  count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
2556  sti->info->duration_count;
2557  if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
2559  if (count < fps_analyze_framecount)
2560  break;
2561  }
2562  // Look at the first 3 frames if there is evidence of frame delay
2563  // but the decoder delay is not set.
2564  if (sti->info->frame_delay_evidence && count < 2 && sti->avctx->has_b_frames == 0)
2565  break;
2566  if (!sti->avctx->extradata &&
2567  (!sti->extract_extradata.inited || sti->extract_extradata.bsf) &&
2569  break;
2570  if (sti->first_dts == AV_NOPTS_VALUE &&
2571  !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
2575  break;
2576  }
2577  analyzed_all_streams = 0;
2578  if (!missing_streams || !*missing_streams)
2579  if (i == ic->nb_streams) {
2580  analyzed_all_streams = 1;
2581  /* NOTE: If the format has no header, then we need to read some
2582  * packets to get most of the streams, so we cannot stop here. */
2583  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2584  /* If we found the info for all the codecs, we can stop. */
2585  ret = count;
2586  av_log(ic, AV_LOG_DEBUG, "All info found\n");
2587  flush_codecs = 0;
2588  break;
2589  }
2590  }
2591  /* We did not get all the codec info, but we read too much data. */
2592  if (read_size >= probesize) {
2593  ret = count;
2594  av_log(ic, AV_LOG_DEBUG,
2595  "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
2596  for (unsigned i = 0; i < ic->nb_streams; i++) {
2597  AVStream *const st = ic->streams[i];
2598  FFStream *const sti = ffstream(st);
2599  if (!st->r_frame_rate.num &&
2600  sti->info->duration_count <= 1 &&
2602  strcmp(ic->iformat->name, "image2"))
2603  av_log(ic, AV_LOG_WARNING,
2604  "Stream #%d: not enough frames to estimate rate; "
2605  "consider increasing probesize\n", i);
2606  }
2607  break;
2608  }
2609 
2610  /* NOTE: A new stream can be added there if no header in file
2611  * (AVFMTCTX_NOHEADER). */
2612  ret = read_frame_internal(ic, pkt1);
2613  if (ret == AVERROR(EAGAIN))
2614  continue;
2615 
2616  if (ret < 0) {
2617  /* EOF or error*/
2618  eof_reached = 1;
2619  break;
2620  }
2621 
2622  if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
2624  pkt1, NULL, 0);
2625  if (ret < 0)
2626  goto unref_then_goto_end;
2627 
2628  pkt = &si->packet_buffer.tail->pkt;
2629  } else {
2630  pkt = pkt1;
2631  }
2632 
2633  st = ic->streams[pkt->stream_index];
2634  sti = ffstream(st);
2636  read_size += pkt->size;
2637 
2638  avctx = sti->avctx;
2639  if (!sti->avctx_inited) {
2641  if (ret < 0)
2642  goto unref_then_goto_end;
2643  sti->avctx_inited = 1;
2644  }
2645 
2646  if (pkt->dts != AV_NOPTS_VALUE && sti->codec_info_nb_frames > 1) {
2647  /* check for non-increasing dts */
2648  if (sti->info->fps_last_dts != AV_NOPTS_VALUE &&
2649  sti->info->fps_last_dts >= pkt->dts) {
2650  av_log(ic, AV_LOG_DEBUG,
2651  "Non-increasing DTS in stream %d: packet %d with DTS "
2652  "%"PRId64", packet %d with DTS %"PRId64"\n",
2653  st->index, sti->info->fps_last_dts_idx,
2655  pkt->dts);
2656  sti->info->fps_first_dts =
2658  }
2659  /* Check for a discontinuity in dts. If the difference in dts
2660  * is more than 1000 times the average packet duration in the
2661  * sequence, we treat it as a discontinuity. */
2662  if (sti->info->fps_last_dts != AV_NOPTS_VALUE &&
2663  sti->info->fps_last_dts_idx > sti->info->fps_first_dts_idx &&
2664  (pkt->dts - (uint64_t)sti->info->fps_last_dts) / 1000 >
2665  (sti->info->fps_last_dts - (uint64_t)sti->info->fps_first_dts) /
2666  (sti->info->fps_last_dts_idx - sti->info->fps_first_dts_idx)) {
2667  av_log(ic, AV_LOG_WARNING,
2668  "DTS discontinuity in stream %d: packet %d with DTS "
2669  "%"PRId64", packet %d with DTS %"PRId64"\n",
2670  st->index, sti->info->fps_last_dts_idx,
2672  pkt->dts);
2673  sti->info->fps_first_dts =
2675  }
2676 
2677  /* update stored dts values */
2678  if (sti->info->fps_first_dts == AV_NOPTS_VALUE) {
2679  sti->info->fps_first_dts = pkt->dts;
2681  }
2682  sti->info->fps_last_dts = pkt->dts;
2684  }
2685  if (sti->codec_info_nb_frames > 1) {
2686  int64_t t = 0;
2687  int64_t limit;
2688 
2689  if (st->time_base.den > 0)
2691  if (st->avg_frame_rate.num > 0)
2693 
2694  if ( t == 0
2695  && sti->codec_info_nb_frames > 30
2696  && sti->info->fps_first_dts != AV_NOPTS_VALUE
2697  && sti->info->fps_last_dts != AV_NOPTS_VALUE) {
2698  int64_t dur = av_sat_sub64(sti->info->fps_last_dts, sti->info->fps_first_dts);
2699  t = FFMAX(t, av_rescale_q(dur, st->time_base, AV_TIME_BASE_Q));
2700  }
2701 
2702  if (analyzed_all_streams) limit = max_analyze_duration;
2703  else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
2704  else limit = max_stream_analyze_duration;
2705 
2706  if (t >= limit) {
2707  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
2708  limit,
2709  t, pkt->stream_index);
2710  if (ic->flags & AVFMT_FLAG_NOBUFFER)
2711  av_packet_unref(pkt1);
2712  break;
2713  }
2714  if (pkt->duration > 0) {
2716  && (uint64_t)pkt->pts - st->start_time < INT64_MAX
2717  ) {
2719  } else
2721  sti->info->codec_info_duration_fields += sti->parser && sti->need_parsing && avctx->ticks_per_frame == 2
2722  ? sti->parser->repeat_pict + 1 : 2;
2723  }
2724  }
2725  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2726 #if FF_API_R_FRAME_RATE
2727  ff_rfps_add_frame(ic, st, pkt->dts);
2728 #endif
2729  if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
2730  sti->info->frame_delay_evidence = 1;
2731  }
2732  if (!sti->avctx->extradata) {
2733  ret = extract_extradata(si, st, pkt);
2734  if (ret < 0)
2735  goto unref_then_goto_end;
2736  }
2737 
2738  /* If still no information, we try to open the codec and to
2739  * decompress the frame. We try to avoid that in most cases as
2740  * it takes longer and uses more memory. For MPEG-4, we need to
2741  * decompress for QuickTime.
2742  *
2743  * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2744  * least one frame of codec data, this makes sure the codec initializes
2745  * the channel configuration and does not only trust the values from
2746  * the container. */
2747  try_decode_frame(ic, st, pkt,
2748  (options && i < orig_nb_streams) ? &options[i] : NULL);
2749 
2750  if (ic->flags & AVFMT_FLAG_NOBUFFER)
2751  av_packet_unref(pkt1);
2752 
2753  sti->codec_info_nb_frames++;
2754  count++;
2755  }
2756 
2757  if (eof_reached) {
2758  for (unsigned stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
2759  AVStream *const st = ic->streams[stream_index];
2760  AVCodecContext *const avctx = ffstream(st)->avctx;
2761  if (!has_codec_parameters(st, NULL)) {
2762  const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
2763  if (codec && !avctx->codec) {
2764  AVDictionary *opts = NULL;
2765  if (ic->codec_whitelist)
2766  av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
2767  if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
2768  av_log(ic, AV_LOG_WARNING,
2769  "Failed to open codec in %s\n",__FUNCTION__);
2770  av_dict_free(&opts);
2771  }
2772  }
2773 
2774  // EOF already reached while reading the stream above.
2775  // So continue with reoordering DTS with whatever delay we have.
2777  update_dts_from_pts(ic, stream_index, si->packet_buffer.head);
2778  }
2779  }
2780  }
2781 
2782  if (flush_codecs) {
2783  AVPacket *empty_pkt = si->pkt;
2784  int err = 0;
2785  av_packet_unref(empty_pkt);
2786 
2787  for (unsigned i = 0; i < ic->nb_streams; i++) {
2788  AVStream *const st = ic->streams[i];
2789  FFStream *const sti = ffstream(st);
2790 
2791  /* flush the decoders */
2792  if (sti->info->found_decoder == 1) {
2793  err = try_decode_frame(ic, st, empty_pkt,
2794  (options && i < orig_nb_streams)
2795  ? &options[i] : NULL);
2796 
2797  if (err < 0) {
2798  av_log(ic, AV_LOG_INFO,
2799  "decoding for stream %d failed\n", st->index);
2800  }
2801  }
2802  }
2803  }
2804 
2805  ff_rfps_calculate(ic);
2806 
2807  for (unsigned i = 0; i < ic->nb_streams; i++) {
2808  AVStream *const st = ic->streams[i];
2809  FFStream *const sti = ffstream(st);
2810  AVCodecContext *const avctx = sti->avctx;
2811 
2812  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
2813  if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
2814  uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
2816  avctx->codec_tag= tag;
2817  }
2818 
2819  /* estimate average framerate if not set by demuxer */
2820  if (sti->info->codec_info_duration_fields &&
2821  !st->avg_frame_rate.num &&
2822  sti->info->codec_info_duration) {
2823  int best_fps = 0;
2824  double best_error = 0.01;
2825  AVRational codec_frame_rate = avctx->framerate;
2826 
2827  if (sti->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
2828  sti->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
2829  sti->info->codec_info_duration < 0)
2830  continue;
2832  sti->info->codec_info_duration_fields * (int64_t) st->time_base.den,
2833  sti->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
2834 
2835  /* Round guessed framerate to a "standard" framerate if it's
2836  * within 1% of the original estimate. */
2837  for (int j = 0; j < MAX_STD_TIMEBASES; j++) {
2838  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
2839  double error = fabs(av_q2d(st->avg_frame_rate) /
2840  av_q2d(std_fps) - 1);
2841 
2842  if (error < best_error) {
2843  best_error = error;
2844  best_fps = std_fps.num;
2845  }
2846 
2847  if (si->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
2848  error = fabs(av_q2d(codec_frame_rate) /
2849  av_q2d(std_fps) - 1);
2850  if (error < best_error) {
2851  best_error = error;
2852  best_fps = std_fps.num;
2853  }
2854  }
2855  }
2856  if (best_fps)
2858  best_fps, 12 * 1001, INT_MAX);
2859  }
2860 
2861  if (!st->r_frame_rate.num) {
2862  if ( avctx->time_base.den * (int64_t) st->time_base.num
2863  <= avctx->time_base.num * (uint64_t)avctx->ticks_per_frame * st->time_base.den) {
2865  avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
2866  } else {
2867  st->r_frame_rate.num = st->time_base.den;
2868  st->r_frame_rate.den = st->time_base.num;
2869  }
2870  }
2871  if (sti->display_aspect_ratio.num && sti->display_aspect_ratio.den) {
2872  AVRational hw_ratio = { avctx->height, avctx->width };
2874  hw_ratio);
2875  }
2876  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2877  if (!avctx->bits_per_coded_sample)
2878  avctx->bits_per_coded_sample =
2880  // set stream disposition based on audio service type
2881  switch (avctx->audio_service_type) {
2884  break;
2887  break;
2890  break;
2893  break;
2896  break;
2897  }
2898  }
2899  }
2900 
2901  if (probesize)
2902  estimate_timings(ic, old_offset);
2903 
2904  av_opt_set_int(ic, "skip_clear", 0, AV_OPT_SEARCH_CHILDREN);
2905 
2906  if (ret >= 0 && ic->nb_streams)
2907  /* We could not have all the codec parameters before EOF. */
2908  ret = -1;
2909  for (unsigned i = 0; i < ic->nb_streams; i++) {
2910  AVStream *const st = ic->streams[i];
2911  FFStream *const sti = ffstream(st);
2912  const char *errmsg;
2913 
2914  /* if no packet was ever seen, update context now for has_codec_parameters */
2915  if (!sti->avctx_inited) {
2916  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2918  st->codecpar->format = sti->avctx->sample_fmt;
2920  if (ret < 0)
2921  goto find_stream_info_err;
2922  }
2923  if (!has_codec_parameters(st, &errmsg)) {
2924  char buf[256];
2925  avcodec_string(buf, sizeof(buf), sti->avctx, 0);
2926  av_log(ic, AV_LOG_WARNING,
2927  "Could not find codec parameters for stream %d (%s): %s\n"
2928  "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
2929  i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
2930  } else {
2931  ret = 0;
2932  }
2933  }
2934 
2935  ret = compute_chapters_end(ic);
2936  if (ret < 0)
2937  goto find_stream_info_err;
2938 
2939  /* update the stream parameters from the internal codec contexts */
2940  for (unsigned i = 0; i < ic->nb_streams; i++) {
2941  AVStream *const st = ic->streams[i];
2942  FFStream *const sti = ffstream(st);
2943 
2944  if (sti->avctx_inited) {
2946  if (ret < 0)
2947  goto find_stream_info_err;
2948  ret = add_coded_side_data(st, sti->avctx);
2949  if (ret < 0)
2950  goto find_stream_info_err;
2951  }
2952 
2953  sti->avctx_inited = 0;
2954  }
2955 
2956 find_stream_info_err:
2957  for (unsigned i = 0; i < ic->nb_streams; i++) {
2958  AVStream *const st = ic->streams[i];
2959  FFStream *const sti = ffstream(st);
2960  if (sti->info) {
2961  av_freep(&sti->info->duration_error);
2962  av_freep(&sti->info);
2963  }
2964  avcodec_close(sti->avctx);
2965  // FIXME: avcodec_close() frees AVOption settable fields which includes ch_layout,
2966  // so we need to restore it.
2969  }
2970  if (ic->pb) {
2971  FFIOContext *const ctx = ffiocontext(ic->pb);
2972  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
2973  avio_tell(ic->pb), ctx->bytes_read, ctx->seek_count, count);
2974  }
2975  return ret;
2976 
2977 unref_then_goto_end:
2978  av_packet_unref(pkt1);
2979  goto find_stream_info_err;
2980 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
AVSubtitle
Definition: avcodec.h:2308
avcodec_close
av_cold int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
Definition: avcodec.c:434
FFStreamInfo::fps_last_dts
int64_t fps_last_dts
Definition: demux.h:54
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1035
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:204
ff_rfps_add_frame
int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
add frame for rfps calculation.
Definition: demux.c:2174
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:1343
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:2819
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:436
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:1199
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:57
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:227
AVCodecContext::audio_service_type
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:1086
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:1489
AVSTREAM_EVENT_FLAG_NEW_PACKETS
#define AVSTREAM_EVENT_FLAG_NEW_PACKETS
Definition: avformat.h:1087
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:1255
ff_find_decoder
const AVCodec * ff_find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
Definition: avformat.c:789
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:2808
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1007
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:879
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:1010
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:362
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:2914
avcodec_string
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: avcodec.c:515
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:481
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:1858
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:116
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:325
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
try_decode_frame
static int try_decode_frame(AVFormatContext *s, AVStream *st, const AVPacket *avpkt, AVDictionary **options)
Definition: demux.c:1986
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1284
AVPacketSideData
Definition: packet.h:315
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:223
avcodec_decode_subtitle2
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:863
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:544
extract_extradata_check
static int extract_extradata_check(AVStream *st)
Definition: demux.c:2299
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:1028
AVChapter::start
int64_t start
Definition: avformat.h:1178
AVFMT_FLAG_CUSTOM_IO
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don't avio_close() it.
Definition: avformat.h:1342
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:1605
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1385
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:31
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:456
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:298
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:1371
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:714
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:325
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:303
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:543
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:352
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:477
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
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:637
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:815
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:334
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:826
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:312
avformat_queue_attached_pictures
int avformat_queue_attached_pictures(AVFormatContext *s)
Definition: demux_utils.c:93
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1735
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:2840
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:1483
AVCodecParserContext::key_frame
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
Definition: avcodec.h:2849
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:407
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:2059
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:1698
fail
#define fail()
Definition: checkasm.h:133
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:801
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:505
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:1175
AVFMT_GENERIC_INDEX
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:482
AVFMT_DURATION_FROM_PTS
@ AVFMT_DURATION_FROM_PTS
Duration accurately estimated from PTSes.
Definition: avformat.h:1197
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:467
av_parser_init
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:32
pts
static int64_t pts
Definition: transcode_aac.c:654
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:434
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:998
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:130
AV_PTS_WRAP_IGNORE
#define AV_PTS_WRAP_IGNORE
Options for behavior on timestamp wrap detection.
Definition: avformat.h:937
ff_check_interrupt
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrupt a blocking function associated with cb.
Definition: avio.c:658
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
extract_extradata_init
static int extract_extradata_init(AVStream *st)
Definition: demux.c:2315
AVCodecParserContext::dts
int64_t dts
Definition: avcodec.h:2820
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:412
raw.h
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:104
AV_CODEC_ID_DVB_SUBTITLE
@ AV_CODEC_ID_DVB_SUBTITLE
Definition: codec_id.h:538
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:1325
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:575
AV_DISPOSITION_CLEAN_EFFECTS
#define AV_DISPOSITION_CLEAN_EFFECTS
The audio stream contains music and sound effects without voice.
Definition: avformat.h:871
AVFormatContext::max_ts_probe
int max_ts_probe
Maximum number of packets to read while waiting for the first timestamp.
Definition: avformat.h:1539
avassert.h
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
pkt
AVPacket * pkt
Definition: movenc.c:59
chapter_start_cmp
static int chapter_start_cmp(const void *p1, const void *p2)
Definition: demux.c: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:105
AVInputFormat
Definition: avformat.h:656
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:1265
AV_CHANNEL_ORDER_NATIVE
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
Definition: channel_layout.h:112
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:500
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:694
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:1178
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
MAX_REORDER_DELAY
@ MAX_REORDER_DELAY
Definition: vaapi_encode.h:45
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:1334
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:137
duration_name
static const char *const duration_name[]
Definition: demux.c:1864
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1384
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:661
AVFormatContext::iformat
const struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1228
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:455
frame_size
int frame_size
Definition: mxfenc.c:2202
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:530
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:433
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:719
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
tb_unreliable
static int tb_unreliable(AVCodecContext *c)
Definition: demux.c:2159
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:500
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:388
AVProgram::start_time
int64_t start_time
Definition: avformat.h:1160
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:471
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:408
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:1379
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:1340
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
FFStream::extract_extradata
struct FFStream::@273 extract_extradata
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:209
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:2818
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:1216
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:1108
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
AVChannelLayout::u
union AVChannelLayout::@304 u
Details about which channels are present in this layout.
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:978
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:607
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:973
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:455
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:153
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1167
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:1465
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:1198
AVCodecContext::nb_coded_side_data
int nb_coded_side_data
Definition: avcodec.h:1859
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:448
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:844
AVSTREAM_PARSE_NONE
@ AVSTREAM_PARSE_NONE
Definition: avformat.h:797
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:1258
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:1196
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:453
AV_ROUND_NEAR_INF
@ AV_ROUND_NEAR_INF
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:84
get_next_pkt
static PacketListEntry * get_next_pkt(AVFormatContext *s, AVStream *st, PacketListEntry *pktl)
Definition: demux.c: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:2833
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:1803
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:212
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:2403
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:177
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:473
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1272
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:109
FFFormatContext::id3v2_meta
AVDictionary * id3v2_meta
ID3v2 tag useful for MP3 demuxing.
Definition: internal.h:173
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:435
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:1339
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:521
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:2416
f
f
Definition: af_crystalizer.c:122
AVIOContext
Bytestream IO Context.
Definition: avio.h:162
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:2803
AV_PTS_WRAP_SUB_OFFSET
#define AV_PTS_WRAP_SUB_OFFSET
subtract the format specific offset on wrap detection
Definition: avformat.h:939
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
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:324
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:164
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:263
FFStream
Definition: internal.h:196
shift
static int shift(int a, int b)
Definition: bonk.c:260
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:1161
start_time
static int64_t start_time
Definition: ffplay.c:331
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:437
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1023
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:1074
FFStream::dts_misordered
uint8_t dts_misordered
Definition: internal.h:356
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:938
AVFMT_FLAG_IGNDTS
#define AVFMT_FLAG_IGNDTS
Ignore DTS on frames that contain both DTS & PTS.
Definition: avformat.h:1338
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:470
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:1017
set_codec_from_probe_data
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
Definition: demux.c:100
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
The stream is intended for hearing impaired audiences.
Definition: avformat.h:863
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
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:208
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:2235
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:1057
AVCodec::id
enum AVCodecID id
Definition: codec.h:218
filesize
static int64_t filesize(AVIOContext *pb)
Definition: ffmpeg_mux.c:77
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
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:74
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:436
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1444
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:637
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:1288
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:1341
ff_is_intra_only
int ff_is_intra_only(enum AVCodecID id)
Definition: avformat.c:827
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:2902
PacketListEntry
Definition: packet_internal.h:26
PARSER_FLAG_COMPLETE_FRAMES
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:2834
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:1176
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:499
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:1661
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:852
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:377
AVPROBE_SCORE_RETRY
#define AVPROBE_SCORE_RETRY
Definition: avformat.h:460
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:808
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:264
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1140
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:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
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:896
avcodec.h
limit
static double limit(double x)
Definition: vf_pseudocolor.c:128
AVCodecParserContext
Definition: avcodec.h:2800
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:1008
AVFMT_FLAG_GENPTS
#define AVFMT_FLAG_GENPTS
Generate missing pts even if it requires parsing future frames.
Definition: avformat.h:1335
AV_DISPOSITION_VISUAL_IMPAIRED
#define AV_DISPOSITION_VISUAL_IMPAIRED
The stream is intended for visually impaired audiences.
Definition: avformat.h:867
tag
uint32_t tag
Definition: movenc.c:1646
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:962
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:948
pixfmt.h
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:260
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AVStream::nb_side_data
int nb_side_data
The number of elements in the AVStream.side_data array.
Definition: avformat.h:1061
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:799
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
AVCodecContext
main external API structure.
Definition: avcodec.h:398
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:956
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:675
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:85
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:95
PARSER_FLAG_USE_CODEC_TS
#define PARSER_FLAG_USE_CODEC_TS
Definition: avcodec.h:2838
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:1097
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:802
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:1318
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:461
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:347
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:628
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:406
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:280
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:2354
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:85
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
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:423
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:61
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:71
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:222
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:190
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
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:90
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:1308
AV_CODEC_ID_AAC_LATM
@ AV_CODEC_ID_AAC_LATM
Definition: codec_id.h:482
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:144
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
estimate_timings
static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
Definition: demux.c: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:988
PARSER_FLAG_ONCE
#define PARSER_FLAG_ONCE
Definition: avcodec.h:2835
AV_CODEC_ID_APTX
@ AV_CODEC_ID_APTX
Definition: codec_id.h:518
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:800
AVDiscard
AVDiscard
Definition: defs.h:67
AVStream::pts_wrap_bits
int pts_wrap_bits
Number of bits in timestamps.
Definition: avformat.h:1117
AVChapter::time_base
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1177
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:475
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1244
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:432
AVFMT_EVENT_FLAG_METADATA_UPDATED
#define AVFMT_EVENT_FLAG_METADATA_UPDATED
Definition: avformat.h:1533
AVInputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:686
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_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:81