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