FFmpeg
utils.c
Go to the documentation of this file.
1 /*
2  * various utility functions for use within FFmpeg
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <stdint.h>
23 
24 #include "config.h"
25 
26 #include "libavutil/avassert.h"
27 #include "libavutil/avstring.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/mathematics.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/parseutils.h"
33 #include "libavutil/pixfmt.h"
34 #include "libavutil/thread.h"
35 #include "libavutil/time.h"
36 #include "libavutil/timestamp.h"
37 
38 #include "libavcodec/bytestream.h"
39 #include "libavcodec/internal.h"
40 #include "libavcodec/raw.h"
41 
42 #include "avformat.h"
43 #include "avio_internal.h"
44 #include "id3v2.h"
45 #include "internal.h"
46 #if CONFIG_NETWORK
47 #include "network.h"
48 #endif
49 #include "url.h"
50 
51 #include "libavutil/ffversion.h"
52 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
53 
55 
56 /**
57  * @file
58  * various utility functions for use within FFmpeg
59  */
60 
61 unsigned avformat_version(void)
62 {
65 }
66 
67 const char *avformat_configuration(void)
68 {
69  return FFMPEG_CONFIGURATION;
70 }
71 
72 const char *avformat_license(void)
73 {
74 #define LICENSE_PREFIX "libavformat license: "
75  return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
76 }
77 
79 {
80  return ff_mutex_lock(&avformat_mutex) ? -1 : 0;
81 }
82 
84 {
85  return ff_mutex_unlock(&avformat_mutex) ? -1 : 0;
86 }
87 
88 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
89 
90 static int is_relative(int64_t ts) {
91  return ts > (RELATIVE_TS_BASE - (1LL<<48));
92 }
93 
94 /**
95  * Wrap a given time stamp, if there is an indication for an overflow
96  *
97  * @param st stream
98  * @param timestamp the time stamp to wrap
99  * @return resulting time stamp
100  */
101 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
102 {
104  st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
106  timestamp < st->pts_wrap_reference)
107  return timestamp + (1ULL << st->pts_wrap_bits);
108  else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
109  timestamp >= st->pts_wrap_reference)
110  return timestamp - (1ULL << st->pts_wrap_bits);
111  }
112  return timestamp;
113 }
114 
115 #if FF_API_FORMAT_GET_SET
116 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
117 #if FF_API_LAVF_FFSERVER
119 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
121 #endif
124 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
126 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
127 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
129 #if FF_API_OLD_OPEN_CALLBACKS
133 #endif
134 #endif
135 
136 int64_t av_stream_get_end_pts(const AVStream *st)
137 {
138  if (st->internal->priv_pts) {
139  return st->internal->priv_pts->val;
140  } else
141  return AV_NOPTS_VALUE;
142 }
143 
145 {
146  return st->parser;
147 }
148 
150 {
151  int i;
153  for (i = 0; i < s->nb_streams; i++) {
154  AVStream *st = s->streams[i];
155  st->inject_global_side_data = 1;
156  }
157 }
158 
160 {
161  av_assert0(!dst->codec_whitelist &&
162  !dst->format_whitelist &&
163  !dst->protocol_whitelist &&
164  !dst->protocol_blacklist);
165  dst-> codec_whitelist = av_strdup(src->codec_whitelist);
169  if ( (src-> codec_whitelist && !dst-> codec_whitelist)
170  || (src-> format_whitelist && !dst-> format_whitelist)
171  || (src->protocol_whitelist && !dst->protocol_whitelist)
172  || (src->protocol_blacklist && !dst->protocol_blacklist)) {
173  av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
174  return AVERROR(ENOMEM);
175  }
176  return 0;
177 }
178 
180 {
181 #if FF_API_LAVF_AVCTX
183  if (st->codec->codec)
184  return st->codec->codec;
186 #endif
187 
188  switch (st->codecpar->codec_type) {
189  case AVMEDIA_TYPE_VIDEO:
190  if (s->video_codec) return s->video_codec;
191  break;
192  case AVMEDIA_TYPE_AUDIO:
193  if (s->audio_codec) return s->audio_codec;
194  break;
196  if (s->subtitle_codec) return s->subtitle_codec;
197  break;
198  }
199 
200  return avcodec_find_decoder(codec_id);
201 }
202 
204 {
205  const AVCodec *codec;
206 
207 #if CONFIG_H264_DECODER
208  /* Other parts of the code assume this decoder to be used for h264,
209  * so force it if possible. */
210  if (codec_id == AV_CODEC_ID_H264)
211  return avcodec_find_decoder_by_name("h264");
212 #endif
213 
214  codec = find_decoder(s, st, codec_id);
215  if (!codec)
216  return NULL;
217 
219  const AVCodec *probe_codec = NULL;
220  void *iter = NULL;
221  while ((probe_codec = av_codec_iterate(&iter))) {
222  if (probe_codec->id == codec->id &&
223  av_codec_is_decoder(probe_codec) &&
225  return probe_codec;
226  }
227  }
228  }
229 
230  return codec;
231 }
232 
233 #if FF_API_FORMAT_GET_SET
234 int av_format_get_probe_score(const AVFormatContext *s)
235 {
236  return s->probe_score;
237 }
238 #endif
239 
240 /* an arbitrarily chosen "sane" max packet size -- 50M */
241 #define SANE_CHUNK_SIZE (50000000)
242 
244 {
245  if (s->maxsize>= 0) {
246  int64_t remaining= s->maxsize - avio_tell(s);
247  if (remaining < size) {
248  int64_t newsize = avio_size(s);
249  if (!s->maxsize || s->maxsize<newsize)
250  s->maxsize = newsize - !newsize;
251  remaining= s->maxsize - avio_tell(s);
252  remaining= FFMAX(remaining, 0);
253  }
254 
255  if (s->maxsize>= 0 && remaining+1 < size) {
256  av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
257  size = remaining+1;
258  }
259  }
260  return size;
261 }
262 
263 /* Read the data in sane-sized chunks and append to pkt.
264  * Return the number of bytes read or an error. */
266 {
267  int orig_size = pkt->size;
268  int ret;
269 
270  do {
271  int prev_size = pkt->size;
272  int read_size;
273 
274  /* When the caller requests a lot of data, limit it to the amount
275  * left in file or SANE_CHUNK_SIZE when it is not known. */
276  read_size = size;
277  if (read_size > SANE_CHUNK_SIZE/10) {
278  read_size = ffio_limit(s, read_size);
279  // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
280  if (s->maxsize < 0)
281  read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
282  }
283 
284  ret = av_grow_packet(pkt, read_size);
285  if (ret < 0)
286  break;
287 
288  ret = avio_read(s, pkt->data + prev_size, read_size);
289  if (ret != read_size) {
290  av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
291  break;
292  }
293 
294  size -= read_size;
295  } while (size > 0);
296  if (size > 0)
297  pkt->flags |= AV_PKT_FLAG_CORRUPT;
298 
299  if (!pkt->size)
300  av_packet_unref(pkt);
301  return pkt->size > orig_size ? pkt->size - orig_size : ret;
302 }
303 
305 {
306  av_init_packet(pkt);
307  pkt->data = NULL;
308  pkt->size = 0;
309  pkt->pos = avio_tell(s);
310 
311  return append_packet_chunked(s, pkt, size);
312 }
313 
315 {
316  if (!pkt->size)
317  return av_get_packet(s, pkt, size);
318  return append_packet_chunked(s, pkt, size);
319 }
320 
321 int av_filename_number_test(const char *filename)
322 {
323  char buf[1024];
324  return filename &&
325  (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
326 }
327 
329  AVProbeData *pd)
330 {
331  static const struct {
332  const char *name;
333  enum AVCodecID id;
334  enum AVMediaType type;
335  } fmt_id_type[] = {
337  { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
338  { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO },
339  { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
341  { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
342  { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
344  { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
345  { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
346  { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
347  { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
348  { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
349  { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
350  { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
351  { 0 }
352  };
353  int score;
354  const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
355 
356  if (fmt) {
357  int i;
358  av_log(s, AV_LOG_DEBUG,
359  "Probe with size=%d, packets=%d detected %s with score=%d\n",
361  fmt->name, score);
362  for (i = 0; fmt_id_type[i].name; i++) {
363  if (!strcmp(fmt->name, fmt_id_type[i].name)) {
364  if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
365  st->codecpar->sample_rate)
366  continue;
367  if (st->request_probe > score &&
368  st->codecpar->codec_id != fmt_id_type[i].id)
369  continue;
370  st->codecpar->codec_id = fmt_id_type[i].id;
371  st->codecpar->codec_type = fmt_id_type[i].type;
372  st->internal->need_context_update = 1;
373 #if FF_API_LAVF_AVCTX
375  st->codec->codec_type = st->codecpar->codec_type;
376  st->codec->codec_id = st->codecpar->codec_id;
378 #endif
379  return score;
380  }
381  }
382  }
383  return 0;
384 }
385 
386 /************************************************************/
387 /* input media file */
388 
390  int err;
391 
392  if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
393  av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
394  return AVERROR(EINVAL);
395  }
396 
397  if (ic->iformat->read_header) {
398  err = ic->iformat->read_header(ic);
399  if (err < 0)
400  return err;
401  }
402 
403  if (ic->pb && !ic->internal->data_offset)
404  ic->internal->data_offset = avio_tell(ic->pb);
405 
406  return 0;
407 }
408 
409 /* Open input file and probe the format if necessary. */
410 static int init_input(AVFormatContext *s, const char *filename,
412 {
413  int ret;
414  AVProbeData pd = { filename, NULL, 0 };
415  int score = AVPROBE_SCORE_RETRY;
416 
417  if (s->pb) {
419  if (!s->iformat)
420  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
421  s, 0, s->format_probesize);
422  else if (s->iformat->flags & AVFMT_NOFILE)
423  av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
424  "will be ignored with AVFMT_NOFILE format.\n");
425  return 0;
426  }
427 
428  if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
429  (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
430  return score;
431 
432  if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
433  return ret;
434 
435  if (s->iformat)
436  return 0;
437  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
438  s, 0, s->format_probesize);
439 }
440 
441 int ff_packet_list_put(AVPacketList **packet_buffer,
442  AVPacketList **plast_pktl,
443  AVPacket *pkt, int flags)
444 {
445  AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
446  int ret;
447 
448  if (!pktl)
449  return AVERROR(ENOMEM);
450 
451  if (flags & FF_PACKETLIST_FLAG_REF_PACKET) {
452  if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
453  av_free(pktl);
454  return ret;
455  }
456  } else {
457  ret = av_packet_make_refcounted(pkt);
458  if (ret < 0) {
459  av_free(pktl);
460  return ret;
461  }
462  av_packet_move_ref(&pktl->pkt, pkt);
463  }
464 
465  if (*packet_buffer)
466  (*plast_pktl)->next = pktl;
467  else
468  *packet_buffer = pktl;
469 
470  /* Add the packet in the buffered packet list. */
471  *plast_pktl = pktl;
472  return 0;
473 }
474 
476 {
477  int i, ret;
478  for (i = 0; i < s->nb_streams; i++)
480  s->streams[i]->discard < AVDISCARD_ALL) {
481  if (s->streams[i]->attached_pic.size <= 0) {
483  "Attached picture on stream %d has invalid size, "
484  "ignoring\n", i);
485  continue;
486  }
487 
490  &s->streams[i]->attached_pic,
492  if (ret < 0)
493  return ret;
494  }
495  return 0;
496 }
497 
499 {
500  int i, ret;
501  for (i = 0; i < s->nb_streams; i++) {
502  AVStream *st = s->streams[i];
503 
504  if (!st->internal->need_context_update)
505  continue;
506 
507  /* close parser, because it depends on the codec */
508  if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
509  av_parser_close(st->parser);
510  st->parser = NULL;
511  }
512 
513  /* update internal codec context, for the parser */
515  if (ret < 0)
516  return ret;
517 
518 #if FF_API_LAVF_AVCTX
520  /* update deprecated public codec context */
521  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
522  if (ret < 0)
523  return ret;
525 #endif
526 
527  st->internal->need_context_update = 0;
528  }
529  return 0;
530 }
531 
532 
533 int avformat_open_input(AVFormatContext **ps, const char *filename,
535 {
536  AVFormatContext *s = *ps;
537  int i, ret = 0;
538  AVDictionary *tmp = NULL;
539  ID3v2ExtraMeta *id3v2_extra_meta = NULL;
540 
541  if (!s && !(s = avformat_alloc_context()))
542  return AVERROR(ENOMEM);
543  if (!s->av_class) {
544  av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
545  return AVERROR(EINVAL);
546  }
547  if (fmt)
548  s->iformat = fmt;
549 
550  if (options)
551  av_dict_copy(&tmp, *options, 0);
552 
553  if (s->pb) // must be before any goto fail
555 
556  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
557  goto fail;
558 
559  if (!(s->url = av_strdup(filename ? filename : ""))) {
560  ret = AVERROR(ENOMEM);
561  goto fail;
562  }
563 
564 #if FF_API_FORMAT_FILENAME
566  av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
568 #endif
569  if ((ret = init_input(s, filename, &tmp)) < 0)
570  goto fail;
571  s->probe_score = ret;
572 
573  if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
575  if (!s->protocol_whitelist) {
576  ret = AVERROR(ENOMEM);
577  goto fail;
578  }
579  }
580 
581  if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
583  if (!s->protocol_blacklist) {
584  ret = AVERROR(ENOMEM);
585  goto fail;
586  }
587  }
588 
589  if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
590  av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
591  ret = AVERROR(EINVAL);
592  goto fail;
593  }
594 
596 
597  /* Check filename in case an image number is expected. */
598  if (s->iformat->flags & AVFMT_NEEDNUMBER) {
599  if (!av_filename_number_test(filename)) {
600  ret = AVERROR(EINVAL);
601  goto fail;
602  }
603  }
604 
606 
607  /* Allocate private data. */
608  if (s->iformat->priv_data_size > 0) {
609  if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
610  ret = AVERROR(ENOMEM);
611  goto fail;
612  }
613  if (s->iformat->priv_class) {
614  *(const AVClass **) s->priv_data = s->iformat->priv_class;
616  if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
617  goto fail;
618  }
619  }
620 
621  /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
622  if (s->pb)
623  ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
624 
625 
626  if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
627  if ((ret = s->iformat->read_header(s)) < 0)
628  goto fail;
629 
630  if (!s->metadata) {
631  s->metadata = s->internal->id3v2_meta;
632  s->internal->id3v2_meta = NULL;
633  } else if (s->internal->id3v2_meta) {
634  av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
636  }
637 
638  if (id3v2_extra_meta) {
639  if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
640  !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
641  if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
642  goto close;
643  if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
644  goto close;
645  if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
646  goto close;
647  } else
648  av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
649  }
650  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
651 
652  if ((ret = avformat_queue_attached_pictures(s)) < 0)
653  goto close;
654 
655  if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
656  s->internal->data_offset = avio_tell(s->pb);
657 
659 
661 
662  for (i = 0; i < s->nb_streams; i++)
664 
665  if (options) {
666  av_dict_free(options);
667  *options = tmp;
668  }
669  *ps = s;
670  return 0;
671 
672 close:
673  if (s->iformat->read_close)
674  s->iformat->read_close(s);
675 fail:
676  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
677  av_dict_free(&tmp);
678  if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
679  avio_closep(&s->pb);
681  *ps = NULL;
682  return ret;
683 }
684 
685 /*******************************************************/
686 
688 {
689  switch (st->codecpar->codec_type) {
690  case AVMEDIA_TYPE_VIDEO:
691  if (s->video_codec_id)
692  st->codecpar->codec_id = s->video_codec_id;
693  break;
694  case AVMEDIA_TYPE_AUDIO:
695  if (s->audio_codec_id)
696  st->codecpar->codec_id = s->audio_codec_id;
697  break;
699  if (s->subtitle_codec_id)
701  break;
702  case AVMEDIA_TYPE_DATA:
703  if (s->data_codec_id)
704  st->codecpar->codec_id = s->data_codec_id;
705  break;
706  }
707 }
708 
709 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
710 {
711  if (st->request_probe>0) {
712  AVProbeData *pd = &st->probe_data;
713  int end;
714  av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
715  --st->probe_packets;
716 
717  if (pkt) {
718  uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
719  if (!new_buf) {
721  "Failed to reallocate probe buffer for stream %d\n",
722  st->index);
723  goto no_packet;
724  }
725  pd->buf = new_buf;
726  memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
727  pd->buf_size += pkt->size;
728  memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
729  } else {
730 no_packet:
731  st->probe_packets = 0;
732  if (!pd->buf_size) {
734  "nothing to probe for stream %d\n", st->index);
735  }
736  }
737 
739  || st->probe_packets<= 0;
740 
741  if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
742  int score = set_codec_from_probe_data(s, st, pd);
744  || end) {
745  pd->buf_size = 0;
746  av_freep(&pd->buf);
747  st->request_probe = -1;
748  if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
749  av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
750  } else
751  av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
752  }
753  force_codec_ids(s, st);
754  }
755  }
756  return 0;
757 }
758 
759 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
760 {
761  int64_t ref = pkt->dts;
762  int i, pts_wrap_behavior;
763  int64_t pts_wrap_reference;
764  AVProgram *first_program;
765 
766  if (ref == AV_NOPTS_VALUE)
767  ref = pkt->pts;
768  if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
769  return 0;
770  ref &= (1LL << st->pts_wrap_bits)-1;
771 
772  // reference time stamp should be 60 s before first time stamp
773  pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
774  // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
775  pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
776  (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
778 
779  first_program = av_find_program_from_stream(s, NULL, stream_index);
780 
781  if (!first_program) {
782  int default_stream_index = av_find_default_stream_index(s);
783  if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
784  for (i = 0; i < s->nb_streams; i++) {
786  continue;
787  s->streams[i]->pts_wrap_reference = pts_wrap_reference;
788  s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
789  }
790  }
791  else {
792  st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
793  st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
794  }
795  }
796  else {
797  AVProgram *program = first_program;
798  while (program) {
799  if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
800  pts_wrap_reference = program->pts_wrap_reference;
801  pts_wrap_behavior = program->pts_wrap_behavior;
802  break;
803  }
804  program = av_find_program_from_stream(s, program, stream_index);
805  }
806 
807  // update every program with differing pts_wrap_reference
808  program = first_program;
809  while (program) {
810  if (program->pts_wrap_reference != pts_wrap_reference) {
811  for (i = 0; i<program->nb_stream_indexes; i++) {
812  s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
813  s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
814  }
815 
816  program->pts_wrap_reference = pts_wrap_reference;
817  program->pts_wrap_behavior = pts_wrap_behavior;
818  }
819  program = av_find_program_from_stream(s, program, stream_index);
820  }
821  }
822  return 1;
823 }
824 
826 {
827  int ret, i, err;
828  AVStream *st;
829 
830  pkt->data = NULL;
831  pkt->size = 0;
832  av_init_packet(pkt);
833 
834  for (;;) {
836  const AVPacket *pkt1;
837 
838  if (pktl) {
839  st = s->streams[pktl->pkt.stream_index];
841  if ((err = probe_codec(s, st, NULL)) < 0)
842  return err;
843  if (st->request_probe <= 0) {
845  &s->internal->raw_packet_buffer_end, pkt);
847  return 0;
848  }
849  }
850 
851  ret = s->iformat->read_packet(s, pkt);
852  if (ret < 0) {
853  av_packet_unref(pkt);
854 
855  /* Some demuxers return FFERROR_REDO when they consume
856  data and discard it (ignored streams, junk, extradata).
857  We must re-call the demuxer to get the real packet. */
858  if (ret == FFERROR_REDO)
859  continue;
860  if (!pktl || ret == AVERROR(EAGAIN))
861  return ret;
862  for (i = 0; i < s->nb_streams; i++) {
863  st = s->streams[i];
864  if (st->probe_packets || st->request_probe > 0)
865  if ((err = probe_codec(s, st, NULL)) < 0)
866  return err;
867  av_assert0(st->request_probe <= 0);
868  }
869  continue;
870  }
871 
872  err = av_packet_make_refcounted(pkt);
873  if (err < 0) {
874  av_packet_unref(pkt);
875  return err;
876  }
877 
878  if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
880  "Packet corrupt (stream = %d, dts = %s)",
881  pkt->stream_index, av_ts2str(pkt->dts));
883  av_log(s, AV_LOG_WARNING, ", dropping it.\n");
884  av_packet_unref(pkt);
885  continue;
886  }
887  av_log(s, AV_LOG_WARNING, ".\n");
888  }
889 
890  av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
891  "Invalid stream index.\n");
892 
893  st = s->streams[pkt->stream_index];
894 
896  // correct first time stamps to negative values
897  if (!is_relative(st->first_dts))
898  st->first_dts = wrap_timestamp(st, st->first_dts);
899  if (!is_relative(st->start_time))
900  st->start_time = wrap_timestamp(st, st->start_time);
901  if (!is_relative(st->cur_dts))
902  st->cur_dts = wrap_timestamp(st, st->cur_dts);
903  }
904 
905  pkt->dts = wrap_timestamp(st, pkt->dts);
906  pkt->pts = wrap_timestamp(st, pkt->pts);
907 
908  force_codec_ids(s, st);
909 
910  /* TODO: audio: time filter; video: frame reordering (pts != dts) */
912  pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
913 
914  if (!pktl && st->request_probe <= 0)
915  return ret;
916 
919  pkt, 0);
920  if (err < 0) {
921  av_packet_unref(pkt);
922  return err;
923  }
924  pkt1 = &s->internal->raw_packet_buffer_end->pkt;
926 
927  if ((err = probe_codec(s, st, pkt1)) < 0)
928  return err;
929  }
930 }
931 
932 
933 /**********************************************************/
934 
936 {
937  switch(avctx->codec_id) {
938  case AV_CODEC_ID_MP1:
939  case AV_CODEC_ID_MP2:
940  case AV_CODEC_ID_MP3:
941  case AV_CODEC_ID_CODEC2:
942  return 1;
943  }
944 
945  return 0;
946 }
947 
948 /**
949  * Return the frame duration in seconds. Return 0 if not available.
950  */
951 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
953 {
954  AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
955  av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
956  int frame_size, sample_rate;
957 
958 #if FF_API_LAVF_AVCTX
960  if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
961  codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
963 #endif
964 
965  *pnum = 0;
966  *pden = 0;
967  switch (st->codecpar->codec_type) {
968  case AVMEDIA_TYPE_VIDEO:
969  if (st->r_frame_rate.num && !pc && s->iformat) {
970  *pnum = st->r_frame_rate.den;
971  *pden = st->r_frame_rate.num;
972  } else if (st->time_base.num * 1000LL > st->time_base.den) {
973  *pnum = st->time_base.num;
974  *pden = st->time_base.den;
975  } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
977  av_reduce(pnum, pden,
978  codec_framerate.den,
979  codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
980  INT_MAX);
981 
982  if (pc && pc->repeat_pict) {
983  av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
984  av_reduce(pnum, pden,
985  (*pnum) * (1LL + pc->repeat_pict),
986  (*pden),
987  INT_MAX);
988  }
989  /* If this codec can be interlaced or progressive then we need
990  * a parser to compute duration of a packet. Thus if we have
991  * no parser in such case leave duration undefined. */
992  if (st->internal->avctx->ticks_per_frame > 1 && !pc)
993  *pnum = *pden = 0;
994  }
995  break;
996  case AVMEDIA_TYPE_AUDIO:
997  if (st->internal->avctx_inited) {
998  frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
999  sample_rate = st->internal->avctx->sample_rate;
1000  } else {
1001  frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
1002  sample_rate = st->codecpar->sample_rate;
1003  }
1004  if (frame_size <= 0 || sample_rate <= 0)
1005  break;
1006  *pnum = frame_size;
1007  *pden = sample_rate;
1008  break;
1009  default:
1010  break;
1011  }
1012 }
1013 
1015 {
1017  if (!d)
1018  return 0;
1019  if ((d->type == AVMEDIA_TYPE_VIDEO || d->type == AVMEDIA_TYPE_AUDIO) &&
1021  return 0;
1022  return 1;
1023 }
1024 
1026 {
1027  if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
1028  if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
1029  return 1;
1030 #if CONFIG_H264_DECODER
1031  if (st->internal->avctx->has_b_frames &&
1033  return 1;
1034 #endif
1035  if (st->internal->avctx->has_b_frames<3)
1036  return st->nb_decoded_frames >= 7;
1037  else if (st->internal->avctx->has_b_frames<4)
1038  return st->nb_decoded_frames >= 18;
1039  else
1040  return st->nb_decoded_frames >= 20;
1041 }
1042 
1044 {
1045  if (pktl->next)
1046  return pktl->next;
1047  if (pktl == s->internal->packet_buffer_end)
1048  return s->internal->parse_queue;
1049  return NULL;
1050 }
1051 
1052 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1053  int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1055 
1056  if(!onein_oneout) {
1057  int delay = st->internal->avctx->has_b_frames;
1058  int i;
1059 
1060  if (dts == AV_NOPTS_VALUE) {
1061  int64_t best_score = INT64_MAX;
1062  for (i = 0; i<delay; i++) {
1063  if (st->pts_reorder_error_count[i]) {
1064  int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1065  if (score < best_score) {
1066  best_score = score;
1067  dts = pts_buffer[i];
1068  }
1069  }
1070  }
1071  } else {
1072  for (i = 0; i<delay; i++) {
1073  if (pts_buffer[i] != AV_NOPTS_VALUE) {
1074  int64_t diff = FFABS(pts_buffer[i] - dts)
1075  + (uint64_t)st->pts_reorder_error[i];
1076  diff = FFMAX(diff, st->pts_reorder_error[i]);
1077  st->pts_reorder_error[i] = diff;
1078  st->pts_reorder_error_count[i]++;
1079  if (st->pts_reorder_error_count[i] > 250) {
1080  st->pts_reorder_error[i] >>= 1;
1081  st->pts_reorder_error_count[i] >>= 1;
1082  }
1083  }
1084  }
1085  }
1086  }
1087 
1088  if (dts == AV_NOPTS_VALUE)
1089  dts = pts_buffer[0];
1090 
1091  return dts;
1092 }
1093 
1094 /**
1095  * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1096  * of the packets in a window.
1097  */
1098 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1099  AVPacketList *pkt_buffer)
1100 {
1101  AVStream *st = s->streams[stream_index];
1102  int delay = st->internal->avctx->has_b_frames;
1103  int i;
1104 
1105  int64_t pts_buffer[MAX_REORDER_DELAY+1];
1106 
1107  for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1108  pts_buffer[i] = AV_NOPTS_VALUE;
1109 
1110  for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1111  if (pkt_buffer->pkt.stream_index != stream_index)
1112  continue;
1113 
1114  if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1115  pts_buffer[0] = pkt_buffer->pkt.pts;
1116  for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1117  FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1118 
1119  pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1120  }
1121  }
1122 }
1123 
1124 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1125  int64_t dts, int64_t pts, AVPacket *pkt)
1126 {
1127  AVStream *st = s->streams[stream_index];
1129  AVPacketList *pktl_it;
1130 
1131  uint64_t shift;
1132 
1133  if (st->first_dts != AV_NOPTS_VALUE ||
1134  dts == AV_NOPTS_VALUE ||
1135  st->cur_dts == AV_NOPTS_VALUE ||
1136  st->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
1137  is_relative(dts))
1138  return;
1139 
1140  st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1141  st->cur_dts = dts;
1142  shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1143 
1144  if (is_relative(pts))
1145  pts += shift;
1146 
1147  for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1148  if (pktl_it->pkt.stream_index != stream_index)
1149  continue;
1150  if (is_relative(pktl_it->pkt.pts))
1151  pktl_it->pkt.pts += shift;
1152 
1153  if (is_relative(pktl_it->pkt.dts))
1154  pktl_it->pkt.dts += shift;
1155 
1156  if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1157  st->start_time = pktl_it->pkt.pts;
1159  st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1160  }
1161  }
1162 
1164  update_dts_from_pts(s, stream_index, pktl);
1165  }
1166 
1167  if (st->start_time == AV_NOPTS_VALUE) {
1168  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) {
1169  st->start_time = pts;
1170  }
1172  st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1173  }
1174 }
1175 
1177  int stream_index, int64_t duration)
1178 {
1180  int64_t cur_dts = RELATIVE_TS_BASE;
1181 
1182  if (st->first_dts != AV_NOPTS_VALUE) {
1184  return;
1186  cur_dts = st->first_dts;
1187  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1188  if (pktl->pkt.stream_index == stream_index) {
1189  if (pktl->pkt.pts != pktl->pkt.dts ||
1190  pktl->pkt.dts != AV_NOPTS_VALUE ||
1191  pktl->pkt.duration)
1192  break;
1193  cur_dts -= duration;
1194  }
1195  }
1196  if (pktl && pktl->pkt.dts != st->first_dts) {
1197  av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1198  av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1199  return;
1200  }
1201  if (!pktl) {
1202  av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1203  return;
1204  }
1206  st->first_dts = cur_dts;
1207  } else if (st->cur_dts != RELATIVE_TS_BASE)
1208  return;
1209 
1210  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1211  if (pktl->pkt.stream_index != stream_index)
1212  continue;
1213  if ((pktl->pkt.pts == pktl->pkt.dts ||
1214  pktl->pkt.pts == AV_NOPTS_VALUE) &&
1215  (pktl->pkt.dts == AV_NOPTS_VALUE ||
1216  pktl->pkt.dts == st->first_dts ||
1217  pktl->pkt.dts == RELATIVE_TS_BASE) &&
1218  !pktl->pkt.duration) {
1219  pktl->pkt.dts = cur_dts;
1220  if (!st->internal->avctx->has_b_frames)
1221  pktl->pkt.pts = cur_dts;
1222 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1223  pktl->pkt.duration = duration;
1224  } else
1225  break;
1226  cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1227  }
1228  if (!pktl)
1229  st->cur_dts = cur_dts;
1230 }
1231 
1234  int64_t next_dts, int64_t next_pts)
1235 {
1236  int num, den, presentation_delayed, delay, i;
1237  int64_t offset;
1239  int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1241 
1242  if (s->flags & AVFMT_FLAG_NOFILLIN)
1243  return;
1244 
1245  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1246  if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1247  if (st->last_dts_for_order_check <= pkt->dts) {
1248  st->dts_ordered++;
1249  } else {
1251  "DTS %"PRIi64" < %"PRIi64" out of order\n",
1252  pkt->dts,
1254  st->dts_misordered++;
1255  }
1256  if (st->dts_ordered + st->dts_misordered > 250) {
1257  st->dts_ordered >>= 1;
1258  st->dts_misordered >>= 1;
1259  }
1260  }
1261 
1262  st->last_dts_for_order_check = pkt->dts;
1263  if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1264  pkt->dts = AV_NOPTS_VALUE;
1265  }
1266 
1267  if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1268  pkt->dts = AV_NOPTS_VALUE;
1269 
1270  if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1271  && !st->internal->avctx->has_b_frames)
1272  //FIXME Set low_delay = 0 when has_b_frames = 1
1273  st->internal->avctx->has_b_frames = 1;
1274 
1275  /* do we have a video B-frame ? */
1276  delay = st->internal->avctx->has_b_frames;
1277  presentation_delayed = 0;
1278 
1279  /* XXX: need has_b_frame, but cannot get it if the codec is
1280  * not initialized */
1281  if (delay &&
1282  pc && pc->pict_type != AV_PICTURE_TYPE_B)
1283  presentation_delayed = 1;
1284 
1285  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1286  st->pts_wrap_bits < 63 &&
1287  pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1288  if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1289  pkt->dts -= 1LL << st->pts_wrap_bits;
1290  } else
1291  pkt->pts += 1LL << st->pts_wrap_bits;
1292  }
1293 
1294  /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1295  * We take the conservative approach and discard both.
1296  * Note: If this is misbehaving for an H.264 file, then possibly
1297  * presentation_delayed is not set correctly. */
1298  if (delay == 1 && pkt->dts == pkt->pts &&
1299  pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1300  av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1301  if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1302  && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1303  pkt->dts = AV_NOPTS_VALUE;
1304  }
1305 
1306  duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1307  if (pkt->duration <= 0) {
1308  ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1309  if (den && num) {
1310  duration = (AVRational) {num, den};
1311  pkt->duration = av_rescale_rnd(1,
1312  num * (int64_t) st->time_base.den,
1313  den * (int64_t) st->time_base.num,
1314  AV_ROUND_DOWN);
1315  }
1316  }
1317 
1318  if (pkt->duration > 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1319  update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1320 
1321  /* Correct timestamps with byte offset if demuxers only have timestamps
1322  * on packet boundaries */
1323  if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1324  /* this will estimate bitrate based on this frame's duration and size */
1325  offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1326  if (pkt->pts != AV_NOPTS_VALUE)
1327  pkt->pts += offset;
1328  if (pkt->dts != AV_NOPTS_VALUE)
1329  pkt->dts += offset;
1330  }
1331 
1332  /* This may be redundant, but it should not hurt. */
1333  if (pkt->dts != AV_NOPTS_VALUE &&
1334  pkt->pts != AV_NOPTS_VALUE &&
1335  pkt->pts > pkt->dts)
1336  presentation_delayed = 1;
1337 
1338  if (s->debug & FF_FDEBUG_TS)
1339  av_log(s, AV_LOG_DEBUG,
1340  "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1341  presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1342  pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1343 
1344  /* Interpolate PTS and DTS if they are not present. We skip H264
1345  * currently because delay and has_b_frames are not reliably set. */
1346  if ((delay == 0 || (delay == 1 && pc)) &&
1347  onein_oneout) {
1348  if (presentation_delayed) {
1349  /* DTS = decompression timestamp */
1350  /* PTS = presentation timestamp */
1351  if (pkt->dts == AV_NOPTS_VALUE)
1352  pkt->dts = st->last_IP_pts;
1353  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1354  if (pkt->dts == AV_NOPTS_VALUE)
1355  pkt->dts = st->cur_dts;
1356 
1357  /* This is tricky: the dts must be incremented by the duration
1358  * of the frame we are displaying, i.e. the last I- or P-frame. */
1359  if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1360  st->last_IP_duration = pkt->duration;
1361  if (pkt->dts != AV_NOPTS_VALUE)
1362  st->cur_dts = av_sat_add64(pkt->dts, st->last_IP_duration);
1363  if (pkt->dts != AV_NOPTS_VALUE &&
1364  pkt->pts == AV_NOPTS_VALUE &&
1365  st->last_IP_duration > 0 &&
1366  ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1367  next_dts != next_pts &&
1368  next_pts != AV_NOPTS_VALUE)
1369  pkt->pts = next_dts;
1370 
1371  if ((uint64_t)pkt->duration <= INT32_MAX)
1372  st->last_IP_duration = pkt->duration;
1373  st->last_IP_pts = pkt->pts;
1374  /* Cannot compute PTS if not present (we can compute it only
1375  * by knowing the future. */
1376  } else if (pkt->pts != AV_NOPTS_VALUE ||
1377  pkt->dts != AV_NOPTS_VALUE ||
1378  pkt->duration > 0 ) {
1379 
1380  /* presentation is not delayed : PTS and DTS are the same */
1381  if (pkt->pts == AV_NOPTS_VALUE)
1382  pkt->pts = pkt->dts;
1384  pkt->pts, pkt);
1385  if (pkt->pts == AV_NOPTS_VALUE)
1386  pkt->pts = st->cur_dts;
1387  pkt->dts = pkt->pts;
1388  if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1389  st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1390  }
1391  }
1392 
1393  if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1394  st->pts_buffer[0] = pkt->pts;
1395  for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1396  FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1397 
1399  pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1400  }
1401  // We skipped it above so we try here.
1402  if (!onein_oneout)
1403  // This should happen on the first packet
1404  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1405  if (pkt->dts > st->cur_dts)
1406  st->cur_dts = pkt->dts;
1407 
1408  if (s->debug & FF_FDEBUG_TS)
1409  av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1410  presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
1411 
1412  /* update flags */
1414  pkt->flags |= AV_PKT_FLAG_KEY;
1415 #if FF_API_CONVERGENCE_DURATION
1417  if (pc)
1418  pkt->convergence_duration = pc->convergence_duration;
1420 #endif
1421 }
1422 
1423 void ff_packet_list_free(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1424 {
1425  AVPacketList *tmp = *pkt_buf;
1426 
1427  while (tmp) {
1428  AVPacketList *pktl = tmp;
1429  tmp = pktl->next;
1430  av_packet_unref(&pktl->pkt);
1431  av_freep(&pktl);
1432  }
1433  *pkt_buf = NULL;
1434  *pkt_buf_end = NULL;
1435 }
1436 
1437 /**
1438  * Parse a packet, add all split parts to parse_queue.
1439  *
1440  * @param pkt Packet to parse; must not be NULL.
1441  * @param flush Indicates whether to flush. If set, pkt must be blank.
1442  */
1444  int stream_index, int flush)
1445 {
1446  AVPacket out_pkt;
1447  AVStream *st = s->streams[stream_index];
1448  uint8_t *data = pkt->data;
1449  int size = pkt->size;
1450  int ret = 0, got_output = flush;
1451 
1452  if (size || flush) {
1453  av_init_packet(&out_pkt);
1454  } else if (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1455  // preserve 0-size sync packets
1457  }
1458 
1459  while (size > 0 || (flush && got_output)) {
1460  int len;
1461  int64_t next_pts = pkt->pts;
1462  int64_t next_dts = pkt->dts;
1463 
1464  len = av_parser_parse2(st->parser, st->internal->avctx,
1465  &out_pkt.data, &out_pkt.size, data, size,
1466  pkt->pts, pkt->dts, pkt->pos);
1467 
1468  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1469  pkt->pos = -1;
1470  /* increment read pointer */
1471  data += len;
1472  size -= len;
1473 
1474  got_output = !!out_pkt.size;
1475 
1476  if (!out_pkt.size)
1477  continue;
1478 
1479  if (pkt->buf && out_pkt.data == pkt->data) {
1480  /* reference pkt->buf only when out_pkt.data is guaranteed to point
1481  * to data in it and not in the parser's internal buffer. */
1482  /* XXX: Ensure this is the case with all parsers when st->parser->flags
1483  * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1484  out_pkt.buf = av_buffer_ref(pkt->buf);
1485  if (!out_pkt.buf) {
1486  ret = AVERROR(ENOMEM);
1487  goto fail;
1488  }
1489  } else {
1490  ret = av_packet_make_refcounted(&out_pkt);
1491  if (ret < 0)
1492  goto fail;
1493  }
1494 
1495  if (pkt->side_data) {
1496  out_pkt.side_data = pkt->side_data;
1497  out_pkt.side_data_elems = pkt->side_data_elems;
1498  pkt->side_data = NULL;
1499  pkt->side_data_elems = 0;
1500  }
1501 
1502  /* set the duration */
1503  out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1505  if (st->internal->avctx->sample_rate > 0) {
1506  out_pkt.duration =
1508  (AVRational) { 1, st->internal->avctx->sample_rate },
1509  st->time_base,
1510  AV_ROUND_DOWN);
1511  }
1512  }
1513 
1514  out_pkt.stream_index = st->index;
1515  out_pkt.pts = st->parser->pts;
1516  out_pkt.dts = st->parser->dts;
1517  out_pkt.pos = st->parser->pos;
1518  out_pkt.flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1519 
1521  out_pkt.pos = st->parser->frame_offset;
1522 
1523  if (st->parser->key_frame == 1 ||
1524  (st->parser->key_frame == -1 &&
1526  out_pkt.flags |= AV_PKT_FLAG_KEY;
1527 
1528  if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1529  out_pkt.flags |= AV_PKT_FLAG_KEY;
1530 
1531  compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1532 
1535  &out_pkt, 0);
1536  if (ret < 0) {
1537  av_packet_unref(&out_pkt);
1538  goto fail;
1539  }
1540  }
1541 
1542  /* end of the stream => close and free the parser */
1543  if (flush) {
1544  av_parser_close(st->parser);
1545  st->parser = NULL;
1546  }
1547 
1548 fail:
1549  av_packet_unref(pkt);
1550  return ret;
1551 }
1552 
1554  AVPacketList **pkt_buffer_end,
1555  AVPacket *pkt)
1556 {
1557  AVPacketList *pktl;
1558  av_assert0(*pkt_buffer);
1559  pktl = *pkt_buffer;
1560  *pkt = pktl->pkt;
1561  *pkt_buffer = pktl->next;
1562  if (!pktl->next)
1563  *pkt_buffer_end = NULL;
1564  av_freep(&pktl);
1565  return 0;
1566 }
1567 
1568 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1569 {
1570  return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1571 }
1572 
1574 {
1575  int ret, i, got_packet = 0;
1576  AVDictionary *metadata = NULL;
1577 
1578  while (!got_packet && !s->internal->parse_queue) {
1579  AVStream *st;
1580 
1581  /* read next packet */
1582  ret = ff_read_packet(s, pkt);
1583  if (ret < 0) {
1584  if (ret == AVERROR(EAGAIN))
1585  return ret;
1586  /* flush the parsers */
1587  for (i = 0; i < s->nb_streams; i++) {
1588  st = s->streams[i];
1589  if (st->parser && st->need_parsing)
1590  parse_packet(s, pkt, st->index, 1);
1591  }
1592  /* all remaining packets are now in parse_queue =>
1593  * really terminate parsing */
1594  break;
1595  }
1596  ret = 0;
1597  st = s->streams[pkt->stream_index];
1598 
1599  /* update context if required */
1600  if (st->internal->need_context_update) {
1601  if (avcodec_is_open(st->internal->avctx)) {
1602  av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1604  st->info->found_decoder = 0;
1605  }
1606 
1607  /* close parser, because it depends on the codec */
1608  if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1609  av_parser_close(st->parser);
1610  st->parser = NULL;
1611  }
1612 
1614  if (ret < 0) {
1615  av_packet_unref(pkt);
1616  return ret;
1617  }
1618 
1619 #if FF_API_LAVF_AVCTX
1621  /* update deprecated public codec context */
1622  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1623  if (ret < 0) {
1624  av_packet_unref(pkt);
1625  return ret;
1626  }
1628 #endif
1629 
1630  st->internal->need_context_update = 0;
1631  }
1632 
1633  if (pkt->pts != AV_NOPTS_VALUE &&
1634  pkt->dts != AV_NOPTS_VALUE &&
1635  pkt->pts < pkt->dts) {
1637  "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1638  pkt->stream_index,
1639  av_ts2str(pkt->pts),
1640  av_ts2str(pkt->dts),
1641  pkt->size);
1642  }
1643  if (s->debug & FF_FDEBUG_TS)
1644  av_log(s, AV_LOG_DEBUG,
1645  "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1646  pkt->stream_index,
1647  av_ts2str(pkt->pts),
1648  av_ts2str(pkt->dts),
1649  pkt->size, pkt->duration, pkt->flags);
1650 
1651  if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1652  st->parser = av_parser_init(st->codecpar->codec_id);
1653  if (!st->parser) {
1654  av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1655  "%s, packets or times may be invalid.\n",
1657  /* no parser available: just output the raw packets */
1659  } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1661  else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1662  st->parser->flags |= PARSER_FLAG_ONCE;
1663  else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1665  }
1666 
1667  if (!st->need_parsing || !st->parser) {
1668  /* no parsing needed: we just output the packet as is */
1670  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1671  (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1672  ff_reduce_index(s, st->index);
1673  av_add_index_entry(st, pkt->pos, pkt->dts,
1674  0, 0, AVINDEX_KEYFRAME);
1675  }
1676  got_packet = 1;
1677  } else if (st->discard < AVDISCARD_ALL) {
1678  if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1679  return ret;
1681  st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1682  st->codecpar->channels = st->internal->avctx->channels;
1684  st->codecpar->codec_id = st->internal->avctx->codec_id;
1685  } else {
1686  /* free packet */
1687  av_packet_unref(pkt);
1688  }
1689  if (pkt->flags & AV_PKT_FLAG_KEY)
1690  st->skip_to_keyframe = 0;
1691  if (st->skip_to_keyframe) {
1692  av_packet_unref(pkt);
1693  got_packet = 0;
1694  }
1695  }
1696 
1697  if (!got_packet && s->internal->parse_queue)
1699 
1700  if (ret >= 0) {
1701  AVStream *st = s->streams[pkt->stream_index];
1702  int discard_padding = 0;
1703  if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1704  int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1705  int64_t sample = ts_to_samples(st, pts);
1706  int duration = ts_to_samples(st, pkt->duration);
1707  int64_t end_sample = sample + duration;
1708  if (duration > 0 && end_sample >= st->first_discard_sample &&
1709  sample < st->last_discard_sample)
1710  discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1711  }
1712  if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1713  st->skip_samples = st->start_skip_samples;
1714  if (st->skip_samples || discard_padding) {
1716  if (p) {
1717  AV_WL32(p, st->skip_samples);
1718  AV_WL32(p + 4, discard_padding);
1719  av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1720  }
1721  st->skip_samples = 0;
1722  }
1723 
1724  if (st->inject_global_side_data) {
1725  for (i = 0; i < st->nb_side_data; i++) {
1726  AVPacketSideData *src_sd = &st->side_data[i];
1727  uint8_t *dst_data;
1728 
1729  if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1730  continue;
1731 
1732  dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1733  if (!dst_data) {
1734  av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1735  continue;
1736  }
1737 
1738  memcpy(dst_data, src_sd->data, src_sd->size);
1739  }
1740  st->inject_global_side_data = 0;
1741  }
1742  }
1743 
1744  av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1745  if (metadata) {
1747  av_dict_copy(&s->metadata, metadata, 0);
1748  av_dict_free(&metadata);
1750  }
1751 
1752 #if FF_API_LAVF_AVCTX
1754 #endif
1755 
1756  if (s->debug & FF_FDEBUG_TS)
1757  av_log(s, AV_LOG_DEBUG,
1758  "read_frame_internal stream=%d, pts=%s, dts=%s, "
1759  "size=%d, duration=%"PRId64", flags=%d\n",
1760  pkt->stream_index,
1761  av_ts2str(pkt->pts),
1762  av_ts2str(pkt->dts),
1763  pkt->size, pkt->duration, pkt->flags);
1764 
1765  /* A demuxer might have returned EOF because of an IO error, let's
1766  * propagate this back to the user. */
1767  if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1768  ret = s->pb->error;
1769 
1770  return ret;
1771 }
1772 
1774 {
1775  const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1776  int eof = 0;
1777  int ret;
1778  AVStream *st;
1779 
1780  if (!genpts) {
1781  ret = s->internal->packet_buffer
1783  &s->internal->packet_buffer_end, pkt)
1784  : read_frame_internal(s, pkt);
1785  if (ret < 0)
1786  return ret;
1787  goto return_packet;
1788  }
1789 
1790  for (;;) {
1791  AVPacketList *pktl = s->internal->packet_buffer;
1792 
1793  if (pktl) {
1794  AVPacket *next_pkt = &pktl->pkt;
1795 
1796  if (next_pkt->dts != AV_NOPTS_VALUE) {
1797  int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1798  // last dts seen for this stream. if any of packets following
1799  // current one had no dts, we will set this to AV_NOPTS_VALUE.
1800  int64_t last_dts = next_pkt->dts;
1801  av_assert2(wrap_bits <= 64);
1802  while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1803  if (pktl->pkt.stream_index == next_pkt->stream_index &&
1804  av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1805  if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1806  // not B-frame
1807  next_pkt->pts = pktl->pkt.dts;
1808  }
1809  if (last_dts != AV_NOPTS_VALUE) {
1810  // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1811  last_dts = pktl->pkt.dts;
1812  }
1813  }
1814  pktl = pktl->next;
1815  }
1816  if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1817  // Fixing the last reference frame had none pts issue (For MXF etc).
1818  // We only do this when
1819  // 1. eof.
1820  // 2. we are not able to resolve a pts value for current packet.
1821  // 3. the packets for this stream at the end of the files had valid dts.
1822  next_pkt->pts = last_dts + next_pkt->duration;
1823  }
1824  pktl = s->internal->packet_buffer;
1825  }
1826 
1827  /* read packet from packet buffer, if there is data */
1828  st = s->streams[next_pkt->stream_index];
1829  if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1830  next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1832  &s->internal->packet_buffer_end, pkt);
1833  goto return_packet;
1834  }
1835  }
1836 
1837  ret = read_frame_internal(s, pkt);
1838  if (ret < 0) {
1839  if (pktl && ret != AVERROR(EAGAIN)) {
1840  eof = 1;
1841  continue;
1842  } else
1843  return ret;
1844  }
1845 
1848  pkt, 0);
1849  if (ret < 0) {
1850  av_packet_unref(pkt);
1851  return ret;
1852  }
1853  }
1854 
1855 return_packet:
1856 
1857  st = s->streams[pkt->stream_index];
1858  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1859  ff_reduce_index(s, st->index);
1860  av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1861  }
1862 
1863  if (is_relative(pkt->dts))
1864  pkt->dts -= RELATIVE_TS_BASE;
1865  if (is_relative(pkt->pts))
1866  pkt->pts -= RELATIVE_TS_BASE;
1867 
1868  return ret;
1869 }
1870 
1871 /* XXX: suppress the packet queue */
1873 {
1874  if (!s->internal)
1875  return;
1879 
1881 }
1882 
1883 /*******************************************************/
1884 /* seek support */
1885 
1887 {
1888  int i;
1889  AVStream *st;
1890  int best_stream = 0;
1891  int best_score = INT_MIN;
1892 
1893  if (s->nb_streams <= 0)
1894  return -1;
1895  for (i = 0; i < s->nb_streams; i++) {
1896  int score = 0;
1897  st = s->streams[i];
1898  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1900  score -= 400;
1901  if (st->codecpar->width && st->codecpar->height)
1902  score += 50;
1903  score+= 25;
1904  }
1905  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1906  if (st->codecpar->sample_rate)
1907  score += 50;
1908  }
1909  if (st->codec_info_nb_frames)
1910  score += 12;
1911 
1912  if (st->discard != AVDISCARD_ALL)
1913  score += 200;
1914 
1915  if (score > best_score) {
1916  best_score = score;
1917  best_stream = i;
1918  }
1919  }
1920  return best_stream;
1921 }
1922 
1923 /** Flush the frame reader. */
1925 {
1926  AVStream *st;
1927  int i, j;
1928 
1929  flush_packet_queue(s);
1930 
1931  /* Reset read state for each stream. */
1932  for (i = 0; i < s->nb_streams; i++) {
1933  st = s->streams[i];
1934 
1935  if (st->parser) {
1936  av_parser_close(st->parser);
1937  st->parser = NULL;
1938  }
1941  if (st->first_dts == AV_NOPTS_VALUE)
1942  st->cur_dts = RELATIVE_TS_BASE;
1943  else
1944  /* We set the current DTS to an unspecified origin. */
1945  st->cur_dts = AV_NOPTS_VALUE;
1946 
1948 
1949  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1950  st->pts_buffer[j] = AV_NOPTS_VALUE;
1951 
1953  st->inject_global_side_data = 1;
1954 
1955  st->skip_samples = 0;
1956  }
1957 }
1958 
1959 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1960 {
1961  int i;
1962 
1963  for (i = 0; i < s->nb_streams; i++) {
1964  AVStream *st = s->streams[i];
1965 
1966  st->cur_dts =
1967  av_rescale(timestamp,
1968  st->time_base.den * (int64_t) ref_st->time_base.num,
1969  st->time_base.num * (int64_t) ref_st->time_base.den);
1970  }
1971 }
1972 
1973 void ff_reduce_index(AVFormatContext *s, int stream_index)
1974 {
1975  AVStream *st = s->streams[stream_index];
1976  unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1977 
1978  if ((unsigned) st->nb_index_entries >= max_entries) {
1979  int i;
1980  for (i = 0; 2 * i < st->nb_index_entries; i++)
1981  st->index_entries[i] = st->index_entries[2 * i];
1982  st->nb_index_entries = i;
1983  }
1984 }
1985 
1986 int ff_add_index_entry(AVIndexEntry **index_entries,
1987  int *nb_index_entries,
1988  unsigned int *index_entries_allocated_size,
1989  int64_t pos, int64_t timestamp,
1990  int size, int distance, int flags)
1991 {
1992  AVIndexEntry *entries, *ie;
1993  int index;
1994 
1995  if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1996  return -1;
1997 
1998  if (timestamp == AV_NOPTS_VALUE)
1999  return AVERROR(EINVAL);
2000 
2001  if (size < 0 || size > 0x3FFFFFFF)
2002  return AVERROR(EINVAL);
2003 
2004  if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
2005  timestamp -= RELATIVE_TS_BASE;
2006 
2007  entries = av_fast_realloc(*index_entries,
2008  index_entries_allocated_size,
2009  (*nb_index_entries + 1) *
2010  sizeof(AVIndexEntry));
2011  if (!entries)
2012  return -1;
2013 
2014  *index_entries = entries;
2015 
2016  index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
2017  timestamp, AVSEEK_FLAG_ANY);
2018 
2019  if (index < 0) {
2020  index = (*nb_index_entries)++;
2021  ie = &entries[index];
2022  av_assert0(index == 0 || ie[-1].timestamp < timestamp);
2023  } else {
2024  ie = &entries[index];
2025  if (ie->timestamp != timestamp) {
2026  if (ie->timestamp <= timestamp)
2027  return -1;
2028  memmove(entries + index + 1, entries + index,
2029  sizeof(AVIndexEntry) * (*nb_index_entries - index));
2030  (*nb_index_entries)++;
2031  } else if (ie->pos == pos && distance < ie->min_distance)
2032  // do not reduce the distance
2033  distance = ie->min_distance;
2034  }
2035 
2036  ie->pos = pos;
2037  ie->timestamp = timestamp;
2038  ie->min_distance = distance;
2039  ie->size = size;
2040  ie->flags = flags;
2041 
2042  return index;
2043 }
2044 
2045 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
2046  int size, int distance, int flags)
2047 {
2048  timestamp = wrap_timestamp(st, timestamp);
2050  &st->index_entries_allocated_size, pos,
2051  timestamp, size, distance, flags);
2052 }
2053 
2054 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2055  int64_t wanted_timestamp, int flags)
2056 {
2057  int a, b, m;
2058  int64_t timestamp;
2059 
2060  a = -1;
2061  b = nb_entries;
2062 
2063  // Optimize appending index entries at the end.
2064  if (b && entries[b - 1].timestamp < wanted_timestamp)
2065  a = b - 1;
2066 
2067  while (b - a > 1) {
2068  m = (a + b) >> 1;
2069 
2070  // Search for the next non-discarded packet.
2071  while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2072  m++;
2073  if (m == b && entries[m].timestamp >= wanted_timestamp) {
2074  m = b - 1;
2075  break;
2076  }
2077  }
2078 
2079  timestamp = entries[m].timestamp;
2080  if (timestamp >= wanted_timestamp)
2081  b = m;
2082  if (timestamp <= wanted_timestamp)
2083  a = m;
2084  }
2085  m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2086 
2087  if (!(flags & AVSEEK_FLAG_ANY))
2088  while (m >= 0 && m < nb_entries &&
2089  !(entries[m].flags & AVINDEX_KEYFRAME))
2090  m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2091 
2092  if (m == nb_entries)
2093  return -1;
2094  return m;
2095 }
2096 
2097 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2098 {
2099  int ist1, ist2;
2100  int64_t pos_delta = 0;
2101  int64_t skip = 0;
2102  //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2103  const char *proto = avio_find_protocol_name(s->url);
2104 
2105  av_assert0(time_tolerance >= 0);
2106 
2107  if (!proto) {
2108  av_log(s, AV_LOG_INFO,
2109  "Protocol name not provided, cannot determine if input is local or "
2110  "a network protocol, buffers and access patterns cannot be configured "
2111  "optimally without knowing the protocol\n");
2112  }
2113 
2114  if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2115  return;
2116 
2117  for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2118  AVStream *st1 = s->streams[ist1];
2119  for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2120  AVStream *st2 = s->streams[ist2];
2121  int i1, i2;
2122 
2123  if (ist1 == ist2)
2124  continue;
2125 
2126  for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2127  AVIndexEntry *e1 = &st1->index_entries[i1];
2128  int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2129 
2130  skip = FFMAX(skip, e1->size);
2131  for (; i2 < st2->nb_index_entries; i2++) {
2132  AVIndexEntry *e2 = &st2->index_entries[i2];
2133  int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2134  if (e2_pts < e1_pts || e2_pts - (uint64_t)e1_pts < time_tolerance)
2135  continue;
2136  pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2137  break;
2138  }
2139  }
2140  }
2141  }
2142 
2143  pos_delta *= 2;
2144  /* XXX This could be adjusted depending on protocol*/
2145  if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2146  av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2147 
2148  /* realloc the buffer and the original data will be retained */
2149  if (ffio_realloc_buf(s->pb, pos_delta)) {
2150  av_log(s, AV_LOG_ERROR, "Realloc buffer fail.\n");
2151  return;
2152  }
2153 
2154  s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2155  }
2156 
2157  if (skip < (1<<23)) {
2159  }
2160 }
2161 
2162 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2163 {
2165  wanted_timestamp, flags);
2166 }
2167 
2168 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2169  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2170 {
2171  int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2172  if (stream_index >= 0)
2173  ts = wrap_timestamp(s->streams[stream_index], ts);
2174  return ts;
2175 }
2176 
2177 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2178  int64_t target_ts, int flags)
2179 {
2180  const AVInputFormat *avif = s->iformat;
2181  int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2182  int64_t ts_min, ts_max, ts;
2183  int index;
2184  int64_t ret;
2185  AVStream *st;
2186 
2187  if (stream_index < 0)
2188  return -1;
2189 
2190  av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2191 
2192  ts_max =
2193  ts_min = AV_NOPTS_VALUE;
2194  pos_limit = -1; // GCC falsely says it may be uninitialized.
2195 
2196  st = s->streams[stream_index];
2197  if (st->index_entries) {
2198  AVIndexEntry *e;
2199 
2200  /* FIXME: Whole function must be checked for non-keyframe entries in
2201  * index case, especially read_timestamp(). */
2202  index = av_index_search_timestamp(st, target_ts,
2203  flags | AVSEEK_FLAG_BACKWARD);
2204  index = FFMAX(index, 0);
2205  e = &st->index_entries[index];
2206 
2207  if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2208  pos_min = e->pos;
2209  ts_min = e->timestamp;
2210  av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2211  pos_min, av_ts2str(ts_min));
2212  } else {
2213  av_assert1(index == 0);
2214  }
2215 
2216  index = av_index_search_timestamp(st, target_ts,
2217  flags & ~AVSEEK_FLAG_BACKWARD);
2218  av_assert0(index < st->nb_index_entries);
2219  if (index >= 0) {
2220  e = &st->index_entries[index];
2221  av_assert1(e->timestamp >= target_ts);
2222  pos_max = e->pos;
2223  ts_max = e->timestamp;
2224  pos_limit = pos_max - e->min_distance;
2225  av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2226  " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2227  }
2228  }
2229 
2230  pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2231  ts_min, ts_max, flags, &ts, avif->read_timestamp);
2232  if (pos < 0)
2233  return -1;
2234 
2235  /* do the seek */
2236  if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2237  return ret;
2238 
2240  ff_update_cur_dts(s, st, ts);
2241 
2242  return 0;
2243 }
2244 
2245 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2246  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2247 {
2248  int64_t step = 1024;
2249  int64_t limit, ts_max;
2250  int64_t filesize = avio_size(s->pb);
2251  int64_t pos_max = filesize - 1;
2252  do {
2253  limit = pos_max;
2254  pos_max = FFMAX(0, (pos_max) - step);
2255  ts_max = ff_read_timestamp(s, stream_index,
2256  &pos_max, limit, read_timestamp);
2257  step += step;
2258  } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2259  if (ts_max == AV_NOPTS_VALUE)
2260  return -1;
2261 
2262  for (;;) {
2263  int64_t tmp_pos = pos_max + 1;
2264  int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2265  &tmp_pos, INT64_MAX, read_timestamp);
2266  if (tmp_ts == AV_NOPTS_VALUE)
2267  break;
2268  av_assert0(tmp_pos > pos_max);
2269  ts_max = tmp_ts;
2270  pos_max = tmp_pos;
2271  if (tmp_pos >= filesize)
2272  break;
2273  }
2274 
2275  if (ts)
2276  *ts = ts_max;
2277  if (pos)
2278  *pos = pos_max;
2279 
2280  return 0;
2281 }
2282 
2283 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2284  int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2285  int64_t ts_min, int64_t ts_max,
2286  int flags, int64_t *ts_ret,
2287  int64_t (*read_timestamp)(struct AVFormatContext *, int,
2288  int64_t *, int64_t))
2289 {
2290  int64_t pos, ts;
2291  int64_t start_pos;
2292  int no_change;
2293  int ret;
2294 
2295  av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2296 
2297  if (ts_min == AV_NOPTS_VALUE) {
2298  pos_min = s->internal->data_offset;
2299  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2300  if (ts_min == AV_NOPTS_VALUE)
2301  return -1;
2302  }
2303 
2304  if (ts_min >= target_ts) {
2305  *ts_ret = ts_min;
2306  return pos_min;
2307  }
2308 
2309  if (ts_max == AV_NOPTS_VALUE) {
2310  if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2311  return ret;
2312  pos_limit = pos_max;
2313  }
2314 
2315  if (ts_max <= target_ts) {
2316  *ts_ret = ts_max;
2317  return pos_max;
2318  }
2319 
2320  av_assert0(ts_min < ts_max);
2321 
2322  no_change = 0;
2323  while (pos_min < pos_limit) {
2324  av_log(s, AV_LOG_TRACE,
2325  "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2326  pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2327  av_assert0(pos_limit <= pos_max);
2328 
2329  if (no_change == 0) {
2330  int64_t approximate_keyframe_distance = pos_max - pos_limit;
2331  // interpolate position (better than dichotomy)
2332  pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2333  ts_max - ts_min) +
2334  pos_min - approximate_keyframe_distance;
2335  } else if (no_change == 1) {
2336  // bisection if interpolation did not change min / max pos last time
2337  pos = (pos_min + pos_limit) >> 1;
2338  } else {
2339  /* linear search if bisection failed, can only happen if there
2340  * are very few or no keyframes between min/max */
2341  pos = pos_min;
2342  }
2343  if (pos <= pos_min)
2344  pos = pos_min + 1;
2345  else if (pos > pos_limit)
2346  pos = pos_limit;
2347  start_pos = pos;
2348 
2349  // May pass pos_limit instead of -1.
2350  ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2351  if (pos == pos_max)
2352  no_change++;
2353  else
2354  no_change = 0;
2355  av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2356  " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2357  pos_min, pos, pos_max,
2358  av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2359  pos_limit, start_pos, no_change);
2360  if (ts == AV_NOPTS_VALUE) {
2361  av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2362  return -1;
2363  }
2364  if (target_ts <= ts) {
2365  pos_limit = start_pos - 1;
2366  pos_max = pos;
2367  ts_max = ts;
2368  }
2369  if (target_ts >= ts) {
2370  pos_min = pos;
2371  ts_min = ts;
2372  }
2373  }
2374 
2375  pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2376  ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2377 #if 0
2378  pos_min = pos;
2379  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2380  pos_min++;
2381  ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2382  av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2383  pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2384 #endif
2385  *ts_ret = ts;
2386  return pos;
2387 }
2388 
2389 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2390  int64_t pos, int flags)
2391 {
2392  int64_t pos_min, pos_max;
2393 
2394  pos_min = s->internal->data_offset;
2395  pos_max = avio_size(s->pb) - 1;
2396 
2397  if (pos < pos_min)
2398  pos = pos_min;
2399  else if (pos > pos_max)
2400  pos = pos_max;
2401 
2402  avio_seek(s->pb, pos, SEEK_SET);
2403 
2404  s->io_repositioned = 1;
2405 
2406  return 0;
2407 }
2408 
2409 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2410  int64_t timestamp, int flags)
2411 {
2412  int index;
2413  int64_t ret;
2414  AVStream *st;
2415  AVIndexEntry *ie;
2416 
2417  st = s->streams[stream_index];
2418 
2419  index = av_index_search_timestamp(st, timestamp, flags);
2420 
2421  if (index < 0 && st->nb_index_entries &&
2422  timestamp < st->index_entries[0].timestamp)
2423  return -1;
2424 
2425  if (index < 0 || index == st->nb_index_entries - 1) {
2426  AVPacket pkt;
2427  int nonkey = 0;
2428 
2429  if (st->nb_index_entries) {
2431  ie = &st->index_entries[st->nb_index_entries - 1];
2432  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2433  return ret;
2434  ff_update_cur_dts(s, st, ie->timestamp);
2435  } else {
2436  if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2437  return ret;
2438  }
2439  for (;;) {
2440  int read_status;
2441  do {
2442  read_status = av_read_frame(s, &pkt);
2443  } while (read_status == AVERROR(EAGAIN));
2444  if (read_status < 0)
2445  break;
2446  if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2447  if (pkt.flags & AV_PKT_FLAG_KEY) {
2448  av_packet_unref(&pkt);
2449  break;
2450  }
2451  if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2452  av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
2453  av_packet_unref(&pkt);
2454  break;
2455  }
2456  }
2457  av_packet_unref(&pkt);
2458  }
2459  index = av_index_search_timestamp(st, timestamp, flags);
2460  }
2461  if (index < 0)
2462  return -1;
2463 
2465  if (s->iformat->read_seek)
2466  if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2467  return 0;
2468  ie = &st->index_entries[index];
2469  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2470  return ret;
2471  ff_update_cur_dts(s, st, ie->timestamp);
2472 
2473  return 0;
2474 }
2475 
2476 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2477  int64_t timestamp, int flags)
2478 {
2479  int ret;
2480  AVStream *st;
2481 
2482  if (flags & AVSEEK_FLAG_BYTE) {
2483  if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2484  return -1;
2486  return seek_frame_byte(s, stream_index, timestamp, flags);
2487  }
2488 
2489  if (stream_index < 0) {
2490  stream_index = av_find_default_stream_index(s);
2491  if (stream_index < 0)
2492  return -1;
2493 
2494  st = s->streams[stream_index];
2495  /* timestamp for default must be expressed in AV_TIME_BASE units */
2496  timestamp = av_rescale(timestamp, st->time_base.den,
2497  AV_TIME_BASE * (int64_t) st->time_base.num);
2498  }
2499 
2500  /* first, we try the format specific seek */
2501  if (s->iformat->read_seek) {
2503  ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2504  } else
2505  ret = -1;
2506  if (ret >= 0)
2507  return 0;
2508 
2509  if (s->iformat->read_timestamp &&
2510  !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2512  return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2513  } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2515  return seek_frame_generic(s, stream_index, timestamp, flags);
2516  } else
2517  return -1;
2518 }
2519 
2520 int av_seek_frame(AVFormatContext *s, int stream_index,
2521  int64_t timestamp, int flags)
2522 {
2523  int ret;
2524 
2525  if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2526  int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2527  if ((flags & AVSEEK_FLAG_BACKWARD))
2528  max_ts = timestamp;
2529  else
2530  min_ts = timestamp;
2531  return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2532  flags & ~AVSEEK_FLAG_BACKWARD);
2533  }
2534 
2535  ret = seek_frame_internal(s, stream_index, timestamp, flags);
2536 
2537  if (ret >= 0)
2539 
2540  return ret;
2541 }
2542 
2543 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2544  int64_t ts, int64_t max_ts, int flags)
2545 {
2546  if (min_ts > ts || max_ts < ts)
2547  return -1;
2548  if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2549  return AVERROR(EINVAL);
2550 
2551  if (s->seek2any>0)
2552  flags |= AVSEEK_FLAG_ANY;
2553  flags &= ~AVSEEK_FLAG_BACKWARD;
2554 
2555  if (s->iformat->read_seek2) {
2556  int ret;
2558 
2559  if (stream_index == -1 && s->nb_streams == 1) {
2560  AVRational time_base = s->streams[0]->time_base;
2561  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2562  min_ts = av_rescale_rnd(min_ts, time_base.den,
2563  time_base.num * (int64_t)AV_TIME_BASE,
2565  max_ts = av_rescale_rnd(max_ts, time_base.den,
2566  time_base.num * (int64_t)AV_TIME_BASE,
2568  stream_index = 0;
2569  }
2570 
2571  ret = s->iformat->read_seek2(s, stream_index, min_ts,
2572  ts, max_ts, flags);
2573 
2574  if (ret >= 0)
2576  return ret;
2577  }
2578 
2579  if (s->iformat->read_timestamp) {
2580  // try to seek via read_timestamp()
2581  }
2582 
2583  // Fall back on old API if new is not implemented but old is.
2584  // Note the old API has somewhat different semantics.
2585  if (s->iformat->read_seek || 1) {
2586  int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2587  int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2588  if (ret<0 && ts != min_ts && max_ts != ts) {
2589  ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2590  if (ret >= 0)
2591  ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2592  }
2593  return ret;
2594  }
2595 
2596  // try some generic seek like seek_frame_generic() but with new ts semantics
2597  return -1; //unreachable
2598 }
2599 
2601 {
2603  return 0;
2604 }
2605 
2606 /*******************************************************/
2607 
2608 /**
2609  * Return TRUE if the stream has accurate duration in any stream.
2610  *
2611  * @return TRUE if the stream has accurate duration for at least one component.
2612  */
2614 {
2615  int i;
2616  AVStream *st;
2617 
2618  for (i = 0; i < ic->nb_streams; i++) {
2619  st = ic->streams[i];
2620  if (st->duration != AV_NOPTS_VALUE)
2621  return 1;
2622  }
2623  if (ic->duration != AV_NOPTS_VALUE)
2624  return 1;
2625  return 0;
2626 }
2627 
2628 /**
2629  * Estimate the stream timings from the one of each components.
2630  *
2631  * Also computes the global bitrate if possible.
2632  */
2634 {
2635  int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2636  int64_t duration, duration1, duration_text, filesize;
2637  int i;
2638  AVProgram *p;
2639 
2640  start_time = INT64_MAX;
2641  start_time_text = INT64_MAX;
2642  end_time = INT64_MIN;
2643  end_time_text = INT64_MIN;
2644  duration = INT64_MIN;
2645  duration_text = INT64_MIN;
2646 
2647  for (i = 0; i < ic->nb_streams; i++) {
2648  AVStream *st = ic->streams[i];
2649  int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2651  if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2652  start_time1 = av_rescale_q(st->start_time, st->time_base,
2653  AV_TIME_BASE_Q);
2654  if (is_text)
2655  start_time_text = FFMIN(start_time_text, start_time1);
2656  else
2657  start_time = FFMIN(start_time, start_time1);
2658  end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2661  if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2662  end_time1 += start_time1;
2663  if (is_text)
2664  end_time_text = FFMAX(end_time_text, end_time1);
2665  else
2666  end_time = FFMAX(end_time, end_time1);
2667  }
2668  for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2669  if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2670  p->start_time = start_time1;
2671  if (p->end_time < end_time1)
2672  p->end_time = end_time1;
2673  }
2674  }
2675  if (st->duration != AV_NOPTS_VALUE) {
2676  duration1 = av_rescale_q(st->duration, st->time_base,
2677  AV_TIME_BASE_Q);
2678  if (is_text)
2679  duration_text = FFMAX(duration_text, duration1);
2680  else
2681  duration = FFMAX(duration, duration1);
2682  }
2683  }
2684  if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2685  start_time = start_time_text;
2686  else if (start_time > start_time_text)
2687  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2688 
2689  if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2690  end_time = end_time_text;
2691  else if (end_time < end_time_text)
2692  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2693 
2694  if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2695  duration = duration_text;
2696  else if (duration < duration_text)
2697  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2698 
2699  if (start_time != INT64_MAX) {
2700  ic->start_time = start_time;
2701  if (end_time != INT64_MIN) {
2702  if (ic->nb_programs > 1) {
2703  for (i = 0; i < ic->nb_programs; i++) {
2704  p = ic->programs[i];
2705  if (p->start_time != AV_NOPTS_VALUE &&
2706  p->end_time > p->start_time &&
2707  p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2708  duration = FFMAX(duration, p->end_time - p->start_time);
2709  }
2710  } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2711  duration = FFMAX(duration, end_time - start_time);
2712  }
2713  }
2714  }
2715  if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2716  ic->duration = duration;
2717  }
2718  if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2719  /* compute the bitrate */
2720  double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2721  (double) ic->duration;
2722  if (bitrate >= 0 && bitrate <= INT64_MAX)
2723  ic->bit_rate = bitrate;
2724  }
2725 }
2726 
2728 {
2729  int i;
2730  AVStream *st;
2731 
2733  for (i = 0; i < ic->nb_streams; i++) {
2734  st = ic->streams[i];
2735  if (st->start_time == AV_NOPTS_VALUE) {
2736  if (ic->start_time != AV_NOPTS_VALUE)
2738  st->time_base);
2739  if (ic->duration != AV_NOPTS_VALUE)
2741  st->time_base);
2742  }
2743  }
2744 }
2745 
2747 {
2748  int64_t filesize, duration;
2749  int i, show_warning = 0;
2750  AVStream *st;
2751 
2752  /* if bit_rate is already set, we believe it */
2753  if (ic->bit_rate <= 0) {
2754  int64_t bit_rate = 0;
2755  for (i = 0; i < ic->nb_streams; i++) {
2756  st = ic->streams[i];
2757  if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2758  st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2759  if (st->codecpar->bit_rate > 0) {
2760  if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2761  bit_rate = 0;
2762  break;
2763  }
2764  bit_rate += st->codecpar->bit_rate;
2765  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2766  // If we have a videostream with packets but without a bitrate
2767  // then consider the sum not known
2768  bit_rate = 0;
2769  break;
2770  }
2771  }
2772  ic->bit_rate = bit_rate;
2773  }
2774 
2775  /* if duration is already set, we believe it */
2776  if (ic->duration == AV_NOPTS_VALUE &&
2777  ic->bit_rate != 0) {
2778  filesize = ic->pb ? avio_size(ic->pb) : 0;
2779  if (filesize > ic->internal->data_offset) {
2780  filesize -= ic->internal->data_offset;
2781  for (i = 0; i < ic->nb_streams; i++) {
2782  st = ic->streams[i];
2783  if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2784  && st->duration == AV_NOPTS_VALUE) {
2785  duration = av_rescale(filesize, 8LL * st->time_base.den,
2786  ic->bit_rate *
2787  (int64_t) st->time_base.num);
2788  st->duration = duration;
2789  show_warning = 1;
2790  }
2791  }
2792  }
2793  }
2794  if (show_warning)
2795  av_log(ic, AV_LOG_WARNING,
2796  "Estimating duration from bitrate, this may be inaccurate\n");
2797 }
2798 
2799 #define DURATION_MAX_READ_SIZE 250000LL
2800 #define DURATION_MAX_RETRY 6
2801 
2802 /* only usable for MPEG-PS streams */
2803 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2804 {
2805  AVPacket pkt1, *pkt = &pkt1;
2806  AVStream *st;
2807  int num, den, read_size, i, ret;
2808  int found_duration = 0;
2809  int is_end;
2810  int64_t filesize, offset, duration;
2811  int retry = 0;
2812 
2813  /* flush packet queue */
2814  flush_packet_queue(ic);
2815 
2816  for (i = 0; i < ic->nb_streams; i++) {
2817  st = ic->streams[i];
2818  if (st->start_time == AV_NOPTS_VALUE &&
2819  st->first_dts == AV_NOPTS_VALUE &&
2821  av_log(ic, AV_LOG_WARNING,
2822  "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2823 
2824  if (st->parser) {
2825  av_parser_close(st->parser);
2826  st->parser = NULL;
2827  }
2828  }
2829 
2831  av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2832  goto skip_duration_calc;
2833  }
2834 
2835  av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2836  /* estimate the end time (duration) */
2837  /* XXX: may need to support wrapping */
2838  filesize = ic->pb ? avio_size(ic->pb) : 0;
2839  do {
2840  is_end = found_duration;
2841  offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2842  if (offset < 0)
2843  offset = 0;
2844 
2845  avio_seek(ic->pb, offset, SEEK_SET);
2846  read_size = 0;
2847  for (;;) {
2848  if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2849  break;
2850 
2851  do {
2852  ret = ff_read_packet(ic, pkt);
2853  } while (ret == AVERROR(EAGAIN));
2854  if (ret != 0)
2855  break;
2856  read_size += pkt->size;
2857  st = ic->streams[pkt->stream_index];
2858  if (pkt->pts != AV_NOPTS_VALUE &&
2859  (st->start_time != AV_NOPTS_VALUE ||
2860  st->first_dts != AV_NOPTS_VALUE)) {
2861  if (pkt->duration == 0) {
2862  ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2863  if (den && num) {
2864  pkt->duration = av_rescale_rnd(1,
2865  num * (int64_t) st->time_base.den,
2866  den * (int64_t) st->time_base.num,
2867  AV_ROUND_DOWN);
2868  }
2869  }
2870  duration = pkt->pts + pkt->duration;
2871  found_duration = 1;
2872  if (st->start_time != AV_NOPTS_VALUE)
2873  duration -= st->start_time;
2874  else
2875  duration -= st->first_dts;
2876  if (duration > 0) {
2877  if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2878  (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2879  st->duration = duration;
2880  st->info->last_duration = duration;
2881  }
2882  }
2883  av_packet_unref(pkt);
2884  }
2885 
2886  /* check if all audio/video streams have valid duration */
2887  if (!is_end) {
2888  is_end = 1;
2889  for (i = 0; i < ic->nb_streams; i++) {
2890  st = ic->streams[i];
2891  switch (st->codecpar->codec_type) {
2892  case AVMEDIA_TYPE_VIDEO:
2893  case AVMEDIA_TYPE_AUDIO:
2894  if (st->duration == AV_NOPTS_VALUE)
2895  is_end = 0;
2896  }
2897  }
2898  }
2899  } while (!is_end &&
2900  offset &&
2901  ++retry <= DURATION_MAX_RETRY);
2902 
2903  av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2904 
2905  /* warn about audio/video streams which duration could not be estimated */
2906  for (i = 0; i < ic->nb_streams; i++) {
2907  st = ic->streams[i];
2908  if (st->duration == AV_NOPTS_VALUE) {
2909  switch (st->codecpar->codec_type) {
2910  case AVMEDIA_TYPE_VIDEO:
2911  case AVMEDIA_TYPE_AUDIO:
2912  if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2913  av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
2914  } else
2915  av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
2916  }
2917  }
2918  }
2919 skip_duration_calc:
2921 
2922  avio_seek(ic->pb, old_offset, SEEK_SET);
2923  for (i = 0; i < ic->nb_streams; i++) {
2924  int j;
2925 
2926  st = ic->streams[i];
2927  st->cur_dts = st->first_dts;
2930  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2931  st->pts_buffer[j] = AV_NOPTS_VALUE;
2932  }
2933 }
2934 
2935 /* 1:1 map to AVDurationEstimationMethod */
2936 static const char *duration_name[] = {
2937  [AVFMT_DURATION_FROM_PTS] = "pts",
2938  [AVFMT_DURATION_FROM_STREAM] = "stream",
2939  [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
2940 };
2941 
2943 {
2944  return duration_name[method];
2945 }
2946 
2947 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2948 {
2949  int64_t file_size;
2950 
2951  /* get the file size, if possible */
2952  if (ic->iformat->flags & AVFMT_NOFILE) {
2953  file_size = 0;
2954  } else {
2955  file_size = avio_size(ic->pb);
2956  file_size = FFMAX(0, file_size);
2957  }
2958 
2959  if ((!strcmp(ic->iformat->name, "mpeg") ||
2960  !strcmp(ic->iformat->name, "mpegts")) &&
2961  file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2962  /* get accurate estimate from the PTSes */
2963  estimate_timings_from_pts(ic, old_offset);
2965  } else if (has_duration(ic)) {
2966  /* at least one component has timings - we use them for all
2967  * the components */
2969  /* nut demuxer estimate the duration from PTS */
2970  if(!strcmp(ic->iformat->name, "nut"))
2972  else
2974  } else {
2975  /* less precise: use bitrate info */
2978  }
2980 
2981  {
2982  int i;
2983  AVStream av_unused *st;
2984  for (i = 0; i < ic->nb_streams; i++) {
2985  st = ic->streams[i];
2986  if (st->time_base.den)
2987  av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %s duration: %s\n", i,
2988  av_ts2timestr(st->start_time, &st->time_base),
2989  av_ts2timestr(st->duration, &st->time_base));
2990  }
2991  av_log(ic, AV_LOG_TRACE,
2992  "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
2996  (int64_t)ic->bit_rate / 1000);
2997  }
2998 }
2999 
3000 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
3001 {
3002  AVCodecContext *avctx = st->internal->avctx;
3003 
3004 #define FAIL(errmsg) do { \
3005  if (errmsg_ptr) \
3006  *errmsg_ptr = errmsg; \
3007  return 0; \
3008  } while (0)
3009 
3010  if ( avctx->codec_id == AV_CODEC_ID_NONE
3011  && avctx->codec_type != AVMEDIA_TYPE_DATA)
3012  FAIL("unknown codec");
3013  switch (avctx->codec_type) {
3014  case AVMEDIA_TYPE_AUDIO:
3015  if (!avctx->frame_size && determinable_frame_size(avctx))
3016  FAIL("unspecified frame size");
3017  if (st->info->found_decoder >= 0 &&
3018  avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
3019  FAIL("unspecified sample format");
3020  if (!avctx->sample_rate)
3021  FAIL("unspecified sample rate");
3022  if (!avctx->channels)
3023  FAIL("unspecified number of channels");
3024  if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
3025  FAIL("no decodable DTS frames");
3026  break;
3027  case AVMEDIA_TYPE_VIDEO:
3028  if (!avctx->width)
3029  FAIL("unspecified size");
3030  if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
3031  FAIL("unspecified pixel format");
3034  FAIL("no frame in rv30/40 and no sar");
3035  break;
3036  case AVMEDIA_TYPE_SUBTITLE:
3037  if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
3038  FAIL("unspecified size");
3039  break;
3040  case AVMEDIA_TYPE_DATA:
3041  if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
3042  }
3043 
3044  return 1;
3045 }
3046 
3047 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3049  const AVPacket *avpkt, AVDictionary **options)
3050 {
3051  AVCodecContext *avctx = st->internal->avctx;
3052  const AVCodec *codec;
3053  int got_picture = 1, ret = 0;
3055  AVSubtitle subtitle;
3056  AVPacket pkt = *avpkt;
3057  int do_skip_frame = 0;
3058  enum AVDiscard skip_frame;
3059 
3060  if (!frame)
3061  return AVERROR(ENOMEM);
3062 
3063  if (!avcodec_is_open(avctx) &&
3064  st->info->found_decoder <= 0 &&
3065  (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
3066  AVDictionary *thread_opt = NULL;
3067 
3068  codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3069 
3070  if (!codec) {
3071  st->info->found_decoder = -st->codecpar->codec_id;
3072  ret = -1;
3073  goto fail;
3074  }
3075 
3076  /* Force thread count to 1 since the H.264 decoder will not extract
3077  * SPS and PPS to extradata during multi-threaded decoding. */
3078  av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3079  if (s->codec_whitelist)
3080  av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3081  ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3082  if (!options)
3083  av_dict_free(&thread_opt);
3084  if (ret < 0) {
3085  st->info->found_decoder = -avctx->codec_id;
3086  goto fail;
3087  }
3088  st->info->found_decoder = 1;
3089  } else if (!st->info->found_decoder)
3090  st->info->found_decoder = 1;
3091 
3092  if (st->info->found_decoder < 0) {
3093  ret = -1;
3094  goto fail;
3095  }
3096 
3098  do_skip_frame = 1;
3099  skip_frame = avctx->skip_frame;
3100  avctx->skip_frame = AVDISCARD_ALL;
3101  }
3102 
3103  while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3104  ret >= 0 &&
3106  (!st->codec_info_nb_frames &&
3108  got_picture = 0;
3109  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3110  avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3111  ret = avcodec_send_packet(avctx, &pkt);
3112  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3113  break;
3114  if (ret >= 0)
3115  pkt.size = 0;
3116  ret = avcodec_receive_frame(avctx, frame);
3117  if (ret >= 0)
3118  got_picture = 1;
3119  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3120  ret = 0;
3121  } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3122  ret = avcodec_decode_subtitle2(avctx, &subtitle,
3123  &got_picture, &pkt);
3124  if (got_picture)
3125  avsubtitle_free(&subtitle);
3126  if (ret >= 0)
3127  pkt.size = 0;
3128  }
3129  if (ret >= 0) {
3130  if (got_picture)
3131  st->nb_decoded_frames++;
3132  ret = got_picture;
3133  }
3134  }
3135 
3136  if (!pkt.data && !got_picture)
3137  ret = -1;
3138 
3139 fail:
3140  if (do_skip_frame) {
3141  avctx->skip_frame = skip_frame;
3142  }
3143 
3144  av_frame_free(&frame);
3145  return ret;
3146 }
3147 
3148 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3149 {
3150  while (tags->id != AV_CODEC_ID_NONE) {
3151  if (tags->id == id)
3152  return tags->tag;
3153  tags++;
3154  }
3155  return 0;
3156 }
3157 
3158 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3159 {
3160  int i;
3161  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3162  if (tag == tags[i].tag)
3163  return tags[i].id;
3164  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3165  if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3166  return tags[i].id;
3167  return AV_CODEC_ID_NONE;
3168 }
3169 
3170 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3171 {
3172  if (bps <= 0 || bps > 64)
3173  return AV_CODEC_ID_NONE;
3174 
3175  if (flt) {
3176  switch (bps) {
3177  case 32:
3179  case 64:
3181  default:
3182  return AV_CODEC_ID_NONE;
3183  }
3184  } else {
3185  bps += 7;
3186  bps >>= 3;
3187  if (sflags & (1 << (bps - 1))) {
3188  switch (bps) {
3189  case 1:
3190  return AV_CODEC_ID_PCM_S8;
3191  case 2:
3193  case 3:
3195  case 4:
3197  case 8:
3199  default:
3200  return AV_CODEC_ID_NONE;
3201  }
3202  } else {
3203  switch (bps) {
3204  case 1:
3205  return AV_CODEC_ID_PCM_U8;
3206  case 2:
3208  case 3:
3210  case 4:
3212  default:
3213  return AV_CODEC_ID_NONE;
3214  }
3215  }
3216  }
3217 }
3218 
3219 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3220 {
3221  unsigned int tag;
3222  if (!av_codec_get_tag2(tags, id, &tag))
3223  return 0;
3224  return tag;
3225 }
3226 
3227 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3228  unsigned int *tag)
3229 {
3230  int i;
3231  for (i = 0; tags && tags[i]; i++) {
3232  const AVCodecTag *codec_tags = tags[i];
3233  while (codec_tags->id != AV_CODEC_ID_NONE) {
3234  if (codec_tags->id == id) {
3235  *tag = codec_tags->tag;
3236  return 1;
3237  }
3238  codec_tags++;
3239  }
3240  }
3241  return 0;
3242 }
3243 
3244 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3245 {
3246  int i;
3247  for (i = 0; tags && tags[i]; i++) {
3248  enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3249  if (id != AV_CODEC_ID_NONE)
3250  return id;
3251  }
3252  return AV_CODEC_ID_NONE;
3253 }
3254 
3256 {
3257  unsigned int i, j;
3258  int64_t max_time = 0;
3259 
3260  if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3261  max_time = s->duration +
3262  ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3263 
3264  for (i = 0; i < s->nb_chapters; i++)
3265  if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3266  AVChapter *ch = s->chapters[i];
3267  int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3268  ch->time_base)
3269  : INT64_MAX;
3270 
3271  for (j = 0; j < s->nb_chapters; j++) {
3272  AVChapter *ch1 = s->chapters[j];
3273  int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3274  ch->time_base);
3275  if (j != i && next_start > ch->start && next_start < end)
3276  end = next_start;
3277  }
3278  ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3279  }
3280 }
3281 
3282 static int get_std_framerate(int i)
3283 {
3284  if (i < 30*12)
3285  return (i + 1) * 1001;
3286  i -= 30*12;
3287 
3288  if (i < 30)
3289  return (i + 31) * 1001 * 12;
3290  i -= 30;
3291 
3292  if (i < 3)
3293  return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3294 
3295  i -= 3;
3296 
3297  return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3298 }
3299 
3300 /* Is the time base unreliable?
3301  * This is a heuristic to balance between quick acceptance of the values in
3302  * the headers vs. some extra checks.
3303  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3304  * MPEG-2 commonly misuses field repeat flags to store different framerates.
3305  * And there are "variable" fps files this needs to detect as well. */
3307 {
3308  if (c->time_base.den >= 101LL * c->time_base.num ||
3309  c->time_base.den < 5LL * c->time_base.num ||
3310  // c->codec_tag == AV_RL32("DIVX") ||
3311  // c->codec_tag == AV_RL32("XVID") ||
3312  c->codec_tag == AV_RL32("mp4v") ||
3314  c->codec_id == AV_CODEC_ID_GIF ||
3315  c->codec_id == AV_CODEC_ID_HEVC ||
3316  c->codec_id == AV_CODEC_ID_H264)
3317  return 1;
3318  return 0;
3319 }
3320 
3322 {
3323  av_freep(&par->extradata);
3324  par->extradata_size = 0;
3325 
3327  return AVERROR(EINVAL);
3328 
3330  if (!par->extradata)
3331  return AVERROR(ENOMEM);
3332 
3333  memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3334  par->extradata_size = size;
3335 
3336  return 0;
3337 }
3338 
3340 {
3341  int ret = ff_alloc_extradata(par, size);
3342  if (ret < 0)
3343  return ret;
3344  ret = avio_read(pb, par->extradata, size);
3345  if (ret != size) {
3346  av_freep(&par->extradata);
3347  par->extradata_size = 0;
3348  av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3349  return ret < 0 ? ret : AVERROR_INVALIDDATA;
3350  }
3351 
3352  return ret;
3353 }
3354 
3355 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3356 {
3357  int i, j;
3358  int64_t last = st->info->last_dts;
3359 
3360  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3361  && ts - (uint64_t)last < INT64_MAX) {
3362  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3363  int64_t duration = ts - last;
3364 
3365  if (!st->info->duration_error)
3366  st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3367  if (!st->info->duration_error)
3368  return AVERROR(ENOMEM);
3369 
3370 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3371 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3372  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3373  if (st->info->duration_error[0][1][i] < 1e10) {
3374  int framerate = get_std_framerate(i);
3375  double sdts = dts*framerate/(1001*12);
3376  for (j= 0; j<2; j++) {
3377  int64_t ticks = llrint(sdts+j*0.5);
3378  double error= sdts - ticks + j*0.5;
3379  st->info->duration_error[j][0][i] += error;
3380  st->info->duration_error[j][1][i] += error*error;
3381  }
3382  }
3383  }
3384  if (st->info->rfps_duration_sum <= INT64_MAX - duration) {
3385  st->info->duration_count++;
3387  }
3388 
3389  if (st->info->duration_count % 10 == 0) {
3390  int n = st->info->duration_count;
3391  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3392  if (st->info->duration_error[0][1][i] < 1e10) {
3393  double a0 = st->info->duration_error[0][0][i] / n;
3394  double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3395  double a1 = st->info->duration_error[1][0][i] / n;
3396  double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3397  if (error0 > 0.04 && error1 > 0.04) {
3398  st->info->duration_error[0][1][i] = 2e10;
3399  st->info->duration_error[1][1][i] = 2e10;
3400  }
3401  }
3402  }
3403  }
3404 
3405  // ignore the first 4 values, they might have some random jitter
3406  if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3407  st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3408  }
3409  if (ts != AV_NOPTS_VALUE)
3410  st->info->last_dts = ts;
3411 
3412  return 0;
3413 }
3414 
3416 {
3417  int i, j;
3418 
3419  for (i = 0; i < ic->nb_streams; i++) {
3420  AVStream *st = ic->streams[i];
3421 
3423  continue;
3424  // the check for tb_unreliable() is not completely correct, since this is not about handling
3425  // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3426  // ipmovie.c produces.
3427  if (tb_unreliable(st->internal->avctx) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
3428  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
3429  if (st->info->duration_count>1 && !st->r_frame_rate.num
3430  && tb_unreliable(st->internal->avctx)) {
3431  int num = 0;
3432  double best_error= 0.01;
3433  AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3434 
3435  for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3436  int k;
3437 
3438  if (st->info->codec_info_duration &&
3439  st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3440  continue;
3441  if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3442  continue;
3443 
3444  if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3445  continue;
3446 
3447  for (k= 0; k<2; k++) {
3448  int n = st->info->duration_count;
3449  double a= st->info->duration_error[k][0][j] / n;
3450  double error= st->info->duration_error[k][1][j]/n - a*a;
3451 
3452  if (error < best_error && best_error> 0.000000001) {
3453  best_error= error;
3454  num = get_std_framerate(j);
3455  }
3456  if (error < 0.02)
3457  av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3458  }
3459  }
3460  // do not increase frame rate by more than 1 % in order to match a standard rate.
3461  if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3462  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3463  }
3464  if ( !st->avg_frame_rate.num
3465  && st->r_frame_rate.num && st->info->rfps_duration_sum
3466  && st->info->codec_info_duration <= 0
3467  && st->info->duration_count > 2
3468  && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->info->rfps_duration_sum / (double)st->info->duration_count) <= 1.0
3469  ) {
3470  av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3471  st->avg_frame_rate = st->r_frame_rate;
3472  }
3473 
3474  av_freep(&st->info->duration_error);
3475  st->info->last_dts = AV_NOPTS_VALUE;
3476  st->info->duration_count = 0;
3477  st->info->rfps_duration_sum = 0;
3478  }
3479 }
3480 
3482 {
3483  const AVBitStreamFilter *f;
3484 
3485  f = av_bsf_get_by_name("extract_extradata");
3486  if (!f)
3487  return 0;
3488 
3489  if (f->codec_ids) {
3490  const enum AVCodecID *ids;
3491  for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3492  if (*ids == st->codecpar->codec_id)
3493  return 1;
3494  }
3495 
3496  return 0;
3497 }
3498 
3500 {
3501  AVStreamInternal *sti = st->internal;
3502  const AVBitStreamFilter *f;
3503  int ret;
3504 
3505  f = av_bsf_get_by_name("extract_extradata");
3506  if (!f)
3507  goto finish;
3508 
3509  /* check that the codec id is supported */
3510  ret = extract_extradata_check(st);
3511  if (!ret)
3512  goto finish;
3513 
3515  if (!sti->extract_extradata.pkt)
3516  return AVERROR(ENOMEM);
3517 
3518  ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3519  if (ret < 0)
3520  goto fail;
3521 
3523  st->codecpar);
3524  if (ret < 0)
3525  goto fail;
3526 
3528 
3529  ret = av_bsf_init(sti->extract_extradata.bsf);
3530  if (ret < 0)
3531  goto fail;
3532 
3533 finish:
3534  sti->extract_extradata.inited = 1;
3535 
3536  return 0;
3537 fail:
3540  return ret;
3541 }
3542 
3543 static int extract_extradata(AVStream *st, const AVPacket *pkt)
3544 {
3545  AVStreamInternal *sti = st->internal;
3546  AVPacket *pkt_ref;
3547  int ret;
3548 
3549  if (!sti->extract_extradata.inited) {
3550  ret = extract_extradata_init(st);
3551  if (ret < 0)
3552  return ret;
3553  }
3554 
3555  if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3556  return 0;
3557 
3558  pkt_ref = sti->extract_extradata.pkt;
3559  ret = av_packet_ref(pkt_ref, pkt);
3560  if (ret < 0)
3561  return ret;
3562 
3563  ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3564  if (ret < 0) {
3565  av_packet_unref(pkt_ref);
3566  return ret;
3567  }
3568 
3569  while (ret >= 0 && !sti->avctx->extradata) {
3570  int extradata_size;
3571  uint8_t *extradata;
3572 
3573  ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3574  if (ret < 0) {
3575  if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3576  return ret;
3577  continue;
3578  }
3579 
3581  &extradata_size);
3582 
3583  if (extradata) {
3584  av_assert0(!sti->avctx->extradata);
3585  if ((unsigned)extradata_size < FF_MAX_EXTRADATA_SIZE)
3586  sti->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3587  if (!sti->avctx->extradata) {
3588  av_packet_unref(pkt_ref);
3589  return AVERROR(ENOMEM);
3590  }
3591  memcpy(sti->avctx->extradata, extradata, extradata_size);
3592  sti->avctx->extradata_size = extradata_size;
3593  }
3594  av_packet_unref(pkt_ref);
3595  }
3596 
3597  return 0;
3598 }
3599 
3601 {
3602  int i;
3603 
3604  for (i = 0; i < avctx->nb_coded_side_data; i++) {
3605  const AVPacketSideData *sd_src = &avctx->coded_side_data[i];
3606  uint8_t *dst_data;
3607  dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
3608  if (!dst_data)
3609  return AVERROR(ENOMEM);
3610  memcpy(dst_data, sd_src->data, sd_src->size);
3611  }
3612  return 0;
3613 }
3614 
3616 {
3617  int i, count = 0, ret = 0, j;
3618  int64_t read_size;
3619  AVStream *st;
3620  AVCodecContext *avctx;
3621  AVPacket pkt1;
3622  int64_t old_offset = avio_tell(ic->pb);
3623  // new streams might appear, no options for those
3624  int orig_nb_streams = ic->nb_streams;
3625  int flush_codecs;
3626  int64_t max_analyze_duration = ic->max_analyze_duration;
3627  int64_t max_stream_analyze_duration;
3628  int64_t max_subtitle_analyze_duration;
3629  int64_t probesize = ic->probesize;
3630  int eof_reached = 0;
3631  int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3632 
3633  flush_codecs = probesize > 0;
3634 
3635  av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3636 
3637  max_stream_analyze_duration = max_analyze_duration;
3638  max_subtitle_analyze_duration = max_analyze_duration;
3639  if (!max_analyze_duration) {
3640  max_stream_analyze_duration =
3641  max_analyze_duration = 5*AV_TIME_BASE;
3642  max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3643  if (!strcmp(ic->iformat->name, "flv"))
3644  max_stream_analyze_duration = 90*AV_TIME_BASE;
3645  if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3646  max_stream_analyze_duration = 7*AV_TIME_BASE;
3647  }
3648 
3649  if (ic->pb)
3650  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3651  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3652 
3653  for (i = 0; i < ic->nb_streams; i++) {
3654  const AVCodec *codec;
3655  AVDictionary *thread_opt = NULL;
3656  st = ic->streams[i];
3657  avctx = st->internal->avctx;
3658 
3659  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3661 /* if (!st->time_base.num)
3662  st->time_base = */
3663  if (!avctx->time_base.num)
3664  avctx->time_base = st->time_base;
3665  }
3666 
3667  /* check if the caller has overridden the codec id */
3668 #if FF_API_LAVF_AVCTX
3670  if (st->codec->codec_id != st->internal->orig_codec_id) {
3671  st->codecpar->codec_id = st->codec->codec_id;
3672  st->codecpar->codec_type = st->codec->codec_type;
3673  st->internal->orig_codec_id = st->codec->codec_id;
3674  }
3676 #endif
3677  // only for the split stuff
3678  if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3679  st->parser = av_parser_init(st->codecpar->codec_id);
3680  if (st->parser) {
3681  if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3683  } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3685  }
3686  } else if (st->need_parsing) {
3687  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3688  "%s, packets or times may be invalid.\n",
3690  }
3691  }
3692 
3693  if (st->codecpar->codec_id != st->internal->orig_codec_id)
3695 
3697  if (ret < 0)
3698  goto find_stream_info_err;
3699  if (st->request_probe <= 0)
3700  st->internal->avctx_inited = 1;
3701 
3702  codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3703 
3704  /* Force thread count to 1 since the H.264 decoder will not extract
3705  * SPS and PPS to extradata during multi-threaded decoding. */
3706  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3707 
3708  if (ic->codec_whitelist)
3709  av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3710 
3711  /* Ensure that subtitle_header is properly set. */
3713  && codec && !avctx->codec) {
3714  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3715  av_log(ic, AV_LOG_WARNING,
3716  "Failed to open codec in %s\n",__FUNCTION__);
3717  }
3718 
3719  // Try to just open decoders, in case this is enough to get parameters.
3720  if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3721  if (codec && !avctx->codec)
3722  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3723  av_log(ic, AV_LOG_WARNING,
3724  "Failed to open codec in %s\n",__FUNCTION__);
3725  }
3726  if (!options)
3727  av_dict_free(&thread_opt);
3728  }
3729 
3730  for (i = 0; i < ic->nb_streams; i++) {
3731 #if FF_API_R_FRAME_RATE
3733 #endif
3736  }
3737 
3738  read_size = 0;
3739  for (;;) {
3740  const AVPacket *pkt;
3741  int analyzed_all_streams;
3743  ret = AVERROR_EXIT;
3744  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3745  break;
3746  }
3747 
3748  /* check if one codec still needs to be handled */
3749  for (i = 0; i < ic->nb_streams; i++) {
3750  int fps_analyze_framecount = 20;
3751  int count;
3752 
3753  st = ic->streams[i];
3754  if (!has_codec_parameters(st, NULL))
3755  break;
3756  /* If the timebase is coarse (like the usual millisecond precision
3757  * of mkv), we need to analyze more frames to reliably arrive at
3758  * the correct fps. */
3759  if (av_q2d(st->time_base) > 0.0005)
3760  fps_analyze_framecount *= 2;
3761  if (!tb_unreliable(st->internal->avctx))
3762  fps_analyze_framecount = 0;
3763  if (ic->fps_probe_size >= 0)
3764  fps_analyze_framecount = ic->fps_probe_size;
3766  fps_analyze_framecount = 0;
3767  /* variable fps and no guess at the real fps */
3768  count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3770  st->info->duration_count;
3771  if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3773  if (count < fps_analyze_framecount)
3774  break;
3775  }
3776  // Look at the first 3 frames if there is evidence of frame delay
3777  // but the decoder delay is not set.
3778  if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3779  break;
3780  if (!st->internal->avctx->extradata &&
3782  st->internal->extract_extradata.bsf) &&
3784  break;
3785  if (st->first_dts == AV_NOPTS_VALUE &&
3786  !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3790  break;
3791  }
3792  analyzed_all_streams = 0;
3793  if (!missing_streams || !*missing_streams)
3794  if (i == ic->nb_streams) {
3795  analyzed_all_streams = 1;
3796  /* NOTE: If the format has no header, then we need to read some
3797  * packets to get most of the streams, so we cannot stop here. */
3798  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3799  /* If we found the info for all the codecs, we can stop. */
3800  ret = count;
3801  av_log(ic, AV_LOG_DEBUG, "All info found\n");
3802  flush_codecs = 0;
3803  break;
3804  }
3805  }
3806  /* We did not get all the codec info, but we read too much data. */
3807  if (read_size >= probesize) {
3808  ret = count;
3809  av_log(ic, AV_LOG_DEBUG,
3810  "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3811  for (i = 0; i < ic->nb_streams; i++)
3812  if (!ic->streams[i]->r_frame_rate.num &&
3813  ic->streams[i]->info->duration_count <= 1 &&
3815  strcmp(ic->iformat->name, "image2"))
3816  av_log(ic, AV_LOG_WARNING,
3817  "Stream #%d: not enough frames to estimate rate; "
3818  "consider increasing probesize\n", i);
3819  break;
3820  }
3821 
3822  /* NOTE: A new stream can be added there if no header in file
3823  * (AVFMTCTX_NOHEADER). */
3824  ret = read_frame_internal(ic, &pkt1);
3825  if (ret == AVERROR(EAGAIN))
3826  continue;
3827 
3828  if (ret < 0) {
3829  /* EOF or error*/
3830  eof_reached = 1;
3831  break;
3832  }
3833 
3834  if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3837  &pkt1, 0);
3838  if (ret < 0)
3839  goto unref_then_goto_end;
3840 
3841  pkt = &ic->internal->packet_buffer_end->pkt;
3842  } else {
3843  pkt = &pkt1;
3844  }
3845 
3846  st = ic->streams[pkt->stream_index];
3848  read_size += pkt->size;
3849 
3850  avctx = st->internal->avctx;
3851  if (!st->internal->avctx_inited) {
3853  if (ret < 0)
3854  goto unref_then_goto_end;
3855  st->internal->avctx_inited = 1;
3856  }
3857 
3858  if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3859  /* check for non-increasing dts */
3860  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3861  st->info->fps_last_dts >= pkt->dts) {
3862  av_log(ic, AV_LOG_DEBUG,
3863  "Non-increasing DTS in stream %d: packet %d with DTS "
3864  "%"PRId64", packet %d with DTS %"PRId64"\n",
3865  st->index, st->info->fps_last_dts_idx,
3867  pkt->dts);
3868  st->info->fps_first_dts =
3870  }
3871  /* Check for a discontinuity in dts. If the difference in dts
3872  * is more than 1000 times the average packet duration in the
3873  * sequence, we treat it as a discontinuity. */
3874  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3876  (pkt->dts - (uint64_t)st->info->fps_last_dts) / 1000 >
3877  (st->info->fps_last_dts - (uint64_t)st->info->fps_first_dts) /
3878  (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3879  av_log(ic, AV_LOG_WARNING,
3880  "DTS discontinuity in stream %d: packet %d with DTS "
3881  "%"PRId64", packet %d with DTS %"PRId64"\n",
3882  st->index, st->info->fps_last_dts_idx,
3884  pkt->dts);
3885  st->info->fps_first_dts =
3887  }
3888 
3889  /* update stored dts values */
3890  if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3891  st->info->fps_first_dts = pkt->dts;
3893  }
3894  st->info->fps_last_dts = pkt->dts;
3896  }
3897  if (st->codec_info_nb_frames>1) {
3898  int64_t t = 0;
3899  int64_t limit;
3900 
3901  if (st->time_base.den > 0)
3903  if (st->avg_frame_rate.num > 0)
3905 
3906  if ( t == 0
3907  && st->codec_info_nb_frames>30
3908  && st->info->fps_first_dts != AV_NOPTS_VALUE
3909  && st->info->fps_last_dts != AV_NOPTS_VALUE)
3911 
3912  if (analyzed_all_streams) limit = max_analyze_duration;
3913  else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3914  else limit = max_stream_analyze_duration;
3915 
3916  if (t >= limit) {
3917  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3918  limit,
3919  t, pkt->stream_index);
3920  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3921  av_packet_unref(&pkt1);
3922  break;
3923  }
3924  if (pkt->duration) {
3925  if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3926  st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3927  } else
3928  st->info->codec_info_duration += pkt->duration;
3929  st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3930  }
3931  }
3932  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3933 #if FF_API_R_FRAME_RATE
3934  ff_rfps_add_frame(ic, st, pkt->dts);
3935 #endif
3936  if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3937  st->info->frame_delay_evidence = 1;
3938  }
3939  if (!st->internal->avctx->extradata) {
3940  ret = extract_extradata(st, pkt);
3941  if (ret < 0)
3942  goto unref_then_goto_end;
3943  }
3944 
3945  /* If still no information, we try to open the codec and to
3946  * decompress the frame. We try to avoid that in most cases as
3947  * it takes longer and uses more memory. For MPEG-4, we need to
3948  * decompress for QuickTime.
3949  *
3950  * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3951  * least one frame of codec data, this makes sure the codec initializes
3952  * the channel configuration and does not only trust the values from
3953  * the container. */
3954  try_decode_frame(ic, st, pkt,
3955  (options && i < orig_nb_streams) ? &options[i] : NULL);
3956 
3957  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3958  av_packet_unref(&pkt1);
3959 
3960  st->codec_info_nb_frames++;
3961  count++;
3962  }
3963 
3964  if (eof_reached) {
3965  int stream_index;
3966  for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3967  st = ic->streams[stream_index];
3968  avctx = st->internal->avctx;
3969  if (!has_codec_parameters(st, NULL)) {
3970  const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3971  if (codec && !avctx->codec) {
3972  AVDictionary *opts = NULL;
3973  if (ic->codec_whitelist)
3974  av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3975  if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3976  av_log(ic, AV_LOG_WARNING,
3977  "Failed to open codec in %s\n",__FUNCTION__);
3978  av_dict_free(&opts);
3979  }
3980  }
3981 
3982  // EOF already reached while reading the stream above.
3983  // So continue with reoordering DTS with whatever delay we have.
3985  update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3986  }
3987  }
3988  }
3989 
3990  if (flush_codecs) {
3991  AVPacket empty_pkt = { 0 };
3992  int err = 0;
3993  av_init_packet(&empty_pkt);
3994 
3995  for (i = 0; i < ic->nb_streams; i++) {
3996 
3997  st = ic->streams[i];
3998 
3999  /* flush the decoders */
4000  if (st->info->found_decoder == 1) {
4001  do {
4002  err = try_decode_frame(ic, st, &empty_pkt,
4003  (options && i < orig_nb_streams)
4004  ? &options[i] : NULL);
4005  } while (err > 0 && !has_codec_parameters(st, NULL));
4006 
4007  if (err < 0) {
4008  av_log(ic, AV_LOG_INFO,
4009  "decoding for stream %d failed\n", st->index);
4010  }
4011  }
4012  }
4013  }
4014 
4015  ff_rfps_calculate(ic);
4016 
4017  for (i = 0; i < ic->nb_streams; i++) {
4018  st = ic->streams[i];
4019  avctx = st->internal->avctx;
4020  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
4021  if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
4022  uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
4024  avctx->codec_tag= tag;
4025  }
4026 
4027  /* estimate average framerate if not set by demuxer */
4028  if (st->info->codec_info_duration_fields &&
4029  !st->avg_frame_rate.num &&
4030  st->info->codec_info_duration) {
4031  int best_fps = 0;
4032  double best_error = 0.01;
4033  AVRational codec_frame_rate = avctx->framerate;
4034 
4035  if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
4036  st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
4037  st->info->codec_info_duration < 0)
4038  continue;
4040  st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
4041  st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
4042 
4043  /* Round guessed framerate to a "standard" framerate if it's
4044  * within 1% of the original estimate. */
4045  for (j = 0; j < MAX_STD_TIMEBASES; j++) {
4046  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
4047  double error = fabs(av_q2d(st->avg_frame_rate) /
4048  av_q2d(std_fps) - 1);
4049 
4050  if (error < best_error) {
4051  best_error = error;
4052  best_fps = std_fps.num;
4053  }
4054 
4055  if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4056  error = fabs(av_q2d(codec_frame_rate) /
4057  av_q2d(std_fps) - 1);
4058  if (error < best_error) {
4059  best_error = error;
4060  best_fps = std_fps.num;
4061  }
4062  }
4063  }
4064  if (best_fps)
4066  best_fps, 12 * 1001, INT_MAX);
4067  }
4068 
4069  if (!st->r_frame_rate.num) {
4070  if ( avctx->time_base.den * (int64_t) st->time_base.num
4071  <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4073  avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4074  } else {
4075  st->r_frame_rate.num = st->time_base.den;
4076  st->r_frame_rate.den = st->time_base.num;
4077  }
4078  }
4080  AVRational hw_ratio = { avctx->height, avctx->width };
4082  hw_ratio);
4083  }
4084  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4085  if (!avctx->bits_per_coded_sample)
4086  avctx->bits_per_coded_sample =
4088  // set stream disposition based on audio service type
4089  switch (avctx->audio_service_type) {
4092  break;
4095  break;
4098  break;
4101  break;
4104  break;
4105  }
4106  }
4107  }
4108 
4109  if (probesize)
4110  estimate_timings(ic, old_offset);
4111 
4112  av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4113 
4114  if (ret >= 0 && ic->nb_streams)
4115  /* We could not have all the codec parameters before EOF. */
4116  ret = -1;
4117  for (i = 0; i < ic->nb_streams; i++) {
4118  const char *errmsg;
4119  st = ic->streams[i];
4120 
4121  /* if no packet was ever seen, update context now for has_codec_parameters */
4122  if (!st->internal->avctx_inited) {
4123  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4125  st->codecpar->format = st->internal->avctx->sample_fmt;
4127  if (ret < 0)
4128  goto find_stream_info_err;
4129  }
4130  if (!has_codec_parameters(st, &errmsg)) {
4131  char buf[256];
4132  avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4133  av_log(ic, AV_LOG_WARNING,
4134  "Could not find codec parameters for stream %d (%s): %s\n"
4135  "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
4136  i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
4137  } else {
4138  ret = 0;
4139  }
4140  }
4141 
4143 
4144  /* update the stream parameters from the internal codec contexts */
4145  for (i = 0; i < ic->nb_streams; i++) {
4146  st = ic->streams[i];
4147 
4148  if (st->internal->avctx_inited) {
4149  int orig_w = st->codecpar->width;
4150  int orig_h = st->codecpar->height;
4152  if (ret < 0)
4153  goto find_stream_info_err;
4154  ret = add_coded_side_data(st, st->internal->avctx);
4155  if (ret < 0)
4156  goto find_stream_info_err;
4157 #if FF_API_LOWRES
4158  // The decoder might reduce the video size by the lowres factor.
4159  if (st->internal->avctx->lowres && orig_w) {
4160  st->codecpar->width = orig_w;
4161  st->codecpar->height = orig_h;
4162  }
4163 #endif
4164  }
4165 
4166 #if FF_API_LAVF_AVCTX
4168  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4169  if (ret < 0)
4170  goto find_stream_info_err;
4171 
4172 #if FF_API_LOWRES
4173  // The old API (AVStream.codec) "requires" the resolution to be adjusted
4174  // by the lowres factor.
4175  if (st->internal->avctx->lowres && st->internal->avctx->width) {
4176  st->codec->lowres = st->internal->avctx->lowres;
4177  st->codec->width = st->internal->avctx->width;
4178  st->codec->height = st->internal->avctx->height;
4179  }
4180 #endif
4181 
4182  if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4183  st->codec->time_base = st->internal->avctx->time_base;
4184  st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4185  }
4186  st->codec->framerate = st->avg_frame_rate;
4187 
4188  if (st->internal->avctx->subtitle_header) {
4189  st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4190  if (!st->codec->subtitle_header)
4191  goto find_stream_info_err;
4192  st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4193  memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4194  st->codec->subtitle_header_size);
4195  }
4196 
4197  // Fields unavailable in AVCodecParameters
4198  st->codec->coded_width = st->internal->avctx->coded_width;
4199  st->codec->coded_height = st->internal->avctx->coded_height;
4200  st->codec->properties = st->internal->avctx->properties;
4202 #endif
4203 
4204  st->internal->avctx_inited = 0;
4205  }
4206 
4207 find_stream_info_err:
4208  for (i = 0; i < ic->nb_streams; i++) {
4209  st = ic->streams[i];
4210  if (st->info)
4211  av_freep(&st->info->duration_error);
4212  avcodec_close(ic->streams[i]->internal->avctx);
4213  av_freep(&ic->streams[i]->info);
4216  }
4217  if (ic->pb)
4218  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4219  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4220  return ret;
4221 
4222 unref_then_goto_end:
4223  av_packet_unref(&pkt1);
4224  goto find_stream_info_err;
4225 }
4226 
4228 {
4229  int i, j;
4230 
4231  for (i = 0; i < ic->nb_programs; i++) {
4232  if (ic->programs[i] == last) {
4233  last = NULL;
4234  } else {
4235  if (!last)
4236  for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4237  if (ic->programs[i]->stream_index[j] == s)
4238  return ic->programs[i];
4239  }
4240  }
4241  return NULL;
4242 }
4243 
4245  int wanted_stream_nb, int related_stream,
4246  AVCodec **decoder_ret, int flags)
4247 {
4248  int i, nb_streams = ic->nb_streams;
4250  int best_count = -1, best_multiframe = -1, best_disposition = -1;
4251  int count, multiframe, disposition;
4252  int64_t best_bitrate = -1;
4253  int64_t bitrate;
4254  unsigned *program = NULL;
4255  const AVCodec *decoder = NULL, *best_decoder = NULL;
4256 
4257  if (related_stream >= 0 && wanted_stream_nb < 0) {
4258  AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4259  if (p) {
4260  program = p->stream_index;
4261  nb_streams = p->nb_stream_indexes;
4262  }
4263  }
4264  for (i = 0; i < nb_streams; i++) {
4265  int real_stream_index = program ? program[i] : i;
4266  AVStream *st = ic->streams[real_stream_index];
4267  AVCodecParameters *par = st->codecpar;
4268  if (par->codec_type != type)
4269  continue;
4270  if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4271  continue;
4272  if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4273  continue;
4274  if (decoder_ret) {
4275  decoder = find_decoder(ic, st, par->codec_id);
4276  if (!decoder) {
4277  if (ret < 0)
4279  continue;
4280  }
4281  }
4283  + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4284  count = st->codec_info_nb_frames;
4285  bitrate = par->bit_rate;
4286  multiframe = FFMIN(5, count);
4287  if ((best_disposition > disposition) ||
4288  (best_disposition == disposition && best_multiframe > multiframe) ||
4289  (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4290  (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4291  continue;
4292  best_disposition = disposition;
4293  best_count = count;
4294  best_bitrate = bitrate;
4295  best_multiframe = multiframe;
4296  ret = real_stream_index;
4297  best_decoder = decoder;
4298  if (program && i == nb_streams - 1 && ret < 0) {
4299  program = NULL;
4300  nb_streams = ic->nb_streams;
4301  /* no related stream found, try again with everything */
4302  i = 0;
4303  }
4304  }
4305  if (decoder_ret)
4306  *decoder_ret = (AVCodec*)best_decoder;
4307  return ret;
4308 }
4309 
4310 /*******************************************************/
4311 
4313 {
4314  if (s->iformat->read_play)
4315  return s->iformat->read_play(s);
4316  if (s->pb)
4317  return avio_pause(s->pb, 0);
4318  return AVERROR(ENOSYS);
4319 }
4320 
4322 {
4323  if (s->iformat->read_pause)
4324  return s->iformat->read_pause(s);
4325  if (s->pb)
4326  return avio_pause(s->pb, 1);
4327  return AVERROR(ENOSYS);
4328 }
4329 
4331 {
4332  int ret, i;
4333 
4334  dst->id = src->id;
4335  dst->time_base = src->time_base;
4336  dst->nb_frames = src->nb_frames;
4337  dst->disposition = src->disposition;
4339  dst->avg_frame_rate = src->avg_frame_rate;
4340  dst->r_frame_rate = src->r_frame_rate;
4341 
4342  av_dict_free(&dst->metadata);
4343  ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4344  if (ret < 0)
4345  return ret;
4346 
4347  ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4348  if (ret < 0)
4349  return ret;
4350 
4351  /* Free existing side data*/
4352  for (i = 0; i < dst->nb_side_data; i++)
4353  av_free(dst->side_data[i].data);
4354  av_freep(&dst->side_data);
4355  dst->nb_side_data = 0;
4356 
4357  /* Copy side data if present */
4358  if (src->nb_side_data) {
4360  sizeof(AVPacketSideData));
4361  if (!dst->side_data)
4362  return AVERROR(ENOMEM);
4363  dst->nb_side_data = src->nb_side_data;
4364 
4365  for (i = 0; i < src->nb_side_data; i++) {
4366  uint8_t *data = av_memdup(src->side_data[i].data,
4367  src->side_data[i].size);
4368  if (!data)
4369  return AVERROR(ENOMEM);
4370  dst->side_data[i].type = src->side_data[i].type;
4371  dst->side_data[i].size = src->side_data[i].size;
4372  dst->side_data[i].data = data;
4373  }
4374  }
4375 
4376 #if FF_API_LAVF_FFSERVER
4378  av_freep(&dst->recommended_encoder_configuration);
4379  if (src->recommended_encoder_configuration) {
4380  const char *conf_str = src->recommended_encoder_configuration;
4381  dst->recommended_encoder_configuration = av_strdup(conf_str);
4382  if (!dst->recommended_encoder_configuration)
4383  return AVERROR(ENOMEM);
4384  }
4386 #endif
4387 
4388  return 0;
4389 }
4390 
4391 static void free_stream(AVStream **pst)
4392 {
4393  AVStream *st = *pst;
4394  int i;
4395 
4396  if (!st)
4397  return;
4398 
4399  for (i = 0; i < st->nb_side_data; i++)
4400  av_freep(&st->side_data[i].data);
4401  av_freep(&st->side_data);
4402 
4403  if (st->parser)
4404  av_parser_close(st->parser);
4405 
4406  if (st->attached_pic.data)
4408 
4409  if (st->internal) {
4411  av_bsf_free(&st->internal->bsfc);
4412  av_freep(&st->internal->priv_pts);
4415  }
4416  av_freep(&st->internal);
4417 
4418  av_dict_free(&st->metadata);
4420  av_freep(&st->probe_data.buf);
4421  av_freep(&st->index_entries);
4422 #if FF_API_LAVF_AVCTX
4424  avcodec_free_context(&st->codec);
4426 #endif
4427  av_freep(&st->priv_data);
4428  if (st->info)
4429  av_freep(&st->info->duration_error);
4430  av_freep(&st->info);
4431 #if FF_API_LAVF_FFSERVER
4433  av_freep(&st->recommended_encoder_configuration);
4435 #endif
4436 
4437  av_freep(pst);
4438 }
4439 
4441 {
4442  av_assert0(s->nb_streams>0);
4443  av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4444 
4445  free_stream(&s->streams[ --s->nb_streams ]);
4446 }
4447 
4449 {
4450  int i;
4451 
4452  if (!s)
4453  return;
4454 
4455  if (s->oformat && s->oformat->deinit && s->internal->initialized)
4456  s->oformat->deinit(s);
4457 
4458  av_opt_free(s);
4459  if (s->iformat && s->iformat->priv_class && s->priv_data)
4460  av_opt_free(s->priv_data);
4461  if (s->oformat && s->oformat->priv_class && s->priv_data)
4462  av_opt_free(s->priv_data);
4463 
4464  for (i = 0; i < s->nb_streams; i++)
4465  free_stream(&s->streams[i]);
4466  s->nb_streams = 0;
4467 
4468  for (i = 0; i < s->nb_programs; i++) {
4469  av_dict_free(&s->programs[i]->metadata);
4470  av_freep(&s->programs[i]->stream_index);
4471  av_freep(&s->programs[i]);
4472  }
4473  s->nb_programs = 0;
4474 
4475  av_freep(&s->programs);
4476  av_freep(&s->priv_data);
4477  while (s->nb_chapters--) {
4479  av_freep(&s->chapters[s->nb_chapters]);
4480  }
4481  av_freep(&s->chapters);
4482  av_dict_free(&s->metadata);
4484  av_freep(&s->streams);
4485  flush_packet_queue(s);
4486  av_freep(&s->internal);
4487  av_freep(&s->url);
4488  av_free(s);
4489 }
4490 
4492 {
4493  AVFormatContext *s;
4494  AVIOContext *pb;
4495 
4496  if (!ps || !*ps)
4497  return;
4498 
4499  s = *ps;
4500  pb = s->pb;
4501 
4502  if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4503  (s->flags & AVFMT_FLAG_CUSTOM_IO))
4504  pb = NULL;
4505 
4506  flush_packet_queue(s);
4507 
4508  if (s->iformat)
4509  if (s->iformat->read_close)
4510  s->iformat->read_close(s);
4511 
4513 
4514  *ps = NULL;
4515 
4516  avio_close(pb);
4517 }
4518 
4520 {
4521  AVStream *st;
4522  int i;
4523  AVStream **streams;
4524 
4525  if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4526  if (s->max_streams < INT_MAX/sizeof(*streams))
4527  av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter (%d), see the documentation if you wish to increase it\n", s->max_streams);
4528  return NULL;
4529  }
4530  streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4531  if (!streams)
4532  return NULL;
4533  s->streams = streams;
4534 
4535  st = av_mallocz(sizeof(AVStream));
4536  if (!st)
4537  return NULL;
4538  if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4539  av_free(st);
4540  return NULL;
4541  }
4542  st->info->last_dts = AV_NOPTS_VALUE;
4543 
4544 #if FF_API_LAVF_AVCTX
4546  st->codec = avcodec_alloc_context3(c);
4547  if (!st->codec) {
4548  av_free(st->info);
4549  av_free(st);
4550  return NULL;
4551  }
4553 #endif
4554 
4555  st->internal = av_mallocz(sizeof(*st->internal));
4556  if (!st->internal)
4557  goto fail;
4558 
4560  if (!st->codecpar)
4561  goto fail;
4562 
4564  if (!st->internal->avctx)
4565  goto fail;
4566 
4567  if (s->iformat) {
4568 #if FF_API_LAVF_AVCTX
4570  /* no default bitrate if decoding */
4571  st->codec->bit_rate = 0;
4573 #endif
4574 
4575  /* default pts setting is MPEG-like */
4576  avpriv_set_pts_info(st, 33, 1, 90000);
4577  /* we set the current DTS to 0 so that formats without any timestamps
4578  * but durations get some timestamps, formats with some unknown
4579  * timestamps have their first few packets buffered and the
4580  * timestamps corrected before they are returned to the user */
4581  st->cur_dts = RELATIVE_TS_BASE;
4582  } else {
4583  st->cur_dts = AV_NOPTS_VALUE;
4584  }
4585 
4586  st->index = s->nb_streams;
4587  st->start_time = AV_NOPTS_VALUE;
4588  st->duration = AV_NOPTS_VALUE;
4589  st->