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