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