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