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