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