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