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