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