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