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