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 #undef NDEBUG
23 #include <assert.h>
24 #include <stdarg.h>
25 #include <stdint.h>
26 
27 #include "config.h"
28 
29 #include "libavutil/avassert.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/dict.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/parseutils.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/time.h"
38 #include "libavutil/timestamp.h"
39 
40 #include "libavcodec/bytestream.h"
41 #include "libavcodec/internal.h"
42 #include "libavcodec/raw.h"
43 
44 #include "audiointerleave.h"
45 #include "avformat.h"
46 #include "avio_internal.h"
47 #include "id3v2.h"
48 #include "internal.h"
49 #include "metadata.h"
50 #if CONFIG_NETWORK
51 #include "network.h"
52 #endif
53 #include "riff.h"
54 #include "url.h"
55 
56 /**
57  * @file
58  * various utility functions for use within FFmpeg
59  */
60 
61 unsigned avformat_version(void)
62 {
65 }
66 
67 const char *avformat_configuration(void)
68 {
69  return FFMPEG_CONFIGURATION;
70 }
71 
72 const char *avformat_license(void)
73 {
74 #define LICENSE_PREFIX "libavformat license: "
75  return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
76 }
77 
78 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
79 
80 static int is_relative(int64_t ts) {
81  return ts > (RELATIVE_TS_BASE - (1LL<<48));
82 }
83 
84 /**
85  * Wrap a given time stamp, if there is an indication for an overflow
86  *
87  * @param st stream
88  * @param timestamp the time stamp to wrap
89  * @return resulting time stamp
90  */
91 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
92 {
94  st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
96  timestamp < st->pts_wrap_reference)
97  return timestamp + (1ULL << st->pts_wrap_bits);
98  else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
99  timestamp >= st->pts_wrap_reference)
100  return timestamp - (1ULL << st->pts_wrap_bits);
101  }
102  return timestamp;
103 }
104 
105 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
106 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
107 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
108 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
109 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
110 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
111 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
112 
113 static AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
114 {
115  if (st->codec->codec)
116  return st->codec->codec;
117 
118  switch (st->codec->codec_type) {
119  case AVMEDIA_TYPE_VIDEO:
120  if (s->video_codec) return s->video_codec;
121  break;
122  case AVMEDIA_TYPE_AUDIO:
123  if (s->audio_codec) return s->audio_codec;
124  break;
126  if (s->subtitle_codec) return s->subtitle_codec;
127  break;
128  }
129 
130  return avcodec_find_decoder(codec_id);
131 }
132 
134 {
135  return s->probe_score;
136 }
137 
138 /* an arbitrarily chosen "sane" max packet size -- 50M */
139 #define SANE_CHUNK_SIZE (50000000)
140 
142 {
143  if (s->maxsize>= 0) {
144  int64_t remaining= s->maxsize - avio_tell(s);
145  if (remaining < size) {
146  int64_t newsize = avio_size(s);
147  if (!s->maxsize || s->maxsize<newsize)
148  s->maxsize = newsize - !newsize;
149  remaining= s->maxsize - avio_tell(s);
150  remaining= FFMAX(remaining, 0);
151  }
152 
153  if (s->maxsize>= 0 && remaining+1 < size) {
154  av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
155  size = remaining+1;
156  }
157  }
158  return size;
159 }
160 
161 /* Read the data in sane-sized chunks and append to pkt.
162  * Return the number of bytes read or an error. */
164 {
165  int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
166  int orig_size = pkt->size;
167  int ret;
168 
169  do {
170  int prev_size = pkt->size;
171  int read_size;
172 
173  /* When the caller requests a lot of data, limit it to the amount
174  * left in file or SANE_CHUNK_SIZE when it is not known. */
175  read_size = size;
176  if (read_size > SANE_CHUNK_SIZE/10) {
177  read_size = ffio_limit(s, read_size);
178  // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
179  if (s->maxsize < 0)
180  read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
181  }
182 
183  ret = av_grow_packet(pkt, read_size);
184  if (ret < 0)
185  break;
186 
187  ret = avio_read(s, pkt->data + prev_size, read_size);
188  if (ret != read_size) {
189  av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
190  break;
191  }
192 
193  size -= read_size;
194  } while (size > 0);
195  if (size > 0)
196  pkt->flags |= AV_PKT_FLAG_CORRUPT;
197 
198  pkt->pos = orig_pos;
199  if (!pkt->size)
200  av_free_packet(pkt);
201  return pkt->size > orig_size ? pkt->size - orig_size : ret;
202 }
203 
205 {
206  av_init_packet(pkt);
207  pkt->data = NULL;
208  pkt->size = 0;
209  pkt->pos = avio_tell(s);
210 
211  return append_packet_chunked(s, pkt, size);
212 }
213 
215 {
216  if (!pkt->size)
217  return av_get_packet(s, pkt, size);
218  return append_packet_chunked(s, pkt, size);
219 }
220 
221 int av_filename_number_test(const char *filename)
222 {
223  char buf[1024];
224  return filename &&
225  (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
226 }
227 
229  int *score_ret)
230 {
231  AVProbeData lpd = *pd;
232  AVInputFormat *fmt1 = NULL, *fmt;
233  int score, nodat = 0, score_max = 0;
234  const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
235 
236  if (!lpd.buf)
237  lpd.buf = zerobuffer;
238 
239  if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
240  int id3len = ff_id3v2_tag_len(lpd.buf);
241  if (lpd.buf_size > id3len + 16) {
242  lpd.buf += id3len;
243  lpd.buf_size -= id3len;
244  } else
245  nodat = 1;
246  }
247 
248  fmt = NULL;
249  while ((fmt1 = av_iformat_next(fmt1))) {
250  if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
251  continue;
252  score = 0;
253  if (fmt1->read_probe) {
254  score = fmt1->read_probe(&lpd);
255  if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
256  score = FFMAX(score, nodat ? AVPROBE_SCORE_EXTENSION / 2 - 1 : 1);
257  } else if (fmt1->extensions) {
258  if (av_match_ext(lpd.filename, fmt1->extensions))
259  score = AVPROBE_SCORE_EXTENSION;
260  }
261  if (score > score_max) {
262  score_max = score;
263  fmt = fmt1;
264  } else if (score == score_max)
265  fmt = NULL;
266  }
267  if (nodat)
268  score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
269  *score_ret = score_max;
270 
271  return fmt;
272 }
273 
274 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
275 {
276  int score_ret;
277  AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
278  if (score_ret > *score_max) {
279  *score_max = score_ret;
280  return fmt;
281  } else
282  return NULL;
283 }
284 
286 {
287  int score = 0;
288  return av_probe_input_format2(pd, is_opened, &score);
289 }
290 
292  AVProbeData *pd)
293 {
294  static const struct {
295  const char *name;
296  enum AVCodecID id;
297  enum AVMediaType type;
298  } fmt_id_type[] = {
308  { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
309  { 0 }
310  };
311  int score;
312  AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
313 
314  if (fmt && st->request_probe <= score) {
315  int i;
316  av_log(s, AV_LOG_DEBUG,
317  "Probe with size=%d, packets=%d detected %s with score=%d\n",
319  fmt->name, score);
320  for (i = 0; fmt_id_type[i].name; i++) {
321  if (!strcmp(fmt->name, fmt_id_type[i].name)) {
322  st->codec->codec_id = fmt_id_type[i].id;
323  st->codec->codec_type = fmt_id_type[i].type;
324  break;
325  }
326  }
327  }
328  return score;
329 }
330 
331 /************************************************************/
332 /* input media file */
333 
335  int err;
336 
337  if (ic->iformat->read_header) {
338  err = ic->iformat->read_header(ic);
339  if (err < 0)
340  return err;
341  }
342 
343  if (ic->pb && !ic->data_offset)
344  ic->data_offset = avio_tell(ic->pb);
345 
346  return 0;
347 }
348 
349 
351  const char *filename, void *logctx,
352  unsigned int offset, unsigned int max_probe_size)
353 {
354  AVProbeData pd = { filename ? filename : "" };
355  uint8_t *buf = NULL;
356  uint8_t *mime_type;
357  int ret = 0, probe_size, buf_offset = 0;
358  int score = 0;
359 
360  if (!max_probe_size)
361  max_probe_size = PROBE_BUF_MAX;
362  else if (max_probe_size > PROBE_BUF_MAX)
363  max_probe_size = PROBE_BUF_MAX;
364  else if (max_probe_size < PROBE_BUF_MIN) {
365  av_log(logctx, AV_LOG_ERROR,
366  "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
367  return AVERROR(EINVAL);
368  }
369 
370  if (offset >= max_probe_size)
371  return AVERROR(EINVAL);
372 
373  if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
374  if (!av_strcasecmp(mime_type, "audio/aacp")) {
375  *fmt = av_find_input_format("aac");
376  }
377  av_freep(&mime_type);
378  }
379 
380  for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
381  probe_size = FFMIN(probe_size << 1,
382  FFMAX(max_probe_size, probe_size + 1))) {
383  score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
384 
385  /* Read probe data. */
386  if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
387  return ret;
388  if ((ret = avio_read(pb, buf + buf_offset,
389  probe_size - buf_offset)) < 0) {
390  /* Fail if error was not end of file, otherwise, lower score. */
391  if (ret != AVERROR_EOF) {
392  av_free(buf);
393  return ret;
394  }
395  score = 0;
396  ret = 0; /* error was end of file, nothing read */
397  }
398  buf_offset += ret;
399  if (buf_offset < offset)
400  continue;
401  pd.buf_size = buf_offset - offset;
402  pd.buf = &buf[offset];
403 
404  memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
405 
406  /* Guess file format. */
407  *fmt = av_probe_input_format2(&pd, 1, &score);
408  if (*fmt) {
409  /* This can only be true in the last iteration. */
410  if (score <= AVPROBE_SCORE_RETRY) {
411  av_log(logctx, AV_LOG_WARNING,
412  "Format %s detected only with low score of %d, "
413  "misdetection possible!\n", (*fmt)->name, score);
414  } else
415  av_log(logctx, AV_LOG_DEBUG,
416  "Format %s probed with size=%d and score=%d\n",
417  (*fmt)->name, probe_size, score);
418 #if 0
419  FILE *f = fopen("probestat.tmp", "ab");
420  fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
421  fclose(f);
422 #endif
423  }
424  }
425 
426  if (!*fmt) {
427  av_free(buf);
428  return AVERROR_INVALIDDATA;
429  }
430 
431  /* Rewind. Reuse probe buffer to avoid seeking. */
432  ret = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
433 
434  return ret < 0 ? ret : score;
435 }
436 
438  const char *filename, void *logctx,
439  unsigned int offset, unsigned int max_probe_size)
440 {
441  int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
442  return ret < 0 ? ret : 0;
443 }
444 
445 /* Open input file and probe the format if necessary. */
446 static int init_input(AVFormatContext *s, const char *filename,
448 {
449  int ret;
450  AVProbeData pd = { filename, NULL, 0 };
451  int score = AVPROBE_SCORE_RETRY;
452 
453  if (s->pb) {
455  if (!s->iformat)
456  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
457  s, 0, s->probesize);
458  else if (s->iformat->flags & AVFMT_NOFILE)
459  av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
460  "will be ignored with AVFMT_NOFILE format.\n");
461  return 0;
462  }
463 
464  if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
465  (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
466  return score;
467 
468  if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
469  &s->interrupt_callback, options)) < 0)
470  return ret;
471  if (s->iformat)
472  return 0;
473  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
474  s, 0, s->probesize);
475 }
476 
477 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
478  AVPacketList **plast_pktl)
479 {
480  AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
481  if (!pktl)
482  return NULL;
483 
484  if (*packet_buffer)
485  (*plast_pktl)->next = pktl;
486  else
487  *packet_buffer = pktl;
488 
489  /* Add the packet in the buffered packet list. */
490  *plast_pktl = pktl;
491  pktl->pkt = *pkt;
492  return &pktl->pkt;
493 }
494 
496 {
497  int i;
498  for (i = 0; i < s->nb_streams; i++)
500  s->streams[i]->discard < AVDISCARD_ALL) {
502  copy.buf = av_buffer_ref(copy.buf);
503  if (!copy.buf)
504  return AVERROR(ENOMEM);
505 
506  add_to_pktbuf(&s->raw_packet_buffer, &copy,
508  }
509  return 0;
510 }
511 
512 int avformat_open_input(AVFormatContext **ps, const char *filename,
514 {
515  AVFormatContext *s = *ps;
516  int ret = 0;
517  AVDictionary *tmp = NULL;
518  ID3v2ExtraMeta *id3v2_extra_meta = NULL;
519 
520  if (!s && !(s = avformat_alloc_context()))
521  return AVERROR(ENOMEM);
522  if (!s->av_class) {
523  av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
524  return AVERROR(EINVAL);
525  }
526  if (fmt)
527  s->iformat = fmt;
528 
529  if (options)
530  av_dict_copy(&tmp, *options, 0);
531 
532  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
533  goto fail;
534 
535  if ((ret = init_input(s, filename, &tmp)) < 0)
536  goto fail;
537  s->probe_score = ret;
539 
540  /* Check filename in case an image number is expected. */
541  if (s->iformat->flags & AVFMT_NEEDNUMBER) {
542  if (!av_filename_number_test(filename)) {
543  ret = AVERROR(EINVAL);
544  goto fail;
545  }
546  }
547 
549  av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
550 
551  /* Allocate private data. */
552  if (s->iformat->priv_data_size > 0) {
553  if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
554  ret = AVERROR(ENOMEM);
555  goto fail;
556  }
557  if (s->iformat->priv_class) {
558  *(const AVClass **) s->priv_data = s->iformat->priv_class;
560  if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
561  goto fail;
562  }
563  }
564 
565  /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
566  if (s->pb)
567  ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
568 
569  if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
570  if ((ret = s->iformat->read_header(s)) < 0)
571  goto fail;
572 
573  if (id3v2_extra_meta) {
574  if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
575  !strcmp(s->iformat->name, "tta")) {
576  if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
577  goto fail;
578  } else
579  av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
580  }
581  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
582 
583  if ((ret = avformat_queue_attached_pictures(s)) < 0)
584  goto fail;
585 
586  if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
587  s->data_offset = avio_tell(s->pb);
588 
590 
591  if (options) {
592  av_dict_free(options);
593  *options = tmp;
594  }
595  *ps = s;
596  return 0;
597 
598 fail:
599  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
600  av_dict_free(&tmp);
601  if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
602  avio_close(s->pb);
604  *ps = NULL;
605  return ret;
606 }
607 
608 /*******************************************************/
609 
611 {
612  switch (st->codec->codec_type) {
613  case AVMEDIA_TYPE_VIDEO:
614  if (s->video_codec_id)
615  st->codec->codec_id = s->video_codec_id;
616  break;
617  case AVMEDIA_TYPE_AUDIO:
618  if (s->audio_codec_id)
619  st->codec->codec_id = s->audio_codec_id;
620  break;
622  if (s->subtitle_codec_id)
623  st->codec->codec_id = s->subtitle_codec_id;
624  break;
625  }
626 }
627 
629 {
630  if (st->request_probe>0) {
631  AVProbeData *pd = &st->probe_data;
632  int end;
633  av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
634  --st->probe_packets;
635 
636  if (pkt) {
637  uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
638  if (!new_buf) {
640  "Failed to reallocate probe buffer for stream %d\n",
641  st->index);
642  goto no_packet;
643  }
644  pd->buf = new_buf;
645  memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
646  pd->buf_size += pkt->size;
647  memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
648  } else {
649 no_packet:
650  st->probe_packets = 0;
651  if (!pd->buf_size) {
653  "nothing to probe for stream %d\n", st->index);
654  }
655  }
656 
658  || st->probe_packets<= 0;
659 
660  if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
661  int score = set_codec_from_probe_data(s, st, pd);
663  || end) {
664  pd->buf_size = 0;
665  av_freep(&pd->buf);
666  st->request_probe = -1;
667  if (st->codec->codec_id != AV_CODEC_ID_NONE) {
668  av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
669  } else
670  av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
671  }
672  force_codec_ids(s, st);
673  }
674  }
675  return 0;
676 }
677 
678 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
679 {
680  int64_t ref = pkt->dts;
681  int i, pts_wrap_behavior;
682  int64_t pts_wrap_reference;
683  AVProgram *first_program;
684 
685  if (ref == AV_NOPTS_VALUE)
686  ref = pkt->pts;
687  if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
688  return 0;
689  ref &= (1LL << st->pts_wrap_bits)-1;
690 
691  // reference time stamp should be 60 s before first time stamp
692  pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
693  // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
694  pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
695  (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
697 
698  first_program = av_find_program_from_stream(s, NULL, stream_index);
699 
700  if (!first_program) {
701  int default_stream_index = av_find_default_stream_index(s);
702  if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
703  for (i = 0; i < s->nb_streams; i++) {
704  s->streams[i]->pts_wrap_reference = pts_wrap_reference;
705  s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
706  }
707  }
708  else {
709  st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
710  st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
711  }
712  }
713  else {
714  AVProgram *program = first_program;
715  while (program) {
716  if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
717  pts_wrap_reference = program->pts_wrap_reference;
718  pts_wrap_behavior = program->pts_wrap_behavior;
719  break;
720  }
721  program = av_find_program_from_stream(s, program, stream_index);
722  }
723 
724  // update every program with differing pts_wrap_reference
725  program = first_program;
726  while (program) {
727  if (program->pts_wrap_reference != pts_wrap_reference) {
728  for (i = 0; i<program->nb_stream_indexes; i++) {
729  s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
730  s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
731  }
732 
733  program->pts_wrap_reference = pts_wrap_reference;
734  program->pts_wrap_behavior = pts_wrap_behavior;
735  }
736  program = av_find_program_from_stream(s, program, stream_index);
737  }
738  }
739  return 1;
740 }
741 
743 {
744  int ret, i, err;
745  AVStream *st;
746 
747  for (;;) {
748  AVPacketList *pktl = s->raw_packet_buffer;
749 
750  if (pktl) {
751  *pkt = pktl->pkt;
752  st = s->streams[pkt->stream_index];
754  if ((err = probe_codec(s, st, NULL)) < 0)
755  return err;
756  if (st->request_probe <= 0) {
757  s->raw_packet_buffer = pktl->next;
759  av_free(pktl);
760  return 0;
761  }
762  }
763 
764  pkt->data = NULL;
765  pkt->size = 0;
766  av_init_packet(pkt);
767  ret = s->iformat->read_packet(s, pkt);
768  if (ret < 0) {
769  if (!pktl || ret == AVERROR(EAGAIN))
770  return ret;
771  for (i = 0; i < s->nb_streams; i++) {
772  st = s->streams[i];
773  if (st->probe_packets)
774  if ((err = probe_codec(s, st, NULL)) < 0)
775  return err;
776  av_assert0(st->request_probe <= 0);
777  }
778  continue;
779  }
780 
781  if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
782  (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
784  "Dropped corrupted packet (stream = %d)\n",
785  pkt->stream_index);
786  av_free_packet(pkt);
787  continue;
788  }
789 
790  if (pkt->stream_index >= (unsigned)s->nb_streams) {
791  av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
792  continue;
793  }
794 
795  st = s->streams[pkt->stream_index];
796 
798  // correct first time stamps to negative values
799  if (!is_relative(st->first_dts))
800  st->first_dts = wrap_timestamp(st, st->first_dts);
801  if (!is_relative(st->start_time))
802  st->start_time = wrap_timestamp(st, st->start_time);
803  if (!is_relative(st->cur_dts))
804  st->cur_dts = wrap_timestamp(st, st->cur_dts);
805  }
806 
807  pkt->dts = wrap_timestamp(st, pkt->dts);
808  pkt->pts = wrap_timestamp(st, pkt->pts);
809 
810  force_codec_ids(s, st);
811 
812  /* TODO: audio: time filter; video: frame reordering (pts != dts) */
814  pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
815 
816  if (!pktl && st->request_probe <= 0)
817  return ret;
818 
821 
822  if ((err = probe_codec(s, st, pkt)) < 0)
823  return err;
824  }
825 }
826 
827 #if FF_API_READ_PACKET
828 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
829 {
830  return ff_read_packet(s, pkt);
831 }
832 #endif
833 
834 
835 /**********************************************************/
836 
838 {
839  if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
840  avctx->codec_id == AV_CODEC_ID_MP1 ||
841  avctx->codec_id == AV_CODEC_ID_MP2 ||
842  avctx->codec_id == AV_CODEC_ID_MP3/* ||
843  avctx->codec_id == AV_CODEC_ID_CELT*/)
844  return 1;
845  return 0;
846 }
847 
848 /**
849  * Get the number of samples of an audio frame. Return -1 on error.
850  */
852 {
853  int frame_size;
854 
855  /* give frame_size priority if demuxing */
856  if (!mux && enc->frame_size > 1)
857  return enc->frame_size;
858 
859  if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
860  return frame_size;
861 
862  /* Fall back on using frame_size if muxing. */
863  if (enc->frame_size > 1)
864  return enc->frame_size;
865 
866  //For WMA we currently have no other means to calculate duration thus we
867  //do it here by assuming CBR, which is true for all known cases.
868  if (!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
869  if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
870  return ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
871  }
872 
873  return -1;
874 }
875 
876 /**
877  * Return the frame duration in seconds. Return 0 if not available.
878  */
879 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
881 {
882  int frame_size;
883 
884  *pnum = 0;
885  *pden = 0;
886  switch (st->codec->codec_type) {
887  case AVMEDIA_TYPE_VIDEO:
888  if (st->r_frame_rate.num && !pc) {
889  *pnum = st->r_frame_rate.den;
890  *pden = st->r_frame_rate.num;
891  } else if (st->time_base.num * 1000LL > st->time_base.den) {
892  *pnum = st->time_base.num;
893  *pden = st->time_base.den;
894  } else if (st->codec->time_base.num * 1000LL > st->codec->time_base.den) {
895  *pnum = st->codec->time_base.num;
896  *pden = st->codec->time_base.den;
897  if (pc && pc->repeat_pict) {
898  if (*pnum > INT_MAX / (1 + pc->repeat_pict))
899  *pden /= 1 + pc->repeat_pict;
900  else
901  *pnum *= 1 + pc->repeat_pict;
902  }
903  /* If this codec can be interlaced or progressive then we need
904  * a parser to compute duration of a packet. Thus if we have
905  * no parser in such case leave duration undefined. */
906  if (st->codec->ticks_per_frame > 1 && !pc)
907  *pnum = *pden = 0;
908  }
909  break;
910  case AVMEDIA_TYPE_AUDIO:
911  frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
912  if (frame_size <= 0 || st->codec->sample_rate <= 0)
913  break;
914  *pnum = frame_size;
915  *pden = st->codec->sample_rate;
916  break;
917  default:
918  break;
919  }
920 }
921 
922 static int is_intra_only(AVCodecContext *enc) {
923  const AVCodecDescriptor *desc;
924 
925  if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
926  return 1;
927 
928  desc = av_codec_get_codec_descriptor(enc);
929  if (!desc) {
930  desc = avcodec_descriptor_get(enc->codec_id);
932  }
933  if (desc)
934  return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
935  return 0;
936 }
937 
939 {
940  if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
941  if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
942  return 1;
943 #if CONFIG_H264_DECODER
944  if (st->codec->has_b_frames &&
946  return 1;
947 #endif
948  if (st->codec->has_b_frames<3)
949  return st->nb_decoded_frames >= 7;
950  else if (st->codec->has_b_frames<4)
951  return st->nb_decoded_frames >= 18;
952  else
953  return st->nb_decoded_frames >= 20;
954 }
955 
957 {
958  if (pktl->next)
959  return pktl->next;
960  if (pktl == s->packet_buffer_end)
961  return s->parse_queue;
962  return NULL;
963 }
964 
965 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
966  int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
968 
969  if(!onein_oneout) {
970  int delay = st->codec->has_b_frames;
971  int i;
972 
973  if (dts == AV_NOPTS_VALUE) {
974  int64_t best_score = INT64_MAX;
975  for (i = 0; i<delay; i++) {
976  if (st->pts_reorder_error_count[i]) {
977  int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
978  if (score < best_score) {
979  best_score = score;
980  dts = pts_buffer[i];
981  }
982  }
983  }
984  } else {
985  for (i = 0; i<delay; i++) {
986  if (pts_buffer[i] != AV_NOPTS_VALUE) {
987  int64_t diff = FFABS(pts_buffer[i] - dts)
988  + (uint64_t)st->pts_reorder_error[i];
989  diff = FFMAX(diff, st->pts_reorder_error[i]);
990  st->pts_reorder_error[i] = diff;
991  st->pts_reorder_error_count[i]++;
992  if (st->pts_reorder_error_count[i] > 250) {
993  st->pts_reorder_error[i] >>= 1;
994  st->pts_reorder_error_count[i] >>= 1;
995  }
996  }
997  }
998  }
999  }
1000 
1001  if (dts == AV_NOPTS_VALUE)
1002  dts = pts_buffer[0];
1003 
1004  return dts;
1005 }
1006 
1007 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1008  int64_t dts, int64_t pts, AVPacket *pkt)
1009 {
1010  AVStream *st = s->streams[stream_index];
1011  AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1012  int64_t pts_buffer[MAX_REORDER_DELAY+1];
1013  int64_t shift;
1014  int i, delay;
1015 
1016  if (st->first_dts != AV_NOPTS_VALUE ||
1017  dts == AV_NOPTS_VALUE ||
1018  st->cur_dts == AV_NOPTS_VALUE ||
1019  is_relative(dts))
1020  return;
1021 
1022  delay = st->codec->has_b_frames;
1023  st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1024  st->cur_dts = dts;
1025  shift = st->first_dts - RELATIVE_TS_BASE;
1026 
1027  for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1028  pts_buffer[i] = AV_NOPTS_VALUE;
1029 
1030  if (is_relative(pts))
1031  pts += shift;
1032 
1033  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1034  if (pktl->pkt.stream_index != stream_index)
1035  continue;
1036  if (is_relative(pktl->pkt.pts))
1037  pktl->pkt.pts += shift;
1038 
1039  if (is_relative(pktl->pkt.dts))
1040  pktl->pkt.dts += shift;
1041 
1042  if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
1043  st->start_time = pktl->pkt.pts;
1044 
1045  if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1046  pts_buffer[0] = pktl->pkt.pts;
1047  for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1048  FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1049 
1050  pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
1051  }
1052  }
1053 
1054  if (st->start_time == AV_NOPTS_VALUE)
1055  st->start_time = pts;
1056 }
1057 
1059  int stream_index, int duration)
1060 {
1061  AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1062  int64_t cur_dts = RELATIVE_TS_BASE;
1063 
1064  if (st->first_dts != AV_NOPTS_VALUE) {
1066  return;
1068  cur_dts = st->first_dts;
1069  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1070  if (pktl->pkt.stream_index == stream_index) {
1071  if (pktl->pkt.pts != pktl->pkt.dts ||
1072  pktl->pkt.dts != AV_NOPTS_VALUE ||
1073  pktl->pkt.duration)
1074  break;
1075  cur_dts -= duration;
1076  }
1077  }
1078  if (pktl && pktl->pkt.dts != st->first_dts) {
1079  av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
1080  av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1081  return;
1082  }
1083  if (!pktl) {
1084  av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1085  return;
1086  }
1087  pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1088  st->first_dts = cur_dts;
1089  } else if (st->cur_dts != RELATIVE_TS_BASE)
1090  return;
1091 
1092  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1093  if (pktl->pkt.stream_index != stream_index)
1094  continue;
1095  if (pktl->pkt.pts == pktl->pkt.dts &&
1096  (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
1097  !pktl->pkt.duration) {
1098  pktl->pkt.dts = cur_dts;
1099  if (!st->codec->has_b_frames)
1100  pktl->pkt.pts = cur_dts;
1101 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1102  pktl->pkt.duration = duration;
1103  } else
1104  break;
1105  cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1106  }
1107  if (!pktl)
1108  st->cur_dts = cur_dts;
1109 }
1110 
1113 {
1114  int num, den, presentation_delayed, delay, i;
1115  int64_t offset;
1117  int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
1119 
1120  if (s->flags & AVFMT_FLAG_NOFILLIN)
1121  return;
1122 
1123  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1124  if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1125  if (st->last_dts_for_order_check <= pkt->dts) {
1126  st->dts_ordered++;
1127  } else {
1129  "DTS %"PRIi64" < %"PRIi64" out of order\n",
1130  pkt->dts,
1132  st->dts_misordered++;
1133  }
1134  if (st->dts_ordered + st->dts_misordered > 250) {
1135  st->dts_ordered >>= 1;
1136  st->dts_misordered >>= 1;
1137  }
1138  }
1139 
1140  st->last_dts_for_order_check = pkt->dts;
1141  if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1142  pkt->dts = AV_NOPTS_VALUE;
1143  }
1144 
1145  if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1146  pkt->dts = AV_NOPTS_VALUE;
1147 
1148  if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1149  && !st->codec->has_b_frames)
1150  //FIXME Set low_delay = 0 when has_b_frames = 1
1151  st->codec->has_b_frames = 1;
1152 
1153  /* do we have a video B-frame ? */
1154  delay = st->codec->has_b_frames;
1155  presentation_delayed = 0;
1156 
1157  /* XXX: need has_b_frame, but cannot get it if the codec is
1158  * not initialized */
1159  if (delay &&
1160  pc && pc->pict_type != AV_PICTURE_TYPE_B)
1161  presentation_delayed = 1;
1162 
1163  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1164  st->pts_wrap_bits < 63 &&
1165  pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1166  if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1167  pkt->dts -= 1LL << st->pts_wrap_bits;
1168  } else
1169  pkt->pts += 1LL << st->pts_wrap_bits;
1170  }
1171 
1172  /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1173  * We take the conservative approach and discard both.
1174  * Note: If this is misbehaving for an H.264 file, then possibly
1175  * presentation_delayed is not set correctly. */
1176  if (delay == 1 && pkt->dts == pkt->pts &&
1177  pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1178  av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1179  if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1180  && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1181  pkt->dts = AV_NOPTS_VALUE;
1182  }
1183 
1184  duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1185  if (pkt->duration == 0) {
1186  ff_compute_frame_duration(&num, &den, st, pc, pkt);
1187  if (den && num) {
1188  duration = (AVRational) {num, den};
1189  pkt->duration = av_rescale_rnd(1,
1190  num * (int64_t) st->time_base.den,
1191  den * (int64_t) st->time_base.num,
1192  AV_ROUND_DOWN);
1193  }
1194  }
1195 
1196  if (pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1197  update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1198 
1199  /* Correct timestamps with byte offset if demuxers only have timestamps
1200  * on packet boundaries */
1201  if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1202  /* this will estimate bitrate based on this frame's duration and size */
1203  offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1204  if (pkt->pts != AV_NOPTS_VALUE)
1205  pkt->pts += offset;
1206  if (pkt->dts != AV_NOPTS_VALUE)
1207  pkt->dts += offset;
1208  }
1209 
1210  /* This may be redundant, but it should not hurt. */
1211  if (pkt->dts != AV_NOPTS_VALUE &&
1212  pkt->pts != AV_NOPTS_VALUE &&
1213  pkt->pts > pkt->dts)
1214  presentation_delayed = 1;
1215 
1216  av_dlog(NULL,
1217  "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1218  presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1219  pkt->stream_index, pc, pkt->duration);
1220  /* Interpolate PTS and DTS if they are not present. We skip H264
1221  * currently because delay and has_b_frames are not reliably set. */
1222  if ((delay == 0 || (delay == 1 && pc)) &&
1223  onein_oneout) {
1224  if (presentation_delayed) {
1225  /* DTS = decompression timestamp */
1226  /* PTS = presentation timestamp */
1227  if (pkt->dts == AV_NOPTS_VALUE)
1228  pkt->dts = st->last_IP_pts;
1229  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1230  if (pkt->dts == AV_NOPTS_VALUE)
1231  pkt->dts = st->cur_dts;
1232 
1233  /* This is tricky: the dts must be incremented by the duration
1234  * of the frame we are displaying, i.e. the last I- or P-frame. */
1235  if (st->last_IP_duration == 0)
1236  st->last_IP_duration = pkt->duration;
1237  if (pkt->dts != AV_NOPTS_VALUE)
1238  st->cur_dts = pkt->dts + st->last_IP_duration;
1239  st->last_IP_duration = pkt->duration;
1240  st->last_IP_pts = pkt->pts;
1241  /* Cannot compute PTS if not present (we can compute it only
1242  * by knowing the future. */
1243  } else if (pkt->pts != AV_NOPTS_VALUE ||
1244  pkt->dts != AV_NOPTS_VALUE ||
1245  pkt->duration ) {
1246 
1247  /* presentation is not delayed : PTS and DTS are the same */
1248  if (pkt->pts == AV_NOPTS_VALUE)
1249  pkt->pts = pkt->dts;
1251  pkt->pts, pkt);
1252  if (pkt->pts == AV_NOPTS_VALUE)
1253  pkt->pts = st->cur_dts;
1254  pkt->dts = pkt->pts;
1255  if (pkt->pts != AV_NOPTS_VALUE)
1256  st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1257  }
1258  }
1259 
1260  if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1261  st->pts_buffer[0] = pkt->pts;
1262  for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1263  FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1264 
1265  pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1266  }
1267  // We skipped it above so we try here.
1268  if (!onein_oneout)
1269  // This should happen on the first packet
1270  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1271  if (pkt->dts > st->cur_dts)
1272  st->cur_dts = pkt->dts;
1273 
1274  av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1275  presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1276 
1277  /* update flags */
1278  if (is_intra_only(st->codec))
1279  pkt->flags |= AV_PKT_FLAG_KEY;
1280  if (pc)
1282 }
1283 
1284 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1285 {
1286  while (*pkt_buf) {
1287  AVPacketList *pktl = *pkt_buf;
1288  *pkt_buf = pktl->next;
1289  av_free_packet(&pktl->pkt);
1290  av_freep(&pktl);
1291  }
1292  *pkt_buf_end = NULL;
1293 }
1294 
1295 /**
1296  * Parse a packet, add all split parts to parse_queue.
1297  *
1298  * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1299  */
1300 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1301 {
1302  AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1303  AVStream *st = s->streams[stream_index];
1304  uint8_t *data = pkt ? pkt->data : NULL;
1305  int size = pkt ? pkt->size : 0;
1306  int ret = 0, got_output = 0;
1307 
1308  if (!pkt) {
1310  pkt = &flush_pkt;
1311  got_output = 1;
1312  } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1313  // preserve 0-size sync packets
1314  compute_pkt_fields(s, st, st->parser, pkt);
1315  }
1316 
1317  while (size > 0 || (pkt == &flush_pkt && got_output)) {
1318  int len;
1319 
1320  av_init_packet(&out_pkt);
1321  len = av_parser_parse2(st->parser, st->codec,
1322  &out_pkt.data, &out_pkt.size, data, size,
1323  pkt->pts, pkt->dts, pkt->pos);
1324 
1325  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1326  pkt->pos = -1;
1327  /* increment read pointer */
1328  data += len;
1329  size -= len;
1330 
1331  got_output = !!out_pkt.size;
1332 
1333  if (!out_pkt.size)
1334  continue;
1335 
1336  if (pkt->side_data) {
1337  out_pkt.side_data = pkt->side_data;
1338  out_pkt.side_data_elems = pkt->side_data_elems;
1339  pkt->side_data = NULL;
1340  pkt->side_data_elems = 0;
1341  }
1342 
1343  /* set the duration */
1344  out_pkt.duration = 0;
1345  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1346  if (st->codec->sample_rate > 0) {
1347  out_pkt.duration =
1349  (AVRational) { 1, st->codec->sample_rate },
1350  st->time_base,
1351  AV_ROUND_DOWN);
1352  }
1353  } else if (st->codec->time_base.num != 0 &&
1354  st->codec->time_base.den != 0) {
1355  out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1356  st->codec->time_base,
1357  st->time_base,
1358  AV_ROUND_DOWN);
1359  }
1360 
1361  out_pkt.stream_index = st->index;
1362  out_pkt.pts = st->parser->pts;
1363  out_pkt.dts = st->parser->dts;
1364  out_pkt.pos = st->parser->pos;
1365 
1367  out_pkt.pos = st->parser->frame_offset;
1368 
1369  if (st->parser->key_frame == 1 ||
1370  (st->parser->key_frame == -1 &&
1372  out_pkt.flags |= AV_PKT_FLAG_KEY;
1373 
1374  if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1375  out_pkt.flags |= AV_PKT_FLAG_KEY;
1376 
1377  compute_pkt_fields(s, st, st->parser, &out_pkt);
1378 
1379  if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1380  out_pkt.buf = pkt->buf;
1381  pkt->buf = NULL;
1382 #if FF_API_DESTRUCT_PACKET
1384  out_pkt.destruct = pkt->destruct;
1385  pkt->destruct = NULL;
1387 #endif
1388  }
1389  if ((ret = av_dup_packet(&out_pkt)) < 0)
1390  goto fail;
1391 
1392  if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1393  av_free_packet(&out_pkt);
1394  ret = AVERROR(ENOMEM);
1395  goto fail;
1396  }
1397  }
1398 
1399  /* end of the stream => close and free the parser */
1400  if (pkt == &flush_pkt) {
1401  av_parser_close(st->parser);
1402  st->parser = NULL;
1403  }
1404 
1405 fail:
1407  return ret;
1408 }
1409 
1410 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1411  AVPacketList **pkt_buffer_end,
1412  AVPacket *pkt)
1413 {
1414  AVPacketList *pktl;
1415  av_assert0(*pkt_buffer);
1416  pktl = *pkt_buffer;
1417  *pkt = pktl->pkt;
1418  *pkt_buffer = pktl->next;
1419  if (!pktl->next)
1420  *pkt_buffer_end = NULL;
1421  av_freep(&pktl);
1422  return 0;
1423 }
1424 
1426 {
1427  int ret = 0, i, got_packet = 0;
1428 
1429  av_init_packet(pkt);
1430 
1431  while (!got_packet && !s->parse_queue) {
1432  AVStream *st;
1433  AVPacket cur_pkt;
1434 
1435  /* read next packet */
1436  ret = ff_read_packet(s, &cur_pkt);
1437  if (ret < 0) {
1438  if (ret == AVERROR(EAGAIN))
1439  return ret;
1440  /* flush the parsers */
1441  for (i = 0; i < s->nb_streams; i++) {
1442  st = s->streams[i];
1443  if (st->parser && st->need_parsing)
1444  parse_packet(s, NULL, st->index);
1445  }
1446  /* all remaining packets are now in parse_queue =>
1447  * really terminate parsing */
1448  break;
1449  }
1450  ret = 0;
1451  st = s->streams[cur_pkt.stream_index];
1452 
1453  if (cur_pkt.pts != AV_NOPTS_VALUE &&
1454  cur_pkt.dts != AV_NOPTS_VALUE &&
1455  cur_pkt.pts < cur_pkt.dts) {
1457  "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1458  cur_pkt.stream_index,
1459  av_ts2str(cur_pkt.pts),
1460  av_ts2str(cur_pkt.dts),
1461  cur_pkt.size);
1462  }
1463  if (s->debug & FF_FDEBUG_TS)
1464  av_log(s, AV_LOG_DEBUG,
1465  "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1466  cur_pkt.stream_index,
1467  av_ts2str(cur_pkt.pts),
1468  av_ts2str(cur_pkt.dts),
1469  cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1470 
1471  if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1472  st->parser = av_parser_init(st->codec->codec_id);
1473  if (!st->parser) {
1474  av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1475  "%s, packets or times may be invalid.\n",
1477  /* no parser available: just output the raw packets */
1479  } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1481  else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1482  st->parser->flags |= PARSER_FLAG_ONCE;
1483  else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1485  }
1486 
1487  if (!st->need_parsing || !st->parser) {
1488  /* no parsing needed: we just output the packet as is */
1489  *pkt = cur_pkt;
1490  compute_pkt_fields(s, st, NULL, pkt);
1491  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1492  (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1493  ff_reduce_index(s, st->index);
1494  av_add_index_entry(st, pkt->pos, pkt->dts,
1495  0, 0, AVINDEX_KEYFRAME);
1496  }
1497  got_packet = 1;
1498  } else if (st->discard < AVDISCARD_ALL) {
1499  if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1500  return ret;
1501  } else {
1502  /* free packet */
1503  av_free_packet(&cur_pkt);
1504  }
1505  if (pkt->flags & AV_PKT_FLAG_KEY)
1506  st->skip_to_keyframe = 0;
1507  if (st->skip_to_keyframe) {
1508  av_free_packet(&cur_pkt);
1509  if (got_packet) {
1510  *pkt = cur_pkt;
1511  }
1512  got_packet = 0;
1513  }
1514  }
1515 
1516  if (!got_packet && s->parse_queue)
1518 
1519  if (ret >= 0) {
1520  AVStream *st = s->streams[pkt->stream_index];
1521  if (st->skip_samples) {
1523  if (p) {
1524  AV_WL32(p, st->skip_samples);
1525  av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1526  }
1527  st->skip_samples = 0;
1528  }
1529  }
1530 
1531  if (ret >= 0 && !(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1533 
1534  if (s->debug & FF_FDEBUG_TS)
1535  av_log(s, AV_LOG_DEBUG,
1536  "read_frame_internal stream=%d, pts=%s, dts=%s, "
1537  "size=%d, duration=%d, flags=%d\n",
1538  pkt->stream_index,
1539  av_ts2str(pkt->pts),
1540  av_ts2str(pkt->dts),
1541  pkt->size, pkt->duration, pkt->flags);
1542 
1543  return ret;
1544 }
1545 
1547 {
1548  const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1549  int eof = 0;
1550  int ret;
1551  AVStream *st;
1552 
1553  if (!genpts) {
1554  ret = s->packet_buffer
1556  &s->packet_buffer_end, pkt)
1557  : read_frame_internal(s, pkt);
1558  if (ret < 0)
1559  return ret;
1560  goto return_packet;
1561  }
1562 
1563  for (;;) {
1564  AVPacketList *pktl = s->packet_buffer;
1565 
1566  if (pktl) {
1567  AVPacket *next_pkt = &pktl->pkt;
1568 
1569  if (next_pkt->dts != AV_NOPTS_VALUE) {
1570  int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1571  // last dts seen for this stream. if any of packets following
1572  // current one had no dts, we will set this to AV_NOPTS_VALUE.
1573  int64_t last_dts = next_pkt->dts;
1574  while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1575  if (pktl->pkt.stream_index == next_pkt->stream_index &&
1576  (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1577  if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1578  // not B-frame
1579  next_pkt->pts = pktl->pkt.dts;
1580  }
1581  if (last_dts != AV_NOPTS_VALUE) {
1582  // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1583  last_dts = pktl->pkt.dts;
1584  }
1585  }
1586  pktl = pktl->next;
1587  }
1588  if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1589  // Fixing the last reference frame had none pts issue (For MXF etc).
1590  // We only do this when
1591  // 1. eof.
1592  // 2. we are not able to resolve a pts value for current packet.
1593  // 3. the packets for this stream at the end of the files had valid dts.
1594  next_pkt->pts = last_dts + next_pkt->duration;
1595  }
1596  pktl = s->packet_buffer;
1597  }
1598 
1599  /* read packet from packet buffer, if there is data */
1600  if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1601  next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1603  &s->packet_buffer_end, pkt);
1604  goto return_packet;
1605  }
1606  }
1607 
1608  ret = read_frame_internal(s, pkt);
1609  if (ret < 0) {
1610  if (pktl && ret != AVERROR(EAGAIN)) {
1611  eof = 1;
1612  continue;
1613  } else
1614  return ret;
1615  }
1616 
1618  &s->packet_buffer_end)) < 0)
1619  return AVERROR(ENOMEM);
1620  }
1621 
1622 return_packet:
1623 
1624  st = s->streams[pkt->stream_index];
1625  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1626  ff_reduce_index(s, st->index);
1627  av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1628  }
1629 
1630  if (is_relative(pkt->dts))
1631  pkt->dts -= RELATIVE_TS_BASE;
1632  if (is_relative(pkt->pts))
1633  pkt->pts -= RELATIVE_TS_BASE;
1634 
1635  return ret;
1636 }
1637 
1638 /* XXX: suppress the packet queue */
1640 {
1644 
1646 }
1647 
1648 /*******************************************************/
1649 /* seek support */
1650 
1652 {
1653  int first_audio_index = -1;
1654  int i;
1655  AVStream *st;
1656 
1657  if (s->nb_streams <= 0)
1658  return -1;
1659  for (i = 0; i < s->nb_streams; i++) {
1660  st = s->streams[i];
1661  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1663  return i;
1664  }
1665  if (first_audio_index < 0 &&
1667  first_audio_index = i;
1668  }
1669  return first_audio_index >= 0 ? first_audio_index : 0;
1670 }
1671 
1672 /** Flush the frame reader. */
1674 {
1675  AVStream *st;
1676  int i, j;
1677 
1678  flush_packet_queue(s);
1679 
1680  /* Reset read state for each stream. */
1681  for (i = 0; i < s->nb_streams; i++) {
1682  st = s->streams[i];
1683 
1684  if (st->parser) {
1685  av_parser_close(st->parser);
1686  st->parser = NULL;
1687  }
1690  if (st->first_dts == AV_NOPTS_VALUE)
1691  st->cur_dts = RELATIVE_TS_BASE;
1692  else
1693  /* We set the current DTS to an unspecified origin. */
1694  st->cur_dts = AV_NOPTS_VALUE;
1695 
1697 
1698  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1699  st->pts_buffer[j] = AV_NOPTS_VALUE;
1700  }
1701 }
1702 
1703 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1704 {
1705  int i;
1706 
1707  for (i = 0; i < s->nb_streams; i++) {
1708  AVStream *st = s->streams[i];
1709 
1710  st->cur_dts =
1711  av_rescale(timestamp,
1712  st->time_base.den * (int64_t) ref_st->time_base.num,
1713  st->time_base.num * (int64_t) ref_st->time_base.den);
1714  }
1715 }
1716 
1717 void ff_reduce_index(AVFormatContext *s, int stream_index)
1718 {
1719  AVStream *st = s->streams[stream_index];
1720  unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1721 
1722  if ((unsigned) st->nb_index_entries >= max_entries) {
1723  int i;
1724  for (i = 0; 2 * i < st->nb_index_entries; i++)
1725  st->index_entries[i] = st->index_entries[2 * i];
1726  st->nb_index_entries = i;
1727  }
1728 }
1729 
1730 int ff_add_index_entry(AVIndexEntry **index_entries,
1731  int *nb_index_entries,
1732  unsigned int *index_entries_allocated_size,
1733  int64_t pos, int64_t timestamp,
1734  int size, int distance, int flags)
1735 {
1736  AVIndexEntry *entries, *ie;
1737  int index;
1738 
1739  if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1740  return -1;
1741 
1742  if (timestamp == AV_NOPTS_VALUE)
1743  return AVERROR(EINVAL);
1744 
1745  if (size < 0 || size > 0x3FFFFFFF)
1746  return AVERROR(EINVAL);
1747 
1748  if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1749  timestamp -= RELATIVE_TS_BASE;
1750 
1751  entries = av_fast_realloc(*index_entries,
1752  index_entries_allocated_size,
1753  (*nb_index_entries + 1) *
1754  sizeof(AVIndexEntry));
1755  if (!entries)
1756  return -1;
1757 
1758  *index_entries = entries;
1759 
1760  index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1761  timestamp, AVSEEK_FLAG_ANY);
1762 
1763  if (index < 0) {
1764  index = (*nb_index_entries)++;
1765  ie = &entries[index];
1766  av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1767  } else {
1768  ie = &entries[index];
1769  if (ie->timestamp != timestamp) {
1770  if (ie->timestamp <= timestamp)
1771  return -1;
1772  memmove(entries + index + 1, entries + index,
1773  sizeof(AVIndexEntry) * (*nb_index_entries - index));
1774  (*nb_index_entries)++;
1775  } else if (ie->pos == pos && distance < ie->min_distance)
1776  // do not reduce the distance
1777  distance = ie->min_distance;
1778  }
1779 
1780  ie->pos = pos;
1781  ie->timestamp = timestamp;
1782  ie->min_distance = distance;
1783  ie->size = size;
1784  ie->flags = flags;
1785 
1786  return index;
1787 }
1788 
1789 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1790  int size, int distance, int flags)
1791 {
1792  timestamp = wrap_timestamp(st, timestamp);
1794  &st->index_entries_allocated_size, pos,
1795  timestamp, size, distance, flags);
1796 }
1797 
1798 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1799  int64_t wanted_timestamp, int flags)
1800 {
1801  int a, b, m;
1802  int64_t timestamp;
1803 
1804  a = -1;
1805  b = nb_entries;
1806 
1807  // Optimize appending index entries at the end.
1808  if (b && entries[b - 1].timestamp < wanted_timestamp)
1809  a = b - 1;
1810 
1811  while (b - a > 1) {
1812  m = (a + b) >> 1;
1813  timestamp = entries[m].timestamp;
1814  if (timestamp >= wanted_timestamp)
1815  b = m;
1816  if (timestamp <= wanted_timestamp)
1817  a = m;
1818  }
1819  m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1820 
1821  if (!(flags & AVSEEK_FLAG_ANY))
1822  while (m >= 0 && m < nb_entries &&
1823  !(entries[m].flags & AVINDEX_KEYFRAME))
1824  m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1825 
1826  if (m == nb_entries)
1827  return -1;
1828  return m;
1829 }
1830 
1831 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1832 {
1834  wanted_timestamp, flags);
1835 }
1836 
1837 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1838  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1839 {
1840  int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1841  if (stream_index >= 0)
1842  ts = wrap_timestamp(s->streams[stream_index], ts);
1843  return ts;
1844 }
1845 
1846 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1847  int64_t target_ts, int flags)
1848 {
1849  AVInputFormat *avif = s->iformat;
1850  int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1851  int64_t ts_min, ts_max, ts;
1852  int index;
1853  int64_t ret;
1854  AVStream *st;
1855 
1856  if (stream_index < 0)
1857  return -1;
1858 
1859  av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1860 
1861  ts_max =
1862  ts_min = AV_NOPTS_VALUE;
1863  pos_limit = -1; // GCC falsely says it may be uninitialized.
1864 
1865  st = s->streams[stream_index];
1866  if (st->index_entries) {
1867  AVIndexEntry *e;
1868 
1869  /* FIXME: Whole function must be checked for non-keyframe entries in
1870  * index case, especially read_timestamp(). */
1871  index = av_index_search_timestamp(st, target_ts,
1872  flags | AVSEEK_FLAG_BACKWARD);
1873  index = FFMAX(index, 0);
1874  e = &st->index_entries[index];
1875 
1876  if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1877  pos_min = e->pos;
1878  ts_min = e->timestamp;
1879  av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1880  pos_min, av_ts2str(ts_min));
1881  } else {
1882  av_assert1(index == 0);
1883  }
1884 
1885  index = av_index_search_timestamp(st, target_ts,
1886  flags & ~AVSEEK_FLAG_BACKWARD);
1887  av_assert0(index < st->nb_index_entries);
1888  if (index >= 0) {
1889  e = &st->index_entries[index];
1890  av_assert1(e->timestamp >= target_ts);
1891  pos_max = e->pos;
1892  ts_max = e->timestamp;
1893  pos_limit = pos_max - e->min_distance;
1894  av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1895  " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1896  }
1897  }
1898 
1899  pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1900  ts_min, ts_max, flags, &ts, avif->read_timestamp);
1901  if (pos < 0)
1902  return -1;
1903 
1904  /* do the seek */
1905  if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1906  return ret;
1907 
1909  ff_update_cur_dts(s, st, ts);
1910 
1911  return 0;
1912 }
1913 
1914 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1915  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1916 {
1917  int64_t step = 1024;
1918  int64_t limit, ts_max;
1919  int64_t filesize = avio_size(s->pb);
1920  int64_t pos_max = filesize - 1;
1921  do {
1922  limit = pos_max;
1923  pos_max = FFMAX(0, (pos_max) - step);
1924  ts_max = ff_read_timestamp(s, stream_index,
1925  &pos_max, limit, read_timestamp);
1926  step += step;
1927  } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1928  if (ts_max == AV_NOPTS_VALUE)
1929  return -1;
1930 
1931  for (;;) {
1932  int64_t tmp_pos = pos_max + 1;
1933  int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1934  &tmp_pos, INT64_MAX, read_timestamp);
1935  if (tmp_ts == AV_NOPTS_VALUE)
1936  break;
1937  av_assert0(tmp_pos > pos_max);
1938  ts_max = tmp_ts;
1939  pos_max = tmp_pos;
1940  if (tmp_pos >= filesize)
1941  break;
1942  }
1943 
1944  if (ts)
1945  *ts = ts_max;
1946  if (pos)
1947  *pos = pos_max;
1948 
1949  return 0;
1950 }
1951 
1952 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1953  int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1954  int64_t ts_min, int64_t ts_max,
1955  int flags, int64_t *ts_ret,
1956  int64_t (*read_timestamp)(struct AVFormatContext *, int,
1957  int64_t *, int64_t))
1958 {
1959  int64_t pos, ts;
1960  int64_t start_pos;
1961  int no_change;
1962  int ret;
1963 
1964  av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1965 
1966  if (ts_min == AV_NOPTS_VALUE) {
1967  pos_min = s->data_offset;
1968  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1969  if (ts_min == AV_NOPTS_VALUE)
1970  return -1;
1971  }
1972 
1973  if (ts_min >= target_ts) {
1974  *ts_ret = ts_min;
1975  return pos_min;
1976  }
1977 
1978  if (ts_max == AV_NOPTS_VALUE) {
1979  if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1980  return ret;
1981  pos_limit = pos_max;
1982  }
1983 
1984  if (ts_max <= target_ts) {
1985  *ts_ret = ts_max;
1986  return pos_max;
1987  }
1988 
1989  if (ts_min > ts_max)
1990  return -1;
1991  else if (ts_min == ts_max)
1992  pos_limit = pos_min;
1993 
1994  no_change = 0;
1995  while (pos_min < pos_limit) {
1996  av_dlog(s,
1997  "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1998  pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1999  assert(pos_limit <= pos_max);
2000 
2001  if (no_change == 0) {
2002  int64_t approximate_keyframe_distance = pos_max - pos_limit;
2003  // interpolate position (better than dichotomy)
2004  pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2005  ts_max - ts_min) +
2006  pos_min - approximate_keyframe_distance;
2007  } else if (no_change == 1) {
2008  // bisection if interpolation did not change min / max pos last time
2009  pos = (pos_min + pos_limit) >> 1;
2010  } else {
2011  /* linear search if bisection failed, can only happen if there
2012  * are very few or no keyframes between min/max */
2013  pos = pos_min;
2014  }
2015  if (pos <= pos_min)
2016  pos = pos_min + 1;
2017  else if (pos > pos_limit)
2018  pos = pos_limit;
2019  start_pos = pos;
2020 
2021  // May pass pos_limit instead of -1.
2022  ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2023  if (pos == pos_max)
2024  no_change++;
2025  else
2026  no_change = 0;
2027  av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2028  " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2029  pos_min, pos, pos_max,
2030  av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2031  pos_limit, start_pos, no_change);
2032  if (ts == AV_NOPTS_VALUE) {
2033  av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2034  return -1;
2035  }
2036  assert(ts != AV_NOPTS_VALUE);
2037  if (target_ts <= ts) {
2038  pos_limit = start_pos - 1;
2039  pos_max = pos;
2040  ts_max = ts;
2041  }
2042  if (target_ts >= ts) {
2043  pos_min = pos;
2044  ts_min = ts;
2045  }
2046  }
2047 
2048  pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2049  ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2050 #if 0
2051  pos_min = pos;
2052  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2053  pos_min++;
2054  ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2055  av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2056  pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2057 #endif
2058  *ts_ret = ts;
2059  return pos;
2060 }
2061 
2062 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2063  int64_t pos, int flags)
2064 {
2065  int64_t pos_min, pos_max;
2066 
2067  pos_min = s->data_offset;
2068  pos_max = avio_size(s->pb) - 1;
2069 
2070  if (pos < pos_min)
2071  pos = pos_min;
2072  else if (pos > pos_max)
2073  pos = pos_max;
2074 
2075  avio_seek(s->pb, pos, SEEK_SET);
2076 
2077  s->io_repositioned = 1;
2078 
2079  return 0;
2080 }
2081 
2082 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2083  int64_t timestamp, int flags)
2084 {
2085  int index;
2086  int64_t ret;
2087  AVStream *st;
2088  AVIndexEntry *ie;
2089 
2090  st = s->streams[stream_index];
2091 
2092  index = av_index_search_timestamp(st, timestamp, flags);
2093 
2094  if (index < 0 && st->nb_index_entries &&
2095  timestamp < st->index_entries[0].timestamp)
2096  return -1;
2097 
2098  if (index < 0 || index == st->nb_index_entries - 1) {
2099  AVPacket pkt;
2100  int nonkey = 0;
2101 
2102  if (st->nb_index_entries) {
2104  ie = &st->index_entries[st->nb_index_entries - 1];
2105  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2106  return ret;
2107  ff_update_cur_dts(s, st, ie->timestamp);
2108  } else {
2109  if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2110  return ret;
2111  }
2112  for (;;) {
2113  int read_status;
2114  do {
2115  read_status = av_read_frame(s, &pkt);
2116  } while (read_status == AVERROR(EAGAIN));
2117  if (read_status < 0)
2118  break;
2119  av_free_packet(&pkt);
2120  if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2121  if (pkt.flags & AV_PKT_FLAG_KEY)
2122  break;
2123  if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2124  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);
2125  break;
2126  }
2127  }
2128  }
2129  index = av_index_search_timestamp(st, timestamp, flags);
2130  }
2131  if (index < 0)
2132  return -1;
2133 
2135  if (s->iformat->read_seek)
2136  if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2137  return 0;
2138  ie = &st->index_entries[index];
2139  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2140  return ret;
2141  ff_update_cur_dts(s, st, ie->timestamp);
2142 
2143  return 0;
2144 }
2145 
2146 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2147  int64_t timestamp, int flags)
2148 {
2149  int ret;
2150  AVStream *st;
2151 
2152  if (flags & AVSEEK_FLAG_BYTE) {
2153  if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2154  return -1;
2156  return seek_frame_byte(s, stream_index, timestamp, flags);
2157  }
2158 
2159  if (stream_index < 0) {
2160  stream_index = av_find_default_stream_index(s);
2161  if (stream_index < 0)
2162  return -1;
2163 
2164  st = s->streams[stream_index];
2165  /* timestamp for default must be expressed in AV_TIME_BASE units */
2166  timestamp = av_rescale(timestamp, st->time_base.den,
2167  AV_TIME_BASE * (int64_t) st->time_base.num);
2168  }
2169 
2170  /* first, we try the format specific seek */
2171  if (s->iformat->read_seek) {
2173  ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2174  } else
2175  ret = -1;
2176  if (ret >= 0)
2177  return 0;
2178 
2179  if (s->iformat->read_timestamp &&
2180  !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2182  return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2183  } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2185  return seek_frame_generic(s, stream_index, timestamp, flags);
2186  } else
2187  return -1;
2188 }
2189 
2190 int av_seek_frame(AVFormatContext *s, int stream_index,
2191  int64_t timestamp, int flags)
2192 {
2193  int ret;
2194 
2195  if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2196  int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2197  if ((flags & AVSEEK_FLAG_BACKWARD))
2198  max_ts = timestamp;
2199  else
2200  min_ts = timestamp;
2201  return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2202  flags & ~AVSEEK_FLAG_BACKWARD);
2203  }
2204 
2205  ret = seek_frame_internal(s, stream_index, timestamp, flags);
2206 
2207  if (ret >= 0)
2209 
2210  return ret;
2211 }
2212 
2213 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2214  int64_t ts, int64_t max_ts, int flags)
2215 {
2216  if (min_ts > ts || max_ts < ts)
2217  return -1;
2218  if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2219  return AVERROR(EINVAL);
2220 
2221  if (s->seek2any>0)
2222  flags |= AVSEEK_FLAG_ANY;
2223  flags &= ~AVSEEK_FLAG_BACKWARD;
2224 
2225  if (s->iformat->read_seek2) {
2226  int ret;
2228 
2229  if (stream_index == -1 && s->nb_streams == 1) {
2230  AVRational time_base = s->streams[0]->time_base;
2231  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2232  min_ts = av_rescale_rnd(min_ts, time_base.den,
2233  time_base.num * (int64_t)AV_TIME_BASE,
2235  max_ts = av_rescale_rnd(max_ts, time_base.den,
2236  time_base.num * (int64_t)AV_TIME_BASE,
2238  }
2239 
2240  ret = s->iformat->read_seek2(s, stream_index, min_ts,
2241  ts, max_ts, flags);
2242 
2243  if (ret >= 0)
2245  return ret;
2246  }
2247 
2248  if (s->iformat->read_timestamp) {
2249  // try to seek via read_timestamp()
2250  }
2251 
2252  // Fall back on old API if new is not implemented but old is.
2253  // Note the old API has somewhat different semantics.
2254  if (s->iformat->read_seek || 1) {
2255  int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2256  int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2257  if (ret<0 && ts != min_ts && max_ts != ts) {
2258  ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2259  if (ret >= 0)
2260  ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2261  }
2262  return ret;
2263  }
2264 
2265  // try some generic seek like seek_frame_generic() but with new ts semantics
2266  return -1; //unreachable
2267 }
2268 
2269 /*******************************************************/
2270 
2271 /**
2272  * Return TRUE if the stream has accurate duration in any stream.
2273  *
2274  * @return TRUE if the stream has accurate duration for at least one component.
2275  */
2277 {
2278  int i;
2279  AVStream *st;
2280 
2281  for (i = 0; i < ic->nb_streams; i++) {
2282  st = ic->streams[i];
2283  if (st->duration != AV_NOPTS_VALUE)
2284  return 1;
2285  }
2286  if (ic->duration != AV_NOPTS_VALUE)
2287  return 1;
2288  return 0;
2289 }
2290 
2291 /**
2292  * Estimate the stream timings from the one of each components.
2293  *
2294  * Also computes the global bitrate if possible.
2295  */
2297 {
2298  int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2299  int64_t duration, duration1, filesize;
2300  int i;
2301  AVStream *st;
2302  AVProgram *p;
2303 
2304  start_time = INT64_MAX;
2305  start_time_text = INT64_MAX;
2306  end_time = INT64_MIN;
2307  duration = INT64_MIN;
2308  for (i = 0; i < ic->nb_streams; i++) {
2309  st = ic->streams[i];
2310  if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2311  start_time1 = av_rescale_q(st->start_time, st->time_base,
2312  AV_TIME_BASE_Q);
2314  if (start_time1 < start_time_text)
2315  start_time_text = start_time1;
2316  } else
2317  start_time = FFMIN(start_time, start_time1);
2318  end_time1 = AV_NOPTS_VALUE;
2319  if (st->duration != AV_NOPTS_VALUE) {
2320  end_time1 = start_time1 +
2321  av_rescale_q(st->duration, st->time_base,
2322  AV_TIME_BASE_Q);
2323  end_time = FFMAX(end_time, end_time1);
2324  }
2325  for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2326  if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2327  p->start_time = start_time1;
2328  if (p->end_time < end_time1)
2329  p->end_time = end_time1;
2330  }
2331  }
2332  if (st->duration != AV_NOPTS_VALUE) {
2333  duration1 = av_rescale_q(st->duration, st->time_base,
2334  AV_TIME_BASE_Q);
2335  duration = FFMAX(duration, duration1);
2336  }
2337  }
2338  if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2339  start_time = start_time_text;
2340  else if (start_time > start_time_text)
2341  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2342 
2343  if (start_time != INT64_MAX) {
2344  ic->start_time = start_time;
2345  if (end_time != INT64_MIN) {
2346  if (ic->nb_programs) {
2347  for (i = 0; i < ic->nb_programs; i++) {
2348  p = ic->programs[i];
2349  if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2350  duration = FFMAX(duration, p->end_time - p->start_time);
2351  }
2352  } else
2353  duration = FFMAX(duration, end_time - start_time);
2354  }
2355  }
2356  if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2357  ic->duration = duration;
2358  }
2359  if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2360  /* compute the bitrate */
2361  double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2362  (double) ic->duration;
2363  if (bitrate >= 0 && bitrate <= INT_MAX)
2364  ic->bit_rate = bitrate;
2365  }
2366 }
2367 
2369 {
2370  int i;
2371  AVStream *st;
2372 
2374  for (i = 0; i < ic->nb_streams; i++) {
2375  st = ic->streams[i];
2376  if (st->start_time == AV_NOPTS_VALUE) {
2377  if (ic->start_time != AV_NOPTS_VALUE)
2379  st->time_base);
2380  if (ic->duration != AV_NOPTS_VALUE)
2382  st->time_base);
2383  }
2384  }
2385 }
2386 
2388 {
2389  int64_t filesize, duration;
2390  int i, show_warning = 0;
2391  AVStream *st;
2392 
2393  /* if bit_rate is already set, we believe it */
2394  if (ic->bit_rate <= 0) {
2395  int bit_rate = 0;
2396  for (i = 0; i < ic->nb_streams; i++) {
2397  st = ic->streams[i];
2398  if (st->codec->bit_rate > 0) {
2399  if (INT_MAX - st->codec->bit_rate < bit_rate) {
2400  bit_rate = 0;
2401  break;
2402  }
2403  bit_rate += st->codec->bit_rate;
2404  }
2405  }
2406  ic->bit_rate = bit_rate;
2407  }
2408 
2409  /* if duration is already set, we believe it */
2410  if (ic->duration == AV_NOPTS_VALUE &&
2411  ic->bit_rate != 0) {
2412  filesize = ic->pb ? avio_size(ic->pb) : 0;
2413  if (filesize > 0) {
2414  for (i = 0; i < ic->nb_streams; i++) {
2415  st = ic->streams[i];
2416  if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2417  && st->duration == AV_NOPTS_VALUE) {
2418  duration = av_rescale(8 * filesize, st->time_base.den,
2419  ic->bit_rate *
2420  (int64_t) st->time_base.num);
2421  st->duration = duration;
2422  show_warning = 1;
2423  }
2424  }
2425  }
2426  }
2427  if (show_warning)
2428  av_log(ic, AV_LOG_WARNING,
2429  "Estimating duration from bitrate, this may be inaccurate\n");
2430 }
2431 
2432 #define DURATION_MAX_READ_SIZE 250000LL
2433 #define DURATION_MAX_RETRY 4
2434 
2435 /* only usable for MPEG-PS streams */
2436 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2437 {
2438  AVPacket pkt1, *pkt = &pkt1;
2439  AVStream *st;
2440  int read_size, i, ret;
2441  int64_t end_time;
2442  int64_t filesize, offset, duration;
2443  int retry = 0;
2444 
2445  /* flush packet queue */
2446  flush_packet_queue(ic);
2447 
2448  for (i = 0; i < ic->nb_streams; i++) {
2449  st = ic->streams[i];
2450  if (st->start_time == AV_NOPTS_VALUE &&
2451  st->first_dts == AV_NOPTS_VALUE &&
2454  "start time is not set in estimate_timings_from_pts\n");
2455 
2456  if (st->parser) {
2457  av_parser_close(st->parser);
2458  st->parser = NULL;
2459  }
2460  }
2461 
2462  /* estimate the end time (duration) */
2463  /* XXX: may need to support wrapping */
2464  filesize = ic->pb ? avio_size(ic->pb) : 0;
2465  end_time = AV_NOPTS_VALUE;
2466  do {
2467  offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2468  if (offset < 0)
2469  offset = 0;
2470 
2471  avio_seek(ic->pb, offset, SEEK_SET);
2472  read_size = 0;
2473  for (;;) {
2474  if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2475  break;
2476 
2477  do {
2478  ret = ff_read_packet(ic, pkt);
2479  } while (ret == AVERROR(EAGAIN));
2480  if (ret != 0)
2481  break;
2482  read_size += pkt->size;
2483  st = ic->streams[pkt->stream_index];
2484  if (pkt->pts != AV_NOPTS_VALUE &&
2485  (st->start_time != AV_NOPTS_VALUE ||
2486  st->first_dts != AV_NOPTS_VALUE)) {
2487  duration = end_time = pkt->pts;
2488  if (st->start_time != AV_NOPTS_VALUE)
2489  duration -= st->start_time;
2490  else
2491  duration -= st->first_dts;
2492  if (duration > 0) {
2493  if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2494  (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2495  st->duration = duration;
2496  st->info->last_duration = duration;
2497  }
2498  }
2499  av_free_packet(pkt);
2500  }
2501  } while (end_time == AV_NOPTS_VALUE &&
2502  filesize > (DURATION_MAX_READ_SIZE << retry) &&
2503  ++retry <= DURATION_MAX_RETRY);
2504 
2506 
2507  avio_seek(ic->pb, old_offset, SEEK_SET);
2508  for (i = 0; i < ic->nb_streams; i++) {
2509  int j;
2510 
2511  st = ic->streams[i];
2512  st->cur_dts = st->first_dts;
2515  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2516  st->pts_buffer[j] = AV_NOPTS_VALUE;
2517  }
2518 }
2519 
2520 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2521 {
2522  int64_t file_size;
2523 
2524  /* get the file size, if possible */
2525  if (ic->iformat->flags & AVFMT_NOFILE) {
2526  file_size = 0;
2527  } else {
2528  file_size = avio_size(ic->pb);
2529  file_size = FFMAX(0, file_size);
2530  }
2531 
2532  if ((!strcmp(ic->iformat->name, "mpeg") ||
2533  !strcmp(ic->iformat->name, "mpegts")) &&
2534  file_size && ic->pb->seekable) {
2535  /* get accurate estimate from the PTSes */
2536  estimate_timings_from_pts(ic, old_offset);
2538  } else if (has_duration(ic)) {
2539  /* at least one component has timings - we use them for all
2540  * the components */
2543  } else {
2544  /* less precise: use bitrate info */
2547  }
2549 
2550  {
2551  int i;
2552  AVStream av_unused *st;
2553  for (i = 0; i < ic->nb_streams; i++) {
2554  st = ic->streams[i];
2555  av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2556  (double) st->start_time / AV_TIME_BASE,
2557  (double) st->duration / AV_TIME_BASE);
2558  }
2559  av_dlog(ic,
2560  "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2561  (double) ic->start_time / AV_TIME_BASE,
2562  (double) ic->duration / AV_TIME_BASE,
2563  ic->bit_rate / 1000);
2564  }
2565 }
2566 
2567 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2568 {
2569  AVCodecContext *avctx = st->codec;
2570 
2571 #define FAIL(errmsg) do { \
2572  if (errmsg_ptr) \
2573  *errmsg_ptr = errmsg; \
2574  return 0; \
2575  } while (0)
2576 
2577  switch (avctx->codec_type) {
2578  case AVMEDIA_TYPE_AUDIO:
2579  if (!avctx->frame_size && determinable_frame_size(avctx))
2580  FAIL("unspecified frame size");
2581  if (st->info->found_decoder >= 0 &&
2582  avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2583  FAIL("unspecified sample format");
2584  if (!avctx->sample_rate)
2585  FAIL("unspecified sample rate");
2586  if (!avctx->channels)
2587  FAIL("unspecified number of channels");
2588  if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2589  FAIL("no decodable DTS frames");
2590  break;
2591  case AVMEDIA_TYPE_VIDEO:
2592  if (!avctx->width)
2593  FAIL("unspecified size");
2594  if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2595  FAIL("unspecified pixel format");
2598  FAIL("no frame in rv30/40 and no sar");
2599  break;
2600  case AVMEDIA_TYPE_SUBTITLE:
2601  if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2602  FAIL("unspecified size");
2603  break;
2604  case AVMEDIA_TYPE_DATA:
2605  if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2606  }
2607 
2608  if (avctx->codec_id == AV_CODEC_ID_NONE)
2609  FAIL("unknown codec");
2610  return 1;
2611 }
2612 
2613 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2616 {
2617  const AVCodec *codec;
2618  int got_picture = 1, ret = 0;
2620  AVSubtitle subtitle;
2621  AVPacket pkt = *avpkt;
2622 
2623  if (!frame)
2624  return AVERROR(ENOMEM);
2625 
2626  if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2627  AVDictionary *thread_opt = NULL;
2628 
2629  codec = find_decoder(s, st, st->codec->codec_id);
2630 
2631  if (!codec) {
2632  st->info->found_decoder = -1;
2633  ret = -1;
2634  goto fail;
2635  }
2636 
2637  /* Force thread count to 1 since the H.264 decoder will not extract
2638  * SPS and PPS to extradata during multi-threaded decoding. */
2639  av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2640  ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2641  if (!options)
2642  av_dict_free(&thread_opt);
2643  if (ret < 0) {
2644  st->info->found_decoder = -1;
2645  goto fail;
2646  }
2647  st->info->found_decoder = 1;
2648  } else if (!st->info->found_decoder)
2649  st->info->found_decoder = 1;
2650 
2651  if (st->info->found_decoder < 0) {
2652  ret = -1;
2653  goto fail;
2654  }
2655 
2656  while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2657  ret >= 0 &&
2659  (!st->codec_info_nb_frames &&
2661  got_picture = 0;
2662  switch (st->codec->codec_type) {
2663  case AVMEDIA_TYPE_VIDEO:
2664  ret = avcodec_decode_video2(st->codec, frame,
2665  &got_picture, &pkt);
2666  break;
2667  case AVMEDIA_TYPE_AUDIO:
2668  ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2669  break;
2670  case AVMEDIA_TYPE_SUBTITLE:
2671  ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2672  &got_picture, &pkt);
2673  ret = pkt.size;
2674  break;
2675  default:
2676  break;
2677  }
2678  if (ret >= 0) {
2679  if (got_picture)
2680  st->nb_decoded_frames++;
2681  pkt.data += ret;
2682  pkt.size -= ret;
2683  ret = got_picture;
2684  }
2685  }
2686 
2687  if (!pkt.data && !got_picture)
2688  ret = -1;
2689 
2690 fail:
2691  av_frame_free(&frame);
2692  return ret;
2693 }
2694 
2695 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2696 {
2697  while (tags->id != AV_CODEC_ID_NONE) {
2698  if (tags->id == id)
2699  return tags->tag;
2700  tags++;
2701  }
2702  return 0;
2703 }
2704 
2705 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2706 {
2707  int i;
2708  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2709  if (tag == tags[i].tag)
2710  return tags[i].id;
2711  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2712  if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2713  return tags[i].id;
2714  return AV_CODEC_ID_NONE;
2715 }
2716 
2717 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2718 {
2719  if (flt) {
2720  switch (bps) {
2721  case 32:
2723  case 64:
2725  default:
2726  return AV_CODEC_ID_NONE;
2727  }
2728  } else {
2729  bps += 7;
2730  bps >>= 3;
2731  if (sflags & (1 << (bps - 1))) {
2732  switch (bps) {
2733  case 1:
2734  return AV_CODEC_ID_PCM_S8;
2735  case 2:
2737  case 3:
2739  case 4:
2741  default:
2742  return AV_CODEC_ID_NONE;
2743  }
2744  } else {
2745  switch (bps) {
2746  case 1:
2747  return AV_CODEC_ID_PCM_U8;
2748  case 2:
2750  case 3:
2752  case 4:
2754  default:
2755  return AV_CODEC_ID_NONE;
2756  }
2757  }
2758  }
2759 }
2760 
2761 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2762 {
2763  unsigned int tag;
2764  if (!av_codec_get_tag2(tags, id, &tag))
2765  return 0;
2766  return tag;
2767 }
2768 
2769 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2770  unsigned int *tag)
2771 {
2772  int i;
2773  for (i = 0; tags && tags[i]; i++) {
2774  const AVCodecTag *codec_tags = tags[i];
2775  while (codec_tags->id != AV_CODEC_ID_NONE) {
2776  if (codec_tags->id == id) {
2777  *tag = codec_tags->tag;
2778  return 1;
2779  }
2780  codec_tags++;
2781  }
2782  }
2783  return 0;
2784 }
2785 
2786 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2787 {
2788  int i;
2789  for (i = 0; tags && tags[i]; i++) {
2790  enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2791  if (id != AV_CODEC_ID_NONE)
2792  return id;
2793  }
2794  return AV_CODEC_ID_NONE;
2795 }
2796 
2798 {
2799  unsigned int i, j;
2800  int64_t max_time = s->duration +
2801  ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2802 
2803  for (i = 0; i < s->nb_chapters; i++)
2804  if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2805  AVChapter *ch = s->chapters[i];
2806  int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2807  ch->time_base)
2808  : INT64_MAX;
2809 
2810  for (j = 0; j < s->nb_chapters; j++) {
2811  AVChapter *ch1 = s->chapters[j];
2812  int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2813  ch->time_base);
2814  if (j != i && next_start > ch->start && next_start < end)
2815  end = next_start;
2816  }
2817  ch->end = (end == INT64_MAX) ? ch->start : end;
2818  }
2819 }
2820 
2821 static int get_std_framerate(int i)
2822 {
2823  if (i < 60 * 12)
2824  return (i + 1) * 1001;
2825  else
2826  return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2827 }
2828 
2829 /* Is the time base unreliable?
2830  * This is a heuristic to balance between quick acceptance of the values in
2831  * the headers vs. some extra checks.
2832  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2833  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2834  * And there are "variable" fps files this needs to detect as well. */
2836 {
2837  if (c->time_base.den >= 101L * c->time_base.num ||
2838  c->time_base.den < 5L * c->time_base.num ||
2839  // c->codec_tag == AV_RL32("DIVX") ||
2840  // c->codec_tag == AV_RL32("XVID") ||
2841  c->codec_tag == AV_RL32("mp4v") ||
2843  c->codec_id == AV_CODEC_ID_H264)
2844  return 1;
2845  return 0;
2846 }
2847 
2848 #if FF_API_FORMAT_PARAMETERS
2849 int av_find_stream_info(AVFormatContext *ic)
2850 {
2851  return avformat_find_stream_info(ic, NULL);
2852 }
2853 #endif
2854 
2856 {
2857  int ret;
2858 
2860  avctx->extradata_size = 0;
2861  return AVERROR(EINVAL);
2862  }
2864  if (avctx->extradata) {
2865  memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2866  avctx->extradata_size = size;
2867  ret = 0;
2868  } else {
2869  avctx->extradata_size = 0;
2870  ret = AVERROR(ENOMEM);
2871  }
2872  return ret;
2873 }
2874 
2876 {
2877  int ret = ff_alloc_extradata(avctx, size);
2878  if (ret < 0)
2879  return ret;
2880  ret = avio_read(pb, avctx->extradata, size);
2881  if (ret != size) {
2882  av_freep(&avctx->extradata);
2883  avctx->extradata_size = 0;
2884  av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2885  return ret < 0 ? ret : AVERROR_INVALIDDATA;
2886  }
2887 
2888  return ret;
2889 }
2890 
2891 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2892 {
2893  int i, j;
2894  int64_t last = st->info->last_dts;
2895 
2896  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2897  && ts - (uint64_t)last < INT64_MAX) {
2898  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2899  int64_t duration = ts - last;
2900 
2901  if (!st->info->duration_error)
2902  st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2903  if (!st->info->duration_error)
2904  return AVERROR(ENOMEM);
2905 
2906 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2907 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2908  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2909  if (st->info->duration_error[0][1][i] < 1e10) {
2910  int framerate = get_std_framerate(i);
2911  double sdts = dts*framerate/(1001*12);
2912  for (j= 0; j<2; j++) {
2913  int64_t ticks = llrint(sdts+j*0.5);
2914  double error= sdts - ticks + j*0.5;
2915  st->info->duration_error[j][0][i] += error;
2916  st->info->duration_error[j][1][i] += error*error;
2917  }
2918  }
2919  }
2920  st->info->duration_count++;
2922 
2923  if (st->info->duration_count % 10 == 0) {
2924  int n = st->info->duration_count;
2925  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2926  if (st->info->duration_error[0][1][i] < 1e10) {
2927  double a0 = st->info->duration_error[0][0][i] / n;
2928  double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2929  double a1 = st->info->duration_error[1][0][i] / n;
2930  double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2931  if (error0 > 0.04 && error1 > 0.04) {
2932  st->info->duration_error[0][1][i] = 2e10;
2933  st->info->duration_error[1][1][i] = 2e10;
2934  }
2935  }
2936  }
2937  }
2938 
2939  // ignore the first 4 values, they might have some random jitter
2940  if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2941  st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2942  }
2943  if (ts != AV_NOPTS_VALUE)
2944  st->info->last_dts = ts;
2945 
2946  return 0;
2947 }
2948 
2950 {
2951  int i, j;
2952 
2953  for (i = 0; i < ic->nb_streams; i++) {
2954  AVStream *st = ic->streams[i];
2955 
2956  if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2957  continue;
2958  // the check for tb_unreliable() is not completely correct, since this is not about handling
2959  // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2960  // ipmovie.c produces.
2961  if (tb_unreliable(st->codec) && 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)
2962  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);
2963  if (st->info->duration_count>1 && !st->r_frame_rate.num
2964  && tb_unreliable(st->codec)) {
2965  int num = 0;
2966  double best_error= 0.01;
2967 
2968  for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2969  int k;
2970 
2971  if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2972  continue;
2973  if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2974  continue;
2975 
2976  if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2977  continue;
2978 
2979  for (k= 0; k<2; k++) {
2980  int n = st->info->duration_count;
2981  double a= st->info->duration_error[k][0][j] / n;
2982  double error= st->info->duration_error[k][1][j]/n - a*a;
2983 
2984  if (error < best_error && best_error> 0.000000001) {
2985  best_error= error;
2986  num = get_std_framerate(j);
2987  }
2988  if (error < 0.02)
2989  av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2990  }
2991  }
2992  // do not increase frame rate by more than 1 % in order to match a standard rate.
2993  if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2994  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2995  }
2996 
2997  av_freep(&st->info->duration_error);
2998  st->info->last_dts = AV_NOPTS_VALUE;
2999  st->info->duration_count = 0;
3000  st->info->rfps_duration_sum = 0;
3001  }
3002 }
3003 
3005 {
3006  int i, count, ret = 0, j;
3007  int64_t read_size;
3008  AVStream *st;
3009  AVPacket pkt1, *pkt;
3010  int64_t old_offset = avio_tell(ic->pb);
3011  // new streams might appear, no options for those
3012  int orig_nb_streams = ic->nb_streams;
3013  int flush_codecs = ic->probesize > 0;
3014 
3015  if (ic->pb)
3016  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3017  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3018 
3019  for (i = 0; i < ic->nb_streams; i++) {
3020  const AVCodec *codec;
3021  AVDictionary *thread_opt = NULL;
3022  st = ic->streams[i];
3023 
3024  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3026 /* if (!st->time_base.num)
3027  st->time_base = */
3028  if (!st->codec->time_base.num)
3029  st->codec->time_base = st->time_base;
3030  }
3031  // only for the split stuff
3032  if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3033  st->parser = av_parser_init(st->codec->codec_id);
3034  if (st->parser) {
3035  if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3037  } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3039  }
3040  } else if (st->need_parsing) {
3041  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3042  "%s, packets or times may be invalid.\n",
3044  }
3045  }
3046  codec = find_decoder(ic, st, st->codec->codec_id);
3047 
3048  /* Force thread count to 1 since the H.264 decoder will not extract
3049  * SPS and PPS to extradata during multi-threaded decoding. */
3050  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3051 
3052  /* Ensure that subtitle_header is properly set. */
3054  && codec && !st->codec->codec) {
3055  if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3056  av_log(ic, AV_LOG_WARNING,
3057  "Failed to open codec in av_find_stream_info\n");
3058  }
3059 
3060  // Try to just open decoders, in case this is enough to get parameters.
3061  if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3062  if (codec && !st->codec->codec)
3063  if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3064  av_log(ic, AV_LOG_WARNING,
3065  "Failed to open codec in av_find_stream_info\n");
3066  }
3067  if (!options)
3068  av_dict_free(&thread_opt);
3069  }
3070 
3071  for (i = 0; i < ic->nb_streams; i++) {
3072 #if FF_API_R_FRAME_RATE
3073  ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3074 #endif
3077  }
3078 
3079  count = 0;
3080  read_size = 0;
3081  for (;;) {
3083  ret = AVERROR_EXIT;
3084  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3085  break;
3086  }
3087 
3088  /* check if one codec still needs to be handled */
3089  for (i = 0; i < ic->nb_streams; i++) {
3090  int fps_analyze_framecount = 20;
3091 
3092  st = ic->streams[i];
3093  if (!has_codec_parameters(st, NULL))
3094  break;
3095  /* If the timebase is coarse (like the usual millisecond precision
3096  * of mkv), we need to analyze more frames to reliably arrive at
3097  * the correct fps. */
3098  if (av_q2d(st->time_base) > 0.0005)
3099  fps_analyze_framecount *= 2;
3100  if (ic->fps_probe_size >= 0)
3101  fps_analyze_framecount = ic->fps_probe_size;
3103  fps_analyze_framecount = 0;
3104  /* variable fps and no guess at the real fps */
3105  if (tb_unreliable(st->codec) &&
3106  !(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3107  st->info->duration_count < fps_analyze_framecount &&
3109  break;
3110  if (st->parser && st->parser->parser->split &&
3111  !st->codec->extradata)
3112  break;
3113  if (st->first_dts == AV_NOPTS_VALUE &&
3114  (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3116  break;
3117  }
3118  if (i == ic->nb_streams) {
3119  /* NOTE: If the format has no header, then we need to read some
3120  * packets to get most of the streams, so we cannot stop here. */
3121  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3122  /* If we found the info for all the codecs, we can stop. */
3123  ret = count;
3124  av_log(ic, AV_LOG_DEBUG, "All info found\n");
3125  flush_codecs = 0;
3126  break;
3127  }
3128  }
3129  /* We did not get all the codec info, but we read too much data. */
3130  if (read_size >= ic->probesize) {
3131  ret = count;
3132  av_log(ic, AV_LOG_DEBUG,
3133  "Probe buffer size limit of %d bytes reached\n", ic->probesize);
3134  for (i = 0; i < ic->nb_streams; i++)
3135  if (!ic->streams[i]->r_frame_rate.num &&
3136  ic->streams[i]->info->duration_count <= 1 &&
3138  strcmp(ic->iformat->name, "image2"))
3139  av_log(ic, AV_LOG_WARNING,
3140  "Stream #%d: not enough frames to estimate rate; "
3141  "consider increasing probesize\n", i);
3142  break;
3143  }
3144 
3145  /* NOTE: A new stream can be added there if no header in file
3146  * (AVFMTCTX_NOHEADER). */
3147  ret = read_frame_internal(ic, &pkt1);
3148  if (ret == AVERROR(EAGAIN))
3149  continue;
3150 
3151  if (ret < 0) {
3152  /* EOF or error*/
3153  break;
3154  }
3155 
3156  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3158  {
3159  pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3160  &ic->packet_buffer_end);
3161  if (!pkt) {
3162  ret = AVERROR(ENOMEM);
3163  goto find_stream_info_err;
3164  }
3165  if ((ret = av_dup_packet(pkt)) < 0)
3166  goto find_stream_info_err;
3167  }
3168 
3169  st = ic->streams[pkt->stream_index];
3171  read_size += pkt->size;
3172 
3173  if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3174  /* check for non-increasing dts */
3175  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3176  st->info->fps_last_dts >= pkt->dts) {
3177  av_log(ic, AV_LOG_DEBUG,
3178  "Non-increasing DTS in stream %d: packet %d with DTS "
3179  "%"PRId64", packet %d with DTS %"PRId64"\n",
3180  st->index, st->info->fps_last_dts_idx,
3182  pkt->dts);
3183  st->info->fps_first_dts =
3185  }
3186  /* Check for a discontinuity in dts. If the difference in dts
3187  * is more than 1000 times the average packet duration in the
3188  * sequence, we treat it as a discontinuity. */
3189  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3191  (pkt->dts - st->info->fps_last_dts) / 1000 >
3192  (st->info->fps_last_dts - st->info->fps_first_dts) /
3193  (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3194  av_log(ic, AV_LOG_WARNING,
3195  "DTS discontinuity in stream %d: packet %d with DTS "
3196  "%"PRId64", packet %d with DTS %"PRId64"\n",
3197  st->index, st->info->fps_last_dts_idx,
3199  pkt->dts);
3200  st->info->fps_first_dts =
3202  }
3203 
3204  /* update stored dts values */
3205  if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3206  st->info->fps_first_dts = pkt->dts;
3208  }
3209  st->info->fps_last_dts = pkt->dts;
3211  }
3212  if (st->codec_info_nb_frames>1) {
3213  int64_t t = 0;
3214  if (st->time_base.den > 0)
3216  if (st->avg_frame_rate.num > 0)
3218 
3219  if ( t == 0
3220  && st->codec_info_nb_frames>30
3221  && st->info->fps_first_dts != AV_NOPTS_VALUE
3222  && st->info->fps_last_dts != AV_NOPTS_VALUE)
3224 
3225  if (t >= ic->max_analyze_duration) {
3226  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
3227  break;
3228  }
3229  if (pkt->duration) {
3230  st->info->codec_info_duration += pkt->duration;
3231  st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3232  }
3233  }
3234 #if FF_API_R_FRAME_RATE
3235  ff_rfps_add_frame(ic, st, pkt->dts);
3236 #endif
3237  if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3238  int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3239  if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3240  if (ff_alloc_extradata(st->codec, i))
3241  return AVERROR(ENOMEM);
3242  memcpy(st->codec->extradata, pkt->data,
3243  st->codec->extradata_size);
3244  }
3245  }
3246 
3247  /* If still no information, we try to open the codec and to
3248  * decompress the frame. We try to avoid that in most cases as
3249  * it takes longer and uses more memory. For MPEG-4, we need to
3250  * decompress for QuickTime.
3251  *
3252  * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3253  * least one frame of codec data, this makes sure the codec initializes
3254  * the channel configuration and does not only trust the values from
3255  * the container. */
3256  try_decode_frame(ic, st, pkt,
3257  (options && i < orig_nb_streams) ? &options[i] : NULL);
3258 
3259  st->codec_info_nb_frames++;
3260  count++;
3261  }
3262 
3263  if (flush_codecs) {
3264  AVPacket empty_pkt = { 0 };
3265  int err = 0;
3266  av_init_packet(&empty_pkt);
3267 
3268  for (i = 0; i < ic->nb_streams; i++) {
3269 
3270  st = ic->streams[i];
3271 
3272  /* flush the decoders */
3273  if (st->info->found_decoder == 1) {
3274  do {
3275  err = try_decode_frame(ic, st, &empty_pkt,
3276  (options && i < orig_nb_streams)
3277  ? &options[i] : NULL);
3278  } while (err > 0 && !has_codec_parameters(st, NULL));
3279 
3280  if (err < 0) {
3281  av_log(ic, AV_LOG_INFO,
3282  "decoding for stream %d failed\n", st->index);
3283  }
3284  }
3285  }
3286  }
3287 
3288  // close codecs which were opened in try_decode_frame()
3289  for (i = 0; i < ic->nb_streams; i++) {
3290  st = ic->streams[i];
3291  avcodec_close(st->codec);
3292  }
3293 
3294  ff_rfps_calculate(ic);
3295 
3296  for (i = 0; i < ic->nb_streams; i++) {
3297  st = ic->streams[i];
3298  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3302  st->codec->codec_tag= tag;
3303  }
3304 
3305  /* estimate average framerate if not set by demuxer */
3306  if (st->info->codec_info_duration_fields &&
3307  !st->avg_frame_rate.num &&
3308  st->info->codec_info_duration) {
3309  int best_fps = 0;
3310  double best_error = 0.01;
3311 
3312  if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3313  st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3314  st->info->codec_info_duration < 0)
3315  continue;
3317  st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3318  st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3319 
3320  /* Round guessed framerate to a "standard" framerate if it's
3321  * within 1% of the original estimate. */
3322  for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3323  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3324  double error = fabs(av_q2d(st->avg_frame_rate) /
3325  av_q2d(std_fps) - 1);
3326 
3327  if (error < best_error) {
3328  best_error = error;
3329  best_fps = std_fps.num;
3330  }
3331  }
3332  if (best_fps)
3334  best_fps, 12 * 1001, INT_MAX);
3335  }
3336 
3337  if (!st->r_frame_rate.num) {
3338  if ( st->codec->time_base.den * (int64_t) st->time_base.num
3339  <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3340  st->r_frame_rate.num = st->codec->time_base.den;
3342  } else {
3343  st->r_frame_rate.num = st->time_base.den;
3344  st->r_frame_rate.den = st->time_base.num;
3345  }
3346  }
3347  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3348  if (!st->codec->bits_per_coded_sample)
3351  // set stream disposition based on audio service type
3352  switch (st->codec->audio_service_type) {
3355  break;
3358  break;
3361  break;
3364  break;
3367  break;
3368  }
3369  }
3370  }
3371 
3372  if (ic->probesize)
3373  estimate_timings(ic, old_offset);
3374 
3375  if (ret >= 0 && ic->nb_streams)
3376  /* We could not have all the codec parameters before EOF. */
3377  ret = -1;
3378  for (i = 0; i < ic->nb_streams; i++) {
3379  const char *errmsg;
3380  st = ic->streams[i];
3381  if (!has_codec_parameters(st, &errmsg)) {
3382  char buf[256];
3383  avcodec_string(buf, sizeof(buf), st->codec, 0);
3384  av_log(ic, AV_LOG_WARNING,
3385  "Could not find codec parameters for stream %d (%s): %s\n"
3386  "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3387  i, buf, errmsg);
3388  } else {
3389  ret = 0;
3390  }
3391  }
3392 
3394 
3395 find_stream_info_err:
3396  for (i = 0; i < ic->nb_streams; i++) {
3397  st = ic->streams[i];
3398  if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3399  ic->streams[i]->codec->thread_count = 0;
3400  if (st->info)
3401  av_freep(&st->info->duration_error);
3402  av_freep(&ic->streams[i]->info);
3403  }
3404  if (ic->pb)
3405  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3406  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3407  return ret;
3408 }
3409 
3411 {
3412  int i, j;
3413 
3414  for (i = 0; i < ic->nb_programs; i++) {
3415  if (ic->programs[i] == last) {
3416  last = NULL;
3417  } else {
3418  if (!last)
3419  for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3420  if (ic->programs[i]->stream_index[j] == s)
3421  return ic->programs[i];
3422  }
3423  }
3424  return NULL;
3425 }
3426 
3428  int wanted_stream_nb, int related_stream,
3429  AVCodec **decoder_ret, int flags)
3430 {
3431  int i, nb_streams = ic->nb_streams;
3432  int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3433  unsigned *program = NULL;
3434  AVCodec *decoder = NULL, *best_decoder = NULL;
3435 
3436  if (related_stream >= 0 && wanted_stream_nb < 0) {
3437  AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3438  if (p) {
3439  program = p->stream_index;
3440  nb_streams = p->nb_stream_indexes;
3441  }
3442  }
3443  for (i = 0; i < nb_streams; i++) {
3444  int real_stream_index = program ? program[i] : i;
3445  AVStream *st = ic->streams[real_stream_index];
3446  AVCodecContext *avctx = st->codec;
3447  if (avctx->codec_type != type)
3448  continue;
3449  if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3450  continue;
3451  if (wanted_stream_nb != real_stream_index &&
3454  continue;
3455  if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3456  continue;
3457  if (decoder_ret) {
3458  decoder = find_decoder(ic, st, st->codec->codec_id);
3459  if (!decoder) {
3460  if (ret < 0)
3462  continue;
3463  }
3464  }
3466  bitrate = avctx->bit_rate;
3467  multiframe = FFMIN(5, count);
3468  if ((best_multiframe > multiframe) ||
3469  (best_multiframe == multiframe && best_bitrate > bitrate) ||
3470  (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3471  continue;
3472  best_count = count;
3473  best_bitrate = bitrate;
3474  best_multiframe = multiframe;
3475  ret = real_stream_index;
3476  best_decoder = decoder;
3477  if (program && i == nb_streams - 1 && ret < 0) {
3478  program = NULL;
3479  nb_streams = ic->nb_streams;
3480  /* no related stream found, try again with everything */
3481  i = 0;
3482  }
3483  }
3484  if (decoder_ret)
3485  *decoder_ret = best_decoder;
3486  return ret;
3487 }
3488 
3489 /*******************************************************/
3490 
3492 {
3493  if (s->iformat->read_play)
3494  return s->iformat->read_play(s);
3495  if (s->pb)
3496  return avio_pause(s->pb, 0);
3497  return AVERROR(ENOSYS);
3498 }
3499 
3501 {
3502  if (s->iformat->read_pause)
3503  return s->iformat->read_pause(s);
3504  if (s->pb)
3505  return avio_pause(s->pb, 1);
3506  return AVERROR(ENOSYS);
3507 }
3508 
3510  av_assert0(s->nb_streams>0);
3511  av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3512 
3513  if (st->parser) {
3514  av_parser_close(st->parser);
3515  }
3516  if (st->attached_pic.data)
3518  av_dict_free(&st->metadata);
3519  av_freep(&st->probe_data.buf);
3520  av_freep(&st->index_entries);
3521  av_freep(&st->codec->extradata);
3523  av_freep(&st->codec);
3524  av_freep(&st->priv_data);
3525  if (st->info)
3526  av_freep(&st->info->duration_error);
3527  av_freep(&st->info);
3528  av_freep(&s->streams[ --s->nb_streams ]);
3529 }
3530 
3532 {
3533  int i;
3534 
3535  if (!s)
3536  return;
3537 
3538  av_opt_free(s);
3539  if (s->iformat && s->iformat->priv_class && s->priv_data)
3540  av_opt_free(s->priv_data);
3541 
3542  for (i = s->nb_streams - 1; i >= 0; i--) {
3543  ff_free_stream(s, s->streams[i]);
3544  }
3545  for (i = s->nb_programs - 1; i >= 0; i--) {
3546  av_dict_free(&s->programs[i]->metadata);
3547  av_freep(&s->programs[i]->stream_index);
3548  av_freep(&s->programs[i]);
3549  }
3550  av_freep(&s->programs);
3551  av_freep(&s->priv_data);
3552  while (s->nb_chapters--) {
3554  av_freep(&s->chapters[s->nb_chapters]);
3555  }
3556  av_freep(&s->chapters);
3557  av_dict_free(&s->metadata);
3558  av_freep(&s->streams);
3559  av_freep(&s->internal);
3560  av_free(s);
3561 }
3562 
3563 #if FF_API_CLOSE_INPUT_FILE
3564 void av_close_input_file(AVFormatContext *s)
3565 {
3567 }
3568 #endif
3569 
3571 {
3572  AVFormatContext *s;
3573  AVIOContext *pb;
3574 
3575  if (!ps || !*ps)
3576  return;
3577 
3578  s = *ps;
3579  pb = s->pb;
3580 
3581  if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3582  (s->flags & AVFMT_FLAG_CUSTOM_IO))
3583  pb = NULL;
3584 
3585  flush_packet_queue(s);
3586 
3587  if (s->iformat)
3588  if (s->iformat->read_close)
3589  s->iformat->read_close(s);
3590 
3592 
3593  *ps = NULL;
3594 
3595  avio_close(pb);
3596 }
3597 
3598 #if FF_API_NEW_STREAM
3599 AVStream *av_new_stream(AVFormatContext *s, int id)
3600 {
3601  AVStream *st = avformat_new_stream(s, NULL);
3602  if (st)
3603  st->id = id;
3604  return st;
3605 }
3606 #endif
3607 
3609 {
3610  AVStream *st;
3611  int i;
3612  AVStream **streams;
3613 
3614  if (s->nb_streams >= INT_MAX/sizeof(*streams))
3615  return NULL;
3616  streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3617  if (!streams)
3618  return NULL;
3619  s->streams = streams;
3620 
3621  st = av_mallocz(sizeof(AVStream));
3622  if (!st)
3623  return NULL;
3624  if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3625  av_free(st);
3626  return NULL;
3627  }
3628  st->info->last_dts = AV_NOPTS_VALUE;
3629 
3630  st->codec = avcodec_alloc_context3(c);
3631  if (s->iformat)
3632  /* no default bitrate if decoding */
3633  st->codec->bit_rate = 0;
3634  st->index = s->nb_streams;
3635  st->start_time = AV_NOPTS_VALUE;
3636  st->duration = AV_NOPTS_VALUE;
3637  /* we set the current DTS to 0 so that formats without any timestamps
3638  * but durations get some timestamps, formats with some unknown
3639  * timestamps have their first few packets buffered and the
3640  * timestamps corrected before they are returned to the user */
3641  st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3642  st->first_dts = AV_NOPTS_VALUE;
3646 
3647  /* default pts setting is MPEG-like */
3648  avpriv_set_pts_info(st, 33, 1, 90000);
3651  for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3652  st->pts_buffer[i] = AV_NOPTS_VALUE;
3653 
3654  st->sample_aspect_ratio = (AVRational) { 0, 1 };
3655 
3656 #if FF_API_R_FRAME_RATE
3657  st->info->last_dts = AV_NOPTS_VALUE;
3658 #endif
3661 
3662  s->streams[s->nb_streams++] = st;
3663  return st;
3664 }
3665 
3667 {
3668  AVProgram *program = NULL;
3669  int i;
3670 
3671  av_dlog(ac, "new_program: id=0x%04x\n", id);
3672 
3673  for (i = 0; i < ac->nb_programs; i++)
3674  if (ac->programs[i]->id == id)
3675  program = ac->programs[i];
3676 
3677  if (!program) {
3678  program = av_mallocz(sizeof(AVProgram));
3679  if (!program)
3680  return NULL;
3681  dynarray_add(&ac->programs, &ac->nb_programs, program);
3682  program->discard = AVDISCARD_NONE;
3683  }
3684  program->id = id;
3687 
3688  program->start_time =
3689  program->end_time = AV_NOPTS_VALUE;
3690 
3691  return program;
3692 }
3693 
3695  int64_t start, int64_t end, const char *title)
3696 {
3697  AVChapter *chapter = NULL;
3698  int i;
3699 
3700  for (i = 0; i < s->nb_chapters; i++)
3701  if (s->chapters[i]->id == id)
3702  chapter = s->chapters[i];
3703 
3704  if (!chapter) {
3705  chapter = av_mallocz(sizeof(AVChapter));
3706  if (!chapter)
3707  return NULL;
3708  dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3709  }
3710  av_dict_set(&chapter->metadata, "title", title, 0);
3711  chapter->id = id;
3712  chapter->time_base = time_base;
3713  chapter->start = start;
3714  chapter->end = end;
3715 
3716  return chapter;
3717 }
3718 
3719 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3720 {
3721  int i, j;
3722  AVProgram *program = NULL;
3723  void *tmp;
3724 
3725  if (idx >= ac->nb_streams) {
3726  av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3727  return;
3728  }
3729 
3730  for (i = 0; i < ac->nb_programs; i++) {
3731  if (ac->programs[i]->id != progid)
3732  continue;
3733  program = ac->programs[i];
3734  for (j = 0; j < program->nb_stream_indexes; j++)
3735  if (program->stream_index[j] == idx)
3736  return;
3737 
3738  tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3739  if (!tmp)
3740  return;
3741  program->stream_index = tmp;
3742  program->stream_index[program->nb_stream_indexes++] = idx;
3743  return;
3744  }
3745 }
3746 
3747 static void print_fps(double d, const char *postfix)
3748 {
3749  uint64_t v = lrintf(d * 100);
3750  if (v % 100)
3751  av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3752  else if (v % (100 * 1000))
3753  av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3754  else
3755  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d / 1000, postfix);
3756 }
3757 
3758 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3759 {
3760  if (m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))) {
3761  AVDictionaryEntry *tag = NULL;
3762 
3763  av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3764  while ((tag = av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX)))
3765  if (strcmp("language", tag->key)) {
3766  const char *p = tag->value;
3767  av_log(ctx, AV_LOG_INFO,
3768  "%s %-16s: ", indent, tag->key);
3769  while (*p) {
3770  char tmp[256];
3771  size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3772  av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3773  av_log(ctx, AV_LOG_INFO, "%s", tmp);
3774  p += len;
3775  if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3776  if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
3777  if (*p) p++;
3778  }
3779  av_log(ctx, AV_LOG_INFO, "\n");
3780  }
3781  }
3782 }
3783 
3784 /* "user interface" functions */
3785 static void dump_stream_format(AVFormatContext *ic, int i,
3786  int index, int is_output)
3787 {
3788  char buf[256];
3789  int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3790  AVStream *st = ic->streams[i];
3791  int g = av_gcd(st->time_base.num, st->time_base.den);
3792  AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3793  avcodec_string(buf, sizeof(buf), st->codec, is_output);
3794  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3795  /* the pid is an important information, so we display it */
3796  /* XXX: add a generic system */
3797  if (flags & AVFMT_SHOW_IDS)
3798  av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3799  if (lang)
3800  av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3801  av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames,
3802  st->time_base.num / g, st->time_base.den / g);
3803  av_log(NULL, AV_LOG_INFO, ": %s", buf);
3804  if (st->sample_aspect_ratio.num && // default
3806  AVRational display_aspect_ratio;
3807  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3808  st->codec->width * st->sample_aspect_ratio.num,
3809  st->codec->height * st->sample_aspect_ratio.den,
3810  1024 * 1024);
3811  av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3813  display_aspect_ratio.num, display_aspect_ratio.den);
3814  }
3815  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3816  if (st->avg_frame_rate.den && st->avg_frame_rate.num)
3817  print_fps(av_q2d(st->avg_frame_rate), "fps");
3818 #if FF_API_R_FRAME_RATE
3819  if (st->r_frame_rate.den && st->r_frame_rate.num)
3820  print_fps(av_q2d(st->r_frame_rate), "tbr");
3821 #endif
3822  if (st->time_base.den && st->time_base.num)
3823  print_fps(1 / av_q2d(st->time_base), "tbn");
3824  if (st->codec->time_base.den && st->codec->time_base.num)
3825  print_fps(1 / av_q2d(st->codec->time_base), "tbc");
3826  }
3828  av_log(NULL, AV_LOG_INFO, " (default)");
3829  if (st->disposition & AV_DISPOSITION_DUB)
3830  av_log(NULL, AV_LOG_INFO, " (dub)");
3832  av_log(NULL, AV_LOG_INFO, " (original)");
3834  av_log(NULL, AV_LOG_INFO, " (comment)");
3836  av_log(NULL, AV_LOG_INFO, " (lyrics)");
3838  av_log(NULL, AV_LOG_INFO, " (karaoke)");
3840  av_log(NULL, AV_LOG_INFO, " (forced)");
3842  av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3844  av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3846  av_log(NULL, AV_LOG_INFO, " (clean effects)");
3847  av_log(NULL, AV_LOG_INFO, "\n");
3848  dump_metadata(NULL, st->metadata, " ");
3849 }
3850 
3852  const char *url, int is_output)
3853 {
3854  int i;
3855  uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3856  if (ic->nb_streams && !printed)
3857  return;
3858 
3859  av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3860  is_output ? "Output" : "Input",
3861  index,
3862  is_output ? ic->oformat->name : ic->iformat->name,
3863  is_output ? "to" : "from", url);
3864  dump_metadata(NULL, ic->metadata, " ");
3865  if (!is_output) {
3866  av_log(NULL, AV_LOG_INFO, " Duration: ");
3867  if (ic->duration != AV_NOPTS_VALUE) {
3868  int hours, mins, secs, us;
3869  int64_t duration = ic->duration + 5000;
3870  secs = duration / AV_TIME_BASE;
3871  us = duration % AV_TIME_BASE;
3872  mins = secs / 60;
3873  secs %= 60;
3874  hours = mins / 60;
3875  mins %= 60;
3876  av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3877  (100 * us) / AV_TIME_BASE);
3878  } else {
3879  av_log(NULL, AV_LOG_INFO, "N/A");
3880  }
3881  if (ic->start_time != AV_NOPTS_VALUE) {
3882  int secs, us;
3883  av_log(NULL, AV_LOG_INFO, ", start: ");
3884  secs = ic->start_time / AV_TIME_BASE;
3885  us = abs(ic->start_time % AV_TIME_BASE);
3886  av_log(NULL, AV_LOG_INFO, "%d.%06d",
3887  secs, (int) av_rescale(us, 1000000, AV_TIME_BASE));
3888  }
3889  av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3890  if (ic->bit_rate)
3891  av_log(NULL, AV_LOG_INFO, "%d kb/s", ic->bit_rate / 1000);
3892  else
3893  av_log(NULL, AV_LOG_INFO, "N/A");
3894  av_log(NULL, AV_LOG_INFO, "\n");
3895  }
3896  for (i = 0; i < ic->nb_chapters; i++) {
3897  AVChapter *ch = ic->chapters[i];
3898  av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3899  av_log(NULL, AV_LOG_INFO,
3900  "start %f, ", ch->start * av_q2d(ch->time_base));
3901  av_log(NULL, AV_LOG_INFO,
3902  "end %f\n", ch->end * av_q2d(ch->time_base));
3903 
3904  dump_metadata(NULL, ch->metadata, " ");
3905  }
3906  if (ic->nb_programs) {
3907  int j, k, total = 0;
3908  for (j = 0; j < ic->nb_programs; j++) {
3910  "name", NULL, 0);
3911  av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3912  name ? name->value : "");
3913  dump_metadata(NULL, ic->programs[j]->metadata, " ");
3914  for (k = 0; k < ic->programs[j]->nb_stream_indexes; k++) {
3915  dump_stream_format(ic, ic->programs[j]->stream_index[k],
3916  index, is_output);
3917  printed[ic->programs[j]->stream_index[k]] = 1;
3918  }
3919  total += ic->programs[j]->nb_stream_indexes;
3920  }
3921  if (total < ic->nb_streams)
3922  av_log(NULL, AV_LOG_INFO, " No Program\n");
3923  }
3924  for (i = 0; i < ic->nb_streams; i++)
3925  if (!printed[i])
3926  dump_stream_format(ic, i, index, is_output);
3927 
3928  av_free(printed);
3929 }
3930 
3931 uint64_t ff_ntp_time(void)
3932 {
3933  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3934 }
3935 
3936 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3937 {
3938  const char *p;
3939  char *q, buf1[20], c;
3940  int nd, len, percentd_found;
3941 
3942  q = buf;
3943  p = path;
3944  percentd_found = 0;
3945  for (;;) {
3946  c = *p++;
3947  if (c == '\0')
3948  break;
3949  if (c == '%') {
3950  do {
3951  nd = 0;
3952  while (av_isdigit(*p))
3953  nd = nd * 10 + *p++ - '0';
3954  c = *p++;
3955  } while (av_isdigit(c));
3956 
3957  switch (c) {
3958  case '%':
3959  goto addchar;
3960  case 'd':
3961  if (percentd_found)
3962  goto fail;
3963  percentd_found = 1;
3964  snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3965  len = strlen(buf1);
3966  if ((q - buf + len) > buf_size - 1)
3967  goto fail;
3968  memcpy(q, buf1, len);
3969  q += len;
3970  break;
3971  default:
3972  goto fail;
3973  }
3974  } else {
3975 addchar:
3976  if ((q - buf) < buf_size - 1)
3977  *q++ = c;
3978  }
3979  }
3980  if (!percentd_found)
3981  goto fail;
3982  *q = '\0';
3983  return 0;
3984 fail:
3985  *q = '\0';
3986  return -1;
3987 }
3988 
3989 #define HEXDUMP_PRINT(...) \
3990  do { \
3991  if (!f) \
3992  av_log(avcl, level, __VA_ARGS__); \
3993  else \
3994  fprintf(f, __VA_ARGS__); \
3995  } while (0)
3996 
3997 static void hex_dump_internal(void *avcl, FILE *f, int level,
3998  const uint8_t *buf, int size)
3999 {
4000  int len, i, j, c;
4001 
4002  for (i = 0; i < size; i += 16) {
4003  len = size - i;
4004  if (len > 16)
4005  len = 16;
4006  HEXDUMP_PRINT("%08x ", i);
4007  for (j = 0; j < 16; j++) {
4008  if (j < len)
4009  HEXDUMP_PRINT(" %02x", buf[i + j]);
4010  else
4011  HEXDUMP_PRINT(" ");
4012  }
4013  HEXDUMP_PRINT(" ");
4014  for (j = 0; j < len; j++) {
4015  c = buf[i + j];
4016  if (c < ' ' || c > '~')
4017  c = '.';
4018  HEXDUMP_PRINT("%c", c);
4019  }
4020  HEXDUMP_PRINT("\n");
4021  }
4022 }
4023 
4024 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
4025 {
4026  hex_dump_internal(NULL, f, 0, buf, size);
4027 }
4028 
4029 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
4030 {
4031  hex_dump_internal(avcl, NULL, level, buf, size);
4032 }
4033 
4034 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt,
4035  int dump_payload, AVRational time_base)
4036 {
4037  HEXDUMP_PRINT("stream #%d:\n", pkt->stream_index);
4038  HEXDUMP_PRINT(" keyframe=%d\n", (pkt->flags & AV_PKT_FLAG_KEY) != 0);
4039  HEXDUMP_PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
4040  /* DTS is _always_ valid after av_read_frame() */
4041  HEXDUMP_PRINT(" dts=");
4042  if (pkt->dts == AV_NOPTS_VALUE)
4043  HEXDUMP_PRINT("N/A");
4044  else
4045  HEXDUMP_PRINT("%0.3f", pkt->dts * av_q2d(time_base));
4046  /* PTS may not be known if B-frames are present. */
4047  HEXDUMP_PRINT(" pts=");
4048  if (pkt->pts == AV_NOPTS_VALUE)
4049  HEXDUMP_PRINT("N/A");
4050  else
4051  HEXDUMP_PRINT("%0.3f", pkt->pts * av_q2d(time_base));
4052  HEXDUMP_PRINT("\n");
4053  HEXDUMP_PRINT(" size=%d\n", pkt->size);
4054  if (dump_payload)
4055  av_hex_dump(f, pkt->data, pkt->size);
4056 }
4057 
4058 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
4059 {
4060  pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
4061 }
4062 
4063 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
4064  AVStream *st)
4065 {
4066  pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
4067 }
4068 
4069 void av_url_split(char *proto, int proto_size,
4070  char *authorization, int authorization_size,
4071  char *hostname, int hostname_size,
4072  int *port_ptr, char *path, int path_size, const char *url)
4073 {
4074  const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4075 
4076  if (port_ptr)
4077  *port_ptr = -1;
4078  if (proto_size > 0)
4079  proto[0] = 0;
4080  if (authorization_size > 0)
4081  authorization[0] = 0;
4082  if (hostname_size > 0)
4083  hostname[0] = 0;
4084  if (path_size > 0)
4085  path[0] = 0;
4086 
4087  /* parse protocol */
4088  if ((p = strchr(url, ':'))) {
4089  av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4090  p++; /* skip ':' */
4091  if (*p == '/')
4092  p++;
4093  if (*p == '/')
4094  p++;
4095  } else {
4096  /* no protocol means plain filename */
4097  av_strlcpy(path, url, path_size);
4098  return;
4099  }
4100 
4101  /* separate path from hostname */
4102  ls = strchr(p, '/');
4103  ls2 = strchr(p, '?');
4104  if (!ls)
4105  ls = ls2;
4106  else if (ls && ls2)
4107  ls = FFMIN(ls, ls2);
4108  if (ls)
4109