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