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