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->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
107  timestamp < st->pts_wrap_reference)
108  return timestamp + (1ULL << st->pts_wrap_bits);
109  else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
110  timestamp >= st->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];
156  st->inject_global_side_data = 1;
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->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->request_probe>0) {
679  AVProbeData *pd = &st->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->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;
735  if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
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]->pts_wrap_reference == AV_NOPTS_VALUE) {
751  for (i = 0; i < s->nb_streams; i++) {
753  continue;
754  s->streams[i]->pts_wrap_reference = pts_wrap_reference;
755  s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
756  }
757  }
758  else {
759  st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
760  st->pts_wrap_behavior = s->streams[default_stream_index]->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]]->pts_wrap_reference = pts_wrap_reference;
780  s->streams[program->stream_index[i]]->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->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->request_probe > 0)
832  if ((err = probe_codec(s, st, NULL)) < 0)
833  return err;
834  av_assert0(st->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->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->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->nb_decoded_frames >= 7;
1004  else if (st->internal->avctx->has_b_frames<4)
1005  return st->nb_decoded_frames >= 18;
1006  else
1007  return st->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->pts_reorder_error_count[i]) {
1031  int64_t score = st->pts_reorder_error[i] / st->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->pts_reorder_error[i];
1043  diff = FFMAX(diff, st->pts_reorder_error[i]);
1044  st->pts_reorder_error[i] = diff;
1045  st->pts_reorder_error_count[i]++;
1046  if (st->pts_reorder_error_count[i] > 250) {
1047  st->pts_reorder_error[i] >>= 1;
1048  st->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->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->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 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1190  pktl->pkt.duration = duration;
1191  } else
1192  break;
1193  cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1194  }
1195  if (!pktl)
1196  st->cur_dts = cur_dts;
1197 }
1198 
1201  int64_t next_dts, int64_t next_pts)
1202 {
1203  int num, den, presentation_delayed, delay, i;
1204  int64_t offset;
1206  int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1208 
1209  if (s->flags & AVFMT_FLAG_NOFILLIN)
1210  return;
1211 
1212  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1213  if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1214  if (st->last_dts_for_order_check <= pkt->dts) {
1215  st->dts_ordered++;
1216  } else {
1218  "DTS %"PRIi64" < %"PRIi64" out of order\n",
1219  pkt->dts,
1221  st->dts_misordered++;
1222  }
1223  if (st->dts_ordered + st->dts_misordered > 250) {
1224  st->dts_ordered >>= 1;
1225  st->dts_misordered >>= 1;
1226  }
1227  }
1228 
1229  st->last_dts_for_order_check = pkt->dts;
1230  if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1231  pkt->dts = AV_NOPTS_VALUE;
1232  }
1233 
1234  if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1235  pkt->dts = AV_NOPTS_VALUE;
1236 
1237  if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1238  && !st->internal->avctx->has_b_frames)
1239  //FIXME Set low_delay = 0 when has_b_frames = 1
1240  st->internal->avctx->has_b_frames = 1;
1241 
1242  /* do we have a video B-frame ? */
1243  delay = st->internal->avctx->has_b_frames;
1244  presentation_delayed = 0;
1245 
1246  /* XXX: need has_b_frame, but cannot get it if the codec is
1247  * not initialized */
1248  if (delay &&
1249  pc && pc->pict_type != AV_PICTURE_TYPE_B)
1250  presentation_delayed = 1;
1251 
1252  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1253  st->pts_wrap_bits < 63 &&
1254  pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1255  if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1256  pkt->dts -= 1LL << st->pts_wrap_bits;
1257  } else
1258  pkt->pts += 1LL << st->pts_wrap_bits;
1259  }
1260 
1261  /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1262  * We take the conservative approach and discard both.
1263  * Note: If this is misbehaving for an H.264 file, then possibly
1264  * presentation_delayed is not set correctly. */
1265  if (delay == 1 && pkt->dts == pkt->pts &&
1266  pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1267  av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1268  if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1269  && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1270  pkt->dts = AV_NOPTS_VALUE;
1271  }
1272 
1273  duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1274  if (pkt->duration <= 0) {
1275  ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1276  if (den && num) {
1277  duration = (AVRational) {num, den};
1278  pkt->duration = av_rescale_rnd(1,
1279  num * (int64_t) st->time_base.den,
1280  den * (int64_t) st->time_base.num,
1281  AV_ROUND_DOWN);
1282  }
1283  }
1284 
1285  if (pkt->duration > 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1286  update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1287 
1288  /* Correct timestamps with byte offset if demuxers only have timestamps
1289  * on packet boundaries */
1290  if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1291  /* this will estimate bitrate based on this frame's duration and size */
1292  offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1293  if (pkt->pts != AV_NOPTS_VALUE)
1294  pkt->pts += offset;
1295  if (pkt->dts != AV_NOPTS_VALUE)
1296  pkt->dts += offset;
1297  }
1298 
1299  /* This may be redundant, but it should not hurt. */
1300  if (pkt->dts != AV_NOPTS_VALUE &&
1301  pkt->pts != AV_NOPTS_VALUE &&
1302  pkt->pts > pkt->dts)
1303  presentation_delayed = 1;
1304 
1305  if (s->debug & FF_FDEBUG_TS)
1306  av_log(s, AV_LOG_DEBUG,
1307  "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1308  presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1309  pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1310 
1311  /* Interpolate PTS and DTS if they are not present. We skip H264
1312  * currently because delay and has_b_frames are not reliably set. */
1313  if ((delay == 0 || (delay == 1 && pc)) &&
1314  onein_oneout) {
1315  if (presentation_delayed) {
1316  /* DTS = decompression timestamp */
1317  /* PTS = presentation timestamp */
1318  if (pkt->dts == AV_NOPTS_VALUE)
1319  pkt->dts = st->last_IP_pts;
1320  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1321  if (pkt->dts == AV_NOPTS_VALUE)
1322  pkt->dts = st->cur_dts;
1323 
1324  /* This is tricky: the dts must be incremented by the duration
1325  * of the frame we are displaying, i.e. the last I- or P-frame. */
1326  if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1327  st->last_IP_duration = pkt->duration;
1328  if (pkt->dts != AV_NOPTS_VALUE)
1329  st->cur_dts = av_sat_add64(pkt->dts, st->last_IP_duration);
1330  if (pkt->dts != AV_NOPTS_VALUE &&
1331  pkt->pts == AV_NOPTS_VALUE &&
1332  st->last_IP_duration > 0 &&
1333  ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1334  next_dts != next_pts &&
1335  next_pts != AV_NOPTS_VALUE)
1336  pkt->pts = next_dts;
1337 
1338  if ((uint64_t)pkt->duration <= INT32_MAX)
1339  st->last_IP_duration = pkt->duration;
1340  st->last_IP_pts = pkt->pts;
1341  /* Cannot compute PTS if not present (we can compute it only
1342  * by knowing the future. */
1343  } else if (pkt->pts != AV_NOPTS_VALUE ||
1344  pkt->dts != AV_NOPTS_VALUE ||
1345  pkt->duration > 0 ) {
1346 
1347  /* presentation is not delayed : PTS and DTS are the same */
1348  if (pkt->pts == AV_NOPTS_VALUE)
1349  pkt->pts = pkt->dts;
1351  pkt->pts, pkt);
1352  if (pkt->pts == AV_NOPTS_VALUE)
1353  pkt->pts = st->cur_dts;
1354  pkt->dts = pkt->pts;
1355  if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1356  st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1357  }
1358  }
1359 
1360  if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1361  st->pts_buffer[0] = pkt->pts;
1362  for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1363  FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1364 
1366  pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1367  }
1368  // We skipped it above so we try here.
1369  if (!onein_oneout)
1370  // This should happen on the first packet
1371  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1372  if (pkt->dts > st->cur_dts)
1373  st->cur_dts = pkt->dts;
1374 
1375  if (s->debug & FF_FDEBUG_TS)
1376  av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1377  presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
1378 
1379  /* update flags */
1381  pkt->flags |= AV_PKT_FLAG_KEY;
1382 #if FF_API_CONVERGENCE_DURATION
1384  if (pc)
1385  pkt->convergence_duration = pc->convergence_duration;
1387 #endif
1388 }
1389 
1390 /**
1391  * Parse a packet, add all split parts to parse_queue.
1392  *
1393  * @param pkt Packet to parse; must not be NULL.
1394  * @param flush Indicates whether to flush. If set, pkt must be blank.
1395  */
1397  int stream_index, int flush)
1398 {
1399  AVPacket out_pkt;
1400  AVStream *st = s->streams[stream_index];
1401  uint8_t *data = pkt->data;
1402  int size = pkt->size;
1403  int ret = 0, got_output = flush;
1404 
1405  if (size || flush) {
1406  av_init_packet(&out_pkt);
1407  } else if (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1408  // preserve 0-size sync packets
1410  }
1411 
1412  while (size > 0 || (flush && got_output)) {
1413  int len;
1414  int64_t next_pts = pkt->pts;
1415  int64_t next_dts = pkt->dts;
1416 
1417  len = av_parser_parse2(st->parser, st->internal->avctx,
1418  &out_pkt.data, &out_pkt.size, data, size,
1419  pkt->pts, pkt->dts, pkt->pos);
1420 
1421  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1422  pkt->pos = -1;
1423  /* increment read pointer */
1424  data += len;
1425  size -= len;
1426 
1427  got_output = !!out_pkt.size;
1428 
1429  if (!out_pkt.size)
1430  continue;
1431 
1432  if (pkt->buf && out_pkt.data == pkt->data) {
1433  /* reference pkt->buf only when out_pkt.data is guaranteed to point
1434  * to data in it and not in the parser's internal buffer. */
1435  /* XXX: Ensure this is the case with all parsers when st->parser->flags
1436  * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1437  out_pkt.buf = av_buffer_ref(pkt->buf);
1438  if (!out_pkt.buf) {
1439  ret = AVERROR(ENOMEM);
1440  goto fail;
1441  }
1442  } else {
1443  ret = av_packet_make_refcounted(&out_pkt);
1444  if (ret < 0)
1445  goto fail;
1446  }
1447 
1448  if (pkt->side_data) {
1449  out_pkt.side_data = pkt->side_data;
1450  out_pkt.side_data_elems = pkt->side_data_elems;
1451  pkt->side_data = NULL;
1452  pkt->side_data_elems = 0;
1453  }
1454 
1455  /* set the duration */
1456  out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1458  if (st->internal->avctx->sample_rate > 0) {
1459  out_pkt.duration =
1461  (AVRational) { 1, st->internal->avctx->sample_rate },
1462  st->time_base,
1463  AV_ROUND_DOWN);
1464  }
1465  }
1466 
1467  out_pkt.stream_index = st->index;
1468  out_pkt.pts = st->parser->pts;
1469  out_pkt.dts = st->parser->dts;
1470  out_pkt.pos = st->parser->pos;
1471  out_pkt.flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1472 
1474  out_pkt.pos = st->parser->frame_offset;
1475 
1476  if (st->parser->key_frame == 1 ||
1477  (st->parser->key_frame == -1 &&
1479  out_pkt.flags |= AV_PKT_FLAG_KEY;
1480 
1481  if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1482  out_pkt.flags |= AV_PKT_FLAG_KEY;
1483 
1484  compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1485 
1488  &out_pkt, NULL, 0);
1489  if (ret < 0) {
1490  av_packet_unref(&out_pkt);
1491  goto fail;
1492  }
1493  }
1494 
1495  /* end of the stream => close and free the parser */
1496  if (flush) {
1497  av_parser_close(st->parser);
1498  st->parser = NULL;
1499  }
1500 
1501 fail:
1502  av_packet_unref(pkt);
1503  return ret;
1504 }
1505 
1506 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1507 {
1508  return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1509 }
1510 
1512 {
1513  int ret, i, got_packet = 0;
1514  AVDictionary *metadata = NULL;
1515 
1516  while (!got_packet && !s->internal->parse_queue) {
1517  AVStream *st;
1518 
1519  /* read next packet */
1520  ret = ff_read_packet(s, pkt);
1521  if (ret < 0) {
1522  if (ret == AVERROR(EAGAIN))
1523  return ret;
1524  /* flush the parsers */
1525  for (i = 0; i < s->nb_streams; i++) {
1526  st = s->streams[i];
1527  if (st->parser && st->need_parsing)
1528  parse_packet(s, pkt, st->index, 1);
1529  }
1530  /* all remaining packets are now in parse_queue =>
1531  * really terminate parsing */
1532  break;
1533  }
1534  ret = 0;
1535  st = s->streams[pkt->stream_index];
1536 
1537  /* update context if required */
1538  if (st->internal->need_context_update) {
1539  if (avcodec_is_open(st->internal->avctx)) {
1540  av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1542  st->info->found_decoder = 0;
1543  }
1544 
1545  /* close parser, because it depends on the codec */
1546  if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1547  av_parser_close(st->parser);
1548  st->parser = NULL;
1549  }
1550 
1552  if (ret < 0) {
1553  av_packet_unref(pkt);
1554  return ret;
1555  }
1556 
1557 #if FF_API_LAVF_AVCTX
1559  /* update deprecated public codec context */
1560  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1561  if (ret < 0) {
1562  av_packet_unref(pkt);
1563  return ret;
1564  }
1566 #endif
1567 
1568  st->internal->need_context_update = 0;
1569  }
1570 
1571  if (pkt->pts != AV_NOPTS_VALUE &&
1572  pkt->dts != AV_NOPTS_VALUE &&
1573  pkt->pts < pkt->dts) {
1575  "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1576  pkt->stream_index,
1577  av_ts2str(pkt->pts),
1578  av_ts2str(pkt->dts),
1579  pkt->size);
1580  }
1581  if (s->debug & FF_FDEBUG_TS)
1582  av_log(s, AV_LOG_DEBUG,
1583  "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1584  pkt->stream_index,
1585  av_ts2str(pkt->pts),
1586  av_ts2str(pkt->dts),
1587  pkt->size, pkt->duration, pkt->flags);
1588 
1589  if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1590  st->parser = av_parser_init(st->codecpar->codec_id);
1591  if (!st->parser) {
1592  av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1593  "%s, packets or times may be invalid.\n",
1595  /* no parser available: just output the raw packets */
1597  } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1599  else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1600  st->parser->flags |= PARSER_FLAG_ONCE;
1601  else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1603  }
1604 
1605  if (!st->need_parsing || !st->parser) {
1606  /* no parsing needed: we just output the packet as is */
1608  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1609  (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1610  ff_reduce_index(s, st->index);
1611  av_add_index_entry(st, pkt->pos, pkt->dts,
1612  0, 0, AVINDEX_KEYFRAME);
1613  }
1614  got_packet = 1;
1615  } else if (st->discard < AVDISCARD_ALL) {
1616  if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1617  return ret;
1619  st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1620  st->codecpar->channels = st->internal->avctx->channels;
1622  st->codecpar->codec_id = st->internal->avctx->codec_id;
1623  } else {
1624  /* free packet */
1625  av_packet_unref(pkt);
1626  }
1627  if (pkt->flags & AV_PKT_FLAG_KEY)
1628  st->skip_to_keyframe = 0;
1629  if (st->skip_to_keyframe) {
1630  av_packet_unref(pkt);
1631  got_packet = 0;
1632  }
1633  }
1634 
1635  if (!got_packet && s->internal->parse_queue)
1637 
1638  if (ret >= 0) {
1639  AVStream *st = s->streams[pkt->stream_index];
1640  int discard_padding = 0;
1641  if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1642  int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1643  int64_t sample = ts_to_samples(st, pts);
1644  int duration = ts_to_samples(st, pkt->duration);
1645  int64_t end_sample = sample + duration;
1646  if (duration > 0 && end_sample >= st->first_discard_sample &&
1647  sample < st->last_discard_sample)
1648  discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1649  }
1650  if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1651  st->skip_samples = st->start_skip_samples;
1652  if (st->skip_samples || discard_padding) {
1654  if (p) {
1655  AV_WL32(p, st->skip_samples);
1656  AV_WL32(p + 4, discard_padding);
1657  av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1658  }
1659  st->skip_samples = 0;
1660  }
1661 
1662  if (st->inject_global_side_data) {
1663  for (i = 0; i < st->nb_side_data; i++) {
1664  AVPacketSideData *src_sd = &st->side_data[i];
1665  uint8_t *dst_data;
1666 
1667  if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1668  continue;
1669 
1670  dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1671  if (!dst_data) {
1672  av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1673  continue;
1674  }
1675 
1676  memcpy(dst_data, src_sd->data, src_sd->size);
1677  }
1678  st->inject_global_side_data = 0;
1679  }
1680  }
1681 
1682  av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1683  if (metadata) {
1685  av_dict_copy(&s->metadata, metadata, 0);
1686  av_dict_free(&metadata);
1688  }
1689 
1690 #if FF_API_LAVF_AVCTX
1692 #endif
1693 
1694  if (s->debug & FF_FDEBUG_TS)
1695  av_log(s, AV_LOG_DEBUG,
1696  "read_frame_internal stream=%d, pts=%s, dts=%s, "
1697  "size=%d, duration=%"PRId64", flags=%d\n",
1698  pkt->stream_index,
1699  av_ts2str(pkt->pts),
1700  av_ts2str(pkt->dts),
1701  pkt->size, pkt->duration, pkt->flags);
1702 
1703  /* A demuxer might have returned EOF because of an IO error, let's
1704  * propagate this back to the user. */
1705  if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1706  ret = s->pb->error;
1707 
1708  return ret;
1709 }
1710 
1712 {
1713  const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1714  int eof = 0;
1715  int ret;
1716  AVStream *st;
1717 
1718  if (!genpts) {
1719  ret = s->internal->packet_buffer
1721  &s->internal->packet_buffer_end, pkt)
1722  : read_frame_internal(s, pkt);
1723  if (ret < 0)
1724  return ret;
1725  goto return_packet;
1726  }
1727 
1728  for (;;) {
1729  AVPacketList *pktl = s->internal->packet_buffer;
1730 
1731  if (pktl) {
1732  AVPacket *next_pkt = &pktl->pkt;
1733 
1734  if (next_pkt->dts != AV_NOPTS_VALUE) {
1735  int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1736  // last dts seen for this stream. if any of packets following
1737  // current one had no dts, we will set this to AV_NOPTS_VALUE.
1738  int64_t last_dts = next_pkt->dts;
1739  av_assert2(wrap_bits <= 64);
1740  while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1741  if (pktl->pkt.stream_index == next_pkt->stream_index &&
1742  av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1743  if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1744  // not B-frame
1745  next_pkt->pts = pktl->pkt.dts;
1746  }
1747  if (last_dts != AV_NOPTS_VALUE) {
1748  // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1749  last_dts = pktl->pkt.dts;
1750  }
1751  }
1752  pktl = pktl->next;
1753  }
1754  if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1755  // Fixing the last reference frame had none pts issue (For MXF etc).
1756  // We only do this when
1757  // 1. eof.
1758  // 2. we are not able to resolve a pts value for current packet.
1759  // 3. the packets for this stream at the end of the files had valid dts.
1760  next_pkt->pts = last_dts + next_pkt->duration;
1761  }
1762  pktl = s->internal->packet_buffer;
1763  }
1764 
1765  /* read packet from packet buffer, if there is data */
1766  st = s->streams[next_pkt->stream_index];
1767  if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1768  next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1770  &s->internal->packet_buffer_end, pkt);
1771  goto return_packet;
1772  }
1773  }
1774 
1775  ret = read_frame_internal(s, pkt);
1776  if (ret < 0) {
1777  if (pktl && ret != AVERROR(EAGAIN)) {
1778  eof = 1;
1779  continue;
1780  } else
1781  return ret;
1782  }
1783 
1786  pkt, NULL, 0);
1787  if (ret < 0) {
1788  av_packet_unref(pkt);
1789  return ret;
1790  }
1791  }
1792 
1793 return_packet:
1794 
1795  st = s->streams[pkt->stream_index];
1796  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1797  ff_reduce_index(s, st->index);
1798  av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1799  }
1800 
1801  if (is_relative(pkt->dts))
1802  pkt->dts -= RELATIVE_TS_BASE;
1803  if (is_relative(pkt->pts))
1804  pkt->pts -= RELATIVE_TS_BASE;
1805 
1806  return ret;
1807 }
1808 
1809 /* XXX: suppress the packet queue */
1811 {
1812  if (!s->internal)
1813  return;
1817 
1819 }
1820 
1821 /*******************************************************/
1822 /* seek support */
1823 
1825 {
1826  int i;
1827  AVStream *st;
1828  int best_stream = 0;
1829  int best_score = INT_MIN;
1830 
1831  if (s->nb_streams <= 0)
1832  return -1;
1833  for (i = 0; i < s->nb_streams; i++) {
1834  int score = 0;
1835  st = s->streams[i];
1836  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1838  score -= 400;
1839  if (st->codecpar->width && st->codecpar->height)
1840  score += 50;
1841  score+= 25;
1842  }
1843  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1844  if (st->codecpar->sample_rate)
1845  score += 50;
1846  }
1847  if (st->codec_info_nb_frames)
1848  score += 12;
1849 
1850  if (st->discard != AVDISCARD_ALL)
1851  score += 200;
1852 
1853  if (score > best_score) {
1854  best_score = score;
1855  best_stream = i;
1856  }
1857  }
1858  return best_stream;
1859 }
1860 
1861 /** Flush the frame reader. */
1863 {
1864  AVStream *st;
1865  int i, j;
1866 
1867  flush_packet_queue(s);
1868 
1869  /* Reset read state for each stream. */
1870  for (i = 0; i < s->nb_streams; i++) {
1871  st = s->streams[i];
1872 
1873  if (st->parser) {
1874  av_parser_close(st->parser);
1875  st->parser = NULL;
1876  }
1879  if (st->first_dts == AV_NOPTS_VALUE)
1880  st->cur_dts = RELATIVE_TS_BASE;
1881  else
1882  /* We set the current DTS to an unspecified origin. */
1883  st->cur_dts = AV_NOPTS_VALUE;
1884 
1886 
1887  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1888  st->pts_buffer[j] = AV_NOPTS_VALUE;
1889 
1891  st->inject_global_side_data = 1;
1892 
1893  st->skip_samples = 0;
1894  }
1895 }
1896 
1897 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1898 {
1899  int i;
1900 
1901  for (i = 0; i < s->nb_streams; i++) {
1902  AVStream *st = s->streams[i];
1903 
1904  st->cur_dts =
1905  av_rescale(timestamp,
1906  st->time_base.den * (int64_t) ref_st->time_base.num,
1907  st->time_base.num * (int64_t) ref_st->time_base.den);
1908  }
1909 }
1910 
1911 void ff_reduce_index(AVFormatContext *s, int stream_index)
1912 {
1913  AVStream *st = s->streams[stream_index];
1914  unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1915 
1916  if ((unsigned) st->nb_index_entries >= max_entries) {
1917  int i;
1918  for (i = 0; 2 * i < st->nb_index_entries; i++)
1919  st->index_entries[i] = st->index_entries[2 * i];
1920  st->nb_index_entries = i;
1921  }
1922 }
1923 
1924 int ff_add_index_entry(AVIndexEntry **index_entries,
1925  int *nb_index_entries,
1926  unsigned int *index_entries_allocated_size,
1927  int64_t pos, int64_t timestamp,
1928  int size, int distance, int flags)
1929 {
1930  AVIndexEntry *entries, *ie;
1931  int index;
1932 
1933  if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1934  return -1;
1935 
1936  if (timestamp == AV_NOPTS_VALUE)
1937  return AVERROR(EINVAL);
1938 
1939  if (size < 0 || size > 0x3FFFFFFF)
1940  return AVERROR(EINVAL);
1941 
1942  if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1943  timestamp -= RELATIVE_TS_BASE;
1944 
1945  entries = av_fast_realloc(*index_entries,
1946  index_entries_allocated_size,
1947  (*nb_index_entries + 1) *
1948  sizeof(AVIndexEntry));
1949  if (!entries)
1950  return -1;
1951 
1952  *index_entries = entries;
1953 
1954  index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1955  timestamp, AVSEEK_FLAG_ANY);
1956 
1957  if (index < 0) {
1958  index = (*nb_index_entries)++;
1959  ie = &entries[index];
1960  av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1961  } else {
1962  ie = &entries[index];
1963  if (ie->timestamp != timestamp) {
1964  if (ie->timestamp <= timestamp)
1965  return -1;
1966  memmove(entries + index + 1, entries + index,
1967  sizeof(AVIndexEntry) * (*nb_index_entries - index));
1968  (*nb_index_entries)++;
1969  } else if (ie->pos == pos && distance < ie->min_distance)
1970  // do not reduce the distance
1971  distance = ie->min_distance;
1972  }
1973 
1974  ie->pos = pos;
1975  ie->timestamp = timestamp;
1976  ie->min_distance = distance;
1977  ie->size = size;
1978  ie->flags = flags;
1979 
1980  return index;
1981 }
1982 
1983 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1984  int size, int distance, int flags)
1985 {
1986  timestamp = wrap_timestamp(st, timestamp);
1988  &st->index_entries_allocated_size, pos,
1989  timestamp, size, distance, flags);
1990 }
1991 
1992 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1993  int64_t wanted_timestamp, int flags)
1994 {
1995  int a, b, m;
1996  int64_t timestamp;
1997 
1998  a = -1;
1999  b = nb_entries;
2000 
2001  // Optimize appending index entries at the end.
2002  if (b && entries[b - 1].timestamp < wanted_timestamp)
2003  a = b - 1;
2004 
2005  while (b - a > 1) {
2006  m = (a + b) >> 1;
2007 
2008  // Search for the next non-discarded packet.
2009  while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2010  m++;
2011  if (m == b && entries[m].timestamp >= wanted_timestamp) {
2012  m = b - 1;
2013  break;
2014  }
2015  }
2016 
2017  timestamp = entries[m].timestamp;
2018  if (timestamp >= wanted_timestamp)
2019  b = m;
2020  if (timestamp <= wanted_timestamp)
2021  a = m;
2022  }
2023  m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2024 
2025  if (!(flags & AVSEEK_FLAG_ANY))
2026  while (m >= 0 && m < nb_entries &&
2027  !(entries[m].flags & AVINDEX_KEYFRAME))
2028  m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2029 
2030  if (m == nb_entries)
2031  return -1;
2032  return m;
2033 }
2034 
2035 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2036 {
2037  int ist1, ist2;
2038  int64_t pos_delta = 0;
2039  int64_t skip = 0;
2040  //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2041  const char *proto = avio_find_protocol_name(s->url);
2042 
2043  av_assert0(time_tolerance >= 0);
2044 
2045  if (!proto) {
2046  av_log(s, AV_LOG_INFO,
2047  "Protocol name not provided, cannot determine if input is local or "
2048  "a network protocol, buffers and access patterns cannot be configured "
2049  "optimally without knowing the protocol\n");
2050  }
2051 
2052  if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2053  return;
2054 
2055  for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2056  AVStream *st1 = s->streams[ist1];
2057  for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2058  AVStream *st2 = s->streams[ist2];
2059  int i1, i2;
2060 
2061  if (ist1 == ist2)
2062  continue;
2063 
2064  for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2065  AVIndexEntry *e1 = &st1->index_entries[i1];
2066  int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2067 
2068  skip = FFMAX(skip, e1->size);
2069  for (; i2 < st2->nb_index_entries; i2++) {
2070  AVIndexEntry *e2 = &st2->index_entries[i2];
2071  int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2072  if (e2_pts < e1_pts || e2_pts - (uint64_t)e1_pts < time_tolerance)
2073  continue;
2074  pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2075  break;
2076  }
2077  }
2078  }
2079  }
2080 
2081  pos_delta *= 2;
2082  /* XXX This could be adjusted depending on protocol*/
2083  if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2084  av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2085 
2086  /* realloc the buffer and the original data will be retained */
2087  if (ffio_realloc_buf(s->pb, pos_delta)) {
2088  av_log(s, AV_LOG_ERROR, "Realloc buffer fail.\n");
2089  return;
2090  }
2091 
2092  s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2093  }
2094 
2095  if (skip < (1<<23)) {
2097  }
2098 }
2099 
2100 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2101 {
2103  wanted_timestamp, flags);
2104 }
2105 
2106 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2107  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2108 {
2109  int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2110  if (stream_index >= 0)
2111  ts = wrap_timestamp(s->streams[stream_index], ts);
2112  return ts;
2113 }
2114 
2115 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2116  int64_t target_ts, int flags)
2117 {
2118  const AVInputFormat *avif = s->iformat;
2119  int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2120  int64_t ts_min, ts_max, ts;
2121  int index;
2122  int64_t ret;
2123  AVStream *st;
2124 
2125  if (stream_index < 0)
2126  return -1;
2127 
2128  av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2129 
2130  ts_max =
2131  ts_min = AV_NOPTS_VALUE;
2132  pos_limit = -1; // GCC falsely says it may be uninitialized.
2133 
2134  st = s->streams[stream_index];
2135  if (st->index_entries) {
2136  AVIndexEntry *e;
2137 
2138  /* FIXME: Whole function must be checked for non-keyframe entries in
2139  * index case, especially read_timestamp(). */
2140  index = av_index_search_timestamp(st, target_ts,
2141  flags | AVSEEK_FLAG_BACKWARD);
2142  index = FFMAX(index, 0);
2143  e = &st->index_entries[index];
2144 
2145  if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2146  pos_min = e->pos;
2147  ts_min = e->timestamp;
2148  av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2149  pos_min, av_ts2str(ts_min));
2150  } else {
2151  av_assert1(index == 0);
2152  }
2153 
2154  index = av_index_search_timestamp(st, target_ts,
2155  flags & ~AVSEEK_FLAG_BACKWARD);
2156  av_assert0(index < st->nb_index_entries);
2157  if (index >= 0) {
2158  e = &st->index_entries[index];
2159  av_assert1(e->timestamp >= target_ts);
2160  pos_max = e->pos;
2161  ts_max = e->timestamp;
2162  pos_limit = pos_max - e->min_distance;
2163  av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2164  " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2165  }
2166  }
2167 
2168  pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2169  ts_min, ts_max, flags, &ts, avif->read_timestamp);
2170  if (pos < 0)
2171  return -1;
2172 
2173  /* do the seek */
2174  if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2175  return ret;
2176 
2178  ff_update_cur_dts(s, st, ts);
2179 
2180  return 0;
2181 }
2182 
2183 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2184  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2185 {
2186  int64_t step = 1024;
2187  int64_t limit, ts_max;
2188  int64_t filesize = avio_size(s->pb);
2189  int64_t pos_max = filesize - 1;
2190  do {
2191  limit = pos_max;
2192  pos_max = FFMAX(0, (pos_max) - step);
2193  ts_max = ff_read_timestamp(s, stream_index,
2194  &pos_max, limit, read_timestamp);
2195  step += step;
2196  } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2197  if (ts_max == AV_NOPTS_VALUE)
2198  return -1;
2199 
2200  for (;;) {
2201  int64_t tmp_pos = pos_max + 1;
2202  int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2203  &tmp_pos, INT64_MAX, read_timestamp);
2204  if (tmp_ts == AV_NOPTS_VALUE)
2205  break;
2206  av_assert0(tmp_pos > pos_max);
2207  ts_max = tmp_ts;
2208  pos_max = tmp_pos;
2209  if (tmp_pos >= filesize)
2210  break;
2211  }
2212 
2213  if (ts)
2214  *ts = ts_max;
2215  if (pos)
2216  *pos = pos_max;
2217 
2218  return 0;
2219 }
2220 
2221 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2222  int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2223  int64_t ts_min, int64_t ts_max,
2224  int flags, int64_t *ts_ret,
2225  int64_t (*read_timestamp)(struct AVFormatContext *, int,
2226  int64_t *, int64_t))
2227 {
2228  int64_t pos, ts;
2229  int64_t start_pos;
2230  int no_change;
2231  int ret;
2232 
2233  av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2234 
2235  if (ts_min == AV_NOPTS_VALUE) {
2236  pos_min = s->internal->data_offset;
2237  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2238  if (ts_min == AV_NOPTS_VALUE)
2239  return -1;
2240  }
2241 
2242  if (ts_min >= target_ts) {
2243  *ts_ret = ts_min;
2244  return pos_min;
2245  }
2246 
2247  if (ts_max == AV_NOPTS_VALUE) {
2248  if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2249  return ret;
2250  pos_limit = pos_max;
2251  }
2252 
2253  if (ts_max <= target_ts) {
2254  *ts_ret = ts_max;
2255  return pos_max;
2256  }
2257 
2258  av_assert0(ts_min < ts_max);
2259 
2260  no_change = 0;
2261  while (pos_min < pos_limit) {
2262  av_log(s, AV_LOG_TRACE,
2263  "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2264  pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2265  av_assert0(pos_limit <= pos_max);
2266 
2267  if (no_change == 0) {
2268  int64_t approximate_keyframe_distance = pos_max - pos_limit;
2269  // interpolate position (better than dichotomy)
2270  pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2271  ts_max - ts_min) +
2272  pos_min - approximate_keyframe_distance;
2273  } else if (no_change == 1) {
2274  // bisection if interpolation did not change min / max pos last time
2275  pos = (pos_min + pos_limit) >> 1;
2276  } else {
2277  /* linear search if bisection failed, can only happen if there
2278  * are very few or no keyframes between min/max */
2279  pos = pos_min;
2280  }
2281  if (pos <= pos_min)
2282  pos = pos_min + 1;
2283  else if (pos > pos_limit)
2284  pos = pos_limit;
2285  start_pos = pos;
2286 
2287  // May pass pos_limit instead of -1.
2288  ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2289  if (pos == pos_max)
2290  no_change++;
2291  else
2292  no_change = 0;
2293  av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2294  " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2295  pos_min, pos, pos_max,
2296  av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2297  pos_limit, start_pos, no_change);
2298  if (ts == AV_NOPTS_VALUE) {
2299  av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2300  return -1;
2301  }
2302  if (target_ts <= ts) {
2303  pos_limit = start_pos - 1;
2304  pos_max = pos;
2305  ts_max = ts;
2306  }
2307  if (target_ts >= ts) {
2308  pos_min = pos;
2309  ts_min = ts;
2310  }
2311  }
2312 
2313  pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2314  ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2315 #if 0
2316  pos_min = pos;
2317  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2318  pos_min++;
2319  ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2320  av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2321  pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2322 #endif
2323  *ts_ret = ts;
2324  return pos;
2325 }
2326 
2327 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2328  int64_t pos, int flags)
2329 {
2330  int64_t pos_min, pos_max;
2331 
2332  pos_min = s->internal->data_offset;
2333  pos_max = avio_size(s->pb) - 1;
2334 
2335  if (pos < pos_min)
2336  pos = pos_min;
2337  else if (pos > pos_max)
2338  pos = pos_max;
2339 
2340  avio_seek(s->pb, pos, SEEK_SET);
2341 
2342  s->io_repositioned = 1;
2343 
2344  return 0;
2345 }
2346 
2347 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2348  int64_t timestamp, int flags)
2349 {
2350  int index;
2351  int64_t ret;
2352  AVStream *st;
2353  AVIndexEntry *ie;
2354 
2355  st = s->streams[stream_index];
2356 
2357  index = av_index_search_timestamp(st, timestamp, flags);
2358 
2359  if (index < 0 && st->nb_index_entries &&
2360  timestamp < st->index_entries[0].timestamp)
2361  return -1;
2362 
2363  if (index < 0 || index == st->nb_index_entries - 1) {
2364  AVPacket pkt;
2365  int nonkey = 0;
2366 
2367  if (st->nb_index_entries) {
2369  ie = &st->index_entries[st->nb_index_entries - 1];
2370  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2371  return ret;
2372  ff_update_cur_dts(s, st, ie->timestamp);
2373  } else {
2374  if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2375  return ret;
2376  }
2377  for (;;) {
2378  int read_status;
2379  do {
2380  read_status = av_read_frame(s, &pkt);
2381  } while (read_status == AVERROR(EAGAIN));
2382  if (read_status < 0)
2383  break;
2384  if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2385  if (pkt.flags & AV_PKT_FLAG_KEY) {
2386  av_packet_unref(&pkt);
2387  break;
2388  }
2389  if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2390  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);
2391  av_packet_unref(&pkt);
2392  break;
2393  }
2394  }
2395  av_packet_unref(&pkt);
2396  }
2397  index = av_index_search_timestamp(st, timestamp, flags);
2398  }
2399  if (index < 0)
2400  return -1;
2401 
2403  if (s->iformat->read_seek)
2404  if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2405  return 0;
2406  ie = &st->index_entries[index];
2407  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2408  return ret;
2409  ff_update_cur_dts(s, st, ie->timestamp);
2410 
2411  return 0;
2412 }
2413 
2414 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2415  int64_t timestamp, int flags)
2416 {
2417  int ret;
2418  AVStream *st;
2419 
2420  if (flags & AVSEEK_FLAG_BYTE) {
2421  if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2422  return -1;
2424  return seek_frame_byte(s, stream_index, timestamp, flags);
2425  }
2426 
2427  if (stream_index < 0) {
2428  stream_index = av_find_default_stream_index(s);
2429  if (stream_index < 0)
2430  return -1;
2431 
2432  st = s->streams[stream_index];
2433  /* timestamp for default must be expressed in AV_TIME_BASE units */
2434  timestamp = av_rescale(timestamp, st->time_base.den,
2435  AV_TIME_BASE * (int64_t) st->time_base.num);
2436  }
2437 
2438  /* first, we try the format specific seek */
2439  if (s->iformat->read_seek) {
2441  ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2442  } else
2443  ret = -1;
2444  if (ret >= 0)
2445  return 0;
2446 
2447  if (s->iformat->read_timestamp &&
2448  !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2450  return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2451  } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2453  return seek_frame_generic(s, stream_index, timestamp, flags);
2454  } else
2455  return -1;
2456 }
2457 
2458 int av_seek_frame(AVFormatContext *s, int stream_index,
2459  int64_t timestamp, int flags)
2460 {
2461  int ret;
2462 
2463  if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2464  int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2465  if ((flags & AVSEEK_FLAG_BACKWARD))
2466  max_ts = timestamp;
2467  else
2468  min_ts = timestamp;
2469  return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2470  flags & ~AVSEEK_FLAG_BACKWARD);
2471  }
2472 
2473  ret = seek_frame_internal(s, stream_index, timestamp, flags);
2474 
2475  if (ret >= 0)
2477 
2478  return ret;
2479 }
2480 
2481 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2482  int64_t ts, int64_t max_ts, int flags)
2483 {
2484  if (min_ts > ts || max_ts < ts)
2485  return -1;
2486  if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2487  return AVERROR(EINVAL);
2488 
2489  if (s->seek2any>0)
2490  flags |= AVSEEK_FLAG_ANY;
2491  flags &= ~AVSEEK_FLAG_BACKWARD;
2492 
2493  if (s->iformat->read_seek2) {
2494  int ret;
2496 
2497  if (stream_index == -1 && s->nb_streams == 1) {
2498  AVRational time_base = s->streams[0]->time_base;
2499  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2500  min_ts = av_rescale_rnd(min_ts, time_base.den,
2501  time_base.num * (int64_t)AV_TIME_BASE,
2503  max_ts = av_rescale_rnd(max_ts, time_base.den,
2504  time_base.num * (int64_t)AV_TIME_BASE,
2506  stream_index = 0;
2507  }
2508 
2509  ret = s->iformat->read_seek2(s, stream_index, min_ts,
2510  ts, max_ts, flags);
2511 
2512  if (ret >= 0)
2514  return ret;
2515  }
2516 
2517  if (s->iformat->read_timestamp) {
2518  // try to seek via read_timestamp()
2519  }
2520 
2521  // Fall back on old API if new is not implemented but old is.
2522  // Note the old API has somewhat different semantics.
2523  if (s->iformat->read_seek || 1) {
2524  int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2525  int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2526  if (ret<0 && ts != min_ts && max_ts != ts) {
2527  ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2528  if (ret >= 0)
2529  ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2530  }
2531  return ret;
2532  }
2533 
2534  // try some generic seek like seek_frame_generic() but with new ts semantics
2535  return -1; //unreachable
2536 }
2537 
2539 {
2541  return 0;
2542 }
2543 
2544 /*******************************************************/
2545 
2546 /**
2547  * Return TRUE if the stream has accurate duration in any stream.
2548  *
2549  * @return TRUE if the stream has accurate duration for at least one component.
2550  */
2552 {
2553  int i;
2554  AVStream *st;
2555 
2556  for (i = 0; i < ic->nb_streams; i++) {
2557  st = ic->streams[i];
2558  if (st->duration != AV_NOPTS_VALUE)
2559  return 1;
2560  }
2561  if (ic->duration != AV_NOPTS_VALUE)
2562  return 1;
2563  return 0;
2564 }
2565 
2566 /**
2567  * Estimate the stream timings from the one of each components.
2568  *
2569  * Also computes the global bitrate if possible.
2570  */
2572 {
2573  int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2574  int64_t duration, duration1, duration_text, filesize;
2575  int i;
2576  AVProgram *p;
2577 
2578  start_time = INT64_MAX;
2579  start_time_text = INT64_MAX;
2580  end_time = INT64_MIN;
2581  end_time_text = INT64_MIN;
2582  duration = INT64_MIN;
2583  duration_text = INT64_MIN;
2584 
2585  for (i = 0; i < ic->nb_streams; i++) {
2586  AVStream *st = ic->streams[i];
2587  int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2589  if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2590  start_time1 = av_rescale_q(st->start_time, st->time_base,
2591  AV_TIME_BASE_Q);
2592  if (is_text)
2593  start_time_text = FFMIN(start_time_text, start_time1);
2594  else
2595  start_time = FFMIN(start_time, start_time1);
2596  end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2599  if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2600  end_time1 += start_time1;
2601  if (is_text)
2602  end_time_text = FFMAX(end_time_text, end_time1);
2603  else
2604  end_time = FFMAX(end_time, end_time1);
2605  }
2606  for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2607  if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2608  p->start_time = start_time1;
2609  if (p->end_time < end_time1)
2610  p->end_time = end_time1;
2611  }
2612  }
2613  if (st->duration != AV_NOPTS_VALUE) {
2614  duration1 = av_rescale_q(st->duration, st->time_base,
2615  AV_TIME_BASE_Q);
2616  if (is_text)
2617  duration_text = FFMAX(duration_text, duration1);
2618  else
2619  duration = FFMAX(duration, duration1);
2620  }
2621  }
2622  if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2623  start_time = start_time_text;
2624  else if (start_time > start_time_text)
2625  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2626 
2627  if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2628  end_time = end_time_text;
2629  else if (end_time < end_time_text)
2630  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2631 
2632  if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2633  duration = duration_text;
2634  else if (duration < duration_text)
2635  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2636 
2637  if (start_time != INT64_MAX) {
2638  ic->start_time = start_time;
2639  if (end_time != INT64_MIN) {
2640  if (ic->nb_programs > 1) {
2641  for (i = 0; i < ic->nb_programs; i++) {
2642  p = ic->programs[i];
2643  if (p->start_time != AV_NOPTS_VALUE &&
2644  p->end_time > p->start_time &&
2645  p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2646  duration = FFMAX(duration, p->end_time - p->start_time);
2647  }
2648  } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2649  duration = FFMAX(duration, end_time - start_time);
2650  }
2651  }
2652  }
2653  if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2654  ic->duration = duration;
2655  }
2656  if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2657  /* compute the bitrate */
2658  double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2659  (double) ic->duration;
2660  if (bitrate >= 0 && bitrate <= INT64_MAX)
2661  ic->bit_rate = bitrate;
2662  }
2663 }
2664 
2666 {
2667  int i;
2668  AVStream *st;
2669 
2671  for (i = 0; i < ic->nb_streams; i++) {
2672  st = ic->streams[i];
2673  if (st->start_time == AV_NOPTS_VALUE) {
2674  if (ic->start_time != AV_NOPTS_VALUE)
2676  st->time_base);
2677  if (ic->duration != AV_NOPTS_VALUE)
2679  st->time_base);
2680  }
2681  }
2682 }
2683 
2685 {
2686  int64_t filesize, duration;
2687  int i, show_warning = 0;
2688  AVStream *st;
2689 
2690  /* if bit_rate is already set, we believe it */
2691  if (ic->bit_rate <= 0) {
2692  int64_t bit_rate = 0;
2693  for (i = 0; i < ic->nb_streams; i++) {
2694  st = ic->streams[i];
2695  if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2696  st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2697  if (st->codecpar->bit_rate > 0) {
2698  if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2699  bit_rate = 0;
2700  break;
2701  }
2702  bit_rate += st->codecpar->bit_rate;
2703  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2704  // If we have a videostream with packets but without a bitrate
2705  // then consider the sum not known
2706  bit_rate = 0;
2707  break;
2708  }
2709  }
2710  ic->bit_rate = bit_rate;
2711  }
2712 
2713  /* if duration is already set, we believe it */
2714  if (ic->duration == AV_NOPTS_VALUE &&
2715  ic->bit_rate != 0) {
2716  filesize = ic->pb ? avio_size(ic->pb) : 0;
2717  if (filesize > ic->internal->data_offset) {
2718  filesize -= ic->internal->data_offset;
2719  for (i = 0; i < ic->nb_streams; i++) {
2720  st = ic->streams[i];
2721  if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2722  && st->duration == AV_NOPTS_VALUE) {
2723  duration = av_rescale(filesize, 8LL * st->time_base.den,
2724  ic->bit_rate *
2725  (int64_t) st->time_base.num);
2726  st->duration = duration;
2727  show_warning = 1;
2728  }
2729  }
2730  }
2731  }
2732  if (show_warning)
2733  av_log(ic, AV_LOG_WARNING,
2734  "Estimating duration from bitrate, this may be inaccurate\n");
2735 }
2736 
2737 #define DURATION_MAX_READ_SIZE 250000LL
2738 #define DURATION_MAX_RETRY 6
2739 
2740 /* only usable for MPEG-PS streams */
2741 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2742 {
2743  AVPacket pkt1, *pkt = &pkt1;
2744  AVStream *st;
2745  int num, den, read_size, i, ret;
2746  int found_duration = 0;
2747  int is_end;
2748  int64_t filesize, offset, duration;
2749  int retry = 0;
2750 
2751  /* flush packet queue */
2752  flush_packet_queue(ic);
2753 
2754  for (i = 0; i < ic->nb_streams; i++) {
2755  st = ic->streams[i];
2756  if (st->start_time == AV_NOPTS_VALUE &&
2757  st->first_dts == AV_NOPTS_VALUE &&
2759  av_log(ic, AV_LOG_WARNING,
2760  "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2761 
2762  if (st->parser) {
2763  av_parser_close(st->parser);
2764  st->parser = NULL;
2765  }
2766  }
2767 
2769  av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2770  goto skip_duration_calc;
2771  }
2772 
2773  av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2774  /* estimate the end time (duration) */
2775  /* XXX: may need to support wrapping */
2776  filesize = ic->pb ? avio_size(ic->pb) : 0;
2777  do {
2778  is_end = found_duration;
2779  offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2780  if (offset < 0)
2781  offset = 0;
2782 
2783  avio_seek(ic->pb, offset, SEEK_SET);
2784  read_size = 0;
2785  for (;;) {
2786  if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2787  break;
2788 
2789  do {
2790  ret = ff_read_packet(ic, pkt);
2791  } while (ret == AVERROR(EAGAIN));
2792  if (ret != 0)
2793  break;
2794  read_size += pkt->size;
2795  st = ic->streams[pkt->stream_index];
2796  if (pkt->pts != AV_NOPTS_VALUE &&
2797  (st->start_time != AV_NOPTS_VALUE ||
2798  st->first_dts != AV_NOPTS_VALUE)) {
2799  if (pkt->duration == 0) {
2800  ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2801  if (den && num) {
2802  pkt->duration = av_rescale_rnd(1,
2803  num * (int64_t) st->time_base.den,
2804  den * (int64_t) st->time_base.num,
2805  AV_ROUND_DOWN);
2806  }
2807  }
2808  duration = pkt->pts + pkt->duration;
2809  found_duration = 1;
2810  if (st->start_time != AV_NOPTS_VALUE)
2811  duration -= st->start_time;
2812  else
2813  duration -= st->first_dts;
2814  if (duration > 0) {
2815  if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2816  (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2817  st->duration = duration;
2818  st->info->last_duration = duration;
2819  }
2820  }
2821  av_packet_unref(pkt);
2822  }
2823 
2824  /* check if all audio/video streams have valid duration */
2825  if (!is_end) {
2826  is_end = 1;
2827  for (i = 0; i < ic->nb_streams; i++) {
2828  st = ic->streams[i];
2829  switch (st->codecpar->codec_type) {
2830  case AVMEDIA_TYPE_VIDEO:
2831  case AVMEDIA_TYPE_AUDIO:
2832  if (st->duration == AV_NOPTS_VALUE)
2833  is_end = 0;
2834  }
2835  }
2836  }
2837  } while (!is_end &&
2838  offset &&
2839  ++retry <= DURATION_MAX_RETRY);
2840 
2841  av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2842 
2843  /* warn about audio/video streams which duration could not be estimated */
2844  for (i = 0; i < ic->nb_streams; i++) {
2845  st = ic->streams[i];
2846  if (st->duration == AV_NOPTS_VALUE) {
2847  switch (st->codecpar->codec_type) {
2848  case AVMEDIA_TYPE_VIDEO:
2849  case AVMEDIA_TYPE_AUDIO:
2850  if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2851  av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
2852  } else
2853  av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
2854  }
2855  }
2856  }
2857 skip_duration_calc:
2859 
2860  avio_seek(ic->pb, old_offset, SEEK_SET);
2861  for (i = 0; i < ic->nb_streams; i++) {
2862  int j;
2863 
2864  st = ic->streams[i];
2865  st->cur_dts = st->first_dts;
2868  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2869  st->pts_buffer[j] = AV_NOPTS_VALUE;
2870  }
2871 }
2872 
2873 /* 1:1 map to AVDurationEstimationMethod */
2874 static const char *duration_name[] = {
2875  [AVFMT_DURATION_FROM_PTS] = "pts",
2876  [AVFMT_DURATION_FROM_STREAM] = "stream",
2877  [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
2878 };
2879 
2881 {
2882  return duration_name[method];
2883 }
2884 
2885 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2886 {
2887  int64_t file_size;
2888 
2889  /* get the file size, if possible */
2890  if (ic->iformat->flags & AVFMT_NOFILE) {
2891  file_size = 0;
2892  } else {
2893  file_size = avio_size(ic->pb);
2894  file_size = FFMAX(0, file_size);
2895  }
2896 
2897  if ((!strcmp(ic->iformat->name, "mpeg") ||
2898  !strcmp(ic->iformat->name, "mpegts")) &&
2899  file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2900  /* get accurate estimate from the PTSes */
2901  estimate_timings_from_pts(ic, old_offset);
2903  } else if (has_duration(ic)) {
2904  /* at least one component has timings - we use them for all
2905  * the components */
2907  /* nut demuxer estimate the duration from PTS */
2908  if(!strcmp(ic->iformat->name, "nut"))
2910  else
2912  } else {
2913  /* less precise: use bitrate info */
2916  }
2918 
2919  {
2920  int i;
2921  AVStream av_unused *st;
2922  for (i = 0; i < ic->nb_streams; i++) {
2923  st = ic->streams[i];
2924  if (st->time_base.den)
2925  av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %s duration: %s\n", i,
2926  av_ts2timestr(st->start_time, &st->time_base),
2927  av_ts2timestr(st->duration, &st->time_base));
2928  }
2929  av_log(ic, AV_LOG_TRACE,
2930  "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
2934  (int64_t)ic->bit_rate / 1000);
2935  }
2936 }
2937 
2938 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2939 {
2940  AVCodecContext *avctx = st->internal->avctx;
2941 
2942 #define FAIL(errmsg) do { \
2943  if (errmsg_ptr) \
2944  *errmsg_ptr = errmsg; \
2945  return 0; \
2946  } while (0)
2947 
2948  if ( avctx->codec_id == AV_CODEC_ID_NONE
2949  && avctx->codec_type != AVMEDIA_TYPE_DATA)
2950  FAIL("unknown codec");
2951  switch (avctx->codec_type) {
2952  case AVMEDIA_TYPE_AUDIO:
2953  if (!avctx->frame_size && determinable_frame_size(avctx))
2954  FAIL("unspecified frame size");
2955  if (st->info->found_decoder >= 0 &&
2956  avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2957  FAIL("unspecified sample format");
2958  if (!avctx->sample_rate)
2959  FAIL("unspecified sample rate");
2960  if (!avctx->channels)
2961  FAIL("unspecified number of channels");
2962  if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2963  FAIL("no decodable DTS frames");
2964  break;
2965  case AVMEDIA_TYPE_VIDEO:
2966  if (!avctx->width)
2967  FAIL("unspecified size");
2968  if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2969  FAIL("unspecified pixel format");
2972  FAIL("no frame in rv30/40 and no sar");
2973  break;
2974  case AVMEDIA_TYPE_SUBTITLE:
2975  if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2976  FAIL("unspecified size");
2977  break;
2978  case AVMEDIA_TYPE_DATA:
2979  if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2980  }
2981 
2982  return 1;
2983 }
2984 
2985 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2987  const AVPacket *avpkt, AVDictionary **options)
2988 {
2989  AVCodecContext *avctx = st->internal->avctx;
2990  const AVCodec *codec;
2991  int got_picture = 1, ret = 0;
2993  AVSubtitle subtitle;
2994  AVPacket pkt = *avpkt;
2995  int do_skip_frame = 0;
2996  enum AVDiscard skip_frame;
2997 
2998  if (!frame)
2999  return AVERROR(ENOMEM);
3000 
3001  if (!avcodec_is_open(avctx) &&
3002  st->info->found_decoder <= 0 &&
3003  (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
3004  AVDictionary *thread_opt = NULL;
3005 
3006  codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3007 
3008  if (!codec) {
3009  st->info->found_decoder = -st->codecpar->codec_id;
3010  ret = -1;
3011  goto fail;
3012  }
3013 
3014  /* Force thread count to 1 since the H.264 decoder will not extract
3015  * SPS and PPS to extradata during multi-threaded decoding. */
3016  av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3017  if (s->codec_whitelist)
3018  av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3019  ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3020  if (!options)
3021  av_dict_free(&thread_opt);
3022  if (ret < 0) {
3023  st->info->found_decoder = -avctx->codec_id;
3024  goto fail;
3025  }
3026  st->info->found_decoder = 1;
3027  } else if (!st->info->found_decoder)
3028  st->info->found_decoder = 1;
3029 
3030  if (st->info->found_decoder < 0) {
3031  ret = -1;
3032  goto fail;
3033  }
3034 
3036  do_skip_frame = 1;
3037  skip_frame = avctx->skip_frame;
3038  avctx->skip_frame = AVDISCARD_ALL;
3039  }
3040 
3041  while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3042  ret >= 0 &&
3044  (!st->codec_info_nb_frames &&
3046  got_picture = 0;
3047  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3048  avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3049  ret = avcodec_send_packet(avctx, &pkt);
3050  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3051  break;
3052  if (ret >= 0)
3053  pkt.size = 0;
3054  ret = avcodec_receive_frame(avctx, frame);
3055  if (ret >= 0)
3056  got_picture = 1;
3057  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3058  ret = 0;
3059  } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3060  ret = avcodec_decode_subtitle2(avctx, &subtitle,
3061  &got_picture, &pkt);
3062  if (got_picture)
3063  avsubtitle_free(&subtitle);
3064  if (ret >= 0)
3065  pkt.size = 0;
3066  }
3067  if (ret >= 0) {
3068  if (got_picture)
3069  st->nb_decoded_frames++;
3070  ret = got_picture;
3071  }
3072  }
3073 
3074  if (!pkt.data && !got_picture)
3075  ret = -1;
3076 
3077 fail:
3078  if (do_skip_frame) {
3079  avctx->skip_frame = skip_frame;
3080  }
3081 
3082  av_frame_free(&frame);
3083  return ret;
3084 }
3085 
3086 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3087 {
3088  while (tags->id != AV_CODEC_ID_NONE) {
3089  if (tags->id == id)
3090  return tags->tag;
3091  tags++;
3092  }
3093  return 0;
3094 }
3095 
3096 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3097 {
3098  int i;
3099  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3100  if (tag == tags[i].tag)
3101  return tags[i].id;
3102  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3103  if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3104  return tags[i].id;
3105  return AV_CODEC_ID_NONE;
3106 }
3107 
3108 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3109 {
3110  if (bps <= 0 || bps > 64)
3111  return AV_CODEC_ID_NONE;
3112 
3113  if (flt) {
3114  switch (bps) {
3115  case 32:
3117  case 64:
3119  default:
3120  return AV_CODEC_ID_NONE;
3121  }
3122  } else {
3123  bps += 7;
3124  bps >>= 3;
3125  if (sflags & (1 << (bps - 1))) {
3126  switch (bps) {
3127  case 1:
3128  return AV_CODEC_ID_PCM_S8;
3129  case 2:
3131  case 3:
3133  case 4:
3135  case 8:
3137  default:
3138  return AV_CODEC_ID_NONE;
3139  }
3140  } else {
3141  switch (bps) {
3142  case 1:
3143  return AV_CODEC_ID_PCM_U8;
3144  case 2:
3146  case 3:
3148  case 4:
3150  default:
3151  return AV_CODEC_ID_NONE;
3152  }
3153  }
3154  }
3155 }
3156 
3157 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3158 {
3159  unsigned int tag;
3160  if (!av_codec_get_tag2(tags, id, &tag))
3161  return 0;
3162  return tag;
3163 }
3164 
3165 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3166  unsigned int *tag)
3167 {
3168  int i;
3169  for (i = 0; tags && tags[i]; i++) {
3170  const AVCodecTag *codec_tags = tags[i];
3171  while (codec_tags->id != AV_CODEC_ID_NONE) {
3172  if (codec_tags->id == id) {
3173  *tag = codec_tags->tag;
3174  return 1;
3175  }
3176  codec_tags++;
3177  }
3178  }
3179  return 0;
3180 }
3181 
3182 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3183 {
3184  int i;
3185  for (i = 0; tags && tags[i]; i++) {
3186  enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3187  if (id != AV_CODEC_ID_NONE)
3188  return id;
3189  }
3190  return AV_CODEC_ID_NONE;
3191 }
3192 
3194 {
3195  unsigned int i, j;
3196  int64_t max_time = 0;
3197 
3198  if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3199  max_time = s->duration +
3200  ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3201 
3202  for (i = 0; i < s->nb_chapters; i++)
3203  if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3204  AVChapter *ch = s->chapters[i];
3205  int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3206  ch->time_base)
3207  : INT64_MAX;
3208 
3209  for (j = 0; j < s->nb_chapters; j++) {
3210  AVChapter *ch1 = s->chapters[j];
3211  int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3212  ch->time_base);
3213  if (j != i && next_start > ch->start && next_start < end)
3214  end = next_start;
3215  }
3216  ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3217  }
3218 }
3219 
3220 static int get_std_framerate(int i)
3221 {
3222  if (i < 30*12)
3223  return (i + 1) * 1001;
3224  i -= 30*12;
3225 
3226  if (i < 30)
3227  return (i + 31) * 1001 * 12;
3228  i -= 30;
3229 
3230  if (i < 3)
3231  return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3232 
3233  i -= 3;
3234 
3235  return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3236 }
3237 
3238 /* Is the time base unreliable?
3239  * This is a heuristic to balance between quick acceptance of the values in
3240  * the headers vs. some extra checks.
3241  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3242  * MPEG-2 commonly misuses field repeat flags to store different framerates.
3243  * And there are "variable" fps files this needs to detect as well. */
3245 {
3246  if (c->time_base.den >= 101LL * c->time_base.num ||
3247  c->time_base.den < 5LL * c->time_base.num ||
3248  // c->codec_tag == AV_RL32("DIVX") ||
3249  // c->codec_tag == AV_RL32("XVID") ||
3250  c->codec_tag == AV_RL32("mp4v") ||
3252  c->codec_id == AV_CODEC_ID_GIF ||
3253  c->codec_id == AV_CODEC_ID_HEVC ||
3254  c->codec_id == AV_CODEC_ID_H264)
3255  return 1;
3256  return 0;
3257 }
3258 
3260 {
3261  av_freep(&par->extradata);
3262  par->extradata_size = 0;
3263 
3265  return AVERROR(EINVAL);
3266 
3268  if (!par->extradata)
3269  return AVERROR(ENOMEM);
3270 
3271  memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3272  par->extradata_size = size;
3273 
3274  return 0;
3275 }
3276 
3278 {
3279  int ret = ff_alloc_extradata(par, size);
3280  if (ret < 0)
3281  return ret;
3282  ret = avio_read(pb, par->extradata, size);
3283  if (ret != size) {
3284  av_freep(&par->extradata);
3285  par->extradata_size = 0;
3286  av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3287  return ret < 0 ? ret : AVERROR_INVALIDDATA;
3288  }
3289 
3290  return ret;
3291 }
3292 
3293 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3294 {
3295  int i, j;
3296  int64_t last = st->info->last_dts;
3297 
3298  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3299  && ts - (uint64_t)last < INT64_MAX) {
3300  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3301  int64_t duration = ts - last;
3302 
3303  if (!st->info->duration_error)
3304  st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3305  if (!st->info->duration_error)
3306  return AVERROR(ENOMEM);
3307 
3308 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3309 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3310  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3311  if (st->info->duration_error[0][1][i] < 1e10) {
3312  int framerate = get_std_framerate(i);
3313  double sdts = dts*framerate/(1001*12);
3314  for (j= 0; j<2; j++) {
3315  int64_t ticks = llrint(sdts+j*0.5);
3316  double error= sdts - ticks + j*0.5;
3317  st->info->duration_error[j][0][i] += error;
3318  st->info->duration_error[j][1][i] += error*error;
3319  }
3320  }
3321  }
3322  if (st->info->rfps_duration_sum <= INT64_MAX - duration) {
3323  st->info->duration_count++;
3325  }
3326 
3327  if (st->info->duration_count % 10 == 0) {
3328  int n = st->info->duration_count;
3329  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3330  if (st->info->duration_error[0][1][i] < 1e10) {
3331  double a0 = st->info->duration_error[0][0][i] / n;
3332  double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3333  double a1 = st->info->duration_error[1][0][i] / n;
3334  double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3335  if (error0 > 0.04 && error1 > 0.04) {
3336  st->info->duration_error[0][1][i] = 2e10;
3337  st->info->duration_error[1][1][i] = 2e10;
3338  }
3339  }
3340  }
3341  }
3342 
3343  // ignore the first 4 values, they might have some random jitter
3344  if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3345  st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3346  }
3347  if (ts != AV_NOPTS_VALUE)
3348  st->info->last_dts = ts;
3349 
3350  return 0;
3351 }
3352 
3354 {
3355  int i, j;
3356 
3357  for (i = 0; i < ic->nb_streams; i++) {
3358  AVStream *st = ic->streams[i];
3359 
3361  continue;
3362  // the check for tb_unreliable() is not completely correct, since this is not about handling
3363  // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3364  // ipmovie.c produces.
3365  if (tb_unreliable(st->internal->avctx) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
3366  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
3367  if (st->info->duration_count>1 && !st->r_frame_rate.num
3368  && tb_unreliable(st->internal->avctx)) {
3369  int num = 0;
3370  double best_error= 0.01;
3371  AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3372 
3373  for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3374  int k;
3375 
3376  if (st->info->codec_info_duration &&
3377  st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3378  continue;
3379  if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3380  continue;
3381 
3382  if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3383  continue;
3384 
3385  for (k= 0; k<2; k++) {
3386  int n = st->info->duration_count;
3387  double a= st->info->duration_error[k][0][j] / n;
3388  double error= st->info->duration_error[k][1][j]/n - a*a;
3389 
3390  if (error < best_error && best_error> 0.000000001) {
3391  best_error= error;
3392  num = get_std_framerate(j);
3393  }
3394  if (error < 0.02)
3395  av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3396  }
3397  }
3398  // do not increase frame rate by more than 1 % in order to match a standard rate.
3399  if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3400  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3401  }
3402  if ( !st->avg_frame_rate.num
3403  && st->r_frame_rate.num && st->info->rfps_duration_sum
3404  && st->info->codec_info_duration <= 0
3405  && st->info->duration_count > 2
3406  && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->info->rfps_duration_sum / (double)st->info->duration_count) <= 1.0
3407  ) {
3408  av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3409  st->avg_frame_rate = st->r_frame_rate;
3410  }
3411 
3412  av_freep(&st->info->duration_error);
3413  st->info->last_dts = AV_NOPTS_VALUE;
3414  st->info->duration_count = 0;
3415  st->info->rfps_duration_sum = 0;
3416  }
3417 }
3418 
3420 {
3421  const AVBitStreamFilter *f;
3422 
3423  f = av_bsf_get_by_name("extract_extradata");
3424  if (!f)
3425  return 0;
3426 
3427  if (f->codec_ids) {
3428  const enum AVCodecID *ids;
3429  for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3430  if (*ids == st->codecpar->codec_id)
3431  return 1;
3432  }
3433 
3434  return 0;
3435 }
3436 
3438 {
3439  AVStreamInternal *sti = st->internal;
3440  const AVBitStreamFilter *f;
3441  int ret;
3442 
3443  f = av_bsf_get_by_name("extract_extradata");
3444  if (!f)
3445  goto finish;
3446 
3447  /* check that the codec id is supported */
3448  ret = extract_extradata_check(st);
3449  if (!ret)
3450  goto finish;
3451 
3453  if (!sti->extract_extradata.pkt)
3454  return AVERROR(ENOMEM);
3455 
3456  ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3457  if (ret < 0)
3458  goto fail;
3459 
3461  st->codecpar);
3462  if (ret < 0)
3463  goto fail;
3464 
3466 
3467  ret = av_bsf_init(sti->extract_extradata.bsf);
3468  if (ret < 0)
3469  goto fail;
3470 
3471 finish:
3472  sti->extract_extradata.inited = 1;
3473 
3474  return 0;
3475 fail:
3478  return ret;
3479 }
3480 
3481 static int extract_extradata(AVStream *st, const AVPacket *pkt)
3482 {
3483  AVStreamInternal *sti = st->internal;
3484  AVPacket *pkt_ref;
3485  int ret;
3486 
3487  if (!sti->extract_extradata.inited) {
3488  ret = extract_extradata_init(st);
3489  if (ret < 0)
3490  return ret;
3491  }
3492 
3493  if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3494  return 0;
3495 
3496  pkt_ref = sti->extract_extradata.pkt;
3497  ret = av_packet_ref(pkt_ref, pkt);
3498  if (ret < 0)
3499  return ret;
3500 
3501  ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3502  if (ret < 0) {
3503  av_packet_unref(pkt_ref);
3504  return ret;
3505  }
3506 
3507  while (ret >= 0 && !sti->avctx->extradata) {
3508  ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3509  if (ret < 0) {
3510  if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3511  return ret;
3512  continue;
3513  }
3514 
3515  for (int i = 0; i < pkt_ref->side_data_elems; i++) {
3516  AVPacketSideData *side_data = &pkt_ref->side_data[i];
3517  if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) {
3518  sti->avctx->extradata = side_data->data;
3519  sti->avctx->extradata_size = side_data->size;
3520  side_data->data = NULL;
3521  side_data->size = 0;
3522  break;
3523  }
3524  }
3525  av_packet_unref(pkt_ref);
3526  }
3527 
3528  return 0;
3529 }
3530 
3532 {
3533  int i;
3534 
3535  for (i = 0; i < avctx->nb_coded_side_data; i++) {
3536  const AVPacketSideData *sd_src = &avctx->coded_side_data[i];
3537  uint8_t *dst_data;
3538  dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
3539  if (!dst_data)
3540  return AVERROR(ENOMEM);
3541  memcpy(dst_data, sd_src->data, sd_src->size);
3542  }
3543  return 0;
3544 }
3545 
3547 {
3548  int i, count = 0, ret = 0, j;
3549  int64_t read_size;
3550  AVStream *st;
3551  AVCodecContext *avctx;
3552  AVPacket pkt1;
3553  int64_t old_offset = avio_tell(ic->pb);
3554  // new streams might appear, no options for those
3555  int orig_nb_streams = ic->nb_streams;
3556  int flush_codecs;
3557  int64_t max_analyze_duration = ic->max_analyze_duration;
3558  int64_t max_stream_analyze_duration;
3559  int64_t max_subtitle_analyze_duration;
3560  int64_t probesize = ic->probesize;
3561  int eof_reached = 0;
3562  int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3563 
3564  flush_codecs = probesize > 0;
3565 
3566  av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3567 
3568  max_stream_analyze_duration = max_analyze_duration;
3569  max_subtitle_analyze_duration = max_analyze_duration;
3570  if (!max_analyze_duration) {
3571  max_stream_analyze_duration =
3572  max_analyze_duration = 5*AV_TIME_BASE;
3573  max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3574  if (!strcmp(ic->iformat->name, "flv"))
3575  max_stream_analyze_duration = 90*AV_TIME_BASE;
3576  if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3577  max_stream_analyze_duration = 7*AV_TIME_BASE;
3578  }
3579 
3580  if (ic->pb)
3581  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3582  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3583 
3584  for (i = 0; i < ic->nb_streams; i++) {
3585  const AVCodec *codec;
3586  AVDictionary *thread_opt = NULL;
3587  st = ic->streams[i];
3588  avctx = st->internal->avctx;
3589 
3590  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3592 /* if (!st->time_base.num)
3593  st->time_base = */
3594  if (!avctx->time_base.num)
3595  avctx->time_base = st->time_base;
3596  }
3597 
3598  /* check if the caller has overridden the codec id */
3599 #if FF_API_LAVF_AVCTX
3601  if (st->codec->codec_id != st->internal->orig_codec_id) {
3602  st->codecpar->codec_id = st->codec->codec_id;
3603  st->codecpar->codec_type = st->codec->codec_type;
3604  st->internal->orig_codec_id = st->codec->codec_id;
3605  }
3607 #endif
3608  // only for the split stuff
3609  if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3610  st->parser = av_parser_init(st->codecpar->codec_id);
3611  if (st->parser) {
3612  if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3614  } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3616  }
3617  } else if (st->need_parsing) {
3618  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3619  "%s, packets or times may be invalid.\n",
3621  }
3622  }
3623 
3624  if (st->codecpar->codec_id != st->internal->orig_codec_id)
3626 
3628  if (ret < 0)
3629  goto find_stream_info_err;
3630  if (st->request_probe <= 0)
3631  st->internal->avctx_inited = 1;
3632 
3633  codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3634 
3635  /* Force thread count to 1 since the H.264 decoder will not extract
3636  * SPS and PPS to extradata during multi-threaded decoding. */
3637  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3638 
3639  if (ic->codec_whitelist)
3640  av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3641 
3642  /* Ensure that subtitle_header is properly set. */
3644  && codec && !avctx->codec) {
3645  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3646  av_log(ic, AV_LOG_WARNING,
3647  "Failed to open codec in %s\n",__FUNCTION__);
3648  }
3649 
3650  // Try to just open decoders, in case this is enough to get parameters.
3651  if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3652  if (codec && !avctx->codec)
3653  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3654  av_log(ic, AV_LOG_WARNING,
3655  "Failed to open codec in %s\n",__FUNCTION__);
3656  }
3657  if (!options)
3658  av_dict_free(&thread_opt);
3659  }
3660 
3661  for (i = 0; i < ic->nb_streams; i++) {
3662 #if FF_API_R_FRAME_RATE
3664 #endif
3667  }
3668 
3669  read_size = 0;
3670  for (;;) {
3671  const AVPacket *pkt;
3672  int analyzed_all_streams;
3674  ret = AVERROR_EXIT;
3675  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3676  break;
3677  }
3678 
3679  /* check if one codec still needs to be handled */
3680  for (i = 0; i < ic->nb_streams; i++) {
3681  int fps_analyze_framecount = 20;
3682  int count;
3683 
3684  st = ic->streams[i];
3685  if (!has_codec_parameters(st, NULL))
3686  break;
3687  /* If the timebase is coarse (like the usual millisecond precision
3688  * of mkv), we need to analyze more frames to reliably arrive at
3689  * the correct fps. */
3690  if (av_q2d(st->time_base) > 0.0005)
3691  fps_analyze_framecount *= 2;
3692  if (!tb_unreliable(st->internal->avctx))
3693  fps_analyze_framecount = 0;
3694  if (ic->fps_probe_size >= 0)
3695  fps_analyze_framecount = ic->fps_probe_size;
3697  fps_analyze_framecount = 0;
3698  /* variable fps and no guess at the real fps */
3699  count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3701  st->info->duration_count;
3702  if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3704  if (count < fps_analyze_framecount)
3705  break;
3706  }
3707  // Look at the first 3 frames if there is evidence of frame delay
3708  // but the decoder delay is not set.
3709  if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3710  break;
3711  if (!st->internal->avctx->extradata &&
3713  st->internal->extract_extradata.bsf) &&
3715  break;
3716  if (st->first_dts == AV_NOPTS_VALUE &&
3717  !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3721  break;
3722  }
3723  analyzed_all_streams = 0;
3724  if (!missing_streams || !*missing_streams)
3725  if (i == ic->nb_streams) {
3726  analyzed_all_streams = 1;
3727  /* NOTE: If the format has no header, then we need to read some
3728  * packets to get most of the streams, so we cannot stop here. */
3729  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3730  /* If we found the info for all the codecs, we can stop. */
3731  ret = count;
3732  av_log(ic, AV_LOG_DEBUG, "All info found\n");
3733  flush_codecs = 0;
3734  break;
3735  }
3736  }
3737  /* We did not get all the codec info, but we read too much data. */
3738  if (read_size >= probesize) {
3739  ret = count;
3740  av_log(ic, AV_LOG_DEBUG,
3741  "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3742  for (i = 0; i < ic->nb_streams; i++)
3743  if (!ic->streams[i]->r_frame_rate.num &&
3744  ic->streams[i]->info->duration_count <= 1 &&
3746  strcmp(ic->iformat->name, "image2"))
3747  av_log(ic, AV_LOG_WARNING,
3748  "Stream #%d: not enough frames to estimate rate; "
3749  "consider increasing probesize\n", i);
3750  break;
3751  }
3752 
3753  /* NOTE: A new stream can be added there if no header in file
3754  * (AVFMTCTX_NOHEADER). */
3755  ret = read_frame_internal(ic, &pkt1);
3756  if (ret == AVERROR(EAGAIN))
3757  continue;
3758 
3759  if (ret < 0) {
3760  /* EOF or error*/
3761  eof_reached = 1;
3762  break;
3763  }
3764 
3765  if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3768  &pkt1, NULL, 0);
3769  if (ret < 0)
3770  goto unref_then_goto_end;
3771 
3772  pkt = &ic->internal->packet_buffer_end->pkt;
3773  } else {
3774  pkt = &pkt1;
3775  }
3776 
3777  st = ic->streams[pkt->stream_index];
3779  read_size += pkt->size;
3780 
3781  avctx = st->internal->avctx;
3782  if (!st->internal->avctx_inited) {
3784  if (ret < 0)
3785  goto unref_then_goto_end;
3786  st->internal->avctx_inited = 1;
3787  }
3788 
3789  if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3790  /* check for non-increasing dts */
3791  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3792  st->info->fps_last_dts >= pkt->dts) {
3793  av_log(ic, AV_LOG_DEBUG,
3794  "Non-increasing DTS in stream %d: packet %d with DTS "
3795  "%"PRId64", packet %d with DTS %"PRId64"\n",
3796  st->index, st->info->fps_last_dts_idx,
3798  pkt->dts);
3799  st->info->fps_first_dts =
3801  }
3802  /* Check for a discontinuity in dts. If the difference in dts
3803  * is more than 1000 times the average packet duration in the
3804  * sequence, we treat it as a discontinuity. */
3805  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3807  (pkt->dts - (uint64_t)st->info->fps_last_dts) / 1000 >
3808  (st->info->fps_last_dts - (uint64_t)st->info->fps_first_dts) /
3809  (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3810  av_log(ic, AV_LOG_WARNING,
3811  "DTS discontinuity in stream %d: packet %d with DTS "
3812  "%"PRId64", packet %d with DTS %"PRId64"\n",
3813  st->index, st->info->fps_last_dts_idx,
3815  pkt->dts);
3816  st->info->fps_first_dts =
3818  }
3819 
3820  /* update stored dts values */
3821  if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3822  st->info->fps_first_dts = pkt->dts;
3824  }
3825  st->info->fps_last_dts = pkt->dts;
3827  }
3828  if (st->codec_info_nb_frames>1) {
3829  int64_t t = 0;
3830  int64_t limit;
3831 
3832  if (st->time_base.den > 0)
3834  if (st->avg_frame_rate.num > 0)
3836 
3837  if ( t == 0
3838  && st->codec_info_nb_frames>30
3839  && st->info->fps_first_dts != AV_NOPTS_VALUE
3840  && st->info->fps_last_dts != AV_NOPTS_VALUE)
3842 
3843  if (analyzed_all_streams) limit = max_analyze_duration;
3844  else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3845  else limit = max_stream_analyze_duration;
3846 
3847  if (t >= limit) {
3848  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3849  limit,
3850  t, pkt->stream_index);
3851  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3852  av_packet_unref(&pkt1);
3853  break;
3854  }
3855  if (pkt->duration) {
3856  if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3857  st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3858  } else
3859  st->info->codec_info_duration += pkt->duration;
3860  st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3861  }
3862  }
3863  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3864 #if FF_API_R_FRAME_RATE
3865  ff_rfps_add_frame(ic, st, pkt->dts);
3866 #endif
3867  if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3868  st->info->frame_delay_evidence = 1;
3869  }
3870  if (!st->internal->avctx->extradata) {
3871  ret = extract_extradata(st, pkt);
3872  if (ret < 0)
3873  goto unref_then_goto_end;
3874  }
3875 
3876  /* If still no information, we try to open the codec and to
3877  * decompress the frame. We try to avoid that in most cases as
3878  * it takes longer and uses more memory. For MPEG-4, we need to
3879  * decompress for QuickTime.
3880  *
3881  * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3882  * least one frame of codec data, this makes sure the codec initializes
3883  * the channel configuration and does not only trust the values from
3884  * the container. */
3885  try_decode_frame(ic, st, pkt,
3886  (options && i < orig_nb_streams) ? &options[i] : NULL);
3887 
3888  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3889  av_packet_unref(&pkt1);
3890 
3891  st->codec_info_nb_frames++;
3892  count++;
3893  }
3894 
3895  if (eof_reached) {
3896  int stream_index;
3897  for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3898  st = ic->streams[stream_index];
3899  avctx = st->internal->avctx;
3900  if (!has_codec_parameters(st, NULL)) {
3901  const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3902  if (codec && !avctx->codec) {
3903  AVDictionary *opts = NULL;
3904  if (ic->codec_whitelist)
3905  av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3906  if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3907  av_log(ic, AV_LOG_WARNING,
3908  "Failed to open codec in %s\n",__FUNCTION__);
3909  av_dict_free(&opts);
3910  }
3911  }
3912 
3913  // EOF already reached while reading the stream above.
3914  // So continue with reoordering DTS with whatever delay we have.
3916  update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3917  }
3918  }
3919  }
3920 
3921  if (flush_codecs) {
3922  AVPacket empty_pkt = { 0 };
3923  int err = 0;
3924  av_init_packet(&empty_pkt);
3925 
3926  for (i = 0; i < ic->nb_streams; i++) {
3927 
3928  st = ic->streams[i];
3929 
3930  /* flush the decoders */
3931  if (st->info->found_decoder == 1) {
3932  do {
3933  err = try_decode_frame(ic, st, &empty_pkt,
3934  (options && i < orig_nb_streams)
3935  ? &options[i] : NULL);
3936  } while (err > 0 && !has_codec_parameters(st, NULL));
3937 
3938  if (err < 0) {
3939  av_log(ic, AV_LOG_INFO,
3940  "decoding for stream %d failed\n", st->index);
3941  }
3942  }
3943  }
3944  }
3945 
3946  ff_rfps_calculate(ic);
3947 
3948  for (i = 0; i < ic->nb_streams; i++) {
3949  st = ic->streams[i];
3950  avctx = st->internal->avctx;
3951  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3952  if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3953  uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3955  avctx->codec_tag= tag;
3956  }
3957 
3958  /* estimate average framerate if not set by demuxer */
3959  if (st->info->codec_info_duration_fields &&
3960  !st->avg_frame_rate.num &&
3961  st->info->codec_info_duration) {
3962  int best_fps = 0;
3963  double best_error = 0.01;
3964  AVRational codec_frame_rate = avctx->framerate;
3965 
3966  if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3967  st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3968  st->info->codec_info_duration < 0)
3969  continue;
3971  st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3972  st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3973 
3974  /* Round guessed framerate to a "standard" framerate if it's
3975  * within 1% of the original estimate. */
3976  for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3977  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3978  double error = fabs(av_q2d(st->avg_frame_rate) /
3979  av_q2d(std_fps) - 1);
3980 
3981  if (error < best_error) {
3982  best_error = error;
3983  best_fps = std_fps.num;
3984  }
3985 
3986  if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3987  error = fabs(av_q2d(codec_frame_rate) /
3988  av_q2d(std_fps) - 1);
3989  if (error < best_error) {
3990  best_error = error;
3991  best_fps = std_fps.num;
3992  }
3993  }
3994  }
3995  if (best_fps)
3997  best_fps, 12 * 1001, INT_MAX);
3998  }
3999 
4000  if (!st->r_frame_rate.num) {
4001  if ( avctx->time_base.den * (int64_t) st->time_base.num
4002  <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4004  avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4005  } else {
4006  st->r_frame_rate.num = st->time_base.den;
4007  st->r_frame_rate.den = st->time_base.num;
4008  }
4009  }
4011  AVRational hw_ratio = { avctx->height, avctx->width };
4013  hw_ratio);
4014  }
4015  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4016  if (!avctx->bits_per_coded_sample)
4017  avctx->bits_per_coded_sample =
4019  // set stream disposition based on audio service type
4020  switch (avctx->audio_service_type) {
4023  break;
4026  break;
4029  break;
4032  break;
4035  break;
4036  }
4037  }
4038  }
4039 
4040  if (probesize)
4041  estimate_timings(ic, old_offset);
4042 
4043  av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4044 
4045  if (ret >= 0 && ic->nb_streams)
4046  /* We could not have all the codec parameters before EOF. */
4047  ret = -1;
4048  for (i = 0; i < ic->nb_streams; i++) {
4049  const char *errmsg;
4050  st = ic->streams[i];
4051 
4052  /* if no packet was ever seen, update context now for has_codec_parameters */
4053  if (!st->internal->avctx_inited) {
4054  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4056  st->codecpar->format = st->internal->avctx->sample_fmt;
4058  if (ret < 0)
4059  goto find_stream_info_err;
4060  }
4061  if (!has_codec_parameters(st, &errmsg)) {
4062  char buf[256];
4063  avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4064  av_log(ic, AV_LOG_WARNING,
4065  "Could not find codec parameters for stream %d (%s): %s\n"
4066  "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
4067  i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
4068  } else {
4069  ret = 0;
4070  }
4071  }
4072 
4074 
4075  /* update the stream parameters from the internal codec contexts */
4076  for (i = 0; i < ic->nb_streams; i++) {
4077  st = ic->streams[i];
4078 
4079  if (st->internal->avctx_inited) {
4080  int orig_w = st->codecpar->width;
4081  int orig_h = st->codecpar->height;
4083  if (ret < 0)
4084  goto find_stream_info_err;
4085  ret = add_coded_side_data(st, st->internal->avctx);
4086  if (ret < 0)
4087  goto find_stream_info_err;
4088 #if FF_API_LOWRES
4089  // The decoder might reduce the video size by the lowres factor.
4090  if (st->internal->avctx->lowres && orig_w) {
4091  st->codecpar->width = orig_w;
4092  st->codecpar->height = orig_h;
4093  }
4094 #endif
4095  }
4096 
4097 #if FF_API_LAVF_AVCTX
4099  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4100  if (ret < 0)
4101  goto find_stream_info_err;
4102 
4103 #if FF_API_LOWRES
4104  // The old API (AVStream.codec) "requires" the resolution to be adjusted
4105  // by the lowres factor.
4106  if (st->internal->avctx->lowres && st->internal->avctx->width) {
4107  st->codec->lowres = st->internal->avctx->lowres;
4108  st->codec->width = st->internal->avctx->width;
4109  st->codec->height = st->internal->avctx->height;
4110  }
4111 #endif
4112 
4113  if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4114  st->codec->time_base = st->internal->avctx->time_base;
4115  st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4116  }
4117  st->codec->framerate = st->avg_frame_rate;
4118 
4119  if (st->internal->avctx->subtitle_header) {
4120  st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4121  if (!st->codec->subtitle_header)
4122  goto find_stream_info_err;
4123  st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4124  memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4125  st->codec->subtitle_header_size);
4126  }
4127 
4128  // Fields unavailable in AVCodecParameters
4129  st->codec->coded_width = st->internal->avctx->coded_width;
4130  st->codec->coded_height = st->internal->avctx->coded_height;
4131  st->codec->properties = st->internal->avctx->properties;
4133 #endif
4134 
4135  st->internal->avctx_inited = 0;
4136  }
4137 
4138 find_stream_info_err:
4139  for (i = 0; i < ic->nb_streams; i++) {
4140  st = ic->streams[i];
4141  if (st->info)
4142  av_freep(&st->info->duration_error);
4143  avcodec_close(ic->streams[i]->internal->avctx);
4144  av_freep(&ic->streams[i]->info);
4147  }
4148  if (ic->pb)
4149  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4150  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4151  return ret;
4152 
4153 unref_then_goto_end:
4154  av_packet_unref(&pkt1);
4155  goto find_stream_info_err;
4156 }
4157 
4159 {
4160  int i, j;
4161 
4162  for (i = 0; i < ic->nb_programs; i++) {
4163  if (ic->programs[i] == last) {
4164  last = NULL;
4165  } else {
4166  if (!last)
4167  for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4168  if (ic->programs[i]->stream_index[j] == s)
4169  return ic->programs[i];
4170  }
4171  }
4172  return NULL;
4173 }
4174 
4176  int wanted_stream_nb, int related_stream,
4177  AVCodec **decoder_ret, int flags)
4178 {
4179  int i, nb_streams = ic->nb_streams;
4181  int best_count = -1, best_multiframe = -1, best_disposition = -1;
4182  int count, multiframe, disposition;
4183  int64_t best_bitrate = -1;
4184  int64_t bitrate;
4185  unsigned *program = NULL;
4186  const AVCodec *decoder = NULL, *best_decoder = NULL;
4187 
4188  if (related_stream >= 0 && wanted_stream_nb < 0) {
4189  AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4190  if (p) {
4191  program = p->stream_index;
4192  nb_streams = p->nb_stream_indexes;
4193  }
4194  }
4195  for (i = 0; i < nb_streams; i++) {
4196  int real_stream_index = program ? program[i] : i;
4197  AVStream *st = ic->streams[real_stream_index];
4198  AVCodecParameters *par = st->codecpar;
4199  if (par->codec_type != type)
4200  continue;
4201  if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4202  continue;
4203  if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4204  continue;
4205  if (decoder_ret) {
4206  decoder = find_decoder(ic, st, par->codec_id);
4207  if (!decoder) {
4208  if (ret < 0)
4210  continue;
4211  }
4212  }
4214  + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4215  count = st->codec_info_nb_frames;
4216  bitrate = par->bit_rate;
4217  multiframe = FFMIN(5, count);
4218  if ((best_disposition > disposition) ||
4219  (best_disposition == disposition && best_multiframe > multiframe) ||
4220  (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4221  (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4222  continue;
4223  best_disposition = disposition;
4224  best_count = count;
4225  best_bitrate = bitrate;
4226  best_multiframe = multiframe;
4227  ret = real_stream_index;
4228  best_decoder = decoder;
4229  if (program && i == nb_streams - 1 && ret < 0) {
4230  program = NULL;
4231  nb_streams = ic->nb_streams;
4232  /* no related stream found, try again with everything */
4233  i = 0;
4234  }
4235  }
4236  if (decoder_ret)
4237  *decoder_ret = (AVCodec*)best_decoder;
4238  return ret;
4239 }
4240 
4241 /*******************************************************/
4242 
4244 {
4245  if (s->iformat->read_play)
4246  return s->iformat->read_play(s);
4247  if (s->pb)
4248  return avio_pause(s->pb, 0);
4249  return AVERROR(ENOSYS);
4250 }
4251 
4253 {
4254  if (s->iformat->read_pause)
4255  return s->iformat->read_pause(s);
4256  if (s->pb)
4257  return avio_pause(s->pb, 1);
4258  return AVERROR(ENOSYS);
4259 }
4260 
4262 {
4263  int ret, i;
4264 
4265  dst->id = src->id;
4266  dst->time_base = src->time_base;
4267  dst->nb_frames = src->nb_frames;
4268  dst->disposition = src->disposition;
4270  dst->avg_frame_rate = src->avg_frame_rate;
4271  dst->r_frame_rate = src->r_frame_rate;
4272 
4273  av_dict_free(&dst->metadata);
4274  ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4275  if (ret < 0)
4276  return ret;
4277 
4278  ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4279  if (ret < 0)
4280  return ret;
4281 
4282  /* Free existing side data*/
4283  for (i = 0; i < dst->nb_side_data; i++)
4284  av_free(dst->side_data[i].data);
4285  av_freep(&dst->side_data);
4286  dst->nb_side_data = 0;
4287 
4288  /* Copy side data if present */
4289  if (src->nb_side_data) {
4291  sizeof(AVPacketSideData));
4292  if (!dst->side_data)
4293  return AVERROR(ENOMEM);
4294  dst->nb_side_data = src->nb_side_data;
4295 
4296  for (i = 0; i < src->nb_side_data; i++) {
4297  uint8_t *data = av_memdup(src->side_data[i].data,
4298  src->side_data[i].size);
4299  if (!data)
4300  return AVERROR(ENOMEM);
4301  dst->side_data[i].type = src->side_data[i].type;
4302  dst->side_data[i].size = src->side_data[i].size;
4303  dst->side_data[i].data = data;
4304  }
4305  }
4306 
4307 #if FF_API_LAVF_FFSERVER
4309  av_freep(&dst->recommended_encoder_configuration);
4310  if (src->recommended_encoder_configuration) {
4311  const char *conf_str = src->recommended_encoder_configuration;
4312  dst->recommended_encoder_configuration = av_strdup(conf_str);
4313  if (!dst->recommended_encoder_configuration)
4314  return AVERROR(ENOMEM);
4315  }
4317 #endif
4318 
4319  return 0;
4320 }
4321 
4322 static void free_stream(AVStream **pst)
4323 {
4324  AVStream *st = *pst;
4325  int i;
4326 
4327  if (!st)
4328  return;
4329 
4330  for (i = 0; i < st->nb_side_data; i++)
4331  av_freep(&st->side_data[i].data);
4332  av_freep(&st->side_data);
4333 
4334  if (st->parser)
4335  av_parser_close(st->parser);
4336 
4337  if (st->attached_pic.data)
4339 
4340  if (st->internal) {
4342  av_bsf_free(&st->internal->bsfc);
4343  av_freep(&st->internal->priv_pts);
4346  }
4347  av_freep(&st->internal);
4348 
4349  av_dict_free(&st->metadata);
4351  av_freep(&st->probe_data.buf);
4352  av_freep(&st->index_entries);
4353 #if FF_API_LAVF_AVCTX
4355  avcodec_free_context(&st->codec);
4357 #endif
4358  av_freep(&st->priv_data);
4359  if (st->info)
4360  av_freep(&st->info->duration_error);
4361  av_freep(&st->info);
4362 #if FF_API_LAVF_FFSERVER
4364  av_freep(&st->recommended_encoder_configuration);
4366 #endif
4367 
4368  av_freep(pst);
4369 }
4370 
4372 {
4373  av_assert0(s->nb_streams>0);
4374  av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4375 
4376  free_stream(&s->streams[ --s->nb_streams ]);
4377 }
4378 
4380 {
4381  int i;
4382 
4383  if (!s)
4384  return;
4385 
4386  if (s->oformat && s->oformat->deinit && s->internal->initialized)
4387  s->oformat->deinit(s);
4388 
4389  av_opt_free(s);
4390  if (s->iformat && s->iformat->priv_class && s->priv_data)
4391  av_opt_free(s->priv_data);
4392  if (s->oformat && s->oformat->priv_class && s->priv_data)
4393  av_opt_free(s->priv_data);
4394 
4395  for (i = 0; i < s->nb_streams; i++)
4396  free_stream(&s->streams[i]);
4397  s->nb_streams = 0;
4398 
4399  for (i = 0; i < s->nb_programs; i++) {
4400  av_dict_free(&s->programs[i]->metadata);
4401  av_freep(&s->programs[i]->stream_index);
4402  av_freep(&s->programs[i]);
4403  }
4404  s->nb_programs = 0;
4405 
4406  av_freep(&s->programs);
4407  av_freep(&s->priv_data);
4408  while (s->nb_chapters--) {
4410  av_freep(&s->chapters[s->nb_chapters]);
4411  }
4412  av_freep(&s->chapters);
4413  av_dict_free(&s->metadata);
4415  av_freep(&s->streams);
4416  flush_packet_queue(s);
4417  av_freep(&s->internal);
4418  av_freep(&s->url);
4419  av_free(s);
4420 }
4421 
4423 {
4424  AVFormatContext *s;
4425  AVIOContext *pb;
4426 
4427  if (!ps || !*ps)
4428  return;
4429 
4430  s = *ps;
4431  pb = s->pb;
4432 
4433  if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4434  (s->flags & AVFMT_FLAG_CUSTOM_IO))
4435  pb = NULL;
4436 
4437  flush_packet_queue(s);
4438 
4439  if (s->iformat)
4440  if (s->iformat->read_close)
4441  s->iformat->read_close(s);
4442 
4444 
4445  *ps = NULL;
4446 
4447  avio_close(pb);
4448 }
4449 
4451 {
4452  AVStream *st;
4453  int i;
4454  AVStream **streams;
4455 
4456  if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4457  if (s->max_streams < INT_MAX/sizeof(*streams))
4458  av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter (%d), see the documentation if you wish to increase it\n", s->max_streams);
4459  return NULL;
4460  }
4461  streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4462  if (!streams)
4463  return NULL;
4464  s->streams = streams;
4465 
4466  st = av_mallocz(sizeof(AVStream));
4467  if (!st)
4468  return NULL;
4469  if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4470  av_free(st);
4471  return NULL;
4472  }
4473  st->info->last_dts = AV_NOPTS_VALUE;
4474 
4475 #if FF_API_LAVF_AVCTX
4477  st->codec = avcodec_alloc_context3(c);
4478  if (!st->codec) {
4479  av_free(st->info);
4480  av_free(st);
4481  return NULL;
4482  }
4484 #endif
4485 
4486  st->internal = av_mallocz(sizeof(*st->internal));
4487  if (!st->internal)
4488  goto fail;
4489 
4491  if (!st->codecpar)
4492  goto fail;
4493 
4495  if (!st->internal->avctx)
4496  goto fail;
4497 
4498  if (s->iformat) {
4499 #if FF_API_LAVF_AVCTX
4501  /* no default bitrate if decoding */
4502  st->codec->bit_rate = 0;
4504 #endif
4505 
4506  /* default pts setting is MPEG-like */
4507  avpriv_set_pts_info(st, 33, 1, 90000);
4508  /* we set the current DTS to 0 so that formats without any timestamps
4509  * but durations get some timestamps, formats with some unknown
4510  * timestamps have their first few packets buffered and the
4511  * timestamps corrected before they are returned to the user */
4512  st->cur_dts = RELATIVE_TS_BASE;
4513  } else {
4514  st->cur_dts = AV_NOPTS_VALUE;
4515  }
4516 
4517  st->index = s->nb_streams;
4518  st->start_time = AV_NOPTS_VALUE;
4519  st->duration = AV_NOPTS_VALUE;
4520  st->first_dts = AV_NOPTS_VALUE;
4524 
4527  for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4528  st->pts_buffer[i] = AV_NOPTS_VALUE;
4529 
4530  st->sample_aspect_ratio = (AVRational) { 0, 1 };
4531 
4532 #if FF_API_R_FRAME_RATE
4533  st->info->last_dts = AV_NOPTS_VALUE;
4534 #endif
4537 
4539 
4540  st->internal->need_context_update = 1;
4541 
4542  s->streams[s->nb_streams++] = st;
4543  return st;
4544 fail:
4545  free_stream(&st);
4546  return NULL;
4547 }
4548 
4550 {
4551  AVProgram *program = NULL;
4552  int i;
4553 
4554  av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4555 
4556  for (i = 0; i < ac->nb_programs; i++)
4557  if (ac->programs[i]->id == id)
4558  program = ac->programs[i];
4559 
4560  if (!program) {
4561  program = av_mallocz(sizeof(AVProgram));
4562  if (!program)
4563  return NULL;
4564  dynarray_add(&ac->programs, &ac->nb_programs, program);
4565  program->discard = AVDISCARD_NONE;
4566  program->pmt_version = -1;
4567  }
4568  program->id = id;
4571 
4572  progr