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