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;
152  s->internal->inject_global_side_data = 1;
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);
166  dst->format_whitelist = av_strdup(src->format_whitelist);
167  dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
168  dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
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 
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 &&
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 pos = avio_tell(s);
247  int64_t remaining= s->maxsize - pos;
248  if (remaining < size) {
249  int64_t newsize = avio_size(s);
250  if (!s->maxsize || s->maxsize<newsize)
251  s->maxsize = newsize - !newsize;
252  if (pos > s->maxsize && s->maxsize >= 0)
253  s->maxsize = AVERROR(EIO);
254  if (s->maxsize >= 0)
255  remaining = s->maxsize - pos;
256  }
257 
258  if (s->maxsize>= 0 && remaining+1 < size) {
259  av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
260  size = remaining+1;
261  }
262  }
263  return size;
264 }
265 
266 /* Read the data in sane-sized chunks and append to pkt.
267  * Return the number of bytes read or an error. */
269 {
270  int orig_size = pkt->size;
271  int ret;
272 
273  do {
274  int prev_size = pkt->size;
275  int read_size;
276 
277  /* When the caller requests a lot of data, limit it to the amount
278  * left in file or SANE_CHUNK_SIZE when it is not known. */
279  read_size = size;
280  if (read_size > SANE_CHUNK_SIZE/10) {
281  read_size = ffio_limit(s, read_size);
282  // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
283  if (s->maxsize < 0)
284  read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
285  }
286 
287  ret = av_grow_packet(pkt, read_size);
288  if (ret < 0)
289  break;
290 
291  ret = avio_read(s, pkt->data + prev_size, read_size);
292  if (ret != read_size) {
293  av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
294  break;
295  }
296 
297  size -= read_size;
298  } while (size > 0);
299  if (size > 0)
301 
302  if (!pkt->size)
304  return pkt->size > orig_size ? pkt->size - orig_size : ret;
305 }
306 
308 {
310  pkt->data = NULL;
311  pkt->size = 0;
312  pkt->pos = avio_tell(s);
313 
314  return append_packet_chunked(s, pkt, size);
315 }
316 
318 {
319  if (!pkt->size)
320  return av_get_packet(s, pkt, size);
321  return append_packet_chunked(s, pkt, size);
322 }
323 
324 int av_filename_number_test(const char *filename)
325 {
326  char buf[1024];
327  return filename &&
328  (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
329 }
330 
332  AVProbeData *pd)
333 {
334  static const struct {
335  const char *name;
336  enum AVCodecID id;
337  enum AVMediaType type;
338  } fmt_id_type[] = {
350  { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
352  { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
353  { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
354  { 0 }
355  };
356  int score;
357  const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
358 
359  if (fmt) {
360  int i;
362  "Probe with size=%d, packets=%d detected %s with score=%d\n",
363  pd->buf_size, s->max_probe_packets - st->probe_packets,
364  fmt->name, score);
365  for (i = 0; fmt_id_type[i].name; i++) {
366  if (!strcmp(fmt->name, fmt_id_type[i].name)) {
367  if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
368  st->codecpar->sample_rate)
369  continue;
370  if (st->request_probe > score &&
371  st->codecpar->codec_id != fmt_id_type[i].id)
372  continue;
373  st->codecpar->codec_id = fmt_id_type[i].id;
374  st->codecpar->codec_type = fmt_id_type[i].type;
375  st->internal->need_context_update = 1;
376 #if FF_API_LAVF_AVCTX
378  st->codec->codec_type = st->codecpar->codec_type;
379  st->codec->codec_id = st->codecpar->codec_id;
381 #endif
382  return score;
383  }
384  }
385  }
386  return 0;
387 }
388 
389 /************************************************************/
390 /* input media file */
391 
393  int err;
394 
395  if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
396  av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
397  return AVERROR(EINVAL);
398  }
399 
400  if (ic->iformat->read_header) {
401  err = ic->iformat->read_header(ic);
402  if (err < 0)
403  return err;
404  }
405 
406  if (ic->pb && !ic->internal->data_offset)
407  ic->internal->data_offset = avio_tell(ic->pb);
408 
409  return 0;
410 }
411 
412 /* Open input file and probe the format if necessary. */
413 static int init_input(AVFormatContext *s, const char *filename,
415 {
416  int ret;
417  AVProbeData pd = { filename, NULL, 0 };
418  int score = AVPROBE_SCORE_RETRY;
419 
420  if (s->pb) {
421  s->flags |= AVFMT_FLAG_CUSTOM_IO;
422  if (!s->iformat)
423  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
424  s, 0, s->format_probesize);
425  else if (s->iformat->flags & AVFMT_NOFILE)
426  av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
427  "will be ignored with AVFMT_NOFILE format.\n");
428  return 0;
429  }
430 
431  if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
432  (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
433  return score;
434 
435  if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
436  return ret;
437 
438  if (s->iformat)
439  return 0;
440  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
441  s, 0, s->format_probesize);
442 }
443 
444 int ff_packet_list_put(AVPacketList **packet_buffer,
445  AVPacketList **plast_pktl,
446  AVPacket *pkt, int flags)
447 {
448  AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
449  int ret;
450 
451  if (!pktl)
452  return AVERROR(ENOMEM);
453 
455  if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
456  av_free(pktl);
457  return ret;
458  }
459  } else {
461  if (ret < 0) {
462  av_free(pktl);
463  return ret;
464  }
465  av_packet_move_ref(&pktl->pkt, pkt);
466  }
467 
468  if (*packet_buffer)
469  (*plast_pktl)->next = pktl;
470  else
471  *packet_buffer = pktl;
472 
473  /* Add the packet in the buffered packet list. */
474  *plast_pktl = pktl;
475  return 0;
476 }
477 
479 {
480  int i, ret;
481  for (i = 0; i < s->nb_streams; i++)
482  if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
483  s->streams[i]->discard < AVDISCARD_ALL) {
484  if (s->streams[i]->attached_pic.size <= 0) {
486  "Attached picture on stream %d has invalid size, "
487  "ignoring\n", i);
488  continue;
489  }
490 
491  ret = ff_packet_list_put(&s->internal->raw_packet_buffer,
492  &s->internal->raw_packet_buffer_end,
493  &s->streams[i]->attached_pic,
495  if (ret < 0)
496  return ret;
497  }
498  return 0;
499 }
500 
502 {
503  int i, ret;
504  for (i = 0; i < s->nb_streams; i++) {
505  AVStream *st = s->streams[i];
506 
507  if (!st->internal->need_context_update)
508  continue;
509 
510  /* close parser, because it depends on the codec */
511  if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
512  av_parser_close(st->parser);
513  st->parser = NULL;
514  }
515 
516  /* update internal codec context, for the parser */
518  if (ret < 0)
519  return ret;
520 
521 #if FF_API_LAVF_AVCTX
523  /* update deprecated public codec context */
524  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
525  if (ret < 0)
526  return ret;
528 #endif
529 
530  st->internal->need_context_update = 0;
531  }
532  return 0;
533 }
534 
535 
536 int avformat_open_input(AVFormatContext **ps, const char *filename,
538 {
539  AVFormatContext *s = *ps;
540  int i, ret = 0;
541  AVDictionary *tmp = NULL;
542  ID3v2ExtraMeta *id3v2_extra_meta = NULL;
543 
544  if (!s && !(s = avformat_alloc_context()))
545  return AVERROR(ENOMEM);
546  if (!s->av_class) {
547  av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
548  return AVERROR(EINVAL);
549  }
550  if (fmt)
551  s->iformat = fmt;
552 
553  if (options)
554  av_dict_copy(&tmp, *options, 0);
555 
556  if (s->pb) // must be before any goto fail
557  s->flags |= AVFMT_FLAG_CUSTOM_IO;
558 
559  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
560  goto fail;
561 
562  if (!(s->url = av_strdup(filename ? filename : ""))) {
563  ret = AVERROR(ENOMEM);
564  goto fail;
565  }
566 
567 #if FF_API_FORMAT_FILENAME
569  av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
571 #endif
572  if ((ret = init_input(s, filename, &tmp)) < 0)
573  goto fail;
574  s->probe_score = ret;
575 
576  if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
577  s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
578  if (!s->protocol_whitelist) {
579  ret = AVERROR(ENOMEM);
580  goto fail;
581  }
582  }
583 
584  if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
585  s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
586  if (!s->protocol_blacklist) {
587  ret = AVERROR(ENOMEM);
588  goto fail;
589  }
590  }
591 
592  if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
593  av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
594  ret = AVERROR(EINVAL);
595  goto fail;
596  }
597 
598  avio_skip(s->pb, s->skip_initial_bytes);
599 
600  /* Check filename in case an image number is expected. */
601  if (s->iformat->flags & AVFMT_NEEDNUMBER) {
602  if (!av_filename_number_test(filename)) {
603  ret = AVERROR(EINVAL);
604  goto fail;
605  }
606  }
607 
608  s->duration = s->start_time = AV_NOPTS_VALUE;
609 
610  /* Allocate private data. */
611  if (s->iformat->priv_data_size > 0) {
612  if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
613  ret = AVERROR(ENOMEM);
614  goto fail;
615  }
616  if (s->iformat->priv_class) {
617  *(const AVClass **) s->priv_data = s->iformat->priv_class;
618  av_opt_set_defaults(s->priv_data);
619  if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
620  goto fail;
621  }
622  }
623 
624  /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
625  if (s->pb)
626  ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
627 
628 
629  if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
630  if ((ret = s->iformat->read_header(s)) < 0)
631  goto fail;
632 
633  if (!s->metadata) {
634  s->metadata = s->internal->id3v2_meta;
635  s->internal->id3v2_meta = NULL;
636  } else if (s->internal->id3v2_meta) {
637  av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
638  av_dict_free(&s->internal->id3v2_meta);
639  }
640 
641  if (id3v2_extra_meta) {
642  if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
643  !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
644  if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
645  goto close;
646  if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
647  goto close;
648  if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
649  goto close;
650  } else
651  av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
652  }
653  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
654 
656  goto close;
657 
658  if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
659  s->internal->data_offset = avio_tell(s->pb);
660 
661  s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
662 
664 
665  for (i = 0; i < s->nb_streams; i++)
666  s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
667 
668  if (options) {
670  *options = tmp;
671  }
672  *ps = s;
673  return 0;
674 
675 close:
676  if (s->iformat->read_close)
677  s->iformat->read_close(s);
678 fail:
679  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
680  av_dict_free(&tmp);
681  if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
682  avio_closep(&s->pb);
684  *ps = NULL;
685  return ret;
686 }
687 
688 /*******************************************************/
689 
691 {
692  switch (st->codecpar->codec_type) {
693  case AVMEDIA_TYPE_VIDEO:
694  if (s->video_codec_id)
695  st->codecpar->codec_id = s->video_codec_id;
696  break;
697  case AVMEDIA_TYPE_AUDIO:
698  if (s->audio_codec_id)
699  st->codecpar->codec_id = s->audio_codec_id;
700  break;
702  if (s->subtitle_codec_id)
703  st->codecpar->codec_id = s->subtitle_codec_id;
704  break;
705  case AVMEDIA_TYPE_DATA:
706  if (s->data_codec_id)
707  st->codecpar->codec_id = s->data_codec_id;
708  break;
709  }
710 }
711 
713 {
714  if (st->request_probe>0) {
715  AVProbeData *pd = &st->probe_data;
716  int end;
717  av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
718  --st->probe_packets;
719 
720  if (pkt) {
722  if (!new_buf) {
724  "Failed to reallocate probe buffer for stream %d\n",
725  st->index);
726  goto no_packet;
727  }
728  pd->buf = new_buf;
729  memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
730  pd->buf_size += pkt->size;
731  memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
732  } else {
733 no_packet:
734  st->probe_packets = 0;
735  if (!pd->buf_size) {
737  "nothing to probe for stream %d\n", st->index);
738  }
739  }
740 
741  end= s->internal->raw_packet_buffer_remaining_size <= 0
742  || st->probe_packets<= 0;
743 
744  if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
745  int score = set_codec_from_probe_data(s, st, pd);
747  || end) {
748  pd->buf_size = 0;
749  av_freep(&pd->buf);
750  st->request_probe = -1;
751  if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
752  av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
753  } else
754  av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
755  }
756  force_codec_ids(s, st);
757  }
758  }
759  return 0;
760 }
761 
762 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
763 {
764  int64_t ref = pkt->dts;
765  int i, pts_wrap_behavior;
766  int64_t pts_wrap_reference;
767  AVProgram *first_program;
768 
769  if (ref == AV_NOPTS_VALUE)
770  ref = pkt->pts;
771  if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
772  return 0;
773  ref &= (1LL << st->pts_wrap_bits)-1;
774 
775  // reference time stamp should be 60 s before first time stamp
776  pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
777  // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
778  pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
779  (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
781 
782  first_program = av_find_program_from_stream(s, NULL, stream_index);
783 
784  if (!first_program) {
785  int default_stream_index = av_find_default_stream_index(s);
786  if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
787  for (i = 0; i < s->nb_streams; i++) {
789  continue;
790  s->streams[i]->pts_wrap_reference = pts_wrap_reference;
791  s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
792  }
793  }
794  else {
795  st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
796  st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
797  }
798  }
799  else {
800  AVProgram *program = first_program;
801  while (program) {
802  if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
803  pts_wrap_reference = program->pts_wrap_reference;
804  pts_wrap_behavior = program->pts_wrap_behavior;
805  break;
806  }
807  program = av_find_program_from_stream(s, program, stream_index);
808  }
809 
810  // update every program with differing pts_wrap_reference
811  program = first_program;
812  while (program) {
813  if (program->pts_wrap_reference != pts_wrap_reference) {
814  for (i = 0; i<program->nb_stream_indexes; i++) {
815  s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
816  s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
817  }
818 
819  program->pts_wrap_reference = pts_wrap_reference;
820  program->pts_wrap_behavior = pts_wrap_behavior;
821  }
822  program = av_find_program_from_stream(s, program, stream_index);
823  }
824  }
825  return 1;
826 }
827 
829 {
830  int ret, i, err;
831  AVStream *st;
832 
833  pkt->data = NULL;
834  pkt->size = 0;
836 
837  for (;;) {
838  AVPacketList *pktl = s->internal->raw_packet_buffer;
839  const AVPacket *pkt1;
840 
841  if (pktl) {
842  st = s->streams[pktl->pkt.stream_index];
843  if (s->internal->raw_packet_buffer_remaining_size <= 0)
844  if ((err = probe_codec(s, st, NULL)) < 0)
845  return err;
846  if (st->request_probe <= 0) {
847  ff_packet_list_get(&s->internal->raw_packet_buffer,
848  &s->internal->raw_packet_buffer_end, pkt);
849  s->internal->raw_packet_buffer_remaining_size += pkt->size;
850  return 0;
851  }
852  }
853 
854  ret = s->iformat->read_packet(s, pkt);
855  if (ret < 0) {
857 
858  /* Some demuxers return FFERROR_REDO when they consume
859  data and discard it (ignored streams, junk, extradata).
860  We must re-call the demuxer to get the real packet. */
861  if (ret == FFERROR_REDO)
862  continue;
863  if (!pktl || ret == AVERROR(EAGAIN))
864  return ret;
865  for (i = 0; i < s->nb_streams; i++) {
866  st = s->streams[i];
867  if (st->probe_packets || st->request_probe > 0)
868  if ((err = probe_codec(s, st, NULL)) < 0)
869  return err;
870  av_assert0(st->request_probe <= 0);
871  }
872  continue;
873  }
874 
876  if (err < 0) {
878  return err;
879  }
880 
881  if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
883  "Packet corrupt (stream = %d, dts = %s)",
885  if (s->flags & AVFMT_FLAG_DISCARD_CORRUPT) {
886  av_log(s, AV_LOG_WARNING, ", dropping it.\n");
888  continue;
889  }
890  av_log(s, AV_LOG_WARNING, ".\n");
891  }
892 
893  av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
894  "Invalid stream index.\n");
895 
896  st = s->streams[pkt->stream_index];
897 
899  // correct first time stamps to negative values
900  if (!is_relative(st->first_dts))
901  st->first_dts = wrap_timestamp(st, st->first_dts);
902  if (!is_relative(st->start_time))
903  st->start_time = wrap_timestamp(st, st->start_time);
904  if (!is_relative(st->cur_dts))
905  st->cur_dts = wrap_timestamp(st, st->cur_dts);
906  }
907 
908  pkt->dts = wrap_timestamp(st, pkt->dts);
909  pkt->pts = wrap_timestamp(st, pkt->pts);
910 
911  force_codec_ids(s, st);
912 
913  /* TODO: audio: time filter; video: frame reordering (pts != dts) */
914  if (s->use_wallclock_as_timestamps)
916 
917  if (!pktl && st->request_probe <= 0)
918  return ret;
919 
920  err = ff_packet_list_put(&s->internal->raw_packet_buffer,
921  &s->internal->raw_packet_buffer_end,
922  pkt, 0);
923  if (err < 0) {
925  return err;
926  }
927  pkt1 = &s->internal->raw_packet_buffer_end->pkt;
928  s->internal->raw_packet_buffer_remaining_size -= pkt1->size;
929 
930  if ((err = probe_codec(s, st, pkt1)) < 0)
931  return err;
932  }
933 }
934 
935 
936 /**********************************************************/
937 
939 {
940  switch(avctx->codec_id) {
941  case AV_CODEC_ID_MP1:
942  case AV_CODEC_ID_MP2:
943  case AV_CODEC_ID_MP3:
944  case AV_CODEC_ID_CODEC2:
945  return 1;
946  }
947 
948  return 0;
949 }
950 
951 /**
952  * Return the frame duration in seconds. Return 0 if not available.
953  */
954 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
956 {
957  AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
958  av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
959  int frame_size, sample_rate;
960 
961 #if FF_API_LAVF_AVCTX
963  if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
964  codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
966 #endif
967 
968  *pnum = 0;
969  *pden = 0;
970  switch (st->codecpar->codec_type) {
971  case AVMEDIA_TYPE_VIDEO:
972  if (st->r_frame_rate.num && !pc && s->iformat) {
973  *pnum = st->r_frame_rate.den;
974  *pden = st->r_frame_rate.num;
975  } else if (st->time_base.num * 1000LL > st->time_base.den) {
976  *pnum = st->time_base.num;
977  *pden = st->time_base.den;
978  } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
980  av_reduce(pnum, pden,
981  codec_framerate.den,
982  codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
983  INT_MAX);
984 
985  if (pc && pc->repeat_pict) {
986  av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
987  av_reduce(pnum, pden,
988  (*pnum) * (1LL + pc->repeat_pict),
989  (*pden),
990  INT_MAX);
991  }
992  /* If this codec can be interlaced or progressive then we need
993  * a parser to compute duration of a packet. Thus if we have
994  * no parser in such case leave duration undefined. */
995  if (st->internal->avctx->ticks_per_frame > 1 && !pc)
996  *pnum = *pden = 0;
997  }
998  break;
999  case AVMEDIA_TYPE_AUDIO:
1000  if (st->internal->avctx_inited) {
1003  } else {
1006  }
1007  if (frame_size <= 0 || sample_rate <= 0)
1008  break;
1009  *pnum = frame_size;
1010  *pden = sample_rate;
1011  break;
1012  default:
1013  break;
1014  }
1015 }
1016 
1018 {
1020  if (!d)
1021  return 0;
1022  if ((d->type == AVMEDIA_TYPE_VIDEO || d->type == AVMEDIA_TYPE_AUDIO) &&
1024  return 0;
1025  return 1;
1026 }
1027 
1029 {
1030  if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
1031  if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
1032  return 1;
1033 #if CONFIG_H264_DECODER
1034  if (st->internal->avctx->has_b_frames &&
1036  return 1;
1037 #endif
1038  if (st->internal->avctx->has_b_frames<3)
1039  return st->nb_decoded_frames >= 7;
1040  else if (st->internal->avctx->has_b_frames<4)
1041  return st->nb_decoded_frames >= 18;
1042  else
1043  return st->nb_decoded_frames >= 20;
1044 }
1045 
1047 {
1048  if (pktl->next)
1049  return pktl->next;
1050  if (pktl == s->internal->packet_buffer_end)
1051  return s->internal->parse_queue;
1052  return NULL;
1053 }
1054 
1055 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1056  int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1058 
1059  if(!onein_oneout) {
1060  int delay = st->internal->avctx->has_b_frames;
1061  int i;
1062 
1063  if (dts == AV_NOPTS_VALUE) {
1064  int64_t best_score = INT64_MAX;
1065  for (i = 0; i<delay; i++) {
1066  if (st->pts_reorder_error_count[i]) {
1067  int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1068  if (score < best_score) {
1069  best_score = score;
1070  dts = pts_buffer[i];
1071  }
1072  }
1073  }
1074  } else {
1075  for (i = 0; i<delay; i++) {
1076  if (pts_buffer[i] != AV_NOPTS_VALUE) {
1077  int64_t diff = FFABS(pts_buffer[i] - dts)
1078  + (uint64_t)st->pts_reorder_error[i];
1079  diff = FFMAX(diff, st->pts_reorder_error[i]);
1080  st->pts_reorder_error[i] = diff;
1081  st->pts_reorder_error_count[i]++;
1082  if (st->pts_reorder_error_count[i] > 250) {
1083  st->pts_reorder_error[i] >>= 1;
1084  st->pts_reorder_error_count[i] >>= 1;
1085  }
1086  }
1087  }
1088  }
1089  }
1090 
1091  if (dts == AV_NOPTS_VALUE)
1092  dts = pts_buffer[0];
1093 
1094  return dts;
1095 }
1096 
1097 /**
1098  * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1099  * of the packets in a window.
1100  */
1101 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1102  AVPacketList *pkt_buffer)
1103 {
1104  AVStream *st = s->streams[stream_index];
1105  int delay = st->internal->avctx->has_b_frames;
1106  int i;
1107 
1108  int64_t pts_buffer[MAX_REORDER_DELAY+1];
1109 
1110  for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1111  pts_buffer[i] = AV_NOPTS_VALUE;
1112 
1113  for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1114  if (pkt_buffer->pkt.stream_index != stream_index)
1115  continue;
1116 
1117  if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1118  pts_buffer[0] = pkt_buffer->pkt.pts;
1119  for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1120  FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1121 
1122  pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1123  }
1124  }
1125 }
1126 
1127 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1128  int64_t dts, int64_t pts, AVPacket *pkt)
1129 {
1130  AVStream *st = s->streams[stream_index];
1131  AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1132  AVPacketList *pktl_it;
1133 
1134  uint64_t shift;
1135 
1136  if (st->first_dts != AV_NOPTS_VALUE ||
1137  dts == AV_NOPTS_VALUE ||
1138  st->cur_dts == AV_NOPTS_VALUE ||
1139  st->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
1140  dts < INT_MIN + (st->cur_dts - RELATIVE_TS_BASE) ||
1141  is_relative(dts))
1142  return;
1143 
1144  st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1145  st->cur_dts = dts;
1146  shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1147 
1148  if (is_relative(pts))
1149  pts += shift;
1150 
1151  for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1152  if (pktl_it->pkt.stream_index != stream_index)
1153  continue;
1154  if (is_relative(pktl_it->pkt.pts))
1155  pktl_it->pkt.pts += shift;
1156 
1157  if (is_relative(pktl_it->pkt.dts))
1158  pktl_it->pkt.dts += shift;
1159 
1160  if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1161  st->start_time = pktl_it->pkt.pts;
1163  st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1164  }
1165  }
1166 
1168  update_dts_from_pts(s, stream_index, pktl);
1169  }
1170 
1171  if (st->start_time == AV_NOPTS_VALUE) {
1173  st->start_time = pts;
1174  }
1176  st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1177  }
1178 }
1179 
1181  int stream_index, int64_t duration)
1182 {
1183  AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1184  int64_t cur_dts = RELATIVE_TS_BASE;
1185 
1186  if (st->first_dts != AV_NOPTS_VALUE) {
1188  return;
1190  cur_dts = st->first_dts;
1191  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1192  if (pktl->pkt.stream_index == stream_index) {
1193  if (pktl->pkt.pts != pktl->pkt.dts ||
1194  pktl->pkt.dts != AV_NOPTS_VALUE ||
1195  pktl->pkt.duration)
1196  break;
1197  cur_dts -= duration;
1198  }
1199  }
1200  if (pktl && pktl->pkt.dts != st->first_dts) {
1201  av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1202  av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1203  return;
1204  }
1205  if (!pktl) {
1206  av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1207  return;
1208  }
1209  pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1210  st->first_dts = cur_dts;
1211  } else if (st->cur_dts != RELATIVE_TS_BASE)
1212  return;
1213 
1214  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1215  if (pktl->pkt.stream_index != stream_index)
1216  continue;
1217  if ((pktl->pkt.pts == pktl->pkt.dts ||
1218  pktl->pkt.pts == AV_NOPTS_VALUE) &&
1219  (pktl->pkt.dts == AV_NOPTS_VALUE ||
1220  pktl->pkt.dts == st->first_dts ||
1221  pktl->pkt.dts == RELATIVE_TS_BASE) &&
1222  !pktl->pkt.duration &&
1223  av_sat_add64(cur_dts, duration) == cur_dts + (uint64_t)duration
1224  ) {
1225  pktl->pkt.dts = cur_dts;
1226  if (!st->internal->avctx->has_b_frames)
1227  pktl->pkt.pts = cur_dts;
1228 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1229  pktl->pkt.duration = duration;
1230  } else
1231  break;
1232  cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1233  }
1234  if (!pktl)
1235  st->cur_dts = cur_dts;
1236 }
1237 
1240  int64_t next_dts, int64_t next_pts)
1241 {
1242  int num, den, presentation_delayed, delay, i;
1243  int64_t offset;
1245  int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1247 
1248  if (s->flags & AVFMT_FLAG_NOFILLIN)
1249  return;
1250 
1252  if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1253  if (st->last_dts_for_order_check <= pkt->dts) {
1254  st->dts_ordered++;
1255  } else {
1257  "DTS %"PRIi64" < %"PRIi64" out of order\n",
1258  pkt->dts,
1260  st->dts_misordered++;
1261  }
1262  if (st->dts_ordered + st->dts_misordered > 250) {
1263  st->dts_ordered >>= 1;
1264  st->dts_misordered >>= 1;
1265  }
1266  }
1267 
1269  if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1270  pkt->dts = AV_NOPTS_VALUE;
1271  }
1272 
1273  if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1274  pkt->dts = AV_NOPTS_VALUE;
1275 
1276  if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1277  && !st->internal->avctx->has_b_frames)
1278  //FIXME Set low_delay = 0 when has_b_frames = 1
1279  st->internal->avctx->has_b_frames = 1;
1280 
1281  /* do we have a video B-frame ? */
1282  delay = st->internal->avctx->has_b_frames;
1283  presentation_delayed = 0;
1284 
1285  /* XXX: need has_b_frame, but cannot get it if the codec is
1286  * not initialized */
1287  if (delay &&
1288  pc && pc->pict_type != AV_PICTURE_TYPE_B)
1289  presentation_delayed = 1;
1290 
1291  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1292  st->pts_wrap_bits < 63 && pkt->dts > INT64_MIN + (1LL << st->pts_wrap_bits) &&
1293  pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1294  if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1295  pkt->dts -= 1LL << st->pts_wrap_bits;
1296  } else
1297  pkt->pts += 1LL << st->pts_wrap_bits;
1298  }
1299 
1300  /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1301  * We take the conservative approach and discard both.
1302  * Note: If this is misbehaving for an H.264 file, then possibly
1303  * presentation_delayed is not set correctly. */
1304  if (delay == 1 && pkt->dts == pkt->pts &&
1305  pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1306  av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1307  if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1308  && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1309  pkt->dts = AV_NOPTS_VALUE;
1310  }
1311 
1313  if (pkt->duration <= 0) {
1314  ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1315  if (den && num) {
1316  duration = (AVRational) {num, den};
1318  num * (int64_t) st->time_base.den,
1319  den * (int64_t) st->time_base.num,
1320  AV_ROUND_DOWN);
1321  }
1322  }
1323 
1324  if (pkt->duration > 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1326 
1327  /* Correct timestamps with byte offset if demuxers only have timestamps
1328  * on packet boundaries */
1329  if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1330  /* this will estimate bitrate based on this frame's duration and size */
1332  if (pkt->pts != AV_NOPTS_VALUE)
1333  pkt->pts += offset;
1334  if (pkt->dts != AV_NOPTS_VALUE)
1335  pkt->dts += offset;
1336  }
1337 
1338  /* This may be redundant, but it should not hurt. */
1339  if (pkt->dts != AV_NOPTS_VALUE &&
1340  pkt->pts != AV_NOPTS_VALUE &&
1341  pkt->pts > pkt->dts)
1342  presentation_delayed = 1;
1343 
1344  if (s->debug & FF_FDEBUG_TS)
1346  "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1347  presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1348  pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1349 
1350  /* Interpolate PTS and DTS if they are not present. We skip H264
1351  * currently because delay and has_b_frames are not reliably set. */
1352  if ((delay == 0 || (delay == 1 && pc)) &&
1353  onein_oneout) {
1354  if (presentation_delayed) {
1355  /* DTS = decompression timestamp */
1356  /* PTS = presentation timestamp */
1357  if (pkt->dts == AV_NOPTS_VALUE)
1358  pkt->dts = st->last_IP_pts;
1360  if (pkt->dts == AV_NOPTS_VALUE)
1361  pkt->dts = st->cur_dts;
1362 
1363  /* This is tricky: the dts must be incremented by the duration
1364  * of the frame we are displaying, i.e. the last I- or P-frame. */
1365  if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1366  st->last_IP_duration = pkt->duration;
1367  if (pkt->dts != AV_NOPTS_VALUE)
1368  st->cur_dts = av_sat_add64(pkt->dts, st->last_IP_duration);
1369  if (pkt->dts != AV_NOPTS_VALUE &&
1370  pkt->pts == AV_NOPTS_VALUE &&
1371  st->last_IP_duration > 0 &&
1372  ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1373  next_dts != next_pts &&
1374  next_pts != AV_NOPTS_VALUE)
1375  pkt->pts = next_dts;
1376 
1377  if ((uint64_t)pkt->duration <= INT32_MAX)
1378  st->last_IP_duration = pkt->duration;
1379  st->last_IP_pts = pkt->pts;
1380  /* Cannot compute PTS if not present (we can compute it only
1381  * by knowing the future. */
1382  } else if (pkt->pts != AV_NOPTS_VALUE ||
1383  pkt->dts != AV_NOPTS_VALUE ||
1384  pkt->duration > 0 ) {
1385 
1386  /* presentation is not delayed : PTS and DTS are the same */
1387  if (pkt->pts == AV_NOPTS_VALUE)
1388  pkt->pts = pkt->dts;
1390  pkt->pts, pkt);
1391  if (pkt->pts == AV_NOPTS_VALUE)
1392  pkt->pts = st->cur_dts;
1393  pkt->dts = pkt->pts;
1394  if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1395  st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1396  }
1397  }
1398 
1399  if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1400  st->pts_buffer[0] = pkt->pts;
1401  for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1402  FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1403 
1406  }
1407  // We skipped it above so we try here.
1408  if (!onein_oneout)
1409  // This should happen on the first packet
1411  if (pkt->dts > st->cur_dts)
1412  st->cur_dts = pkt->dts;
1413 
1414  if (s->debug & FF_FDEBUG_TS)
1415  av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1416  presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
1417 
1418  /* update flags */
1421 #if FF_API_CONVERGENCE_DURATION
1423  if (pc)
1424  pkt->convergence_duration = pc->convergence_duration;
1426 #endif
1427 }
1428 
1429 void ff_packet_list_free(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1430 {
1431  AVPacketList *tmp = *pkt_buf;
1432 
1433  while (tmp) {
1434  AVPacketList *pktl = tmp;
1435  tmp = pktl->next;
1436  av_packet_unref(&pktl->pkt);
1437  av_freep(&pktl);
1438  }
1439  *pkt_buf = NULL;
1440  *pkt_buf_end = NULL;
1441 }
1442 
1443 /**
1444  * Parse a packet, add all split parts to parse_queue.
1445  *
1446  * @param pkt Packet to parse; must not be NULL.
1447  * @param flush Indicates whether to flush. If set, pkt must be blank.
1448  */
1450  int stream_index, int flush)
1451 {
1452  AVPacket out_pkt;
1453  AVStream *st = s->streams[stream_index];
1454  uint8_t *data = pkt->data;
1455  int size = pkt->size;
1456  int ret = 0, got_output = flush;
1457 
1458  if (size || flush) {
1459  av_init_packet(&out_pkt);
1460  } else if (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1461  // preserve 0-size sync packets
1463  }
1464 
1465  while (size > 0 || (flush && got_output)) {
1466  int len;
1467  int64_t next_pts = pkt->pts;
1468  int64_t next_dts = pkt->dts;
1469 
1471  &out_pkt.data, &out_pkt.size, data, size,
1472  pkt->pts, pkt->dts, pkt->pos);
1473 
1474  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1475  pkt->pos = -1;
1476  /* increment read pointer */
1477  av_assert1(data || !len);
1478  data = len ? data + len : data;
1479  size -= len;
1480 
1481  got_output = !!out_pkt.size;
1482 
1483  if (!out_pkt.size)
1484  continue;
1485 
1486  if (pkt->buf && out_pkt.data == pkt->data) {
1487  /* reference pkt->buf only when out_pkt.data is guaranteed to point
1488  * to data in it and not in the parser's internal buffer. */
1489  /* XXX: Ensure this is the case with all parsers when st->parser->flags
1490  * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1491  out_pkt.buf = av_buffer_ref(pkt->buf);
1492  if (!out_pkt.buf) {
1493  ret = AVERROR(ENOMEM);
1494  goto fail;
1495  }
1496  } else {
1497  ret = av_packet_make_refcounted(&out_pkt);
1498  if (ret < 0)
1499  goto fail;
1500  }
1501 
1502  if (pkt->side_data) {
1503  out_pkt.side_data = pkt->side_data;
1504  out_pkt.side_data_elems = pkt->side_data_elems;
1505  pkt->side_data = NULL;
1506  pkt->side_data_elems = 0;
1507  }
1508 
1509  /* set the duration */
1510  out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1512  if (st->internal->avctx->sample_rate > 0) {
1513  out_pkt.duration =
1515  (AVRational) { 1, st->internal->avctx->sample_rate },
1516  st->time_base,
1517  AV_ROUND_DOWN);
1518  }
1519  }
1520 
1521  out_pkt.stream_index = st->index;
1522  out_pkt.pts = st->parser->pts;
1523  out_pkt.dts = st->parser->dts;
1524  out_pkt.pos = st->parser->pos;
1525  out_pkt.flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1526 
1528  out_pkt.pos = st->parser->frame_offset;
1529 
1530  if (st->parser->key_frame == 1 ||
1531  (st->parser->key_frame == -1 &&
1533  out_pkt.flags |= AV_PKT_FLAG_KEY;
1534 
1536  out_pkt.flags |= AV_PKT_FLAG_KEY;
1537 
1538  compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1539 
1540  ret = ff_packet_list_put(&s->internal->parse_queue,
1541  &s->internal->parse_queue_end,
1542  &out_pkt, 0);
1543  if (ret < 0) {
1544  av_packet_unref(&out_pkt);
1545  goto fail;
1546  }
1547  }
1548 
1549  /* end of the stream => close and free the parser */
1550  if (flush) {
1551  av_parser_close(st->parser);
1552  st->parser = NULL;
1553  }
1554 
1555 fail:
1557  return ret;
1558 }
1559 
1561  AVPacketList **pkt_buffer_end,
1562  AVPacket *pkt)
1563 {
1564  AVPacketList *pktl;
1565  av_assert0(*pkt_buffer);
1566  pktl = *pkt_buffer;
1567  *pkt = pktl->pkt;
1568  *pkt_buffer = pktl->next;
1569  if (!pktl->next)
1570  *pkt_buffer_end = NULL;
1571  av_freep(&pktl);
1572  return 0;
1573 }
1574 
1575 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1576 {
1577  return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1578 }
1579 
1581 {
1582  int ret, i, got_packet = 0;
1583  AVDictionary *metadata = NULL;
1584 
1585  while (!got_packet && !s->internal->parse_queue) {
1586  AVStream *st;
1587 
1588  /* read next packet */
1589  ret = ff_read_packet(s, pkt);
1590  if (ret < 0) {
1591  if (ret == AVERROR(EAGAIN))
1592  return ret;
1593  /* flush the parsers */
1594  for (i = 0; i < s->nb_streams; i++) {
1595  st = s->streams[i];
1596  if (st->parser && st->need_parsing)
1597  parse_packet(s, pkt, st->index, 1);
1598  }
1599  /* all remaining packets are now in parse_queue =>
1600  * really terminate parsing */
1601  break;
1602  }
1603  ret = 0;
1604  st = s->streams[pkt->stream_index];
1605 
1606  /* update context if required */
1607  if (st->internal->need_context_update) {
1608  if (avcodec_is_open(st->internal->avctx)) {
1609  av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1611  st->info->found_decoder = 0;
1612  }
1613 
1614  /* close parser, because it depends on the codec */
1615  if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1616  av_parser_close(st->parser);
1617  st->parser = NULL;
1618  }
1619 
1621  if (ret < 0) {
1623  return ret;
1624  }
1625 
1626 #if FF_API_LAVF_AVCTX
1628  /* update deprecated public codec context */
1629  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1630  if (ret < 0) {
1632  return ret;
1633  }
1635 #endif
1636 
1637  st->internal->need_context_update = 0;
1638  }
1639 
1640  if (pkt->pts != AV_NOPTS_VALUE &&
1641  pkt->dts != AV_NOPTS_VALUE &&
1642  pkt->pts < pkt->dts) {
1644  "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1645  pkt->stream_index,
1646  av_ts2str(pkt->pts),
1647  av_ts2str(pkt->dts),
1648  pkt->size);
1649  }
1650  if (s->debug & FF_FDEBUG_TS)
1652  "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1653  pkt->stream_index,
1654  av_ts2str(pkt->pts),
1655  av_ts2str(pkt->dts),
1656  pkt->size, pkt->duration, pkt->flags);
1657 
1658  if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1659  st->parser = av_parser_init(st->codecpar->codec_id);
1660  if (!st->parser) {
1661  av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1662  "%s, packets or times may be invalid.\n",
1664  /* no parser available: just output the raw packets */
1666  } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1668  else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1669  st->parser->flags |= PARSER_FLAG_ONCE;
1670  else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1672  }
1673 
1674  if (!st->need_parsing || !st->parser) {
1675  /* no parsing needed: we just output the packet as is */
1677  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1679  ff_reduce_index(s, st->index);
1680  av_add_index_entry(st, pkt->pos, pkt->dts,
1681  0, 0, AVINDEX_KEYFRAME);
1682  }
1683  got_packet = 1;
1684  } else if (st->discard < AVDISCARD_ALL) {
1685  if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1686  return ret;
1688  st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1689  st->codecpar->channels = st->internal->avctx->channels;
1691  st->codecpar->codec_id = st->internal->avctx->codec_id;
1692  } else {
1693  /* free packet */
1695  }
1696  if (pkt->flags & AV_PKT_FLAG_KEY)
1697  st->skip_to_keyframe = 0;
1698  if (st->skip_to_keyframe) {
1700  got_packet = 0;
1701  }
1702  }
1703 
1704  if (!got_packet && s->internal->parse_queue)
1705  ret = ff_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1706 
1707  if (ret >= 0) {
1708  AVStream *st = s->streams[pkt->stream_index];
1709  int discard_padding = 0;
1710  if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1711  int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1712  int64_t sample = ts_to_samples(st, pts);
1713  int duration = ts_to_samples(st, pkt->duration);
1714  int64_t end_sample = sample + duration;
1715  if (duration > 0 && end_sample >= st->first_discard_sample &&
1716  sample < st->last_discard_sample)
1717  discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1718  }
1719  if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1720  st->skip_samples = st->start_skip_samples;
1721  if (st->skip_samples || discard_padding) {
1723  if (p) {
1724  AV_WL32(p, st->skip_samples);
1725  AV_WL32(p + 4, discard_padding);
1726  av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1727  }
1728  st->skip_samples = 0;
1729  }
1730 
1731  if (st->inject_global_side_data) {
1732  for (i = 0; i < st->nb_side_data; i++) {
1733  AVPacketSideData *src_sd = &st->side_data[i];
1734  uint8_t *dst_data;
1735 
1736  if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1737  continue;
1738 
1739  dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1740  if (!dst_data) {
1741  av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1742  continue;
1743  }
1744 
1745  memcpy(dst_data, src_sd->data, src_sd->size);
1746  }
1747  st->inject_global_side_data = 0;
1748  }
1749  }
1750 
1751  av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1752  if (metadata) {
1753  s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1754  av_dict_copy(&s->metadata, metadata, 0);
1755  av_dict_free(&metadata);
1757  }
1758 
1759 #if FF_API_LAVF_AVCTX
1761 #endif
1762 
1763  if (s->debug & FF_FDEBUG_TS)
1765  "read_frame_internal stream=%d, pts=%s, dts=%s, "
1766  "size=%d, duration=%"PRId64", flags=%d\n",
1767  pkt->stream_index,
1768  av_ts2str(pkt->pts),
1769  av_ts2str(pkt->dts),
1770  pkt->size, pkt->duration, pkt->flags);
1771 
1772  /* A demuxer might have returned EOF because of an IO error, let's
1773  * propagate this back to the user. */
1774  if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1775  ret = s->pb->error;
1776 
1777  return ret;
1778 }
1779 
1781 {
1782  const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1783  int eof = 0;
1784  int ret;
1785  AVStream *st;
1786 
1787  if (!genpts) {
1788  ret = s->internal->packet_buffer
1789  ? ff_packet_list_get(&s->internal->packet_buffer,
1790  &s->internal->packet_buffer_end, pkt)
1792  if (ret < 0)
1793  return ret;
1794  goto return_packet;
1795  }
1796 
1797  for (;;) {
1798  AVPacketList *pktl = s->internal->packet_buffer;
1799 
1800  if (pktl) {
1801  AVPacket *next_pkt = &pktl->pkt;
1802 
1803  if (next_pkt->dts != AV_NOPTS_VALUE) {
1804  int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1805  // last dts seen for this stream. if any of packets following
1806  // current one had no dts, we will set this to AV_NOPTS_VALUE.
1807  int64_t last_dts = next_pkt->dts;
1808  av_assert2(wrap_bits <= 64);
1809  while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1810  if (pktl->pkt.stream_index == next_pkt->stream_index &&
1811  av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1812  if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1813  // not B-frame
1814  next_pkt->pts = pktl->pkt.dts;
1815  }
1816  if (last_dts != AV_NOPTS_VALUE) {
1817  // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1818  last_dts = pktl->pkt.dts;
1819  }
1820  }
1821  pktl = pktl->next;
1822  }
1823  if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1824  // Fixing the last reference frame had none pts issue (For MXF etc).
1825  // We only do this when
1826  // 1. eof.
1827  // 2. we are not able to resolve a pts value for current packet.
1828  // 3. the packets for this stream at the end of the files had valid dts.
1829  next_pkt->pts = last_dts + next_pkt->duration;
1830  }
1831  pktl = s->internal->packet_buffer;
1832  }
1833 
1834  /* read packet from packet buffer, if there is data */
1835  st = s->streams[next_pkt->stream_index];
1836  if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1837  next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1838  ret = ff_packet_list_get(&s->internal->packet_buffer,
1839  &s->internal->packet_buffer_end, pkt);
1840  goto return_packet;
1841  }
1842  }
1843 
1845  if (ret < 0) {
1846  if (pktl && ret != AVERROR(EAGAIN)) {
1847  eof = 1;
1848  continue;
1849  } else
1850  return ret;
1851  }
1852 
1853  ret = ff_packet_list_put(&s->internal->packet_buffer,
1854  &s->internal->packet_buffer_end,
1855  pkt, 0);
1856  if (ret < 0) {
1858  return ret;
1859  }
1860  }
1861 
1862 return_packet:
1863 
1864  st = s->streams[pkt->stream_index];
1865  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1866  ff_reduce_index(s, st->index);
1868  }
1869 
1870  if (is_relative(pkt->dts))
1871  pkt->dts -= RELATIVE_TS_BASE;
1872  if (is_relative(pkt->pts))
1873  pkt->pts -= RELATIVE_TS_BASE;
1874 
1875  return ret;
1876 }
1877 
1878 /* XXX: suppress the packet queue */
1880 {
1881  if (!s->internal)
1882  return;
1883  ff_packet_list_free(&s->internal->parse_queue, &s->internal->parse_queue_end);
1884  ff_packet_list_free(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1885  ff_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1886 
1887  s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1888 }
1889 
1890 /*******************************************************/
1891 /* seek support */
1892 
1894 {
1895  int i;
1896  AVStream *st;
1897  int best_stream = 0;
1898  int best_score = INT_MIN;
1899 
1900  if (s->nb_streams <= 0)
1901  return -1;
1902  for (i = 0; i < s->nb_streams; i++) {
1903  int score = 0;
1904  st = s->streams[i];
1905  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1907  score -= 400;
1908  if (st->codecpar->width && st->codecpar->height)
1909  score += 50;
1910  score+= 25;
1911  }
1912  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1913  if (st->codecpar->sample_rate)
1914  score += 50;
1915  }
1916  if (st->codec_info_nb_frames)
1917  score += 12;
1918 
1919  if (st->discard != AVDISCARD_ALL)
1920  score += 200;
1921 
1922  if (score > best_score) {
1923  best_score = score;
1924  best_stream = i;
1925  }
1926  }
1927  return best_stream;
1928 }
1929 
1930 /** Flush the frame reader. */
1932 {
1933  AVStream *st;
1934  int i, j;
1935 
1937 
1938  /* Reset read state for each stream. */
1939  for (i = 0; i < s->nb_streams; i++) {
1940  st = s->streams[i];
1941 
1942  if (st->parser) {
1943  av_parser_close(st->parser);
1944  st->parser = NULL;
1945  }
1948  if (st->first_dts == AV_NOPTS_VALUE)
1949  st->cur_dts = RELATIVE_TS_BASE;
1950  else
1951  /* We set the current DTS to an unspecified origin. */
1952  st->cur_dts = AV_NOPTS_VALUE;
1953 
1954  st->probe_packets = s->max_probe_packets;
1955 
1956  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1957  st->pts_buffer[j] = AV_NOPTS_VALUE;
1958 
1959  if (s->internal->inject_global_side_data)
1960  st->inject_global_side_data = 1;
1961 
1962  st->skip_samples = 0;
1963  }
1964 }
1965 
1966 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1967 {
1968  int i;
1969 
1970  for (i = 0; i < s->nb_streams; i++) {
1971  AVStream *st = s->streams[i];
1972 
1973  st->cur_dts =
1974  av_rescale(timestamp,
1975  st->time_base.den * (int64_t) ref_st->time_base.num,
1976  st->time_base.num * (int64_t) ref_st->time_base.den);
1977  }
1978 }
1979 
1980 void ff_reduce_index(AVFormatContext *s, int stream_index)
1981 {
1982  AVStream *st = s->streams[stream_index];
1983  unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1984 
1985  if ((unsigned) st->nb_index_entries >= max_entries) {
1986  int i;
1987  for (i = 0; 2 * i < st->nb_index_entries; i++)
1988  st->index_entries[i] = st->index_entries[2 * i];
1989  st->nb_index_entries = i;
1990  }
1991 }
1992 
1993 int ff_add_index_entry(AVIndexEntry **index_entries,
1994  int *nb_index_entries,
1995  unsigned int *index_entries_allocated_size,
1996  int64_t pos, int64_t timestamp,
1997  int size, int distance, int flags)
1998 {
1999  AVIndexEntry *entries, *ie;
2000  int index;
2001 
2002  if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
2003  return -1;
2004 
2005  if (timestamp == AV_NOPTS_VALUE)
2006  return AVERROR(EINVAL);
2007 
2008  if (size < 0 || size > 0x3FFFFFFF)
2009  return AVERROR(EINVAL);
2010 
2011  if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
2012  timestamp -= RELATIVE_TS_BASE;
2013 
2014  entries = av_fast_realloc(*index_entries,
2015  index_entries_allocated_size,
2016  (*nb_index_entries + 1) *
2017  sizeof(AVIndexEntry));
2018  if (!entries)
2019  return -1;
2020 
2021  *index_entries = entries;
2022 
2023  index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
2024  timestamp, AVSEEK_FLAG_ANY);
2025 
2026  if (index < 0) {
2027  index = (*nb_index_entries)++;
2028  ie = &entries[index];
2029  av_assert0(index == 0 || ie[-1].timestamp < timestamp);
2030  } else {
2031  ie = &entries[index];
2032  if (ie->timestamp != timestamp) {
2033  if (ie->timestamp <= timestamp)
2034  return -1;
2035  memmove(entries + index + 1, entries + index,
2036  sizeof(AVIndexEntry) * (*nb_index_entries - index));
2037  (*nb_index_entries)++;
2038  } else if (ie->pos == pos && distance < ie->min_distance)
2039  // do not reduce the distance
2040  distance = ie->min_distance;
2041  }
2042 
2043  ie->pos = pos;
2044  ie->timestamp = timestamp;
2045  ie->min_distance = distance;
2046  ie->size = size;
2047  ie->flags = flags;
2048 
2049  return index;
2050 }
2051 
2052 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
2053  int size, int distance, int flags)
2054 {
2055  timestamp = wrap_timestamp(st, timestamp);
2058  timestamp, size, distance, flags);
2059 }
2060 
2061 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2062  int64_t wanted_timestamp, int flags)
2063 {
2064  int a, b, m;
2065  int64_t timestamp;
2066 
2067  a = -1;
2068  b = nb_entries;
2069 
2070  // Optimize appending index entries at the end.
2071  if (b && entries[b - 1].timestamp < wanted_timestamp)
2072  a = b - 1;
2073 
2074  while (b - a > 1) {
2075  m = (a + b) >> 1;
2076 
2077  // Search for the next non-discarded packet.
2078  while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2079  m++;
2080  if (m == b && entries[m].timestamp >= wanted_timestamp) {
2081  m = b - 1;
2082  break;
2083  }
2084  }
2085 
2086  timestamp = entries[m].timestamp;
2087  if (timestamp >= wanted_timestamp)
2088  b = m;
2089  if (timestamp <= wanted_timestamp)
2090  a = m;
2091  }
2092  m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2093 
2094  if (!(flags & AVSEEK_FLAG_ANY))
2095  while (m >= 0 && m < nb_entries &&
2096  !(entries[m].flags & AVINDEX_KEYFRAME))
2097  m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2098 
2099  if (m == nb_entries)
2100  return -1;
2101  return m;
2102 }
2103 
2104 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2105 {
2106  int ist1, ist2;
2107  int64_t pos_delta = 0;
2108  int64_t skip = 0;
2109  //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2110  const char *proto = avio_find_protocol_name(s->url);
2111 
2112  av_assert0(time_tolerance >= 0);
2113 
2114  if (!proto) {
2115  av_log(s, AV_LOG_INFO,
2116  "Protocol name not provided, cannot determine if input is local or "
2117  "a network protocol, buffers and access patterns cannot be configured "
2118  "optimally without knowing the protocol\n");
2119  }
2120 
2121  if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2122  return;
2123 
2124  for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2125  AVStream *st1 = s->streams[ist1];
2126  for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2127  AVStream *st2 = s->streams[ist2];
2128  int i1, i2;
2129 
2130  if (ist1 == ist2)
2131  continue;
2132 
2133  for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2134  AVIndexEntry *e1 = &st1->index_entries[i1];
2135  int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2136 
2137  skip = FFMAX(skip, e1->size);
2138  for (; i2 < st2->nb_index_entries; i2++) {
2139  AVIndexEntry *e2 = &st2->index_entries[i2];
2140  int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2141  if (e2_pts < e1_pts || e2_pts - (uint64_t)e1_pts < time_tolerance)
2142  continue;
2143  pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2144  break;
2145  }
2146  }
2147  }
2148  }
2149 
2150  pos_delta *= 2;
2151  /* XXX This could be adjusted depending on protocol*/
2152  if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2153  av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2154 
2155  /* realloc the buffer and the original data will be retained */
2156  if (ffio_realloc_buf(s->pb, pos_delta)) {
2157  av_log(s, AV_LOG_ERROR, "Realloc buffer fail.\n");
2158  return;
2159  }
2160 
2161  s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2162  }
2163 
2164  if (skip < (1<<23)) {
2165  s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2166  }
2167 }
2168 
2169 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2170 {
2172  wanted_timestamp, flags);
2173 }
2174 
2175 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2176  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2177 {
2178  int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2179  if (stream_index >= 0)
2180  ts = wrap_timestamp(s->streams[stream_index], ts);
2181  return ts;
2182 }
2183 
2184 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2185  int64_t target_ts, int flags)
2186 {
2187  const AVInputFormat *avif = s->iformat;
2188  int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2189  int64_t ts_min, ts_max, ts;
2190  int index;
2191  int64_t ret;
2192  AVStream *st;
2193 
2194  if (stream_index < 0)
2195  return -1;
2196 
2197  av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2198 
2199  ts_max =
2200  ts_min = AV_NOPTS_VALUE;
2201  pos_limit = -1; // GCC falsely says it may be uninitialized.
2202 
2203  st = s->streams[stream_index];
2204  if (st->index_entries) {
2205  AVIndexEntry *e;
2206 
2207  /* FIXME: Whole function must be checked for non-keyframe entries in
2208  * index case, especially read_timestamp(). */
2209  index = av_index_search_timestamp(st, target_ts,
2211  index = FFMAX(index, 0);
2212  e = &st->index_entries[index];
2213 
2214  if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2215  pos_min = e->pos;
2216  ts_min = e->timestamp;
2217  av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2218  pos_min, av_ts2str(ts_min));
2219  } else {
2220  av_assert1(index == 0);
2221  }
2222 
2223  index = av_index_search_timestamp(st, target_ts,
2225  av_assert0(index < st->nb_index_entries);
2226  if (index >= 0) {
2227  e = &st->index_entries[index];
2228  av_assert1(e->timestamp >= target_ts);
2229  pos_max = e->pos;
2230  ts_max = e->timestamp;
2231  pos_limit = pos_max - e->min_distance;
2232  av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2233  " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2234  }
2235  }
2236 
2237  pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2238  ts_min, ts_max, flags, &ts, avif->read_timestamp);
2239  if (pos < 0)
2240  return -1;
2241 
2242  /* do the seek */
2243  if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2244  return ret;
2245 
2247  ff_update_cur_dts(s, st, ts);
2248 
2249  return 0;
2250 }
2251 
2252 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2253  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2254 {
2255  int64_t step = 1024;
2256  int64_t limit, ts_max;
2257  int64_t filesize = avio_size(s->pb);
2258  int64_t pos_max = filesize - 1;
2259  do {
2260  limit = pos_max;
2261  pos_max = FFMAX(0, (pos_max) - step);
2262  ts_max = ff_read_timestamp(s, stream_index,
2263  &pos_max, limit, read_timestamp);
2264  step += step;
2265  } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2266  if (ts_max == AV_NOPTS_VALUE)
2267  return -1;
2268 
2269  for (;;) {
2270  int64_t tmp_pos = pos_max + 1;
2271  int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2272  &tmp_pos, INT64_MAX, read_timestamp);
2273  if (tmp_ts == AV_NOPTS_VALUE)
2274  break;
2275  av_assert0(tmp_pos > pos_max);
2276  ts_max = tmp_ts;
2277  pos_max = tmp_pos;
2278  if (tmp_pos >= filesize)
2279  break;
2280  }
2281 
2282  if (ts)
2283  *ts = ts_max;
2284  if (pos)
2285  *pos = pos_max;
2286 
2287  return 0;
2288 }
2289 
2290 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2291  int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2292  int64_t ts_min, int64_t ts_max,
2293  int flags, int64_t *ts_ret,
2294  int64_t (*read_timestamp)(struct AVFormatContext *, int,
2295  int64_t *, int64_t))
2296 {
2297  int64_t pos, ts;
2298  int64_t start_pos;
2299  int no_change;
2300  int ret;
2301 
2302  av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2303 
2304  if (ts_min == AV_NOPTS_VALUE) {
2305  pos_min = s->internal->data_offset;
2306  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2307  if (ts_min == AV_NOPTS_VALUE)
2308  return -1;
2309  }
2310 
2311  if (ts_min >= target_ts) {
2312  *ts_ret = ts_min;
2313  return pos_min;
2314  }
2315 
2316  if (ts_max == AV_NOPTS_VALUE) {
2317  if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2318  return ret;
2319  pos_limit = pos_max;
2320  }
2321 
2322  if (ts_max <= target_ts) {
2323  *ts_ret = ts_max;
2324  return pos_max;
2325  }
2326 
2327  av_assert0(ts_min < ts_max);
2328 
2329  no_change = 0;
2330  while (pos_min < pos_limit) {
2332  "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2333  pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2334  av_assert0(pos_limit <= pos_max);
2335 
2336  if (no_change == 0) {
2337  int64_t approximate_keyframe_distance = pos_max - pos_limit;
2338  // interpolate position (better than dichotomy)
2339  pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2340  ts_max - ts_min) +
2341  pos_min - approximate_keyframe_distance;
2342  } else if (no_change == 1) {
2343  // bisection if interpolation did not change min / max pos last time
2344  pos = (pos_min + pos_limit) >> 1;
2345  } else {
2346  /* linear search if bisection failed, can only happen if there
2347  * are very few or no keyframes between min/max */
2348  pos = pos_min;
2349  }
2350  if (pos <= pos_min)
2351  pos = pos_min + 1;
2352  else if (pos > pos_limit)
2353  pos = pos_limit;
2354  start_pos = pos;
2355 
2356  // May pass pos_limit instead of -1.
2357  ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2358  if (pos == pos_max)
2359  no_change++;
2360  else
2361  no_change = 0;
2362  av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2363  " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2364  pos_min, pos, pos_max,
2365  av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2366  pos_limit, start_pos, no_change);
2367  if (ts == AV_NOPTS_VALUE) {
2368  av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2369  return -1;
2370  }
2371  if (target_ts <= ts) {
2372  pos_limit = start_pos - 1;
2373  pos_max = pos;
2374  ts_max = ts;
2375  }
2376  if (target_ts >= ts) {
2377  pos_min = pos;
2378  ts_min = ts;
2379  }
2380  }
2381 
2382  pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2383  ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2384 #if 0
2385  pos_min = pos;
2386  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2387  pos_min++;
2388  ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2389  av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2390  pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2391 #endif
2392  *ts_ret = ts;
2393  return pos;
2394 }
2395 
2396 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2397  int64_t pos, int flags)
2398 {
2399  int64_t pos_min, pos_max;
2400 
2401  pos_min = s->internal->data_offset;
2402  pos_max = avio_size(s->pb) - 1;
2403 
2404  if (pos < pos_min)
2405  pos = pos_min;
2406  else if (pos > pos_max)
2407  pos = pos_max;
2408 
2409  avio_seek(s->pb, pos, SEEK_SET);
2410 
2411  s->io_repositioned = 1;
2412 
2413  return 0;
2414 }
2415 
2416 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2417  int64_t timestamp, int flags)
2418 {
2419  int index;
2420  int64_t ret;
2421  AVStream *st;
2422  AVIndexEntry *ie;
2423 
2424  st = s->streams[stream_index];
2425 
2426  index = av_index_search_timestamp(st, timestamp, flags);
2427 
2428  if (index < 0 && st->nb_index_entries &&
2429  timestamp < st->index_entries[0].timestamp)
2430  return -1;
2431 
2432  if (index < 0 || index == st->nb_index_entries - 1) {
2433  AVPacket pkt;
2434  int nonkey = 0;
2435 
2436  if (st->nb_index_entries) {
2438  ie = &st->index_entries[st->nb_index_entries - 1];
2439  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2440  return ret;
2441  ff_update_cur_dts(s, st, ie->timestamp);
2442  } else {
2443  if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2444  return ret;
2445  }
2446  for (;;) {
2447  int read_status;
2448  do {
2449  read_status = av_read_frame(s, &pkt);
2450  } while (read_status == AVERROR(EAGAIN));
2451  if (read_status < 0)
2452  break;
2453  if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2454  if (pkt.flags & AV_PKT_FLAG_KEY) {
2455  av_packet_unref(&pkt);
2456  break;
2457  }
2458  if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2459  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);
2460  av_packet_unref(&pkt);
2461  break;
2462  }
2463  }
2464  av_packet_unref(&pkt);
2465  }
2466  index = av_index_search_timestamp(st, timestamp, flags);
2467  }
2468  if (index < 0)
2469  return -1;
2470 
2472  if (s->iformat->read_seek)
2473  if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2474  return 0;
2475  ie = &st->index_entries[index];
2476  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2477  return ret;
2478  ff_update_cur_dts(s, st, ie->timestamp);
2479 
2480  return 0;
2481 }
2482 
2483 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2484  int64_t timestamp, int flags)
2485 {
2486  int ret;
2487  AVStream *st;
2488 
2489  if (flags & AVSEEK_FLAG_BYTE) {
2490  if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2491  return -1;
2493  return seek_frame_byte(s, stream_index, timestamp, flags);
2494  }
2495 
2496  if (stream_index < 0) {
2497  stream_index = av_find_default_stream_index(s);
2498  if (stream_index < 0)
2499  return -1;
2500 
2501  st = s->streams[stream_index];
2502  /* timestamp for default must be expressed in AV_TIME_BASE units */
2503  timestamp = av_rescale(timestamp, st->time_base.den,
2504  AV_TIME_BASE * (int64_t) st->time_base.num);
2505  }
2506 
2507  /* first, we try the format specific seek */
2508  if (s->iformat->read_seek) {
2510  ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2511  } else
2512  ret = -1;
2513  if (ret >= 0)
2514  return 0;
2515 
2516  if (s->iformat->read_timestamp &&
2517  !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2519  return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2520  } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2522  return seek_frame_generic(s, stream_index, timestamp, flags);
2523  } else
2524  return -1;
2525 }
2526 
2527 int av_seek_frame(AVFormatContext *s, int stream_index,
2528  int64_t timestamp, int flags)
2529 {
2530  int ret;
2531 
2532  if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2533  int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2534  if ((flags & AVSEEK_FLAG_BACKWARD))
2535  max_ts = timestamp;
2536  else
2537  min_ts = timestamp;
2538  return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2540  }
2541 
2542  ret = seek_frame_internal(s, stream_index, timestamp, flags);
2543 
2544  if (ret >= 0)
2546 
2547  return ret;
2548 }
2549 
2550 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2551  int64_t ts, int64_t max_ts, int flags)
2552 {
2553  if (min_ts > ts || max_ts < ts)
2554  return -1;
2555  if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2556  return AVERROR(EINVAL);
2557 
2558  if (s->seek2any>0)
2561 
2562  if (s->iformat->read_seek2) {
2563  int ret;
2565 
2566  if (stream_index == -1 && s->nb_streams == 1) {
2567  AVRational time_base = s->streams[0]->time_base;
2568  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2569  min_ts = av_rescale_rnd(min_ts, time_base.den,
2570  time_base.num * (int64_t)AV_TIME_BASE,
2572  max_ts = av_rescale_rnd(max_ts, time_base.den,
2573  time_base.num * (int64_t)AV_TIME_BASE,
2575  stream_index = 0;
2576  }
2577 
2578  ret = s->iformat->read_seek2(s, stream_index, min_ts,
2579  ts, max_ts, flags);
2580 
2581  if (ret >= 0)
2583  return ret;
2584  }
2585 
2586  if (s->iformat->read_timestamp) {
2587  // try to seek via read_timestamp()
2588  }
2589 
2590  // Fall back on old API if new is not implemented but old is.
2591  // Note the old API has somewhat different semantics.
2592  if (s->iformat->read_seek || 1) {
2593  int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2594  int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2595  if (ret<0 && ts != min_ts && max_ts != ts) {
2596  ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2597  if (ret >= 0)
2598  ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2599  }
2600  return ret;
2601  }
2602 
2603  // try some generic seek like seek_frame_generic() but with new ts semantics
2604  return -1; //unreachable
2605 }
2606 
2608 {
2610  return 0;
2611 }
2612 
2613 /*******************************************************/
2614 
2615 /**
2616  * Return TRUE if the stream has accurate duration in any stream.
2617  *
2618  * @return TRUE if the stream has accurate duration for at least one component.
2619  */
2621 {
2622  int i;
2623  AVStream *st;
2624 
2625  for (i = 0; i < ic->nb_streams; i++) {
2626  st = ic->streams[i];
2627  if (st->duration != AV_NOPTS_VALUE)
2628  return 1;
2629  }
2630  if (ic->duration != AV_NOPTS_VALUE)
2631  return 1;
2632  return 0;
2633 }
2634 
2635 /**
2636  * Estimate the stream timings from the one of each components.
2637  *
2638  * Also computes the global bitrate if possible.
2639  */
2641 {
2642  int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2643  int64_t duration, duration1, duration_text, filesize;
2644  int i;
2645  AVProgram *p;
2646 
2647  start_time = INT64_MAX;
2648  start_time_text = INT64_MAX;
2649  end_time = INT64_MIN;
2650  end_time_text = INT64_MIN;
2651  duration = INT64_MIN;
2652  duration_text = INT64_MIN;
2653 
2654  for (i = 0; i < ic->nb_streams; i++) {
2655  AVStream *st = ic->streams[i];
2656  int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2658  if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2659  start_time1 = av_rescale_q(st->start_time, st->time_base,
2660  AV_TIME_BASE_Q);
2661  if (is_text)
2662  start_time_text = FFMIN(start_time_text, start_time1);
2663  else
2664  start_time = FFMIN(start_time, start_time1);
2665  end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2668  if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2669  end_time1 += start_time1;
2670  if (is_text)
2671  end_time_text = FFMAX(end_time_text, end_time1);
2672  else
2673  end_time = FFMAX(end_time, end_time1);
2674  }
2675  for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2676  if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2677  p->start_time = start_time1;
2678  if (p->end_time < end_time1)
2679  p->end_time = end_time1;
2680  }
2681  }
2682  if (st->duration != AV_NOPTS_VALUE) {
2683  duration1 = av_rescale_q(st->duration, st->time_base,
2684  AV_TIME_BASE_Q);
2685  if (is_text)
2686  duration_text = FFMAX(duration_text, duration1);
2687  else
2688  duration = FFMAX(duration, duration1);
2689  }
2690  }
2691  if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2692  start_time = start_time_text;
2693  else if (start_time > start_time_text)
2694  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2695 
2696  if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2697  end_time = end_time_text;
2698  else if (end_time < end_time_text)
2699  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2700 
2701  if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2702  duration = duration_text;
2703  else if (duration < duration_text)
2704  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2705 
2706  if (start_time != INT64_MAX) {
2707  ic->start_time = start_time;
2708  if (end_time != INT64_MIN) {
2709  if (ic->nb_programs > 1) {
2710  for (i = 0; i < ic->nb_programs; i++) {
2711  p = ic->programs[i];
2712  if (p->start_time != AV_NOPTS_VALUE &&
2713  p->end_time > p->start_time &&
2714  p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2716  }
2717  } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2718  duration = FFMAX(duration, end_time - start_time);
2719  }
2720  }
2721  }
2722  if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2723  ic->duration = duration;
2724  }
2725  if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2726  /* compute the bitrate */
2727  double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2728  (double) ic->duration;
2729  if (bitrate >= 0 && bitrate <= INT64_MAX)
2730  ic->bit_rate = bitrate;
2731  }
2732 }
2733 
2735 {
2736  int i;
2737  AVStream *st;
2738 
2740  for (i = 0; i < ic->nb_streams; i++) {
2741  st = ic->streams[i];
2742  if (st->start_time == AV_NOPTS_VALUE) {
2743  if (ic->start_time != AV_NOPTS_VALUE)
2745  st->time_base);
2746  if (ic->duration != AV_NOPTS_VALUE)
2748  st->time_base);
2749  }
2750  }
2751 }
2752 
2754 {
2755  int64_t filesize, duration;
2756  int i, show_warning = 0;
2757  AVStream *st;
2758 
2759  /* if bit_rate is already set, we believe it */
2760  if (ic->bit_rate <= 0) {
2761  int64_t bit_rate = 0;
2762  for (i = 0; i < ic->nb_streams; i++) {
2763  st = ic->streams[i];
2764  if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2765  st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2766  if (st->codecpar->bit_rate > 0) {
2767  if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2768  bit_rate = 0;
2769  break;
2770  }
2771  bit_rate += st->codecpar->bit_rate;
2772  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2773  // If we have a videostream with packets but without a bitrate
2774  // then consider the sum not known
2775  bit_rate = 0;
2776  break;
2777  }
2778  }
2779  ic->bit_rate = bit_rate;
2780  }
2781 
2782  /* if duration is already set, we believe it */
2783  if (ic->duration == AV_NOPTS_VALUE &&
2784  ic->bit_rate != 0) {
2785  filesize = ic->pb ? avio_size(ic->pb) : 0;
2786  if (filesize > ic->internal->data_offset) {
2787  filesize -= ic->internal->data_offset;
2788  for (i = 0; i < ic->nb_streams; i++) {
2789  st = ic->streams[i];
2790  if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2791  && st->duration == AV_NOPTS_VALUE) {
2792  duration = av_rescale(filesize, 8LL * st->time_base.den,
2793  ic->bit_rate *
2794  (int64_t) st->time_base.num);
2795  st->duration = duration;
2796  show_warning = 1;
2797  }
2798  }
2799  }
2800  }
2801  if (show_warning)
2802  av_log(ic, AV_LOG_WARNING,
2803  "Estimating duration from bitrate, this may be inaccurate\n");
2804 }
2805 
2806 #define DURATION_MAX_READ_SIZE 250000LL
2807 #define DURATION_MAX_RETRY 6
2808 
2809 /* only usable for MPEG-PS streams */
2810 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2811 {
2812  AVPacket pkt1, *pkt = &pkt1;
2813  AVStream *st;
2814  int num, den, read_size, i, ret;
2815  int found_duration = 0;
2816  int is_end;
2817  int64_t filesize, offset, duration;
2818  int retry = 0;
2819 
2820  /* flush packet queue */
2821  flush_packet_queue(ic);
2822 
2823  for (i = 0; i < ic->nb_streams; i++) {
2824  st = ic->streams[i];
2825  if (st->start_time == AV_NOPTS_VALUE &&
2826  st->first_dts == AV_NOPTS_VALUE &&
2828  av_log(ic, AV_LOG_WARNING,
2829  "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2830 
2831  if (st->parser) {
2832  av_parser_close(st->parser);
2833  st->parser = NULL;
2834  }
2835  }
2836 
2838  av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2839  goto skip_duration_calc;
2840  }
2841 
2842  av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2843  /* estimate the end time (duration) */
2844  /* XXX: may need to support wrapping */
2845  filesize = ic->pb ? avio_size(ic->pb) : 0;
2846  do {
2847  is_end = found_duration;
2848  offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2849  if (offset < 0)
2850  offset = 0;
2851 
2852  avio_seek(ic->pb, offset, SEEK_SET);
2853  read_size = 0;
2854  for (;;) {
2855  if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2856  break;
2857 
2858  do {
2859  ret = ff_read_packet(ic, pkt);
2860  } while (ret == AVERROR(EAGAIN));
2861  if (ret != 0)
2862  break;
2863  read_size += pkt->size;
2864  st = ic->streams[pkt->stream_index];
2865  if (pkt->pts != AV_NOPTS_VALUE &&
2866  (st->start_time != AV_NOPTS_VALUE ||
2867  st->first_dts != AV_NOPTS_VALUE)) {
2868  if (pkt->duration == 0) {
2869  ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2870  if (den && num) {
2872  num * (int64_t) st->time_base.den,
2873  den * (int64_t) st->time_base.num,
2874  AV_ROUND_DOWN);
2875  }
2876  }
2877  duration = pkt->pts + pkt->duration;
2878  found_duration = 1;
2879  if (st->start_time != AV_NOPTS_VALUE)
2880  duration -= st->start_time;
2881  else
2882  duration -= st->first_dts;
2883  if (duration > 0) {
2884  if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2885  (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2886  st->duration = duration;
2887  st->info->last_duration = duration;
2888  }
2889  }
2891  }
2892 
2893  /* check if all audio/video streams have valid duration */
2894  if (!is_end) {
2895  is_end = 1;
2896  for (i = 0; i < ic->nb_streams; i++) {
2897  st = ic->streams[i];
2898  switch (st->codecpar->codec_type) {
2899  case AVMEDIA_TYPE_VIDEO:
2900  case AVMEDIA_TYPE_AUDIO:
2901  if (st->duration == AV_NOPTS_VALUE)
2902  is_end = 0;
2903  }
2904  }
2905  }
2906  } while (!is_end &&
2907  offset &&
2908  ++retry <= DURATION_MAX_RETRY);
2909 
2910  av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2911 
2912  /* warn about audio/video streams which duration could not be estimated */
2913  for (i = 0; i < ic->nb_streams; i++) {
2914  st = ic->streams[i];
2915  if (st->duration == AV_NOPTS_VALUE) {
2916  switch (st->codecpar->codec_type) {
2917  case AVMEDIA_TYPE_VIDEO:
2918  case AVMEDIA_TYPE_AUDIO:
2919  if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2920  av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
2921  } else
2922  av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
2923  }
2924  }
2925  }
2926 skip_duration_calc:
2928 
2929  avio_seek(ic->pb, old_offset, SEEK_SET);
2930  for (i = 0; i < ic->nb_streams; i++) {
2931  int j;
2932 
2933  st = ic->streams[i];
2934  st->cur_dts = st->first_dts;
2937  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2938  st->pts_buffer[j] = AV_NOPTS_VALUE;
2939  }
2940 }
2941 
2942 /* 1:1 map to AVDurationEstimationMethod */
2943 static const char *duration_name[] = {
2944  [AVFMT_DURATION_FROM_PTS] = "pts",
2945  [AVFMT_DURATION_FROM_STREAM] = "stream",
2946  [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
2947 };
2948 
2950 {
2951  return duration_name[method];
2952 }
2953 
2954 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2955 {
2956  int64_t file_size;
2957 
2958  /* get the file size, if possible */
2959  if (ic->iformat->flags & AVFMT_NOFILE) {
2960  file_size = 0;
2961  } else {
2962  file_size = avio_size(ic->pb);
2963  file_size = FFMAX(0, file_size);
2964  }
2965 
2966  if ((!strcmp(ic->iformat->name, "mpeg") ||
2967  !strcmp(ic->iformat->name, "mpegts")) &&
2968  file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2969  /* get accurate estimate from the PTSes */
2970  estimate_timings_from_pts(ic, old_offset);
2972  } else if (has_duration(ic)) {
2973  /* at least one component has timings - we use them for all
2974  * the components */
2976  /* nut demuxer estimate the duration from PTS */
2977  if(!strcmp(ic->iformat->name, "nut"))
2979  else
2981  } else {
2982  /* less precise: use bitrate info */
2985  }
2987 
2988  {
2989  int i;
2990  AVStream av_unused *st;
2991  for (i = 0; i < ic->nb_streams; i++) {
2992  st = ic->streams[i];
2993  if (st->time_base.den)
2994  av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %s duration: %s\n", i,
2995  av_ts2timestr(st->start_time, &st->time_base),
2996  av_ts2timestr(st->duration, &st->time_base));
2997  }
2998  av_log(ic, AV_LOG_TRACE,
2999  "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
3003  (int64_t)ic->bit_rate / 1000);
3004  }
3005 }
3006 
3007 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
3008 {
3009  AVCodecContext *avctx = st->internal->avctx;
3010 
3011 #define FAIL(errmsg) do { \
3012  if (errmsg_ptr) \
3013  *errmsg_ptr = errmsg; \
3014  return 0; \
3015  } while (0)
3016 
3017  if ( avctx->codec_id == AV_CODEC_ID_NONE
3018  && avctx->codec_type != AVMEDIA_TYPE_DATA)
3019  FAIL("unknown codec");
3020  switch (avctx->codec_type) {
3021  case AVMEDIA_TYPE_AUDIO:
3022  if (!avctx->frame_size && determinable_frame_size(avctx))
3023  FAIL("unspecified frame size");
3024  if (st->info->found_decoder >= 0 &&
3025  avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
3026  FAIL("unspecified sample format");
3027  if (!avctx->sample_rate)
3028  FAIL("unspecified sample rate");
3029  if (!avctx->channels)
3030  FAIL("unspecified number of channels");
3031  if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
3032  FAIL("no decodable DTS frames");
3033  break;
3034  case AVMEDIA_TYPE_VIDEO:
3035  if (!avctx->width)
3036  FAIL("unspecified size");
3037  if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
3038  FAIL("unspecified pixel format");
3041  FAIL("no frame in rv30/40 and no sar");
3042  break;
3043  case AVMEDIA_TYPE_SUBTITLE:
3044  if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
3045  FAIL("unspecified size");
3046  break;
3047  case AVMEDIA_TYPE_DATA:
3048  if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
3049  }
3050 
3051  return 1;
3052 }
3053 
3054 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3056  const AVPacket *avpkt, AVDictionary **options)
3057 {
3058  AVCodecContext *avctx = st->internal->avctx;
3059  const AVCodec *codec;
3060  int got_picture = 1, ret = 0;
3062  AVSubtitle subtitle;
3063  AVPacket pkt = *avpkt;
3064  int do_skip_frame = 0;
3065  enum AVDiscard skip_frame;
3066 
3067  if (!frame)
3068  return AVERROR(ENOMEM);
3069 
3070  if (!avcodec_is_open(avctx) &&
3071  st->info->found_decoder <= 0 &&
3072  (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
3073  AVDictionary *thread_opt = NULL;
3074 
3075  codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3076 
3077  if (!codec) {
3078  st->info->found_decoder = -st->codecpar->codec_id;
3079  ret = -1;
3080  goto fail;
3081  }
3082 
3083  /* Force thread count to 1 since the H.264 decoder will not extract
3084  * SPS and PPS to extradata during multi-threaded decoding. */
3085  av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3086  if (s->codec_whitelist)
3087  av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3088  ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3089  if (!options)
3090  av_dict_free(&thread_opt);
3091  if (ret < 0) {
3092  st->info->found_decoder = -avctx->codec_id;
3093  goto fail;
3094  }
3095  st->info->found_decoder = 1;
3096  } else if (!st->info->found_decoder)
3097  st->info->found_decoder = 1;
3098 
3099  if (st->info->found_decoder < 0) {
3100  ret = -1;
3101  goto fail;
3102  }
3103 
3105  do_skip_frame = 1;
3106  skip_frame = avctx->skip_frame;
3107  avctx->skip_frame = AVDISCARD_ALL;
3108  }
3109 
3110  while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3111  ret >= 0 &&
3113  (!st->codec_info_nb_frames &&
3115  got_picture = 0;
3116  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3117  avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3118  ret = avcodec_send_packet(avctx, &pkt);
3119  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3120  break;
3121  if (ret >= 0)
3122  pkt.size = 0;
3123  ret = avcodec_receive_frame(avctx, frame);
3124  if (ret >= 0)
3125  got_picture = 1;
3126  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3127  ret = 0;
3128  } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3129  ret = avcodec_decode_subtitle2(avctx, &subtitle,
3130  &got_picture, &pkt);
3131  if (got_picture)
3132  avsubtitle_free(&subtitle);
3133  if (ret >= 0)
3134  pkt.size = 0;
3135  }
3136  if (ret >= 0) {
3137  if (got_picture)
3138  st->nb_decoded_frames++;
3139  ret = got_picture;
3140  }
3141  }
3142 
3143  if (!pkt.data && !got_picture)
3144  ret = -1;
3145 
3146 fail:
3147  if (do_skip_frame) {
3148  avctx->skip_frame = skip_frame;
3149  }
3150 
3151  av_frame_free(&frame);
3152  return ret;
3153 }
3154 
3155 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3156 {
3157  while (tags->id != AV_CODEC_ID_NONE) {
3158  if (tags->id == id)
3159  return tags->tag;
3160  tags++;
3161  }
3162  return 0;
3163 }
3164 
3165 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3166 {
3167  int i;
3168  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3169  if (tag == tags[i].tag)
3170  return tags[i].id;
3171  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3172  if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3173  return tags[i].id;
3174  return AV_CODEC_ID_NONE;
3175 }
3176 
3177 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3178 {
3179  if (bps <= 0 || bps > 64)
3180  return AV_CODEC_ID_NONE;
3181 
3182  if (flt) {
3183  switch (bps) {
3184  case 32:
3186  case 64:
3188  default:
3189  return AV_CODEC_ID_NONE;
3190  }
3191  } else {
3192  bps += 7;
3193  bps >>= 3;
3194  if (sflags & (1 << (bps - 1))) {
3195  switch (bps) {
3196  case 1:
3197  return AV_CODEC_ID_PCM_S8;
3198  case 2:
3200  case 3:
3202  case 4:
3204  case 8:
3206  default:
3207  return AV_CODEC_ID_NONE;
3208  }
3209  } else {
3210  switch (bps) {
3211  case 1:
3212  return AV_CODEC_ID_PCM_U8;
3213  case 2:
3215  case 3:
3217  case 4:
3219  default:
3220  return AV_CODEC_ID_NONE;
3221  }
3222  }
3223  }
3224 }
3225 
3226 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3227 {
3228  unsigned int tag;
3229  if (!av_codec_get_tag2(tags, id, &tag))
3230  return 0;
3231  return tag;
3232 }
3233 
3234 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3235  unsigned int *tag)
3236 {
3237  int i;
3238  for (i = 0; tags && tags[i]; i++) {
3239  const AVCodecTag *codec_tags = tags[i];
3240  while (codec_tags->id != AV_CODEC_ID_NONE) {
3241  if (codec_tags->id == id) {
3242  *tag = codec_tags->tag;
3243  return 1;
3244  }
3245  codec_tags++;
3246  }
3247  }
3248  return 0;
3249 }
3250 
3251 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3252 {
3253  int i;
3254  for (i = 0; tags && tags[i]; i++) {
3255  enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3256  if (id != AV_CODEC_ID_NONE)
3257  return id;
3258  }
3259  return AV_CODEC_ID_NONE;
3260 }
3261 
3263 {
3264  unsigned int i, j;
3265  int64_t max_time = 0;
3266 
3267  if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3268  max_time = s->duration +
3269  ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3270 
3271  for (i = 0; i < s->nb_chapters; i++)
3272  if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3273  AVChapter *ch = s->chapters[i];
3274  int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3275  ch->time_base)
3276  : INT64_MAX;
3277 
3278  for (j = 0; j < s->nb_chapters; j++) {
3279  AVChapter *ch1 = s->chapters[j];
3280  int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3281  ch->time_base);
3282  if (j != i && next_start > ch->start && next_start < end)
3283  end = next_start;
3284  }
3285  ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3286  }
3287 }
3288 
3289 static int get_std_framerate(int i)
3290 {
3291  if (i < 30*12)
3292  return (i + 1) * 1001;
3293  i -= 30*12;
3294 
3295  if (i < 30)
3296  return (i + 31) * 1001 * 12;
3297  i -= 30;
3298 
3299  if (i < 3)
3300  return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3301 
3302  i -= 3;
3303 
3304  return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3305 }
3306 
3307 /* Is the time base unreliable?
3308  * This is a heuristic to balance between quick acceptance of the values in
3309  * the headers vs. some extra checks.
3310  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3311  * MPEG-2 commonly misuses field repeat flags to store different framerates.
3312  * And there are "variable" fps files this needs to detect as well. */
3314 {
3315  if (c->time_base.den >= 101LL * c->time_base.num ||
3316  c->time_base.den < 5LL * c->time_base.num ||
3317  // c->codec_tag == AV_RL32("DIVX") ||
3318  // c->codec_tag == AV_RL32("XVID") ||
3319  c->codec_tag == AV_RL32("mp4v") ||
3320  c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3321  c->codec_id == AV_CODEC_ID_GIF ||
3322  c->codec_id == AV_CODEC_ID_HEVC ||
3323  c->codec_id == AV_CODEC_ID_H264)
3324  return 1;
3325  return 0;
3326 }
3327 
3329 {
3330  av_freep(&par->extradata);
3331  par->extradata_size = 0;
3332 
3333  if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3334  return AVERROR(EINVAL);
3335 
3337  if (!par->extradata)
3338  return AVERROR(ENOMEM);
3339 
3340  memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3341  par->extradata_size = size;
3342 
3343  return 0;
3344 }
3345 
3347 {
3348  int ret = ff_alloc_extradata(par, size);
3349  if (ret < 0)
3350  return ret;
3351  ret = avio_read(pb, par->extradata, size);
3352  if (ret != size) {
3353  av_freep(&par->extradata);
3354  par->extradata_size = 0;
3355  av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3356  return ret < 0 ? ret : AVERROR_INVALIDDATA;
3357  }
3358 
3359  return ret;
3360 }
3361 
3362 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3363 {
3364  int i, j;
3365  int64_t last = st->info->last_dts;
3366 
3367  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3368  && ts - (uint64_t)last < INT64_MAX) {
3369  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3370  int64_t duration = ts - last;
3371 
3372  if (!st->info->duration_error)
3373  st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3374  if (!st->info->duration_error)
3375  return AVERROR(ENOMEM);
3376 
3377 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3378 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3379  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3380  if (st->info->duration_error[0][1][i] < 1e10) {
3381  int framerate = get_std_framerate(i);
3382  double sdts = dts*framerate/(1001*12);
3383  for (j= 0; j<2; j++) {
3384  int64_t ticks = llrint(sdts+j*0.5);
3385  double error= sdts - ticks + j*0.5;
3386  st->info->duration_error[j][0][i] += error;
3387  st->info->duration_error[j][1][i] += error*error;
3388  }
3389  }
3390  }
3391  if (st->info->rfps_duration_sum <= INT64_MAX - duration) {
3392  st->info->duration_count++;
3394  }
3395 
3396  if (st->info->duration_count % 10 == 0) {
3397  int n = st->info->duration_count;
3398  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3399  if (st->info->duration_error[0][1][i] < 1e10) {
3400  double a0 = st->info->duration_error[0][0][i] / n;
3401  double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3402  double a1 = st->info->duration_error[1][0][i] / n;
3403  double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3404  if (error0 > 0.04 && error1 > 0.04) {
3405  st->info->duration_error[0][1][i] = 2e10;
3406  st->info->duration_error[1][1][i] = 2e10;
3407  }
3408  }
3409  }
3410  }
3411 
3412  // ignore the first 4 values, they might have some random jitter
3413  if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3415  }
3416  if (ts != AV_NOPTS_VALUE)
3417  st->info->last_dts = ts;
3418 
3419  return 0;
3420 }
3421 
3423 {
3424  int i, j;
3425 
3426  for (i = 0; i < ic->nb_streams; i++) {
3427  AVStream *st = ic->streams[i];
3428 
3430  continue;
3431  // the check for tb_unreliable() is not completely correct, since this is not about handling
3432  // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3433  // ipmovie.c produces.
3434  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)
3435  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);
3436  if (st->info->duration_count>1 && !st->r_frame_rate.num
3437  && tb_unreliable(st->internal->avctx)) {
3438  int num = 0;
3439  double best_error= 0.01;
3440  AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3441 
3442  for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3443  int k;
3444 
3445  if (st->info->codec_info_duration &&
3446  st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3447  continue;
3448  if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3449  continue;
3450 
3451  if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3452  continue;
3453 
3454  for (k= 0; k<2; k++) {
3455  int n = st->info->duration_count;
3456  double a= st->info->duration_error[k][0][j] / n;
3457  double error= st->info->duration_error[k][1][j]/n - a*a;
3458 
3459  if (error < best_error && best_error> 0.000000001) {
3460  best_error= error;
3461  num = get_std_framerate(j);
3462  }
3463  if (error < 0.02)
3464  av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3465  }
3466  }
3467  // do not increase frame rate by more than 1 % in order to match a standard rate.
3468  if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3469  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3470  }
3471  if ( !st->avg_frame_rate.num
3472  && st->r_frame_rate.num && st->info->rfps_duration_sum
3473  && st->info->codec_info_duration <= 0
3474  && st->info->duration_count > 2
3475  && 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
3476  ) {
3477  av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3478  st->avg_frame_rate = st->r_frame_rate;
3479  }
3480 
3481  av_freep(&st->info->duration_error);
3482  st->info->last_dts = AV_NOPTS_VALUE;
3483  st->info->duration_count = 0;
3484  st->info->rfps_duration_sum = 0;
3485  }
3486 }
3487 
3489 {
3490  const AVBitStreamFilter *f;
3491 
3492  f = av_bsf_get_by_name("extract_extradata");
3493  if (!f)
3494  return 0;
3495 
3496  if (f->codec_ids) {
3497  const enum AVCodecID *ids;
3498  for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3499  if (*ids == st->codecpar->codec_id)
3500  return 1;
3501  }
3502 
3503  return 0;
3504 }
3505 
3507 {
3508  AVStreamInternal *sti = st->internal;
3509  const AVBitStreamFilter *f;
3510  int ret;
3511 
3512  f = av_bsf_get_by_name("extract_extradata");
3513  if (!f)
3514  goto finish;
3515 
3516  /* check that the codec id is supported */
3518  if (!ret)
3519  goto finish;
3520 
3522  if (!sti->extract_extradata.pkt)
3523  return AVERROR(ENOMEM);
3524 
3526  if (ret < 0)
3527  goto fail;
3528 
3530  st->codecpar);
3531  if (ret < 0)
3532  goto fail;
3533 
3535 
3537  if (ret < 0)
3538  goto fail;
3539 
3540 finish:
3541  sti->extract_extradata.inited = 1;
3542 
3543  return 0;
3544 fail:
3547  return ret;
3548 }
3549 
3550 static int extract_extradata(AVStream *st, const AVPacket *pkt)
3551 {
3552  AVStreamInternal *sti = st->internal;
3553  AVPacket *pkt_ref;
3554  int ret;
3555 
3556  if (!sti->extract_extradata.inited) {
3558  if (ret < 0)
3559  return ret;
3560  }
3561 
3562  if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3563  return 0;
3564 
3565  pkt_ref = sti->extract_extradata.pkt;
3566  ret = av_packet_ref(pkt_ref, pkt);
3567  if (ret < 0)
3568  return ret;
3569 
3570  ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3571  if (ret < 0) {
3572  av_packet_unref(pkt_ref);
3573  return ret;
3574  }
3575 
3576  while (ret >= 0 && !sti->avctx->extradata) {
3577  int extradata_size;
3578  uint8_t *extradata;
3579 
3581  if (ret < 0) {
3582  if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3583  return ret;
3584  continue;
3585  }
3586 
3588  &extradata_size);
3589 
3590  if (extradata) {
3591  av_assert0(!sti->avctx->extradata);
3592  if ((unsigned)extradata_size < FF_MAX_EXTRADATA_SIZE)
3593  sti->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3594  if (!sti->avctx->extradata) {
3595  av_packet_unref(pkt_ref);
3596  return AVERROR(ENOMEM);
3597  }
3598  memcpy(sti->avctx->extradata, extradata, extradata_size);
3599  sti->avctx->extradata_size = extradata_size;
3600  }
3601  av_packet_unref(pkt_ref);
3602  }
3603 
3604  return 0;
3605 }
3606 
3608 {
3609  int i;
3610 
3611  for (i = 0; i < avctx->nb_coded_side_data; i++) {
3612  const AVPacketSideData *sd_src = &avctx->coded_side_data[i];
3613  uint8_t *dst_data;
3614  dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
3615  if (!dst_data)
3616  return AVERROR(ENOMEM);
3617  memcpy(dst_data, sd_src->data, sd_src->size);
3618  }
3619  return 0;
3620 }
3621 
3623 {
3624  int i, count = 0, ret = 0, j;
3625  int64_t read_size;
3626  AVStream *st;
3627  AVCodecContext *avctx;
3628  AVPacket pkt1;
3629  int64_t old_offset = avio_tell(ic->pb);
3630  // new streams might appear, no options for those
3631  int orig_nb_streams = ic->nb_streams;
3632  int flush_codecs;
3633  int64_t max_analyze_duration = ic->max_analyze_duration;
3634  int64_t max_stream_analyze_duration;
3635  int64_t max_subtitle_analyze_duration;
3636  int64_t probesize = ic->probesize;
3637  int eof_reached = 0;
3638  int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3639 
3640  flush_codecs = probesize > 0;
3641 
3642  av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3643 
3644  max_stream_analyze_duration = max_analyze_duration;
3645  max_subtitle_analyze_duration = max_analyze_duration;
3646  if (!max_analyze_duration) {
3647  max_stream_analyze_duration =
3648  max_analyze_duration = 5*AV_TIME_BASE;
3649  max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3650  if (!strcmp(ic->iformat->name, "flv"))
3651  max_stream_analyze_duration = 90*AV_TIME_BASE;
3652  if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3653  max_stream_analyze_duration = 7*AV_TIME_BASE;
3654  }
3655 
3656  if (ic->pb)
3657  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3658  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3659 
3660  for (i = 0; i < ic->nb_streams; i++) {
3661  const AVCodec *codec;
3662  AVDictionary *thread_opt = NULL;
3663  st = ic->streams[i];
3664  avctx = st->internal->avctx;
3665 
3666  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3668 /* if (!st->time_base.num)
3669  st->time_base = */
3670  if (!avctx->time_base.num)
3671  avctx->time_base = st->time_base;
3672  }
3673 
3674  /* check if the caller has overridden the codec id */
3675 #if FF_API_LAVF_AVCTX
3677  if (st->codec->codec_id != st->internal->orig_codec_id) {
3678  st->codecpar->codec_id = st->codec->codec_id;
3679  st->codecpar->codec_type = st->codec->codec_type;
3680  st->internal->orig_codec_id = st->codec->codec_id;
3681  }
3683 #endif
3684  // only for the split stuff
3685  if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3686  st->parser = av_parser_init(st->codecpar->codec_id);
3687  if (st->parser) {
3688  if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3690  } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3692  }
3693  } else if (st->need_parsing) {
3694  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3695  "%s, packets or times may be invalid.\n",
3697  }
3698  }
3699 
3700  if (st->codecpar->codec_id != st->internal->orig_codec_id)
3702 
3704  if (ret < 0)
3705  goto find_stream_info_err;
3706  if (st->request_probe <= 0)
3707  st->internal->avctx_inited = 1;
3708 
3709  codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3710 
3711  /* Force thread count to 1 since the H.264 decoder will not extract
3712  * SPS and PPS to extradata during multi-threaded decoding. */
3713  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3714 
3715  if (ic->codec_whitelist)
3716  av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3717 
3718  /* Ensure that subtitle_header is properly set. */
3720  && codec && !avctx->codec) {
3721  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3722  av_log(ic, AV_LOG_WARNING,
3723  "Failed to open codec in %s\n",__FUNCTION__);
3724  }
3725 
3726  // Try to just open decoders, in case this is enough to get parameters.
3727  if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3728  if (codec && !avctx->codec)
3729  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3730  av_log(ic, AV_LOG_WARNING,
3731  "Failed to open codec in %s\n",__FUNCTION__);
3732  }
3733  if (!options)
3734  av_dict_free(&thread_opt);
3735  }
3736 
3737  for (i = 0; i < ic->nb_streams; i++) {
3738 #if FF_API_R_FRAME_RATE
3740 #endif
3743  }
3744 
3745  read_size = 0;
3746  for (;;) {
3747  const AVPacket *pkt;
3748  int analyzed_all_streams;
3750  ret = AVERROR_EXIT;
3751  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3752  break;
3753  }
3754 
3755  /* check if one codec still needs to be handled */
3756  for (i = 0; i < ic->nb_streams; i++) {
3757  int fps_analyze_framecount = 20;
3758  int count;
3759 
3760  st = ic->streams[i];
3761  if (!has_codec_parameters(st, NULL))
3762  break;
3763  /* If the timebase is coarse (like the usual millisecond precision
3764  * of mkv), we need to analyze more frames to reliably arrive at
3765  * the correct fps. */
3766  if (av_q2d(st->time_base) > 0.0005)
3767  fps_analyze_framecount *= 2;
3768  if (!tb_unreliable(st->internal->avctx))
3769  fps_analyze_framecount = 0;
3770  if (ic->fps_probe_size >= 0)
3771  fps_analyze_framecount = ic->fps_probe_size;
3773  fps_analyze_framecount = 0;
3774  /* variable fps and no guess at the real fps */
3775  count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3777  st->info->duration_count;
3778  if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3780  if (count < fps_analyze_framecount)
3781  break;
3782  }
3783  // Look at the first 3 frames if there is evidence of frame delay
3784  // but the decoder delay is not set.
3785  if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3786  break;
3787  if (!st->internal->avctx->extradata &&
3789  st->internal->extract_extradata.bsf) &&
3791  break;
3792  if (st->first_dts == AV_NOPTS_VALUE &&
3793  !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3797  break;
3798  }
3799  analyzed_all_streams = 0;
3800  if (!missing_streams || !*missing_streams)
3801  if (i == ic->nb_streams) {
3802  analyzed_all_streams = 1;
3803  /* NOTE: If the format has no header, then we need to read some
3804  * packets to get most of the streams, so we cannot stop here. */
3805  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3806  /* If we found the info for all the codecs, we can stop. */
3807  ret = count;
3808  av_log(ic, AV_LOG_DEBUG, "All info found\n");
3809  flush_codecs = 0;
3810  break;
3811  }
3812  }
3813  /* We did not get all the codec info, but we read too much data. */
3814  if (read_size >= probesize) {
3815  ret = count;
3816  av_log(ic, AV_LOG_DEBUG,
3817  "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3818  for (i = 0; i < ic->nb_streams; i++)
3819  if (!ic->streams[i]->r_frame_rate.num &&
3820  ic->streams[i]->info->duration_count <= 1 &&
3822  strcmp(ic->iformat->name, "image2"))
3823  av_log(ic, AV_LOG_WARNING,
3824  "Stream #%d: not enough frames to estimate rate; "
3825  "consider increasing probesize\n", i);
3826  break;
3827  }
3828 
3829  /* NOTE: A new stream can be added there if no header in file
3830  * (AVFMTCTX_NOHEADER). */
3831  ret = read_frame_internal(ic, &pkt1);
3832  if (ret == AVERROR(EAGAIN))
3833  continue;
3834 
3835  if (ret < 0) {
3836  /* EOF or error*/
3837  eof_reached = 1;
3838  break;
3839  }
3840 
3841  if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3844  &pkt1, 0);
3845  if (ret < 0)
3846  goto unref_then_goto_end;
3847 
3848  pkt = &ic->internal->packet_buffer_end->pkt;
3849  } else {
3850  pkt = &pkt1;
3851  }
3852 
3853  st = ic->streams[pkt->stream_index];
3855  read_size += pkt->size;
3856 
3857  avctx = st->internal->avctx;
3858  if (!st->internal->avctx_inited) {
3860  if (ret < 0)
3861  goto unref_then_goto_end;
3862  st->internal->avctx_inited = 1;
3863  }
3864 
3865  if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3866  /* check for non-increasing dts */
3867  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3868  st->info->fps_last_dts >= pkt->dts) {
3869  av_log(ic, AV_LOG_DEBUG,
3870  "Non-increasing DTS in stream %d: packet %d with DTS "
3871  "%"PRId64", packet %d with DTS %"PRId64"\n",
3872  st->index, st->info->fps_last_dts_idx,
3874  pkt->dts);
3875  st->info->fps_first_dts =
3877  }
3878  /* Check for a discontinuity in dts. If the difference in dts
3879  * is more than 1000 times the average packet duration in the
3880  * sequence, we treat it as a discontinuity. */
3881  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3883  (pkt->dts - (uint64_t)st->info->fps_last_dts) / 1000 >
3884  (st->info->fps_last_dts - (uint64_t)st->info->fps_first_dts) /
3885  (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3886  av_log(ic, AV_LOG_WARNING,
3887  "DTS discontinuity in stream %d: packet %d with DTS "
3888  "%"PRId64", packet %d with DTS %"PRId64"\n",
3889  st->index, st->info->fps_last_dts_idx,
3891  pkt->dts);
3892  st->info->fps_first_dts =
3894  }
3895 
3896  /* update stored dts values */
3897  if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3898  st->info->fps_first_dts = pkt->dts;
3900  }
3901  st->info->fps_last_dts = pkt->dts;
3903  }
3904  if (st->codec_info_nb_frames>1) {
3905  int64_t t = 0;
3906  int64_t limit;
3907 
3908  if (st->time_base.den > 0)
3910  if (st->avg_frame_rate.num > 0)
3912 
3913  if ( t == 0
3914  && st->codec_info_nb_frames>30
3915  && st->info->fps_first_dts != AV_NOPTS_VALUE
3916  && st->info->fps_last_dts != AV_NOPTS_VALUE)
3918 
3919  if (analyzed_all_streams) limit = max_analyze_duration;
3920  else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3921  else limit = max_stream_analyze_duration;
3922 
3923  if (t >= limit) {
3924  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3925  limit,
3926  t, pkt->stream_index);
3927  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3928  av_packet_unref(&pkt1);
3929  break;
3930  }
3931  if (pkt->duration) {
3932  if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3934  } else
3936  st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3937  }
3938  }
3939  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3940 #if FF_API_R_FRAME_RATE
3941  ff_rfps_add_frame(ic, st, pkt->dts);
3942 #endif
3943  if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3944  st->info->frame_delay_evidence = 1;
3945  }
3946  if (!st->internal->avctx->extradata) {
3947  ret = extract_extradata(st, pkt);
3948  if (ret < 0)
3949  goto unref_then_goto_end;
3950  }
3951 
3952  /* If still no information, we try to open the codec and to
3953  * decompress the frame. We try to avoid that in most cases as
3954  * it takes longer and uses more memory. For MPEG-4, we need to
3955  * decompress for QuickTime.
3956  *
3957  * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3958  * least one frame of codec data, this makes sure the codec initializes
3959  * the channel configuration and does not only trust the values from
3960  * the container. */
3961  try_decode_frame(ic, st, pkt,
3962  (options && i < orig_nb_streams) ? &options[i] : NULL);
3963 
3964  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3965  av_packet_unref(&pkt1);
3966 
3967  st->codec_info_nb_frames++;
3968  count++;
3969  }
3970 
3971  if (eof_reached) {
3972  int stream_index;
3973  for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3974  st = ic->streams[stream_index];
3975  avctx = st->internal->avctx;
3976  if (!has_codec_parameters(st, NULL)) {
3977  const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3978  if (codec && !avctx->codec) {
3979  AVDictionary *opts = NULL;
3980  if (ic->codec_whitelist)
3981  av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3982  if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3983  av_log(ic, AV_LOG_WARNING,
3984  "Failed to open codec in %s\n",__FUNCTION__);
3985  av_dict_free(&opts);
3986  }
3987  }
3988 
3989  // EOF already reached while reading the stream above.
3990  // So continue with reoordering DTS with whatever delay we have.
3992  update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3993  }
3994  }
3995  }
3996 
3997  if (flush_codecs) {
3998  AVPacket empty_pkt = { 0 };
3999  int err = 0;
4000  av_init_packet(&empty_pkt);
4001 
4002  for (i = 0; i < ic->nb_streams; i++) {
4003 
4004  st = ic->streams[i];
4005 
4006  /* flush the decoders */
4007  if (st->info->found_decoder == 1) {
4008  do {
4009  err = try_decode_frame(ic, st, &empty_pkt,
4010  (options && i < orig_nb_streams)
4011  ? &options[i] : NULL);
4012  } while (err > 0 && !has_codec_parameters(st, NULL));
4013 
4014  if (err < 0) {
4015  av_log(ic, AV_LOG_INFO,
4016  "decoding for stream %d failed\n", st->index);
4017  }
4018  }
4019  }
4020  }
4021 
4022  ff_rfps_calculate(ic);
4023 
4024  for (i = 0; i < ic->nb_streams; i++) {
4025  st = ic->streams[i];
4026  avctx = st->internal->avctx;
4027  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
4028  if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
4029  uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
4031  avctx->codec_tag= tag;
4032  }
4033 
4034  /* estimate average framerate if not set by demuxer */
4035  if (st->info->codec_info_duration_fields &&
4036  !st->avg_frame_rate.num &&
4037  st->info->codec_info_duration) {
4038  int best_fps = 0;
4039  double best_error = 0.01;
4040  AVRational codec_frame_rate = avctx->framerate;
4041 
4042  if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
4043  st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
4044  st->info->codec_info_duration < 0)
4045  continue;
4047  st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
4048  st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
4049 
4050  /* Round guessed framerate to a "standard" framerate if it's
4051  * within 1% of the original estimate. */
4052  for (j = 0; j < MAX_STD_TIMEBASES; j++) {
4053  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
4054  double error = fabs(av_q2d(st->avg_frame_rate) /
4055  av_q2d(std_fps) - 1);
4056 
4057  if (error < best_error) {
4058  best_error = error;
4059  best_fps = std_fps.num;
4060  }
4061 
4062  if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4063  error = fabs(av_q2d(codec_frame_rate) /
4064  av_q2d(std_fps) - 1);
4065  if (error < best_error) {
4066  best_error = error;
4067  best_fps = std_fps.num;
4068  }
4069  }
4070  }
4071  if (best_fps)
4073  best_fps, 12 * 1001, INT_MAX);
4074  }
4075 
4076  if (!st->r_frame_rate.num) {
4077  if ( avctx->time_base.den * (int64_t) st->time_base.num
4078  <= avctx->time_base.num * (uint64_t)avctx->ticks_per_frame * st->time_base.den) {
4080  avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4081  } else {
4082  st->r_frame_rate.num = st->time_base.den;
4083  st->r_frame_rate.den = st->time_base.num;
4084  }
4085  }
4087  AVRational hw_ratio = { avctx->height, avctx->width };
4089  hw_ratio);
4090  }
4091  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4092  if (!avctx->bits_per_coded_sample)
4093  avctx->bits_per_coded_sample =
4095  // set stream disposition based on audio service type
4096  switch (avctx->audio_service_type) {
4099  break;
4102  break;
4105  break;
4108  break;
4111  break;
4112  }
4113  }
4114  }
4115 
4116  if (probesize)
4117  estimate_timings(ic, old_offset);
4118 
4119  av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4120 
4121  if (ret >= 0 && ic->nb_streams)
4122  /* We could not have all the codec parameters before EOF. */
4123  ret = -1;
4124  for (i = 0; i < ic->nb_streams; i++) {
4125  const char *errmsg;
4126  st = ic->streams[i];
4127 
4128  /* if no packet was ever seen, update context now for has_codec_parameters */
4129  if (!st->internal->avctx_inited) {
4130  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4132  st->codecpar->format = st->internal->avctx->sample_fmt;
4134  if (ret < 0)
4135  goto find_stream_info_err;
4136  }
4137  if (!has_codec_parameters(st, &errmsg)) {
4138  char buf[256];
4139  avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4140  av_log(ic, AV_LOG_WARNING,
4141  "Could not find codec parameters for stream %d (%s): %s\n"
4142  "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4143  i, buf, errmsg);
4144  } else {
4145  ret = 0;
4146  }
4147  }
4148 
4150 
4151  /* update the stream parameters from the internal codec contexts */
4152  for (i = 0; i < ic->nb_streams; i++) {
4153  st = ic->streams[i];
4154 
4155  if (st->internal->avctx_inited) {
4156  int orig_w = st->codecpar->width;
4157  int orig_h = st->codecpar->height;
4159  if (ret < 0)
4160  goto find_stream_info_err;
4161  ret = add_coded_side_data(st, st->internal->avctx);
4162  if (ret < 0)
4163  goto find_stream_info_err;
4164 #if FF_API_LOWRES
4165  // The decoder might reduce the video size by the lowres factor.
4166  if (st->internal->avctx->lowres && orig_w) {
4167  st->codecpar->width = orig_w;
4168  st->codecpar->height = orig_h;
4169  }
4170 #endif
4171  }
4172 
4173 #if FF_API_LAVF_AVCTX
4175  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4176  if (ret < 0)
4177  goto find_stream_info_err;
4178 
4179 #if FF_API_LOWRES
4180  // The old API (AVStream.codec) "requires" the resolution to be adjusted
4181  // by the lowres factor.
4182  if (st->internal->avctx->lowres && st->internal->avctx->width) {
4183  st->codec->lowres = st->internal->avctx->lowres;
4184  st->codec->width = st->internal->avctx->width;
4185  st->codec->height = st->internal->avctx->height;
4186  }
4187 #endif
4188 
4189  if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4190  st->codec->time_base = st->internal->avctx->time_base;
4191  st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4192  }
4193  st->codec->framerate = st->avg_frame_rate;
4194 
4195  if (st->internal->avctx->subtitle_header) {
4196  st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4197  if (!st->codec->subtitle_header)
4198  goto find_stream_info_err;
4199  st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4200  memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4201  st->codec->subtitle_header_size);
4202  }
4203 
4204  // Fields unavailable in AVCodecParameters
4205  st->codec->coded_width = st->internal->avctx->coded_width;
4206  st->codec->coded_height = st->internal->avctx->coded_height;
4207  st->codec->properties = st->internal->avctx->properties;
4209 #endif
4210 
4211  st->internal->avctx_inited = 0;
4212  }
4213 
4214 find_stream_info_err:
4215  for (i = 0; i < ic->nb_streams; i++) {
4216  st = ic->streams[i];
4217  if (st->info)
4218  av_freep(&st->info->duration_error);
4220  av_freep(&ic->streams[i]->info);
4223  }
4224  if (ic->pb)
4225  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4226  avi