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