lavc: eliminate tb_unreliable()
[ffmpeg.git] / libavformat / utils.c
1 /*
2  * various utility functions for use within Libav
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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
39 #include "libavcodec/bytestream.h"
40 #include "libavcodec/internal.h"
41
42 #include "audiointerleave.h"
43 #include "avformat.h"
44 #include "avio_internal.h"
45 #include "id3v2.h"
46 #include "internal.h"
47 #include "metadata.h"
48 #if CONFIG_NETWORK
49 #include "network.h"
50 #endif
51 #include "riff.h"
52 #include "url.h"
53
54 /**
55  * @file
56  * various utility functions for use within Libav
57  */
58
59 unsigned avformat_version(void)
60 {
61     return LIBAVFORMAT_VERSION_INT;
62 }
63
64 const char *avformat_configuration(void)
65 {
66     return LIBAV_CONFIGURATION;
67 }
68
69 const char *avformat_license(void)
70 {
71 #define LICENSE_PREFIX "libavformat license: "
72     return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
73 }
74
75 /* an arbitrarily chosen "sane" max packet size -- 50M */
76 #define SANE_CHUNK_SIZE (50000000)
77
78 /* Read the data in sane-sized chunks and append to pkt.
79  * Return the number of bytes read or an error. */
80 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
81 {
82     int64_t chunk_size = size;
83     int64_t orig_pos   = pkt->pos; // av_grow_packet might reset pos
84     int orig_size      = pkt->size;
85     int ret = 0;
86
87     do {
88         int prev_size = pkt->size;
89         int read_size;
90
91         /* When the caller requests a lot of data, limit it to the amount
92          * left in file or SANE_CHUNK_SIZE when it is not known. */
93         if (size > SANE_CHUNK_SIZE) {
94             int64_t filesize = avio_size(s) - avio_tell(s);
95             chunk_size = FFMAX(filesize, SANE_CHUNK_SIZE);
96         }
97         read_size = FFMIN(size, chunk_size);
98
99         ret = av_grow_packet(pkt, read_size);
100         if (ret < 0)
101             break;
102
103         ret = avio_read(s, pkt->data + prev_size, read_size);
104         if (ret != read_size) {
105             av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
106             break;
107         }
108
109         size -= read_size;
110     } while (size > 0);
111
112     pkt->pos = orig_pos;
113     if (!pkt->size)
114         av_free_packet(pkt);
115     return pkt->size > orig_size ? pkt->size - orig_size : ret;
116 }
117
118 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
119 {
120     av_init_packet(pkt);
121     pkt->data = NULL;
122     pkt->size = 0;
123     pkt->pos  = avio_tell(s);
124
125     return append_packet_chunked(s, pkt, size);
126 }
127
128 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
129 {
130     if (!pkt->size)
131         return av_get_packet(s, pkt, size);
132     return append_packet_chunked(s, pkt, size);
133 }
134
135 int av_filename_number_test(const char *filename)
136 {
137     char buf[1024];
138     return filename &&
139            (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
140 }
141
142 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened,
143                                       int *score_max)
144 {
145     AVProbeData lpd = *pd;
146     AVInputFormat *fmt1 = NULL, *fmt;
147     int score, id3 = 0;
148
149     if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
150         int id3len = ff_id3v2_tag_len(lpd.buf);
151         if (lpd.buf_size > id3len + 16) {
152             lpd.buf      += id3len;
153             lpd.buf_size -= id3len;
154         }
155         id3 = 1;
156     }
157
158     fmt = NULL;
159     while ((fmt1 = av_iformat_next(fmt1))) {
160         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
161             continue;
162         score = 0;
163         if (fmt1->read_probe) {
164             score = fmt1->read_probe(&lpd);
165         } else if (fmt1->extensions) {
166             if (av_match_ext(lpd.filename, fmt1->extensions))
167                 score = AVPROBE_SCORE_EXTENSION;
168         }
169         if (score > *score_max) {
170             *score_max = score;
171             fmt        = fmt1;
172         } else if (score == *score_max)
173             fmt = NULL;
174     }
175
176     // A hack for files with huge id3v2 tags -- try to guess by file extension.
177     if (!fmt && is_opened && *score_max < AVPROBE_SCORE_EXTENSION / 2) {
178         while ((fmt = av_iformat_next(fmt)))
179             if (fmt->extensions &&
180                 av_match_ext(lpd.filename, fmt->extensions)) {
181                 *score_max = AVPROBE_SCORE_EXTENSION / 2;
182                 break;
183             }
184     }
185
186     if (!fmt && id3 && *score_max < AVPROBE_SCORE_EXTENSION / 2 - 1) {
187         while ((fmt = av_iformat_next(fmt)))
188             if (fmt->extensions && av_match_ext("mp3", fmt->extensions)) {
189                 *score_max = AVPROBE_SCORE_EXTENSION / 2 - 1;
190                 break;
191             }
192     }
193
194     return fmt;
195 }
196
197 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
198 {
199     int score = 0;
200     return av_probe_input_format2(pd, is_opened, &score);
201 }
202
203 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
204                                      AVProbeData *pd, int score)
205 {
206     static const struct {
207         const char *name;
208         enum AVCodecID id;
209         enum AVMediaType type;
210     } fmt_id_type[] = {
211         { "aac",       AV_CODEC_ID_AAC,        AVMEDIA_TYPE_AUDIO },
212         { "ac3",       AV_CODEC_ID_AC3,        AVMEDIA_TYPE_AUDIO },
213         { "dts",       AV_CODEC_ID_DTS,        AVMEDIA_TYPE_AUDIO },
214         { "eac3",      AV_CODEC_ID_EAC3,       AVMEDIA_TYPE_AUDIO },
215         { "h264",      AV_CODEC_ID_H264,       AVMEDIA_TYPE_VIDEO },
216         { "m4v",       AV_CODEC_ID_MPEG4,      AVMEDIA_TYPE_VIDEO },
217         { "mp3",       AV_CODEC_ID_MP3,        AVMEDIA_TYPE_AUDIO },
218         { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
219         { 0 }
220     };
221     AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
222
223     if (fmt) {
224         int i;
225         av_log(s, AV_LOG_DEBUG,
226                "Probe with size=%d, packets=%d detected %s with score=%d\n",
227                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
228                fmt->name, score);
229         for (i = 0; fmt_id_type[i].name; i++) {
230             if (!strcmp(fmt->name, fmt_id_type[i].name)) {
231                 st->codec->codec_id   = fmt_id_type[i].id;
232                 st->codec->codec_type = fmt_id_type[i].type;
233                 break;
234             }
235         }
236     }
237     return !!fmt;
238 }
239
240 /************************************************************/
241 /* input media file */
242
243 /** size of probe buffer, for guessing file type from file contents */
244 #define PROBE_BUF_MIN 2048
245 #define PROBE_BUF_MAX (1 << 20)
246
247 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
248                           const char *filename, void *logctx,
249                           unsigned int offset, unsigned int max_probe_size)
250 {
251     AVProbeData pd = { filename ? filename : "" };
252     uint8_t *buf = NULL;
253     int ret = 0, probe_size;
254
255     if (!max_probe_size)
256         max_probe_size = PROBE_BUF_MAX;
257     else if (max_probe_size > PROBE_BUF_MAX)
258         max_probe_size = PROBE_BUF_MAX;
259     else if (max_probe_size < PROBE_BUF_MIN)
260         return AVERROR(EINVAL);
261
262     if (offset >= max_probe_size)
263         return AVERROR(EINVAL);
264     avio_skip(pb, offset);
265     max_probe_size -= offset;
266
267     for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
268          probe_size = FFMIN(probe_size << 1,
269                             FFMAX(max_probe_size, probe_size + 1))) {
270         int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX / 4 : 0;
271
272         /* Read probe data. */
273         if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
274             return ret;
275         if ((ret = avio_read(pb, buf + pd.buf_size,
276                              probe_size - pd.buf_size)) < 0) {
277             /* Fail if error was not end of file, otherwise, lower score. */
278             if (ret != AVERROR_EOF) {
279                 av_free(buf);
280                 return ret;
281             }
282             score = 0;
283             ret   = 0;          /* error was end of file, nothing read */
284         }
285         pd.buf_size += ret;
286         pd.buf       = buf;
287
288         memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
289
290         /* Guess file format. */
291         *fmt = av_probe_input_format2(&pd, 1, &score);
292         if (*fmt) {
293             /* This can only be true in the last iteration. */
294             if (score <= AVPROBE_SCORE_MAX / 4) {
295                 av_log(logctx, AV_LOG_WARNING,
296                        "Format detected only with low score of %d, "
297                        "misdetection possible!\n", score);
298             } else
299                 av_log(logctx, AV_LOG_DEBUG,
300                        "Probed with size=%d and score=%d\n", probe_size, score);
301         }
302     }
303
304     if (!*fmt) {
305         av_free(buf);
306         return AVERROR_INVALIDDATA;
307     }
308
309     /* Rewind. Reuse probe buffer to avoid seeking. */
310     if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
311         av_free(buf);
312
313     return ret;
314 }
315
316 /* Open input file and probe the format if necessary. */
317 static int init_input(AVFormatContext *s, const char *filename,
318                       AVDictionary **options)
319 {
320     int ret;
321     AVProbeData pd = { filename, NULL, 0 };
322
323     if (s->pb) {
324         s->flags |= AVFMT_FLAG_CUSTOM_IO;
325         if (!s->iformat)
326             return av_probe_input_buffer(s->pb, &s->iformat, filename,
327                                          s, 0, s->probesize);
328         else if (s->iformat->flags & AVFMT_NOFILE)
329             return AVERROR(EINVAL);
330         return 0;
331     }
332
333     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
334         (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
335         return 0;
336
337     if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
338                           &s->interrupt_callback, options)) < 0)
339         return ret;
340     if (s->iformat)
341         return 0;
342     return av_probe_input_buffer(s->pb, &s->iformat, filename,
343                                  s, 0, s->probesize);
344 }
345
346 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
347                                AVPacketList **plast_pktl)
348 {
349     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
350     if (!pktl)
351         return NULL;
352
353     if (*packet_buffer)
354         (*plast_pktl)->next = pktl;
355     else
356         *packet_buffer = pktl;
357
358     /* Add the packet in the buffered packet list. */
359     *plast_pktl = pktl;
360     pktl->pkt   = *pkt;
361     return &pktl->pkt;
362 }
363
364 static int queue_attached_pictures(AVFormatContext *s)
365 {
366     int i;
367     for (i = 0; i < s->nb_streams; i++)
368         if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
369             s->streams[i]->discard < AVDISCARD_ALL) {
370             AVPacket copy = s->streams[i]->attached_pic;
371             copy.buf = av_buffer_ref(copy.buf);
372             if (!copy.buf)
373                 return AVERROR(ENOMEM);
374
375             add_to_pktbuf(&s->raw_packet_buffer, &copy,
376                           &s->raw_packet_buffer_end);
377         }
378     return 0;
379 }
380
381 int avformat_open_input(AVFormatContext **ps, const char *filename,
382                         AVInputFormat *fmt, AVDictionary **options)
383 {
384     AVFormatContext *s = *ps;
385     int ret = 0;
386     AVDictionary *tmp = NULL;
387     ID3v2ExtraMeta *id3v2_extra_meta = NULL;
388
389     if (!s && !(s = avformat_alloc_context()))
390         return AVERROR(ENOMEM);
391     if (fmt)
392         s->iformat = fmt;
393
394     if (options)
395         av_dict_copy(&tmp, *options, 0);
396
397     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
398         goto fail;
399
400     if ((ret = init_input(s, filename, &tmp)) < 0)
401         goto fail;
402
403     /* Check filename in case an image number is expected. */
404     if (s->iformat->flags & AVFMT_NEEDNUMBER) {
405         if (!av_filename_number_test(filename)) {
406             ret = AVERROR(EINVAL);
407             goto fail;
408         }
409     }
410
411     s->duration = s->start_time = AV_NOPTS_VALUE;
412     av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
413
414     /* Allocate private data. */
415     if (s->iformat->priv_data_size > 0) {
416         if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
417             ret = AVERROR(ENOMEM);
418             goto fail;
419         }
420         if (s->iformat->priv_class) {
421             *(const AVClass **) s->priv_data = s->iformat->priv_class;
422             av_opt_set_defaults(s->priv_data);
423             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
424                 goto fail;
425         }
426     }
427
428     /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
429     if (s->pb)
430         ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
431
432     if (s->iformat->read_header)
433         if ((ret = s->iformat->read_header(s)) < 0)
434             goto fail;
435
436     if (id3v2_extra_meta &&
437         (ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
438         goto fail;
439     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
440
441     if ((ret = queue_attached_pictures(s)) < 0)
442         goto fail;
443
444     if (s->pb && !s->data_offset)
445         s->data_offset = avio_tell(s->pb);
446
447     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
448
449     if (options) {
450         av_dict_free(options);
451         *options = tmp;
452     }
453     *ps = s;
454     return 0;
455
456 fail:
457     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
458     av_dict_free(&tmp);
459     if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
460         avio_close(s->pb);
461     avformat_free_context(s);
462     *ps = NULL;
463     return ret;
464 }
465
466 /*******************************************************/
467
468 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
469 {
470     if (st->codec->codec_id == AV_CODEC_ID_PROBE) {
471         AVProbeData *pd = &st->probe_data;
472         av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
473         --st->probe_packets;
474
475         if (pkt) {
476             int err;
477             if ((err = av_reallocp(&pd->buf, pd->buf_size + pkt->size +
478                                    AVPROBE_PADDING_SIZE)) < 0)
479                 return err;
480             memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
481             pd->buf_size += pkt->size;
482             memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
483         } else {
484             st->probe_packets = 0;
485             if (!pd->buf_size) {
486                 av_log(s, AV_LOG_ERROR,
487                        "nothing to probe for stream %d\n", st->index);
488                 return 0;
489             }
490         }
491
492         if (!st->probe_packets ||
493             av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
494             set_codec_from_probe_data(s, st, pd, st->probe_packets > 0
495                                                  ? AVPROBE_SCORE_MAX / 4 : 0);
496             if (st->codec->codec_id != AV_CODEC_ID_PROBE) {
497                 pd->buf_size = 0;
498                 av_freep(&pd->buf);
499                 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
500             }
501         }
502     }
503     return 0;
504 }
505
506 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
507 {
508     int ret, i, err;
509     AVStream *st;
510
511     for (;;) {
512         AVPacketList *pktl = s->raw_packet_buffer;
513
514         if (pktl) {
515             *pkt = pktl->pkt;
516             st   = s->streams[pkt->stream_index];
517             if (st->codec->codec_id != AV_CODEC_ID_PROBE ||
518                 !st->probe_packets ||
519                 s->raw_packet_buffer_remaining_size < pkt->size) {
520                 AVProbeData *pd;
521                 if (st->probe_packets)
522                     if ((err = probe_codec(s, st, NULL)) < 0)
523                         return err;
524                 pd = &st->probe_data;
525                 av_freep(&pd->buf);
526                 pd->buf_size = 0;
527                 s->raw_packet_buffer                 = pktl->next;
528                 s->raw_packet_buffer_remaining_size += pkt->size;
529                 av_free(pktl);
530                 return 0;
531             }
532         }
533
534         pkt->data = NULL;
535         pkt->size = 0;
536         av_init_packet(pkt);
537         ret = s->iformat->read_packet(s, pkt);
538         if (ret < 0) {
539             if (!pktl || ret == AVERROR(EAGAIN))
540                 return ret;
541             for (i = 0; i < s->nb_streams; i++) {
542                 st = s->streams[i];
543                 if (st->probe_packets)
544                     if ((err = probe_codec(s, st, NULL)) < 0)
545                         return err;
546             }
547             continue;
548         }
549
550         if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
551             (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
552             av_log(s, AV_LOG_WARNING,
553                    "Dropped corrupted packet (stream = %d)\n",
554                    pkt->stream_index);
555             av_free_packet(pkt);
556             continue;
557         }
558
559         st = s->streams[pkt->stream_index];
560
561         switch (st->codec->codec_type) {
562         case AVMEDIA_TYPE_VIDEO:
563             if (s->video_codec_id)
564                 st->codec->codec_id = s->video_codec_id;
565             break;
566         case AVMEDIA_TYPE_AUDIO:
567             if (s->audio_codec_id)
568                 st->codec->codec_id = s->audio_codec_id;
569             break;
570         case AVMEDIA_TYPE_SUBTITLE:
571             if (s->subtitle_codec_id)
572                 st->codec->codec_id = s->subtitle_codec_id;
573             break;
574         }
575
576         if (!pktl && (st->codec->codec_id != AV_CODEC_ID_PROBE ||
577                       !st->probe_packets))
578             return ret;
579
580         add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
581         s->raw_packet_buffer_remaining_size -= pkt->size;
582
583         if ((err = probe_codec(s, st, pkt)) < 0)
584             return err;
585     }
586 }
587
588 /**********************************************************/
589
590 /**
591  * Get the number of samples of an audio frame. Return -1 on error.
592  */
593 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
594 {
595     int frame_size;
596
597     /* give frame_size priority if demuxing */
598     if (!mux && enc->frame_size > 1)
599         return enc->frame_size;
600
601     if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
602         return frame_size;
603
604     /* Fall back on using frame_size if muxing. */
605     if (enc->frame_size > 1)
606         return enc->frame_size;
607
608     return -1;
609 }
610
611 /**
612  * Return the frame duration in seconds. Return 0 if not available.
613  */
614 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
615                                AVCodecParserContext *pc, AVPacket *pkt)
616 {
617     int frame_size;
618
619     *pnum = 0;
620     *pden = 0;
621     switch (st->codec->codec_type) {
622     case AVMEDIA_TYPE_VIDEO:
623         if (st->avg_frame_rate.num) {
624             *pnum = st->avg_frame_rate.den;
625             *pden = st->avg_frame_rate.num;
626         } else if (st->time_base.num * 1000LL > st->time_base.den) {
627             *pnum = st->time_base.num;
628             *pden = st->time_base.den;
629         } else if (st->codec->time_base.num * 1000LL > st->codec->time_base.den) {
630             *pnum = st->codec->time_base.num;
631             *pden = st->codec->time_base.den;
632             if (pc && pc->repeat_pict) {
633                 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
634                     *pden /= 1 + pc->repeat_pict;
635                 else
636                     *pnum *= 1 + pc->repeat_pict;
637             }
638             /* If this codec can be interlaced or progressive then we need
639              * a parser to compute duration of a packet. Thus if we have
640              * no parser in such case leave duration undefined. */
641             if (st->codec->ticks_per_frame > 1 && !pc)
642                 *pnum = *pden = 0;
643         }
644         break;
645     case AVMEDIA_TYPE_AUDIO:
646         frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
647         if (frame_size <= 0 || st->codec->sample_rate <= 0)
648             break;
649         *pnum = frame_size;
650         *pden = st->codec->sample_rate;
651         break;
652     default:
653         break;
654     }
655 }
656
657 static int is_intra_only(enum AVCodecID id)
658 {
659     const AVCodecDescriptor *d = avcodec_descriptor_get(id);
660     if (!d)
661         return 0;
662     if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
663         return 0;
664     return 1;
665 }
666
667 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
668                                       int64_t dts, int64_t pts)
669 {
670     AVStream *st       = s->streams[stream_index];
671     AVPacketList *pktl = s->packet_buffer;
672
673     if (st->first_dts != AV_NOPTS_VALUE ||
674         dts           == AV_NOPTS_VALUE ||
675         st->cur_dts   == AV_NOPTS_VALUE)
676         return;
677
678     st->first_dts = dts - st->cur_dts;
679     st->cur_dts   = dts;
680
681     for (; pktl; pktl = pktl->next) {
682         if (pktl->pkt.stream_index != stream_index)
683             continue;
684         // FIXME: think more about this check
685         if (pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
686             pktl->pkt.pts += st->first_dts;
687
688         if (pktl->pkt.dts != AV_NOPTS_VALUE)
689             pktl->pkt.dts += st->first_dts;
690
691         if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
692             st->start_time = pktl->pkt.pts;
693     }
694     if (st->start_time == AV_NOPTS_VALUE)
695         st->start_time = pts;
696 }
697
698 static void update_initial_durations(AVFormatContext *s, AVStream *st,
699                                      int stream_index, int duration)
700 {
701     AVPacketList *pktl = s->packet_buffer;
702     int64_t cur_dts    = 0;
703
704     if (st->first_dts != AV_NOPTS_VALUE) {
705         cur_dts = st->first_dts;
706         for (; pktl; pktl = pktl->next) {
707             if (pktl->pkt.stream_index == stream_index) {
708                 if (pktl->pkt.pts != pktl->pkt.dts  ||
709                     pktl->pkt.dts != AV_NOPTS_VALUE ||
710                     pktl->pkt.duration)
711                     break;
712                 cur_dts -= duration;
713             }
714         }
715         pktl          = s->packet_buffer;
716         st->first_dts = cur_dts;
717     } else if (st->cur_dts)
718         return;
719
720     for (; pktl; pktl = pktl->next) {
721         if (pktl->pkt.stream_index != stream_index)
722             continue;
723         if (pktl->pkt.pts == pktl->pkt.dts  &&
724             pktl->pkt.dts == AV_NOPTS_VALUE &&
725             !pktl->pkt.duration) {
726             pktl->pkt.dts = cur_dts;
727             if (!st->codec->has_b_frames)
728                 pktl->pkt.pts = cur_dts;
729             cur_dts += duration;
730             if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
731                 pktl->pkt.duration = duration;
732         } else
733             break;
734     }
735     if (st->first_dts == AV_NOPTS_VALUE)
736         st->cur_dts = cur_dts;
737 }
738
739 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
740                                AVCodecParserContext *pc, AVPacket *pkt)
741 {
742     int num, den, presentation_delayed, delay, i;
743     int64_t offset;
744
745     if (s->flags & AVFMT_FLAG_NOFILLIN)
746         return;
747
748     if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
749         pkt->dts = AV_NOPTS_VALUE;
750
751     /* do we have a video B-frame ? */
752     delay = st->codec->has_b_frames;
753     presentation_delayed = 0;
754
755     /* XXX: need has_b_frame, but cannot get it if the codec is
756      *  not initialized */
757     if (delay &&
758         pc && pc->pict_type != AV_PICTURE_TYPE_B)
759         presentation_delayed = 1;
760
761     if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
762         st->pts_wrap_bits < 63 &&
763         pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
764         pkt->dts -= 1LL << st->pts_wrap_bits;
765     }
766
767     /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
768      * We take the conservative approach and discard both.
769      * Note: If this is misbehaving for an H.264 file, then possibly
770      * presentation_delayed is not set correctly. */
771     if (delay == 1 && pkt->dts == pkt->pts &&
772         pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
773         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
774         pkt->dts = pkt->pts = AV_NOPTS_VALUE;
775     }
776
777     if (pkt->duration == 0 && st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
778         ff_compute_frame_duration(&num, &den, st, pc, pkt);
779         if (den && num) {
780             pkt->duration = av_rescale_rnd(1, num * (int64_t) st->time_base.den,
781                                            den * (int64_t) st->time_base.num,
782                                            AV_ROUND_DOWN);
783
784             if (pkt->duration != 0 && s->packet_buffer)
785                 update_initial_durations(s, st, pkt->stream_index,
786                                          pkt->duration);
787         }
788     }
789
790     /* Correct timestamps with byte offset if demuxers only have timestamps
791      * on packet boundaries */
792     if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
793         /* this will estimate bitrate based on this frame's duration and size */
794         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
795         if (pkt->pts != AV_NOPTS_VALUE)
796             pkt->pts += offset;
797         if (pkt->dts != AV_NOPTS_VALUE)
798             pkt->dts += offset;
799     }
800
801     /* This may be redundant, but it should not hurt. */
802     if (pkt->dts != AV_NOPTS_VALUE &&
803         pkt->pts != AV_NOPTS_VALUE &&
804         pkt->pts > pkt->dts)
805         presentation_delayed = 1;
806
807     av_dlog(NULL,
808             "IN delayed:%d pts:%"PRId64", dts:%"PRId64" "
809             "cur_dts:%"PRId64" st:%d pc:%p\n",
810             presentation_delayed, pkt->pts, pkt->dts, st->cur_dts,
811             pkt->stream_index, pc);
812     /* Interpolate PTS and DTS if they are not present. We skip H.264
813      * currently because delay and has_b_frames are not reliably set. */
814     if ((delay == 0 || (delay == 1 && pc)) &&
815         st->codec->codec_id != AV_CODEC_ID_H264) {
816         if (presentation_delayed) {
817             /* DTS = decompression timestamp */
818             /* PTS = presentation timestamp */
819             if (pkt->dts == AV_NOPTS_VALUE)
820                 pkt->dts = st->last_IP_pts;
821             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
822             if (pkt->dts == AV_NOPTS_VALUE)
823                 pkt->dts = st->cur_dts;
824
825             /* This is tricky: the dts must be incremented by the duration
826              * of the frame we are displaying, i.e. the last I- or P-frame. */
827             if (st->last_IP_duration == 0)
828                 st->last_IP_duration = pkt->duration;
829             if (pkt->dts != AV_NOPTS_VALUE)
830                 st->cur_dts = pkt->dts + st->last_IP_duration;
831             st->last_IP_duration = pkt->duration;
832             st->last_IP_pts      = pkt->pts;
833             /* Cannot compute PTS if not present (we can compute it only
834              * by knowing the future. */
835         } else if (pkt->pts != AV_NOPTS_VALUE ||
836                    pkt->dts != AV_NOPTS_VALUE ||
837                    pkt->duration              ||
838                    st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
839             int duration = pkt->duration;
840             if (!duration && st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
841                 ff_compute_frame_duration(&num, &den, st, pc, pkt);
842                 if (den && num) {
843                     duration = av_rescale_rnd(1,
844                                               num * (int64_t) st->time_base.den,
845                                               den * (int64_t) st->time_base.num,
846                                               AV_ROUND_DOWN);
847                     if (duration != 0 && s->packet_buffer)
848                         update_initial_durations(s, st, pkt->stream_index,
849                                                  duration);
850                 }
851             }
852
853             if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE ||
854                 duration) {
855                 /* presentation is not delayed : PTS and DTS are the same */
856                 if (pkt->pts == AV_NOPTS_VALUE)
857                     pkt->pts = pkt->dts;
858                 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
859                                           pkt->pts);
860                 if (pkt->pts == AV_NOPTS_VALUE)
861                     pkt->pts = st->cur_dts;
862                 pkt->dts = pkt->pts;
863                 if (pkt->pts != AV_NOPTS_VALUE)
864                     st->cur_dts = pkt->pts + duration;
865             }
866         }
867     }
868
869     if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
870         st->pts_buffer[0] = pkt->pts;
871         for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
872             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
873         if (pkt->dts == AV_NOPTS_VALUE)
874             pkt->dts = st->pts_buffer[0];
875         // We skipped it above so we try here.
876         if (st->codec->codec_id == AV_CODEC_ID_H264)
877             // This should happen on the first packet
878             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
879         if (pkt->dts > st->cur_dts)
880             st->cur_dts = pkt->dts;
881     }
882
883     av_dlog(NULL,
884             "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n",
885             presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
886
887     /* update flags */
888     if (is_intra_only(st->codec->codec_id))
889         pkt->flags |= AV_PKT_FLAG_KEY;
890     if (pc)
891         pkt->convergence_duration = pc->convergence_duration;
892 }
893
894 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
895 {
896     while (*pkt_buf) {
897         AVPacketList *pktl = *pkt_buf;
898         *pkt_buf = pktl->next;
899         av_free_packet(&pktl->pkt);
900         av_freep(&pktl);
901     }
902     *pkt_buf_end = NULL;
903 }
904
905 /**
906  * Parse a packet, add all split parts to parse_queue.
907  *
908  * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
909  */
910 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
911 {
912     AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
913     AVStream *st = s->streams[stream_index];
914     uint8_t *data = pkt ? pkt->data : NULL;
915     int size      = pkt ? pkt->size : 0;
916     int ret = 0, got_output = 0;
917
918     if (!pkt) {
919         av_init_packet(&flush_pkt);
920         pkt        = &flush_pkt;
921         got_output = 1;
922     }
923
924     while (size > 0 || (pkt == &flush_pkt && got_output)) {
925         int len;
926
927         av_init_packet(&out_pkt);
928         len = av_parser_parse2(st->parser, st->codec,
929                                &out_pkt.data, &out_pkt.size, data, size,
930                                pkt->pts, pkt->dts, pkt->pos);
931
932         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
933         /* increment read pointer */
934         data += len;
935         size -= len;
936
937         got_output = !!out_pkt.size;
938
939         if (!out_pkt.size)
940             continue;
941
942         if (pkt->side_data) {
943             out_pkt.side_data       = pkt->side_data;
944             out_pkt.side_data_elems = pkt->side_data_elems;
945             pkt->side_data          = NULL;
946             pkt->side_data_elems    = 0;
947         }
948
949         /* set the duration */
950         out_pkt.duration = 0;
951         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
952             if (st->codec->sample_rate > 0) {
953                 out_pkt.duration =
954                     av_rescale_q_rnd(st->parser->duration,
955                                      (AVRational) { 1, st->codec->sample_rate },
956                                      st->time_base,
957                                      AV_ROUND_DOWN);
958             }
959         }
960
961         out_pkt.stream_index = st->index;
962         out_pkt.pts          = st->parser->pts;
963         out_pkt.dts          = st->parser->dts;
964         out_pkt.pos          = st->parser->pos;
965
966         if (st->parser->key_frame == 1 ||
967             (st->parser->key_frame == -1 &&
968              st->parser->pict_type == AV_PICTURE_TYPE_I))
969             out_pkt.flags |= AV_PKT_FLAG_KEY;
970
971         compute_pkt_fields(s, st, st->parser, &out_pkt);
972
973         if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
974             out_pkt.flags & AV_PKT_FLAG_KEY) {
975             ff_reduce_index(s, st->index);
976             av_add_index_entry(st, st->parser->frame_offset, out_pkt.dts,
977                                0, 0, AVINDEX_KEYFRAME);
978         }
979
980         if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
981             out_pkt.buf = pkt->buf;
982             pkt->buf    = NULL;
983 #if FF_API_DESTRUCT_PACKET
984 FF_DISABLE_DEPRECATION_WARNINGS
985             out_pkt.destruct = pkt->destruct;
986             pkt->destruct = NULL;
987 FF_ENABLE_DEPRECATION_WARNINGS
988 #endif
989         }
990         if ((ret = av_dup_packet(&out_pkt)) < 0)
991             goto fail;
992
993         if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
994             av_free_packet(&out_pkt);
995             ret = AVERROR(ENOMEM);
996             goto fail;
997         }
998     }
999
1000     /* end of the stream => close and free the parser */
1001     if (pkt == &flush_pkt) {
1002         av_parser_close(st->parser);
1003         st->parser = NULL;
1004     }
1005
1006 fail:
1007     av_free_packet(pkt);
1008     return ret;
1009 }
1010
1011 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1012                                    AVPacketList **pkt_buffer_end,
1013                                    AVPacket      *pkt)
1014 {
1015     AVPacketList *pktl;
1016     av_assert0(*pkt_buffer);
1017     pktl        = *pkt_buffer;
1018     *pkt        = pktl->pkt;
1019     *pkt_buffer = pktl->next;
1020     if (!pktl->next)
1021         *pkt_buffer_end = NULL;
1022     av_freep(&pktl);
1023     return 0;
1024 }
1025
1026 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1027 {
1028     int ret = 0, i, got_packet = 0;
1029
1030     av_init_packet(pkt);
1031
1032     while (!got_packet && !s->parse_queue) {
1033         AVStream *st;
1034         AVPacket cur_pkt;
1035
1036         /* read next packet */
1037         ret = ff_read_packet(s, &cur_pkt);
1038         if (ret < 0) {
1039             if (ret == AVERROR(EAGAIN))
1040                 return ret;
1041             /* flush the parsers */
1042             for (i = 0; i < s->nb_streams; i++) {
1043                 st = s->streams[i];
1044                 if (st->parser && st->need_parsing)
1045                     parse_packet(s, NULL, st->index);
1046             }
1047             /* all remaining packets are now in parse_queue =>
1048              * really terminate parsing */
1049             break;
1050         }
1051         ret = 0;
1052         st  = s->streams[cur_pkt.stream_index];
1053
1054         if (cur_pkt.pts != AV_NOPTS_VALUE &&
1055             cur_pkt.dts != AV_NOPTS_VALUE &&
1056             cur_pkt.pts < cur_pkt.dts) {
1057             av_log(s, AV_LOG_WARNING,
1058                    "Invalid timestamps stream=%d, pts=%"PRId64", "
1059                    "dts=%"PRId64", size=%d\n",
1060                    cur_pkt.stream_index, cur_pkt.pts,
1061                    cur_pkt.dts, cur_pkt.size);
1062         }
1063         if (s->debug & FF_FDEBUG_TS)
1064             av_log(s, AV_LOG_DEBUG,
1065                    "ff_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", "
1066                    "size=%d, duration=%d, flags=%d\n",
1067                    cur_pkt.stream_index, cur_pkt.pts, cur_pkt.dts,
1068                    cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1069
1070         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1071             st->parser = av_parser_init(st->codec->codec_id);
1072             if (!st->parser)
1073                 /* no parser available: just output the raw packets */
1074                 st->need_parsing = AVSTREAM_PARSE_NONE;
1075             else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1076                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1077             else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1078                 st->parser->flags |= PARSER_FLAG_ONCE;
1079         }
1080
1081         if (!st->need_parsing || !st->parser) {
1082             /* no parsing needed: we just output the packet as is */
1083             *pkt = cur_pkt;
1084             compute_pkt_fields(s, st, NULL, pkt);
1085             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1086                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1087                 ff_reduce_index(s, st->index);
1088                 av_add_index_entry(st, pkt->pos, pkt->dts,
1089                                    0, 0, AVINDEX_KEYFRAME);
1090             }
1091             got_packet = 1;
1092         } else if (st->discard < AVDISCARD_ALL) {
1093             if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1094                 return ret;
1095         } else {
1096             /* free packet */
1097             av_free_packet(&cur_pkt);
1098         }
1099     }
1100
1101     if (!got_packet && s->parse_queue)
1102         ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1103
1104     if (s->debug & FF_FDEBUG_TS)
1105         av_log(s, AV_LOG_DEBUG,
1106                "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", "
1107                "size=%d, duration=%d, flags=%d\n",
1108                pkt->stream_index, pkt->pts, pkt->dts,
1109                pkt->size, pkt->duration, pkt->flags);
1110
1111     return ret;
1112 }
1113
1114 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1115 {
1116     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1117     int eof = 0;
1118
1119     if (!genpts)
1120         return s->packet_buffer
1121                ? read_from_packet_buffer(&s->packet_buffer,
1122                                          &s->packet_buffer_end, pkt)
1123                : read_frame_internal(s, pkt);
1124
1125     for (;;) {
1126         int ret;
1127         AVPacketList *pktl = s->packet_buffer;
1128
1129         if (pktl) {
1130             AVPacket *next_pkt = &pktl->pkt;
1131
1132             if (next_pkt->dts != AV_NOPTS_VALUE) {
1133                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1134                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1135                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1136                         (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0) &&
1137                          av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1138                         // not B-frame
1139                         next_pkt->pts = pktl->pkt.dts;
1140                     }
1141                     pktl = pktl->next;
1142                 }
1143                 pktl = s->packet_buffer;
1144             }
1145
1146             /* read packet from packet buffer, if there is data */
1147             if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1148                   next_pkt->dts != AV_NOPTS_VALUE && !eof))
1149                 return read_from_packet_buffer(&s->packet_buffer,
1150                                                &s->packet_buffer_end, pkt);
1151         }
1152
1153         ret = read_frame_internal(s, pkt);
1154         if (ret < 0) {
1155             if (pktl && ret != AVERROR(EAGAIN)) {
1156                 eof = 1;
1157                 continue;
1158             } else
1159                 return ret;
1160         }
1161
1162         if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1163                                         &s->packet_buffer_end)) < 0)
1164             return AVERROR(ENOMEM);
1165     }
1166 }
1167
1168 /* XXX: suppress the packet queue */
1169 static void flush_packet_queue(AVFormatContext *s)
1170 {
1171     free_packet_buffer(&s->parse_queue,       &s->parse_queue_end);
1172     free_packet_buffer(&s->packet_buffer,     &s->packet_buffer_end);
1173     free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1174
1175     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1176 }
1177
1178 /*******************************************************/
1179 /* seek support */
1180
1181 int av_find_default_stream_index(AVFormatContext *s)
1182 {
1183     int first_audio_index = -1;
1184     int i;
1185     AVStream *st;
1186
1187     if (s->nb_streams <= 0)
1188         return -1;
1189     for (i = 0; i < s->nb_streams; i++) {
1190         st = s->streams[i];
1191         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1192             !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1193             return i;
1194         }
1195         if (first_audio_index < 0 &&
1196             st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1197             first_audio_index = i;
1198     }
1199     return first_audio_index >= 0 ? first_audio_index : 0;
1200 }
1201
1202 /** Flush the frame reader. */
1203 void ff_read_frame_flush(AVFormatContext *s)
1204 {
1205     AVStream *st;
1206     int i, j;
1207
1208     flush_packet_queue(s);
1209
1210     /* Reset read state for each stream. */
1211     for (i = 0; i < s->nb_streams; i++) {
1212         st = s->streams[i];
1213
1214         if (st->parser) {
1215             av_parser_close(st->parser);
1216             st->parser = NULL;
1217         }
1218         st->last_IP_pts = AV_NOPTS_VALUE;
1219         /* We set the current DTS to an unspecified origin. */
1220         st->cur_dts     = AV_NOPTS_VALUE;
1221
1222         st->probe_packets = MAX_PROBE_PACKETS;
1223
1224         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1225             st->pts_buffer[j] = AV_NOPTS_VALUE;
1226     }
1227 }
1228
1229 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1230 {
1231     int i;
1232
1233     for (i = 0; i < s->nb_streams; i++) {
1234         AVStream *st = s->streams[i];
1235
1236         st->cur_dts =
1237             av_rescale(timestamp,
1238                        st->time_base.den * (int64_t) ref_st->time_base.num,
1239                        st->time_base.num * (int64_t) ref_st->time_base.den);
1240     }
1241 }
1242
1243 void ff_reduce_index(AVFormatContext *s, int stream_index)
1244 {
1245     AVStream *st             = s->streams[stream_index];
1246     unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1247
1248     if ((unsigned) st->nb_index_entries >= max_entries) {
1249         int i;
1250         for (i = 0; 2 * i < st->nb_index_entries; i++)
1251             st->index_entries[i] = st->index_entries[2 * i];
1252         st->nb_index_entries = i;
1253     }
1254 }
1255
1256 int ff_add_index_entry(AVIndexEntry **index_entries,
1257                        int *nb_index_entries,
1258                        unsigned int *index_entries_allocated_size,
1259                        int64_t pos, int64_t timestamp,
1260                        int size, int distance, int flags)
1261 {
1262     AVIndexEntry *entries, *ie;
1263     int index;
1264
1265     if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1266         return -1;
1267
1268     entries = av_fast_realloc(*index_entries,
1269                               index_entries_allocated_size,
1270                               (*nb_index_entries + 1) *
1271                               sizeof(AVIndexEntry));
1272     if (!entries)
1273         return -1;
1274
1275     *index_entries = entries;
1276
1277     index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1278                                       timestamp, AVSEEK_FLAG_ANY);
1279
1280     if (index < 0) {
1281         index = (*nb_index_entries)++;
1282         ie    = &entries[index];
1283         assert(index == 0 || ie[-1].timestamp < timestamp);
1284     } else {
1285         ie = &entries[index];
1286         if (ie->timestamp != timestamp) {
1287             if (ie->timestamp <= timestamp)
1288                 return -1;
1289             memmove(entries + index + 1, entries + index,
1290                     sizeof(AVIndexEntry) * (*nb_index_entries - index));
1291             (*nb_index_entries)++;
1292         } else if (ie->pos == pos && distance < ie->min_distance)
1293             // do not reduce the distance
1294             distance = ie->min_distance;
1295     }
1296
1297     ie->pos          = pos;
1298     ie->timestamp    = timestamp;
1299     ie->min_distance = distance;
1300     ie->size         = size;
1301     ie->flags        = flags;
1302
1303     return index;
1304 }
1305
1306 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1307                        int size, int distance, int flags)
1308 {
1309     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1310                               &st->index_entries_allocated_size, pos,
1311                               timestamp, size, distance, flags);
1312 }
1313
1314 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1315                               int64_t wanted_timestamp, int flags)
1316 {
1317     int a, b, m;
1318     int64_t timestamp;
1319
1320     a = -1;
1321     b = nb_entries;
1322
1323     // Optimize appending index entries at the end.
1324     if (b && entries[b - 1].timestamp < wanted_timestamp)
1325         a = b - 1;
1326
1327     while (b - a > 1) {
1328         m         = (a + b) >> 1;
1329         timestamp = entries[m].timestamp;
1330         if (timestamp >= wanted_timestamp)
1331             b = m;
1332         if (timestamp <= wanted_timestamp)
1333             a = m;
1334     }
1335     m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1336
1337     if (!(flags & AVSEEK_FLAG_ANY))
1338         while (m >= 0 && m < nb_entries &&
1339                !(entries[m].flags & AVINDEX_KEYFRAME))
1340             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1341
1342     if (m == nb_entries)
1343         return -1;
1344     return m;
1345 }
1346
1347 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1348 {
1349     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1350                                      wanted_timestamp, flags);
1351 }
1352
1353 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1354                          int64_t target_ts, int flags)
1355 {
1356     AVInputFormat *avif = s->iformat;
1357     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1358     int64_t ts_min, ts_max, ts;
1359     int index;
1360     int64_t ret;
1361     AVStream *st;
1362
1363     if (stream_index < 0)
1364         return -1;
1365
1366     av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1367
1368     ts_max =
1369     ts_min = AV_NOPTS_VALUE;
1370     pos_limit = -1; // GCC falsely says it may be uninitialized.
1371
1372     st = s->streams[stream_index];
1373     if (st->index_entries) {
1374         AVIndexEntry *e;
1375
1376         /* FIXME: Whole function must be checked for non-keyframe entries in
1377          * index case, especially read_timestamp(). */
1378         index = av_index_search_timestamp(st, target_ts,
1379                                           flags | AVSEEK_FLAG_BACKWARD);
1380         index = FFMAX(index, 0);
1381         e     = &st->index_entries[index];
1382
1383         if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1384             pos_min = e->pos;
1385             ts_min  = e->timestamp;
1386             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1387                     pos_min, ts_min);
1388         } else {
1389             assert(index == 0);
1390         }
1391
1392         index = av_index_search_timestamp(st, target_ts,
1393                                           flags & ~AVSEEK_FLAG_BACKWARD);
1394         assert(index < st->nb_index_entries);
1395         if (index >= 0) {
1396             e = &st->index_entries[index];
1397             assert(e->timestamp >= target_ts);
1398             pos_max   = e->pos;
1399             ts_max    = e->timestamp;
1400             pos_limit = pos_max - e->min_distance;
1401             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1402                     " dts_max=%"PRId64"\n", pos_max, pos_limit, ts_max);
1403         }
1404     }
1405
1406     pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1407                         ts_min, ts_max, flags, &ts, avif->read_timestamp);
1408     if (pos < 0)
1409         return -1;
1410
1411     /* do the seek */
1412     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1413         return ret;
1414
1415     ff_update_cur_dts(s, st, ts);
1416
1417     return 0;
1418 }
1419
1420 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1421                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1422                       int64_t ts_min, int64_t ts_max,
1423                       int flags, int64_t *ts_ret,
1424                       int64_t (*read_timestamp)(struct AVFormatContext *, int,
1425                                                 int64_t *, int64_t))
1426 {
1427     int64_t pos, ts;
1428     int64_t start_pos, filesize;
1429     int no_change;
1430
1431     av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1432
1433     if (ts_min == AV_NOPTS_VALUE) {
1434         pos_min = s->data_offset;
1435         ts_min  = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1436         if (ts_min == AV_NOPTS_VALUE)
1437             return -1;
1438     }
1439
1440     if (ts_max == AV_NOPTS_VALUE) {
1441         int step = 1024;
1442         filesize = avio_size(s->pb);
1443         pos_max  = filesize - 1;
1444         do {
1445             pos_max -= step;
1446             ts_max   = read_timestamp(s, stream_index, &pos_max,
1447                                       pos_max + step);
1448             step    += step;
1449         } while (ts_max == AV_NOPTS_VALUE && pos_max >= step);
1450         if (ts_max == AV_NOPTS_VALUE)
1451             return -1;
1452
1453         for (;;) {
1454             int64_t tmp_pos = pos_max + 1;
1455             int64_t tmp_ts  = read_timestamp(s, stream_index,
1456                                              &tmp_pos, INT64_MAX);
1457             if (tmp_ts == AV_NOPTS_VALUE)
1458                 break;
1459             ts_max  = tmp_ts;
1460             pos_max = tmp_pos;
1461             if (tmp_pos >= filesize)
1462                 break;
1463         }
1464         pos_limit = pos_max;
1465     }
1466
1467     if (ts_min > ts_max)
1468         return -1;
1469     else if (ts_min == ts_max)
1470         pos_limit = pos_min;
1471
1472     no_change = 0;
1473     while (pos_min < pos_limit) {
1474         av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64
1475                 " dts_max=%"PRId64"\n", pos_min, pos_max, ts_min, ts_max);
1476         assert(pos_limit <= pos_max);
1477
1478         if (no_change == 0) {
1479             int64_t approximate_keyframe_distance = pos_max - pos_limit;
1480             // interpolate position (better than dichotomy)
1481             pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1482                              ts_max - ts_min) +
1483                   pos_min - approximate_keyframe_distance;
1484         } else if (no_change == 1) {
1485             // bisection if interpolation did not change min / max pos last time
1486             pos = (pos_min + pos_limit) >> 1;
1487         } else {
1488             /* linear search if bisection failed, can only happen if there
1489              * are very few or no keyframes between min/max */
1490             pos = pos_min;
1491         }
1492         if (pos <= pos_min)
1493             pos = pos_min + 1;
1494         else if (pos > pos_limit)
1495             pos = pos_limit;
1496         start_pos = pos;
1497
1498         // May pass pos_limit instead of -1.
1499         ts = read_timestamp(s, stream_index, &pos, INT64_MAX);
1500         if (pos == pos_max)
1501             no_change++;
1502         else
1503             no_change = 0;
1504         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64
1505                 " target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1506                 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1507                 pos_limit, start_pos, no_change);
1508         if (ts == AV_NOPTS_VALUE) {
1509             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1510             return -1;
1511         }
1512         assert(ts != AV_NOPTS_VALUE);
1513         if (target_ts <= ts) {
1514             pos_limit = start_pos - 1;
1515             pos_max   = pos;
1516             ts_max    = ts;
1517         }
1518         if (target_ts >= ts) {
1519             pos_min = pos;
1520             ts_min  = ts;
1521         }
1522     }
1523
1524     pos     = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1525     ts      = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min  : ts_max;
1526     pos_min = pos;
1527     ts_min  = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1528     pos_min++;
1529     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1530     av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1531             pos, ts_min, target_ts, ts_max);
1532     *ts_ret = ts;
1533     return pos;
1534 }
1535
1536 static int seek_frame_byte(AVFormatContext *s, int stream_index,
1537                            int64_t pos, int flags)
1538 {
1539     int64_t pos_min, pos_max;
1540
1541     pos_min = s->data_offset;
1542     pos_max = avio_size(s->pb) - 1;
1543
1544     if (pos < pos_min)
1545         pos = pos_min;
1546     else if (pos > pos_max)
1547         pos = pos_max;
1548
1549     avio_seek(s->pb, pos, SEEK_SET);
1550
1551     return 0;
1552 }
1553
1554 static int seek_frame_generic(AVFormatContext *s, int stream_index,
1555                               int64_t timestamp, int flags)
1556 {
1557     int index;
1558     int64_t ret;
1559     AVStream *st;
1560     AVIndexEntry *ie;
1561
1562     st = s->streams[stream_index];
1563
1564     index = av_index_search_timestamp(st, timestamp, flags);
1565
1566     if (index < 0 && st->nb_index_entries &&
1567         timestamp < st->index_entries[0].timestamp)
1568         return -1;
1569
1570     if (index < 0 || index == st->nb_index_entries - 1) {
1571         AVPacket pkt;
1572
1573         if (st->nb_index_entries) {
1574             assert(st->index_entries);
1575             ie = &st->index_entries[st->nb_index_entries - 1];
1576             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1577                 return ret;
1578             ff_update_cur_dts(s, st, ie->timestamp);
1579         } else {
1580             if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1581                 return ret;
1582         }
1583         for (;;) {
1584             int read_status;
1585             do {
1586                 read_status = av_read_frame(s, &pkt);
1587             } while (read_status == AVERROR(EAGAIN));
1588             if (read_status < 0)
1589                 break;
1590             av_free_packet(&pkt);
1591             if (stream_index == pkt.stream_index)
1592                 if ((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1593                     break;
1594         }
1595         index = av_index_search_timestamp(st, timestamp, flags);
1596     }
1597     if (index < 0)
1598         return -1;
1599
1600     ff_read_frame_flush(s);
1601     if (s->iformat->read_seek)
1602         if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1603             return 0;
1604     ie = &st->index_entries[index];
1605     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1606         return ret;
1607     ff_update_cur_dts(s, st, ie->timestamp);
1608
1609     return 0;
1610 }
1611
1612 static int seek_frame_internal(AVFormatContext *s, int stream_index,
1613                                int64_t timestamp, int flags)
1614 {
1615     int ret;
1616     AVStream *st;
1617
1618     if (flags & AVSEEK_FLAG_BYTE) {
1619         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1620             return -1;
1621         ff_read_frame_flush(s);
1622         return seek_frame_byte(s, stream_index, timestamp, flags);
1623     }
1624
1625     if (stream_index < 0) {
1626         stream_index = av_find_default_stream_index(s);
1627         if (stream_index < 0)
1628             return -1;
1629
1630         st = s->streams[stream_index];
1631         /* timestamp for default must be expressed in AV_TIME_BASE units */
1632         timestamp = av_rescale(timestamp, st->time_base.den,
1633                                AV_TIME_BASE * (int64_t) st->time_base.num);
1634     }
1635
1636     /* first, we try the format specific seek */
1637     if (s->iformat->read_seek) {
1638         ff_read_frame_flush(s);
1639         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1640     } else
1641         ret = -1;
1642     if (ret >= 0)
1643         return 0;
1644
1645     if (s->iformat->read_timestamp &&
1646         !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1647         ff_read_frame_flush(s);
1648         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1649     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1650         ff_read_frame_flush(s);
1651         return seek_frame_generic(s, stream_index, timestamp, flags);
1652     } else
1653         return -1;
1654 }
1655
1656 int av_seek_frame(AVFormatContext *s, int stream_index,
1657                   int64_t timestamp, int flags)
1658 {
1659     int ret = seek_frame_internal(s, stream_index, timestamp, flags);
1660
1661     if (ret >= 0)
1662         ret = queue_attached_pictures(s);
1663
1664     return ret;
1665 }
1666
1667 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
1668                        int64_t ts, int64_t max_ts, int flags)
1669 {
1670     if (min_ts > ts || max_ts < ts)
1671         return -1;
1672
1673     if (s->iformat->read_seek2) {
1674         int ret;
1675         ff_read_frame_flush(s);
1676         ret = s->iformat->read_seek2(s, stream_index, min_ts,
1677                                      ts, max_ts, flags);
1678
1679         if (ret >= 0)
1680             ret = queue_attached_pictures(s);
1681         return ret;
1682     }
1683
1684     if (s->iformat->read_timestamp) {
1685         // try to seek via read_timestamp()
1686     }
1687
1688     // Fall back on old API if new is not implemented but old is.
1689     // Note the old API has somewhat different semantics.
1690     if (s->iformat->read_seek || 1)
1691         return av_seek_frame(s, stream_index, ts,
1692                              flags | ((uint64_t) ts - min_ts >
1693                                       (uint64_t) max_ts - ts
1694                                       ? AVSEEK_FLAG_BACKWARD : 0));
1695
1696     // try some generic seek like seek_frame_generic() but with new ts semantics
1697 }
1698
1699 /*******************************************************/
1700
1701 /**
1702  * Return TRUE if the stream has accurate duration in any stream.
1703  *
1704  * @return TRUE if the stream has accurate duration for at least one component.
1705  */
1706 static int has_duration(AVFormatContext *ic)
1707 {
1708     int i;
1709     AVStream *st;
1710
1711     for (i = 0; i < ic->nb_streams; i++) {
1712         st = ic->streams[i];
1713         if (st->duration != AV_NOPTS_VALUE)
1714             return 1;
1715     }
1716     if (ic->duration != AV_NOPTS_VALUE)
1717         return 1;
1718     return 0;
1719 }
1720
1721 /**
1722  * Estimate the stream timings from the one of each components.
1723  *
1724  * Also computes the global bitrate if possible.
1725  */
1726 static void update_stream_timings(AVFormatContext *ic)
1727 {
1728     int64_t start_time, start_time1, end_time, end_time1;
1729     int64_t duration, duration1, filesize;
1730     int i;
1731     AVStream *st;
1732
1733     start_time = INT64_MAX;
1734     end_time   = INT64_MIN;
1735     duration   = INT64_MIN;
1736     for (i = 0; i < ic->nb_streams; i++) {
1737         st = ic->streams[i];
1738         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1739             start_time1 = av_rescale_q(st->start_time, st->time_base,
1740                                        AV_TIME_BASE_Q);
1741             start_time  = FFMIN(start_time, start_time1);
1742             if (st->duration != AV_NOPTS_VALUE) {
1743                 end_time1 = start_time1 +
1744                             av_rescale_q(st->duration, st->time_base,
1745                                          AV_TIME_BASE_Q);
1746                 end_time = FFMAX(end_time, end_time1);
1747             }
1748         }
1749         if (st->duration != AV_NOPTS_VALUE) {
1750             duration1 = av_rescale_q(st->duration, st->time_base,
1751                                      AV_TIME_BASE_Q);
1752             duration  = FFMAX(duration, duration1);
1753         }
1754     }
1755     if (start_time != INT64_MAX) {
1756         ic->start_time = start_time;
1757         if (end_time != INT64_MIN)
1758             duration = FFMAX(duration, end_time - start_time);
1759     }
1760     if (duration != INT64_MIN) {
1761         ic->duration = duration;
1762         if (ic->pb && (filesize = avio_size(ic->pb)) > 0)
1763             /* compute the bitrate */
1764             ic->bit_rate = (double) filesize * 8.0 * AV_TIME_BASE /
1765                            (double) ic->duration;
1766     }
1767 }
1768
1769 static void fill_all_stream_timings(AVFormatContext *ic)
1770 {
1771     int i;
1772     AVStream *st;
1773
1774     update_stream_timings(ic);
1775     for (i = 0; i < ic->nb_streams; i++) {
1776         st = ic->streams[i];
1777         if (st->start_time == AV_NOPTS_VALUE) {
1778             if (ic->start_time != AV_NOPTS_VALUE)
1779                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
1780                                               st->time_base);
1781             if (ic->duration != AV_NOPTS_VALUE)
1782                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
1783                                             st->time_base);
1784         }
1785     }
1786 }
1787
1788 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1789 {
1790     int64_t filesize, duration;
1791     int i;
1792     AVStream *st;
1793
1794     /* if bit_rate is already set, we believe it */
1795     if (ic->bit_rate <= 0) {
1796         int bit_rate = 0;
1797         for (i = 0; i < ic->nb_streams; i++) {
1798             st = ic->streams[i];
1799             if (st->codec->bit_rate > 0) {
1800                 if (INT_MAX - st->codec->bit_rate < bit_rate) {
1801                     bit_rate = 0;
1802                     break;
1803                 }
1804                 bit_rate += st->codec->bit_rate;
1805             }
1806         }
1807         ic->bit_rate = bit_rate;
1808     }
1809
1810     /* if duration is already set, we believe it */
1811     if (ic->duration == AV_NOPTS_VALUE &&
1812         ic->bit_rate != 0) {
1813         filesize = ic->pb ? avio_size(ic->pb) : 0;
1814         if (filesize > 0) {
1815             for (i = 0; i < ic->nb_streams; i++) {
1816                 st       = ic->streams[i];
1817                 duration = av_rescale(8 * filesize, st->time_base.den,
1818                                       ic->bit_rate *
1819                                       (int64_t) st->time_base.num);
1820                 if (st->duration == AV_NOPTS_VALUE)
1821                     st->duration = duration;
1822             }
1823         }
1824     }
1825 }
1826
1827 #define DURATION_MAX_READ_SIZE 250000
1828 #define DURATION_MAX_RETRY 3
1829
1830 /* only usable for MPEG-PS streams */
1831 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1832 {
1833     AVPacket pkt1, *pkt = &pkt1;
1834     AVStream *st;
1835     int read_size, i, ret;
1836     int64_t end_time;
1837     int64_t filesize, offset, duration;
1838     int retry = 0;
1839
1840     /* flush packet queue */
1841     flush_packet_queue(ic);
1842
1843     for (i = 0; i < ic->nb_streams; i++) {
1844         st = ic->streams[i];
1845         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1846             av_log(st->codec, AV_LOG_WARNING,
1847                    "start time is not set in estimate_timings_from_pts\n");
1848
1849         if (st->parser) {
1850             av_parser_close(st->parser);
1851             st->parser = NULL;
1852         }
1853     }
1854
1855     /* estimate the end time (duration) */
1856     /* XXX: may need to support wrapping */
1857     filesize = ic->pb ? avio_size(ic->pb) : 0;
1858     end_time = AV_NOPTS_VALUE;
1859     do {
1860         offset = filesize - (DURATION_MAX_READ_SIZE << retry);
1861         if (offset < 0)
1862             offset = 0;
1863
1864         avio_seek(ic->pb, offset, SEEK_SET);
1865         read_size = 0;
1866         for (;;) {
1867             if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
1868                 break;
1869
1870             do {
1871                 ret = ff_read_packet(ic, pkt);
1872             } while (ret == AVERROR(EAGAIN));
1873             if (ret != 0)
1874                 break;
1875             read_size += pkt->size;
1876             st         = ic->streams[pkt->stream_index];
1877             if (pkt->pts != AV_NOPTS_VALUE &&
1878                 (st->start_time != AV_NOPTS_VALUE ||
1879                  st->first_dts  != AV_NOPTS_VALUE)) {
1880                 duration = end_time = pkt->pts;
1881                 if (st->start_time != AV_NOPTS_VALUE)
1882                     duration -= st->start_time;
1883                 else
1884                     duration -= st->first_dts;
1885                 if (duration < 0)
1886                     duration += 1LL << st->pts_wrap_bits;
1887                 if (duration > 0) {
1888                     if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
1889                         st->duration = duration;
1890                 }
1891             }
1892             av_free_packet(pkt);
1893         }
1894     } while (end_time == AV_NOPTS_VALUE &&
1895              filesize > (DURATION_MAX_READ_SIZE << retry) &&
1896              ++retry <= DURATION_MAX_RETRY);
1897
1898     fill_all_stream_timings(ic);
1899
1900     avio_seek(ic->pb, old_offset, SEEK_SET);
1901     for (i = 0; i < ic->nb_streams; i++) {
1902         st              = ic->streams[i];
1903         st->cur_dts     = st->first_dts;
1904         st->last_IP_pts = AV_NOPTS_VALUE;
1905     }
1906 }
1907
1908 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
1909 {
1910     int64_t file_size;
1911
1912     /* get the file size, if possible */
1913     if (ic->iformat->flags & AVFMT_NOFILE) {
1914         file_size = 0;
1915     } else {
1916         file_size = avio_size(ic->pb);
1917         file_size = FFMAX(0, file_size);
1918     }
1919
1920     if ((!strcmp(ic->iformat->name, "mpeg") ||
1921          !strcmp(ic->iformat->name, "mpegts")) &&
1922         file_size && ic->pb->seekable) {
1923         /* get accurate estimate from the PTSes */
1924         estimate_timings_from_pts(ic, old_offset);
1925     } else if (has_duration(ic)) {
1926         /* at least one component has timings - we use them for all
1927          * the components */
1928         fill_all_stream_timings(ic);
1929     } else {
1930         av_log(ic, AV_LOG_WARNING,
1931                "Estimating duration from bitrate, this may be inaccurate\n");
1932         /* less precise: use bitrate info */
1933         estimate_timings_from_bit_rate(ic);
1934     }
1935     update_stream_timings(ic);
1936
1937     {
1938         int i;
1939         AVStream av_unused *st;
1940         for (i = 0; i < ic->nb_streams; i++) {
1941             st = ic->streams[i];
1942             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
1943                     (double) st->start_time / AV_TIME_BASE,
1944                     (double) st->duration   / AV_TIME_BASE);
1945         }
1946         av_dlog(ic,
1947                 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1948                 (double) ic->start_time / AV_TIME_BASE,
1949                 (double) ic->duration   / AV_TIME_BASE,
1950                 ic->bit_rate / 1000);
1951     }
1952 }
1953
1954 static int has_codec_parameters(AVStream *st)
1955 {
1956     AVCodecContext *avctx = st->codec;
1957     int val;
1958
1959     switch (avctx->codec_type) {
1960     case AVMEDIA_TYPE_AUDIO:
1961         val = avctx->sample_rate && avctx->channels;
1962         if (st->info->found_decoder >= 0 &&
1963             avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
1964             return 0;
1965         break;
1966     case AVMEDIA_TYPE_VIDEO:
1967         val = avctx->width;
1968         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
1969             return 0;
1970         break;
1971     default:
1972         val = 1;
1973         break;
1974     }
1975     return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
1976 }
1977
1978 static int has_decode_delay_been_guessed(AVStream *st)
1979 {
1980     return st->codec->codec_id != AV_CODEC_ID_H264 ||
1981            st->info->nb_decoded_frames >= 6;
1982 }
1983
1984 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
1985 static int try_decode_frame(AVStream *st, AVPacket *avpkt,
1986                             AVDictionary **options)
1987 {
1988     const AVCodec *codec;
1989     int got_picture = 1, ret = 0;
1990     AVFrame *frame = av_frame_alloc();
1991     AVPacket pkt = *avpkt;
1992
1993     if (!frame)
1994         return AVERROR(ENOMEM);
1995
1996     if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
1997         AVDictionary *thread_opt = NULL;
1998
1999         codec = st->codec->codec ? st->codec->codec
2000                                  : avcodec_find_decoder(st->codec->codec_id);
2001
2002         if (!codec) {
2003             st->info->found_decoder = -1;
2004             ret                     = -1;
2005             goto fail;
2006         }
2007
2008         /* Force thread count to 1 since the H.264 decoder will not extract
2009          * SPS and PPS to extradata during multi-threaded decoding. */
2010         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2011         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2012         if (!options)
2013             av_dict_free(&thread_opt);
2014         if (ret < 0) {
2015             st->info->found_decoder = -1;
2016             goto fail;
2017         }
2018         st->info->found_decoder = 1;
2019     } else if (!st->info->found_decoder)
2020         st->info->found_decoder = 1;
2021
2022     if (st->info->found_decoder < 0) {
2023         ret = -1;
2024         goto fail;
2025     }
2026
2027     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2028            ret >= 0 &&
2029            (!has_codec_parameters(st) || !has_decode_delay_been_guessed(st) ||
2030             (!st->codec_info_nb_frames &&
2031              st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2032         got_picture = 0;
2033         switch (st->codec->codec_type) {
2034         case AVMEDIA_TYPE_VIDEO:
2035             ret = avcodec_decode_video2(st->codec, frame,
2036                                         &got_picture, &pkt);
2037             break;
2038         case AVMEDIA_TYPE_AUDIO:
2039             ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2040             break;
2041         default:
2042             break;
2043         }
2044         if (ret >= 0) {
2045             if (got_picture)
2046                 st->info->nb_decoded_frames++;
2047             pkt.data += ret;
2048             pkt.size -= ret;
2049             ret       = got_picture;
2050         }
2051     }
2052
2053 fail:
2054     av_frame_free(&frame);
2055     return ret;
2056 }
2057
2058 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2059 {
2060     while (tags->id != AV_CODEC_ID_NONE) {
2061         if (tags->id == id)
2062             return tags->tag;
2063         tags++;
2064     }
2065     return 0;
2066 }
2067
2068 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2069 {
2070     int i;
2071     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2072         if (tag == tags[i].tag)
2073             return tags[i].id;
2074     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2075         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2076             return tags[i].id;
2077     return AV_CODEC_ID_NONE;
2078 }
2079
2080 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2081 {
2082     if (flt) {
2083         switch (bps) {
2084         case 32:
2085             return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2086         case 64:
2087             return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2088         default:
2089             return AV_CODEC_ID_NONE;
2090         }
2091     } else {
2092         bps >>= 3;
2093         if (sflags & (1 << (bps - 1))) {
2094             switch (bps) {
2095             case 1:
2096                 return AV_CODEC_ID_PCM_S8;
2097             case 2:
2098                 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2099             case 3:
2100                 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2101             case 4:
2102                 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2103             default:
2104                 return AV_CODEC_ID_NONE;
2105             }
2106         } else {
2107             switch (bps) {
2108             case 1:
2109                 return AV_CODEC_ID_PCM_U8;
2110             case 2:
2111                 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2112             case 3:
2113                 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2114             case 4:
2115                 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2116             default:
2117                 return AV_CODEC_ID_NONE;
2118             }
2119         }
2120     }
2121 }
2122
2123 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2124 {
2125     int i;
2126     for (i = 0; tags && tags[i]; i++) {
2127         int tag = ff_codec_get_tag(tags[i], id);
2128         if (tag)
2129             return tag;
2130     }
2131     return 0;
2132 }
2133
2134 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2135 {
2136     int i;
2137     for (i = 0; tags && tags[i]; i++) {
2138         enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2139         if (id != AV_CODEC_ID_NONE)
2140             return id;
2141     }
2142     return AV_CODEC_ID_NONE;
2143 }
2144
2145 static void compute_chapters_end(AVFormatContext *s)
2146 {
2147     unsigned int i, j;
2148     int64_t max_time = s->duration +
2149                        ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2150
2151     for (i = 0; i < s->nb_chapters; i++)
2152         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2153             AVChapter *ch = s->chapters[i];
2154             int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2155                                                   ch->time_base)
2156                                    : INT64_MAX;
2157
2158             for (j = 0; j < s->nb_chapters; j++) {
2159                 AVChapter *ch1     = s->chapters[j];
2160                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2161                                                   ch->time_base);
2162                 if (j != i && next_start > ch->start && next_start < end)
2163                     end = next_start;
2164             }
2165             ch->end = (end == INT64_MAX) ? ch->start : end;
2166         }
2167 }
2168
2169 static int get_std_framerate(int i)
2170 {
2171     if (i < 60 * 12)
2172         return (i + 1) * 1001;
2173     else
2174         return ((const int[]) { 24, 30, 60, 12, 15 })[i - 60 * 12] * 1000 * 12;
2175 }
2176
2177 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2178 {
2179     int i, count, ret, read_size, j;
2180     AVStream *st;
2181     AVPacket pkt1, *pkt;
2182     int64_t old_offset  = avio_tell(ic->pb);
2183     // new streams might appear, no options for those
2184     int orig_nb_streams = ic->nb_streams;
2185
2186     for (i = 0; i < ic->nb_streams; i++) {
2187         const AVCodec *codec;
2188         AVDictionary *thread_opt = NULL;
2189         st = ic->streams[i];
2190
2191         // only for the split stuff
2192         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2193             st->parser = av_parser_init(st->codec->codec_id);
2194             if (st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser)
2195                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2196         }
2197         codec = st->codec->codec ? st->codec->codec
2198                                  : avcodec_find_decoder(st->codec->codec_id);
2199
2200         /* Force thread count to 1 since the H.264 decoder will not extract
2201          * SPS and PPS to extradata during multi-threaded decoding. */
2202         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2203
2204         /* Ensure that subtitle_header is properly set. */
2205         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2206             && codec && !st->codec->codec)
2207             avcodec_open2(st->codec, codec,
2208                           options ? &options[i] : &thread_opt);
2209
2210         // Try to just open decoders, in case this is enough to get parameters.
2211         if (!has_codec_parameters(st)) {
2212             if (codec && !st->codec->codec)
2213                 avcodec_open2(st->codec, codec,
2214                               options ? &options[i] : &thread_opt);
2215         }
2216         if (!options)
2217             av_dict_free(&thread_opt);
2218     }
2219
2220     for (i = 0; i < ic->nb_streams; i++) {
2221         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2222         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
2223     }
2224
2225     count     = 0;
2226     read_size = 0;
2227     for (;;) {
2228         if (ff_check_interrupt(&ic->interrupt_callback)) {
2229             ret = AVERROR_EXIT;
2230             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2231             break;
2232         }
2233
2234         /* check if one codec still needs to be handled */
2235         for (i = 0; i < ic->nb_streams; i++) {
2236             int fps_analyze_framecount = 20;
2237
2238             st = ic->streams[i];
2239             if (!has_codec_parameters(st))
2240                 break;
2241             /* If the timebase is coarse (like the usual millisecond precision
2242              * of mkv), we need to analyze more frames to reliably arrive at
2243              * the correct fps. */
2244             if (av_q2d(st->time_base) > 0.0005)
2245                 fps_analyze_framecount *= 2;
2246             if (ic->fps_probe_size >= 0)
2247                 fps_analyze_framecount = ic->fps_probe_size;
2248             /* variable fps and no guess at the real fps */
2249             if (!st->avg_frame_rate.num &&
2250                 st->codec_info_nb_frames < fps_analyze_framecount &&
2251                 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2252                 break;
2253             if (st->parser && st->parser->parser->split &&
2254                 !st->codec->extradata)
2255                 break;
2256             if (st->first_dts == AV_NOPTS_VALUE &&
2257                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2258                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2259                 break;
2260         }
2261         if (i == ic->nb_streams) {
2262             /* NOTE: If the format has no header, then we need to read some
2263              * packets to get most of the streams, so we cannot stop here. */
2264             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2265                 /* If we found the info for all the codecs, we can stop. */
2266                 ret = count;
2267                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2268                 break;
2269             }
2270         }
2271         /* We did not get all the codec info, but we read too much data. */
2272         if (read_size >= ic->probesize) {
2273             ret = count;
2274             av_log(ic, AV_LOG_DEBUG,
2275                    "Probe buffer size limit %d reached\n", ic->probesize);
2276             break;
2277         }
2278
2279         /* NOTE: A new stream can be added there if no header in file
2280          * (AVFMTCTX_NOHEADER). */
2281         ret = read_frame_internal(ic, &pkt1);
2282         if (ret == AVERROR(EAGAIN))
2283             continue;
2284
2285         if (ret < 0) {
2286             /* EOF or error*/
2287             AVPacket empty_pkt = { 0 };
2288             int err = 0;
2289             av_init_packet(&empty_pkt);
2290
2291             /* We could not have all the codec parameters before EOF. */
2292             ret = -1;
2293             for (i = 0; i < ic->nb_streams; i++) {
2294                 st = ic->streams[i];
2295
2296                 /* flush the decoders */
2297                 if (st->info->found_decoder == 1) {
2298                     do {
2299                         err = try_decode_frame(st, &empty_pkt,
2300                                                (options && i < orig_nb_streams)
2301                                                ? &options[i] : NULL);
2302                     } while (err > 0 && !has_codec_parameters(st));
2303                 }
2304
2305                 if (err < 0) {
2306                     av_log(ic, AV_LOG_WARNING,
2307                            "decoding for stream %d failed\n", st->index);
2308                 } else if (!has_codec_parameters(st)) {
2309                     char buf[256];
2310                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2311                     av_log(ic, AV_LOG_WARNING,
2312                            "Could not find codec parameters (%s)\n", buf);
2313                 } else {
2314                     ret = 0;
2315                 }
2316             }
2317             break;
2318         }
2319
2320         if (ic->flags & AVFMT_FLAG_NOBUFFER) {
2321             pkt = &pkt1;
2322         } else {
2323             pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2324                                 &ic->packet_buffer_end);
2325             if ((ret = av_dup_packet(pkt)) < 0)
2326                 goto find_stream_info_err;
2327         }
2328
2329         read_size += pkt->size;
2330
2331         st = ic->streams[pkt->stream_index];
2332         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2333             /* check for non-increasing dts */
2334             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2335                 st->info->fps_last_dts >= pkt->dts) {
2336                 av_log(ic, AV_LOG_WARNING,
2337                        "Non-increasing DTS in stream %d: packet %d with DTS "
2338                        "%"PRId64", packet %d with DTS %"PRId64"\n",
2339                        st->index, st->info->fps_last_dts_idx,
2340                        st->info->fps_last_dts, st->codec_info_nb_frames,
2341                        pkt->dts);
2342                 st->info->fps_first_dts =
2343                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
2344             }
2345             /* Check for a discontinuity in dts. If the difference in dts
2346              * is more than 1000 times the average packet duration in the
2347              * sequence, we treat it as a discontinuity. */
2348             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2349                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2350                 (pkt->dts - st->info->fps_last_dts) / 1000 >
2351                 (st->info->fps_last_dts     - st->info->fps_first_dts) /
2352                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2353                 av_log(ic, AV_LOG_WARNING,
2354                        "DTS discontinuity in stream %d: packet %d with DTS "
2355                        "%"PRId64", packet %d with DTS %"PRId64"\n",
2356                        st->index, st->info->fps_last_dts_idx,
2357                        st->info->fps_last_dts, st->codec_info_nb_frames,
2358                        pkt->dts);
2359                 st->info->fps_first_dts =
2360                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
2361             }
2362
2363             /* update stored dts values */
2364             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2365                 st->info->fps_first_dts     = pkt->dts;
2366                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2367             }
2368             st->info->fps_last_dts     = pkt->dts;
2369             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2370
2371             /* check max_analyze_duration */
2372             if (av_rescale_q(pkt->dts - st->info->fps_first_dts, st->time_base,
2373                              AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2374                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached\n",
2375                        ic->max_analyze_duration);
2376                 break;
2377             }
2378         }
2379         if (st->parser && st->parser->parser->split && !st->codec->extradata) {
2380             int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
2381             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2382                 st->codec->extradata_size = i;
2383                 st->codec->extradata = av_malloc(st->codec->extradata_size +
2384                                                  FF_INPUT_BUFFER_PADDING_SIZE);
2385                 if (!st->codec->extradata)
2386                     return AVERROR(ENOMEM);
2387                 memcpy(st->codec->extradata, pkt->data,
2388                        st->codec->extradata_size);
2389                 memset(st->codec->extradata + i, 0,
2390                        FF_INPUT_BUFFER_PADDING_SIZE);
2391             }
2392         }
2393
2394         /* If still no information, we try to open the codec and to
2395          * decompress the frame. We try to avoid that in most cases as
2396          * it takes longer and uses more memory. For MPEG-4, we need to
2397          * decompress for QuickTime.
2398          *
2399          * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2400          * least one frame of codec data, this makes sure the codec initializes
2401          * the channel configuration and does not only trust the values from
2402          * the container. */
2403         try_decode_frame(st, pkt,
2404                          (options && i < orig_nb_streams) ? &options[i] : NULL);
2405
2406         st->codec_info_nb_frames++;
2407         count++;
2408     }
2409
2410     // close codecs which were opened in try_decode_frame()
2411     for (i = 0; i < ic->nb_streams; i++) {
2412         st = ic->streams[i];
2413         avcodec_close(st->codec);
2414     }
2415     for (i = 0; i < ic->nb_streams; i++) {
2416         st = ic->streams[i];
2417         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2418             /* estimate average framerate if not set by demuxer */
2419             if (!st->avg_frame_rate.num &&
2420                 st->info->fps_last_dts != st->info->fps_first_dts) {
2421                 int64_t delta_dts = st->info->fps_last_dts -
2422                                     st->info->fps_first_dts;
2423                 int delta_packets = st->info->fps_last_dts_idx -
2424                                     st->info->fps_first_dts_idx;
2425                 int best_fps      = 0;
2426                 double best_error = 0.01;
2427
2428                 if (delta_dts     >= INT64_MAX / st->time_base.num ||
2429                     delta_packets >= INT64_MAX / st->time_base.den ||
2430                     delta_dts < 0)
2431                     continue;
2432                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2433                           delta_packets * (int64_t) st->time_base.den,
2434                           delta_dts * (int64_t) st->time_base.num, 60000);
2435
2436                 /* Round guessed framerate to a "standard" framerate if it's
2437                  * within 1% of the original estimate. */
2438                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
2439                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
2440                     double error       = fabs(av_q2d(st->avg_frame_rate) /
2441                                               av_q2d(std_fps) - 1);
2442
2443                     if (error < best_error) {
2444                         best_error = error;
2445                         best_fps   = std_fps.num;
2446                     }
2447                 }
2448                 if (best_fps)
2449                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2450                               best_fps, 12 * 1001, INT_MAX);
2451             }
2452         } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2453             if (!st->codec->bits_per_coded_sample)
2454                 st->codec->bits_per_coded_sample =
2455                     av_get_bits_per_sample(st->codec->codec_id);
2456             // set stream disposition based on audio service type
2457             switch (st->codec->audio_service_type) {
2458             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2459                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
2460                 break;
2461             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2462                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
2463                 break;
2464             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2465                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
2466                 break;
2467             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2468                 st->disposition = AV_DISPOSITION_COMMENT;
2469                 break;
2470             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2471                 st->disposition = AV_DISPOSITION_KARAOKE;
2472                 break;
2473             }
2474         }
2475     }
2476
2477     estimate_timings(ic, old_offset);
2478
2479     compute_chapters_end(ic);
2480
2481 find_stream_info_err:
2482     for (i = 0; i < ic->nb_streams; i++) {
2483         ic->streams[i]->codec->thread_count = 0;
2484         av_freep(&ic->streams[i]->info);
2485     }
2486     return ret;
2487 }
2488
2489 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2490 {
2491     int i, j;
2492
2493     for (i = 0; i < ic->nb_programs; i++)
2494         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2495             if (ic->programs[i]->stream_index[j] == s)
2496                 return ic->programs[i];
2497     return NULL;
2498 }
2499
2500 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
2501                         int wanted_stream_nb, int related_stream,
2502                         AVCodec **decoder_ret, int flags)
2503 {
2504     int i, nb_streams = ic->nb_streams;
2505     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2506     unsigned *program = NULL;
2507     AVCodec *decoder = NULL, *best_decoder = NULL;
2508
2509     if (related_stream >= 0 && wanted_stream_nb < 0) {
2510         AVProgram *p = find_program_from_stream(ic, related_stream);
2511         if (p) {
2512             program    = p->stream_index;
2513             nb_streams = p->nb_stream_indexes;
2514         }
2515     }
2516     for (i = 0; i < nb_streams; i++) {
2517         int real_stream_index = program ? program[i] : i;
2518         AVStream *st          = ic->streams[real_stream_index];
2519         AVCodecContext *avctx = st->codec;
2520         if (avctx->codec_type != type)
2521             continue;
2522         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2523             continue;
2524         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
2525                                AV_DISPOSITION_VISUAL_IMPAIRED))
2526             continue;
2527         if (decoder_ret) {
2528             decoder = avcodec_find_decoder(st->codec->codec_id);
2529             if (!decoder) {
2530                 if (ret < 0)
2531                     ret = AVERROR_DECODER_NOT_FOUND;
2532                 continue;
2533             }
2534         }
2535         if (best_count >= st->codec_info_nb_frames)
2536             continue;
2537         best_count   = st->codec_info_nb_frames;
2538         ret          = real_stream_index;
2539         best_decoder = decoder;
2540         if (program && i == nb_streams - 1 && ret < 0) {
2541             program    = NULL;
2542             nb_streams = ic->nb_streams;
2543             /* no related stream found, try again with everything */
2544             i = 0;
2545         }
2546     }
2547     if (decoder_ret)
2548         *decoder_ret = best_decoder;
2549     return ret;
2550 }
2551
2552 /*******************************************************/
2553
2554 int av_read_play(AVFormatContext *s)
2555 {
2556     if (s->iformat->read_play)
2557         return s->iformat->read_play(s);
2558     if (s->pb)
2559         return avio_pause(s->pb, 0);
2560     return AVERROR(ENOSYS);
2561 }
2562
2563 int av_read_pause(AVFormatContext *s)
2564 {
2565     if (s->iformat->read_pause)
2566         return s->iformat->read_pause(s);
2567     if (s->pb)
2568         return avio_pause(s->pb, 1);
2569     return AVERROR(ENOSYS);
2570 }
2571
2572 void avformat_free_context(AVFormatContext *s)
2573 {
2574     int i, j;
2575     AVStream *st;
2576
2577     av_opt_free(s);
2578     if (s->iformat && s->iformat->priv_class && s->priv_data)
2579         av_opt_free(s->priv_data);
2580
2581     for (i = 0; i < s->nb_streams; i++) {
2582         /* free all data in a stream component */
2583         st = s->streams[i];
2584
2585         for (j = 0; j < st->nb_side_data; j++)
2586             av_freep(&st->side_data[j].data);
2587         av_freep(&st->side_data);
2588         st->nb_side_data = 0;
2589
2590         if (st->parser) {
2591             av_parser_close(st->parser);
2592         }
2593         if (st->attached_pic.data)
2594             av_free_packet(&st->attached_pic);
2595         av_dict_free(&st->metadata);
2596         av_freep(&st->probe_data.buf);
2597         av_free(st->index_entries);
2598         av_free(st->codec->extradata);
2599         av_free(st->codec->subtitle_header);
2600         av_free(st->codec);
2601         av_free(st->priv_data);
2602         av_free(st->info);
2603         av_free(st);
2604     }
2605     for (i = s->nb_programs - 1; i >= 0; i--) {
2606         av_dict_free(&s->programs[i]->metadata);
2607         av_freep(&s->programs[i]->stream_index);
2608         av_freep(&s->programs[i]);
2609     }
2610     av_freep(&s->programs);
2611     av_freep(&s->priv_data);
2612     while (s->nb_chapters--) {
2613         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2614         av_free(s->chapters[s->nb_chapters]);
2615     }
2616     av_freep(&s->chapters);
2617     av_dict_free(&s->metadata);
2618     av_freep(&s->streams);
2619     av_freep(&s->internal);
2620     av_free(s);
2621 }
2622
2623 void avformat_close_input(AVFormatContext **ps)
2624 {
2625     AVFormatContext *s = *ps;
2626     AVIOContext *pb    = s->pb;
2627
2628     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
2629         (s->flags & AVFMT_FLAG_CUSTOM_IO))
2630         pb = NULL;
2631
2632     flush_packet_queue(s);
2633
2634     if (s->iformat)
2635         if (s->iformat->read_close)
2636             s->iformat->read_close(s);
2637
2638     avformat_free_context(s);
2639
2640     *ps = NULL;
2641
2642     avio_close(pb);
2643 }
2644
2645 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2646 {
2647     AVStream *st;
2648     int i;
2649
2650     if (av_reallocp_array(&s->streams, s->nb_streams + 1,
2651                           sizeof(*s->streams)) < 0) {
2652         s->nb_streams = 0;
2653         return NULL;
2654     }
2655
2656     st = av_mallocz(sizeof(AVStream));
2657     if (!st)
2658         return NULL;
2659     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2660         av_free(st);
2661         return NULL;
2662     }
2663
2664     st->codec = avcodec_alloc_context3(c);
2665     if (s->iformat)
2666         /* no default bitrate if decoding */
2667         st->codec->bit_rate = 0;
2668     st->index      = s->nb_streams;
2669     st->start_time = AV_NOPTS_VALUE;
2670     st->duration   = AV_NOPTS_VALUE;
2671     /* we set the current DTS to 0 so that formats without any timestamps
2672      * but durations get some timestamps, formats with some unknown
2673      * timestamps have their first few packets buffered and the
2674      * timestamps corrected before they are returned to the user */
2675     st->cur_dts       = 0;
2676     st->first_dts     = AV_NOPTS_VALUE;
2677     st->probe_packets = MAX_PROBE_PACKETS;
2678
2679     /* default pts setting is MPEG-like */
2680     avpriv_set_pts_info(st, 33, 1, 90000);
2681     st->last_IP_pts = AV_NOPTS_VALUE;
2682     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
2683         st->pts_buffer[i] = AV_NOPTS_VALUE;
2684
2685     st->sample_aspect_ratio = (AVRational) { 0, 1 };
2686
2687     st->info->fps_first_dts = AV_NOPTS_VALUE;
2688     st->info->fps_last_dts  = AV_NOPTS_VALUE;
2689
2690     s->streams[s->nb_streams++] = st;
2691     return st;
2692 }
2693
2694 AVProgram *av_new_program(AVFormatContext *ac, int id)
2695 {
2696     AVProgram *program = NULL;
2697     int i;
2698
2699     av_dlog(ac, "new_program: id=0x%04x\n", id);
2700
2701     for (i = 0; i < ac->nb_programs; i++)
2702         if (ac->programs[i]->id == id)
2703             program = ac->programs[i];
2704
2705     if (!program) {
2706         program = av_mallocz(sizeof(AVProgram));
2707         if (!program)
2708             return NULL;
2709         dynarray_add(&ac->programs, &ac->nb_programs, program);
2710         program->discard = AVDISCARD_NONE;
2711     }
2712     program->id = id;
2713
2714     return program;
2715 }
2716
2717 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
2718                               int64_t start, int64_t end, const char *title)
2719 {
2720     AVChapter *chapter = NULL;
2721     int i;
2722
2723     for (i = 0; i < s->nb_chapters; i++)
2724         if (s->chapters[i]->id == id)
2725             chapter = s->chapters[i];
2726
2727     if (!chapter) {
2728         chapter = av_mallocz(sizeof(AVChapter));
2729         if (!chapter)
2730             return NULL;
2731         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2732     }
2733     av_dict_set(&chapter->metadata, "title", title, 0);
2734     chapter->id        = id;
2735     chapter->time_base = time_base;
2736     chapter->start     = start;
2737     chapter->end       = end;
2738
2739     return chapter;
2740 }
2741
2742 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
2743 {
2744     int i, j;
2745     AVProgram *program = NULL;
2746
2747     if (idx >= ac->nb_streams) {
2748         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2749         return;
2750     }
2751
2752     for (i = 0; i < ac->nb_programs; i++) {
2753         if (ac->programs[i]->id != progid)
2754             continue;
2755         program = ac->programs[i];
2756         for (j = 0; j < program->nb_stream_indexes; j++)
2757             if (program->stream_index[j] == idx)
2758                 return;
2759
2760         if (av_reallocp_array(&program->stream_index,
2761                               program->nb_stream_indexes + 1,
2762                               sizeof(*program->stream_index)) < 0) {
2763             program->nb_stream_indexes = 0;
2764             return;
2765         }
2766         program->stream_index[program->nb_stream_indexes++] = idx;
2767         return;
2768     }
2769 }
2770
2771 static void print_fps(double d, const char *postfix)
2772 {
2773     uint64_t v = lrintf(d * 100);
2774     if (v % 100)
2775         av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2776     else if (v % (100 * 1000))
2777         av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2778     else
2779         av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d / 1000, postfix);
2780 }
2781
2782 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
2783 {
2784     if (m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))) {
2785         AVDictionaryEntry *tag = NULL;
2786
2787         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2788         while ((tag = av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX)))
2789             if (strcmp("language", tag->key))
2790                 av_log(ctx, AV_LOG_INFO,
2791                        "%s  %-16s: %s\n", indent, tag->key, tag->value);
2792     }
2793 }
2794
2795 /* "user interface" functions */
2796 static void dump_stream_format(AVFormatContext *ic, int i,
2797                                int index, int is_output)
2798 {
2799     char buf[256];
2800     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2801     AVStream *st = ic->streams[i];
2802     int g = av_gcd(st->time_base.num, st->time_base.den);
2803     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
2804     avcodec_string(buf, sizeof(buf), st->codec, is_output);
2805     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2806     /* the pid is an important information, so we display it */
2807     /* XXX: add a generic system */
2808     if (flags & AVFMT_SHOW_IDS)
2809         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2810     if (lang)
2811         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2812     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames,
2813            st->time_base.num / g, st->time_base.den / g);
2814     av_log(NULL, AV_LOG_INFO, ": %s", buf);
2815     if (st->sample_aspect_ratio.num && // default
2816         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2817         AVRational display_aspect_ratio;
2818         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2819                   st->codec->width  * st->sample_aspect_ratio.num,
2820                   st->codec->height * st->sample_aspect_ratio.den,
2821                   1024 * 1024);
2822         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2823                st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2824                display_aspect_ratio.num, display_aspect_ratio.den);
2825     }
2826     if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2827         if (st->avg_frame_rate.den && st->avg_frame_rate.num)
2828             print_fps(av_q2d(st->avg_frame_rate), "fps");
2829         if (st->time_base.den && st->time_base.num)
2830             print_fps(1 / av_q2d(st->time_base), "tbn");
2831         if (st->codec->time_base.den && st->codec->time_base.num)
2832             print_fps(1 / av_q2d(st->codec->time_base), "tbc");
2833     }
2834     if (st->disposition & AV_DISPOSITION_DEFAULT)
2835         av_log(NULL, AV_LOG_INFO, " (default)");
2836     if (st->disposition & AV_DISPOSITION_DUB)
2837         av_log(NULL, AV_LOG_INFO, " (dub)");
2838     if (st->disposition & AV_DISPOSITION_ORIGINAL)
2839         av_log(NULL, AV_LOG_INFO, " (original)");
2840     if (st->disposition & AV_DISPOSITION_COMMENT)
2841         av_log(NULL, AV_LOG_INFO, " (comment)");
2842     if (st->disposition & AV_DISPOSITION_LYRICS)
2843         av_log(NULL, AV_LOG_INFO, " (lyrics)");
2844     if (st->disposition & AV_DISPOSITION_KARAOKE)
2845         av_log(NULL, AV_LOG_INFO, " (karaoke)");
2846     if (st->disposition & AV_DISPOSITION_FORCED)
2847         av_log(NULL, AV_LOG_INFO, " (forced)");
2848     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
2849         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
2850     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
2851         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
2852     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
2853         av_log(NULL, AV_LOG_INFO, " (clean effects)");
2854     av_log(NULL, AV_LOG_INFO, "\n");
2855     dump_metadata(NULL, st->metadata, "    ");
2856 }
2857
2858 void av_dump_format(AVFormatContext *ic, int index,
2859                     const char *url, int is_output)
2860 {
2861     int i;
2862     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
2863     if (ic->nb_streams && !printed)
2864         return;
2865
2866     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2867            is_output ? "Output" : "Input",
2868            index,
2869            is_output ? ic->oformat->name : ic->iformat->name,
2870            is_output ? "to" : "from", url);
2871     dump_metadata(NULL, ic->metadata, "  ");
2872     if (!is_output) {
2873         av_log(NULL, AV_LOG_INFO, "  Duration: ");
2874         if (ic->duration != AV_NOPTS_VALUE) {
2875             int hours, mins, secs, us;
2876             secs  = ic->duration / AV_TIME_BASE;
2877             us    = ic->duration % AV_TIME_BASE;
2878             mins  = secs / 60;
2879             secs %= 60;
2880             hours = mins / 60;
2881             mins %= 60;
2882             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2883                    (100 * us) / AV_TIME_BASE);
2884         } else {
2885             av_log(NULL, AV_LOG_INFO, "N/A");
2886         }
2887         if (ic->start_time != AV_NOPTS_VALUE) {
2888             int secs, us;
2889             av_log(NULL, AV_LOG_INFO, ", start: ");
2890             secs = ic->start_time / AV_TIME_BASE;
2891             us   = abs(ic->start_time % AV_TIME_BASE);
2892             av_log(NULL, AV_LOG_INFO, "%d.%06d",
2893                    secs, (int) av_rescale(us, 1000000, AV_TIME_BASE));
2894         }
2895         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2896         if (ic->bit_rate)
2897             av_log(NULL, AV_LOG_INFO, "%d kb/s", ic->bit_rate / 1000);
2898         else
2899             av_log(NULL, AV_LOG_INFO, "N/A");
2900         av_log(NULL, AV_LOG_INFO, "\n");
2901     }
2902     for (i = 0; i < ic->nb_chapters; i++) {
2903         AVChapter *ch = ic->chapters[i];
2904         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
2905         av_log(NULL, AV_LOG_INFO,
2906                "start %f, ", ch->start * av_q2d(ch->time_base));
2907         av_log(NULL, AV_LOG_INFO,
2908                "end %f\n", ch->end * av_q2d(ch->time_base));
2909
2910         dump_metadata(NULL, ch->metadata, "    ");
2911     }
2912     if (ic->nb_programs) {
2913         int j, k, total = 0;
2914         for (j = 0; j < ic->nb_programs; j++) {
2915             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
2916                                                   "name", NULL, 0);
2917             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2918                    name ? name->value : "");
2919             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
2920             for (k = 0; k < ic->programs[j]->nb_stream_indexes; k++) {
2921                 dump_stream_format(ic, ic->programs[j]->stream_index[k],
2922                                    index, is_output);
2923                 printed[ic->programs[j]->stream_index[k]] = 1;
2924             }
2925             total += ic->programs[j]->nb_stream_indexes;
2926         }
2927         if (total < ic->nb_streams)
2928             av_log(NULL, AV_LOG_INFO, "  No Program\n");
2929     }
2930     for (i = 0; i < ic->nb_streams; i++)
2931         if (!printed[i])
2932             dump_stream_format(ic, i, index, is_output);
2933
2934     av_free(printed);
2935 }
2936
2937 uint64_t ff_ntp_time(void)
2938 {
2939     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
2940 }
2941
2942 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
2943 {
2944     const char *p;
2945     char *q, buf1[20], c;
2946     int nd, len, percentd_found;
2947
2948     q = buf;
2949     p = path;
2950     percentd_found = 0;
2951     for (;;) {
2952         c = *p++;
2953         if (c == '\0')
2954             break;
2955         if (c == '%') {
2956             do {
2957                 nd = 0;
2958                 while (av_isdigit(*p))
2959                     nd = nd * 10 + *p++ - '0';
2960                 c = *p++;
2961             } while (av_isdigit(c));
2962
2963             switch (c) {
2964             case '%':
2965                 goto addchar;
2966             case 'd':
2967                 if (percentd_found)
2968                     goto fail;
2969                 percentd_found = 1;
2970                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2971                 len = strlen(buf1);
2972                 if ((q - buf + len) > buf_size - 1)
2973                     goto fail;
2974                 memcpy(q, buf1, len);
2975                 q += len;
2976                 break;
2977             default:
2978                 goto fail;
2979             }
2980         } else {
2981 addchar:
2982             if ((q - buf) < buf_size - 1)
2983                 *q++ = c;
2984         }
2985     }
2986     if (!percentd_found)
2987         goto fail;
2988     *q = '\0';
2989     return 0;
2990 fail:
2991     *q = '\0';
2992     return -1;
2993 }
2994
2995 #define HEXDUMP_PRINT(...)                      \
2996     do {                                        \
2997         if (!f)                                 \
2998             av_log(avcl, level, __VA_ARGS__);   \
2999         else                                    \
3000             fprintf(f, __VA_ARGS__);            \
3001     } while (0)
3002
3003 static void hex_dump_internal(void *avcl, FILE *f, int level,
3004                               const uint8_t *buf, int size)
3005 {
3006     int len, i, j, c;
3007
3008     for (i = 0; i < size; i += 16) {
3009         len = size - i;
3010         if (len > 16)
3011             len = 16;
3012         HEXDUMP_PRINT("%08x ", i);
3013         for (j = 0; j < 16; j++) {
3014             if (j < len)
3015                 HEXDUMP_PRINT(" %02x", buf[i + j]);
3016             else
3017                 HEXDUMP_PRINT("   ");
3018         }
3019         HEXDUMP_PRINT(" ");
3020         for (j = 0; j < len; j++) {
3021             c = buf[i + j];
3022             if (c < ' ' || c > '~')
3023                 c = '.';
3024             HEXDUMP_PRINT("%c", c);
3025         }
3026         HEXDUMP_PRINT("\n");
3027     }
3028 }
3029
3030 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3031 {
3032     hex_dump_internal(NULL, f, 0, buf, size);
3033 }
3034
3035 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3036 {
3037     hex_dump_internal(avcl, NULL, level, buf, size);
3038 }
3039
3040 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt,
3041                               int dump_payload, AVRational time_base)
3042 {
3043     HEXDUMP_PRINT("stream #%d:\n", pkt->stream_index);
3044     HEXDUMP_PRINT("  keyframe=%d\n", (pkt->flags & AV_PKT_FLAG_KEY) != 0);
3045     HEXDUMP_PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3046     /* DTS is _always_ valid after av_read_frame() */
3047     HEXDUMP_PRINT("  dts=");
3048     if (pkt->dts == AV_NOPTS_VALUE)
3049         HEXDUMP_PRINT("N/A");
3050     else
3051         HEXDUMP_PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3052     /* PTS may not be known if B-frames are present. */
3053     HEXDUMP_PRINT("  pts=");
3054     if (pkt->pts == AV_NOPTS_VALUE)
3055         HEXDUMP_PRINT("N/A");
3056     else
3057         HEXDUMP_PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3058     HEXDUMP_PRINT("\n");
3059     HEXDUMP_PRINT("  size=%d\n", pkt->size);
3060     if (dump_payload)
3061         av_hex_dump(f, pkt->data, pkt->size);
3062 }
3063
3064 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3065 {
3066     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3067 }
3068
3069 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3070                       AVStream *st)
3071 {
3072     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3073 }
3074
3075 void av_url_split(char *proto, int proto_size,
3076                   char *authorization, int authorization_size,
3077                   char *hostname, int hostname_size,
3078                   int *port_ptr, char *path, int path_size, const char *url)
3079 {
3080     const char *p, *ls, *at, *col, *brk;
3081
3082     if (port_ptr)
3083         *port_ptr = -1;
3084     if (proto_size > 0)
3085         proto[0] = 0;
3086     if (authorization_size > 0)
3087         authorization[0] = 0;
3088     if (hostname_size > 0)
3089         hostname[0] = 0;
3090     if (path_size > 0)
3091         path[0] = 0;
3092
3093     /* parse protocol */
3094     if ((p = strchr(url, ':'))) {
3095         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3096         p++; /* skip ':' */
3097         if (*p == '/')
3098             p++;
3099         if (*p == '/')
3100             p++;
3101     } else {
3102         /* no protocol means plain filename */
3103         av_strlcpy(path, url, path_size);
3104         return;
3105     }
3106
3107     /* separate path from hostname */
3108     ls = strchr(p, '/');
3109     if (!ls)
3110         ls = strchr(p, '?');
3111     if (ls)
3112         av_strlcpy(path, ls, path_size);
3113     else
3114         ls = &p[strlen(p)];  // XXX
3115
3116     /* the rest is hostname, use that to parse auth/port */
3117     if (ls != p) {
3118         /* authorization (user[:pass]@hostname) */
3119         if ((at = strchr(p, '@')) && at < ls) {
3120             av_strlcpy(authorization, p,
3121                        FFMIN(authorization_size, at + 1 - p));
3122             p = at + 1; /* skip '@' */
3123         }
3124
3125         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3126             /* [host]:port */
3127             av_strlcpy(hostname, p + 1,
3128                        FFMIN(hostname_size, brk - p));
3129             if (brk[1] == ':' && port_ptr)
3130                 *port_ptr = atoi(brk + 2);
3131         } else if ((col = strchr(p, ':')) && col < ls) {
3132             av_strlcpy(hostname, p,
3133                        FFMIN(col + 1 - p, hostname_size));
3134             if (port_ptr)
3135                 *port_ptr = atoi(col + 1);
3136         } else
3137             av_strlcpy(hostname, p,
3138                        FFMIN(ls + 1 - p, hostname_size));
3139     }
3140 }
3141
3142 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3143 {
3144     int i;
3145     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3146                                            '4', '5', '6', '7',
3147                                            '8', '9', 'A', 'B',
3148                                            'C', 'D', 'E', 'F' };
3149     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3150                                            '4', '5', '6', '7',
3151                                            '8', '9', 'a', 'b',
3152                                            'c', 'd', 'e', 'f' };
3153     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3154
3155     for (i = 0; i < s; i++) {
3156         buff[i * 2]     = hex_table[src[i] >> 4];
3157         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3158     }
3159
3160     return buff;
3161 }
3162
3163 int ff_hex_to_data(uint8_t *data, const char *p)
3164 {
3165     int c, len, v;
3166
3167     len = 0;
3168     v   = 1;
3169     for (;;) {
3170         p += strspn(p, SPACE_CHARS);
3171         if (*p == '\0')
3172             break;
3173         c = av_toupper((unsigned char) *p++);
3174         if (c >= '0' && c <= '9')
3175             c = c - '0';
3176         else if (c >= 'A' && c <= 'F')
3177             c = c - 'A' + 10;
3178         else
3179             break;
3180         v = (v << 4) | c;
3181         if (v & 0x100) {
3182             if (data)
3183                 data[len] = v;
3184             len++;
3185             v = 1;
3186         }
3187     }
3188     return len;
3189 }
3190
3191 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3192                          unsigned int pts_num, unsigned int pts_den)
3193 {
3194     AVRational new_tb;
3195     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3196         if (new_tb.num != pts_num)
3197             av_log(NULL, AV_LOG_DEBUG,
3198                    "st:%d removing common factor %d from timebase\n",
3199                    s->index, pts_num / new_tb.num);
3200     } else
3201         av_log(NULL, AV_LOG_WARNING,
3202                "st:%d has too large timebase, reducing\n", s->index);
3203
3204     if (new_tb.num <= 0 || new_tb.den <= 0) {
3205         av_log(NULL, AV_LOG_ERROR,
3206                "Ignoring attempt to set invalid timebase for st:%d\n",
3207                s->index);
3208         return;
3209     }
3210     s->time_base     = new_tb;
3211     s->pts_wrap_bits = pts_wrap_bits;
3212 }
3213
3214 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3215                         void *context)
3216 {
3217     const char *ptr = str;
3218
3219     /* Parse key=value pairs. */
3220     for (;;) {
3221         const char *key;
3222         char *dest = NULL, *dest_end;
3223         int key_len, dest_len = 0;
3224
3225         /* Skip whitespace and potential commas. */
3226         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3227             ptr++;
3228         if (!*ptr)
3229             break;
3230
3231         key = ptr;
3232
3233         if (!(ptr = strchr(key, '=')))
3234             break;
3235         ptr++;
3236         key_len = ptr - key;
3237
3238         callback_get_buf(context, key, key_len, &dest, &dest_len);
3239         dest_end = dest + dest_len - 1;
3240
3241         if (*ptr == '\"') {
3242             ptr++;
3243             while (*ptr && *ptr != '\"') {
3244                 if (*ptr == '\\') {
3245                     if (!ptr[1])
3246                         break;
3247                     if (dest && dest < dest_end)
3248                         *dest++ = ptr[1];
3249                     ptr += 2;
3250                 } else {
3251                     if (dest && dest < dest_end)
3252                         *dest++ = *ptr;
3253                     ptr++;
3254                 }
3255             }
3256             if (*ptr == '\"')
3257                 ptr++;
3258         } else {
3259             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
3260                 if (dest && dest < dest_end)
3261                     *dest++ = *ptr;
3262         }
3263         if (dest)
3264             *dest = 0;
3265     }
3266 }
3267
3268 int ff_find_stream_index(AVFormatContext *s, int id)
3269 {
3270     int i;
3271     for (i = 0; i < s->nb_streams; i++)
3272         if (s->streams[i]->id == id)
3273             return i;
3274     return -1;
3275 }
3276
3277 int64_t ff_iso8601_to_unix_time(const char *datestr)
3278 {
3279 #if HAVE_STRPTIME
3280     struct tm time1 = { 0 }, time2 = { 0 };
3281     char *ret1, *ret2;
3282     ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
3283     ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
3284     if (ret2 && !ret1)
3285         return av_timegm(&time2);
3286     else
3287         return av_timegm(&time1);
3288 #else
3289     av_log(NULL, AV_LOG_WARNING,
3290            "strptime() unavailable on this system, cannot convert "
3291            "the date string.\n");
3292     return 0;
3293 #endif
3294 }
3295
3296 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id,
3297                          int std_compliance)
3298 {
3299     if (ofmt) {
3300         if (ofmt->query_codec)
3301             return ofmt->query_codec(codec_id, std_compliance);
3302         else if (ofmt->codec_tag)
3303             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
3304         else if (codec_id == ofmt->video_codec ||
3305                  codec_id == ofmt->audio_codec ||
3306                  codec_id == ofmt->subtitle_codec)
3307             return 1;
3308     }
3309     return AVERROR_PATCHWELCOME;
3310 }
3311
3312 int avformat_network_init(void)
3313 {
3314 #if CONFIG_NETWORK
3315     int ret;
3316     ff_network_inited_globally = 1;
3317     if ((ret = ff_network_init()) < 0)
3318         return ret;
3319     ff_tls_init();
3320 #endif
3321     return 0;
3322 }
3323
3324 int avformat_network_deinit(void)
3325 {
3326 #if CONFIG_NETWORK
3327     ff_network_close();
3328     ff_tls_deinit();
3329 #endif
3330     return 0;
3331 }
3332
3333 int ff_add_param_change(AVPacket *pkt, int32_t channels,
3334                         uint64_t channel_layout, int32_t sample_rate,
3335                         int32_t width, int32_t height)
3336 {
3337     uint32_t flags = 0;
3338     int size = 4;
3339     uint8_t *data;
3340     if (!pkt)
3341         return AVERROR(EINVAL);
3342     if (channels) {
3343         size  += 4;
3344         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
3345     }
3346     if (channel_layout) {
3347         size  += 8;
3348         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
3349     }
3350     if (sample_rate) {
3351         size  += 4;
3352         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
3353     }
3354     if (width || height) {
3355         size  += 8;
3356         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
3357     }
3358     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
3359     if (!data)
3360         return AVERROR(ENOMEM);
3361     bytestream_put_le32(&data, flags);
3362     if (channels)
3363         bytestream_put_le32(&data, channels);
3364     if (channel_layout)
3365         bytestream_put_le64(&data, channel_layout);
3366     if (sample_rate)
3367         bytestream_put_le32(&data, sample_rate);
3368     if (width || height) {
3369         bytestream_put_le32(&data, width);
3370         bytestream_put_le32(&data, height);
3371     }
3372     return 0;
3373 }
3374
3375 int ff_generate_avci_extradata(AVStream *st)
3376 {
3377     static const uint8_t avci100_1080p_extradata[] = {
3378         // SPS
3379         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
3380         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
3381         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
3382         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
3383         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
3384         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
3385         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
3386         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
3387         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3388         // PPS
3389         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
3390         0xd0
3391     };
3392     static const uint8_t avci100_1080i_extradata[] = {
3393         // SPS
3394         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
3395         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
3396         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
3397         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
3398         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
3399         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
3400         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
3401         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
3402         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
3403         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
3404         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
3405         // PPS
3406         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
3407         0xd0
3408     };
3409     static const uint8_t avci50_1080i_extradata[] = {
3410         // SPS
3411         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
3412         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
3413         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
3414         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
3415         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
3416         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
3417         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
3418         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
3419         0x81, 0x13, 0xf7, 0xff, 0x80, 0x01, 0x80, 0x02,
3420         0x71, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
3421         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
3422         // PPS
3423         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
3424         0x11
3425     };
3426     static const uint8_t avci100_720p_extradata[] = {
3427         // SPS
3428         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
3429         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
3430         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
3431         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
3432         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
3433         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
3434         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
3435         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
3436         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
3437         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
3438         // PPS
3439         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
3440         0x11
3441     };
3442
3443     const uint8_t *data = NULL;
3444     int size            = 0;
3445
3446     if (st->codec->width == 1920) {
3447         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
3448             data = avci100_1080p_extradata;
3449             size = sizeof(avci100_1080p_extradata);
3450         } else {
3451             data = avci100_1080i_extradata;
3452             size = sizeof(avci100_1080i_extradata);
3453         }
3454     } else if (st->codec->width == 1440) {
3455         data = avci50_1080i_extradata;
3456         size = sizeof(avci50_1080i_extradata);
3457     } else if (st->codec->width == 1280) {
3458         data = avci100_720p_extradata;
3459         size = sizeof(avci100_720p_extradata);
3460     }
3461
3462     if (!size)
3463         return 0;
3464
3465     av_freep(&st->codec->extradata);
3466     st->codec->extradata_size = 0;
3467     st->codec->extradata      = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
3468     if (!st->codec->extradata)
3469         return AVERROR(ENOMEM);
3470
3471     memcpy(st->codec->extradata, data, size);
3472     st->codec->extradata_size = size;
3473
3474     return 0;
3475 }