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