faad9c9db4e39af406892c53847bf702b0dab2f0
[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                 break;
2232             }
2233         }
2234         if (st->parser && st->parser->parser->split && !st->codec->extradata) {
2235             int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
2236             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2237                 st->codec->extradata_size = i;
2238                 st->codec->extradata = av_mallocz(st->codec->extradata_size +
2239                                                   FF_INPUT_BUFFER_PADDING_SIZE);
2240                 if (!st->codec->extradata)
2241                     return AVERROR(ENOMEM);
2242                 memcpy(st->codec->extradata, pkt->data,
2243                        st->codec->extradata_size);
2244             }
2245         }
2246
2247         /* If still no information, we try to open the codec and to
2248          * decompress the frame. We try to avoid that in most cases as
2249          * it takes longer and uses more memory. For MPEG-4, we need to
2250          * decompress for QuickTime.
2251          *
2252          * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2253          * least one frame of codec data, this makes sure the codec initializes
2254          * the channel configuration and does not only trust the values from
2255          * the container. */
2256         try_decode_frame(st, pkt,
2257                          (options && i < orig_nb_streams) ? &options[i] : NULL);
2258
2259         st->codec_info_nb_frames++;
2260         count++;
2261     }
2262
2263     // close codecs which were opened in try_decode_frame()
2264     for (i = 0; i < ic->nb_streams; i++) {
2265         st = ic->streams[i];
2266         avcodec_close(st->codec);
2267     }
2268     for (i = 0; i < ic->nb_streams; i++) {
2269         st = ic->streams[i];
2270         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2271             /* estimate average framerate if not set by demuxer */
2272             if (!st->avg_frame_rate.num &&
2273                 st->info->fps_last_dts != st->info->fps_first_dts) {
2274                 int64_t delta_dts = st->info->fps_last_dts -
2275                                     st->info->fps_first_dts;
2276                 int delta_packets = st->info->fps_last_dts_idx -
2277                                     st->info->fps_first_dts_idx;
2278                 int best_fps      = 0;
2279                 double best_error = 0.01;
2280
2281                 if (delta_dts     >= INT64_MAX / st->time_base.num ||
2282                     delta_packets >= INT64_MAX / st->time_base.den ||
2283                     delta_dts < 0)
2284                     continue;
2285                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2286                           delta_packets * (int64_t) st->time_base.den,
2287                           delta_dts * (int64_t) st->time_base.num, 60000);
2288
2289                 /* Round guessed framerate to a "standard" framerate if it's
2290                  * within 1% of the original estimate. */
2291                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
2292                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
2293                     double error       = fabs(av_q2d(st->avg_frame_rate) /
2294                                               av_q2d(std_fps) - 1);
2295
2296                     if (error < best_error) {
2297                         best_error = error;
2298                         best_fps   = std_fps.num;
2299                     }
2300                 }
2301                 if (best_fps)
2302                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2303                               best_fps, 12 * 1001, INT_MAX);
2304             }
2305         } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2306             if (!st->codec->bits_per_coded_sample)
2307                 st->codec->bits_per_coded_sample =
2308                     av_get_bits_per_sample(st->codec->codec_id);
2309             // set stream disposition based on audio service type
2310             switch (st->codec->audio_service_type) {
2311             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2312                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
2313                 break;
2314             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2315                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
2316                 break;
2317             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2318                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
2319                 break;
2320             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2321                 st->disposition = AV_DISPOSITION_COMMENT;
2322                 break;
2323             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2324                 st->disposition = AV_DISPOSITION_KARAOKE;
2325                 break;
2326             }
2327         }
2328     }
2329
2330     estimate_timings(ic, old_offset);
2331
2332     compute_chapters_end(ic);
2333
2334 find_stream_info_err:
2335     for (i = 0; i < ic->nb_streams; i++) {
2336         ic->streams[i]->codec->thread_count = 0;
2337         av_freep(&ic->streams[i]->info);
2338     }
2339     return ret;
2340 }
2341
2342 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2343 {
2344     int i, j;
2345
2346     for (i = 0; i < ic->nb_programs; i++)
2347         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2348             if (ic->programs[i]->stream_index[j] == s)
2349                 return ic->programs[i];
2350     return NULL;
2351 }
2352
2353 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
2354                         int wanted_stream_nb, int related_stream,
2355                         AVCodec **decoder_ret, int flags)
2356 {
2357     int i, nb_streams = ic->nb_streams;
2358     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2359     unsigned *program = NULL;
2360     AVCodec *decoder = NULL, *best_decoder = NULL;
2361
2362     if (related_stream >= 0 && wanted_stream_nb < 0) {
2363         AVProgram *p = find_program_from_stream(ic, related_stream);
2364         if (p) {
2365             program    = p->stream_index;
2366             nb_streams = p->nb_stream_indexes;
2367         }
2368     }
2369     for (i = 0; i < nb_streams; i++) {
2370         int real_stream_index = program ? program[i] : i;
2371         AVStream *st          = ic->streams[real_stream_index];
2372         AVCodecContext *avctx = st->codec;
2373         if (avctx->codec_type != type)
2374             continue;
2375         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2376             continue;
2377         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
2378                                AV_DISPOSITION_VISUAL_IMPAIRED))
2379             continue;
2380         if (decoder_ret) {
2381             decoder = avcodec_find_decoder(st->codec->codec_id);
2382             if (!decoder) {
2383                 if (ret < 0)
2384                     ret = AVERROR_DECODER_NOT_FOUND;
2385                 continue;
2386             }
2387         }
2388         if (best_count >= st->codec_info_nb_frames)
2389             continue;
2390         best_count   = st->codec_info_nb_frames;
2391         ret          = real_stream_index;
2392         best_decoder = decoder;
2393         if (program && i == nb_streams - 1 && ret < 0) {
2394             program    = NULL;
2395             nb_streams = ic->nb_streams;
2396             /* no related stream found, try again with everything */
2397             i = 0;
2398         }
2399     }
2400     if (decoder_ret)
2401         *decoder_ret = best_decoder;
2402     return ret;
2403 }
2404
2405 /*******************************************************/
2406
2407 int av_read_play(AVFormatContext *s)
2408 {
2409     if (s->iformat->read_play)
2410         return s->iformat->read_play(s);
2411     if (s->pb)
2412         return avio_pause(s->pb, 0);
2413     return AVERROR(ENOSYS);
2414 }
2415
2416 int av_read_pause(AVFormatContext *s)
2417 {
2418     if (s->iformat->read_pause)
2419         return s->iformat->read_pause(s);
2420     if (s->pb)
2421         return avio_pause(s->pb, 1);
2422     return AVERROR(ENOSYS);
2423 }
2424
2425 void avformat_free_context(AVFormatContext *s)
2426 {
2427     int i, j;
2428     AVStream *st;
2429
2430     av_opt_free(s);
2431     if (s->iformat && s->iformat->priv_class && s->priv_data)
2432         av_opt_free(s->priv_data);
2433
2434     for (i = 0; i < s->nb_streams; i++) {
2435         /* free all data in a stream component */
2436         st = s->streams[i];
2437
2438         for (j = 0; j < st->nb_side_data; j++)
2439             av_freep(&st->side_data[j].data);
2440         av_freep(&st->side_data);
2441         st->nb_side_data = 0;
2442
2443         if (st->parser) {
2444             av_parser_close(st->parser);
2445         }
2446         if (st->attached_pic.data)
2447             av_free_packet(&st->attached_pic);
2448         av_dict_free(&st->metadata);
2449         av_freep(&st->probe_data.buf);
2450         av_free(st->index_entries);
2451         av_free(st->codec->extradata);
2452         av_free(st->codec->subtitle_header);
2453         av_free(st->codec);
2454         av_free(st->priv_data);
2455         av_free(st->info);
2456         av_free(st);
2457     }
2458     for (i = s->nb_programs - 1; i >= 0; i--) {
2459         av_dict_free(&s->programs[i]->metadata);
2460         av_freep(&s->programs[i]->stream_index);
2461         av_freep(&s->programs[i]);
2462     }
2463     av_freep(&s->programs);
2464     av_freep(&s->priv_data);
2465     while (s->nb_chapters--) {
2466         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2467         av_free(s->chapters[s->nb_chapters]);
2468     }
2469     av_freep(&s->chapters);
2470     av_dict_free(&s->metadata);
2471     av_freep(&s->streams);
2472     av_freep(&s->internal);
2473     av_free(s);
2474 }
2475
2476 void avformat_close_input(AVFormatContext **ps)
2477 {
2478     AVFormatContext *s = *ps;
2479     AVIOContext *pb    = s->pb;
2480
2481     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
2482         (s->flags & AVFMT_FLAG_CUSTOM_IO))
2483         pb = NULL;
2484
2485     flush_packet_queue(s);
2486
2487     if (s->iformat)
2488         if (s->iformat->read_close)
2489             s->iformat->read_close(s);
2490
2491     avformat_free_context(s);
2492
2493     *ps = NULL;
2494
2495     avio_close(pb);
2496 }
2497
2498 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
2499 {
2500     AVStream *st;
2501     int i;
2502
2503     if (av_reallocp_array(&s->streams, s->nb_streams + 1,
2504                           sizeof(*s->streams)) < 0) {
2505         s->nb_streams = 0;
2506         return NULL;
2507     }
2508
2509     st = av_mallocz(sizeof(AVStream));
2510     if (!st)
2511         return NULL;
2512     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2513         av_free(st);
2514         return NULL;
2515     }
2516
2517     st->codec = avcodec_alloc_context3(c);
2518     if (s->iformat) {
2519         /* no default bitrate if decoding */
2520         st->codec->bit_rate = 0;
2521
2522         /* default pts setting is MPEG-like */
2523         avpriv_set_pts_info(st, 33, 1, 90000);
2524     }
2525
2526     st->index      = s->nb_streams;
2527     st->start_time = AV_NOPTS_VALUE;
2528     st->duration   = AV_NOPTS_VALUE;
2529     /* we set the current DTS to 0 so that formats without any timestamps
2530      * but durations get some timestamps, formats with some unknown
2531      * timestamps have their first few packets buffered and the
2532      * timestamps corrected before they are returned to the user */
2533     st->cur_dts       = 0;
2534     st->first_dts     = AV_NOPTS_VALUE;
2535     st->probe_packets = MAX_PROBE_PACKETS;
2536
2537     st->last_IP_pts = AV_NOPTS_VALUE;
2538     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
2539         st->pts_buffer[i] = AV_NOPTS_VALUE;
2540
2541     st->sample_aspect_ratio = (AVRational) { 0, 1 };
2542
2543     st->info->fps_first_dts = AV_NOPTS_VALUE;
2544     st->info->fps_last_dts  = AV_NOPTS_VALUE;
2545
2546     s->streams[s->nb_streams++] = st;
2547     return st;
2548 }
2549
2550 AVProgram *av_new_program(AVFormatContext *ac, int id)
2551 {
2552     AVProgram *program = NULL;
2553     int i;
2554
2555     av_dlog(ac, "new_program: id=0x%04x\n", id);
2556
2557     for (i = 0; i < ac->nb_programs; i++)
2558         if (ac->programs[i]->id == id)
2559             program = ac->programs[i];
2560
2561     if (!program) {
2562         program = av_mallocz(sizeof(AVProgram));
2563         if (!program)
2564             return NULL;
2565         dynarray_add(&ac->programs, &ac->nb_programs, program);
2566         program->discard = AVDISCARD_NONE;
2567     }
2568     program->id = id;
2569
2570     return program;
2571 }
2572
2573 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
2574                               int64_t start, int64_t end, const char *title)
2575 {
2576     AVChapter *chapter = NULL;
2577     int i;
2578
2579     for (i = 0; i < s->nb_chapters; i++)
2580         if (s->chapters[i]->id == id)
2581             chapter = s->chapters[i];
2582
2583     if (!chapter) {
2584         chapter = av_mallocz(sizeof(AVChapter));
2585         if (!chapter)
2586             return NULL;
2587         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2588     }
2589     av_dict_set(&chapter->metadata, "title", title, 0);
2590     chapter->id        = id;
2591     chapter->time_base = time_base;
2592     chapter->start     = start;
2593     chapter->end       = end;
2594
2595     return chapter;
2596 }
2597
2598 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
2599 {
2600     int i, j;
2601     AVProgram *program = NULL;
2602
2603     if (idx >= ac->nb_streams) {
2604         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2605         return;
2606     }
2607
2608     for (i = 0; i < ac->nb_programs; i++) {
2609         if (ac->programs[i]->id != progid)
2610             continue;
2611         program = ac->programs[i];
2612         for (j = 0; j < program->nb_stream_indexes; j++)
2613             if (program->stream_index[j] == idx)
2614                 return;
2615
2616         if (av_reallocp_array(&program->stream_index,
2617                               program->nb_stream_indexes + 1,
2618                               sizeof(*program->stream_index)) < 0) {
2619             program->nb_stream_indexes = 0;
2620             return;
2621         }
2622         program->stream_index[program->nb_stream_indexes++] = idx;
2623         return;
2624     }
2625 }
2626
2627 uint64_t ff_ntp_time(void)
2628 {
2629     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
2630 }
2631
2632 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
2633 {
2634     const char *p;
2635     char *q, buf1[20], c;
2636     int nd, len, percentd_found;
2637
2638     q = buf;
2639     p = path;
2640     percentd_found = 0;
2641     for (;;) {
2642         c = *p++;
2643         if (c == '\0')
2644             break;
2645         if (c == '%') {
2646             do {
2647                 nd = 0;
2648                 while (av_isdigit(*p))
2649                     nd = nd * 10 + *p++ - '0';
2650                 c = *p++;
2651             } while (av_isdigit(c));
2652
2653             switch (c) {
2654             case '%':
2655                 goto addchar;
2656             case 'd':
2657                 if (percentd_found)
2658                     goto fail;
2659                 percentd_found = 1;
2660                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2661                 len = strlen(buf1);
2662                 if ((q - buf + len) > buf_size - 1)
2663                     goto fail;
2664                 memcpy(q, buf1, len);
2665                 q += len;
2666                 break;
2667             default:
2668                 goto fail;
2669             }
2670         } else {
2671 addchar:
2672             if ((q - buf) < buf_size - 1)
2673                 *q++ = c;
2674         }
2675     }
2676     if (!percentd_found)
2677         goto fail;
2678     *q = '\0';
2679     return 0;
2680 fail:
2681     *q = '\0';
2682     return -1;
2683 }
2684
2685 void av_url_split(char *proto, int proto_size,
2686                   char *authorization, int authorization_size,
2687                   char *hostname, int hostname_size,
2688                   int *port_ptr, char *path, int path_size, const char *url)
2689 {
2690     const char *p, *ls, *at, *col, *brk;
2691
2692     if (port_ptr)
2693         *port_ptr = -1;
2694     if (proto_size > 0)
2695         proto[0] = 0;
2696     if (authorization_size > 0)
2697         authorization[0] = 0;
2698     if (hostname_size > 0)
2699         hostname[0] = 0;
2700     if (path_size > 0)
2701         path[0] = 0;
2702
2703     /* parse protocol */
2704     if ((p = strchr(url, ':'))) {
2705         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
2706         p++; /* skip ':' */
2707         if (*p == '/')
2708             p++;
2709         if (*p == '/')
2710             p++;
2711     } else {
2712         /* no protocol means plain filename */
2713         av_strlcpy(path, url, path_size);
2714         return;
2715     }
2716
2717     /* separate path from hostname */
2718     ls = strchr(p, '/');
2719     if (!ls)
2720         ls = strchr(p, '?');
2721     if (ls)
2722         av_strlcpy(path, ls, path_size);
2723     else
2724         ls = &p[strlen(p)];  // XXX
2725
2726     /* the rest is hostname, use that to parse auth/port */
2727     if (ls != p) {
2728         /* authorization (user[:pass]@hostname) */
2729         if ((at = strchr(p, '@')) && at < ls) {
2730             av_strlcpy(authorization, p,
2731                        FFMIN(authorization_size, at + 1 - p));
2732             p = at + 1; /* skip '@' */
2733         }
2734
2735         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
2736             /* [host]:port */
2737             av_strlcpy(hostname, p + 1,
2738                        FFMIN(hostname_size, brk - p));
2739             if (brk[1] == ':' && port_ptr)
2740                 *port_ptr = atoi(brk + 2);
2741         } else if ((col = strchr(p, ':')) && col < ls) {
2742             av_strlcpy(hostname, p,
2743                        FFMIN(col + 1 - p, hostname_size));
2744             if (port_ptr)
2745                 *port_ptr = atoi(col + 1);
2746         } else
2747             av_strlcpy(hostname, p,
2748                        FFMIN(ls + 1 - p, hostname_size));
2749     }
2750 }
2751
2752 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
2753 {
2754     int i;
2755     static const char hex_table_uc[16] = { '0', '1', '2', '3',
2756                                            '4', '5', '6', '7',
2757                                            '8', '9', 'A', 'B',
2758                                            'C', 'D', 'E', 'F' };
2759     static const char hex_table_lc[16] = { '0', '1', '2', '3',
2760                                            '4', '5', '6', '7',
2761                                            '8', '9', 'a', 'b',
2762                                            'c', 'd', 'e', 'f' };
2763     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
2764
2765     for (i = 0; i < s; i++) {
2766         buff[i * 2]     = hex_table[src[i] >> 4];
2767         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
2768     }
2769
2770     return buff;
2771 }
2772
2773 int ff_hex_to_data(uint8_t *data, const char *p)
2774 {
2775     int c, len, v;
2776
2777     len = 0;
2778     v   = 1;
2779     for (;;) {
2780         p += strspn(p, SPACE_CHARS);
2781         if (*p == '\0')
2782             break;
2783         c = av_toupper((unsigned char) *p++);
2784         if (c >= '0' && c <= '9')
2785             c = c - '0';
2786         else if (c >= 'A' && c <= 'F')
2787             c = c - 'A' + 10;
2788         else
2789             break;
2790         v = (v << 4) | c;
2791         if (v & 0x100) {
2792             if (data)
2793                 data[len] = v;
2794             len++;
2795             v = 1;
2796         }
2797     }
2798     return len;
2799 }
2800
2801 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
2802                          unsigned int pts_num, unsigned int pts_den)
2803 {
2804     AVRational new_tb;
2805     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
2806         if (new_tb.num != pts_num)
2807             av_log(NULL, AV_LOG_DEBUG,
2808                    "st:%d removing common factor %d from timebase\n",
2809                    s->index, pts_num / new_tb.num);
2810     } else
2811         av_log(NULL, AV_LOG_WARNING,
2812                "st:%d has too large timebase, reducing\n", s->index);
2813
2814     if (new_tb.num <= 0 || new_tb.den <= 0) {
2815         av_log(NULL, AV_LOG_ERROR,
2816                "Ignoring attempt to set invalid timebase for st:%d\n",
2817                s->index);
2818         return;
2819     }
2820     s->time_base     = new_tb;
2821     s->pts_wrap_bits = pts_wrap_bits;
2822 }
2823
2824 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
2825                         void *context)
2826 {
2827     const char *ptr = str;
2828
2829     /* Parse key=value pairs. */
2830     for (;;) {
2831         const char *key;
2832         char *dest = NULL, *dest_end;
2833         int key_len, dest_len = 0;
2834
2835         /* Skip whitespace and potential commas. */
2836         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
2837             ptr++;
2838         if (!*ptr)
2839             break;
2840
2841         key = ptr;
2842
2843         if (!(ptr = strchr(key, '=')))
2844             break;
2845         ptr++;
2846         key_len = ptr - key;
2847
2848         callback_get_buf(context, key, key_len, &dest, &dest_len);
2849         dest_end = dest + dest_len - 1;
2850
2851         if (*ptr == '\"') {
2852             ptr++;
2853             while (*ptr && *ptr != '\"') {
2854                 if (*ptr == '\\') {
2855                     if (!ptr[1])
2856                         break;
2857                     if (dest && dest < dest_end)
2858                         *dest++ = ptr[1];
2859                     ptr += 2;
2860                 } else {
2861                     if (dest && dest < dest_end)
2862                         *dest++ = *ptr;
2863                     ptr++;
2864                 }
2865             }
2866             if (*ptr == '\"')
2867                 ptr++;
2868         } else {
2869             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
2870                 if (dest && dest < dest_end)
2871                     *dest++ = *ptr;
2872         }
2873         if (dest)
2874             *dest = 0;
2875     }
2876 }
2877
2878 int ff_find_stream_index(AVFormatContext *s, int id)
2879 {
2880     int i;
2881     for (i = 0; i < s->nb_streams; i++)
2882         if (s->streams[i]->id == id)
2883             return i;
2884     return -1;
2885 }
2886
2887 int64_t ff_iso8601_to_unix_time(const char *datestr)
2888 {
2889 #if HAVE_STRPTIME
2890     struct tm time1 = { 0 }, time2 = { 0 };
2891     char *ret1, *ret2;
2892     ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
2893     ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
2894     if (ret2 && !ret1)
2895         return av_timegm(&time2);
2896     else
2897         return av_timegm(&time1);
2898 #else
2899     av_log(NULL, AV_LOG_WARNING,
2900            "strptime() unavailable on this system, cannot convert "
2901            "the date string.\n");
2902     return 0;
2903 #endif
2904 }
2905
2906 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
2907                          int std_compliance)
2908 {
2909     if (ofmt) {
2910         if (ofmt->query_codec)
2911             return ofmt->query_codec(codec_id, std_compliance);
2912         else if (ofmt->codec_tag)
2913             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
2914         else if (codec_id == ofmt->video_codec ||
2915                  codec_id == ofmt->audio_codec ||
2916                  codec_id == ofmt->subtitle_codec)
2917             return 1;
2918     }
2919     return AVERROR_PATCHWELCOME;
2920 }
2921
2922 int avformat_network_init(void)
2923 {
2924 #if CONFIG_NETWORK
2925     int ret;
2926     ff_network_inited_globally = 1;
2927     if ((ret = ff_network_init()) < 0)
2928         return ret;
2929     ff_tls_init();
2930 #endif
2931     return 0;
2932 }
2933
2934 int avformat_network_deinit(void)
2935 {
2936 #if CONFIG_NETWORK
2937     ff_network_close();
2938     ff_tls_deinit();
2939 #endif
2940     return 0;
2941 }
2942
2943 int ff_add_param_change(AVPacket *pkt, int32_t channels,
2944                         uint64_t channel_layout, int32_t sample_rate,
2945                         int32_t width, int32_t height)
2946 {
2947     uint32_t flags = 0;
2948     int size = 4;
2949     uint8_t *data;
2950     if (!pkt)
2951         return AVERROR(EINVAL);
2952     if (channels) {
2953         size  += 4;
2954         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
2955     }
2956     if (channel_layout) {
2957         size  += 8;
2958         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
2959     }
2960     if (sample_rate) {
2961         size  += 4;
2962         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
2963     }
2964     if (width || height) {
2965         size  += 8;
2966         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
2967     }
2968     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
2969     if (!data)
2970         return AVERROR(ENOMEM);
2971     bytestream_put_le32(&data, flags);
2972     if (channels)
2973         bytestream_put_le32(&data, channels);
2974     if (channel_layout)
2975         bytestream_put_le64(&data, channel_layout);
2976     if (sample_rate)
2977         bytestream_put_le32(&data, sample_rate);
2978     if (width || height) {
2979         bytestream_put_le32(&data, width);
2980         bytestream_put_le32(&data, height);
2981     }
2982     return 0;
2983 }
2984
2985 int ff_generate_avci_extradata(AVStream *st)
2986 {
2987     static const uint8_t avci100_1080p_extradata[] = {
2988         // SPS
2989         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
2990         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
2991         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
2992         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
2993         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
2994         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
2995         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
2996         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
2997         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2998         // PPS
2999         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
3000         0xd0
3001     };
3002     static const uint8_t avci100_1080i_extradata[] = {
3003         // SPS
3004         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
3005         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
3006         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
3007         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
3008         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
3009         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
3010         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
3011         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
3012         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
3013         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
3014         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
3015         // PPS
3016         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
3017         0xd0
3018     };
3019     static const uint8_t avci50_1080i_extradata[] = {
3020         // SPS
3021         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
3022         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
3023         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
3024         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
3025         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
3026         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
3027         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
3028         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
3029         0x81, 0x13, 0xf7, 0xff, 0x80, 0x01, 0x80, 0x02,
3030         0x71, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
3031         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
3032         // PPS
3033         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
3034         0x11
3035     };
3036     static const uint8_t avci100_720p_extradata[] = {
3037         // SPS
3038         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
3039         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
3040         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
3041         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
3042         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
3043         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
3044         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
3045         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
3046         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
3047         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
3048         // PPS
3049         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
3050         0x11
3051     };
3052
3053     const uint8_t *data = NULL;
3054     int size            = 0;
3055
3056     if (st->codec->width == 1920) {
3057         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
3058             data = avci100_1080p_extradata;
3059             size = sizeof(avci100_1080p_extradata);
3060         } else {
3061             data = avci100_1080i_extradata;
3062             size = sizeof(avci100_1080i_extradata);
3063         }
3064     } else if (st->codec->width == 1440) {
3065         data = avci50_1080i_extradata;
3066         size = sizeof(avci50_1080i_extradata);
3067     } else if (st->codec->width == 1280) {
3068         data = avci100_720p_extradata;
3069         size = sizeof(avci100_720p_extradata);
3070     }
3071
3072     if (!size)
3073         return 0;
3074
3075     av_freep(&st->codec->extradata);
3076     st->codec->extradata_size = 0;
3077     st->codec->extradata      = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
3078     if (!st->codec->extradata)
3079         return AVERROR(ENOMEM);
3080
3081     memcpy(st->codec->extradata, data, size);
3082     st->codec->extradata_size = size;
3083
3084     return 0;
3085 }
3086
3087 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
3088                                  int *size)
3089 {
3090     int i;
3091
3092     for (i = 0; i < st->nb_side_data; i++) {
3093         if (st->side_data[i].type == type) {
3094             if (size)
3095                 *size = st->side_data[i].size;
3096             return st->side_data[i].data;
3097         }
3098     }
3099     return NULL;
3100 }