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